From eda8c544cdefd5b29d2ba297779deaefeef5784d Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@blockstack.com>
Date: Sat, 6 May 2023 15:40:03 -0500
Subject: [PATCH 0001/1166] add replay-block stacks-inspect method

---
 src/chainstate/stacks/db/blocks.rs |  10 +-
 src/main.rs                        | 154 +++++++++++++++++++++++++++++
 2 files changed, 159 insertions(+), 5 deletions(-)

diff --git a/src/chainstate/stacks/db/blocks.rs b/src/chainstate/stacks/db/blocks.rs
index 440029166f..2510ac8157 100644
--- a/src/chainstate/stacks/db/blocks.rs
+++ b/src/chainstate/stacks/db/blocks.rs
@@ -5941,7 +5941,7 @@ impl StacksChainState {
     /// necessary so that the Headers database and Clarity database's
     /// transactions can commit very close to one another, after the
     /// event observer has emitted.
-    fn append_block<'a>(
+    pub fn append_block<'a>(
         chainstate_tx: &mut ChainstateTx,
         clarity_instance: &'a mut ClarityInstance,
         burn_dbconn: &mut SortitionHandleTx,
@@ -6371,7 +6371,7 @@ impl StacksChainState {
     /// Verify that a Stacks anchored block attaches to its parent anchored block.
     /// * checks .header.total_work.work
     /// * checks .header.parent_block
-    fn check_block_attachment(
+    pub fn check_block_attachment(
         parent_block_header: &StacksBlockHeader,
         block_header: &StacksBlockHeader,
     ) -> bool {
@@ -6398,7 +6398,7 @@ impl StacksChainState {
     /// The header info will be pulled from the headers DB, so this method only succeeds if the
     /// parent block has been processed.
     /// If it's not known, return None.
-    fn get_parent_header_info(
+    pub fn get_parent_header_info(
         chainstate_tx: &mut ChainstateTx,
         next_staging_block: &StagingBlock,
     ) -> Result<Option<StacksHeaderInfo>, Error> {
@@ -6440,7 +6440,7 @@ impl StacksChainState {
     }
 
     /// Extract and parse the block from a loaded staging block, and verify its integrity.
-    fn extract_stacks_block(next_staging_block: &StagingBlock) -> Result<StacksBlock, Error> {
+    pub fn extract_stacks_block(next_staging_block: &StagingBlock) -> Result<StacksBlock, Error> {
         let block = {
             StacksBlock::consensus_deserialize(&mut &next_staging_block.block_data[..])
                 .map_err(Error::CodecError)?
@@ -6462,7 +6462,7 @@ impl StacksChainState {
     /// header info), determine which branch connects to the given block.  If there are multiple
     /// branches, punish the parent.  Return the portion of the branch that actually connects to
     /// the given block.
-    fn extract_connecting_microblocks(
+    pub fn extract_connecting_microblocks(
         parent_block_header_info: &StacksHeaderInfo,
         next_staging_block: &StagingBlock,
         block: &StacksBlock,
diff --git a/src/main.rs b/src/main.rs
index fcf8abb7e2..373e8d57cb 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1005,6 +1005,160 @@ simulating a miner.
         return;
     }
 
+    if argv[1] == "replay-block" {
+        let index_block_hash = &argv[3];
+        let index_block_hash = StacksBlockId::from_hex(&index_block_hash).unwrap();
+        let chain_state_path = format!("{}/mainnet/chainstate/", &argv[2]);
+        let sort_db_path = format!("{}/mainnet/burnchain/sortition", &argv[2]);
+        let burn_db_path = format!("{}/mainnet/burnchain/burnchain.sqlite", &argv[2]);
+        let burnchain_blocks_db = BurnchainDB::open(&burn_db_path, false).unwrap();
+
+        let (mut chainstate, _) =
+            StacksChainState::open(true, CHAIN_ID_MAINNET, &chain_state_path, None).unwrap();
+
+        let mut sortdb =
+            SortitionDB::open(&sort_db_path, true, PoxConstants::mainnet_default()).unwrap();
+        let mut sort_tx = sortdb.tx_begin_at_tip();
+
+        let (mut chainstate_tx, clarity_instance) = chainstate
+            .chainstate_tx_begin()
+            .expect("Failed to start chainstate tx");
+        let next_staging_block =
+            StacksChainState::load_staging_block_info(&chainstate_tx.tx, &index_block_hash)
+                .expect("Failed to load staging block data")
+                .expect("No such index block hash in block database");
+        let next_microblocks =
+            StacksChainState::find_parent_microblock_stream(&chainstate_tx.tx, &next_staging_block)
+                .unwrap()
+                .unwrap();
+
+        let (burn_header_hash, burn_header_height, burn_header_timestamp, winning_block_txid) =
+            match SortitionDB::get_block_snapshot_consensus(
+                &sort_tx,
+                &next_staging_block.consensus_hash,
+            )
+            .unwrap()
+            {
+                Some(sn) => (
+                    sn.burn_header_hash,
+                    sn.block_height as u32,
+                    sn.burn_header_timestamp,
+                    sn.winning_block_txid,
+                ),
+                None => {
+                    // shouldn't happen
+                    panic!(
+                        "CORRUPTION: staging block {}/{} does not correspond to a burn block",
+                        &next_staging_block.consensus_hash, &next_staging_block.anchored_block_hash
+                    );
+                }
+            };
+
+        info!(
+            "Process block {}/{} = {} in burn block {}, parent microblock {}",
+            next_staging_block.consensus_hash,
+            next_staging_block.anchored_block_hash,
+            &index_block_hash,
+            &burn_header_hash,
+            &next_staging_block.parent_microblock_hash,
+        );
+
+        let parent_header_info =
+            match StacksChainState::get_parent_header_info(&mut chainstate_tx, &next_staging_block)
+                .unwrap()
+            {
+                Some(hinfo) => hinfo,
+                None => panic!("Failed to load parent head info for block"),
+            };
+
+        let block = StacksChainState::extract_stacks_block(&next_staging_block).unwrap();
+        let block_size = next_staging_block.block_data.len() as u64;
+
+        if !StacksChainState::check_block_attachment(
+            &parent_header_info.anchored_header,
+            &block.header,
+        ) {
+            let msg = format!(
+                "Invalid stacks block {}/{} -- does not attach to parent {}/{}",
+                &next_staging_block.consensus_hash,
+                block.block_hash(),
+                parent_header_info.anchored_header.block_hash(),
+                &parent_header_info.consensus_hash
+            );
+            warn!("{}", &msg);
+            process::exit(1);
+        }
+
+        // validation check -- validate parent microblocks and find the ones that connect the
+        // block's parent to this block.
+        let next_microblocks = StacksChainState::extract_connecting_microblocks(
+            &parent_header_info,
+            &next_staging_block,
+            &block,
+            next_microblocks,
+        )
+        .unwrap();
+        let (last_microblock_hash, last_microblock_seq) = match next_microblocks.len() {
+            0 => (EMPTY_MICROBLOCK_PARENT_HASH.clone(), 0),
+            _ => {
+                let l = next_microblocks.len();
+                (
+                    next_microblocks[l - 1].block_hash(),
+                    next_microblocks[l - 1].header.sequence,
+                )
+            }
+        };
+        assert_eq!(
+            next_staging_block.parent_microblock_hash,
+            last_microblock_hash
+        );
+        assert_eq!(
+            next_staging_block.parent_microblock_seq,
+            last_microblock_seq
+        );
+
+        // user supports were never activated
+        let user_supports = vec![];
+
+        let block_am = StacksChainState::find_stacks_tip_affirmation_map(
+            &burnchain_blocks_db,
+            sort_tx.tx(),
+            &next_staging_block.consensus_hash,
+            &next_staging_block.anchored_block_hash,
+        )
+        .unwrap();
+
+        let pox_constants = sort_tx.context.pox_constants.clone();
+
+        let epoch_receipt = match StacksChainState::append_block(
+            &mut chainstate_tx,
+            clarity_instance,
+            &mut sort_tx,
+            &pox_constants,
+            &parent_header_info,
+            &next_staging_block.consensus_hash,
+            &burn_header_hash,
+            burn_header_height,
+            burn_header_timestamp,
+            &block,
+            block_size,
+            &next_microblocks,
+            next_staging_block.commit_burn,
+            next_staging_block.sortition_burn,
+            &user_supports,
+            block_am.weight(),
+        ) {
+            Ok((receipt, _)) => {
+                info!("Block processed successfully!");
+                receipt
+            }
+            Err(e) => {
+                error!("Failed processing block"; "error" => ?e);
+                process::exit(1)
+            }
+        };
+    }
+
     if argv[1] == "replay-chainstate" {
         if argv.len() < 7 {
             eprintln!("Usage: {} OLD_CHAINSTATE_PATH OLD_SORTITION_DB_PATH OLD_BURNCHAIN_DB_PATH NEW_CHAINSTATE_PATH NEW_BURNCHAIN_DB_PATH", &argv[0]);

From 55a41203c00b2e1b31cadc96a58cf62d3ed0ab36 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Wed, 10 May 2023 10:12:02 -0500
Subject: [PATCH 0002/1166] working replay-block command

---
 src/chainstate/stacks/db/blocks.rs | 20 ++++++++++++++++++++
 src/main.rs                        | 25 ++++++++++++++++++++++---
 2 files changed, 42 insertions(+), 3 deletions(-)

diff --git a/src/chainstate/stacks/db/blocks.rs b/src/chainstate/stacks/db/blocks.rs
index 2510ac8157..c986f4bc1f 100644
--- a/src/chainstate/stacks/db/blocks.rs
+++ b/src/chainstate/stacks/db/blocks.rs
@@ -5958,6 +5958,7 @@ impl StacksChainState {
         burnchain_sortition_burn: u64,
         user_burns: &[StagingUserBurnSupport],
         affirmation_weight: u64,
+        do_not_advance: bool,
     ) -> Result<(StacksEpochReceipt, PreCommitClarityBlock<'a>), Error> {
         debug!(
             "Process block {:?} with {} transactions",
@@ -6323,6 +6324,24 @@ impl StacksChainState {
             .as_ref()
             .map(|(_, _, _, info)| info.clone());
 
+        if do_not_advance {
+            let epoch_receipt = StacksEpochReceipt {
+                header: StacksHeaderInfo::regtest_genesis(),
+                tx_receipts,
+                matured_rewards,
+                matured_rewards_info,
+                parent_microblocks_cost: microblock_execution_cost,
+                anchored_block_cost: block_execution_cost,
+                parent_burn_block_hash,
+                parent_burn_block_height,
+                parent_burn_block_timestamp,
+                evaluated_epoch,
+                epoch_transition: applied_epoch_transition,
+            };
+
+            return Ok((epoch_receipt, clarity_commit));
+        }
+
         let new_tip = StacksChainState::advance_tip(
             &mut chainstate_tx.tx,
             &parent_chain_tip.anchored_header,
@@ -6707,6 +6726,7 @@ impl StacksChainState {
             next_staging_block.sortition_burn,
             &user_supports,
             block_am.weight(),
+            false,
         ) {
             Ok(next_chain_tip_info) => next_chain_tip_info,
             Err(e) => {
diff --git a/src/main.rs b/src/main.rs
index 373e8d57cb..1abfd24b10 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1016,17 +1016,35 @@ simulating a miner.
         let (mut chainstate, _) =
             StacksChainState::open(true, CHAIN_ID_MAINNET, &chain_state_path, None).unwrap();
 
-        let mut sortdb =
-            SortitionDB::open(&sort_db_path, true, PoxConstants::mainnet_default()).unwrap();
+        let mut sortdb = SortitionDB::connect(
+            &sort_db_path,
+            BITCOIN_MAINNET_FIRST_BLOCK_HEIGHT,
+            &BurnchainHeaderHash::from_hex(BITCOIN_MAINNET_FIRST_BLOCK_HASH).unwrap(),
+            BITCOIN_MAINNET_FIRST_BLOCK_TIMESTAMP.into(),
+            STACKS_EPOCHS_MAINNET.as_ref(),
+            PoxConstants::mainnet_default(),
+            true,
+        )
+        .unwrap();
         let mut sort_tx = sortdb.tx_begin_at_tip();
 
+        let blocks_path = chainstate.blocks_path.clone();
         let (mut chainstate_tx, clarity_instance) = chainstate
             .chainstate_tx_begin()
             .expect("Failed to start chainstate tx");
-        let next_staging_block =
+        let mut next_staging_block =
             StacksChainState::load_staging_block_info(&chainstate_tx.tx, &index_block_hash)
                 .expect("Failed to load staging block data")
                 .expect("No such index block hash in block database");
+
+        next_staging_block.block_data = StacksChainState::load_block_bytes(
+            &blocks_path,
+            &next_staging_block.consensus_hash,
+            &next_staging_block.anchored_block_hash,
+        )
+        .unwrap()
+        .unwrap_or(vec![]);
+
         let next_microblocks =
             StacksChainState::find_parent_microblock_stream(&chainstate_tx.tx, &next_staging_block)
                 .unwrap()
@@ -1147,6 +1165,7 @@ simulating a miner.
             next_staging_block.sortition_burn,
             &user_supports,
             block_am.weight(),
+            true,
         ) {
             Ok((receipt, _)) => {
                 info!("Block processed successfully!");

From 8bb3863001ffdf695f079d8eadbca569d54f78f9 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Wed, 10 May 2023 16:26:19 -0500
Subject: [PATCH 0003/1166] allow replay-block to use a block prefix

---
 src/main.rs                   | 366 +++++++++++++++++++---------------
 stacks-common/src/util/log.rs |   2 +
 2 files changed, 204 insertions(+), 164 deletions(-)

diff --git a/src/main.rs b/src/main.rs
index 1abfd24b10..d7b09ccaff 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1006,176 +1006,43 @@ simulating a miner.
     }
 
     if argv[1] == "replay-block" {
-        let index_block_hash = &argv[3];
-        let index_block_hash = StacksBlockId::from_hex(&index_block_hash).unwrap();
-        let chain_state_path = format!("{}/mainnet/chainstate/", &argv[2]);
-        let sort_db_path = format!("{}/mainnet/burnchain/sortition", &argv[2]);
-        let burn_db_path = format!("{}/mainnet/burnchain/burnchain.sqlite", &argv[2]);
-        let burnchain_blocks_db = BurnchainDB::open(&burn_db_path, false).unwrap();
-
-        let (mut chainstate, _) =
-            StacksChainState::open(true, CHAIN_ID_MAINNET, &chain_state_path, None).unwrap();
-
-        let mut sortdb = SortitionDB::connect(
-            &sort_db_path,
-            BITCOIN_MAINNET_FIRST_BLOCK_HEIGHT,
-            &BurnchainHeaderHash::from_hex(BITCOIN_MAINNET_FIRST_BLOCK_HASH).unwrap(),
-            BITCOIN_MAINNET_FIRST_BLOCK_TIMESTAMP.into(),
-            STACKS_EPOCHS_MAINNET.as_ref(),
-            PoxConstants::mainnet_default(),
-            true,
-        )
-        .unwrap();
-        let mut sort_tx = sortdb.tx_begin_at_tip();
-
-        let blocks_path = chainstate.blocks_path.clone();
-        let (mut chainstate_tx, clarity_instance) = chainstate
-            .chainstate_tx_begin()
-            .expect("Failed to start chainstate tx");
-        let mut next_staging_block =
-            StacksChainState::load_staging_block_info(&chainstate_tx.tx, &index_block_hash)
-                .expect("Failed to load staging block data")
-                .expect("No such index block hash in block database");
-
-        next_staging_block.block_data = StacksChainState::load_block_bytes(
-            &blocks_path,
-            &next_staging_block.consensus_hash,
-            &next_staging_block.anchored_block_hash,
-        )
-        .unwrap()
-        .unwrap_or(vec![]);
-
-        let next_microblocks =
-            StacksChainState::find_parent_microblock_stream(&chainstate_tx.tx, &next_staging_block)
-                .unwrap()
-                .unwrap();
-
-        let (burn_header_hash, burn_header_height, burn_header_timestamp, winning_block_txid) =
-            match SortitionDB::get_block_snapshot_consensus(
-                &sort_tx,
-                &next_staging_block.consensus_hash,
-            )
-            .unwrap()
-            {
-                Some(sn) => (
-                    sn.burn_header_hash,
-                    sn.block_height as u32,
-                    sn.burn_header_timestamp,
-                    sn.winning_block_txid,
-                ),
-                None => {
-                    // shouldn't happen
-                    panic!(
-                        "CORRUPTION: staging block {}/{} does not correspond to a burn block",
-                        &next_staging_block.consensus_hash, &next_staging_block.anchored_block_hash
-                    );
-                }
-            };
-
-        info!(
-            "Process block {}/{} = {} in burn block {}, parent microblock {}",
-            next_staging_block.consensus_hash,
-            next_staging_block.anchored_block_hash,
-            &index_block_hash,
-            &burn_header_hash,
-            &next_staging_block.parent_microblock_hash,
-        );
-
-        let parent_header_info =
-            match StacksChainState::get_parent_header_info(&mut chainstate_tx, &next_staging_block)
-                .unwrap()
-            {
-                Some(hinfo) => hinfo,
-                None => panic!("Failed to load parent head info for block"),
-            };
-
-        let block = StacksChainState::extract_stacks_block(&next_staging_block).unwrap();
-        let block_size = next_staging_block.block_data.len() as u64;
-
-        if !StacksChainState::check_block_attachment(
-            &parent_header_info.anchored_header,
-            &block.header,
-        ) {
-            let msg = format!(
-                "Invalid stacks block {}/{} -- does not attach to parent {}/{}",
-                &next_staging_block.consensus_hash,
-                block.block_hash(),
-                parent_header_info.anchored_header.block_hash(),
-                &parent_header_info.consensus_hash
+        if argv.len() < 3 {
+            eprintln!(
+                "Usage: {} chainstate_path index-block-hash-prefix",
+                &argv[0]
             );
-            warn!("{}", &msg);
             process::exit(1);
         }
+        let stacks_path = &argv[2];
+        let index_block_hash_prefix = &argv[3];
+        let staging_blocks_db_path = format!("{}/mainnet/chainstate/vm/index.sqlite", stacks_path);
+        let conn =
+            Connection::open_with_flags(&staging_blocks_db_path, OpenFlags::SQLITE_OPEN_READ_ONLY)
+                .unwrap();
+        let mut stmt = conn
+            .prepare(&format!(
+                "SELECT index_block_hash FROM staging_blocks WHERE index_block_hash LIKE \"{}%\"",
+                index_block_hash_prefix
+            ))
+            .unwrap();
+        let mut hashes_set = stmt.query(rusqlite::NO_PARAMS).unwrap();
 
-        // validation check -- validate parent microblocks and find the ones that connect the
-        // block's parent to this block.
-        let next_microblocks = StacksChainState::extract_connecting_microblocks(
-            &parent_header_info,
-            &next_staging_block,
-            &block,
-            next_microblocks,
-        )
-        .unwrap();
-        let (last_microblock_hash, last_microblock_seq) = match next_microblocks.len() {
-            0 => (EMPTY_MICROBLOCK_PARENT_HASH.clone(), 0),
-            _ => {
-                let l = next_microblocks.len();
-                (
-                    next_microblocks[l - 1].block_hash(),
-                    next_microblocks[l - 1].header.sequence,
-                )
-            }
-        };
-        assert_eq!(
-            next_staging_block.parent_microblock_hash,
-            last_microblock_hash
-        );
-        assert_eq!(
-            next_staging_block.parent_microblock_seq,
-            last_microblock_seq
-        );
-
-        // user supports were never activated
-        let user_supports = vec![];
-
-        let block_am = StacksChainState::find_stacks_tip_affirmation_map(
-            &burnchain_blocks_db,
-            sort_tx.tx(),
-            &next_staging_block.consensus_hash,
-            &next_staging_block.anchored_block_hash,
-        )
-        .unwrap();
-
-        let pox_constants = sort_tx.context.pox_constants.clone();
+        let mut index_block_hashes: Vec<String> = vec![];
+        while let Ok(Some(row)) = hashes_set.next() {
+            index_block_hashes.push(row.get(0).unwrap());
+        }
 
-        let epoch_receipt = match StacksChainState::append_block(
-            &mut chainstate_tx,
-            clarity_instance,
-            &mut sort_tx,
-            &pox_constants,
-            &parent_header_info,
-            &next_staging_block.consensus_hash,
-            &burn_header_hash,
-            burn_header_height,
-            burn_header_timestamp,
-            &block,
-            block_size,
-            &next_microblocks,
-            next_staging_block.commit_burn,
-            next_staging_block.sortition_burn,
-            &user_supports,
-            block_am.weight(),
-            true,
-        ) {
-            Ok((receipt, _)) => {
-                info!("Block processed successfully!");
-                receipt
+        let total = index_block_hashes.len();
+        let mut i = 1;
+        println!("Will check {} blocks.", total);
+        for index_block_hash in index_block_hashes.iter() {
+            if i % 100 == 0 {
+                println!("Checked {}...", i);
             }
-            Err(e) => {
-                error!("Failed processing block"; "error" => ?e);
-                process::exit(1)
-            }
-        };
+            i += 1;
+            replay_block(stacks_path, index_block_hash);
+        }
+        process::exit(0);
     }
 
     if argv[1] == "replay-chainstate" {
@@ -1708,3 +1575,174 @@ simulating a miner.
 
     process::exit(0);
 }
+
+fn replay_block(stacks_path: &str, index_block_hash_hex: &str) {
+    let index_block_hash = StacksBlockId::from_hex(index_block_hash_hex).unwrap();
+    let chain_state_path = format!("{}/mainnet/chainstate/", stacks_path);
+    let sort_db_path = format!("{}/mainnet/burnchain/sortition", stacks_path);
+    let burn_db_path = format!("{}/mainnet/burnchain/burnchain.sqlite", stacks_path);
+    let burnchain_blocks_db = BurnchainDB::open(&burn_db_path, false).unwrap();
+
+    let (mut chainstate, _) =
+        StacksChainState::open(true, CHAIN_ID_MAINNET, &chain_state_path, None).unwrap();
+
+    let mut sortdb = SortitionDB::connect(
+        &sort_db_path,
+        BITCOIN_MAINNET_FIRST_BLOCK_HEIGHT,
+        &BurnchainHeaderHash::from_hex(BITCOIN_MAINNET_FIRST_BLOCK_HASH).unwrap(),
+        BITCOIN_MAINNET_FIRST_BLOCK_TIMESTAMP.into(),
+        STACKS_EPOCHS_MAINNET.as_ref(),
+        PoxConstants::mainnet_default(),
+        true,
+    )
+    .unwrap();
+    let mut sort_tx = sortdb.tx_begin_at_tip();
+
+    let blocks_path = chainstate.blocks_path.clone();
+    let (mut chainstate_tx, clarity_instance) = chainstate
+        .chainstate_tx_begin()
+        .expect("Failed to start chainstate tx");
+    let mut next_staging_block =
+        StacksChainState::load_staging_block_info(&chainstate_tx.tx, &index_block_hash)
+            .expect("Failed to load staging block data")
+            .expect("No such index block hash in block database");
+
+    next_staging_block.block_data = StacksChainState::load_block_bytes(
+        &blocks_path,
+        &next_staging_block.consensus_hash,
+        &next_staging_block.anchored_block_hash,
+    )
+    .unwrap()
+    .unwrap_or(vec![]);
+
+    let next_microblocks =
+        StacksChainState::find_parent_microblock_stream(&chainstate_tx.tx, &next_staging_block)
+            .unwrap()
+            .unwrap();
+
+    let (burn_header_hash, burn_header_height, burn_header_timestamp, _winning_block_txid) =
+        match SortitionDB::get_block_snapshot_consensus(
+            &sort_tx,
+            &next_staging_block.consensus_hash,
+        )
+        .unwrap()
+        {
+            Some(sn) => (
+                sn.burn_header_hash,
+                sn.block_height as u32,
+                sn.burn_header_timestamp,
+                sn.winning_block_txid,
+            ),
+            None => {
+                // shouldn't happen
+                panic!(
+                    "CORRUPTION: staging block {}/{} does not correspond to a burn block",
+                    &next_staging_block.consensus_hash, &next_staging_block.anchored_block_hash
+                );
+            }
+        };
+
+    info!(
+        "Process block {}/{} = {} in burn block {}, parent microblock {}",
+        next_staging_block.consensus_hash,
+        next_staging_block.anchored_block_hash,
+        &index_block_hash,
+        &burn_header_hash,
+        &next_staging_block.parent_microblock_hash,
+    );
+
+    let parent_header_info =
+        match StacksChainState::get_parent_header_info(&mut chainstate_tx, &next_staging_block)
+            .unwrap()
+        {
+            Some(hinfo) => hinfo,
+            None => panic!("Failed to load parent head info for block"),
+        };
+
+    let block = StacksChainState::extract_stacks_block(&next_staging_block).unwrap();
+    let block_size = next_staging_block.block_data.len() as u64;
+
+    if !StacksChainState::check_block_attachment(&parent_header_info.anchored_header, &block.header)
+    {
+        let msg = format!(
+            "Invalid stacks block {}/{} -- does not attach to parent {}/{}",
+            &next_staging_block.consensus_hash,
+            block.block_hash(),
+            parent_header_info.anchored_header.block_hash(),
+            &parent_header_info.consensus_hash
+        );
+        println!("{}", &msg);
+        return;
+    }
+
+    // validation check -- validate parent microblocks and find the ones that connect the
+    // block's parent to this block.
+    let next_microblocks = StacksChainState::extract_connecting_microblocks(
+        &parent_header_info,
+        &next_staging_block,
+        &block,
+        next_microblocks,
+    )
+    .unwrap();
+    let (last_microblock_hash, last_microblock_seq) = match next_microblocks.len() {
+        0 => (EMPTY_MICROBLOCK_PARENT_HASH.clone(), 0),
+        _ => {
+            let l = next_microblocks.len();
+            (
+                next_microblocks[l - 1].block_hash(),
+                next_microblocks[l - 1].header.sequence,
+            )
+        }
+    };
+    assert_eq!(
+        next_staging_block.parent_microblock_hash,
+        last_microblock_hash
+    );
+    assert_eq!(
+        next_staging_block.parent_microblock_seq,
+        last_microblock_seq
+    );
+
+    // user supports were never activated
+    let user_supports = vec![];
+
+    let block_am = StacksChainState::find_stacks_tip_affirmation_map(
+        &burnchain_blocks_db,
+        sort_tx.tx(),
+        &next_staging_block.consensus_hash,
+        &next_staging_block.anchored_block_hash,
+    )
+    .unwrap();
+
+    let pox_constants = sort_tx.context.pox_constants.clone();
+
+    let epoch_receipt = match StacksChainState::append_block(
+        &mut chainstate_tx,
+        clarity_instance,
+        &mut sort_tx,
+        &pox_constants,
+        &parent_header_info,
+        &next_staging_block.consensus_hash,
+        &burn_header_hash,
+        burn_header_height,
+        burn_header_timestamp,
+        &block,
+        block_size,
+        &next_microblocks,
+        next_staging_block.commit_burn,
+        next_staging_block.sortition_burn,
+        &user_supports,
+        block_am.weight(),
+        true,
+    ) {
+        Ok((_receipt, _)) => {
+            info!("Block processed successfully! block = {}", index_block_hash);
+        }
+        Err(e) => {
+            println!(
+                "Failed processing block! block = {}, error = {:?}",
+                index_block_hash, e
+            );
+        }
+    };
+}
diff --git a/stacks-common/src/util/log.rs b/stacks-common/src/util/log.rs
index 26de14e676..ef3ee7c0de 100644
--- a/stacks-common/src/util/log.rs
+++ b/stacks-common/src/util/log.rs
@@ -251,6 +251,8 @@ fn inner_get_loglevel() -> slog::Level {
         slog::Level::Debug
     } else if env::var("BLOCKSTACK_DEBUG") == Ok("1".into()) {
         slog::Level::Debug
+    } else if env::var("STACKS_LOG_CRITONLY") == Ok("1".into()) {
+        slog::Level::Critical
     } else {
         slog::Level::Info
     }

From 15639c5da3138833508ecb041e804a095eba5efd Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Fri, 12 May 2023 13:48:40 -0500
Subject: [PATCH 0004/1166] skip blocks without microblock data or parent
 header info

---
 src/main.rs | 25 ++++++++++++++++++++-----
 1 file changed, 20 insertions(+), 5 deletions(-)

diff --git a/src/main.rs b/src/main.rs
index d7b09ccaff..e0878d0993 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1042,6 +1042,7 @@ simulating a miner.
             i += 1;
             replay_block(stacks_path, index_block_hash);
         }
+        println!("Finished!");
         process::exit(0);
     }
 
@@ -1615,10 +1616,18 @@ fn replay_block(stacks_path: &str, index_block_hash_hex: &str) {
     .unwrap()
     .unwrap_or(vec![]);
 
-    let next_microblocks =
-        StacksChainState::find_parent_microblock_stream(&chainstate_tx.tx, &next_staging_block)
-            .unwrap()
-            .unwrap();
+    let next_microblocks = match StacksChainState::find_parent_microblock_stream(
+        &chainstate_tx.tx,
+        &next_staging_block,
+    )
+    .unwrap()
+    {
+        Some(x) => x,
+        None => {
+            println!("No microblock stream found for {}", index_block_hash_hex);
+            return;
+        }
+    };
 
     let (burn_header_hash, burn_header_height, burn_header_timestamp, _winning_block_txid) =
         match SortitionDB::get_block_snapshot_consensus(
@@ -1656,7 +1665,13 @@ fn replay_block(stacks_path: &str, index_block_hash_hex: &str) {
             .unwrap()
         {
             Some(hinfo) => hinfo,
-            None => panic!("Failed to load parent head info for block"),
+            None => {
+                println!(
+                    "Failed to load parent head info for block: {}",
+                    index_block_hash_hex
+                );
+                return;
+            }
         };
 
     let block = StacksChainState::extract_stacks_block(&next_staging_block).unwrap();

From 303082078bae9a5598569a1dc795e090e281b066 Mon Sep 17 00:00:00 2001
From: bestmike007 <i@bestmike007.com>
Date: Tue, 22 Aug 2023 03:42:39 +0000
Subject: [PATCH 0005/1166] chore: fix compiler warnings

Signed-off-by: bestmike007 <i@bestmike007.com>
---
 stacks-common/src/util/hash.rs                   | 2 +-
 stackslib/src/chainstate/stacks/index/storage.rs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/stacks-common/src/util/hash.rs b/stacks-common/src/util/hash.rs
index 9660210dc9..3f7c165518 100644
--- a/stacks-common/src/util/hash.rs
+++ b/stacks-common/src/util/hash.rs
@@ -429,7 +429,7 @@ where
             row_hashes.reserve(nodes[i].len() / 2);
 
             for j in 0..(nodes[i].len() / 2) {
-                let h = MerkleTree::get_node_hash(&nodes[i][(2 * j)], &nodes[i][2 * j + 1]);
+                let h = MerkleTree::get_node_hash(&nodes[i][2 * j], &nodes[i][2 * j + 1]);
                 row_hashes.push(h);
             }
 
diff --git a/stackslib/src/chainstate/stacks/index/storage.rs b/stackslib/src/chainstate/stacks/index/storage.rs
index 4bb57db524..21d1311f1f 100644
--- a/stackslib/src/chainstate/stacks/index/storage.rs
+++ b/stackslib/src/chainstate/stacks/index/storage.rs
@@ -875,7 +875,7 @@ impl<T: MarfTrieId> TrieRAM<T> {
         for j in 0..node_data.len() {
             let next_node = &mut self.data[node_data[j] as usize].0;
             if !next_node.is_leaf() {
-                let mut ptrs = next_node.ptrs_mut();
+                let ptrs = next_node.ptrs_mut();
                 let num_children = ptrs.len();
                 for k in 0..num_children {
                     if ptrs[k].id != TrieNodeID::Empty as u8 && !is_backptr(ptrs[k].id) {

From ef5a76be7c417103de5016b9e6e73ca8b4d236cd Mon Sep 17 00:00:00 2001
From: bestmike007 <i@bestmike007.com>
Date: Tue, 22 Aug 2023 04:52:15 +0000
Subject: [PATCH 0006/1166] chore: fix profile-sqlite

Signed-off-by: bestmike007 <i@bestmike007.com>
---
 stackslib/src/util_lib/db.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/stackslib/src/util_lib/db.rs b/stackslib/src/util_lib/db.rs
index 32e1f32714..431b74c82a 100644
--- a/stackslib/src/util_lib/db.rs
+++ b/stackslib/src/util_lib/db.rs
@@ -716,9 +716,12 @@ pub fn sqlite_open<P: AsRef<Path>>(
     flags: OpenFlags,
     foreign_keys: bool,
 ) -> Result<Connection, sqlite_error> {
-    let db = Connection::open_with_flags(path, flags)?;
+    #[cfg(feature = "profile-sqlite")]
+    let mut db = Connection::open_with_flags(path, flags)?;
     #[cfg(feature = "profile-sqlite")]
     db.profile(Some(trace_profile));
+    #[cfg(not(feature = "profile-sqlite"))]
+    let db = Connection::open_with_flags(path, flags)?;
     db.busy_handler(Some(tx_busy_handler))?;
     inner_sql_pragma(&db, "journal_mode", &"WAL")?;
     inner_sql_pragma(&db, "synchronous", &"NORMAL")?;

From ce15261e4fa70181714128351270ad7bf70da765 Mon Sep 17 00:00:00 2001
From: bestmike007 <i@bestmike007.com>
Date: Tue, 22 Aug 2023 15:18:19 +0000
Subject: [PATCH 0007/1166] chore: extract inner_connection_open

Signed-off-by: bestmike007 <i@bestmike007.com>
---
 stackslib/src/util_lib/db.rs | 25 +++++++++++++++++++------
 1 file changed, 19 insertions(+), 6 deletions(-)

diff --git a/stackslib/src/util_lib/db.rs b/stackslib/src/util_lib/db.rs
index 431b74c82a..dcf4f71f13 100644
--- a/stackslib/src/util_lib/db.rs
+++ b/stackslib/src/util_lib/db.rs
@@ -710,18 +710,31 @@ fn trace_profile(query: &str, duration: Duration) {
     );
 }
 
+#[cfg(feature = "profile-sqlite")]
+fn inner_connection_open<P: AsRef<Path>>(
+    path: P,
+    flags: OpenFlags,
+) -> Result<Connection, sqlite_error> {
+    let mut db = Connection::open_with_flags(path, flags)?;
+    db.profile(Some(trace_profile));
+    Ok(db)
+}
+
+#[cfg(not(feature = "profile-sqlite"))]
+fn inner_connection_open<P: AsRef<Path>>(
+    path: P,
+    flags: OpenFlags,
+) -> Result<Connection, sqlite_error> {
+    Connection::open_with_flags(path, flags)
+}
+
 /// Open a database connection and set some typically-used pragmas
 pub fn sqlite_open<P: AsRef<Path>>(
     path: P,
     flags: OpenFlags,
     foreign_keys: bool,
 ) -> Result<Connection, sqlite_error> {
-    #[cfg(feature = "profile-sqlite")]
-    let mut db = Connection::open_with_flags(path, flags)?;
-    #[cfg(feature = "profile-sqlite")]
-    db.profile(Some(trace_profile));
-    #[cfg(not(feature = "profile-sqlite"))]
-    let db = Connection::open_with_flags(path, flags)?;
+    let db = inner_connection_open(path, flags)?;
     db.busy_handler(Some(tx_busy_handler))?;
     inner_sql_pragma(&db, "journal_mode", &"WAL")?;
     inner_sql_pragma(&db, "synchronous", &"NORMAL")?;

From fe45e9157bbbbe690260b306039a1adae0e7a86d Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Fri, 1 Sep 2023 13:25:36 -0400
Subject: [PATCH 0008/1166] ci: Fix CI failing when we don't have DockerHub
 credentials

---
 .github/workflows/image-build-alpine-binary.yml | 5 ++++-
 .github/workflows/image-build-debian-binary.yml | 5 ++++-
 .github/workflows/image-build-debian-source.yml | 5 ++++-
 3 files changed, 12 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/image-build-alpine-binary.yml b/.github/workflows/image-build-alpine-binary.yml
index f5dc992380..75a9144d6d 100644
--- a/.github/workflows/image-build-alpine-binary.yml
+++ b/.github/workflows/image-build-alpine-binary.yml
@@ -39,6 +39,7 @@ jobs:
         run: |
           echo "GITHUB_SHA_SHORT=${GITHUB_SHA::7}" >> $GITHUB_ENV
           echo "GITHUB_REF_SHORT=${GITHUB_REF#refs/*/}" >> $GITHUB_ENV
+          echo "DOCKER_PUSH=${{ (secrets.DOCKERHUB_USERNAME != '') && (secrets.DOCKERHUB_PASSWORD != '') }}" >> $GITHUB_ENV
       - name: Set up QEMU
         id: docker_qemu
         uses: docker/setup-qemu-action@v2
@@ -62,6 +63,8 @@ jobs:
       - name: Login to DockerHub
         id: docker_login
         uses: docker/login-action@v2
+        # Only attempt login and push if we have credentials
+        if: env.DOCKER_PUSH == 'true'
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_PASSWORD }}
@@ -78,4 +81,4 @@ jobs:
             STACKS_NODE_VERSION=${{ inputs.tag || env.GITHUB_SHA_SHORT }}
             GIT_BRANCH=${{ env.GITHUB_REF_SHORT }}
             GIT_COMMIT=${{ env.GITHUB_SHA_SHORT }}
-          push: true
+          push: ${{ env.DOCKER_PUSH }}
diff --git a/.github/workflows/image-build-debian-binary.yml b/.github/workflows/image-build-debian-binary.yml
index e1584abbc1..052a2f87f5 100644
--- a/.github/workflows/image-build-debian-binary.yml
+++ b/.github/workflows/image-build-debian-binary.yml
@@ -49,6 +49,7 @@ jobs:
         run: |
           echo "GITHUB_SHA_SHORT=${GITHUB_SHA::7}" >> $GITHUB_ENV
           echo "GITHUB_REF_SHORT=${GITHUB_REF#refs/*/}" >> $GITHUB_ENV
+          echo "DOCKER_PUSH=${{ (secrets.DOCKERHUB_USERNAME != '') && (secrets.DOCKERHUB_PASSWORD != '') }}" >> $GITHUB_ENV
       - name: Set up QEMU
         id: docker_qemu
         uses: docker/setup-qemu-action@v2
@@ -73,6 +74,8 @@ jobs:
       - name: Login to DockerHub
         id: docker_login
         uses: docker/login-action@v2
+        # Only attempt login and push if we have credentials
+        if: env.DOCKER_PUSH == 'true'
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_PASSWORD }}
@@ -89,4 +92,4 @@ jobs:
             STACKS_NODE_VERSION=${{ inputs.tag || env.GITHUB_SHA_SHORT }}
             GIT_BRANCH=${{ env.GITHUB_REF_SHORT }}
             GIT_COMMIT=${{ env.GITHUB_SHA_SHORT }}
-          push: true
+          push: ${{ env.DOCKER_PUSH }}
diff --git a/.github/workflows/image-build-debian-source.yml b/.github/workflows/image-build-debian-source.yml
index d60166e26c..0ba8b2bfbe 100644
--- a/.github/workflows/image-build-debian-source.yml
+++ b/.github/workflows/image-build-debian-source.yml
@@ -46,6 +46,7 @@ jobs:
         run: |
           echo "GITHUB_SHA_SHORT=${GITHUB_SHA::7}" >> $GITHUB_ENV
           echo "GITHUB_REF_SHORT=${GITHUB_REF#refs/*/}" >> $GITHUB_ENV
+          echo "DOCKER_PUSH=${{ (secrets.DOCKERHUB_USERNAME != '') && (secrets.DOCKERHUB_PASSWORD != '') }}" >> $GITHUB_ENV
       - name: Set up QEMU
         id: docker_qemu
         uses: docker/setup-qemu-action@v2
@@ -72,6 +73,8 @@ jobs:
       - name: Login to DockerHub
         id: docker_login
         uses: docker/login-action@v2
+        # Only attempt login and push if we have credentials
+        if: env.DOCKER_PUSH == 'true'
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_PASSWORD }}
@@ -87,4 +90,4 @@ jobs:
             STACKS_NODE_VERSION=${{ env.GITHUB_SHA_SHORT }}
             GIT_BRANCH=${{ env.GITHUB_REF_SHORT }}
             GIT_COMMIT=${{ env.GITHUB_SHA_SHORT }}
-          push: true
+          push: ${{ env.DOCKER_PUSH }}

From 6134cc877d383465770a3f803d14996994452f35 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 20 Sep 2023 09:00:38 -0700
Subject: [PATCH 0009/1166] Add 'sudo apt-get update' to the build image step

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 .github/workflows/bitcoin-tests.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/workflows/bitcoin-tests.yml b/.github/workflows/bitcoin-tests.yml
index 66adcf4f94..0d5613ff56 100644
--- a/.github/workflows/bitcoin-tests.yml
+++ b/.github/workflows/bitcoin-tests.yml
@@ -31,6 +31,7 @@ jobs:
       - name: Reclaim disk space
         id: cleanup
         run: |
+          sudo apt-get update
           sudo apt-get remove -y '^dotnet-.*'
           sudo apt-get remove -y '^llvm-.*'
           sudo apt-get remove -y 'php.*'

From fec356804a90b1c36ad7ed6644cd06cbcafd4621 Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Thu, 21 Sep 2023 10:10:06 -0400
Subject: [PATCH 0010/1166] fix: lower warning about mempool nonce caching to
 `debug!`

This case happens often in normal execution, so it is just spamming the
logs as a `warn!`.
---
 src/core/mempool.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/core/mempool.rs b/src/core/mempool.rs
index 7f3c195d21..5efb762815 100644
--- a/src/core/mempool.rs
+++ b/src/core/mempool.rs
@@ -853,7 +853,7 @@ impl NonceCache {
                         let should_store_again = match db_set_nonce(mempool_db, address, nonce) {
                             Ok(_) => false,
                             Err(e) => {
-                                warn!("error caching nonce to sqlite: {}", e);
+                                debug!("error caching nonce to sqlite: {}", e);
                                 true
                             }
                         };

From 34703d7b63135987c296014bff7377b4115ff57f Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Mon, 10 Jul 2023 11:02:45 -0500
Subject: [PATCH 0011/1166] feat: ignore logging errors rather than panicking

---
 stacks-common/src/util/log.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/stacks-common/src/util/log.rs b/stacks-common/src/util/log.rs
index 26de14e676..73463cc45f 100644
--- a/stacks-common/src/util/log.rs
+++ b/stacks-common/src/util/log.rs
@@ -205,8 +205,8 @@ fn make_json_logger() -> Logger {
                       }),
     );
 
-    let drain = Mutex::new(slog_json::Json::default(std::io::stderr())).map(slog::Fuse);
-    let filtered_drain = slog::LevelFilter::new(drain, get_loglevel()).fuse();
+    let drain = Mutex::new(slog_json::Json::default(std::io::stderr()));
+    let filtered_drain = slog::LevelFilter::new(drain, get_loglevel()).ignore_res();
     slog::Logger::root(filtered_drain, def_keys)
 }
 
@@ -225,7 +225,7 @@ fn make_logger() -> Logger {
         let decorator = slog_term::PlainSyncDecorator::new(std::io::stderr());
         let atty = isatty(Stream::Stderr);
         let drain = TermFormat::new(decorator, pretty_print, debug, atty);
-        let logger = Logger::root(drain.fuse(), o!());
+        let logger = Logger::root(drain.ignore_res(), o!());
         logger
     }
 }
@@ -239,7 +239,7 @@ fn make_logger() -> Logger {
         let plain = slog_term::PlainSyncDecorator::new(slog_term::TestStdoutWriter);
         let isatty = isatty(Stream::Stdout);
         let drain = TermFormat::new(plain, false, debug, isatty);
-        let logger = Logger::root(drain.fuse(), o!());
+        let logger = Logger::root(drain.ignore_res(), o!());
         logger
     }
 }

From fb5e2f592fc56907752a0d12d3e9f8f69a57c9ba Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Wed, 20 Sep 2023 13:24:21 -0500
Subject: [PATCH 0012/1166] chore: add changelog entry for 3784 hotfix

---
 CHANGELOG.md | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 40ed706181..66f936c5e8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,11 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to the versioning scheme outlined in the [README.md](README.md).
 
+## [2.4.0.0.2]
+
+This is a hotfix that changes the logging failure behavior from panicking to dropping
+the log message (PR #3784).
+
 ## [2.4.0.0.1]
 
 This is a minor change to add `txid` fields into the log messages from failing

From 96872fb657b0292873a94ff3f3733e94911c705a Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 24 Oct 2023 17:50:21 -0400
Subject: [PATCH 0013/1166] fix: fix trait handler and cut release

---
 CHANGELOG.md          | 5 +++++
 clarity/src/vm/mod.rs | 7 ++++++-
 2 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 66f936c5e8..eb9a75b0aa 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,11 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to the versioning scheme outlined in the [README.md](README.md).
 
+## [2.4.0.0.3]
+
+This is a high-priority hotfix that addresses a bug in transaction processing which
+could impact miner availability.
+
 ## [2.4.0.0.2]
 
 This is a hotfix that changes the logging failure behavior from panicking to dropping
diff --git a/clarity/src/vm/mod.rs b/clarity/src/vm/mod.rs
index db54d5b245..9943f0038d 100644
--- a/clarity/src/vm/mod.rs
+++ b/clarity/src/vm/mod.rs
@@ -344,7 +344,12 @@ pub fn eval<'a>(
             let f = lookup_function(&function_name, env)?;
             apply(&f, &rest, env, context)
         }
-        TraitReference(_, _) | Field(_) => unreachable!("can't be evaluated"),
+        TraitReference(_, _) | Field(_) => {
+            return Err(InterpreterError::BadSymbolicRepresentation(
+                "Unexpected trait reference".into(),
+            )
+            .into())
+        }
     };
 
     if let Some(mut eval_hooks) = env.global_context.eval_hooks.take() {

From f7be9aff24642c33781813bbc402f0d2c5d27ea5 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Mon, 6 Nov 2023 12:59:45 -0600
Subject: [PATCH 0014/1166] fix: address issue in print eval

---
 CHANGELOG.md                    | 5 +++++
 clarity/src/vm/functions/mod.rs | 7 ++++++-
 2 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index eb9a75b0aa..812eb18c5e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,11 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to the versioning scheme outlined in the [README.md](README.md).
 
+## [2.4.0.0.4]
+
+This is a high-priority hotfix that addresses a bug in transaction processing which
+could impact miner availability.
+
 ## [2.4.0.0.3]
 
 This is a high-priority hotfix that addresses a bug in transaction processing which
diff --git a/clarity/src/vm/functions/mod.rs b/clarity/src/vm/functions/mod.rs
index 991e074ffe..da8cbde4d1 100644
--- a/clarity/src/vm/functions/mod.rs
+++ b/clarity/src/vm/functions/mod.rs
@@ -69,6 +69,8 @@ macro_rules! switch_on_global_epoch {
 
 use crate::vm::ClarityVersion;
 
+use super::errors::InterpreterError;
+
 mod arithmetic;
 mod assets;
 mod boolean;
@@ -606,7 +608,10 @@ fn special_print(
     env: &mut Environment,
     context: &LocalContext,
 ) -> Result<Value> {
-    let input = eval(&args[0], env, context)?;
+    let arg = args.get(0).ok_or_else(|| {
+        InterpreterError::BadSymbolicRepresentation("Print should have an argument".into())
+    })?;
+    let input = eval(arg, env, context)?;
 
     runtime_cost(ClarityCostFunction::Print, env, input.size())?;
 

From 2547ddce4c27622c0d924d3a995b7c4531e625b0 Mon Sep 17 00:00:00 2001
From: wileyj <2847772+wileyj@users.noreply.github.com>
Date: Tue, 7 Nov 2023 08:55:22 -0800
Subject: [PATCH 0015/1166] remove missing packags from ci

---
 .github/workflows/bitcoin-tests.yml | 1 -
 1 file changed, 1 deletion(-)

diff --git a/.github/workflows/bitcoin-tests.yml b/.github/workflows/bitcoin-tests.yml
index 0d5613ff56..9aba4e6250 100644
--- a/.github/workflows/bitcoin-tests.yml
+++ b/.github/workflows/bitcoin-tests.yml
@@ -37,7 +37,6 @@ jobs:
           sudo apt-get remove -y 'php.*'
           sudo apt-get remove -y '^mongodb-.*'
           sudo apt-get remove -y '^mysql-.*'
-          sudo apt-get remove -y azure-cli google-cloud-sdk google-chrome-stable firefox powershell mono-devel libgl1-mesa-dri
           sudo apt-get autoremove -y
           sudo apt-get clean
           docker system prune --force

From 4354a9d5fd25d4f0168d41d4227b739b9b339189 Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Thu, 9 Nov 2023 10:58:06 -0500
Subject: [PATCH 0016/1166] docs: fix invalid example in docs

---
 clarity/src/vm/docs/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/clarity/src/vm/docs/mod.rs b/clarity/src/vm/docs/mod.rs
index 9a019dbbc9..8a432481ef 100644
--- a/clarity/src/vm/docs/mod.rs
+++ b/clarity/src/vm/docs/mod.rs
@@ -1417,7 +1417,7 @@ The function returns the result of evaluating `expr`.
     example: "
 (define-data-var data int 1)
 (at-block 0x0000000000000000000000000000000000000000000000000000000000000000 block-height) ;; Returns u0
-(at-block (get-block-info? id-header-hash 0) (var-get data)) ;; Throws NoSuchDataVariable because `data` wasn't initialized at block height 0"
+(at-block (unwrap-panic (get-block-info? id-header-hash u0)) (var-get data)) ;; Throws NoSuchDataVariable because `data` wasn't initialized at block height 0"
 };
 
 const AS_CONTRACT_API: SpecialAPI = SpecialAPI {

From 049db7ec56b80812e9a40a051b0911a7cc2c308b Mon Sep 17 00:00:00 2001
From: wileyj <2847772+wileyj@users.noreply.github.com>
Date: Mon, 13 Nov 2023 07:42:57 -0800
Subject: [PATCH 0017/1166] Add new docker tag to address repo name change

---
 .github/workflows/image-build-alpine-binary.yml | 1 +
 .github/workflows/image-build-debian-binary.yml | 1 +
 .github/workflows/image-build-debian-source.yml | 1 +
 3 files changed, 3 insertions(+)

diff --git a/.github/workflows/image-build-alpine-binary.yml b/.github/workflows/image-build-alpine-binary.yml
index 75a9144d6d..5422baffd8 100644
--- a/.github/workflows/image-build-alpine-binary.yml
+++ b/.github/workflows/image-build-alpine-binary.yml
@@ -55,6 +55,7 @@ jobs:
         uses: docker/metadata-action@v4
         with:
           images: |
+            blockstack/stacks-blockchain
             blockstack/${{ github.event.repository.name }}
           tags: |
             type=raw,value=latest,enable=${{ inputs.tag != '' && (github.ref == format('refs/heads/{0}', github.event.repository.default_branch) )}}
diff --git a/.github/workflows/image-build-debian-binary.yml b/.github/workflows/image-build-debian-binary.yml
index 052a2f87f5..c7c30ff266 100644
--- a/.github/workflows/image-build-debian-binary.yml
+++ b/.github/workflows/image-build-debian-binary.yml
@@ -67,6 +67,7 @@ jobs:
         uses: docker/metadata-action@v4
         with:
           images: |
+            blockstack/stacks-blockchain
             blockstack/${{ github.event.repository.name }}
           tags: |
             type=raw,value=latest-${{ inputs.linux_version }},enable=${{ inputs.tag != '' && (github.ref == format('refs/heads/{0}', github.event.repository.default_branch) )}}
diff --git a/.github/workflows/image-build-debian-source.yml b/.github/workflows/image-build-debian-source.yml
index 0ba8b2bfbe..3a8e379971 100644
--- a/.github/workflows/image-build-debian-source.yml
+++ b/.github/workflows/image-build-debian-source.yml
@@ -66,6 +66,7 @@ jobs:
         uses: docker/metadata-action@v4
         with:
           images: |
+            blockstack/stacks-blockchain
             blockstack/${{ github.event.repository.name }}
           tags: |
             type=raw,value=${{ env.BRANCH_NAME }}

From 3b4888d4afad2219a3e85695c9f83be19fab64f1 Mon Sep 17 00:00:00 2001
From: "brady.ouren" <tippenein@gmail.com>
Date: Sat, 18 Nov 2023 17:11:42 -0800
Subject: [PATCH 0018/1166] use hashset for event_observers

---
 clarity/src/vm/types/signatures.rs |  2 +-
 testnet/stacks-node/src/config.rs  | 30 +++++++++++++++++-------------
 2 files changed, 18 insertions(+), 14 deletions(-)

diff --git a/clarity/src/vm/types/signatures.rs b/clarity/src/vm/types/signatures.rs
index 88b59c3ba5..86d0c83496 100644
--- a/clarity/src/vm/types/signatures.rs
+++ b/clarity/src/vm/types/signatures.rs
@@ -39,7 +39,7 @@ use crate::vm::types::{
 
 type Result<R> = std::result::Result<R, CheckErrors>;
 
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Hash)]
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Serialize, Deserialize, Hash)]
 pub struct AssetIdentifier {
     pub contract_identifier: QualifiedContractIdentifier,
     pub asset_name: ClarityName,
diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index 08e626e187..e8bb392cfd 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -1,3 +1,4 @@
+use std::collections::HashSet;
 use std::convert::TryInto;
 use std::fs;
 use std::net::{SocketAddr, ToSocketAddrs};
@@ -44,7 +45,7 @@ pub struct ConfigFile {
     pub burnchain: Option<BurnchainConfigFile>,
     pub node: Option<NodeConfigFile>,
     pub ustx_balance: Option<Vec<InitialBalanceFile>>,
-    pub events_observer: Option<Vec<EventObserverConfigFile>>,
+    pub events_observer: Option<HashSet<EventObserverConfigFile>>,
     pub connection_options: Option<ConnectionOptionsFile>,
     pub fee_estimation: Option<FeeEstimationConfigFile>,
     pub miner: Option<MinerConfigFile>,
@@ -353,7 +354,7 @@ pub struct Config {
     pub burnchain: BurnchainConfig,
     pub node: NodeConfig,
     pub initial_balances: Vec<InitialBalance>,
-    pub events_observers: Vec<EventObserverConfig>,
+    pub events_observers: HashSet<EventObserverConfig>,
     pub connection_options: ConnectionOptions,
     pub miner: MinerConfig,
     pub estimation: FeeEstimationConfig,
@@ -979,7 +980,7 @@ impl Config {
 
         let mut events_observers = match config_file.events_observer {
             Some(raw_observers) => {
-                let mut observers = vec![];
+                let mut observers = HashSet::new();
                 for observer in raw_observers {
                     let events_keys: Vec<EventKeyType> = observer
                         .events_keys
@@ -989,22 +990,25 @@ impl Config {
 
                     let endpoint = format!("{}", observer.endpoint);
 
-                    observers.push(EventObserverConfig {
+                    observers.insert(EventObserverConfig {
                         endpoint,
                         events_keys,
                     });
                 }
                 observers
             }
-            None => vec![],
+            None => HashSet::new(),
         };
 
         // check for observer config in env vars
         match std::env::var("STACKS_EVENT_OBSERVER") {
-            Ok(val) => events_observers.push(EventObserverConfig {
-                endpoint: val,
-                events_keys: vec![EventKeyType::AnyEvent],
-            }),
+            Ok(val) => {
+                events_observers.insert(EventObserverConfig {
+                    endpoint: val,
+                    events_keys: vec![EventKeyType::AnyEvent],
+                });
+                ()
+            }
             _ => (),
         };
 
@@ -1347,7 +1351,7 @@ impl std::default::Default for Config {
             burnchain,
             node,
             initial_balances: vec![],
-            events_observers: vec![],
+            events_observers: HashSet::new(),
             connection_options,
             estimation,
             miner: MinerConfig::default(),
@@ -2079,19 +2083,19 @@ impl AtlasConfigFile {
     }
 }
 
-#[derive(Clone, Deserialize, Default, Debug)]
+#[derive(Clone, Deserialize, Default, Debug, Hash, PartialEq, Eq, PartialOrd)]
 pub struct EventObserverConfigFile {
     pub endpoint: String,
     pub events_keys: Vec<String>,
 }
 
-#[derive(Clone, Default, Debug)]
+#[derive(Clone, Default, Debug, Hash, PartialEq, Eq, PartialOrd)]
 pub struct EventObserverConfig {
     pub endpoint: String,
     pub events_keys: Vec<EventKeyType>,
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Hash, PartialEq, Eq, PartialOrd)]
 pub enum EventKeyType {
     SmartContractEvent((QualifiedContractIdentifier, String)),
     AssetEvent(AssetIdentifier),

From ef4c6bc712be0b458e2a38bbf4ea80db16a1e949 Mon Sep 17 00:00:00 2001
From: "brady.ouren" <tippenein@gmail.com>
Date: Sat, 18 Nov 2023 17:49:44 -0800
Subject: [PATCH 0019/1166] update stackerdb tests

---
 testnet/stacks-node/src/tests/stackerdb.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/testnet/stacks-node/src/tests/stackerdb.rs b/testnet/stacks-node/src/tests/stackerdb.rs
index a38f98b767..e24b5c5c24 100644
--- a/testnet/stacks-node/src/tests/stackerdb.rs
+++ b/testnet/stacks-node/src/tests/stackerdb.rs
@@ -113,7 +113,7 @@ fn test_stackerdb_load_store() {
     }
 
     let (mut conf, _) = neon_integration_test_conf();
-    conf.events_observers.push(EventObserverConfig {
+    conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
         events_keys: vec![EventKeyType::AnyEvent],
     });
@@ -246,7 +246,7 @@ fn test_stackerdb_event_observer() {
     }
 
     let (mut conf, _) = neon_integration_test_conf();
-    conf.events_observers.push(EventObserverConfig {
+    conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
         events_keys: vec![EventKeyType::StackerDBChunks],
     });

From 7b00a1faa357850efcc4f5b17dfeb431db2b5e9d Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Mon, 20 Nov 2023 12:20:49 -0500
Subject: [PATCH 0020/1166] feat: side-car to watch and report estimated
 sats/vbyte

---
 contrib/side-cars/fee-estimate.sh | 211 ++++++++++++++++++++++++++++++
 1 file changed, 211 insertions(+)
 create mode 100755 contrib/side-cars/fee-estimate.sh

diff --git a/contrib/side-cars/fee-estimate.sh b/contrib/side-cars/fee-estimate.sh
new file mode 100755
index 0000000000..1682c3fe0a
--- /dev/null
+++ b/contrib/side-cars/fee-estimate.sh
@@ -0,0 +1,211 @@
+#!/bin/bash
+
+####################################
+# Usage
+# 
+# $ ./fee-estimate.sh
+# 161
+# 
+# $ ./fee-estimate.sh test; echo $?
+# 0
+####################################
+
+set -uoe pipefail
+
+function exit_error() {
+   echo >&2 "$@"
+   exit 1
+}
+
+####################################
+# Dependencies
+####################################
+# Dependencies
+for cmd in curl jq bc sed date grep; do
+   command -v "$cmd" >/dev/null 2>&1 || exit_error "Command not found: '$cmd'"
+done
+
+
+####################################
+# Functions
+####################################
+
+# Convert a fee/kb to fee/vbyte.
+# If there's a fractional part of the fee/kb (i.e. if it's not divisible by 1000),
+# then round up.
+# Arguments:
+#   $1 -- the fee per kb
+# Stdout: the satoshis per vbyte, as an integer
+# Stderr: none
+# Return:
+#   0 on success
+#   nonzero on error
+function fee_per_kb_to_fee_per_vbyte() {
+   local fee_per_kb="$1"
+   local fee_per_vbyte_float=
+   local fee_per_vbyte_ipart=
+   local fee_per_vbyte_fpart=
+   local fee_per_vbyte=
+
+   # must be an integer
+   if ! [[ "$fee_per_kb" =~ ^[0-9]+$ ]]; then
+      exit_error "Did not receive a fee/kb from $fee_endpoint, but got '$fee_per_kb'"
+   fi
+
+   # NOTE: round up -- get the fractional part, and if it's anything other than 000, then add 1
+   fee_per_vbyte_float="$(echo "scale=3; $fee_per_kb / 1000" | bc)"
+   fee_per_vbyte_ipart="$(echo "$fee_per_vbyte_float" | sed -r 's/^([0-9]*)\..+$/\1/g')"
+   fee_per_vbyte_fpart="$(echo "$fee_per_vbyte_float" | sed -r -e 's/.+\.([0-9]+)$/\1/g' -e 's/0//g')"
+   fee_per_vbyte="$fee_per_vbyte_ipart"
+   if [ -n "$fee_per_vbyte_fpart" ]; then
+      fee_per_vbyte="$((fee_per_vbyte + 1))"
+   fi
+
+   echo "$fee_per_vbyte"
+   return 0
+}
+
+# Determine satoshis per vbyte
+# Arguments: none
+# Stdout: the satoshis per vbyte, as an integer
+# Stderr: none
+# Return:
+#   0 on success
+#   nonzero on error
+function get_sats_per_vbyte() {
+   local fee_endpoint="https://api.blockcypher.com/v1/btc/main"
+   local fee_per_kb=
+
+   fee_per_kb="$(curl -sL "$fee_endpoint" | jq -r '.high_fee_per_kb')"
+   fee_per_kb_to_fee_per_vbyte "$fee_per_kb"
+   return 0
+}
+
+# Update the fee rate in the config file.
+# Arguments:
+#   $1 -- path to the config file
+#   $2 -- new fee to write
+# Stdout: (none)
+# Stderr: (none)
+# Returns:
+#   0 on success
+#   nonzero on error
+function update_fee() {
+   local config_path="$1"
+   local fee="$2"
+   sed -i -r "s/satoshis_per_byte[ \t]+=.*$/satoshis_per_byte = ${fee}/g" "$config_path"
+   return 0
+}
+
+# Poll fees every so often, and update a config file.
+# Runs indefinitely.
+# If the fee estimator endpoint cannot be reached, then the file is not modified.
+# Arguments:
+#   $1 -- path to file to watch
+#   $2 -- interval at which to poll, in seconds
+# Stdout: (none)
+# Stderr: (none)
+# Returns: (none)
+function watch_fees() {
+   local config_path="$1"
+   local interval="$2"
+
+   local fee=
+   local rc=
+
+   while true; do
+      # allow poll command to fail without killing the script
+      set +e
+      fee="$(get_sats_per_vbyte)"
+      rc="$?"
+      set -e
+
+      if [ $rc -ne 0 ]; then
+         echo >&2 "WARN[$(date +%s)]: failed to poll fees"
+      else
+         update_fee "$config_path" "$fee"
+      fi
+      sleep "$interval"
+   done
+}
+
+# Unit tests
+function unit_test() {
+   local test_config="/tmp/test-miner-config-$$.toml"
+   if [ "$(fee_per_kb_to_fee_per_vbyte 1000)" != "1" ]; then
+      exit_error "failed -- 1000 sats/kbyte != 1 sats/vbyte"
+   fi
+
+   if [ "$(fee_per_kb_to_fee_per_vbyte 1001)" != "2" ]; then
+      exit_error "failed -- 1001 sats/vbyte != 2 sats/vbyte"
+   fi
+
+   if [ "$(fee_per_kb_to_fee_per_vbyte 999)" != "1" ]; then 
+      exit_error "failed -- 999 sats/vbyte != 1 sats/vbyte"
+   fi
+
+   echo "satoshis_per_byte = 123" > "$test_config"
+   update_fee "$test_config" "456"
+   if ! grep 'satoshis_per_byte = 456' >/dev/null "$test_config"; then
+      exit_error "failed -- did not update satoshis_per_byte"
+   fi
+  
+   echo "" > "$test_config"
+   update_fee "$test_config" "456"
+   if grep "satoshis_per_byte" "$test_config" >/dev/null; then
+      exit_error "failed -- updated satoshis_per_byte in a config file without it"
+   fi
+
+   rm "$test_config"
+   return 0
+}
+
+####################################
+# Entry point
+####################################
+
+# Main body
+# Arguments
+#   $1: mode of operation.  Can be "test" or empty
+# Stdout: the fee rate, in sats/vbte
+# Stderr: None
+# Return: (no return)
+function main() {
+   local mode="$1"
+   local config_path=
+   local interval=
+
+   case "$mode" in
+      "test")
+         # run unit tests
+         echo "Run unit tests"
+         unit_test
+         exit 0
+         ;;
+      "watch")
+         # watch and update the file
+         if (( $# < 3 )); then
+            exit_error "Usage: $0 watch /path/to/miner.toml interval_in_seconds"
+         fi
+         
+         config_path="$2"
+         interval="$3"
+
+         watch_fees "$config_path" "$interval"
+         ;;
+
+      "")
+         # one-shot
+         get_sats_per_vbyte
+         ;;
+   esac
+   exit 0
+}
+
+if (( $# > 0 )); then
+   # got arguments
+   main "$@"
+else
+   # no arguments
+   main ""
+fi

From 29e31cd43a531e4d9464a030c49a43a6f5a013e4 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Mon, 20 Nov 2023 12:30:57 -0500
Subject: [PATCH 0021/1166] chore: more usage docs

---
 contrib/side-cars/fee-estimate.sh | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/contrib/side-cars/fee-estimate.sh b/contrib/side-cars/fee-estimate.sh
index 1682c3fe0a..672f237dfb 100755
--- a/contrib/side-cars/fee-estimate.sh
+++ b/contrib/side-cars/fee-estimate.sh
@@ -3,9 +3,14 @@
 ####################################
 # Usage
 # 
+# $ # one-shot fee-rate calculation
 # $ ./fee-estimate.sh
 # 161
 # 
+# $ # Check fees every 5 seconds and update `satoshis_per_byte` in `/path/to/miner.toml`
+# $ ./fee-estimate.sh watch /path/to/miner.toml 5
+# 
+# $ # Run unit tests and report result (0 means success)
 # $ ./fee-estimate.sh test; echo $?
 # 0
 ####################################

From 0224b1a1dadbab0c49469cc8ca45afae0dfed909 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Mon, 20 Nov 2023 15:42:58 -0500
Subject: [PATCH 0022/1166] chore: address PR feedback -- log HTTP errors and
 check that the config file exists

---
 contrib/side-cars/fee-estimate.sh | 50 +++++++++++++++++++++++++++----
 1 file changed, 45 insertions(+), 5 deletions(-)

diff --git a/contrib/side-cars/fee-estimate.sh b/contrib/side-cars/fee-estimate.sh
index 672f237dfb..e7810b4880 100755
--- a/contrib/side-cars/fee-estimate.sh
+++ b/contrib/side-cars/fee-estimate.sh
@@ -25,8 +25,7 @@ function exit_error() {
 ####################################
 # Dependencies
 ####################################
-# Dependencies
-for cmd in curl jq bc sed date grep; do
+for cmd in curl jq bc sed date grep head tail; do
    command -v "$cmd" >/dev/null 2>&1 || exit_error "Command not found: '$cmd'"
 done
 
@@ -54,7 +53,7 @@ function fee_per_kb_to_fee_per_vbyte() {
 
    # must be an integer
    if ! [[ "$fee_per_kb" =~ ^[0-9]+$ ]]; then
-      exit_error "Did not receive a fee/kb from $fee_endpoint, but got '$fee_per_kb'"
+      return 1
    fi
 
    # NOTE: round up -- get the fractional part, and if it's anything other than 000, then add 1
@@ -70,6 +69,41 @@ function fee_per_kb_to_fee_per_vbyte() {
    return 0
 }
 
+# Query the endpoint and log HTTP errors gracefully 
+# Arguments:
+#   $1 endpoint to query
+# Stdout: the HTTP response body
+# Stderr: an error message, if we failed to query
+# Return:
+#   0 on success
+#   nonzero on error
+function query_fee_endpoint() {
+   local fee_endpoint="$1"
+   local response=
+   local http_status_code=
+
+   response="$(curl -sL -w "\n%{http_code}" "$fee_endpoint" || true)";
+   http_status_code="$(echo "$response" | tail -n 1)";
+   case $http_status_code in 
+      200)
+         ;;
+      429)
+         echo >&2 "WARN[$(date +%s)]: 429 Rate-Limited retreiving ${fee_endpoint}"
+         return 1
+         ;;
+      404)
+         echo >&2 "WARN[$(date +%s)]: 404 Not Found retrieving ${fee_endpoint}"
+         return 1
+         ;;
+      **)
+         echo >&2 "WARN[$(date +%s)]: ${http_status_code} Error retrieving ${fee_endpoint}"
+         return 1
+         ;;
+   esac
+   echo "$response" | head -n -1
+   return 0
+}
+
 # Determine satoshis per vbyte
 # Arguments: none
 # Stdout: the satoshis per vbyte, as an integer
@@ -81,8 +115,10 @@ function get_sats_per_vbyte() {
    local fee_endpoint="https://api.blockcypher.com/v1/btc/main"
    local fee_per_kb=
 
-   fee_per_kb="$(curl -sL "$fee_endpoint" | jq -r '.high_fee_per_kb')"
-   fee_per_kb_to_fee_per_vbyte "$fee_per_kb"
+   fee_per_kb="$(query_fee_endpoint "$fee_endpoint" | jq -r '.high_fee_per_kb')"
+   if ! fee_per_kb_to_fee_per_vbyte "$fee_per_kb"; then
+      return 1
+   fi
    return 0
 }
 
@@ -196,6 +232,10 @@ function main() {
          config_path="$2"
          interval="$3"
 
+         if ! [ -f "$config_path" ]; then 
+            exit_error "No such config file: ${config_path}"
+         fi
+
          watch_fees "$config_path" "$interval"
          ;;
 

From e585d258ccdf27b55102509f2231bd2d41a350cb Mon Sep 17 00:00:00 2001
From: AshtonStephens <ashton.cs.stephens@gmail.com>
Date: Tue, 21 Nov 2023 12:50:23 -0500
Subject: [PATCH 0023/1166] Add sidecar scripts for fee estimation and stacks
 block delay detection

---
 contrib/side-cars/config/fee-estimate.json    |   4 +
 .../stacks-block-delay-event-trigger.json     |   6 +
 contrib/side-cars/fee-estimate.py             | 188 +++++++++++++++
 .../stacks-block-delay-event-trigger.py       | 226 ++++++++++++++++++
 4 files changed, 424 insertions(+)
 create mode 100644 contrib/side-cars/config/fee-estimate.json
 create mode 100644 contrib/side-cars/config/stacks-block-delay-event-trigger.json
 create mode 100644 contrib/side-cars/fee-estimate.py
 create mode 100644 contrib/side-cars/stacks-block-delay-event-trigger.py

diff --git a/contrib/side-cars/config/fee-estimate.json b/contrib/side-cars/config/fee-estimate.json
new file mode 100644
index 0000000000..9c8c1dc44c
--- /dev/null
+++ b/contrib/side-cars/config/fee-estimate.json
@@ -0,0 +1,4 @@
+{
+    "toml_file_location": "Path/To/miner.toml",
+    "polling_delay_seconds": 60
+}
\ No newline at end of file
diff --git a/contrib/side-cars/config/stacks-block-delay-event-trigger.json b/contrib/side-cars/config/stacks-block-delay-event-trigger.json
new file mode 100644
index 0000000000..e9778e8c74
--- /dev/null
+++ b/contrib/side-cars/config/stacks-block-delay-event-trigger.json
@@ -0,0 +1,6 @@
+{
+    "polling_delay_seconds": 60,
+    "max_stacks_delay_seconds": 1500,
+    "recovery_delay_seconds": 660,
+    "shell_command": ["echo", "command not specified"]
+}
\ No newline at end of file
diff --git a/contrib/side-cars/fee-estimate.py b/contrib/side-cars/fee-estimate.py
new file mode 100644
index 0000000000..62dff1579d
--- /dev/null
+++ b/contrib/side-cars/fee-estimate.py
@@ -0,0 +1,188 @@
+"""
+Script to continuously update the `satoshis_per_byte` value in a TOML file with the
+mean fee estimate from a list of API endpoints.
+
+Usage:
+    $ COMMAND /path/to/miner.toml polling_delay_seconds
+
+Args:
+    toml_file_location (str): The path to the TOML file to update.
+    polling_delay_seconds (int): The frequency in seconds to check for fee updates.
+"""
+
+import toml
+import json
+import requests
+import time
+from backoff_utils import strategies
+from backoff_utils import apply_backoff
+from sys import argv
+
+# Fee estimation API URLS and their corresponding fee extraction functions.
+# At least one of these needs to be working in order for the script to function.
+FEE_ESTIMATIONS = [
+    # Bitcoiner Live API
+    (
+        'https://bitcoiner.live/api/fees/estimates/latest',
+        lambda response_json: response_json["estimates"]["30"]["sat_per_vbyte"],
+    ),
+
+    # Mempool Space API
+    (
+        'https://mempool.space/api/v1/fees/recommended',
+        lambda response_json: response_json["halfHourFee"],
+    ),
+
+    # Blockchain.info API
+    (
+        'https://api.blockchain.info/mempool/fees',
+        lambda response_json: response_json["regular"],
+    ),
+]
+
+def calculate_fee_estimate():
+    """
+    Calculates the mean fee estimate from a list of API URLs
+    and their corresponding fee extraction functions.
+
+    Args:
+        FEE_ESTIMATIONS (list): A list of tuples, where each tuple
+        contains the URL of an API endpoint and a function that extracts
+        the fee estimate from the JSON response.
+
+    Returns:
+        int: The mean fee estimate in sat/Byte.
+
+    Raises:
+        None
+    """
+
+    # Gather all API estimated fees in sat/Byte
+    estimated_fees = []
+    for api_url, unpack_fee_estimate in FEE_ESTIMATIONS:
+
+        try:
+            json_response = json.loads(get_from_api(api_url))
+            estimated_fee = unpack_fee_estimate(json_response)
+            estimated_fees.append(estimated_fee)
+
+        except Exception as e:
+            pass
+
+    # Calculate the mean fee estimate
+    mean_fee = int(sum(estimated_fees) / len(estimated_fees))
+
+    return mean_fee
+
+@apply_backoff(
+    strategy=strategies.Exponential,
+    catch_exceptions=(RuntimeError,),
+    max_tries=3,
+    max_delay=60,
+)
+def get_from_api(api_url: str) -> str:
+    """
+    Sends a GET request to the specified API URL and returns the string response.
+
+    Args:
+        api_url (str): The URL of the API endpoint to call.
+
+    Returns:
+        dict: The string response data.
+
+    Raises:
+        RuntimeError: If the API call fails.
+    """
+
+    try:
+        # Make a GET request to the API endpoint
+        response = requests.get(api_url)
+
+        # Check if the request was successful
+        if response.status_code == 200:
+            # Parse the response and return the data
+            return response.text
+
+    except Exception as e:
+        # If an exception occurs, raise a RuntimeError
+        raise RuntimeError("Failed to unpack JSON.")
+
+    # If the code reaches this point, it means the API call failed.
+    raise RuntimeError("Failed to get response.")
+
+
+def update_config_fee(toml_file_location: str, polling_delay_seconds: int):
+    """
+    Updates the `satoshis_per_byte` value in the specified TOML file
+    with the mean fee estimate from a list of API endpoints.
+
+    Args:
+        toml_file_location (str): The path to the TOML file to update.
+
+    Raises:
+        IOError: If the TOML file cannot be read or written.
+        RuntimeError: If the fee estimation process fails.
+    """
+
+    while True:
+        # Calculate mean fee estimate from the list of APIs
+        fee_estimate = calculate_fee_estimate()
+
+        # Read toml file data
+        with open(toml_file_location, 'r') as toml_file:
+            toml_data = toml.load(toml_file)
+
+        # Update satoshis_per_byte data
+        toml_data["burnchain"]["satoshis_per_byte"] = fee_estimate
+
+        # Update toml file with configuration changes
+        with open(toml_file_location, 'w') as toml_file:
+            toml.dump(toml_data, toml_file)
+
+        time.sleep()
+
+def read_config(config_location: str):
+    """
+    Reads and returns the contents of a configuration file.
+    """
+    with open(config_location, "r") as config_file:
+        return json.load(config_file)
+
+def main():
+    """
+    Continuously updates the `satoshis_per_byte` value in the specified
+    TOML file with the mean fee estimate from a list of API endpoints.
+
+    Usage:
+        $ {argv[0]} /path/to/miner.toml polling_delay
+    """
+
+    try:
+        configuration = {}
+
+        if len(argv) == 1:
+            configuration = read_config("./config/fee-estimate.json")
+        elif "-c" in argv:
+            # Load configuration from specified file
+            config_location = argv[argv.index("-c") + 1]
+            configuration = read_config(config_location)
+        else:
+            # Load configuration from command-line arguments
+            configuration = {
+                "toml_file_location": argv[1],
+                "polling_delay_seconds": int(argv[2]),
+            }
+
+        update_config_fee(**configuration)
+
+    # Print usage if there are errors.
+    except Exception as e:
+        print(f"Failed to run {argv[0]}")
+        print(f"\n\t$ COMMAND /path/to/miner.toml polling_delay_seconds")
+        print("\t\tOR")
+        print(f"\t$ COMMAND -c /path/to/config_file.json\n")
+        print(f"Error: {e}")
+
+# Execute main.
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git a/contrib/side-cars/stacks-block-delay-event-trigger.py b/contrib/side-cars/stacks-block-delay-event-trigger.py
new file mode 100644
index 0000000000..4a8c57de01
--- /dev/null
+++ b/contrib/side-cars/stacks-block-delay-event-trigger.py
@@ -0,0 +1,226 @@
+"""
+Monitors the time difference between Stacks blocks and Bitcoin blocks, triggering an event
+when the time difference exceeds a specified threshold.
+
+This script continuously checks the time difference between the latest Stacks
+block and the latest Bitcoin block. If the time difference exceeds a user-defined
+threshold, the script executes a user-defined shell command. The script utilizes
+exponential backoff with retries and a maximum delay to handle temporary API outages.
+
+Usage:
+
+    $ COMMAND polling_delay_seconds max_stacks_delay_seconds recovery_delay_seconds shell_command...
+
+    OR
+
+    $ COMMAND -c /path/to/config_file
+
+Options:
+
+    polling_delay_seconds: The time interval between checking the time difference,
+        in seconds.
+    max_stacks_delay_seconds: The maximum acceptable time difference between
+        Stacks and Bitcoin blocks, in seconds.
+    recovery_delay_seconds: The delay after executing the shell command before
+        resuming monitoring, in seconds.
+    shell_command: The shell command to execute when the time difference exceeds
+        the threshold.
+
+Alternatively, you can provide a configuration file using the -c option.
+The configuration file should be a JSON file with the following fields:
+
+```json
+{
+    "polling_delay_seconds": <int>,
+    "max_stacks_delay_seconds": <int>,
+    "recovery_delay_seconds": <int>,
+    "shell_command": <list[str]>
+}
+```
+
+Example:
+```json
+{
+  "polling_delay_seconds": 60,
+  "max_stacks_delay_seconds": 60,
+  "recovery_delay_seconds": 60,
+  "shell_command": ["echo", "hello, world!"],
+}
+```
+"""
+
+import toml
+import json
+import requests
+import time
+from backoff_utils import strategies
+from backoff_utils import apply_backoff
+from datetime import datetime
+from sys import argv
+import subprocess
+
+# Stacks API endpoints.
+API_URL_LATEST_STACKS_BLOCK = "https://api.mainnet.hiro.so/extended/v1/block?limit=1"
+API_URL_LATEST_STACKS_TRANSACTION = "https://api.mainnet.hiro.so/extended/v1/tx/{transaction_id}"
+
+# Bitcoin API endpoints.
+API_URL_LATEST_BTC_BLOCK_HASH = "https://mempool.space/api/blocks/tip/hash"
+API_URL_BTC_BLOCK_FROM_HASH = "https://mempool.space/api/block/{block_hash}"
+
+@apply_backoff(
+    strategy=strategies.Exponential,
+    catch_exceptions=(RuntimeError,),
+    max_tries=3,
+    max_delay=60,
+)
+def get_from_api(api_url: str) -> dict:
+    """
+    Sends a GET request to the specified API URL and returns the string response.
+
+    Args:
+        api_url (str): The URL of the API endpoint to call.
+
+    Returns:
+        dict: The string response data.
+
+    Raises:
+        RuntimeError: If the API call fails or the response cannot be parsed as JSON.
+    """
+
+    try:
+        # Make a GET request to the API endpoint
+        response = requests.get(api_url)
+
+        # Check if the request was successful
+        if response.status_code == 200:
+            # Parse the response and return the data
+            return response.text
+
+    except Exception as e:
+        # If an exception occurs, raise a RuntimeError
+        raise RuntimeError("Failed to unpack JSON.")
+
+    # If the code reaches this point, it means the API call failed.
+    raise RuntimeError("Failed to get response.")
+
+
+def get_latest_bitcoin_block_timestamp() -> int:
+    """
+    Retrieves the timestamp of the latest Bitcoin block.
+
+    Returns:
+        int: The timestamp of the latest Bitcoin block.
+    """
+
+    latest_btc_block_hash = get_from_api(API_URL_LATEST_BTC_BLOCK_HASH)
+    json_response = json.loads(get_from_api(
+        API_URL_BTC_BLOCK_FROM_HASH.format(block_hash=latest_btc_block_hash)))
+    return json_response["timestamp"]
+
+
+def get_latest_stacks_block_timestamp() -> int:
+    """
+    Retrieves the timestamp of the latest Stacks block.
+
+    Returns:
+        int: The timestamp of the latest Stacks block.
+    """
+
+    latest_stacks_block_json = json.loads(get_from_api(API_URL_LATEST_STACKS_BLOCK))
+    return latest_stacks_block_json["results"][0]["burn_block_time"]
+
+def stacks_block_delay_event_listener(
+    polling_delay_seconds: int,
+    max_stacks_delay_seconds: int,
+    recovery_delay_seconds: int,
+    shell_command: list[str],
+):
+    """
+    Continuously monitors the time between Stacks blocks and Bitcoin blocks.
+
+    If the time difference exceeds a specified threshold, the script executes
+    a user-defined shell command. The script utilizes exponential backoff with
+    retries and a maximum delay to handle temporary API outages.
+
+    Args:
+        polling_delay_seconds (int): The time interval between checking the
+            time difference, in seconds (default: 60).
+        max_stacks_delay_seconds (int): The maximum acceptable time difference
+            between Stacks and Bitcoin blocks, in seconds (default: 60).
+        recovery_delay_seconds (int): The delay after executing the shell
+            command before resuming monitoring, in seconds (default: 60).
+        shell_command (list[str]): The shell command to execute when the time
+            difference exceeds the threshold (default: ["echo", "hello"]).
+    """
+
+    while True:
+
+        # Continuously retrieve the timestamps of the latest Stacks and Bitcoin blocks.
+        latest_stacks_block_timestamp = get_latest_stacks_block_timestamp()
+        latest_bitcoin_block_timestamp = get_latest_bitcoin_block_timestamp()
+
+        # Calculate the time difference between the latest Stacks and Bitcoin blocks.
+        stacks_block_delay = datetime.fromtimestamp(latest_bitcoin_block_timestamp) - \
+            datetime.fromtimestamp(latest_stacks_block_timestamp)
+
+        # If the time difference exceeds the specified threshold execute the shell command.
+        if stacks_block_delay.seconds > max_stacks_delay_seconds:
+            print(f"Delay between stacks and bitcoin block: {stacks_block_delay}")
+            print(f"$ {' '.join(shell_command)}")
+
+            subprocess.run(shell_command, shell=True)
+            time.sleep(recovery_delay_seconds) # Wait for the recovery period before resuming monitoring.
+
+        # If the time difference is within the acceptable range wait for the polling interval.
+        else:
+            time.sleep(polling_delay_seconds)
+
+def read_config(config_location: str):
+    """
+    Reads and returns the contents of a configuration file.
+    """
+    with open(config_location, "r") as config_file:
+        return json.load(config_file)
+
+def main():
+    """
+    Continuously monitors the time between Stacks blocks and Bitcoin blocks,
+    triggering an event when thresholds are exceeded.
+
+    If the time difference exceeds a specified threshold, the script executes
+    a user-defined shell command. It utilizes exponential backoff with
+    retries and a maximum delay to handle temporary API outages.
+    """
+
+    try:
+        configuration = {}
+
+        if len(argv) == 1:
+            configuration = read_config("./config/stacks-block-delay-event-trigger.json")
+        elif "-c" in argv:
+            # Load configuration from specified file
+            config_location = argv[argv.index("-c") + 1]
+            configuration = read_config(config_location)
+
+        else:
+            # Load configuration from command-line arguments
+            configuration = {
+                "polling_delay_seconds": int(argv[1]),
+                "max_stacks_delay_seconds": int(argv[2]),
+                "recovery_delay_seconds": int(argv[3]),
+                "shell_command": argv[4:],
+            }
+
+        stacks_block_delay_event_listener(**configuration)
+
+    # Print usage if there are errors.
+    except Exception as e:
+        print(f"Failed to run {argv[0]}")
+        print(f"\n\t$ COMMAND polling_delay_seconds max_stacks_delay_seconds recovery_delay_seconds shell_command...")
+        print("\t\tOR")
+        print(f"\t$ COMMAND -c /path/to/config_file.json\n")
+        print(f"Error: {e}")
+
+# Execute main.
+if __name__ == "__main__":
+    main()
\ No newline at end of file

From 347c1cf68c69d40bda7ec306ead23cef15561cd7 Mon Sep 17 00:00:00 2001
From: Friedger <mail@friedger.de>
Date: Mon, 30 Oct 2023 16:14:07 +0100
Subject: [PATCH 0024/1166] Improve error description of `ft-mint?`

---
 clarity/src/vm/docs/mod.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/clarity/src/vm/docs/mod.rs b/clarity/src/vm/docs/mod.rs
index 81e4ce3434..9961a72971 100644
--- a/clarity/src/vm/docs/mod.rs
+++ b/clarity/src/vm/docs/mod.rs
@@ -2082,7 +2082,8 @@ type defined using `define-fungible-token`. The increased token balance is _not_
 rather minted.  
 
 If a non-positive amount is provided to mint, this function returns `(err 1)`. Otherwise, on successfuly mint, it
-returns `(ok true)`.
+returns `(ok true)`. If this call would result in more supplied tokens than defined by the total supply in 
+`define-fungible-token`, then a `SupplyOverflow` runtime error is thrown.
 ",
     example: "
 (define-fungible-token stackaroo)

From ca523fb267e12a65ee8e4438c8ea2bdc8d085b61 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Wed, 22 Nov 2023 11:56:40 -0500
Subject: [PATCH 0025/1166] fix: Address warning messages and errors in `cargo
 build` and `cargo test`

---
 stackslib/src/chainstate/stacks/db/transactions.rs          | 4 ++--
 stackslib/src/net/api/tests/mod.rs                          | 4 ++--
 stackslib/src/net/atlas/download.rs                         | 2 +-
 stackslib/src/net/download.rs                               | 2 +-
 stackslib/src/net/p2p.rs                                    | 2 +-
 stackslib/src/net/stackerdb/config.rs                       | 2 ++
 stackslib/src/util_lib/db.rs                                | 2 +-
 stackslib/src/util_lib/strings.rs                           | 4 ++--
 .../src/burnchains/bitcoin_regtest_controller.rs            | 6 +++---
 9 files changed, 15 insertions(+), 13 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/db/transactions.rs b/stackslib/src/chainstate/stacks/db/transactions.rs
index ac11e74897..6348883d1a 100644
--- a/stackslib/src/chainstate/stacks/db/transactions.rs
+++ b/stackslib/src/chainstate/stacks/db/transactions.rs
@@ -2108,8 +2108,8 @@ pub mod test {
             );
 
             let contracts = vec![
-                contract_correct.clone(),
-                contract_correct.clone(),
+                contract_correct,
+                contract_correct,
                 contract_syntax_error, // should still be mined, even though analysis fails
             ];
 
diff --git a/stackslib/src/net/api/tests/mod.rs b/stackslib/src/net/api/tests/mod.rs
index adcd681ae5..cc52a80e6e 100644
--- a/stackslib/src/net/api/tests/mod.rs
+++ b/stackslib/src/net/api/tests/mod.rs
@@ -301,7 +301,7 @@ impl<'a> TestRPC<'a> {
         let tx_coinbase_signed = tx_signer.get_tx().unwrap();
 
         // next the contract
-        let contract = TEST_CONTRACT.clone();
+        let contract = TEST_CONTRACT;
         let mut tx_contract = StacksTransaction::new(
             TransactionVersion::Testnet,
             TransactionAuth::from_p2pkh(&privk1).unwrap(),
@@ -343,7 +343,7 @@ impl<'a> TestRPC<'a> {
         };
 
         // make an unconfirmed contract
-        let unconfirmed_contract = TEST_CONTRACT_UNCONFIRMED.clone();
+        let unconfirmed_contract = TEST_CONTRACT_UNCONFIRMED;
         let mut tx_unconfirmed_contract = StacksTransaction::new(
             TransactionVersion::Testnet,
             TransactionAuth::from_p2pkh(&privk1).unwrap(),
diff --git a/stackslib/src/net/atlas/download.rs b/stackslib/src/net/atlas/download.rs
index 489050bcbd..a9dad242a5 100644
--- a/stackslib/src/net/atlas/download.rs
+++ b/stackslib/src/net/atlas/download.rs
@@ -724,7 +724,7 @@ impl BatchedDNSLookupsState {
                     match url.host() {
                         Some(url::Host::Domain(domain)) => {
                             let res = dns_client.queue_lookup(
-                                domain.clone(),
+                                domain,
                                 port,
                                 get_epoch_time_ms() + connection_options.dns_timeout,
                             );
diff --git a/stackslib/src/net/download.rs b/stackslib/src/net/download.rs
index 5957b9818a..022152be54 100644
--- a/stackslib/src/net/download.rs
+++ b/stackslib/src/net/download.rs
@@ -350,7 +350,7 @@ impl BlockDownloader {
             match url.host() {
                 Some(url::Host::Domain(domain)) => {
                     match dns_client.queue_lookup(
-                        domain.clone(),
+                        domain,
                         port,
                         get_epoch_time_ms() + self.dns_timeout,
                     ) {
diff --git a/stackslib/src/net/p2p.rs b/stackslib/src/net/p2p.rs
index 0de77c4ff2..9c4492720b 100644
--- a/stackslib/src/net/p2p.rs
+++ b/stackslib/src/net/p2p.rs
@@ -3483,7 +3483,7 @@ impl PeerNetwork {
             if let Some(ref mut dns_client) = dns_client_opt {
                 // begin DNS query
                 match dns_client.queue_lookup(
-                    domain.clone(),
+                    domain,
                     port,
                     get_epoch_time_ms() + self.connection_opts.dns_timeout,
                 ) {
diff --git a/stackslib/src/net/stackerdb/config.rs b/stackslib/src/net/stackerdb/config.rs
index 376f57b141..8cd3147558 100644
--- a/stackslib/src/net/stackerdb/config.rs
+++ b/stackslib/src/net/stackerdb/config.rs
@@ -17,6 +17,7 @@
 /// This file implements the interface to the StackerDB smart contract for loading the DB's config.
 /// The smart contract must conform to this trait:
 ///
+/// ```clarity,ignore
 /// ;; Any StackerDB smart contract must conform to this trait.
 /// (define-trait stackerdb-trait
 ///
@@ -34,6 +35,7 @@
 ///         },
 ///         uint))
 /// )
+/// ```
 use std::collections::{HashMap, HashSet};
 use std::mem;
 
diff --git a/stackslib/src/util_lib/db.rs b/stackslib/src/util_lib/db.rs
index d309bfe5f5..e10ca1b886 100644
--- a/stackslib/src/util_lib/db.rs
+++ b/stackslib/src/util_lib/db.rs
@@ -353,7 +353,7 @@ fn log_sql_eqp(conn: &Connection, sql_query: &str) {
         return;
     }
 
-    let mut parts = sql_query.clone().split(" ");
+    let mut parts = sql_query.split(" ");
     let mut full_sql = if let Some(part) = parts.next() {
         part.to_string()
     } else {
diff --git a/stackslib/src/util_lib/strings.rs b/stackslib/src/util_lib/strings.rs
index cb43956274..b7d32b64a6 100644
--- a/stackslib/src/util_lib/strings.rs
+++ b/stackslib/src/util_lib/strings.rs
@@ -331,8 +331,8 @@ mod test {
     fn tx_stacks_strings_codec() {
         let s = "hello-world";
         let stacks_str = StacksString::from_str(&s).unwrap();
-        let clarity_str = ClarityName::try_from(s.clone()).unwrap();
-        let contract_str = ContractName::try_from(s.clone()).unwrap();
+        let clarity_str = ClarityName::try_from(s).unwrap();
+        let contract_str = ContractName::try_from(s).unwrap();
 
         assert_eq!(stacks_str[..], s.as_bytes().to_vec()[..]);
         let s2 = stacks_str.to_string();
diff --git a/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs b/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
index c17322f818..319fec7080 100644
--- a/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
+++ b/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
@@ -166,13 +166,13 @@ pub fn get_satoshis_per_byte(config: &Config) -> u64 {
 
 #[cfg(test)]
 mod tests {
-    use crate::config::DEFAULT_SATS_PER_VB;
-
-    use super::*;
     use std::env::temp_dir;
     use std::fs::File;
     use std::io::Write;
 
+    use super::*;
+    use crate::config::DEFAULT_SATS_PER_VB;
+
     #[test]
     fn test_get_satoshis_per_byte() {
         let dir = temp_dir();

From fc6102191ff4d5f34306c1307370ee1b282084eb Mon Sep 17 00:00:00 2001
From: "brady.ouren" <tippenein@gmail.com>
Date: Wed, 22 Nov 2023 16:37:48 -0800
Subject: [PATCH 0026/1166] mass replace .push with .insert

---
 testnet/stacks-node/src/tests/epoch_205.rs    | 10 +--
 testnet/stacks-node/src/tests/epoch_21.rs     | 14 ++--
 testnet/stacks-node/src/tests/epoch_22.rs     |  4 +-
 testnet/stacks-node/src/tests/epoch_23.rs     |  2 +-
 testnet/stacks-node/src/tests/epoch_24.rs     |  4 +-
 .../src/tests/neon_integrations.rs            | 80 +++++++++----------
 testnet/stacks-node/src/tests/signer.rs       |  2 +-
 7 files changed, 58 insertions(+), 58 deletions(-)

diff --git a/testnet/stacks-node/src/tests/epoch_205.rs b/testnet/stacks-node/src/tests/epoch_205.rs
index 60577cb690..568912feec 100644
--- a/testnet/stacks-node/src/tests/epoch_205.rs
+++ b/testnet/stacks-node/src/tests/epoch_205.rs
@@ -110,7 +110,7 @@ fn test_exact_block_costs() {
         .collect();
 
     test_observer::spawn();
-    conf.events_observers.push(EventObserverConfig {
+    conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
         events_keys: vec![EventKeyType::AnyEvent, EventKeyType::MinedBlocks],
     });
@@ -336,7 +336,7 @@ fn test_dynamic_db_method_costs() {
     };
 
     test_observer::spawn();
-    conf.events_observers.push(EventObserverConfig {
+    conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
         events_keys: vec![EventKeyType::AnyEvent],
     });
@@ -772,7 +772,7 @@ fn test_cost_limit_switch_version205() {
     });
 
     test_observer::spawn();
-    conf.events_observers.push(EventObserverConfig {
+    conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
         events_keys: vec![EventKeyType::AnyEvent],
     });
@@ -920,7 +920,7 @@ fn bigger_microblock_streams_in_2_05() {
                 &format!("large-{}", ix),
                 &format!("
                     ;; a single one of these transactions consumes over half the runtime budget
-                    (define-constant BUFF_TO_BYTE (list 
+                    (define-constant BUFF_TO_BYTE (list
                        0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f
                        0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f
                        0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x2a 0x2b 0x2c 0x2d 0x2e 0x2f
@@ -1030,7 +1030,7 @@ fn bigger_microblock_streams_in_2_05() {
     conf.burnchain.pox_2_activation = Some(10_003);
 
     test_observer::spawn();
-    conf.events_observers.push(EventObserverConfig {
+    conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
         events_keys: vec![EventKeyType::AnyEvent],
     });
diff --git a/testnet/stacks-node/src/tests/epoch_21.rs b/testnet/stacks-node/src/tests/epoch_21.rs
index fb73916964..34ac467bc0 100644
--- a/testnet/stacks-node/src/tests/epoch_21.rs
+++ b/testnet/stacks-node/src/tests/epoch_21.rs
@@ -72,7 +72,7 @@ fn advance_to_2_1(
     conf.initial_balances.append(&mut initial_balances);
     conf.miner.block_reward_recipient = block_reward_recipient;
 
-    conf.events_observers.push(EventObserverConfig {
+    conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
         events_keys: vec![EventKeyType::AnyEvent],
     });
@@ -573,7 +573,7 @@ fn transition_fixes_bitcoin_rigidity() {
     ];
 
     conf.initial_balances.append(&mut initial_balances);
-    conf.events_observers.push(EventObserverConfig {
+    conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
         events_keys: vec![EventKeyType::AnyEvent],
     });
@@ -1461,7 +1461,7 @@ fn transition_removes_pox_sunset() {
 
     test_observer::spawn();
 
-    conf.events_observers.push(EventObserverConfig {
+    conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
         events_keys: vec![EventKeyType::AnyEvent],
     });
@@ -1775,7 +1775,7 @@ fn transition_empty_blocks() {
 
     test_observer::spawn();
 
-    conf.events_observers.push(EventObserverConfig {
+    conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
         events_keys: vec![EventKeyType::AnyEvent],
     });
@@ -4716,7 +4716,7 @@ fn trait_invocation_cross_epoch() {
         amount: 200_000_000,
     }];
     conf.initial_balances.append(&mut initial_balances);
-    conf.events_observers.push(EventObserverConfig {
+    conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
         events_keys: vec![EventKeyType::AnyEvent],
     });
@@ -4962,7 +4962,7 @@ fn test_v1_unlock_height_with_current_stackers() {
 
     test_observer::spawn();
 
-    conf.events_observers.push(EventObserverConfig {
+    conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
         events_keys: vec![EventKeyType::AnyEvent],
     });
@@ -5224,7 +5224,7 @@ fn test_v1_unlock_height_with_delay_and_current_stackers() {
 
     test_observer::spawn();
 
-    conf.events_observers.push(EventObserverConfig {
+    conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
         events_keys: vec![EventKeyType::AnyEvent],
     });
diff --git a/testnet/stacks-node/src/tests/epoch_22.rs b/testnet/stacks-node/src/tests/epoch_22.rs
index 4e817452b9..eab6ea5685 100644
--- a/testnet/stacks-node/src/tests/epoch_22.rs
+++ b/testnet/stacks-node/src/tests/epoch_22.rs
@@ -136,7 +136,7 @@ fn disable_pox() {
 
     test_observer::spawn();
 
-    conf.events_observers.push(EventObserverConfig {
+    conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
         events_keys: vec![EventKeyType::AnyEvent],
     });
@@ -666,7 +666,7 @@ fn pox_2_unlock_all() {
 
     test_observer::spawn();
 
-    conf.events_observers.push(EventObserverConfig {
+    conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
         events_keys: vec![EventKeyType::AnyEvent],
     });
diff --git a/testnet/stacks-node/src/tests/epoch_23.rs b/testnet/stacks-node/src/tests/epoch_23.rs
index 73a731a5bc..9e13e597dd 100644
--- a/testnet/stacks-node/src/tests/epoch_23.rs
+++ b/testnet/stacks-node/src/tests/epoch_23.rs
@@ -102,7 +102,7 @@ fn trait_invocation_behavior() {
 
     test_observer::spawn();
 
-    conf.events_observers.push(EventObserverConfig {
+    conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
         events_keys: vec![EventKeyType::AnyEvent],
     });
diff --git a/testnet/stacks-node/src/tests/epoch_24.rs b/testnet/stacks-node/src/tests/epoch_24.rs
index 97f9744223..9b002f6253 100644
--- a/testnet/stacks-node/src/tests/epoch_24.rs
+++ b/testnet/stacks-node/src/tests/epoch_24.rs
@@ -154,7 +154,7 @@ fn fix_to_pox_contract() {
 
     test_observer::spawn();
 
-    conf.events_observers.push(EventObserverConfig {
+    conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
         events_keys: vec![EventKeyType::AnyEvent],
     });
@@ -790,7 +790,7 @@ fn verify_auto_unlock_behavior() {
 
     test_observer::spawn();
 
-    conf.events_observers.push(EventObserverConfig {
+    conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
         events_keys: vec![EventKeyType::AnyEvent],
     });
diff --git a/testnet/stacks-node/src/tests/neon_integrations.rs b/testnet/stacks-node/src/tests/neon_integrations.rs
index e9664e46dc..02461ce840 100644
--- a/testnet/stacks-node/src/tests/neon_integrations.rs
+++ b/testnet/stacks-node/src/tests/neon_integrations.rs
@@ -777,7 +777,7 @@ fn bitcoind_integration_test() {
 
     test_observer::spawn();
 
-    conf.events_observers.push(EventObserverConfig {
+    conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
         events_keys: vec![EventKeyType::AnyEvent],
     });
@@ -1110,7 +1110,7 @@ fn deep_contract() {
 
     test_observer::spawn();
 
-    conf.events_observers.push(EventObserverConfig {
+    conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
         events_keys: vec![EventKeyType::AnyEvent],
     });
@@ -1214,7 +1214,7 @@ fn bad_microblock_pubkey() {
 
     test_observer::spawn();
 
-    conf.events_observers.push(EventObserverConfig {
+    conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
         events_keys: vec![EventKeyType::AnyEvent],
     });
@@ -1299,7 +1299,7 @@ fn liquid_ustx_integration() {
 
     test_observer::spawn();
 
-    conf.events_observers.push(EventObserverConfig {
+    conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
         events_keys: vec![EventKeyType::AnyEvent],
     });
@@ -1427,7 +1427,7 @@ fn lockup_integration() {
 
     test_observer::spawn();
 
-    conf.events_observers.push(EventObserverConfig {
+    conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
         events_keys: vec![EventKeyType::AnyEvent],
     });
@@ -1543,7 +1543,7 @@ fn stx_transfer_btc_integration_test() {
     let (mut conf, _miner_account) = neon_integration_test_conf();
 
     test_observer::spawn();
-    conf.events_observers.push(EventObserverConfig {
+    conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
         events_keys: vec![EventKeyType::AnyEvent],
     });
@@ -1812,7 +1812,7 @@ fn stx_delegate_btc_integration_test() {
     conf.burnchain.pox_2_activation = Some(3);
 
     test_observer::spawn();
-    conf.events_observers.push(EventObserverConfig {
+    conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
         events_keys: vec![EventKeyType::AnyEvent],
     });
@@ -2381,7 +2381,7 @@ fn microblock_fork_poison_integration_test() {
 
     test_observer::spawn();
 
-    conf.events_observers.push(EventObserverConfig {
+    conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
         events_keys: vec![EventKeyType::AnyEvent],
     });
@@ -2612,7 +2612,7 @@ fn microblock_integration_test() {
 
     test_observer::spawn();
 
-    conf.events_observers.push(EventObserverConfig {
+    conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
         events_keys: vec![EventKeyType::AnyEvent],
     });
@@ -3597,7 +3597,7 @@ fn size_overflow_unconfirmed_microblocks_integration_test() {
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
     test_observer::spawn();
-    conf.events_observers.push(EventObserverConfig {
+    conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
         events_keys: vec![EventKeyType::AnyEvent],
     });
@@ -3794,7 +3794,7 @@ fn size_overflow_unconfirmed_stream_microblocks_integration_test() {
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
     test_observer::spawn();
-    conf.events_observers.push(EventObserverConfig {
+    conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
         events_keys: vec![EventKeyType::AnyEvent],
     });
@@ -3989,7 +3989,7 @@ fn size_overflow_unconfirmed_invalid_stream_microblocks_integration_test() {
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
     test_observer::spawn();
-    conf.events_observers.push(EventObserverConfig {
+    conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
         events_keys: vec![EventKeyType::AnyEvent],
     });
@@ -4130,7 +4130,7 @@ fn runtime_overflow_unconfirmed_microblocks_integration_test() {
                     &format!("large-{}", ix),
                     &format!("
                         ;; a single one of these transactions consumes over half the runtime budget
-                        (define-constant BUFF_TO_BYTE (list 
+                        (define-constant BUFF_TO_BYTE (list
                            0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f
                            0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f
                            0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x2a 0x2b 0x2c 0x2d 0x2e 0x2f
@@ -4184,7 +4184,7 @@ fn runtime_overflow_unconfirmed_microblocks_integration_test() {
                         &format!("small-{}-{}", ix, i),
                         &format!("
                             ;; a single one of these transactions consumes over half the runtime budget
-                            (define-constant BUFF_TO_BYTE (list 
+                            (define-constant BUFF_TO_BYTE (list
                                0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f
                                0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f
                                0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x2a 0x2b 0x2c 0x2d 0x2e 0x2f
@@ -4256,7 +4256,7 @@ fn runtime_overflow_unconfirmed_microblocks_integration_test() {
     conf.burnchain.epochs = Some(epochs);
 
     test_observer::spawn();
-    conf.events_observers.push(EventObserverConfig {
+    conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
         events_keys: vec![EventKeyType::AnyEvent],
     });
@@ -4429,7 +4429,7 @@ fn block_replay_integration_test() {
 
     test_observer::spawn();
 
-    conf.events_observers.push(EventObserverConfig {
+    conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
         events_keys: vec![EventKeyType::AnyEvent],
     });
@@ -4561,7 +4561,7 @@ fn cost_voting_integration() {
 
     test_observer::spawn();
 
-    conf.events_observers.push(EventObserverConfig {
+    conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
         events_keys: vec![EventKeyType::AnyEvent],
     });
@@ -4880,7 +4880,7 @@ fn mining_events_integration_test() {
 
     test_observer::spawn();
 
-    conf.events_observers.push(EventObserverConfig {
+    conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
         events_keys: vec![
             EventKeyType::AnyEvent,
@@ -5044,7 +5044,7 @@ fn block_limit_hit_integration_test() {
 
     // 700 invocations
     let max_contract_src = format!(
-         "(define-private (work) (begin {} 1)) 
+         "(define-private (work) (begin {} 1))
          (define-private (times-100) (begin {} 1))
          (define-private (times-200) (begin (times-100) (times-100) 1))
          (define-private (times-500) (begin (times-200) (times-200) (times-100) 1))
@@ -5066,7 +5066,7 @@ fn block_limit_hit_integration_test() {
 
     // 2900 invocations
     let oversize_contract_src = format!(
-        "(define-private (work) (begin {} 1)) 
+        "(define-private (work) (begin {} 1))
          (define-private (times-100) (begin {} 1))
          (define-private (times-200) (begin (times-100) (times-100) 1))
          (define-private (times-500) (begin (times-200) (times-200) (times-100) 1))
@@ -5128,7 +5128,7 @@ fn block_limit_hit_integration_test() {
 
     test_observer::spawn();
 
-    conf.events_observers.push(EventObserverConfig {
+    conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
         events_keys: vec![EventKeyType::AnyEvent],
     });
@@ -5234,7 +5234,7 @@ fn microblock_limit_hit_integration_test() {
     }
 
     let max_contract_src = format!(
-        "(define-private (work) (begin {} 1)) 
+        "(define-private (work) (begin {} 1))
          (define-private (times-100) (begin {} 1))
          (define-private (times-200) (begin (times-100) (times-100) 1))
          (define-private (times-500) (begin (times-200) (times-200) (times-100) 1))
@@ -5255,7 +5255,7 @@ fn microblock_limit_hit_integration_test() {
     );
 
     let oversize_contract_src = format!(
-        "(define-private (work) (begin {} 1)) 
+        "(define-private (work) (begin {} 1))
          (define-private (times-100) (begin {} 1))
          (define-private (times-200) (begin (times-100) (times-100) 1))
          (define-private (times-500) (begin (times-200) (times-200) (times-100) 1))
@@ -5384,7 +5384,7 @@ fn microblock_limit_hit_integration_test() {
 
     test_observer::spawn();
 
-    conf.events_observers.push(EventObserverConfig {
+    conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
         events_keys: vec![EventKeyType::AnyEvent],
     });
@@ -5534,7 +5534,7 @@ fn block_large_tx_integration_test() {
     let (mut conf, miner_account) = neon_integration_test_conf();
     test_observer::spawn();
 
-    conf.events_observers.push(EventObserverConfig {
+    conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
         events_keys: vec![EventKeyType::AnyEvent],
     });
@@ -5673,7 +5673,7 @@ fn microblock_large_tx_integration_test_FLAKY() {
 
     test_observer::spawn();
 
-    conf.events_observers.push(EventObserverConfig {
+    conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
         events_keys: vec![EventKeyType::AnyEvent],
     });
@@ -5812,7 +5812,7 @@ fn pox_integration_test() {
     // required for testing post-sunset behavior
     conf.node.always_use_affirmation_maps = false;
 
-    conf.events_observers.push(EventObserverConfig {
+    conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
         events_keys: vec![EventKeyType::AnyEvent],
     });
@@ -6349,7 +6349,7 @@ fn atlas_integration_test() {
         .push(initial_balance_user_1.clone());
     conf_follower_node
         .events_observers
-        .push(EventObserverConfig {
+        .insert(EventObserverConfig {
             endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
             events_keys: vec![EventKeyType::AnyEvent],
         });
@@ -6889,7 +6889,7 @@ fn antientropy_integration_test() {
         .push(initial_balance_user_1.clone());
     conf_follower_node
         .events_observers
-        .push(EventObserverConfig {
+        .insert(EventObserverConfig {
             endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
             events_keys: vec![EventKeyType::AnyEvent],
         });
@@ -7891,7 +7891,7 @@ fn fuzzed_median_fee_rate_estimation_test(window_size: u64, expected_final_value
         amount: 10000000000,
     });
     test_observer::spawn();
-    conf.events_observers.push(EventObserverConfig {
+    conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
         events_keys: vec![EventKeyType::AnyEvent],
     });
@@ -8071,7 +8071,7 @@ fn use_latest_tip_integration_test() {
 
     test_observer::spawn();
 
-    conf.events_observers.push(EventObserverConfig {
+    conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
         events_keys: vec![EventKeyType::AnyEvent],
     });
@@ -8465,7 +8465,7 @@ fn test_problematic_txs_are_not_stored() {
 
     test_observer::spawn();
 
-    conf.events_observers.push(EventObserverConfig {
+    conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
         events_keys: vec![EventKeyType::AnyEvent],
     });
@@ -8617,7 +8617,7 @@ fn spawn_follower_node(
         conf.burnchain.peer_version,
     );
 
-    conf.events_observers.push(EventObserverConfig {
+    conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
         events_keys: vec![EventKeyType::AnyEvent],
     });
@@ -8716,7 +8716,7 @@ fn test_problematic_blocks_are_not_mined() {
 
     test_observer::spawn();
 
-    conf.events_observers.push(EventObserverConfig {
+    conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
         events_keys: vec![EventKeyType::AnyEvent],
     });
@@ -9074,7 +9074,7 @@ fn test_problematic_blocks_are_not_relayed_or_stored() {
 
     test_observer::spawn();
 
-    conf.events_observers.push(EventObserverConfig {
+    conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
         events_keys: vec![EventKeyType::AnyEvent],
     });
@@ -9468,7 +9468,7 @@ fn test_problematic_microblocks_are_not_mined() {
 
     test_observer::spawn();
 
-    conf.events_observers.push(EventObserverConfig {
+    conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
         events_keys: vec![EventKeyType::AnyEvent],
     });
@@ -9854,7 +9854,7 @@ fn test_problematic_microblocks_are_not_relayed_or_stored() {
 
     test_observer::spawn();
 
-    conf.events_observers.push(EventObserverConfig {
+    conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
         events_keys: vec![EventKeyType::AnyEvent],
     });
@@ -10205,7 +10205,7 @@ fn push_boot_receipts() {
     }
 
     let (mut conf, _) = neon_integration_test_conf();
-    conf.events_observers.push(EventObserverConfig {
+    conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
         events_keys: vec![EventKeyType::AnyEvent],
     });
@@ -10253,7 +10253,7 @@ fn run_with_custom_wallet() {
     }
 
     let (mut conf, _) = neon_integration_test_conf();
-    conf.events_observers.push(EventObserverConfig {
+    conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
         events_keys: vec![EventKeyType::AnyEvent],
     });
@@ -10327,7 +10327,7 @@ fn make_runtime_sized_contract(num_index_of: usize, nonce: u64, addr_prefix: &st
 
     let code = format!(
         "
-        (define-constant BUFF_TO_BYTE (list 
+        (define-constant BUFF_TO_BYTE (list
            0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f
            0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f
            0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x2a 0x2b 0x2c 0x2d 0x2e 0x2f
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index f064c5ed84..7c459b5e4f 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -70,7 +70,7 @@ fn setup_stx_btc_node(
     for toml in signer_config_tomls {
         let signer_config = SignerConfig::load_from_str(toml).unwrap();
 
-        conf.events_observers.push(EventObserverConfig {
+        conf.events_observers.insert(EventObserverConfig {
             endpoint: format!("{}", signer_config.endpoint),
             events_keys: vec![EventKeyType::StackerDBChunks],
         });

From 83702137a31ffb2382dbb867f77dfc4003b71dd5 Mon Sep 17 00:00:00 2001
From: ASuciuX <asuciu@hiro.so>
Date: Sat, 25 Nov 2023 00:38:51 +0200
Subject: [PATCH 0027/1166] feat: mutation testing initial integration

- dockerfile and shell script for specific packages
- ci.yml for diff on packages on PR
---
 .../Dockerfile.mutation-testing               | 29 ++++++++++++++++
 .github/workflows/ci.yml                      | 29 ++++++++++++++--
 .gitignore                                    |  1 +
 mutants-testing-general.sh                    | 34 +++++++++++++++++++
 4 files changed, 91 insertions(+), 2 deletions(-)
 create mode 100644 .github/actions/bitcoin-int-tests/Dockerfile.mutation-testing
 create mode 100644 mutants-testing-general.sh

diff --git a/.github/actions/bitcoin-int-tests/Dockerfile.mutation-testing b/.github/actions/bitcoin-int-tests/Dockerfile.mutation-testing
new file mode 100644
index 0000000000..2d26551a08
--- /dev/null
+++ b/.github/actions/bitcoin-int-tests/Dockerfile.mutation-testing
@@ -0,0 +1,29 @@
+FROM rust:bullseye
+
+# Set the working directory in the container
+WORKDIR /src
+
+# Copy all the files into the container
+COPY . .
+
+# Update rustup and build the project
+RUN rustup update
+
+# Install cargo-mutants
+RUN cargo install cargo-mutants
+
+# Make a directory for mutants
+RUN mkdir -p mutants
+
+# Run mutants for different packages
+RUN cargo mutants --package clarity --output mutants/clarity
+RUN cargo mutants --package libsigner --output mutants/libsigner 
+# RUN cargo mutants --package libstackerdb --output mutants/libstackerdb 
+# RUN cargo mutants --package pox-locking --output mutants/pox-locking 
+# RUN cargo mutants --package stacks-common --output mutants/stacks-common
+# RUN cargo mutants --package stx-genesis --output mutants/stx-genesis
+
+# Comment out the commands for 'stacks-node' and 'stackslib' following the mutants.sh script
+# RUN cargo mutants --package stacks-signer --output mutants/stacks-signer
+# RUN cargo mutants --package stacks-node --output mutants/stacks-node
+# RUN cargo mutants --package stackslib --output mutants/stackslib
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 605b0818c0..4252e729f9 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -13,7 +13,7 @@ on:
   workflow_dispatch:
     inputs:
       tag:
-        description: "The tag to create (optional)"
+        description: 'The tag to create (optional)'
         required: false
 
 concurrency:
@@ -38,7 +38,7 @@ jobs:
         with:
           toolchain: ${{ env.RUST_TOOLCHAIN }}
           components: rustfmt
-      - name: Rustfmt 
+      - name: Rustfmt
         id: rustfmt
         uses: actions-rust-lang/rustfmt@v1
 
@@ -75,6 +75,31 @@ jobs:
           base: ${{ env.BRANCH_NAME }}
           head: HEAD
 
+  ## Mutants testing: Execute on PR on packages that have tested functions modified
+  incremental-mutants:
+    name: Incremental Mutants Testing
+    runs-on: ubuntu-latest
+    if: github.event_name == 'pull_request'
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+      - name: Relative diff
+        run: |
+          git branch -av
+          git diff origin/${{ github.base_ref }}.. | tee git.diff
+      - uses: Swatinem/rust-cache@v2
+      - run: cargo install cargo-mutants
+      - name: Mutants
+        run: |
+          cargo mutants --no-shuffle -j 2 -vV --in-diff git.diff || true
+      - name: Archive mutants.out
+        uses: actions/upload-artifact@v3
+        if: always()
+        with:
+          name: mutants-incremental.out
+          path: mutants.out
+
   ###############################################
   ## Build Tagged Release
   ###############################################
diff --git a/.gitignore b/.gitignore
index 5069c47120..ef04f35d59 100644
--- a/.gitignore
+++ b/.gitignore
@@ -23,6 +23,7 @@ pip-log.txt
 .coverage
 .tox
 nosetests.xml
+mutants.out*
 
 # Translations
 *.mo
diff --git a/mutants-testing-general.sh b/mutants-testing-general.sh
new file mode 100644
index 0000000000..aa0f0e81e7
--- /dev/null
+++ b/mutants-testing-general.sh
@@ -0,0 +1,34 @@
+#!/bin/bash
+
+# Create mutants directory
+mkdir mutants
+
+### Run mutation testing on the packages uncommented
+
+# Run mutation testing for clarity package
+cargo mutants --package clarity --output mutants/clarity
+
+# Run mutation testing for libsigner package
+cargo mutants --package libsigner --output mutants/libsigner
+
+# Run mutation testing for libstackerdb package
+cargo mutants --package libstackerdb --output mutants/libstackerdb
+
+# Run mutation testing for pox-locking package
+cargo mutants --package pox-locking --output mutants/pox-locking
+
+# Run mutation testing for stacks-common package
+cargo mutants --package stacks-common --output mutants/stacks-common
+
+# Run mutation testing for stx-genesis package
+cargo mutants --package stx-genesis --output mutants/stx-genesis
+
+
+# Run mutation testing for stacks-signer package - working, 10 min approx. 
+# cargo mutants --package stacks-signer --output mutants/stacks-signer
+
+# Commented out mutation testing for stacks-node package due to test errors and long compile/testing time
+# cargo mutants --package stacks-node --output mutants/stacks-node
+
+# Commented out mutation testing for stackslib package due to long compile/testing time
+# cargo mutants --package stackslib --output mutants/stackslib

From 1c5a75c9b36956347d8da9336ad54d41ce7263f3 Mon Sep 17 00:00:00 2001
From: ASuciuX <asuciu@hiro.so>
Date: Sat, 25 Nov 2023 01:13:14 +0200
Subject: [PATCH 0028/1166] fix: made functions discoverable to be mutants

---
 clarity/Cargo.toml                    | 2 +-
 clarity/src/{libclarity.rs => mod.rs} | 0
 2 files changed, 1 insertion(+), 1 deletion(-)
 rename clarity/src/{libclarity.rs => mod.rs} (100%)

diff --git a/clarity/Cargo.toml b/clarity/Cargo.toml
index 86089991dc..791e981015 100644
--- a/clarity/Cargo.toml
+++ b/clarity/Cargo.toml
@@ -15,7 +15,7 @@ resolver = "2"
 
 [lib]
 name = "clarity"
-path = "./src/libclarity.rs"
+path = "./src/mod.rs"
 
 [dependencies]
 rand = "0.7.3"
diff --git a/clarity/src/libclarity.rs b/clarity/src/mod.rs
similarity index 100%
rename from clarity/src/libclarity.rs
rename to clarity/src/mod.rs

From 19f56ea3fb72c205cf808088c855801a2684fda8 Mon Sep 17 00:00:00 2001
From: ASuciuX <asuciu@hiro.so>
Date: Mon, 27 Nov 2023 15:54:09 +0200
Subject: [PATCH 0029/1166] feat: added mutants output before fix clarity
 package

---
 .gitignore                                |   1 -
 clarity/Cargo.toml                        |   2 +-
 clarity/src/{mod.rs => libclarity.rs}     |   0
 mutants/clarity/mutants.out/caught.txt    |   0
 mutants/clarity/mutants.out/lock.json     |   6 +
 mutants/clarity/mutants.out/missed.txt    |   2 +
 mutants/clarity/mutants.out/mutants.json  |  38 +++++
 mutants/clarity/mutants.out/outcomes.json | 179 ++++++++++++++++++++++
 mutants/clarity/mutants.out/timeout.txt   |   0
 mutants/clarity/mutants.out/unviable.txt  |   2 +
 10 files changed, 228 insertions(+), 2 deletions(-)
 rename clarity/src/{mod.rs => libclarity.rs} (100%)
 create mode 100644 mutants/clarity/mutants.out/caught.txt
 create mode 100644 mutants/clarity/mutants.out/lock.json
 create mode 100644 mutants/clarity/mutants.out/missed.txt
 create mode 100644 mutants/clarity/mutants.out/mutants.json
 create mode 100644 mutants/clarity/mutants.out/outcomes.json
 create mode 100644 mutants/clarity/mutants.out/timeout.txt
 create mode 100644 mutants/clarity/mutants.out/unviable.txt

diff --git a/.gitignore b/.gitignore
index ef04f35d59..5069c47120 100644
--- a/.gitignore
+++ b/.gitignore
@@ -23,7 +23,6 @@ pip-log.txt
 .coverage
 .tox
 nosetests.xml
-mutants.out*
 
 # Translations
 *.mo
diff --git a/clarity/Cargo.toml b/clarity/Cargo.toml
index 791e981015..86089991dc 100644
--- a/clarity/Cargo.toml
+++ b/clarity/Cargo.toml
@@ -15,7 +15,7 @@ resolver = "2"
 
 [lib]
 name = "clarity"
-path = "./src/mod.rs"
+path = "./src/libclarity.rs"
 
 [dependencies]
 rand = "0.7.3"
diff --git a/clarity/src/mod.rs b/clarity/src/libclarity.rs
similarity index 100%
rename from clarity/src/mod.rs
rename to clarity/src/libclarity.rs
diff --git a/mutants/clarity/mutants.out/caught.txt b/mutants/clarity/mutants.out/caught.txt
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/mutants/clarity/mutants.out/lock.json b/mutants/clarity/mutants.out/lock.json
new file mode 100644
index 0000000000..d975e39ebd
--- /dev/null
+++ b/mutants/clarity/mutants.out/lock.json
@@ -0,0 +1,6 @@
+{
+  "cargo_mutants_version": "23.11.1",
+  "start_time": "2023-11-27T13:34:56.627198Z",
+  "hostname": "asuciu-macbook-pro.local",
+  "username": "asuciu"
+}
diff --git a/mutants/clarity/mutants.out/missed.txt b/mutants/clarity/mutants.out/missed.txt
new file mode 100644
index 0000000000..57aa211996
--- /dev/null
+++ b/mutants/clarity/mutants.out/missed.txt
@@ -0,0 +1,2 @@
+clarity/src/libclarity.rs:96: replace version_string -> String with String::new()
+clarity/src/libclarity.rs:96: replace version_string -> String with "xyzzy".into()
diff --git a/mutants/clarity/mutants.out/mutants.json b/mutants/clarity/mutants.out/mutants.json
new file mode 100644
index 0000000000..c2671c1849
--- /dev/null
+++ b/mutants/clarity/mutants.out/mutants.json
@@ -0,0 +1,38 @@
+[
+  {
+    "package": "clarity",
+    "file": "clarity/src/libclarity.rs",
+    "line": 81,
+    "function": "boot_util::boot_code_addr",
+    "return_type": "-> StacksAddress",
+    "replacement": "Default::default()",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/libclarity.rs",
+    "line": 96,
+    "function": "version_string",
+    "return_type": "-> String",
+    "replacement": "String::new()",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/libclarity.rs",
+    "line": 73,
+    "function": "boot_util::boot_code_id",
+    "return_type": "-> QualifiedContractIdentifier",
+    "replacement": "Default::default()",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/libclarity.rs",
+    "line": 96,
+    "function": "version_string",
+    "return_type": "-> String",
+    "replacement": "\"xyzzy\".into()",
+    "genre": "FnValue"
+  }
+]
\ No newline at end of file
diff --git a/mutants/clarity/mutants.out/outcomes.json b/mutants/clarity/mutants.out/outcomes.json
new file mode 100644
index 0000000000..b9556f45a0
--- /dev/null
+++ b/mutants/clarity/mutants.out/outcomes.json
@@ -0,0 +1,179 @@
+{
+  "outcomes": [
+    {
+      "scenario": "Baseline",
+      "log_path": "mutants/clarity/mutants.out/log/baseline.log",
+      "summary": "Success",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 46.04112825,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-HHiHlU.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 13.555701334,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-HHiHlU.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/libclarity.rs",
+          "line": 81,
+          "function": "boot_util::boot_code_addr",
+          "return_type": "-> StacksAddress",
+          "replacement": "Default::default()",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "mutants/clarity/mutants.out/log/clarity__src__libclarity.rs_line_81.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 2.030609209,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-HHiHlU.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/libclarity.rs",
+          "line": 96,
+          "function": "version_string",
+          "return_type": "-> String",
+          "replacement": "String::new()",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "mutants/clarity/mutants.out/log/clarity__src__libclarity.rs_line_96.log",
+      "summary": "MissedMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 6.272183792,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-HHiHlU.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 3.609116292,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-HHiHlU.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/libclarity.rs",
+          "line": 73,
+          "function": "boot_util::boot_code_id",
+          "return_type": "-> QualifiedContractIdentifier",
+          "replacement": "Default::default()",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "mutants/clarity/mutants.out/log/clarity__src__libclarity.rs_line_73.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 1.755918375,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-HHiHlU.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/libclarity.rs",
+          "line": 96,
+          "function": "version_string",
+          "return_type": "-> String",
+          "replacement": "\"xyzzy\".into()",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "mutants/clarity/mutants.out/log/clarity__src__libclarity.rs_line_96_001.log",
+      "summary": "MissedMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 5.987611125,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-HHiHlU.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 3.399572666,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-HHiHlU.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    }
+  ],
+  "total_mutants": 4,
+  "missed": 2,
+  "caught": 0,
+  "timeout": 0,
+  "unviable": 2,
+  "success": 0,
+  "failure": 0
+}
\ No newline at end of file
diff --git a/mutants/clarity/mutants.out/timeout.txt b/mutants/clarity/mutants.out/timeout.txt
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/mutants/clarity/mutants.out/unviable.txt b/mutants/clarity/mutants.out/unviable.txt
new file mode 100644
index 0000000000..9e7caf81c0
--- /dev/null
+++ b/mutants/clarity/mutants.out/unviable.txt
@@ -0,0 +1,2 @@
+clarity/src/libclarity.rs:81: replace boot_util::boot_code_addr -> StacksAddress with Default::default()
+clarity/src/libclarity.rs:73: replace boot_util::boot_code_id -> QualifiedContractIdentifier with Default::default()

From a3caebb32fb5b44925e642aecef70ae123d85388 Mon Sep 17 00:00:00 2001
From: ASuciuX <asuciu@hiro.so>
Date: Mon, 27 Nov 2023 16:32:58 +0200
Subject: [PATCH 0030/1166] feat: added mutants output after fix clarity
 package

---
 clarity/Cargo.toml                        |    2 +-
 clarity/src/{libclarity.rs => mod.rs}     |    0
 mutants/clarity/mutants.out/caught.txt    |   54 +
 mutants/clarity/mutants.out/lock.json     |    2 +-
 mutants/clarity/mutants.out/missed.txt    |   26 +-
 mutants/clarity/mutants.out/mutants.json  | 1247 +++++-
 mutants/clarity/mutants.out/outcomes.json | 4837 ++++++++++++++++++++-
 mutants/clarity/mutants.out/unviable.txt  |   63 +-
 8 files changed, 6166 insertions(+), 65 deletions(-)
 rename clarity/src/{libclarity.rs => mod.rs} (100%)

diff --git a/clarity/Cargo.toml b/clarity/Cargo.toml
index 86089991dc..791e981015 100644
--- a/clarity/Cargo.toml
+++ b/clarity/Cargo.toml
@@ -15,7 +15,7 @@ resolver = "2"
 
 [lib]
 name = "clarity"
-path = "./src/libclarity.rs"
+path = "./src/mod.rs"
 
 [dependencies]
 rand = "0.7.3"
diff --git a/clarity/src/libclarity.rs b/clarity/src/mod.rs
similarity index 100%
rename from clarity/src/libclarity.rs
rename to clarity/src/mod.rs
diff --git a/mutants/clarity/mutants.out/caught.txt b/mutants/clarity/mutants.out/caught.txt
index e69de29bb2..7325042f1c 100644
--- a/mutants/clarity/mutants.out/caught.txt
+++ b/mutants/clarity/mutants.out/caught.txt
@@ -0,0 +1,54 @@
+clarity/src/vm/types/signatures.rs:1923: replace <impl Display for StringUTF8Length>::fmt -> fmt::Result with Ok(Default::default())
+clarity/src/vm/types/signatures.rs:1652: replace TypeSignature::size -> u32 with 0
+clarity/src/vm/types/signatures.rs:524: replace TypeSignature::admits_type -> Result<bool> with Ok(false)
+clarity/src/vm/types/signatures.rs:1862: replace <impl Debug for TupleTypeSignature>::fmt -> fmt::Result with Ok(Default::default())
+clarity/src/vm/types/signatures.rs:1722: replace ListTypeData::inner_size -> Option<u32> with Some(1)
+clarity/src/vm/types/signatures.rs:524: replace TypeSignature::admits_type -> Result<bool> with Ok(true)
+clarity/src/vm/types/signatures.rs:1782: replace TupleTypeSignature::inner_size -> Option<u32> with None
+clarity/src/vm/types/signatures.rs:848: replace TupleTypeSignature::len -> u64 with 0
+clarity/src/vm/types/signatures.rs:1652: replace TypeSignature::size -> u32 with 1
+clarity/src/vm/types/signatures.rs:1658: replace TypeSignature::inner_size -> Option<u32> with Some(1)
+clarity/src/vm/types/signatures.rs:341: replace <impl From for u32>::from -> u32 with 0
+clarity/src/vm/types/signatures.rs:515: replace TypeSignature::is_no_type -> bool with true
+clarity/src/vm/types/signatures.rs:1722: replace ListTypeData::inner_size -> Option<u32> with None
+clarity/src/vm/types/signatures.rs:515: replace TypeSignature::is_no_type -> bool with false
+clarity/src/vm/types/signatures.rs:394: replace <impl From for u32>::from -> u32 with 0
+clarity/src/vm/types/signatures.rs:1748: replace TupleTypeSignature::type_size -> Option<u32> with None
+clarity/src/vm/types/signatures.rs:1722: replace ListTypeData::inner_size -> Option<u32> with Some(0)
+clarity/src/vm/types/signatures.rs:388: replace <impl From for u32>::from -> u32 with 0
+clarity/src/vm/types/signatures.rs:1883: replace <impl Display for TypeSignature>::fmt -> fmt::Result with Ok(Default::default())
+clarity/src/vm/types/signatures.rs:394: replace <impl From for u32>::from -> u32 with 1
+clarity/src/vm/types/signatures.rs:1782: replace TupleTypeSignature::inner_size -> Option<u32> with Some(1)
+clarity/src/vm/types/signatures.rs:624: replace TypeSignature::admits_type_v2_1 -> Result<bool> with Ok(true)
+clarity/src/vm/types/signatures.rs:511: replace TypeSignature::is_response_type -> bool with false
+clarity/src/vm/types/signatures.rs:347: replace <impl From for u32>::from -> u32 with 1
+clarity/src/vm/types/signatures.rs:476: replace ListTypeData::get_max_len -> u32 with 0
+clarity/src/vm/types/signatures.rs:476: replace ListTypeData::get_max_len -> u32 with 1
+clarity/src/vm/types/signatures.rs:1735: replace ListTypeData::type_size -> Option<u32> with None
+clarity/src/vm/types/signatures.rs:857: replace TupleTypeSignature::field_type -> Option<&TypeSignature> with None
+clarity/src/vm/types/signatures.rs:341: replace <impl From for u32>::from -> u32 with 1
+clarity/src/vm/types/signatures.rs:865: replace TupleTypeSignature::admits -> Result<bool> with Ok(true)
+clarity/src/vm/types/signatures.rs:1917: replace <impl Display for BufferLength>::fmt -> fmt::Result with Ok(Default::default())
+clarity/src/vm/types/signatures.rs:1658: replace TypeSignature::inner_size -> Option<u32> with Some(0)
+clarity/src/vm/types/signatures.rs:848: replace TupleTypeSignature::len -> u64 with 1
+clarity/src/vm/types/signatures.rs:926: replace FunctionSignature::check_args_trait_compliance -> Result<bool> with Ok(true)
+clarity/src/vm/types/signatures.rs:926: replace FunctionSignature::check_args_trait_compliance -> Result<bool> with Ok(false)
+clarity/src/vm/types/signatures.rs:535: replace TypeSignature::admits_type_v2_0 -> Result<bool> with Ok(true)
+clarity/src/vm/types/signatures.rs:624: replace TypeSignature::admits_type_v2_1 -> Result<bool> with Ok(false)
+clarity/src/vm/types/signatures.rs:1782: replace TupleTypeSignature::inner_size -> Option<u32> with Some(0)
+clarity/src/vm/types/signatures.rs:388: replace <impl From for u32>::from -> u32 with 1
+clarity/src/vm/types/signatures.rs:535: replace TypeSignature::admits_type_v2_0 -> Result<bool> with Ok(false)
+clarity/src/vm/types/signatures.rs:1551: replace TypeSignature::parse_trait_type_repr -> Result<BTreeMap<ClarityName, FunctionSignature>> with Ok(BTreeMap::new())
+clarity/src/vm/types/signatures.rs:865: replace TupleTypeSignature::admits -> Result<bool> with Ok(false)
+clarity/src/vm/types/signatures.rs:470: replace ListTypeData::reduce_max_len with ()
+clarity/src/vm/types/signatures.rs:519: replace TypeSignature::admits -> Result<bool> with Ok(false)
+clarity/src/vm/types/signatures.rs:1658: replace TypeSignature::inner_size -> Option<u32> with None
+clarity/src/vm/types/signatures.rs:1852: replace <impl Display for TupleTypeSignature>::fmt -> fmt::Result with Ok(Default::default())
+clarity/src/vm/types/signatures.rs:511: replace TypeSignature::is_response_type -> bool with true
+clarity/src/vm/types/signatures.rs:1696: replace TypeSignature::inner_type_size -> Option<u32> with None
+clarity/src/vm/types/signatures.rs:519: replace TypeSignature::admits -> Result<bool> with Ok(true)
+clarity/src/vm/types/signatures.rs:347: replace <impl From for u32>::from -> u32 with 0
+clarity/src/vm/types/signatures.rs:1812: replace parse_name_type_pairs -> Result<Vec<(ClarityName, TypeSignature)>> with Ok(vec![])
+clarity/src/vm/types/signatures.rs:1627: replace TypeSignature::depth -> u8 with 1
+clarity/src/vm/types/signatures.rs:896: replace TupleTypeSignature::shallow_merge with ()
+clarity/src/vm/types/signatures.rs:1627: replace TypeSignature::depth -> u8 with 0
diff --git a/mutants/clarity/mutants.out/lock.json b/mutants/clarity/mutants.out/lock.json
index d975e39ebd..d5fceb8673 100644
--- a/mutants/clarity/mutants.out/lock.json
+++ b/mutants/clarity/mutants.out/lock.json
@@ -1,6 +1,6 @@
 {
   "cargo_mutants_version": "23.11.1",
-  "start_time": "2023-11-27T13:34:56.627198Z",
+  "start_time": "2023-11-27T14:07:14.518556Z",
   "hostname": "asuciu-macbook-pro.local",
   "username": "asuciu"
 }
diff --git a/mutants/clarity/mutants.out/missed.txt b/mutants/clarity/mutants.out/missed.txt
index 57aa211996..93210d252c 100644
--- a/mutants/clarity/mutants.out/missed.txt
+++ b/mutants/clarity/mutants.out/missed.txt
@@ -1,2 +1,24 @@
-clarity/src/libclarity.rs:96: replace version_string -> String with String::new()
-clarity/src/libclarity.rs:96: replace version_string -> String with "xyzzy".into()
+clarity/src/vm/types/signatures.rs:902: replace FixedFunction::total_type_size -> Result<u64> with Ok(0)
+clarity/src/vm/types/signatures.rs:69: replace AssetIdentifier::sugared -> String with "xyzzy".into()
+clarity/src/vm/types/signatures.rs:913: replace FunctionSignature::total_type_size -> Result<u64> with Ok(1)
+clarity/src/vm/types/signatures.rs:139: replace SequenceSubtype::is_list_type -> bool with false
+clarity/src/vm/types/signatures.rs:1690: replace TypeSignature::type_size -> Result<u32> with Ok(1)
+clarity/src/vm/types/signatures.rs:139: replace SequenceSubtype::is_list_type -> bool with true
+clarity/src/vm/types/signatures.rs:1735: replace ListTypeData::type_size -> Option<u32> with Some(0)
+clarity/src/vm/types/signatures.rs:1696: replace TypeSignature::inner_type_size -> Option<u32> with Some(0)
+clarity/src/vm/types/signatures.rs:1872: replace <impl Display for AssetIdentifier>::fmt -> fmt::Result with Ok(Default::default())
+clarity/src/vm/types/signatures.rs:1696: replace TypeSignature::inner_type_size -> Option<u32> with Some(1)
+clarity/src/vm/types/signatures.rs:1766: replace TupleTypeSignature::size -> u32 with 1
+clarity/src/vm/types/signatures.rs:1929: replace <impl Display for FunctionArg>::fmt -> fmt::Result with Ok(Default::default())
+clarity/src/vm/types/signatures.rs:1748: replace TupleTypeSignature::type_size -> Option<u32> with Some(1)
+clarity/src/vm/types/signatures.rs:1735: replace ListTypeData::type_size -> Option<u32> with Some(1)
+clarity/src/vm/types/signatures.rs:853: replace TupleTypeSignature::is_empty -> bool with true
+clarity/src/vm/types/signatures.rs:1766: replace TupleTypeSignature::size -> u32 with 0
+clarity/src/vm/types/signatures.rs:913: replace FunctionSignature::total_type_size -> Result<u64> with Ok(0)
+clarity/src/vm/types/signatures.rs:902: replace FixedFunction::total_type_size -> Result<u64> with Ok(1)
+clarity/src/vm/types/signatures.rs:69: replace AssetIdentifier::sugared -> String with String::new()
+clarity/src/vm/types/signatures.rs:1748: replace TupleTypeSignature::type_size -> Option<u32> with Some(0)
+clarity/src/vm/types/signatures.rs:1771: replace TupleTypeSignature::max_depth -> u8 with 0
+clarity/src/vm/types/signatures.rs:853: replace TupleTypeSignature::is_empty -> bool with false
+clarity/src/vm/types/signatures.rs:1771: replace TupleTypeSignature::max_depth -> u8 with 1
+clarity/src/vm/types/signatures.rs:1690: replace TypeSignature::type_size -> Result<u32> with Ok(0)
diff --git a/mutants/clarity/mutants.out/mutants.json b/mutants/clarity/mutants.out/mutants.json
index c2671c1849..23c0f4d577 100644
--- a/mutants/clarity/mutants.out/mutants.json
+++ b/mutants/clarity/mutants.out/mutants.json
@@ -1,38 +1,1253 @@
 [
   {
     "package": "clarity",
-    "file": "clarity/src/libclarity.rs",
-    "line": 81,
-    "function": "boot_util::boot_code_addr",
-    "return_type": "-> StacksAddress",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1923,
+    "function": "<impl Display for StringUTF8Length>::fmt",
+    "return_type": "-> fmt::Result",
+    "replacement": "Ok(Default::default())",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 401,
+    "function": "<impl TryFrom for StringUTF8Length>::try_from",
+    "return_type": "-> Result<StringUTF8Length>",
+    "replacement": "Ok(Default::default())",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1349,
+    "function": "TypeSignature::construct_parent_list_type",
+    "return_type": "-> Result<ListTypeData>",
+    "replacement": "Ok(Default::default())",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1652,
+    "function": "TypeSignature::size",
+    "return_type": "-> u32",
+    "replacement": "0",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 498,
+    "function": "TypeSignature::new_response",
+    "return_type": "-> Result<TypeSignature>",
+    "replacement": "Ok(Default::default())",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 902,
+    "function": "FixedFunction::total_type_size",
+    "return_type": "-> Result<u64>",
+    "replacement": "Ok(0)",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 721,
+    "function": "TypeSignature::canonicalize",
+    "return_type": "-> TypeSignature",
+    "replacement": "Default::default()",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 243,
+    "function": "FunctionArgSignature::canonicalize",
+    "return_type": "-> FunctionArgSignature",
+    "replacement": "Default::default()",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1862,
+    "function": "<impl Debug for TupleTypeSignature>::fmt",
+    "return_type": "-> fmt::Result",
+    "replacement": "Ok(Default::default())",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 524,
+    "function": "TypeSignature::admits_type",
+    "return_type": "-> Result<bool>",
+    "replacement": "Ok(false)",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1356,
+    "function": "TypeSignature::parent_list_type",
+    "return_type": "-> std::result::Result<ListTypeData, CheckErrors>",
+    "replacement": "Ok(Default::default())",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1722,
+    "function": "ListTypeData::inner_size",
+    "return_type": "-> Option<u32>",
+    "replacement": "Some(1)",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 464,
+    "function": "ListTypeData::destruct",
+    "return_type": "-> (TypeSignature, u32)",
+    "replacement": "(Default::default(), 0)",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 524,
+    "function": "TypeSignature::admits_type",
+    "return_type": "-> Result<bool>",
+    "replacement": "Ok(true)",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 69,
+    "function": "AssetIdentifier::sugared",
+    "return_type": "-> String",
+    "replacement": "\"xyzzy\".into()",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 913,
+    "function": "FunctionSignature::total_type_size",
+    "return_type": "-> Result<u64>",
+    "replacement": "Ok(1)",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1782,
+    "function": "TupleTypeSignature::inner_size",
+    "return_type": "-> Option<u32>",
+    "replacement": "None",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 128,
+    "function": "SequenceSubtype::unit_type",
+    "return_type": "-> TypeSignature",
+    "replacement": "Default::default()",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 139,
+    "function": "SequenceSubtype::is_list_type",
+    "return_type": "-> bool",
+    "replacement": "false",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1463,
+    "function": "TypeSignature::parse_optional_type_repr",
+    "return_type": "-> Result<TypeSignature>",
+    "replacement": "Ok(Default::default())",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1652,
+    "function": "TypeSignature::size",
+    "return_type": "-> u32",
+    "replacement": "1",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 848,
+    "function": "TupleTypeSignature::len",
+    "return_type": "-> u64",
+    "replacement": "0",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1690,
+    "function": "TypeSignature::type_size",
+    "return_type": "-> Result<u32>",
+    "replacement": "Ok(1)",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1658,
+    "function": "TypeSignature::inner_size",
+    "return_type": "-> Option<u32>",
+    "replacement": "Some(1)",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 139,
+    "function": "SequenceSubtype::is_list_type",
+    "return_type": "-> bool",
+    "replacement": "true",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 341,
+    "function": "<impl From for u32>::from",
+    "return_type": "-> u32",
+    "replacement": "0",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1305,
+    "function": "TypeSignature::empty_list",
+    "return_type": "-> ListTypeData",
+    "replacement": "Default::default()",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1417,
+    "function": "TypeSignature::parse_buff_type_repr",
+    "return_type": "-> Result<TypeSignature>",
+    "replacement": "Ok(Default::default())",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 273,
+    "function": "FunctionType::canonicalize",
+    "return_type": "-> FunctionType",
+    "replacement": "Default::default()",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 515,
+    "function": "TypeSignature::is_no_type",
+    "return_type": "-> bool",
+    "replacement": "false",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 992,
+    "function": "TypeSignature::max_buffer",
+    "return_type": "-> TypeSignature",
+    "replacement": "Default::default()",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 515,
+    "function": "TypeSignature::is_no_type",
+    "return_type": "-> bool",
+    "replacement": "true",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 486,
+    "function": "TypeSignature::new_option",
+    "return_type": "-> Result<TypeSignature>",
+    "replacement": "Ok(Default::default())",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 394,
+    "function": "<impl From for u32>::from",
+    "return_type": "-> u32",
+    "replacement": "0",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1722,
+    "function": "ListTypeData::inner_size",
+    "return_type": "-> Option<u32>",
+    "replacement": "None",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1748,
+    "function": "TupleTypeSignature::type_size",
+    "return_type": "-> Option<u32>",
+    "replacement": "None",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1722,
+    "function": "ListTypeData::inner_size",
+    "return_type": "-> Option<u32>",
+    "replacement": "Some(0)",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1339,
+    "function": "TypeSignature::literal_type_of",
+    "return_type": "-> TypeSignature",
+    "replacement": "Default::default()",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1312,
+    "function": "TypeSignature::type_of",
+    "return_type": "-> TypeSignature",
+    "replacement": "Default::default()",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 388,
+    "function": "<impl From for u32>::from",
+    "return_type": "-> u32",
+    "replacement": "0",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 958,
+    "function": "TypeSignature::empty_buffer",
+    "return_type": "-> TypeSignature",
+    "replacement": "Default::default()",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1446,
+    "function": "TypeSignature::parse_string_ascii_type_repr",
+    "return_type": "-> Result<TypeSignature>",
+    "replacement": "Ok(Default::default())",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1883,
+    "function": "<impl Display for TypeSignature>::fmt",
+    "return_type": "-> fmt::Result",
+    "replacement": "Ok(Default::default())",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 978,
+    "function": "TypeSignature::max_string_ascii",
+    "return_type": "-> TypeSignature",
+    "replacement": "Default::default()",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 806,
+    "function": "<impl TryFrom for TupleTypeSignature>::try_from",
+    "return_type": "-> Result<TupleTypeSignature>",
+    "replacement": "Ok(Default::default())",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1735,
+    "function": "ListTypeData::type_size",
+    "return_type": "-> Option<u32>",
+    "replacement": "Some(0)",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 329,
+    "function": "<impl From for TypeSignature>::from",
+    "return_type": "-> Self",
+    "replacement": "Default::default()",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1476,
+    "function": "TypeSignature::parse_response_type_repr",
+    "return_type": "-> Result<TypeSignature>",
+    "replacement": "Ok(Default::default())",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 480,
+    "function": "ListTypeData::get_list_item_type",
+    "return_type": "-> &TypeSignature",
+    "replacement": "&Default::default()",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1782,
+    "function": "TupleTypeSignature::inner_size",
+    "return_type": "-> Option<u32>",
+    "replacement": "Some(1)",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 394,
+    "function": "<impl From for u32>::from",
+    "return_type": "-> u32",
+    "replacement": "1",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 763,
+    "function": "TypeSignature::concretize",
+    "return_type": "-> Result<TypeSignature>",
+    "replacement": "Ok(Default::default())",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1007,
+    "function": "TypeSignature::bound_string_ascii_type",
+    "return_type": "-> TypeSignature",
+    "replacement": "Default::default()",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1388,
+    "function": "TypeSignature::parse_list_type_repr",
+    "return_type": "-> Result<TypeSignature>",
+    "replacement": "Ok(Default::default())",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 624,
+    "function": "TypeSignature::admits_type_v2_1",
+    "return_type": "-> Result<bool>",
+    "replacement": "Ok(true)",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1696,
+    "function": "TypeSignature::inner_type_size",
+    "return_type": "-> Option<u32>",
+    "replacement": "Some(0)",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 511,
+    "function": "TypeSignature::is_response_type",
+    "return_type": "-> bool",
+    "replacement": "false",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 347,
+    "function": "<impl From for u32>::from",
+    "return_type": "-> u32",
+    "replacement": "1",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1409,
+    "function": "TypeSignature::parse_tuple_type_repr",
+    "return_type": "-> Result<TypeSignature>",
+    "replacement": "Ok(Default::default())",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 476,
+    "function": "ListTypeData::get_max_len",
+    "return_type": "-> u32",
+    "replacement": "0",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 476,
+    "function": "ListTypeData::get_max_len",
+    "return_type": "-> u32",
+    "replacement": "1",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 857,
+    "function": "TupleTypeSignature::field_type",
+    "return_type": "-> Option<&TypeSignature>",
+    "replacement": "None",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1735,
+    "function": "ListTypeData::type_size",
+    "return_type": "-> Option<u32>",
+    "replacement": "None",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1872,
+    "function": "<impl Display for AssetIdentifier>::fmt",
+    "return_type": "-> fmt::Result",
+    "replacement": "Ok(Default::default())",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1019,
+    "function": "TypeSignature::factor_out_no_type",
+    "return_type": "-> Result<TypeSignature>",
+    "replacement": "Ok(Default::default())",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1766,
+    "function": "TupleTypeSignature::size",
+    "return_type": "-> u32",
+    "replacement": "1",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 887,
+    "function": "TupleTypeSignature::parse_name_type_pair_list",
+    "return_type": "-> Result<TupleTypeSignature>",
+    "replacement": "Ok(Default::default())",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1696,
+    "function": "TypeSignature::inner_type_size",
+    "return_type": "-> Option<u32>",
+    "replacement": "Some(1)",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 861,
+    "function": "TupleTypeSignature::get_type_map",
+    "return_type": "-> &BTreeMap<ClarityName, TypeSignature>",
+    "replacement": "&BTreeMap::from_iter([(Default::default(), Default::default())])",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1929,
+    "function": "<impl Display for FunctionArg>::fmt",
+    "return_type": "-> fmt::Result",
+    "replacement": "Ok(Default::default())",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1748,
+    "function": "TupleTypeSignature::type_size",
+    "return_type": "-> Option<u32>",
+    "replacement": "Some(1)",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1065,
+    "function": "TypeSignature::least_supertype_v2_0",
+    "return_type": "-> Result<TypeSignature>",
+    "replacement": "Ok(Default::default())",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1167,
+    "function": "TypeSignature::least_supertype_v2_1",
+    "return_type": "-> Result<TypeSignature>",
+    "replacement": "Ok(Default::default())",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 341,
+    "function": "<impl From for u32>::from",
+    "return_type": "-> u32",
+    "replacement": "1",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 865,
+    "function": "TupleTypeSignature::admits",
+    "return_type": "-> Result<bool>",
+    "replacement": "Ok(true)",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 857,
+    "function": "TupleTypeSignature::field_type",
+    "return_type": "-> Option<&TypeSignature>",
+    "replacement": "Some(&Default::default())",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 261,
+    "function": "FunctionReturnsSignature::canonicalize",
+    "return_type": "-> FunctionReturnsSignature",
+    "replacement": "Default::default()",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1431,
+    "function": "TypeSignature::parse_string_utf8_type_repr",
+    "return_type": "-> Result<TypeSignature>",
+    "replacement": "Ok(Default::default())",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1735,
+    "function": "ListTypeData::type_size",
+    "return_type": "-> Option<u32>",
+    "replacement": "Some(1)",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1917,
+    "function": "<impl Display for BufferLength>::fmt",
+    "return_type": "-> fmt::Result",
+    "replacement": "Ok(Default::default())",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 853,
+    "function": "TupleTypeSignature::is_empty",
+    "return_type": "-> bool",
+    "replacement": "true",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1658,
+    "function": "TypeSignature::inner_size",
+    "return_type": "-> Option<u32>",
+    "replacement": "Some(0)",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1372,
+    "function": "TypeSignature::parse_atom_type",
+    "return_type": "-> Result<TypeSignature>",
+    "replacement": "Ok(Default::default())",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 848,
+    "function": "TupleTypeSignature::len",
+    "return_type": "-> u64",
+    "replacement": "1",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 926,
+    "function": "FunctionSignature::check_args_trait_compliance",
+    "return_type": "-> Result<bool>",
+    "replacement": "Ok(false)",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 926,
+    "function": "FunctionSignature::check_args_trait_compliance",
+    "return_type": "-> Result<bool>",
+    "replacement": "Ok(true)",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 999,
+    "function": "TypeSignature::contract_name_string_ascii_type",
+    "return_type": "-> TypeSignature",
+    "replacement": "Default::default()",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 535,
+    "function": "TypeSignature::admits_type_v2_0",
+    "return_type": "-> Result<bool>",
+    "replacement": "Ok(true)",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 624,
+    "function": "TypeSignature::admits_type_v2_1",
+    "return_type": "-> Result<bool>",
+    "replacement": "Ok(false)",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 535,
+    "function": "TypeSignature::admits_type_v2_0",
+    "return_type": "-> Result<bool>",
+    "replacement": "Ok(false)",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1782,
+    "function": "TupleTypeSignature::inner_size",
+    "return_type": "-> Option<u32>",
+    "replacement": "Some(0)",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 388,
+    "function": "<impl From for u32>::from",
+    "return_type": "-> u32",
+    "replacement": "1",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 939,
+    "function": "FunctionSignature::canonicalize",
+    "return_type": "-> FunctionSignature",
+    "replacement": "Default::default()",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1551,
+    "function": "TypeSignature::parse_trait_type_repr",
+    "return_type": "-> Result<BTreeMap<ClarityName, FunctionSignature>>",
+    "replacement": "Ok(BTreeMap::from_iter([(Default::default(), Default::default())]))",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1551,
+    "function": "TypeSignature::parse_trait_type_repr",
+    "return_type": "-> Result<BTreeMap<ClarityName, FunctionSignature>>",
+    "replacement": "Ok(BTreeMap::new())",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1301,
+    "function": "TypeSignature::list_of",
+    "return_type": "-> Result<TypeSignature>",
+    "replacement": "Ok(Default::default())",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1489,
+    "function": "TypeSignature::parse_type_repr",
+    "return_type": "-> Result<TypeSignature>",
+    "replacement": "Ok(Default::default())",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 825,
+    "function": "<impl TryFrom for TupleTypeSignature>::try_from",
+    "return_type": "-> Result<TupleTypeSignature>",
+    "replacement": "Ok(Default::default())",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 865,
+    "function": "TupleTypeSignature::admits",
+    "return_type": "-> Result<bool>",
+    "replacement": "Ok(false)",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 365,
+    "function": "<impl TryFrom for BufferLength>::try_from",
+    "return_type": "-> Result<BufferLength>",
+    "replacement": "Ok(Default::default())",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 470,
+    "function": "ListTypeData::reduce_max_len",
+    "return_type": "",
+    "replacement": "()",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1766,
+    "function": "TupleTypeSignature::size",
+    "return_type": "-> u32",
+    "replacement": "0",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 519,
+    "function": "TypeSignature::admits",
+    "return_type": "-> Result<bool>",
+    "replacement": "Ok(false)",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 415,
+    "function": "<impl TryFrom for StringUTF8Length>::try_from",
+    "return_type": "-> Result<StringUTF8Length>",
+    "replacement": "Ok(Default::default())",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 321,
+    "function": "<impl From for FunctionSignature>::from",
+    "return_type": "-> FunctionSignature",
+    "replacement": "Default::default()",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 376,
+    "function": "<impl TryFrom for BufferLength>::try_from",
+    "return_type": "-> Result<BufferLength>",
+    "replacement": "Ok(Default::default())",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1658,
+    "function": "TypeSignature::inner_size",
+    "return_type": "-> Option<u32>",
+    "replacement": "None",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 59,
+    "function": "AssetIdentifier::STX_burned",
+    "return_type": "-> AssetIdentifier",
+    "replacement": "Default::default()",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1852,
+    "function": "<impl Display for TupleTypeSignature>::fmt",
+    "return_type": "-> fmt::Result",
+    "replacement": "Ok(Default::default())",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 913,
+    "function": "FunctionSignature::total_type_size",
+    "return_type": "-> Result<u64>",
+    "replacement": "Ok(0)",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 511,
+    "function": "TypeSignature::is_response_type",
+    "return_type": "-> bool",
+    "replacement": "true",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 519,
+    "function": "TypeSignature::admits",
+    "return_type": "-> Result<bool>",
+    "replacement": "Ok(true)",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1696,
+    "function": "TypeSignature::inner_type_size",
+    "return_type": "-> Option<u32>",
+    "replacement": "None",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 966,
+    "function": "TypeSignature::min_string_ascii",
+    "return_type": "-> TypeSignature",
+    "replacement": "Default::default()",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 861,
+    "function": "TupleTypeSignature::get_type_map",
+    "return_type": "-> &BTreeMap<ClarityName, TypeSignature>",
+    "replacement": "&BTreeMap::new()",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 962,
+    "function": "TypeSignature::min_buffer",
+    "return_type": "-> TypeSignature",
     "replacement": "Default::default()",
     "genre": "FnValue"
   },
   {
     "package": "clarity",
-    "file": "clarity/src/libclarity.rs",
-    "line": 96,
-    "function": "version_string",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1812,
+    "function": "parse_name_type_pairs",
+    "return_type": "-> Result<Vec<(ClarityName, TypeSignature)>>",
+    "replacement": "Ok(vec![])",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 347,
+    "function": "<impl From for u32>::from",
+    "return_type": "-> u32",
+    "replacement": "0",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 444,
+    "function": "ListTypeData::new_list",
+    "return_type": "-> Result<ListTypeData>",
+    "replacement": "Ok(Default::default())",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 464,
+    "function": "ListTypeData::destruct",
+    "return_type": "-> (TypeSignature, u32)",
+    "replacement": "(Default::default(), 1)",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 69,
+    "function": "AssetIdentifier::sugared",
     "return_type": "-> String",
     "replacement": "String::new()",
     "genre": "FnValue"
   },
   {
     "package": "clarity",
-    "file": "clarity/src/libclarity.rs",
-    "line": 73,
-    "function": "boot_util::boot_code_id",
-    "return_type": "-> QualifiedContractIdentifier",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 902,
+    "function": "FixedFunction::total_type_size",
+    "return_type": "-> Result<u64>",
+    "replacement": "Ok(1)",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1812,
+    "function": "parse_name_type_pairs",
+    "return_type": "-> Result<Vec<(ClarityName, TypeSignature)>>",
+    "replacement": "Ok(vec![(Default::default(), Default::default())])",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1748,
+    "function": "TupleTypeSignature::type_size",
+    "return_type": "-> Option<u32>",
+    "replacement": "Some(0)",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1627,
+    "function": "TypeSignature::depth",
+    "return_type": "-> u8",
+    "replacement": "1",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 985,
+    "function": "TypeSignature::max_string_utf8",
+    "return_type": "-> TypeSignature",
     "replacement": "Default::default()",
     "genre": "FnValue"
   },
   {
     "package": "clarity",
-    "file": "clarity/src/libclarity.rs",
-    "line": 96,
-    "function": "version_string",
-    "return_type": "-> String",
-    "replacement": "\"xyzzy\".into()",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1771,
+    "function": "TupleTypeSignature::max_depth",
+    "return_type": "-> u8",
+    "replacement": "0",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 354,
+    "function": "<impl TryFrom for BufferLength>::try_from",
+    "return_type": "-> Result<BufferLength>",
+    "replacement": "Ok(Default::default())",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 429,
+    "function": "<impl TryFrom for StringUTF8Length>::try_from",
+    "return_type": "-> Result<StringUTF8Length>",
+    "replacement": "Ok(Default::default())",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 853,
+    "function": "TupleTypeSignature::is_empty",
+    "return_type": "-> bool",
+    "replacement": "false",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1054,
+    "function": "TypeSignature::least_supertype",
+    "return_type": "-> Result<TypeSignature>",
+    "replacement": "Ok(Default::default())",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 972,
+    "function": "TypeSignature::min_string_utf8",
+    "return_type": "-> TypeSignature",
+    "replacement": "Default::default()",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 896,
+    "function": "TupleTypeSignature::shallow_merge",
+    "return_type": "",
+    "replacement": "()",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 733,
+    "function": "TypeSignature::canonicalize_v2_1",
+    "return_type": "-> TypeSignature",
+    "replacement": "Default::default()",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1627,
+    "function": "TypeSignature::depth",
+    "return_type": "-> u8",
+    "replacement": "0",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1771,
+    "function": "TupleTypeSignature::max_depth",
+    "return_type": "-> u8",
+    "replacement": "1",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 49,
+    "function": "AssetIdentifier::STX",
+    "return_type": "-> AssetIdentifier",
+    "replacement": "Default::default()",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 335,
+    "function": "<impl From for TypeSignature>::from",
+    "return_type": "-> Self",
+    "replacement": "Default::default()",
+    "genre": "FnValue"
+  },
+  {
+    "package": "clarity",
+    "file": "clarity/src/vm/types/signatures.rs",
+    "line": 1690,
+    "function": "TypeSignature::type_size",
+    "return_type": "-> Result<u32>",
+    "replacement": "Ok(0)",
     "genre": "FnValue"
   }
 ]
\ No newline at end of file
diff --git a/mutants/clarity/mutants.out/outcomes.json b/mutants/clarity/mutants.out/outcomes.json
index b9556f45a0..163ef2651e 100644
--- a/mutants/clarity/mutants.out/outcomes.json
+++ b/mutants/clarity/mutants.out/outcomes.json
@@ -2,30 +2,30 @@
   "outcomes": [
     {
       "scenario": "Baseline",
-      "log_path": "mutants/clarity/mutants.out/log/baseline.log",
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/baseline.log",
       "summary": "Success",
       "phase_results": [
         {
           "phase": "Build",
-          "duration": 46.04112825,
+          "duration": 48.870485542,
           "process_status": "Success",
           "argv": [
             "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
             "build",
             "--tests",
             "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-HHiHlU.tmp/clarity/Cargo.toml"
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
           ]
         },
         {
           "phase": "Test",
-          "duration": 13.555701334,
+          "duration": 13.581365083,
           "process_status": "Success",
           "argv": [
             "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
             "test",
             "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-HHiHlU.tmp/clarity/Cargo.toml"
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
           ]
         }
       ]
@@ -34,27 +34,4560 @@
       "scenario": {
         "Mutant": {
           "package": "clarity",
-          "file": "clarity/src/libclarity.rs",
-          "line": 81,
-          "function": "boot_util::boot_code_addr",
-          "return_type": "-> StacksAddress",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1349,
+          "function": "TypeSignature::construct_parent_list_type",
+          "return_type": "-> Result<ListTypeData>",
+          "replacement": "Ok(Default::default())",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1349.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 2.413352667,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 498,
+          "function": "TypeSignature::new_response",
+          "return_type": "-> Result<TypeSignature>",
+          "replacement": "Ok(Default::default())",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_498.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 1.8009515,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 401,
+          "function": "<impl TryFrom for StringUTF8Length>::try_from",
+          "return_type": "-> Result<StringUTF8Length>",
+          "replacement": "Ok(Default::default())",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_401.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 8.302728625,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 721,
+          "function": "TypeSignature::canonicalize",
+          "return_type": "-> TypeSignature",
+          "replacement": "Default::default()",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_721.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 5.217074708,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 243,
+          "function": "FunctionArgSignature::canonicalize",
+          "return_type": "-> FunctionArgSignature",
+          "replacement": "Default::default()",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_243.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 7.594266708,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 902,
+          "function": "FixedFunction::total_type_size",
+          "return_type": "-> Result<u64>",
+          "replacement": "Ok(0)",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_902.log",
+      "summary": "MissedMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 13.547835583,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 18.191711542,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1923,
+          "function": "<impl Display for StringUTF8Length>::fmt",
+          "return_type": "-> fmt::Result",
+          "replacement": "Ok(Default::default())",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1923.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 40.211793125,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 37.435264791,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1652,
+          "function": "TypeSignature::size",
+          "return_type": "-> u32",
+          "replacement": "0",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1652.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 40.639337375,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 38.695793333,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 524,
+          "function": "TypeSignature::admits_type",
+          "return_type": "-> Result<bool>",
+          "replacement": "Ok(false)",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_524.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 23.007986375,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 21.6112545,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1356,
+          "function": "TypeSignature::parent_list_type",
+          "return_type": "-> std::result::Result<ListTypeData, CheckErrors>",
+          "replacement": "Ok(Default::default())",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1356.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 3.227544417,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 464,
+          "function": "ListTypeData::destruct",
+          "return_type": "-> (TypeSignature, u32)",
+          "replacement": "(Default::default(), 0)",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_464.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 2.31028175,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1862,
+          "function": "<impl Debug for TupleTypeSignature>::fmt",
+          "return_type": "-> fmt::Result",
+          "replacement": "Ok(Default::default())",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1862.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 51.42247,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 34.323780375,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1722,
+          "function": "ListTypeData::inner_size",
+          "return_type": "-> Option<u32>",
+          "replacement": "Some(1)",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1722.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 25.53248325,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 17.148738375,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 524,
+          "function": "TypeSignature::admits_type",
+          "return_type": "-> Result<bool>",
+          "replacement": "Ok(true)",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_524_001.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 27.380569833,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 15.380072333,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 128,
+          "function": "SequenceSubtype::unit_type",
+          "return_type": "-> TypeSignature",
+          "replacement": "Default::default()",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_128.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 5.409524667,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 69,
+          "function": "AssetIdentifier::sugared",
+          "return_type": "-> String",
+          "replacement": "\"xyzzy\".into()",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_69.log",
+      "summary": "MissedMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 29.446663375,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 17.413222167,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1463,
+          "function": "TypeSignature::parse_optional_type_repr",
+          "return_type": "-> Result<TypeSignature>",
+          "replacement": "Ok(Default::default())",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1463.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 3.474340375,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 913,
+          "function": "FunctionSignature::total_type_size",
+          "return_type": "-> Result<u64>",
+          "replacement": "Ok(1)",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_913.log",
+      "summary": "MissedMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 25.763329209,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 18.006977416,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1782,
+          "function": "TupleTypeSignature::inner_size",
+          "return_type": "-> Option<u32>",
+          "replacement": "None",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1782.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 24.627890208,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 17.050794,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 139,
+          "function": "SequenceSubtype::is_list_type",
+          "return_type": "-> bool",
+          "replacement": "false",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_139.log",
+      "summary": "MissedMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 25.401799458,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 16.346395333,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 848,
+          "function": "TupleTypeSignature::len",
+          "return_type": "-> u64",
+          "replacement": "0",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_848.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 22.287401166,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 16.466721334,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1652,
+          "function": "TypeSignature::size",
+          "return_type": "-> u32",
+          "replacement": "1",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1652_001.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 28.696065875,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 27.5143085,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1658,
+          "function": "TypeSignature::inner_size",
+          "return_type": "-> Option<u32>",
+          "replacement": "Some(1)",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1658.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 27.29746575,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 21.400906083,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1690,
+          "function": "TypeSignature::type_size",
+          "return_type": "-> Result<u32>",
+          "replacement": "Ok(1)",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1690.log",
+      "summary": "MissedMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 31.799000625,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 24.386971708,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1305,
+          "function": "TypeSignature::empty_list",
+          "return_type": "-> ListTypeData",
+          "replacement": "Default::default()",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1305.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 2.679374833,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1417,
+          "function": "TypeSignature::parse_buff_type_repr",
+          "return_type": "-> Result<TypeSignature>",
+          "replacement": "Ok(Default::default())",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1417.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 2.883547541,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 273,
+          "function": "FunctionType::canonicalize",
+          "return_type": "-> FunctionType",
+          "replacement": "Default::default()",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_273.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 4.964104416,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 139,
+          "function": "SequenceSubtype::is_list_type",
+          "return_type": "-> bool",
+          "replacement": "true",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_139_001.log",
+      "summary": "MissedMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 27.802188125,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 11.663400458,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 341,
+          "function": "<impl From for u32>::from",
+          "return_type": "-> u32",
+          "replacement": "0",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_341.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 30.443008583,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 10.891368875,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 992,
+          "function": "TypeSignature::max_buffer",
+          "return_type": "-> TypeSignature",
+          "replacement": "Default::default()",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_992.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 4.977954417,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 486,
+          "function": "TypeSignature::new_option",
+          "return_type": "-> Result<TypeSignature>",
+          "replacement": "Ok(Default::default())",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_486.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 2.949309,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 515,
+          "function": "TypeSignature::is_no_type",
+          "return_type": "-> bool",
+          "replacement": "true",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_515_001.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 16.662940541,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 26.950355875,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1722,
+          "function": "ListTypeData::inner_size",
+          "return_type": "-> Option<u32>",
+          "replacement": "None",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1722_001.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 22.340065042,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 19.566255917,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 515,
+          "function": "TypeSignature::is_no_type",
+          "return_type": "-> bool",
+          "replacement": "false",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_515.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 17.362938667,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 35.683727708,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 394,
+          "function": "<impl From for u32>::from",
+          "return_type": "-> u32",
+          "replacement": "0",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_394.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 24.428596417,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 19.539569416,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1312,
+          "function": "TypeSignature::type_of",
+          "return_type": "-> TypeSignature",
+          "replacement": "Default::default()",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1312.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 3.602411708,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1339,
+          "function": "TypeSignature::literal_type_of",
+          "return_type": "-> TypeSignature",
+          "replacement": "Default::default()",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1339.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 4.225163333,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 958,
+          "function": "TypeSignature::empty_buffer",
+          "return_type": "-> TypeSignature",
+          "replacement": "Default::default()",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_958.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 3.6419924999999997,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1446,
+          "function": "TypeSignature::parse_string_ascii_type_repr",
+          "return_type": "-> Result<TypeSignature>",
+          "replacement": "Ok(Default::default())",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1446.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 6.7703145,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1748,
+          "function": "TupleTypeSignature::type_size",
+          "return_type": "-> Option<u32>",
+          "replacement": "None",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1748.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 18.313141792,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 19.517415292,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1722,
+          "function": "ListTypeData::inner_size",
+          "return_type": "-> Option<u32>",
+          "replacement": "Some(0)",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1722_002.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 19.117432125,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 16.168920166,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 978,
+          "function": "TypeSignature::max_string_ascii",
+          "return_type": "-> TypeSignature",
+          "replacement": "Default::default()",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_978.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 4.838537667,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 388,
+          "function": "<impl From for u32>::from",
+          "return_type": "-> u32",
+          "replacement": "0",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_388.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 19.122941792,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 16.852404458,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 329,
+          "function": "<impl From for TypeSignature>::from",
+          "return_type": "-> Self",
+          "replacement": "Default::default()",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_329.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 5.721400625,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 806,
+          "function": "<impl TryFrom for TupleTypeSignature>::try_from",
+          "return_type": "-> Result<TupleTypeSignature>",
+          "replacement": "Ok(Default::default())",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_806.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 10.547628916,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 480,
+          "function": "ListTypeData::get_list_item_type",
+          "return_type": "-> &TypeSignature",
+          "replacement": "&Default::default()",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_480.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 5.957461708,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1476,
+          "function": "TypeSignature::parse_response_type_repr",
+          "return_type": "-> Result<TypeSignature>",
+          "replacement": "Ok(Default::default())",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1476.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 6.321656875,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1883,
+          "function": "<impl Display for TypeSignature>::fmt",
+          "return_type": "-> fmt::Result",
+          "replacement": "Ok(Default::default())",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1883.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 26.04623475,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 15.193360584,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 763,
+          "function": "TypeSignature::concretize",
+          "return_type": "-> Result<TypeSignature>",
+          "replacement": "Ok(Default::default())",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_763.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 10.950827167,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1007,
+          "function": "TypeSignature::bound_string_ascii_type",
+          "return_type": "-> TypeSignature",
+          "replacement": "Default::default()",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1007.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 4.369384333,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1735,
+          "function": "ListTypeData::type_size",
+          "return_type": "-> Option<u32>",
+          "replacement": "Some(0)",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1735.log",
+      "summary": "MissedMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 22.466542667,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 16.240326875,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1388,
+          "function": "TypeSignature::parse_list_type_repr",
+          "return_type": "-> Result<TypeSignature>",
+          "replacement": "Ok(Default::default())",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1388.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 17.4692515,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 394,
+          "function": "<impl From for u32>::from",
+          "return_type": "-> u32",
+          "replacement": "1",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_394_001.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 32.002660209,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 13.946704166,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1782,
+          "function": "TupleTypeSignature::inner_size",
+          "return_type": "-> Option<u32>",
+          "replacement": "Some(1)",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1782_001.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 33.862695291,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 13.977090042,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 624,
+          "function": "TypeSignature::admits_type_v2_1",
+          "return_type": "-> Result<bool>",
+          "replacement": "Ok(true)",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_624.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 31.504170458,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 21.17088,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1696,
+          "function": "TypeSignature::inner_type_size",
+          "return_type": "-> Option<u32>",
+          "replacement": "Some(0)",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1696.log",
+      "summary": "MissedMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 25.22403,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 23.3472345,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1409,
+          "function": "TypeSignature::parse_tuple_type_repr",
+          "return_type": "-> Result<TypeSignature>",
+          "replacement": "Ok(Default::default())",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1409.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 7.313209583,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 511,
+          "function": "TypeSignature::is_response_type",
+          "return_type": "-> bool",
+          "replacement": "false",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_511.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 34.332864583,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 14.411179167,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 347,
+          "function": "<impl From for u32>::from",
+          "return_type": "-> u32",
+          "replacement": "1",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_347.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 34.903205959,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 12.939255167,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 476,
+          "function": "ListTypeData::get_max_len",
+          "return_type": "-> u32",
+          "replacement": "0",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_476.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 23.590776833,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 26.328106792,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 476,
+          "function": "ListTypeData::get_max_len",
+          "return_type": "-> u32",
+          "replacement": "1",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_476_001.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 24.598913458,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 24.816297667,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1735,
+          "function": "ListTypeData::type_size",
+          "return_type": "-> Option<u32>",
+          "replacement": "None",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1735_001.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 36.564255542,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 12.595694292,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 857,
+          "function": "TupleTypeSignature::field_type",
+          "return_type": "-> Option<&TypeSignature>",
+          "replacement": "None",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_857.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 39.241546583,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 11.131983583,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1019,
+          "function": "TypeSignature::factor_out_no_type",
+          "return_type": "-> Result<TypeSignature>",
+          "replacement": "Ok(Default::default())",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1019.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 10.367219875,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 887,
+          "function": "TupleTypeSignature::parse_name_type_pair_list",
+          "return_type": "-> Result<TupleTypeSignature>",
+          "replacement": "Ok(Default::default())",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_887.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 2.40049375,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 861,
+          "function": "TupleTypeSignature::get_type_map",
+          "return_type": "-> &BTreeMap<ClarityName, TypeSignature>",
+          "replacement": "&BTreeMap::from_iter([(Default::default(), Default::default())])",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_861.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 3.293869042,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1872,
+          "function": "<impl Display for AssetIdentifier>::fmt",
+          "return_type": "-> fmt::Result",
+          "replacement": "Ok(Default::default())",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1872.log",
+      "summary": "MissedMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 25.456887166,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 27.397120625,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1696,
+          "function": "TypeSignature::inner_type_size",
+          "return_type": "-> Option<u32>",
+          "replacement": "Some(1)",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1696_001.log",
+      "summary": "MissedMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 22.660173125,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 20.802173791,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1766,
+          "function": "TupleTypeSignature::size",
+          "return_type": "-> u32",
+          "replacement": "1",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1766.log",
+      "summary": "MissedMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 21.661805625,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 23.552763792,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1065,
+          "function": "TypeSignature::least_supertype_v2_0",
+          "return_type": "-> Result<TypeSignature>",
+          "replacement": "Ok(Default::default())",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1065.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 3.021114625,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1167,
+          "function": "TypeSignature::least_supertype_v2_1",
+          "return_type": "-> Result<TypeSignature>",
+          "replacement": "Ok(Default::default())",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1167.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 2.657739084,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1929,
+          "function": "<impl Display for FunctionArg>::fmt",
+          "return_type": "-> fmt::Result",
+          "replacement": "Ok(Default::default())",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1929.log",
+      "summary": "MissedMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 37.439525708,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 10.930792666,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 857,
+          "function": "TupleTypeSignature::field_type",
+          "return_type": "-> Option<&TypeSignature>",
+          "replacement": "Some(&Default::default())",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_857_001.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 16.4943715,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1748,
+          "function": "TupleTypeSignature::type_size",
+          "return_type": "-> Option<u32>",
+          "replacement": "Some(1)",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1748_001.log",
+      "summary": "MissedMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 23.868041583,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 11.95483925,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 261,
+          "function": "FunctionReturnsSignature::canonicalize",
+          "return_type": "-> FunctionReturnsSignature",
+          "replacement": "Default::default()",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_261.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 8.962593708,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1431,
+          "function": "TypeSignature::parse_string_utf8_type_repr",
+          "return_type": "-> Result<TypeSignature>",
+          "replacement": "Ok(Default::default())",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1431.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 4.787142875,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 341,
+          "function": "<impl From for u32>::from",
+          "return_type": "-> u32",
+          "replacement": "1",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_341_001.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 25.077840209,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 17.215056958,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 865,
+          "function": "TupleTypeSignature::admits",
+          "return_type": "-> Result<bool>",
+          "replacement": "Ok(true)",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_865.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 25.271255166,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 17.210464291,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1735,
+          "function": "ListTypeData::type_size",
+          "return_type": "-> Option<u32>",
+          "replacement": "Some(1)",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1735_002.log",
+      "summary": "MissedMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 22.162701709,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 22.213987666,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1372,
+          "function": "TypeSignature::parse_atom_type",
+          "return_type": "-> Result<TypeSignature>",
+          "replacement": "Ok(Default::default())",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1372.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 6.311530666,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 853,
+          "function": "TupleTypeSignature::is_empty",
+          "return_type": "-> bool",
+          "replacement": "true",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_853.log",
+      "summary": "MissedMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 29.040213167,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 18.036327625,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1917,
+          "function": "<impl Display for BufferLength>::fmt",
+          "return_type": "-> fmt::Result",
+          "replacement": "Ok(Default::default())",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1917.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 31.234916625,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 22.999341708,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1658,
+          "function": "TypeSignature::inner_size",
+          "return_type": "-> Option<u32>",
+          "replacement": "Some(0)",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1658_001.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 31.879440375,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 16.39029575,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 999,
+          "function": "TypeSignature::contract_name_string_ascii_type",
+          "return_type": "-> TypeSignature",
+          "replacement": "Default::default()",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_999.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 2.634524958,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 848,
+          "function": "TupleTypeSignature::len",
+          "return_type": "-> u64",
+          "replacement": "1",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_848_001.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 22.726564416,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 21.53074675,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 926,
+          "function": "FunctionSignature::check_args_trait_compliance",
+          "return_type": "-> Result<bool>",
+          "replacement": "Ok(true)",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_926_001.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 29.798568625,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 24.423910333,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 926,
+          "function": "FunctionSignature::check_args_trait_compliance",
+          "return_type": "-> Result<bool>",
+          "replacement": "Ok(false)",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_926.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 30.697343,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 24.892369292,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 535,
+          "function": "TypeSignature::admits_type_v2_0",
+          "return_type": "-> Result<bool>",
+          "replacement": "Ok(true)",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_535.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 32.350779208,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 19.450091875,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 624,
+          "function": "TypeSignature::admits_type_v2_1",
+          "return_type": "-> Result<bool>",
+          "replacement": "Ok(false)",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_624_001.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 24.073024042,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 15.364809125,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 939,
+          "function": "FunctionSignature::canonicalize",
+          "return_type": "-> FunctionSignature",
+          "replacement": "Default::default()",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_939.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 16.522799374999998,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1551,
+          "function": "TypeSignature::parse_trait_type_repr",
+          "return_type": "-> Result<BTreeMap<ClarityName, FunctionSignature>>",
+          "replacement": "Ok(BTreeMap::from_iter([(Default::default(), Default::default())]))",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1551.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 3.015027042,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1782,
+          "function": "TupleTypeSignature::inner_size",
+          "return_type": "-> Option<u32>",
+          "replacement": "Some(0)",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1782_002.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 34.659983166,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 17.324460541,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 388,
+          "function": "<impl From for u32>::from",
+          "return_type": "-> u32",
+          "replacement": "1",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_388_001.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 36.759580875,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 16.639867666,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 535,
+          "function": "TypeSignature::admits_type_v2_0",
+          "return_type": "-> Result<bool>",
+          "replacement": "Ok(false)",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_535_001.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 38.100834542,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 16.205373792,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1301,
+          "function": "TypeSignature::list_of",
+          "return_type": "-> Result<TypeSignature>",
+          "replacement": "Ok(Default::default())",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1301.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 3.31055975,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1489,
+          "function": "TypeSignature::parse_type_repr",
+          "return_type": "-> Result<TypeSignature>",
+          "replacement": "Ok(Default::default())",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1489.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 3.339428291,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 825,
+          "function": "<impl TryFrom for TupleTypeSignature>::try_from",
+          "return_type": "-> Result<TupleTypeSignature>",
+          "replacement": "Ok(Default::default())",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_825.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 3.236037084,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 365,
+          "function": "<impl TryFrom for BufferLength>::try_from",
+          "return_type": "-> Result<BufferLength>",
+          "replacement": "Ok(Default::default())",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_365.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 6.0192135,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1551,
+          "function": "TypeSignature::parse_trait_type_repr",
+          "return_type": "-> Result<BTreeMap<ClarityName, FunctionSignature>>",
+          "replacement": "Ok(BTreeMap::new())",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1551_001.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 22.54061125,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 20.491565334,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 865,
+          "function": "TupleTypeSignature::admits",
+          "return_type": "-> Result<bool>",
+          "replacement": "Ok(false)",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_865_001.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 25.454946334,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 15.922607833,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 415,
+          "function": "<impl TryFrom for StringUTF8Length>::try_from",
+          "return_type": "-> Result<StringUTF8Length>",
+          "replacement": "Ok(Default::default())",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_415.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 4.640949792,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 321,
+          "function": "<impl From for FunctionSignature>::from",
+          "return_type": "-> FunctionSignature",
+          "replacement": "Default::default()",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_321.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 7.98785425,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 470,
+          "function": "ListTypeData::reduce_max_len",
+          "return_type": "",
+          "replacement": "()",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_470.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 30.48559,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 23.830903709,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1766,
+          "function": "TupleTypeSignature::size",
+          "return_type": "-> u32",
+          "replacement": "0",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1766_001.log",
+      "summary": "MissedMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 29.497742,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 19.984396041,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 376,
+          "function": "<impl TryFrom for BufferLength>::try_from",
+          "return_type": "-> Result<BufferLength>",
+          "replacement": "Ok(Default::default())",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_376.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 5.595003125,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 59,
+          "function": "AssetIdentifier::STX_burned",
+          "return_type": "-> AssetIdentifier",
+          "replacement": "Default::default()",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_59.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 3.673552333,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 519,
+          "function": "TypeSignature::admits",
+          "return_type": "-> Result<bool>",
+          "replacement": "Ok(false)",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_519.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 30.971769917,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 15.166688708,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1658,
+          "function": "TypeSignature::inner_size",
+          "return_type": "-> Option<u32>",
+          "replacement": "None",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1658_002.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 26.2354305,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 18.948411792,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1852,
+          "function": "<impl Display for TupleTypeSignature>::fmt",
+          "return_type": "-> fmt::Result",
+          "replacement": "Ok(Default::default())",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1852.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 26.726568792,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 20.415309459,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 913,
+          "function": "FunctionSignature::total_type_size",
+          "return_type": "-> Result<u64>",
+          "replacement": "Ok(0)",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_913_001.log",
+      "summary": "MissedMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 28.608253959,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 23.206093625,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 966,
+          "function": "TypeSignature::min_string_ascii",
+          "return_type": "-> TypeSignature",
+          "replacement": "Default::default()",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_966.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 7.5618245,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 511,
+          "function": "TypeSignature::is_response_type",
+          "return_type": "-> bool",
+          "replacement": "true",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_511_001.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 34.760121541,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 19.49756125,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 861,
+          "function": "TupleTypeSignature::get_type_map",
+          "return_type": "-> &BTreeMap<ClarityName, TypeSignature>",
+          "replacement": "&BTreeMap::new()",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_861_001.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 14.486307541,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 962,
+          "function": "TypeSignature::min_buffer",
+          "return_type": "-> TypeSignature",
+          "replacement": "Default::default()",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_962.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 8.547444375,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1696,
+          "function": "TypeSignature::inner_type_size",
+          "return_type": "-> Option<u32>",
+          "replacement": "None",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1696_002.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 28.793845166,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 14.089337209,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 519,
+          "function": "TypeSignature::admits",
+          "return_type": "-> Result<bool>",
+          "replacement": "Ok(true)",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_519_001.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 34.086433792,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 15.454312584,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 444,
+          "function": "ListTypeData::new_list",
+          "return_type": "-> Result<ListTypeData>",
+          "replacement": "Ok(Default::default())",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_444.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 6.085910917,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 464,
+          "function": "ListTypeData::destruct",
+          "return_type": "-> (TypeSignature, u32)",
+          "replacement": "(Default::default(), 1)",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_464_001.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 6.066003333,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 347,
+          "function": "<impl From for u32>::from",
+          "return_type": "-> u32",
+          "replacement": "0",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_347_001.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 24.544213833,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 11.491642792,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1812,
+          "function": "parse_name_type_pairs",
+          "return_type": "-> Result<Vec<(ClarityName, TypeSignature)>>",
+          "replacement": "Ok(vec![])",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1812.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 26.021988834,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 19.17278175,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1812,
+          "function": "parse_name_type_pairs",
+          "return_type": "-> Result<Vec<(ClarityName, TypeSignature)>>",
+          "replacement": "Ok(vec![(Default::default(), Default::default())])",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1812_001.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 7.83972475,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 902,
+          "function": "FixedFunction::total_type_size",
+          "return_type": "-> Result<u64>",
+          "replacement": "Ok(1)",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_902_001.log",
+      "summary": "MissedMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 30.021399917,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 16.801482375,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 69,
+          "function": "AssetIdentifier::sugared",
+          "return_type": "-> String",
+          "replacement": "String::new()",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_69_001.log",
+      "summary": "MissedMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 31.32015925,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 17.240559375,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 985,
+          "function": "TypeSignature::max_string_utf8",
+          "return_type": "-> TypeSignature",
+          "replacement": "Default::default()",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_985.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 7.443240834,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 354,
+          "function": "<impl TryFrom for BufferLength>::try_from",
+          "return_type": "-> Result<BufferLength>",
+          "replacement": "Ok(Default::default())",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_354.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 5.393277042,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 429,
+          "function": "<impl TryFrom for StringUTF8Length>::try_from",
+          "return_type": "-> Result<StringUTF8Length>",
+          "replacement": "Ok(Default::default())",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_429.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 7.044557916,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1627,
+          "function": "TypeSignature::depth",
+          "return_type": "-> u8",
+          "replacement": "1",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1627.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 29.645121667,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 19.553984583,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1748,
+          "function": "TupleTypeSignature::type_size",
+          "return_type": "-> Option<u32>",
+          "replacement": "Some(0)",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1748_002.log",
+      "summary": "MissedMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 34.89297,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 20.507274458,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1054,
+          "function": "TypeSignature::least_supertype",
+          "return_type": "-> Result<TypeSignature>",
+          "replacement": "Ok(Default::default())",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1054.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 5.065974042,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 972,
+          "function": "TypeSignature::min_string_utf8",
+          "return_type": "-> TypeSignature",
           "replacement": "Default::default()",
           "genre": "FnValue"
         }
       },
-      "log_path": "mutants/clarity/mutants.out/log/clarity__src__libclarity.rs_line_81.log",
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_972.log",
       "summary": "Unviable",
       "phase_results": [
         {
           "phase": "Build",
-          "duration": 2.030609209,
+          "duration": 5.034059459,
           "process_status": "Failure",
           "argv": [
             "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
             "build",
             "--tests",
             "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-HHiHlU.tmp/clarity/Cargo.toml"
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
           ]
         }
       ]
@@ -63,38 +4596,38 @@
       "scenario": {
         "Mutant": {
           "package": "clarity",
-          "file": "clarity/src/libclarity.rs",
-          "line": 96,
-          "function": "version_string",
-          "return_type": "-> String",
-          "replacement": "String::new()",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1771,
+          "function": "TupleTypeSignature::max_depth",
+          "return_type": "-> u8",
+          "replacement": "0",
           "genre": "FnValue"
         }
       },
-      "log_path": "mutants/clarity/mutants.out/log/clarity__src__libclarity.rs_line_96.log",
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1771.log",
       "summary": "MissedMutant",
       "phase_results": [
         {
           "phase": "Build",
-          "duration": 6.272183792,
+          "duration": 27.657742417,
           "process_status": "Success",
           "argv": [
             "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
             "build",
             "--tests",
             "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-HHiHlU.tmp/clarity/Cargo.toml"
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
           ]
         },
         {
           "phase": "Test",
-          "duration": 3.609116292,
+          "duration": 14.668397542,
           "process_status": "Success",
           "argv": [
             "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
             "test",
             "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-HHiHlU.tmp/clarity/Cargo.toml"
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
           ]
         }
       ]
@@ -103,27 +4636,27 @@
       "scenario": {
         "Mutant": {
           "package": "clarity",
-          "file": "clarity/src/libclarity.rs",
-          "line": 73,
-          "function": "boot_util::boot_code_id",
-          "return_type": "-> QualifiedContractIdentifier",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 733,
+          "function": "TypeSignature::canonicalize_v2_1",
+          "return_type": "-> TypeSignature",
           "replacement": "Default::default()",
           "genre": "FnValue"
         }
       },
-      "log_path": "mutants/clarity/mutants.out/log/clarity__src__libclarity.rs_line_73.log",
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_733.log",
       "summary": "Unviable",
       "phase_results": [
         {
           "phase": "Build",
-          "duration": 1.755918375,
+          "duration": 6.798037042,
           "process_status": "Failure",
           "argv": [
             "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
             "build",
             "--tests",
             "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-HHiHlU.tmp/clarity/Cargo.toml"
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
           ]
         }
       ]
@@ -132,48 +4665,266 @@
       "scenario": {
         "Mutant": {
           "package": "clarity",
-          "file": "clarity/src/libclarity.rs",
-          "line": 96,
-          "function": "version_string",
-          "return_type": "-> String",
-          "replacement": "\"xyzzy\".into()",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 853,
+          "function": "TupleTypeSignature::is_empty",
+          "return_type": "-> bool",
+          "replacement": "false",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_853_001.log",
+      "summary": "MissedMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 24.447810042,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 17.067637541,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 49,
+          "function": "AssetIdentifier::STX",
+          "return_type": "-> AssetIdentifier",
+          "replacement": "Default::default()",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_49.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 9.820691042,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 335,
+          "function": "<impl From for TypeSignature>::from",
+          "return_type": "-> Self",
+          "replacement": "Default::default()",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_335.log",
+      "summary": "Unviable",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 7.351396958,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 896,
+          "function": "TupleTypeSignature::shallow_merge",
+          "return_type": "",
+          "replacement": "()",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_896.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 22.808443583,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 25.333841625,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1627,
+          "function": "TypeSignature::depth",
+          "return_type": "-> u8",
+          "replacement": "0",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1627_001.log",
+      "summary": "CaughtMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 34.04683525,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 23.64262775,
+          "process_status": "Failure",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1771,
+          "function": "TupleTypeSignature::max_depth",
+          "return_type": "-> u8",
+          "replacement": "1",
+          "genre": "FnValue"
+        }
+      },
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1771_001.log",
+      "summary": "MissedMutant",
+      "phase_results": [
+        {
+          "phase": "Build",
+          "duration": 33.750561667,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "build",
+            "--tests",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        },
+        {
+          "phase": "Test",
+          "duration": 23.97481975,
+          "process_status": "Success",
+          "argv": [
+            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
+            "test",
+            "--manifest-path",
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
+          ]
+        }
+      ]
+    },
+    {
+      "scenario": {
+        "Mutant": {
+          "package": "clarity",
+          "file": "clarity/src/vm/types/signatures.rs",
+          "line": 1690,
+          "function": "TypeSignature::type_size",
+          "return_type": "-> Result<u32>",
+          "replacement": "Ok(0)",
           "genre": "FnValue"
         }
       },
-      "log_path": "mutants/clarity/mutants.out/log/clarity__src__libclarity.rs_line_96_001.log",
+      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1690_001.log",
       "summary": "MissedMutant",
       "phase_results": [
         {
           "phase": "Build",
-          "duration": 5.987611125,
+          "duration": 26.267381666,
           "process_status": "Success",
           "argv": [
             "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
             "build",
             "--tests",
             "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-HHiHlU.tmp/clarity/Cargo.toml"
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
           ]
         },
         {
           "phase": "Test",
-          "duration": 3.399572666,
+          "duration": 8.574997125,
           "process_status": "Success",
           "argv": [
             "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
             "test",
             "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-HHiHlU.tmp/clarity/Cargo.toml"
+            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
           ]
         }
       ]
     }
   ],
-  "total_mutants": 4,
-  "missed": 2,
-  "caught": 0,
+  "total_mutants": 139,
+  "missed": 24,
+  "caught": 54,
   "timeout": 0,
-  "unviable": 2,
+  "unviable": 61,
   "success": 0,
   "failure": 0
 }
\ No newline at end of file
diff --git a/mutants/clarity/mutants.out/unviable.txt b/mutants/clarity/mutants.out/unviable.txt
index 9e7caf81c0..a24d04d96c 100644
--- a/mutants/clarity/mutants.out/unviable.txt
+++ b/mutants/clarity/mutants.out/unviable.txt
@@ -1,2 +1,61 @@
-clarity/src/libclarity.rs:81: replace boot_util::boot_code_addr -> StacksAddress with Default::default()
-clarity/src/libclarity.rs:73: replace boot_util::boot_code_id -> QualifiedContractIdentifier with Default::default()
+clarity/src/vm/types/signatures.rs:1349: replace TypeSignature::construct_parent_list_type -> Result<ListTypeData> with Ok(Default::default())
+clarity/src/vm/types/signatures.rs:498: replace TypeSignature::new_response -> Result<TypeSignature> with Ok(Default::default())
+clarity/src/vm/types/signatures.rs:401: replace <impl TryFrom for StringUTF8Length>::try_from -> Result<StringUTF8Length> with Ok(Default::default())
+clarity/src/vm/types/signatures.rs:721: replace TypeSignature::canonicalize -> TypeSignature with Default::default()
+clarity/src/vm/types/signatures.rs:243: replace FunctionArgSignature::canonicalize -> FunctionArgSignature with Default::default()
+clarity/src/vm/types/signatures.rs:1356: replace TypeSignature::parent_list_type -> std::result::Result<ListTypeData, CheckErrors> with Ok(Default::default())
+clarity/src/vm/types/signatures.rs:464: replace ListTypeData::destruct -> (TypeSignature, u32) with (Default::default(), 0)
+clarity/src/vm/types/signatures.rs:128: replace SequenceSubtype::unit_type -> TypeSignature with Default::default()
+clarity/src/vm/types/signatures.rs:1463: replace TypeSignature::parse_optional_type_repr -> Result<TypeSignature> with Ok(Default::default())
+clarity/src/vm/types/signatures.rs:1305: replace TypeSignature::empty_list -> ListTypeData with Default::default()
+clarity/src/vm/types/signatures.rs:1417: replace TypeSignature::parse_buff_type_repr -> Result<TypeSignature> with Ok(Default::default())
+clarity/src/vm/types/signatures.rs:273: replace FunctionType::canonicalize -> FunctionType with Default::default()
+clarity/src/vm/types/signatures.rs:992: replace TypeSignature::max_buffer -> TypeSignature with Default::default()
+clarity/src/vm/types/signatures.rs:486: replace TypeSignature::new_option -> Result<TypeSignature> with Ok(Default::default())
+clarity/src/vm/types/signatures.rs:1312: replace TypeSignature::type_of -> TypeSignature with Default::default()
+clarity/src/vm/types/signatures.rs:1339: replace TypeSignature::literal_type_of -> TypeSignature with Default::default()
+clarity/src/vm/types/signatures.rs:958: replace TypeSignature::empty_buffer -> TypeSignature with Default::default()
+clarity/src/vm/types/signatures.rs:1446: replace TypeSignature::parse_string_ascii_type_repr -> Result<TypeSignature> with Ok(Default::default())
+clarity/src/vm/types/signatures.rs:978: replace TypeSignature::max_string_ascii -> TypeSignature with Default::default()
+clarity/src/vm/types/signatures.rs:329: replace <impl From for TypeSignature>::from -> Self with Default::default()
+clarity/src/vm/types/signatures.rs:806: replace <impl TryFrom for TupleTypeSignature>::try_from -> Result<TupleTypeSignature> with Ok(Default::default())
+clarity/src/vm/types/signatures.rs:480: replace ListTypeData::get_list_item_type -> &TypeSignature with &Default::default()
+clarity/src/vm/types/signatures.rs:1476: replace TypeSignature::parse_response_type_repr -> Result<TypeSignature> with Ok(Default::default())
+clarity/src/vm/types/signatures.rs:763: replace TypeSignature::concretize -> Result<TypeSignature> with Ok(Default::default())
+clarity/src/vm/types/signatures.rs:1007: replace TypeSignature::bound_string_ascii_type -> TypeSignature with Default::default()
+clarity/src/vm/types/signatures.rs:1388: replace TypeSignature::parse_list_type_repr -> Result<TypeSignature> with Ok(Default::default())
+clarity/src/vm/types/signatures.rs:1409: replace TypeSignature::parse_tuple_type_repr -> Result<TypeSignature> with Ok(Default::default())
+clarity/src/vm/types/signatures.rs:1019: replace TypeSignature::factor_out_no_type -> Result<TypeSignature> with Ok(Default::default())
+clarity/src/vm/types/signatures.rs:887: replace TupleTypeSignature::parse_name_type_pair_list -> Result<TupleTypeSignature> with Ok(Default::default())
+clarity/src/vm/types/signatures.rs:861: replace TupleTypeSignature::get_type_map -> &BTreeMap<ClarityName, TypeSignature> with &BTreeMap::from_iter([(Default::default(), Default::default())])
+clarity/src/vm/types/signatures.rs:1065: replace TypeSignature::least_supertype_v2_0 -> Result<TypeSignature> with Ok(Default::default())
+clarity/src/vm/types/signatures.rs:1167: replace TypeSignature::least_supertype_v2_1 -> Result<TypeSignature> with Ok(Default::default())
+clarity/src/vm/types/signatures.rs:857: replace TupleTypeSignature::field_type -> Option<&TypeSignature> with Some(&Default::default())
+clarity/src/vm/types/signatures.rs:261: replace FunctionReturnsSignature::canonicalize -> FunctionReturnsSignature with Default::default()
+clarity/src/vm/types/signatures.rs:1431: replace TypeSignature::parse_string_utf8_type_repr -> Result<TypeSignature> with Ok(Default::default())
+clarity/src/vm/types/signatures.rs:1372: replace TypeSignature::parse_atom_type -> Result<TypeSignature> with Ok(Default::default())
+clarity/src/vm/types/signatures.rs:999: replace TypeSignature::contract_name_string_ascii_type -> TypeSignature with Default::default()
+clarity/src/vm/types/signatures.rs:939: replace FunctionSignature::canonicalize -> FunctionSignature with Default::default()
+clarity/src/vm/types/signatures.rs:1551: replace TypeSignature::parse_trait_type_repr -> Result<BTreeMap<ClarityName, FunctionSignature>> with Ok(BTreeMap::from_iter([(Default::default(), Default::default())]))
+clarity/src/vm/types/signatures.rs:1301: replace TypeSignature::list_of -> Result<TypeSignature> with Ok(Default::default())
+clarity/src/vm/types/signatures.rs:1489: replace TypeSignature::parse_type_repr -> Result<TypeSignature> with Ok(Default::default())
+clarity/src/vm/types/signatures.rs:825: replace <impl TryFrom for TupleTypeSignature>::try_from -> Result<TupleTypeSignature> with Ok(Default::default())
+clarity/src/vm/types/signatures.rs:365: replace <impl TryFrom for BufferLength>::try_from -> Result<BufferLength> with Ok(Default::default())
+clarity/src/vm/types/signatures.rs:415: replace <impl TryFrom for StringUTF8Length>::try_from -> Result<StringUTF8Length> with Ok(Default::default())
+clarity/src/vm/types/signatures.rs:321: replace <impl From for FunctionSignature>::from -> FunctionSignature with Default::default()
+clarity/src/vm/types/signatures.rs:376: replace <impl TryFrom for BufferLength>::try_from -> Result<BufferLength> with Ok(Default::default())
+clarity/src/vm/types/signatures.rs:59: replace AssetIdentifier::STX_burned -> AssetIdentifier with Default::default()
+clarity/src/vm/types/signatures.rs:966: replace TypeSignature::min_string_ascii -> TypeSignature with Default::default()
+clarity/src/vm/types/signatures.rs:861: replace TupleTypeSignature::get_type_map -> &BTreeMap<ClarityName, TypeSignature> with &BTreeMap::new()
+clarity/src/vm/types/signatures.rs:962: replace TypeSignature::min_buffer -> TypeSignature with Default::default()
+clarity/src/vm/types/signatures.rs:444: replace ListTypeData::new_list -> Result<ListTypeData> with Ok(Default::default())
+clarity/src/vm/types/signatures.rs:464: replace ListTypeData::destruct -> (TypeSignature, u32) with (Default::default(), 1)
+clarity/src/vm/types/signatures.rs:1812: replace parse_name_type_pairs -> Result<Vec<(ClarityName, TypeSignature)>> with Ok(vec![(Default::default(), Default::default())])
+clarity/src/vm/types/signatures.rs:985: replace TypeSignature::max_string_utf8 -> TypeSignature with Default::default()
+clarity/src/vm/types/signatures.rs:354: replace <impl TryFrom for BufferLength>::try_from -> Result<BufferLength> with Ok(Default::default())
+clarity/src/vm/types/signatures.rs:429: replace <impl TryFrom for StringUTF8Length>::try_from -> Result<StringUTF8Length> with Ok(Default::default())
+clarity/src/vm/types/signatures.rs:1054: replace TypeSignature::least_supertype -> Result<TypeSignature> with Ok(Default::default())
+clarity/src/vm/types/signatures.rs:972: replace TypeSignature::min_string_utf8 -> TypeSignature with Default::default()
+clarity/src/vm/types/signatures.rs:733: replace TypeSignature::canonicalize_v2_1 -> TypeSignature with Default::default()
+clarity/src/vm/types/signatures.rs:49: replace AssetIdentifier::STX -> AssetIdentifier with Default::default()
+clarity/src/vm/types/signatures.rs:335: replace <impl From for TypeSignature>::from -> Self with Default::default()

From e41e89a4513abbdc85bf96b68fde8d6945b5c068 Mon Sep 17 00:00:00 2001
From: ASuciuX <151519329+ASuciuX@users.noreply.github.com>
Date: Mon, 27 Nov 2023 17:16:30 +0200
Subject: [PATCH 0031/1166] Update mutants-testing-general.sh

Co-authored-by: jbencin <jeff.bencin@gmail.com>
---
 mutants-testing-general.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/mutants-testing-general.sh b/mutants-testing-general.sh
index aa0f0e81e7..27aad563a2 100644
--- a/mutants-testing-general.sh
+++ b/mutants-testing-general.sh
@@ -1,7 +1,7 @@
 #!/bin/bash
 
 # Create mutants directory
-mkdir mutants
+mkdir -p mutants
 
 ### Run mutation testing on the packages uncommented
 

From 6ec90efe4d2fdde31b7c38697a655903d2ed0e4c Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 22 Nov 2023 11:35:21 -0500
Subject: [PATCH 0032/1166] BUG: fix find_prepare_phase_sortitions to not
 include one BEFORE prepare phase

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 .../chainstate/nakamoto/coordinator/mod.rs    | 20 ++++++++-----------
 1 file changed, 8 insertions(+), 12 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
index 8e4e297bed..d920f9518a 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
@@ -109,25 +109,21 @@ fn find_prepare_phase_sortitions(
     burnchain: &Burnchain,
     sortition_tip: &SortitionId,
 ) -> Result<Vec<BlockSnapshot>, Error> {
-    let sn = SortitionDB::get_block_snapshot(sort_db.conn(), sortition_tip)?
+    let mut prepare_phase_sn = SortitionDB::get_block_snapshot(sort_db.conn(), sortition_tip)?
         .ok_or(DBError::NotFoundError)?;
 
-    let mut height = sn.block_height;
-    let mut sns = vec![sn];
+    let mut height = prepare_phase_sn.block_height;
+    let mut sns = vec![];
 
     while burnchain.is_in_prepare_phase(height) && height > 0 {
-        let Some(sn) = SortitionDB::get_block_snapshot(
-            sort_db.conn(),
-            &sns.last()
-                .as_ref()
-                .expect("FATAL: unreachable: sns is never empty")
-                .parent_sortition_id,
-        )?
+        let parent_sortition_id = prepare_phase_sn.parent_sortition_id;
+        sns.push(prepare_phase_sn);
+        let Some(sn) = SortitionDB::get_block_snapshot(sort_db.conn(), &parent_sortition_id)?
         else {
             break;
         };
-        height = sn.block_height.saturating_sub(1);
-        sns.push(sn);
+        prepare_phase_sn = sn;
+        height = height.saturating_sub(1);
     }
 
     sns.reverse();

From eee3f20e78842abe0bb68eaf8fe60f70a3f49917 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Tue, 28 Nov 2023 11:47:54 -0500
Subject: [PATCH 0033/1166] BUG: fix reward cycle off by one error in
 get_reward_set_nakamoto

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 .../src/chainstate/nakamoto/coordinator/mod.rs |  7 ++++++-
 stackslib/src/chainstate/stacks/boot/mod.rs    | 18 +++++++++++++++---
 2 files changed, 21 insertions(+), 4 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
index d920f9518a..7cbdea2ad4 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
@@ -61,8 +61,13 @@ impl OnChainRewardSetProvider {
         sortdb: &SortitionDB,
         block_id: &StacksBlockId,
     ) -> Result<RewardSet, Error> {
+        let cycle = burnchain
+            .block_height_to_reward_cycle(current_burn_height)
+            .expect("FATAL: no reward cycle for burn height")
+            + 1;
+
         let registered_addrs =
-            chainstate.get_reward_addresses(burnchain, sortdb, current_burn_height, block_id)?;
+            chainstate.get_reward_addresses_in_cycle(burnchain, sortdb, cycle, block_id)?;
 
         let liquid_ustx = chainstate.get_liquid_ustx(block_id);
 
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 2854dc893d..40c8bea389 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -1080,15 +1080,27 @@ impl StacksChainState {
             .block_height_to_reward_cycle(current_burn_height)
             .ok_or(Error::PoxNoRewardCycle)?;
 
+        self.get_reward_addresses_in_cycle(burnchain, sortdb, reward_cycle, block_id)
+    }
+    /// Get the sequence of reward addresses, as well as the PoX-specified hash mode (which gets
+    /// lost in the conversion to StacksAddress)
+    /// Each address will have at least (get-stacking-minimum) tokens.
+    pub fn get_reward_addresses_in_cycle(
+        &mut self,
+        burnchain: &Burnchain,
+        sortdb: &SortitionDB,
+        reward_cycle: u64,
+        block_id: &StacksBlockId,
+    ) -> Result<Vec<RawRewardSetEntry>, Error> {
         let reward_cycle_start_height = burnchain.reward_cycle_to_block_height(reward_cycle);
 
         let pox_contract_name = burnchain
             .pox_constants
             .active_pox_contract(reward_cycle_start_height);
 
-        debug!(
-            "Active PoX contract at {} (burn height {}): {}",
-            block_id, current_burn_height, &pox_contract_name
+        info!(
+            "Active PoX contract at {} (cycle start height {}): {}",
+            block_id, reward_cycle_start_height, &pox_contract_name
         );
         let result = match pox_contract_name {
             x if x == POX_1_NAME => self.get_reward_addresses_pox_1(sortdb, block_id, reward_cycle),

From 1bb5331785dd31efb97fa529cf3e4b74dfe98b9c Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Tue, 28 Nov 2023 12:27:44 -0500
Subject: [PATCH 0034/1166] CI Fix: Replace Reclaim disk space with cleanup
 action

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 .github/workflows/bitcoin-tests.yml | 17 ++++-------------
 1 file changed, 4 insertions(+), 13 deletions(-)

diff --git a/.github/workflows/bitcoin-tests.yml b/.github/workflows/bitcoin-tests.yml
index efb2895aa0..81cf93d4d9 100644
--- a/.github/workflows/bitcoin-tests.yml
+++ b/.github/workflows/bitcoin-tests.yml
@@ -28,19 +28,10 @@ jobs:
         id: git_checkout
         uses: actions/checkout@v3
 
-      - name: Reclaim disk space
-        id: cleanup
-        run: |
-          sudo apt-get update
-          sudo apt-get remove -y '^dotnet-.*'
-          sudo apt-get remove -y '^llvm-.*'
-          sudo apt-get remove -y 'php.*'
-          sudo apt-get remove -y '^mongodb-.*'
-          sudo apt-get remove -y '^mysql-.*'
-          sudo apt-get remove -y azure-cli google-chrome-stable firefox powershell mono-devel libgl1-mesa-dri
-          sudo apt-get autoremove -y
-          sudo apt-get clean
-          docker system prune --force
+      ## cleanup runner
+      - name: Cleanup Runner
+        id: runner_cleanup
+        uses: stacks-network/actions/cleanup/disk@main
 
       - name: Build bitcoin integration testing image
         id: build_docker_image

From b70dd0033678ea266334ed02f274cdb5163130d2 Mon Sep 17 00:00:00 2001
From: Mitchell Cuevas <6131188+cuevasm@users.noreply.github.com>
Date: Wed, 1 Nov 2023 09:53:01 -0400
Subject: [PATCH 0035/1166] Update README.md

Updating L2 language in readme
---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 06fca3166c..2f1be08873 100644
--- a/README.md
+++ b/README.md
@@ -8,7 +8,7 @@
 
 Reference implementation of the [Stacks blockchain](https://github.com/stacks-network/stacks) in Rust.
 
-Stacks is a layer-1 blockchain that connects to Bitcoin for security and enables decentralized apps and predictable smart contracts using the [Clarity language](https://clarity-lang.org/). Stacks implements [Proof of Transfer (PoX)](https://community.stacks.org/pox) mining that anchors to Bitcoin security. Leader election happens at the Bitcoin blockchain and Stacks (STX) miners write new blocks on the separate Stacks blockchain. With PoX there is no need to modify Bitcoin to enable smart contracts and decentralized apps.
+Stacks is a layer-2 blockchain that uses Bitcoin as a base layer for security and enables decentralized apps and predictable smart contracts using the [Clarity language](https://clarity-lang.org/). Stacks implements [Proof of Transfer (PoX)](https://community.stacks.org/pox) mining that anchors to Bitcoin security. Leader election happens at the Bitcoin blockchain and Stacks (STX) miners write new blocks on the separate Stacks blockchain. With PoX there is no need to modify Bitcoin to enable smart contracts and decentralized apps.
 
 [![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg?style=flat)](https://www.gnu.org/licenses/gpl-3.0)
 [![Release](https://img.shields.io/github/v/release/stacks-network/stacks-blockchain?style=flat)](https://github.com/stacks-network/stacks-blockchain/releases/latest)

From 0b88a92aa5e30d89e51bdbc5e3bb3bf4e43f690a Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Fri, 17 Nov 2023 17:15:15 -0500
Subject: [PATCH 0036/1166] Update `wsts` to `v5.0.0`

This commit also contains the following changes:
  - Make `ThresholdSignature` wrapper around `wsts::common::signature` in order to use `verify()`
  - Eliminate `p256k1` from `Cargo.toml`
  - Use a common version of `wsts` for all workspace members

I had to update all workspace members, including `stacks-signer`, because it wouldn't build if `stackslib` was using a different version of `wsts`
---
 Cargo.lock                                    | 11 +++----
 Cargo.toml                                    |  4 +++
 stacks-signer/Cargo.toml                      |  3 +-
 stacks-signer/src/config.rs                   |  4 +--
 stacks-signer/src/main.rs                     |  6 ++++
 stacks-signer/src/runloop.rs                  | 33 ++++++++++---------
 stacks-signer/src/stacks_client.rs            |  3 +-
 stacks-signer/src/utils.rs                    |  4 +--
 stackslib/Cargo.toml                          |  3 +-
 stackslib/src/chainstate/stacks/mod.rs        |  5 +--
 .../src/chainstate/stacks/transaction.rs      | 28 +++++++++++-----
 testnet/stacks-node/Cargo.toml                |  3 +-
 testnet/stacks-node/src/tests/signer.rs       |  3 ++
 13 files changed, 64 insertions(+), 46 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 7a8502fa3f..5bc70b146b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2353,9 +2353,9 @@ checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39"
 
 [[package]]
 name = "p256k1"
-version = "5.5.0"
+version = "6.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22e81c2cb5a1936d3f26278f9d698932239d03ddf0d5818392d91cd5f98ffc79"
+checksum = "5afcf536d20c074ef45371ee9a654dcfc46fb2dde18ecc54ec30c936eb850fa2"
 dependencies = [
  "bindgen",
  "bitvec",
@@ -3548,7 +3548,6 @@ dependencies = [
  "lazy_static",
  "libc",
  "libsigner",
- "p256k1",
  "pico-args",
  "rand 0.7.3",
  "regex",
@@ -3582,7 +3581,6 @@ dependencies = [
  "hashbrown 0.14.0",
  "libsigner",
  "libstackerdb",
- "p256k1",
  "rand_core 0.6.4",
  "reqwest",
  "secp256k1",
@@ -3618,7 +3616,6 @@ dependencies = [
  "libstackerdb",
  "mio 0.6.23",
  "nix",
- "p256k1",
  "percent-encoding",
  "pox-locking",
  "prometheus",
@@ -4711,9 +4708,9 @@ dependencies = [
 
 [[package]]
 name = "wsts"
-version = "4.0.0"
+version = "5.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a0c0ec44cbd35be82490c8c566ad4971f7b41ffe8508f1c9938140df7fe18b2"
+checksum = "2c250118354755b4abb091a83cb8d659b511c0ae211ccdb3b1254e3db199cb86"
 dependencies = [
  "aes-gcm 0.10.2",
  "bs58 0.5.0",
diff --git a/Cargo.toml b/Cargo.toml
index df81990bc8..a861f143e9 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -12,6 +12,10 @@ members = [
     "stacks-signer",
     "testnet/stacks-node"]
 
+# Dependencies we want to keep the same between workspace members
+[workspace.dependencies]  
+wsts = "5.0"
+
 # Use a bit more than default optimization for
 #  dev builds to speed up test execution
 [profile.dev]
diff --git a/stacks-signer/Cargo.toml b/stacks-signer/Cargo.toml
index 50f501b51a..cd5571657f 100644
--- a/stacks-signer/Cargo.toml
+++ b/stacks-signer/Cargo.toml
@@ -27,7 +27,6 @@ clap = { version = "4.1.1", features = ["derive", "env"] }
 hashbrown = "0.14"
 libsigner = { path = "../libsigner" }
 libstackerdb = { path = "../libstackerdb" }
-p256k1 = "5.5"
 rand_core = "0.6"
 reqwest = { version = "0.11.22", features = ["blocking", "json"] }
 serde = "1"
@@ -42,7 +41,7 @@ thiserror = "1.0"
 toml = "0.5.6"
 tracing = "0.1.37"
 tracing-subscriber = { version = "0.3.17", features = ["env-filter"] }
-wsts = "4.0.0"
+wsts = { workspace = true }
 
 [dependencies.serde_json]
 version = "1.0"
diff --git a/stacks-signer/src/config.rs b/stacks-signer/src/config.rs
index d634dd0cdd..4991fb3fff 100644
--- a/stacks-signer/src/config.rs
+++ b/stacks-signer/src/config.rs
@@ -23,14 +23,14 @@ use std::time::Duration;
 use blockstack_lib::chainstate::stacks::TransactionVersion;
 use clarity::vm::types::QualifiedContractIdentifier;
 use hashbrown::HashMap;
-use p256k1::ecdsa;
-use p256k1::scalar::Scalar;
 use serde::Deserialize;
 use stacks_common::address::{
     AddressHashMode, C32_ADDRESS_VERSION_MAINNET_SINGLESIG, C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
 };
 use stacks_common::consts::{CHAIN_ID_MAINNET, CHAIN_ID_TESTNET};
 use stacks_common::types::chainstate::{StacksAddress, StacksPrivateKey, StacksPublicKey};
+use wsts::curve::ecdsa;
+use wsts::curve::scalar::Scalar;
 use wsts::state_machine::PublicKeys;
 
 /// List of key_ids for each signer_id
diff --git a/stacks-signer/src/main.rs b/stacks-signer/src/main.rs
index dce30b8d42..a2fdac84eb 100644
--- a/stacks-signer/src/main.rs
+++ b/stacks-signer/src/main.rs
@@ -124,6 +124,9 @@ fn process_dkg_result(dkg_res: &[OperationResult]) {
                 &schnorr_proof.r, &schnorr_proof.s,
             );
         }
+        OperationResult::DkgError(..) | OperationResult::SignError(..) => {
+            todo!()
+        }
     }
 }
 
@@ -147,6 +150,9 @@ fn process_sign_result(sign_res: &[OperationResult]) {
                 &schnorr_proof.r, &schnorr_proof.s,
             );
         }
+        OperationResult::DkgError(..) | OperationResult::SignError(..) => {
+            todo!()
+        }
     }
 }
 
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 7d6bf54d1a..e4a6e5c01b 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -2,15 +2,16 @@ use std::collections::VecDeque;
 use std::sync::mpsc::Sender;
 use std::time::Duration;
 
+use backoff::default;
 use libsigner::{SignerRunLoop, StackerDBChunksEvent};
-use p256k1::ecdsa;
 use slog::{slog_debug, slog_error, slog_info, slog_warn};
 use stacks_common::{debug, error, info, warn};
 use wsts::common::MerkleRoot;
+use wsts::curve::ecdsa;
 use wsts::net::{Message, Packet, Signable};
 use wsts::state_machine::coordinator::frost::Coordinator as FrostCoordinator;
-use wsts::state_machine::coordinator::Coordinatable;
-use wsts::state_machine::signer::SigningRound;
+use wsts::state_machine::coordinator::{Config as CoordinatorConfig, Coordinator};
+use wsts::state_machine::signer::Signer;
 use wsts::state_machine::{OperationResult, PublicKeys};
 use wsts::v2;
 
@@ -56,7 +57,7 @@ pub struct RunLoop<C> {
     /// The signing round used to sign messages
     // TODO: update this to use frost_signer directly instead of the frost signing round
     // See: https://github.com/stacks-network/stacks-blockchain/issues/3913
-    pub signing_round: SigningRound<v2::Signer>,
+    pub signing_round: Signer<v2::Signer>,
     /// The stacks client
     pub stacks_client: StacksClient,
     /// Received Commands that need to be processed
@@ -65,7 +66,7 @@ pub struct RunLoop<C> {
     pub state: State,
 }
 
-impl<C: Coordinatable> RunLoop<C> {
+impl<C: Coordinator> RunLoop<C> {
     /// Initialize the signer, reading the stacker-db state and setting the aggregate public key
     fn initialize(&mut self) -> Result<(), ClientError> {
         // TODO: update to read stacker db to get state.
@@ -92,7 +93,7 @@ impl<C: Coordinatable> RunLoop<C> {
         match command {
             RunLoopCommand::Dkg => {
                 info!("Starting DKG");
-                match self.coordinator.start_distributed_key_generation() {
+                match self.coordinator.start_dkg_round() {
                     Ok(msg) => {
                         let ack = self
                             .stacks_client
@@ -117,7 +118,7 @@ impl<C: Coordinatable> RunLoop<C> {
                 info!("Signing message: {:?}", message);
                 match self
                     .coordinator
-                    .start_signing_message(message, *is_taproot, *merkle_root)
+                    .start_signing_round(message, *is_taproot, *merkle_root)
                 {
                     Ok(msg) => {
                         let ack = self
@@ -231,15 +232,17 @@ impl From<&Config> for RunLoop<FrostCoordinator<v2::Aggregator>> {
             .get(&config.signer_id)
             .unwrap()
             .iter()
-            .map(|i| i - 1) // SigningRound::new (unlike SigningRound::from) doesn't do this
+            .map(|i| i - 1) // Signer::new (unlike Signer::from) doesn't do this
             .collect::<Vec<u32>>();
-        let coordinator = FrostCoordinator::new(
-            total_signers,
-            total_keys,
+        let coordinator_config = CoordinatorConfig {
             threshold,
-            config.message_private_key,
-        );
-        let signing_round = SigningRound::new(
+            num_signers: total_signers,
+            num_keys: total_keys,
+            message_private_key: config.message_private_key,
+            ..Default::default()
+        };
+        let coordinator = FrostCoordinator::new(coordinator_config);
+        let signing_round = Signer::new(
             threshold,
             total_signers,
             total_keys,
@@ -260,7 +263,7 @@ impl From<&Config> for RunLoop<FrostCoordinator<v2::Aggregator>> {
     }
 }
 
-impl<C: Coordinatable> SignerRunLoop<Vec<OperationResult>, RunLoopCommand> for RunLoop<C> {
+impl<C: Coordinator> SignerRunLoop<Vec<OperationResult>, RunLoopCommand> for RunLoop<C> {
     fn set_event_timeout(&mut self, timeout: Duration) {
         self.event_timeout = timeout;
     }
diff --git a/stacks-signer/src/stacks_client.rs b/stacks-signer/src/stacks_client.rs
index 0621df4b09..cc70a0b8ce 100644
--- a/stacks-signer/src/stacks_client.rs
+++ b/stacks-signer/src/stacks_client.rs
@@ -18,8 +18,9 @@ use slog::{slog_debug, slog_warn};
 use stacks_common::codec::StacksMessageCodec;
 use stacks_common::types::chainstate::{StacksAddress, StacksPrivateKey, StacksPublicKey};
 use stacks_common::{debug, warn};
+use wsts::curve::point::Point;
+use wsts::curve::scalar::Scalar;
 use wsts::net::{Message, Packet};
-use wsts::{Point, Scalar};
 
 use crate::config::Config;
 
diff --git a/stacks-signer/src/utils.rs b/stacks-signer/src/utils.rs
index 86436f09af..5664fd7076 100644
--- a/stacks-signer/src/utils.rs
+++ b/stacks-signer/src/utils.rs
@@ -1,11 +1,11 @@
 use std::time::Duration;
 
-use p256k1::ecdsa;
 use rand_core::OsRng;
 use slog::slog_debug;
 use stacks_common::debug;
 use stacks_common::types::chainstate::{StacksAddress, StacksPrivateKey};
-use wsts::Scalar;
+use wsts::curve::ecdsa;
+use wsts::curve::scalar::Scalar;
 
 use crate::stacks_client::SLOTS_PER_USER;
 
diff --git a/stackslib/Cargo.toml b/stackslib/Cargo.toml
index bc114d2051..54a87b22c6 100644
--- a/stackslib/Cargo.toml
+++ b/stackslib/Cargo.toml
@@ -55,8 +55,7 @@ stacks-common = { path = "../stacks-common" }
 pox-locking = { path = "../pox-locking" }
 libstackerdb = { path = "../libstackerdb" }
 siphasher = "0.3.7"
-wsts = "4.0.0"
-p256k1 = "5.5.0"
+wsts = {workspace = true}
 
 [target.'cfg(unix)'.dependencies]
 nix = "0.23"
diff --git a/stackslib/src/chainstate/stacks/mod.rs b/stackslib/src/chainstate/stacks/mod.rs
index a822ea5403..defeb01eab 100644
--- a/stackslib/src/chainstate/stacks/mod.rs
+++ b/stackslib/src/chainstate/stacks/mod.rs
@@ -658,10 +658,7 @@ pub enum TenureChangeError {
 
 /// Schnorr threshold signature using types from `wsts`
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct ThresholdSignature {
-    R: wsts::Point,
-    z: wsts::Scalar,
-}
+pub struct ThresholdSignature(pub wsts::common::Signature);
 
 /// A transaction from Stackers to signal new mining tenure
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
diff --git a/stackslib/src/chainstate/stacks/transaction.rs b/stackslib/src/chainstate/stacks/transaction.rs
index 06a738730d..60c58b985a 100644
--- a/stackslib/src/chainstate/stacks/transaction.rs
+++ b/stackslib/src/chainstate/stacks/transaction.rs
@@ -29,6 +29,7 @@ use stacks_common::types::StacksPublicKeyBuffer;
 use stacks_common::util::hash::{to_hex, MerkleHashFunc, MerkleTree, Sha512Trunc256Sum};
 use stacks_common::util::retry::BoundReader;
 use stacks_common::util::secp256k1::MessageSignature;
+use wsts::curve as p256k1;
 
 use crate::burnchains::Txid;
 use crate::chainstate::stacks::{TransactionPayloadID, *};
@@ -151,17 +152,18 @@ impl StacksMessageCodec for TenureChangeCause {
 
 impl StacksMessageCodec for ThresholdSignature {
     fn consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), codec_error> {
-        let compressed = self.R.compress();
+        let compressed = self.0.R.compress();
         let bytes = compressed.as_bytes();
         fd.write_all(bytes)
             .map_err(crate::codec::Error::WriteError)?;
-        write_next(fd, &self.z.to_bytes())?;
+        write_next(fd, &self.0.z.to_bytes())?;
         Ok(())
     }
 
     fn consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, codec_error> {
-        use p256k1::point::Compressed;
-        use wsts::{Point, Scalar};
+        use p256k1::point::{Compressed, Point};
+        use p256k1::scalar::Scalar;
+        use wsts::common::Signature;
 
         // Read curve point
         let mut buf = [0u8; 33];
@@ -177,17 +179,25 @@ impl StacksMessageCodec for ThresholdSignature {
             .map_err(crate::codec::Error::ReadError)?;
         let z = Scalar::from(buf);
 
-        Ok(Self { R, z })
+        Ok(Self(Signature { R, z }))
     }
 }
 
 impl ThresholdSignature {
+    pub fn verify(&self, public_key: &p256k1::point::Point, msg: &[u8]) -> bool {
+        self.0.verify(public_key, msg)
+    }
+
     /// Create mock data for testing. Not valid data
     pub fn mock() -> Self {
-        Self {
-            R: wsts::Point::G(),
-            z: wsts::Scalar::new(),
-        }
+        use p256k1::point::Point;
+        use p256k1::scalar::Scalar;
+        use wsts::common::Signature;
+
+        Self(Signature {
+            R: Point::G(),
+            z: Scalar::new(),
+        })
     }
 }
 
diff --git a/testnet/stacks-node/Cargo.toml b/testnet/stacks-node/Cargo.toml
index f75d2c4224..7e0e7387ec 100644
--- a/testnet/stacks-node/Cargo.toml
+++ b/testnet/stacks-node/Cargo.toml
@@ -38,10 +38,9 @@ clarity = { path = "../../clarity", features = ["default", "testing"]}
 stacks-common = { path = "../../stacks-common", features = ["default", "testing"] }
 stacks = { package = "stackslib", path = "../../stackslib", features = ["default", "testing"] }
 stacks-signer = { path = "../../stacks-signer" }
-p256k1 = "5.5"
 tracing = "0.1.37"
 tracing-subscriber = { version = "0.3.17", features = ["env-filter"] }
-wsts = "4.0"
+wsts = {workspace = true}
 
 [dependencies.rusqlite]
 version = "=0.24.2"
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index f064c5ed84..f2c44c483e 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -310,6 +310,9 @@ fn test_stackerdb_dkg() {
                         info!("Received SchnorrProof ({},{})", &proof.r, &proof.s);
                         schnorr_proof = Some(proof);
                     }
+                    OperationResult::DkgError(..) | OperationResult::SignError(..) => {
+                        todo!()
+                    }
                 }
             }
             if aggregate_group_key.is_some() && frost_signature.is_some() && schnorr_proof.is_some()

From 3169ae196b325fd060576f2bf8fe9e83284db217 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Wed, 29 Nov 2023 11:51:38 -0500
Subject: [PATCH 0037/1166] Clean up `use` statements

---
 .../src/chainstate/stacks/transaction.rs      | 26 +++++++------------
 1 file changed, 10 insertions(+), 16 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/transaction.rs b/stackslib/src/chainstate/stacks/transaction.rs
index 60c58b985a..8d9eb6873d 100644
--- a/stackslib/src/chainstate/stacks/transaction.rs
+++ b/stackslib/src/chainstate/stacks/transaction.rs
@@ -29,7 +29,9 @@ use stacks_common::types::StacksPublicKeyBuffer;
 use stacks_common::util::hash::{to_hex, MerkleHashFunc, MerkleTree, Sha512Trunc256Sum};
 use stacks_common::util::retry::BoundReader;
 use stacks_common::util::secp256k1::MessageSignature;
-use wsts::curve as p256k1;
+use wsts::common::Signature as Secp256k1Signature;
+use wsts::curve::point::{Compressed as Secp256k1Compressed, Point as Secp256k1Point};
+use wsts::curve::scalar::Scalar as Secp256k1Scalar;
 
 use crate::burnchains::Txid;
 use crate::chainstate::stacks::{TransactionPayloadID, *};
@@ -161,15 +163,11 @@ impl StacksMessageCodec for ThresholdSignature {
     }
 
     fn consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, codec_error> {
-        use p256k1::point::{Compressed, Point};
-        use p256k1::scalar::Scalar;
-        use wsts::common::Signature;
-
         // Read curve point
         let mut buf = [0u8; 33];
         fd.read_exact(&mut buf)
             .map_err(crate::codec::Error::ReadError)?;
-        let R = Point::try_from(&Compressed::from(buf)).map_err(|_| {
+        let R = Secp256k1Point::try_from(&Secp256k1Compressed::from(buf)).map_err(|_| {
             crate::codec::Error::DeserializeError("Failed to read curve point".into())
         })?;
 
@@ -177,26 +175,22 @@ impl StacksMessageCodec for ThresholdSignature {
         let mut buf = [0u8; 32];
         fd.read_exact(&mut buf)
             .map_err(crate::codec::Error::ReadError)?;
-        let z = Scalar::from(buf);
+        let z = Secp256k1Scalar::from(buf);
 
-        Ok(Self(Signature { R, z }))
+        Ok(Self(Secp256k1Signature { R, z }))
     }
 }
 
 impl ThresholdSignature {
-    pub fn verify(&self, public_key: &p256k1::point::Point, msg: &[u8]) -> bool {
+    pub fn verify(&self, public_key: &Secp256k1Point, msg: &[u8]) -> bool {
         self.0.verify(public_key, msg)
     }
 
     /// Create mock data for testing. Not valid data
     pub fn mock() -> Self {
-        use p256k1::point::Point;
-        use p256k1::scalar::Scalar;
-        use wsts::common::Signature;
-
-        Self(Signature {
-            R: Point::G(),
-            z: Scalar::new(),
+        Self(Secp256k1Signature {
+            R: Secp256k1Point::G(),
+            z: Secp256k1Scalar::new(),
         })
     }
 }

From b1649a3133a3b3911f42f2654d4400ef8c494e7e Mon Sep 17 00:00:00 2001
From: ASuciuX <asuciu@hiro.so>
Date: Wed, 29 Nov 2023 22:00:25 +0200
Subject: [PATCH 0038/1166] feat: renamed mod to lib.rs

---
 clarity/Cargo.toml             | 2 +-
 clarity/src/{mod.rs => lib.rs} | 0
 2 files changed, 1 insertion(+), 1 deletion(-)
 rename clarity/src/{mod.rs => lib.rs} (100%)

diff --git a/clarity/Cargo.toml b/clarity/Cargo.toml
index 791e981015..e83c77f823 100644
--- a/clarity/Cargo.toml
+++ b/clarity/Cargo.toml
@@ -15,7 +15,7 @@ resolver = "2"
 
 [lib]
 name = "clarity"
-path = "./src/mod.rs"
+path = "./src/lib.rs"
 
 [dependencies]
 rand = "0.7.3"
diff --git a/clarity/src/mod.rs b/clarity/src/lib.rs
similarity index 100%
rename from clarity/src/mod.rs
rename to clarity/src/lib.rs

From 4cad8baf8fa0abf21f59a30193d80e97a8573ca1 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 8 Nov 2023 12:43:22 -0500
Subject: [PATCH 0039/1166] Update wsts and p256k1 libs to latest

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 Cargo.lock               | 55 +++++++++++++++++++++++++++++++++++++---
 stacks-common/Cargo.toml |  2 ++
 2 files changed, 53 insertions(+), 4 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 5bc70b146b..1e8a2b6a25 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2351,6 +2351,29 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39"
 
+[[package]]
+name = "p256k1"
+version = "5.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22e81c2cb5a1936d3f26278f9d698932239d03ddf0d5818392d91cd5f98ffc79"
+dependencies = [
+ "bindgen",
+ "bitvec",
+ "bs58 0.4.0",
+ "cc",
+ "hex",
+ "itertools",
+ "num-traits",
+ "primitive-types",
+ "proc-macro2",
+ "quote",
+ "rand_core 0.6.4",
+ "rustfmt-wrapper",
+ "serde",
+ "sha2 0.10.6",
+ "syn 2.0.29",
+]
+
 [[package]]
 name = "p256k1"
 version = "6.0.0"
@@ -3514,6 +3537,7 @@ dependencies = [
  "lazy_static",
  "libc",
  "nix",
+ "p256k1 5.5.0",
  "percent-encoding",
  "rand 0.7.3",
  "ripemd",
@@ -3532,6 +3556,7 @@ dependencies = [
  "slog-term",
  "time 0.2.27",
  "winapi 0.3.9",
+ "wsts 4.0.0",
 ]
 
 [[package]]
@@ -3567,7 +3592,7 @@ dependencies = [
  "tracing",
  "tracing-subscriber",
  "warp",
- "wsts",
+ "wsts 5.0.0",
 ]
 
 [[package]]
@@ -3597,7 +3622,7 @@ dependencies = [
  "toml",
  "tracing",
  "tracing-subscriber",
- "wsts",
+ "wsts 5.0.0",
 ]
 
 [[package]]
@@ -3643,7 +3668,7 @@ dependencies = [
  "time 0.2.27",
  "url",
  "winapi 0.3.9",
- "wsts",
+ "wsts 5.0.0",
 ]
 
 [[package]]
@@ -4706,6 +4731,28 @@ dependencies = [
  "winapi-build",
 ]
 
+[[package]]
+name = "wsts"
+version = "4.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4a0c0ec44cbd35be82490c8c566ad4971f7b41ffe8508f1c9938140df7fe18b2"
+dependencies = [
+ "aes-gcm 0.10.2",
+ "bs58 0.5.0",
+ "hashbrown 0.14.0",
+ "hex",
+ "num-traits",
+ "p256k1 5.5.0",
+ "polynomial",
+ "primitive-types",
+ "rand_core 0.6.4",
+ "serde",
+ "sha2 0.10.6",
+ "thiserror",
+ "tracing",
+ "tracing-subscriber",
+]
+
 [[package]]
 name = "wsts"
 version = "5.0.0"
@@ -4717,7 +4764,7 @@ dependencies = [
  "hashbrown 0.14.0",
  "hex",
  "num-traits",
- "p256k1",
+ "p256k1 6.0.0",
  "polynomial",
  "primitive-types",
  "rand_core 0.6.4",
diff --git a/stacks-common/Cargo.toml b/stacks-common/Cargo.toml
index 863a82d53c..8894ed9cdb 100644
--- a/stacks-common/Cargo.toml
+++ b/stacks-common/Cargo.toml
@@ -31,6 +31,8 @@ slog-term = "2.6.0"
 slog-json = { version = "2.3.0", optional = true }
 chrono = "0.4.19"
 libc = "0.2.82"
+wsts = "4.0.0"
+p256k1 = "5.5"
 
 [target.'cfg(unix)'.dependencies]
 nix = "0.23"

From 2e45ed873f595fb12a40ac42a4f6ba5677120fd1 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 8 Nov 2023 13:54:53 -0500
Subject: [PATCH 0040/1166] Add wsts::common::Signature to and from
 SchnorrSignature conversion

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-common/src/types/chainstate.rs |  6 +++-
 stacks-common/src/util/secp256k1.rs   | 43 +++++++++++++++++++++++++++
 2 files changed, 48 insertions(+), 1 deletion(-)

diff --git a/stacks-common/src/types/chainstate.rs b/stacks-common/src/types/chainstate.rs
index ac6849dfc6..72dbb1e23a 100644
--- a/stacks-common/src/types/chainstate.rs
+++ b/stacks-common/src/types/chainstate.rs
@@ -14,7 +14,9 @@ use crate::codec::{read_next, write_next, Error as CodecError, StacksMessageCode
 use crate::consts::{FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH};
 use crate::deps_common::bitcoin::util::hash::Sha256dHash;
 use crate::util::hash::{to_hex, DoubleSha256, Hash160, Sha512Trunc256Sum, HASH160_ENCODED_SIZE};
-use crate::util::secp256k1::{MessageSignature, Secp256k1PrivateKey, Secp256k1PublicKey};
+use crate::util::secp256k1::{
+    MessageSignature, SchnorrSignature, Secp256k1PrivateKey, Secp256k1PublicKey,
+};
 use crate::util::uint::Uint256;
 use crate::util::vrf::{VRFProof, VRF_PROOF_ENCODED_SIZE};
 
@@ -336,6 +338,7 @@ impl_byte_array_rusqlite_only!(VRFProof);
 impl_byte_array_rusqlite_only!(TrieHash);
 impl_byte_array_rusqlite_only!(Sha512Trunc256Sum);
 impl_byte_array_rusqlite_only!(MessageSignature);
+impl_byte_array_rusqlite_only!(SchnorrSignature);
 
 impl_byte_array_message_codec!(TrieHash, TRIEHASH_ENCODED_SIZE as u32);
 impl_byte_array_message_codec!(Sha512Trunc256Sum, 32);
@@ -346,6 +349,7 @@ impl_byte_array_message_codec!(BurnchainHeaderHash, 32);
 impl_byte_array_message_codec!(BlockHeaderHash, 32);
 impl_byte_array_message_codec!(StacksBlockId, 32);
 impl_byte_array_message_codec!(MessageSignature, 65);
+impl_byte_array_message_codec!(SchnorrSignature, 65);
 
 impl BlockHeaderHash {
     pub fn to_hash160(&self) -> Hash160 {
diff --git a/stacks-common/src/util/secp256k1.rs b/stacks-common/src/util/secp256k1.rs
index 7b6134b8b2..43ed1bf97b 100644
--- a/stacks-common/src/util/secp256k1.rs
+++ b/stacks-common/src/util/secp256k1.rs
@@ -14,6 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+use p256k1::point::Compressed;
 use rand::{thread_rng, RngCore};
 use secp256k1;
 use secp256k1::ecdsa::{
@@ -27,8 +28,11 @@ use secp256k1::{
 use serde::de::{Deserialize, Error as de_Error};
 use serde::ser::Error as ser_Error;
 use serde::Serialize;
+use wsts::common::Signature as WSTSSignature;
+use wsts::{Point, Scalar};
 
 use super::hash::Sha256Sum;
+use crate::impl_byte_array_message_codec;
 use crate::types::{PrivateKey, PublicKey};
 use crate::util::hash::{hex_bytes, to_hex};
 
@@ -115,6 +119,45 @@ impl Default for Secp256k1PublicKey {
     }
 }
 
+pub struct SchnorrSignature(pub [u8; 65]);
+impl_array_newtype!(SchnorrSignature, u8, 65);
+impl_array_hexstring_fmt!(SchnorrSignature);
+impl_byte_array_newtype!(SchnorrSignature, u8, 65);
+impl_byte_array_serde!(SchnorrSignature);
+pub const SCHNORR_SIGNATURE_ENCODED_SIZE: u32 = 65;
+
+impl Default for SchnorrSignature {
+    /// Creates a default Schnorr Signature. Note this is not a valid signature.
+    fn default() -> Self {
+        Self([0u8; 65])
+    }
+}
+
+impl SchnorrSignature {
+    /// Attempt to convert a Schnorr signature to a WSTS Signature
+    pub fn to_wsts_signature(&self) -> Option<WSTSSignature> {
+        // TODO: update wsts to add a TryFrom for a [u8; 65] and a slice to a Signature
+        let point_bytes: [u8; 33] = self.0[..33].try_into().ok()?;
+        let scalar_bytes: [u8; 32] = self.0[33..].try_into().ok()?;
+        let point = Point::try_from(&Compressed::from(point_bytes)).ok()?;
+        let scalar = Scalar::from(scalar_bytes);
+        Some(WSTSSignature {
+            R: point,
+            z: scalar,
+        })
+    }
+}
+
+/// Convert a WSTS Signature to a SchnorrSignature
+impl From<&WSTSSignature> for SchnorrSignature {
+    fn from(signature: &WSTSSignature) -> Self {
+        let mut buf = [0u8; 65];
+        buf[..33].copy_from_slice(&signature.R.compress().data);
+        buf[33..].copy_from_slice(&signature.z.to_bytes());
+        SchnorrSignature(buf)
+    }
+}
+
 impl Secp256k1PublicKey {
     #[cfg(any(test, feature = "testing"))]
     pub fn new() -> Secp256k1PublicKey {

From 1a45811b371659c749737c9258217b9348f75b97 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 8 Nov 2023 14:07:57 -0500
Subject: [PATCH 0041/1166] Add a test for schnorr signature serde

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 Cargo.lock                          |  1 +
 stacks-common/Cargo.toml            |  1 +
 stacks-common/src/util/secp256k1.rs | 75 +++++++++++++++++++++++++++++
 3 files changed, 77 insertions(+)

diff --git a/Cargo.lock b/Cargo.lock
index 1e8a2b6a25..0800b52481 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3540,6 +3540,7 @@ dependencies = [
  "p256k1 5.5.0",
  "percent-encoding",
  "rand 0.7.3",
+ "rand_core 0.6.4",
  "ripemd",
  "rstest 0.11.0",
  "rstest_reuse 0.1.3",
diff --git a/stacks-common/Cargo.toml b/stacks-common/Cargo.toml
index 8894ed9cdb..079a769b1d 100644
--- a/stacks-common/Cargo.toml
+++ b/stacks-common/Cargo.toml
@@ -71,6 +71,7 @@ features = ["std"]
 rstest = "0.11.0"
 rstest_reuse = "0.1.3"
 assert-json-diff = "1.0.0"
+rand_core = "0.6"
 
 [features]
 default = ["developer-mode"]
diff --git a/stacks-common/src/util/secp256k1.rs b/stacks-common/src/util/secp256k1.rs
index 43ed1bf97b..f70c0eb770 100644
--- a/stacks-common/src/util/secp256k1.rs
+++ b/stacks-common/src/util/secp256k1.rs
@@ -744,4 +744,79 @@ mod tests {
             runtime_verify - runtime_recover
         );
     }
+
+    #[test]
+    fn test_schnorr_signature_serde() {
+        use wsts::traits::Aggregator;
+
+        // Test that an empty conversion fails.
+        let empty_signature = SchnorrSignature::default();
+        assert!(empty_signature.to_wsts_signature().is_none());
+
+        // Generate a random Signature and ensure it successfully converts
+        let mut rng = rand_core::OsRng::default();
+        let msg =
+            "You Idiots! These Are Not Them! You\'ve Captured Their Stunt Doubles!".as_bytes();
+
+        let num_keys = 10;
+        let threshold = 7;
+        let party_key_ids: Vec<Vec<u32>> =
+            vec![vec![0, 1, 2], vec![3, 4], vec![5, 6, 7], vec![8, 9]];
+        let num_parties = party_key_ids.len().try_into().unwrap();
+
+        // Create the parties
+        let mut signers: Vec<wsts::v2::Party> = party_key_ids
+            .iter()
+            .enumerate()
+            .map(|(pid, pkids)| {
+                wsts::v2::Party::new(
+                    pid.try_into().unwrap(),
+                    pkids,
+                    num_parties,
+                    num_keys,
+                    threshold,
+                    &mut rng,
+                )
+            })
+            .collect();
+
+        // Generate an aggregate public key
+        let comms = match wsts::v2::test_helpers::dkg(&mut signers, &mut rng) {
+            Ok(comms) => comms,
+            Err(secret_errors) => {
+                panic!("Got secret errors from DKG: {:?}", secret_errors);
+            }
+        };
+        let aggregate_public_key = comms
+            .iter()
+            .fold(Point::default(), |s, comm| s + comm.poly[0]);
+
+        // signers [0,1,3] have "threshold" keys
+        {
+            let mut signers = [signers[0].clone(), signers[1].clone(), signers[3].clone()].to_vec();
+            let mut sig_agg = wsts::v2::Aggregator::new(num_keys, threshold);
+
+            sig_agg.init(comms.clone()).expect("aggregator init failed");
+
+            let (nonces, sig_shares, key_ids) =
+                wsts::v2::test_helpers::sign(msg, &mut signers, &mut rng);
+            let original_signature = sig_agg
+                .sign(msg, &nonces, &sig_shares, &key_ids)
+                .expect("aggregator sig failed");
+            // Serialize the signature and verify the results
+            let schnorr_signature = SchnorrSignature::from(&original_signature);
+            assert_eq!(
+                schnorr_signature[..33],
+                original_signature.R.compress().data[..]
+            );
+            assert_eq!(schnorr_signature[33..], original_signature.z.to_bytes());
+
+            // Deserialize the signature and verify the results
+            let reverted_signature = schnorr_signature
+                .to_wsts_signature()
+                .expect("Failed to convert schnorr signature to wsts signature");
+            assert_eq!(reverted_signature.R, original_signature.R);
+            assert_eq!(reverted_signature.z, original_signature.z);
+        }
+    }
 }

From 6ea4ddb3daff95e50650315bd9ceb669785928d4 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 8 Nov 2023 14:08:20 -0500
Subject: [PATCH 0042/1166] Add a stacker signature hash function that includes
 the miner signature

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stackslib/src/chainstate/nakamoto/mod.rs | 18 +++++++++++++++++-
 1 file changed, 17 insertions(+), 1 deletion(-)

diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index 3d55999b16..6865820c61 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -328,7 +328,7 @@ impl StacksMessageCodec for NakamotoBlockHeader {
 }
 
 impl NakamotoBlockHeader {
-    /// Calculate the message digest to sign.
+    /// Calculate the message digest for miners to sign.
     /// This includes all fields _except_ the signatures.
     pub fn signature_hash(&self) -> Result<Sha512Trunc256Sum, CodecError> {
         let mut hasher = Sha512_256::new();
@@ -343,6 +343,22 @@ impl NakamotoBlockHeader {
         Ok(Sha512Trunc256Sum::from_hasher(hasher))
     }
 
+    /// Calculate the message digest for stackers to sign.
+    /// This includes all fields _except_ the stacker signature.
+    pub fn stacker_signature_hash(&self) -> Result<Sha512Trunc256Sum, CodecError> {
+        let mut hasher = Sha512_256::new();
+        let fd = &mut hasher;
+        write_next(fd, &self.version)?;
+        write_next(fd, &self.chain_length)?;
+        write_next(fd, &self.burn_spent)?;
+        write_next(fd, &self.consensus_hash)?;
+        write_next(fd, &self.parent_block_id)?;
+        write_next(fd, &self.tx_merkle_root)?;
+        write_next(fd, &self.state_index_root)?;
+        write_next(fd, &self.miner_signature)?;
+        Ok(Sha512Trunc256Sum::from_hasher(hasher))
+    }
+
     pub fn recover_miner_pk(&self) -> Option<StacksPublicKey> {
         let signed_hash = self.signature_hash().ok()?;
         let recovered_pk =

From 3ae5e37f0e4f5165975ed83d377c92832efb0def Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Tue, 14 Nov 2023 11:43:29 -0500
Subject: [PATCH 0043/1166] Change stacker_signature type to a SchnorrSignature

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stackslib/src/chainstate/burn/db/sortdb.rs    |  5 +++-
 stackslib/src/chainstate/nakamoto/mod.rs      | 25 +++++++++++--------
 .../src/chainstate/nakamoto/tests/mod.rs      |  8 +++---
 testnet/stacks-node/src/mockamoto.rs          |  6 ++---
 4 files changed, 25 insertions(+), 19 deletions(-)

diff --git a/stackslib/src/chainstate/burn/db/sortdb.rs b/stackslib/src/chainstate/burn/db/sortdb.rs
index 36cb2ebabb..85ce738748 100644
--- a/stackslib/src/chainstate/burn/db/sortdb.rs
+++ b/stackslib/src/chainstate/burn/db/sortdb.rs
@@ -26,6 +26,7 @@ use clarity::vm::ast::ASTRules;
 use clarity::vm::costs::ExecutionCost;
 use clarity::vm::representations::{ClarityName, ContractName};
 use clarity::vm::types::{PrincipalData, Value};
+use p256k1::point::Compressed;
 use rand;
 use rand::RngCore;
 use rusqlite::types::ToSql;
@@ -43,6 +44,8 @@ use stacks_common::util::hash::{hex_bytes, to_hex, Hash160, Sha512Trunc256Sum};
 use stacks_common::util::secp256k1::{MessageSignature, Secp256k1PublicKey};
 use stacks_common::util::vrf::*;
 use stacks_common::util::{get_epoch_time_secs, log};
+use wsts::common::Signature as WSTSSignature;
+use wsts::Point;
 
 use crate::burnchains::affirmation::{AffirmationMap, AffirmationMapEntry};
 use crate::burnchains::bitcoin::BitcoinNetworkType;
@@ -1925,7 +1928,7 @@ impl<'a> SortitionHandleConn<'a> {
     pub fn expects_stacker_signature(
         &self,
         consensus_hash: &ConsensusHash,
-        _stacker_signature: &MessageSignature,
+        _stacker_signature: &WSTSSignature,
     ) -> Result<bool, db_error> {
         let sn = SortitionDB::get_block_snapshot(self, &self.context.chain_tip)?
             .ok_or(db_error::NotFoundError)
diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index 6865820c61..64b15bd882 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -40,7 +40,7 @@ use stacks_common::types::{PrivateKey, StacksEpochId};
 use stacks_common::util::get_epoch_time_secs;
 use stacks_common::util::hash::{to_hex, Hash160, MerkleHashFunc, MerkleTree, Sha512Trunc256Sum};
 use stacks_common::util::retry::BoundReader;
-use stacks_common::util::secp256k1::MessageSignature;
+use stacks_common::util::secp256k1::{MessageSignature, SchnorrSignature};
 use stacks_common::util::vrf::{VRFProof, VRF};
 
 use super::burn::db::sortdb::{get_block_commit_by_txid, SortitionHandleConn, SortitionHandleTx};
@@ -254,9 +254,8 @@ pub struct NakamotoBlockHeader {
     pub state_index_root: TrieHash,
     /// Recoverable ECDSA signature from the tenure's miner.
     pub miner_signature: MessageSignature,
-    /// Recoverable ECDSA signature from the stacker set active during the tenure.
-    /// TODO: This is a placeholder
-    pub stacker_signature: MessageSignature,
+    /// Schnorr signature over the block header from the stacker set active during the tenure.
+    pub stacker_signature: SchnorrSignature,
 }
 
 #[derive(Debug, Clone, PartialEq)]
@@ -407,7 +406,7 @@ impl NakamotoBlockHeader {
             tx_merkle_root: Sha512Trunc256Sum([0u8; 32]),
             state_index_root: TrieHash([0u8; 32]),
             miner_signature: MessageSignature::empty(),
-            stacker_signature: MessageSignature::empty(),
+            stacker_signature: SchnorrSignature::default(),
         }
     }
 
@@ -422,7 +421,7 @@ impl NakamotoBlockHeader {
             tx_merkle_root: Sha512Trunc256Sum([0u8; 32]),
             state_index_root: TrieHash([0u8; 32]),
             miner_signature: MessageSignature::empty(),
-            stacker_signature: MessageSignature::empty(),
+            stacker_signature: SchnorrSignature::default(),
         }
     }
 
@@ -437,7 +436,7 @@ impl NakamotoBlockHeader {
             tx_merkle_root: Sha512Trunc256Sum([0u8; 32]),
             state_index_root: TrieHash([0u8; 32]),
             miner_signature: MessageSignature::empty(),
-            stacker_signature: MessageSignature::empty(),
+            stacker_signature: SchnorrSignature::default(),
         }
     }
 }
@@ -1360,10 +1359,14 @@ impl NakamotoChainState {
             return Ok(false);
         };
 
-        if !sortdb.expects_stacker_signature(
-            &block.header.consensus_hash,
-            &block.header.stacker_signature,
-        )? {
+        let schnorr_signature = block.header.stacker_signature.to_wsts_signature().ok_or({
+            let msg =
+                format!("Received block, signed by miner, but the block has no stacker signature");
+            warn!("{}", msg);
+            ChainstateError::InvalidStacksBlock(msg)
+        })?;
+
+        if !sortdb.expects_stacker_signature(&block.header.consensus_hash, &schnorr_signature)? {
             let msg = format!("Received block, but the stacker signature does not match the active stacking cycle");
             warn!("{}", msg);
             return Err(ChainstateError::InvalidStacksBlock(msg));
diff --git a/stackslib/src/chainstate/nakamoto/tests/mod.rs b/stackslib/src/chainstate/nakamoto/tests/mod.rs
index a7d299b9ca..c912c9b6b2 100644
--- a/stackslib/src/chainstate/nakamoto/tests/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/mod.rs
@@ -28,7 +28,7 @@ use stacks_common::types::chainstate::{
 };
 use stacks_common::types::{PrivateKey, StacksEpoch, StacksEpochId};
 use stacks_common::util::hash::{hex_bytes, Hash160, MerkleTree, Sha512Trunc256Sum};
-use stacks_common::util::secp256k1::{MessageSignature, Secp256k1PublicKey};
+use stacks_common::util::secp256k1::{MessageSignature, SchnorrSignature, Secp256k1PublicKey};
 use stacks_common::util::vrf::{VRFPrivateKey, VRFProof};
 use stdext::prelude::Integer;
 use stx_genesis::GenesisData;
@@ -100,7 +100,7 @@ fn codec_nakamoto_header() {
         tx_merkle_root: Sha512Trunc256Sum([0x06; 32]),
         state_index_root: TrieHash([0x07; 32]),
         miner_signature: MessageSignature::empty(),
-        stacker_signature: MessageSignature::empty(),
+        stacker_signature: SchnorrSignature::default(),
     };
 
     let bytes = vec![
@@ -146,7 +146,7 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
         tx_merkle_root: Sha512Trunc256Sum([0x06; 32]),
         state_index_root: TrieHash([0x07; 32]),
         miner_signature: MessageSignature::empty(),
-        stacker_signature: MessageSignature::empty(),
+        stacker_signature: SchnorrSignature::default(),
     };
 
     let tenure_change_payload = TransactionPayload::TenureChange(
@@ -500,7 +500,7 @@ pub fn test_load_store_update_nakamoto_blocks() {
         tx_merkle_root: nakamoto_tx_merkle_root,
         state_index_root: TrieHash([0x07; 32]),
         miner_signature: MessageSignature::empty(),
-        stacker_signature: MessageSignature::empty(),
+        stacker_signature: SchnorrSignature::default(),
     };
 
     let nakamoto_header_info = StacksHeaderInfo {
diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index 7168bd5630..608728603f 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -38,7 +38,7 @@ use stacks_common::types::chainstate::{
 };
 use stacks_common::types::{PrivateKey, StacksEpochId};
 use stacks_common::util::hash::{Hash160, MerkleTree, Sha512Trunc256Sum};
-use stacks_common::util::secp256k1::{MessageSignature, Secp256k1PublicKey};
+use stacks_common::util::secp256k1::{MessageSignature, SchnorrSignature, Secp256k1PublicKey};
 
 use crate::neon::Counters;
 use crate::neon_node::{
@@ -457,8 +457,8 @@ impl MockamotoNode {
                 burn_spent: 10,
                 tx_merkle_root: tx_merkle_tree.root(),
                 state_index_root,
-                stacker_signature: MessageSignature([0; 65]),
-                miner_signature: MessageSignature([0; 65]),
+                stacker_signature: SchnorrSignature::default(),
+                miner_signature: MessageSignature::empty(),
                 consensus_hash: sortition_tip.consensus_hash.clone(),
                 parent_block_id: StacksBlockId::new(&chain_tip_ch, &chain_tip_bh),
             },

From b8c0335517d2094d2645514921a943bff0de6542 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Tue, 14 Nov 2023 11:45:24 -0500
Subject: [PATCH 0044/1166] Update expects_stacker_signature to accept the
 block signature hash and verify it against the provided signature

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stackslib/src/chainstate/burn/db/sortdb.rs | 18 ++++++++++++++----
 stackslib/src/chainstate/nakamoto/mod.rs   |  6 +++++-
 2 files changed, 19 insertions(+), 5 deletions(-)

diff --git a/stackslib/src/chainstate/burn/db/sortdb.rs b/stackslib/src/chainstate/burn/db/sortdb.rs
index 85ce738748..0c7c22b6ca 100644
--- a/stackslib/src/chainstate/burn/db/sortdb.rs
+++ b/stackslib/src/chainstate/burn/db/sortdb.rs
@@ -1928,7 +1928,8 @@ impl<'a> SortitionHandleConn<'a> {
     pub fn expects_stacker_signature(
         &self,
         consensus_hash: &ConsensusHash,
-        _stacker_signature: &WSTSSignature,
+        stacker_signature: &WSTSSignature,
+        message: &[u8],
     ) -> Result<bool, db_error> {
         let sn = SortitionDB::get_block_snapshot(self, &self.context.chain_tip)?
             .ok_or(db_error::NotFoundError)
@@ -1983,12 +1984,21 @@ impl<'a> SortitionHandleConn<'a> {
         else {
             return Ok(false);
         };
-        let Some(_sortition_id) = self.get_sortition_id_for_bhh(&bhh)? else {
+        let Some(sortition_id) = self.get_sortition_id_for_bhh(&bhh)? else {
             return Ok(false);
         };
+        let Some(aggregate_public_key) = self.get_aggregate_public_key(&sortition_id)? else {
+            return Ok(false);
+        };
+        Ok(stacker_signature.verify(&aggregate_public_key, message))
+    }
 
-        // TODO: query set of stacker signers in order to get the aggregate public key
-        Ok(true)
+    /// Retrieve the aggregate public key from the sortition DB
+    pub fn get_aggregate_public_key(
+        &self,
+        _sortition_id: &SortitionId,
+    ) -> Result<Option<Point>, db_error> {
+        todo!("Retrieve the aggregate public key from the sortition DB")
     }
 
     pub fn get_reward_set_size_at(&self, sortition_id: &SortitionId) -> Result<u16, db_error> {
diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index 64b15bd882..36bd76348f 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -1366,7 +1366,11 @@ impl NakamotoChainState {
             ChainstateError::InvalidStacksBlock(msg)
         })?;
 
-        if !sortdb.expects_stacker_signature(&block.header.consensus_hash, &schnorr_signature)? {
+        if !sortdb.expects_stacker_signature(
+            &block.header.consensus_hash,
+            &schnorr_signature,
+            &block.header.stacker_signature_hash()?.0,
+        )? {
             let msg = format!("Received block, but the stacker signature does not match the active stacking cycle");
             warn!("{}", msg);
             return Err(ChainstateError::InvalidStacksBlock(msg));

From 5ffb234aeee875cbe94517fa9d3d804f0dbf3529 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Tue, 14 Nov 2023 11:46:08 -0500
Subject: [PATCH 0045/1166] Add get_aggregate_public_key_pox_4 function
 implementaton

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stackslib/src/chainstate/stacks/boot/mod.rs | 33 +++++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 40c8bea389..afda95321c 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -39,6 +39,7 @@ use stacks_common::codec::StacksMessageCodec;
 use stacks_common::types;
 use stacks_common::types::chainstate::{BlockHeaderHash, StacksAddress, StacksBlockId};
 use stacks_common::util::hash::{to_hex, Hash160};
+use wsts::{Point, Scalar};
 
 use crate::burnchains::bitcoin::address::BitcoinAddress;
 use crate::burnchains::{Address, Burnchain, PoxConstants};
@@ -1125,6 +1126,38 @@ impl StacksChainState {
             x => x,
         }
     }
+
+    /// Get the aggregate public key for a given reward cycle from pox 4
+    pub fn get_aggregate_public_key_pox_4(
+        &mut self,
+        sortdb: &SortitionDB,
+        block_id: &StacksBlockId,
+        reward_cycle: u64,
+    ) -> Result<Option<Point>, Error> {
+        if !self.is_pox_active(sortdb, block_id, reward_cycle as u128, POX_4_NAME)? {
+            debug!(
+                "PoX was voted disabled in block {} (reward cycle {})",
+                block_id, reward_cycle
+            );
+            return Ok(None);
+        }
+
+        let aggregate_public_key = self
+            .eval_boot_code_read_only(
+                sortdb,
+                block_id,
+                POX_4_NAME,
+                &format!("(get-aggregate-pubilc-key u{})", reward_cycle),
+            )?
+            .expect_optional()
+            .map(|value| {
+                let mut bytes = [0_u8; 32];
+                let data = value.expect_buff(bytes.len());
+                bytes.copy_from_slice(&data);
+                Point::from(Scalar::from(bytes))
+            });
+        Ok(aggregate_public_key)
+    }
 }
 
 #[cfg(test)]

From 127d4a9ab4151646b2f3644bdc5d0ae327233680 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Tue, 14 Nov 2023 11:46:25 -0500
Subject: [PATCH 0046/1166] Retrieve aggregate public key in
 get_reward_set_nakamoto

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stackslib/src/chainstate/nakamoto/coordinator/mod.rs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
index 7cbdea2ad4..7d69e3bea5 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
@@ -69,6 +69,12 @@ impl OnChainRewardSetProvider {
         let registered_addrs =
             chainstate.get_reward_addresses_in_cycle(burnchain, sortdb, cycle, block_id)?;
 
+        let reward_cycle = burnchain
+            .block_height_to_reward_cycle(current_burn_height)
+            .ok_or(crate::chainstate::stacks::Error::PoxNoRewardCycle)?;
+
+        let _aggregate_public_key =
+            chainstate.get_aggregate_public_key_pox_4(sortdb, block_id, reward_cycle)?;
         let liquid_ustx = chainstate.get_liquid_ustx(block_id);
 
         let (threshold, participation) = StacksChainState::get_reward_threshold_and_participation(

From dc811de9fdb06507d25c8d33b87bbb5b0e35578f Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Tue, 14 Nov 2023 11:46:36 -0500
Subject: [PATCH 0047/1166] Add aggregate public key to reward set struct

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stackslib/src/chainstate/coordinator/mod.rs          | 1 +
 stackslib/src/chainstate/coordinator/tests.rs        | 1 +
 stackslib/src/chainstate/nakamoto/coordinator/mod.rs | 3 ++-
 stackslib/src/chainstate/stacks/boot/mod.rs          | 7 ++++++-
 4 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/stackslib/src/chainstate/coordinator/mod.rs b/stackslib/src/chainstate/coordinator/mod.rs
index 05fc9a0fe5..7c5d61838b 100644
--- a/stackslib/src/chainstate/coordinator/mod.rs
+++ b/stackslib/src/chainstate/coordinator/mod.rs
@@ -405,6 +405,7 @@ impl OnChainRewardSetProvider {
             threshold,
             registered_addrs,
             cur_epoch.epoch_id,
+            None,
         ))
     }
 }
diff --git a/stackslib/src/chainstate/coordinator/tests.rs b/stackslib/src/chainstate/coordinator/tests.rs
index 7e94c4bbc3..4d919f3994 100644
--- a/stackslib/src/chainstate/coordinator/tests.rs
+++ b/stackslib/src/chainstate/coordinator/tests.rs
@@ -495,6 +495,7 @@ impl RewardSetProvider for StubbedRewardSetProvider {
             start_cycle_state: PoxStartCycleInfo {
                 missed_reward_slots: vec![],
             },
+            aggregate_public_key: None,
         })
     }
 }
diff --git a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
index 7d69e3bea5..0273129236 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
@@ -73,7 +73,7 @@ impl OnChainRewardSetProvider {
             .block_height_to_reward_cycle(current_burn_height)
             .ok_or(crate::chainstate::stacks::Error::PoxNoRewardCycle)?;
 
-        let _aggregate_public_key =
+        let aggregate_public_key =
             chainstate.get_aggregate_public_key_pox_4(sortdb, block_id, reward_cycle)?;
         let liquid_ustx = chainstate.get_liquid_ustx(block_id);
 
@@ -106,6 +106,7 @@ impl OnChainRewardSetProvider {
             threshold,
             registered_addrs,
             cur_epoch.epoch_id,
+            aggregate_public_key,
         ))
     }
 }
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index afda95321c..1e2bba7f7e 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -162,6 +162,8 @@ pub struct PoxStartCycleInfo {
 pub struct RewardSet {
     pub rewarded_addresses: Vec<PoxAddress>,
     pub start_cycle_state: PoxStartCycleInfo,
+    /// The aggregate public key for the reward set.  This is only present in pox-4 cycles.
+    pub aggregate_public_key: Option<Point>,
 }
 
 const POX_CYCLE_START_HANDLED_VALUE: &'static str = "1";
@@ -188,6 +190,7 @@ impl RewardSet {
             start_cycle_state: PoxStartCycleInfo {
                 missed_reward_slots: vec![],
             },
+            aggregate_public_key: None,
         }
     }
 }
@@ -576,6 +579,7 @@ impl StacksChainState {
         threshold: u128,
         mut addresses: Vec<RawRewardSetEntry>,
         epoch_id: StacksEpochId,
+        aggregate_public_key: Option<Point>,
     ) -> RewardSet {
         let mut reward_set = vec![];
         let mut missed_slots = vec![];
@@ -665,6 +669,7 @@ impl StacksChainState {
             start_cycle_state: PoxStartCycleInfo {
                 missed_reward_slots: missed_slots,
             },
+            aggregate_public_key,
         }
     }
 
@@ -1242,7 +1247,7 @@ pub mod test {
             },
         ];
         assert_eq!(
-            StacksChainState::make_reward_set(threshold, addresses, StacksEpochId::Epoch2_05)
+            StacksChainState::make_reward_set(threshold, addresses, StacksEpochId::Epoch2_05, None)
                 .rewarded_addresses
                 .len(),
             3

From 3c93abda1eaa32aac4bac63da0e90720ed8bbbfd Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Tue, 14 Nov 2023 11:46:51 -0500
Subject: [PATCH 0048/1166] Get the aggregate public key from the sortition db
 preprocessed reward sets

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stackslib/src/chainstate/burn/db/sortdb.rs | 18 +++++++++++++-----
 1 file changed, 13 insertions(+), 5 deletions(-)

diff --git a/stackslib/src/chainstate/burn/db/sortdb.rs b/stackslib/src/chainstate/burn/db/sortdb.rs
index 0c7c22b6ca..0bc5588a70 100644
--- a/stackslib/src/chainstate/burn/db/sortdb.rs
+++ b/stackslib/src/chainstate/burn/db/sortdb.rs
@@ -1987,18 +1987,26 @@ impl<'a> SortitionHandleConn<'a> {
         let Some(sortition_id) = self.get_sortition_id_for_bhh(&bhh)? else {
             return Ok(false);
         };
-        let Some(aggregate_public_key) = self.get_aggregate_public_key(&sortition_id)? else {
+        let Some(aggregate_public_key) = self.get_reward_set_aggregate_public_key(&sortition_id)?
+        else {
             return Ok(false);
         };
         Ok(stacker_signature.verify(&aggregate_public_key, message))
     }
 
-    /// Retrieve the aggregate public key from the sortition DB
-    pub fn get_aggregate_public_key(
+    /// Get the aggregate public key for the current reward set
+    pub fn get_reward_set_aggregate_public_key(
         &self,
-        _sortition_id: &SortitionId,
+        sortition_id: &SortitionId,
     ) -> Result<Option<Point>, db_error> {
-        todo!("Retrieve the aggregate public key from the sortition DB")
+        if let Some(reward_info) = SortitionDB::get_preprocessed_reward_set(self, sortition_id)? {
+            if let PoxAnchorBlockStatus::SelectedAndKnown(_, _, reward_set) =
+                reward_info.anchor_status
+            {
+                return Ok(reward_set.aggregate_public_key);
+            }
+        }
+        Ok(None)
     }
 
     pub fn get_reward_set_size_at(&self, sortition_id: &SortitionId) -> Result<u16, db_error> {

From f30a39bc5d9f1fa52eb25deb2165d6760d71bfa3 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Tue, 14 Nov 2023 11:47:07 -0500
Subject: [PATCH 0049/1166] Add get-aggregate-public-key to pox-4.clar and fix
 typo in contract call

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stackslib/src/chainstate/stacks/boot/mod.rs     |  2 +-
 stackslib/src/chainstate/stacks/boot/pox-4.clar | 13 +++++++++++++
 2 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 1e2bba7f7e..f28bd0695a 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -1152,7 +1152,7 @@ impl StacksChainState {
                 sortdb,
                 block_id,
                 POX_4_NAME,
-                &format!("(get-aggregate-pubilc-key u{})", reward_cycle),
+                &format!("(get-aggregate-public-key u{})", reward_cycle),
             )?
             .expect_optional()
             .map(|value| {
diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index 1f9ad6dad7..beb0da9cc1 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -202,6 +202,13 @@
     { amount: uint }
 )
 
+;; The stackers' aggregate public key
+;;   for the given reward cycle
+(define-map aggregate-public-keys
+    { reward-cycle: uint }
+    { aggregate-public-key: (buff 33) }
+)
+
 ;; Getter for stacking-rejectors
 (define-read-only (get-pox-rejection (stacker principal) (reward-cycle uint))
     (map-get? stacking-rejectors { stacker: stacker, reward-cycle: reward-cycle }))
@@ -1318,3 +1325,9 @@
         u0
     )
 )
+
+;; What is the given reward cycle's stackers' aggregate public key?
+;; *New in Stacks 3.0*
+(define-read-only (get-aggregate-public-key (reward-cycle uint))
+    (map-get? aggregate-public-keys { reward-cycle: reward-cycle })
+)
\ No newline at end of file

From 402826c115426c0dc5245ce4bdf548ef3421ccd9 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Tue, 14 Nov 2023 11:51:39 -0500
Subject: [PATCH 0050/1166] Replace stacker_signature with signer_signature

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stackslib/src/chainstate/burn/db/sortdb.rs    | 10 +++---
 stackslib/src/chainstate/nakamoto/mod.rs      | 34 +++++++++----------
 .../src/chainstate/nakamoto/tests/mod.rs      |  6 ++--
 testnet/stacks-node/src/mockamoto.rs          |  2 +-
 4 files changed, 26 insertions(+), 26 deletions(-)

diff --git a/stackslib/src/chainstate/burn/db/sortdb.rs b/stackslib/src/chainstate/burn/db/sortdb.rs
index 0bc5588a70..7d892d97a0 100644
--- a/stackslib/src/chainstate/burn/db/sortdb.rs
+++ b/stackslib/src/chainstate/burn/db/sortdb.rs
@@ -1917,18 +1917,18 @@ impl<'a> SortitionHandleConn<'a> {
     }
 
     /// Does the sortition db expect to receive blocks
-    /// signed by this stacker set?
+    /// signed by this signer set?
     ///
     /// This only works if `consensus_hash` is within one reward cycle (2100 blocks) of the
     /// sortition pointed to by this handle's sortiton tip.  If it isn't, then this
     /// method returns Ok(false).  This is to prevent a DDoS vector whereby compromised stale
-    /// Stacker keys can be used to blast out lots of Nakamoto blocks that will be accepted
+    /// Signer keys can be used to blast out lots of Nakamoto blocks that will be accepted
     /// but never processed.  So, `consensus_hash` can be in the same reward cycle as
     /// `self.context.chain_tip`, or the previous, but no earlier.
-    pub fn expects_stacker_signature(
+    pub fn expects_signer_signature(
         &self,
         consensus_hash: &ConsensusHash,
-        stacker_signature: &WSTSSignature,
+        signer_signature: &WSTSSignature,
         message: &[u8],
     ) -> Result<bool, db_error> {
         let sn = SortitionDB::get_block_snapshot(self, &self.context.chain_tip)?
@@ -1991,7 +1991,7 @@ impl<'a> SortitionHandleConn<'a> {
         else {
             return Ok(false);
         };
-        Ok(stacker_signature.verify(&aggregate_public_key, message))
+        Ok(signer_signature.verify(&aggregate_public_key, message))
     }
 
     /// Get the aggregate public key for the current reward set
diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index 36bd76348f..0aa0b099ff 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -170,8 +170,8 @@ lazy_static! {
                      state_index_root TEXT NOT NULL,
                      -- miner's signature over the block
                      miner_signature TEXT NOT NULL,
-                     -- stackers' signature over the block
-                     stacker_signature TEXT NOT NULL,
+                     -- signers' signature over the block
+                     signer_signature TEXT NOT NULL,
           -- The following fields are not part of either the StacksHeaderInfo struct
           --   or its contained NakamotoBlockHeader struct, but are used for querying
                      -- what kind of header this is (nakamoto or stacks 2.x)
@@ -254,8 +254,8 @@ pub struct NakamotoBlockHeader {
     pub state_index_root: TrieHash,
     /// Recoverable ECDSA signature from the tenure's miner.
     pub miner_signature: MessageSignature,
-    /// Schnorr signature over the block header from the stacker set active during the tenure.
-    pub stacker_signature: SchnorrSignature,
+    /// Schnorr signature over the block header from the signer set active during the tenure.
+    pub signer_signature: SchnorrSignature,
 }
 
 #[derive(Debug, Clone, PartialEq)]
@@ -279,7 +279,7 @@ impl FromRow<NakamotoBlockHeader> for NakamotoBlockHeader {
         let parent_block_id = row.get("parent_block_id")?;
         let tx_merkle_root = row.get("tx_merkle_root")?;
         let state_index_root = row.get("state_index_root")?;
-        let stacker_signature = row.get("stacker_signature")?;
+        let signer_signature = row.get("signer_signature")?;
         let miner_signature = row.get("miner_signature")?;
 
         Ok(NakamotoBlockHeader {
@@ -290,7 +290,7 @@ impl FromRow<NakamotoBlockHeader> for NakamotoBlockHeader {
             parent_block_id,
             tx_merkle_root,
             state_index_root,
-            stacker_signature,
+            signer_signature,
             miner_signature,
         })
     }
@@ -306,7 +306,7 @@ impl StacksMessageCodec for NakamotoBlockHeader {
         write_next(fd, &self.tx_merkle_root)?;
         write_next(fd, &self.state_index_root)?;
         write_next(fd, &self.miner_signature)?;
-        write_next(fd, &self.stacker_signature)?;
+        write_next(fd, &self.signer_signature)?;
 
         Ok(())
     }
@@ -321,7 +321,7 @@ impl StacksMessageCodec for NakamotoBlockHeader {
             tx_merkle_root: read_next(fd)?,
             state_index_root: read_next(fd)?,
             miner_signature: read_next(fd)?,
-            stacker_signature: read_next(fd)?,
+            signer_signature: read_next(fd)?,
         })
     }
 }
@@ -344,7 +344,7 @@ impl NakamotoBlockHeader {
 
     /// Calculate the message digest for stackers to sign.
     /// This includes all fields _except_ the stacker signature.
-    pub fn stacker_signature_hash(&self) -> Result<Sha512Trunc256Sum, CodecError> {
+    pub fn signer_signature_hash(&self) -> Result<Sha512Trunc256Sum, CodecError> {
         let mut hasher = Sha512_256::new();
         let fd = &mut hasher;
         write_next(fd, &self.version)?;
@@ -406,7 +406,7 @@ impl NakamotoBlockHeader {
             tx_merkle_root: Sha512Trunc256Sum([0u8; 32]),
             state_index_root: TrieHash([0u8; 32]),
             miner_signature: MessageSignature::empty(),
-            stacker_signature: SchnorrSignature::default(),
+            signer_signature: SchnorrSignature::default(),
         }
     }
 
@@ -421,7 +421,7 @@ impl NakamotoBlockHeader {
             tx_merkle_root: Sha512Trunc256Sum([0u8; 32]),
             state_index_root: TrieHash([0u8; 32]),
             miner_signature: MessageSignature::empty(),
-            stacker_signature: SchnorrSignature::default(),
+            signer_signature: SchnorrSignature::default(),
         }
     }
 
@@ -436,7 +436,7 @@ impl NakamotoBlockHeader {
             tx_merkle_root: Sha512Trunc256Sum([0u8; 32]),
             state_index_root: TrieHash([0u8; 32]),
             miner_signature: MessageSignature::empty(),
-            stacker_signature: SchnorrSignature::default(),
+            signer_signature: SchnorrSignature::default(),
         }
     }
 }
@@ -1359,17 +1359,17 @@ impl NakamotoChainState {
             return Ok(false);
         };
 
-        let schnorr_signature = block.header.stacker_signature.to_wsts_signature().ok_or({
+        let schnorr_signature = block.header.signer_signature.to_wsts_signature().ok_or({
             let msg =
                 format!("Received block, signed by miner, but the block has no stacker signature");
             warn!("{}", msg);
             ChainstateError::InvalidStacksBlock(msg)
         })?;
 
-        if !sortdb.expects_stacker_signature(
+        if !sortdb.expects_signer_signature(
             &block.header.consensus_hash,
             &schnorr_signature,
-            &block.header.stacker_signature_hash()?.0,
+            &block.header.signer_signature_hash()?.0,
         )? {
             let msg = format!("Received block, but the stacker signature does not match the active stacking cycle");
             warn!("{}", msg);
@@ -1846,7 +1846,7 @@ impl NakamotoChainState {
             &u64_to_sql(header.chain_length)?,
             &u64_to_sql(header.burn_spent)?,
             &header.miner_signature,
-            &header.stacker_signature,
+            &header.signer_signature,
             &header.tx_merkle_root,
             &header.state_index_root,
             &block_hash,
@@ -1868,7 +1868,7 @@ impl NakamotoChainState {
 
                      header_type,
                      version, chain_length, burn_spent,
-                     miner_signature, stacker_signature, tx_merkle_root, state_index_root,
+                     miner_signature, signer_signature, tx_merkle_root, state_index_root,
 
                      block_hash,
                      index_block_hash,
diff --git a/stackslib/src/chainstate/nakamoto/tests/mod.rs b/stackslib/src/chainstate/nakamoto/tests/mod.rs
index c912c9b6b2..65fbcae74d 100644
--- a/stackslib/src/chainstate/nakamoto/tests/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/mod.rs
@@ -100,7 +100,7 @@ fn codec_nakamoto_header() {
         tx_merkle_root: Sha512Trunc256Sum([0x06; 32]),
         state_index_root: TrieHash([0x07; 32]),
         miner_signature: MessageSignature::empty(),
-        stacker_signature: SchnorrSignature::default(),
+        signer_signature: SchnorrSignature::default(),
     };
 
     let bytes = vec![
@@ -146,7 +146,7 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
         tx_merkle_root: Sha512Trunc256Sum([0x06; 32]),
         state_index_root: TrieHash([0x07; 32]),
         miner_signature: MessageSignature::empty(),
-        stacker_signature: SchnorrSignature::default(),
+        signer_signature: SchnorrSignature::default(),
     };
 
     let tenure_change_payload = TransactionPayload::TenureChange(
@@ -500,7 +500,7 @@ pub fn test_load_store_update_nakamoto_blocks() {
         tx_merkle_root: nakamoto_tx_merkle_root,
         state_index_root: TrieHash([0x07; 32]),
         miner_signature: MessageSignature::empty(),
-        stacker_signature: SchnorrSignature::default(),
+        signer_signature: SchnorrSignature::default(),
     };
 
     let nakamoto_header_info = StacksHeaderInfo {
diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index 608728603f..d66941125f 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -457,7 +457,7 @@ impl MockamotoNode {
                 burn_spent: 10,
                 tx_merkle_root: tx_merkle_tree.root(),
                 state_index_root,
-                stacker_signature: SchnorrSignature::default(),
+                signer_signature: SchnorrSignature::default(),
                 miner_signature: MessageSignature::empty(),
                 consensus_hash: sortition_tip.consensus_hash.clone(),
                 parent_block_id: StacksBlockId::new(&chain_tip_ch, &chain_tip_bh),

From 505e4b8d4f8a6ecb7f1b084a964a95a90c621aec Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Tue, 14 Nov 2023 12:44:11 -0500
Subject: [PATCH 0051/1166] CRC: make sure to reattempt getting the reward
 cycle info if no DKG set

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stackslib/src/chainstate/nakamoto/coordinator/mod.rs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
index 0273129236..f6102c31ad 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
@@ -284,7 +284,11 @@ pub fn get_nakamoto_reward_cycle_info<U: RewardSetProvider>(
 
         let reward_set =
             provider.get_reward_set(burn_height, chain_state, burnchain, sort_db, &block_id)?;
-
+        // if the aggregate_public_key is not set, signers may not be done the DKG round/DKG vote
+        // The caller should try again when more blocks have arrived
+        if reward_set.aggregate_public_key.is_none() {
+            return Ok(None);
+        }
         debug!(
             "Stacks anchor block (ch {}) {} cycle {} is processed",
             &anchor_block_header.consensus_hash, &block_id, reward_cycle

From 379cf1d5318fe4a442f994a2c4e8249b1404b20a Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Mon, 20 Nov 2023 09:05:36 -0500
Subject: [PATCH 0052/1166] Search for the first sortition of the prepare phase
 of the parent reward cycle to determine the aggregate public key

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stackslib/src/chainstate/burn/db/sortdb.rs | 105 ++++++++++++++++++---
 1 file changed, 93 insertions(+), 12 deletions(-)

diff --git a/stackslib/src/chainstate/burn/db/sortdb.rs b/stackslib/src/chainstate/burn/db/sortdb.rs
index 7d892d97a0..a614adeec3 100644
--- a/stackslib/src/chainstate/burn/db/sortdb.rs
+++ b/stackslib/src/chainstate/burn/db/sortdb.rs
@@ -83,11 +83,11 @@ use crate::core::{
     FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH, STACKS_EPOCH_MAX,
 };
 use crate::net::neighbors::MAX_NEIGHBOR_BLOCK_DELAY;
-use crate::net::{Error as NetError, Error};
+use crate::net::Error as NetError;
 use crate::util_lib::db::{
-    db_mkdirs, opt_u64_to_sql, query_count, query_row, query_row_columns, query_row_panic,
-    query_rows, sql_pragma, tx_begin_immediate, tx_busy_handler, u64_to_sql, DBConn, DBTx,
-    Error as db_error, FromColumn, FromRow, IndexDBConn, IndexDBTx,
+    db_mkdirs, get_ancestor_block_hash, opt_u64_to_sql, query_count, query_row, query_row_columns,
+    query_row_panic, query_rows, sql_pragma, tx_begin_immediate, tx_busy_handler, u64_to_sql,
+    DBConn, DBTx, Error as db_error, FromColumn, FromRow, IndexDBConn, IndexDBTx,
 };
 
 const BLOCK_HEIGHT_MAX: u64 = ((1 as u64) << 63) - 1;
@@ -1980,21 +1980,102 @@ impl<'a> SortitionHandleConn<'a> {
         }
 
         // is this consensus hash in this fork?
-        let Some(bhh) = SortitionDB::get_burnchain_header_hash_by_consensus(self, consensus_hash)?
+        let Some(_bhh) = SortitionDB::get_burnchain_header_hash_by_consensus(self, consensus_hash)?
         else {
             return Ok(false);
         };
-        let Some(sortition_id) = self.get_sortition_id_for_bhh(&bhh)? else {
-            return Ok(false);
-        };
-        let Some(aggregate_public_key) = self.get_reward_set_aggregate_public_key(&sortition_id)?
-        else {
+
+        // Get the current reward cycle
+        let reward_cycle = if let Some(reward_cycle) = self
+            .context
+            .pox_constants
+            .block_height_to_reward_cycle(self.context.first_block_height, sn.block_height)
+        {
+            reward_cycle
+        } else {
+            // can't do anything
+            warn!("Failed to determine reward cycle of block with consensus hash";
+                  "consensus_hash" => %consensus_hash,
+                  "block_height" => ch_sn.block_height
+            );
             return Ok(false);
         };
-        Ok(signer_signature.verify(&aggregate_public_key, message))
+        Ok(self
+            .get_reward_cycle_aggregate_public_key(reward_cycle)?
+            .map(|key| signer_signature.verify(&key, message))
+            .unwrap_or(false))
+    }
+
+    /// Get the aggregate public key for the given reward cycle.
+    pub fn get_reward_cycle_aggregate_public_key(
+        &self,
+        reward_cycle: u64,
+    ) -> Result<Option<Point>, db_error> {
+        // Retrieve the the first sortition in the current reward cycle
+        let reward_cycle_block_height = self
+            .context
+            .pox_constants
+            .reward_cycle_to_block_height(self.context.first_block_height, reward_cycle);
+        let reward_cycle_start_sortition_id = self
+            .get_ancestor_block_hash(reward_cycle_block_height, &self.context.chain_tip)?
+            .ok_or_else(|| {
+                warn!(
+                    "reward start height {} does not have a sorition from {}",
+                    reward_cycle_block_height, &self.context.chain_tip
+                );
+                db_error::NotFoundError
+            })?;
+        let reward_cycle_start_snapshot =
+            SortitionDB::get_block_snapshot(self, &reward_cycle_start_sortition_id)?
+                .ok_or(db_error::NotFoundError)
+                .map_err(|e| {
+                    warn!(
+                        "No block snapshot for reward cycle starting sortition id: {:?}",
+                        &reward_cycle_start_sortition_id
+                    );
+                    e
+                })?;
+        // Search for the FIRST sortition in the prepare phase of the PARENT reward cycle
+        let mut prepare_phase_sn = SortitionDB::get_block_snapshot(
+            self,
+            &reward_cycle_start_snapshot.parent_sortition_id,
+        )?
+        .ok_or(db_error::NotFoundError)
+        .map_err(|e| {
+            warn!(
+                "No block snapshot for prepare phase cycle end sortition id: {:?}",
+                &reward_cycle_start_snapshot.parent_sortition_id
+            );
+            e
+        })?;
+        let mut height = prepare_phase_sn.block_height;
+        let mut first_sortition_id = None;
+        while height > 0
+            && self
+                .context
+                .pox_constants
+                .is_in_prepare_phase(self.context.first_block_height, height)
+        {
+            first_sortition_id = Some(prepare_phase_sn.sortition_id.clone());
+            height = prepare_phase_sn.block_height.saturating_sub(1);
+            prepare_phase_sn =
+                SortitionDB::get_block_snapshot(self, &prepare_phase_sn.parent_sortition_id)?
+                    .ok_or(db_error::NotFoundError)
+                    .map_err(|e| {
+                        warn!(
+                            "No sortition for reward cycle starting sortition id: {:?}",
+                            &reward_cycle_start_sortition_id
+                        );
+                        e
+                    })?;
+        }
+        if let Some(first_sortition_id) = first_sortition_id {
+            return self.get_reward_set_aggregate_public_key(&first_sortition_id);
+        }
+        Ok(None)
     }
 
-    /// Get the aggregate public key for the current reward set
+    /// Get the aggregate public key for reward set of the given sortition id.
     pub fn get_reward_set_aggregate_public_key(
         &self,
         sortition_id: &SortitionId,

From 8ff7222756ad9fa8271beafce4c7fc2a05695240 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Mon, 20 Nov 2023 09:07:07 -0500
Subject: [PATCH 0053/1166] Pox-4 activates with old block formats so update
 aggregate key even in pre nakamoto blocks

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stackslib/src/chainstate/coordinator/mod.rs | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/stackslib/src/chainstate/coordinator/mod.rs b/stackslib/src/chainstate/coordinator/mod.rs
index 7c5d61838b..eb34968aa6 100644
--- a/stackslib/src/chainstate/coordinator/mod.rs
+++ b/stackslib/src/chainstate/coordinator/mod.rs
@@ -400,12 +400,17 @@ impl OnChainRewardSetProvider {
                   "liquid_ustx" => liquid_ustx,
                   "registered_addrs" => registered_addrs.len());
         }
+        let reward_cycle = burnchain
+            .block_height_to_reward_cycle(current_burn_height)
+            .ok_or(crate::chainstate::stacks::Error::PoxNoRewardCycle)?;
 
+        let aggregate_public_key =
+            chainstate.get_aggregate_public_key_pox_4(sortdb, block_id, reward_cycle)?;
         Ok(StacksChainState::make_reward_set(
             threshold,
             registered_addrs,
             cur_epoch.epoch_id,
-            None,
+            aggregate_public_key,
         ))
     }
 }

From f06ce03202b28838d4bf3b74c30b4eda7fe92e87 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Mon, 20 Nov 2023 09:08:36 -0500
Subject: [PATCH 0054/1166] Add set-aggregate-public-key and fix point
 deserialization from pox-4

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stackslib/src/chainstate/stacks/boot/mod.rs   | 28 ++++++++++++++++---
 .../src/chainstate/stacks/boot/pox-4.clar     | 16 +++++++----
 2 files changed, 35 insertions(+), 9 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index f28bd0695a..0dec459614 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -34,6 +34,7 @@ use clarity::vm::types::{
 };
 use clarity::vm::{ClarityVersion, Environment, SymbolicExpression};
 use lazy_static::lazy_static;
+use p256k1::point::Compressed;
 use stacks_common::address::AddressHashMode;
 use stacks_common::codec::StacksMessageCodec;
 use stacks_common::types;
@@ -1156,10 +1157,11 @@ impl StacksChainState {
             )?
             .expect_optional()
             .map(|value| {
-                let mut bytes = [0_u8; 32];
-                let data = value.expect_buff(bytes.len());
-                bytes.copy_from_slice(&data);
-                Point::from(Scalar::from(bytes))
+                // A point should have 33 bytes exactly.
+                let data = value.expect_buff(33);
+                let msg = "Pox-4 get-aggregate-public-key returned a corrupted value.";
+                let compressed_data = Compressed::try_from(data.as_slice()).expect(msg);
+                Point::try_from(&compressed_data).expect(msg)
             });
         Ok(aggregate_public_key)
     }
@@ -1713,6 +1715,24 @@ pub mod test {
         make_tx(key, nonce, 0, payload)
     }
 
+    pub fn make_pox_4_aggregate_key(
+        key: &StacksPrivateKey,
+        nonce: u64,
+        reward_cycle: u64,
+        aggregate_public_key: &Point,
+    ) -> StacksTransaction {
+        let aggregate_public_key = Value::buff_from(aggregate_public_key.compress().data.to_vec())
+            .expect("Failed to serialize aggregate public key");
+        let payload = TransactionPayload::new_contract_call(
+            boot_code_test_addr(),
+            POX_4_NAME,
+            "set-aggregate-public-key",
+            vec![Value::UInt(reward_cycle as u128), aggregate_public_key],
+        )
+        .unwrap();
+        make_tx(key, nonce, 0, payload)
+    }
+
     pub fn make_pox_2_increase(
         key: &StacksPrivateKey,
         nonce: u64,
diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index beb0da9cc1..2e6f7933e9 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -204,10 +204,7 @@
 
 ;; The stackers' aggregate public key
 ;;   for the given reward cycle
-(define-map aggregate-public-keys
-    { reward-cycle: uint }
-    { aggregate-public-key: (buff 33) }
-)
+(define-map aggregate-public-keys uint (buff 33))
 
 ;; Getter for stacking-rejectors
 (define-read-only (get-pox-rejection (stacker principal) (reward-cycle uint))
@@ -1329,5 +1326,14 @@
 ;; What is the given reward cycle's stackers' aggregate public key?
 ;; *New in Stacks 3.0*
 (define-read-only (get-aggregate-public-key (reward-cycle uint))
-    (map-get? aggregate-public-keys { reward-cycle: reward-cycle })
+    (map-get? aggregate-public-keys reward-cycle)
+)
+
+;; Set the aggregate public key to the provided value
+;; TODO: REMOVE THIS
+;; *New in Stacks 3.0*
+(define-public (set-aggregate-public-key (reward-cycle uint) (aggregate-public-key (buff 33)))
+    (begin
+        (ok (map-set aggregate-public-keys reward-cycle aggregate-public-key))
+    )
 )
\ No newline at end of file

From 521d20fb35a205474960c066f1fa99dccb68bd6c Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Mon, 20 Nov 2023 09:10:03 -0500
Subject: [PATCH 0055/1166] Boot nakamoto by simulating signer DKG rounds to
 set dkg in contract

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 Cargo.lock                                    | 58 ++----------
 stacks-common/Cargo.toml                      |  3 +-
 stacks-common/src/util/secp256k1.rs           |  7 +-
 stackslib/Cargo.toml                          |  1 +
 stackslib/src/chainstate/burn/db/sortdb.rs    |  3 +-
 .../chainstate/nakamoto/coordinator/tests.rs  | 46 +++++-----
 stackslib/src/chainstate/nakamoto/mod.rs      | 17 ++--
 .../src/chainstate/nakamoto/tests/node.rs     | 88 +++++++++++++++++++
 stackslib/src/chainstate/stacks/boot/mod.rs   |  4 +-
 stackslib/src/net/mod.rs                      |  7 +-
 testnet/stacks-node/Cargo.toml                |  2 +
 11 files changed, 148 insertions(+), 88 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 0800b52481..8ac1f554b1 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2351,29 +2351,6 @@ version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39"
 
-[[package]]
-name = "p256k1"
-version = "5.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22e81c2cb5a1936d3f26278f9d698932239d03ddf0d5818392d91cd5f98ffc79"
-dependencies = [
- "bindgen",
- "bitvec",
- "bs58 0.4.0",
- "cc",
- "hex",
- "itertools",
- "num-traits",
- "primitive-types",
- "proc-macro2",
- "quote",
- "rand_core 0.6.4",
- "rustfmt-wrapper",
- "serde",
- "sha2 0.10.6",
- "syn 2.0.29",
-]
-
 [[package]]
 name = "p256k1"
 version = "6.0.0"
@@ -3537,7 +3514,6 @@ dependencies = [
  "lazy_static",
  "libc",
  "nix",
- "p256k1 5.5.0",
  "percent-encoding",
  "rand 0.7.3",
  "rand_core 0.6.4",
@@ -3557,7 +3533,7 @@ dependencies = [
  "slog-term",
  "time 0.2.27",
  "winapi 0.3.9",
- "wsts 4.0.0",
+ "wsts",
 ]
 
 [[package]]
@@ -3576,6 +3552,7 @@ dependencies = [
  "libsigner",
  "pico-args",
  "rand 0.7.3",
+ "rand_core 0.6.4",
  "regex",
  "reqwest",
  "ring",
@@ -3593,7 +3570,7 @@ dependencies = [
  "tracing",
  "tracing-subscriber",
  "warp",
- "wsts 5.0.0",
+ "wsts",
 ]
 
 [[package]]
@@ -3623,7 +3600,7 @@ dependencies = [
  "toml",
  "tracing",
  "tracing-subscriber",
- "wsts 5.0.0",
+ "wsts",
 ]
 
 [[package]]
@@ -3647,6 +3624,7 @@ dependencies = [
  "prometheus",
  "rand 0.7.3",
  "rand_chacha 0.2.2",
+ "rand_core 0.6.4",
  "regex",
  "ripemd",
  "rstest 0.17.0",
@@ -3669,7 +3647,7 @@ dependencies = [
  "time 0.2.27",
  "url",
  "winapi 0.3.9",
- "wsts 5.0.0",
+ "wsts",
 ]
 
 [[package]]
@@ -4732,28 +4710,6 @@ dependencies = [
  "winapi-build",
 ]
 
-[[package]]
-name = "wsts"
-version = "4.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a0c0ec44cbd35be82490c8c566ad4971f7b41ffe8508f1c9938140df7fe18b2"
-dependencies = [
- "aes-gcm 0.10.2",
- "bs58 0.5.0",
- "hashbrown 0.14.0",
- "hex",
- "num-traits",
- "p256k1 5.5.0",
- "polynomial",
- "primitive-types",
- "rand_core 0.6.4",
- "serde",
- "sha2 0.10.6",
- "thiserror",
- "tracing",
- "tracing-subscriber",
-]
-
 [[package]]
 name = "wsts"
 version = "5.0.0"
@@ -4765,7 +4721,7 @@ dependencies = [
  "hashbrown 0.14.0",
  "hex",
  "num-traits",
- "p256k1 6.0.0",
+ "p256k1",
  "polynomial",
  "primitive-types",
  "rand_core 0.6.4",
diff --git a/stacks-common/Cargo.toml b/stacks-common/Cargo.toml
index 079a769b1d..1916572cf4 100644
--- a/stacks-common/Cargo.toml
+++ b/stacks-common/Cargo.toml
@@ -31,8 +31,7 @@ slog-term = "2.6.0"
 slog-json = { version = "2.3.0", optional = true }
 chrono = "0.4.19"
 libc = "0.2.82"
-wsts = "4.0.0"
-p256k1 = "5.5"
+wsts = { workspace = true }
 
 [target.'cfg(unix)'.dependencies]
 nix = "0.23"
diff --git a/stacks-common/src/util/secp256k1.rs b/stacks-common/src/util/secp256k1.rs
index f70c0eb770..c06a0e83d3 100644
--- a/stacks-common/src/util/secp256k1.rs
+++ b/stacks-common/src/util/secp256k1.rs
@@ -13,8 +13,6 @@
 //
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-use p256k1::point::Compressed;
 use rand::{thread_rng, RngCore};
 use secp256k1;
 use secp256k1::ecdsa::{
@@ -29,7 +27,8 @@ use serde::de::{Deserialize, Error as de_Error};
 use serde::ser::Error as ser_Error;
 use serde::Serialize;
 use wsts::common::Signature as WSTSSignature;
-use wsts::{Point, Scalar};
+use wsts::curve::point::{Compressed, Point};
+use wsts::curve::scalar::Scalar;
 
 use super::hash::Sha256Sum;
 use crate::impl_byte_array_message_codec;
@@ -817,6 +816,8 @@ mod tests {
                 .expect("Failed to convert schnorr signature to wsts signature");
             assert_eq!(reverted_signature.R, original_signature.R);
             assert_eq!(reverted_signature.z, original_signature.z);
+            assert!(original_signature.verify(&aggregate_public_key, msg));
+            assert!(reverted_signature.verify(&aggregate_public_key, msg));
         }
     }
 }
diff --git a/stackslib/Cargo.toml b/stackslib/Cargo.toml
index 54a87b22c6..df70e2b801 100644
--- a/stackslib/Cargo.toml
+++ b/stackslib/Cargo.toml
@@ -56,6 +56,7 @@ pox-locking = { path = "../pox-locking" }
 libstackerdb = { path = "../libstackerdb" }
 siphasher = "0.3.7"
 wsts = {workspace = true}
+rand_core = "0.6"
 
 [target.'cfg(unix)'.dependencies]
 nix = "0.23"
diff --git a/stackslib/src/chainstate/burn/db/sortdb.rs b/stackslib/src/chainstate/burn/db/sortdb.rs
index a614adeec3..15ed3b8a9b 100644
--- a/stackslib/src/chainstate/burn/db/sortdb.rs
+++ b/stackslib/src/chainstate/burn/db/sortdb.rs
@@ -26,7 +26,6 @@ use clarity::vm::ast::ASTRules;
 use clarity::vm::costs::ExecutionCost;
 use clarity::vm::representations::{ClarityName, ContractName};
 use clarity::vm::types::{PrincipalData, Value};
-use p256k1::point::Compressed;
 use rand;
 use rand::RngCore;
 use rusqlite::types::ToSql;
@@ -45,7 +44,7 @@ use stacks_common::util::secp256k1::{MessageSignature, Secp256k1PublicKey};
 use stacks_common::util::vrf::*;
 use stacks_common::util::{get_epoch_time_secs, log};
 use wsts::common::Signature as WSTSSignature;
-use wsts::Point;
+use wsts::curve::point::{Compressed, Point};
 
 use crate::burnchains::affirmation::{AffirmationMap, AffirmationMapEntry};
 use crate::burnchains::bitcoin::BitcoinNetworkType;
diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index 33d6899a7e..43395ef6b6 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -24,14 +24,16 @@ use stacks_common::types::chainstate::{
 };
 use stacks_common::types::{Address, StacksEpoch};
 use stacks_common::util::vrf::VRFProof;
+use wsts::curve::point::Point;
 
 use crate::chainstate::burn::db::sortdb::SortitionDB;
 use crate::chainstate::burn::operations::BlockstackOperationType;
 use crate::chainstate::coordinator::tests::p2pkh_from;
 use crate::chainstate::nakamoto::tests::get_account;
+use crate::chainstate::nakamoto::tests::node::TestSigners;
 use crate::chainstate::nakamoto::{NakamotoBlock, NakamotoChainState};
 use crate::chainstate::stacks::address::PoxAddress;
-use crate::chainstate::stacks::boot::test::make_pox_4_lockup;
+use crate::chainstate::stacks::boot::test::{make_pox_4_aggregate_key, make_pox_4_lockup};
 use crate::chainstate::stacks::db::{StacksAccount, StacksChainState};
 use crate::chainstate::stacks::{
     CoinbasePayload, StacksTransaction, StacksTransactionSigner, TenureChangeCause,
@@ -44,7 +46,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) {
+fn advance_to_nakamoto(peer: &mut TestPeer, aggregate_public_key: &Point) {
     let mut peer_nonce = 0;
     let private_key = peer.config.private_key.clone();
     let addr = StacksAddress::from_public_keys(
@@ -55,14 +57,9 @@ fn advance_to_nakamoto(peer: &mut TestPeer) {
     )
     .unwrap();
 
-    // advance through cycle 6
-    for _ in 0..5 {
-        peer.tenure_with_txs(&[], &mut peer_nonce);
-    }
-
-    // stack to pox-3 in cycle 7
-    for sortition_height in 0..6 {
-        let txs = if sortition_height == 0 {
+    for sortition_height in 0..11 {
+        // stack to pox-3 in cycle 7
+        let txs = if sortition_height == 6 {
             // stack them all
             let stack_tx = make_pox_4_lockup(
                 &private_key,
@@ -72,7 +69,9 @@ fn advance_to_nakamoto(peer: &mut TestPeer) {
                 12,
                 34,
             );
-            vec![stack_tx]
+            let aggregate_tx: StacksTransaction =
+                make_pox_4_aggregate_key(&private_key, 1, 7, aggregate_public_key);
+            vec![stack_tx, aggregate_tx]
         } else {
             vec![]
         };
@@ -85,7 +84,11 @@ fn advance_to_nakamoto(peer: &mut TestPeer) {
 
 /// Make a peer and transition it into the Nakamoto epoch.
 /// The node needs to be stacking; otherwise, Nakamoto won't activate.
-fn boot_nakamoto(test_name: &str, mut initial_balances: Vec<(PrincipalData, u64)>) -> TestPeer {
+fn boot_nakamoto(
+    test_name: &str,
+    mut initial_balances: Vec<(PrincipalData, u64)>,
+    aggregate_public_key: Point,
+) -> TestPeer {
     let mut peer_config = TestPeerConfig::new(test_name, 0, 0);
     let private_key = peer_config.private_key.clone();
     let addr = StacksAddress::from_public_keys(
@@ -109,19 +112,19 @@ fn boot_nakamoto(test_name: &str, mut initial_balances: Vec<(PrincipalData, u64)
     peer_config.burnchain.pox_constants.pox_4_activation_height = 31;
 
     let mut peer = TestPeer::new(peer_config);
-    advance_to_nakamoto(&mut peer);
+    advance_to_nakamoto(&mut peer, &aggregate_public_key);
     peer
 }
 
 /// Make a replay peer, used for replaying the blockchain
-fn make_replay_peer<'a>(peer: &'a mut TestPeer<'a>) -> TestPeer<'a> {
+fn make_replay_peer<'a>(peer: &'a mut TestPeer<'a>, aggregate_public_key: &Point) -> 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);
+    advance_to_nakamoto(&mut replay_peer, aggregate_public_key);
 
     // sanity check
     let replay_tip = {
@@ -223,7 +226,8 @@ fn replay_reward_cycle(
 /// Mine a single Nakamoto tenure with a single Nakamoto block
 #[test]
 fn test_simple_nakamoto_coordinator_bootup() {
-    let mut peer = boot_nakamoto(function_name!(), vec![]);
+    let test_signers = TestSigners::default();
+    let mut peer = boot_nakamoto(function_name!(), vec![], test_signers.aggregate_public_key);
 
     let (burn_ops, tenure_change, miner_key) =
         peer.begin_nakamoto_tenure(TenureChangeCause::BlockFound);
@@ -261,7 +265,8 @@ fn test_simple_nakamoto_coordinator_bootup() {
 /// Mine a single Nakamoto tenure with 10 Nakamoto blocks
 #[test]
 fn test_simple_nakamoto_coordinator_1_tenure_10_blocks() {
-    let mut peer = boot_nakamoto(function_name!(), vec![]);
+    let test_signers = TestSigners::default();
+    let mut peer = boot_nakamoto(function_name!(), vec![], test_signers.aggregate_public_key);
     let private_key = peer.config.private_key.clone();
     let addr = StacksAddress::from_public_keys(
         C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
@@ -333,7 +338,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);
+    let mut replay_peer = make_replay_peer(&mut peer, &test_signers.aggregate_public_key);
     replay_reward_cycle(&mut replay_peer, &[burn_ops], &blocks);
 
     let tip = {
@@ -360,7 +365,8 @@ fn test_simple_nakamoto_coordinator_1_tenure_10_blocks() {
 /// Mine a 10 Nakamoto tenures with 10 Nakamoto blocks
 #[test]
 fn test_simple_nakamoto_coordinator_10_tenures_10_blocks() {
-    let mut peer = boot_nakamoto(function_name!(), vec![]);
+    let test_signers = TestSigners::default();
+    let mut peer = boot_nakamoto(function_name!(), vec![], test_signers.aggregate_public_key);
     let private_key = peer.config.private_key.clone();
     let addr = StacksAddress::from_public_keys(
         C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
@@ -529,7 +535,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);
+    let mut replay_peer = make_replay_peer(&mut peer, &test_signers.aggregate_public_key);
     for (burn_ops, blocks) in rc_burn_ops.iter().zip(rc_blocks.iter()) {
         replay_reward_cycle(&mut replay_peer, burn_ops, blocks);
     }
diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index 0aa0b099ff..e224d97eca 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -1359,12 +1359,17 @@ impl NakamotoChainState {
             return Ok(false);
         };
 
-        let schnorr_signature = block.header.signer_signature.to_wsts_signature().ok_or({
-            let msg =
-                format!("Received block, signed by miner, but the block has no stacker signature");
-            warn!("{}", msg);
-            ChainstateError::InvalidStacksBlock(msg)
-        })?;
+        let schnorr_signature = block
+            .header
+            .signer_signature
+            .to_wsts_signature()
+            .ok_or_else(|| {
+                let msg = format!(
+                    "Received block, signed by miner, but the block has no stacker signature"
+                );
+                warn!("{}", msg);
+                ChainstateError::InvalidStacksBlock(msg)
+            })?;
 
         if !sortdb.expects_signer_signature(
             &block.header.consensus_hash,
diff --git a/stackslib/src/chainstate/nakamoto/tests/node.rs b/stackslib/src/chainstate/nakamoto/tests/node.rs
index 082fd9e80b..16a19850d5 100644
--- a/stackslib/src/chainstate/nakamoto/tests/node.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/node.rs
@@ -28,8 +28,11 @@ use stacks_common::address::*;
 use stacks_common::consts::{FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH};
 use stacks_common::types::chainstate::{BlockHeaderHash, SortitionId, StacksBlockId, VRFSeed};
 use stacks_common::util::hash::Hash160;
+use stacks_common::util::secp256k1::SchnorrSignature;
 use stacks_common::util::sleep_ms;
 use stacks_common::util::vrf::{VRFProof, VRFPublicKey};
+use wsts::traits::Aggregator;
+use wsts::curve::point::Point;
 
 use crate::burnchains::bitcoin::indexer::BitcoinIndexer;
 use crate::burnchains::tests::*;
@@ -63,6 +66,88 @@ use crate::net::test::{TestPeer, TestPeerConfig, *};
 use crate::util_lib::boot::boot_code_addr;
 use crate::util_lib::db::Error as db_error;
 
+#[derive(Debug, Clone)]
+pub struct TestSigners {
+    /// The parties that will sign the blocks
+    pub signer_parties: Vec<wsts::v2::Party>,
+    /// The commitments to the polynomials for the aggregate public key
+    pub comms: Vec<wsts::common::PolyCommitment>,
+    /// The aggregate public key
+    pub aggregate_public_key: Point,
+    /// The total number of key ids distributed among signer_parties
+    pub num_keys: u32,
+    /// The number of vote shares required to sign a block
+    pub threshold: u32,
+}
+
+impl Default for TestSigners {
+    fn default() -> Self {
+        let mut rng = rand_core::OsRng::default();
+        let num_keys = 10;
+        let threshold = 7;
+        let party_key_ids: Vec<Vec<u32>> =
+            vec![vec![0, 1, 2], vec![3, 4], vec![5, 6, 7], vec![8, 9]];
+        let num_parties = party_key_ids.len().try_into().unwrap();
+
+        // Create the parties
+        let mut signer_parties: Vec<wsts::v2::Party> = party_key_ids
+            .iter()
+            .enumerate()
+            .map(|(pid, pkids)| {
+                wsts::v2::Party::new(
+                    pid.try_into().unwrap(),
+                    pkids,
+                    num_parties,
+                    num_keys,
+                    threshold,
+                    &mut rng,
+                )
+            })
+            .collect();
+
+        // Generate an aggregate public key
+        let comms = match wsts::v2::test_helpers::dkg(&mut signer_parties, &mut rng) {
+            Ok(comms) => comms,
+            Err(secret_errors) => {
+                panic!("Got secret errors from DKG: {:?}", secret_errors);
+            }
+        };
+        let aggregate_public_key = comms
+            .iter()
+            .fold(Point::default(), |s, comm| s + comm.poly[0]);
+        Self {
+            signer_parties,
+            aggregate_public_key,
+            comms,
+            num_keys,
+            threshold,
+        }
+    }
+}
+
+impl TestSigners {
+    pub fn sign_nakamoto_block(&mut self, block: &mut NakamotoBlock) {
+        let mut rng = rand_core::OsRng;
+        let msg = block
+            .header
+            .signer_signature_hash()
+            .expect("Failed to determine the block header signature hash for signers.")
+            .0;
+        let (nonces, sig_shares, key_ids) =
+            wsts::v2::test_helpers::sign(msg.as_slice(), &mut self.signer_parties, &mut rng);
+
+        let mut sig_aggregator = wsts::v2::Aggregator::new(self.num_keys, self.threshold);
+        sig_aggregator
+            .init(self.comms.clone())
+            .expect("aggregator init failed");
+        let signature = sig_aggregator
+            .sign(msg.as_slice(), &nonces, &sig_shares, &key_ids)
+            .expect("aggregator sig failed");
+        let schnorr_signature = SchnorrSignature::from(&signature);
+        block.header.signer_signature = schnorr_signature;
+    }
+}
+
 impl TestBurnchainBlock {
     pub fn add_nakamoto_tenure_commit(
         &mut self,
@@ -397,6 +482,7 @@ impl TestStacksNode {
         chainstate: &mut StacksChainState,
         sortdb: &SortitionDB,
         miner: &mut TestMiner,
+        signers: &mut TestSigners,
         proof: VRFProof,
         tenure_change_payload: TenureChangePayload,
         coord: &mut ChainsCoordinator<
@@ -473,6 +559,7 @@ impl TestStacksNode {
                 .make_nakamoto_block_from_txs(chainstate, &sortdb.index_conn(), txs)
                 .unwrap();
             miner.sign_nakamoto_block(&mut nakamoto_block);
+            signers.sign_nakamoto_block(&mut nakamoto_block);
 
             let block_id = nakamoto_block.block_id();
             debug!(
@@ -771,6 +858,7 @@ impl<'a> TestPeer<'a> {
             &mut stacks_node.chainstate,
             &sortdb,
             &mut self.miner,
+            &mut self.signers,
             vrf_proof,
             tenure_change_payload,
             &mut self.coord,
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 0dec459614..ede55d9d8b 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -34,13 +34,13 @@ use clarity::vm::types::{
 };
 use clarity::vm::{ClarityVersion, Environment, SymbolicExpression};
 use lazy_static::lazy_static;
-use p256k1::point::Compressed;
 use stacks_common::address::AddressHashMode;
 use stacks_common::codec::StacksMessageCodec;
 use stacks_common::types;
 use stacks_common::types::chainstate::{BlockHeaderHash, StacksAddress, StacksBlockId};
 use stacks_common::util::hash::{to_hex, Hash160};
-use wsts::{Point, Scalar};
+use wsts::curve::point::{Compressed, Point};
+use wsts::curve::scalar::Scalar;
 
 use crate::burnchains::bitcoin::address::BitcoinAddress;
 use crate::burnchains::{Address, Burnchain, PoxConstants};
diff --git a/stackslib/src/net/mod.rs b/stackslib/src/net/mod.rs
index 4790ddd8fb..781707e606 100644
--- a/stackslib/src/net/mod.rs
+++ b/stackslib/src/net/mod.rs
@@ -1602,6 +1602,7 @@ pub mod test {
     use crate::chainstate::burn::*;
     use crate::chainstate::coordinator::tests::*;
     use crate::chainstate::coordinator::*;
+    use crate::chainstate::nakamoto::tests::node::TestSigners;
     use crate::chainstate::stacks::address::PoxAddress;
     use crate::chainstate::stacks::boot::test::get_parent_tip;
     use crate::chainstate::stacks::boot::*;
@@ -2096,6 +2097,7 @@ pub mod test {
         pub network: PeerNetwork,
         pub sortdb: Option<SortitionDB>,
         pub miner: TestMiner,
+        pub signers: TestSigners,
         pub stacks_node: Option<TestStacksNode>,
         pub relayer: Relayer,
         pub mempool: Option<MemPoolDB>,
@@ -2196,7 +2198,7 @@ pub mod test {
             let mut miner_factory = TestMinerFactory::new();
             let mut miner =
                 miner_factory.next_miner(&config.burnchain, 1, 1, AddressHashMode::SerializeP2PKH);
-
+            let signers = TestSigners::default();
             // manually set fees
             miner.test_with_tx_fees = false;
 
@@ -2446,7 +2448,8 @@ pub mod test {
                 config: config,
                 network: peer_network,
                 sortdb: Some(sortdb),
-                miner: miner,
+                miner,
+                signers,
                 stacks_node: Some(stacks_node),
                 relayer: relayer,
                 mempool: Some(mempool),
diff --git a/testnet/stacks-node/Cargo.toml b/testnet/stacks-node/Cargo.toml
index 7e0e7387ec..780b65116e 100644
--- a/testnet/stacks-node/Cargo.toml
+++ b/testnet/stacks-node/Cargo.toml
@@ -28,6 +28,8 @@ stacks-common = { path = "../../stacks-common" }
 chrono = "0.4.19"
 regex = "1"
 libsigner = { path = "../../libsigner" }
+wsts = { workspace = true }
+rand_core = "0.6"
 
 [dev-dependencies]
 ring = "0.16.19"

From 217ca4d558adc1a9f4bec7f54acf84b82ec02c16 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Mon, 20 Nov 2023 09:14:53 -0500
Subject: [PATCH 0056/1166] Cleanup is_some check for bhh

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stackslib/src/chainstate/burn/db/sortdb.rs | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/stackslib/src/chainstate/burn/db/sortdb.rs b/stackslib/src/chainstate/burn/db/sortdb.rs
index 15ed3b8a9b..4674cbaff9 100644
--- a/stackslib/src/chainstate/burn/db/sortdb.rs
+++ b/stackslib/src/chainstate/burn/db/sortdb.rs
@@ -1979,10 +1979,9 @@ impl<'a> SortitionHandleConn<'a> {
         }
 
         // is this consensus hash in this fork?
-        let Some(_bhh) = SortitionDB::get_burnchain_header_hash_by_consensus(self, consensus_hash)?
-        else {
+        if !SortitionDB::get_burnchain_header_hash_by_consensus(self, consensus_hash)?.is_some() {
             return Ok(false);
-        };
+        }
 
         // Get the current reward cycle
         let reward_cycle = if let Some(reward_cycle) = self

From c1465e1881a1bcbb4bafdf49ea3f5bba2c7d51b2 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Mon, 20 Nov 2023 12:55:33 -0500
Subject: [PATCH 0057/1166] Fix TestPeer to use the correct TestSigners

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stackslib/src/chainstate/nakamoto/coordinator/tests.rs | 9 ++++++---
 stackslib/src/chainstate/nakamoto/tests/node.rs        | 3 ++-
 stackslib/src/net/mod.rs                               | 3 ---
 3 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index 43395ef6b6..3dcea456ca 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -226,7 +226,7 @@ fn replay_reward_cycle(
 /// Mine a single Nakamoto tenure with a single Nakamoto block
 #[test]
 fn test_simple_nakamoto_coordinator_bootup() {
-    let test_signers = TestSigners::default();
+    let mut test_signers = TestSigners::default();
     let mut peer = boot_nakamoto(function_name!(), vec![], test_signers.aggregate_public_key);
 
     let (burn_ops, tenure_change, miner_key) =
@@ -236,6 +236,7 @@ fn test_simple_nakamoto_coordinator_bootup() {
     let blocks_and_sizes = peer.make_nakamoto_tenure(
         &consensus_hash,
         tenure_change,
+        &mut test_signers,
         vrf_proof,
         |_miner, _chainstate, _sort_dbconn, _count| vec![],
     );
@@ -265,7 +266,7 @@ fn test_simple_nakamoto_coordinator_bootup() {
 /// Mine a single Nakamoto tenure with 10 Nakamoto blocks
 #[test]
 fn test_simple_nakamoto_coordinator_1_tenure_10_blocks() {
-    let test_signers = TestSigners::default();
+    let mut test_signers = TestSigners::default();
     let mut peer = boot_nakamoto(function_name!(), vec![], test_signers.aggregate_public_key);
     let private_key = peer.config.private_key.clone();
     let addr = StacksAddress::from_public_keys(
@@ -288,6 +289,7 @@ fn test_simple_nakamoto_coordinator_1_tenure_10_blocks() {
     let blocks_and_sizes = peer.make_nakamoto_tenure(
         &consensus_hash,
         tenure_change,
+        &mut test_signers,
         vrf_proof,
         |miner, chainstate, sortdb, count| {
             if count < 10 {
@@ -365,7 +367,7 @@ fn test_simple_nakamoto_coordinator_1_tenure_10_blocks() {
 /// Mine a 10 Nakamoto tenures with 10 Nakamoto blocks
 #[test]
 fn test_simple_nakamoto_coordinator_10_tenures_10_blocks() {
-    let test_signers = TestSigners::default();
+    let mut test_signers = TestSigners::default();
     let mut peer = boot_nakamoto(function_name!(), vec![], test_signers.aggregate_public_key);
     let private_key = peer.config.private_key.clone();
     let addr = StacksAddress::from_public_keys(
@@ -398,6 +400,7 @@ fn test_simple_nakamoto_coordinator_10_tenures_10_blocks() {
         let blocks_and_sizes = peer.make_nakamoto_tenure(
             &consensus_hash,
             tenure_change,
+            &mut test_signers,
             vrf_proof,
             |miner, chainstate, sortdb, count| {
                 if count < 10 {
diff --git a/stackslib/src/chainstate/nakamoto/tests/node.rs b/stackslib/src/chainstate/nakamoto/tests/node.rs
index 16a19850d5..8aaa09cf4e 100644
--- a/stackslib/src/chainstate/nakamoto/tests/node.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/node.rs
@@ -838,6 +838,7 @@ impl<'a> TestPeer<'a> {
         &mut self,
         consensus_hash: &ConsensusHash,
         tenure_change_payload: TenureChangePayload,
+        signers: &mut TestSigners,
         vrf_proof: VRFProof,
         block_builder: F,
     ) -> Vec<(NakamotoBlock, u64, ExecutionCost)>
@@ -858,7 +859,7 @@ impl<'a> TestPeer<'a> {
             &mut stacks_node.chainstate,
             &sortdb,
             &mut self.miner,
-            &mut self.signers,
+            signers,
             vrf_proof,
             tenure_change_payload,
             &mut self.coord,
diff --git a/stackslib/src/net/mod.rs b/stackslib/src/net/mod.rs
index 781707e606..414691d37d 100644
--- a/stackslib/src/net/mod.rs
+++ b/stackslib/src/net/mod.rs
@@ -2097,7 +2097,6 @@ pub mod test {
         pub network: PeerNetwork,
         pub sortdb: Option<SortitionDB>,
         pub miner: TestMiner,
-        pub signers: TestSigners,
         pub stacks_node: Option<TestStacksNode>,
         pub relayer: Relayer,
         pub mempool: Option<MemPoolDB>,
@@ -2198,7 +2197,6 @@ pub mod test {
             let mut miner_factory = TestMinerFactory::new();
             let mut miner =
                 miner_factory.next_miner(&config.burnchain, 1, 1, AddressHashMode::SerializeP2PKH);
-            let signers = TestSigners::default();
             // manually set fees
             miner.test_with_tx_fees = false;
 
@@ -2449,7 +2447,6 @@ pub mod test {
                 network: peer_network,
                 sortdb: Some(sortdb),
                 miner,
-                signers,
                 stacks_node: Some(stacks_node),
                 relayer: relayer,
                 mempool: Some(mempool),

From fef85a8b3c7fd465860c56d383852e5377394d70 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Mon, 20 Nov 2023 13:42:24 -0500
Subject: [PATCH 0058/1166] Only set the aggregate public key if in Pox 4

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stackslib/src/chainstate/coordinator/mod.rs | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/stackslib/src/chainstate/coordinator/mod.rs b/stackslib/src/chainstate/coordinator/mod.rs
index eb34968aa6..a7750eb568 100644
--- a/stackslib/src/chainstate/coordinator/mod.rs
+++ b/stackslib/src/chainstate/coordinator/mod.rs
@@ -328,6 +328,7 @@ impl OnChainRewardSetProvider {
         block_id: &StacksBlockId,
         cur_epoch: StacksEpoch,
     ) -> Result<RewardSet, Error> {
+        let mut aggregate_public_key = None;
         match cur_epoch.epoch_id {
             StacksEpochId::Epoch10
             | StacksEpochId::Epoch20
@@ -368,6 +369,11 @@ impl OnChainRewardSetProvider {
                     info!("PoX reward cycle defaulting to burn in Epoch 2.5 because cycle start is before PoX-4 activation");
                     return Ok(RewardSet::empty());
                 }
+                let reward_cycle = burnchain
+                    .block_height_to_reward_cycle(current_burn_height)
+                    .ok_or(crate::chainstate::stacks::Error::PoxNoRewardCycle)?;
+                aggregate_public_key =
+                    chainstate.get_aggregate_public_key_pox_4(sortdb, block_id, reward_cycle)?;
             }
         };
 
@@ -400,12 +406,7 @@ impl OnChainRewardSetProvider {
                   "liquid_ustx" => liquid_ustx,
                   "registered_addrs" => registered_addrs.len());
         }
-        let reward_cycle = burnchain
-            .block_height_to_reward_cycle(current_burn_height)
-            .ok_or(crate::chainstate::stacks::Error::PoxNoRewardCycle)?;
 
-        let aggregate_public_key =
-            chainstate.get_aggregate_public_key_pox_4(sortdb, block_id, reward_cycle)?;
         Ok(StacksChainState::make_reward_set(
             threshold,
             registered_addrs,
@@ -681,7 +682,6 @@ pub fn get_reward_cycle_info<U: RewardSetProvider>(
     let epoch_at_height = SortitionDB::get_stacks_epoch(sort_db.conn(), burn_height)?.expect(
         &format!("FATAL: no epoch defined for burn height {}", burn_height),
     );
-
     let reward_cycle_info = if burnchain.is_reward_cycle_start(burn_height) {
         let reward_cycle = burnchain
             .block_height_to_reward_cycle(burn_height)

From 692d07c3edbf9246ed2e5d21a5a4d4510cd4cb4d Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 22 Nov 2023 11:07:02 -0500
Subject: [PATCH 0059/1166] Cleanup get_reard_cycle_aggregate_public_key and
 set aggregate key for all reward cycles

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stackslib/src/chainstate/burn/db/sortdb.rs    | 79 +++++--------------
 .../chainstate/nakamoto/coordinator/tests.rs  | 10 ++-
 2 files changed, 26 insertions(+), 63 deletions(-)

diff --git a/stackslib/src/chainstate/burn/db/sortdb.rs b/stackslib/src/chainstate/burn/db/sortdb.rs
index 4674cbaff9..dbb99c8401 100644
--- a/stackslib/src/chainstate/burn/db/sortdb.rs
+++ b/stackslib/src/chainstate/burn/db/sortdb.rs
@@ -1998,10 +1998,12 @@ impl<'a> SortitionHandleConn<'a> {
             );
             return Ok(false);
         };
-        Ok(self
-            .get_reward_cycle_aggregate_public_key(reward_cycle)?
-            .map(|key| signer_signature.verify(&key, message))
-            .unwrap_or(false))
+        if let Some(key) = self.get_reward_cycle_aggregate_public_key(reward_cycle)? {
+            return Ok(signer_signature.verify(&key, message));
+        } else {
+            warn!("No known aggregate public key for reward cycle {reward_cycle}");
+            return Ok(false);
+        }
     }
 
     /// Get the aggregate public key for the given reward cycle.
@@ -2009,68 +2011,23 @@ impl<'a> SortitionHandleConn<'a> {
         &self,
         reward_cycle: u64,
     ) -> Result<Option<Point>, db_error> {
-        // Retrieve the the first sortition in the current reward cycle
-        let reward_cycle_block_height = self
+        let prev_reward_cycle = reward_cycle - 1;
+        // Get the first sortition in the prepare phase of the PARENT reward cycle
+        let prepare_phase_start = self
             .context
             .pox_constants
-            .reward_cycle_to_block_height(self.context.first_block_height, reward_cycle);
-        let reward_cycle_start_sortition_id = self
-            .get_ancestor_block_hash(reward_cycle_block_height, &self.context.chain_tip)?
-            .ok_or_else(|| {
-                warn!(
-                    "reward start height {} does not have a sorition from {}",
-                    reward_cycle_block_height, &self.context.chain_tip
-                );
-                db_error::NotFoundError
-            })?;
-        let reward_cycle_start_snapshot =
-            SortitionDB::get_block_snapshot(self, &reward_cycle_start_sortition_id)?
-                .ok_or(db_error::NotFoundError)
-                .map_err(|e| {
+            .prepare_phase_start(self.context.first_block_height, prev_reward_cycle);
+        let first_prepare_sn =
+            SortitionDB::get_ancestor_snapshot(self, prepare_phase_start, &self.context.chain_tip)?
+                .ok_or_else(|| {
                     warn!(
-                        "No block snapshot for reward cycle starting sortition id: {:?}",
-                        &reward_cycle_start_sortition_id
+                        "Prepare phase for reward cycle {} does not have a sorition from {}",
+                        prev_reward_cycle, &self.context.chain_tip
                     );
-                    e
+                    db_error::NotFoundError
                 })?;
-        // Search for the FIRST sortition in the prepare phase of the PARENT reward cycle
-        let mut prepare_phase_sn = SortitionDB::get_block_snapshot(
-            self,
-            &reward_cycle_start_snapshot.parent_sortition_id,
-        )?
-        .ok_or(db_error::NotFoundError)
-        .map_err(|e| {
-            warn!(
-                "No block snapshot for prepare phase cycle end sortition id: {:?}",
-                &reward_cycle_start_snapshot.parent_sortition_id
-            );
-            e
-        })?;
-        let mut height = prepare_phase_sn.block_height;
-        let mut first_sortition_id = None;
-        while height > 0
-            && self
-                .context
-                .pox_constants
-                .is_in_prepare_phase(self.context.first_block_height, height)
-        {
-            first_sortition_id = Some(prepare_phase_sn.sortition_id.clone());
-            height = prepare_phase_sn.block_height.saturating_sub(1);
-            prepare_phase_sn =
-                SortitionDB::get_block_snapshot(self, &prepare_phase_sn.parent_sortition_id)?
-                    .ok_or(db_error::NotFoundError)
-                    .map_err(|e| {
-                        warn!(
-                            "No sortition for reward cycle starting sortition id: {:?}",
-                            &reward_cycle_start_sortition_id
-                        );
-                        e
-                    })?;
-        }
-        if let Some(first_sortition_id) = first_sortition_id {
-            return self.get_reward_set_aggregate_public_key(&first_sortition_id);
-        }
-        Ok(None)
+
+        self.get_reward_set_aggregate_public_key(&first_prepare_sn.sortition_id)
     }
 
     /// Get the aggregate public key for reward set of the given sortition id.
diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index 3dcea456ca..8faa34df04 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -396,7 +396,7 @@ 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(
             &consensus_hash,
             tenure_change,
@@ -418,7 +418,13 @@ fn test_simple_nakamoto_coordinator_10_tenures_10_blocks() {
                         &recipient_addr,
                     );
 
-                    vec![stx_transfer]
+                    let aggregate_tx = make_pox_4_aggregate_key(
+                        &private_key,
+                        account.nonce + 1,
+                        7 + i,
+                        &aggregate_public_key,
+                    );
+                    vec![stx_transfer, aggregate_tx]
                 } else {
                     vec![]
                 }

From ab0debbd4780e21fcbd193942c27875872a2fdf1 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 22 Nov 2023 11:35:21 -0500
Subject: [PATCH 0060/1166] BUG: fix find_prepare_phase_sortitions to not
 include one BEFORE prepare phase

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stackslib/src/chainstate/burn/db/sortdb.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/stackslib/src/chainstate/burn/db/sortdb.rs b/stackslib/src/chainstate/burn/db/sortdb.rs
index dbb99c8401..e476943fad 100644
--- a/stackslib/src/chainstate/burn/db/sortdb.rs
+++ b/stackslib/src/chainstate/burn/db/sortdb.rs
@@ -2021,12 +2021,11 @@ impl<'a> SortitionHandleConn<'a> {
             SortitionDB::get_ancestor_snapshot(self, prepare_phase_start, &self.context.chain_tip)?
                 .ok_or_else(|| {
                     warn!(
-                        "Prepare phase for reward cycle {} does not have a sorition from {}",
+                        "Prepare phase for reward cycle {} does not have a sortition from {}",
                         prev_reward_cycle, &self.context.chain_tip
                     );
                     db_error::NotFoundError
                 })?;
-
         self.get_reward_set_aggregate_public_key(&first_prepare_sn.sortition_id)
     }
 

From 1cab88eff7399c27012e1de824cce714dae4472c Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Tue, 28 Nov 2023 13:04:44 -0500
Subject: [PATCH 0061/1166] Always retrieve the aggregate public key from pox-4

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stackslib/src/chainstate/burn/db/sortdb.rs    | 64 +---------------
 stackslib/src/chainstate/coordinator/mod.rs   |  7 --
 stackslib/src/chainstate/coordinator/tests.rs |  1 -
 .../chainstate/nakamoto/coordinator/mod.rs    | 12 ---
 stackslib/src/chainstate/nakamoto/mod.rs      | 74 +++++++++++++++++--
 .../src/chainstate/nakamoto/tests/node.rs     | 11 ++-
 stackslib/src/chainstate/stacks/boot/mod.rs   |  7 +-
 stackslib/src/net/relay.rs                    | 41 +++++++++-
 testnet/stacks-node/src/mockamoto.rs          | 20 ++++-
 9 files changed, 135 insertions(+), 102 deletions(-)

diff --git a/stackslib/src/chainstate/burn/db/sortdb.rs b/stackslib/src/chainstate/burn/db/sortdb.rs
index e476943fad..e7443ff525 100644
--- a/stackslib/src/chainstate/burn/db/sortdb.rs
+++ b/stackslib/src/chainstate/burn/db/sortdb.rs
@@ -67,6 +67,7 @@ use crate::chainstate::burn::{
 use crate::chainstate::coordinator::{
     Error as CoordinatorError, PoxAnchorBlockStatus, RewardCycleInfo,
 };
+use crate::chainstate::nakamoto::NakamotoBlockHeader;
 use crate::chainstate::stacks::address::{PoxAddress, StacksAddressExtensions};
 use crate::chainstate::stacks::boot::PoxStartCycleInfo;
 use crate::chainstate::stacks::db::{StacksChainState, StacksHeaderInfo};
@@ -1929,6 +1930,7 @@ impl<'a> SortitionHandleConn<'a> {
         consensus_hash: &ConsensusHash,
         signer_signature: &WSTSSignature,
         message: &[u8],
+        aggregate_public_key: &Point,
     ) -> Result<bool, db_error> {
         let sn = SortitionDB::get_block_snapshot(self, &self.context.chain_tip)?
             .ok_or(db_error::NotFoundError)
@@ -1979,69 +1981,11 @@ impl<'a> SortitionHandleConn<'a> {
         }
 
         // is this consensus hash in this fork?
-        if !SortitionDB::get_burnchain_header_hash_by_consensus(self, consensus_hash)?.is_some() {
+        if SortitionDB::get_burnchain_header_hash_by_consensus(self, consensus_hash)?.is_none() {
             return Ok(false);
         }
 
-        // Get the current reward cycle
-        let reward_cycle = if let Some(reward_cycle) = self
-            .context
-            .pox_constants
-            .block_height_to_reward_cycle(self.context.first_block_height, sn.block_height)
-        {
-            reward_cycle
-        } else {
-            // can't do anything
-            warn!("Failed to determine reward cycle of block with consensus hash";
-                  "consensus_hash" => %consensus_hash,
-                  "block_height" => ch_sn.block_height
-            );
-            return Ok(false);
-        };
-        if let Some(key) = self.get_reward_cycle_aggregate_public_key(reward_cycle)? {
-            return Ok(signer_signature.verify(&key, message));
-        } else {
-            warn!("No known aggregate public key for reward cycle {reward_cycle}");
-            return Ok(false);
-        }
-    }
-
-    /// Get the aggregate public key for the given reward cycle.
-    pub fn get_reward_cycle_aggregate_public_key(
-        &self,
-        reward_cycle: u64,
-    ) -> Result<Option<Point>, db_error> {
-        let prev_reward_cycle = reward_cycle - 1;
-        // Get the first sortition in the prepare phase of the PARENT reward cycle
-        let prepare_phase_start = self
-            .context
-            .pox_constants
-            .prepare_phase_start(self.context.first_block_height, prev_reward_cycle);
-        let first_prepare_sn =
-            SortitionDB::get_ancestor_snapshot(self, prepare_phase_start, &self.context.chain_tip)?
-                .ok_or_else(|| {
-                    warn!(
-                        "Prepare phase for reward cycle {} does not have a sortition from {}",
-                        prev_reward_cycle, &self.context.chain_tip
-                    );
-                    db_error::NotFoundError
-                })?;
-        self.get_reward_set_aggregate_public_key(&first_prepare_sn.sortition_id)
-    }
-
-    /// Get the aggregate public key for reward set of the given sortition id.
-    pub fn get_reward_set_aggregate_public_key(
-        &self,
-        sortition_id: &SortitionId,
-    ) -> Result<Option<Point>, db_error> {
-        if let Some(reward_info) = SortitionDB::get_preprocessed_reward_set(self, sortition_id)? {
-            if let PoxAnchorBlockStatus::SelectedAndKnown(_, _, reward_set) =
-                reward_info.anchor_status
-            {
-                return Ok(reward_set.aggregate_public_key);
-            }
-        }
-        Ok(None)
+        Ok(signer_signature.verify(aggregate_public_key, message))
     }
 
     pub fn get_reward_set_size_at(&self, sortition_id: &SortitionId) -> Result<u16, db_error> {
diff --git a/stackslib/src/chainstate/coordinator/mod.rs b/stackslib/src/chainstate/coordinator/mod.rs
index a7750eb568..0e813d1e71 100644
--- a/stackslib/src/chainstate/coordinator/mod.rs
+++ b/stackslib/src/chainstate/coordinator/mod.rs
@@ -328,7 +328,6 @@ impl OnChainRewardSetProvider {
         block_id: &StacksBlockId,
         cur_epoch: StacksEpoch,
     ) -> Result<RewardSet, Error> {
-        let mut aggregate_public_key = None;
         match cur_epoch.epoch_id {
             StacksEpochId::Epoch10
             | StacksEpochId::Epoch20
@@ -369,11 +368,6 @@ impl OnChainRewardSetProvider {
                     info!("PoX reward cycle defaulting to burn in Epoch 2.5 because cycle start is before PoX-4 activation");
                     return Ok(RewardSet::empty());
                 }
-                let reward_cycle = burnchain
-                    .block_height_to_reward_cycle(current_burn_height)
-                    .ok_or(crate::chainstate::stacks::Error::PoxNoRewardCycle)?;
-                aggregate_public_key =
-                    chainstate.get_aggregate_public_key_pox_4(sortdb, block_id, reward_cycle)?;
             }
         };
 
@@ -411,7 +405,6 @@ impl OnChainRewardSetProvider {
             threshold,
             registered_addrs,
             cur_epoch.epoch_id,
-            aggregate_public_key,
         ))
     }
 }
diff --git a/stackslib/src/chainstate/coordinator/tests.rs b/stackslib/src/chainstate/coordinator/tests.rs
index 4d919f3994..7e94c4bbc3 100644
--- a/stackslib/src/chainstate/coordinator/tests.rs
+++ b/stackslib/src/chainstate/coordinator/tests.rs
@@ -495,7 +495,6 @@ impl RewardSetProvider for StubbedRewardSetProvider {
             start_cycle_state: PoxStartCycleInfo {
                 missed_reward_slots: vec![],
             },
-            aggregate_public_key: None,
         })
     }
 }
diff --git a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
index f6102c31ad..0daf3ee196 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
@@ -69,12 +69,6 @@ impl OnChainRewardSetProvider {
         let registered_addrs =
             chainstate.get_reward_addresses_in_cycle(burnchain, sortdb, cycle, block_id)?;
 
-        let reward_cycle = burnchain
-            .block_height_to_reward_cycle(current_burn_height)
-            .ok_or(crate::chainstate::stacks::Error::PoxNoRewardCycle)?;
-
-        let aggregate_public_key =
-            chainstate.get_aggregate_public_key_pox_4(sortdb, block_id, reward_cycle)?;
         let liquid_ustx = chainstate.get_liquid_ustx(block_id);
 
         let (threshold, participation) = StacksChainState::get_reward_threshold_and_participation(
@@ -106,7 +100,6 @@ impl OnChainRewardSetProvider {
             threshold,
             registered_addrs,
             cur_epoch.epoch_id,
-            aggregate_public_key,
         ))
     }
 }
@@ -284,11 +277,6 @@ pub fn get_nakamoto_reward_cycle_info<U: RewardSetProvider>(
 
         let reward_set =
             provider.get_reward_set(burn_height, chain_state, burnchain, sort_db, &block_id)?;
-        // if the aggregate_public_key is not set, signers may not be done the DKG round/DKG vote
-        // The caller should try again when more blocks have arrived
-        if reward_set.aggregate_public_key.is_none() {
-            return Ok(None);
-        }
         debug!(
             "Stacks anchor block (ch {}) {} cycle {} is processed",
             &anchor_block_header.consensus_hash, &block_id, reward_cycle
diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index e224d97eca..9dee495640 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -42,6 +42,7 @@ use stacks_common::util::hash::{to_hex, Hash160, MerkleHashFunc, MerkleTree, Sha
 use stacks_common::util::retry::BoundReader;
 use stacks_common::util::secp256k1::{MessageSignature, SchnorrSignature};
 use stacks_common::util::vrf::{VRFProof, VRF};
+use wsts::Point;
 
 use super::burn::db::sortdb::{get_block_commit_by_txid, SortitionHandleConn, SortitionHandleTx};
 use super::burn::operations::{DelegateStxOp, StackStxOp, TransferStxOp};
@@ -1327,11 +1328,12 @@ impl NakamotoChainState {
     pub fn accept_block(
         config: &ChainstateConfig,
         block: NakamotoBlock,
-        sortdb: &SortitionHandleConn,
+        db_handle: &SortitionHandleConn,
         staging_db_tx: &rusqlite::Transaction,
+        aggregate_public_key: &Point,
     ) -> Result<bool, ChainstateError> {
         // do nothing if we already have this block
-        if let Some(_) = Self::get_block_header(&staging_db_tx, &block.header.block_id())? {
+        if let Some(_) = Self::get_block_header(staging_db_tx, &block.header.block_id())? {
             debug!("Already have block {}", &block.header.block_id());
             return Ok(false);
         }
@@ -1349,9 +1351,12 @@ impl NakamotoChainState {
 
         // this block must be consistent with its miner's leader-key and block-commit, and must
         // contain only transactions that are valid in this epoch.
-        if let Err(e) =
-            Self::validate_nakamoto_block_burnchain(sortdb, &block, config.mainnet, config.chain_id)
-        {
+        if let Err(e) = Self::validate_nakamoto_block_burnchain(
+            db_handle,
+            &block,
+            config.mainnet,
+            config.chain_id,
+        ) {
             warn!("Unacceptable Nakamoto block; will not store";
                   "block_id" => %block.block_id(),
                   "error" => format!("{:?}", &e)
@@ -1370,11 +1375,11 @@ impl NakamotoChainState {
                 warn!("{}", msg);
                 ChainstateError::InvalidStacksBlock(msg)
             })?;
-
-        if !sortdb.expects_signer_signature(
+        if !db_handle.expects_signer_signature(
             &block.header.consensus_hash,
             &schnorr_signature,
             &block.header.signer_signature_hash()?.0,
+            aggregate_public_key,
         )? {
             let msg = format!("Received block, but the stacker signature does not match the active stacking cycle");
             warn!("{}", msg);
@@ -1383,7 +1388,7 @@ impl NakamotoChainState {
 
         // if the burnchain block of this Stacks block's tenure has been processed, then it
         // is ready to be processed from the perspective of the burnchain
-        let burn_attachable = sortdb.processed_block(&block.header.consensus_hash)?;
+        let burn_attachable = db_handle.processed_block(&block.header.consensus_hash)?;
 
         // check if the parent Stacks Block ID has been processed. if so, then this block is stacks_attachable
         let stacks_attachable =
@@ -1413,6 +1418,59 @@ impl NakamotoChainState {
         Ok(true)
     }
 
+    /// Get the aggregate public key for the given block.
+    pub fn get_aggregate_public_key(
+        sortdb: &SortitionDB,
+        sort_handle: &SortitionHandleConn,
+        chainstate: &mut StacksChainState,
+        header: &NakamotoBlockHeader,
+        canonical_block_header: &StacksHeaderInfo,
+    ) -> Result<Point, ChainstateError> {
+        let ch_sn = SortitionDB::get_block_snapshot_consensus(sort_handle, &header.consensus_hash)?
+            .ok_or(ChainstateError::DBError(DBError::NotFoundError))
+            .map_err(|e| {
+                warn!(
+                    "No sortition for consensus hash: {:?}",
+                    &header.consensus_hash
+                );
+                e
+            })?;
+        // Get the current reward cycle
+        let Some(reward_cycle) = sort_handle
+            .context
+            .pox_constants
+            .block_height_to_reward_cycle(
+                sort_handle.context.first_block_height,
+                ch_sn.block_height,
+            )
+        else {
+            // can't do anything
+            let msg = format!(
+                "Failed to determine reward cycle of block height: {}.",
+                ch_sn.block_height
+            );
+            warn!("{msg}");
+            return Err(ChainstateError::InvalidStacksBlock(msg));
+        };
+
+        chainstate
+            .get_aggregate_public_key_pox_4(
+                sortdb,
+                &canonical_block_header.index_block_hash(),
+                reward_cycle,
+            )?
+            .ok_or_else(|| {
+                warn!(
+                    "Failed to get aggregate public key";
+                    "block_id" => %canonical_block_header.index_block_hash(),
+                    "reward_cycle" => reward_cycle,
+                    "canonical_block_height" => canonical_block_header.stacks_block_height,
+                    "canonical_block_height" => canonical_block_header.burn_header_height,
+                );
+                ChainstateError::InvalidStacksBlock("Failed to get aggregate public key".into())
+            })
+    }
+
     /// Create the block reward for a NakamotoBlock
     /// `coinbase_reward_ustx` is the total coinbase reward for this block, including any
     ///    accumulated rewards from missed sortitions or initial mining rewards.
diff --git a/stackslib/src/chainstate/nakamoto/tests/node.rs b/stackslib/src/chainstate/nakamoto/tests/node.rs
index 8aaa09cf4e..5746d482f6 100644
--- a/stackslib/src/chainstate/nakamoto/tests/node.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/node.rs
@@ -570,6 +570,7 @@ impl TestStacksNode {
             let sort_tip = SortitionDB::get_canonical_sortition_tip(sortdb.conn()).unwrap();
             let sort_handle = sortdb.index_handle(&sort_tip);
             let accepted = Relayer::process_new_nakamoto_block(
+                sortdb,
                 &sort_handle,
                 chainstate,
                 nakamoto_block.clone(),
@@ -893,9 +894,13 @@ impl<'a> TestPeer<'a> {
         for block in blocks.into_iter() {
             let block_id = block.block_id();
             debug!("Process Nakamoto block {} ({:?}", &block_id, &block.header);
-            let accepted =
-                Relayer::process_new_nakamoto_block(&sort_handle, &mut node.chainstate, block)
-                    .unwrap();
+            let accepted = Relayer::process_new_nakamoto_block(
+                &sortdb,
+                &sort_handle,
+                &mut node.chainstate,
+                block,
+            )
+            .unwrap();
             if accepted {
                 test_debug!("Accepted Nakamoto block {}", &block_id);
                 self.coord.handle_new_nakamoto_stacks_block().unwrap();
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index ede55d9d8b..a0f8cf53c3 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -163,8 +163,6 @@ pub struct PoxStartCycleInfo {
 pub struct RewardSet {
     pub rewarded_addresses: Vec<PoxAddress>,
     pub start_cycle_state: PoxStartCycleInfo,
-    /// The aggregate public key for the reward set.  This is only present in pox-4 cycles.
-    pub aggregate_public_key: Option<Point>,
 }
 
 const POX_CYCLE_START_HANDLED_VALUE: &'static str = "1";
@@ -191,7 +189,6 @@ impl RewardSet {
             start_cycle_state: PoxStartCycleInfo {
                 missed_reward_slots: vec![],
             },
-            aggregate_public_key: None,
         }
     }
 }
@@ -580,7 +577,6 @@ impl StacksChainState {
         threshold: u128,
         mut addresses: Vec<RawRewardSetEntry>,
         epoch_id: StacksEpochId,
-        aggregate_public_key: Option<Point>,
     ) -> RewardSet {
         let mut reward_set = vec![];
         let mut missed_slots = vec![];
@@ -670,7 +666,6 @@ impl StacksChainState {
             start_cycle_state: PoxStartCycleInfo {
                 missed_reward_slots: missed_slots,
             },
-            aggregate_public_key,
         }
     }
 
@@ -1249,7 +1244,7 @@ pub mod test {
             },
         ];
         assert_eq!(
-            StacksChainState::make_reward_set(threshold, addresses, StacksEpochId::Epoch2_05, None)
+            StacksChainState::make_reward_set(threshold, addresses, StacksEpochId::Epoch2_05)
                 .rewarded_addresses
                 .len(),
             3
diff --git a/stackslib/src/net/relay.rs b/stackslib/src/net/relay.rs
index 8e2cf2200d..b1a6c1f166 100644
--- a/stackslib/src/net/relay.rs
+++ b/stackslib/src/net/relay.rs
@@ -30,13 +30,14 @@ use stacks_common::types::chainstate::{BurnchainHeaderHash, PoxId, SortitionId,
 use stacks_common::types::StacksEpochId;
 use stacks_common::util::get_epoch_time_secs;
 use stacks_common::util::hash::Sha512Trunc256Sum;
+use wsts::Point;
 
 use crate::burnchains::{Burnchain, BurnchainView};
 use crate::chainstate::burn::db::sortdb::{SortitionDB, SortitionDBConn, SortitionHandleConn};
 use crate::chainstate::burn::{BlockSnapshot, ConsensusHash};
 use crate::chainstate::coordinator::comm::CoordinatorChannels;
 use crate::chainstate::coordinator::BlockEventDispatcher;
-use crate::chainstate::nakamoto::{NakamotoBlock, NakamotoChainState};
+use crate::chainstate::nakamoto::{NakamotoBlock, NakamotoBlockHeader, NakamotoChainState};
 use crate::chainstate::stacks::db::unconfirmed::ProcessedUnconfirmedState;
 use crate::chainstate::stacks::db::{StacksChainState, StacksEpochReceipt, StacksHeaderInfo};
 use crate::chainstate::stacks::events::StacksTransactionReceipt;
@@ -652,6 +653,7 @@ impl Relayer {
     /// downloaded by us, or pushed via p2p.
     /// Return Ok(true) if we stored it, Ok(false) if we didn't
     pub fn process_new_nakamoto_block(
+        sortdb: &SortitionDB,
         sort_handle: &SortitionHandleConn,
         chainstate: &mut StacksChainState,
         block: NakamotoBlock,
@@ -711,10 +713,43 @@ impl Relayer {
             &block.header.block_hash()
         );
 
+        let Some(canonical_block_header) =
+            NakamotoChainState::get_canonical_block_header(chainstate.db(), &sortdb)?
+        else {
+            warn!(
+                "Failed to find Nakamoto canonical block header.  Will not store or relay";
+                "stacks_block_hash" => %block.header.block_hash(),
+                "consensus_hash" => %block.header.consensus_hash,
+                "burn_height" => block.header.chain_length,
+                "sortition_height" => block_sn.block_height,
+            );
+            return Ok(false);
+        };
+
         let config = chainstate.config();
+        let Ok(aggregate_public_key) = NakamotoChainState::get_aggregate_public_key(
+            &sortdb,
+            &sort_handle,
+            chainstate,
+            &block.header,
+            &canonical_block_header,
+        ) else {
+            warn!("Failed to get aggregate public key. Will not store or relay";
+                "stacks_block_hash" => %block.header.block_hash(),
+                "consensus_hash" => %block.header.consensus_hash,
+                "burn_height" => block.header.chain_length,
+                "sortition_height" => block_sn.block_height,
+            );
+            return Ok(false);
+        };
         let staging_db_tx = chainstate.db_tx_begin()?;
-        let accepted =
-            NakamotoChainState::accept_block(&config, block, sort_handle, &staging_db_tx)?;
+        let accepted = NakamotoChainState::accept_block(
+            &config,
+            block,
+            sort_handle,
+            &staging_db_tx,
+            &aggregate_public_key,
+        )?;
         staging_db_tx.commit()?;
 
         if accepted {
diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index d66941125f..c551237d6f 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -478,9 +478,25 @@ impl MockamotoNode {
     fn mine_and_stage_block(&mut self) -> Result<(), ChainstateError> {
         let block = self.mine_stacks_block()?;
         let config = self.chainstate.config();
-        let chainstate_tx = self.chainstate.db_tx_begin()?;
         let sortition_handle = self.sortdb.index_handle_at_tip();
-        NakamotoChainState::accept_block(&config, block, &sortition_handle, &chainstate_tx)?;
+        let canonical_block_header =
+            NakamotoChainState::get_canonical_block_header(self.chainstate.db(), &self.sortdb)?
+                .unwrap();
+        let aggregate_public_key = NakamotoChainState::get_aggregate_public_key(
+            &self.sortdb,
+            &sortition_handle,
+            &mut self.chainstate,
+            &block.header,
+            &canonical_block_header,
+        )?;
+        let chainstate_tx = self.chainstate.db_tx_begin()?;
+        NakamotoChainState::accept_block(
+            &config,
+            block,
+            &sortition_handle,
+            &chainstate_tx,
+            &aggregate_public_key,
+        )?;
         chainstate_tx.commit()?;
         Ok(())
     }

From 3801d2592382eb650a8c59827e42972211bd8351 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Tue, 28 Nov 2023 13:05:22 -0500
Subject: [PATCH 0062/1166] Update replay_reward_cycle to keep retrying failed
 blocks

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 .../chainstate/nakamoto/coordinator/tests.rs  | 38 +++++++++++++------
 1 file changed, 27 insertions(+), 11 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index 8faa34df04..312aa86c24 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -69,8 +69,12 @@ 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, 7, aggregate_public_key);
+            let aggregate_tx: StacksTransaction = make_pox_4_aggregate_key(
+                &private_key,
+                1,
+                sortition_height + 1,
+                aggregate_public_key,
+            );
             vec![stack_tx, aggregate_tx]
         } else {
             vec![]
@@ -182,13 +186,18 @@ fn make_token_transfer(
 }
 
 /// Given the blocks and block-commits for a reward cycle, replay the sortitions on the given
-/// TestPeer but submit the blocks in random order.
+/// TestPeer, always processing the first block of the reward cycle before processing all
+/// subsequent blocks in random order.
 fn replay_reward_cycle(
     peer: &mut TestPeer,
     burn_ops: &[Vec<BlockstackOperationType>],
     stacks_blocks: &[NakamotoBlock],
 ) {
     eprintln!("\n\n=============================================\nBegin replay\n==============================================\n");
+    let reward_cycle_length = peer.config.burnchain.pox_constants.reward_cycle_length as usize;
+    let reward_cycle_indices: Vec<usize> = (0..stacks_blocks.len())
+        .step_by(reward_cycle_length)
+        .collect();
 
     let mut indexes: Vec<_> = (0..stacks_blocks.len()).collect();
     indexes.shuffle(&mut thread_rng());
@@ -203,19 +212,26 @@ fn replay_reward_cycle(
     let sort_tip = SortitionDB::get_canonical_sortition_tip(sortdb.conn()).unwrap();
     let sort_handle = sortdb.index_handle(&sort_tip);
 
-    for i in indexes.into_iter() {
-        let block: &NakamotoBlock = &stacks_blocks[i];
+    let mut blocks_to_process = stacks_blocks.to_vec();
+    blocks_to_process.shuffle(&mut thread_rng());
+    while let Some(block) = blocks_to_process.pop() {
         let block_id = block.block_id();
-        debug!("Process Nakamoto block {} ({:?}", &block_id, &block.header);
+        info!("Process Nakamoto block {} ({:?}", &block_id, &block.header);
 
-        let accepted =
-            Relayer::process_new_nakamoto_block(&sort_handle, &mut node.chainstate, block.clone())
-                .unwrap();
+        let accepted = Relayer::process_new_nakamoto_block(
+            &sortdb,
+            &sort_handle,
+            &mut node.chainstate,
+            block.clone(),
+        )
+        .unwrap();
         if accepted {
-            test_debug!("Accepted Nakamoto block {}", &block_id);
+            test_debug!("Accepted Nakamoto block {block_id}");
             peer.coord.handle_new_nakamoto_stacks_block().unwrap();
         } else {
-            test_debug!("Did NOT accept Nakamoto block {}", &block_id);
+            test_debug!("Did NOT accept Nakamoto block {block_id}");
+            blocks_to_process.push(block);
+            blocks_to_process.shuffle(&mut thread_rng());
         }
     }
 

From de8129cced156bb180bd19e42ac4ad1b2bca8d53 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 29 Nov 2023 09:14:42 -0500
Subject: [PATCH 0063/1166] CRC: add clarifying comments and names

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stackslib/src/chainstate/nakamoto/mod.rs      |  6 +++---
 .../src/chainstate/nakamoto/tests/node.rs     | 19 ++++++++++---------
 stackslib/src/chainstate/stacks/boot/mod.rs   |  2 +-
 .../src/chainstate/stacks/boot/pox-4.clar     |  2 +-
 stackslib/src/net/relay.rs                    |  2 +-
 5 files changed, 16 insertions(+), 15 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index 9dee495640..b6e64dd34a 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -42,7 +42,7 @@ use stacks_common::util::hash::{to_hex, Hash160, MerkleHashFunc, MerkleTree, Sha
 use stacks_common::util::retry::BoundReader;
 use stacks_common::util::secp256k1::{MessageSignature, SchnorrSignature};
 use stacks_common::util::vrf::{VRFProof, VRF};
-use wsts::Point;
+use wsts::curve::point::Point;
 
 use super::burn::db::sortdb::{get_block_commit_by_txid, SortitionHandleConn, SortitionHandleTx};
 use super::burn::operations::{DelegateStxOp, StackStxOp, TransferStxOp};
@@ -1444,9 +1444,9 @@ impl NakamotoChainState {
                 ch_sn.block_height,
             )
         else {
-            // can't do anything
+            // This should be unreachable, but we'll return an error just in case.
             let msg = format!(
-                "Failed to determine reward cycle of block height: {}.",
+                "BUG: Failed to determine reward cycle of block height: {}.",
                 ch_sn.block_height
             );
             warn!("{msg}");
diff --git a/stackslib/src/chainstate/nakamoto/tests/node.rs b/stackslib/src/chainstate/nakamoto/tests/node.rs
index 5746d482f6..5118dbfd22 100644
--- a/stackslib/src/chainstate/nakamoto/tests/node.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/node.rs
@@ -31,8 +31,8 @@ use stacks_common::util::hash::Hash160;
 use stacks_common::util::secp256k1::SchnorrSignature;
 use stacks_common::util::sleep_ms;
 use stacks_common::util::vrf::{VRFProof, VRFPublicKey};
-use wsts::traits::Aggregator;
 use wsts::curve::point::Point;
+use wsts::traits::Aggregator;
 
 use crate::burnchains::bitcoin::indexer::BitcoinIndexer;
 use crate::burnchains::tests::*;
@@ -71,7 +71,7 @@ pub struct TestSigners {
     /// The parties that will sign the blocks
     pub signer_parties: Vec<wsts::v2::Party>,
     /// The commitments to the polynomials for the aggregate public key
-    pub comms: Vec<wsts::common::PolyCommitment>,
+    pub poly_commitments: Vec<wsts::common::PolyCommitment>,
     /// The aggregate public key
     pub aggregate_public_key: Point,
     /// The total number of key ids distributed among signer_parties
@@ -106,19 +106,20 @@ impl Default for TestSigners {
             .collect();
 
         // Generate an aggregate public key
-        let comms = match wsts::v2::test_helpers::dkg(&mut signer_parties, &mut rng) {
-            Ok(comms) => comms,
+        let poly_commitments = match wsts::v2::test_helpers::dkg(&mut signer_parties, &mut rng) {
+            Ok(poly_commitments) => poly_commitments,
             Err(secret_errors) => {
                 panic!("Got secret errors from DKG: {:?}", secret_errors);
             }
         };
-        let aggregate_public_key = comms
-            .iter()
-            .fold(Point::default(), |s, comm| s + comm.poly[0]);
+        let aggregate_public_key = poly_commitments.iter().fold(
+            Point::default(),
+            |s, poly_commitment: &wsts::common::PolyCommitment| s + poly_commitment.poly[0],
+        );
         Self {
             signer_parties,
             aggregate_public_key,
-            comms,
+            poly_commitments,
             num_keys,
             threshold,
         }
@@ -138,7 +139,7 @@ impl TestSigners {
 
         let mut sig_aggregator = wsts::v2::Aggregator::new(self.num_keys, self.threshold);
         sig_aggregator
-            .init(self.comms.clone())
+            .init(self.poly_commitments.clone())
             .expect("aggregator init failed");
         let signature = sig_aggregator
             .sign(msg.as_slice(), &nonces, &sig_shares, &key_ids)
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index a0f8cf53c3..efaa578be1 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -1135,7 +1135,7 @@ impl StacksChainState {
         block_id: &StacksBlockId,
         reward_cycle: u64,
     ) -> Result<Option<Point>, Error> {
-        if !self.is_pox_active(sortdb, block_id, reward_cycle as u128, POX_4_NAME)? {
+        if !self.is_pox_active(sortdb, block_id, u128::from(reward_cycle), POX_4_NAME)? {
             debug!(
                 "PoX was voted disabled in block {} (reward cycle {})",
                 block_id, reward_cycle
diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index 2e6f7933e9..6766e4022e 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -1330,7 +1330,7 @@
 )
 
 ;; Set the aggregate public key to the provided value
-;; TODO: REMOVE THIS
+;; TODO: https://github.com/stacks-network/stacks-core/issues/4101
 ;; *New in Stacks 3.0*
 (define-public (set-aggregate-public-key (reward-cycle uint) (aggregate-public-key (buff 33)))
     (begin
diff --git a/stackslib/src/net/relay.rs b/stackslib/src/net/relay.rs
index b1a6c1f166..f1448aac97 100644
--- a/stackslib/src/net/relay.rs
+++ b/stackslib/src/net/relay.rs
@@ -30,7 +30,7 @@ use stacks_common::types::chainstate::{BurnchainHeaderHash, PoxId, SortitionId,
 use stacks_common::types::StacksEpochId;
 use stacks_common::util::get_epoch_time_secs;
 use stacks_common::util::hash::Sha512Trunc256Sum;
-use wsts::Point;
+use wsts::curve::point::Point;
 
 use crate::burnchains::{Burnchain, BurnchainView};
 use crate::chainstate::burn::db::sortdb::{SortitionDB, SortitionDBConn, SortitionHandleConn};

From b2f0b39ae41546860e6f02e77b1a74139684a2c4 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Thu, 30 Nov 2023 09:17:47 -0500
Subject: [PATCH 0064/1166] CRC: add clarifying names and todo with issue 4109

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stackslib/src/chainstate/nakamoto/mod.rs | 30 +++++-------------------
 stackslib/src/net/relay.rs               |  6 +++--
 testnet/stacks-node/src/mockamoto.rs     | 14 ++++++++---
 3 files changed, 21 insertions(+), 29 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index b6e64dd34a..a7ca6e6a79 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -1423,49 +1423,31 @@ impl NakamotoChainState {
         sortdb: &SortitionDB,
         sort_handle: &SortitionHandleConn,
         chainstate: &mut StacksChainState,
-        header: &NakamotoBlockHeader,
-        canonical_block_header: &StacksHeaderInfo,
+        for_block_height: u64,
+        at_block_id: &StacksBlockId,
     ) -> Result<Point, ChainstateError> {
-        let ch_sn = SortitionDB::get_block_snapshot_consensus(sort_handle, &header.consensus_hash)?
-            .ok_or(ChainstateError::DBError(DBError::NotFoundError))
-            .map_err(|e| {
-                warn!(
-                    "No sortition for consensus hash: {:?}",
-                    &header.consensus_hash
-                );
-                e
-            })?;
         // Get the current reward cycle
         let Some(reward_cycle) = sort_handle
             .context
             .pox_constants
-            .block_height_to_reward_cycle(
-                sort_handle.context.first_block_height,
-                ch_sn.block_height,
-            )
+            .block_height_to_reward_cycle(sort_handle.context.first_block_height, for_block_height)
         else {
             // This should be unreachable, but we'll return an error just in case.
             let msg = format!(
                 "BUG: Failed to determine reward cycle of block height: {}.",
-                ch_sn.block_height
+                for_block_height
             );
             warn!("{msg}");
             return Err(ChainstateError::InvalidStacksBlock(msg));
         };
 
         chainstate
-            .get_aggregate_public_key_pox_4(
-                sortdb,
-                &canonical_block_header.index_block_hash(),
-                reward_cycle,
-            )?
+            .get_aggregate_public_key_pox_4(sortdb, at_block_id, reward_cycle)?
             .ok_or_else(|| {
                 warn!(
                     "Failed to get aggregate public key";
-                    "block_id" => %canonical_block_header.index_block_hash(),
+                    "block_id" => %at_block_id,
                     "reward_cycle" => reward_cycle,
-                    "canonical_block_height" => canonical_block_header.stacks_block_height,
-                    "canonical_block_height" => canonical_block_header.burn_header_height,
                 );
                 ChainstateError::InvalidStacksBlock("Failed to get aggregate public key".into())
             })
diff --git a/stackslib/src/net/relay.rs b/stackslib/src/net/relay.rs
index f1448aac97..f8062c6c27 100644
--- a/stackslib/src/net/relay.rs
+++ b/stackslib/src/net/relay.rs
@@ -713,6 +713,8 @@ impl Relayer {
             &block.header.block_hash()
         );
 
+        // TODO: https://github.com/stacks-network/stacks-core/issues/4109
+        // Update this to retrieve the last block in the last reward cycle rather than chain tip
         let Some(canonical_block_header) =
             NakamotoChainState::get_canonical_block_header(chainstate.db(), &sortdb)?
         else {
@@ -731,8 +733,8 @@ impl Relayer {
             &sortdb,
             &sort_handle,
             chainstate,
-            &block.header,
-            &canonical_block_header,
+            block_sn.block_height,
+            &canonical_block_header.index_block_hash(),
         ) else {
             warn!("Failed to get aggregate public key. Will not store or relay";
                 "stacks_block_hash" => %block.header.block_hash(),
diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index c551237d6f..70576b287b 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -29,6 +29,7 @@ use stacks::core::{
 };
 use stacks::net::relay::Relayer;
 use stacks::net::stackerdb::StackerDBs;
+use stacks::util_lib::db::Error as db_error;
 use stacks_common::consts::{
     FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH, STACKS_EPOCH_MAX,
 };
@@ -479,15 +480,22 @@ impl MockamotoNode {
         let block = self.mine_stacks_block()?;
         let config = self.chainstate.config();
         let sortition_handle = self.sortdb.index_handle_at_tip();
-        let canonical_block_header =
+        let block_sn = SortitionDB::get_block_snapshot_consensus(
+            sortition_handle.conn(),
+            &block.header.consensus_hash,
+        )?
+        .ok_or(ChainstateError::DBError(db_error::NotFoundError))?;
+        // TODO: https://github.com/stacks-network/stacks-core/issues/4109
+        // Update this to retrieve the last block in the last reward cycle rather than chain tip
+        let aggregate_key_block_header =
             NakamotoChainState::get_canonical_block_header(self.chainstate.db(), &self.sortdb)?
                 .unwrap();
         let aggregate_public_key = NakamotoChainState::get_aggregate_public_key(
             &self.sortdb,
             &sortition_handle,
             &mut self.chainstate,
-            &block.header,
-            &canonical_block_header,
+            block_sn.block_height,
+            &aggregate_key_block_header.index_block_hash(),
         )?;
         let chainstate_tx = self.chainstate.db_tx_begin()?;
         NakamotoChainState::accept_block(

From 0780d445540b0c4917ccb403c46b77a4d311e99f Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Tue, 14 Nov 2023 10:26:07 -0600
Subject: [PATCH 0065/1166] stashing demo changes

---
 stackslib/src/chainstate/stacks/miner.rs |  12 +-
 stackslib/src/core/mempool.rs            |   6 +-
 testnet/stacks-node/src/config.rs        |  24 +++-
 testnet/stacks-node/src/mockamoto.rs     | 163 ++++++++++++++++++++---
 testnet/stacks-node/src/neon_node.rs     |   2 +-
 5 files changed, 178 insertions(+), 29 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/miner.rs b/stackslib/src/chainstate/stacks/miner.rs
index f4c150c9e4..ca101c066d 100644
--- a/stackslib/src/chainstate/stacks/miner.rs
+++ b/stackslib/src/chainstate/stacks/miner.rs
@@ -2138,7 +2138,7 @@ impl StacksBlockBuilder {
         epoch_tx: &mut ClarityTx,
         builder: &mut B,
         mempool: &mut MemPoolDB,
-        parent_stacks_header: &StacksHeaderInfo,
+        tip_height: u64,
         coinbase_tx: Option<&StacksTransaction>,
         settings: BlockBuilderSettings,
         event_observer: Option<&dyn MemPoolEventDispatcher>,
@@ -2146,7 +2146,6 @@ impl StacksBlockBuilder {
     ) -> Result<(bool, Vec<TransactionEvent>), Error> {
         let max_miner_time_ms = settings.max_miner_time_ms;
         let mempool_settings = settings.mempool_settings.clone();
-        let tip_height = parent_stacks_header.stacks_block_height;
         let ts_start = get_epoch_time_ms();
         let stacks_epoch_id = epoch_tx.get_epoch();
         let block_limit = epoch_tx
@@ -2178,10 +2177,7 @@ impl StacksBlockBuilder {
         let mut num_txs = 0;
         let mut blocked = false;
 
-        debug!(
-            "Block transaction selection begins (child of {})",
-            &parent_stacks_header.anchored_header.block_hash()
-        );
+        debug!("Block transaction selection begins (parent height = {tip_height})");
         let result = {
             let mut intermediate_result: Result<_, Error> = Ok(0);
             while block_limit_hit != BlockLimitFunction::LIMIT_REACHED {
@@ -2354,7 +2350,7 @@ impl StacksBlockBuilder {
                     break;
                 }
             }
-            debug!("Block transaction selection finished (child of {}): {} transactions selected ({} considered)", &parent_stacks_header.anchored_header.block_hash(), num_txs, considered.len());
+            debug!("Block transaction selection finished (parent height {}): {} transactions selected ({} considered)", &tip_height, num_txs, considered.len());
             intermediate_result
         };
 
@@ -2437,7 +2433,7 @@ impl StacksBlockBuilder {
             &mut epoch_tx,
             &mut builder,
             mempool,
-            parent_stacks_header,
+            parent_stacks_header.stacks_block_height,
             Some(coinbase_tx),
             settings,
             event_observer,
diff --git a/stackslib/src/core/mempool.rs b/stackslib/src/core/mempool.rs
index 80ec178247..d534483ec9 100644
--- a/stackslib/src/core/mempool.rs
+++ b/stackslib/src/core/mempool.rs
@@ -46,6 +46,7 @@ use crate::chainstate::burn::ConsensusHash;
 use crate::chainstate::nakamoto::NakamotoBlock;
 use crate::chainstate::stacks::db::blocks::MemPoolRejection;
 use crate::chainstate::stacks::db::{ClarityTx, StacksChainState};
+use crate::chainstate::nakamoto::NakamotoChainState;
 use crate::chainstate::stacks::events::StacksTransactionReceipt;
 use crate::chainstate::stacks::index::Error as MarfError;
 use crate::chainstate::stacks::miner::TransactionEvent;
@@ -2159,8 +2160,9 @@ impl MemPoolDB {
             block_hash
         );
 
-        let height = match chainstate.get_stacks_block_height(consensus_hash, block_hash) {
-            Ok(Some(h)) => h,
+        let block_id = StacksBlockId::new(consensus_hash, block_hash);
+        let height = match NakamotoChainState::get_block_header(chainstate.db(), &block_id) {
+            Ok(Some(header)) => header.stacks_block_height,
             Ok(None) => {
                 if *consensus_hash == FIRST_BURNCHAIN_CONSENSUS_HASH {
                     0
diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index 193e50c863..c58fd3ce5f 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -28,6 +28,8 @@ use stacks::net::atlas::AtlasConfig;
 use stacks::net::connection::ConnectionOptions;
 use stacks::net::{Neighbor, NeighborKey};
 use stacks_common::types::net::PeerAddress;
+use stacks_common::address::{AddressHashMode, C32_ADDRESS_VERSION_TESTNET_SINGLESIG};
+use stacks_common::types::chainstate::StacksAddress;
 use stacks_common::util::get_epoch_time_ms;
 use stacks_common::util::hash::hex_bytes;
 use stacks_common::util::secp256k1::{Secp256k1PrivateKey, Secp256k1PublicKey};
@@ -285,11 +287,31 @@ impl ConfigFile {
             ..MinerConfigFile::default()
         };
 
+        let mock_private_key = Secp256k1PrivateKey::from_seed(&[0]);
+        let mock_public_key = Secp256k1PublicKey::from_private(&mock_private_key);
+        let mock_address = StacksAddress::from_public_keys(
+            C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
+            &AddressHashMode::SerializeP2PKH,
+            1,
+            &vec![mock_public_key],
+        )
+        .unwrap();
+
+        info!(
+            "Mockamoto starting. Initial balance set to mock_private_key = {}",
+            mock_private_key.to_hex()
+        );
+
+        let ustx_balance = vec![InitialBalanceFile {
+            address: mock_address.to_string(),
+            amount: 1_000_000_000_000,
+        }];
+
         ConfigFile {
             burnchain: Some(burnchain),
             node: Some(node),
-            ustx_balance: None,
             miner: Some(miner),
+            ustx_balance: Some(ustx_balance),
             ..ConfigFile::default()
         }
     }
diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index 70576b287b..6538b44006 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -12,21 +12,46 @@ use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::burn::{BlockSnapshot, OpsHash, SortitionHash};
 use stacks::chainstate::coordinator::comm::CoordinatorReceivers;
 use stacks::chainstate::coordinator::CoordinatorCommunication;
-use stacks::chainstate::nakamoto::{
-    NakamotoBlock, NakamotoBlockHeader, NakamotoChainState, SetupBlockResult,
-};
-use stacks::chainstate::stacks::db::{ChainStateBootData, StacksChainState};
+use stacks::chainstate::nakamoto::NakamotoBlock;
+use stacks::chainstate::nakamoto::NakamotoBlockHeader;
+use stacks::chainstate::nakamoto::NakamotoChainState;
+use stacks::chainstate::nakamoto::SetupBlockResult;
+use stacks::chainstate::stacks::db::ChainStateBootData;
+use stacks::chainstate::stacks::db::ClarityTx;
+use stacks::chainstate::stacks::db::StacksChainState;
+use stacks::chainstate::stacks::miner::BlockBuilder;
+use stacks::chainstate::stacks::miner::BlockBuilderSettings;
+use stacks::chainstate::stacks::miner::BlockLimitFunction;
 use stacks::chainstate::stacks::miner::MinerStatus;
-use stacks::chainstate::stacks::{
-    CoinbasePayload, Error as ChainstateError, StacksTransaction, StacksTransactionSigner,
-    TenureChangeCause, TenureChangePayload, ThresholdSignature, TransactionAuth,
-    TransactionPayload, TransactionVersion, MINER_BLOCK_CONSENSUS_HASH, MINER_BLOCK_HEADER_HASH,
-};
-use stacks::core::{
-    StacksEpoch, BLOCK_LIMIT_MAINNET_10, HELIUM_BLOCK_LIMIT_20, PEER_VERSION_EPOCH_1_0,
-    PEER_VERSION_EPOCH_2_0, PEER_VERSION_EPOCH_2_05, PEER_VERSION_EPOCH_2_1,
-    PEER_VERSION_EPOCH_2_2, PEER_VERSION_EPOCH_2_3, PEER_VERSION_EPOCH_2_4,
-};
+use stacks::chainstate::stacks::miner::TransactionResult;
+use stacks::chainstate::stacks::CoinbasePayload;
+use stacks::chainstate::stacks::Error as ChainstateError;
+use stacks::chainstate::stacks::SchnorrThresholdSignature;
+use stacks::chainstate::stacks::StacksBlockBuilder;
+use stacks::chainstate::stacks::StacksTransaction;
+use stacks::chainstate::stacks::StacksTransactionSigner;
+use stacks::chainstate::stacks::TenureChangeCause;
+use stacks::chainstate::stacks::TenureChangePayload;
+use stacks::chainstate::stacks::TransactionAuth;
+use stacks::chainstate::stacks::TransactionPayload;
+use stacks::chainstate::stacks::TransactionVersion;
+use stacks::chainstate::stacks::MAX_EPOCH_SIZE;
+use stacks::chainstate::stacks::MINER_BLOCK_CONSENSUS_HASH;
+use stacks::chainstate::stacks::MINER_BLOCK_HEADER_HASH;
+use stacks::clarity_vm::database::SortitionDBRef;
+use stacks::core::mempool::MemPoolWalkSettings;
+use stacks::core::MemPoolDB;
+use stacks::core::StacksEpoch;
+use stacks::core::BLOCK_LIMIT_MAINNET_10;
+use stacks::core::HELIUM_BLOCK_LIMIT_20;
+use stacks::core::PEER_VERSION_EPOCH_1_0;
+use stacks::core::PEER_VERSION_EPOCH_2_0;
+use stacks::core::PEER_VERSION_EPOCH_2_05;
+use stacks::core::PEER_VERSION_EPOCH_2_1;
+use stacks::core::PEER_VERSION_EPOCH_2_2;
+use stacks::core::PEER_VERSION_EPOCH_2_3;
+use stacks::core::PEER_VERSION_EPOCH_2_4;
+use stacks::core::TX_BLOCK_LIMIT_PROPORTION_HEURISTIC;
 use stacks::net::relay::Relayer;
 use stacks::net::stackerdb::StackerDBs;
 use stacks::util_lib::db::Error as db_error;
@@ -169,6 +194,7 @@ fn make_snapshot(
 ///
 pub struct MockamotoNode {
     sortdb: SortitionDB,
+    mempool: MemPoolDB,
     chainstate: StacksChainState,
     miner_key: StacksPrivateKey,
     relay_rcv: Receiver<RelayerDirective>,
@@ -177,6 +203,72 @@ pub struct MockamotoNode {
     config: Config,
 }
 
+struct MockamotoBlockBuilder {
+    txs: Vec<StacksTransaction>,
+    bytes_so_far: u64,
+}
+
+impl BlockBuilder for MockamotoBlockBuilder {
+    fn try_mine_tx_with_len(
+        &mut self,
+        clarity_tx: &mut ClarityTx,
+        tx: &StacksTransaction,
+        tx_len: u64,
+        limit_behavior: &BlockLimitFunction,
+        ast_rules: ASTRules,
+    ) -> TransactionResult {
+        if self.bytes_so_far + tx_len >= MAX_EPOCH_SIZE.into() {
+            return TransactionResult::skipped(tx, "BlockSizeLimit".into());
+        }
+
+        if BlockLimitFunction::NO_LIMIT_HIT != *limit_behavior {
+            return TransactionResult::skipped(tx, "LimitReached".into());
+        }
+
+        let (fee, receipt) = match StacksChainState::process_transaction(
+            clarity_tx, tx, true, ast_rules,
+        ) {
+            Ok(x) => x,
+            Err(ChainstateError::CostOverflowError(cost_before, cost_after, total_budget)) => {
+                clarity_tx.reset_cost(cost_before.clone());
+                if total_budget.proportion_largest_dimension(&cost_before)
+                    < TX_BLOCK_LIMIT_PROPORTION_HEURISTIC
+                {
+                    warn!(
+                        "Transaction {} consumed over {}% of block budget, marking as invalid; budget was {}",
+                        tx.txid(),
+                        100 - TX_BLOCK_LIMIT_PROPORTION_HEURISTIC,
+                        &total_budget
+                    );
+                    return TransactionResult::error(&tx, ChainstateError::TransactionTooBigError);
+                } else {
+                    warn!(
+                        "Transaction {} reached block cost {}; budget was {}",
+                        tx.txid(),
+                        &cost_after,
+                        &total_budget
+                    );
+                    return TransactionResult::skipped_due_to_error(
+                        &tx,
+                        ChainstateError::BlockTooBigError,
+                    );
+                }
+            }
+            Err(e) => return TransactionResult::error(&tx, e),
+        };
+
+        info!("Include tx";
+              "tx" => %tx.txid(),
+              "payload" => tx.payload.name(),
+              "origin" => %tx.origin_address());
+
+        self.txs.push(tx.clone());
+        self.bytes_so_far += tx_len;
+
+        TransactionResult::success(tx, fee, receipt)
+    }
+}
+
 impl MockamotoNode {
     pub fn new(config: &Config) -> Result<MockamotoNode, String> {
         let miner_key = config
@@ -195,7 +287,12 @@ impl MockamotoNode {
             )
             .map_err(|e| e.to_string())?;
 
-        let mut boot_data = ChainStateBootData::new(&burnchain, vec![], None);
+        let initial_balances: Vec<_> = config
+            .initial_balances
+            .iter()
+            .map(|balance| (balance.address.clone(), balance.amount))
+            .collect();
+        let mut boot_data = ChainStateBootData::new(&burnchain, initial_balances, None);
         let (chainstate, _) = StacksChainState::open_and_exec(
             config.is_mainnet(),
             config.burnchain.chain_id,
@@ -204,6 +301,7 @@ impl MockamotoNode {
             Some(config.node.get_marf_opts()),
         )
         .unwrap();
+        let mempool = PeerThread::connect_mempool_db(config);
 
         let (coord_rcv, coord_comms) = CoordinatorCommunication::instantiate();
         let miner_status = Arc::new(Mutex::new(MinerStatus::make_ready(100)));
@@ -227,6 +325,7 @@ impl MockamotoNode {
             miner_key,
             relay_rcv,
             coord_rcv,
+            mempool,
             globals,
             config: config.clone(),
         })
@@ -431,6 +530,32 @@ impl MockamotoNode {
             Ok((block_fees, _block_burns, txs_receipts)) => (block_fees, txs_receipts),
         };
 
+        let bytes_so_far = txs.iter().map(|tx| tx.tx_len()).sum();
+        let mut builder = MockamotoBlockBuilder { txs, bytes_so_far };
+        let _ = match StacksBlockBuilder::select_and_apply_transactions(
+            &mut clarity_tx,
+            &mut builder,
+            &mut self.mempool,
+            parent_chain_length,
+            None,
+            BlockBuilderSettings {
+                max_miner_time_ms: 15_000,
+                mempool_settings: MemPoolWalkSettings::default(),
+                miner_status: Arc::new(Mutex::new(MinerStatus::make_ready(10000))),
+            },
+            None,
+            ASTRules::PrecheckSize,
+        ) {
+            Ok(x) => x,
+            Err(e) => {
+                let msg = format!("Mined invalid stacks block {e:?}");
+                warn!("{msg}");
+
+                clarity_tx.rollback_block();
+                return Err(ChainstateError::InvalidStacksBlock(msg));
+            }
+        };
+
         let mut lockup_events = match NakamotoChainState::finish_block(
             &mut clarity_tx,
             matured_miner_rewards_opt.as_ref(),
@@ -444,7 +569,7 @@ impl MockamotoNode {
         };
 
         let state_index_root = clarity_tx.seal();
-        let tx_merkle_tree: MerkleTree<Sha512Trunc256Sum> = txs.iter().collect();
+        let tx_merkle_tree: MerkleTree<Sha512Trunc256Sum> = builder.txs.iter().collect();
         clarity_tx.commit_mined_block(&StacksBlockId::new(
             &MINER_BLOCK_CONSENSUS_HASH,
             &MINER_BLOCK_HEADER_HASH,
@@ -463,7 +588,7 @@ impl MockamotoNode {
                 consensus_hash: sortition_tip.consensus_hash.clone(),
                 parent_block_id: StacksBlockId::new(&chain_tip_ch, &chain_tip_bh),
             },
-            txs,
+            txs: builder.txs,
         };
 
         let miner_signature = self
@@ -510,6 +635,8 @@ impl MockamotoNode {
     }
 
     fn process_staging_block(&mut self) -> Result<bool, ChainstateError> {
+        info!("Processing a staging block!");
+
         let (mut chainstate_tx, clarity_instance) = self.chainstate.chainstate_tx_begin()?;
         let pox_constants = self.sortdb.pox_constants.clone();
         let mut sortdb_tx = self.sortdb.tx_begin_at_tip();
@@ -568,6 +695,8 @@ impl MockamotoNode {
         chainstate_tx.commit();
         clarity_tx.commit();
 
+        info!("Processed a staging block!");
+
         Ok(true)
     }
 }
diff --git a/testnet/stacks-node/src/neon_node.rs b/testnet/stacks-node/src/neon_node.rs
index ed766dab5c..c13a35af53 100644
--- a/testnet/stacks-node/src/neon_node.rs
+++ b/testnet/stacks-node/src/neon_node.rs
@@ -3573,7 +3573,7 @@ pub struct PeerThread {
 
 impl PeerThread {
     /// set up the mempool DB connection
-    fn connect_mempool_db(config: &Config) -> MemPoolDB {
+    pub fn connect_mempool_db(config: &Config) -> MemPoolDB {
         // create estimators, metric instances for RPC handler
         let cost_estimator = config
             .make_cost_estimator()

From 30157d219c56cf2c43e4de526a3a1d40c7f0a53d Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Fri, 17 Nov 2023 14:28:35 -0600
Subject: [PATCH 0066/1166] mockamoto mining working with merge

---
 stackslib/src/chainstate/burn/db/sortdb.rs |  26 ++-
 stackslib/src/chainstate/nakamoto/miner.rs |   2 +-
 testnet/stacks-node/src/mockamoto.rs       | 257 +++++++++++----------
 3 files changed, 160 insertions(+), 125 deletions(-)

diff --git a/stackslib/src/chainstate/burn/db/sortdb.rs b/stackslib/src/chainstate/burn/db/sortdb.rs
index e7443ff525..a7577011fc 100644
--- a/stackslib/src/chainstate/burn/db/sortdb.rs
+++ b/stackslib/src/chainstate/burn/db/sortdb.rs
@@ -4601,12 +4601,20 @@ impl SortitionDB {
 
         if cur_epoch.epoch_id >= StacksEpochId::Epoch30 {
             // nakamoto behavior -- look to the stacks_chain_tip table
-            let res: Result<_, db_error> = conn.query_row_and_then(
-                "SELECT consensus_hash,block_hash FROM stacks_chain_tips WHERE sortition_id = ?",
-                &[&sn.sortition_id],
-                |row| Ok((row.get_unwrap(0), row.get_unwrap(1))),
-            );
-            return res;
+            //  if the chain tip of the current sortition hasn't been set, have to iterate to parent
+            let mut cursor = sn;
+            loop {
+                let result_at_tip = conn.query_row_and_then(
+                    "SELECT consensus_hash,block_hash FROM stacks_chain_tips WHERE sortition_id = ?",
+                    &[&cursor.sortition_id],
+                    |row| Ok((row.get_unwrap(0), row.get_unwrap(1))),
+                ).optional()?;
+                if let Some(stacks_tip) = result_at_tip {
+                    return Ok(stacks_tip);
+                }
+                cursor = SortitionDB::get_block_snapshot(conn, &cursor.parent_sortition_id)?
+                    .ok_or_else(|| db_error::NotFoundError)?;
+            }
         }
 
         // epoch 2.x behavior -- look at the snapshot itself
@@ -5281,6 +5289,12 @@ impl<'a> SortitionHandleTx<'a> {
                 canonical_stacks_tip_block_hash,
                 canonical_stacks_tip_height,
             ) = res?;
+            info!(
+                "Setting initial stacks_chain_tips values";
+                "stacks_tip_height" => canonical_stacks_tip_height,
+                "stacks_tip_hash" => %canonical_stacks_tip_block_hash,
+                "stacks_tip_consensus" => %canonical_stacks_tip_consensus_hash
+            );
             sn.canonical_stacks_tip_height = canonical_stacks_tip_height;
             sn.canonical_stacks_tip_hash = canonical_stacks_tip_block_hash;
             sn.canonical_stacks_tip_consensus_hash = canonical_stacks_tip_consensus_hash;
diff --git a/stackslib/src/chainstate/nakamoto/miner.rs b/stackslib/src/chainstate/nakamoto/miner.rs
index 319efe9794..c7bedf9228 100644
--- a/stackslib/src/chainstate/nakamoto/miner.rs
+++ b/stackslib/src/chainstate/nakamoto/miner.rs
@@ -540,7 +540,7 @@ impl NakamotoBlockBuilder {
             &mut tenure_tx,
             &mut builder,
             mempool,
-            parent_stacks_header,
+            parent_stacks_header.stacks_block_height,
             new_tenure_info.as_ref().map(|info| &info.coinbase_tx),
             settings,
             event_observer,
diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index 6538b44006..29e2d3aae5 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -7,64 +7,51 @@ use std::time::Duration;
 
 use clarity::vm::ast::ASTRules;
 use lazy_static::lazy_static;
-use stacks::burnchains::Txid;
+use stacks::burnchains::{BurnchainSigner, Txid};
 use stacks::chainstate::burn::db::sortdb::SortitionDB;
+use stacks::chainstate::burn::operations::{
+    BlockstackOperationType, LeaderBlockCommitOp, LeaderKeyRegisterOp,
+};
 use stacks::chainstate::burn::{BlockSnapshot, OpsHash, SortitionHash};
 use stacks::chainstate::coordinator::comm::CoordinatorReceivers;
 use stacks::chainstate::coordinator::CoordinatorCommunication;
-use stacks::chainstate::nakamoto::NakamotoBlock;
-use stacks::chainstate::nakamoto::NakamotoBlockHeader;
-use stacks::chainstate::nakamoto::NakamotoChainState;
-use stacks::chainstate::nakamoto::SetupBlockResult;
-use stacks::chainstate::stacks::db::ChainStateBootData;
-use stacks::chainstate::stacks::db::ClarityTx;
-use stacks::chainstate::stacks::db::StacksChainState;
-use stacks::chainstate::stacks::miner::BlockBuilder;
-use stacks::chainstate::stacks::miner::BlockBuilderSettings;
-use stacks::chainstate::stacks::miner::BlockLimitFunction;
-use stacks::chainstate::stacks::miner::MinerStatus;
-use stacks::chainstate::stacks::miner::TransactionResult;
-use stacks::chainstate::stacks::CoinbasePayload;
-use stacks::chainstate::stacks::Error as ChainstateError;
-use stacks::chainstate::stacks::SchnorrThresholdSignature;
-use stacks::chainstate::stacks::StacksBlockBuilder;
-use stacks::chainstate::stacks::StacksTransaction;
-use stacks::chainstate::stacks::StacksTransactionSigner;
-use stacks::chainstate::stacks::TenureChangeCause;
-use stacks::chainstate::stacks::TenureChangePayload;
-use stacks::chainstate::stacks::TransactionAuth;
-use stacks::chainstate::stacks::TransactionPayload;
-use stacks::chainstate::stacks::TransactionVersion;
-use stacks::chainstate::stacks::MAX_EPOCH_SIZE;
-use stacks::chainstate::stacks::MINER_BLOCK_CONSENSUS_HASH;
-use stacks::chainstate::stacks::MINER_BLOCK_HEADER_HASH;
+use stacks::chainstate::nakamoto::{
+    NakamotoBlock, NakamotoBlockHeader, NakamotoChainState, SetupBlockResult,
+};
+use stacks::chainstate::stacks::address::PoxAddress;
+use stacks::chainstate::stacks::db::blocks::DummyEventDispatcher;
+use stacks::chainstate::stacks::db::{ChainStateBootData, ClarityTx, StacksChainState};
+use stacks::chainstate::stacks::miner::{
+    BlockBuilder, BlockBuilderSettings, BlockLimitFunction, MinerStatus, TransactionResult,
+};
+use stacks::chainstate::stacks::{
+    CoinbasePayload, Error as ChainstateError, StacksBlockBuilder, StacksTransaction,
+    StacksTransactionSigner, TenureChangeCause, TenureChangePayload, ThresholdSignature,
+    TransactionAuth, TransactionPayload, TransactionVersion, MAX_EPOCH_SIZE,
+    MINER_BLOCK_CONSENSUS_HASH, MINER_BLOCK_HEADER_HASH,
+};
 use stacks::clarity_vm::database::SortitionDBRef;
 use stacks::core::mempool::MemPoolWalkSettings;
-use stacks::core::MemPoolDB;
-use stacks::core::StacksEpoch;
-use stacks::core::BLOCK_LIMIT_MAINNET_10;
-use stacks::core::HELIUM_BLOCK_LIMIT_20;
-use stacks::core::PEER_VERSION_EPOCH_1_0;
-use stacks::core::PEER_VERSION_EPOCH_2_0;
-use stacks::core::PEER_VERSION_EPOCH_2_05;
-use stacks::core::PEER_VERSION_EPOCH_2_1;
-use stacks::core::PEER_VERSION_EPOCH_2_2;
-use stacks::core::PEER_VERSION_EPOCH_2_3;
-use stacks::core::PEER_VERSION_EPOCH_2_4;
-use stacks::core::TX_BLOCK_LIMIT_PROPORTION_HEURISTIC;
+use stacks::core::{
+    MemPoolDB, StacksEpoch, BLOCK_LIMIT_MAINNET_10, HELIUM_BLOCK_LIMIT_20, PEER_VERSION_EPOCH_1_0,
+    PEER_VERSION_EPOCH_2_0, PEER_VERSION_EPOCH_2_05, PEER_VERSION_EPOCH_2_1,
+    PEER_VERSION_EPOCH_2_2, PEER_VERSION_EPOCH_2_3, PEER_VERSION_EPOCH_2_4, PEER_VERSION_EPOCH_2_5,
+    PEER_VERSION_EPOCH_3_0, TX_BLOCK_LIMIT_PROPORTION_HEURISTIC,
+};
 use stacks::net::relay::Relayer;
 use stacks::net::stackerdb::StackerDBs;
-use stacks::util_lib::db::Error as db_error;
+use stacks::util_lib::db::Error as DBError;
 use stacks_common::consts::{
     FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH, STACKS_EPOCH_MAX,
 };
 use stacks_common::types::chainstate::{
-    BlockHeaderHash, BurnchainHeaderHash, ConsensusHash, PoxId, SortitionId, StacksBlockId,
-    StacksPrivateKey, TrieHash,
+    BlockHeaderHash, BurnchainHeaderHash, ConsensusHash, PoxId, SortitionId, StacksAddress,
+    StacksBlockId, StacksPrivateKey, TrieHash, VRFSeed,
 };
 use stacks_common::types::{PrivateKey, StacksEpochId};
 use stacks_common::util::hash::{Hash160, MerkleTree, Sha512Trunc256Sum};
 use stacks_common::util::secp256k1::{MessageSignature, SchnorrSignature, Secp256k1PublicKey};
+use stacks_common::util::vrf::{VRFPrivateKey, VRFProof, VRFPublicKey, VRF};
 
 use crate::neon::Counters;
 use crate::neon_node::{
@@ -74,7 +61,7 @@ use crate::syncctl::PoxSyncWatchdogComms;
 use crate::{Config, EventDispatcher};
 
 lazy_static! {
-    pub static ref STACKS_EPOCHS_MOCKAMOTO: [StacksEpoch; 8] = [
+    pub static ref STACKS_EPOCHS_MOCKAMOTO: [StacksEpoch; 9] = [
         StacksEpoch {
             epoch_id: StacksEpochId::Epoch10,
             start_height: 0,
@@ -125,11 +112,18 @@ lazy_static! {
             network_epoch: PEER_VERSION_EPOCH_2_4
         },
         StacksEpoch {
-            epoch_id: StacksEpochId::Epoch30,
+            epoch_id: StacksEpochId::Epoch25,
             start_height: 6,
+            end_height: 7,
+            block_limit: HELIUM_BLOCK_LIMIT_20.clone(),
+            network_epoch: PEER_VERSION_EPOCH_2_5
+        },
+        StacksEpoch {
+            epoch_id: StacksEpochId::Epoch30,
+            start_height: 7,
             end_height: STACKS_EPOCH_MAX,
             block_limit: HELIUM_BLOCK_LIMIT_20.clone(),
-            network_epoch: PEER_VERSION_EPOCH_2_4
+            network_epoch: PEER_VERSION_EPOCH_3_0
         },
     ];
 }
@@ -137,6 +131,7 @@ lazy_static! {
 fn make_snapshot(
     parent_snapshot: &BlockSnapshot,
     miner_pkh: &Hash160,
+    initializing: bool,
 ) -> Result<BlockSnapshot, ChainstateError> {
     let burn_height = parent_snapshot.block_height + 1;
     let mut mock_burn_hash_contents = [0u8; 32];
@@ -146,7 +141,16 @@ fn make_snapshot(
 
     let new_bhh = BurnchainHeaderHash(mock_burn_hash_contents);
     let new_ch = ConsensusHash(mock_consensus_hash_contents);
-    let new_sh = SortitionHash([1; 32]);
+    let mut new_sh = SortitionHash([3; 32]);
+    new_sh.0[0..8].copy_from_slice((burn_height + 1).to_be_bytes().as_ref());
+
+    let winning_block_txid = if initializing {
+        Txid([0; 32])
+    } else {
+        let mut winning_block_txid = [1u8; 32];
+        winning_block_txid[0..8].copy_from_slice((burn_height + 1).to_be_bytes().as_ref());
+        Txid(winning_block_txid)
+    };
 
     let new_snapshot = BlockSnapshot {
         block_height: burn_height,
@@ -158,7 +162,7 @@ fn make_snapshot(
         total_burn: 10,
         sortition: true,
         sortition_hash: new_sh,
-        winning_block_txid: Txid([0; 32]),
+        winning_block_txid,
         winning_stacks_block_hash: BlockHeaderHash([0; 32]),
         index_root: TrieHash([0; 32]),
         num_sortitions: parent_snapshot.num_sortitions + 1,
@@ -197,6 +201,7 @@ pub struct MockamotoNode {
     mempool: MemPoolDB,
     chainstate: StacksChainState,
     miner_key: StacksPrivateKey,
+    vrf_key: VRFPrivateKey,
     relay_rcv: Receiver<RelayerDirective>,
     coord_rcv: CoordinatorReceivers,
     globals: Globals,
@@ -276,6 +281,7 @@ impl MockamotoNode {
             .mining_key
             .clone()
             .ok_or("Mockamoto node must be configured with `miner.mining_key`")?;
+        let vrf_key = VRFPrivateKey::new();
 
         let burnchain = config.get_burnchain();
         let (sortdb, _burndb) = burnchain
@@ -323,6 +329,7 @@ impl MockamotoNode {
             sortdb,
             chainstate,
             miner_key,
+            vrf_key,
             relay_rcv,
             coord_rcv,
             mempool,
@@ -333,10 +340,12 @@ impl MockamotoNode {
 
     pub fn run(&mut self) {
         info!("Starting a burn cycle");
-        self.produce_burnchain_block().unwrap();
-        self.produce_burnchain_block().unwrap();
-        self.produce_burnchain_block().unwrap();
-        self.produce_burnchain_block().unwrap();
+        self.produce_burnchain_block(true).unwrap();
+        self.produce_burnchain_block(true).unwrap();
+        self.produce_burnchain_block(true).unwrap();
+        self.produce_burnchain_block(true).unwrap();
+        self.produce_burnchain_block(true).unwrap();
+        self.produce_burnchain_block(true).unwrap();
 
         let mut p2p_net = StacksNode::setup_peer_network(
             &self.config,
@@ -367,7 +376,7 @@ impl MockamotoNode {
 
         loop {
             info!("Starting a burn cycle");
-            self.produce_burnchain_block().unwrap();
+            self.produce_burnchain_block(false).unwrap();
             info!("Produced a burn block");
             sleep(Duration::from_millis(100));
             info!("Mining a staging block");
@@ -379,18 +388,76 @@ impl MockamotoNode {
         }
     }
 
-    fn produce_burnchain_block(&mut self) -> Result<(), ChainstateError> {
+    fn produce_burnchain_block(&mut self, initializing: bool) -> Result<(), ChainstateError> {
         let miner_pk = Secp256k1PublicKey::from_private(&self.miner_key);
         let miner_pk_hash = Hash160::from_node_public_key(&miner_pk);
 
         let parent_snapshot = SortitionDB::get_canonical_burn_chain_tip(&self.sortdb.conn())?;
-        let new_snapshot = make_snapshot(&parent_snapshot, &miner_pk_hash)?;
+        info!("Mocking bitcoin block"; "parent_height" => parent_snapshot.block_height);
+        let new_snapshot = make_snapshot(&parent_snapshot, &miner_pk_hash, initializing)?;
         let mut sortdb_tx = self.sortdb.tx_handle_begin(&parent_snapshot.sortition_id)?;
+        let burn_height = new_snapshot.block_height;
+
+        let mut ops = vec![];
+
+        if burn_height == 1 {
+            let mut txid = [2u8; 32];
+            txid[0..8].copy_from_slice((burn_height + 1).to_be_bytes().as_ref());
+            let key_register = LeaderKeyRegisterOp {
+                consensus_hash: new_snapshot.consensus_hash,
+                public_key: VRFPublicKey::from_private(&self.vrf_key),
+                memo: miner_pk_hash.as_bytes().to_vec(),
+                txid: Txid(txid),
+                vtxindex: 0,
+                block_height: new_snapshot.block_height,
+                burn_header_hash: new_snapshot.burn_header_hash,
+            };
+            ops.push(BlockstackOperationType::LeaderKeyRegister(key_register));
+        } else if !initializing {
+            let (parent_block_ptr, parent_vtxindex) =
+                if parent_snapshot.winning_block_txid.as_bytes() == &[0; 32] {
+                    (0, 0)
+                } else {
+                    (parent_snapshot.block_height.try_into().unwrap(), 0)
+                };
+
+            let parent_vrf_proof = NakamotoChainState::get_block_vrf_proof(
+                self.chainstate.db(),
+                &parent_snapshot.consensus_hash,
+            )?
+            .unwrap_or_else(|| VRFProof::empty());
+
+            let vrf_seed = VRFSeed::from_proof(&parent_vrf_proof);
+
+            let block_commit = LeaderBlockCommitOp {
+                block_header_hash: BlockHeaderHash([0; 32]),
+                new_seed: vrf_seed,
+                parent_block_ptr,
+                parent_vtxindex,
+                key_block_ptr: 1,
+                key_vtxindex: 0,
+                memo: vec![],
+                burn_fee: 5000,
+                input: (parent_snapshot.winning_block_txid.clone(), 3),
+                burn_parent_modulus: u8::try_from(burn_height % 5).unwrap(),
+                apparent_sender: BurnchainSigner(miner_pk_hash.to_string()),
+                commit_outs: vec![
+                    PoxAddress::Standard(StacksAddress::burn_address(false), None),
+                    PoxAddress::Standard(StacksAddress::burn_address(false), None),
+                ],
+                sunset_burn: 0,
+                txid: new_snapshot.winning_block_txid.clone(),
+                vtxindex: 0,
+                block_height: new_snapshot.block_height,
+                burn_header_hash: new_snapshot.burn_header_hash,
+            };
+            ops.push(BlockstackOperationType::LeaderBlockCommit(block_commit))
+        }
 
         sortdb_tx.append_chain_tip_snapshot(
             &parent_snapshot,
             &new_snapshot,
-            &vec![],
+            &ops,
             &vec![],
             None,
             None,
@@ -439,18 +506,20 @@ impl MockamotoNode {
             (tip_info.stacks_block_height, tip_info.burn_header_height)
         };
 
+        info!("Mining block"; "parent_chain_length" => parent_chain_length, "chain_tip_bh" => %chain_tip_bh, "chain_tip_ch" => %chain_tip_ch);
         let miner_nonce = 2 * parent_chain_length;
 
         // TODO: VRF proof cannot be None in Nakamoto rules
+        let vrf_proof = VRF::prove(&self.vrf_key, sortition_tip.sortition_hash.as_bytes());
         let coinbase_tx_payload =
-            TransactionPayload::Coinbase(CoinbasePayload([1; 32]), None, None);
+            TransactionPayload::Coinbase(CoinbasePayload([1; 32]), None, Some(vrf_proof));
         let mut coinbase_tx = StacksTransaction::new(
             TransactionVersion::Testnet,
             TransactionAuth::from_p2pkh(&self.miner_key).unwrap(),
             coinbase_tx_payload,
         );
         coinbase_tx.chain_id = chain_id;
-        coinbase_tx.set_origin_nonce(miner_nonce);
+        coinbase_tx.set_origin_nonce(miner_nonce + 1);
         let mut coinbase_tx_signer = StacksTransactionSigner::new(&coinbase_tx);
         coinbase_tx_signer.sign_origin(&self.miner_key).unwrap();
         let coinbase_tx = coinbase_tx_signer.get_tx().unwrap();
@@ -477,7 +546,7 @@ impl MockamotoNode {
             tenure_change_tx_payload,
         );
         tenure_tx.chain_id = chain_id;
-        tenure_tx.set_origin_nonce(miner_nonce + 1);
+        tenure_tx.set_origin_nonce(miner_nonce);
         let txid = tenure_tx.txid();
         let mut tenure_tx_signer = StacksTransactionSigner::new(&tenure_tx);
         tenure_tx_signer.sign_origin(&self.miner_key).unwrap();
@@ -512,7 +581,7 @@ impl MockamotoNode {
             parent_chain_length + 1,
         )?;
 
-        let txs = vec![coinbase_tx, tenure_tx];
+        let txs = vec![tenure_tx, coinbase_tx];
 
         let _ = match StacksChainState::process_block_transactions(
             &mut clarity_tx,
@@ -609,7 +678,7 @@ impl MockamotoNode {
             sortition_handle.conn(),
             &block.header.consensus_hash,
         )?
-        .ok_or(ChainstateError::DBError(db_error::NotFoundError))?;
+        .ok_or(ChainstateError::DBError(DBError::NotFoundError))?;
         // TODO: https://github.com/stacks-network/stacks-core/issues/4109
         // Update this to retrieve the last block in the last reward cycle rather than chain tip
         let aggregate_key_block_header =
@@ -636,67 +705,19 @@ impl MockamotoNode {
 
     fn process_staging_block(&mut self) -> Result<bool, ChainstateError> {
         info!("Processing a staging block!");
-
-        let (mut chainstate_tx, clarity_instance) = self.chainstate.chainstate_tx_begin()?;
-        let pox_constants = self.sortdb.pox_constants.clone();
         let mut sortdb_tx = self.sortdb.tx_begin_at_tip();
-        let Some((next_block, _)) = NakamotoChainState::next_ready_nakamoto_block(&chainstate_tx)?
-        else {
-            return Ok(false);
-        };
-
-        let parent_block_id = &next_block.header.parent_block_id;
-        let parent_chain_tip =
-            NakamotoChainState::get_block_header(&chainstate_tx, &parent_block_id)?.ok_or_else(
-                || {
-                    warn!(
-                        "Tried to process next ready block, but its parent header cannot be found";
-                        "block_hash" => %next_block.header.block_hash(),
-                        "parent_block_id" => %parent_block_id
-                    );
-                    ChainstateError::NoSuchBlockError
-                },
-            )?;
-
-        let burnchain_tip_info = SortitionDB::get_block_snapshot_consensus(
-            &sortdb_tx,
-            &next_block.header.consensus_hash,
-        )?.ok_or_else(|| {
-            warn!(
-                "Tried to process next ready block, but the snapshot that elected it cannot be found";
-                "block_hash" => %next_block.header.block_hash(),
-                "consensus_hash" => %next_block.header.consensus_hash,
-            );
-            ChainstateError::NoSuchBlockError
-        })?;
-
-        let burnchain_height = burnchain_tip_info.block_height.try_into().map_err(|_| {
-            error!("Burnchain height exceeds u32");
-            ChainstateError::InvalidStacksBlock("Burnchain height exceeds u32".into())
-        })?;
-        let block_size = 1;
-
-        let (_receipt, clarity_tx) = NakamotoChainState::append_block(
-            &mut chainstate_tx,
-            clarity_instance,
+        let result = NakamotoChainState::process_next_nakamoto_block::<DummyEventDispatcher>(
+            &mut self.chainstate,
             &mut sortdb_tx,
-            &pox_constants,
-            &parent_chain_tip,
-            &burnchain_tip_info.burn_header_hash,
-            burnchain_height,
-            burnchain_tip_info.burn_header_timestamp,
-            &next_block,
-            block_size,
-            1,
-            1,
+            None,
         )
         .unwrap();
-
-        chainstate_tx.commit();
-        clarity_tx.commit();
-
-        info!("Processed a staging block!");
-
-        Ok(true)
+        sortdb_tx.commit().unwrap();
+        if result.is_none() {
+            return Ok(false);
+        } else {
+            info!("Processed a staging block!");
+            return Ok(true);
+        }
     }
 }

From 352e73e9de035b0cf421077637b2edb833336974 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Mon, 27 Nov 2023 15:29:00 -0600
Subject: [PATCH 0067/1166] working integration with chains coordinator

---
 .../burn/operations/leader_block_commit.rs    |   4 +-
 .../chainstate/nakamoto/coordinator/mod.rs    |   8 +
 stackslib/src/chainstate/stacks/boot/mod.rs   |   2 +-
 testnet/stacks-node/src/config.rs             |  96 +++++
 testnet/stacks-node/src/main.rs               |   1 +
 testnet/stacks-node/src/mockamoto.rs          | 398 +++++++++++++-----
 6 files changed, 406 insertions(+), 103 deletions(-)

diff --git a/stackslib/src/chainstate/burn/operations/leader_block_commit.rs b/stackslib/src/chainstate/burn/operations/leader_block_commit.rs
index 081a2b8866..426447c350 100644
--- a/stackslib/src/chainstate/burn/operations/leader_block_commit.rs
+++ b/stackslib/src/chainstate/burn/operations/leader_block_commit.rs
@@ -47,6 +47,7 @@ use crate::core::{
 use crate::net::Error as net_error;
 
 // return type from parse_data below
+#[derive(Debug)]
 struct ParsedData {
     block_header_hash: BlockHeaderHash,
     new_seed: VRFSeed,
@@ -884,7 +885,8 @@ impl LeaderBlockCommitOp {
 
         let is_already_committed = tx.expects_stacks_block_in_fork(&self.block_header_hash)?;
 
-        if is_already_committed {
+        // in Epoch3.0+, block commits can include Stacks blocks already accepted in the fork.
+        if is_already_committed && epoch_id < StacksEpochId::Epoch30 {
             warn!(
                 "Invalid block commit: already committed to {}",
                 self.block_header_hash;
diff --git a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
index 0daf3ee196..462662d4d9 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
@@ -720,6 +720,14 @@ impl<
                 header.block_height, reward_cycle, &self.burnchain.working_dir,
             );
 
+            info!(
+                "Process burn block {} reward cycle {} in {}",
+                header.block_height, reward_cycle, &self.burnchain.working_dir;
+                "in_prepare_phase" => self.burnchain.is_in_prepare_phase(header.block_height),
+                "is_rc_start" => self.burnchain.is_reward_cycle_start(header.block_height),
+                "is_prior_in_prepare_phase" => self.burnchain.is_in_prepare_phase(header.block_height.saturating_sub(2)),
+            );
+
             // calculate paid rewards during this burnchain block if we announce
             //  to an events dispatcher
             let paid_rewards = if self.dispatcher.is_some() {
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index efaa578be1..2f2cc637c7 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -1081,9 +1081,9 @@ impl StacksChainState {
         let reward_cycle = burnchain
             .block_height_to_reward_cycle(current_burn_height)
             .ok_or(Error::PoxNoRewardCycle)?;
-
         self.get_reward_addresses_in_cycle(burnchain, sortdb, reward_cycle, block_id)
     }
+
     /// Get the sequence of reward addresses, as well as the PoX-specified hash mode (which gets
     /// lost in the conversion to StacksAddress)
     /// Each address will have at least (get-stacking-minimum) tokens.
diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index c58fd3ce5f..4ae095f9a2 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -264,6 +264,45 @@ impl ConfigFile {
     }
 
     pub fn mockamoto() -> ConfigFile {
+        let epochs = vec![
+            StacksEpochConfigFile {
+                epoch_name: "1.0".into(),
+                start_height: 0,
+            },
+            StacksEpochConfigFile {
+                epoch_name: "2.0".into(),
+                start_height: 0,
+            },
+            StacksEpochConfigFile {
+                epoch_name: "2.05".into(),
+                start_height: 1,
+            },
+            StacksEpochConfigFile {
+                epoch_name: "2.1".into(),
+                start_height: 2,
+            },
+            StacksEpochConfigFile {
+                epoch_name: "2.2".into(),
+                start_height: 3,
+            },
+            StacksEpochConfigFile {
+                epoch_name: "2.3".into(),
+                start_height: 4,
+            },
+            StacksEpochConfigFile {
+                epoch_name: "2.4".into(),
+                start_height: 5,
+            },
+            StacksEpochConfigFile {
+                epoch_name: "2.5".into(),
+                start_height: 6,
+            },
+            StacksEpochConfigFile {
+                epoch_name: "3.0".into(),
+                start_height: 7,
+            },
+        ];
+
         let burnchain = BurnchainConfigFile {
             mode: Some("mockamoto".into()),
             rpc_port: Some(8332),
@@ -272,6 +311,9 @@ impl ConfigFile {
             username: Some("blockstack".into()),
             password: Some("blockstacksystem".into()),
             magic_bytes: Some("M3".into()),
+            epochs: Some(epochs),
+            pox_prepare_length: Some(2),
+            pox_reward_length: Some(36),
             ..BurnchainConfigFile::default()
         };
 
@@ -464,6 +506,16 @@ impl Config {
             return;
         }
 
+        if let Some(pox_prepare_length) = self.burnchain.pox_prepare_length {
+            debug!("Override pox_prepare_length to {pox_prepare_length}");
+            burnchain.pox_constants.prepare_length = pox_prepare_length;
+        }
+
+        if let Some(pox_reward_length) = self.burnchain.pox_reward_length {
+            debug!("Override pox_reward_length to {pox_reward_length}");
+            burnchain.pox_constants.reward_cycle_length = pox_reward_length;
+        }
+
         if let Some(v1_unlock_height) = self.burnchain.pox_2_activation {
             debug!(
                 "Override v1_unlock_height from {} to {}",
@@ -474,6 +526,19 @@ impl Config {
 
         if let Some(epochs) = &self.burnchain.epochs {
             // Iterate through the epochs vector and find the item where epoch_id == StacksEpochId::Epoch22
+            if let Some(epoch) = epochs
+                .iter()
+                .find(|epoch| epoch.epoch_id == StacksEpochId::Epoch21)
+            {
+                // Override v1_unlock_height to the start_height of epoch2.1
+                debug!(
+                    "Override v2_unlock_height from {} to {}",
+                    burnchain.pox_constants.v1_unlock_height,
+                    epoch.start_height + 1
+                );
+                burnchain.pox_constants.v1_unlock_height = epoch.start_height as u32 + 1;
+            }
+
             if let Some(epoch) = epochs
                 .iter()
                 .find(|epoch| epoch.epoch_id == StacksEpochId::Epoch22)
@@ -498,6 +563,19 @@ impl Config {
                 );
                 burnchain.pox_constants.pox_3_activation_height = epoch.start_height as u32;
             }
+
+            if let Some(epoch) = epochs
+                .iter()
+                .find(|epoch| epoch.epoch_id == StacksEpochId::Epoch25)
+            {
+                // Override pox_3_activation_height to the start_height of epoch2.5
+                debug!(
+                    "Override pox_4_activation_height from {} to {}",
+                    burnchain.pox_constants.pox_4_activation_height, epoch.start_height
+                );
+                burnchain.pox_constants.pox_4_activation_height = epoch.start_height as u32;
+                burnchain.pox_constants.v3_unlock_height = epoch.start_height as u32 + 1;
+            }
         }
 
         if let Some(sunset_start) = self.burnchain.sunset_start {
@@ -605,6 +683,10 @@ impl Config {
                 Ok(StacksEpochId::Epoch23)
             } else if epoch_name == EPOCH_CONFIG_2_4_0 {
                 Ok(StacksEpochId::Epoch24)
+            } else if epoch_name == EPOCH_CONFIG_2_5_0 {
+                Ok(StacksEpochId::Epoch25)
+            } else if epoch_name == EPOCH_CONFIG_3_0_0 {
+                Ok(StacksEpochId::Epoch30)
             } else {
                 Err(format!("Unknown epoch name specified: {}", epoch_name))
             }?;
@@ -924,6 +1006,12 @@ impl Config {
                     wallet_name: burnchain
                         .wallet_name
                         .unwrap_or(default_burnchain_config.wallet_name.clone()),
+                    pox_reward_length: burnchain
+                        .pox_reward_length
+                        .or(default_burnchain_config.pox_reward_length),
+                    pox_prepare_length: burnchain
+                        .pox_prepare_length
+                        .or(default_burnchain_config.pox_prepare_length),
                 };
 
                 if let BitcoinNetworkType::Mainnet = result.get_bitcoin_network().1 {
@@ -1452,6 +1540,8 @@ pub struct BurnchainConfig {
     /// regtest nodes.
     pub epochs: Option<Vec<StacksEpoch>>,
     pub pox_2_activation: Option<u32>,
+    pub pox_reward_length: Option<u32>,
+    pub pox_prepare_length: Option<u32>,
     pub sunset_start: Option<u32>,
     pub sunset_end: Option<u32>,
     pub wallet_name: String,
@@ -1485,6 +1575,8 @@ impl BurnchainConfig {
             rbf_fee_increment: DEFAULT_RBF_FEE_RATE_INCREMENT,
             epochs: None,
             pox_2_activation: None,
+            pox_prepare_length: None,
+            pox_reward_length: None,
             sunset_start: None,
             sunset_end: None,
             wallet_name: "".to_string(),
@@ -1540,6 +1632,8 @@ pub const EPOCH_CONFIG_2_1_0: &'static str = "2.1";
 pub const EPOCH_CONFIG_2_2_0: &'static str = "2.2";
 pub const EPOCH_CONFIG_2_3_0: &'static str = "2.3";
 pub const EPOCH_CONFIG_2_4_0: &'static str = "2.4";
+pub const EPOCH_CONFIG_2_5_0: &'static str = "2.5";
+pub const EPOCH_CONFIG_3_0_0: &'static str = "3.0";
 
 #[derive(Clone, Deserialize, Default, Debug)]
 pub struct BurnchainConfigFile {
@@ -1564,6 +1658,8 @@ pub struct BurnchainConfigFile {
     pub rbf_fee_increment: Option<u64>,
     pub max_rbf: Option<u64>,
     pub epochs: Option<Vec<StacksEpochConfigFile>>,
+    pub pox_prepare_length: Option<u32>,
+    pub pox_reward_length: Option<u32>,
     pub pox_2_activation: Option<u32>,
     pub sunset_start: Option<u32>,
     pub sunset_end: Option<u32>,
diff --git a/testnet/stacks-node/src/main.rs b/testnet/stacks-node/src/main.rs
index 1de6bce591..6addce37a1 100644
--- a/testnet/stacks-node/src/main.rs
+++ b/testnet/stacks-node/src/main.rs
@@ -186,6 +186,7 @@ fn main() {
             process::exit(1);
         }
     };
+
     debug!("node configuration {:?}", &conf.node);
     debug!("burnchain configuration {:?}", &conf.burnchain);
     debug!("connection configuration {:?}", &conf.connection_options);
diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index 29e2d3aae5..3d6c8246bc 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -2,19 +2,31 @@ use std::sync::atomic::AtomicBool;
 use std::sync::mpsc::{sync_channel, Receiver};
 use std::sync::{Arc, Mutex};
 use std::thread;
-use std::thread::sleep;
+use std::thread::{sleep, JoinHandle};
 use std::time::Duration;
 
 use clarity::vm::ast::ASTRules;
+use clarity::vm::Value as ClarityValue;
 use lazy_static::lazy_static;
-use stacks::burnchains::{BurnchainSigner, Txid};
+use stacks::burnchains::bitcoin::address::{
+    BitcoinAddress, LegacyBitcoinAddress, LegacyBitcoinAddressType,
+};
+use stacks::burnchains::bitcoin::{
+    BitcoinBlock, BitcoinInputType, BitcoinNetworkType, BitcoinTransaction,
+    BitcoinTxInputStructured, BitcoinTxOutput,
+};
+use stacks::burnchains::db::{BurnchainDB, BurnchainHeaderReader};
+use stacks::burnchains::{BurnchainBlock, BurnchainBlockHeader, BurnchainSigner, Txid};
 use stacks::chainstate::burn::db::sortdb::SortitionDB;
+use stacks::chainstate::burn::operations::leader_block_commit::BURN_BLOCK_MINED_AT_MODULUS;
 use stacks::chainstate::burn::operations::{
     BlockstackOperationType, LeaderBlockCommitOp, LeaderKeyRegisterOp,
 };
-use stacks::chainstate::burn::{BlockSnapshot, OpsHash, SortitionHash};
+use stacks::chainstate::burn::BlockSnapshot;
 use stacks::chainstate::coordinator::comm::CoordinatorReceivers;
-use stacks::chainstate::coordinator::CoordinatorCommunication;
+use stacks::chainstate::coordinator::{
+    ChainsCoordinator, ChainsCoordinatorConfig, CoordinatorCommunication,
+};
 use stacks::chainstate::nakamoto::{
     NakamotoBlock, NakamotoBlockHeader, NakamotoChainState, SetupBlockResult,
 };
@@ -27,26 +39,28 @@ use stacks::chainstate::stacks::miner::{
 use stacks::chainstate::stacks::{
     CoinbasePayload, Error as ChainstateError, StacksBlockBuilder, StacksTransaction,
     StacksTransactionSigner, TenureChangeCause, TenureChangePayload, ThresholdSignature,
-    TransactionAuth, TransactionPayload, TransactionVersion, MAX_EPOCH_SIZE,
-    MINER_BLOCK_CONSENSUS_HASH, MINER_BLOCK_HEADER_HASH,
+    TransactionAuth, TransactionContractCall, TransactionPayload, TransactionVersion,
+    MAX_EPOCH_SIZE, MINER_BLOCK_CONSENSUS_HASH, MINER_BLOCK_HEADER_HASH,
 };
-use stacks::clarity_vm::database::SortitionDBRef;
 use stacks::core::mempool::MemPoolWalkSettings;
 use stacks::core::{
     MemPoolDB, StacksEpoch, BLOCK_LIMIT_MAINNET_10, HELIUM_BLOCK_LIMIT_20, PEER_VERSION_EPOCH_1_0,
     PEER_VERSION_EPOCH_2_0, PEER_VERSION_EPOCH_2_05, PEER_VERSION_EPOCH_2_1,
     PEER_VERSION_EPOCH_2_2, PEER_VERSION_EPOCH_2_3, PEER_VERSION_EPOCH_2_4, PEER_VERSION_EPOCH_2_5,
-    PEER_VERSION_EPOCH_3_0, TX_BLOCK_LIMIT_PROPORTION_HEURISTIC,
+    PEER_VERSION_EPOCH_3_0, STACKS_EPOCH_3_0_MARKER, TX_BLOCK_LIMIT_PROPORTION_HEURISTIC,
 };
+use stacks::net::atlas::{AtlasConfig, AtlasDB};
 use stacks::net::relay::Relayer;
 use stacks::net::stackerdb::StackerDBs;
 use stacks::util_lib::db::Error as DBError;
+use stacks_common::address::{AddressHashMode, C32_ADDRESS_VERSION_TESTNET_SINGLESIG};
+use stacks_common::codec::StacksMessageCodec;
 use stacks_common::consts::{
     FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH, STACKS_EPOCH_MAX,
 };
 use stacks_common::types::chainstate::{
-    BlockHeaderHash, BurnchainHeaderHash, ConsensusHash, PoxId, SortitionId, StacksAddress,
-    StacksBlockId, StacksPrivateKey, TrieHash, VRFSeed,
+    BlockHeaderHash, BurnchainHeaderHash, ConsensusHash, StacksAddress, StacksBlockId,
+    StacksPrivateKey, VRFSeed,
 };
 use stacks_common::types::{PrivateKey, StacksEpochId};
 use stacks_common::util::hash::{Hash160, MerkleTree, Sha512Trunc256Sum};
@@ -128,57 +142,94 @@ lazy_static! {
     ];
 }
 
-fn make_snapshot(
+fn make_burn_block(
     parent_snapshot: &BlockSnapshot,
     miner_pkh: &Hash160,
-    initializing: bool,
-) -> Result<BlockSnapshot, ChainstateError> {
-    let burn_height = parent_snapshot.block_height + 1;
+    ops: Vec<BlockstackOperationType>,
+) -> Result<BitcoinBlock, ChainstateError> {
+    let block_height = parent_snapshot.block_height + 1;
     let mut mock_burn_hash_contents = [0u8; 32];
-    mock_burn_hash_contents[0..8].copy_from_slice((burn_height + 1).to_be_bytes().as_ref());
-    let mut mock_consensus_hash_contents = [0u8; 20];
-    mock_consensus_hash_contents[0..8].copy_from_slice((burn_height + 1).to_be_bytes().as_ref());
-
-    let new_bhh = BurnchainHeaderHash(mock_burn_hash_contents);
-    let new_ch = ConsensusHash(mock_consensus_hash_contents);
-    let mut new_sh = SortitionHash([3; 32]);
-    new_sh.0[0..8].copy_from_slice((burn_height + 1).to_be_bytes().as_ref());
-
-    let winning_block_txid = if initializing {
-        Txid([0; 32])
-    } else {
-        let mut winning_block_txid = [1u8; 32];
-        winning_block_txid[0..8].copy_from_slice((burn_height + 1).to_be_bytes().as_ref());
-        Txid(winning_block_txid)
-    };
-
-    let new_snapshot = BlockSnapshot {
-        block_height: burn_height,
-        burn_header_timestamp: 100 * u64::from(burn_height + 1),
-        burn_header_hash: new_bhh.clone(),
-        parent_burn_header_hash: parent_snapshot.burn_header_hash.clone(),
-        consensus_hash: new_ch.clone(),
-        ops_hash: OpsHash([0; 32]),
-        total_burn: 10,
-        sortition: true,
-        sortition_hash: new_sh,
-        winning_block_txid,
-        winning_stacks_block_hash: BlockHeaderHash([0; 32]),
-        index_root: TrieHash([0; 32]),
-        num_sortitions: parent_snapshot.num_sortitions + 1,
-        stacks_block_accepted: true,
-        stacks_block_height: 1,
-        arrival_index: parent_snapshot.arrival_index + 1,
-        canonical_stacks_tip_height: 1,
-        canonical_stacks_tip_hash: BlockHeaderHash([0; 32]),
-        canonical_stacks_tip_consensus_hash: new_ch.clone(),
-        sortition_id: SortitionId::new(&new_bhh.clone(), &PoxId::new(vec![true])),
-        parent_sortition_id: parent_snapshot.sortition_id.clone(),
-        pox_valid: true,
-        accumulated_coinbase_ustx: 0,
-        miner_pk_hash: Some(miner_pkh.clone()),
-    };
-    Ok(new_snapshot)
+    mock_burn_hash_contents[0..8].copy_from_slice((block_height + 1).to_be_bytes().as_ref());
+
+    let txs = ops.into_iter().map(|op| {
+        let mut data = match &op {
+            BlockstackOperationType::LeaderKeyRegister(op) => op.serialize_to_vec(),
+            BlockstackOperationType::LeaderBlockCommit(op) => op.serialize_to_vec(),
+            _ => panic!("Attempted to mock unexpected blockstack operation."),
+        };
+
+        data.remove(0);
+
+        let (inputs, outputs) = if let BlockstackOperationType::LeaderBlockCommit(ref op) = op {
+            let burn_output = BitcoinTxOutput {
+                units: op.burn_fee,
+                address: BitcoinAddress::Legacy(LegacyBitcoinAddress {
+                    addrtype: LegacyBitcoinAddressType::PublicKeyHash,
+                    network_id: BitcoinNetworkType::Testnet,
+                    bytes: Hash160([0; 20]),
+                }),
+            };
+
+            let change_output = BitcoinTxOutput {
+                units: 1_000_000_000_000,
+                address: BitcoinAddress::Legacy(LegacyBitcoinAddress {
+                    addrtype: LegacyBitcoinAddressType::PublicKeyHash,
+                    network_id: BitcoinNetworkType::Testnet,
+                    bytes: miner_pkh.clone(),
+                }),
+            };
+
+            let tx_ref = (parent_snapshot.winning_block_txid.clone(), 3);
+
+            let input = BitcoinTxInputStructured {
+                keys: vec![],
+                num_required: 0,
+                in_type: BitcoinInputType::Standard,
+                tx_ref,
+            };
+
+            (
+                vec![input.into()],
+                vec![burn_output.clone(), burn_output, change_output],
+            )
+        } else {
+            (
+                vec![BitcoinTxInputStructured {
+                    keys: vec![],
+                    num_required: 0,
+                    in_type: BitcoinInputType::Standard,
+                    tx_ref: (Txid([0; 32]), 0),
+                }
+                .into()],
+                vec![BitcoinTxOutput {
+                    units: 1_000_000_000_000,
+                    address: BitcoinAddress::Legacy(LegacyBitcoinAddress {
+                        addrtype: LegacyBitcoinAddressType::PublicKeyHash,
+                        network_id: BitcoinNetworkType::Testnet,
+                        bytes: miner_pkh.clone(),
+                    }),
+                }],
+            )
+        };
+
+        BitcoinTransaction {
+            txid: op.txid(),
+            vtxindex: op.vtxindex(),
+            opcode: op.opcode() as u8,
+            data,
+            data_amt: 0,
+            inputs,
+            outputs,
+        }
+    });
+
+    Ok(BitcoinBlock {
+        block_height,
+        block_hash: BurnchainHeaderHash(mock_burn_hash_contents),
+        parent_block_hash: parent_snapshot.burn_header_hash.clone(),
+        txs: txs.collect(),
+        timestamp: 100 * u64::from(block_height + 1),
+    })
 }
 
 /// This struct wraps all the state required for operating a
@@ -203,7 +254,8 @@ pub struct MockamotoNode {
     miner_key: StacksPrivateKey,
     vrf_key: VRFPrivateKey,
     relay_rcv: Receiver<RelayerDirective>,
-    coord_rcv: CoordinatorReceivers,
+    coord_rcv: Option<CoordinatorReceivers>,
+    dispatcher: EventDispatcher,
     globals: Globals,
     config: Config,
 }
@@ -213,6 +265,42 @@ struct MockamotoBlockBuilder {
     bytes_so_far: u64,
 }
 
+/// This struct is used by mockamoto to pass the burnchain indexer
+///  parameter to the `ChainsCoordinator`. It errors on every
+///  invocation except `read_burnchain_headers`.
+///
+/// The `ChainsCoordinator` only uses this indexer for evaluating
+///  affirmation maps, which should never be evaluated in mockamoto.
+/// This is passed to the Burnchain DB block processor, though, which
+///  requires `read_burnchain_headers` (to generate affirmation maps)
+struct MockBurnchainIndexer(BurnchainDB);
+
+impl BurnchainHeaderReader for MockBurnchainIndexer {
+    fn read_burnchain_headers(
+        &self,
+        start_height: u64,
+        end_height: u64,
+    ) -> Result<Vec<BurnchainBlockHeader>, DBError> {
+        let mut output = vec![];
+        for i in start_height..end_height {
+            let header = BurnchainDB::get_burnchain_header(self.0.conn(), i)
+                .map_err(|e| DBError::Other(e.to_string()))?
+                .ok_or_else(|| DBError::NotFoundError)?;
+            output.push(header);
+        }
+        Ok(output)
+    }
+    fn get_burnchain_headers_height(&self) -> Result<u64, DBError> {
+        Err(DBError::NoDBError)
+    }
+    fn find_burnchain_header_height(
+        &self,
+        header_hash: &BurnchainHeaderHash,
+    ) -> Result<Option<u64>, DBError> {
+        Err(DBError::NoDBError)
+    }
+}
+
 impl BlockBuilder for MockamotoBlockBuilder {
     fn try_mine_tx_with_len(
         &mut self,
@@ -276,6 +364,7 @@ impl BlockBuilder for MockamotoBlockBuilder {
 
 impl MockamotoNode {
     pub fn new(config: &Config) -> Result<MockamotoNode, String> {
+        info!("Started");
         let miner_key = config
             .miner
             .mining_key
@@ -283,6 +372,14 @@ impl MockamotoNode {
             .ok_or("Mockamoto node must be configured with `miner.mining_key`")?;
         let vrf_key = VRFPrivateKey::new();
 
+        let stacker_pk = Secp256k1PublicKey::from_private(&miner_key);
+        let stacker_pk_hash = Hash160::from_node_public_key(&stacker_pk);
+
+        let stacker = StacksAddress {
+            version: C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
+            bytes: stacker_pk_hash,
+        };
+
         let burnchain = config.get_burnchain();
         let (sortdb, _burndb) = burnchain
             .connect_db(
@@ -293,11 +390,14 @@ impl MockamotoNode {
             )
             .map_err(|e| e.to_string())?;
 
-        let initial_balances: Vec<_> = config
+        let mut initial_balances: Vec<_> = config
             .initial_balances
             .iter()
             .map(|balance| (balance.address.clone(), balance.amount))
             .collect();
+
+        initial_balances.push((stacker.into(), 100_000_000_000_000));
+
         let mut boot_data = ChainStateBootData::new(&burnchain, initial_balances, None);
         let (chainstate, _) = StacksChainState::open_and_exec(
             config.is_mainnet(),
@@ -331,15 +431,66 @@ impl MockamotoNode {
             miner_key,
             vrf_key,
             relay_rcv,
-            coord_rcv,
+            coord_rcv: Some(coord_rcv),
+            dispatcher: EventDispatcher::new(),
             mempool,
             globals,
             config: config.clone(),
         })
     }
 
+    fn spawn_chains_coordinator(&mut self) -> JoinHandle<()> {
+        let config = self.config.clone();
+        let atlas_config = AtlasConfig::new(false);
+
+        let (chainstate, _) = self.chainstate.reopen().unwrap();
+        let coord_config = ChainsCoordinatorConfig {
+            always_use_affirmation_maps: false,
+            require_affirmed_anchor_blocks: false,
+            ..ChainsCoordinatorConfig::new()
+        };
+        let mut dispatcher = self.dispatcher.clone();
+        let burnchain = self.config.get_burnchain();
+        let burndb = burnchain.open_burnchain_db(true).unwrap();
+        let coordinator_indexer = MockBurnchainIndexer(burndb);
+        let atlas_db = AtlasDB::connect(
+            atlas_config.clone(),
+            &self.config.get_atlas_db_file_path(),
+            true,
+        )
+        .unwrap();
+        let miner_status = Arc::new(Mutex::new(MinerStatus::make_ready(100)));
+        let coordinator_receivers = self.coord_rcv.take().unwrap();
+
+        thread::Builder::new()
+            .name(format!("chains-coordinator-{}", &config.node.rpc_bind))
+            .stack_size(BLOCK_PROCESSOR_STACK_SIZE)
+            .spawn(move || {
+                debug!(
+                    "chains-coordinator thread ID is {:?}",
+                    thread::current().id()
+                );
+                ChainsCoordinator::run(
+                    coord_config,
+                    chainstate,
+                    burnchain,
+                    &mut dispatcher,
+                    coordinator_receivers,
+                    atlas_config,
+                    Some(&mut ()),
+                    Some(&mut ()),
+                    miner_status,
+                    coordinator_indexer,
+                    atlas_db,
+                );
+            })
+            .expect("FATAL: failed to start chains coordinator thread")
+    }
+
     pub fn run(&mut self) {
         info!("Starting a burn cycle");
+        let coordinator = self.spawn_chains_coordinator();
+
         self.produce_burnchain_block(true).unwrap();
         self.produce_burnchain_block(true).unwrap();
         self.produce_burnchain_block(true).unwrap();
@@ -364,8 +515,8 @@ impl MockamotoNode {
             self.config.get_burnchain().pox_constants,
             p2p_net,
         );
-        let ev_dispatcher = EventDispatcher::new();
 
+        let ev_dispatcher = self.dispatcher.clone();
         let _peer_thread = thread::Builder::new()
             .stack_size(BLOCK_PROCESSOR_STACK_SIZE)
             .name("p2p".into())
@@ -382,9 +533,10 @@ impl MockamotoNode {
             info!("Mining a staging block");
             self.mine_and_stage_block().unwrap();
             info!("Processing a staging block");
-            self.process_staging_block().unwrap();
+            // self.process_staging_block().unwrap();
+            self.globals.coord().announce_new_stacks_block();
             info!("Cycle done");
-            sleep(Duration::from_secs(5));
+            sleep(Duration::from_millis(100));
         }
     }
 
@@ -394,9 +546,7 @@ impl MockamotoNode {
 
         let parent_snapshot = SortitionDB::get_canonical_burn_chain_tip(&self.sortdb.conn())?;
         info!("Mocking bitcoin block"; "parent_height" => parent_snapshot.block_height);
-        let new_snapshot = make_snapshot(&parent_snapshot, &miner_pk_hash, initializing)?;
-        let mut sortdb_tx = self.sortdb.tx_handle_begin(&parent_snapshot.sortition_id)?;
-        let burn_height = new_snapshot.block_height;
+        let burn_height = parent_snapshot.block_height + 1;
 
         let mut ops = vec![];
 
@@ -404,16 +554,20 @@ impl MockamotoNode {
             let mut txid = [2u8; 32];
             txid[0..8].copy_from_slice((burn_height + 1).to_be_bytes().as_ref());
             let key_register = LeaderKeyRegisterOp {
-                consensus_hash: new_snapshot.consensus_hash,
+                consensus_hash: ConsensusHash([0; 20]),
                 public_key: VRFPublicKey::from_private(&self.vrf_key),
                 memo: miner_pk_hash.as_bytes().to_vec(),
                 txid: Txid(txid),
                 vtxindex: 0,
-                block_height: new_snapshot.block_height,
-                burn_header_hash: new_snapshot.burn_header_hash,
+                block_height: burn_height,
+                burn_header_hash: BurnchainHeaderHash([0; 32]),
             };
             ops.push(BlockstackOperationType::LeaderKeyRegister(key_register));
         } else if !initializing {
+            let mut txid = [1u8; 32];
+            txid[0..8].copy_from_slice((burn_height + 1).to_be_bytes().as_ref());
+            txid[8..16].copy_from_slice((0u64).to_be_bytes().as_ref());
+
             let (parent_block_ptr, parent_vtxindex) =
                 if parent_snapshot.winning_block_txid.as_bytes() == &[0; 32] {
                     (0, 0)
@@ -436,39 +590,47 @@ impl MockamotoNode {
                 parent_vtxindex,
                 key_block_ptr: 1,
                 key_vtxindex: 0,
-                memo: vec![],
+                memo: vec![STACKS_EPOCH_3_0_MARKER],
                 burn_fee: 5000,
                 input: (parent_snapshot.winning_block_txid.clone(), 3),
-                burn_parent_modulus: u8::try_from(burn_height % 5).unwrap(),
+                burn_parent_modulus: u8::try_from(
+                    parent_snapshot.block_height % BURN_BLOCK_MINED_AT_MODULUS,
+                )
+                .unwrap(),
                 apparent_sender: BurnchainSigner(miner_pk_hash.to_string()),
                 commit_outs: vec![
                     PoxAddress::Standard(StacksAddress::burn_address(false), None),
                     PoxAddress::Standard(StacksAddress::burn_address(false), None),
                 ],
                 sunset_burn: 0,
-                txid: new_snapshot.winning_block_txid.clone(),
+                txid: Txid(txid),
                 vtxindex: 0,
-                block_height: new_snapshot.block_height,
-                burn_header_hash: new_snapshot.burn_header_hash,
+                block_height: burn_height,
+                burn_header_hash: BurnchainHeaderHash([0; 32]),
             };
             ops.push(BlockstackOperationType::LeaderBlockCommit(block_commit))
         }
 
-        sortdb_tx.append_chain_tip_snapshot(
-            &parent_snapshot,
-            &new_snapshot,
-            &ops,
-            &vec![],
-            None,
-            None,
-            None,
-        )?;
+        let new_burn_block = make_burn_block(&parent_snapshot, &miner_pk_hash, ops)?;
 
-        sortdb_tx.commit()?;
+        let burnchain = self.config.get_burnchain();
+        let burndb = burnchain.open_burnchain_db(true).unwrap();
+        let indexer = MockBurnchainIndexer(burndb);
+        let mut burndb = burnchain.open_burnchain_db(true).unwrap();
 
-        let staging_db_tx = self.chainstate.db_tx_begin()?;
-        NakamotoChainState::set_burn_block_processed(&staging_db_tx, &new_snapshot.consensus_hash)?;
-        staging_db_tx.commit()?;
+        burndb.store_new_burnchain_block(
+            &burnchain,
+            &indexer,
+            &BurnchainBlock::Bitcoin(new_burn_block),
+            StacksEpochId::Epoch30,
+        );
+
+        self.globals.coord().announce_new_burn_block();
+        let mut cur_snapshot = SortitionDB::get_canonical_burn_chain_tip(&self.sortdb.conn())?;
+        while cur_snapshot.burn_header_hash == parent_snapshot.burn_header_hash {
+            thread::sleep(Duration::from_millis(100));
+            cur_snapshot = SortitionDB::get_canonical_burn_chain_tip(&self.sortdb.conn())?;
+        }
 
         Ok(())
     }
@@ -507,7 +669,7 @@ impl MockamotoNode {
         };
 
         info!("Mining block"; "parent_chain_length" => parent_chain_length, "chain_tip_bh" => %chain_tip_bh, "chain_tip_ch" => %chain_tip_ch);
-        let miner_nonce = 2 * parent_chain_length;
+        let miner_nonce = 3 * parent_chain_length;
 
         // TODO: VRF proof cannot be None in Nakamoto rules
         let vrf_proof = VRF::prove(&self.vrf_key, sortition_tip.sortition_hash.as_bytes());
@@ -547,22 +709,56 @@ impl MockamotoNode {
         );
         tenure_tx.chain_id = chain_id;
         tenure_tx.set_origin_nonce(miner_nonce);
-        let txid = tenure_tx.txid();
         let mut tenure_tx_signer = StacksTransactionSigner::new(&tenure_tx);
         tenure_tx_signer.sign_origin(&self.miner_key).unwrap();
         let tenure_tx = tenure_tx_signer.get_tx().unwrap();
 
+        let pox_address = PoxAddress::Standard(
+            StacksAddress::burn_address(false),
+            Some(AddressHashMode::SerializeP2PKH),
+        );
+
+        let stack_stx_payload = if parent_chain_length < 2 {
+            TransactionPayload::ContractCall(TransactionContractCall {
+                address: StacksAddress::burn_address(false),
+                contract_name: "pox-4".try_into().unwrap(),
+                function_name: "stack-stx".try_into().unwrap(),
+                function_args: vec![
+                    ClarityValue::UInt(99_000_000_000_000),
+                    pox_address.as_clarity_tuple().unwrap().into(),
+                    ClarityValue::UInt(u128::from(parent_burn_height)),
+                    ClarityValue::UInt(12),
+                ],
+            })
+        } else {
+            // NOTE: stack-extend doesn't currently work, because the PoX-4 lockup
+            //  special functions have not been implemented.
+            TransactionPayload::ContractCall(TransactionContractCall {
+                address: StacksAddress::burn_address(false),
+                contract_name: "pox-4".try_into().unwrap(),
+                function_name: "stack-extend".try_into().unwrap(),
+                function_args: vec![
+                    ClarityValue::UInt(5),
+                    pox_address.as_clarity_tuple().unwrap().into(),
+                ],
+            })
+        };
+        let mut stack_stx_tx = StacksTransaction::new(
+            TransactionVersion::Testnet,
+            TransactionAuth::from_p2pkh(&self.miner_key).unwrap(),
+            stack_stx_payload,
+        );
+        stack_stx_tx.chain_id = chain_id;
+        stack_stx_tx.set_origin_nonce(miner_nonce + 2);
+        let mut stack_stx_tx_signer = StacksTransactionSigner::new(&stack_stx_tx);
+        stack_stx_tx_signer.sign_origin(&self.miner_key).unwrap();
+        let stacks_stx_tx = stack_stx_tx_signer.get_tx().unwrap();
+
         let sortdb_handle = self.sortdb.index_conn();
         let SetupBlockResult {
             mut clarity_tx,
-            mut tx_receipts,
             matured_miner_rewards_opt,
-            evaluated_epoch,
-            applied_epoch_transition,
-            burn_stack_stx_ops,
-            burn_transfer_stx_ops,
-            mut auto_unlock_events,
-            burn_delegate_stx_ops,
+            ..
         } = NakamotoChainState::setup_block(
             &mut chainstate_tx,
             clarity_instance,
@@ -581,7 +777,7 @@ impl MockamotoNode {
             parent_chain_length + 1,
         )?;
 
-        let txs = vec![tenure_tx, coinbase_tx];
+        let txs = vec![tenure_tx, coinbase_tx, stacks_stx_tx];
 
         let _ = match StacksChainState::process_block_transactions(
             &mut clarity_tx,
@@ -625,7 +821,7 @@ impl MockamotoNode {
             }
         };
 
-        let mut lockup_events = match NakamotoChainState::finish_block(
+        let _lockup_events = match NakamotoChainState::finish_block(
             &mut clarity_tx,
             matured_miner_rewards_opt.as_ref(),
         ) {
@@ -643,13 +839,13 @@ impl MockamotoNode {
             &MINER_BLOCK_CONSENSUS_HASH,
             &MINER_BLOCK_HEADER_HASH,
         ));
-        chainstate_tx.commit();
+        chainstate_tx.commit().unwrap();
 
         let mut block = NakamotoBlock {
             header: NakamotoBlockHeader {
                 version: 100,
                 chain_length: parent_chain_length + 1,
-                burn_spent: 10,
+                burn_spent: sortition_tip.total_burn,
                 tx_merkle_root: tx_merkle_tree.root(),
                 state_index_root,
                 signer_signature: SchnorrSignature::default(),

From e3f3928e4d904adb7f8740b7a6b46f98e8004e29 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Tue, 28 Nov 2023 14:53:18 -0600
Subject: [PATCH 0068/1166] add test for mockamoto, cleanup implementation

---
 testnet/stacks-node/src/config.rs          |  49 ++++++-
 testnet/stacks-node/src/mockamoto.rs       | 141 +++++++++++++--------
 testnet/stacks-node/src/mockamoto/tests.rs |  60 +++++++++
 3 files changed, 194 insertions(+), 56 deletions(-)
 create mode 100644 testnet/stacks-node/src/mockamoto/tests.rs

diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index 4ae095f9a2..da34a1ea11 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -775,7 +775,39 @@ impl Config {
     }
 
     pub fn from_config_file(config_file: ConfigFile) -> Result<Config, String> {
-        let default_node_config = NodeConfig::default();
+        if config_file.burnchain.as_ref().map(|b| b.mode.clone()) == Some(Some("mockamoto".into()))
+        {
+            let default = Self::from_config_default(ConfigFile::mockamoto(), None)?;
+            Self::from_config_default(config_file, Some(default))
+        } else {
+            Self::from_config_default(config_file, None)
+        }
+    }
+
+    fn from_config_default(
+        config_file: ConfigFile,
+        default: Option<Config>,
+    ) -> Result<Config, String> {
+        let (
+            default_node_config,
+            default_burnchain_config,
+            miner_default_config,
+            default_estimator,
+        ) = match default {
+            Some(Config {
+                node,
+                burnchain,
+                miner,
+                estimation,
+                ..
+            }) => (node, burnchain, miner, estimation),
+            None => (
+                NodeConfig::default(),
+                BurnchainConfig::default(),
+                MinerConfig::default(),
+                FeeEstimationConfig::default(),
+            ),
+        };
         let mut has_require_affirmed_anchor_blocks = false;
         let (mut node, bootstrap_node, deny_nodes) = match config_file.node {
             Some(node) => {
@@ -859,14 +891,15 @@ impl Config {
                             QualifiedContractIdentifier::parse(contract_id).ok()
                         })
                         .collect(),
+                    mockamoto_time_ms: node
+                        .mockamoto_time_ms
+                        .unwrap_or(default_node_config.mockamoto_time_ms),
                 };
                 (node_config, node.bootstrap_node, node.deny_nodes)
             }
             None => (default_node_config, None, None),
         };
 
-        let default_burnchain_config = BurnchainConfig::default();
-
         let burnchain = match config_file.burnchain {
             Some(mut burnchain) => {
                 if burnchain.mode.as_deref() == Some("xenon") {
@@ -1038,7 +1071,6 @@ impl Config {
             None => default_burnchain_config,
         };
 
-        let miner_default_config = MinerConfig::default();
         let miner = match config_file.miner {
             Some(ref miner) => MinerConfig {
                 min_tx_fee: miner.min_tx_fee.unwrap_or(miner_default_config.min_tx_fee),
@@ -1316,7 +1348,7 @@ impl Config {
 
         let estimation = match config_file.fee_estimation {
             Some(f) => FeeEstimationConfig::from(f),
-            None => FeeEstimationConfig::default(),
+            None => default_estimator,
         };
 
         let mainnet = burnchain.mode == "mainnet";
@@ -1701,6 +1733,9 @@ pub struct NodeConfig {
     pub chain_liveness_poll_time_secs: u64,
     /// stacker DBs we replicate
     pub stacker_dbs: Vec<QualifiedContractIdentifier>,
+    /// if running in mockamoto mode, how long to wait between each
+    /// simulated bitcoin block
+    pub mockamoto_time_ms: u64,
 }
 
 #[derive(Clone, Debug)]
@@ -1980,6 +2015,7 @@ impl NodeConfig {
             fault_injection_hide_blocks: false,
             chain_liveness_poll_time_secs: 300,
             stacker_dbs: vec![],
+            mockamoto_time_ms: 3_000,
         }
     }
 
@@ -2190,6 +2226,9 @@ pub struct NodeConfigFile {
     pub chain_liveness_poll_time_secs: Option<u64>,
     /// Stacker DBs we replicate
     pub stacker_dbs: Option<Vec<String>>,
+    /// if running in mockamoto mode, how long to wait between each
+    /// simulated bitcoin block
+    pub mockamoto_time_ms: Option<u64>,
 }
 
 #[derive(Clone, Deserialize, Default, Debug)]
diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index 3d6c8246bc..913c02bc71 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -1,5 +1,5 @@
 use std::sync::atomic::AtomicBool;
-use std::sync::mpsc::{sync_channel, Receiver};
+use std::sync::mpsc::{sync_channel, Receiver, RecvTimeoutError};
 use std::sync::{Arc, Mutex};
 use std::thread;
 use std::thread::{sleep, JoinHandle};
@@ -16,7 +16,9 @@ use stacks::burnchains::bitcoin::{
     BitcoinTxInputStructured, BitcoinTxOutput,
 };
 use stacks::burnchains::db::{BurnchainDB, BurnchainHeaderReader};
-use stacks::burnchains::{BurnchainBlock, BurnchainBlockHeader, BurnchainSigner, Txid};
+use stacks::burnchains::{
+    BurnchainBlock, BurnchainBlockHeader, BurnchainSigner, Error as BurnchainError, Txid,
+};
 use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::burn::operations::leader_block_commit::BURN_BLOCK_MINED_AT_MODULUS;
 use stacks::chainstate::burn::operations::{
@@ -31,7 +33,6 @@ use stacks::chainstate::nakamoto::{
     NakamotoBlock, NakamotoBlockHeader, NakamotoChainState, SetupBlockResult,
 };
 use stacks::chainstate::stacks::address::PoxAddress;
-use stacks::chainstate::stacks::db::blocks::DummyEventDispatcher;
 use stacks::chainstate::stacks::db::{ChainStateBootData, ClarityTx, StacksChainState};
 use stacks::chainstate::stacks::miner::{
     BlockBuilder, BlockBuilderSettings, BlockLimitFunction, MinerStatus, TransactionResult,
@@ -74,6 +75,9 @@ use crate::neon_node::{
 use crate::syncctl::PoxSyncWatchdogComms;
 use crate::{Config, EventDispatcher};
 
+#[cfg(test)]
+mod tests;
+
 lazy_static! {
     pub static ref STACKS_EPOCHS_MOCKAMOTO: [StacksEpoch; 9] = [
         StacksEpoch {
@@ -142,11 +146,14 @@ lazy_static! {
     ];
 }
 
+/// Produce a mock bitcoin block that is descended from `parent_snapshot` and includes
+/// `ops`. This method uses `miner_pkh` to set the inputs and outputs of any supplied
+/// block commits or leader key registrations
 fn make_burn_block(
     parent_snapshot: &BlockSnapshot,
     miner_pkh: &Hash160,
     ops: Vec<BlockstackOperationType>,
-) -> Result<BitcoinBlock, ChainstateError> {
+) -> Result<BitcoinBlock, BurnchainError> {
     let block_height = parent_snapshot.block_height + 1;
     let mut mock_burn_hash_contents = [0u8; 32];
     mock_burn_hash_contents[0..8].copy_from_slice((block_height + 1).to_be_bytes().as_ref());
@@ -240,12 +247,10 @@ fn make_burn_block(
 /// operating as regtest, testnet or mainnet). This operation mode
 /// is useful for testing the stacks-only operation of Nakamoto.
 ///
-/// The current implementation of the mockamoto node simply produces
-/// Nakamoto blocks containing *only* coinbase and tenure-change
-/// transactions. As the implementation of Nakamoto progresses, and
-/// the mockamoto mode merges with changes to the chains coordinator,
-/// the mockamoto node will support mining of transactions and event
-/// emission.
+/// During operation, the mockamoto node issues `stack-stx` and
+/// `stack-extend` contract-calls to ensure that the miner is a member
+/// of the current stacking set. This ensures nakamoto blocks can be
+/// produced with tenure change txs.
 ///
 pub struct MockamotoNode {
     sortdb: SortitionDB,
@@ -253,10 +258,10 @@ pub struct MockamotoNode {
     chainstate: StacksChainState,
     miner_key: StacksPrivateKey,
     vrf_key: VRFPrivateKey,
-    relay_rcv: Receiver<RelayerDirective>,
+    relay_rcv: Option<Receiver<RelayerDirective>>,
     coord_rcv: Option<CoordinatorReceivers>,
     dispatcher: EventDispatcher,
-    globals: Globals,
+    pub globals: Globals,
     config: Config,
 }
 
@@ -295,7 +300,7 @@ impl BurnchainHeaderReader for MockBurnchainIndexer {
     }
     fn find_burnchain_header_height(
         &self,
-        header_hash: &BurnchainHeaderHash,
+        _header_hash: &BurnchainHeaderHash,
     ) -> Result<Option<u64>, DBError> {
         Err(DBError::NoDBError)
     }
@@ -364,7 +369,6 @@ impl BlockBuilder for MockamotoBlockBuilder {
 
 impl MockamotoNode {
     pub fn new(config: &Config) -> Result<MockamotoNode, String> {
-        info!("Started");
         let miner_key = config
             .miner
             .mining_key
@@ -425,14 +429,19 @@ impl MockamotoNode {
             should_keep_running,
         );
 
+        let mut event_dispatcher = EventDispatcher::new();
+        for observer in config.events_observers.iter() {
+            event_dispatcher.register_observer(observer);
+        }
+
         Ok(MockamotoNode {
             sortdb,
             chainstate,
             miner_key,
             vrf_key,
-            relay_rcv,
+            relay_rcv: Some(relay_rcv),
             coord_rcv: Some(coord_rcv),
-            dispatcher: EventDispatcher::new(),
+            dispatcher: event_dispatcher,
             mempool,
             globals,
             config: config.clone(),
@@ -488,7 +497,7 @@ impl MockamotoNode {
     }
 
     pub fn run(&mut self) {
-        info!("Starting a burn cycle");
+        info!("Starting the mockamoto node by issuing initial empty mock burn blocks");
         let coordinator = self.spawn_chains_coordinator();
 
         self.produce_burnchain_block(true).unwrap();
@@ -507,7 +516,29 @@ impl MockamotoNode {
         let stackerdbs = StackerDBs::connect(&self.config.get_stacker_db_file_path(), true)
             .expect("FATAL: failed to connect to stacker DB");
 
-        let relayer = Relayer::from_p2p(&mut p2p_net, stackerdbs);
+        let _relayer = Relayer::from_p2p(&mut p2p_net, stackerdbs);
+
+        let relayer_rcv = self.relay_rcv.take().unwrap();
+        let relayer_globals = self.globals.clone();
+        let mock_relayer_thread = thread::Builder::new()
+            .name("mock-relayer".into())
+            .spawn(move || {
+                while relayer_globals.keep_running() {
+                    match relayer_rcv.recv_timeout(Duration::from_millis(500)) {
+                        Ok(dir) => {
+                            if let RelayerDirective::Exit = dir {
+                                break;
+                            }
+                        }
+                        Err(RecvTimeoutError::Timeout) => continue,
+                        Err(e) => {
+                            warn!("Error accepting relayer directive: {e:?}");
+                            break;
+                        }
+                    }
+                }
+            })
+            .expect("FATAL: failed to start mock relayer thread");
 
         let peer_thread = PeerThread::new_all(
             self.globals.clone(),
@@ -517,7 +548,7 @@ impl MockamotoNode {
         );
 
         let ev_dispatcher = self.dispatcher.clone();
-        let _peer_thread = thread::Builder::new()
+        let peer_thread = thread::Builder::new()
             .stack_size(BLOCK_PROCESSOR_STACK_SIZE)
             .name("p2p".into())
             .spawn(move || {
@@ -525,22 +556,46 @@ impl MockamotoNode {
             })
             .expect("FATAL: failed to start p2p thread");
 
-        loop {
-            info!("Starting a burn cycle");
+        while self.globals.keep_running() {
             self.produce_burnchain_block(false).unwrap();
-            info!("Produced a burn block");
-            sleep(Duration::from_millis(100));
-            info!("Mining a staging block");
-            self.mine_and_stage_block().unwrap();
-            info!("Processing a staging block");
-            // self.process_staging_block().unwrap();
+            let expected_chain_length = self.mine_and_stage_block().unwrap();
             self.globals.coord().announce_new_stacks_block();
-            info!("Cycle done");
+            let _ = self.wait_for_stacks_block(expected_chain_length);
+            sleep(Duration::from_millis(self.config.node.mockamoto_time_ms));
+        }
+
+        self.globals.coord().stop_chains_coordinator();
+
+        if let Err(e) = coordinator.join() {
+            warn!("Error joining coordinator thread during shutdown: {e:?}");
+        }
+        if let Err(e) = mock_relayer_thread.join() {
+            warn!("Error joining coordinator thread during shutdown: {e:?}");
+        }
+        if let Err(e) = peer_thread.join() {
+            warn!("Error joining p2p thread during shutdown: {e:?}");
+        }
+    }
+
+    fn wait_for_stacks_block(&mut self, expected_length: u64) -> Result<(), ChainstateError> {
+        while self.globals.keep_running() {
+            let chain_length = match NakamotoChainState::get_canonical_block_header(
+                self.chainstate.db(),
+                &self.sortdb,
+            ) {
+                Ok(Some(chain_tip)) => chain_tip.stacks_block_height,
+                Ok(None) | Err(ChainstateError::NoSuchBlockError) => 0,
+                Err(e) => return Err(e),
+            };
+            if chain_length >= expected_length {
+                return Ok(());
+            }
             sleep(Duration::from_millis(100));
         }
+        Err(ChainstateError::NoSuchBlockError)
     }
 
-    fn produce_burnchain_block(&mut self, initializing: bool) -> Result<(), ChainstateError> {
+    fn produce_burnchain_block(&mut self, initializing: bool) -> Result<(), BurnchainError> {
         let miner_pk = Secp256k1PublicKey::from_private(&self.miner_key);
         let miner_pk_hash = Hash160::from_node_public_key(&miner_pk);
 
@@ -578,7 +633,8 @@ impl MockamotoNode {
             let parent_vrf_proof = NakamotoChainState::get_block_vrf_proof(
                 self.chainstate.db(),
                 &parent_snapshot.consensus_hash,
-            )?
+            )
+            .map_err(|_e| BurnchainError::MissingParentBlock)?
             .unwrap_or_else(|| VRFProof::empty());
 
             let vrf_seed = VRFSeed::from_proof(&parent_vrf_proof);
@@ -623,7 +679,7 @@ impl MockamotoNode {
             &indexer,
             &BurnchainBlock::Bitcoin(new_burn_block),
             StacksEpochId::Epoch30,
-        );
+        )?;
 
         self.globals.coord().announce_new_burn_block();
         let mut cur_snapshot = SortitionDB::get_canonical_burn_chain_tip(&self.sortdb.conn())?;
@@ -866,9 +922,10 @@ impl MockamotoNode {
         Ok(block)
     }
 
-    fn mine_and_stage_block(&mut self) -> Result<(), ChainstateError> {
+    fn mine_and_stage_block(&mut self) -> Result<u64, ChainstateError> {
         let block = self.mine_stacks_block()?;
         let config = self.chainstate.config();
+        let chain_length = block.header.chain_length;
         let sortition_handle = self.sortdb.index_handle_at_tip();
         let block_sn = SortitionDB::get_block_snapshot_consensus(
             sortition_handle.conn(),
@@ -896,24 +953,6 @@ impl MockamotoNode {
             &aggregate_public_key,
         )?;
         chainstate_tx.commit()?;
-        Ok(())
-    }
-
-    fn process_staging_block(&mut self) -> Result<bool, ChainstateError> {
-        info!("Processing a staging block!");
-        let mut sortdb_tx = self.sortdb.tx_begin_at_tip();
-        let result = NakamotoChainState::process_next_nakamoto_block::<DummyEventDispatcher>(
-            &mut self.chainstate,
-            &mut sortdb_tx,
-            None,
-        )
-        .unwrap();
-        sortdb_tx.commit().unwrap();
-        if result.is_none() {
-            return Ok(false);
-        } else {
-            info!("Processed a staging block!");
-            return Ok(true);
-        }
+        Ok(chain_length)
     }
 }
diff --git a/testnet/stacks-node/src/mockamoto/tests.rs b/testnet/stacks-node/src/mockamoto/tests.rs
new file mode 100644
index 0000000000..c4f72a039c
--- /dev/null
+++ b/testnet/stacks-node/src/mockamoto/tests.rs
@@ -0,0 +1,60 @@
+use std::thread;
+use std::time::Duration;
+use std::time::Instant;
+
+use crate::config::EventKeyType;
+use crate::config::EventObserverConfig;
+use crate::tests::neon_integrations::test_observer;
+use crate::Config;
+use crate::ConfigFile;
+
+use super::MockamotoNode;
+
+#[test]
+fn observe_100_blocks() {
+    let mut conf = Config::from_config_file(ConfigFile::mockamoto()).unwrap();
+    conf.node.mockamoto_time_ms = 10;
+
+    test_observer::spawn();
+    let observer_port = test_observer::EVENT_OBSERVER_PORT;
+    conf.events_observers.push(EventObserverConfig {
+        endpoint: format!("localhost:{observer_port}"),
+        events_keys: vec![EventKeyType::AnyEvent],
+    });
+
+    let mut mockamoto = MockamotoNode::new(&conf).unwrap();
+    let globals = mockamoto.globals.clone();
+    let start = Instant::now();
+
+    let node_thread = thread::Builder::new()
+        .name("mockamoto-main".into())
+        .spawn(move || mockamoto.run())
+        .expect("FATAL: failed to start mockamoto main thread");
+
+    // complete within 2 minutes or abort
+    let completed = loop {
+        if Instant::now().duration_since(start) > Duration::from_secs(120) {
+            break false;
+        }
+        let latest_block = test_observer::get_blocks().pop();
+        thread::sleep(Duration::from_secs(1));
+        let Some(ref latest_block) = latest_block else {
+            info!("No block observed yet!");
+            continue;
+        };
+        let stacks_block_height = latest_block.get("block_height").unwrap().as_u64().unwrap();
+        info!("Block height observed: {stacks_block_height}");
+        if stacks_block_height >= 100 {
+            break true;
+        }
+    };
+
+    globals.signal_stop();
+    assert!(
+        completed,
+        "Mockamoto node failed to produce and announce 100 blocks before timeout"
+    );
+    node_thread
+        .join()
+        .expect("Failed to join node thread to exit");
+}

From b447984a5887dc02bacb1b7acaba3a526508c98f Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Wed, 29 Nov 2023 10:00:21 -0600
Subject: [PATCH 0069/1166] add transfer tx to mockamoto test, address PR
 feedback

---
 stackslib/src/core/mempool.rs              |  2 +-
 testnet/stacks-node/src/config.rs          |  2 +-
 testnet/stacks-node/src/mockamoto.rs       | 42 +++++++++----
 testnet/stacks-node/src/mockamoto/tests.rs | 68 ++++++++++++++++++++++
 4 files changed, 102 insertions(+), 12 deletions(-)

diff --git a/stackslib/src/core/mempool.rs b/stackslib/src/core/mempool.rs
index d534483ec9..f67d57000b 100644
--- a/stackslib/src/core/mempool.rs
+++ b/stackslib/src/core/mempool.rs
@@ -44,9 +44,9 @@ use crate::burnchains::Txid;
 use crate::chainstate::burn::db::sortdb::SortitionDB;
 use crate::chainstate::burn::ConsensusHash;
 use crate::chainstate::nakamoto::NakamotoBlock;
+use crate::chainstate::nakamoto::NakamotoChainState;
 use crate::chainstate::stacks::db::blocks::MemPoolRejection;
 use crate::chainstate::stacks::db::{ClarityTx, StacksChainState};
-use crate::chainstate::nakamoto::NakamotoChainState;
 use crate::chainstate::stacks::events::StacksTransactionReceipt;
 use crate::chainstate::stacks::index::Error as MarfError;
 use crate::chainstate::stacks::miner::TransactionEvent;
diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index da34a1ea11..cb9695c256 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -27,9 +27,9 @@ use stacks::cost_estimates::{CostEstimator, FeeEstimator, PessimisticEstimator};
 use stacks::net::atlas::AtlasConfig;
 use stacks::net::connection::ConnectionOptions;
 use stacks::net::{Neighbor, NeighborKey};
-use stacks_common::types::net::PeerAddress;
 use stacks_common::address::{AddressHashMode, C32_ADDRESS_VERSION_TESTNET_SINGLESIG};
 use stacks_common::types::chainstate::StacksAddress;
+use stacks_common::types::net::PeerAddress;
 use stacks_common::util::get_epoch_time_ms;
 use stacks_common::util::hash::hex_bytes;
 use stacks_common::util::secp256k1::{Secp256k1PrivateKey, Secp256k1PublicKey};
diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index 913c02bc71..4f8c74601f 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -638,9 +638,10 @@ impl MockamotoNode {
             .unwrap_or_else(|| VRFProof::empty());
 
             let vrf_seed = VRFSeed::from_proof(&parent_vrf_proof);
+            let parent_block_id = parent_snapshot.get_canonical_stacks_block_id();
 
             let block_commit = LeaderBlockCommitOp {
-                block_header_hash: BlockHeaderHash([0; 32]),
+                block_header_hash: BlockHeaderHash(parent_block_id.0),
                 new_seed: vrf_seed,
                 parent_block_ptr,
                 parent_vtxindex,
@@ -692,6 +693,14 @@ impl MockamotoNode {
     }
 
     fn mine_stacks_block(&mut self) -> Result<NakamotoBlock, ChainstateError> {
+        let miner_principal = StacksAddress::from_public_keys(
+            C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
+            &AddressHashMode::SerializeP2PKH,
+            1,
+            &vec![Secp256k1PublicKey::from_private(&self.miner_key)],
+        )
+        .unwrap()
+        .into();
         let sortition_tip = SortitionDB::get_canonical_burn_chain_tip(self.sortdb.conn())?;
         let chain_id = self.chainstate.chain_id;
         let (mut chainstate_tx, clarity_instance) = self.chainstate.chainstate_tx_begin().unwrap();
@@ -715,19 +724,33 @@ impl MockamotoNode {
                 Err(e) => return Err(e),
             };
 
+        let parent_block_id = StacksBlockId::new(&chain_tip_ch, &chain_tip_bh);
+
         let (parent_chain_length, parent_burn_height) = if is_genesis {
             (0, 0)
         } else {
-            let tip_block_id = StacksBlockId::new(&chain_tip_ch, &chain_tip_bh);
-            let tip_info = NakamotoChainState::get_block_header(&chainstate_tx, &tip_block_id)?
+            let tip_info = NakamotoChainState::get_block_header(&chainstate_tx, &parent_block_id)?
                 .ok_or(ChainstateError::NoSuchBlockError)?;
             (tip_info.stacks_block_height, tip_info.burn_header_height)
         };
 
-        info!("Mining block"; "parent_chain_length" => parent_chain_length, "chain_tip_bh" => %chain_tip_bh, "chain_tip_ch" => %chain_tip_ch);
-        let miner_nonce = 3 * parent_chain_length;
+        let miner_nonce = if is_genesis {
+            0
+        } else {
+            let sortdb_conn = self.sortdb.index_conn();
+            let mut clarity_conn = clarity_instance.read_only_connection_checked(
+                &parent_block_id,
+                &chainstate_tx,
+                &sortdb_conn,
+            )?;
+            StacksChainState::get_nonce(&mut clarity_conn, &miner_principal)
+        };
+
+        info!(
+            "Mining block"; "parent_chain_length" => parent_chain_length, "chain_tip_bh" => %chain_tip_bh,
+            "chain_tip_ch" => %chain_tip_ch, "miner_account" => %miner_principal, "miner_nonce" => %miner_nonce,
+        );
 
-        // TODO: VRF proof cannot be None in Nakamoto rules
         let vrf_proof = VRF::prove(&self.vrf_key, sortition_tip.sortition_hash.as_bytes());
         let coinbase_tx_payload =
             TransactionPayload::Coinbase(CoinbasePayload([1; 32]), None, Some(vrf_proof));
@@ -742,7 +765,6 @@ impl MockamotoNode {
         coinbase_tx_signer.sign_origin(&self.miner_key).unwrap();
         let coinbase_tx = coinbase_tx_signer.get_tx().unwrap();
 
-        let parent_block_id = StacksBlockId::new(&chain_tip_ch, &chain_tip_bh);
         // Add a tenure change transaction to the block:
         //  as of now every mockamoto block is a tenure-change.
         // If mockamoto mode changes to support non-tenure-changing blocks, this will have
@@ -944,15 +966,15 @@ impl MockamotoNode {
             block_sn.block_height,
             &aggregate_key_block_header.index_block_hash(),
         )?;
-        let chainstate_tx = self.chainstate.db_tx_begin()?;
+        let staging_tx = self.chainstate.staging_db_tx_begin()?;
         NakamotoChainState::accept_block(
             &config,
             block,
             &sortition_handle,
-            &chainstate_tx,
+            &staging_tx,
             &aggregate_public_key,
         )?;
-        chainstate_tx.commit()?;
+        staging_tx.commit()?;
         Ok(chain_length)
     }
 }
diff --git a/testnet/stacks-node/src/mockamoto/tests.rs b/testnet/stacks-node/src/mockamoto/tests.rs
index c4f72a039c..989c3184f9 100644
--- a/testnet/stacks-node/src/mockamoto/tests.rs
+++ b/testnet/stacks-node/src/mockamoto/tests.rs
@@ -2,9 +2,20 @@ use std::thread;
 use std::time::Duration;
 use std::time::Instant;
 
+use clarity::vm::costs::ExecutionCost;
+use stacks::chainstate::nakamoto::NakamotoChainState;
+use stacks::chainstate::stacks::db::StacksChainState;
+use stacks_common::types::chainstate::StacksAddress;
+use stacks_common::types::chainstate::StacksPrivateKey;
+use stacks_common::types::StacksEpochId;
+use stacks_common::util::hash::to_hex;
+
 use crate::config::EventKeyType;
 use crate::config::EventObserverConfig;
+use crate::neon_node::PeerThread;
+use crate::tests::make_stacks_transfer;
 use crate::tests::neon_integrations::test_observer;
+use crate::tests::to_addr;
 use crate::Config;
 use crate::ConfigFile;
 
@@ -15,6 +26,11 @@ fn observe_100_blocks() {
     let mut conf = Config::from_config_file(ConfigFile::mockamoto()).unwrap();
     conf.node.mockamoto_time_ms = 10;
 
+    let submitter_sk = StacksPrivateKey::from_seed(&[1]);
+    let submitter_addr = to_addr(&submitter_sk);
+    conf.add_initial_balance(submitter_addr.to_string(), 1_000);
+    let recipient_addr = StacksAddress::burn_address(false).into();
+
     test_observer::spawn();
     let observer_port = test_observer::EVENT_OBSERVER_PORT;
     conf.events_observers.push(EventObserverConfig {
@@ -24,6 +40,18 @@ fn observe_100_blocks() {
 
     let mut mockamoto = MockamotoNode::new(&conf).unwrap();
     let globals = mockamoto.globals.clone();
+
+    let mut mempool = PeerThread::connect_mempool_db(&conf);
+    let (mut chainstate, _) = StacksChainState::open(
+        conf.is_mainnet(),
+        conf.burnchain.chain_id,
+        &conf.get_chainstate_path_str(),
+        None,
+    )
+    .unwrap();
+    let burnchain = conf.get_burnchain();
+    let sortdb = burnchain.open_sortition_db(true).unwrap();
+
     let start = Instant::now();
 
     let node_thread = thread::Builder::new()
@@ -31,6 +59,10 @@ fn observe_100_blocks() {
         .spawn(move || mockamoto.run())
         .expect("FATAL: failed to start mockamoto main thread");
 
+    // make a transfer tx to test that the mockamoto miner picks up txs from the mempool
+    let transfer_tx = make_stacks_transfer(&submitter_sk, 0, 10, &recipient_addr, 100);
+    let transfer_tx_hex = format!("0x{}", to_hex(&transfer_tx));
+
     // complete within 2 minutes or abort
     let completed = loop {
         if Instant::now().duration_since(start) > Duration::from_secs(120) {
@@ -44,12 +76,48 @@ fn observe_100_blocks() {
         };
         let stacks_block_height = latest_block.get("block_height").unwrap().as_u64().unwrap();
         info!("Block height observed: {stacks_block_height}");
+
+        if stacks_block_height == 1 {
+            let tip = NakamotoChainState::get_canonical_block_header(chainstate.db(), &sortdb)
+                .unwrap()
+                .unwrap();
+            mempool
+                .submit_raw(
+                    &mut chainstate,
+                    &sortdb,
+                    &tip.consensus_hash,
+                    &tip.anchored_header.block_hash(),
+                    transfer_tx.clone(),
+                    &ExecutionCost::max_value(),
+                    &StacksEpochId::Epoch30,
+                )
+                .unwrap();
+        }
+
         if stacks_block_height >= 100 {
             break true;
         }
     };
 
     globals.signal_stop();
+
+    let transfer_tx_included = test_observer::get_blocks()
+        .into_iter()
+        .find(|block_json| {
+            block_json["transactions"]
+                .as_array()
+                .unwrap()
+                .iter()
+                .find(|tx_json| tx_json["raw_tx"].as_str() == Some(&transfer_tx_hex))
+                .is_some()
+        })
+        .is_some();
+
+    assert!(
+        transfer_tx_included,
+        "Mockamoto node failed to include the transfer tx"
+    );
+
     assert!(
         completed,
         "Mockamoto node failed to produce and announce 100 blocks before timeout"

From be3c28b0f3382429bad21408df6de0756e6b5800 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Thu, 30 Nov 2023 14:48:31 -0600
Subject: [PATCH 0070/1166] add stacker-self-signer to mockamoto, add boot
 receipts, add pox_v3_unlock to /new_block events

---
 testnet/stacks-node/src/config.rs           | 50 ++++----------
 testnet/stacks-node/src/event_dispatcher.rs |  1 +
 testnet/stacks-node/src/mockamoto.rs        | 35 +++++-----
 testnet/stacks-node/src/mockamoto/signer.rs | 76 +++++++++++++++++++++
 4 files changed, 108 insertions(+), 54 deletions(-)
 create mode 100644 testnet/stacks-node/src/mockamoto/signer.rs

diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index cb9695c256..c28ebaa4f1 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -777,37 +777,23 @@ impl Config {
     pub fn from_config_file(config_file: ConfigFile) -> Result<Config, String> {
         if config_file.burnchain.as_ref().map(|b| b.mode.clone()) == Some(Some("mockamoto".into()))
         {
-            let default = Self::from_config_default(ConfigFile::mockamoto(), None)?;
-            Self::from_config_default(config_file, Some(default))
+            // in the case of mockamoto, use `ConfigFile::mockamoto()` as the default for
+            //  processing a user-supplied config
+            let default = Self::from_config_default(ConfigFile::mockamoto(), Config::default())?;
+            Self::from_config_default(config_file, default)
         } else {
-            Self::from_config_default(config_file, None)
+            Self::from_config_default(config_file, Config::default())
         }
     }
 
-    fn from_config_default(
-        config_file: ConfigFile,
-        default: Option<Config>,
-    ) -> Result<Config, String> {
-        let (
-            default_node_config,
-            default_burnchain_config,
-            miner_default_config,
-            default_estimator,
-        ) = match default {
-            Some(Config {
-                node,
-                burnchain,
-                miner,
-                estimation,
-                ..
-            }) => (node, burnchain, miner, estimation),
-            None => (
-                NodeConfig::default(),
-                BurnchainConfig::default(),
-                MinerConfig::default(),
-                FeeEstimationConfig::default(),
-            ),
-        };
+    fn from_config_default(config_file: ConfigFile, default: Config) -> Result<Config, String> {
+        let Config {
+            node: default_node_config,
+            burnchain: default_burnchain_config,
+            miner: miner_default_config,
+            estimation: default_estimator,
+            ..
+        } = default;
         let mut has_require_affirmed_anchor_blocks = false;
         let (mut node, bootstrap_node, deny_nodes) = match config_file.node {
             Some(node) => {
@@ -1517,14 +1503,8 @@ impl Config {
 
 impl std::default::Default for Config {
     fn default() -> Config {
-        // Testnet's name
-        let node = NodeConfig {
-            ..NodeConfig::default()
-        };
-
-        let burnchain = BurnchainConfig {
-            ..BurnchainConfig::default()
-        };
+        let node = NodeConfig::default();
+        let burnchain = BurnchainConfig::default();
 
         let connection_options = HELIUM_DEFAULT_CONNECTION_OPTIONS.clone();
         let estimation = FeeEstimationConfig::default();
diff --git a/testnet/stacks-node/src/event_dispatcher.rs b/testnet/stacks-node/src/event_dispatcher.rs
index 371a5da842..a6621bbc9d 100644
--- a/testnet/stacks-node/src/event_dispatcher.rs
+++ b/testnet/stacks-node/src/event_dispatcher.rs
@@ -418,6 +418,7 @@ impl EventObserver {
             "confirmed_microblocks_cost": mblock_confirmed_consumed,
             "pox_v1_unlock_height": pox_constants.v1_unlock_height,
             "pox_v2_unlock_height": pox_constants.v2_unlock_height,
+            "pox_v3_unlock_height": pox_constants.v3_unlock_height,
         })
     }
 }
diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index 4f8c74601f..a371a77b0b 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -75,6 +75,9 @@ use crate::neon_node::{
 use crate::syncctl::PoxSyncWatchdogComms;
 use crate::{Config, EventDispatcher};
 
+use self::signer::SelfSigner;
+
+pub mod signer;
 #[cfg(test)]
 mod tests;
 
@@ -256,6 +259,7 @@ pub struct MockamotoNode {
     sortdb: SortitionDB,
     mempool: MemPoolDB,
     chainstate: StacksChainState,
+    self_signer: SelfSigner,
     miner_key: StacksPrivateKey,
     vrf_key: VRFPrivateKey,
     relay_rcv: Option<Receiver<RelayerDirective>>,
@@ -403,7 +407,7 @@ impl MockamotoNode {
         initial_balances.push((stacker.into(), 100_000_000_000_000));
 
         let mut boot_data = ChainStateBootData::new(&burnchain, initial_balances, None);
-        let (chainstate, _) = StacksChainState::open_and_exec(
+        let (chainstate, boot_receipts) = StacksChainState::open_and_exec(
             config.is_mainnet(),
             config.burnchain.chain_id,
             &config.get_chainstate_path_str(),
@@ -434,8 +438,16 @@ impl MockamotoNode {
             event_dispatcher.register_observer(observer);
         }
 
+        crate::run_loop::announce_boot_receipts(
+            &mut event_dispatcher,
+            &chainstate,
+            &burnchain.pox_constants,
+            &boot_receipts,
+        );
+
         Ok(MockamotoNode {
             sortdb,
+            self_signer: SelfSigner::single_signer(),
             chainstate,
             miner_key,
             vrf_key,
@@ -945,27 +957,12 @@ impl MockamotoNode {
     }
 
     fn mine_and_stage_block(&mut self) -> Result<u64, ChainstateError> {
-        let block = self.mine_stacks_block()?;
+        let mut block = self.mine_stacks_block()?;
         let config = self.chainstate.config();
         let chain_length = block.header.chain_length;
         let sortition_handle = self.sortdb.index_handle_at_tip();
-        let block_sn = SortitionDB::get_block_snapshot_consensus(
-            sortition_handle.conn(),
-            &block.header.consensus_hash,
-        )?
-        .ok_or(ChainstateError::DBError(DBError::NotFoundError))?;
-        // TODO: https://github.com/stacks-network/stacks-core/issues/4109
-        // Update this to retrieve the last block in the last reward cycle rather than chain tip
-        let aggregate_key_block_header =
-            NakamotoChainState::get_canonical_block_header(self.chainstate.db(), &self.sortdb)?
-                .unwrap();
-        let aggregate_public_key = NakamotoChainState::get_aggregate_public_key(
-            &self.sortdb,
-            &sortition_handle,
-            &mut self.chainstate,
-            block_sn.block_height,
-            &aggregate_key_block_header.index_block_hash(),
-        )?;
+        let aggregate_public_key = self.self_signer.aggregate_public_key;
+        self.self_signer.sign_nakamoto_block(&mut block);
         let staging_tx = self.chainstate.staging_db_tx_begin()?;
         NakamotoChainState::accept_block(
             &config,
diff --git a/testnet/stacks-node/src/mockamoto/signer.rs b/testnet/stacks-node/src/mockamoto/signer.rs
new file mode 100644
index 0000000000..c95651bf39
--- /dev/null
+++ b/testnet/stacks-node/src/mockamoto/signer.rs
@@ -0,0 +1,76 @@
+use stacks::chainstate::nakamoto::NakamotoBlock;
+use stacks_common::util::secp256k1::SchnorrSignature;
+use wsts::curve::point::Point;
+use wsts::traits::Aggregator;
+
+/// This struct encapsulates a FROST signer that is capable of
+///  signing its own aggregate public key.
+/// This is used in `mockamoto` and `nakamoto-neon` operation
+///  by the miner in order to self-sign blocks.
+#[derive(Debug, Clone)]
+pub struct SelfSigner {
+    /// The parties that will sign the blocks
+    pub signer_parties: Vec<wsts::v2::Party>,
+    /// The commitments to the polynomials for the aggregate public key
+    pub poly_commitments: Vec<wsts::common::PolyCommitment>,
+    /// The aggregate public key
+    pub aggregate_public_key: Point,
+    /// The total number of key ids distributed among signer_parties
+    pub num_keys: u32,
+    /// The number of vote shares required to sign a block
+    pub threshold: u32,
+}
+
+impl SelfSigner {
+    pub fn single_signer() -> Self {
+        let mut rng = rand_core::OsRng::default();
+
+        // Create the parties
+        let mut signer_parties = [wsts::v2::Party::new(0, &[0], 1, 1, 1, &mut rng)];
+
+        // Generate an aggregate public key
+        let poly_commitments = match wsts::v2::test_helpers::dkg(&mut signer_parties, &mut rng) {
+            Ok(poly_commitments) => poly_commitments,
+            Err(secret_errors) => {
+                panic!("Got secret errors from DKG: {:?}", secret_errors);
+            }
+        };
+
+        assert_eq!(poly_commitments.len(), 1);
+        assert_eq!(signer_parties.len(), 1);
+
+        let aggregate_public_key = poly_commitments.iter().fold(
+            Point::default(),
+            |s, poly_commitment: &wsts::common::PolyCommitment| s + poly_commitment.poly[0],
+        );
+
+        Self {
+            signer_parties: signer_parties.to_vec(),
+            aggregate_public_key,
+            poly_commitments,
+            num_keys: 1,
+            threshold: 1,
+        }
+    }
+
+    pub fn sign_nakamoto_block(&mut self, block: &mut NakamotoBlock) {
+        let mut rng = rand_core::OsRng;
+        let msg = block
+            .header
+            .signer_signature_hash()
+            .expect("Failed to determine the block header signature hash for signers.")
+            .0;
+        let (nonces, sig_shares, key_ids) =
+            wsts::v2::test_helpers::sign(msg.as_slice(), &mut self.signer_parties, &mut rng);
+
+        let mut sig_aggregator = wsts::v2::Aggregator::new(self.num_keys, self.threshold);
+        sig_aggregator
+            .init(self.poly_commitments.clone())
+            .expect("aggregator init failed");
+        let signature = sig_aggregator
+            .sign(msg.as_slice(), &nonces, &sig_shares, &key_ids)
+            .expect("aggregator sig failed");
+        let schnorr_signature = SchnorrSignature::from(&signature);
+        block.header.signer_signature = schnorr_signature;
+    }
+}

From 32aa967d41dd9262ff4221ffe164b68430289f94 Mon Sep 17 00:00:00 2001
From: ASuciuX <151519329+ASuciuX@users.noreply.github.com>
Date: Thu, 30 Nov 2023 23:15:13 +0200
Subject: [PATCH 0071/1166] Delete Dockerfile.mutation-testing as it is also
 run locally with cargo

---
 .../Dockerfile.mutation-testing               | 29 -------------------
 1 file changed, 29 deletions(-)
 delete mode 100644 .github/actions/bitcoin-int-tests/Dockerfile.mutation-testing

diff --git a/.github/actions/bitcoin-int-tests/Dockerfile.mutation-testing b/.github/actions/bitcoin-int-tests/Dockerfile.mutation-testing
deleted file mode 100644
index 2d26551a08..0000000000
--- a/.github/actions/bitcoin-int-tests/Dockerfile.mutation-testing
+++ /dev/null
@@ -1,29 +0,0 @@
-FROM rust:bullseye
-
-# Set the working directory in the container
-WORKDIR /src
-
-# Copy all the files into the container
-COPY . .
-
-# Update rustup and build the project
-RUN rustup update
-
-# Install cargo-mutants
-RUN cargo install cargo-mutants
-
-# Make a directory for mutants
-RUN mkdir -p mutants
-
-# Run mutants for different packages
-RUN cargo mutants --package clarity --output mutants/clarity
-RUN cargo mutants --package libsigner --output mutants/libsigner 
-# RUN cargo mutants --package libstackerdb --output mutants/libstackerdb 
-# RUN cargo mutants --package pox-locking --output mutants/pox-locking 
-# RUN cargo mutants --package stacks-common --output mutants/stacks-common
-# RUN cargo mutants --package stx-genesis --output mutants/stx-genesis
-
-# Comment out the commands for 'stacks-node' and 'stackslib' following the mutants.sh script
-# RUN cargo mutants --package stacks-signer --output mutants/stacks-signer
-# RUN cargo mutants --package stacks-node --output mutants/stacks-node
-# RUN cargo mutants --package stackslib --output mutants/stackslib

From 6bfb9bc54a9e0d70486b509d89a860c3dad33509 Mon Sep 17 00:00:00 2001
From: wileyj <2847772+wileyj@users.noreply.github.com>
Date: Fri, 3 Nov 2023 13:18:43 -0700
Subject: [PATCH 0072/1166] updating invalid FQDNs to stacks.org

---
 CODE_OF_CONDUCT.md                         | 2 +-
 contrib/helm/stacks-blockchain/README.md   | 4 ++--
 contrib/helm/stacks-blockchain/values.yaml | 6 +++---
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md
index 81c865506e..6d6e5053dd 100644
--- a/CODE_OF_CONDUCT.md
+++ b/CODE_OF_CONDUCT.md
@@ -39,7 +39,7 @@ This Code of Conduct applies within all community spaces, and also applies when
 
 ## Enforcement
 
-Instances of abusive, harassing, or otherwise unacceptable behavior may be reported to the community leaders responsible for enforcement at opensource@blockstack.org. All complaints will be reviewed and investigated promptly and fairly.
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported to the community leaders responsible for enforcement at opensource@stacks.org. All complaints will be reviewed and investigated promptly and fairly.
 
 All community leaders are obligated to respect the privacy and security of the reporter of any incident.
 
diff --git a/contrib/helm/stacks-blockchain/README.md b/contrib/helm/stacks-blockchain/README.md
index c37f598846..6cbd1fd957 100644
--- a/contrib/helm/stacks-blockchain/README.md
+++ b/contrib/helm/stacks-blockchain/README.md
@@ -27,7 +27,7 @@ $ helm repo add blockstack https://charts.blockstack.xyz
 $ helm install my-release blockstack/stacks-blockchain
 ```
 
-To install the chart with the release name `my-release` and run the node as a **miner** using your private key [generated from the instructions on this page](https://docs.blockstack.org/mining):
+To install the chart with the release name `my-release` and run the node as a **miner** using your private key [generated from the instructions on this page](https://docs.stacks.co/docs/nodes-and-miners/miner-mainnet):
 
 ```bash
 $ helm repo add blockstack https://charts.blockstack.xyz
@@ -93,7 +93,7 @@ The following tables lists the configurable parameters of the stacks-blockchain
 | config.node.miner | Set this to `true` if deploying a miner node.<br>Set this to `false` if deploying a follower node. | false |
 | config.burnchain.chain |  | bitcoin |
 | config.burnchain.mode |  | krypton |
-| config.burnchain.peer_host |  | bitcoind.blockstack.org |
+| config.burnchain.peer_host |  | bitcoin.mainnet.stacks.org |
 | config.burnchain.rpc_port |  | 18443 |
 | config.burnchain.peer_port |  | 18444 |
 | config.ustx_balance |  | See values.yaml |
diff --git a/contrib/helm/stacks-blockchain/values.yaml b/contrib/helm/stacks-blockchain/values.yaml
index 24d39c4ef2..2f46aadb12 100644
--- a/contrib/helm/stacks-blockchain/values.yaml
+++ b/contrib/helm/stacks-blockchain/values.yaml
@@ -211,7 +211,7 @@ node:
 ## OR you can uncomment the config.raw field, which will take precedence over the aforementationed config fields
 ##
 ## For more info, please reference our docs and example config files:
-## https://docs.blockstack.org/stacks-blockchain/running-testnet-node
+## https://docs.stacks.co/docs/nodes-and-miners/run-a-node
 ## https://github.com/blockstack/stacks-blockchain/tree/master/testnet/stacks-node/conf
 ##
 config:
@@ -225,7 +225,7 @@ config:
   burnchain:
     chain: bitcoin
     mode: krypton
-    peer_host: bitcoind.blockstack.org
+    peer_host: bitcoin.testnet.stacks.org
     # process_exit_at_block_height: 5340
     # commit_anchor_block_within: 10000
     rpc_port: 18443
@@ -255,7 +255,7 @@ config:
   #   [burnchain]
   #   chain = "bitcoin"
   #   mode = "krypton"
-  #   peer_host = "bitcoind.blockstack.org"
+  #   peer_host = "bitcoin.mainnet.stacks.org"
   #   #process_exit_at_block_height = 5340
   #   #commit_anchor_block_within = 10000
   #   rpc_port = 18443

From 92b4e23f99b7f3f36e454db8ca134368b31277bd Mon Sep 17 00:00:00 2001
From: ASuciuX <asuciu@hiro.so>
Date: Fri, 1 Dec 2023 16:06:07 +0200
Subject: [PATCH 0073/1166] feat: modular mutations on shell

- runs for modified files & created files
- has to be run before committing the changes
```
cd mutation-testing/scripts
sh git-diff.sh
```
---
 .github/workflows/mutants.yml                 |  185 +
 libsigner/Cargo.toml                          |    2 +-
 libsigner/src/{libsigner.rs => lib.rs}        |    0
 mutants-testing-general.sh                    |   34 -
 mutants/clarity/mutants.out/caught.txt        |   54 -
 mutants/clarity/mutants.out/lock.json         |    6 -
 mutants/clarity/mutants.out/missed.txt        |   24 -
 mutants/clarity/mutants.out/mutants.json      | 1253 -----
 mutants/clarity/mutants.out/outcomes.json     | 4930 -----------------
 mutants/clarity/mutants.out/unviable.txt      |   61 -
 .../packages-output/clarity/caught.txt        |  487 ++
 .../packages-output/clarity/missed.txt        |  634 +++
 .../packages-output/clarity}/timeout.txt      |    0
 .../packages-output/clarity/unviable.txt      | 1791 ++++++
 .../packages-output/pox-locking/caught.txt    |    0
 .../packages-output/pox-locking/missed.txt    |   28 +
 .../packages-output/pox-locking/timeout.txt   |    0
 .../packages-output/pox-locking/unviable.txt  |   22 +
 .../packages-output/stx-genesis/caught.txt    |    1 +
 .../packages-output/stx-genesis/missed.txt    |    1 +
 .../packages-output/stx-genesis/timeout.txt   |    0
 .../packages-output/stx-genesis/unviable.txt  |   11 +
 mutation-testing/scripts/README.md            |   38 +
 .../scripts/append-match-package.sh           |   68 +
 mutation-testing/scripts/create-stable.sh     |   55 +
 mutation-testing/scripts/git-diff.sh          |   35 +
 .../scripts/modular-mutants-run.sh            |   41 +
 mutation-testing/testing.md                   |   65 +
 stacks-common/Cargo.toml                      |    2 +-
 stacks-common/src/{libcommon.rs => lib.rs}    |    0
 30 files changed, 3464 insertions(+), 6364 deletions(-)
 create mode 100644 .github/workflows/mutants.yml
 rename libsigner/src/{libsigner.rs => lib.rs} (100%)
 delete mode 100644 mutants-testing-general.sh
 delete mode 100644 mutants/clarity/mutants.out/caught.txt
 delete mode 100644 mutants/clarity/mutants.out/lock.json
 delete mode 100644 mutants/clarity/mutants.out/missed.txt
 delete mode 100644 mutants/clarity/mutants.out/mutants.json
 delete mode 100644 mutants/clarity/mutants.out/outcomes.json
 delete mode 100644 mutants/clarity/mutants.out/unviable.txt
 create mode 100644 mutation-testing/packages-output/clarity/caught.txt
 create mode 100644 mutation-testing/packages-output/clarity/missed.txt
 rename {mutants/clarity/mutants.out => mutation-testing/packages-output/clarity}/timeout.txt (100%)
 create mode 100644 mutation-testing/packages-output/clarity/unviable.txt
 create mode 100644 mutation-testing/packages-output/pox-locking/caught.txt
 create mode 100644 mutation-testing/packages-output/pox-locking/missed.txt
 create mode 100644 mutation-testing/packages-output/pox-locking/timeout.txt
 create mode 100644 mutation-testing/packages-output/pox-locking/unviable.txt
 create mode 100644 mutation-testing/packages-output/stx-genesis/caught.txt
 create mode 100644 mutation-testing/packages-output/stx-genesis/missed.txt
 create mode 100644 mutation-testing/packages-output/stx-genesis/timeout.txt
 create mode 100644 mutation-testing/packages-output/stx-genesis/unviable.txt
 create mode 100644 mutation-testing/scripts/README.md
 create mode 100644 mutation-testing/scripts/append-match-package.sh
 create mode 100644 mutation-testing/scripts/create-stable.sh
 create mode 100755 mutation-testing/scripts/git-diff.sh
 create mode 100644 mutation-testing/scripts/modular-mutants-run.sh
 create mode 100644 mutation-testing/testing.md
 rename stacks-common/src/{libcommon.rs => lib.rs} (100%)

diff --git a/.github/workflows/mutants.yml b/.github/workflows/mutants.yml
new file mode 100644
index 0000000000..094dd4e7af
--- /dev/null
+++ b/.github/workflows/mutants.yml
@@ -0,0 +1,185 @@
+name: Mutants
+# to be tried cache vs artifacts
+
+# only run on push in order to update the artifact output
+# flow:
+# download artifact
+# run sh script for cargo mutants diff
+# upload artifact/cache
+
+on:
+  push:
+    branches:
+      - master
+      - develop
+      - next
+      - deployer/testing-shell-script
+
+### commented functions in order to not run them on every push
+jobs:
+  # cache_mutants:
+  #   runs-on: ubuntu-latest
+
+  #   steps:
+  #     - name: Checkout the latest code
+  #       id: git_checkout
+  #       uses: actions/checkout@v3
+  #     - name: Cache mutants-initial folder
+  #       uses: actions/cache@v3
+  #       with:
+  #         path: mutants-initial
+  #         key: mutants-initial
+  #     - name: Print caught mutants
+  #       run: cat mutants-initial/caught.txt
+  #     - name: Print missed mutants
+  #       run: cat mutants-initial/missed.txt
+  #     - name: Print unviable mutants
+  #       run: cat mutants-initial/unviable.txt
+  #     - name: Print timeout mutants
+  #       run: cat mutants-initial/timeout.txt
+
+  # Upload cache stable output version
+  # cache_mutants_output:
+  #   runs-on: ubuntu-latest
+
+  #   steps:
+  #     - name: Checkout the latest code
+  #       id: git_checkout
+  #       uses: actions/checkout@v3
+  #     - name: Cache mutants-initial folder
+  #       uses: actions/cache@v3
+  #       with:
+  #         path: mutation-testing/packages-output
+  #         key: mutants-stable-develop
+  #     # - name: Print caught mutants
+  #     #   run: cat mutants-initial/caught.txt
+
+  # ## Mutants testing: Execute on push on packages that have tested functions modified
+  cache_update_output:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout the latest code
+        id: git_checkout
+        uses: actions/checkout@v3
+      - name: Restore mutants-output cached folder
+        uses: actions/cache/restore@v3
+        with:
+          path: mutation-testing/packages-output
+          key: mutants-stable-develop
+      - name: Print caught mutants
+        run: cat mutation-testing/packages-output/pox-locking/missed.txt
+      - run: cargo install cargo-mutants
+      # - name: Update stable mutants with modified functions
+      #   run: ./git-diff.sh
+      #   working-directory: mutation-testing/scripts
+      # - name: Print updated missed mutants
+      #   run: cat mutation-testing/packages-output/pox-locking/missed.txt
+      - name: Append 2 line to one file
+        run: |
+          echo "text 1" >> missed.txt
+          echo "text 2" >> missed.txt
+        working-directory: mutation-testing/packages-output/pox-locking
+      - name: outshow new cached file
+        run: cat missed.txt
+        working-directory: mutation-testing/packages-output/pox-locking
+      # - name: Cache mutants-initial folder
+      #   uses: actions/cache/save@v3
+      #   with:
+      #     path: mutation-testing/packages-output
+      #     key: mutants-stable-develop
+      - name: Save Cache
+        uses: Wandalen/wretry.action@a163f62ae554a8f3cbe27b23db15b60c0ae2e93c # v1.3.0
+        with:
+          action: actions/cache/save@704facf57e6136b1bc63b828d79edcd491f0ee84 # v3.3.2
+          with: |
+            path: mutation-testing/packages-output
+            key: mutants-stable-develop
+          attempt_limit: 5
+          attempt_delay: 3000
+
+  # # Upload stable output version
+  # stable-mutants:
+  #   name: Upload Stable Mutants Testing
+  #   runs-on: ubuntu-latest
+  #   steps:
+  #     - uses: actions/checkout@v3
+  #       with:
+  #         fetch-depth: 0 # do we want to fetch all?
+  #     - name: Archive mutants output
+  #       uses: actions/upload-artifact@v3
+  #       if: always()
+  #       with:
+  #         name: mutants-stable-develop
+  #         path: mutation-testing/packages-output
+
+  # ## Mutants testing: Execute on PR on packages that have tested functions modified
+  # ### download it && see how it is
+  # incremental-mutants:
+  #   name: Incremental Mutants Testing
+  #   runs-on: ubuntu-latest
+  #   steps:
+  #     - uses: actions/checkout@v3
+  #     - name: Download stable output artifact
+  #       uses: actions/download-artifact@v3
+  #       with:
+  #         name: mutants-stable-develop
+  #         path: mutation-testing/packages-output
+  #     - name: Display structure of downloaded files
+  #       run: ls -R
+  #       working-directory: mutation-testing/packages-output
+  #     - run: cargo install cargo-mutants
+  #     - name: Update stable mutants with modified functions
+  #       run: ./git-diff.sh
+  #       working-directory: mutation-testing/scripts
+  #     - name: Archive mutants output
+  #       uses: actions/upload-artifact@v3
+  #       if: always()
+  #       with:
+  #         name: mutants-stable-develop
+  #         path: mutation-testing/packages-output
+
+  # incremental-mutants-2:
+  #   name: Incremental Mutants Testing
+  #   runs-on: ubuntu-latest
+  #   steps:
+  #     - uses: actions/checkout@v3
+
+  #     - name: Check for the existence of the stable output artifact
+  #       id: check-artifact
+  #       uses: actions/github-script@v5
+  #       with:
+  #         script: |
+  #           const artifacts = await github.rest.actions.listWorkflowRunArtifacts({
+  #             owner: context.repo.owner,
+  #             repo: context.repo.repo,
+  #             run_id: context.runId,
+  #           });
+  #           const artifactExists = artifacts.data.artifacts.some(artifact => artifact.name === 'mutants-stable-develop');
+  #           core.setOutput('exists', artifactExists);
+
+  #     - name: Download stable output artifact
+  #       if: steps.check-artifact.outputs.exists == 'true'
+  #       uses: actions/download-artifact@v3
+  #       with:
+  #         name: mutants-stable-develop
+  #         path: mutation-testing/packages-output
+
+  #     - name: Display structure of downloaded files
+  #       if: steps.check-artifact.outputs.exists == 'true'
+  #       run: ls -R
+  #       working-directory: mutation-testing/packages-output
+
+  #     - run: cargo install cargo-mutants
+
+  #     - name: Update stable mutants with modified functions
+  #       if: steps.check-artifact.outputs.exists == 'true'
+  #       run: ./git-diff.sh
+  #       working-directory: mutation-testing/scripts
+
+  #     - name: Archive mutants output
+  #       uses: actions/upload-artifact@v3
+  #       if: always()
+  #       with:
+  #         name: mutants-stable-develop
+  #         path: mutation-testing/packages-output
diff --git a/libsigner/Cargo.toml b/libsigner/Cargo.toml
index 8500ef55fa..35aaca69f7 100644
--- a/libsigner/Cargo.toml
+++ b/libsigner/Cargo.toml
@@ -13,7 +13,7 @@ edition = "2021"
 
 [lib]
 name = "libsigner"
-path = "./src/libsigner.rs"
+path = "./src/lib.rs"
 
 [dependencies]
 clarity = { path = "../clarity" }
diff --git a/libsigner/src/libsigner.rs b/libsigner/src/lib.rs
similarity index 100%
rename from libsigner/src/libsigner.rs
rename to libsigner/src/lib.rs
diff --git a/mutants-testing-general.sh b/mutants-testing-general.sh
deleted file mode 100644
index 27aad563a2..0000000000
--- a/mutants-testing-general.sh
+++ /dev/null
@@ -1,34 +0,0 @@
-#!/bin/bash
-
-# Create mutants directory
-mkdir -p mutants
-
-### Run mutation testing on the packages uncommented
-
-# Run mutation testing for clarity package
-cargo mutants --package clarity --output mutants/clarity
-
-# Run mutation testing for libsigner package
-cargo mutants --package libsigner --output mutants/libsigner
-
-# Run mutation testing for libstackerdb package
-cargo mutants --package libstackerdb --output mutants/libstackerdb
-
-# Run mutation testing for pox-locking package
-cargo mutants --package pox-locking --output mutants/pox-locking
-
-# Run mutation testing for stacks-common package
-cargo mutants --package stacks-common --output mutants/stacks-common
-
-# Run mutation testing for stx-genesis package
-cargo mutants --package stx-genesis --output mutants/stx-genesis
-
-
-# Run mutation testing for stacks-signer package - working, 10 min approx. 
-# cargo mutants --package stacks-signer --output mutants/stacks-signer
-
-# Commented out mutation testing for stacks-node package due to test errors and long compile/testing time
-# cargo mutants --package stacks-node --output mutants/stacks-node
-
-# Commented out mutation testing for stackslib package due to long compile/testing time
-# cargo mutants --package stackslib --output mutants/stackslib
diff --git a/mutants/clarity/mutants.out/caught.txt b/mutants/clarity/mutants.out/caught.txt
deleted file mode 100644
index 7325042f1c..0000000000
--- a/mutants/clarity/mutants.out/caught.txt
+++ /dev/null
@@ -1,54 +0,0 @@
-clarity/src/vm/types/signatures.rs:1923: replace <impl Display for StringUTF8Length>::fmt -> fmt::Result with Ok(Default::default())
-clarity/src/vm/types/signatures.rs:1652: replace TypeSignature::size -> u32 with 0
-clarity/src/vm/types/signatures.rs:524: replace TypeSignature::admits_type -> Result<bool> with Ok(false)
-clarity/src/vm/types/signatures.rs:1862: replace <impl Debug for TupleTypeSignature>::fmt -> fmt::Result with Ok(Default::default())
-clarity/src/vm/types/signatures.rs:1722: replace ListTypeData::inner_size -> Option<u32> with Some(1)
-clarity/src/vm/types/signatures.rs:524: replace TypeSignature::admits_type -> Result<bool> with Ok(true)
-clarity/src/vm/types/signatures.rs:1782: replace TupleTypeSignature::inner_size -> Option<u32> with None
-clarity/src/vm/types/signatures.rs:848: replace TupleTypeSignature::len -> u64 with 0
-clarity/src/vm/types/signatures.rs:1652: replace TypeSignature::size -> u32 with 1
-clarity/src/vm/types/signatures.rs:1658: replace TypeSignature::inner_size -> Option<u32> with Some(1)
-clarity/src/vm/types/signatures.rs:341: replace <impl From for u32>::from -> u32 with 0
-clarity/src/vm/types/signatures.rs:515: replace TypeSignature::is_no_type -> bool with true
-clarity/src/vm/types/signatures.rs:1722: replace ListTypeData::inner_size -> Option<u32> with None
-clarity/src/vm/types/signatures.rs:515: replace TypeSignature::is_no_type -> bool with false
-clarity/src/vm/types/signatures.rs:394: replace <impl From for u32>::from -> u32 with 0
-clarity/src/vm/types/signatures.rs:1748: replace TupleTypeSignature::type_size -> Option<u32> with None
-clarity/src/vm/types/signatures.rs:1722: replace ListTypeData::inner_size -> Option<u32> with Some(0)
-clarity/src/vm/types/signatures.rs:388: replace <impl From for u32>::from -> u32 with 0
-clarity/src/vm/types/signatures.rs:1883: replace <impl Display for TypeSignature>::fmt -> fmt::Result with Ok(Default::default())
-clarity/src/vm/types/signatures.rs:394: replace <impl From for u32>::from -> u32 with 1
-clarity/src/vm/types/signatures.rs:1782: replace TupleTypeSignature::inner_size -> Option<u32> with Some(1)
-clarity/src/vm/types/signatures.rs:624: replace TypeSignature::admits_type_v2_1 -> Result<bool> with Ok(true)
-clarity/src/vm/types/signatures.rs:511: replace TypeSignature::is_response_type -> bool with false
-clarity/src/vm/types/signatures.rs:347: replace <impl From for u32>::from -> u32 with 1
-clarity/src/vm/types/signatures.rs:476: replace ListTypeData::get_max_len -> u32 with 0
-clarity/src/vm/types/signatures.rs:476: replace ListTypeData::get_max_len -> u32 with 1
-clarity/src/vm/types/signatures.rs:1735: replace ListTypeData::type_size -> Option<u32> with None
-clarity/src/vm/types/signatures.rs:857: replace TupleTypeSignature::field_type -> Option<&TypeSignature> with None
-clarity/src/vm/types/signatures.rs:341: replace <impl From for u32>::from -> u32 with 1
-clarity/src/vm/types/signatures.rs:865: replace TupleTypeSignature::admits -> Result<bool> with Ok(true)
-clarity/src/vm/types/signatures.rs:1917: replace <impl Display for BufferLength>::fmt -> fmt::Result with Ok(Default::default())
-clarity/src/vm/types/signatures.rs:1658: replace TypeSignature::inner_size -> Option<u32> with Some(0)
-clarity/src/vm/types/signatures.rs:848: replace TupleTypeSignature::len -> u64 with 1
-clarity/src/vm/types/signatures.rs:926: replace FunctionSignature::check_args_trait_compliance -> Result<bool> with Ok(true)
-clarity/src/vm/types/signatures.rs:926: replace FunctionSignature::check_args_trait_compliance -> Result<bool> with Ok(false)
-clarity/src/vm/types/signatures.rs:535: replace TypeSignature::admits_type_v2_0 -> Result<bool> with Ok(true)
-clarity/src/vm/types/signatures.rs:624: replace TypeSignature::admits_type_v2_1 -> Result<bool> with Ok(false)
-clarity/src/vm/types/signatures.rs:1782: replace TupleTypeSignature::inner_size -> Option<u32> with Some(0)
-clarity/src/vm/types/signatures.rs:388: replace <impl From for u32>::from -> u32 with 1
-clarity/src/vm/types/signatures.rs:535: replace TypeSignature::admits_type_v2_0 -> Result<bool> with Ok(false)
-clarity/src/vm/types/signatures.rs:1551: replace TypeSignature::parse_trait_type_repr -> Result<BTreeMap<ClarityName, FunctionSignature>> with Ok(BTreeMap::new())
-clarity/src/vm/types/signatures.rs:865: replace TupleTypeSignature::admits -> Result<bool> with Ok(false)
-clarity/src/vm/types/signatures.rs:470: replace ListTypeData::reduce_max_len with ()
-clarity/src/vm/types/signatures.rs:519: replace TypeSignature::admits -> Result<bool> with Ok(false)
-clarity/src/vm/types/signatures.rs:1658: replace TypeSignature::inner_size -> Option<u32> with None
-clarity/src/vm/types/signatures.rs:1852: replace <impl Display for TupleTypeSignature>::fmt -> fmt::Result with Ok(Default::default())
-clarity/src/vm/types/signatures.rs:511: replace TypeSignature::is_response_type -> bool with true
-clarity/src/vm/types/signatures.rs:1696: replace TypeSignature::inner_type_size -> Option<u32> with None
-clarity/src/vm/types/signatures.rs:519: replace TypeSignature::admits -> Result<bool> with Ok(true)
-clarity/src/vm/types/signatures.rs:347: replace <impl From for u32>::from -> u32 with 0
-clarity/src/vm/types/signatures.rs:1812: replace parse_name_type_pairs -> Result<Vec<(ClarityName, TypeSignature)>> with Ok(vec![])
-clarity/src/vm/types/signatures.rs:1627: replace TypeSignature::depth -> u8 with 1
-clarity/src/vm/types/signatures.rs:896: replace TupleTypeSignature::shallow_merge with ()
-clarity/src/vm/types/signatures.rs:1627: replace TypeSignature::depth -> u8 with 0
diff --git a/mutants/clarity/mutants.out/lock.json b/mutants/clarity/mutants.out/lock.json
deleted file mode 100644
index d5fceb8673..0000000000
--- a/mutants/clarity/mutants.out/lock.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-  "cargo_mutants_version": "23.11.1",
-  "start_time": "2023-11-27T14:07:14.518556Z",
-  "hostname": "asuciu-macbook-pro.local",
-  "username": "asuciu"
-}
diff --git a/mutants/clarity/mutants.out/missed.txt b/mutants/clarity/mutants.out/missed.txt
deleted file mode 100644
index 93210d252c..0000000000
--- a/mutants/clarity/mutants.out/missed.txt
+++ /dev/null
@@ -1,24 +0,0 @@
-clarity/src/vm/types/signatures.rs:902: replace FixedFunction::total_type_size -> Result<u64> with Ok(0)
-clarity/src/vm/types/signatures.rs:69: replace AssetIdentifier::sugared -> String with "xyzzy".into()
-clarity/src/vm/types/signatures.rs:913: replace FunctionSignature::total_type_size -> Result<u64> with Ok(1)
-clarity/src/vm/types/signatures.rs:139: replace SequenceSubtype::is_list_type -> bool with false
-clarity/src/vm/types/signatures.rs:1690: replace TypeSignature::type_size -> Result<u32> with Ok(1)
-clarity/src/vm/types/signatures.rs:139: replace SequenceSubtype::is_list_type -> bool with true
-clarity/src/vm/types/signatures.rs:1735: replace ListTypeData::type_size -> Option<u32> with Some(0)
-clarity/src/vm/types/signatures.rs:1696: replace TypeSignature::inner_type_size -> Option<u32> with Some(0)
-clarity/src/vm/types/signatures.rs:1872: replace <impl Display for AssetIdentifier>::fmt -> fmt::Result with Ok(Default::default())
-clarity/src/vm/types/signatures.rs:1696: replace TypeSignature::inner_type_size -> Option<u32> with Some(1)
-clarity/src/vm/types/signatures.rs:1766: replace TupleTypeSignature::size -> u32 with 1
-clarity/src/vm/types/signatures.rs:1929: replace <impl Display for FunctionArg>::fmt -> fmt::Result with Ok(Default::default())
-clarity/src/vm/types/signatures.rs:1748: replace TupleTypeSignature::type_size -> Option<u32> with Some(1)
-clarity/src/vm/types/signatures.rs:1735: replace ListTypeData::type_size -> Option<u32> with Some(1)
-clarity/src/vm/types/signatures.rs:853: replace TupleTypeSignature::is_empty -> bool with true
-clarity/src/vm/types/signatures.rs:1766: replace TupleTypeSignature::size -> u32 with 0
-clarity/src/vm/types/signatures.rs:913: replace FunctionSignature::total_type_size -> Result<u64> with Ok(0)
-clarity/src/vm/types/signatures.rs:902: replace FixedFunction::total_type_size -> Result<u64> with Ok(1)
-clarity/src/vm/types/signatures.rs:69: replace AssetIdentifier::sugared -> String with String::new()
-clarity/src/vm/types/signatures.rs:1748: replace TupleTypeSignature::type_size -> Option<u32> with Some(0)
-clarity/src/vm/types/signatures.rs:1771: replace TupleTypeSignature::max_depth -> u8 with 0
-clarity/src/vm/types/signatures.rs:853: replace TupleTypeSignature::is_empty -> bool with false
-clarity/src/vm/types/signatures.rs:1771: replace TupleTypeSignature::max_depth -> u8 with 1
-clarity/src/vm/types/signatures.rs:1690: replace TypeSignature::type_size -> Result<u32> with Ok(0)
diff --git a/mutants/clarity/mutants.out/mutants.json b/mutants/clarity/mutants.out/mutants.json
deleted file mode 100644
index 23c0f4d577..0000000000
--- a/mutants/clarity/mutants.out/mutants.json
+++ /dev/null
@@ -1,1253 +0,0 @@
-[
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1923,
-    "function": "<impl Display for StringUTF8Length>::fmt",
-    "return_type": "-> fmt::Result",
-    "replacement": "Ok(Default::default())",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 401,
-    "function": "<impl TryFrom for StringUTF8Length>::try_from",
-    "return_type": "-> Result<StringUTF8Length>",
-    "replacement": "Ok(Default::default())",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1349,
-    "function": "TypeSignature::construct_parent_list_type",
-    "return_type": "-> Result<ListTypeData>",
-    "replacement": "Ok(Default::default())",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1652,
-    "function": "TypeSignature::size",
-    "return_type": "-> u32",
-    "replacement": "0",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 498,
-    "function": "TypeSignature::new_response",
-    "return_type": "-> Result<TypeSignature>",
-    "replacement": "Ok(Default::default())",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 902,
-    "function": "FixedFunction::total_type_size",
-    "return_type": "-> Result<u64>",
-    "replacement": "Ok(0)",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 721,
-    "function": "TypeSignature::canonicalize",
-    "return_type": "-> TypeSignature",
-    "replacement": "Default::default()",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 243,
-    "function": "FunctionArgSignature::canonicalize",
-    "return_type": "-> FunctionArgSignature",
-    "replacement": "Default::default()",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1862,
-    "function": "<impl Debug for TupleTypeSignature>::fmt",
-    "return_type": "-> fmt::Result",
-    "replacement": "Ok(Default::default())",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 524,
-    "function": "TypeSignature::admits_type",
-    "return_type": "-> Result<bool>",
-    "replacement": "Ok(false)",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1356,
-    "function": "TypeSignature::parent_list_type",
-    "return_type": "-> std::result::Result<ListTypeData, CheckErrors>",
-    "replacement": "Ok(Default::default())",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1722,
-    "function": "ListTypeData::inner_size",
-    "return_type": "-> Option<u32>",
-    "replacement": "Some(1)",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 464,
-    "function": "ListTypeData::destruct",
-    "return_type": "-> (TypeSignature, u32)",
-    "replacement": "(Default::default(), 0)",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 524,
-    "function": "TypeSignature::admits_type",
-    "return_type": "-> Result<bool>",
-    "replacement": "Ok(true)",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 69,
-    "function": "AssetIdentifier::sugared",
-    "return_type": "-> String",
-    "replacement": "\"xyzzy\".into()",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 913,
-    "function": "FunctionSignature::total_type_size",
-    "return_type": "-> Result<u64>",
-    "replacement": "Ok(1)",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1782,
-    "function": "TupleTypeSignature::inner_size",
-    "return_type": "-> Option<u32>",
-    "replacement": "None",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 128,
-    "function": "SequenceSubtype::unit_type",
-    "return_type": "-> TypeSignature",
-    "replacement": "Default::default()",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 139,
-    "function": "SequenceSubtype::is_list_type",
-    "return_type": "-> bool",
-    "replacement": "false",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1463,
-    "function": "TypeSignature::parse_optional_type_repr",
-    "return_type": "-> Result<TypeSignature>",
-    "replacement": "Ok(Default::default())",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1652,
-    "function": "TypeSignature::size",
-    "return_type": "-> u32",
-    "replacement": "1",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 848,
-    "function": "TupleTypeSignature::len",
-    "return_type": "-> u64",
-    "replacement": "0",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1690,
-    "function": "TypeSignature::type_size",
-    "return_type": "-> Result<u32>",
-    "replacement": "Ok(1)",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1658,
-    "function": "TypeSignature::inner_size",
-    "return_type": "-> Option<u32>",
-    "replacement": "Some(1)",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 139,
-    "function": "SequenceSubtype::is_list_type",
-    "return_type": "-> bool",
-    "replacement": "true",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 341,
-    "function": "<impl From for u32>::from",
-    "return_type": "-> u32",
-    "replacement": "0",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1305,
-    "function": "TypeSignature::empty_list",
-    "return_type": "-> ListTypeData",
-    "replacement": "Default::default()",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1417,
-    "function": "TypeSignature::parse_buff_type_repr",
-    "return_type": "-> Result<TypeSignature>",
-    "replacement": "Ok(Default::default())",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 273,
-    "function": "FunctionType::canonicalize",
-    "return_type": "-> FunctionType",
-    "replacement": "Default::default()",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 515,
-    "function": "TypeSignature::is_no_type",
-    "return_type": "-> bool",
-    "replacement": "false",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 992,
-    "function": "TypeSignature::max_buffer",
-    "return_type": "-> TypeSignature",
-    "replacement": "Default::default()",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 515,
-    "function": "TypeSignature::is_no_type",
-    "return_type": "-> bool",
-    "replacement": "true",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 486,
-    "function": "TypeSignature::new_option",
-    "return_type": "-> Result<TypeSignature>",
-    "replacement": "Ok(Default::default())",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 394,
-    "function": "<impl From for u32>::from",
-    "return_type": "-> u32",
-    "replacement": "0",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1722,
-    "function": "ListTypeData::inner_size",
-    "return_type": "-> Option<u32>",
-    "replacement": "None",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1748,
-    "function": "TupleTypeSignature::type_size",
-    "return_type": "-> Option<u32>",
-    "replacement": "None",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1722,
-    "function": "ListTypeData::inner_size",
-    "return_type": "-> Option<u32>",
-    "replacement": "Some(0)",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1339,
-    "function": "TypeSignature::literal_type_of",
-    "return_type": "-> TypeSignature",
-    "replacement": "Default::default()",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1312,
-    "function": "TypeSignature::type_of",
-    "return_type": "-> TypeSignature",
-    "replacement": "Default::default()",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 388,
-    "function": "<impl From for u32>::from",
-    "return_type": "-> u32",
-    "replacement": "0",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 958,
-    "function": "TypeSignature::empty_buffer",
-    "return_type": "-> TypeSignature",
-    "replacement": "Default::default()",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1446,
-    "function": "TypeSignature::parse_string_ascii_type_repr",
-    "return_type": "-> Result<TypeSignature>",
-    "replacement": "Ok(Default::default())",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1883,
-    "function": "<impl Display for TypeSignature>::fmt",
-    "return_type": "-> fmt::Result",
-    "replacement": "Ok(Default::default())",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 978,
-    "function": "TypeSignature::max_string_ascii",
-    "return_type": "-> TypeSignature",
-    "replacement": "Default::default()",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 806,
-    "function": "<impl TryFrom for TupleTypeSignature>::try_from",
-    "return_type": "-> Result<TupleTypeSignature>",
-    "replacement": "Ok(Default::default())",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1735,
-    "function": "ListTypeData::type_size",
-    "return_type": "-> Option<u32>",
-    "replacement": "Some(0)",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 329,
-    "function": "<impl From for TypeSignature>::from",
-    "return_type": "-> Self",
-    "replacement": "Default::default()",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1476,
-    "function": "TypeSignature::parse_response_type_repr",
-    "return_type": "-> Result<TypeSignature>",
-    "replacement": "Ok(Default::default())",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 480,
-    "function": "ListTypeData::get_list_item_type",
-    "return_type": "-> &TypeSignature",
-    "replacement": "&Default::default()",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1782,
-    "function": "TupleTypeSignature::inner_size",
-    "return_type": "-> Option<u32>",
-    "replacement": "Some(1)",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 394,
-    "function": "<impl From for u32>::from",
-    "return_type": "-> u32",
-    "replacement": "1",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 763,
-    "function": "TypeSignature::concretize",
-    "return_type": "-> Result<TypeSignature>",
-    "replacement": "Ok(Default::default())",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1007,
-    "function": "TypeSignature::bound_string_ascii_type",
-    "return_type": "-> TypeSignature",
-    "replacement": "Default::default()",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1388,
-    "function": "TypeSignature::parse_list_type_repr",
-    "return_type": "-> Result<TypeSignature>",
-    "replacement": "Ok(Default::default())",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 624,
-    "function": "TypeSignature::admits_type_v2_1",
-    "return_type": "-> Result<bool>",
-    "replacement": "Ok(true)",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1696,
-    "function": "TypeSignature::inner_type_size",
-    "return_type": "-> Option<u32>",
-    "replacement": "Some(0)",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 511,
-    "function": "TypeSignature::is_response_type",
-    "return_type": "-> bool",
-    "replacement": "false",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 347,
-    "function": "<impl From for u32>::from",
-    "return_type": "-> u32",
-    "replacement": "1",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1409,
-    "function": "TypeSignature::parse_tuple_type_repr",
-    "return_type": "-> Result<TypeSignature>",
-    "replacement": "Ok(Default::default())",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 476,
-    "function": "ListTypeData::get_max_len",
-    "return_type": "-> u32",
-    "replacement": "0",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 476,
-    "function": "ListTypeData::get_max_len",
-    "return_type": "-> u32",
-    "replacement": "1",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 857,
-    "function": "TupleTypeSignature::field_type",
-    "return_type": "-> Option<&TypeSignature>",
-    "replacement": "None",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1735,
-    "function": "ListTypeData::type_size",
-    "return_type": "-> Option<u32>",
-    "replacement": "None",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1872,
-    "function": "<impl Display for AssetIdentifier>::fmt",
-    "return_type": "-> fmt::Result",
-    "replacement": "Ok(Default::default())",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1019,
-    "function": "TypeSignature::factor_out_no_type",
-    "return_type": "-> Result<TypeSignature>",
-    "replacement": "Ok(Default::default())",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1766,
-    "function": "TupleTypeSignature::size",
-    "return_type": "-> u32",
-    "replacement": "1",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 887,
-    "function": "TupleTypeSignature::parse_name_type_pair_list",
-    "return_type": "-> Result<TupleTypeSignature>",
-    "replacement": "Ok(Default::default())",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1696,
-    "function": "TypeSignature::inner_type_size",
-    "return_type": "-> Option<u32>",
-    "replacement": "Some(1)",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 861,
-    "function": "TupleTypeSignature::get_type_map",
-    "return_type": "-> &BTreeMap<ClarityName, TypeSignature>",
-    "replacement": "&BTreeMap::from_iter([(Default::default(), Default::default())])",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1929,
-    "function": "<impl Display for FunctionArg>::fmt",
-    "return_type": "-> fmt::Result",
-    "replacement": "Ok(Default::default())",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1748,
-    "function": "TupleTypeSignature::type_size",
-    "return_type": "-> Option<u32>",
-    "replacement": "Some(1)",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1065,
-    "function": "TypeSignature::least_supertype_v2_0",
-    "return_type": "-> Result<TypeSignature>",
-    "replacement": "Ok(Default::default())",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1167,
-    "function": "TypeSignature::least_supertype_v2_1",
-    "return_type": "-> Result<TypeSignature>",
-    "replacement": "Ok(Default::default())",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 341,
-    "function": "<impl From for u32>::from",
-    "return_type": "-> u32",
-    "replacement": "1",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 865,
-    "function": "TupleTypeSignature::admits",
-    "return_type": "-> Result<bool>",
-    "replacement": "Ok(true)",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 857,
-    "function": "TupleTypeSignature::field_type",
-    "return_type": "-> Option<&TypeSignature>",
-    "replacement": "Some(&Default::default())",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 261,
-    "function": "FunctionReturnsSignature::canonicalize",
-    "return_type": "-> FunctionReturnsSignature",
-    "replacement": "Default::default()",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1431,
-    "function": "TypeSignature::parse_string_utf8_type_repr",
-    "return_type": "-> Result<TypeSignature>",
-    "replacement": "Ok(Default::default())",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1735,
-    "function": "ListTypeData::type_size",
-    "return_type": "-> Option<u32>",
-    "replacement": "Some(1)",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1917,
-    "function": "<impl Display for BufferLength>::fmt",
-    "return_type": "-> fmt::Result",
-    "replacement": "Ok(Default::default())",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 853,
-    "function": "TupleTypeSignature::is_empty",
-    "return_type": "-> bool",
-    "replacement": "true",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1658,
-    "function": "TypeSignature::inner_size",
-    "return_type": "-> Option<u32>",
-    "replacement": "Some(0)",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1372,
-    "function": "TypeSignature::parse_atom_type",
-    "return_type": "-> Result<TypeSignature>",
-    "replacement": "Ok(Default::default())",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 848,
-    "function": "TupleTypeSignature::len",
-    "return_type": "-> u64",
-    "replacement": "1",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 926,
-    "function": "FunctionSignature::check_args_trait_compliance",
-    "return_type": "-> Result<bool>",
-    "replacement": "Ok(false)",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 926,
-    "function": "FunctionSignature::check_args_trait_compliance",
-    "return_type": "-> Result<bool>",
-    "replacement": "Ok(true)",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 999,
-    "function": "TypeSignature::contract_name_string_ascii_type",
-    "return_type": "-> TypeSignature",
-    "replacement": "Default::default()",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 535,
-    "function": "TypeSignature::admits_type_v2_0",
-    "return_type": "-> Result<bool>",
-    "replacement": "Ok(true)",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 624,
-    "function": "TypeSignature::admits_type_v2_1",
-    "return_type": "-> Result<bool>",
-    "replacement": "Ok(false)",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 535,
-    "function": "TypeSignature::admits_type_v2_0",
-    "return_type": "-> Result<bool>",
-    "replacement": "Ok(false)",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1782,
-    "function": "TupleTypeSignature::inner_size",
-    "return_type": "-> Option<u32>",
-    "replacement": "Some(0)",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 388,
-    "function": "<impl From for u32>::from",
-    "return_type": "-> u32",
-    "replacement": "1",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 939,
-    "function": "FunctionSignature::canonicalize",
-    "return_type": "-> FunctionSignature",
-    "replacement": "Default::default()",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1551,
-    "function": "TypeSignature::parse_trait_type_repr",
-    "return_type": "-> Result<BTreeMap<ClarityName, FunctionSignature>>",
-    "replacement": "Ok(BTreeMap::from_iter([(Default::default(), Default::default())]))",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1551,
-    "function": "TypeSignature::parse_trait_type_repr",
-    "return_type": "-> Result<BTreeMap<ClarityName, FunctionSignature>>",
-    "replacement": "Ok(BTreeMap::new())",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1301,
-    "function": "TypeSignature::list_of",
-    "return_type": "-> Result<TypeSignature>",
-    "replacement": "Ok(Default::default())",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1489,
-    "function": "TypeSignature::parse_type_repr",
-    "return_type": "-> Result<TypeSignature>",
-    "replacement": "Ok(Default::default())",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 825,
-    "function": "<impl TryFrom for TupleTypeSignature>::try_from",
-    "return_type": "-> Result<TupleTypeSignature>",
-    "replacement": "Ok(Default::default())",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 865,
-    "function": "TupleTypeSignature::admits",
-    "return_type": "-> Result<bool>",
-    "replacement": "Ok(false)",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 365,
-    "function": "<impl TryFrom for BufferLength>::try_from",
-    "return_type": "-> Result<BufferLength>",
-    "replacement": "Ok(Default::default())",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 470,
-    "function": "ListTypeData::reduce_max_len",
-    "return_type": "",
-    "replacement": "()",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1766,
-    "function": "TupleTypeSignature::size",
-    "return_type": "-> u32",
-    "replacement": "0",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 519,
-    "function": "TypeSignature::admits",
-    "return_type": "-> Result<bool>",
-    "replacement": "Ok(false)",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 415,
-    "function": "<impl TryFrom for StringUTF8Length>::try_from",
-    "return_type": "-> Result<StringUTF8Length>",
-    "replacement": "Ok(Default::default())",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 321,
-    "function": "<impl From for FunctionSignature>::from",
-    "return_type": "-> FunctionSignature",
-    "replacement": "Default::default()",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 376,
-    "function": "<impl TryFrom for BufferLength>::try_from",
-    "return_type": "-> Result<BufferLength>",
-    "replacement": "Ok(Default::default())",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1658,
-    "function": "TypeSignature::inner_size",
-    "return_type": "-> Option<u32>",
-    "replacement": "None",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 59,
-    "function": "AssetIdentifier::STX_burned",
-    "return_type": "-> AssetIdentifier",
-    "replacement": "Default::default()",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1852,
-    "function": "<impl Display for TupleTypeSignature>::fmt",
-    "return_type": "-> fmt::Result",
-    "replacement": "Ok(Default::default())",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 913,
-    "function": "FunctionSignature::total_type_size",
-    "return_type": "-> Result<u64>",
-    "replacement": "Ok(0)",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 511,
-    "function": "TypeSignature::is_response_type",
-    "return_type": "-> bool",
-    "replacement": "true",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 519,
-    "function": "TypeSignature::admits",
-    "return_type": "-> Result<bool>",
-    "replacement": "Ok(true)",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1696,
-    "function": "TypeSignature::inner_type_size",
-    "return_type": "-> Option<u32>",
-    "replacement": "None",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 966,
-    "function": "TypeSignature::min_string_ascii",
-    "return_type": "-> TypeSignature",
-    "replacement": "Default::default()",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 861,
-    "function": "TupleTypeSignature::get_type_map",
-    "return_type": "-> &BTreeMap<ClarityName, TypeSignature>",
-    "replacement": "&BTreeMap::new()",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 962,
-    "function": "TypeSignature::min_buffer",
-    "return_type": "-> TypeSignature",
-    "replacement": "Default::default()",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1812,
-    "function": "parse_name_type_pairs",
-    "return_type": "-> Result<Vec<(ClarityName, TypeSignature)>>",
-    "replacement": "Ok(vec![])",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 347,
-    "function": "<impl From for u32>::from",
-    "return_type": "-> u32",
-    "replacement": "0",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 444,
-    "function": "ListTypeData::new_list",
-    "return_type": "-> Result<ListTypeData>",
-    "replacement": "Ok(Default::default())",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 464,
-    "function": "ListTypeData::destruct",
-    "return_type": "-> (TypeSignature, u32)",
-    "replacement": "(Default::default(), 1)",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 69,
-    "function": "AssetIdentifier::sugared",
-    "return_type": "-> String",
-    "replacement": "String::new()",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 902,
-    "function": "FixedFunction::total_type_size",
-    "return_type": "-> Result<u64>",
-    "replacement": "Ok(1)",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1812,
-    "function": "parse_name_type_pairs",
-    "return_type": "-> Result<Vec<(ClarityName, TypeSignature)>>",
-    "replacement": "Ok(vec![(Default::default(), Default::default())])",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1748,
-    "function": "TupleTypeSignature::type_size",
-    "return_type": "-> Option<u32>",
-    "replacement": "Some(0)",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1627,
-    "function": "TypeSignature::depth",
-    "return_type": "-> u8",
-    "replacement": "1",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 985,
-    "function": "TypeSignature::max_string_utf8",
-    "return_type": "-> TypeSignature",
-    "replacement": "Default::default()",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1771,
-    "function": "TupleTypeSignature::max_depth",
-    "return_type": "-> u8",
-    "replacement": "0",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 354,
-    "function": "<impl TryFrom for BufferLength>::try_from",
-    "return_type": "-> Result<BufferLength>",
-    "replacement": "Ok(Default::default())",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 429,
-    "function": "<impl TryFrom for StringUTF8Length>::try_from",
-    "return_type": "-> Result<StringUTF8Length>",
-    "replacement": "Ok(Default::default())",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 853,
-    "function": "TupleTypeSignature::is_empty",
-    "return_type": "-> bool",
-    "replacement": "false",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1054,
-    "function": "TypeSignature::least_supertype",
-    "return_type": "-> Result<TypeSignature>",
-    "replacement": "Ok(Default::default())",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 972,
-    "function": "TypeSignature::min_string_utf8",
-    "return_type": "-> TypeSignature",
-    "replacement": "Default::default()",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 896,
-    "function": "TupleTypeSignature::shallow_merge",
-    "return_type": "",
-    "replacement": "()",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 733,
-    "function": "TypeSignature::canonicalize_v2_1",
-    "return_type": "-> TypeSignature",
-    "replacement": "Default::default()",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1627,
-    "function": "TypeSignature::depth",
-    "return_type": "-> u8",
-    "replacement": "0",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1771,
-    "function": "TupleTypeSignature::max_depth",
-    "return_type": "-> u8",
-    "replacement": "1",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 49,
-    "function": "AssetIdentifier::STX",
-    "return_type": "-> AssetIdentifier",
-    "replacement": "Default::default()",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 335,
-    "function": "<impl From for TypeSignature>::from",
-    "return_type": "-> Self",
-    "replacement": "Default::default()",
-    "genre": "FnValue"
-  },
-  {
-    "package": "clarity",
-    "file": "clarity/src/vm/types/signatures.rs",
-    "line": 1690,
-    "function": "TypeSignature::type_size",
-    "return_type": "-> Result<u32>",
-    "replacement": "Ok(0)",
-    "genre": "FnValue"
-  }
-]
\ No newline at end of file
diff --git a/mutants/clarity/mutants.out/outcomes.json b/mutants/clarity/mutants.out/outcomes.json
deleted file mode 100644
index 163ef2651e..0000000000
--- a/mutants/clarity/mutants.out/outcomes.json
+++ /dev/null
@@ -1,4930 +0,0 @@
-{
-  "outcomes": [
-    {
-      "scenario": "Baseline",
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/baseline.log",
-      "summary": "Success",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 48.870485542,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 13.581365083,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1349,
-          "function": "TypeSignature::construct_parent_list_type",
-          "return_type": "-> Result<ListTypeData>",
-          "replacement": "Ok(Default::default())",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1349.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 2.413352667,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 498,
-          "function": "TypeSignature::new_response",
-          "return_type": "-> Result<TypeSignature>",
-          "replacement": "Ok(Default::default())",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_498.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 1.8009515,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 401,
-          "function": "<impl TryFrom for StringUTF8Length>::try_from",
-          "return_type": "-> Result<StringUTF8Length>",
-          "replacement": "Ok(Default::default())",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_401.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 8.302728625,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 721,
-          "function": "TypeSignature::canonicalize",
-          "return_type": "-> TypeSignature",
-          "replacement": "Default::default()",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_721.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 5.217074708,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 243,
-          "function": "FunctionArgSignature::canonicalize",
-          "return_type": "-> FunctionArgSignature",
-          "replacement": "Default::default()",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_243.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 7.594266708,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 902,
-          "function": "FixedFunction::total_type_size",
-          "return_type": "-> Result<u64>",
-          "replacement": "Ok(0)",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_902.log",
-      "summary": "MissedMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 13.547835583,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 18.191711542,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1923,
-          "function": "<impl Display for StringUTF8Length>::fmt",
-          "return_type": "-> fmt::Result",
-          "replacement": "Ok(Default::default())",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1923.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 40.211793125,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 37.435264791,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1652,
-          "function": "TypeSignature::size",
-          "return_type": "-> u32",
-          "replacement": "0",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1652.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 40.639337375,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 38.695793333,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 524,
-          "function": "TypeSignature::admits_type",
-          "return_type": "-> Result<bool>",
-          "replacement": "Ok(false)",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_524.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 23.007986375,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 21.6112545,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1356,
-          "function": "TypeSignature::parent_list_type",
-          "return_type": "-> std::result::Result<ListTypeData, CheckErrors>",
-          "replacement": "Ok(Default::default())",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1356.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 3.227544417,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 464,
-          "function": "ListTypeData::destruct",
-          "return_type": "-> (TypeSignature, u32)",
-          "replacement": "(Default::default(), 0)",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_464.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 2.31028175,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1862,
-          "function": "<impl Debug for TupleTypeSignature>::fmt",
-          "return_type": "-> fmt::Result",
-          "replacement": "Ok(Default::default())",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1862.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 51.42247,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 34.323780375,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1722,
-          "function": "ListTypeData::inner_size",
-          "return_type": "-> Option<u32>",
-          "replacement": "Some(1)",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1722.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 25.53248325,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 17.148738375,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 524,
-          "function": "TypeSignature::admits_type",
-          "return_type": "-> Result<bool>",
-          "replacement": "Ok(true)",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_524_001.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 27.380569833,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 15.380072333,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 128,
-          "function": "SequenceSubtype::unit_type",
-          "return_type": "-> TypeSignature",
-          "replacement": "Default::default()",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_128.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 5.409524667,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 69,
-          "function": "AssetIdentifier::sugared",
-          "return_type": "-> String",
-          "replacement": "\"xyzzy\".into()",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_69.log",
-      "summary": "MissedMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 29.446663375,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 17.413222167,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1463,
-          "function": "TypeSignature::parse_optional_type_repr",
-          "return_type": "-> Result<TypeSignature>",
-          "replacement": "Ok(Default::default())",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1463.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 3.474340375,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 913,
-          "function": "FunctionSignature::total_type_size",
-          "return_type": "-> Result<u64>",
-          "replacement": "Ok(1)",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_913.log",
-      "summary": "MissedMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 25.763329209,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 18.006977416,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1782,
-          "function": "TupleTypeSignature::inner_size",
-          "return_type": "-> Option<u32>",
-          "replacement": "None",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1782.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 24.627890208,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 17.050794,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 139,
-          "function": "SequenceSubtype::is_list_type",
-          "return_type": "-> bool",
-          "replacement": "false",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_139.log",
-      "summary": "MissedMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 25.401799458,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 16.346395333,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 848,
-          "function": "TupleTypeSignature::len",
-          "return_type": "-> u64",
-          "replacement": "0",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_848.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 22.287401166,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 16.466721334,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1652,
-          "function": "TypeSignature::size",
-          "return_type": "-> u32",
-          "replacement": "1",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1652_001.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 28.696065875,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 27.5143085,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1658,
-          "function": "TypeSignature::inner_size",
-          "return_type": "-> Option<u32>",
-          "replacement": "Some(1)",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1658.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 27.29746575,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 21.400906083,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1690,
-          "function": "TypeSignature::type_size",
-          "return_type": "-> Result<u32>",
-          "replacement": "Ok(1)",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1690.log",
-      "summary": "MissedMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 31.799000625,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 24.386971708,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1305,
-          "function": "TypeSignature::empty_list",
-          "return_type": "-> ListTypeData",
-          "replacement": "Default::default()",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1305.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 2.679374833,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1417,
-          "function": "TypeSignature::parse_buff_type_repr",
-          "return_type": "-> Result<TypeSignature>",
-          "replacement": "Ok(Default::default())",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1417.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 2.883547541,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 273,
-          "function": "FunctionType::canonicalize",
-          "return_type": "-> FunctionType",
-          "replacement": "Default::default()",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_273.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 4.964104416,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 139,
-          "function": "SequenceSubtype::is_list_type",
-          "return_type": "-> bool",
-          "replacement": "true",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_139_001.log",
-      "summary": "MissedMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 27.802188125,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 11.663400458,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 341,
-          "function": "<impl From for u32>::from",
-          "return_type": "-> u32",
-          "replacement": "0",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_341.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 30.443008583,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 10.891368875,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 992,
-          "function": "TypeSignature::max_buffer",
-          "return_type": "-> TypeSignature",
-          "replacement": "Default::default()",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_992.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 4.977954417,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 486,
-          "function": "TypeSignature::new_option",
-          "return_type": "-> Result<TypeSignature>",
-          "replacement": "Ok(Default::default())",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_486.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 2.949309,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 515,
-          "function": "TypeSignature::is_no_type",
-          "return_type": "-> bool",
-          "replacement": "true",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_515_001.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 16.662940541,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 26.950355875,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1722,
-          "function": "ListTypeData::inner_size",
-          "return_type": "-> Option<u32>",
-          "replacement": "None",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1722_001.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 22.340065042,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 19.566255917,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 515,
-          "function": "TypeSignature::is_no_type",
-          "return_type": "-> bool",
-          "replacement": "false",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_515.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 17.362938667,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 35.683727708,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 394,
-          "function": "<impl From for u32>::from",
-          "return_type": "-> u32",
-          "replacement": "0",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_394.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 24.428596417,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 19.539569416,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1312,
-          "function": "TypeSignature::type_of",
-          "return_type": "-> TypeSignature",
-          "replacement": "Default::default()",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1312.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 3.602411708,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1339,
-          "function": "TypeSignature::literal_type_of",
-          "return_type": "-> TypeSignature",
-          "replacement": "Default::default()",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1339.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 4.225163333,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 958,
-          "function": "TypeSignature::empty_buffer",
-          "return_type": "-> TypeSignature",
-          "replacement": "Default::default()",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_958.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 3.6419924999999997,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1446,
-          "function": "TypeSignature::parse_string_ascii_type_repr",
-          "return_type": "-> Result<TypeSignature>",
-          "replacement": "Ok(Default::default())",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1446.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 6.7703145,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1748,
-          "function": "TupleTypeSignature::type_size",
-          "return_type": "-> Option<u32>",
-          "replacement": "None",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1748.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 18.313141792,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 19.517415292,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1722,
-          "function": "ListTypeData::inner_size",
-          "return_type": "-> Option<u32>",
-          "replacement": "Some(0)",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1722_002.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 19.117432125,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 16.168920166,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 978,
-          "function": "TypeSignature::max_string_ascii",
-          "return_type": "-> TypeSignature",
-          "replacement": "Default::default()",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_978.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 4.838537667,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 388,
-          "function": "<impl From for u32>::from",
-          "return_type": "-> u32",
-          "replacement": "0",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_388.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 19.122941792,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 16.852404458,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 329,
-          "function": "<impl From for TypeSignature>::from",
-          "return_type": "-> Self",
-          "replacement": "Default::default()",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_329.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 5.721400625,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 806,
-          "function": "<impl TryFrom for TupleTypeSignature>::try_from",
-          "return_type": "-> Result<TupleTypeSignature>",
-          "replacement": "Ok(Default::default())",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_806.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 10.547628916,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 480,
-          "function": "ListTypeData::get_list_item_type",
-          "return_type": "-> &TypeSignature",
-          "replacement": "&Default::default()",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_480.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 5.957461708,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1476,
-          "function": "TypeSignature::parse_response_type_repr",
-          "return_type": "-> Result<TypeSignature>",
-          "replacement": "Ok(Default::default())",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1476.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 6.321656875,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1883,
-          "function": "<impl Display for TypeSignature>::fmt",
-          "return_type": "-> fmt::Result",
-          "replacement": "Ok(Default::default())",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1883.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 26.04623475,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 15.193360584,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 763,
-          "function": "TypeSignature::concretize",
-          "return_type": "-> Result<TypeSignature>",
-          "replacement": "Ok(Default::default())",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_763.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 10.950827167,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1007,
-          "function": "TypeSignature::bound_string_ascii_type",
-          "return_type": "-> TypeSignature",
-          "replacement": "Default::default()",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1007.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 4.369384333,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1735,
-          "function": "ListTypeData::type_size",
-          "return_type": "-> Option<u32>",
-          "replacement": "Some(0)",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1735.log",
-      "summary": "MissedMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 22.466542667,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 16.240326875,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1388,
-          "function": "TypeSignature::parse_list_type_repr",
-          "return_type": "-> Result<TypeSignature>",
-          "replacement": "Ok(Default::default())",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1388.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 17.4692515,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 394,
-          "function": "<impl From for u32>::from",
-          "return_type": "-> u32",
-          "replacement": "1",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_394_001.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 32.002660209,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 13.946704166,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1782,
-          "function": "TupleTypeSignature::inner_size",
-          "return_type": "-> Option<u32>",
-          "replacement": "Some(1)",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1782_001.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 33.862695291,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 13.977090042,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 624,
-          "function": "TypeSignature::admits_type_v2_1",
-          "return_type": "-> Result<bool>",
-          "replacement": "Ok(true)",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_624.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 31.504170458,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 21.17088,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1696,
-          "function": "TypeSignature::inner_type_size",
-          "return_type": "-> Option<u32>",
-          "replacement": "Some(0)",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1696.log",
-      "summary": "MissedMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 25.22403,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 23.3472345,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1409,
-          "function": "TypeSignature::parse_tuple_type_repr",
-          "return_type": "-> Result<TypeSignature>",
-          "replacement": "Ok(Default::default())",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1409.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 7.313209583,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 511,
-          "function": "TypeSignature::is_response_type",
-          "return_type": "-> bool",
-          "replacement": "false",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_511.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 34.332864583,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 14.411179167,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 347,
-          "function": "<impl From for u32>::from",
-          "return_type": "-> u32",
-          "replacement": "1",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_347.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 34.903205959,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 12.939255167,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 476,
-          "function": "ListTypeData::get_max_len",
-          "return_type": "-> u32",
-          "replacement": "0",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_476.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 23.590776833,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 26.328106792,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 476,
-          "function": "ListTypeData::get_max_len",
-          "return_type": "-> u32",
-          "replacement": "1",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_476_001.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 24.598913458,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 24.816297667,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1735,
-          "function": "ListTypeData::type_size",
-          "return_type": "-> Option<u32>",
-          "replacement": "None",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1735_001.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 36.564255542,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 12.595694292,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 857,
-          "function": "TupleTypeSignature::field_type",
-          "return_type": "-> Option<&TypeSignature>",
-          "replacement": "None",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_857.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 39.241546583,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 11.131983583,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1019,
-          "function": "TypeSignature::factor_out_no_type",
-          "return_type": "-> Result<TypeSignature>",
-          "replacement": "Ok(Default::default())",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1019.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 10.367219875,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 887,
-          "function": "TupleTypeSignature::parse_name_type_pair_list",
-          "return_type": "-> Result<TupleTypeSignature>",
-          "replacement": "Ok(Default::default())",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_887.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 2.40049375,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 861,
-          "function": "TupleTypeSignature::get_type_map",
-          "return_type": "-> &BTreeMap<ClarityName, TypeSignature>",
-          "replacement": "&BTreeMap::from_iter([(Default::default(), Default::default())])",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_861.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 3.293869042,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1872,
-          "function": "<impl Display for AssetIdentifier>::fmt",
-          "return_type": "-> fmt::Result",
-          "replacement": "Ok(Default::default())",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1872.log",
-      "summary": "MissedMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 25.456887166,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 27.397120625,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1696,
-          "function": "TypeSignature::inner_type_size",
-          "return_type": "-> Option<u32>",
-          "replacement": "Some(1)",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1696_001.log",
-      "summary": "MissedMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 22.660173125,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 20.802173791,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1766,
-          "function": "TupleTypeSignature::size",
-          "return_type": "-> u32",
-          "replacement": "1",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1766.log",
-      "summary": "MissedMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 21.661805625,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 23.552763792,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1065,
-          "function": "TypeSignature::least_supertype_v2_0",
-          "return_type": "-> Result<TypeSignature>",
-          "replacement": "Ok(Default::default())",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1065.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 3.021114625,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1167,
-          "function": "TypeSignature::least_supertype_v2_1",
-          "return_type": "-> Result<TypeSignature>",
-          "replacement": "Ok(Default::default())",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1167.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 2.657739084,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1929,
-          "function": "<impl Display for FunctionArg>::fmt",
-          "return_type": "-> fmt::Result",
-          "replacement": "Ok(Default::default())",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1929.log",
-      "summary": "MissedMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 37.439525708,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 10.930792666,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 857,
-          "function": "TupleTypeSignature::field_type",
-          "return_type": "-> Option<&TypeSignature>",
-          "replacement": "Some(&Default::default())",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_857_001.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 16.4943715,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1748,
-          "function": "TupleTypeSignature::type_size",
-          "return_type": "-> Option<u32>",
-          "replacement": "Some(1)",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1748_001.log",
-      "summary": "MissedMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 23.868041583,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 11.95483925,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 261,
-          "function": "FunctionReturnsSignature::canonicalize",
-          "return_type": "-> FunctionReturnsSignature",
-          "replacement": "Default::default()",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_261.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 8.962593708,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1431,
-          "function": "TypeSignature::parse_string_utf8_type_repr",
-          "return_type": "-> Result<TypeSignature>",
-          "replacement": "Ok(Default::default())",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1431.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 4.787142875,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 341,
-          "function": "<impl From for u32>::from",
-          "return_type": "-> u32",
-          "replacement": "1",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_341_001.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 25.077840209,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 17.215056958,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 865,
-          "function": "TupleTypeSignature::admits",
-          "return_type": "-> Result<bool>",
-          "replacement": "Ok(true)",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_865.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 25.271255166,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 17.210464291,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1735,
-          "function": "ListTypeData::type_size",
-          "return_type": "-> Option<u32>",
-          "replacement": "Some(1)",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1735_002.log",
-      "summary": "MissedMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 22.162701709,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 22.213987666,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1372,
-          "function": "TypeSignature::parse_atom_type",
-          "return_type": "-> Result<TypeSignature>",
-          "replacement": "Ok(Default::default())",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1372.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 6.311530666,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 853,
-          "function": "TupleTypeSignature::is_empty",
-          "return_type": "-> bool",
-          "replacement": "true",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_853.log",
-      "summary": "MissedMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 29.040213167,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 18.036327625,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1917,
-          "function": "<impl Display for BufferLength>::fmt",
-          "return_type": "-> fmt::Result",
-          "replacement": "Ok(Default::default())",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1917.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 31.234916625,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 22.999341708,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1658,
-          "function": "TypeSignature::inner_size",
-          "return_type": "-> Option<u32>",
-          "replacement": "Some(0)",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1658_001.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 31.879440375,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 16.39029575,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 999,
-          "function": "TypeSignature::contract_name_string_ascii_type",
-          "return_type": "-> TypeSignature",
-          "replacement": "Default::default()",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_999.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 2.634524958,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 848,
-          "function": "TupleTypeSignature::len",
-          "return_type": "-> u64",
-          "replacement": "1",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_848_001.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 22.726564416,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 21.53074675,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 926,
-          "function": "FunctionSignature::check_args_trait_compliance",
-          "return_type": "-> Result<bool>",
-          "replacement": "Ok(true)",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_926_001.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 29.798568625,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 24.423910333,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 926,
-          "function": "FunctionSignature::check_args_trait_compliance",
-          "return_type": "-> Result<bool>",
-          "replacement": "Ok(false)",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_926.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 30.697343,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 24.892369292,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 535,
-          "function": "TypeSignature::admits_type_v2_0",
-          "return_type": "-> Result<bool>",
-          "replacement": "Ok(true)",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_535.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 32.350779208,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 19.450091875,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 624,
-          "function": "TypeSignature::admits_type_v2_1",
-          "return_type": "-> Result<bool>",
-          "replacement": "Ok(false)",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_624_001.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 24.073024042,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 15.364809125,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 939,
-          "function": "FunctionSignature::canonicalize",
-          "return_type": "-> FunctionSignature",
-          "replacement": "Default::default()",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_939.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 16.522799374999998,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1551,
-          "function": "TypeSignature::parse_trait_type_repr",
-          "return_type": "-> Result<BTreeMap<ClarityName, FunctionSignature>>",
-          "replacement": "Ok(BTreeMap::from_iter([(Default::default(), Default::default())]))",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1551.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 3.015027042,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1782,
-          "function": "TupleTypeSignature::inner_size",
-          "return_type": "-> Option<u32>",
-          "replacement": "Some(0)",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1782_002.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 34.659983166,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 17.324460541,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 388,
-          "function": "<impl From for u32>::from",
-          "return_type": "-> u32",
-          "replacement": "1",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_388_001.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 36.759580875,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 16.639867666,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 535,
-          "function": "TypeSignature::admits_type_v2_0",
-          "return_type": "-> Result<bool>",
-          "replacement": "Ok(false)",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_535_001.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 38.100834542,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 16.205373792,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1301,
-          "function": "TypeSignature::list_of",
-          "return_type": "-> Result<TypeSignature>",
-          "replacement": "Ok(Default::default())",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1301.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 3.31055975,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1489,
-          "function": "TypeSignature::parse_type_repr",
-          "return_type": "-> Result<TypeSignature>",
-          "replacement": "Ok(Default::default())",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1489.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 3.339428291,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 825,
-          "function": "<impl TryFrom for TupleTypeSignature>::try_from",
-          "return_type": "-> Result<TupleTypeSignature>",
-          "replacement": "Ok(Default::default())",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_825.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 3.236037084,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 365,
-          "function": "<impl TryFrom for BufferLength>::try_from",
-          "return_type": "-> Result<BufferLength>",
-          "replacement": "Ok(Default::default())",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_365.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 6.0192135,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1551,
-          "function": "TypeSignature::parse_trait_type_repr",
-          "return_type": "-> Result<BTreeMap<ClarityName, FunctionSignature>>",
-          "replacement": "Ok(BTreeMap::new())",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1551_001.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 22.54061125,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 20.491565334,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 865,
-          "function": "TupleTypeSignature::admits",
-          "return_type": "-> Result<bool>",
-          "replacement": "Ok(false)",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_865_001.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 25.454946334,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 15.922607833,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 415,
-          "function": "<impl TryFrom for StringUTF8Length>::try_from",
-          "return_type": "-> Result<StringUTF8Length>",
-          "replacement": "Ok(Default::default())",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_415.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 4.640949792,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 321,
-          "function": "<impl From for FunctionSignature>::from",
-          "return_type": "-> FunctionSignature",
-          "replacement": "Default::default()",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_321.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 7.98785425,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 470,
-          "function": "ListTypeData::reduce_max_len",
-          "return_type": "",
-          "replacement": "()",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_470.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 30.48559,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 23.830903709,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1766,
-          "function": "TupleTypeSignature::size",
-          "return_type": "-> u32",
-          "replacement": "0",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1766_001.log",
-      "summary": "MissedMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 29.497742,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 19.984396041,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 376,
-          "function": "<impl TryFrom for BufferLength>::try_from",
-          "return_type": "-> Result<BufferLength>",
-          "replacement": "Ok(Default::default())",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_376.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 5.595003125,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 59,
-          "function": "AssetIdentifier::STX_burned",
-          "return_type": "-> AssetIdentifier",
-          "replacement": "Default::default()",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_59.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 3.673552333,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 519,
-          "function": "TypeSignature::admits",
-          "return_type": "-> Result<bool>",
-          "replacement": "Ok(false)",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_519.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 30.971769917,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 15.166688708,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1658,
-          "function": "TypeSignature::inner_size",
-          "return_type": "-> Option<u32>",
-          "replacement": "None",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1658_002.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 26.2354305,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 18.948411792,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1852,
-          "function": "<impl Display for TupleTypeSignature>::fmt",
-          "return_type": "-> fmt::Result",
-          "replacement": "Ok(Default::default())",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1852.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 26.726568792,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 20.415309459,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 913,
-          "function": "FunctionSignature::total_type_size",
-          "return_type": "-> Result<u64>",
-          "replacement": "Ok(0)",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_913_001.log",
-      "summary": "MissedMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 28.608253959,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 23.206093625,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 966,
-          "function": "TypeSignature::min_string_ascii",
-          "return_type": "-> TypeSignature",
-          "replacement": "Default::default()",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_966.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 7.5618245,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 511,
-          "function": "TypeSignature::is_response_type",
-          "return_type": "-> bool",
-          "replacement": "true",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_511_001.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 34.760121541,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 19.49756125,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 861,
-          "function": "TupleTypeSignature::get_type_map",
-          "return_type": "-> &BTreeMap<ClarityName, TypeSignature>",
-          "replacement": "&BTreeMap::new()",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_861_001.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 14.486307541,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 962,
-          "function": "TypeSignature::min_buffer",
-          "return_type": "-> TypeSignature",
-          "replacement": "Default::default()",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_962.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 8.547444375,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1696,
-          "function": "TypeSignature::inner_type_size",
-          "return_type": "-> Option<u32>",
-          "replacement": "None",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1696_002.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 28.793845166,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 14.089337209,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 519,
-          "function": "TypeSignature::admits",
-          "return_type": "-> Result<bool>",
-          "replacement": "Ok(true)",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_519_001.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 34.086433792,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 15.454312584,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 444,
-          "function": "ListTypeData::new_list",
-          "return_type": "-> Result<ListTypeData>",
-          "replacement": "Ok(Default::default())",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_444.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 6.085910917,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 464,
-          "function": "ListTypeData::destruct",
-          "return_type": "-> (TypeSignature, u32)",
-          "replacement": "(Default::default(), 1)",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_464_001.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 6.066003333,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 347,
-          "function": "<impl From for u32>::from",
-          "return_type": "-> u32",
-          "replacement": "0",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_347_001.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 24.544213833,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 11.491642792,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1812,
-          "function": "parse_name_type_pairs",
-          "return_type": "-> Result<Vec<(ClarityName, TypeSignature)>>",
-          "replacement": "Ok(vec![])",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1812.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 26.021988834,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 19.17278175,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1812,
-          "function": "parse_name_type_pairs",
-          "return_type": "-> Result<Vec<(ClarityName, TypeSignature)>>",
-          "replacement": "Ok(vec![(Default::default(), Default::default())])",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1812_001.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 7.83972475,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 902,
-          "function": "FixedFunction::total_type_size",
-          "return_type": "-> Result<u64>",
-          "replacement": "Ok(1)",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_902_001.log",
-      "summary": "MissedMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 30.021399917,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 16.801482375,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 69,
-          "function": "AssetIdentifier::sugared",
-          "return_type": "-> String",
-          "replacement": "String::new()",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_69_001.log",
-      "summary": "MissedMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 31.32015925,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 17.240559375,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 985,
-          "function": "TypeSignature::max_string_utf8",
-          "return_type": "-> TypeSignature",
-          "replacement": "Default::default()",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_985.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 7.443240834,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 354,
-          "function": "<impl TryFrom for BufferLength>::try_from",
-          "return_type": "-> Result<BufferLength>",
-          "replacement": "Ok(Default::default())",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_354.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 5.393277042,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 429,
-          "function": "<impl TryFrom for StringUTF8Length>::try_from",
-          "return_type": "-> Result<StringUTF8Length>",
-          "replacement": "Ok(Default::default())",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_429.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 7.044557916,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1627,
-          "function": "TypeSignature::depth",
-          "return_type": "-> u8",
-          "replacement": "1",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1627.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 29.645121667,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 19.553984583,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1748,
-          "function": "TupleTypeSignature::type_size",
-          "return_type": "-> Option<u32>",
-          "replacement": "Some(0)",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1748_002.log",
-      "summary": "MissedMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 34.89297,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 20.507274458,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1054,
-          "function": "TypeSignature::least_supertype",
-          "return_type": "-> Result<TypeSignature>",
-          "replacement": "Ok(Default::default())",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1054.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 5.065974042,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 972,
-          "function": "TypeSignature::min_string_utf8",
-          "return_type": "-> TypeSignature",
-          "replacement": "Default::default()",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_972.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 5.034059459,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1771,
-          "function": "TupleTypeSignature::max_depth",
-          "return_type": "-> u8",
-          "replacement": "0",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1771.log",
-      "summary": "MissedMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 27.657742417,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 14.668397542,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 733,
-          "function": "TypeSignature::canonicalize_v2_1",
-          "return_type": "-> TypeSignature",
-          "replacement": "Default::default()",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_733.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 6.798037042,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 853,
-          "function": "TupleTypeSignature::is_empty",
-          "return_type": "-> bool",
-          "replacement": "false",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_853_001.log",
-      "summary": "MissedMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 24.447810042,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 17.067637541,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 49,
-          "function": "AssetIdentifier::STX",
-          "return_type": "-> AssetIdentifier",
-          "replacement": "Default::default()",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_49.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 9.820691042,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 335,
-          "function": "<impl From for TypeSignature>::from",
-          "return_type": "-> Self",
-          "replacement": "Default::default()",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_335.log",
-      "summary": "Unviable",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 7.351396958,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 896,
-          "function": "TupleTypeSignature::shallow_merge",
-          "return_type": "",
-          "replacement": "()",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_896.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 22.808443583,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 25.333841625,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W9cEZK.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1627,
-          "function": "TypeSignature::depth",
-          "return_type": "-> u8",
-          "replacement": "0",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1627_001.log",
-      "summary": "CaughtMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 34.04683525,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 23.64262775,
-          "process_status": "Failure",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-rJ7Ra1.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1771,
-          "function": "TupleTypeSignature::max_depth",
-          "return_type": "-> u8",
-          "replacement": "1",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1771_001.log",
-      "summary": "MissedMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 33.750561667,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 23.97481975,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-W1ZG58.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    },
-    {
-      "scenario": {
-        "Mutant": {
-          "package": "clarity",
-          "file": "clarity/src/vm/types/signatures.rs",
-          "line": 1690,
-          "function": "TypeSignature::type_size",
-          "return_type": "-> Result<u32>",
-          "replacement": "Ok(0)",
-          "genre": "FnValue"
-        }
-      },
-      "log_path": "/Users/asuciu/Documents/GitHub/my-core/stacks-core/mutants.out/log/clarity__src__vm__types__signatures.rs_line_1690_001.log",
-      "summary": "MissedMutant",
-      "phase_results": [
-        {
-          "phase": "Build",
-          "duration": 26.267381666,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "build",
-            "--tests",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        },
-        {
-          "phase": "Test",
-          "duration": 8.574997125,
-          "process_status": "Success",
-          "argv": [
-            "/Users/asuciu/.rustup/toolchains/stable-aarch64-apple-darwin/bin/cargo",
-            "test",
-            "--manifest-path",
-            "/var/folders/wr/nxd5pyh545z8rk128h04wj480000gs/T/cargo-mutants-stacks-core-Og13Ay.tmp/clarity/Cargo.toml"
-          ]
-        }
-      ]
-    }
-  ],
-  "total_mutants": 139,
-  "missed": 24,
-  "caught": 54,
-  "timeout": 0,
-  "unviable": 61,
-  "success": 0,
-  "failure": 0
-}
\ No newline at end of file
diff --git a/mutants/clarity/mutants.out/unviable.txt b/mutants/clarity/mutants.out/unviable.txt
deleted file mode 100644
index a24d04d96c..0000000000
--- a/mutants/clarity/mutants.out/unviable.txt
+++ /dev/null
@@ -1,61 +0,0 @@
-clarity/src/vm/types/signatures.rs:1349: replace TypeSignature::construct_parent_list_type -> Result<ListTypeData> with Ok(Default::default())
-clarity/src/vm/types/signatures.rs:498: replace TypeSignature::new_response -> Result<TypeSignature> with Ok(Default::default())
-clarity/src/vm/types/signatures.rs:401: replace <impl TryFrom for StringUTF8Length>::try_from -> Result<StringUTF8Length> with Ok(Default::default())
-clarity/src/vm/types/signatures.rs:721: replace TypeSignature::canonicalize -> TypeSignature with Default::default()
-clarity/src/vm/types/signatures.rs:243: replace FunctionArgSignature::canonicalize -> FunctionArgSignature with Default::default()
-clarity/src/vm/types/signatures.rs:1356: replace TypeSignature::parent_list_type -> std::result::Result<ListTypeData, CheckErrors> with Ok(Default::default())
-clarity/src/vm/types/signatures.rs:464: replace ListTypeData::destruct -> (TypeSignature, u32) with (Default::default(), 0)
-clarity/src/vm/types/signatures.rs:128: replace SequenceSubtype::unit_type -> TypeSignature with Default::default()
-clarity/src/vm/types/signatures.rs:1463: replace TypeSignature::parse_optional_type_repr -> Result<TypeSignature> with Ok(Default::default())
-clarity/src/vm/types/signatures.rs:1305: replace TypeSignature::empty_list -> ListTypeData with Default::default()
-clarity/src/vm/types/signatures.rs:1417: replace TypeSignature::parse_buff_type_repr -> Result<TypeSignature> with Ok(Default::default())
-clarity/src/vm/types/signatures.rs:273: replace FunctionType::canonicalize -> FunctionType with Default::default()
-clarity/src/vm/types/signatures.rs:992: replace TypeSignature::max_buffer -> TypeSignature with Default::default()
-clarity/src/vm/types/signatures.rs:486: replace TypeSignature::new_option -> Result<TypeSignature> with Ok(Default::default())
-clarity/src/vm/types/signatures.rs:1312: replace TypeSignature::type_of -> TypeSignature with Default::default()
-clarity/src/vm/types/signatures.rs:1339: replace TypeSignature::literal_type_of -> TypeSignature with Default::default()
-clarity/src/vm/types/signatures.rs:958: replace TypeSignature::empty_buffer -> TypeSignature with Default::default()
-clarity/src/vm/types/signatures.rs:1446: replace TypeSignature::parse_string_ascii_type_repr -> Result<TypeSignature> with Ok(Default::default())
-clarity/src/vm/types/signatures.rs:978: replace TypeSignature::max_string_ascii -> TypeSignature with Default::default()
-clarity/src/vm/types/signatures.rs:329: replace <impl From for TypeSignature>::from -> Self with Default::default()
-clarity/src/vm/types/signatures.rs:806: replace <impl TryFrom for TupleTypeSignature>::try_from -> Result<TupleTypeSignature> with Ok(Default::default())
-clarity/src/vm/types/signatures.rs:480: replace ListTypeData::get_list_item_type -> &TypeSignature with &Default::default()
-clarity/src/vm/types/signatures.rs:1476: replace TypeSignature::parse_response_type_repr -> Result<TypeSignature> with Ok(Default::default())
-clarity/src/vm/types/signatures.rs:763: replace TypeSignature::concretize -> Result<TypeSignature> with Ok(Default::default())
-clarity/src/vm/types/signatures.rs:1007: replace TypeSignature::bound_string_ascii_type -> TypeSignature with Default::default()
-clarity/src/vm/types/signatures.rs:1388: replace TypeSignature::parse_list_type_repr -> Result<TypeSignature> with Ok(Default::default())
-clarity/src/vm/types/signatures.rs:1409: replace TypeSignature::parse_tuple_type_repr -> Result<TypeSignature> with Ok(Default::default())
-clarity/src/vm/types/signatures.rs:1019: replace TypeSignature::factor_out_no_type -> Result<TypeSignature> with Ok(Default::default())
-clarity/src/vm/types/signatures.rs:887: replace TupleTypeSignature::parse_name_type_pair_list -> Result<TupleTypeSignature> with Ok(Default::default())
-clarity/src/vm/types/signatures.rs:861: replace TupleTypeSignature::get_type_map -> &BTreeMap<ClarityName, TypeSignature> with &BTreeMap::from_iter([(Default::default(), Default::default())])
-clarity/src/vm/types/signatures.rs:1065: replace TypeSignature::least_supertype_v2_0 -> Result<TypeSignature> with Ok(Default::default())
-clarity/src/vm/types/signatures.rs:1167: replace TypeSignature::least_supertype_v2_1 -> Result<TypeSignature> with Ok(Default::default())
-clarity/src/vm/types/signatures.rs:857: replace TupleTypeSignature::field_type -> Option<&TypeSignature> with Some(&Default::default())
-clarity/src/vm/types/signatures.rs:261: replace FunctionReturnsSignature::canonicalize -> FunctionReturnsSignature with Default::default()
-clarity/src/vm/types/signatures.rs:1431: replace TypeSignature::parse_string_utf8_type_repr -> Result<TypeSignature> with Ok(Default::default())
-clarity/src/vm/types/signatures.rs:1372: replace TypeSignature::parse_atom_type -> Result<TypeSignature> with Ok(Default::default())
-clarity/src/vm/types/signatures.rs:999: replace TypeSignature::contract_name_string_ascii_type -> TypeSignature with Default::default()
-clarity/src/vm/types/signatures.rs:939: replace FunctionSignature::canonicalize -> FunctionSignature with Default::default()
-clarity/src/vm/types/signatures.rs:1551: replace TypeSignature::parse_trait_type_repr -> Result<BTreeMap<ClarityName, FunctionSignature>> with Ok(BTreeMap::from_iter([(Default::default(), Default::default())]))
-clarity/src/vm/types/signatures.rs:1301: replace TypeSignature::list_of -> Result<TypeSignature> with Ok(Default::default())
-clarity/src/vm/types/signatures.rs:1489: replace TypeSignature::parse_type_repr -> Result<TypeSignature> with Ok(Default::default())
-clarity/src/vm/types/signatures.rs:825: replace <impl TryFrom for TupleTypeSignature>::try_from -> Result<TupleTypeSignature> with Ok(Default::default())
-clarity/src/vm/types/signatures.rs:365: replace <impl TryFrom for BufferLength>::try_from -> Result<BufferLength> with Ok(Default::default())
-clarity/src/vm/types/signatures.rs:415: replace <impl TryFrom for StringUTF8Length>::try_from -> Result<StringUTF8Length> with Ok(Default::default())
-clarity/src/vm/types/signatures.rs:321: replace <impl From for FunctionSignature>::from -> FunctionSignature with Default::default()
-clarity/src/vm/types/signatures.rs:376: replace <impl TryFrom for BufferLength>::try_from -> Result<BufferLength> with Ok(Default::default())
-clarity/src/vm/types/signatures.rs:59: replace AssetIdentifier::STX_burned -> AssetIdentifier with Default::default()
-clarity/src/vm/types/signatures.rs:966: replace TypeSignature::min_string_ascii -> TypeSignature with Default::default()
-clarity/src/vm/types/signatures.rs:861: replace TupleTypeSignature::get_type_map -> &BTreeMap<ClarityName, TypeSignature> with &BTreeMap::new()
-clarity/src/vm/types/signatures.rs:962: replace TypeSignature::min_buffer -> TypeSignature with Default::default()
-clarity/src/vm/types/signatures.rs:444: replace ListTypeData::new_list -> Result<ListTypeData> with Ok(Default::default())
-clarity/src/vm/types/signatures.rs:464: replace ListTypeData::destruct -> (TypeSignature, u32) with (Default::default(), 1)
-clarity/src/vm/types/signatures.rs:1812: replace parse_name_type_pairs -> Result<Vec<(ClarityName, TypeSignature)>> with Ok(vec![(Default::default(), Default::default())])
-clarity/src/vm/types/signatures.rs:985: replace TypeSignature::max_string_utf8 -> TypeSignature with Default::default()
-clarity/src/vm/types/signatures.rs:354: replace <impl TryFrom for BufferLength>::try_from -> Result<BufferLength> with Ok(Default::default())
-clarity/src/vm/types/signatures.rs:429: replace <impl TryFrom for StringUTF8Length>::try_from -> Result<StringUTF8Length> with Ok(Default::default())
-clarity/src/vm/types/signatures.rs:1054: replace TypeSignature::least_supertype -> Result<TypeSignature> with Ok(Default::default())
-clarity/src/vm/types/signatures.rs:972: replace TypeSignature::min_string_utf8 -> TypeSignature with Default::default()
-clarity/src/vm/types/signatures.rs:733: replace TypeSignature::canonicalize_v2_1 -> TypeSignature with Default::default()
-clarity/src/vm/types/signatures.rs:49: replace AssetIdentifier::STX -> AssetIdentifier with Default::default()
-clarity/src/vm/types/signatures.rs:335: replace <impl From for TypeSignature>::from -> Self with Default::default()
diff --git a/mutation-testing/packages-output/clarity/caught.txt b/mutation-testing/packages-output/clarity/caught.txt
new file mode 100644
index 0000000000..41203cc4ae
--- /dev/null
+++ b/mutation-testing/packages-output/clarity/caught.txt
@@ -0,0 +1,487 @@
+clarity/src/vm/database/key_value_wrapper.rs:265: replace RollbackWrapper<'a>::commit with ()
+clarity/src/vm/types/mod.rs:871: replace Value::size -> u32 with 1
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:210: replace ContractContext::into_contract_analysis with ()
+clarity/src/vm/contexts.rs:271: replace AssetMap::get_next_stx_burn_amount -> Result<u128> with Ok(0)
+clarity/src/vm/functions/boolean.rs:27: replace type_force_bool -> Result<bool> with Ok(true)
+clarity/src/vm/database/key_value_wrapper.rs:45: replace rollback_edits_push with ()
+clarity/src/vm/representations.rs:194: replace <impl SymbolicExpressionCommon for PreSymbolicExpression>::set_id with ()
+clarity/src/vm/database/structures.rs:837: replace STXBalance::checked_add_unlocked_amount -> Option<u128> with Some(1)
+clarity/src/vm/database/clarity_db.rs:1870: replace ClarityDatabase<'a>::make_key_for_account -> String with String::new()
+clarity/src/vm/database/clarity_store.rs:323: replace <impl ClarityBackingStore for MemoryBackingStore>::get_current_block_height -> u32 with 0
+clarity/src/vm/functions/principals.rs:40: replace version_matches_testnet -> bool with false
+clarity/src/vm/database/structures.rs:892: replace STXBalance::get_available_balance_at_burn_block -> u128 with 0
+clarity/src/vm/functions/options.rs:220: replace is_some -> Result<bool> with Ok(true)
+clarity/src/vm/diagnostic.rs:67: replace <impl Display for Diagnostic>::fmt -> fmt::Result with Ok(Default::default())
+clarity/src/vm/database/clarity_db.rs:1760: replace ClarityDatabase<'a>::get_ft_supply -> Result<u128> with Ok(1)
+clarity/src/vm/types/serialization.rs:396: replace TypeSignature::max_serialized_size -> Result<u32, CheckErrors> with Ok(0)
+clarity/src/vm/mod.rs:557: replace execute -> Result<Option<Value>> with Ok(None)
+clarity/src/vm/database/clarity_db.rs:472: replace ClarityDatabase<'a>::get -> Option<T> with None
+clarity/src/vm/types/signatures.rs:535: replace TypeSignature::admits_type_v2_0 -> Result<bool> with Ok(false)
+clarity/src/vm/database/structures.rs:790: replace STXBalance::amount_locked -> u128 with 1
+clarity/src/vm/analysis/types.rs:104: replace ContractAnalysis::replace_contract_cost_tracker with ()
+clarity/src/vm/database/clarity_db.rs:441: replace ClarityDatabase<'a>::commit with ()
+clarity/src/vm/database/clarity_db.rs:561: replace ClarityDatabase<'a>::insert_contract_hash -> Result<()> with Ok(())
+clarity/src/vm/functions/principals.rs:34: replace version_matches_mainnet -> bool with false
+clarity/src/vm/analysis/analysis_db.rs:58: replace AnalysisDatabase<'a>::begin with ()
+clarity/src/vm/contexts.rs:1699: replace GlobalContext<'a, 'hooks>::begin with ()
+clarity/src/vm/functions/define.rs:277: replace DefineFunctions::try_parse -> Option<(DefineFunctions, &[SymbolicExpression])> with None
+clarity/src/vm/contexts.rs:314: replace AssetMap::add_asset_transfer with ()
+clarity/src/vm/database/clarity_db.rs:1870: replace ClarityDatabase<'a>::make_key_for_account -> String with "xyzzy".into()
+clarity/src/vm/database/clarity_db.rs:1290: replace ClarityDatabase<'a>::make_key_for_data_map_entry -> String with String::new()
+clarity/src/vm/costs/mod.rs:1114: replace <impl CostOverflowingMath for u64>::cost_overflow_mul -> Result<u64> with Ok(1)
+clarity/src/vm/types/signatures.rs:926: replace FunctionSignature::check_args_trait_compliance -> Result<bool> with Ok(true)
+clarity/src/vm/analysis/analysis_db.rs:62: replace AnalysisDatabase<'a>::commit with ()
+clarity/src/vm/contexts.rs:1694: replace GlobalContext<'a, 'hooks>::is_read_only -> bool with true
+clarity/src/vm/contexts.rs:1714: replace GlobalContext<'a, 'hooks>::commit -> Result<(Option<AssetMap>, Option<EventBatch>)> with Ok((None, None))
+clarity/src/vm/contexts.rs:1274: replace Environment<'a, 'b, 'hooks>::initialize_contract -> Result<()> with Ok(())
+clarity/src/vm/errors.rs:132: replace <impl Display for Error>::fmt -> fmt::Result with Ok(Default::default())
+clarity/src/vm/analysis/types.rs:118: replace ContractAnalysis::add_variable_type with ()
+clarity/src/vm/types/signatures.rs:624: replace TypeSignature::admits_type_v2_1 -> Result<bool> with Ok(true)
+clarity/src/vm/contexts.rs:1889: replace LocalContext<'a>::extend -> Result<LocalContext<'a>> with Ok(Default::default())
+clarity/src/vm/database/clarity_db.rs:758: replace ClarityDatabase<'a>::increment_ustx_liquid_supply -> Result<()> with Ok(())
+clarity/src/vm/costs/mod.rs:1114: replace <impl CostOverflowingMath for u64>::cost_overflow_mul -> Result<u64> with Ok(0)
+clarity/src/vm/representations.rs:372: replace PreSymbolicExpression::match_list -> Option<&[PreSymbolicExpression]> with None
+clarity/src/vm/types/signatures.rs:476: replace ListTypeData::get_max_len -> u32 with 1
+clarity/src/vm/mod.rs:513: replace execute_with_parameters -> Result<Option<Value>> with Ok(None)
+clarity/src/vm/functions/define.rs:114: replace check_legal_define -> Result<()> with Ok(())
+clarity/src/vm/types/signatures.rs:865: replace TupleTypeSignature::admits -> Result<bool> with Ok(false)
+clarity/src/vm/types/signatures.rs:515: replace TypeSignature::is_no_type -> bool with true
+clarity/src/vm/types/signatures.rs:1627: replace TypeSignature::depth -> u8 with 1
+clarity/src/vm/types/serialization.rs:1175: replace Value::serialize_to_vec -> Vec<u8> with vec![1]
+clarity/src/vm/mod.rs:369: replace eval_all -> Result<Option<Value>> with Ok(None)
+clarity/src/vm/database/clarity_db.rs:436: replace ClarityDatabase<'a>::begin with ()
+clarity/src/vm/database/clarity_db.rs:937: replace ClarityDatabase<'a>::get_pox_payout_addrs_for_burnchain_height -> Option<(Vec<TupleData>, u128)> with None
+clarity/src/vm/database/key_value_wrapper.rs:315: replace RollbackWrapper<'a>::put with ()
+clarity/src/vm/ast/definition_sorter/mod.rs:488: replace GraphWalker::get_cycling_dependencies -> Option<Vec<usize>> with None
+clarity/src/vm/mod.rs:353: replace is_reserved -> bool with false
+clarity/src/vm/types/signatures.rs:1627: replace TypeSignature::depth -> u8 with 0
+clarity/src/vm/types/mod.rs:875: replace Value::depth -> u8 with 1
+clarity/src/vm/contexts.rs:1818: replace ContractContext::lookup_function -> Option<DefinedFunction> with None
+clarity/src/vm/database/structures.rs:837: replace STXBalance::checked_add_unlocked_amount -> Option<u128> with Some(0)
+clarity/src/vm/ast/definition_sorter/mod.rs:421: replace Graph::get_node_descendants -> Vec<usize> with vec![0]
+clarity/src/vm/contexts.rs:1829: replace ContractContext::is_explicitly_implementing_trait -> bool with true
+clarity/src/vm/types/mod.rs:1053: replace Value::expect_buff -> Vec<u8> with vec![1]
+clarity/src/vm/types/signatures.rs:519: replace TypeSignature::admits -> Result<bool> with Ok(false)
+clarity/src/vm/contexts.rs:284: replace AssetMap::get_next_amount -> Result<u128> with Ok(0)
+clarity/src/vm/types/signatures.rs:1722: replace ListTypeData::inner_size -> Option<u32> with Some(0)
+clarity/src/vm/database/clarity_db.rs:748: replace ClarityDatabase<'a>::set_ustx_liquid_supply with ()
+clarity/src/vm/analysis/arithmetic_checker/mod.rs:92: replace ArithmeticOnlyChecker<'a>::check_define_function -> Result<(), Error> with Ok(())
+clarity/src/vm/database/structures.rs:396: replace STXBalanceSnapshot<'db, 'conn>::can_transfer -> bool with false
+clarity/src/vm/database/structures.rs:409: replace STXBalanceSnapshot<'db, 'conn>::credit with ()
+clarity/src/vm/analysis/analysis_db.rs:93: replace AnalysisDatabase<'a>::load_contract_non_canonical -> Option<ContractAnalysis> with None
+clarity/src/vm/functions/options.rs:28: replace inner_unwrap -> Result<Option<Value>> with Ok(None)
+clarity/src/vm/types/signatures.rs:476: replace ListTypeData::get_max_len -> u32 with 0
+clarity/src/vm/database/key_value_wrapper.rs:305: replace inner_put with ()
+clarity/src/vm/contexts.rs:1694: replace GlobalContext<'a, 'hooks>::is_read_only -> bool with false
+clarity/src/vm/database/structures.rs:358: replace STXBalanceSnapshot<'db, 'conn>::get_available_balance -> u128 with 0
+clarity/src/vm/analysis/errors.rs:279: replace check_argument_count -> Result<(), CheckErrors> with Ok(())
+clarity/src/vm/docs/mod.rs:728: replace get_input_type_string -> String with "xyzzy".into()
+clarity/src/vm/database/sqlite.rs:81: replace SqliteConnection::get -> Option<String> with None
+clarity/src/vm/contexts.rs:1626: replace GlobalContext<'a, 'hooks>::log_token_transfer -> Result<()> with Ok(())
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:312: replace ContractContext::get_variable_type -> Option<&TypeSignature> with None
+clarity/src/vm/database/clarity_db.rs:699: replace ClarityDatabase<'a>::has_contract -> bool with true
+clarity/src/vm/contexts.rs:263: replace AssetMap::get_next_stx_amount -> Result<u128> with Ok(0)
+clarity/src/vm/types/mod.rs:1253: replace <impl Display for ResponseData>::fmt -> fmt::Result with Ok(Default::default())
+clarity/src/vm/contexts.rs:1714: replace GlobalContext<'a, 'hooks>::commit -> Result<(Option<AssetMap>, Option<EventBatch>)> with Ok((Some(Default::default()), None))
+clarity/src/vm/database/clarity_db.rs:1115: replace map_no_contract_as_none -> Result<Option<T>> with Ok(None)
+clarity/src/vm/analysis/arithmetic_checker/mod.rs:274: replace ArithmeticOnlyChecker<'a>::check_function_application -> Result<(), Error> with Ok(())
+clarity/src/vm/database/clarity_store.rs:319: replace <impl ClarityBackingStore for MemoryBackingStore>::get_open_chain_tip_height -> u32 with 1
+clarity/src/vm/contexts.rs:1939: replace CallStack::depth -> usize with 1
+clarity/src/vm/database/clarity_db.rs:1302: replace ClarityDatabase<'a>::make_key_for_data_map_entry_serialized -> String with String::new()
+clarity/src/vm/types/signatures.rs:1917: replace <impl Display for BufferLength>::fmt -> fmt::Result with Ok(Default::default())
+clarity/src/vm/database/key_value_wrapper.rs:420: replace RollbackWrapper<'a>::get_current_block_height -> u32 with 0
+clarity/src/vm/contexts.rs:1635: replace GlobalContext<'a, 'hooks>::log_stx_transfer -> Result<()> with Ok(())
+clarity/src/vm/analysis/arithmetic_checker/mod.rs:165: replace ArithmeticOnlyChecker<'a>::try_native_function_check -> Option<Result<(), Error>> with Some(Ok(()))
+clarity/src/vm/database/clarity_db.rs:926: replace ClarityDatabase<'a>::get_burnchain_block_header_hash_for_burnchain_height -> Option<BurnchainHeaderHash> with None
+clarity/src/vm/database/clarity_db.rs:694: replace ClarityDatabase<'a>::insert_contract with ()
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:43: replace is_string_terminator -> bool with true
+clarity/src/vm/types/signatures.rs:524: replace TypeSignature::admits_type -> Result<bool> with Ok(true)
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:88: replace ContractContext::get_nft_type -> Option<&TypeSignature> with None
+clarity/src/vm/analysis/types.rs:171: replace ContractAnalysis::get_private_function -> Option<&FunctionType> with None
+clarity/src/vm/ast/parser/v2/lexer/token.rs:47: replace <impl Display for Token>::fmt -> std::fmt::Result with Ok(Default::default())
+clarity/src/vm/types/signatures.rs:926: replace FunctionSignature::check_args_trait_compliance -> Result<bool> with Ok(false)
+clarity/src/vm/database/clarity_db.rs:1719: replace ClarityDatabase<'a>::get_ft_balance -> Result<u128> with Ok(1)
+clarity/src/vm/representations.rs:570: replace SymbolicExpression::match_list -> Option<&[SymbolicExpression]> with Some(Vec::leak(Vec::new()))
+clarity/src/vm/contexts.rs:1913: replace LocalContext<'a>::lookup_callable_contract -> Option<&CallableData> with None
+clarity/src/vm/analysis/types.rs:139: replace ContractAnalysis::add_private_function with ()
+clarity/src/vm/types/mod.rs:1361: replace <impl Display for PrincipalData>::fmt -> fmt::Result with Ok(Default::default())
+clarity/src/vm/contexts.rs:1825: replace ContractContext::lookup_trait_definition -> Option<BTreeMap<ClarityName, FunctionSignature>> with None
+clarity/src/vm/types/serialization.rs:1153: replace <impl Write for WriteCounter>::write -> std::io::Result<usize> with Ok(0)
+clarity/src/vm/database/clarity_db.rs:446: replace ClarityDatabase<'a>::roll_back with ()
+clarity/src/vm/types/signatures.rs:1782: replace TupleTypeSignature::inner_size -> Option<u32> with Some(1)
+clarity/src/vm/types/mod.rs:794: replace <impl PartialEq for ListData>::eq -> bool with false
+clarity/src/vm/contexts.rs:1595: replace GlobalContext<'a, 'hooks>::is_top_level -> bool with false
+clarity/src/vm/database/clarity_db.rs:306: replace <impl HeadersDB for NullHeadersDB>::get_burn_block_height_for_block -> Option<u32> with None
+clarity/src/vm/ast/definition_sorter/mod.rs:421: replace Graph::get_node_descendants -> Vec<usize> with vec![1]
+clarity/src/vm/database/key_value_wrapper.rs:363: replace RollbackWrapper<'a>::get -> Option<T> with None
+clarity/src/vm/database/clarity_db.rs:737: replace ClarityDatabase<'a>::get_total_liquid_ustx -> u128 with 0
+clarity/src/vm/database/key_value_wrapper.rs:243: replace RollbackWrapper<'a>::rollback with ()
+clarity/src/vm/ast/types.rs:67: replace ContractAST::get_referenced_trait -> Option<&TraitDefinition> with None
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:332: replace ContractContext::into_contract_analysis with ()
+clarity/src/vm/database/clarity_db.rs:782: replace ClarityDatabase<'a>::is_in_regtest -> bool with false
+clarity/src/vm/database/clarity_db.rs:1874: replace ClarityDatabase<'a>::make_key_for_account_balance -> String with "xyzzy".into()
+clarity/src/vm/types/signatures.rs:341: replace <impl From for u32>::from -> u32 with 1
+clarity/src/vm/database/clarity_db.rs:943: replace ClarityDatabase<'a>::get_burnchain_block_height -> Option<u32> with None
+clarity/src/vm/types/serialization.rs:1183: replace Value::serialize_to_hex -> String with "xyzzy".into()
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:316: replace ContractContext::get_persisted_variable_type -> Option<&TypeSignature> with None
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:84: replace ContractContext::ft_exists -> bool with false
+clarity/src/vm/types/serialization.rs:1017: replace Value::serialize_write -> std::io::Result<()> with Ok(())
+clarity/src/vm/functions/options.rs:227: replace is_okay -> Result<bool> with Ok(false)
+clarity/src/vm/types/serialization.rs:1139: replace Value::serialized_size -> u32 with 0
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:190: replace ContractContext::get_variable_type -> Option<&TypeSignature> with None
+clarity/src/vm/types/mod.rs:423: replace SequenceData::filter -> Result<()> with Ok(())
+clarity/src/vm/types/mod.rs:680: replace <impl SequencedValue for UTF8Data>::drained_items -> Vec<Vec<u8>> with vec![vec![0]]
+clarity/src/vm/database/clarity_db.rs:476: replace ClarityDatabase<'a>::put_value -> Result<()> with Ok(())
+clarity/src/vm/types/serialization.rs:348: replace DeserializeStackItem::next_expected_type -> Result<Option<TypeSignature>, SerializationError> with Ok(None)
+clarity/src/vm/types/signatures.rs:1722: replace ListTypeData::inner_size -> Option<u32> with None
+clarity/src/vm/contexts.rs:302: replace AssetMap::add_stx_burn -> Result<()> with Ok(())
+clarity/src/vm/types/signatures.rs:347: replace <impl From for u32>::from -> u32 with 1
+clarity/src/vm/types/mod.rs:657: replace <impl SequencedValue for ASCIIData>::drained_items -> Vec<u8> with vec![]
+clarity/src/vm/analysis/contract_interface_builder/mod.rs:266: replace ContractInterfaceFunction::from_map -> Vec<ContractInterfaceFunction> with vec![]
+clarity/src/vm/analysis/errors.rs:230: replace <impl Display for CheckError>::fmt -> fmt::Result with Ok(Default::default())
+clarity/src/vm/types/signatures.rs:1696: replace TypeSignature::inner_type_size -> Option<u32> with None
+clarity/src/vm/contexts.rs:1903: replace LocalContext<'a>::lookup_variable -> Option<&Value> with None
+clarity/src/vm/database/clarity_db.rs:550: replace ClarityDatabase<'a>::make_key_for_quad -> String with "xyzzy".into()
+clarity/src/vm/callables.rs:331: replace DefinedFunction::is_read_only -> bool with true
+clarity/src/vm/database/key_value_wrapper.rs:433: replace RollbackWrapper<'a>::prepare_for_contract_metadata with ()
+clarity/src/vm/types/mod.rs:1244: replace <impl Display for OptionalData>::fmt -> fmt::Result with Ok(Default::default())
+clarity/src/vm/types/serialization.rs:1153: replace <impl Write for WriteCounter>::write -> std::io::Result<usize> with Ok(1)
+clarity/src/vm/errors.rs:151: replace <impl Display for RuntimeErrorType>::fmt -> std::fmt::Result with Ok(Default::default())
+clarity/src/vm/contexts.rs:837: replace OwnedEnvironment<'a, 'hooks>::commit -> Result<(AssetMap, EventBatch)> with Ok((Default::default(), Default::default()))
+clarity/src/vm/database/sqlite.rs:77: replace SqliteConnection::put with ()
+clarity/src/vm/database/clarity_store.rs:295: replace <impl ClarityBackingStore for MemoryBackingStore>::get -> Option<String> with Some("xyzzy".into())
+clarity/src/vm/types/signatures.rs:848: replace TupleTypeSignature::len -> u64 with 0
+clarity/src/vm/ast/definition_sorter/mod.rs:429: replace Graph::nodes_count -> usize with 0
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:320: replace ContractContext::get_function_type -> Option<&FunctionType> with None
+clarity/src/vm/contexts.rs:1943: replace CallStack::contains -> bool with true
+clarity/src/vm/ast/definition_sorter/mod.rs:488: replace GraphWalker::get_cycling_dependencies -> Option<Vec<usize>> with Some(vec![0])
+clarity/src/vm/types/signatures.rs:1735: replace ListTypeData::type_size -> Option<u32> with None
+clarity/src/vm/types/mod.rs:125: replace <impl Display for QualifiedContractIdentifier>::fmt -> fmt::Result with Ok(Default::default())
+clarity/src/vm/database/clarity_db.rs:802: replace ClarityDatabase<'a>::get_current_block_height -> u32 with 0
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:43: replace is_string_terminator -> bool with false
+clarity/src/vm/database/clarity_db.rs:1485: replace ClarityDatabase<'a>::data_map_entry_exists -> Result<bool> with Ok(true)
+clarity/src/vm/database/clarity_db.rs:1693: replace ClarityDatabase<'a>::checked_decrease_token_supply -> Result<()> with Ok(())
+clarity/src/vm/test_util/mod.rs:71: replace is_committed -> bool with true
+clarity/src/vm/contexts.rs:271: replace AssetMap::get_next_stx_burn_amount -> Result<u128> with Ok(1)
+clarity/src/vm/representations.rs:396: replace PreSymbolicExpression::match_comment -> Option<&str> with None
+clarity/src/vm/functions/principals.rs:47: replace version_matches_current_network -> bool with false
+clarity/src/vm/variables.rs:63: replace lookup_reserved_variable -> Result<Option<Value>> with Ok(None)
+clarity/src/vm/database/clarity_db.rs:486: replace ClarityDatabase<'a>::put_value_with_size -> Result<u64> with Ok(1)
+clarity/src/vm/types/mod.rs:657: replace <impl SequencedValue for ASCIIData>::drained_items -> Vec<u8> with vec![1]
+clarity/src/vm/representations.rs:586: replace SymbolicExpression::match_atom_value -> Option<&Value> with None
+clarity/src/vm/database/structures.rs:837: replace STXBalance::checked_add_unlocked_amount -> Option<u128> with None
+clarity/src/vm/analysis/contract_interface_builder/mod.rs:170: replace ContractInterfaceAtomType::vec_from_tuple_type -> Vec<ContractInterfaceTupleEntryType> with vec![]
+clarity/src/vm/database/clarity_db.rs:458: replace ClarityDatabase<'a>::put with ()
+clarity/src/vm/analysis/read_only_checker/mod.rs:268: replace ReadOnlyChecker<'a, 'b>::try_check_native_function_is_read_only -> Option<CheckResult<bool>> with None
+clarity/src/vm/contexts.rs:1714: replace GlobalContext<'a, 'hooks>::commit -> Result<(Option<AssetMap>, Option<EventBatch>)> with Ok((Some(Default::default()), Some(Default::default())))
+clarity/src/vm/database/clarity_db.rs:537: replace ClarityDatabase<'a>::make_metadata_key -> String with "xyzzy".into()
+clarity/src/vm/types/signatures.rs:1652: replace TypeSignature::size -> u32 with 1
+clarity/src/vm/types/signatures.rs:1862: replace <impl Debug for TupleTypeSignature>::fmt -> fmt::Result with Ok(Default::default())
+clarity/src/vm/contexts.rs:333: replace AssetMap::add_token_transfer -> Result<()> with Ok(())
+clarity/src/vm/functions/principals.rs:34: replace version_matches_mainnet -> bool with true
+clarity/src/vm/analysis/types.rs:114: replace ContractAnalysis::add_map_type with ()
+clarity/src/vm/types/signatures.rs:1782: replace TupleTypeSignature::inner_size -> Option<u32> with Some(0)
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:304: replace ContractContext::get_trait -> Option<&BTreeMap<ClarityName, FunctionSignature>> with None
+clarity/src/vm/docs/mod.rs:779: replace get_output_type_string -> String with "xyzzy".into()
+clarity/src/vm/database/structures.rs:163: replace <impl ClaritySerializable for STXBalance>::serialize -> String with "xyzzy".into()
+clarity/src/vm/database/clarity_db.rs:1874: replace ClarityDatabase<'a>::make_key_for_account_balance -> String with String::new()
+clarity/src/vm/analysis/types.rs:190: replace ContractAnalysis::get_defined_trait -> Option<&BTreeMap<ClarityName, FunctionSignature>> with None
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:308: replace ContractContext::get_map_type -> Option<&(TypeSignature, TypeSignature)> with None
+clarity/src/vm/types/serialization.rs:1175: replace Value::serialize_to_vec -> Vec<u8> with vec![]
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:198: replace ContractContext::get_function_type -> Option<&FunctionType> with None
+clarity/src/vm/database/structures.rs:337: replace STXBalanceSnapshot<'db, 'conn>::transfer_to -> Result<()> with Ok(())
+clarity/src/vm/analysis/errors.rs:287: replace check_arguments_at_least -> Result<(), CheckErrors> with Ok(())
+clarity/src/vm/errors.rs:120: replace <impl PartialEq for Error>::eq -> bool with true
+clarity/src/vm/costs/mod.rs:1120: replace <impl CostOverflowingMath for u64>::cost_overflow_sub -> Result<u64> with Ok(1)
+clarity/src/vm/types/signatures.rs:511: replace TypeSignature::is_response_type -> bool with true
+clarity/src/vm/ast/traits_resolver/mod.rs:182: replace TraitsResolver::try_parse_pre_expr -> Option<(DefineFunctions, Vec<&'a PreSymbolicExpression>)> with None
+clarity/src/vm/test_util/mod.rs:88: replace is_err_code_i128 -> bool with false
+clarity/src/vm/contexts.rs:1825: replace ContractContext::lookup_trait_definition -> Option<BTreeMap<ClarityName, FunctionSignature>> with Some(BTreeMap::new())
+clarity/src/vm/database/clarity_store.rs:295: replace <impl ClarityBackingStore for MemoryBackingStore>::get -> Option<String> with None
+clarity/src/vm/types/mod.rs:1341: replace StandardPrincipalData::to_address -> String with String::new()
+clarity/src/vm/representations.rs:594: replace SymbolicExpression::match_literal_value -> Option<&Value> with None
+clarity/src/vm/contexts.rs:1943: replace CallStack::contains -> bool with false
+clarity/src/vm/types/signatures.rs:1782: replace TupleTypeSignature::inner_size -> Option<u32> with None
+clarity/src/vm/types/mod.rs:1233: replace UTF8Data::append -> Result<()> with Ok(())
+clarity/src/vm/costs/mod.rs:70: replace runtime_cost -> Result<()> with Ok(())
+clarity/src/vm/database/key_value_wrapper.rs:425: replace RollbackWrapper<'a>::get_block_header_hash -> Option<StacksBlockId> with None
+clarity/src/vm/database/clarity_db.rs:537: replace ClarityDatabase<'a>::make_metadata_key -> String with String::new()
+clarity/src/vm/functions/mod.rs:692: replace parse_eval_bindings -> Result<Vec<(ClarityName, Value)>> with Ok(vec![])
+clarity/src/vm/analysis/analysis_db.rs:106: replace AnalysisDatabase<'a>::load_contract -> Option<ContractAnalysis> with None
+clarity/src/vm/types/mod.rs:1186: replace BuffData::append -> Result<()> with Ok(())
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:102: replace TraitContext::get_trait -> Option<&BTreeMap<ClarityName, FunctionSignature>> with None
+clarity/src/vm/mod.rs:353: replace is_reserved -> bool with true
+clarity/src/vm/database/sqlite.rs:50: replace sqlite_get -> Option<String> with Some("xyzzy".into())
+clarity/src/vm/database/key_value_wrapper.rs:532: replace RollbackWrapper<'a>::has_metadata_entry -> bool with true
+clarity/src/vm/database/key_value_wrapper.rs:402: replace RollbackWrapper<'a>::get_value -> Result<Option<ValueResult>, SerializationError> with Ok(None)
+clarity/src/vm/database/structures.rs:767: replace STXBalance::effective_unlock_height -> u64 with 1
+clarity/src/vm/types/mod.rs:1035: replace Value::expect_u128 -> u128 with 1
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:525: replace clarity2_check_functions_compatible -> bool with false
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:195: replace ContractContext::get_nft_type -> Option<&TypeSignature> with None
+clarity/src/vm/test_util/mod.rs:71: replace is_committed -> bool with false
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:525: replace clarity2_check_functions_compatible -> bool with true
+clarity/src/vm/analysis/contract_interface_builder/mod.rs:236: replace ContractInterfaceFunctionArg::from_function_args -> Vec<ContractInterfaceFunctionArg> with vec![]
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:50: replace TraitContext::is_name_used -> bool with true
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1044: replace TypeChecker<'a, 'b>::get_function_type -> Option<FunctionType> with None
+clarity/src/vm/types/serialization.rs:204: replace <impl ClarityValueSerializable for StandardPrincipalData>::serialize_write -> std::io::Result<()> with Ok(())
+clarity/src/vm/docs/mod.rs:728: replace get_input_type_string -> String with String::new()
+clarity/src/vm/database/clarity_db.rs:1485: replace ClarityDatabase<'a>::data_map_entry_exists -> Result<bool> with Ok(false)
+clarity/src/vm/types/mod.rs:1080: replace Value::expect_buff_padded -> Vec<u8> with vec![1]
+clarity/src/vm/types/serialization.rs:1301: replace <impl ClaritySerializable for u32>::serialize -> String with "xyzzy".into()
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:36: replace is_separator -> bool with false
+clarity/src/vm/types/signatures.rs:341: replace <impl From for u32>::from -> u32 with 0
+clarity/src/vm/database/clarity_store.rs:331: replace <impl ClarityBackingStore for MemoryBackingStore>::put_all with ()
+clarity/src/vm/tests/mod.rs:164: replace test_only_mainnet_to_chain_id -> u32 with 0
+clarity/src/vm/types/mod.rs:1347: replace <impl Display for StandardPrincipalData>::fmt -> fmt::Result with Ok(Default::default())
+clarity/src/vm/types/mod.rs:247: replace SequenceData::atom_values -> Vec<SymbolicExpression> with vec![]
+clarity/src/vm/contexts.rs:1611: replace GlobalContext<'a, 'hooks>::log_asset_transfer with ()
+clarity/src/vm/types/mod.rs:1035: replace Value::expect_u128 -> u128 with 0
+clarity/src/vm/types/signatures.rs:1722: replace ListTypeData::inner_size -> Option<u32> with Some(1)
+clarity/src/vm/database/clarity_db.rs:550: replace ClarityDatabase<'a>::make_key_for_quad -> String with String::new()
+clarity/src/vm/representations.rs:208: replace <impl SymbolicExpressionCommon for SymbolicExpression>::set_id with ()
+clarity/src/vm/functions/boolean.rs:27: replace type_force_bool -> Result<bool> with Ok(false)
+clarity/src/vm/types/mod.rs:619: replace <impl SequencedValue for ListData>::drained_items -> Vec<Value> with vec![]
+clarity/src/vm/representations.rs:620: replace <impl Display for SymbolicExpression>::fmt -> fmt::Result with Ok(Default::default())
+clarity/src/vm/types/mod.rs:637: replace <impl SequencedValue for BuffData>::drained_items -> Vec<u8> with vec![1]
+clarity/src/vm/database/clarity_db.rs:1744: replace ClarityDatabase<'a>::set_ft_balance -> Result<()> with Ok(())
+clarity/src/vm/analysis/arithmetic_checker/mod.rs:144: replace ArithmeticOnlyChecker<'a>::check_variables_allowed -> Result<(), Error> with Ok(())
+clarity/src/vm/types/mod.rs:657: replace <impl SequencedValue for ASCIIData>::drained_items -> Vec<u8> with vec![0]
+clarity/src/vm/database/key_value_wrapper.rs:444: replace RollbackWrapper<'a>::insert_metadata with ()
+clarity/src/vm/database/structures.rs:396: replace STXBalanceSnapshot<'db, 'conn>::can_transfer -> bool with true
+clarity/src/vm/types/mod.rs:1354: replace <impl Debug for StandardPrincipalData>::fmt -> fmt::Result with Ok(Default::default())
+clarity/src/vm/database/clarity_db.rs:937: replace ClarityDatabase<'a>::get_pox_payout_addrs_for_burnchain_height -> Option<(Vec<TupleData>, u128)> with Some((vec![], 0))
+clarity/src/vm/types/signatures.rs:1883: replace <impl Display for TypeSignature>::fmt -> fmt::Result with Ok(Default::default())
+clarity/src/vm/database/clarity_db.rs:1664: replace ClarityDatabase<'a>::checked_increase_token_supply -> Result<()> with Ok(())
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:110: replace TraitContext::into_contract_analysis with ()
+clarity/src/vm/types/mod.rs:1182: replace BuffData::as_slice -> &[u8] with Vec::leak(vec![0])
+clarity/src/vm/analysis/types.rs:163: replace ContractAnalysis::get_public_function_type -> Option<&FunctionType> with None
+clarity/src/vm/analysis/arithmetic_checker/mod.rs:77: replace ArithmeticOnlyChecker<'a>::run -> Result<(), Error> with Ok(())
+clarity/src/vm/types/signatures.rs:1658: replace TypeSignature::inner_size -> Option<u32> with Some(0)
+clarity/src/vm/functions/principals.rs:40: replace version_matches_testnet -> bool with true
+clarity/src/vm/types/mod.rs:265: replace SequenceData::len -> usize with 0
+clarity/src/vm/database/key_value_wrapper.rs:189: replace rollback_lookup_map -> String with String::new()
+clarity/src/vm/database/clarity_db.rs:516: replace ClarityDatabase<'a>::get_value -> Result<Option<ValueResult>> with Ok(None)
+clarity/src/vm/types/serialization.rs:396: replace TypeSignature::max_serialized_size -> Result<u32, CheckErrors> with Ok(1)
+clarity/src/vm/callables.rs:308: replace DefinedFunction::check_trait_expectations -> Result<()> with Ok(())
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:191: replace ContractContext::ft_exists -> bool with false
+clarity/src/vm/types/mod.rs:1341: replace StandardPrincipalData::to_address -> String with "xyzzy".into()
+clarity/src/vm/contexts.rs:1639: replace GlobalContext<'a, 'hooks>::log_stx_burn -> Result<()> with Ok(())
+clarity/src/vm/database/clarity_db.rs:1760: replace ClarityDatabase<'a>::get_ft_supply -> Result<u128> with Ok(0)
+clarity/src/vm/types/mod.rs:1197: replace ListData::len -> u32 with 1
+clarity/src/vm/types/mod.rs:1080: replace Value::expect_buff_padded -> Vec<u8> with vec![]
+clarity/src/vm/types/mod.rs:1388: replace <impl Display for TraitIdentifier>::fmt -> fmt::Result with Ok(Default::default())
+clarity/src/vm/types/signatures.rs:388: replace <impl From for u32>::from -> u32 with 0
+clarity/src/vm/contexts.rs:295: replace AssetMap::add_stx_transfer -> Result<()> with Ok(())
+clarity/src/vm/types/mod.rs:1222: replace ASCIIData::append -> Result<()> with Ok(())
+clarity/src/vm/representations.rs:380: replace PreSymbolicExpression::match_field_identifier -> Option<&TraitIdentifier> with None
+clarity/src/vm/types/signatures.rs:1658: replace TypeSignature::inner_size -> Option<u32> with None
+clarity/src/vm/types/signatures.rs:515: replace TypeSignature::is_no_type -> bool with false
+clarity/src/vm/database/clarity_db.rs:1290: replace ClarityDatabase<'a>::make_key_for_data_map_entry -> String with "xyzzy".into()
+clarity/src/vm/analysis/types.rs:159: replace ContractAnalysis::add_implemented_trait with ()
+clarity/src/vm/database/structures.rs:163: replace <impl ClaritySerializable for STXBalance>::serialize -> String with String::new()
+clarity/src/vm/types/mod.rs:351: replace SequenceData::contains -> Result<Option<usize>> with Ok(Some(0))
+clarity/src/vm/types/serialization.rs:1301: replace <impl ClaritySerializable for u32>::serialize -> String with String::new()
+clarity/src/vm/analysis/errors.rs:319: replace <impl DiagnosableError for CheckErrors>::message -> String with String::new()
+clarity/src/vm/contexts.rs:408: replace AssetMap::to_table -> HashMap<PrincipalData, HashMap<AssetIdentifier, AssetMapEntry>> with HashMap::new()
+clarity/src/vm/ast/definition_sorter/mod.rs:488: replace GraphWalker::get_cycling_dependencies -> Option<Vec<usize>> with Some(vec![1])
+clarity/src/vm/ast/parser/v2/mod.rs:171: replace Parser<'a>::ignore_whitespace -> bool with false
+clarity/src/vm/representations.rs:570: replace SymbolicExpression::match_list -> Option<&[SymbolicExpression]> with None
+clarity/src/vm/docs/mod.rs:779: replace get_output_type_string -> String with String::new()
+clarity/src/vm/analysis/types.rs:131: replace ContractAnalysis::add_read_only_function with ()
+clarity/src/vm/contexts.rs:687: replace OwnedEnvironment<'a, 'hooks>::initialize_contract -> Result<((), AssetMap, Vec<StacksTransactionEvent>)> with Ok(((), Default::default(), vec![]))
+clarity/src/vm/ast/definition_sorter/mod.rs:421: replace Graph::get_node_descendants -> Vec<usize> with vec![]
+clarity/src/vm/types/mod.rs:875: replace Value::depth -> u8 with 0
+clarity/src/vm/database/clarity_db.rs:601: replace ClarityDatabase<'a>::insert_metadata with ()
+clarity/src/vm/types/mod.rs:533: replace SequenceData::is_list -> bool with false
+clarity/src/vm/analysis/types.rs:195: replace ContractAnalysis::canonicalize_types with ()
+clarity/src/vm/types/mod.rs:754: replace BlockInfoProperty::lookup_by_name_at_version -> Option<BlockInfoProperty> with None
+clarity/src/vm/types/signatures.rs:865: replace TupleTypeSignature::admits -> Result<bool> with Ok(true)
+clarity/src/vm/types/signatures.rs:1923: replace <impl Display for StringUTF8Length>::fmt -> fmt::Result with Ok(Default::default())
+clarity/src/vm/types/serialization.rs:1311: replace <impl ClarityDeserializable for u32>::deserialize -> Self with Default::default()
+clarity/src/vm/database/sqlite.rs:133: replace SqliteConnection::get_metadata -> Option<String> with Some(String::new())
+clarity/src/vm/representations.rs:364: replace PreSymbolicExpression::match_atom -> Option<&ClarityName> with None
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:191: replace ContractContext::ft_exists -> bool with true
+clarity/src/vm/callables.rs:343: replace DefinedFunction::is_public -> bool with true
+clarity/src/vm/functions/define.rs:291: replace DefineFunctionsParsed<'a>::try_parse -> std::result::Result<Option<DefineFunctionsParsed<'a>>, CheckErrors> with Ok(None)
+clarity/src/vm/types/signatures.rs:388: replace <impl From for u32>::from -> u32 with 1
+clarity/src/vm/analysis/types.rs:155: replace ContractAnalysis::add_defined_trait with ()
+clarity/src/vm/types/mod.rs:1274: replace <impl Display for Value>::fmt -> fmt::Result with Ok(Default::default())
+clarity/src/vm/ast/definition_sorter/mod.rs:488: replace GraphWalker::get_cycling_dependencies -> Option<Vec<usize>> with Some(vec![])
+clarity/src/vm/ast/parser/v1.rs:499: replace handle_expression with ()
+clarity/src/vm/ast/parser/v2/mod.rs:171: replace Parser<'a>::ignore_whitespace -> bool with true
+clarity/src/vm/types/mod.rs:1108: replace Value::expect_optional -> Option<Value> with None
+clarity/src/vm/types/signatures.rs:1748: replace TupleTypeSignature::type_size -> Option<u32> with None
+clarity/src/vm/representations.rs:211: replace <impl SymbolicExpressionCommon for SymbolicExpression>::match_list_mut -> Option<&mut[SymbolicExpression]> with None
+clarity/src/vm/ast/types.rs:102: replace <impl Iterator for PreExpressionsDrain>::next -> Option<PreSymbolicExpression> with None
+clarity/src/vm/ast/definition_sorter/mod.rs:470: replace GraphWalker::sort_dependencies_recursion with ()
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:164: replace ContractContext::is_contract -> bool with true
+clarity/src/vm/analysis/type_checker/contexts.rs:129: replace TypingContext<'a>::lookup_trait_reference_type -> Option<&TraitIdentifier> with None
+clarity/src/vm/analysis/arithmetic_checker/mod.rs:165: replace ArithmeticOnlyChecker<'a>::try_native_function_check -> Option<Result<(), Error>> with None
+clarity/src/vm/database/clarity_store.rs:187: replace <impl ClaritySerializable for ContractCommitment>::serialize -> String with String::new()
+clarity/src/vm/functions/options.rs:44: replace inner_unwrap_err -> Result<Option<Value>> with Ok(None)
+clarity/src/vm/analysis/analysis_db.rs:66: replace AnalysisDatabase<'a>::roll_back with ()
+clarity/src/vm/functions/mod.rs:212: replace lookup_reserved_functions -> Option<CallableType> with None
+clarity/src/vm/contexts.rs:771: replace OwnedEnvironment<'a, 'hooks>::stx_faucet with ()
+clarity/src/vm/types/signatures.rs:848: replace TupleTypeSignature::len -> u64 with 1
+clarity/src/vm/types/mod.rs:351: replace SequenceData::contains -> Result<Option<usize>> with Ok(Some(1))
+clarity/src/vm/types/mod.rs:1262: replace <impl Display for BuffData>::fmt -> fmt::Result with Ok(Default::default())
+clarity/src/vm/test_util/mod.rs:80: replace is_err_code -> bool with false
+clarity/src/vm/types/signatures.rs:394: replace <impl From for u32>::from -> u32 with 0
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:535: replace TypeChecker<'a, 'b>::get_function_type -> Option<FunctionType> with None
+clarity/src/vm/types/mod.rs:1182: replace BuffData::as_slice -> &[u8] with Vec::leak(Vec::new())
+clarity/src/vm/contexts.rs:263: replace AssetMap::get_next_stx_amount -> Result<u128> with Ok(1)
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:182: replace ContractContext::get_trait -> Option<&BTreeMap<ClarityName, FunctionSignature>> with None
+clarity/src/vm/types/signatures.rs:470: replace ListTypeData::reduce_max_len with ()
+clarity/src/vm/database/key_value_wrapper.rs:59: replace rollback_check_pre_bottom_commit -> Vec<(T, String)> with vec![]
+clarity/src/vm/database/clarity_db.rs:937: replace ClarityDatabase<'a>::get_pox_payout_addrs_for_burnchain_height -> Option<(Vec<TupleData>, u128)> with Some((vec![], 1))
+clarity/src/vm/types/mod.rs:1478: replace TupleData::len -> u64 with 1
+clarity/src/vm/types/mod.rs:680: replace <impl SequencedValue for UTF8Data>::drained_items -> Vec<Vec<u8>> with vec![]
+clarity/src/vm/database/clarity_db.rs:620: replace ClarityDatabase<'a>::fetch_metadata -> Result<Option<T>> with Ok(None)
+clarity/src/vm/analysis/errors.rs:303: replace formatted_expected_types -> String with "xyzzy".into()
+clarity/src/vm/database/clarity_db.rs:879: replace ClarityDatabase<'a>::get_sortition_id_for_stacks_tip -> Option<SortitionId> with None
+clarity/src/vm/database/clarity_db.rs:737: replace ClarityDatabase<'a>::get_total_liquid_ustx -> u128 with 1
+clarity/src/vm/functions/options.rs:227: replace is_okay -> Result<bool> with Ok(true)
+clarity/src/vm/database/sqlite.rs:159: replace SqliteConnection::initialize_conn -> Result<()> with Ok(())
+clarity/src/vm/contexts.rs:1833: replace ContractContext::is_name_used -> bool with true
+clarity/src/vm/database/clarity_db.rs:1826: replace ClarityDatabase<'a>::set_nft_owner -> Result<()> with Ok(())
+clarity/src/vm/analysis/types.rs:126: replace ContractAnalysis::add_persisted_variable_type with ()
+clarity/src/vm/types/signatures.rs:1658: replace TypeSignature::inner_size -> Option<u32> with Some(1)
+clarity/src/vm/types/mod.rs:581: replace <impl Display for UTF8Data>::fmt -> fmt::Result with Ok(Default::default())
+clarity/src/vm/ast/mod.rs:53: replace parse -> Result<Vec<SymbolicExpression>, Error> with Ok(vec![])
+clarity/src/vm/contexts.rs:1814: replace ContractContext::lookup_variable -> Option<&Value> with None
+clarity/src/vm/contexts.rs:1749: replace GlobalContext<'a, 'hooks>::roll_back with ()
+clarity/src/vm/types/serialization.rs:1183: replace Value::serialize_to_hex -> String with String::new()
+clarity/src/vm/representations.rs:211: replace <impl SymbolicExpressionCommon for SymbolicExpression>::match_list_mut -> Option<&mut[SymbolicExpression]> with Some(Vec::leak(Vec::new()))
+clarity/src/vm/costs/mod.rs:1117: replace <impl CostOverflowingMath for u64>::cost_overflow_add -> Result<u64> with Ok(0)
+clarity/src/vm/representations.rs:348: replace PreSymbolicExpression::match_trait_reference -> Option<&ClarityName> with None
+clarity/src/vm/types/signatures.rs:1551: replace TypeSignature::parse_trait_type_repr -> Result<BTreeMap<ClarityName, FunctionSignature>> with Ok(BTreeMap::new())
+clarity/src/vm/types/signatures.rs:1852: replace <impl Display for TupleTypeSignature>::fmt -> fmt::Result with Ok(Default::default())
+clarity/src/vm/representations.rs:396: replace PreSymbolicExpression::match_comment -> Option<&str> with Some("xyzzy")
+clarity/src/vm/functions/mod.rs:672: replace handle_binding_list -> std::result::Result<(), E> with Ok(())
+clarity/src/vm/contexts.rs:1947: replace CallStack::insert with ()
+clarity/src/vm/types/signatures.rs:535: replace TypeSignature::admits_type_v2_0 -> Result<bool> with Ok(true)
+clarity/src/vm/database/clarity_store.rs:187: replace <impl ClaritySerializable for ContractCommitment>::serialize -> String with "xyzzy".into()
+clarity/src/vm/variables.rs:44: replace NativeVariables::lookup_by_name_at_version -> Option<NativeVariables> with None
+clarity/src/vm/representations.rs:396: replace PreSymbolicExpression::match_comment -> Option<&str> with Some("")
+clarity/src/vm/types/signatures.rs:511: replace TypeSignature::is_response_type -> bool with false
+clarity/src/vm/analysis/arithmetic_checker/mod.rs:96: replace ArithmeticOnlyChecker<'a>::check_top_levels -> Result<(), Error> with Ok(())
+clarity/src/vm/types/signatures.rs:524: replace TypeSignature::admits_type -> Result<bool> with Ok(false)
+clarity/src/vm/analysis/type_checker/contexts.rs:65: replace TypeMap::get_type -> Option<&TypeSignature> with None
+clarity/src/vm/contexts.rs:1299: replace Environment<'a, 'b, 'hooks>::initialize_contract_from_ast -> Result<()> with Ok(())
+clarity/src/vm/types/signatures.rs:896: replace TupleTypeSignature::shallow_merge with ()
+clarity/src/vm/database/key_value_wrapper.rs:233: replace RollbackWrapper<'a>::nest with ()
+clarity/src/vm/callables.rs:343: replace DefinedFunction::is_public -> bool with false
+clarity/src/vm/analysis/errors.rs:303: replace formatted_expected_types -> String with String::new()
+clarity/src/vm/contexts.rs:1833: replace ContractContext::is_name_used -> bool with false
+clarity/src/vm/contexts.rs:833: replace OwnedEnvironment<'a, 'hooks>::begin with ()
+clarity/src/vm/database/clarity_db.rs:1851: replace ClarityDatabase<'a>::burn_nft -> Result<()> with Ok(())
+clarity/src/vm/database/clarity_store.rs:307: replace <impl ClarityBackingStore for MemoryBackingStore>::get_block_at_height -> Option<StacksBlockId> with None
+clarity/src/vm/representations.rs:197: replace <impl SymbolicExpressionCommon for PreSymbolicExpression>::match_list_mut -> Option<&mut[PreSymbolicExpression]> with None
+clarity/src/vm/analysis/contract_interface_builder/mod.rs:333: replace ContractInterfaceVariable::from_map -> Vec<ContractInterfaceVariable> with vec![]
+clarity/src/vm/variables.rs:55: replace is_reserved_name -> bool with true
+clarity/src/vm/analysis/types.rs:167: replace ContractAnalysis::get_read_only_function_type -> Option<&FunctionType> with None
+clarity/src/vm/contexts.rs:1848: replace ContractContext::canonicalize_types with ()
+clarity/src/vm/tests/mod.rs:164: replace test_only_mainnet_to_chain_id -> u32 with 1
+clarity/src/vm/types/mod.rs:637: replace <impl SequencedValue for BuffData>::drained_items -> Vec<u8> with vec![]
+clarity/src/vm/database/clarity_store.rs:295: replace <impl ClarityBackingStore for MemoryBackingStore>::get -> Option<String> with Some(String::new())
+clarity/src/vm/types/serialization.rs:1175: replace Value::serialize_to_vec -> Vec<u8> with vec![0]
+clarity/src/vm/costs/mod.rs:1250: replace int_log2 -> Option<u64> with None
+clarity/src/vm/database/structures.rs:332: replace STXBalanceSnapshot<'db, 'conn>::save with ()
+clarity/src/vm/types/mod.rs:680: replace <impl SequencedValue for UTF8Data>::drained_items -> Vec<Vec<u8>> with vec![vec![1]]
+clarity/src/vm/types/mod.rs:1182: replace BuffData::as_slice -> &[u8] with Vec::leak(vec![1])
+clarity/src/vm/callables.rs:363: replace DefinedFunction::canonicalize_types with ()
+clarity/src/vm/analysis/errors.rs:224: replace <impl Display for CheckErrors>::fmt -> fmt::Result with Ok(Default::default())
+clarity/src/vm/types/mod.rs:637: replace <impl SequencedValue for BuffData>::drained_items -> Vec<u8> with vec![0]
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:84: replace ContractContext::ft_exists -> bool with true
+clarity/src/vm/database/structures.rs:420: replace STXBalanceSnapshot<'db, 'conn>::set_balance with ()
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:194: replace ContractContext::get_persisted_variable_type -> Option<&TypeSignature> with None
+clarity/src/vm/ast/definition_sorter/mod.rs:412: replace Graph::add_node with ()
+clarity/src/vm/analysis/contract_interface_builder/mod.rs:389: replace ContractInterface::serialize -> String with String::new()
+clarity/src/vm/representations.rs:372: replace PreSymbolicExpression::match_list -> Option<&[PreSymbolicExpression]> with Some(Vec::leak(Vec::new()))
+clarity/src/vm/database/structures.rs:892: replace STXBalance::get_available_balance_at_burn_block -> u128 with 1
+clarity/src/vm/costs/mod.rs:1120: replace <impl CostOverflowingMath for u64>::cost_overflow_sub -> Result<u64> with Ok(0)
+clarity/src/vm/database/sqlite.rs:50: replace sqlite_get -> Option<String> with None
+clarity/src/vm/variables.rs:55: replace is_reserved_name -> bool with false
+clarity/src/vm/types/mod.rs:1080: replace Value::expect_buff_padded -> Vec<u8> with vec![0]
+clarity/src/vm/types/signatures.rs:1652: replace TypeSignature::size -> u32 with 0
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:36: replace is_separator -> bool with true
+clarity/src/vm/contexts.rs:1707: replace GlobalContext<'a, 'hooks>::begin_read_only with ()
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1156: replace TypeChecker<'a, 'b>::try_native_function_check -> Option<TypeResult> with None
+clarity/src/vm/database/structures.rs:801: replace STXBalance::amount_unlocked -> u128 with 1
+clarity/src/vm/types/mod.rs:1053: replace Value::expect_buff -> Vec<u8> with vec![]
+clarity/src/vm/analysis/contract_interface_builder/mod.rs:389: replace ContractInterface::serialize -> String with "xyzzy".into()
+clarity/src/vm/database/structures.rs:801: replace STXBalance::amount_unlocked -> u128 with 0
+clarity/src/vm/database/sqlite.rs:133: replace SqliteConnection::get_metadata -> Option<String> with Some("xyzzy".into())
+clarity/src/vm/database/sqlite.rs:133: replace SqliteConnection::get_metadata -> Option<String> with None
+clarity/src/vm/types/mod.rs:1053: replace Value::expect_buff -> Vec<u8> with vec![0]
+clarity/src/vm/mod.rs:569: replace execute_v2 -> Result<Option<Value>> with Ok(None)
+clarity/src/vm/types/mod.rs:1197: replace ListData::len -> u32 with 0
+clarity/src/vm/database/sqlite.rs:50: replace sqlite_get -> Option<String> with Some(String::new())
+clarity/src/vm/database/key_value_wrapper.rs:189: replace rollback_lookup_map -> String with "xyzzy".into()
+clarity/src/vm/analysis/arithmetic_checker/mod.rs:174: replace ArithmeticOnlyChecker<'a>::check_native_function -> Result<(), Error> with Ok(())
+clarity/src/vm/callables.rs:331: replace DefinedFunction::is_read_only -> bool with false
+clarity/src/vm/database/clarity_db.rs:678: replace ClarityDatabase<'a>::set_contract_data_size -> Result<()> with Ok(())
+clarity/src/vm/types/signatures.rs:1812: replace parse_name_type_pairs -> Result<Vec<(ClarityName, TypeSignature)>> with Ok(vec![])
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:646: replace TypeChecker<'a, 'b>::try_native_function_check -> Option<TypeResult> with None
+clarity/src/vm/analysis/type_checker/contexts.rs:112: replace TypingContext<'a>::add_variable_type with ()
+clarity/src/vm/contexts.rs:349: replace AssetMap::commit_other -> Result<()> with Ok(())
+clarity/src/vm/test_util/mod.rs:65: replace symbols_from_values -> Vec<SymbolicExpression> with vec![]
+clarity/src/vm/types/signatures.rs:519: replace TypeSignature::admits -> Result<bool> with Ok(true)
+clarity/src/vm/database/sqlite.rs:91: replace SqliteConnection::insert_metadata with ()
+clarity/src/vm/types/mod.rs:351: replace SequenceData::contains -> Result<Option<usize>> with Ok(None)
+clarity/src/vm/contexts.rs:1714: replace GlobalContext<'a, 'hooks>::commit -> Result<(Option<AssetMap>, Option<EventBatch>)> with Ok((None, Some(Default::default())))
+clarity/src/vm/database/clarity_db.rs:1719: replace ClarityDatabase<'a>::get_ft_balance -> Result<u128> with Ok(0)
+clarity/src/vm/contexts.rs:1599: replace GlobalContext<'a, 'hooks>::get_asset_map -> &mut AssetMap with Box::leak(Box::new(Default::default()))
+clarity/src/vm/types/signatures.rs:624: replace TypeSignature::admits_type_v2_1 -> Result<bool> with Ok(false)
+clarity/src/vm/types/mod.rs:800: replace <impl PartialEq for TupleData>::eq -> bool with false
+clarity/src/vm/contexts.rs:1962: replace CallStack::remove -> Result<()> with Ok(())
+clarity/src/vm/analysis/contract_interface_builder/mod.rs:354: replace ContractInterfaceMap::from_map -> Vec<ContractInterfaceMap> with vec![]
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:186: replace ContractContext::get_map_type -> Option<&(TypeSignature, TypeSignature)> with None
+clarity/src/vm/functions/principals.rs:47: replace version_matches_current_network -> bool with true
+clarity/src/vm/functions/options.rs:220: replace is_some -> Result<bool> with Ok(false)
+clarity/src/vm/representations.rs:197: replace <impl SymbolicExpressionCommon for PreSymbolicExpression>::match_list_mut -> Option<&mut[PreSymbolicExpression]> with Some(Vec::leak(Vec::new()))
+clarity/src/vm/ast/parser/v2/mod.rs:131: replace Parser<'a>::next_token -> Option<PlacedToken> with None
+clarity/src/vm/database/clarity_db.rs:486: replace ClarityDatabase<'a>::put_value_with_size -> Result<u64> with Ok(0)
+clarity/src/vm/contexts.rs:284: replace AssetMap::get_next_amount -> Result<u128> with Ok(1)
+clarity/src/vm/ast/definition_sorter/mod.rs:429: replace Graph::nodes_count -> usize with 1
+clarity/src/vm/types/mod.rs:1205: replace ListData::append -> Result<()> with Ok(())
+clarity/src/vm/analysis/errors.rs:319: replace <impl DiagnosableError for CheckErrors>::message -> String with "xyzzy".into()
+clarity/src/vm/database/sqlite.rs:36: replace sqlite_put with ()
+clarity/src/vm/analysis/types.rs:135: replace ContractAnalysis::add_public_function with ()
+clarity/src/vm/database/sqlite.rs:81: replace SqliteConnection::get -> Option<String> with Some(String::new())
+clarity/src/vm/contexts.rs:1939: replace CallStack::depth -> usize with 0
+clarity/src/vm/contexts.rs:1958: replace CallStack::decr_apply_depth with ()
+clarity/src/vm/types/mod.rs:565: replace <impl Display for ASCIIData>::fmt -> fmt::Result with Ok(Default::default())
+clarity/src/vm/database/sqlite.rs:81: replace SqliteConnection::get -> Option<String> with Some("xyzzy".into())
+clarity/src/vm/types/mod.rs:545: replace <impl Display for CharType>::fmt -> fmt::Result with Ok(Default::default())
+clarity/src/vm/types/mod.rs:278: replace SequenceData::element_at -> Option<Value> with None
+clarity/src/vm/errors.rs:120: replace <impl PartialEq for Error>::eq -> bool with false
+clarity/src/vm/costs/mod.rs:1250: replace int_log2 -> Option<u64> with Some(0)
+clarity/src/vm/ast/definition_sorter/mod.rs:416: replace Graph::add_directed_edge with ()
+clarity/src/vm/contexts.rs:1954: replace CallStack::incr_apply_depth with ()
+clarity/src/vm/analysis/type_checker/contexts.rs:97: replace TypingContext<'a>::lookup_variable_type -> Option<&TypeSignature> with None
+clarity/src/vm/ast/definition_sorter/mod.rs:379: replace DefinitionSorter::find_expression_definition -> Option<(ClarityName, u64, &'b PreSymbolicExpression)> with None
+clarity/src/vm/representations.rs:356: replace PreSymbolicExpression::match_atom_value -> Option<&Value> with None
+clarity/src/vm/database/structures.rs:358: replace STXBalanceSnapshot<'db, 'conn>::get_available_balance -> u128 with 1
+clarity/src/vm/ast/definition_sorter/mod.rs:425: replace Graph::has_node_descendants -> bool with false
+clarity/src/vm/types/mod.rs:871: replace Value::size -> u32 with 0
+clarity/src/vm/types/signatures.rs:347: replace <impl From for u32>::from -> u32 with 0
+clarity/src/vm/types/serialization.rs:1198: replace Value::sanitize_value -> Option<(Value, bool)> with None
+clarity/src/vm/analysis/arithmetic_checker/mod.rs:132: replace ArithmeticOnlyChecker<'a>::check_expression -> Result<(), Error> with Ok(())
+clarity/src/vm/types/mod.rs:680: replace <impl SequencedValue for UTF8Data>::drained_items -> Vec<Vec<u8>> with vec![vec![]]
+clarity/src/vm/database/clarity_db.rs:1302: replace ClarityDatabase<'a>::make_key_for_data_map_entry_serialized -> String with "xyzzy".into()
+clarity/src/vm/costs/mod.rs:1250: replace int_log2 -> Option<u64> with Some(1)
+clarity/src/vm/types/mod.rs:463: replace SequenceData::concat -> Result<()> with Ok(())
+clarity/src/vm/analysis/errors.rs:295: replace check_arguments_at_most -> Result<(), CheckErrors> with Ok(())
+clarity/src/vm/analysis/type_checker/contexts.rs:125: replace TypingContext<'a>::add_trait_reference with ()
+clarity/src/vm/functions/mod.rs:197: replace NativeFunctions::lookup_by_name_at_version -> Option<NativeFunctions> with None
+clarity/src/vm/costs/mod.rs:1117: replace <impl CostOverflowingMath for u64>::cost_overflow_add -> Result<u64> with Ok(1)
+clarity/src/vm/types/mod.rs:265: replace SequenceData::len -> usize with 1
+clarity/src/vm/types/serialization.rs:1139: replace Value::serialized_size -> u32 with 1
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:305: replace type_reserved_variable -> Option<TypeSignature> with None
+clarity/src/vm/types/signatures.rs:394: replace <impl From for u32>::from -> u32 with 1
+clarity/src/vm/ast/parser/v2/mod.rs:188: replace Parser<'a>::ignore_whitespace_and_comments -> Vec<PreSymbolicExpression> with vec![]
+clarity/src/vm/types/signatures.rs:857: replace TupleTypeSignature::field_type -> Option<&TypeSignature> with None
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:845: replace type_reserved_variable -> Option<TypeSignature> with None
+clarity/src/vm/representations.rs:578: replace SymbolicExpression::match_atom -> Option<&ClarityName> with None
+clarity/src/vm/types/mod.rs:1547: replace <impl Display for TupleData>::fmt -> fmt::Result with Ok(Default::default())
diff --git a/mutation-testing/packages-output/clarity/missed.txt b/mutation-testing/packages-output/clarity/missed.txt
new file mode 100644
index 0000000000..a0fc67adf4
--- /dev/null
+++ b/mutation-testing/packages-output/clarity/missed.txt
@@ -0,0 +1,634 @@
+clarity/src/vm/database/clarity_db.rs:1038: replace ClarityDatabase<'a>::get_cc_special_cases_handler -> Option<SpecialCaseHandler> with None
+clarity/src/vm/costs/mod.rs:1137: replace ExecutionCost::proportion_largest_dimension -> u64 with 0
+clarity/src/vm/types/signatures.rs:1766: replace TupleTypeSignature::size -> u32 with 1
+clarity/src/vm/database/clarity_db.rs:332: replace <impl BurnStateDB for NullBurnStateDB>::get_burn_block_height -> Option<u32> with Some(0)
+clarity/src/vm/database/clarity_store.rs:231: replace <impl ClarityBackingStore for NullBackingStore>::get_with_proof -> Option<(String, Vec<u8>)> with None
+clarity/src/vm/contexts.rs:852: replace OwnedEnvironment<'a, 'hooks>::destruct -> Option<(ClarityDatabase<'a>, LimitedCostTracker)> with None
+clarity/src/vm/database/clarity_db.rs:172: replace <impl HeadersDB for &dyn HeadersDB>::get_burn_block_height_for_block -> Option<u32> with Some(0)
+clarity/src/vm/database/clarity_db.rs:194: replace <impl BurnStateDB for &dyn BurnStateDB>::get_v2_unlock_height -> u32 with 1
+clarity/src/vm/tests/datamaps.rs:25: replace assert_executes with ()
+clarity/src/vm/representations.rs:222: replace PreSymbolicExpression::cons -> PreSymbolicExpression with Default::default()
+clarity/src/vm/database/structures.rs:726: replace STXBalanceSnapshot<'db, 'conn>::unlock_available_tokens_if_any -> u128 with 1
+clarity/src/vm/analysis/errors.rs:217: replace CheckError::set_expressions with ()
+clarity/src/vm/contexts.rs:479: replace AssetMap::get_fungible_tokens -> Option<u128> with None
+clarity/src/vm/database/clarity_db.rs:317: replace <impl HeadersDB for NullHeadersDB>::get_burnchain_tokens_spent_for_block -> Option<u128> with None
+clarity/src/vm/costs/mod.rs:1006: replace <impl CostTracker for LimitedCostTracker>::drop_memory with ()
+clarity/src/vm/database/clarity_store.rs:227: replace <impl ClarityBackingStore for NullBackingStore>::get -> Option<String> with None
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:95: replace <impl CostTracker for TypeChecker<'_, '_>>::add_cost -> std::result::Result<(), CostErrors> with Ok(())
+clarity/src/vm/database/clarity_store.rs:231: replace <impl ClarityBackingStore for NullBackingStore>::get_with_proof -> Option<(String, Vec<u8>)> with Some((String::new(), vec![1]))
+clarity/src/vm/database/clarity_db.rs:343: replace <impl BurnStateDB for NullBurnStateDB>::get_sortition_id_from_consensus_hash -> Option<SortitionId> with None
+clarity/src/vm/costs/mod.rs:1070: replace <impl CostTracker for &mut LimitedCostTracker>::short_circuit_contract_call -> Result<bool> with Ok(true)
+clarity/src/vm/tests/defines.rs:30: replace assert_eq_err with ()
+clarity/src/vm/database/clarity_db.rs:1006: replace ClarityDatabase<'a>::get_stx_btc_ops_processed -> u64 with 0
+clarity/src/vm/database/clarity_db.rs:1951: replace ClarityDatabase<'a>::get_burn_block_height -> Option<u32> with None
+clarity/src/vm/database/clarity_db.rs:716: replace ClarityDatabase<'a>::ustx_liquid_supply_key -> &'static str with "xyzzy"
+clarity/src/vm/coverage.rs:196: replace CoverageReporter::produce_lcov -> std::io::Result<()> with Ok(())
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:112: replace <impl CostTracker for TypeChecker<'_, '_>>::short_circuit_contract_call -> std::result::Result<bool, CostErrors> with Ok(false)
+clarity/src/vm/costs/mod.rs:104: replace <impl MemoryConsumer for Value>::get_memory_use -> u64 with 0
+clarity/src/vm/test_util/mod.rs:198: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_burn_block_height -> Option<u32> with None
+clarity/src/vm/tests/contracts.rs:890: replace test_factorial_contract with ()
+clarity/src/vm/database/clarity_db.rs:368: replace <impl BurnStateDB for NullBurnStateDB>::get_v1_unlock_height -> u32 with 0
+clarity/src/vm/database/clarity_db.rs:336: replace <impl BurnStateDB for NullBurnStateDB>::get_burn_start_height -> u32 with 0
+clarity/src/vm/contexts.rs:465: replace AssetMap::get_stx_burned_total -> u128 with 1
+clarity/src/vm/analysis/errors.rs:208: replace CheckError::has_expression -> bool with false
+clarity/src/vm/contexts.rs:465: replace AssetMap::get_stx_burned_total -> u128 with 0
+clarity/src/vm/tests/traits.rs:767: replace test_readwrite_violation_dynamic_dispatch with ()
+clarity/src/vm/database/clarity_db.rs:194: replace <impl BurnStateDB for &dyn BurnStateDB>::get_v2_unlock_height -> u32 with 0
+clarity/src/vm/tests/contracts.rs:1079: replace test_cc_stack_depth with ()
+clarity/src/vm/tests/defines.rs:191: replace test_recursive_panic with ()
+clarity/src/vm/database/structures.rs:512: replace STXBalanceSnapshot<'db, 'conn>::extend_lock_v2 with ()
+clarity/src/vm/costs/mod.rs:813: replace LimitedCostTracker::set_total with ()
+clarity/src/vm/costs/mod.rs:152: replace <impl CostTracker for ()>::short_circuit_contract_call -> Result<bool> with Ok(true)
+clarity/src/vm/database/clarity_db.rs:1023: replace ClarityDatabase<'a>::make_microblock_poison_key -> String with "xyzzy".into()
+clarity/src/vm/types/serialization.rs:253: replace PrincipalData::inner_consensus_serialize -> std::io::Result<()> with Ok(())
+clarity/src/vm/database/clarity_db.rs:580: replace ClarityDatabase<'a>::get_contract_src -> Option<String> with Some(String::new())
+clarity/src/vm/database/clarity_db.rs:1072: replace ClarityDatabase<'a>::get_microblock_pubkey_hash_height -> Option<u32> with Some(0)
+clarity/src/vm/database/clarity_db.rs:295: replace <impl HeadersDB for NullHeadersDB>::get_consensus_hash_for_block -> Option<ConsensusHash> with None
+clarity/src/vm/tests/traits.rs:824: replace test_bad_call_with_trait with ()
+clarity/src/vm/database/clarity_store.rs:251: replace <impl ClarityBackingStore for NullBackingStore>::get_current_block_height -> u32 with 0
+clarity/src/vm/contexts.rs:1411: replace Environment<'a, 'b, 'hooks>::push_to_event_batch with ()
+clarity/src/vm/database/clarity_db.rs:169: replace <impl HeadersDB for &dyn HeadersDB>::get_burn_block_time_for_block -> Option<u64> with Some(0)
+clarity/src/vm/costs/mod.rs:959: replace drop_memory with ()
+clarity/src/vm/database/clarity_db.rs:819: replace ClarityDatabase<'a>::get_v2_unlock_height -> u32 with 0
+clarity/src/vm/database/sqlite.rs:72: replace sqlite_has_entry -> bool with false
+clarity/src/vm/mod.rs:545: replace execute_against_version -> Result<Option<Value>> with Ok(None)
+clarity/src/vm/ast/parser/v2/lexer/error.rs:67: replace <impl DiagnosableError for LexerError>::suggestion -> Option<String> with Some("xyzzy".into())
+clarity/src/vm/contexts.rs:1560: replace Environment<'a, 'b, 'hooks>::register_ft_burn_event -> Result<()> with Ok(())
+clarity/src/vm/database/clarity_db.rs:317: replace <impl HeadersDB for NullHeadersDB>::get_burnchain_tokens_spent_for_block -> Option<u128> with Some(1)
+clarity/src/vm/database/clarity_db.rs:323: replace <impl HeadersDB for NullHeadersDB>::get_burnchain_tokens_spent_for_winning_block -> Option<u128> with Some(0)
+clarity/src/vm/database/clarity_db.rs:1085: replace ClarityDatabase<'a>::get_microblock_poison_report -> Option<(StandardPrincipalData, u16)> with None
+clarity/src/vm/database/clarity_db.rs:1023: replace ClarityDatabase<'a>::make_microblock_poison_key -> String with String::new()
+clarity/src/vm/contexts.rs:1829: replace ContractContext::is_explicitly_implementing_trait -> bool with false
+clarity/src/vm/costs/mod.rs:1230: replace ExecutionCost::exceeds -> bool with false
+clarity/src/vm/database/structures.rs:979: replace STXBalance::was_locked_by_v3 -> bool with false
+clarity/src/vm/test_util/mod.rs:160: replace <impl HeadersDB for UnitTestHeaderDB>::get_burn_block_height_for_block -> Option<u32> with None
+clarity/src/vm/test_util/mod.rs:80: replace is_err_code -> bool with true
+clarity/src/vm/test_util/mod.rs:186: replace <impl HeadersDB for UnitTestHeaderDB>::get_burnchain_tokens_spent_for_winning_block -> Option<u128> with None
+clarity/src/vm/database/clarity_db.rs:160: replace <impl HeadersDB for &dyn HeadersDB>::get_burn_header_hash_for_block -> Option<BurnchainHeaderHash> with None
+clarity/src/vm/representations.rs:266: replace PreSymbolicExpression::span -> &Span with &Default::default()
+clarity/src/vm/contexts.rs:893: replace <impl CostTracker for Environment<'_, '_, '_>>::short_circuit_contract_call -> std::result::Result<bool, CostErrors> with Ok(false)
+clarity/src/vm/ast/errors.rs:117: replace ParseError::set_pre_expression with ()
+clarity/src/vm/callables.rs:105: replace cost_input_sized_vararg -> Result<u64> with Ok(0)
+clarity/src/vm/contexts.rs:479: replace AssetMap::get_fungible_tokens -> Option<u128> with Some(0)
+clarity/src/vm/analysis/analysis_db.rs:70: replace AnalysisDatabase<'a>::storage_key -> &'static str with ""
+clarity/src/vm/events.rs:172: replace STXMintEventData::json_serialize -> serde_json::Value with Default::default()
+clarity/src/vm/costs/mod.rs:1230: replace ExecutionCost::exceeds -> bool with true
+clarity/src/vm/database/clarity_store.rs:231: replace <impl ClarityBackingStore for NullBackingStore>::get_with_proof -> Option<(String, Vec<u8>)> with Some(("xyzzy".into(), vec![0]))
+clarity/src/vm/types/mod.rs:1026: replace Value::expect_ascii -> String with String::new()
+clarity/src/vm/database/clarity_db.rs:984: replace ClarityDatabase<'a>::get_block_reward -> Option<u128> with Some(0)
+clarity/src/vm/database/clarity_db.rs:860: replace ClarityDatabase<'a>::get_block_time -> u64 with 0
+clarity/src/vm/database/structures.rs:949: replace STXBalance::get_total_balance -> u128 with 0
+clarity/src/vm/contexts.rs:912: replace <impl CostTracker for GlobalContext<'_, '_>>::add_memory -> std::result::Result<(), CostErrors> with Ok(())
+clarity/src/vm/events.rs:189: replace STXLockEventData::json_serialize -> serde_json::Value with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:164: replace ContractContext::is_contract -> bool with false
+clarity/src/vm/database/clarity_store.rs:177: replace make_contract_hash_key -> String with "xyzzy".into()
+clarity/src/vm/database/clarity_db.rs:732: replace ClarityDatabase<'a>::set_clarity_epoch_version with ()
+clarity/src/vm/database/clarity_db.rs:395: replace <impl BurnStateDB for NullBurnStateDB>::get_pox_payout_addrs -> Option<(Vec<TupleData>, u128)> with Some((vec![], 1))
+clarity/src/vm/contexts.rs:1595: replace GlobalContext<'a, 'hooks>::is_top_level -> bool with true
+clarity/src/vm/contexts.rs:1878: replace LocalContext<'a>::depth -> u16 with 1
+clarity/src/vm/types/serialization.rs:290: replace <impl StacksMessageCodec for PrincipalData>::consensus_serialize -> Result<(), codec_error> with Ok(())
+clarity/src/vm/database/clarity_db.rs:172: replace <impl HeadersDB for &dyn HeadersDB>::get_burn_block_height_for_block -> Option<u32> with None
+clarity/src/vm/test_util/mod.rs:191: replace <impl HeadersDB for UnitTestHeaderDB>::get_tokens_earned_for_block -> Option<u128> with Some(0)
+clarity/src/vm/costs/mod.rs:1053: replace <impl CostTracker for &mut LimitedCostTracker>::add_cost -> std::result::Result<(), CostErrors> with Ok(())
+clarity/src/vm/database/key_value_wrapper.rs:96: replace rollback_check_pre_bottom_commit -> Vec<(T, String)> with vec![(Default::default(), "xyzzy".into())]
+clarity/src/vm/database/clarity_db.rs:355: replace <impl BurnStateDB for NullBurnStateDB>::get_stacks_epoch -> Option<StacksEpoch> with None
+clarity/src/vm/tests/traits.rs:1744: replace test_pass_embedded_trait_to_subtrait_list with ()
+clarity/src/vm/database/clarity_db.rs:240: replace <impl BurnStateDB for &dyn BurnStateDB>::get_stacks_epoch_by_epoch_id -> Option<StacksEpoch> with None
+clarity/src/vm/contexts.rs:1525: replace Environment<'a, 'b, 'hooks>::register_ft_transfer_event -> Result<()> with Ok(())
+clarity/src/vm/database/clarity_db.rs:962: replace ClarityDatabase<'a>::get_miner_spend_winner -> u128 with 0
+clarity/src/vm/costs/mod.rs:1201: replace ExecutionCost::add -> Result<()> with Ok(())
+clarity/src/vm/ast/errors.rs:173: replace <impl DiagnosableError for ParseErrors>::message -> String with String::new()
+clarity/src/vm/database/structures.rs:1109: replace STXBalance::can_transfer_at_burn_block -> bool with true
+clarity/src/vm/tests/contracts.rs:160: replace test_contract_caller with ()
+clarity/src/vm/events.rs:315: replace FTMintEventData::json_serialize -> serde_json::Value with Default::default()
+clarity/src/vm/database/structures.rs:920: replace STXBalance::get_locked_balance_at_burn_block -> (u128, u64) with (1, 1)
+clarity/src/vm/database/key_value_wrapper.rs:96: replace rollback_check_pre_bottom_commit -> Vec<(T, String)> with vec![(Default::default(), String::new())]
+clarity/src/vm/database/clarity_db.rs:1938: replace ClarityDatabase<'a>::get_account_nonce -> u64 with 1
+clarity/src/vm/coverage.rs:104: replace CoverageReporter::executable_lines -> Vec<u32> with vec![1]
+clarity/src/vm/docs/mod.rs:809: replace get_signature -> Option<String> with Some("xyzzy".into())
+clarity/src/vm/database/structures.rs:920: replace STXBalance::get_locked_balance_at_burn_block -> (u128, u64) with (0, 0)
+clarity/src/vm/costs/mod.rs:142: replace <impl CostTracker for ()>::add_memory -> std::result::Result<(), CostErrors> with Ok(())
+clarity/src/vm/test_util/mod.rs:160: replace <impl HeadersDB for UnitTestHeaderDB>::get_burn_block_height_for_block -> Option<u32> with Some(0)
+clarity/src/vm/costs/mod.rs:1210: replace ExecutionCost::sub -> Result<()> with Ok(())
+clarity/src/vm/test_util/mod.rs:168: replace <impl HeadersDB for UnitTestHeaderDB>::get_miner_address -> Option<StacksAddress> with None
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:96: replace <impl CostTracker for TypeChecker<'_, '_>>::drop_memory with ()
+clarity/src/vm/costs/mod.rs:164: replace <impl Display for ClarityCostFunctionReference>::fmt -> ::std::fmt::Result with Ok(Default::default())
+clarity/src/vm/tests/contracts.rs:742: replace test_aborts with ()
+clarity/src/vm/database/structures.rs:691: replace STXBalanceSnapshot<'db, 'conn>::accelerate_unlock with ()
+clarity/src/vm/docs/mod.rs:2532: replace make_keyword_reference -> Option<KeywordAPI> with None
+clarity/src/vm/docs/mod.rs:2626: replace make_json_api_reference -> String with String::new()
+clarity/src/vm/database/clarity_db.rs:178: replace <impl HeadersDB for &dyn HeadersDB>::get_burnchain_tokens_spent_for_block -> Option<u128> with Some(0)
+clarity/src/vm/contexts.rs:1983: replace CallStack::make_stack_trace -> StackTrace with Default::default()
+clarity/src/vm/database/clarity_db.rs:376: replace <impl BurnStateDB for NullBurnStateDB>::get_pox_3_activation_height -> u32 with 1
+clarity/src/vm/analysis/arithmetic_checker/mod.rs:66: replace <impl Display for Error>::fmt -> std::fmt::Result with Ok(Default::default())
+clarity/src/vm/analysis/contract_interface_builder/mod.rs:318: replace ContractInterfaceNonFungibleTokens::from_map -> Vec<Self> with vec![]
+clarity/src/vm/types/mod.rs:533: replace SequenceData::is_list -> bool with true
+clarity/src/vm/contexts.rs:1490: replace Environment<'a, 'b, 'hooks>::register_nft_mint_event -> Result<()> with Ok(())
+clarity/src/vm/database/clarity_store.rs:327: replace <impl ClarityBackingStore for MemoryBackingStore>::get_cc_special_cases_handler -> Option<SpecialCaseHandler> with None
+clarity/src/vm/costs/mod.rs:1070: replace <impl CostTracker for &mut LimitedCostTracker>::short_circuit_contract_call -> Result<bool> with Ok(false)
+clarity/src/vm/tests/traits.rs:1462: replace test_embedded_trait with ()
+clarity/src/vm/tests/defines.rs:58: replace test_accept_options with ()
+clarity/src/vm/database/clarity_db.rs:1878: replace ClarityDatabase<'a>::make_key_for_account_nonce -> String with "xyzzy".into()
+clarity/src/vm/ast/parser/v2/mod.rs:1109: replace parse_collect_diagnostics -> (Vec<PreSymbolicExpression>, Vec<Diagnostic>, bool) with (vec![], vec![], false)
+clarity/src/vm/test_util/mod.rs:232: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_pox_3_activation_height -> u32 with 0
+clarity/src/vm/database/clarity_db.rs:376: replace <impl BurnStateDB for NullBurnStateDB>::get_pox_3_activation_height -> u32 with 0
+clarity/src/vm/database/key_value_wrapper.rs:96: replace rollback_check_pre_bottom_commit -> Vec<(T, String)> with vec![]
+clarity/src/vm/database/clarity_db.rs:202: replace <impl BurnStateDB for &dyn BurnStateDB>::get_burn_block_height -> Option<u32> with Some(0)
+clarity/src/vm/database/clarity_db.rs:647: replace ClarityDatabase<'a>::load_contract_analysis -> Option<ContractAnalysis> with None
+clarity/src/vm/database/clarity_db.rs:306: replace <impl HeadersDB for NullHeadersDB>::get_burn_block_height_for_block -> Option<u32> with Some(1)
+clarity/src/vm/tests/traits.rs:204: replace test_dynamic_dispatch_intra_contract_call with ()
+clarity/src/vm/test_util/mod.rs:244: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_pox_rejection_fraction -> u64 with 0
+clarity/src/vm/tests/traits.rs:710: replace test_readwrite_dynamic_dispatch with ()
+clarity/src/vm/database/clarity_db.rs:1047: replace ClarityDatabase<'a>::insert_microblock_poison -> Result<()> with Ok(())
+clarity/src/vm/database/clarity_db.rs:1072: replace ClarityDatabase<'a>::get_microblock_pubkey_hash_height -> Option<u32> with None
+clarity/src/vm/costs/mod.rs:152: replace <impl CostTracker for ()>::short_circuit_contract_call -> Result<bool> with Ok(false)
+clarity/src/vm/types/mod.rs:800: replace <impl PartialEq for TupleData>::eq -> bool with true
+clarity/src/vm/ast/parser/v1.rs:108: replace get_lines_at -> Vec<usize> with vec![0]
+clarity/src/vm/ast/parser/v2/lexer/token.rs:82: replace Token::reproduce -> String with "xyzzy".into()
+clarity/src/vm/database/structures.rs:818: replace STXBalance::debit_unlocked_amount with ()
+clarity/src/vm/database/structures.rs:42: replace <impl ClaritySerializable for String>::serialize -> String with String::new()
+clarity/src/vm/analysis/arithmetic_checker/mod.rs:267: replace ArithmeticOnlyChecker<'a>::check_all -> Result<(), Error> with Ok(())
+clarity/src/vm/database/clarity_db.rs:172: replace <impl HeadersDB for &dyn HeadersDB>::get_burn_block_height_for_block -> Option<u32> with Some(1)
+clarity/src/vm/database/clarity_db.rs:229: replace <impl BurnStateDB for &dyn BurnStateDB>::get_pox_prepare_length -> u32 with 0
+clarity/src/vm/test_util/mod.rs:253: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_sortition_id_from_consensus_hash -> Option<SortitionId> with None
+clarity/src/vm/database/clarity_db.rs:973: replace ClarityDatabase<'a>::get_miner_spend_total -> u128 with 0
+clarity/src/vm/types/signatures.rs:913: replace FunctionSignature::total_type_size -> Result<u64> with Ok(0)
+clarity/src/vm/tests/traits.rs:1963: replace test_let_trait with ()
+clarity/src/vm/costs/mod.rs:1062: replace <impl CostTracker for &mut LimitedCostTracker>::reset_memory with ()
+clarity/src/vm/database/structures.rs:949: replace STXBalance::get_total_balance -> u128 with 1
+clarity/src/vm/events.rs:206: replace STXBurnEventData::json_serialize -> serde_json::Value with Default::default()
+clarity/src/vm/ast/errors.rs:296: replace <impl DiagnosableError for ParseErrors>::suggestion -> Option<String> with Some(String::new())
+clarity/src/vm/database/clarity_db.rs:237: replace <impl BurnStateDB for &dyn BurnStateDB>::get_pox_rejection_fraction -> u64 with 0
+clarity/src/vm/types/signatures.rs:902: replace FixedFunction::total_type_size -> Result<u64> with Ok(1)
+clarity/src/vm/contexts.rs:502: replace <impl Display for AssetMap>::fmt -> fmt::Result with Ok(Default::default())
+clarity/src/vm/database/clarity_db.rs:943: replace ClarityDatabase<'a>::get_burnchain_block_height -> Option<u32> with Some(0)
+clarity/src/vm/types/signatures.rs:1748: replace TupleTypeSignature::type_size -> Option<u32> with Some(0)
+clarity/src/vm/tests/traits.rs:1346: replace test_return_trait_with_contract_of with ()
+clarity/src/vm/costs/mod.rs:1059: replace <impl CostTracker for &mut LimitedCostTracker>::drop_memory with ()
+clarity/src/vm/tests/contracts.rs:99: replace test_get_block_info_eval with ()
+clarity/src/vm/database/clarity_db.rs:298: replace <impl HeadersDB for NullHeadersDB>::get_burn_block_time_for_block -> Option<u64> with None
+clarity/src/vm/database/clarity_store.rs:239: replace <impl ClarityBackingStore for NullBackingStore>::get_block_at_height -> Option<StacksBlockId> with None
+clarity/src/vm/errors.rs:114: replace <impl PartialEq for IncomparableError<T>>::eq -> bool with false
+clarity/src/vm/types/signatures.rs:1735: replace ListTypeData::type_size -> Option<u32> with Some(1)
+clarity/src/vm/database/clarity_db.rs:163: replace <impl HeadersDB for &dyn HeadersDB>::get_consensus_hash_for_block -> Option<ConsensusHash> with None
+clarity/src/vm/tests/sequences.rs:1160: replace test_construct_bad_list with ()
+clarity/src/vm/errors.rs:163: replace <impl Error for RuntimeErrorType>::source -> Option<&(dyn error::Error +'static)> with None
+clarity/src/vm/database/key_value_wrapper.rs:261: replace RollbackWrapper<'a>::depth -> usize with 1
+clarity/src/vm/types/mod.rs:274: replace SequenceData::is_empty -> bool with true
+clarity/src/vm/database/structures.rs:386: replace STXBalanceSnapshot<'db, 'conn>::has_unlockable_tokens -> bool with true
+clarity/src/vm/analysis/analysis_db.rs:84: replace AnalysisDatabase<'a>::has_contract -> bool with false
+clarity/src/vm/docs/mod.rs:2626: replace make_json_api_reference -> String with "xyzzy".into()
+clarity/src/vm/test_util/mod.rs:236: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_pox_prepare_length -> u32 with 1
+clarity/src/vm/tests/contracts.rs:458: replace test_simple_naming_system with ()
+clarity/src/vm/database/clarity_store.rs:299: replace <impl ClarityBackingStore for MemoryBackingStore>::get_with_proof -> Option<(String, Vec<u8>)> with Some((String::new(), vec![1]))
+clarity/src/vm/analysis/types.rs:179: replace ContractAnalysis::get_variable_type -> Option<&TypeSignature> with None
+clarity/src/vm/tests/assets.rs:521: replace test_simple_token_system with ()
+clarity/src/vm/types/mod.rs:1559: replace byte_len_of_serialization -> u64 with 0
+clarity/src/vm/representations.rs:511: replace SymbolicExpression::span -> &Span with &Default::default()
+clarity/src/vm/database/clarity_db.rs:1072: replace ClarityDatabase<'a>::get_microblock_pubkey_hash_height -> Option<u32> with Some(1)
+clarity/src/vm/database/clarity_db.rs:181: replace <impl HeadersDB for &dyn HeadersDB>::get_burnchain_tokens_spent_for_winning_block -> Option<u128> with None
+clarity/src/vm/database/clarity_store.rs:227: replace <impl ClarityBackingStore for NullBackingStore>::get -> Option<String> with Some(String::new())
+clarity/src/vm/types/mod.rs:1301: replace PrincipalData::version -> u8 with 0
+clarity/src/vm/tests/contracts.rs:295: replace test_tx_sponsor with ()
+clarity/src/vm/database/clarity_db.rs:832: replace ClarityDatabase<'a>::get_current_burnchain_block_height -> u32 with 0
+clarity/src/vm/mod.rs:221: replace add_stack_trace with ()
+clarity/src/vm/database/key_value_wrapper.rs:174: replace RollbackWrapperPersistedLog::nest with ()
+clarity/src/vm/types/mod.rs:1044: replace Value::expect_i128 -> i128 with 0
+clarity/src/vm/database/clarity_db.rs:384: replace <impl BurnStateDB for NullBurnStateDB>::get_pox_reward_cycle_length -> u32 with 0
+clarity/src/vm/database/clarity_db.rs:388: replace <impl BurnStateDB for NullBurnStateDB>::get_pox_rejection_fraction -> u64 with 1
+clarity/src/vm/types/mod.rs:274: replace SequenceData::is_empty -> bool with false
+clarity/src/vm/database/clarity_store.rs:319: replace <impl ClarityBackingStore for MemoryBackingStore>::get_open_chain_tip_height -> u32 with 0
+clarity/src/vm/test_util/mod.rs:236: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_pox_prepare_length -> u32 with 0
+clarity/src/vm/events.rs:155: replace STXTransferEventData::json_serialize -> serde_json::Value with Default::default()
+clarity/src/vm/coverage.rs:237: replace <impl EvalHook for CoverageReporter>::will_begin_eval with ()
+clarity/src/vm/types/mod.rs:256: replace SequenceData::element_size -> u32 with 0
+clarity/src/vm/database/clarity_db.rs:233: replace <impl BurnStateDB for &dyn BurnStateDB>::get_pox_reward_cycle_length -> u32 with 0
+clarity/src/vm/database/sqlite.rs:153: replace SqliteConnection::has_entry -> bool with false
+clarity/src/vm/costs/mod.rs:826: replace LimitedCostTracker::get_memory -> u64 with 0
+clarity/src/vm/contexts.rs:926: replace <impl CostTracker for GlobalContext<'_, '_>>::short_circuit_contract_call -> std::result::Result<bool, CostErrors> with Ok(false)
+clarity/src/vm/tests/traits.rs:2024: replace test_let3_trait with ()
+clarity/src/vm/database/clarity_store.rs:299: replace <impl ClarityBackingStore for MemoryBackingStore>::get_with_proof -> Option<(String, Vec<u8>)> with Some(("xyzzy".into(), vec![0]))
+clarity/src/vm/database/clarity_db.rs:326: replace <impl HeadersDB for NullHeadersDB>::get_tokens_earned_for_block -> Option<u128> with Some(1)
+clarity/src/vm/database/structures.rs:979: replace STXBalance::was_locked_by_v3 -> bool with true
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:50: replace TraitContext::is_name_used -> bool with false
+clarity/src/vm/ast/errors.rs:296: replace <impl DiagnosableError for ParseErrors>::suggestion -> Option<String> with Some("xyzzy".into())
+clarity/src/vm/database/structures.rs:578: replace STXBalanceSnapshot<'db, 'conn>::lock_tokens_v3 with ()
+clarity/src/vm/test_util/mod.rs:247: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_burn_start_height -> u32 with 0
+clarity/src/vm/tests/traits.rs:452: replace test_dynamic_dispatch_including_nested_trait with ()
+clarity/src/vm/ast/parser/v2/lexer/error.rs:67: replace <impl DiagnosableError for LexerError>::suggestion -> Option<String> with None
+clarity/src/vm/database/clarity_db.rs:336: replace <impl BurnStateDB for NullBurnStateDB>::get_burn_start_height -> u32 with 1
+clarity/src/vm/database/clarity_db.rs:580: replace ClarityDatabase<'a>::get_contract_src -> Option<String> with Some("xyzzy".into())
+clarity/src/vm/analysis/errors.rs:208: replace CheckError::has_expression -> bool with true
+clarity/src/vm/types/mod.rs:1374: replace <impl Display for CallableData>::fmt -> fmt::Result with Ok(Default::default())
+clarity/src/vm/types/mod.rs:1483: replace TupleData::is_empty -> bool with false
+clarity/src/vm/mod.rs:481: replace execute_on_network -> Result<Option<Value>> with Ok(None)
+clarity/src/vm/types/serialization.rs:1169: replace <impl Write for WriteCounter>::flush -> std::io::Result<()> with Ok(())
+clarity/src/vm/contexts.rs:915: replace <impl CostTracker for GlobalContext<'_, '_>>::drop_memory with ()
+clarity/src/vm/database/clarity_db.rs:306: replace <impl HeadersDB for NullHeadersDB>::get_burn_block_height_for_block -> Option<u32> with Some(0)
+clarity/src/vm/database/clarity_db.rs:314: replace <impl HeadersDB for NullHeadersDB>::get_miner_address -> Option<StacksAddress> with None
+clarity/src/vm/tests/traits.rs:1816: replace test_pass_embedded_trait_to_subtrait_list_option with ()
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:90: replace <impl CostTracker for TypeChecker<'_, '_>>::add_cost -> std::result::Result<(), CostErrors> with Ok(())
+clarity/src/vm/database/structures.rs:42: replace <impl ClaritySerializable for String>::serialize -> String with "xyzzy".into()
+clarity/src/vm/ast/errors.rs:173: replace <impl DiagnosableError for ParseErrors>::message -> String with "xyzzy".into()
+clarity/src/vm/database/clarity_store.rs:251: replace <impl ClarityBackingStore for NullBackingStore>::get_current_block_height -> u32 with 1
+clarity/src/vm/database/structures.rs:1109: replace STXBalance::can_transfer_at_burn_block -> bool with false
+clarity/src/vm/database/clarity_db.rs:190: replace <impl BurnStateDB for &dyn BurnStateDB>::get_v1_unlock_height -> u32 with 0
+clarity/src/vm/database/clarity_db.rs:213: replace <impl BurnStateDB for &dyn BurnStateDB>::get_burn_start_height -> u32 with 1
+clarity/src/vm/contexts.rs:1988: replace CallStack::make_stack_trace -> StackTrace with Default::default()
+clarity/src/vm/database/clarity_db.rs:323: replace <impl HeadersDB for NullHeadersDB>::get_burnchain_tokens_spent_for_winning_block -> Option<u128> with None
+clarity/src/vm/database/clarity_db.rs:533: replace ClarityDatabase<'a>::make_key_for_trip -> String with String::new()
+clarity/src/vm/types/signatures.rs:69: replace AssetIdentifier::sugared -> String with "xyzzy".into()
+clarity/src/vm/test_util/mod.rs:149: replace <impl HeadersDB for UnitTestHeaderDB>::get_burn_block_time_for_block -> Option<u64> with Some(1)
+clarity/src/vm/costs/mod.rs:259: replace LimitedCostTracker::contract_call_circuits -> HashMap<(QualifiedContractIdentifier, ClarityName), ClarityCostFunctionReference> with HashMap::new()
+clarity/src/vm/contexts.rs:461: replace AssetMap::get_stx_burned -> Option<u128> with None
+clarity/src/vm/database/clarity_db.rs:659: replace ClarityDatabase<'a>::get_contract_size -> Result<u64> with Ok(0)
+clarity/src/vm/test_util/mod.rs:228: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_v2_unlock_height -> u32 with 0
+clarity/src/vm/types/signatures.rs:913: replace FunctionSignature::total_type_size -> Result<u64> with Ok(1)
+clarity/src/vm/tests/principals.rs:138: replace test_simple_is_standard_mainnet_cases with ()
+clarity/src/vm/database/key_value_wrapper.rs:261: replace RollbackWrapper<'a>::depth -> usize with 0
+clarity/src/vm/database/clarity_db.rs:221: replace <impl BurnStateDB for &dyn BurnStateDB>::get_burn_header_hash -> Option<BurnchainHeaderHash> with None
+clarity/src/vm/analysis/errors.rs:212: replace CheckError::set_expression with ()
+clarity/src/vm/database/clarity_db.rs:175: replace <impl HeadersDB for &dyn HeadersDB>::get_miner_address -> Option<StacksAddress> with None
+clarity/src/vm/database/clarity_db.rs:178: replace <impl HeadersDB for &dyn HeadersDB>::get_burnchain_tokens_spent_for_block -> Option<u128> with None
+clarity/src/vm/tests/traits.rs:1232: replace test_return_trait_with_contract_of_wrapped_in_begin with ()
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:99: replace <impl CostTracker for TypeChecker<'_, '_>>::reset_memory with ()
+clarity/src/vm/contexts.rs:457: replace AssetMap::get_stx -> Option<u128> with Some(1)
+clarity/src/vm/costs/mod.rs:735: replace TrackerData::load_costs -> Result<()> with Ok(())
+clarity/src/vm/types/signatures.rs:1872: replace <impl Display for AssetIdentifier>::fmt -> fmt::Result with Ok(Default::default())
+clarity/src/vm/ast/errors.rs:129: replace <impl Display for ParseError>::fmt -> fmt::Result with Ok(Default::default())
+clarity/src/vm/database/clarity_db.rs:395: replace <impl BurnStateDB for NullBurnStateDB>::get_pox_payout_addrs -> Option<(Vec<TupleData>, u128)> with None
+clarity/src/vm/database/clarity_db.rs:962: replace ClarityDatabase<'a>::get_miner_spend_winner -> u128 with 1
+clarity/src/vm/ast/errors.rs:113: replace ParseError::has_pre_expression -> bool with false
+clarity/src/vm/database/structures.rs:988: replace STXBalance::has_locked_tokens_at_burn_block -> bool with true
+clarity/src/vm/representations.rs:503: replace SymbolicExpression::copy_span with ()
+clarity/src/vm/test_util/mod.rs:220: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_stacks_epoch_by_epoch_id -> Option<StacksEpoch> with None
+clarity/src/vm/database/clarity_db.rs:229: replace <impl BurnStateDB for &dyn BurnStateDB>::get_pox_prepare_length -> u32 with 1
+clarity/src/vm/database/clarity_db.rs:1031: replace ClarityDatabase<'a>::insert_microblock_pubkey_hash_height -> Result<()> with Ok(())
+clarity/src/vm/coverage.rs:104: replace CoverageReporter::executable_lines -> Vec<u32> with vec![0]
+clarity/src/vm/database/structures.rs:48: replace <impl ClarityDeserializable for String>::deserialize -> String with String::new()
+clarity/src/vm/database/clarity_db.rs:463: replace ClarityDatabase<'a>::put_with_size -> u64 with 1
+clarity/src/vm/types/mod.rs:1201: replace ListData::is_empty -> bool with false
+clarity/src/vm/costs/mod.rs:716: replace LimitedCostTracker::default_cost_contract_for_epoch -> String with String::new()
+clarity/src/vm/database/clarity_db.rs:298: replace <impl HeadersDB for NullHeadersDB>::get_burn_block_time_for_block -> Option<u64> with Some(0)
+clarity/src/vm/tests/traits.rs:1165: replace test_contract_of_no_impl with ()
+clarity/src/vm/database/clarity_store.rs:231: replace <impl ClarityBackingStore for NullBackingStore>::get_with_proof -> Option<(String, Vec<u8>)> with Some(("xyzzy".into(), vec![1]))
+clarity/src/vm/tests/traits.rs:390: replace test_dynamic_dispatch_by_importing_trait with ()
+clarity/src/vm/costs/mod.rs:358: replace store_state_summary -> Result<()> with Ok(())
+clarity/src/vm/test_util/mod.rs:186: replace <impl HeadersDB for UnitTestHeaderDB>::get_burnchain_tokens_spent_for_winning_block -> Option<u128> with Some(1)
+clarity/src/vm/contracts.rs:57: replace Contract::canonicalize_types with ()
+clarity/src/vm/contexts.rs:479: replace AssetMap::get_fungible_tokens -> Option<u128> with Some(1)
+clarity/src/vm/tests/contracts.rs:685: replace test_simple_contract_call with ()
+clarity/src/vm/database/key_value_wrapper.rs:77: replace rollback_value_check with ()
+clarity/src/vm/database/clarity_store.rs:231: replace <impl ClarityBackingStore for NullBackingStore>::get_with_proof -> Option<(String, Vec<u8>)> with Some((String::new(), vec![0]))
+clarity/src/vm/database/clarity_store.rs:299: replace <impl ClarityBackingStore for MemoryBackingStore>::get_with_proof -> Option<(String, Vec<u8>)> with None
+clarity/src/vm/database/clarity_store.rs:247: replace <impl ClarityBackingStore for NullBackingStore>::get_open_chain_tip_height -> u32 with 1
+clarity/src/vm/database/clarity_db.rs:388: replace <impl BurnStateDB for NullBurnStateDB>::get_pox_rejection_fraction -> u64 with 0
+clarity/src/vm/database/clarity_store.rs:323: replace <impl ClarityBackingStore for MemoryBackingStore>::get_current_block_height -> u32 with 1
+clarity/src/vm/database/key_value_wrapper.rs:229: replace RollbackWrapper<'a>::get_cc_special_cases_handler -> Option<SpecialCaseHandler> with None
+clarity/src/vm/database/clarity_db.rs:298: replace <impl HeadersDB for NullHeadersDB>::get_burn_block_time_for_block -> Option<u64> with Some(1)
+clarity/src/vm/database/clarity_db.rs:252: replace <impl BurnStateDB for &dyn BurnStateDB>::get_pox_payout_addrs -> Option<(Vec<TupleData>, u128)> with None
+clarity/src/vm/database/clarity_db.rs:431: replace ClarityDatabase<'a>::is_stack_empty -> bool with true
+clarity/src/vm/representations.rs:121: replace <impl StacksMessageCodec for ContractName>::consensus_serialize -> Result<(), codec_error> with Ok(())
+clarity/src/vm/analysis/contract_interface_builder/mod.rs:307: replace ContractInterfaceFungibleTokens::from_set -> Vec<Self> with vec![]
+clarity/src/vm/database/clarity_store.rs:255: replace <impl ClarityBackingStore for NullBackingStore>::put_all with ()
+clarity/src/vm/contexts.rs:893: replace <impl CostTracker for Environment<'_, '_, '_>>::short_circuit_contract_call -> std::result::Result<bool, CostErrors> with Ok(true)
+clarity/src/vm/test_util/mod.rs:232: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_pox_3_activation_height -> u32 with 1
+clarity/src/vm/ast/parser/v2/mod.rs:167: replace Parser<'a>::skip_to_end with ()
+clarity/src/vm/database/clarity_db.rs:326: replace <impl HeadersDB for NullHeadersDB>::get_tokens_earned_for_block -> Option<u128> with None
+clarity/src/vm/database/structures.rs:463: replace STXBalanceSnapshot<'db, 'conn>::is_v2_locked -> bool with false
+clarity/src/vm/database/clarity_db.rs:943: replace ClarityDatabase<'a>::get_burnchain_block_height -> Option<u32> with Some(1)
+clarity/src/vm/tests/contracts.rs:992: replace test_at_unknown_block with ()
+clarity/src/vm/coverage.rs:104: replace CoverageReporter::executable_lines -> Vec<u32> with vec![]
+clarity/src/vm/types/serialization.rs:102: replace <impl Error for SerializationError>::source -> Option<&(dyn error::Error +'static)> with None
+clarity/src/vm/representations.rs:81: replace <impl StacksMessageCodec for ClarityName>::consensus_serialize -> Result<(), codec_error> with Ok(())
+clarity/src/vm/database/clarity_db.rs:1951: replace ClarityDatabase<'a>::get_burn_block_height -> Option<u32> with Some(0)
+clarity/src/vm/test_util/mod.rs:263: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_pox_payout_addrs -> Option<(Vec<TupleData>, u128)> with Some((vec![], 1))
+clarity/src/vm/database/clarity_store.rs:227: replace <impl ClarityBackingStore for NullBackingStore>::get -> Option<String> with Some("xyzzy".into())
+clarity/src/vm/test_util/mod.rs:228: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_v2_unlock_height -> u32 with 1
+clarity/src/vm/database/clarity_db.rs:384: replace <impl BurnStateDB for NullBurnStateDB>::get_pox_reward_cycle_length -> u32 with 1
+clarity/src/vm/tests/traits.rs:89: replace test_dynamic_dispatch_pass_trait_nested_in_let with ()
+clarity/src/vm/errors.rs:114: replace <impl PartialEq for IncomparableError<T>>::eq -> bool with true
+clarity/src/vm/callables.rs:370: replace DefinedFunction::get_span -> Span with Default::default()
+clarity/src/vm/database/clarity_store.rs:177: replace make_contract_hash_key -> String with String::new()
+clarity/src/vm/database/clarity_db.rs:768: replace ClarityDatabase<'a>::decrement_ustx_liquid_supply -> Result<()> with Ok(())
+clarity/src/vm/contexts.rs:1507: replace Environment<'a, 'b, 'hooks>::register_nft_burn_event -> Result<()> with Ok(())
+clarity/src/vm/database/structures.rs:680: replace STXBalanceSnapshot<'db, 'conn>::is_v3_locked -> bool with false
+clarity/src/vm/database/clarity_db.rs:592: replace ClarityDatabase<'a>::set_metadata with ()
+clarity/src/vm/database/clarity_db.rs:213: replace <impl BurnStateDB for &dyn BurnStateDB>::get_burn_start_height -> u32 with 0
+clarity/src/vm/analysis/errors.rs:443: replace <impl DiagnosableError for CheckErrors>::suggestion -> Option<String> with None
+clarity/src/vm/costs/mod.rs:282: replace <impl Debug for LimitedCostTracker>::fmt -> fmt::Result with Ok(Default::default())
+clarity/src/vm/database/clarity_db.rs:463: replace ClarityDatabase<'a>::put_with_size -> u64 with 0
+clarity/src/vm/types/mod.rs:1268: replace <impl Debug for BuffData>::fmt -> fmt::Result with Ok(Default::default())
+clarity/src/vm/ast/parser/v1.rs:108: replace get_lines_at -> Vec<usize> with vec![]
+clarity/src/vm/representations.rs:388: replace PreSymbolicExpression::match_placeholder -> Option<&str> with Some("xyzzy")
+clarity/src/vm/database/clarity_db.rs:323: replace <impl HeadersDB for NullHeadersDB>::get_burnchain_tokens_spent_for_winning_block -> Option<u128> with Some(1)
+clarity/src/vm/database/clarity_db.rs:184: replace <impl HeadersDB for &dyn HeadersDB>::get_tokens_earned_for_block -> Option<u128> with Some(0)
+clarity/src/vm/database/structures.rs:971: replace STXBalance::was_locked_by_v1 -> bool with true
+clarity/src/vm/tests/traits.rs:1036: replace test_dynamic_dispatch_pass_literal_principal_as_trait_in_user_defined_functions with ()
+clarity/src/vm/database/clarity_db.rs:1878: replace ClarityDatabase<'a>::make_key_for_account_nonce -> String with String::new()
+clarity/src/vm/costs/mod.rs:934: replace add_cost -> std::result::Result<(), CostErrors> with Ok(())
+clarity/src/vm/test_util/mod.rs:125: replace <impl HeadersDB for UnitTestHeaderDB>::get_burn_header_hash_for_block -> Option<BurnchainHeaderHash> with None
+clarity/src/vm/contexts.rs:1429: replace Environment<'a, 'b, 'hooks>::register_print_event -> Result<()> with Ok(())
+clarity/src/vm/contexts.rs:1445: replace Environment<'a, 'b, 'hooks>::register_stx_transfer_event -> Result<()> with Ok(())
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:93: replace <impl CostTracker for TypeChecker<'_, '_>>::add_memory -> std::result::Result<(), CostErrors> with Ok(())
+clarity/src/vm/coverage.rs:54: replace CoverageReporter::report_eval with ()
+clarity/src/vm/types/mod.rs:1026: replace Value::expect_ascii -> String with "xyzzy".into()
+clarity/src/vm/events.rs:272: replace NFTBurnEventData::json_serialize -> serde_json::Value with Default::default()
+clarity/src/vm/test_util/mod.rs:244: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_pox_rejection_fraction -> u64 with 1
+clarity/src/vm/types/mod.rs:1044: replace Value::expect_i128 -> i128 with -1
+clarity/src/vm/tests/traits.rs:1397: replace test_pass_trait_to_subtrait with ()
+clarity/src/vm/contexts.rs:457: replace AssetMap::get_stx -> Option<u128> with Some(0)
+clarity/src/vm/database/clarity_db.rs:819: replace ClarityDatabase<'a>::get_v2_unlock_height -> u32 with 1
+clarity/src/vm/database/structures.rs:1047: replace STXBalance::has_unlockable_tokens_at_burn_block -> bool with true
+clarity/src/vm/tests/traits.rs:650: replace test_reentrant_dynamic_dispatch with ()
+clarity/src/vm/database/clarity_db.rs:716: replace ClarityDatabase<'a>::ustx_liquid_supply_key -> &'static str with ""
+clarity/src/vm/ast/parser/v2/mod.rs:1109: replace parse_collect_diagnostics -> (Vec<PreSymbolicExpression>, Vec<Diagnostic>, bool) with (vec![], vec![], true)
+clarity/src/vm/tests/traits.rs:262: replace test_dynamic_dispatch_by_implementing_imported_trait with ()
+clarity/src/vm/types/signatures.rs:1690: replace TypeSignature::type_size -> Result<u32> with Ok(1)
+clarity/src/vm/representations.rs:238: replace PreSymbolicExpression::set_span with ()
+clarity/src/vm/costs/mod.rs:270: replace LimitedCostTracker::cost_function_references -> HashMap<&'static ClarityCostFunction, ClarityCostFunctionReference> with HashMap::new()
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:98: replace <impl CostTracker for TypeChecker<'_, '_>>::add_memory -> std::result::Result<(), CostErrors> with Ok(())
+clarity/src/vm/callables.rs:119: replace <impl Display for FunctionIdentifier>::fmt -> fmt::Result with Ok(Default::default())
+clarity/src/vm/database/structures.rs:975: replace STXBalance::was_locked_by_v2 -> bool with true
+clarity/src/vm/database/clarity_db.rs:984: replace ClarityDatabase<'a>::get_block_reward -> Option<u128> with None
+clarity/src/vm/database/clarity_db.rs:178: replace <impl HeadersDB for &dyn HeadersDB>::get_burnchain_tokens_spent_for_block -> Option<u128> with Some(1)
+clarity/src/vm/database/clarity_db.rs:782: replace ClarityDatabase<'a>::is_in_regtest -> bool with true
+clarity/src/vm/version.rs:15: replace <impl Display for ClarityVersion>::fmt -> fmt::Result with Ok(Default::default())
+clarity/src/vm/tests/traits.rs:1528: replace test_pass_embedded_trait_to_subtrait_optional with ()
+clarity/src/vm/database/structures.rs:754: replace STXBalance::unlock_height -> u64 with 0
+clarity/src/vm/analysis/errors.rs:262: replace <impl Error for CheckError>::source -> Option<&(dyn error::Error +'static)> with None
+clarity/src/vm/types/mod.rs:1559: replace byte_len_of_serialization -> u64 with 1
+clarity/src/vm/contexts.rs:876: replace <impl CostTracker for Environment<'_, '_, '_>>::add_cost -> std::result::Result<(), CostErrors> with Ok(())
+clarity/src/vm/database/clarity_db.rs:659: replace ClarityDatabase<'a>::get_contract_size -> Result<u64> with Ok(1)
+clarity/src/vm/analysis/arithmetic_checker/mod.rs:72: replace ArithmeticOnlyChecker<'a>::check_contract_cost_eligible with ()
+clarity/src/vm/database/clarity_db.rs:1938: replace ClarityDatabase<'a>::get_account_nonce -> u64 with 0
+clarity/src/vm/callables.rs:105: replace cost_input_sized_vararg -> Result<u64> with Ok(1)
+clarity/src/vm/database/sqlite.rs:121: replace SqliteConnection::drop_metadata with ()
+clarity/src/vm/database/clarity_db.rs:317: replace <impl HeadersDB for NullHeadersDB>::get_burnchain_tokens_spent_for_block -> Option<u128> with Some(0)
+clarity/src/vm/contexts.rs:102: replace AssetMap::to_json -> serde_json::Value with Default::default()
+clarity/src/vm/test_util/mod.rs:191: replace <impl HeadersDB for UnitTestHeaderDB>::get_tokens_earned_for_block -> Option<u128> with Some(1)
+clarity/src/vm/types/mod.rs:1478: replace TupleData::len -> u64 with 0
+clarity/src/vm/database/clarity_db.rs:252: replace <impl BurnStateDB for &dyn BurnStateDB>::get_pox_payout_addrs -> Option<(Vec<TupleData>, u128)> with Some((vec![], 0))
+clarity/src/vm/clarity.rs:42: replace <impl Error for Error>::cause -> Option<&dyn std::error::Error> with None
+clarity/src/vm/database/sqlite.rs:110: replace SqliteConnection::commit_metadata_to with ()
+clarity/src/vm/database/structures.rs:376: replace STXBalanceSnapshot<'db, 'conn>::has_locked_tokens -> bool with true
+clarity/src/vm/events.rs:332: replace FTBurnEventData::json_serialize -> serde_json::Value with Default::default()
+clarity/src/mod.rs:96: replace version_string -> String with String::new()
+clarity/src/vm/database/sqlite.rs:192: replace SqliteConnection::check_schema -> Result<()> with Ok(())
+clarity/src/vm/test_util/mod.rs:181: replace <impl HeadersDB for UnitTestHeaderDB>::get_burnchain_tokens_spent_for_block -> Option<u128> with Some(0)
+clarity/src/vm/database/clarity_db.rs:1011: replace ClarityDatabase<'a>::set_stx_btc_ops_processed with ()
+clarity/src/vm/database/structures.rs:400: replace STXBalanceSnapshot<'db, 'conn>::debit with ()
+clarity/src/vm/database/clarity_db.rs:1882: replace ClarityDatabase<'a>::make_key_for_account_stx_locked -> String with "xyzzy".into()
+clarity/src/vm/database/sqlite.rs:72: replace sqlite_has_entry -> bool with true
+clarity/src/vm/tests/traits.rs:895: replace test_good_call_with_trait with ()
+clarity/src/vm/types/signatures.rs:1929: replace <impl Display for FunctionArg>::fmt -> fmt::Result with Ok(Default::default())
+clarity/src/vm/contexts.rs:461: replace AssetMap::get_stx_burned -> Option<u128> with Some(1)
+clarity/src/vm/database/clarity_db.rs:209: replace <impl BurnStateDB for &dyn BurnStateDB>::get_sortition_id_from_consensus_hash -> Option<SortitionId> with None
+clarity/src/vm/clarity.rs:27: replace <impl Display for Error>::fmt -> fmt::Result with Ok(Default::default())
+clarity/src/vm/database/clarity_db.rs:351: replace <impl BurnStateDB for NullBurnStateDB>::get_burn_header_hash -> Option<BurnchainHeaderHash> with None
+clarity/src/vm/test_util/mod.rs:206: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_burn_header_hash -> Option<BurnchainHeaderHash> with None
+clarity/src/vm/database/key_value_wrapper.rs:84: replace rollback_edits_push with ()
+clarity/src/vm/costs/mod.rs:832: replace LimitedCostTracker::get_memory_limit -> u64 with 1
+clarity/src/vm/database/clarity_db.rs:332: replace <impl BurnStateDB for NullBurnStateDB>::get_burn_block_height -> Option<u32> with Some(1)
+clarity/src/vm/tests/traits.rs:2092: replace test_pass_principal_literal_to_trait with ()
+clarity/src/vm/costs/mod.rs:1085: replace <impl Display for ExecutionCost>::fmt -> fmt::Result with Ok(Default::default())
+clarity/src/vm/database/clarity_store.rs:299: replace <impl ClarityBackingStore for MemoryBackingStore>::get_with_proof -> Option<(String, Vec<u8>)> with Some(("xyzzy".into(), vec![1]))
+clarity/src/vm/types/mod.rs:1090: replace Value::expect_bool -> bool with false
+clarity/src/vm/types/mod.rs:794: replace <impl PartialEq for ListData>::eq -> bool with true
+clarity/src/vm/ast/definition_sorter/mod.rs:425: replace Graph::has_node_descendants -> bool with true
+clarity/src/vm/database/clarity_db.rs:169: replace <impl HeadersDB for &dyn HeadersDB>::get_burn_block_time_for_block -> Option<u64> with Some(1)
+clarity/src/vm/database/clarity_db.rs:372: replace <impl BurnStateDB for NullBurnStateDB>::get_v2_unlock_height -> u32 with 0
+clarity/src/vm/representations.rs:388: replace PreSymbolicExpression::match_placeholder -> Option<&str> with Some("")
+clarity/src/vm/contexts.rs:909: replace <impl CostTracker for GlobalContext<'_, '_>>::add_cost -> std::result::Result<(), CostErrors> with Ok(())
+clarity/src/vm/contexts.rs:726: replace OwnedEnvironment<'a, 'hooks>::initialize_contract_from_ast -> Result<((), AssetMap, Vec<StacksTransactionEvent>)> with Ok(((), Default::default(), vec![]))
+clarity/src/vm/analysis/arithmetic_checker/mod.rs:60: replace <impl Error for Error>::source -> Option<&(dyn std::error::Error +'static)> with None
+clarity/src/vm/database/key_value_wrapper.rs:532: replace RollbackWrapper<'a>::has_metadata_entry -> bool with false
+clarity/src/vm/ast/parser/v2/lexer/error.rs:36: replace <impl DiagnosableError for LexerError>::message -> String with "xyzzy".into()
+clarity/src/vm/database/clarity_db.rs:380: replace <impl BurnStateDB for NullBurnStateDB>::get_pox_prepare_length -> u32 with 0
+clarity/src/vm/types/signatures.rs:1696: replace TypeSignature::inner_type_size -> Option<u32> with Some(1)
+clarity/src/vm/database/structures.rs:726: replace STXBalanceSnapshot<'db, 'conn>::unlock_available_tokens_if_any -> u128 with 0
+clarity/src/vm/types/serialization.rs:1338: replace <impl Hash for Value>::hash with ()
+clarity/src/vm/database/clarity_db.rs:225: replace <impl BurnStateDB for &dyn BurnStateDB>::get_stacks_epoch -> Option<StacksEpoch> with None
+clarity/src/vm/tests/traits.rs:963: replace test_good_call_2_with_trait with ()
+clarity/src/vm/types/mod.rs:1301: replace PrincipalData::version -> u8 with 1
+clarity/src/vm/representations.rs:610: replace SymbolicExpression::match_field -> Option<&TraitIdentifier> with None
+clarity/src/vm/analysis/errors.rs:443: replace <impl DiagnosableError for CheckErrors>::suggestion -> Option<String> with Some(String::new())
+clarity/src/vm/database/clarity_db.rs:541: replace ClarityDatabase<'a>::clarity_state_epoch_key -> &'static str with ""
+clarity/src/vm/database/clarity_db.rs:431: replace ClarityDatabase<'a>::is_stack_empty -> bool with false
+clarity/src/vm/costs/mod.rs:139: replace <impl CostTracker for ()>::add_cost -> std::result::Result<(), CostErrors> with Ok(())
+clarity/src/vm/representations.rs:602: replace SymbolicExpression::match_trait_reference -> Option<&ClarityName> with None
+clarity/src/vm/ast/errors.rs:113: replace ParseError::has_pre_expression -> bool with true
+clarity/src/vm/contexts.rs:461: replace AssetMap::get_stx_burned -> Option<u128> with Some(0)
+clarity/src/vm/database/key_value_wrapper.rs:420: replace RollbackWrapper<'a>::get_current_block_height -> u32 with 1
+clarity/src/vm/types/signatures.rs:69: replace AssetIdentifier::sugared -> String with String::new()
+clarity/src/vm/database/clarity_db.rs:541: replace ClarityDatabase<'a>::clarity_state_epoch_key -> &'static str with "xyzzy"
+clarity/src/vm/tests/traits.rs:147: replace test_dynamic_dispatch_pass_trait with ()
+clarity/src/vm/database/clarity_db.rs:380: replace <impl BurnStateDB for NullBurnStateDB>::get_pox_prepare_length -> u32 with 1
+clarity/src/vm/types/signatures.rs:1735: replace ListTypeData::type_size -> Option<u32> with Some(0)
+clarity/src/vm/database/clarity_db.rs:580: replace ClarityDatabase<'a>::get_contract_src -> Option<String> with None
+clarity/src/vm/database/clarity_store.rs:231: replace <impl ClarityBackingStore for NullBackingStore>::get_with_proof -> Option<(String, Vec<u8>)> with Some(("xyzzy".into(), vec![]))
+clarity/src/vm/test_util/mod.rs:240: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_pox_reward_cycle_length -> u32 with 1
+clarity/src/vm/database/clarity_db.rs:1006: replace ClarityDatabase<'a>::get_stx_btc_ops_processed -> u64 with 1
+clarity/src/vm/contexts.rs:918: replace <impl CostTracker for GlobalContext<'_, '_>>::reset_memory with ()
+clarity/src/vm/database/clarity_db.rs:984: replace ClarityDatabase<'a>::get_block_reward -> Option<u128> with Some(1)
+clarity/src/vm/ast/parser/v2/lexer/error.rs:67: replace <impl DiagnosableError for LexerError>::suggestion -> Option<String> with Some(String::new())
+clarity/src/vm/database/key_value_wrapper.rs:517: replace RollbackWrapper<'a>::has_entry -> bool with false
+clarity/src/vm/database/clarity_db.rs:1882: replace ClarityDatabase<'a>::make_key_for_account_stx_locked -> String with String::new()
+clarity/src/vm/database/clarity_db.rs:372: replace <impl BurnStateDB for NullBurnStateDB>::get_v2_unlock_height -> u32 with 1
+clarity/src/vm/types/signatures.rs:902: replace FixedFunction::total_type_size -> Result<u64> with Ok(0)
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:112: replace <impl CostTracker for TypeChecker<'_, '_>>::short_circuit_contract_call -> std::result::Result<bool, CostErrors> with Ok(true)
+clarity/src/vm/analysis/errors.rs:443: replace <impl DiagnosableError for CheckErrors>::suggestion -> Option<String> with Some("xyzzy".into())
+clarity/src/vm/database/clarity_db.rs:198: replace <impl BurnStateDB for &dyn BurnStateDB>::get_pox_3_activation_height -> u32 with 1
+clarity/src/vm/database/clarity_db.rs:368: replace <impl BurnStateDB for NullBurnStateDB>::get_v1_unlock_height -> u32 with 1
+clarity/src/vm/contexts.rs:879: replace <impl CostTracker for Environment<'_, '_, '_>>::add_memory -> std::result::Result<(), CostErrors> with Ok(())
+clarity/src/vm/database/structures.rs:754: replace STXBalance::unlock_height -> u64 with 1
+clarity/src/vm/test_util/mod.rs:224: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_v1_unlock_height -> u32 with 0
+clarity/src/vm/database/clarity_db.rs:190: replace <impl BurnStateDB for &dyn BurnStateDB>::get_v1_unlock_height -> u32 with 1
+clarity/src/vm/costs/mod.rs:104: replace <impl MemoryConsumer for Value>::get_memory_use -> u64 with 1
+clarity/src/vm/events.rs:41: replace StacksTransactionEvent::json_serialize -> serde_json::Value with Default::default()
+clarity/src/vm/database/structures.rs:975: replace STXBalance::was_locked_by_v2 -> bool with false
+clarity/src/vm/docs/mod.rs:809: replace get_signature -> Option<String> with None
+clarity/src/vm/representations.rs:388: replace PreSymbolicExpression::match_placeholder -> Option<&str> with None
+clarity/src/vm/test_util/mod.rs:198: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_burn_block_height -> Option<u32> with Some(1)
+clarity/src/vm/analysis/types.rs:147: replace ContractAnalysis::add_fungible_token with ()
+clarity/src/vm/test_util/mod.rs:263: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_pox_payout_addrs -> Option<(Vec<TupleData>, u128)> with Some((vec![], 0))
+clarity/src/vm/analysis/errors.rs:268: replace <impl Error for CheckErrors>::source -> Option<&(dyn error::Error +'static)> with None
+clarity/src/vm/types/mod.rs:1483: replace TupleData::is_empty -> bool with true
+clarity/src/vm/database/clarity_db.rs:233: replace <impl BurnStateDB for &dyn BurnStateDB>::get_pox_reward_cycle_length -> u32 with 1
+clarity/src/vm/database/structures.rs:386: replace STXBalanceSnapshot<'db, 'conn>::has_unlockable_tokens -> bool with false
+clarity/src/vm/database/clarity_db.rs:271: replace <impl HeadersDB for NullHeadersDB>::get_burn_header_hash_for_block -> Option<BurnchainHeaderHash> with None
+clarity/src/vm/test_util/mod.rs:181: replace <impl HeadersDB for UnitTestHeaderDB>::get_burnchain_tokens_spent_for_block -> Option<u128> with None
+clarity/src/vm/tests/assets.rs:821: replace test_total_supply with ()
+clarity/src/vm/tests/assets.rs:985: replace test_simple_naming_system with ()
+clarity/src/vm/costs/mod.rs:1153: replace ExecutionCost::proportion_dot_product -> u64 with 1
+clarity/src/vm/tests/traits.rs:1672: replace test_pass_embedded_trait_to_subtrait_err with ()
+clarity/src/vm/costs/mod.rs:303: replace <impl PartialEq for LimitedCostTracker>::eq -> bool with false
+clarity/src/vm/database/structures.rs:641: replace STXBalanceSnapshot<'db, 'conn>::increase_lock_v3 with ()
+clarity/src/vm/database/structures.rs:48: replace <impl ClarityDeserializable for String>::deserialize -> String with "xyzzy".into()
+clarity/src/vm/database/structures.rs:920: replace STXBalance::get_locked_balance_at_burn_block -> (u128, u64) with (1, 0)
+clarity/src/vm/tests/traits.rs:325: replace test_dynamic_dispatch_by_implementing_imported_trait_mul_funcs with ()
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:104: replace <impl CostTracker for TypeChecker<'_, '_>>::reset_memory with ()
+clarity/src/vm/database/clarity_db.rs:184: replace <impl HeadersDB for &dyn HeadersDB>::get_tokens_earned_for_block -> Option<u128> with Some(1)
+clarity/src/vm/database/clarity_db.rs:169: replace <impl HeadersDB for &dyn HeadersDB>::get_burn_block_time_for_block -> Option<u64> with None
+clarity/src/vm/database/clarity_db.rs:634: replace ClarityDatabase<'a>::fetch_metadata_manual -> Result<Option<T>> with Ok(None)
+clarity/src/vm/analysis/analysis_db.rs:84: replace AnalysisDatabase<'a>::has_contract -> bool with true
+clarity/src/vm/analysis/types.rs:183: replace ContractAnalysis::get_persisted_variable_type -> Option<&TypeSignature> with None
+clarity/src/vm/database/clarity_db.rs:813: replace ClarityDatabase<'a>::get_pox_3_activation_height -> u32 with 0
+clarity/src/vm/diagnostic.rs:56: replace Diagnostic::add_span with ()
+clarity/src/vm/costs/mod.rs:1153: replace ExecutionCost::proportion_dot_product -> u64 with 0
+clarity/src/vm/test_util/mod.rs:224: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_v1_unlock_height -> u32 with 1
+clarity/src/vm/database/sqlite.rs:153: replace SqliteConnection::has_entry -> bool with true
+clarity/src/vm/database/clarity_db.rs:332: replace <impl BurnStateDB for NullBurnStateDB>::get_burn_block_height -> Option<u32> with None
+clarity/src/vm/contexts.rs:926: replace <impl CostTracker for GlobalContext<'_, '_>>::short_circuit_contract_call -> std::result::Result<bool, CostErrors> with Ok(true)
+clarity/src/vm/contexts.rs:1878: replace LocalContext<'a>::depth -> u16 with 0
+clarity/src/vm/ast/parser/v2/lexer/error.rs:36: replace <impl DiagnosableError for LexerError>::message -> String with String::new()
+clarity/src/vm/types/signatures.rs:139: replace SequenceSubtype::is_list_type -> bool with false
+clarity/src/vm/contexts.rs:457: replace AssetMap::get_stx -> Option<u128> with None
+clarity/src/vm/test_util/mod.rs:135: replace <impl HeadersDB for UnitTestHeaderDB>::get_vrf_seed_for_block -> Option<VRFSeed> with None
+clarity/src/vm/types/signatures.rs:1690: replace TypeSignature::type_size -> Result<u32> with Ok(0)
+clarity/src/vm/database/clarity_db.rs:973: replace ClarityDatabase<'a>::get_miner_spend_total -> u128 with 1
+clarity/src/vm/costs/mod.rs:826: replace LimitedCostTracker::get_memory -> u64 with 1
+clarity/src/vm/types/signatures.rs:853: replace TupleTypeSignature::is_empty -> bool with false
+clarity/src/vm/ast/parser/v1.rs:108: replace get_lines_at -> Vec<usize> with vec![1]
+clarity/src/vm/database/structures.rs:988: replace STXBalance::has_locked_tokens_at_burn_block -> bool with false
+clarity/src/vm/types/serialization.rs:1325: replace <impl StacksMessageCodec for Value>::consensus_serialize -> Result<(), codec_error> with Ok(())
+clarity/src/vm/types/signatures.rs:1766: replace TupleTypeSignature::size -> u32 with 0
+clarity/src/vm/test_util/mod.rs:88: replace is_err_code_i128 -> bool with true
+clarity/src/vm/contexts.rs:856: replace OwnedEnvironment<'a, 'hooks>::add_eval_hook with ()
+clarity/src/vm/types/signatures.rs:1748: replace TupleTypeSignature::type_size -> Option<u32> with Some(1)
+clarity/src/vm/database/clarity_db.rs:181: replace <impl HeadersDB for &dyn HeadersDB>::get_burnchain_tokens_spent_for_winning_block -> Option<u128> with Some(1)
+clarity/src/vm/database/clarity_db.rs:184: replace <impl HeadersDB for &dyn HeadersDB>::get_tokens_earned_for_block -> Option<u128> with None
+clarity/src/vm/contexts.rs:1472: replace Environment<'a, 'b, 'hooks>::register_nft_transfer_event -> Result<()> with Ok(())
+clarity/src/vm/database/structures.rs:767: replace STXBalance::effective_unlock_height -> u64 with 0
+clarity/src/vm/docs/contracts.rs:178: replace produce_docs_refs -> BTreeMap<String, ContractRef> with BTreeMap::new()
+clarity/src/vm/ast/errors.rs:296: replace <impl DiagnosableError for ParseErrors>::suggestion -> Option<String> with None
+clarity/src/vm/database/structures.rs:790: replace STXBalance::amount_locked -> u128 with 0
+clarity/src/vm/analysis/analysis_db.rs:70: replace AnalysisDatabase<'a>::storage_key -> &'static str with "xyzzy"
+clarity/src/vm/ast/errors.rs:141: replace <impl Error for ParseError>::source -> Option<&(dyn error::Error +'static)> with None
+clarity/src/vm/types/mod.rs:1044: replace Value::expect_i128 -> i128 with 1
+clarity/src/vm/costs/mod.rs:1012: replace <impl CostTracker for LimitedCostTracker>::reset_memory with ()
+clarity/src/vm/representations.rs:483: replace SymbolicExpression::set_span with ()
+clarity/src/vm/database/clarity_db.rs:281: replace <impl HeadersDB for NullHeadersDB>::get_vrf_seed_for_block -> Option<VRFSeed> with None
+clarity/src/vm/costs/mod.rs:950: replace add_memory -> std::result::Result<(), CostErrors> with Ok(())
+clarity/src/vm/database/structures.rs:971: replace STXBalance::was_locked_by_v1 -> bool with false
+clarity/src/vm/test_util/mod.rs:160: replace <impl HeadersDB for UnitTestHeaderDB>::get_burn_block_height_for_block -> Option<u32> with Some(1)
+clarity/src/vm/tests/traits.rs:1891: replace test_pass_embedded_trait_to_subtrait_option_list with ()
+clarity/src/vm/tests/contracts.rs:247: replace tx_sponsor_contract_asserts with ()
+clarity/src/vm/database/clarity_db.rs:237: replace <impl BurnStateDB for &dyn BurnStateDB>::get_pox_rejection_fraction -> u64 with 1
+clarity/src/vm/tests/traits.rs:536: replace test_dynamic_dispatch_mismatched_args with ()
+clarity/src/vm/analysis/types.rs:175: replace ContractAnalysis::get_map_type -> Option<&(TypeSignature, TypeSignature)> with None
+clarity/src/vm/database/clarity_store.rs:299: replace <impl ClarityBackingStore for MemoryBackingStore>::get_with_proof -> Option<(String, Vec<u8>)> with Some((String::new(), vec![0]))
+clarity/src/vm/database/clarity_db.rs:832: replace ClarityDatabase<'a>::get_current_burnchain_block_height -> u32 with 1
+clarity/src/vm/costs/mod.rs:1219: replace ExecutionCost::multiply -> Result<()> with Ok(())
+clarity/src/vm/costs/mod.rs:303: replace <impl PartialEq for LimitedCostTracker>::eq -> bool with true
+clarity/src/vm/database/clarity_db.rs:1019: replace ClarityDatabase<'a>::make_microblock_pubkey_height_key -> String with String::new()
+clarity/src/vm/database/clarity_store.rs:231: replace <impl ClarityBackingStore for NullBackingStore>::get_with_proof -> Option<(String, Vec<u8>)> with Some((String::new(), vec![]))
+clarity/src/vm/ast/types.rs:63: replace ContractAST::add_implemented_trait with ()
+clarity/src/vm/database/structures.rs:920: replace STXBalance::get_locked_balance_at_burn_block -> (u128, u64) with (0, 1)
+clarity/src/vm/test_util/mod.rs:141: replace <impl HeadersDB for UnitTestHeaderDB>::get_stacks_block_header_hash_for_block -> Option<BlockHeaderHash> with None
+clarity/src/vm/database/clarity_db.rs:802: replace ClarityDatabase<'a>::get_current_block_height -> u32 with 1
+clarity/src/vm/ast/errors.rs:122: replace ParseError::set_pre_expressions with ()
+clarity/src/vm/database/clarity_db.rs:813: replace ClarityDatabase<'a>::get_pox_3_activation_height -> u32 with 1
+clarity/src/vm/tests/traits.rs:34: replace test_dynamic_dispatch_by_defining_trait with ()
+clarity/src/vm/analysis/types.rs:143: replace ContractAnalysis::add_non_fungible_token with ()
+clarity/src/vm/test_util/mod.rs:240: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_pox_reward_cycle_length -> u32 with 0
+clarity/src/vm/errors.rs:157: replace <impl Error for Error>::source -> Option<&(dyn error::Error +'static)> with None
+clarity/src/vm/database/clarity_db.rs:808: replace ClarityDatabase<'a>::get_v1_unlock_height -> u32 with 0
+clarity/src/vm/database/clarity_db.rs:1951: replace ClarityDatabase<'a>::get_burn_block_height -> Option<u32> with Some(1)
+clarity/src/vm/docs/mod.rs:809: replace get_signature -> Option<String> with Some(String::new())
+clarity/src/vm/database/key_value_wrapper.rs:150: replace <impl From for RollbackWrapperPersistedLog>::from -> RollbackWrapperPersistedLog with Default::default()
+clarity/src/vm/database/structures.rs:1047: replace STXBalance::has_unlockable_tokens_at_burn_block -> bool with false
+clarity/src/vm/test_util/mod.rs:210: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_stacks_epoch -> Option<StacksEpoch> with None
+clarity/src/vm/costs/mod.rs:1056: replace <impl CostTracker for &mut LimitedCostTracker>::add_memory -> std::result::Result<(), CostErrors> with Ok(())
+clarity/src/vm/database/key_value_wrapper.rs:354: replace RollbackWrapper<'a>::get_with_proof -> Option<(T, Vec<u8>)> with None
+clarity/src/vm/tests/traits.rs:593: replace test_dynamic_dispatch_mismatched_returned with ()
+clarity/src/vm/database/clarity_db.rs:198: replace <impl BurnStateDB for &dyn BurnStateDB>::get_pox_3_activation_height -> u32 with 0
+clarity/src/vm/test_util/mod.rs:172: replace <impl HeadersDB for UnitTestHeaderDB>::get_consensus_hash_for_block -> Option<ConsensusHash> with None
+clarity/src/vm/types/signatures.rs:1771: replace TupleTypeSignature::max_depth -> u8 with 0
+clarity/src/vm/types/mod.rs:1071: replace Value::expect_list -> Vec<Value> with vec![]
+clarity/src/vm/representations.rs:258: replace PreSymbolicExpression::copy_span with ()
+clarity/src/vm/tests/contracts.rs:369: replace test_fully_qualified_contract_call with ()
+clarity/src/vm/events.rs:223: replace NFTTransferEventData::json_serialize -> serde_json::Value with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:101: replace <impl CostTracker for TypeChecker<'_, '_>>::drop_memory with ()
+clarity/src/vm/database/structures.rs:463: replace STXBalanceSnapshot<'db, 'conn>::is_v2_locked -> bool with true
+clarity/src/vm/costs/mod.rs:832: replace LimitedCostTracker::get_memory_limit -> u64 with 0
+clarity/src/vm/types/signatures.rs:1771: replace TupleTypeSignature::max_depth -> u8 with 1
+clarity/src/vm/types/serialization.rs:78: replace <impl Display for SerializationError>::fmt -> std::fmt::Result with Ok(Default::default())
+clarity/src/vm/tests/assets.rs:935: replace test_overlapping_nfts with ()
+clarity/src/vm/database/structures.rs:538: replace STXBalanceSnapshot<'db, 'conn>::lock_tokens_v2 with ()
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:107: replace <impl CostTracker for TypeChecker<'_, '_>>::short_circuit_contract_call -> std::result::Result<bool, CostErrors> with Ok(false)
+clarity/src/vm/events.rs:348: replace SmartContractEventData::json_serialize -> serde_json::Value with Default::default()
+clarity/src/vm/costs/mod.rs:716: replace LimitedCostTracker::default_cost_contract_for_epoch -> String with "xyzzy".into()
+clarity/src/vm/tests/traits.rs:1600: replace test_pass_embedded_trait_to_subtrait_ok with ()
+clarity/src/vm/types/signatures.rs:139: replace SequenceSubtype::is_list_type -> bool with true
+clarity/src/vm/database/clarity_db.rs:166: replace <impl HeadersDB for &dyn HeadersDB>::get_vrf_seed_for_block -> Option<VRFSeed> with None
+clarity/src/vm/database/clarity_store.rs:247: replace <impl ClarityBackingStore for NullBackingStore>::get_open_chain_tip_height -> u32 with 0
+clarity/src/vm/test_util/mod.rs:191: replace <impl HeadersDB for UnitTestHeaderDB>::get_tokens_earned_for_block -> Option<u128> with None
+clarity/src/vm/database/clarity_db.rs:1886: replace ClarityDatabase<'a>::make_key_for_account_unlock_height -> String with String::new()
+clarity/src/vm/coverage.rs:78: replace CoverageReporter::to_file -> std::io::Result<()> with Ok(())
+clarity/src/vm/tests/traits.rs:1100: replace test_contract_of_value with ()
+clarity/src/vm/database/structures.rs:616: replace STXBalanceSnapshot<'db, 'conn>::extend_lock_v3 with ()
+clarity/src/vm/database/clarity_db.rs:287: replace <impl HeadersDB for NullHeadersDB>::get_stacks_block_header_hash_for_block -> Option<BlockHeaderHash> with None
+clarity/src/vm/database/clarity_db.rs:181: replace <impl HeadersDB for &dyn HeadersDB>::get_burnchain_tokens_spent_for_winning_block -> Option<u128> with Some(0)
+clarity/src/vm/contexts.rs:882: replace <impl CostTracker for Environment<'_, '_, '_>>::drop_memory with ()
+clarity/src/vm/representations.rs:464: replace SymbolicExpression::cons -> SymbolicExpression with Default::default()
+clarity/src/vm/test_util/mod.rs:263: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_pox_payout_addrs -> Option<(Vec<TupleData>, u128)> with None
+clarity/src/vm/test_util/mod.rs:181: replace <impl HeadersDB for UnitTestHeaderDB>::get_burnchain_tokens_spent_for_block -> Option<u128> with Some(1)
+clarity/src/vm/database/clarity_db.rs:699: replace ClarityDatabase<'a>::has_contract -> bool with false
+clarity/src/vm/test_util/mod.rs:186: replace <impl HeadersDB for UnitTestHeaderDB>::get_burnchain_tokens_spent_for_winning_block -> Option<u128> with Some(0)
+clarity/src/vm/costs/mod.rs:1025: replace <impl CostTracker for LimitedCostTracker>::short_circuit_contract_call -> Result<bool> with Ok(true)
+clarity/src/vm/events.rs:297: replace FTTransferEventData::json_serialize -> serde_json::Value with Default::default()
+clarity/src/vm/types/signatures.rs:853: replace TupleTypeSignature::is_empty -> bool with true
+clarity/src/vm/tests/assets.rs:138: replace test_native_stx_ops with ()
+clarity/src/vm/database/clarity_db.rs:808: replace ClarityDatabase<'a>::get_v1_unlock_height -> u32 with 1
+clarity/src/vm/database/clarity_db.rs:202: replace <impl BurnStateDB for &dyn BurnStateDB>::get_burn_block_height -> Option<u32> with Some(1)
+clarity/src/vm/contexts.rs:885: replace <impl CostTracker for Environment<'_, '_, '_>>::reset_memory with ()
+clarity/src/vm/costs/mod.rs:89: replace analysis_typecheck_cost -> Result<()> with Ok(())
+clarity/src/vm/database/clarity_db.rs:252: replace <impl BurnStateDB for &dyn BurnStateDB>::get_pox_payout_addrs -> Option<(Vec<TupleData>, u128)> with Some((vec![], 1))
+clarity/src/vm/types/mod.rs:554: replace <impl Debug for CharType>::fmt -> fmt::Result with Ok(Default::default())
+clarity/src/vm/database/structures.rs:472: replace STXBalanceSnapshot<'db, 'conn>::increase_lock_v2 with ()
+clarity/src/vm/costs/mod.rs:1025: replace <impl CostTracker for LimitedCostTracker>::short_circuit_contract_call -> Result<bool> with Ok(false)
+clarity/src/vm/costs/mod.rs:1196: replace ExecutionCost::add_runtime -> Result<()> with Ok(())
+clarity/src/vm/tests/contracts.rs:1116: replace test_cc_trait_stack_depth with ()
+clarity/src/vm/docs/contracts.rs:69: replace doc_execute -> Result<Option<Value>, vm::Error> with Ok(None)
+clarity/src/vm/database/clarity_db.rs:157: replace <impl HeadersDB for &dyn HeadersDB>::get_stacks_block_header_hash_for_block -> Option<BlockHeaderHash> with None
+clarity/src/vm/database/clarity_db.rs:364: replace <impl BurnStateDB for NullBurnStateDB>::get_stacks_epoch_by_epoch_id -> Option<StacksEpoch> with None
+clarity/src/vm/database/clarity_db.rs:202: replace <impl BurnStateDB for &dyn BurnStateDB>::get_burn_block_height -> Option<u32> with None
+clarity/src/vm/ast/parser/v2/lexer/token.rs:82: replace Token::reproduce -> String with String::new()
+clarity/src/vm/database/clarity_store.rs:299: replace <impl ClarityBackingStore for MemoryBackingStore>::get_with_proof -> Option<(String, Vec<u8>)> with Some((String::new(), vec![]))
+clarity/src/vm/tests/traits.rs:1289: replace test_return_trait_with_contract_of_wrapped_in_let with ()
+clarity/src/vm/costs/mod.rs:1000: replace <impl CostTracker for LimitedCostTracker>::add_memory -> std::result::Result<(), CostErrors> with Ok(())
+clarity/src/vm/contexts.rs:1458: replace Environment<'a, 'b, 'hooks>::register_stx_burn_event -> Result<()> with Ok(())
+clarity/src/vm/database/clarity_db.rs:326: replace <impl HeadersDB for NullHeadersDB>::get_tokens_earned_for_block -> Option<u128> with Some(0)
+clarity/src/vm/database/clarity_db.rs:1886: replace ClarityDatabase<'a>::make_key_for_account_unlock_height -> String with "xyzzy".into()
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:107: replace <impl CostTracker for TypeChecker<'_, '_>>::short_circuit_contract_call -> std::result::Result<bool, CostErrors> with Ok(true)
+clarity/src/vm/database/clarity_db.rs:1019: replace ClarityDatabase<'a>::make_microblock_pubkey_height_key -> String with "xyzzy".into()
+clarity/src/vm/contexts.rs:1784: replace GlobalContext<'a, 'hooks>::destruct -> Option<(ClarityDatabase<'a>, LimitedCostTracker)> with None
+clarity/src/mod.rs:96: replace version_string -> String with "xyzzy".into()
+clarity/src/vm/test_util/mod.rs:149: replace <impl HeadersDB for UnitTestHeaderDB>::get_burn_block_time_for_block -> Option<u64> with None
+clarity/src/vm/contexts.rs:705: replace OwnedEnvironment<'a, 'hooks>::initialize_versioned_contract -> Result<((), AssetMap, Vec<StacksTransactionEvent>)> with Ok(((), Default::default(), vec![]))
+clarity/src/vm/database/structures.rs:424: replace STXBalanceSnapshot<'db, 'conn>::lock_tokens_v1 with ()
+clarity/src/vm/test_util/mod.rs:149: replace <impl HeadersDB for UnitTestHeaderDB>::get_burn_block_time_for_block -> Option<u64> with Some(0)
+clarity/src/vm/database/structures.rs:376: replace STXBalanceSnapshot<'db, 'conn>::has_locked_tokens -> bool with false
+clarity/src/vm/types/signatures.rs:1696: replace TypeSignature::inner_type_size -> Option<u32> with Some(0)
+clarity/src/vm/contexts.rs:490: replace AssetMap::get_nonfungible_tokens -> Option<&Vec<Value>> with None
+clarity/src/vm/types/mod.rs:1090: replace Value::expect_bool -> bool with true
+clarity/src/vm/database/key_value_wrapper.rs:517: replace RollbackWrapper<'a>::has_entry -> bool with true
+clarity/src/vm/database/clarity_db.rs:1943: replace ClarityDatabase<'a>::set_account_nonce with ()
+clarity/src/vm/test_util/mod.rs:198: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_burn_block_height -> Option<u32> with Some(0)
+clarity/src/vm/database/clarity_db.rs:860: replace ClarityDatabase<'a>::get_block_time -> u64 with 1
+clarity/src/vm/contexts.rs:1543: replace Environment<'a, 'b, 'hooks>::register_ft_mint_event -> Result<()> with Ok(())
+clarity/src/vm/costs/mod.rs:994: replace <impl CostTracker for LimitedCostTracker>::add_cost -> std::result::Result<(), CostErrors> with Ok(())
+clarity/src/vm/database/clarity_db.rs:395: replace <impl BurnStateDB for NullBurnStateDB>::get_pox_payout_addrs -> Option<(Vec<TupleData>, u128)> with Some((vec![], 0))
+clarity/src/vm/events.rs:248: replace NFTMintEventData::json_serialize -> serde_json::Value with Default::default()
+clarity/src/vm/tests/contracts.rs:1018: replace test_as_max_len with ()
+clarity/src/vm/coverage.rs:170: replace CoverageReporter::register_src_file -> std::io::Result<()> with Ok(())
+clarity/src/vm/database/clarity_db.rs:1957: replace ClarityDatabase<'a>::get_stacks_epoch -> Option<StacksEpoch> with None
+clarity/src/vm/types/mod.rs:256: replace SequenceData::element_size -> u32 with 1
+clarity/src/vm/database/clarity_db.rs:533: replace ClarityDatabase<'a>::make_key_for_trip -> String with "xyzzy".into()
+clarity/src/vm/test_util/mod.rs:247: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_burn_start_height -> u32 with 1
+clarity/src/vm/types/mod.rs:1201: replace ListData::is_empty -> bool with true
+clarity/src/vm/database/clarity_store.rs:299: replace <impl ClarityBackingStore for MemoryBackingStore>::get_with_proof -> Option<(String, Vec<u8>)> with Some(("xyzzy".into(), vec![]))
+clarity/src/vm/costs/mod.rs:1137: replace ExecutionCost::proportion_largest_dimension -> u64 with 1
+clarity/src/vm/database/clarity_db.rs:525: replace ClarityDatabase<'a>::get_with_proof -> Option<(T, Vec<u8>)> with None
+clarity/src/vm/database/structures.rs:680: replace STXBalanceSnapshot<'db, 'conn>::is_v3_locked -> bool with true
diff --git a/mutants/clarity/mutants.out/timeout.txt b/mutation-testing/packages-output/clarity/timeout.txt
similarity index 100%
rename from mutants/clarity/mutants.out/timeout.txt
rename to mutation-testing/packages-output/clarity/timeout.txt
diff --git a/mutation-testing/packages-output/clarity/unviable.txt b/mutation-testing/packages-output/clarity/unviable.txt
new file mode 100644
index 0000000000..819f07c57f
--- /dev/null
+++ b/mutation-testing/packages-output/clarity/unviable.txt
@@ -0,0 +1,1791 @@
+clarity/src/vm/ast/parser/v1.rs:101: replace get_value_or_err -> ParseResult<String> with ParseResult::from_iter([String::new()])
+clarity/src/vm/contexts.rs:801: replace OwnedEnvironment<'a, 'hooks>::eval_raw -> Result<(Value, AssetMap, Vec<StacksTransactionEvent>)> with Ok((Default::default(), Default::default(), vec![]))
+clarity/src/vm/callables.rs:376: replace CallableType::get_identifier -> FunctionIdentifier with Default::default()
+clarity/src/vm/ast/parser/v2/mod.rs:1109: replace parse_collect_diagnostics -> (Vec<PreSymbolicExpression>, Vec<Diagnostic>, bool) with (vec![Default::default()], vec![], false)
+clarity/src/vm/ast/parser/v1.rs:192: replace inner_lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::new()
+clarity/src/vm/ast/parser/v2/mod.rs:219: replace Parser<'a>::handle_open_node -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::new()
+clarity/src/vm/callables.rs:144: replace DefinedFunction::execute_apply -> Result<Value> with Ok(Default::default())
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:160: replace Lexer<'a>::proceed_through_error -> LexResult<String> with LexResult::from_iter(["xyzzy".into()])
+clarity/src/vm/ast/parser/v2/mod.rs:219: replace Parser<'a>::handle_open_node -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::from_iter([Some(Default::default())])
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:78: replace Lexer<'a>::read_char -> LexResult<()> with LexResult::from_iter([()])
+clarity/src/vm/functions/arithmetic.rs:504: replace special_greater -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:111: replace Lexer<'a>::report_line_ending -> LexResult<()> with LexResult::from_iter([()])
+clarity/src/vm/ast/definition_sorter/mod.rs:115: replace DefinitionSorter::probe_for_dependencies -> ParseResult<()> with ParseResult::new(())
+clarity/src/vm/ast/parser/v2/mod.rs:1093: replace parse -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::from_iter([vec![Default::default()]])
+clarity/src/vm/test_util/mod.rs:172: replace <impl HeadersDB for UnitTestHeaderDB>::get_consensus_hash_for_block -> Option<ConsensusHash> with Some(Default::default())
+clarity/src/vm/ast/definition_sorter/mod.rs:456: replace GraphWalker::get_sorted_dependencies -> ParseResult<Vec<usize>> with ParseResult::from(vec![])
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1346: replace TypeChecker<'a, 'b>::type_check_define_variable -> CheckResult<(ClarityName, TypeSignature)> with CheckResult::from_iter([(Default::default(), Default::default())])
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:326: replace Lexer<'a>::read_integer -> LexResult<Token> with LexResult::from(Default::default())
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:136: replace ContractContext::add_variable_type -> CheckResult<()> with CheckResult::from_iter([()])
+clarity/src/vm/types/mod.rs:1415: replace <impl From for Value>::from -> Self with Default::default()
+clarity/src/vm/analysis/analysis_db.rs:189: replace AnalysisDatabase<'a>::get_defined_trait -> CheckResult<Option<BTreeMap<ClarityName, FunctionSignature>>> with CheckResult::new(None)
+clarity/src/vm/functions/arithmetic.rs:557: replace native_sub -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
+clarity/src/vm/docs/contracts.rs:48: replace make_func_ref -> FunctionRef with Default::default()
+clarity/src/vm/types/signatures.rs:1301: replace TypeSignature::list_of -> Result<TypeSignature> with Ok(Default::default())
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:740: replace TypeChecker<'a, 'b>::type_check_define_variable -> CheckResult<(ClarityName, TypeSignature)> with CheckResult::new()
+clarity/src/vm/ast/parser/v1.rs:720: replace parse -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::new()
+clarity/src/vm/functions/arithmetic.rs:47: replace I128Ops::make_value -> InterpreterResult<Value> with InterpreterResult::new()
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:145: replace FunctionType::check_args_2_05 -> CheckResult<TypeSignature> with CheckResult::new(Default::default())
+clarity/src/vm/analysis/type_checker/mod.rs:45: replace FunctionType::check_args -> CheckResult<TypeSignature> with CheckResult::new(Default::default())
+clarity/src/vm/ast/mod.rs:288: replace build_ast_precheck_size -> ParseResult<ContractAST> with ParseResult::from_iter([Default::default()])
+clarity/src/vm/analysis/type_checker/v2_05/natives/sequences.rs:296: replace check_special_as_max_len -> TypeResult with Default::default()
+clarity/src/vm/ast/traits_resolver/mod.rs:201: replace TraitsResolver::probe_for_generics -> ParseResult<()> with ParseResult::new(())
+clarity/src/vm/ast/definition_sorter/mod.rs:456: replace GraphWalker::get_sorted_dependencies -> ParseResult<Vec<usize>> with ParseResult::new(vec![])
+clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs:479: replace check_principal_of -> TypeResult with Default::default()
+clarity/src/vm/costs/mod.rs:270: replace LimitedCostTracker::cost_function_references -> HashMap<&'static ClarityCostFunction, ClarityCostFunctionReference> with HashMap::from_iter([(&Default::default(), Default::default())])
+clarity/src/vm/ast/parser/v1.rs:455: replace lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::from_iter([vec![(Default::default(), 0, 0)]])
+clarity/src/vm/database/clarity_db.rs:947: replace ClarityDatabase<'a>::get_block_vrf_seed -> VRFSeed with Default::default()
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:474: replace Lexer<'a>::read_utf8_encoding -> LexResult<Result<String, String>> with LexResult::new(Ok(String::new()))
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:186: replace ContractContext::check_function_type -> CheckResult<()> with CheckResult::from_iter([()])
+clarity/src/vm/ast/expression_identifier/mod.rs:23: replace inner_relabel -> ParseResult<u64> with ParseResult::from(0)
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:785: replace clarity2_lookup_trait -> CheckResult<BTreeMap<ClarityName, FunctionSignature>> with CheckResult::new(BTreeMap::from_iter([(Default::default(), Default::default())]))
+clarity/src/vm/functions/conversions.rs:174: replace native_string_to_uint -> Result<Value> with Ok(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:292: replace ContractContext::add_used_trait -> CheckResult<()> with CheckResult::from_iter([()])
+clarity/src/vm/functions/arithmetic.rs:377: replace native_bitwise_or -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
+clarity/src/vm/ast/traits_resolver/mod.rs:36: replace <impl BuildASTPass for TraitsResolver>::run_pass -> ParseResult<()> with ParseResult::from(())
+clarity/src/vm/functions/arithmetic.rs:572: replace native_log2 -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
+clarity/src/vm/analysis/analysis_db.rs:189: replace AnalysisDatabase<'a>::get_defined_trait -> CheckResult<Option<BTreeMap<ClarityName, FunctionSignature>>> with CheckResult::from_iter([None])
+clarity/src/vm/database/key_value_wrapper.rs:495: replace RollbackWrapper<'a>::get_metadata_manual -> InterpreterResult<Option<String>> with InterpreterResult::new(None)
+clarity/src/vm/functions/arithmetic.rs:462: replace special_leq -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:145: replace FunctionType::check_args_2_05 -> CheckResult<TypeSignature> with CheckResult::from(Default::default())
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:210: replace Lexer<'a>::read_identifier -> LexResult<Token> with LexResult::from_iter([Default::default()])
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:839: replace contract_analysis_size -> CheckResult<u64> with CheckResult::from(1)
+clarity/src/vm/functions/sequences.rs:120: replace special_map -> Result<Value> with Ok(Default::default())
+clarity/src/vm/costs/mod.rs:326: replace load_state_summary -> Result<CostStateSummary> with Ok(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs:39: replace get_simple_native_or_user_define -> CheckResult<FunctionType> with CheckResult::new()
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:546: replace TypeChecker<'a, 'b>::type_check_define_function -> CheckResult<(ClarityName, FixedFunction)> with CheckResult::from((Default::default(), Default::default()))
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:172: replace ContractContext::add_trait -> CheckResult<()> with CheckResult::from_iter([()])
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:86: replace TraitContext::add_used_trait -> CheckResult<()> with CheckResult::from(())
+clarity/src/vm/costs/mod.rs:259: replace LimitedCostTracker::contract_call_circuits -> HashMap<(QualifiedContractIdentifier, ClarityName), ClarityCostFunctionReference> with HashMap::from_iter([((Default::default(), Default::default()), Default::default())])
+clarity/src/vm/analysis/type_checker/v2_05/natives/assets.rs:28: replace check_special_get_owner -> TypeResult with Default::default()
+clarity/src/vm/ast/parser/v2/mod.rs:521: replace Parser<'a>::read_principal -> ParseResult<PreSymbolicExpression> with ParseResult::from(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:123: replace <impl AnalysisPass for TypeChecker<'_, '_>>::run_pass -> CheckResult<()> with CheckResult::from_iter([()])
+clarity/src/vm/ast/traits_resolver/mod.rs:36: replace <impl BuildASTPass for TraitsResolver>::run_pass -> ParseResult<()> with ParseResult::new()
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:808: replace TypeChecker<'a, 'b>::try_type_check_define -> CheckResult<Option<()>> with CheckResult::from_iter([None])
+clarity/src/vm/docs/mod.rs:2601: replace make_all_api_reference -> ReferenceAPIs with Default::default()
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:716: replace TypeChecker<'a, 'b>::inner_type_check -> TypeResult with Default::default()
+clarity/src/vm/callables.rs:355: replace DefinedFunction::get_arguments -> &Vec<ClarityName> with &vec![]
+clarity/src/vm/ast/stack_depth_checker.rs:53: replace check_vary -> ParseResult<()> with ParseResult::from(())
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:172: replace ContractContext::add_trait -> CheckResult<()> with CheckResult::from(())
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:185: replace Lexer<'a>::proceed_through_error_string -> LexResult<String> with LexResult::from("xyzzy".into())
+clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs:195: replace check_special_tuple_cons -> TypeResult with Default::default()
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:61: replace ContractContext::check_name_used -> CheckResult<()> with CheckResult::from(())
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:168: replace ContractContext::check_name_used -> CheckResult<()> with CheckResult::from_iter([()])
+clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs:699: replace TypedNativeFunction::type_native_function -> TypedNativeFunction with Default::default()
+clarity/src/vm/types/signatures.rs:999: replace TypeSignature::contract_name_string_ascii_type -> TypeSignature with Default::default()
+clarity/src/vm/types/mod.rs:1433: replace <impl From for PrincipalData>::from -> Self with Default::default()
+clarity/src/vm/ast/expression_identifier/mod.rs:58: replace ExpressionIdentifier::run_expression_pass -> ParseResult<()> with ParseResult::from_iter([()])
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:88: replace ContractContext::get_nft_type -> Option<&TypeSignature> with Some(&Default::default())
+clarity/src/vm/ast/expression_identifier/mod.rs:58: replace ExpressionIdentifier::run_expression_pass -> ParseResult<()> with ParseResult::from(())
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:269: replace ContractContext::add_nft -> CheckResult<()> with CheckResult::from_iter([()])
+clarity/src/vm/ast/definition_sorter/mod.rs:357: replace DefinitionSorter::probe_for_dependencies_in_wrapped_key_value_pairs -> ParseResult<()> with ParseResult::from(())
+clarity/src/vm/database/clarity_db.rs:281: replace <impl HeadersDB for NullHeadersDB>::get_vrf_seed_for_block -> Option<VRFSeed> with Some(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1023: replace TypeChecker<'a, 'b>::type_check_all -> CheckResult<Vec<TypeSignature>> with CheckResult::new(vec![Default::default()])
+clarity/src/vm/mod.rs:169: replace lookup_variable -> Result<Value> with Ok(Default::default())
+clarity/src/vm/analysis/analysis_db.rs:137: replace AnalysisDatabase<'a>::get_clarity_version -> CheckResult<ClarityVersion> with CheckResult::new()
+clarity/src/vm/database/clarity_store.rs:315: replace <impl ClarityBackingStore for MemoryBackingStore>::get_open_chain_tip -> StacksBlockId with Default::default()
+clarity/src/vm/analysis/read_only_checker/mod.rs:112: replace ReadOnlyChecker<'a, 'b>::check_top_level_expression -> CheckResult<()> with CheckResult::from_iter([()])
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:198: replace ContractContext::get_function_type -> Option<&FunctionType> with Some(&Default::default())
+clarity/src/vm/test_util/mod.rs:168: replace <impl HeadersDB for UnitTestHeaderDB>::get_miner_address -> Option<StacksAddress> with Some(Default::default())
+clarity/src/vm/ast/stack_depth_checker.rs:53: replace check_vary -> ParseResult<()> with ParseResult::new()
+clarity/src/vm/ast/parser/v1.rs:192: replace inner_lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::from_iter([vec![(Default::default(), 0, 0)]])
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:210: replace Lexer<'a>::read_identifier -> LexResult<Token> with LexResult::new()
+clarity/src/vm/database/sqlite.rs:182: replace SqliteConnection::memory -> Result<Connection> with Ok(Default::default())
+clarity/src/vm/analysis/read_only_checker/mod.rs:112: replace ReadOnlyChecker<'a, 'b>::check_top_level_expression -> CheckResult<()> with CheckResult::new(())
+clarity/src/vm/functions/tuples.rs:79: replace tuple_merge -> Result<Value> with Ok(Default::default())
+clarity/src/vm/types/mod.rs:1108: replace Value::expect_optional -> Option<Value> with Some(Default::default())
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:185: replace Lexer<'a>::proceed_through_error_string -> LexResult<String> with LexResult::new(String::new())
+clarity/src/vm/ast/mod.rs:153: replace build_ast_with_diagnostics -> (ContractAST, Vec<Diagnostic>, bool) with (Default::default(), vec![Default::default()], false)
+clarity/src/vm/database/clarity_db.rs:1085: replace ClarityDatabase<'a>::get_microblock_poison_report -> Option<(StandardPrincipalData, u16)> with Some((Default::default(), 1))
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:808: replace TypeChecker<'a, 'b>::try_type_check_define -> CheckResult<Option<()>> with CheckResult::from(None)
+clarity/src/vm/ast/sugar_expander/mod.rs:66: replace SugarExpander::transform -> ParseResult<Vec<SymbolicExpression>> with ParseResult::new(vec![Default::default()])
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:831: replace trait_type_size -> CheckResult<u64> with CheckResult::from_iter([0])
+clarity/src/vm/functions/conversions.rs:162: replace native_string_to_int -> Result<Value> with Ok(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1414: replace TypeChecker<'a, 'b>::try_type_check_define -> CheckResult<Option<()>> with CheckResult::new()
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1398: replace TypeChecker<'a, 'b>::type_check_define_trait -> CheckResult<(ClarityName, BTreeMap<ClarityName, FunctionSignature>)> with CheckResult::from_iter([(Default::default(), BTreeMap::new())])
+clarity/src/vm/ast/definition_sorter/mod.rs:324: replace DefinitionSorter::probe_for_dependencies_in_define_args -> ParseResult<()> with ParseResult::from(())
+clarity/src/vm/test_util/mod.rs:97: replace <impl From for StandardPrincipalData>::from -> StandardPrincipalData with Default::default()
+clarity/src/vm/contexts.rs:1814: replace ContractContext::lookup_variable -> Option<&Value> with Some(&Default::default())
+clarity/src/vm/functions/arithmetic.rs:434: replace special_leq_v1 -> InterpreterResult<Value> with InterpreterResult::new()
+clarity/src/vm/ast/definition_sorter/mod.rs:65: replace DefinitionSorter::run -> ParseResult<()> with ParseResult::new(())
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:831: replace trait_type_size -> CheckResult<u64> with CheckResult::from(0)
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:160: replace Lexer<'a>::proceed_through_error -> LexResult<String> with LexResult::new("xyzzy".into())
+clarity/src/vm/types/signatures.rs:861: replace TupleTypeSignature::get_type_map -> &BTreeMap<ClarityName, TypeSignature> with &BTreeMap::from_iter([(Default::default(), Default::default())])
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1372: replace TypeChecker<'a, 'b>::type_check_define_ft -> CheckResult<ClarityName> with CheckResult::from_iter([Default::default()])
+clarity/src/vm/analysis/type_checker/contexts.rs:82: replace TypingContext<'a>::extend -> CheckResult<TypingContext> with CheckResult::from_iter([Default::default()])
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:485: replace check_function_arg_signature -> CheckResult<()> with CheckResult::new()
+clarity/src/vm/functions/define.rs:191: replace handle_define_nonfungible_asset -> Result<DefineResult> with Ok(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/natives/conversions.rs:36: replace check_special_from_consensus_buff -> TypeResult with Default::default()
+clarity/src/vm/ast/parser/v2/mod.rs:1062: replace Parser<'a>::parse_node_or_eof -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::from_iter([None])
+clarity/src/vm/analysis/read_only_checker/mod.rs:170: replace ReadOnlyChecker<'a, 'b>::check_define_function -> CheckResult<(ClarityName, bool)> with CheckResult::new()
+clarity/src/vm/tests/assets.rs:133: replace execute_transaction -> Result<(Value, AssetMap, Vec<StacksTransactionEvent>), Error> with Ok((Default::default(), Default::default(), vec![Default::default()]))
+clarity/src/vm/analysis/analysis_db.rs:189: replace AnalysisDatabase<'a>::get_defined_trait -> CheckResult<Option<BTreeMap<ClarityName, FunctionSignature>>> with CheckResult::new(Some(BTreeMap::from_iter([(Default::default(), Default::default())])))
+clarity/src/vm/functions/arithmetic.rs:604: replace native_bitwise_right_shift -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
+clarity/src/vm/test_util/mod.rs:141: replace <impl HeadersDB for UnitTestHeaderDB>::get_stacks_block_header_hash_for_block -> Option<BlockHeaderHash> with Some(Default::default())
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:79: replace ContractContext::check_function_type -> CheckResult<()> with CheckResult::from(())
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1398: replace TypeChecker<'a, 'b>::type_check_define_trait -> CheckResult<(ClarityName, BTreeMap<ClarityName, FunctionSignature>)> with CheckResult::from_iter([(Default::default(), BTreeMap::from_iter([(Default::default(), Default::default())]))])
+clarity/src/vm/ast/stack_depth_checker.rs:28: replace check -> ParseResult<()> with ParseResult::new(())
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:62: replace TraitContext::add_defined_trait -> CheckResult<()> with CheckResult::new()
+clarity/src/vm/ast/mod.rs:69: replace parse_in_epoch -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::new(vec![])
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:766: replace TypeChecker<'a, 'b>::type_check_define_ft -> CheckResult<ClarityName> with CheckResult::new(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1055: replace TypeChecker<'a, 'b>::type_check_define_function -> CheckResult<(ClarityName, FixedFunction)> with CheckResult::new()
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:128: replace Lexer<'a>::skip_whitespace -> LexResult<()> with LexResult::from_iter([()])
+clarity/src/vm/functions/arithmetic.rs:575: replace native_mod -> InterpreterResult<Value> with InterpreterResult::new()
+clarity/src/vm/analysis/read_only_checker/mod.rs:88: replace ReadOnlyChecker<'a, 'b>::run -> CheckResult<()> with CheckResult::new(())
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1385: replace TypeChecker<'a, 'b>::type_check_define_nft -> CheckResult<(ClarityName, TypeSignature)> with CheckResult::from_iter([(Default::default(), Default::default())])
+clarity/src/vm/ast/parser/v1.rs:462: replace unescape_ascii_chars -> ParseResult<String> with ParseResult::from(String::new())
+clarity/src/vm/analysis/type_checker/v2_1/natives/maps.rs:106: replace check_set_or_insert_entry -> TypeResult with Default::default()
+clarity/src/vm/analysis/analysis_db.rs:171: replace AnalysisDatabase<'a>::get_read_only_function_type -> CheckResult<Option<FunctionType>> with CheckResult::from(None)
+clarity/src/vm/ast/definition_sorter/mod.rs:433: replace Graph::edges_count -> ParseResult<u64> with ParseResult::new()
+clarity/src/vm/functions/database.rs:599: replace special_insert_entry_v205 -> Result<Value> with Ok(Default::default())
+clarity/src/vm/analysis/type_checker/v2_05/natives/assets.rs:108: replace check_special_mint_token -> TypeResult with Default::default()
+clarity/src/vm/ast/sugar_expander/mod.rs:40: replace <impl BuildASTPass for SugarExpander>::run_pass -> ParseResult<()> with ParseResult::from_iter([()])
+clarity/src/vm/analysis/type_checker/v2_05/natives/sequences.rs:203: replace check_special_concat -> TypeResult with Default::default()
+clarity/src/vm/ast/parser/v1.rs:455: replace lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::from(vec![(Default::default(), 1, 0)])
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:185: replace Lexer<'a>::proceed_through_error_string -> LexResult<String> with LexResult::from(String::new())
+clarity/src/vm/contexts.rs:1784: replace GlobalContext<'a, 'hooks>::destruct -> Option<(ClarityDatabase<'a>, LimitedCostTracker)> with Some((Default::default(), Default::default()))
+clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs:625: replace check_secp256k1_verify -> TypeResult with Default::default()
+clarity/src/vm/types/mod.rs:641: replace <impl SequencedValue for BuffData>::type_signature -> TypeSignature with Default::default()
+clarity/src/vm/types/signatures.rs:354: replace <impl TryFrom for BufferLength>::try_from -> Result<BufferLength> with Ok(Default::default())
+clarity/src/vm/types/mod.rs:1071: replace Value::expect_list -> Vec<Value> with vec![Default::default()]
+clarity/src/vm/types/mod.rs:1400: replace <impl From for PrincipalData>::from -> PrincipalData with Default::default()
+clarity/src/vm/functions/assets.rs:777: replace special_get_balance -> Result<Value> with Ok(Default::default())
+clarity/src/vm/callables.rs:404: replace clarity2_implicit_cast -> Result<Value> with Ok(Default::default())
+clarity/src/vm/database/clarity_db.rs:879: replace ClarityDatabase<'a>::get_sortition_id_for_stacks_tip -> Option<SortitionId> with Some(Default::default())
+clarity/src/vm/ast/parser/v1.rs:455: replace lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::from_iter([vec![]])
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:626: replace TypeChecker<'a, 'b>::type_check_define_map -> CheckResult<(ClarityName, (TypeSignature, TypeSignature))> with CheckResult::new((Default::default(), (Default::default(), Default::default())))
+clarity/src/vm/analysis/errors.rs:242: replace <impl From for CheckError>::from -> Self with Default::default()
+clarity/src/vm/functions/arithmetic.rs:373: replace native_bitwise_and -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:186: replace ContractContext::get_map_type -> Option<&(TypeSignature, TypeSignature)> with Some(&(Default::default(), Default::default()))
+clarity/src/vm/functions/arithmetic.rs:575: replace native_mod -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
+clarity/src/vm/costs/mod.rs:843: replace parse_cost -> Result<ExecutionCost> with Ok(Default::default())
+clarity/src/vm/analysis/type_checker/v2_05/natives/maps.rs:74: replace check_special_delete_entry -> TypeResult with Default::default()
+clarity/src/vm/clarity.rs:42: replace <impl Error for Error>::cause -> Option<&dyn std::error::Error> with Some(&Default::default())
+clarity/src/vm/analysis/contract_interface_builder/mod.rs:333: replace ContractInterfaceVariable::from_map -> Vec<ContractInterfaceVariable> with vec![Default::default()]
+clarity/src/vm/test_util/mod.rs:263: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_pox_payout_addrs -> Option<(Vec<TupleData>, u128)> with Some((vec![Default::default()], 0))
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:899: replace TypeChecker<'a, 'b>::track_return_type -> CheckResult<()> with CheckResult::new(())
+clarity/src/vm/functions/conversions.rs:96: replace native_buff_to_uint_le -> Result<Value> with Ok(Default::default())
+clarity/src/vm/types/serialization.rs:266: replace PrincipalData::inner_consensus_deserialize -> Result<PrincipalData, SerializationError> with Ok(Default::default())
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:516: replace TypeChecker<'a, 'b>::type_check_all -> CheckResult<Vec<TypeSignature>> with CheckResult::new()
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:297: replace trait_type_size -> CheckResult<u64> with CheckResult::from_iter([1])
+clarity/src/vm/ast/stack_depth_checker.rs:48: replace <impl BuildASTPass for StackDepthChecker>::run_pass -> ParseResult<()> with ParseResult::from_iter([()])
+clarity/src/vm/errors.rs:157: replace <impl Error for Error>::source -> Option<&(dyn error::Error +'static)> with Some(&Default::default())
+clarity/src/vm/database/clarity_db.rs:163: replace <impl HeadersDB for &dyn HeadersDB>::get_consensus_hash_for_block -> Option<ConsensusHash> with Some(Default::default())
+clarity/src/vm/ast/parser/v2/mod.rs:1083: replace Parser<'a>::parse -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::from_iter([vec![]])
+clarity/src/vm/ast/parser/v1.rs:728: replace parse_no_stack_limit -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::from_iter([vec![Default::default()]])
+clarity/src/vm/database/clarity_db.rs:240: replace <impl BurnStateDB for &dyn BurnStateDB>::get_stacks_epoch_by_epoch_id -> Option<StacksEpoch> with Some(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:839: replace contract_analysis_size -> CheckResult<u64> with CheckResult::new()
+clarity/src/vm/mod.rs:234: replace apply -> Result<Value> with Ok(Default::default())
+clarity/src/vm/representations.rs:230: replace PreSymbolicExpression::cons -> PreSymbolicExpression with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:156: replace FunctionType::check_args_2_1 -> CheckResult<TypeSignature> with CheckResult::from_iter([Default::default()])
+clarity/src/vm/ast/definition_sorter/mod.rs:345: replace DefinitionSorter::probe_for_dependencies_in_list_of_wrapped_key_value_pairs -> ParseResult<()> with ParseResult::from(())
+clarity/src/vm/analysis/read_only_checker/mod.rs:227: replace ReadOnlyChecker<'a, 'b>::check_read_only -> CheckResult<bool> with CheckResult::new(false)
+clarity/src/vm/ast/definition_sorter/mod.rs:115: replace DefinitionSorter::probe_for_dependencies -> ParseResult<()> with ParseResult::new()
+clarity/src/vm/analysis/mod.rs:50: replace mem_type_check -> CheckResult<(Option<TypeSignature>, ContractAnalysis)> with CheckResult::new()
+clarity/src/vm/analysis/type_checker/v2_1/natives/options.rs:343: replace check_special_match_resp -> TypeResult with Default::default()
+clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs:287: replace check_special_set_var -> TypeResult with Default::default()
+clarity/src/vm/functions/arithmetic.rs:546: replace special_less -> InterpreterResult<Value> with InterpreterResult::new()
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1023: replace TypeChecker<'a, 'b>::type_check_all -> CheckResult<Vec<TypeSignature>> with CheckResult::new(vec![])
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:899: replace TypeChecker<'a, 'b>::track_return_type -> CheckResult<()> with CheckResult::from(())
+clarity/src/vm/errors.rs:175: replace <impl From for Error>::from -> Self with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:785: replace clarity2_lookup_trait -> CheckResult<BTreeMap<ClarityName, FunctionSignature>> with CheckResult::from_iter([BTreeMap::from_iter([(Default::default(), Default::default())])])
+clarity/src/vm/functions/arithmetic.rs:369: replace native_bitwise_xor -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
+clarity/src/vm/analysis/types.rs:98: replace ContractAnalysis::take_contract_cost_tracker -> LimitedCostTracker with Default::default()
+clarity/src/vm/analysis/type_checker/contexts.rs:57: replace TypeMap::set_type -> CheckResult<()> with CheckResult::new(())
+clarity/src/vm/analysis/read_only_checker/mod.rs:227: replace ReadOnlyChecker<'a, 'b>::check_read_only -> CheckResult<bool> with CheckResult::from(false)
+clarity/src/vm/contexts.rs:990: replace Environment<'a, 'b, 'hooks>::eval_read_only_with_rules -> Result<Value> with Ok(Default::default())
+clarity/src/vm/analysis/types.rs:183: replace ContractAnalysis::get_persisted_variable_type -> Option<&TypeSignature> with Some(&Default::default())
+clarity/src/vm/database/clarity_store.rs:291: replace <impl ClarityBackingStore for MemoryBackingStore>::set_block_hash -> InterpreterResult<StacksBlockId> with InterpreterResult::from_iter([Default::default()])
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:751: replace TypeChecker<'a, 'b>::type_check_define_persisted_variable -> CheckResult<(ClarityName, TypeSignature)> with CheckResult::from_iter([(Default::default(), Default::default())])
+clarity/src/vm/analysis/errors.rs:268: replace <impl Error for CheckErrors>::source -> Option<&(dyn error::Error +'static)> with Some(&Default::default())
+clarity/src/vm/ast/parser/v2/mod.rs:1062: replace Parser<'a>::parse_node_or_eof -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::new(None)
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:292: replace ContractContext::add_used_trait -> CheckResult<()> with CheckResult::new(())
+clarity/src/vm/ast/definition_sorter/mod.rs:369: replace DefinitionSorter::probe_for_dependencies_in_key_value_pair -> ParseResult<()> with ParseResult::new(())
+clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs:367: replace check_special_element_at -> TypeResult with Default::default()
+clarity/src/vm/database/key_value_wrapper.rs:466: replace RollbackWrapper<'a>::get_metadata -> InterpreterResult<Option<String>> with InterpreterResult::from_iter([Some("xyzzy".into())])
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:320: replace ContractContext::get_function_type -> Option<&FunctionType> with Some(&Default::default())
+clarity/src/vm/analysis/analysis_db.rs:171: replace AnalysisDatabase<'a>::get_read_only_function_type -> CheckResult<Option<FunctionType>> with CheckResult::new(Some(Default::default()))
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:330: replace no_type -> TypeSignature with Default::default()
+clarity/src/vm/ast/mod.rs:153: replace build_ast_with_diagnostics -> (ContractAST, Vec<Diagnostic>, bool) with (Default::default(), vec![], true)
+clarity/src/vm/types/signatures.rs:1446: replace TypeSignature::parse_string_ascii_type_repr -> Result<TypeSignature> with Ok(Default::default())
+clarity/src/vm/analysis/read_only_checker/mod.rs:59: replace <impl AnalysisPass for ReadOnlyChecker<'a, 'b>>::run_pass -> CheckResult<()> with CheckResult::from_iter([()])
+clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs:539: replace check_contract_of -> TypeResult with Default::default()
+clarity/src/vm/representations.rs:516: replace SymbolicExpression::span -> &Span with &Default::default()
+clarity/src/vm/database/clarity_db.rs:1408: replace ClarityDatabase<'a>::set_entry -> Result<ValueResult> with Ok(Default::default())
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:66: replace Lexer<'a>::add_diagnostic -> LexResult<()> with LexResult::from_iter([()])
+clarity/src/vm/database/structures.rs:870: replace STXBalance::canonical_repr_at_block -> (STXBalance, u128) with (Default::default(), 0)
+clarity/src/vm/functions/database.rs:512: replace special_set_entry_v205 -> Result<Value> with Ok(Default::default())
+clarity/src/vm/analysis/analysis_db.rs:189: replace AnalysisDatabase<'a>::get_defined_trait -> CheckResult<Option<BTreeMap<ClarityName, FunctionSignature>>> with CheckResult::from_iter([Some(BTreeMap::new())])
+clarity/src/vm/functions/arithmetic.rs:419: replace special_geq -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
+clarity/src/vm/ast/definition_sorter/mod.rs:433: replace Graph::edges_count -> ParseResult<u64> with ParseResult::from_iter([0])
+clarity/src/vm/functions/arithmetic.rs:490: replace special_greater_v2 -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:246: replace Lexer<'a>::read_trait_identifier -> LexResult<Token> with LexResult::new(Default::default())
+clarity/src/vm/ast/definition_sorter/mod.rs:456: replace GraphWalker::get_sorted_dependencies -> ParseResult<Vec<usize>> with ParseResult::from_iter([vec![]])
+clarity/src/vm/types/mod.rs:202: replace TraitIdentifier::parse -> Result<(Option<StandardPrincipalData>, ContractName, ClarityName)> with Ok((Some(Default::default()), Default::default(), Default::default()))
+clarity/src/vm/contexts.rs:652: replace OwnedEnvironment<'a, 'hooks>::execute_in_env -> std::result::Result<(A, AssetMap, Vec<StacksTransactionEvent>), E> with Ok((Default::default(), Default::default(), vec![]))
+clarity/src/vm/ast/parser/v2/mod.rs:119: replace Parser<'a>::add_diagnostic -> ParseResult<()> with ParseResult::from(())
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:706: replace Lexer<'a>::read_token -> Result<PlacedToken, LexerError> with Ok(Default::default())
+clarity/src/vm/analysis/analysis_db.rs:153: replace AnalysisDatabase<'a>::get_public_function_type -> CheckResult<Option<FunctionType>> with CheckResult::from_iter([None])
+clarity/src/vm/contexts.rs:1095: replace Environment<'a, 'b, 'hooks>::epoch -> &StacksEpochId with &Default::default()
+clarity/src/vm/ast/sugar_expander/mod.rs:56: replace SugarExpander::run -> ParseResult<()> with ParseResult::new()
+clarity/src/vm/functions/arithmetic.rs:41: replace U128Ops::make_value -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:223: replace ContractContext::add_private_function_type -> CheckResult<()> with CheckResult::from_iter([()])
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1357: replace TypeChecker<'a, 'b>::type_check_define_persisted_variable -> CheckResult<(ClarityName, TypeSignature)> with CheckResult::new()
+clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs:120: replace inner_handle_tuple_get -> TypeResult with Default::default()
+clarity/src/vm/database/clarity_db.rs:1625: replace ClarityDatabase<'a>::load_ft -> Result<FungibleTokenMetadata> with Ok(Default::default())
+clarity/src/vm/ast/parser/v2/mod.rs:119: replace Parser<'a>::add_diagnostic -> ParseResult<()> with ParseResult::new()
+clarity/src/vm/ast/definition_sorter/mod.rs:433: replace Graph::edges_count -> ParseResult<u64> with ParseResult::from(1)
+clarity/src/vm/ast/definition_sorter/mod.rs:65: replace DefinitionSorter::run -> ParseResult<()> with ParseResult::from_iter([()])
+clarity/src/vm/database/clarity_db.rs:244: replace <impl BurnStateDB for &dyn BurnStateDB>::get_ast_rules -> ASTRules with Default::default()
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:288: replace Lexer<'a>::read_principal -> LexResult<Token> with LexResult::from(Default::default())
+clarity/src/vm/analysis/read_only_checker/mod.rs:227: replace ReadOnlyChecker<'a, 'b>::check_read_only -> CheckResult<bool> with CheckResult::new(true)
+clarity/src/vm/analysis/types.rs:179: replace ContractAnalysis::get_variable_type -> Option<&TypeSignature> with Some(&Default::default())
+clarity/src/vm/analysis/mod.rs:50: replace mem_type_check -> CheckResult<(Option<TypeSignature>, ContractAnalysis)> with CheckResult::from_iter([(Some(Default::default()), Default::default())])
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:345: replace Lexer<'a>::read_hex -> LexResult<Token> with LexResult::new(Default::default())
+clarity/src/vm/functions/options.rs:73: replace native_unwrap_err -> Result<Value> with Ok(Default::default())
+clarity/src/vm/functions/arithmetic.rs:532: replace special_less_v2 -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:792: replace TypeChecker<'a, 'b>::type_check_define_trait -> CheckResult<(ClarityName, BTreeMap<ClarityName, FunctionSignature>)> with CheckResult::from_iter([(Default::default(), BTreeMap::from_iter([(Default::default(), Default::default())]))])
+clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs:582: replace check_principal_construct -> TypeResult with Default::default()
+clarity/src/vm/tests/mod.rs:131: replace tl_env_factory -> TopLevelMemoryEnvironmentGenerator with Default::default()
+clarity/src/vm/types/signatures.rs:985: replace TypeSignature::max_string_utf8 -> TypeSignature with Default::default()
+clarity/src/vm/functions/arithmetic.rs:381: replace native_bitwise_not -> InterpreterResult<Value> with InterpreterResult::new()
+clarity/src/vm/callables.rs:359: replace DefinedFunction::get_arg_types -> &Vec<TypeSignature> with &vec![Default::default()]
+clarity/src/vm/types/serialization.rs:1329: replace <impl StacksMessageCodec for Value>::consensus_deserialize -> Result<Value, codec_error> with Ok(Default::default())
+clarity/src/vm/mod.rs:314: replace eval -> Result<Value> with Ok(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/natives/assets.rs:82: replace check_special_mint_asset -> TypeResult with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/natives/assets.rs:172: replace check_special_transfer_token -> TypeResult with Default::default()
+clarity/src/vm/ast/mod.rs:153: replace build_ast_with_diagnostics -> (ContractAST, Vec<Diagnostic>, bool) with (Default::default(), vec![Default::default()], true)
+clarity/src/vm/database/clarity_db.rs:647: replace ClarityDatabase<'a>::load_contract_analysis -> Option<ContractAnalysis> with Some(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/natives/assets.rs:113: replace check_special_mint_token -> TypeResult with Default::default()
+clarity/src/vm/types/serialization.rs:126: replace <impl From for SerializationError>::from -> Self with Default::default()
+clarity/src/vm/functions/principals.rs:60: replace special_is_standard -> Result<Value> with Ok(Default::default())
+clarity/src/vm/ast/parser/v1.rs:508: replace parse_lexed -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::new()
+clarity/src/vm/functions/define.rs:126: replace handle_define_variable -> Result<DefineResult> with Ok(Default::default())
+clarity/src/vm/database/key_value_wrapper.rs:59: replace rollback_check_pre_bottom_commit -> Vec<(T, String)> with vec![(Default::default(), "xyzzy".into())]
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:571: replace clarity2_trait_check_trait_compliance -> CheckResult<()> with CheckResult::from(())
+clarity/src/vm/analysis/analysis_db.rs:171: replace AnalysisDatabase<'a>::get_read_only_function_type -> CheckResult<Option<FunctionType>> with CheckResult::new()
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:91: replace <impl CostTracker for TypeChecker<'_, '_>>::compute_cost -> Result<ExecutionCost, CostErrors> with Ok(Default::default())
+clarity/src/vm/functions/assets.rs:1061: replace special_burn_asset_v205 -> Result<Value> with Ok(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:213: replace ContractContext::add_read_only_function_type -> CheckResult<()> with CheckResult::new()
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:140: replace Lexer<'a>::read_line -> LexResult<String> with LexResult::from("xyzzy".into())
+clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs:260: replace check_special_fetch_var -> TypeResult with Default::default()
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:297: replace trait_type_size -> CheckResult<u64> with CheckResult::new()
+clarity/src/vm/contexts.rs:1818: replace ContractContext::lookup_function -> Option<DefinedFunction> with Some(Default::default())
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:172: replace ContractContext::add_trait -> CheckResult<()> with CheckResult::new(())
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1414: replace TypeChecker<'a, 'b>::try_type_check_define -> CheckResult<Option<()>> with CheckResult::from_iter([Some(())])
+clarity/src/vm/functions/arithmetic.rs:579: replace native_bitwise_left_shift -> InterpreterResult<Value> with InterpreterResult::new()
+clarity/src/vm/test_util/mod.rs:263: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_pox_payout_addrs -> Option<(Vec<TupleData>, u128)> with Some((vec![Default::default()], 1))
+clarity/src/vm/types/signatures.rs:1372: replace TypeSignature::parse_atom_type -> Result<TypeSignature> with Ok(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:203: replace ContractContext::add_public_function_type -> CheckResult<()> with CheckResult::new(())
+clarity/src/vm/functions/arithmetic.rs:448: replace special_leq_v2 -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
+clarity/src/vm/ast/parser/v1.rs:192: replace inner_lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::from(vec![(Default::default(), 0, 1)])
+clarity/src/vm/analysis/type_checker/v2_1/natives/options.rs:49: replace check_special_some -> TypeResult with Default::default()
+clarity/src/vm/analysis/analysis_db.rs:171: replace AnalysisDatabase<'a>::get_read_only_function_type -> CheckResult<Option<FunctionType>> with CheckResult::from_iter([Some(Default::default())])
+clarity/src/vm/database/clarity_store.rs:307: replace <impl ClarityBackingStore for MemoryBackingStore>::get_block_at_height -> Option<StacksBlockId> with Some(Default::default())
+clarity/src/vm/analysis/read_only_checker/mod.rs:244: replace ReadOnlyChecker<'a, 'b>::check_each_expression_is_read_only -> CheckResult<bool> with CheckResult::new()
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:474: replace Lexer<'a>::read_utf8_encoding -> LexResult<Result<String, String>> with LexResult::from(Ok(String::new()))
+clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs:325: replace check_special_equals -> TypeResult with Default::default()
+clarity/src/vm/types/mod.rs:831: replace Value::err_uint -> Value with Default::default()
+clarity/src/vm/functions/arithmetic.rs:419: replace special_geq -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
+clarity/src/vm/analysis/mod.rs:50: replace mem_type_check -> CheckResult<(Option<TypeSignature>, ContractAnalysis)> with CheckResult::from((None, Default::default()))
+clarity/src/vm/costs/mod.rs:208: replace <impl From for CostStateSummary>::from -> CostStateSummary with Default::default()
+clarity/src/vm/representations.rs:356: replace PreSymbolicExpression::match_atom_value -> Option<&Value> with Some(&Default::default())
+clarity/src/vm/database/clarity_store.rs:223: replace <impl ClarityBackingStore for NullBackingStore>::set_block_hash -> Result<StacksBlockId> with Ok(Default::default())
+clarity/src/vm/ast/definition_sorter/mod.rs:54: replace DefinitionSorter::run_pass -> ParseResult<()> with ParseResult::new()
+clarity/src/vm/ast/parser/v2/mod.rs:807: replace Parser<'a>::parse_node -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::new(None)
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:831: replace trait_type_size -> CheckResult<u64> with CheckResult::new()
+clarity/src/vm/types/mod.rs:1445: replace <impl From for Value>::from -> Self with Default::default()
+clarity/src/vm/database/clarity_db.rs:1263: replace ClarityDatabase<'a>::create_map -> DataMapMetadata with Default::default()
+clarity/src/vm/types/mod.rs:970: replace Value::string_utf8_from_string_utf8_literal -> Result<Value> with Ok(Default::default())
+clarity/src/vm/types/serialization.rs:522: replace Value::deserialize_read -> Result<Value, SerializationError> with Ok(Default::default())
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:140: replace Lexer<'a>::read_line -> LexResult<String> with LexResult::new("xyzzy".into())
+clarity/src/vm/functions/database.rs:229: replace special_fetch_variable_v200 -> Result<Value> with Ok(Default::default())
+clarity/src/vm/ast/parser/v1.rs:508: replace parse_lexed -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::new(vec![Default::default()])
+clarity/src/vm/representations.rs:520: replace SymbolicExpression::atom_value -> SymbolicExpression with Default::default()
+clarity/src/vm/analysis/type_checker/contexts.rs:97: replace TypingContext<'a>::lookup_variable_type -> Option<&TypeSignature> with Some(&Default::default())
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:118: replace <impl AnalysisPass for TypeChecker<'_, '_>>::run_pass -> CheckResult<()> with CheckResult::new(())
+clarity/src/vm/docs/contracts.rs:178: replace produce_docs_refs -> BTreeMap<String, ContractRef> with BTreeMap::from_iter([("xyzzy".into(), Default::default())])
+clarity/src/vm/ast/parser/v2/mod.rs:283: replace Parser<'a>::handle_open_tuple -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::from(None)
+clarity/src/vm/ast/definition_sorter/mod.rs:54: replace DefinitionSorter::run_pass -> ParseResult<()> with ParseResult::from(())
+clarity/src/vm/functions/arithmetic.rs:369: replace native_bitwise_xor -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1023: replace TypeChecker<'a, 'b>::type_check_all -> CheckResult<Vec<TypeSignature>> with CheckResult::from_iter([vec![Default::default()]])
+clarity/src/vm/analysis/type_checker/v2_05/natives/sequences.rs:62: replace check_special_map -> TypeResult with Default::default()
+clarity/src/vm/analysis/read_only_checker/mod.rs:227: replace ReadOnlyChecker<'a, 'b>::check_read_only -> CheckResult<bool> with CheckResult::from(true)
+clarity/src/vm/types/mod.rs:1427: replace <impl From for Value>::from -> Self with Default::default()
+clarity/src/vm/types/mod.rs:1527: replace TupleData::get_owned -> Result<Value> with Ok(Default::default())
+clarity/src/vm/ast/parser/v1.rs:455: replace lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::from(vec![(Default::default(), 0, 1)])
+clarity/src/vm/analysis/type_checker/v2_05/natives/options.rs:60: replace check_special_error -> TypeResult with Default::default()
+clarity/src/vm/ast/parser/v1.rs:728: replace parse_no_stack_limit -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::from(vec![Default::default()])
+clarity/src/vm/functions/options.rs:112: replace eval_with_new_binding -> Result<Value> with Ok(Default::default())
+clarity/src/vm/ast/definition_sorter/mod.rs:324: replace DefinitionSorter::probe_for_dependencies_in_define_args -> ParseResult<()> with ParseResult::from_iter([()])
+clarity/src/vm/ast/parser/v1.rs:192: replace inner_lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::new(vec![])
+clarity/src/vm/database/clarity_db.rs:724: replace ClarityDatabase<'a>::get_clarity_epoch_version -> StacksEpochId with Default::default()
+clarity/src/vm/database/clarity_db.rs:1361: replace ClarityDatabase<'a>::fetch_entry_with_size -> Result<ValueResult> with Ok(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:156: replace FunctionType::check_args_2_1 -> CheckResult<TypeSignature> with CheckResult::new(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/natives/options.rs:134: replace check_special_asserts -> TypeResult with Default::default()
+clarity/src/vm/database/clarity_db.rs:343: replace <impl BurnStateDB for NullBurnStateDB>::get_sortition_id_from_consensus_hash -> Option<SortitionId> with Some(Default::default())
+clarity/src/vm/ast/parser/v2/mod.rs:1062: replace Parser<'a>::parse_node_or_eof -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::from_iter([Some(Default::default())])
+clarity/src/vm/contexts.rs:1760: replace GlobalContext<'a, 'hooks>::handle_tx_result -> Result<Value> with Ok(Default::default())
+clarity/src/vm/types/mod.rs:942: replace Value::buff_from -> Result<Value> with Ok(Default::default())
+clarity/src/vm/database/clarity_db.rs:634: replace ClarityDatabase<'a>::fetch_metadata_manual -> Result<Option<T>> with Ok(Some(Default::default()))
+clarity/src/vm/functions/conversions.rs:88: replace native_buff_to_int_le -> Result<Value> with Ok(Default::default())
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:194: replace ContractContext::get_persisted_variable_type -> Option<&TypeSignature> with Some(&Default::default())
+clarity/src/vm/ast/parser/v2/mod.rs:1083: replace Parser<'a>::parse -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::new()
+clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs:265: replace check_special_fetch_var -> TypeResult with Default::default()
+clarity/src/vm/functions/sequences.rs:409: replace special_replace_at -> Result<Value> with Ok(Default::default())
+clarity/src/vm/database/structures.rs:748: replace STXBalance::initial -> STXBalance with Default::default()
+clarity/src/vm/ast/expression_identifier/mod.rs:40: replace update_expression_id -> ParseResult<()> with ParseResult::from(())
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1023: replace TypeChecker<'a, 'b>::type_check_all -> CheckResult<Vec<TypeSignature>> with CheckResult::new()
+clarity/src/vm/functions/arithmetic.rs:579: replace native_bitwise_left_shift -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:66: replace Lexer<'a>::add_diagnostic -> LexResult<()> with LexResult::new()
+clarity/src/vm/database/key_value_wrapper.rs:466: replace RollbackWrapper<'a>::get_metadata -> InterpreterResult<Option<String>> with InterpreterResult::from(None)
+clarity/src/vm/contexts.rs:1246: replace Environment<'a, 'b, 'hooks>::evaluate_at_block -> Result<Value> with Ok(Default::default())
+clarity/src/vm/functions/conversions.rs:242: replace from_consensus_buff -> Result<Value> with Ok(Default::default())
+clarity/src/vm/version.rs:27: replace ClarityVersion::default_for_epoch -> ClarityVersion with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:269: replace ContractContext::add_nft -> CheckResult<()> with CheckResult::new(())
+clarity/src/vm/analysis/read_only_checker/mod.rs:281: replace ReadOnlyChecker<'a, 'b>::check_native_function_is_read_only -> CheckResult<bool> with CheckResult::from_iter([true])
+clarity/src/vm/callables.rs:355: replace DefinedFunction::get_arguments -> &Vec<ClarityName> with &vec![Default::default()]
+clarity/src/vm/contexts.rs:490: replace AssetMap::get_nonfungible_tokens -> Option<&Vec<Value>> with Some(&vec![])
+clarity/src/vm/analysis/arithmetic_checker/mod.rs:60: replace <impl Error for Error>::source -> Option<&(dyn std::error::Error +'static)> with Some(&Default::default())
+clarity/src/vm/functions/arithmetic.rs:557: replace native_sub -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
+clarity/src/vm/database/clarity_db.rs:937: replace ClarityDatabase<'a>::get_pox_payout_addrs_for_burnchain_height -> Option<(Vec<TupleData>, u128)> with Some((vec![Default::default()], 1))
+clarity/src/vm/errors.rs:199: replace <impl From for Error>::from -> Self with Default::default()
+clarity/src/vm/types/serialization.rs:1133: replace Value::try_deserialize_hex_untyped -> Result<Value, SerializationError> with Ok(Default::default())
+clarity/src/vm/analysis/types.rs:190: replace ContractAnalysis::get_defined_trait -> Option<&BTreeMap<ClarityName, FunctionSignature>> with Some(&BTreeMap::from_iter([(Default::default(), Default::default())]))
+clarity/src/vm/functions/arithmetic.rs:47: replace I128Ops::make_value -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
+clarity/src/vm/ast/parser/v1.rs:728: replace parse_no_stack_limit -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::new()
+clarity/src/vm/analysis/type_checker/v2_1/natives/assets.rs:250: replace check_special_get_token_supply -> TypeResult with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/natives/options.rs:306: replace check_special_match_opt -> TypeResult with Default::default()
+clarity/src/vm/ast/parser/v2/mod.rs:1109: replace parse_collect_diagnostics -> (Vec<PreSymbolicExpression>, Vec<Diagnostic>, bool) with (vec![Default::default()], vec![], true)
+clarity/src/vm/test_util/mod.rs:125: replace <impl HeadersDB for UnitTestHeaderDB>::get_burn_header_hash_for_block -> Option<BurnchainHeaderHash> with Some(Default::default())
+clarity/src/vm/contexts.rs:1069: replace Environment<'a, 'b, 'hooks>::eval_raw -> Result<Value> with Ok(Default::default())
+clarity/src/vm/ast/parser/v1.rs:462: replace unescape_ascii_chars -> ParseResult<String> with ParseResult::new()
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:79: replace ContractContext::check_function_type -> CheckResult<()> with CheckResult::new()
+clarity/src/vm/docs/mod.rs:2557: replace make_for_special -> FunctionAPI with Default::default()
+clarity/src/vm/types/mod.rs:247: replace SequenceData::atom_values -> Vec<SymbolicExpression> with vec![Default::default()]
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:785: replace clarity2_lookup_trait -> CheckResult<BTreeMap<ClarityName, FunctionSignature>> with CheckResult::new()
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:808: replace TypeChecker<'a, 'b>::try_type_check_define -> CheckResult<Option<()>> with CheckResult::new(Some(()))
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:172: replace ContractContext::add_trait -> CheckResult<()> with CheckResult::new()
+clarity/src/vm/analysis/analysis_db.rs:208: replace AnalysisDatabase<'a>::get_implemented_traits -> CheckResult<BTreeSet<TraitIdentifier>> with CheckResult::from_iter([BTreeSet::from_iter([Default::default()])])
+clarity/src/vm/functions/arithmetic.rs:490: replace special_greater_v2 -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:358: replace TypeChecker<'a, 'b>::track_return_type -> CheckResult<()> with CheckResult::new(())
+clarity/src/vm/ast/mod.rs:130: replace build_ast_typical -> ParseResult<ContractAST> with ParseResult::new(Default::default())
+clarity/src/vm/docs/mod.rs:2532: replace make_keyword_reference -> Option<KeywordAPI> with Some(Default::default())
+clarity/src/vm/types/mod.rs:653: replace <impl SequencedValue for ASCIIData>::items -> &Vec<u8> with &vec![1]
+clarity/src/vm/ast/expression_identifier/mod.rs:40: replace update_expression_id -> ParseResult<()> with ParseResult::from_iter([()])
+clarity/src/vm/analysis/read_only_checker/mod.rs:430: replace ReadOnlyChecker<'a, 'b>::check_expression_application_is_read_only -> CheckResult<bool> with CheckResult::new(true)
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1346: replace TypeChecker<'a, 'b>::type_check_define_variable -> CheckResult<(ClarityName, TypeSignature)> with CheckResult::from((Default::default(), Default::default()))
+clarity/src/vm/version.rs:24: replace ClarityVersion::latest -> ClarityVersion with Default::default()
+clarity/src/vm/functions/arithmetic.rs:47: replace I128Ops::make_value -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
+clarity/src/vm/ast/definition_sorter/mod.rs:357: replace DefinitionSorter::probe_for_dependencies_in_wrapped_key_value_pairs -> ParseResult<()> with ParseResult::new()
+clarity/src/vm/types/mod.rs:299: replace SequenceData::replace_at -> Result<Value> with Ok(Default::default())
+clarity/src/vm/analysis/analysis_db.rs:189: replace AnalysisDatabase<'a>::get_defined_trait -> CheckResult<Option<BTreeMap<ClarityName, FunctionSignature>>> with CheckResult::from(Some(BTreeMap::from_iter([(Default::default(), Default::default())])))
+clarity/src/vm/database/clarity_db.rs:395: replace <impl BurnStateDB for NullBurnStateDB>::get_pox_payout_addrs -> Option<(Vec<TupleData>, u128)> with Some((vec![Default::default()], 1))
+clarity/src/vm/functions/boolean.rs:58: replace special_and -> Result<Value> with Ok(Default::default())
+clarity/src/vm/docs/mod.rs:828: replace make_for_simple_native -> FunctionAPI with Default::default()
+clarity/src/vm/functions/define.rs:411: replace evaluate_define -> Result<DefineResult> with Ok(Default::default())
+clarity/src/vm/functions/database.rs:642: replace special_delete_entry_v200 -> Result<Value> with Ok(Default::default())
+clarity/src/vm/types/signatures.rs:1054: replace TypeSignature::least_supertype -> Result<TypeSignature> with Ok(Default::default())
+clarity/src/vm/database/key_value_wrapper.rs:466: replace RollbackWrapper<'a>::get_metadata -> InterpreterResult<Option<String>> with InterpreterResult::new()
+clarity/src/vm/functions/crypto.rs:102: replace special_principal_of -> Result<Value> with Ok(Default::default())
+clarity/src/vm/ast/definition_sorter/mod.rs:345: replace DefinitionSorter::probe_for_dependencies_in_list_of_wrapped_key_value_pairs -> ParseResult<()> with ParseResult::new(())
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:326: replace Lexer<'a>::read_integer -> LexResult<Token> with LexResult::new()
+clarity/src/vm/database/clarity_db.rs:1928: replace ClarityDatabase<'a>::get_account_stx_balance -> STXBalance with Default::default()
+clarity/src/vm/ast/parser/v2/mod.rs:283: replace Parser<'a>::handle_open_tuple -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::new()
+clarity/src/vm/ast/definition_sorter/mod.rs:456: replace GraphWalker::get_sorted_dependencies -> ParseResult<Vec<usize>> with ParseResult::from(vec![1])
+clarity/src/vm/docs/contracts.rs:69: replace doc_execute -> Result<Option<Value>, vm::Error> with Ok(Some(Default::default()))
+clarity/src/vm/test_util/mod.rs:135: replace <impl HeadersDB for UnitTestHeaderDB>::get_vrf_seed_for_block -> Option<VRFSeed> with Some(Default::default())
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:751: replace TypeChecker<'a, 'b>::type_check_define_persisted_variable -> CheckResult<(ClarityName, TypeSignature)> with CheckResult::from((Default::default(), Default::default()))
+clarity/src/vm/analysis/read_only_checker/mod.rs:430: replace ReadOnlyChecker<'a, 'b>::check_expression_application_is_read_only -> CheckResult<bool> with CheckResult::new(false)
+clarity/src/vm/ast/parser/v1.rs:101: replace get_value_or_err -> ParseResult<String> with ParseResult::from("xyzzy".into())
+clarity/src/vm/contracts.rs:44: replace Contract::initialize_from_ast -> Result<Contract> with Ok(Default::default())
+clarity/src/vm/analysis/analysis_db.rs:189: replace AnalysisDatabase<'a>::get_defined_trait -> CheckResult<Option<BTreeMap<ClarityName, FunctionSignature>>> with CheckResult::new(Some(BTreeMap::new()))
+clarity/src/vm/contexts.rs:905: replace <impl CostTracker for GlobalContext<'_, '_>>::compute_cost -> std::result::Result<ExecutionCost, CostErrors> with Ok(Default::default())
+clarity/src/vm/ast/parser/v1.rs:192: replace inner_lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::new(vec![(Default::default(), 1, 1)])
+clarity/src/vm/analysis/type_checker/v2_05/natives/options.rs:74: replace check_special_is_response -> TypeResult with Default::default()
+clarity/src/vm/ast/expression_identifier/mod.rs:23: replace inner_relabel -> ParseResult<u64> with ParseResult::new(0)
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:516: replace TypeChecker<'a, 'b>::type_check_all -> CheckResult<Vec<TypeSignature>> with CheckResult::new(vec![Default::default()])
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:259: replace ContractContext::add_ft -> CheckResult<()> with CheckResult::new(())
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:429: replace TypeChecker<'a, 'b>::type_check_expects -> TypeResult with Default::default()
+clarity/src/vm/analysis/type_checker/v2_05/natives/sequences.rs:39: replace get_simple_native_or_user_define -> CheckResult<FunctionType> with CheckResult::from(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:571: replace clarity2_trait_check_trait_compliance -> CheckResult<()> with CheckResult::new()
+clarity/src/vm/functions/arithmetic.rs:462: replace special_leq -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
+clarity/src/vm/costs/mod.rs:677: replace LimitedCostTracker::new_mid_block -> Result<LimitedCostTracker> with Ok(Default::default())
+clarity/src/vm/contexts.rs:871: replace <impl CostTracker for Environment<'_, '_, '_>>::compute_cost -> std::result::Result<ExecutionCost, CostErrors> with Ok(Default::default())
+clarity/src/vm/representations.rs:475: replace SymbolicExpression::cons -> SymbolicExpression with Default::default()
+clarity/src/vm/representations.rs:211: replace <impl SymbolicExpressionCommon for SymbolicExpression>::match_list_mut -> Option<&mut[SymbolicExpression]> with Some(Vec::leak(vec![Default::default()]))
+clarity/src/vm/functions/arithmetic.rs:557: replace native_sub -> InterpreterResult<Value> with InterpreterResult::new()
+clarity/src/vm/functions/arithmetic.rs:405: replace special_geq_v2 -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
+clarity/src/vm/types/signatures.rs:721: replace TypeSignature::canonicalize -> TypeSignature with Default::default()
+clarity/src/vm/functions/sequences.rs:38: replace list_cons -> Result<Value> with Ok(Default::default())
+clarity/src/vm/types/mod.rs:1451: replace <impl From for Value>::from -> Self with Default::default()
+clarity/src/vm/analysis/read_only_checker/mod.rs:281: replace ReadOnlyChecker<'a, 'b>::check_native_function_is_read_only -> CheckResult<bool> with CheckResult::from_iter([false])
+clarity/src/vm/ast/types.rs:67: replace ContractAST::get_referenced_trait -> Option<&TraitDefinition> with Some(&Default::default())
+clarity/src/vm/functions/arithmetic.rs:532: replace special_less_v2 -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:389: replace Lexer<'a>::read_ascii_string -> LexResult<Token> with LexResult::from_iter([Default::default()])
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:213: replace ContractContext::add_read_only_function_type -> CheckResult<()> with CheckResult::new(())
+clarity/src/vm/contexts.rs:1420: replace Environment<'a, 'b, 'hooks>::construct_print_transaction_event -> StacksTransactionEvent with Default::default()
+clarity/src/vm/analysis/analysis_db.rs:208: replace AnalysisDatabase<'a>::get_implemented_traits -> CheckResult<BTreeSet<TraitIdentifier>> with CheckResult::from(BTreeSet::new())
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:78: replace Lexer<'a>::read_char -> LexResult<()> with LexResult::new(())
+clarity/src/vm/ast/mod.rs:174: replace inner_build_ast -> ParseResult<(ContractAST, Vec<Diagnostic>, bool)> with ParseResult::from_iter([(Default::default(), vec![], false)])
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:223: replace ContractContext::add_private_function_type -> CheckResult<()> with CheckResult::new(())
+clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs:228: replace check_special_let -> TypeResult with Default::default()
+clarity/src/vm/ast/parser/v2/mod.rs:463: replace Parser<'a>::open_tuple -> ParseResult<SetupTupleResult> with ParseResult::new(Default::default())
+clarity/src/vm/representations.rs:334: replace PreSymbolicExpression::placeholder -> PreSymbolicExpression with Default::default()
+clarity/src/vm/functions/mod.rs:573: replace native_eq -> Result<Value> with Ok(Default::default())
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:111: replace Lexer<'a>::report_line_ending -> LexResult<()> with LexResult::new(())
+clarity/src/vm/types/signatures.rs:486: replace TypeSignature::new_option -> Result<TypeSignature> with Ok(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1385: replace TypeChecker<'a, 'b>::type_check_define_nft -> CheckResult<(ClarityName, TypeSignature)> with CheckResult::from((Default::default(), Default::default()))
+clarity/src/vm/contexts.rs:829: replace OwnedEnvironment<'a, 'hooks>::eval_read_only -> Result<(Value, AssetMap, Vec<StacksTransactionEvent>)> with Ok((Default::default(), Default::default(), vec![Default::default()]))
+clarity/src/vm/types/mod.rs:1406: replace <impl From for StacksAddress>::from -> StacksAddress with Default::default()
+clarity/src/vm/contexts.rs:1209: replace Environment<'a, 'b, 'hooks>::execute_function_as_transaction -> Result<Value> with Ok(Default::default())
+clarity/src/vm/ast/parser/v1.rs:728: replace parse_no_stack_limit -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::from_iter([vec![]])
+clarity/src/vm/representations.rs:602: replace SymbolicExpression::match_trait_reference -> Option<&ClarityName> with Some(&Default::default())
+clarity/src/vm/types/mod.rs:716: replace OptionalData::type_signature -> TypeSignature with Default::default()
+clarity/src/vm/functions/arithmetic.rs:391: replace special_geq_v1 -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
+clarity/src/vm/ast/parser/v2/mod.rs:807: replace Parser<'a>::parse_node -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::new(Some(Default::default()))
+clarity/src/vm/database/clarity_db.rs:454: replace ClarityDatabase<'a>::set_block_hash -> Result<StacksBlockId> with Ok(Default::default())
+clarity/src/vm/ast/parser/v1.rs:101: replace get_value_or_err -> ParseResult<String> with ParseResult::from_iter(["xyzzy".into()])
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:516: replace TypeChecker<'a, 'b>::type_check_all -> CheckResult<Vec<TypeSignature>> with CheckResult::new(vec![])
+clarity/src/vm/analysis/read_only_checker/mod.rs:430: replace ReadOnlyChecker<'a, 'b>::check_expression_application_is_read_only -> CheckResult<bool> with CheckResult::new()
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:128: replace Lexer<'a>::skip_whitespace -> LexResult<()> with LexResult::new(())
+clarity/src/vm/analysis/type_checker/v2_1/natives/options.rs:217: replace check_special_try_ret -> TypeResult with Default::default()
+clarity/src/vm/database/key_value_wrapper.rs:338: replace RollbackWrapper<'a>::set_block_hash -> InterpreterResult<StacksBlockId> with InterpreterResult::from_iter([Default::default()])
+clarity/src/vm/analysis/type_checker/v2_1/natives/assets.rs:299: replace check_special_burn_token -> TypeResult with Default::default()
+clarity/src/vm/types/mod.rs:808: replace Value::some -> Result<Value> with Ok(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:168: replace ContractContext::check_name_used -> CheckResult<()> with CheckResult::from(())
+clarity/src/vm/ast/traits_resolver/mod.rs:36: replace <impl BuildASTPass for TraitsResolver>::run_pass -> ParseResult<()> with ParseResult::from_iter([()])
+clarity/src/vm/tests/contracts.rs:91: replace get_principal_as_principal_data -> PrincipalData with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1372: replace TypeChecker<'a, 'b>::type_check_define_ft -> CheckResult<ClarityName> with CheckResult::from(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:253: replace ContractContext::add_persisted_variable_type -> CheckResult<()> with CheckResult::from(())
+clarity/src/vm/ast/parser/v1.rs:192: replace inner_lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::new(vec![(Default::default(), 0, 0)])
+clarity/src/vm/functions/conversions.rs:106: replace native_buff_to_int_be::convert_to_int_be -> Value with Default::default()
+clarity/src/vm/ast/definition_sorter/mod.rs:456: replace GraphWalker::get_sorted_dependencies -> ParseResult<Vec<usize>> with ParseResult::new(vec![1])
+clarity/src/vm/functions/assets.rs:305: replace special_mint_token -> Result<Value> with Ok(Default::default())
+clarity/src/vm/functions/mod.rs:606: replace special_print -> Result<Value> with Ok(Default::default())
+clarity/src/vm/ast/definition_sorter/mod.rs:307: replace DefinitionSorter::probe_for_dependencies_in_tuple -> ParseResult<()> with ParseResult::from_iter([()])
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:177: replace ContractContext::add_implemented_trait -> CheckResult<()> with CheckResult::new()
+clarity/src/vm/contexts.rs:1044: replace Environment<'a, 'b, 'hooks>::eval_raw_with_rules -> Result<Value> with Ok(Default::default())
+clarity/src/vm/ast/parser/v1.rs:455: replace lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::from(vec![])
+clarity/src/vm/database/structures.rs:234: replace <impl ClarityDeserializable for STXBalance>::deserialize -> Self with Default::default()
+clarity/src/vm/database/clarity_store.rs:291: replace <impl ClarityBackingStore for MemoryBackingStore>::set_block_hash -> InterpreterResult<StacksBlockId> with InterpreterResult::new(Default::default())
+clarity/src/vm/ast/sugar_expander/mod.rs:56: replace SugarExpander::run -> ParseResult<()> with ParseResult::from(())
+clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs:685: replace TypedNativeFunction::type_check_application -> TypeResult with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1372: replace TypeChecker<'a, 'b>::type_check_define_ft -> CheckResult<ClarityName> with CheckResult::new(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:223: replace ContractContext::add_private_function_type -> CheckResult<()> with CheckResult::from(())
+clarity/src/vm/functions/arithmetic.rs:476: replace special_greater_v1 -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
+clarity/src/vm/analysis/read_only_checker/mod.rs:182: replace ReadOnlyChecker<'a, 'b>::check_reads_only_valid -> CheckResult<()> with CheckResult::from_iter([()])
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:626: replace TypeChecker<'a, 'b>::type_check_define_map -> CheckResult<(ClarityName, (TypeSignature, TypeSignature))> with CheckResult::from_iter([(Default::default(), (Default::default(), Default::default()))])
+clarity/src/vm/ast/parser/v1.rs:101: replace get_value_or_err -> ParseResult<String> with ParseResult::new()
+clarity/src/vm/ast/stack_depth_checker.rs:48: replace <impl BuildASTPass for StackDepthChecker>::run_pass -> ParseResult<()> with ParseResult::new()
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:146: replace ContractContext::add_persisted_variable_type -> CheckResult<()> with CheckResult::new()
+clarity/src/vm/functions/arithmetic.rs:639: replace native_to_int -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
+clarity/src/vm/database/clarity_db.rs:1213: replace ClarityDatabase<'a>::lookup_variable -> Result<Value> with Ok(Default::default())
+clarity/src/vm/functions/arithmetic.rs:391: replace special_geq_v1 -> InterpreterResult<Value> with InterpreterResult::new()
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:792: replace TypeChecker<'a, 'b>::type_check_define_trait -> CheckResult<(ClarityName, BTreeMap<ClarityName, FunctionSignature>)> with CheckResult::from((Default::default(), BTreeMap::new()))
+clarity/src/vm/analysis/read_only_checker/mod.rs:182: replace ReadOnlyChecker<'a, 'b>::check_reads_only_valid -> CheckResult<()> with CheckResult::from(())
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:246: replace Lexer<'a>::read_trait_identifier -> LexResult<Token> with LexResult::from_iter([Default::default()])
+clarity/src/vm/ast/parser/v2/mod.rs:521: replace Parser<'a>::read_principal -> ParseResult<PreSymbolicExpression> with ParseResult::new()
+clarity/src/vm/analysis/trait_checker/mod.rs:55: replace TraitChecker::run -> CheckResult<()> with CheckResult::from_iter([()])
+clarity/src/vm/functions/arithmetic.rs:554: replace native_add -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
+clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs:359: replace check_contract_call -> TypeResult with Default::default()
+clarity/src/vm/test_util/mod.rs:65: replace symbols_from_values -> Vec<SymbolicExpression> with vec![Default::default()]
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:389: replace Lexer<'a>::read_ascii_string -> LexResult<Token> with LexResult::new(Default::default())
+clarity/src/vm/costs/mod.rs:820: replace LimitedCostTracker::get_limit -> ExecutionCost with Default::default()
+clarity/src/vm/functions/arithmetic.rs:579: replace native_bitwise_left_shift -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
+clarity/src/vm/types/signatures.rs:329: replace <impl From for TypeSignature>::from -> Self with Default::default()
+clarity/src/vm/analysis/type_checker/v2_05/natives/assets.rs:195: replace check_special_get_token_supply -> TypeResult with Default::default()
+clarity/src/vm/types/mod.rs:202: replace TraitIdentifier::parse -> Result<(Option<StandardPrincipalData>, ContractName, ClarityName)> with Ok((None, Default::default(), Default::default()))
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:182: replace ContractContext::get_trait -> Option<&BTreeMap<ClarityName, FunctionSignature>> with Some(&BTreeMap::from_iter([(Default::default(), Default::default())]))
+clarity/src/vm/functions/arithmetic.rs:448: replace special_leq_v2 -> InterpreterResult<Value> with InterpreterResult::new()
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:233: replace ContractContext::add_map_type -> CheckResult<()> with CheckResult::from(())
+clarity/src/vm/tests/mod.rs:147: replace TopLevelMemoryEnvironmentGenerator::get_env -> OwnedEnvironment with Default::default()
+clarity/src/vm/functions/arithmetic.rs:532: replace special_less_v2 -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
+clarity/src/vm/types/signatures.rs:128: replace SequenceSubtype::unit_type -> TypeSignature with Default::default()
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:111: replace Lexer<'a>::report_line_ending -> LexResult<()> with LexResult::new()
+clarity/src/vm/functions/arithmetic.rs:377: replace native_bitwise_or -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
+clarity/src/vm/ast/parser/v2/mod.rs:1083: replace Parser<'a>::parse -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::new(vec![Default::default()])
+clarity/src/vm/contexts.rs:852: replace OwnedEnvironment<'a, 'hooks>::destruct -> Option<(ClarityDatabase<'a>, LimitedCostTracker)> with Some((Default::default(), Default::default()))
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:156: replace FunctionType::check_args_2_1 -> CheckResult<TypeSignature> with CheckResult::from(Default::default())
+clarity/src/vm/ast/parser/v2/mod.rs:1093: replace parse -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::new(vec![])
+clarity/src/vm/functions/arithmetic.rs:563: replace native_div -> InterpreterResult<Value> with InterpreterResult::new()
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:839: replace contract_analysis_size -> CheckResult<u64> with CheckResult::from_iter([1])
+clarity/src/vm/functions/mod.rs:197: replace NativeFunctions::lookup_by_name_at_version -> Option<NativeFunctions> with Some(Default::default())
+clarity/src/vm/ast/parser/v2/mod.rs:283: replace Parser<'a>::handle_open_tuple -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::new(Some(Default::default()))
+clarity/src/vm/analysis/analysis_db.rs:189: replace AnalysisDatabase<'a>::get_defined_trait -> CheckResult<Option<BTreeMap<ClarityName, FunctionSignature>>> with CheckResult::from_iter([Some(BTreeMap::from_iter([(Default::default(), Default::default())]))])
+clarity/src/vm/ast/mod.rs:103: replace build_ast_with_rules -> ParseResult<ContractAST> with ParseResult::new()
+clarity/src/vm/functions/arithmetic.rs:490: replace special_greater_v2 -> InterpreterResult<Value> with InterpreterResult::new()
+clarity/src/vm/analysis/read_only_checker/mod.rs:268: replace ReadOnlyChecker<'a, 'b>::try_check_native_function_is_read_only -> Option<CheckResult<bool>> with Some(CheckResult::new(true))
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1229: replace TypeChecker<'a, 'b>::clarity1_type_check_expects -> TypeResult with Default::default()
+clarity/src/vm/functions/arithmetic.rs:391: replace special_geq_v1 -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:415: replace FunctionType::check_args_by_allowing_trait_cast_2_1 -> CheckResult<TypeSignature> with CheckResult::new(Default::default())
+clarity/src/vm/types/signatures.rs:464: replace ListTypeData::destruct -> (TypeSignature, u32) with (Default::default(), 0)
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:86: replace TraitContext::add_used_trait -> CheckResult<()> with CheckResult::new()
+clarity/src/vm/database/key_value_wrapper.rs:466: replace RollbackWrapper<'a>::get_metadata -> InterpreterResult<Option<String>> with InterpreterResult::from(Some("xyzzy".into()))
+clarity/src/vm/functions/arithmetic.rs:572: replace native_log2 -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
+clarity/src/vm/database/clarity_db.rs:1317: replace ClarityDatabase<'a>::fetch_entry_unknown_descriptor -> Result<Value> with Ok(Default::default())
+clarity/src/vm/costs/mod.rs:1186: replace ExecutionCost::runtime -> ExecutionCost with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/natives/options.rs:77: replace check_special_is_response -> TypeResult with Default::default()
+clarity/src/vm/ast/parser/v1.rs:192: replace inner_lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::from(vec![])
+clarity/src/vm/analysis/trait_checker/mod.rs:55: replace TraitChecker::run -> CheckResult<()> with CheckResult::new(())
+clarity/src/vm/ast/definition_sorter/mod.rs:456: replace GraphWalker::get_sorted_dependencies -> ParseResult<Vec<usize>> with ParseResult::new(vec![0])
+clarity/src/vm/representations.rs:586: replace SymbolicExpression::match_atom_value -> Option<&Value> with Some(&Default::default())
+clarity/src/vm/analysis/type_checker/contexts.rs:57: replace TypeMap::set_type -> CheckResult<()> with CheckResult::from(())
+clarity/src/vm/ast/mod.rs:309: replace build_ast -> ParseResult<ContractAST> with ParseResult::new(Default::default())
+clarity/src/vm/contexts.rs:408: replace AssetMap::to_table -> HashMap<PrincipalData, HashMap<AssetIdentifier, AssetMapEntry>> with HashMap::from_iter([(Default::default(), HashMap::new())])
+clarity/src/vm/functions/arithmetic.rs:405: replace special_geq_v2 -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
+clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs:512: replace check_get_block_info -> TypeResult with Default::default()
+clarity/src/vm/analysis/errors.rs:248: replace <impl From for CheckErrors>::from -> Self with Default::default()
+clarity/src/vm/ast/traits_resolver/mod.rs:182: replace TraitsResolver::try_parse_pre_expr -> Option<(DefineFunctions, Vec<&'a PreSymbolicExpression>)> with Some((Default::default(), vec![&Default::default()]))
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:792: replace TypeChecker<'a, 'b>::type_check_define_trait -> CheckResult<(ClarityName, BTreeMap<ClarityName, FunctionSignature>)> with CheckResult::new((Default::default(), BTreeMap::from_iter([(Default::default(), Default::default())])))
+clarity/src/vm/functions/arithmetic.rs:546: replace special_less -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:123: replace <impl AnalysisPass for TypeChecker<'_, '_>>::run_pass -> CheckResult<()> with CheckResult::new(())
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:253: replace ContractContext::add_persisted_variable_type -> CheckResult<()> with CheckResult::new(())
+clarity/src/vm/ast/parser/v2/mod.rs:1093: replace parse -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::from(vec![Default::default()])
+clarity/src/vm/analysis/analysis_db.rs:153: replace AnalysisDatabase<'a>::get_public_function_type -> CheckResult<Option<FunctionType>> with CheckResult::new()
+clarity/src/vm/ast/parser/v2/mod.rs:119: replace Parser<'a>::add_diagnostic -> ParseResult<()> with ParseResult::new(())
+clarity/src/vm/contexts.rs:815: replace OwnedEnvironment<'a, 'hooks>::eval_read_only_with_rules -> Result<(Value, AssetMap, Vec<StacksTransactionEvent>)> with Ok((Default::default(), Default::default(), vec![Default::default()]))
+clarity/src/vm/database/clarity_db.rs:1115: replace map_no_contract_as_none -> Result<Option<T>> with Ok(Some(Default::default()))
+clarity/src/vm/analysis/analysis_db.rs:123: replace AnalysisDatabase<'a>::insert_contract -> CheckResult<()> with CheckResult::from_iter([()])
+clarity/src/vm/test_util/mod.rs:110: replace <impl From for PrincipalData>::from -> PrincipalData with Default::default()
+clarity/src/vm/ast/parser/v1.rs:192: replace inner_lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::from_iter([vec![]])
+clarity/src/vm/database/sqlite.rs:187: replace SqliteConnection::open -> Result<Connection> with Ok(Default::default())
+clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs:489: replace check_secp256k1_recover -> TypeResult with Default::default()
+clarity/src/vm/ast/parser/v2/mod.rs:119: replace Parser<'a>::add_diagnostic -> ParseResult<()> with ParseResult::from_iter([()])
+clarity/src/vm/ast/parser/v1.rs:101: replace get_value_or_err -> ParseResult<String> with ParseResult::new("xyzzy".into())
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:766: replace TypeChecker<'a, 'b>::type_check_define_ft -> CheckResult<ClarityName> with CheckResult::new()
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:831: replace trait_type_size -> CheckResult<u64> with CheckResult::from_iter([1])
+clarity/src/vm/database/clarity_store.rs:243: replace <impl ClarityBackingStore for NullBackingStore>::get_open_chain_tip -> StacksBlockId with Default::default()
+clarity/src/vm/ast/mod.rs:87: replace ast_check_size -> ParseResult<ContractAST> with ParseResult::from(Default::default())
+clarity/src/vm/types/mod.rs:1421: replace <impl From for Value>::from -> Self with Default::default()
+clarity/src/vm/functions/database.rs:333: replace special_set_variable_v205 -> Result<Value> with Ok(Default::default())
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:779: replace TypeChecker<'a, 'b>::type_check_define_nft -> CheckResult<(ClarityName, TypeSignature)> with CheckResult::from_iter([(Default::default(), Default::default())])
+clarity/src/vm/types/mod.rs:169: replace <impl StacksAddressExtensions for StacksAddress>::to_account_principal -> PrincipalData with Default::default()
+clarity/src/vm/ast/parser/v2/mod.rs:283: replace Parser<'a>::handle_open_tuple -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::from_iter([Some(Default::default())])
+clarity/src/vm/analysis/type_checker/mod.rs:45: replace FunctionType::check_args -> CheckResult<TypeSignature> with CheckResult::from_iter([Default::default()])
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:415: replace FunctionType::check_args_by_allowing_trait_cast_2_1 -> CheckResult<TypeSignature> with CheckResult::from(Default::default())
+clarity/src/vm/functions/crypto.rs:139: replace special_secp256k1_recover -> Result<Value> with Ok(Default::default())
+clarity/src/vm/ast/expression_identifier/mod.rs:51: replace ExpressionIdentifier::run_pre_expression_pass -> ParseResult<()> with ParseResult::new()
+clarity/src/vm/ast/parser/v1.rs:455: replace lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::from_iter([vec![(Default::default(), 1, 0)]])
+clarity/src/vm/analysis/trait_checker/mod.rs:55: replace TraitChecker::run -> CheckResult<()> with CheckResult::new()
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:929: replace TypeChecker<'a, 'b>::run -> CheckResult<()> with CheckResult::from(())
+clarity/src/vm/ast/parser/v2/mod.rs:807: replace Parser<'a>::parse_node -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::new()
+clarity/src/vm/contexts.rs:705: replace OwnedEnvironment<'a, 'hooks>::initialize_versioned_contract -> Result<((), AssetMap, Vec<StacksTransactionEvent>)> with Ok(((), Default::default(), vec![Default::default()]))
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:123: replace <impl AnalysisPass for TypeChecker<'_, '_>>::run_pass -> CheckResult<()> with CheckResult::from(())
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1414: replace TypeChecker<'a, 'b>::try_type_check_define -> CheckResult<Option<()>> with CheckResult::from_iter([None])
+clarity/src/vm/ast/parser/v2/mod.rs:1093: replace parse -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::from(vec![])
+clarity/src/vm/errors.rs:163: replace <impl Error for RuntimeErrorType>::source -> Option<&(dyn error::Error +'static)> with Some(&Default::default())
+clarity/src/vm/analysis/analysis_db.rs:123: replace AnalysisDatabase<'a>::insert_contract -> CheckResult<()> with CheckResult::new()
+clarity/src/vm/analysis/types.rs:171: replace ContractAnalysis::get_private_function -> Option<&FunctionType> with Some(&Default::default())
+clarity/src/vm/types/signatures.rs:1167: replace TypeSignature::least_supertype_v2_1 -> Result<TypeSignature> with Ok(Default::default())
+clarity/src/vm/ast/parser/v1.rs:192: replace inner_lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::new(vec![(Default::default(), 0, 1)])
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:233: replace ContractContext::add_map_type -> CheckResult<()> with CheckResult::from_iter([()])
+clarity/src/vm/functions/arithmetic.rs:566: replace native_pow -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
+clarity/src/vm/functions/arithmetic.rs:369: replace native_bitwise_xor -> InterpreterResult<Value> with InterpreterResult::new()
+clarity/src/vm/representations.rs:380: replace PreSymbolicExpression::match_field_identifier -> Option<&TraitIdentifier> with Some(&Default::default())
+clarity/src/vm/database/clarity_store.rs:217: replace NullBackingStore::as_analysis_db -> AnalysisDatabase with Default::default()
+clarity/src/vm/types/mod.rs:676: replace <impl SequencedValue for UTF8Data>::items -> &Vec<Vec<u8>> with &vec![]
+clarity/src/vm/analysis/contract_interface_builder/mod.rs:28: replace build_contract_interface -> ContractInterface with Default::default()
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:152: replace ContractContext::add_ft -> CheckResult<()> with CheckResult::new()
+clarity/src/vm/ast/mod.rs:288: replace build_ast_precheck_size -> ParseResult<ContractAST> with ParseResult::new(Default::default())
+clarity/src/vm/ast/parser/v1.rs:720: replace parse -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::from_iter([vec![]])
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:162: replace ContractContext::add_nft -> CheckResult<()> with CheckResult::from(())
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:116: replace ContractContext::add_private_function_type -> CheckResult<()> with CheckResult::from(())
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:288: replace Lexer<'a>::read_principal -> LexResult<Token> with LexResult::new()
+clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs:221: replace check_special_let -> TypeResult with Default::default()
+clarity/src/vm/ast/parser/v1.rs:720: replace parse -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::from(vec![])
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:345: replace Lexer<'a>::read_hex -> LexResult<Token> with LexResult::from_iter([Default::default()])
+clarity/src/vm/database/key_value_wrapper.rs:466: replace RollbackWrapper<'a>::get_metadata -> InterpreterResult<Option<String>> with InterpreterResult::new(Some(String::new()))
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:345: replace Lexer<'a>::read_hex -> LexResult<Token> with LexResult::new()
+clarity/src/vm/analysis/type_checker/v2_1/natives/options.rs:255: replace check_special_unwrap -> TypeResult with Default::default()
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:136: replace ContractContext::add_variable_type -> CheckResult<()> with CheckResult::new()
+clarity/src/vm/errors.rs:181: replace <impl From for Error>::from -> Self with Default::default()
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:516: replace TypeChecker<'a, 'b>::type_check_all -> CheckResult<Vec<TypeSignature>> with CheckResult::from_iter([vec![Default::default()]])
+clarity/src/vm/analysis/type_checker/mod.rs:45: replace FunctionType::check_args -> CheckResult<TypeSignature> with CheckResult::from(Default::default())
+clarity/src/vm/callables.rs:394: replace FunctionIdentifier::new_user_function -> FunctionIdentifier with Default::default()
+clarity/src/vm/types/signatures.rs:59: replace AssetIdentifier::STX_burned -> AssetIdentifier with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:892: replace TypeChecker<'a, 'b>::into_contract_analysis -> LimitedCostTracker with Default::default()
+clarity/src/vm/costs/mod.rs:395: replace load_cost_functions -> Result<CostStateSummary> with Ok(Default::default())
+clarity/src/vm/errors.rs:205: replace <impl From for Error>::from -> Self with Default::default()
+clarity/src/vm/ast/parser/v2/mod.rs:219: replace Parser<'a>::handle_open_node -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::from(Some(Default::default()))
+clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs:64: replace check_special_list_cons -> TypeResult with Default::default()
+clarity/src/vm/types/mod.rs:1487: replace TupleData::from_data -> Result<TupleData> with Ok(Default::default())
+clarity/src/vm/functions/arithmetic.rs:629: replace native_to_uint -> InterpreterResult<Value> with InterpreterResult::new()
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:190: replace ContractContext::get_variable_type -> Option<&TypeSignature> with Some(&Default::default())
+clarity/src/vm/types/signatures.rs:243: replace FunctionArgSignature::canonicalize -> FunctionArgSignature with Default::default()
+clarity/src/vm/functions/arithmetic.rs:629: replace native_to_uint -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
+clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs:141: replace check_special_get -> TypeResult with Default::default()
+clarity/src/vm/functions/assets.rs:499: replace special_transfer_asset_v200 -> Result<Value> with Ok(Default::default())
+clarity/src/vm/costs/mod.rs:807: replace LimitedCostTracker::get_total -> ExecutionCost with Default::default()
+clarity/src/vm/types/mod.rs:615: replace <impl SequencedValue for ListData>::items -> &Vec<Value> with &vec![]
+clarity/src/vm/database/clarity_db.rs:926: replace ClarityDatabase<'a>::get_burnchain_block_header_hash_for_burnchain_height -> Option<BurnchainHeaderHash> with Some(Default::default())
+clarity/src/vm/ast/mod.rs:130: replace build_ast_typical -> ParseResult<ContractAST> with ParseResult::from(Default::default())
+clarity/src/vm/analysis/type_checker/v2_05/natives/maps.rs:153: replace check_special_set_entry -> TypeResult with Default::default()
+clarity/src/vm/functions/database.rs:555: replace special_insert_entry_v200 -> Result<Value> with Ok(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:929: replace TypeChecker<'a, 'b>::run -> CheckResult<()> with CheckResult::new(())
+clarity/src/vm/contexts.rs:583: replace OwnedEnvironment<'a, 'hooks>::new_max_limit -> OwnedEnvironment<'a, '_> with Default::default()
+clarity/src/vm/analysis/analysis_db.rs:41: replace AnalysisDatabase<'a>::new_with_rollback_wrapper -> AnalysisDatabase<'a> with Default::default()
+clarity/src/vm/functions/arithmetic.rs:448: replace special_leq_v2 -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
+clarity/src/vm/ast/parser/v2/mod.rs:1109: replace parse_collect_diagnostics -> (Vec<PreSymbolicExpression>, Vec<Diagnostic>, bool) with (vec![Default::default()], vec![Default::default()], true)
+clarity/src/vm/database/key_value_wrapper.rs:495: replace RollbackWrapper<'a>::get_metadata_manual -> InterpreterResult<Option<String>> with InterpreterResult::from_iter([Some("xyzzy".into())])
+clarity/src/vm/database/clarity_db.rs:853: replace ClarityDatabase<'a>::get_block_header_hash -> BlockHeaderHash with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1171: replace TypeChecker<'a, 'b>::type_check_function_application -> TypeResult with Default::default()
+clarity/src/vm/database/clarity_db.rs:160: replace <impl HeadersDB for &dyn HeadersDB>::get_burn_header_hash_for_block -> Option<BurnchainHeaderHash> with Some(Default::default())
+clarity/src/vm/mod.rs:545: replace execute_against_version -> Result<Option<Value>> with Ok(Some(Default::default()))
+clarity/src/vm/representations.rs:348: replace PreSymbolicExpression::match_trait_reference -> Option<&ClarityName> with Some(&Default::default())
+clarity/src/vm/types/mod.rs:858: replace Value::error -> Result<Value> with Ok(Default::default())
+clarity/src/vm/database/clarity_db.rs:1141: replace ClarityDatabase<'a>::load_variable -> Result<DataVariableMetadata> with Ok(Default::default())
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:288: replace Lexer<'a>::read_principal -> LexResult<Token> with LexResult::new(Default::default())
+clarity/src/vm/representations.rs:136: replace <impl StacksMessageCodec for ContractName>::consensus_deserialize -> Result<ContractName, codec_error> with Ok(Default::default())
+clarity/src/vm/analysis/read_only_checker/mod.rs:170: replace ReadOnlyChecker<'a, 'b>::check_define_function -> CheckResult<(ClarityName, bool)> with CheckResult::from((Default::default(), true))
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1023: replace TypeChecker<'a, 'b>::type_check_all -> CheckResult<Vec<TypeSignature>> with CheckResult::from_iter([vec![]])
+clarity/src/vm/ast/parser/v1.rs:720: replace parse -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::from(vec![Default::default()])
+clarity/src/vm/functions/options.rs:234: replace native_is_some -> Result<Value> with Ok(Default::default())
+clarity/src/vm/costs/mod.rs:1099: replace <impl FromSql for ExecutionCost>::column_result -> FromSqlResult<ExecutionCost> with FromSqlResult::new()
+clarity/src/vm/functions/arithmetic.rs:391: replace special_geq_v1 -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
+clarity/src/vm/functions/arithmetic.rs:419: replace special_geq -> InterpreterResult<Value> with InterpreterResult::new()
+clarity/src/vm/functions/options.rs:202: replace special_match -> Result<Value> with Ok(Default::default())
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:297: replace trait_type_size -> CheckResult<u64> with CheckResult::from(1)
+clarity/src/vm/database/clarity_db.rs:778: replace ClarityDatabase<'a>::destroy -> RollbackWrapper<'a> with Default::default()
+clarity/src/vm/analysis/read_only_checker/mod.rs:59: replace <impl AnalysisPass for ReadOnlyChecker<'a, 'b>>::run_pass -> CheckResult<()> with CheckResult::from(())
+clarity/src/vm/types/signatures.rs:1312: replace TypeSignature::type_of -> TypeSignature with Default::default()
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:808: replace TypeChecker<'a, 'b>::try_type_check_define -> CheckResult<Option<()>> with CheckResult::new()
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:808: replace TypeChecker<'a, 'b>::try_type_check_define -> CheckResult<Option<()>> with CheckResult::from(Some(()))
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:243: replace ContractContext::add_variable_type -> CheckResult<()> with CheckResult::new(())
+clarity/src/vm/types/mod.rs:1533: replace TupleData::shallow_merge -> Result<TupleData> with Ok(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/natives/maps.rs:73: replace check_special_delete_entry -> TypeResult with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs:422: replace check_special_slice -> TypeResult with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:415: replace FunctionType::check_args_by_allowing_trait_cast_2_1 -> CheckResult<TypeSignature> with CheckResult::from_iter([Default::default()])
+clarity/src/vm/ast/parser/v1.rs:508: replace parse_lexed -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::from_iter([vec![Default::default()]])
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:296: replace ContractContext::add_implemented_trait -> CheckResult<()> with CheckResult::new()
+clarity/src/vm/analysis/type_checker/v2_05/natives/options.rs:165: replace inner_unwrap_err -> TypeResult with Default::default()
+clarity/src/vm/types/mod.rs:676: replace <impl SequencedValue for UTF8Data>::items -> &Vec<Vec<u8>> with &vec![vec![1]]
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:311: replace Lexer<'a>::read_unsigned -> LexResult<Token> with LexResult::from_iter([Default::default()])
+clarity/src/vm/contexts.rs:1903: replace LocalContext<'a>::lookup_variable -> Option<&Value> with Some(&Default::default())
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:288: replace Lexer<'a>::read_principal -> LexResult<Token> with LexResult::from_iter([Default::default()])
+clarity/src/vm/analysis/type_checker/v2_05/natives/sequences.rs:118: replace check_special_filter -> TypeResult with Default::default()
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:626: replace TypeChecker<'a, 'b>::type_check_define_map -> CheckResult<(ClarityName, (TypeSignature, TypeSignature))> with CheckResult::new()
+clarity/src/vm/costs/mod.rs:1099: replace <impl FromSql for ExecutionCost>::column_result -> FromSqlResult<ExecutionCost> with FromSqlResult::from_iter([Default::default()])
+clarity/src/vm/functions/define.rs:277: replace DefineFunctions::try_parse -> Option<(DefineFunctions, &[SymbolicExpression])> with Some((Default::default(), Vec::leak(vec![Default::default()])))
+clarity/src/vm/ast/definition_sorter/mod.rs:433: replace Graph::edges_count -> ParseResult<u64> with ParseResult::from_iter([1])
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:516: replace TypeChecker<'a, 'b>::type_check_all -> CheckResult<Vec<TypeSignature>> with CheckResult::from(vec![])
+clarity/src/vm/functions/options.rs:250: replace native_okay -> Result<Value> with Ok(Default::default())
+clarity/src/vm/types/serialization.rs:295: replace <impl StacksMessageCodec for PrincipalData>::consensus_deserialize -> Result<PrincipalData, codec_error> with Ok(Default::default())
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:128: replace Lexer<'a>::skip_whitespace -> LexResult<()> with LexResult::from(())
+clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs:292: replace check_special_set_var -> TypeResult with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1156: replace TypeChecker<'a, 'b>::try_native_function_check -> Option<TypeResult> with Some(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:243: replace ContractContext::add_variable_type -> CheckResult<()> with CheckResult::from_iter([()])
+clarity/src/vm/functions/crypto.rs:181: replace special_secp256k1_verify -> Result<Value> with Ok(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:929: replace TypeChecker<'a, 'b>::run -> CheckResult<()> with CheckResult::new()
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:740: replace TypeChecker<'a, 'b>::type_check_define_variable -> CheckResult<(ClarityName, TypeSignature)> with CheckResult::new((Default::default(), Default::default()))
+clarity/src/vm/types/signatures.rs:972: replace TypeSignature::min_string_utf8 -> TypeSignature with Default::default()
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:535: replace TypeChecker<'a, 'b>::get_function_type -> Option<FunctionType> with Some(Default::default())
+clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs:452: replace check_contract_of -> TypeResult with Default::default()
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:185: replace Lexer<'a>::proceed_through_error_string -> LexResult<String> with LexResult::from_iter(["xyzzy".into()])
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:162: replace ContractContext::add_nft -> CheckResult<()> with CheckResult::new()
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:388: replace TypeChecker<'a, 'b>::run -> CheckResult<()> with CheckResult::new()
+clarity/src/vm/analysis/type_checker/v2_1/natives/options.rs:267: replace check_special_unwrap_err -> TypeResult with Default::default()
+clarity/src/vm/mod.rs:136: replace CostSynthesis::from_cost_tracker -> CostSynthesis with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:839: replace contract_analysis_size -> CheckResult<u64> with CheckResult::from(0)
+clarity/src/vm/types/mod.rs:661: replace <impl SequencedValue for ASCIIData>::type_signature -> TypeSignature with Default::default()
+clarity/src/vm/functions/arithmetic.rs:373: replace native_bitwise_and -> InterpreterResult<Value> with InterpreterResult::new()
+clarity/src/vm/functions/arithmetic.rs:364: replace native_xor -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:210: replace Lexer<'a>::read_identifier -> LexResult<Token> with LexResult::new(Default::default())
+clarity/src/vm/analysis/type_checker/contexts.rs:57: replace TypeMap::set_type -> CheckResult<()> with CheckResult::from_iter([()])
+clarity/src/vm/types/mod.rs:633: replace <impl SequencedValue for BuffData>::items -> &Vec<u8> with &vec![1]
+clarity/src/vm/ast/definition_sorter/mod.rs:307: replace DefinitionSorter::probe_for_dependencies_in_tuple -> ParseResult<()> with ParseResult::new()
+clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs:538: replace TypedNativeFunction::type_check_application -> TypeResult with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1414: replace TypeChecker<'a, 'b>::try_type_check_define -> CheckResult<Option<()>> with CheckResult::new(None)
+clarity/src/vm/ast/parser/v1.rs:720: replace parse -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::from_iter([vec![Default::default()]])
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:279: replace ContractContext::add_defined_trait -> CheckResult<()> with CheckResult::new()
+clarity/src/vm/database/key_value_wrapper.rs:402: replace RollbackWrapper<'a>::get_value -> Result<Option<ValueResult>, SerializationError> with Ok(Some(Default::default()))
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:146: replace ContractContext::add_persisted_variable_type -> CheckResult<()> with CheckResult::from_iter([()])
+clarity/src/vm/errors.rs:216: replace <impl From for Value>::from -> Self with Default::default()
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:246: replace Lexer<'a>::read_trait_identifier -> LexResult<Token> with LexResult::new()
+clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs:118: replace check_special_filter -> TypeResult with Default::default()
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:311: replace Lexer<'a>::read_unsigned -> LexResult<Token> with LexResult::new()
+clarity/src/vm/functions/boolean.rs:74: replace native_not -> Result<Value> with Ok(Default::default())
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:152: replace ContractContext::add_ft -> CheckResult<()> with CheckResult::from_iter([()])
+clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs:167: replace check_special_merge -> TypeResult with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:243: replace ContractContext::add_variable_type -> CheckResult<()> with CheckResult::new()
+clarity/src/vm/analysis/mod.rs:122: replace run_analysis -> Result<ContractAnalysis, (CheckError, LimitedCostTracker)> with Ok(Default::default())
+clarity/src/vm/docs/contracts.rs:62: replace get_constant_value -> Value with Default::default()
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:86: replace <impl CostTracker for TypeChecker<'_, '_>>::compute_cost -> Result<ExecutionCost, CostErrors> with Ok(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs:264: replace check_special_append -> TypeResult with Default::default()
+clarity/src/vm/database/key_value_wrapper.rs:495: replace RollbackWrapper<'a>::get_metadata_manual -> InterpreterResult<Option<String>> with InterpreterResult::new(Some("xyzzy".into()))
+clarity/src/vm/functions/conversions.rs:128: replace native_string_to_int_generic -> Result<Value> with Ok(Default::default())
+clarity/src/vm/functions/arithmetic.rs:569: replace native_sqrti -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:415: replace FunctionType::check_args_by_allowing_trait_cast_2_1 -> CheckResult<TypeSignature> with CheckResult::new()
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:516: replace TypeChecker<'a, 'b>::type_check_all -> CheckResult<Vec<TypeSignature>> with CheckResult::from_iter([vec![]])
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:259: replace ContractContext::add_ft -> CheckResult<()> with CheckResult::new()
+clarity/src/vm/ast/parser/v2/mod.rs:1083: replace Parser<'a>::parse -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::from_iter([vec![Default::default()]])
+clarity/src/vm/types/signatures.rs:962: replace TypeSignature::min_buffer -> TypeSignature with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1283: replace TypeChecker<'a, 'b>::clarity2_type_check_expects -> TypeResult with Default::default()
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:106: replace ContractContext::add_read_only_function_type -> CheckResult<()> with CheckResult::new(())
+clarity/src/vm/functions/arithmetic.rs:405: replace special_geq_v2 -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
+clarity/src/vm/functions/define.rs:263: replace handle_use_trait -> Result<DefineResult> with Ok(Default::default())
+clarity/src/vm/functions/options.rs:238: replace native_is_none -> Result<Value> with Ok(Default::default())
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:78: replace Lexer<'a>::read_char -> LexResult<()> with LexResult::from(())
+clarity/src/vm/analysis/type_checker/v2_05/natives/maps.rs:34: replace check_special_fetch_entry -> TypeResult with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:839: replace contract_analysis_size -> CheckResult<u64> with CheckResult::new(0)
+clarity/src/vm/analysis/analysis_db.rs:137: replace AnalysisDatabase<'a>::get_clarity_version -> CheckResult<ClarityVersion> with CheckResult::from(Default::default())
+clarity/src/vm/analysis/contract_interface_builder/mod.rs:170: replace ContractInterfaceAtomType::vec_from_tuple_type -> Vec<ContractInterfaceTupleEntryType> with vec![Default::default()]
+clarity/src/vm/functions/crypto.rs:83: replace pubkey_to_address_v2 -> StacksAddress with Default::default()
+clarity/src/vm/tests/mod.rs:137: replace MemoryEnvironmentGenerator::get_env -> OwnedEnvironment with Default::default()
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:358: replace TypeChecker<'a, 'b>::track_return_type -> CheckResult<()> with CheckResult::new()
+clarity/src/vm/types/mod.rs:742: replace BlockInfoProperty::type_result -> TypeSignature with Default::default()
+clarity/src/vm/ast/mod.rs:69: replace parse_in_epoch -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::from(vec![Default::default()])
+clarity/src/vm/types/mod.rs:1135: replace Value::expect_result -> std::result::Result<Value, Value> with Ok(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1136: replace TypeChecker<'a, 'b>::type_check_define_map -> CheckResult<(ClarityName, (TypeSignature, TypeSignature))> with CheckResult::new()
+clarity/src/vm/types/mod.rs:676: replace <impl SequencedValue for UTF8Data>::items -> &Vec<Vec<u8>> with &vec![vec![0]]
+clarity/src/vm/contexts.rs:845: replace OwnedEnvironment<'a, 'hooks>::get_cost_total -> ExecutionCost with Default::default()
+clarity/src/vm/functions/arithmetic.rs:59: replace UTF8Ops::make_value -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
+clarity/src/vm/analysis/read_only_checker/mod.rs:88: replace ReadOnlyChecker<'a, 'b>::run -> CheckResult<()> with CheckResult::new()
+clarity/src/vm/ast/stack_depth_checker.rs:74: replace <impl BuildASTPass for VaryStackDepthChecker>::run_pass -> ParseResult<()> with ParseResult::from(())
+clarity/src/vm/ast/traits_resolver/mod.rs:48: replace TraitsResolver::run -> ParseResult<()> with ParseResult::from_iter([()])
+clarity/src/vm/mod.rs:513: replace execute_with_parameters -> Result<Option<Value>> with Ok(Some(Default::default()))
+clarity/src/vm/functions/conversions.rs:97: replace native_buff_to_uint_le::convert_to_uint_le -> Value with Default::default()
+clarity/src/vm/database/key_value_wrapper.rs:466: replace RollbackWrapper<'a>::get_metadata -> InterpreterResult<Option<String>> with InterpreterResult::from_iter([Some(String::new())])
+clarity/src/vm/types/mod.rs:910: replace Value::cons_list_unsanitized -> Result<Value> with Ok(Default::default())
+clarity/src/vm/database/key_value_wrapper.rs:59: replace rollback_check_pre_bottom_commit -> Vec<(T, String)> with vec![(Default::default(), String::new())]
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1398: replace TypeChecker<'a, 'b>::type_check_define_trait -> CheckResult<(ClarityName, BTreeMap<ClarityName, FunctionSignature>)> with CheckResult::from((Default::default(), BTreeMap::from_iter([(Default::default(), Default::default())])))
+clarity/src/vm/functions/arithmetic.rs:579: replace native_bitwise_left_shift -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
+clarity/src/vm/ast/definition_sorter/mod.rs:115: replace DefinitionSorter::probe_for_dependencies -> ParseResult<()> with ParseResult::from(())
+clarity/src/vm/ast/parser/v2/mod.rs:1109: replace parse_collect_diagnostics -> (Vec<PreSymbolicExpression>, Vec<Diagnostic>, bool) with (vec![Default::default()], vec![Default::default()], false)
+clarity/src/vm/analysis/analysis_db.rs:189: replace AnalysisDatabase<'a>::get_defined_trait -> CheckResult<Option<BTreeMap<ClarityName, FunctionSignature>>> with CheckResult::from(Some(BTreeMap::new()))
+clarity/src/vm/ast/parser/v2/mod.rs:219: replace Parser<'a>::handle_open_node -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::from_iter([None])
+clarity/src/vm/functions/arithmetic.rs:373: replace native_bitwise_and -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1044: replace TypeChecker<'a, 'b>::get_function_type -> Option<FunctionType> with Some(Default::default())
+clarity/src/vm/costs/mod.rs:712: replace LimitedCostTracker::new_free -> LimitedCostTracker with Default::default()
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:751: replace TypeChecker<'a, 'b>::type_check_define_persisted_variable -> CheckResult<(ClarityName, TypeSignature)> with CheckResult::new((Default::default(), Default::default()))
+clarity/src/vm/functions/assets.rs:590: replace special_transfer_asset_v205 -> Result<Value> with Ok(Default::default())
+clarity/src/vm/functions/define.rs:230: replace handle_define_map -> Result<DefineResult> with Ok(Default::default())
+clarity/src/vm/clarity.rs:84: replace <impl From for Error>::from -> Self with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1357: replace TypeChecker<'a, 'b>::type_check_define_persisted_variable -> CheckResult<(ClarityName, TypeSignature)> with CheckResult::from((Default::default(), Default::default()))
+clarity/src/vm/types/mod.rs:1238: replace UTF8Data::len -> BufferLength with Default::default()
+clarity/src/vm/errors.rs:187: replace <impl From for Error>::from -> Self with Default::default()
+clarity/src/vm/analysis/type_checker/v2_05/natives/assets.rs:135: replace check_special_transfer_asset -> TypeResult with Default::default()
+clarity/src/vm/types/mod.rs:627: replace <impl SequencedValue for ListData>::to_value -> Value with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/natives/assets.rs:61: replace check_special_get_balance -> TypeResult with Default::default()
+clarity/src/vm/analysis/type_checker/v2_05/natives/assets.rs:77: replace check_special_mint_asset -> TypeResult with Default::default()
+clarity/src/vm/analysis/type_checker/v2_05/natives/options.rs:278: replace eval_with_new_binding -> TypeResult with Default::default()
+clarity/src/vm/ast/mod.rs:69: replace parse_in_epoch -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::from(vec![])
+clarity/src/vm/functions/options.rs:66: replace native_unwrap_or_ret -> Result<Value> with Ok(Default::default())
+clarity/src/vm/ast/parser/v1.rs:508: replace parse_lexed -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::from_iter([vec![]])
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:474: replace Lexer<'a>::read_utf8_encoding -> LexResult<Result<String, String>> with LexResult::from(Ok("xyzzy".into()))
+clarity/src/vm/ast/parser/v1.rs:455: replace lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::new(vec![])
+clarity/src/vm/ast/stack_depth_checker.rs:28: replace check -> ParseResult<()> with ParseResult::from(())
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:474: replace Lexer<'a>::read_utf8_encoding -> LexResult<Result<String, String>> with LexResult::from_iter([Ok(String::new())])
+clarity/src/vm/analysis/types.rs:175: replace ContractAnalysis::get_map_type -> Option<&(TypeSignature, TypeSignature)> with Some(&(Default::default(), Default::default()))
+clarity/src/vm/types/signatures.rs:1388: replace TypeSignature::parse_list_type_repr -> Result<TypeSignature> with Ok(Default::default())
+clarity/src/vm/docs/mod.rs:2419: replace make_api_reference -> FunctionAPI with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:571: replace clarity2_trait_check_trait_compliance -> CheckResult<()> with CheckResult::from_iter([()])
+clarity/src/vm/functions/arithmetic.rs:563: replace native_div -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
+clarity/src/vm/types/signatures.rs:939: replace FunctionSignature::canonicalize -> FunctionSignature with Default::default()
+clarity/src/vm/contexts.rs:974: replace Environment<'a, 'b, 'hooks>::nest_with_caller -> Environment<'c, 'b, 'hooks> with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/natives/options.rs:202: replace check_special_unwrap_err_or_ret -> TypeResult with Default::default()
+clarity/src/vm/analysis/type_checker/v2_05/natives/options.rs:214: replace check_special_try_ret -> TypeResult with Default::default()
+clarity/src/vm/database/clarity_db.rs:793: replace ClarityDatabase<'a>::get_index_block_header_hash -> StacksBlockId with Default::default()
+clarity/src/vm/callables.rs:335: replace DefinedFunction::apply -> Result<Value> with Ok(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1385: replace TypeChecker<'a, 'b>::type_check_define_nft -> CheckResult<(ClarityName, TypeSignature)> with CheckResult::new((Default::default(), Default::default()))
+clarity/src/vm/ast/mod.rs:309: replace build_ast -> ParseResult<ContractAST> with ParseResult::from_iter([Default::default()])
+clarity/src/vm/representations.rs:372: replace PreSymbolicExpression::match_list -> Option<&[PreSymbolicExpression]> with Some(Vec::leak(vec![Default::default()]))
+clarity/src/vm/analysis/type_checker/v2_05/natives/options.rs:199: replace check_special_unwrap_err_or_ret -> TypeResult with Default::default()
+clarity/src/vm/ast/definition_sorter/mod.rs:369: replace DefinitionSorter::probe_for_dependencies_in_key_value_pair -> ParseResult<()> with ParseResult::from_iter([()])
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:247: replace FunctionType::check_args_by_allowing_trait_cast_2_05 -> CheckResult<TypeSignature> with CheckResult::new(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:223: replace ContractContext::add_private_function_type -> CheckResult<()> with CheckResult::new()
+clarity/src/vm/types/mod.rs:1507: replace TupleData::from_data_typed -> Result<TupleData> with Ok(Default::default())
+clarity/src/vm/analysis/analysis_db.rs:171: replace AnalysisDatabase<'a>::get_read_only_function_type -> CheckResult<Option<FunctionType>> with CheckResult::new(None)
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:474: replace Lexer<'a>::read_utf8_encoding -> LexResult<Result<String, String>> with LexResult::from_iter([Ok("xyzzy".into())])
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:297: replace trait_type_size -> CheckResult<u64> with CheckResult::from_iter([0])
+clarity/src/vm/ast/expression_identifier/mod.rs:23: replace inner_relabel -> ParseResult<u64> with ParseResult::from_iter([1])
+clarity/src/vm/database/clarity_db.rs:1813: replace ClarityDatabase<'a>::get_nft_key_type -> Result<TypeSignature> with Ok(Default::default())
+clarity/src/vm/functions/arithmetic.rs:41: replace U128Ops::make_value -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:145: replace FunctionType::check_args_2_05 -> CheckResult<TypeSignature> with CheckResult::new()
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:203: replace ContractContext::add_public_function_type -> CheckResult<()> with CheckResult::new()
+clarity/src/vm/representations.rs:578: replace SymbolicExpression::match_atom -> Option<&ClarityName> with Some(&Default::default())
+clarity/src/vm/ast/sugar_expander/mod.rs:40: replace <impl BuildASTPass for SugarExpander>::run_pass -> ParseResult<()> with ParseResult::new()
+clarity/src/vm/analysis/read_only_checker/mod.rs:88: replace ReadOnlyChecker<'a, 'b>::run -> CheckResult<()> with CheckResult::from(())
+clarity/src/vm/types/signatures.rs:401: replace <impl TryFrom for StringUTF8Length>::try_from -> Result<StringUTF8Length> with Ok(Default::default())
+clarity/src/vm/database/key_value_wrapper.rs:338: replace RollbackWrapper<'a>::set_block_hash -> InterpreterResult<StacksBlockId> with InterpreterResult::new()
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:785: replace clarity2_lookup_trait -> CheckResult<BTreeMap<ClarityName, FunctionSignature>> with CheckResult::new(BTreeMap::new())
+clarity/src/vm/representations.rs:327: replace PreSymbolicExpression::tuple -> PreSymbolicExpression with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs:637: replace check_get_block_info -> TypeResult with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:831: replace trait_type_size -> CheckResult<u64> with CheckResult::new(0)
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:140: replace Lexer<'a>::read_line -> LexResult<String> with LexResult::from(String::new())
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1198: replace TypeChecker<'a, 'b>::lookup_variable -> TypeResult with Default::default()
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:345: replace Lexer<'a>::read_hex -> LexResult<Token> with LexResult::from(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs:296: replace check_special_as_max_len -> TypeResult with Default::default()
+clarity/src/vm/types/mod.rs:633: replace <impl SequencedValue for BuffData>::items -> &Vec<u8> with &vec![0]
+clarity/src/vm/database/clarity_db.rs:867: replace ClarityDatabase<'a>::get_burnchain_block_header_hash -> BurnchainHeaderHash with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:316: replace ContractContext::get_persisted_variable_type -> Option<&TypeSignature> with Some(&Default::default())
+clarity/src/vm/database/clarity_store.rs:303: replace <impl ClarityBackingStore for MemoryBackingStore>::get_side_store -> &Connection with &Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:123: replace <impl AnalysisPass for TypeChecker<'_, '_>>::run_pass -> CheckResult<()> with CheckResult::new()
+clarity/src/vm/types/serialization.rs:160: replace <impl From for TypePrefix>::from -> TypePrefix with Default::default()
+clarity/src/vm/database/clarity_db.rs:1637: replace ClarityDatabase<'a>::create_non_fungible_token -> NonFungibleTokenMetadata with Default::default()
+clarity/src/vm/functions/arithmetic.rs:504: replace special_greater -> InterpreterResult<Value> with InterpreterResult::new()
+clarity/src/vm/functions/principals.rs:188: replace special_principal_construct -> Result<Value> with Ok(Default::default())
+clarity/src/vm/representations.rs:594: replace SymbolicExpression::match_literal_value -> Option<&Value> with Some(&Default::default())
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:779: replace TypeChecker<'a, 'b>::type_check_define_nft -> CheckResult<(ClarityName, TypeSignature)> with CheckResult::new()
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1357: replace TypeChecker<'a, 'b>::type_check_define_persisted_variable -> CheckResult<(ClarityName, TypeSignature)> with CheckResult::from_iter([(Default::default(), Default::default())])
+clarity/src/vm/types/mod.rs:845: replace Value::okay -> Result<Value> with Ok(Default::default())
+clarity/src/vm/ast/types.rs:55: replace ContractAST::pre_expressions_drain -> PreExpressionsDrain with Default::default()
+clarity/src/vm/types/mod.rs:955: replace Value::string_ascii_from_bytes -> Result<Value> with Ok(Default::default())
+clarity/src/vm/ast/definition_sorter/mod.rs:345: replace DefinitionSorter::probe_for_dependencies_in_list_of_wrapped_key_value_pairs -> ParseResult<()> with ParseResult::new()
+clarity/src/vm/database/key_value_wrapper.rs:466: replace RollbackWrapper<'a>::get_metadata -> InterpreterResult<Option<String>> with InterpreterResult::new(None)
+clarity/src/vm/analysis/read_only_checker/mod.rs:170: replace ReadOnlyChecker<'a, 'b>::check_define_function -> CheckResult<(ClarityName, bool)> with CheckResult::new((Default::default(), true))
+clarity/src/vm/types/mod.rs:615: replace <impl SequencedValue for ListData>::items -> &Vec<Value> with &vec![Default::default()]
+clarity/src/vm/types/signatures.rs:335: replace <impl From for TypeSignature>::from -> Self with Default::default()
+clarity/src/vm/types/mod.rs:195: replace TraitIdentifier::parse_sugared_syntax -> Result<(ContractName, ClarityName)> with Ok((Default::default(), Default::default()))
+clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs:57: replace check_special_list_cons -> TypeResult with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:86: replace TraitContext::add_used_trait -> CheckResult<()> with CheckResult::from_iter([()])
+clarity/src/vm/analysis/analysis_db.rs:189: replace AnalysisDatabase<'a>::get_defined_trait -> CheckResult<Option<BTreeMap<ClarityName, FunctionSignature>>> with CheckResult::from(None)
+clarity/src/vm/types/mod.rs:619: replace <impl SequencedValue for ListData>::drained_items -> Vec<Value> with vec![Default::default()]
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:118: replace <impl AnalysisPass for TypeChecker<'_, '_>>::run_pass -> CheckResult<()> with CheckResult::new()
+clarity/src/vm/analysis/read_only_checker/mod.rs:281: replace ReadOnlyChecker<'a, 'b>::check_native_function_is_read_only -> CheckResult<bool> with CheckResult::new(false)
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:516: replace TypeChecker<'a, 'b>::type_check_all -> CheckResult<Vec<TypeSignature>> with CheckResult::from(vec![Default::default()])
+clarity/src/vm/ast/expression_identifier/mod.rs:40: replace update_expression_id -> ParseResult<()> with ParseResult::new()
+clarity/src/vm/analysis/type_checker/v2_1/natives/assets.rs:200: replace check_special_stx_transfer -> TypeResult with Default::default()
+clarity/src/vm/types/signatures.rs:1431: replace TypeSignature::parse_string_utf8_type_repr -> Result<TypeSignature> with Ok(Default::default())
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:546: replace TypeChecker<'a, 'b>::type_check_define_function -> CheckResult<(ClarityName, FixedFunction)> with CheckResult::from_iter([(Default::default(), Default::default())])
+clarity/src/vm/database/key_value_wrapper.rs:354: replace RollbackWrapper<'a>::get_with_proof -> Option<(T, Vec<u8>)> with Some((Default::default(), vec![0]))
+clarity/src/vm/analysis/types.rs:230: replace ContractAnalysis::check_trait_compliance -> CheckResult<()> with CheckResult::from(())
+clarity/src/vm/ast/errors.rs:141: replace <impl Error for ParseError>::source -> Option<&(dyn error::Error +'static)> with Some(&Default::default())
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:740: replace TypeChecker<'a, 'b>::type_check_define_variable -> CheckResult<(ClarityName, TypeSignature)> with CheckResult::from_iter([(Default::default(), Default::default())])
+clarity/src/vm/analysis/type_checker/v2_1/natives/maps.rs:33: replace check_special_fetch_entry -> TypeResult with Default::default()
+clarity/src/vm/database/key_value_wrapper.rs:338: replace RollbackWrapper<'a>::set_block_hash -> InterpreterResult<StacksBlockId> with InterpreterResult::new(Default::default())
+clarity/src/vm/diagnostic.rs:47: replace Diagnostic::err -> Diagnostic with Default::default()
+clarity/src/vm/database/clarity_db.rs:1154: replace ClarityDatabase<'a>::set_variable_unknown_descriptor -> Result<Value> with Ok(Default::default())
+clarity/src/vm/functions/arithmetic.rs:518: replace special_less_v1 -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
+clarity/src/vm/functions/assets.rs:166: replace special_stx_transfer -> Result<Value> with Ok(Default::default())
+clarity/src/vm/analysis/type_checker/contexts.rs:57: replace TypeMap::set_type -> CheckResult<()> with CheckResult::new()
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:246: replace Lexer<'a>::read_trait_identifier -> LexResult<Token> with LexResult::from(Default::default())
+clarity/src/vm/types/signatures.rs:887: replace TupleTypeSignature::parse_name_type_pair_list -> Result<TupleTypeSignature> with Ok(Default::default())
+clarity/src/vm/types/mod.rs:820: replace Value::none -> Value with Default::default()
+clarity/src/vm/ast/expression_identifier/mod.rs:23: replace inner_relabel -> ParseResult<u64> with ParseResult::new()
+clarity/src/vm/contexts.rs:1669: replace GlobalContext<'a, 'hooks>::special_cc_handler_execute_read_only -> std::result::Result<A, E> with Ok(Default::default())
+clarity/src/vm/types/mod.rs:1456: replace <impl From for ASCIIData>::from -> Self with Default::default()
+clarity/src/vm/database/clarity_db.rs:1651: replace ClarityDatabase<'a>::load_nft -> Result<NonFungibleTokenMetadata> with Ok(Default::default())
+clarity/src/vm/functions/database.rs:682: replace special_delete_entry_v205 -> Result<Value> with Ok(Default::default())
+clarity/src/vm/analysis/read_only_checker/mod.rs:281: replace ReadOnlyChecker<'a, 'b>::check_native_function_is_read_only -> CheckResult<bool> with CheckResult::new()
+clarity/src/vm/functions/mod.rs:785: replace special_contract_of -> Result<Value> with Ok(Default::default())
+clarity/src/vm/analysis/analysis_db.rs:93: replace AnalysisDatabase<'a>::load_contract_non_canonical -> Option<ContractAnalysis> with Some(Default::default())
+clarity/src/vm/contexts.rs:1118: replace Environment<'a, 'b, 'hooks>::execute_contract_allow_private -> Result<Value> with Ok(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:233: replace ContractContext::add_map_type -> CheckResult<()> with CheckResult::new()
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:899: replace TypeChecker<'a, 'b>::track_return_type -> CheckResult<()> with CheckResult::new()
+clarity/src/vm/ast/parser/v2/mod.rs:188: replace Parser<'a>::ignore_whitespace_and_comments -> Vec<PreSymbolicExpression> with vec![Default::default()]
+clarity/src/vm/analysis/type_checker/v2_05/natives/options.rs:110: replace check_special_default_to -> TypeResult with Default::default()
+clarity/src/vm/ast/definition_sorter/mod.rs:456: replace GraphWalker::get_sorted_dependencies -> ParseResult<Vec<usize>> with ParseResult::from_iter([vec![1]])
+clarity/src/vm/ast/mod.rs:130: replace build_ast_typical -> ParseResult<ContractAST> with ParseResult::new()
+clarity/src/vm/analysis/type_checker/v2_05/natives/options.rs:264: replace check_special_unwrap_err -> TypeResult with Default::default()
+clarity/src/vm/contexts.rs:1913: replace LocalContext<'a>::lookup_callable_contract -> Option<&CallableData> with Some(&Default::default())
+clarity/src/vm/functions/tuples.rs:47: replace tuple_get -> Result<Value> with Ok(Default::default())
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:247: replace FunctionType::check_args_by_allowing_trait_cast_2_05 -> CheckResult<TypeSignature> with CheckResult::new()
+clarity/src/vm/functions/conversions.rs:89: replace native_buff_to_int_le::convert_to_int_le -> Value with Default::default()
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:326: replace Lexer<'a>::read_integer -> LexResult<Token> with LexResult::new(Default::default())
+clarity/src/vm/functions/database.rs:293: replace special_set_variable_v200 -> Result<Value> with Ok(Default::default())
+clarity/src/vm/ast/definition_sorter/mod.rs:379: replace DefinitionSorter::find_expression_definition -> Option<(ClarityName, u64, &'b PreSymbolicExpression)> with Some((Default::default(), 1, &Default::default()))
+clarity/src/vm/representations.rs:285: replace PreSymbolicExpression::sugared_field_identifier -> PreSymbolicExpression with Default::default()
+clarity/src/vm/contexts.rs:815: replace OwnedEnvironment<'a, 'hooks>::eval_read_only_with_rules -> Result<(Value, AssetMap, Vec<StacksTransactionEvent>)> with Ok((Default::default(), Default::default(), vec![]))
+clarity/src/vm/functions/conversions.rs:205: replace native_int_to_ascii -> Result<Value> with Ok(Default::default())
+clarity/src/vm/ast/parser/v2/mod.rs:158: replace Parser<'a>::peek_last_token -> ParseResult<&PlacedToken> with ParseResult::new(&Default::default())
+clarity/src/vm/ast/parser/v1.rs:455: replace lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::new(vec![(Default::default(), 1, 0)])
+clarity/src/vm/functions/assets.rs:368: replace special_mint_asset_v200 -> Result<Value> with Ok(Default::default())
+clarity/src/vm/contexts.rs:1882: replace LocalContext<'a>::function_context -> &LocalContext with &Default::default()
+clarity/src/vm/ast/mod.rs:87: replace ast_check_size -> ParseResult<ContractAST> with ParseResult::new(Default::default())
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:247: replace FunctionType::check_args_by_allowing_trait_cast_2_05 -> CheckResult<TypeSignature> with CheckResult::from(Default::default())
+clarity/src/vm/ast/mod.rs:174: replace inner_build_ast -> ParseResult<(ContractAST, Vec<Diagnostic>, bool)> with ParseResult::new()
+clarity/src/vm/types/signatures.rs:1356: replace TypeSignature::parent_list_type -> std::result::Result<ListTypeData, CheckErrors> with Ok(Default::default())
+clarity/src/vm/functions/sequences.rs:359: replace special_slice -> Result<Value> with Ok(Default::default())
+clarity/src/vm/functions/mod.rs:645: replace special_asserts -> Result<Value> with Ok(Default::default())
+clarity/src/vm/ast/definition_sorter/mod.rs:433: replace Graph::edges_count -> ParseResult<u64> with ParseResult::new(1)
+clarity/src/vm/types/serialization.rs:348: replace DeserializeStackItem::next_expected_type -> Result<Option<TypeSignature>, SerializationError> with Ok(Some(Default::default()))
+clarity/src/vm/analysis/type_checker/v2_05/natives/options.rs:131: replace check_special_asserts -> TypeResult with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:929: replace TypeChecker<'a, 'b>::run -> CheckResult<()> with CheckResult::from_iter([()])
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:474: replace Lexer<'a>::read_utf8_encoding -> LexResult<Result<String, String>> with LexResult::new()
+clarity/src/vm/ast/parser/v2/mod.rs:521: replace Parser<'a>::read_principal -> ParseResult<PreSymbolicExpression> with ParseResult::new(Default::default())
+clarity/src/vm/database/key_value_wrapper.rs:219: replace RollbackWrapper<'a>::from_persisted_log -> RollbackWrapper with Default::default()
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:661: replace TypeChecker<'a, 'b>::type_check_function_application -> TypeResult with Default::default()
+clarity/src/vm/ast/parser/v2/mod.rs:1062: replace Parser<'a>::parse_node_or_eof -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::new()
+clarity/src/vm/ast/expression_identifier/mod.rs:51: replace ExpressionIdentifier::run_pre_expression_pass -> ParseResult<()> with ParseResult::new(())
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:259: replace ContractContext::add_ft -> CheckResult<()> with CheckResult::from_iter([()])
+clarity/src/vm/ast/mod.rs:309: replace build_ast -> ParseResult<ContractAST> with ParseResult::from(Default::default())
+clarity/src/vm/functions/options.rs:44: replace inner_unwrap_err -> Result<Option<Value>> with Ok(Some(Default::default()))
+clarity/src/vm/ast/parser/v2/mod.rs:1062: replace Parser<'a>::parse_node_or_eof -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::from(None)
+clarity/src/vm/representations.rs:95: replace <impl StacksMessageCodec for ClarityName>::consensus_deserialize -> Result<ClarityName, codec_error> with Ok(Default::default())
+clarity/src/vm/ast/parser/v2/mod.rs:1109: replace parse_collect_diagnostics -> (Vec<PreSymbolicExpression>, Vec<Diagnostic>, bool) with (vec![], vec![Default::default()], false)
+clarity/src/vm/analysis/read_only_checker/mod.rs:227: replace ReadOnlyChecker<'a, 'b>::check_read_only -> CheckResult<bool> with CheckResult::new()
+clarity/src/vm/ast/parser/v2/mod.rs:1083: replace Parser<'a>::parse -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::new(vec![])
+clarity/src/vm/database/key_value_wrapper.rs:495: replace RollbackWrapper<'a>::get_metadata_manual -> InterpreterResult<Option<String>> with InterpreterResult::from(Some(String::new()))
+clarity/src/vm/ast/errors.rs:300: replace <impl DiagnosableError for ParseErrors>::level -> crate::vm::diagnostic::Level with Default::default()
+clarity/src/vm/ast/definition_sorter/mod.rs:369: replace DefinitionSorter::probe_for_dependencies_in_key_value_pair -> ParseResult<()> with ParseResult::new()
+clarity/src/vm/contexts.rs:600: replace OwnedEnvironment<'a, 'hooks>::new_free -> OwnedEnvironment<'a, '_> with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs:401: replace check_special_index_of -> TypeResult with Default::default()
+clarity/src/vm/ast/expression_identifier/mod.rs:51: replace ExpressionIdentifier::run_pre_expression_pass -> ParseResult<()> with ParseResult::from(())
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1136: replace TypeChecker<'a, 'b>::type_check_define_map -> CheckResult<(ClarityName, (TypeSignature, TypeSignature))> with CheckResult::from((Default::default(), (Default::default(), Default::default())))
+clarity/src/vm/functions/options.rs:148: replace special_match_opt -> Result<Value> with Ok(Default::default())
+clarity/src/vm/ast/parser/v2/mod.rs:1062: replace Parser<'a>::parse_node_or_eof -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::new(Some(Default::default()))
+clarity/src/vm/ast/mod.rs:174: replace inner_build_ast -> ParseResult<(ContractAST, Vec<Diagnostic>, bool)> with ParseResult::new((Default::default(), vec![Default::default()], true))
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:485: replace check_function_arg_signature -> CheckResult<()> with CheckResult::new(())
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:646: replace TypeChecker<'a, 'b>::try_native_function_check -> Option<TypeResult> with Some(Default::default())
+clarity/src/vm/ast/parser/v1.rs:508: replace parse_lexed -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::from(vec![])
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:626: replace TypeChecker<'a, 'b>::type_check_define_map -> CheckResult<(ClarityName, (TypeSignature, TypeSignature))> with CheckResult::from((Default::default(), (Default::default(), Default::default())))
+clarity/src/vm/database/clarity_db.rs:516: replace ClarityDatabase<'a>::get_value -> Result<Option<ValueResult>> with Ok(Some(Default::default()))
+clarity/src/vm/representations.rs:271: replace PreSymbolicExpression::span -> &Span with &Default::default()
+clarity/src/vm/analysis/analysis_db.rs:153: replace AnalysisDatabase<'a>::get_public_function_type -> CheckResult<Option<FunctionType>> with CheckResult::new(Some(Default::default()))
+clarity/src/vm/types/mod.rs:824: replace Value::okay_true -> Value with Default::default()
+clarity/src/vm/functions/arithmetic.rs:639: replace native_to_int -> InterpreterResult<Value> with InterpreterResult::new()
+clarity/src/vm/types/mod.rs:684: replace <impl SequencedValue for UTF8Data>::type_signature -> TypeSignature with Default::default()
+clarity/src/vm/analysis/trait_checker/mod.rs:39: replace <impl AnalysisPass for TraitChecker>::run_pass -> CheckResult<()> with CheckResult::new(())
+clarity/src/vm/ast/parser/v2/mod.rs:807: replace Parser<'a>::parse_node -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::from(Some(Default::default()))
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:297: replace trait_type_size -> CheckResult<u64> with CheckResult::new(1)
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:296: replace ContractContext::add_implemented_trait -> CheckResult<()> with CheckResult::from_iter([()])
+clarity/src/vm/analysis/read_only_checker/mod.rs:268: replace ReadOnlyChecker<'a, 'b>::try_check_native_function_is_read_only -> Option<CheckResult<bool>> with Some(CheckResult::from(true))
+clarity/src/vm/types/mod.rs:838: replace Value::err_none -> Value with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs:39: replace get_simple_native_or_user_define -> CheckResult<FunctionType> with CheckResult::new(Default::default())
+clarity/src/vm/functions/define.rs:172: replace handle_define_persisted_variable -> Result<DefineResult> with Ok(Default::default())
+clarity/src/vm/functions/options.rs:87: replace native_try_ret -> Result<Value> with Ok(Default::default())
+clarity/src/vm/ast/mod.rs:288: replace build_ast_precheck_size -> ParseResult<ContractAST> with ParseResult::new()
+clarity/src/vm/types/signatures.rs:857: replace TupleTypeSignature::field_type -> Option<&TypeSignature> with Some(&Default::default())
+clarity/src/vm/ast/stack_depth_checker.rs:53: replace check_vary -> ParseResult<()> with ParseResult::from_iter([()])
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:358: replace TypeChecker<'a, 'b>::track_return_type -> CheckResult<()> with CheckResult::from_iter([()])
+clarity/src/vm/functions/database.rs:442: replace special_at_block -> Result<Value> with Ok(Default::default())
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:128: replace Lexer<'a>::skip_whitespace -> LexResult<()> with LexResult::new()
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1414: replace TypeChecker<'a, 'b>::try_type_check_define -> CheckResult<Option<()>> with CheckResult::from(Some(()))
+clarity/src/vm/functions/arithmetic.rs:560: replace native_mul -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
+clarity/src/vm/database/clarity_db.rs:1236: replace ClarityDatabase<'a>::lookup_variable_with_size -> Result<ValueResult> with Ok(Default::default())
+clarity/src/vm/docs/contracts.rs:178: replace produce_docs_refs -> BTreeMap<String, ContractRef> with BTreeMap::from_iter([(String::new(), Default::default())])
+clarity/src/vm/types/signatures.rs:1339: replace TypeSignature::literal_type_of -> TypeSignature with Default::default()
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:575: replace Lexer<'a>::read_utf8_string -> LexResult<Token> with LexResult::new()
+clarity/src/vm/analysis/analysis_db.rs:208: replace AnalysisDatabase<'a>::get_implemented_traits -> CheckResult<BTreeSet<TraitIdentifier>> with CheckResult::from(BTreeSet::from_iter([Default::default()]))
+clarity/src/vm/types/signatures.rs:825: replace <impl TryFrom for TupleTypeSignature>::try_from -> Result<TupleTypeSignature> with Ok(Default::default())
+clarity/src/vm/database/key_value_wrapper.rs:354: replace RollbackWrapper<'a>::get_with_proof -> Option<(T, Vec<u8>)> with Some((Default::default(), vec![1]))
+clarity/src/vm/analysis/type_checker/v2_1/natives/maps.rs:160: replace check_special_insert_entry -> TypeResult with Default::default()
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:136: replace ContractContext::add_variable_type -> CheckResult<()> with CheckResult::new(())
+clarity/src/vm/database/key_value_wrapper.rs:363: replace RollbackWrapper<'a>::get -> Option<T> with Some(Default::default())
+clarity/src/vm/analysis/contract_interface_builder/mod.rs:181: replace ContractInterfaceAtomType::from_type_signature -> ContractInterfaceAtomType with Default::default()
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:96: replace ContractContext::add_public_function_type -> CheckResult<()> with CheckResult::new(())
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:66: replace Lexer<'a>::add_diagnostic -> LexResult<()> with LexResult::from(())
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:185: replace Lexer<'a>::proceed_through_error_string -> LexResult<String> with LexResult::new("xyzzy".into())
+clarity/src/vm/ast/sugar_expander/mod.rs:66: replace SugarExpander::transform -> ParseResult<Vec<SymbolicExpression>> with ParseResult::from_iter([vec![]])
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:312: replace ContractContext::get_variable_type -> Option<&TypeSignature> with Some(&Default::default())
+clarity/src/vm/analysis/read_only_checker/mod.rs:88: replace ReadOnlyChecker<'a, 'b>::run -> CheckResult<()> with CheckResult::from_iter([()])
+clarity/src/vm/analysis/analysis_db.rs:153: replace AnalysisDatabase<'a>::get_public_function_type -> CheckResult<Option<FunctionType>> with CheckResult::from(Some(Default::default()))
+clarity/src/vm/database/clarity_db.rs:707: replace ClarityDatabase<'a>::get_contract -> Result<Contract> with Ok(Default::default())
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:111: replace Lexer<'a>::report_line_ending -> LexResult<()> with LexResult::from(())
+clarity/src/vm/analysis/mod.rs:50: replace mem_type_check -> CheckResult<(Option<TypeSignature>, ContractAnalysis)> with CheckResult::from_iter([(None, Default::default())])
+clarity/src/vm/types/mod.rs:1394: replace <impl From for StandardPrincipalData>::from -> StandardPrincipalData with Default::default()
+clarity/src/vm/functions/options.rs:28: replace inner_unwrap -> Result<Option<Value>> with Ok(Some(Default::default()))
+clarity/src/vm/types/signatures.rs:992: replace TypeSignature::max_buffer -> TypeSignature with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:485: replace check_function_arg_signature -> CheckResult<()> with CheckResult::from(())
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:86: replace TraitContext::add_used_trait -> CheckResult<()> with CheckResult::new(())
+clarity/src/vm/ast/parser/v2/mod.rs:463: replace Parser<'a>::open_tuple -> ParseResult<SetupTupleResult> with ParseResult::new()
+clarity/src/vm/types/signatures.rs:733: replace TypeSignature::canonicalize_v2_1 -> TypeSignature with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:485: replace check_function_arg_signature -> CheckResult<()> with CheckResult::from_iter([()])
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:792: replace TypeChecker<'a, 'b>::type_check_define_trait -> CheckResult<(ClarityName, BTreeMap<ClarityName, FunctionSignature>)> with CheckResult::new()
+clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs:339: replace check_special_if -> TypeResult with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/natives/options.rs:168: replace inner_unwrap_err -> TypeResult with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:213: replace ContractContext::add_read_only_function_type -> CheckResult<()> with CheckResult::from(())
+clarity/src/vm/database/clarity_db.rs:1202: replace ClarityDatabase<'a>::lookup_variable_unknown_descriptor -> Result<Value> with Ok(Default::default())
+clarity/src/vm/ast/parser/v2/mod.rs:158: replace Parser<'a>::peek_last_token -> ParseResult<&PlacedToken> with ParseResult::new()
+clarity/src/vm/contexts.rs:1841: replace ContractContext::get_clarity_version -> &ClarityVersion with &Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs:91: replace check_special_as_contract -> TypeResult with Default::default()
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:146: replace ContractContext::add_persisted_variable_type -> CheckResult<()> with CheckResult::new(())
+clarity/src/vm/ast/mod.rs:130: replace build_ast_typical -> ParseResult<ContractAST> with ParseResult::from_iter([Default::default()])
+clarity/src/vm/functions/assets.rs:912: replace special_burn_token -> Result<Value> with Ok(Default::default())
+clarity/src/vm/database/clarity_db.rs:1427: replace ClarityDatabase<'a>::set_entry_unknown_descriptor -> Result<Value> with Ok(Default::default())
+clarity/src/vm/types/mod.rs:278: replace SequenceData::element_at -> Option<Value> with Some(Default::default())
+clarity/src/vm/functions/mod.rs:212: replace lookup_reserved_functions -> Option<CallableType> with Some(Default::default())
+clarity/src/vm/analysis/errors.rs:274: replace <impl From for CheckError>::from -> Self with Default::default()
+clarity/src/vm/functions/arithmetic.rs:476: replace special_greater_v1 -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:106: replace ContractContext::add_read_only_function_type -> CheckResult<()> with CheckResult::new()
+clarity/src/vm/ast/parser/v1.rs:720: replace parse -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::new(vec![])
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:296: replace ContractContext::add_implemented_trait -> CheckResult<()> with CheckResult::from(())
+clarity/src/vm/functions/arithmetic.rs:434: replace special_leq_v1 -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
+clarity/src/vm/ast/definition_sorter/mod.rs:115: replace DefinitionSorter::probe_for_dependencies -> ParseResult<()> with ParseResult::from_iter([()])
+clarity/src/vm/functions/sequences.rs:319: replace native_index_of -> Result<Value> with Ok(Default::default())
+clarity/src/vm/functions/arithmetic.rs:572: replace native_log2 -> InterpreterResult<Value> with InterpreterResult::new()
+clarity/src/vm/ast/definition_sorter/mod.rs:324: replace DefinitionSorter::probe_for_dependencies_in_define_args -> ParseResult<()> with ParseResult::new()
+clarity/src/vm/representations.rs:197: replace <impl SymbolicExpressionCommon for PreSymbolicExpression>::match_list_mut -> Option<&mut[PreSymbolicExpression]> with Some(Vec::leak(vec![Default::default()]))
+clarity/src/vm/types/signatures.rs:480: replace ListTypeData::get_list_item_type -> &TypeSignature with &Default::default()
+clarity/src/vm/ast/definition_sorter/mod.rs:357: replace DefinitionSorter::probe_for_dependencies_in_wrapped_key_value_pairs -> ParseResult<()> with ParseResult::from_iter([()])
+clarity/src/vm/types/mod.rs:754: replace BlockInfoProperty::lookup_by_name_at_version -> Option<BlockInfoProperty> with Some(Default::default())
+clarity/src/vm/representations.rs:313: replace PreSymbolicExpression::field_identifier -> PreSymbolicExpression with Default::default()
+clarity/src/vm/functions/principals.rs:118: replace create_principal_true_error_response -> Value with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:839: replace contract_analysis_size -> CheckResult<u64> with CheckResult::from_iter([0])
+clarity/src/vm/ast/mod.rs:174: replace inner_build_ast -> ParseResult<(ContractAST, Vec<Diagnostic>, bool)> with ParseResult::new((Default::default(), vec![], false))
+clarity/src/vm/types/mod.rs:1308: replace PrincipalData::parse -> Result<PrincipalData> with Ok(Default::default())
+clarity/src/vm/types/serialization.rs:209: replace <impl ClarityValueSerializable for StandardPrincipalData>::deserialize_read -> Result<Self, SerializationError> with Ok(Default::default())
+clarity/src/vm/analysis/read_only_checker/mod.rs:281: replace ReadOnlyChecker<'a, 'b>::check_native_function_is_read_only -> CheckResult<bool> with CheckResult::from(true)
+clarity/src/vm/test_util/mod.rs:39: replace generate_test_burn_state_db -> UnitTestBurnStateDB with Default::default()
+clarity/src/vm/ast/parser/v1.rs:455: replace lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::new()
+clarity/src/vm/costs/mod.rs:1176: replace ExecutionCost::max_value -> ExecutionCost with Default::default()
+clarity/src/vm/contexts.rs:752: replace OwnedEnvironment<'a, 'hooks>::execute_transaction -> Result<(Value, AssetMap, Vec<StacksTransactionEvent>)> with Ok((Default::default(), Default::default(), vec![]))
+clarity/src/vm/database/clarity_db.rs:395: replace <impl BurnStateDB for NullBurnStateDB>::get_pox_payout_addrs -> Option<(Vec<TupleData>, u128)> with Some((vec![Default::default()], 0))
+clarity/src/vm/ast/parser/v1.rs:455: replace lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::from(vec![(Default::default(), 0, 0)])
+clarity/src/vm/contexts.rs:1078: replace Environment<'a, 'b, 'hooks>::run_free -> A with Default::default()
+clarity/src/vm/costs/mod.rs:699: replace LimitedCostTracker::new_max_limit -> Result<LimitedCostTracker> with Ok(Default::default())
+clarity/src/vm/ast/parser/v1.rs:455: replace lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::from_iter([vec![(Default::default(), 0, 1)]])
+clarity/src/vm/ast/errors.rs:153: replace <impl From for ParseError>::from -> Self with Default::default()
+clarity/src/vm/database/structures.rs:328: replace STXBalanceSnapshot<'db, 'conn>::balance -> &STXBalance with &Default::default()
+clarity/src/vm/ast/parser/v2/mod.rs:158: replace Parser<'a>::peek_last_token -> ParseResult<&PlacedToken> with ParseResult::from_iter([&Default::default()])
+clarity/src/vm/ast/parser/v1.rs:455: replace lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::new(vec![(Default::default(), 0, 0)])
+clarity/src/vm/database/clarity_db.rs:271: replace <impl HeadersDB for NullHeadersDB>::get_burn_header_hash_for_block -> Option<BurnchainHeaderHash> with Some(Default::default())
+clarity/src/vm/database/clarity_db.rs:252: replace <impl BurnStateDB for &dyn BurnStateDB>::get_pox_payout_addrs -> Option<(Vec<TupleData>, u128)> with Some((vec![Default::default()], 0))
+clarity/src/vm/functions/arithmetic.rs:629: replace native_to_uint -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
+clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs:84: replace check_special_as_contract -> TypeResult with Default::default()
+clarity/src/vm/functions/assets.rs:128: replace stx_transfer_consolidated -> Result<Value> with Ok(Default::default())
+clarity/src/vm/analysis/contract_interface_builder/mod.rs:307: replace ContractInterfaceFungibleTokens::from_set -> Vec<Self> with vec![Default::default()]
+clarity/src/vm/database/clarity_db.rs:1468: replace ClarityDatabase<'a>::insert_entry -> Result<ValueResult> with Ok(Default::default())
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:185: replace Lexer<'a>::proceed_through_error_string -> LexResult<String> with LexResult::from_iter([String::new()])
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1136: replace TypeChecker<'a, 'b>::type_check_define_map -> CheckResult<(ClarityName, (TypeSignature, TypeSignature))> with CheckResult::from_iter([(Default::default(), (Default::default(), Default::default()))])
+clarity/src/vm/ast/parser/v2/mod.rs:131: replace Parser<'a>::next_token -> Option<PlacedToken> with Some(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:279: replace ContractContext::add_defined_trait -> CheckResult<()> with CheckResult::from_iter([()])
+clarity/src/vm/functions/arithmetic.rs:364: replace native_xor -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
+clarity/src/vm/contexts.rs:960: replace Environment<'a, 'b, 'hooks>::nest_as_principal -> Environment<'c, 'b, 'hooks> with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/natives/options.rs:145: replace inner_unwrap -> TypeResult with Default::default()
+clarity/src/vm/database/clarity_db.rs:314: replace <impl HeadersDB for NullHeadersDB>::get_miner_address -> Option<StacksAddress> with Some(Default::default())
+clarity/src/vm/types/serialization.rs:1114: replace Value::try_deserialize_bytes_exact -> Result<Value, SerializationError> with Ok(Default::default())
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:96: replace ContractContext::add_public_function_type -> CheckResult<()> with CheckResult::new()
+clarity/src/vm/ast/traits_resolver/mod.rs:201: replace TraitsResolver::probe_for_generics -> ParseResult<()> with ParseResult::from_iter([()])
+clarity/src/vm/functions/define.rs:270: replace handle_impl_trait -> Result<DefineResult> with Ok(Default::default())
+clarity/src/vm/functions/arithmetic.rs:566: replace native_pow -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
+clarity/src/vm/mod.rs:205: replace lookup_function -> Result<CallableType> with Ok(Default::default())
+clarity/src/vm/functions/arithmetic.rs:364: replace native_xor -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
+clarity/src/vm/types/serialization.rs:574: replace Value::inner_deserialize_read -> Result<Value, SerializationError> with Ok(Default::default())
+clarity/src/vm/analysis/read_only_checker/mod.rs:244: replace ReadOnlyChecker<'a, 'b>::check_each_expression_is_read_only -> CheckResult<bool> with CheckResult::from(true)
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:292: replace ContractContext::add_used_trait -> CheckResult<()> with CheckResult::from(())
+clarity/src/vm/functions/options.rs:80: replace native_unwrap_err_or_ret -> Result<Value> with Ok(Default::default())
+clarity/src/vm/types/signatures.rs:1551: replace TypeSignature::parse_trait_type_repr -> Result<BTreeMap<ClarityName, FunctionSignature>> with Ok(BTreeMap::from_iter([(Default::default(), Default::default())]))
+clarity/src/vm/functions/arithmetic.rs:434: replace special_leq_v1 -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:740: replace TypeChecker<'a, 'b>::type_check_define_variable -> CheckResult<(ClarityName, TypeSignature)> with CheckResult::from((Default::default(), Default::default()))
+clarity/src/vm/representations.rs:527: replace SymbolicExpression::atom -> SymbolicExpression with Default::default()
+clarity/src/vm/analysis/contract_interface_builder/mod.rs:164: replace ContractInterfaceAtomType::from_tuple_type -> ContractInterfaceAtomType with Default::default()
+clarity/src/vm/functions/database.rs:723: replace special_get_block_info -> Result<Value> with Ok(Default::default())
+clarity/src/vm/analysis/read_only_checker/mod.rs:227: replace ReadOnlyChecker<'a, 'b>::check_read_only -> CheckResult<bool> with CheckResult::from_iter([true])
+clarity/src/vm/ast/definition_sorter/mod.rs:369: replace DefinitionSorter::probe_for_dependencies_in_key_value_pair -> ParseResult<()> with ParseResult::from(())
+clarity/src/vm/types/serialization.rs:1085: replace Value::try_deserialize_bytes -> Result<Value, SerializationError> with Ok(Default::default())
+clarity/src/vm/database/clarity_db.rs:175: replace <impl HeadersDB for &dyn HeadersDB>::get_miner_address -> Option<StacksAddress> with Some(Default::default())
+clarity/src/vm/ast/parser/v1.rs:462: replace unescape_ascii_chars -> ParseResult<String> with ParseResult::from_iter([String::new()])
+clarity/src/vm/functions/assets.rs:219: replace special_stx_account -> Result<Value> with Ok(Default::default())
+clarity/src/vm/analysis/read_only_checker/mod.rs:430: replace ReadOnlyChecker<'a, 'b>::check_expression_application_is_read_only -> CheckResult<bool> with CheckResult::from_iter([true])
+clarity/src/vm/types/mod.rs:623: replace <impl SequencedValue for ListData>::type_signature -> TypeSignature with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:831: replace trait_type_size -> CheckResult<u64> with CheckResult::from(1)
+clarity/src/vm/analysis/type_checker/contexts.rs:82: replace TypingContext<'a>::extend -> CheckResult<TypingContext> with CheckResult::new(Default::default())
+clarity/src/vm/database/clarity_db.rs:1555: replace ClarityDatabase<'a>::delete_entry -> Result<ValueResult> with Ok(Default::default())
+clarity/src/vm/ast/sugar_expander/mod.rs:56: replace SugarExpander::run -> ParseResult<()> with ParseResult::new(())
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:388: replace TypeChecker<'a, 'b>::run -> CheckResult<()> with CheckResult::from(())
+clarity/src/vm/ast/expression_identifier/mod.rs:58: replace ExpressionIdentifier::run_expression_pass -> ParseResult<()> with ParseResult::new(())
+clarity/src/vm/analysis/type_checker/v2_05/natives/options.rs:184: replace check_special_unwrap_or_ret -> TypeResult with Default::default()
+clarity/src/vm/ast/parser/v2/mod.rs:687: replace Parser<'a>::read_sugared_principal -> ParseResult<PreSymbolicExpression> with ParseResult::new(Default::default())
+clarity/src/vm/functions/arithmetic.rs:419: replace special_geq -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:792: replace TypeChecker<'a, 'b>::type_check_define_trait -> CheckResult<(ClarityName, BTreeMap<ClarityName, FunctionSignature>)> with CheckResult::from((Default::default(), BTreeMap::from_iter([(Default::default(), Default::default())])))
+clarity/src/vm/analysis/type_checker/v2_05/natives/sequences.rs:39: replace get_simple_native_or_user_define -> CheckResult<FunctionType> with CheckResult::new()
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:253: replace ContractContext::add_persisted_variable_type -> CheckResult<()> with CheckResult::from_iter([()])
+clarity/src/vm/database/clarity_db.rs:421: replace ClarityDatabase<'a>::new_with_rollback_wrapper -> ClarityDatabase<'a> with Default::default()
+clarity/src/vm/functions/arithmetic.rs:575: replace native_mod -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
+clarity/src/vm/analysis/type_checker/v2_05/natives/maps.rs:161: replace check_special_insert_entry -> TypeResult with Default::default()
+clarity/src/vm/types/mod.rs:1117: replace Value::expect_principal -> PrincipalData with Default::default()
+clarity/src/vm/ast/parser/v2/mod.rs:1083: replace Parser<'a>::parse -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::from(vec![Default::default()])
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:203: replace ContractContext::add_public_function_type -> CheckResult<()> with CheckResult::from(())
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1004: replace TypeChecker<'a, 'b>::type_check_consecutive_statements -> TypeResult with Default::default()
+clarity/src/vm/functions/arithmetic.rs:59: replace UTF8Ops::make_value -> InterpreterResult<Value> with InterpreterResult::new()
+clarity/src/vm/analysis/read_only_checker/mod.rs:244: replace ReadOnlyChecker<'a, 'b>::check_each_expression_is_read_only -> CheckResult<bool> with CheckResult::new(true)
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:96: replace ContractContext::add_public_function_type -> CheckResult<()> with CheckResult::from_iter([()])
+clarity/src/vm/functions/arithmetic.rs:462: replace special_leq -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:140: replace Lexer<'a>::read_line -> LexResult<String> with LexResult::new(String::new())
+clarity/src/vm/functions/arithmetic.rs:476: replace special_greater_v1 -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
+clarity/src/vm/callables.rs:359: replace DefinedFunction::get_arg_types -> &Vec<TypeSignature> with &vec![]
+clarity/src/vm/database/key_value_wrapper.rs:495: replace RollbackWrapper<'a>::get_metadata_manual -> InterpreterResult<Option<String>> with InterpreterResult::from_iter([Some(String::new())])
+clarity/src/vm/ast/parser/v2/mod.rs:219: replace Parser<'a>::handle_open_node -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::from(None)
+clarity/src/vm/database/clarity_db.rs:221: replace <impl BurnStateDB for &dyn BurnStateDB>::get_burn_header_hash -> Option<BurnchainHeaderHash> with Some(Default::default())
+clarity/src/vm/ast/parser/v1.rs:101: replace get_value_or_err -> ParseResult<String> with ParseResult::new(String::new())
+clarity/src/vm/ast/parser/v2/mod.rs:140: replace Parser<'a>::peek_next_token -> PlacedToken with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/natives/assets.rs:223: replace check_special_stx_transfer_memo -> TypeResult with Default::default()
+clarity/src/vm/functions/define.rs:277: replace DefineFunctions::try_parse -> Option<(DefineFunctions, &[SymbolicExpression])> with Some((Default::default(), Vec::leak(Vec::new())))
+clarity/src/vm/analysis/read_only_checker/mod.rs:182: replace ReadOnlyChecker<'a, 'b>::check_reads_only_valid -> CheckResult<()> with CheckResult::new(())
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:146: replace ContractContext::add_persisted_variable_type -> CheckResult<()> with CheckResult::from(())
+clarity/src/vm/functions/boolean.rs:38: replace special_or -> Result<Value> with Ok(Default::default())
+clarity/src/vm/functions/define.rs:247: replace handle_define_trait -> Result<DefineResult> with Ok(Default::default())
+clarity/src/vm/ast/parser/v1.rs:192: replace inner_lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::from_iter([vec![(Default::default(), 1, 0)]])
+clarity/src/vm/database/clarity_db.rs:399: replace <impl BurnStateDB for NullBurnStateDB>::get_ast_rules -> ASTRules with Default::default()
+clarity/src/vm/analysis/read_only_checker/mod.rs:59: replace <impl AnalysisPass for ReadOnlyChecker<'a, 'b>>::run_pass -> CheckResult<()> with CheckResult::new()
+clarity/src/vm/costs/mod.rs:971: replace <impl CostTracker for LimitedCostTracker>::compute_cost -> std::result::Result<ExecutionCost, CostErrors> with Ok(Default::default())
+clarity/src/vm/ast/parser/v2/mod.rs:283: replace Parser<'a>::handle_open_tuple -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::new(None)
+clarity/src/vm/contexts.rs:1396: replace Environment<'a, 'b, 'hooks>::run_as_transaction -> std::result::Result<O, E> with Ok(Default::default())
+clarity/src/vm/ast/parser/v1.rs:462: replace unescape_ascii_chars -> ParseResult<String> with ParseResult::from("xyzzy".into())
+clarity/src/vm/analysis/read_only_checker/mod.rs:244: replace ReadOnlyChecker<'a, 'b>::check_each_expression_is_read_only -> CheckResult<bool> with CheckResult::from_iter([true])
+clarity/src/vm/types/mod.rs:490: replace SequenceData::slice -> Result<Value> with Ok(Default::default())
+clarity/src/vm/representations.rs:306: replace PreSymbolicExpression::trait_reference -> PreSymbolicExpression with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/natives/options.rs:63: replace check_special_error -> TypeResult with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1055: replace TypeChecker<'a, 'b>::type_check_define_function -> CheckResult<(ClarityName, FixedFunction)> with CheckResult::from_iter([(Default::default(), Default::default())])
+clarity/src/vm/types/signatures.rs:273: replace FunctionType::canonicalize -> FunctionType with Default::default()
+clarity/src/vm/ast/stack_depth_checker.rs:74: replace <impl BuildASTPass for VaryStackDepthChecker>::run_pass -> ParseResult<()> with ParseResult::from_iter([()])
+clarity/src/vm/ast/stack_depth_checker.rs:28: replace check -> ParseResult<()> with ParseResult::new()
+clarity/src/vm/functions/arithmetic.rs:67: replace BuffOps::make_value -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
+clarity/src/vm/database/clarity_db.rs:954: replace ClarityDatabase<'a>::get_miner_address -> StandardPrincipalData with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:279: replace ContractContext::add_defined_trait -> CheckResult<()> with CheckResult::from(())
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:358: replace TypeChecker<'a, 'b>::track_return_type -> CheckResult<()> with CheckResult::from(())
+clarity/src/vm/functions/options.rs:59: replace native_unwrap -> Result<Value> with Ok(Default::default())
+clarity/src/vm/tests/principals.rs:846: replace create_principal_from_strings -> Value with Default::default()
+clarity/src/vm/analysis/read_only_checker/mod.rs:244: replace ReadOnlyChecker<'a, 'b>::check_each_expression_is_read_only -> CheckResult<bool> with CheckResult::new(false)
+clarity/src/vm/functions/arithmetic.rs:462: replace special_leq -> InterpreterResult<Value> with InterpreterResult::new()
+clarity/src/vm/database/clarity_store.rs:281: replace MemoryBackingStore::as_clarity_db -> ClarityDatabase with Default::default()
+clarity/src/vm/ast/parser/v1.rs:728: replace parse_no_stack_limit -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::from(vec![])
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:297: replace trait_type_size -> CheckResult<u64> with CheckResult::new(0)
+clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs:320: replace check_special_equals -> TypeResult with Default::default()
+clarity/src/vm/tests/contracts.rs:87: replace get_principal -> Value with Default::default()
+clarity/src/vm/functions/arithmetic.rs:566: replace native_pow -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:279: replace ContractContext::add_defined_trait -> CheckResult<()> with CheckResult::new(())
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1023: replace TypeChecker<'a, 'b>::type_check_all -> CheckResult<Vec<TypeSignature>> with CheckResult::from(vec![Default::default()])
+clarity/src/vm/analysis/type_checker/v2_1/natives/conversions.rs:18: replace check_special_to_consensus_buff -> TypeResult with Default::default()
+clarity/src/vm/types/mod.rs:676: replace <impl SequencedValue for UTF8Data>::items -> &Vec<Vec<u8>> with &vec![vec![]]
+clarity/src/vm/database/clarity_db.rs:1085: replace ClarityDatabase<'a>::get_microblock_poison_report -> Option<(StandardPrincipalData, u16)> with Some((Default::default(), 0))
+clarity/src/vm/functions/conversions.rs:105: replace native_buff_to_int_be -> Result<Value> with Ok(Default::default())
+clarity/src/vm/ast/definition_sorter/mod.rs:456: replace GraphWalker::get_sorted_dependencies -> ParseResult<Vec<usize>> with ParseResult::from(vec![0])
+clarity/src/vm/costs/mod.rs:1126: replace ExecutionCost::zero -> ExecutionCost with Default::default()
+clarity/src/vm/types/signatures.rs:365: replace <impl TryFrom for BufferLength>::try_from -> Result<BufferLength> with Ok(Default::default())
+clarity/src/vm/database/structures.rs:870: replace STXBalance::canonical_repr_at_block -> (STXBalance, u128) with (Default::default(), 1)
+clarity/src/vm/ast/parser/v2/mod.rs:283: replace Parser<'a>::handle_open_tuple -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::from_iter([None])
+clarity/src/vm/types/mod.rs:647: replace <impl SequencedValue for BuffData>::to_value -> Value with Default::default()
+clarity/src/vm/functions/options.rs:254: replace native_error -> Result<Value> with Ok(Default::default())
+clarity/src/vm/ast/parser/v1.rs:101: replace get_value_or_err -> ParseResult<String> with ParseResult::from(String::new())
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:839: replace contract_analysis_size -> CheckResult<u64> with CheckResult::new(1)
+clarity/src/vm/types/serialization.rs:1198: replace Value::sanitize_value -> Option<(Value, bool)> with Some((Default::default(), false))
+clarity/src/vm/types/signatures.rs:1019: replace TypeSignature::factor_out_no_type -> Result<TypeSignature> with Ok(Default::default())
+clarity/src/vm/costs/mod.rs:1238: replace ExecutionCost::max_cost -> ExecutionCost with Default::default()
+clarity/src/vm/functions/arithmetic.rs:373: replace native_bitwise_and -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
+clarity/src/vm/types/mod.rs:669: replace <impl SequencedValue for ASCIIData>::to_value -> Value with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs:62: replace check_special_map -> TypeResult with Default::default()
+clarity/src/vm/callables.rs:389: replace FunctionIdentifier::new_native_function -> FunctionIdentifier with Default::default()
+clarity/src/vm/tests/assets.rs:133: replace execute_transaction -> Result<(Value, AssetMap, Vec<StacksTransactionEvent>), Error> with Ok((Default::default(), Default::default(), vec![]))
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:96: replace ContractContext::add_public_function_type -> CheckResult<()> with CheckResult::from(())
+clarity/src/vm/ast/types.rs:102: replace <impl Iterator for PreExpressionsDrain>::next -> Option<PreSymbolicExpression> with Some(Default::default())
+clarity/src/vm/mod.rs:569: replace execute_v2 -> Result<Option<Value>> with Ok(Some(Default::default()))
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:688: replace TypeChecker<'a, 'b>::lookup_variable -> TypeResult with Default::default()
+clarity/src/vm/ast/parser/v1.rs:192: replace inner_lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::from_iter([vec![(Default::default(), 1, 1)]])
+clarity/src/vm/analysis/analysis_db.rs:208: replace AnalysisDatabase<'a>::get_implemented_traits -> CheckResult<BTreeSet<TraitIdentifier>> with CheckResult::from_iter([BTreeSet::new()])
+clarity/src/vm/types/mod.rs:633: replace <impl SequencedValue for BuffData>::items -> &Vec<u8> with &vec![]
+clarity/src/vm/analysis/analysis_db.rs:123: replace AnalysisDatabase<'a>::insert_contract -> CheckResult<()> with CheckResult::from(())
+clarity/src/vm/contexts.rs:1105: replace Environment<'a, 'b, 'hooks>::execute_contract -> Result<Value> with Ok(Default::default())
+clarity/src/vm/functions/sequences.rs:312: replace native_len -> Result<Value> with Ok(Default::default())
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:61: replace ContractContext::check_name_used -> CheckResult<()> with CheckResult::new()
+clarity/src/vm/ast/parser/v2/mod.rs:463: replace Parser<'a>::open_tuple -> ParseResult<SetupTupleResult> with ParseResult::from_iter([Default::default()])
+clarity/src/vm/functions/database.rs:407: replace special_fetch_entry_v205 -> Result<Value> with Ok(Default::default())
+clarity/src/vm/functions/arithmetic.rs:566: replace native_pow -> InterpreterResult<Value> with InterpreterResult::new()
+clarity/src/vm/functions/assets.rs:854: replace special_get_owner_v205 -> Result<Value> with Ok(Default::default())
+clarity/src/vm/ast/mod.rs:174: replace inner_build_ast -> ParseResult<(ContractAST, Vec<Diagnostic>, bool)> with ParseResult::from((Default::default(), vec![Default::default()], false))
+clarity/src/vm/database/clarity_db.rs:1173: replace ClarityDatabase<'a>::set_variable -> Result<ValueResult> with Ok(Default::default())
+clarity/src/vm/ast/mod.rs:174: replace inner_build_ast -> ParseResult<(ContractAST, Vec<Diagnostic>, bool)> with ParseResult::new((Default::default(), vec![Default::default()], false))
+clarity/src/vm/ast/traits_resolver/mod.rs:48: replace TraitsResolver::run -> ParseResult<()> with ParseResult::from(())
+clarity/src/vm/functions/mod.rs:758: replace special_as_contract -> Result<Value> with Ok(Default::default())
+clarity/src/vm/types/mod.rs:1439: replace <impl From for PrincipalData>::from -> Self with Default::default()
+clarity/src/vm/functions/mod.rs:692: replace parse_eval_bindings -> Result<Vec<(ClarityName, Value)>> with Ok(vec![(Default::default(), Default::default())])
+clarity/src/vm/types/signatures.rs:415: replace <impl TryFrom for StringUTF8Length>::try_from -> Result<StringUTF8Length> with Ok(Default::default())
+clarity/src/vm/types/signatures.rs:429: replace <impl TryFrom for StringUTF8Length>::try_from -> Result<StringUTF8Length> with Ok(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs:39: replace get_simple_native_or_user_define -> CheckResult<FunctionType> with CheckResult::from(Default::default())
+clarity/src/vm/test_util/mod.rs:206: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_burn_header_hash -> Option<BurnchainHeaderHash> with Some(Default::default())
+clarity/src/vm/mod.rs:481: replace execute_on_network -> Result<Option<Value>> with Ok(Some(Default::default()))
+clarity/src/vm/functions/arithmetic.rs:369: replace native_bitwise_xor -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
+clarity/src/vm/ast/definition_sorter/mod.rs:433: replace Graph::edges_count -> ParseResult<u64> with ParseResult::from(0)
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1346: replace TypeChecker<'a, 'b>::type_check_define_variable -> CheckResult<(ClarityName, TypeSignature)> with CheckResult::new()
+clarity/src/vm/functions/mod.rs:705: replace special_let -> Result<Value> with Ok(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1023: replace TypeChecker<'a, 'b>::type_check_all -> CheckResult<Vec<TypeSignature>> with CheckResult::from(vec![])
+clarity/src/vm/database/clarity_db.rs:1912: replace ClarityDatabase<'a>::get_stx_balance_snapshot_genesis -> STXBalanceSnapshot<'a, 'conn> with Default::default()
+clarity/src/vm/ast/mod.rs:288: replace build_ast_precheck_size -> ParseResult<ContractAST> with ParseResult::from(Default::default())
+clarity/src/vm/analysis/type_checker/mod.rs:64: replace FunctionType::check_args_by_allowing_trait_cast -> CheckResult<TypeSignature> with CheckResult::new(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:969: replace TypeChecker<'a, 'b>::type_check_expects -> TypeResult with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1055: replace TypeChecker<'a, 'b>::type_check_define_function -> CheckResult<(ClarityName, FixedFunction)> with CheckResult::new((Default::default(), Default::default()))
+clarity/src/vm/ast/stack_depth_checker.rs:48: replace <impl BuildASTPass for StackDepthChecker>::run_pass -> ParseResult<()> with ParseResult::new(())
+clarity/src/vm/analysis/read_only_checker/mod.rs:170: replace ReadOnlyChecker<'a, 'b>::check_define_function -> CheckResult<(ClarityName, bool)> with CheckResult::from((Default::default(), false))
+clarity/src/vm/ast/definition_sorter/mod.rs:307: replace DefinitionSorter::probe_for_dependencies_in_tuple -> ParseResult<()> with ParseResult::new(())
+clarity/src/vm/types/mod.rs:726: replace ResponseData::type_signature -> TypeSignature with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/natives/maps.rs:152: replace check_special_set_entry -> TypeResult with Default::default()
+clarity/src/vm/functions/arithmetic.rs:52: replace ASCIIOps::make_value -> InterpreterResult<Value> with InterpreterResult::new()
+clarity/src/vm/analysis/type_checker/v2_05/natives/options.rs:340: replace check_special_match_resp -> TypeResult with Default::default()
+clarity/src/vm/database/clarity_db.rs:1893: replace ClarityDatabase<'a>::get_stx_balance_snapshot -> STXBalanceSnapshot<'a, 'conn> with Default::default()
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:751: replace TypeChecker<'a, 'b>::type_check_define_persisted_variable -> CheckResult<(ClarityName, TypeSignature)> with CheckResult::new()
+clarity/src/vm/contexts.rs:764: replace OwnedEnvironment<'a, 'hooks>::stx_transfer -> Result<(Value, AssetMap, Vec<StacksTransactionEvent>)> with Ok((Default::default(), Default::default(), vec![Default::default()]))
+clarity/src/vm/representations.rs:364: replace PreSymbolicExpression::match_atom -> Option<&ClarityName> with Some(&Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs:344: replace check_special_if -> TypeResult with Default::default()
+clarity/src/vm/functions/arithmetic.rs:560: replace native_mul -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
+clarity/src/vm/functions/arithmetic.rs:490: replace special_greater_v2 -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
+clarity/src/vm/ast/sugar_expander/mod.rs:66: replace SugarExpander::transform -> ParseResult<Vec<SymbolicExpression>> with ParseResult::from(vec![Default::default()])
+clarity/src/vm/analysis/type_checker/v2_1/natives/assets.rs:268: replace check_special_burn_asset -> TypeResult with Default::default()
+clarity/src/vm/database/clarity_store.rs:291: replace <impl ClarityBackingStore for MemoryBackingStore>::set_block_hash -> InterpreterResult<StacksBlockId> with InterpreterResult::from(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/natives/options.rs:187: replace check_special_unwrap_or_ret -> TypeResult with Default::default()
+clarity/src/vm/ast/mod.rs:174: replace inner_build_ast -> ParseResult<(ContractAST, Vec<Diagnostic>, bool)> with ParseResult::from((Default::default(), vec![], false))
+clarity/src/vm/functions/arithmetic.rs:629: replace native_to_uint -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
+clarity/src/vm/functions/principals.rs:137: replace create_principal_value_error_response -> Value with Default::default()
+clarity/src/vm/database/clarity_db.rs:252: replace <impl BurnStateDB for &dyn BurnStateDB>::get_pox_payout_addrs -> Option<(Vec<TupleData>, u128)> with Some((vec![Default::default()], 1))
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:296: replace ContractContext::add_implemented_trait -> CheckResult<()> with CheckResult::new(())
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:160: replace Lexer<'a>::proceed_through_error -> LexResult<String> with LexResult::from_iter([String::new()])
+clarity/src/vm/functions/conversions.rs:154: replace safe_convert_string_to_int -> Result<Value> with Ok(Default::default())
+clarity/src/vm/functions/conversions.rs:210: replace native_int_to_utf8 -> Result<Value> with Ok(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:243: replace ContractContext::add_variable_type -> CheckResult<()> with CheckResult::from(())
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:78: replace Lexer<'a>::read_char -> LexResult<()> with LexResult::new()
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:899: replace TypeChecker<'a, 'b>::track_return_type -> CheckResult<()> with CheckResult::from_iter([()])
+clarity/src/vm/functions/arithmetic.rs:604: replace native_bitwise_right_shift -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
+clarity/src/vm/representations.rs:610: replace SymbolicExpression::match_field -> Option<&TraitIdentifier> with Some(&Default::default())
+clarity/src/mod.rs:81: replace boot_util::boot_code_addr -> StacksAddress with Default::default()
+clarity/src/vm/ast/stack_depth_checker.rs:74: replace <impl BuildASTPass for VaryStackDepthChecker>::run_pass -> ParseResult<()> with ParseResult::new(())
+clarity/src/vm/clarity.rs:70: replace <impl From for Error>::from -> Self with Default::default()
+clarity/src/vm/functions/arithmetic.rs:639: replace native_to_int -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
+clarity/src/vm/mod.rs:369: replace eval_all -> Result<Option<Value>> with Ok(Some(Default::default()))
+clarity/src/vm/functions/mod.rs:595: replace native_begin -> Result<Value> with Ok(Default::default())
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:311: replace Lexer<'a>::read_unsigned -> LexResult<Token> with LexResult::from(Default::default())
+clarity/src/vm/analysis/type_checker/v2_05/natives/assets.rs:56: replace check_special_get_balance -> TypeResult with Default::default()
+clarity/src/vm/analysis/analysis_db.rs:153: replace AnalysisDatabase<'a>::get_public_function_type -> CheckResult<Option<FunctionType>> with CheckResult::from_iter([Some(Default::default())])
+clarity/src/vm/ast/parser/v2/mod.rs:1062: replace Parser<'a>::parse_node_or_eof -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::from(Some(Default::default()))
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:253: replace ContractContext::add_persisted_variable_type -> CheckResult<()> with CheckResult::new()
+clarity/src/vm/ast/mod.rs:174: replace inner_build_ast -> ParseResult<(ContractAST, Vec<Diagnostic>, bool)> with ParseResult::new((Default::default(), vec![], true))
+clarity/src/vm/functions/tuples.rs:30: replace tuple_cons -> Result<Value> with Ok(Default::default())
+clarity/src/vm/analysis/contract_interface_builder/mod.rs:318: replace ContractInterfaceNonFungibleTokens::from_map -> Vec<Self> with vec![Default::default()]
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:62: replace TraitContext::add_defined_trait -> CheckResult<()> with CheckResult::from(())
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:388: replace TypeChecker<'a, 'b>::run -> CheckResult<()> with CheckResult::from_iter([()])
+clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs:100: replace check_special_at_block -> TypeResult with Default::default()
+clarity/src/vm/analysis/analysis_db.rs:123: replace AnalysisDatabase<'a>::insert_contract -> CheckResult<()> with CheckResult::new(())
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:162: replace ContractContext::add_nft -> CheckResult<()> with CheckResult::from_iter([()])
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:186: replace ContractContext::check_function_type -> CheckResult<()> with CheckResult::new()
+clarity/src/vm/database/structures.rs:744: replace STXBalance::zero -> STXBalance with Default::default()
+clarity/src/vm/contexts.rs:619: replace OwnedEnvironment<'a, 'hooks>::new_cost_limited -> OwnedEnvironment<'a, '_> with Default::default()
+clarity/src/vm/functions/arithmetic.rs:504: replace special_greater -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
+clarity/src/vm/functions/arithmetic.rs:572: replace native_log2 -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
+clarity/src/vm/types/mod.rs:101: replace QualifiedContractIdentifier::transient -> QualifiedContractIdentifier with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:986: replace TypeChecker<'a, 'b>::type_check -> TypeResult with Default::default()
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:126: replace ContractContext::add_map_type -> CheckResult<()> with CheckResult::from(())
+clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs:82: replace check_special_print -> TypeResult with Default::default()
+clarity/src/vm/database/clarity_db.rs:1129: replace ClarityDatabase<'a>::create_variable -> DataVariableMetadata with Default::default()
+clarity/src/vm/functions/assets.rs:436: replace special_mint_asset_v205 -> Result<Value> with Ok(Default::default())
+clarity/src/vm/ast/definition_sorter/mod.rs:456: replace GraphWalker::get_sorted_dependencies -> ParseResult<Vec<usize>> with ParseResult::new()
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:351: replace TypeChecker<'a, 'b>::into_contract_analysis -> LimitedCostTracker with Default::default()
+clarity/src/vm/analysis/types.rs:230: replace ContractAnalysis::check_trait_compliance -> CheckResult<()> with CheckResult::from_iter([()])
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:497: replace TypeChecker<'a, 'b>::type_check_consecutive_statements -> TypeResult with Default::default()
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:126: replace ContractContext::add_map_type -> CheckResult<()> with CheckResult::new(())
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:160: replace Lexer<'a>::proceed_through_error -> LexResult<String> with LexResult::new(String::new())
+clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs:500: replace check_secp256k1_verify -> TypeResult with Default::default()
+clarity/src/vm/ast/parser/v2/mod.rs:219: replace Parser<'a>::handle_open_node -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::new(None)
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:145: replace FunctionType::check_args_2_05 -> CheckResult<TypeSignature> with CheckResult::from_iter([Default::default()])
+clarity/src/vm/types/mod.rs:109: replace QualifiedContractIdentifier::parse -> Result<QualifiedContractIdentifier> with Ok(Default::default())
+clarity/src/vm/analysis/types.rs:167: replace ContractAnalysis::get_read_only_function_type -> Option<&FunctionType> with Some(&Default::default())
+clarity/src/vm/analysis/types.rs:230: replace ContractAnalysis::check_trait_compliance -> CheckResult<()> with CheckResult::new(())
+clarity/src/vm/types/signatures.rs:958: replace TypeSignature::empty_buffer -> TypeSignature with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:168: replace ContractContext::check_name_used -> CheckResult<()> with CheckResult::new(())
+clarity/src/vm/analysis/contract_interface_builder/mod.rs:266: replace ContractInterfaceFunction::from_map -> Vec<ContractInterfaceFunction> with vec![Default::default()]
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:571: replace clarity2_trait_check_trait_compliance -> CheckResult<()> with CheckResult::new(())
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1372: replace TypeChecker<'a, 'b>::type_check_define_ft -> CheckResult<ClarityName> with CheckResult::new()
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:118: replace <impl AnalysisPass for TypeChecker<'_, '_>>::run_pass -> CheckResult<()> with CheckResult::from(())
+clarity/src/vm/ast/sugar_expander/mod.rs:40: replace <impl BuildASTPass for SugarExpander>::run_pass -> ParseResult<()> with ParseResult::new(())
+clarity/src/vm/functions/assets.rs:260: replace special_stx_burn -> Result<Value> with Ok(Default::default())
+clarity/src/vm/database/key_value_wrapper.rs:466: replace RollbackWrapper<'a>::get_metadata -> InterpreterResult<Option<String>> with InterpreterResult::from(Some(String::new()))
+clarity/src/vm/costs/mod.rs:1050: replace <impl CostTracker for &mut LimitedCostTracker>::compute_cost -> std::result::Result<ExecutionCost, CostErrors> with Ok(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/natives/assets.rs:33: replace check_special_get_owner -> TypeResult with Default::default()
+clarity/src/vm/database/key_value_wrapper.rs:495: replace RollbackWrapper<'a>::get_metadata_manual -> InterpreterResult<Option<String>> with InterpreterResult::from(None)
+clarity/src/vm/functions/sequences.rs:87: replace special_fold -> Result<Value> with Ok(Default::default())
+clarity/src/vm/ast/traits_resolver/mod.rs:36: replace <impl BuildASTPass for TraitsResolver>::run_pass -> ParseResult<()> with ParseResult::new(())
+clarity/src/vm/functions/mod.rs:623: replace special_if -> Result<Value> with Ok(Default::default())
+clarity/src/vm/types/serialization.rs:120: replace <impl From for SerializationError>::from -> Self with Default::default()
+clarity/src/vm/database/clarity_db.rs:295: replace <impl HeadersDB for NullHeadersDB>::get_consensus_hash_for_block -> Option<ConsensusHash> with Some(Default::default())
+clarity/src/vm/representations.rs:664: replace Span::zero -> Span with Default::default()
+clarity/src/vm/ast/parser/v2/mod.rs:1093: replace parse -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::new()
+clarity/src/vm/analysis/type_checker/v2_1/natives/options.rs:113: replace check_special_default_to -> TypeResult with Default::default()
+clarity/src/vm/contexts.rs:1135: replace Environment<'a, 'b, 'hooks>::inner_execute_contract -> Result<Value> with Ok(Default::default())
+clarity/src/vm/test_util/mod.rs:210: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_stacks_epoch -> Option<StacksEpoch> with Some(Default::default())
+clarity/src/vm/functions/arithmetic.rs:554: replace native_add -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
+clarity/src/vm/functions/options.rs:173: replace special_match_resp -> Result<Value> with Ok(Default::default())
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:160: replace Lexer<'a>::proceed_through_error -> LexResult<String> with LexResult::from(String::new())
+clarity/src/vm/analysis/read_only_checker/mod.rs:182: replace ReadOnlyChecker<'a, 'b>::check_reads_only_valid -> CheckResult<()> with CheckResult::new()
+clarity/src/vm/database/clarity_db.rs:525: replace ClarityDatabase<'a>::get_with_proof -> Option<(T, Vec<u8>)> with Some((Default::default(), vec![]))
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1385: replace TypeChecker<'a, 'b>::type_check_define_nft -> CheckResult<(ClarityName, TypeSignature)> with CheckResult::new()
+clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs:662: replace check_get_burn_block_info -> TypeResult with Default::default()
+clarity/src/vm/database/clarity_db.rs:1602: replace ClarityDatabase<'a>::create_fungible_token -> FungibleTokenMetadata with Default::default()
+clarity/src/vm/database/clarity_db.rs:1778: replace ClarityDatabase<'a>::get_nft_owner -> Result<PrincipalData> with Ok(Default::default())
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:389: replace Lexer<'a>::read_ascii_string -> LexResult<Token> with LexResult::from(Default::default())
+clarity/src/vm/ast/mod.rs:69: replace parse_in_epoch -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::from_iter([vec![Default::default()]])
+clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs:103: replace check_special_begin -> TypeResult with Default::default()
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:185: replace Lexer<'a>::proceed_through_error_string -> LexResult<String> with LexResult::new()
+clarity/src/vm/ast/mod.rs:69: replace parse_in_epoch -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::new(vec![Default::default()])
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:62: replace TraitContext::add_defined_trait -> CheckResult<()> with CheckResult::from_iter([()])
+clarity/src/vm/types/mod.rs:1324: replace PrincipalData::parse_standard_principal -> Result<StandardPrincipalData> with Ok(Default::default())
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:530: replace TypeChecker<'a, 'b>::type_check_function_type -> TypeResult with Default::default()
+clarity/src/vm/ast/parser/v2/mod.rs:219: replace Parser<'a>::handle_open_node -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::new(Some(Default::default()))
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:102: replace TraitContext::get_trait -> Option<&BTreeMap<ClarityName, FunctionSignature>> with Some(&BTreeMap::new())
+clarity/src/vm/analysis/read_only_checker/mod.rs:281: replace ReadOnlyChecker<'a, 'b>::check_native_function_is_read_only -> CheckResult<bool> with CheckResult::new(true)
+clarity/src/vm/database/key_value_wrapper.rs:495: replace RollbackWrapper<'a>::get_metadata_manual -> InterpreterResult<Option<String>> with InterpreterResult::from(Some("xyzzy".into()))
+clarity/src/vm/costs/mod.rs:1099: replace <impl FromSql for ExecutionCost>::column_result -> FromSqlResult<ExecutionCost> with FromSqlResult::from(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs:203: replace check_special_concat -> TypeResult with Default::default()
+clarity/src/vm/functions/options.rs:258: replace native_default_to -> Result<Value> with Ok(Default::default())
+clarity/src/vm/functions/arithmetic.rs:381: replace native_bitwise_not -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
+clarity/src/vm/analysis/analysis_db.rs:106: replace AnalysisDatabase<'a>::load_contract -> Option<ContractAnalysis> with Some(Default::default())
+clarity/src/vm/types/mod.rs:1178: replace BuffData::len -> BufferLength with Default::default()
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:160: replace Lexer<'a>::proceed_through_error -> LexResult<String> with LexResult::new()
+clarity/src/vm/ast/mod.rs:103: replace build_ast_with_rules -> ParseResult<ContractAST> with ParseResult::from(Default::default())
+clarity/src/vm/types/mod.rs:653: replace <impl SequencedValue for ASCIIData>::items -> &Vec<u8> with &vec![0]
+clarity/src/vm/functions/arithmetic.rs:518: replace special_less_v1 -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1414: replace TypeChecker<'a, 'b>::try_type_check_define -> CheckResult<Option<()>> with CheckResult::new(Some(()))
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:785: replace clarity2_lookup_trait -> CheckResult<BTreeMap<ClarityName, FunctionSignature>> with CheckResult::from_iter([BTreeMap::new()])
+clarity/src/vm/test_util/mod.rs:256: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_ast_rules -> ASTRules with Default::default()
+clarity/src/vm/ast/parser/v2/mod.rs:1093: replace parse -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::new(vec![Default::default()])
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:182: replace ContractContext::get_trait -> Option<&BTreeMap<ClarityName, FunctionSignature>> with Some(&BTreeMap::new())
+clarity/src/vm/functions/conversions.rs:166: replace safe_convert_string_to_uint -> Result<Value> with Ok(Default::default())
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:61: replace ContractContext::check_name_used -> CheckResult<()> with CheckResult::from_iter([()])
+clarity/src/vm/database/clarity_db.rs:1502: replace ClarityDatabase<'a>::inner_set_entry -> Result<ValueResult> with Ok(Default::default())
+clarity/src/vm/ast/parser/v1.rs:192: replace inner_lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::from(vec![(Default::default(), 1, 1)])
+clarity/src/vm/analysis/read_only_checker/mod.rs:430: replace ReadOnlyChecker<'a, 'b>::check_expression_application_is_read_only -> CheckResult<bool> with CheckResult::from(false)
+clarity/src/vm/ast/expression_identifier/mod.rs:40: replace update_expression_id -> ParseResult<()> with ParseResult::new(())
+clarity/src/vm/test_util/mod.rs:61: replace execute_on_network -> Value with Default::default()
+clarity/src/vm/ast/parser/v2/mod.rs:807: replace Parser<'a>::parse_node -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::from_iter([None])
+clarity/src/vm/functions/arithmetic.rs:52: replace ASCIIOps::make_value -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1136: replace TypeChecker<'a, 'b>::type_check_define_map -> CheckResult<(ClarityName, (TypeSignature, TypeSignature))> with CheckResult::new((Default::default(), (Default::default(), Default::default())))
+clarity/src/vm/functions/assets.rs:979: replace special_burn_asset_v200 -> Result<Value> with Ok(Default::default())
+clarity/src/vm/analysis/analysis_db.rs:48: replace AnalysisDatabase<'a>::execute -> Result<T, E> with Ok(Default::default())
+clarity/src/vm/analysis/type_checker/v2_05/natives/sequences.rs:401: replace check_special_index_of -> TypeResult with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1398: replace TypeChecker<'a, 'b>::type_check_define_trait -> CheckResult<(ClarityName, BTreeMap<ClarityName, FunctionSignature>)> with CheckResult::from((Default::default(), BTreeMap::new()))
+clarity/src/vm/types/signatures.rs:1476: replace TypeSignature::parse_response_type_repr -> Result<TypeSignature> with Ok(Default::default())
+clarity/src/vm/functions/arithmetic.rs:67: replace BuffOps::make_value -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
+clarity/src/vm/ast/parser/v1.rs:462: replace unescape_ascii_chars -> ParseResult<String> with ParseResult::new(String::new())
+clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs:93: replace check_special_at_block -> TypeResult with Default::default()
+clarity/src/vm/analysis/errors.rs:262: replace <impl Error for CheckError>::source -> Option<&(dyn error::Error +'static)> with Some(&Default::default())
+clarity/src/vm/variables.rs:44: replace NativeVariables::lookup_by_name_at_version -> Option<NativeVariables> with Some(Default::default())
+clarity/src/vm/database/clarity_store.rs:327: replace <impl ClarityBackingStore for MemoryBackingStore>::get_cc_special_cases_handler -> Option<SpecialCaseHandler> with Some(Default::default())
+clarity/src/vm/types/serialization.rs:535: replace Value::deserialize_read_count -> Result<(Value, u64), SerializationError> with Ok((Default::default(), 0))
+clarity/src/vm/database/clarity_db.rs:157: replace <impl HeadersDB for &dyn HeadersDB>::get_stacks_block_header_hash_for_block -> Option<BlockHeaderHash> with Some(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/natives/options.rs:35: replace check_special_okay -> TypeResult with Default::default()
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:177: replace ContractContext::add_implemented_trait -> CheckResult<()> with CheckResult::from_iter([()])
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:845: replace type_reserved_variable -> Option<TypeSignature> with Some(Default::default())
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:106: replace ContractContext::add_read_only_function_type -> CheckResult<()> with CheckResult::from_iter([()])
+clarity/src/vm/database/key_value_wrapper.rs:354: replace RollbackWrapper<'a>::get_with_proof -> Option<(T, Vec<u8>)> with Some((Default::default(), vec![]))
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:311: replace Lexer<'a>::read_unsigned -> LexResult<Token> with LexResult::new(Default::default())
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:140: replace Lexer<'a>::read_line -> LexResult<String> with LexResult::new()
+clarity/src/vm/version.rs:46: replace <impl FromStr for ClarityVersion>::from_str -> Result<ClarityVersion, Error> with Ok(Default::default())
+clarity/src/vm/analysis/type_checker/mod.rs:64: replace FunctionType::check_args_by_allowing_trait_cast -> CheckResult<TypeSignature> with CheckResult::new()
+clarity/src/vm/analysis/type_checker/v2_05/natives/options.rs:46: replace check_special_some -> TypeResult with Default::default()
+clarity/src/vm/ast/parser/v1.rs:462: replace unescape_ascii_chars -> ParseResult<String> with ParseResult::new("xyzzy".into())
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:203: replace ContractContext::add_public_function_type -> CheckResult<()> with CheckResult::from_iter([()])
+clarity/src/vm/database/clarity_store.rs:285: replace MemoryBackingStore::as_analysis_db -> AnalysisDatabase with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/natives/options.rs:95: replace check_special_is_optional -> TypeResult with Default::default()
+clarity/src/vm/functions/arithmetic.rs:59: replace UTF8Ops::make_value -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
+clarity/src/vm/types/mod.rs:918: replace Value::cons_list -> Result<Value> with Ok(Default::default())
+clarity/src/vm/functions/arithmetic.rs:434: replace special_leq_v1 -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
+clarity/src/vm/functions/arithmetic.rs:518: replace special_less_v1 -> InterpreterResult<Value> with InterpreterResult::new()
+clarity/src/vm/database/clarity_db.rs:1447: replace ClarityDatabase<'a>::insert_entry_unknown_descriptor -> Result<Value> with Ok(Default::default())
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:388: replace TypeChecker<'a, 'b>::run -> CheckResult<()> with CheckResult::new(())
+clarity/src/vm/tests/datamaps.rs:689: replace make_tuple -> Value with Default::default()
+clarity/src/vm/analysis/read_only_checker/mod.rs:268: replace ReadOnlyChecker<'a, 'b>::try_check_native_function_is_read_only -> Option<CheckResult<bool>> with Some(CheckResult::new())
+clarity/src/vm/functions/arithmetic.rs:569: replace native_sqrti -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:792: replace TypeChecker<'a, 'b>::type_check_define_trait -> CheckResult<(ClarityName, BTreeMap<ClarityName, FunctionSignature>)> with CheckResult::from_iter([(Default::default(), BTreeMap::new())])
+clarity/src/vm/types/signatures.rs:261: replace FunctionReturnsSignature::canonicalize -> FunctionReturnsSignature with Default::default()
+clarity/src/vm/analysis/analysis_db.rs:208: replace AnalysisDatabase<'a>::get_implemented_traits -> CheckResult<BTreeSet<TraitIdentifier>> with CheckResult::new()
+clarity/src/vm/errors.rs:193: replace <impl From for Error>::from -> Self with Default::default()
+clarity/src/vm/ast/errors.rs:147: replace <impl From for ParseError>::from -> Self with Default::default()
+clarity/src/vm/contexts.rs:1646: replace GlobalContext<'a, 'hooks>::execute -> Result<T> with Ok(Default::default())
+clarity/src/vm/analysis/read_only_checker/mod.rs:268: replace ReadOnlyChecker<'a, 'b>::try_check_native_function_is_read_only -> Option<CheckResult<bool>> with Some(CheckResult::from_iter([true]))
+clarity/src/vm/database/key_value_wrapper.rs:466: replace RollbackWrapper<'a>::get_metadata -> InterpreterResult<Option<String>> with InterpreterResult::from_iter([None])
+clarity/src/vm/docs/mod.rs:2583: replace make_define_reference -> FunctionAPI with Default::default()
+clarity/src/vm/types/signatures.rs:1007: replace TypeSignature::bound_string_ascii_type -> TypeSignature with Default::default()
+clarity/src/vm/ast/stack_depth_checker.rs:28: replace check -> ParseResult<()> with ParseResult::from_iter([()])
+clarity/src/vm/functions/arithmetic.rs:476: replace special_greater_v1 -> InterpreterResult<Value> with InterpreterResult::new()
+clarity/src/vm/analysis/trait_checker/mod.rs:39: replace <impl AnalysisPass for TraitChecker>::run_pass -> CheckResult<()> with CheckResult::new()
+clarity/src/vm/test_util/mod.rs:116: replace <impl From for Value>::from -> Value with Default::default()
+clarity/src/vm/functions/database.rs:840: replace special_get_burn_block_info -> Result<Value> with Ok(Default::default())
+clarity/src/vm/representations.rs:534: replace SymbolicExpression::literal_value -> SymbolicExpression with Default::default()
+clarity/src/vm/ast/parser/v1.rs:455: replace lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::from_iter([vec![(Default::default(), 1, 1)]])
+clarity/src/vm/ast/parser/v1.rs:462: replace unescape_ascii_chars -> ParseResult<String> with ParseResult::from_iter(["xyzzy".into()])
+clarity/src/vm/functions/arithmetic.rs:575: replace native_mod -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:346: replace FunctionType::clarity2_principal_to_callable_type -> TypeResult with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:102: replace TraitContext::get_trait -> Option<&BTreeMap<ClarityName, FunctionSignature>> with Some(&BTreeMap::from_iter([(Default::default(), Default::default())]))
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:305: replace type_reserved_variable -> Option<TypeSignature> with Some(Default::default())
+clarity/src/vm/ast/parser/v1.rs:192: replace inner_lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::from(vec![(Default::default(), 0, 0)])
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:785: replace clarity2_lookup_trait -> CheckResult<BTreeMap<ClarityName, FunctionSignature>> with CheckResult::from(BTreeMap::new())
+clarity/src/vm/database/key_value_wrapper.rs:495: replace RollbackWrapper<'a>::get_metadata_manual -> InterpreterResult<Option<String>> with InterpreterResult::new(Some(String::new()))
+clarity/src/vm/functions/arithmetic.rs:569: replace native_sqrti -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1346: replace TypeChecker<'a, 'b>::type_check_define_variable -> CheckResult<(ClarityName, TypeSignature)> with CheckResult::new((Default::default(), Default::default()))
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1398: replace TypeChecker<'a, 'b>::type_check_define_trait -> CheckResult<(ClarityName, BTreeMap<ClarityName, FunctionSignature>)> with CheckResult::new((Default::default(), BTreeMap::from_iter([(Default::default(), Default::default())])))
+clarity/src/vm/types/mod.rs:886: replace Value::list_with_type -> Result<Value> with Ok(Default::default())
+clarity/src/vm/contexts.rs:1040: replace Environment<'a, 'b, 'hooks>::eval_read_only -> Result<Value> with Ok(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs:566: replace check_principal_of -> TypeResult with Default::default()
+clarity/src/vm/contexts.rs:1825: replace ContractContext::lookup_trait_definition -> Option<BTreeMap<ClarityName, FunctionSignature>> with Some(BTreeMap::from_iter([(Default::default(), Default::default())]))
+clarity/src/vm/types/signatures.rs:1489: replace TypeSignature::parse_type_repr -> Result<TypeSignature> with Ok(Default::default())
+clarity/src/vm/ast/mod.rs:53: replace parse -> Result<Vec<SymbolicExpression>, Error> with Ok(vec![Default::default()])
+clarity/src/vm/database/clarity_db.rs:166: replace <impl HeadersDB for &dyn HeadersDB>::get_vrf_seed_for_block -> Option<VRFSeed> with Some(Default::default())
+clarity/src/vm/functions/arithmetic.rs:518: replace special_less_v1 -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
+clarity/src/vm/ast/parser/v2/mod.rs:1093: replace parse -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::from_iter([vec![]])
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:304: replace ContractContext::get_trait -> Option<&BTreeMap<ClarityName, FunctionSignature>> with Some(&BTreeMap::new())
+clarity/src/vm/analysis/read_only_checker/mod.rs:227: replace ReadOnlyChecker<'a, 'b>::check_read_only -> CheckResult<bool> with CheckResult::from_iter([false])
+clarity/src/vm/types/signatures.rs:49: replace AssetIdentifier::STX -> AssetIdentifier with Default::default()
+clarity/src/vm/functions/arithmetic.rs:560: replace native_mul -> InterpreterResult<Value> with InterpreterResult::new()
+clarity/src/vm/database/clarity_db.rs:525: replace ClarityDatabase<'a>::get_with_proof -> Option<(T, Vec<u8>)> with Some((Default::default(), vec![1]))
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:213: replace ContractContext::add_read_only_function_type -> CheckResult<()> with CheckResult::from_iter([()])
+clarity/src/vm/ast/stack_depth_checker.rs:53: replace check_vary -> ParseResult<()> with ParseResult::new(())
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:156: replace FunctionType::check_args_2_1 -> CheckResult<TypeSignature> with CheckResult::new()
+clarity/src/vm/analysis/analysis_db.rs:208: replace AnalysisDatabase<'a>::get_implemented_traits -> CheckResult<BTreeSet<TraitIdentifier>> with CheckResult::new(BTreeSet::from_iter([Default::default()]))
+clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs:113: replace inner_handle_tuple_get -> TypeResult with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs:864: replace TypedNativeFunction::type_native_function::parse_principal_basic_type -> TypeSignature with Default::default()
+clarity/src/vm/database/clarity_store.rs:291: replace <impl ClarityBackingStore for MemoryBackingStore>::set_block_hash -> InterpreterResult<StacksBlockId> with InterpreterResult::new()
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:126: replace ContractContext::add_map_type -> CheckResult<()> with CheckResult::from_iter([()])
+clarity/src/vm/functions/arithmetic.rs:569: replace native_sqrti -> InterpreterResult<Value> with InterpreterResult::new()
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1357: replace TypeChecker<'a, 'b>::type_check_define_persisted_variable -> CheckResult<(ClarityName, TypeSignature)> with CheckResult::new((Default::default(), Default::default()))
+clarity/src/vm/analysis/type_checker/contexts.rs:129: replace TypingContext<'a>::lookup_trait_reference_type -> Option<&TraitIdentifier> with Some(&Default::default())
+clarity/src/vm/functions/arithmetic.rs:47: replace I128Ops::make_value -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
+clarity/src/vm/types/signatures.rs:1409: replace TypeSignature::parse_tuple_type_repr -> Result<TypeSignature> with Ok(Default::default())
+clarity/src/vm/functions/database.rs:69: replace special_contract_call -> Result<Value> with Ok(Default::default())
+clarity/src/vm/ast/mod.rs:87: replace ast_check_size -> ParseResult<ContractAST> with ParseResult::from_iter([Default::default()])
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:546: replace TypeChecker<'a, 'b>::type_check_define_function -> CheckResult<(ClarityName, FixedFunction)> with CheckResult::new()
+clarity/src/vm/contexts.rs:408: replace AssetMap::to_table -> HashMap<PrincipalData, HashMap<AssetIdentifier, AssetMapEntry>> with HashMap::from_iter([(Default::default(), HashMap::from_iter([(Default::default(), Default::default())]))])
+clarity/src/vm/analysis/type_checker/contexts.rs:65: replace TypeMap::get_type -> Option<&TypeSignature> with Some(&Default::default())
+clarity/src/vm/functions/arithmetic.rs:554: replace native_add -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
+clarity/src/vm/functions/arithmetic.rs:532: replace special_less_v2 -> InterpreterResult<Value> with InterpreterResult::new()
+clarity/src/vm/database/clarity_store.rs:239: replace <impl ClarityBackingStore for NullBackingStore>::get_block_at_height -> Option<StacksBlockId> with Some(Default::default())
+clarity/src/vm/clarity.rs:55: replace <impl From for Error>::from -> Self with Default::default()
+clarity/src/vm/functions/arithmetic.rs:67: replace BuffOps::make_value -> InterpreterResult<Value> with InterpreterResult::new()
+clarity/src/vm/analysis/contract_interface_builder/mod.rs:354: replace ContractInterfaceMap::from_map -> Vec<ContractInterfaceMap> with vec![Default::default()]
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:116: replace ContractContext::add_private_function_type -> CheckResult<()> with CheckResult::new()
+clarity/src/vm/functions/define.rs:139: replace handle_define_function -> Result<DefineResult> with Ok(Default::default())
+clarity/src/vm/contexts.rs:631: replace OwnedEnvironment<'a, 'hooks>::get_exec_environment -> Environment<'b, 'a, 'hooks> with Default::default()
+clarity/src/vm/analysis/mod.rs:50: replace mem_type_check -> CheckResult<(Option<TypeSignature>, ContractAnalysis)> with CheckResult::new((None, Default::default()))
+clarity/src/vm/representations.rs:275: replace PreSymbolicExpression::sugared_contract_identifier -> PreSymbolicExpression with Default::default()
+clarity/src/vm/analysis/analysis_db.rs:189: replace AnalysisDatabase<'a>::get_defined_trait -> CheckResult<Option<BTreeMap<ClarityName, FunctionSignature>>> with CheckResult::new()
+clarity/src/vm/types/mod.rs:653: replace <impl SequencedValue for ASCIIData>::items -> &Vec<u8> with &vec![]
+clarity/src/vm/representations.rs:292: replace PreSymbolicExpression::atom_value -> PreSymbolicExpression with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:233: replace ContractContext::add_map_type -> CheckResult<()> with CheckResult::new(())
+clarity/src/vm/ast/definition_sorter/mod.rs:433: replace Graph::edges_count -> ParseResult<u64> with ParseResult::new(0)
+clarity/src/vm/analysis/read_only_checker/mod.rs:170: replace ReadOnlyChecker<'a, 'b>::check_define_function -> CheckResult<(ClarityName, bool)> with CheckResult::from_iter([(Default::default(), true)])
+clarity/src/vm/functions/arithmetic.rs:377: replace native_bitwise_or -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
+clarity/src/vm/analysis/analysis_db.rs:215: replace AnalysisDatabase<'a>::destroy -> RollbackWrapper<'a> with Default::default()
+clarity/src/vm/database/clarity_db.rs:351: replace <impl BurnStateDB for NullBurnStateDB>::get_burn_header_hash -> Option<BurnchainHeaderHash> with Some(Default::default())
+clarity/src/vm/functions/arithmetic.rs:504: replace special_greater -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
+clarity/src/vm/ast/sugar_expander/mod.rs:66: replace SugarExpander::transform -> ParseResult<Vec<SymbolicExpression>> with ParseResult::new()
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:546: replace TypeChecker<'a, 'b>::type_check_define_function -> CheckResult<(ClarityName, FixedFunction)> with CheckResult::new((Default::default(), Default::default()))
+clarity/src/vm/analysis/type_checker/mod.rs:64: replace FunctionType::check_args_by_allowing_trait_cast -> CheckResult<TypeSignature> with CheckResult::from_iter([Default::default()])
+clarity/src/vm/ast/parser/v1.rs:720: replace parse -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::new(vec![Default::default()])
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:186: replace ContractContext::check_function_type -> CheckResult<()> with CheckResult::from(())
+clarity/src/vm/representations.rs:299: replace PreSymbolicExpression::atom -> PreSymbolicExpression with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/natives/assets.rs:140: replace check_special_transfer_asset -> TypeResult with Default::default()
+clarity/src/vm/analysis/read_only_checker/mod.rs:170: replace ReadOnlyChecker<'a, 'b>::check_define_function -> CheckResult<(ClarityName, bool)> with CheckResult::from_iter([(Default::default(), false)])
+clarity/src/vm/ast/mod.rs:153: replace build_ast_with_diagnostics -> (ContractAST, Vec<Diagnostic>, bool) with (Default::default(), vec![], false)
+clarity/src/vm/analysis/type_checker/contexts.rs:82: replace TypingContext<'a>::extend -> CheckResult<TypingContext> with CheckResult::from(Default::default())
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:779: replace TypeChecker<'a, 'b>::type_check_define_nft -> CheckResult<(ClarityName, TypeSignature)> with CheckResult::new((Default::default(), Default::default()))
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:162: replace ContractContext::add_nft -> CheckResult<()> with CheckResult::new(())
+clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs:365: replace check_contract_call -> TypeResult with Default::default()
+clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs:75: replace check_special_print -> TypeResult with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1414: replace TypeChecker<'a, 'b>::try_type_check_define -> CheckResult<Option<()>> with CheckResult::from(None)
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:831: replace trait_type_size -> CheckResult<u64> with CheckResult::new(1)
+clarity/src/vm/analysis/trait_checker/mod.rs:55: replace TraitChecker::run -> CheckResult<()> with CheckResult::from(())
+clarity/src/vm/database/clarity_db.rs:620: replace ClarityDatabase<'a>::fetch_metadata -> Result<Option<T>> with Ok(Some(Default::default()))
+clarity/src/vm/analysis/type_checker/mod.rs:64: replace FunctionType::check_args_by_allowing_trait_cast -> CheckResult<TypeSignature> with CheckResult::from(Default::default())
+clarity/src/vm/ast/definition_sorter/mod.rs:54: replace DefinitionSorter::run_pass -> ParseResult<()> with ParseResult::new(())
+clarity/src/vm/ast/sugar_expander/mod.rs:66: replace SugarExpander::transform -> ParseResult<Vec<SymbolicExpression>> with ParseResult::from_iter([vec![Default::default()]])
+clarity/src/vm/types/mod.rs:690: replace <impl SequencedValue for UTF8Data>::to_value -> Value with Default::default()
+clarity/src/vm/ast/expression_identifier/mod.rs:51: replace ExpressionIdentifier::run_pre_expression_pass -> ParseResult<()> with ParseResult::from_iter([()])
+clarity/src/vm/ast/parser/v1.rs:455: replace lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::from(vec![(Default::default(), 1, 1)])
+clarity/src/vm/database/sqlite.rs:203: replace SqliteConnection::inner_open -> Result<Connection> with Ok(Default::default())
+clarity/src/vm/analysis/analysis_db.rs:171: replace AnalysisDatabase<'a>::get_read_only_function_type -> CheckResult<Option<FunctionType>> with CheckResult::from_iter([None])
+clarity/src/vm/types/mod.rs:1521: replace TupleData::get -> Result<&Value> with Ok(&Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:868: replace no_type -> TypeSignature with Default::default()
+clarity/src/vm/analysis/type_checker/v2_05/natives/options.rs:142: replace inner_unwrap -> TypeResult with Default::default()
+clarity/src/vm/analysis/type_checker/v2_05/natives/maps.rs:107: replace check_set_or_insert_entry -> TypeResult with Default::default()
+clarity/src/vm/types/signatures.rs:861: replace TupleTypeSignature::get_type_map -> &BTreeMap<ClarityName, TypeSignature> with &BTreeMap::new()
+clarity/src/vm/database/clarity_db.rs:1330: replace ClarityDatabase<'a>::fetch_entry -> Result<Value> with Ok(Default::default())
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:177: replace ContractContext::add_implemented_trait -> CheckResult<()> with CheckResult::new(())
+clarity/src/vm/analysis/contract_interface_builder/mod.rs:236: replace ContractInterfaceFunctionArg::from_function_args -> Vec<ContractInterfaceFunctionArg> with vec![Default::default()]
+clarity/src/vm/contexts.rs:726: replace OwnedEnvironment<'a, 'hooks>::initialize_contract_from_ast -> Result<((), AssetMap, Vec<StacksTransactionEvent>)> with Ok(((), Default::default(), vec![Default::default()]))
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:785: replace clarity2_lookup_trait -> CheckResult<BTreeMap<ClarityName, FunctionSignature>> with CheckResult::from(BTreeMap::from_iter([(Default::default(), Default::default())]))
+clarity/src/vm/ast/sugar_expander/mod.rs:66: replace SugarExpander::transform -> ParseResult<Vec<SymbolicExpression>> with ParseResult::new(vec![])
+clarity/src/vm/mod.rs:557: replace execute -> Result<Option<Value>> with Ok(Some(Default::default()))
+clarity/src/vm/types/signatures.rs:1065: replace TypeSignature::least_supertype_v2_0 -> Result<TypeSignature> with Ok(Default::default())
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:389: replace Lexer<'a>::read_ascii_string -> LexResult<Token> with LexResult::new()
+clarity/src/vm/functions/sequences.rs:252: replace special_concat_v205 -> Result<Value> with Ok(Default::default())
+clarity/src/vm/types/serialization.rs:150: replace <impl From for TypePrefix>::from -> TypePrefix with Default::default()
+clarity/src/vm/ast/mod.rs:174: replace inner_build_ast -> ParseResult<(ContractAST, Vec<Diagnostic>, bool)> with ParseResult::from_iter([(Default::default(), vec![Default::default()], true)])
+clarity/src/vm/representations.rs:341: replace PreSymbolicExpression::comment -> PreSymbolicExpression with Default::default()
+clarity/src/vm/database/key_value_wrapper.rs:495: replace RollbackWrapper<'a>::get_metadata_manual -> InterpreterResult<Option<String>> with InterpreterResult::new()
+clarity/src/vm/representations.rs:570: replace SymbolicExpression::match_list -> Option<&[SymbolicExpression]> with Some(Vec::leak(vec![Default::default()]))
+clarity/src/vm/representations.rs:424: replace depth_traverse -> Result<T, E> with Ok(Default::default())
+clarity/src/vm/database/clarity_db.rs:287: replace <impl HeadersDB for NullHeadersDB>::get_stacks_block_header_hash_for_block -> Option<BlockHeaderHash> with Some(Default::default())
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:160: replace Lexer<'a>::proceed_through_error -> LexResult<String> with LexResult::from("xyzzy".into())
+clarity/src/vm/functions/sequences.rs:330: replace native_element_at -> Result<Value> with Ok(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1321: replace TypeChecker<'a, 'b>::inner_type_check -> TypeResult with Default::default()
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:326: replace Lexer<'a>::read_integer -> LexResult<Token> with LexResult::from_iter([Default::default()])
+clarity/src/vm/functions/arithmetic.rs:405: replace special_geq_v2 -> InterpreterResult<Value> with InterpreterResult::new()
+clarity/src/vm/types/mod.rs:1148: replace Value::expect_result_ok -> Value with Default::default()
+clarity/src/vm/contexts.rs:764: replace OwnedEnvironment<'a, 'hooks>::stx_transfer -> Result<(Value, AssetMap, Vec<StacksTransactionEvent>)> with Ok((Default::default(), Default::default(), vec![]))
+clarity/src/vm/analysis/type_checker/v2_05/natives/options.rs:252: replace check_special_unwrap -> TypeResult with Default::default()
+clarity/src/vm/types/mod.rs:189: replace TraitIdentifier::parse_fully_qualified -> Result<TraitIdentifier> with Ok(Default::default())
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:575: replace Lexer<'a>::read_utf8_string -> LexResult<Token> with LexResult::from(Default::default())
+clarity/src/vm/analysis/type_checker/v2_05/natives/sequences.rs:349: replace check_special_len -> TypeResult with Default::default()
+clarity/src/vm/functions/arithmetic.rs:604: replace native_bitwise_right_shift -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
+clarity/src/vm/callables.rs:351: replace DefinedFunction::get_identifier -> FunctionIdentifier with Default::default()
+clarity/src/vm/functions/arithmetic.rs:67: replace BuffOps::make_value -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
+clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs:548: replace TypedNativeFunction::type_native_function -> TypedNativeFunction with Default::default()
+clarity/src/vm/ast/parser/v2/lexer/error.rs:71: replace <impl DiagnosableError for LexerError>::level -> crate::vm::diagnostic::Level with Default::default()
+clarity/src/vm/ast/definition_sorter/mod.rs:54: replace DefinitionSorter::run_pass -> ParseResult<()> with ParseResult::from_iter([()])
+clarity/src/vm/docs/mod.rs:2570: replace make_for_define -> FunctionAPI with Default::default()
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:766: replace TypeChecker<'a, 'b>::type_check_define_ft -> CheckResult<ClarityName> with CheckResult::from(Default::default())
+clarity/src/vm/analysis/type_checker/v2_05/natives/options.rs:92: replace check_special_is_optional -> TypeResult with Default::default()
+clarity/src/vm/analysis/type_checker/v2_05/natives/assets.rs:244: replace check_special_burn_token -> TypeResult with Default::default()
+clarity/src/vm/analysis/mod.rs:50: replace mem_type_check -> CheckResult<(Option<TypeSignature>, ContractAnalysis)> with CheckResult::new((Some(Default::default()), Default::default()))
+clarity/src/vm/types/signatures.rs:1812: replace parse_name_type_pairs -> Result<Vec<(ClarityName, TypeSignature)>> with Ok(vec![(Default::default(), Default::default())])
+clarity/src/vm/contexts.rs:752: replace OwnedEnvironment<'a, 'hooks>::execute_transaction -> Result<(Value, AssetMap, Vec<StacksTransactionEvent>)> with Ok((Default::default(), Default::default(), vec![Default::default()]))
+clarity/src/vm/docs/contracts.rs:95: replace make_docs -> ContractRef with Default::default()
+clarity/src/vm/functions/arithmetic.rs:604: replace native_bitwise_right_shift -> InterpreterResult<Value> with InterpreterResult::new()
+clarity/src/vm/functions/define.rs:206: replace handle_define_fungible_token -> Result<DefineResult> with Ok(Default::default())
+clarity/src/vm/analysis/trait_checker/mod.rs:39: replace <impl AnalysisPass for TraitChecker>::run_pass -> CheckResult<()> with CheckResult::from_iter([()])
+clarity/src/vm/contexts.rs:556: replace OwnedEnvironment<'a, 'hooks>::new_toplevel -> OwnedEnvironment<'a, '_> with Default::default()
+clarity/src/vm/functions/principals.rs:155: replace special_principal_destruct -> Result<Value> with Ok(Default::default())
+clarity/src/vm/functions/options.rs:246: replace native_is_err -> Result<Value> with Ok(Default::default())
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:792: replace TypeChecker<'a, 'b>::type_check_define_trait -> CheckResult<(ClarityName, BTreeMap<ClarityName, FunctionSignature>)> with CheckResult::new((Default::default(), BTreeMap::new()))
+clarity/src/vm/ast/traits_resolver/mod.rs:201: replace TraitsResolver::probe_for_generics -> ParseResult<()> with ParseResult::from(())
+clarity/src/vm/database/clarity_db.rs:225: replace <impl BurnStateDB for &dyn BurnStateDB>::get_stacks_epoch -> Option<StacksEpoch> with Some(Default::default())
+clarity/src/vm/ast/parser/v2/mod.rs:687: replace Parser<'a>::read_sugared_principal -> ParseResult<PreSymbolicExpression> with ParseResult::from_iter([Default::default()])
+clarity/src/vm/database/key_value_wrapper.rs:384: replace RollbackWrapper<'a>::deserialize_value -> Result<ValueResult, SerializationError> with Ok(Default::default())
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:116: replace ContractContext::add_private_function_type -> CheckResult<()> with CheckResult::from_iter([()])
+clarity/src/vm/analysis/read_only_checker/mod.rs:112: replace ReadOnlyChecker<'a, 'b>::check_top_level_expression -> CheckResult<()> with CheckResult::new()
+clarity/src/vm/functions/arithmetic.rs:560: replace native_mul -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:304: replace ContractContext::get_trait -> Option<&BTreeMap<ClarityName, FunctionSignature>> with Some(&BTreeMap::from_iter([(Default::default(), Default::default())]))
+clarity/src/vm/ast/traits_resolver/mod.rs:48: replace TraitsResolver::run -> ParseResult<()> with ParseResult::new(())
+clarity/src/vm/functions/sequences.rs:56: replace special_filter -> Result<Value> with Ok(Default::default())
+clarity/src/vm/functions/database.rs:469: replace special_set_entry_v200 -> Result<Value> with Ok(Default::default())
+clarity/src/vm/ast/definition_sorter/mod.rs:379: replace DefinitionSorter::find_expression_definition -> Option<(ClarityName, u64, &'b PreSymbolicExpression)> with Some((Default::default(), 0, &Default::default()))
+clarity/src/vm/functions/conversions.rs:218: replace to_consensus_buff -> Result<Value> with Ok(Default::default())
+clarity/src/vm/types/mod.rs:1191: replace BuffData::empty -> Self with Default::default()
+clarity/src/vm/types/signatures.rs:464: replace ListTypeData::destruct -> (TypeSignature, u32) with (Default::default(), 1)
+clarity/src/vm/ast/parser/v2/mod.rs:1083: replace Parser<'a>::parse -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::from(vec![])
+clarity/src/vm/analysis/read_only_checker/mod.rs:244: replace ReadOnlyChecker<'a, 'b>::check_each_expression_is_read_only -> CheckResult<bool> with CheckResult::from_iter([false])
+clarity/src/vm/analysis/analysis_db.rs:137: replace AnalysisDatabase<'a>::get_clarity_version -> CheckResult<ClarityVersion> with CheckResult::new(Default::default())
+clarity/src/vm/database/clarity_db.rs:364: replace <impl BurnStateDB for NullBurnStateDB>::get_stacks_epoch_by_epoch_id -> Option<StacksEpoch> with Some(Default::default())
+clarity/src/vm/ast/definition_sorter/mod.rs:65: replace DefinitionSorter::run -> ParseResult<()> with ParseResult::new()
+clarity/src/vm/types/mod.rs:1126: replace Value::expect_callable -> CallableData with Default::default()
+clarity/src/vm/types/signatures.rs:444: replace ListTypeData::new_list -> Result<ListTypeData> with Ok(Default::default())
+clarity/src/vm/analysis/read_only_checker/mod.rs:170: replace ReadOnlyChecker<'a, 'b>::check_define_function -> CheckResult<(ClarityName, bool)> with CheckResult::new((Default::default(), false))
+clarity/src/vm/contexts.rs:829: replace OwnedEnvironment<'a, 'hooks>::eval_read_only -> Result<(Value, AssetMap, Vec<StacksTransactionEvent>)> with Ok((Default::default(), Default::default(), vec![]))
+clarity/src/vm/ast/sugar_expander/mod.rs:66: replace SugarExpander::transform -> ParseResult<Vec<SymbolicExpression>> with ParseResult::from(vec![])
+clarity/src/vm/types/serialization.rs:114: replace <impl From for SerializationError>::from -> Self with Default::default()
+clarity/src/vm/functions/arithmetic.rs:563: replace native_div -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
+clarity/src/vm/ast/mod.rs:69: replace parse_in_epoch -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::from_iter([vec![]])
+clarity/src/vm/types/mod.rs:1007: replace Value::string_utf8_from_bytes -> Result<Value> with Ok(Default::default())
+clarity/src/vm/database/key_value_wrapper.rs:466: replace RollbackWrapper<'a>::get_metadata -> InterpreterResult<Option<String>> with InterpreterResult::new(Some("xyzzy".into()))
+clarity/src/vm/database/key_value_wrapper.rs:425: replace RollbackWrapper<'a>::get_block_header_hash -> Option<StacksBlockId> with Some(Default::default())
+clarity/src/vm/functions/arithmetic.rs:41: replace U128Ops::make_value -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
+clarity/src/vm/costs/mod.rs:891: replace compute_cost -> Result<ExecutionCost> with Ok(Default::default())
+clarity/src/vm/functions/arithmetic.rs:563: replace native_div -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:168: replace ContractContext::check_name_used -> CheckResult<()> with CheckResult::new()
+clarity/src/vm/ast/mod.rs:174: replace inner_build_ast -> ParseResult<(ContractAST, Vec<Diagnostic>, bool)> with ParseResult::from((Default::default(), vec![Default::default()], true))
+clarity/src/vm/types/signatures.rs:763: replace TypeSignature::concretize -> Result<TypeSignature> with Ok(Default::default())
+clarity/src/vm/functions/sequences.rs:281: replace special_as_max_len -> Result<Value> with Ok(Default::default())
+clarity/src/vm/ast/definition_sorter/mod.rs:357: replace DefinitionSorter::probe_for_dependencies_in_wrapped_key_value_pairs -> ParseResult<()> with ParseResult::new(())
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:328: replace FunctionType::principal_to_callable_type -> TypeResult with Default::default()
+clarity/src/vm/tests/principals.rs:306: replace create_principal_destruct_tuple_from_strings -> Value with Default::default()
+clarity/src/vm/types/mod.rs:1099: replace Value::expect_tuple -> TupleData with Default::default()
+clarity/src/vm/functions/sequences.rs:178: replace special_append -> Result<Value> with Ok(Default::default())
+clarity/src/vm/analysis/types.rs:230: replace ContractAnalysis::check_trait_compliance -> CheckResult<()> with CheckResult::new()
+clarity/src/vm/analysis/trait_checker/mod.rs:39: replace <impl AnalysisPass for TraitChecker>::run_pass -> CheckResult<()> with CheckResult::from(())
+clarity/src/vm/analysis/type_checker/v2_05/natives/sequences.rs:264: replace check_special_append -> TypeResult with Default::default()
+clarity/src/vm/analysis/type_checker/v2_05/natives/options.rs:303: replace check_special_match_opt -> TypeResult with Default::default()
+clarity/src/vm/database/clarity_db.rs:525: replace ClarityDatabase<'a>::get_with_proof -> Option<(T, Vec<u8>)> with Some((Default::default(), vec![0]))
+clarity/src/vm/database/clarity_db.rs:1038: replace ClarityDatabase<'a>::get_cc_special_cases_handler -> Option<SpecialCaseHandler> with Some(Default::default())
+clarity/src/vm/types/serialization.rs:1198: replace Value::sanitize_value -> Option<(Value, bool)> with Some((Default::default(), true))
+clarity/src/vm/analysis/type_checker/v2_05/natives/sequences.rs:39: replace get_simple_native_or_user_define -> CheckResult<FunctionType> with CheckResult::from_iter([Default::default()])
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:186: replace ContractContext::check_function_type -> CheckResult<()> with CheckResult::new(())
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:766: replace TypeChecker<'a, 'b>::type_check_define_ft -> CheckResult<ClarityName> with CheckResult::from_iter([Default::default()])
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:126: replace ContractContext::add_map_type -> CheckResult<()> with CheckResult::new()
+clarity/src/vm/functions/principals.rs:88: replace create_principal_destruct_tuple -> Value with Default::default()
+clarity/src/vm/types/mod.rs:1319: replace PrincipalData::parse_qualified_contract_principal -> Result<PrincipalData> with Ok(Default::default())
+clarity/src/vm/ast/expression_identifier/mod.rs:23: replace inner_relabel -> ParseResult<u64> with ParseResult::from_iter([0])
+clarity/src/vm/test_util/mod.rs:253: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_sortition_id_from_consensus_hash -> Option<SortitionId> with Some(Default::default())
+clarity/src/vm/ast/sugar_expander/mod.rs:40: replace <impl BuildASTPass for SugarExpander>::run_pass -> ParseResult<()> with ParseResult::from(())
+clarity/src/vm/types/signatures.rs:1463: replace TypeSignature::parse_optional_type_repr -> Result<TypeSignature> with Ok(Default::default())
+clarity/src/vm/ast/definition_sorter/mod.rs:456: replace GraphWalker::get_sorted_dependencies -> ParseResult<Vec<usize>> with ParseResult::from_iter([vec![0]])
+clarity/src/vm/representations.rs:551: replace SymbolicExpression::trait_reference -> SymbolicExpression with Default::default()
+clarity/src/vm/ast/parser/v2/mod.rs:687: replace Parser<'a>::read_sugared_principal -> ParseResult<PreSymbolicExpression> with ParseResult::new()
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:575: replace Lexer<'a>::read_utf8_string -> LexResult<Token> with LexResult::new(Default::default())
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:479: replace TypeChecker<'a, 'b>::type_check -> TypeResult with Default::default()
+clarity/src/vm/ast/definition_sorter/mod.rs:345: replace DefinitionSorter::probe_for_dependencies_in_list_of_wrapped_key_value_pairs -> ParseResult<()> with ParseResult::from_iter([()])
+clarity/src/vm/types/serialization.rs:102: replace <impl Error for SerializationError>::source -> Option<&(dyn error::Error +'static)> with Some(&Default::default())
+clarity/src/vm/functions/crypto.rs:71: replace pubkey_to_address_v1 -> StacksAddress with Default::default()
+clarity/src/vm/ast/parser/v2/mod.rs:463: replace Parser<'a>::open_tuple -> ParseResult<SetupTupleResult> with ParseResult::from(Default::default())
+clarity/src/vm/functions/database.rs:260: replace special_fetch_variable_v205 -> Result<Value> with Ok(Default::default())
+clarity/src/vm/contexts.rs:687: replace OwnedEnvironment<'a, 'hooks>::initialize_contract -> Result<((), AssetMap, Vec<StacksTransactionEvent>)> with Ok(((), Default::default(), vec![Default::default()]))
+clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs:188: replace check_special_tuple_cons -> TypeResult with Default::default()
+clarity/src/vm/types/signatures.rs:1305: replace TypeSignature::empty_list -> ListTypeData with Default::default()
+clarity/src/vm/functions/arithmetic.rs:557: replace native_sub -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:779: replace TypeChecker<'a, 'b>::type_check_define_nft -> CheckResult<(ClarityName, TypeSignature)> with CheckResult::from((Default::default(), Default::default()))
+clarity/src/vm/ast/stack_depth_checker.rs:48: replace <impl BuildASTPass for StackDepthChecker>::run_pass -> ParseResult<()> with ParseResult::from(())
+clarity/src/vm/ast/sugar_expander/mod.rs:56: replace SugarExpander::run -> ParseResult<()> with ParseResult::from_iter([()])
+clarity/src/vm/functions/define.rs:291: replace DefineFunctionsParsed<'a>::try_parse -> std::result::Result<Option<DefineFunctionsParsed<'a>>, CheckErrors> with Ok(Some(Default::default()))
+clarity/src/vm/analysis/type_checker/v2_05/natives/sequences.rs:156: replace check_special_fold -> TypeResult with Default::default()
+clarity/src/vm/types/signatures.rs:806: replace <impl TryFrom for TupleTypeSignature>::try_from -> Result<TupleTypeSignature> with Ok(Default::default())
+clarity/src/vm/representations.rs:558: replace SymbolicExpression::field -> SymbolicExpression with Default::default()
+clarity/src/vm/functions/sequences.rs:226: replace special_concat_v200 -> Result<Value> with Ok(Default::default())
+clarity/src/vm/database/key_value_wrapper.rs:495: replace RollbackWrapper<'a>::get_metadata_manual -> InterpreterResult<Option<String>> with InterpreterResult::from_iter([None])
+clarity/src/vm/functions/arithmetic.rs:639: replace native_to_int -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
+clarity/src/vm/types/serialization.rs:1097: replace Value::try_deserialize_hex -> Result<Value, SerializationError> with Ok(Default::default())
+clarity/src/vm/functions/options.rs:242: replace native_is_okay -> Result<Value> with Ok(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs:39: replace get_simple_native_or_user_define -> CheckResult<FunctionType> with CheckResult::from_iter([Default::default()])
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:61: replace ContractContext::check_name_used -> CheckResult<()> with CheckResult::new(())
+clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs:110: replace check_special_begin -> TypeResult with Default::default()
+clarity/src/vm/functions/options.rs:216: replace native_some -> Result<Value> with Ok(Default::default())
+clarity/src/vm/ast/parser/v1.rs:192: replace inner_lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::from(vec![(Default::default(), 1, 0)])
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:79: replace ContractContext::check_function_type -> CheckResult<()> with CheckResult::from_iter([()])
+clarity/src/vm/ast/mod.rs:103: replace build_ast_with_rules -> ParseResult<ContractAST> with ParseResult::from_iter([Default::default()])
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1398: replace TypeChecker<'a, 'b>::type_check_define_trait -> CheckResult<(ClarityName, BTreeMap<ClarityName, FunctionSignature>)> with CheckResult::new()
+clarity/src/vm/analysis/read_only_checker/mod.rs:59: replace <impl AnalysisPass for ReadOnlyChecker<'a, 'b>>::run_pass -> CheckResult<()> with CheckResult::new(())
+clarity/src/vm/callables.rs:87: replace NativeHandle::apply -> Result<Value> with Ok(Default::default())
+clarity/src/vm/ast/expression_identifier/mod.rs:58: replace ExpressionIdentifier::run_expression_pass -> ParseResult<()> with ParseResult::new()
+clarity/src/vm/analysis/type_checker/contexts.rs:82: replace TypingContext<'a>::extend -> CheckResult<TypingContext> with CheckResult::new()
+clarity/src/vm/ast/mod.rs:174: replace inner_build_ast -> ParseResult<(ContractAST, Vec<Diagnostic>, bool)> with ParseResult::from((Default::default(), vec![], true))
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:177: replace ContractContext::add_implemented_trait -> CheckResult<()> with CheckResult::from(())
+clarity/src/vm/ast/definition_sorter/mod.rs:324: replace DefinitionSorter::probe_for_dependencies_in_define_args -> ParseResult<()> with ParseResult::new(())
+clarity/src/vm/analysis/type_checker/v2_05/natives/assets.rs:213: replace check_special_burn_asset -> TypeResult with Default::default()
+clarity/src/vm/ast/mod.rs:174: replace inner_build_ast -> ParseResult<(ContractAST, Vec<Diagnostic>, bool)> with ParseResult::from_iter([(Default::default(), vec![Default::default()], false)])
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:195: replace ContractContext::get_nft_type -> Option<&TypeSignature> with Some(&Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:269: replace ContractContext::add_nft -> CheckResult<()> with CheckResult::from(())
+clarity/src/vm/ast/expression_identifier/mod.rs:23: replace inner_relabel -> ParseResult<u64> with ParseResult::new(1)
+clarity/src/vm/types/mod.rs:766: replace BurnBlockInfoProperty::type_result -> TypeSignature with Default::default()
+clarity/src/vm/costs/mod.rs:1092: replace <impl ToSql for ExecutionCost>::to_sql -> rusqlite::Result<ToSqlOutput> with Ok(Default::default())
+clarity/src/vm/functions/conversions.rs:53: replace buff_to_int_generic -> Result<Value> with Ok(Default::default())
+clarity/src/vm/database/clarity_db.rs:355: replace <impl BurnStateDB for NullBurnStateDB>::get_stacks_epoch -> Option<StacksEpoch> with Some(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:259: replace ContractContext::add_ft -> CheckResult<()> with CheckResult::from(())
+clarity/src/vm/functions/conversions.rs:114: replace native_buff_to_uint_be::convert_to_uint_be -> Value with Default::default()
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:297: replace trait_type_size -> CheckResult<u64> with CheckResult::from(0)
+clarity/src/vm/ast/definition_sorter/mod.rs:65: replace DefinitionSorter::run -> ParseResult<()> with ParseResult::from(())
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:612: replace clarity2_inner_type_check_type -> TypeResult with Default::default()
+clarity/src/vm/analysis/read_only_checker/mod.rs:268: replace ReadOnlyChecker<'a, 'b>::try_check_native_function_is_read_only -> Option<CheckResult<bool>> with Some(CheckResult::from(false))
+clarity/src/vm/database/clarity_store.rs:213: replace NullBackingStore::as_clarity_db -> ClarityDatabase with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs:349: replace check_special_len -> TypeResult with Default::default()
+clarity/src/vm/database/key_value_wrapper.rs:229: replace RollbackWrapper<'a>::get_cc_special_cases_handler -> Option<SpecialCaseHandler> with Some(Default::default())
+clarity/src/vm/analysis/type_checker/v2_05/natives/sequences.rs:367: replace check_special_element_at -> TypeResult with Default::default()
+clarity/src/vm/ast/parser/v1.rs:728: replace parse_no_stack_limit -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::new(vec![Default::default()])
+clarity/src/vm/costs/mod.rs:1099: replace <impl FromSql for ExecutionCost>::column_result -> FromSqlResult<ExecutionCost> with FromSqlResult::new(Default::default())
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:79: replace ContractContext::check_function_type -> CheckResult<()> with CheckResult::new(())
+clarity/src/vm/costs/mod.rs:221: replace CostStateSummary::empty -> CostStateSummary with Default::default()
+clarity/src/vm/types/signatures.rs:376: replace <impl TryFrom for BufferLength>::try_from -> Result<BufferLength> with Ok(Default::default())
+clarity/src/vm/ast/parser/v1.rs:508: replace parse_lexed -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::from(vec![Default::default()])
+clarity/src/vm/test_util/mod.rs:220: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_stacks_epoch_by_epoch_id -> Option<StacksEpoch> with Some(Default::default())
+clarity/src/vm/functions/arithmetic.rs:381: replace native_bitwise_not -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
+clarity/src/vm/types/mod.rs:1162: replace Value::expect_result_err -> Value with Default::default()
+clarity/src/vm/functions/arithmetic.rs:41: replace U128Ops::make_value -> InterpreterResult<Value> with InterpreterResult::new()
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:118: replace <impl AnalysisPass for TypeChecker<'_, '_>>::run_pass -> CheckResult<()> with CheckResult::from_iter([()])
+clarity/src/vm/ast/definition_sorter/mod.rs:307: replace DefinitionSorter::probe_for_dependencies_in_tuple -> ParseResult<()> with ParseResult::from(())
+clarity/src/vm/functions/arithmetic.rs:448: replace special_leq_v2 -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
+clarity/src/vm/analysis/read_only_checker/mod.rs:281: replace ReadOnlyChecker<'a, 'b>::check_native_function_is_read_only -> CheckResult<bool> with CheckResult::from(false)
+clarity/src/vm/analysis/type_checker/v2_05/natives/options.rs:378: replace check_special_match -> TypeResult with Default::default()
+clarity/src/vm/analysis/types.rs:163: replace ContractAnalysis::get_public_function_type -> Option<&FunctionType> with Some(&Default::default())
+clarity/src/vm/costs/mod.rs:195: replace <impl From for SerializedCostStateSummary>::from -> SerializedCostStateSummary with Default::default()
+clarity/src/vm/types/signatures.rs:321: replace <impl From for FunctionSignature>::from -> FunctionSignature with Default::default()
+clarity/src/vm/contexts.rs:801: replace OwnedEnvironment<'a, 'hooks>::eval_raw -> Result<(Value, AssetMap, Vec<StacksTransactionEvent>)> with Ok((Default::default(), Default::default(), vec![Default::default()]))
+clarity/src/vm/types/mod.rs:77: replace StandardPrincipalData::transient -> StandardPrincipalData with Default::default()
+clarity/src/vm/ast/parser/v2/mod.rs:158: replace Parser<'a>::peek_last_token -> ParseResult<&PlacedToken> with ParseResult::from(&Default::default())
+clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs:160: replace check_special_merge -> TypeResult with Default::default()
+clarity/src/vm/contexts.rs:1371: replace Environment<'a, 'b, 'hooks>::stx_transfer -> Result<Value> with Ok(Default::default())
+clarity/src/vm/functions/arithmetic.rs:364: replace native_xor -> InterpreterResult<Value> with InterpreterResult::new()
+clarity/src/vm/ast/parser/v1.rs:728: replace parse_no_stack_limit -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::new(vec![])
+clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs:614: replace check_secp256k1_recover -> TypeResult with Default::default()
+clarity/src/vm/functions/assets.rs:676: replace special_transfer_token -> Result<Value> with Ok(Default::default())
+clarity/src/mod.rs:73: replace boot_util::boot_code_id -> QualifiedContractIdentifier with Default::default()
+clarity/src/vm/ast/mod.rs:309: replace build_ast -> ParseResult<ContractAST> with ParseResult::new()
+clarity/src/vm/analysis/read_only_checker/mod.rs:430: replace ReadOnlyChecker<'a, 'b>::check_expression_application_is_read_only -> CheckResult<bool> with CheckResult::from(true)
+clarity/src/vm/types/signatures.rs:1349: replace TypeSignature::construct_parent_list_type -> Result<ListTypeData> with Ok(Default::default())
+clarity/src/vm/analysis/analysis_db.rs:208: replace AnalysisDatabase<'a>::get_implemented_traits -> CheckResult<BTreeSet<TraitIdentifier>> with CheckResult::new(BTreeSet::new())
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:136: replace ContractContext::add_variable_type -> CheckResult<()> with CheckResult::from(())
+clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs:156: replace check_special_fold -> TypeResult with Default::default()
+clarity/src/vm/ast/mod.rs:174: replace inner_build_ast -> ParseResult<(ContractAST, Vec<Diagnostic>, bool)> with ParseResult::from_iter([(Default::default(), vec![], true)])
+clarity/src/vm/functions/arithmetic.rs:52: replace ASCIIOps::make_value -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
+clarity/src/vm/test_util/mod.rs:57: replace execute -> Value with Default::default()
+clarity/src/vm/ast/parser/v2/mod.rs:283: replace Parser<'a>::handle_open_tuple -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::from(Some(Default::default()))
+clarity/src/vm/ast/parser/v2/mod.rs:1109: replace parse_collect_diagnostics -> (Vec<PreSymbolicExpression>, Vec<Diagnostic>, bool) with (vec![], vec![Default::default()], true)
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:152: replace ContractContext::add_ft -> CheckResult<()> with CheckResult::new(())
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:474: replace Lexer<'a>::read_utf8_encoding -> LexResult<Result<String, String>> with LexResult::new(Ok("xyzzy".into()))
+clarity/src/vm/functions/arithmetic.rs:554: replace native_add -> InterpreterResult<Value> with InterpreterResult::new()
+clarity/src/vm/tests/mod.rs:126: replace env_factory -> MemoryEnvironmentGenerator with Default::default()
+clarity/src/vm/representations.rs:541: replace SymbolicExpression::list -> SymbolicExpression with Default::default()
+clarity/src/vm/database/clarity_db.rs:1279: replace ClarityDatabase<'a>::load_map -> Result<DataMapMetadata> with Ok(Default::default())
+clarity/src/vm/ast/parser/v2/mod.rs:807: replace Parser<'a>::parse_node -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::from_iter([Some(Default::default())])
+clarity/src/vm/analysis/analysis_db.rs:137: replace AnalysisDatabase<'a>::get_clarity_version -> CheckResult<ClarityVersion> with CheckResult::from_iter([Default::default()])
+clarity/src/vm/functions/arithmetic.rs:546: replace special_less -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
+clarity/src/vm/analysis/read_only_checker/mod.rs:244: replace ReadOnlyChecker<'a, 'b>::check_each_expression_is_read_only -> CheckResult<bool> with CheckResult::from(false)
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:152: replace ContractContext::add_ft -> CheckResult<()> with CheckResult::from(())
+clarity/src/vm/errors.rs:169: replace <impl From for Error>::from -> Self with Default::default()
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:140: replace Lexer<'a>::read_line -> LexResult<String> with LexResult::from_iter(["xyzzy".into()])
+clarity/src/vm/ast/parser/v1.rs:455: replace lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::new(vec![(Default::default(), 1, 1)])
+clarity/src/vm/analysis/type_checker/mod.rs:45: replace FunctionType::check_args -> CheckResult<TypeSignature> with CheckResult::new()
+clarity/src/vm/analysis/type_checker/v2_1/natives/options.rs:381: replace check_special_match -> TypeResult with Default::default()
+clarity/src/vm/ast/traits_resolver/mod.rs:201: replace TraitsResolver::probe_for_generics -> ParseResult<()> with ParseResult::new()
+clarity/src/vm/ast/parser/v1.rs:455: replace lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::new(vec![(Default::default(), 0, 1)])
+clarity/src/vm/analysis/analysis_db.rs:171: replace AnalysisDatabase<'a>::get_read_only_function_type -> CheckResult<Option<FunctionType>> with CheckResult::from(Some(Default::default()))
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:66: replace Lexer<'a>::add_diagnostic -> LexResult<()> with LexResult::new(())
+clarity/src/vm/database/clarity_db.rs:472: replace ClarityDatabase<'a>::get -> Option<T> with Some(Default::default())
+clarity/src/vm/types/signatures.rs:978: replace TypeSignature::max_string_ascii -> TypeSignature with Default::default()
+clarity/src/vm/types/mod.rs:96: replace QualifiedContractIdentifier::local -> Result<QualifiedContractIdentifier> with Ok(Default::default())
+clarity/src/vm/types/mod.rs:1227: replace ASCIIData::len -> BufferLength with Default::default()
+clarity/src/vm/ast/mod.rs:103: replace build_ast_with_rules -> ParseResult<ContractAST> with ParseResult::new(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:308: replace ContractContext::get_map_type -> Option<&(TypeSignature, TypeSignature)> with Some(&(Default::default(), Default::default()))
+clarity/src/vm/types/serialization.rs:535: replace Value::deserialize_read_count -> Result<(Value, u64), SerializationError> with Ok((Default::default(), 1))
+clarity/src/vm/representations.rs:320: replace PreSymbolicExpression::list -> PreSymbolicExpression with Default::default()
+clarity/src/vm/ast/parser/v1.rs:192: replace inner_lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::from_iter([vec![(Default::default(), 0, 1)]])
+clarity/src/vm/ast/parser/v1.rs:508: replace parse_lexed -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::new(vec![])
+clarity/src/vm/ast/stack_depth_checker.rs:74: replace <impl BuildASTPass for VaryStackDepthChecker>::run_pass -> ParseResult<()> with ParseResult::new()
+clarity/src/vm/database/clarity_store.rs:193: replace <impl ClarityDeserializable for ContractCommitment>::deserialize -> ContractCommitment with Default::default()
+clarity/src/vm/analysis/type_checker/v2_05/natives/assets.rs:167: replace check_special_transfer_token -> TypeResult with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1398: replace TypeChecker<'a, 'b>::type_check_define_trait -> CheckResult<(ClarityName, BTreeMap<ClarityName, FunctionSignature>)> with CheckResult::new((Default::default(), BTreeMap::new()))
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:140: replace Lexer<'a>::read_line -> LexResult<String> with LexResult::from_iter([String::new()])
+clarity/src/vm/analysis/read_only_checker/mod.rs:268: replace ReadOnlyChecker<'a, 'b>::try_check_native_function_is_read_only -> Option<CheckResult<bool>> with Some(CheckResult::new(false))
+clarity/src/vm/functions/arithmetic.rs:546: replace special_less -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
+clarity/src/vm/costs/mod.rs:136: replace <impl CostTracker for ()>::compute_cost -> std::result::Result<ExecutionCost, CostErrors> with Ok(Default::default())
+clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs:134: replace check_special_get -> TypeResult with Default::default()
+clarity/src/vm/ast/parser/v1.rs:192: replace inner_lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::new(vec![(Default::default(), 1, 0)])
+clarity/src/vm/functions/conversions.rs:185: replace native_int_to_string_generic -> Result<Value> with Ok(Default::default())
+clarity/src/vm/ast/traits_resolver/mod.rs:48: replace TraitsResolver::run -> ParseResult<()> with ParseResult::new()
+clarity/src/vm/functions/database.rs:374: replace special_fetch_entry_v200 -> Result<Value> with Ok(Default::default())
+clarity/src/vm/analysis/type_checker/v2_05/natives/sequences.rs:39: replace get_simple_native_or_user_define -> CheckResult<FunctionType> with CheckResult::new(Default::default())
+clarity/src/vm/database/structures.rs:368: replace STXBalanceSnapshot<'db, 'conn>::canonical_balance_repr -> STXBalance with Default::default()
+clarity/src/vm/analysis/read_only_checker/mod.rs:112: replace ReadOnlyChecker<'a, 'b>::check_top_level_expression -> CheckResult<()> with CheckResult::from(())
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:808: replace TypeChecker<'a, 'b>::try_type_check_define -> CheckResult<Option<()>> with CheckResult::new(None)
+clarity/src/vm/analysis/mod.rs:50: replace mem_type_check -> CheckResult<(Option<TypeSignature>, ContractAnalysis)> with CheckResult::from((Some(Default::default()), Default::default()))
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:116: replace ContractContext::add_private_function_type -> CheckResult<()> with CheckResult::new(())
+clarity/src/vm/functions/assets.rs:193: replace special_stx_transfer_memo -> Result<Value> with Ok(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/natives/options.rs:281: replace eval_with_new_binding -> TypeResult with Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs:448: replace check_special_replace_at -> TypeResult with Default::default()
+clarity/src/vm/ast/parser/v2/mod.rs:807: replace Parser<'a>::parse_node -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::from(None)
+clarity/src/vm/analysis/analysis_db.rs:153: replace AnalysisDatabase<'a>::get_public_function_type -> CheckResult<Option<FunctionType>> with CheckResult::from(None)
+clarity/src/vm/database/key_value_wrapper.rs:338: replace RollbackWrapper<'a>::set_block_hash -> InterpreterResult<StacksBlockId> with InterpreterResult::from(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1039: replace TypeChecker<'a, 'b>::type_check_function_type -> TypeResult with Default::default()
+clarity/src/vm/analysis/analysis_db.rs:153: replace AnalysisDatabase<'a>::get_public_function_type -> CheckResult<Option<FunctionType>> with CheckResult::new(None)
+clarity/src/vm/contexts.rs:652: replace OwnedEnvironment<'a, 'hooks>::execute_in_env -> std::result::Result<(A, AssetMap, Vec<StacksTransactionEvent>), E> with Ok((Default::default(), Default::default(), vec![Default::default()]))
+clarity/src/vm/functions/assets.rs:809: replace special_get_owner_v200 -> Result<Value> with Ok(Default::default())
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:210: replace Lexer<'a>::read_identifier -> LexResult<Token> with LexResult::from(Default::default())
+clarity/src/vm/functions/arithmetic.rs:381: replace native_bitwise_not -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:62: replace TraitContext::add_defined_trait -> CheckResult<()> with CheckResult::new(())
+clarity/src/vm/contexts.rs:490: replace AssetMap::get_nonfungible_tokens -> Option<&Vec<Value>> with Some(&vec![Default::default()])
+clarity/src/vm/ast/mod.rs:87: replace ast_check_size -> ParseResult<ContractAST> with ParseResult::new()
+clarity/src/vm/types/mod.rs:951: replace Value::buff_from_byte -> Value with Default::default()
+clarity/src/vm/types/signatures.rs:498: replace TypeSignature::new_response -> Result<TypeSignature> with Ok(Default::default())
+clarity/src/vm/analysis/read_only_checker/mod.rs:268: replace ReadOnlyChecker<'a, 'b>::try_check_native_function_is_read_only -> Option<CheckResult<bool>> with Some(CheckResult::from_iter([false]))
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:247: replace FunctionType::check_args_by_allowing_trait_cast_2_05 -> CheckResult<TypeSignature> with CheckResult::from_iter([Default::default()])
+clarity/src/vm/ast/traits_resolver/mod.rs:182: replace TraitsResolver::try_parse_pre_expr -> Option<(DefineFunctions, Vec<&'a PreSymbolicExpression>)> with Some((Default::default(), vec![]))
+clarity/src/vm/functions/assets.rs:894: replace special_get_token_supply -> Result<Value> with Ok(Default::default())
+clarity/src/vm/ast/parser/v2/mod.rs:687: replace Parser<'a>::read_sugared_principal -> ParseResult<PreSymbolicExpression> with ParseResult::from(Default::default())
+clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1055: replace TypeChecker<'a, 'b>::type_check_define_function -> CheckResult<(ClarityName, FixedFunction)> with CheckResult::from((Default::default(), Default::default()))
+clarity/src/vm/functions/arithmetic.rs:59: replace UTF8Ops::make_value -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
+clarity/src/vm/database/clarity_db.rs:209: replace <impl BurnStateDB for &dyn BurnStateDB>::get_sortition_id_from_consensus_hash -> Option<SortitionId> with Some(Default::default())
+clarity/src/vm/functions/assets.rs:98: replace special_stx_balance -> Result<Value> with Ok(Default::default())
+clarity/src/vm/ast/parser/v2/mod.rs:521: replace Parser<'a>::read_principal -> ParseResult<PreSymbolicExpression> with ParseResult::from_iter([Default::default()])
+clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:106: replace ContractContext::add_read_only_function_type -> CheckResult<()> with CheckResult::from(())
+clarity/src/vm/database/clarity_db.rs:1957: replace ClarityDatabase<'a>::get_stacks_epoch -> Option<StacksEpoch> with Some(Default::default())
+clarity/src/vm/functions/conversions.rs:113: replace native_buff_to_uint_be -> Result<Value> with Ok(Default::default())
+clarity/src/vm/analysis/read_only_checker/mod.rs:430: replace ReadOnlyChecker<'a, 'b>::check_expression_application_is_read_only -> CheckResult<bool> with CheckResult::from_iter([false])
+clarity/src/vm/variables.rs:63: replace lookup_reserved_variable -> Result<Option<Value>> with Ok(Some(Default::default()))
+clarity/src/vm/database/clarity_store.rs:235: replace <impl ClarityBackingStore for NullBackingStore>::get_side_store -> &Connection with &Default::default()
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:292: replace ContractContext::add_used_trait -> CheckResult<()> with CheckResult::new()
+clarity/src/vm/types/signatures.rs:1417: replace TypeSignature::parse_buff_type_repr -> Result<TypeSignature> with Ok(Default::default())
+clarity/src/vm/types/serialization.rs:1127: replace Value::try_deserialize_bytes_untyped -> Result<Value, SerializationError> with Ok(Default::default())
+clarity/src/vm/analysis/types.rs:190: replace ContractAnalysis::get_defined_trait -> Option<&BTreeMap<ClarityName, FunctionSignature>> with Some(&BTreeMap::new())
+clarity/src/vm/analysis/type_checker/v2_05/mod.rs:808: replace TypeChecker<'a, 'b>::try_type_check_define -> CheckResult<Option<()>> with CheckResult::from_iter([Some(())])
+clarity/src/vm/ast/mod.rs:69: replace parse_in_epoch -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::new()
+clarity/src/vm/types/signatures.rs:966: replace TypeSignature::min_string_ascii -> TypeSignature with Default::default()
+clarity/src/vm/analysis/type_checker/v2_05/natives/options.rs:32: replace check_special_okay -> TypeResult with Default::default()
+clarity/src/vm/functions/arithmetic.rs:52: replace ASCIIOps::make_value -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
+clarity/src/vm/functions/arithmetic.rs:377: replace native_bitwise_or -> InterpreterResult<Value> with InterpreterResult::new()
+clarity/src/vm/ast/expression_identifier/mod.rs:23: replace inner_relabel -> ParseResult<u64> with ParseResult::from(1)
+clarity/src/vm/database/clarity_db.rs:937: replace ClarityDatabase<'a>::get_pox_payout_addrs_for_burnchain_height -> Option<(Vec<TupleData>, u128)> with Some((vec![Default::default()], 0))
+clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:269: replace ContractContext::add_nft -> CheckResult<()> with CheckResult::new()
+clarity/src/vm/ast/parser/v2/lexer/mod.rs:575: replace Lexer<'a>::read_utf8_string -> LexResult<Token> with LexResult::from_iter([Default::default()])
diff --git a/mutation-testing/packages-output/pox-locking/caught.txt b/mutation-testing/packages-output/pox-locking/caught.txt
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/mutation-testing/packages-output/pox-locking/missed.txt b/mutation-testing/packages-output/pox-locking/missed.txt
new file mode 100644
index 0000000000..1151cd78b6
--- /dev/null
+++ b/mutation-testing/packages-output/pox-locking/missed.txt
@@ -0,0 +1,28 @@
+pox-locking/src/pox_1.rs:90: replace pox_lock_v1 -> Result<(), LockingError> with Ok(())
+pox-locking/src/pox_3.rs:355: replace handle_contract_call -> Result<(), ClarityError> with Ok(())
+pox-locking/src/pox_2.rs:217: replace pox_lock_extend_v2 -> Result<u128, LockingError> with Ok(0)
+pox-locking/src/pox_2.rs:33: replace is_read_only -> bool with true
+pox-locking/src/pox_3.rs:292: replace handle_stack_lockup_increase_pox_v3 -> Result<Option<StacksTransactionEvent>, ClarityError> with Ok(None)
+pox-locking/src/pox_1.rs:69: replace is_read_only -> bool with true
+pox-locking/src/pox_1.rs:128: replace handle_contract_call -> Result<(), ClarityError> with Ok(())
+pox-locking/src/pox_2.rs:473: replace handle_contract_call -> Result<(), ClarityError> with Ok(())
+pox-locking/src/events.rs:76: replace create_event_info_aggregation_code -> String with String::new()
+pox-locking/src/pox_2.rs:345: replace handle_stack_lockup_extension_pox_v2 -> Result<Option<StacksTransactionEvent>, ClarityError> with Ok(None)
+pox-locking/src/pox_2.rs:409: replace handle_stack_lockup_increase_pox_v2 -> Result<Option<StacksTransactionEvent>, ClarityError> with Ok(None)
+pox-locking/src/pox_2.rs:217: replace pox_lock_extend_v2 -> Result<u128, LockingError> with Ok(1)
+pox-locking/src/events.rs:103: replace create_event_info_data_code -> String with String::new()
+pox-locking/src/pox_3.rs:79: replace pox_lock_extend_v3 -> Result<u128, LockingError> with Ok(0)
+pox-locking/src/pox_2.rs:280: replace handle_stack_lockup_pox_v2 -> Result<Option<StacksTransactionEvent>, ClarityError> with Ok(None)
+pox-locking/src/events.rs:47: replace create_event_info_stack_or_delegate_code -> String with "xyzzy".into()
+pox-locking/src/events.rs:76: replace create_event_info_aggregation_code -> String with "xyzzy".into()
+pox-locking/src/pox_3.rs:161: replace handle_stack_lockup_pox_v3 -> Result<Option<StacksTransactionEvent>, ClarityError> with Ok(None)
+pox-locking/src/events.rs:351: replace synthesize_pox_2_or_3_event_info -> Result<Option<Value>, ClarityError> with Ok(None)
+pox-locking/src/pox_3.rs:42: replace pox_lock_v3 -> Result<(), LockingError> with Ok(())
+pox-locking/src/pox_1.rs:69: replace is_read_only -> bool with false
+pox-locking/src/events.rs:103: replace create_event_info_data_code -> String with "xyzzy".into()
+pox-locking/src/pox_3.rs:228: replace handle_stack_lockup_extension_pox_v3 -> Result<Option<StacksTransactionEvent>, ClarityError> with Ok(None)
+pox-locking/src/pox_2.rs:248: replace pox_lock_v2 -> Result<(), LockingError> with Ok(())
+pox-locking/src/pox_3.rs:79: replace pox_lock_extend_v3 -> Result<u128, LockingError> with Ok(1)
+pox-locking/src/pox_2.rs:33: replace is_read_only -> bool with false
+pox-locking/src/lib.rs:65: replace handle_contract_call_special_cases -> Result<(), ClarityError> with Ok(())
+pox-locking/src/events.rs:47: replace create_event_info_stack_or_delegate_code -> String with String::new()
diff --git a/mutation-testing/packages-output/pox-locking/timeout.txt b/mutation-testing/packages-output/pox-locking/timeout.txt
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/mutation-testing/packages-output/pox-locking/unviable.txt b/mutation-testing/packages-output/pox-locking/unviable.txt
new file mode 100644
index 0000000000..5d9b53f3eb
--- /dev/null
+++ b/mutation-testing/packages-output/pox-locking/unviable.txt
@@ -0,0 +1,22 @@
+pox-locking/src/pox_2.rs:127: replace parse_pox_increase -> std::result::Result<(PrincipalData, u128), i128> with Ok((Default::default(), 1))
+pox-locking/src/pox_2.rs:164: replace pox_lock_increase_v2 -> Result<STXBalance, LockingError> with Ok(Default::default())
+pox-locking/src/pox_2.rs:64: replace parse_pox_stacking_result -> std::result::Result<(PrincipalData, u128, u64), i128> with Ok((Default::default(), 1, 1))
+pox-locking/src/pox_3.rs:228: replace handle_stack_lockup_extension_pox_v3 -> Result<Option<StacksTransactionEvent>, ClarityError> with Ok(Some(Default::default()))
+pox-locking/src/pox_3.rs:115: replace pox_lock_increase_v3 -> Result<STXBalance, LockingError> with Ok(Default::default())
+pox-locking/src/pox_1.rs:36: replace parse_pox_stacking_result_v1 -> std::result::Result<(PrincipalData, u128, u64), i128> with Ok((Default::default(), 0, 0))
+pox-locking/src/pox_2.rs:409: replace handle_stack_lockup_increase_pox_v2 -> Result<Option<StacksTransactionEvent>, ClarityError> with Ok(Some(Default::default()))
+pox-locking/src/pox_2.rs:64: replace parse_pox_stacking_result -> std::result::Result<(PrincipalData, u128, u64), i128> with Ok((Default::default(), 1, 0))
+pox-locking/src/pox_2.rs:127: replace parse_pox_increase -> std::result::Result<(PrincipalData, u128), i128> with Ok((Default::default(), 0))
+pox-locking/src/pox_3.rs:161: replace handle_stack_lockup_pox_v3 -> Result<Option<StacksTransactionEvent>, ClarityError> with Ok(Some(Default::default()))
+pox-locking/src/pox_2.rs:345: replace handle_stack_lockup_extension_pox_v2 -> Result<Option<StacksTransactionEvent>, ClarityError> with Ok(Some(Default::default()))
+pox-locking/src/events.rs:351: replace synthesize_pox_2_or_3_event_info -> Result<Option<Value>, ClarityError> with Ok(Some(Default::default()))
+pox-locking/src/pox_2.rs:280: replace handle_stack_lockup_pox_v2 -> Result<Option<StacksTransactionEvent>, ClarityError> with Ok(Some(Default::default()))
+pox-locking/src/pox_3.rs:292: replace handle_stack_lockup_increase_pox_v3 -> Result<Option<StacksTransactionEvent>, ClarityError> with Ok(Some(Default::default()))
+pox-locking/src/pox_2.rs:64: replace parse_pox_stacking_result -> std::result::Result<(PrincipalData, u128, u64), i128> with Ok((Default::default(), 0, 0))
+pox-locking/src/pox_2.rs:64: replace parse_pox_stacking_result -> std::result::Result<(PrincipalData, u128, u64), i128> with Ok((Default::default(), 0, 1))
+pox-locking/src/pox_1.rs:36: replace parse_pox_stacking_result_v1 -> std::result::Result<(PrincipalData, u128, u64), i128> with Ok((Default::default(), 1, 1))
+pox-locking/src/pox_1.rs:36: replace parse_pox_stacking_result_v1 -> std::result::Result<(PrincipalData, u128, u64), i128> with Ok((Default::default(), 1, 0))
+pox-locking/src/events.rs:32: replace get_stacker -> Value with Default::default()
+pox-locking/src/pox_1.rs:36: replace parse_pox_stacking_result_v1 -> std::result::Result<(PrincipalData, u128, u64), i128> with Ok((Default::default(), 0, 1))
+pox-locking/src/pox_2.rs:98: replace parse_pox_extend_result -> std::result::Result<(PrincipalData, u64), i128> with Ok((Default::default(), 1))
+pox-locking/src/pox_2.rs:98: replace parse_pox_extend_result -> std::result::Result<(PrincipalData, u64), i128> with Ok((Default::default(), 0))
diff --git a/mutation-testing/packages-output/stx-genesis/caught.txt b/mutation-testing/packages-output/stx-genesis/caught.txt
new file mode 100644
index 0000000000..26e704cf83
--- /dev/null
+++ b/mutation-testing/packages-output/stx-genesis/caught.txt
@@ -0,0 +1 @@
+stx-genesis/src/lib.rs:100: replace <impl Iterator for LinePairReader>::next -> Option<Self::Item> with Some(Default::default())
diff --git a/mutation-testing/packages-output/stx-genesis/missed.txt b/mutation-testing/packages-output/stx-genesis/missed.txt
new file mode 100644
index 0000000000..d5f5500801
--- /dev/null
+++ b/mutation-testing/packages-output/stx-genesis/missed.txt
@@ -0,0 +1 @@
+stx-genesis/src/lib.rs:100: replace <impl Iterator for LinePairReader>::next -> Option<Self::Item> with None
diff --git a/mutation-testing/packages-output/stx-genesis/timeout.txt b/mutation-testing/packages-output/stx-genesis/timeout.txt
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/mutation-testing/packages-output/stx-genesis/unviable.txt b/mutation-testing/packages-output/stx-genesis/unviable.txt
new file mode 100644
index 0000000000..7c35ac7a7f
--- /dev/null
+++ b/mutation-testing/packages-output/stx-genesis/unviable.txt
@@ -0,0 +1,11 @@
+stx-genesis/src/lib.rs:167: replace read_names -> Box<dyn Iterator<Item = GenesisName>> with Box::new(Default::default())
+stx-genesis/src/lib.rs:136: replace read_balances -> Box<dyn Iterator<Item = GenesisAccountBalance>> with Box::new(Default::default())
+stx-genesis/src/lib.rs:125: replace iter_deflated_csv -> Box<dyn Iterator<Item = Vec<String>>> with Box::new(Default::default())
+stx-genesis/src/lib.rs:111: replace read_deflated_zonefiles -> Box<dyn Iterator<Item = GenesisZonefile>> with Box::new(Default::default())
+stx-genesis/src/lib.rs:153: replace read_namespaces -> Box<dyn Iterator<Item = GenesisNamespace>> with Box::new(Default::default())
+stx-genesis/src/lib.rs:57: replace GenesisData::read_balances -> Box<dyn Iterator<Item = GenesisAccountBalance>> with Box::new(Default::default())
+stx-genesis/src/lib.rs:64: replace GenesisData::read_lockups -> Box<dyn Iterator<Item = GenesisAccountLockup>> with Box::new(Default::default())
+stx-genesis/src/lib.rs:78: replace GenesisData::read_names -> Box<dyn Iterator<Item = GenesisName>> with Box::new(Default::default())
+stx-genesis/src/lib.rs:144: replace read_lockups -> Box<dyn Iterator<Item = GenesisAccountLockup>> with Box::new(Default::default())
+stx-genesis/src/lib.rs:71: replace GenesisData::read_namespaces -> Box<dyn Iterator<Item = GenesisNamespace>> with Box::new(Default::default())
+stx-genesis/src/lib.rs:85: replace GenesisData::read_name_zonefiles -> Box<dyn Iterator<Item = GenesisZonefile>> with Box::new(Default::default())
diff --git a/mutation-testing/scripts/README.md b/mutation-testing/scripts/README.md
new file mode 100644
index 0000000000..66a0efb4cf
--- /dev/null
+++ b/mutation-testing/scripts/README.md
@@ -0,0 +1,38 @@
+## steps to reproduce working version with different number lines:
+
+in trials/mutants-stable/caught.txt replace line number 23 with 109
+the append.sh won't work anymore
+the append-match.sh works
+
+```bash
+sh append-match.sh
+
+```
+
+example run:
+
+```bash
+./modular-mutants-run.sh stx-genesis lib.rs test_this init_ next as.rs ab cd ef clarity lib.rs stacks-node
+# the command above makes and runs 579 mutants on these regex matches:
+
+# functions named 'test_this', 'init_' and 'next' (everything that starts with any of the given names) from 'lib.rs' file of 'stx-genesis' package (5 mutants)
+stx-genesis/[^/]+/lib.rs.*(?:test_this|init_|next).*->
+
+# functions that start with 'ab', 'cd' or 'ef' from files named 'as.rs' of 'stx-genesis' package (0 mutants)
+stx-genesis/[^/]+/as.rs.*(?:ab|cd|ef).*->
+
+# all functions from 'lib.rs' files of the 'clarity' package (4 mutants)
+clarity/[^/]+/lib.rs.*(?:).*->
+
+# all functions from all files of 'stacks-node' package (570 mutants)
+stacks-node/[^/]+/.*(?:).*->
+```
+
+# Create Stable
+
+Only run it once and the packages that should be updated from zero. Then it will be the reference point for the upcoming PRs that modify these functions
+
+### recap flow for a developer which
+
+1. works on functions and modifies them
+2. before commiting -> `call git-diff.sh`
diff --git a/mutation-testing/scripts/append-match-package.sh b/mutation-testing/scripts/append-match-package.sh
new file mode 100644
index 0000000000..9026cfc563
--- /dev/null
+++ b/mutation-testing/scripts/append-match-package.sh
@@ -0,0 +1,68 @@
+#!/bin/bash
+
+# the append-match-package.sh
+## goes through each line in the output and based on the package ( first element before /)
+### verifies the line with the other lines in that specific folder
+#### in our case folder_name == package_name
+
+
+# goes through each PR file line by line
+# for each first_element/the_rest_of_the_line goes through it
+## search in that specific folder on all 4 files
+## if it is matchy, remove it from that file
+## based on the file it was taken from, append it to the same file in the STABLE folder
+
+
+PR_FOLDER="../temp/mutants.out"
+STABLE_FOLDER_PARENT="../packages-output"
+FILES=("caught.txt" "missed.txt" "timeout.txt" "unviable.txt")
+
+echo "Starting script..."
+echo "PR Folder: $PR_FOLDER"
+echo "STABLE Folder: $STABLE_FOLDER_PARENT"
+echo "Files to process: ${FILES[*]}"
+
+# Iterate over the specified files
+for file in "${FILES[@]}"; do
+    pr_file="$PR_FOLDER/$file"
+
+    echo "Processing file: $file"
+
+    # Check if PR file exists and is not empty
+    if [[ -s "$pr_file" ]]; then
+        # Read each line from the PR file
+        while IFS= read -r line; do
+            echo "Reading line from PR file: $line"
+
+            # Extract the package from which the line is coming from
+            local_package=${line%%/*}
+
+            # Extract the after the number line without the line number and escape it for awk
+            # Escape the variables for use in a sed pattern
+            var_1=$(echo "$line" | sed -E 's/^(.+):[0-9]+:[^:]+/\1/')
+            escaped_var_1=$(sed 's/[][/.^$]/\\&/g' <<< "$var_1")
+
+            var_2=$(echo "$line" | sed -E 's/^[^:]+:[0-9]+:(.+)/\1/')
+            escaped_var_2=$(sed 's/[][/.^$]/\\&/g' <<< "$var_2")
+
+            regex="${escaped_var_1}.*${escaped_var_2}"
+
+            # Iterate over each file in the STABLE folder combined with local_package
+            for target_file in "${FILES[@]}"; do
+                target_path="$STABLE_FOLDER_PARENT/$local_package/$target_file"
+                echo "Checking against STABLE file: $target_path"
+
+                # Use sed to remove lines matching the pattern
+                sed "/$regex/d" "$target_path" > temp_file && mv temp_file "$target_path"
+            done
+
+            # Append PR line to the corresponding package and file
+            echo "$line" >> "$STABLE_FOLDER_PARENT/$local_package/$file"
+            
+        done < "$pr_file"
+    else
+        echo "PR file $pr_file is empty or does not exist, skipping..."
+    fi
+done
+
+echo "Script completed."
diff --git a/mutation-testing/scripts/create-stable.sh b/mutation-testing/scripts/create-stable.sh
new file mode 100644
index 0000000000..1659714ed0
--- /dev/null
+++ b/mutation-testing/scripts/create-stable.sh
@@ -0,0 +1,55 @@
+# for specific packages creates the outpup
+
+# removes everything except .txt files
+
+#!/bin/bash
+
+# moves to mutation-testing folder
+cd ../packages-output
+
+### Run mutation testing on the packages uncommented
+
+# Run mutation testing for stx-genesis package
+cargo mutants --package stx-genesis --output stx-genesis
+mv stx-genesis/mutants.out/*.txt stx-genesis/
+rm -rf stx-genesis/mutants.out
+
+# Run mutation testing for pox-locking package
+cargo mutants --package pox-locking --output pox-locking
+mv pox-locking/mutants.out/*.txt pox-locking/
+rm -rf pox-locking/mutants.out
+
+# # Run mutation testing for libsigner package
+# cargo mutants --package libsigner --output libsigner
+# mv libsigner/mutants.out/*.txt libsigner/
+# rm -rf libsigner/mutants.out
+
+# # Run mutation testing for libstackerdb package
+# cargo mutants --package libstackerdb --output libstackerdb
+# mv libstackerdb/mutants.out/*.txt libstackerdb/
+# rm -rf libstackerdb/mutants.out
+
+# # Run mutation testing for stacks-common package
+# cargo mutants --package stacks-common --output stacks-common
+# mv stacks-common/mutants.out/*.txt stacks-common/
+# rm -rf stacks-common/mutants.out
+
+# # Run mutation testing for clarity package
+# cargo mutants --package clarity --output clarity
+# mv clarity/mutants.out/*.txt clarity/
+# rm -rf clarity/mutants.out
+
+# Run mutation testing for stacks-signer package - working, 10 min approx. 
+# cargo mutants --package stacks-signer --output stacks-signer
+# mv stacks-signer/mutants.out/*.txt stacks-signer/
+# rm -rf stacks-signer/mutants.out
+
+# Commented out mutation testing for stacks-node package due to test errors and long compile/testing time
+# cargo mutants --package stacks-node --output stacks-node
+# mv stacks-node/mutants.out/*.txt stacks-node/
+# rm -rf stacks-node/mutants.out
+
+# Commented out mutation testing for stackslib package due to long compile/testing time
+# cargo mutants --package stackslib --output stackslib
+# mv stackslib/mutants.out/*.txt stackslib/
+# rm -rf stackslib/mutants.out
\ No newline at end of file
diff --git a/mutation-testing/scripts/git-diff.sh b/mutation-testing/scripts/git-diff.sh
new file mode 100755
index 0000000000..256db10290
--- /dev/null
+++ b/mutation-testing/scripts/git-diff.sh
@@ -0,0 +1,35 @@
+# script that makes .git for the differences
+# it saves the .git on scripts folder
+
+# add untracked files to git diff
+# go to root folder
+cd ./../..
+
+# run git status on root
+untracked_files=($(git ls-files --others --exclude-standard))
+
+# for each file untracked -> run git add file path
+echo "${untracked_files[@]}"
+for file in "${untracked_files[@]}"; do
+  git add -N "$file"
+done
+
+cd mutation-testing
+
+
+# run from mutation-testing folder
+git diff > git.diff
+
+# it runs cargo mutants for those specific changed functions and outputs to /temp/mutants.out
+# for faster builds: increase number to 4 if at least 16 gb ram and 6 cores CPU
+cargo mutants --no-shuffle -j 2 -vV --in-diff git.diff --output temp/
+
+# go to scripts folder level
+cd scripts
+
+# call append-match-package.sh to update the content from the stable output
+sh append-match-package.sh
+
+# removes extra files
+rm -rf ../git.diff
+rm -rf ../temp
diff --git a/mutation-testing/scripts/modular-mutants-run.sh b/mutation-testing/scripts/modular-mutants-run.sh
new file mode 100644
index 0000000000..c8bc357e09
--- /dev/null
+++ b/mutation-testing/scripts/modular-mutants-run.sh
@@ -0,0 +1,41 @@
+#!/bin/bash
+
+packages=$(cargo tree --workspace --prefix depth | grep "^0" | cut -c2- | awk '{print $1}')
+regex_list=()
+
+while [ $# -gt 0 ]; do
+  arg=$1
+
+  if [[ $packages == *$arg* ]]; then
+    package=$arg
+    file=""
+    shift
+    arg=$1
+  fi
+  if [[ $arg == *.rs ]]; then
+    file=$arg
+    shift
+    arg=$1
+  fi
+
+  functions=()
+  while [ $# -gt 0 ] && [[ $1 != *.rs ]] && [[ $packages != *$1* ]]; do
+    functions+=("$1")
+    shift
+  done
+
+  IFS="|"
+  functions_str="${functions[*]}"
+  IFS=""
+
+  regex="${package}/[^/]+/${file}.*?(?:${functions_str})[^-()]*(?:->|\(\))"
+  regex_list+=("$regex")
+done
+
+command="cargo mutants -vV --no-shuffle"
+
+for regex in "${regex_list[@]}"; do
+  command+=" -F \"$regex\""
+done
+
+eval "$command"
\ No newline at end of file
diff --git a/mutation-testing/testing.md b/mutation-testing/testing.md
new file mode 100644
index 0000000000..28c885b0df
--- /dev/null
+++ b/mutation-testing/testing.md
@@ -0,0 +1,65 @@
+# Mutation Testing
+
+### What is mutation testing and how does it work?
+
+Mutation testing is a technique of evaluating the effectiveness of a series of tests by introducing small changes to the code (mutations) and checking if the tests can detect these small changes.
+Cargo-mutants is an external library installed to cargo, through which you can run mutants on the code, and it consists of:
+
+- Building and testing the baseline code (no mutations).
+- If the previous step fails, no mutants are applied, since the base code fails. Otherwise, copy the code to another location, apply mutations and then run `cargo build` and `cargo test` commands for each mutation.
+
+### Install and run
+
+In order to install cargo-mutants crate:
+
+```
+cargo install --locked cargo-mutants
+```
+
+In order to run mutated tests:
+
+```bash
+# In the whole workspace
+cargo mutants
+# Only in the 'clarity' package
+cargo mutants --package clarity
+# In files named 'signatures.rs' from the whole workspace
+cargo mutants -f signatures.rs
+# Only in files named 'signatures.rs' only from the 'clarity' package
+cargo mutants --package clarity -f signatures.rs
+# From all files except the ones named 'signatures.rs' and 'lib.rs' from the whole workspace
+cargo mutants -e signatures.rs -e lib.rs
+# Output from 'clarity' package to a specific directory in the workspace
+cargo mutants --package clarity --output mutants/clarity
+# To list all the possible mutants
+cargo mutants --list
+# To list all the files with possible mutants:
+cargo mutants --list-files
+```
+
+In order to exclude a function from being mutated, parse the `#[mutants::skip]` attribute above it.
+
+### Reading the output
+
+There are 2 places where the progress of mutations are shown: terminal and [output folders](https://mutants.rs/mutants-out.html).
+The terminal shows information about the progress of the mutants:
+
+- How many mutants out of the total were tested (`1274/2912 mutants tested, 44% done`).
+- Mutants status so far (`280 missed, 209 caught, 799 unviable`).
+- Time elapsed and remaining (`141:36 elapsed, about 168 min remaining`).
+- Tests missed so far (`clarity/src/vm/database/key_value_wrapper.rs:77: replace rollback_value_check with () ... NOT CAUGHT in 22.8s build + 17.2s test`).
+- Current job (`clarity/src/vm/ast/parser/v2/mod.rs:167: replace Parser<'a>::skip_to_end with () ... 2.1s build`)
+
+`mutants.out` - This is the folder where the mutants test output is written, and is composed of:
+
+- log - The folder of the command log, here you can find the output of the cargo build and cargo test commands for every mutation.
+- caught.txt - The file where caught mutations are logged (`clarity/src/vm/types/mod.rs:871: replace Value::size -> u32 with 1`).
+- debug.log - The output of the cargo mutants command.
+- lock.json - A file with fs2 lock on it in order to prevent 2 jobs from writing to the same directory at the same time, containing runtime information (cargo mutants version, start time, hostname, username).
+- missed.txt - Missed mutations - mutations that are successful at cargo build, not detected in tests (`clarity/src/vm/types/signatures.rs:1766: replace TupleTypeSignature::size -> u32 with 1`).
+- mutants.json - A list with every mutation applied, written before the testing begins (filename, line, return type, replacement etc).
+- outcome.json - List of outcomes for every mutation (mutant applied, log path, results for build/test phases with status and command args)
+- timeout.txt - Mutations that timed out
+- unviable.txt - Unviable mutations (When a mutation is applied and it causes the cargo build command to fail)
+
+`mutants.out.old` - This is the folder where _mutants.out_ folder’s content is copied into, on successive runs (it’s contents are being overwritten), making way for the next logs.
diff --git a/stacks-common/Cargo.toml b/stacks-common/Cargo.toml
index 863a82d53c..650446ea25 100644
--- a/stacks-common/Cargo.toml
+++ b/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"
diff --git a/stacks-common/src/libcommon.rs b/stacks-common/src/lib.rs
similarity index 100%
rename from stacks-common/src/libcommon.rs
rename to stacks-common/src/lib.rs

From ab8a906712025070fb8d86d0bde014de1fe7adc1 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Fri, 1 Dec 2023 12:21:55 -0500
Subject: [PATCH 0074/1166] chore: getters for previous mock miner's
 block-commits and blocks

---
 stackslib/src/burnchains/tests/mod.rs | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/stackslib/src/burnchains/tests/mod.rs b/stackslib/src/burnchains/tests/mod.rs
index 9aef938061..b65501d129 100644
--- a/stackslib/src/burnchains/tests/mod.rs
+++ b/stackslib/src/burnchains/tests/mod.rs
@@ -167,6 +167,15 @@ impl TestMiner {
         }
     }
 
+    pub fn block_commit_at(&self, idx: usize) -> Option<LeaderBlockCommitOp> {
+        assert!(idx < self.block_commits.len());
+        self.block_commits.get(idx).cloned()
+    }
+
+    pub fn num_block_commits(&self) -> usize {
+        self.block_commits.len()
+    }
+
     pub fn next_VRF_key(&mut self) -> VRFPrivateKey {
         let pk = if self.vrf_keys.len() == 0 {
             // first key is simply the 32-byte hash of the secret state

From 434867940623a98bdc4cb062f7c471765c2fb187 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Fri, 1 Dec 2023 12:22:27 -0500
Subject: [PATCH 0075/1166] refactor: use new matured miner reward struct

---
 stackslib/src/chainstate/nakamoto/miner.rs | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/miner.rs b/stackslib/src/chainstate/nakamoto/miner.rs
index 319efe9794..e8a06f2576 100644
--- a/stackslib/src/chainstate/nakamoto/miner.rs
+++ b/stackslib/src/chainstate/nakamoto/miner.rs
@@ -45,7 +45,7 @@ use crate::chainstate::burn::db::sortdb::{SortitionDB, SortitionDBConn, Sortitio
 use crate::chainstate::burn::operations::*;
 use crate::chainstate::burn::*;
 use crate::chainstate::nakamoto::{
-    NakamotoBlock, NakamotoBlockHeader, NakamotoChainState, SetupBlockResult,
+    MaturedMinerRewards, NakamotoBlock, NakamotoBlockHeader, NakamotoChainState, SetupBlockResult,
 };
 use crate::chainstate::stacks::address::StacksAddressExtensions;
 use crate::chainstate::stacks::db::accounts::MinerReward;
@@ -94,8 +94,7 @@ pub struct NakamotoBlockBuilder {
     /// parent block-commit hash value
     parent_commit_hash_value: BlockHeaderHash,
     /// Matured miner rewards to process, if any.
-    /// If given, this is (parent-miner-reward, this-miner-reward, reward-info)
-    matured_miner_rewards_opt: Option<(MinerReward, MinerReward, MinerRewardInfo)>,
+    matured_miner_rewards_opt: Option<MaturedMinerRewards>,
     /// bytes of space consumed so far
     bytes_so_far: u64,
     /// transactions selected
@@ -410,7 +409,6 @@ impl NakamotoBlockBuilder {
             info.parent_burn_block_height,
             info.burn_tip,
             info.burn_tip_height,
-            info.mainnet,
             info.tenure_start,
             info.tenure_height,
         )?;

From 7e47dfaebf2b92ec3bc1cabc85dba60683bc6516 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Fri, 1 Dec 2023 12:23:00 -0500
Subject: [PATCH 0076/1166] feat: implement full tenure-change validation by
 tracking highest-processed tenures and verifying that tenure-changes account
 for any missed sortitions or tenures.  This deviates from the SIP slightly --
 there is at most one TC per block, and we only distinguish between TCs that
 extend the budget and those that create new tenures.

---
 stackslib/src/chainstate/nakamoto/mod.rs | 1605 +++++++++++++++-------
 1 file changed, 1116 insertions(+), 489 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index c1a027900b..5fc5d9dd7d 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -41,9 +41,11 @@ use stacks_common::util::get_epoch_time_secs;
 use stacks_common::util::hash::{to_hex, Hash160, MerkleHashFunc, MerkleTree, Sha512Trunc256Sum};
 use stacks_common::util::retry::BoundReader;
 use stacks_common::util::secp256k1::MessageSignature;
-use stacks_common::util::vrf::{VRFProof, VRF};
+use stacks_common::util::vrf::{VRFProof, VRFPublicKey, VRF};
 
-use super::burn::db::sortdb::{get_block_commit_by_txid, SortitionHandleConn, SortitionHandleTx};
+use super::burn::db::sortdb::{
+    get_ancestor_sort_id_tx, get_block_commit_by_txid, SortitionHandleConn, SortitionHandleTx,
+};
 use super::burn::operations::{DelegateStxOp, StackStxOp, TransferStxOp};
 use super::stacks::db::accounts::MinerReward;
 use super::stacks::db::blocks::StagingUserBurnSupport;
@@ -54,12 +56,12 @@ use super::stacks::db::{
 use super::stacks::events::StacksTransactionReceipt;
 use super::stacks::{
     Error as ChainstateError, StacksBlock, StacksBlockHeader, StacksMicroblock, StacksTransaction,
-    TenureChangeError, TenureChangePayload, TransactionPayload,
+    TenureChangeCause, TenureChangePayload, TransactionPayload,
 };
 use crate::burnchains::{PoxConstants, Txid};
 use crate::chainstate::burn::db::sortdb::SortitionDB;
 use crate::chainstate::burn::operations::{LeaderBlockCommitOp, LeaderKeyRegisterOp};
-use crate::chainstate::burn::BlockSnapshot;
+use crate::chainstate::burn::{BlockSnapshot, SortitionHash};
 use crate::chainstate::coordinator::{BlockEventDispatcher, Error};
 use crate::chainstate::stacks::db::{DBConfig as ChainstateConfig, StacksChainState};
 use crate::chainstate::stacks::{MINER_BLOCK_CONSENSUS_HASH, MINER_BLOCK_HEADER_HASH};
@@ -69,7 +71,8 @@ use crate::core::BOOT_BLOCK_HASH;
 use crate::monitoring;
 use crate::net::Error as net_error;
 use crate::util_lib::db::{
-    query_row, query_row_panic, query_rows, u64_to_sql, DBConn, Error as DBError, FromRow,
+    query_int, query_row, query_row_panic, query_rows, u64_to_sql, DBConn, Error as DBError,
+    FromRow,
 };
 
 pub mod coordinator;
@@ -107,7 +110,7 @@ lazy_static! {
       CREATE TABLE nakamoto_staging_blocks (
                      -- SHA512/256 hash of this block
                      block_hash TEXT NOT NULL,
-                     -- the consensus hash of the burnchain block that selected this block's **tenure**
+                     -- the consensus hash of the burnchain block that selected this block's miner's block-commit
                      consensus_hash TEXT NOT NULL,
                      -- the parent index_block_hash
                      parent_block_id TEXT NOT NULL,
@@ -137,6 +140,34 @@ lazy_static! {
                     
                      PRIMARY KEY(block_hash,consensus_hash)
     );"#.into(),
+    r#"
+        -- Table for all processed tenures.
+        -- This represents all BlockFound tenure changes, not extensions.
+        -- Every time we insert a header which has `tenure_changed == 1`, we should insert a record into this table as well.
+        -- Note that not every sortition is represented here.  If a tenure is extended, then no new tenure record is created
+        -- for it.
+        CREATE TABLE nakamoto_tenures (
+            -- consensus hash of start-tenure block (i.e. the consensus hash of the sortition in which the miner's block-commit
+            -- was mined)
+            consensus_hash TEXT NOT NULL,
+            -- consensus hash of the previous tenure's start-tenure block
+            prev_consensus_hash TEXT NOT NULL,
+            -- block hash of start-tenure block
+            block_hash TEXT NOT NULL,
+            -- block ID of this start block (this is the StacksBlockId of the above consensus_hash and block_hash)
+            block_id TEXT NOT NULL,
+            -- this field is the total number of *tenures* in the chain history (including this tenure),
+            -- as of the _end_ of this block.  A block can contain multiple TenureChanges; if so, then this
+            -- is the height of the _last_ TenureChange.
+            tenure_height INTEGER NOT NULL,
+            -- number of blocks this tenure confirms
+            num_blocks_confirmed INTEGER NOT NULL,
+
+            PRIMARY KEY(consensus_hash)
+        );
+        CREATE INDEX nakamoto_tenures_by_block_id ON nakamoto_tenures(block_id);
+        CREATE INDEX nakamoto_tenures_by_block_and_consensus_hashes ON nakamoto_tenures(consensus_hash,block_hash);
+    "#.into(),
     r#"
       -- Table for Nakamoto block headers
       CREATE TABLE nakamoto_block_headers (
@@ -160,7 +191,7 @@ lazy_static! {
                      chain_length INTEGER NOT NULL,
                      -- this field is the total amount of BTC spent in the chain history (including this block)
                      burn_spent INTEGER NOT NULL,
-                     -- the consensus hash of the burnchain block that selected this block's tenure
+                     -- the consensus hash of the burnchain block that selected this block's miner's block-commit
                      consensus_hash TEXT NOT NULL,
                      -- the parent StacksBlockId
                      parent_block_id TEXT NOT NULL,
@@ -186,18 +217,16 @@ lazy_static! {
                      cost TEXT NOT NULL,
                      -- the total cost up to and including this block in the current tenure
                      total_tenure_cost TEXT NOT NULL,
-                     -- this field is the total number of *tenures* in the chain history (including this tenure),
-                     -- as of the _end_ of this block.  A block can contain multiple TenureChanges; if so, then this
-                     -- is the height of the _last_ TenureChange.
-                     tenure_height INTEGER NOT NULL,
                      -- this field is true if this is the first block of a new tenure
                      tenure_changed INTEGER NOT NULL,
                      -- this field tracks the total tx fees so far in this tenure. it is a text-serialized u128
                      tenure_tx_fees TEXT NOT NULL,
                      -- nakamoto block's VRF proof, if this is a tenure-start block
                      vrf_proof TEXT,
-              PRIMARY KEY(consensus_hash,block_hash)
+              PRIMARY KEY(consensus_hash,block_hash),
+              FOREIGN KEY(consensus_hash) REFERENCES nakamoto_tenures(consensus_hash)
           );
+          CREATE INDEX nakamoto_block_headers_by_consensus_hash ON nakamoto_block_headers(consensus_hash);
     "#.into(),
         format!(
             r#"ALTER TABLE payments
@@ -210,14 +239,54 @@ lazy_static! {
     ];
 }
 
+/// Matured miner reward schedules
+pub struct MaturedMinerPaymentSchedules {
+    /// miners whose rewards matured
+    pub latest_miners: Vec<MinerPaymentSchedule>,
+    /// parent to be paid (epoch2 only)
+    pub parent_miner: MinerPaymentSchedule,
+}
+
+impl MaturedMinerPaymentSchedules {
+    pub fn genesis(mainnet: bool) -> Self {
+        Self {
+            latest_miners: vec![],
+            parent_miner: MinerPaymentSchedule::genesis(mainnet),
+        }
+    }
+}
+
+/// Calculated matured miner rewards, from scheduled rewards
+pub struct MaturedMinerRewards {
+    /// this block's reward recipient
+    /// NOTE: in epoch2, if a PoisonMicroblock report was successful, then the recipient is the
+    /// reporter, not the miner.
+    pub recipient: MinerReward,
+    /// the parent block's reward.
+    /// this is all of the fees they accumulated during their tenure.
+    pub parent_reward: MinerReward,
+    /// metadata about the block miner's reward
+    pub reward_info: MinerRewardInfo,
+}
+
+impl MaturedMinerRewards {
+    /// Get the list of miner rewards this struct represents
+    pub fn consolidate(&self) -> Vec<MinerReward> {
+        let mut ret = vec![];
+        ret.push(self.recipient.clone());
+        ret.push(self.parent_reward.clone());
+        ret
+    }
+}
+
 /// Result of preparing to produce or validate a block
 pub struct SetupBlockResult<'a, 'b> {
     /// Handle to the ClarityVM
     pub clarity_tx: ClarityTx<'a, 'b>,
     /// Transaction receipts from any Stacks-on-Bitcoin transactions and epoch transition events
     pub tx_receipts: Vec<StacksTransactionReceipt>,
-    /// Miner rewards that can be paid now: (this-miner-reward, parent-miner-reward, miner-info)
-    pub matured_miner_rewards_opt: Option<(MinerReward, MinerReward, MinerRewardInfo)>,
+    /// Miner rewards that can be paid now
+    pub matured_miner_rewards_opt: Option<MaturedMinerRewards>,
     /// Epoch in which this block was set up
     pub evaluated_epoch: StacksEpochId,
     /// Whether or not we applied an epoch transition in this block
@@ -267,6 +336,22 @@ pub struct NakamotoBlock {
 
 pub struct NakamotoChainState;
 
+#[derive(Debug, Clone, PartialEq)]
+pub struct NakamotoTenure {
+    /// consensus hash of start-tenure block
+    pub consensus_hash: ConsensusHash,
+    /// consensus hash of parent tenure's start-tenure block
+    pub prev_consensus_hash: ConsensusHash,
+    /// block hash of start-tenure block
+    pub block_hash: BlockHeaderHash,
+    /// block ID of this start block
+    pub block_id: StacksBlockId,
+    /// number of tenures so far, including this one
+    pub tenure_height: u64,
+    /// number of blocks this tenure confirms
+    pub num_blocks_confirmed: u32,
+}
+
 impl FromRow<NakamotoBlockHeader> for NakamotoBlockHeader {
     fn from_row(row: &rusqlite::Row) -> Result<NakamotoBlockHeader, DBError> {
         let version = row.get("version")?;
@@ -297,6 +382,28 @@ impl FromRow<NakamotoBlockHeader> for NakamotoBlockHeader {
     }
 }
 
+impl FromRow<NakamotoTenure> for NakamotoTenure {
+    fn from_row(row: &rusqlite::Row) -> Result<NakamotoTenure, DBError> {
+        let consensus_hash = row.get("consensus_hash")?;
+        let prev_consensus_hash = row.get("prev_consensus_hash")?;
+        let block_hash = row.get("block_hash")?;
+        let block_id = row.get("block_id")?;
+        let tenure_height_i64: i64 = row.get("tenure_height")?;
+        let tenure_height = tenure_height_i64
+            .try_into()
+            .map_err(|_| DBError::ParseError)?;
+        let num_blocks_confirmed: u32 = row.get("num_blocks_confirmed")?;
+        Ok(NakamotoTenure {
+            consensus_hash,
+            prev_consensus_hash,
+            block_hash,
+            block_id,
+            tenure_height,
+            num_blocks_confirmed,
+        })
+    }
+}
+
 impl StacksMessageCodec for NakamotoBlockHeader {
     fn consensus_serialize<W: std::io::Write>(&self, fd: &mut W) -> Result<(), CodecError> {
         write_next(fd, &self.version)?;
@@ -442,76 +549,33 @@ impl NakamotoBlock {
         ret
     }
 
-    /// Does this block contain one or more well-formed and valid tenure change transactions?
-    /// Return Some(true) if it does contain at least one, and they're all valid
-    /// Return Some(false) if it does contain at least one, but at least one is invalid
-    /// Return None if it contains none.
-    pub fn tenure_changed(&self) -> Option<bool> {
-        let wellformed = self.is_wellformed_first_tenure_block();
-        if wellformed.is_none() {
-            // block isn't a first-tenure block, so no valid tenure changes
-            return None;
-        } else if let Some(false) = wellformed {
-            // this block is malformed
-            info!("Block is malformed";
-                  "block_id" => %self.block_id());
-            return Some(false);
-        }
-
-        // Find all txs that have TenureChange payload
-        let tenure_changes = self
-            .find_tenure_changes()
-            .iter()
-            .map(|i| &self.txs[*i])
-            .collect::<Vec<_>>();
+    pub fn is_first_mined(&self) -> bool {
+        self.header.is_first_mined()
+    }
 
-        if tenure_changes.len() > 1 {
-            debug!(
-                "Block contains multiple TenureChange transactions";
-                "tenure_change_txs" => tenure_changes.len(),
-                "parent_block_id" => %self.header.parent_block_id,
-                "consensus_hash" => %self.header.consensus_hash,
-            );
+    /// Get the tenure-change transaction in Nakamoto.
+    /// If it's present, then it's the first transaction (i.e. tx 0)
+    pub fn get_tenure_change_tx(&self) -> Option<&StacksTransaction> {
+        let wellformed = self.is_wellformed_tenure_start_block();
+        if let Some(false) = wellformed {
+            // block isn't well-formed
+            return None;
         }
 
-        let validate = |tc: &StacksTransaction| -> Result<(), TenureChangeError> {
-            if let TransactionPayload::TenureChange(tc) = &tc.payload {
-                if tc.previous_tenure_end != self.header.parent_block_id {
-                    return Err(TenureChangeError::PreviousTenureInvalid);
-                }
-
-                // TODO: check number of blocks in previous tenure
-                // TODO: check tenure change cause
-                tc.validate()
+        // if it exists, it's the first
+        self.txs.get(0).and_then(|tx| {
+            if let TransactionPayload::TenureChange(..) = &tx.payload {
+                Some(tx)
             } else {
-                // placeholder error
-                Err(TenureChangeError::NotNakamoto)
+                None
             }
-        };
-
-        // Return true if all of the following are true:
-        // (1) there is at least one tenure change
-        // (2) all tenure changes are valid
-        Some(
-            tenure_changes.len() > 0
-                && tenure_changes.len()
-                    == tenure_changes
-                        .iter()
-                        .filter(|tc| validate(tc).is_ok())
-                        .collect::<Vec<_>>()
-                        .len(),
-        )
-    }
-
-    pub fn is_first_mined(&self) -> bool {
-        self.header.is_first_mined()
+        })
     }
 
     /// Get the coinbase transaction in Nakamoto.
-    /// It's the first non-TenureChange transaction
-    /// (and, all preceding transactions _must_ be TenureChanges)
+    /// It's the first non-TenureChange transaction (i.e. tx 1)
     pub fn get_coinbase_tx(&self) -> Option<&StacksTransaction> {
-        let wellformed = self.is_wellformed_first_tenure_block();
+        let wellformed = self.is_wellformed_tenure_start_block();
         if wellformed.is_none() {
             // block isn't a first-tenure block, so no coinbase
             return None;
@@ -548,15 +612,16 @@ impl NakamotoBlock {
     }
 
     /// Determine if this is a well-formed first block in a tenure.
-    /// * It has one or more TenureChange transactions
-    /// * It then has a coinbase
+    /// * It has exactly one TenureChange, and it requires a sortition and points to the parent of
+    /// this block (this checks `cause` and `previous_tenure_end`)
+    /// * It then has a Nakamoto coinbase
     /// * Coinbases and TenureChanges do not occur anywhere else
     ///
     /// Returns Some(true) if the above are true
     /// Returns Some(false) if this block has at least one coinbase or TenureChange tx, but one of
     /// the above checks are false
     /// Returns None if this block has no coinbase or TenureChange txs
-    pub fn is_wellformed_first_tenure_block(&self) -> Option<bool> {
+    pub fn is_wellformed_tenure_start_block(&self) -> Option<bool> {
         // sanity check -- this may contain no coinbases or tenure-changes
         let coinbase_positions = self
             .txs
@@ -571,6 +636,7 @@ impl NakamotoBlock {
             })
             .collect::<Vec<_>>();
 
+        // find all tenure changes, even if they're not sortition-induced
         let tenure_change_positions = self
             .txs
             .iter()
@@ -589,44 +655,73 @@ impl NakamotoBlock {
             return None;
         }
 
-        if coinbase_positions.len() > 1 {
-            // has more than one coinbase
+        if coinbase_positions.len() > 1 || tenure_change_positions.len() > 1 {
+            // never valid to have more than one of each
             return Some(false);
         }
 
         if coinbase_positions.len() == 1 && tenure_change_positions.len() == 0 {
-            // has a coinbase but no tenure change
+            // coinbase unaccompanied by a tenure change
             return Some(false);
         }
 
-        if coinbase_positions.len() == 0 && tenure_change_positions.len() > 0 {
-            // has tenure-changes but no coinbase
-            return Some(false);
-        }
+        if coinbase_positions.len() == 0 && tenure_change_positions.len() == 1 {
+            // this is possibly a block with a tenure-extend transaction.
+            // It must be the first tx
+            if tenure_change_positions != vec![0] {
+                // wrong position
+                return Some(false);
+            }
 
-        // tenure-changes must all come first, and must be in order
-        for (i, pos) in tenure_change_positions.iter().enumerate() {
-            if &i != pos {
-                // tenure-change is out of place
+            // must be a non-sortition-triggered tenure change
+            let TransactionPayload::TenureChange(tc_payload) = &self.txs[0].payload else {
+                // this transaction is not a tenure change
+                // (should be unreachable)
+                return Some(false);
+            };
+
+            if tc_payload.cause.expects_sortition() {
+                // not valid
                 return Some(false);
             }
+
+            // not a tenure-start block, but syntactically valid w.r.t. tenure changes
+            return None;
+        }
+
+        // have both a coinbase and a tenure-change
+        let tc_idx = 0;
+        let coinbase_idx = 1;
+        if coinbase_positions != vec![coinbase_idx] || tenure_change_positions != vec![tc_idx] {
+            // invalid -- expect exactly one sortition-induced tenure change and exactly one coinbase expected,
+            // and the tenure change must be the first transaction and the coinbase must be the second transaction
+            return Some(false);
         }
 
-        let coinbase_idx = *coinbase_positions
-            .first()
-            .expect("FATAL: coinbase_positions.len() == 1");
-        if coinbase_idx != tenure_change_positions.len() {
-            // coinbase is not the next transaction after tenure changes
+        // must be a sortition-triggered tenure change that points to our parent block
+        let TransactionPayload::TenureChange(tc_payload) = &self.txs[tc_idx].payload else {
+            // this transaction is not a tenure change
+            // (should be unreachable)
+            return Some(false);
+        };
+        if !tc_payload.cause.expects_sortition() {
+            // the only tenure change allowed in a block with a coinbase is a sortition-triggered
+            // tenure change
+            return Some(false);
+        }
+        if tc_payload.previous_tenure_end != self.header.parent_block_id {
+            // discontinuous
             return Some(false);
         }
 
+        // must be a Nakamoto coinbase
         let TransactionPayload::Coinbase(_, _, vrf_proof_opt) = &self.txs[coinbase_idx].payload
         else {
             // this transaction is not a coinbase (but this should be unreachable)
             return Some(false);
         };
         if vrf_proof_opt.is_none() {
-            // no a Nakamoto coinbase
+            // not a Nakamoto coinbase
             return Some(false);
         }
 
@@ -668,48 +763,8 @@ impl NakamotoBlock {
         self.header.block_id()
     }
 
-    /// Validate this Nakamoto block header against burnchain state.
-    /// Used to determine whether or not we'll keep a block around (even if we don't yet have its parent).
-    ///
-    /// Arguments
-    /// -- `burn_chain_tip` is the BlockSnapshot containing the block-commit for this block's
-    /// tenure
-    /// -- `leader_key` is the miner's leader key registration transaction
-    /// -- `bloc_commit` is the block-commit for this tenure
-    ///
-    /// Verifies the following:
-    /// -- that this block falls into this block-commit's tenure
-    /// -- that this miner signed this block
-    /// -- if this block has a coinbase, then that it's VRF proof was generated by this miner
-    /// -- that this block's burn total matches `burn_chain_tip`'s total burn
-    pub fn validate_against_burnchain(
-        &self,
-        burn_chain_tip: &BlockSnapshot,
-        leader_key: &LeaderKeyRegisterOp,
-    ) -> Result<(), ChainstateError> {
-        // this block's consensus hash must match the sortition that selected it
-        if burn_chain_tip.consensus_hash != self.header.consensus_hash {
-            warn!("Invalid Nakamoto block: consensus hash does not match sortition";
-                  "consensus_hash" => %self.header.consensus_hash,
-                  "sortition.consensus_hash" => %burn_chain_tip.consensus_hash
-            );
-            return Err(ChainstateError::InvalidStacksBlock(
-                "Invalid Nakamoto block: invalid consensus hash".into(),
-            ));
-        }
-
-        // miner must have signed this block
-        let miner_pubkey_hash160 = leader_key
-            .interpret_nakamoto_signing_key()
-            .ok_or(ChainstateError::NoSuchBlockError)
-            .map_err(|e| {
-                warn!(
-                    "Leader key did not contain a hash160 of the miner signing public key";
-                    "leader_key" => format!("{:?}", &leader_key),
-                );
-                e
-            })?;
-
+    /// Get the miner's public key hash160 from this signature
+    pub(crate) fn get_miner_pubkh(&self) -> Result<Hash160, ChainstateError> {
         let recovered_miner_pubk = self.header.recover_miner_pk().ok_or_else(|| {
             warn!(
                 "Nakamoto Stacks block downloaded with unrecoverable miner public key";
@@ -720,18 +775,79 @@ impl NakamotoBlock {
         })?;
 
         let recovered_miner_hash160 = Hash160::from_node_public_key(&recovered_miner_pubk);
-        if recovered_miner_hash160 != miner_pubkey_hash160 {
+        Ok(recovered_miner_hash160)
+    }
+
+    /// Verify the miner signature over this block.
+    pub(crate) fn check_miner_signature(
+        &self,
+        miner_pubkey_hash160: &Hash160,
+    ) -> Result<(), ChainstateError> {
+        let recovered_miner_hash160 = self.get_miner_pubkh()?;
+        if &recovered_miner_hash160 != miner_pubkey_hash160 {
             warn!(
-                "Nakamoto Stacks block signature from {recovered_miner_pubk:?} mismatch: {recovered_miner_hash160} != {miner_pubkey_hash160} from leader-key";
+                "Nakamoto Stacks block signature mismatch: {recovered_miner_hash160} != {miner_pubkey_hash160} from leader-key";
                 "block_hash" => %self.header.block_hash(),
                 "block_id" => %self.header.block_id(),
-                "leader_key" => format!("{:?}", &leader_key),
             );
             return Err(ChainstateError::InvalidStacksBlock(
                 "Invalid miner signature".into(),
             ));
         }
 
+        Ok(())
+    }
+
+    /// Verify that if this block has a tenure-change, that it is consistent with our header's
+    /// consensus_hash and miner_signature.  If there is no tenure change tx in this block, then
+    /// this is a no-op
+    pub(crate) fn check_tenure_change_tx(&self) -> Result<(), ChainstateError> {
+        // If this block has a tenure-change, then verify that the miner public key is the same as
+        // the leader key.  This is required for all tenure-change causes.
+        if let Some(tenure_change_tx) = self.get_tenure_change_tx() {
+            // in all cases, the miner public key must match that of the tenure change
+            let tc_payload = tenure_change_tx
+                .try_as_tenure_change()
+                .expect("FATAL: `get_tenure_change_tx()` did not return a tenure-change");
+            let recovered_miner_hash160 = self.get_miner_pubkh()?;
+            if tc_payload.pubkey_hash != recovered_miner_hash160 {
+                warn!(
+                    "Invalid tenure-change transaction -- bad miner pubkey hash160";
+                    "block_hash" => %self.header.block_hash(),
+                    "block_id" => %self.header.block_id(),
+                    "pubkey_hash" => %tc_payload.pubkey_hash,
+                    "recovered_miner_hash160" => %recovered_miner_hash160
+                );
+                return Err(ChainstateError::InvalidStacksBlock(
+                    "Invalid tenure change -- bad miner pubkey hash160".into(),
+                ));
+            }
+
+            // in all cases, the tenure change's consensus hash must match the block's consensus
+            // hash
+            if tc_payload.consensus_hash != self.header.consensus_hash {
+                warn!(
+                    "Invalid tenure-change transaction -- bad consensus hash";
+                    "block_hash" => %self.header.block_hash(),
+                    "block_id" => %self.header.block_id(),
+                    "consensus_hash" => %self.header.consensus_hash,
+                    "tc_payload.consensus_hash" => %tc_payload.consensus_hash
+                );
+                return Err(ChainstateError::InvalidStacksBlock(
+                    "Invalid tenure change -- bad consensus hash".into(),
+                ));
+            }
+        }
+        Ok(())
+    }
+
+    /// Verify that if this block has a coinbase, that its VRF proof is consistent with the leader
+    /// public key's VRF key. If there is no coinbase tx, then this is a no-op.
+    pub(crate) fn check_coinbase_tx(
+        &self,
+        leader_vrf_key: &VRFPublicKey,
+        sortition_hash: &SortitionHash,
+    ) -> Result<(), ChainstateError> {
         // If this block has a coinbase, then verify that its VRF proof was generated by this
         // block's miner.  We'll verify that the seed of this block-commit was generated from the
         // parnet tenure's VRF proof via the `validate_vrf_seed()` method, which requires that we
@@ -746,11 +862,7 @@ impl NakamotoBlock {
 
             // this block's VRF proof must have ben generated from the last sortition's sortition
             // hash (which includes the last commit's VRF seed)
-            let valid = match VRF::verify(
-                &leader_key.public_key,
-                vrf_proof,
-                burn_chain_tip.sortition_hash.as_bytes(),
-            ) {
+            let valid = match VRF::verify(leader_vrf_key, vrf_proof, sortition_hash.as_bytes()) {
                 Ok(v) => v,
                 Err(e) => {
                     warn!(
@@ -765,14 +877,48 @@ impl NakamotoBlock {
             if !valid {
                 warn!("Invalid Nakamoto block: leader VRF key did not produce a valid proof";
                       "block_id" => %self.block_id(),
-                      "leader_public_key" => %leader_key.public_key.to_hex(),
-                      "sortition_hash" => %burn_chain_tip.sortition_hash
+                      "leader_public_key" => %leader_vrf_key.to_hex(),
+                      "sortition_hash" => %sortition_hash
                 );
                 return Err(ChainstateError::InvalidStacksBlock(
                     "Invalid Nakamoto block: leader VRF key did not produce a valid proof".into(),
                 ));
             }
         }
+        Ok(())
+    }
+
+    /// Validate this Nakamoto block header against burnchain state.
+    /// Used to determine whether or not we'll keep a block around (even if we don't yet have its parent).
+    ///
+    /// Arguments
+    /// -- `burn_chain_tip` is the BlockSnapshot containing the block-commit for this block's
+    /// tenure
+    /// -- `leader_key` is the miner's leader key registration transaction
+    /// -- `bloc_commit` is the block-commit for this tenure
+    ///
+    /// Verifies the following:
+    /// -- (self.header.consensus_hash) that this block falls into this block-commit's tenure
+    /// -- (self.header.burn_spent) that this block's burn total matches `burn_chain_tip`'s total burn
+    /// -- (self.header.miner_signature) that this miner signed this block
+    /// -- if this block has a tenure change, then it's consistent with the miner's public key and
+    /// self.header.consensus_hash
+    /// -- if this block has a coinbase, then that it's VRF proof was generated by this miner
+    pub fn validate_against_burnchain(
+        &self,
+        burn_chain_tip: &BlockSnapshot,
+        leader_key: &LeaderKeyRegisterOp,
+    ) -> Result<(), ChainstateError> {
+        // this block's consensus hash must match the sortition that selected it
+        if burn_chain_tip.consensus_hash != self.header.consensus_hash {
+            warn!("Invalid Nakamoto block: consensus hash does not match sortition";
+                  "consensus_hash" => %self.header.consensus_hash,
+                  "sortition.consensus_hash" => %burn_chain_tip.consensus_hash
+            );
+            return Err(ChainstateError::InvalidStacksBlock(
+                "Invalid Nakamoto block: invalid consensus hash".into(),
+            ));
+        }
 
         // this block must commit to all of the work seen so far
         if self.header.burn_spent != burn_chain_tip.total_burn {
@@ -784,6 +930,23 @@ impl NakamotoBlock {
                 "Invalid Nakamoto block: invalid total burns".into(),
             ));
         }
+
+        // miner must have signed this block
+        let miner_pubkey_hash160 = leader_key
+            .interpret_nakamoto_signing_key()
+            .ok_or(ChainstateError::NoSuchBlockError)
+            .map_err(|e| {
+                warn!(
+                    "Leader key did not contain a hash160 of the miner signing public key";
+                    "leader_key" => format!("{:?}", &leader_key),
+                );
+                e
+            })?;
+
+        self.check_miner_signature(&miner_pubkey_hash160)?;
+        self.check_tenure_change_tx()?;
+        self.check_coinbase_tx(&leader_key.public_key, &burn_chain_tip.sortition_hash)?;
+
         // not verified by this method:
         // * chain_length       (need parent block header)
         // * parent_block_id    (need parent block header)
@@ -801,8 +964,7 @@ impl NakamotoBlock {
     /// * that all txs use the given chain ID
     /// * if this is a tenure-start tx, that:
     ///    * it has a well-formed coinbase
-    ///    * all TenureChange transactions are present and in the right order, starting with
-    ///    `stacks_tip` and leading up to this block
+    ///    * it has a sortition-induced tenure change transaction
     /// * that only epoch-permitted transactions are present
     pub fn validate_transactions_static(
         &self,
@@ -822,7 +984,7 @@ impl NakamotoBlock {
         if !StacksBlock::validate_transactions_chain_id(&self.txs, chain_id) {
             return false;
         }
-        if let Some(valid) = self.tenure_changed() {
+        if let Some(valid) = self.is_wellformed_tenure_start_block() {
             if !valid {
                 // bad tenure change
                 return false;
@@ -830,25 +992,13 @@ impl NakamotoBlock {
             if self.get_coinbase_tx().is_none() {
                 return false;
             }
+            if self.get_tenure_change_tx().is_none() {
+                return false;
+            }
         }
         if !StacksBlock::validate_transactions_static_epoch(&self.txs, epoch_id) {
             return false;
         }
-        match self.is_wellformed_first_tenure_block() {
-            Some(true) => match self.tenure_changed() {
-                Some(false) | None => {
-                    // either the tenure_changed() check failed, or this is a tenure change that is
-                    // not in a well-formed tenure block. Either way, this block is invalid.
-                    return false;
-                }
-                _ => {}
-            },
-            Some(false) => {
-                // tenure_change() check failed
-                return false;
-            }
-            None => {}
-        }
         return true;
     }
 }
@@ -1061,19 +1211,19 @@ impl NakamotoChainState {
         }
 
         // find commit and sortition burns if this is a tenure-start block
-        // TODO: store each *tenure*
-        let tenure_changed = if let Some(tenure_valid) = next_ready_block.tenure_changed() {
-            if !tenure_valid {
-                return Err(ChainstateError::InvalidStacksBlock(
-                    "Invalid Nakamoto block: invalid tenure change tx(s)".into(),
-                ));
-            }
-            true
-        } else {
-            false
-        };
+        let new_tenure =
+            if let Some(tenure_valid) = next_ready_block.is_wellformed_tenure_start_block() {
+                if !tenure_valid {
+                    return Err(ChainstateError::InvalidStacksBlock(
+                        "Invalid Nakamoto block: invalid tenure change tx(s)".into(),
+                    ));
+                }
+                true
+            } else {
+                false
+            };
 
-        let (commit_burn, sortition_burn) = if tenure_changed {
+        let (commit_burn, sortition_burn) = if new_tenure {
             // find block-commit to get commit-burn
             let block_commit = sort_tx
                 .get_block_commit(
@@ -1315,6 +1465,7 @@ impl NakamotoChainState {
         sortdb: &SortitionHandleConn,
         staging_db_tx: &rusqlite::Transaction,
     ) -> Result<bool, ChainstateError> {
+        test_debug!("Consider Nakamoto block {}", &block.block_id());
         // do nothing if we already have this block
         if let Some(_) = Self::get_block_header(&staging_db_tx, &block.header.block_id())? {
             debug!("Already have block {}", &block.header.block_id());
@@ -1322,7 +1473,7 @@ impl NakamotoChainState {
         }
 
         // if this is the first tenure block, then make sure it's well-formed
-        if let Some(false) = block.is_wellformed_first_tenure_block() {
+        if let Some(false) = block.is_wellformed_tenure_start_block() {
             warn!(
                 "Block {} is not a well-formed first tenure block",
                 &block.block_id()
@@ -1381,13 +1532,16 @@ impl NakamotoChainState {
                 ).optional()?.is_none()
                );
 
+        let block_id = block.block_id();
         Self::store_block(staging_db_tx, block, burn_attachable, stacks_attachable)?;
+        test_debug!("Stored Nakamoto block {}", &block_id);
         Ok(true)
     }
 
     /// Create the block reward for a NakamotoBlock
     /// `coinbase_reward_ustx` is the total coinbase reward for this block, including any
     ///    accumulated rewards from missed sortitions or initial mining rewards.
+    /// TODO: unit test
     pub fn make_scheduled_miner_reward(
         mainnet: bool,
         epoch_id: StacksEpochId,
@@ -1472,19 +1626,20 @@ impl NakamotoChainState {
     /// Return a Nakamoto StacksHeaderInfo at a given tenure height in the fork identified by `tip_index_hash`.
     /// * For Stacks 2.x, this is the Stacks block's header
     /// * For Stacks 3.x (Nakamoto), this is the first block in the miner's tenure.
+    /// TODO: unit test
     pub fn get_header_by_tenure_height(
         tx: &mut StacksDBTx,
         tip_index_hash: &StacksBlockId,
         tenure_height: u64,
     ) -> Result<Option<StacksHeaderInfo>, ChainstateError> {
         // query for block header info at the tenure-height, then check if in fork
-        let qry =
-            "SELECT * FROM nakamoto_block_headers WHERE tenure_changed = 1 AND tenure_height = ?";
-        let candidate_headers: Vec<StacksHeaderInfo> =
+        let qry = "SELECT consensus_hash FROM nakamoto_tenures WHERE tenure_height = ?1";
+
+        let candidate_chs: Vec<ConsensusHash> =
             query_rows(tx.tx(), qry, &[u64_to_sql(tenure_height)?])?;
 
-        if candidate_headers.len() == 0 {
-            // no nakamoto_block_headers at that tenure height, check if there's a stack block header where
+        if candidate_chs.len() == 0 {
+            // no nakamoto_tenures at that tenure height, check if there's a stack block header where
             //   block_height = tenure_height
             let Some(ancestor_at_height) = tx
                 .get_ancestor_block_hash(tenure_height, tip_index_hash)?
@@ -1492,6 +1647,10 @@ impl NakamotoChainState {
                 .transpose()?
                 .flatten()
             else {
+                warn!("No such epoch2 ancestor";
+                      "tenure_height" => tenure_height,
+                      "tip_index_hash" => %tip_index_hash,
+                );
                 return Ok(None);
             };
             // only return if it is an epoch-2 block, because that's
@@ -1504,7 +1663,11 @@ impl NakamotoChainState {
             }
         }
 
-        for candidate in candidate_headers.into_iter() {
+        for candidate_ch in candidate_chs.into_iter() {
+            let Some(candidate) = Self::get_block_header_by_consensus_hash(tx, &candidate_ch)?
+            else {
+                continue;
+            };
             let Ok(Some(ancestor_at_height)) =
                 tx.get_ancestor_block_hash(candidate.stacks_block_height, tip_index_hash)
             else {
@@ -1529,17 +1692,27 @@ impl NakamotoChainState {
         chainstate_conn: &Connection,
         block: &StacksBlockId,
     ) -> Result<Option<u64>, ChainstateError> {
-        let nak_qry = "SELECT tenure_height FROM nakamoto_block_headers WHERE index_block_hash = ?";
-        let opt_height: Option<i64> = chainstate_conn
-            .query_row(nak_qry, &[block], |row| row.get(0))
-            .optional()?;
-        if let Some(height) = opt_height {
-            return Ok(Some(
-                u64::try_from(height).map_err(|_| DBError::ParseError)?,
-            ));
+        let sql = "SELECT * FROM nakamoto_block_headers WHERE index_block_hash = ?1";
+        let result: Option<NakamotoBlockHeader> =
+            query_row_panic(chainstate_conn, sql, &[&block], || {
+                "FATAL: multiple rows for the same block hash".to_string()
+            })?;
+        if let Some(nak_hdr) = result {
+            let nak_qry = "SELECT tenure_height FROM nakamoto_tenures WHERE consensus_hash = ?1";
+            let opt_height: Option<i64> = chainstate_conn
+                .query_row(nak_qry, &[&nak_hdr.consensus_hash], |row| row.get(0))
+                .optional()?;
+            if let Some(height) = opt_height {
+                return Ok(Some(
+                    u64::try_from(height).map_err(|_| DBError::ParseError)?,
+                ));
+            } else {
+                // should be unreachable
+                return Err(DBError::NotFoundError.into());
+            }
         }
 
-        let epoch_2_qry = "SELECT block_height FROM block_headers WHERE index_block_hash = ?";
+        let epoch_2_qry = "SELECT block_height FROM block_headers WHERE index_block_hash = ?1";
         let opt_height: Option<i64> = chainstate_conn
             .query_row(epoch_2_qry, &[block], |row| row.get(0))
             .optional()?;
@@ -1571,6 +1744,7 @@ impl NakamotoChainState {
     }
 
     /// Load the canonical Stacks block header (either epoch-2 rules or Nakamoto)
+    /// TODO: unit test
     pub fn get_canonical_block_header(
         chainstate_conn: &Connection,
         sortdb: &SortitionDB,
@@ -1641,6 +1815,8 @@ impl NakamotoChainState {
     ///
     /// Returns NoSuchBlockError if the block header for `consensus_hash` does not exist, or if the
     /// parent block header info does not exist (i.e. the chainstate DB is missing something)
+    ///
+    /// TODO: unit test
     pub fn get_parent_vrf_proof(
         chainstate_conn: &Connection,
         sortdb_conn: &Connection,
@@ -1702,6 +1878,21 @@ impl NakamotoChainState {
         .map_err(ChainstateError::DBError)
     }
 
+    /// Get the number of blocks in a tenure.
+    /// Only works for Nakamoto blocks, not Stacks epoch2 blocks.
+    /// Returns 0 if the consensus hash is not found.
+    pub fn get_nakamoto_tenure_length(
+        chainstate_conn: &Connection,
+        consensus_hash: &ConsensusHash,
+    ) -> Result<u32, ChainstateError> {
+        let sql = "SELECT IFNULL(COUNT(block_hash),0) FROM nakamoto_block_headers WHERE consensus_hash = ?1";
+        let count_i64 = query_int(chainstate_conn, sql, &[&consensus_hash])?;
+        let count: u32 = count_i64
+            .try_into()
+            .expect("FATAL: too many blocks in tenure");
+        Ok(count)
+    }
+
     /// Get the status of a Nakamoto block.
     /// Returns Some(accepted?, orphaned?) on success
     /// Returns None if there's no such block
@@ -1783,7 +1974,6 @@ impl NakamotoChainState {
         vrf_proof: Option<&VRFProof>,
         block_cost: &ExecutionCost,
         total_tenure_cost: &ExecutionCost,
-        tenure_height: u64,
         tenure_changed: bool,
         tenure_tx_fees: u128,
     ) -> Result<(), ChainstateError> {
@@ -1832,7 +2022,6 @@ impl NakamotoChainState {
             total_tenure_cost,
             &tenure_tx_fees.to_string(),
             &header.parent_block_id,
-            &u64_to_sql(tenure_height)?,
             if tenure_changed { &1i64 } else { &0 },
             &vrf_proof_bytes.as_ref(),
         ];
@@ -1853,46 +2042,356 @@ impl NakamotoChainState {
                      total_tenure_cost,
                      tenure_tx_fees,
                      parent_block_id,
-                     tenure_height,
                      tenure_changed,
                      vrf_proof)
-                    VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14, ?15, ?16, ?17, ?18, ?19, ?20, ?21, ?22, ?23, ?24)",
+                    VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14, ?15, ?16, ?17, ?18, ?19, ?20, ?21, ?22, ?23)",
             args
         )?;
 
         Ok(())
     }
 
-    /// Append a Stacks block to an existing Stacks block, and grant the miner the block reward.
-    /// Return the new Stacks header info.
-    fn advance_tip(
-        headers_tx: &mut StacksDBTx,
-        parent_tip: &StacksBlockHeaderTypes,
-        parent_consensus_hash: &ConsensusHash,
-        new_tip: &NakamotoBlockHeader,
-        new_vrf_proof: Option<&VRFProof>,
-        new_burn_header_hash: &BurnchainHeaderHash,
-        new_burnchain_height: u32,
-        new_burnchain_timestamp: u64,
-        block_reward: Option<&MinerPaymentSchedule>,
-        mature_miner_payouts: Option<(MinerReward, MinerReward, MinerRewardInfo)>, // (miner, parent, matured rewards)
-        anchor_block_cost: &ExecutionCost,
-        total_tenure_cost: &ExecutionCost,
-        block_size: u64,
-        applied_epoch_transition: bool,
-        burn_stack_stx_ops: Vec<StackStxOp>,
-        burn_transfer_stx_ops: Vec<TransferStxOp>,
-        burn_delegate_stx_ops: Vec<DelegateStxOp>,
+    /// Insert a nakamoto tenure.
+    /// No validation will be done.
+    pub(crate) fn insert_nakamoto_tenure(
+        tx: &Connection,
+        block_header: &NakamotoBlockHeader,
         tenure_height: u64,
-        tenure_changed: bool,
-        block_fees: u128,
-    ) -> Result<StacksHeaderInfo, ChainstateError> {
-        if new_tip.parent_block_id
-            != StacksBlockId::new(&FIRST_BURNCHAIN_CONSENSUS_HASH, &FIRST_STACKS_BLOCK_HASH)
+        tenure: &TenureChangePayload,
+    ) -> Result<(), ChainstateError> {
+        // NOTE: this is checked with check_nakamoto_tenure()
+        assert_eq!(block_header.consensus_hash, tenure.consensus_hash);
+        let args: &[&dyn ToSql] = &[
+            &tenure.consensus_hash,
+            &tenure.prev_consensus_hash,
+            &block_header.block_hash(),
+            &block_header.block_id(),
+            &u64_to_sql(tenure_height)?,
+            &tenure.previous_tenure_blocks,
+        ];
+        tx.execute(
+            "INSERT INTO nakamoto_tenures
+                (consensus_hash, prev_consensus_hash, block_hash, block_id,
+                tenure_height, num_blocks_confirmed)
+            VALUES
+                (?1,?2,?3,?4,?5,?6)",
+            args,
+        )?;
+
+        Ok(())
+    }
+
+    /// Get the highest tenure height processed.
+    /// Returns Ok(Some(tenure_height)) if we have processed at least one tenure
+    /// Returns Ok(None) if we have not yet processed a Nakamoto tenure
+    /// Returns Err(..) on database errors
+    pub fn get_highest_nakamoto_tenure_height(
+        conn: &Connection,
+    ) -> Result<Option<u64>, ChainstateError> {
+        match conn
+            .query_row(
+                "SELECT IFNULL(MAX(tenure_height), 0) FROM nakamoto_tenures",
+                NO_PARAMS,
+                |row| Ok(u64::from_row(row).expect("Expected u64 in database")),
+            )
+            .optional()?
         {
-            // not the first-ever block, so linkage must occur
-            match parent_tip {
-                StacksBlockHeaderTypes::Epoch2(..) => {
+            Some(height_i64) => {
+                if height_i64 == 0 {
+                    // this never happens, so it's None
+                    Ok(None)
+                } else {
+                    Ok(Some(
+                        height_i64.try_into().map_err(|_| DBError::ParseError)?,
+                    ))
+                }
+            }
+            None => Ok(None),
+        }
+    }
+
+    /// Get the highest processed tenure on the canonical sortition history.
+    /// TODO: unit test
+    pub fn get_highest_nakamoto_tenure(
+        conn: &Connection,
+        sort_tx: &mut SortitionHandleTx,
+    ) -> Result<Option<NakamotoTenure>, ChainstateError> {
+        let Some(max_sort_height) = Self::get_highest_nakamoto_tenure_height(conn)? else {
+            // no tenures yet
+            return Ok(None);
+        };
+
+        let sql = "SELECT * FROM nakamoto_tenures WHERE tenure_height = ?1";
+        let args: &[&dyn ToSql] = &[&u64_to_sql(max_sort_height)?];
+        let tenures: Vec<NakamotoTenure> = query_rows(conn, sql, args)?;
+        let tip = SortitionDB::get_canonical_burn_chain_tip(sort_tx)?;
+
+        // find the one that's in the canonical sortition history
+        for tenure in tenures.into_iter() {
+            let Some(sn) =
+                SortitionDB::get_block_snapshot_consensus(sort_tx, &tenure.consensus_hash)?
+            else {
+                // not in sortition DB.
+                // This is unreachable, but be defensive and just skip it.
+                continue;
+            };
+            let Some(_ancestor_sort_id) =
+                get_ancestor_sort_id_tx(sort_tx, sn.block_height, &tip.sortition_id)?
+            else {
+                // not canonical
+                continue;
+            };
+            return Ok(Some(tenure));
+        }
+        // not found
+        Ok(None)
+    }
+
+    /// Verify that a tenure change tx is a valid first-ever tenure change.  It must connect to an
+    /// epoch2 block.
+    /// TODO: unit test
+    pub(crate) fn check_first_nakamoto_tenure_change(
+        headers_conn: &Connection,
+        tenure_payload: &TenureChangePayload,
+    ) -> Result<bool, ChainstateError> {
+        let Some(parent_header) =
+            Self::get_block_header(headers_conn, &tenure_payload.previous_tenure_end)?
+        else {
+            warn!("Invalid tenure-change: no parent epoch2 header";
+                  "consensus_hash" => %tenure_payload.consensus_hash,
+                  "previous_tenure_end" => %tenure_payload.previous_tenure_end
+            );
+            return Ok(false);
+        };
+        if parent_header.anchored_header.as_stacks_epoch2().is_none() {
+            warn!("Invalid tenure-change: parent header is not epoch2";
+                  "consensus_hash" => %tenure_payload.consensus_hash,
+                  "previous_tenure_end" => %tenure_payload.previous_tenure_end
+            );
+            return Ok(false);
+        }
+        if tenure_payload.previous_tenure_blocks != 1 {
+            warn!("Invalid tenure-change: expected 1 previous tenure block";
+                  "consensus_hash" => %tenure_payload.consensus_hash,
+            );
+            return Ok(false);
+        }
+        return Ok(true);
+    }
+
+    /// Check a Nakamoto tenure transaction's validity with respect to the last-processed tenure
+    /// and the sortition DB.  This validates the following fields:
+    /// * consensus_hash
+    /// * prev_consensus_hash
+    /// * previous_tenure_end
+    /// * previous_tenure_blocks
+    /// * cause
+    ///
+    /// Returns Ok(true) on success
+    /// Returns Ok(false) if the tenure change is invalid
+    /// Returns Err(..) on DB error
+    /// TODO: unit test
+    pub(crate) fn check_nakamoto_tenure(
+        headers_conn: &Connection,
+        sort_tx: &mut SortitionHandleTx,
+        block_header: &NakamotoBlockHeader,
+        tenure_payload: &TenureChangePayload,
+    ) -> Result<bool, ChainstateError> {
+        if !tenure_payload.cause.expects_sortition() {
+            // not paired with a sortition
+            return Ok(true);
+        }
+
+        // block header must match tenure
+        if block_header.consensus_hash != tenure_payload.consensus_hash {
+            warn!("Invalid tenure-change (or block) -- mismatched consensus hash";
+                  "tenure_payload.consensus_hash" => %tenure_payload.consensus_hash,
+                  "block_header.consensus_hash" => %block_header.consensus_hash
+            );
+            return Ok(false);
+        }
+
+        let tip = SortitionDB::get_canonical_burn_chain_tip(sort_tx)?;
+
+        // the target sortition must exist, and it must be on the canonical fork
+        let Some(sn) =
+            SortitionDB::get_block_snapshot_consensus(sort_tx, &tenure_payload.consensus_hash)?
+        else {
+            // no sortition
+            warn!("Invalid tenure-change: no such snapshot"; "consensus_hash" => %tenure_payload.consensus_hash);
+            return Ok(false);
+        };
+        let Some(_ancestor_sort_id) =
+            get_ancestor_sort_id_tx(sort_tx, sn.block_height, &tip.sortition_id)?
+        else {
+            // not canonical
+            warn!("Invalid tenure-change: snapshot is not canonical"; "consensus_hash" => %tenure_payload.consensus_hash);
+            return Ok(false);
+        };
+        if tenure_payload.prev_consensus_hash != FIRST_BURNCHAIN_CONSENSUS_HASH {
+            // the parent sortition must exist, must be canonical, and must be an ancestor of the
+            // sortition for the given consensus hash.
+            let Some(prev_sn) = SortitionDB::get_block_snapshot_consensus(
+                sort_tx,
+                &tenure_payload.prev_consensus_hash,
+            )?
+            else {
+                // no parent sortition
+                warn!("Invalid tenure-change: no such parent snapshot"; "prev_consensus_hash" => %tenure_payload.prev_consensus_hash);
+                return Ok(false);
+            };
+            let Some(_ancestor_sort_id) =
+                get_ancestor_sort_id_tx(sort_tx, sn.block_height, &tip.sortition_id)?
+            else {
+                // parent not canonical
+                warn!("Invalid tenure-change: parent snapshot is not canonical"; "prev_consensus_hash" => %tenure_payload.prev_consensus_hash);
+                return Ok(false);
+            };
+            if prev_sn.block_height >= sn.block_height {
+                // parent comes after child
+                warn!("Invalid tenure-change: parent snapshot comes after child"; "consensus_hash" => %tenure_payload.consensus_hash, "prev_consensus_hash" => %tenure_payload.prev_consensus_hash);
+                return Ok(false);
+            }
+        }
+
+        // validate cause
+        match tenure_payload.cause {
+            TenureChangeCause::BlockFound => {
+                // there must have been a block-commit which one sortition
+                if !sn.sortition {
+                    warn!("Invalid tenure-change: no block found";
+                          "consensus_hash" => %tenure_payload.consensus_hash
+                    );
+                    return Ok(false);
+                }
+            }
+            TenureChangeCause::Extended => {}
+        }
+
+        let Some(highest_processed_tenure) =
+            Self::get_highest_nakamoto_tenure(headers_conn, sort_tx)?
+        else {
+            // no previous tenures.  This is the first tenure change.  It should point to an epoch
+            // 2.x block.
+            return Self::check_first_nakamoto_tenure_change(headers_conn, tenure_payload);
+        };
+
+        let Some(last_tenure_finish_block_id) = Self::get_nakamoto_tenure_finish_block_header(
+            headers_conn,
+            &highest_processed_tenure.consensus_hash,
+        )?
+        .map(|hdr| hdr.index_block_hash()) else {
+            // last tenure doesn't exist (should be unreachable)
+            warn!("Invalid tenure-change: no blocks found for highest processed tenure";
+                  "consensus_hash" => %highest_processed_tenure.consensus_hash,
+            );
+            return Ok(false);
+        };
+
+        if last_tenure_finish_block_id != tenure_payload.previous_tenure_end
+            || highest_processed_tenure.consensus_hash != tenure_payload.prev_consensus_hash
+        {
+            // not continuous -- this tenure-change does not point to the end of the
+            // last-processed tenure, or does not point to the last-processed tenure's sortition
+            warn!("Invalid tenure-change: discontiguous";
+                  "consensus_hash" => %tenure_payload.consensus_hash,
+                  "prev_consensus_hash" => %tenure_payload.prev_consensus_hash,
+                  "highest_processed_tenure.consensus_hash" => %highest_processed_tenure.consensus_hash,
+                  "last_tenure_finish_block_id" => %last_tenure_finish_block_id,
+                  "tenure_payload.previous_tenure_end" => %tenure_payload.previous_tenure_end
+            );
+            return Ok(false);
+        }
+
+        let tenure_len = Self::get_nakamoto_tenure_length(
+            headers_conn,
+            &highest_processed_tenure.consensus_hash,
+        )?;
+        if tenure_len != tenure_payload.previous_tenure_blocks {
+            // invalid -- does not report the correct number of blocks in the past tenure
+            warn!("Invalid tenure-change: wrong number of blocks";
+                  "consensus_hash" => %tenure_payload.consensus_hash,
+                  "highest_processed_tenure.consensus_hash" => %highest_processed_tenure.consensus_hash,
+                  "tenure_len" => tenure_len,
+                  "tenure_payload.previous_tenure_blocks" => tenure_payload.previous_tenure_blocks
+            );
+            return Ok(false);
+        }
+
+        Ok(true)
+    }
+
+    /// Advance the tenures table with a validated block's tenure data.
+    /// Only stores tenures that are paired with sortitions
+    /// TODO: unit test
+    pub(crate) fn advance_nakamoto_tenure(
+        headers_tx: &mut StacksDBTx,
+        sort_tx: &mut SortitionHandleTx,
+        block: &NakamotoBlock,
+        parent_tenure_height: u64,
+    ) -> Result<u64, ChainstateError> {
+        let tenure_height = parent_tenure_height
+            .checked_add(1)
+            .expect("FATAL: too many tenures");
+
+        for tx in block.txs.iter() {
+            let TransactionPayload::TenureChange(ref tenure_change_payload) = &tx.payload else {
+                continue;
+            };
+
+            if !Self::check_nakamoto_tenure(
+                headers_tx,
+                sort_tx,
+                &block.header,
+                tenure_change_payload,
+            )? {
+                return Err(ChainstateError::InvalidStacksTransaction(
+                    "Invalid tenure-change".into(),
+                    false,
+                ));
+            }
+
+            Self::insert_nakamoto_tenure(
+                headers_tx,
+                &block.header,
+                tenure_height,
+                tenure_change_payload,
+            )?;
+            return Ok(tenure_height);
+        }
+        // no new tenure
+        return Ok(parent_tenure_height);
+    }
+
+    /// Append a Stacks block to an existing Stacks block, and grant the miner the block reward.
+    /// Return the new Stacks header info.
+    fn advance_tip(
+        headers_tx: &mut StacksDBTx,
+        parent_tip: &StacksBlockHeaderTypes,
+        parent_consensus_hash: &ConsensusHash,
+        new_tip: &NakamotoBlockHeader,
+        new_vrf_proof: Option<&VRFProof>,
+        new_burn_header_hash: &BurnchainHeaderHash,
+        new_burnchain_height: u32,
+        new_burnchain_timestamp: u64,
+        block_reward: Option<&MinerPaymentSchedule>,
+        mature_miner_payouts_opt: Option<MaturedMinerRewards>,
+        anchor_block_cost: &ExecutionCost,
+        total_tenure_cost: &ExecutionCost,
+        block_size: u64,
+        applied_epoch_transition: bool,
+        burn_stack_stx_ops: Vec<StackStxOp>,
+        burn_transfer_stx_ops: Vec<TransferStxOp>,
+        burn_delegate_stx_ops: Vec<DelegateStxOp>,
+        new_tenure: bool,
+        block_fees: u128,
+    ) -> Result<StacksHeaderInfo, ChainstateError> {
+        if new_tip.parent_block_id
+            != StacksBlockId::new(&FIRST_BURNCHAIN_CONSENSUS_HASH, &FIRST_STACKS_BLOCK_HASH)
+        {
+            // not the first-ever block, so linkage must occur
+            match parent_tip {
+                StacksBlockHeaderTypes::Epoch2(..) => {
                     assert_eq!(
                         new_tip.parent_block_id,
                         StacksBlockId::new(&parent_consensus_hash, &parent_tip.block_hash())
@@ -1936,7 +2435,7 @@ impl NakamotoChainState {
         };
 
         let tenure_fees = block_fees
-            + if tenure_changed {
+            + if new_tenure {
                 0
             } else {
                 Self::get_total_tenure_tx_fees_at(&headers_tx, &parent_hash)?.ok_or_else(|| {
@@ -1956,8 +2455,7 @@ impl NakamotoChainState {
             new_vrf_proof,
             anchor_block_cost,
             total_tenure_cost,
-            tenure_height,
-            tenure_changed,
+            new_tenure,
             tenure_fees,
         )?;
         if let Some(block_reward) = block_reward {
@@ -1975,27 +2473,31 @@ impl NakamotoChainState {
             burn_delegate_stx_ops,
         )?;
 
-        if let Some((miner_payout, parent_payout, reward_info)) = mature_miner_payouts {
+        if let Some(matured_miner_payouts) = mature_miner_payouts_opt {
             let rewarded_miner_block_id = StacksBlockId::new(
-                &reward_info.from_block_consensus_hash,
-                &reward_info.from_stacks_block_hash,
+                &matured_miner_payouts.reward_info.from_block_consensus_hash,
+                &matured_miner_payouts.reward_info.from_stacks_block_hash,
             );
             let rewarded_parent_miner_block_id = StacksBlockId::new(
-                &reward_info.from_parent_block_consensus_hash,
-                &reward_info.from_parent_stacks_block_hash,
+                &matured_miner_payouts
+                    .reward_info
+                    .from_parent_block_consensus_hash,
+                &matured_miner_payouts
+                    .reward_info
+                    .from_parent_stacks_block_hash,
             );
 
             StacksChainState::insert_matured_child_miner_reward(
                 headers_tx.deref_mut(),
                 &rewarded_parent_miner_block_id,
                 &rewarded_miner_block_id,
-                &miner_payout,
+                &matured_miner_payouts.recipient,
             )?;
             StacksChainState::insert_matured_parent_miner_reward(
                 headers_tx.deref_mut(),
                 &rewarded_parent_miner_block_id,
                 &rewarded_miner_block_id,
-                &parent_payout,
+                &matured_miner_payouts.parent_reward,
             )?;
         }
 
@@ -2013,34 +2515,83 @@ impl NakamotoChainState {
         Ok(new_tip_info)
     }
 
-    /// This function is called in both `append_block` in blocks.rs (follower) and
-    /// `mine_anchored_block` in miner.rs.
-    /// Processes matured miner rewards, alters liquid supply of ustx, processes
-    /// stx lock events, and marks the microblock public key as used
-    /// Returns stx lockup events.
-    pub fn finish_block(
-        clarity_tx: &mut ClarityTx,
-        miner_payouts: Option<&(MinerReward, MinerReward, MinerRewardInfo)>,
-    ) -> Result<Vec<StacksTransactionEvent>, ChainstateError> {
-        // add miner payments
-        if let Some((ref miner_reward, ref parent_reward, _)) = miner_payouts {
-            // grant in order by miner, then users
-            let matured_ustx = StacksChainState::process_matured_miner_rewards(
-                clarity_tx,
-                miner_reward,
-                &[],
-                parent_reward,
-            )?;
+    /// Get scheduled miner rewards that have matured when this tenure starts.
+    /// Returns (list of miners to pay, any residual payments to the parent miner) on success.
+    /// TODO: unit test
+    pub(crate) fn get_matured_miner_reward_schedules(
+        chainstate_tx: &mut ChainstateTx,
+        tip_index_hash: &StacksBlockId,
+        tenure_height: u64,
+    ) -> Result<Option<MaturedMinerPaymentSchedules>, ChainstateError> {
+        let mainnet = chainstate_tx.get_config().mainnet;
 
-            clarity_tx.increment_ustx_liquid_supply(matured_ustx);
+        // find matured miner rewards, so we can grant them within the Clarity DB tx.
+        if tenure_height < MINER_REWARD_MATURITY {
+            return Ok(Some(MaturedMinerPaymentSchedules::genesis(mainnet)));
         }
 
-        // process unlocks
-        let (new_unlocked_ustx, lockup_events) = StacksChainState::process_stx_unlocks(clarity_tx)?;
+        let matured_tenure_height = tenure_height - MINER_REWARD_MATURITY;
+        let matured_tenure_block_header = Self::get_header_by_tenure_height(
+            chainstate_tx,
+            &tip_index_hash,
+            matured_tenure_height,
+        )?
+        .ok_or_else(|| {
+            warn!("Matured tenure data not found");
+            ChainstateError::NoSuchBlockError
+        })?;
 
-        clarity_tx.increment_ustx_liquid_supply(new_unlocked_ustx);
+        let latest_miners = StacksChainState::get_scheduled_block_rewards_at_block(
+            chainstate_tx.deref_mut(),
+            &matured_tenure_block_header.index_block_hash(),
+        )?;
+        let parent_miner = StacksChainState::get_parent_matured_miner(
+            chainstate_tx.deref_mut(),
+            mainnet,
+            &latest_miners,
+        )?;
+        Ok(Some(MaturedMinerPaymentSchedules {
+            latest_miners,
+            parent_miner,
+        }))
+    }
 
-        Ok(lockup_events)
+    /// Calculate the total matured rewards from the scheduled matured rewards.
+    /// This takes a ClarityTx, so PoisonMicroblocks can be taken into account (which deduct
+    /// STX from the block reward for offending miners).
+    /// The recipient of the block reward may not be the miner, but may be a PoisonMicroblock
+    /// reporter (both are captured as the sole `recipient` in the `MaturedMinerRewards` struct).
+    ///
+    /// Returns Ok(Some(rewards)) if we were able to calculate the rewards
+    /// Returns Ok(None) if there are no matured rewards yet
+    /// Returns Err(..) on DB error
+    /// TODO: unit test
+    pub(crate) fn calculate_matured_miner_rewards(
+        clarity_tx: &mut ClarityTx,
+        sortdb_conn: &Connection,
+        parent_stacks_height: u64,
+        matured_miner_schedule: MaturedMinerPaymentSchedules,
+    ) -> Result<Option<MaturedMinerRewards>, ChainstateError> {
+        let matured_miner_rewards_opt = match StacksChainState::find_mature_miner_rewards(
+            clarity_tx,
+            sortdb_conn,
+            parent_stacks_height,
+            matured_miner_schedule.latest_miners,
+            matured_miner_schedule.parent_miner,
+        ) {
+            Ok(Some((recipient, _user_burns, parent, reward_info))) => Some(MaturedMinerRewards {
+                recipient,
+                parent_reward: parent,
+                reward_info,
+            }),
+            Ok(None) => None,
+            Err(e) => {
+                let msg = format!("Failed to load miner rewards: {:?}", &e);
+                warn!("{}", &msg);
+                return Err(ChainstateError::InvalidStacksBlock(msg));
+            }
+        };
+        Ok(matured_miner_rewards_opt)
     }
 
     /// Begin block-processing and return all of the pre-processed state within a
@@ -2063,9 +2614,8 @@ impl NakamotoChainState {
     /// pointer to the already-processed parent Stacks block
     /// * burn_header_hash, burn_header_height: pointer to the Bitcoin block that identifies the
     /// tenure of this block to be processed
-    /// * mainnet: whether or not we're in mainnet
-    /// * tenure_chainged: whether or not this block represents a tenure change
-    /// * tenure_height: the number of tenures that this block confirms
+    /// * new_tenure: whether or not this block is the start of a new tenure
+    /// * tenure_height: the number of tenures that this block confirms (including epoch2 blocks)
     ///
     /// Returns clarity_tx, list of receipts, microblock execution cost,
     /// microblock fees, microblock burns, list of microblock tx receipts,
@@ -2082,8 +2632,7 @@ impl NakamotoChainState {
         parent_burn_height: u32,
         burn_header_hash: BurnchainHeaderHash,
         burn_header_height: u32,
-        mainnet: bool,
-        tenure_changed: bool,
+        new_tenure: bool,
         tenure_height: u64,
     ) -> Result<SetupBlockResult<'a, 'b>, ChainstateError> {
         let parent_index_hash = StacksBlockId::new(&parent_consensus_hash, &parent_header_hash);
@@ -2093,54 +2642,11 @@ impl NakamotoChainState {
         let tip_index_hash = StacksBlockId::new(&parent_consensus_hash, &parent_header_hash);
 
         // find matured miner rewards, so we can grant them within the Clarity DB tx.
-        let matured_rewards_pair = if !tenure_changed {
-            // only grant matured rewards at a tenure changing block
-            None
+        let matured_rewards_schedule_opt = if new_tenure {
+            Self::get_matured_miner_reward_schedules(chainstate_tx, &tip_index_hash, tenure_height)?
         } else {
-            if tenure_height < MINER_REWARD_MATURITY {
-                Some((vec![], MinerPaymentSchedule::genesis(mainnet)))
-            } else {
-                let matured_tenure_height = tenure_height - MINER_REWARD_MATURITY;
-                // for finding matured rewards at a tenure height, we identify the tenure
-                //  by the consensus hash associated with that tenure's sortition.
-                let matured_tenure_block_header = Self::get_header_by_tenure_height(
-                    chainstate_tx,
-                    &tip_index_hash,
-                    matured_tenure_height,
-                )?
-                .ok_or_else(|| {
-                    warn!("Matured tenure data not found");
-                    ChainstateError::NoSuchBlockError
-                })?;
-
-                if matured_tenure_block_header.is_epoch_2_block() {
-                    // is matured_tenure_height a epoch-2 rules block? if so, use StacksChainState block rewards methods
-                    let latest_miners = StacksChainState::get_scheduled_block_rewards_at_block(
-                        chainstate_tx.deref_mut(),
-                        &matured_tenure_block_header.index_block_hash(),
-                    )?;
-                    let parent_miner = StacksChainState::get_parent_matured_miner(
-                        chainstate_tx.deref_mut(),
-                        mainnet,
-                        &latest_miners,
-                    )?;
-                    Some((latest_miners, parent_miner))
-                } else {
-                    // otherwise, apply nakamoto rules for getting block rewards: fetch by the consensus hash
-                    //   associated with the tenure, parent_miner is None.
-                    let latest_miners = StacksChainState::get_scheduled_block_rewards_at_block(
-                        chainstate_tx.deref_mut(),
-                        &matured_tenure_block_header.index_block_hash(),
-                    )?;
-                    // find the parent of this tenure
-                    let parent_miner = StacksChainState::get_parent_matured_miner(
-                        chainstate_tx.deref_mut(),
-                        mainnet,
-                        &latest_miners,
-                    )?;
-                    Some((latest_miners, parent_miner))
-                }
-            }
+            // no rewards if mid-tenure
+            None
         };
 
         // TODO: only need to do this if this is a tenure-start block
@@ -2163,33 +2669,22 @@ impl NakamotoChainState {
             &MINER_BLOCK_HEADER_HASH,
         );
 
-        let matured_miner_rewards_result =
-            matured_rewards_pair.map(|(latest_matured_miners, matured_miner_parent)| {
-                StacksChainState::find_mature_miner_rewards(
+        // now that we have access to the ClarityVM, we can account for reward deductions from
+        // PoisonMicroblocks if we have new rewards scheduled
+        let matured_rewards_opt = matured_rewards_schedule_opt
+            .map(|matured_rewards_schedule| {
+                Self::calculate_matured_miner_rewards(
                     &mut clarity_tx,
                     sortition_dbconn.sqlite_conn(),
                     parent_stacks_height,
-                    latest_matured_miners,
-                    matured_miner_parent,
+                    matured_rewards_schedule,
                 )
-            });
-        let matured_miner_rewards_opt = match matured_miner_rewards_result {
-            Some(Ok(Some((miner, _user_burns, parent, reward_info)))) => {
-                Some((miner, parent, reward_info))
-            }
-            Some(Ok(None)) => None,
-            Some(Err(e)) => {
-                let msg = format!("Failed to load miner rewards: {:?}", &e);
-                warn!("{}", &msg);
-
-                clarity_tx.rollback_block();
-                return Err(ChainstateError::InvalidStacksBlock(msg));
-            }
-            None => None,
-        };
+            })
+            .transpose()?
+            .flatten();
 
         // Nakamoto must load block cost from parent if this block isn't a tenure change
-        let initial_cost = if tenure_changed {
+        let initial_cost = if new_tenure {
             ExecutionCost::zero()
         } else {
             let parent_cost_total =
@@ -2279,7 +2774,7 @@ impl NakamotoChainState {
         Ok(SetupBlockResult {
             clarity_tx,
             tx_receipts,
-            matured_miner_rewards_opt,
+            matured_miner_rewards_opt: matured_rewards_opt,
             evaluated_epoch,
             applied_epoch_transition,
             burn_stack_stx_ops: stacking_burn_ops,
@@ -2289,6 +2784,231 @@ impl NakamotoChainState {
         })
     }
 
+    /// This function is called in both `append_block` in blocks.rs (follower) and
+    /// `mine_anchored_block` in miner.rs.
+    /// Processes matured miner rewards, alters liquid supply of ustx, processes
+    /// stx lock events, and marks the microblock public key as used
+    /// Returns stx lockup events.
+    pub fn finish_block(
+        clarity_tx: &mut ClarityTx,
+        miner_payouts: Option<&MaturedMinerRewards>,
+    ) -> Result<Vec<StacksTransactionEvent>, ChainstateError> {
+        // add miner payments
+        if let Some(ref rewards) = miner_payouts {
+            // grant in order by miner, then users
+            let matured_ustx = StacksChainState::process_matured_miner_rewards(
+                clarity_tx,
+                &rewards.recipient,
+                &[],
+                &rewards.parent_reward,
+            )?;
+
+            clarity_tx.increment_ustx_liquid_supply(matured_ustx);
+        }
+
+        // process unlocks
+        let (new_unlocked_ustx, lockup_events) = StacksChainState::process_stx_unlocks(clarity_tx)?;
+
+        clarity_tx.increment_ustx_liquid_supply(new_unlocked_ustx);
+
+        Ok(lockup_events)
+    }
+
+    /// Check that a given Nakamoto block's tenure's sortition exists and was processed.
+    /// Return the sortition's burnchain block's hash and its burnchain height
+    /// TODO: unit test
+    pub(crate) fn check_sortition_exists(
+        burn_dbconn: &mut SortitionHandleTx,
+        block_consensus_hash: &ConsensusHash,
+    ) -> Result<(BurnchainHeaderHash, u64), ChainstateError> {
+        // check that the burnchain block that this block is associated with has been processed.
+        // N.B. we must first get its hash, and then verify that it's in the same Bitcoin fork as
+        // our `burn_dbconn` indicates.
+        let burn_header_hash =
+            SortitionDB::get_burnchain_header_hash_by_consensus(burn_dbconn, block_consensus_hash)?
+                .ok_or_else(|| {
+                    warn!(
+                        "Unrecognized consensus hash";
+                        "consensus_hash" => %block_consensus_hash,
+                    );
+                    ChainstateError::NoSuchBlockError
+                })?;
+
+        let sortition_tip = burn_dbconn.context.chain_tip.clone();
+        let burn_header_height = burn_dbconn
+            .get_block_snapshot(&burn_header_hash, &sortition_tip)?
+            .ok_or_else(|| {
+                warn!(
+                    "Tried to process Nakamoto block before its burn view was processed";
+                    "burn_header_hash" => %burn_header_hash,
+                );
+                ChainstateError::NoSuchBlockError
+            })?
+            .block_height;
+
+        Ok((burn_header_hash, burn_header_height))
+    }
+
+    /// Check that this block is in the same tenure as its parent, and that this tenure is the
+    /// highest-seen tenure.
+    /// Returns Ok(bool) to indicate whether or not this block is in the same tenure as its parent.
+    /// Returns Err(..) on DB error
+    /// TODO: unit test
+    pub(crate) fn check_tenure_continuity(
+        headers_conn: &Connection,
+        sort_tx: &mut SortitionHandleTx,
+        parent_ch: &ConsensusHash,
+        block_header: &NakamotoBlockHeader,
+    ) -> Result<bool, ChainstateError> {
+        // block must have the same consensus hash as its parent
+        if block_header.is_first_mined() || parent_ch != &block_header.consensus_hash {
+            return Ok(false);
+        }
+
+        // block must be in the same tenure as the highest-processed tenure
+        let Some(highest_tenure) = Self::get_highest_nakamoto_tenure(headers_conn, sort_tx)? else {
+            // no tenures yet, so definitely not continuous
+            return Ok(false);
+        };
+
+        if &highest_tenure.consensus_hash != parent_ch {
+            // this block is not in the highest-known tenure, so it can't be continuous
+            return Ok(false);
+        }
+
+        Ok(true)
+    }
+
+    /// Calculate the scheduled block-reward for this tenure.
+    /// - chainstate_tx: the transaction open against the chainstate
+    /// - burn_dbconn: the sortition fork tx open against the sortition DB
+    /// - block: the block being processed
+    /// - parent_tenure_height: the number of tenures represented by the parent of this block
+    /// - chain_tip_burn_header_height: the height of the burnchain block mined when this block was
+    /// produced
+    /// - burnchain_commit_burn: how many burnchain tokens were spent by this block's tenure's block-commit
+    /// - burnchain_sortition_burn: total burnchain tokens spent by all miners for this block's
+    /// tenure
+    ///
+    /// Returns the scheduled reward for this block's miner, subject to:
+    /// - accumulated STX from missed sortitions
+    /// - initial mining bonus, if any
+    /// - the coinbase reward at this burnchain block height
+    /// - the parent tenure's total fees
+    ///
+    /// TODO: unit test
+    pub(crate) fn calculate_scheduled_tenure_reward(
+        chainstate_tx: &mut ChainstateTx,
+        burn_dbconn: &mut SortitionHandleTx,
+        block: &NakamotoBlock,
+        evaluated_epoch: StacksEpochId,
+        parent_tenure_height: u64,
+        chain_tip_burn_header_height: u64,
+        burnchain_commit_burn: u64,
+        burnchain_sortition_burn: u64,
+    ) -> Result<MinerPaymentSchedule, ChainstateError> {
+        let mainnet = chainstate_tx.get_config().mainnet;
+
+        // figure out if there any accumulated rewards by
+        //   getting the snapshot that elected this block.
+        let accumulated_rewards = SortitionDB::get_block_snapshot_consensus(
+            burn_dbconn.tx(),
+            &block.header.consensus_hash,
+        )?
+        .expect("CORRUPTION: failed to load snapshot that elected processed block")
+        .accumulated_coinbase_ustx;
+
+        let coinbase_at_block = StacksChainState::get_coinbase_reward(
+            chain_tip_burn_header_height,
+            burn_dbconn.context.first_block_height,
+        );
+
+        let total_coinbase = coinbase_at_block.saturating_add(accumulated_rewards);
+        let parent_tenure_start_header: StacksHeaderInfo = Self::get_header_by_tenure_height(
+            chainstate_tx,
+            &block.header.parent_block_id,
+            parent_tenure_height,
+        )?
+        .ok_or_else(|| {
+            warn!("While processing tenure change, failed to look up parent tenure";
+                  "parent_tenure_height" => parent_tenure_height,
+                  "parent_block_id" => %block.header.parent_block_id,
+                  "block_hash" => %block.header.block_hash(),
+                  "block_consensus_hash" => %block.header.consensus_hash);
+            ChainstateError::NoSuchBlockError
+        })?;
+        // fetch the parent tenure fees by reading the total tx fees from this block's
+        // *parent* (not parent_tenure_start_header), because `parent_block_id` is the last
+        // block of that tenure, so contains a total fee accumulation for the whole tenure
+        let parent_tenure_fees = if parent_tenure_start_header.is_nakamoto_block() {
+            Self::get_total_tenure_tx_fees_at(
+                chainstate_tx,
+                &block.header.parent_block_id
+            )?.ok_or_else(|| {
+                warn!("While processing tenure change, failed to look up parent block's total tx fees";
+                      "parent_block_id" => %block.header.parent_block_id,
+                      "block_hash" => %block.header.block_hash(),
+                      "block_consensus_hash" => %block.header.consensus_hash);
+                ChainstateError::NoSuchBlockError
+            })?
+        } else {
+            // if the parent tenure is an epoch-2 block, don't pay
+            // any fees to them in this schedule: nakamoto blocks
+            // cannot confirm microblock transactions, and
+            // anchored transactions are scheduled
+            // by the parent in epoch-2.
+            0
+        };
+
+        Ok(Self::make_scheduled_miner_reward(
+            mainnet,
+            evaluated_epoch,
+            &parent_tenure_start_header.anchored_header.block_hash(),
+            &parent_tenure_start_header.consensus_hash,
+            &block.header.block_hash(),
+            &block.header.consensus_hash,
+            block.header.chain_length,
+            block
+                .get_coinbase_tx()
+                .ok_or(ChainstateError::InvalidStacksBlock(
+                    "No coinbase transaction in tenure changing block".into(),
+                ))?,
+            parent_tenure_fees,
+            burnchain_commit_burn,
+            burnchain_sortition_burn,
+            total_coinbase,
+        ))
+    }
+
+    /// Get the burnchain block info of a given tenure's consensus hash.
+    /// Used for the tx receipt.
+    /// TODO: unit test
+    pub(crate) fn get_tenure_burn_block_info(
+        burn_dbconn: &Connection,
+        first_mined: bool,
+        ch: &ConsensusHash,
+    ) -> Result<(BurnchainHeaderHash, u64, u64), ChainstateError> {
+        // get burn block stats, for the transaction receipt
+        let (burn_block_hash, burn_block_height, burn_block_timestamp) = if first_mined {
+            (BurnchainHeaderHash([0; 32]), 0, 0)
+        } else {
+            match SortitionDB::get_block_snapshot_consensus(burn_dbconn, ch)? {
+                Some(sn) => (
+                    sn.burn_header_hash,
+                    sn.block_height,
+                    sn.burn_header_timestamp,
+                ),
+                None => {
+                    // shouldn't happen
+                    warn!("CORRUPTION: {} does not correspond to a burn block", ch,);
+                    (BurnchainHeaderHash([0; 32]), 0, 0)
+                }
+            }
+        };
+
+        Ok((burn_block_hash, burn_block_height, burn_block_timestamp))
+    }
+
     /// Append a Nakamoto Stacks block to the Stacks chain state.
     pub fn append_block<'a>(
         chainstate_tx: &mut ChainstateTx,
@@ -2311,9 +3031,9 @@ impl NakamotoChainState {
         );
 
         let ast_rules = ASTRules::PrecheckSize;
-        let mainnet = chainstate_tx.get_config().mainnet;
         let next_block_height = block.header.chain_length;
 
+        // check that this block attaches to the `parent_chain_tip`
         let (parent_ch, parent_block_hash) = if block.is_first_mined() {
             (
                 FIRST_BURNCHAIN_CONSENSUS_HASH.clone(),
@@ -2326,7 +3046,7 @@ impl NakamotoChainState {
             )
         };
 
-        let parent_block_id = StacksChainState::get_index_hash(&parent_ch, &parent_block_hash);
+        let parent_block_id = StacksBlockId::new(&parent_ch, &parent_block_hash);
         if parent_block_id != block.header.parent_block_id {
             warn!("Error processing nakamoto block: Parent consensus hash does not match db view";
                   "db.parent_block_id" => %parent_block_id,
@@ -2336,37 +3056,13 @@ impl NakamotoChainState {
             ));
         }
 
-        // check that the burnchain block that this block is associated with has been processed.
-        // N.B. we must first get its hash, and then verify that it's in the same Bitcoin fork as
-        // our `burn_dbconn` indicates.
-        let burn_header_hash = SortitionDB::get_burnchain_header_hash_by_consensus(
-            burn_dbconn,
-            &block.header.consensus_hash,
-        )?
-        .ok_or_else(|| {
-            warn!(
-                "Unrecognized consensus hash";
-                "block_hash" => %block.header.block_hash(),
-                "consensus_hash" => %block.header.consensus_hash,
-            );
-            ChainstateError::NoSuchBlockError
-        })?;
-
-        let sortition_tip = burn_dbconn.context.chain_tip.clone();
-        let burn_header_height = burn_dbconn
-            .get_block_snapshot(&burn_header_hash, &sortition_tip)?
-            .ok_or_else(|| {
-                warn!(
-                    "Tried to process Nakamoto block before its burn view was processed";
-                    "block_hash" => block.header.block_hash(),
-                    "burn_header_hash" => %burn_header_hash,
-                );
-                ChainstateError::NoSuchBlockError
-            })?
-            .block_height;
-
+        // look up this block's sortition's burnchain block hash and height.
+        // It must exist in the same Bitcoin fork as our `burn_dbconn`.
+        let (burn_header_hash, burn_header_height) =
+            Self::check_sortition_exists(burn_dbconn, &block.header.consensus_hash)?;
         let block_hash = block.header.block_hash();
-        let tenure_changed = if let Some(tenures_valid) = block.tenure_changed() {
+
+        let new_tenure = if let Some(tenures_valid) = block.is_wellformed_tenure_start_block() {
             if !tenures_valid {
                 return Err(ChainstateError::InvalidStacksBlock(
                     "Invalid tenure changes in nakamoto block".into(),
@@ -2374,13 +3070,20 @@ impl NakamotoChainState {
             }
             true
         } else {
+            // this block is mined in the ongoing tenure.
+            if !Self::check_tenure_continuity(
+                chainstate_tx,
+                burn_dbconn,
+                &parent_ch,
+                &block.header,
+            )? {
+                // this block is not part of the ongoing tenure; it's invalid
+                return Err(ChainstateError::ExpectedTenureChange);
+            }
+
             false
         };
 
-        if !tenure_changed && (block.is_first_mined() || parent_ch != block.header.consensus_hash) {
-            return Err(ChainstateError::ExpectedTenureChange);
-        }
-
         let parent_tenure_height = if block.is_first_mined() {
             0
         } else {
@@ -2395,17 +3098,10 @@ impl NakamotoChainState {
             })?
         };
 
-        let tenure_height = if tenure_changed {
-            // TODO: this should be + ${num_tenures_passed_since_parent}
-            parent_tenure_height + 1
-        } else {
-            parent_tenure_height
-        };
-
         // verify VRF proof, if present
         // only need to do this once per tenure
         // get the resulting vrf proof bytes
-        let vrf_proof_opt = if tenure_changed {
+        let vrf_proof_opt = if new_tenure {
             Self::check_block_commit_vrf_seed(chainstate_tx.deref(), burn_dbconn, block)?;
             Some(
                 block
@@ -2418,6 +3114,25 @@ impl NakamotoChainState {
             None
         };
 
+        // process the tenure-change if it happened, so that when block-processing begins, it happens in whatever the
+        // current tenure is
+        let tenure_height =
+            Self::advance_nakamoto_tenure(chainstate_tx, burn_dbconn, block, parent_tenure_height)?;
+        if new_tenure {
+            // tenure height must have advanced
+            if tenure_height
+                != parent_tenure_height
+                    .checked_add(1)
+                    .expect("Too many tenures")
+            {
+                // this should be unreachable
+                return Err(ChainstateError::InvalidStacksBlock(
+                    "Could not advance tenure, even though tenure changed".into(),
+                ));
+            }
+        }
+
+        // begin processing this block
         let SetupBlockResult {
             mut clarity_tx,
             mut tx_receipts,
@@ -2441,8 +3156,7 @@ impl NakamotoChainState {
             burn_header_height.try_into().map_err(|_| {
                 ChainstateError::InvalidStacksBlock("Burn block height exceeded u32".into())
             })?,
-            mainnet,
-            tenure_changed,
+            new_tenure,
             tenure_height,
         )?;
 
@@ -2484,21 +3198,13 @@ impl NakamotoChainState {
 
         // obtain reward info for receipt -- consolidate miner, user, and parent rewards into a
         // single list, but keep the miner/user/parent/info tuple for advancing the chain tip
-        // TODO: drop user burn support
-        let (matured_rewards, miner_payouts_opt) =
-            if let Some(matured_miner_rewards) = matured_miner_rewards_opt {
-                let (miner_reward, parent_reward, reward_ptr) = matured_miner_rewards;
-
-                let mut ret = vec![];
-                ret.push(miner_reward.clone());
-                ret.push(parent_reward.clone());
-                (ret, Some((miner_reward, parent_reward, reward_ptr)))
-            } else {
-                (vec![], None)
-            };
+        let matured_rewards = matured_miner_rewards_opt
+            .as_ref()
+            .map(|matured_miner_rewards| matured_miner_rewards.consolidate())
+            .unwrap_or(vec![]);
 
         let mut lockup_events =
-            match Self::finish_block(&mut clarity_tx, miner_payouts_opt.as_ref()) {
+            match Self::finish_block(&mut clarity_tx, matured_miner_rewards_opt.as_ref()) {
                 Err(ChainstateError::InvalidStacksBlock(e)) => {
                     clarity_tx.rollback_block();
                     return Err(ChainstateError::InvalidStacksBlock(e));
@@ -2532,6 +3238,7 @@ impl NakamotoChainState {
             }
         }
 
+        // verify that the resulting chainstate matches the block's state root
         let root_hash = clarity_tx.seal();
         if root_hash != block.header.state_index_root {
             let msg = format!(
@@ -2554,82 +3261,26 @@ impl NakamotoChainState {
         let clarity_commit =
             clarity_tx.precommit_to_block(&block.header.consensus_hash, &block_hash);
 
-        // figure out if there any accumulated rewards by
-        //   getting the snapshot that elected this block.
-        let accumulated_rewards = SortitionDB::get_block_snapshot_consensus(
-            burn_dbconn.tx(),
-            &block.header.consensus_hash,
-        )?
-        .expect("CORRUPTION: failed to load snapshot that elected processed block")
-        .accumulated_coinbase_ustx;
-
-        let coinbase_at_block = StacksChainState::get_coinbase_reward(
-            u64::from(chain_tip_burn_header_height),
-            burn_dbconn.context.first_block_height,
-        );
-
-        let total_coinbase = coinbase_at_block.saturating_add(accumulated_rewards);
-
-        let scheduled_miner_reward = if tenure_changed {
-            let parent_tenure_header: StacksHeaderInfo = Self::get_header_by_tenure_height(
+        // calculate the reward for this tenure
+        let scheduled_miner_reward = if new_tenure {
+            Some(Self::calculate_scheduled_tenure_reward(
                 chainstate_tx,
-                &parent_block_id,
-                parent_tenure_height,
-            )?
-            .ok_or_else(|| {
-                warn!("While processing tenure change, failed to look up parent tenure";
-                      "parent_tenure_height" => parent_tenure_height,
-                      "parent_block_id" => %parent_block_id,
-                      "block_hash" => %block_hash,
-                      "block_consensus_hash" => %block.header.consensus_hash);
-                ChainstateError::NoSuchBlockError
-            })?;
-            // fetch the parent tenure fees by reading the total tx fees from this block's
-            // *parent* (not parent_tenure_header), because `parent_block_id` is the last
-            // block of that tenure, so contains a total fee accumulation for the whole tenure
-            let parent_tenure_fees = if parent_tenure_header.is_nakamoto_block() {
-                Self::get_total_tenure_tx_fees_at(
-                    chainstate_tx,
-                    &parent_block_id
-                )?.ok_or_else(|| {
-                    warn!("While processing tenure change, failed to look up parent block's total tx fees";
-                          "parent_block_id" => %parent_block_id,
-                          "block_hash" => %block_hash,
-                          "block_consensus_hash" => %block.header.consensus_hash);
-                    ChainstateError::NoSuchBlockError
-                })?
-            } else {
-                // if the parent tenure is an epoch-2 block, don't pay
-                // any fees to them in this schedule: nakamoto blocks
-                // cannot confirm microblock transactions, and
-                // anchored transactions are scheduled
-                // by the parent in epoch-2.
-                0
-            };
-
-            Some(Self::make_scheduled_miner_reward(
-                mainnet,
+                burn_dbconn,
+                block,
                 evaluated_epoch,
-                &parent_tenure_header.anchored_header.block_hash(),
-                &parent_tenure_header.consensus_hash,
-                &block_hash,
-                &block.header.consensus_hash,
-                next_block_height,
-                block
-                    .get_coinbase_tx()
-                    .ok_or(ChainstateError::InvalidStacksBlock(
-                        "No coinbase transaction in tenure changing block".into(),
-                    ))?,
-                parent_tenure_fees,
+                parent_tenure_height,
+                chain_tip_burn_header_height.into(),
                 burnchain_commit_burn,
                 burnchain_sortition_burn,
-                total_coinbase,
-            ))
+            )?)
         } else {
             None
         };
 
-        let matured_rewards_info = miner_payouts_opt.as_ref().map(|(_, _, info)| info.clone());
+        // extract matured rewards info -- we'll need it for the receipt
+        let matured_rewards_info_opt = matured_miner_rewards_opt
+            .as_ref()
+            .map(|rewards| rewards.reward_info.clone());
 
         let new_tip = Self::advance_tip(
             &mut chainstate_tx.tx,
@@ -2641,7 +3292,7 @@ impl NakamotoChainState {
             chain_tip_burn_header_height,
             chain_tip_burn_header_timestamp,
             scheduled_miner_reward.as_ref(),
-            miner_payouts_opt,
+            matured_miner_rewards_opt,
             &block_execution_cost,
             &total_tenure_cost,
             block_size,
@@ -2649,8 +3300,7 @@ impl NakamotoChainState {
             burn_stack_stx_ops,
             burn_transfer_stx_ops,
             burn_delegate_stx_ops,
-            tenure_height,
-            tenure_changed,
+            new_tenure,
             block_fees,
         )
         .expect("FATAL: failed to advance chain tip");
@@ -2661,41 +3311,18 @@ impl NakamotoChainState {
         monitoring::set_last_block_transaction_count(u64::try_from(block.txs.len()).unwrap());
         monitoring::set_last_execution_cost_observed(&block_execution_cost, &block_limit);
 
-        // get previous burn block stats
+        // get previous burn block stats, for the transaction receipt
         let (parent_burn_block_hash, parent_burn_block_height, parent_burn_block_timestamp) =
-            if block.is_first_mined() {
-                (BurnchainHeaderHash([0; 32]), 0, 0)
-            } else {
-                match SortitionDB::get_block_snapshot_consensus(burn_dbconn, &parent_ch)? {
-                    Some(sn) => (
-                        sn.burn_header_hash,
-                        u32::try_from(sn.block_height).map_err(|_| {
-                            ChainstateError::InvalidStacksBlock(
-                                "Burn block height exceeds u32".into(),
-                            )
-                        })?,
-                        sn.burn_header_timestamp,
-                    ),
-                    None => {
-                        // shouldn't happen
-                        warn!(
-                            "CORRUPTION: block {}/{} does not correspond to a burn block",
-                            &parent_ch, &parent_block_hash
-                        );
-                        (BurnchainHeaderHash([0; 32]), 0, 0)
-                    }
-                }
-            };
-
+            Self::get_tenure_burn_block_info(burn_dbconn, block.is_first_mined(), &parent_ch)?;
         let epoch_receipt = StacksEpochReceipt {
             header: new_tip,
             tx_receipts,
             matured_rewards,
-            matured_rewards_info,
+            matured_rewards_info: matured_rewards_info_opt,
             parent_microblocks_cost: ExecutionCost::zero(),
             anchored_block_cost: block_execution_cost,
             parent_burn_block_hash,
-            parent_burn_block_height,
+            parent_burn_block_height: u32::try_from(parent_burn_block_height).unwrap_or(0), // shouldn't be fatal
             parent_burn_block_timestamp,
             evaluated_epoch,
             epoch_transition: applied_epoch_transition,

From 948595c45e3bcc2b162c5bcbeccd6185a5837165 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Fri, 1 Dec 2023 12:24:10 -0500
Subject: [PATCH 0077/1166] testing: expand unit testing for tenure-start block
 validation, coinbase validation, and tenure table structure and queries

---
 .../src/chainstate/nakamoto/tests/mod.rs      | 676 ++++++++++++++++--
 1 file changed, 622 insertions(+), 54 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/tests/mod.rs b/stackslib/src/chainstate/nakamoto/tests/mod.rs
index cd76000b0c..110d876b24 100644
--- a/stackslib/src/chainstate/nakamoto/tests/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/mod.rs
@@ -24,12 +24,12 @@ use clarity::vm::types::StacksAddressExtensions;
 use stacks_common::consts::{FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH};
 use stacks_common::types::chainstate::{
     BlockHeaderHash, BurnchainHeaderHash, ConsensusHash, StacksAddress, StacksPrivateKey,
-    StacksWorkScore, TrieHash,
+    StacksPublicKey, StacksWorkScore, TrieHash,
 };
-use stacks_common::types::{PrivateKey, StacksEpoch, StacksEpochId};
+use stacks_common::types::{Address, PrivateKey, StacksEpoch, StacksEpochId};
 use stacks_common::util::hash::{hex_bytes, Hash160, MerkleTree, Sha512Trunc256Sum};
 use stacks_common::util::secp256k1::{MessageSignature, Secp256k1PublicKey};
-use stacks_common::util::vrf::{VRFPrivateKey, VRFProof};
+use stacks_common::util::vrf::{VRFPrivateKey, VRFProof, VRFPublicKey, VRF};
 use stdext::prelude::Integer;
 use stx_genesis::GenesisData;
 
@@ -40,7 +40,9 @@ use crate::chainstate::coordinator::tests::{
     get_burnchain, get_burnchain_db, get_chainstate, get_rw_sortdb, get_sortition_db, p2pkh_from,
     pox_addr_from, setup_states_with_epochs,
 };
-use crate::chainstate::nakamoto::{NakamotoBlock, NakamotoBlockHeader, NakamotoChainState};
+use crate::chainstate::nakamoto::{
+    NakamotoBlock, NakamotoBlockHeader, NakamotoChainState, NakamotoTenure,
+};
 use crate::chainstate::stacks::db::{
     ChainStateBootData, ChainstateAccountBalance, ChainstateAccountLockup, ChainstateBNSName,
     ChainstateBNSNamespace, StacksAccount, StacksBlockHeaderTypes, StacksChainState,
@@ -149,7 +151,10 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
         stacker_signature: MessageSignature::empty(),
     };
 
+    // sortition-inducing tenure change
     let tenure_change_payload = TransactionPayload::TenureChange(TenureChangePayload {
+        consensus_hash: ConsensusHash([0x04; 20]),
+        prev_consensus_hash: ConsensusHash([0x03; 20]),
         previous_tenure_end: header.parent_block_id.clone(),
         previous_tenure_blocks: 1,
         cause: TenureChangeCause::BlockFound,
@@ -158,8 +163,22 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
         signers: vec![],
     });
 
+    // non-sortition-inducing tenure change
+    let tenure_extend_payload = TransactionPayload::TenureChange(TenureChangePayload {
+        consensus_hash: ConsensusHash([0x04; 20]),
+        prev_consensus_hash: ConsensusHash([0x03; 20]),
+        previous_tenure_end: header.parent_block_id.clone(),
+        previous_tenure_blocks: 1,
+        cause: TenureChangeCause::Extended,
+        pubkey_hash: Hash160([0x02; 20]),
+        signature: SchnorrThresholdSignature {},
+        signers: vec![],
+    });
+
     let invalid_tenure_change_payload = TransactionPayload::TenureChange(TenureChangePayload {
         // bad parent block ID
+        consensus_hash: ConsensusHash([0x04; 20]),
+        prev_consensus_hash: ConsensusHash([0x03; 20]),
         previous_tenure_end: StacksBlockId([0x00; 32]),
         previous_tenure_blocks: 1,
         cause: TenureChangeCause::BlockFound,
@@ -186,6 +205,14 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
     tenure_change_tx.chain_id = 0x80000000;
     tenure_change_tx.anchor_mode = TransactionAnchorMode::OnChainOnly;
 
+    let mut tenure_extend_tx = StacksTransaction::new(
+        TransactionVersion::Testnet,
+        TransactionAuth::from_p2pkh(&private_key).unwrap(),
+        tenure_extend_payload.clone(),
+    );
+    tenure_extend_tx.chain_id = 0x80000000;
+    tenure_extend_tx.anchor_mode = TransactionAnchorMode::OnChainOnly;
+
     let mut invalid_tenure_change_tx = StacksTransaction::new(
         TransactionVersion::Testnet,
         TransactionAuth::from_p2pkh(&private_key).unwrap(),
@@ -210,13 +237,26 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
     invalid_coinbase_tx.chain_id = 0x80000000;
     invalid_coinbase_tx.anchor_mode = TransactionAnchorMode::OnChainOnly;
 
+    let recipient_addr =
+        StacksAddress::from_string("ST2YM3J4KQK09V670TD6ZZ1XYNYCNGCWCVTASN5VM").unwrap();
+    let mut stx_transfer = StacksTransaction::new(
+        TransactionVersion::Testnet,
+        TransactionAuth::from_p2pkh(&private_key).unwrap(),
+        TransactionPayload::TokenTransfer(
+            recipient_addr.to_account_principal(),
+            1,
+            TokenTransferMemo([0x00; 34]),
+        ),
+    );
+    stx_transfer.chain_id = 0x80000000;
+    stx_transfer.anchor_mode = TransactionAnchorMode::OnChainOnly;
+
     // no tenure change if the block doesn't have a tenure change
     let block = NakamotoBlock {
         header: header.clone(),
         txs: vec![],
     };
-    assert_eq!(block.is_wellformed_first_tenure_block(), None);
-    assert_eq!(block.tenure_changed(), None);
+    assert_eq!(block.is_wellformed_tenure_start_block(), None);
     assert_eq!(block.get_coinbase_tx(), None);
     assert_eq!(block.get_vrf_proof(), None);
     assert_eq!(
@@ -224,14 +264,14 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
         false
     ); // empty blocks not allowed
 
-    // syntactically invalid block if there's a tenure change but no coinbase
+    // syntactically invalid block if there's a sortition-inducing tenure change but no coinbase
     let block = NakamotoBlock {
         header: header.clone(),
         txs: vec![tenure_change_tx.clone()],
     };
-    assert_eq!(block.is_wellformed_first_tenure_block(), Some(false));
-    assert_eq!(block.tenure_changed(), Some(false));
+    assert_eq!(block.is_wellformed_tenure_start_block(), Some(false));
     assert_eq!(block.get_coinbase_tx(), None);
+    assert_eq!(block.get_tenure_change_tx(), None);
     assert_eq!(block.get_vrf_proof(), None);
     assert_eq!(
         block.validate_transactions_static(false, 0x80000000, StacksEpochId::Epoch30),
@@ -243,9 +283,9 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
         header: header.clone(),
         txs: vec![coinbase_tx.clone()],
     };
-    assert_eq!(block.is_wellformed_first_tenure_block(), Some(false));
-    assert_eq!(block.tenure_changed(), Some(false));
+    assert_eq!(block.is_wellformed_tenure_start_block(), Some(false));
     assert_eq!(block.get_coinbase_tx(), None);
+    assert_eq!(block.get_tenure_change_tx(), None);
     assert_eq!(block.get_vrf_proof(), None);
     assert_eq!(
         block.validate_transactions_static(false, 0x80000000, StacksEpochId::Epoch30),
@@ -258,9 +298,9 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
         header: header.clone(),
         txs: vec![tenure_change_tx.clone(), invalid_coinbase_tx.clone()],
     };
-    assert_eq!(block.is_wellformed_first_tenure_block(), Some(false));
-    assert_eq!(block.tenure_changed(), Some(false));
+    assert_eq!(block.is_wellformed_tenure_start_block(), Some(false));
     assert_eq!(block.get_coinbase_tx(), None);
+    assert_eq!(block.get_tenure_change_tx(), None);
     assert_eq!(block.get_vrf_proof(), None);
     assert_eq!(
         block.validate_transactions_static(false, 0x80000000, StacksEpochId::Epoch30),
@@ -276,9 +316,9 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
             coinbase_tx.clone(),
         ],
     };
-    assert_eq!(block.is_wellformed_first_tenure_block(), Some(false));
-    assert_eq!(block.tenure_changed(), Some(false));
+    assert_eq!(block.is_wellformed_tenure_start_block(), Some(false));
     assert_eq!(block.get_coinbase_tx(), None);
+    assert_eq!(block.get_tenure_change_tx(), None);
     assert_eq!(block.get_vrf_proof(), None);
     assert_eq!(
         block.validate_transactions_static(false, 0x80000000, StacksEpochId::Epoch30),
@@ -290,9 +330,9 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
         header: header.clone(),
         txs: vec![coinbase_tx.clone(), tenure_change_tx.clone()],
     };
-    assert_eq!(block.is_wellformed_first_tenure_block(), Some(false));
-    assert_eq!(block.tenure_changed(), Some(false));
+    assert_eq!(block.is_wellformed_tenure_start_block(), Some(false));
     assert_eq!(block.get_coinbase_tx(), None);
+    assert_eq!(block.get_tenure_change_tx(), None);
     assert_eq!(block.get_vrf_proof(), None);
     assert_eq!(
         block.validate_transactions_static(false, 0x80000000, StacksEpochId::Epoch30),
@@ -308,9 +348,9 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
             tenure_change_tx.clone(),
         ],
     };
-    assert_eq!(block.is_wellformed_first_tenure_block(), Some(false));
-    assert_eq!(block.tenure_changed(), Some(false));
+    assert_eq!(block.is_wellformed_tenure_start_block(), Some(false));
     assert_eq!(block.get_coinbase_tx(), None);
+    assert_eq!(block.get_tenure_change_tx(), None);
     assert_eq!(block.get_vrf_proof(), None);
     assert_eq!(
         block.validate_transactions_static(false, 0x80000000, StacksEpochId::Epoch30),
@@ -326,32 +366,89 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
             coinbase_tx.clone(),
         ],
     };
-    assert_eq!(block.is_wellformed_first_tenure_block(), Some(true));
-    assert_eq!(block.tenure_changed(), Some(false));
-    assert_eq!(block.get_coinbase_tx(), Some(&coinbase_tx));
-    assert_eq!(block.get_vrf_proof(), Some(&proof));
+    assert_eq!(block.is_wellformed_tenure_start_block(), Some(false));
+    assert_eq!(block.get_coinbase_tx(), None);
+    assert_eq!(block.get_tenure_change_tx(), None);
+    assert_eq!(block.get_vrf_proof(), None);
     assert_eq!(
         block.validate_transactions_static(false, 0x80000000, StacksEpochId::Epoch30),
         false
     );
 
-    // syntactically valid only if we have syntactically valid tenure changes and a syntactically
+    // syntactically valid tenure-start block only if we have a syntactically valid tenure change and a syntactically
     // valid coinbase
     let block = NakamotoBlock {
         header: header.clone(),
         txs: vec![tenure_change_tx.clone(), coinbase_tx.clone()],
     };
-    assert_eq!(block.is_wellformed_first_tenure_block(), Some(true));
-    assert_eq!(block.tenure_changed(), Some(true));
+    assert_eq!(block.is_wellformed_tenure_start_block(), Some(true));
     assert_eq!(block.get_coinbase_tx(), Some(&coinbase_tx));
+    assert_eq!(block.get_tenure_change_tx(), Some(&tenure_change_tx));
     assert_eq!(block.get_vrf_proof(), Some(&proof));
     assert_eq!(
         block.validate_transactions_static(false, 0x80000000, StacksEpochId::Epoch30),
         true
     );
 
-    // can have multiple valid tenure changes (but note that this block is syntactically invalid
-    // because duplicate txs are not allowed)
+    // syntactically valid non-tenure-start block only if we have a syntactically valid tenure change which is not sortition-induced,
+    // or we don't have one at all.
+    let block = NakamotoBlock {
+        header: header.clone(),
+        txs: vec![tenure_extend_tx.clone()],
+    };
+    assert_eq!(block.is_wellformed_tenure_start_block(), None);
+    assert_eq!(block.get_coinbase_tx(), None);
+    assert_eq!(block.get_tenure_change_tx(), Some(&tenure_extend_tx));
+    assert_eq!(block.get_vrf_proof(), None);
+    assert_eq!(
+        block.validate_transactions_static(false, 0x80000000, StacksEpochId::Epoch30),
+        true
+    );
+
+    // syntactically valid non-tenure-start block only if we have a syntactically valid tenure change which is not sortition-induced,
+    // or we don't have one at all.
+    let block = NakamotoBlock {
+        header: header.clone(),
+        txs: vec![tenure_extend_tx.clone(), stx_transfer.clone()],
+    };
+    assert_eq!(block.is_wellformed_tenure_start_block(), None);
+    assert_eq!(block.get_coinbase_tx(), None);
+    assert_eq!(block.get_tenure_change_tx(), Some(&tenure_extend_tx));
+    assert_eq!(block.get_vrf_proof(), None);
+    assert_eq!(
+        block.validate_transactions_static(false, 0x80000000, StacksEpochId::Epoch30),
+        true
+    );
+
+    // syntactically invalid if there's more than one tenure change, no matter what
+    let block = NakamotoBlock {
+        header: header.clone(),
+        txs: vec![tenure_extend_tx.clone(), tenure_extend_tx.clone()],
+    };
+    assert_eq!(block.is_wellformed_tenure_start_block(), Some(false));
+    assert_eq!(block.get_coinbase_tx(), None);
+    assert_eq!(block.get_tenure_change_tx(), None);
+    assert_eq!(block.get_vrf_proof(), None);
+    assert_eq!(
+        block.validate_transactions_static(false, 0x80000000, StacksEpochId::Epoch30),
+        false
+    );
+
+    // syntactically invalid if there's a tx before the one tenure change
+    let block = NakamotoBlock {
+        header: header.clone(),
+        txs: vec![stx_transfer.clone(), tenure_extend_tx.clone()],
+    };
+    assert_eq!(block.is_wellformed_tenure_start_block(), Some(false));
+    assert_eq!(block.get_coinbase_tx(), None);
+    assert_eq!(block.get_tenure_change_tx(), None);
+    assert_eq!(block.get_vrf_proof(), None);
+    assert_eq!(
+        block.validate_transactions_static(false, 0x80000000, StacksEpochId::Epoch30),
+        false
+    );
+
+    // invalid if there are multiple tenure changes
     let block = NakamotoBlock {
         header: header.clone(),
         txs: vec![
@@ -360,14 +457,14 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
             coinbase_tx.clone(),
         ],
     };
-    assert_eq!(block.is_wellformed_first_tenure_block(), Some(true));
-    assert_eq!(block.tenure_changed(), Some(true));
-    assert_eq!(block.get_coinbase_tx(), Some(&coinbase_tx));
-    assert_eq!(block.get_vrf_proof(), Some(&proof));
+    assert_eq!(block.is_wellformed_tenure_start_block(), Some(false));
+    assert_eq!(block.get_coinbase_tx(), None);
+    assert_eq!(block.get_tenure_change_tx(), None);
+    assert_eq!(block.get_vrf_proof(), None);
     assert_eq!(
         block.validate_transactions_static(false, 0x80000000, StacksEpochId::Epoch30),
         false
-    ); // duplicate transaction
+    );
 }
 
 #[test]
@@ -458,22 +555,36 @@ pub fn test_load_store_update_nakamoto_blocks() {
         runtime: 104,
     };
 
-    let tenure_change_payload = TransactionPayload::TenureChange(TenureChangePayload {
+    let tenure_change_payload = TenureChangePayload {
+        consensus_hash: ConsensusHash([0x04; 20]), // same as in nakamoto header
+        prev_consensus_hash: ConsensusHash([0x01; 20]),
         previous_tenure_end: epoch2_parent_block_id.clone(),
         previous_tenure_blocks: 1,
         cause: TenureChangeCause::BlockFound,
         pubkey_hash: Hash160([0x02; 20]),
         signature: SchnorrThresholdSignature {},
         signers: vec![],
-    });
+    };
+
+    let tenure_change_tx_payload = TransactionPayload::TenureChange(tenure_change_payload.clone());
     let mut tenure_change_tx = StacksTransaction::new(
         TransactionVersion::Testnet,
         TransactionAuth::from_p2pkh(&private_key).unwrap(),
-        tenure_change_payload.clone(),
+        tenure_change_tx_payload.clone(),
     );
     tenure_change_tx.chain_id = 0x80000000;
     tenure_change_tx.anchor_mode = TransactionAnchorMode::OnChainOnly;
 
+    let recipient_addr =
+        StacksAddress::from_string("ST2YM3J4KQK09V670TD6ZZ1XYNYCNGCWCVTASN5VM").unwrap();
+    let mut stx_transfer_tx = StacksTransaction::new(
+        TransactionVersion::Testnet,
+        TransactionAuth::from_p2pkh(&private_key).unwrap(),
+        TransactionPayload::TokenTransfer(recipient_addr.into(), 123, TokenTransferMemo([0u8; 34])),
+    );
+    stx_transfer_tx.chain_id = 0x80000000;
+    stx_transfer_tx.anchor_mode = TransactionAnchorMode::OnChainOnly;
+
     let nakamoto_txs = vec![tenure_change_tx.clone(), coinbase_tx.clone()];
     let nakamoto_tx_merkle_root = {
         let txid_vecs = nakamoto_txs
@@ -484,11 +595,21 @@ pub fn test_load_store_update_nakamoto_blocks() {
         MerkleTree::<Sha512Trunc256Sum>::new(&txid_vecs).root()
     };
 
+    let nakamoto_txs_2 = vec![stx_transfer_tx.clone()];
+    let nakamoto_tx_merkle_root_2 = {
+        let txid_vecs = nakamoto_txs_2
+            .iter()
+            .map(|tx| tx.txid().as_bytes().to_vec())
+            .collect();
+
+        MerkleTree::<Sha512Trunc256Sum>::new(&txid_vecs).root()
+    };
+
     let nakamoto_header = NakamotoBlockHeader {
         version: 1,
         chain_length: 457,
         burn_spent: 126,
-        consensus_hash: ConsensusHash([0x04; 20]),
+        consensus_hash: tenure_change_payload.consensus_hash.clone(),
         parent_block_id: epoch2_parent_block_id.clone(),
         tx_merkle_root: nakamoto_tx_merkle_root,
         state_index_root: TrieHash([0x07; 32]),
@@ -508,6 +629,16 @@ pub fn test_load_store_update_nakamoto_blocks() {
         anchored_block_size: 123,
     };
 
+    let epoch2_block = StacksBlock {
+        header: epoch2_header.clone(),
+        txs: epoch2_txs,
+    };
+
+    let nakamoto_block = NakamotoBlock {
+        header: nakamoto_header.clone(),
+        txs: nakamoto_txs,
+    };
+
     let nakamoto_execution_cost = ExecutionCost {
         write_length: 200,
         write_count: 201,
@@ -516,22 +647,56 @@ pub fn test_load_store_update_nakamoto_blocks() {
         runtime: 204,
     };
 
-    let total_nakamoto_execution_cost = ExecutionCost {
-        write_length: 400,
-        write_count: 401,
-        read_length: 402,
-        read_count: 403,
-        runtime: 404,
+    // second nakamoto block
+    let nakamoto_header_2 = NakamotoBlockHeader {
+        version: 1,
+        chain_length: 458,
+        burn_spent: 127,
+        consensus_hash: tenure_change_payload.consensus_hash.clone(),
+        parent_block_id: nakamoto_header.block_id(),
+        tx_merkle_root: nakamoto_tx_merkle_root_2,
+        state_index_root: TrieHash([0x07; 32]),
+        miner_signature: MessageSignature::empty(),
+        stacker_signature: MessageSignature::empty(),
     };
 
-    let epoch2_block = StacksBlock {
-        header: epoch2_header.clone(),
-        txs: epoch2_txs,
+    let nakamoto_header_info_2 = StacksHeaderInfo {
+        anchored_header: StacksBlockHeaderTypes::Nakamoto(nakamoto_header_2.clone()),
+        microblock_tail: None,
+        stacks_block_height: nakamoto_header_2.chain_length,
+        index_root: TrieHash([0x67; 32]),
+        consensus_hash: nakamoto_header_2.consensus_hash.clone(),
+        burn_header_hash: BurnchainHeaderHash([0x88; 32]),
+        burn_header_height: 200,
+        burn_header_timestamp: 1001,
+        anchored_block_size: 123,
     };
 
-    let nakamoto_block = NakamotoBlock {
-        header: nakamoto_header.clone(),
-        txs: nakamoto_txs,
+    let nakamoto_block_2 = NakamotoBlock {
+        header: nakamoto_header_2.clone(),
+        txs: nakamoto_txs_2,
+    };
+
+    let nakamoto_execution_cost_2 = ExecutionCost {
+        write_length: 200,
+        write_count: 201,
+        read_length: 202,
+        read_count: 203,
+        runtime: 204,
+    };
+
+    let mut total_nakamoto_execution_cost = nakamoto_execution_cost.clone();
+    total_nakamoto_execution_cost
+        .add(&nakamoto_execution_cost_2)
+        .unwrap();
+
+    let nakamoto_tenure = NakamotoTenure {
+        consensus_hash: tenure_change_payload.consensus_hash.clone(),
+        prev_consensus_hash: tenure_change_payload.prev_consensus_hash.clone(),
+        block_hash: nakamoto_block.header.block_hash(),
+        block_id: nakamoto_block.header.block_id(),
+        tenure_height: epoch2_header.total_work.work + 1,
+        num_blocks_confirmed: 1,
     };
 
     let mut chainstate = get_chainstate(&path);
@@ -547,19 +712,147 @@ pub fn test_load_store_update_nakamoto_blocks() {
             1,
         )
         .unwrap();
+
+        // tenure length doesn't apply to epoch2 blocks
+        assert_eq!(
+            NakamotoChainState::get_nakamoto_tenure_length(&tx, &epoch2_header_info.consensus_hash)
+                .unwrap(),
+            0
+        );
+
+        // no tenure rows
+        assert_eq!(
+            NakamotoChainState::get_highest_nakamoto_tenure_height(&tx).unwrap(),
+            None
+        );
+
+        // but, this upcoming tenure-change payload should be the first-ever tenure-change payload!
+        assert!(NakamotoChainState::check_first_nakamoto_tenure_change(
+            &tx,
+            &tenure_change_payload
+        )
+        .unwrap());
+
+        // this will fail without a tenure (e.g. due to foreign key constraints)
         NakamotoChainState::insert_stacks_block_header(
             &tx,
             &nakamoto_header_info,
             &nakamoto_header,
             Some(&nakamoto_proof),
             &nakamoto_execution_cost,
-            &total_nakamoto_execution_cost,
-            epoch2_header_info.anchored_header.height() + 1,
+            &nakamoto_execution_cost,
+            true,
+            300,
+        )
+        .unwrap_err();
+
+        // no tenure yet, so zero blocks
+        assert_eq!(
+            NakamotoChainState::get_nakamoto_tenure_length(
+                &tx,
+                &nakamoto_block.header.consensus_hash
+            )
+            .unwrap(),
+            0
+        );
+
+        // no tenure rows
+        assert_eq!(
+            NakamotoChainState::get_highest_nakamoto_tenure_height(&tx).unwrap(),
+            None
+        );
+
+        // add the tenure for these blocks
+        NakamotoChainState::insert_nakamoto_tenure(
+            &tx,
+            &nakamoto_header,
+            epoch2_header.total_work.work + 1,
+            &tenure_change_payload,
+        )
+        .unwrap();
+
+        // no blocks yet, so zero blocks
+        assert_eq!(
+            NakamotoChainState::get_nakamoto_tenure_length(
+                &tx,
+                &nakamoto_block.header.consensus_hash
+            )
+            .unwrap(),
+            0
+        );
+
+        // have a tenure
+        assert_eq!(
+            NakamotoChainState::get_highest_nakamoto_tenure_height(&tx)
+                .unwrap()
+                .unwrap(),
+            epoch2_header.total_work.work + 1
+        );
+
+        // this succeeds now
+        NakamotoChainState::insert_stacks_block_header(
+            &tx,
+            &nakamoto_header_info,
+            &nakamoto_header,
+            Some(&nakamoto_proof),
+            &nakamoto_execution_cost,
+            &nakamoto_execution_cost,
             true,
             300,
         )
         .unwrap();
         NakamotoChainState::store_block(&tx, nakamoto_block.clone(), false, false).unwrap();
+
+        // tenure has one block
+        assert_eq!(
+            NakamotoChainState::get_nakamoto_tenure_length(
+                &tx,
+                &nakamoto_block.header.consensus_hash
+            )
+            .unwrap(),
+            1
+        );
+
+        // same tenure
+        assert_eq!(
+            NakamotoChainState::get_highest_nakamoto_tenure_height(&tx)
+                .unwrap()
+                .unwrap(),
+            epoch2_header.total_work.work + 1
+        );
+
+        // this succeeds now
+        NakamotoChainState::insert_stacks_block_header(
+            &tx,
+            &nakamoto_header_info_2,
+            &nakamoto_header_2,
+            None,
+            &nakamoto_execution_cost,
+            &total_nakamoto_execution_cost,
+            false,
+            400,
+        )
+        .unwrap();
+
+        NakamotoChainState::store_block(&tx, nakamoto_block_2.clone(), false, false).unwrap();
+
+        // tenure has two blocks
+        assert_eq!(
+            NakamotoChainState::get_nakamoto_tenure_length(
+                &tx,
+                &nakamoto_block.header.consensus_hash
+            )
+            .unwrap(),
+            2
+        );
+
+        // same tenure
+        assert_eq!(
+            NakamotoChainState::get_highest_nakamoto_tenure_height(&tx)
+                .unwrap()
+                .unwrap(),
+            epoch2_header.total_work.work + 1
+        );
         tx.commit().unwrap();
     }
 
@@ -574,6 +867,16 @@ pub fn test_load_store_update_nakamoto_blocks() {
         .unwrap(),
         nakamoto_block
     );
+    assert_eq!(
+        NakamotoChainState::load_nakamoto_block(
+            chainstate.db(),
+            &nakamoto_header_2.consensus_hash,
+            &nakamoto_header_2.block_hash()
+        )
+        .unwrap()
+        .unwrap(),
+        nakamoto_block_2
+    );
     assert_eq!(
         NakamotoChainState::load_nakamoto_block(
             chainstate.db(),
@@ -595,6 +898,16 @@ pub fn test_load_store_update_nakamoto_blocks() {
         .unwrap(),
         (false, false)
     );
+    assert_eq!(
+        NakamotoChainState::get_nakamoto_block_status(
+            chainstate.db(),
+            &nakamoto_header_2.consensus_hash,
+            &nakamoto_header_2.block_hash()
+        )
+        .unwrap()
+        .unwrap(),
+        (false, false)
+    );
     assert_eq!(
         NakamotoChainState::get_nakamoto_block_status(
             chainstate.db(),
@@ -651,7 +964,7 @@ pub fn test_load_store_update_nakamoto_blocks() {
         );
     }
 
-    // only one nakamoto block in this tenure, so it's both the start and finish
+    // check start/finish
     assert_eq!(
         NakamotoChainState::get_nakamoto_tenure_start_block_header(
             chainstate.db(),
@@ -668,7 +981,7 @@ pub fn test_load_store_update_nakamoto_blocks() {
         )
         .unwrap()
         .unwrap(),
-        nakamoto_header_info
+        nakamoto_header_info_2
     );
 
     // can query the tenure-start and epoch2 headers by consensus hash
@@ -698,6 +1011,12 @@ pub fn test_load_store_update_nakamoto_blocks() {
             .unwrap(),
         nakamoto_header_info
     );
+    assert_eq!(
+        NakamotoChainState::get_block_header(chainstate.db(), &nakamoto_header_2.block_id())
+            .unwrap()
+            .unwrap(),
+        nakamoto_header_info_2
+    );
     assert_eq!(
         NakamotoChainState::get_block_header(
             chainstate.db(),
@@ -715,6 +1034,12 @@ pub fn test_load_store_update_nakamoto_blocks() {
             .unwrap(),
         epoch2_header_info.anchored_header.height() + 1
     );
+    assert_eq!(
+        NakamotoChainState::get_tenure_height(chainstate.db(), &nakamoto_header_2.block_id())
+            .unwrap()
+            .unwrap(),
+        epoch2_header_info.anchored_header.height() + 1
+    );
     assert_eq!(
         NakamotoChainState::get_tenure_height(
             chainstate.db(),
@@ -730,6 +1055,15 @@ pub fn test_load_store_update_nakamoto_blocks() {
         NakamotoChainState::get_total_tenure_cost_at(chainstate.db(), &nakamoto_header.block_id())
             .unwrap()
             .unwrap(),
+        nakamoto_execution_cost
+    );
+    assert_eq!(
+        NakamotoChainState::get_total_tenure_cost_at(
+            chainstate.db(),
+            &nakamoto_header_2.block_id()
+        )
+        .unwrap()
+        .unwrap(),
         total_nakamoto_execution_cost
     );
     assert_eq!(
@@ -751,6 +1085,15 @@ pub fn test_load_store_update_nakamoto_blocks() {
         .unwrap(),
         300
     );
+    assert_eq!(
+        NakamotoChainState::get_total_tenure_tx_fees_at(
+            chainstate.db(),
+            &nakamoto_header_2.block_id()
+        )
+        .unwrap()
+        .unwrap(),
+        400
+    );
     assert_eq!(
         NakamotoChainState::get_total_tenure_tx_fees_at(
             chainstate.db(),
@@ -806,7 +1149,7 @@ pub fn test_load_store_update_nakamoto_blocks() {
             None
         );
 
-        // set parent block processed
+        // set parent epoch2 block processed
         NakamotoChainState::set_block_processed(&tx, &epoch2_header_info.index_block_hash())
             .unwrap();
 
@@ -818,5 +1161,230 @@ pub fn test_load_store_update_nakamoto_blocks() {
                 .0,
             nakamoto_block
         );
+
+        // set parent nakamoto block processed
+        NakamotoChainState::set_block_processed(&tx, &nakamoto_header_info.index_block_hash())
+            .unwrap();
+
+        // next nakamoto block
+        assert_eq!(
+            NakamotoChainState::next_ready_nakamoto_block(&tx)
+                .unwrap()
+                .unwrap()
+                .0,
+            nakamoto_block_2
+        );
     }
 }
+
+/// Tests:
+/// * NakamotoBlockHeader::check_miner_signature
+/// * NakamotoBlockHeader::check_tenure_change_tx
+/// * NakamotoBlockHeader::check_coinbase_tx
+#[test]
+fn test_nakamoto_block_static_verification() {
+    let private_key = StacksPrivateKey::new();
+    let private_key_2 = StacksPrivateKey::new();
+
+    let vrf_privkey = VRFPrivateKey::new();
+    let vrf_pubkey = VRFPublicKey::from_private(&vrf_privkey);
+    let sortition_hash = SortitionHash([0x01; 32]);
+    let vrf_proof = VRF::prove(&vrf_privkey, sortition_hash.as_bytes());
+
+    let coinbase_payload =
+        TransactionPayload::Coinbase(CoinbasePayload([0x12; 32]), None, Some(vrf_proof.clone()));
+
+    let mut coinbase_tx = StacksTransaction::new(
+        TransactionVersion::Testnet,
+        TransactionAuth::from_p2pkh(&private_key).unwrap(),
+        coinbase_payload.clone(),
+    );
+    coinbase_tx.chain_id = 0x80000000;
+    coinbase_tx.anchor_mode = TransactionAnchorMode::OnChainOnly;
+
+    let tenure_change_payload = TenureChangePayload {
+        consensus_hash: ConsensusHash([0x04; 20]), // same as in nakamoto header
+        prev_consensus_hash: ConsensusHash([0x01; 20]),
+        previous_tenure_end: StacksBlockId([0x03; 32]),
+        previous_tenure_blocks: 1,
+        cause: TenureChangeCause::BlockFound,
+        pubkey_hash: Hash160::from_node_public_key(&StacksPublicKey::from_private(&private_key)),
+        signature: SchnorrThresholdSignature {},
+        signers: vec![],
+    };
+
+    let tenure_change_payload_bad_ch = TenureChangePayload {
+        consensus_hash: ConsensusHash([0x05; 20]), // wrong
+        prev_consensus_hash: ConsensusHash([0x01; 20]),
+        previous_tenure_end: StacksBlockId([0x03; 32]),
+        previous_tenure_blocks: 1,
+        cause: TenureChangeCause::BlockFound,
+        pubkey_hash: Hash160::from_node_public_key(&StacksPublicKey::from_private(&private_key)),
+        signature: SchnorrThresholdSignature {},
+        signers: vec![],
+    };
+
+    let tenure_change_payload_bad_miner_sig = TenureChangePayload {
+        consensus_hash: ConsensusHash([0x04; 20]), // same as in nakamoto header
+        prev_consensus_hash: ConsensusHash([0x01; 20]),
+        previous_tenure_end: StacksBlockId([0x03; 32]),
+        previous_tenure_blocks: 1,
+        cause: TenureChangeCause::BlockFound,
+        pubkey_hash: Hash160([0x02; 20]), // wrong
+        signature: SchnorrThresholdSignature {},
+        signers: vec![],
+    };
+
+    let tenure_change_tx_payload = TransactionPayload::TenureChange(tenure_change_payload.clone());
+    let mut tenure_change_tx = StacksTransaction::new(
+        TransactionVersion::Testnet,
+        TransactionAuth::from_p2pkh(&private_key).unwrap(),
+        tenure_change_tx_payload.clone(),
+    );
+    tenure_change_tx.chain_id = 0x80000000;
+    tenure_change_tx.anchor_mode = TransactionAnchorMode::OnChainOnly;
+
+    let tenure_change_tx_payload_bad_ch =
+        TransactionPayload::TenureChange(tenure_change_payload_bad_ch.clone());
+    let mut tenure_change_tx_bad_ch = StacksTransaction::new(
+        TransactionVersion::Testnet,
+        TransactionAuth::from_p2pkh(&private_key).unwrap(),
+        tenure_change_tx_payload_bad_ch.clone(),
+    );
+    tenure_change_tx_bad_ch.chain_id = 0x80000000;
+    tenure_change_tx_bad_ch.anchor_mode = TransactionAnchorMode::OnChainOnly;
+
+    let tenure_change_tx_payload_bad_miner_sig =
+        TransactionPayload::TenureChange(tenure_change_payload_bad_miner_sig.clone());
+    let mut tenure_change_tx_bad_miner_sig = StacksTransaction::new(
+        TransactionVersion::Testnet,
+        TransactionAuth::from_p2pkh(&private_key).unwrap(),
+        tenure_change_tx_payload_bad_miner_sig.clone(),
+    );
+    tenure_change_tx_bad_miner_sig.chain_id = 0x80000000;
+    tenure_change_tx_bad_miner_sig.anchor_mode = TransactionAnchorMode::OnChainOnly;
+
+    let nakamoto_txs = vec![tenure_change_tx.clone(), coinbase_tx.clone()];
+    let nakamoto_tx_merkle_root = {
+        let txid_vecs = nakamoto_txs
+            .iter()
+            .map(|tx| tx.txid().as_bytes().to_vec())
+            .collect();
+
+        MerkleTree::<Sha512Trunc256Sum>::new(&txid_vecs).root()
+    };
+
+    let nakamoto_txs_bad_ch = vec![tenure_change_tx_bad_ch.clone(), coinbase_tx.clone()];
+    let nakamoto_tx_merkle_root_bad_ch = {
+        let txid_vecs = nakamoto_txs_bad_ch
+            .iter()
+            .map(|tx| tx.txid().as_bytes().to_vec())
+            .collect();
+
+        MerkleTree::<Sha512Trunc256Sum>::new(&txid_vecs).root()
+    };
+
+    let nakamoto_txs_bad_miner_sig =
+        vec![tenure_change_tx_bad_miner_sig.clone(), coinbase_tx.clone()];
+    let nakamoto_tx_merkle_root_bad_miner_sig = {
+        let txid_vecs = nakamoto_txs_bad_miner_sig
+            .iter()
+            .map(|tx| tx.txid().as_bytes().to_vec())
+            .collect();
+
+        MerkleTree::<Sha512Trunc256Sum>::new(&txid_vecs).root()
+    };
+
+    let mut nakamoto_header = NakamotoBlockHeader {
+        version: 1,
+        chain_length: 457,
+        burn_spent: 126,
+        consensus_hash: tenure_change_payload.consensus_hash.clone(),
+        parent_block_id: StacksBlockId([0x03; 32]),
+        tx_merkle_root: nakamoto_tx_merkle_root,
+        state_index_root: TrieHash([0x07; 32]),
+        miner_signature: MessageSignature::empty(),
+        stacker_signature: MessageSignature::empty(),
+    };
+    nakamoto_header.sign_miner(&private_key).unwrap();
+
+    let nakamoto_block = NakamotoBlock {
+        header: nakamoto_header.clone(),
+        txs: nakamoto_txs,
+    };
+
+    let mut nakamoto_header_bad_ch = NakamotoBlockHeader {
+        version: 1,
+        chain_length: 457,
+        burn_spent: 126,
+        consensus_hash: tenure_change_payload.consensus_hash.clone(),
+        parent_block_id: StacksBlockId([0x03; 32]),
+        tx_merkle_root: nakamoto_tx_merkle_root_bad_ch,
+        state_index_root: TrieHash([0x07; 32]),
+        miner_signature: MessageSignature::empty(),
+        stacker_signature: MessageSignature::empty(),
+    };
+    nakamoto_header_bad_ch.sign_miner(&private_key).unwrap();
+
+    let nakamoto_block_bad_ch = NakamotoBlock {
+        header: nakamoto_header_bad_ch.clone(),
+        txs: nakamoto_txs_bad_ch,
+    };
+
+    let mut nakamoto_header_bad_miner_sig = NakamotoBlockHeader {
+        version: 1,
+        chain_length: 457,
+        burn_spent: 126,
+        consensus_hash: tenure_change_payload.consensus_hash.clone(),
+        parent_block_id: StacksBlockId([0x03; 32]),
+        tx_merkle_root: nakamoto_tx_merkle_root_bad_miner_sig,
+        state_index_root: TrieHash([0x07; 32]),
+        miner_signature: MessageSignature::empty(),
+        stacker_signature: MessageSignature::empty(),
+    };
+    nakamoto_header_bad_miner_sig
+        .sign_miner(&private_key)
+        .unwrap();
+
+    let nakamoto_block_bad_miner_sig = NakamotoBlock {
+        header: nakamoto_header_bad_miner_sig.clone(),
+        txs: nakamoto_txs_bad_miner_sig,
+    };
+
+    assert_eq!(
+        nakamoto_block.header.recover_miner_pk().unwrap(),
+        StacksPublicKey::from_private(&private_key)
+    );
+    assert_eq!(
+        nakamoto_block.get_miner_pubkh().unwrap(),
+        tenure_change_payload.pubkey_hash
+    );
+
+    assert!(nakamoto_block
+        .check_miner_signature(&tenure_change_payload.pubkey_hash)
+        .is_ok());
+    assert!(nakamoto_block
+        .check_miner_signature(&Hash160::from_node_public_key(
+            &StacksPublicKey::from_private(&private_key_2)
+        ))
+        .is_err());
+
+    assert!(nakamoto_block.check_tenure_change_tx().is_ok());
+    assert!(nakamoto_block_bad_ch.check_tenure_change_tx().is_err());
+    assert!(nakamoto_block_bad_miner_sig
+        .check_tenure_change_tx()
+        .is_err());
+
+    let vrf_alt_privkey = VRFPrivateKey::new();
+    let vrf_alt_pubkey = VRFPublicKey::from_private(&vrf_alt_privkey);
+
+    assert!(nakamoto_block
+        .check_coinbase_tx(&vrf_pubkey, &sortition_hash)
+        .is_ok());
+    assert!(nakamoto_block
+        .check_coinbase_tx(&vrf_pubkey, &SortitionHash([0x02; 32]))
+        .is_err());
+    assert!(nakamoto_block
+        .check_coinbase_tx(&vrf_alt_pubkey, &sortition_hash)
+        .is_err());
+}

From 13b0f1bc160ec783e21fe116b7026ddb0af21c3b Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Fri, 1 Dec 2023 12:24:38 -0500
Subject: [PATCH 0078/1166] testing: require nodes to begin Nakamoto off of an
 epoch2 block, and correctly fill in the tenure-change fields

---
 .../src/chainstate/nakamoto/tests/node.rs     | 192 ++++++++++--------
 1 file changed, 103 insertions(+), 89 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/tests/node.rs b/stackslib/src/chainstate/nakamoto/tests/node.rs
index 2e5be9ef87..5dada18116 100644
--- a/stackslib/src/chainstate/nakamoto/tests/node.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/node.rs
@@ -287,89 +287,85 @@ impl TestStacksNode {
         burn_amount: u64,
         tenure_change_cause: TenureChangeCause,
     ) -> (LeaderBlockCommitOp, TenureChangePayload) {
-        let (
-            last_tenure_id,
-            previous_tenure_end,
-            previous_tenure_blocks,
-            parent_block_snapshot_opt,
-        ) = if let Some(parent_blocks) = parent_nakamoto_tenure {
-            // parent is an epoch 3 nakamoto block
-            let first_parent = parent_blocks.first().unwrap();
-            let last_parent = parent_blocks.last().unwrap();
-            let parent_tenure_id = StacksBlockId::new(
-                &first_parent.header.consensus_hash,
-                &first_parent.header.block_hash(),
-            );
-            let parent_sortition = SortitionDB::get_block_snapshot_consensus(
-                &sortdb.conn(),
-                &first_parent.header.consensus_hash,
-            )
-            .unwrap()
-            .unwrap();
+        let (last_tenure_id, previous_tenure_end, previous_tenure_blocks, parent_block_snapshot) =
+            if let Some(parent_blocks) = parent_nakamoto_tenure {
+                // parent is an epoch 3 nakamoto block
+                let first_parent = parent_blocks.first().unwrap();
+                let last_parent = parent_blocks.last().unwrap();
+                let parent_tenure_id = StacksBlockId::new(
+                    &first_parent.header.consensus_hash,
+                    &first_parent.header.block_hash(),
+                );
+                let parent_sortition = SortitionDB::get_block_snapshot_consensus(
+                    &sortdb.conn(),
+                    &first_parent.header.consensus_hash,
+                )
+                .unwrap()
+                .unwrap();
 
-            test_debug!(
-                "Work in {} {} for Nakamoto parent: {},{}",
-                burn_block.block_height,
-                burn_block.parent_snapshot.burn_header_hash,
-                parent_sortition.total_burn,
-                last_parent.header.chain_length + 1,
-            );
+                test_debug!(
+                    "Work in {} {} for Nakamoto parent: {},{}",
+                    burn_block.block_height,
+                    burn_block.parent_snapshot.burn_header_hash,
+                    parent_sortition.total_burn,
+                    last_parent.header.chain_length + 1,
+                );
 
-            (
-                parent_tenure_id,
-                last_parent.header.block_id(),
-                parent_blocks.len(),
-                Some(parent_sortition),
-            )
-        } else if let Some(parent_stacks_block) = parent_stacks_block {
-            // building off an existing stacks block
-            let parent_stacks_block_snapshot = {
-                let ic = sortdb.index_conn();
-                let parent_stacks_block_snapshot =
-                    SortitionDB::get_block_snapshot_for_winning_stacks_block(
-                        &ic,
-                        &burn_block.parent_snapshot.sortition_id,
-                        &parent_stacks_block.block_hash(),
-                    )
-                    .unwrap()
-                    .unwrap();
-                parent_stacks_block_snapshot
-            };
+                (
+                    parent_tenure_id,
+                    last_parent.header.block_id(),
+                    parent_blocks.len(),
+                    parent_sortition,
+                )
+            } else if let Some(parent_stacks_block) = parent_stacks_block {
+                // building off an existing stacks block
+                let parent_stacks_block_snapshot = {
+                    let ic = sortdb.index_conn();
+                    let parent_stacks_block_snapshot =
+                        SortitionDB::get_block_snapshot_for_winning_stacks_block(
+                            &ic,
+                            &burn_block.parent_snapshot.sortition_id,
+                            &parent_stacks_block.block_hash(),
+                        )
+                        .unwrap()
+                        .unwrap();
+                    parent_stacks_block_snapshot
+                };
 
-            let parent_chain_tip = StacksChainState::get_anchored_block_header_info(
-                self.chainstate.db(),
-                &parent_stacks_block_snapshot.consensus_hash,
-                &parent_stacks_block.header.block_hash(),
-            )
-            .unwrap()
-            .unwrap();
+                let parent_chain_tip = StacksChainState::get_anchored_block_header_info(
+                    self.chainstate.db(),
+                    &parent_stacks_block_snapshot.consensus_hash,
+                    &parent_stacks_block.header.block_hash(),
+                )
+                .unwrap()
+                .unwrap();
 
-            let parent_tenure_id = parent_chain_tip.index_block_hash();
+                let parent_tenure_id = parent_chain_tip.index_block_hash();
 
-            test_debug!(
-                "Work in {} {} for Stacks 2.x parent: {},{}",
-                burn_block.block_height,
-                burn_block.parent_snapshot.burn_header_hash,
-                parent_stacks_block_snapshot.total_burn,
-                parent_chain_tip.anchored_header.height(),
-            );
+                test_debug!(
+                    "Work in {} {} for Stacks 2.x parent: {},{}",
+                    burn_block.block_height,
+                    burn_block.parent_snapshot.burn_header_hash,
+                    parent_stacks_block_snapshot.total_burn,
+                    parent_chain_tip.anchored_header.height(),
+                );
 
-            (
-                parent_tenure_id.clone(),
-                parent_tenure_id,
-                1,
-                Some(parent_stacks_block_snapshot),
-            )
-        } else {
-            // first epoch is a nakamoto epoch (testing only)
-            let parent_tenure_id =
-                StacksBlockId::new(&FIRST_BURNCHAIN_CONSENSUS_HASH, &FIRST_STACKS_BLOCK_HASH);
-            (parent_tenure_id.clone(), parent_tenure_id, 0, None)
-        };
+                (
+                    parent_tenure_id.clone(),
+                    parent_tenure_id,
+                    1,
+                    parent_stacks_block_snapshot,
+                )
+            } else {
+                panic!("Neither Nakamoto nor epoch2 parent found");
+            };
 
         let previous_tenure_blocks =
             u32::try_from(previous_tenure_blocks).expect("FATAL: too many blocks from last miner");
+
         let tenure_change_payload = TenureChangePayload {
+            consensus_hash: ConsensusHash([0x00; 20]), // will be overwritten
+            prev_consensus_hash: parent_block_snapshot.consensus_hash.clone(),
             previous_tenure_end,
             previous_tenure_blocks,
             cause: tenure_change_cause,
@@ -385,7 +381,7 @@ impl TestStacksNode {
             &last_tenure_id,
             burn_amount,
             miner_key,
-            parent_block_snapshot_opt.as_ref(),
+            Some(&parent_block_snapshot),
         );
 
         (block_commit_op, tenure_change_payload)
@@ -543,6 +539,13 @@ impl<'a> TestPeer<'a> {
                 &parent_tenure_id,
             )
             .unwrap();
+            if parent_sortition_opt.is_none() {
+                warn!(
+                    "No parent sortition: tip.sortition_id = {}, parent_tenure_id = {}",
+                    &tip.sortition_id, &parent_tenure_id
+                );
+            }
+
             let last_tenure_id = StacksBlockId::new(
                 &first_parent.header.consensus_hash,
                 &first_parent.header.block_hash(),
@@ -555,19 +558,27 @@ impl<'a> TestPeer<'a> {
             )
         } else {
             // parent may be an epoch 2.x block
-            let (parent_opt, parent_sortition_opt) =
-                if let Some(parent_block) = stacks_node.get_last_anchored_block(miner) {
-                    let ic = sortdb.index_conn();
-                    let sort_opt = SortitionDB::get_block_snapshot_for_winning_stacks_block(
-                        &ic,
-                        &tip.sortition_id,
-                        &parent_block.block_hash(),
-                    )
-                    .unwrap();
-                    (Some(parent_block), sort_opt)
-                } else {
-                    (None, None)
-                };
+            let (parent_opt, parent_sortition_opt) = if let Some(parent_block) =
+                stacks_node.get_last_anchored_block(miner)
+            {
+                let ic = sortdb.index_conn();
+                let sort_opt = SortitionDB::get_block_snapshot_for_winning_stacks_block(
+                    &ic,
+                    &tip.sortition_id,
+                    &parent_block.block_hash(),
+                )
+                .unwrap();
+                if sort_opt.is_none() {
+                    warn!("No parent sortition in epoch2: tip.sortition_id = {}, parent_block.block_hash() = {}", &tip.sortition_id, &parent_block.block_hash());
+                }
+                (Some(parent_block), sort_opt)
+            } else {
+                warn!(
+                    "No parent sortition in epoch2: tip.sortition_id = {}",
+                    &tip.sortition_id
+                );
+                (None, None)
+            };
 
             let last_tenure_id = if let Some(last_epoch2_block) = parent_opt.as_ref() {
                 let parent_sort = parent_sortition_opt.as_ref().unwrap();
@@ -751,7 +762,7 @@ impl<'a> TestPeer<'a> {
     pub fn make_nakamoto_tenure<F>(
         &mut self,
         consensus_hash: &ConsensusHash,
-        tenure_change_payload: TenureChangePayload,
+        mut tenure_change_payload: TenureChangePayload,
         vrf_proof: VRFProof,
         block_builder: F,
     ) -> Vec<(NakamotoBlock, u64, ExecutionCost)>
@@ -766,8 +777,11 @@ impl<'a> TestPeer<'a> {
         let mut stacks_node = self.stacks_node.take().unwrap();
         let sortdb = self.sortdb.take().unwrap();
 
-        let (last_tenure_id, parent_block_opt, _parent_tenure_opt, parent_sortition_opt) =
+        let (last_tenure_id, parent_block_opt, parent_tenure_opt, parent_sortition_opt) =
             Self::get_nakamoto_parent(&self.miner, &stacks_node, &sortdb);
+
+        tenure_change_payload.consensus_hash = consensus_hash.clone();
+
         let blocks = TestStacksNode::make_nakamoto_tenure_blocks(
             &mut stacks_node.chainstate,
             &sortdb,

From bf865d4bdcc37ffbdf9511d50a6d46f33639f61f Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Fri, 1 Dec 2023 12:25:15 -0500
Subject: [PATCH 0079/1166] chore: sync with tenure-change struct

---
 stackslib/src/chainstate/stacks/block.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/stackslib/src/chainstate/stacks/block.rs b/stackslib/src/chainstate/stacks/block.rs
index 60af9a874e..f32e2b3c19 100644
--- a/stackslib/src/chainstate/stacks/block.rs
+++ b/stackslib/src/chainstate/stacks/block.rs
@@ -1782,6 +1782,8 @@ mod test {
         );
 
         let tenure_change_payload = TenureChangePayload {
+            consensus_hash: ConsensusHash([0x01; 20]),
+            prev_consensus_hash: ConsensusHash([0x02; 20]),
             previous_tenure_end: StacksBlockId([0x00; 32]),
             previous_tenure_blocks: 0,
             cause: TenureChangeCause::BlockFound,

From b753a7cdcf8ee02a9f0321d8dfc610c499c5cdeb Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Fri, 1 Dec 2023 12:25:31 -0500
Subject: [PATCH 0080/1166] feat: add support for tenure budget extension

---
 .../src/chainstate/stacks/db/transactions.rs     | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/db/transactions.rs b/stackslib/src/chainstate/stacks/db/transactions.rs
index a36880b4af..20e43ef875 100644
--- a/stackslib/src/chainstate/stacks/db/transactions.rs
+++ b/stackslib/src/chainstate/stacks/db/transactions.rs
@@ -1345,7 +1345,7 @@ impl StacksChainState {
                 let receipt = StacksTransactionReceipt::from_coinbase(tx.clone());
                 Ok(receipt)
             }
-            TransactionPayload::TenureChange(ref _payload) => {
+            TransactionPayload::TenureChange(ref payload) => {
                 // post-conditions are not allowed for this variant, since they're non-sensical.
                 // Their presence in this variant makes the transaction invalid.
                 if tx.post_conditions.len() > 0 {
@@ -1355,7 +1355,19 @@ impl StacksChainState {
                     return Err(Error::InvalidStacksTransaction(msg, false));
                 }
 
-                // TODO: More checks before adding to block?
+                // what kind of tenure-change?
+                match payload.cause {
+                    TenureChangeCause::BlockFound => {
+                        // a sortition triggered this tenure change.
+                        // this is already processed, so it's a no-op here.
+                    }
+                    TenureChangeCause::Extended => {
+                        // the stackers granted a tenure extension.
+                        // reset the runtime cost
+                        debug!("TenureChange extends block tenure");
+                        clarity_tx.reset_cost(ExecutionCost::zero());
+                    }
+                }
 
                 let receipt = StacksTransactionReceipt::from_tenure_change(tx.clone());
                 Ok(receipt)

From 60fee442f92189d3f5302dad60626000509a2326 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Fri, 1 Dec 2023 12:25:48 -0500
Subject: [PATCH 0081/1166] feat: tenure-changes identify current and previous
 tenures by consensus hash

---
 stackslib/src/chainstate/stacks/mod.rs | 44 ++++++++++++++------------
 1 file changed, 24 insertions(+), 20 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/mod.rs b/stackslib/src/chainstate/stacks/mod.rs
index fcef542582..898072a904 100644
--- a/stackslib/src/chainstate/stacks/mod.rs
+++ b/stackslib/src/chainstate/stacks/mod.rs
@@ -627,10 +627,8 @@ impl_byte_array_serde!(TokenTransferMemo);
 pub enum TenureChangeCause {
     /// A valid winning block-commit, end current tenure
     BlockFound = 0,
-    /// No winning block-commits, extend current tenure
-    NoBlockFound = 1,
-    /// A null miner won the block-commit
-    NullMiner = 2,
+    /// The next burnchain block is taking too long, so extend the runtime budget
+    Extended = 1,
 }
 
 impl TryFrom<u8> for TenureChangeCause {
@@ -639,13 +637,22 @@ impl TryFrom<u8> for TenureChangeCause {
     fn try_from(num: u8) -> Result<Self, Self::Error> {
         match num {
             0 => Ok(Self::BlockFound),
-            1 => Ok(Self::NoBlockFound),
-            2 => Ok(Self::NullMiner),
+            1 => Ok(Self::Extended),
             _ => Err(()),
         }
     }
 }
 
+impl TenureChangeCause {
+    /// Does this tenure change cause require a sortition to be valid?
+    pub fn expects_sortition(&self) -> bool {
+        match self {
+            Self::BlockFound => true,
+            Self::Extended => false,
+        }
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct SchnorrThresholdSignature {
     //pub point: wsts::Point,
@@ -658,25 +665,22 @@ impl SchnorrThresholdSignature {
     }
 }
 
-/// Reasons why a `TenureChange` transaction can be bad
-pub enum TenureChangeError {
-    SignatureInvalid,
-    /// Not signed by required threshold (>70%)
-    SignatureThresholdNotReached,
-    /// `previous_tenure_end` does not match parent block
-    PreviousTenureInvalid,
-    /// Block is not a Nakamoto block
-    NotNakamoto,
-}
-
-/// A transaction from Stackers to signal new mining tenure
+/// A payload from Stackers to signal new mining tenure
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct TenureChangePayload {
+    /// Consensus hash of this tenure.  Corresponds to the sortition in which the miner of this
+    /// block was chosen.  It may be the case that this miner's tenure gets _extended_ across
+    /// subsequent sortitions; if this happens, then this `consensus_hash` value _remains the same_
+    /// as the sortition in which the winning block-commit was mined.
+    pub consensus_hash: ConsensusHash,
+    /// Consensus hash of the previous tenure.  Corresponds to the sortition of the previous
+    /// winning block-commit.
+    pub prev_consensus_hash: ConsensusHash,
     /// The StacksBlockId of the last block from the previous tenure
     pub previous_tenure_end: StacksBlockId,
-    /// The number of blocks produced in the previous tenure
+    /// The number of blocks produced since the last sortition-linked tenure
     pub previous_tenure_blocks: u32,
-    /// A flag to indicate which of the following triggered the tenure change
+    /// A flag to indicate the cause of this tenure change
     pub cause: TenureChangeCause,
     /// The ECDSA public key hash of the current tenure
     pub pubkey_hash: Hash160,

From 3a700cbaf9928cc870e308391cfc858eff9b9529 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Fri, 1 Dec 2023 12:26:06 -0500
Subject: [PATCH 0082/1166] testing: find the last anchored block in the mock
 miner even if it's not yet linked to a block-commit it has (e.g. if the
 commit was the first nakamoto commit)

---
 stackslib/src/chainstate/stacks/tests/mod.rs | 27 +++++++++++++++-----
 1 file changed, 21 insertions(+), 6 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/tests/mod.rs b/stackslib/src/chainstate/stacks/tests/mod.rs
index 678ee17f28..75246acd8c 100644
--- a/stackslib/src/chainstate/stacks/tests/mod.rs
+++ b/stackslib/src/chainstate/stacks/tests/mod.rs
@@ -430,15 +430,30 @@ impl TestStacksNode {
     }
 
     pub fn get_last_anchored_block(&self, miner: &TestMiner) -> Option<StacksBlock> {
-        match miner.last_block_commit() {
-            None => None,
-            Some(block_commit_op) => {
-                match self.commit_ops.get(&block_commit_op.block_header_hash) {
-                    None => None,
-                    Some(idx) => Some(self.anchored_blocks[*idx].clone()),
+        let mut num_commits = miner.num_block_commits();
+        if num_commits == 0 {
+            return None;
+        }
+
+        while num_commits > 0 {
+            num_commits -= 1;
+            match miner.block_commit_at(num_commits) {
+                None => {
+                    continue;
+                }
+                Some(block_commit_op) => {
+                    match self.commit_ops.get(&block_commit_op.block_header_hash) {
+                        None => {
+                            continue;
+                        }
+                        Some(idx) => {
+                            return Some(self.anchored_blocks[*idx].clone());
+                        }
+                    }
                 }
             }
         }
+        None
     }
 
     pub fn get_last_accepted_anchored_block(

From a0386c22ec2692773d230d94bbdd7096d4e99e1f Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Fri, 1 Dec 2023 12:26:42 -0500
Subject: [PATCH 0083/1166] chore: try_as_tenure_change()

---
 stackslib/src/chainstate/stacks/transaction.rs | 18 ++++++++++++------
 1 file changed, 12 insertions(+), 6 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/transaction.rs b/stackslib/src/chainstate/stacks/transaction.rs
index 629ccad10f..105ba0f682 100644
--- a/stackslib/src/chainstate/stacks/transaction.rs
+++ b/stackslib/src/chainstate/stacks/transaction.rs
@@ -159,14 +159,10 @@ impl StacksMessageCodec for SchnorrThresholdSignature {
     }
 }
 
-impl TenureChangePayload {
-    pub fn validate(&self) -> Result<(), TenureChangeError> {
-        Ok(())
-    }
-}
-
 impl StacksMessageCodec for TenureChangePayload {
     fn consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), codec_error> {
+        write_next(fd, &self.consensus_hash)?;
+        write_next(fd, &self.prev_consensus_hash)?;
         write_next(fd, &self.previous_tenure_end)?;
         write_next(fd, &self.previous_tenure_blocks)?;
         write_next(fd, &self.cause)?;
@@ -177,6 +173,8 @@ impl StacksMessageCodec for TenureChangePayload {
 
     fn consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, codec_error> {
         Ok(Self {
+            consensus_hash: read_next(fd)?,
+            prev_consensus_hash: read_next(fd)?,
             previous_tenure_end: read_next(fd)?,
             previous_tenure_blocks: read_next(fd)?,
             cause: read_next(fd)?,
@@ -688,6 +686,14 @@ impl StacksTransaction {
             _ => None,
         }
     }
+
+    /// Try to convert to a tenure change payload
+    pub fn try_as_tenure_change(&self) -> Option<&TenureChangePayload> {
+        match &self.payload {
+            TransactionPayload::TenureChange(ref tc_payload) => Some(tc_payload),
+            _ => None,
+        }
+    }
 }
 
 impl StacksMessageCodec for StacksTransaction {

From 461b2824d5b6d7a7bf13868d53d0b91e9731470d Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Fri, 1 Dec 2023 12:26:54 -0500
Subject: [PATCH 0084/1166] chore: add reset_cost() function for tenure-change
 budget extension

---
 stackslib/src/clarity_vm/clarity.rs | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/stackslib/src/clarity_vm/clarity.rs b/stackslib/src/clarity_vm/clarity.rs
index aed3bb9947..b385859320 100644
--- a/stackslib/src/clarity_vm/clarity.rs
+++ b/stackslib/src/clarity_vm/clarity.rs
@@ -1651,6 +1651,14 @@ impl<'a, 'b> ClarityTransactionConnection<'a, 'b> {
         }
     }
 
+    /// Reset the cost tracker to the given cost
+    pub fn reset_cost(&mut self, new_cost: ExecutionCost) {
+        match self.cost_track {
+            Some(ref mut track) => track.set_total(new_cost),
+            None => { /* no-op */ }
+        }
+    }
+
     /// Evaluate a poison-microblock transaction
     pub fn run_poison_microblock(
         &mut self,

From ad1f1788bf7794f5413052017902cd695f2992fd Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Fri, 1 Dec 2023 12:27:08 -0500
Subject: [PATCH 0085/1166] chore: log block rejection

---
 stackslib/src/net/relay.rs | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/stackslib/src/net/relay.rs b/stackslib/src/net/relay.rs
index 8e2cf2200d..8989555b93 100644
--- a/stackslib/src/net/relay.rs
+++ b/stackslib/src/net/relay.rs
@@ -710,6 +710,11 @@ impl Relayer {
             &block.header.consensus_hash,
             &block.header.block_hash()
         );
+        let reject_msg = format!(
+            "Rejected incoming Nakamoto block {}/{}",
+            &block.header.consensus_hash,
+            &block.header.block_hash()
+        );
 
         let config = chainstate.config();
         let staging_db_tx = chainstate.db_tx_begin()?;
@@ -719,7 +724,10 @@ impl Relayer {
 
         if accepted {
             debug!("{}", &accept_msg);
+        } else {
+            debug!("{}", &reject_msg);
         }
+
         Ok(accepted)
     }
 

From a276e500be9bdd37a95c4427d7841266fecd742d Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Fri, 1 Dec 2023 12:27:21 -0500
Subject: [PATCH 0086/1166] chore: tenure-change requires prev_consensus_hash

---
 testnet/stacks-node/src/mockamoto.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index 8d6582f9cd..7af1ed15a8 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -361,6 +361,8 @@ impl MockamotoNode {
         // If mockamoto mode changes to support non-tenure-changing blocks, this will have
         //  to be gated.
         let tenure_change_tx_payload = TransactionPayload::TenureChange(TenureChangePayload {
+            consensus_hash: sortition_tip.consensus_hash,
+            prev_consensus_hash: chain_tip_ch.clone(),
             previous_tenure_end: parent_block_id,
             previous_tenure_blocks: 1,
             cause: TenureChangeCause::BlockFound,
@@ -404,7 +406,6 @@ impl MockamotoNode {
             sortition_tip.block_height.try_into().map_err(|_| {
                 ChainstateError::InvalidStacksBlock("Burn block height exceeded u32".into())
             })?,
-            false,
             true,
             parent_chain_length + 1,
         )?;

From b3de84a78f507d92b274ddccf8c1c91f45645281 Mon Sep 17 00:00:00 2001
From: wileyj <2847772+wileyj@users.noreply.github.com>
Date: Sun, 19 Nov 2023 22:31:01 -0800
Subject: [PATCH 0087/1166] (3847) - Adding/updating Dockerfiles for ARM arch

---
 .../dockerfiles/Dockerfile.alpine-binary      |  3 ++-
 .../dockerfiles/Dockerfile.debian-binary      |  3 ++-
 build-scripts/Dockerfile.linux-glibc-arm64    |  1 +
 build-scripts/Dockerfile.linux-glibc-armv7    | 26 +++++++++++++++++++
 build-scripts/Dockerfile.linux-glibc-x64      |  1 +
 build-scripts/Dockerfile.linux-musl-armv7     | 21 +++++++++++++++
 build-scripts/build-dist.sh                   |  4 +++
 7 files changed, 57 insertions(+), 2 deletions(-)
 create mode 100644 build-scripts/Dockerfile.linux-glibc-armv7
 create mode 100644 build-scripts/Dockerfile.linux-musl-armv7

diff --git a/.github/actions/dockerfiles/Dockerfile.alpine-binary b/.github/actions/dockerfiles/Dockerfile.alpine-binary
index 8c450a67f3..2388ffa031 100644
--- a/.github/actions/dockerfiles/Dockerfile.alpine-binary
+++ b/.github/actions/dockerfiles/Dockerfile.alpine-binary
@@ -7,11 +7,12 @@ ARG TARGETPLATFORM
 ARG BUILDPLATFORM
 ARG TARGETARCH
 ARG TARGETVARIANT
-ARG REPO=stacks-network/stacks-blockchain
+ARG REPO=stacks-network/stacks-core
 
 RUN case ${TARGETARCH} in \
     "amd64")  BIN_ARCH=linux-musl-x64  ;; \
     "arm64")  BIN_ARCH=linux-musl-arm64  ;; \
+    "arm")  BIN_ARCH=linux-musl-armv7  ;; \
     "*") exit 1 ;; \
     esac \
     && echo "wget  -q https://github.com/${REPO}/releases/download/${TAG}/${BIN_ARCH}.zip -O /${BIN_ARCH}.zip" \
diff --git a/.github/actions/dockerfiles/Dockerfile.debian-binary b/.github/actions/dockerfiles/Dockerfile.debian-binary
index cf1380361b..1cc5341d2c 100644
--- a/.github/actions/dockerfiles/Dockerfile.debian-binary
+++ b/.github/actions/dockerfiles/Dockerfile.debian-binary
@@ -7,11 +7,12 @@ ARG TARGETPLATFORM
 ARG BUILDPLATFORM
 ARG TARGETARCH
 ARG TARGETVARIANT
-ARG REPO=stacks-network/stacks-blockchain
+ARG REPO=stacks-network/stacks-core
 
 RUN case ${TARGETARCH} in \
     "amd64")  BIN_ARCH=linux-musl-x64  ;; \
     "arm64")  BIN_ARCH=linux-musl-arm64  ;; \
+    "arm")  BIN_ARCH=linux-musl-armv7  ;; \
     "*") exit 1 ;; \
     esac \
     && echo "wget  -q https://github.com/${REPO}/releases/download/${TAG}/${BIN_ARCH}.zip -O /${BIN_ARCH}.zip" \
diff --git a/build-scripts/Dockerfile.linux-glibc-arm64 b/build-scripts/Dockerfile.linux-glibc-arm64
index 7ce50b6a68..61ff5f4a04 100644
--- a/build-scripts/Dockerfile.linux-glibc-arm64
+++ b/build-scripts/Dockerfile.linux-glibc-arm64
@@ -24,3 +24,4 @@ RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
 
 FROM scratch AS export-stage
 COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
+## comment
diff --git a/build-scripts/Dockerfile.linux-glibc-armv7 b/build-scripts/Dockerfile.linux-glibc-armv7
new file mode 100644
index 0000000000..eb893baeb6
--- /dev/null
+++ b/build-scripts/Dockerfile.linux-glibc-armv7
@@ -0,0 +1,26 @@
+FROM rust:bullseye as build
+
+ARG STACKS_NODE_VERSION="No Version Info"
+ARG GIT_BRANCH='No Branch Info'
+ARG GIT_COMMIT='No Commit Info'
+ARG BUILD_DIR=/build
+ARG TARGET=armv7-unknown-linux-gnueabihf
+WORKDIR /src
+
+COPY . .
+
+RUN apt-get update && apt-get install -y git gcc-arm-linux-gnueabihf
+
+# Run all the build steps in ramdisk in an attempt to speed things up
+RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
+    && cd ${BUILD_DIR} \
+    && rustup target add ${TARGET} \
+    && CC=arm-linux-gnueabihf-gcc \
+    CC_armv7_unknown_linux_gnueabihf=arm-linux-gnueabihf-gcc \
+    CARGO_TARGET_ARMV7_UNKNOWN_LINUX_GNUEABIHF_LINKER=arm-linux-gnueabihf-gcc \
+    cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} \
+    && mkdir -p /out \
+    && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
+
+FROM scratch AS export-stage
+COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
\ No newline at end of file
diff --git a/build-scripts/Dockerfile.linux-glibc-x64 b/build-scripts/Dockerfile.linux-glibc-x64
index 2db13cb51e..9c68c58af4 100644
--- a/build-scripts/Dockerfile.linux-glibc-x64
+++ b/build-scripts/Dockerfile.linux-glibc-x64
@@ -21,3 +21,4 @@ RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
 
 FROM scratch AS export-stage
 COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
+## comment
diff --git a/build-scripts/Dockerfile.linux-musl-armv7 b/build-scripts/Dockerfile.linux-musl-armv7
new file mode 100644
index 0000000000..57b93b47ec
--- /dev/null
+++ b/build-scripts/Dockerfile.linux-musl-armv7
@@ -0,0 +1,21 @@
+FROM messense/rust-musl-cross:armv7-musleabihf as build
+
+ARG STACKS_NODE_VERSION="No Version Info"
+ARG GIT_BRANCH='No Branch Info'
+ARG GIT_COMMIT='No Commit Info'
+ARG BUILD_DIR=/build
+ARG TARGET=armv7-unknown-linux-musleabihf
+WORKDIR /src
+
+COPY . .
+
+# Run all the build steps in ramdisk in an attempt to speed things up
+RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
+    && cd ${BUILD_DIR} \
+    && rustup target add ${TARGET} \
+    && cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} \
+    && mkdir -p /out \
+    && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
+
+FROM scratch AS export-stage
+COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
\ No newline at end of file
diff --git a/build-scripts/build-dist.sh b/build-scripts/build-dist.sh
index ac2c8bcd5c..8be8f4f8a7 100755
--- a/build-scripts/build-dist.sh
+++ b/build-scripts/build-dist.sh
@@ -17,8 +17,10 @@ case $DIST_TARGET_FILTER in
     case $DIST_TARGET_FILTER in
       linux-glibc-x64)      build_platform linux-glibc-x64 ;;
       linux-glibc-arm64)    build_platform linux-glibc-arm64 ;;
+      linux-glibc-armv7)    build_platform linux-glibc-armv7 ;;
       linux-musl-x64)       build_platform linux-musl-x64 ;;
       linux-musl-arm64)     build_platform linux-musl-arm64 ;;
+      linux-musl-armv7)     build_platform linux-musl-armv7 ;;
       windows-x64)          build_platform windows-x64 ;;
       macos-x64)            build_platform macos-x64 ;;
       macos-arm64)          build_platform macos-arm64 ;;
@@ -32,8 +34,10 @@ case $DIST_TARGET_FILTER in
     echo "Building distrubtions for all targets."
     build_platform linux-glibc-x64
     build_platform linux-glibc-arm64
+    build_platform linux-glibc-armv7
     build_platform linux-musl-x64
     build_platform linux-musl-arm64
+    build_platform linux-musl-armv7
     build_platform windows-x64
     build_platform macos-x64
     build_platform macos-arm64

From 99b54fd2d79c4a2469d44b7ad1fcdd5669d26597 Mon Sep 17 00:00:00 2001
From: wileyj <2847772+wileyj@users.noreply.github.com>
Date: Sun, 19 Nov 2023 22:34:22 -0800
Subject: [PATCH 0088/1166] (3847) - Removing files

---
 .github/workflows/audit.yml                   | 35 -------
 .github/workflows/build-source-binary.yml     | 65 -------------
 .github/workflows/clippy.yml                  | 44 ---------
 .../workflows/image-build-alpine-binary.yml   | 85 ----------------
 .../workflows/image-build-debian-binary.yml   | 96 -------------------
 .../workflows/image-build-debian-source.yml   | 94 ------------------
 6 files changed, 419 deletions(-)
 delete mode 100644 .github/workflows/audit.yml
 delete mode 100644 .github/workflows/build-source-binary.yml
 delete mode 100644 .github/workflows/clippy.yml
 delete mode 100644 .github/workflows/image-build-alpine-binary.yml
 delete mode 100644 .github/workflows/image-build-debian-binary.yml
 delete mode 100644 .github/workflows/image-build-debian-source.yml

diff --git a/.github/workflows/audit.yml b/.github/workflows/audit.yml
deleted file mode 100644
index c3864d5659..0000000000
--- a/.github/workflows/audit.yml
+++ /dev/null
@@ -1,35 +0,0 @@
-##
-## Performs an audit for crate advisories against cargo dependencies
-##
-
-name: Security Audit
-
-# Only run when:
-#   - workflow is manually triggered
-#   - Cargo.toml/lock is changed
-#   - Daily at 0330 UTC
-# Note: this will create issues for any crate advisories unless they already exist
-
-on:
-  workflow_dispatch:
-  push:
-    paths:
-      - "**/Cargo.toml"
-      - "**/Cargo.lock"
-  schedule:
-    - cron: 30 03 * * *
-
-jobs:
-  security_audit:
-    if: ${{ false }}
-    name: Crate Vulnerability Check
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout the latest code
-        id: git_checkout
-        uses: actions/checkout@v3
-      - name: Rust Dependency Check
-        id: rust_dep_check
-        uses: actions-rs/audit-check@v1
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
diff --git a/.github/workflows/build-source-binary.yml b/.github/workflows/build-source-binary.yml
deleted file mode 100644
index 284171d672..0000000000
--- a/.github/workflows/build-source-binary.yml
+++ /dev/null
@@ -1,65 +0,0 @@
-##
-## Builds binary assets of stacks-blockchain and creates a named tag github (draft) release
-##
-
-name: Build Distributable Assets
-
-# Only run when:
-#   - manually triggered via the ci.yml workflow with a provided input tag
-
-on:
-  workflow_call:
-    inputs:
-      tag:
-        description: "Tag name of this release (x.y.z)"
-        required: true
-        type: string
-      parallel_jobs:
-        description: "Number of parallel binary builds"
-        required: false
-        type: number
-        default: 4
-      arch:
-        description: "Stringified JSON object listing of platform matrix"
-        required: true
-        type: string
-
-jobs:
-  artifact:
-    if: ${{ inputs.tag != '' }}
-    name: Create Artifacts
-    runs-on: ubuntu-latest
-    strategy:
-      max-parallel: ${{ inputs.parallel_jobs }}
-      matrix:
-        platform: ${{ fromJson(inputs.arch) }}
-    steps:
-      - name: Checkout the latest code
-        id: git_checkout
-        uses: actions/checkout@v3
-      - name: Set Vars
-        id: set_vars
-        run: |
-          echo "GITHUB_SHA_SHORT=${GITHUB_SHA::7}" >> $GITHUB_ENV
-          echo "GITHUB_REF_SHORT=${GITHUB_REF#refs/*/}" >> $GITHUB_ENV
-      - name: Set up Docker Buildx
-        id: setup_buildx
-        uses: docker/setup-buildx-action@v2
-      - name: Build Binaries
-        id: build_binaries
-        uses: docker/build-push-action@v3
-        with:
-          file: build-scripts/Dockerfile.${{ matrix.platform }}
-          outputs: type=local,dest=./release/${{ matrix.platform }}
-          build-args: |
-            OS_ARCH=${{ matrix.platform }}
-            GIT_BRANCH=${{ env.GITHUB_REF_SHORT }}
-            GIT_COMMIT=${{ env.GITHUB_SHA_SHORT }}
-      - name: Compress artifact
-        id: compress_artifact
-        run: zip --junk-paths ${{ matrix.platform }} ./release/${{ matrix.platform }}/*
-      - name: Upload artifact
-        id: upload_artifact
-        uses: actions/upload-artifact@v3
-        with:
-          path: ${{ matrix.platform }}.zip
diff --git a/.github/workflows/clippy.yml b/.github/workflows/clippy.yml
deleted file mode 100644
index 1e6872bd69..0000000000
--- a/.github/workflows/clippy.yml
+++ /dev/null
@@ -1,44 +0,0 @@
-# Disabled - this workflow needs more work so it's not incredibly chatty
-##
-## Perform Clippy checks - currently set to defaults
-##   https://github.com/rust-lang/rust-clippy#usage
-##   https://rust-lang.github.io/rust-clippy/master/index.html
-##
-
-name: Clippy Checks
-
-# Only run when:
-#   - PRs are (re)opened against develop branch
-
-on:
-  pull_request:
-    branches:
-      - develop
-    types:
-      - opened
-      - reopened
-
-jobs:
-  clippy_check:
-    if: ${{ false }}
-    name: Clippy Check
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout the latest code
-        id: git_checkout
-        uses: actions/checkout@v3
-      - name: Define Rust Toolchain
-        id: define_rust_toolchain
-        run: echo "RUST_TOOLCHAIN=$(cat ./rust-toolchain)" >> $GITHUB_ENV
-      - name: Setup Rust Toolchain
-        id: setup_rust_toolchain
-        uses: actions-rust-lang/setup-rust-toolchain@v1
-        with:
-          toolchain: ${{ env.RUST_TOOLCHAIN }}
-          components: clippy
-      - name: Clippy
-        id: clippy
-        uses: actions-rs/clippy-check@v1
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          args: --all-features
diff --git a/.github/workflows/image-build-alpine-binary.yml b/.github/workflows/image-build-alpine-binary.yml
deleted file mode 100644
index 5422baffd8..0000000000
--- a/.github/workflows/image-build-alpine-binary.yml
+++ /dev/null
@@ -1,85 +0,0 @@
-##
-## Build the Docker Alpine image from the pre-built downloaded binary asset
-##
-
-name: Build Alpine Binary Image
-
-# Only run when:
-#   - manually triggered via the ci.yml workflow
-
-on:
-  workflow_call:
-    inputs:
-      tag:
-        required: true
-        type: string
-        description: "semver tag for alpine images"
-      docker_platforms:
-        required: true
-        description: "Arch to buid alpine images"
-        type: string
-    secrets:
-      DOCKERHUB_USERNAME:
-        required: true
-      DOCKERHUB_PASSWORD:
-        required: true
-
-jobs:
-  image:
-    # Only run if a tag is provided manually
-    if: ${{ inputs.tag != '' }}
-    name: Build Image
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout the latest code
-        id: git_checkout
-        uses: actions/checkout@v3
-      - name: Set Vars
-        id: set_vars
-        run: |
-          echo "GITHUB_SHA_SHORT=${GITHUB_SHA::7}" >> $GITHUB_ENV
-          echo "GITHUB_REF_SHORT=${GITHUB_REF#refs/*/}" >> $GITHUB_ENV
-          echo "DOCKER_PUSH=${{ (secrets.DOCKERHUB_USERNAME != '') && (secrets.DOCKERHUB_PASSWORD != '') }}" >> $GITHUB_ENV
-      - name: Set up QEMU
-        id: docker_qemu
-        uses: docker/setup-qemu-action@v2
-      - name: Set up Docker Buildx
-        id: docker_buildx
-        uses: docker/setup-buildx-action@v2
-      # tag image with:
-      #   latest: `latest`
-      #   input tag: `<input tag>`
-      #   git tag: `1234`
-      - name: Docker Metadata
-        id: docker_metadata
-        uses: docker/metadata-action@v4
-        with:
-          images: |
-            blockstack/stacks-blockchain
-            blockstack/${{ github.event.repository.name }}
-          tags: |
-            type=raw,value=latest,enable=${{ inputs.tag != '' && (github.ref == format('refs/heads/{0}', github.event.repository.default_branch) )}}
-            type=raw,value=${{ inputs.tag }},enable=${{ inputs.tag != '' }}
-            type=ref,event=tag,enable=true
-      - name: Login to DockerHub
-        id: docker_login
-        uses: docker/login-action@v2
-        # Only attempt login and push if we have credentials
-        if: env.DOCKER_PUSH == 'true'
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_PASSWORD }}
-      - name: Build and Push
-        id: docker_build
-        uses: docker/build-push-action@v3
-        with:
-          file: ./.github/actions/dockerfiles/Dockerfile.alpine-binary
-          platforms: ${{ inputs.docker_platforms }}
-          tags: ${{ steps.docker_metadata.outputs.tags }}
-          labels: ${{ steps.docker_metadata.outputs.labels }}
-          build-args: |
-            TAG=${{ inputs.tag}}
-            STACKS_NODE_VERSION=${{ inputs.tag || env.GITHUB_SHA_SHORT }}
-            GIT_BRANCH=${{ env.GITHUB_REF_SHORT }}
-            GIT_COMMIT=${{ env.GITHUB_SHA_SHORT }}
-          push: ${{ env.DOCKER_PUSH }}
diff --git a/.github/workflows/image-build-debian-binary.yml b/.github/workflows/image-build-debian-binary.yml
deleted file mode 100644
index c7c30ff266..0000000000
--- a/.github/workflows/image-build-debian-binary.yml
+++ /dev/null
@@ -1,96 +0,0 @@
-##
-## Build the Docker Debian image from the pre-built downloaded binary asset
-##
-
-name: Build Linux Binary Image
-
-# Only run when:
-#   - manually triggered via the ci.yml workflow
-
-on:
-  workflow_call:
-    inputs:
-      tag:
-        required: true
-        type: string
-        description: "semver tag for linux images"
-      docker_platforms:
-        required: true
-        description: "Arch to buid linux images"
-        type: string
-      linux_version:
-        required: true
-        description: "Linux image to build"
-        type: string
-        default: debian
-      build_type:
-        required: true
-        description: Build type (source/binary)
-        type: string
-        default: binary
-    secrets:
-      DOCKERHUB_USERNAME:
-        required: true
-      DOCKERHUB_PASSWORD:
-        required: true
-
-jobs:
-  image:
-    # Only run if a tag is provided manually
-    if: ${{ inputs.tag != '' }}
-    name: Build Image
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout the latest code
-        id: git_checkout
-        uses: actions/checkout@v3
-      - name: Set Vars
-        id: set_vars
-        run: |
-          echo "GITHUB_SHA_SHORT=${GITHUB_SHA::7}" >> $GITHUB_ENV
-          echo "GITHUB_REF_SHORT=${GITHUB_REF#refs/*/}" >> $GITHUB_ENV
-          echo "DOCKER_PUSH=${{ (secrets.DOCKERHUB_USERNAME != '') && (secrets.DOCKERHUB_PASSWORD != '') }}" >> $GITHUB_ENV
-      - name: Set up QEMU
-        id: docker_qemu
-        uses: docker/setup-qemu-action@v2
-      - name: Set up Docker Buildx
-        id: docker_buildx
-        uses: docker/setup-buildx-action@v2
-      - name: Extract branch name
-        id: extract_branch
-        run: echo "BRANCH_NAME=$(echo ${GITHUB_REF#refs/heads/})" >> $GITHUB_ENV
-      # tag image with:
-      #   branch name: `latest-<linux version>`
-      #   input tag: `<input tag>-<linux version>`
-      - name: Docker Metadata
-        id: docker_metadata
-        uses: docker/metadata-action@v4
-        with:
-          images: |
-            blockstack/stacks-blockchain
-            blockstack/${{ github.event.repository.name }}
-          tags: |
-            type=raw,value=latest-${{ inputs.linux_version }},enable=${{ inputs.tag != '' && (github.ref == format('refs/heads/{0}', github.event.repository.default_branch) )}}
-            type=raw,value=${{ inputs.tag }}-${{ inputs.linux_version }},enable=${{ inputs.tag != '' }}
-      - name: Login to DockerHub
-        id: docker_login
-        uses: docker/login-action@v2
-        # Only attempt login and push if we have credentials
-        if: env.DOCKER_PUSH == 'true'
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_PASSWORD }}
-      - name: Build and Push
-        id: docker_build
-        uses: docker/build-push-action@v3
-        with:
-          file: ./.github/actions/dockerfiles/Dockerfile.${{ inputs.linux_version }}-${{ inputs.build_type }}
-          platforms: ${{ inputs.docker_platforms }}
-          tags: ${{ steps.docker_metadata.outputs.tags }}
-          labels: ${{ steps.docker_metadata.outputs.labels }}
-          build-args: |
-            TAG=${{ inputs.tag}}
-            STACKS_NODE_VERSION=${{ inputs.tag || env.GITHUB_SHA_SHORT }}
-            GIT_BRANCH=${{ env.GITHUB_REF_SHORT }}
-            GIT_COMMIT=${{ env.GITHUB_SHA_SHORT }}
-          push: ${{ env.DOCKER_PUSH }}
diff --git a/.github/workflows/image-build-debian-source.yml b/.github/workflows/image-build-debian-source.yml
deleted file mode 100644
index 3a8e379971..0000000000
--- a/.github/workflows/image-build-debian-source.yml
+++ /dev/null
@@ -1,94 +0,0 @@
-##
-## Build the Docker Debian image from source
-##
-
-name: Build Linux Source Image
-
-# Only run when:
-#   - workflow is manually triggered
-#   - manually triggered via the ci.yml workflow
-
-on:
-  workflow_dispatch:
-  workflow_call:
-    inputs:
-      docker_platforms:
-        required: true
-        description: "Arch to buid images"
-        type: string
-        default: linux/amd64
-      linux_version:
-        required: true
-        description: "Linux image to build"
-        type: string
-        default: debian
-      build_type:
-        required: true
-        description: Build type (source/binary)
-        type: string
-        default: source
-    secrets:
-      DOCKERHUB_USERNAME:
-        required: true
-      DOCKERHUB_PASSWORD:
-        required: true
-
-jobs:
-  image:
-    name: Build Image
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout the latest code
-        id: git_checkout
-        uses: actions/checkout@v3
-      - name: Set Vars
-        id: set_vars
-        run: |
-          echo "GITHUB_SHA_SHORT=${GITHUB_SHA::7}" >> $GITHUB_ENV
-          echo "GITHUB_REF_SHORT=${GITHUB_REF#refs/*/}" >> $GITHUB_ENV
-          echo "DOCKER_PUSH=${{ (secrets.DOCKERHUB_USERNAME != '') && (secrets.DOCKERHUB_PASSWORD != '') }}" >> $GITHUB_ENV
-      - name: Set up QEMU
-        id: docker_qemu
-        uses: docker/setup-qemu-action@v2
-      - name: Set up Docker Buildx
-        id: docker_buildx
-        uses: docker/setup-buildx-action@v2
-      - name: Extract branch name
-        id: extract_branch
-        if: ${{ github.event_name != 'pull_request' }}
-        run: echo "BRANCH_NAME=$(echo ${GITHUB_REF#refs/heads/})" >> $GITHUB_ENV
-      - name: Extract branch name (PR)
-        id: extract_branch_pr
-        if: ${{ github.event_name == 'pull_request' }}
-        run: echo "BRANCH_NAME=$(echo ${GITHUB_HEAD_REF})" >> $GITHUB_ENV
-      - name: Docker Metadata
-        id: docker_metadata
-        uses: docker/metadata-action@v4
-        with:
-          images: |
-            blockstack/stacks-blockchain
-            blockstack/${{ github.event.repository.name }}
-          tags: |
-            type=raw,value=${{ env.BRANCH_NAME }}
-            type=ref,event=pr
-      - name: Login to DockerHub
-        id: docker_login
-        uses: docker/login-action@v2
-        # Only attempt login and push if we have credentials
-        if: env.DOCKER_PUSH == 'true'
-        with:
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_PASSWORD }}
-      - name: Build and Push
-        id: docker_build
-        uses: docker/build-push-action@v3
-        with:
-          file: ./.github/actions/dockerfiles/Dockerfile.${{ inputs.linux_version }}-${{ inputs.build_type }}
-          platforms: ${{ inputs.docker_platforms }}
-          tags: ${{ steps.docker_metadata.outputs.tags }}
-          labels: ${{ steps.docker_metadata.outputs.labels }}
-          build-args: |
-            STACKS_NODE_VERSION=${{ env.GITHUB_SHA_SHORT }}
-            GIT_BRANCH=${{ env.GITHUB_REF_SHORT }}
-            GIT_COMMIT=${{ env.GITHUB_SHA_SHORT }}
-          push: ${{ env.DOCKER_PUSH }}

From f07190e65a507e9fc9733668bf86d069f1a2e4e7 Mon Sep 17 00:00:00 2001
From: wileyj <2847772+wileyj@users.noreply.github.com>
Date: Sun, 19 Nov 2023 22:37:19 -0800
Subject: [PATCH 0089/1166] (3847) - Adding updated files

---
 .github/workflows/bitcoin-tests.yml           | 245 ++++---------
 .github/workflows/ci.yml                      | 327 ++++++++++--------
 .github/workflows/clarity-js-sdk-pr.yml       |  11 +-
 .github/workflows/docs-pr.yml                 |  19 +-
 .github/workflows/github-release.yml          |  75 +++-
 .github/workflows/stacks-blockchain-tests.yml | 185 ++++++----
 docs/ci-release.md                            | 266 ++++++++------
 7 files changed, 604 insertions(+), 524 deletions(-)

diff --git a/.github/workflows/bitcoin-tests.yml b/.github/workflows/bitcoin-tests.yml
index 9aba4e6250..48e53915ce 100644
--- a/.github/workflows/bitcoin-tests.yml
+++ b/.github/workflows/bitcoin-tests.yml
@@ -1,205 +1,100 @@
-##
-## Bitcoin Integration Tests
-##
+## Github workflow to run bitcoin tests
 
-name: Bitcoin Integration Tests
-
-# Only run when:
-#   - PRs are (re)opened against master branch
+name: Tests::Bitcoin
 
 on:
-  pull_request:
-    types:
-      - opened
-      - reopened
+  workflow_call:
+
+defaults:
+  run:
+    shell: bash
+
+## env vars are transferred to composite action steps
+env:
+  BITCOIND_TEST: 1
+  RUST_BACKTRACE: full
+  SEGMENT_DOWNLOAD_TIMEOUT_MINS: 15
+  RETRIES: 3
+  RETRY_DELAY: 10000
+  TEST_TIMEOUT: 30
+  TEST_RETRIES: 2
 
 concurrency:
-  group: stacks-bitcoin-integration-tests-${{ github.ref }}
-  # Only cancel in progress if this is for a PR
+  group: bitcoin-tests-${{ github.head_ref || github.ref || github.run_id}}
+  ## Only cancel in progress if this is for a PR
   cancel-in-progress: ${{ github.event_name == 'pull_request' }}
 
 jobs:
-  # Create bitcoin image used for later tests
-  build-integration-image:
-    name: Build Image
+  # Bitcoin integration tests with code coverage
+  integration-tests:
+    name: Integration Tests
     runs-on: ubuntu-latest
-    steps:
-      - name: Checkout the latest code
-        id: git_checkout
-        uses: actions/checkout@v3
-
-      - name: Reclaim disk space
-        id: cleanup
-        run: |
-          sudo apt-get update
-          sudo apt-get remove -y '^dotnet-.*'
-          sudo apt-get remove -y '^llvm-.*'
-          sudo apt-get remove -y 'php.*'
-          sudo apt-get remove -y '^mongodb-.*'
-          sudo apt-get remove -y '^mysql-.*'
-          sudo apt-get autoremove -y
-          sudo apt-get clean
-          docker system prune --force
-
-      - name: Build bitcoin integration testing image
-        id: build_docker_image
-        env:
-          DOCKER_BUILDKIT: 1
-        # Remove .dockerignore file so codecov has access to git info and build the image
-        run: |
-          rm .dockerignore
-          docker build -f ./.github/actions/bitcoin-int-tests/Dockerfile.generic.bitcoin-tests -t stacks-blockchain:integrations .
-
-      - name: Export docker image as tarball
-        id: export_docker_image
-        run: docker save stacks-blockchain:integrations | gzip > integration-image.tar.gz
-
-      - name: Upload built docker image
-        id: upload_docker_image
-        uses: actions/upload-artifact@v3
-        with:
-          name: integration-image.tar.gz
-          path: integration-image.tar.gz
-
-  # Run integration tests using sampled genesis block
-  sampled-genesis:
-    name: Sampled Genesis
-    runs-on: ubuntu-latest
-    needs:
-      - build-integration-image
     strategy:
+      ## Continue with the test matrix even if we've had a failure
       fail-fast: false
+      ## Run a maximum of 32 concurrent tests from the test matrix
+      max-parallel: 32
       matrix:
         test-name:
-          - tests::neon_integrations::miner_submit_twice
-          - tests::neon_integrations::microblock_integration_test
-          - tests::neon_integrations::microblock_fork_poison_integration_test
-          - tests::neon_integrations::size_check_integration_test
-          - tests::neon_integrations::cost_voting_integration
+          - tests::bitcoin_regtest::bitcoind_integration_test
           - tests::integrations::integration_test_get_info
+          - tests::neon_integrations::antientropy_integration_test ## forced failure
+          - tests::neon_integrations::bad_microblock_pubkey
+          - tests::neon_integrations::bitcoind_forking_test
           - tests::neon_integrations::bitcoind_integration_test
+          - tests::neon_integrations::block_large_tx_integration_test
+          - tests::neon_integrations::block_limit_hit_integration_test
+          - tests::neon_integrations::cost_voting_integration
+          - tests::neon_integrations::filter_long_runtime_tx_integration_test
+          - tests::neon_integrations::filter_low_fee_tx_integration_test
+          - tests::neon_integrations::fuzzed_median_fee_rate_estimation_test_window10
+          - tests::neon_integrations::fuzzed_median_fee_rate_estimation_test_window5
           - tests::neon_integrations::liquid_ustx_integration
-          - tests::neon_integrations::stx_transfer_btc_integration_test
-          - tests::neon_integrations::stx_delegate_btc_integration_test
-          - tests::neon_integrations::bitcoind_forking_test
-          - tests::neon_integrations::should_fix_2771
-          - tests::neon_integrations::pox_integration_test
+          - tests::neon_integrations::microblock_fork_poison_integration_test
+          - tests::neon_integrations::microblock_integration_test
+          - tests::neon_integrations::microblock_large_tx_integration_test_FLAKY
+          - tests::neon_integrations::microblock_limit_hit_integration_test
+          - tests::neon_integrations::miner_submit_twice
           - tests::neon_integrations::mining_events_integration_test
-          - tests::bitcoin_regtest::bitcoind_integration_test
-          - tests::should_succeed_handling_malformed_and_valid_txs
+          - tests::neon_integrations::pox_integration_test
+          - tests::neon_integrations::push_boot_receipts
+          - tests::neon_integrations::runtime_overflow_unconfirmed_microblocks_integration_test
+          - tests::neon_integrations::should_fix_2771
+          - tests::neon_integrations::size_check_integration_test
+          - tests::neon_integrations::size_overflow_unconfirmed_invalid_stream_microblocks_integration_test
           - tests::neon_integrations::size_overflow_unconfirmed_microblocks_integration_test
           - tests::neon_integrations::size_overflow_unconfirmed_stream_microblocks_integration_test
-          - tests::neon_integrations::size_overflow_unconfirmed_invalid_stream_microblocks_integration_test
-          - tests::neon_integrations::runtime_overflow_unconfirmed_microblocks_integration_test
-          - tests::neon_integrations::antientropy_integration_test
-          - tests::neon_integrations::filter_low_fee_tx_integration_test
-          - tests::neon_integrations::filter_long_runtime_tx_integration_test
-          - tests::neon_integrations::microblock_large_tx_integration_test_FLAKY
-          - tests::neon_integrations::block_large_tx_integration_test
-          - tests::neon_integrations::microblock_limit_hit_integration_test
-          - tests::neon_integrations::block_limit_hit_integration_test
-          - tests::neon_integrations::fuzzed_median_fee_rate_estimation_test_window5
-          - tests::neon_integrations::fuzzed_median_fee_rate_estimation_test_window10
-          - tests::neon_integrations::use_latest_tip_integration_test
-          - tests::neon_integrations::test_flash_block_skip_tenure
+          - tests::neon_integrations::stx_delegate_btc_integration_test
+          - tests::neon_integrations::stx_transfer_btc_integration_test
           - tests::neon_integrations::test_chainwork_first_intervals
           - tests::neon_integrations::test_chainwork_partial_interval
-          - tests::neon_integrations::test_problematic_txs_are_not_stored
+          - tests::neon_integrations::test_flash_block_skip_tenure
           - tests::neon_integrations::test_problematic_blocks_are_not_mined
           - tests::neon_integrations::test_problematic_blocks_are_not_relayed_or_stored
           - tests::neon_integrations::test_problematic_microblocks_are_not_mined
           - tests::neon_integrations::test_problematic_microblocks_are_not_relayed_or_stored
-          - tests::neon_integrations::push_boot_receipts
-          - tests::epoch_205::test_dynamic_db_method_costs
-          - tests::epoch_205::transition_empty_blocks
-          - tests::epoch_205::test_cost_limit_switch_version205
-          - tests::epoch_205::test_exact_block_costs
-          - tests::epoch_205::bigger_microblock_streams_in_2_05
-          - tests::epoch_21::transition_adds_burn_block_height
-          - tests::epoch_21::transition_fixes_bitcoin_rigidity
-          - tests::epoch_21::transition_adds_pay_to_contract
-          - tests::epoch_21::transition_adds_get_pox_addr_recipients
-          - tests::epoch_21::transition_adds_mining_from_segwit
-          - tests::epoch_21::transition_removes_pox_sunset
-          - tests::epoch_21::transition_empty_blocks
-          - tests::epoch_21::test_pox_reorgs_three_flaps
-          - tests::epoch_21::test_pox_reorg_one_flap
-          - tests::epoch_21::test_pox_reorg_flap_duel
-          - tests::epoch_21::test_pox_reorg_flap_reward_cycles
-          - tests::epoch_21::test_pox_missing_five_anchor_blocks
-          - tests::epoch_21::test_sortition_divergence_pre_21
-          - tests::epoch_21::test_v1_unlock_height_with_current_stackers
-          - tests::epoch_21::test_v1_unlock_height_with_delay_and_current_stackers
-          - tests::epoch_21::trait_invocation_cross_epoch
-          - tests::epoch_22::pox_2_unlock_all
-          - tests::epoch_22::disable_pox
-          - tests::epoch_22::test_pox_reorg_one_flap
-          - tests::epoch_23::trait_invocation_behavior
-          - tests::neon_integrations::bad_microblock_pubkey
-          - tests::epoch_24::fix_to_pox_contract
-          - tests::epoch_24::verify_auto_unlock_behavior
+          - tests::neon_integrations::test_problematic_txs_are_not_stored
+          - tests::neon_integrations::use_latest_tip_integration_test
+          - tests::should_succeed_handling_malformed_and_valid_txs
     steps:
-      - name: Checkout the latest code
-        id: git_checkout
-        uses: actions/checkout@v3
-      - name: Download docker image
-        id: download_docker_image
-        uses: actions/download-artifact@v3
-        with:
-          name: integration-image.tar.gz
-      - name: Load docker image
-        id: load_docker_image
-        run: docker load -i integration-image.tar.gz && rm integration-image.tar.gz
-      - name: All integration tests with sampled genesis
-        id: bitcoin_integration_tests
-        timeout-minutes: 30
-        env:
-          DOCKER_BUILDKIT: 1
-          TEST_NAME: ${{ matrix.test-name }}
-        run: docker build -o coverage-output --build-arg test_name=${{ matrix.test-name }} -f ./.github/actions/bitcoin-int-tests/Dockerfile.bitcoin-tests .
-      - name: Code Coverage
-        id: code_coverage
-        uses: codecov/codecov-action@v3
-        with:
-          files: ./coverage-output/lcov.info
-          name: ${{ matrix.test-name }}
-          fail_ci_if_error: false
+      ## Setup test environment
+      - name: Setup Test Environment
+        id: setup_tests
+        uses: stacks-network/actions/stacks-core/testenv@main
 
-  # Run atlas integration tests
-  atlas-test:
-    name: Atlas Test
-    runs-on: ubuntu-latest
-    needs:
-      - build-integration-image
-    strategy:
-      fail-fast: false
-      matrix:
-        test-name:
-          - tests::neon_integrations::atlas_integration_test
-          - tests::neon_integrations::atlas_stress_integration_test
-    steps:
-      - name: Checkout the latest code
-        id: git_checkout
-        uses: actions/checkout@v3
-      - name: Download docker image
-        id: download_docker_image
-        uses: actions/download-artifact@v3
+      ## Run test matrix using restored cache of archive file
+      ##   - Test will timeout after env.TEST_TIMEOUT minutes
+      - name: Run Tests
+        id: run_tests
+        timeout-minutes: ${{ fromJSON(env.TEST_TIMEOUT) }}
+        uses: stacks-network/actions/stacks-core/run-tests@main
         with:
-          name: integration-image.tar.gz
-      - name: Load docker image
-        id: load_docker_image
-        run: docker load -i integration-image.tar.gz && rm integration-image.tar.gz
-      - name: Atlas integration tests
-        id: atlas_integration_tests
-        timeout-minutes: 40
-        env:
-          DOCKER_BUILDKIT: 1
-          TEST_NAME: ${{ matrix.test-name }}
-        run: docker build -o coverage-output --build-arg test_name=${{ matrix.test-name }} -f ./.github/actions/bitcoin-int-tests/Dockerfile.bitcoin-tests .
+          test-name: ${{ matrix.test-name }}
+          threads: 1
+
+      ## Create and upload code coverage file
       - name: Code Coverage
-        id: code_coverage
-        uses: codecov/codecov-action@v3
+        id: codecov
+        uses: stacks-network/actions/codecov@main
         with:
-          files: ./coverage-output/lcov.info
-          name: ${{ matrix.test-name }}
-          fail_ci_if_error: false
+          test-name: ${{ matrix.test-name }}
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 5b72c9faf3..9075172268 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -1,180 +1,223 @@
+## The main Github Actions workflow
 name: CI
 
-## Only run when:
-##   - manually triggered
-##   - PR's are (re)opened
-##   - push to master (i.e. merge develop -> master)
-
 on:
   push:
     branches:
       - master
-  pull_request:
+      - develop
+    paths-ignore:
+      - "**.md"
+      - "**.yml"
   workflow_dispatch:
     inputs:
       tag:
         description: "The tag to create (optional)"
         required: false
+  pull_request_target:
+    types:
+      - opened
+      - reopened
+      - synchronize
+    paths-ignore:
+      - "**.md"
+      - "**.yml"
+    ## might be better to use inclusive v exclusive paths here, ex:
+    # paths:
+    #   - "**.rs"
+    #   - "**.clar"
+  pull_request_review:
+    types:
+      - submitted
+
+defaults:
+  run:
+    shell: bash
 
 concurrency:
-  group: ${{ github.head_ref || github.run_id }}
+  group: ci-${{ github.head_ref || github.ref }}
+  ## Always cancel duplicate jobs
   cancel-in-progress: true
 
+run-name: ${{ inputs.tag }}
+
 jobs:
-  ## rust format: Execute on every run
+  ##
+  ## Jobs to execute everytime workflow runs
+  ##   do not run if the trigger is any of the following:
+  ##   - PR review submitted (not approved)
+  ##   and any of:
+  ##     - PR review comment
+  ##     - PR change is requested
   rustfmt:
+    if: |
+      !(
+        github.event_name == 'pull_request_review' && 
+        github.event.action == 'submitted' && 
+        (
+          github.event.review.state == 'commented' ||
+          github.event.review.state == 'changes_requested'
+        )
+      )
     name: Rust Format
     runs-on: ubuntu-latest
     steps:
       - name: Checkout the latest code
         id: git_checkout
-        uses: actions/checkout@v3
-      - name: Define Rust Toolchain
-        id: define_rust_toolchain
-        run: echo "RUST_TOOLCHAIN=$(cat ./rust-toolchain)" >> $GITHUB_ENV
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+
       - name: Setup Rust Toolchain
         id: setup_rust_toolchain
-        uses: actions-rust-lang/setup-rust-toolchain@v1
+        uses: actions-rust-lang/setup-rust-toolchain@f3c84ee10bf5a86e7a5d607d487bf17d57670965 # v1.5.0
         with:
-          toolchain: ${{ env.RUST_TOOLCHAIN }}
           components: rustfmt
-      - name: Rustfmt 
-        id: rustfmt
-        uses: actions-rust-lang/rustfmt@v1
+          cache: false
 
-  ## Release tests: Execute on every run
-  release-tests:
-    name: Release Tests
-    uses: stacks-network/stacks-blockchain/.github/workflows/stacks-blockchain-tests.yml@master
-
-  ## Checked for leaked credentials: Execute on every run
-  leaked-cred-test:
-    name: Leaked Credential Test
-    runs-on: ubuntu-latest
-    steps:
-      - name: Extract branch name
-        id: extract_branch
-        if: ${{ github.event_name != 'pull_request' }}
-        run: echo "BRANCH_NAME=$(echo ${GITHUB_REF#refs/heads/})" >> $GITHUB_ENV
-      - name: Extract branch name
-        id: extract_branch_pr
-        if: ${{ github.event_name == 'pull_request' }}
-        run: echo "BRANCH_NAME=$(echo ${GITHUB_HEAD_REF})" >> $GITHUB_ENV
-      - name: Branch name
-        run: echo running on branch ${{ env.BRANCH_NAME }}
-      - name: Checkout the latest code
-        id: git_checkout
-        uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-      - name: TruffleHog Scan
-        id: trufflehog_check
-        uses: trufflesecurity/trufflehog@main
-        with:
-          path: ./
-          base: ${{ env.BRANCH_NAME }}
-          head: HEAD
+      - name: Rustfmt
+        id: rustfmt
+        uses: actions-rust-lang/rustfmt@2d1d4e9f72379428552fa1def0b898733fb8472d # v1.1.0
 
-  ###############################################
-  ## Build Tagged Release
-  ###############################################
-  ## Build source binaries
-  ## Only run if:
-  ##    - Tag is provided
-  ##    - OR
-  ##        - Not the default branch
-  ##        - AND
-  ##        - Not a PR
-  build-source:
-    if: ${{ inputs.tag != '' || (github.ref != format('refs/heads/{0}', github.event.repository.default_branch) && !contains(github.ref, 'refs/pull')) }}
-    name: Build Binaries
-    uses: stacks-network/stacks-blockchain/.github/workflows/build-source-binary.yml@master
+  ######################################################################################
+  ## Create a tagged github release
+  ##
+  ## Runs when the following is true:
+  ##  - tag is provided
+  ##  - workflow is building default branch (master)
+  create-release:
+    if: |
+      inputs.tag != '' &&
+      github.ref == format('refs/heads/{0}', github.event.repository.default_branch)
+    name: Create Release
     needs:
       - rustfmt
-      - release-tests
-      - leaked-cred-test
+    uses: ./.github/workflows/github-release.yml
     with:
       tag: ${{ inputs.tag }}
-      parallel_jobs: 4
-      arch: >-
-        ["linux-glibc-x64", "linux-musl-x64", "linux-glibc-arm64", "linux-musl-arm64", "macos-x64", "macos-arm64", "windows-x64"]
+    secrets: inherit
 
-  ## Create github release with binary archives
-  ## Only run if:
-  ##    - Tag is provided
-  ##    - OR
-  ##        - Not the default branch
-  ##        - AND
-  ##        - Not a PR
-  github-release:
-    if: ${{ inputs.tag != '' || (github.ref != format('refs/heads/{0}', github.event.repository.default_branch) && !contains(github.ref, 'refs/pull')) }}
-    name: Github Release
-    uses: stacks-network/stacks-blockchain/.github/workflows/github-release.yml@master
-    needs: build-source
-    with:
-      tag: ${{ inputs.tag }}
-      arch: >-
-        ["linux-glibc-x64", "linux-musl-x64", "linux-glibc-arm64", "linux-musl-arm64", "macos-x64", "macos-arm64", "windows-x64"]
-    secrets:
-      GH_TOKEN: ${{ secrets.GH_TOKEN }}
+  ## Build and push Debian image built from source
+  ##
+  ## Runs when:
+  ##   - tag is not provided
+  ##   and the following are not true:
+  ##     - PR review submitted (not approved)
+  ##     and any of:
+  ##       - PR review comment
+  ##       - PR change is requested
+  docker-image:
+    if: |
+      inputs.tag == '' &&
+      !(
+        github.event_name == 'pull_request_review' &&
+        github.event.action == 'submitted' &&
+        (
+          github.event.review.state == 'commented' ||
+          github.event.review.state == 'changes_requested'
+        )
+      )
+    name: Docker Image (Source)
+    uses: ./.github/workflows/image-build-source.yml
+    needs:
+      - rustfmt
+    secrets: inherit
 
-  ## Create docker alpine images
-  ## Only run if:
-  ##    - Tag is provided
-  ##    - OR
-  ##      - Not the default branch
-  ##      - AND
-  ##      - Not a PR
-  docker-alpine:
-    if: ${{ inputs.tag != '' || (github.ref != format('refs/heads/{0}', github.event.repository.default_branch) && !contains(github.ref, 'refs/pull')) }}
-    name: Docker Alpine (Binary)
-    uses: stacks-network/stacks-blockchain/.github/workflows/image-build-alpine-binary.yml@master
-    needs: github-release
-    with:
-      tag: ${{ inputs.tag }}
-      docker_platforms: linux/arm64, linux/amd64, linux/amd64/v2, linux/amd64/v3
-    secrets:
-      DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
-      DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
+  ## Create a reusable cache for tests
+  ##
+  ## Runs when:
+  ##   - tag is provided
+  ##   or:
+  ##     - no tag provided
+  ##       and any of:
+  ##         - PR is approved (any approval will trigger)
+  ##         - this workflow is called manually
+  ##         - PR is opened
+  ##         - commit to either (development, master) branch
+  create-cache:
+    if: |
+      inputs.tag != '' || (
+        inputs.tag == '' && (
+          (
+            github.event_name == 'pull_request_review' &&
+            github.event.action == 'submitted' &&
+            github.event.review.state == 'approved'
+          ) ||
+          github.event_name == 'workflow_dispatch' ||
+          github.event_name == 'pull_request_target' ||
+          (
+            contains('
+              refs/heads/develoment
+              refs/heads/master
+            ', github.event.pull_request.head.ref) &&
+            github.event_name == 'push'
+          )
+        )
+      )
+    name: Create Test Cache
+    needs:
+      - rustfmt
+    uses: ./.github/workflows/create-cache.yml
 
-  ## Create docker debian images
-  ## Only run if:
-  ##    - Tag is provided
-  ##    - OR
-  ##        - Not the default branch
-  ##        - AND
-  ##        - Not a PR
-  docker-debian:
-    if: ${{ inputs.tag != '' || (github.ref != format('refs/heads/{0}', github.event.repository.default_branch) && !contains(github.ref, 'refs/pull')) }}
-    name: Docker Debian (Binary)
-    uses: stacks-network/stacks-blockchain/.github/workflows/image-build-debian-binary.yml@master
-    needs: github-release
-    with:
-      tag: ${{ inputs.tag }}
-      docker_platforms: linux/amd64, linux/amd64/v2, linux/amd64/v3
-      linux_version: debian
-      build_type: binary
-    secrets:
-      DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
-      DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
+  ## Tests to run regularly
+  ##
+  ## Runs when:
+  ##   - tag is provided
+  ##   either or of the following:
+  ##     - tag is not provided
+  ##     - PR is approved
+  stacks-blockchain-tests:
+    if: |
+      inputs.tag != '' || (
+        inputs.tag == '' || (
+          github.event_name == 'pull_request_review' &&
+          github.event.action == 'submitted' &&
+          github.event.review.state == 'approved'
+        )
+      )
+    name: Stacks Blockchain Tests
+    needs:
+      - rustfmt
+      - create-cache
+    uses: ./.github/workflows/stacks-blockchain-tests.yml
 
-  ###############################################
-  ## Build Branch/PR
-  ###############################################
-  ## Create docker debian images
-  ## Only run if:
-  ##   - Tag is *not* provided
-  build-branch:
-    if: ${{ inputs.tag == '' }}
-    name: Docker Debian (Source)
-    uses: stacks-network/stacks-blockchain/.github/workflows/image-build-debian-source.yml@master
+  bitcoin-tests:
+    if: |
+      inputs.tag != '' || (
+        inputs.tag == '' || (
+          github.event_name == 'pull_request_review' &&
+          github.event.action == 'submitted' &&
+          github.event.review.state == 'approved'
+        )
+      )
+    name: Bitcoin Tests
     needs:
       - rustfmt
-      - leaked-cred-test
-    with:
-      docker_platforms: linux/amd64
-      linux_version: debian
-      build_type: source
-    secrets:
-      DOCKERHUB_USERNAME: ${{ secrets.DOCKERHUB_USERNAME }}
-      DOCKERHUB_PASSWORD: ${{ secrets.DOCKERHUB_PASSWORD }}
+      - create-cache
+    uses: ./.github/workflows/bitcoin-tests.yml
+
+  ## Test to run on a tagged release
+  ##
+  ## Runs when:
+  ##   - tag is provided
+  atlas-tests:
+    if: inputs.tag != ''
+    name: Atlas Tests
+    needs:
+      - rustfmt
+      - create-cache
+    uses: ./.github/workflows/atlas-tests.yml
+
+  epoch-tests:
+    if: inputs.tag != ''
+    name: Epoch Tests
+    needs:
+      - rustfmt
+      - create-cache
+    uses: ./.github/workflows/epoch-tests.yml
+
+  slow-tests:
+    if: inputs.tag != ''
+    name: Slow Tests
+    needs:
+      - rustfmt
+      - create-cache
+    uses: ./.github/workflows/slow-tests.yml
diff --git a/.github/workflows/clarity-js-sdk-pr.yml b/.github/workflows/clarity-js-sdk-pr.yml
index 9ac0956a85..25e96f9f2b 100644
--- a/.github/workflows/clarity-js-sdk-pr.yml
+++ b/.github/workflows/clarity-js-sdk-pr.yml
@@ -4,6 +4,10 @@
 
 name: Open Clarity JS SDK PR
 
+defaults:
+  run:
+    shell: bash
+
 env:
   CLARITY_JS_SDK_REPOSITORY: stacks-network/clarity-js-sdk
   COMMIT_USER: Hiro DevOps
@@ -24,22 +28,25 @@ jobs:
     steps:
       - name: Checkout latest clarity js sdk
         id: git_checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
         with:
           token: ${{ secrets.GH_TOKEN }}
           repository: ${{ env.CLARITY_JS_SDK_REPOSITORY }}
           ref: master
+
       - name: Determine Release Version
         id: get_release_version
         run: |
           RELEASE_VERSION=$(echo ${GITHUB_REF#refs/*/} | tr / -)
           echo "RELEASE_VERSION=$RELEASE_VERSION" >> $GITHUB_ENV
+
       - name: Update SDK Tag
         id: update_sdk_tag
         run: sed -i "s@CORE_SDK_TAG = \".*\"@CORE_SDK_TAG = \"$RELEASE_VERSION\"@g" packages/clarity-native-bin/src/index.ts
+
       - name: Create Pull Request
         id: create_pr
-        uses: peter-evans/create-pull-request@v4
+        uses: peter-evans/create-pull-request@153407881ec5c347639a548ade7d8ad1d6740e38 # v5.0.2
         with:
           token: ${{ secrets.GH_TOKEN }}
           commit-message: "chore: update clarity-native-bin tag"
diff --git a/.github/workflows/docs-pr.yml b/.github/workflows/docs-pr.yml
index b2a44f7296..bb54c28cc3 100644
--- a/.github/workflows/docs-pr.yml
+++ b/.github/workflows/docs-pr.yml
@@ -9,6 +9,10 @@
 
 name: Open Docs PR
 
+defaults:
+  run:
+    shell: bash
+
 env:
   ROBOT_OWNER: kantai-robot
   ROBOT_REPO: docs.blockstack
@@ -16,9 +20,8 @@ env:
   TARGET_REPO: docs
   TARGET_REPOSITORY: stacks-network/docs
 
-# Only run when:
-#   - push to master
-
+## Only run when:
+##   - push to master
 on:
   push:
     branches:
@@ -33,19 +36,22 @@ jobs:
     steps:
       - name: Checkout the latest code
         id: git_checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+
       - name: Build docs
         id: build_docs
         env:
           DOCKER_BUILDKIT: 1
         run: rm -rf docs-output && docker build -o docs-output -f ./.github/actions/docsgen/Dockerfile.docsgen .
+
       - name: Checkout latest docs
         id: git_checkout_docs
-        uses: actions/checkout@v3
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
         with:
           token: ${{ secrets.DOCS_GITHUB_TOKEN }}
           repository: ${{ env.TARGET_REPOSITORY }}
           path: docs
+
       - name: Branch and commit
         id: push
         run: |
@@ -67,10 +73,11 @@ jobs:
             git push robot $ROBOT_BRANCH
             echo "::set-output name=open_pr::1"
           fi
+
       - name: Open PR
         id: open_pr
         if: ${{ steps.push.outputs.open_pr == '1' }}
-        uses: actions/github-script@v6
+        uses: actions/github-script@d7906e4ad0b1822421a7e6a35d5ca353c962f410 # v6.4.1
         with:
           github-token: ${{ secrets.DOCS_GITHUB_TOKEN }}
           script: |
diff --git a/.github/workflows/github-release.yml b/.github/workflows/github-release.yml
index c0683f51df..14e7117a95 100644
--- a/.github/workflows/github-release.yml
+++ b/.github/workflows/github-release.yml
@@ -1,50 +1,75 @@
-##
-## Create the github release and store artifact files (with checksum)
-##
+## Github workflow to create a github release and upload binary artifacts
 
 name: Github Release
 
-# Only run when:
-#   - manually triggered via the ci.yml workflow
-
 on:
   workflow_call:
     inputs:
       tag:
-        required: true
-        type: string
-      arch:
-        description: "Stringified JSON object listing of platform matrix"
+        description: "Release Tag"
         required: true
         type: string
     secrets:
       GH_TOKEN:
         required: true
 
+concurrency:
+  group: github-release-${{ github.head_ref || github.ref }}
+  ## Always cancel duplicate jobs
+  cancel-in-progress: true
+
+run-name: ${{ inputs.tag }}
+
 jobs:
+  ## Build arch dependent binaries from source
+  ##
+  ## Runs when the following is true:
+  ##  - tag is provided
+  ##  - workflow is building default branch (master)
+  build-binaries:
+    if: |
+      inputs.tag != '' && 
+      github.ref == format('refs/heads/{0}', github.event.repository.default_branch)
+    name: Build Binaries
+    uses: ./.github/workflows/create-source-binary.yml
+    with:
+      tag: ${{ inputs.tag }}
+    secrets: inherit
+
+  ## Runs when the following is true:
+  ##  - tag is provided
+  ##  - workflow is building default branch (master)
   create-release:
-    if: ${{ inputs.tag != '' }}
+    if: |
+      inputs.tag != '' && 
+      github.ref == format('refs/heads/{0}', github.event.repository.default_branch)
     name: Create Release
     runs-on: ubuntu-latest
+    needs:
+      - build-binaries
     steps:
+      ## Downloads the artifacts built in `create-source-binary.yml`
       - name: Download Artifacts
         id: download_artifacts
-        uses: actions/download-artifact@v3
+        uses: actions/download-artifact@9bc31d5ccc31df68ecc42ccf4149144866c47d8a # v3.0.2
         with:
           name: artifact
           path: release
-      # Generate a checksums file to be added to the release page
+
+      ## Generate a checksums file to be added to the release page
       - name: Generate Checksums
         id: generate_checksum
-        uses: jmgilman/actions-generate-checksum@v1
+        uses: jmgilman/actions-generate-checksum@24a35957fba81c6cbaefeb1e3d59ee56e3db5077 # v1.0.0
         with:
+          method: sha512
           output: CHECKSUMS.txt
           patterns: |
             release/*.zip
-      # Upload the release archives with the checksums file
+
+      ## Upload the release archives with the checksums file
       - name: Upload Release
         id: upload_release
-        uses: softprops/action-gh-release@v1
+        uses: softprops/action-gh-release@de2c0eb89ae2a093876385947365aca7b0e5f844 #v0.1.15
         env:
           GITHUB_TOKEN: ${{ secrets.GH_TOKEN }}
         with:
@@ -56,3 +81,21 @@ jobs:
           files: |
             release/*.zip
             CHECKSUMS.txt
+
+  ## Builds arch dependent Docker images from binaries
+  ##
+  ## Runs when the following is true:
+  ##  - tag is provided
+  ##  - workflow is building default branch (master)
+  docker-image:
+    if: |
+      inputs.tag != '' && 
+      github.ref == format('refs/heads/{0}', github.event.repository.default_branch)
+    name: Docker Image (Binary)
+    uses: ./.github/workflows/image-build-binary.yml
+    needs:
+      - build-binaries
+      - create-release
+    with:
+      tag: ${{ inputs.tag }}
+    secrets: inherit
diff --git a/.github/workflows/stacks-blockchain-tests.yml b/.github/workflows/stacks-blockchain-tests.yml
index fb1dffc1ae..fa415a9cdc 100644
--- a/.github/workflows/stacks-blockchain-tests.yml
+++ b/.github/workflows/stacks-blockchain-tests.yml
@@ -1,95 +1,138 @@
-##
-## Run tests for tagged releases
-##
+## Github workflow to run full genesis and unit tests
 
-name: Tests
-
-# Only run when:
-#   - manually triggered via the ci.yml workflow
+name: Tests::Stacks Blockchain
 
 on:
   workflow_call:
 
+defaults:
+  run:
+    shell: bash
+
+## env vars are transferred to composite action steps
+env:
+  BITCOIND_TEST: 1
+  RUST_BACKTRACE: full
+  SEGMENT_DOWNLOAD_TIMEOUT_MINS: 3
+  RETRIES: 3
+  RETRY_DELAY: 10000
+  TEST_TIMEOUT: 30
+  TEST_RETRIES: 2
+
+concurrency:
+  group: stacks-blockchain-tests-${{ github.head_ref || github.ref || github.run_id }}
+  ## Only cancel in progress if this is for a PR
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
 jobs:
-  # Run full genesis test
+  # Full genesis test with code coverage
   full-genesis:
     name: Full Genesis Test
     runs-on: ubuntu-latest
+    strategy:
+      ## Continue with the test matrix even if we've had a failure
+      fail-fast: false
+      ## Run a maximum of 2 concurrent tests from the test matrix
+      max-parallel: 2
+      matrix:
+        test-name:
+          - neon_integrations::bitcoind_integration_test
     steps:
-      - name: Checkout the latest code
-        id: git_checkout
-        uses: actions/checkout@v3
-      - name: Single full genesis integration test
-        id: full_genesis_test
-        env:
-          DOCKER_BUILDKIT: 1
-        # Remove .dockerignore file so codecov has access to git info
-        run: |
-          rm .dockerignore
-          docker build -o coverage-output -f ./.github/actions/bitcoin-int-tests/Dockerfile.large-genesis .
-      - name: Large Genesis Codecov
-        id: full_genesis_codecov
-        uses: codecov/codecov-action@v3
+      ## Setup test environment
+      - name: Setup Test Environment
+        id: setup_tests
+        uses: stacks-network/actions/stacks-core/testenv@main
+        with:
+          genesis: true
+
+      ## Run test matrix using restored cache of archive file
+      ##   - Test will timeout after env.TEST_TIMEOUT minutes
+      - name: Run Tests
+        id: run_tests
+        timeout-minutes: ${{ fromJSON(env.TEST_TIMEOUT) }}
+        uses: stacks-network/actions/stacks-core/run-tests@main
+        with:
+          test-name: ${{ matrix.test-name }}
+          threads: 1
+          archive-file: /tmp/genesis_archive.tar.zst
+
+      ## Upload code coverage file
+      - name: Code Coverage
+        id: codecov
+        uses: stacks-network/actions/codecov@main
         with:
-          files: ./coverage-output/lcov.info
-          name: large_genesis
-          fail_ci_if_error: false
+          test-name: large_genesis
+          filename: ./lcov.info
+
+      - name: Status Output
+        run: |
+          echo "run_tests: ${{ steps.run_tests.outputs.status }}"
+          echo "codecov: ${{ steps.codecov.outputs.status }}"
+
+      - name: Check Failures
+        if: steps.run_tests.outputs.status == 'failure' || steps.codecov.outputs.status == 'failure'
+        run: exit 1
 
-  # Run unit tests with code coverage
+  # Unit tests with code coverage
   unit-tests:
     name: Unit Tests
     runs-on: ubuntu-latest
+    ## Continue the workflow in case a step fails (ex a single test fails)
+    continue-on-error: true
+    strategy:
+      ## Continue the workflow in case a step fails (ex a single test fails)
+      fail-fast: false
+      matrix:
+        ## Partition the tests into 8 jobs
+        ##   - This is used in a later step when running `cargo nextest run ... --partition count:num/8`
+        partition: [1, 2, 3, 4, 5, 6, 7, 8]
     steps:
-      - name: Checkout the latest code
-        id: git_checkout
-        uses: actions/checkout@v3
-      - name: Run unit tests (with coverage)
-        id: unit_tests_codecov
-        env:
-          DOCKER_BUILDKIT: 1
-        # Remove .dockerignore file so codecov has access to git info
-        run: |
-          rm .dockerignore
-          docker build -o coverage-output -f ./.github/actions/bitcoin-int-tests/Dockerfile.code-cov .
-      - name: Run unit tests
-        id: codedov
-        uses: codecov/codecov-action@v3
+      ## Setup test environment
+      - name: Setup Test Environment
+        id: setup_tests
+        uses: stacks-network/actions/stacks-core/testenv@main
+
+      ## Run test matrix using restored cache of archive file
+      ##   - Test will timeout after env.TEST_TIMEOUT minutes
+      - name: Run Tests
+        id: run_tests
+        timeout-minutes: ${{ fromJSON(env.TEST_TIMEOUT) }}
+        uses: stacks-network/actions/stacks-core/run-tests/partition@main
+        with:
+          partition: ${{ matrix.partition }}
+          total-partitions: 8
+
+      ## Create and upload code coverage file
+      - name: Code Coverage
+        id: codecov
+        uses: stacks-network/actions/codecov@main
         with:
-          files: ./coverage-output/lcov.info
-          name: unit_tests
-          fail_ci_if_error: false
+          test-name: ${{ matrix.test-name }}
 
+  ## Generate and upload openapi html artifact
   open-api-validation:
     name: OpenAPI Validation
     runs-on: ubuntu-latest
     steps:
-      - name: Checkout the latest code
-        id: git_checkout
-        uses: actions/checkout@v3
-      - name: Run units tests (with coverage)
-        id: api_codecov
-        env:
-          DOCKER_BUILDKIT: 1
-        run: docker build -o dist/ -f .github/actions/open-api/Dockerfile.open-api-validate .
-      - name: Upload bundled html
-        id: upload_html_artifact
-        uses: actions/upload-artifact@v3
+      - name: OpenAPI
+        id: openapi
+        uses: stacks-network/actions/openapi@main
         with:
-          name: open-api-bundle
-          path: |
-            dist
+          input: ./docs/rpc/openapi.yaml
+          output: ./open-api-docs.html
 
-  # Run net-tests
+  ## Disabled
+  ##   - this test can take several hours to run
   nettest:
-    # disable this job/test for now, since we haven't seen this pass
-    #  on github actions in a while, and the failures can take > 4 hours
     if: ${{ false }}
     name: Net-Test
     runs-on: ubuntu-latest
     steps:
+      ## checkout the code
       - name: Checkout the latest code
         id: git_checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+
       - name: Run network relay tests
         id: nettest
         env:
@@ -101,17 +144,23 @@ jobs:
     name: Core Contracts Test
     runs-on: ubuntu-latest
     steps:
+      ## Checkout the code
       - name: Checkout the latest code
         id: git_checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
+
+      ## Use Clarinet to run contract unit-tests and create code coverage file
       - name: Execute core contract unit tests in Clarinet
         id: clarinet_unit_test
-        uses: docker://hirosystems/clarinet:1.1.0
+        uses: docker://hirosystems/clarinet:1.8.0
         with:
           args: test --coverage --manifest-path=./contrib/core-contract-tests/Clarinet.toml
-      - name: Export code coverage
-        id: clarinet_codecov
-        uses: codecov/codecov-action@v3
+
+      ## Upload code coverage file
+      - name: Code Coverage
+        id: codecov
+        uses: stacks-network/actions/codecov@main
         with:
-          files: ./coverage.lcov
-          verbose: true
+          test-name: ${{ matrix.test-name }}
+          upload-only: true
+          filename: ./coverage.lcov
diff --git a/docs/ci-release.md b/docs/ci-release.md
index 7025226d1e..82fe164ec5 100644
--- a/docs/ci-release.md
+++ b/docs/ci-release.md
@@ -3,148 +3,184 @@
 All releases are built via a Github Actions workflow named `CI`, and is responsible for building binary archives, checksums, and resulting docker images.
 This workflow will also trigger any tests that need to be run, like integration tests.
 
-1. Releases are only created if a tag is manually provided when the ci workflow is triggered.
-2. Pushing a new feature branch: Nothing is triggered automatically. PR's are required, or the ci workflow can be triggered manually on a specific branch to build a docker image for the specified branch.
-
-The following workflow steps are currently disabled:
-
-- Clippy
-- Net-test
-- Crate audit
+1. Releases are only created if a tag is **manually** provided when the ci workflow is triggered.
+2. Pushing a new feature branch: Nothing is triggered automatically. A PR is required, or the ci workflow can be triggered manually on a specific branch to build a docker image (and run the standard PR tests) for the specified branch.
+3. Caching is used to speed up testing - a cache is created based on the type of data (i.e. cargo) and the commit sha. tests can be retried quickly since the cache will persist until the cleanup job is run.
+4. [nextest](https://nexte.st/) is used to run the tests from an archived file that is cached (using commit sha as a key))
+   - Two [archives](https://nexte.st/book/reusing-builds.html) are created, one for genesis tests and one for generic tests (it is done this way to reduce the time spent building)
+   - Unit-tests are [partitioned](https://nexte.st/book/partitioning.html) and multi-threaded to speed up execution time
 
 ## TL;DR
 
-1. A PR will produce a single image built from source on Debian with glibc with 2 tags:
+1. An open/re-opened/synchronized PR will produce a single image built from source on Debian with glibc with 2 tags:
    - `stacks-blockchain:<branch-name>`
    - `stacks-blockchain:<pr-number>`
 2. A merged PR from `develop` to the default branch will produce a single image built from source on Debian with glibc:
    - `stacks-blockchain:<default-branch-name>`
 3. An untagged build of any branch will produce a single image built from source on Debian with glibc:
    - `stacks-blockchain:<branch-name>`
-4. A tagged release on a non-default branch will produce 2 versions of the docker image (along with all binary archives):
-   - An Alpine image for several architectures tagged with:
+4. A tagged release on a non-default branch will produces:
+   - Docker Alpine image for several architectures tagged with:
      - `stacks-blockchain:<x.x.x.x.x>`
-   - An Debian image for several architectures tagged with:
+   - Docker Debian image for several architectures tagged with:
      - `stacks-blockchain:<x.x.x.x.x-debian>`
-5. A tagged release on the default branch will produce 2 versions of the docker image (along with all binary archives):
-   - An Alpine image for several architectures tagged with:
+5. A tagged release on the default branch will produce:
+   - Github Release of the specified tag with:
+     - Binary archives for several architectures
+   - Docker Alpine image for several architectures tagged with:
      - `stacks-blockchain:<x.x.x.x.x>`
      - `stacks-blockchain:<latest>`
-   - An Debian image for several architectures tagged with:
+   - Docker Debian image for several architectures tagged with:
      - `stacks-blockchain:<x.x.x.x.x-debian>`
      - `stacks-blockchain:<latest-debian>`
 
-## Release workflow:
-
-1. Create a feature branch: `feat/112-fix-something`
-2. PR `feat/112-fix-something` to the `develop` branch
-   1. CI Workflow is automatically triggered, resulting in a pushed docker image tagged with the **branch name** and **PR number**
-3. PR `develop` to the default branch
-   1. CI Workflow is automatically triggered, resulting in a pushed docker image tagged with the **branch name** and **PR number**
+## Release workflow
+
+1. Create a feature branch: `feat/fix-something`
+2. PR `feat/fix-something` to the `develop` branch where the PR is numbered `112`
+   1. Docker image tagged with the **branch name** and **PR number**
+   - ex:
+     - `stacks-blockchain:feat-fix-something`
+     - `stacks-blockchain:pr-112`
+   2. CI tests are run
+3. PR `develop` to the default branch where the PR is numbered `112`
+   1. Docker image tagged with the **branch name** and **PR number**
+   - ex:
+     - `stacks-blockchain:feat-fix-something`
+     - `stacks-blockchain:pr-112`
+   2. CI tests are run
 4. Merge `develop` branch to the default branch
-   1. CI Workflow is triggered, resulting in a pushed docker image tagged with the **default branch name**
+   1. Docker image is tagged with the **default branch** `master`
+   - ex:
+     - `stacks-blockchain:master`
+   2. CI tests are run
 5. CI workflow is manually triggered on **non-default branch** with a version, i.e. `2.1.0.0.0-rc0`
-   1. Github release for the manually input version is created with binaries
-   2. Docker image pushed with tags of the **input version** and **branch**
+   1. No Docker images/binaries are created
+   2. All release tests are run
 6. CI workflow is manually triggered on **default branch** with a version, i.e. `2.1.0.0.0`
    1. Github release for the manually input version is created with binaries
-   2. Docker image pushed with tags of the **input version** and **latest**
+   2. All release tests are run
+   3. Docker image pushed with tags of the **input version** and **latest**
+   - ex:
+   - `stacks-blockchain:2.1.0.0.0-debian`
+   - `stacks-blockchain:latest-debian`
+   - `stacks-blockchain:2.1.0.0.0`
+   - `stacks-blockchain:latest`
+
+## Tests
+
+Tests are separated into several different workflows, with the intention that they can be _conditionally_ run depending upon the triggering operation. For example, on a PR synchronize we don't want to run some identified "slow" tests, but we do want to run the [Stacks Blockchain Tests](../.github/workflows/stacks-blockchain-tests.yml) and [Bitcoin Tests](../.github/workflows/bitcoin-tests.yml).
+
+There are also 2 different methods in use with regard to running tests:
+
+1. [Github Actions matrix](https://docs.github.com/en/actions/using-jobs/using-a-matrix-for-your-jobs)
+2. [nextest partitioning](https://nexte.st/book/partitioning.html)
 
-## PR a branch to develop:
+A matrix is used when there are several known tests that need to be run. Partitions (shards) are used when there is a large and unknown number of tests to run (ex: `cargo test` to run all tests).
 
-ex: Branch is named `feat/112-fix-something` and the PR is numbered `112`
+There is also a workflow designed to run tests that are manually triggered: [Standalone Tests](../.github/workflows/standalone-tests.yml).
+This workflow requires you to select which test(s) you want to run, which then triggers a reusbale workflow via conditional. For example, selecting "Epoch Tests" will run the tests defined in [Epoch Tests](../.github/workflows/epoch-tests.yml). Likewise, selecting `Release Tests` will run the same tests as a release workflow.
 
-- Steps executed:
-  - Rust Format
-  - Integration Tests
-  - Leaked credential test
-  - Docker image is built from source on a debian distribution and pushed with the branch name and PR number as tags
-  - ex:
-    - `stacks-blockchain:feat-112-fix-something`
-    - `stacks-blockchain:pr-112`
-- Steps _not_ executed:
-  - No binaries are built
-  - No github release
-  - No docker images built from binary artifacts
+Files:
 
-## Merging a branch to develop:
+- [Standalone Tests](../.github/workflows/standalone-tests.yml)
+- [Stacks Blockchain Tests](../.github/workflows/stacks-blockchain-tests.yml)
+- [Bitcoin Tests](../.github/workflows/bitcoin-tests.yml)
+- [Atlas Tests](../.github/workflows/atlas-tests.yml)
+- [Epoch Tests](../.github/workflows/epoch-tests.yml)
+- [Slow Tests](../.github/workflows/slow-tests.yml)
+
+## Triggering a workflow
+
+### PR a branch to develop
+
+ex: Branch is named `feat/fix-something` and the PR is numbered `112`
+
+- [Rust format](../.github/workflows/ci.yml)
+- [Create Test Cache](../.github/workflows/create-cache.yml)
+- [Stacks Blockchain Tests](../.github/workflows/stacks-blockchain-tests.yml)
+- [Bitcoin Tests](../.github/workflows/bitcoin-tests.yml)
+- [Docker image](../.github/workflows/image-build-source.yml) is built from source on a debian distribution and pushed with the branch name and PR number as tags
+- ex:
+  - `stacks-blockchain:feat-fix-something`
+  - `stacks-blockchain:pr-112`
+
+---
+
+### Merging a branch to develop
 
 Nothing is triggered automatically
 
-## PR develop to master branches:
+---
+
+### PR develop to master branches
 
 ex: Branch is named `develop` and the PR is numbered `113`
 
-- Steps executed:
-  - Rust format
-  - Integration tests
-  - Leaked credential test
-  - Docker image is built from source on a debian distribution and pushed with the branch name and PR number as tags
-  - ex:
-    - `stacks-blockchain:develop`
-    - `stacks-blockchain:pr-113`
-- Steps _not_ executed:
-  - No binaries are built
-  - No github release
-  - No docker images built from binary artifacts
-
-## Merging a PR from develop to master:
-
-- Steps executed:
-  - Rust format
-  - Integration tests
-  - Leaked credential test
-  - Docker image is built from source on a debian distribution and pushed with the branch name as a tag
-  - ex:
-    - `stacks-blockchain:master`
-- Steps _not_ executed:
-  - No binaries are built
-  - No github release
-  - No docker images built from binary artifacts
-
-## Manually triggering workflow without tag (any branch):
-
-- Steps executed:
-  - Rust format
-  - Integration tests
-  - Leaked credential test
-  - Docker image is built from source on a debian distribution and pushed with the branch name as a tag
-  - ex:
-    - `stacks-blockchain:<branch name>`
-- Steps _not_ executed:
-  - No binaries are built
-  - No github release
-  - No docker images built from binary artifacts
-
-## Manually triggering workflow with tag on a non-default branch (i.e. tag of `2.1.0.0.0-rc0`):
-
-- Steps executed:
-  - Rust format
-  - Integration tests
-  - Leaked credential test
-  - Binaries built for specified architectures
-    - Archive and checksum files added to github release
-  - Github release (with artifacts/checksum) is created using the manually input tag
-  - Docker image built from binaries on debian/alpine distributions and pushed with the provided input tag and `latest`
-  - ex:
-    - `stacks-blockchain:2.1.0.0.0-rc0`
-- Steps _not_ executed:
-  - No docker images built from source
-
-## Manually triggering workflow with tag on default branch (i.e. tag of `2.1.0.0.0`):
-
-- Steps executed:
-  - Rust format
-  - Integration tests
-  - Leaked credential test
-  - Binaries built for specified architectures
-    - Archive and checksum files added to github release
-  - Github release (with artifacts/checksum) is created using the manually input tag
-  - Docker image built from binaries on debian/alpine distributions and pushed with the provided input tag and `latest`
-  - ex:
-    - `stacks-blockchain:2.1.0.0.0-debian`
-    - `stacks-blockchain:latest-debian`
-    - `stacks-blockchain:2.1.0.0.0`
-    - `stacks-blockchain:latest`
-- Steps _not_ executed:
-  - No docker images built from source
+- [Rust format](../.github/workflows/ci.yml)
+- [Create Test Cache](../.github/workflows/create-cache.yml)
+- [Stacks Blockchain Tests](../.github/workflows/stacks-blockchain-tests.yml)
+- [Bitcoin Tests](../.github/workflows/bitcoin-tests.yml)
+- [Docker image](../.github/workflows/image-build-source.yml) is built from source on a debian distribution and pushed with the branch name and PR number as tags
+- ex:
+  - `stacks-blockchain:develop`
+  - `stacks-blockchain:pr-113`
+
+---
+
+### Merging a PR from develop to master
+
+- [Rust format](../.github/workflows/ci.yml)
+- [Create Test Cache](../.github/workflows/create-cache.yml)
+- [Stacks Blockchain Tests](../.github/workflows/stacks-blockchain-tests.yml)
+- [Bitcoin Tests](../.github/workflows/bitcoin-tests.yml)
+- [Docker image](../.github/workflows/image-build-source.yml) is built from source on a debian distribution and pushed with the branch name as a tag
+- ex:
+  - `stacks-blockchain:master`
+
+---
+
+### Manually triggering workflow without tag (any branch)
+
+- [Rust format](../.github/workflows/ci.yml)
+- [Create Test Cache](../.github/workflows/create-cache.yml)
+- [Stacks Blockchain Tests](../.github/workflows/stacks-blockchain-tests.yml)
+- [Bitcoin Tests](../.github/workflows/bitcoin-tests.yml)
+- [Docker image](../.github/workflows/image-build-source.yml) is built from source on a debian distribution and pushed with the branch name as a tag
+- ex:
+  - `stacks-blockchain:<branch name>`
+
+---
+
+### Manually triggering workflow with tag on a non-default branch (i.e. tag of `2.1.0.0.0-rc0`)
+
+- [Rust format](../.github/workflows/ci.yml)
+- [Create Test Cache](../.github/workflows/create-cache.yml)
+- [Stacks Blockchain Tests](../.github/workflows/stacks-blockchain-tests.yml)
+- [Bitcoin Tests](../.github/workflows/bitcoin-tests.yml)
+- [Atlas Tests](../.github/workflows/atlas-tests.yml)
+- [Epoch Tests](../.github/workflows/epoch-tests.yml)
+- [Slow Tests](../.github/workflows/slow-tests.yml)
+
+---
+
+### Manually triggering workflow with tag on default branch (i.e. tag of `2.1.0.0.0`)
+
+- [Rust format](../.github/workflows/ci.yml)
+- [Create Test Cache](../.github/workflows/create-cache.yml)
+- [Stacks Blockchain Tests](../.github/workflows/stacks-blockchain-tests.yml)
+- [Bitcoin Tests](../.github/workflows/bitcoin-tests.yml)
+- [Atlas Tests](../.github/workflows/atlas-tests.yml)
+- [Epoch Tests](../.github/workflows/epoch-tests.yml)
+- [Slow Tests](../.github/workflows/slow-tests.yml)
+- [Binaries built for specified architectures](../.github/workflows/create-source-binary.yml)
+  - Archive and checksum files added to github release
+- [Github release](../.github/workflows/github-release.yml) (with artifacts/checksum) is created using the manually input tag
+- [Docker image](../.github/workflows/image-build-binary.yml) built from binaries on debian/alpine distributions and pushed with the provided input tag and `latest`
+- ex:
+  - `stacks-blockchain:2.1.0.0.0-debian`
+  - `stacks-blockchain:latest-debian`
+  - `stacks-blockchain:2.1.0.0.0`
+  - `stacks-blockchain:latest`
+
+---

From 478b8dab8950896580cf6490f1f3340a74ef4f55 Mon Sep 17 00:00:00 2001
From: wileyj <2847772+wileyj@users.noreply.github.com>
Date: Sun, 19 Nov 2023 22:37:55 -0800
Subject: [PATCH 0090/1166] (3847) - Adding new workflow files

---
 .github/workflows/atlas-tests.yml          |  61 +++++++++++
 .github/workflows/create-cache.yml         |  63 +++++++++++
 .github/workflows/create-source-binary.yml |  74 +++++++++++++
 .github/workflows/epoch-tests.yml          |  85 +++++++++++++++
 .github/workflows/image-build-binary.yml   |  92 +++++++++++++++++
 .github/workflows/image-build-source.yml   |  69 +++++++++++++
 .github/workflows/slow-tests.yml           |  63 +++++++++++
 .github/workflows/standalone-tests.yml     | 115 +++++++++++++++++++++
 .github/workflows/workflow-cleanup.yml     |  47 +++++++++
 9 files changed, 669 insertions(+)
 create mode 100644 .github/workflows/atlas-tests.yml
 create mode 100644 .github/workflows/create-cache.yml
 create mode 100644 .github/workflows/create-source-binary.yml
 create mode 100644 .github/workflows/epoch-tests.yml
 create mode 100644 .github/workflows/image-build-binary.yml
 create mode 100644 .github/workflows/image-build-source.yml
 create mode 100644 .github/workflows/slow-tests.yml
 create mode 100644 .github/workflows/standalone-tests.yml
 create mode 100644 .github/workflows/workflow-cleanup.yml

diff --git a/.github/workflows/atlas-tests.yml b/.github/workflows/atlas-tests.yml
new file mode 100644
index 0000000000..21da3c830d
--- /dev/null
+++ b/.github/workflows/atlas-tests.yml
@@ -0,0 +1,61 @@
+## Github workflow to run atlas tests
+
+name: Tests::Atlas
+
+on:
+  workflow_call:
+
+defaults:
+  run:
+    shell: bash
+
+## env vars are transferred to composite action steps
+env:
+  BITCOIND_TEST: 1
+  RUST_BACKTRACE: full
+  SEGMENT_DOWNLOAD_TIMEOUT_MINS: 15
+  RETRIES: 3
+  RETRY_DELAY: 10000
+  TEST_TIMEOUT: 30
+  TEST_RETRIES: 2
+
+concurrency:
+  group: atlas-tests-${{ github.head_ref || github.ref || github.run_id}}
+  ## Only cancel in progress if this is for a PR
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
+jobs:
+  # Atlas integration tests with code coverage
+  atlas-tests:
+    name: Atlas Test
+    runs-on: ubuntu-latest
+    strategy:
+      ## Continue with the test matrix even if we've had a failure
+      fail-fast: false
+      ## Run a maximum of 2 concurrent tests from the test matrix
+      max-parallel: 2
+      matrix:
+        test-name:
+          - tests::neon_integrations::atlas_integration_test
+          - tests::neon_integrations::atlas_stress_integration_test
+    steps:
+      ## Setup test environment
+      - name: Setup Test Environment
+        id: setup_tests
+        uses: stacks-network/actions/stacks-core/testenv@main
+
+      ## Run test matrix using restored cache of archive file
+      ##   - Test will timeout after env.TEST_TIMEOUT minutes
+      - name: Run Tests
+        id: run_tests
+        timeout-minutes: ${{ fromJSON(env.TEST_TIMEOUT) }}
+        uses: stacks-network/actions/stacks-core/run-tests@main
+        with:
+          test-name: ${{ matrix.test-name }}
+
+      ## Create and upload code coverage file
+      - name: Code Coverage
+        id: codecov
+        uses: stacks-network/actions/codecov@main
+        with:
+          test-name: ${{ matrix.test-name }}
diff --git a/.github/workflows/create-cache.yml b/.github/workflows/create-cache.yml
new file mode 100644
index 0000000000..8bb736dd0f
--- /dev/null
+++ b/.github/workflows/create-cache.yml
@@ -0,0 +1,63 @@
+## Github workflow to create reusable caches
+
+name: Create Test Cache
+
+on:
+  workflow_dispatch:
+  workflow_call:
+
+defaults:
+  run:
+    shell: bash
+
+## env vars are transferred to composite action steps
+env:
+  RUSTFLAGS: "-Cinstrument-coverage -Awarnings"
+  LLVM_PROFILE_FILE: "stacks-blockchain-%p-%m.profraw"
+  BTC_VERSION: "0.20.0"
+
+##
+## Cache will exist longer than workflow execution so other runners have access
+##   ex: a failed job should have access to the cache for however long `cleanup.yml` is set to delete old caches
+##       however, this is only relevant if the commit sha does not change between runs
+concurrency:
+  group: create-cache-${{ github.head_ref || github.ref || github.run_id}}
+  ## Only cancel in progress if this is for a PR
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
+jobs:
+  ## Cache cargo data
+  cargo:
+    name: Cargo
+    runs-on: ubuntu-latest
+    steps:
+      ## Perform a lookup to check if the cache already exists
+      - name: Cargo Cache
+        id: cargo-cache
+        uses: stacks-network/actions/stacks-core/cache/cargo@main
+        with:
+          action: save
+
+  ## Cache the bitcoin binary
+  bitcoin-binary:
+    name: Bitcoin Binary
+    runs-on: ubuntu-latest
+    steps:
+      - name: Bitcoin Cache
+        id: bitcoin-cache
+        uses: stacks-network/actions/stacks-core/cache/bitcoin@main
+        with:
+          action: save
+
+  ## Cache nextest archives for tests
+  nextest-archive:
+    name: Test Archive
+    runs-on: ubuntu-latest
+    needs:
+      - cargo
+    steps:
+      - name: Build Nexttest Cache
+        id: nextest-cache
+        uses: stacks-network/actions/stacks-core/cache/build-cache@main
+        with:
+          genesis: true
diff --git a/.github/workflows/create-source-binary.yml b/.github/workflows/create-source-binary.yml
new file mode 100644
index 0000000000..a6e70756e3
--- /dev/null
+++ b/.github/workflows/create-source-binary.yml
@@ -0,0 +1,74 @@
+## Github workflow to create multiarch binaries from source
+
+name: Create Binaries
+
+on:
+  workflow_call:
+    inputs:
+      tag:
+        description: "Tag name of this release (x.y.z)"
+        required: true
+        type: string
+      arch:
+        description: "Stringified JSON object listing of platform matrix"
+        required: false
+        type: string
+        default: >-
+          ["linux-glibc-x64", "linux-musl-x64", "linux-glibc-arm64", "linux-glibc-armv7", "linux-musl-arm64", "linux-musl-armv7", "macos-x64", "macos-arm64", "windows-x64"]
+
+defaults:
+  run:
+    shell: bash
+
+## change the display name to the tag being built
+run-name: ${{ inputs.tag }}
+
+concurrency:
+  group: create-binary-${{ github.head_ref || github.ref || github.run_id}}
+  ## Only cancel in progress if this is for a PR
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
+jobs:
+  ## Runs when the following is true:
+  ##  - tag is provided
+  ##  - workflow is building default branch (master)
+  artifact:
+    if: |
+      inputs.tag != '' && 
+      github.ref == format('refs/heads/{0}', github.event.repository.default_branch)
+    name: Build Binaries
+    runs-on: ubuntu-latest
+    strategy:
+      ## Run a maximum of 10 builds concurrently, using the matrix defined in inputs.arch
+      max-parallel: 10
+      matrix:
+        platform: ${{ fromJson(inputs.arch) }}
+    steps:
+      ## Setup Docker for the builds
+      - name: Docker setup
+        uses: stacks-network/actions/docker@main
+
+      ## Build the binaries using defined dockerfiles
+      - name: Build Binary (${{ matrix.platform }})
+        id: build_binaries
+        uses: docker/build-push-action@0565240e2d4ab88bba5387d719585280857ece09 # 5.0.0
+        with:
+          file: build-scripts/Dockerfile.${{ matrix.platform }}
+          outputs: type=local,dest=./release/${{ matrix.platform }}
+          build-args: |
+            STACKS_NODE_VERSION=${{ inputs.tag || env.GITHUB_SHA_SHORT }}
+            OS_ARCH=${{ matrix.platform }}
+            GIT_BRANCH=${{ env.GITHUB_REF_SHORT }}
+            GIT_COMMIT=${{ env.GITHUB_SHA_SHORT }}
+
+      ## Compress the binary artifact
+      - name: Compress artifact
+        id: compress_artifact
+        run: zip --junk-paths ${{ matrix.platform }} ./release/${{ matrix.platform }}/*
+
+      ## Upload the binary artifact to the github action (used in `github-release.yml` to create a release)
+      - name: Upload artifact
+        id: upload_artifact
+        uses: actions/upload-artifact@a8a3f3ad30e3422c9c7b888a15615d19a852ae32 # v3.1.3
+        with:
+          path: ${{ matrix.platform }}.zip
diff --git a/.github/workflows/epoch-tests.yml b/.github/workflows/epoch-tests.yml
new file mode 100644
index 0000000000..a46d1520c3
--- /dev/null
+++ b/.github/workflows/epoch-tests.yml
@@ -0,0 +1,85 @@
+## Github workflow to run epoch tests
+
+name: Tests::Epoch
+
+on:
+  workflow_call:
+
+defaults:
+  run:
+    shell: bash
+
+## env vars are transferred to composite action steps
+env:
+  BITCOIND_TEST: 1
+  RUST_BACKTRACE: full
+  SEGMENT_DOWNLOAD_TIMEOUT_MINS: 15
+  RETRIES: 3
+  RETRY_DELAY: 10000
+  TEST_TIMEOUT: 30
+  TEST_RETRIES: 2
+
+concurrency:
+  group: epoch-tests-${{ github.head_ref || github.ref || github.run_id }}
+  ## Only cancel in progress if this is for a PR
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
+jobs:
+  # Epoch integration tests with code coverage
+  epoch-tests:
+    name: Epoch Tests
+    runs-on: ubuntu-latest
+    strategy:
+      ## Continue with the test matrix even if we've had a failure
+      fail-fast: false
+      ## Run a maximum of 32 concurrent tests from the test matrix
+      max-parallel: 32
+      matrix:
+        test-name:
+          - tests::epoch_205::bigger_microblock_streams_in_2_05
+          - tests::epoch_205::test_cost_limit_switch_version205
+          - tests::epoch_205::test_dynamic_db_method_costs
+          - tests::epoch_205::test_exact_block_costs
+          - tests::epoch_205::transition_empty_blocks
+          - tests::epoch_21::test_pox_missing_five_anchor_blocks
+          - tests::epoch_21::test_pox_reorg_one_flap
+          - tests::epoch_21::test_pox_reorgs_three_flaps
+          - tests::epoch_21::test_sortition_divergence_pre_21
+          - tests::epoch_21::test_v1_unlock_height_with_current_stackers
+          - tests::epoch_21::test_v1_unlock_height_with_delay_and_current_stackers
+          - tests::epoch_21::trait_invocation_cross_epoch
+          - tests::epoch_21::transition_adds_burn_block_height
+          - tests::epoch_21::transition_adds_get_pox_addr_recipients
+          - tests::epoch_21::transition_adds_mining_from_segwit
+          - tests::epoch_21::transition_adds_pay_to_contract
+          - tests::epoch_21::transition_empty_blocks
+          - tests::epoch_21::transition_fixes_bitcoin_rigidity
+          - tests::epoch_21::transition_removes_pox_sunset
+          - tests::epoch_22::disable_pox
+          - tests::epoch_22::pox_2_unlock_all
+          - tests::epoch_22::test_pox_reorg_one_flap
+          - tests::epoch_23::trait_invocation_behavior
+          - tests::epoch_24::fix_to_pox_contract
+          - tests::epoch_24::verify_auto_unlock_behavior
+    steps:
+      ## Setup test environment
+      - name: Setup Test Environment
+        id: setup_tests
+        uses: stacks-network/actions/stacks-core/testenv@main
+
+      ## Run test matrix using restored cache of archive file
+      ##   - Test will timeout after env.TEST_TIMEOUT minutes
+      - name: Run Tests
+        id: run_tests
+        timeout-minutes: ${{ fromJSON(env.TEST_TIMEOUT) }}
+        uses: stacks-network/actions/stacks-core/run-tests@main
+        with:
+          test-name: ${{ matrix.test-name }}
+          threads: 1
+
+      ## Create and upload code coverage file
+      - name: Code Coverage
+        id: codecov
+        uses: stacks-network/actions/codecov@main
+        with:
+          test-name: ${{ matrix.test-name }}
diff --git a/.github/workflows/image-build-binary.yml b/.github/workflows/image-build-binary.yml
new file mode 100644
index 0000000000..291a607570
--- /dev/null
+++ b/.github/workflows/image-build-binary.yml
@@ -0,0 +1,92 @@
+## Github workflow to build a multiarch docker image from pre-built binaries
+
+name: Docker Image (Binary)
+
+on:
+  workflow_call:
+    inputs:
+      tag:
+        required: true
+        type: string
+        description: "Version tag for alpine images"
+      docker-org:
+        required: false
+        type: string
+        description: "Docker repo org for uploading images (defaults to github org)"
+        default: "${GITHUB_REPOSITORY_OWNER}"
+
+defaults:
+  run:
+    shell: bash
+
+## Define which docker arch to build for
+env:
+  docker_platforms: "linux/arm64, linux/arm/v7, linux/amd64, linux/amd64/v2, linux/amd64/v3"
+  docker-org: ${{ github.repository_owner }}
+
+concurrency:
+  group: docker-image-binary-${{ github.head_ref || github.ref || github.run_id }}
+  ## Always cancel duplicate jobs
+  cancel-in-progress: true
+
+run-name: ${{ inputs.tag }}
+
+jobs:
+  ## Runs when the following is true:
+  ##  - tag is provided
+  ##  - workflow is building default branch (master)
+  image:
+    if: |
+      inputs.tag != '' && 
+      github.ref == format('refs/heads/{0}', github.event.repository.default_branch)
+    name: Build Image
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      ## Build a maximum of 2 images concurrently based on matrix.dist
+      max-parallel: 2
+      matrix:
+        dist:
+          - alpine
+          - debian
+    steps:
+      ## Setup Docker for the builds
+      - name: Docker setup
+        uses: stacks-network/actions/docker@main
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_PASSWORD }}
+
+      ## Set docker metatdata
+      ## - depending on the matrix.dist, different tags will be enabled
+      ## ex. alpine will have this tag: `type=ref,event=tag,enable=${{ matrix.dist == 'alpine' }}`
+      - name: Docker Metadata ( ${{matrix.dist}} )
+        id: docker_metadata
+        uses: docker/metadata-action@96383f45573cb7f253c731d3b3ab81c87ef81934 #v5.0.0
+        with:
+          images: |
+            ${{env.docker-org}}/${{ github.event.repository.name }}
+            ${{env.docker-org}}/stacks-core
+          tags: |
+            type=raw,value=latest,enable=${{ inputs.tag != '' && (github.ref == format('refs/heads/{0}', github.event.repository.default_branch) ) && matrix.dist == 'alpine' }}
+            type=raw,value=${{ inputs.tag }}-${{ matrix.dist }},enable=${{ inputs.tag != '' && matrix.dist == 'alpine'}}
+            type=raw,value=${{ inputs.tag }},enable=${{ inputs.tag != '' && matrix.dist == 'alpine' }}
+            type=ref,event=tag,enable=${{ matrix.dist == 'alpine' }}
+            type=raw,value=latest-${{ matrix.dist }},enable=${{ inputs.tag != '' && (github.ref == format('refs/heads/{0}', github.event.repository.default_branch) ) && matrix.dist == 'debian' }}
+            type=raw,value=${{ inputs.tag }}-${{ matrix.dist }},enable=${{ inputs.tag != '' && matrix.dist == 'debian' }}
+
+      ## Build docker image for release
+      - name: Build and Push ( ${{matrix.dist}} )
+        id: docker_build
+        uses: docker/build-push-action@0565240e2d4ab88bba5387d719585280857ece09 # v5.0.0
+        with:
+          file: ./.github/actions/dockerfiles/Dockerfile.${{ matrix.dist }}-binary
+          platforms: ${{ env.docker_platforms }}
+          tags: ${{ steps.docker_metadata.outputs.tags }}
+          labels: ${{ steps.docker_metadata.outputs.labels }}
+          build-args: |
+            REPO=${{ github.repository_owner }}/${{ github.event.repository.name }}
+            STACKS_NODE_VERSION=${{ inputs.tag || env.GITHUB_SHA_SHORT }}
+            GIT_BRANCH=${{ env.GITHUB_REF_SHORT }}
+            GIT_COMMIT=${{ env.GITHUB_SHA_SHORT }}
+          push: ${{ env.DOCKER_PUSH }}
diff --git a/.github/workflows/image-build-source.yml b/.github/workflows/image-build-source.yml
new file mode 100644
index 0000000000..d126336dad
--- /dev/null
+++ b/.github/workflows/image-build-source.yml
@@ -0,0 +1,69 @@
+## Github workflow to build a docker image from source
+
+name: Docker Image (Source)
+
+on:
+  workflow_dispatch:
+  workflow_call:
+
+defaults:
+  run:
+    shell: bash
+
+## Define which docker arch to build for
+env:
+  docker_platforms: linux/amd64
+  docker-org: ${{ github.repository_owner }}
+
+concurrency:
+  group: docker-image-source-${{ github.head_ref || github.ref || github.run_id }}
+  ## Always cancel duplicate jobs
+  cancel-in-progress: true
+
+jobs:
+  ## Runs anytime `ci.yml` runs or when manually called
+  image:
+    name: Build Image
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      ## Build a maximum of 2 images concurrently based on matrix.dist
+      max-parallel: 2
+      matrix:
+        dist:
+          - debian
+    steps:
+      ## Setup Docker for the builds
+      - name: Docker setup
+        uses: stacks-network/actions/docker@main
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_PASSWORD }}
+
+      ## Set docker metatdata
+      - name: Docker Metadata ( ${{matrix.dist}} )
+        id: docker_metadata
+        uses: docker/metadata-action@96383f45573cb7f253c731d3b3ab81c87ef81934 #v5.0.0
+        with:
+          images: |
+            ${{env.docker-org}}/${{ github.event.repository.name }}
+            ${{env.docker-org}}/stacks-core
+          tags: |
+            type=raw,value=${{ env.BRANCH_NAME }}
+            type=ref,event=pr
+
+      ## Build docker image
+      - name: Build and Push ( ${{matrix.dist}} )
+        id: docker_build
+        uses: docker/build-push-action@0565240e2d4ab88bba5387d719585280857ece09 # v5.0.0
+        with:
+          file: ./.github/actions/dockerfiles/Dockerfile.${{matrix.dist}}-source
+          platforms: ${{ env.docker_platforms }}
+          tags: ${{ steps.docker_metadata.outputs.tags }}
+          labels: ${{ steps.docker_metadata.outputs.labels }}
+          build-args: |
+            REPO=${{ github.repository_owner }}/${{ github.event.repository.name }}
+            STACKS_NODE_VERSION=${{ env.GITHUB_SHA_SHORT }}
+            GIT_BRANCH=${{ env.GITHUB_REF_SHORT }}
+            GIT_COMMIT=${{ env.GITHUB_SHA_SHORT }}
+          push: ${{ env.DOCKER_PUSH }}
diff --git a/.github/workflows/slow-tests.yml b/.github/workflows/slow-tests.yml
new file mode 100644
index 0000000000..edc53713e6
--- /dev/null
+++ b/.github/workflows/slow-tests.yml
@@ -0,0 +1,63 @@
+## Github workflow to run slow tests
+
+name: Tests::Slow
+
+on:
+  workflow_call:
+
+defaults:
+  run:
+    shell: bash
+
+## env vars are transferred to composite action steps
+env:
+  BITCOIND_TEST: 1
+  RUST_BACKTRACE: full
+  SEGMENT_DOWNLOAD_TIMEOUT_MINS: 15
+  RETRIES: 3
+  RETRY_DELAY: 10000
+  TEST_TIMEOUT: 30
+  TEST_RETRIES: 2
+
+concurrency:
+  group: slow-tests-${{ github.head_ref || github.ref || github.run_id }}
+  ## Only cancel in progress if this is for a PR
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
+jobs:
+  # Slow integration tests with code coverage
+  slow-tests:
+    name: Slow Tests
+    runs-on: ubuntu-latest
+    strategy:
+      ## Continue with the test matrix even if we've had a failure
+      fail-fast: false
+      ## Run a maximum of 2 concurrent tests from the test matrix
+      max-parallel: 2
+      matrix:
+        ## Each of these tests should take ~20 minutes if they are successful
+        test-name:
+          - tests::epoch_21::test_pox_reorg_flap_duel
+          - tests::epoch_21::test_pox_reorg_flap_reward_cycles
+    steps:
+      ## Setup test environment
+      - name: Setup Test Environment
+        id: setup_tests
+        uses: stacks-network/actions/stacks-core/testenv@main
+
+      ## Run test matrix using restored cache of archive file
+      ##   - Test will timeout after env.TEST_TIMEOUT minutes
+      - name: Run Tests
+        id: run_tests
+        timeout-minutes: ${{ fromJSON(env.TEST_TIMEOUT) }}
+        uses: stacks-network/actions/stacks-core/run-tests@main
+        with:
+          test-name: ${{ matrix.test-name }}
+          threads: 1
+
+      ## Create and upload code coverage file
+      - name: Code Coverage
+        id: codecov
+        uses: stacks-network/actions/codecov@main
+        with:
+          test-name: ${{ matrix.test-name }}
diff --git a/.github/workflows/standalone-tests.yml b/.github/workflows/standalone-tests.yml
new file mode 100644
index 0000000000..458ea4c5e3
--- /dev/null
+++ b/.github/workflows/standalone-tests.yml
@@ -0,0 +1,115 @@
+## Github workflow to run specified tests on demand
+
+name: Standalone Tests
+
+on:
+  workflow_call:
+    inputs:
+      workflow:
+        description: "Tests to run (required)"
+        required: true
+        type: string
+  workflow_dispatch:
+    inputs:
+      workflow:
+        description: "Tests to run (required)"
+        required: true
+        type: choice
+        options:
+          - Release Tests
+          - CI Tests
+          - Atlas Tests
+          - Bitcoin Tests
+          - Epoch Tests
+          - Slow Tests
+          - Stacks-Blockchain Tests
+
+## Set the display name to the test being run
+run-name: ${{ inputs.workflow }}
+
+jobs:
+  ## Runs every time to either create the required caches or confirm they already exist
+  create-cache:
+    name: Create Test Cache
+    uses: ./.github/workflows/create-cache.yml
+
+  #####################################################
+  ## Runs when:
+  ##   either or of the following:
+  ##     - workflow is 'Release Tests'
+  ##     - workflow is 'CI Tests'
+  ##     - workflow is 'Stacks-Blockchain Tests'
+  stacks-blockchain-tests:
+    if: |
+      (
+        inputs.workflow == 'Release Tests' ||
+        inputs.workflow == 'CI Tests' ||
+        inputs.workflow == 'Stacks-Blockchain Tests'
+      )
+    name: Stacks Blockchain Tests
+    needs:
+      - create-cache
+    uses: ./.github/workflows/stacks-blockchain-tests.yml
+
+  ## Runs when:
+  ##   either or of the following:
+  ##     - workflow is 'Release Tests'
+  ##     - workflow is 'CI Tests'
+  ##     - workflow is 'Bitcoin Tests'
+  bitcoin-tests:
+    if: |
+      (
+        inputs.workflow == 'Release Tests' ||
+        inputs.workflow == 'CI Tests' ||
+        inputs.workflow == 'Bitcoin Tests'
+      )
+    name: Bitcoin Tests
+    needs:
+      - create-cache
+    uses: ./.github/workflows/bitcoin-tests.yml
+
+  #####################################################
+  ## Runs when:
+  ##   either or of the following:
+  ##     - workflow is 'Release Tests'
+  ##     - workflow is 'Atlas Tests'
+  atlas-tests:
+    if: |
+      (
+        inputs.workflow == 'Release Tests' ||
+        inputs.workflow == 'Atlas Tests' 
+      )
+    name: Atlas Tests
+    needs:
+      - create-cache
+    uses: ./.github/workflows/atlas-tests.yml
+
+  ## Runs when:
+  ##   either or of the following:
+  ##     - workflow is 'Release Tests'
+  ##     - workflow is 'Epoch Tests'
+  epoch-tests:
+    if: |
+      (
+        inputs.workflow == 'Release Tests' ||
+        inputs.workflow == 'Epoch Tests'
+      )
+    name: Epoch Tests
+    needs:
+      - create-cache
+    uses: ./.github/workflows/epoch-tests.yml
+
+  ## Runs when:
+  ##   either or of the following:
+  ##     - workflow is 'Release Tests'
+  ##     - workflow is 'Slow Tests'
+  slow-tests:
+    if: |
+      (
+        inputs.workflow == 'Release Tests' ||
+        inputs.workflow == 'Slow Tests'
+      )
+    name: Slow Tests
+    needs:
+      - create-cache
+    uses: ./.github/workflows/slow-tests.yml
diff --git a/.github/workflows/workflow-cleanup.yml b/.github/workflows/workflow-cleanup.yml
new file mode 100644
index 0000000000..e9d79305da
--- /dev/null
+++ b/.github/workflows/workflow-cleanup.yml
@@ -0,0 +1,47 @@
+## Github workflow to clean up old caches and workflow runs
+
+name: Workflow Cleanup
+
+on:
+  workflow_dispatch:
+    inputs:
+      cache-ttl:
+        description: "How many days to keep a cache (default: 7)"
+        required: false
+        default: "7"
+      workflow-ttl:
+        description: "How many days to keep a successful workflow (default: 30)"
+        required: false
+        default: "30"
+      failed-workflow-ttl:
+        description: "How many days to keep failed workflows (default: 15)"
+        required: false
+        default: "15"
+  schedule:
+    ## Run every day at 00:00:00
+    - cron: "0 0 * * *"
+
+## env vars are transferred to composite action steps
+env:
+  CACHE_TTL: 7 ## number of days to keep a cache
+  WORKFLOW_TTL: 30 ## number of days to keep a successful workflow
+  FAILED_WORKFLOW_TTL: 15 ## number of days to keep a failed workflow
+
+concurrency:
+  group: cleanup-${{ github.head_ref || github.ref }}
+  ## Always cancel duplicate jobs
+  cancel-in-progress: true
+
+jobs:
+  workflow-cleanup:
+    name: Workflow Cleanup
+    runs-on: ubuntu-latest
+    steps:
+      - name: Cleanup
+        id: cleanup
+        uses: stacks-network/actions/cleanup/workflows@main
+        with:
+          token: ${{ secrets.GH_TOKEN }}
+          cache-ttl: ${{ inputs.cache-ttl || env.CACHE_TTL}}
+          workflow-ttl: ${{ inputs.workflow-ttl || env.WORKFLOW_TTL}}
+          failed-workflow-ttl: ${{ inputs.failed-workflow-ttl || env.FAILED_WORKFLOW_TTL }}

From 6f6d1ab5cc044caa880b32856e84602ebe63b8bb Mon Sep 17 00:00:00 2001
From: wileyj <2847772+wileyj@users.noreply.github.com>
Date: Mon, 20 Nov 2023 12:02:07 -0800
Subject: [PATCH 0091/1166] set docker repo name and add tag arg for build

---
 .github/workflows/image-build-binary.yml | 3 ++-
 .github/workflows/image-build-source.yml | 2 +-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/image-build-binary.yml b/.github/workflows/image-build-binary.yml
index 291a607570..a821531dc5 100644
--- a/.github/workflows/image-build-binary.yml
+++ b/.github/workflows/image-build-binary.yml
@@ -22,7 +22,7 @@ defaults:
 ## Define which docker arch to build for
 env:
   docker_platforms: "linux/arm64, linux/arm/v7, linux/amd64, linux/amd64/v2, linux/amd64/v3"
-  docker-org: ${{ github.repository_owner }}
+  docker-org: blockstack
 
 concurrency:
   group: docker-image-binary-${{ github.head_ref || github.ref || github.run_id }}
@@ -85,6 +85,7 @@ jobs:
           tags: ${{ steps.docker_metadata.outputs.tags }}
           labels: ${{ steps.docker_metadata.outputs.labels }}
           build-args: |
+            TAG=${{ inputs.tag }}
             REPO=${{ github.repository_owner }}/${{ github.event.repository.name }}
             STACKS_NODE_VERSION=${{ inputs.tag || env.GITHUB_SHA_SHORT }}
             GIT_BRANCH=${{ env.GITHUB_REF_SHORT }}
diff --git a/.github/workflows/image-build-source.yml b/.github/workflows/image-build-source.yml
index d126336dad..79c428073c 100644
--- a/.github/workflows/image-build-source.yml
+++ b/.github/workflows/image-build-source.yml
@@ -13,7 +13,7 @@ defaults:
 ## Define which docker arch to build for
 env:
   docker_platforms: linux/amd64
-  docker-org: ${{ github.repository_owner }}
+  docker-org: blockstack
 
 concurrency:
   group: docker-image-source-${{ github.head_ref || github.ref || github.run_id }}

From 2af76d943741ed7f3b941d9578053ac6c6af9ba9 Mon Sep 17 00:00:00 2001
From: wileyj <2847772+wileyj@users.noreply.github.com>
Date: Wed, 22 Nov 2023 11:35:48 -0800
Subject: [PATCH 0092/1166] Add checks/trigger for next/fix typo

---
 .github/workflows/ci.yml | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 9075172268..60b5d967f8 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -6,6 +6,7 @@ on:
     branches:
       - master
       - develop
+      - next
     paths-ignore:
       - "**.md"
       - "**.yml"
@@ -145,8 +146,9 @@ jobs:
           github.event_name == 'pull_request_target' ||
           (
             contains('
-              refs/heads/develoment
               refs/heads/master
+              refs/heads/develop
+              refs/heads/next
             ', github.event.pull_request.head.ref) &&
             github.event_name == 'push'
           )

From 98f638616f451e5034b38d1a65b508f581177acc Mon Sep 17 00:00:00 2001
From: wileyj <2847772+wileyj@users.noreply.github.com>
Date: Wed, 22 Nov 2023 13:40:39 -0800
Subject: [PATCH 0093/1166] Update docker image name

Co-authored-by: Charlie <2747302+CharlieC3@users.noreply.github.com>
---
 .github/workflows/image-build-binary.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/image-build-binary.yml b/.github/workflows/image-build-binary.yml
index a821531dc5..35c130b557 100644
--- a/.github/workflows/image-build-binary.yml
+++ b/.github/workflows/image-build-binary.yml
@@ -66,7 +66,7 @@ jobs:
         with:
           images: |
             ${{env.docker-org}}/${{ github.event.repository.name }}
-            ${{env.docker-org}}/stacks-core
+            ${{env.docker-org}}/stacks-blockchain
           tags: |
             type=raw,value=latest,enable=${{ inputs.tag != '' && (github.ref == format('refs/heads/{0}', github.event.repository.default_branch) ) && matrix.dist == 'alpine' }}
             type=raw,value=${{ inputs.tag }}-${{ matrix.dist }},enable=${{ inputs.tag != '' && matrix.dist == 'alpine'}}

From ef07100409a6b3665c183de5b241c2a30b65ee8d Mon Sep 17 00:00:00 2001
From: wileyj <2847772+wileyj@users.noreply.github.com>
Date: Wed, 22 Nov 2023 13:48:16 -0800
Subject: [PATCH 0094/1166] spelling error

Co-authored-by: Charlie <2747302+CharlieC3@users.noreply.github.com>
---
 docs/ci-release.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/ci-release.md b/docs/ci-release.md
index 82fe164ec5..6a0bc7e1ca 100644
--- a/docs/ci-release.md
+++ b/docs/ci-release.md
@@ -79,7 +79,7 @@ There are also 2 different methods in use with regard to running tests:
 A matrix is used when there are several known tests that need to be run. Partitions (shards) are used when there is a large and unknown number of tests to run (ex: `cargo test` to run all tests).
 
 There is also a workflow designed to run tests that are manually triggered: [Standalone Tests](../.github/workflows/standalone-tests.yml).
-This workflow requires you to select which test(s) you want to run, which then triggers a reusbale workflow via conditional. For example, selecting "Epoch Tests" will run the tests defined in [Epoch Tests](../.github/workflows/epoch-tests.yml). Likewise, selecting `Release Tests` will run the same tests as a release workflow.
+This workflow requires you to select which test(s) you want to run, which then triggers a reusable workflow via conditional. For example, selecting "Epoch Tests" will run the tests defined in [Epoch Tests](../.github/workflows/epoch-tests.yml). Likewise, selecting `Release Tests` will run the same tests as a release workflow.
 
 Files:
 

From 7702eaa19210789d3dadedeabac233e59488627e Mon Sep 17 00:00:00 2001
From: wileyj <2847772+wileyj@users.noreply.github.com>
Date: Sun, 26 Nov 2023 18:14:10 -0800
Subject: [PATCH 0095/1166] address comments in 4079

---
 .github/workflows/atlas-tests.yml             | 7 -------
 .github/workflows/bitcoin-tests.yml           | 7 -------
 .github/workflows/ci.yml                      | 2 +-
 .github/workflows/create-cache.yml            | 4 ----
 .github/workflows/create-source-binary.yml    | 4 ----
 .github/workflows/epoch-tests.yml             | 7 -------
 .github/workflows/image-build-binary.yml      | 4 ----
 .github/workflows/image-build-source.yml      | 6 +-----
 .github/workflows/slow-tests.yml              | 7 -------
 .github/workflows/stacks-blockchain-tests.yml | 7 -------
 10 files changed, 2 insertions(+), 53 deletions(-)

diff --git a/.github/workflows/atlas-tests.yml b/.github/workflows/atlas-tests.yml
index 21da3c830d..cb9f4a968f 100644
--- a/.github/workflows/atlas-tests.yml
+++ b/.github/workflows/atlas-tests.yml
@@ -5,19 +5,12 @@ name: Tests::Atlas
 on:
   workflow_call:
 
-defaults:
-  run:
-    shell: bash
-
 ## env vars are transferred to composite action steps
 env:
   BITCOIND_TEST: 1
   RUST_BACKTRACE: full
   SEGMENT_DOWNLOAD_TIMEOUT_MINS: 15
-  RETRIES: 3
-  RETRY_DELAY: 10000
   TEST_TIMEOUT: 30
-  TEST_RETRIES: 2
 
 concurrency:
   group: atlas-tests-${{ github.head_ref || github.ref || github.run_id}}
diff --git a/.github/workflows/bitcoin-tests.yml b/.github/workflows/bitcoin-tests.yml
index 48e53915ce..de1b16c26f 100644
--- a/.github/workflows/bitcoin-tests.yml
+++ b/.github/workflows/bitcoin-tests.yml
@@ -5,19 +5,12 @@ name: Tests::Bitcoin
 on:
   workflow_call:
 
-defaults:
-  run:
-    shell: bash
-
 ## env vars are transferred to composite action steps
 env:
   BITCOIND_TEST: 1
   RUST_BACKTRACE: full
   SEGMENT_DOWNLOAD_TIMEOUT_MINS: 15
-  RETRIES: 3
-  RETRY_DELAY: 10000
   TEST_TIMEOUT: 30
-  TEST_RETRIES: 2
 
 concurrency:
   group: bitcoin-tests-${{ github.head_ref || github.ref || github.run_id}}
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 60b5d967f8..d4ae0ce806 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -36,7 +36,7 @@ defaults:
     shell: bash
 
 concurrency:
-  group: ci-${{ github.head_ref || github.ref }}
+  group: ci-${{ github.head_ref || github.ref || github.run_id }}
   ## Always cancel duplicate jobs
   cancel-in-progress: true
 
diff --git a/.github/workflows/create-cache.yml b/.github/workflows/create-cache.yml
index 8bb736dd0f..71e0c02a31 100644
--- a/.github/workflows/create-cache.yml
+++ b/.github/workflows/create-cache.yml
@@ -6,10 +6,6 @@ on:
   workflow_dispatch:
   workflow_call:
 
-defaults:
-  run:
-    shell: bash
-
 ## env vars are transferred to composite action steps
 env:
   RUSTFLAGS: "-Cinstrument-coverage -Awarnings"
diff --git a/.github/workflows/create-source-binary.yml b/.github/workflows/create-source-binary.yml
index a6e70756e3..8e32893f78 100644
--- a/.github/workflows/create-source-binary.yml
+++ b/.github/workflows/create-source-binary.yml
@@ -16,10 +16,6 @@ on:
         default: >-
           ["linux-glibc-x64", "linux-musl-x64", "linux-glibc-arm64", "linux-glibc-armv7", "linux-musl-arm64", "linux-musl-armv7", "macos-x64", "macos-arm64", "windows-x64"]
 
-defaults:
-  run:
-    shell: bash
-
 ## change the display name to the tag being built
 run-name: ${{ inputs.tag }}
 
diff --git a/.github/workflows/epoch-tests.yml b/.github/workflows/epoch-tests.yml
index a46d1520c3..b7d9bd6f06 100644
--- a/.github/workflows/epoch-tests.yml
+++ b/.github/workflows/epoch-tests.yml
@@ -5,19 +5,12 @@ name: Tests::Epoch
 on:
   workflow_call:
 
-defaults:
-  run:
-    shell: bash
-
 ## env vars are transferred to composite action steps
 env:
   BITCOIND_TEST: 1
   RUST_BACKTRACE: full
   SEGMENT_DOWNLOAD_TIMEOUT_MINS: 15
-  RETRIES: 3
-  RETRY_DELAY: 10000
   TEST_TIMEOUT: 30
-  TEST_RETRIES: 2
 
 concurrency:
   group: epoch-tests-${{ github.head_ref || github.ref || github.run_id }}
diff --git a/.github/workflows/image-build-binary.yml b/.github/workflows/image-build-binary.yml
index 35c130b557..cab5ff162b 100644
--- a/.github/workflows/image-build-binary.yml
+++ b/.github/workflows/image-build-binary.yml
@@ -15,10 +15,6 @@ on:
         description: "Docker repo org for uploading images (defaults to github org)"
         default: "${GITHUB_REPOSITORY_OWNER}"
 
-defaults:
-  run:
-    shell: bash
-
 ## Define which docker arch to build for
 env:
   docker_platforms: "linux/arm64, linux/arm/v7, linux/amd64, linux/amd64/v2, linux/amd64/v3"
diff --git a/.github/workflows/image-build-source.yml b/.github/workflows/image-build-source.yml
index 79c428073c..1936999b27 100644
--- a/.github/workflows/image-build-source.yml
+++ b/.github/workflows/image-build-source.yml
@@ -6,10 +6,6 @@ on:
   workflow_dispatch:
   workflow_call:
 
-defaults:
-  run:
-    shell: bash
-
 ## Define which docker arch to build for
 env:
   docker_platforms: linux/amd64
@@ -47,7 +43,7 @@ jobs:
         with:
           images: |
             ${{env.docker-org}}/${{ github.event.repository.name }}
-            ${{env.docker-org}}/stacks-core
+            ${{env.docker-org}}/stacks-blockchain
           tags: |
             type=raw,value=${{ env.BRANCH_NAME }}
             type=ref,event=pr
diff --git a/.github/workflows/slow-tests.yml b/.github/workflows/slow-tests.yml
index edc53713e6..38fb20ac3d 100644
--- a/.github/workflows/slow-tests.yml
+++ b/.github/workflows/slow-tests.yml
@@ -5,19 +5,12 @@ name: Tests::Slow
 on:
   workflow_call:
 
-defaults:
-  run:
-    shell: bash
-
 ## env vars are transferred to composite action steps
 env:
   BITCOIND_TEST: 1
   RUST_BACKTRACE: full
   SEGMENT_DOWNLOAD_TIMEOUT_MINS: 15
-  RETRIES: 3
-  RETRY_DELAY: 10000
   TEST_TIMEOUT: 30
-  TEST_RETRIES: 2
 
 concurrency:
   group: slow-tests-${{ github.head_ref || github.ref || github.run_id }}
diff --git a/.github/workflows/stacks-blockchain-tests.yml b/.github/workflows/stacks-blockchain-tests.yml
index fa415a9cdc..de285f4b77 100644
--- a/.github/workflows/stacks-blockchain-tests.yml
+++ b/.github/workflows/stacks-blockchain-tests.yml
@@ -5,19 +5,12 @@ name: Tests::Stacks Blockchain
 on:
   workflow_call:
 
-defaults:
-  run:
-    shell: bash
-
 ## env vars are transferred to composite action steps
 env:
   BITCOIND_TEST: 1
   RUST_BACKTRACE: full
   SEGMENT_DOWNLOAD_TIMEOUT_MINS: 3
-  RETRIES: 3
-  RETRY_DELAY: 10000
   TEST_TIMEOUT: 30
-  TEST_RETRIES: 2
 
 concurrency:
   group: stacks-blockchain-tests-${{ github.head_ref || github.ref || github.run_id }}

From 6f29b3cbbb0107b8ce4eea60cbfd090f8fe78d70 Mon Sep 17 00:00:00 2001
From: wileyj <2847772+wileyj@users.noreply.github.com>
Date: Sun, 26 Nov 2023 18:17:33 -0800
Subject: [PATCH 0096/1166] remove comment in dockerfile

---
 build-scripts/Dockerfile.linux-glibc-arm64 | 1 -
 build-scripts/Dockerfile.linux-glibc-x64   | 1 -
 2 files changed, 2 deletions(-)

diff --git a/build-scripts/Dockerfile.linux-glibc-arm64 b/build-scripts/Dockerfile.linux-glibc-arm64
index 61ff5f4a04..7ce50b6a68 100644
--- a/build-scripts/Dockerfile.linux-glibc-arm64
+++ b/build-scripts/Dockerfile.linux-glibc-arm64
@@ -24,4 +24,3 @@ RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
 
 FROM scratch AS export-stage
 COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
-## comment
diff --git a/build-scripts/Dockerfile.linux-glibc-x64 b/build-scripts/Dockerfile.linux-glibc-x64
index 9c68c58af4..2db13cb51e 100644
--- a/build-scripts/Dockerfile.linux-glibc-x64
+++ b/build-scripts/Dockerfile.linux-glibc-x64
@@ -21,4 +21,3 @@ RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
 
 FROM scratch AS export-stage
 COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
-## comment

From dec30101dea72d69619a0cbfd17662efdc17690b Mon Sep 17 00:00:00 2001
From: wileyj <2847772+wileyj@users.noreply.github.com>
Date: Tue, 28 Nov 2023 20:10:46 -0800
Subject: [PATCH 0097/1166] renaming items to stacks-core

---
 .github/workflows/ci.yml                             |  6 +++---
 .github/workflows/clarity-js-sdk-pr.yml              |  4 ++--
 .github/workflows/create-cache.yml                   |  2 +-
 .github/workflows/docs-pr.yml                        |  6 +++---
 ...ks-blockchain-tests.yml => stacks-core-tests.yml} |  4 ++--
 .github/workflows/standalone-tests.yml               | 12 ++++++------
 6 files changed, 17 insertions(+), 17 deletions(-)
 rename .github/workflows/{stacks-blockchain-tests.yml => stacks-core-tests.yml} (97%)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index d4ae0ce806..2c86c6dcb1 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -166,7 +166,7 @@ jobs:
   ##   either or of the following:
   ##     - tag is not provided
   ##     - PR is approved
-  stacks-blockchain-tests:
+  stacks-core-tests:
     if: |
       inputs.tag != '' || (
         inputs.tag == '' || (
@@ -175,11 +175,11 @@ jobs:
           github.event.review.state == 'approved'
         )
       )
-    name: Stacks Blockchain Tests
+    name: Stacks Core Tests
     needs:
       - rustfmt
       - create-cache
-    uses: ./.github/workflows/stacks-blockchain-tests.yml
+    uses: ./.github/workflows/stacks-core-tests.yml
 
   bitcoin-tests:
     if: |
diff --git a/.github/workflows/clarity-js-sdk-pr.yml b/.github/workflows/clarity-js-sdk-pr.yml
index 25e96f9f2b..4523808410 100644
--- a/.github/workflows/clarity-js-sdk-pr.yml
+++ b/.github/workflows/clarity-js-sdk-pr.yml
@@ -22,7 +22,7 @@ jobs:
   run:
     name: Open Clarity JS SDK PR
     runs-on: ubuntu-latest
-    # This condition can be removed once the main `stacks-blockchain` workflow creates pre-releases
+    # This condition can be removed once the main `stacks-core` workflow creates pre-releases
     # when appropriate, instead of full releases for every tag passed in.
     if: "!contains(github.ref, '-rc')"
     steps:
@@ -58,7 +58,7 @@ jobs:
           labels: |
             dependencies
           body: |
-            :robot: This is an automated pull request created from a new release in [stacks-blockchain](https://github.com/stacks-network/stacks-blockchain/releases).
+            :robot: This is an automated pull request created from a new release in [stacks-core](https://github.com/stacks-network/stacks-core/releases).
 
             Updates the clarity-native-bin tag.
           assignees: zone117x
diff --git a/.github/workflows/create-cache.yml b/.github/workflows/create-cache.yml
index 71e0c02a31..a67ecc8fa0 100644
--- a/.github/workflows/create-cache.yml
+++ b/.github/workflows/create-cache.yml
@@ -9,7 +9,7 @@ on:
 ## env vars are transferred to composite action steps
 env:
   RUSTFLAGS: "-Cinstrument-coverage -Awarnings"
-  LLVM_PROFILE_FILE: "stacks-blockchain-%p-%m.profraw"
+  LLVM_PROFILE_FILE: "stacks-core-%p-%m.profraw"
   BTC_VERSION: "0.20.0"
 
 ##
diff --git a/.github/workflows/docs-pr.yml b/.github/workflows/docs-pr.yml
index bb54c28cc3..d3dbeaa45c 100644
--- a/.github/workflows/docs-pr.yml
+++ b/.github/workflows/docs-pr.yml
@@ -69,7 +69,7 @@ jobs:
             echo "::set-output name=open_pr::0"
           else
             git remote add robot https://github.com/$ROBOT_OWNER/$ROBOT_REPO
-            git commit -m "auto: update Clarity references JSONs from stacks-blockchain@${GITHUB_SHA}"
+            git commit -m "auto: update Clarity references JSONs from stacks-core@${GITHUB_SHA}"
             git push robot $ROBOT_BRANCH
             echo "::set-output name=open_pr::1"
           fi
@@ -109,6 +109,6 @@ jobs:
             let result = await github.pulls.create({
                 owner, repo, head,
                 base: "master",
-                title: "Auto: Update API documentation from stacks-blockchain",
-                body: "Update API documentation from the latest in `stacks-blockchain`",
+                title: "Auto: Update API documentation from stacks-core",
+                body: "Update API documentation from the latest in `stacks-core`",
             });
diff --git a/.github/workflows/stacks-blockchain-tests.yml b/.github/workflows/stacks-core-tests.yml
similarity index 97%
rename from .github/workflows/stacks-blockchain-tests.yml
rename to .github/workflows/stacks-core-tests.yml
index de285f4b77..6d3eb8d391 100644
--- a/.github/workflows/stacks-blockchain-tests.yml
+++ b/.github/workflows/stacks-core-tests.yml
@@ -1,6 +1,6 @@
 ## Github workflow to run full genesis and unit tests
 
-name: Tests::Stacks Blockchain
+name: Tests::Stacks Core
 
 on:
   workflow_call:
@@ -13,7 +13,7 @@ env:
   TEST_TIMEOUT: 30
 
 concurrency:
-  group: stacks-blockchain-tests-${{ github.head_ref || github.ref || github.run_id }}
+  group: stacks-core-tests-${{ github.head_ref || github.ref || github.run_id }}
   ## Only cancel in progress if this is for a PR
   cancel-in-progress: ${{ github.event_name == 'pull_request' }}
 
diff --git a/.github/workflows/standalone-tests.yml b/.github/workflows/standalone-tests.yml
index 458ea4c5e3..5c2bbe86bc 100644
--- a/.github/workflows/standalone-tests.yml
+++ b/.github/workflows/standalone-tests.yml
@@ -22,7 +22,7 @@ on:
           - Bitcoin Tests
           - Epoch Tests
           - Slow Tests
-          - Stacks-Blockchain Tests
+          - Stacks-Core Tests
 
 ## Set the display name to the test being run
 run-name: ${{ inputs.workflow }}
@@ -38,18 +38,18 @@ jobs:
   ##   either or of the following:
   ##     - workflow is 'Release Tests'
   ##     - workflow is 'CI Tests'
-  ##     - workflow is 'Stacks-Blockchain Tests'
-  stacks-blockchain-tests:
+  ##     - workflow is 'Stacks-Core Tests'
+  stacks-core-tests:
     if: |
       (
         inputs.workflow == 'Release Tests' ||
         inputs.workflow == 'CI Tests' ||
-        inputs.workflow == 'Stacks-Blockchain Tests'
+        inputs.workflow == 'Stacks-Core Tests'
       )
-    name: Stacks Blockchain Tests
+    name: Stacks Core Tests
     needs:
       - create-cache
-    uses: ./.github/workflows/stacks-blockchain-tests.yml
+    uses: ./.github/workflows/stacks-core-tests.yml
 
   ## Runs when:
   ##   either or of the following:

From bd35a46bbca86248a72bc64e386f4d2b9273c963 Mon Sep 17 00:00:00 2001
From: wileyj <2847772+wileyj@users.noreply.github.com>
Date: Tue, 28 Nov 2023 20:11:31 -0800
Subject: [PATCH 0098/1166] update documentation

---
 .github/PULL_REQUEST_TEMPLATE.md |   4 +-
 docs/ci-release.md               | 139 ++++++++++++++++++++-----------
 2 files changed, 95 insertions(+), 48 deletions(-)

diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md
index abcdea7256..69ef6240b2 100644
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -3,17 +3,19 @@
   Pull requests are ideal for making small changes to this project. However, they are NOT an appropriate venue to introducing non-trivial or breaking changes to the codebase.
 
   For introducing non-trivial or breaking changes to the codebase, please follow the SIP (Stacks Improvement Proposal) process documented here:
-  https://github.com/blockstack/stacks-blockchain/blob/master/sip/sip-000-stacks-improvement-proposal-process.md.
+  https://github.com/stacksgov/sips/blob/main/sips/sip-000/sip-000-stacks-improvement-proposal-process.md.
 -->
 
 ### Description
 
 ### Applicable issues
+
 - fixes #
 
 ### Additional info (benefits, drawbacks, caveats)
 
 ### Checklist
+
 - [ ] Test coverage for new or modified code paths
 - [ ] Changelog is updated
 - [ ] Required documentation changes (e.g., `docs/rpc/openapi.yaml` and `rpc-endpoints.md` for v2 endpoints, `event-dispatcher.md` for new events)
diff --git a/docs/ci-release.md b/docs/ci-release.md
index 6a0bc7e1ca..f042b05ed2 100644
--- a/docs/ci-release.md
+++ b/docs/ci-release.md
@@ -1,38 +1,42 @@
 # Releases
 
-All releases are built via a Github Actions workflow named `CI`, and is responsible for building binary archives, checksums, and resulting docker images.
-This workflow will also trigger any tests that need to be run, like integration tests.
+All releases are built via a Github Actions workflow named `CI` ([ci.yml](../.github/workflows/ci.yml)), and is responsible for:
 
-1. Releases are only created if a tag is **manually** provided when the ci workflow is triggered.
-2. Pushing a new feature branch: Nothing is triggered automatically. A PR is required, or the ci workflow can be triggered manually on a specific branch to build a docker image (and run the standard PR tests) for the specified branch.
-3. Caching is used to speed up testing - a cache is created based on the type of data (i.e. cargo) and the commit sha. tests can be retried quickly since the cache will persist until the cleanup job is run.
-4. [nextest](https://nexte.st/) is used to run the tests from an archived file that is cached (using commit sha as a key))
+- Verifying code is formatted correctly
+- Building binary archives and checksums
+- Docker images
+- Triggering tests conditionally (different tests run for a release vs a PR)
+
+1. Releases are only created if a tag is **manually** provided when the [CI workflow](../.github/workflows/ci.yml) is triggered.
+2. [Caching](https://docs.github.com/en/actions/using-workflows/caching-dependencies-to-speed-up-workflows) is used to speed up testing - a cache is created based on the type of data (i.e. cargo) and the commit sha. tests can be retried quickly since the cache will persist until the cleanup job is run.
+3. [nextest](https://nexte.st/) is used to run the tests from an archived file that is cached (using commit sha as a key))
    - Two [archives](https://nexte.st/book/reusing-builds.html) are created, one for genesis tests and one for generic tests (it is done this way to reduce the time spent building)
    - Unit-tests are [partitioned](https://nexte.st/book/partitioning.html) and multi-threaded to speed up execution time
 
 ## TL;DR
 
-1. An open/re-opened/synchronized PR will produce a single image built from source on Debian with glibc with 2 tags:
-   - `stacks-blockchain:<branch-name>`
-   - `stacks-blockchain:<pr-number>`
-2. A merged PR from `develop` to the default branch will produce a single image built from source on Debian with glibc:
-   - `stacks-blockchain:<default-branch-name>`
-3. An untagged build of any branch will produce a single image built from source on Debian with glibc:
-   - `stacks-blockchain:<branch-name>`
-4. A tagged release on a non-default branch will produces:
-   - Docker Alpine image for several architectures tagged with:
-     - `stacks-blockchain:<x.x.x.x.x>`
-   - Docker Debian image for several architectures tagged with:
-     - `stacks-blockchain:<x.x.x.x.x-debian>`
-5. A tagged release on the default branch will produce:
-   - Github Release of the specified tag with:
-     - Binary archives for several architectures
-   - Docker Alpine image for several architectures tagged with:
-     - `stacks-blockchain:<x.x.x.x.x>`
-     - `stacks-blockchain:<latest>`
-   - Docker Debian image for several architectures tagged with:
-     - `stacks-blockchain:<x.x.x.x.x-debian>`
-     - `stacks-blockchain:<latest-debian>`
+- Pushing a feature branch will not trigger a workflow
+- An open/re-opened/synchronized PR will produce a single image built from source on Debian with glibc with 2 tags:
+  - `stacks-core:<branch-name>`
+  - `stacks-core:<pr-number>`
+- A merged PR into `default-branch` from `develop` will produce a single image built from source on Debian with glibc:
+  - `stacks-core:<default-branch-name>`
+- An untagged build of any branch will produce a single image built from source on Debian with glibc:
+  - `stacks-core:<branch-name>`
+- A tagged release on a non-default branch will produces:
+  - Docker Alpine image for several architectures tagged with:
+    - `stacks-core:<x.x.x.x.x>`
+  - Docker Debian image for several architectures tagged with:
+    - `stacks-core:<x.x.x.x.x-debian>`
+- A tagged release on the default branch will produce:
+  - Github Release of the specified tag with:
+    - Binary archives for several architectures
+  - Docker Alpine image for several architectures tagged with:
+    - `stacks-core:<x.x.x.x.x>`
+    - `stacks-core:<latest>`
+  - Docker Debian image for several architectures tagged with:
+    - `stacks-core:<x.x.x.x.x-debian>`
+    - `stacks-core:<latest-debian>`
 
 ## Release workflow
 
@@ -40,19 +44,19 @@ This workflow will also trigger any tests that need to be run, like integration
 2. PR `feat/fix-something` to the `develop` branch where the PR is numbered `112`
    1. Docker image tagged with the **branch name** and **PR number**
    - ex:
-     - `stacks-blockchain:feat-fix-something`
-     - `stacks-blockchain:pr-112`
+     - `stacks-core:feat-fix-something`
+     - `stacks-core:pr-112`
    2. CI tests are run
 3. PR `develop` to the default branch where the PR is numbered `112`
    1. Docker image tagged with the **branch name** and **PR number**
    - ex:
-     - `stacks-blockchain:feat-fix-something`
-     - `stacks-blockchain:pr-112`
+     - `stacks-core:feat-fix-something`
+     - `stacks-core:pr-112`
    2. CI tests are run
 4. Merge `develop` branch to the default branch
    1. Docker image is tagged with the **default branch** `master`
    - ex:
-     - `stacks-blockchain:master`
+     - `stacks-core:master`
    2. CI tests are run
 5. CI workflow is manually triggered on **non-default branch** with a version, i.e. `2.1.0.0.0-rc0`
    1. No Docker images/binaries are created
@@ -62,10 +66,10 @@ This workflow will also trigger any tests that need to be run, like integration
    2. All release tests are run
    3. Docker image pushed with tags of the **input version** and **latest**
    - ex:
-   - `stacks-blockchain:2.1.0.0.0-debian`
-   - `stacks-blockchain:latest-debian`
-   - `stacks-blockchain:2.1.0.0.0`
-   - `stacks-blockchain:latest`
+   - `stacks-core:2.1.0.0.0-debian`
+   - `stacks-core:latest-debian`
+   - `stacks-core:2.1.0.0.0`
+   - `stacks-core:latest`
 
 ## Tests
 
@@ -79,7 +83,7 @@ There are also 2 different methods in use with regard to running tests:
 A matrix is used when there are several known tests that need to be run. Partitions (shards) are used when there is a large and unknown number of tests to run (ex: `cargo test` to run all tests).
 
 There is also a workflow designed to run tests that are manually triggered: [Standalone Tests](../.github/workflows/standalone-tests.yml).
-This workflow requires you to select which test(s) you want to run, which then triggers a reusable workflow via conditional. For example, selecting "Epoch Tests" will run the tests defined in [Epoch Tests](../.github/workflows/epoch-tests.yml). Likewise, selecting `Release Tests` will run the same tests as a release workflow.
+This workflow requires you to select which test(s) you want to run, which then triggers a reusbale workflow via conditional. For example, selecting "Epoch Tests" will run the tests defined in [Epoch Tests](../.github/workflows/epoch-tests.yml). Likewise, selecting `Release Tests` will run the same tests as a release workflow.
 
 Files:
 
@@ -90,6 +94,47 @@ Files:
 - [Epoch Tests](../.github/workflows/epoch-tests.yml)
 - [Slow Tests](../.github/workflows/slow-tests.yml)
 
+### Adding/changing tests
+
+With the exception of `unit-tests` in [Stacks Blockchain Tests](../.github/workflows/stacks-blockchain-tests.yml), adding/removing a test requires a change to the workflow matrix. Example from [Atlas Tests](../.github/workflows/atlas-tests.yml):
+
+```yaml
+atlas-tests:
+  name: Atlas Test
+  runs-on: ubuntu-latest
+  strategy:
+    ## Continue with the test matrix even if we've had a failure
+    fail-fast: false
+    ## Run a maximum of 2 concurrent tests from the test matrix
+    max-parallel: 2
+    matrix:
+      test-name:
+        - tests::neon_integrations::atlas_integration_test
+        - tests::neon_integrations::atlas_stress_integration_test
+```
+
+Example of adding a new test `tests::neon_integrations::atlas_new_test`:
+
+```yaml
+    ...
+    matrix:
+      test-name:
+        - tests::neon_integrations::atlas_integration_test
+        - tests::neon_integrations::atlas_stress_integration_test
+        - tests::neon_integrations::atlas_new_test
+```
+
+The separation of tests (outside of [Slow Tests](../.github/workflows/slow-tests.yml)) is performed by creating a separate workflow for each _type_ of test that is being run. Using the example above, to add/remove any tests from being run - the `matrix` will need to be adjusted.
+
+ex:
+
+- `Atlas Tests`: Tests related to Atlas
+- `Bitcoin Tests`: Tests relating to burnchain operations
+- `Epoch Tests`: Tests related to epoch changes
+- `Slow Tests`: These tests have been identified as taking longer than others. The threshold used is if a test takes longer than `10 minutes` to complete successfully (or times out semi-regularly), it should be added here.
+- `Stacks Blockchain Tests`:
+  - `full-genesis`: Tests related to full genesis
+
 ## Triggering a workflow
 
 ### PR a branch to develop
@@ -102,8 +147,8 @@ ex: Branch is named `feat/fix-something` and the PR is numbered `112`
 - [Bitcoin Tests](../.github/workflows/bitcoin-tests.yml)
 - [Docker image](../.github/workflows/image-build-source.yml) is built from source on a debian distribution and pushed with the branch name and PR number as tags
 - ex:
-  - `stacks-blockchain:feat-fix-something`
-  - `stacks-blockchain:pr-112`
+  - `stacks-core:feat-fix-something`
+  - `stacks-core:pr-112`
 
 ---
 
@@ -123,8 +168,8 @@ ex: Branch is named `develop` and the PR is numbered `113`
 - [Bitcoin Tests](../.github/workflows/bitcoin-tests.yml)
 - [Docker image](../.github/workflows/image-build-source.yml) is built from source on a debian distribution and pushed with the branch name and PR number as tags
 - ex:
-  - `stacks-blockchain:develop`
-  - `stacks-blockchain:pr-113`
+  - `stacks-core:develop`
+  - `stacks-core:pr-113`
 
 ---
 
@@ -136,7 +181,7 @@ ex: Branch is named `develop` and the PR is numbered `113`
 - [Bitcoin Tests](../.github/workflows/bitcoin-tests.yml)
 - [Docker image](../.github/workflows/image-build-source.yml) is built from source on a debian distribution and pushed with the branch name as a tag
 - ex:
-  - `stacks-blockchain:master`
+  - `stacks-core:master`
 
 ---
 
@@ -148,7 +193,7 @@ ex: Branch is named `develop` and the PR is numbered `113`
 - [Bitcoin Tests](../.github/workflows/bitcoin-tests.yml)
 - [Docker image](../.github/workflows/image-build-source.yml) is built from source on a debian distribution and pushed with the branch name as a tag
 - ex:
-  - `stacks-blockchain:<branch name>`
+  - `stacks-core:<branch name>`
 
 ---
 
@@ -178,9 +223,9 @@ ex: Branch is named `develop` and the PR is numbered `113`
 - [Github release](../.github/workflows/github-release.yml) (with artifacts/checksum) is created using the manually input tag
 - [Docker image](../.github/workflows/image-build-binary.yml) built from binaries on debian/alpine distributions and pushed with the provided input tag and `latest`
 - ex:
-  - `stacks-blockchain:2.1.0.0.0-debian`
-  - `stacks-blockchain:latest-debian`
-  - `stacks-blockchain:2.1.0.0.0`
-  - `stacks-blockchain:latest`
+  - `stacks-core:2.1.0.0.0-debian`
+  - `stacks-core:latest-debian`
+  - `stacks-core:2.1.0.0.0`
+  - `stacks-core:latest`
 
 ---

From 6bdc9d5f8f872afd91a56089d7cceb7dcb7ddf9b Mon Sep 17 00:00:00 2001
From: wileyj <2847772+wileyj@users.noreply.github.com>
Date: Wed, 29 Nov 2023 22:53:52 -0800
Subject: [PATCH 0099/1166] Update location of archive

---
 .github/workflows/stacks-core-tests.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/stacks-core-tests.yml b/.github/workflows/stacks-core-tests.yml
index 6d3eb8d391..af0b1a934c 100644
--- a/.github/workflows/stacks-core-tests.yml
+++ b/.github/workflows/stacks-core-tests.yml
@@ -47,7 +47,7 @@ jobs:
         with:
           test-name: ${{ matrix.test-name }}
           threads: 1
-          archive-file: /tmp/genesis_archive.tar.zst
+          archive-file: ~/genesis_archive.tar.zst
 
       ## Upload code coverage file
       - name: Code Coverage

From 5f92195ae34e530feaa8f26e4663d0e4f4e1268e Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Fri, 1 Dec 2023 15:34:46 -0500
Subject: [PATCH 0100/1166] fix: workspace dependency

---
 Cargo.toml | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/Cargo.toml b/Cargo.toml
index df81990bc8..a861f143e9 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -12,6 +12,10 @@ members = [
     "stacks-signer",
     "testnet/stacks-node"]
 
+# Dependencies we want to keep the same between workspace members
+[workspace.dependencies]  
+wsts = "5.0"
+
 # Use a bit more than default optimization for
 #  dev builds to speed up test execution
 [profile.dev]

From d650b72aca852e7853af7fe1eefb836592559400 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Fri, 1 Dec 2023 15:59:26 -0500
Subject: [PATCH 0101/1166] chore: remove commented-out code

---
 stacks-common/src/types/chainstate.rs |  4 +--
 stacks-common/src/util/secp256k1.rs   | 41 ---------------------------
 2 files changed, 1 insertion(+), 44 deletions(-)

diff --git a/stacks-common/src/types/chainstate.rs b/stacks-common/src/types/chainstate.rs
index ddbcfc58b3..95469e79f6 100644
--- a/stacks-common/src/types/chainstate.rs
+++ b/stacks-common/src/types/chainstate.rs
@@ -15,7 +15,7 @@ use crate::consts::{FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH};
 use crate::deps_common::bitcoin::util::hash::Sha256dHash;
 use crate::util::hash::{to_hex, DoubleSha256, Hash160, Sha512Trunc256Sum, HASH160_ENCODED_SIZE};
 use crate::util::secp256k1::{
-    MessageSignature, /* SchnorrSignature, */ Secp256k1PrivateKey, Secp256k1PublicKey,
+    MessageSignature, Secp256k1PrivateKey, Secp256k1PublicKey,
 };
 use crate::util::uint::Uint256;
 use crate::util::vrf::{VRFProof, VRF_PROOF_ENCODED_SIZE};
@@ -338,7 +338,6 @@ impl_byte_array_rusqlite_only!(VRFProof);
 impl_byte_array_rusqlite_only!(TrieHash);
 impl_byte_array_rusqlite_only!(Sha512Trunc256Sum);
 impl_byte_array_rusqlite_only!(MessageSignature);
-// impl_byte_array_rusqlite_only!(SchnorrSignature);
 
 impl_byte_array_message_codec!(TrieHash, TRIEHASH_ENCODED_SIZE as u32);
 impl_byte_array_message_codec!(Sha512Trunc256Sum, 32);
@@ -349,7 +348,6 @@ impl_byte_array_message_codec!(BurnchainHeaderHash, 32);
 impl_byte_array_message_codec!(BlockHeaderHash, 32);
 impl_byte_array_message_codec!(StacksBlockId, 32);
 impl_byte_array_message_codec!(MessageSignature, 65);
-// impl_byte_array_message_codec!(SchnorrSignature, 65);
 
 impl BlockHeaderHash {
     pub fn to_hash160(&self) -> Hash160 {
diff --git a/stacks-common/src/util/secp256k1.rs b/stacks-common/src/util/secp256k1.rs
index 50cb283a1f..8a84a4bedd 100644
--- a/stacks-common/src/util/secp256k1.rs
+++ b/stacks-common/src/util/secp256k1.rs
@@ -118,47 +118,6 @@ impl Default for Secp256k1PublicKey {
     }
 }
 
-/*
-pub struct SchnorrSignature(pub [u8; 65]);
-impl_array_newtype!(SchnorrSignature, u8, 65);
-impl_array_hexstring_fmt!(SchnorrSignature);
-impl_byte_array_newtype!(SchnorrSignature, u8, 65);
-impl_byte_array_serde!(SchnorrSignature);
-pub const SCHNORR_SIGNATURE_ENCODED_SIZE: u32 = 65;
-
-impl Default for SchnorrSignature {
-    /// Creates a default Schnorr Signature. Note this is not a valid signature.
-    fn default() -> Self {
-        Self([0u8; 65])
-    }
-}
-
-impl SchnorrSignature {
-    /// Attempt to convert a Schnorr signature to a WSTS Signature
-    pub fn to_wsts_signature(&self) -> Option<WSTSSignature> {
-        // TODO: update wsts to add a TryFrom for a [u8; 65] and a slice to a Signature
-        let point_bytes: [u8; 33] = self.0[..33].try_into().ok()?;
-        let scalar_bytes: [u8; 32] = self.0[33..].try_into().ok()?;
-        let point = Point::try_from(&Compressed::from(point_bytes)).ok()?;
-        let scalar = Scalar::from(scalar_bytes);
-        Some(WSTSSignature {
-            R: point,
-            z: scalar,
-        })
-    }
-}
-
-/// Convert a WSTS Signature to a SchnorrSignature
-impl From<&WSTSSignature> for SchnorrSignature {
-    fn from(signature: &WSTSSignature) -> Self {
-        let mut buf = [0u8; 65];
-        buf[..33].copy_from_slice(&signature.R.compress().data);
-        buf[33..].copy_from_slice(&signature.z.to_bytes());
-        SchnorrSignature(buf)
-    }
-}
-*/
-
 impl Secp256k1PublicKey {
     #[cfg(any(test, feature = "testing"))]
     pub fn new() -> Secp256k1PublicKey {

From 609005fa1e4f9cac52497160637b6b2422198e81 Mon Sep 17 00:00:00 2001
From: wileyj <2847772+wileyj@users.noreply.github.com>
Date: Mon, 4 Dec 2023 20:29:25 -0800
Subject: [PATCH 0102/1166] revert logging commit (pr 4124)

---
 stacks-common/src/util/log.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/stacks-common/src/util/log.rs b/stacks-common/src/util/log.rs
index 0889fc6a8f..3aa2a1e5af 100644
--- a/stacks-common/src/util/log.rs
+++ b/stacks-common/src/util/log.rs
@@ -238,8 +238,7 @@ fn make_logger() -> Logger {
         let plain = slog_term::PlainSyncDecorator::new(slog_term::TestStdoutWriter);
         let isatty = isatty(Stream::Stdout);
         let drain = TermFormat::new(plain, false, debug, isatty);
-        let logger = Logger::root(drain.ignore_res(), o!());
-        logger
+        Logger::root(drain.ignore_res(), o!())
     }
 }
 

From 9e9478fecbf3502613b907d71b3dd75cbe1afa0e Mon Sep 17 00:00:00 2001
From: wileyj <2847772+wileyj@users.noreply.github.com>
Date: Mon, 4 Dec 2023 21:02:40 -0800
Subject: [PATCH 0103/1166] Revert "revert logging commit (pr 4124)"

This reverts commit 609005fa1e4f9cac52497160637b6b2422198e81.
---
 stacks-common/src/util/log.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/stacks-common/src/util/log.rs b/stacks-common/src/util/log.rs
index 3aa2a1e5af..0889fc6a8f 100644
--- a/stacks-common/src/util/log.rs
+++ b/stacks-common/src/util/log.rs
@@ -238,7 +238,8 @@ fn make_logger() -> Logger {
         let plain = slog_term::PlainSyncDecorator::new(slog_term::TestStdoutWriter);
         let isatty = isatty(Stream::Stdout);
         let drain = TermFormat::new(plain, false, debug, isatty);
-        Logger::root(drain.ignore_res(), o!())
+        let logger = Logger::root(drain.ignore_res(), o!());
+        logger
     }
 }
 

From 6518de5e4c861f42444a83b12a098b3c6dccd6ad Mon Sep 17 00:00:00 2001
From: wileyj <2847772+wileyj@users.noreply.github.com>
Date: Tue, 5 Dec 2023 18:00:58 -0800
Subject: [PATCH 0104/1166] adding tests/fixing build error

---
 .github/workflows/sbtc-tests.yml           |  57 +++++++++
 .github/workflows/standalone-tests.yml     |  17 +++
 testnet/stacks-node/src/mockamoto/tests.rs | 128 +++++++++++++++++++++
 3 files changed, 202 insertions(+)
 create mode 100644 .github/workflows/sbtc-tests.yml
 create mode 100644 testnet/stacks-node/src/mockamoto/tests.rs

diff --git a/.github/workflows/sbtc-tests.yml b/.github/workflows/sbtc-tests.yml
new file mode 100644
index 0000000000..7d9e7abbdf
--- /dev/null
+++ b/.github/workflows/sbtc-tests.yml
@@ -0,0 +1,57 @@
+## Github workflow to run sbtc tests
+
+name: Tests::SBTC
+
+on:
+  workflow_call:
+
+## env vars are transferred to composite action steps
+env:
+  BITCOIND_TEST: 1
+  RUST_BACKTRACE: full
+  SEGMENT_DOWNLOAD_TIMEOUT_MINS: 15
+  TEST_TIMEOUT: 30
+
+concurrency:
+  group: sbtc-tests-${{ github.head_ref || github.ref || github.run_id}}
+  ## Only cancel in progress if this is for a PR
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
+jobs:
+  # Bitcoin integration tests with code coverage
+  sbtc-tests:
+    name: SBTC Tests
+    runs-on: ubuntu-latest
+    strategy:
+      ## Continue with the test matrix even if we've had a failure
+      fail-fast: false
+      ## Run a maximum of 32 concurrent tests from the test matrix
+      max-parallel: 32
+      matrix:
+        test-name:
+          - tests::neon_integrations::test_submit_and_observe_sbtc_ops
+          - tests::signer::test_stackerdb_dkg
+          - tests::stackerdb::test_stackerdb_event_observer
+          - tests::stackerdb::test_stackerdb_load_store
+    steps:
+      ## Setup test environment
+      - name: Setup Test Environment
+        id: setup_tests
+        uses: stacks-network/actions/stacks-core/testenv@main
+
+      ## Run test matrix using restored cache of archive file
+      ##   - Test will timeout after env.TEST_TIMEOUT minutes
+      - name: Run Tests
+        id: run_tests
+        timeout-minutes: ${{ fromJSON(env.TEST_TIMEOUT) }}
+        uses: stacks-network/actions/stacks-core/run-tests@main
+        with:
+          test-name: ${{ matrix.test-name }}
+
+      ## Create and upload code coverage file
+      - name: Code Coverage
+        id: codecov
+        uses: stacks-network/actions/codecov@main
+        with:
+          test-name: ${{ matrix.test-name }}
+
diff --git a/.github/workflows/standalone-tests.yml b/.github/workflows/standalone-tests.yml
index 5c2bbe86bc..e0fe2d345b 100644
--- a/.github/workflows/standalone-tests.yml
+++ b/.github/workflows/standalone-tests.yml
@@ -23,6 +23,7 @@ on:
           - Epoch Tests
           - Slow Tests
           - Stacks-Core Tests
+          - SBTC Tests
 
 ## Set the display name to the test being run
 run-name: ${{ inputs.workflow }}
@@ -113,3 +114,19 @@ jobs:
     needs:
       - create-cache
     uses: ./.github/workflows/slow-tests.yml
+
+  ## Runs when:
+  ##   either or of the following:
+  ##     - workflow is 'Release Tests'
+  ##     - workflow is 'SBTC Tests'
+  sbtc-tests:
+    if: |
+      (
+        inputs.workflow == 'Release Tests' ||
+        inputs.workflow == 'SBTC Tests'
+      )
+    name: SBTC Tests
+    needs:
+      - create-cache
+    uses: ./.github/workflows/sbtc-tests.yml
+
diff --git a/testnet/stacks-node/src/mockamoto/tests.rs b/testnet/stacks-node/src/mockamoto/tests.rs
new file mode 100644
index 0000000000..94253e4179
--- /dev/null
+++ b/testnet/stacks-node/src/mockamoto/tests.rs
@@ -0,0 +1,128 @@
+use std::thread;
+use std::time::Duration;
+use std::time::Instant;
+
+use clarity::vm::costs::ExecutionCost;
+use stacks::chainstate::nakamoto::NakamotoChainState;
+use stacks::chainstate::stacks::db::StacksChainState;
+use stacks_common::types::chainstate::StacksAddress;
+use stacks_common::types::chainstate::StacksPrivateKey;
+use stacks_common::types::StacksEpochId;
+use stacks_common::util::hash::to_hex;
+
+use crate::config::EventKeyType;
+use crate::config::EventObserverConfig;
+use crate::neon_node::PeerThread;
+use crate::tests::make_stacks_transfer;
+use crate::tests::neon_integrations::test_observer;
+use crate::tests::to_addr;
+use crate::Config;
+use crate::ConfigFile;
+
+use super::MockamotoNode;
+
+#[test]
+fn observe_100_blocks() {
+    let mut conf = Config::from_config_file(ConfigFile::mockamoto()).unwrap();
+    conf.node.mockamoto_time_ms = 10;
+
+    let submitter_sk = StacksPrivateKey::from_seed(&[1]);
+    let submitter_addr = to_addr(&submitter_sk);
+    conf.add_initial_balance(submitter_addr.to_string(), 1_000);
+    let recipient_addr = StacksAddress::burn_address(false).into();
+
+    test_observer::spawn();
+    let observer_port = test_observer::EVENT_OBSERVER_PORT;
+    conf.events_observers.insert(EventObserverConfig {
+        endpoint: format!("localhost:{observer_port}"),
+        events_keys: vec![EventKeyType::AnyEvent],
+    });
+
+    let mut mockamoto = MockamotoNode::new(&conf).unwrap();
+    let globals = mockamoto.globals.clone();
+
+    let mut mempool = PeerThread::connect_mempool_db(&conf);
+    let (mut chainstate, _) = StacksChainState::open(
+        conf.is_mainnet(),
+        conf.burnchain.chain_id,
+        &conf.get_chainstate_path_str(),
+        None,
+    )
+    .unwrap();
+    let burnchain = conf.get_burnchain();
+    let sortdb = burnchain.open_sortition_db(true).unwrap();
+
+    let start = Instant::now();
+
+    let node_thread = thread::Builder::new()
+        .name("mockamoto-main".into())
+        .spawn(move || mockamoto.run())
+        .expect("FATAL: failed to start mockamoto main thread");
+
+    // make a transfer tx to test that the mockamoto miner picks up txs from the mempool
+    let transfer_tx = make_stacks_transfer(&submitter_sk, 0, 10, &recipient_addr, 100);
+    let transfer_tx_hex = format!("0x{}", to_hex(&transfer_tx));
+
+    // complete within 2 minutes or abort
+    let completed = loop {
+        if Instant::now().duration_since(start) > Duration::from_secs(120) {
+            break false;
+        }
+        let latest_block = test_observer::get_blocks().pop();
+        thread::sleep(Duration::from_secs(1));
+        let Some(ref latest_block) = latest_block else {
+            info!("No block observed yet!");
+            continue;
+        };
+        let stacks_block_height = latest_block.get("block_height").unwrap().as_u64().unwrap();
+        info!("Block height observed: {stacks_block_height}");
+
+        if stacks_block_height == 1 {
+            let tip = NakamotoChainState::get_canonical_block_header(chainstate.db(), &sortdb)
+                .unwrap()
+                .unwrap();
+            mempool
+                .submit_raw(
+                    &mut chainstate,
+                    &sortdb,
+                    &tip.consensus_hash,
+                    &tip.anchored_header.block_hash(),
+                    transfer_tx.clone(),
+                    &ExecutionCost::max_value(),
+                    &StacksEpochId::Epoch30,
+                )
+                .unwrap();
+        }
+
+        if stacks_block_height >= 100 {
+            break true;
+        }
+    };
+
+    globals.signal_stop();
+
+    let transfer_tx_included = test_observer::get_blocks()
+        .into_iter()
+        .find(|block_json| {
+            block_json["transactions"]
+                .as_array()
+                .unwrap()
+                .iter()
+                .find(|tx_json| tx_json["raw_tx"].as_str() == Some(&transfer_tx_hex))
+                .is_some()
+        })
+        .is_some();
+
+    assert!(
+        transfer_tx_included,
+        "Mockamoto node failed to include the transfer tx"
+    );
+
+    assert!(
+        completed,
+        "Mockamoto node failed to produce and announce 100 blocks before timeout"
+    );
+    node_thread
+        .join()
+        .expect("Failed to join node thread to exit");
+}

From 5c1ce84de500af591340abaff3780493ac9a50d5 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Mon, 4 Dec 2023 11:43:35 -0500
Subject: [PATCH 0105/1166] fix: Use `VRFProof::consensus_serialize()` to
 address issue #4115

---
 stackslib/src/chainstate/stacks/transaction.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/transaction.rs b/stackslib/src/chainstate/stacks/transaction.rs
index 8d9eb6873d..00dd5e1aba 100644
--- a/stackslib/src/chainstate/stacks/transaction.rs
+++ b/stackslib/src/chainstate/stacks/transaction.rs
@@ -282,7 +282,7 @@ impl StacksMessageCodec for TransactionPayload {
                         write_next(fd, &(TransactionPayloadID::NakamotoCoinbase as u8))?;
                         write_next(fd, buf)?;
                         write_next(fd, &Value::none())?;
-                        write_next(fd, &vrf_proof.to_bytes().to_vec())?;
+                        write_next(fd, vrf_proof)?;
                     }
                     (Some(recipient), Some(vrf_proof)) => {
                         write_next(fd, &(TransactionPayloadID::NakamotoCoinbase as u8))?;
@@ -293,7 +293,7 @@ impl StacksMessageCodec for TransactionPayload {
                                 "FATAL: failed to encode recipient principal as `optional`",
                             ),
                         )?;
-                        write_next(fd, &vrf_proof.to_bytes().to_vec())?;
+                        write_next(fd, vrf_proof)?;
                     }
                 }
             }

From 396b34ba414220834de7ff96a890d55458ded51b Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Tue, 5 Dec 2023 16:19:54 -0500
Subject: [PATCH 0106/1166] Fix unit tests and
 `TransactionPayload::deserialize()`

---
 stackslib/src/chainstate/stacks/transaction.rs | 17 +----------------
 stackslib/src/core/mempool.rs                  |  3 +--
 testnet/stacks-node/src/mockamoto.rs           |  3 +--
 testnet/stacks-node/src/mockamoto/tests.rs     | 18 ++++++------------
 4 files changed, 9 insertions(+), 32 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/transaction.rs b/stackslib/src/chainstate/stacks/transaction.rs
index 00dd5e1aba..1b7f858c54 100644
--- a/stackslib/src/chainstate/stacks/transaction.rs
+++ b/stackslib/src/chainstate/stacks/transaction.rs
@@ -387,12 +387,7 @@ impl StacksMessageCodec for TransactionPayload {
                 } else {
                     return Err(codec_error::DeserializeError("Failed to parse nakamoto coinbase transaction -- did not receive an optional recipient principal value".to_string()));
                 };
-                let vrf_proof_bytes: Vec<u8> = read_next(fd)?;
-                let Some(vrf_proof) = VRFProof::from_bytes(&vrf_proof_bytes) else {
-                    return Err(codec_error::DeserializeError(
-                        "Failed to decode coinbase VRF proof".to_string(),
-                    ));
-                };
+                let vrf_proof: VRFProof = read_next(fd)?;
                 TransactionPayload::Coinbase(payload, recipient_opt, Some(vrf_proof))
             }
             TransactionPayloadID::TenureChange => {
@@ -2043,11 +2038,6 @@ mod test {
             0x12,
             // no alt recipient, so Value::none
             0x09,
-            // proof bytes length
-            0x00,
-            0x00,
-            0x00,
-            0x50,
             // proof bytes
             0x92,
             0x75,
@@ -2227,11 +2217,6 @@ mod test {
             0x61,
             0x63,
             0x74,
-            // proof bytes length
-            0x00,
-            0x00,
-            0x00,
-            0x50,
             // proof bytes
             0x92,
             0x75,
diff --git a/stackslib/src/core/mempool.rs b/stackslib/src/core/mempool.rs
index a481c6ae1b..f85a0e0ef9 100644
--- a/stackslib/src/core/mempool.rs
+++ b/stackslib/src/core/mempool.rs
@@ -43,8 +43,7 @@ use stacks_common::util::{get_epoch_time_ms, get_epoch_time_secs};
 use crate::burnchains::Txid;
 use crate::chainstate::burn::db::sortdb::SortitionDB;
 use crate::chainstate::burn::ConsensusHash;
-use crate::chainstate::nakamoto::NakamotoBlock;
-use crate::chainstate::nakamoto::NakamotoChainState;
+use crate::chainstate::nakamoto::{NakamotoBlock, NakamotoChainState};
 use crate::chainstate::stacks::db::blocks::MemPoolRejection;
 use crate::chainstate::stacks::db::{ClarityTx, StacksChainState};
 use crate::chainstate::stacks::events::StacksTransactionReceipt;
diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index a371a77b0b..20bd7106b8 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -68,6 +68,7 @@ use stacks_common::util::hash::{Hash160, MerkleTree, Sha512Trunc256Sum};
 use stacks_common::util::secp256k1::{MessageSignature, SchnorrSignature, Secp256k1PublicKey};
 use stacks_common::util::vrf::{VRFPrivateKey, VRFProof, VRFPublicKey, VRF};
 
+use self::signer::SelfSigner;
 use crate::neon::Counters;
 use crate::neon_node::{
     Globals, PeerThread, RelayerDirective, StacksNode, BLOCK_PROCESSOR_STACK_SIZE,
@@ -75,8 +76,6 @@ use crate::neon_node::{
 use crate::syncctl::PoxSyncWatchdogComms;
 use crate::{Config, EventDispatcher};
 
-use self::signer::SelfSigner;
-
 pub mod signer;
 #[cfg(test)]
 mod tests;
diff --git a/testnet/stacks-node/src/mockamoto/tests.rs b/testnet/stacks-node/src/mockamoto/tests.rs
index 94253e4179..d1f3696418 100644
--- a/testnet/stacks-node/src/mockamoto/tests.rs
+++ b/testnet/stacks-node/src/mockamoto/tests.rs
@@ -1,25 +1,19 @@
 use std::thread;
-use std::time::Duration;
-use std::time::Instant;
+use std::time::{Duration, Instant};
 
 use clarity::vm::costs::ExecutionCost;
 use stacks::chainstate::nakamoto::NakamotoChainState;
 use stacks::chainstate::stacks::db::StacksChainState;
-use stacks_common::types::chainstate::StacksAddress;
-use stacks_common::types::chainstate::StacksPrivateKey;
+use stacks_common::types::chainstate::{StacksAddress, StacksPrivateKey};
 use stacks_common::types::StacksEpochId;
 use stacks_common::util::hash::to_hex;
 
-use crate::config::EventKeyType;
-use crate::config::EventObserverConfig;
+use super::MockamotoNode;
+use crate::config::{EventKeyType, EventObserverConfig};
 use crate::neon_node::PeerThread;
-use crate::tests::make_stacks_transfer;
 use crate::tests::neon_integrations::test_observer;
-use crate::tests::to_addr;
-use crate::Config;
-use crate::ConfigFile;
-
-use super::MockamotoNode;
+use crate::tests::{make_stacks_transfer, to_addr};
+use crate::{Config, ConfigFile};
 
 #[test]
 fn observe_100_blocks() {

From 38af405571fa040b08c8c0aa03c9284d8cef9b87 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Thu, 7 Dec 2023 09:53:00 -0500
Subject: [PATCH 0107/1166] chore: cargo fmt

---
 stacks-common/src/types/chainstate.rs | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/stacks-common/src/types/chainstate.rs b/stacks-common/src/types/chainstate.rs
index 95469e79f6..ac6849dfc6 100644
--- a/stacks-common/src/types/chainstate.rs
+++ b/stacks-common/src/types/chainstate.rs
@@ -14,9 +14,7 @@ use crate::codec::{read_next, write_next, Error as CodecError, StacksMessageCode
 use crate::consts::{FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH};
 use crate::deps_common::bitcoin::util::hash::Sha256dHash;
 use crate::util::hash::{to_hex, DoubleSha256, Hash160, Sha512Trunc256Sum, HASH160_ENCODED_SIZE};
-use crate::util::secp256k1::{
-    MessageSignature, Secp256k1PrivateKey, Secp256k1PublicKey,
-};
+use crate::util::secp256k1::{MessageSignature, Secp256k1PrivateKey, Secp256k1PublicKey};
 use crate::util::uint::Uint256;
 use crate::util::vrf::{VRFProof, VRF_PROOF_ENCODED_SIZE};
 

From e1283efbac86ef900a53b3e6afc92a09aab4af28 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Thu, 7 Dec 2023 09:53:13 -0500
Subject: [PATCH 0108/1166] testing: return the snapshots created in a fork run

---
 stackslib/src/chainstate/burn/db/sortdb.rs | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/stackslib/src/chainstate/burn/db/sortdb.rs b/stackslib/src/chainstate/burn/db/sortdb.rs
index a7577011fc..5b8d4b9c21 100644
--- a/stackslib/src/chainstate/burn/db/sortdb.rs
+++ b/stackslib/src/chainstate/burn/db/sortdb.rs
@@ -8957,13 +8957,14 @@ pub mod tests {
         }
     }
 
-    fn make_fork_run(
+    pub fn make_fork_run(
         db: &mut SortitionDB,
         start_snapshot: &BlockSnapshot,
         length: u64,
         bit_pattern: u8,
-    ) -> () {
+    ) -> Vec<BlockSnapshot> {
         let mut last_snapshot = start_snapshot.clone();
+        let mut new_snapshots = vec![];
         for i in last_snapshot.block_height..(last_snapshot.block_height + length) {
             let snapshot = BlockSnapshot {
                 accumulated_coinbase_ustx: 0,
@@ -8991,6 +8992,7 @@ pub mod tests {
                 canonical_stacks_tip_consensus_hash: ConsensusHash([0u8; 20]),
                 miner_pk_hash: None,
             };
+            new_snapshots.push(snapshot.clone());
             {
                 let mut tx = SortitionHandleTx::begin(db, &last_snapshot.sortition_id).unwrap();
                 let _index_root = tx
@@ -9010,6 +9012,7 @@ pub mod tests {
                 .unwrap()
                 .unwrap();
         }
+        new_snapshots
     }
 
     #[test]

From 63b20394c2d72939277ae6d1b99366a70ef4eb90 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Thu, 7 Dec 2023 09:53:37 -0500
Subject: [PATCH 0109/1166] testing: expand test coverage over more
 NakamotoChainState methods, and add testing for tenure extensions across and
 within sortitions.  Also, require that the caller produce the tenure-change
 and coinbase transactions

---
 .../chainstate/nakamoto/coordinator/tests.rs  | 1229 ++++++++++++++++-
 1 file changed, 1205 insertions(+), 24 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index 312aa86c24..911dd36bc4 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -17,7 +17,7 @@
 use clarity::vm::clarity::ClarityConnection;
 use clarity::vm::types::PrincipalData;
 use rand::prelude::SliceRandom;
-use rand::{thread_rng, RngCore};
+use rand::{thread_rng, Rng, RngCore};
 use stacks_common::address::{AddressHashMode, C32_ADDRESS_VERSION_TESTNET_SINGLESIG};
 use stacks_common::types::chainstate::{
     StacksAddress, StacksBlockId, StacksPrivateKey, StacksPublicKey,
@@ -34,7 +34,7 @@ use crate::chainstate::nakamoto::tests::node::TestSigners;
 use crate::chainstate::nakamoto::{NakamotoBlock, NakamotoChainState};
 use crate::chainstate::stacks::address::PoxAddress;
 use crate::chainstate::stacks::boot::test::{make_pox_4_aggregate_key, make_pox_4_lockup};
-use crate::chainstate::stacks::db::{StacksAccount, StacksChainState};
+use crate::chainstate::stacks::db::{MinerPaymentTxFees, StacksAccount, StacksChainState};
 use crate::chainstate::stacks::{
     CoinbasePayload, StacksTransaction, StacksTransactionSigner, TenureChangeCause,
     TokenTransferMemo, TransactionAnchorMode, TransactionAuth, TransactionPayload,
@@ -88,7 +88,7 @@ fn advance_to_nakamoto(peer: &mut TestPeer, aggregate_public_key: &Point) {
 
 /// Make a peer and transition it into the Nakamoto epoch.
 /// The node needs to be stacking; otherwise, Nakamoto won't activate.
-fn boot_nakamoto(
+pub fn boot_nakamoto(
     test_name: &str,
     mut initial_balances: Vec<(PrincipalData, u64)>,
     aggregate_public_key: Point,
@@ -210,7 +210,7 @@ fn replay_reward_cycle(
     let mut node = peer.stacks_node.take().unwrap();
 
     let sort_tip = SortitionDB::get_canonical_sortition_tip(sortdb.conn()).unwrap();
-    let sort_handle = sortdb.index_handle(&sort_tip);
+    let mut sort_handle = sortdb.index_handle(&sort_tip);
 
     let mut blocks_to_process = stacks_blocks.to_vec();
     blocks_to_process.shuffle(&mut thread_rng());
@@ -220,7 +220,7 @@ fn replay_reward_cycle(
 
         let accepted = Relayer::process_new_nakamoto_block(
             &sortdb,
-            &sort_handle,
+            &mut sort_handle,
             &mut node.chainstate,
             block.clone(),
         )
@@ -245,16 +245,23 @@ 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 (burn_ops, tenure_change, miner_key) =
+    let (burn_ops, mut tenure_change, miner_key) =
         peer.begin_nakamoto_tenure(TenureChangeCause::BlockFound);
     let (_, _, consensus_hash) = peer.next_burnchain_block(burn_ops);
     let vrf_proof = peer.make_nakamoto_vrf_proof(miner_key);
+
+    tenure_change.tenure_consensus_hash = consensus_hash.clone();
+    tenure_change.sortition_consensus_hash = consensus_hash.clone();
+    let tenure_change_tx = peer
+        .miner
+        .make_nakamoto_tenure_change(tenure_change.clone());
+    let coinbase_tx = peer.miner.make_nakamoto_coinbase(None, vrf_proof);
+
     let blocks_and_sizes = peer.make_nakamoto_tenure(
-        &consensus_hash,
-        tenure_change,
+        tenure_change_tx,
+        coinbase_tx,
         &mut test_signers,
-        vrf_proof,
-        |_miner, _chainstate, _sort_dbconn, _count| vec![],
+        |_miner, _chainstate, _sort_dbconn, _blocks| vec![],
     );
     let blocks: Vec<_> = blocks_and_sizes
         .into_iter()
@@ -293,23 +300,30 @@ fn test_simple_nakamoto_coordinator_1_tenure_10_blocks() {
     )
     .unwrap();
 
-    let (burn_ops, tenure_change, miner_key) =
+    let (burn_ops, mut tenure_change, miner_key) =
         peer.begin_nakamoto_tenure(TenureChangeCause::BlockFound);
     let (_, _, consensus_hash) = peer.next_burnchain_block(burn_ops.clone());
     let vrf_proof = peer.make_nakamoto_vrf_proof(miner_key);
 
+    tenure_change.tenure_consensus_hash = consensus_hash.clone();
+    tenure_change.sortition_consensus_hash = consensus_hash.clone();
+
+    let tenure_change_tx = peer
+        .miner
+        .make_nakamoto_tenure_change(tenure_change.clone());
+    let coinbase_tx = peer.miner.make_nakamoto_coinbase(None, vrf_proof);
+
     // do a stx transfer in each block to a given recipient
     let recipient_addr =
         StacksAddress::from_string("ST2YM3J4KQK09V670TD6ZZ1XYNYCNGCWCVTASN5VM").unwrap();
 
     let blocks_and_sizes = peer.make_nakamoto_tenure(
-        &consensus_hash,
-        tenure_change,
+        tenure_change_tx,
+        coinbase_tx,
         &mut test_signers,
-        vrf_proof,
-        |miner, chainstate, sortdb, count| {
-            if count < 10 {
-                debug!("\n\nProduce block {}\n\n", count);
+        |miner, chainstate, sortdb, blocks_so_far| {
+            if blocks_so_far.len() < 10 {
+                debug!("\n\nProduce block {}\n\n", blocks_so_far.len());
 
                 let account = get_account(chainstate, sortdb, &addr);
                 let stx_transfer = make_token_transfer(
@@ -380,7 +394,468 @@ fn test_simple_nakamoto_coordinator_1_tenure_10_blocks() {
     );
 }
 
-/// Mine a 10 Nakamoto tenures with 10 Nakamoto blocks
+/// Test chainstate getters against an instantiated epoch2/Nakamoto chain.
+/// There are 11 epoch2 blocks and 2 nakamto tenure with 10 nakamoto blocks each
+/// Tests:
+/// * get_header_by_coinbase_height
+/// * get_parent_vrf_proof
+/// * get_highest_nakamoto_tenure
+/// * check_first_nakamoto_tenure
+/// * check_valid_consensus_hash
+/// * check_nakamoto_tenure
+/// * check_tenure_continuity
+#[test]
+fn test_nakamoto_chainstate_getters() {
+    let mut test_signers = TestSigners::default();
+    let mut peer = boot_nakamoto(function_name!(), vec![], test_signers.aggregate_public_key);
+    let private_key = peer.config.private_key.clone();
+    let addr = StacksAddress::from_public_keys(
+        C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
+        &AddressHashMode::SerializeP2PKH,
+        1,
+        &vec![StacksPublicKey::from_private(&private_key)],
+    )
+    .unwrap();
+
+    let sort_tip = {
+        let sort_db = peer.sortdb.as_ref().unwrap();
+        SortitionDB::get_canonical_burn_chain_tip(sort_db.conn()).unwrap()
+    };
+    {
+        // scope this to drop the chainstate ref and db tx
+        let chainstate = &peer.stacks_node.as_mut().unwrap().chainstate;
+        let sort_db = peer.sortdb.as_mut().unwrap();
+        let mut sort_tx = sort_db.tx_handle_begin(&sort_tip.sortition_id).unwrap();
+
+        // no tenures yet
+        assert!(
+            NakamotoChainState::get_highest_nakamoto_tenure(chainstate.db(), &mut sort_tx)
+                .unwrap()
+                .is_none()
+        );
+
+        // sortition-existence-check works
+        assert_eq!(
+            NakamotoChainState::check_sortition_exists(&mut sort_tx, &sort_tip.consensus_hash)
+                .unwrap(),
+            (sort_tip.burn_header_hash.clone(), sort_tip.block_height)
+        );
+    }
+
+    let (burn_ops, mut tenure_change, miner_key) =
+        peer.begin_nakamoto_tenure(TenureChangeCause::BlockFound);
+    let (_, _, consensus_hash) = peer.next_burnchain_block(burn_ops.clone());
+    let vrf_proof = peer.make_nakamoto_vrf_proof(miner_key);
+
+    tenure_change.tenure_consensus_hash = consensus_hash.clone();
+    tenure_change.sortition_consensus_hash = consensus_hash.clone();
+    let tenure_change_tx = peer
+        .miner
+        .make_nakamoto_tenure_change(tenure_change.clone());
+    let coinbase_tx = peer.miner.make_nakamoto_coinbase(None, vrf_proof.clone());
+
+    // do a stx transfer in each block to a given recipient
+    let recipient_addr =
+        StacksAddress::from_string("ST2YM3J4KQK09V670TD6ZZ1XYNYCNGCWCVTASN5VM").unwrap();
+
+    let blocks_and_sizes = peer.make_nakamoto_tenure(
+        tenure_change_tx,
+        coinbase_tx,
+        &mut test_signers,
+        |miner, chainstate, sortdb, blocks_so_far| {
+            if blocks_so_far.len() < 10 {
+                debug!("\n\nProduce block {}\n\n", blocks_so_far.len());
+
+                let account = get_account(chainstate, sortdb, &addr);
+                let stx_transfer = make_token_transfer(
+                    chainstate,
+                    sortdb,
+                    &private_key,
+                    account.nonce,
+                    100,
+                    1,
+                    &recipient_addr,
+                );
+
+                vec![stx_transfer]
+            } else {
+                vec![]
+            }
+        },
+    );
+
+    let blocks: Vec<_> = blocks_and_sizes
+        .into_iter()
+        .map(|(block, _, _)| block)
+        .collect();
+
+    let tip = {
+        let chainstate = &peer.stacks_node.as_mut().unwrap().chainstate;
+        let sort_db = peer.sortdb.as_mut().unwrap();
+        NakamotoChainState::get_canonical_block_header(chainstate.db(), sort_db)
+            .unwrap()
+            .unwrap()
+    };
+
+    assert_eq!(
+        tip.anchored_header
+            .as_stacks_nakamoto()
+            .unwrap()
+            .chain_length,
+        21
+    );
+    assert_eq!(
+        tip.anchored_header.as_stacks_nakamoto().unwrap(),
+        &blocks.last().unwrap().header
+    );
+
+    let sort_tip = {
+        let sort_db = peer.sortdb.as_ref().unwrap();
+        SortitionDB::get_canonical_burn_chain_tip(sort_db.conn()).unwrap()
+    };
+    {
+        // scope this to drop the chainstate ref and db tx
+        let chainstate = &mut peer.stacks_node.as_mut().unwrap().chainstate;
+        let sort_db = peer.sortdb.as_ref().unwrap();
+
+        let (mut stacks_db_tx, _) = chainstate.chainstate_tx_begin().unwrap();
+
+        for coinbase_height in 0..=((tip
+            .anchored_header
+            .as_stacks_nakamoto()
+            .unwrap()
+            .chain_length
+            - 10)
+            + 1)
+        {
+            let header_opt = NakamotoChainState::get_header_by_coinbase_height(
+                &mut stacks_db_tx,
+                &tip.index_block_hash(),
+                coinbase_height,
+            )
+            .unwrap();
+            let header = header_opt.expect("No tenure");
+
+            if coinbase_height
+                <= tip
+                    .anchored_header
+                    .as_stacks_nakamoto()
+                    .unwrap()
+                    .chain_length
+                    - 10
+            {
+                // all tenures except the last are epoch2
+                assert!(header.anchored_header.as_stacks_epoch2().is_some());
+            } else {
+                // last tenure is nakamoto
+                assert!(header.anchored_header.as_stacks_nakamoto().is_some());
+            }
+        }
+    }
+
+    debug!("\n======================================\nBegin tests\n===========================================\n");
+    {
+        // scope this to drop the chainstate ref and db tx
+        let chainstate = &peer.stacks_node.as_mut().unwrap().chainstate;
+        let sort_db = peer.sortdb.as_mut().unwrap();
+        let mut sort_tx = sort_db.tx_handle_begin(&sort_tip.sortition_id).unwrap();
+
+        // we now have a tenure, and it confirms the last epoch2 block
+        let highest_tenure =
+            NakamotoChainState::get_highest_nakamoto_tenure(chainstate.db(), &mut sort_tx)
+                .unwrap()
+                .unwrap();
+        assert_eq!(highest_tenure.coinbase_height, 12);
+        assert_eq!(highest_tenure.num_blocks_confirmed, 1);
+        assert_eq!(highest_tenure.tenure_index, 1);
+        assert_eq!(highest_tenure.tenure_id_consensus_hash, consensus_hash);
+        assert_eq!(highest_tenure.sortition_consensus_hash, consensus_hash);
+
+        // confirm that getting the burn block for this highest tenure works
+        let sn = SortitionDB::get_block_snapshot_consensus(
+            sort_tx.tx(),
+            &highest_tenure.tenure_id_consensus_hash,
+        )
+        .unwrap()
+        .unwrap();
+        let (bhh, bhh_height, bhh_ts) = NakamotoChainState::get_tenure_burn_block_info(
+            sort_tx.tx(),
+            false,
+            &highest_tenure.tenure_id_consensus_hash,
+        )
+        .unwrap();
+        assert_eq!(sn.burn_header_hash, bhh);
+        assert_eq!(sn.block_height, bhh_height);
+        assert_eq!(sn.burn_header_timestamp, bhh_ts);
+
+        // this tenure's TC tx is the first-ever TC
+        let tenure_change_payload = blocks[0].get_tenure_change_tx_payload().unwrap().clone();
+
+        assert!(NakamotoChainState::check_first_nakamoto_tenure_change(
+            chainstate.db(),
+            &tenure_change_payload
+        )
+        .unwrap()
+        .is_some());
+        assert!(NakamotoChainState::check_tenure_continuity(
+            chainstate.db(),
+            &mut sort_tx,
+            &blocks[0].header.consensus_hash,
+            &blocks[1].header
+        )
+        .unwrap());
+        assert!(NakamotoChainState::check_valid_consensus_hash(
+            &mut sort_tx,
+            &tenure_change_payload.tenure_consensus_hash
+        )
+        .unwrap()
+        .is_some());
+        assert!(NakamotoChainState::check_valid_consensus_hash(
+            &mut sort_tx,
+            &tenure_change_payload.prev_tenure_consensus_hash
+        )
+        .unwrap()
+        .is_some());
+        assert!(NakamotoChainState::check_valid_consensus_hash(
+            &mut sort_tx,
+            &tenure_change_payload.sortition_consensus_hash
+        )
+        .unwrap()
+        .is_some());
+
+        // this should fail, since it's not idempotent -- the highest tenure _is_ this tenure
+        assert!(NakamotoChainState::check_nakamoto_tenure(
+            chainstate.db(),
+            &mut sort_tx,
+            &blocks[0].header,
+            &tenure_change_payload
+        )
+        .unwrap()
+        .is_none());
+
+        NakamotoChainState::delete_nakamoto_tenure(
+            chainstate.db(),
+            &blocks[0].header.consensus_hash,
+        )
+        .unwrap();
+
+        // drop the highest tenure, so this check can pass
+        assert!(NakamotoChainState::check_nakamoto_tenure(
+            chainstate.db(),
+            &mut sort_tx,
+            &blocks[0].header,
+            &tenure_change_payload
+        )
+        .unwrap()
+        .is_some());
+
+        // restore
+        NakamotoChainState::insert_nakamoto_tenure(
+            chainstate.db(),
+            &blocks[0].header,
+            12,
+            1,
+            &tenure_change_payload,
+        )
+        .unwrap();
+    }
+
+    debug!("\n======================================\nBegin second tenure\n===========================================\n");
+    // begin another tenure
+    let (burn_ops, mut next_tenure_change, miner_key) =
+        peer.begin_nakamoto_tenure(TenureChangeCause::BlockFound);
+
+    // find the txid
+    let mut txid = None;
+    for op in burn_ops.iter() {
+        if let BlockstackOperationType::LeaderBlockCommit(ref op) = &op {
+            txid = Some(op.txid.clone());
+        }
+    }
+    let txid = txid.unwrap();
+
+    let (_, _, next_consensus_hash) = peer.next_burnchain_block(burn_ops.clone());
+    let next_vrf_proof = peer.make_nakamoto_vrf_proof(miner_key);
+
+    next_tenure_change.tenure_consensus_hash = next_consensus_hash.clone();
+    next_tenure_change.sortition_consensus_hash = next_consensus_hash.clone();
+
+    let next_tenure_change_tx = peer
+        .miner
+        .make_nakamoto_tenure_change(next_tenure_change.clone());
+    let next_coinbase_tx = peer
+        .miner
+        .make_nakamoto_coinbase(None, next_vrf_proof.clone());
+
+    // parent VRF proof check
+    let parent_vrf_proof = NakamotoChainState::get_parent_vrf_proof(
+        &peer.stacks_node.as_ref().unwrap().chainstate.db(),
+        peer.sortdb.as_ref().unwrap().conn(),
+        &next_consensus_hash,
+        &txid,
+    )
+    .unwrap();
+    assert_eq!(parent_vrf_proof, vrf_proof);
+
+    // make the second tenure's blocks
+    let blocks_and_sizes = peer.make_nakamoto_tenure(
+        next_tenure_change_tx.clone(),
+        next_coinbase_tx.clone(),
+        &mut test_signers,
+        |miner, chainstate, sortdb, blocks_so_far| {
+            if blocks_so_far.len() < 10 {
+                debug!("\n\nProduce block {}\n\n", blocks_so_far.len());
+
+                let account = get_account(chainstate, sortdb, &addr);
+                let stx_transfer = make_token_transfer(
+                    chainstate,
+                    sortdb,
+                    &private_key,
+                    account.nonce,
+                    100,
+                    1,
+                    &recipient_addr,
+                );
+
+                vec![stx_transfer]
+            } else {
+                vec![]
+            }
+        },
+    );
+
+    let new_blocks: Vec<_> = blocks_and_sizes
+        .into_iter()
+        .map(|(block, _, _)| block)
+        .collect();
+
+    let sort_tip = {
+        let sort_db = peer.sortdb.as_ref().unwrap();
+        SortitionDB::get_canonical_burn_chain_tip(sort_db.conn()).unwrap()
+    };
+    {
+        // scope this to drop the chainstate ref and db tx
+        let chainstate = &peer.stacks_node.as_mut().unwrap().chainstate;
+        let sort_db = peer.sortdb.as_mut().unwrap();
+
+        let mut sort_tx = sort_db.tx_handle_begin(&sort_tip.sortition_id).unwrap();
+
+        // we now have a new highest tenure
+        let highest_tenure =
+            NakamotoChainState::get_highest_nakamoto_tenure(chainstate.db(), &mut sort_tx)
+                .unwrap()
+                .unwrap();
+        assert_eq!(highest_tenure.coinbase_height, 13);
+        assert_eq!(highest_tenure.num_blocks_confirmed, 10);
+        assert_eq!(highest_tenure.tenure_index, 2);
+        assert_eq!(highest_tenure.tenure_id_consensus_hash, next_consensus_hash);
+        assert_eq!(highest_tenure.prev_tenure_id_consensus_hash, consensus_hash);
+        assert_eq!(highest_tenure.sortition_consensus_hash, next_consensus_hash);
+
+        // this tenure's TC tx is NOT the first-ever TC
+        let tenure_change_payload = new_blocks[0]
+            .get_tenure_change_tx_payload()
+            .unwrap()
+            .clone();
+        let old_tenure_change_payload = blocks[0].get_tenure_change_tx_payload().unwrap().clone();
+
+        assert!(NakamotoChainState::check_first_nakamoto_tenure_change(
+            chainstate.db(),
+            &tenure_change_payload
+        )
+        .unwrap()
+        .is_none());
+        assert!(NakamotoChainState::check_tenure_continuity(
+            chainstate.db(),
+            &mut sort_tx,
+            &new_blocks[0].header.consensus_hash,
+            &new_blocks[1].header
+        )
+        .unwrap());
+        assert!(!NakamotoChainState::check_tenure_continuity(
+            chainstate.db(),
+            &mut sort_tx,
+            &blocks[0].header.consensus_hash,
+            &new_blocks[1].header
+        )
+        .unwrap());
+
+        assert!(NakamotoChainState::check_valid_consensus_hash(
+            &mut sort_tx,
+            &tenure_change_payload.tenure_consensus_hash
+        )
+        .unwrap()
+        .is_some());
+        assert!(NakamotoChainState::check_valid_consensus_hash(
+            &mut sort_tx,
+            &tenure_change_payload.prev_tenure_consensus_hash
+        )
+        .unwrap()
+        .is_some());
+        assert!(NakamotoChainState::check_valid_consensus_hash(
+            &mut sort_tx,
+            &tenure_change_payload.sortition_consensus_hash
+        )
+        .unwrap()
+        .is_some());
+        assert!(NakamotoChainState::check_valid_consensus_hash(
+            &mut sort_tx,
+            &old_tenure_change_payload.tenure_consensus_hash
+        )
+        .unwrap()
+        .is_some());
+        assert!(NakamotoChainState::check_valid_consensus_hash(
+            &mut sort_tx,
+            &old_tenure_change_payload.prev_tenure_consensus_hash
+        )
+        .unwrap()
+        .is_some());
+        assert!(NakamotoChainState::check_valid_consensus_hash(
+            &mut sort_tx,
+            &old_tenure_change_payload.sortition_consensus_hash
+        )
+        .unwrap()
+        .is_some());
+
+        NakamotoChainState::delete_nakamoto_tenure(
+            chainstate.db(),
+            &new_blocks[0].header.consensus_hash,
+        )
+        .unwrap();
+
+        assert!(NakamotoChainState::check_nakamoto_tenure(
+            chainstate.db(),
+            &mut sort_tx,
+            &new_blocks[0].header,
+            &tenure_change_payload
+        )
+        .unwrap()
+        .is_some());
+
+        // checks on older confired tenures continue to fail
+        assert!(NakamotoChainState::check_nakamoto_tenure(
+            chainstate.db(),
+            &mut sort_tx,
+            &blocks[0].header,
+            &old_tenure_change_payload
+        )
+        .unwrap()
+        .is_none());
+
+        // restore
+        NakamotoChainState::insert_nakamoto_tenure(
+            chainstate.db(),
+            &new_blocks[0].header,
+            13,
+            2,
+            &tenure_change_payload,
+        )
+        .unwrap();
+    }
+}
+
+/// Mine a 10 Nakamoto tenures with between 1 and 10 Nakamoto blocks each.
+/// Checks the matured mining rewards as well.
 #[test]
 fn test_simple_nakamoto_coordinator_10_tenures_10_blocks() {
     let mut test_signers = TestSigners::default();
@@ -399,27 +874,45 @@ fn test_simple_nakamoto_coordinator_10_tenures_10_blocks() {
     let mut rc_blocks = vec![];
     let mut rc_burn_ops = vec![];
     let mut consensus_hashes = vec![];
+    let mut fee_counts = vec![];
+    let mut total_blocks = 0;
     let stx_miner_key = peer.miner.nakamoto_miner_key();
+    let stx_miner_addr = StacksAddress::from_public_keys(
+        C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
+        &AddressHashMode::SerializeP2PKH,
+        1,
+        &vec![StacksPublicKey::from_private(&private_key)],
+    )
+    .unwrap();
 
     for i in 0..10 {
-        let (burn_ops, tenure_change, miner_key) =
+        let (burn_ops, mut tenure_change, miner_key) =
             peer.begin_nakamoto_tenure(TenureChangeCause::BlockFound);
         let (_, _, consensus_hash) = peer.next_burnchain_block(burn_ops.clone());
         let vrf_proof = peer.make_nakamoto_vrf_proof(miner_key);
 
+        tenure_change.tenure_consensus_hash = consensus_hash.clone();
+        tenure_change.sortition_consensus_hash = consensus_hash.clone();
+
+        let tenure_change_tx = peer
+            .miner
+            .make_nakamoto_tenure_change(tenure_change.clone());
+        let coinbase_tx = peer.miner.make_nakamoto_coinbase(None, vrf_proof);
+
         debug!("Next burnchain block: {}", &consensus_hash);
 
+        let num_blocks: usize = (thread_rng().gen::<usize>() % 10) + 1;
+
         // 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(
-            &consensus_hash,
-            tenure_change,
+            tenure_change_tx,
+            coinbase_tx,
             &mut test_signers,
-            vrf_proof,
-            |miner, chainstate, sortdb, count| {
-                if count < 10 {
+            |miner, chainstate, sortdb, blocks_so_far| {
+                if blocks_so_far.len() < num_blocks {
                     debug!("\n\nProduce block {}\n\n", all_blocks.len());
 
                     let account = get_account(chainstate, sortdb, &addr);
@@ -448,6 +941,9 @@ fn test_simple_nakamoto_coordinator_10_tenures_10_blocks() {
         );
 
         consensus_hashes.push(consensus_hash);
+        fee_counts.push(num_blocks as u128);
+        total_blocks += num_blocks;
+
         let mut blocks: Vec<NakamotoBlock> = blocks_and_sizes
             .into_iter()
             .map(|(block, _, _)| block)
@@ -486,6 +982,691 @@ fn test_simple_nakamoto_coordinator_10_tenures_10_blocks() {
     let chainstate = &mut peer.stacks_node.as_mut().unwrap().chainstate;
     let sort_db = peer.sortdb.as_mut().unwrap();
 
+    // this is sortition height 12, and this miner has earned all 12 of the coinbases
+    // plus the initial per-block mining bonus of 2600 STX, but minus the last three rewards (since
+    // the miner rewards take three sortitions to confirm).
+    //
+    // This is (1000 + 2600) * 10 + 1000 - (3600 * 2 + 1000)
+    //            first 10          block    unmatured rewards
+    //            blocks             11
+    debug!("block fees: {:?}", &fee_counts);
+    let mut expected_coinbase_rewards: u128 = 28800000000;
+    let mut fees_so_far: u128 = 0;
+    for (i, ch) in consensus_hashes.into_iter().enumerate() {
+        let sn = SortitionDB::get_block_snapshot_consensus(sort_db.conn(), &ch)
+            .unwrap()
+            .unwrap();
+
+        if !sn.sortition {
+            continue;
+        }
+        let block_id = StacksBlockId(sn.winning_stacks_block_hash.0);
+
+        let (chainstate_tx, clarity_instance) = chainstate.chainstate_tx_begin().unwrap();
+        let sort_db_tx = sort_db.tx_begin_at_tip();
+
+        let stx_balance = clarity_instance
+            .read_only_connection(&block_id, &chainstate_tx, &sort_db_tx)
+            .with_clarity_db_readonly(|db| db.get_account_stx_balance(&miner.clone().into()));
+
+        // only count matured rewards (last 3 blocks are not mature)
+        let block_fee = if i > 3 {
+            fee_counts[i.saturating_sub(4)]
+        } else {
+            0
+        };
+        let expected_total_tx_fees = fees_so_far + block_fee;
+        let expected_total_coinbase = expected_coinbase_rewards;
+        fees_so_far += block_fee;
+
+        if i == 0 {
+            // first tenure awards the last of the initial mining bonus
+            expected_coinbase_rewards += (1000 + 2600) * 1000000;
+        } else {
+            // subsequent tenures award normal coinbases
+            expected_coinbase_rewards += 1000 * 1000000;
+        }
+
+        eprintln!(
+            "Checking block #{} ({},{}): {} =?= {} + {}",
+            i,
+            &ch,
+            &sn.block_height,
+            stx_balance.amount_unlocked(),
+            expected_total_coinbase,
+            expected_total_tx_fees
+        );
+        assert_eq!(
+            stx_balance.amount_unlocked(),
+            expected_total_coinbase + expected_total_tx_fees
+        );
+    }
+
+    let tip = {
+        let chainstate = &mut peer.stacks_node.as_mut().unwrap().chainstate;
+        let sort_db = peer.sortdb.as_mut().unwrap();
+        NakamotoChainState::get_canonical_block_header(chainstate.db(), sort_db)
+            .unwrap()
+            .unwrap()
+    };
+
+    assert_eq!(
+        tip.anchored_header
+            .as_stacks_nakamoto()
+            .unwrap()
+            .chain_length,
+        (11 + total_blocks) as u64
+    );
+    assert_eq!(
+        tip.anchored_header.as_stacks_nakamoto().unwrap(),
+        &rc_blocks.last().unwrap().last().unwrap().header
+    );
+
+    // verify that matured miner records were in place
+    let mut matured_rewards = vec![];
+    {
+        let chainstate = &mut peer.stacks_node.as_mut().unwrap().chainstate;
+        let sort_db = peer.sortdb.as_mut().unwrap();
+        let (mut chainstate_tx, _) = chainstate.chainstate_tx_begin().unwrap();
+        for i in 0..24 {
+            let matured_reward_opt = NakamotoChainState::get_matured_miner_reward_schedules(
+                &mut chainstate_tx,
+                &tip.index_block_hash(),
+                i,
+            )
+            .unwrap();
+            matured_rewards.push(matured_reward_opt);
+        }
+    }
+    for (i, matured_reward_opt) in matured_rewards[4..].into_iter().enumerate() {
+        let matured_reward = (*matured_reward_opt).clone().unwrap();
+        debug!("{}: {:?}", i, &matured_reward);
+
+        if i < 10 {
+            assert_eq!(matured_reward.parent_miner.coinbase, 3600_000_000);
+        } else {
+            assert_eq!(matured_reward.parent_miner.coinbase, 1000_000_000);
+        }
+
+        if i < 11 {
+            // epoch2
+            assert_eq!(
+                matured_reward.parent_miner.tx_fees,
+                MinerPaymentTxFees::Epoch2 {
+                    anchored: 0,
+                    streamed: 0
+                }
+            );
+        } else if i == 11 {
+            // transition
+            assert_eq!(
+                matured_reward.parent_miner.tx_fees,
+                MinerPaymentTxFees::Nakamoto { parent_fees: 0 }
+            );
+        } else {
+            // nakamoto
+            assert_eq!(
+                matured_reward.parent_miner.tx_fees,
+                MinerPaymentTxFees::Nakamoto {
+                    parent_fees: fee_counts[i - 12]
+                }
+            )
+        }
+
+        assert_eq!(matured_reward.latest_miners.len(), 1);
+
+        let miner_reward = &matured_reward.latest_miners[0];
+
+        if i < 9 {
+            assert_eq!(miner_reward.coinbase, 3600_000_000);
+        } else {
+            assert_eq!(miner_reward.coinbase, 1000_000_000);
+        }
+        if i < 10 {
+            // epoch2
+            assert_eq!(
+                miner_reward.tx_fees,
+                MinerPaymentTxFees::Epoch2 {
+                    anchored: 0,
+                    streamed: 0
+                }
+            );
+        } else if i == 10 {
+            // transition
+            assert_eq!(
+                miner_reward.tx_fees,
+                MinerPaymentTxFees::Nakamoto { parent_fees: 0 }
+            )
+        } else {
+            // nakamoto
+            assert_eq!(
+                miner_reward.tx_fees,
+                MinerPaymentTxFees::Nakamoto {
+                    parent_fees: fee_counts[i - 11]
+                }
+            )
+        }
+    }
+    // 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);
+    for (burn_ops, blocks) in rc_burn_ops.iter().zip(rc_blocks.iter()) {
+        replay_reward_cycle(&mut replay_peer, burn_ops, blocks);
+    }
+
+    let tip = {
+        let chainstate = &mut replay_peer.stacks_node.as_mut().unwrap().chainstate;
+        let sort_db = replay_peer.sortdb.as_mut().unwrap();
+        NakamotoChainState::get_canonical_block_header(chainstate.db(), sort_db)
+            .unwrap()
+            .unwrap()
+    };
+
+    assert_eq!(
+        tip.anchored_header
+            .as_stacks_nakamoto()
+            .unwrap()
+            .chain_length,
+        (11 + total_blocks) as u64
+    );
+    assert_eq!(
+        tip.anchored_header.as_stacks_nakamoto().unwrap(),
+        &rc_blocks.last().unwrap().last().unwrap().header
+    );
+}
+
+/// Mine two tenures across three sortitions, using a tenure-extend to allow the first tenure to
+/// cover the time of two sortitions.
+///
+/// Use a tenure-extend to grant the miner of the first tenure the ability to mine
+/// 20 blocks in the first tenure (10 before the second sortiton, and 10 after)
+#[test]
+fn test_simple_nakamoto_coordinator_2_tenures_3_sortitions() {
+    let mut test_signers = TestSigners::default();
+    let mut peer = boot_nakamoto(function_name!(), vec![], test_signers.aggregate_public_key);
+    let private_key = peer.config.private_key.clone();
+    let addr = StacksAddress::from_public_keys(
+        C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
+        &AddressHashMode::SerializeP2PKH,
+        1,
+        &vec![StacksPublicKey::from_private(&private_key)],
+    )
+    .unwrap();
+
+    let mut rc_burn_ops = vec![];
+    let mut all_blocks = vec![];
+
+    // first tenure
+    let (burn_ops, mut tenure_change, miner_key) =
+        peer.begin_nakamoto_tenure(TenureChangeCause::BlockFound);
+    let (_, _, consensus_hash) = peer.next_burnchain_block(burn_ops.clone());
+    let vrf_proof = peer.make_nakamoto_vrf_proof(miner_key);
+
+    tenure_change.tenure_consensus_hash = consensus_hash.clone();
+    tenure_change.sortition_consensus_hash = consensus_hash.clone();
+    let tenure_change_tx = peer
+        .miner
+        .make_nakamoto_tenure_change(tenure_change.clone());
+    let coinbase_tx = peer.miner.make_nakamoto_coinbase(None, vrf_proof);
+
+    rc_burn_ops.push(burn_ops);
+
+    // do a stx transfer in each block to a given recipient
+    let recipient_addr =
+        StacksAddress::from_string("ST2YM3J4KQK09V670TD6ZZ1XYNYCNGCWCVTASN5VM").unwrap();
+
+    let blocks_and_sizes = peer.make_nakamoto_tenure(
+        tenure_change_tx,
+        coinbase_tx,
+        &mut test_signers,
+        |miner, chainstate, sortdb, blocks_so_far| {
+            if blocks_so_far.len() < 10 {
+                debug!("\n\nProduce block {}\n\n", blocks_so_far.len());
+
+                let account = get_account(chainstate, sortdb, &addr);
+                let stx_transfer = make_token_transfer(
+                    chainstate,
+                    sortdb,
+                    &private_key,
+                    account.nonce,
+                    100,
+                    1,
+                    &recipient_addr,
+                );
+
+                vec![stx_transfer]
+            } else {
+                vec![]
+            }
+        },
+    );
+
+    let blocks: Vec<_> = blocks_and_sizes
+        .into_iter()
+        .map(|(block, _, _)| block)
+        .collect();
+
+    all_blocks.append(&mut blocks.clone());
+
+    let tip = {
+        let chainstate = &mut peer.stacks_node.as_mut().unwrap().chainstate;
+        let sort_db = peer.sortdb.as_mut().unwrap();
+        NakamotoChainState::get_canonical_block_header(chainstate.db(), sort_db)
+            .unwrap()
+            .unwrap()
+    };
+
+    assert_eq!(
+        tip.anchored_header
+            .as_stacks_nakamoto()
+            .unwrap()
+            .chain_length,
+        21
+    );
+    assert_eq!(
+        tip.anchored_header.as_stacks_nakamoto().unwrap(),
+        &blocks.last().unwrap().header
+    );
+
+    // highest tenure is our tenure-change
+    let (highest_tenure, sort_tip) = {
+        let chainstate = &mut peer.stacks_node.as_mut().unwrap().chainstate;
+        let sort_db = peer.sortdb.as_mut().unwrap();
+        let tip = SortitionDB::get_canonical_burn_chain_tip(sort_db.conn()).unwrap();
+        let mut sort_handle = sort_db.index_handle(&tip.sortition_id);
+        let tenure =
+            NakamotoChainState::get_highest_nakamoto_tenure(chainstate.db(), &mut sort_handle)
+                .unwrap()
+                .unwrap();
+        (tenure, tip)
+    };
+    assert_eq!(highest_tenure.tenure_id_consensus_hash, tip.consensus_hash);
+    assert_eq!(
+        highest_tenure.sortition_consensus_hash,
+        sort_tip.consensus_hash
+    );
+    assert!(tip.consensus_hash == sort_tip.consensus_hash);
+    assert_eq!(highest_tenure.coinbase_height, 12);
+    assert_eq!(highest_tenure.cause, TenureChangeCause::BlockFound);
+    assert_eq!(highest_tenure.tenure_index, 1);
+    assert_eq!(highest_tenure.num_blocks_confirmed, 1);
+
+    // extend first tenure
+    let (burn_ops, tenure_change_extend, miner_key) =
+        peer.begin_nakamoto_tenure(TenureChangeCause::Extended);
+    let (_, _, next_consensus_hash) = peer.next_burnchain_block(burn_ops.clone());
+
+    rc_burn_ops.push(burn_ops);
+
+    // extending first tenure
+    let tenure_change_extend = tenure_change.extend(
+        next_consensus_hash,
+        blocks.last().cloned().unwrap().header.block_id(),
+        blocks.len() as u32,
+    );
+    let tenure_change_tx = peer
+        .miner
+        .make_nakamoto_tenure_change(tenure_change_extend.clone());
+
+    let blocks_and_sizes = peer.make_nakamoto_tenure_extension(
+        tenure_change_tx,
+        &mut test_signers,
+        |miner, chainstate, sortdb, blocks_so_far| {
+            if blocks_so_far.len() < 10 {
+                debug!("\n\nProduce extended block {}\n\n", blocks_so_far.len());
+
+                let account = get_account(chainstate, sortdb, &addr);
+                let stx_transfer = make_token_transfer(
+                    chainstate,
+                    sortdb,
+                    &private_key,
+                    account.nonce,
+                    100,
+                    1,
+                    &recipient_addr,
+                );
+
+                vec![stx_transfer]
+            } else {
+                vec![]
+            }
+        },
+    );
+
+    let blocks: Vec<_> = blocks_and_sizes
+        .into_iter()
+        .map(|(block, _, _)| block)
+        .collect();
+
+    all_blocks.append(&mut blocks.clone());
+
+    let tip = {
+        let chainstate = &mut peer.stacks_node.as_mut().unwrap().chainstate;
+        let sort_db = peer.sortdb.as_mut().unwrap();
+        NakamotoChainState::get_canonical_block_header(chainstate.db(), sort_db)
+            .unwrap()
+            .unwrap()
+    };
+
+    // chain grew
+    assert_eq!(
+        tip.anchored_header
+            .as_stacks_nakamoto()
+            .unwrap()
+            .chain_length,
+        31
+    );
+    assert_eq!(
+        tip.anchored_header.as_stacks_nakamoto().unwrap(),
+        &blocks.last().unwrap().header
+    );
+
+    // highest tenure is our tenure-extend
+    let (highest_tenure, sort_tip) = {
+        let chainstate = &mut peer.stacks_node.as_mut().unwrap().chainstate;
+        let sort_db = peer.sortdb.as_mut().unwrap();
+        let tip = SortitionDB::get_canonical_burn_chain_tip(sort_db.conn()).unwrap();
+        let mut sort_handle = sort_db.index_handle(&tip.sortition_id);
+        let tenure =
+            NakamotoChainState::get_highest_nakamoto_tenure(chainstate.db(), &mut sort_handle)
+                .unwrap()
+                .unwrap();
+        (tenure, tip)
+    };
+    assert_eq!(highest_tenure.tenure_id_consensus_hash, tip.consensus_hash);
+    assert_eq!(
+        highest_tenure.sortition_consensus_hash,
+        sort_tip.consensus_hash
+    );
+    assert!(tip.consensus_hash != sort_tip.consensus_hash);
+    assert_eq!(highest_tenure.coinbase_height, 12);
+    assert_eq!(highest_tenure.cause, TenureChangeCause::Extended);
+    assert_eq!(highest_tenure.tenure_index, 2);
+    assert_eq!(highest_tenure.num_blocks_confirmed, 10);
+
+    // second tenure
+    let (burn_ops, mut tenure_change, miner_key) =
+        peer.begin_nakamoto_tenure(TenureChangeCause::BlockFound);
+    let (_, _, consensus_hash) = peer.next_burnchain_block(burn_ops.clone());
+    let vrf_proof = peer.make_nakamoto_vrf_proof(miner_key);
+
+    tenure_change.tenure_consensus_hash = consensus_hash.clone();
+    tenure_change.sortition_consensus_hash = consensus_hash.clone();
+
+    let tenure_change_tx = peer
+        .miner
+        .make_nakamoto_tenure_change(tenure_change.clone());
+    let coinbase_tx = peer.miner.make_nakamoto_coinbase(None, vrf_proof);
+
+    rc_burn_ops.push(burn_ops);
+
+    // do a stx transfer in each block to a given recipient
+    let recipient_addr =
+        StacksAddress::from_string("ST2YM3J4KQK09V670TD6ZZ1XYNYCNGCWCVTASN5VM").unwrap();
+
+    let blocks_and_sizes = peer.make_nakamoto_tenure(
+        tenure_change_tx,
+        coinbase_tx,
+        &mut test_signers,
+        |miner, chainstate, sortdb, blocks_so_far| {
+            if blocks_so_far.len() < 10 {
+                debug!("\n\nProduce block {}\n\n", blocks_so_far.len());
+
+                let account = get_account(chainstate, sortdb, &addr);
+                let stx_transfer = make_token_transfer(
+                    chainstate,
+                    sortdb,
+                    &private_key,
+                    account.nonce,
+                    100,
+                    1,
+                    &recipient_addr,
+                );
+
+                vec![stx_transfer]
+            } else {
+                vec![]
+            }
+        },
+    );
+
+    let blocks: Vec<_> = blocks_and_sizes
+        .into_iter()
+        .map(|(block, _, _)| block)
+        .collect();
+
+    all_blocks.append(&mut blocks.clone());
+
+    let tip = {
+        let chainstate = &mut peer.stacks_node.as_mut().unwrap().chainstate;
+        let sort_db = peer.sortdb.as_mut().unwrap();
+        NakamotoChainState::get_canonical_block_header(chainstate.db(), sort_db)
+            .unwrap()
+            .unwrap()
+    };
+
+    assert_eq!(
+        tip.anchored_header
+            .as_stacks_nakamoto()
+            .unwrap()
+            .chain_length,
+        41
+    );
+    assert_eq!(
+        tip.anchored_header.as_stacks_nakamoto().unwrap(),
+        &blocks.last().unwrap().header
+    );
+
+    // highest tenure is our new tenure-change
+    let (highest_tenure, sort_tip) = {
+        let chainstate = &mut peer.stacks_node.as_mut().unwrap().chainstate;
+        let sort_db = peer.sortdb.as_mut().unwrap();
+        let tip = SortitionDB::get_canonical_burn_chain_tip(sort_db.conn()).unwrap();
+        let mut sort_handle = sort_db.index_handle(&tip.sortition_id);
+        let tenure =
+            NakamotoChainState::get_highest_nakamoto_tenure(chainstate.db(), &mut sort_handle)
+                .unwrap()
+                .unwrap();
+        (tenure, tip)
+    };
+    assert_eq!(highest_tenure.tenure_id_consensus_hash, tip.consensus_hash);
+    assert_eq!(
+        highest_tenure.sortition_consensus_hash,
+        sort_tip.consensus_hash
+    );
+    assert!(tip.consensus_hash == sort_tip.consensus_hash);
+    assert_eq!(highest_tenure.coinbase_height, 13);
+    assert_eq!(highest_tenure.cause, TenureChangeCause::BlockFound);
+    assert_eq!(highest_tenure.tenure_index, 3);
+    assert_eq!(highest_tenure.num_blocks_confirmed, 20);
+
+    // 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);
+    replay_reward_cycle(&mut replay_peer, &rc_burn_ops, &all_blocks);
+
+    let tip = {
+        let chainstate = &mut replay_peer.stacks_node.as_mut().unwrap().chainstate;
+        let sort_db = replay_peer.sortdb.as_mut().unwrap();
+        NakamotoChainState::get_canonical_block_header(chainstate.db(), sort_db)
+            .unwrap()
+            .unwrap()
+    };
+
+    assert_eq!(
+        tip.anchored_header
+            .as_stacks_nakamoto()
+            .unwrap()
+            .chain_length,
+        41
+    );
+    assert_eq!(
+        tip.anchored_header.as_stacks_nakamoto().unwrap(),
+        &blocks.last().unwrap().header
+    );
+}
+
+/// Mine a 10 Nakamoto tenures with 10 Nakamoto blocks, but do a tenure-extend in each block
+#[test]
+fn test_simple_nakamoto_coordinator_10_tenures_and_extensions_10_blocks() {
+    let mut test_signers = TestSigners::default();
+    let mut peer = boot_nakamoto(function_name!(), vec![], test_signers.aggregate_public_key);
+    let private_key = peer.config.private_key.clone();
+    let addr = StacksAddress::from_public_keys(
+        C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
+        &AddressHashMode::SerializeP2PKH,
+        1,
+        &vec![StacksPublicKey::from_private(&private_key)],
+    )
+    .unwrap();
+
+    let mut all_blocks = vec![];
+    let mut all_burn_ops = vec![];
+    let mut rc_blocks = vec![];
+    let mut rc_burn_ops = vec![];
+    let mut consensus_hashes = vec![];
+    let stx_miner_key = peer.miner.nakamoto_miner_key();
+
+    for i in 0..10 {
+        let (burn_ops, mut tenure_change, miner_key) =
+            peer.begin_nakamoto_tenure(TenureChangeCause::BlockFound);
+        let (_, _, consensus_hash) = peer.next_burnchain_block(burn_ops.clone());
+        let vrf_proof = peer.make_nakamoto_vrf_proof(miner_key);
+
+        tenure_change.tenure_consensus_hash = consensus_hash.clone();
+        tenure_change.sortition_consensus_hash = consensus_hash.clone();
+
+        let tenure_change_tx = peer
+            .miner
+            .make_nakamoto_tenure_change(tenure_change.clone());
+        let coinbase_tx = peer.miner.make_nakamoto_coinbase(None, vrf_proof);
+
+        debug!("Next burnchain block: {}", &consensus_hash);
+
+        // 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,
+            &mut test_signers,
+            |miner, chainstate, sortdb, blocks_so_far| {
+                if blocks_so_far.len() < 10 {
+                    debug!("\n\nProduce block {}\n\n", blocks_so_far.len());
+
+                    let account = get_account(chainstate, sortdb, &addr);
+
+                    let stx_transfer = make_token_transfer(
+                        chainstate,
+                        sortdb,
+                        &private_key,
+                        account.nonce,
+                        100,
+                        1,
+                        &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()
+                        .map(|(block, _size, _cost)| block.header.block_id());
+
+                    let mut txs = vec![];
+                    if let Some(last_block) = last_block_opt.as_ref() {
+                        let tenure_extension = tenure_change.extend(
+                            consensus_hash.clone(),
+                            last_block.clone(),
+                            blocks_so_far.len() as u32,
+                        );
+                        let tenure_extension_tx =
+                            miner.make_nakamoto_tenure_change(tenure_extension.clone());
+                        txs.push(tenure_extension_tx);
+                    }
+                    txs.append(&mut vec![stx_transfer, aggregate_tx]);
+                    txs
+                } else {
+                    vec![]
+                }
+            },
+        );
+        consensus_hashes.push(consensus_hash);
+        let mut blocks: Vec<NakamotoBlock> = blocks_and_sizes
+            .into_iter()
+            .map(|(block, _, _)| block)
+            .collect();
+
+        // check that our tenure-extends have been getting applied
+        let (highest_tenure, sort_tip) = {
+            let chainstate = &mut peer.stacks_node.as_mut().unwrap().chainstate;
+            let sort_db = peer.sortdb.as_mut().unwrap();
+            let tip = SortitionDB::get_canonical_burn_chain_tip(sort_db.conn()).unwrap();
+            let mut sort_handle = sort_db.index_handle(&tip.sortition_id);
+            let tenure =
+                NakamotoChainState::get_highest_nakamoto_tenure(chainstate.db(), &mut sort_handle)
+                    .unwrap()
+                    .unwrap();
+            (tenure, tip)
+        };
+
+        let last_block = blocks.last().as_ref().cloned().unwrap();
+        assert_eq!(
+            highest_tenure.tenure_id_consensus_hash,
+            last_block.header.consensus_hash
+        );
+        assert_eq!(
+            highest_tenure.sortition_consensus_hash,
+            sort_tip.consensus_hash
+        );
+        assert!(last_block.header.consensus_hash == sort_tip.consensus_hash);
+        assert_eq!(highest_tenure.coinbase_height, 12 + i);
+        assert_eq!(highest_tenure.cause, TenureChangeCause::Extended);
+        assert_eq!(highest_tenure.tenure_index, 8 * (i + 1));
+        assert_eq!(
+            highest_tenure.num_blocks_confirmed,
+            (blocks.len() as u32) - 1
+        );
+
+        // if we're starting a new reward cycle, then save the current one
+        let tip = {
+            let sort_db = peer.sortdb.as_mut().unwrap();
+            SortitionDB::get_canonical_burn_chain_tip(sort_db.conn()).unwrap()
+        };
+        if peer
+            .config
+            .burnchain
+            .is_reward_cycle_start(tip.block_height)
+        {
+            rc_blocks.push(all_blocks.clone());
+            rc_burn_ops.push(all_burn_ops.clone());
+
+            all_burn_ops.clear();
+            all_blocks.clear();
+        }
+
+        all_blocks.append(&mut blocks);
+        all_burn_ops.push(burn_ops);
+    }
+
+    rc_blocks.push(all_blocks.clone());
+    rc_burn_ops.push(all_burn_ops.clone());
+
+    all_burn_ops.clear();
+    all_blocks.clear();
+
+    // in nakamoto, tx fees are rewarded by the next tenure, so the
+    // scheduled rewards come 1 tenure after the coinbase reward matures
+    let miner = p2pkh_from(&stx_miner_key);
+    let chainstate = &mut peer.stacks_node.as_mut().unwrap().chainstate;
+    let sort_db = peer.sortdb.as_mut().unwrap();
+
     // this is sortition height 12, and this miner has earned all 12 of the coinbases
     // plus the initial per-block mining bonus of 2600 STX, but minus the last three rewards (since
     // the miner rewards take three sortitions to confirm).

From 2fe8fb3ce32b01942e9dce7d841962da7168b515 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Thu, 7 Dec 2023 09:54:16 -0500
Subject: [PATCH 0110/1166] chore: alter the Nakamoto block miner so it just
 takes the coinbase and tenure-change transactions

---
 stackslib/src/chainstate/nakamoto/miner.rs | 171 +++++++++++++--------
 1 file changed, 103 insertions(+), 68 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/miner.rs b/stackslib/src/chainstate/nakamoto/miner.rs
index 911d015b8a..82b6d34b93 100644
--- a/stackslib/src/chainstate/nakamoto/miner.rs
+++ b/stackslib/src/chainstate/nakamoto/miner.rs
@@ -38,7 +38,6 @@ use stacks_common::types::StacksPublicKeyBuffer;
 use stacks_common::util::get_epoch_time_ms;
 use stacks_common::util::hash::{Hash160, MerkleTree, Sha512Trunc256Sum};
 use stacks_common::util::secp256k1::{MessageSignature, Secp256k1PrivateKey};
-use stacks_common::util::vrf::*;
 
 use crate::burnchains::{PrivateKey, PublicKey};
 use crate::chainstate::burn::db::sortdb::{SortitionDB, SortitionDBConn, SortitionHandleTx};
@@ -74,12 +73,29 @@ use crate::monitoring::{
 use crate::net::relay::Relayer;
 use crate::net::Error as net_error;
 
-/// New tenure information
-pub struct NakamotoTenureStart {
-    /// coinbase transaction for this miner
-    pub coinbase_tx: StacksTransaction,
-    /// VRF proof for this miner
-    pub vrf_proof: VRFProof,
+/// Nakamaoto tenure information
+pub struct NakamotoTenureInfo {
+    /// Coinbase tx, if this is a new tenure
+    pub coinbase_tx: Option<StacksTransaction>,
+    /// Tenure change transaction from Stackers
+    pub tenure_change_tx: Option<StacksTransaction>,
+}
+
+impl NakamotoTenureInfo {
+    pub fn cause(&self) -> Option<TenureChangeCause> {
+        self.tenure_change_tx
+            .as_ref()
+            .map(|tx| tx.try_as_tenure_change().map(|payload| payload.cause))
+            .flatten()
+    }
+
+    pub fn tenure_change_tx(&self) -> Option<&StacksTransaction> {
+        self.tenure_change_tx.as_ref()
+    }
+
+    pub fn coinbase_tx(&self) -> Option<&StacksTransaction> {
+        self.coinbase_tx.as_ref()
+    }
 }
 
 pub struct NakamotoBlockBuilder {
@@ -87,8 +103,10 @@ pub struct NakamotoBlockBuilder {
     epoch2_parent_header: Option<(StacksBlockHeader, ConsensusHash)>,
     /// if this is building atop an epoch 3 block, then this is that block's header
     nakamoto_parent_header: Option<NakamotoBlockHeader>,
-    /// VRF proof, if needed
-    vrf_proof: Option<VRFProof>,
+    /// Signed coinbase tx, if starting a new tenure
+    coinbase_tx: Option<StacksTransaction>,
+    /// Tenure change tx, if starting or extending a tenure
+    tenure_tx: Option<StacksTransaction>,
     /// Total burn this block represents
     total_burn: u64,
     /// parent block-commit hash value
@@ -115,8 +133,8 @@ pub struct MinerTenureInfo<'a> {
     pub parent_header_hash: BlockHeaderHash,
     pub parent_stacks_block_height: u64,
     pub parent_burn_block_height: u32,
-    pub tenure_start: bool,
-    pub tenure_height: u64,
+    pub coinbase_height: u64,
+    pub cause: Option<TenureChangeCause>,
 }
 
 impl NakamotoBlockBuilder {
@@ -124,16 +142,18 @@ impl NakamotoBlockBuilder {
     pub fn new_tenure_from_nakamoto_parent(
         parent_tenure_id: &StacksBlockId,
         parent: &NakamotoBlockHeader,
-        consensus_hash: &ConsensusHash,
+        tenure_id_consensus_hash: &ConsensusHash,
         total_burn: u64,
-        proof: &VRFProof,
+        tenure_change: &StacksTransaction,
+        coinbase: &StacksTransaction,
     ) -> NakamotoBlockBuilder {
         let parent_commit_hash_value = BlockHeaderHash(parent_tenure_id.0.clone());
         NakamotoBlockBuilder {
             epoch2_parent_header: None,
             nakamoto_parent_header: Some(parent.clone()),
             total_burn,
-            vrf_proof: Some(proof.clone()),
+            coinbase_tx: Some(coinbase.clone()),
+            tenure_tx: Some(tenure_change.clone()),
             parent_commit_hash_value,
             matured_miner_rewards_opt: None,
             bytes_so_far: 0,
@@ -141,7 +161,7 @@ impl NakamotoBlockBuilder {
             header: NakamotoBlockHeader::from_parent_empty(
                 parent.chain_length + 1,
                 total_burn,
-                consensus_hash.clone(),
+                tenure_id_consensus_hash.clone(),
                 parent.block_id(),
             ),
         }
@@ -150,15 +170,17 @@ impl NakamotoBlockBuilder {
     /// Make a block builder atop a Nakamoto parent for a new block within a tenure
     pub fn continue_tenure_from_nakamoto_parent(
         parent: &NakamotoBlockHeader,
-        consensus_hash: &ConsensusHash,
+        tenure_id_consensus_hash: &ConsensusHash,
         total_burn: u64,
+        tenure_extend: Option<&StacksTransaction>,
     ) -> NakamotoBlockBuilder {
         let parent_commit_hash_value = BlockHeaderHash(parent.block_id().0.clone());
         NakamotoBlockBuilder {
             epoch2_parent_header: None,
             nakamoto_parent_header: Some(parent.clone()),
             total_burn,
-            vrf_proof: None,
+            coinbase_tx: None,
+            tenure_tx: tenure_extend.cloned(),
             parent_commit_hash_value,
             matured_miner_rewards_opt: None,
             bytes_so_far: 0,
@@ -166,7 +188,7 @@ impl NakamotoBlockBuilder {
             header: NakamotoBlockHeader::from_parent_empty(
                 parent.chain_length + 1,
                 total_burn,
-                consensus_hash.clone(),
+                tenure_id_consensus_hash.clone(),
                 parent.block_id(),
             ),
         }
@@ -175,16 +197,18 @@ impl NakamotoBlockBuilder {
     /// Make a block builder atop an epoch 2 parent for a new tenure
     pub fn new_tenure_from_epoch2_parent(
         parent: &StacksBlockHeader,
-        parent_consensus_hash: &ConsensusHash,
-        consensus_hash: &ConsensusHash,
+        parent_tenure_id_consensus_hash: &ConsensusHash,
+        tenure_id_consensus_hash: &ConsensusHash,
         total_burn: u64,
-        proof: &VRFProof,
+        tenure_change: &StacksTransaction,
+        coinbase: &StacksTransaction,
     ) -> NakamotoBlockBuilder {
         NakamotoBlockBuilder {
-            epoch2_parent_header: Some((parent.clone(), parent_consensus_hash.clone())),
+            epoch2_parent_header: Some((parent.clone(), parent_tenure_id_consensus_hash.clone())),
             nakamoto_parent_header: None,
             total_burn,
-            vrf_proof: Some(proof.clone()),
+            coinbase_tx: Some(coinbase.clone()),
+            tenure_tx: Some(tenure_change.clone()),
             parent_commit_hash_value: parent.block_hash(),
             matured_miner_rewards_opt: None,
             bytes_so_far: 0,
@@ -192,19 +216,23 @@ impl NakamotoBlockBuilder {
             header: NakamotoBlockHeader::from_parent_empty(
                 parent.total_work.work + 1,
                 total_burn,
-                consensus_hash.clone(),
-                StacksBlockId::new(parent_consensus_hash, &parent.block_hash()),
+                tenure_id_consensus_hash.clone(),
+                StacksBlockId::new(parent_tenure_id_consensus_hash, &parent.block_hash()),
             ),
         }
     }
 
     /// Make a block builder from genesis (testing only)
-    pub fn new_tenure_from_genesis(proof: &VRFProof) -> NakamotoBlockBuilder {
+    pub fn new_tenure_from_genesis(
+        tenure_change: &StacksTransaction,
+        coinbase: &StacksTransaction,
+    ) -> NakamotoBlockBuilder {
         NakamotoBlockBuilder {
             epoch2_parent_header: None,
             nakamoto_parent_header: None,
             total_burn: 0,
-            vrf_proof: Some(proof.clone()),
+            coinbase_tx: Some(coinbase.clone()),
+            tenure_tx: Some(tenure_change.clone()),
             parent_commit_hash_value: FIRST_STACKS_BLOCK_HASH.clone(),
             matured_miner_rewards_opt: None,
             bytes_so_far: 0,
@@ -221,31 +249,36 @@ impl NakamotoBlockBuilder {
         parent_tenure_id: &StacksBlockId,
         // Stacks header we're building off of.
         parent_stacks_header: &StacksHeaderInfo,
-        // consensus hash of this tenure's burnchain block
-        consensus_hash: &ConsensusHash,
+        // consensus hash of this tenure's burnchain block. This is the consensus hash that goes
+        // into the block header.
+        tenure_id_consensus_hash: &ConsensusHash,
         // total BTC burn so far
         total_burn: u64,
-        // VRF proof, if we're starting a _new_ tenure (instead of continuing an existing one)
-        vrf_proof_opt: Option<VRFProof>,
+        // tenure change, if we're starting or extending a tenure
+        tenure_change: Option<&StacksTransaction>,
+        // coinbase, if we're starting a new tenure
+        coinbase: Option<&StacksTransaction>,
     ) -> Result<NakamotoBlockBuilder, Error> {
         let builder = if let Some(parent_nakamoto_header) =
             parent_stacks_header.anchored_header.as_stacks_nakamoto()
         {
             // building atop a nakamoto block
             // new tenure?
-            if let Some(vrf_proof) = vrf_proof_opt.as_ref() {
+            if coinbase.is_some() && tenure_change.is_some() {
                 NakamotoBlockBuilder::new_tenure_from_nakamoto_parent(
                     parent_tenure_id,
                     parent_nakamoto_header,
-                    consensus_hash,
+                    tenure_id_consensus_hash,
                     total_burn,
-                    vrf_proof,
+                    tenure_change.ok_or(Error::ExpectedTenureChange)?,
+                    coinbase.ok_or(Error::ExpectedTenureChange)?,
                 )
             } else {
                 NakamotoBlockBuilder::continue_tenure_from_nakamoto_parent(
                     parent_nakamoto_header,
-                    consensus_hash,
+                    tenure_id_consensus_hash,
                     total_burn,
+                    tenure_change,
                 )
             }
         } else if let Some(parent_epoch2_header) =
@@ -253,17 +286,18 @@ impl NakamotoBlockBuilder {
         {
             // building atop a stacks 2.x block.
             // we are necessarily starting a new tenure
-            if let Some(vrf_proof) = vrf_proof_opt.as_ref() {
+            if tenure_change.is_some() && coinbase.is_some() {
                 NakamotoBlockBuilder::new_tenure_from_epoch2_parent(
                     parent_epoch2_header,
                     &parent_stacks_header.consensus_hash,
-                    consensus_hash,
+                    tenure_id_consensus_hash,
                     total_burn,
-                    vrf_proof,
+                    tenure_change.ok_or(Error::ExpectedTenureChange)?,
+                    coinbase.ok_or(Error::ExpectedTenureChange)?,
                 )
             } else {
                 // not allowed
-                warn!("Failed to start a Nakamoto tenure atop a Stacks 2.x block -- missing a VRF proof");
+                warn!("Failed to start a Nakamoto tenure atop a Stacks 2.x block -- missing a coinbase and/or tenure");
                 return Err(Error::ExpectedTenureChange);
             }
         } else {
@@ -284,7 +318,7 @@ impl NakamotoBlockBuilder {
         &self,
         chainstate: &'a mut StacksChainState,
         burn_dbconn: &'a SortitionDBConn,
-        tenure_start: bool,
+        cause: Option<TenureChangeCause>,
     ) -> Result<MinerTenureInfo<'a>, Error> {
         debug!("Nakamoto miner tenure begin");
 
@@ -296,7 +330,7 @@ impl NakamotoBlockBuilder {
 
         let mainnet = chainstate.config().mainnet;
 
-        let (chain_tip, parent_consensus_hash, parent_header_hash) =
+        let (chain_tip, parent_tenure_id_consensus_hash, parent_header_hash) =
             if let Some(nakamoto_parent_header) = self.nakamoto_parent_header.as_ref() {
                 // parent is a nakamoto block
                 let parent_header_info = NakamotoChainState::get_block_header(
@@ -354,12 +388,12 @@ impl NakamotoBlockBuilder {
                 )
             };
 
-        let tenure_height = if let Ok(Some(parent_tenure_height)) =
-            NakamotoChainState::get_tenure_height(
+        let coinbase_height = if let Ok(Some(parent_coinbase_height)) =
+            NakamotoChainState::get_coinbase_height(
                 chainstate.db(),
-                &StacksBlockId::new(&parent_consensus_hash, &parent_header_hash),
+                &StacksBlockId::new(&parent_tenure_id_consensus_hash, &parent_header_hash),
             ) {
-            parent_tenure_height
+            parent_coinbase_height
                 .checked_add(1)
                 .expect("Blockchain overflow")
         } else {
@@ -375,12 +409,12 @@ impl NakamotoBlockBuilder {
             burn_tip,
             burn_tip_height,
             mainnet,
-            parent_consensus_hash,
+            parent_consensus_hash: parent_tenure_id_consensus_hash,
             parent_header_hash,
             parent_stacks_block_height: chain_tip.stacks_block_height,
             parent_burn_block_height: chain_tip.burn_header_height,
-            tenure_start,
-            tenure_height,
+            cause,
+            coinbase_height,
         })
     }
 
@@ -409,8 +443,9 @@ impl NakamotoBlockBuilder {
             info.parent_burn_block_height,
             info.burn_tip,
             info.burn_tip_height,
-            info.tenure_start,
-            info.tenure_height,
+            info.cause == Some(TenureChangeCause::BlockFound),
+            info.coinbase_height,
+            info.cause == Some(TenureChangeCause::Extended),
         )?;
         self.matured_miner_rewards_opt = matured_miner_rewards_opt;
         Ok(clarity_tx)
@@ -495,11 +530,11 @@ impl NakamotoBlockBuilder {
         parent_tenure_id: &StacksBlockId,
         // Stacks header we're building off of.
         parent_stacks_header: &StacksHeaderInfo,
-        // consensus hash of this block
-        consensus_hash: &ConsensusHash,
+        // tenure ID consensus hash of this block
+        tenure_id_consensus_hash: &ConsensusHash,
         // the burn so far on the burnchain (i.e. from the last burnchain block)
         total_burn: u64,
-        new_tenure_info: Option<NakamotoTenureStart>,
+        tenure_info: NakamotoTenureInfo,
         settings: BlockBuilderSettings,
         event_observer: Option<&dyn MemPoolEventDispatcher>,
     ) -> Result<(NakamotoBlock, ExecutionCost, u64), Error> {
@@ -519,15 +554,16 @@ impl NakamotoBlockBuilder {
         let mut builder = NakamotoBlockBuilder::new_from_parent(
             parent_tenure_id,
             parent_stacks_header,
-            consensus_hash,
+            tenure_id_consensus_hash,
             total_burn,
-            new_tenure_info.as_ref().map(|info| info.vrf_proof.clone()),
+            tenure_info.tenure_change_tx(),
+            tenure_info.coinbase_tx(),
         )?;
 
         let ts_start = get_epoch_time_ms();
 
         let mut miner_tenure_info =
-            builder.load_tenure_info(&mut chainstate, burn_dbconn, new_tenure_info.is_some())?;
+            builder.load_tenure_info(&mut chainstate, burn_dbconn, tenure_info.cause())?;
         let mut tenure_tx = builder.tenure_begin(burn_dbconn, &mut miner_tenure_info)?;
 
         let block_limit = tenure_tx
@@ -539,7 +575,8 @@ impl NakamotoBlockBuilder {
             &mut builder,
             mempool,
             parent_stacks_header.stacks_block_height,
-            new_tenure_info.as_ref().map(|info| &info.coinbase_tx),
+            tenure_info.tenure_change_tx(),
+            tenure_info.coinbase_tx(),
             settings,
             event_observer,
             ASTRules::PrecheckSize,
@@ -606,19 +643,17 @@ impl NakamotoBlockBuilder {
         debug!("Build Nakamoto block from {} transactions", txs.len());
         let (mut chainstate, _) = chainstate_handle.reopen()?;
 
-        let new_tenure = txs
-            .iter()
-            .find(|txn| {
-                if let TransactionPayload::TenureChange(..) = txn.payload {
-                    true
-                } else {
-                    false
-                }
-            })
-            .is_some();
+        let mut tenure_cause = None;
+        for tx in txs.iter() {
+            let TransactionPayload::TenureChange(payload) = &tx.payload else {
+                continue;
+            };
+            tenure_cause = Some(payload.cause);
+            break;
+        }
 
         let mut miner_tenure_info =
-            self.load_tenure_info(&mut chainstate, burn_dbconn, new_tenure)?;
+            self.load_tenure_info(&mut chainstate, burn_dbconn, tenure_cause)?;
         let mut tenure_tx = self.tenure_begin(burn_dbconn, &mut miner_tenure_info)?;
         for tx in txs.drain(..) {
             let tx_len = tx.tx_len();

From 0d8b1d34e273b3db3f5338415a0d9005ab3b3716 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Thu, 7 Dec 2023 09:54:45 -0500
Subject: [PATCH 0111/1166] feat: flesh out tenure-extension handling, and
 also, move all tenure-related code to its own file

---
 stackslib/src/chainstate/nakamoto/mod.rs | 1330 +++++++---------------
 1 file changed, 430 insertions(+), 900 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index cf0c4ba792..7373ba2a99 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -17,6 +17,10 @@
 use std::collections::HashSet;
 use std::ops::DerefMut;
 
+pub mod coordinator;
+pub mod miner;
+pub mod tenure;
+
 use clarity::vm::ast::ASTRules;
 use clarity::vm::costs::ExecutionCost;
 use clarity::vm::database::BurnStateDB;
@@ -45,7 +49,8 @@ use stacks_common::util::vrf::{VRFProof, VRFPublicKey, VRF};
 use wsts::curve::point::Point;
 
 use super::burn::db::sortdb::{
-    get_ancestor_sort_id_tx, get_block_commit_by_txid, SortitionHandleConn, SortitionHandleTx,
+    get_ancestor_sort_id, get_ancestor_sort_id_tx, get_block_commit_by_txid, SortitionHandle,
+    SortitionHandleConn, SortitionHandleTx,
 };
 use super::burn::operations::{DelegateStxOp, StackStxOp, TransferStxOp};
 use super::stacks::db::accounts::MinerReward;
@@ -64,6 +69,7 @@ use crate::chainstate::burn::db::sortdb::SortitionDB;
 use crate::chainstate::burn::operations::{LeaderBlockCommitOp, LeaderKeyRegisterOp};
 use crate::chainstate::burn::{BlockSnapshot, SortitionHash};
 use crate::chainstate::coordinator::{BlockEventDispatcher, Error};
+use crate::chainstate::nakamoto::tenure::NAKAMOTO_TENURES_SCHEMA;
 use crate::chainstate::stacks::db::{DBConfig as ChainstateConfig, StacksChainState};
 use crate::chainstate::stacks::{
     TenureChangeCause, MINER_BLOCK_CONSENSUS_HASH, MINER_BLOCK_HEADER_HASH,
@@ -78,9 +84,6 @@ use crate::util_lib::db::{
     FromRow,
 };
 
-pub mod coordinator;
-pub mod miner;
-
 #[cfg(test)]
 pub mod tests;
 
@@ -143,34 +146,7 @@ lazy_static! {
                     
                      PRIMARY KEY(block_hash,consensus_hash)
     );"#.into(),
-    r#"
-        -- Table for all processed tenures.
-        -- This represents all BlockFound tenure changes, not extensions.
-        -- Every time we insert a header which has `tenure_changed == 1`, we should insert a record into this table as well.
-        -- Note that not every sortition is represented here.  If a tenure is extended, then no new tenure record is created
-        -- for it.
-        CREATE TABLE nakamoto_tenures (
-            -- consensus hash of start-tenure block (i.e. the consensus hash of the sortition in which the miner's block-commit
-            -- was mined)
-            consensus_hash TEXT NOT NULL,
-            -- consensus hash of the previous tenure's start-tenure block
-            prev_consensus_hash TEXT NOT NULL,
-            -- block hash of start-tenure block
-            block_hash TEXT NOT NULL,
-            -- block ID of this start block (this is the StacksBlockId of the above consensus_hash and block_hash)
-            block_id TEXT NOT NULL,
-            -- this field is the total number of *tenures* in the chain history (including this tenure),
-            -- as of the _end_ of this block.  A block can contain multiple TenureChanges; if so, then this
-            -- is the height of the _last_ TenureChange.
-            tenure_height INTEGER NOT NULL,
-            -- number of blocks this tenure confirms
-            num_blocks_confirmed INTEGER NOT NULL,
-
-            PRIMARY KEY(consensus_hash)
-        );
-        CREATE INDEX nakamoto_tenures_by_block_id ON nakamoto_tenures(block_id);
-        CREATE INDEX nakamoto_tenures_by_block_and_consensus_hashes ON nakamoto_tenures(consensus_hash,block_hash);
-    "#.into(),
+    NAKAMOTO_TENURES_SCHEMA.into(),
     r#"
       -- Table for Nakamoto block headers
       CREATE TABLE nakamoto_block_headers (
@@ -226,8 +202,8 @@ lazy_static! {
                      tenure_tx_fees TEXT NOT NULL,
                      -- nakamoto block's VRF proof, if this is a tenure-start block
                      vrf_proof TEXT,
-              PRIMARY KEY(consensus_hash,block_hash),
-              FOREIGN KEY(consensus_hash) REFERENCES nakamoto_tenures(consensus_hash)
+
+              PRIMARY KEY(consensus_hash,block_hash)
           );
           CREATE INDEX nakamoto_block_headers_by_consensus_hash ON nakamoto_block_headers(consensus_hash);
     "#.into(),
@@ -243,6 +219,7 @@ lazy_static! {
 }
 
 /// Matured miner reward schedules
+#[derive(Debug, Clone)]
 pub struct MaturedMinerPaymentSchedules {
     /// miners whose rewards matured
     pub latest_miners: Vec<MinerPaymentSchedule>,
@@ -260,6 +237,7 @@ impl MaturedMinerPaymentSchedules {
 }
 
 /// Calculated matured miner rewards, from scheduled rewards
+#[derive(Debug, Clone)]
 pub struct MaturedMinerRewards {
     /// this block's reward recipient
     /// NOTE: in epoch2, if a PoisonMicroblock report was successful, then the recipient is the
@@ -330,30 +308,6 @@ pub struct NakamotoBlockHeader {
     pub signer_signature: ThresholdSignature,
 }
 
-#[derive(Debug, Clone, PartialEq)]
-pub struct NakamotoBlock {
-    pub header: NakamotoBlockHeader,
-    pub txs: Vec<StacksTransaction>,
-}
-
-pub struct NakamotoChainState;
-
-#[derive(Debug, Clone, PartialEq)]
-pub struct NakamotoTenure {
-    /// consensus hash of start-tenure block
-    pub consensus_hash: ConsensusHash,
-    /// consensus hash of parent tenure's start-tenure block
-    pub prev_consensus_hash: ConsensusHash,
-    /// block hash of start-tenure block
-    pub block_hash: BlockHeaderHash,
-    /// block ID of this start block
-    pub block_id: StacksBlockId,
-    /// number of tenures so far, including this one
-    pub tenure_height: u64,
-    /// number of blocks this tenure confirms
-    pub num_blocks_confirmed: u32,
-}
-
 impl FromRow<NakamotoBlockHeader> for NakamotoBlockHeader {
     fn from_row(row: &rusqlite::Row) -> Result<NakamotoBlockHeader, DBError> {
         let version = row.get("version")?;
@@ -384,28 +338,14 @@ impl FromRow<NakamotoBlockHeader> for NakamotoBlockHeader {
     }
 }
 
-impl FromRow<NakamotoTenure> for NakamotoTenure {
-    fn from_row(row: &rusqlite::Row) -> Result<NakamotoTenure, DBError> {
-        let consensus_hash = row.get("consensus_hash")?;
-        let prev_consensus_hash = row.get("prev_consensus_hash")?;
-        let block_hash = row.get("block_hash")?;
-        let block_id = row.get("block_id")?;
-        let tenure_height_i64: i64 = row.get("tenure_height")?;
-        let tenure_height = tenure_height_i64
-            .try_into()
-            .map_err(|_| DBError::ParseError)?;
-        let num_blocks_confirmed: u32 = row.get("num_blocks_confirmed")?;
-        Ok(NakamotoTenure {
-            consensus_hash,
-            prev_consensus_hash,
-            block_hash,
-            block_id,
-            tenure_height,
-            num_blocks_confirmed,
-        })
-    }
+#[derive(Debug, Clone, PartialEq)]
+pub struct NakamotoBlock {
+    pub header: NakamotoBlockHeader,
+    pub txs: Vec<StacksTransaction>,
 }
 
+pub struct NakamotoChainState;
+
 impl StacksMessageCodec for NakamotoBlockHeader {
     fn consensus_serialize<W: std::io::Write>(&self, fd: &mut W) -> Result<(), CodecError> {
         write_next(fd, &self.version)?;
@@ -572,24 +512,63 @@ impl NakamotoBlock {
     }
 
     /// Get the tenure-change transaction in Nakamoto.
-    /// If it's present, then it's the first transaction (i.e. tx 0)
-    pub fn get_tenure_change_tx(&self) -> Option<&StacksTransaction> {
+    /// If it's present, then it's the first transaction (i.e. tx 0).
+    /// NOTE: this does _not_ return a tenure-extend transaction payload.
+    pub fn get_tenure_change_tx_payload(&self) -> Option<&TenureChangePayload> {
         let wellformed = self.is_wellformed_tenure_start_block();
         if let Some(false) = wellformed {
             // block isn't well-formed
             return None;
+        } else if wellformed.is_none() {
+            // no tenure-change
+            return None;
         }
 
         // if it exists, it's the first
         self.txs.get(0).and_then(|tx| {
-            if let TransactionPayload::TenureChange(..) = &tx.payload {
-                Some(tx)
+            if let TransactionPayload::TenureChange(ref tc) = &tx.payload {
+                Some(tc)
             } else {
                 None
             }
         })
     }
 
+    /// Get the tenure-extend transaction in Nakamoto.
+    /// If it's present, then it's the first transaction (i.e. tx 0)
+    /// NOTE: this does _not_ return a tenure-change transaction payload.
+    pub fn get_tenure_extend_tx_payload(&self) -> Option<&TenureChangePayload> {
+        let wellformed = self.is_wellformed_tenure_extend_block();
+        if let Some(false) = wellformed {
+            // block isn't well-formed
+            return None;
+        } else if wellformed.is_none() {
+            // no tenure extend
+            return None;
+        }
+
+        // if it exists, it's the first
+        self.txs.get(0).and_then(|tx| {
+            if let TransactionPayload::TenureChange(ref tc) = &tx.payload {
+                Some(tc)
+            } else {
+                None
+            }
+        })
+    }
+
+    /// Get the tenure-change or tenure-extend transaction in Nakamoto, if it exists.
+    /// At most one will exist.
+    pub fn get_tenure_tx_payload(&self) -> Option<&TenureChangePayload> {
+        if let Some(payload) = self.get_tenure_change_tx_payload() {
+            return Some(payload);
+        }
+        if let Some(payload) = self.get_tenure_extend_tx_payload() {
+            return Some(payload);
+        }
+        return None;
+    }
+
     /// Get the coinbase transaction in Nakamoto.
     /// It's the first non-TenureChange transaction (i.e. tx 1)
     pub fn get_coinbase_tx(&self) -> Option<&StacksTransaction> {
@@ -629,6 +608,116 @@ impl NakamotoBlock {
             .flatten()
     }
 
+    /// Determine if this is a well-formed tenure-extend block.
+    /// * It has exactly one TenureChange, and it does _not_ require a sortiton (it's `cause` is
+    /// `Extended`)
+    /// * Its consensus hash and previous consensus hash values point to this block.
+    /// * There is no coinbase
+    /// * There are no other TenureChange transactions
+    ///
+    /// Returns Some(true) if the above are true
+    /// Returns Some(false) if at least one of the above is false
+    /// Returns None if this block is not a tenure-extend block
+    pub fn is_wellformed_tenure_extend_block(&self) -> Option<bool> {
+        // find coinbases
+        let coinbase_positions = self
+            .txs
+            .iter()
+            .enumerate()
+            .filter_map(|(i, tx)| {
+                if let TransactionPayload::Coinbase(..) = &tx.payload {
+                    Some(i)
+                } else {
+                    None
+                }
+            })
+            .collect::<Vec<_>>();
+
+        if coinbase_positions.len() > 0 {
+            // can't be
+            return None;
+        }
+
+        // find all tenure changes, even if they're not sortition-induced
+        let tenure_change_positions = self
+            .txs
+            .iter()
+            .enumerate()
+            .filter_map(|(i, tx)| {
+                if let TransactionPayload::TenureChange(..) = &tx.payload {
+                    Some(i)
+                } else {
+                    None
+                }
+            })
+            .collect::<Vec<_>>();
+
+        if tenure_change_positions.len() == 0 {
+            return None;
+        }
+
+        if tenure_change_positions.len() > 1 {
+            // invalid
+            debug!(
+                "Invalid block -- {} tenure txs",
+                tenure_change_positions.len()
+            );
+            return Some(false);
+        }
+
+        let tc_idx = 0;
+        if tenure_change_positions != vec![tc_idx] {
+            // invalid -- wrong placement
+            debug!(
+                "Invalid block -- tenure txs at {:?}, expected {:?}",
+                &tenure_change_positions,
+                &vec![tc_idx]
+            );
+            return Some(false);
+        }
+
+        let TransactionPayload::TenureChange(tc_payload) = &self.txs[tc_idx].payload else {
+            // this transaction is not a tenure change
+            // (should be unreachable)
+            debug!(
+                "Invalid block -- tx at index {} is not a tenure tx",
+                &tc_idx
+            );
+            return Some(false);
+        };
+        if tc_payload.cause != TenureChangeCause::Extended {
+            // not a tenure-extend, and can't be valid since all other tenure-change types require
+            // a coinbase (which is not present)
+            debug!("Invalid block -- tenure tx is not a tenure extension");
+            return Some(false);
+        }
+
+        if tc_payload.previous_tenure_end != self.header.parent_block_id {
+            // discontinuous
+            debug!(
+                "Invalid block -- discontiguous: {} != {}",
+                &tc_payload.previous_tenure_end, &self.header.parent_block_id
+            );
+            return Some(false);
+        }
+
+        if tc_payload.tenure_consensus_hash != self.header.consensus_hash
+            || tc_payload.prev_tenure_consensus_hash != self.header.consensus_hash
+        {
+            // tenure-extends don't change the current miner
+            debug!(
+                "Invalid block -- expected {} = {} && {} = {}",
+                &tc_payload.tenure_consensus_hash,
+                &self.header.consensus_hash,
+                &tc_payload.prev_tenure_consensus_hash,
+                &self.header.consensus_hash
+            );
+            return Some(false);
+        }
+
+        Some(true)
+    }
+
     /// Determine if this is a well-formed first block in a tenure.
     /// * It has exactly one TenureChange, and it requires a sortition and points to the parent of
     /// this block (this checks `cause` and `previous_tenure_end`)
@@ -675,11 +764,17 @@ impl NakamotoBlock {
 
         if coinbase_positions.len() > 1 || tenure_change_positions.len() > 1 {
             // never valid to have more than one of each
+            debug!(
+                "Invalid block -- have {} coinbases and {} tenure txs",
+                coinbase_positions.len(),
+                tenure_change_positions.len()
+            );
             return Some(false);
         }
 
         if coinbase_positions.len() == 1 && tenure_change_positions.len() == 0 {
             // coinbase unaccompanied by a tenure change
+            debug!("Invalid block -- have coinbase without tenure change");
             return Some(false);
         }
 
@@ -688,6 +783,11 @@ impl NakamotoBlock {
             // It must be the first tx
             if tenure_change_positions != vec![0] {
                 // wrong position
+                debug!(
+                    "Invalid block -- tenure change positions = {:?}, expected {:?}",
+                    &tenure_change_positions,
+                    &vec![0]
+                );
                 return Some(false);
             }
 
@@ -695,11 +795,13 @@ impl NakamotoBlock {
             let TransactionPayload::TenureChange(tc_payload) = &self.txs[0].payload else {
                 // this transaction is not a tenure change
                 // (should be unreachable)
+                debug!("Invalid block -- first transaction is not a tenure change");
                 return Some(false);
             };
 
             if tc_payload.cause.expects_sortition() {
                 // not valid
+                debug!("Invalid block -- no coinbase, but tenure change expects sortition");
                 return Some(false);
             }
 
@@ -713,6 +815,7 @@ impl NakamotoBlock {
         if coinbase_positions != vec![coinbase_idx] || tenure_change_positions != vec![tc_idx] {
             // invalid -- expect exactly one sortition-induced tenure change and exactly one coinbase expected,
             // and the tenure change must be the first transaction and the coinbase must be the second transaction
+            debug!("Invalid block -- coinbase and/or tenure change txs are in the wrong position -- ({:?}, {:?}) != ({:?}, {:?})", &coinbase_positions, &tenure_change_positions, &vec![coinbase_idx], &vec![tc_idx]);
             return Some(false);
         }
 
@@ -720,15 +823,21 @@ impl NakamotoBlock {
         let TransactionPayload::TenureChange(tc_payload) = &self.txs[tc_idx].payload else {
             // this transaction is not a tenure change
             // (should be unreachable)
+            debug!("Invalid block -- tx index {} is not a tenure tx", tc_idx);
             return Some(false);
         };
         if !tc_payload.cause.expects_sortition() {
             // the only tenure change allowed in a block with a coinbase is a sortition-triggered
             // tenure change
+            debug!("Invalid block -- tenure change does not expect a sortition");
             return Some(false);
         }
         if tc_payload.previous_tenure_end != self.header.parent_block_id {
             // discontinuous
+            debug!(
+                "Invalid block -- discontiguous -- {} != {}",
+                &tc_payload.previous_tenure_end, &self.header.parent_block_id
+            );
             return Some(false);
         }
 
@@ -736,10 +845,15 @@ impl NakamotoBlock {
         let TransactionPayload::Coinbase(_, _, vrf_proof_opt) = &self.txs[coinbase_idx].payload
         else {
             // this transaction is not a coinbase (but this should be unreachable)
+            debug!(
+                "Invalid block -- tx index {} is not a coinbase",
+                coinbase_idx
+            );
             return Some(false);
         };
         if vrf_proof_opt.is_none() {
             // not a Nakamoto coinbase
+            debug!("Invalid block -- no VRF proof in coinbase");
             return Some(false);
         }
 
@@ -782,7 +896,7 @@ impl NakamotoBlock {
     }
 
     /// Get the miner's public key hash160 from this signature
-    pub(crate) fn get_miner_pubkh(&self) -> Result<Hash160, ChainstateError> {
+    pub(crate) fn recover_miner_pubkh(&self) -> Result<Hash160, ChainstateError> {
         let recovered_miner_pubk = self.header.recover_miner_pk().ok_or_else(|| {
             warn!(
                 "Nakamoto Stacks block downloaded with unrecoverable miner public key";
@@ -801,7 +915,7 @@ impl NakamotoBlock {
         &self,
         miner_pubkey_hash160: &Hash160,
     ) -> Result<(), ChainstateError> {
-        let recovered_miner_hash160 = self.get_miner_pubkh()?;
+        let recovered_miner_hash160 = self.recover_miner_pubkh()?;
         if &recovered_miner_hash160 != miner_pubkey_hash160 {
             warn!(
                 "Nakamoto Stacks block signature mismatch: {recovered_miner_hash160} != {miner_pubkey_hash160} from leader-key";
@@ -818,44 +932,46 @@ impl NakamotoBlock {
 
     /// Verify that if this block has a tenure-change, that it is consistent with our header's
     /// consensus_hash and miner_signature.  If there is no tenure change tx in this block, then
-    /// this is a no-op
-    pub(crate) fn check_tenure_change_tx(&self) -> Result<(), ChainstateError> {
+    /// this is a no-op.
+    ///
+    /// This check applies to both tenure-changes and tenure-extends
+    pub(crate) fn check_tenure_tx(&self) -> Result<(), ChainstateError> {
         // If this block has a tenure-change, then verify that the miner public key is the same as
         // the leader key.  This is required for all tenure-change causes.
-        if let Some(tenure_change_tx) = self.get_tenure_change_tx() {
-            // in all cases, the miner public key must match that of the tenure change
-            let tc_payload = tenure_change_tx
-                .try_as_tenure_change()
-                .expect("FATAL: `get_tenure_change_tx()` did not return a tenure-change");
-            let recovered_miner_hash160 = self.get_miner_pubkh()?;
-            if tc_payload.pubkey_hash != recovered_miner_hash160 {
-                warn!(
-                    "Invalid tenure-change transaction -- bad miner pubkey hash160";
-                    "block_hash" => %self.header.block_hash(),
-                    "block_id" => %self.header.block_id(),
-                    "pubkey_hash" => %tc_payload.pubkey_hash,
-                    "recovered_miner_hash160" => %recovered_miner_hash160
-                );
-                return Err(ChainstateError::InvalidStacksBlock(
-                    "Invalid tenure change -- bad miner pubkey hash160".into(),
-                ));
-            }
+        let Some(tc_payload) = self.get_tenure_tx_payload() else {
+            return Ok(());
+        };
 
-            // in all cases, the tenure change's consensus hash must match the block's consensus
-            // hash
-            if tc_payload.consensus_hash != self.header.consensus_hash {
-                warn!(
-                    "Invalid tenure-change transaction -- bad consensus hash";
-                    "block_hash" => %self.header.block_hash(),
-                    "block_id" => %self.header.block_id(),
-                    "consensus_hash" => %self.header.consensus_hash,
-                    "tc_payload.consensus_hash" => %tc_payload.consensus_hash
-                );
-                return Err(ChainstateError::InvalidStacksBlock(
-                    "Invalid tenure change -- bad consensus hash".into(),
-                ));
-            }
+        // in all cases, the miner public key must match that of the tenure change
+        let recovered_miner_hash160 = self.recover_miner_pubkh()?;
+        if tc_payload.pubkey_hash != recovered_miner_hash160 {
+            warn!(
+                "Invalid tenure-change transaction -- bad miner pubkey hash160";
+                "block_hash" => %self.header.block_hash(),
+                "block_id" => %self.header.block_id(),
+                "pubkey_hash" => %tc_payload.pubkey_hash,
+                "recovered_miner_hash160" => %recovered_miner_hash160
+            );
+            return Err(ChainstateError::InvalidStacksBlock(
+                "Invalid tenure change -- bad miner pubkey hash160".into(),
+            ));
         }
+
+        // in all cases, the tenure change's consensus hash must match the block's consensus
+        // hash
+        if tc_payload.tenure_consensus_hash != self.header.consensus_hash {
+            warn!(
+                "Invalid tenure-change transaction -- bad consensus hash";
+                "block_hash" => %self.header.block_hash(),
+                "block_id" => %self.header.block_id(),
+                "consensus_hash" => %self.header.consensus_hash,
+                "tc_payload.tenure_consensus_hash" => %tc_payload.tenure_consensus_hash
+            );
+            return Err(ChainstateError::InvalidStacksBlock(
+                "Invalid tenure change -- bad consensus hash".into(),
+            ));
+        }
+
         Ok(())
     }
 
@@ -910,28 +1026,29 @@ impl NakamotoBlock {
     /// Used to determine whether or not we'll keep a block around (even if we don't yet have its parent).
     ///
     /// Arguments
-    /// -- `burn_chain_tip` is the BlockSnapshot containing the block-commit for this block's
-    /// tenure
+    /// -- `tenure_burn_chain_tip` is the BlockSnapshot containing the block-commit for this block's
+    /// tenure.  It is not always the tip of the burnchain.
+    /// -- `expected_burn` is the total number of burnchain tokens spent
     /// -- `leader_key` is the miner's leader key registration transaction
-    /// -- `bloc_commit` is the block-commit for this tenure
     ///
     /// Verifies the following:
     /// -- (self.header.consensus_hash) that this block falls into this block-commit's tenure
-    /// -- (self.header.burn_spent) that this block's burn total matches `burn_chain_tip`'s total burn
+    /// -- (self.header.burn_spent) that this block's burn total matches `burn_tip`'s total burn
     /// -- (self.header.miner_signature) that this miner signed this block
     /// -- if this block has a tenure change, then it's consistent with the miner's public key and
     /// self.header.consensus_hash
     /// -- if this block has a coinbase, then that it's VRF proof was generated by this miner
     pub fn validate_against_burnchain(
         &self,
-        burn_chain_tip: &BlockSnapshot,
+        tenure_burn_chain_tip: &BlockSnapshot,
+        expected_burn: u64,
         leader_key: &LeaderKeyRegisterOp,
     ) -> Result<(), ChainstateError> {
         // this block's consensus hash must match the sortition that selected it
-        if burn_chain_tip.consensus_hash != self.header.consensus_hash {
+        if tenure_burn_chain_tip.consensus_hash != self.header.consensus_hash {
             warn!("Invalid Nakamoto block: consensus hash does not match sortition";
                   "consensus_hash" => %self.header.consensus_hash,
-                  "sortition.consensus_hash" => %burn_chain_tip.consensus_hash
+                  "sortition.consensus_hash" => %tenure_burn_chain_tip.consensus_hash
             );
             return Err(ChainstateError::InvalidStacksBlock(
                 "Invalid Nakamoto block: invalid consensus hash".into(),
@@ -939,10 +1056,10 @@ impl NakamotoBlock {
         }
 
         // this block must commit to all of the work seen so far
-        if self.header.burn_spent != burn_chain_tip.total_burn {
+        if self.header.burn_spent != expected_burn {
             warn!("Invalid Nakamoto block header: invalid total burns";
                   "header.burn_spent" => self.header.burn_spent,
-                  "burn_chain_tip.total_burn" => burn_chain_tip.total_burn
+                  "expected_burn" => expected_burn,
             );
             return Err(ChainstateError::InvalidStacksBlock(
                 "Invalid Nakamoto block: invalid total burns".into(),
@@ -962,8 +1079,11 @@ impl NakamotoBlock {
             })?;
 
         self.check_miner_signature(&miner_pubkey_hash160)?;
-        self.check_tenure_change_tx()?;
-        self.check_coinbase_tx(&leader_key.public_key, &burn_chain_tip.sortition_hash)?;
+        self.check_tenure_tx()?;
+        self.check_coinbase_tx(
+            &leader_key.public_key,
+            &tenure_burn_chain_tip.sortition_hash,
+        )?;
 
         // not verified by this method:
         // * chain_length       (need parent block header)
@@ -971,6 +1091,7 @@ impl NakamotoBlock {
         // * block-commit seed  (need parent block)
         // * tx_merkle_root     (already verified; validated on deserialization)
         // * state_index_root   (validated on process_block())
+        // * stacker signature  (validated on accept_block())
         Ok(())
     }
 
@@ -1005,12 +1126,23 @@ impl NakamotoBlock {
         if let Some(valid) = self.is_wellformed_tenure_start_block() {
             if !valid {
                 // bad tenure change
+                warn!("Not a well-formed tenure-start block");
                 return false;
             }
             if self.get_coinbase_tx().is_none() {
                 return false;
             }
-            if self.get_tenure_change_tx().is_none() {
+            if self.get_tenure_change_tx_payload().is_none() {
+                return false;
+            }
+        }
+        if let Some(valid) = self.is_wellformed_tenure_extend_block() {
+            if !valid {
+                // bad tenure extend
+                warn!("Not a well-formed tenure-extend block");
+                return false;
+            }
+            if self.get_tenure_extend_tx_payload().is_none() {
                 return false;
             }
         }
@@ -1344,24 +1476,64 @@ impl NakamotoChainState {
         Ok(Some(receipt))
     }
 
+    /// Get the expected total burnchain tokens spent so far for a given block.
+    /// * if the block has a tenure-change tx, then this is the tx's sortition consensus hash's
+    /// snapshot's burn total (since the miner will have produced this tenure-change tx in reaction
+    /// to the arrival of this new sortition)
+    /// * otherwise, it's the highest processed tenure's sortition consensus hash's snapshot's burn
+    /// total.
+    ///
+    /// TODO: unit test
+    pub(crate) fn get_expected_burns<SH: SortitionHandle>(
+        sort_handle: &mut SH,
+        chainstate_conn: &Connection,
+        block: &NakamotoBlock,
+    ) -> Result<Option<u64>, ChainstateError> {
+        let target_ch = if let Some(tenure_payload) = block.get_tenure_tx_payload() {
+            tenure_payload.sortition_consensus_hash
+        } else if let Some(highest_tenure) =
+            Self::get_highest_nakamoto_tenure(chainstate_conn, sort_handle)?
+        {
+            highest_tenure.sortition_consensus_hash
+        } else {
+            // no nakamoto tenures yet, so this is the consensus hash of the canonical stacks tip
+            let (consensus_hash, _) =
+                SortitionDB::get_canonical_stacks_chain_tip_hash(sort_handle.sqlite())?;
+            consensus_hash
+        };
+
+        let Some(sn) = SortitionDB::get_block_snapshot_consensus(sort_handle.sqlite(), &target_ch)?
+        else {
+            warn!("Unacceptable Nakamoto block -- no sortition for tenure";
+                  "sortition_consensus_hash" => %target_ch
+            );
+            return Ok(None);
+        };
+        Ok(Some(sn.total_burn))
+    }
+
     /// Validate that a Nakamoto block attaches to the burn chain state.
     /// Called before inserting the block into the staging DB.
     /// Wraps `NakamotoBlock::validate_against_burnchain()`, and
     /// verifies that all transactions in the block are allowed in this epoch.
     pub fn validate_nakamoto_block_burnchain(
         db_handle: &SortitionHandleConn,
+        expected_burn: u64,
         block: &NakamotoBlock,
         mainnet: bool,
         chain_id: u32,
     ) -> Result<(), ChainstateError> {
         // find the sortition-winning block commit for this block, as well as the block snapshot
-        // containing the parent block-commit
+        // containing the parent block-commit.  This is the snapshot that corresponds to when the
+        // miner begain its tenure; it may not be the burnchain tip.
         let block_hash = block.header.block_hash();
         let consensus_hash = &block.header.consensus_hash;
 
-        // burn chain tip that selected this commit's block
-        let Some(burn_chain_tip) =
-            SortitionDB::get_block_snapshot_consensus(db_handle, &consensus_hash)?
+        let sort_tip = SortitionDB::get_canonical_burn_chain_tip(db_handle)?;
+
+        // burn chain tip that selected this commit's block (the tenure sortition)
+        let Some(tenure_burn_chain_tip) =
+            SortitionDB::get_block_snapshot_consensus(db_handle, consensus_hash)?
         else {
             warn!("No sortition for {}", &consensus_hash);
             return Err(ChainstateError::InvalidStacksBlock(
@@ -1369,15 +1541,36 @@ impl NakamotoChainState {
             ));
         };
 
+        // tenure sortition is canonical
+        let Some(ancestor_sort_id) = get_ancestor_sort_id(
+            db_handle,
+            tenure_burn_chain_tip.block_height,
+            &sort_tip.sortition_id,
+        )?
+        else {
+            // not canonical
+            warn!("Invalid consensus hash: snapshot is not canonical"; "consensus_hash" => %consensus_hash);
+            return Err(ChainstateError::InvalidStacksBlock(
+                "No sortition for block's consensus hash -- not canonical".into(),
+            ));
+        };
+        if ancestor_sort_id != tenure_burn_chain_tip.sortition_id {
+            // not canonical
+            warn!("Invalid consensus hash: snapshot is not canonical"; "consensus_hash" => %consensus_hash);
+            return Err(ChainstateError::InvalidStacksBlock(
+                "No sortition for block's consensus hash -- not canonical".into(),
+            ));
+        };
+
         // the block-commit itself
         let Some(block_commit) = db_handle.get_block_commit_by_txid(
-            &burn_chain_tip.sortition_id,
-            &burn_chain_tip.winning_block_txid,
+            &tenure_burn_chain_tip.sortition_id,
+            &tenure_burn_chain_tip.winning_block_txid,
         )?
         else {
             warn!(
                 "No block commit for {} in sortition for {}",
-                &burn_chain_tip.winning_block_txid, &consensus_hash
+                &tenure_burn_chain_tip.winning_block_txid, &consensus_hash
             );
             return Err(ChainstateError::InvalidStacksBlock(
                 "No block-commit in sortition for block's consensus hash".into(),
@@ -1393,7 +1586,9 @@ impl NakamotoChainState {
             .expect("FATAL: have block commit but no leader key");
 
         // attaches to burn chain
-        if let Err(e) = block.validate_against_burnchain(&burn_chain_tip, &leader_key) {
+        if let Err(e) =
+            block.validate_against_burnchain(&tenure_burn_chain_tip, expected_burn, &leader_key)
+        {
             warn!(
                 "Invalid Nakamoto block, could not validate on burnchain";
                 "consensus_hash" => %consensus_hash,
@@ -1406,9 +1601,11 @@ impl NakamotoChainState {
 
         // check the _next_ block's tenure, since when Nakamoto's miner activates, the current chain tip
         // will be in epoch 2.5 (the next block will be epoch 3.0)
-        let cur_epoch =
-            SortitionDB::get_stacks_epoch(db_handle.deref(), burn_chain_tip.block_height + 1)?
-                .expect("FATAL: no epoch defined for current Stacks block");
+        let cur_epoch = SortitionDB::get_stacks_epoch(
+            db_handle.deref(),
+            tenure_burn_chain_tip.block_height + 1,
+        )?
+        .expect("FATAL: no epoch defined for current Stacks block");
 
         // static checks on transactions all pass
         let valid = block.validate_transactions_static(mainnet, chain_id, cur_epoch.epoch_id);
@@ -1480,7 +1677,8 @@ impl NakamotoChainState {
     pub fn accept_block(
         config: &ChainstateConfig,
         block: NakamotoBlock,
-        db_handle: &SortitionHandleConn,
+        db_handle: &mut SortitionHandleConn,
+        // TODO: need a separate connection for the headers
         staging_db_tx: &rusqlite::Transaction,
         aggregate_public_key: &Point,
     ) -> Result<bool, ChainstateError> {
@@ -1498,14 +1696,34 @@ impl NakamotoChainState {
                 &block.block_id()
             );
             return Err(ChainstateError::InvalidStacksBlock(
-                "Not a well-formed first block".into(),
+                "Not a well-formed first-tenure block".into(),
             ));
         }
 
+        // if this is a tenure-extend block, then make sure it's well-formed
+        if let Some(false) = block.is_wellformed_tenure_extend_block() {
+            warn!(
+                "Block {} is not a well-formed tenure-extend block",
+                &block.block_id()
+            );
+            return Err(ChainstateError::InvalidStacksBlock(
+                "Not a well-formed tenure-extend block".into(),
+            ));
+        }
+
+        let Some(expected_burn) = Self::get_expected_burns(db_handle, staging_db_tx, &block)?
+        else {
+            warn!("Unacceptable Nakamoto block: unable to find its paired sortition";
+                  "block_id" => %block.block_id()
+            );
+            return Ok(false);
+        };
+
         // this block must be consistent with its miner's leader-key and block-commit, and must
         // contain only transactions that are valid in this epoch.
         if let Err(e) = Self::validate_nakamoto_block_burnchain(
             db_handle,
+            expected_burn,
             &block,
             config.mainnet,
             config.chain_id,
@@ -1557,9 +1775,9 @@ impl NakamotoChainState {
                 ).optional()?.is_none()
                );
 
-        let block_id = block.block_id();
+        let _block_id = block.block_id();
         Self::store_block(staging_db_tx, block, burn_attachable, stacks_attachable)?;
-        test_debug!("Stored Nakamoto block {}", &block_id);
+        test_debug!("Stored Nakamoto block {}", &_block_id);
         Ok(true)
     }
 
@@ -1598,62 +1816,6 @@ impl NakamotoChainState {
             })
     }
 
-    /// Create the block reward for a NakamotoBlock
-    /// `coinbase_reward_ustx` is the total coinbase reward for this block, including any
-    ///    accumulated rewards from missed sortitions or initial mining rewards.
-    /// TODO: unit test
-    pub fn make_scheduled_miner_reward(
-        mainnet: bool,
-        epoch_id: StacksEpochId,
-        parent_block_hash: &BlockHeaderHash,
-        parent_consensus_hash: &ConsensusHash,
-        block_hash: &BlockHeaderHash,
-        block_consensus_hash: &ConsensusHash,
-        block_height: u64,
-        coinbase_tx: &StacksTransaction,
-        parent_fees: u128,
-        burnchain_commit_burn: u64,
-        burnchain_sortition_burn: u64,
-        coinbase_reward_ustx: u128,
-    ) -> MinerPaymentSchedule {
-        let miner_auth = coinbase_tx.get_origin();
-        let miner_addr = miner_auth.get_address(mainnet);
-
-        let recipient = if epoch_id >= StacksEpochId::Epoch21 {
-            // pay to tx-designated recipient, or if there is none, pay to the origin
-            match coinbase_tx.try_as_coinbase() {
-                Some((_, recipient_opt, _)) => recipient_opt
-                    .cloned()
-                    .unwrap_or(miner_addr.to_account_principal()),
-                None => miner_addr.to_account_principal(),
-            }
-        } else {
-            // pre-2.1, always pay to the origin
-            miner_addr.to_account_principal()
-        };
-
-        // N.B. a `MinerPaymentSchedule` that pays to a contract can never be created before 2.1,
-        // per the above check (and moreover, a Stacks block with a pay-to-alt-recipient coinbase would
-        // not become valid until after 2.1 activates).
-        let miner_reward = MinerPaymentSchedule {
-            address: miner_addr,
-            recipient,
-            block_hash: block_hash.clone(),
-            consensus_hash: block_consensus_hash.clone(),
-            parent_block_hash: parent_block_hash.clone(),
-            parent_consensus_hash: parent_consensus_hash.clone(),
-            coinbase: coinbase_reward_ustx,
-            tx_fees: MinerPaymentTxFees::Nakamoto { parent_fees },
-            burnchain_commit_burn,
-            burnchain_sortition_burn,
-            miner: true,
-            stacks_block_height: block_height,
-            vtxindex: 0,
-        };
-
-        miner_reward
-    }
-
     /// Return the total ExecutionCost consumed during the tenure up to and including
     ///  `block`
     pub fn get_total_tenure_cost_at(
@@ -1683,32 +1845,31 @@ impl NakamotoChainState {
             .map_err(|_| ChainstateError::DBError(DBError::ParseError))
     }
 
-    /// Return a Nakamoto StacksHeaderInfo at a given tenure height in the fork identified by `tip_index_hash`.
+    /// Return a Nakamoto StacksHeaderInfo at a given coinbase height in the fork identified by `tip_index_hash`.
     /// * For Stacks 2.x, this is the Stacks block's header
     /// * For Stacks 3.x (Nakamoto), this is the first block in the miner's tenure.
-    /// TODO: unit test
-    pub fn get_header_by_tenure_height(
+    pub fn get_header_by_coinbase_height(
         tx: &mut StacksDBTx,
         tip_index_hash: &StacksBlockId,
-        tenure_height: u64,
+        coinbase_height: u64,
     ) -> Result<Option<StacksHeaderInfo>, ChainstateError> {
         // query for block header info at the tenure-height, then check if in fork
-        let qry = "SELECT consensus_hash FROM nakamoto_tenures WHERE tenure_height = ?1";
+        let qry = "SELECT DISTINCT tenure_id_consensus_hash AS consensus_hash FROM nakamoto_tenures WHERE coinbase_height = ?1";
 
         let candidate_chs: Vec<ConsensusHash> =
-            query_rows(tx.tx(), qry, &[u64_to_sql(tenure_height)?])?;
+            query_rows(tx.tx(), qry, &[u64_to_sql(coinbase_height)?])?;
 
         if candidate_chs.len() == 0 {
             // no nakamoto_tenures at that tenure height, check if there's a stack block header where
-            //   block_height = tenure_height
+            //   block_height = coinbase_height
             let Some(ancestor_at_height) = tx
-                .get_ancestor_block_hash(tenure_height, tip_index_hash)?
+                .get_ancestor_block_hash(coinbase_height, tip_index_hash)?
                 .map(|ancestor| Self::get_block_header(tx.tx(), &ancestor))
                 .transpose()?
                 .flatten()
             else {
                 warn!("No such epoch2 ancestor";
-                      "tenure_height" => tenure_height,
+                      "coinbase_height" => coinbase_height,
                       "tip_index_hash" => %tip_index_hash,
                 );
                 return Ok(None);
@@ -1741,47 +1902,6 @@ impl NakamotoChainState {
         Ok(None)
     }
 
-    /// Return the tenure height of `block` if it was a nakamoto block, or the
-    ///  Stacks block height of `block` if it was an epoch-2 block
-    ///
-    /// In Stacks 2.x, the tenure height and block height are the
-    /// same. A miner's tenure in Stacks 2.x is entirely encompassed
-    /// in the single Bitcoin-anchored Stacks block they produce, as
-    /// well as the microblock stream they append to it.
-    pub fn get_tenure_height(
-        chainstate_conn: &Connection,
-        block: &StacksBlockId,
-    ) -> Result<Option<u64>, ChainstateError> {
-        let sql = "SELECT * FROM nakamoto_block_headers WHERE index_block_hash = ?1";
-        let result: Option<NakamotoBlockHeader> =
-            query_row_panic(chainstate_conn, sql, &[&block], || {
-                "FATAL: multiple rows for the same block hash".to_string()
-            })?;
-        if let Some(nak_hdr) = result {
-            let nak_qry = "SELECT tenure_height FROM nakamoto_tenures WHERE consensus_hash = ?1";
-            let opt_height: Option<i64> = chainstate_conn
-                .query_row(nak_qry, &[&nak_hdr.consensus_hash], |row| row.get(0))
-                .optional()?;
-            if let Some(height) = opt_height {
-                return Ok(Some(
-                    u64::try_from(height).map_err(|_| DBError::ParseError)?,
-                ));
-            } else {
-                // should be unreachable
-                return Err(DBError::NotFoundError.into());
-            }
-        }
-
-        let epoch_2_qry = "SELECT block_height FROM block_headers WHERE index_block_hash = ?1";
-        let opt_height: Option<i64> = chainstate_conn
-            .query_row(epoch_2_qry, &[block], |row| row.get(0))
-            .optional()?;
-        opt_height
-            .map(u64::try_from)
-            .transpose()
-            .map_err(|_| ChainstateError::DBError(DBError::ParseError))
-    }
-
     /// Load block header (either Epoch-2 rules or Nakamoto) by `index_block_hash`
     pub fn get_block_header(
         chainstate_conn: &Connection,
@@ -1804,7 +1924,6 @@ impl NakamotoChainState {
     }
 
     /// Load the canonical Stacks block header (either epoch-2 rules or Nakamoto)
-    /// TODO: unit test
     pub fn get_canonical_block_header(
         chainstate_conn: &Connection,
         sortdb: &SortitionDB,
@@ -1875,8 +1994,6 @@ impl NakamotoChainState {
     ///
     /// Returns NoSuchBlockError if the block header for `consensus_hash` does not exist, or if the
     /// parent block header info does not exist (i.e. the chainstate DB is missing something)
-    ///
-    /// TODO: unit test
     pub fn get_parent_vrf_proof(
         chainstate_conn: &Connection,
         sortdb_conn: &Connection,
@@ -1914,45 +2031,6 @@ impl NakamotoChainState {
         Ok(parent_vrf_proof)
     }
 
-    /// Get the first block header in a Nakamoto tenure
-    pub fn get_nakamoto_tenure_start_block_header(
-        chainstate_conn: &Connection,
-        consensus_hash: &ConsensusHash,
-    ) -> Result<Option<StacksHeaderInfo>, ChainstateError> {
-        let sql = "SELECT * FROM nakamoto_block_headers WHERE consensus_hash = ?1 ORDER BY block_height ASC LIMIT 1";
-        query_row_panic(chainstate_conn, sql, &[&consensus_hash], || {
-            "FATAL: multiple rows for the same consensus hash".to_string()
-        })
-        .map_err(ChainstateError::DBError)
-    }
-
-    /// Get the last block header in a Nakamoto tenure
-    pub fn get_nakamoto_tenure_finish_block_header(
-        chainstate_conn: &Connection,
-        consensus_hash: &ConsensusHash,
-    ) -> Result<Option<StacksHeaderInfo>, ChainstateError> {
-        let sql = "SELECT * FROM nakamoto_block_headers WHERE consensus_hash = ?1 ORDER BY block_height DESC LIMIT 1";
-        query_row_panic(chainstate_conn, sql, &[&consensus_hash], || {
-            "FATAL: multiple rows for the same consensus hash".to_string()
-        })
-        .map_err(ChainstateError::DBError)
-    }
-
-    /// Get the number of blocks in a tenure.
-    /// Only works for Nakamoto blocks, not Stacks epoch2 blocks.
-    /// Returns 0 if the consensus hash is not found.
-    pub fn get_nakamoto_tenure_length(
-        chainstate_conn: &Connection,
-        consensus_hash: &ConsensusHash,
-    ) -> Result<u32, ChainstateError> {
-        let sql = "SELECT IFNULL(COUNT(block_hash),0) FROM nakamoto_block_headers WHERE consensus_hash = ?1";
-        let count_i64 = query_int(chainstate_conn, sql, &[&consensus_hash])?;
-        let count: u32 = count_i64
-            .try_into()
-            .expect("FATAL: too many blocks in tenure");
-        Ok(count)
-    }
-
     /// Get the status of a Nakamoto block.
     /// Returns Some(accepted?, orphaned?) on success
     /// Returns None if there's no such block
@@ -2111,318 +2189,6 @@ impl NakamotoChainState {
         Ok(())
     }
 
-    /// Insert a nakamoto tenure.
-    /// No validation will be done.
-    pub(crate) fn insert_nakamoto_tenure(
-        tx: &Connection,
-        block_header: &NakamotoBlockHeader,
-        tenure_height: u64,
-        tenure: &TenureChangePayload,
-    ) -> Result<(), ChainstateError> {
-        // NOTE: this is checked with check_nakamoto_tenure()
-        assert_eq!(block_header.consensus_hash, tenure.consensus_hash);
-        let args: &[&dyn ToSql] = &[
-            &tenure.consensus_hash,
-            &tenure.prev_consensus_hash,
-            &block_header.block_hash(),
-            &block_header.block_id(),
-            &u64_to_sql(tenure_height)?,
-            &tenure.previous_tenure_blocks,
-        ];
-        tx.execute(
-            "INSERT INTO nakamoto_tenures
-                (consensus_hash, prev_consensus_hash, block_hash, block_id,
-                tenure_height, num_blocks_confirmed)
-            VALUES
-                (?1,?2,?3,?4,?5,?6)",
-            args,
-        )?;
-
-        Ok(())
-    }
-
-    /// Get the highest tenure height processed.
-    /// Returns Ok(Some(tenure_height)) if we have processed at least one tenure
-    /// Returns Ok(None) if we have not yet processed a Nakamoto tenure
-    /// Returns Err(..) on database errors
-    pub fn get_highest_nakamoto_tenure_height(
-        conn: &Connection,
-    ) -> Result<Option<u64>, ChainstateError> {
-        match conn
-            .query_row(
-                "SELECT IFNULL(MAX(tenure_height), 0) FROM nakamoto_tenures",
-                NO_PARAMS,
-                |row| Ok(u64::from_row(row).expect("Expected u64 in database")),
-            )
-            .optional()?
-        {
-            Some(height_i64) => {
-                if height_i64 == 0 {
-                    // this never happens, so it's None
-                    Ok(None)
-                } else {
-                    Ok(Some(
-                        height_i64.try_into().map_err(|_| DBError::ParseError)?,
-                    ))
-                }
-            }
-            None => Ok(None),
-        }
-    }
-
-    /// Get the highest processed tenure on the canonical sortition history.
-    /// TODO: unit test
-    pub fn get_highest_nakamoto_tenure(
-        conn: &Connection,
-        sort_tx: &mut SortitionHandleTx,
-    ) -> Result<Option<NakamotoTenure>, ChainstateError> {
-        let Some(max_sort_height) = Self::get_highest_nakamoto_tenure_height(conn)? else {
-            // no tenures yet
-            return Ok(None);
-        };
-
-        let sql = "SELECT * FROM nakamoto_tenures WHERE tenure_height = ?1";
-        let args: &[&dyn ToSql] = &[&u64_to_sql(max_sort_height)?];
-        let tenures: Vec<NakamotoTenure> = query_rows(conn, sql, args)?;
-        let tip = SortitionDB::get_canonical_burn_chain_tip(sort_tx)?;
-
-        // find the one that's in the canonical sortition history
-        for tenure in tenures.into_iter() {
-            let Some(sn) =
-                SortitionDB::get_block_snapshot_consensus(sort_tx, &tenure.consensus_hash)?
-            else {
-                // not in sortition DB.
-                // This is unreachable, but be defensive and just skip it.
-                continue;
-            };
-            let Some(_ancestor_sort_id) =
-                get_ancestor_sort_id_tx(sort_tx, sn.block_height, &tip.sortition_id)?
-            else {
-                // not canonical
-                continue;
-            };
-            return Ok(Some(tenure));
-        }
-        // not found
-        Ok(None)
-    }
-
-    /// Verify that a tenure change tx is a valid first-ever tenure change.  It must connect to an
-    /// epoch2 block.
-    /// TODO: unit test
-    pub(crate) fn check_first_nakamoto_tenure_change(
-        headers_conn: &Connection,
-        tenure_payload: &TenureChangePayload,
-    ) -> Result<bool, ChainstateError> {
-        let Some(parent_header) =
-            Self::get_block_header(headers_conn, &tenure_payload.previous_tenure_end)?
-        else {
-            warn!("Invalid tenure-change: no parent epoch2 header";
-                  "consensus_hash" => %tenure_payload.consensus_hash,
-                  "previous_tenure_end" => %tenure_payload.previous_tenure_end
-            );
-            return Ok(false);
-        };
-        if parent_header.anchored_header.as_stacks_epoch2().is_none() {
-            warn!("Invalid tenure-change: parent header is not epoch2";
-                  "consensus_hash" => %tenure_payload.consensus_hash,
-                  "previous_tenure_end" => %tenure_payload.previous_tenure_end
-            );
-            return Ok(false);
-        }
-        if tenure_payload.previous_tenure_blocks != 1 {
-            warn!("Invalid tenure-change: expected 1 previous tenure block";
-                  "consensus_hash" => %tenure_payload.consensus_hash,
-            );
-            return Ok(false);
-        }
-        return Ok(true);
-    }
-
-    /// Check a Nakamoto tenure transaction's validity with respect to the last-processed tenure
-    /// and the sortition DB.  This validates the following fields:
-    /// * consensus_hash
-    /// * prev_consensus_hash
-    /// * previous_tenure_end
-    /// * previous_tenure_blocks
-    /// * cause
-    ///
-    /// Returns Ok(true) on success
-    /// Returns Ok(false) if the tenure change is invalid
-    /// Returns Err(..) on DB error
-    /// TODO: unit test
-    pub(crate) fn check_nakamoto_tenure(
-        headers_conn: &Connection,
-        sort_tx: &mut SortitionHandleTx,
-        block_header: &NakamotoBlockHeader,
-        tenure_payload: &TenureChangePayload,
-    ) -> Result<bool, ChainstateError> {
-        if !tenure_payload.cause.expects_sortition() {
-            // not paired with a sortition
-            return Ok(true);
-        }
-
-        // block header must match tenure
-        if block_header.consensus_hash != tenure_payload.consensus_hash {
-            warn!("Invalid tenure-change (or block) -- mismatched consensus hash";
-                  "tenure_payload.consensus_hash" => %tenure_payload.consensus_hash,
-                  "block_header.consensus_hash" => %block_header.consensus_hash
-            );
-            return Ok(false);
-        }
-
-        let tip = SortitionDB::get_canonical_burn_chain_tip(sort_tx)?;
-
-        // the target sortition must exist, and it must be on the canonical fork
-        let Some(sn) =
-            SortitionDB::get_block_snapshot_consensus(sort_tx, &tenure_payload.consensus_hash)?
-        else {
-            // no sortition
-            warn!("Invalid tenure-change: no such snapshot"; "consensus_hash" => %tenure_payload.consensus_hash);
-            return Ok(false);
-        };
-        let Some(_ancestor_sort_id) =
-            get_ancestor_sort_id_tx(sort_tx, sn.block_height, &tip.sortition_id)?
-        else {
-            // not canonical
-            warn!("Invalid tenure-change: snapshot is not canonical"; "consensus_hash" => %tenure_payload.consensus_hash);
-            return Ok(false);
-        };
-        if tenure_payload.prev_consensus_hash != FIRST_BURNCHAIN_CONSENSUS_HASH {
-            // the parent sortition must exist, must be canonical, and must be an ancestor of the
-            // sortition for the given consensus hash.
-            let Some(prev_sn) = SortitionDB::get_block_snapshot_consensus(
-                sort_tx,
-                &tenure_payload.prev_consensus_hash,
-            )?
-            else {
-                // no parent sortition
-                warn!("Invalid tenure-change: no such parent snapshot"; "prev_consensus_hash" => %tenure_payload.prev_consensus_hash);
-                return Ok(false);
-            };
-            let Some(_ancestor_sort_id) =
-                get_ancestor_sort_id_tx(sort_tx, sn.block_height, &tip.sortition_id)?
-            else {
-                // parent not canonical
-                warn!("Invalid tenure-change: parent snapshot is not canonical"; "prev_consensus_hash" => %tenure_payload.prev_consensus_hash);
-                return Ok(false);
-            };
-            if prev_sn.block_height >= sn.block_height {
-                // parent comes after child
-                warn!("Invalid tenure-change: parent snapshot comes after child"; "consensus_hash" => %tenure_payload.consensus_hash, "prev_consensus_hash" => %tenure_payload.prev_consensus_hash);
-                return Ok(false);
-            }
-        }
-
-        // validate cause
-        match tenure_payload.cause {
-            TenureChangeCause::BlockFound => {
-                // there must have been a block-commit which one sortition
-                if !sn.sortition {
-                    warn!("Invalid tenure-change: no block found";
-                          "consensus_hash" => %tenure_payload.consensus_hash
-                    );
-                    return Ok(false);
-                }
-            }
-            TenureChangeCause::Extended => {}
-        }
-
-        let Some(highest_processed_tenure) =
-            Self::get_highest_nakamoto_tenure(headers_conn, sort_tx)?
-        else {
-            // no previous tenures.  This is the first tenure change.  It should point to an epoch
-            // 2.x block.
-            return Self::check_first_nakamoto_tenure_change(headers_conn, tenure_payload);
-        };
-
-        let Some(last_tenure_finish_block_id) = Self::get_nakamoto_tenure_finish_block_header(
-            headers_conn,
-            &highest_processed_tenure.consensus_hash,
-        )?
-        .map(|hdr| hdr.index_block_hash()) else {
-            // last tenure doesn't exist (should be unreachable)
-            warn!("Invalid tenure-change: no blocks found for highest processed tenure";
-                  "consensus_hash" => %highest_processed_tenure.consensus_hash,
-            );
-            return Ok(false);
-        };
-
-        if last_tenure_finish_block_id != tenure_payload.previous_tenure_end
-            || highest_processed_tenure.consensus_hash != tenure_payload.prev_consensus_hash
-        {
-            // not continuous -- this tenure-change does not point to the end of the
-            // last-processed tenure, or does not point to the last-processed tenure's sortition
-            warn!("Invalid tenure-change: discontiguous";
-                  "consensus_hash" => %tenure_payload.consensus_hash,
-                  "prev_consensus_hash" => %tenure_payload.prev_consensus_hash,
-                  "highest_processed_tenure.consensus_hash" => %highest_processed_tenure.consensus_hash,
-                  "last_tenure_finish_block_id" => %last_tenure_finish_block_id,
-                  "tenure_payload.previous_tenure_end" => %tenure_payload.previous_tenure_end
-            );
-            return Ok(false);
-        }
-
-        let tenure_len = Self::get_nakamoto_tenure_length(
-            headers_conn,
-            &highest_processed_tenure.consensus_hash,
-        )?;
-        if tenure_len != tenure_payload.previous_tenure_blocks {
-            // invalid -- does not report the correct number of blocks in the past tenure
-            warn!("Invalid tenure-change: wrong number of blocks";
-                  "consensus_hash" => %tenure_payload.consensus_hash,
-                  "highest_processed_tenure.consensus_hash" => %highest_processed_tenure.consensus_hash,
-                  "tenure_len" => tenure_len,
-                  "tenure_payload.previous_tenure_blocks" => tenure_payload.previous_tenure_blocks
-            );
-            return Ok(false);
-        }
-
-        Ok(true)
-    }
-
-    /// Advance the tenures table with a validated block's tenure data.
-    /// Only stores tenures that are paired with sortitions
-    /// TODO: unit test
-    pub(crate) fn advance_nakamoto_tenure(
-        headers_tx: &mut StacksDBTx,
-        sort_tx: &mut SortitionHandleTx,
-        block: &NakamotoBlock,
-        parent_tenure_height: u64,
-    ) -> Result<u64, ChainstateError> {
-        let tenure_height = parent_tenure_height
-            .checked_add(1)
-            .expect("FATAL: too many tenures");
-
-        for tx in block.txs.iter() {
-            let TransactionPayload::TenureChange(ref tenure_change_payload) = &tx.payload else {
-                continue;
-            };
-
-            if !Self::check_nakamoto_tenure(
-                headers_tx,
-                sort_tx,
-                &block.header,
-                tenure_change_payload,
-            )? {
-                return Err(ChainstateError::InvalidStacksTransaction(
-                    "Invalid tenure-change".into(),
-                    false,
-                ));
-            }
-
-            Self::insert_nakamoto_tenure(
-                headers_tx,
-                &block.header,
-                tenure_height,
-                tenure_change_payload,
-            )?;
-            return Ok(tenure_height);
-        }
-        // no new tenure
-        return Ok(parent_tenure_height);
-    }
-
     /// Append a Stacks block to an existing Stacks block, and grant the miner the block reward.
     /// Return the new Stacks header info.
     fn advance_tip(
@@ -2575,85 +2341,6 @@ impl NakamotoChainState {
         Ok(new_tip_info)
     }
 
-    /// Get scheduled miner rewards that have matured when this tenure starts.
-    /// Returns (list of miners to pay, any residual payments to the parent miner) on success.
-    /// TODO: unit test
-    pub(crate) fn get_matured_miner_reward_schedules(
-        chainstate_tx: &mut ChainstateTx,
-        tip_index_hash: &StacksBlockId,
-        tenure_height: u64,
-    ) -> Result<Option<MaturedMinerPaymentSchedules>, ChainstateError> {
-        let mainnet = chainstate_tx.get_config().mainnet;
-
-        // find matured miner rewards, so we can grant them within the Clarity DB tx.
-        if tenure_height < MINER_REWARD_MATURITY {
-            return Ok(Some(MaturedMinerPaymentSchedules::genesis(mainnet)));
-        }
-
-        let matured_tenure_height = tenure_height - MINER_REWARD_MATURITY;
-        let matured_tenure_block_header = Self::get_header_by_tenure_height(
-            chainstate_tx,
-            &tip_index_hash,
-            matured_tenure_height,
-        )?
-        .ok_or_else(|| {
-            warn!("Matured tenure data not found");
-            ChainstateError::NoSuchBlockError
-        })?;
-
-        let latest_miners = StacksChainState::get_scheduled_block_rewards_at_block(
-            chainstate_tx.deref_mut(),
-            &matured_tenure_block_header.index_block_hash(),
-        )?;
-        let parent_miner = StacksChainState::get_parent_matured_miner(
-            chainstate_tx.deref_mut(),
-            mainnet,
-            &latest_miners,
-        )?;
-        Ok(Some(MaturedMinerPaymentSchedules {
-            latest_miners,
-            parent_miner,
-        }))
-    }
-
-    /// Calculate the total matured rewards from the scheduled matured rewards.
-    /// This takes a ClarityTx, so PoisonMicroblocks can be taken into account (which deduct
-    /// STX from the block reward for offending miners).
-    /// The recipient of the block reward may not be the miner, but may be a PoisonMicroblock
-    /// reporter (both are captured as the sole `recipient` in the `MaturedMinerRewards` struct).
-    ///
-    /// Returns Ok(Some(rewards)) if we were able to calculate the rewards
-    /// Returns Ok(None) if there are no matured rewards yet
-    /// Returns Err(..) on DB error
-    /// TODO: unit test
-    pub(crate) fn calculate_matured_miner_rewards(
-        clarity_tx: &mut ClarityTx,
-        sortdb_conn: &Connection,
-        parent_stacks_height: u64,
-        matured_miner_schedule: MaturedMinerPaymentSchedules,
-    ) -> Result<Option<MaturedMinerRewards>, ChainstateError> {
-        let matured_miner_rewards_opt = match StacksChainState::find_mature_miner_rewards(
-            clarity_tx,
-            sortdb_conn,
-            parent_stacks_height,
-            matured_miner_schedule.latest_miners,
-            matured_miner_schedule.parent_miner,
-        ) {
-            Ok(Some((recipient, _user_burns, parent, reward_info))) => Some(MaturedMinerRewards {
-                recipient,
-                parent_reward: parent,
-                reward_info,
-            }),
-            Ok(None) => None,
-            Err(e) => {
-                let msg = format!("Failed to load miner rewards: {:?}", &e);
-                warn!("{}", &msg);
-                return Err(ChainstateError::InvalidStacksBlock(msg));
-            }
-        };
-        Ok(matured_miner_rewards_opt)
-    }
-
     /// Begin block-processing and return all of the pre-processed state within a
     /// `SetupBlockResult`.
     ///
@@ -2675,7 +2362,9 @@ impl NakamotoChainState {
     /// * burn_header_hash, burn_header_height: pointer to the Bitcoin block that identifies the
     /// tenure of this block to be processed
     /// * new_tenure: whether or not this block is the start of a new tenure
-    /// * tenure_height: the number of tenures that this block confirms (including epoch2 blocks)
+    /// * coinbase_height: the number of tenures that this block confirms (including epoch2 blocks)
+    ///   (this is equivalent to the number of coinbases)
+    /// * tenure_extend: whether or not to reset the tenure's ongoing execution cost
     ///
     /// Returns clarity_tx, list of receipts, microblock execution cost,
     /// microblock fees, microblock burns, list of microblock tx receipts,
@@ -2693,7 +2382,8 @@ impl NakamotoChainState {
         burn_header_hash: BurnchainHeaderHash,
         burn_header_height: u32,
         new_tenure: bool,
-        tenure_height: u64,
+        coinbase_height: u64,
+        tenure_extend: bool,
     ) -> Result<SetupBlockResult<'a, 'b>, ChainstateError> {
         let parent_index_hash = StacksBlockId::new(&parent_consensus_hash, &parent_header_hash);
         let parent_sortition_id = sortition_dbconn
@@ -2703,7 +2393,11 @@ impl NakamotoChainState {
 
         // find matured miner rewards, so we can grant them within the Clarity DB tx.
         let matured_rewards_schedule_opt = if new_tenure {
-            Self::get_matured_miner_reward_schedules(chainstate_tx, &tip_index_hash, tenure_height)?
+            Self::get_matured_miner_reward_schedules(
+                chainstate_tx,
+                &tip_index_hash,
+                coinbase_height,
+            )?
         } else {
             // no rewards if mid-tenure
             None
@@ -2743,8 +2437,9 @@ impl NakamotoChainState {
             .transpose()?
             .flatten();
 
-        // Nakamoto must load block cost from parent if this block isn't a tenure change
-        let initial_cost = if new_tenure {
+        // Nakamoto must load block cost from parent if this block isn't a tenure change.
+        // If this is a tenure-extend, then the execution cost is reset.
+        let initial_cost = if new_tenure || tenure_extend {
             ExecutionCost::zero()
         } else {
             let parent_cost_total =
@@ -2874,201 +2569,6 @@ impl NakamotoChainState {
         Ok(lockup_events)
     }
 
-    /// Check that a given Nakamoto block's tenure's sortition exists and was processed.
-    /// Return the sortition's burnchain block's hash and its burnchain height
-    /// TODO: unit test
-    pub(crate) fn check_sortition_exists(
-        burn_dbconn: &mut SortitionHandleTx,
-        block_consensus_hash: &ConsensusHash,
-    ) -> Result<(BurnchainHeaderHash, u64), ChainstateError> {
-        // check that the burnchain block that this block is associated with has been processed.
-        // N.B. we must first get its hash, and then verify that it's in the same Bitcoin fork as
-        // our `burn_dbconn` indicates.
-        let burn_header_hash =
-            SortitionDB::get_burnchain_header_hash_by_consensus(burn_dbconn, block_consensus_hash)?
-                .ok_or_else(|| {
-                    warn!(
-                        "Unrecognized consensus hash";
-                        "consensus_hash" => %block_consensus_hash,
-                    );
-                    ChainstateError::NoSuchBlockError
-                })?;
-
-        let sortition_tip = burn_dbconn.context.chain_tip.clone();
-        let burn_header_height = burn_dbconn
-            .get_block_snapshot(&burn_header_hash, &sortition_tip)?
-            .ok_or_else(|| {
-                warn!(
-                    "Tried to process Nakamoto block before its burn view was processed";
-                    "burn_header_hash" => %burn_header_hash,
-                );
-                ChainstateError::NoSuchBlockError
-            })?
-            .block_height;
-
-        Ok((burn_header_hash, burn_header_height))
-    }
-
-    /// Check that this block is in the same tenure as its parent, and that this tenure is the
-    /// highest-seen tenure.
-    /// Returns Ok(bool) to indicate whether or not this block is in the same tenure as its parent.
-    /// Returns Err(..) on DB error
-    /// TODO: unit test
-    pub(crate) fn check_tenure_continuity(
-        headers_conn: &Connection,
-        sort_tx: &mut SortitionHandleTx,
-        parent_ch: &ConsensusHash,
-        block_header: &NakamotoBlockHeader,
-    ) -> Result<bool, ChainstateError> {
-        // block must have the same consensus hash as its parent
-        if block_header.is_first_mined() || parent_ch != &block_header.consensus_hash {
-            return Ok(false);
-        }
-
-        // block must be in the same tenure as the highest-processed tenure
-        let Some(highest_tenure) = Self::get_highest_nakamoto_tenure(headers_conn, sort_tx)? else {
-            // no tenures yet, so definitely not continuous
-            return Ok(false);
-        };
-
-        if &highest_tenure.consensus_hash != parent_ch {
-            // this block is not in the highest-known tenure, so it can't be continuous
-            return Ok(false);
-        }
-
-        Ok(true)
-    }
-
-    /// Calculate the scheduled block-reward for this tenure.
-    /// - chainstate_tx: the transaction open against the chainstate
-    /// - burn_dbconn: the sortition fork tx open against the sortition DB
-    /// - block: the block being processed
-    /// - parent_tenure_height: the number of tenures represented by the parent of this block
-    /// - chain_tip_burn_header_height: the height of the burnchain block mined when this block was
-    /// produced
-    /// - burnchain_commit_burn: how many burnchain tokens were spent by this block's tenure's block-commit
-    /// - burnchain_sortition_burn: total burnchain tokens spent by all miners for this block's
-    /// tenure
-    ///
-    /// Returns the scheduled reward for this block's miner, subject to:
-    /// - accumulated STX from missed sortitions
-    /// - initial mining bonus, if any
-    /// - the coinbase reward at this burnchain block height
-    /// - the parent tenure's total fees
-    ///
-    /// TODO: unit test
-    pub(crate) fn calculate_scheduled_tenure_reward(
-        chainstate_tx: &mut ChainstateTx,
-        burn_dbconn: &mut SortitionHandleTx,
-        block: &NakamotoBlock,
-        evaluated_epoch: StacksEpochId,
-        parent_tenure_height: u64,
-        chain_tip_burn_header_height: u64,
-        burnchain_commit_burn: u64,
-        burnchain_sortition_burn: u64,
-    ) -> Result<MinerPaymentSchedule, ChainstateError> {
-        let mainnet = chainstate_tx.get_config().mainnet;
-
-        // figure out if there any accumulated rewards by
-        //   getting the snapshot that elected this block.
-        let accumulated_rewards = SortitionDB::get_block_snapshot_consensus(
-            burn_dbconn.tx(),
-            &block.header.consensus_hash,
-        )?
-        .expect("CORRUPTION: failed to load snapshot that elected processed block")
-        .accumulated_coinbase_ustx;
-
-        let coinbase_at_block = StacksChainState::get_coinbase_reward(
-            chain_tip_burn_header_height,
-            burn_dbconn.context.first_block_height,
-        );
-
-        let total_coinbase = coinbase_at_block.saturating_add(accumulated_rewards);
-        let parent_tenure_start_header: StacksHeaderInfo = Self::get_header_by_tenure_height(
-            chainstate_tx,
-            &block.header.parent_block_id,
-            parent_tenure_height,
-        )?
-        .ok_or_else(|| {
-            warn!("While processing tenure change, failed to look up parent tenure";
-                  "parent_tenure_height" => parent_tenure_height,
-                  "parent_block_id" => %block.header.parent_block_id,
-                  "block_hash" => %block.header.block_hash(),
-                  "block_consensus_hash" => %block.header.consensus_hash);
-            ChainstateError::NoSuchBlockError
-        })?;
-        // fetch the parent tenure fees by reading the total tx fees from this block's
-        // *parent* (not parent_tenure_start_header), because `parent_block_id` is the last
-        // block of that tenure, so contains a total fee accumulation for the whole tenure
-        let parent_tenure_fees = if parent_tenure_start_header.is_nakamoto_block() {
-            Self::get_total_tenure_tx_fees_at(
-                chainstate_tx,
-                &block.header.parent_block_id
-            )?.ok_or_else(|| {
-                warn!("While processing tenure change, failed to look up parent block's total tx fees";
-                      "parent_block_id" => %block.header.parent_block_id,
-                      "block_hash" => %block.header.block_hash(),
-                      "block_consensus_hash" => %block.header.consensus_hash);
-                ChainstateError::NoSuchBlockError
-            })?
-        } else {
-            // if the parent tenure is an epoch-2 block, don't pay
-            // any fees to them in this schedule: nakamoto blocks
-            // cannot confirm microblock transactions, and
-            // anchored transactions are scheduled
-            // by the parent in epoch-2.
-            0
-        };
-
-        Ok(Self::make_scheduled_miner_reward(
-            mainnet,
-            evaluated_epoch,
-            &parent_tenure_start_header.anchored_header.block_hash(),
-            &parent_tenure_start_header.consensus_hash,
-            &block.header.block_hash(),
-            &block.header.consensus_hash,
-            block.header.chain_length,
-            block
-                .get_coinbase_tx()
-                .ok_or(ChainstateError::InvalidStacksBlock(
-                    "No coinbase transaction in tenure changing block".into(),
-                ))?,
-            parent_tenure_fees,
-            burnchain_commit_burn,
-            burnchain_sortition_burn,
-            total_coinbase,
-        ))
-    }
-
-    /// Get the burnchain block info of a given tenure's consensus hash.
-    /// Used for the tx receipt.
-    /// TODO: unit test
-    pub(crate) fn get_tenure_burn_block_info(
-        burn_dbconn: &Connection,
-        first_mined: bool,
-        ch: &ConsensusHash,
-    ) -> Result<(BurnchainHeaderHash, u64, u64), ChainstateError> {
-        // get burn block stats, for the transaction receipt
-        let (burn_block_hash, burn_block_height, burn_block_timestamp) = if first_mined {
-            (BurnchainHeaderHash([0; 32]), 0, 0)
-        } else {
-            match SortitionDB::get_block_snapshot_consensus(burn_dbconn, ch)? {
-                Some(sn) => (
-                    sn.burn_header_hash,
-                    sn.block_height,
-                    sn.burn_header_timestamp,
-                ),
-                None => {
-                    // shouldn't happen
-                    warn!("CORRUPTION: {} does not correspond to a burn block", ch,);
-                    (BurnchainHeaderHash([0; 32]), 0, 0)
-                }
-            }
-        };
-
-        Ok((burn_block_hash, burn_block_height, burn_block_timestamp))
-    }
-
     /// Append a Nakamoto Stacks block to the Stacks chain state.
     pub fn append_block<'a>(
         chainstate_tx: &mut ChainstateTx,
@@ -3144,18 +2644,36 @@ impl NakamotoChainState {
             false
         };
 
-        let parent_tenure_height = if block.is_first_mined() {
+        let tenure_extend = if let Some(tenure_extend) = block.is_wellformed_tenure_extend_block() {
+            if !tenure_extend {
+                return Err(ChainstateError::InvalidStacksBlock(
+                    "Invalid tenure extend in nakamoto block".into(),
+                ));
+            }
+            if new_tenure {
+                return Err(ChainstateError::InvalidStacksBlock(
+                    "Both started and extended tenure".into(),
+                ));
+            }
+            true
+        } else {
+            false
+        };
+
+        let parent_coinbase_height = if block.is_first_mined() {
             0
         } else {
-            Self::get_tenure_height(chainstate_tx.deref(), &parent_block_id)?.ok_or_else(|| {
-                warn!(
-                    "Parent of Nakamoto block in block headers DB yet";
-                    "block_hash" => %block.header.block_hash(),
-                    "parent_block_hash" => %parent_block_hash,
-                    "parent_block_id" => %parent_block_id
-                );
-                ChainstateError::NoSuchBlockError
-            })?
+            Self::get_coinbase_height(chainstate_tx.deref(), &parent_block_id)?.ok_or_else(
+                || {
+                    warn!(
+                        "Parent of Nakamoto block in block headers DB yet";
+                        "block_hash" => %block.header.block_hash(),
+                        "parent_block_hash" => %parent_block_hash,
+                        "parent_block_id" => %parent_block_id
+                    );
+                    ChainstateError::NoSuchBlockError
+                },
+            )?
         };
 
         // verify VRF proof, if present
@@ -3176,12 +2694,16 @@ impl NakamotoChainState {
 
         // process the tenure-change if it happened, so that when block-processing begins, it happens in whatever the
         // current tenure is
-        let tenure_height =
-            Self::advance_nakamoto_tenure(chainstate_tx, burn_dbconn, block, parent_tenure_height)?;
+        let coinbase_height = Self::advance_nakamoto_tenure(
+            chainstate_tx,
+            burn_dbconn,
+            block,
+            parent_coinbase_height,
+        )?;
         if new_tenure {
             // tenure height must have advanced
-            if tenure_height
-                != parent_tenure_height
+            if coinbase_height
+                != parent_coinbase_height
                     .checked_add(1)
                     .expect("Too many tenures")
             {
@@ -3190,6 +2712,13 @@ impl NakamotoChainState {
                     "Could not advance tenure, even though tenure changed".into(),
                 ));
             }
+        } else {
+            if coinbase_height != parent_coinbase_height {
+                // this should be unreachable
+                return Err(ChainstateError::InvalidStacksBlock(
+                    "Advanced tenure even though a new tenure did not happen".into(),
+                ));
+            }
         }
 
         // begin processing this block
@@ -3217,7 +2746,8 @@ impl NakamotoChainState {
                 ChainstateError::InvalidStacksBlock("Burn block height exceeded u32".into())
             })?,
             new_tenure,
-            tenure_height,
+            coinbase_height,
+            tenure_extend,
         )?;
 
         let starting_cost = clarity_tx.cost_so_far();
@@ -3328,7 +2858,7 @@ impl NakamotoChainState {
                 burn_dbconn,
                 block,
                 evaluated_epoch,
-                parent_tenure_height,
+                parent_coinbase_height,
                 chain_tip_burn_header_height.into(),
                 burnchain_commit_burn,
                 burnchain_sortition_burn,

From 5139cf6ceac98575fd91faaba43065c9f9a89410 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Thu, 7 Dec 2023 09:55:24 -0500
Subject: [PATCH 0112/1166] feat: test that the query to find the highest
 tenure works even if the burnchain forks

---
 .../src/chainstate/nakamoto/tests/mod.rs      | 303 ++++++++++++++----
 1 file changed, 242 insertions(+), 61 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/tests/mod.rs b/stackslib/src/chainstate/nakamoto/tests/mod.rs
index 34d6910f51..c2bec8d9a1 100644
--- a/stackslib/src/chainstate/nakamoto/tests/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/mod.rs
@@ -34,14 +34,18 @@ use stdext::prelude::Integer;
 use stx_genesis::GenesisData;
 
 use crate::burnchains::{PoxConstants, Txid};
+use crate::chainstate::burn::db::sortdb::tests::make_fork_run;
 use crate::chainstate::burn::db::sortdb::SortitionDB;
 use crate::chainstate::burn::{BlockSnapshot, OpsHash, SortitionHash};
 use crate::chainstate::coordinator::tests::{
     get_burnchain, get_burnchain_db, get_chainstate, get_rw_sortdb, get_sortition_db, p2pkh_from,
     pox_addr_from, setup_states_with_epochs,
 };
+use crate::chainstate::nakamoto::coordinator::tests::boot_nakamoto;
+use crate::chainstate::nakamoto::tenure::NakamotoTenure;
+use crate::chainstate::nakamoto::tests::node::TestSigners;
 use crate::chainstate::nakamoto::{
-    NakamotoBlock, NakamotoBlockHeader, NakamotoChainState, NakamotoTenure,
+    NakamotoBlock, NakamotoBlockHeader, NakamotoChainState, FIRST_STACKS_BLOCK_ID,
 };
 use crate::chainstate::stacks::db::{
     ChainStateBootData, ChainstateAccountBalance, ChainstateAccountLockup, ChainstateBNSName,
@@ -152,40 +156,43 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
     };
 
     // sortition-inducing tenure change
-    let tenure_change_payload = TransactionPayload::TenureChange(TenureChangePayload {
-        consensus_hash: ConsensusHash([0x04; 20]),
-        prev_consensus_hash: ConsensusHash([0x03; 20]),
+    let tenure_change_payload = TenureChangePayload {
+        tenure_consensus_hash: ConsensusHash([0x04; 20]),
+        prev_tenure_consensus_hash: ConsensusHash([0x03; 20]),
+        sortition_consensus_hash: ConsensusHash([0x04; 20]),
         previous_tenure_end: header.parent_block_id.clone(),
         previous_tenure_blocks: 1,
         cause: TenureChangeCause::BlockFound,
         pubkey_hash: Hash160([0x02; 20]),
         signature: ThresholdSignature::mock(),
         signers: vec![],
-    });
+    };
 
     // non-sortition-inducing tenure change
-    let tenure_extend_payload = TransactionPayload::TenureChange(TenureChangePayload {
-        consensus_hash: ConsensusHash([0x04; 20]),
-        prev_consensus_hash: ConsensusHash([0x03; 20]),
+    let tenure_extend_payload = TenureChangePayload {
+        tenure_consensus_hash: ConsensusHash([0x04; 20]),
+        prev_tenure_consensus_hash: ConsensusHash([0x04; 20]),
+        sortition_consensus_hash: ConsensusHash([0x04; 20]),
         previous_tenure_end: header.parent_block_id.clone(),
         previous_tenure_blocks: 1,
         cause: TenureChangeCause::Extended,
         pubkey_hash: Hash160([0x02; 20]),
         signature: ThresholdSignature::mock(),
         signers: vec![],
-    });
+    };
 
-    let invalid_tenure_change_payload = TransactionPayload::TenureChange(TenureChangePayload {
+    let invalid_tenure_change_payload = TenureChangePayload {
         // bad parent block ID
-        consensus_hash: ConsensusHash([0x04; 20]),
-        prev_consensus_hash: ConsensusHash([0x03; 20]),
+        tenure_consensus_hash: ConsensusHash([0x04; 20]),
+        prev_tenure_consensus_hash: ConsensusHash([0x03; 20]),
+        sortition_consensus_hash: ConsensusHash([0x04; 20]),
         previous_tenure_end: StacksBlockId([0x00; 32]),
         previous_tenure_blocks: 1,
         cause: TenureChangeCause::BlockFound,
         pubkey_hash: Hash160([0x02; 20]),
         signature: ThresholdSignature::mock(),
         signers: vec![],
-    });
+    };
 
     let proof_bytes = hex_bytes("9275df67a68c8745c0ff97b48201ee6db447f7c93b23ae24cdc2400f52fdb08a1a6ac7ec71bf9c9c76e96ee4675ebff60625af28718501047bfd87b810c2d2139b73c23bd69de66360953a642c2a330a").unwrap();
     let proof = VRFProof::from_bytes(&proof_bytes[..].to_vec()).unwrap();
@@ -200,7 +207,7 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
     let mut tenure_change_tx = StacksTransaction::new(
         TransactionVersion::Testnet,
         TransactionAuth::from_p2pkh(&private_key).unwrap(),
-        tenure_change_payload.clone(),
+        TransactionPayload::TenureChange(tenure_change_payload.clone()),
     );
     tenure_change_tx.chain_id = 0x80000000;
     tenure_change_tx.anchor_mode = TransactionAnchorMode::OnChainOnly;
@@ -208,7 +215,7 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
     let mut tenure_extend_tx = StacksTransaction::new(
         TransactionVersion::Testnet,
         TransactionAuth::from_p2pkh(&private_key).unwrap(),
-        tenure_extend_payload.clone(),
+        TransactionPayload::TenureChange(tenure_extend_payload.clone()),
     );
     tenure_extend_tx.chain_id = 0x80000000;
     tenure_extend_tx.anchor_mode = TransactionAnchorMode::OnChainOnly;
@@ -216,7 +223,7 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
     let mut invalid_tenure_change_tx = StacksTransaction::new(
         TransactionVersion::Testnet,
         TransactionAuth::from_p2pkh(&private_key).unwrap(),
-        invalid_tenure_change_payload.clone(),
+        TransactionPayload::TenureChange(invalid_tenure_change_payload.clone()),
     );
     invalid_tenure_change_tx.chain_id = 0x80000000;
     invalid_tenure_change_tx.anchor_mode = TransactionAnchorMode::OnChainOnly;
@@ -270,8 +277,10 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
         txs: vec![tenure_change_tx.clone()],
     };
     assert_eq!(block.is_wellformed_tenure_start_block(), Some(false));
+    assert_eq!(block.is_wellformed_tenure_extend_block(), Some(false));
     assert_eq!(block.get_coinbase_tx(), None);
-    assert_eq!(block.get_tenure_change_tx(), None);
+    assert_eq!(block.get_tenure_change_tx_payload(), None);
+    assert_eq!(block.get_tenure_extend_tx_payload(), None);
     assert_eq!(block.get_vrf_proof(), None);
     assert_eq!(
         block.validate_transactions_static(false, 0x80000000, StacksEpochId::Epoch30),
@@ -284,8 +293,10 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
         txs: vec![coinbase_tx.clone()],
     };
     assert_eq!(block.is_wellformed_tenure_start_block(), Some(false));
+    assert_eq!(block.is_wellformed_tenure_extend_block(), None);
     assert_eq!(block.get_coinbase_tx(), None);
-    assert_eq!(block.get_tenure_change_tx(), None);
+    assert_eq!(block.get_tenure_change_tx_payload(), None);
+    assert_eq!(block.get_tenure_extend_tx_payload(), None);
     assert_eq!(block.get_vrf_proof(), None);
     assert_eq!(
         block.validate_transactions_static(false, 0x80000000, StacksEpochId::Epoch30),
@@ -299,8 +310,10 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
         txs: vec![tenure_change_tx.clone(), invalid_coinbase_tx.clone()],
     };
     assert_eq!(block.is_wellformed_tenure_start_block(), Some(false));
+    assert_eq!(block.is_wellformed_tenure_extend_block(), None);
     assert_eq!(block.get_coinbase_tx(), None);
-    assert_eq!(block.get_tenure_change_tx(), None);
+    assert_eq!(block.get_tenure_change_tx_payload(), None);
+    assert_eq!(block.get_tenure_extend_tx_payload(), None);
     assert_eq!(block.get_vrf_proof(), None);
     assert_eq!(
         block.validate_transactions_static(false, 0x80000000, StacksEpochId::Epoch30),
@@ -317,8 +330,10 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
         ],
     };
     assert_eq!(block.is_wellformed_tenure_start_block(), Some(false));
+    assert_eq!(block.is_wellformed_tenure_extend_block(), None);
     assert_eq!(block.get_coinbase_tx(), None);
-    assert_eq!(block.get_tenure_change_tx(), None);
+    assert_eq!(block.get_tenure_change_tx_payload(), None);
+    assert_eq!(block.get_tenure_extend_tx_payload(), None);
     assert_eq!(block.get_vrf_proof(), None);
     assert_eq!(
         block.validate_transactions_static(false, 0x80000000, StacksEpochId::Epoch30),
@@ -331,8 +346,10 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
         txs: vec![coinbase_tx.clone(), tenure_change_tx.clone()],
     };
     assert_eq!(block.is_wellformed_tenure_start_block(), Some(false));
+    assert_eq!(block.is_wellformed_tenure_extend_block(), None);
     assert_eq!(block.get_coinbase_tx(), None);
-    assert_eq!(block.get_tenure_change_tx(), None);
+    assert_eq!(block.get_tenure_change_tx_payload(), None);
+    assert_eq!(block.get_tenure_extend_tx_payload(), None);
     assert_eq!(block.get_vrf_proof(), None);
     assert_eq!(
         block.validate_transactions_static(false, 0x80000000, StacksEpochId::Epoch30),
@@ -349,8 +366,10 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
         ],
     };
     assert_eq!(block.is_wellformed_tenure_start_block(), Some(false));
+    assert_eq!(block.is_wellformed_tenure_extend_block(), None);
     assert_eq!(block.get_coinbase_tx(), None);
-    assert_eq!(block.get_tenure_change_tx(), None);
+    assert_eq!(block.get_tenure_change_tx_payload(), None);
+    assert_eq!(block.get_tenure_extend_tx_payload(), None);
     assert_eq!(block.get_vrf_proof(), None);
     assert_eq!(
         block.validate_transactions_static(false, 0x80000000, StacksEpochId::Epoch30),
@@ -367,8 +386,10 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
         ],
     };
     assert_eq!(block.is_wellformed_tenure_start_block(), Some(false));
+    assert_eq!(block.is_wellformed_tenure_extend_block(), None);
     assert_eq!(block.get_coinbase_tx(), None);
-    assert_eq!(block.get_tenure_change_tx(), None);
+    assert_eq!(block.get_tenure_change_tx_payload(), None);
+    assert_eq!(block.get_tenure_extend_tx_payload(), None);
     assert_eq!(block.get_vrf_proof(), None);
     assert_eq!(
         block.validate_transactions_static(false, 0x80000000, StacksEpochId::Epoch30),
@@ -382,8 +403,13 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
         txs: vec![tenure_change_tx.clone(), coinbase_tx.clone()],
     };
     assert_eq!(block.is_wellformed_tenure_start_block(), Some(true));
+    assert_eq!(block.is_wellformed_tenure_extend_block(), None);
     assert_eq!(block.get_coinbase_tx(), Some(&coinbase_tx));
-    assert_eq!(block.get_tenure_change_tx(), Some(&tenure_change_tx));
+    assert_eq!(
+        block.get_tenure_change_tx_payload(),
+        Some(&tenure_change_payload)
+    );
+    assert_eq!(block.get_tenure_extend_tx_payload(), None);
     assert_eq!(block.get_vrf_proof(), Some(&proof));
     assert_eq!(
         block.validate_transactions_static(false, 0x80000000, StacksEpochId::Epoch30),
@@ -397,8 +423,13 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
         txs: vec![tenure_extend_tx.clone()],
     };
     assert_eq!(block.is_wellformed_tenure_start_block(), None);
+    assert_eq!(block.is_wellformed_tenure_extend_block(), Some(true));
     assert_eq!(block.get_coinbase_tx(), None);
-    assert_eq!(block.get_tenure_change_tx(), Some(&tenure_extend_tx));
+    assert_eq!(block.get_tenure_change_tx_payload(), None);
+    assert_eq!(
+        block.get_tenure_extend_tx_payload(),
+        Some(&tenure_extend_payload)
+    );
     assert_eq!(block.get_vrf_proof(), None);
     assert_eq!(
         block.validate_transactions_static(false, 0x80000000, StacksEpochId::Epoch30),
@@ -412,8 +443,13 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
         txs: vec![tenure_extend_tx.clone(), stx_transfer.clone()],
     };
     assert_eq!(block.is_wellformed_tenure_start_block(), None);
+    assert_eq!(block.is_wellformed_tenure_extend_block(), Some(true));
     assert_eq!(block.get_coinbase_tx(), None);
-    assert_eq!(block.get_tenure_change_tx(), Some(&tenure_extend_tx));
+    assert_eq!(block.get_tenure_change_tx_payload(), None);
+    assert_eq!(
+        block.get_tenure_extend_tx_payload(),
+        Some(&tenure_extend_payload)
+    );
     assert_eq!(block.get_vrf_proof(), None);
     assert_eq!(
         block.validate_transactions_static(false, 0x80000000, StacksEpochId::Epoch30),
@@ -426,8 +462,10 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
         txs: vec![tenure_extend_tx.clone(), tenure_extend_tx.clone()],
     };
     assert_eq!(block.is_wellformed_tenure_start_block(), Some(false));
+    assert_eq!(block.is_wellformed_tenure_extend_block(), Some(false));
     assert_eq!(block.get_coinbase_tx(), None);
-    assert_eq!(block.get_tenure_change_tx(), None);
+    assert_eq!(block.get_tenure_change_tx_payload(), None);
+    assert_eq!(block.get_tenure_extend_tx_payload(), None);
     assert_eq!(block.get_vrf_proof(), None);
     assert_eq!(
         block.validate_transactions_static(false, 0x80000000, StacksEpochId::Epoch30),
@@ -440,8 +478,10 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
         txs: vec![stx_transfer.clone(), tenure_extend_tx.clone()],
     };
     assert_eq!(block.is_wellformed_tenure_start_block(), Some(false));
+    assert_eq!(block.is_wellformed_tenure_extend_block(), Some(false));
     assert_eq!(block.get_coinbase_tx(), None);
-    assert_eq!(block.get_tenure_change_tx(), None);
+    assert_eq!(block.get_tenure_change_tx_payload(), None);
+    assert_eq!(block.get_tenure_extend_tx_payload(), None);
     assert_eq!(block.get_vrf_proof(), None);
     assert_eq!(
         block.validate_transactions_static(false, 0x80000000, StacksEpochId::Epoch30),
@@ -458,8 +498,10 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
         ],
     };
     assert_eq!(block.is_wellformed_tenure_start_block(), Some(false));
+    assert_eq!(block.is_wellformed_tenure_extend_block(), None);
     assert_eq!(block.get_coinbase_tx(), None);
-    assert_eq!(block.get_tenure_change_tx(), None);
+    assert_eq!(block.get_tenure_change_tx_payload(), None);
+    assert_eq!(block.get_tenure_extend_tx_payload(), None);
     assert_eq!(block.get_vrf_proof(), None);
     assert_eq!(
         block.validate_transactions_static(false, 0x80000000, StacksEpochId::Epoch30),
@@ -556,8 +598,9 @@ pub fn test_load_store_update_nakamoto_blocks() {
     };
 
     let tenure_change_payload = TenureChangePayload {
-        consensus_hash: ConsensusHash([0x04; 20]), // same as in nakamoto header
-        prev_consensus_hash: ConsensusHash([0x01; 20]),
+        tenure_consensus_hash: ConsensusHash([0x04; 20]), // same as in nakamoto header
+        prev_tenure_consensus_hash: ConsensusHash([0x01; 20]),
+        sortition_consensus_hash: ConsensusHash([0x04; 20]),
         previous_tenure_end: epoch2_parent_block_id.clone(),
         previous_tenure_blocks: 1,
         cause: TenureChangeCause::BlockFound,
@@ -609,7 +652,7 @@ pub fn test_load_store_update_nakamoto_blocks() {
         version: 1,
         chain_length: 457,
         burn_spent: 126,
-        consensus_hash: tenure_change_payload.consensus_hash.clone(),
+        consensus_hash: tenure_change_payload.tenure_consensus_hash.clone(),
         parent_block_id: epoch2_parent_block_id.clone(),
         tx_merkle_root: nakamoto_tx_merkle_root,
         state_index_root: TrieHash([0x07; 32]),
@@ -652,7 +695,7 @@ pub fn test_load_store_update_nakamoto_blocks() {
         version: 1,
         chain_length: 458,
         burn_spent: 127,
-        consensus_hash: tenure_change_payload.consensus_hash.clone(),
+        consensus_hash: tenure_change_payload.tenure_consensus_hash.clone(),
         parent_block_id: nakamoto_header.block_id(),
         tx_merkle_root: nakamoto_tx_merkle_root_2,
         state_index_root: TrieHash([0x07; 32]),
@@ -691,11 +734,14 @@ pub fn test_load_store_update_nakamoto_blocks() {
         .unwrap();
 
     let nakamoto_tenure = NakamotoTenure {
-        consensus_hash: tenure_change_payload.consensus_hash.clone(),
-        prev_consensus_hash: tenure_change_payload.prev_consensus_hash.clone(),
+        tenure_id_consensus_hash: tenure_change_payload.tenure_consensus_hash.clone(),
+        prev_tenure_id_consensus_hash: tenure_change_payload.prev_tenure_consensus_hash.clone(),
+        sortition_consensus_hash: tenure_change_payload.sortition_consensus_hash.clone(),
+        cause: tenure_change_payload.cause,
         block_hash: nakamoto_block.header.block_hash(),
         block_id: nakamoto_block.header.block_id(),
-        tenure_height: epoch2_header.total_work.work + 1,
+        coinbase_height: epoch2_header.total_work.work + 1,
+        tenure_index: 1,
         num_blocks_confirmed: 1,
     };
 
@@ -722,7 +768,7 @@ pub fn test_load_store_update_nakamoto_blocks() {
 
         // no tenure rows
         assert_eq!(
-            NakamotoChainState::get_highest_nakamoto_tenure_height(&tx).unwrap(),
+            NakamotoChainState::get_highest_nakamoto_coinbase_height(&tx, i64::MAX as u64).unwrap(),
             None
         );
 
@@ -731,7 +777,8 @@ pub fn test_load_store_update_nakamoto_blocks() {
             &tx,
             &tenure_change_payload
         )
-        .unwrap());
+        .unwrap()
+        .is_some());
 
         // this will fail without a tenure (e.g. due to foreign key constraints)
         NakamotoChainState::insert_stacks_block_header(
@@ -758,7 +805,7 @@ pub fn test_load_store_update_nakamoto_blocks() {
 
         // no tenure rows
         assert_eq!(
-            NakamotoChainState::get_highest_nakamoto_tenure_height(&tx).unwrap(),
+            NakamotoChainState::get_highest_nakamoto_coinbase_height(&tx, i64::MAX as u64).unwrap(),
             None
         );
 
@@ -767,6 +814,7 @@ pub fn test_load_store_update_nakamoto_blocks() {
             &tx,
             &nakamoto_header,
             epoch2_header.total_work.work + 1,
+            1,
             &tenure_change_payload,
         )
         .unwrap();
@@ -783,7 +831,7 @@ pub fn test_load_store_update_nakamoto_blocks() {
 
         // have a tenure
         assert_eq!(
-            NakamotoChainState::get_highest_nakamoto_tenure_height(&tx)
+            NakamotoChainState::get_highest_nakamoto_coinbase_height(&tx, i64::MAX as u64)
                 .unwrap()
                 .unwrap(),
             epoch2_header.total_work.work + 1
@@ -815,7 +863,7 @@ pub fn test_load_store_update_nakamoto_blocks() {
 
         // same tenure
         assert_eq!(
-            NakamotoChainState::get_highest_nakamoto_tenure_height(&tx)
+            NakamotoChainState::get_highest_nakamoto_coinbase_height(&tx, i64::MAX as u64)
                 .unwrap()
                 .unwrap(),
             epoch2_header.total_work.work + 1
@@ -848,7 +896,7 @@ pub fn test_load_store_update_nakamoto_blocks() {
 
         // same tenure
         assert_eq!(
-            NakamotoChainState::get_highest_nakamoto_tenure_height(&tx)
+            NakamotoChainState::get_highest_nakamoto_coinbase_height(&tx, i64::MAX as u64)
                 .unwrap()
                 .unwrap(),
             epoch2_header.total_work.work + 1
@@ -1029,19 +1077,19 @@ pub fn test_load_store_update_nakamoto_blocks() {
 
     // can get tenure height of nakamoto blocks and epoch2 blocks
     assert_eq!(
-        NakamotoChainState::get_tenure_height(chainstate.db(), &nakamoto_header.block_id())
+        NakamotoChainState::get_coinbase_height(chainstate.db(), &nakamoto_header.block_id())
             .unwrap()
             .unwrap(),
         epoch2_header_info.anchored_header.height() + 1
     );
     assert_eq!(
-        NakamotoChainState::get_tenure_height(chainstate.db(), &nakamoto_header_2.block_id())
+        NakamotoChainState::get_coinbase_height(chainstate.db(), &nakamoto_header_2.block_id())
             .unwrap()
             .unwrap(),
         epoch2_header_info.anchored_header.height() + 1
     );
     assert_eq!(
-        NakamotoChainState::get_tenure_height(
+        NakamotoChainState::get_coinbase_height(
             chainstate.db(),
             &epoch2_header_info.index_block_hash()
         )
@@ -1179,7 +1227,7 @@ pub fn test_load_store_update_nakamoto_blocks() {
 
 /// Tests:
 /// * NakamotoBlockHeader::check_miner_signature
-/// * NakamotoBlockHeader::check_tenure_change_tx
+/// * NakamotoBlockHeader::check_tenure_tx
 /// * NakamotoBlockHeader::check_coinbase_tx
 #[test]
 fn test_nakamoto_block_static_verification() {
@@ -1203,8 +1251,9 @@ fn test_nakamoto_block_static_verification() {
     coinbase_tx.anchor_mode = TransactionAnchorMode::OnChainOnly;
 
     let tenure_change_payload = TenureChangePayload {
-        consensus_hash: ConsensusHash([0x04; 20]), // same as in nakamoto header
-        prev_consensus_hash: ConsensusHash([0x01; 20]),
+        tenure_consensus_hash: ConsensusHash([0x04; 20]), // same as in nakamoto header
+        prev_tenure_consensus_hash: ConsensusHash([0x01; 20]),
+        sortition_consensus_hash: ConsensusHash([0x04; 20]),
         previous_tenure_end: StacksBlockId([0x03; 32]),
         previous_tenure_blocks: 1,
         cause: TenureChangeCause::BlockFound,
@@ -1214,8 +1263,9 @@ fn test_nakamoto_block_static_verification() {
     };
 
     let tenure_change_payload_bad_ch = TenureChangePayload {
-        consensus_hash: ConsensusHash([0x05; 20]), // wrong
-        prev_consensus_hash: ConsensusHash([0x01; 20]),
+        tenure_consensus_hash: ConsensusHash([0x05; 20]), // wrong
+        prev_tenure_consensus_hash: ConsensusHash([0x01; 20]),
+        sortition_consensus_hash: ConsensusHash([0x04; 20]),
         previous_tenure_end: StacksBlockId([0x03; 32]),
         previous_tenure_blocks: 1,
         cause: TenureChangeCause::BlockFound,
@@ -1225,8 +1275,9 @@ fn test_nakamoto_block_static_verification() {
     };
 
     let tenure_change_payload_bad_miner_sig = TenureChangePayload {
-        consensus_hash: ConsensusHash([0x04; 20]), // same as in nakamoto header
-        prev_consensus_hash: ConsensusHash([0x01; 20]),
+        tenure_consensus_hash: ConsensusHash([0x04; 20]), // same as in nakamoto header
+        prev_tenure_consensus_hash: ConsensusHash([0x01; 20]),
+        sortition_consensus_hash: ConsensusHash([0x04; 20]),
         previous_tenure_end: StacksBlockId([0x03; 32]),
         previous_tenure_blocks: 1,
         cause: TenureChangeCause::BlockFound,
@@ -1299,7 +1350,7 @@ fn test_nakamoto_block_static_verification() {
         version: 1,
         chain_length: 457,
         burn_spent: 126,
-        consensus_hash: tenure_change_payload.consensus_hash.clone(),
+        consensus_hash: tenure_change_payload.tenure_consensus_hash.clone(),
         parent_block_id: StacksBlockId([0x03; 32]),
         tx_merkle_root: nakamoto_tx_merkle_root,
         state_index_root: TrieHash([0x07; 32]),
@@ -1317,7 +1368,7 @@ fn test_nakamoto_block_static_verification() {
         version: 1,
         chain_length: 457,
         burn_spent: 126,
-        consensus_hash: tenure_change_payload.consensus_hash.clone(),
+        consensus_hash: tenure_change_payload.tenure_consensus_hash.clone(),
         parent_block_id: StacksBlockId([0x03; 32]),
         tx_merkle_root: nakamoto_tx_merkle_root_bad_ch,
         state_index_root: TrieHash([0x07; 32]),
@@ -1335,7 +1386,7 @@ fn test_nakamoto_block_static_verification() {
         version: 1,
         chain_length: 457,
         burn_spent: 126,
-        consensus_hash: tenure_change_payload.consensus_hash.clone(),
+        consensus_hash: tenure_change_payload.tenure_consensus_hash.clone(),
         parent_block_id: StacksBlockId([0x03; 32]),
         tx_merkle_root: nakamoto_tx_merkle_root_bad_miner_sig,
         state_index_root: TrieHash([0x07; 32]),
@@ -1356,7 +1407,7 @@ fn test_nakamoto_block_static_verification() {
         StacksPublicKey::from_private(&private_key)
     );
     assert_eq!(
-        nakamoto_block.get_miner_pubkh().unwrap(),
+        nakamoto_block.recover_miner_pubkh().unwrap(),
         tenure_change_payload.pubkey_hash
     );
 
@@ -1369,11 +1420,9 @@ fn test_nakamoto_block_static_verification() {
         ))
         .is_err());
 
-    assert!(nakamoto_block.check_tenure_change_tx().is_ok());
-    assert!(nakamoto_block_bad_ch.check_tenure_change_tx().is_err());
-    assert!(nakamoto_block_bad_miner_sig
-        .check_tenure_change_tx()
-        .is_err());
+    assert!(nakamoto_block.check_tenure_tx().is_ok());
+    assert!(nakamoto_block_bad_ch.check_tenure_tx().is_err());
+    assert!(nakamoto_block_bad_miner_sig.check_tenure_tx().is_err());
 
     let vrf_alt_privkey = VRFPrivateKey::new();
     let vrf_alt_pubkey = VRFPublicKey::from_private(&vrf_alt_privkey);
@@ -1388,3 +1437,135 @@ fn test_nakamoto_block_static_verification() {
         .check_coinbase_tx(&vrf_alt_pubkey, &sortition_hash)
         .is_err());
 }
+
+/// Tests that getting the highest nakamoto tenure works in the presence of forks
+#[test]
+pub fn test_get_highest_nakamoto_tenure() {
+    let test_signers = TestSigners::default();
+    let mut peer = boot_nakamoto(function_name!(), vec![], test_signers.aggregate_public_key);
+
+    // extract chainstate and sortdb -- we don't need the peer anymore
+    let chainstate = &mut peer.stacks_node.as_mut().unwrap().chainstate;
+    let sort_db = peer.sortdb.as_mut().unwrap();
+
+    // seed a single fork of tenures
+    let last_snapshot = SortitionDB::get_canonical_burn_chain_tip(sort_db.conn()).unwrap();
+    let snapshots = make_fork_run(sort_db, &last_snapshot, 5, 0);
+    let mut last_header: Option<NakamotoBlockHeader> = None;
+    let mut last_tenure_change: Option<TenureChangePayload> = None;
+    let mut all_headers = vec![];
+    let mut all_tenure_changes = vec![];
+    for (i, sn) in snapshots.iter().enumerate() {
+        let block_header = NakamotoBlockHeader {
+            version: 0,
+            chain_length: i as u64,
+            burn_spent: i as u64,
+            consensus_hash: sn.consensus_hash.clone(),
+            parent_block_id: last_header
+                .as_ref()
+                .map(|hdr| hdr.block_id())
+                .unwrap_or(FIRST_STACKS_BLOCK_ID.clone()),
+            tx_merkle_root: Sha512Trunc256Sum([0x00; 32]),
+            state_index_root: TrieHash([0x00; 32]),
+            miner_signature: MessageSignature::empty(),
+            signer_signature: ThresholdSignature::mock(),
+        };
+        let tenure_change = TenureChangePayload {
+            tenure_consensus_hash: sn.consensus_hash.clone(),
+            prev_tenure_consensus_hash: last_tenure_change
+                .as_ref()
+                .map(|tc| tc.tenure_consensus_hash.clone())
+                .unwrap_or(FIRST_BURNCHAIN_CONSENSUS_HASH.clone()),
+            sortition_consensus_hash: sn.consensus_hash.clone(),
+            previous_tenure_end: block_header.block_id(),
+            previous_tenure_blocks: 1,
+            cause: TenureChangeCause::BlockFound,
+            pubkey_hash: Hash160([0x00; 20]),
+            signature: ThresholdSignature::mock(),
+            signers: vec![],
+        };
+
+        let tx = chainstate.db_tx_begin().unwrap();
+        NakamotoChainState::insert_nakamoto_tenure(
+            &tx,
+            &block_header,
+            1 + i as u64,
+            1 + i as u64,
+            &tenure_change,
+        )
+        .unwrap();
+        tx.commit().unwrap();
+
+        all_headers.push(block_header.clone());
+        all_tenure_changes.push(tenure_change.clone());
+
+        last_header = Some(block_header);
+        last_tenure_change = Some(tenure_change);
+    }
+
+    // highest tenure should be the last one we inserted
+    let tip = SortitionDB::get_canonical_burn_chain_tip(sort_db.conn()).unwrap();
+    debug!("tip = {:?}", &tip);
+    let highest_tenure = NakamotoChainState::get_highest_nakamoto_tenure(
+        chainstate.db(),
+        &mut sort_db.index_handle(&tip.sortition_id),
+    )
+    .unwrap()
+    .unwrap();
+
+    let last_tenure_change = last_tenure_change.unwrap();
+    let last_header = last_header.unwrap();
+    assert_eq!(
+        highest_tenure.tenure_id_consensus_hash,
+        last_tenure_change.tenure_consensus_hash
+    );
+    assert_eq!(
+        highest_tenure.prev_tenure_id_consensus_hash,
+        last_tenure_change.prev_tenure_consensus_hash
+    );
+    assert_eq!(
+        highest_tenure.sortition_consensus_hash,
+        last_tenure_change.sortition_consensus_hash
+    );
+    assert_eq!(highest_tenure.cause, last_tenure_change.cause);
+    assert_eq!(highest_tenure.block_hash, last_header.block_hash());
+    assert_eq!(highest_tenure.block_id, last_header.block_id());
+    assert_eq!(highest_tenure.coinbase_height, 5);
+    assert_eq!(highest_tenure.tenure_index, 5);
+    assert_eq!(highest_tenure.num_blocks_confirmed, 1);
+
+    // uh oh, a bitcoin fork!
+    let last_snapshot = snapshots[2].clone();
+    let snapshots = make_fork_run(sort_db, &last_snapshot, 7, 0x80);
+
+    let new_tip = SortitionDB::get_canonical_burn_chain_tip(sort_db.conn()).unwrap();
+    debug!("tip = {:?}", &new_tip);
+
+    // new tip doesn't include the last two tenures
+    let highest_tenure = NakamotoChainState::get_highest_nakamoto_tenure(
+        chainstate.db(),
+        &mut sort_db.index_handle(&new_tip.sortition_id),
+    )
+    .unwrap()
+    .unwrap();
+    let last_tenure_change = &all_tenure_changes[2];
+    let last_header = &all_headers[2];
+    assert_eq!(
+        highest_tenure.tenure_id_consensus_hash,
+        last_tenure_change.tenure_consensus_hash
+    );
+    assert_eq!(
+        highest_tenure.prev_tenure_id_consensus_hash,
+        last_tenure_change.prev_tenure_consensus_hash
+    );
+    assert_eq!(
+        highest_tenure.sortition_consensus_hash,
+        last_tenure_change.sortition_consensus_hash
+    );
+    assert_eq!(highest_tenure.cause, last_tenure_change.cause);
+    assert_eq!(highest_tenure.block_hash, last_header.block_hash());
+    assert_eq!(highest_tenure.block_id, last_header.block_id());
+    assert_eq!(highest_tenure.coinbase_height, 3);
+    assert_eq!(highest_tenure.tenure_index, 3);
+    assert_eq!(highest_tenure.num_blocks_confirmed, 1);
+}

From 6e34e3b7232af065e127a6046d39fade882d7fe8 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Thu, 7 Dec 2023 09:55:47 -0500
Subject: [PATCH 0113/1166] chore: refactor test code so that the caller
 supplies the tenure-change and coinbase transactions

---
 .../src/chainstate/nakamoto/tests/node.rs     | 207 +++++++++++++-----
 1 file changed, 153 insertions(+), 54 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/tests/node.rs b/stackslib/src/chainstate/nakamoto/tests/node.rs
index 63f79776b8..ca901d0181 100644
--- a/stackslib/src/chainstate/nakamoto/tests/node.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/node.rs
@@ -47,7 +47,7 @@ use crate::chainstate::coordinator::{
 use crate::chainstate::nakamoto::coordinator::get_nakamoto_next_recipients;
 use crate::chainstate::nakamoto::miner::NakamotoBlockBuilder;
 use crate::chainstate::nakamoto::tests::get_account;
-use crate::chainstate::nakamoto::{NakamotoBlock, NakamotoChainState};
+use crate::chainstate::nakamoto::{NakamotoBlock, NakamotoBlockHeader, NakamotoChainState};
 use crate::chainstate::stacks::address::PoxAddress;
 use crate::chainstate::stacks::db::blocks::test::store_staging_block;
 use crate::chainstate::stacks::db::test::*;
@@ -349,11 +349,20 @@ impl TestStacksNode {
         block_commit_op
     }
 
-    /// Record the nakamoto tenure blocks
+    /// Record the nakamoto blocks as a new tenure
     pub fn add_nakamoto_tenure_blocks(&mut self, tenure_blocks: Vec<NakamotoBlock>) {
         self.nakamoto_blocks.push(tenure_blocks);
     }
 
+    /// Record the nakamoto blocks as an extension of the current tenure
+    pub fn add_nakamoto_extended_blocks(&mut self, mut tenure_blocks: Vec<NakamotoBlock>) {
+        if let Some(ref mut blks) = self.nakamoto_blocks.last_mut() {
+            blks.append(&mut tenure_blocks);
+        } else {
+            panic!("Tried to extend a tenure when no tenures exist");
+        }
+    }
+
     /// Begin the next Nakamoto tenure.
     /// Create a block-commit, as well as a tenure change and VRF proof for use in a follow-on call
     /// to make_nakamoto_tenure_blocks()
@@ -370,7 +379,9 @@ impl TestStacksNode {
         burn_amount: u64,
         tenure_change_cause: TenureChangeCause,
     ) -> (LeaderBlockCommitOp, TenureChangePayload) {
-        let (last_tenure_id, previous_tenure_end, previous_tenure_blocks, parent_block_snapshot) =
+        // this is the tenure that the block-commit confirms.
+        // It's not the last-ever tenure; it's the one just before it.
+        let (last_tenure_id, parent_block_snapshot) =
             if let Some(parent_blocks) = parent_nakamoto_tenure {
                 // parent is an epoch 3 nakamoto block
                 let first_parent = parent_blocks.first().unwrap();
@@ -394,12 +405,7 @@ impl TestStacksNode {
                     last_parent.header.chain_length + 1,
                 );
 
-                (
-                    parent_tenure_id,
-                    last_parent.header.block_id(),
-                    parent_blocks.len(),
-                    parent_sortition,
-                )
+                (parent_tenure_id, parent_sortition)
             } else if let Some(parent_stacks_block) = parent_stacks_block {
                 // building off an existing stacks block
                 let parent_stacks_block_snapshot = {
@@ -433,22 +439,39 @@ impl TestStacksNode {
                     parent_chain_tip.anchored_header.height(),
                 );
 
-                (
-                    parent_tenure_id.clone(),
-                    parent_tenure_id,
-                    1,
-                    parent_stacks_block_snapshot,
-                )
+                (parent_tenure_id, parent_stacks_block_snapshot)
             } else {
                 panic!("Neither Nakamoto nor epoch2 parent found");
             };
 
-        let previous_tenure_blocks =
-            u32::try_from(previous_tenure_blocks).expect("FATAL: too many blocks from last miner");
+        // the tenure-change contains a pointer to the end of the last tenure, which is currently
+        // the canonical tip
+        let (previous_tenure_end, previous_tenure_consensus_hash, previous_tenure_blocks) = {
+            let hdr = NakamotoChainState::get_canonical_block_header(self.chainstate.db(), &sortdb)
+                .unwrap()
+                .unwrap();
+            if hdr.anchored_header.as_stacks_nakamoto().is_some() {
+                // building atop nakamoto
+                let tenure_len = NakamotoChainState::get_nakamoto_tenure_length(
+                    self.chainstate.db(),
+                    &hdr.consensus_hash,
+                )
+                .unwrap();
+                (hdr.index_block_hash(), hdr.consensus_hash, tenure_len)
+            } else {
+                // building atop epoch2
+                (
+                    last_tenure_id,
+                    parent_block_snapshot.consensus_hash.clone(),
+                    1,
+                )
+            }
+        };
 
         let tenure_change_payload = TenureChangePayload {
-            consensus_hash: ConsensusHash([0x00; 20]), // will be overwritten
-            prev_consensus_hash: parent_block_snapshot.consensus_hash.clone(),
+            tenure_consensus_hash: ConsensusHash([0x00; 20]), // will be overwritten
+            prev_tenure_consensus_hash: previous_tenure_consensus_hash,
+            sortition_consensus_hash: ConsensusHash([0x00; 20]), // will be overwritten
             previous_tenure_end,
             previous_tenure_blocks,
             cause: tenure_change_cause,
@@ -470,16 +493,17 @@ impl TestStacksNode {
         (block_commit_op, tenure_change_payload)
     }
 
-    /// Construct a full Nakamoto tenure with the given block builder.
-    /// The first block will contain a coinbase and a tenure-change.
+    /// Construct or extend a full Nakamoto tenure with the given block builder.
+    /// The first block will contain a coinbase, if coinbase is Some(..)
     /// Process the blocks via the chains coordinator as we produce them.
     pub fn make_nakamoto_tenure_blocks<'a, F>(
         chainstate: &mut StacksChainState,
         sortdb: &SortitionDB,
         miner: &mut TestMiner,
         signers: &mut TestSigners,
-        proof: VRFProof,
-        tenure_change_payload: TenureChangePayload,
+        tenure_id_consensus_hash: &ConsensusHash,
+        mut tenure_change: Option<StacksTransaction>,
+        mut coinbase: Option<StacksTransaction>,
         coord: &mut ChainsCoordinator<
             'a,
             TestEventObserver,
@@ -496,27 +520,24 @@ impl TestStacksNode {
             &mut TestMiner,
             &mut StacksChainState,
             &SortitionDB,
-            usize,
+            &[(NakamotoBlock, u64, ExecutionCost)],
         ) -> Vec<StacksTransaction>,
     {
         let miner_addr = miner.origin_address().unwrap();
         let miner_account = get_account(chainstate, sortdb, &miner_addr);
         miner.set_nonce(miner_account.nonce);
 
-        let mut tenure_change = Some(miner.make_nakamoto_tenure_change(tenure_change_payload));
-        let mut coinbase = Some(miner.make_nakamoto_coinbase(None, proof.clone()));
-
         let mut blocks = vec![];
         let mut block_count = 0;
         loop {
             let mut txs = vec![];
-            if let Some(tenure_change) = tenure_change.take() {
+            if let Some(tenure_change) = tenure_change.clone().take() {
                 txs.push(tenure_change);
             }
-            if let Some(coinbase) = coinbase.take() {
+            if let Some(coinbase) = coinbase.clone().take() {
                 txs.push(coinbase);
             }
-            let mut next_block_txs = block_builder(miner, chainstate, sortdb, block_count);
+            let mut next_block_txs = block_builder(miner, chainstate, sortdb, &blocks);
             txs.append(&mut next_block_txs);
 
             if txs.len() == 0 {
@@ -528,8 +549,8 @@ impl TestStacksNode {
             let burn_tip = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn()).unwrap();
 
             debug!(
-                "Build Nakamoto block in tenure {}",
-                &burn_tip.consensus_hash
+                "Build Nakamoto block in tenure {} sortition {}",
+                &tenure_id_consensus_hash, &burn_tip.consensus_hash
             );
 
             // make a block
@@ -537,19 +558,30 @@ impl TestStacksNode {
                 NakamotoBlockBuilder::new_from_parent(
                     &parent_tip.index_block_hash(),
                     &parent_tip,
-                    &burn_tip.consensus_hash,
+                    tenure_id_consensus_hash,
                     burn_tip.total_burn,
-                    if block_count == 0 {
-                        Some(proof.clone())
+                    if block_count == 0 && tenure_change.is_some() {
+                        tenure_change.as_ref()
+                    } else {
+                        None
+                    },
+                    if block_count == 0 && coinbase.is_some() {
+                        coinbase.as_ref()
                     } else {
                         None
                     },
                 )
                 .unwrap()
             } else {
-                NakamotoBlockBuilder::new_tenure_from_genesis(&proof)
+                NakamotoBlockBuilder::new_tenure_from_genesis(
+                    &tenure_change.clone().unwrap(),
+                    &coinbase.clone().unwrap(),
+                )
             };
 
+            tenure_change = None;
+            coinbase = None;
+
             let (mut nakamoto_block, size, cost) = builder
                 .make_nakamoto_block_from_txs(chainstate, &sortdb.index_conn(), txs)
                 .unwrap();
@@ -561,16 +593,28 @@ impl TestStacksNode {
                 "Process Nakamoto block {} ({:?}",
                 &block_id, &nakamoto_block.header
             );
+            debug!(
+                "Nakamoto block {} txs: {:?}",
+                &block_id, &nakamoto_block.txs
+            );
 
             let sort_tip = SortitionDB::get_canonical_sortition_tip(sortdb.conn()).unwrap();
-            let sort_handle = sortdb.index_handle(&sort_tip);
-            let accepted = Relayer::process_new_nakamoto_block(
+            let mut sort_handle = sortdb.index_handle(&sort_tip);
+            let accepted = match Relayer::process_new_nakamoto_block(
                 sortdb,
-                &sort_handle,
+                &mut sort_handle,
                 chainstate,
                 nakamoto_block.clone(),
-            )
-            .unwrap();
+            ) {
+                Ok(accepted) => accepted,
+                Err(e) => {
+                    error!(
+                        "Failed to process nakamoto block: {:?}\n{:?}",
+                        &e, &nakamoto_block
+                    );
+                    panic!();
+                }
+            };
             if accepted {
                 test_debug!("Accepted Nakamoto block {}", &block_id);
                 coord.handle_new_nakamoto_stacks_block().unwrap();
@@ -718,7 +762,7 @@ impl<'a> TestPeer<'a> {
             None
         };
 
-        let last_key = if let Some(ch) = parent_consensus_hash_opt {
+        let last_key = if let Some(ch) = parent_consensus_hash_opt.clone() {
             let tenure_sn = SortitionDB::get_block_snapshot_consensus(sortdb.conn(), &ch)
                 .unwrap()
                 .unwrap();
@@ -813,6 +857,11 @@ impl<'a> TestPeer<'a> {
 
         burn_ops.push(BlockstackOperationType::LeaderBlockCommit(block_commit_op));
 
+        // prepare to mine
+        let miner_addr = self.miner.origin_address().unwrap();
+        let miner_account = get_account(&mut stacks_node.chainstate, &sortdb, &miner_addr);
+        self.miner.set_nonce(miner_account.nonce);
+
         self.stacks_node = Some(stacks_node);
         self.sortdb = Some(sortdb);
         (burn_ops, tenure_change_payload, last_key)
@@ -847,10 +896,9 @@ impl<'a> TestPeer<'a> {
     /// Returns the blocks, their sizes, and runtime costs
     pub fn make_nakamoto_tenure<F>(
         &mut self,
-        consensus_hash: &ConsensusHash,
-        mut tenure_change_payload: TenureChangePayload,
+        tenure_change: StacksTransaction,
+        coinbase: StacksTransaction,
         signers: &mut TestSigners,
-        vrf_proof: VRFProof,
         block_builder: F,
     ) -> Vec<(NakamotoBlock, u64, ExecutionCost)>
     where
@@ -858,24 +906,75 @@ impl<'a> TestPeer<'a> {
             &mut TestMiner,
             &mut StacksChainState,
             &SortitionDB,
-            usize,
+            &[(NakamotoBlock, u64, ExecutionCost)],
         ) -> Vec<StacksTransaction>,
     {
         let mut stacks_node = self.stacks_node.take().unwrap();
         let sortdb = self.sortdb.take().unwrap();
 
-        let (last_tenure_id, parent_block_opt, parent_tenure_opt, parent_sortition_opt) =
-            Self::get_nakamoto_parent(&self.miner, &stacks_node, &sortdb);
+        let blocks = TestStacksNode::make_nakamoto_tenure_blocks(
+            &mut stacks_node.chainstate,
+            &sortdb,
+            &mut self.miner,
+            signers,
+            &tenure_change
+                .try_as_tenure_change()
+                .unwrap()
+                .tenure_consensus_hash
+                .clone(),
+            Some(tenure_change),
+            Some(coinbase),
+            &mut self.coord,
+            block_builder,
+        );
 
-        tenure_change_payload.consensus_hash = consensus_hash.clone();
+        let just_blocks = blocks
+            .clone()
+            .into_iter()
+            .map(|(block, _, _)| block)
+            .collect();
+        stacks_node.add_nakamoto_tenure_blocks(just_blocks);
+
+        self.stacks_node = Some(stacks_node);
+        self.sortdb = Some(sortdb);
+
+        blocks
+    }
+
+    /// Produce and process a Nakamoto tenure extension.
+    /// `tenure_change_payload` is the original tenure-change payload for this tenure.
+    /// `last_tenure_block_header` is the final block's header produced in the last batch of blocks
+    /// `num_blocks_so_far` is the number of blocks produced so far in this tenure,
+    /// Returns the blocks, their sizes, and runtime costs
+    pub fn make_nakamoto_tenure_extension<F>(
+        &mut self,
+        tenure_extend_tx: StacksTransaction,
+        signers: &mut TestSigners,
+        block_builder: F,
+    ) -> Vec<(NakamotoBlock, u64, ExecutionCost)>
+    where
+        F: FnMut(
+            &mut TestMiner,
+            &mut StacksChainState,
+            &SortitionDB,
+            &[(NakamotoBlock, u64, ExecutionCost)],
+        ) -> Vec<StacksTransaction>,
+    {
+        let mut stacks_node = self.stacks_node.take().unwrap();
+        let sortdb = self.sortdb.take().unwrap();
 
         let blocks = TestStacksNode::make_nakamoto_tenure_blocks(
             &mut stacks_node.chainstate,
             &sortdb,
             &mut self.miner,
             signers,
-            vrf_proof,
-            tenure_change_payload,
+            &tenure_extend_tx
+                .try_as_tenure_change()
+                .unwrap()
+                .tenure_consensus_hash
+                .clone(),
+            Some(tenure_extend_tx),
+            None,
             &mut self.coord,
             block_builder,
         );
@@ -885,7 +984,7 @@ impl<'a> TestPeer<'a> {
             .into_iter()
             .map(|(block, _, _)| block)
             .collect();
-        stacks_node.add_nakamoto_tenure_blocks(just_blocks);
+        stacks_node.add_nakamoto_extended_blocks(just_blocks);
 
         self.stacks_node = Some(stacks_node);
         self.sortdb = Some(sortdb);
@@ -901,7 +1000,7 @@ impl<'a> TestPeer<'a> {
         let mut node = self.stacks_node.take().unwrap();
 
         let tip = SortitionDB::get_canonical_sortition_tip(sortdb.conn()).unwrap();
-        let sort_handle = sortdb.index_handle(&tip);
+        let mut sort_handle = sortdb.index_handle(&tip);
 
         node.add_nakamoto_tenure_blocks(blocks.clone());
         for block in blocks.into_iter() {
@@ -909,7 +1008,7 @@ impl<'a> TestPeer<'a> {
             debug!("Process Nakamoto block {} ({:?}", &block_id, &block.header);
             let accepted = Relayer::process_new_nakamoto_block(
                 &sortdb,
-                &sort_handle,
+                &mut sort_handle,
                 &mut node.chainstate,
                 block,
             )

From 76009a98d7a9fa5af3756f97d0374f7289f73369 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Thu, 7 Dec 2023 09:56:09 -0500
Subject: [PATCH 0114/1166] chore: API sync

---
 stackslib/src/chainstate/stacks/block.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/block.rs b/stackslib/src/chainstate/stacks/block.rs
index 2ab2a2c5bd..2a59312a60 100644
--- a/stackslib/src/chainstate/stacks/block.rs
+++ b/stackslib/src/chainstate/stacks/block.rs
@@ -1782,8 +1782,9 @@ mod test {
         );
 
         let tenure_change_payload = TenureChangePayload {
-            consensus_hash: ConsensusHash([0x01; 20]),
-            prev_consensus_hash: ConsensusHash([0x02; 20]),
+            tenure_consensus_hash: ConsensusHash([0x01; 20]),
+            prev_tenure_consensus_hash: ConsensusHash([0x02; 20]),
+            sortition_consensus_hash: ConsensusHash([0x03; 20]),
             previous_tenure_end: StacksBlockId([0x00; 32]),
             previous_tenure_blocks: 0,
             cause: TenureChangeCause::BlockFound,

From 158f58fc0ce4f85e1b2603642b52333c54aedeeb Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Thu, 7 Dec 2023 09:56:19 -0500
Subject: [PATCH 0115/1166] chore: don't reset execution cost in response to a
 tx

---
 stackslib/src/chainstate/stacks/db/transactions.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/stackslib/src/chainstate/stacks/db/transactions.rs b/stackslib/src/chainstate/stacks/db/transactions.rs
index 20e43ef875..823903969b 100644
--- a/stackslib/src/chainstate/stacks/db/transactions.rs
+++ b/stackslib/src/chainstate/stacks/db/transactions.rs
@@ -1365,7 +1365,6 @@ impl StacksChainState {
                         // the stackers granted a tenure extension.
                         // reset the runtime cost
                         debug!("TenureChange extends block tenure");
-                        clarity_tx.reset_cost(ExecutionCost::zero());
                     }
                 }
 

From 071fd3bc8ecc819e2aac9d9fcc193d803a1e6095 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Thu, 7 Dec 2023 09:56:36 -0500
Subject: [PATCH 0116/1166] chore: require a tenure-change tx in addition to a
 coinbase

---
 stackslib/src/chainstate/stacks/miner.rs | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/stackslib/src/chainstate/stacks/miner.rs b/stackslib/src/chainstate/stacks/miner.rs
index ca101c066d..a9cfacf929 100644
--- a/stackslib/src/chainstate/stacks/miner.rs
+++ b/stackslib/src/chainstate/stacks/miner.rs
@@ -2139,6 +2139,7 @@ impl StacksBlockBuilder {
         builder: &mut B,
         mempool: &mut MemPoolDB,
         tip_height: u64,
+        tenure_change_tx: Option<&StacksTransaction>,
         coinbase_tx: Option<&StacksTransaction>,
         settings: BlockBuilderSettings,
         event_observer: Option<&dyn MemPoolEventDispatcher>,
@@ -2154,6 +2155,13 @@ impl StacksBlockBuilder {
 
         let mut tx_events = Vec::new();
 
+        if let Some(tenure_tx) = tenure_change_tx {
+            tx_events.push(
+                builder
+                    .try_mine_tx(epoch_tx, tenure_tx, ast_rules.clone())?
+                    .convert_to_event(),
+            );
+        }
         if let Some(coinbase_tx) = coinbase_tx {
             tx_events.push(
                 builder
@@ -2434,6 +2442,7 @@ impl StacksBlockBuilder {
             &mut builder,
             mempool,
             parent_stacks_header.stacks_block_height,
+            None,
             Some(coinbase_tx),
             settings,
             event_observer,

From c46c776307b4b2c4a7bc03a2546c57201382b89f Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Thu, 7 Dec 2023 09:56:52 -0500
Subject: [PATCH 0117/1166] feat: derive tenure extension from a tenure change

---
 stackslib/src/chainstate/stacks/mod.rs | 38 +++++++++++++++++++++++---
 1 file changed, 34 insertions(+), 4 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/mod.rs b/stackslib/src/chainstate/stacks/mod.rs
index 7c9ede4c57..3cf46ad833 100644
--- a/stackslib/src/chainstate/stacks/mod.rs
+++ b/stackslib/src/chainstate/stacks/mod.rs
@@ -655,6 +655,11 @@ impl TenureChangeCause {
             Self::Extended => false,
         }
     }
+
+    /// Convert to u8 representation
+    pub fn as_u8(&self) -> u8 {
+        *self as u8
+    }
 }
 
 /// Reasons why a `TenureChange` transaction can be bad
@@ -695,10 +700,13 @@ pub struct TenureChangePayload {
     /// block was chosen.  It may be the case that this miner's tenure gets _extended_ across
     /// subsequent sortitions; if this happens, then this `consensus_hash` value _remains the same_
     /// as the sortition in which the winning block-commit was mined.
-    pub consensus_hash: ConsensusHash,
+    pub tenure_consensus_hash: ConsensusHash,
     /// Consensus hash of the previous tenure.  Corresponds to the sortition of the previous
     /// winning block-commit.
-    pub prev_consensus_hash: ConsensusHash,
+    pub prev_tenure_consensus_hash: ConsensusHash,
+    /// Current consensus hash on the underlying burnchain.  Corresponds to the last-seen
+    /// sortition.
+    pub sortition_consensus_hash: ConsensusHash,
     /// The StacksBlockId of the last block from the previous tenure
     pub previous_tenure_end: StacksBlockId,
     /// The number of blocks produced since the last sortition-linked tenure
@@ -713,6 +721,27 @@ pub struct TenureChangePayload {
     pub signers: Vec<u8>,
 }
 
+impl TenureChangePayload {
+    pub fn extend(
+        &self,
+        sortition_consensus_hash: ConsensusHash,
+        last_tenure_block_id: StacksBlockId,
+        num_blocks_so_far: u32,
+    ) -> Self {
+        TenureChangePayload {
+            tenure_consensus_hash: self.tenure_consensus_hash.clone(),
+            prev_tenure_consensus_hash: self.tenure_consensus_hash.clone(),
+            sortition_consensus_hash,
+            previous_tenure_end: last_tenure_block_id,
+            previous_tenure_blocks: num_blocks_so_far,
+            cause: TenureChangeCause::Extended,
+            pubkey_hash: self.pubkey_hash.clone(),
+            signature: ThresholdSignature::mock(),
+            signers: vec![],
+        }
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub enum TransactionPayload {
     TokenTransfer(PrincipalData, u64, TokenTransferMemo),
@@ -1348,8 +1377,9 @@ pub mod test {
             ),
             TransactionPayload::PoisonMicroblock(mblock_header_1, mblock_header_2),
             TransactionPayload::TenureChange(TenureChangePayload {
-                consensus_hash: ConsensusHash([0x01; 20]),
-                prev_consensus_hash: ConsensusHash([0x02; 20]),
+                tenure_consensus_hash: ConsensusHash([0x01; 20]),
+                prev_tenure_consensus_hash: ConsensusHash([0x02; 20]),
+                sortition_consensus_hash: ConsensusHash([0x03; 20]),
                 previous_tenure_end: StacksBlockId([0x00; 32]),
                 previous_tenure_blocks: 0,
                 cause: TenureChangeCause::BlockFound,

From 259f481508e87f229059ec550bc002b86822fed9 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Thu, 7 Dec 2023 09:57:05 -0500
Subject: [PATCH 0118/1166] chore: API sync

---
 stackslib/src/chainstate/stacks/transaction.rs | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/transaction.rs b/stackslib/src/chainstate/stacks/transaction.rs
index 88788a53f5..0ea6887658 100644
--- a/stackslib/src/chainstate/stacks/transaction.rs
+++ b/stackslib/src/chainstate/stacks/transaction.rs
@@ -194,8 +194,9 @@ impl ThresholdSignature {
 
 impl StacksMessageCodec for TenureChangePayload {
     fn consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), codec_error> {
-        write_next(fd, &self.consensus_hash)?;
-        write_next(fd, &self.prev_consensus_hash)?;
+        write_next(fd, &self.tenure_consensus_hash)?;
+        write_next(fd, &self.prev_tenure_consensus_hash)?;
+        write_next(fd, &self.sortition_consensus_hash)?;
         write_next(fd, &self.previous_tenure_end)?;
         write_next(fd, &self.previous_tenure_blocks)?;
         write_next(fd, &self.cause)?;
@@ -206,8 +207,9 @@ impl StacksMessageCodec for TenureChangePayload {
 
     fn consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, codec_error> {
         Ok(Self {
-            consensus_hash: read_next(fd)?,
-            prev_consensus_hash: read_next(fd)?,
+            tenure_consensus_hash: read_next(fd)?,
+            prev_tenure_consensus_hash: read_next(fd)?,
+            sortition_consensus_hash: read_next(fd)?,
             previous_tenure_end: read_next(fd)?,
             previous_tenure_blocks: read_next(fd)?,
             cause: read_next(fd)?,
@@ -3787,8 +3789,9 @@ mod test {
             TransactionVersion::Mainnet,
             auth.clone(),
             TransactionPayload::TenureChange(TenureChangePayload {
-                consensus_hash: ConsensusHash([0x01; 20]),
-                prev_consensus_hash: ConsensusHash([0x02; 20]),
+                tenure_consensus_hash: ConsensusHash([0x01; 20]),
+                prev_tenure_consensus_hash: ConsensusHash([0x02; 20]),
+                sortition_consensus_hash: ConsensusHash([0x03; 20]),
                 previous_tenure_end: StacksBlockId([0x00; 32]),
                 previous_tenure_blocks: 0,
                 cause: TenureChangeCause::BlockFound,

From cddf031cb68ab088a04f3ed2d75092e0ff4a9977 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Thu, 7 Dec 2023 09:57:14 -0500
Subject: [PATCH 0119/1166] chore: don't allow a transaction to reset the
 runtime cost

---
 stackslib/src/clarity_vm/clarity.rs | 8 --------
 1 file changed, 8 deletions(-)

diff --git a/stackslib/src/clarity_vm/clarity.rs b/stackslib/src/clarity_vm/clarity.rs
index b385859320..aed3bb9947 100644
--- a/stackslib/src/clarity_vm/clarity.rs
+++ b/stackslib/src/clarity_vm/clarity.rs
@@ -1651,14 +1651,6 @@ impl<'a, 'b> ClarityTransactionConnection<'a, 'b> {
         }
     }
 
-    /// Reset the cost tracker to the given cost
-    pub fn reset_cost(&mut self, new_cost: ExecutionCost) {
-        match self.cost_track {
-            Some(ref mut track) => track.set_total(new_cost),
-            None => { /* no-op */ }
-        }
-    }
-
     /// Evaluate a poison-microblock transaction
     pub fn run_poison_microblock(
         &mut self,

From 48e6b002b3d10dae36580d8e10206b35eb515222 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Thu, 7 Dec 2023 09:57:28 -0500
Subject: [PATCH 0120/1166] chore: need &mut for sortition handle

---
 stackslib/src/net/relay.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stackslib/src/net/relay.rs b/stackslib/src/net/relay.rs
index 14a3e1e67c..d1f787b667 100644
--- a/stackslib/src/net/relay.rs
+++ b/stackslib/src/net/relay.rs
@@ -654,7 +654,7 @@ impl Relayer {
     /// Return Ok(true) if we stored it, Ok(false) if we didn't
     pub fn process_new_nakamoto_block(
         sortdb: &SortitionDB,
-        sort_handle: &SortitionHandleConn,
+        sort_handle: &mut SortitionHandleConn,
         chainstate: &mut StacksChainState,
         block: NakamotoBlock,
     ) -> Result<bool, chainstate_error> {

From aa9cbb7526615f78ba0b657b32570407146e5969 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Thu, 7 Dec 2023 09:57:38 -0500
Subject: [PATCH 0121/1166] feat: move all tenure-control logic into its own
 file

---
 stackslib/src/chainstate/nakamoto/tenure.rs | 1107 +++++++++++++++++++
 1 file changed, 1107 insertions(+)
 create mode 100644 stackslib/src/chainstate/nakamoto/tenure.rs

diff --git a/stackslib/src/chainstate/nakamoto/tenure.rs b/stackslib/src/chainstate/nakamoto/tenure.rs
new file mode 100644
index 0000000000..f4adc1c08a
--- /dev/null
+++ b/stackslib/src/chainstate/nakamoto/tenure.rs
@@ -0,0 +1,1107 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020-2023 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+//! This module is concerned with tracking all Nakamoto tenures.
+//!
+//! A _tenure_ is the sequence of blocks that a miner produces from a winning sortition.  A tenure
+//! can last for the duration of one or more burnchain blocks, and may be extended by Stackers.  As
+//! such, every tenure corresponds to exactly one cryptographic sortition with a winning miner.
+//! The consensus hash of the winning miner's sortition serves as the _tenure ID_, and it is
+//! guaranteed to be globally unique across all Stacks chain histories and burnchain histories.
+//!
+//! The tenures within one burnchain fork are well-ordered.  Each tenure has exactly one parent
+//! tenure, such that the last block in the parent tenure is the parent of the first block in the
+//! child tenure.  The first-ever Nakamoto tenure's parent block is the last epoch2 Stacks block.
+//! Due to well-ordering, each burnchain fork has a highest tenure, which is used to validate
+//! blocks before processing them.  Namely, a Nakamoto block must belong to the highest tenure in
+//! order to be appended to the chain tip.
+//!
+//! Treating tenures as sequences of blocks mined by a winning miner allows us to cause coinbases
+//! to mature based on tenure confirmations.  This is consistent with the epoch2 behavior.  It also
+//! allows us to quickly identify whether or not a block belongs to a given tenure, and it allows a
+//! booting miner to identify the set of all tenure IDs in a reward cycle using only burnchain
+//! state (although some of these tenures may be empty).
+//!
+//! Tenures are created and extended via `TenureChange` transactions.  These come in two flavors:
+//!
+//! * A `BlockFound` tenure change, which is induced by a winning sortition.  This causes the new
+//! miner to start producing blocks, and stops the current miner from producing more blocks.
+//!
+//! * An `Extended` tenure change, which is induced by Stackers. This resets the tenure's ongoing
+//! execution budget, thereby allowing the miner to continue producing blocks.
+//!
+//! A tenure may be extended at any time by Stackers, and may span multiple Bitcoin blocks (such
+//! as if there was no sortition winner, or the winning miner never comes online).
+//!
+//! `TenureChanges` contain three pointers to chainstate:
+//! * The _tenure consensus hash_: this is the consensus hash of the sortition that chose the last
+//! winning miner.  Note that due to the above, it may not be the highest sortition processed.
+//! * The _previous tenure consensus hash_: this is the consensus hash of the sortition that chose
+//! the miner who produced the parent tenure of the current ongoing tenure.
+//! * The _sortition consensus hash: this is the tip of the sortition history that Stackers knew
+//! about when they created the `TenureChange.
+//!
+//! The Nakamoto system uses this module to track the set of all tenures.  It does so within a
+//! (derived-state) table called `nakamoto_tenures`.  Whenever a `TenureChange` transaction is
+//! processed, a new row will be added to this table.
+//!
+use std::collections::HashSet;
+use std::ops::DerefMut;
+
+use clarity::vm::ast::ASTRules;
+use clarity::vm::costs::ExecutionCost;
+use clarity::vm::database::BurnStateDB;
+use clarity::vm::events::StacksTransactionEvent;
+use clarity::vm::types::StacksAddressExtensions;
+use lazy_static::{__Deref, lazy_static};
+use rusqlite::types::{FromSql, FromSqlError};
+use rusqlite::{params, Connection, OptionalExtension, ToSql, NO_PARAMS};
+use sha2::{Digest as Sha2Digest, Sha512_256};
+use stacks_common::codec::{
+    read_next, write_next, Error as CodecError, StacksMessageCodec, MAX_MESSAGE_LEN,
+};
+use stacks_common::consts::{
+    FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH, MINER_REWARD_MATURITY,
+};
+use stacks_common::types::chainstate::{
+    BlockHeaderHash, BurnchainHeaderHash, ConsensusHash, StacksBlockId, StacksPrivateKey,
+    StacksPublicKey, TrieHash, VRFSeed,
+};
+use stacks_common::types::{PrivateKey, StacksEpochId};
+use stacks_common::util::get_epoch_time_secs;
+use stacks_common::util::hash::{to_hex, Hash160, MerkleHashFunc, MerkleTree, Sha512Trunc256Sum};
+use stacks_common::util::retry::BoundReader;
+use stacks_common::util::secp256k1::MessageSignature;
+use stacks_common::util::vrf::{VRFProof, VRFPublicKey, VRF};
+use wsts::curve::point::Point;
+
+use crate::burnchains::{PoxConstants, Txid};
+use crate::chainstate::burn::db::sortdb::{
+    get_ancestor_sort_id, get_ancestor_sort_id_tx, get_block_commit_by_txid, SortitionDB,
+    SortitionHandle, SortitionHandleConn, SortitionHandleTx,
+};
+use crate::chainstate::burn::operations::{
+    DelegateStxOp, LeaderBlockCommitOp, LeaderKeyRegisterOp, StackStxOp, TransferStxOp,
+};
+use crate::chainstate::burn::{BlockSnapshot, SortitionHash};
+use crate::chainstate::coordinator::{BlockEventDispatcher, Error};
+use crate::chainstate::nakamoto::{
+    MaturedMinerPaymentSchedules, MaturedMinerRewards, NakamotoBlock, NakamotoBlockHeader,
+    NakamotoChainState,
+};
+use crate::chainstate::stacks::db::accounts::MinerReward;
+use crate::chainstate::stacks::db::blocks::StagingUserBurnSupport;
+use crate::chainstate::stacks::db::{
+    ChainstateTx, ClarityTx, DBConfig as ChainstateConfig, MinerPaymentSchedule,
+    MinerPaymentTxFees, MinerRewardInfo, StacksBlockHeaderTypes, StacksChainState, StacksDBTx,
+    StacksEpochReceipt, StacksHeaderInfo,
+};
+use crate::chainstate::stacks::events::StacksTransactionReceipt;
+use crate::chainstate::stacks::{
+    Error as ChainstateError, StacksBlock, StacksBlockHeader, StacksMicroblock, StacksTransaction,
+    TenureChangeCause, TenureChangeError, TenureChangePayload, ThresholdSignature,
+    TransactionPayload, MINER_BLOCK_CONSENSUS_HASH, MINER_BLOCK_HEADER_HASH,
+};
+use crate::clarity_vm::clarity::{ClarityInstance, PreCommitClarityBlock};
+use crate::clarity_vm::database::SortitionDBRef;
+use crate::core::BOOT_BLOCK_HASH;
+use crate::monitoring;
+use crate::net::Error as net_error;
+use crate::util_lib::db::{
+    query_int, query_row, query_row_panic, query_rows, u64_to_sql, DBConn, Error as DBError,
+    FromRow,
+};
+
+pub static NAKAMOTO_TENURES_SCHEMA: &'static str = r#"
+    CREATE TABLE nakamoto_tenures (
+        -- consensus hash of start-tenure block (i.e. the consensus hash of the sortition in which the miner's block-commit
+        -- was mined)
+        tenure_id_consensus_hash TEXT NOT NULL,
+        -- consensus hash of the previous tenure's start-tenure block
+        prev_tenure_id_consensus_hash TEXT NOT NULL,
+        -- consensus hash of the last-processed sortition
+        sortition_consensus_hash TEXT NOT NULL,
+        -- whether or not this tenure was triggered by a sortition (as opposed to a tenure-extension).
+        -- this is equal to the `cause` field in a TenureChange
+        cause INETGER NOT NULL,
+        -- block hash of start-tenure block
+        block_hash TEXT NOT NULL,
+        -- block ID of this start block (this is the StacksBlockId of the above tenure_id_consensus_hash and block_hash)
+        block_id TEXT NOT NULL,
+        -- this field is the total number of _sortition-induced_ tenures in the chain history (including this tenure),
+        -- as of the _end_ of this block.  A tenure can contain multiple TenureChanges; if so, then this
+        -- is the height of the _sortition-induced_ TenureChange that created it.
+        coinbase_height INTEGER NOT NULL,
+        -- number of blocks this tenure.
+        -- * for tenure-changes induced by sortitions, this is the number of blocks in the previous tenure
+        -- * for tenure-changes induced by extension, this is the number of blocks in the current tenure so far.
+        num_blocks_confirmed INTEGER NOT NULL,
+        -- this is the ith tenure transaction in its respective Nakamoto chain history.
+        tenure_index INTEGER NOT NULL,
+
+        PRIMARY KEY(sortition_consensus_hash,tenure_index)
+    );
+    CREATE INDEX nakamoto_tenures_by_block_id ON nakamoto_tenures(block_id);
+    CREATE INDEX nakamoto_tenures_by_block_and_consensus_hashes ON nakamoto_tenures(tenure_id_consensus_hash,block_hash);
+    CREATE INDEX nakamoto_tenures_by_sortition_consensus_hash ON nakamoto_tenures(sortition_consensus_hash);
+    CREATE INDEX nakamoto_tenures_by_tenure_index ON nakamoto_tenures(tenure_index);
+"#;
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct NakamotoTenure {
+    /// consensus hash of start-tenure block
+    pub tenure_id_consensus_hash: ConsensusHash,
+    /// consensus hash of parent tenure's start-tenure block
+    pub prev_tenure_id_consensus_hash: ConsensusHash,
+    /// sortition tip consensus hash when this tenure was processed
+    pub sortition_consensus_hash: ConsensusHash,
+    /// the cause of this tenure -- either a new miner was chosen, or the current miner's tenure
+    /// was extended
+    pub cause: TenureChangeCause,
+    /// block hash of start-tenure block
+    pub block_hash: BlockHeaderHash,
+    /// block ID of this start block
+    pub block_id: StacksBlockId,
+    /// number of sortition-tenures so far, including this one.
+    /// This is, equivalently, the number of coinbases emitted so far.
+    pub coinbase_height: u64,
+    /// number of tenure-change transactions so far, including this one
+    pub tenure_index: u64,
+    /// number of blocks this tenure confirms
+    pub num_blocks_confirmed: u32,
+}
+
+impl FromRow<NakamotoTenure> for NakamotoTenure {
+    fn from_row(row: &rusqlite::Row) -> Result<NakamotoTenure, DBError> {
+        let tenure_id_consensus_hash = row.get("tenure_id_consensus_hash")?;
+        let prev_tenure_id_consensus_hash = row.get("prev_tenure_id_consensus_hash")?;
+        let sortition_consensus_hash = row.get("sortition_consensus_hash")?;
+        let cause_u8: u8 = row.get("cause")?;
+        let cause = TenureChangeCause::try_from(cause_u8).map_err(|_| DBError::ParseError)?;
+        let block_hash = row.get("block_hash")?;
+        let block_id = row.get("block_id")?;
+        let coinbase_height_i64: i64 = row.get("coinbase_height")?;
+        let coinbase_height = coinbase_height_i64
+            .try_into()
+            .map_err(|_| DBError::ParseError)?;
+        let tenure_index_i64: i64 = row.get("tenure_index")?;
+        let tenure_index = tenure_index_i64
+            .try_into()
+            .map_err(|_| DBError::ParseError)?;
+        let num_blocks_confirmed: u32 = row.get("num_blocks_confirmed")?;
+        Ok(NakamotoTenure {
+            tenure_id_consensus_hash,
+            prev_tenure_id_consensus_hash,
+            sortition_consensus_hash,
+            cause,
+            block_hash,
+            block_id,
+            coinbase_height,
+            tenure_index,
+            num_blocks_confirmed,
+        })
+    }
+}
+
+impl NakamotoChainState {
+    /// Create the block reward for a NakamotoBlock
+    /// `coinbase_reward_ustx` is the total coinbase reward for this block, including any
+    ///    accumulated rewards from missed sortitions or initial mining rewards.
+    /// TODO: unit test
+    pub fn make_scheduled_miner_reward(
+        mainnet: bool,
+        epoch_id: StacksEpochId,
+        parent_block_hash: &BlockHeaderHash,
+        parent_consensus_hash: &ConsensusHash,
+        block_hash: &BlockHeaderHash,
+        block_consensus_hash: &ConsensusHash,
+        block_height: u64,
+        coinbase_tx: &StacksTransaction,
+        parent_fees: u128,
+        burnchain_commit_burn: u64,
+        burnchain_sortition_burn: u64,
+        coinbase_reward_ustx: u128,
+    ) -> MinerPaymentSchedule {
+        let miner_auth = coinbase_tx.get_origin();
+        let miner_addr = miner_auth.get_address(mainnet);
+
+        let recipient = if epoch_id >= StacksEpochId::Epoch21 {
+            // pay to tx-designated recipient, or if there is none, pay to the origin
+            match coinbase_tx.try_as_coinbase() {
+                Some((_, recipient_opt, _)) => recipient_opt
+                    .cloned()
+                    .unwrap_or(miner_addr.to_account_principal()),
+                None => miner_addr.to_account_principal(),
+            }
+        } else {
+            // pre-2.1, always pay to the origin
+            miner_addr.to_account_principal()
+        };
+
+        // N.B. a `MinerPaymentSchedule` that pays to a contract can never be created before 2.1,
+        // per the above check (and moreover, a Stacks block with a pay-to-alt-recipient coinbase would
+        // not become valid until after 2.1 activates).
+        let miner_reward = MinerPaymentSchedule {
+            address: miner_addr,
+            recipient,
+            block_hash: block_hash.clone(),
+            consensus_hash: block_consensus_hash.clone(),
+            parent_block_hash: parent_block_hash.clone(),
+            parent_consensus_hash: parent_consensus_hash.clone(),
+            coinbase: coinbase_reward_ustx,
+            tx_fees: MinerPaymentTxFees::Nakamoto { parent_fees },
+            burnchain_commit_burn,
+            burnchain_sortition_burn,
+            miner: true,
+            stacks_block_height: block_height,
+            vtxindex: 0,
+        };
+
+        miner_reward
+    }
+
+    /// Get scheduled miner rewards that have matured when this tenure starts.
+    /// Returns (list of miners to pay, any residual payments to the parent miner) on success.
+    pub(crate) fn get_matured_miner_reward_schedules(
+        chainstate_tx: &mut ChainstateTx,
+        tip_index_hash: &StacksBlockId,
+        coinbase_height: u64,
+    ) -> Result<Option<MaturedMinerPaymentSchedules>, ChainstateError> {
+        let mainnet = chainstate_tx.get_config().mainnet;
+
+        // find matured miner rewards, so we can grant them within the Clarity DB tx.
+        if coinbase_height < MINER_REWARD_MATURITY {
+            return Ok(Some(MaturedMinerPaymentSchedules::genesis(mainnet)));
+        }
+
+        let matured_coinbase_height = coinbase_height - MINER_REWARD_MATURITY;
+        let matured_tenure_block_header = Self::get_header_by_coinbase_height(
+            chainstate_tx,
+            &tip_index_hash,
+            matured_coinbase_height,
+        )?
+        .ok_or_else(|| {
+            warn!("Matured tenure data not found");
+            ChainstateError::NoSuchBlockError
+        })?;
+
+        let latest_miners = StacksChainState::get_scheduled_block_rewards_at_block(
+            chainstate_tx.deref_mut(),
+            &matured_tenure_block_header.index_block_hash(),
+        )?;
+        let parent_miner = StacksChainState::get_parent_matured_miner(
+            chainstate_tx.deref_mut(),
+            mainnet,
+            &latest_miners,
+        )?;
+        Ok(Some(MaturedMinerPaymentSchedules {
+            latest_miners,
+            parent_miner,
+        }))
+    }
+
+    /// Calculate the total matured rewards from the scheduled matured rewards.
+    /// This takes a ClarityTx, so PoisonMicroblocks can be taken into account (which deduct
+    /// STX from the block reward for offending miners).
+    /// The recipient of the block reward may not be the miner, but may be a PoisonMicroblock
+    /// reporter (both are captured as the sole `recipient` in the `MaturedMinerRewards` struct).
+    ///
+    /// Returns Ok(Some(rewards)) if we were able to calculate the rewards
+    /// Returns Ok(None) if there are no matured rewards yet
+    /// Returns Err(..) on DB error
+    /// TODO: unit test
+    pub(crate) fn calculate_matured_miner_rewards(
+        clarity_tx: &mut ClarityTx,
+        sortdb_conn: &Connection,
+        parent_stacks_height: u64,
+        matured_miner_schedule: MaturedMinerPaymentSchedules,
+    ) -> Result<Option<MaturedMinerRewards>, ChainstateError> {
+        let matured_miner_rewards_opt = match StacksChainState::find_mature_miner_rewards(
+            clarity_tx,
+            sortdb_conn,
+            parent_stacks_height,
+            matured_miner_schedule.latest_miners,
+            matured_miner_schedule.parent_miner,
+        ) {
+            Ok(Some((recipient, _user_burns, parent, reward_info))) => Some(MaturedMinerRewards {
+                recipient,
+                parent_reward: parent,
+                reward_info,
+            }),
+            Ok(None) => None,
+            Err(e) => {
+                let msg = format!("Failed to load miner rewards: {:?}", &e);
+                warn!("{}", &msg);
+                return Err(ChainstateError::InvalidStacksBlock(msg));
+            }
+        };
+        Ok(matured_miner_rewards_opt)
+    }
+
+    /// Return the coinbase height of `block` if it was a nakamoto block, or the
+    ///  Stacks block height of `block` if it was an epoch-2 block
+    ///
+    /// In Stacks 2.x, the coinbase height and block height are the
+    /// same. A miner's tenure in Stacks 2.x is entirely encompassed
+    /// in the single Bitcoin-anchored Stacks block they produce, as
+    /// well as the microblock stream they append to it.  But in Nakamoto,
+    /// the coinbase height and block height are decoupled.
+    pub fn get_coinbase_height(
+        chainstate_conn: &Connection,
+        block: &StacksBlockId,
+    ) -> Result<Option<u64>, ChainstateError> {
+        let sql = "SELECT * FROM nakamoto_block_headers WHERE index_block_hash = ?1";
+        let result: Option<NakamotoBlockHeader> =
+            query_row_panic(chainstate_conn, sql, &[&block], || {
+                "FATAL: multiple rows for the same block hash".to_string()
+            })?;
+        if let Some(nak_hdr) = result {
+            let nak_qry = "SELECT coinbase_height FROM nakamoto_tenures WHERE tenure_id_consensus_hash = ?1 ORDER BY tenure_index DESC LIMIT 1";
+            let opt_height: Option<i64> = chainstate_conn
+                .query_row(nak_qry, &[&nak_hdr.consensus_hash], |row| row.get(0))
+                .optional()?;
+            if let Some(height) = opt_height {
+                return Ok(Some(
+                    u64::try_from(height).map_err(|_| DBError::ParseError)?,
+                ));
+            } else {
+                // should be unreachable
+                return Err(DBError::NotFoundError.into());
+            }
+        }
+
+        let epoch_2_qry = "SELECT block_height FROM block_headers WHERE index_block_hash = ?1";
+        let opt_height: Option<i64> = chainstate_conn
+            .query_row(epoch_2_qry, &[block], |row| row.get(0))
+            .optional()?;
+        opt_height
+            .map(u64::try_from)
+            .transpose()
+            .map_err(|_| ChainstateError::DBError(DBError::ParseError))
+    }
+
+    /// Insert a nakamoto tenure.
+    /// No validation will be done.
+    pub(crate) fn insert_nakamoto_tenure(
+        tx: &Connection,
+        block_header: &NakamotoBlockHeader,
+        coinbase_height: u64,
+        tenure_index: u64,
+        tenure: &TenureChangePayload,
+    ) -> Result<(), ChainstateError> {
+        // NOTE: this is checked with check_nakamoto_tenure()
+        assert_eq!(block_header.consensus_hash, tenure.tenure_consensus_hash);
+        let args: &[&dyn ToSql] = &[
+            &tenure.tenure_consensus_hash,
+            &tenure.prev_tenure_consensus_hash,
+            &tenure.sortition_consensus_hash,
+            &tenure.cause.as_u8(),
+            &block_header.block_hash(),
+            &block_header.block_id(),
+            &u64_to_sql(coinbase_height)?,
+            &u64_to_sql(tenure_index)?,
+            &tenure.previous_tenure_blocks,
+        ];
+        tx.execute(
+            "INSERT INTO nakamoto_tenures
+                (tenure_id_consensus_hash, prev_tenure_id_consensus_hash, sortition_consensus_hash, cause,
+                block_hash, block_id, coinbase_height, tenure_index, num_blocks_confirmed)
+            VALUES
+                (?1,?2,?3,?4,?5,?6,?7,?8,?9)",
+            args,
+        )?;
+
+        Ok(())
+    }
+
+    /// Drop a nakamoto tenure.
+    /// Used for testing
+    #[cfg(test)]
+    pub(crate) fn delete_nakamoto_tenure(
+        tx: &Connection,
+        ch: &ConsensusHash,
+    ) -> Result<(), ChainstateError> {
+        tx.execute(
+            "DELETE FROM nakamoto_tenures WHERE tenure_id_consensus_hash = ?1",
+            &[ch],
+        )?;
+        Ok(())
+    }
+
+    /// Get the first block header in a Nakamoto tenure
+    pub fn get_nakamoto_tenure_start_block_header(
+        chainstate_conn: &Connection,
+        consensus_hash: &ConsensusHash,
+    ) -> Result<Option<StacksHeaderInfo>, ChainstateError> {
+        let sql = "SELECT * FROM nakamoto_block_headers WHERE consensus_hash = ?1 ORDER BY block_height ASC LIMIT 1";
+        query_row_panic(chainstate_conn, sql, &[&consensus_hash], || {
+            "FATAL: multiple rows for the same consensus hash".to_string()
+        })
+        .map_err(ChainstateError::DBError)
+    }
+
+    /// Get the last block header in a Nakamoto tenure
+    pub fn get_nakamoto_tenure_finish_block_header(
+        chainstate_conn: &Connection,
+        consensus_hash: &ConsensusHash,
+    ) -> Result<Option<StacksHeaderInfo>, ChainstateError> {
+        let sql = "SELECT * FROM nakamoto_block_headers WHERE consensus_hash = ?1 ORDER BY block_height DESC LIMIT 1";
+        query_row_panic(chainstate_conn, sql, &[&consensus_hash], || {
+            "FATAL: multiple rows for the same consensus hash".to_string()
+        })
+        .map_err(ChainstateError::DBError)
+    }
+
+    /// Get the number of blocks in a tenure.
+    /// Only works for Nakamoto blocks, not Stacks epoch2 blocks.
+    /// Returns 0 if the consensus hash is not found.
+    pub fn get_nakamoto_tenure_length(
+        chainstate_conn: &Connection,
+        consensus_hash: &ConsensusHash,
+    ) -> Result<u32, ChainstateError> {
+        let sql = "SELECT IFNULL(COUNT(block_hash),0) FROM nakamoto_block_headers WHERE consensus_hash = ?1";
+        let count_i64 = query_int(chainstate_conn, sql, &[&consensus_hash])?;
+        let count: u32 = count_i64
+            .try_into()
+            .expect("FATAL: too many blocks in tenure");
+        Ok(count)
+    }
+
+    /// Get the highest coinbase height processed.
+    /// Returns Ok(Some(coinbase_height)) if we have processed at least one tenure
+    /// Returns Ok(None) if we have not yet processed a Nakamoto tenure
+    /// Returns Err(..) on database errors
+    pub fn get_highest_nakamoto_coinbase_height(
+        conn: &Connection,
+        max: u64,
+    ) -> Result<Option<u64>, ChainstateError> {
+        match conn
+            .query_row(
+                "SELECT IFNULL(MAX(coinbase_height), 0) FROM nakamoto_tenures WHERE coinbase_height < ?1",
+                &[&u64_to_sql(max)?],
+                |row| Ok(u64::from_row(row).expect("Expected u64 in database")),
+            )
+            .optional()?
+        {
+            Some(height_i64) => {
+                if height_i64 == 0 {
+                    // this never happens, so it's None
+                    Ok(None)
+                } else {
+                    Ok(Some(
+                        height_i64.try_into().map_err(|_| DBError::ParseError)?,
+                    ))
+                }
+            }
+            None => Ok(None),
+        }
+    }
+
+    /// Get the highest processed tenure on the canonical sortition history.
+    pub fn get_highest_nakamoto_tenure<SH: SortitionHandle>(
+        conn: &Connection,
+        sort_handle: &mut SH,
+    ) -> Result<Option<NakamotoTenure>, ChainstateError> {
+        let mut max_search_coinbase_height = u64::try_from(i64::MAX - 1).expect("infallible");
+        while max_search_coinbase_height > 0 {
+            let Some(max_coinbase_height) =
+                Self::get_highest_nakamoto_coinbase_height(conn, max_search_coinbase_height)?
+            else {
+                // no tenures yet
+                test_debug!(
+                    "No tenures yet (max search height was {})",
+                    max_search_coinbase_height
+                );
+                return Ok(None);
+            };
+
+            let sql = "SELECT * FROM nakamoto_tenures WHERE coinbase_height = ?1 ORDER BY tenure_index DESC";
+            let args: &[&dyn ToSql] = &[&u64_to_sql(max_coinbase_height)?];
+            let tenures: Vec<NakamotoTenure> = query_rows(conn, sql, args)?;
+
+            test_debug!(
+                "Found {} tenures at coinbase height {}",
+                tenures.len(),
+                max_coinbase_height
+            );
+
+            // find the one that's in the canonical sortition history
+            for tenure in tenures.into_iter() {
+                // check the tenure consensus and the sortition consensus
+                let mut canonical = true;
+                for ch in &[
+                    &tenure.tenure_id_consensus_hash,
+                    &tenure.sortition_consensus_hash,
+                ] {
+                    let Some(sn) =
+                        SortitionDB::get_block_snapshot_consensus(sort_handle.sqlite(), ch)?
+                    else {
+                        // not in sortition DB.
+                        // This is unreachable, but be defensive and just skip it.
+                        canonical = false;
+                        break;
+                    };
+                    let Some(ancestor_snapshot) =
+                        sort_handle.get_block_snapshot_by_height(sn.block_height)?
+                    else {
+                        // not canonical
+                        canonical = false;
+                        break;
+                    };
+                    if ancestor_snapshot.sortition_id != sn.sortition_id {
+                        // not canonical
+                        canonical = false;
+                        break;
+                    }
+                }
+                if canonical {
+                    return Ok(Some(tenure));
+                }
+            }
+
+            // no tenures at max_search_coinbase_height were canonical,
+            // but lower ones may be!
+            max_search_coinbase_height = max_coinbase_height.saturating_sub(1);
+        }
+        // no tenures at all were canonical
+        Ok(None)
+    }
+
+    /// Verify that a tenure change tx is a valid first-ever tenure change.  It must connect to an
+    /// epoch2 block, and it must be sortition-induced.
+    ///
+    /// Returns Some(mocked-epoch2-tenure) on success
+    /// Returns None on error
+    pub(crate) fn check_first_nakamoto_tenure_change(
+        headers_conn: &Connection,
+        tenure_payload: &TenureChangePayload,
+    ) -> Result<Option<NakamotoTenure>, ChainstateError> {
+        // must be a tenure-change
+        if !tenure_payload.cause.expects_sortition() {
+            warn!("Invalid tenure-change: not a sortition-induced tenure-change";
+                  "consensus_hash" => %tenure_payload.tenure_consensus_hash,
+                  "previous_tenure_end" => %tenure_payload.previous_tenure_end
+            );
+            return Ok(None);
+        }
+
+        let Some(parent_header) =
+            Self::get_block_header(headers_conn, &tenure_payload.previous_tenure_end)?
+        else {
+            warn!("Invalid tenure-change: no parent epoch2 header";
+                  "consensus_hash" => %tenure_payload.tenure_consensus_hash,
+                  "previous_tenure_end" => %tenure_payload.previous_tenure_end
+            );
+            return Ok(None);
+        };
+        if tenure_payload.previous_tenure_blocks != 1 {
+            warn!("Invalid tenure-change: expected 1 previous tenure block";
+                  "consensus_hash" => %tenure_payload.tenure_consensus_hash,
+                  "previous_tenure_blocks" => %tenure_payload.previous_tenure_blocks
+            );
+            return Ok(None);
+        }
+        let Some(epoch2_header_info) = parent_header.anchored_header.as_stacks_epoch2() else {
+            warn!("Invalid tenure-change: parent header is not epoch2";
+                  "consensus_hash" => %tenure_payload.tenure_consensus_hash,
+                  "previous_tenure_end" => %tenure_payload.previous_tenure_end
+            );
+            return Ok(None);
+        };
+
+        // synthesize the "last epoch2" tenure info, so we can calculate the first nakamoto tenure
+        let last_epoch2_tenure = NakamotoTenure {
+            tenure_id_consensus_hash: parent_header.consensus_hash.clone(),
+            prev_tenure_id_consensus_hash: ConsensusHash([0x00; 20]), // ignored,
+            sortition_consensus_hash: parent_header.consensus_hash.clone(),
+            cause: TenureChangeCause::BlockFound,
+            block_hash: epoch2_header_info.block_hash(),
+            block_id: StacksBlockId::new(
+                &parent_header.consensus_hash,
+                &epoch2_header_info.block_hash(),
+            ),
+            coinbase_height: epoch2_header_info.total_work.work,
+            // NOTE: first Nakamoto tenure and tenure index will have height 1
+            tenure_index: 0,
+            num_blocks_confirmed: 1,
+        };
+        Ok(Some(last_epoch2_tenure))
+    }
+
+    /// Check that a consensus hash is on the canonical burnchain fork
+    /// Returns Some(corresponding snapshot) if so
+    /// Returns None if it's not on the canonical fork
+    pub(crate) fn check_valid_consensus_hash<SH: SortitionHandle>(
+        sort_handle: &mut SH,
+        ch: &ConsensusHash,
+    ) -> Result<Option<BlockSnapshot>, ChainstateError> {
+        // the target sortition must exist, and it must be on the canonical fork
+        let Some(sn) = SortitionDB::get_block_snapshot_consensus(sort_handle.sqlite(), ch)? else {
+            // no sortition
+            warn!("Invalid consensus hash: no such snapshot"; "consensus_hash" => %ch);
+            return Ok(None);
+        };
+        let Some(ancestor_sn) = sort_handle.get_block_snapshot_by_height(sn.block_height)? else {
+            // not canonical
+            warn!("Invalid consensus hash: snapshot is not canonical"; "consensus_hash" => %ch);
+            return Ok(None);
+        };
+        if ancestor_sn.sortition_id != sn.sortition_id {
+            // not canonical
+            return Ok(None);
+        }
+        Ok(Some(sn))
+    }
+
+    /// Check a Nakamoto tenure transaction's validity with respect to the last-processed tenure
+    /// and the sortition DB.  This validates the following fields:
+    /// * tenure_consensus_hash
+    /// * prev_tenure_consensus_hash
+    /// * previous_tenure_end
+    /// * previous_tenure_blocks
+    /// * cause
+    ///
+    /// Returns Ok(Some(highest-processed-tenure)) on success
+    /// Returns Ok(None) if the tenure change is invalid
+    /// Returns Err(..) on DB error
+    pub(crate) fn check_nakamoto_tenure<SH: SortitionHandle>(
+        headers_conn: &Connection,
+        sort_handle: &mut SH,
+        block_header: &NakamotoBlockHeader,
+        tenure_payload: &TenureChangePayload,
+    ) -> Result<Option<NakamotoTenure>, ChainstateError> {
+        // block header must match this tenure
+        if block_header.consensus_hash != tenure_payload.tenure_consensus_hash {
+            warn!("Invalid tenure-change (or block) -- mismatched consensus hash";
+                  "tenure_payload.tenure_consensus_hash" => %tenure_payload.tenure_consensus_hash,
+                  "block_header.consensus_hash" => %block_header.consensus_hash
+            );
+            return Ok(None);
+        }
+
+        // all consensus hashes must be on the canonical fork, if they're not the first-ever
+        let Some(tenure_sn) =
+            Self::check_valid_consensus_hash(sort_handle, &tenure_payload.tenure_consensus_hash)?
+        else {
+            return Ok(None);
+        };
+        let Some(sortition_sn) = Self::check_valid_consensus_hash(
+            sort_handle,
+            &tenure_payload.sortition_consensus_hash,
+        )?
+        else {
+            return Ok(None);
+        };
+
+        // tenure_sn must be no more recent than sortition_sn
+        if tenure_sn.block_height > sortition_sn.block_height {
+            warn!("Invalid tenure-change: tenure snapshot comes sortition snapshot"; "tenure_consensus_hash" => %tenure_payload.tenure_consensus_hash, "sortition_consensus_hash" => %tenure_payload.prev_tenure_consensus_hash);
+            return Ok(None);
+        }
+
+        if tenure_payload.prev_tenure_consensus_hash != FIRST_BURNCHAIN_CONSENSUS_HASH {
+            // the parent sortition must exist, must be canonical, and must be an ancestor of the
+            // sortition for the given consensus hash.
+            let Some(prev_sn) = Self::check_valid_consensus_hash(
+                sort_handle,
+                &tenure_payload.prev_tenure_consensus_hash,
+            )?
+            else {
+                return Ok(None);
+            };
+            match tenure_payload.cause {
+                TenureChangeCause::BlockFound => {
+                    if prev_sn.block_height >= tenure_sn.block_height {
+                        // parent comes after child
+                        warn!("Invalid tenure-change: parent snapshot comes at or after current tenure"; "tenure_consensus_hash" => %tenure_payload.tenure_consensus_hash, "prev_tenure_consensus_hash" => %tenure_payload.prev_tenure_consensus_hash);
+                        return Ok(None);
+                    }
+                }
+                TenureChangeCause::Extended => {
+                    // prev and current tenure consensus hashes must be identical
+                    if prev_sn.consensus_hash != tenure_sn.consensus_hash {
+                        warn!("Invalid tenure-change extension: parent snapshot is not the same as the current tenure snapshot"; "tenure_consensus_hash" => %tenure_payload.tenure_consensus_hash, "prev_tenure_consensus_hash" => %tenure_payload.prev_tenure_consensus_hash);
+                        return Ok(None);
+                    }
+                }
+            }
+
+            if prev_sn.block_height > sortition_sn.block_height {
+                // parent comes after tip
+                warn!("Invalid tenure-change: parent snapshot comes after current tip"; "sortition_consensus_hash" => %tenure_payload.sortition_consensus_hash, "prev_tenure_consensus_hash" => %tenure_payload.prev_tenure_consensus_hash);
+                return Ok(None);
+            }
+            if !prev_sn.sortition {
+                // parent wasn't a sortition-induced tenure change
+                warn!("Invalid tenure-change: no block found";
+                      "prev_tenure_consensus_hash" => %tenure_payload.prev_tenure_consensus_hash
+                );
+                return Ok(None);
+            }
+        }
+
+        // the tenure must correspond to sortitions
+        if !tenure_sn.sortition {
+            warn!("Invalid tenure-change: no block found";
+                  "tenure_consensus_hash" => %tenure_payload.tenure_consensus_hash
+            );
+            return Ok(None);
+        }
+
+        let Some(highest_processed_tenure) =
+            Self::get_highest_nakamoto_tenure(headers_conn, sort_handle)?
+        else {
+            // no previous tenures.  This is the first tenure change.  It should point to an epoch
+            // 2.x block.
+            return Self::check_first_nakamoto_tenure_change(headers_conn, tenure_payload);
+        };
+
+        // validate cause
+        match tenure_payload.cause {
+            TenureChangeCause::BlockFound => {}
+            TenureChangeCause::Extended => {
+                // tenure extensions don't begin a new tenure (since the miner isn't changing), so
+                // the tenure consensus hash must be the same as the previous tenure consensus hash
+                if tenure_payload.tenure_consensus_hash != tenure_payload.prev_tenure_consensus_hash
+                {
+                    warn!("Invalid tenure-change: tenure extension tries to start a new tenure";
+                          "tenure_consensus_hash" => %tenure_payload.tenure_consensus_hash,
+                          "prev_tenure_consensus_hash" => %tenure_payload.prev_tenure_consensus_hash,
+                    );
+                    return Ok(None);
+                }
+                if tenure_payload.sortition_consensus_hash
+                    == highest_processed_tenure.sortition_consensus_hash
+                {
+                    // if we're extending tenure within the same sortition, then the tenure and
+                    // prev_tenure consensus hashes must match that of the highest.
+                    if highest_processed_tenure.tenure_id_consensus_hash
+                        != tenure_payload.tenure_consensus_hash
+                        || highest_processed_tenure.tenure_id_consensus_hash
+                            != tenure_payload.prev_tenure_consensus_hash
+                    {
+                        warn!("Invalid tenure-change: tenure extension within the same sortition tries to override the highest sortition";
+                              "tenure_consensus_hash" => %tenure_payload.tenure_consensus_hash,
+                              "prev_tenure_consensus_hash" => %tenure_payload.prev_tenure_consensus_hash,
+                              "highest_processed_tenure.consensus_hash" => %highest_processed_tenure.tenure_id_consensus_hash,
+                              "highest_processed_tenure.prev_consensus_hash" => %highest_processed_tenure.prev_tenure_id_consensus_hash
+                        );
+                        return Ok(None);
+                    }
+                }
+            }
+        }
+
+        let Some(last_tenure_finish_block_id) = Self::get_nakamoto_tenure_finish_block_header(
+            headers_conn,
+            &highest_processed_tenure.tenure_id_consensus_hash,
+        )?
+        .map(|hdr| hdr.index_block_hash()) else {
+            // last tenure doesn't exist (should be unreachable)
+            warn!("Invalid tenure-change: no blocks found for highest processed tenure";
+                  "consensus_hash" => %highest_processed_tenure.tenure_id_consensus_hash,
+            );
+            return Ok(None);
+        };
+
+        // must build atop the highest-processed tenure.
+        // NOTE: for tenure-extensions, the second check is always false, since the tenure and
+        // prev-tenure consensus hashes must be the same per the above check.
+        if last_tenure_finish_block_id != tenure_payload.previous_tenure_end
+            || highest_processed_tenure.tenure_id_consensus_hash
+                != tenure_payload.prev_tenure_consensus_hash
+        {
+            // not continuous -- this tenure-change does not point to the end of the
+            // last-processed tenure, or does not point to the last-processed tenure's sortition
+            warn!("Invalid tenure-change: discontiguous";
+                  "tenure_consensus_hash" => %tenure_payload.tenure_consensus_hash,
+                  "prev_tenure_consensus_hash" => %tenure_payload.prev_tenure_consensus_hash,
+                  "highest_processed_tenure.consensus_hash" => %highest_processed_tenure.tenure_id_consensus_hash,
+                  "last_tenure_finish_block_id" => %last_tenure_finish_block_id,
+                  "tenure_payload.previous_tenure_end" => %tenure_payload.previous_tenure_end
+            );
+            return Ok(None);
+        }
+
+        // The tenure-change must report the number of blocks _so far_ in the current tenure.  If
+        // there is a succession of tenure-extensions for a given tenure, then the reported tenure
+        // length must report the number of blocks since the last _sortition-induced_ tenure
+        // change.
+        let tenure_len = Self::get_nakamoto_tenure_length(
+            headers_conn,
+            &highest_processed_tenure.tenure_id_consensus_hash,
+        )?;
+        if tenure_len != tenure_payload.previous_tenure_blocks {
+            // invalid -- does not report the correct number of blocks in the past tenure
+            warn!("Invalid tenure-change: wrong number of blocks";
+                  "tenure_consensus_hash" => %tenure_payload.tenure_consensus_hash,
+                  "highest_processed_tenure.consensus_hash" => %highest_processed_tenure.tenure_id_consensus_hash,
+                  "tenure_len" => tenure_len,
+                  "tenure_payload.previous_tenure_blocks" => tenure_payload.previous_tenure_blocks
+            );
+            return Ok(None);
+        }
+
+        Ok(Some(highest_processed_tenure))
+    }
+
+    /// Advance the tenures table with a validated block's tenure data.
+    /// This applies to both tenure-changes and tenure-extends.
+    /// Returns the highest tenure-change height (this is parent_coinbase_height + 1 if there was a
+    /// tenure-change tx, or just parent_coinbase_height if there was a tenure-extend tx or no tenure
+    /// txs at all).
+    /// TODO: unit test
+    pub(crate) fn advance_nakamoto_tenure(
+        headers_tx: &mut StacksDBTx,
+        sort_tx: &mut SortitionHandleTx,
+        block: &NakamotoBlock,
+        parent_coinbase_height: u64,
+    ) -> Result<u64, ChainstateError> {
+        let Some(tenure_payload) = block.get_tenure_tx_payload() else {
+            // no new tenure
+            return Ok(parent_coinbase_height);
+        };
+
+        let coinbase_height = match tenure_payload.cause {
+            TenureChangeCause::BlockFound => {
+                // tenure height advances
+                parent_coinbase_height
+                    .checked_add(1)
+                    .expect("FATAL: too many tenures")
+            }
+            TenureChangeCause::Extended => {
+                // tenure height does not advance
+                parent_coinbase_height
+            }
+        };
+
+        let Some(highest_processed_tenure) =
+            Self::check_nakamoto_tenure(headers_tx, sort_tx, &block.header, tenure_payload)?
+        else {
+            return Err(ChainstateError::InvalidStacksTransaction(
+                "Invalid tenure tx".into(),
+                false,
+            ));
+        };
+
+        Self::insert_nakamoto_tenure(
+            headers_tx,
+            &block.header,
+            coinbase_height,
+            highest_processed_tenure
+                .tenure_index
+                .checked_add(1)
+                .expect("too many tenure-changes"),
+            tenure_payload,
+        )?;
+        return Ok(coinbase_height);
+    }
+
+    /// Check that this block is in the same tenure as its parent, and that this tenure is the
+    /// highest-seen tenure.  Use this to check blocks that do _not_ have tenure-changes.
+    ///
+    /// Returns Ok(bool) to indicate whether or not this block is in the same tenure as its parent.
+    /// Returns Err(..) on DB error
+    pub(crate) fn check_tenure_continuity<SH: SortitionHandle>(
+        headers_conn: &Connection,
+        sort_handle: &mut SH,
+        parent_ch: &ConsensusHash,
+        block_header: &NakamotoBlockHeader,
+    ) -> Result<bool, ChainstateError> {
+        // block must have the same consensus hash as its parent
+        if block_header.is_first_mined() || parent_ch != &block_header.consensus_hash {
+            return Ok(false);
+        }
+
+        // block must be in the same tenure as the highest-processed tenure.
+        let Some(highest_tenure) = Self::get_highest_nakamoto_tenure(headers_conn, sort_handle)?
+        else {
+            // no tenures yet, so definitely not continuous
+            return Ok(false);
+        };
+
+        if &highest_tenure.tenure_id_consensus_hash != parent_ch {
+            // this block is not in the highest-known tenure, so it can't be continuous
+            return Ok(false);
+        }
+
+        Ok(true)
+    }
+
+    /// Calculate the scheduled block-reward for this tenure.
+    /// - chainstate_tx: the transaction open against the chainstate
+    /// - burn_dbconn: the sortition fork tx open against the sortition DB
+    /// - block: the block being processed
+    /// - parent_coinbase_height: the number of tenures represented by the parent of this block
+    /// (equivalent to the number of coinbases)
+    /// - chain_tip_burn_header_height: the height of the burnchain block mined when this block was
+    /// produced
+    /// - burnchain_commit_burn: how many burnchain tokens were spent by this block's tenure's block-commit
+    /// - burnchain_sortition_burn: total burnchain tokens spent by all miners for this block's
+    /// tenure
+    ///
+    /// Returns the scheduled reward for this block's miner, subject to:
+    /// - accumulated STX from missed sortitions
+    /// - initial mining bonus, if any
+    /// - the coinbase reward at this burnchain block height
+    /// - the parent tenure's total fees
+    ///
+    /// TODO: unit test
+    pub(crate) fn calculate_scheduled_tenure_reward(
+        chainstate_tx: &mut ChainstateTx,
+        burn_dbconn: &mut SortitionHandleTx,
+        block: &NakamotoBlock,
+        evaluated_epoch: StacksEpochId,
+        parent_coinbase_height: u64,
+        chain_tip_burn_header_height: u64,
+        burnchain_commit_burn: u64,
+        burnchain_sortition_burn: u64,
+    ) -> Result<MinerPaymentSchedule, ChainstateError> {
+        let mainnet = chainstate_tx.get_config().mainnet;
+
+        // figure out if there any accumulated rewards by
+        //   getting the snapshot that elected this block.
+        let accumulated_rewards = SortitionDB::get_block_snapshot_consensus(
+            burn_dbconn.tx(),
+            &block.header.consensus_hash,
+        )?
+        .expect("CORRUPTION: failed to load snapshot that elected processed block")
+        .accumulated_coinbase_ustx;
+
+        let coinbase_at_block = StacksChainState::get_coinbase_reward(
+            chain_tip_burn_header_height,
+            burn_dbconn.context.first_block_height,
+        );
+
+        let total_coinbase = coinbase_at_block.saturating_add(accumulated_rewards);
+        let parent_tenure_start_header: StacksHeaderInfo = Self::get_header_by_coinbase_height(
+            chainstate_tx,
+            &block.header.parent_block_id,
+            parent_coinbase_height,
+        )?
+        .ok_or_else(|| {
+            warn!("While processing tenure change, failed to look up parent tenure";
+                  "parent_coinbase_height" => parent_coinbase_height,
+                  "parent_block_id" => %block.header.parent_block_id,
+                  "block_hash" => %block.header.block_hash(),
+                  "block_consensus_hash" => %block.header.consensus_hash);
+            ChainstateError::NoSuchBlockError
+        })?;
+        // fetch the parent tenure fees by reading the total tx fees from this block's
+        // *parent* (not parent_tenure_start_header), because `parent_block_id` is the last
+        // block of that tenure, so contains a total fee accumulation for the whole tenure
+        let parent_tenure_fees = if parent_tenure_start_header.is_nakamoto_block() {
+            Self::get_total_tenure_tx_fees_at(
+                chainstate_tx,
+                &block.header.parent_block_id
+            )?.ok_or_else(|| {
+                warn!("While processing tenure change, failed to look up parent block's total tx fees";
+                      "parent_block_id" => %block.header.parent_block_id,
+                      "block_hash" => %block.header.block_hash(),
+                      "block_consensus_hash" => %block.header.consensus_hash);
+                ChainstateError::NoSuchBlockError
+            })?
+        } else {
+            // if the parent tenure is an epoch-2 block, don't pay
+            // any fees to them in this schedule: nakamoto blocks
+            // cannot confirm microblock transactions, and
+            // anchored transactions are scheduled
+            // by the parent in epoch-2.
+            0
+        };
+
+        Ok(Self::make_scheduled_miner_reward(
+            mainnet,
+            evaluated_epoch,
+            &parent_tenure_start_header.anchored_header.block_hash(),
+            &parent_tenure_start_header.consensus_hash,
+            &block.header.block_hash(),
+            &block.header.consensus_hash,
+            block.header.chain_length,
+            block
+                .get_coinbase_tx()
+                .ok_or(ChainstateError::InvalidStacksBlock(
+                    "No coinbase transaction in tenure changing block".into(),
+                ))?,
+            parent_tenure_fees,
+            burnchain_commit_burn,
+            burnchain_sortition_burn,
+            total_coinbase,
+        ))
+    }
+
+    /// Get the burnchain block info of a given tenure's consensus hash.
+    /// Used for the tx receipt.
+    pub(crate) fn get_tenure_burn_block_info(
+        burn_dbconn: &Connection,
+        first_mined: bool,
+        ch: &ConsensusHash,
+    ) -> Result<(BurnchainHeaderHash, u64, u64), ChainstateError> {
+        // get burn block stats, for the transaction receipt
+        let (burn_block_hash, burn_block_height, burn_block_timestamp) = if first_mined {
+            (BurnchainHeaderHash([0; 32]), 0, 0)
+        } else {
+            match SortitionDB::get_block_snapshot_consensus(burn_dbconn, ch)? {
+                Some(sn) => (
+                    sn.burn_header_hash,
+                    sn.block_height,
+                    sn.burn_header_timestamp,
+                ),
+                None => {
+                    // shouldn't happen
+                    warn!("CORRUPTION: {} does not correspond to a burn block", ch,);
+                    (BurnchainHeaderHash([0; 32]), 0, 0)
+                }
+            }
+        };
+
+        Ok((burn_block_hash, burn_block_height, burn_block_timestamp))
+    }
+
+    /// Check that a given Nakamoto block's tenure's sortition exists and was processed.
+    /// Return the sortition's burnchain block's hash and its burnchain height
+    pub(crate) fn check_sortition_exists(
+        burn_dbconn: &mut SortitionHandleTx,
+        block_consensus_hash: &ConsensusHash,
+    ) -> Result<(BurnchainHeaderHash, u64), ChainstateError> {
+        // check that the burnchain block that this block is associated with has been processed.
+        // N.B. we must first get its hash, and then verify that it's in the same Bitcoin fork as
+        // our `burn_dbconn` indicates.
+        let burn_header_hash =
+            SortitionDB::get_burnchain_header_hash_by_consensus(burn_dbconn, block_consensus_hash)?
+                .ok_or_else(|| {
+                    warn!(
+                        "Unrecognized consensus hash";
+                        "consensus_hash" => %block_consensus_hash,
+                    );
+                    ChainstateError::NoSuchBlockError
+                })?;
+
+        let sortition_tip = burn_dbconn.context.chain_tip.clone();
+        let burn_header_height = burn_dbconn
+            .get_block_snapshot(&burn_header_hash, &sortition_tip)?
+            .ok_or_else(|| {
+                warn!(
+                    "Tried to process Nakamoto block before its burn view was processed";
+                    "burn_header_hash" => %burn_header_hash,
+                );
+                ChainstateError::NoSuchBlockError
+            })?
+            .block_height;
+
+        Ok((burn_header_hash, burn_header_height))
+    }
+}

From 85f32f7730d35286862daecd5ddfa2e3f2b9ecf0 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Thu, 7 Dec 2023 12:19:58 -0500
Subject: [PATCH 0122/1166] Make tx fee a variable in stackerdb dkg test and
 increase it

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 clarity/src/vm/functions/mod.rs         | 3 +--
 testnet/stacks-node/src/tests/signer.rs | 5 +++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/clarity/src/vm/functions/mod.rs b/clarity/src/vm/functions/mod.rs
index ac03c6db34..b653ebab76 100644
--- a/clarity/src/vm/functions/mod.rs
+++ b/clarity/src/vm/functions/mod.rs
@@ -64,9 +64,8 @@ macro_rules! switch_on_global_epoch {
     };
 }
 
-use crate::vm::ClarityVersion;
-
 use super::errors::InterpreterError;
+use crate::vm::ClarityVersion;
 
 mod arithmetic;
 mod assets;
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index 7c459b5e4f..87f0698610 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -133,10 +133,11 @@ fn setup_stx_btc_node(
 
     info!("Send pox contract-publish...");
 
+    let tx_fee = 100_000;
     let tx = make_contract_publish(
         publisher_private_key,
         0,
-        10_000,
+        tx_fee,
         &pox_contract_id.name,
         pox_contract,
     );
@@ -146,7 +147,7 @@ fn setup_stx_btc_node(
     let tx = make_contract_publish(
         publisher_private_key,
         1,
-        10_000,
+        tx_fee,
         &stackerdb_contract_id.name,
         stackerdb_contract,
     );

From 301243bea0b9a21d62c8b768abbe855d9724bd5c Mon Sep 17 00:00:00 2001
From: Joey Yandle <xoloki@gmail.com>
Date: Thu, 7 Dec 2023 14:54:42 -0500
Subject: [PATCH 0123/1166] reduce number of signers and keys so test doesn't
 consume all available file descriptors

---
 testnet/stacks-node/src/tests/signer.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index 87f0698610..a3b5865f7f 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -200,8 +200,8 @@ fn test_stackerdb_dkg() {
         .init();
 
     // Generate Signer Data
-    let num_signers: u32 = 100;
-    let num_keys: u32 = 4000;
+    let num_signers: u32 = 10;
+    let num_keys: u32 = 400;
     let publisher_private_key = StacksPrivateKey::new();
     let signer_stacks_private_keys = (0..num_signers)
         .map(|_| StacksPrivateKey::new())

From fa6d26b4660760c012a0e07e9f95b0aa7c24d7a4 Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Thu, 7 Dec 2023 22:59:40 -0500
Subject: [PATCH 0124/1166] fix: handle epochs 2.5 and 3.0 correctly

---
 clarity/src/vm/functions/mod.rs      | 3 +--
 testnet/stacks-node/src/config.rs    | 2 ++
 testnet/stacks-node/src/neon_node.rs | 4 ++--
 3 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/clarity/src/vm/functions/mod.rs b/clarity/src/vm/functions/mod.rs
index b399f14928..479f79581b 100644
--- a/clarity/src/vm/functions/mod.rs
+++ b/clarity/src/vm/functions/mod.rs
@@ -68,9 +68,8 @@ macro_rules! switch_on_global_epoch {
     };
 }
 
-use crate::vm::ClarityVersion;
-
 use super::errors::InterpreterError;
+use crate::vm::ClarityVersion;
 
 mod arithmetic;
 mod assets;
diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index 395a9415b7..f634f526c8 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -713,6 +713,8 @@ impl Config {
             StacksEpochId::Epoch22,
             StacksEpochId::Epoch23,
             StacksEpochId::Epoch24,
+            StacksEpochId::Epoch25,
+            StacksEpochId::Epoch30,
         ];
         for (expected_epoch, configured_epoch) in expected_list
             .iter()
diff --git a/testnet/stacks-node/src/neon_node.rs b/testnet/stacks-node/src/neon_node.rs
index c13a35af53..5ef68a4c28 100644
--- a/testnet/stacks-node/src/neon_node.rs
+++ b/testnet/stacks-node/src/neon_node.rs
@@ -178,7 +178,7 @@ use stacks::chainstate::stacks::{
     TransactionAnchorMode, TransactionPayload, TransactionVersion,
 };
 use stacks::core::mempool::MemPoolDB;
-use stacks::core::{FIRST_BURNCHAIN_CONSENSUS_HASH, STACKS_EPOCH_2_4_MARKER};
+use stacks::core::{FIRST_BURNCHAIN_CONSENSUS_HASH, STACKS_EPOCH_3_0_MARKER};
 use stacks::cost_estimates::metrics::{CostMetric, UnitMetric};
 use stacks::cost_estimates::{CostEstimator, FeeEstimator, UnitEstimator};
 use stacks::monitoring;
@@ -1317,7 +1317,7 @@ impl BlockMinerThread {
             apparent_sender: sender,
             key_block_ptr: key.block_height as u32,
             key_vtxindex: key.op_vtxindex as u16,
-            memo: vec![STACKS_EPOCH_2_4_MARKER],
+            memo: vec![STACKS_EPOCH_3_0_MARKER],
             new_seed: vrf_seed,
             parent_block_ptr,
             parent_vtxindex,

From ce5faa34b27dccd64e56059c9d012327fe864644 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Fri, 8 Dec 2023 09:48:52 -0600
Subject: [PATCH 0125/1166] fix: RPC endpoints should default to proof=1

---
 stackslib/src/net/http/request.rs |  2 +-
 stackslib/src/net/httpcore.rs     | 13 ++++++-------
 2 files changed, 7 insertions(+), 8 deletions(-)

diff --git a/stackslib/src/net/http/request.rs b/stackslib/src/net/http/request.rs
index b0e2eab059..36df8235a0 100644
--- a/stackslib/src/net/http/request.rs
+++ b/stackslib/src/net/http/request.rs
@@ -612,7 +612,7 @@ impl HttpRequestContents {
     }
 
     /// Get a query argument
-    pub fn get_query_arg(&self, key: &String) -> Option<&String> {
+    pub fn get_query_arg(&self, key: &str) -> Option<&String> {
         self.query_args.get(key)
     }
 
diff --git a/stackslib/src/net/httpcore.rs b/stackslib/src/net/httpcore.rs
index 5ed344fefe..8b4c11bb07 100644
--- a/stackslib/src/net/httpcore.rs
+++ b/stackslib/src/net/httpcore.rs
@@ -329,13 +329,12 @@ impl HttpRequestContentsExtensions for HttpRequestContents {
 
     /// Get the proof= query parameter value
     fn get_with_proof(&self) -> bool {
-        let with_proof = if let Some(proof_val) = self.get_query_arg(&"proof".to_string()) {
-            proof_val == "1"
-        } else {
-            false
-        };
-
-        with_proof
+        let proof_value = self
+            .get_query_arg("proof")
+            .map(|x| x.to_owned())
+            // default to "with proof"
+            .unwrap_or("1".into());
+        &proof_value == "1"
     }
 }
 

From 37e134b0f3ed0e21d630806ef466e730d594fde5 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Fri, 8 Dec 2023 12:40:22 -0500
Subject: [PATCH 0126/1166] chore: address PR feedback and get testnet to build

---
 clarity/src/vm/functions/mod.rs               |   3 +-
 .../chainstate/nakamoto/coordinator/tests.rs  |  43 +--
 stackslib/src/chainstate/nakamoto/mod.rs      | 363 +++++++++---------
 stackslib/src/chainstate/nakamoto/tenure.rs   |  73 ++--
 .../src/chainstate/nakamoto/tests/mod.rs      |  80 ++--
 .../src/chainstate/nakamoto/tests/node.rs     |   2 +-
 stackslib/src/chainstate/stacks/block.rs      |   2 +-
 stackslib/src/chainstate/stacks/db/mod.rs     |   8 +
 stackslib/src/chainstate/stacks/mod.rs        |   8 +-
 .../src/chainstate/stacks/transaction.rs      |   6 +-
 testnet/stacks-node/src/mockamoto.rs          |  15 +-
 testnet/stacks-node/src/mockamoto/signer.rs   |   5 +-
 12 files changed, 292 insertions(+), 316 deletions(-)

diff --git a/clarity/src/vm/functions/mod.rs b/clarity/src/vm/functions/mod.rs
index b399f14928..479f79581b 100644
--- a/clarity/src/vm/functions/mod.rs
+++ b/clarity/src/vm/functions/mod.rs
@@ -68,9 +68,8 @@ macro_rules! switch_on_global_epoch {
     };
 }
 
-use crate::vm::ClarityVersion;
-
 use super::errors::InterpreterError;
+use crate::vm::ClarityVersion;
 
 mod arithmetic;
 mod assets;
diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index 911dd36bc4..6fcf5b1498 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -251,7 +251,7 @@ fn test_simple_nakamoto_coordinator_bootup() {
     let vrf_proof = peer.make_nakamoto_vrf_proof(miner_key);
 
     tenure_change.tenure_consensus_hash = consensus_hash.clone();
-    tenure_change.sortition_consensus_hash = consensus_hash.clone();
+    tenure_change.burn_view_consensus_hash = consensus_hash.clone();
     let tenure_change_tx = peer
         .miner
         .make_nakamoto_tenure_change(tenure_change.clone());
@@ -306,7 +306,7 @@ fn test_simple_nakamoto_coordinator_1_tenure_10_blocks() {
     let vrf_proof = peer.make_nakamoto_vrf_proof(miner_key);
 
     tenure_change.tenure_consensus_hash = consensus_hash.clone();
-    tenure_change.sortition_consensus_hash = consensus_hash.clone();
+    tenure_change.burn_view_consensus_hash = consensus_hash.clone();
 
     let tenure_change_tx = peer
         .miner
@@ -448,7 +448,7 @@ fn test_nakamoto_chainstate_getters() {
     let vrf_proof = peer.make_nakamoto_vrf_proof(miner_key);
 
     tenure_change.tenure_consensus_hash = consensus_hash.clone();
-    tenure_change.sortition_consensus_hash = consensus_hash.clone();
+    tenure_change.burn_view_consensus_hash = consensus_hash.clone();
     let tenure_change_tx = peer
         .miner
         .make_nakamoto_tenure_change(tenure_change.clone());
@@ -569,7 +569,7 @@ fn test_nakamoto_chainstate_getters() {
         assert_eq!(highest_tenure.num_blocks_confirmed, 1);
         assert_eq!(highest_tenure.tenure_index, 1);
         assert_eq!(highest_tenure.tenure_id_consensus_hash, consensus_hash);
-        assert_eq!(highest_tenure.sortition_consensus_hash, consensus_hash);
+        assert_eq!(highest_tenure.burn_view_consensus_hash, consensus_hash);
 
         // confirm that getting the burn block for this highest tenure works
         let sn = SortitionDB::get_block_snapshot_consensus(
@@ -578,15 +578,6 @@ fn test_nakamoto_chainstate_getters() {
         )
         .unwrap()
         .unwrap();
-        let (bhh, bhh_height, bhh_ts) = NakamotoChainState::get_tenure_burn_block_info(
-            sort_tx.tx(),
-            false,
-            &highest_tenure.tenure_id_consensus_hash,
-        )
-        .unwrap();
-        assert_eq!(sn.burn_header_hash, bhh);
-        assert_eq!(sn.block_height, bhh_height);
-        assert_eq!(sn.burn_header_timestamp, bhh_ts);
 
         // this tenure's TC tx is the first-ever TC
         let tenure_change_payload = blocks[0].get_tenure_change_tx_payload().unwrap().clone();
@@ -618,7 +609,7 @@ fn test_nakamoto_chainstate_getters() {
         .is_some());
         assert!(NakamotoChainState::check_valid_consensus_hash(
             &mut sort_tx,
-            &tenure_change_payload.sortition_consensus_hash
+            &tenure_change_payload.burn_view_consensus_hash
         )
         .unwrap()
         .is_some());
@@ -678,7 +669,7 @@ fn test_nakamoto_chainstate_getters() {
     let next_vrf_proof = peer.make_nakamoto_vrf_proof(miner_key);
 
     next_tenure_change.tenure_consensus_hash = next_consensus_hash.clone();
-    next_tenure_change.sortition_consensus_hash = next_consensus_hash.clone();
+    next_tenure_change.burn_view_consensus_hash = next_consensus_hash.clone();
 
     let next_tenure_change_tx = peer
         .miner
@@ -750,7 +741,7 @@ fn test_nakamoto_chainstate_getters() {
         assert_eq!(highest_tenure.tenure_index, 2);
         assert_eq!(highest_tenure.tenure_id_consensus_hash, next_consensus_hash);
         assert_eq!(highest_tenure.prev_tenure_id_consensus_hash, consensus_hash);
-        assert_eq!(highest_tenure.sortition_consensus_hash, next_consensus_hash);
+        assert_eq!(highest_tenure.burn_view_consensus_hash, next_consensus_hash);
 
         // this tenure's TC tx is NOT the first-ever TC
         let tenure_change_payload = new_blocks[0]
@@ -794,7 +785,7 @@ fn test_nakamoto_chainstate_getters() {
         .is_some());
         assert!(NakamotoChainState::check_valid_consensus_hash(
             &mut sort_tx,
-            &tenure_change_payload.sortition_consensus_hash
+            &tenure_change_payload.burn_view_consensus_hash
         )
         .unwrap()
         .is_some());
@@ -812,7 +803,7 @@ fn test_nakamoto_chainstate_getters() {
         .is_some());
         assert!(NakamotoChainState::check_valid_consensus_hash(
             &mut sort_tx,
-            &old_tenure_change_payload.sortition_consensus_hash
+            &old_tenure_change_payload.burn_view_consensus_hash
         )
         .unwrap()
         .is_some());
@@ -892,7 +883,7 @@ fn test_simple_nakamoto_coordinator_10_tenures_10_blocks() {
         let vrf_proof = peer.make_nakamoto_vrf_proof(miner_key);
 
         tenure_change.tenure_consensus_hash = consensus_hash.clone();
-        tenure_change.sortition_consensus_hash = consensus_hash.clone();
+        tenure_change.burn_view_consensus_hash = consensus_hash.clone();
 
         let tenure_change_tx = peer
             .miner
@@ -1203,7 +1194,7 @@ fn test_simple_nakamoto_coordinator_2_tenures_3_sortitions() {
     let vrf_proof = peer.make_nakamoto_vrf_proof(miner_key);
 
     tenure_change.tenure_consensus_hash = consensus_hash.clone();
-    tenure_change.sortition_consensus_hash = consensus_hash.clone();
+    tenure_change.burn_view_consensus_hash = consensus_hash.clone();
     let tenure_change_tx = peer
         .miner
         .make_nakamoto_tenure_change(tenure_change.clone());
@@ -1282,7 +1273,7 @@ fn test_simple_nakamoto_coordinator_2_tenures_3_sortitions() {
     };
     assert_eq!(highest_tenure.tenure_id_consensus_hash, tip.consensus_hash);
     assert_eq!(
-        highest_tenure.sortition_consensus_hash,
+        highest_tenure.burn_view_consensus_hash,
         sort_tip.consensus_hash
     );
     assert!(tip.consensus_hash == sort_tip.consensus_hash);
@@ -1375,7 +1366,7 @@ fn test_simple_nakamoto_coordinator_2_tenures_3_sortitions() {
     };
     assert_eq!(highest_tenure.tenure_id_consensus_hash, tip.consensus_hash);
     assert_eq!(
-        highest_tenure.sortition_consensus_hash,
+        highest_tenure.burn_view_consensus_hash,
         sort_tip.consensus_hash
     );
     assert!(tip.consensus_hash != sort_tip.consensus_hash);
@@ -1391,7 +1382,7 @@ fn test_simple_nakamoto_coordinator_2_tenures_3_sortitions() {
     let vrf_proof = peer.make_nakamoto_vrf_proof(miner_key);
 
     tenure_change.tenure_consensus_hash = consensus_hash.clone();
-    tenure_change.sortition_consensus_hash = consensus_hash.clone();
+    tenure_change.burn_view_consensus_hash = consensus_hash.clone();
 
     let tenure_change_tx = peer
         .miner
@@ -1471,7 +1462,7 @@ fn test_simple_nakamoto_coordinator_2_tenures_3_sortitions() {
     };
     assert_eq!(highest_tenure.tenure_id_consensus_hash, tip.consensus_hash);
     assert_eq!(
-        highest_tenure.sortition_consensus_hash,
+        highest_tenure.burn_view_consensus_hash,
         sort_tip.consensus_hash
     );
     assert!(tip.consensus_hash == sort_tip.consensus_hash);
@@ -1534,7 +1525,7 @@ fn test_simple_nakamoto_coordinator_10_tenures_and_extensions_10_blocks() {
         let vrf_proof = peer.make_nakamoto_vrf_proof(miner_key);
 
         tenure_change.tenure_consensus_hash = consensus_hash.clone();
-        tenure_change.sortition_consensus_hash = consensus_hash.clone();
+        tenure_change.burn_view_consensus_hash = consensus_hash.clone();
 
         let tenure_change_tx = peer
             .miner
@@ -1622,7 +1613,7 @@ fn test_simple_nakamoto_coordinator_10_tenures_and_extensions_10_blocks() {
             last_block.header.consensus_hash
         );
         assert_eq!(
-            highest_tenure.sortition_consensus_hash,
+            highest_tenure.burn_view_consensus_hash,
             sort_tip.consensus_hash
         );
         assert!(last_block.header.consensus_hash == sort_tip.consensus_hash);
diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index 7373ba2a99..6d6bb8b6ab 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -515,12 +515,8 @@ impl NakamotoBlock {
     /// If it's present, then it's the first transaction (i.e. tx 0).
     /// NOTE: this does _not_ return a tenure-extend transaction payload.
     pub fn get_tenure_change_tx_payload(&self) -> Option<&TenureChangePayload> {
-        let wellformed = self.is_wellformed_tenure_start_block();
-        if let Some(false) = wellformed {
-            // block isn't well-formed
-            return None;
-        } else if wellformed.is_none() {
-            // no tenure-change
+        if self.is_wellformed_tenure_start_block() != Ok(true) {
+            // no tenure-change, or invalid
             return None;
         }
 
@@ -538,12 +534,8 @@ impl NakamotoBlock {
     /// If it's present, then it's the first transaction (i.e. tx 0)
     /// NOTE: this does _not_ return a tenure-change transaction payload.
     pub fn get_tenure_extend_tx_payload(&self) -> Option<&TenureChangePayload> {
-        let wellformed = self.is_wellformed_tenure_extend_block();
-        if let Some(false) = wellformed {
-            // block isn't well-formed
-            return None;
-        } else if wellformed.is_none() {
-            // no tenure extend
+        if self.is_wellformed_tenure_extend_block() != Ok(true) {
+            // no tenure-extend, or invalid
             return None;
         }
 
@@ -572,13 +564,8 @@ impl NakamotoBlock {
     /// Get the coinbase transaction in Nakamoto.
     /// It's the first non-TenureChange transaction (i.e. tx 1)
     pub fn get_coinbase_tx(&self) -> Option<&StacksTransaction> {
-        let wellformed = self.is_wellformed_tenure_start_block();
-        if wellformed.is_none() {
-            // block isn't a first-tenure block, so no coinbase
-            return None;
-        }
-        if let Some(false) = wellformed {
-            // block isn't well-formed
+        if self.is_wellformed_tenure_start_block() != Ok(true) {
+            // not a tenure-change block, or invalid
             return None;
         }
 
@@ -608,6 +595,20 @@ impl NakamotoBlock {
             .flatten()
     }
 
+    /// Try to get the first transaction in the block as a tenure-change
+    /// Return Some(tenure-change-payload) if it's a tenure change
+    /// Return None if not
+    fn try_get_tenure_change_payload(&self) -> Option<&TenureChangePayload> {
+        if self.txs.len() == 0 {
+            return None;
+        }
+        if let TransactionPayload::TenureChange(ref tc) = &self.txs[0].payload {
+            Some(tc)
+        } else {
+            None
+        }
+    }
+
     /// Determine if this is a well-formed tenure-extend block.
     /// * It has exactly one TenureChange, and it does _not_ require a sortiton (it's `cause` is
     /// `Extended`)
@@ -615,27 +616,20 @@ impl NakamotoBlock {
     /// * There is no coinbase
     /// * There are no other TenureChange transactions
     ///
-    /// Returns Some(true) if the above are true
-    /// Returns Some(false) if at least one of the above is false
-    /// Returns None if this block is not a tenure-extend block
-    pub fn is_wellformed_tenure_extend_block(&self) -> Option<bool> {
+    /// Returns Ok(true) if the above are true
+    /// Returns Ok(false) if it is not a tenure-extend block
+    /// Returns Err(()) if this block cannot be a valid block
+    pub fn is_wellformed_tenure_extend_block(&self) -> Result<bool, ()> {
         // find coinbases
-        let coinbase_positions = self
+        let has_coinbase = self
             .txs
             .iter()
-            .enumerate()
-            .filter_map(|(i, tx)| {
-                if let TransactionPayload::Coinbase(..) = &tx.payload {
-                    Some(i)
-                } else {
-                    None
-                }
-            })
-            .collect::<Vec<_>>();
+            .find(|tx| matches!(&tx.payload, TransactionPayload::Coinbase(..)))
+            .is_some();
 
-        if coinbase_positions.len() > 0 {
+        if has_coinbase {
             // can't be
-            return None;
+            return Ok(false);
         }
 
         // find all tenure changes, even if they're not sortition-induced
@@ -653,69 +647,53 @@ impl NakamotoBlock {
             .collect::<Vec<_>>();
 
         if tenure_change_positions.len() == 0 {
-            return None;
+            return Ok(false);
         }
 
         if tenure_change_positions.len() > 1 {
             // invalid
-            debug!(
+            warn!(
                 "Invalid block -- {} tenure txs",
                 tenure_change_positions.len()
             );
-            return Some(false);
-        }
-
-        let tc_idx = 0;
-        if tenure_change_positions != vec![tc_idx] {
-            // invalid -- wrong placement
-            debug!(
-                "Invalid block -- tenure txs at {:?}, expected {:?}",
-                &tenure_change_positions,
-                &vec![tc_idx]
-            );
-            return Some(false);
+            return Err(());
         }
 
-        let TransactionPayload::TenureChange(tc_payload) = &self.txs[tc_idx].payload else {
-            // this transaction is not a tenure change
-            // (should be unreachable)
-            debug!(
-                "Invalid block -- tx at index {} is not a tenure tx",
-                &tc_idx
-            );
-            return Some(false);
+        let Some(tc_payload) = self.try_get_tenure_change_payload() else {
+            warn!("Invalid block -- tx at index 0 is not a tenure tx",);
+            return Err(());
         };
         if tc_payload.cause != TenureChangeCause::Extended {
             // not a tenure-extend, and can't be valid since all other tenure-change types require
             // a coinbase (which is not present)
-            debug!("Invalid block -- tenure tx is not a tenure extension");
-            return Some(false);
+            warn!("Invalid block -- tenure tx cause is not an extension");
+            return Err(());
         }
 
         if tc_payload.previous_tenure_end != self.header.parent_block_id {
             // discontinuous
-            debug!(
-                "Invalid block -- discontiguous: {} != {}",
-                &tc_payload.previous_tenure_end, &self.header.parent_block_id
+            warn!(
+                "Invalid block -- discontiguous";
+                "previosu_tenure_end" => %tc_payload.previous_tenure_end,
+                "parent_block_id" => %self.header.parent_block_id
             );
-            return Some(false);
+            return Err(());
         }
 
         if tc_payload.tenure_consensus_hash != self.header.consensus_hash
             || tc_payload.prev_tenure_consensus_hash != self.header.consensus_hash
         {
             // tenure-extends don't change the current miner
-            debug!(
-                "Invalid block -- expected {} = {} && {} = {}",
-                &tc_payload.tenure_consensus_hash,
-                &self.header.consensus_hash,
-                &tc_payload.prev_tenure_consensus_hash,
-                &self.header.consensus_hash
+            warn!(
+                "Invalid block -- tenure extend tx must have the same consensus hash and previous consensus hash as the block header";
+                "tenure_consensus_hash" => %tc_payload.tenure_consensus_hash,
+                "prev_tenure_consensus_hash" => %tc_payload.prev_tenure_consensus_hash,
+                "consensus_hash" => %self.header.consensus_hash,
             );
-            return Some(false);
+            return Err(());
         }
 
-        Some(true)
+        Ok(true)
     }
 
     /// Determine if this is a well-formed first block in a tenure.
@@ -724,11 +702,10 @@ impl NakamotoBlock {
     /// * It then has a Nakamoto coinbase
     /// * Coinbases and TenureChanges do not occur anywhere else
     ///
-    /// Returns Some(true) if the above are true
-    /// Returns Some(false) if this block has at least one coinbase or TenureChange tx, but one of
-    /// the above checks are false
-    /// Returns None if this block has no coinbase or TenureChange txs
-    pub fn is_wellformed_tenure_start_block(&self) -> Option<bool> {
+    /// Returns Ok(true) if the above are true
+    /// Returns Ok(false) if this is not a tenure-start block
+    /// Returns Err(()) if this block cannot be a valid block
+    pub fn is_wellformed_tenure_start_block(&self) -> Result<bool, ()> {
         // sanity check -- this may contain no coinbases or tenure-changes
         let coinbase_positions = self
             .txs
@@ -759,105 +736,100 @@ impl NakamotoBlock {
 
         if coinbase_positions.len() == 0 && tenure_change_positions.len() == 0 {
             // can't be a first block in a tenure
-            return None;
+            return Ok(false);
         }
 
         if coinbase_positions.len() > 1 || tenure_change_positions.len() > 1 {
             // never valid to have more than one of each
-            debug!(
+            warn!(
                 "Invalid block -- have {} coinbases and {} tenure txs",
                 coinbase_positions.len(),
                 tenure_change_positions.len()
             );
-            return Some(false);
+            return Err(());
         }
 
         if coinbase_positions.len() == 1 && tenure_change_positions.len() == 0 {
             // coinbase unaccompanied by a tenure change
-            debug!("Invalid block -- have coinbase without tenure change");
-            return Some(false);
+            warn!("Invalid block -- have coinbase without tenure change");
+            return Err(());
         }
 
         if coinbase_positions.len() == 0 && tenure_change_positions.len() == 1 {
             // this is possibly a block with a tenure-extend transaction.
             // It must be the first tx
-            if tenure_change_positions != vec![0] {
+            if tenure_change_positions[0] != 0 {
                 // wrong position
-                debug!(
-                    "Invalid block -- tenure change positions = {:?}, expected {:?}",
+                warn!(
+                    "Invalid block -- tenure change positions = {:?}, expected [0]",
                     &tenure_change_positions,
-                    &vec![0]
                 );
-                return Some(false);
+                return Err(());
             }
 
             // must be a non-sortition-triggered tenure change
             let TransactionPayload::TenureChange(tc_payload) = &self.txs[0].payload else {
                 // this transaction is not a tenure change
                 // (should be unreachable)
-                debug!("Invalid block -- first transaction is not a tenure change");
-                return Some(false);
+                warn!("Invalid block -- first transaction is not a tenure change");
+                return Err(());
             };
 
             if tc_payload.cause.expects_sortition() {
                 // not valid
-                debug!("Invalid block -- no coinbase, but tenure change expects sortition");
-                return Some(false);
+                warn!("Invalid block -- no coinbase, but tenure change expects sortition");
+                return Err(());
             }
 
             // not a tenure-start block, but syntactically valid w.r.t. tenure changes
-            return None;
+            return Ok(false);
         }
 
         // have both a coinbase and a tenure-change
-        let tc_idx = 0;
         let coinbase_idx = 1;
-        if coinbase_positions != vec![coinbase_idx] || tenure_change_positions != vec![tc_idx] {
+        let tc_idx = 0;
+        if coinbase_positions[0] != coinbase_idx && tenure_change_positions[0] != tc_idx {
             // invalid -- expect exactly one sortition-induced tenure change and exactly one coinbase expected,
             // and the tenure change must be the first transaction and the coinbase must be the second transaction
-            debug!("Invalid block -- coinbase and/or tenure change txs are in the wrong position -- ({:?}, {:?}) != ({:?}, {:?})", &coinbase_positions, &tenure_change_positions, &vec![coinbase_idx], &vec![tc_idx]);
-            return Some(false);
+            warn!("Invalid block -- coinbase and/or tenure change txs are in the wrong position -- ({:?}, {:?}) != [{}], [{}]", &coinbase_positions, &tenure_change_positions, coinbase_idx, tc_idx);
+            return Err(());
         }
-
-        // must be a sortition-triggered tenure change that points to our parent block
-        let TransactionPayload::TenureChange(tc_payload) = &self.txs[tc_idx].payload else {
-            // this transaction is not a tenure change
-            // (should be unreachable)
-            debug!("Invalid block -- tx index {} is not a tenure tx", tc_idx);
-            return Some(false);
+        let Some(tc_payload) = self.try_get_tenure_change_payload() else {
+            warn!("Invalid block -- tx at index 0 is not a tenure tx",);
+            return Err(());
         };
         if !tc_payload.cause.expects_sortition() {
             // the only tenure change allowed in a block with a coinbase is a sortition-triggered
             // tenure change
-            debug!("Invalid block -- tenure change does not expect a sortition");
-            return Some(false);
+            warn!("Invalid block -- tenure change does not expect a sortition");
+            return Err(());
         }
         if tc_payload.previous_tenure_end != self.header.parent_block_id {
             // discontinuous
-            debug!(
+            warn!(
                 "Invalid block -- discontiguous -- {} != {}",
                 &tc_payload.previous_tenure_end, &self.header.parent_block_id
             );
-            return Some(false);
+            return Err(());
         }
 
         // must be a Nakamoto coinbase
         let TransactionPayload::Coinbase(_, _, vrf_proof_opt) = &self.txs[coinbase_idx].payload
         else {
             // this transaction is not a coinbase (but this should be unreachable)
-            debug!(
+            warn!(
                 "Invalid block -- tx index {} is not a coinbase",
                 coinbase_idx
             );
-            return Some(false);
+            return Err(());
         };
         if vrf_proof_opt.is_none() {
             // not a Nakamoto coinbase
-            debug!("Invalid block -- no VRF proof in coinbase");
-            return Some(false);
+            warn!("Invalid block -- no VRF proof in coinbase");
+            return Err(());
         }
 
-        return Some(true);
+        return Ok(true);
     }
 
     /// Verify that the VRF seed of this block's block-commit is the hash of the parent tenure's
@@ -1123,28 +1095,28 @@ impl NakamotoBlock {
         if !StacksBlock::validate_transactions_chain_id(&self.txs, chain_id) {
             return false;
         }
-        if let Some(valid) = self.is_wellformed_tenure_start_block() {
-            if !valid {
-                // bad tenure change
-                warn!("Not a well-formed tenure-start block");
-                return false;
-            }
+        let valid_tenure_start = self.is_wellformed_tenure_start_block();
+        if valid_tenure_start == Ok(true) {
             if self.get_coinbase_tx().is_none() {
                 return false;
             }
             if self.get_tenure_change_tx_payload().is_none() {
                 return false;
             }
+        } else if valid_tenure_start.is_err() {
+            // bad tenure change
+            warn!("Not a well-formed tenure-start block");
+            return false;
         }
-        if let Some(valid) = self.is_wellformed_tenure_extend_block() {
-            if !valid {
-                // bad tenure extend
-                warn!("Not a well-formed tenure-extend block");
-                return false;
-            }
+        let valid_tenure_extend = self.is_wellformed_tenure_extend_block();
+        if valid_tenure_extend == Ok(true) {
             if self.get_tenure_extend_tx_payload().is_none() {
                 return false;
             }
+        } else if valid_tenure_extend.is_err() {
+            // bad tenure extend
+            warn!("Not a well-formed tenure-extend block");
+            return false;
         }
         if !StacksBlock::validate_transactions_static_epoch(&self.txs, epoch_id) {
             return false;
@@ -1361,17 +1333,11 @@ impl NakamotoChainState {
         }
 
         // find commit and sortition burns if this is a tenure-start block
-        let new_tenure =
-            if let Some(tenure_valid) = next_ready_block.is_wellformed_tenure_start_block() {
-                if !tenure_valid {
-                    return Err(ChainstateError::InvalidStacksBlock(
-                        "Invalid Nakamoto block: invalid tenure change tx(s)".into(),
-                    ));
-                }
-                true
-            } else {
-                false
-            };
+        let Ok(new_tenure) = next_ready_block.is_wellformed_tenure_start_block() else {
+            return Err(ChainstateError::InvalidStacksBlock(
+                "Invalid Nakamoto block: invalid tenure change tx(s)".into(),
+            ));
+        };
 
         let (commit_burn, sortition_burn) = if new_tenure {
             // find block-commit to get commit-burn
@@ -1488,13 +1454,38 @@ impl NakamotoChainState {
         sort_handle: &mut SH,
         chainstate_conn: &Connection,
         block: &NakamotoBlock,
-    ) -> Result<Option<u64>, ChainstateError> {
+    ) -> Result<u64, ChainstateError> {
+        let burn_view_ch = if let Some(tenure_payload) = block.get_tenure_tx_payload() {
+            tenure_payload.burn_view_consensus_hash
+        } else {
+            // if there's no new tenure for this block, the burn total should be the same as its parent
+            let parent = Self::get_block_header(chainstate_conn, &block.header.parent_block_id)?
+                .ok_or_else(|| {
+                    warn!("Could not load expected burns -- no parent block";
+                          "block_id" => %block.block_id(),
+                          "parent_block_id" => %block.header.parent_block_id
+                    );
+                    ChainstateError::NoSuchBlockError
+                })?;
+
+            return Ok(parent.anchored_header.total_burns());
+        };
+        let burn_view_sn =
+            SortitionDB::get_block_snapshot_consensus(sort_handle.sqlite(), &burn_view_ch)?
+                .ok_or_else(|| {
+                    warn!("Could not load expected burns -- no such burn view";
+                          "burn_view_consensus_hash" => %burn_view_ch
+                    );
+                    ChainstateError::NoSuchBlockError
+                })?;
+        Ok(burn_view_sn.total_burn)
+        /*
         let target_ch = if let Some(tenure_payload) = block.get_tenure_tx_payload() {
-            tenure_payload.sortition_consensus_hash
+            tenure_payload.burn_view_consensus_hash
         } else if let Some(highest_tenure) =
             Self::get_highest_nakamoto_tenure(chainstate_conn, sort_handle)?
         {
-            highest_tenure.sortition_consensus_hash
+            highest_tenure.burn_view_consensus_hash
         } else {
             // no nakamoto tenures yet, so this is the consensus hash of the canonical stacks tip
             let (consensus_hash, _) =
@@ -1505,11 +1496,12 @@ impl NakamotoChainState {
         let Some(sn) = SortitionDB::get_block_snapshot_consensus(sort_handle.sqlite(), &target_ch)?
         else {
             warn!("Unacceptable Nakamoto block -- no sortition for tenure";
-                  "sortition_consensus_hash" => %target_ch
+                  "burn_view_consensus_hash" => %target_ch
             );
             return Ok(None);
         };
         Ok(Some(sn.total_burn))
+        */
     }
 
     /// Validate that a Nakamoto block attaches to the burn chain state.
@@ -1690,31 +1682,26 @@ impl NakamotoChainState {
         }
 
         // if this is the first tenure block, then make sure it's well-formed
-        if let Some(false) = block.is_wellformed_tenure_start_block() {
+        block.is_wellformed_tenure_start_block().map_err(|_| {
             warn!(
                 "Block {} is not a well-formed first tenure block",
                 &block.block_id()
             );
-            return Err(ChainstateError::InvalidStacksBlock(
-                "Not a well-formed first-tenure block".into(),
-            ));
-        }
+            ChainstateError::InvalidStacksBlock("Not a well-formed first-tenure block".into())
+        })?;
 
         // if this is a tenure-extend block, then make sure it's well-formed
-        if let Some(false) = block.is_wellformed_tenure_extend_block() {
+        block.is_wellformed_tenure_extend_block().map_err(|_| {
             warn!(
                 "Block {} is not a well-formed tenure-extend block",
                 &block.block_id()
             );
-            return Err(ChainstateError::InvalidStacksBlock(
-                "Not a well-formed tenure-extend block".into(),
-            ));
-        }
+            ChainstateError::InvalidStacksBlock("Not a well-formed tenure-extend block".into())
+        })?;
 
-        let Some(expected_burn) = Self::get_expected_burns(db_handle, staging_db_tx, &block)?
-        else {
+        let Ok(expected_burn) = Self::get_expected_burns(db_handle, staging_db_tx, &block) else {
             warn!("Unacceptable Nakamoto block: unable to find its paired sortition";
-                  "block_id" => %block.block_id()
+                  "block_id" => %block.block_id(),
             );
             return Ok(false);
         };
@@ -2622,42 +2609,43 @@ impl NakamotoChainState {
             Self::check_sortition_exists(burn_dbconn, &block.header.consensus_hash)?;
         let block_hash = block.header.block_hash();
 
-        let new_tenure = if let Some(tenures_valid) = block.is_wellformed_tenure_start_block() {
-            if !tenures_valid {
+        let new_tenure = match block.is_wellformed_tenure_start_block() {
+            Ok(true) => true,
+            Ok(false) => {
+                // this block is mined in the ongoing tenure.
+                if !Self::check_tenure_continuity(
+                    chainstate_tx,
+                    burn_dbconn,
+                    &parent_ch,
+                    &block.header,
+                )? {
+                    // this block is not part of the ongoing tenure; it's invalid
+                    return Err(ChainstateError::ExpectedTenureChange);
+                }
+                false
+            }
+            Err(_) => {
                 return Err(ChainstateError::InvalidStacksBlock(
                     "Invalid tenure changes in nakamoto block".into(),
                 ));
             }
-            true
-        } else {
-            // this block is mined in the ongoing tenure.
-            if !Self::check_tenure_continuity(
-                chainstate_tx,
-                burn_dbconn,
-                &parent_ch,
-                &block.header,
-            )? {
-                // this block is not part of the ongoing tenure; it's invalid
-                return Err(ChainstateError::ExpectedTenureChange);
-            }
-
-            false
         };
 
-        let tenure_extend = if let Some(tenure_extend) = block.is_wellformed_tenure_extend_block() {
-            if !tenure_extend {
-                return Err(ChainstateError::InvalidStacksBlock(
-                    "Invalid tenure extend in nakamoto block".into(),
-                ));
+        let tenure_extend = match block.is_wellformed_tenure_extend_block() {
+            Ok(true) => {
+                if new_tenure {
+                    return Err(ChainstateError::InvalidStacksBlock(
+                        "Both started and extended tenure".into(),
+                    ));
+                }
+                true
             }
-            if new_tenure {
+            Ok(false) => false,
+            Err(_) => {
                 return Err(ChainstateError::InvalidStacksBlock(
-                    "Both started and extended tenure".into(),
+                    "Invalid tenure extend in nakamoto block".into(),
                 ));
             }
-            true
-        } else {
-            false
         };
 
         let parent_coinbase_height = if block.is_first_mined() {
@@ -2901,9 +2889,26 @@ impl NakamotoChainState {
         monitoring::set_last_block_transaction_count(u64::try_from(block.txs.len()).unwrap());
         monitoring::set_last_execution_cost_observed(&block_execution_cost, &block_limit);
 
-        // get previous burn block stats, for the transaction receipt
+        // get burn block stats, for the transaction receipt
         let (parent_burn_block_hash, parent_burn_block_height, parent_burn_block_timestamp) =
-            Self::get_tenure_burn_block_info(burn_dbconn, block.is_first_mined(), &parent_ch)?;
+            if block.is_first_mined() {
+                (BurnchainHeaderHash([0; 32]), 0, 0)
+            } else {
+                let sn = SortitionDB::get_block_snapshot_consensus(burn_dbconn, &parent_ch)?
+                    .ok_or_else(|| {
+                        // shouldn't happen
+                        warn!(
+                            "CORRUPTION: {} does not correspond to a burn block",
+                            &parent_ch
+                        );
+                        ChainstateError::InvalidStacksBlock("No parent consensus hash".into())
+                    })?;
+                (
+                    sn.burn_header_hash,
+                    sn.block_height,
+                    sn.burn_header_timestamp,
+                )
+            };
         let epoch_receipt = StacksEpochReceipt {
             header: new_tip,
             tx_receipts,
diff --git a/stackslib/src/chainstate/nakamoto/tenure.rs b/stackslib/src/chainstate/nakamoto/tenure.rs
index f4adc1c08a..8496e74fd6 100644
--- a/stackslib/src/chainstate/nakamoto/tenure.rs
+++ b/stackslib/src/chainstate/nakamoto/tenure.rs
@@ -133,7 +133,7 @@ pub static NAKAMOTO_TENURES_SCHEMA: &'static str = r#"
         -- consensus hash of the previous tenure's start-tenure block
         prev_tenure_id_consensus_hash TEXT NOT NULL,
         -- consensus hash of the last-processed sortition
-        sortition_consensus_hash TEXT NOT NULL,
+        burn_view_consensus_hash TEXT NOT NULL,
         -- whether or not this tenure was triggered by a sortition (as opposed to a tenure-extension).
         -- this is equal to the `cause` field in a TenureChange
         cause INETGER NOT NULL,
@@ -152,11 +152,11 @@ pub static NAKAMOTO_TENURES_SCHEMA: &'static str = r#"
         -- this is the ith tenure transaction in its respective Nakamoto chain history.
         tenure_index INTEGER NOT NULL,
 
-        PRIMARY KEY(sortition_consensus_hash,tenure_index)
+        PRIMARY KEY(burn_view_consensus_hash,tenure_index)
     );
     CREATE INDEX nakamoto_tenures_by_block_id ON nakamoto_tenures(block_id);
     CREATE INDEX nakamoto_tenures_by_block_and_consensus_hashes ON nakamoto_tenures(tenure_id_consensus_hash,block_hash);
-    CREATE INDEX nakamoto_tenures_by_sortition_consensus_hash ON nakamoto_tenures(sortition_consensus_hash);
+    CREATE INDEX nakamoto_tenures_by_burn_view_consensus_hash ON nakamoto_tenures(burn_view_consensus_hash);
     CREATE INDEX nakamoto_tenures_by_tenure_index ON nakamoto_tenures(tenure_index);
 "#;
 
@@ -167,7 +167,7 @@ pub struct NakamotoTenure {
     /// consensus hash of parent tenure's start-tenure block
     pub prev_tenure_id_consensus_hash: ConsensusHash,
     /// sortition tip consensus hash when this tenure was processed
-    pub sortition_consensus_hash: ConsensusHash,
+    pub burn_view_consensus_hash: ConsensusHash,
     /// the cause of this tenure -- either a new miner was chosen, or the current miner's tenure
     /// was extended
     pub cause: TenureChangeCause,
@@ -188,7 +188,7 @@ impl FromRow<NakamotoTenure> for NakamotoTenure {
     fn from_row(row: &rusqlite::Row) -> Result<NakamotoTenure, DBError> {
         let tenure_id_consensus_hash = row.get("tenure_id_consensus_hash")?;
         let prev_tenure_id_consensus_hash = row.get("prev_tenure_id_consensus_hash")?;
-        let sortition_consensus_hash = row.get("sortition_consensus_hash")?;
+        let burn_view_consensus_hash = row.get("burn_view_consensus_hash")?;
         let cause_u8: u8 = row.get("cause")?;
         let cause = TenureChangeCause::try_from(cause_u8).map_err(|_| DBError::ParseError)?;
         let block_hash = row.get("block_hash")?;
@@ -205,7 +205,7 @@ impl FromRow<NakamotoTenure> for NakamotoTenure {
         Ok(NakamotoTenure {
             tenure_id_consensus_hash,
             prev_tenure_id_consensus_hash,
-            sortition_consensus_hash,
+            burn_view_consensus_hash,
             cause,
             block_hash,
             block_id,
@@ -407,7 +407,7 @@ impl NakamotoChainState {
         let args: &[&dyn ToSql] = &[
             &tenure.tenure_consensus_hash,
             &tenure.prev_tenure_consensus_hash,
-            &tenure.sortition_consensus_hash,
+            &tenure.burn_view_consensus_hash,
             &tenure.cause.as_u8(),
             &block_header.block_hash(),
             &block_header.block_id(),
@@ -417,7 +417,7 @@ impl NakamotoChainState {
         ];
         tx.execute(
             "INSERT INTO nakamoto_tenures
-                (tenure_id_consensus_hash, prev_tenure_id_consensus_hash, sortition_consensus_hash, cause,
+                (tenure_id_consensus_hash, prev_tenure_id_consensus_hash, burn_view_consensus_hash, cause,
                 block_hash, block_id, coinbase_height, tenure_index, num_blocks_confirmed)
             VALUES
                 (?1,?2,?3,?4,?5,?6,?7,?8,?9)",
@@ -496,15 +496,14 @@ impl NakamotoChainState {
             )
             .optional()?
         {
+            Some(0) => {
+                // this never happens, so it's None
+                Ok(None)
+            }
             Some(height_i64) => {
-                if height_i64 == 0 {
-                    // this never happens, so it's None
-                    Ok(None)
-                } else {
-                    Ok(Some(
-                        height_i64.try_into().map_err(|_| DBError::ParseError)?,
-                    ))
-                }
+                Ok(Some(
+                    height_i64.try_into().map_err(|_| DBError::ParseError)?,
+                ))
             }
             None => Ok(None),
         }
@@ -544,7 +543,7 @@ impl NakamotoChainState {
                 let mut canonical = true;
                 for ch in &[
                     &tenure.tenure_id_consensus_hash,
-                    &tenure.sortition_consensus_hash,
+                    &tenure.burn_view_consensus_hash,
                 ] {
                     let Some(sn) =
                         SortitionDB::get_block_snapshot_consensus(sort_handle.sqlite(), ch)?
@@ -626,7 +625,7 @@ impl NakamotoChainState {
         let last_epoch2_tenure = NakamotoTenure {
             tenure_id_consensus_hash: parent_header.consensus_hash.clone(),
             prev_tenure_id_consensus_hash: ConsensusHash([0x00; 20]), // ignored,
-            sortition_consensus_hash: parent_header.consensus_hash.clone(),
+            burn_view_consensus_hash: parent_header.consensus_hash.clone(),
             cause: TenureChangeCause::BlockFound,
             block_hash: epoch2_header_info.block_hash(),
             block_id: StacksBlockId::new(
@@ -700,7 +699,7 @@ impl NakamotoChainState {
         };
         let Some(sortition_sn) = Self::check_valid_consensus_hash(
             sort_handle,
-            &tenure_payload.sortition_consensus_hash,
+            &tenure_payload.burn_view_consensus_hash,
         )?
         else {
             return Ok(None);
@@ -708,7 +707,7 @@ impl NakamotoChainState {
 
         // tenure_sn must be no more recent than sortition_sn
         if tenure_sn.block_height > sortition_sn.block_height {
-            warn!("Invalid tenure-change: tenure snapshot comes sortition snapshot"; "tenure_consensus_hash" => %tenure_payload.tenure_consensus_hash, "sortition_consensus_hash" => %tenure_payload.prev_tenure_consensus_hash);
+            warn!("Invalid tenure-change: tenure snapshot comes sortition snapshot"; "tenure_consensus_hash" => %tenure_payload.tenure_consensus_hash, "burn_view_consensus_hash" => %tenure_payload.prev_tenure_consensus_hash);
             return Ok(None);
         }
 
@@ -741,7 +740,7 @@ impl NakamotoChainState {
 
             if prev_sn.block_height > sortition_sn.block_height {
                 // parent comes after tip
-                warn!("Invalid tenure-change: parent snapshot comes after current tip"; "sortition_consensus_hash" => %tenure_payload.sortition_consensus_hash, "prev_tenure_consensus_hash" => %tenure_payload.prev_tenure_consensus_hash);
+                warn!("Invalid tenure-change: parent snapshot comes after current tip"; "burn_view_consensus_hash" => %tenure_payload.burn_view_consensus_hash, "prev_tenure_consensus_hash" => %tenure_payload.prev_tenure_consensus_hash);
                 return Ok(None);
             }
             if !prev_sn.sortition {
@@ -783,8 +782,8 @@ impl NakamotoChainState {
                     );
                     return Ok(None);
                 }
-                if tenure_payload.sortition_consensus_hash
-                    == highest_processed_tenure.sortition_consensus_hash
+                if tenure_payload.burn_view_consensus_hash
+                    == highest_processed_tenure.burn_view_consensus_hash
                 {
                     // if we're extending tenure within the same sortition, then the tenure and
                     // prev_tenure consensus hashes must match that of the highest.
@@ -1043,34 +1042,6 @@ impl NakamotoChainState {
         ))
     }
 
-    /// Get the burnchain block info of a given tenure's consensus hash.
-    /// Used for the tx receipt.
-    pub(crate) fn get_tenure_burn_block_info(
-        burn_dbconn: &Connection,
-        first_mined: bool,
-        ch: &ConsensusHash,
-    ) -> Result<(BurnchainHeaderHash, u64, u64), ChainstateError> {
-        // get burn block stats, for the transaction receipt
-        let (burn_block_hash, burn_block_height, burn_block_timestamp) = if first_mined {
-            (BurnchainHeaderHash([0; 32]), 0, 0)
-        } else {
-            match SortitionDB::get_block_snapshot_consensus(burn_dbconn, ch)? {
-                Some(sn) => (
-                    sn.burn_header_hash,
-                    sn.block_height,
-                    sn.burn_header_timestamp,
-                ),
-                None => {
-                    // shouldn't happen
-                    warn!("CORRUPTION: {} does not correspond to a burn block", ch,);
-                    (BurnchainHeaderHash([0; 32]), 0, 0)
-                }
-            }
-        };
-
-        Ok((burn_block_hash, burn_block_height, burn_block_timestamp))
-    }
-
     /// Check that a given Nakamoto block's tenure's sortition exists and was processed.
     /// Return the sortition's burnchain block's hash and its burnchain height
     pub(crate) fn check_sortition_exists(
diff --git a/stackslib/src/chainstate/nakamoto/tests/mod.rs b/stackslib/src/chainstate/nakamoto/tests/mod.rs
index c2bec8d9a1..8731258938 100644
--- a/stackslib/src/chainstate/nakamoto/tests/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/mod.rs
@@ -159,7 +159,7 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
     let tenure_change_payload = TenureChangePayload {
         tenure_consensus_hash: ConsensusHash([0x04; 20]),
         prev_tenure_consensus_hash: ConsensusHash([0x03; 20]),
-        sortition_consensus_hash: ConsensusHash([0x04; 20]),
+        burn_view_consensus_hash: ConsensusHash([0x04; 20]),
         previous_tenure_end: header.parent_block_id.clone(),
         previous_tenure_blocks: 1,
         cause: TenureChangeCause::BlockFound,
@@ -172,7 +172,7 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
     let tenure_extend_payload = TenureChangePayload {
         tenure_consensus_hash: ConsensusHash([0x04; 20]),
         prev_tenure_consensus_hash: ConsensusHash([0x04; 20]),
-        sortition_consensus_hash: ConsensusHash([0x04; 20]),
+        burn_view_consensus_hash: ConsensusHash([0x04; 20]),
         previous_tenure_end: header.parent_block_id.clone(),
         previous_tenure_blocks: 1,
         cause: TenureChangeCause::Extended,
@@ -185,7 +185,7 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
         // bad parent block ID
         tenure_consensus_hash: ConsensusHash([0x04; 20]),
         prev_tenure_consensus_hash: ConsensusHash([0x03; 20]),
-        sortition_consensus_hash: ConsensusHash([0x04; 20]),
+        burn_view_consensus_hash: ConsensusHash([0x04; 20]),
         previous_tenure_end: StacksBlockId([0x00; 32]),
         previous_tenure_blocks: 1,
         cause: TenureChangeCause::BlockFound,
@@ -263,7 +263,7 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
         header: header.clone(),
         txs: vec![],
     };
-    assert_eq!(block.is_wellformed_tenure_start_block(), None);
+    assert_eq!(block.is_wellformed_tenure_start_block(), Ok(false));
     assert_eq!(block.get_coinbase_tx(), None);
     assert_eq!(block.get_vrf_proof(), None);
     assert_eq!(
@@ -276,8 +276,8 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
         header: header.clone(),
         txs: vec![tenure_change_tx.clone()],
     };
-    assert_eq!(block.is_wellformed_tenure_start_block(), Some(false));
-    assert_eq!(block.is_wellformed_tenure_extend_block(), Some(false));
+    assert_eq!(block.is_wellformed_tenure_start_block(), Err(()));
+    assert_eq!(block.is_wellformed_tenure_extend_block(), Err(()));
     assert_eq!(block.get_coinbase_tx(), None);
     assert_eq!(block.get_tenure_change_tx_payload(), None);
     assert_eq!(block.get_tenure_extend_tx_payload(), None);
@@ -292,8 +292,8 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
         header: header.clone(),
         txs: vec![coinbase_tx.clone()],
     };
-    assert_eq!(block.is_wellformed_tenure_start_block(), Some(false));
-    assert_eq!(block.is_wellformed_tenure_extend_block(), None);
+    assert_eq!(block.is_wellformed_tenure_start_block(), Err(()));
+    assert_eq!(block.is_wellformed_tenure_extend_block(), Ok(false));
     assert_eq!(block.get_coinbase_tx(), None);
     assert_eq!(block.get_tenure_change_tx_payload(), None);
     assert_eq!(block.get_tenure_extend_tx_payload(), None);
@@ -309,8 +309,8 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
         header: header.clone(),
         txs: vec![tenure_change_tx.clone(), invalid_coinbase_tx.clone()],
     };
-    assert_eq!(block.is_wellformed_tenure_start_block(), Some(false));
-    assert_eq!(block.is_wellformed_tenure_extend_block(), None);
+    assert_eq!(block.is_wellformed_tenure_start_block(), Err(()));
+    assert_eq!(block.is_wellformed_tenure_extend_block(), Ok(false));
     assert_eq!(block.get_coinbase_tx(), None);
     assert_eq!(block.get_tenure_change_tx_payload(), None);
     assert_eq!(block.get_tenure_extend_tx_payload(), None);
@@ -329,8 +329,8 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
             coinbase_tx.clone(),
         ],
     };
-    assert_eq!(block.is_wellformed_tenure_start_block(), Some(false));
-    assert_eq!(block.is_wellformed_tenure_extend_block(), None);
+    assert_eq!(block.is_wellformed_tenure_start_block(), Err(()));
+    assert_eq!(block.is_wellformed_tenure_extend_block(), Ok(false));
     assert_eq!(block.get_coinbase_tx(), None);
     assert_eq!(block.get_tenure_change_tx_payload(), None);
     assert_eq!(block.get_tenure_extend_tx_payload(), None);
@@ -345,8 +345,8 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
         header: header.clone(),
         txs: vec![coinbase_tx.clone(), tenure_change_tx.clone()],
     };
-    assert_eq!(block.is_wellformed_tenure_start_block(), Some(false));
-    assert_eq!(block.is_wellformed_tenure_extend_block(), None);
+    assert_eq!(block.is_wellformed_tenure_start_block(), Err(()));
+    assert_eq!(block.is_wellformed_tenure_extend_block(), Ok(false));
     assert_eq!(block.get_coinbase_tx(), None);
     assert_eq!(block.get_tenure_change_tx_payload(), None);
     assert_eq!(block.get_tenure_extend_tx_payload(), None);
@@ -365,8 +365,8 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
             tenure_change_tx.clone(),
         ],
     };
-    assert_eq!(block.is_wellformed_tenure_start_block(), Some(false));
-    assert_eq!(block.is_wellformed_tenure_extend_block(), None);
+    assert_eq!(block.is_wellformed_tenure_start_block(), Err(()));
+    assert_eq!(block.is_wellformed_tenure_extend_block(), Ok(false));
     assert_eq!(block.get_coinbase_tx(), None);
     assert_eq!(block.get_tenure_change_tx_payload(), None);
     assert_eq!(block.get_tenure_extend_tx_payload(), None);
@@ -385,8 +385,8 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
             coinbase_tx.clone(),
         ],
     };
-    assert_eq!(block.is_wellformed_tenure_start_block(), Some(false));
-    assert_eq!(block.is_wellformed_tenure_extend_block(), None);
+    assert_eq!(block.is_wellformed_tenure_start_block(), Err(()));
+    assert_eq!(block.is_wellformed_tenure_extend_block(), Ok(false));
     assert_eq!(block.get_coinbase_tx(), None);
     assert_eq!(block.get_tenure_change_tx_payload(), None);
     assert_eq!(block.get_tenure_extend_tx_payload(), None);
@@ -402,8 +402,8 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
         header: header.clone(),
         txs: vec![tenure_change_tx.clone(), coinbase_tx.clone()],
     };
-    assert_eq!(block.is_wellformed_tenure_start_block(), Some(true));
-    assert_eq!(block.is_wellformed_tenure_extend_block(), None);
+    assert_eq!(block.is_wellformed_tenure_start_block(), Ok(true));
+    assert_eq!(block.is_wellformed_tenure_extend_block(), Ok(false));
     assert_eq!(block.get_coinbase_tx(), Some(&coinbase_tx));
     assert_eq!(
         block.get_tenure_change_tx_payload(),
@@ -422,8 +422,8 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
         header: header.clone(),
         txs: vec![tenure_extend_tx.clone()],
     };
-    assert_eq!(block.is_wellformed_tenure_start_block(), None);
-    assert_eq!(block.is_wellformed_tenure_extend_block(), Some(true));
+    assert_eq!(block.is_wellformed_tenure_start_block(), Ok(false));
+    assert_eq!(block.is_wellformed_tenure_extend_block(), Ok(true));
     assert_eq!(block.get_coinbase_tx(), None);
     assert_eq!(block.get_tenure_change_tx_payload(), None);
     assert_eq!(
@@ -442,8 +442,8 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
         header: header.clone(),
         txs: vec![tenure_extend_tx.clone(), stx_transfer.clone()],
     };
-    assert_eq!(block.is_wellformed_tenure_start_block(), None);
-    assert_eq!(block.is_wellformed_tenure_extend_block(), Some(true));
+    assert_eq!(block.is_wellformed_tenure_start_block(), Ok(false));
+    assert_eq!(block.is_wellformed_tenure_extend_block(), Ok(true));
     assert_eq!(block.get_coinbase_tx(), None);
     assert_eq!(block.get_tenure_change_tx_payload(), None);
     assert_eq!(
@@ -461,8 +461,8 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
         header: header.clone(),
         txs: vec![tenure_extend_tx.clone(), tenure_extend_tx.clone()],
     };
-    assert_eq!(block.is_wellformed_tenure_start_block(), Some(false));
-    assert_eq!(block.is_wellformed_tenure_extend_block(), Some(false));
+    assert_eq!(block.is_wellformed_tenure_start_block(), Err(()));
+    assert_eq!(block.is_wellformed_tenure_extend_block(), Err(()));
     assert_eq!(block.get_coinbase_tx(), None);
     assert_eq!(block.get_tenure_change_tx_payload(), None);
     assert_eq!(block.get_tenure_extend_tx_payload(), None);
@@ -477,8 +477,8 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
         header: header.clone(),
         txs: vec![stx_transfer.clone(), tenure_extend_tx.clone()],
     };
-    assert_eq!(block.is_wellformed_tenure_start_block(), Some(false));
-    assert_eq!(block.is_wellformed_tenure_extend_block(), Some(false));
+    assert_eq!(block.is_wellformed_tenure_start_block(), Err(()));
+    assert_eq!(block.is_wellformed_tenure_extend_block(), Err(()));
     assert_eq!(block.get_coinbase_tx(), None);
     assert_eq!(block.get_tenure_change_tx_payload(), None);
     assert_eq!(block.get_tenure_extend_tx_payload(), None);
@@ -497,8 +497,8 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
             coinbase_tx.clone(),
         ],
     };
-    assert_eq!(block.is_wellformed_tenure_start_block(), Some(false));
-    assert_eq!(block.is_wellformed_tenure_extend_block(), None);
+    assert_eq!(block.is_wellformed_tenure_start_block(), Err(()));
+    assert_eq!(block.is_wellformed_tenure_extend_block(), Ok(false));
     assert_eq!(block.get_coinbase_tx(), None);
     assert_eq!(block.get_tenure_change_tx_payload(), None);
     assert_eq!(block.get_tenure_extend_tx_payload(), None);
@@ -600,7 +600,7 @@ pub fn test_load_store_update_nakamoto_blocks() {
     let tenure_change_payload = TenureChangePayload {
         tenure_consensus_hash: ConsensusHash([0x04; 20]), // same as in nakamoto header
         prev_tenure_consensus_hash: ConsensusHash([0x01; 20]),
-        sortition_consensus_hash: ConsensusHash([0x04; 20]),
+        burn_view_consensus_hash: ConsensusHash([0x04; 20]),
         previous_tenure_end: epoch2_parent_block_id.clone(),
         previous_tenure_blocks: 1,
         cause: TenureChangeCause::BlockFound,
@@ -736,7 +736,7 @@ pub fn test_load_store_update_nakamoto_blocks() {
     let nakamoto_tenure = NakamotoTenure {
         tenure_id_consensus_hash: tenure_change_payload.tenure_consensus_hash.clone(),
         prev_tenure_id_consensus_hash: tenure_change_payload.prev_tenure_consensus_hash.clone(),
-        sortition_consensus_hash: tenure_change_payload.sortition_consensus_hash.clone(),
+        burn_view_consensus_hash: tenure_change_payload.burn_view_consensus_hash.clone(),
         cause: tenure_change_payload.cause,
         block_hash: nakamoto_block.header.block_hash(),
         block_id: nakamoto_block.header.block_id(),
@@ -1253,7 +1253,7 @@ fn test_nakamoto_block_static_verification() {
     let tenure_change_payload = TenureChangePayload {
         tenure_consensus_hash: ConsensusHash([0x04; 20]), // same as in nakamoto header
         prev_tenure_consensus_hash: ConsensusHash([0x01; 20]),
-        sortition_consensus_hash: ConsensusHash([0x04; 20]),
+        burn_view_consensus_hash: ConsensusHash([0x04; 20]),
         previous_tenure_end: StacksBlockId([0x03; 32]),
         previous_tenure_blocks: 1,
         cause: TenureChangeCause::BlockFound,
@@ -1265,7 +1265,7 @@ fn test_nakamoto_block_static_verification() {
     let tenure_change_payload_bad_ch = TenureChangePayload {
         tenure_consensus_hash: ConsensusHash([0x05; 20]), // wrong
         prev_tenure_consensus_hash: ConsensusHash([0x01; 20]),
-        sortition_consensus_hash: ConsensusHash([0x04; 20]),
+        burn_view_consensus_hash: ConsensusHash([0x04; 20]),
         previous_tenure_end: StacksBlockId([0x03; 32]),
         previous_tenure_blocks: 1,
         cause: TenureChangeCause::BlockFound,
@@ -1277,7 +1277,7 @@ fn test_nakamoto_block_static_verification() {
     let tenure_change_payload_bad_miner_sig = TenureChangePayload {
         tenure_consensus_hash: ConsensusHash([0x04; 20]), // same as in nakamoto header
         prev_tenure_consensus_hash: ConsensusHash([0x01; 20]),
-        sortition_consensus_hash: ConsensusHash([0x04; 20]),
+        burn_view_consensus_hash: ConsensusHash([0x04; 20]),
         previous_tenure_end: StacksBlockId([0x03; 32]),
         previous_tenure_blocks: 1,
         cause: TenureChangeCause::BlockFound,
@@ -1476,7 +1476,7 @@ pub fn test_get_highest_nakamoto_tenure() {
                 .as_ref()
                 .map(|tc| tc.tenure_consensus_hash.clone())
                 .unwrap_or(FIRST_BURNCHAIN_CONSENSUS_HASH.clone()),
-            sortition_consensus_hash: sn.consensus_hash.clone(),
+            burn_view_consensus_hash: sn.consensus_hash.clone(),
             previous_tenure_end: block_header.block_id(),
             previous_tenure_blocks: 1,
             cause: TenureChangeCause::BlockFound,
@@ -1524,8 +1524,8 @@ pub fn test_get_highest_nakamoto_tenure() {
         last_tenure_change.prev_tenure_consensus_hash
     );
     assert_eq!(
-        highest_tenure.sortition_consensus_hash,
-        last_tenure_change.sortition_consensus_hash
+        highest_tenure.burn_view_consensus_hash,
+        last_tenure_change.burn_view_consensus_hash
     );
     assert_eq!(highest_tenure.cause, last_tenure_change.cause);
     assert_eq!(highest_tenure.block_hash, last_header.block_hash());
@@ -1559,8 +1559,8 @@ pub fn test_get_highest_nakamoto_tenure() {
         last_tenure_change.prev_tenure_consensus_hash
     );
     assert_eq!(
-        highest_tenure.sortition_consensus_hash,
-        last_tenure_change.sortition_consensus_hash
+        highest_tenure.burn_view_consensus_hash,
+        last_tenure_change.burn_view_consensus_hash
     );
     assert_eq!(highest_tenure.cause, last_tenure_change.cause);
     assert_eq!(highest_tenure.block_hash, last_header.block_hash());
diff --git a/stackslib/src/chainstate/nakamoto/tests/node.rs b/stackslib/src/chainstate/nakamoto/tests/node.rs
index ca901d0181..73ef55c360 100644
--- a/stackslib/src/chainstate/nakamoto/tests/node.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/node.rs
@@ -471,7 +471,7 @@ impl TestStacksNode {
         let tenure_change_payload = TenureChangePayload {
             tenure_consensus_hash: ConsensusHash([0x00; 20]), // will be overwritten
             prev_tenure_consensus_hash: previous_tenure_consensus_hash,
-            sortition_consensus_hash: ConsensusHash([0x00; 20]), // will be overwritten
+            burn_view_consensus_hash: ConsensusHash([0x00; 20]), // will be overwritten
             previous_tenure_end,
             previous_tenure_blocks,
             cause: tenure_change_cause,
diff --git a/stackslib/src/chainstate/stacks/block.rs b/stackslib/src/chainstate/stacks/block.rs
index 2a59312a60..8de0eb75e4 100644
--- a/stackslib/src/chainstate/stacks/block.rs
+++ b/stackslib/src/chainstate/stacks/block.rs
@@ -1784,7 +1784,7 @@ mod test {
         let tenure_change_payload = TenureChangePayload {
             tenure_consensus_hash: ConsensusHash([0x01; 20]),
             prev_tenure_consensus_hash: ConsensusHash([0x02; 20]),
-            sortition_consensus_hash: ConsensusHash([0x03; 20]),
+            burn_view_consensus_hash: ConsensusHash([0x03; 20]),
             previous_tenure_end: StacksBlockId([0x00; 32]),
             previous_tenure_blocks: 0,
             cause: TenureChangeCause::BlockFound,
diff --git a/stackslib/src/chainstate/stacks/db/mod.rs b/stackslib/src/chainstate/stacks/db/mod.rs
index 16593424fa..d1cb81c6db 100644
--- a/stackslib/src/chainstate/stacks/db/mod.rs
+++ b/stackslib/src/chainstate/stacks/db/mod.rs
@@ -325,6 +325,14 @@ impl StacksBlockHeaderTypes {
         }
     }
 
+    /// Get the total spend by miners for this block
+    pub fn total_burns(&self) -> u64 {
+        match self {
+            StacksBlockHeaderTypes::Epoch2(x) => x.total_work.burn,
+            StacksBlockHeaderTypes::Nakamoto(x) => x.burn_spent,
+        }
+    }
+
     pub fn as_stacks_epoch2(&self) -> Option<&StacksBlockHeader> {
         match &self {
             StacksBlockHeaderTypes::Epoch2(ref x) => Some(x),
diff --git a/stackslib/src/chainstate/stacks/mod.rs b/stackslib/src/chainstate/stacks/mod.rs
index 3cf46ad833..eec991157a 100644
--- a/stackslib/src/chainstate/stacks/mod.rs
+++ b/stackslib/src/chainstate/stacks/mod.rs
@@ -706,7 +706,7 @@ pub struct TenureChangePayload {
     pub prev_tenure_consensus_hash: ConsensusHash,
     /// Current consensus hash on the underlying burnchain.  Corresponds to the last-seen
     /// sortition.
-    pub sortition_consensus_hash: ConsensusHash,
+    pub burn_view_consensus_hash: ConsensusHash,
     /// The StacksBlockId of the last block from the previous tenure
     pub previous_tenure_end: StacksBlockId,
     /// The number of blocks produced since the last sortition-linked tenure
@@ -724,14 +724,14 @@ pub struct TenureChangePayload {
 impl TenureChangePayload {
     pub fn extend(
         &self,
-        sortition_consensus_hash: ConsensusHash,
+        burn_view_consensus_hash: ConsensusHash,
         last_tenure_block_id: StacksBlockId,
         num_blocks_so_far: u32,
     ) -> Self {
         TenureChangePayload {
             tenure_consensus_hash: self.tenure_consensus_hash.clone(),
             prev_tenure_consensus_hash: self.tenure_consensus_hash.clone(),
-            sortition_consensus_hash,
+            burn_view_consensus_hash,
             previous_tenure_end: last_tenure_block_id,
             previous_tenure_blocks: num_blocks_so_far,
             cause: TenureChangeCause::Extended,
@@ -1379,7 +1379,7 @@ pub mod test {
             TransactionPayload::TenureChange(TenureChangePayload {
                 tenure_consensus_hash: ConsensusHash([0x01; 20]),
                 prev_tenure_consensus_hash: ConsensusHash([0x02; 20]),
-                sortition_consensus_hash: ConsensusHash([0x03; 20]),
+                burn_view_consensus_hash: ConsensusHash([0x03; 20]),
                 previous_tenure_end: StacksBlockId([0x00; 32]),
                 previous_tenure_blocks: 0,
                 cause: TenureChangeCause::BlockFound,
diff --git a/stackslib/src/chainstate/stacks/transaction.rs b/stackslib/src/chainstate/stacks/transaction.rs
index f0aee804f4..ff9efc7724 100644
--- a/stackslib/src/chainstate/stacks/transaction.rs
+++ b/stackslib/src/chainstate/stacks/transaction.rs
@@ -196,7 +196,7 @@ impl StacksMessageCodec for TenureChangePayload {
     fn consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), codec_error> {
         write_next(fd, &self.tenure_consensus_hash)?;
         write_next(fd, &self.prev_tenure_consensus_hash)?;
-        write_next(fd, &self.sortition_consensus_hash)?;
+        write_next(fd, &self.burn_view_consensus_hash)?;
         write_next(fd, &self.previous_tenure_end)?;
         write_next(fd, &self.previous_tenure_blocks)?;
         write_next(fd, &self.cause)?;
@@ -209,7 +209,7 @@ impl StacksMessageCodec for TenureChangePayload {
         Ok(Self {
             tenure_consensus_hash: read_next(fd)?,
             prev_tenure_consensus_hash: read_next(fd)?,
-            sortition_consensus_hash: read_next(fd)?,
+            burn_view_consensus_hash: read_next(fd)?,
             previous_tenure_end: read_next(fd)?,
             previous_tenure_blocks: read_next(fd)?,
             cause: read_next(fd)?,
@@ -3776,7 +3776,7 @@ mod test {
             TransactionPayload::TenureChange(TenureChangePayload {
                 tenure_consensus_hash: ConsensusHash([0x01; 20]),
                 prev_tenure_consensus_hash: ConsensusHash([0x02; 20]),
-                sortition_consensus_hash: ConsensusHash([0x03; 20]),
+                burn_view_consensus_hash: ConsensusHash([0x03; 20]),
                 previous_tenure_end: StacksBlockId([0x00; 32]),
                 previous_tenure_blocks: 0,
                 cause: TenureChangeCause::BlockFound,
diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index 9b43142c53..6c5e7ca878 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -65,7 +65,7 @@ use stacks_common::types::chainstate::{
 };
 use stacks_common::types::{PrivateKey, StacksEpochId};
 use stacks_common::util::hash::{Hash160, MerkleTree, Sha512Trunc256Sum};
-use stacks_common::util::secp256k1::{MessageSignature, SchnorrSignature, Secp256k1PublicKey};
+use stacks_common::util::secp256k1::{MessageSignature, Secp256k1PublicKey};
 use stacks_common::util::vrf::{VRFPrivateKey, VRFProof, VRFPublicKey, VRF};
 
 use self::signer::SelfSigner;
@@ -781,8 +781,9 @@ impl MockamotoNode {
         // If mockamoto mode changes to support non-tenure-changing blocks, this will have
         //  to be gated.
         let tenure_change_tx_payload = TransactionPayload::TenureChange(TenureChangePayload {
-            consensus_hash: sortition_tip.consensus_hash,
-            prev_consensus_hash: chain_tip_ch.clone(),
+            tenure_consensus_hash: sortition_tip.consensus_hash.clone(),
+            prev_tenure_consensus_hash: chain_tip_ch.clone(),
+            sortition_consensus_hash: sortition_tip.consensus_hash,
             previous_tenure_end: parent_block_id,
             previous_tenure_blocks: 1,
             cause: TenureChangeCause::BlockFound,
@@ -862,6 +863,7 @@ impl MockamotoNode {
             })?,
             true,
             parent_chain_length + 1,
+            false,
         )?;
 
         let txs = vec![tenure_tx, coinbase_tx, stacks_stx_tx];
@@ -890,6 +892,7 @@ impl MockamotoNode {
             &mut self.mempool,
             parent_chain_length,
             None,
+            None,
             BlockBuilderSettings {
                 max_miner_time_ms: 15_000,
                 mempool_settings: MemPoolWalkSettings::default(),
@@ -935,7 +938,7 @@ impl MockamotoNode {
                 burn_spent: sortition_tip.total_burn,
                 tx_merkle_root: tx_merkle_tree.root(),
                 state_index_root,
-                signer_signature: SchnorrSignature::default(),
+                signer_signature: ThresholdSignature::mock(),
                 miner_signature: MessageSignature::empty(),
                 consensus_hash: sortition_tip.consensus_hash.clone(),
                 parent_block_id: StacksBlockId::new(&chain_tip_ch, &chain_tip_bh),
@@ -957,14 +960,14 @@ impl MockamotoNode {
         let mut block = self.mine_stacks_block()?;
         let config = self.chainstate.config();
         let chain_length = block.header.chain_length;
-        let sortition_handle = self.sortdb.index_handle_at_tip();
+        let mut sortition_handle = self.sortdb.index_handle_at_tip();
         let aggregate_public_key = self.self_signer.aggregate_public_key;
         self.self_signer.sign_nakamoto_block(&mut block);
         let staging_tx = self.chainstate.staging_db_tx_begin()?;
         NakamotoChainState::accept_block(
             &config,
             block,
-            &sortition_handle,
+            &mut sortition_handle,
             &staging_tx,
             &aggregate_public_key,
         )?;
diff --git a/testnet/stacks-node/src/mockamoto/signer.rs b/testnet/stacks-node/src/mockamoto/signer.rs
index c95651bf39..c0d4af0b69 100644
--- a/testnet/stacks-node/src/mockamoto/signer.rs
+++ b/testnet/stacks-node/src/mockamoto/signer.rs
@@ -1,5 +1,5 @@
 use stacks::chainstate::nakamoto::NakamotoBlock;
-use stacks_common::util::secp256k1::SchnorrSignature;
+use stacks::chainstate::stacks::ThresholdSignature;
 use wsts::curve::point::Point;
 use wsts::traits::Aggregator;
 
@@ -70,7 +70,6 @@ impl SelfSigner {
         let signature = sig_aggregator
             .sign(msg.as_slice(), &nonces, &sig_shares, &key_ids)
             .expect("aggregator sig failed");
-        let schnorr_signature = SchnorrSignature::from(&signature);
-        block.header.signer_signature = schnorr_signature;
+        block.header.signer_signature = ThresholdSignature(signature);
     }
 }

From 67e4f309e4585a583c47feb67d4145b8eb632084 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Fri, 8 Dec 2023 17:17:38 -0600
Subject: [PATCH 0127/1166] test: fix httpcore test for defaulting in proof
 query string

---
 stackslib/src/net/tests/httpcore.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stackslib/src/net/tests/httpcore.rs b/stackslib/src/net/tests/httpcore.rs
index 8cd42f45b7..d10ba9a231 100644
--- a/stackslib/src/net/tests/httpcore.rs
+++ b/stackslib/src/net/tests/httpcore.rs
@@ -1012,7 +1012,7 @@ fn test_http_parse_proof_request_query() {
     let proof_req = HttpRequestContents::new()
         .query_string(Some(query_txt))
         .get_with_proof();
-    assert!(!proof_req);
+    assert!(proof_req);
 
     let query_txt = "proof=0";
     let proof_req = HttpRequestContents::new()

From 5387f44bbebbd7d1f3a97dbbfc05e0e755735a01 Mon Sep 17 00:00:00 2001
From: ASuciuX <asuciu@hiro.so>
Date: Mon, 11 Dec 2023 13:53:42 +0200
Subject: [PATCH 0128/1166] feat: restructure mutants to new CI workflows

---
 .github/workflows/ci.yml                      |   27 +-
 .github/workflows/filter-pr-mutants.yml       |   15 +
 .github/workflows/logger-mutants.yml          |   30 +
 .github/workflows/mutants.yml                 |  185 --
 .../packages-output/clarity/caught.txt        |  487 -----
 .../packages-output/clarity/missed.txt        |  634 ------
 .../packages-output/clarity/timeout.txt       |    0
 .../packages-output/clarity/unviable.txt      | 1791 -----------------
 .../packages-output/pox-locking/caught.txt    |    0
 .../packages-output/pox-locking/missed.txt    |   28 -
 .../packages-output/pox-locking/timeout.txt   |    0
 .../packages-output/pox-locking/unviable.txt  |   22 -
 .../packages-output/stx-genesis/caught.txt    |    1 -
 .../packages-output/stx-genesis/missed.txt    |    1 -
 .../packages-output/stx-genesis/timeout.txt   |    0
 .../packages-output/stx-genesis/unviable.txt  |   11 -
 mutation-testing/scripts/README.md            |   38 -
 .../scripts/append-match-package.sh           |   68 -
 mutation-testing/scripts/create-stable.sh     |   55 -
 mutation-testing/scripts/git-diff.sh          |   35 -
 .../scripts/modular-mutants-run.sh            |   41 -
 mutation-testing/testing.md                   |   65 -
 22 files changed, 46 insertions(+), 3488 deletions(-)
 create mode 100644 .github/workflows/filter-pr-mutants.yml
 create mode 100644 .github/workflows/logger-mutants.yml
 delete mode 100644 .github/workflows/mutants.yml
 delete mode 100644 mutation-testing/packages-output/clarity/caught.txt
 delete mode 100644 mutation-testing/packages-output/clarity/missed.txt
 delete mode 100644 mutation-testing/packages-output/clarity/timeout.txt
 delete mode 100644 mutation-testing/packages-output/clarity/unviable.txt
 delete mode 100644 mutation-testing/packages-output/pox-locking/caught.txt
 delete mode 100644 mutation-testing/packages-output/pox-locking/missed.txt
 delete mode 100644 mutation-testing/packages-output/pox-locking/timeout.txt
 delete mode 100644 mutation-testing/packages-output/pox-locking/unviable.txt
 delete mode 100644 mutation-testing/packages-output/stx-genesis/caught.txt
 delete mode 100644 mutation-testing/packages-output/stx-genesis/missed.txt
 delete mode 100644 mutation-testing/packages-output/stx-genesis/timeout.txt
 delete mode 100644 mutation-testing/packages-output/stx-genesis/unviable.txt
 delete mode 100644 mutation-testing/scripts/README.md
 delete mode 100644 mutation-testing/scripts/append-match-package.sh
 delete mode 100644 mutation-testing/scripts/create-stable.sh
 delete mode 100755 mutation-testing/scripts/git-diff.sh
 delete mode 100644 mutation-testing/scripts/modular-mutants-run.sh
 delete mode 100644 mutation-testing/testing.md

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 4252e729f9..cfc0b7c71e 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -13,7 +13,7 @@ on:
   workflow_dispatch:
     inputs:
       tag:
-        description: 'The tag to create (optional)'
+        description: "The tag to create (optional)"
         required: false
 
 concurrency:
@@ -75,31 +75,6 @@ jobs:
           base: ${{ env.BRANCH_NAME }}
           head: HEAD
 
-  ## Mutants testing: Execute on PR on packages that have tested functions modified
-  incremental-mutants:
-    name: Incremental Mutants Testing
-    runs-on: ubuntu-latest
-    if: github.event_name == 'pull_request'
-    steps:
-      - uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-      - name: Relative diff
-        run: |
-          git branch -av
-          git diff origin/${{ github.base_ref }}.. | tee git.diff
-      - uses: Swatinem/rust-cache@v2
-      - run: cargo install cargo-mutants
-      - name: Mutants
-        run: |
-          cargo mutants --no-shuffle -j 2 -vV --in-diff git.diff || true
-      - name: Archive mutants.out
-        uses: actions/upload-artifact@v3
-        if: always()
-        with:
-          name: mutants-incremental.out
-          path: mutants.out
-
   ###############################################
   ## Build Tagged Release
   ###############################################
diff --git a/.github/workflows/filter-pr-mutants.yml b/.github/workflows/filter-pr-mutants.yml
new file mode 100644
index 0000000000..226eab14df
--- /dev/null
+++ b/.github/workflows/filter-pr-mutants.yml
@@ -0,0 +1,15 @@
+name: Tracking PR Mutants
+
+on:
+  pull_request:
+
+jobs:
+  # Mutants testing: Execute on PR on packages that have functions modified, and fail the workflow if there are missed or timeout mutations
+  incremental-mutants:
+    name: Incremental Mutants Testing
+
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Run filtering pr mutants from actions
+        uses: ASuciuX/actions/mutation-testing/filter-pr@feat/mutation-testing
diff --git a/.github/workflows/logger-mutants.yml b/.github/workflows/logger-mutants.yml
new file mode 100644
index 0000000000..6bfd0c2c21
--- /dev/null
+++ b/.github/workflows/logger-mutants.yml
@@ -0,0 +1,30 @@
+name: Logging Mutants
+
+# only run on push in order to update the cache output
+# flow:
+# restore cache
+# install cargo-mutants crate in order to run the 'cargo mutants' command
+# create a file with the current commit hash if a previous one doesn't exist, then print it
+# run the script that handles the 'cargo mutants' command on the differences between the latest updates and the last commit where it was ran
+# overwrite the previous commit hash with the current one for the following run
+# delete the old cache
+# save the new cache with the updated mutants
+# upload artifact to easily check it for the given commit
+
+on:
+  push:
+    branches:
+      - master
+      - develop
+      - next
+
+jobs:
+  save_cache:
+    runs-on: ubuntu-latest
+
+    # test
+    steps:
+      - name: Run logging mutants from actions
+        uses: ASuciuX/actions/mutation-testing/logger@feat/mutation-testing
+        with:
+          gh-token: ${{ secrets.GITHUB_TOKEN }}
diff --git a/.github/workflows/mutants.yml b/.github/workflows/mutants.yml
deleted file mode 100644
index 094dd4e7af..0000000000
--- a/.github/workflows/mutants.yml
+++ /dev/null
@@ -1,185 +0,0 @@
-name: Mutants
-# to be tried cache vs artifacts
-
-# only run on push in order to update the artifact output
-# flow:
-# download artifact
-# run sh script for cargo mutants diff
-# upload artifact/cache
-
-on:
-  push:
-    branches:
-      - master
-      - develop
-      - next
-      - deployer/testing-shell-script
-
-### commented functions in order to not run them on every push
-jobs:
-  # cache_mutants:
-  #   runs-on: ubuntu-latest
-
-  #   steps:
-  #     - name: Checkout the latest code
-  #       id: git_checkout
-  #       uses: actions/checkout@v3
-  #     - name: Cache mutants-initial folder
-  #       uses: actions/cache@v3
-  #       with:
-  #         path: mutants-initial
-  #         key: mutants-initial
-  #     - name: Print caught mutants
-  #       run: cat mutants-initial/caught.txt
-  #     - name: Print missed mutants
-  #       run: cat mutants-initial/missed.txt
-  #     - name: Print unviable mutants
-  #       run: cat mutants-initial/unviable.txt
-  #     - name: Print timeout mutants
-  #       run: cat mutants-initial/timeout.txt
-
-  # Upload cache stable output version
-  # cache_mutants_output:
-  #   runs-on: ubuntu-latest
-
-  #   steps:
-  #     - name: Checkout the latest code
-  #       id: git_checkout
-  #       uses: actions/checkout@v3
-  #     - name: Cache mutants-initial folder
-  #       uses: actions/cache@v3
-  #       with:
-  #         path: mutation-testing/packages-output
-  #         key: mutants-stable-develop
-  #     # - name: Print caught mutants
-  #     #   run: cat mutants-initial/caught.txt
-
-  # ## Mutants testing: Execute on push on packages that have tested functions modified
-  cache_update_output:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout the latest code
-        id: git_checkout
-        uses: actions/checkout@v3
-      - name: Restore mutants-output cached folder
-        uses: actions/cache/restore@v3
-        with:
-          path: mutation-testing/packages-output
-          key: mutants-stable-develop
-      - name: Print caught mutants
-        run: cat mutation-testing/packages-output/pox-locking/missed.txt
-      - run: cargo install cargo-mutants
-      # - name: Update stable mutants with modified functions
-      #   run: ./git-diff.sh
-      #   working-directory: mutation-testing/scripts
-      # - name: Print updated missed mutants
-      #   run: cat mutation-testing/packages-output/pox-locking/missed.txt
-      - name: Append 2 line to one file
-        run: |
-          echo "text 1" >> missed.txt
-          echo "text 2" >> missed.txt
-        working-directory: mutation-testing/packages-output/pox-locking
-      - name: outshow new cached file
-        run: cat missed.txt
-        working-directory: mutation-testing/packages-output/pox-locking
-      # - name: Cache mutants-initial folder
-      #   uses: actions/cache/save@v3
-      #   with:
-      #     path: mutation-testing/packages-output
-      #     key: mutants-stable-develop
-      - name: Save Cache
-        uses: Wandalen/wretry.action@a163f62ae554a8f3cbe27b23db15b60c0ae2e93c # v1.3.0
-        with:
-          action: actions/cache/save@704facf57e6136b1bc63b828d79edcd491f0ee84 # v3.3.2
-          with: |
-            path: mutation-testing/packages-output
-            key: mutants-stable-develop
-          attempt_limit: 5
-          attempt_delay: 3000
-
-  # # Upload stable output version
-  # stable-mutants:
-  #   name: Upload Stable Mutants Testing
-  #   runs-on: ubuntu-latest
-  #   steps:
-  #     - uses: actions/checkout@v3
-  #       with:
-  #         fetch-depth: 0 # do we want to fetch all?
-  #     - name: Archive mutants output
-  #       uses: actions/upload-artifact@v3
-  #       if: always()
-  #       with:
-  #         name: mutants-stable-develop
-  #         path: mutation-testing/packages-output
-
-  # ## Mutants testing: Execute on PR on packages that have tested functions modified
-  # ### download it && see how it is
-  # incremental-mutants:
-  #   name: Incremental Mutants Testing
-  #   runs-on: ubuntu-latest
-  #   steps:
-  #     - uses: actions/checkout@v3
-  #     - name: Download stable output artifact
-  #       uses: actions/download-artifact@v3
-  #       with:
-  #         name: mutants-stable-develop
-  #         path: mutation-testing/packages-output
-  #     - name: Display structure of downloaded files
-  #       run: ls -R
-  #       working-directory: mutation-testing/packages-output
-  #     - run: cargo install cargo-mutants
-  #     - name: Update stable mutants with modified functions
-  #       run: ./git-diff.sh
-  #       working-directory: mutation-testing/scripts
-  #     - name: Archive mutants output
-  #       uses: actions/upload-artifact@v3
-  #       if: always()
-  #       with:
-  #         name: mutants-stable-develop
-  #         path: mutation-testing/packages-output
-
-  # incremental-mutants-2:
-  #   name: Incremental Mutants Testing
-  #   runs-on: ubuntu-latest
-  #   steps:
-  #     - uses: actions/checkout@v3
-
-  #     - name: Check for the existence of the stable output artifact
-  #       id: check-artifact
-  #       uses: actions/github-script@v5
-  #       with:
-  #         script: |
-  #           const artifacts = await github.rest.actions.listWorkflowRunArtifacts({
-  #             owner: context.repo.owner,
-  #             repo: context.repo.repo,
-  #             run_id: context.runId,
-  #           });
-  #           const artifactExists = artifacts.data.artifacts.some(artifact => artifact.name === 'mutants-stable-develop');
-  #           core.setOutput('exists', artifactExists);
-
-  #     - name: Download stable output artifact
-  #       if: steps.check-artifact.outputs.exists == 'true'
-  #       uses: actions/download-artifact@v3
-  #       with:
-  #         name: mutants-stable-develop
-  #         path: mutation-testing/packages-output
-
-  #     - name: Display structure of downloaded files
-  #       if: steps.check-artifact.outputs.exists == 'true'
-  #       run: ls -R
-  #       working-directory: mutation-testing/packages-output
-
-  #     - run: cargo install cargo-mutants
-
-  #     - name: Update stable mutants with modified functions
-  #       if: steps.check-artifact.outputs.exists == 'true'
-  #       run: ./git-diff.sh
-  #       working-directory: mutation-testing/scripts
-
-  #     - name: Archive mutants output
-  #       uses: actions/upload-artifact@v3
-  #       if: always()
-  #       with:
-  #         name: mutants-stable-develop
-  #         path: mutation-testing/packages-output
diff --git a/mutation-testing/packages-output/clarity/caught.txt b/mutation-testing/packages-output/clarity/caught.txt
deleted file mode 100644
index 41203cc4ae..0000000000
--- a/mutation-testing/packages-output/clarity/caught.txt
+++ /dev/null
@@ -1,487 +0,0 @@
-clarity/src/vm/database/key_value_wrapper.rs:265: replace RollbackWrapper<'a>::commit with ()
-clarity/src/vm/types/mod.rs:871: replace Value::size -> u32 with 1
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:210: replace ContractContext::into_contract_analysis with ()
-clarity/src/vm/contexts.rs:271: replace AssetMap::get_next_stx_burn_amount -> Result<u128> with Ok(0)
-clarity/src/vm/functions/boolean.rs:27: replace type_force_bool -> Result<bool> with Ok(true)
-clarity/src/vm/database/key_value_wrapper.rs:45: replace rollback_edits_push with ()
-clarity/src/vm/representations.rs:194: replace <impl SymbolicExpressionCommon for PreSymbolicExpression>::set_id with ()
-clarity/src/vm/database/structures.rs:837: replace STXBalance::checked_add_unlocked_amount -> Option<u128> with Some(1)
-clarity/src/vm/database/clarity_db.rs:1870: replace ClarityDatabase<'a>::make_key_for_account -> String with String::new()
-clarity/src/vm/database/clarity_store.rs:323: replace <impl ClarityBackingStore for MemoryBackingStore>::get_current_block_height -> u32 with 0
-clarity/src/vm/functions/principals.rs:40: replace version_matches_testnet -> bool with false
-clarity/src/vm/database/structures.rs:892: replace STXBalance::get_available_balance_at_burn_block -> u128 with 0
-clarity/src/vm/functions/options.rs:220: replace is_some -> Result<bool> with Ok(true)
-clarity/src/vm/diagnostic.rs:67: replace <impl Display for Diagnostic>::fmt -> fmt::Result with Ok(Default::default())
-clarity/src/vm/database/clarity_db.rs:1760: replace ClarityDatabase<'a>::get_ft_supply -> Result<u128> with Ok(1)
-clarity/src/vm/types/serialization.rs:396: replace TypeSignature::max_serialized_size -> Result<u32, CheckErrors> with Ok(0)
-clarity/src/vm/mod.rs:557: replace execute -> Result<Option<Value>> with Ok(None)
-clarity/src/vm/database/clarity_db.rs:472: replace ClarityDatabase<'a>::get -> Option<T> with None
-clarity/src/vm/types/signatures.rs:535: replace TypeSignature::admits_type_v2_0 -> Result<bool> with Ok(false)
-clarity/src/vm/database/structures.rs:790: replace STXBalance::amount_locked -> u128 with 1
-clarity/src/vm/analysis/types.rs:104: replace ContractAnalysis::replace_contract_cost_tracker with ()
-clarity/src/vm/database/clarity_db.rs:441: replace ClarityDatabase<'a>::commit with ()
-clarity/src/vm/database/clarity_db.rs:561: replace ClarityDatabase<'a>::insert_contract_hash -> Result<()> with Ok(())
-clarity/src/vm/functions/principals.rs:34: replace version_matches_mainnet -> bool with false
-clarity/src/vm/analysis/analysis_db.rs:58: replace AnalysisDatabase<'a>::begin with ()
-clarity/src/vm/contexts.rs:1699: replace GlobalContext<'a, 'hooks>::begin with ()
-clarity/src/vm/functions/define.rs:277: replace DefineFunctions::try_parse -> Option<(DefineFunctions, &[SymbolicExpression])> with None
-clarity/src/vm/contexts.rs:314: replace AssetMap::add_asset_transfer with ()
-clarity/src/vm/database/clarity_db.rs:1870: replace ClarityDatabase<'a>::make_key_for_account -> String with "xyzzy".into()
-clarity/src/vm/database/clarity_db.rs:1290: replace ClarityDatabase<'a>::make_key_for_data_map_entry -> String with String::new()
-clarity/src/vm/costs/mod.rs:1114: replace <impl CostOverflowingMath for u64>::cost_overflow_mul -> Result<u64> with Ok(1)
-clarity/src/vm/types/signatures.rs:926: replace FunctionSignature::check_args_trait_compliance -> Result<bool> with Ok(true)
-clarity/src/vm/analysis/analysis_db.rs:62: replace AnalysisDatabase<'a>::commit with ()
-clarity/src/vm/contexts.rs:1694: replace GlobalContext<'a, 'hooks>::is_read_only -> bool with true
-clarity/src/vm/contexts.rs:1714: replace GlobalContext<'a, 'hooks>::commit -> Result<(Option<AssetMap>, Option<EventBatch>)> with Ok((None, None))
-clarity/src/vm/contexts.rs:1274: replace Environment<'a, 'b, 'hooks>::initialize_contract -> Result<()> with Ok(())
-clarity/src/vm/errors.rs:132: replace <impl Display for Error>::fmt -> fmt::Result with Ok(Default::default())
-clarity/src/vm/analysis/types.rs:118: replace ContractAnalysis::add_variable_type with ()
-clarity/src/vm/types/signatures.rs:624: replace TypeSignature::admits_type_v2_1 -> Result<bool> with Ok(true)
-clarity/src/vm/contexts.rs:1889: replace LocalContext<'a>::extend -> Result<LocalContext<'a>> with Ok(Default::default())
-clarity/src/vm/database/clarity_db.rs:758: replace ClarityDatabase<'a>::increment_ustx_liquid_supply -> Result<()> with Ok(())
-clarity/src/vm/costs/mod.rs:1114: replace <impl CostOverflowingMath for u64>::cost_overflow_mul -> Result<u64> with Ok(0)
-clarity/src/vm/representations.rs:372: replace PreSymbolicExpression::match_list -> Option<&[PreSymbolicExpression]> with None
-clarity/src/vm/types/signatures.rs:476: replace ListTypeData::get_max_len -> u32 with 1
-clarity/src/vm/mod.rs:513: replace execute_with_parameters -> Result<Option<Value>> with Ok(None)
-clarity/src/vm/functions/define.rs:114: replace check_legal_define -> Result<()> with Ok(())
-clarity/src/vm/types/signatures.rs:865: replace TupleTypeSignature::admits -> Result<bool> with Ok(false)
-clarity/src/vm/types/signatures.rs:515: replace TypeSignature::is_no_type -> bool with true
-clarity/src/vm/types/signatures.rs:1627: replace TypeSignature::depth -> u8 with 1
-clarity/src/vm/types/serialization.rs:1175: replace Value::serialize_to_vec -> Vec<u8> with vec![1]
-clarity/src/vm/mod.rs:369: replace eval_all -> Result<Option<Value>> with Ok(None)
-clarity/src/vm/database/clarity_db.rs:436: replace ClarityDatabase<'a>::begin with ()
-clarity/src/vm/database/clarity_db.rs:937: replace ClarityDatabase<'a>::get_pox_payout_addrs_for_burnchain_height -> Option<(Vec<TupleData>, u128)> with None
-clarity/src/vm/database/key_value_wrapper.rs:315: replace RollbackWrapper<'a>::put with ()
-clarity/src/vm/ast/definition_sorter/mod.rs:488: replace GraphWalker::get_cycling_dependencies -> Option<Vec<usize>> with None
-clarity/src/vm/mod.rs:353: replace is_reserved -> bool with false
-clarity/src/vm/types/signatures.rs:1627: replace TypeSignature::depth -> u8 with 0
-clarity/src/vm/types/mod.rs:875: replace Value::depth -> u8 with 1
-clarity/src/vm/contexts.rs:1818: replace ContractContext::lookup_function -> Option<DefinedFunction> with None
-clarity/src/vm/database/structures.rs:837: replace STXBalance::checked_add_unlocked_amount -> Option<u128> with Some(0)
-clarity/src/vm/ast/definition_sorter/mod.rs:421: replace Graph::get_node_descendants -> Vec<usize> with vec![0]
-clarity/src/vm/contexts.rs:1829: replace ContractContext::is_explicitly_implementing_trait -> bool with true
-clarity/src/vm/types/mod.rs:1053: replace Value::expect_buff -> Vec<u8> with vec![1]
-clarity/src/vm/types/signatures.rs:519: replace TypeSignature::admits -> Result<bool> with Ok(false)
-clarity/src/vm/contexts.rs:284: replace AssetMap::get_next_amount -> Result<u128> with Ok(0)
-clarity/src/vm/types/signatures.rs:1722: replace ListTypeData::inner_size -> Option<u32> with Some(0)
-clarity/src/vm/database/clarity_db.rs:748: replace ClarityDatabase<'a>::set_ustx_liquid_supply with ()
-clarity/src/vm/analysis/arithmetic_checker/mod.rs:92: replace ArithmeticOnlyChecker<'a>::check_define_function -> Result<(), Error> with Ok(())
-clarity/src/vm/database/structures.rs:396: replace STXBalanceSnapshot<'db, 'conn>::can_transfer -> bool with false
-clarity/src/vm/database/structures.rs:409: replace STXBalanceSnapshot<'db, 'conn>::credit with ()
-clarity/src/vm/analysis/analysis_db.rs:93: replace AnalysisDatabase<'a>::load_contract_non_canonical -> Option<ContractAnalysis> with None
-clarity/src/vm/functions/options.rs:28: replace inner_unwrap -> Result<Option<Value>> with Ok(None)
-clarity/src/vm/types/signatures.rs:476: replace ListTypeData::get_max_len -> u32 with 0
-clarity/src/vm/database/key_value_wrapper.rs:305: replace inner_put with ()
-clarity/src/vm/contexts.rs:1694: replace GlobalContext<'a, 'hooks>::is_read_only -> bool with false
-clarity/src/vm/database/structures.rs:358: replace STXBalanceSnapshot<'db, 'conn>::get_available_balance -> u128 with 0
-clarity/src/vm/analysis/errors.rs:279: replace check_argument_count -> Result<(), CheckErrors> with Ok(())
-clarity/src/vm/docs/mod.rs:728: replace get_input_type_string -> String with "xyzzy".into()
-clarity/src/vm/database/sqlite.rs:81: replace SqliteConnection::get -> Option<String> with None
-clarity/src/vm/contexts.rs:1626: replace GlobalContext<'a, 'hooks>::log_token_transfer -> Result<()> with Ok(())
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:312: replace ContractContext::get_variable_type -> Option<&TypeSignature> with None
-clarity/src/vm/database/clarity_db.rs:699: replace ClarityDatabase<'a>::has_contract -> bool with true
-clarity/src/vm/contexts.rs:263: replace AssetMap::get_next_stx_amount -> Result<u128> with Ok(0)
-clarity/src/vm/types/mod.rs:1253: replace <impl Display for ResponseData>::fmt -> fmt::Result with Ok(Default::default())
-clarity/src/vm/contexts.rs:1714: replace GlobalContext<'a, 'hooks>::commit -> Result<(Option<AssetMap>, Option<EventBatch>)> with Ok((Some(Default::default()), None))
-clarity/src/vm/database/clarity_db.rs:1115: replace map_no_contract_as_none -> Result<Option<T>> with Ok(None)
-clarity/src/vm/analysis/arithmetic_checker/mod.rs:274: replace ArithmeticOnlyChecker<'a>::check_function_application -> Result<(), Error> with Ok(())
-clarity/src/vm/database/clarity_store.rs:319: replace <impl ClarityBackingStore for MemoryBackingStore>::get_open_chain_tip_height -> u32 with 1
-clarity/src/vm/contexts.rs:1939: replace CallStack::depth -> usize with 1
-clarity/src/vm/database/clarity_db.rs:1302: replace ClarityDatabase<'a>::make_key_for_data_map_entry_serialized -> String with String::new()
-clarity/src/vm/types/signatures.rs:1917: replace <impl Display for BufferLength>::fmt -> fmt::Result with Ok(Default::default())
-clarity/src/vm/database/key_value_wrapper.rs:420: replace RollbackWrapper<'a>::get_current_block_height -> u32 with 0
-clarity/src/vm/contexts.rs:1635: replace GlobalContext<'a, 'hooks>::log_stx_transfer -> Result<()> with Ok(())
-clarity/src/vm/analysis/arithmetic_checker/mod.rs:165: replace ArithmeticOnlyChecker<'a>::try_native_function_check -> Option<Result<(), Error>> with Some(Ok(()))
-clarity/src/vm/database/clarity_db.rs:926: replace ClarityDatabase<'a>::get_burnchain_block_header_hash_for_burnchain_height -> Option<BurnchainHeaderHash> with None
-clarity/src/vm/database/clarity_db.rs:694: replace ClarityDatabase<'a>::insert_contract with ()
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:43: replace is_string_terminator -> bool with true
-clarity/src/vm/types/signatures.rs:524: replace TypeSignature::admits_type -> Result<bool> with Ok(true)
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:88: replace ContractContext::get_nft_type -> Option<&TypeSignature> with None
-clarity/src/vm/analysis/types.rs:171: replace ContractAnalysis::get_private_function -> Option<&FunctionType> with None
-clarity/src/vm/ast/parser/v2/lexer/token.rs:47: replace <impl Display for Token>::fmt -> std::fmt::Result with Ok(Default::default())
-clarity/src/vm/types/signatures.rs:926: replace FunctionSignature::check_args_trait_compliance -> Result<bool> with Ok(false)
-clarity/src/vm/database/clarity_db.rs:1719: replace ClarityDatabase<'a>::get_ft_balance -> Result<u128> with Ok(1)
-clarity/src/vm/representations.rs:570: replace SymbolicExpression::match_list -> Option<&[SymbolicExpression]> with Some(Vec::leak(Vec::new()))
-clarity/src/vm/contexts.rs:1913: replace LocalContext<'a>::lookup_callable_contract -> Option<&CallableData> with None
-clarity/src/vm/analysis/types.rs:139: replace ContractAnalysis::add_private_function with ()
-clarity/src/vm/types/mod.rs:1361: replace <impl Display for PrincipalData>::fmt -> fmt::Result with Ok(Default::default())
-clarity/src/vm/contexts.rs:1825: replace ContractContext::lookup_trait_definition -> Option<BTreeMap<ClarityName, FunctionSignature>> with None
-clarity/src/vm/types/serialization.rs:1153: replace <impl Write for WriteCounter>::write -> std::io::Result<usize> with Ok(0)
-clarity/src/vm/database/clarity_db.rs:446: replace ClarityDatabase<'a>::roll_back with ()
-clarity/src/vm/types/signatures.rs:1782: replace TupleTypeSignature::inner_size -> Option<u32> with Some(1)
-clarity/src/vm/types/mod.rs:794: replace <impl PartialEq for ListData>::eq -> bool with false
-clarity/src/vm/contexts.rs:1595: replace GlobalContext<'a, 'hooks>::is_top_level -> bool with false
-clarity/src/vm/database/clarity_db.rs:306: replace <impl HeadersDB for NullHeadersDB>::get_burn_block_height_for_block -> Option<u32> with None
-clarity/src/vm/ast/definition_sorter/mod.rs:421: replace Graph::get_node_descendants -> Vec<usize> with vec![1]
-clarity/src/vm/database/key_value_wrapper.rs:363: replace RollbackWrapper<'a>::get -> Option<T> with None
-clarity/src/vm/database/clarity_db.rs:737: replace ClarityDatabase<'a>::get_total_liquid_ustx -> u128 with 0
-clarity/src/vm/database/key_value_wrapper.rs:243: replace RollbackWrapper<'a>::rollback with ()
-clarity/src/vm/ast/types.rs:67: replace ContractAST::get_referenced_trait -> Option<&TraitDefinition> with None
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:332: replace ContractContext::into_contract_analysis with ()
-clarity/src/vm/database/clarity_db.rs:782: replace ClarityDatabase<'a>::is_in_regtest -> bool with false
-clarity/src/vm/database/clarity_db.rs:1874: replace ClarityDatabase<'a>::make_key_for_account_balance -> String with "xyzzy".into()
-clarity/src/vm/types/signatures.rs:341: replace <impl From for u32>::from -> u32 with 1
-clarity/src/vm/database/clarity_db.rs:943: replace ClarityDatabase<'a>::get_burnchain_block_height -> Option<u32> with None
-clarity/src/vm/types/serialization.rs:1183: replace Value::serialize_to_hex -> String with "xyzzy".into()
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:316: replace ContractContext::get_persisted_variable_type -> Option<&TypeSignature> with None
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:84: replace ContractContext::ft_exists -> bool with false
-clarity/src/vm/types/serialization.rs:1017: replace Value::serialize_write -> std::io::Result<()> with Ok(())
-clarity/src/vm/functions/options.rs:227: replace is_okay -> Result<bool> with Ok(false)
-clarity/src/vm/types/serialization.rs:1139: replace Value::serialized_size -> u32 with 0
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:190: replace ContractContext::get_variable_type -> Option<&TypeSignature> with None
-clarity/src/vm/types/mod.rs:423: replace SequenceData::filter -> Result<()> with Ok(())
-clarity/src/vm/types/mod.rs:680: replace <impl SequencedValue for UTF8Data>::drained_items -> Vec<Vec<u8>> with vec![vec![0]]
-clarity/src/vm/database/clarity_db.rs:476: replace ClarityDatabase<'a>::put_value -> Result<()> with Ok(())
-clarity/src/vm/types/serialization.rs:348: replace DeserializeStackItem::next_expected_type -> Result<Option<TypeSignature>, SerializationError> with Ok(None)
-clarity/src/vm/types/signatures.rs:1722: replace ListTypeData::inner_size -> Option<u32> with None
-clarity/src/vm/contexts.rs:302: replace AssetMap::add_stx_burn -> Result<()> with Ok(())
-clarity/src/vm/types/signatures.rs:347: replace <impl From for u32>::from -> u32 with 1
-clarity/src/vm/types/mod.rs:657: replace <impl SequencedValue for ASCIIData>::drained_items -> Vec<u8> with vec![]
-clarity/src/vm/analysis/contract_interface_builder/mod.rs:266: replace ContractInterfaceFunction::from_map -> Vec<ContractInterfaceFunction> with vec![]
-clarity/src/vm/analysis/errors.rs:230: replace <impl Display for CheckError>::fmt -> fmt::Result with Ok(Default::default())
-clarity/src/vm/types/signatures.rs:1696: replace TypeSignature::inner_type_size -> Option<u32> with None
-clarity/src/vm/contexts.rs:1903: replace LocalContext<'a>::lookup_variable -> Option<&Value> with None
-clarity/src/vm/database/clarity_db.rs:550: replace ClarityDatabase<'a>::make_key_for_quad -> String with "xyzzy".into()
-clarity/src/vm/callables.rs:331: replace DefinedFunction::is_read_only -> bool with true
-clarity/src/vm/database/key_value_wrapper.rs:433: replace RollbackWrapper<'a>::prepare_for_contract_metadata with ()
-clarity/src/vm/types/mod.rs:1244: replace <impl Display for OptionalData>::fmt -> fmt::Result with Ok(Default::default())
-clarity/src/vm/types/serialization.rs:1153: replace <impl Write for WriteCounter>::write -> std::io::Result<usize> with Ok(1)
-clarity/src/vm/errors.rs:151: replace <impl Display for RuntimeErrorType>::fmt -> std::fmt::Result with Ok(Default::default())
-clarity/src/vm/contexts.rs:837: replace OwnedEnvironment<'a, 'hooks>::commit -> Result<(AssetMap, EventBatch)> with Ok((Default::default(), Default::default()))
-clarity/src/vm/database/sqlite.rs:77: replace SqliteConnection::put with ()
-clarity/src/vm/database/clarity_store.rs:295: replace <impl ClarityBackingStore for MemoryBackingStore>::get -> Option<String> with Some("xyzzy".into())
-clarity/src/vm/types/signatures.rs:848: replace TupleTypeSignature::len -> u64 with 0
-clarity/src/vm/ast/definition_sorter/mod.rs:429: replace Graph::nodes_count -> usize with 0
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:320: replace ContractContext::get_function_type -> Option<&FunctionType> with None
-clarity/src/vm/contexts.rs:1943: replace CallStack::contains -> bool with true
-clarity/src/vm/ast/definition_sorter/mod.rs:488: replace GraphWalker::get_cycling_dependencies -> Option<Vec<usize>> with Some(vec![0])
-clarity/src/vm/types/signatures.rs:1735: replace ListTypeData::type_size -> Option<u32> with None
-clarity/src/vm/types/mod.rs:125: replace <impl Display for QualifiedContractIdentifier>::fmt -> fmt::Result with Ok(Default::default())
-clarity/src/vm/database/clarity_db.rs:802: replace ClarityDatabase<'a>::get_current_block_height -> u32 with 0
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:43: replace is_string_terminator -> bool with false
-clarity/src/vm/database/clarity_db.rs:1485: replace ClarityDatabase<'a>::data_map_entry_exists -> Result<bool> with Ok(true)
-clarity/src/vm/database/clarity_db.rs:1693: replace ClarityDatabase<'a>::checked_decrease_token_supply -> Result<()> with Ok(())
-clarity/src/vm/test_util/mod.rs:71: replace is_committed -> bool with true
-clarity/src/vm/contexts.rs:271: replace AssetMap::get_next_stx_burn_amount -> Result<u128> with Ok(1)
-clarity/src/vm/representations.rs:396: replace PreSymbolicExpression::match_comment -> Option<&str> with None
-clarity/src/vm/functions/principals.rs:47: replace version_matches_current_network -> bool with false
-clarity/src/vm/variables.rs:63: replace lookup_reserved_variable -> Result<Option<Value>> with Ok(None)
-clarity/src/vm/database/clarity_db.rs:486: replace ClarityDatabase<'a>::put_value_with_size -> Result<u64> with Ok(1)
-clarity/src/vm/types/mod.rs:657: replace <impl SequencedValue for ASCIIData>::drained_items -> Vec<u8> with vec![1]
-clarity/src/vm/representations.rs:586: replace SymbolicExpression::match_atom_value -> Option<&Value> with None
-clarity/src/vm/database/structures.rs:837: replace STXBalance::checked_add_unlocked_amount -> Option<u128> with None
-clarity/src/vm/analysis/contract_interface_builder/mod.rs:170: replace ContractInterfaceAtomType::vec_from_tuple_type -> Vec<ContractInterfaceTupleEntryType> with vec![]
-clarity/src/vm/database/clarity_db.rs:458: replace ClarityDatabase<'a>::put with ()
-clarity/src/vm/analysis/read_only_checker/mod.rs:268: replace ReadOnlyChecker<'a, 'b>::try_check_native_function_is_read_only -> Option<CheckResult<bool>> with None
-clarity/src/vm/contexts.rs:1714: replace GlobalContext<'a, 'hooks>::commit -> Result<(Option<AssetMap>, Option<EventBatch>)> with Ok((Some(Default::default()), Some(Default::default())))
-clarity/src/vm/database/clarity_db.rs:537: replace ClarityDatabase<'a>::make_metadata_key -> String with "xyzzy".into()
-clarity/src/vm/types/signatures.rs:1652: replace TypeSignature::size -> u32 with 1
-clarity/src/vm/types/signatures.rs:1862: replace <impl Debug for TupleTypeSignature>::fmt -> fmt::Result with Ok(Default::default())
-clarity/src/vm/contexts.rs:333: replace AssetMap::add_token_transfer -> Result<()> with Ok(())
-clarity/src/vm/functions/principals.rs:34: replace version_matches_mainnet -> bool with true
-clarity/src/vm/analysis/types.rs:114: replace ContractAnalysis::add_map_type with ()
-clarity/src/vm/types/signatures.rs:1782: replace TupleTypeSignature::inner_size -> Option<u32> with Some(0)
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:304: replace ContractContext::get_trait -> Option<&BTreeMap<ClarityName, FunctionSignature>> with None
-clarity/src/vm/docs/mod.rs:779: replace get_output_type_string -> String with "xyzzy".into()
-clarity/src/vm/database/structures.rs:163: replace <impl ClaritySerializable for STXBalance>::serialize -> String with "xyzzy".into()
-clarity/src/vm/database/clarity_db.rs:1874: replace ClarityDatabase<'a>::make_key_for_account_balance -> String with String::new()
-clarity/src/vm/analysis/types.rs:190: replace ContractAnalysis::get_defined_trait -> Option<&BTreeMap<ClarityName, FunctionSignature>> with None
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:308: replace ContractContext::get_map_type -> Option<&(TypeSignature, TypeSignature)> with None
-clarity/src/vm/types/serialization.rs:1175: replace Value::serialize_to_vec -> Vec<u8> with vec![]
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:198: replace ContractContext::get_function_type -> Option<&FunctionType> with None
-clarity/src/vm/database/structures.rs:337: replace STXBalanceSnapshot<'db, 'conn>::transfer_to -> Result<()> with Ok(())
-clarity/src/vm/analysis/errors.rs:287: replace check_arguments_at_least -> Result<(), CheckErrors> with Ok(())
-clarity/src/vm/errors.rs:120: replace <impl PartialEq for Error>::eq -> bool with true
-clarity/src/vm/costs/mod.rs:1120: replace <impl CostOverflowingMath for u64>::cost_overflow_sub -> Result<u64> with Ok(1)
-clarity/src/vm/types/signatures.rs:511: replace TypeSignature::is_response_type -> bool with true
-clarity/src/vm/ast/traits_resolver/mod.rs:182: replace TraitsResolver::try_parse_pre_expr -> Option<(DefineFunctions, Vec<&'a PreSymbolicExpression>)> with None
-clarity/src/vm/test_util/mod.rs:88: replace is_err_code_i128 -> bool with false
-clarity/src/vm/contexts.rs:1825: replace ContractContext::lookup_trait_definition -> Option<BTreeMap<ClarityName, FunctionSignature>> with Some(BTreeMap::new())
-clarity/src/vm/database/clarity_store.rs:295: replace <impl ClarityBackingStore for MemoryBackingStore>::get -> Option<String> with None
-clarity/src/vm/types/mod.rs:1341: replace StandardPrincipalData::to_address -> String with String::new()
-clarity/src/vm/representations.rs:594: replace SymbolicExpression::match_literal_value -> Option<&Value> with None
-clarity/src/vm/contexts.rs:1943: replace CallStack::contains -> bool with false
-clarity/src/vm/types/signatures.rs:1782: replace TupleTypeSignature::inner_size -> Option<u32> with None
-clarity/src/vm/types/mod.rs:1233: replace UTF8Data::append -> Result<()> with Ok(())
-clarity/src/vm/costs/mod.rs:70: replace runtime_cost -> Result<()> with Ok(())
-clarity/src/vm/database/key_value_wrapper.rs:425: replace RollbackWrapper<'a>::get_block_header_hash -> Option<StacksBlockId> with None
-clarity/src/vm/database/clarity_db.rs:537: replace ClarityDatabase<'a>::make_metadata_key -> String with String::new()
-clarity/src/vm/functions/mod.rs:692: replace parse_eval_bindings -> Result<Vec<(ClarityName, Value)>> with Ok(vec![])
-clarity/src/vm/analysis/analysis_db.rs:106: replace AnalysisDatabase<'a>::load_contract -> Option<ContractAnalysis> with None
-clarity/src/vm/types/mod.rs:1186: replace BuffData::append -> Result<()> with Ok(())
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:102: replace TraitContext::get_trait -> Option<&BTreeMap<ClarityName, FunctionSignature>> with None
-clarity/src/vm/mod.rs:353: replace is_reserved -> bool with true
-clarity/src/vm/database/sqlite.rs:50: replace sqlite_get -> Option<String> with Some("xyzzy".into())
-clarity/src/vm/database/key_value_wrapper.rs:532: replace RollbackWrapper<'a>::has_metadata_entry -> bool with true
-clarity/src/vm/database/key_value_wrapper.rs:402: replace RollbackWrapper<'a>::get_value -> Result<Option<ValueResult>, SerializationError> with Ok(None)
-clarity/src/vm/database/structures.rs:767: replace STXBalance::effective_unlock_height -> u64 with 1
-clarity/src/vm/types/mod.rs:1035: replace Value::expect_u128 -> u128 with 1
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:525: replace clarity2_check_functions_compatible -> bool with false
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:195: replace ContractContext::get_nft_type -> Option<&TypeSignature> with None
-clarity/src/vm/test_util/mod.rs:71: replace is_committed -> bool with false
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:525: replace clarity2_check_functions_compatible -> bool with true
-clarity/src/vm/analysis/contract_interface_builder/mod.rs:236: replace ContractInterfaceFunctionArg::from_function_args -> Vec<ContractInterfaceFunctionArg> with vec![]
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:50: replace TraitContext::is_name_used -> bool with true
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1044: replace TypeChecker<'a, 'b>::get_function_type -> Option<FunctionType> with None
-clarity/src/vm/types/serialization.rs:204: replace <impl ClarityValueSerializable for StandardPrincipalData>::serialize_write -> std::io::Result<()> with Ok(())
-clarity/src/vm/docs/mod.rs:728: replace get_input_type_string -> String with String::new()
-clarity/src/vm/database/clarity_db.rs:1485: replace ClarityDatabase<'a>::data_map_entry_exists -> Result<bool> with Ok(false)
-clarity/src/vm/types/mod.rs:1080: replace Value::expect_buff_padded -> Vec<u8> with vec![1]
-clarity/src/vm/types/serialization.rs:1301: replace <impl ClaritySerializable for u32>::serialize -> String with "xyzzy".into()
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:36: replace is_separator -> bool with false
-clarity/src/vm/types/signatures.rs:341: replace <impl From for u32>::from -> u32 with 0
-clarity/src/vm/database/clarity_store.rs:331: replace <impl ClarityBackingStore for MemoryBackingStore>::put_all with ()
-clarity/src/vm/tests/mod.rs:164: replace test_only_mainnet_to_chain_id -> u32 with 0
-clarity/src/vm/types/mod.rs:1347: replace <impl Display for StandardPrincipalData>::fmt -> fmt::Result with Ok(Default::default())
-clarity/src/vm/types/mod.rs:247: replace SequenceData::atom_values -> Vec<SymbolicExpression> with vec![]
-clarity/src/vm/contexts.rs:1611: replace GlobalContext<'a, 'hooks>::log_asset_transfer with ()
-clarity/src/vm/types/mod.rs:1035: replace Value::expect_u128 -> u128 with 0
-clarity/src/vm/types/signatures.rs:1722: replace ListTypeData::inner_size -> Option<u32> with Some(1)
-clarity/src/vm/database/clarity_db.rs:550: replace ClarityDatabase<'a>::make_key_for_quad -> String with String::new()
-clarity/src/vm/representations.rs:208: replace <impl SymbolicExpressionCommon for SymbolicExpression>::set_id with ()
-clarity/src/vm/functions/boolean.rs:27: replace type_force_bool -> Result<bool> with Ok(false)
-clarity/src/vm/types/mod.rs:619: replace <impl SequencedValue for ListData>::drained_items -> Vec<Value> with vec![]
-clarity/src/vm/representations.rs:620: replace <impl Display for SymbolicExpression>::fmt -> fmt::Result with Ok(Default::default())
-clarity/src/vm/types/mod.rs:637: replace <impl SequencedValue for BuffData>::drained_items -> Vec<u8> with vec![1]
-clarity/src/vm/database/clarity_db.rs:1744: replace ClarityDatabase<'a>::set_ft_balance -> Result<()> with Ok(())
-clarity/src/vm/analysis/arithmetic_checker/mod.rs:144: replace ArithmeticOnlyChecker<'a>::check_variables_allowed -> Result<(), Error> with Ok(())
-clarity/src/vm/types/mod.rs:657: replace <impl SequencedValue for ASCIIData>::drained_items -> Vec<u8> with vec![0]
-clarity/src/vm/database/key_value_wrapper.rs:444: replace RollbackWrapper<'a>::insert_metadata with ()
-clarity/src/vm/database/structures.rs:396: replace STXBalanceSnapshot<'db, 'conn>::can_transfer -> bool with true
-clarity/src/vm/types/mod.rs:1354: replace <impl Debug for StandardPrincipalData>::fmt -> fmt::Result with Ok(Default::default())
-clarity/src/vm/database/clarity_db.rs:937: replace ClarityDatabase<'a>::get_pox_payout_addrs_for_burnchain_height -> Option<(Vec<TupleData>, u128)> with Some((vec![], 0))
-clarity/src/vm/types/signatures.rs:1883: replace <impl Display for TypeSignature>::fmt -> fmt::Result with Ok(Default::default())
-clarity/src/vm/database/clarity_db.rs:1664: replace ClarityDatabase<'a>::checked_increase_token_supply -> Result<()> with Ok(())
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:110: replace TraitContext::into_contract_analysis with ()
-clarity/src/vm/types/mod.rs:1182: replace BuffData::as_slice -> &[u8] with Vec::leak(vec![0])
-clarity/src/vm/analysis/types.rs:163: replace ContractAnalysis::get_public_function_type -> Option<&FunctionType> with None
-clarity/src/vm/analysis/arithmetic_checker/mod.rs:77: replace ArithmeticOnlyChecker<'a>::run -> Result<(), Error> with Ok(())
-clarity/src/vm/types/signatures.rs:1658: replace TypeSignature::inner_size -> Option<u32> with Some(0)
-clarity/src/vm/functions/principals.rs:40: replace version_matches_testnet -> bool with true
-clarity/src/vm/types/mod.rs:265: replace SequenceData::len -> usize with 0
-clarity/src/vm/database/key_value_wrapper.rs:189: replace rollback_lookup_map -> String with String::new()
-clarity/src/vm/database/clarity_db.rs:516: replace ClarityDatabase<'a>::get_value -> Result<Option<ValueResult>> with Ok(None)
-clarity/src/vm/types/serialization.rs:396: replace TypeSignature::max_serialized_size -> Result<u32, CheckErrors> with Ok(1)
-clarity/src/vm/callables.rs:308: replace DefinedFunction::check_trait_expectations -> Result<()> with Ok(())
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:191: replace ContractContext::ft_exists -> bool with false
-clarity/src/vm/types/mod.rs:1341: replace StandardPrincipalData::to_address -> String with "xyzzy".into()
-clarity/src/vm/contexts.rs:1639: replace GlobalContext<'a, 'hooks>::log_stx_burn -> Result<()> with Ok(())
-clarity/src/vm/database/clarity_db.rs:1760: replace ClarityDatabase<'a>::get_ft_supply -> Result<u128> with Ok(0)
-clarity/src/vm/types/mod.rs:1197: replace ListData::len -> u32 with 1
-clarity/src/vm/types/mod.rs:1080: replace Value::expect_buff_padded -> Vec<u8> with vec![]
-clarity/src/vm/types/mod.rs:1388: replace <impl Display for TraitIdentifier>::fmt -> fmt::Result with Ok(Default::default())
-clarity/src/vm/types/signatures.rs:388: replace <impl From for u32>::from -> u32 with 0
-clarity/src/vm/contexts.rs:295: replace AssetMap::add_stx_transfer -> Result<()> with Ok(())
-clarity/src/vm/types/mod.rs:1222: replace ASCIIData::append -> Result<()> with Ok(())
-clarity/src/vm/representations.rs:380: replace PreSymbolicExpression::match_field_identifier -> Option<&TraitIdentifier> with None
-clarity/src/vm/types/signatures.rs:1658: replace TypeSignature::inner_size -> Option<u32> with None
-clarity/src/vm/types/signatures.rs:515: replace TypeSignature::is_no_type -> bool with false
-clarity/src/vm/database/clarity_db.rs:1290: replace ClarityDatabase<'a>::make_key_for_data_map_entry -> String with "xyzzy".into()
-clarity/src/vm/analysis/types.rs:159: replace ContractAnalysis::add_implemented_trait with ()
-clarity/src/vm/database/structures.rs:163: replace <impl ClaritySerializable for STXBalance>::serialize -> String with String::new()
-clarity/src/vm/types/mod.rs:351: replace SequenceData::contains -> Result<Option<usize>> with Ok(Some(0))
-clarity/src/vm/types/serialization.rs:1301: replace <impl ClaritySerializable for u32>::serialize -> String with String::new()
-clarity/src/vm/analysis/errors.rs:319: replace <impl DiagnosableError for CheckErrors>::message -> String with String::new()
-clarity/src/vm/contexts.rs:408: replace AssetMap::to_table -> HashMap<PrincipalData, HashMap<AssetIdentifier, AssetMapEntry>> with HashMap::new()
-clarity/src/vm/ast/definition_sorter/mod.rs:488: replace GraphWalker::get_cycling_dependencies -> Option<Vec<usize>> with Some(vec![1])
-clarity/src/vm/ast/parser/v2/mod.rs:171: replace Parser<'a>::ignore_whitespace -> bool with false
-clarity/src/vm/representations.rs:570: replace SymbolicExpression::match_list -> Option<&[SymbolicExpression]> with None
-clarity/src/vm/docs/mod.rs:779: replace get_output_type_string -> String with String::new()
-clarity/src/vm/analysis/types.rs:131: replace ContractAnalysis::add_read_only_function with ()
-clarity/src/vm/contexts.rs:687: replace OwnedEnvironment<'a, 'hooks>::initialize_contract -> Result<((), AssetMap, Vec<StacksTransactionEvent>)> with Ok(((), Default::default(), vec![]))
-clarity/src/vm/ast/definition_sorter/mod.rs:421: replace Graph::get_node_descendants -> Vec<usize> with vec![]
-clarity/src/vm/types/mod.rs:875: replace Value::depth -> u8 with 0
-clarity/src/vm/database/clarity_db.rs:601: replace ClarityDatabase<'a>::insert_metadata with ()
-clarity/src/vm/types/mod.rs:533: replace SequenceData::is_list -> bool with false
-clarity/src/vm/analysis/types.rs:195: replace ContractAnalysis::canonicalize_types with ()
-clarity/src/vm/types/mod.rs:754: replace BlockInfoProperty::lookup_by_name_at_version -> Option<BlockInfoProperty> with None
-clarity/src/vm/types/signatures.rs:865: replace TupleTypeSignature::admits -> Result<bool> with Ok(true)
-clarity/src/vm/types/signatures.rs:1923: replace <impl Display for StringUTF8Length>::fmt -> fmt::Result with Ok(Default::default())
-clarity/src/vm/types/serialization.rs:1311: replace <impl ClarityDeserializable for u32>::deserialize -> Self with Default::default()
-clarity/src/vm/database/sqlite.rs:133: replace SqliteConnection::get_metadata -> Option<String> with Some(String::new())
-clarity/src/vm/representations.rs:364: replace PreSymbolicExpression::match_atom -> Option<&ClarityName> with None
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:191: replace ContractContext::ft_exists -> bool with true
-clarity/src/vm/callables.rs:343: replace DefinedFunction::is_public -> bool with true
-clarity/src/vm/functions/define.rs:291: replace DefineFunctionsParsed<'a>::try_parse -> std::result::Result<Option<DefineFunctionsParsed<'a>>, CheckErrors> with Ok(None)
-clarity/src/vm/types/signatures.rs:388: replace <impl From for u32>::from -> u32 with 1
-clarity/src/vm/analysis/types.rs:155: replace ContractAnalysis::add_defined_trait with ()
-clarity/src/vm/types/mod.rs:1274: replace <impl Display for Value>::fmt -> fmt::Result with Ok(Default::default())
-clarity/src/vm/ast/definition_sorter/mod.rs:488: replace GraphWalker::get_cycling_dependencies -> Option<Vec<usize>> with Some(vec![])
-clarity/src/vm/ast/parser/v1.rs:499: replace handle_expression with ()
-clarity/src/vm/ast/parser/v2/mod.rs:171: replace Parser<'a>::ignore_whitespace -> bool with true
-clarity/src/vm/types/mod.rs:1108: replace Value::expect_optional -> Option<Value> with None
-clarity/src/vm/types/signatures.rs:1748: replace TupleTypeSignature::type_size -> Option<u32> with None
-clarity/src/vm/representations.rs:211: replace <impl SymbolicExpressionCommon for SymbolicExpression>::match_list_mut -> Option<&mut[SymbolicExpression]> with None
-clarity/src/vm/ast/types.rs:102: replace <impl Iterator for PreExpressionsDrain>::next -> Option<PreSymbolicExpression> with None
-clarity/src/vm/ast/definition_sorter/mod.rs:470: replace GraphWalker::sort_dependencies_recursion with ()
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:164: replace ContractContext::is_contract -> bool with true
-clarity/src/vm/analysis/type_checker/contexts.rs:129: replace TypingContext<'a>::lookup_trait_reference_type -> Option<&TraitIdentifier> with None
-clarity/src/vm/analysis/arithmetic_checker/mod.rs:165: replace ArithmeticOnlyChecker<'a>::try_native_function_check -> Option<Result<(), Error>> with None
-clarity/src/vm/database/clarity_store.rs:187: replace <impl ClaritySerializable for ContractCommitment>::serialize -> String with String::new()
-clarity/src/vm/functions/options.rs:44: replace inner_unwrap_err -> Result<Option<Value>> with Ok(None)
-clarity/src/vm/analysis/analysis_db.rs:66: replace AnalysisDatabase<'a>::roll_back with ()
-clarity/src/vm/functions/mod.rs:212: replace lookup_reserved_functions -> Option<CallableType> with None
-clarity/src/vm/contexts.rs:771: replace OwnedEnvironment<'a, 'hooks>::stx_faucet with ()
-clarity/src/vm/types/signatures.rs:848: replace TupleTypeSignature::len -> u64 with 1
-clarity/src/vm/types/mod.rs:351: replace SequenceData::contains -> Result<Option<usize>> with Ok(Some(1))
-clarity/src/vm/types/mod.rs:1262: replace <impl Display for BuffData>::fmt -> fmt::Result with Ok(Default::default())
-clarity/src/vm/test_util/mod.rs:80: replace is_err_code -> bool with false
-clarity/src/vm/types/signatures.rs:394: replace <impl From for u32>::from -> u32 with 0
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:535: replace TypeChecker<'a, 'b>::get_function_type -> Option<FunctionType> with None
-clarity/src/vm/types/mod.rs:1182: replace BuffData::as_slice -> &[u8] with Vec::leak(Vec::new())
-clarity/src/vm/contexts.rs:263: replace AssetMap::get_next_stx_amount -> Result<u128> with Ok(1)
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:182: replace ContractContext::get_trait -> Option<&BTreeMap<ClarityName, FunctionSignature>> with None
-clarity/src/vm/types/signatures.rs:470: replace ListTypeData::reduce_max_len with ()
-clarity/src/vm/database/key_value_wrapper.rs:59: replace rollback_check_pre_bottom_commit -> Vec<(T, String)> with vec![]
-clarity/src/vm/database/clarity_db.rs:937: replace ClarityDatabase<'a>::get_pox_payout_addrs_for_burnchain_height -> Option<(Vec<TupleData>, u128)> with Some((vec![], 1))
-clarity/src/vm/types/mod.rs:1478: replace TupleData::len -> u64 with 1
-clarity/src/vm/types/mod.rs:680: replace <impl SequencedValue for UTF8Data>::drained_items -> Vec<Vec<u8>> with vec![]
-clarity/src/vm/database/clarity_db.rs:620: replace ClarityDatabase<'a>::fetch_metadata -> Result<Option<T>> with Ok(None)
-clarity/src/vm/analysis/errors.rs:303: replace formatted_expected_types -> String with "xyzzy".into()
-clarity/src/vm/database/clarity_db.rs:879: replace ClarityDatabase<'a>::get_sortition_id_for_stacks_tip -> Option<SortitionId> with None
-clarity/src/vm/database/clarity_db.rs:737: replace ClarityDatabase<'a>::get_total_liquid_ustx -> u128 with 1
-clarity/src/vm/functions/options.rs:227: replace is_okay -> Result<bool> with Ok(true)
-clarity/src/vm/database/sqlite.rs:159: replace SqliteConnection::initialize_conn -> Result<()> with Ok(())
-clarity/src/vm/contexts.rs:1833: replace ContractContext::is_name_used -> bool with true
-clarity/src/vm/database/clarity_db.rs:1826: replace ClarityDatabase<'a>::set_nft_owner -> Result<()> with Ok(())
-clarity/src/vm/analysis/types.rs:126: replace ContractAnalysis::add_persisted_variable_type with ()
-clarity/src/vm/types/signatures.rs:1658: replace TypeSignature::inner_size -> Option<u32> with Some(1)
-clarity/src/vm/types/mod.rs:581: replace <impl Display for UTF8Data>::fmt -> fmt::Result with Ok(Default::default())
-clarity/src/vm/ast/mod.rs:53: replace parse -> Result<Vec<SymbolicExpression>, Error> with Ok(vec![])
-clarity/src/vm/contexts.rs:1814: replace ContractContext::lookup_variable -> Option<&Value> with None
-clarity/src/vm/contexts.rs:1749: replace GlobalContext<'a, 'hooks>::roll_back with ()
-clarity/src/vm/types/serialization.rs:1183: replace Value::serialize_to_hex -> String with String::new()
-clarity/src/vm/representations.rs:211: replace <impl SymbolicExpressionCommon for SymbolicExpression>::match_list_mut -> Option<&mut[SymbolicExpression]> with Some(Vec::leak(Vec::new()))
-clarity/src/vm/costs/mod.rs:1117: replace <impl CostOverflowingMath for u64>::cost_overflow_add -> Result<u64> with Ok(0)
-clarity/src/vm/representations.rs:348: replace PreSymbolicExpression::match_trait_reference -> Option<&ClarityName> with None
-clarity/src/vm/types/signatures.rs:1551: replace TypeSignature::parse_trait_type_repr -> Result<BTreeMap<ClarityName, FunctionSignature>> with Ok(BTreeMap::new())
-clarity/src/vm/types/signatures.rs:1852: replace <impl Display for TupleTypeSignature>::fmt -> fmt::Result with Ok(Default::default())
-clarity/src/vm/representations.rs:396: replace PreSymbolicExpression::match_comment -> Option<&str> with Some("xyzzy")
-clarity/src/vm/functions/mod.rs:672: replace handle_binding_list -> std::result::Result<(), E> with Ok(())
-clarity/src/vm/contexts.rs:1947: replace CallStack::insert with ()
-clarity/src/vm/types/signatures.rs:535: replace TypeSignature::admits_type_v2_0 -> Result<bool> with Ok(true)
-clarity/src/vm/database/clarity_store.rs:187: replace <impl ClaritySerializable for ContractCommitment>::serialize -> String with "xyzzy".into()
-clarity/src/vm/variables.rs:44: replace NativeVariables::lookup_by_name_at_version -> Option<NativeVariables> with None
-clarity/src/vm/representations.rs:396: replace PreSymbolicExpression::match_comment -> Option<&str> with Some("")
-clarity/src/vm/types/signatures.rs:511: replace TypeSignature::is_response_type -> bool with false
-clarity/src/vm/analysis/arithmetic_checker/mod.rs:96: replace ArithmeticOnlyChecker<'a>::check_top_levels -> Result<(), Error> with Ok(())
-clarity/src/vm/types/signatures.rs:524: replace TypeSignature::admits_type -> Result<bool> with Ok(false)
-clarity/src/vm/analysis/type_checker/contexts.rs:65: replace TypeMap::get_type -> Option<&TypeSignature> with None
-clarity/src/vm/contexts.rs:1299: replace Environment<'a, 'b, 'hooks>::initialize_contract_from_ast -> Result<()> with Ok(())
-clarity/src/vm/types/signatures.rs:896: replace TupleTypeSignature::shallow_merge with ()
-clarity/src/vm/database/key_value_wrapper.rs:233: replace RollbackWrapper<'a>::nest with ()
-clarity/src/vm/callables.rs:343: replace DefinedFunction::is_public -> bool with false
-clarity/src/vm/analysis/errors.rs:303: replace formatted_expected_types -> String with String::new()
-clarity/src/vm/contexts.rs:1833: replace ContractContext::is_name_used -> bool with false
-clarity/src/vm/contexts.rs:833: replace OwnedEnvironment<'a, 'hooks>::begin with ()
-clarity/src/vm/database/clarity_db.rs:1851: replace ClarityDatabase<'a>::burn_nft -> Result<()> with Ok(())
-clarity/src/vm/database/clarity_store.rs:307: replace <impl ClarityBackingStore for MemoryBackingStore>::get_block_at_height -> Option<StacksBlockId> with None
-clarity/src/vm/representations.rs:197: replace <impl SymbolicExpressionCommon for PreSymbolicExpression>::match_list_mut -> Option<&mut[PreSymbolicExpression]> with None
-clarity/src/vm/analysis/contract_interface_builder/mod.rs:333: replace ContractInterfaceVariable::from_map -> Vec<ContractInterfaceVariable> with vec![]
-clarity/src/vm/variables.rs:55: replace is_reserved_name -> bool with true
-clarity/src/vm/analysis/types.rs:167: replace ContractAnalysis::get_read_only_function_type -> Option<&FunctionType> with None
-clarity/src/vm/contexts.rs:1848: replace ContractContext::canonicalize_types with ()
-clarity/src/vm/tests/mod.rs:164: replace test_only_mainnet_to_chain_id -> u32 with 1
-clarity/src/vm/types/mod.rs:637: replace <impl SequencedValue for BuffData>::drained_items -> Vec<u8> with vec![]
-clarity/src/vm/database/clarity_store.rs:295: replace <impl ClarityBackingStore for MemoryBackingStore>::get -> Option<String> with Some(String::new())
-clarity/src/vm/types/serialization.rs:1175: replace Value::serialize_to_vec -> Vec<u8> with vec![0]
-clarity/src/vm/costs/mod.rs:1250: replace int_log2 -> Option<u64> with None
-clarity/src/vm/database/structures.rs:332: replace STXBalanceSnapshot<'db, 'conn>::save with ()
-clarity/src/vm/types/mod.rs:680: replace <impl SequencedValue for UTF8Data>::drained_items -> Vec<Vec<u8>> with vec![vec![1]]
-clarity/src/vm/types/mod.rs:1182: replace BuffData::as_slice -> &[u8] with Vec::leak(vec![1])
-clarity/src/vm/callables.rs:363: replace DefinedFunction::canonicalize_types with ()
-clarity/src/vm/analysis/errors.rs:224: replace <impl Display for CheckErrors>::fmt -> fmt::Result with Ok(Default::default())
-clarity/src/vm/types/mod.rs:637: replace <impl SequencedValue for BuffData>::drained_items -> Vec<u8> with vec![0]
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:84: replace ContractContext::ft_exists -> bool with true
-clarity/src/vm/database/structures.rs:420: replace STXBalanceSnapshot<'db, 'conn>::set_balance with ()
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:194: replace ContractContext::get_persisted_variable_type -> Option<&TypeSignature> with None
-clarity/src/vm/ast/definition_sorter/mod.rs:412: replace Graph::add_node with ()
-clarity/src/vm/analysis/contract_interface_builder/mod.rs:389: replace ContractInterface::serialize -> String with String::new()
-clarity/src/vm/representations.rs:372: replace PreSymbolicExpression::match_list -> Option<&[PreSymbolicExpression]> with Some(Vec::leak(Vec::new()))
-clarity/src/vm/database/structures.rs:892: replace STXBalance::get_available_balance_at_burn_block -> u128 with 1
-clarity/src/vm/costs/mod.rs:1120: replace <impl CostOverflowingMath for u64>::cost_overflow_sub -> Result<u64> with Ok(0)
-clarity/src/vm/database/sqlite.rs:50: replace sqlite_get -> Option<String> with None
-clarity/src/vm/variables.rs:55: replace is_reserved_name -> bool with false
-clarity/src/vm/types/mod.rs:1080: replace Value::expect_buff_padded -> Vec<u8> with vec![0]
-clarity/src/vm/types/signatures.rs:1652: replace TypeSignature::size -> u32 with 0
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:36: replace is_separator -> bool with true
-clarity/src/vm/contexts.rs:1707: replace GlobalContext<'a, 'hooks>::begin_read_only with ()
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1156: replace TypeChecker<'a, 'b>::try_native_function_check -> Option<TypeResult> with None
-clarity/src/vm/database/structures.rs:801: replace STXBalance::amount_unlocked -> u128 with 1
-clarity/src/vm/types/mod.rs:1053: replace Value::expect_buff -> Vec<u8> with vec![]
-clarity/src/vm/analysis/contract_interface_builder/mod.rs:389: replace ContractInterface::serialize -> String with "xyzzy".into()
-clarity/src/vm/database/structures.rs:801: replace STXBalance::amount_unlocked -> u128 with 0
-clarity/src/vm/database/sqlite.rs:133: replace SqliteConnection::get_metadata -> Option<String> with Some("xyzzy".into())
-clarity/src/vm/database/sqlite.rs:133: replace SqliteConnection::get_metadata -> Option<String> with None
-clarity/src/vm/types/mod.rs:1053: replace Value::expect_buff -> Vec<u8> with vec![0]
-clarity/src/vm/mod.rs:569: replace execute_v2 -> Result<Option<Value>> with Ok(None)
-clarity/src/vm/types/mod.rs:1197: replace ListData::len -> u32 with 0
-clarity/src/vm/database/sqlite.rs:50: replace sqlite_get -> Option<String> with Some(String::new())
-clarity/src/vm/database/key_value_wrapper.rs:189: replace rollback_lookup_map -> String with "xyzzy".into()
-clarity/src/vm/analysis/arithmetic_checker/mod.rs:174: replace ArithmeticOnlyChecker<'a>::check_native_function -> Result<(), Error> with Ok(())
-clarity/src/vm/callables.rs:331: replace DefinedFunction::is_read_only -> bool with false
-clarity/src/vm/database/clarity_db.rs:678: replace ClarityDatabase<'a>::set_contract_data_size -> Result<()> with Ok(())
-clarity/src/vm/types/signatures.rs:1812: replace parse_name_type_pairs -> Result<Vec<(ClarityName, TypeSignature)>> with Ok(vec![])
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:646: replace TypeChecker<'a, 'b>::try_native_function_check -> Option<TypeResult> with None
-clarity/src/vm/analysis/type_checker/contexts.rs:112: replace TypingContext<'a>::add_variable_type with ()
-clarity/src/vm/contexts.rs:349: replace AssetMap::commit_other -> Result<()> with Ok(())
-clarity/src/vm/test_util/mod.rs:65: replace symbols_from_values -> Vec<SymbolicExpression> with vec![]
-clarity/src/vm/types/signatures.rs:519: replace TypeSignature::admits -> Result<bool> with Ok(true)
-clarity/src/vm/database/sqlite.rs:91: replace SqliteConnection::insert_metadata with ()
-clarity/src/vm/types/mod.rs:351: replace SequenceData::contains -> Result<Option<usize>> with Ok(None)
-clarity/src/vm/contexts.rs:1714: replace GlobalContext<'a, 'hooks>::commit -> Result<(Option<AssetMap>, Option<EventBatch>)> with Ok((None, Some(Default::default())))
-clarity/src/vm/database/clarity_db.rs:1719: replace ClarityDatabase<'a>::get_ft_balance -> Result<u128> with Ok(0)
-clarity/src/vm/contexts.rs:1599: replace GlobalContext<'a, 'hooks>::get_asset_map -> &mut AssetMap with Box::leak(Box::new(Default::default()))
-clarity/src/vm/types/signatures.rs:624: replace TypeSignature::admits_type_v2_1 -> Result<bool> with Ok(false)
-clarity/src/vm/types/mod.rs:800: replace <impl PartialEq for TupleData>::eq -> bool with false
-clarity/src/vm/contexts.rs:1962: replace CallStack::remove -> Result<()> with Ok(())
-clarity/src/vm/analysis/contract_interface_builder/mod.rs:354: replace ContractInterfaceMap::from_map -> Vec<ContractInterfaceMap> with vec![]
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:186: replace ContractContext::get_map_type -> Option<&(TypeSignature, TypeSignature)> with None
-clarity/src/vm/functions/principals.rs:47: replace version_matches_current_network -> bool with true
-clarity/src/vm/functions/options.rs:220: replace is_some -> Result<bool> with Ok(false)
-clarity/src/vm/representations.rs:197: replace <impl SymbolicExpressionCommon for PreSymbolicExpression>::match_list_mut -> Option<&mut[PreSymbolicExpression]> with Some(Vec::leak(Vec::new()))
-clarity/src/vm/ast/parser/v2/mod.rs:131: replace Parser<'a>::next_token -> Option<PlacedToken> with None
-clarity/src/vm/database/clarity_db.rs:486: replace ClarityDatabase<'a>::put_value_with_size -> Result<u64> with Ok(0)
-clarity/src/vm/contexts.rs:284: replace AssetMap::get_next_amount -> Result<u128> with Ok(1)
-clarity/src/vm/ast/definition_sorter/mod.rs:429: replace Graph::nodes_count -> usize with 1
-clarity/src/vm/types/mod.rs:1205: replace ListData::append -> Result<()> with Ok(())
-clarity/src/vm/analysis/errors.rs:319: replace <impl DiagnosableError for CheckErrors>::message -> String with "xyzzy".into()
-clarity/src/vm/database/sqlite.rs:36: replace sqlite_put with ()
-clarity/src/vm/analysis/types.rs:135: replace ContractAnalysis::add_public_function with ()
-clarity/src/vm/database/sqlite.rs:81: replace SqliteConnection::get -> Option<String> with Some(String::new())
-clarity/src/vm/contexts.rs:1939: replace CallStack::depth -> usize with 0
-clarity/src/vm/contexts.rs:1958: replace CallStack::decr_apply_depth with ()
-clarity/src/vm/types/mod.rs:565: replace <impl Display for ASCIIData>::fmt -> fmt::Result with Ok(Default::default())
-clarity/src/vm/database/sqlite.rs:81: replace SqliteConnection::get -> Option<String> with Some("xyzzy".into())
-clarity/src/vm/types/mod.rs:545: replace <impl Display for CharType>::fmt -> fmt::Result with Ok(Default::default())
-clarity/src/vm/types/mod.rs:278: replace SequenceData::element_at -> Option<Value> with None
-clarity/src/vm/errors.rs:120: replace <impl PartialEq for Error>::eq -> bool with false
-clarity/src/vm/costs/mod.rs:1250: replace int_log2 -> Option<u64> with Some(0)
-clarity/src/vm/ast/definition_sorter/mod.rs:416: replace Graph::add_directed_edge with ()
-clarity/src/vm/contexts.rs:1954: replace CallStack::incr_apply_depth with ()
-clarity/src/vm/analysis/type_checker/contexts.rs:97: replace TypingContext<'a>::lookup_variable_type -> Option<&TypeSignature> with None
-clarity/src/vm/ast/definition_sorter/mod.rs:379: replace DefinitionSorter::find_expression_definition -> Option<(ClarityName, u64, &'b PreSymbolicExpression)> with None
-clarity/src/vm/representations.rs:356: replace PreSymbolicExpression::match_atom_value -> Option<&Value> with None
-clarity/src/vm/database/structures.rs:358: replace STXBalanceSnapshot<'db, 'conn>::get_available_balance -> u128 with 1
-clarity/src/vm/ast/definition_sorter/mod.rs:425: replace Graph::has_node_descendants -> bool with false
-clarity/src/vm/types/mod.rs:871: replace Value::size -> u32 with 0
-clarity/src/vm/types/signatures.rs:347: replace <impl From for u32>::from -> u32 with 0
-clarity/src/vm/types/serialization.rs:1198: replace Value::sanitize_value -> Option<(Value, bool)> with None
-clarity/src/vm/analysis/arithmetic_checker/mod.rs:132: replace ArithmeticOnlyChecker<'a>::check_expression -> Result<(), Error> with Ok(())
-clarity/src/vm/types/mod.rs:680: replace <impl SequencedValue for UTF8Data>::drained_items -> Vec<Vec<u8>> with vec![vec![]]
-clarity/src/vm/database/clarity_db.rs:1302: replace ClarityDatabase<'a>::make_key_for_data_map_entry_serialized -> String with "xyzzy".into()
-clarity/src/vm/costs/mod.rs:1250: replace int_log2 -> Option<u64> with Some(1)
-clarity/src/vm/types/mod.rs:463: replace SequenceData::concat -> Result<()> with Ok(())
-clarity/src/vm/analysis/errors.rs:295: replace check_arguments_at_most -> Result<(), CheckErrors> with Ok(())
-clarity/src/vm/analysis/type_checker/contexts.rs:125: replace TypingContext<'a>::add_trait_reference with ()
-clarity/src/vm/functions/mod.rs:197: replace NativeFunctions::lookup_by_name_at_version -> Option<NativeFunctions> with None
-clarity/src/vm/costs/mod.rs:1117: replace <impl CostOverflowingMath for u64>::cost_overflow_add -> Result<u64> with Ok(1)
-clarity/src/vm/types/mod.rs:265: replace SequenceData::len -> usize with 1
-clarity/src/vm/types/serialization.rs:1139: replace Value::serialized_size -> u32 with 1
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:305: replace type_reserved_variable -> Option<TypeSignature> with None
-clarity/src/vm/types/signatures.rs:394: replace <impl From for u32>::from -> u32 with 1
-clarity/src/vm/ast/parser/v2/mod.rs:188: replace Parser<'a>::ignore_whitespace_and_comments -> Vec<PreSymbolicExpression> with vec![]
-clarity/src/vm/types/signatures.rs:857: replace TupleTypeSignature::field_type -> Option<&TypeSignature> with None
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:845: replace type_reserved_variable -> Option<TypeSignature> with None
-clarity/src/vm/representations.rs:578: replace SymbolicExpression::match_atom -> Option<&ClarityName> with None
-clarity/src/vm/types/mod.rs:1547: replace <impl Display for TupleData>::fmt -> fmt::Result with Ok(Default::default())
diff --git a/mutation-testing/packages-output/clarity/missed.txt b/mutation-testing/packages-output/clarity/missed.txt
deleted file mode 100644
index a0fc67adf4..0000000000
--- a/mutation-testing/packages-output/clarity/missed.txt
+++ /dev/null
@@ -1,634 +0,0 @@
-clarity/src/vm/database/clarity_db.rs:1038: replace ClarityDatabase<'a>::get_cc_special_cases_handler -> Option<SpecialCaseHandler> with None
-clarity/src/vm/costs/mod.rs:1137: replace ExecutionCost::proportion_largest_dimension -> u64 with 0
-clarity/src/vm/types/signatures.rs:1766: replace TupleTypeSignature::size -> u32 with 1
-clarity/src/vm/database/clarity_db.rs:332: replace <impl BurnStateDB for NullBurnStateDB>::get_burn_block_height -> Option<u32> with Some(0)
-clarity/src/vm/database/clarity_store.rs:231: replace <impl ClarityBackingStore for NullBackingStore>::get_with_proof -> Option<(String, Vec<u8>)> with None
-clarity/src/vm/contexts.rs:852: replace OwnedEnvironment<'a, 'hooks>::destruct -> Option<(ClarityDatabase<'a>, LimitedCostTracker)> with None
-clarity/src/vm/database/clarity_db.rs:172: replace <impl HeadersDB for &dyn HeadersDB>::get_burn_block_height_for_block -> Option<u32> with Some(0)
-clarity/src/vm/database/clarity_db.rs:194: replace <impl BurnStateDB for &dyn BurnStateDB>::get_v2_unlock_height -> u32 with 1
-clarity/src/vm/tests/datamaps.rs:25: replace assert_executes with ()
-clarity/src/vm/representations.rs:222: replace PreSymbolicExpression::cons -> PreSymbolicExpression with Default::default()
-clarity/src/vm/database/structures.rs:726: replace STXBalanceSnapshot<'db, 'conn>::unlock_available_tokens_if_any -> u128 with 1
-clarity/src/vm/analysis/errors.rs:217: replace CheckError::set_expressions with ()
-clarity/src/vm/contexts.rs:479: replace AssetMap::get_fungible_tokens -> Option<u128> with None
-clarity/src/vm/database/clarity_db.rs:317: replace <impl HeadersDB for NullHeadersDB>::get_burnchain_tokens_spent_for_block -> Option<u128> with None
-clarity/src/vm/costs/mod.rs:1006: replace <impl CostTracker for LimitedCostTracker>::drop_memory with ()
-clarity/src/vm/database/clarity_store.rs:227: replace <impl ClarityBackingStore for NullBackingStore>::get -> Option<String> with None
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:95: replace <impl CostTracker for TypeChecker<'_, '_>>::add_cost -> std::result::Result<(), CostErrors> with Ok(())
-clarity/src/vm/database/clarity_store.rs:231: replace <impl ClarityBackingStore for NullBackingStore>::get_with_proof -> Option<(String, Vec<u8>)> with Some((String::new(), vec![1]))
-clarity/src/vm/database/clarity_db.rs:343: replace <impl BurnStateDB for NullBurnStateDB>::get_sortition_id_from_consensus_hash -> Option<SortitionId> with None
-clarity/src/vm/costs/mod.rs:1070: replace <impl CostTracker for &mut LimitedCostTracker>::short_circuit_contract_call -> Result<bool> with Ok(true)
-clarity/src/vm/tests/defines.rs:30: replace assert_eq_err with ()
-clarity/src/vm/database/clarity_db.rs:1006: replace ClarityDatabase<'a>::get_stx_btc_ops_processed -> u64 with 0
-clarity/src/vm/database/clarity_db.rs:1951: replace ClarityDatabase<'a>::get_burn_block_height -> Option<u32> with None
-clarity/src/vm/database/clarity_db.rs:716: replace ClarityDatabase<'a>::ustx_liquid_supply_key -> &'static str with "xyzzy"
-clarity/src/vm/coverage.rs:196: replace CoverageReporter::produce_lcov -> std::io::Result<()> with Ok(())
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:112: replace <impl CostTracker for TypeChecker<'_, '_>>::short_circuit_contract_call -> std::result::Result<bool, CostErrors> with Ok(false)
-clarity/src/vm/costs/mod.rs:104: replace <impl MemoryConsumer for Value>::get_memory_use -> u64 with 0
-clarity/src/vm/test_util/mod.rs:198: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_burn_block_height -> Option<u32> with None
-clarity/src/vm/tests/contracts.rs:890: replace test_factorial_contract with ()
-clarity/src/vm/database/clarity_db.rs:368: replace <impl BurnStateDB for NullBurnStateDB>::get_v1_unlock_height -> u32 with 0
-clarity/src/vm/database/clarity_db.rs:336: replace <impl BurnStateDB for NullBurnStateDB>::get_burn_start_height -> u32 with 0
-clarity/src/vm/contexts.rs:465: replace AssetMap::get_stx_burned_total -> u128 with 1
-clarity/src/vm/analysis/errors.rs:208: replace CheckError::has_expression -> bool with false
-clarity/src/vm/contexts.rs:465: replace AssetMap::get_stx_burned_total -> u128 with 0
-clarity/src/vm/tests/traits.rs:767: replace test_readwrite_violation_dynamic_dispatch with ()
-clarity/src/vm/database/clarity_db.rs:194: replace <impl BurnStateDB for &dyn BurnStateDB>::get_v2_unlock_height -> u32 with 0
-clarity/src/vm/tests/contracts.rs:1079: replace test_cc_stack_depth with ()
-clarity/src/vm/tests/defines.rs:191: replace test_recursive_panic with ()
-clarity/src/vm/database/structures.rs:512: replace STXBalanceSnapshot<'db, 'conn>::extend_lock_v2 with ()
-clarity/src/vm/costs/mod.rs:813: replace LimitedCostTracker::set_total with ()
-clarity/src/vm/costs/mod.rs:152: replace <impl CostTracker for ()>::short_circuit_contract_call -> Result<bool> with Ok(true)
-clarity/src/vm/database/clarity_db.rs:1023: replace ClarityDatabase<'a>::make_microblock_poison_key -> String with "xyzzy".into()
-clarity/src/vm/types/serialization.rs:253: replace PrincipalData::inner_consensus_serialize -> std::io::Result<()> with Ok(())
-clarity/src/vm/database/clarity_db.rs:580: replace ClarityDatabase<'a>::get_contract_src -> Option<String> with Some(String::new())
-clarity/src/vm/database/clarity_db.rs:1072: replace ClarityDatabase<'a>::get_microblock_pubkey_hash_height -> Option<u32> with Some(0)
-clarity/src/vm/database/clarity_db.rs:295: replace <impl HeadersDB for NullHeadersDB>::get_consensus_hash_for_block -> Option<ConsensusHash> with None
-clarity/src/vm/tests/traits.rs:824: replace test_bad_call_with_trait with ()
-clarity/src/vm/database/clarity_store.rs:251: replace <impl ClarityBackingStore for NullBackingStore>::get_current_block_height -> u32 with 0
-clarity/src/vm/contexts.rs:1411: replace Environment<'a, 'b, 'hooks>::push_to_event_batch with ()
-clarity/src/vm/database/clarity_db.rs:169: replace <impl HeadersDB for &dyn HeadersDB>::get_burn_block_time_for_block -> Option<u64> with Some(0)
-clarity/src/vm/costs/mod.rs:959: replace drop_memory with ()
-clarity/src/vm/database/clarity_db.rs:819: replace ClarityDatabase<'a>::get_v2_unlock_height -> u32 with 0
-clarity/src/vm/database/sqlite.rs:72: replace sqlite_has_entry -> bool with false
-clarity/src/vm/mod.rs:545: replace execute_against_version -> Result<Option<Value>> with Ok(None)
-clarity/src/vm/ast/parser/v2/lexer/error.rs:67: replace <impl DiagnosableError for LexerError>::suggestion -> Option<String> with Some("xyzzy".into())
-clarity/src/vm/contexts.rs:1560: replace Environment<'a, 'b, 'hooks>::register_ft_burn_event -> Result<()> with Ok(())
-clarity/src/vm/database/clarity_db.rs:317: replace <impl HeadersDB for NullHeadersDB>::get_burnchain_tokens_spent_for_block -> Option<u128> with Some(1)
-clarity/src/vm/database/clarity_db.rs:323: replace <impl HeadersDB for NullHeadersDB>::get_burnchain_tokens_spent_for_winning_block -> Option<u128> with Some(0)
-clarity/src/vm/database/clarity_db.rs:1085: replace ClarityDatabase<'a>::get_microblock_poison_report -> Option<(StandardPrincipalData, u16)> with None
-clarity/src/vm/database/clarity_db.rs:1023: replace ClarityDatabase<'a>::make_microblock_poison_key -> String with String::new()
-clarity/src/vm/contexts.rs:1829: replace ContractContext::is_explicitly_implementing_trait -> bool with false
-clarity/src/vm/costs/mod.rs:1230: replace ExecutionCost::exceeds -> bool with false
-clarity/src/vm/database/structures.rs:979: replace STXBalance::was_locked_by_v3 -> bool with false
-clarity/src/vm/test_util/mod.rs:160: replace <impl HeadersDB for UnitTestHeaderDB>::get_burn_block_height_for_block -> Option<u32> with None
-clarity/src/vm/test_util/mod.rs:80: replace is_err_code -> bool with true
-clarity/src/vm/test_util/mod.rs:186: replace <impl HeadersDB for UnitTestHeaderDB>::get_burnchain_tokens_spent_for_winning_block -> Option<u128> with None
-clarity/src/vm/database/clarity_db.rs:160: replace <impl HeadersDB for &dyn HeadersDB>::get_burn_header_hash_for_block -> Option<BurnchainHeaderHash> with None
-clarity/src/vm/representations.rs:266: replace PreSymbolicExpression::span -> &Span with &Default::default()
-clarity/src/vm/contexts.rs:893: replace <impl CostTracker for Environment<'_, '_, '_>>::short_circuit_contract_call -> std::result::Result<bool, CostErrors> with Ok(false)
-clarity/src/vm/ast/errors.rs:117: replace ParseError::set_pre_expression with ()
-clarity/src/vm/callables.rs:105: replace cost_input_sized_vararg -> Result<u64> with Ok(0)
-clarity/src/vm/contexts.rs:479: replace AssetMap::get_fungible_tokens -> Option<u128> with Some(0)
-clarity/src/vm/analysis/analysis_db.rs:70: replace AnalysisDatabase<'a>::storage_key -> &'static str with ""
-clarity/src/vm/events.rs:172: replace STXMintEventData::json_serialize -> serde_json::Value with Default::default()
-clarity/src/vm/costs/mod.rs:1230: replace ExecutionCost::exceeds -> bool with true
-clarity/src/vm/database/clarity_store.rs:231: replace <impl ClarityBackingStore for NullBackingStore>::get_with_proof -> Option<(String, Vec<u8>)> with Some(("xyzzy".into(), vec![0]))
-clarity/src/vm/types/mod.rs:1026: replace Value::expect_ascii -> String with String::new()
-clarity/src/vm/database/clarity_db.rs:984: replace ClarityDatabase<'a>::get_block_reward -> Option<u128> with Some(0)
-clarity/src/vm/database/clarity_db.rs:860: replace ClarityDatabase<'a>::get_block_time -> u64 with 0
-clarity/src/vm/database/structures.rs:949: replace STXBalance::get_total_balance -> u128 with 0
-clarity/src/vm/contexts.rs:912: replace <impl CostTracker for GlobalContext<'_, '_>>::add_memory -> std::result::Result<(), CostErrors> with Ok(())
-clarity/src/vm/events.rs:189: replace STXLockEventData::json_serialize -> serde_json::Value with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:164: replace ContractContext::is_contract -> bool with false
-clarity/src/vm/database/clarity_store.rs:177: replace make_contract_hash_key -> String with "xyzzy".into()
-clarity/src/vm/database/clarity_db.rs:732: replace ClarityDatabase<'a>::set_clarity_epoch_version with ()
-clarity/src/vm/database/clarity_db.rs:395: replace <impl BurnStateDB for NullBurnStateDB>::get_pox_payout_addrs -> Option<(Vec<TupleData>, u128)> with Some((vec![], 1))
-clarity/src/vm/contexts.rs:1595: replace GlobalContext<'a, 'hooks>::is_top_level -> bool with true
-clarity/src/vm/contexts.rs:1878: replace LocalContext<'a>::depth -> u16 with 1
-clarity/src/vm/types/serialization.rs:290: replace <impl StacksMessageCodec for PrincipalData>::consensus_serialize -> Result<(), codec_error> with Ok(())
-clarity/src/vm/database/clarity_db.rs:172: replace <impl HeadersDB for &dyn HeadersDB>::get_burn_block_height_for_block -> Option<u32> with None
-clarity/src/vm/test_util/mod.rs:191: replace <impl HeadersDB for UnitTestHeaderDB>::get_tokens_earned_for_block -> Option<u128> with Some(0)
-clarity/src/vm/costs/mod.rs:1053: replace <impl CostTracker for &mut LimitedCostTracker>::add_cost -> std::result::Result<(), CostErrors> with Ok(())
-clarity/src/vm/database/key_value_wrapper.rs:96: replace rollback_check_pre_bottom_commit -> Vec<(T, String)> with vec![(Default::default(), "xyzzy".into())]
-clarity/src/vm/database/clarity_db.rs:355: replace <impl BurnStateDB for NullBurnStateDB>::get_stacks_epoch -> Option<StacksEpoch> with None
-clarity/src/vm/tests/traits.rs:1744: replace test_pass_embedded_trait_to_subtrait_list with ()
-clarity/src/vm/database/clarity_db.rs:240: replace <impl BurnStateDB for &dyn BurnStateDB>::get_stacks_epoch_by_epoch_id -> Option<StacksEpoch> with None
-clarity/src/vm/contexts.rs:1525: replace Environment<'a, 'b, 'hooks>::register_ft_transfer_event -> Result<()> with Ok(())
-clarity/src/vm/database/clarity_db.rs:962: replace ClarityDatabase<'a>::get_miner_spend_winner -> u128 with 0
-clarity/src/vm/costs/mod.rs:1201: replace ExecutionCost::add -> Result<()> with Ok(())
-clarity/src/vm/ast/errors.rs:173: replace <impl DiagnosableError for ParseErrors>::message -> String with String::new()
-clarity/src/vm/database/structures.rs:1109: replace STXBalance::can_transfer_at_burn_block -> bool with true
-clarity/src/vm/tests/contracts.rs:160: replace test_contract_caller with ()
-clarity/src/vm/events.rs:315: replace FTMintEventData::json_serialize -> serde_json::Value with Default::default()
-clarity/src/vm/database/structures.rs:920: replace STXBalance::get_locked_balance_at_burn_block -> (u128, u64) with (1, 1)
-clarity/src/vm/database/key_value_wrapper.rs:96: replace rollback_check_pre_bottom_commit -> Vec<(T, String)> with vec![(Default::default(), String::new())]
-clarity/src/vm/database/clarity_db.rs:1938: replace ClarityDatabase<'a>::get_account_nonce -> u64 with 1
-clarity/src/vm/coverage.rs:104: replace CoverageReporter::executable_lines -> Vec<u32> with vec![1]
-clarity/src/vm/docs/mod.rs:809: replace get_signature -> Option<String> with Some("xyzzy".into())
-clarity/src/vm/database/structures.rs:920: replace STXBalance::get_locked_balance_at_burn_block -> (u128, u64) with (0, 0)
-clarity/src/vm/costs/mod.rs:142: replace <impl CostTracker for ()>::add_memory -> std::result::Result<(), CostErrors> with Ok(())
-clarity/src/vm/test_util/mod.rs:160: replace <impl HeadersDB for UnitTestHeaderDB>::get_burn_block_height_for_block -> Option<u32> with Some(0)
-clarity/src/vm/costs/mod.rs:1210: replace ExecutionCost::sub -> Result<()> with Ok(())
-clarity/src/vm/test_util/mod.rs:168: replace <impl HeadersDB for UnitTestHeaderDB>::get_miner_address -> Option<StacksAddress> with None
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:96: replace <impl CostTracker for TypeChecker<'_, '_>>::drop_memory with ()
-clarity/src/vm/costs/mod.rs:164: replace <impl Display for ClarityCostFunctionReference>::fmt -> ::std::fmt::Result with Ok(Default::default())
-clarity/src/vm/tests/contracts.rs:742: replace test_aborts with ()
-clarity/src/vm/database/structures.rs:691: replace STXBalanceSnapshot<'db, 'conn>::accelerate_unlock with ()
-clarity/src/vm/docs/mod.rs:2532: replace make_keyword_reference -> Option<KeywordAPI> with None
-clarity/src/vm/docs/mod.rs:2626: replace make_json_api_reference -> String with String::new()
-clarity/src/vm/database/clarity_db.rs:178: replace <impl HeadersDB for &dyn HeadersDB>::get_burnchain_tokens_spent_for_block -> Option<u128> with Some(0)
-clarity/src/vm/contexts.rs:1983: replace CallStack::make_stack_trace -> StackTrace with Default::default()
-clarity/src/vm/database/clarity_db.rs:376: replace <impl BurnStateDB for NullBurnStateDB>::get_pox_3_activation_height -> u32 with 1
-clarity/src/vm/analysis/arithmetic_checker/mod.rs:66: replace <impl Display for Error>::fmt -> std::fmt::Result with Ok(Default::default())
-clarity/src/vm/analysis/contract_interface_builder/mod.rs:318: replace ContractInterfaceNonFungibleTokens::from_map -> Vec<Self> with vec![]
-clarity/src/vm/types/mod.rs:533: replace SequenceData::is_list -> bool with true
-clarity/src/vm/contexts.rs:1490: replace Environment<'a, 'b, 'hooks>::register_nft_mint_event -> Result<()> with Ok(())
-clarity/src/vm/database/clarity_store.rs:327: replace <impl ClarityBackingStore for MemoryBackingStore>::get_cc_special_cases_handler -> Option<SpecialCaseHandler> with None
-clarity/src/vm/costs/mod.rs:1070: replace <impl CostTracker for &mut LimitedCostTracker>::short_circuit_contract_call -> Result<bool> with Ok(false)
-clarity/src/vm/tests/traits.rs:1462: replace test_embedded_trait with ()
-clarity/src/vm/tests/defines.rs:58: replace test_accept_options with ()
-clarity/src/vm/database/clarity_db.rs:1878: replace ClarityDatabase<'a>::make_key_for_account_nonce -> String with "xyzzy".into()
-clarity/src/vm/ast/parser/v2/mod.rs:1109: replace parse_collect_diagnostics -> (Vec<PreSymbolicExpression>, Vec<Diagnostic>, bool) with (vec![], vec![], false)
-clarity/src/vm/test_util/mod.rs:232: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_pox_3_activation_height -> u32 with 0
-clarity/src/vm/database/clarity_db.rs:376: replace <impl BurnStateDB for NullBurnStateDB>::get_pox_3_activation_height -> u32 with 0
-clarity/src/vm/database/key_value_wrapper.rs:96: replace rollback_check_pre_bottom_commit -> Vec<(T, String)> with vec![]
-clarity/src/vm/database/clarity_db.rs:202: replace <impl BurnStateDB for &dyn BurnStateDB>::get_burn_block_height -> Option<u32> with Some(0)
-clarity/src/vm/database/clarity_db.rs:647: replace ClarityDatabase<'a>::load_contract_analysis -> Option<ContractAnalysis> with None
-clarity/src/vm/database/clarity_db.rs:306: replace <impl HeadersDB for NullHeadersDB>::get_burn_block_height_for_block -> Option<u32> with Some(1)
-clarity/src/vm/tests/traits.rs:204: replace test_dynamic_dispatch_intra_contract_call with ()
-clarity/src/vm/test_util/mod.rs:244: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_pox_rejection_fraction -> u64 with 0
-clarity/src/vm/tests/traits.rs:710: replace test_readwrite_dynamic_dispatch with ()
-clarity/src/vm/database/clarity_db.rs:1047: replace ClarityDatabase<'a>::insert_microblock_poison -> Result<()> with Ok(())
-clarity/src/vm/database/clarity_db.rs:1072: replace ClarityDatabase<'a>::get_microblock_pubkey_hash_height -> Option<u32> with None
-clarity/src/vm/costs/mod.rs:152: replace <impl CostTracker for ()>::short_circuit_contract_call -> Result<bool> with Ok(false)
-clarity/src/vm/types/mod.rs:800: replace <impl PartialEq for TupleData>::eq -> bool with true
-clarity/src/vm/ast/parser/v1.rs:108: replace get_lines_at -> Vec<usize> with vec![0]
-clarity/src/vm/ast/parser/v2/lexer/token.rs:82: replace Token::reproduce -> String with "xyzzy".into()
-clarity/src/vm/database/structures.rs:818: replace STXBalance::debit_unlocked_amount with ()
-clarity/src/vm/database/structures.rs:42: replace <impl ClaritySerializable for String>::serialize -> String with String::new()
-clarity/src/vm/analysis/arithmetic_checker/mod.rs:267: replace ArithmeticOnlyChecker<'a>::check_all -> Result<(), Error> with Ok(())
-clarity/src/vm/database/clarity_db.rs:172: replace <impl HeadersDB for &dyn HeadersDB>::get_burn_block_height_for_block -> Option<u32> with Some(1)
-clarity/src/vm/database/clarity_db.rs:229: replace <impl BurnStateDB for &dyn BurnStateDB>::get_pox_prepare_length -> u32 with 0
-clarity/src/vm/test_util/mod.rs:253: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_sortition_id_from_consensus_hash -> Option<SortitionId> with None
-clarity/src/vm/database/clarity_db.rs:973: replace ClarityDatabase<'a>::get_miner_spend_total -> u128 with 0
-clarity/src/vm/types/signatures.rs:913: replace FunctionSignature::total_type_size -> Result<u64> with Ok(0)
-clarity/src/vm/tests/traits.rs:1963: replace test_let_trait with ()
-clarity/src/vm/costs/mod.rs:1062: replace <impl CostTracker for &mut LimitedCostTracker>::reset_memory with ()
-clarity/src/vm/database/structures.rs:949: replace STXBalance::get_total_balance -> u128 with 1
-clarity/src/vm/events.rs:206: replace STXBurnEventData::json_serialize -> serde_json::Value with Default::default()
-clarity/src/vm/ast/errors.rs:296: replace <impl DiagnosableError for ParseErrors>::suggestion -> Option<String> with Some(String::new())
-clarity/src/vm/database/clarity_db.rs:237: replace <impl BurnStateDB for &dyn BurnStateDB>::get_pox_rejection_fraction -> u64 with 0
-clarity/src/vm/types/signatures.rs:902: replace FixedFunction::total_type_size -> Result<u64> with Ok(1)
-clarity/src/vm/contexts.rs:502: replace <impl Display for AssetMap>::fmt -> fmt::Result with Ok(Default::default())
-clarity/src/vm/database/clarity_db.rs:943: replace ClarityDatabase<'a>::get_burnchain_block_height -> Option<u32> with Some(0)
-clarity/src/vm/types/signatures.rs:1748: replace TupleTypeSignature::type_size -> Option<u32> with Some(0)
-clarity/src/vm/tests/traits.rs:1346: replace test_return_trait_with_contract_of with ()
-clarity/src/vm/costs/mod.rs:1059: replace <impl CostTracker for &mut LimitedCostTracker>::drop_memory with ()
-clarity/src/vm/tests/contracts.rs:99: replace test_get_block_info_eval with ()
-clarity/src/vm/database/clarity_db.rs:298: replace <impl HeadersDB for NullHeadersDB>::get_burn_block_time_for_block -> Option<u64> with None
-clarity/src/vm/database/clarity_store.rs:239: replace <impl ClarityBackingStore for NullBackingStore>::get_block_at_height -> Option<StacksBlockId> with None
-clarity/src/vm/errors.rs:114: replace <impl PartialEq for IncomparableError<T>>::eq -> bool with false
-clarity/src/vm/types/signatures.rs:1735: replace ListTypeData::type_size -> Option<u32> with Some(1)
-clarity/src/vm/database/clarity_db.rs:163: replace <impl HeadersDB for &dyn HeadersDB>::get_consensus_hash_for_block -> Option<ConsensusHash> with None
-clarity/src/vm/tests/sequences.rs:1160: replace test_construct_bad_list with ()
-clarity/src/vm/errors.rs:163: replace <impl Error for RuntimeErrorType>::source -> Option<&(dyn error::Error +'static)> with None
-clarity/src/vm/database/key_value_wrapper.rs:261: replace RollbackWrapper<'a>::depth -> usize with 1
-clarity/src/vm/types/mod.rs:274: replace SequenceData::is_empty -> bool with true
-clarity/src/vm/database/structures.rs:386: replace STXBalanceSnapshot<'db, 'conn>::has_unlockable_tokens -> bool with true
-clarity/src/vm/analysis/analysis_db.rs:84: replace AnalysisDatabase<'a>::has_contract -> bool with false
-clarity/src/vm/docs/mod.rs:2626: replace make_json_api_reference -> String with "xyzzy".into()
-clarity/src/vm/test_util/mod.rs:236: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_pox_prepare_length -> u32 with 1
-clarity/src/vm/tests/contracts.rs:458: replace test_simple_naming_system with ()
-clarity/src/vm/database/clarity_store.rs:299: replace <impl ClarityBackingStore for MemoryBackingStore>::get_with_proof -> Option<(String, Vec<u8>)> with Some((String::new(), vec![1]))
-clarity/src/vm/analysis/types.rs:179: replace ContractAnalysis::get_variable_type -> Option<&TypeSignature> with None
-clarity/src/vm/tests/assets.rs:521: replace test_simple_token_system with ()
-clarity/src/vm/types/mod.rs:1559: replace byte_len_of_serialization -> u64 with 0
-clarity/src/vm/representations.rs:511: replace SymbolicExpression::span -> &Span with &Default::default()
-clarity/src/vm/database/clarity_db.rs:1072: replace ClarityDatabase<'a>::get_microblock_pubkey_hash_height -> Option<u32> with Some(1)
-clarity/src/vm/database/clarity_db.rs:181: replace <impl HeadersDB for &dyn HeadersDB>::get_burnchain_tokens_spent_for_winning_block -> Option<u128> with None
-clarity/src/vm/database/clarity_store.rs:227: replace <impl ClarityBackingStore for NullBackingStore>::get -> Option<String> with Some(String::new())
-clarity/src/vm/types/mod.rs:1301: replace PrincipalData::version -> u8 with 0
-clarity/src/vm/tests/contracts.rs:295: replace test_tx_sponsor with ()
-clarity/src/vm/database/clarity_db.rs:832: replace ClarityDatabase<'a>::get_current_burnchain_block_height -> u32 with 0
-clarity/src/vm/mod.rs:221: replace add_stack_trace with ()
-clarity/src/vm/database/key_value_wrapper.rs:174: replace RollbackWrapperPersistedLog::nest with ()
-clarity/src/vm/types/mod.rs:1044: replace Value::expect_i128 -> i128 with 0
-clarity/src/vm/database/clarity_db.rs:384: replace <impl BurnStateDB for NullBurnStateDB>::get_pox_reward_cycle_length -> u32 with 0
-clarity/src/vm/database/clarity_db.rs:388: replace <impl BurnStateDB for NullBurnStateDB>::get_pox_rejection_fraction -> u64 with 1
-clarity/src/vm/types/mod.rs:274: replace SequenceData::is_empty -> bool with false
-clarity/src/vm/database/clarity_store.rs:319: replace <impl ClarityBackingStore for MemoryBackingStore>::get_open_chain_tip_height -> u32 with 0
-clarity/src/vm/test_util/mod.rs:236: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_pox_prepare_length -> u32 with 0
-clarity/src/vm/events.rs:155: replace STXTransferEventData::json_serialize -> serde_json::Value with Default::default()
-clarity/src/vm/coverage.rs:237: replace <impl EvalHook for CoverageReporter>::will_begin_eval with ()
-clarity/src/vm/types/mod.rs:256: replace SequenceData::element_size -> u32 with 0
-clarity/src/vm/database/clarity_db.rs:233: replace <impl BurnStateDB for &dyn BurnStateDB>::get_pox_reward_cycle_length -> u32 with 0
-clarity/src/vm/database/sqlite.rs:153: replace SqliteConnection::has_entry -> bool with false
-clarity/src/vm/costs/mod.rs:826: replace LimitedCostTracker::get_memory -> u64 with 0
-clarity/src/vm/contexts.rs:926: replace <impl CostTracker for GlobalContext<'_, '_>>::short_circuit_contract_call -> std::result::Result<bool, CostErrors> with Ok(false)
-clarity/src/vm/tests/traits.rs:2024: replace test_let3_trait with ()
-clarity/src/vm/database/clarity_store.rs:299: replace <impl ClarityBackingStore for MemoryBackingStore>::get_with_proof -> Option<(String, Vec<u8>)> with Some(("xyzzy".into(), vec![0]))
-clarity/src/vm/database/clarity_db.rs:326: replace <impl HeadersDB for NullHeadersDB>::get_tokens_earned_for_block -> Option<u128> with Some(1)
-clarity/src/vm/database/structures.rs:979: replace STXBalance::was_locked_by_v3 -> bool with true
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:50: replace TraitContext::is_name_used -> bool with false
-clarity/src/vm/ast/errors.rs:296: replace <impl DiagnosableError for ParseErrors>::suggestion -> Option<String> with Some("xyzzy".into())
-clarity/src/vm/database/structures.rs:578: replace STXBalanceSnapshot<'db, 'conn>::lock_tokens_v3 with ()
-clarity/src/vm/test_util/mod.rs:247: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_burn_start_height -> u32 with 0
-clarity/src/vm/tests/traits.rs:452: replace test_dynamic_dispatch_including_nested_trait with ()
-clarity/src/vm/ast/parser/v2/lexer/error.rs:67: replace <impl DiagnosableError for LexerError>::suggestion -> Option<String> with None
-clarity/src/vm/database/clarity_db.rs:336: replace <impl BurnStateDB for NullBurnStateDB>::get_burn_start_height -> u32 with 1
-clarity/src/vm/database/clarity_db.rs:580: replace ClarityDatabase<'a>::get_contract_src -> Option<String> with Some("xyzzy".into())
-clarity/src/vm/analysis/errors.rs:208: replace CheckError::has_expression -> bool with true
-clarity/src/vm/types/mod.rs:1374: replace <impl Display for CallableData>::fmt -> fmt::Result with Ok(Default::default())
-clarity/src/vm/types/mod.rs:1483: replace TupleData::is_empty -> bool with false
-clarity/src/vm/mod.rs:481: replace execute_on_network -> Result<Option<Value>> with Ok(None)
-clarity/src/vm/types/serialization.rs:1169: replace <impl Write for WriteCounter>::flush -> std::io::Result<()> with Ok(())
-clarity/src/vm/contexts.rs:915: replace <impl CostTracker for GlobalContext<'_, '_>>::drop_memory with ()
-clarity/src/vm/database/clarity_db.rs:306: replace <impl HeadersDB for NullHeadersDB>::get_burn_block_height_for_block -> Option<u32> with Some(0)
-clarity/src/vm/database/clarity_db.rs:314: replace <impl HeadersDB for NullHeadersDB>::get_miner_address -> Option<StacksAddress> with None
-clarity/src/vm/tests/traits.rs:1816: replace test_pass_embedded_trait_to_subtrait_list_option with ()
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:90: replace <impl CostTracker for TypeChecker<'_, '_>>::add_cost -> std::result::Result<(), CostErrors> with Ok(())
-clarity/src/vm/database/structures.rs:42: replace <impl ClaritySerializable for String>::serialize -> String with "xyzzy".into()
-clarity/src/vm/ast/errors.rs:173: replace <impl DiagnosableError for ParseErrors>::message -> String with "xyzzy".into()
-clarity/src/vm/database/clarity_store.rs:251: replace <impl ClarityBackingStore for NullBackingStore>::get_current_block_height -> u32 with 1
-clarity/src/vm/database/structures.rs:1109: replace STXBalance::can_transfer_at_burn_block -> bool with false
-clarity/src/vm/database/clarity_db.rs:190: replace <impl BurnStateDB for &dyn BurnStateDB>::get_v1_unlock_height -> u32 with 0
-clarity/src/vm/database/clarity_db.rs:213: replace <impl BurnStateDB for &dyn BurnStateDB>::get_burn_start_height -> u32 with 1
-clarity/src/vm/contexts.rs:1988: replace CallStack::make_stack_trace -> StackTrace with Default::default()
-clarity/src/vm/database/clarity_db.rs:323: replace <impl HeadersDB for NullHeadersDB>::get_burnchain_tokens_spent_for_winning_block -> Option<u128> with None
-clarity/src/vm/database/clarity_db.rs:533: replace ClarityDatabase<'a>::make_key_for_trip -> String with String::new()
-clarity/src/vm/types/signatures.rs:69: replace AssetIdentifier::sugared -> String with "xyzzy".into()
-clarity/src/vm/test_util/mod.rs:149: replace <impl HeadersDB for UnitTestHeaderDB>::get_burn_block_time_for_block -> Option<u64> with Some(1)
-clarity/src/vm/costs/mod.rs:259: replace LimitedCostTracker::contract_call_circuits -> HashMap<(QualifiedContractIdentifier, ClarityName), ClarityCostFunctionReference> with HashMap::new()
-clarity/src/vm/contexts.rs:461: replace AssetMap::get_stx_burned -> Option<u128> with None
-clarity/src/vm/database/clarity_db.rs:659: replace ClarityDatabase<'a>::get_contract_size -> Result<u64> with Ok(0)
-clarity/src/vm/test_util/mod.rs:228: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_v2_unlock_height -> u32 with 0
-clarity/src/vm/types/signatures.rs:913: replace FunctionSignature::total_type_size -> Result<u64> with Ok(1)
-clarity/src/vm/tests/principals.rs:138: replace test_simple_is_standard_mainnet_cases with ()
-clarity/src/vm/database/key_value_wrapper.rs:261: replace RollbackWrapper<'a>::depth -> usize with 0
-clarity/src/vm/database/clarity_db.rs:221: replace <impl BurnStateDB for &dyn BurnStateDB>::get_burn_header_hash -> Option<BurnchainHeaderHash> with None
-clarity/src/vm/analysis/errors.rs:212: replace CheckError::set_expression with ()
-clarity/src/vm/database/clarity_db.rs:175: replace <impl HeadersDB for &dyn HeadersDB>::get_miner_address -> Option<StacksAddress> with None
-clarity/src/vm/database/clarity_db.rs:178: replace <impl HeadersDB for &dyn HeadersDB>::get_burnchain_tokens_spent_for_block -> Option<u128> with None
-clarity/src/vm/tests/traits.rs:1232: replace test_return_trait_with_contract_of_wrapped_in_begin with ()
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:99: replace <impl CostTracker for TypeChecker<'_, '_>>::reset_memory with ()
-clarity/src/vm/contexts.rs:457: replace AssetMap::get_stx -> Option<u128> with Some(1)
-clarity/src/vm/costs/mod.rs:735: replace TrackerData::load_costs -> Result<()> with Ok(())
-clarity/src/vm/types/signatures.rs:1872: replace <impl Display for AssetIdentifier>::fmt -> fmt::Result with Ok(Default::default())
-clarity/src/vm/ast/errors.rs:129: replace <impl Display for ParseError>::fmt -> fmt::Result with Ok(Default::default())
-clarity/src/vm/database/clarity_db.rs:395: replace <impl BurnStateDB for NullBurnStateDB>::get_pox_payout_addrs -> Option<(Vec<TupleData>, u128)> with None
-clarity/src/vm/database/clarity_db.rs:962: replace ClarityDatabase<'a>::get_miner_spend_winner -> u128 with 1
-clarity/src/vm/ast/errors.rs:113: replace ParseError::has_pre_expression -> bool with false
-clarity/src/vm/database/structures.rs:988: replace STXBalance::has_locked_tokens_at_burn_block -> bool with true
-clarity/src/vm/representations.rs:503: replace SymbolicExpression::copy_span with ()
-clarity/src/vm/test_util/mod.rs:220: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_stacks_epoch_by_epoch_id -> Option<StacksEpoch> with None
-clarity/src/vm/database/clarity_db.rs:229: replace <impl BurnStateDB for &dyn BurnStateDB>::get_pox_prepare_length -> u32 with 1
-clarity/src/vm/database/clarity_db.rs:1031: replace ClarityDatabase<'a>::insert_microblock_pubkey_hash_height -> Result<()> with Ok(())
-clarity/src/vm/coverage.rs:104: replace CoverageReporter::executable_lines -> Vec<u32> with vec![0]
-clarity/src/vm/database/structures.rs:48: replace <impl ClarityDeserializable for String>::deserialize -> String with String::new()
-clarity/src/vm/database/clarity_db.rs:463: replace ClarityDatabase<'a>::put_with_size -> u64 with 1
-clarity/src/vm/types/mod.rs:1201: replace ListData::is_empty -> bool with false
-clarity/src/vm/costs/mod.rs:716: replace LimitedCostTracker::default_cost_contract_for_epoch -> String with String::new()
-clarity/src/vm/database/clarity_db.rs:298: replace <impl HeadersDB for NullHeadersDB>::get_burn_block_time_for_block -> Option<u64> with Some(0)
-clarity/src/vm/tests/traits.rs:1165: replace test_contract_of_no_impl with ()
-clarity/src/vm/database/clarity_store.rs:231: replace <impl ClarityBackingStore for NullBackingStore>::get_with_proof -> Option<(String, Vec<u8>)> with Some(("xyzzy".into(), vec![1]))
-clarity/src/vm/tests/traits.rs:390: replace test_dynamic_dispatch_by_importing_trait with ()
-clarity/src/vm/costs/mod.rs:358: replace store_state_summary -> Result<()> with Ok(())
-clarity/src/vm/test_util/mod.rs:186: replace <impl HeadersDB for UnitTestHeaderDB>::get_burnchain_tokens_spent_for_winning_block -> Option<u128> with Some(1)
-clarity/src/vm/contracts.rs:57: replace Contract::canonicalize_types with ()
-clarity/src/vm/contexts.rs:479: replace AssetMap::get_fungible_tokens -> Option<u128> with Some(1)
-clarity/src/vm/tests/contracts.rs:685: replace test_simple_contract_call with ()
-clarity/src/vm/database/key_value_wrapper.rs:77: replace rollback_value_check with ()
-clarity/src/vm/database/clarity_store.rs:231: replace <impl ClarityBackingStore for NullBackingStore>::get_with_proof -> Option<(String, Vec<u8>)> with Some((String::new(), vec![0]))
-clarity/src/vm/database/clarity_store.rs:299: replace <impl ClarityBackingStore for MemoryBackingStore>::get_with_proof -> Option<(String, Vec<u8>)> with None
-clarity/src/vm/database/clarity_store.rs:247: replace <impl ClarityBackingStore for NullBackingStore>::get_open_chain_tip_height -> u32 with 1
-clarity/src/vm/database/clarity_db.rs:388: replace <impl BurnStateDB for NullBurnStateDB>::get_pox_rejection_fraction -> u64 with 0
-clarity/src/vm/database/clarity_store.rs:323: replace <impl ClarityBackingStore for MemoryBackingStore>::get_current_block_height -> u32 with 1
-clarity/src/vm/database/key_value_wrapper.rs:229: replace RollbackWrapper<'a>::get_cc_special_cases_handler -> Option<SpecialCaseHandler> with None
-clarity/src/vm/database/clarity_db.rs:298: replace <impl HeadersDB for NullHeadersDB>::get_burn_block_time_for_block -> Option<u64> with Some(1)
-clarity/src/vm/database/clarity_db.rs:252: replace <impl BurnStateDB for &dyn BurnStateDB>::get_pox_payout_addrs -> Option<(Vec<TupleData>, u128)> with None
-clarity/src/vm/database/clarity_db.rs:431: replace ClarityDatabase<'a>::is_stack_empty -> bool with true
-clarity/src/vm/representations.rs:121: replace <impl StacksMessageCodec for ContractName>::consensus_serialize -> Result<(), codec_error> with Ok(())
-clarity/src/vm/analysis/contract_interface_builder/mod.rs:307: replace ContractInterfaceFungibleTokens::from_set -> Vec<Self> with vec![]
-clarity/src/vm/database/clarity_store.rs:255: replace <impl ClarityBackingStore for NullBackingStore>::put_all with ()
-clarity/src/vm/contexts.rs:893: replace <impl CostTracker for Environment<'_, '_, '_>>::short_circuit_contract_call -> std::result::Result<bool, CostErrors> with Ok(true)
-clarity/src/vm/test_util/mod.rs:232: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_pox_3_activation_height -> u32 with 1
-clarity/src/vm/ast/parser/v2/mod.rs:167: replace Parser<'a>::skip_to_end with ()
-clarity/src/vm/database/clarity_db.rs:326: replace <impl HeadersDB for NullHeadersDB>::get_tokens_earned_for_block -> Option<u128> with None
-clarity/src/vm/database/structures.rs:463: replace STXBalanceSnapshot<'db, 'conn>::is_v2_locked -> bool with false
-clarity/src/vm/database/clarity_db.rs:943: replace ClarityDatabase<'a>::get_burnchain_block_height -> Option<u32> with Some(1)
-clarity/src/vm/tests/contracts.rs:992: replace test_at_unknown_block with ()
-clarity/src/vm/coverage.rs:104: replace CoverageReporter::executable_lines -> Vec<u32> with vec![]
-clarity/src/vm/types/serialization.rs:102: replace <impl Error for SerializationError>::source -> Option<&(dyn error::Error +'static)> with None
-clarity/src/vm/representations.rs:81: replace <impl StacksMessageCodec for ClarityName>::consensus_serialize -> Result<(), codec_error> with Ok(())
-clarity/src/vm/database/clarity_db.rs:1951: replace ClarityDatabase<'a>::get_burn_block_height -> Option<u32> with Some(0)
-clarity/src/vm/test_util/mod.rs:263: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_pox_payout_addrs -> Option<(Vec<TupleData>, u128)> with Some((vec![], 1))
-clarity/src/vm/database/clarity_store.rs:227: replace <impl ClarityBackingStore for NullBackingStore>::get -> Option<String> with Some("xyzzy".into())
-clarity/src/vm/test_util/mod.rs:228: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_v2_unlock_height -> u32 with 1
-clarity/src/vm/database/clarity_db.rs:384: replace <impl BurnStateDB for NullBurnStateDB>::get_pox_reward_cycle_length -> u32 with 1
-clarity/src/vm/tests/traits.rs:89: replace test_dynamic_dispatch_pass_trait_nested_in_let with ()
-clarity/src/vm/errors.rs:114: replace <impl PartialEq for IncomparableError<T>>::eq -> bool with true
-clarity/src/vm/callables.rs:370: replace DefinedFunction::get_span -> Span with Default::default()
-clarity/src/vm/database/clarity_store.rs:177: replace make_contract_hash_key -> String with String::new()
-clarity/src/vm/database/clarity_db.rs:768: replace ClarityDatabase<'a>::decrement_ustx_liquid_supply -> Result<()> with Ok(())
-clarity/src/vm/contexts.rs:1507: replace Environment<'a, 'b, 'hooks>::register_nft_burn_event -> Result<()> with Ok(())
-clarity/src/vm/database/structures.rs:680: replace STXBalanceSnapshot<'db, 'conn>::is_v3_locked -> bool with false
-clarity/src/vm/database/clarity_db.rs:592: replace ClarityDatabase<'a>::set_metadata with ()
-clarity/src/vm/database/clarity_db.rs:213: replace <impl BurnStateDB for &dyn BurnStateDB>::get_burn_start_height -> u32 with 0
-clarity/src/vm/analysis/errors.rs:443: replace <impl DiagnosableError for CheckErrors>::suggestion -> Option<String> with None
-clarity/src/vm/costs/mod.rs:282: replace <impl Debug for LimitedCostTracker>::fmt -> fmt::Result with Ok(Default::default())
-clarity/src/vm/database/clarity_db.rs:463: replace ClarityDatabase<'a>::put_with_size -> u64 with 0
-clarity/src/vm/types/mod.rs:1268: replace <impl Debug for BuffData>::fmt -> fmt::Result with Ok(Default::default())
-clarity/src/vm/ast/parser/v1.rs:108: replace get_lines_at -> Vec<usize> with vec![]
-clarity/src/vm/representations.rs:388: replace PreSymbolicExpression::match_placeholder -> Option<&str> with Some("xyzzy")
-clarity/src/vm/database/clarity_db.rs:323: replace <impl HeadersDB for NullHeadersDB>::get_burnchain_tokens_spent_for_winning_block -> Option<u128> with Some(1)
-clarity/src/vm/database/clarity_db.rs:184: replace <impl HeadersDB for &dyn HeadersDB>::get_tokens_earned_for_block -> Option<u128> with Some(0)
-clarity/src/vm/database/structures.rs:971: replace STXBalance::was_locked_by_v1 -> bool with true
-clarity/src/vm/tests/traits.rs:1036: replace test_dynamic_dispatch_pass_literal_principal_as_trait_in_user_defined_functions with ()
-clarity/src/vm/database/clarity_db.rs:1878: replace ClarityDatabase<'a>::make_key_for_account_nonce -> String with String::new()
-clarity/src/vm/costs/mod.rs:934: replace add_cost -> std::result::Result<(), CostErrors> with Ok(())
-clarity/src/vm/test_util/mod.rs:125: replace <impl HeadersDB for UnitTestHeaderDB>::get_burn_header_hash_for_block -> Option<BurnchainHeaderHash> with None
-clarity/src/vm/contexts.rs:1429: replace Environment<'a, 'b, 'hooks>::register_print_event -> Result<()> with Ok(())
-clarity/src/vm/contexts.rs:1445: replace Environment<'a, 'b, 'hooks>::register_stx_transfer_event -> Result<()> with Ok(())
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:93: replace <impl CostTracker for TypeChecker<'_, '_>>::add_memory -> std::result::Result<(), CostErrors> with Ok(())
-clarity/src/vm/coverage.rs:54: replace CoverageReporter::report_eval with ()
-clarity/src/vm/types/mod.rs:1026: replace Value::expect_ascii -> String with "xyzzy".into()
-clarity/src/vm/events.rs:272: replace NFTBurnEventData::json_serialize -> serde_json::Value with Default::default()
-clarity/src/vm/test_util/mod.rs:244: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_pox_rejection_fraction -> u64 with 1
-clarity/src/vm/types/mod.rs:1044: replace Value::expect_i128 -> i128 with -1
-clarity/src/vm/tests/traits.rs:1397: replace test_pass_trait_to_subtrait with ()
-clarity/src/vm/contexts.rs:457: replace AssetMap::get_stx -> Option<u128> with Some(0)
-clarity/src/vm/database/clarity_db.rs:819: replace ClarityDatabase<'a>::get_v2_unlock_height -> u32 with 1
-clarity/src/vm/database/structures.rs:1047: replace STXBalance::has_unlockable_tokens_at_burn_block -> bool with true
-clarity/src/vm/tests/traits.rs:650: replace test_reentrant_dynamic_dispatch with ()
-clarity/src/vm/database/clarity_db.rs:716: replace ClarityDatabase<'a>::ustx_liquid_supply_key -> &'static str with ""
-clarity/src/vm/ast/parser/v2/mod.rs:1109: replace parse_collect_diagnostics -> (Vec<PreSymbolicExpression>, Vec<Diagnostic>, bool) with (vec![], vec![], true)
-clarity/src/vm/tests/traits.rs:262: replace test_dynamic_dispatch_by_implementing_imported_trait with ()
-clarity/src/vm/types/signatures.rs:1690: replace TypeSignature::type_size -> Result<u32> with Ok(1)
-clarity/src/vm/representations.rs:238: replace PreSymbolicExpression::set_span with ()
-clarity/src/vm/costs/mod.rs:270: replace LimitedCostTracker::cost_function_references -> HashMap<&'static ClarityCostFunction, ClarityCostFunctionReference> with HashMap::new()
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:98: replace <impl CostTracker for TypeChecker<'_, '_>>::add_memory -> std::result::Result<(), CostErrors> with Ok(())
-clarity/src/vm/callables.rs:119: replace <impl Display for FunctionIdentifier>::fmt -> fmt::Result with Ok(Default::default())
-clarity/src/vm/database/structures.rs:975: replace STXBalance::was_locked_by_v2 -> bool with true
-clarity/src/vm/database/clarity_db.rs:984: replace ClarityDatabase<'a>::get_block_reward -> Option<u128> with None
-clarity/src/vm/database/clarity_db.rs:178: replace <impl HeadersDB for &dyn HeadersDB>::get_burnchain_tokens_spent_for_block -> Option<u128> with Some(1)
-clarity/src/vm/database/clarity_db.rs:782: replace ClarityDatabase<'a>::is_in_regtest -> bool with true
-clarity/src/vm/version.rs:15: replace <impl Display for ClarityVersion>::fmt -> fmt::Result with Ok(Default::default())
-clarity/src/vm/tests/traits.rs:1528: replace test_pass_embedded_trait_to_subtrait_optional with ()
-clarity/src/vm/database/structures.rs:754: replace STXBalance::unlock_height -> u64 with 0
-clarity/src/vm/analysis/errors.rs:262: replace <impl Error for CheckError>::source -> Option<&(dyn error::Error +'static)> with None
-clarity/src/vm/types/mod.rs:1559: replace byte_len_of_serialization -> u64 with 1
-clarity/src/vm/contexts.rs:876: replace <impl CostTracker for Environment<'_, '_, '_>>::add_cost -> std::result::Result<(), CostErrors> with Ok(())
-clarity/src/vm/database/clarity_db.rs:659: replace ClarityDatabase<'a>::get_contract_size -> Result<u64> with Ok(1)
-clarity/src/vm/analysis/arithmetic_checker/mod.rs:72: replace ArithmeticOnlyChecker<'a>::check_contract_cost_eligible with ()
-clarity/src/vm/database/clarity_db.rs:1938: replace ClarityDatabase<'a>::get_account_nonce -> u64 with 0
-clarity/src/vm/callables.rs:105: replace cost_input_sized_vararg -> Result<u64> with Ok(1)
-clarity/src/vm/database/sqlite.rs:121: replace SqliteConnection::drop_metadata with ()
-clarity/src/vm/database/clarity_db.rs:317: replace <impl HeadersDB for NullHeadersDB>::get_burnchain_tokens_spent_for_block -> Option<u128> with Some(0)
-clarity/src/vm/contexts.rs:102: replace AssetMap::to_json -> serde_json::Value with Default::default()
-clarity/src/vm/test_util/mod.rs:191: replace <impl HeadersDB for UnitTestHeaderDB>::get_tokens_earned_for_block -> Option<u128> with Some(1)
-clarity/src/vm/types/mod.rs:1478: replace TupleData::len -> u64 with 0
-clarity/src/vm/database/clarity_db.rs:252: replace <impl BurnStateDB for &dyn BurnStateDB>::get_pox_payout_addrs -> Option<(Vec<TupleData>, u128)> with Some((vec![], 0))
-clarity/src/vm/clarity.rs:42: replace <impl Error for Error>::cause -> Option<&dyn std::error::Error> with None
-clarity/src/vm/database/sqlite.rs:110: replace SqliteConnection::commit_metadata_to with ()
-clarity/src/vm/database/structures.rs:376: replace STXBalanceSnapshot<'db, 'conn>::has_locked_tokens -> bool with true
-clarity/src/vm/events.rs:332: replace FTBurnEventData::json_serialize -> serde_json::Value with Default::default()
-clarity/src/mod.rs:96: replace version_string -> String with String::new()
-clarity/src/vm/database/sqlite.rs:192: replace SqliteConnection::check_schema -> Result<()> with Ok(())
-clarity/src/vm/test_util/mod.rs:181: replace <impl HeadersDB for UnitTestHeaderDB>::get_burnchain_tokens_spent_for_block -> Option<u128> with Some(0)
-clarity/src/vm/database/clarity_db.rs:1011: replace ClarityDatabase<'a>::set_stx_btc_ops_processed with ()
-clarity/src/vm/database/structures.rs:400: replace STXBalanceSnapshot<'db, 'conn>::debit with ()
-clarity/src/vm/database/clarity_db.rs:1882: replace ClarityDatabase<'a>::make_key_for_account_stx_locked -> String with "xyzzy".into()
-clarity/src/vm/database/sqlite.rs:72: replace sqlite_has_entry -> bool with true
-clarity/src/vm/tests/traits.rs:895: replace test_good_call_with_trait with ()
-clarity/src/vm/types/signatures.rs:1929: replace <impl Display for FunctionArg>::fmt -> fmt::Result with Ok(Default::default())
-clarity/src/vm/contexts.rs:461: replace AssetMap::get_stx_burned -> Option<u128> with Some(1)
-clarity/src/vm/database/clarity_db.rs:209: replace <impl BurnStateDB for &dyn BurnStateDB>::get_sortition_id_from_consensus_hash -> Option<SortitionId> with None
-clarity/src/vm/clarity.rs:27: replace <impl Display for Error>::fmt -> fmt::Result with Ok(Default::default())
-clarity/src/vm/database/clarity_db.rs:351: replace <impl BurnStateDB for NullBurnStateDB>::get_burn_header_hash -> Option<BurnchainHeaderHash> with None
-clarity/src/vm/test_util/mod.rs:206: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_burn_header_hash -> Option<BurnchainHeaderHash> with None
-clarity/src/vm/database/key_value_wrapper.rs:84: replace rollback_edits_push with ()
-clarity/src/vm/costs/mod.rs:832: replace LimitedCostTracker::get_memory_limit -> u64 with 1
-clarity/src/vm/database/clarity_db.rs:332: replace <impl BurnStateDB for NullBurnStateDB>::get_burn_block_height -> Option<u32> with Some(1)
-clarity/src/vm/tests/traits.rs:2092: replace test_pass_principal_literal_to_trait with ()
-clarity/src/vm/costs/mod.rs:1085: replace <impl Display for ExecutionCost>::fmt -> fmt::Result with Ok(Default::default())
-clarity/src/vm/database/clarity_store.rs:299: replace <impl ClarityBackingStore for MemoryBackingStore>::get_with_proof -> Option<(String, Vec<u8>)> with Some(("xyzzy".into(), vec![1]))
-clarity/src/vm/types/mod.rs:1090: replace Value::expect_bool -> bool with false
-clarity/src/vm/types/mod.rs:794: replace <impl PartialEq for ListData>::eq -> bool with true
-clarity/src/vm/ast/definition_sorter/mod.rs:425: replace Graph::has_node_descendants -> bool with true
-clarity/src/vm/database/clarity_db.rs:169: replace <impl HeadersDB for &dyn HeadersDB>::get_burn_block_time_for_block -> Option<u64> with Some(1)
-clarity/src/vm/database/clarity_db.rs:372: replace <impl BurnStateDB for NullBurnStateDB>::get_v2_unlock_height -> u32 with 0
-clarity/src/vm/representations.rs:388: replace PreSymbolicExpression::match_placeholder -> Option<&str> with Some("")
-clarity/src/vm/contexts.rs:909: replace <impl CostTracker for GlobalContext<'_, '_>>::add_cost -> std::result::Result<(), CostErrors> with Ok(())
-clarity/src/vm/contexts.rs:726: replace OwnedEnvironment<'a, 'hooks>::initialize_contract_from_ast -> Result<((), AssetMap, Vec<StacksTransactionEvent>)> with Ok(((), Default::default(), vec![]))
-clarity/src/vm/analysis/arithmetic_checker/mod.rs:60: replace <impl Error for Error>::source -> Option<&(dyn std::error::Error +'static)> with None
-clarity/src/vm/database/key_value_wrapper.rs:532: replace RollbackWrapper<'a>::has_metadata_entry -> bool with false
-clarity/src/vm/ast/parser/v2/lexer/error.rs:36: replace <impl DiagnosableError for LexerError>::message -> String with "xyzzy".into()
-clarity/src/vm/database/clarity_db.rs:380: replace <impl BurnStateDB for NullBurnStateDB>::get_pox_prepare_length -> u32 with 0
-clarity/src/vm/types/signatures.rs:1696: replace TypeSignature::inner_type_size -> Option<u32> with Some(1)
-clarity/src/vm/database/structures.rs:726: replace STXBalanceSnapshot<'db, 'conn>::unlock_available_tokens_if_any -> u128 with 0
-clarity/src/vm/types/serialization.rs:1338: replace <impl Hash for Value>::hash with ()
-clarity/src/vm/database/clarity_db.rs:225: replace <impl BurnStateDB for &dyn BurnStateDB>::get_stacks_epoch -> Option<StacksEpoch> with None
-clarity/src/vm/tests/traits.rs:963: replace test_good_call_2_with_trait with ()
-clarity/src/vm/types/mod.rs:1301: replace PrincipalData::version -> u8 with 1
-clarity/src/vm/representations.rs:610: replace SymbolicExpression::match_field -> Option<&TraitIdentifier> with None
-clarity/src/vm/analysis/errors.rs:443: replace <impl DiagnosableError for CheckErrors>::suggestion -> Option<String> with Some(String::new())
-clarity/src/vm/database/clarity_db.rs:541: replace ClarityDatabase<'a>::clarity_state_epoch_key -> &'static str with ""
-clarity/src/vm/database/clarity_db.rs:431: replace ClarityDatabase<'a>::is_stack_empty -> bool with false
-clarity/src/vm/costs/mod.rs:139: replace <impl CostTracker for ()>::add_cost -> std::result::Result<(), CostErrors> with Ok(())
-clarity/src/vm/representations.rs:602: replace SymbolicExpression::match_trait_reference -> Option<&ClarityName> with None
-clarity/src/vm/ast/errors.rs:113: replace ParseError::has_pre_expression -> bool with true
-clarity/src/vm/contexts.rs:461: replace AssetMap::get_stx_burned -> Option<u128> with Some(0)
-clarity/src/vm/database/key_value_wrapper.rs:420: replace RollbackWrapper<'a>::get_current_block_height -> u32 with 1
-clarity/src/vm/types/signatures.rs:69: replace AssetIdentifier::sugared -> String with String::new()
-clarity/src/vm/database/clarity_db.rs:541: replace ClarityDatabase<'a>::clarity_state_epoch_key -> &'static str with "xyzzy"
-clarity/src/vm/tests/traits.rs:147: replace test_dynamic_dispatch_pass_trait with ()
-clarity/src/vm/database/clarity_db.rs:380: replace <impl BurnStateDB for NullBurnStateDB>::get_pox_prepare_length -> u32 with 1
-clarity/src/vm/types/signatures.rs:1735: replace ListTypeData::type_size -> Option<u32> with Some(0)
-clarity/src/vm/database/clarity_db.rs:580: replace ClarityDatabase<'a>::get_contract_src -> Option<String> with None
-clarity/src/vm/database/clarity_store.rs:231: replace <impl ClarityBackingStore for NullBackingStore>::get_with_proof -> Option<(String, Vec<u8>)> with Some(("xyzzy".into(), vec![]))
-clarity/src/vm/test_util/mod.rs:240: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_pox_reward_cycle_length -> u32 with 1
-clarity/src/vm/database/clarity_db.rs:1006: replace ClarityDatabase<'a>::get_stx_btc_ops_processed -> u64 with 1
-clarity/src/vm/contexts.rs:918: replace <impl CostTracker for GlobalContext<'_, '_>>::reset_memory with ()
-clarity/src/vm/database/clarity_db.rs:984: replace ClarityDatabase<'a>::get_block_reward -> Option<u128> with Some(1)
-clarity/src/vm/ast/parser/v2/lexer/error.rs:67: replace <impl DiagnosableError for LexerError>::suggestion -> Option<String> with Some(String::new())
-clarity/src/vm/database/key_value_wrapper.rs:517: replace RollbackWrapper<'a>::has_entry -> bool with false
-clarity/src/vm/database/clarity_db.rs:1882: replace ClarityDatabase<'a>::make_key_for_account_stx_locked -> String with String::new()
-clarity/src/vm/database/clarity_db.rs:372: replace <impl BurnStateDB for NullBurnStateDB>::get_v2_unlock_height -> u32 with 1
-clarity/src/vm/types/signatures.rs:902: replace FixedFunction::total_type_size -> Result<u64> with Ok(0)
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:112: replace <impl CostTracker for TypeChecker<'_, '_>>::short_circuit_contract_call -> std::result::Result<bool, CostErrors> with Ok(true)
-clarity/src/vm/analysis/errors.rs:443: replace <impl DiagnosableError for CheckErrors>::suggestion -> Option<String> with Some("xyzzy".into())
-clarity/src/vm/database/clarity_db.rs:198: replace <impl BurnStateDB for &dyn BurnStateDB>::get_pox_3_activation_height -> u32 with 1
-clarity/src/vm/database/clarity_db.rs:368: replace <impl BurnStateDB for NullBurnStateDB>::get_v1_unlock_height -> u32 with 1
-clarity/src/vm/contexts.rs:879: replace <impl CostTracker for Environment<'_, '_, '_>>::add_memory -> std::result::Result<(), CostErrors> with Ok(())
-clarity/src/vm/database/structures.rs:754: replace STXBalance::unlock_height -> u64 with 1
-clarity/src/vm/test_util/mod.rs:224: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_v1_unlock_height -> u32 with 0
-clarity/src/vm/database/clarity_db.rs:190: replace <impl BurnStateDB for &dyn BurnStateDB>::get_v1_unlock_height -> u32 with 1
-clarity/src/vm/costs/mod.rs:104: replace <impl MemoryConsumer for Value>::get_memory_use -> u64 with 1
-clarity/src/vm/events.rs:41: replace StacksTransactionEvent::json_serialize -> serde_json::Value with Default::default()
-clarity/src/vm/database/structures.rs:975: replace STXBalance::was_locked_by_v2 -> bool with false
-clarity/src/vm/docs/mod.rs:809: replace get_signature -> Option<String> with None
-clarity/src/vm/representations.rs:388: replace PreSymbolicExpression::match_placeholder -> Option<&str> with None
-clarity/src/vm/test_util/mod.rs:198: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_burn_block_height -> Option<u32> with Some(1)
-clarity/src/vm/analysis/types.rs:147: replace ContractAnalysis::add_fungible_token with ()
-clarity/src/vm/test_util/mod.rs:263: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_pox_payout_addrs -> Option<(Vec<TupleData>, u128)> with Some((vec![], 0))
-clarity/src/vm/analysis/errors.rs:268: replace <impl Error for CheckErrors>::source -> Option<&(dyn error::Error +'static)> with None
-clarity/src/vm/types/mod.rs:1483: replace TupleData::is_empty -> bool with true
-clarity/src/vm/database/clarity_db.rs:233: replace <impl BurnStateDB for &dyn BurnStateDB>::get_pox_reward_cycle_length -> u32 with 1
-clarity/src/vm/database/structures.rs:386: replace STXBalanceSnapshot<'db, 'conn>::has_unlockable_tokens -> bool with false
-clarity/src/vm/database/clarity_db.rs:271: replace <impl HeadersDB for NullHeadersDB>::get_burn_header_hash_for_block -> Option<BurnchainHeaderHash> with None
-clarity/src/vm/test_util/mod.rs:181: replace <impl HeadersDB for UnitTestHeaderDB>::get_burnchain_tokens_spent_for_block -> Option<u128> with None
-clarity/src/vm/tests/assets.rs:821: replace test_total_supply with ()
-clarity/src/vm/tests/assets.rs:985: replace test_simple_naming_system with ()
-clarity/src/vm/costs/mod.rs:1153: replace ExecutionCost::proportion_dot_product -> u64 with 1
-clarity/src/vm/tests/traits.rs:1672: replace test_pass_embedded_trait_to_subtrait_err with ()
-clarity/src/vm/costs/mod.rs:303: replace <impl PartialEq for LimitedCostTracker>::eq -> bool with false
-clarity/src/vm/database/structures.rs:641: replace STXBalanceSnapshot<'db, 'conn>::increase_lock_v3 with ()
-clarity/src/vm/database/structures.rs:48: replace <impl ClarityDeserializable for String>::deserialize -> String with "xyzzy".into()
-clarity/src/vm/database/structures.rs:920: replace STXBalance::get_locked_balance_at_burn_block -> (u128, u64) with (1, 0)
-clarity/src/vm/tests/traits.rs:325: replace test_dynamic_dispatch_by_implementing_imported_trait_mul_funcs with ()
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:104: replace <impl CostTracker for TypeChecker<'_, '_>>::reset_memory with ()
-clarity/src/vm/database/clarity_db.rs:184: replace <impl HeadersDB for &dyn HeadersDB>::get_tokens_earned_for_block -> Option<u128> with Some(1)
-clarity/src/vm/database/clarity_db.rs:169: replace <impl HeadersDB for &dyn HeadersDB>::get_burn_block_time_for_block -> Option<u64> with None
-clarity/src/vm/database/clarity_db.rs:634: replace ClarityDatabase<'a>::fetch_metadata_manual -> Result<Option<T>> with Ok(None)
-clarity/src/vm/analysis/analysis_db.rs:84: replace AnalysisDatabase<'a>::has_contract -> bool with true
-clarity/src/vm/analysis/types.rs:183: replace ContractAnalysis::get_persisted_variable_type -> Option<&TypeSignature> with None
-clarity/src/vm/database/clarity_db.rs:813: replace ClarityDatabase<'a>::get_pox_3_activation_height -> u32 with 0
-clarity/src/vm/diagnostic.rs:56: replace Diagnostic::add_span with ()
-clarity/src/vm/costs/mod.rs:1153: replace ExecutionCost::proportion_dot_product -> u64 with 0
-clarity/src/vm/test_util/mod.rs:224: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_v1_unlock_height -> u32 with 1
-clarity/src/vm/database/sqlite.rs:153: replace SqliteConnection::has_entry -> bool with true
-clarity/src/vm/database/clarity_db.rs:332: replace <impl BurnStateDB for NullBurnStateDB>::get_burn_block_height -> Option<u32> with None
-clarity/src/vm/contexts.rs:926: replace <impl CostTracker for GlobalContext<'_, '_>>::short_circuit_contract_call -> std::result::Result<bool, CostErrors> with Ok(true)
-clarity/src/vm/contexts.rs:1878: replace LocalContext<'a>::depth -> u16 with 0
-clarity/src/vm/ast/parser/v2/lexer/error.rs:36: replace <impl DiagnosableError for LexerError>::message -> String with String::new()
-clarity/src/vm/types/signatures.rs:139: replace SequenceSubtype::is_list_type -> bool with false
-clarity/src/vm/contexts.rs:457: replace AssetMap::get_stx -> Option<u128> with None
-clarity/src/vm/test_util/mod.rs:135: replace <impl HeadersDB for UnitTestHeaderDB>::get_vrf_seed_for_block -> Option<VRFSeed> with None
-clarity/src/vm/types/signatures.rs:1690: replace TypeSignature::type_size -> Result<u32> with Ok(0)
-clarity/src/vm/database/clarity_db.rs:973: replace ClarityDatabase<'a>::get_miner_spend_total -> u128 with 1
-clarity/src/vm/costs/mod.rs:826: replace LimitedCostTracker::get_memory -> u64 with 1
-clarity/src/vm/types/signatures.rs:853: replace TupleTypeSignature::is_empty -> bool with false
-clarity/src/vm/ast/parser/v1.rs:108: replace get_lines_at -> Vec<usize> with vec![1]
-clarity/src/vm/database/structures.rs:988: replace STXBalance::has_locked_tokens_at_burn_block -> bool with false
-clarity/src/vm/types/serialization.rs:1325: replace <impl StacksMessageCodec for Value>::consensus_serialize -> Result<(), codec_error> with Ok(())
-clarity/src/vm/types/signatures.rs:1766: replace TupleTypeSignature::size -> u32 with 0
-clarity/src/vm/test_util/mod.rs:88: replace is_err_code_i128 -> bool with true
-clarity/src/vm/contexts.rs:856: replace OwnedEnvironment<'a, 'hooks>::add_eval_hook with ()
-clarity/src/vm/types/signatures.rs:1748: replace TupleTypeSignature::type_size -> Option<u32> with Some(1)
-clarity/src/vm/database/clarity_db.rs:181: replace <impl HeadersDB for &dyn HeadersDB>::get_burnchain_tokens_spent_for_winning_block -> Option<u128> with Some(1)
-clarity/src/vm/database/clarity_db.rs:184: replace <impl HeadersDB for &dyn HeadersDB>::get_tokens_earned_for_block -> Option<u128> with None
-clarity/src/vm/contexts.rs:1472: replace Environment<'a, 'b, 'hooks>::register_nft_transfer_event -> Result<()> with Ok(())
-clarity/src/vm/database/structures.rs:767: replace STXBalance::effective_unlock_height -> u64 with 0
-clarity/src/vm/docs/contracts.rs:178: replace produce_docs_refs -> BTreeMap<String, ContractRef> with BTreeMap::new()
-clarity/src/vm/ast/errors.rs:296: replace <impl DiagnosableError for ParseErrors>::suggestion -> Option<String> with None
-clarity/src/vm/database/structures.rs:790: replace STXBalance::amount_locked -> u128 with 0
-clarity/src/vm/analysis/analysis_db.rs:70: replace AnalysisDatabase<'a>::storage_key -> &'static str with "xyzzy"
-clarity/src/vm/ast/errors.rs:141: replace <impl Error for ParseError>::source -> Option<&(dyn error::Error +'static)> with None
-clarity/src/vm/types/mod.rs:1044: replace Value::expect_i128 -> i128 with 1
-clarity/src/vm/costs/mod.rs:1012: replace <impl CostTracker for LimitedCostTracker>::reset_memory with ()
-clarity/src/vm/representations.rs:483: replace SymbolicExpression::set_span with ()
-clarity/src/vm/database/clarity_db.rs:281: replace <impl HeadersDB for NullHeadersDB>::get_vrf_seed_for_block -> Option<VRFSeed> with None
-clarity/src/vm/costs/mod.rs:950: replace add_memory -> std::result::Result<(), CostErrors> with Ok(())
-clarity/src/vm/database/structures.rs:971: replace STXBalance::was_locked_by_v1 -> bool with false
-clarity/src/vm/test_util/mod.rs:160: replace <impl HeadersDB for UnitTestHeaderDB>::get_burn_block_height_for_block -> Option<u32> with Some(1)
-clarity/src/vm/tests/traits.rs:1891: replace test_pass_embedded_trait_to_subtrait_option_list with ()
-clarity/src/vm/tests/contracts.rs:247: replace tx_sponsor_contract_asserts with ()
-clarity/src/vm/database/clarity_db.rs:237: replace <impl BurnStateDB for &dyn BurnStateDB>::get_pox_rejection_fraction -> u64 with 1
-clarity/src/vm/tests/traits.rs:536: replace test_dynamic_dispatch_mismatched_args with ()
-clarity/src/vm/analysis/types.rs:175: replace ContractAnalysis::get_map_type -> Option<&(TypeSignature, TypeSignature)> with None
-clarity/src/vm/database/clarity_store.rs:299: replace <impl ClarityBackingStore for MemoryBackingStore>::get_with_proof -> Option<(String, Vec<u8>)> with Some((String::new(), vec![0]))
-clarity/src/vm/database/clarity_db.rs:832: replace ClarityDatabase<'a>::get_current_burnchain_block_height -> u32 with 1
-clarity/src/vm/costs/mod.rs:1219: replace ExecutionCost::multiply -> Result<()> with Ok(())
-clarity/src/vm/costs/mod.rs:303: replace <impl PartialEq for LimitedCostTracker>::eq -> bool with true
-clarity/src/vm/database/clarity_db.rs:1019: replace ClarityDatabase<'a>::make_microblock_pubkey_height_key -> String with String::new()
-clarity/src/vm/database/clarity_store.rs:231: replace <impl ClarityBackingStore for NullBackingStore>::get_with_proof -> Option<(String, Vec<u8>)> with Some((String::new(), vec![]))
-clarity/src/vm/ast/types.rs:63: replace ContractAST::add_implemented_trait with ()
-clarity/src/vm/database/structures.rs:920: replace STXBalance::get_locked_balance_at_burn_block -> (u128, u64) with (0, 1)
-clarity/src/vm/test_util/mod.rs:141: replace <impl HeadersDB for UnitTestHeaderDB>::get_stacks_block_header_hash_for_block -> Option<BlockHeaderHash> with None
-clarity/src/vm/database/clarity_db.rs:802: replace ClarityDatabase<'a>::get_current_block_height -> u32 with 1
-clarity/src/vm/ast/errors.rs:122: replace ParseError::set_pre_expressions with ()
-clarity/src/vm/database/clarity_db.rs:813: replace ClarityDatabase<'a>::get_pox_3_activation_height -> u32 with 1
-clarity/src/vm/tests/traits.rs:34: replace test_dynamic_dispatch_by_defining_trait with ()
-clarity/src/vm/analysis/types.rs:143: replace ContractAnalysis::add_non_fungible_token with ()
-clarity/src/vm/test_util/mod.rs:240: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_pox_reward_cycle_length -> u32 with 0
-clarity/src/vm/errors.rs:157: replace <impl Error for Error>::source -> Option<&(dyn error::Error +'static)> with None
-clarity/src/vm/database/clarity_db.rs:808: replace ClarityDatabase<'a>::get_v1_unlock_height -> u32 with 0
-clarity/src/vm/database/clarity_db.rs:1951: replace ClarityDatabase<'a>::get_burn_block_height -> Option<u32> with Some(1)
-clarity/src/vm/docs/mod.rs:809: replace get_signature -> Option<String> with Some(String::new())
-clarity/src/vm/database/key_value_wrapper.rs:150: replace <impl From for RollbackWrapperPersistedLog>::from -> RollbackWrapperPersistedLog with Default::default()
-clarity/src/vm/database/structures.rs:1047: replace STXBalance::has_unlockable_tokens_at_burn_block -> bool with false
-clarity/src/vm/test_util/mod.rs:210: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_stacks_epoch -> Option<StacksEpoch> with None
-clarity/src/vm/costs/mod.rs:1056: replace <impl CostTracker for &mut LimitedCostTracker>::add_memory -> std::result::Result<(), CostErrors> with Ok(())
-clarity/src/vm/database/key_value_wrapper.rs:354: replace RollbackWrapper<'a>::get_with_proof -> Option<(T, Vec<u8>)> with None
-clarity/src/vm/tests/traits.rs:593: replace test_dynamic_dispatch_mismatched_returned with ()
-clarity/src/vm/database/clarity_db.rs:198: replace <impl BurnStateDB for &dyn BurnStateDB>::get_pox_3_activation_height -> u32 with 0
-clarity/src/vm/test_util/mod.rs:172: replace <impl HeadersDB for UnitTestHeaderDB>::get_consensus_hash_for_block -> Option<ConsensusHash> with None
-clarity/src/vm/types/signatures.rs:1771: replace TupleTypeSignature::max_depth -> u8 with 0
-clarity/src/vm/types/mod.rs:1071: replace Value::expect_list -> Vec<Value> with vec![]
-clarity/src/vm/representations.rs:258: replace PreSymbolicExpression::copy_span with ()
-clarity/src/vm/tests/contracts.rs:369: replace test_fully_qualified_contract_call with ()
-clarity/src/vm/events.rs:223: replace NFTTransferEventData::json_serialize -> serde_json::Value with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:101: replace <impl CostTracker for TypeChecker<'_, '_>>::drop_memory with ()
-clarity/src/vm/database/structures.rs:463: replace STXBalanceSnapshot<'db, 'conn>::is_v2_locked -> bool with true
-clarity/src/vm/costs/mod.rs:832: replace LimitedCostTracker::get_memory_limit -> u64 with 0
-clarity/src/vm/types/signatures.rs:1771: replace TupleTypeSignature::max_depth -> u8 with 1
-clarity/src/vm/types/serialization.rs:78: replace <impl Display for SerializationError>::fmt -> std::fmt::Result with Ok(Default::default())
-clarity/src/vm/tests/assets.rs:935: replace test_overlapping_nfts with ()
-clarity/src/vm/database/structures.rs:538: replace STXBalanceSnapshot<'db, 'conn>::lock_tokens_v2 with ()
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:107: replace <impl CostTracker for TypeChecker<'_, '_>>::short_circuit_contract_call -> std::result::Result<bool, CostErrors> with Ok(false)
-clarity/src/vm/events.rs:348: replace SmartContractEventData::json_serialize -> serde_json::Value with Default::default()
-clarity/src/vm/costs/mod.rs:716: replace LimitedCostTracker::default_cost_contract_for_epoch -> String with "xyzzy".into()
-clarity/src/vm/tests/traits.rs:1600: replace test_pass_embedded_trait_to_subtrait_ok with ()
-clarity/src/vm/types/signatures.rs:139: replace SequenceSubtype::is_list_type -> bool with true
-clarity/src/vm/database/clarity_db.rs:166: replace <impl HeadersDB for &dyn HeadersDB>::get_vrf_seed_for_block -> Option<VRFSeed> with None
-clarity/src/vm/database/clarity_store.rs:247: replace <impl ClarityBackingStore for NullBackingStore>::get_open_chain_tip_height -> u32 with 0
-clarity/src/vm/test_util/mod.rs:191: replace <impl HeadersDB for UnitTestHeaderDB>::get_tokens_earned_for_block -> Option<u128> with None
-clarity/src/vm/database/clarity_db.rs:1886: replace ClarityDatabase<'a>::make_key_for_account_unlock_height -> String with String::new()
-clarity/src/vm/coverage.rs:78: replace CoverageReporter::to_file -> std::io::Result<()> with Ok(())
-clarity/src/vm/tests/traits.rs:1100: replace test_contract_of_value with ()
-clarity/src/vm/database/structures.rs:616: replace STXBalanceSnapshot<'db, 'conn>::extend_lock_v3 with ()
-clarity/src/vm/database/clarity_db.rs:287: replace <impl HeadersDB for NullHeadersDB>::get_stacks_block_header_hash_for_block -> Option<BlockHeaderHash> with None
-clarity/src/vm/database/clarity_db.rs:181: replace <impl HeadersDB for &dyn HeadersDB>::get_burnchain_tokens_spent_for_winning_block -> Option<u128> with Some(0)
-clarity/src/vm/contexts.rs:882: replace <impl CostTracker for Environment<'_, '_, '_>>::drop_memory with ()
-clarity/src/vm/representations.rs:464: replace SymbolicExpression::cons -> SymbolicExpression with Default::default()
-clarity/src/vm/test_util/mod.rs:263: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_pox_payout_addrs -> Option<(Vec<TupleData>, u128)> with None
-clarity/src/vm/test_util/mod.rs:181: replace <impl HeadersDB for UnitTestHeaderDB>::get_burnchain_tokens_spent_for_block -> Option<u128> with Some(1)
-clarity/src/vm/database/clarity_db.rs:699: replace ClarityDatabase<'a>::has_contract -> bool with false
-clarity/src/vm/test_util/mod.rs:186: replace <impl HeadersDB for UnitTestHeaderDB>::get_burnchain_tokens_spent_for_winning_block -> Option<u128> with Some(0)
-clarity/src/vm/costs/mod.rs:1025: replace <impl CostTracker for LimitedCostTracker>::short_circuit_contract_call -> Result<bool> with Ok(true)
-clarity/src/vm/events.rs:297: replace FTTransferEventData::json_serialize -> serde_json::Value with Default::default()
-clarity/src/vm/types/signatures.rs:853: replace TupleTypeSignature::is_empty -> bool with true
-clarity/src/vm/tests/assets.rs:138: replace test_native_stx_ops with ()
-clarity/src/vm/database/clarity_db.rs:808: replace ClarityDatabase<'a>::get_v1_unlock_height -> u32 with 1
-clarity/src/vm/database/clarity_db.rs:202: replace <impl BurnStateDB for &dyn BurnStateDB>::get_burn_block_height -> Option<u32> with Some(1)
-clarity/src/vm/contexts.rs:885: replace <impl CostTracker for Environment<'_, '_, '_>>::reset_memory with ()
-clarity/src/vm/costs/mod.rs:89: replace analysis_typecheck_cost -> Result<()> with Ok(())
-clarity/src/vm/database/clarity_db.rs:252: replace <impl BurnStateDB for &dyn BurnStateDB>::get_pox_payout_addrs -> Option<(Vec<TupleData>, u128)> with Some((vec![], 1))
-clarity/src/vm/types/mod.rs:554: replace <impl Debug for CharType>::fmt -> fmt::Result with Ok(Default::default())
-clarity/src/vm/database/structures.rs:472: replace STXBalanceSnapshot<'db, 'conn>::increase_lock_v2 with ()
-clarity/src/vm/costs/mod.rs:1025: replace <impl CostTracker for LimitedCostTracker>::short_circuit_contract_call -> Result<bool> with Ok(false)
-clarity/src/vm/costs/mod.rs:1196: replace ExecutionCost::add_runtime -> Result<()> with Ok(())
-clarity/src/vm/tests/contracts.rs:1116: replace test_cc_trait_stack_depth with ()
-clarity/src/vm/docs/contracts.rs:69: replace doc_execute -> Result<Option<Value>, vm::Error> with Ok(None)
-clarity/src/vm/database/clarity_db.rs:157: replace <impl HeadersDB for &dyn HeadersDB>::get_stacks_block_header_hash_for_block -> Option<BlockHeaderHash> with None
-clarity/src/vm/database/clarity_db.rs:364: replace <impl BurnStateDB for NullBurnStateDB>::get_stacks_epoch_by_epoch_id -> Option<StacksEpoch> with None
-clarity/src/vm/database/clarity_db.rs:202: replace <impl BurnStateDB for &dyn BurnStateDB>::get_burn_block_height -> Option<u32> with None
-clarity/src/vm/ast/parser/v2/lexer/token.rs:82: replace Token::reproduce -> String with String::new()
-clarity/src/vm/database/clarity_store.rs:299: replace <impl ClarityBackingStore for MemoryBackingStore>::get_with_proof -> Option<(String, Vec<u8>)> with Some((String::new(), vec![]))
-clarity/src/vm/tests/traits.rs:1289: replace test_return_trait_with_contract_of_wrapped_in_let with ()
-clarity/src/vm/costs/mod.rs:1000: replace <impl CostTracker for LimitedCostTracker>::add_memory -> std::result::Result<(), CostErrors> with Ok(())
-clarity/src/vm/contexts.rs:1458: replace Environment<'a, 'b, 'hooks>::register_stx_burn_event -> Result<()> with Ok(())
-clarity/src/vm/database/clarity_db.rs:326: replace <impl HeadersDB for NullHeadersDB>::get_tokens_earned_for_block -> Option<u128> with Some(0)
-clarity/src/vm/database/clarity_db.rs:1886: replace ClarityDatabase<'a>::make_key_for_account_unlock_height -> String with "xyzzy".into()
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:107: replace <impl CostTracker for TypeChecker<'_, '_>>::short_circuit_contract_call -> std::result::Result<bool, CostErrors> with Ok(true)
-clarity/src/vm/database/clarity_db.rs:1019: replace ClarityDatabase<'a>::make_microblock_pubkey_height_key -> String with "xyzzy".into()
-clarity/src/vm/contexts.rs:1784: replace GlobalContext<'a, 'hooks>::destruct -> Option<(ClarityDatabase<'a>, LimitedCostTracker)> with None
-clarity/src/mod.rs:96: replace version_string -> String with "xyzzy".into()
-clarity/src/vm/test_util/mod.rs:149: replace <impl HeadersDB for UnitTestHeaderDB>::get_burn_block_time_for_block -> Option<u64> with None
-clarity/src/vm/contexts.rs:705: replace OwnedEnvironment<'a, 'hooks>::initialize_versioned_contract -> Result<((), AssetMap, Vec<StacksTransactionEvent>)> with Ok(((), Default::default(), vec![]))
-clarity/src/vm/database/structures.rs:424: replace STXBalanceSnapshot<'db, 'conn>::lock_tokens_v1 with ()
-clarity/src/vm/test_util/mod.rs:149: replace <impl HeadersDB for UnitTestHeaderDB>::get_burn_block_time_for_block -> Option<u64> with Some(0)
-clarity/src/vm/database/structures.rs:376: replace STXBalanceSnapshot<'db, 'conn>::has_locked_tokens -> bool with false
-clarity/src/vm/types/signatures.rs:1696: replace TypeSignature::inner_type_size -> Option<u32> with Some(0)
-clarity/src/vm/contexts.rs:490: replace AssetMap::get_nonfungible_tokens -> Option<&Vec<Value>> with None
-clarity/src/vm/types/mod.rs:1090: replace Value::expect_bool -> bool with true
-clarity/src/vm/database/key_value_wrapper.rs:517: replace RollbackWrapper<'a>::has_entry -> bool with true
-clarity/src/vm/database/clarity_db.rs:1943: replace ClarityDatabase<'a>::set_account_nonce with ()
-clarity/src/vm/test_util/mod.rs:198: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_burn_block_height -> Option<u32> with Some(0)
-clarity/src/vm/database/clarity_db.rs:860: replace ClarityDatabase<'a>::get_block_time -> u64 with 1
-clarity/src/vm/contexts.rs:1543: replace Environment<'a, 'b, 'hooks>::register_ft_mint_event -> Result<()> with Ok(())
-clarity/src/vm/costs/mod.rs:994: replace <impl CostTracker for LimitedCostTracker>::add_cost -> std::result::Result<(), CostErrors> with Ok(())
-clarity/src/vm/database/clarity_db.rs:395: replace <impl BurnStateDB for NullBurnStateDB>::get_pox_payout_addrs -> Option<(Vec<TupleData>, u128)> with Some((vec![], 0))
-clarity/src/vm/events.rs:248: replace NFTMintEventData::json_serialize -> serde_json::Value with Default::default()
-clarity/src/vm/tests/contracts.rs:1018: replace test_as_max_len with ()
-clarity/src/vm/coverage.rs:170: replace CoverageReporter::register_src_file -> std::io::Result<()> with Ok(())
-clarity/src/vm/database/clarity_db.rs:1957: replace ClarityDatabase<'a>::get_stacks_epoch -> Option<StacksEpoch> with None
-clarity/src/vm/types/mod.rs:256: replace SequenceData::element_size -> u32 with 1
-clarity/src/vm/database/clarity_db.rs:533: replace ClarityDatabase<'a>::make_key_for_trip -> String with "xyzzy".into()
-clarity/src/vm/test_util/mod.rs:247: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_burn_start_height -> u32 with 1
-clarity/src/vm/types/mod.rs:1201: replace ListData::is_empty -> bool with true
-clarity/src/vm/database/clarity_store.rs:299: replace <impl ClarityBackingStore for MemoryBackingStore>::get_with_proof -> Option<(String, Vec<u8>)> with Some(("xyzzy".into(), vec![]))
-clarity/src/vm/costs/mod.rs:1137: replace ExecutionCost::proportion_largest_dimension -> u64 with 1
-clarity/src/vm/database/clarity_db.rs:525: replace ClarityDatabase<'a>::get_with_proof -> Option<(T, Vec<u8>)> with None
-clarity/src/vm/database/structures.rs:680: replace STXBalanceSnapshot<'db, 'conn>::is_v3_locked -> bool with true
diff --git a/mutation-testing/packages-output/clarity/timeout.txt b/mutation-testing/packages-output/clarity/timeout.txt
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/mutation-testing/packages-output/clarity/unviable.txt b/mutation-testing/packages-output/clarity/unviable.txt
deleted file mode 100644
index 819f07c57f..0000000000
--- a/mutation-testing/packages-output/clarity/unviable.txt
+++ /dev/null
@@ -1,1791 +0,0 @@
-clarity/src/vm/ast/parser/v1.rs:101: replace get_value_or_err -> ParseResult<String> with ParseResult::from_iter([String::new()])
-clarity/src/vm/contexts.rs:801: replace OwnedEnvironment<'a, 'hooks>::eval_raw -> Result<(Value, AssetMap, Vec<StacksTransactionEvent>)> with Ok((Default::default(), Default::default(), vec![]))
-clarity/src/vm/callables.rs:376: replace CallableType::get_identifier -> FunctionIdentifier with Default::default()
-clarity/src/vm/ast/parser/v2/mod.rs:1109: replace parse_collect_diagnostics -> (Vec<PreSymbolicExpression>, Vec<Diagnostic>, bool) with (vec![Default::default()], vec![], false)
-clarity/src/vm/ast/parser/v1.rs:192: replace inner_lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::new()
-clarity/src/vm/ast/parser/v2/mod.rs:219: replace Parser<'a>::handle_open_node -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::new()
-clarity/src/vm/callables.rs:144: replace DefinedFunction::execute_apply -> Result<Value> with Ok(Default::default())
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:160: replace Lexer<'a>::proceed_through_error -> LexResult<String> with LexResult::from_iter(["xyzzy".into()])
-clarity/src/vm/ast/parser/v2/mod.rs:219: replace Parser<'a>::handle_open_node -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::from_iter([Some(Default::default())])
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:78: replace Lexer<'a>::read_char -> LexResult<()> with LexResult::from_iter([()])
-clarity/src/vm/functions/arithmetic.rs:504: replace special_greater -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:111: replace Lexer<'a>::report_line_ending -> LexResult<()> with LexResult::from_iter([()])
-clarity/src/vm/ast/definition_sorter/mod.rs:115: replace DefinitionSorter::probe_for_dependencies -> ParseResult<()> with ParseResult::new(())
-clarity/src/vm/ast/parser/v2/mod.rs:1093: replace parse -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::from_iter([vec![Default::default()]])
-clarity/src/vm/test_util/mod.rs:172: replace <impl HeadersDB for UnitTestHeaderDB>::get_consensus_hash_for_block -> Option<ConsensusHash> with Some(Default::default())
-clarity/src/vm/ast/definition_sorter/mod.rs:456: replace GraphWalker::get_sorted_dependencies -> ParseResult<Vec<usize>> with ParseResult::from(vec![])
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1346: replace TypeChecker<'a, 'b>::type_check_define_variable -> CheckResult<(ClarityName, TypeSignature)> with CheckResult::from_iter([(Default::default(), Default::default())])
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:326: replace Lexer<'a>::read_integer -> LexResult<Token> with LexResult::from(Default::default())
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:136: replace ContractContext::add_variable_type -> CheckResult<()> with CheckResult::from_iter([()])
-clarity/src/vm/types/mod.rs:1415: replace <impl From for Value>::from -> Self with Default::default()
-clarity/src/vm/analysis/analysis_db.rs:189: replace AnalysisDatabase<'a>::get_defined_trait -> CheckResult<Option<BTreeMap<ClarityName, FunctionSignature>>> with CheckResult::new(None)
-clarity/src/vm/functions/arithmetic.rs:557: replace native_sub -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
-clarity/src/vm/docs/contracts.rs:48: replace make_func_ref -> FunctionRef with Default::default()
-clarity/src/vm/types/signatures.rs:1301: replace TypeSignature::list_of -> Result<TypeSignature> with Ok(Default::default())
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:740: replace TypeChecker<'a, 'b>::type_check_define_variable -> CheckResult<(ClarityName, TypeSignature)> with CheckResult::new()
-clarity/src/vm/ast/parser/v1.rs:720: replace parse -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::new()
-clarity/src/vm/functions/arithmetic.rs:47: replace I128Ops::make_value -> InterpreterResult<Value> with InterpreterResult::new()
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:145: replace FunctionType::check_args_2_05 -> CheckResult<TypeSignature> with CheckResult::new(Default::default())
-clarity/src/vm/analysis/type_checker/mod.rs:45: replace FunctionType::check_args -> CheckResult<TypeSignature> with CheckResult::new(Default::default())
-clarity/src/vm/ast/mod.rs:288: replace build_ast_precheck_size -> ParseResult<ContractAST> with ParseResult::from_iter([Default::default()])
-clarity/src/vm/analysis/type_checker/v2_05/natives/sequences.rs:296: replace check_special_as_max_len -> TypeResult with Default::default()
-clarity/src/vm/ast/traits_resolver/mod.rs:201: replace TraitsResolver::probe_for_generics -> ParseResult<()> with ParseResult::new(())
-clarity/src/vm/ast/definition_sorter/mod.rs:456: replace GraphWalker::get_sorted_dependencies -> ParseResult<Vec<usize>> with ParseResult::new(vec![])
-clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs:479: replace check_principal_of -> TypeResult with Default::default()
-clarity/src/vm/costs/mod.rs:270: replace LimitedCostTracker::cost_function_references -> HashMap<&'static ClarityCostFunction, ClarityCostFunctionReference> with HashMap::from_iter([(&Default::default(), Default::default())])
-clarity/src/vm/ast/parser/v1.rs:455: replace lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::from_iter([vec![(Default::default(), 0, 0)]])
-clarity/src/vm/database/clarity_db.rs:947: replace ClarityDatabase<'a>::get_block_vrf_seed -> VRFSeed with Default::default()
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:474: replace Lexer<'a>::read_utf8_encoding -> LexResult<Result<String, String>> with LexResult::new(Ok(String::new()))
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:186: replace ContractContext::check_function_type -> CheckResult<()> with CheckResult::from_iter([()])
-clarity/src/vm/ast/expression_identifier/mod.rs:23: replace inner_relabel -> ParseResult<u64> with ParseResult::from(0)
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:785: replace clarity2_lookup_trait -> CheckResult<BTreeMap<ClarityName, FunctionSignature>> with CheckResult::new(BTreeMap::from_iter([(Default::default(), Default::default())]))
-clarity/src/vm/functions/conversions.rs:174: replace native_string_to_uint -> Result<Value> with Ok(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:292: replace ContractContext::add_used_trait -> CheckResult<()> with CheckResult::from_iter([()])
-clarity/src/vm/functions/arithmetic.rs:377: replace native_bitwise_or -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
-clarity/src/vm/ast/traits_resolver/mod.rs:36: replace <impl BuildASTPass for TraitsResolver>::run_pass -> ParseResult<()> with ParseResult::from(())
-clarity/src/vm/functions/arithmetic.rs:572: replace native_log2 -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
-clarity/src/vm/analysis/analysis_db.rs:189: replace AnalysisDatabase<'a>::get_defined_trait -> CheckResult<Option<BTreeMap<ClarityName, FunctionSignature>>> with CheckResult::from_iter([None])
-clarity/src/vm/database/key_value_wrapper.rs:495: replace RollbackWrapper<'a>::get_metadata_manual -> InterpreterResult<Option<String>> with InterpreterResult::new(None)
-clarity/src/vm/functions/arithmetic.rs:462: replace special_leq -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:145: replace FunctionType::check_args_2_05 -> CheckResult<TypeSignature> with CheckResult::from(Default::default())
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:210: replace Lexer<'a>::read_identifier -> LexResult<Token> with LexResult::from_iter([Default::default()])
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:839: replace contract_analysis_size -> CheckResult<u64> with CheckResult::from(1)
-clarity/src/vm/functions/sequences.rs:120: replace special_map -> Result<Value> with Ok(Default::default())
-clarity/src/vm/costs/mod.rs:326: replace load_state_summary -> Result<CostStateSummary> with Ok(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs:39: replace get_simple_native_or_user_define -> CheckResult<FunctionType> with CheckResult::new()
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:546: replace TypeChecker<'a, 'b>::type_check_define_function -> CheckResult<(ClarityName, FixedFunction)> with CheckResult::from((Default::default(), Default::default()))
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:172: replace ContractContext::add_trait -> CheckResult<()> with CheckResult::from_iter([()])
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:86: replace TraitContext::add_used_trait -> CheckResult<()> with CheckResult::from(())
-clarity/src/vm/costs/mod.rs:259: replace LimitedCostTracker::contract_call_circuits -> HashMap<(QualifiedContractIdentifier, ClarityName), ClarityCostFunctionReference> with HashMap::from_iter([((Default::default(), Default::default()), Default::default())])
-clarity/src/vm/analysis/type_checker/v2_05/natives/assets.rs:28: replace check_special_get_owner -> TypeResult with Default::default()
-clarity/src/vm/ast/parser/v2/mod.rs:521: replace Parser<'a>::read_principal -> ParseResult<PreSymbolicExpression> with ParseResult::from(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:123: replace <impl AnalysisPass for TypeChecker<'_, '_>>::run_pass -> CheckResult<()> with CheckResult::from_iter([()])
-clarity/src/vm/ast/traits_resolver/mod.rs:36: replace <impl BuildASTPass for TraitsResolver>::run_pass -> ParseResult<()> with ParseResult::new()
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:808: replace TypeChecker<'a, 'b>::try_type_check_define -> CheckResult<Option<()>> with CheckResult::from_iter([None])
-clarity/src/vm/docs/mod.rs:2601: replace make_all_api_reference -> ReferenceAPIs with Default::default()
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:716: replace TypeChecker<'a, 'b>::inner_type_check -> TypeResult with Default::default()
-clarity/src/vm/callables.rs:355: replace DefinedFunction::get_arguments -> &Vec<ClarityName> with &vec![]
-clarity/src/vm/ast/stack_depth_checker.rs:53: replace check_vary -> ParseResult<()> with ParseResult::from(())
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:172: replace ContractContext::add_trait -> CheckResult<()> with CheckResult::from(())
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:185: replace Lexer<'a>::proceed_through_error_string -> LexResult<String> with LexResult::from("xyzzy".into())
-clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs:195: replace check_special_tuple_cons -> TypeResult with Default::default()
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:61: replace ContractContext::check_name_used -> CheckResult<()> with CheckResult::from(())
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:168: replace ContractContext::check_name_used -> CheckResult<()> with CheckResult::from_iter([()])
-clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs:699: replace TypedNativeFunction::type_native_function -> TypedNativeFunction with Default::default()
-clarity/src/vm/types/signatures.rs:999: replace TypeSignature::contract_name_string_ascii_type -> TypeSignature with Default::default()
-clarity/src/vm/types/mod.rs:1433: replace <impl From for PrincipalData>::from -> Self with Default::default()
-clarity/src/vm/ast/expression_identifier/mod.rs:58: replace ExpressionIdentifier::run_expression_pass -> ParseResult<()> with ParseResult::from_iter([()])
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:88: replace ContractContext::get_nft_type -> Option<&TypeSignature> with Some(&Default::default())
-clarity/src/vm/ast/expression_identifier/mod.rs:58: replace ExpressionIdentifier::run_expression_pass -> ParseResult<()> with ParseResult::from(())
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:269: replace ContractContext::add_nft -> CheckResult<()> with CheckResult::from_iter([()])
-clarity/src/vm/ast/definition_sorter/mod.rs:357: replace DefinitionSorter::probe_for_dependencies_in_wrapped_key_value_pairs -> ParseResult<()> with ParseResult::from(())
-clarity/src/vm/database/clarity_db.rs:281: replace <impl HeadersDB for NullHeadersDB>::get_vrf_seed_for_block -> Option<VRFSeed> with Some(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1023: replace TypeChecker<'a, 'b>::type_check_all -> CheckResult<Vec<TypeSignature>> with CheckResult::new(vec![Default::default()])
-clarity/src/vm/mod.rs:169: replace lookup_variable -> Result<Value> with Ok(Default::default())
-clarity/src/vm/analysis/analysis_db.rs:137: replace AnalysisDatabase<'a>::get_clarity_version -> CheckResult<ClarityVersion> with CheckResult::new()
-clarity/src/vm/database/clarity_store.rs:315: replace <impl ClarityBackingStore for MemoryBackingStore>::get_open_chain_tip -> StacksBlockId with Default::default()
-clarity/src/vm/analysis/read_only_checker/mod.rs:112: replace ReadOnlyChecker<'a, 'b>::check_top_level_expression -> CheckResult<()> with CheckResult::from_iter([()])
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:198: replace ContractContext::get_function_type -> Option<&FunctionType> with Some(&Default::default())
-clarity/src/vm/test_util/mod.rs:168: replace <impl HeadersDB for UnitTestHeaderDB>::get_miner_address -> Option<StacksAddress> with Some(Default::default())
-clarity/src/vm/ast/stack_depth_checker.rs:53: replace check_vary -> ParseResult<()> with ParseResult::new()
-clarity/src/vm/ast/parser/v1.rs:192: replace inner_lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::from_iter([vec![(Default::default(), 0, 0)]])
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:210: replace Lexer<'a>::read_identifier -> LexResult<Token> with LexResult::new()
-clarity/src/vm/database/sqlite.rs:182: replace SqliteConnection::memory -> Result<Connection> with Ok(Default::default())
-clarity/src/vm/analysis/read_only_checker/mod.rs:112: replace ReadOnlyChecker<'a, 'b>::check_top_level_expression -> CheckResult<()> with CheckResult::new(())
-clarity/src/vm/functions/tuples.rs:79: replace tuple_merge -> Result<Value> with Ok(Default::default())
-clarity/src/vm/types/mod.rs:1108: replace Value::expect_optional -> Option<Value> with Some(Default::default())
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:185: replace Lexer<'a>::proceed_through_error_string -> LexResult<String> with LexResult::new(String::new())
-clarity/src/vm/ast/mod.rs:153: replace build_ast_with_diagnostics -> (ContractAST, Vec<Diagnostic>, bool) with (Default::default(), vec![Default::default()], false)
-clarity/src/vm/database/clarity_db.rs:1085: replace ClarityDatabase<'a>::get_microblock_poison_report -> Option<(StandardPrincipalData, u16)> with Some((Default::default(), 1))
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:808: replace TypeChecker<'a, 'b>::try_type_check_define -> CheckResult<Option<()>> with CheckResult::from(None)
-clarity/src/vm/ast/sugar_expander/mod.rs:66: replace SugarExpander::transform -> ParseResult<Vec<SymbolicExpression>> with ParseResult::new(vec![Default::default()])
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:831: replace trait_type_size -> CheckResult<u64> with CheckResult::from_iter([0])
-clarity/src/vm/functions/conversions.rs:162: replace native_string_to_int -> Result<Value> with Ok(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1414: replace TypeChecker<'a, 'b>::try_type_check_define -> CheckResult<Option<()>> with CheckResult::new()
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1398: replace TypeChecker<'a, 'b>::type_check_define_trait -> CheckResult<(ClarityName, BTreeMap<ClarityName, FunctionSignature>)> with CheckResult::from_iter([(Default::default(), BTreeMap::new())])
-clarity/src/vm/ast/definition_sorter/mod.rs:324: replace DefinitionSorter::probe_for_dependencies_in_define_args -> ParseResult<()> with ParseResult::from(())
-clarity/src/vm/test_util/mod.rs:97: replace <impl From for StandardPrincipalData>::from -> StandardPrincipalData with Default::default()
-clarity/src/vm/contexts.rs:1814: replace ContractContext::lookup_variable -> Option<&Value> with Some(&Default::default())
-clarity/src/vm/functions/arithmetic.rs:434: replace special_leq_v1 -> InterpreterResult<Value> with InterpreterResult::new()
-clarity/src/vm/ast/definition_sorter/mod.rs:65: replace DefinitionSorter::run -> ParseResult<()> with ParseResult::new(())
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:831: replace trait_type_size -> CheckResult<u64> with CheckResult::from(0)
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:160: replace Lexer<'a>::proceed_through_error -> LexResult<String> with LexResult::new("xyzzy".into())
-clarity/src/vm/types/signatures.rs:861: replace TupleTypeSignature::get_type_map -> &BTreeMap<ClarityName, TypeSignature> with &BTreeMap::from_iter([(Default::default(), Default::default())])
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1372: replace TypeChecker<'a, 'b>::type_check_define_ft -> CheckResult<ClarityName> with CheckResult::from_iter([Default::default()])
-clarity/src/vm/analysis/type_checker/contexts.rs:82: replace TypingContext<'a>::extend -> CheckResult<TypingContext> with CheckResult::from_iter([Default::default()])
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:485: replace check_function_arg_signature -> CheckResult<()> with CheckResult::new()
-clarity/src/vm/functions/define.rs:191: replace handle_define_nonfungible_asset -> Result<DefineResult> with Ok(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/natives/conversions.rs:36: replace check_special_from_consensus_buff -> TypeResult with Default::default()
-clarity/src/vm/ast/parser/v2/mod.rs:1062: replace Parser<'a>::parse_node_or_eof -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::from_iter([None])
-clarity/src/vm/analysis/read_only_checker/mod.rs:170: replace ReadOnlyChecker<'a, 'b>::check_define_function -> CheckResult<(ClarityName, bool)> with CheckResult::new()
-clarity/src/vm/tests/assets.rs:133: replace execute_transaction -> Result<(Value, AssetMap, Vec<StacksTransactionEvent>), Error> with Ok((Default::default(), Default::default(), vec![Default::default()]))
-clarity/src/vm/analysis/analysis_db.rs:189: replace AnalysisDatabase<'a>::get_defined_trait -> CheckResult<Option<BTreeMap<ClarityName, FunctionSignature>>> with CheckResult::new(Some(BTreeMap::from_iter([(Default::default(), Default::default())])))
-clarity/src/vm/functions/arithmetic.rs:604: replace native_bitwise_right_shift -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
-clarity/src/vm/test_util/mod.rs:141: replace <impl HeadersDB for UnitTestHeaderDB>::get_stacks_block_header_hash_for_block -> Option<BlockHeaderHash> with Some(Default::default())
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:79: replace ContractContext::check_function_type -> CheckResult<()> with CheckResult::from(())
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1398: replace TypeChecker<'a, 'b>::type_check_define_trait -> CheckResult<(ClarityName, BTreeMap<ClarityName, FunctionSignature>)> with CheckResult::from_iter([(Default::default(), BTreeMap::from_iter([(Default::default(), Default::default())]))])
-clarity/src/vm/ast/stack_depth_checker.rs:28: replace check -> ParseResult<()> with ParseResult::new(())
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:62: replace TraitContext::add_defined_trait -> CheckResult<()> with CheckResult::new()
-clarity/src/vm/ast/mod.rs:69: replace parse_in_epoch -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::new(vec![])
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:766: replace TypeChecker<'a, 'b>::type_check_define_ft -> CheckResult<ClarityName> with CheckResult::new(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1055: replace TypeChecker<'a, 'b>::type_check_define_function -> CheckResult<(ClarityName, FixedFunction)> with CheckResult::new()
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:128: replace Lexer<'a>::skip_whitespace -> LexResult<()> with LexResult::from_iter([()])
-clarity/src/vm/functions/arithmetic.rs:575: replace native_mod -> InterpreterResult<Value> with InterpreterResult::new()
-clarity/src/vm/analysis/read_only_checker/mod.rs:88: replace ReadOnlyChecker<'a, 'b>::run -> CheckResult<()> with CheckResult::new(())
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1385: replace TypeChecker<'a, 'b>::type_check_define_nft -> CheckResult<(ClarityName, TypeSignature)> with CheckResult::from_iter([(Default::default(), Default::default())])
-clarity/src/vm/ast/parser/v1.rs:462: replace unescape_ascii_chars -> ParseResult<String> with ParseResult::from(String::new())
-clarity/src/vm/analysis/type_checker/v2_1/natives/maps.rs:106: replace check_set_or_insert_entry -> TypeResult with Default::default()
-clarity/src/vm/analysis/analysis_db.rs:171: replace AnalysisDatabase<'a>::get_read_only_function_type -> CheckResult<Option<FunctionType>> with CheckResult::from(None)
-clarity/src/vm/ast/definition_sorter/mod.rs:433: replace Graph::edges_count -> ParseResult<u64> with ParseResult::new()
-clarity/src/vm/functions/database.rs:599: replace special_insert_entry_v205 -> Result<Value> with Ok(Default::default())
-clarity/src/vm/analysis/type_checker/v2_05/natives/assets.rs:108: replace check_special_mint_token -> TypeResult with Default::default()
-clarity/src/vm/ast/sugar_expander/mod.rs:40: replace <impl BuildASTPass for SugarExpander>::run_pass -> ParseResult<()> with ParseResult::from_iter([()])
-clarity/src/vm/analysis/type_checker/v2_05/natives/sequences.rs:203: replace check_special_concat -> TypeResult with Default::default()
-clarity/src/vm/ast/parser/v1.rs:455: replace lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::from(vec![(Default::default(), 1, 0)])
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:185: replace Lexer<'a>::proceed_through_error_string -> LexResult<String> with LexResult::from(String::new())
-clarity/src/vm/contexts.rs:1784: replace GlobalContext<'a, 'hooks>::destruct -> Option<(ClarityDatabase<'a>, LimitedCostTracker)> with Some((Default::default(), Default::default()))
-clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs:625: replace check_secp256k1_verify -> TypeResult with Default::default()
-clarity/src/vm/types/mod.rs:641: replace <impl SequencedValue for BuffData>::type_signature -> TypeSignature with Default::default()
-clarity/src/vm/types/signatures.rs:354: replace <impl TryFrom for BufferLength>::try_from -> Result<BufferLength> with Ok(Default::default())
-clarity/src/vm/types/mod.rs:1071: replace Value::expect_list -> Vec<Value> with vec![Default::default()]
-clarity/src/vm/types/mod.rs:1400: replace <impl From for PrincipalData>::from -> PrincipalData with Default::default()
-clarity/src/vm/functions/assets.rs:777: replace special_get_balance -> Result<Value> with Ok(Default::default())
-clarity/src/vm/callables.rs:404: replace clarity2_implicit_cast -> Result<Value> with Ok(Default::default())
-clarity/src/vm/database/clarity_db.rs:879: replace ClarityDatabase<'a>::get_sortition_id_for_stacks_tip -> Option<SortitionId> with Some(Default::default())
-clarity/src/vm/ast/parser/v1.rs:455: replace lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::from_iter([vec![]])
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:626: replace TypeChecker<'a, 'b>::type_check_define_map -> CheckResult<(ClarityName, (TypeSignature, TypeSignature))> with CheckResult::new((Default::default(), (Default::default(), Default::default())))
-clarity/src/vm/analysis/errors.rs:242: replace <impl From for CheckError>::from -> Self with Default::default()
-clarity/src/vm/functions/arithmetic.rs:373: replace native_bitwise_and -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:186: replace ContractContext::get_map_type -> Option<&(TypeSignature, TypeSignature)> with Some(&(Default::default(), Default::default()))
-clarity/src/vm/functions/arithmetic.rs:575: replace native_mod -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
-clarity/src/vm/costs/mod.rs:843: replace parse_cost -> Result<ExecutionCost> with Ok(Default::default())
-clarity/src/vm/analysis/type_checker/v2_05/natives/maps.rs:74: replace check_special_delete_entry -> TypeResult with Default::default()
-clarity/src/vm/clarity.rs:42: replace <impl Error for Error>::cause -> Option<&dyn std::error::Error> with Some(&Default::default())
-clarity/src/vm/analysis/contract_interface_builder/mod.rs:333: replace ContractInterfaceVariable::from_map -> Vec<ContractInterfaceVariable> with vec![Default::default()]
-clarity/src/vm/test_util/mod.rs:263: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_pox_payout_addrs -> Option<(Vec<TupleData>, u128)> with Some((vec![Default::default()], 0))
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:899: replace TypeChecker<'a, 'b>::track_return_type -> CheckResult<()> with CheckResult::new(())
-clarity/src/vm/functions/conversions.rs:96: replace native_buff_to_uint_le -> Result<Value> with Ok(Default::default())
-clarity/src/vm/types/serialization.rs:266: replace PrincipalData::inner_consensus_deserialize -> Result<PrincipalData, SerializationError> with Ok(Default::default())
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:516: replace TypeChecker<'a, 'b>::type_check_all -> CheckResult<Vec<TypeSignature>> with CheckResult::new()
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:297: replace trait_type_size -> CheckResult<u64> with CheckResult::from_iter([1])
-clarity/src/vm/ast/stack_depth_checker.rs:48: replace <impl BuildASTPass for StackDepthChecker>::run_pass -> ParseResult<()> with ParseResult::from_iter([()])
-clarity/src/vm/errors.rs:157: replace <impl Error for Error>::source -> Option<&(dyn error::Error +'static)> with Some(&Default::default())
-clarity/src/vm/database/clarity_db.rs:163: replace <impl HeadersDB for &dyn HeadersDB>::get_consensus_hash_for_block -> Option<ConsensusHash> with Some(Default::default())
-clarity/src/vm/ast/parser/v2/mod.rs:1083: replace Parser<'a>::parse -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::from_iter([vec![]])
-clarity/src/vm/ast/parser/v1.rs:728: replace parse_no_stack_limit -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::from_iter([vec![Default::default()]])
-clarity/src/vm/database/clarity_db.rs:240: replace <impl BurnStateDB for &dyn BurnStateDB>::get_stacks_epoch_by_epoch_id -> Option<StacksEpoch> with Some(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:839: replace contract_analysis_size -> CheckResult<u64> with CheckResult::new()
-clarity/src/vm/mod.rs:234: replace apply -> Result<Value> with Ok(Default::default())
-clarity/src/vm/representations.rs:230: replace PreSymbolicExpression::cons -> PreSymbolicExpression with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:156: replace FunctionType::check_args_2_1 -> CheckResult<TypeSignature> with CheckResult::from_iter([Default::default()])
-clarity/src/vm/ast/definition_sorter/mod.rs:345: replace DefinitionSorter::probe_for_dependencies_in_list_of_wrapped_key_value_pairs -> ParseResult<()> with ParseResult::from(())
-clarity/src/vm/analysis/read_only_checker/mod.rs:227: replace ReadOnlyChecker<'a, 'b>::check_read_only -> CheckResult<bool> with CheckResult::new(false)
-clarity/src/vm/ast/definition_sorter/mod.rs:115: replace DefinitionSorter::probe_for_dependencies -> ParseResult<()> with ParseResult::new()
-clarity/src/vm/analysis/mod.rs:50: replace mem_type_check -> CheckResult<(Option<TypeSignature>, ContractAnalysis)> with CheckResult::new()
-clarity/src/vm/analysis/type_checker/v2_1/natives/options.rs:343: replace check_special_match_resp -> TypeResult with Default::default()
-clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs:287: replace check_special_set_var -> TypeResult with Default::default()
-clarity/src/vm/functions/arithmetic.rs:546: replace special_less -> InterpreterResult<Value> with InterpreterResult::new()
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1023: replace TypeChecker<'a, 'b>::type_check_all -> CheckResult<Vec<TypeSignature>> with CheckResult::new(vec![])
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:899: replace TypeChecker<'a, 'b>::track_return_type -> CheckResult<()> with CheckResult::from(())
-clarity/src/vm/errors.rs:175: replace <impl From for Error>::from -> Self with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:785: replace clarity2_lookup_trait -> CheckResult<BTreeMap<ClarityName, FunctionSignature>> with CheckResult::from_iter([BTreeMap::from_iter([(Default::default(), Default::default())])])
-clarity/src/vm/functions/arithmetic.rs:369: replace native_bitwise_xor -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
-clarity/src/vm/analysis/types.rs:98: replace ContractAnalysis::take_contract_cost_tracker -> LimitedCostTracker with Default::default()
-clarity/src/vm/analysis/type_checker/contexts.rs:57: replace TypeMap::set_type -> CheckResult<()> with CheckResult::new(())
-clarity/src/vm/analysis/read_only_checker/mod.rs:227: replace ReadOnlyChecker<'a, 'b>::check_read_only -> CheckResult<bool> with CheckResult::from(false)
-clarity/src/vm/contexts.rs:990: replace Environment<'a, 'b, 'hooks>::eval_read_only_with_rules -> Result<Value> with Ok(Default::default())
-clarity/src/vm/analysis/types.rs:183: replace ContractAnalysis::get_persisted_variable_type -> Option<&TypeSignature> with Some(&Default::default())
-clarity/src/vm/database/clarity_store.rs:291: replace <impl ClarityBackingStore for MemoryBackingStore>::set_block_hash -> InterpreterResult<StacksBlockId> with InterpreterResult::from_iter([Default::default()])
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:751: replace TypeChecker<'a, 'b>::type_check_define_persisted_variable -> CheckResult<(ClarityName, TypeSignature)> with CheckResult::from_iter([(Default::default(), Default::default())])
-clarity/src/vm/analysis/errors.rs:268: replace <impl Error for CheckErrors>::source -> Option<&(dyn error::Error +'static)> with Some(&Default::default())
-clarity/src/vm/ast/parser/v2/mod.rs:1062: replace Parser<'a>::parse_node_or_eof -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::new(None)
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:292: replace ContractContext::add_used_trait -> CheckResult<()> with CheckResult::new(())
-clarity/src/vm/ast/definition_sorter/mod.rs:369: replace DefinitionSorter::probe_for_dependencies_in_key_value_pair -> ParseResult<()> with ParseResult::new(())
-clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs:367: replace check_special_element_at -> TypeResult with Default::default()
-clarity/src/vm/database/key_value_wrapper.rs:466: replace RollbackWrapper<'a>::get_metadata -> InterpreterResult<Option<String>> with InterpreterResult::from_iter([Some("xyzzy".into())])
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:320: replace ContractContext::get_function_type -> Option<&FunctionType> with Some(&Default::default())
-clarity/src/vm/analysis/analysis_db.rs:171: replace AnalysisDatabase<'a>::get_read_only_function_type -> CheckResult<Option<FunctionType>> with CheckResult::new(Some(Default::default()))
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:330: replace no_type -> TypeSignature with Default::default()
-clarity/src/vm/ast/mod.rs:153: replace build_ast_with_diagnostics -> (ContractAST, Vec<Diagnostic>, bool) with (Default::default(), vec![], true)
-clarity/src/vm/types/signatures.rs:1446: replace TypeSignature::parse_string_ascii_type_repr -> Result<TypeSignature> with Ok(Default::default())
-clarity/src/vm/analysis/read_only_checker/mod.rs:59: replace <impl AnalysisPass for ReadOnlyChecker<'a, 'b>>::run_pass -> CheckResult<()> with CheckResult::from_iter([()])
-clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs:539: replace check_contract_of -> TypeResult with Default::default()
-clarity/src/vm/representations.rs:516: replace SymbolicExpression::span -> &Span with &Default::default()
-clarity/src/vm/database/clarity_db.rs:1408: replace ClarityDatabase<'a>::set_entry -> Result<ValueResult> with Ok(Default::default())
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:66: replace Lexer<'a>::add_diagnostic -> LexResult<()> with LexResult::from_iter([()])
-clarity/src/vm/database/structures.rs:870: replace STXBalance::canonical_repr_at_block -> (STXBalance, u128) with (Default::default(), 0)
-clarity/src/vm/functions/database.rs:512: replace special_set_entry_v205 -> Result<Value> with Ok(Default::default())
-clarity/src/vm/analysis/analysis_db.rs:189: replace AnalysisDatabase<'a>::get_defined_trait -> CheckResult<Option<BTreeMap<ClarityName, FunctionSignature>>> with CheckResult::from_iter([Some(BTreeMap::new())])
-clarity/src/vm/functions/arithmetic.rs:419: replace special_geq -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
-clarity/src/vm/ast/definition_sorter/mod.rs:433: replace Graph::edges_count -> ParseResult<u64> with ParseResult::from_iter([0])
-clarity/src/vm/functions/arithmetic.rs:490: replace special_greater_v2 -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:246: replace Lexer<'a>::read_trait_identifier -> LexResult<Token> with LexResult::new(Default::default())
-clarity/src/vm/ast/definition_sorter/mod.rs:456: replace GraphWalker::get_sorted_dependencies -> ParseResult<Vec<usize>> with ParseResult::from_iter([vec![]])
-clarity/src/vm/types/mod.rs:202: replace TraitIdentifier::parse -> Result<(Option<StandardPrincipalData>, ContractName, ClarityName)> with Ok((Some(Default::default()), Default::default(), Default::default()))
-clarity/src/vm/contexts.rs:652: replace OwnedEnvironment<'a, 'hooks>::execute_in_env -> std::result::Result<(A, AssetMap, Vec<StacksTransactionEvent>), E> with Ok((Default::default(), Default::default(), vec![]))
-clarity/src/vm/ast/parser/v2/mod.rs:119: replace Parser<'a>::add_diagnostic -> ParseResult<()> with ParseResult::from(())
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:706: replace Lexer<'a>::read_token -> Result<PlacedToken, LexerError> with Ok(Default::default())
-clarity/src/vm/analysis/analysis_db.rs:153: replace AnalysisDatabase<'a>::get_public_function_type -> CheckResult<Option<FunctionType>> with CheckResult::from_iter([None])
-clarity/src/vm/contexts.rs:1095: replace Environment<'a, 'b, 'hooks>::epoch -> &StacksEpochId with &Default::default()
-clarity/src/vm/ast/sugar_expander/mod.rs:56: replace SugarExpander::run -> ParseResult<()> with ParseResult::new()
-clarity/src/vm/functions/arithmetic.rs:41: replace U128Ops::make_value -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:223: replace ContractContext::add_private_function_type -> CheckResult<()> with CheckResult::from_iter([()])
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1357: replace TypeChecker<'a, 'b>::type_check_define_persisted_variable -> CheckResult<(ClarityName, TypeSignature)> with CheckResult::new()
-clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs:120: replace inner_handle_tuple_get -> TypeResult with Default::default()
-clarity/src/vm/database/clarity_db.rs:1625: replace ClarityDatabase<'a>::load_ft -> Result<FungibleTokenMetadata> with Ok(Default::default())
-clarity/src/vm/ast/parser/v2/mod.rs:119: replace Parser<'a>::add_diagnostic -> ParseResult<()> with ParseResult::new()
-clarity/src/vm/ast/definition_sorter/mod.rs:433: replace Graph::edges_count -> ParseResult<u64> with ParseResult::from(1)
-clarity/src/vm/ast/definition_sorter/mod.rs:65: replace DefinitionSorter::run -> ParseResult<()> with ParseResult::from_iter([()])
-clarity/src/vm/database/clarity_db.rs:244: replace <impl BurnStateDB for &dyn BurnStateDB>::get_ast_rules -> ASTRules with Default::default()
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:288: replace Lexer<'a>::read_principal -> LexResult<Token> with LexResult::from(Default::default())
-clarity/src/vm/analysis/read_only_checker/mod.rs:227: replace ReadOnlyChecker<'a, 'b>::check_read_only -> CheckResult<bool> with CheckResult::new(true)
-clarity/src/vm/analysis/types.rs:179: replace ContractAnalysis::get_variable_type -> Option<&TypeSignature> with Some(&Default::default())
-clarity/src/vm/analysis/mod.rs:50: replace mem_type_check -> CheckResult<(Option<TypeSignature>, ContractAnalysis)> with CheckResult::from_iter([(Some(Default::default()), Default::default())])
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:345: replace Lexer<'a>::read_hex -> LexResult<Token> with LexResult::new(Default::default())
-clarity/src/vm/functions/options.rs:73: replace native_unwrap_err -> Result<Value> with Ok(Default::default())
-clarity/src/vm/functions/arithmetic.rs:532: replace special_less_v2 -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:792: replace TypeChecker<'a, 'b>::type_check_define_trait -> CheckResult<(ClarityName, BTreeMap<ClarityName, FunctionSignature>)> with CheckResult::from_iter([(Default::default(), BTreeMap::from_iter([(Default::default(), Default::default())]))])
-clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs:582: replace check_principal_construct -> TypeResult with Default::default()
-clarity/src/vm/tests/mod.rs:131: replace tl_env_factory -> TopLevelMemoryEnvironmentGenerator with Default::default()
-clarity/src/vm/types/signatures.rs:985: replace TypeSignature::max_string_utf8 -> TypeSignature with Default::default()
-clarity/src/vm/functions/arithmetic.rs:381: replace native_bitwise_not -> InterpreterResult<Value> with InterpreterResult::new()
-clarity/src/vm/callables.rs:359: replace DefinedFunction::get_arg_types -> &Vec<TypeSignature> with &vec![Default::default()]
-clarity/src/vm/types/serialization.rs:1329: replace <impl StacksMessageCodec for Value>::consensus_deserialize -> Result<Value, codec_error> with Ok(Default::default())
-clarity/src/vm/mod.rs:314: replace eval -> Result<Value> with Ok(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/natives/assets.rs:82: replace check_special_mint_asset -> TypeResult with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/natives/assets.rs:172: replace check_special_transfer_token -> TypeResult with Default::default()
-clarity/src/vm/ast/mod.rs:153: replace build_ast_with_diagnostics -> (ContractAST, Vec<Diagnostic>, bool) with (Default::default(), vec![Default::default()], true)
-clarity/src/vm/database/clarity_db.rs:647: replace ClarityDatabase<'a>::load_contract_analysis -> Option<ContractAnalysis> with Some(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/natives/assets.rs:113: replace check_special_mint_token -> TypeResult with Default::default()
-clarity/src/vm/types/serialization.rs:126: replace <impl From for SerializationError>::from -> Self with Default::default()
-clarity/src/vm/functions/principals.rs:60: replace special_is_standard -> Result<Value> with Ok(Default::default())
-clarity/src/vm/ast/parser/v1.rs:508: replace parse_lexed -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::new()
-clarity/src/vm/functions/define.rs:126: replace handle_define_variable -> Result<DefineResult> with Ok(Default::default())
-clarity/src/vm/database/key_value_wrapper.rs:59: replace rollback_check_pre_bottom_commit -> Vec<(T, String)> with vec![(Default::default(), "xyzzy".into())]
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:571: replace clarity2_trait_check_trait_compliance -> CheckResult<()> with CheckResult::from(())
-clarity/src/vm/analysis/analysis_db.rs:171: replace AnalysisDatabase<'a>::get_read_only_function_type -> CheckResult<Option<FunctionType>> with CheckResult::new()
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:91: replace <impl CostTracker for TypeChecker<'_, '_>>::compute_cost -> Result<ExecutionCost, CostErrors> with Ok(Default::default())
-clarity/src/vm/functions/assets.rs:1061: replace special_burn_asset_v205 -> Result<Value> with Ok(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:213: replace ContractContext::add_read_only_function_type -> CheckResult<()> with CheckResult::new()
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:140: replace Lexer<'a>::read_line -> LexResult<String> with LexResult::from("xyzzy".into())
-clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs:260: replace check_special_fetch_var -> TypeResult with Default::default()
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:297: replace trait_type_size -> CheckResult<u64> with CheckResult::new()
-clarity/src/vm/contexts.rs:1818: replace ContractContext::lookup_function -> Option<DefinedFunction> with Some(Default::default())
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:172: replace ContractContext::add_trait -> CheckResult<()> with CheckResult::new(())
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1414: replace TypeChecker<'a, 'b>::try_type_check_define -> CheckResult<Option<()>> with CheckResult::from_iter([Some(())])
-clarity/src/vm/functions/arithmetic.rs:579: replace native_bitwise_left_shift -> InterpreterResult<Value> with InterpreterResult::new()
-clarity/src/vm/test_util/mod.rs:263: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_pox_payout_addrs -> Option<(Vec<TupleData>, u128)> with Some((vec![Default::default()], 1))
-clarity/src/vm/types/signatures.rs:1372: replace TypeSignature::parse_atom_type -> Result<TypeSignature> with Ok(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:203: replace ContractContext::add_public_function_type -> CheckResult<()> with CheckResult::new(())
-clarity/src/vm/functions/arithmetic.rs:448: replace special_leq_v2 -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
-clarity/src/vm/ast/parser/v1.rs:192: replace inner_lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::from(vec![(Default::default(), 0, 1)])
-clarity/src/vm/analysis/type_checker/v2_1/natives/options.rs:49: replace check_special_some -> TypeResult with Default::default()
-clarity/src/vm/analysis/analysis_db.rs:171: replace AnalysisDatabase<'a>::get_read_only_function_type -> CheckResult<Option<FunctionType>> with CheckResult::from_iter([Some(Default::default())])
-clarity/src/vm/database/clarity_store.rs:307: replace <impl ClarityBackingStore for MemoryBackingStore>::get_block_at_height -> Option<StacksBlockId> with Some(Default::default())
-clarity/src/vm/analysis/read_only_checker/mod.rs:244: replace ReadOnlyChecker<'a, 'b>::check_each_expression_is_read_only -> CheckResult<bool> with CheckResult::new()
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:474: replace Lexer<'a>::read_utf8_encoding -> LexResult<Result<String, String>> with LexResult::from(Ok(String::new()))
-clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs:325: replace check_special_equals -> TypeResult with Default::default()
-clarity/src/vm/types/mod.rs:831: replace Value::err_uint -> Value with Default::default()
-clarity/src/vm/functions/arithmetic.rs:419: replace special_geq -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
-clarity/src/vm/analysis/mod.rs:50: replace mem_type_check -> CheckResult<(Option<TypeSignature>, ContractAnalysis)> with CheckResult::from((None, Default::default()))
-clarity/src/vm/costs/mod.rs:208: replace <impl From for CostStateSummary>::from -> CostStateSummary with Default::default()
-clarity/src/vm/representations.rs:356: replace PreSymbolicExpression::match_atom_value -> Option<&Value> with Some(&Default::default())
-clarity/src/vm/database/clarity_store.rs:223: replace <impl ClarityBackingStore for NullBackingStore>::set_block_hash -> Result<StacksBlockId> with Ok(Default::default())
-clarity/src/vm/ast/definition_sorter/mod.rs:54: replace DefinitionSorter::run_pass -> ParseResult<()> with ParseResult::new()
-clarity/src/vm/ast/parser/v2/mod.rs:807: replace Parser<'a>::parse_node -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::new(None)
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:831: replace trait_type_size -> CheckResult<u64> with CheckResult::new()
-clarity/src/vm/types/mod.rs:1445: replace <impl From for Value>::from -> Self with Default::default()
-clarity/src/vm/database/clarity_db.rs:1263: replace ClarityDatabase<'a>::create_map -> DataMapMetadata with Default::default()
-clarity/src/vm/types/mod.rs:970: replace Value::string_utf8_from_string_utf8_literal -> Result<Value> with Ok(Default::default())
-clarity/src/vm/types/serialization.rs:522: replace Value::deserialize_read -> Result<Value, SerializationError> with Ok(Default::default())
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:140: replace Lexer<'a>::read_line -> LexResult<String> with LexResult::new("xyzzy".into())
-clarity/src/vm/functions/database.rs:229: replace special_fetch_variable_v200 -> Result<Value> with Ok(Default::default())
-clarity/src/vm/ast/parser/v1.rs:508: replace parse_lexed -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::new(vec![Default::default()])
-clarity/src/vm/representations.rs:520: replace SymbolicExpression::atom_value -> SymbolicExpression with Default::default()
-clarity/src/vm/analysis/type_checker/contexts.rs:97: replace TypingContext<'a>::lookup_variable_type -> Option<&TypeSignature> with Some(&Default::default())
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:118: replace <impl AnalysisPass for TypeChecker<'_, '_>>::run_pass -> CheckResult<()> with CheckResult::new(())
-clarity/src/vm/docs/contracts.rs:178: replace produce_docs_refs -> BTreeMap<String, ContractRef> with BTreeMap::from_iter([("xyzzy".into(), Default::default())])
-clarity/src/vm/ast/parser/v2/mod.rs:283: replace Parser<'a>::handle_open_tuple -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::from(None)
-clarity/src/vm/ast/definition_sorter/mod.rs:54: replace DefinitionSorter::run_pass -> ParseResult<()> with ParseResult::from(())
-clarity/src/vm/functions/arithmetic.rs:369: replace native_bitwise_xor -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1023: replace TypeChecker<'a, 'b>::type_check_all -> CheckResult<Vec<TypeSignature>> with CheckResult::from_iter([vec![Default::default()]])
-clarity/src/vm/analysis/type_checker/v2_05/natives/sequences.rs:62: replace check_special_map -> TypeResult with Default::default()
-clarity/src/vm/analysis/read_only_checker/mod.rs:227: replace ReadOnlyChecker<'a, 'b>::check_read_only -> CheckResult<bool> with CheckResult::from(true)
-clarity/src/vm/types/mod.rs:1427: replace <impl From for Value>::from -> Self with Default::default()
-clarity/src/vm/types/mod.rs:1527: replace TupleData::get_owned -> Result<Value> with Ok(Default::default())
-clarity/src/vm/ast/parser/v1.rs:455: replace lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::from(vec![(Default::default(), 0, 1)])
-clarity/src/vm/analysis/type_checker/v2_05/natives/options.rs:60: replace check_special_error -> TypeResult with Default::default()
-clarity/src/vm/ast/parser/v1.rs:728: replace parse_no_stack_limit -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::from(vec![Default::default()])
-clarity/src/vm/functions/options.rs:112: replace eval_with_new_binding -> Result<Value> with Ok(Default::default())
-clarity/src/vm/ast/definition_sorter/mod.rs:324: replace DefinitionSorter::probe_for_dependencies_in_define_args -> ParseResult<()> with ParseResult::from_iter([()])
-clarity/src/vm/ast/parser/v1.rs:192: replace inner_lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::new(vec![])
-clarity/src/vm/database/clarity_db.rs:724: replace ClarityDatabase<'a>::get_clarity_epoch_version -> StacksEpochId with Default::default()
-clarity/src/vm/database/clarity_db.rs:1361: replace ClarityDatabase<'a>::fetch_entry_with_size -> Result<ValueResult> with Ok(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:156: replace FunctionType::check_args_2_1 -> CheckResult<TypeSignature> with CheckResult::new(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/natives/options.rs:134: replace check_special_asserts -> TypeResult with Default::default()
-clarity/src/vm/database/clarity_db.rs:343: replace <impl BurnStateDB for NullBurnStateDB>::get_sortition_id_from_consensus_hash -> Option<SortitionId> with Some(Default::default())
-clarity/src/vm/ast/parser/v2/mod.rs:1062: replace Parser<'a>::parse_node_or_eof -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::from_iter([Some(Default::default())])
-clarity/src/vm/contexts.rs:1760: replace GlobalContext<'a, 'hooks>::handle_tx_result -> Result<Value> with Ok(Default::default())
-clarity/src/vm/types/mod.rs:942: replace Value::buff_from -> Result<Value> with Ok(Default::default())
-clarity/src/vm/database/clarity_db.rs:634: replace ClarityDatabase<'a>::fetch_metadata_manual -> Result<Option<T>> with Ok(Some(Default::default()))
-clarity/src/vm/functions/conversions.rs:88: replace native_buff_to_int_le -> Result<Value> with Ok(Default::default())
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:194: replace ContractContext::get_persisted_variable_type -> Option<&TypeSignature> with Some(&Default::default())
-clarity/src/vm/ast/parser/v2/mod.rs:1083: replace Parser<'a>::parse -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::new()
-clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs:265: replace check_special_fetch_var -> TypeResult with Default::default()
-clarity/src/vm/functions/sequences.rs:409: replace special_replace_at -> Result<Value> with Ok(Default::default())
-clarity/src/vm/database/structures.rs:748: replace STXBalance::initial -> STXBalance with Default::default()
-clarity/src/vm/ast/expression_identifier/mod.rs:40: replace update_expression_id -> ParseResult<()> with ParseResult::from(())
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1023: replace TypeChecker<'a, 'b>::type_check_all -> CheckResult<Vec<TypeSignature>> with CheckResult::new()
-clarity/src/vm/functions/arithmetic.rs:579: replace native_bitwise_left_shift -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:66: replace Lexer<'a>::add_diagnostic -> LexResult<()> with LexResult::new()
-clarity/src/vm/database/key_value_wrapper.rs:466: replace RollbackWrapper<'a>::get_metadata -> InterpreterResult<Option<String>> with InterpreterResult::from(None)
-clarity/src/vm/contexts.rs:1246: replace Environment<'a, 'b, 'hooks>::evaluate_at_block -> Result<Value> with Ok(Default::default())
-clarity/src/vm/functions/conversions.rs:242: replace from_consensus_buff -> Result<Value> with Ok(Default::default())
-clarity/src/vm/version.rs:27: replace ClarityVersion::default_for_epoch -> ClarityVersion with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:269: replace ContractContext::add_nft -> CheckResult<()> with CheckResult::new(())
-clarity/src/vm/analysis/read_only_checker/mod.rs:281: replace ReadOnlyChecker<'a, 'b>::check_native_function_is_read_only -> CheckResult<bool> with CheckResult::from_iter([true])
-clarity/src/vm/callables.rs:355: replace DefinedFunction::get_arguments -> &Vec<ClarityName> with &vec![Default::default()]
-clarity/src/vm/contexts.rs:490: replace AssetMap::get_nonfungible_tokens -> Option<&Vec<Value>> with Some(&vec![])
-clarity/src/vm/analysis/arithmetic_checker/mod.rs:60: replace <impl Error for Error>::source -> Option<&(dyn std::error::Error +'static)> with Some(&Default::default())
-clarity/src/vm/functions/arithmetic.rs:557: replace native_sub -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
-clarity/src/vm/database/clarity_db.rs:937: replace ClarityDatabase<'a>::get_pox_payout_addrs_for_burnchain_height -> Option<(Vec<TupleData>, u128)> with Some((vec![Default::default()], 1))
-clarity/src/vm/errors.rs:199: replace <impl From for Error>::from -> Self with Default::default()
-clarity/src/vm/types/serialization.rs:1133: replace Value::try_deserialize_hex_untyped -> Result<Value, SerializationError> with Ok(Default::default())
-clarity/src/vm/analysis/types.rs:190: replace ContractAnalysis::get_defined_trait -> Option<&BTreeMap<ClarityName, FunctionSignature>> with Some(&BTreeMap::from_iter([(Default::default(), Default::default())]))
-clarity/src/vm/functions/arithmetic.rs:47: replace I128Ops::make_value -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
-clarity/src/vm/ast/parser/v1.rs:728: replace parse_no_stack_limit -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::new()
-clarity/src/vm/analysis/type_checker/v2_1/natives/assets.rs:250: replace check_special_get_token_supply -> TypeResult with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/natives/options.rs:306: replace check_special_match_opt -> TypeResult with Default::default()
-clarity/src/vm/ast/parser/v2/mod.rs:1109: replace parse_collect_diagnostics -> (Vec<PreSymbolicExpression>, Vec<Diagnostic>, bool) with (vec![Default::default()], vec![], true)
-clarity/src/vm/test_util/mod.rs:125: replace <impl HeadersDB for UnitTestHeaderDB>::get_burn_header_hash_for_block -> Option<BurnchainHeaderHash> with Some(Default::default())
-clarity/src/vm/contexts.rs:1069: replace Environment<'a, 'b, 'hooks>::eval_raw -> Result<Value> with Ok(Default::default())
-clarity/src/vm/ast/parser/v1.rs:462: replace unescape_ascii_chars -> ParseResult<String> with ParseResult::new()
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:79: replace ContractContext::check_function_type -> CheckResult<()> with CheckResult::new()
-clarity/src/vm/docs/mod.rs:2557: replace make_for_special -> FunctionAPI with Default::default()
-clarity/src/vm/types/mod.rs:247: replace SequenceData::atom_values -> Vec<SymbolicExpression> with vec![Default::default()]
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:785: replace clarity2_lookup_trait -> CheckResult<BTreeMap<ClarityName, FunctionSignature>> with CheckResult::new()
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:808: replace TypeChecker<'a, 'b>::try_type_check_define -> CheckResult<Option<()>> with CheckResult::new(Some(()))
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:172: replace ContractContext::add_trait -> CheckResult<()> with CheckResult::new()
-clarity/src/vm/analysis/analysis_db.rs:208: replace AnalysisDatabase<'a>::get_implemented_traits -> CheckResult<BTreeSet<TraitIdentifier>> with CheckResult::from_iter([BTreeSet::from_iter([Default::default()])])
-clarity/src/vm/functions/arithmetic.rs:490: replace special_greater_v2 -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:358: replace TypeChecker<'a, 'b>::track_return_type -> CheckResult<()> with CheckResult::new(())
-clarity/src/vm/ast/mod.rs:130: replace build_ast_typical -> ParseResult<ContractAST> with ParseResult::new(Default::default())
-clarity/src/vm/docs/mod.rs:2532: replace make_keyword_reference -> Option<KeywordAPI> with Some(Default::default())
-clarity/src/vm/types/mod.rs:653: replace <impl SequencedValue for ASCIIData>::items -> &Vec<u8> with &vec![1]
-clarity/src/vm/ast/expression_identifier/mod.rs:40: replace update_expression_id -> ParseResult<()> with ParseResult::from_iter([()])
-clarity/src/vm/analysis/read_only_checker/mod.rs:430: replace ReadOnlyChecker<'a, 'b>::check_expression_application_is_read_only -> CheckResult<bool> with CheckResult::new(true)
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1346: replace TypeChecker<'a, 'b>::type_check_define_variable -> CheckResult<(ClarityName, TypeSignature)> with CheckResult::from((Default::default(), Default::default()))
-clarity/src/vm/version.rs:24: replace ClarityVersion::latest -> ClarityVersion with Default::default()
-clarity/src/vm/functions/arithmetic.rs:47: replace I128Ops::make_value -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
-clarity/src/vm/ast/definition_sorter/mod.rs:357: replace DefinitionSorter::probe_for_dependencies_in_wrapped_key_value_pairs -> ParseResult<()> with ParseResult::new()
-clarity/src/vm/types/mod.rs:299: replace SequenceData::replace_at -> Result<Value> with Ok(Default::default())
-clarity/src/vm/analysis/analysis_db.rs:189: replace AnalysisDatabase<'a>::get_defined_trait -> CheckResult<Option<BTreeMap<ClarityName, FunctionSignature>>> with CheckResult::from(Some(BTreeMap::from_iter([(Default::default(), Default::default())])))
-clarity/src/vm/database/clarity_db.rs:395: replace <impl BurnStateDB for NullBurnStateDB>::get_pox_payout_addrs -> Option<(Vec<TupleData>, u128)> with Some((vec![Default::default()], 1))
-clarity/src/vm/functions/boolean.rs:58: replace special_and -> Result<Value> with Ok(Default::default())
-clarity/src/vm/docs/mod.rs:828: replace make_for_simple_native -> FunctionAPI with Default::default()
-clarity/src/vm/functions/define.rs:411: replace evaluate_define -> Result<DefineResult> with Ok(Default::default())
-clarity/src/vm/functions/database.rs:642: replace special_delete_entry_v200 -> Result<Value> with Ok(Default::default())
-clarity/src/vm/types/signatures.rs:1054: replace TypeSignature::least_supertype -> Result<TypeSignature> with Ok(Default::default())
-clarity/src/vm/database/key_value_wrapper.rs:466: replace RollbackWrapper<'a>::get_metadata -> InterpreterResult<Option<String>> with InterpreterResult::new()
-clarity/src/vm/functions/crypto.rs:102: replace special_principal_of -> Result<Value> with Ok(Default::default())
-clarity/src/vm/ast/definition_sorter/mod.rs:345: replace DefinitionSorter::probe_for_dependencies_in_list_of_wrapped_key_value_pairs -> ParseResult<()> with ParseResult::new(())
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:326: replace Lexer<'a>::read_integer -> LexResult<Token> with LexResult::new()
-clarity/src/vm/database/clarity_db.rs:1928: replace ClarityDatabase<'a>::get_account_stx_balance -> STXBalance with Default::default()
-clarity/src/vm/ast/parser/v2/mod.rs:283: replace Parser<'a>::handle_open_tuple -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::new()
-clarity/src/vm/ast/definition_sorter/mod.rs:456: replace GraphWalker::get_sorted_dependencies -> ParseResult<Vec<usize>> with ParseResult::from(vec![1])
-clarity/src/vm/docs/contracts.rs:69: replace doc_execute -> Result<Option<Value>, vm::Error> with Ok(Some(Default::default()))
-clarity/src/vm/test_util/mod.rs:135: replace <impl HeadersDB for UnitTestHeaderDB>::get_vrf_seed_for_block -> Option<VRFSeed> with Some(Default::default())
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:751: replace TypeChecker<'a, 'b>::type_check_define_persisted_variable -> CheckResult<(ClarityName, TypeSignature)> with CheckResult::from((Default::default(), Default::default()))
-clarity/src/vm/analysis/read_only_checker/mod.rs:430: replace ReadOnlyChecker<'a, 'b>::check_expression_application_is_read_only -> CheckResult<bool> with CheckResult::new(false)
-clarity/src/vm/ast/parser/v1.rs:101: replace get_value_or_err -> ParseResult<String> with ParseResult::from("xyzzy".into())
-clarity/src/vm/contracts.rs:44: replace Contract::initialize_from_ast -> Result<Contract> with Ok(Default::default())
-clarity/src/vm/analysis/analysis_db.rs:189: replace AnalysisDatabase<'a>::get_defined_trait -> CheckResult<Option<BTreeMap<ClarityName, FunctionSignature>>> with CheckResult::new(Some(BTreeMap::new()))
-clarity/src/vm/contexts.rs:905: replace <impl CostTracker for GlobalContext<'_, '_>>::compute_cost -> std::result::Result<ExecutionCost, CostErrors> with Ok(Default::default())
-clarity/src/vm/ast/parser/v1.rs:192: replace inner_lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::new(vec![(Default::default(), 1, 1)])
-clarity/src/vm/analysis/type_checker/v2_05/natives/options.rs:74: replace check_special_is_response -> TypeResult with Default::default()
-clarity/src/vm/ast/expression_identifier/mod.rs:23: replace inner_relabel -> ParseResult<u64> with ParseResult::new(0)
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:516: replace TypeChecker<'a, 'b>::type_check_all -> CheckResult<Vec<TypeSignature>> with CheckResult::new(vec![Default::default()])
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:259: replace ContractContext::add_ft -> CheckResult<()> with CheckResult::new(())
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:429: replace TypeChecker<'a, 'b>::type_check_expects -> TypeResult with Default::default()
-clarity/src/vm/analysis/type_checker/v2_05/natives/sequences.rs:39: replace get_simple_native_or_user_define -> CheckResult<FunctionType> with CheckResult::from(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:571: replace clarity2_trait_check_trait_compliance -> CheckResult<()> with CheckResult::new()
-clarity/src/vm/functions/arithmetic.rs:462: replace special_leq -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
-clarity/src/vm/costs/mod.rs:677: replace LimitedCostTracker::new_mid_block -> Result<LimitedCostTracker> with Ok(Default::default())
-clarity/src/vm/contexts.rs:871: replace <impl CostTracker for Environment<'_, '_, '_>>::compute_cost -> std::result::Result<ExecutionCost, CostErrors> with Ok(Default::default())
-clarity/src/vm/representations.rs:475: replace SymbolicExpression::cons -> SymbolicExpression with Default::default()
-clarity/src/vm/representations.rs:211: replace <impl SymbolicExpressionCommon for SymbolicExpression>::match_list_mut -> Option<&mut[SymbolicExpression]> with Some(Vec::leak(vec![Default::default()]))
-clarity/src/vm/functions/arithmetic.rs:557: replace native_sub -> InterpreterResult<Value> with InterpreterResult::new()
-clarity/src/vm/functions/arithmetic.rs:405: replace special_geq_v2 -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
-clarity/src/vm/types/signatures.rs:721: replace TypeSignature::canonicalize -> TypeSignature with Default::default()
-clarity/src/vm/functions/sequences.rs:38: replace list_cons -> Result<Value> with Ok(Default::default())
-clarity/src/vm/types/mod.rs:1451: replace <impl From for Value>::from -> Self with Default::default()
-clarity/src/vm/analysis/read_only_checker/mod.rs:281: replace ReadOnlyChecker<'a, 'b>::check_native_function_is_read_only -> CheckResult<bool> with CheckResult::from_iter([false])
-clarity/src/vm/ast/types.rs:67: replace ContractAST::get_referenced_trait -> Option<&TraitDefinition> with Some(&Default::default())
-clarity/src/vm/functions/arithmetic.rs:532: replace special_less_v2 -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:389: replace Lexer<'a>::read_ascii_string -> LexResult<Token> with LexResult::from_iter([Default::default()])
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:213: replace ContractContext::add_read_only_function_type -> CheckResult<()> with CheckResult::new(())
-clarity/src/vm/contexts.rs:1420: replace Environment<'a, 'b, 'hooks>::construct_print_transaction_event -> StacksTransactionEvent with Default::default()
-clarity/src/vm/analysis/analysis_db.rs:208: replace AnalysisDatabase<'a>::get_implemented_traits -> CheckResult<BTreeSet<TraitIdentifier>> with CheckResult::from(BTreeSet::new())
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:78: replace Lexer<'a>::read_char -> LexResult<()> with LexResult::new(())
-clarity/src/vm/ast/mod.rs:174: replace inner_build_ast -> ParseResult<(ContractAST, Vec<Diagnostic>, bool)> with ParseResult::from_iter([(Default::default(), vec![], false)])
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:223: replace ContractContext::add_private_function_type -> CheckResult<()> with CheckResult::new(())
-clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs:228: replace check_special_let -> TypeResult with Default::default()
-clarity/src/vm/ast/parser/v2/mod.rs:463: replace Parser<'a>::open_tuple -> ParseResult<SetupTupleResult> with ParseResult::new(Default::default())
-clarity/src/vm/representations.rs:334: replace PreSymbolicExpression::placeholder -> PreSymbolicExpression with Default::default()
-clarity/src/vm/functions/mod.rs:573: replace native_eq -> Result<Value> with Ok(Default::default())
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:111: replace Lexer<'a>::report_line_ending -> LexResult<()> with LexResult::new(())
-clarity/src/vm/types/signatures.rs:486: replace TypeSignature::new_option -> Result<TypeSignature> with Ok(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1385: replace TypeChecker<'a, 'b>::type_check_define_nft -> CheckResult<(ClarityName, TypeSignature)> with CheckResult::from((Default::default(), Default::default()))
-clarity/src/vm/contexts.rs:829: replace OwnedEnvironment<'a, 'hooks>::eval_read_only -> Result<(Value, AssetMap, Vec<StacksTransactionEvent>)> with Ok((Default::default(), Default::default(), vec![Default::default()]))
-clarity/src/vm/types/mod.rs:1406: replace <impl From for StacksAddress>::from -> StacksAddress with Default::default()
-clarity/src/vm/contexts.rs:1209: replace Environment<'a, 'b, 'hooks>::execute_function_as_transaction -> Result<Value> with Ok(Default::default())
-clarity/src/vm/ast/parser/v1.rs:728: replace parse_no_stack_limit -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::from_iter([vec![]])
-clarity/src/vm/representations.rs:602: replace SymbolicExpression::match_trait_reference -> Option<&ClarityName> with Some(&Default::default())
-clarity/src/vm/types/mod.rs:716: replace OptionalData::type_signature -> TypeSignature with Default::default()
-clarity/src/vm/functions/arithmetic.rs:391: replace special_geq_v1 -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
-clarity/src/vm/ast/parser/v2/mod.rs:807: replace Parser<'a>::parse_node -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::new(Some(Default::default()))
-clarity/src/vm/database/clarity_db.rs:454: replace ClarityDatabase<'a>::set_block_hash -> Result<StacksBlockId> with Ok(Default::default())
-clarity/src/vm/ast/parser/v1.rs:101: replace get_value_or_err -> ParseResult<String> with ParseResult::from_iter(["xyzzy".into()])
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:516: replace TypeChecker<'a, 'b>::type_check_all -> CheckResult<Vec<TypeSignature>> with CheckResult::new(vec![])
-clarity/src/vm/analysis/read_only_checker/mod.rs:430: replace ReadOnlyChecker<'a, 'b>::check_expression_application_is_read_only -> CheckResult<bool> with CheckResult::new()
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:128: replace Lexer<'a>::skip_whitespace -> LexResult<()> with LexResult::new(())
-clarity/src/vm/analysis/type_checker/v2_1/natives/options.rs:217: replace check_special_try_ret -> TypeResult with Default::default()
-clarity/src/vm/database/key_value_wrapper.rs:338: replace RollbackWrapper<'a>::set_block_hash -> InterpreterResult<StacksBlockId> with InterpreterResult::from_iter([Default::default()])
-clarity/src/vm/analysis/type_checker/v2_1/natives/assets.rs:299: replace check_special_burn_token -> TypeResult with Default::default()
-clarity/src/vm/types/mod.rs:808: replace Value::some -> Result<Value> with Ok(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:168: replace ContractContext::check_name_used -> CheckResult<()> with CheckResult::from(())
-clarity/src/vm/ast/traits_resolver/mod.rs:36: replace <impl BuildASTPass for TraitsResolver>::run_pass -> ParseResult<()> with ParseResult::from_iter([()])
-clarity/src/vm/tests/contracts.rs:91: replace get_principal_as_principal_data -> PrincipalData with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1372: replace TypeChecker<'a, 'b>::type_check_define_ft -> CheckResult<ClarityName> with CheckResult::from(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:253: replace ContractContext::add_persisted_variable_type -> CheckResult<()> with CheckResult::from(())
-clarity/src/vm/ast/parser/v1.rs:192: replace inner_lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::new(vec![(Default::default(), 0, 0)])
-clarity/src/vm/functions/conversions.rs:106: replace native_buff_to_int_be::convert_to_int_be -> Value with Default::default()
-clarity/src/vm/ast/definition_sorter/mod.rs:456: replace GraphWalker::get_sorted_dependencies -> ParseResult<Vec<usize>> with ParseResult::new(vec![1])
-clarity/src/vm/functions/assets.rs:305: replace special_mint_token -> Result<Value> with Ok(Default::default())
-clarity/src/vm/functions/mod.rs:606: replace special_print -> Result<Value> with Ok(Default::default())
-clarity/src/vm/ast/definition_sorter/mod.rs:307: replace DefinitionSorter::probe_for_dependencies_in_tuple -> ParseResult<()> with ParseResult::from_iter([()])
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:177: replace ContractContext::add_implemented_trait -> CheckResult<()> with CheckResult::new()
-clarity/src/vm/contexts.rs:1044: replace Environment<'a, 'b, 'hooks>::eval_raw_with_rules -> Result<Value> with Ok(Default::default())
-clarity/src/vm/ast/parser/v1.rs:455: replace lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::from(vec![])
-clarity/src/vm/database/structures.rs:234: replace <impl ClarityDeserializable for STXBalance>::deserialize -> Self with Default::default()
-clarity/src/vm/database/clarity_store.rs:291: replace <impl ClarityBackingStore for MemoryBackingStore>::set_block_hash -> InterpreterResult<StacksBlockId> with InterpreterResult::new(Default::default())
-clarity/src/vm/ast/sugar_expander/mod.rs:56: replace SugarExpander::run -> ParseResult<()> with ParseResult::from(())
-clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs:685: replace TypedNativeFunction::type_check_application -> TypeResult with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1372: replace TypeChecker<'a, 'b>::type_check_define_ft -> CheckResult<ClarityName> with CheckResult::new(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:223: replace ContractContext::add_private_function_type -> CheckResult<()> with CheckResult::from(())
-clarity/src/vm/functions/arithmetic.rs:476: replace special_greater_v1 -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
-clarity/src/vm/analysis/read_only_checker/mod.rs:182: replace ReadOnlyChecker<'a, 'b>::check_reads_only_valid -> CheckResult<()> with CheckResult::from_iter([()])
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:626: replace TypeChecker<'a, 'b>::type_check_define_map -> CheckResult<(ClarityName, (TypeSignature, TypeSignature))> with CheckResult::from_iter([(Default::default(), (Default::default(), Default::default()))])
-clarity/src/vm/ast/parser/v1.rs:101: replace get_value_or_err -> ParseResult<String> with ParseResult::new()
-clarity/src/vm/ast/stack_depth_checker.rs:48: replace <impl BuildASTPass for StackDepthChecker>::run_pass -> ParseResult<()> with ParseResult::new()
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:146: replace ContractContext::add_persisted_variable_type -> CheckResult<()> with CheckResult::new()
-clarity/src/vm/functions/arithmetic.rs:639: replace native_to_int -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
-clarity/src/vm/database/clarity_db.rs:1213: replace ClarityDatabase<'a>::lookup_variable -> Result<Value> with Ok(Default::default())
-clarity/src/vm/functions/arithmetic.rs:391: replace special_geq_v1 -> InterpreterResult<Value> with InterpreterResult::new()
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:792: replace TypeChecker<'a, 'b>::type_check_define_trait -> CheckResult<(ClarityName, BTreeMap<ClarityName, FunctionSignature>)> with CheckResult::from((Default::default(), BTreeMap::new()))
-clarity/src/vm/analysis/read_only_checker/mod.rs:182: replace ReadOnlyChecker<'a, 'b>::check_reads_only_valid -> CheckResult<()> with CheckResult::from(())
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:246: replace Lexer<'a>::read_trait_identifier -> LexResult<Token> with LexResult::from_iter([Default::default()])
-clarity/src/vm/ast/parser/v2/mod.rs:521: replace Parser<'a>::read_principal -> ParseResult<PreSymbolicExpression> with ParseResult::new()
-clarity/src/vm/analysis/trait_checker/mod.rs:55: replace TraitChecker::run -> CheckResult<()> with CheckResult::from_iter([()])
-clarity/src/vm/functions/arithmetic.rs:554: replace native_add -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
-clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs:359: replace check_contract_call -> TypeResult with Default::default()
-clarity/src/vm/test_util/mod.rs:65: replace symbols_from_values -> Vec<SymbolicExpression> with vec![Default::default()]
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:389: replace Lexer<'a>::read_ascii_string -> LexResult<Token> with LexResult::new(Default::default())
-clarity/src/vm/costs/mod.rs:820: replace LimitedCostTracker::get_limit -> ExecutionCost with Default::default()
-clarity/src/vm/functions/arithmetic.rs:579: replace native_bitwise_left_shift -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
-clarity/src/vm/types/signatures.rs:329: replace <impl From for TypeSignature>::from -> Self with Default::default()
-clarity/src/vm/analysis/type_checker/v2_05/natives/assets.rs:195: replace check_special_get_token_supply -> TypeResult with Default::default()
-clarity/src/vm/types/mod.rs:202: replace TraitIdentifier::parse -> Result<(Option<StandardPrincipalData>, ContractName, ClarityName)> with Ok((None, Default::default(), Default::default()))
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:182: replace ContractContext::get_trait -> Option<&BTreeMap<ClarityName, FunctionSignature>> with Some(&BTreeMap::from_iter([(Default::default(), Default::default())]))
-clarity/src/vm/functions/arithmetic.rs:448: replace special_leq_v2 -> InterpreterResult<Value> with InterpreterResult::new()
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:233: replace ContractContext::add_map_type -> CheckResult<()> with CheckResult::from(())
-clarity/src/vm/tests/mod.rs:147: replace TopLevelMemoryEnvironmentGenerator::get_env -> OwnedEnvironment with Default::default()
-clarity/src/vm/functions/arithmetic.rs:532: replace special_less_v2 -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
-clarity/src/vm/types/signatures.rs:128: replace SequenceSubtype::unit_type -> TypeSignature with Default::default()
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:111: replace Lexer<'a>::report_line_ending -> LexResult<()> with LexResult::new()
-clarity/src/vm/functions/arithmetic.rs:377: replace native_bitwise_or -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
-clarity/src/vm/ast/parser/v2/mod.rs:1083: replace Parser<'a>::parse -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::new(vec![Default::default()])
-clarity/src/vm/contexts.rs:852: replace OwnedEnvironment<'a, 'hooks>::destruct -> Option<(ClarityDatabase<'a>, LimitedCostTracker)> with Some((Default::default(), Default::default()))
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:156: replace FunctionType::check_args_2_1 -> CheckResult<TypeSignature> with CheckResult::from(Default::default())
-clarity/src/vm/ast/parser/v2/mod.rs:1093: replace parse -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::new(vec![])
-clarity/src/vm/functions/arithmetic.rs:563: replace native_div -> InterpreterResult<Value> with InterpreterResult::new()
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:839: replace contract_analysis_size -> CheckResult<u64> with CheckResult::from_iter([1])
-clarity/src/vm/functions/mod.rs:197: replace NativeFunctions::lookup_by_name_at_version -> Option<NativeFunctions> with Some(Default::default())
-clarity/src/vm/ast/parser/v2/mod.rs:283: replace Parser<'a>::handle_open_tuple -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::new(Some(Default::default()))
-clarity/src/vm/analysis/analysis_db.rs:189: replace AnalysisDatabase<'a>::get_defined_trait -> CheckResult<Option<BTreeMap<ClarityName, FunctionSignature>>> with CheckResult::from_iter([Some(BTreeMap::from_iter([(Default::default(), Default::default())]))])
-clarity/src/vm/ast/mod.rs:103: replace build_ast_with_rules -> ParseResult<ContractAST> with ParseResult::new()
-clarity/src/vm/functions/arithmetic.rs:490: replace special_greater_v2 -> InterpreterResult<Value> with InterpreterResult::new()
-clarity/src/vm/analysis/read_only_checker/mod.rs:268: replace ReadOnlyChecker<'a, 'b>::try_check_native_function_is_read_only -> Option<CheckResult<bool>> with Some(CheckResult::new(true))
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1229: replace TypeChecker<'a, 'b>::clarity1_type_check_expects -> TypeResult with Default::default()
-clarity/src/vm/functions/arithmetic.rs:391: replace special_geq_v1 -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:415: replace FunctionType::check_args_by_allowing_trait_cast_2_1 -> CheckResult<TypeSignature> with CheckResult::new(Default::default())
-clarity/src/vm/types/signatures.rs:464: replace ListTypeData::destruct -> (TypeSignature, u32) with (Default::default(), 0)
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:86: replace TraitContext::add_used_trait -> CheckResult<()> with CheckResult::new()
-clarity/src/vm/database/key_value_wrapper.rs:466: replace RollbackWrapper<'a>::get_metadata -> InterpreterResult<Option<String>> with InterpreterResult::from(Some("xyzzy".into()))
-clarity/src/vm/functions/arithmetic.rs:572: replace native_log2 -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
-clarity/src/vm/database/clarity_db.rs:1317: replace ClarityDatabase<'a>::fetch_entry_unknown_descriptor -> Result<Value> with Ok(Default::default())
-clarity/src/vm/costs/mod.rs:1186: replace ExecutionCost::runtime -> ExecutionCost with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/natives/options.rs:77: replace check_special_is_response -> TypeResult with Default::default()
-clarity/src/vm/ast/parser/v1.rs:192: replace inner_lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::from(vec![])
-clarity/src/vm/analysis/trait_checker/mod.rs:55: replace TraitChecker::run -> CheckResult<()> with CheckResult::new(())
-clarity/src/vm/ast/definition_sorter/mod.rs:456: replace GraphWalker::get_sorted_dependencies -> ParseResult<Vec<usize>> with ParseResult::new(vec![0])
-clarity/src/vm/representations.rs:586: replace SymbolicExpression::match_atom_value -> Option<&Value> with Some(&Default::default())
-clarity/src/vm/analysis/type_checker/contexts.rs:57: replace TypeMap::set_type -> CheckResult<()> with CheckResult::from(())
-clarity/src/vm/ast/mod.rs:309: replace build_ast -> ParseResult<ContractAST> with ParseResult::new(Default::default())
-clarity/src/vm/contexts.rs:408: replace AssetMap::to_table -> HashMap<PrincipalData, HashMap<AssetIdentifier, AssetMapEntry>> with HashMap::from_iter([(Default::default(), HashMap::new())])
-clarity/src/vm/functions/arithmetic.rs:405: replace special_geq_v2 -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
-clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs:512: replace check_get_block_info -> TypeResult with Default::default()
-clarity/src/vm/analysis/errors.rs:248: replace <impl From for CheckErrors>::from -> Self with Default::default()
-clarity/src/vm/ast/traits_resolver/mod.rs:182: replace TraitsResolver::try_parse_pre_expr -> Option<(DefineFunctions, Vec<&'a PreSymbolicExpression>)> with Some((Default::default(), vec![&Default::default()]))
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:792: replace TypeChecker<'a, 'b>::type_check_define_trait -> CheckResult<(ClarityName, BTreeMap<ClarityName, FunctionSignature>)> with CheckResult::new((Default::default(), BTreeMap::from_iter([(Default::default(), Default::default())])))
-clarity/src/vm/functions/arithmetic.rs:546: replace special_less -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:123: replace <impl AnalysisPass for TypeChecker<'_, '_>>::run_pass -> CheckResult<()> with CheckResult::new(())
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:253: replace ContractContext::add_persisted_variable_type -> CheckResult<()> with CheckResult::new(())
-clarity/src/vm/ast/parser/v2/mod.rs:1093: replace parse -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::from(vec![Default::default()])
-clarity/src/vm/analysis/analysis_db.rs:153: replace AnalysisDatabase<'a>::get_public_function_type -> CheckResult<Option<FunctionType>> with CheckResult::new()
-clarity/src/vm/ast/parser/v2/mod.rs:119: replace Parser<'a>::add_diagnostic -> ParseResult<()> with ParseResult::new(())
-clarity/src/vm/contexts.rs:815: replace OwnedEnvironment<'a, 'hooks>::eval_read_only_with_rules -> Result<(Value, AssetMap, Vec<StacksTransactionEvent>)> with Ok((Default::default(), Default::default(), vec![Default::default()]))
-clarity/src/vm/database/clarity_db.rs:1115: replace map_no_contract_as_none -> Result<Option<T>> with Ok(Some(Default::default()))
-clarity/src/vm/analysis/analysis_db.rs:123: replace AnalysisDatabase<'a>::insert_contract -> CheckResult<()> with CheckResult::from_iter([()])
-clarity/src/vm/test_util/mod.rs:110: replace <impl From for PrincipalData>::from -> PrincipalData with Default::default()
-clarity/src/vm/ast/parser/v1.rs:192: replace inner_lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::from_iter([vec![]])
-clarity/src/vm/database/sqlite.rs:187: replace SqliteConnection::open -> Result<Connection> with Ok(Default::default())
-clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs:489: replace check_secp256k1_recover -> TypeResult with Default::default()
-clarity/src/vm/ast/parser/v2/mod.rs:119: replace Parser<'a>::add_diagnostic -> ParseResult<()> with ParseResult::from_iter([()])
-clarity/src/vm/ast/parser/v1.rs:101: replace get_value_or_err -> ParseResult<String> with ParseResult::new("xyzzy".into())
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:766: replace TypeChecker<'a, 'b>::type_check_define_ft -> CheckResult<ClarityName> with CheckResult::new()
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:831: replace trait_type_size -> CheckResult<u64> with CheckResult::from_iter([1])
-clarity/src/vm/database/clarity_store.rs:243: replace <impl ClarityBackingStore for NullBackingStore>::get_open_chain_tip -> StacksBlockId with Default::default()
-clarity/src/vm/ast/mod.rs:87: replace ast_check_size -> ParseResult<ContractAST> with ParseResult::from(Default::default())
-clarity/src/vm/types/mod.rs:1421: replace <impl From for Value>::from -> Self with Default::default()
-clarity/src/vm/functions/database.rs:333: replace special_set_variable_v205 -> Result<Value> with Ok(Default::default())
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:779: replace TypeChecker<'a, 'b>::type_check_define_nft -> CheckResult<(ClarityName, TypeSignature)> with CheckResult::from_iter([(Default::default(), Default::default())])
-clarity/src/vm/types/mod.rs:169: replace <impl StacksAddressExtensions for StacksAddress>::to_account_principal -> PrincipalData with Default::default()
-clarity/src/vm/ast/parser/v2/mod.rs:283: replace Parser<'a>::handle_open_tuple -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::from_iter([Some(Default::default())])
-clarity/src/vm/analysis/type_checker/mod.rs:45: replace FunctionType::check_args -> CheckResult<TypeSignature> with CheckResult::from_iter([Default::default()])
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:415: replace FunctionType::check_args_by_allowing_trait_cast_2_1 -> CheckResult<TypeSignature> with CheckResult::from(Default::default())
-clarity/src/vm/functions/crypto.rs:139: replace special_secp256k1_recover -> Result<Value> with Ok(Default::default())
-clarity/src/vm/ast/expression_identifier/mod.rs:51: replace ExpressionIdentifier::run_pre_expression_pass -> ParseResult<()> with ParseResult::new()
-clarity/src/vm/ast/parser/v1.rs:455: replace lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::from_iter([vec![(Default::default(), 1, 0)]])
-clarity/src/vm/analysis/trait_checker/mod.rs:55: replace TraitChecker::run -> CheckResult<()> with CheckResult::new()
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:929: replace TypeChecker<'a, 'b>::run -> CheckResult<()> with CheckResult::from(())
-clarity/src/vm/ast/parser/v2/mod.rs:807: replace Parser<'a>::parse_node -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::new()
-clarity/src/vm/contexts.rs:705: replace OwnedEnvironment<'a, 'hooks>::initialize_versioned_contract -> Result<((), AssetMap, Vec<StacksTransactionEvent>)> with Ok(((), Default::default(), vec![Default::default()]))
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:123: replace <impl AnalysisPass for TypeChecker<'_, '_>>::run_pass -> CheckResult<()> with CheckResult::from(())
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1414: replace TypeChecker<'a, 'b>::try_type_check_define -> CheckResult<Option<()>> with CheckResult::from_iter([None])
-clarity/src/vm/ast/parser/v2/mod.rs:1093: replace parse -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::from(vec![])
-clarity/src/vm/errors.rs:163: replace <impl Error for RuntimeErrorType>::source -> Option<&(dyn error::Error +'static)> with Some(&Default::default())
-clarity/src/vm/analysis/analysis_db.rs:123: replace AnalysisDatabase<'a>::insert_contract -> CheckResult<()> with CheckResult::new()
-clarity/src/vm/analysis/types.rs:171: replace ContractAnalysis::get_private_function -> Option<&FunctionType> with Some(&Default::default())
-clarity/src/vm/types/signatures.rs:1167: replace TypeSignature::least_supertype_v2_1 -> Result<TypeSignature> with Ok(Default::default())
-clarity/src/vm/ast/parser/v1.rs:192: replace inner_lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::new(vec![(Default::default(), 0, 1)])
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:233: replace ContractContext::add_map_type -> CheckResult<()> with CheckResult::from_iter([()])
-clarity/src/vm/functions/arithmetic.rs:566: replace native_pow -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
-clarity/src/vm/functions/arithmetic.rs:369: replace native_bitwise_xor -> InterpreterResult<Value> with InterpreterResult::new()
-clarity/src/vm/representations.rs:380: replace PreSymbolicExpression::match_field_identifier -> Option<&TraitIdentifier> with Some(&Default::default())
-clarity/src/vm/database/clarity_store.rs:217: replace NullBackingStore::as_analysis_db -> AnalysisDatabase with Default::default()
-clarity/src/vm/types/mod.rs:676: replace <impl SequencedValue for UTF8Data>::items -> &Vec<Vec<u8>> with &vec![]
-clarity/src/vm/analysis/contract_interface_builder/mod.rs:28: replace build_contract_interface -> ContractInterface with Default::default()
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:152: replace ContractContext::add_ft -> CheckResult<()> with CheckResult::new()
-clarity/src/vm/ast/mod.rs:288: replace build_ast_precheck_size -> ParseResult<ContractAST> with ParseResult::new(Default::default())
-clarity/src/vm/ast/parser/v1.rs:720: replace parse -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::from_iter([vec![]])
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:162: replace ContractContext::add_nft -> CheckResult<()> with CheckResult::from(())
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:116: replace ContractContext::add_private_function_type -> CheckResult<()> with CheckResult::from(())
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:288: replace Lexer<'a>::read_principal -> LexResult<Token> with LexResult::new()
-clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs:221: replace check_special_let -> TypeResult with Default::default()
-clarity/src/vm/ast/parser/v1.rs:720: replace parse -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::from(vec![])
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:345: replace Lexer<'a>::read_hex -> LexResult<Token> with LexResult::from_iter([Default::default()])
-clarity/src/vm/database/key_value_wrapper.rs:466: replace RollbackWrapper<'a>::get_metadata -> InterpreterResult<Option<String>> with InterpreterResult::new(Some(String::new()))
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:345: replace Lexer<'a>::read_hex -> LexResult<Token> with LexResult::new()
-clarity/src/vm/analysis/type_checker/v2_1/natives/options.rs:255: replace check_special_unwrap -> TypeResult with Default::default()
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:136: replace ContractContext::add_variable_type -> CheckResult<()> with CheckResult::new()
-clarity/src/vm/errors.rs:181: replace <impl From for Error>::from -> Self with Default::default()
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:516: replace TypeChecker<'a, 'b>::type_check_all -> CheckResult<Vec<TypeSignature>> with CheckResult::from_iter([vec![Default::default()]])
-clarity/src/vm/analysis/type_checker/mod.rs:45: replace FunctionType::check_args -> CheckResult<TypeSignature> with CheckResult::from(Default::default())
-clarity/src/vm/callables.rs:394: replace FunctionIdentifier::new_user_function -> FunctionIdentifier with Default::default()
-clarity/src/vm/types/signatures.rs:59: replace AssetIdentifier::STX_burned -> AssetIdentifier with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:892: replace TypeChecker<'a, 'b>::into_contract_analysis -> LimitedCostTracker with Default::default()
-clarity/src/vm/costs/mod.rs:395: replace load_cost_functions -> Result<CostStateSummary> with Ok(Default::default())
-clarity/src/vm/errors.rs:205: replace <impl From for Error>::from -> Self with Default::default()
-clarity/src/vm/ast/parser/v2/mod.rs:219: replace Parser<'a>::handle_open_node -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::from(Some(Default::default()))
-clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs:64: replace check_special_list_cons -> TypeResult with Default::default()
-clarity/src/vm/types/mod.rs:1487: replace TupleData::from_data -> Result<TupleData> with Ok(Default::default())
-clarity/src/vm/functions/arithmetic.rs:629: replace native_to_uint -> InterpreterResult<Value> with InterpreterResult::new()
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:190: replace ContractContext::get_variable_type -> Option<&TypeSignature> with Some(&Default::default())
-clarity/src/vm/types/signatures.rs:243: replace FunctionArgSignature::canonicalize -> FunctionArgSignature with Default::default()
-clarity/src/vm/functions/arithmetic.rs:629: replace native_to_uint -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
-clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs:141: replace check_special_get -> TypeResult with Default::default()
-clarity/src/vm/functions/assets.rs:499: replace special_transfer_asset_v200 -> Result<Value> with Ok(Default::default())
-clarity/src/vm/costs/mod.rs:807: replace LimitedCostTracker::get_total -> ExecutionCost with Default::default()
-clarity/src/vm/types/mod.rs:615: replace <impl SequencedValue for ListData>::items -> &Vec<Value> with &vec![]
-clarity/src/vm/database/clarity_db.rs:926: replace ClarityDatabase<'a>::get_burnchain_block_header_hash_for_burnchain_height -> Option<BurnchainHeaderHash> with Some(Default::default())
-clarity/src/vm/ast/mod.rs:130: replace build_ast_typical -> ParseResult<ContractAST> with ParseResult::from(Default::default())
-clarity/src/vm/analysis/type_checker/v2_05/natives/maps.rs:153: replace check_special_set_entry -> TypeResult with Default::default()
-clarity/src/vm/functions/database.rs:555: replace special_insert_entry_v200 -> Result<Value> with Ok(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:929: replace TypeChecker<'a, 'b>::run -> CheckResult<()> with CheckResult::new(())
-clarity/src/vm/contexts.rs:583: replace OwnedEnvironment<'a, 'hooks>::new_max_limit -> OwnedEnvironment<'a, '_> with Default::default()
-clarity/src/vm/analysis/analysis_db.rs:41: replace AnalysisDatabase<'a>::new_with_rollback_wrapper -> AnalysisDatabase<'a> with Default::default()
-clarity/src/vm/functions/arithmetic.rs:448: replace special_leq_v2 -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
-clarity/src/vm/ast/parser/v2/mod.rs:1109: replace parse_collect_diagnostics -> (Vec<PreSymbolicExpression>, Vec<Diagnostic>, bool) with (vec![Default::default()], vec![Default::default()], true)
-clarity/src/vm/database/key_value_wrapper.rs:495: replace RollbackWrapper<'a>::get_metadata_manual -> InterpreterResult<Option<String>> with InterpreterResult::from_iter([Some("xyzzy".into())])
-clarity/src/vm/database/clarity_db.rs:853: replace ClarityDatabase<'a>::get_block_header_hash -> BlockHeaderHash with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1171: replace TypeChecker<'a, 'b>::type_check_function_application -> TypeResult with Default::default()
-clarity/src/vm/database/clarity_db.rs:160: replace <impl HeadersDB for &dyn HeadersDB>::get_burn_header_hash_for_block -> Option<BurnchainHeaderHash> with Some(Default::default())
-clarity/src/vm/mod.rs:545: replace execute_against_version -> Result<Option<Value>> with Ok(Some(Default::default()))
-clarity/src/vm/representations.rs:348: replace PreSymbolicExpression::match_trait_reference -> Option<&ClarityName> with Some(&Default::default())
-clarity/src/vm/types/mod.rs:858: replace Value::error -> Result<Value> with Ok(Default::default())
-clarity/src/vm/database/clarity_db.rs:1141: replace ClarityDatabase<'a>::load_variable -> Result<DataVariableMetadata> with Ok(Default::default())
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:288: replace Lexer<'a>::read_principal -> LexResult<Token> with LexResult::new(Default::default())
-clarity/src/vm/representations.rs:136: replace <impl StacksMessageCodec for ContractName>::consensus_deserialize -> Result<ContractName, codec_error> with Ok(Default::default())
-clarity/src/vm/analysis/read_only_checker/mod.rs:170: replace ReadOnlyChecker<'a, 'b>::check_define_function -> CheckResult<(ClarityName, bool)> with CheckResult::from((Default::default(), true))
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1023: replace TypeChecker<'a, 'b>::type_check_all -> CheckResult<Vec<TypeSignature>> with CheckResult::from_iter([vec![]])
-clarity/src/vm/ast/parser/v1.rs:720: replace parse -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::from(vec![Default::default()])
-clarity/src/vm/functions/options.rs:234: replace native_is_some -> Result<Value> with Ok(Default::default())
-clarity/src/vm/costs/mod.rs:1099: replace <impl FromSql for ExecutionCost>::column_result -> FromSqlResult<ExecutionCost> with FromSqlResult::new()
-clarity/src/vm/functions/arithmetic.rs:391: replace special_geq_v1 -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
-clarity/src/vm/functions/arithmetic.rs:419: replace special_geq -> InterpreterResult<Value> with InterpreterResult::new()
-clarity/src/vm/functions/options.rs:202: replace special_match -> Result<Value> with Ok(Default::default())
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:297: replace trait_type_size -> CheckResult<u64> with CheckResult::from(1)
-clarity/src/vm/database/clarity_db.rs:778: replace ClarityDatabase<'a>::destroy -> RollbackWrapper<'a> with Default::default()
-clarity/src/vm/analysis/read_only_checker/mod.rs:59: replace <impl AnalysisPass for ReadOnlyChecker<'a, 'b>>::run_pass -> CheckResult<()> with CheckResult::from(())
-clarity/src/vm/types/signatures.rs:1312: replace TypeSignature::type_of -> TypeSignature with Default::default()
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:808: replace TypeChecker<'a, 'b>::try_type_check_define -> CheckResult<Option<()>> with CheckResult::new()
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:808: replace TypeChecker<'a, 'b>::try_type_check_define -> CheckResult<Option<()>> with CheckResult::from(Some(()))
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:243: replace ContractContext::add_variable_type -> CheckResult<()> with CheckResult::new(())
-clarity/src/vm/types/mod.rs:1533: replace TupleData::shallow_merge -> Result<TupleData> with Ok(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/natives/maps.rs:73: replace check_special_delete_entry -> TypeResult with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs:422: replace check_special_slice -> TypeResult with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:415: replace FunctionType::check_args_by_allowing_trait_cast_2_1 -> CheckResult<TypeSignature> with CheckResult::from_iter([Default::default()])
-clarity/src/vm/ast/parser/v1.rs:508: replace parse_lexed -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::from_iter([vec![Default::default()]])
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:296: replace ContractContext::add_implemented_trait -> CheckResult<()> with CheckResult::new()
-clarity/src/vm/analysis/type_checker/v2_05/natives/options.rs:165: replace inner_unwrap_err -> TypeResult with Default::default()
-clarity/src/vm/types/mod.rs:676: replace <impl SequencedValue for UTF8Data>::items -> &Vec<Vec<u8>> with &vec![vec![1]]
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:311: replace Lexer<'a>::read_unsigned -> LexResult<Token> with LexResult::from_iter([Default::default()])
-clarity/src/vm/contexts.rs:1903: replace LocalContext<'a>::lookup_variable -> Option<&Value> with Some(&Default::default())
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:288: replace Lexer<'a>::read_principal -> LexResult<Token> with LexResult::from_iter([Default::default()])
-clarity/src/vm/analysis/type_checker/v2_05/natives/sequences.rs:118: replace check_special_filter -> TypeResult with Default::default()
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:626: replace TypeChecker<'a, 'b>::type_check_define_map -> CheckResult<(ClarityName, (TypeSignature, TypeSignature))> with CheckResult::new()
-clarity/src/vm/costs/mod.rs:1099: replace <impl FromSql for ExecutionCost>::column_result -> FromSqlResult<ExecutionCost> with FromSqlResult::from_iter([Default::default()])
-clarity/src/vm/functions/define.rs:277: replace DefineFunctions::try_parse -> Option<(DefineFunctions, &[SymbolicExpression])> with Some((Default::default(), Vec::leak(vec![Default::default()])))
-clarity/src/vm/ast/definition_sorter/mod.rs:433: replace Graph::edges_count -> ParseResult<u64> with ParseResult::from_iter([1])
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:516: replace TypeChecker<'a, 'b>::type_check_all -> CheckResult<Vec<TypeSignature>> with CheckResult::from(vec![])
-clarity/src/vm/functions/options.rs:250: replace native_okay -> Result<Value> with Ok(Default::default())
-clarity/src/vm/types/serialization.rs:295: replace <impl StacksMessageCodec for PrincipalData>::consensus_deserialize -> Result<PrincipalData, codec_error> with Ok(Default::default())
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:128: replace Lexer<'a>::skip_whitespace -> LexResult<()> with LexResult::from(())
-clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs:292: replace check_special_set_var -> TypeResult with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1156: replace TypeChecker<'a, 'b>::try_native_function_check -> Option<TypeResult> with Some(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:243: replace ContractContext::add_variable_type -> CheckResult<()> with CheckResult::from_iter([()])
-clarity/src/vm/functions/crypto.rs:181: replace special_secp256k1_verify -> Result<Value> with Ok(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:929: replace TypeChecker<'a, 'b>::run -> CheckResult<()> with CheckResult::new()
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:740: replace TypeChecker<'a, 'b>::type_check_define_variable -> CheckResult<(ClarityName, TypeSignature)> with CheckResult::new((Default::default(), Default::default()))
-clarity/src/vm/types/signatures.rs:972: replace TypeSignature::min_string_utf8 -> TypeSignature with Default::default()
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:535: replace TypeChecker<'a, 'b>::get_function_type -> Option<FunctionType> with Some(Default::default())
-clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs:452: replace check_contract_of -> TypeResult with Default::default()
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:185: replace Lexer<'a>::proceed_through_error_string -> LexResult<String> with LexResult::from_iter(["xyzzy".into()])
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:162: replace ContractContext::add_nft -> CheckResult<()> with CheckResult::new()
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:388: replace TypeChecker<'a, 'b>::run -> CheckResult<()> with CheckResult::new()
-clarity/src/vm/analysis/type_checker/v2_1/natives/options.rs:267: replace check_special_unwrap_err -> TypeResult with Default::default()
-clarity/src/vm/mod.rs:136: replace CostSynthesis::from_cost_tracker -> CostSynthesis with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:839: replace contract_analysis_size -> CheckResult<u64> with CheckResult::from(0)
-clarity/src/vm/types/mod.rs:661: replace <impl SequencedValue for ASCIIData>::type_signature -> TypeSignature with Default::default()
-clarity/src/vm/functions/arithmetic.rs:373: replace native_bitwise_and -> InterpreterResult<Value> with InterpreterResult::new()
-clarity/src/vm/functions/arithmetic.rs:364: replace native_xor -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:210: replace Lexer<'a>::read_identifier -> LexResult<Token> with LexResult::new(Default::default())
-clarity/src/vm/analysis/type_checker/contexts.rs:57: replace TypeMap::set_type -> CheckResult<()> with CheckResult::from_iter([()])
-clarity/src/vm/types/mod.rs:633: replace <impl SequencedValue for BuffData>::items -> &Vec<u8> with &vec![1]
-clarity/src/vm/ast/definition_sorter/mod.rs:307: replace DefinitionSorter::probe_for_dependencies_in_tuple -> ParseResult<()> with ParseResult::new()
-clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs:538: replace TypedNativeFunction::type_check_application -> TypeResult with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1414: replace TypeChecker<'a, 'b>::try_type_check_define -> CheckResult<Option<()>> with CheckResult::new(None)
-clarity/src/vm/ast/parser/v1.rs:720: replace parse -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::from_iter([vec![Default::default()]])
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:279: replace ContractContext::add_defined_trait -> CheckResult<()> with CheckResult::new()
-clarity/src/vm/database/key_value_wrapper.rs:402: replace RollbackWrapper<'a>::get_value -> Result<Option<ValueResult>, SerializationError> with Ok(Some(Default::default()))
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:146: replace ContractContext::add_persisted_variable_type -> CheckResult<()> with CheckResult::from_iter([()])
-clarity/src/vm/errors.rs:216: replace <impl From for Value>::from -> Self with Default::default()
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:246: replace Lexer<'a>::read_trait_identifier -> LexResult<Token> with LexResult::new()
-clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs:118: replace check_special_filter -> TypeResult with Default::default()
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:311: replace Lexer<'a>::read_unsigned -> LexResult<Token> with LexResult::new()
-clarity/src/vm/functions/boolean.rs:74: replace native_not -> Result<Value> with Ok(Default::default())
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:152: replace ContractContext::add_ft -> CheckResult<()> with CheckResult::from_iter([()])
-clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs:167: replace check_special_merge -> TypeResult with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:243: replace ContractContext::add_variable_type -> CheckResult<()> with CheckResult::new()
-clarity/src/vm/analysis/mod.rs:122: replace run_analysis -> Result<ContractAnalysis, (CheckError, LimitedCostTracker)> with Ok(Default::default())
-clarity/src/vm/docs/contracts.rs:62: replace get_constant_value -> Value with Default::default()
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:86: replace <impl CostTracker for TypeChecker<'_, '_>>::compute_cost -> Result<ExecutionCost, CostErrors> with Ok(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs:264: replace check_special_append -> TypeResult with Default::default()
-clarity/src/vm/database/key_value_wrapper.rs:495: replace RollbackWrapper<'a>::get_metadata_manual -> InterpreterResult<Option<String>> with InterpreterResult::new(Some("xyzzy".into()))
-clarity/src/vm/functions/conversions.rs:128: replace native_string_to_int_generic -> Result<Value> with Ok(Default::default())
-clarity/src/vm/functions/arithmetic.rs:569: replace native_sqrti -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:415: replace FunctionType::check_args_by_allowing_trait_cast_2_1 -> CheckResult<TypeSignature> with CheckResult::new()
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:516: replace TypeChecker<'a, 'b>::type_check_all -> CheckResult<Vec<TypeSignature>> with CheckResult::from_iter([vec![]])
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:259: replace ContractContext::add_ft -> CheckResult<()> with CheckResult::new()
-clarity/src/vm/ast/parser/v2/mod.rs:1083: replace Parser<'a>::parse -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::from_iter([vec![Default::default()]])
-clarity/src/vm/types/signatures.rs:962: replace TypeSignature::min_buffer -> TypeSignature with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1283: replace TypeChecker<'a, 'b>::clarity2_type_check_expects -> TypeResult with Default::default()
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:106: replace ContractContext::add_read_only_function_type -> CheckResult<()> with CheckResult::new(())
-clarity/src/vm/functions/arithmetic.rs:405: replace special_geq_v2 -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
-clarity/src/vm/functions/define.rs:263: replace handle_use_trait -> Result<DefineResult> with Ok(Default::default())
-clarity/src/vm/functions/options.rs:238: replace native_is_none -> Result<Value> with Ok(Default::default())
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:78: replace Lexer<'a>::read_char -> LexResult<()> with LexResult::from(())
-clarity/src/vm/analysis/type_checker/v2_05/natives/maps.rs:34: replace check_special_fetch_entry -> TypeResult with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:839: replace contract_analysis_size -> CheckResult<u64> with CheckResult::new(0)
-clarity/src/vm/analysis/analysis_db.rs:137: replace AnalysisDatabase<'a>::get_clarity_version -> CheckResult<ClarityVersion> with CheckResult::from(Default::default())
-clarity/src/vm/analysis/contract_interface_builder/mod.rs:170: replace ContractInterfaceAtomType::vec_from_tuple_type -> Vec<ContractInterfaceTupleEntryType> with vec![Default::default()]
-clarity/src/vm/functions/crypto.rs:83: replace pubkey_to_address_v2 -> StacksAddress with Default::default()
-clarity/src/vm/tests/mod.rs:137: replace MemoryEnvironmentGenerator::get_env -> OwnedEnvironment with Default::default()
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:358: replace TypeChecker<'a, 'b>::track_return_type -> CheckResult<()> with CheckResult::new()
-clarity/src/vm/types/mod.rs:742: replace BlockInfoProperty::type_result -> TypeSignature with Default::default()
-clarity/src/vm/ast/mod.rs:69: replace parse_in_epoch -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::from(vec![Default::default()])
-clarity/src/vm/types/mod.rs:1135: replace Value::expect_result -> std::result::Result<Value, Value> with Ok(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1136: replace TypeChecker<'a, 'b>::type_check_define_map -> CheckResult<(ClarityName, (TypeSignature, TypeSignature))> with CheckResult::new()
-clarity/src/vm/types/mod.rs:676: replace <impl SequencedValue for UTF8Data>::items -> &Vec<Vec<u8>> with &vec![vec![0]]
-clarity/src/vm/contexts.rs:845: replace OwnedEnvironment<'a, 'hooks>::get_cost_total -> ExecutionCost with Default::default()
-clarity/src/vm/functions/arithmetic.rs:59: replace UTF8Ops::make_value -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
-clarity/src/vm/analysis/read_only_checker/mod.rs:88: replace ReadOnlyChecker<'a, 'b>::run -> CheckResult<()> with CheckResult::new()
-clarity/src/vm/ast/stack_depth_checker.rs:74: replace <impl BuildASTPass for VaryStackDepthChecker>::run_pass -> ParseResult<()> with ParseResult::from(())
-clarity/src/vm/ast/traits_resolver/mod.rs:48: replace TraitsResolver::run -> ParseResult<()> with ParseResult::from_iter([()])
-clarity/src/vm/mod.rs:513: replace execute_with_parameters -> Result<Option<Value>> with Ok(Some(Default::default()))
-clarity/src/vm/functions/conversions.rs:97: replace native_buff_to_uint_le::convert_to_uint_le -> Value with Default::default()
-clarity/src/vm/database/key_value_wrapper.rs:466: replace RollbackWrapper<'a>::get_metadata -> InterpreterResult<Option<String>> with InterpreterResult::from_iter([Some(String::new())])
-clarity/src/vm/types/mod.rs:910: replace Value::cons_list_unsanitized -> Result<Value> with Ok(Default::default())
-clarity/src/vm/database/key_value_wrapper.rs:59: replace rollback_check_pre_bottom_commit -> Vec<(T, String)> with vec![(Default::default(), String::new())]
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1398: replace TypeChecker<'a, 'b>::type_check_define_trait -> CheckResult<(ClarityName, BTreeMap<ClarityName, FunctionSignature>)> with CheckResult::from((Default::default(), BTreeMap::from_iter([(Default::default(), Default::default())])))
-clarity/src/vm/functions/arithmetic.rs:579: replace native_bitwise_left_shift -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
-clarity/src/vm/ast/definition_sorter/mod.rs:115: replace DefinitionSorter::probe_for_dependencies -> ParseResult<()> with ParseResult::from(())
-clarity/src/vm/ast/parser/v2/mod.rs:1109: replace parse_collect_diagnostics -> (Vec<PreSymbolicExpression>, Vec<Diagnostic>, bool) with (vec![Default::default()], vec![Default::default()], false)
-clarity/src/vm/analysis/analysis_db.rs:189: replace AnalysisDatabase<'a>::get_defined_trait -> CheckResult<Option<BTreeMap<ClarityName, FunctionSignature>>> with CheckResult::from(Some(BTreeMap::new()))
-clarity/src/vm/ast/parser/v2/mod.rs:219: replace Parser<'a>::handle_open_node -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::from_iter([None])
-clarity/src/vm/functions/arithmetic.rs:373: replace native_bitwise_and -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1044: replace TypeChecker<'a, 'b>::get_function_type -> Option<FunctionType> with Some(Default::default())
-clarity/src/vm/costs/mod.rs:712: replace LimitedCostTracker::new_free -> LimitedCostTracker with Default::default()
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:751: replace TypeChecker<'a, 'b>::type_check_define_persisted_variable -> CheckResult<(ClarityName, TypeSignature)> with CheckResult::new((Default::default(), Default::default()))
-clarity/src/vm/functions/assets.rs:590: replace special_transfer_asset_v205 -> Result<Value> with Ok(Default::default())
-clarity/src/vm/functions/define.rs:230: replace handle_define_map -> Result<DefineResult> with Ok(Default::default())
-clarity/src/vm/clarity.rs:84: replace <impl From for Error>::from -> Self with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1357: replace TypeChecker<'a, 'b>::type_check_define_persisted_variable -> CheckResult<(ClarityName, TypeSignature)> with CheckResult::from((Default::default(), Default::default()))
-clarity/src/vm/types/mod.rs:1238: replace UTF8Data::len -> BufferLength with Default::default()
-clarity/src/vm/errors.rs:187: replace <impl From for Error>::from -> Self with Default::default()
-clarity/src/vm/analysis/type_checker/v2_05/natives/assets.rs:135: replace check_special_transfer_asset -> TypeResult with Default::default()
-clarity/src/vm/types/mod.rs:627: replace <impl SequencedValue for ListData>::to_value -> Value with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/natives/assets.rs:61: replace check_special_get_balance -> TypeResult with Default::default()
-clarity/src/vm/analysis/type_checker/v2_05/natives/assets.rs:77: replace check_special_mint_asset -> TypeResult with Default::default()
-clarity/src/vm/analysis/type_checker/v2_05/natives/options.rs:278: replace eval_with_new_binding -> TypeResult with Default::default()
-clarity/src/vm/ast/mod.rs:69: replace parse_in_epoch -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::from(vec![])
-clarity/src/vm/functions/options.rs:66: replace native_unwrap_or_ret -> Result<Value> with Ok(Default::default())
-clarity/src/vm/ast/parser/v1.rs:508: replace parse_lexed -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::from_iter([vec![]])
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:474: replace Lexer<'a>::read_utf8_encoding -> LexResult<Result<String, String>> with LexResult::from(Ok("xyzzy".into()))
-clarity/src/vm/ast/parser/v1.rs:455: replace lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::new(vec![])
-clarity/src/vm/ast/stack_depth_checker.rs:28: replace check -> ParseResult<()> with ParseResult::from(())
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:474: replace Lexer<'a>::read_utf8_encoding -> LexResult<Result<String, String>> with LexResult::from_iter([Ok(String::new())])
-clarity/src/vm/analysis/types.rs:175: replace ContractAnalysis::get_map_type -> Option<&(TypeSignature, TypeSignature)> with Some(&(Default::default(), Default::default()))
-clarity/src/vm/types/signatures.rs:1388: replace TypeSignature::parse_list_type_repr -> Result<TypeSignature> with Ok(Default::default())
-clarity/src/vm/docs/mod.rs:2419: replace make_api_reference -> FunctionAPI with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:571: replace clarity2_trait_check_trait_compliance -> CheckResult<()> with CheckResult::from_iter([()])
-clarity/src/vm/functions/arithmetic.rs:563: replace native_div -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
-clarity/src/vm/types/signatures.rs:939: replace FunctionSignature::canonicalize -> FunctionSignature with Default::default()
-clarity/src/vm/contexts.rs:974: replace Environment<'a, 'b, 'hooks>::nest_with_caller -> Environment<'c, 'b, 'hooks> with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/natives/options.rs:202: replace check_special_unwrap_err_or_ret -> TypeResult with Default::default()
-clarity/src/vm/analysis/type_checker/v2_05/natives/options.rs:214: replace check_special_try_ret -> TypeResult with Default::default()
-clarity/src/vm/database/clarity_db.rs:793: replace ClarityDatabase<'a>::get_index_block_header_hash -> StacksBlockId with Default::default()
-clarity/src/vm/callables.rs:335: replace DefinedFunction::apply -> Result<Value> with Ok(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1385: replace TypeChecker<'a, 'b>::type_check_define_nft -> CheckResult<(ClarityName, TypeSignature)> with CheckResult::new((Default::default(), Default::default()))
-clarity/src/vm/ast/mod.rs:309: replace build_ast -> ParseResult<ContractAST> with ParseResult::from_iter([Default::default()])
-clarity/src/vm/representations.rs:372: replace PreSymbolicExpression::match_list -> Option<&[PreSymbolicExpression]> with Some(Vec::leak(vec![Default::default()]))
-clarity/src/vm/analysis/type_checker/v2_05/natives/options.rs:199: replace check_special_unwrap_err_or_ret -> TypeResult with Default::default()
-clarity/src/vm/ast/definition_sorter/mod.rs:369: replace DefinitionSorter::probe_for_dependencies_in_key_value_pair -> ParseResult<()> with ParseResult::from_iter([()])
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:247: replace FunctionType::check_args_by_allowing_trait_cast_2_05 -> CheckResult<TypeSignature> with CheckResult::new(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:223: replace ContractContext::add_private_function_type -> CheckResult<()> with CheckResult::new()
-clarity/src/vm/types/mod.rs:1507: replace TupleData::from_data_typed -> Result<TupleData> with Ok(Default::default())
-clarity/src/vm/analysis/analysis_db.rs:171: replace AnalysisDatabase<'a>::get_read_only_function_type -> CheckResult<Option<FunctionType>> with CheckResult::new(None)
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:474: replace Lexer<'a>::read_utf8_encoding -> LexResult<Result<String, String>> with LexResult::from_iter([Ok("xyzzy".into())])
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:297: replace trait_type_size -> CheckResult<u64> with CheckResult::from_iter([0])
-clarity/src/vm/ast/expression_identifier/mod.rs:23: replace inner_relabel -> ParseResult<u64> with ParseResult::from_iter([1])
-clarity/src/vm/database/clarity_db.rs:1813: replace ClarityDatabase<'a>::get_nft_key_type -> Result<TypeSignature> with Ok(Default::default())
-clarity/src/vm/functions/arithmetic.rs:41: replace U128Ops::make_value -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:145: replace FunctionType::check_args_2_05 -> CheckResult<TypeSignature> with CheckResult::new()
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:203: replace ContractContext::add_public_function_type -> CheckResult<()> with CheckResult::new()
-clarity/src/vm/representations.rs:578: replace SymbolicExpression::match_atom -> Option<&ClarityName> with Some(&Default::default())
-clarity/src/vm/ast/sugar_expander/mod.rs:40: replace <impl BuildASTPass for SugarExpander>::run_pass -> ParseResult<()> with ParseResult::new()
-clarity/src/vm/analysis/read_only_checker/mod.rs:88: replace ReadOnlyChecker<'a, 'b>::run -> CheckResult<()> with CheckResult::from(())
-clarity/src/vm/types/signatures.rs:401: replace <impl TryFrom for StringUTF8Length>::try_from -> Result<StringUTF8Length> with Ok(Default::default())
-clarity/src/vm/database/key_value_wrapper.rs:338: replace RollbackWrapper<'a>::set_block_hash -> InterpreterResult<StacksBlockId> with InterpreterResult::new()
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:785: replace clarity2_lookup_trait -> CheckResult<BTreeMap<ClarityName, FunctionSignature>> with CheckResult::new(BTreeMap::new())
-clarity/src/vm/representations.rs:327: replace PreSymbolicExpression::tuple -> PreSymbolicExpression with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs:637: replace check_get_block_info -> TypeResult with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:831: replace trait_type_size -> CheckResult<u64> with CheckResult::new(0)
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:140: replace Lexer<'a>::read_line -> LexResult<String> with LexResult::from(String::new())
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1198: replace TypeChecker<'a, 'b>::lookup_variable -> TypeResult with Default::default()
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:345: replace Lexer<'a>::read_hex -> LexResult<Token> with LexResult::from(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs:296: replace check_special_as_max_len -> TypeResult with Default::default()
-clarity/src/vm/types/mod.rs:633: replace <impl SequencedValue for BuffData>::items -> &Vec<u8> with &vec![0]
-clarity/src/vm/database/clarity_db.rs:867: replace ClarityDatabase<'a>::get_burnchain_block_header_hash -> BurnchainHeaderHash with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:316: replace ContractContext::get_persisted_variable_type -> Option<&TypeSignature> with Some(&Default::default())
-clarity/src/vm/database/clarity_store.rs:303: replace <impl ClarityBackingStore for MemoryBackingStore>::get_side_store -> &Connection with &Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:123: replace <impl AnalysisPass for TypeChecker<'_, '_>>::run_pass -> CheckResult<()> with CheckResult::new()
-clarity/src/vm/types/serialization.rs:160: replace <impl From for TypePrefix>::from -> TypePrefix with Default::default()
-clarity/src/vm/database/clarity_db.rs:1637: replace ClarityDatabase<'a>::create_non_fungible_token -> NonFungibleTokenMetadata with Default::default()
-clarity/src/vm/functions/arithmetic.rs:504: replace special_greater -> InterpreterResult<Value> with InterpreterResult::new()
-clarity/src/vm/functions/principals.rs:188: replace special_principal_construct -> Result<Value> with Ok(Default::default())
-clarity/src/vm/representations.rs:594: replace SymbolicExpression::match_literal_value -> Option<&Value> with Some(&Default::default())
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:779: replace TypeChecker<'a, 'b>::type_check_define_nft -> CheckResult<(ClarityName, TypeSignature)> with CheckResult::new()
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1357: replace TypeChecker<'a, 'b>::type_check_define_persisted_variable -> CheckResult<(ClarityName, TypeSignature)> with CheckResult::from_iter([(Default::default(), Default::default())])
-clarity/src/vm/types/mod.rs:845: replace Value::okay -> Result<Value> with Ok(Default::default())
-clarity/src/vm/ast/types.rs:55: replace ContractAST::pre_expressions_drain -> PreExpressionsDrain with Default::default()
-clarity/src/vm/types/mod.rs:955: replace Value::string_ascii_from_bytes -> Result<Value> with Ok(Default::default())
-clarity/src/vm/ast/definition_sorter/mod.rs:345: replace DefinitionSorter::probe_for_dependencies_in_list_of_wrapped_key_value_pairs -> ParseResult<()> with ParseResult::new()
-clarity/src/vm/database/key_value_wrapper.rs:466: replace RollbackWrapper<'a>::get_metadata -> InterpreterResult<Option<String>> with InterpreterResult::new(None)
-clarity/src/vm/analysis/read_only_checker/mod.rs:170: replace ReadOnlyChecker<'a, 'b>::check_define_function -> CheckResult<(ClarityName, bool)> with CheckResult::new((Default::default(), true))
-clarity/src/vm/types/mod.rs:615: replace <impl SequencedValue for ListData>::items -> &Vec<Value> with &vec![Default::default()]
-clarity/src/vm/types/signatures.rs:335: replace <impl From for TypeSignature>::from -> Self with Default::default()
-clarity/src/vm/types/mod.rs:195: replace TraitIdentifier::parse_sugared_syntax -> Result<(ContractName, ClarityName)> with Ok((Default::default(), Default::default()))
-clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs:57: replace check_special_list_cons -> TypeResult with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:86: replace TraitContext::add_used_trait -> CheckResult<()> with CheckResult::from_iter([()])
-clarity/src/vm/analysis/analysis_db.rs:189: replace AnalysisDatabase<'a>::get_defined_trait -> CheckResult<Option<BTreeMap<ClarityName, FunctionSignature>>> with CheckResult::from(None)
-clarity/src/vm/types/mod.rs:619: replace <impl SequencedValue for ListData>::drained_items -> Vec<Value> with vec![Default::default()]
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:118: replace <impl AnalysisPass for TypeChecker<'_, '_>>::run_pass -> CheckResult<()> with CheckResult::new()
-clarity/src/vm/analysis/read_only_checker/mod.rs:281: replace ReadOnlyChecker<'a, 'b>::check_native_function_is_read_only -> CheckResult<bool> with CheckResult::new(false)
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:516: replace TypeChecker<'a, 'b>::type_check_all -> CheckResult<Vec<TypeSignature>> with CheckResult::from(vec![Default::default()])
-clarity/src/vm/ast/expression_identifier/mod.rs:40: replace update_expression_id -> ParseResult<()> with ParseResult::new()
-clarity/src/vm/analysis/type_checker/v2_1/natives/assets.rs:200: replace check_special_stx_transfer -> TypeResult with Default::default()
-clarity/src/vm/types/signatures.rs:1431: replace TypeSignature::parse_string_utf8_type_repr -> Result<TypeSignature> with Ok(Default::default())
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:546: replace TypeChecker<'a, 'b>::type_check_define_function -> CheckResult<(ClarityName, FixedFunction)> with CheckResult::from_iter([(Default::default(), Default::default())])
-clarity/src/vm/database/key_value_wrapper.rs:354: replace RollbackWrapper<'a>::get_with_proof -> Option<(T, Vec<u8>)> with Some((Default::default(), vec![0]))
-clarity/src/vm/analysis/types.rs:230: replace ContractAnalysis::check_trait_compliance -> CheckResult<()> with CheckResult::from(())
-clarity/src/vm/ast/errors.rs:141: replace <impl Error for ParseError>::source -> Option<&(dyn error::Error +'static)> with Some(&Default::default())
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:740: replace TypeChecker<'a, 'b>::type_check_define_variable -> CheckResult<(ClarityName, TypeSignature)> with CheckResult::from_iter([(Default::default(), Default::default())])
-clarity/src/vm/analysis/type_checker/v2_1/natives/maps.rs:33: replace check_special_fetch_entry -> TypeResult with Default::default()
-clarity/src/vm/database/key_value_wrapper.rs:338: replace RollbackWrapper<'a>::set_block_hash -> InterpreterResult<StacksBlockId> with InterpreterResult::new(Default::default())
-clarity/src/vm/diagnostic.rs:47: replace Diagnostic::err -> Diagnostic with Default::default()
-clarity/src/vm/database/clarity_db.rs:1154: replace ClarityDatabase<'a>::set_variable_unknown_descriptor -> Result<Value> with Ok(Default::default())
-clarity/src/vm/functions/arithmetic.rs:518: replace special_less_v1 -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
-clarity/src/vm/functions/assets.rs:166: replace special_stx_transfer -> Result<Value> with Ok(Default::default())
-clarity/src/vm/analysis/type_checker/contexts.rs:57: replace TypeMap::set_type -> CheckResult<()> with CheckResult::new()
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:246: replace Lexer<'a>::read_trait_identifier -> LexResult<Token> with LexResult::from(Default::default())
-clarity/src/vm/types/signatures.rs:887: replace TupleTypeSignature::parse_name_type_pair_list -> Result<TupleTypeSignature> with Ok(Default::default())
-clarity/src/vm/types/mod.rs:820: replace Value::none -> Value with Default::default()
-clarity/src/vm/ast/expression_identifier/mod.rs:23: replace inner_relabel -> ParseResult<u64> with ParseResult::new()
-clarity/src/vm/contexts.rs:1669: replace GlobalContext<'a, 'hooks>::special_cc_handler_execute_read_only -> std::result::Result<A, E> with Ok(Default::default())
-clarity/src/vm/types/mod.rs:1456: replace <impl From for ASCIIData>::from -> Self with Default::default()
-clarity/src/vm/database/clarity_db.rs:1651: replace ClarityDatabase<'a>::load_nft -> Result<NonFungibleTokenMetadata> with Ok(Default::default())
-clarity/src/vm/functions/database.rs:682: replace special_delete_entry_v205 -> Result<Value> with Ok(Default::default())
-clarity/src/vm/analysis/read_only_checker/mod.rs:281: replace ReadOnlyChecker<'a, 'b>::check_native_function_is_read_only -> CheckResult<bool> with CheckResult::new()
-clarity/src/vm/functions/mod.rs:785: replace special_contract_of -> Result<Value> with Ok(Default::default())
-clarity/src/vm/analysis/analysis_db.rs:93: replace AnalysisDatabase<'a>::load_contract_non_canonical -> Option<ContractAnalysis> with Some(Default::default())
-clarity/src/vm/contexts.rs:1118: replace Environment<'a, 'b, 'hooks>::execute_contract_allow_private -> Result<Value> with Ok(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:233: replace ContractContext::add_map_type -> CheckResult<()> with CheckResult::new()
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:899: replace TypeChecker<'a, 'b>::track_return_type -> CheckResult<()> with CheckResult::new()
-clarity/src/vm/ast/parser/v2/mod.rs:188: replace Parser<'a>::ignore_whitespace_and_comments -> Vec<PreSymbolicExpression> with vec![Default::default()]
-clarity/src/vm/analysis/type_checker/v2_05/natives/options.rs:110: replace check_special_default_to -> TypeResult with Default::default()
-clarity/src/vm/ast/definition_sorter/mod.rs:456: replace GraphWalker::get_sorted_dependencies -> ParseResult<Vec<usize>> with ParseResult::from_iter([vec![1]])
-clarity/src/vm/ast/mod.rs:130: replace build_ast_typical -> ParseResult<ContractAST> with ParseResult::new()
-clarity/src/vm/analysis/type_checker/v2_05/natives/options.rs:264: replace check_special_unwrap_err -> TypeResult with Default::default()
-clarity/src/vm/contexts.rs:1913: replace LocalContext<'a>::lookup_callable_contract -> Option<&CallableData> with Some(&Default::default())
-clarity/src/vm/functions/tuples.rs:47: replace tuple_get -> Result<Value> with Ok(Default::default())
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:247: replace FunctionType::check_args_by_allowing_trait_cast_2_05 -> CheckResult<TypeSignature> with CheckResult::new()
-clarity/src/vm/functions/conversions.rs:89: replace native_buff_to_int_le::convert_to_int_le -> Value with Default::default()
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:326: replace Lexer<'a>::read_integer -> LexResult<Token> with LexResult::new(Default::default())
-clarity/src/vm/functions/database.rs:293: replace special_set_variable_v200 -> Result<Value> with Ok(Default::default())
-clarity/src/vm/ast/definition_sorter/mod.rs:379: replace DefinitionSorter::find_expression_definition -> Option<(ClarityName, u64, &'b PreSymbolicExpression)> with Some((Default::default(), 1, &Default::default()))
-clarity/src/vm/representations.rs:285: replace PreSymbolicExpression::sugared_field_identifier -> PreSymbolicExpression with Default::default()
-clarity/src/vm/contexts.rs:815: replace OwnedEnvironment<'a, 'hooks>::eval_read_only_with_rules -> Result<(Value, AssetMap, Vec<StacksTransactionEvent>)> with Ok((Default::default(), Default::default(), vec![]))
-clarity/src/vm/functions/conversions.rs:205: replace native_int_to_ascii -> Result<Value> with Ok(Default::default())
-clarity/src/vm/ast/parser/v2/mod.rs:158: replace Parser<'a>::peek_last_token -> ParseResult<&PlacedToken> with ParseResult::new(&Default::default())
-clarity/src/vm/ast/parser/v1.rs:455: replace lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::new(vec![(Default::default(), 1, 0)])
-clarity/src/vm/functions/assets.rs:368: replace special_mint_asset_v200 -> Result<Value> with Ok(Default::default())
-clarity/src/vm/contexts.rs:1882: replace LocalContext<'a>::function_context -> &LocalContext with &Default::default()
-clarity/src/vm/ast/mod.rs:87: replace ast_check_size -> ParseResult<ContractAST> with ParseResult::new(Default::default())
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:247: replace FunctionType::check_args_by_allowing_trait_cast_2_05 -> CheckResult<TypeSignature> with CheckResult::from(Default::default())
-clarity/src/vm/ast/mod.rs:174: replace inner_build_ast -> ParseResult<(ContractAST, Vec<Diagnostic>, bool)> with ParseResult::new()
-clarity/src/vm/types/signatures.rs:1356: replace TypeSignature::parent_list_type -> std::result::Result<ListTypeData, CheckErrors> with Ok(Default::default())
-clarity/src/vm/functions/sequences.rs:359: replace special_slice -> Result<Value> with Ok(Default::default())
-clarity/src/vm/functions/mod.rs:645: replace special_asserts -> Result<Value> with Ok(Default::default())
-clarity/src/vm/ast/definition_sorter/mod.rs:433: replace Graph::edges_count -> ParseResult<u64> with ParseResult::new(1)
-clarity/src/vm/types/serialization.rs:348: replace DeserializeStackItem::next_expected_type -> Result<Option<TypeSignature>, SerializationError> with Ok(Some(Default::default()))
-clarity/src/vm/analysis/type_checker/v2_05/natives/options.rs:131: replace check_special_asserts -> TypeResult with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:929: replace TypeChecker<'a, 'b>::run -> CheckResult<()> with CheckResult::from_iter([()])
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:474: replace Lexer<'a>::read_utf8_encoding -> LexResult<Result<String, String>> with LexResult::new()
-clarity/src/vm/ast/parser/v2/mod.rs:521: replace Parser<'a>::read_principal -> ParseResult<PreSymbolicExpression> with ParseResult::new(Default::default())
-clarity/src/vm/database/key_value_wrapper.rs:219: replace RollbackWrapper<'a>::from_persisted_log -> RollbackWrapper with Default::default()
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:661: replace TypeChecker<'a, 'b>::type_check_function_application -> TypeResult with Default::default()
-clarity/src/vm/ast/parser/v2/mod.rs:1062: replace Parser<'a>::parse_node_or_eof -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::new()
-clarity/src/vm/ast/expression_identifier/mod.rs:51: replace ExpressionIdentifier::run_pre_expression_pass -> ParseResult<()> with ParseResult::new(())
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:259: replace ContractContext::add_ft -> CheckResult<()> with CheckResult::from_iter([()])
-clarity/src/vm/ast/mod.rs:309: replace build_ast -> ParseResult<ContractAST> with ParseResult::from(Default::default())
-clarity/src/vm/functions/options.rs:44: replace inner_unwrap_err -> Result<Option<Value>> with Ok(Some(Default::default()))
-clarity/src/vm/ast/parser/v2/mod.rs:1062: replace Parser<'a>::parse_node_or_eof -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::from(None)
-clarity/src/vm/representations.rs:95: replace <impl StacksMessageCodec for ClarityName>::consensus_deserialize -> Result<ClarityName, codec_error> with Ok(Default::default())
-clarity/src/vm/ast/parser/v2/mod.rs:1109: replace parse_collect_diagnostics -> (Vec<PreSymbolicExpression>, Vec<Diagnostic>, bool) with (vec![], vec![Default::default()], false)
-clarity/src/vm/analysis/read_only_checker/mod.rs:227: replace ReadOnlyChecker<'a, 'b>::check_read_only -> CheckResult<bool> with CheckResult::new()
-clarity/src/vm/ast/parser/v2/mod.rs:1083: replace Parser<'a>::parse -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::new(vec![])
-clarity/src/vm/database/key_value_wrapper.rs:495: replace RollbackWrapper<'a>::get_metadata_manual -> InterpreterResult<Option<String>> with InterpreterResult::from(Some(String::new()))
-clarity/src/vm/ast/errors.rs:300: replace <impl DiagnosableError for ParseErrors>::level -> crate::vm::diagnostic::Level with Default::default()
-clarity/src/vm/ast/definition_sorter/mod.rs:369: replace DefinitionSorter::probe_for_dependencies_in_key_value_pair -> ParseResult<()> with ParseResult::new()
-clarity/src/vm/contexts.rs:600: replace OwnedEnvironment<'a, 'hooks>::new_free -> OwnedEnvironment<'a, '_> with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs:401: replace check_special_index_of -> TypeResult with Default::default()
-clarity/src/vm/ast/expression_identifier/mod.rs:51: replace ExpressionIdentifier::run_pre_expression_pass -> ParseResult<()> with ParseResult::from(())
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1136: replace TypeChecker<'a, 'b>::type_check_define_map -> CheckResult<(ClarityName, (TypeSignature, TypeSignature))> with CheckResult::from((Default::default(), (Default::default(), Default::default())))
-clarity/src/vm/functions/options.rs:148: replace special_match_opt -> Result<Value> with Ok(Default::default())
-clarity/src/vm/ast/parser/v2/mod.rs:1062: replace Parser<'a>::parse_node_or_eof -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::new(Some(Default::default()))
-clarity/src/vm/ast/mod.rs:174: replace inner_build_ast -> ParseResult<(ContractAST, Vec<Diagnostic>, bool)> with ParseResult::new((Default::default(), vec![Default::default()], true))
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:485: replace check_function_arg_signature -> CheckResult<()> with CheckResult::new(())
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:646: replace TypeChecker<'a, 'b>::try_native_function_check -> Option<TypeResult> with Some(Default::default())
-clarity/src/vm/ast/parser/v1.rs:508: replace parse_lexed -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::from(vec![])
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:626: replace TypeChecker<'a, 'b>::type_check_define_map -> CheckResult<(ClarityName, (TypeSignature, TypeSignature))> with CheckResult::from((Default::default(), (Default::default(), Default::default())))
-clarity/src/vm/database/clarity_db.rs:516: replace ClarityDatabase<'a>::get_value -> Result<Option<ValueResult>> with Ok(Some(Default::default()))
-clarity/src/vm/representations.rs:271: replace PreSymbolicExpression::span -> &Span with &Default::default()
-clarity/src/vm/analysis/analysis_db.rs:153: replace AnalysisDatabase<'a>::get_public_function_type -> CheckResult<Option<FunctionType>> with CheckResult::new(Some(Default::default()))
-clarity/src/vm/types/mod.rs:824: replace Value::okay_true -> Value with Default::default()
-clarity/src/vm/functions/arithmetic.rs:639: replace native_to_int -> InterpreterResult<Value> with InterpreterResult::new()
-clarity/src/vm/types/mod.rs:684: replace <impl SequencedValue for UTF8Data>::type_signature -> TypeSignature with Default::default()
-clarity/src/vm/analysis/trait_checker/mod.rs:39: replace <impl AnalysisPass for TraitChecker>::run_pass -> CheckResult<()> with CheckResult::new(())
-clarity/src/vm/ast/parser/v2/mod.rs:807: replace Parser<'a>::parse_node -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::from(Some(Default::default()))
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:297: replace trait_type_size -> CheckResult<u64> with CheckResult::new(1)
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:296: replace ContractContext::add_implemented_trait -> CheckResult<()> with CheckResult::from_iter([()])
-clarity/src/vm/analysis/read_only_checker/mod.rs:268: replace ReadOnlyChecker<'a, 'b>::try_check_native_function_is_read_only -> Option<CheckResult<bool>> with Some(CheckResult::from(true))
-clarity/src/vm/types/mod.rs:838: replace Value::err_none -> Value with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs:39: replace get_simple_native_or_user_define -> CheckResult<FunctionType> with CheckResult::new(Default::default())
-clarity/src/vm/functions/define.rs:172: replace handle_define_persisted_variable -> Result<DefineResult> with Ok(Default::default())
-clarity/src/vm/functions/options.rs:87: replace native_try_ret -> Result<Value> with Ok(Default::default())
-clarity/src/vm/ast/mod.rs:288: replace build_ast_precheck_size -> ParseResult<ContractAST> with ParseResult::new()
-clarity/src/vm/types/signatures.rs:857: replace TupleTypeSignature::field_type -> Option<&TypeSignature> with Some(&Default::default())
-clarity/src/vm/ast/stack_depth_checker.rs:53: replace check_vary -> ParseResult<()> with ParseResult::from_iter([()])
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:358: replace TypeChecker<'a, 'b>::track_return_type -> CheckResult<()> with CheckResult::from_iter([()])
-clarity/src/vm/functions/database.rs:442: replace special_at_block -> Result<Value> with Ok(Default::default())
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:128: replace Lexer<'a>::skip_whitespace -> LexResult<()> with LexResult::new()
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1414: replace TypeChecker<'a, 'b>::try_type_check_define -> CheckResult<Option<()>> with CheckResult::from(Some(()))
-clarity/src/vm/functions/arithmetic.rs:560: replace native_mul -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
-clarity/src/vm/database/clarity_db.rs:1236: replace ClarityDatabase<'a>::lookup_variable_with_size -> Result<ValueResult> with Ok(Default::default())
-clarity/src/vm/docs/contracts.rs:178: replace produce_docs_refs -> BTreeMap<String, ContractRef> with BTreeMap::from_iter([(String::new(), Default::default())])
-clarity/src/vm/types/signatures.rs:1339: replace TypeSignature::literal_type_of -> TypeSignature with Default::default()
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:575: replace Lexer<'a>::read_utf8_string -> LexResult<Token> with LexResult::new()
-clarity/src/vm/analysis/analysis_db.rs:208: replace AnalysisDatabase<'a>::get_implemented_traits -> CheckResult<BTreeSet<TraitIdentifier>> with CheckResult::from(BTreeSet::from_iter([Default::default()]))
-clarity/src/vm/types/signatures.rs:825: replace <impl TryFrom for TupleTypeSignature>::try_from -> Result<TupleTypeSignature> with Ok(Default::default())
-clarity/src/vm/database/key_value_wrapper.rs:354: replace RollbackWrapper<'a>::get_with_proof -> Option<(T, Vec<u8>)> with Some((Default::default(), vec![1]))
-clarity/src/vm/analysis/type_checker/v2_1/natives/maps.rs:160: replace check_special_insert_entry -> TypeResult with Default::default()
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:136: replace ContractContext::add_variable_type -> CheckResult<()> with CheckResult::new(())
-clarity/src/vm/database/key_value_wrapper.rs:363: replace RollbackWrapper<'a>::get -> Option<T> with Some(Default::default())
-clarity/src/vm/analysis/contract_interface_builder/mod.rs:181: replace ContractInterfaceAtomType::from_type_signature -> ContractInterfaceAtomType with Default::default()
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:96: replace ContractContext::add_public_function_type -> CheckResult<()> with CheckResult::new(())
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:66: replace Lexer<'a>::add_diagnostic -> LexResult<()> with LexResult::from(())
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:185: replace Lexer<'a>::proceed_through_error_string -> LexResult<String> with LexResult::new("xyzzy".into())
-clarity/src/vm/ast/sugar_expander/mod.rs:66: replace SugarExpander::transform -> ParseResult<Vec<SymbolicExpression>> with ParseResult::from_iter([vec![]])
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:312: replace ContractContext::get_variable_type -> Option<&TypeSignature> with Some(&Default::default())
-clarity/src/vm/analysis/read_only_checker/mod.rs:88: replace ReadOnlyChecker<'a, 'b>::run -> CheckResult<()> with CheckResult::from_iter([()])
-clarity/src/vm/analysis/analysis_db.rs:153: replace AnalysisDatabase<'a>::get_public_function_type -> CheckResult<Option<FunctionType>> with CheckResult::from(Some(Default::default()))
-clarity/src/vm/database/clarity_db.rs:707: replace ClarityDatabase<'a>::get_contract -> Result<Contract> with Ok(Default::default())
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:111: replace Lexer<'a>::report_line_ending -> LexResult<()> with LexResult::from(())
-clarity/src/vm/analysis/mod.rs:50: replace mem_type_check -> CheckResult<(Option<TypeSignature>, ContractAnalysis)> with CheckResult::from_iter([(None, Default::default())])
-clarity/src/vm/types/mod.rs:1394: replace <impl From for StandardPrincipalData>::from -> StandardPrincipalData with Default::default()
-clarity/src/vm/functions/options.rs:28: replace inner_unwrap -> Result<Option<Value>> with Ok(Some(Default::default()))
-clarity/src/vm/types/signatures.rs:992: replace TypeSignature::max_buffer -> TypeSignature with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:485: replace check_function_arg_signature -> CheckResult<()> with CheckResult::from(())
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:86: replace TraitContext::add_used_trait -> CheckResult<()> with CheckResult::new(())
-clarity/src/vm/ast/parser/v2/mod.rs:463: replace Parser<'a>::open_tuple -> ParseResult<SetupTupleResult> with ParseResult::new()
-clarity/src/vm/types/signatures.rs:733: replace TypeSignature::canonicalize_v2_1 -> TypeSignature with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:485: replace check_function_arg_signature -> CheckResult<()> with CheckResult::from_iter([()])
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:792: replace TypeChecker<'a, 'b>::type_check_define_trait -> CheckResult<(ClarityName, BTreeMap<ClarityName, FunctionSignature>)> with CheckResult::new()
-clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs:339: replace check_special_if -> TypeResult with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/natives/options.rs:168: replace inner_unwrap_err -> TypeResult with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:213: replace ContractContext::add_read_only_function_type -> CheckResult<()> with CheckResult::from(())
-clarity/src/vm/database/clarity_db.rs:1202: replace ClarityDatabase<'a>::lookup_variable_unknown_descriptor -> Result<Value> with Ok(Default::default())
-clarity/src/vm/ast/parser/v2/mod.rs:158: replace Parser<'a>::peek_last_token -> ParseResult<&PlacedToken> with ParseResult::new()
-clarity/src/vm/contexts.rs:1841: replace ContractContext::get_clarity_version -> &ClarityVersion with &Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs:91: replace check_special_as_contract -> TypeResult with Default::default()
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:146: replace ContractContext::add_persisted_variable_type -> CheckResult<()> with CheckResult::new(())
-clarity/src/vm/ast/mod.rs:130: replace build_ast_typical -> ParseResult<ContractAST> with ParseResult::from_iter([Default::default()])
-clarity/src/vm/functions/assets.rs:912: replace special_burn_token -> Result<Value> with Ok(Default::default())
-clarity/src/vm/database/clarity_db.rs:1427: replace ClarityDatabase<'a>::set_entry_unknown_descriptor -> Result<Value> with Ok(Default::default())
-clarity/src/vm/types/mod.rs:278: replace SequenceData::element_at -> Option<Value> with Some(Default::default())
-clarity/src/vm/functions/mod.rs:212: replace lookup_reserved_functions -> Option<CallableType> with Some(Default::default())
-clarity/src/vm/analysis/errors.rs:274: replace <impl From for CheckError>::from -> Self with Default::default()
-clarity/src/vm/functions/arithmetic.rs:476: replace special_greater_v1 -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:106: replace ContractContext::add_read_only_function_type -> CheckResult<()> with CheckResult::new()
-clarity/src/vm/ast/parser/v1.rs:720: replace parse -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::new(vec![])
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:296: replace ContractContext::add_implemented_trait -> CheckResult<()> with CheckResult::from(())
-clarity/src/vm/functions/arithmetic.rs:434: replace special_leq_v1 -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
-clarity/src/vm/ast/definition_sorter/mod.rs:115: replace DefinitionSorter::probe_for_dependencies -> ParseResult<()> with ParseResult::from_iter([()])
-clarity/src/vm/functions/sequences.rs:319: replace native_index_of -> Result<Value> with Ok(Default::default())
-clarity/src/vm/functions/arithmetic.rs:572: replace native_log2 -> InterpreterResult<Value> with InterpreterResult::new()
-clarity/src/vm/ast/definition_sorter/mod.rs:324: replace DefinitionSorter::probe_for_dependencies_in_define_args -> ParseResult<()> with ParseResult::new()
-clarity/src/vm/representations.rs:197: replace <impl SymbolicExpressionCommon for PreSymbolicExpression>::match_list_mut -> Option<&mut[PreSymbolicExpression]> with Some(Vec::leak(vec![Default::default()]))
-clarity/src/vm/types/signatures.rs:480: replace ListTypeData::get_list_item_type -> &TypeSignature with &Default::default()
-clarity/src/vm/ast/definition_sorter/mod.rs:357: replace DefinitionSorter::probe_for_dependencies_in_wrapped_key_value_pairs -> ParseResult<()> with ParseResult::from_iter([()])
-clarity/src/vm/types/mod.rs:754: replace BlockInfoProperty::lookup_by_name_at_version -> Option<BlockInfoProperty> with Some(Default::default())
-clarity/src/vm/representations.rs:313: replace PreSymbolicExpression::field_identifier -> PreSymbolicExpression with Default::default()
-clarity/src/vm/functions/principals.rs:118: replace create_principal_true_error_response -> Value with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:839: replace contract_analysis_size -> CheckResult<u64> with CheckResult::from_iter([0])
-clarity/src/vm/ast/mod.rs:174: replace inner_build_ast -> ParseResult<(ContractAST, Vec<Diagnostic>, bool)> with ParseResult::new((Default::default(), vec![], false))
-clarity/src/vm/types/mod.rs:1308: replace PrincipalData::parse -> Result<PrincipalData> with Ok(Default::default())
-clarity/src/vm/types/serialization.rs:209: replace <impl ClarityValueSerializable for StandardPrincipalData>::deserialize_read -> Result<Self, SerializationError> with Ok(Default::default())
-clarity/src/vm/analysis/read_only_checker/mod.rs:281: replace ReadOnlyChecker<'a, 'b>::check_native_function_is_read_only -> CheckResult<bool> with CheckResult::from(true)
-clarity/src/vm/test_util/mod.rs:39: replace generate_test_burn_state_db -> UnitTestBurnStateDB with Default::default()
-clarity/src/vm/ast/parser/v1.rs:455: replace lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::new()
-clarity/src/vm/costs/mod.rs:1176: replace ExecutionCost::max_value -> ExecutionCost with Default::default()
-clarity/src/vm/contexts.rs:752: replace OwnedEnvironment<'a, 'hooks>::execute_transaction -> Result<(Value, AssetMap, Vec<StacksTransactionEvent>)> with Ok((Default::default(), Default::default(), vec![]))
-clarity/src/vm/database/clarity_db.rs:395: replace <impl BurnStateDB for NullBurnStateDB>::get_pox_payout_addrs -> Option<(Vec<TupleData>, u128)> with Some((vec![Default::default()], 0))
-clarity/src/vm/ast/parser/v1.rs:455: replace lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::from(vec![(Default::default(), 0, 0)])
-clarity/src/vm/contexts.rs:1078: replace Environment<'a, 'b, 'hooks>::run_free -> A with Default::default()
-clarity/src/vm/costs/mod.rs:699: replace LimitedCostTracker::new_max_limit -> Result<LimitedCostTracker> with Ok(Default::default())
-clarity/src/vm/ast/parser/v1.rs:455: replace lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::from_iter([vec![(Default::default(), 0, 1)]])
-clarity/src/vm/ast/errors.rs:153: replace <impl From for ParseError>::from -> Self with Default::default()
-clarity/src/vm/database/structures.rs:328: replace STXBalanceSnapshot<'db, 'conn>::balance -> &STXBalance with &Default::default()
-clarity/src/vm/ast/parser/v2/mod.rs:158: replace Parser<'a>::peek_last_token -> ParseResult<&PlacedToken> with ParseResult::from_iter([&Default::default()])
-clarity/src/vm/ast/parser/v1.rs:455: replace lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::new(vec![(Default::default(), 0, 0)])
-clarity/src/vm/database/clarity_db.rs:271: replace <impl HeadersDB for NullHeadersDB>::get_burn_header_hash_for_block -> Option<BurnchainHeaderHash> with Some(Default::default())
-clarity/src/vm/database/clarity_db.rs:252: replace <impl BurnStateDB for &dyn BurnStateDB>::get_pox_payout_addrs -> Option<(Vec<TupleData>, u128)> with Some((vec![Default::default()], 0))
-clarity/src/vm/functions/arithmetic.rs:629: replace native_to_uint -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
-clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs:84: replace check_special_as_contract -> TypeResult with Default::default()
-clarity/src/vm/functions/assets.rs:128: replace stx_transfer_consolidated -> Result<Value> with Ok(Default::default())
-clarity/src/vm/analysis/contract_interface_builder/mod.rs:307: replace ContractInterfaceFungibleTokens::from_set -> Vec<Self> with vec![Default::default()]
-clarity/src/vm/database/clarity_db.rs:1468: replace ClarityDatabase<'a>::insert_entry -> Result<ValueResult> with Ok(Default::default())
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:185: replace Lexer<'a>::proceed_through_error_string -> LexResult<String> with LexResult::from_iter([String::new()])
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1136: replace TypeChecker<'a, 'b>::type_check_define_map -> CheckResult<(ClarityName, (TypeSignature, TypeSignature))> with CheckResult::from_iter([(Default::default(), (Default::default(), Default::default()))])
-clarity/src/vm/ast/parser/v2/mod.rs:131: replace Parser<'a>::next_token -> Option<PlacedToken> with Some(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:279: replace ContractContext::add_defined_trait -> CheckResult<()> with CheckResult::from_iter([()])
-clarity/src/vm/functions/arithmetic.rs:364: replace native_xor -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
-clarity/src/vm/contexts.rs:960: replace Environment<'a, 'b, 'hooks>::nest_as_principal -> Environment<'c, 'b, 'hooks> with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/natives/options.rs:145: replace inner_unwrap -> TypeResult with Default::default()
-clarity/src/vm/database/clarity_db.rs:314: replace <impl HeadersDB for NullHeadersDB>::get_miner_address -> Option<StacksAddress> with Some(Default::default())
-clarity/src/vm/types/serialization.rs:1114: replace Value::try_deserialize_bytes_exact -> Result<Value, SerializationError> with Ok(Default::default())
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:96: replace ContractContext::add_public_function_type -> CheckResult<()> with CheckResult::new()
-clarity/src/vm/ast/traits_resolver/mod.rs:201: replace TraitsResolver::probe_for_generics -> ParseResult<()> with ParseResult::from_iter([()])
-clarity/src/vm/functions/define.rs:270: replace handle_impl_trait -> Result<DefineResult> with Ok(Default::default())
-clarity/src/vm/functions/arithmetic.rs:566: replace native_pow -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
-clarity/src/vm/mod.rs:205: replace lookup_function -> Result<CallableType> with Ok(Default::default())
-clarity/src/vm/functions/arithmetic.rs:364: replace native_xor -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
-clarity/src/vm/types/serialization.rs:574: replace Value::inner_deserialize_read -> Result<Value, SerializationError> with Ok(Default::default())
-clarity/src/vm/analysis/read_only_checker/mod.rs:244: replace ReadOnlyChecker<'a, 'b>::check_each_expression_is_read_only -> CheckResult<bool> with CheckResult::from(true)
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:292: replace ContractContext::add_used_trait -> CheckResult<()> with CheckResult::from(())
-clarity/src/vm/functions/options.rs:80: replace native_unwrap_err_or_ret -> Result<Value> with Ok(Default::default())
-clarity/src/vm/types/signatures.rs:1551: replace TypeSignature::parse_trait_type_repr -> Result<BTreeMap<ClarityName, FunctionSignature>> with Ok(BTreeMap::from_iter([(Default::default(), Default::default())]))
-clarity/src/vm/functions/arithmetic.rs:434: replace special_leq_v1 -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:740: replace TypeChecker<'a, 'b>::type_check_define_variable -> CheckResult<(ClarityName, TypeSignature)> with CheckResult::from((Default::default(), Default::default()))
-clarity/src/vm/representations.rs:527: replace SymbolicExpression::atom -> SymbolicExpression with Default::default()
-clarity/src/vm/analysis/contract_interface_builder/mod.rs:164: replace ContractInterfaceAtomType::from_tuple_type -> ContractInterfaceAtomType with Default::default()
-clarity/src/vm/functions/database.rs:723: replace special_get_block_info -> Result<Value> with Ok(Default::default())
-clarity/src/vm/analysis/read_only_checker/mod.rs:227: replace ReadOnlyChecker<'a, 'b>::check_read_only -> CheckResult<bool> with CheckResult::from_iter([true])
-clarity/src/vm/ast/definition_sorter/mod.rs:369: replace DefinitionSorter::probe_for_dependencies_in_key_value_pair -> ParseResult<()> with ParseResult::from(())
-clarity/src/vm/types/serialization.rs:1085: replace Value::try_deserialize_bytes -> Result<Value, SerializationError> with Ok(Default::default())
-clarity/src/vm/database/clarity_db.rs:175: replace <impl HeadersDB for &dyn HeadersDB>::get_miner_address -> Option<StacksAddress> with Some(Default::default())
-clarity/src/vm/ast/parser/v1.rs:462: replace unescape_ascii_chars -> ParseResult<String> with ParseResult::from_iter([String::new()])
-clarity/src/vm/functions/assets.rs:219: replace special_stx_account -> Result<Value> with Ok(Default::default())
-clarity/src/vm/analysis/read_only_checker/mod.rs:430: replace ReadOnlyChecker<'a, 'b>::check_expression_application_is_read_only -> CheckResult<bool> with CheckResult::from_iter([true])
-clarity/src/vm/types/mod.rs:623: replace <impl SequencedValue for ListData>::type_signature -> TypeSignature with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:831: replace trait_type_size -> CheckResult<u64> with CheckResult::from(1)
-clarity/src/vm/analysis/type_checker/contexts.rs:82: replace TypingContext<'a>::extend -> CheckResult<TypingContext> with CheckResult::new(Default::default())
-clarity/src/vm/database/clarity_db.rs:1555: replace ClarityDatabase<'a>::delete_entry -> Result<ValueResult> with Ok(Default::default())
-clarity/src/vm/ast/sugar_expander/mod.rs:56: replace SugarExpander::run -> ParseResult<()> with ParseResult::new(())
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:388: replace TypeChecker<'a, 'b>::run -> CheckResult<()> with CheckResult::from(())
-clarity/src/vm/ast/expression_identifier/mod.rs:58: replace ExpressionIdentifier::run_expression_pass -> ParseResult<()> with ParseResult::new(())
-clarity/src/vm/analysis/type_checker/v2_05/natives/options.rs:184: replace check_special_unwrap_or_ret -> TypeResult with Default::default()
-clarity/src/vm/ast/parser/v2/mod.rs:687: replace Parser<'a>::read_sugared_principal -> ParseResult<PreSymbolicExpression> with ParseResult::new(Default::default())
-clarity/src/vm/functions/arithmetic.rs:419: replace special_geq -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:792: replace TypeChecker<'a, 'b>::type_check_define_trait -> CheckResult<(ClarityName, BTreeMap<ClarityName, FunctionSignature>)> with CheckResult::from((Default::default(), BTreeMap::from_iter([(Default::default(), Default::default())])))
-clarity/src/vm/analysis/type_checker/v2_05/natives/sequences.rs:39: replace get_simple_native_or_user_define -> CheckResult<FunctionType> with CheckResult::new()
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:253: replace ContractContext::add_persisted_variable_type -> CheckResult<()> with CheckResult::from_iter([()])
-clarity/src/vm/database/clarity_db.rs:421: replace ClarityDatabase<'a>::new_with_rollback_wrapper -> ClarityDatabase<'a> with Default::default()
-clarity/src/vm/functions/arithmetic.rs:575: replace native_mod -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
-clarity/src/vm/analysis/type_checker/v2_05/natives/maps.rs:161: replace check_special_insert_entry -> TypeResult with Default::default()
-clarity/src/vm/types/mod.rs:1117: replace Value::expect_principal -> PrincipalData with Default::default()
-clarity/src/vm/ast/parser/v2/mod.rs:1083: replace Parser<'a>::parse -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::from(vec![Default::default()])
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:203: replace ContractContext::add_public_function_type -> CheckResult<()> with CheckResult::from(())
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1004: replace TypeChecker<'a, 'b>::type_check_consecutive_statements -> TypeResult with Default::default()
-clarity/src/vm/functions/arithmetic.rs:59: replace UTF8Ops::make_value -> InterpreterResult<Value> with InterpreterResult::new()
-clarity/src/vm/analysis/read_only_checker/mod.rs:244: replace ReadOnlyChecker<'a, 'b>::check_each_expression_is_read_only -> CheckResult<bool> with CheckResult::new(true)
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:96: replace ContractContext::add_public_function_type -> CheckResult<()> with CheckResult::from_iter([()])
-clarity/src/vm/functions/arithmetic.rs:462: replace special_leq -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:140: replace Lexer<'a>::read_line -> LexResult<String> with LexResult::new(String::new())
-clarity/src/vm/functions/arithmetic.rs:476: replace special_greater_v1 -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
-clarity/src/vm/callables.rs:359: replace DefinedFunction::get_arg_types -> &Vec<TypeSignature> with &vec![]
-clarity/src/vm/database/key_value_wrapper.rs:495: replace RollbackWrapper<'a>::get_metadata_manual -> InterpreterResult<Option<String>> with InterpreterResult::from_iter([Some(String::new())])
-clarity/src/vm/ast/parser/v2/mod.rs:219: replace Parser<'a>::handle_open_node -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::from(None)
-clarity/src/vm/database/clarity_db.rs:221: replace <impl BurnStateDB for &dyn BurnStateDB>::get_burn_header_hash -> Option<BurnchainHeaderHash> with Some(Default::default())
-clarity/src/vm/ast/parser/v1.rs:101: replace get_value_or_err -> ParseResult<String> with ParseResult::new(String::new())
-clarity/src/vm/ast/parser/v2/mod.rs:140: replace Parser<'a>::peek_next_token -> PlacedToken with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/natives/assets.rs:223: replace check_special_stx_transfer_memo -> TypeResult with Default::default()
-clarity/src/vm/functions/define.rs:277: replace DefineFunctions::try_parse -> Option<(DefineFunctions, &[SymbolicExpression])> with Some((Default::default(), Vec::leak(Vec::new())))
-clarity/src/vm/analysis/read_only_checker/mod.rs:182: replace ReadOnlyChecker<'a, 'b>::check_reads_only_valid -> CheckResult<()> with CheckResult::new(())
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:146: replace ContractContext::add_persisted_variable_type -> CheckResult<()> with CheckResult::from(())
-clarity/src/vm/functions/boolean.rs:38: replace special_or -> Result<Value> with Ok(Default::default())
-clarity/src/vm/functions/define.rs:247: replace handle_define_trait -> Result<DefineResult> with Ok(Default::default())
-clarity/src/vm/ast/parser/v1.rs:192: replace inner_lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::from_iter([vec![(Default::default(), 1, 0)]])
-clarity/src/vm/database/clarity_db.rs:399: replace <impl BurnStateDB for NullBurnStateDB>::get_ast_rules -> ASTRules with Default::default()
-clarity/src/vm/analysis/read_only_checker/mod.rs:59: replace <impl AnalysisPass for ReadOnlyChecker<'a, 'b>>::run_pass -> CheckResult<()> with CheckResult::new()
-clarity/src/vm/costs/mod.rs:971: replace <impl CostTracker for LimitedCostTracker>::compute_cost -> std::result::Result<ExecutionCost, CostErrors> with Ok(Default::default())
-clarity/src/vm/ast/parser/v2/mod.rs:283: replace Parser<'a>::handle_open_tuple -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::new(None)
-clarity/src/vm/contexts.rs:1396: replace Environment<'a, 'b, 'hooks>::run_as_transaction -> std::result::Result<O, E> with Ok(Default::default())
-clarity/src/vm/ast/parser/v1.rs:462: replace unescape_ascii_chars -> ParseResult<String> with ParseResult::from("xyzzy".into())
-clarity/src/vm/analysis/read_only_checker/mod.rs:244: replace ReadOnlyChecker<'a, 'b>::check_each_expression_is_read_only -> CheckResult<bool> with CheckResult::from_iter([true])
-clarity/src/vm/types/mod.rs:490: replace SequenceData::slice -> Result<Value> with Ok(Default::default())
-clarity/src/vm/representations.rs:306: replace PreSymbolicExpression::trait_reference -> PreSymbolicExpression with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/natives/options.rs:63: replace check_special_error -> TypeResult with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1055: replace TypeChecker<'a, 'b>::type_check_define_function -> CheckResult<(ClarityName, FixedFunction)> with CheckResult::from_iter([(Default::default(), Default::default())])
-clarity/src/vm/types/signatures.rs:273: replace FunctionType::canonicalize -> FunctionType with Default::default()
-clarity/src/vm/ast/stack_depth_checker.rs:74: replace <impl BuildASTPass for VaryStackDepthChecker>::run_pass -> ParseResult<()> with ParseResult::from_iter([()])
-clarity/src/vm/ast/stack_depth_checker.rs:28: replace check -> ParseResult<()> with ParseResult::new()
-clarity/src/vm/functions/arithmetic.rs:67: replace BuffOps::make_value -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
-clarity/src/vm/database/clarity_db.rs:954: replace ClarityDatabase<'a>::get_miner_address -> StandardPrincipalData with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:279: replace ContractContext::add_defined_trait -> CheckResult<()> with CheckResult::from(())
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:358: replace TypeChecker<'a, 'b>::track_return_type -> CheckResult<()> with CheckResult::from(())
-clarity/src/vm/functions/options.rs:59: replace native_unwrap -> Result<Value> with Ok(Default::default())
-clarity/src/vm/tests/principals.rs:846: replace create_principal_from_strings -> Value with Default::default()
-clarity/src/vm/analysis/read_only_checker/mod.rs:244: replace ReadOnlyChecker<'a, 'b>::check_each_expression_is_read_only -> CheckResult<bool> with CheckResult::new(false)
-clarity/src/vm/functions/arithmetic.rs:462: replace special_leq -> InterpreterResult<Value> with InterpreterResult::new()
-clarity/src/vm/database/clarity_store.rs:281: replace MemoryBackingStore::as_clarity_db -> ClarityDatabase with Default::default()
-clarity/src/vm/ast/parser/v1.rs:728: replace parse_no_stack_limit -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::from(vec![])
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:297: replace trait_type_size -> CheckResult<u64> with CheckResult::new(0)
-clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs:320: replace check_special_equals -> TypeResult with Default::default()
-clarity/src/vm/tests/contracts.rs:87: replace get_principal -> Value with Default::default()
-clarity/src/vm/functions/arithmetic.rs:566: replace native_pow -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:279: replace ContractContext::add_defined_trait -> CheckResult<()> with CheckResult::new(())
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1023: replace TypeChecker<'a, 'b>::type_check_all -> CheckResult<Vec<TypeSignature>> with CheckResult::from(vec![Default::default()])
-clarity/src/vm/analysis/type_checker/v2_1/natives/conversions.rs:18: replace check_special_to_consensus_buff -> TypeResult with Default::default()
-clarity/src/vm/types/mod.rs:676: replace <impl SequencedValue for UTF8Data>::items -> &Vec<Vec<u8>> with &vec![vec![]]
-clarity/src/vm/database/clarity_db.rs:1085: replace ClarityDatabase<'a>::get_microblock_poison_report -> Option<(StandardPrincipalData, u16)> with Some((Default::default(), 0))
-clarity/src/vm/functions/conversions.rs:105: replace native_buff_to_int_be -> Result<Value> with Ok(Default::default())
-clarity/src/vm/ast/definition_sorter/mod.rs:456: replace GraphWalker::get_sorted_dependencies -> ParseResult<Vec<usize>> with ParseResult::from(vec![0])
-clarity/src/vm/costs/mod.rs:1126: replace ExecutionCost::zero -> ExecutionCost with Default::default()
-clarity/src/vm/types/signatures.rs:365: replace <impl TryFrom for BufferLength>::try_from -> Result<BufferLength> with Ok(Default::default())
-clarity/src/vm/database/structures.rs:870: replace STXBalance::canonical_repr_at_block -> (STXBalance, u128) with (Default::default(), 1)
-clarity/src/vm/ast/parser/v2/mod.rs:283: replace Parser<'a>::handle_open_tuple -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::from_iter([None])
-clarity/src/vm/types/mod.rs:647: replace <impl SequencedValue for BuffData>::to_value -> Value with Default::default()
-clarity/src/vm/functions/options.rs:254: replace native_error -> Result<Value> with Ok(Default::default())
-clarity/src/vm/ast/parser/v1.rs:101: replace get_value_or_err -> ParseResult<String> with ParseResult::from(String::new())
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:839: replace contract_analysis_size -> CheckResult<u64> with CheckResult::new(1)
-clarity/src/vm/types/serialization.rs:1198: replace Value::sanitize_value -> Option<(Value, bool)> with Some((Default::default(), false))
-clarity/src/vm/types/signatures.rs:1019: replace TypeSignature::factor_out_no_type -> Result<TypeSignature> with Ok(Default::default())
-clarity/src/vm/costs/mod.rs:1238: replace ExecutionCost::max_cost -> ExecutionCost with Default::default()
-clarity/src/vm/functions/arithmetic.rs:373: replace native_bitwise_and -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
-clarity/src/vm/types/mod.rs:669: replace <impl SequencedValue for ASCIIData>::to_value -> Value with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs:62: replace check_special_map -> TypeResult with Default::default()
-clarity/src/vm/callables.rs:389: replace FunctionIdentifier::new_native_function -> FunctionIdentifier with Default::default()
-clarity/src/vm/tests/assets.rs:133: replace execute_transaction -> Result<(Value, AssetMap, Vec<StacksTransactionEvent>), Error> with Ok((Default::default(), Default::default(), vec![]))
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:96: replace ContractContext::add_public_function_type -> CheckResult<()> with CheckResult::from(())
-clarity/src/vm/ast/types.rs:102: replace <impl Iterator for PreExpressionsDrain>::next -> Option<PreSymbolicExpression> with Some(Default::default())
-clarity/src/vm/mod.rs:569: replace execute_v2 -> Result<Option<Value>> with Ok(Some(Default::default()))
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:688: replace TypeChecker<'a, 'b>::lookup_variable -> TypeResult with Default::default()
-clarity/src/vm/ast/parser/v1.rs:192: replace inner_lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::from_iter([vec![(Default::default(), 1, 1)]])
-clarity/src/vm/analysis/analysis_db.rs:208: replace AnalysisDatabase<'a>::get_implemented_traits -> CheckResult<BTreeSet<TraitIdentifier>> with CheckResult::from_iter([BTreeSet::new()])
-clarity/src/vm/types/mod.rs:633: replace <impl SequencedValue for BuffData>::items -> &Vec<u8> with &vec![]
-clarity/src/vm/analysis/analysis_db.rs:123: replace AnalysisDatabase<'a>::insert_contract -> CheckResult<()> with CheckResult::from(())
-clarity/src/vm/contexts.rs:1105: replace Environment<'a, 'b, 'hooks>::execute_contract -> Result<Value> with Ok(Default::default())
-clarity/src/vm/functions/sequences.rs:312: replace native_len -> Result<Value> with Ok(Default::default())
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:61: replace ContractContext::check_name_used -> CheckResult<()> with CheckResult::new()
-clarity/src/vm/ast/parser/v2/mod.rs:463: replace Parser<'a>::open_tuple -> ParseResult<SetupTupleResult> with ParseResult::from_iter([Default::default()])
-clarity/src/vm/functions/database.rs:407: replace special_fetch_entry_v205 -> Result<Value> with Ok(Default::default())
-clarity/src/vm/functions/arithmetic.rs:566: replace native_pow -> InterpreterResult<Value> with InterpreterResult::new()
-clarity/src/vm/functions/assets.rs:854: replace special_get_owner_v205 -> Result<Value> with Ok(Default::default())
-clarity/src/vm/ast/mod.rs:174: replace inner_build_ast -> ParseResult<(ContractAST, Vec<Diagnostic>, bool)> with ParseResult::from((Default::default(), vec![Default::default()], false))
-clarity/src/vm/database/clarity_db.rs:1173: replace ClarityDatabase<'a>::set_variable -> Result<ValueResult> with Ok(Default::default())
-clarity/src/vm/ast/mod.rs:174: replace inner_build_ast -> ParseResult<(ContractAST, Vec<Diagnostic>, bool)> with ParseResult::new((Default::default(), vec![Default::default()], false))
-clarity/src/vm/ast/traits_resolver/mod.rs:48: replace TraitsResolver::run -> ParseResult<()> with ParseResult::from(())
-clarity/src/vm/functions/mod.rs:758: replace special_as_contract -> Result<Value> with Ok(Default::default())
-clarity/src/vm/types/mod.rs:1439: replace <impl From for PrincipalData>::from -> Self with Default::default()
-clarity/src/vm/functions/mod.rs:692: replace parse_eval_bindings -> Result<Vec<(ClarityName, Value)>> with Ok(vec![(Default::default(), Default::default())])
-clarity/src/vm/types/signatures.rs:415: replace <impl TryFrom for StringUTF8Length>::try_from -> Result<StringUTF8Length> with Ok(Default::default())
-clarity/src/vm/types/signatures.rs:429: replace <impl TryFrom for StringUTF8Length>::try_from -> Result<StringUTF8Length> with Ok(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs:39: replace get_simple_native_or_user_define -> CheckResult<FunctionType> with CheckResult::from(Default::default())
-clarity/src/vm/test_util/mod.rs:206: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_burn_header_hash -> Option<BurnchainHeaderHash> with Some(Default::default())
-clarity/src/vm/mod.rs:481: replace execute_on_network -> Result<Option<Value>> with Ok(Some(Default::default()))
-clarity/src/vm/functions/arithmetic.rs:369: replace native_bitwise_xor -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
-clarity/src/vm/ast/definition_sorter/mod.rs:433: replace Graph::edges_count -> ParseResult<u64> with ParseResult::from(0)
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1346: replace TypeChecker<'a, 'b>::type_check_define_variable -> CheckResult<(ClarityName, TypeSignature)> with CheckResult::new()
-clarity/src/vm/functions/mod.rs:705: replace special_let -> Result<Value> with Ok(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1023: replace TypeChecker<'a, 'b>::type_check_all -> CheckResult<Vec<TypeSignature>> with CheckResult::from(vec![])
-clarity/src/vm/database/clarity_db.rs:1912: replace ClarityDatabase<'a>::get_stx_balance_snapshot_genesis -> STXBalanceSnapshot<'a, 'conn> with Default::default()
-clarity/src/vm/ast/mod.rs:288: replace build_ast_precheck_size -> ParseResult<ContractAST> with ParseResult::from(Default::default())
-clarity/src/vm/analysis/type_checker/mod.rs:64: replace FunctionType::check_args_by_allowing_trait_cast -> CheckResult<TypeSignature> with CheckResult::new(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:969: replace TypeChecker<'a, 'b>::type_check_expects -> TypeResult with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1055: replace TypeChecker<'a, 'b>::type_check_define_function -> CheckResult<(ClarityName, FixedFunction)> with CheckResult::new((Default::default(), Default::default()))
-clarity/src/vm/ast/stack_depth_checker.rs:48: replace <impl BuildASTPass for StackDepthChecker>::run_pass -> ParseResult<()> with ParseResult::new(())
-clarity/src/vm/analysis/read_only_checker/mod.rs:170: replace ReadOnlyChecker<'a, 'b>::check_define_function -> CheckResult<(ClarityName, bool)> with CheckResult::from((Default::default(), false))
-clarity/src/vm/ast/definition_sorter/mod.rs:307: replace DefinitionSorter::probe_for_dependencies_in_tuple -> ParseResult<()> with ParseResult::new(())
-clarity/src/vm/types/mod.rs:726: replace ResponseData::type_signature -> TypeSignature with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/natives/maps.rs:152: replace check_special_set_entry -> TypeResult with Default::default()
-clarity/src/vm/functions/arithmetic.rs:52: replace ASCIIOps::make_value -> InterpreterResult<Value> with InterpreterResult::new()
-clarity/src/vm/analysis/type_checker/v2_05/natives/options.rs:340: replace check_special_match_resp -> TypeResult with Default::default()
-clarity/src/vm/database/clarity_db.rs:1893: replace ClarityDatabase<'a>::get_stx_balance_snapshot -> STXBalanceSnapshot<'a, 'conn> with Default::default()
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:751: replace TypeChecker<'a, 'b>::type_check_define_persisted_variable -> CheckResult<(ClarityName, TypeSignature)> with CheckResult::new()
-clarity/src/vm/contexts.rs:764: replace OwnedEnvironment<'a, 'hooks>::stx_transfer -> Result<(Value, AssetMap, Vec<StacksTransactionEvent>)> with Ok((Default::default(), Default::default(), vec![Default::default()]))
-clarity/src/vm/representations.rs:364: replace PreSymbolicExpression::match_atom -> Option<&ClarityName> with Some(&Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs:344: replace check_special_if -> TypeResult with Default::default()
-clarity/src/vm/functions/arithmetic.rs:560: replace native_mul -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
-clarity/src/vm/functions/arithmetic.rs:490: replace special_greater_v2 -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
-clarity/src/vm/ast/sugar_expander/mod.rs:66: replace SugarExpander::transform -> ParseResult<Vec<SymbolicExpression>> with ParseResult::from(vec![Default::default()])
-clarity/src/vm/analysis/type_checker/v2_1/natives/assets.rs:268: replace check_special_burn_asset -> TypeResult with Default::default()
-clarity/src/vm/database/clarity_store.rs:291: replace <impl ClarityBackingStore for MemoryBackingStore>::set_block_hash -> InterpreterResult<StacksBlockId> with InterpreterResult::from(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/natives/options.rs:187: replace check_special_unwrap_or_ret -> TypeResult with Default::default()
-clarity/src/vm/ast/mod.rs:174: replace inner_build_ast -> ParseResult<(ContractAST, Vec<Diagnostic>, bool)> with ParseResult::from((Default::default(), vec![], false))
-clarity/src/vm/functions/arithmetic.rs:629: replace native_to_uint -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
-clarity/src/vm/functions/principals.rs:137: replace create_principal_value_error_response -> Value with Default::default()
-clarity/src/vm/database/clarity_db.rs:252: replace <impl BurnStateDB for &dyn BurnStateDB>::get_pox_payout_addrs -> Option<(Vec<TupleData>, u128)> with Some((vec![Default::default()], 1))
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:296: replace ContractContext::add_implemented_trait -> CheckResult<()> with CheckResult::new(())
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:160: replace Lexer<'a>::proceed_through_error -> LexResult<String> with LexResult::from_iter([String::new()])
-clarity/src/vm/functions/conversions.rs:154: replace safe_convert_string_to_int -> Result<Value> with Ok(Default::default())
-clarity/src/vm/functions/conversions.rs:210: replace native_int_to_utf8 -> Result<Value> with Ok(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:243: replace ContractContext::add_variable_type -> CheckResult<()> with CheckResult::from(())
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:78: replace Lexer<'a>::read_char -> LexResult<()> with LexResult::new()
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:899: replace TypeChecker<'a, 'b>::track_return_type -> CheckResult<()> with CheckResult::from_iter([()])
-clarity/src/vm/functions/arithmetic.rs:604: replace native_bitwise_right_shift -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
-clarity/src/vm/representations.rs:610: replace SymbolicExpression::match_field -> Option<&TraitIdentifier> with Some(&Default::default())
-clarity/src/mod.rs:81: replace boot_util::boot_code_addr -> StacksAddress with Default::default()
-clarity/src/vm/ast/stack_depth_checker.rs:74: replace <impl BuildASTPass for VaryStackDepthChecker>::run_pass -> ParseResult<()> with ParseResult::new(())
-clarity/src/vm/clarity.rs:70: replace <impl From for Error>::from -> Self with Default::default()
-clarity/src/vm/functions/arithmetic.rs:639: replace native_to_int -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
-clarity/src/vm/mod.rs:369: replace eval_all -> Result<Option<Value>> with Ok(Some(Default::default()))
-clarity/src/vm/functions/mod.rs:595: replace native_begin -> Result<Value> with Ok(Default::default())
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:311: replace Lexer<'a>::read_unsigned -> LexResult<Token> with LexResult::from(Default::default())
-clarity/src/vm/analysis/type_checker/v2_05/natives/assets.rs:56: replace check_special_get_balance -> TypeResult with Default::default()
-clarity/src/vm/analysis/analysis_db.rs:153: replace AnalysisDatabase<'a>::get_public_function_type -> CheckResult<Option<FunctionType>> with CheckResult::from_iter([Some(Default::default())])
-clarity/src/vm/ast/parser/v2/mod.rs:1062: replace Parser<'a>::parse_node_or_eof -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::from(Some(Default::default()))
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:253: replace ContractContext::add_persisted_variable_type -> CheckResult<()> with CheckResult::new()
-clarity/src/vm/ast/mod.rs:174: replace inner_build_ast -> ParseResult<(ContractAST, Vec<Diagnostic>, bool)> with ParseResult::new((Default::default(), vec![], true))
-clarity/src/vm/functions/tuples.rs:30: replace tuple_cons -> Result<Value> with Ok(Default::default())
-clarity/src/vm/analysis/contract_interface_builder/mod.rs:318: replace ContractInterfaceNonFungibleTokens::from_map -> Vec<Self> with vec![Default::default()]
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:62: replace TraitContext::add_defined_trait -> CheckResult<()> with CheckResult::from(())
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:388: replace TypeChecker<'a, 'b>::run -> CheckResult<()> with CheckResult::from_iter([()])
-clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs:100: replace check_special_at_block -> TypeResult with Default::default()
-clarity/src/vm/analysis/analysis_db.rs:123: replace AnalysisDatabase<'a>::insert_contract -> CheckResult<()> with CheckResult::new(())
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:162: replace ContractContext::add_nft -> CheckResult<()> with CheckResult::from_iter([()])
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:186: replace ContractContext::check_function_type -> CheckResult<()> with CheckResult::new()
-clarity/src/vm/database/structures.rs:744: replace STXBalance::zero -> STXBalance with Default::default()
-clarity/src/vm/contexts.rs:619: replace OwnedEnvironment<'a, 'hooks>::new_cost_limited -> OwnedEnvironment<'a, '_> with Default::default()
-clarity/src/vm/functions/arithmetic.rs:504: replace special_greater -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
-clarity/src/vm/functions/arithmetic.rs:572: replace native_log2 -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
-clarity/src/vm/types/mod.rs:101: replace QualifiedContractIdentifier::transient -> QualifiedContractIdentifier with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:986: replace TypeChecker<'a, 'b>::type_check -> TypeResult with Default::default()
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:126: replace ContractContext::add_map_type -> CheckResult<()> with CheckResult::from(())
-clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs:82: replace check_special_print -> TypeResult with Default::default()
-clarity/src/vm/database/clarity_db.rs:1129: replace ClarityDatabase<'a>::create_variable -> DataVariableMetadata with Default::default()
-clarity/src/vm/functions/assets.rs:436: replace special_mint_asset_v205 -> Result<Value> with Ok(Default::default())
-clarity/src/vm/ast/definition_sorter/mod.rs:456: replace GraphWalker::get_sorted_dependencies -> ParseResult<Vec<usize>> with ParseResult::new()
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:351: replace TypeChecker<'a, 'b>::into_contract_analysis -> LimitedCostTracker with Default::default()
-clarity/src/vm/analysis/types.rs:230: replace ContractAnalysis::check_trait_compliance -> CheckResult<()> with CheckResult::from_iter([()])
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:497: replace TypeChecker<'a, 'b>::type_check_consecutive_statements -> TypeResult with Default::default()
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:126: replace ContractContext::add_map_type -> CheckResult<()> with CheckResult::new(())
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:160: replace Lexer<'a>::proceed_through_error -> LexResult<String> with LexResult::new(String::new())
-clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs:500: replace check_secp256k1_verify -> TypeResult with Default::default()
-clarity/src/vm/ast/parser/v2/mod.rs:219: replace Parser<'a>::handle_open_node -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::new(None)
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:145: replace FunctionType::check_args_2_05 -> CheckResult<TypeSignature> with CheckResult::from_iter([Default::default()])
-clarity/src/vm/types/mod.rs:109: replace QualifiedContractIdentifier::parse -> Result<QualifiedContractIdentifier> with Ok(Default::default())
-clarity/src/vm/analysis/types.rs:167: replace ContractAnalysis::get_read_only_function_type -> Option<&FunctionType> with Some(&Default::default())
-clarity/src/vm/analysis/types.rs:230: replace ContractAnalysis::check_trait_compliance -> CheckResult<()> with CheckResult::new(())
-clarity/src/vm/types/signatures.rs:958: replace TypeSignature::empty_buffer -> TypeSignature with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:168: replace ContractContext::check_name_used -> CheckResult<()> with CheckResult::new(())
-clarity/src/vm/analysis/contract_interface_builder/mod.rs:266: replace ContractInterfaceFunction::from_map -> Vec<ContractInterfaceFunction> with vec![Default::default()]
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:571: replace clarity2_trait_check_trait_compliance -> CheckResult<()> with CheckResult::new(())
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1372: replace TypeChecker<'a, 'b>::type_check_define_ft -> CheckResult<ClarityName> with CheckResult::new()
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:118: replace <impl AnalysisPass for TypeChecker<'_, '_>>::run_pass -> CheckResult<()> with CheckResult::from(())
-clarity/src/vm/ast/sugar_expander/mod.rs:40: replace <impl BuildASTPass for SugarExpander>::run_pass -> ParseResult<()> with ParseResult::new(())
-clarity/src/vm/functions/assets.rs:260: replace special_stx_burn -> Result<Value> with Ok(Default::default())
-clarity/src/vm/database/key_value_wrapper.rs:466: replace RollbackWrapper<'a>::get_metadata -> InterpreterResult<Option<String>> with InterpreterResult::from(Some(String::new()))
-clarity/src/vm/costs/mod.rs:1050: replace <impl CostTracker for &mut LimitedCostTracker>::compute_cost -> std::result::Result<ExecutionCost, CostErrors> with Ok(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/natives/assets.rs:33: replace check_special_get_owner -> TypeResult with Default::default()
-clarity/src/vm/database/key_value_wrapper.rs:495: replace RollbackWrapper<'a>::get_metadata_manual -> InterpreterResult<Option<String>> with InterpreterResult::from(None)
-clarity/src/vm/functions/sequences.rs:87: replace special_fold -> Result<Value> with Ok(Default::default())
-clarity/src/vm/ast/traits_resolver/mod.rs:36: replace <impl BuildASTPass for TraitsResolver>::run_pass -> ParseResult<()> with ParseResult::new(())
-clarity/src/vm/functions/mod.rs:623: replace special_if -> Result<Value> with Ok(Default::default())
-clarity/src/vm/types/serialization.rs:120: replace <impl From for SerializationError>::from -> Self with Default::default()
-clarity/src/vm/database/clarity_db.rs:295: replace <impl HeadersDB for NullHeadersDB>::get_consensus_hash_for_block -> Option<ConsensusHash> with Some(Default::default())
-clarity/src/vm/representations.rs:664: replace Span::zero -> Span with Default::default()
-clarity/src/vm/ast/parser/v2/mod.rs:1093: replace parse -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::new()
-clarity/src/vm/analysis/type_checker/v2_1/natives/options.rs:113: replace check_special_default_to -> TypeResult with Default::default()
-clarity/src/vm/contexts.rs:1135: replace Environment<'a, 'b, 'hooks>::inner_execute_contract -> Result<Value> with Ok(Default::default())
-clarity/src/vm/test_util/mod.rs:210: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_stacks_epoch -> Option<StacksEpoch> with Some(Default::default())
-clarity/src/vm/functions/arithmetic.rs:554: replace native_add -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
-clarity/src/vm/functions/options.rs:173: replace special_match_resp -> Result<Value> with Ok(Default::default())
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:160: replace Lexer<'a>::proceed_through_error -> LexResult<String> with LexResult::from(String::new())
-clarity/src/vm/analysis/read_only_checker/mod.rs:182: replace ReadOnlyChecker<'a, 'b>::check_reads_only_valid -> CheckResult<()> with CheckResult::new()
-clarity/src/vm/database/clarity_db.rs:525: replace ClarityDatabase<'a>::get_with_proof -> Option<(T, Vec<u8>)> with Some((Default::default(), vec![]))
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1385: replace TypeChecker<'a, 'b>::type_check_define_nft -> CheckResult<(ClarityName, TypeSignature)> with CheckResult::new()
-clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs:662: replace check_get_burn_block_info -> TypeResult with Default::default()
-clarity/src/vm/database/clarity_db.rs:1602: replace ClarityDatabase<'a>::create_fungible_token -> FungibleTokenMetadata with Default::default()
-clarity/src/vm/database/clarity_db.rs:1778: replace ClarityDatabase<'a>::get_nft_owner -> Result<PrincipalData> with Ok(Default::default())
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:389: replace Lexer<'a>::read_ascii_string -> LexResult<Token> with LexResult::from(Default::default())
-clarity/src/vm/ast/mod.rs:69: replace parse_in_epoch -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::from_iter([vec![Default::default()]])
-clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs:103: replace check_special_begin -> TypeResult with Default::default()
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:185: replace Lexer<'a>::proceed_through_error_string -> LexResult<String> with LexResult::new()
-clarity/src/vm/ast/mod.rs:69: replace parse_in_epoch -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::new(vec![Default::default()])
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:62: replace TraitContext::add_defined_trait -> CheckResult<()> with CheckResult::from_iter([()])
-clarity/src/vm/types/mod.rs:1324: replace PrincipalData::parse_standard_principal -> Result<StandardPrincipalData> with Ok(Default::default())
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:530: replace TypeChecker<'a, 'b>::type_check_function_type -> TypeResult with Default::default()
-clarity/src/vm/ast/parser/v2/mod.rs:219: replace Parser<'a>::handle_open_node -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::new(Some(Default::default()))
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:102: replace TraitContext::get_trait -> Option<&BTreeMap<ClarityName, FunctionSignature>> with Some(&BTreeMap::new())
-clarity/src/vm/analysis/read_only_checker/mod.rs:281: replace ReadOnlyChecker<'a, 'b>::check_native_function_is_read_only -> CheckResult<bool> with CheckResult::new(true)
-clarity/src/vm/database/key_value_wrapper.rs:495: replace RollbackWrapper<'a>::get_metadata_manual -> InterpreterResult<Option<String>> with InterpreterResult::from(Some("xyzzy".into()))
-clarity/src/vm/costs/mod.rs:1099: replace <impl FromSql for ExecutionCost>::column_result -> FromSqlResult<ExecutionCost> with FromSqlResult::from(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs:203: replace check_special_concat -> TypeResult with Default::default()
-clarity/src/vm/functions/options.rs:258: replace native_default_to -> Result<Value> with Ok(Default::default())
-clarity/src/vm/functions/arithmetic.rs:381: replace native_bitwise_not -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
-clarity/src/vm/analysis/analysis_db.rs:106: replace AnalysisDatabase<'a>::load_contract -> Option<ContractAnalysis> with Some(Default::default())
-clarity/src/vm/types/mod.rs:1178: replace BuffData::len -> BufferLength with Default::default()
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:160: replace Lexer<'a>::proceed_through_error -> LexResult<String> with LexResult::new()
-clarity/src/vm/ast/mod.rs:103: replace build_ast_with_rules -> ParseResult<ContractAST> with ParseResult::from(Default::default())
-clarity/src/vm/types/mod.rs:653: replace <impl SequencedValue for ASCIIData>::items -> &Vec<u8> with &vec![0]
-clarity/src/vm/functions/arithmetic.rs:518: replace special_less_v1 -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1414: replace TypeChecker<'a, 'b>::try_type_check_define -> CheckResult<Option<()>> with CheckResult::new(Some(()))
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:785: replace clarity2_lookup_trait -> CheckResult<BTreeMap<ClarityName, FunctionSignature>> with CheckResult::from_iter([BTreeMap::new()])
-clarity/src/vm/test_util/mod.rs:256: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_ast_rules -> ASTRules with Default::default()
-clarity/src/vm/ast/parser/v2/mod.rs:1093: replace parse -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::new(vec![Default::default()])
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:182: replace ContractContext::get_trait -> Option<&BTreeMap<ClarityName, FunctionSignature>> with Some(&BTreeMap::new())
-clarity/src/vm/functions/conversions.rs:166: replace safe_convert_string_to_uint -> Result<Value> with Ok(Default::default())
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:61: replace ContractContext::check_name_used -> CheckResult<()> with CheckResult::from_iter([()])
-clarity/src/vm/database/clarity_db.rs:1502: replace ClarityDatabase<'a>::inner_set_entry -> Result<ValueResult> with Ok(Default::default())
-clarity/src/vm/ast/parser/v1.rs:192: replace inner_lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::from(vec![(Default::default(), 1, 1)])
-clarity/src/vm/analysis/read_only_checker/mod.rs:430: replace ReadOnlyChecker<'a, 'b>::check_expression_application_is_read_only -> CheckResult<bool> with CheckResult::from(false)
-clarity/src/vm/ast/expression_identifier/mod.rs:40: replace update_expression_id -> ParseResult<()> with ParseResult::new(())
-clarity/src/vm/test_util/mod.rs:61: replace execute_on_network -> Value with Default::default()
-clarity/src/vm/ast/parser/v2/mod.rs:807: replace Parser<'a>::parse_node -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::from_iter([None])
-clarity/src/vm/functions/arithmetic.rs:52: replace ASCIIOps::make_value -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1136: replace TypeChecker<'a, 'b>::type_check_define_map -> CheckResult<(ClarityName, (TypeSignature, TypeSignature))> with CheckResult::new((Default::default(), (Default::default(), Default::default())))
-clarity/src/vm/functions/assets.rs:979: replace special_burn_asset_v200 -> Result<Value> with Ok(Default::default())
-clarity/src/vm/analysis/analysis_db.rs:48: replace AnalysisDatabase<'a>::execute -> Result<T, E> with Ok(Default::default())
-clarity/src/vm/analysis/type_checker/v2_05/natives/sequences.rs:401: replace check_special_index_of -> TypeResult with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1398: replace TypeChecker<'a, 'b>::type_check_define_trait -> CheckResult<(ClarityName, BTreeMap<ClarityName, FunctionSignature>)> with CheckResult::from((Default::default(), BTreeMap::new()))
-clarity/src/vm/types/signatures.rs:1476: replace TypeSignature::parse_response_type_repr -> Result<TypeSignature> with Ok(Default::default())
-clarity/src/vm/functions/arithmetic.rs:67: replace BuffOps::make_value -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
-clarity/src/vm/ast/parser/v1.rs:462: replace unescape_ascii_chars -> ParseResult<String> with ParseResult::new(String::new())
-clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs:93: replace check_special_at_block -> TypeResult with Default::default()
-clarity/src/vm/analysis/errors.rs:262: replace <impl Error for CheckError>::source -> Option<&(dyn error::Error +'static)> with Some(&Default::default())
-clarity/src/vm/variables.rs:44: replace NativeVariables::lookup_by_name_at_version -> Option<NativeVariables> with Some(Default::default())
-clarity/src/vm/database/clarity_store.rs:327: replace <impl ClarityBackingStore for MemoryBackingStore>::get_cc_special_cases_handler -> Option<SpecialCaseHandler> with Some(Default::default())
-clarity/src/vm/types/serialization.rs:535: replace Value::deserialize_read_count -> Result<(Value, u64), SerializationError> with Ok((Default::default(), 0))
-clarity/src/vm/database/clarity_db.rs:157: replace <impl HeadersDB for &dyn HeadersDB>::get_stacks_block_header_hash_for_block -> Option<BlockHeaderHash> with Some(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/natives/options.rs:35: replace check_special_okay -> TypeResult with Default::default()
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:177: replace ContractContext::add_implemented_trait -> CheckResult<()> with CheckResult::from_iter([()])
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:845: replace type_reserved_variable -> Option<TypeSignature> with Some(Default::default())
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:106: replace ContractContext::add_read_only_function_type -> CheckResult<()> with CheckResult::from_iter([()])
-clarity/src/vm/database/key_value_wrapper.rs:354: replace RollbackWrapper<'a>::get_with_proof -> Option<(T, Vec<u8>)> with Some((Default::default(), vec![]))
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:311: replace Lexer<'a>::read_unsigned -> LexResult<Token> with LexResult::new(Default::default())
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:140: replace Lexer<'a>::read_line -> LexResult<String> with LexResult::new()
-clarity/src/vm/version.rs:46: replace <impl FromStr for ClarityVersion>::from_str -> Result<ClarityVersion, Error> with Ok(Default::default())
-clarity/src/vm/analysis/type_checker/mod.rs:64: replace FunctionType::check_args_by_allowing_trait_cast -> CheckResult<TypeSignature> with CheckResult::new()
-clarity/src/vm/analysis/type_checker/v2_05/natives/options.rs:46: replace check_special_some -> TypeResult with Default::default()
-clarity/src/vm/ast/parser/v1.rs:462: replace unescape_ascii_chars -> ParseResult<String> with ParseResult::new("xyzzy".into())
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:203: replace ContractContext::add_public_function_type -> CheckResult<()> with CheckResult::from_iter([()])
-clarity/src/vm/database/clarity_store.rs:285: replace MemoryBackingStore::as_analysis_db -> AnalysisDatabase with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/natives/options.rs:95: replace check_special_is_optional -> TypeResult with Default::default()
-clarity/src/vm/functions/arithmetic.rs:59: replace UTF8Ops::make_value -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
-clarity/src/vm/types/mod.rs:918: replace Value::cons_list -> Result<Value> with Ok(Default::default())
-clarity/src/vm/functions/arithmetic.rs:434: replace special_leq_v1 -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
-clarity/src/vm/functions/arithmetic.rs:518: replace special_less_v1 -> InterpreterResult<Value> with InterpreterResult::new()
-clarity/src/vm/database/clarity_db.rs:1447: replace ClarityDatabase<'a>::insert_entry_unknown_descriptor -> Result<Value> with Ok(Default::default())
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:388: replace TypeChecker<'a, 'b>::run -> CheckResult<()> with CheckResult::new(())
-clarity/src/vm/tests/datamaps.rs:689: replace make_tuple -> Value with Default::default()
-clarity/src/vm/analysis/read_only_checker/mod.rs:268: replace ReadOnlyChecker<'a, 'b>::try_check_native_function_is_read_only -> Option<CheckResult<bool>> with Some(CheckResult::new())
-clarity/src/vm/functions/arithmetic.rs:569: replace native_sqrti -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:792: replace TypeChecker<'a, 'b>::type_check_define_trait -> CheckResult<(ClarityName, BTreeMap<ClarityName, FunctionSignature>)> with CheckResult::from_iter([(Default::default(), BTreeMap::new())])
-clarity/src/vm/types/signatures.rs:261: replace FunctionReturnsSignature::canonicalize -> FunctionReturnsSignature with Default::default()
-clarity/src/vm/analysis/analysis_db.rs:208: replace AnalysisDatabase<'a>::get_implemented_traits -> CheckResult<BTreeSet<TraitIdentifier>> with CheckResult::new()
-clarity/src/vm/errors.rs:193: replace <impl From for Error>::from -> Self with Default::default()
-clarity/src/vm/ast/errors.rs:147: replace <impl From for ParseError>::from -> Self with Default::default()
-clarity/src/vm/contexts.rs:1646: replace GlobalContext<'a, 'hooks>::execute -> Result<T> with Ok(Default::default())
-clarity/src/vm/analysis/read_only_checker/mod.rs:268: replace ReadOnlyChecker<'a, 'b>::try_check_native_function_is_read_only -> Option<CheckResult<bool>> with Some(CheckResult::from_iter([true]))
-clarity/src/vm/database/key_value_wrapper.rs:466: replace RollbackWrapper<'a>::get_metadata -> InterpreterResult<Option<String>> with InterpreterResult::from_iter([None])
-clarity/src/vm/docs/mod.rs:2583: replace make_define_reference -> FunctionAPI with Default::default()
-clarity/src/vm/types/signatures.rs:1007: replace TypeSignature::bound_string_ascii_type -> TypeSignature with Default::default()
-clarity/src/vm/ast/stack_depth_checker.rs:28: replace check -> ParseResult<()> with ParseResult::from_iter([()])
-clarity/src/vm/functions/arithmetic.rs:476: replace special_greater_v1 -> InterpreterResult<Value> with InterpreterResult::new()
-clarity/src/vm/analysis/trait_checker/mod.rs:39: replace <impl AnalysisPass for TraitChecker>::run_pass -> CheckResult<()> with CheckResult::new()
-clarity/src/vm/test_util/mod.rs:116: replace <impl From for Value>::from -> Value with Default::default()
-clarity/src/vm/functions/database.rs:840: replace special_get_burn_block_info -> Result<Value> with Ok(Default::default())
-clarity/src/vm/representations.rs:534: replace SymbolicExpression::literal_value -> SymbolicExpression with Default::default()
-clarity/src/vm/ast/parser/v1.rs:455: replace lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::from_iter([vec![(Default::default(), 1, 1)]])
-clarity/src/vm/ast/parser/v1.rs:462: replace unescape_ascii_chars -> ParseResult<String> with ParseResult::from_iter(["xyzzy".into()])
-clarity/src/vm/functions/arithmetic.rs:575: replace native_mod -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:346: replace FunctionType::clarity2_principal_to_callable_type -> TypeResult with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:102: replace TraitContext::get_trait -> Option<&BTreeMap<ClarityName, FunctionSignature>> with Some(&BTreeMap::from_iter([(Default::default(), Default::default())]))
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:305: replace type_reserved_variable -> Option<TypeSignature> with Some(Default::default())
-clarity/src/vm/ast/parser/v1.rs:192: replace inner_lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::from(vec![(Default::default(), 0, 0)])
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:785: replace clarity2_lookup_trait -> CheckResult<BTreeMap<ClarityName, FunctionSignature>> with CheckResult::from(BTreeMap::new())
-clarity/src/vm/database/key_value_wrapper.rs:495: replace RollbackWrapper<'a>::get_metadata_manual -> InterpreterResult<Option<String>> with InterpreterResult::new(Some(String::new()))
-clarity/src/vm/functions/arithmetic.rs:569: replace native_sqrti -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1346: replace TypeChecker<'a, 'b>::type_check_define_variable -> CheckResult<(ClarityName, TypeSignature)> with CheckResult::new((Default::default(), Default::default()))
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1398: replace TypeChecker<'a, 'b>::type_check_define_trait -> CheckResult<(ClarityName, BTreeMap<ClarityName, FunctionSignature>)> with CheckResult::new((Default::default(), BTreeMap::from_iter([(Default::default(), Default::default())])))
-clarity/src/vm/types/mod.rs:886: replace Value::list_with_type -> Result<Value> with Ok(Default::default())
-clarity/src/vm/contexts.rs:1040: replace Environment<'a, 'b, 'hooks>::eval_read_only -> Result<Value> with Ok(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs:566: replace check_principal_of -> TypeResult with Default::default()
-clarity/src/vm/contexts.rs:1825: replace ContractContext::lookup_trait_definition -> Option<BTreeMap<ClarityName, FunctionSignature>> with Some(BTreeMap::from_iter([(Default::default(), Default::default())]))
-clarity/src/vm/types/signatures.rs:1489: replace TypeSignature::parse_type_repr -> Result<TypeSignature> with Ok(Default::default())
-clarity/src/vm/ast/mod.rs:53: replace parse -> Result<Vec<SymbolicExpression>, Error> with Ok(vec![Default::default()])
-clarity/src/vm/database/clarity_db.rs:166: replace <impl HeadersDB for &dyn HeadersDB>::get_vrf_seed_for_block -> Option<VRFSeed> with Some(Default::default())
-clarity/src/vm/functions/arithmetic.rs:518: replace special_less_v1 -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
-clarity/src/vm/ast/parser/v2/mod.rs:1093: replace parse -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::from_iter([vec![]])
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:304: replace ContractContext::get_trait -> Option<&BTreeMap<ClarityName, FunctionSignature>> with Some(&BTreeMap::new())
-clarity/src/vm/analysis/read_only_checker/mod.rs:227: replace ReadOnlyChecker<'a, 'b>::check_read_only -> CheckResult<bool> with CheckResult::from_iter([false])
-clarity/src/vm/types/signatures.rs:49: replace AssetIdentifier::STX -> AssetIdentifier with Default::default()
-clarity/src/vm/functions/arithmetic.rs:560: replace native_mul -> InterpreterResult<Value> with InterpreterResult::new()
-clarity/src/vm/database/clarity_db.rs:525: replace ClarityDatabase<'a>::get_with_proof -> Option<(T, Vec<u8>)> with Some((Default::default(), vec![1]))
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:213: replace ContractContext::add_read_only_function_type -> CheckResult<()> with CheckResult::from_iter([()])
-clarity/src/vm/ast/stack_depth_checker.rs:53: replace check_vary -> ParseResult<()> with ParseResult::new(())
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:156: replace FunctionType::check_args_2_1 -> CheckResult<TypeSignature> with CheckResult::new()
-clarity/src/vm/analysis/analysis_db.rs:208: replace AnalysisDatabase<'a>::get_implemented_traits -> CheckResult<BTreeSet<TraitIdentifier>> with CheckResult::new(BTreeSet::from_iter([Default::default()]))
-clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs:113: replace inner_handle_tuple_get -> TypeResult with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs:864: replace TypedNativeFunction::type_native_function::parse_principal_basic_type -> TypeSignature with Default::default()
-clarity/src/vm/database/clarity_store.rs:291: replace <impl ClarityBackingStore for MemoryBackingStore>::set_block_hash -> InterpreterResult<StacksBlockId> with InterpreterResult::new()
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:126: replace ContractContext::add_map_type -> CheckResult<()> with CheckResult::from_iter([()])
-clarity/src/vm/functions/arithmetic.rs:569: replace native_sqrti -> InterpreterResult<Value> with InterpreterResult::new()
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1357: replace TypeChecker<'a, 'b>::type_check_define_persisted_variable -> CheckResult<(ClarityName, TypeSignature)> with CheckResult::new((Default::default(), Default::default()))
-clarity/src/vm/analysis/type_checker/contexts.rs:129: replace TypingContext<'a>::lookup_trait_reference_type -> Option<&TraitIdentifier> with Some(&Default::default())
-clarity/src/vm/functions/arithmetic.rs:47: replace I128Ops::make_value -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
-clarity/src/vm/types/signatures.rs:1409: replace TypeSignature::parse_tuple_type_repr -> Result<TypeSignature> with Ok(Default::default())
-clarity/src/vm/functions/database.rs:69: replace special_contract_call -> Result<Value> with Ok(Default::default())
-clarity/src/vm/ast/mod.rs:87: replace ast_check_size -> ParseResult<ContractAST> with ParseResult::from_iter([Default::default()])
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:546: replace TypeChecker<'a, 'b>::type_check_define_function -> CheckResult<(ClarityName, FixedFunction)> with CheckResult::new()
-clarity/src/vm/contexts.rs:408: replace AssetMap::to_table -> HashMap<PrincipalData, HashMap<AssetIdentifier, AssetMapEntry>> with HashMap::from_iter([(Default::default(), HashMap::from_iter([(Default::default(), Default::default())]))])
-clarity/src/vm/analysis/type_checker/contexts.rs:65: replace TypeMap::get_type -> Option<&TypeSignature> with Some(&Default::default())
-clarity/src/vm/functions/arithmetic.rs:554: replace native_add -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
-clarity/src/vm/functions/arithmetic.rs:532: replace special_less_v2 -> InterpreterResult<Value> with InterpreterResult::new()
-clarity/src/vm/database/clarity_store.rs:239: replace <impl ClarityBackingStore for NullBackingStore>::get_block_at_height -> Option<StacksBlockId> with Some(Default::default())
-clarity/src/vm/clarity.rs:55: replace <impl From for Error>::from -> Self with Default::default()
-clarity/src/vm/functions/arithmetic.rs:67: replace BuffOps::make_value -> InterpreterResult<Value> with InterpreterResult::new()
-clarity/src/vm/analysis/contract_interface_builder/mod.rs:354: replace ContractInterfaceMap::from_map -> Vec<ContractInterfaceMap> with vec![Default::default()]
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:116: replace ContractContext::add_private_function_type -> CheckResult<()> with CheckResult::new()
-clarity/src/vm/functions/define.rs:139: replace handle_define_function -> Result<DefineResult> with Ok(Default::default())
-clarity/src/vm/contexts.rs:631: replace OwnedEnvironment<'a, 'hooks>::get_exec_environment -> Environment<'b, 'a, 'hooks> with Default::default()
-clarity/src/vm/analysis/mod.rs:50: replace mem_type_check -> CheckResult<(Option<TypeSignature>, ContractAnalysis)> with CheckResult::new((None, Default::default()))
-clarity/src/vm/representations.rs:275: replace PreSymbolicExpression::sugared_contract_identifier -> PreSymbolicExpression with Default::default()
-clarity/src/vm/analysis/analysis_db.rs:189: replace AnalysisDatabase<'a>::get_defined_trait -> CheckResult<Option<BTreeMap<ClarityName, FunctionSignature>>> with CheckResult::new()
-clarity/src/vm/types/mod.rs:653: replace <impl SequencedValue for ASCIIData>::items -> &Vec<u8> with &vec![]
-clarity/src/vm/representations.rs:292: replace PreSymbolicExpression::atom_value -> PreSymbolicExpression with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:233: replace ContractContext::add_map_type -> CheckResult<()> with CheckResult::new(())
-clarity/src/vm/ast/definition_sorter/mod.rs:433: replace Graph::edges_count -> ParseResult<u64> with ParseResult::new(0)
-clarity/src/vm/analysis/read_only_checker/mod.rs:170: replace ReadOnlyChecker<'a, 'b>::check_define_function -> CheckResult<(ClarityName, bool)> with CheckResult::from_iter([(Default::default(), true)])
-clarity/src/vm/functions/arithmetic.rs:377: replace native_bitwise_or -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
-clarity/src/vm/analysis/analysis_db.rs:215: replace AnalysisDatabase<'a>::destroy -> RollbackWrapper<'a> with Default::default()
-clarity/src/vm/database/clarity_db.rs:351: replace <impl BurnStateDB for NullBurnStateDB>::get_burn_header_hash -> Option<BurnchainHeaderHash> with Some(Default::default())
-clarity/src/vm/functions/arithmetic.rs:504: replace special_greater -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
-clarity/src/vm/ast/sugar_expander/mod.rs:66: replace SugarExpander::transform -> ParseResult<Vec<SymbolicExpression>> with ParseResult::new()
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:546: replace TypeChecker<'a, 'b>::type_check_define_function -> CheckResult<(ClarityName, FixedFunction)> with CheckResult::new((Default::default(), Default::default()))
-clarity/src/vm/analysis/type_checker/mod.rs:64: replace FunctionType::check_args_by_allowing_trait_cast -> CheckResult<TypeSignature> with CheckResult::from_iter([Default::default()])
-clarity/src/vm/ast/parser/v1.rs:720: replace parse -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::new(vec![Default::default()])
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:186: replace ContractContext::check_function_type -> CheckResult<()> with CheckResult::from(())
-clarity/src/vm/representations.rs:299: replace PreSymbolicExpression::atom -> PreSymbolicExpression with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/natives/assets.rs:140: replace check_special_transfer_asset -> TypeResult with Default::default()
-clarity/src/vm/analysis/read_only_checker/mod.rs:170: replace ReadOnlyChecker<'a, 'b>::check_define_function -> CheckResult<(ClarityName, bool)> with CheckResult::from_iter([(Default::default(), false)])
-clarity/src/vm/ast/mod.rs:153: replace build_ast_with_diagnostics -> (ContractAST, Vec<Diagnostic>, bool) with (Default::default(), vec![], false)
-clarity/src/vm/analysis/type_checker/contexts.rs:82: replace TypingContext<'a>::extend -> CheckResult<TypingContext> with CheckResult::from(Default::default())
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:779: replace TypeChecker<'a, 'b>::type_check_define_nft -> CheckResult<(ClarityName, TypeSignature)> with CheckResult::new((Default::default(), Default::default()))
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:162: replace ContractContext::add_nft -> CheckResult<()> with CheckResult::new(())
-clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs:365: replace check_contract_call -> TypeResult with Default::default()
-clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs:75: replace check_special_print -> TypeResult with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1414: replace TypeChecker<'a, 'b>::try_type_check_define -> CheckResult<Option<()>> with CheckResult::from(None)
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:831: replace trait_type_size -> CheckResult<u64> with CheckResult::new(1)
-clarity/src/vm/analysis/trait_checker/mod.rs:55: replace TraitChecker::run -> CheckResult<()> with CheckResult::from(())
-clarity/src/vm/database/clarity_db.rs:620: replace ClarityDatabase<'a>::fetch_metadata -> Result<Option<T>> with Ok(Some(Default::default()))
-clarity/src/vm/analysis/type_checker/mod.rs:64: replace FunctionType::check_args_by_allowing_trait_cast -> CheckResult<TypeSignature> with CheckResult::from(Default::default())
-clarity/src/vm/ast/definition_sorter/mod.rs:54: replace DefinitionSorter::run_pass -> ParseResult<()> with ParseResult::new(())
-clarity/src/vm/ast/sugar_expander/mod.rs:66: replace SugarExpander::transform -> ParseResult<Vec<SymbolicExpression>> with ParseResult::from_iter([vec![Default::default()]])
-clarity/src/vm/types/mod.rs:690: replace <impl SequencedValue for UTF8Data>::to_value -> Value with Default::default()
-clarity/src/vm/ast/expression_identifier/mod.rs:51: replace ExpressionIdentifier::run_pre_expression_pass -> ParseResult<()> with ParseResult::from_iter([()])
-clarity/src/vm/ast/parser/v1.rs:455: replace lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::from(vec![(Default::default(), 1, 1)])
-clarity/src/vm/database/sqlite.rs:203: replace SqliteConnection::inner_open -> Result<Connection> with Ok(Default::default())
-clarity/src/vm/analysis/analysis_db.rs:171: replace AnalysisDatabase<'a>::get_read_only_function_type -> CheckResult<Option<FunctionType>> with CheckResult::from_iter([None])
-clarity/src/vm/types/mod.rs:1521: replace TupleData::get -> Result<&Value> with Ok(&Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:868: replace no_type -> TypeSignature with Default::default()
-clarity/src/vm/analysis/type_checker/v2_05/natives/options.rs:142: replace inner_unwrap -> TypeResult with Default::default()
-clarity/src/vm/analysis/type_checker/v2_05/natives/maps.rs:107: replace check_set_or_insert_entry -> TypeResult with Default::default()
-clarity/src/vm/types/signatures.rs:861: replace TupleTypeSignature::get_type_map -> &BTreeMap<ClarityName, TypeSignature> with &BTreeMap::new()
-clarity/src/vm/database/clarity_db.rs:1330: replace ClarityDatabase<'a>::fetch_entry -> Result<Value> with Ok(Default::default())
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:177: replace ContractContext::add_implemented_trait -> CheckResult<()> with CheckResult::new(())
-clarity/src/vm/analysis/contract_interface_builder/mod.rs:236: replace ContractInterfaceFunctionArg::from_function_args -> Vec<ContractInterfaceFunctionArg> with vec![Default::default()]
-clarity/src/vm/contexts.rs:726: replace OwnedEnvironment<'a, 'hooks>::initialize_contract_from_ast -> Result<((), AssetMap, Vec<StacksTransactionEvent>)> with Ok(((), Default::default(), vec![Default::default()]))
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:785: replace clarity2_lookup_trait -> CheckResult<BTreeMap<ClarityName, FunctionSignature>> with CheckResult::from(BTreeMap::from_iter([(Default::default(), Default::default())]))
-clarity/src/vm/ast/sugar_expander/mod.rs:66: replace SugarExpander::transform -> ParseResult<Vec<SymbolicExpression>> with ParseResult::new(vec![])
-clarity/src/vm/mod.rs:557: replace execute -> Result<Option<Value>> with Ok(Some(Default::default()))
-clarity/src/vm/types/signatures.rs:1065: replace TypeSignature::least_supertype_v2_0 -> Result<TypeSignature> with Ok(Default::default())
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:389: replace Lexer<'a>::read_ascii_string -> LexResult<Token> with LexResult::new()
-clarity/src/vm/functions/sequences.rs:252: replace special_concat_v205 -> Result<Value> with Ok(Default::default())
-clarity/src/vm/types/serialization.rs:150: replace <impl From for TypePrefix>::from -> TypePrefix with Default::default()
-clarity/src/vm/ast/mod.rs:174: replace inner_build_ast -> ParseResult<(ContractAST, Vec<Diagnostic>, bool)> with ParseResult::from_iter([(Default::default(), vec![Default::default()], true)])
-clarity/src/vm/representations.rs:341: replace PreSymbolicExpression::comment -> PreSymbolicExpression with Default::default()
-clarity/src/vm/database/key_value_wrapper.rs:495: replace RollbackWrapper<'a>::get_metadata_manual -> InterpreterResult<Option<String>> with InterpreterResult::new()
-clarity/src/vm/representations.rs:570: replace SymbolicExpression::match_list -> Option<&[SymbolicExpression]> with Some(Vec::leak(vec![Default::default()]))
-clarity/src/vm/representations.rs:424: replace depth_traverse -> Result<T, E> with Ok(Default::default())
-clarity/src/vm/database/clarity_db.rs:287: replace <impl HeadersDB for NullHeadersDB>::get_stacks_block_header_hash_for_block -> Option<BlockHeaderHash> with Some(Default::default())
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:160: replace Lexer<'a>::proceed_through_error -> LexResult<String> with LexResult::from("xyzzy".into())
-clarity/src/vm/functions/sequences.rs:330: replace native_element_at -> Result<Value> with Ok(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1321: replace TypeChecker<'a, 'b>::inner_type_check -> TypeResult with Default::default()
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:326: replace Lexer<'a>::read_integer -> LexResult<Token> with LexResult::from_iter([Default::default()])
-clarity/src/vm/functions/arithmetic.rs:405: replace special_geq_v2 -> InterpreterResult<Value> with InterpreterResult::new()
-clarity/src/vm/types/mod.rs:1148: replace Value::expect_result_ok -> Value with Default::default()
-clarity/src/vm/contexts.rs:764: replace OwnedEnvironment<'a, 'hooks>::stx_transfer -> Result<(Value, AssetMap, Vec<StacksTransactionEvent>)> with Ok((Default::default(), Default::default(), vec![]))
-clarity/src/vm/analysis/type_checker/v2_05/natives/options.rs:252: replace check_special_unwrap -> TypeResult with Default::default()
-clarity/src/vm/types/mod.rs:189: replace TraitIdentifier::parse_fully_qualified -> Result<TraitIdentifier> with Ok(Default::default())
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:575: replace Lexer<'a>::read_utf8_string -> LexResult<Token> with LexResult::from(Default::default())
-clarity/src/vm/analysis/type_checker/v2_05/natives/sequences.rs:349: replace check_special_len -> TypeResult with Default::default()
-clarity/src/vm/functions/arithmetic.rs:604: replace native_bitwise_right_shift -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
-clarity/src/vm/callables.rs:351: replace DefinedFunction::get_identifier -> FunctionIdentifier with Default::default()
-clarity/src/vm/functions/arithmetic.rs:67: replace BuffOps::make_value -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
-clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs:548: replace TypedNativeFunction::type_native_function -> TypedNativeFunction with Default::default()
-clarity/src/vm/ast/parser/v2/lexer/error.rs:71: replace <impl DiagnosableError for LexerError>::level -> crate::vm::diagnostic::Level with Default::default()
-clarity/src/vm/ast/definition_sorter/mod.rs:54: replace DefinitionSorter::run_pass -> ParseResult<()> with ParseResult::from_iter([()])
-clarity/src/vm/docs/mod.rs:2570: replace make_for_define -> FunctionAPI with Default::default()
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:766: replace TypeChecker<'a, 'b>::type_check_define_ft -> CheckResult<ClarityName> with CheckResult::from(Default::default())
-clarity/src/vm/analysis/type_checker/v2_05/natives/options.rs:92: replace check_special_is_optional -> TypeResult with Default::default()
-clarity/src/vm/analysis/type_checker/v2_05/natives/assets.rs:244: replace check_special_burn_token -> TypeResult with Default::default()
-clarity/src/vm/analysis/mod.rs:50: replace mem_type_check -> CheckResult<(Option<TypeSignature>, ContractAnalysis)> with CheckResult::new((Some(Default::default()), Default::default()))
-clarity/src/vm/types/signatures.rs:1812: replace parse_name_type_pairs -> Result<Vec<(ClarityName, TypeSignature)>> with Ok(vec![(Default::default(), Default::default())])
-clarity/src/vm/contexts.rs:752: replace OwnedEnvironment<'a, 'hooks>::execute_transaction -> Result<(Value, AssetMap, Vec<StacksTransactionEvent>)> with Ok((Default::default(), Default::default(), vec![Default::default()]))
-clarity/src/vm/docs/contracts.rs:95: replace make_docs -> ContractRef with Default::default()
-clarity/src/vm/functions/arithmetic.rs:604: replace native_bitwise_right_shift -> InterpreterResult<Value> with InterpreterResult::new()
-clarity/src/vm/functions/define.rs:206: replace handle_define_fungible_token -> Result<DefineResult> with Ok(Default::default())
-clarity/src/vm/analysis/trait_checker/mod.rs:39: replace <impl AnalysisPass for TraitChecker>::run_pass -> CheckResult<()> with CheckResult::from_iter([()])
-clarity/src/vm/contexts.rs:556: replace OwnedEnvironment<'a, 'hooks>::new_toplevel -> OwnedEnvironment<'a, '_> with Default::default()
-clarity/src/vm/functions/principals.rs:155: replace special_principal_destruct -> Result<Value> with Ok(Default::default())
-clarity/src/vm/functions/options.rs:246: replace native_is_err -> Result<Value> with Ok(Default::default())
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:792: replace TypeChecker<'a, 'b>::type_check_define_trait -> CheckResult<(ClarityName, BTreeMap<ClarityName, FunctionSignature>)> with CheckResult::new((Default::default(), BTreeMap::new()))
-clarity/src/vm/ast/traits_resolver/mod.rs:201: replace TraitsResolver::probe_for_generics -> ParseResult<()> with ParseResult::from(())
-clarity/src/vm/database/clarity_db.rs:225: replace <impl BurnStateDB for &dyn BurnStateDB>::get_stacks_epoch -> Option<StacksEpoch> with Some(Default::default())
-clarity/src/vm/ast/parser/v2/mod.rs:687: replace Parser<'a>::read_sugared_principal -> ParseResult<PreSymbolicExpression> with ParseResult::from_iter([Default::default()])
-clarity/src/vm/database/key_value_wrapper.rs:384: replace RollbackWrapper<'a>::deserialize_value -> Result<ValueResult, SerializationError> with Ok(Default::default())
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:116: replace ContractContext::add_private_function_type -> CheckResult<()> with CheckResult::from_iter([()])
-clarity/src/vm/analysis/read_only_checker/mod.rs:112: replace ReadOnlyChecker<'a, 'b>::check_top_level_expression -> CheckResult<()> with CheckResult::new()
-clarity/src/vm/functions/arithmetic.rs:560: replace native_mul -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:304: replace ContractContext::get_trait -> Option<&BTreeMap<ClarityName, FunctionSignature>> with Some(&BTreeMap::from_iter([(Default::default(), Default::default())]))
-clarity/src/vm/ast/traits_resolver/mod.rs:48: replace TraitsResolver::run -> ParseResult<()> with ParseResult::new(())
-clarity/src/vm/functions/sequences.rs:56: replace special_filter -> Result<Value> with Ok(Default::default())
-clarity/src/vm/functions/database.rs:469: replace special_set_entry_v200 -> Result<Value> with Ok(Default::default())
-clarity/src/vm/ast/definition_sorter/mod.rs:379: replace DefinitionSorter::find_expression_definition -> Option<(ClarityName, u64, &'b PreSymbolicExpression)> with Some((Default::default(), 0, &Default::default()))
-clarity/src/vm/functions/conversions.rs:218: replace to_consensus_buff -> Result<Value> with Ok(Default::default())
-clarity/src/vm/types/mod.rs:1191: replace BuffData::empty -> Self with Default::default()
-clarity/src/vm/types/signatures.rs:464: replace ListTypeData::destruct -> (TypeSignature, u32) with (Default::default(), 1)
-clarity/src/vm/ast/parser/v2/mod.rs:1083: replace Parser<'a>::parse -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::from(vec![])
-clarity/src/vm/analysis/read_only_checker/mod.rs:244: replace ReadOnlyChecker<'a, 'b>::check_each_expression_is_read_only -> CheckResult<bool> with CheckResult::from_iter([false])
-clarity/src/vm/analysis/analysis_db.rs:137: replace AnalysisDatabase<'a>::get_clarity_version -> CheckResult<ClarityVersion> with CheckResult::new(Default::default())
-clarity/src/vm/database/clarity_db.rs:364: replace <impl BurnStateDB for NullBurnStateDB>::get_stacks_epoch_by_epoch_id -> Option<StacksEpoch> with Some(Default::default())
-clarity/src/vm/ast/definition_sorter/mod.rs:65: replace DefinitionSorter::run -> ParseResult<()> with ParseResult::new()
-clarity/src/vm/types/mod.rs:1126: replace Value::expect_callable -> CallableData with Default::default()
-clarity/src/vm/types/signatures.rs:444: replace ListTypeData::new_list -> Result<ListTypeData> with Ok(Default::default())
-clarity/src/vm/analysis/read_only_checker/mod.rs:170: replace ReadOnlyChecker<'a, 'b>::check_define_function -> CheckResult<(ClarityName, bool)> with CheckResult::new((Default::default(), false))
-clarity/src/vm/contexts.rs:829: replace OwnedEnvironment<'a, 'hooks>::eval_read_only -> Result<(Value, AssetMap, Vec<StacksTransactionEvent>)> with Ok((Default::default(), Default::default(), vec![]))
-clarity/src/vm/ast/sugar_expander/mod.rs:66: replace SugarExpander::transform -> ParseResult<Vec<SymbolicExpression>> with ParseResult::from(vec![])
-clarity/src/vm/types/serialization.rs:114: replace <impl From for SerializationError>::from -> Self with Default::default()
-clarity/src/vm/functions/arithmetic.rs:563: replace native_div -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
-clarity/src/vm/ast/mod.rs:69: replace parse_in_epoch -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::from_iter([vec![]])
-clarity/src/vm/types/mod.rs:1007: replace Value::string_utf8_from_bytes -> Result<Value> with Ok(Default::default())
-clarity/src/vm/database/key_value_wrapper.rs:466: replace RollbackWrapper<'a>::get_metadata -> InterpreterResult<Option<String>> with InterpreterResult::new(Some("xyzzy".into()))
-clarity/src/vm/database/key_value_wrapper.rs:425: replace RollbackWrapper<'a>::get_block_header_hash -> Option<StacksBlockId> with Some(Default::default())
-clarity/src/vm/functions/arithmetic.rs:41: replace U128Ops::make_value -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
-clarity/src/vm/costs/mod.rs:891: replace compute_cost -> Result<ExecutionCost> with Ok(Default::default())
-clarity/src/vm/functions/arithmetic.rs:563: replace native_div -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:168: replace ContractContext::check_name_used -> CheckResult<()> with CheckResult::new()
-clarity/src/vm/ast/mod.rs:174: replace inner_build_ast -> ParseResult<(ContractAST, Vec<Diagnostic>, bool)> with ParseResult::from((Default::default(), vec![Default::default()], true))
-clarity/src/vm/types/signatures.rs:763: replace TypeSignature::concretize -> Result<TypeSignature> with Ok(Default::default())
-clarity/src/vm/functions/sequences.rs:281: replace special_as_max_len -> Result<Value> with Ok(Default::default())
-clarity/src/vm/ast/definition_sorter/mod.rs:357: replace DefinitionSorter::probe_for_dependencies_in_wrapped_key_value_pairs -> ParseResult<()> with ParseResult::new(())
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:328: replace FunctionType::principal_to_callable_type -> TypeResult with Default::default()
-clarity/src/vm/tests/principals.rs:306: replace create_principal_destruct_tuple_from_strings -> Value with Default::default()
-clarity/src/vm/types/mod.rs:1099: replace Value::expect_tuple -> TupleData with Default::default()
-clarity/src/vm/functions/sequences.rs:178: replace special_append -> Result<Value> with Ok(Default::default())
-clarity/src/vm/analysis/types.rs:230: replace ContractAnalysis::check_trait_compliance -> CheckResult<()> with CheckResult::new()
-clarity/src/vm/analysis/trait_checker/mod.rs:39: replace <impl AnalysisPass for TraitChecker>::run_pass -> CheckResult<()> with CheckResult::from(())
-clarity/src/vm/analysis/type_checker/v2_05/natives/sequences.rs:264: replace check_special_append -> TypeResult with Default::default()
-clarity/src/vm/analysis/type_checker/v2_05/natives/options.rs:303: replace check_special_match_opt -> TypeResult with Default::default()
-clarity/src/vm/database/clarity_db.rs:525: replace ClarityDatabase<'a>::get_with_proof -> Option<(T, Vec<u8>)> with Some((Default::default(), vec![0]))
-clarity/src/vm/database/clarity_db.rs:1038: replace ClarityDatabase<'a>::get_cc_special_cases_handler -> Option<SpecialCaseHandler> with Some(Default::default())
-clarity/src/vm/types/serialization.rs:1198: replace Value::sanitize_value -> Option<(Value, bool)> with Some((Default::default(), true))
-clarity/src/vm/analysis/type_checker/v2_05/natives/sequences.rs:39: replace get_simple_native_or_user_define -> CheckResult<FunctionType> with CheckResult::from_iter([Default::default()])
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:186: replace ContractContext::check_function_type -> CheckResult<()> with CheckResult::new(())
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:766: replace TypeChecker<'a, 'b>::type_check_define_ft -> CheckResult<ClarityName> with CheckResult::from_iter([Default::default()])
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:126: replace ContractContext::add_map_type -> CheckResult<()> with CheckResult::new()
-clarity/src/vm/functions/principals.rs:88: replace create_principal_destruct_tuple -> Value with Default::default()
-clarity/src/vm/types/mod.rs:1319: replace PrincipalData::parse_qualified_contract_principal -> Result<PrincipalData> with Ok(Default::default())
-clarity/src/vm/ast/expression_identifier/mod.rs:23: replace inner_relabel -> ParseResult<u64> with ParseResult::from_iter([0])
-clarity/src/vm/test_util/mod.rs:253: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_sortition_id_from_consensus_hash -> Option<SortitionId> with Some(Default::default())
-clarity/src/vm/ast/sugar_expander/mod.rs:40: replace <impl BuildASTPass for SugarExpander>::run_pass -> ParseResult<()> with ParseResult::from(())
-clarity/src/vm/types/signatures.rs:1463: replace TypeSignature::parse_optional_type_repr -> Result<TypeSignature> with Ok(Default::default())
-clarity/src/vm/ast/definition_sorter/mod.rs:456: replace GraphWalker::get_sorted_dependencies -> ParseResult<Vec<usize>> with ParseResult::from_iter([vec![0]])
-clarity/src/vm/representations.rs:551: replace SymbolicExpression::trait_reference -> SymbolicExpression with Default::default()
-clarity/src/vm/ast/parser/v2/mod.rs:687: replace Parser<'a>::read_sugared_principal -> ParseResult<PreSymbolicExpression> with ParseResult::new()
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:575: replace Lexer<'a>::read_utf8_string -> LexResult<Token> with LexResult::new(Default::default())
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:479: replace TypeChecker<'a, 'b>::type_check -> TypeResult with Default::default()
-clarity/src/vm/ast/definition_sorter/mod.rs:345: replace DefinitionSorter::probe_for_dependencies_in_list_of_wrapped_key_value_pairs -> ParseResult<()> with ParseResult::from_iter([()])
-clarity/src/vm/types/serialization.rs:102: replace <impl Error for SerializationError>::source -> Option<&(dyn error::Error +'static)> with Some(&Default::default())
-clarity/src/vm/functions/crypto.rs:71: replace pubkey_to_address_v1 -> StacksAddress with Default::default()
-clarity/src/vm/ast/parser/v2/mod.rs:463: replace Parser<'a>::open_tuple -> ParseResult<SetupTupleResult> with ParseResult::from(Default::default())
-clarity/src/vm/functions/database.rs:260: replace special_fetch_variable_v205 -> Result<Value> with Ok(Default::default())
-clarity/src/vm/contexts.rs:687: replace OwnedEnvironment<'a, 'hooks>::initialize_contract -> Result<((), AssetMap, Vec<StacksTransactionEvent>)> with Ok(((), Default::default(), vec![Default::default()]))
-clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs:188: replace check_special_tuple_cons -> TypeResult with Default::default()
-clarity/src/vm/types/signatures.rs:1305: replace TypeSignature::empty_list -> ListTypeData with Default::default()
-clarity/src/vm/functions/arithmetic.rs:557: replace native_sub -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:779: replace TypeChecker<'a, 'b>::type_check_define_nft -> CheckResult<(ClarityName, TypeSignature)> with CheckResult::from((Default::default(), Default::default()))
-clarity/src/vm/ast/stack_depth_checker.rs:48: replace <impl BuildASTPass for StackDepthChecker>::run_pass -> ParseResult<()> with ParseResult::from(())
-clarity/src/vm/ast/sugar_expander/mod.rs:56: replace SugarExpander::run -> ParseResult<()> with ParseResult::from_iter([()])
-clarity/src/vm/functions/define.rs:291: replace DefineFunctionsParsed<'a>::try_parse -> std::result::Result<Option<DefineFunctionsParsed<'a>>, CheckErrors> with Ok(Some(Default::default()))
-clarity/src/vm/analysis/type_checker/v2_05/natives/sequences.rs:156: replace check_special_fold -> TypeResult with Default::default()
-clarity/src/vm/types/signatures.rs:806: replace <impl TryFrom for TupleTypeSignature>::try_from -> Result<TupleTypeSignature> with Ok(Default::default())
-clarity/src/vm/representations.rs:558: replace SymbolicExpression::field -> SymbolicExpression with Default::default()
-clarity/src/vm/functions/sequences.rs:226: replace special_concat_v200 -> Result<Value> with Ok(Default::default())
-clarity/src/vm/database/key_value_wrapper.rs:495: replace RollbackWrapper<'a>::get_metadata_manual -> InterpreterResult<Option<String>> with InterpreterResult::from_iter([None])
-clarity/src/vm/functions/arithmetic.rs:639: replace native_to_int -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
-clarity/src/vm/types/serialization.rs:1097: replace Value::try_deserialize_hex -> Result<Value, SerializationError> with Ok(Default::default())
-clarity/src/vm/functions/options.rs:242: replace native_is_okay -> Result<Value> with Ok(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs:39: replace get_simple_native_or_user_define -> CheckResult<FunctionType> with CheckResult::from_iter([Default::default()])
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:61: replace ContractContext::check_name_used -> CheckResult<()> with CheckResult::new(())
-clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs:110: replace check_special_begin -> TypeResult with Default::default()
-clarity/src/vm/functions/options.rs:216: replace native_some -> Result<Value> with Ok(Default::default())
-clarity/src/vm/ast/parser/v1.rs:192: replace inner_lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::from(vec![(Default::default(), 1, 0)])
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:79: replace ContractContext::check_function_type -> CheckResult<()> with CheckResult::from_iter([()])
-clarity/src/vm/ast/mod.rs:103: replace build_ast_with_rules -> ParseResult<ContractAST> with ParseResult::from_iter([Default::default()])
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1398: replace TypeChecker<'a, 'b>::type_check_define_trait -> CheckResult<(ClarityName, BTreeMap<ClarityName, FunctionSignature>)> with CheckResult::new()
-clarity/src/vm/analysis/read_only_checker/mod.rs:59: replace <impl AnalysisPass for ReadOnlyChecker<'a, 'b>>::run_pass -> CheckResult<()> with CheckResult::new(())
-clarity/src/vm/callables.rs:87: replace NativeHandle::apply -> Result<Value> with Ok(Default::default())
-clarity/src/vm/ast/expression_identifier/mod.rs:58: replace ExpressionIdentifier::run_expression_pass -> ParseResult<()> with ParseResult::new()
-clarity/src/vm/analysis/type_checker/contexts.rs:82: replace TypingContext<'a>::extend -> CheckResult<TypingContext> with CheckResult::new()
-clarity/src/vm/ast/mod.rs:174: replace inner_build_ast -> ParseResult<(ContractAST, Vec<Diagnostic>, bool)> with ParseResult::from((Default::default(), vec![], true))
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:177: replace ContractContext::add_implemented_trait -> CheckResult<()> with CheckResult::from(())
-clarity/src/vm/ast/definition_sorter/mod.rs:324: replace DefinitionSorter::probe_for_dependencies_in_define_args -> ParseResult<()> with ParseResult::new(())
-clarity/src/vm/analysis/type_checker/v2_05/natives/assets.rs:213: replace check_special_burn_asset -> TypeResult with Default::default()
-clarity/src/vm/ast/mod.rs:174: replace inner_build_ast -> ParseResult<(ContractAST, Vec<Diagnostic>, bool)> with ParseResult::from_iter([(Default::default(), vec![Default::default()], false)])
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:195: replace ContractContext::get_nft_type -> Option<&TypeSignature> with Some(&Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:269: replace ContractContext::add_nft -> CheckResult<()> with CheckResult::from(())
-clarity/src/vm/ast/expression_identifier/mod.rs:23: replace inner_relabel -> ParseResult<u64> with ParseResult::new(1)
-clarity/src/vm/types/mod.rs:766: replace BurnBlockInfoProperty::type_result -> TypeSignature with Default::default()
-clarity/src/vm/costs/mod.rs:1092: replace <impl ToSql for ExecutionCost>::to_sql -> rusqlite::Result<ToSqlOutput> with Ok(Default::default())
-clarity/src/vm/functions/conversions.rs:53: replace buff_to_int_generic -> Result<Value> with Ok(Default::default())
-clarity/src/vm/database/clarity_db.rs:355: replace <impl BurnStateDB for NullBurnStateDB>::get_stacks_epoch -> Option<StacksEpoch> with Some(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:259: replace ContractContext::add_ft -> CheckResult<()> with CheckResult::from(())
-clarity/src/vm/functions/conversions.rs:114: replace native_buff_to_uint_be::convert_to_uint_be -> Value with Default::default()
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:297: replace trait_type_size -> CheckResult<u64> with CheckResult::from(0)
-clarity/src/vm/ast/definition_sorter/mod.rs:65: replace DefinitionSorter::run -> ParseResult<()> with ParseResult::from(())
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:612: replace clarity2_inner_type_check_type -> TypeResult with Default::default()
-clarity/src/vm/analysis/read_only_checker/mod.rs:268: replace ReadOnlyChecker<'a, 'b>::try_check_native_function_is_read_only -> Option<CheckResult<bool>> with Some(CheckResult::from(false))
-clarity/src/vm/database/clarity_store.rs:213: replace NullBackingStore::as_clarity_db -> ClarityDatabase with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs:349: replace check_special_len -> TypeResult with Default::default()
-clarity/src/vm/database/key_value_wrapper.rs:229: replace RollbackWrapper<'a>::get_cc_special_cases_handler -> Option<SpecialCaseHandler> with Some(Default::default())
-clarity/src/vm/analysis/type_checker/v2_05/natives/sequences.rs:367: replace check_special_element_at -> TypeResult with Default::default()
-clarity/src/vm/ast/parser/v1.rs:728: replace parse_no_stack_limit -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::new(vec![Default::default()])
-clarity/src/vm/costs/mod.rs:1099: replace <impl FromSql for ExecutionCost>::column_result -> FromSqlResult<ExecutionCost> with FromSqlResult::new(Default::default())
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:79: replace ContractContext::check_function_type -> CheckResult<()> with CheckResult::new(())
-clarity/src/vm/costs/mod.rs:221: replace CostStateSummary::empty -> CostStateSummary with Default::default()
-clarity/src/vm/types/signatures.rs:376: replace <impl TryFrom for BufferLength>::try_from -> Result<BufferLength> with Ok(Default::default())
-clarity/src/vm/ast/parser/v1.rs:508: replace parse_lexed -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::from(vec![Default::default()])
-clarity/src/vm/test_util/mod.rs:220: replace <impl BurnStateDB for UnitTestBurnStateDB>::get_stacks_epoch_by_epoch_id -> Option<StacksEpoch> with Some(Default::default())
-clarity/src/vm/functions/arithmetic.rs:381: replace native_bitwise_not -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
-clarity/src/vm/types/mod.rs:1162: replace Value::expect_result_err -> Value with Default::default()
-clarity/src/vm/functions/arithmetic.rs:41: replace U128Ops::make_value -> InterpreterResult<Value> with InterpreterResult::new()
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:118: replace <impl AnalysisPass for TypeChecker<'_, '_>>::run_pass -> CheckResult<()> with CheckResult::from_iter([()])
-clarity/src/vm/ast/definition_sorter/mod.rs:307: replace DefinitionSorter::probe_for_dependencies_in_tuple -> ParseResult<()> with ParseResult::from(())
-clarity/src/vm/functions/arithmetic.rs:448: replace special_leq_v2 -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
-clarity/src/vm/analysis/read_only_checker/mod.rs:281: replace ReadOnlyChecker<'a, 'b>::check_native_function_is_read_only -> CheckResult<bool> with CheckResult::from(false)
-clarity/src/vm/analysis/type_checker/v2_05/natives/options.rs:378: replace check_special_match -> TypeResult with Default::default()
-clarity/src/vm/analysis/types.rs:163: replace ContractAnalysis::get_public_function_type -> Option<&FunctionType> with Some(&Default::default())
-clarity/src/vm/costs/mod.rs:195: replace <impl From for SerializedCostStateSummary>::from -> SerializedCostStateSummary with Default::default()
-clarity/src/vm/types/signatures.rs:321: replace <impl From for FunctionSignature>::from -> FunctionSignature with Default::default()
-clarity/src/vm/contexts.rs:801: replace OwnedEnvironment<'a, 'hooks>::eval_raw -> Result<(Value, AssetMap, Vec<StacksTransactionEvent>)> with Ok((Default::default(), Default::default(), vec![Default::default()]))
-clarity/src/vm/types/mod.rs:77: replace StandardPrincipalData::transient -> StandardPrincipalData with Default::default()
-clarity/src/vm/ast/parser/v2/mod.rs:158: replace Parser<'a>::peek_last_token -> ParseResult<&PlacedToken> with ParseResult::from(&Default::default())
-clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs:160: replace check_special_merge -> TypeResult with Default::default()
-clarity/src/vm/contexts.rs:1371: replace Environment<'a, 'b, 'hooks>::stx_transfer -> Result<Value> with Ok(Default::default())
-clarity/src/vm/functions/arithmetic.rs:364: replace native_xor -> InterpreterResult<Value> with InterpreterResult::new()
-clarity/src/vm/ast/parser/v1.rs:728: replace parse_no_stack_limit -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::new(vec![])
-clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs:614: replace check_secp256k1_recover -> TypeResult with Default::default()
-clarity/src/vm/functions/assets.rs:676: replace special_transfer_token -> Result<Value> with Ok(Default::default())
-clarity/src/mod.rs:73: replace boot_util::boot_code_id -> QualifiedContractIdentifier with Default::default()
-clarity/src/vm/ast/mod.rs:309: replace build_ast -> ParseResult<ContractAST> with ParseResult::new()
-clarity/src/vm/analysis/read_only_checker/mod.rs:430: replace ReadOnlyChecker<'a, 'b>::check_expression_application_is_read_only -> CheckResult<bool> with CheckResult::from(true)
-clarity/src/vm/types/signatures.rs:1349: replace TypeSignature::construct_parent_list_type -> Result<ListTypeData> with Ok(Default::default())
-clarity/src/vm/analysis/analysis_db.rs:208: replace AnalysisDatabase<'a>::get_implemented_traits -> CheckResult<BTreeSet<TraitIdentifier>> with CheckResult::new(BTreeSet::new())
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:136: replace ContractContext::add_variable_type -> CheckResult<()> with CheckResult::from(())
-clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs:156: replace check_special_fold -> TypeResult with Default::default()
-clarity/src/vm/ast/mod.rs:174: replace inner_build_ast -> ParseResult<(ContractAST, Vec<Diagnostic>, bool)> with ParseResult::from_iter([(Default::default(), vec![], true)])
-clarity/src/vm/functions/arithmetic.rs:52: replace ASCIIOps::make_value -> InterpreterResult<Value> with InterpreterResult::from_iter([Default::default()])
-clarity/src/vm/test_util/mod.rs:57: replace execute -> Value with Default::default()
-clarity/src/vm/ast/parser/v2/mod.rs:283: replace Parser<'a>::handle_open_tuple -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::from(Some(Default::default()))
-clarity/src/vm/ast/parser/v2/mod.rs:1109: replace parse_collect_diagnostics -> (Vec<PreSymbolicExpression>, Vec<Diagnostic>, bool) with (vec![], vec![Default::default()], true)
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:152: replace ContractContext::add_ft -> CheckResult<()> with CheckResult::new(())
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:474: replace Lexer<'a>::read_utf8_encoding -> LexResult<Result<String, String>> with LexResult::new(Ok("xyzzy".into()))
-clarity/src/vm/functions/arithmetic.rs:554: replace native_add -> InterpreterResult<Value> with InterpreterResult::new()
-clarity/src/vm/tests/mod.rs:126: replace env_factory -> MemoryEnvironmentGenerator with Default::default()
-clarity/src/vm/representations.rs:541: replace SymbolicExpression::list -> SymbolicExpression with Default::default()
-clarity/src/vm/database/clarity_db.rs:1279: replace ClarityDatabase<'a>::load_map -> Result<DataMapMetadata> with Ok(Default::default())
-clarity/src/vm/ast/parser/v2/mod.rs:807: replace Parser<'a>::parse_node -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::from_iter([Some(Default::default())])
-clarity/src/vm/analysis/analysis_db.rs:137: replace AnalysisDatabase<'a>::get_clarity_version -> CheckResult<ClarityVersion> with CheckResult::from_iter([Default::default()])
-clarity/src/vm/functions/arithmetic.rs:546: replace special_less -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
-clarity/src/vm/analysis/read_only_checker/mod.rs:244: replace ReadOnlyChecker<'a, 'b>::check_each_expression_is_read_only -> CheckResult<bool> with CheckResult::from(false)
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:152: replace ContractContext::add_ft -> CheckResult<()> with CheckResult::from(())
-clarity/src/vm/errors.rs:169: replace <impl From for Error>::from -> Self with Default::default()
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:140: replace Lexer<'a>::read_line -> LexResult<String> with LexResult::from_iter(["xyzzy".into()])
-clarity/src/vm/ast/parser/v1.rs:455: replace lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::new(vec![(Default::default(), 1, 1)])
-clarity/src/vm/analysis/type_checker/mod.rs:45: replace FunctionType::check_args -> CheckResult<TypeSignature> with CheckResult::new()
-clarity/src/vm/analysis/type_checker/v2_1/natives/options.rs:381: replace check_special_match -> TypeResult with Default::default()
-clarity/src/vm/ast/traits_resolver/mod.rs:201: replace TraitsResolver::probe_for_generics -> ParseResult<()> with ParseResult::new()
-clarity/src/vm/ast/parser/v1.rs:455: replace lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::new(vec![(Default::default(), 0, 1)])
-clarity/src/vm/analysis/analysis_db.rs:171: replace AnalysisDatabase<'a>::get_read_only_function_type -> CheckResult<Option<FunctionType>> with CheckResult::from(Some(Default::default()))
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:66: replace Lexer<'a>::add_diagnostic -> LexResult<()> with LexResult::new(())
-clarity/src/vm/database/clarity_db.rs:472: replace ClarityDatabase<'a>::get -> Option<T> with Some(Default::default())
-clarity/src/vm/types/signatures.rs:978: replace TypeSignature::max_string_ascii -> TypeSignature with Default::default()
-clarity/src/vm/types/mod.rs:96: replace QualifiedContractIdentifier::local -> Result<QualifiedContractIdentifier> with Ok(Default::default())
-clarity/src/vm/types/mod.rs:1227: replace ASCIIData::len -> BufferLength with Default::default()
-clarity/src/vm/ast/mod.rs:103: replace build_ast_with_rules -> ParseResult<ContractAST> with ParseResult::new(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:308: replace ContractContext::get_map_type -> Option<&(TypeSignature, TypeSignature)> with Some(&(Default::default(), Default::default()))
-clarity/src/vm/types/serialization.rs:535: replace Value::deserialize_read_count -> Result<(Value, u64), SerializationError> with Ok((Default::default(), 1))
-clarity/src/vm/representations.rs:320: replace PreSymbolicExpression::list -> PreSymbolicExpression with Default::default()
-clarity/src/vm/ast/parser/v1.rs:192: replace inner_lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::from_iter([vec![(Default::default(), 0, 1)]])
-clarity/src/vm/ast/parser/v1.rs:508: replace parse_lexed -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::new(vec![])
-clarity/src/vm/ast/stack_depth_checker.rs:74: replace <impl BuildASTPass for VaryStackDepthChecker>::run_pass -> ParseResult<()> with ParseResult::new()
-clarity/src/vm/database/clarity_store.rs:193: replace <impl ClarityDeserializable for ContractCommitment>::deserialize -> ContractCommitment with Default::default()
-clarity/src/vm/analysis/type_checker/v2_05/natives/assets.rs:167: replace check_special_transfer_token -> TypeResult with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1398: replace TypeChecker<'a, 'b>::type_check_define_trait -> CheckResult<(ClarityName, BTreeMap<ClarityName, FunctionSignature>)> with CheckResult::new((Default::default(), BTreeMap::new()))
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:140: replace Lexer<'a>::read_line -> LexResult<String> with LexResult::from_iter([String::new()])
-clarity/src/vm/analysis/read_only_checker/mod.rs:268: replace ReadOnlyChecker<'a, 'b>::try_check_native_function_is_read_only -> Option<CheckResult<bool>> with Some(CheckResult::new(false))
-clarity/src/vm/functions/arithmetic.rs:546: replace special_less -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
-clarity/src/vm/costs/mod.rs:136: replace <impl CostTracker for ()>::compute_cost -> std::result::Result<ExecutionCost, CostErrors> with Ok(Default::default())
-clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs:134: replace check_special_get -> TypeResult with Default::default()
-clarity/src/vm/ast/parser/v1.rs:192: replace inner_lex -> ParseResult<Vec<(LexItem, u32, u32)>> with ParseResult::new(vec![(Default::default(), 1, 0)])
-clarity/src/vm/functions/conversions.rs:185: replace native_int_to_string_generic -> Result<Value> with Ok(Default::default())
-clarity/src/vm/ast/traits_resolver/mod.rs:48: replace TraitsResolver::run -> ParseResult<()> with ParseResult::new()
-clarity/src/vm/functions/database.rs:374: replace special_fetch_entry_v200 -> Result<Value> with Ok(Default::default())
-clarity/src/vm/analysis/type_checker/v2_05/natives/sequences.rs:39: replace get_simple_native_or_user_define -> CheckResult<FunctionType> with CheckResult::new(Default::default())
-clarity/src/vm/database/structures.rs:368: replace STXBalanceSnapshot<'db, 'conn>::canonical_balance_repr -> STXBalance with Default::default()
-clarity/src/vm/analysis/read_only_checker/mod.rs:112: replace ReadOnlyChecker<'a, 'b>::check_top_level_expression -> CheckResult<()> with CheckResult::from(())
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:808: replace TypeChecker<'a, 'b>::try_type_check_define -> CheckResult<Option<()>> with CheckResult::new(None)
-clarity/src/vm/analysis/mod.rs:50: replace mem_type_check -> CheckResult<(Option<TypeSignature>, ContractAnalysis)> with CheckResult::from((Some(Default::default()), Default::default()))
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:116: replace ContractContext::add_private_function_type -> CheckResult<()> with CheckResult::new(())
-clarity/src/vm/functions/assets.rs:193: replace special_stx_transfer_memo -> Result<Value> with Ok(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/natives/options.rs:281: replace eval_with_new_binding -> TypeResult with Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs:448: replace check_special_replace_at -> TypeResult with Default::default()
-clarity/src/vm/ast/parser/v2/mod.rs:807: replace Parser<'a>::parse_node -> ParseResult<Option<PreSymbolicExpression>> with ParseResult::from(None)
-clarity/src/vm/analysis/analysis_db.rs:153: replace AnalysisDatabase<'a>::get_public_function_type -> CheckResult<Option<FunctionType>> with CheckResult::from(None)
-clarity/src/vm/database/key_value_wrapper.rs:338: replace RollbackWrapper<'a>::set_block_hash -> InterpreterResult<StacksBlockId> with InterpreterResult::from(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1039: replace TypeChecker<'a, 'b>::type_check_function_type -> TypeResult with Default::default()
-clarity/src/vm/analysis/analysis_db.rs:153: replace AnalysisDatabase<'a>::get_public_function_type -> CheckResult<Option<FunctionType>> with CheckResult::new(None)
-clarity/src/vm/contexts.rs:652: replace OwnedEnvironment<'a, 'hooks>::execute_in_env -> std::result::Result<(A, AssetMap, Vec<StacksTransactionEvent>), E> with Ok((Default::default(), Default::default(), vec![Default::default()]))
-clarity/src/vm/functions/assets.rs:809: replace special_get_owner_v200 -> Result<Value> with Ok(Default::default())
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:210: replace Lexer<'a>::read_identifier -> LexResult<Token> with LexResult::from(Default::default())
-clarity/src/vm/functions/arithmetic.rs:381: replace native_bitwise_not -> InterpreterResult<Value> with InterpreterResult::from(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:62: replace TraitContext::add_defined_trait -> CheckResult<()> with CheckResult::new(())
-clarity/src/vm/contexts.rs:490: replace AssetMap::get_nonfungible_tokens -> Option<&Vec<Value>> with Some(&vec![Default::default()])
-clarity/src/vm/ast/mod.rs:87: replace ast_check_size -> ParseResult<ContractAST> with ParseResult::new()
-clarity/src/vm/types/mod.rs:951: replace Value::buff_from_byte -> Value with Default::default()
-clarity/src/vm/types/signatures.rs:498: replace TypeSignature::new_response -> Result<TypeSignature> with Ok(Default::default())
-clarity/src/vm/analysis/read_only_checker/mod.rs:268: replace ReadOnlyChecker<'a, 'b>::try_check_native_function_is_read_only -> Option<CheckResult<bool>> with Some(CheckResult::from_iter([false]))
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:247: replace FunctionType::check_args_by_allowing_trait_cast_2_05 -> CheckResult<TypeSignature> with CheckResult::from_iter([Default::default()])
-clarity/src/vm/ast/traits_resolver/mod.rs:182: replace TraitsResolver::try_parse_pre_expr -> Option<(DefineFunctions, Vec<&'a PreSymbolicExpression>)> with Some((Default::default(), vec![]))
-clarity/src/vm/functions/assets.rs:894: replace special_get_token_supply -> Result<Value> with Ok(Default::default())
-clarity/src/vm/ast/parser/v2/mod.rs:687: replace Parser<'a>::read_sugared_principal -> ParseResult<PreSymbolicExpression> with ParseResult::from(Default::default())
-clarity/src/vm/analysis/type_checker/v2_1/mod.rs:1055: replace TypeChecker<'a, 'b>::type_check_define_function -> CheckResult<(ClarityName, FixedFunction)> with CheckResult::from((Default::default(), Default::default()))
-clarity/src/vm/functions/arithmetic.rs:59: replace UTF8Ops::make_value -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
-clarity/src/vm/database/clarity_db.rs:209: replace <impl BurnStateDB for &dyn BurnStateDB>::get_sortition_id_from_consensus_hash -> Option<SortitionId> with Some(Default::default())
-clarity/src/vm/functions/assets.rs:98: replace special_stx_balance -> Result<Value> with Ok(Default::default())
-clarity/src/vm/ast/parser/v2/mod.rs:521: replace Parser<'a>::read_principal -> ParseResult<PreSymbolicExpression> with ParseResult::from_iter([Default::default()])
-clarity/src/vm/analysis/type_checker/v2_05/contexts.rs:106: replace ContractContext::add_read_only_function_type -> CheckResult<()> with CheckResult::from(())
-clarity/src/vm/database/clarity_db.rs:1957: replace ClarityDatabase<'a>::get_stacks_epoch -> Option<StacksEpoch> with Some(Default::default())
-clarity/src/vm/functions/conversions.rs:113: replace native_buff_to_uint_be -> Result<Value> with Ok(Default::default())
-clarity/src/vm/analysis/read_only_checker/mod.rs:430: replace ReadOnlyChecker<'a, 'b>::check_expression_application_is_read_only -> CheckResult<bool> with CheckResult::from_iter([false])
-clarity/src/vm/variables.rs:63: replace lookup_reserved_variable -> Result<Option<Value>> with Ok(Some(Default::default()))
-clarity/src/vm/database/clarity_store.rs:235: replace <impl ClarityBackingStore for NullBackingStore>::get_side_store -> &Connection with &Default::default()
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:292: replace ContractContext::add_used_trait -> CheckResult<()> with CheckResult::new()
-clarity/src/vm/types/signatures.rs:1417: replace TypeSignature::parse_buff_type_repr -> Result<TypeSignature> with Ok(Default::default())
-clarity/src/vm/types/serialization.rs:1127: replace Value::try_deserialize_bytes_untyped -> Result<Value, SerializationError> with Ok(Default::default())
-clarity/src/vm/analysis/types.rs:190: replace ContractAnalysis::get_defined_trait -> Option<&BTreeMap<ClarityName, FunctionSignature>> with Some(&BTreeMap::new())
-clarity/src/vm/analysis/type_checker/v2_05/mod.rs:808: replace TypeChecker<'a, 'b>::try_type_check_define -> CheckResult<Option<()>> with CheckResult::from_iter([Some(())])
-clarity/src/vm/ast/mod.rs:69: replace parse_in_epoch -> ParseResult<Vec<PreSymbolicExpression>> with ParseResult::new()
-clarity/src/vm/types/signatures.rs:966: replace TypeSignature::min_string_ascii -> TypeSignature with Default::default()
-clarity/src/vm/analysis/type_checker/v2_05/natives/options.rs:32: replace check_special_okay -> TypeResult with Default::default()
-clarity/src/vm/functions/arithmetic.rs:52: replace ASCIIOps::make_value -> InterpreterResult<Value> with InterpreterResult::new(Default::default())
-clarity/src/vm/functions/arithmetic.rs:377: replace native_bitwise_or -> InterpreterResult<Value> with InterpreterResult::new()
-clarity/src/vm/ast/expression_identifier/mod.rs:23: replace inner_relabel -> ParseResult<u64> with ParseResult::from(1)
-clarity/src/vm/database/clarity_db.rs:937: replace ClarityDatabase<'a>::get_pox_payout_addrs_for_burnchain_height -> Option<(Vec<TupleData>, u128)> with Some((vec![Default::default()], 0))
-clarity/src/vm/analysis/type_checker/v2_1/contexts.rs:269: replace ContractContext::add_nft -> CheckResult<()> with CheckResult::new()
-clarity/src/vm/ast/parser/v2/lexer/mod.rs:575: replace Lexer<'a>::read_utf8_string -> LexResult<Token> with LexResult::from_iter([Default::default()])
diff --git a/mutation-testing/packages-output/pox-locking/caught.txt b/mutation-testing/packages-output/pox-locking/caught.txt
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/mutation-testing/packages-output/pox-locking/missed.txt b/mutation-testing/packages-output/pox-locking/missed.txt
deleted file mode 100644
index 1151cd78b6..0000000000
--- a/mutation-testing/packages-output/pox-locking/missed.txt
+++ /dev/null
@@ -1,28 +0,0 @@
-pox-locking/src/pox_1.rs:90: replace pox_lock_v1 -> Result<(), LockingError> with Ok(())
-pox-locking/src/pox_3.rs:355: replace handle_contract_call -> Result<(), ClarityError> with Ok(())
-pox-locking/src/pox_2.rs:217: replace pox_lock_extend_v2 -> Result<u128, LockingError> with Ok(0)
-pox-locking/src/pox_2.rs:33: replace is_read_only -> bool with true
-pox-locking/src/pox_3.rs:292: replace handle_stack_lockup_increase_pox_v3 -> Result<Option<StacksTransactionEvent>, ClarityError> with Ok(None)
-pox-locking/src/pox_1.rs:69: replace is_read_only -> bool with true
-pox-locking/src/pox_1.rs:128: replace handle_contract_call -> Result<(), ClarityError> with Ok(())
-pox-locking/src/pox_2.rs:473: replace handle_contract_call -> Result<(), ClarityError> with Ok(())
-pox-locking/src/events.rs:76: replace create_event_info_aggregation_code -> String with String::new()
-pox-locking/src/pox_2.rs:345: replace handle_stack_lockup_extension_pox_v2 -> Result<Option<StacksTransactionEvent>, ClarityError> with Ok(None)
-pox-locking/src/pox_2.rs:409: replace handle_stack_lockup_increase_pox_v2 -> Result<Option<StacksTransactionEvent>, ClarityError> with Ok(None)
-pox-locking/src/pox_2.rs:217: replace pox_lock_extend_v2 -> Result<u128, LockingError> with Ok(1)
-pox-locking/src/events.rs:103: replace create_event_info_data_code -> String with String::new()
-pox-locking/src/pox_3.rs:79: replace pox_lock_extend_v3 -> Result<u128, LockingError> with Ok(0)
-pox-locking/src/pox_2.rs:280: replace handle_stack_lockup_pox_v2 -> Result<Option<StacksTransactionEvent>, ClarityError> with Ok(None)
-pox-locking/src/events.rs:47: replace create_event_info_stack_or_delegate_code -> String with "xyzzy".into()
-pox-locking/src/events.rs:76: replace create_event_info_aggregation_code -> String with "xyzzy".into()
-pox-locking/src/pox_3.rs:161: replace handle_stack_lockup_pox_v3 -> Result<Option<StacksTransactionEvent>, ClarityError> with Ok(None)
-pox-locking/src/events.rs:351: replace synthesize_pox_2_or_3_event_info -> Result<Option<Value>, ClarityError> with Ok(None)
-pox-locking/src/pox_3.rs:42: replace pox_lock_v3 -> Result<(), LockingError> with Ok(())
-pox-locking/src/pox_1.rs:69: replace is_read_only -> bool with false
-pox-locking/src/events.rs:103: replace create_event_info_data_code -> String with "xyzzy".into()
-pox-locking/src/pox_3.rs:228: replace handle_stack_lockup_extension_pox_v3 -> Result<Option<StacksTransactionEvent>, ClarityError> with Ok(None)
-pox-locking/src/pox_2.rs:248: replace pox_lock_v2 -> Result<(), LockingError> with Ok(())
-pox-locking/src/pox_3.rs:79: replace pox_lock_extend_v3 -> Result<u128, LockingError> with Ok(1)
-pox-locking/src/pox_2.rs:33: replace is_read_only -> bool with false
-pox-locking/src/lib.rs:65: replace handle_contract_call_special_cases -> Result<(), ClarityError> with Ok(())
-pox-locking/src/events.rs:47: replace create_event_info_stack_or_delegate_code -> String with String::new()
diff --git a/mutation-testing/packages-output/pox-locking/timeout.txt b/mutation-testing/packages-output/pox-locking/timeout.txt
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/mutation-testing/packages-output/pox-locking/unviable.txt b/mutation-testing/packages-output/pox-locking/unviable.txt
deleted file mode 100644
index 5d9b53f3eb..0000000000
--- a/mutation-testing/packages-output/pox-locking/unviable.txt
+++ /dev/null
@@ -1,22 +0,0 @@
-pox-locking/src/pox_2.rs:127: replace parse_pox_increase -> std::result::Result<(PrincipalData, u128), i128> with Ok((Default::default(), 1))
-pox-locking/src/pox_2.rs:164: replace pox_lock_increase_v2 -> Result<STXBalance, LockingError> with Ok(Default::default())
-pox-locking/src/pox_2.rs:64: replace parse_pox_stacking_result -> std::result::Result<(PrincipalData, u128, u64), i128> with Ok((Default::default(), 1, 1))
-pox-locking/src/pox_3.rs:228: replace handle_stack_lockup_extension_pox_v3 -> Result<Option<StacksTransactionEvent>, ClarityError> with Ok(Some(Default::default()))
-pox-locking/src/pox_3.rs:115: replace pox_lock_increase_v3 -> Result<STXBalance, LockingError> with Ok(Default::default())
-pox-locking/src/pox_1.rs:36: replace parse_pox_stacking_result_v1 -> std::result::Result<(PrincipalData, u128, u64), i128> with Ok((Default::default(), 0, 0))
-pox-locking/src/pox_2.rs:409: replace handle_stack_lockup_increase_pox_v2 -> Result<Option<StacksTransactionEvent>, ClarityError> with Ok(Some(Default::default()))
-pox-locking/src/pox_2.rs:64: replace parse_pox_stacking_result -> std::result::Result<(PrincipalData, u128, u64), i128> with Ok((Default::default(), 1, 0))
-pox-locking/src/pox_2.rs:127: replace parse_pox_increase -> std::result::Result<(PrincipalData, u128), i128> with Ok((Default::default(), 0))
-pox-locking/src/pox_3.rs:161: replace handle_stack_lockup_pox_v3 -> Result<Option<StacksTransactionEvent>, ClarityError> with Ok(Some(Default::default()))
-pox-locking/src/pox_2.rs:345: replace handle_stack_lockup_extension_pox_v2 -> Result<Option<StacksTransactionEvent>, ClarityError> with Ok(Some(Default::default()))
-pox-locking/src/events.rs:351: replace synthesize_pox_2_or_3_event_info -> Result<Option<Value>, ClarityError> with Ok(Some(Default::default()))
-pox-locking/src/pox_2.rs:280: replace handle_stack_lockup_pox_v2 -> Result<Option<StacksTransactionEvent>, ClarityError> with Ok(Some(Default::default()))
-pox-locking/src/pox_3.rs:292: replace handle_stack_lockup_increase_pox_v3 -> Result<Option<StacksTransactionEvent>, ClarityError> with Ok(Some(Default::default()))
-pox-locking/src/pox_2.rs:64: replace parse_pox_stacking_result -> std::result::Result<(PrincipalData, u128, u64), i128> with Ok((Default::default(), 0, 0))
-pox-locking/src/pox_2.rs:64: replace parse_pox_stacking_result -> std::result::Result<(PrincipalData, u128, u64), i128> with Ok((Default::default(), 0, 1))
-pox-locking/src/pox_1.rs:36: replace parse_pox_stacking_result_v1 -> std::result::Result<(PrincipalData, u128, u64), i128> with Ok((Default::default(), 1, 1))
-pox-locking/src/pox_1.rs:36: replace parse_pox_stacking_result_v1 -> std::result::Result<(PrincipalData, u128, u64), i128> with Ok((Default::default(), 1, 0))
-pox-locking/src/events.rs:32: replace get_stacker -> Value with Default::default()
-pox-locking/src/pox_1.rs:36: replace parse_pox_stacking_result_v1 -> std::result::Result<(PrincipalData, u128, u64), i128> with Ok((Default::default(), 0, 1))
-pox-locking/src/pox_2.rs:98: replace parse_pox_extend_result -> std::result::Result<(PrincipalData, u64), i128> with Ok((Default::default(), 1))
-pox-locking/src/pox_2.rs:98: replace parse_pox_extend_result -> std::result::Result<(PrincipalData, u64), i128> with Ok((Default::default(), 0))
diff --git a/mutation-testing/packages-output/stx-genesis/caught.txt b/mutation-testing/packages-output/stx-genesis/caught.txt
deleted file mode 100644
index 26e704cf83..0000000000
--- a/mutation-testing/packages-output/stx-genesis/caught.txt
+++ /dev/null
@@ -1 +0,0 @@
-stx-genesis/src/lib.rs:100: replace <impl Iterator for LinePairReader>::next -> Option<Self::Item> with Some(Default::default())
diff --git a/mutation-testing/packages-output/stx-genesis/missed.txt b/mutation-testing/packages-output/stx-genesis/missed.txt
deleted file mode 100644
index d5f5500801..0000000000
--- a/mutation-testing/packages-output/stx-genesis/missed.txt
+++ /dev/null
@@ -1 +0,0 @@
-stx-genesis/src/lib.rs:100: replace <impl Iterator for LinePairReader>::next -> Option<Self::Item> with None
diff --git a/mutation-testing/packages-output/stx-genesis/timeout.txt b/mutation-testing/packages-output/stx-genesis/timeout.txt
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/mutation-testing/packages-output/stx-genesis/unviable.txt b/mutation-testing/packages-output/stx-genesis/unviable.txt
deleted file mode 100644
index 7c35ac7a7f..0000000000
--- a/mutation-testing/packages-output/stx-genesis/unviable.txt
+++ /dev/null
@@ -1,11 +0,0 @@
-stx-genesis/src/lib.rs:167: replace read_names -> Box<dyn Iterator<Item = GenesisName>> with Box::new(Default::default())
-stx-genesis/src/lib.rs:136: replace read_balances -> Box<dyn Iterator<Item = GenesisAccountBalance>> with Box::new(Default::default())
-stx-genesis/src/lib.rs:125: replace iter_deflated_csv -> Box<dyn Iterator<Item = Vec<String>>> with Box::new(Default::default())
-stx-genesis/src/lib.rs:111: replace read_deflated_zonefiles -> Box<dyn Iterator<Item = GenesisZonefile>> with Box::new(Default::default())
-stx-genesis/src/lib.rs:153: replace read_namespaces -> Box<dyn Iterator<Item = GenesisNamespace>> with Box::new(Default::default())
-stx-genesis/src/lib.rs:57: replace GenesisData::read_balances -> Box<dyn Iterator<Item = GenesisAccountBalance>> with Box::new(Default::default())
-stx-genesis/src/lib.rs:64: replace GenesisData::read_lockups -> Box<dyn Iterator<Item = GenesisAccountLockup>> with Box::new(Default::default())
-stx-genesis/src/lib.rs:78: replace GenesisData::read_names -> Box<dyn Iterator<Item = GenesisName>> with Box::new(Default::default())
-stx-genesis/src/lib.rs:144: replace read_lockups -> Box<dyn Iterator<Item = GenesisAccountLockup>> with Box::new(Default::default())
-stx-genesis/src/lib.rs:71: replace GenesisData::read_namespaces -> Box<dyn Iterator<Item = GenesisNamespace>> with Box::new(Default::default())
-stx-genesis/src/lib.rs:85: replace GenesisData::read_name_zonefiles -> Box<dyn Iterator<Item = GenesisZonefile>> with Box::new(Default::default())
diff --git a/mutation-testing/scripts/README.md b/mutation-testing/scripts/README.md
deleted file mode 100644
index 66a0efb4cf..0000000000
--- a/mutation-testing/scripts/README.md
+++ /dev/null
@@ -1,38 +0,0 @@
-## steps to reproduce working version with different number lines:
-
-in trials/mutants-stable/caught.txt replace line number 23 with 109
-the append.sh won't work anymore
-the append-match.sh works
-
-```bash
-sh append-match.sh
-
-```
-
-example run:
-
-```bash
-./modular-mutants-run.sh stx-genesis lib.rs test_this init_ next as.rs ab cd ef clarity lib.rs stacks-node
-# the command above makes and runs 579 mutants on these regex matches:
-
-# functions named 'test_this', 'init_' and 'next' (everything that starts with any of the given names) from 'lib.rs' file of 'stx-genesis' package (5 mutants)
-stx-genesis/[^/]+/lib.rs.*(?:test_this|init_|next).*->
-
-# functions that start with 'ab', 'cd' or 'ef' from files named 'as.rs' of 'stx-genesis' package (0 mutants)
-stx-genesis/[^/]+/as.rs.*(?:ab|cd|ef).*->
-
-# all functions from 'lib.rs' files of the 'clarity' package (4 mutants)
-clarity/[^/]+/lib.rs.*(?:).*->
-
-# all functions from all files of 'stacks-node' package (570 mutants)
-stacks-node/[^/]+/.*(?:).*->
-```
-
-# Create Stable
-
-Only run it once and the packages that should be updated from zero. Then it will be the reference point for the upcoming PRs that modify these functions
-
-### recap flow for a developer which
-
-1. works on functions and modifies them
-2. before commiting -> `call git-diff.sh`
diff --git a/mutation-testing/scripts/append-match-package.sh b/mutation-testing/scripts/append-match-package.sh
deleted file mode 100644
index 9026cfc563..0000000000
--- a/mutation-testing/scripts/append-match-package.sh
+++ /dev/null
@@ -1,68 +0,0 @@
-#!/bin/bash
-
-# the append-match-package.sh
-## goes through each line in the output and based on the package ( first element before /)
-### verifies the line with the other lines in that specific folder
-#### in our case folder_name == package_name
-
-
-# goes through each PR file line by line
-# for each first_element/the_rest_of_the_line goes through it
-## search in that specific folder on all 4 files
-## if it is matchy, remove it from that file
-## based on the file it was taken from, append it to the same file in the STABLE folder
-
-
-PR_FOLDER="../temp/mutants.out"
-STABLE_FOLDER_PARENT="../packages-output"
-FILES=("caught.txt" "missed.txt" "timeout.txt" "unviable.txt")
-
-echo "Starting script..."
-echo "PR Folder: $PR_FOLDER"
-echo "STABLE Folder: $STABLE_FOLDER_PARENT"
-echo "Files to process: ${FILES[*]}"
-
-# Iterate over the specified files
-for file in "${FILES[@]}"; do
-    pr_file="$PR_FOLDER/$file"
-
-    echo "Processing file: $file"
-
-    # Check if PR file exists and is not empty
-    if [[ -s "$pr_file" ]]; then
-        # Read each line from the PR file
-        while IFS= read -r line; do
-            echo "Reading line from PR file: $line"
-
-            # Extract the package from which the line is coming from
-            local_package=${line%%/*}
-
-            # Extract the after the number line without the line number and escape it for awk
-            # Escape the variables for use in a sed pattern
-            var_1=$(echo "$line" | sed -E 's/^(.+):[0-9]+:[^:]+/\1/')
-            escaped_var_1=$(sed 's/[][/.^$]/\\&/g' <<< "$var_1")
-
-            var_2=$(echo "$line" | sed -E 's/^[^:]+:[0-9]+:(.+)/\1/')
-            escaped_var_2=$(sed 's/[][/.^$]/\\&/g' <<< "$var_2")
-
-            regex="${escaped_var_1}.*${escaped_var_2}"
-
-            # Iterate over each file in the STABLE folder combined with local_package
-            for target_file in "${FILES[@]}"; do
-                target_path="$STABLE_FOLDER_PARENT/$local_package/$target_file"
-                echo "Checking against STABLE file: $target_path"
-
-                # Use sed to remove lines matching the pattern
-                sed "/$regex/d" "$target_path" > temp_file && mv temp_file "$target_path"
-            done
-
-            # Append PR line to the corresponding package and file
-            echo "$line" >> "$STABLE_FOLDER_PARENT/$local_package/$file"
-            
-        done < "$pr_file"
-    else
-        echo "PR file $pr_file is empty or does not exist, skipping..."
-    fi
-done
-
-echo "Script completed."
diff --git a/mutation-testing/scripts/create-stable.sh b/mutation-testing/scripts/create-stable.sh
deleted file mode 100644
index 1659714ed0..0000000000
--- a/mutation-testing/scripts/create-stable.sh
+++ /dev/null
@@ -1,55 +0,0 @@
-# for specific packages creates the outpup
-
-# removes everything except .txt files
-
-#!/bin/bash
-
-# moves to mutation-testing folder
-cd ../packages-output
-
-### Run mutation testing on the packages uncommented
-
-# Run mutation testing for stx-genesis package
-cargo mutants --package stx-genesis --output stx-genesis
-mv stx-genesis/mutants.out/*.txt stx-genesis/
-rm -rf stx-genesis/mutants.out
-
-# Run mutation testing for pox-locking package
-cargo mutants --package pox-locking --output pox-locking
-mv pox-locking/mutants.out/*.txt pox-locking/
-rm -rf pox-locking/mutants.out
-
-# # Run mutation testing for libsigner package
-# cargo mutants --package libsigner --output libsigner
-# mv libsigner/mutants.out/*.txt libsigner/
-# rm -rf libsigner/mutants.out
-
-# # Run mutation testing for libstackerdb package
-# cargo mutants --package libstackerdb --output libstackerdb
-# mv libstackerdb/mutants.out/*.txt libstackerdb/
-# rm -rf libstackerdb/mutants.out
-
-# # Run mutation testing for stacks-common package
-# cargo mutants --package stacks-common --output stacks-common
-# mv stacks-common/mutants.out/*.txt stacks-common/
-# rm -rf stacks-common/mutants.out
-
-# # Run mutation testing for clarity package
-# cargo mutants --package clarity --output clarity
-# mv clarity/mutants.out/*.txt clarity/
-# rm -rf clarity/mutants.out
-
-# Run mutation testing for stacks-signer package - working, 10 min approx. 
-# cargo mutants --package stacks-signer --output stacks-signer
-# mv stacks-signer/mutants.out/*.txt stacks-signer/
-# rm -rf stacks-signer/mutants.out
-
-# Commented out mutation testing for stacks-node package due to test errors and long compile/testing time
-# cargo mutants --package stacks-node --output stacks-node
-# mv stacks-node/mutants.out/*.txt stacks-node/
-# rm -rf stacks-node/mutants.out
-
-# Commented out mutation testing for stackslib package due to long compile/testing time
-# cargo mutants --package stackslib --output stackslib
-# mv stackslib/mutants.out/*.txt stackslib/
-# rm -rf stackslib/mutants.out
\ No newline at end of file
diff --git a/mutation-testing/scripts/git-diff.sh b/mutation-testing/scripts/git-diff.sh
deleted file mode 100755
index 256db10290..0000000000
--- a/mutation-testing/scripts/git-diff.sh
+++ /dev/null
@@ -1,35 +0,0 @@
-# script that makes .git for the differences
-# it saves the .git on scripts folder
-
-# add untracked files to git diff
-# go to root folder
-cd ./../..
-
-# run git status on root
-untracked_files=($(git ls-files --others --exclude-standard))
-
-# for each file untracked -> run git add file path
-echo "${untracked_files[@]}"
-for file in "${untracked_files[@]}"; do
-  git add -N "$file"
-done
-
-cd mutation-testing
-
-
-# run from mutation-testing folder
-git diff > git.diff
-
-# it runs cargo mutants for those specific changed functions and outputs to /temp/mutants.out
-# for faster builds: increase number to 4 if at least 16 gb ram and 6 cores CPU
-cargo mutants --no-shuffle -j 2 -vV --in-diff git.diff --output temp/
-
-# go to scripts folder level
-cd scripts
-
-# call append-match-package.sh to update the content from the stable output
-sh append-match-package.sh
-
-# removes extra files
-rm -rf ../git.diff
-rm -rf ../temp
diff --git a/mutation-testing/scripts/modular-mutants-run.sh b/mutation-testing/scripts/modular-mutants-run.sh
deleted file mode 100644
index c8bc357e09..0000000000
--- a/mutation-testing/scripts/modular-mutants-run.sh
+++ /dev/null
@@ -1,41 +0,0 @@
-#!/bin/bash
-
-packages=$(cargo tree --workspace --prefix depth | grep "^0" | cut -c2- | awk '{print $1}')
-regex_list=()
-
-while [ $# -gt 0 ]; do
-  arg=$1
-
-  if [[ $packages == *$arg* ]]; then
-    package=$arg
-    file=""
-    shift
-    arg=$1
-  fi
-  if [[ $arg == *.rs ]]; then
-    file=$arg
-    shift
-    arg=$1
-  fi
-
-  functions=()
-  while [ $# -gt 0 ] && [[ $1 != *.rs ]] && [[ $packages != *$1* ]]; do
-    functions+=("$1")
-    shift
-  done
-
-  IFS="|"
-  functions_str="${functions[*]}"
-  IFS=""
-
-  regex="${package}/[^/]+/${file}.*?(?:${functions_str})[^-()]*(?:->|\(\))"
-  regex_list+=("$regex")
-done
-
-command="cargo mutants -vV --no-shuffle"
-
-for regex in "${regex_list[@]}"; do
-  command+=" -F \"$regex\""
-done
-
-eval "$command"
\ No newline at end of file
diff --git a/mutation-testing/testing.md b/mutation-testing/testing.md
deleted file mode 100644
index 28c885b0df..0000000000
--- a/mutation-testing/testing.md
+++ /dev/null
@@ -1,65 +0,0 @@
-# Mutation Testing
-
-### What is mutation testing and how does it work?
-
-Mutation testing is a technique of evaluating the effectiveness of a series of tests by introducing small changes to the code (mutations) and checking if the tests can detect these small changes.
-Cargo-mutants is an external library installed to cargo, through which you can run mutants on the code, and it consists of:
-
-- Building and testing the baseline code (no mutations).
-- If the previous step fails, no mutants are applied, since the base code fails. Otherwise, copy the code to another location, apply mutations and then run `cargo build` and `cargo test` commands for each mutation.
-
-### Install and run
-
-In order to install cargo-mutants crate:
-
-```
-cargo install --locked cargo-mutants
-```
-
-In order to run mutated tests:
-
-```bash
-# In the whole workspace
-cargo mutants
-# Only in the 'clarity' package
-cargo mutants --package clarity
-# In files named 'signatures.rs' from the whole workspace
-cargo mutants -f signatures.rs
-# Only in files named 'signatures.rs' only from the 'clarity' package
-cargo mutants --package clarity -f signatures.rs
-# From all files except the ones named 'signatures.rs' and 'lib.rs' from the whole workspace
-cargo mutants -e signatures.rs -e lib.rs
-# Output from 'clarity' package to a specific directory in the workspace
-cargo mutants --package clarity --output mutants/clarity
-# To list all the possible mutants
-cargo mutants --list
-# To list all the files with possible mutants:
-cargo mutants --list-files
-```
-
-In order to exclude a function from being mutated, parse the `#[mutants::skip]` attribute above it.
-
-### Reading the output
-
-There are 2 places where the progress of mutations are shown: terminal and [output folders](https://mutants.rs/mutants-out.html).
-The terminal shows information about the progress of the mutants:
-
-- How many mutants out of the total were tested (`1274/2912 mutants tested, 44% done`).
-- Mutants status so far (`280 missed, 209 caught, 799 unviable`).
-- Time elapsed and remaining (`141:36 elapsed, about 168 min remaining`).
-- Tests missed so far (`clarity/src/vm/database/key_value_wrapper.rs:77: replace rollback_value_check with () ... NOT CAUGHT in 22.8s build + 17.2s test`).
-- Current job (`clarity/src/vm/ast/parser/v2/mod.rs:167: replace Parser<'a>::skip_to_end with () ... 2.1s build`)
-
-`mutants.out` - This is the folder where the mutants test output is written, and is composed of:
-
-- log - The folder of the command log, here you can find the output of the cargo build and cargo test commands for every mutation.
-- caught.txt - The file where caught mutations are logged (`clarity/src/vm/types/mod.rs:871: replace Value::size -> u32 with 1`).
-- debug.log - The output of the cargo mutants command.
-- lock.json - A file with fs2 lock on it in order to prevent 2 jobs from writing to the same directory at the same time, containing runtime information (cargo mutants version, start time, hostname, username).
-- missed.txt - Missed mutations - mutations that are successful at cargo build, not detected in tests (`clarity/src/vm/types/signatures.rs:1766: replace TupleTypeSignature::size -> u32 with 1`).
-- mutants.json - A list with every mutation applied, written before the testing begins (filename, line, return type, replacement etc).
-- outcome.json - List of outcomes for every mutation (mutant applied, log path, results for build/test phases with status and command args)
-- timeout.txt - Mutations that timed out
-- unviable.txt - Unviable mutations (When a mutation is applied and it causes the cargo build command to fail)
-
-`mutants.out.old` - This is the folder where _mutants.out_ folder’s content is copied into, on successive runs (it’s contents are being overwritten), making way for the next logs.

From 0bf76dd65c015337c5f7f54aec38550cb7070616 Mon Sep 17 00:00:00 2001
From: ASuciuX <asuciu@hiro.so>
Date: Mon, 11 Dec 2023 13:56:06 +0200
Subject: [PATCH 0129/1166] feat: update link to stacks action repo

---
 .github/workflows/filter-pr-mutants.yml | 2 +-
 .github/workflows/logger-mutants.yml    | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/filter-pr-mutants.yml b/.github/workflows/filter-pr-mutants.yml
index 226eab14df..5956e9579f 100644
--- a/.github/workflows/filter-pr-mutants.yml
+++ b/.github/workflows/filter-pr-mutants.yml
@@ -12,4 +12,4 @@ jobs:
 
     steps:
       - name: Run filtering pr mutants from actions
-        uses: ASuciuX/actions/mutation-testing/filter-pr@feat/mutation-testing
+        uses: stacks-network/actions/mutation-testing/filter-pr@feat/mutation-testing
diff --git a/.github/workflows/logger-mutants.yml b/.github/workflows/logger-mutants.yml
index 6bfd0c2c21..1db813ffed 100644
--- a/.github/workflows/logger-mutants.yml
+++ b/.github/workflows/logger-mutants.yml
@@ -25,6 +25,6 @@ jobs:
     # test
     steps:
       - name: Run logging mutants from actions
-        uses: ASuciuX/actions/mutation-testing/logger@feat/mutation-testing
+        uses: stacks-network/actions/mutation-testing/logger@feat/mutation-testing
         with:
           gh-token: ${{ secrets.GITHUB_TOKEN }}

From 1fbfa9acccca767005a0d5961d9709df048b2e3e Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Sat, 9 Dec 2023 07:33:40 -0600
Subject: [PATCH 0130/1166] fix: set maxburncap to 1BTC in sendrawtransaction
 (new in Bitcoin 25.0)

---
 clarity/src/vm/functions/mod.rs                                | 3 +--
 .../stacks-node/src/burnchains/bitcoin_regtest_controller.rs   | 3 ++-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/clarity/src/vm/functions/mod.rs b/clarity/src/vm/functions/mod.rs
index ac03c6db34..b653ebab76 100644
--- a/clarity/src/vm/functions/mod.rs
+++ b/clarity/src/vm/functions/mod.rs
@@ -64,9 +64,8 @@ macro_rules! switch_on_global_epoch {
     };
 }
 
-use crate::vm::ClarityVersion;
-
 use super::errors::InterpreterError;
+use crate::vm::ClarityVersion;
 
 mod arithmetic;
 mod assets;
diff --git a/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs b/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
index 319fec7080..30967f5556 100644
--- a/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
+++ b/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
@@ -2350,7 +2350,8 @@ impl BitcoinRPCRequest {
     pub fn send_raw_transaction(config: &Config, tx: String) -> RPCResult<()> {
         let payload = BitcoinRPCRequest {
             method: "sendrawtransaction".to_string(),
-            params: vec![tx.into()],
+            // set maxfee (as uncapped) and maxburncap (new in bitcoin 25)
+            params: vec![tx.into(), 0.into(), 1_000_000.into()],
             id: "stacks".to_string(),
             jsonrpc: "2.0".to_string(),
         };

From 7b04730e71a50a338a01d2324506bf49109be9cd Mon Sep 17 00:00:00 2001
From: wileyj <2847772+wileyj@users.noreply.github.com>
Date: Fri, 8 Dec 2023 15:32:38 -0800
Subject: [PATCH 0131/1166] use bitcoin 25.0 for tests

---
 .github/workflows/atlas-tests.yml       |  4 ++-
 .github/workflows/bitcoin-tests.yml     |  6 ++--
 .github/workflows/create-cache.yml      |  1 +
 .github/workflows/epoch-tests.yml       |  4 ++-
 .github/workflows/slow-tests.yml        |  4 ++-
 .github/workflows/stacks-core-tests.yml | 43 +++++++++++++++++++------
 6 files changed, 47 insertions(+), 15 deletions(-)

diff --git a/.github/workflows/atlas-tests.yml b/.github/workflows/atlas-tests.yml
index cb9f4a968f..8cb6b6bcc9 100644
--- a/.github/workflows/atlas-tests.yml
+++ b/.github/workflows/atlas-tests.yml
@@ -36,7 +36,9 @@ jobs:
       - name: Setup Test Environment
         id: setup_tests
         uses: stacks-network/actions/stacks-core/testenv@main
-
+        with:
+          btc-version: "25.0"
+          
       ## Run test matrix using restored cache of archive file
       ##   - Test will timeout after env.TEST_TIMEOUT minutes
       - name: Run Tests
diff --git a/.github/workflows/bitcoin-tests.yml b/.github/workflows/bitcoin-tests.yml
index de1b16c26f..4acac1c8a0 100644
--- a/.github/workflows/bitcoin-tests.yml
+++ b/.github/workflows/bitcoin-tests.yml
@@ -31,7 +31,7 @@ jobs:
         test-name:
           - tests::bitcoin_regtest::bitcoind_integration_test
           - tests::integrations::integration_test_get_info
-          - tests::neon_integrations::antientropy_integration_test ## forced failure
+          - tests::neon_integrations::antientropy_integration_test 
           - tests::neon_integrations::bad_microblock_pubkey
           - tests::neon_integrations::bitcoind_forking_test
           - tests::neon_integrations::bitcoind_integration_test
@@ -74,7 +74,9 @@ jobs:
       - name: Setup Test Environment
         id: setup_tests
         uses: stacks-network/actions/stacks-core/testenv@main
-
+        with:
+          btc-version: "25.0"
+          
       ## Run test matrix using restored cache of archive file
       ##   - Test will timeout after env.TEST_TIMEOUT minutes
       - name: Run Tests
diff --git a/.github/workflows/create-cache.yml b/.github/workflows/create-cache.yml
index a67ecc8fa0..af88b02583 100644
--- a/.github/workflows/create-cache.yml
+++ b/.github/workflows/create-cache.yml
@@ -44,6 +44,7 @@ jobs:
         uses: stacks-network/actions/stacks-core/cache/bitcoin@main
         with:
           action: save
+          btc-version: "25.0"
 
   ## Cache nextest archives for tests
   nextest-archive:
diff --git a/.github/workflows/epoch-tests.yml b/.github/workflows/epoch-tests.yml
index b7d9bd6f06..a50e0d344d 100644
--- a/.github/workflows/epoch-tests.yml
+++ b/.github/workflows/epoch-tests.yml
@@ -59,7 +59,9 @@ jobs:
       - name: Setup Test Environment
         id: setup_tests
         uses: stacks-network/actions/stacks-core/testenv@main
-
+        with:
+          btc-version: "25.0"
+          
       ## Run test matrix using restored cache of archive file
       ##   - Test will timeout after env.TEST_TIMEOUT minutes
       - name: Run Tests
diff --git a/.github/workflows/slow-tests.yml b/.github/workflows/slow-tests.yml
index 38fb20ac3d..0c2cb62ea4 100644
--- a/.github/workflows/slow-tests.yml
+++ b/.github/workflows/slow-tests.yml
@@ -37,7 +37,9 @@ jobs:
       - name: Setup Test Environment
         id: setup_tests
         uses: stacks-network/actions/stacks-core/testenv@main
-
+        with:
+          btc-version: "25.0"
+          
       ## Run test matrix using restored cache of archive file
       ##   - Test will timeout after env.TEST_TIMEOUT minutes
       - name: Run Tests
diff --git a/.github/workflows/stacks-core-tests.yml b/.github/workflows/stacks-core-tests.yml
index af0b1a934c..1e883d3d96 100644
--- a/.github/workflows/stacks-core-tests.yml
+++ b/.github/workflows/stacks-core-tests.yml
@@ -37,6 +37,7 @@ jobs:
         uses: stacks-network/actions/stacks-core/testenv@main
         with:
           genesis: true
+          btc-version: "25.0"
 
       ## Run test matrix using restored cache of archive file
       ##   - Test will timeout after env.TEST_TIMEOUT minutes
@@ -84,7 +85,9 @@ jobs:
       - name: Setup Test Environment
         id: setup_tests
         uses: stacks-network/actions/stacks-core/testenv@main
-
+        with:
+          btc-version: "25.0"
+          
       ## Run test matrix using restored cache of archive file
       ##   - Test will timeout after env.TEST_TIMEOUT minutes
       - name: Run Tests
@@ -135,20 +138,23 @@ jobs:
   # Core contract tests
   core-contracts-clarinet-test:
     name: Core Contracts Test
+    defaults:
+      run:
+        working-directory: "./contrib/core-contract-tests/"
     runs-on: ubuntu-latest
     steps:
-      ## Checkout the code
       - name: Checkout the latest code
         id: git_checkout
-        uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11 # v4.1.1
-
-      ## Use Clarinet to run contract unit-tests and create code coverage file
-      - name: Execute core contract unit tests in Clarinet
+        uses: actions/checkout@v3
+      - name: Execute core contract unit tests with clarinet-sdk
         id: clarinet_unit_test
-        uses: docker://hirosystems/clarinet:1.8.0
+        uses: actions/setup-node@v3
         with:
-          args: test --coverage --manifest-path=./contrib/core-contract-tests/Clarinet.toml
-
+          node-version: 18.x
+          cache: "npm"
+          cache-dependency-path: "./contrib/core-contract-tests/package-lock.json"
+      - run: npm ci
+      - run: npm test
       ## Upload code coverage file
       - name: Code Coverage
         id: codecov
@@ -156,4 +162,21 @@ jobs:
         with:
           test-name: ${{ matrix.test-name }}
           upload-only: true
-          filename: ./coverage.lcov
+          filename: ./lcov.info
+
+  # Core contract tests on Clarinet v1
+  # Check for false positives/negatives
+  # https://github.com/stacks-network/stacks-blockchain/pull/4031#pullrequestreview-1713341208
+  core-contracts-clarinet-test-clarinet-v1:
+    name: Core Contracts Test Clarinet V1
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout the latest code
+        id: git_checkout
+        uses: actions/checkout@v3
+      - name: Execute core contract unit tests in Clarinet
+        id: clarinet_unit_test_v1
+        uses: docker://hirosystems/clarinet:1.7.1
+        with:
+          args: test --manifest-path=./contrib/core-contract-tests/Clarinet.toml contrib/core-contract-tests/tests/bns/name_register_test.ts
+

From 38a14a9e08cdb16ecad709663993a5935f5386f7 Mon Sep 17 00:00:00 2001
From: Joey Yandle <xoloki@gmail.com>
Date: Mon, 11 Dec 2023 11:11:11 -0500
Subject: [PATCH 0132/1166] set test_stackerdb_dkg to ignore

---
 testnet/stacks-node/src/tests/signer.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index a3b5865f7f..67f5e9d48c 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -189,6 +189,7 @@ pub fn build_pox_contract(num_signers: u32) -> String {
 }
 
 #[test]
+#[ignore]
 fn test_stackerdb_dkg() {
     if env::var("BITCOIND_TEST") != Ok("1".into()) {
         return;

From adf3953de00dfe82beda2cc7c206373495cf0c14 Mon Sep 17 00:00:00 2001
From: soju-drinker <takashi.hatake@outlook.com>
Date: Fri, 1 Dec 2023 10:02:48 -0500
Subject: [PATCH 0133/1166] remove sbtc ops

---
 stackslib/src/burnchains/burnchain.rs         |  52 +-
 .../src/chainstate/burn/db/processing.rs      |  21 -
 stackslib/src/chainstate/burn/db/sortdb.rs    | 448 +------------
 .../src/chainstate/burn/operations/mod.rs     |  98 ---
 .../src/chainstate/burn/operations/peg_in.rs  | 451 -------------
 .../burn/operations/peg_out_fulfill.rs        | 308 ---------
 .../burn/operations/peg_out_request.rs        | 620 ------------------
 .../burn/operations/test/serialization.rs     | 476 +-------------
 stackslib/src/chainstate/coordinator/tests.rs | 275 --------
 stackslib/src/net/mod.rs                      |  18 +-
 .../burnchains/bitcoin_regtest_controller.rs  | 240 +------
 .../src/burnchains/mocknet_controller.rs      |  24 +-
 .../src/tests/neon_integrations.rs            | 449 +------------
 13 files changed, 10 insertions(+), 3470 deletions(-)
 delete mode 100644 stackslib/src/chainstate/burn/operations/peg_in.rs
 delete mode 100644 stackslib/src/chainstate/burn/operations/peg_out_fulfill.rs
 delete mode 100644 stackslib/src/chainstate/burn/operations/peg_out_request.rs

diff --git a/stackslib/src/burnchains/burnchain.rs b/stackslib/src/burnchains/burnchain.rs
index 7935599347..f4cbd01dbb 100644
--- a/stackslib/src/burnchains/burnchain.rs
+++ b/stackslib/src/burnchains/burnchain.rs
@@ -54,8 +54,7 @@ use crate::chainstate::burn::db::sortdb::{
 use crate::chainstate::burn::distribution::BurnSamplePoint;
 use crate::chainstate::burn::operations::leader_block_commit::MissedBlockCommit;
 use crate::chainstate::burn::operations::{
-    BlockstackOperationType, DelegateStxOp, LeaderBlockCommitOp, LeaderKeyRegisterOp, PegInOp,
-    PegOutFulfillOp, PegOutRequestOp, PreStxOp, StackStxOp, TransferStxOp, UserBurnSupportOp,
+    BlockstackOperationType, DelegateStxOp, LeaderBlockCommitOp, LeaderKeyRegisterOp, PreStxOp, StackStxOp, TransferStxOp, UserBurnSupportOp,
 };
 use crate::chainstate::burn::{BlockSnapshot, Opcodes};
 use crate::chainstate::coordinator::comm::CoordinatorChannels;
@@ -131,15 +130,6 @@ impl BurnchainStateTransition {
                 BlockstackOperationType::LeaderKeyRegister(_) => {
                     accepted_ops.push(block_ops[i].clone());
                 }
-                BlockstackOperationType::PegIn(_) => {
-                    accepted_ops.push(block_ops[i].clone());
-                }
-                BlockstackOperationType::PegOutRequest(_) => {
-                    accepted_ops.push(block_ops[i].clone());
-                }
-                BlockstackOperationType::PegOutFulfill(_) => {
-                    accepted_ops.push(block_ops[i].clone());
-                }
                 BlockstackOperationType::LeaderBlockCommit(ref op) => {
                     // we don't yet know which block commits are going to be accepted until we have
                     // the burn distribution, so just account for them for now.
@@ -885,46 +875,6 @@ impl Burnchain {
                 }
             }
 
-            x if x == Opcodes::PegIn as u8 => match PegInOp::from_tx(block_header, burn_tx) {
-                Ok(op) => Some(BlockstackOperationType::PegIn(op)),
-                Err(e) => {
-                    warn!("Failed to parse peg in tx";
-                        "txid" => %burn_tx.txid(),
-                        "data" => %to_hex(&burn_tx.data()),
-                        "error" => ?e,
-                    );
-                    None
-                }
-            },
-
-            x if x == Opcodes::PegOutRequest as u8 => {
-                match PegOutRequestOp::from_tx(block_header, burn_tx) {
-                    Ok(op) => Some(BlockstackOperationType::PegOutRequest(op)),
-                    Err(e) => {
-                        warn!("Failed to parse peg out request tx";
-                            "txid" => %burn_tx.txid(),
-                            "data" => %to_hex(&burn_tx.data()),
-                            "error" => ?e,
-                        );
-                        None
-                    }
-                }
-            }
-
-            x if x == Opcodes::PegOutFulfill as u8 => {
-                match PegOutFulfillOp::from_tx(block_header, burn_tx) {
-                    Ok(op) => Some(BlockstackOperationType::PegOutFulfill(op)),
-                    Err(e) => {
-                        warn!("Failed to parse peg in tx";
-                            "txid" => %burn_tx.txid(),
-                            "data" => %to_hex(&burn_tx.data()),
-                            "error" => ?e,
-                        );
-                        None
-                    }
-                }
-            }
-
             _ => None,
         }
     }
diff --git a/stackslib/src/chainstate/burn/db/processing.rs b/stackslib/src/chainstate/burn/db/processing.rs
index 5d541d4884..bf1e83efd9 100644
--- a/stackslib/src/chainstate/burn/db/processing.rs
+++ b/stackslib/src/chainstate/burn/db/processing.rs
@@ -102,27 +102,6 @@ impl<'a> SortitionHandleTx<'a> {
                 );
                 BurnchainError::OpError(e)
             }),
-            BlockstackOperationType::PegIn(ref op) => op.check().map_err(|e| {
-                warn!(
-                    "REJECTED({}) peg in op {} at {},{}: {:?}",
-                    op.block_height, &op.txid, op.block_height, op.vtxindex, &e
-                );
-                BurnchainError::OpError(e)
-            }),
-            BlockstackOperationType::PegOutRequest(ref op) => op.check().map_err(|e| {
-                warn!(
-                    "REJECTED({}) peg out request op {} at {},{}: {:?}",
-                    op.block_height, &op.txid, op.block_height, op.vtxindex, &e
-                );
-                BurnchainError::OpError(e)
-            }),
-            BlockstackOperationType::PegOutFulfill(ref op) => op.check().map_err(|e| {
-                warn!(
-                    "REJECTED({}) peg out fulfill op {} at {},{}: {:?}",
-                    op.block_height, &op.txid, op.block_height, op.vtxindex, &e
-                );
-                BurnchainError::OpError(e)
-            }),
         }
     }
 
diff --git a/stackslib/src/chainstate/burn/db/sortdb.rs b/stackslib/src/chainstate/burn/db/sortdb.rs
index a7577011fc..435ea412be 100644
--- a/stackslib/src/chainstate/burn/db/sortdb.rs
+++ b/stackslib/src/chainstate/burn/db/sortdb.rs
@@ -58,8 +58,7 @@ use crate::chainstate::burn::operations::leader_block_commit::{
     MissedBlockCommit, RewardSetInfo, OUTPUTS_PER_COMMIT,
 };
 use crate::chainstate::burn::operations::{
-    BlockstackOperationType, DelegateStxOp, LeaderBlockCommitOp, LeaderKeyRegisterOp, PegInOp,
-    PegOutFulfillOp, PegOutRequestOp, PreStxOp, StackStxOp, TransferStxOp, UserBurnSupportOp,
+    BlockstackOperationType, DelegateStxOp, LeaderBlockCommitOp, LeaderKeyRegisterOp, PreStxOp, StackStxOp, TransferStxOp, UserBurnSupportOp,
 };
 use crate::chainstate::burn::{
     BlockSnapshot, ConsensusHash, ConsensusHashExtensions, Opcodes, OpsHash, SortitionHash,
@@ -403,112 +402,6 @@ impl FromRow<DelegateStxOp> for DelegateStxOp {
     }
 }
 
-impl FromRow<PegInOp> for PegInOp {
-    fn from_row<'a>(row: &'a Row) -> Result<Self, db_error> {
-        let txid = Txid::from_column(row, "txid")?;
-        let vtxindex: u32 = row.get("vtxindex")?;
-        let block_height = u64::from_column(row, "block_height")?;
-        let burn_header_hash = BurnchainHeaderHash::from_column(row, "burn_header_hash")?;
-
-        let recipient = PrincipalData::from_column(row, "recipient")?;
-        let peg_wallet_address = PoxAddress::from_column(row, "peg_wallet_address")?;
-        let amount = row
-            .get::<_, String>("amount")?
-            .parse()
-            .map_err(|_| db_error::ParseError)?;
-
-        let memo_hex: String = row.get_unwrap("memo");
-        let memo_bytes = hex_bytes(&memo_hex).map_err(|_e| db_error::ParseError)?;
-        let memo = memo_bytes.to_vec();
-
-        Ok(Self {
-            txid,
-            vtxindex,
-            block_height,
-            burn_header_hash,
-            recipient,
-            peg_wallet_address,
-            amount,
-            memo,
-        })
-    }
-}
-
-impl FromRow<PegOutRequestOp> for PegOutRequestOp {
-    fn from_row<'a>(row: &'a Row) -> Result<Self, db_error> {
-        let txid = Txid::from_column(row, "txid")?;
-        let vtxindex: u32 = row.get("vtxindex")?;
-        let block_height = u64::from_column(row, "block_height")?;
-        let burn_header_hash = BurnchainHeaderHash::from_column(row, "burn_header_hash")?;
-
-        let recipient = PoxAddress::from_column(row, "recipient")?;
-        let amount = row
-            .get::<_, String>("amount")?
-            .parse()
-            .map_err(|_| db_error::ParseError)?;
-
-        let signature = MessageSignature::from_column(row, "signature")?;
-
-        let peg_wallet_address = PoxAddress::from_column(row, "peg_wallet_address")?;
-        let fulfillment_fee = row
-            .get::<_, String>("fulfillment_fee")?
-            .parse()
-            .map_err(|_| db_error::ParseError)?;
-
-        let memo_hex: String = row.get_unwrap("memo");
-        let memo_bytes = hex_bytes(&memo_hex).map_err(|_e| db_error::ParseError)?;
-        let memo = memo_bytes.to_vec();
-
-        Ok(Self {
-            txid,
-            vtxindex,
-            block_height,
-            burn_header_hash,
-            recipient,
-            amount,
-            signature,
-            peg_wallet_address,
-            fulfillment_fee,
-            memo,
-        })
-    }
-}
-
-impl FromRow<PegOutFulfillOp> for PegOutFulfillOp {
-    fn from_row<'a>(row: &'a Row) -> Result<Self, db_error> {
-        let txid = Txid::from_column(row, "txid")?;
-        let vtxindex: u32 = row.get("vtxindex")?;
-        let block_height = u64::from_column(row, "block_height")?;
-        let burn_header_hash = BurnchainHeaderHash::from_column(row, "burn_header_hash")?;
-
-        let recipient = PoxAddress::from_column(row, "recipient")?;
-        let amount = row
-            .get::<_, String>("amount")?
-            .parse()
-            .map_err(|_| db_error::ParseError)?;
-
-        let chain_tip = StacksBlockId::from_column(row, "chain_tip")?;
-
-        let memo_hex: String = row.get_unwrap("memo");
-        let memo_bytes = hex_bytes(&memo_hex).map_err(|_e| db_error::ParseError)?;
-        let memo = memo_bytes.to_vec();
-
-        let request_ref = Txid::from_column(row, "request_ref")?;
-
-        Ok(Self {
-            txid,
-            vtxindex,
-            block_height,
-            burn_header_hash,
-            chain_tip,
-            recipient,
-            amount,
-            memo,
-            request_ref,
-        })
-    }
-}
-
 impl FromRow<TransferStxOp> for TransferStxOp {
     fn from_row<'a>(row: &'a Row) -> Result<TransferStxOp, db_error> {
         let txid = Txid::from_column(row, "txid")?;
@@ -4460,48 +4353,6 @@ impl SortitionDB {
         )
     }
 
-    /// Get the list of Peg-In operations processed in a given burnchain block.
-    /// This will be the same list in each PoX fork; it's up to the Stacks block-processing logic
-    /// to reject them.
-    pub fn get_peg_in_ops(
-        conn: &Connection,
-        burn_header_hash: &BurnchainHeaderHash,
-    ) -> Result<Vec<PegInOp>, db_error> {
-        query_rows(
-            conn,
-            "SELECT * FROM peg_in WHERE burn_header_hash = ?",
-            &[burn_header_hash],
-        )
-    }
-
-    /// Get the list of Peg-Out Request operations processed in a given burnchain block.
-    /// This will be the same list in each PoX fork; it's up to the Stacks block-processing logic
-    /// to reject them.
-    pub fn get_peg_out_request_ops(
-        conn: &Connection,
-        burn_header_hash: &BurnchainHeaderHash,
-    ) -> Result<Vec<PegOutRequestOp>, db_error> {
-        query_rows(
-            conn,
-            "SELECT * FROM peg_out_requests WHERE burn_header_hash = ?",
-            &[burn_header_hash],
-        )
-    }
-
-    /// Get the list of Peg-Out Fulfill operations processed in a given burnchain block.
-    /// This will be the same list in each PoX fork; it's up to the Stacks block-processing logic
-    /// to reject them.
-    pub fn get_peg_out_fulfill_ops(
-        conn: &Connection,
-        burn_header_hash: &BurnchainHeaderHash,
-    ) -> Result<Vec<PegOutFulfillOp>, db_error> {
-        query_rows(
-            conn,
-            "SELECT * FROM peg_out_fulfillments WHERE burn_header_hash = ?",
-            &[burn_header_hash],
-        )
-    }
-
     /// Get the list of Transfer-STX operations processed in a given burnchain block.
     /// This will be the same list in each PoX fork; it's up to the Stacks block-processing logic
     /// to reject them.
@@ -5461,27 +5312,6 @@ impl<'a> SortitionHandleTx<'a> {
                 );
                 self.insert_delegate_stx(op)
             }
-            BlockstackOperationType::PegIn(ref op) => {
-                info!(
-                    "ACCEPTED({}) sBTC peg in opt {} at {},{}",
-                    op.block_height, &op.txid, op.block_height, op.vtxindex
-                );
-                self.insert_peg_in_sbtc(op)
-            }
-            BlockstackOperationType::PegOutRequest(ref op) => {
-                info!(
-                    "ACCEPTED({}) sBTC peg out request opt {} at {},{}",
-                    op.block_height, &op.txid, op.block_height, op.vtxindex
-                );
-                self.insert_sbtc_peg_out_request(op)
-            }
-            BlockstackOperationType::PegOutFulfill(ref op) => {
-                info!(
-                    "ACCEPTED({}) sBTC peg out fulfill op {} at {},{}",
-                    op.block_height, &op.txid, op.block_height, op.vtxindex
-                );
-                self.insert_sbtc_peg_out_fulfill(op)
-            }
         }
     }
 
@@ -5549,63 +5379,6 @@ impl<'a> SortitionHandleTx<'a> {
         Ok(())
     }
 
-    /// Insert a peg-in op
-    fn insert_peg_in_sbtc(&mut self, op: &PegInOp) -> Result<(), db_error> {
-        let args: &[&dyn ToSql] = &[
-            &op.txid,
-            &op.vtxindex,
-            &u64_to_sql(op.block_height)?,
-            &op.burn_header_hash,
-            &op.recipient.to_string(),
-            &op.peg_wallet_address.to_string(),
-            &op.amount.to_string(),
-            &to_hex(&op.memo),
-        ];
-
-        self.execute("REPLACE INTO peg_in (txid, vtxindex, block_height, burn_header_hash, recipient, peg_wallet_address, amount, memo) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8)", args)?;
-
-        Ok(())
-    }
-
-    /// Insert a peg-out request op
-    fn insert_sbtc_peg_out_request(&mut self, op: &PegOutRequestOp) -> Result<(), db_error> {
-        let args: &[&dyn ToSql] = &[
-            &op.txid,
-            &op.vtxindex,
-            &u64_to_sql(op.block_height)?,
-            &op.burn_header_hash,
-            &op.amount.to_string(),
-            &op.recipient.to_string(),
-            &op.signature,
-            &op.peg_wallet_address.to_string(),
-            &op.fulfillment_fee.to_string(),
-            &to_hex(&op.memo),
-        ];
-
-        self.execute("REPLACE INTO peg_out_requests (txid, vtxindex, block_height, burn_header_hash, amount, recipient, signature, peg_wallet_address, fulfillment_fee, memo) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10)", args)?;
-
-        Ok(())
-    }
-
-    /// Insert a peg-out fulfillment op
-    fn insert_sbtc_peg_out_fulfill(&mut self, op: &PegOutFulfillOp) -> Result<(), db_error> {
-        let args: &[&dyn ToSql] = &[
-            &op.txid,
-            &op.vtxindex,
-            &u64_to_sql(op.block_height)?,
-            &op.burn_header_hash,
-            &op.chain_tip,
-            &op.amount.to_string(),
-            &op.recipient.to_string(),
-            &op.request_ref.to_string(),
-            &to_hex(&op.memo),
-        ];
-
-        self.execute("REPLACE INTO peg_out_fulfillments (txid, vtxindex, block_height, burn_header_hash, chain_tip, amount, recipient, request_ref, memo) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9)", args)?;
-
-        Ok(())
-    }
-
     /// Insert a transfer-stx op
     fn insert_transfer_stx(&mut self, op: &TransferStxOp) -> Result<(), db_error> {
         let args: &[&dyn ToSql] = &[
@@ -7029,225 +6802,6 @@ pub mod tests {
         }
     }
 
-    #[test]
-    fn test_insert_peg_in() {
-        let block_height = 123;
-
-        let peg_in_op = |burn_header_hash, amount| {
-            let txid = Txid([0; 32]);
-            let vtxindex = 456;
-            let recipient = StacksAddress::new(1, Hash160([1u8; 20])).into();
-            let peg_wallet_address =
-                PoxAddress::Addr32(false, address::PoxAddressType32::P2TR, [0; 32]);
-            let memo = vec![1, 3, 3, 7];
-
-            PegInOp {
-                recipient,
-                peg_wallet_address,
-                amount,
-                memo,
-
-                txid,
-                vtxindex,
-                block_height,
-                burn_header_hash,
-            }
-        };
-
-        let burn_header_hash_1 = BurnchainHeaderHash([0x01; 32]);
-        let burn_header_hash_2 = BurnchainHeaderHash([0x02; 32]);
-
-        let peg_in_1 = peg_in_op(burn_header_hash_1, 1337);
-        let peg_in_2 = peg_in_op(burn_header_hash_2, 42);
-
-        let first_burn_hash = BurnchainHeaderHash::from_hex(
-            "0000000000000000000000000000000000000000000000000000000000000000",
-        )
-        .unwrap();
-
-        let epochs = StacksEpoch::unit_test(StacksEpochId::Epoch21, block_height);
-        let mut db =
-            SortitionDB::connect_test_with_epochs(block_height, &first_burn_hash, epochs).unwrap();
-
-        let snapshot_1 = test_append_snapshot(
-            &mut db,
-            burn_header_hash_1,
-            &vec![BlockstackOperationType::PegIn(peg_in_1.clone())],
-        );
-
-        let snapshot_2 = test_append_snapshot(
-            &mut db,
-            burn_header_hash_2,
-            &vec![BlockstackOperationType::PegIn(peg_in_2.clone())],
-        );
-
-        let res_peg_ins_1 = SortitionDB::get_peg_in_ops(db.conn(), &snapshot_1.burn_header_hash)
-            .expect("Failed to get peg-in ops from sortition DB");
-
-        assert_eq!(res_peg_ins_1.len(), 1);
-        assert_eq!(res_peg_ins_1[0], peg_in_1);
-
-        let res_peg_ins_2 = SortitionDB::get_peg_in_ops(db.conn(), &snapshot_2.burn_header_hash)
-            .expect("Failed to get peg-in ops from sortition DB");
-
-        assert_eq!(res_peg_ins_2.len(), 1);
-        assert_eq!(res_peg_ins_2[0], peg_in_2);
-    }
-
-    #[test]
-    fn test_insert_peg_out_request() {
-        let block_height = 123;
-
-        let peg_out_request_op = |burn_header_hash, amount| {
-            let txid = Txid([0; 32]);
-            let vtxindex = 456;
-            let amount = 1337;
-            let recipient = PoxAddress::Addr32(false, address::PoxAddressType32::P2TR, [0; 32]);
-            let signature = MessageSignature([0; 65]);
-            let peg_wallet_address =
-                PoxAddress::Addr32(false, address::PoxAddressType32::P2TR, [0; 32]);
-            let fulfillment_fee = 3;
-            let memo = vec![1, 3, 3, 7];
-
-            PegOutRequestOp {
-                recipient,
-                amount,
-                signature,
-                peg_wallet_address,
-                fulfillment_fee,
-                memo,
-
-                txid,
-                vtxindex,
-                block_height,
-                burn_header_hash,
-            }
-        };
-
-        let burn_header_hash_1 = BurnchainHeaderHash([0x01; 32]);
-        let burn_header_hash_2 = BurnchainHeaderHash([0x02; 32]);
-
-        let peg_out_request_1 = peg_out_request_op(burn_header_hash_1, 1337);
-        let peg_out_request_2 = peg_out_request_op(burn_header_hash_2, 42);
-
-        let first_burn_hash = BurnchainHeaderHash::from_hex(
-            "0000000000000000000000000000000000000000000000000000000000000000",
-        )
-        .unwrap();
-
-        let epochs = StacksEpoch::unit_test(StacksEpochId::Epoch21, block_height);
-        let mut db =
-            SortitionDB::connect_test_with_epochs(block_height, &first_burn_hash, epochs).unwrap();
-
-        let snapshot_1 = test_append_snapshot(
-            &mut db,
-            burn_header_hash_1,
-            &vec![BlockstackOperationType::PegOutRequest(
-                peg_out_request_1.clone(),
-            )],
-        );
-
-        let snapshot_2 = test_append_snapshot(
-            &mut db,
-            burn_header_hash_2,
-            &vec![BlockstackOperationType::PegOutRequest(
-                peg_out_request_2.clone(),
-            )],
-        );
-
-        let res_peg_out_requests_1 =
-            SortitionDB::get_peg_out_request_ops(db.conn(), &burn_header_hash_1)
-                .expect("Failed to get peg-out request ops from sortition DB");
-
-        assert_eq!(res_peg_out_requests_1.len(), 1);
-        assert_eq!(res_peg_out_requests_1[0], peg_out_request_1);
-
-        let res_peg_out_requests_2 =
-            SortitionDB::get_peg_out_request_ops(db.conn(), &burn_header_hash_2)
-                .expect("Failed to get peg-out request ops from sortition DB");
-
-        assert_eq!(res_peg_out_requests_2.len(), 1);
-        assert_eq!(res_peg_out_requests_2[0], peg_out_request_2);
-    }
-
-    #[test]
-    fn test_insert_peg_out_fulfill() {
-        let txid = Txid([0; 32]);
-
-        let peg_out_fulfill_op = |burn_header_hash, amount| {
-            let block_height = 123;
-            let vtxindex = 456;
-            let recipient = PoxAddress::Addr32(false, address::PoxAddressType32::P2TR, [0; 32]);
-            let chain_tip = StacksBlockId([0; 32]);
-            let request_ref = Txid([1; 32]);
-            let memo = vec![1, 3, 3, 7];
-
-            PegOutFulfillOp {
-                recipient,
-                amount,
-                chain_tip,
-                request_ref,
-                memo,
-
-                txid,
-                vtxindex,
-                block_height,
-                burn_header_hash,
-            }
-        };
-
-        let block_height = 123;
-        let vtxindex = 456;
-        let recipient = PoxAddress::Addr32(false, address::PoxAddressType32::P2TR, [0; 32]);
-        let chain_tip = StacksBlockId([0; 32]);
-        let burn_header_hash = BurnchainHeaderHash([0x03; 32]);
-
-        let burn_header_hash_1 = BurnchainHeaderHash([0x01; 32]);
-        let burn_header_hash_2 = BurnchainHeaderHash([0x02; 32]);
-
-        let peg_out_fulfill_1 = peg_out_fulfill_op(burn_header_hash_1, 1337);
-        let peg_out_fulfill_2 = peg_out_fulfill_op(burn_header_hash_2, 42);
-
-        let first_burn_hash = BurnchainHeaderHash::from_hex(
-            "0000000000000000000000000000000000000000000000000000000000000000",
-        )
-        .unwrap();
-
-        let epochs = StacksEpoch::unit_test(StacksEpochId::Epoch21, block_height);
-        let mut db =
-            SortitionDB::connect_test_with_epochs(block_height, &first_burn_hash, epochs).unwrap();
-
-        let snapshot_1 = test_append_snapshot(
-            &mut db,
-            burn_header_hash_1,
-            &vec![BlockstackOperationType::PegOutFulfill(
-                peg_out_fulfill_1.clone(),
-            )],
-        );
-
-        let snapshot_2 = test_append_snapshot(
-            &mut db,
-            burn_header_hash_2,
-            &vec![BlockstackOperationType::PegOutFulfill(
-                peg_out_fulfill_2.clone(),
-            )],
-        );
-
-        let res_peg_out_fulfillments_1 =
-            SortitionDB::get_peg_out_fulfill_ops(db.conn(), &burn_header_hash_1)
-                .expect("Failed to get peg-out fulfill ops from sortition DB");
-
-        assert_eq!(res_peg_out_fulfillments_1.len(), 1);
-        assert_eq!(res_peg_out_fulfillments_1[0], peg_out_fulfill_1);
-
-        let res_peg_out_fulfillments_2 =
-            SortitionDB::get_peg_out_fulfill_ops(db.conn(), &burn_header_hash_2)
-                .expect("Failed to get peg-out fulfill ops from sortition DB");
-
-        assert_eq!(res_peg_out_fulfillments_2.len(), 1);
-        assert_eq!(res_peg_out_fulfillments_2[0], peg_out_fulfill_2);
-    }
-
     #[test]
     fn has_VRF_public_key() {
         let public_key = VRFPublicKey::from_bytes(
diff --git a/stackslib/src/chainstate/burn/operations/mod.rs b/stackslib/src/chainstate/burn/operations/mod.rs
index 1667a667f3..189acab16c 100644
--- a/stackslib/src/chainstate/burn/operations/mod.rs
+++ b/stackslib/src/chainstate/burn/operations/mod.rs
@@ -43,9 +43,6 @@ pub mod delegate_stx;
 pub mod leader_block_commit;
 /// This module contains all burn-chain operations
 pub mod leader_key_register;
-pub mod peg_in;
-pub mod peg_out_fulfill;
-pub mod peg_out_request;
 pub mod stack_stx;
 pub mod transfer_stx;
 pub mod user_burn_support;
@@ -342,71 +339,6 @@ fn principal_deserialize<'de, D: serde::Deserializer<'de>>(
     PrincipalData::parse(&inst_str).map_err(serde::de::Error::custom)
 }
 
-#[derive(Debug, PartialEq, Clone, Eq, Serialize, Deserialize)]
-pub struct PegInOp {
-    #[serde(serialize_with = "principal_serialize")]
-    #[serde(deserialize_with = "principal_deserialize")]
-    pub recipient: PrincipalData,
-    #[serde(serialize_with = "crate::chainstate::stacks::address::pox_addr_b58_serialize")]
-    #[serde(deserialize_with = "crate::chainstate::stacks::address::pox_addr_b58_deser")]
-    pub peg_wallet_address: PoxAddress,
-    pub amount: u64, // BTC amount to peg in, in satoshis
-    #[serde(serialize_with = "hex_ser_memo")]
-    #[serde(deserialize_with = "hex_deser_memo")]
-    pub memo: Vec<u8>, // extra unused bytes
-
-    // common to all transactions
-    pub txid: Txid,        // transaction ID
-    pub vtxindex: u32,     // index in the block where this tx occurs
-    pub block_height: u64, // block height at which this tx occurs
-    #[serde(deserialize_with = "hex_deserialize", serialize_with = "hex_serialize")]
-    pub burn_header_hash: BurnchainHeaderHash, // hash of the burn chain block header
-}
-
-#[derive(Debug, PartialEq, Clone, Eq, Serialize, Deserialize)]
-pub struct PegOutRequestOp {
-    pub amount: u64, // sBTC amount to peg out, in satoshis
-    #[serde(serialize_with = "crate::chainstate::stacks::address::pox_addr_b58_serialize")]
-    #[serde(deserialize_with = "crate::chainstate::stacks::address::pox_addr_b58_deser")]
-    pub recipient: PoxAddress, // Address to receive the BTC when the request is fulfilled
-    pub signature: MessageSignature, // Signature from sBTC owner as per SIP-021
-    #[serde(serialize_with = "crate::chainstate::stacks::address::pox_addr_b58_serialize")]
-    #[serde(deserialize_with = "crate::chainstate::stacks::address::pox_addr_b58_deser")]
-    pub peg_wallet_address: PoxAddress,
-    pub fulfillment_fee: u64, // Funding the fulfillment tx fee
-    #[serde(serialize_with = "hex_ser_memo")]
-    #[serde(deserialize_with = "hex_deser_memo")]
-    pub memo: Vec<u8>, // extra unused bytes
-
-    // common to all transactions
-    pub txid: Txid,        // transaction ID
-    pub vtxindex: u32,     // index in the block where this tx occurs
-    pub block_height: u64, // block height at which this tx occurs
-    #[serde(deserialize_with = "hex_deserialize", serialize_with = "hex_serialize")]
-    pub burn_header_hash: BurnchainHeaderHash, // hash of the burn chain block header
-}
-
-#[derive(Debug, PartialEq, Clone, Eq, Serialize, Deserialize)]
-pub struct PegOutFulfillOp {
-    pub chain_tip: StacksBlockId, // The Stacks chain tip whose state view was used to validate the peg-out request
-
-    pub amount: u64, // Transferred BTC amount, in satoshis
-    #[serde(serialize_with = "crate::chainstate::stacks::address::pox_addr_b58_serialize")]
-    #[serde(deserialize_with = "crate::chainstate::stacks::address::pox_addr_b58_deser")]
-    pub recipient: PoxAddress, // Address to receive the BTC
-    pub request_ref: Txid, // The peg out request which is fulfilled by this op
-    #[serde(serialize_with = "hex_ser_memo")]
-    #[serde(deserialize_with = "hex_deser_memo")]
-    pub memo: Vec<u8>, // extra unused bytes
-
-    // common to all transactions
-    pub txid: Txid,        // transaction ID
-    pub vtxindex: u32,     // index in the block where this tx occurs
-    pub block_height: u64, // block height at which this tx occurs
-    #[serde(deserialize_with = "hex_deserialize", serialize_with = "hex_serialize")]
-    pub burn_header_hash: BurnchainHeaderHash, // hash of the burn chain block header
-}
-
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub enum BlockstackOperationType {
     LeaderKeyRegister(LeaderKeyRegisterOp),
@@ -416,9 +348,6 @@ pub enum BlockstackOperationType {
     StackStx(StackStxOp),
     TransferStx(TransferStxOp),
     DelegateStx(DelegateStxOp),
-    PegIn(PegInOp),
-    PegOutRequest(PegOutRequestOp),
-    PegOutFulfill(PegOutFulfillOp),
 }
 
 // serialization helpers for blockstack_op_to_json function
@@ -446,9 +375,6 @@ impl BlockstackOperationType {
             BlockstackOperationType::PreStx(_) => Opcodes::PreStx,
             BlockstackOperationType::TransferStx(_) => Opcodes::TransferStx,
             BlockstackOperationType::DelegateStx(_) => Opcodes::DelegateStx,
-            BlockstackOperationType::PegIn(_) => Opcodes::PegIn,
-            BlockstackOperationType::PegOutRequest(_) => Opcodes::PegOutRequest,
-            BlockstackOperationType::PegOutFulfill(_) => Opcodes::PegOutFulfill,
         }
     }
 
@@ -465,9 +391,6 @@ impl BlockstackOperationType {
             BlockstackOperationType::PreStx(ref data) => &data.txid,
             BlockstackOperationType::TransferStx(ref data) => &data.txid,
             BlockstackOperationType::DelegateStx(ref data) => &data.txid,
-            BlockstackOperationType::PegIn(ref data) => &data.txid,
-            BlockstackOperationType::PegOutRequest(ref data) => &data.txid,
-            BlockstackOperationType::PegOutFulfill(ref data) => &data.txid,
         }
     }
 
@@ -480,9 +403,6 @@ impl BlockstackOperationType {
             BlockstackOperationType::PreStx(ref data) => data.vtxindex,
             BlockstackOperationType::TransferStx(ref data) => data.vtxindex,
             BlockstackOperationType::DelegateStx(ref data) => data.vtxindex,
-            BlockstackOperationType::PegIn(ref data) => data.vtxindex,
-            BlockstackOperationType::PegOutRequest(ref data) => data.vtxindex,
-            BlockstackOperationType::PegOutFulfill(ref data) => data.vtxindex,
         }
     }
 
@@ -495,9 +415,6 @@ impl BlockstackOperationType {
             BlockstackOperationType::PreStx(ref data) => data.block_height,
             BlockstackOperationType::TransferStx(ref data) => data.block_height,
             BlockstackOperationType::DelegateStx(ref data) => data.block_height,
-            BlockstackOperationType::PegIn(ref data) => data.block_height,
-            BlockstackOperationType::PegOutRequest(ref data) => data.block_height,
-            BlockstackOperationType::PegOutFulfill(ref data) => data.block_height,
         }
     }
 
@@ -510,9 +427,6 @@ impl BlockstackOperationType {
             BlockstackOperationType::PreStx(ref data) => data.burn_header_hash.clone(),
             BlockstackOperationType::TransferStx(ref data) => data.burn_header_hash.clone(),
             BlockstackOperationType::DelegateStx(ref data) => data.burn_header_hash.clone(),
-            BlockstackOperationType::PegIn(ref data) => data.burn_header_hash.clone(),
-            BlockstackOperationType::PegOutRequest(ref data) => data.burn_header_hash.clone(),
-            BlockstackOperationType::PegOutFulfill(ref data) => data.burn_header_hash.clone(),
         }
     }
 
@@ -528,9 +442,6 @@ impl BlockstackOperationType {
             BlockstackOperationType::PreStx(ref mut data) => data.block_height = height,
             BlockstackOperationType::TransferStx(ref mut data) => data.block_height = height,
             BlockstackOperationType::DelegateStx(ref mut data) => data.block_height = height,
-            BlockstackOperationType::PegIn(ref mut data) => data.block_height = height,
-            BlockstackOperationType::PegOutRequest(ref mut data) => data.block_height = height,
-            BlockstackOperationType::PegOutFulfill(ref mut data) => data.block_height = height,
         };
     }
 
@@ -548,9 +459,6 @@ impl BlockstackOperationType {
             BlockstackOperationType::PreStx(ref mut data) => data.burn_header_hash = hash,
             BlockstackOperationType::TransferStx(ref mut data) => data.burn_header_hash = hash,
             BlockstackOperationType::DelegateStx(ref mut data) => data.burn_header_hash = hash,
-            BlockstackOperationType::PegIn(ref mut data) => data.burn_header_hash = hash,
-            BlockstackOperationType::PegOutRequest(ref mut data) => data.burn_header_hash = hash,
-            BlockstackOperationType::PegOutFulfill(ref mut data) => data.burn_header_hash = hash,
         };
     }
 
@@ -624,9 +532,6 @@ impl BlockstackOperationType {
             BlockstackOperationType::StackStx(op) => Self::stack_stx_to_json(op),
             BlockstackOperationType::TransferStx(op) => Self::transfer_stx_to_json(op),
             BlockstackOperationType::DelegateStx(op) => Self::delegate_stx_to_json(op),
-            BlockstackOperationType::PegIn(op) => json!({ "peg_in": op }),
-            BlockstackOperationType::PegOutRequest(op) => json!({ "peg_out_request": op }),
-            BlockstackOperationType::PegOutFulfill(op) => json!({ "peg_out_fulfill": op }),
             // json serialization for the remaining op types is not implemented for now. This function
             // is currently only used to json-ify burnchain ops executed as Stacks transactions (so,
             // stack_stx, transfer_stx, and delegate_stx).
@@ -645,9 +550,6 @@ impl fmt::Display for BlockstackOperationType {
             BlockstackOperationType::UserBurnSupport(ref op) => write!(f, "{:?}", op),
             BlockstackOperationType::TransferStx(ref op) => write!(f, "{:?}", op),
             BlockstackOperationType::DelegateStx(ref op) => write!(f, "{:?}", op),
-            BlockstackOperationType::PegIn(ref op) => write!(f, "{:?}", op),
-            BlockstackOperationType::PegOutRequest(ref op) => write!(f, "{:?}", op),
-            BlockstackOperationType::PegOutFulfill(ref op) => write!(f, "{:?}", op),
         }
     }
 }
diff --git a/stackslib/src/chainstate/burn/operations/peg_in.rs b/stackslib/src/chainstate/burn/operations/peg_in.rs
deleted file mode 100644
index d1322b17f0..0000000000
--- a/stackslib/src/chainstate/burn/operations/peg_in.rs
+++ /dev/null
@@ -1,451 +0,0 @@
-// Copyright (C) 2020 Stacks Open Internet Foundation
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-use clarity::vm::errors::RuntimeErrorType as ClarityRuntimeError;
-use clarity::vm::types::{PrincipalData, QualifiedContractIdentifier, StandardPrincipalData};
-use clarity::vm::ContractName;
-use stacks_common::codec::StacksMessageCodec;
-
-use crate::burnchains::{BurnchainBlockHeader, BurnchainTransaction};
-use crate::chainstate::burn::operations::{Error as OpError, PegInOp};
-use crate::chainstate::burn::Opcodes;
-use crate::types::chainstate::StacksAddress;
-use crate::types::Address;
-
-/// Transaction structure:
-///
-/// Output 0: data output (see PegInOp::parse_data())
-/// Output 1: payment to peg wallet address
-///
-impl PegInOp {
-    pub fn from_tx(
-        block_header: &BurnchainBlockHeader,
-        tx: &BurnchainTransaction,
-    ) -> Result<Self, OpError> {
-        if tx.opcode() != Opcodes::PegIn as u8 {
-            warn!("Invalid tx: invalid opcode {}", tx.opcode());
-            return Err(OpError::InvalidInput);
-        }
-
-        let (amount, peg_wallet_address) =
-            if let Some(Some(recipient)) = tx.get_recipients().first() {
-                (recipient.amount, recipient.address.clone())
-            } else {
-                warn!("Invalid tx: First output not recognized");
-                return Err(OpError::InvalidInput);
-            };
-
-        let parsed_data = Self::parse_data(&tx.data())?;
-
-        let txid = tx.txid();
-        let vtxindex = tx.vtxindex();
-        let block_height = block_header.block_height;
-        let burn_header_hash = block_header.block_hash;
-
-        Ok(Self {
-            recipient: parsed_data.recipient,
-            peg_wallet_address,
-            amount,
-            memo: parsed_data.memo,
-            txid,
-            vtxindex,
-            block_height,
-            burn_header_hash,
-        })
-    }
-
-    fn parse_data(data: &[u8]) -> Result<ParsedData, ParseError> {
-        /*
-            Wire format:
-
-            0      2  3                  24                            64       80
-            |------|--|------------------|-----------------------------|--------|
-             magic  op   Stacks address      Contract name (optional)     memo
-
-             Note that `data` is missing the first 3 bytes -- the magic and op must
-             be stripped before this method is called. At the time of writing,
-             this is done in `burnchains::bitcoin::blocks::BitcoinBlockParser::parse_data`.
-        */
-
-        if data.len() < 21 {
-            warn!(
-                "PegInOp payload is malformed ({} bytes, expected at least {})",
-                data.len(),
-                21
-            );
-            return Err(ParseError::MalformedData);
-        }
-
-        let version = *data.get(0).expect("No version byte");
-        let address_data: [u8; 20] = data
-            .get(1..21)
-            .ok_or(ParseError::MalformedData)?
-            .try_into()?;
-
-        let standard_principal_data = StandardPrincipalData(version, address_data);
-
-        let memo = data.get(61..).unwrap_or(&[]).to_vec();
-
-        let recipient: PrincipalData =
-            if let Some(contract_bytes) = Self::leading_non_zero_bytes(data, 21, 61) {
-                let contract_name: String = std::str::from_utf8(contract_bytes)?.to_owned();
-
-                QualifiedContractIdentifier::new(standard_principal_data, contract_name.try_into()?)
-                    .into()
-            } else {
-                standard_principal_data.into()
-            };
-
-        Ok(ParsedData { recipient, memo })
-    }
-
-    pub fn check(&self) -> Result<(), OpError> {
-        if self.amount == 0 {
-            warn!("PEG_IN Invalid: Peg amount must be positive");
-            return Err(OpError::AmountMustBePositive);
-        }
-
-        Ok(())
-    }
-
-    /// Returns the leading non-zero bytes of the subslice `data[from..to]`
-    ///
-    /// # Panics
-    ///
-    /// Panics if `from` is larger than or equal to `to`
-    fn leading_non_zero_bytes(data: &[u8], from: usize, to: usize) -> Option<&[u8]> {
-        assert!(from < to);
-
-        let end_of_non_zero_slice = {
-            let mut end = to.min(data.len());
-            for i in from..end {
-                if data[i] == 0 {
-                    end = i;
-                    break;
-                }
-            }
-            end
-        };
-
-        if from == end_of_non_zero_slice {
-            return None;
-        }
-
-        data.get(from..end_of_non_zero_slice)
-    }
-}
-
-struct ParsedData {
-    recipient: PrincipalData,
-    memo: Vec<u8>,
-}
-
-enum ParseError {
-    BadContractName,
-    MalformedData,
-    Utf8Error,
-}
-
-impl From<ParseError> for OpError {
-    fn from(_: ParseError) -> Self {
-        Self::ParseError
-    }
-}
-
-impl From<std::str::Utf8Error> for ParseError {
-    fn from(_: std::str::Utf8Error) -> Self {
-        Self::Utf8Error
-    }
-}
-
-impl From<std::array::TryFromSliceError> for ParseError {
-    fn from(_: std::array::TryFromSliceError) -> Self {
-        Self::MalformedData
-    }
-}
-
-impl From<ClarityRuntimeError> for ParseError {
-    fn from(_: ClarityRuntimeError) -> Self {
-        Self::BadContractName
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::chainstate::burn::operations::test;
-
-    #[test]
-    fn test_parse_peg_in_should_succeed_given_a_conforming_transaction_without_memo() {
-        let mut rng = test::seeded_rng();
-        let opcode = Opcodes::PegIn;
-
-        let peg_wallet_address = test::random_bytes(&mut rng);
-        let amount = 10;
-        let output2 = test::Output::new(amount, peg_wallet_address);
-
-        let mut data = vec![1];
-        let addr_bytes = test::random_bytes(&mut rng);
-        let stx_address = StacksAddress::new(1, addr_bytes.into());
-        data.extend_from_slice(&addr_bytes);
-
-        let tx = test::burnchain_transaction(data, Some(output2), opcode);
-        let header = test::burnchain_block_header();
-
-        let op = PegInOp::from_tx(&header, &tx).expect("Failed to construct peg-in operation");
-
-        assert_eq!(op.recipient, stx_address.into());
-        assert_eq!(op.amount, amount);
-        assert_eq!(op.peg_wallet_address.bytes(), peg_wallet_address);
-    }
-
-    #[test]
-    fn test_parse_peg_in_should_succeed_given_a_conforming_transaction_with_memo() {
-        let mut rng = test::seeded_rng();
-        let opcode = Opcodes::PegIn;
-
-        let peg_wallet_address = test::random_bytes(&mut rng);
-        let amount = 10;
-        let output2 = test::Output::new(amount, peg_wallet_address);
-        let memo: [u8; 6] = test::random_bytes(&mut rng);
-
-        let mut data = vec![1];
-        let addr_bytes = test::random_bytes(&mut rng);
-        let stx_address = StacksAddress::new(1, addr_bytes.into());
-        data.extend_from_slice(&addr_bytes);
-        data.extend_from_slice(&[0; 40]); // Padding contract name
-        data.extend_from_slice(&memo);
-
-        let tx = test::burnchain_transaction(data, Some(output2), opcode);
-        let header = test::burnchain_block_header();
-
-        let op = PegInOp::from_tx(&header, &tx).expect("Failed to construct peg-in operation");
-
-        assert_eq!(op.recipient, stx_address.into());
-        assert_eq!(op.amount, amount);
-        assert_eq!(op.peg_wallet_address.bytes(), peg_wallet_address);
-        assert_eq!(op.memo.as_slice(), memo)
-    }
-
-    #[test]
-    fn test_parse_peg_in_should_succeed_given_a_contract_recipient() {
-        let mut rng = test::seeded_rng();
-        let opcode = Opcodes::PegIn;
-
-        let contract_name = "This_is_a_valid_contract_name";
-        let peg_wallet_address = test::random_bytes(&mut rng);
-        let amount = 10;
-        let output2 = test::Output::new(amount, peg_wallet_address);
-        let memo: [u8; 6] = test::random_bytes(&mut rng);
-
-        let mut data = vec![1];
-        let addr_bytes = test::random_bytes(&mut rng);
-        let stx_address = StacksAddress::new(1, addr_bytes.into());
-        data.extend_from_slice(&addr_bytes);
-        data.extend_from_slice(contract_name.as_bytes());
-        data.extend_from_slice(&[0; 11]); // Padding contract name
-        data.extend_from_slice(&memo);
-
-        let tx = test::burnchain_transaction(data, Some(output2), opcode);
-        let header = test::burnchain_block_header();
-
-        let op = PegInOp::from_tx(&header, &tx).expect("Failed to construct peg-in operation");
-
-        let expected_principal =
-            QualifiedContractIdentifier::new(stx_address.into(), contract_name.into()).into();
-
-        assert_eq!(op.recipient, expected_principal);
-        assert_eq!(op.amount, amount);
-        assert_eq!(op.peg_wallet_address.bytes(), peg_wallet_address);
-        assert_eq!(op.memo.as_slice(), memo)
-    }
-
-    #[test]
-    fn test_parse_peg_in_should_return_error_given_invalid_contract_name() {
-        let mut rng = test::seeded_rng();
-        let opcode = Opcodes::PegIn;
-
-        let contract_name = "Mårten_is_not_a_valid_contract_name";
-        let peg_wallet_address = test::random_bytes(&mut rng);
-        let amount = 10;
-        let output2 = test::Output::new(amount, peg_wallet_address);
-        let memo: [u8; 6] = test::random_bytes(&mut rng);
-
-        let mut data = vec![1];
-        let addr_bytes = test::random_bytes(&mut rng);
-        let stx_address = StacksAddress::new(1, addr_bytes.into());
-        data.extend_from_slice(&addr_bytes);
-        data.extend_from_slice(contract_name.as_bytes());
-        data.extend_from_slice(&[0; 4]); // Padding contract name
-        data.extend_from_slice(&memo);
-
-        let tx = test::burnchain_transaction(data, Some(output2), opcode);
-        let header = test::burnchain_block_header();
-
-        let op = PegInOp::from_tx(&header, &tx);
-
-        match op {
-            Err(OpError::ParseError) => (),
-            result => panic!("Expected OpError::ParseError, got {:?}", result),
-        }
-    }
-
-    #[test]
-    fn test_parse_peg_in_should_return_error_given_wrong_opcode() {
-        let mut rng = test::seeded_rng();
-        let opcode = Opcodes::StackStx;
-
-        let peg_wallet_address = test::random_bytes(&mut rng);
-        let amount = 10;
-
-        let output2 = test::Output::new(amount, peg_wallet_address);
-        let memo: [u8; 6] = test::random_bytes(&mut rng);
-
-        let mut data = vec![1];
-        let addr_bytes: [u8; 20] = test::random_bytes(&mut rng);
-        data.extend_from_slice(&addr_bytes);
-        data.extend_from_slice(&[0; 40]); // Padding contract name
-        data.extend_from_slice(&memo);
-
-        let tx = test::burnchain_transaction(data, Some(output2), opcode);
-        let header = test::burnchain_block_header();
-
-        let op = PegInOp::from_tx(&header, &tx);
-
-        match op {
-            Err(OpError::InvalidInput) => (),
-            result => panic!("Expected OpError::InvalidInput, got {:?}", result),
-        }
-    }
-
-    #[test]
-    fn test_parse_peg_in_should_return_error_given_invalid_utf8_contract_name() {
-        let invalid_utf8_byte_sequence = [255, 255];
-
-        let mut rng = test::seeded_rng();
-        let opcode = Opcodes::PegIn;
-
-        let peg_wallet_address = test::random_bytes(&mut rng);
-        let amount = 10;
-        let output2 = test::Output::new(amount, peg_wallet_address);
-        let memo: [u8; 6] = test::random_bytes(&mut rng);
-
-        let mut data = vec![1];
-        let addr_bytes: [u8; 20] = test::random_bytes(&mut rng);
-        data.extend_from_slice(&addr_bytes);
-        data.extend_from_slice(&invalid_utf8_byte_sequence);
-        data.extend_from_slice(&[0; 40]); // Padding contract name
-        data.extend_from_slice(&memo);
-
-        let tx = test::burnchain_transaction(data, Some(output2), opcode);
-        let header = test::burnchain_block_header();
-
-        let op = PegInOp::from_tx(&header, &tx);
-
-        match op {
-            Err(OpError::ParseError) => (),
-            result => panic!("Expected OpError::ParseError, got {:?}", result),
-        }
-    }
-
-    #[test]
-    fn test_parse_peg_in_should_return_error_given_no_second_output() {
-        let mut rng = test::seeded_rng();
-        let opcode = Opcodes::PegIn;
-
-        let memo: [u8; 6] = test::random_bytes(&mut rng);
-
-        let mut data = vec![1];
-        let addr_bytes: [u8; 20] = test::random_bytes(&mut rng);
-        data.extend_from_slice(&addr_bytes);
-        data.extend_from_slice(&[0; 40]); // Padding contract name
-        data.extend_from_slice(&memo);
-
-        let tx = test::burnchain_transaction(data, None, opcode);
-        let header = test::burnchain_block_header();
-
-        let op = PegInOp::from_tx(&header, &tx);
-
-        match op {
-            Err(OpError::InvalidInput) => (),
-            result => panic!("Expected OpError::InvalidInput, got {:?}", result),
-        }
-    }
-
-    #[test]
-    fn test_parse_peg_in_should_return_error_given_too_short_data_array() {
-        let mut rng = test::seeded_rng();
-        let opcode = Opcodes::PegIn;
-
-        let peg_wallet_address = test::random_bytes(&mut rng);
-        let amount = 10;
-        let output2 = test::Output::new(amount, peg_wallet_address);
-
-        let mut data = vec![1];
-        let addr_bytes: [u8; 19] = test::random_bytes(&mut rng);
-        data.extend_from_slice(&addr_bytes);
-
-        let tx = test::burnchain_transaction(data, Some(output2), opcode);
-        let header = test::burnchain_block_header();
-
-        let op = PegInOp::from_tx(&header, &tx);
-
-        match op {
-            Err(OpError::ParseError) => (),
-            result => panic!("Expected OpError::InvalidInput, got {:?}", result),
-        }
-    }
-
-    #[test]
-    fn test_check_should_return_error_on_zero_amount_and_ok_on_any_other_values() {
-        let mut rng = test::seeded_rng();
-
-        let peg_wallet_address = test::random_bytes(&mut rng);
-        let memo: [u8; 6] = test::random_bytes(&mut rng);
-
-        let mut data = vec![1];
-        let addr_bytes = test::random_bytes(&mut rng);
-        let stx_address = StacksAddress::new(1, addr_bytes.into());
-        data.extend_from_slice(&addr_bytes);
-        data.extend_from_slice(&[0; 40]); // Padding contract name
-        data.extend_from_slice(&memo);
-
-        let create_op = move |amount| {
-            let opcode = Opcodes::PegIn;
-            let output2 = test::Output::new(amount, peg_wallet_address.clone());
-
-            let tx = test::burnchain_transaction(data.clone(), Some(output2), opcode);
-            let header = test::burnchain_block_header();
-
-            PegInOp::from_tx(&header, &tx).expect("Failed to construct peg-in operation")
-        };
-
-        match create_op(0).check() {
-            Err(OpError::AmountMustBePositive) => (),
-            result => panic!(
-                "Expected OpError::PegInAmountMustBePositive, got {:?}",
-                result
-            ),
-        };
-
-        create_op(1)
-            .check()
-            .expect("Any strictly positive amounts should be ok");
-
-        create_op(u64::MAX)
-            .check()
-            .expect("Any strictly positive amounts should be ok");
-    }
-}
diff --git a/stackslib/src/chainstate/burn/operations/peg_out_fulfill.rs b/stackslib/src/chainstate/burn/operations/peg_out_fulfill.rs
deleted file mode 100644
index 9f4de13139..0000000000
--- a/stackslib/src/chainstate/burn/operations/peg_out_fulfill.rs
+++ /dev/null
@@ -1,308 +0,0 @@
-// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
-// Copyright (C) 2020 Stacks Open Internet Foundation
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-use stacks_common::codec::StacksMessageCodec;
-use stacks_common::types::chainstate::StacksBlockId;
-
-use crate::burnchains::{BurnchainBlockHeader, BurnchainTransaction, Txid};
-use crate::chainstate::burn::operations::{Error as OpError, PegOutFulfillOp};
-use crate::chainstate::burn::Opcodes;
-use crate::types::chainstate::StacksAddress;
-use crate::types::Address;
-
-/// Transaction structure:
-///
-/// Input 0: The 2nd output of a PegOutRequestOp, spent by the peg wallet (to pay the tx fee)
-///
-/// Output 0: data output (see PegOutFulfillOp::parse_data())
-/// Output 1: Bitcoin address to send the BTC to
-///
-impl PegOutFulfillOp {
-    pub fn from_tx(
-        block_header: &BurnchainBlockHeader,
-        tx: &BurnchainTransaction,
-    ) -> Result<Self, OpError> {
-        if tx.opcode() != Opcodes::PegOutFulfill as u8 {
-            warn!("Invalid tx: invalid opcode {}", tx.opcode());
-            return Err(OpError::InvalidInput);
-        }
-
-        let (amount, recipient) = if let Some(Some(recipient)) = tx.get_recipients().first() {
-            (recipient.amount, recipient.address.clone())
-        } else {
-            warn!("Invalid tx: First output not recognized");
-            return Err(OpError::InvalidInput);
-        };
-
-        let ParsedData { chain_tip, memo } = Self::parse_data(&tx.data())?;
-
-        let txid = tx.txid();
-        let vtxindex = tx.vtxindex();
-        let block_height = block_header.block_height;
-        let burn_header_hash = block_header.block_hash;
-
-        let request_ref = Self::get_sender_txid(tx)?;
-
-        Ok(Self {
-            chain_tip,
-            amount,
-            recipient,
-            memo,
-            request_ref,
-            txid,
-            vtxindex,
-            block_height,
-            burn_header_hash,
-        })
-    }
-
-    fn parse_data(data: &[u8]) -> Result<ParsedData, ParseError> {
-        /*
-            Wire format:
-
-            0      2  3                     35                       80
-            |------|--|---------------------|------------------------|
-             magic  op       Chain tip                  Memo
-
-             Note that `data` is missing the first 3 bytes -- the magic and op must
-             be stripped before this method is called. At the time of writing,
-             this is done in `burnchains::bitcoin::blocks::BitcoinBlockParser::parse_data`.
-        */
-
-        if data.len() < 32 {
-            warn!(
-                "PegInOp payload is malformed ({} bytes, expected at least {})",
-                data.len(),
-                32
-            );
-            return Err(ParseError::MalformedData);
-        }
-
-        let chain_tip = StacksBlockId::from_bytes(&data[..32])
-            .expect("PegOutFulfillment chain tip data failed to convert to block ID");
-        let memo = data.get(32..).unwrap_or(&[]).to_vec();
-
-        Ok(ParsedData { chain_tip, memo })
-    }
-
-    fn get_sender_txid(tx: &BurnchainTransaction) -> Result<Txid, ParseError> {
-        match tx.get_input_tx_ref(0) {
-            Some(&(tx_ref, vout)) => {
-                if vout != 2 {
-                    warn!(
-                        "Invalid tx: PegOutFulfillOp must spend the third output of the PegOutRequestOp"
-                    );
-                    Err(ParseError::InvalidInput)
-                } else {
-                    Ok(tx_ref)
-                }
-            }
-            None => {
-                warn!("Invalid tx: PegOutFulfillOp must have at least one input");
-                Err(ParseError::InvalidInput)
-            }
-        }
-    }
-
-    pub fn check(&self) -> Result<(), OpError> {
-        if self.amount == 0 {
-            warn!("PEG_OUT_FULFILLMENT Invalid: Transferred amount must be positive");
-            return Err(OpError::AmountMustBePositive);
-        }
-
-        Ok(())
-    }
-}
-
-struct ParsedData {
-    chain_tip: StacksBlockId,
-    memo: Vec<u8>,
-}
-
-enum ParseError {
-    MalformedData,
-    InvalidInput,
-}
-
-impl From<ParseError> for OpError {
-    fn from(_: ParseError) -> Self {
-        Self::ParseError
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::chainstate::burn::operations::test;
-
-    #[test]
-    fn test_parse_peg_out_fulfill_should_succeed_given_a_conforming_transaction() {
-        let mut rng = test::seeded_rng();
-        let opcode = Opcodes::PegOutFulfill;
-
-        let amount = 1;
-        let recipient_address_bytes = test::random_bytes(&mut rng);
-        let output2 = test::Output::new(amount, recipient_address_bytes);
-
-        let mut data = vec![];
-        let chain_tip_bytes: [u8; 32] = test::random_bytes(&mut rng);
-        data.extend_from_slice(&chain_tip_bytes);
-
-        let tx = test::burnchain_transaction(data, Some(output2), opcode);
-        let header = test::burnchain_block_header();
-
-        let op =
-            PegOutFulfillOp::from_tx(&header, &tx).expect("Failed to construct peg-out operation");
-
-        assert_eq!(op.recipient.bytes(), recipient_address_bytes);
-        assert_eq!(op.chain_tip.as_bytes(), &chain_tip_bytes);
-        assert_eq!(op.amount, amount);
-    }
-
-    #[test]
-    fn test_parse_peg_out_fulfill_should_succeed_given_a_conforming_transaction_with_extra_memo_bytes(
-    ) {
-        let mut rng = test::seeded_rng();
-        let opcode = Opcodes::PegOutFulfill;
-
-        let amount = 1;
-        let recipient_address_bytes = test::random_bytes(&mut rng);
-        let output2 = test::Output::new(amount, recipient_address_bytes);
-
-        let mut data = vec![];
-        let chain_tip_bytes: [u8; 32] = test::random_bytes(&mut rng);
-        data.extend_from_slice(&chain_tip_bytes);
-        let memo_bytes: [u8; 17] = test::random_bytes(&mut rng);
-        data.extend_from_slice(&memo_bytes);
-
-        let tx = test::burnchain_transaction(data, Some(output2), opcode);
-        let header = test::burnchain_block_header();
-
-        let op =
-            PegOutFulfillOp::from_tx(&header, &tx).expect("Failed to construct peg-out operation");
-
-        assert_eq!(op.recipient.bytes(), recipient_address_bytes);
-        assert_eq!(op.chain_tip.as_bytes(), &chain_tip_bytes);
-        assert_eq!(&op.memo, &memo_bytes);
-        assert_eq!(op.amount, amount);
-    }
-
-    #[test]
-    fn test_parse_peg_out_fulfill_should_return_error_given_wrong_opcode() {
-        let mut rng = test::seeded_rng();
-        let opcode = Opcodes::LeaderKeyRegister;
-
-        let amount = 1;
-        let recipient_address_bytes = test::random_bytes(&mut rng);
-        let output2 = test::Output::new(amount, recipient_address_bytes);
-
-        let mut data = vec![];
-        let chain_tip_bytes: [u8; 32] = test::random_bytes(&mut rng);
-        data.extend_from_slice(&chain_tip_bytes);
-
-        let tx = test::burnchain_transaction(data, Some(output2), opcode);
-        let header = test::burnchain_block_header();
-
-        let op = PegOutFulfillOp::from_tx(&header, &tx);
-
-        match op {
-            Err(OpError::InvalidInput) => (),
-            result => panic!("Expected OpError::InvalidInput, got {:?}", result),
-        }
-    }
-
-    #[test]
-    fn test_parse_peg_out_fulfill_should_return_error_given_no_second_output() {
-        let mut rng = test::seeded_rng();
-        let opcode = Opcodes::PegOutFulfill;
-
-        let output2 = None;
-
-        let mut data = vec![];
-        let chain_tip_bytes: [u8; 32] = test::random_bytes(&mut rng);
-        data.extend_from_slice(&chain_tip_bytes);
-
-        let tx = test::burnchain_transaction(data, output2, opcode);
-        let header = test::burnchain_block_header();
-
-        let op = PegOutFulfillOp::from_tx(&header, &tx);
-
-        match op {
-            Err(OpError::InvalidInput) => (),
-            result => panic!("Expected OpError::InvalidInput, got {:?}", result),
-        }
-    }
-
-    #[test]
-    fn test_parse_peg_out_fulfill_should_return_error_given_too_small_header_hash() {
-        let mut rng = test::seeded_rng();
-        let opcode = Opcodes::PegOutFulfill;
-
-        let amount = 1;
-        let recipient_address_bytes = test::random_bytes(&mut rng);
-        let output2 = test::Output::new(amount, recipient_address_bytes);
-
-        let mut data = vec![];
-        let chain_tip_bytes: [u8; 31] = test::random_bytes(&mut rng);
-        data.extend_from_slice(&chain_tip_bytes);
-
-        let tx = test::burnchain_transaction(data, Some(output2), opcode);
-        let header = test::burnchain_block_header();
-
-        let op = PegOutFulfillOp::from_tx(&header, &tx);
-
-        match op {
-            Err(OpError::ParseError) => (),
-            result => panic!("Expected OpError::ParseError, got {:?}", result),
-        }
-    }
-
-    #[test]
-    fn test_parse_peg_out_fulfill_should_return_error_on_zero_amount_and_ok_on_any_other_values() {
-        let mut rng = test::seeded_rng();
-
-        let mut data = vec![];
-        let chain_tip_bytes: [u8; 32] = test::random_bytes(&mut rng);
-        data.extend_from_slice(&chain_tip_bytes);
-
-        let mut create_op = move |amount| {
-            let opcode = Opcodes::PegOutFulfill;
-            let recipient_address_bytes = test::random_bytes(&mut rng);
-            let output2 = test::Output::new(amount, recipient_address_bytes);
-
-            let tx = test::burnchain_transaction(data.clone(), Some(output2), opcode);
-            let header = test::burnchain_block_header();
-
-            PegOutFulfillOp::from_tx(&header, &tx).expect("Failed to construct peg-in operation")
-        };
-
-        match create_op(0).check() {
-            Err(OpError::AmountMustBePositive) => (),
-            result => panic!(
-                "Expected OpError::PegInAmountMustBePositive, got {:?}",
-                result
-            ),
-        };
-
-        create_op(1)
-            .check()
-            .expect("Any strictly positive amounts should be ok");
-
-        create_op(u64::MAX)
-            .check()
-            .expect("Any strictly positive amounts should be ok");
-    }
-}
diff --git a/stackslib/src/chainstate/burn/operations/peg_out_request.rs b/stackslib/src/chainstate/burn/operations/peg_out_request.rs
deleted file mode 100644
index 459c5a4a25..0000000000
--- a/stackslib/src/chainstate/burn/operations/peg_out_request.rs
+++ /dev/null
@@ -1,620 +0,0 @@
-// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
-// Copyright (C) 2020 Stacks Open Internet Foundation
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-use stacks_common::address::{public_keys_to_address_hash, AddressHashMode};
-use stacks_common::codec::StacksMessageCodec;
-use stacks_common::types::chainstate::StacksPublicKey;
-use stacks_common::util::hash::Sha256Sum;
-use stacks_common::util::secp256k1::MessageSignature;
-
-use crate::burnchains::{BurnchainBlockHeader, BurnchainTransaction};
-use crate::chainstate::burn::operations::{Error as OpError, PegOutRequestOp};
-use crate::chainstate::burn::Opcodes;
-use crate::types::chainstate::StacksAddress;
-use crate::types::Address;
-
-/// Transaction structure:
-///
-/// Output 0: data output (see PegOutRequestOp::parse_data())
-/// Output 1: Bitcoin address to send the BTC to
-/// Output 2: Bitcoin fee payment to the peg wallet (which the peg wallet will spend on fulfillment)
-///
-impl PegOutRequestOp {
-    pub fn from_tx(
-        block_header: &BurnchainBlockHeader,
-        tx: &BurnchainTransaction,
-    ) -> Result<Self, OpError> {
-        if tx.opcode() != Opcodes::PegOutRequest as u8 {
-            warn!("Invalid tx: invalid opcode {}", tx.opcode());
-            return Err(OpError::InvalidInput);
-        }
-
-        let recipient = if let Some(Some(recipient)) = tx.get_recipients().first() {
-            recipient.address.clone()
-        } else {
-            warn!("Invalid tx: First output not recognized");
-            return Err(OpError::InvalidInput);
-        };
-
-        let (fulfillment_fee, peg_wallet_address) =
-            if let Some(Some(recipient)) = tx.get_recipients().get(1) {
-                (recipient.amount, recipient.address.clone())
-            } else {
-                warn!("Invalid tx: Second output not recognized");
-                return Err(OpError::InvalidInput);
-            };
-
-        let parsed_data = Self::parse_data(&tx.data())?;
-
-        let txid = tx.txid();
-        let vtxindex = tx.vtxindex();
-        let block_height = block_header.block_height;
-        let burn_header_hash = block_header.block_hash;
-
-        Ok(Self {
-            amount: parsed_data.amount,
-            signature: parsed_data.signature,
-            recipient,
-            peg_wallet_address,
-            fulfillment_fee,
-            memo: parsed_data.memo,
-            txid,
-            vtxindex,
-            block_height,
-            burn_header_hash,
-        })
-    }
-
-    fn parse_data(data: &[u8]) -> Result<ParsedData, ParseError> {
-        /*
-            Wire format:
-
-            0      2  3         11                76   80
-            |------|--|---------|-----------------|----|
-             magic  op   amount      signature     memo
-
-             Note that `data` is missing the first 3 bytes -- the magic and op must
-             be stripped before this method is called. At the time of writing,
-             this is done in `burnchains::bitcoin::blocks::BitcoinBlockParser::parse_data`.
-        */
-
-        if data.len() < 73 {
-            // too short
-            warn!(
-                "PegOutRequestOp payload is malformed ({} bytes, expected {})",
-                data.len(),
-                73
-            );
-            return Err(ParseError::MalformedPayload);
-        }
-
-        let amount = u64::from_be_bytes(data[0..8].try_into().unwrap());
-        let signature = MessageSignature::from_bytes(&data[8..73]).unwrap();
-        let memo = data.get(73..).unwrap_or(&[]).to_vec();
-
-        Ok(ParsedData {
-            amount,
-            signature,
-            memo,
-        })
-    }
-
-    /// Recover the stacks address which was used by the sBTC holder to sign
-    /// the amount and recipient fields of this peg out request.
-    pub fn stx_address(&self, version: u8) -> Result<StacksAddress, RecoverError> {
-        let script_pubkey = self.recipient.to_bitcoin_tx_out(0).script_pubkey;
-
-        let mut msg = self.amount.to_be_bytes().to_vec();
-        msg.extend_from_slice(script_pubkey.as_bytes());
-
-        let msg_hash = Sha256Sum::from_data(&msg);
-        let pub_key = StacksPublicKey::recover_to_pubkey(msg_hash.as_bytes(), &self.signature)
-            .map_err(RecoverError::PubKeyRecoveryFailed)?;
-
-        let hash_bits =
-            public_keys_to_address_hash(&AddressHashMode::SerializeP2PKH, 1, &vec![pub_key]);
-        Ok(StacksAddress::new(version, hash_bits))
-    }
-
-    pub fn check(&self) -> Result<(), OpError> {
-        if self.amount == 0 {
-            warn!("PEG_OUT_REQUEST Invalid: Requested BTC amount must be positive");
-            return Err(OpError::AmountMustBePositive);
-        }
-
-        if self.fulfillment_fee == 0 {
-            warn!("PEG_OUT_REQUEST Invalid: Fulfillment fee must be positive");
-            return Err(OpError::AmountMustBePositive);
-        }
-
-        Ok(())
-    }
-}
-
-struct ParsedData {
-    amount: u64,
-    signature: MessageSignature,
-    memo: Vec<u8>,
-}
-
-#[derive(Debug, PartialEq)]
-enum ParseError {
-    MalformedPayload,
-    SliceConversion,
-}
-
-#[derive(Debug, PartialEq)]
-pub enum RecoverError {
-    PubKeyRecoveryFailed(&'static str),
-}
-
-impl From<ParseError> for OpError {
-    fn from(_: ParseError) -> Self {
-        Self::ParseError
-    }
-}
-
-impl From<std::array::TryFromSliceError> for ParseError {
-    fn from(_: std::array::TryFromSliceError) -> Self {
-        Self::SliceConversion
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use stacks_common::deps_common::bitcoin::blockdata::transaction::Transaction;
-    use stacks_common::deps_common::bitcoin::network::serialize::deserialize;
-    use stacks_common::types::chainstate::{BurnchainHeaderHash, StacksPrivateKey};
-    use stacks_common::types::{PrivateKey, StacksEpochId};
-    use stacks_common::util::hash::{hex_bytes, to_hex};
-
-    use super::*;
-    use crate::burnchains::bitcoin::blocks::BitcoinBlockParser;
-    use crate::burnchains::bitcoin::BitcoinNetworkType;
-    use crate::burnchains::{Txid, BLOCKSTACK_MAGIC_MAINNET};
-    use crate::chainstate::burn::operations::test;
-    use crate::chainstate::stacks::address::{PoxAddress, PoxAddressType32};
-    use crate::chainstate::stacks::C32_ADDRESS_VERSION_TESTNET_SINGLESIG;
-
-    #[test]
-    fn test_parse_peg_out_request_should_succeed_given_a_conforming_transaction() {
-        let mut rng = test::seeded_rng();
-        let opcode = Opcodes::PegOutRequest;
-
-        let dust_amount = 1;
-        let recipient_address_bytes = test::random_bytes(&mut rng);
-        let output2 = test::Output::new(dust_amount, recipient_address_bytes);
-
-        let peg_wallet_address = test::random_bytes(&mut rng);
-        let fulfillment_fee = 3;
-        let output3 = test::Output::new(fulfillment_fee, peg_wallet_address);
-
-        let mut data = vec![];
-        let amount: u64 = 10;
-        let signature: [u8; 65] = test::random_bytes(&mut rng);
-        data.extend_from_slice(&amount.to_be_bytes());
-        data.extend_from_slice(&signature);
-
-        let tx = test::burnchain_transaction(data, [output2, output3], opcode);
-        let header = test::burnchain_block_header();
-
-        let op =
-            PegOutRequestOp::from_tx(&header, &tx).expect("Failed to construct peg-out operation");
-
-        assert_eq!(op.recipient.bytes(), recipient_address_bytes);
-        assert_eq!(op.signature.as_bytes(), &signature);
-        assert_eq!(op.amount, amount);
-    }
-
-    #[test]
-    fn test_parse_peg_out_request_should_succeed_given_a_transaction_with_extra_memo_bytes() {
-        let mut rng = test::seeded_rng();
-        let opcode = Opcodes::PegOutRequest;
-
-        let dust_amount = 1;
-        let recipient_address_bytes = test::random_bytes(&mut rng);
-        let output2 = test::Output::new(dust_amount, recipient_address_bytes);
-
-        let peg_wallet_address = test::random_bytes(&mut rng);
-        let fulfillment_fee = 3;
-        let output3 = test::Output::new(fulfillment_fee, peg_wallet_address);
-
-        let mut data = vec![];
-        let amount: u64 = 10;
-        let signature: [u8; 65] = test::random_bytes(&mut rng);
-        data.extend_from_slice(&amount.to_be_bytes());
-        data.extend_from_slice(&signature);
-        let memo_bytes: [u8; 4] = test::random_bytes(&mut rng);
-        data.extend_from_slice(&memo_bytes);
-
-        let tx = test::burnchain_transaction(data, [output2, output3], opcode);
-        let header = test::burnchain_block_header();
-
-        let op =
-            PegOutRequestOp::from_tx(&header, &tx).expect("Failed to construct peg-out operation");
-
-        assert_eq!(op.recipient.bytes(), recipient_address_bytes);
-        assert_eq!(op.signature.as_bytes(), &signature);
-        assert_eq!(&op.memo, &memo_bytes);
-        assert_eq!(op.amount, amount);
-        assert_eq!(op.peg_wallet_address.bytes(), peg_wallet_address);
-        assert_eq!(op.fulfillment_fee, fulfillment_fee);
-    }
-
-    #[test]
-    fn test_parse_peg_out_request_should_return_error_given_wrong_opcode() {
-        let mut rng = test::seeded_rng();
-        let opcode = Opcodes::LeaderKeyRegister;
-
-        let dust_amount = 1;
-        let recipient_address_bytes = test::random_bytes(&mut rng);
-        let output2 = test::Output::new(dust_amount, recipient_address_bytes);
-
-        let peg_wallet_address = test::random_bytes(&mut rng);
-        let fulfillment_fee = 3;
-        let output3 = test::Output::new(fulfillment_fee, peg_wallet_address);
-
-        let mut data = vec![];
-        let amount: u64 = 10;
-        let signature: [u8; 65] = test::random_bytes(&mut rng);
-        data.extend_from_slice(&amount.to_be_bytes());
-        data.extend_from_slice(&signature);
-
-        let tx = test::burnchain_transaction(data, [output2, output3], opcode);
-        let header = test::burnchain_block_header();
-
-        let op = PegOutRequestOp::from_tx(&header, &tx);
-
-        match op {
-            Err(OpError::InvalidInput) => (),
-            result => panic!("Expected OpError::InvalidInput, got {:?}", result),
-        }
-    }
-
-    #[test]
-    fn test_parse_peg_out_request_should_return_error_given_no_outputs() {
-        let mut rng = test::seeded_rng();
-        let opcode = Opcodes::PegOutRequest;
-
-        let mut data = vec![];
-        let amount: u64 = 10;
-        let signature: [u8; 65] = test::random_bytes(&mut rng);
-        data.extend_from_slice(&amount.to_be_bytes());
-        data.extend_from_slice(&signature);
-
-        let tx = test::burnchain_transaction(data, None, opcode);
-        let header = test::burnchain_block_header();
-
-        let op = PegOutRequestOp::from_tx(&header, &tx);
-
-        match op {
-            Err(OpError::InvalidInput) => (),
-            result => panic!("Expected OpError::InvalidInput, got {:?}", result),
-        }
-    }
-
-    #[test]
-    fn test_parse_peg_out_request_should_return_error_given_no_third_output() {
-        let mut rng = test::seeded_rng();
-        let opcode = Opcodes::PegOutRequest;
-
-        let dust_amount = 1;
-        let recipient_address_bytes = test::random_bytes(&mut rng);
-        let output2 = test::Output::new(dust_amount, recipient_address_bytes);
-
-        let mut data = vec![];
-        let amount: u64 = 10;
-        let signature: [u8; 65] = test::random_bytes(&mut rng);
-        data.extend_from_slice(&amount.to_be_bytes());
-        data.extend_from_slice(&signature);
-
-        let tx = test::burnchain_transaction(data, Some(output2), opcode);
-        let header = test::burnchain_block_header();
-
-        let op = PegOutRequestOp::from_tx(&header, &tx);
-
-        match op {
-            Err(OpError::InvalidInput) => (),
-            result => panic!("Expected OpError::InvalidInput, got {:?}", result),
-        }
-    }
-
-    #[test]
-    fn test_parse_peg_out_request_should_return_error_given_no_signature() {
-        let mut rng = test::seeded_rng();
-        let opcode = Opcodes::PegOutRequest;
-
-        let dust_amount = 1;
-        let recipient_address_bytes = test::random_bytes(&mut rng);
-        let output2 = test::Output::new(dust_amount, recipient_address_bytes);
-
-        let peg_wallet_address = test::random_bytes(&mut rng);
-        let fulfillment_fee = 3;
-        let output3 = test::Output::new(fulfillment_fee, peg_wallet_address);
-
-        let mut data = vec![];
-        let amount: u64 = 10;
-        let signature: [u8; 0] = test::random_bytes(&mut rng);
-        data.extend_from_slice(&amount.to_be_bytes());
-        data.extend_from_slice(&signature);
-
-        let tx = test::burnchain_transaction(data, [output2, output3], opcode);
-        let header = test::burnchain_block_header();
-
-        let op = PegOutRequestOp::from_tx(&header, &tx);
-
-        match op {
-            Err(OpError::ParseError) => (),
-            result => panic!("Expected OpError::ParseError, got {:?}", result),
-        }
-    }
-
-    #[test]
-    fn test_parse_peg_out_request_should_return_error_on_zero_amount_and_ok_on_any_other_values() {
-        let mut rng = test::seeded_rng();
-
-        let dust_amount = 1;
-        let recipient_address_bytes = test::random_bytes(&mut rng);
-        let output2 = test::Output::new(dust_amount, recipient_address_bytes);
-
-        let peg_wallet_address = test::random_bytes(&mut rng);
-
-        let mut create_op = move |amount: u64, fulfillment_fee: u64| {
-            let opcode = Opcodes::PegOutRequest;
-
-            let mut data = vec![];
-            let signature: [u8; 65] = test::random_bytes(&mut rng);
-            data.extend_from_slice(&amount.to_be_bytes());
-            data.extend_from_slice(&signature);
-
-            let output3 = test::Output::new(fulfillment_fee, peg_wallet_address.clone());
-
-            let tx = test::burnchain_transaction(data, [output2.clone(), output3.clone()], opcode);
-            let header = test::burnchain_block_header();
-
-            PegOutRequestOp::from_tx(&header, &tx)
-                .expect("Failed to construct peg-out request operation")
-        };
-
-        match create_op(0, 1).check() {
-            Err(OpError::AmountMustBePositive) => (),
-            result => panic!(
-                "Expected OpError::PegInAmountMustBePositive, got {:?}",
-                result
-            ),
-        };
-
-        match create_op(1, 0).check() {
-            Err(OpError::AmountMustBePositive) => (),
-            result => panic!(
-                "Expected OpError::PegInAmountMustBePositive, got {:?}",
-                result
-            ),
-        };
-
-        create_op(1, 1)
-            .check()
-            .expect("Any strictly positive amounts should be ok");
-
-        create_op(u64::MAX, 1)
-            .check()
-            .expect("Any strictly positive amounts should be ok");
-    }
-
-    #[test]
-    fn test_stx_address_should_recover_the_same_address_used_to_sign_the_request() {
-        let mut rng = test::seeded_rng();
-        let opcode = Opcodes::PegOutRequest;
-
-        let private_key = StacksPrivateKey::from_hex(
-            "42faca653724860da7a41bfcef7e6ba78db55146f6900de8cb2a9f760ffac70c01",
-        )
-        .unwrap();
-
-        let stx_address = StacksAddress::from_public_keys(
-            C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
-            &AddressHashMode::SerializeP2PKH,
-            1,
-            &vec![StacksPublicKey::from_private(&private_key)],
-        )
-        .unwrap();
-
-        let dust_amount = 1;
-        let recipient_address_bytes = test::random_bytes(&mut rng);
-        let output2 = test::Output::new(dust_amount, recipient_address_bytes);
-
-        let peg_wallet_address = test::random_bytes(&mut rng);
-        let fulfillment_fee = 3;
-        let output3 = test::Output::new(fulfillment_fee, peg_wallet_address);
-
-        let mut data = vec![];
-        let amount: u64 = 10;
-
-        let mut script_pubkey = vec![81, 32]; // OP_1 OP_PUSHBYTES_32
-        script_pubkey.extend_from_slice(&recipient_address_bytes);
-
-        let mut msg = amount.to_be_bytes().to_vec();
-        msg.extend_from_slice(&script_pubkey);
-
-        let msg_hash = Sha256Sum::from_data(&msg);
-
-        let signature = private_key.sign(msg_hash.as_bytes()).unwrap();
-        data.extend_from_slice(&amount.to_be_bytes());
-        data.extend_from_slice(signature.as_bytes());
-
-        let tx = test::burnchain_transaction(data, [output2, output3], opcode);
-        let header = test::burnchain_block_header();
-
-        let op =
-            PegOutRequestOp::from_tx(&header, &tx).expect("Failed to construct peg-out operation");
-
-        assert_eq!(
-            op.stx_address(C32_ADDRESS_VERSION_TESTNET_SINGLESIG)
-                .unwrap(),
-            stx_address
-        );
-    }
-
-    #[test]
-    fn test_stx_address_should_fail_to_recover_stx_address_if_signature_is_noise() {
-        let mut rng = test::seeded_rng();
-        let opcode = Opcodes::PegOutRequest;
-
-        let private_key = StacksPrivateKey::from_hex(
-            "42faca653724860da7a41bfcef7e6ba78db55146f6900de8cb2a9f760ffac70c01",
-        )
-        .unwrap();
-
-        let stx_address = StacksAddress::from_public_keys(
-            C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
-            &AddressHashMode::SerializeP2PKH,
-            1,
-            &vec![StacksPublicKey::from_private(&private_key)],
-        )
-        .unwrap();
-
-        let dust_amount = 1;
-        let recipient_address_bytes = test::random_bytes(&mut rng);
-        let output2 = test::Output::new(dust_amount, recipient_address_bytes);
-
-        let peg_wallet_address = test::random_bytes(&mut rng);
-        let fulfillment_fee = 3;
-        let output3 = test::Output::new(fulfillment_fee, peg_wallet_address);
-
-        let mut data = vec![];
-        let amount: u64 = 10;
-
-        let mut script_pubkey = vec![81, 32]; // OP_1 OP_PUSHBYTES_32
-        script_pubkey.extend_from_slice(&recipient_address_bytes);
-
-        let mut msg = amount.to_be_bytes().to_vec();
-        msg.extend_from_slice(&script_pubkey);
-
-        let msg_hash = Sha256Sum::from_data(&msg);
-
-        let signature = MessageSignature(test::random_bytes(&mut rng));
-        data.extend_from_slice(&amount.to_be_bytes());
-        data.extend_from_slice(signature.as_bytes());
-
-        let tx = test::burnchain_transaction(data, [output2, output3], opcode);
-        let header = test::burnchain_block_header();
-
-        let op =
-            PegOutRequestOp::from_tx(&header, &tx).expect("Failed to construct peg-out operation");
-
-        assert_eq!(
-            op.stx_address(C32_ADDRESS_VERSION_TESTNET_SINGLESIG)
-                .unwrap_err(),
-            RecoverError::PubKeyRecoveryFailed(
-                "Invalid signature: failed to decode recoverable signature"
-            ),
-        );
-    }
-
-    #[test]
-    fn test_stx_address_with_hard_coded_fixtures() {
-        let vtxindex = 1;
-        let _block_height = 694;
-        let burn_header_hash = BurnchainHeaderHash::from_hex(
-            "0000000000000000000000000000000000000000000000000000000000000000",
-        )
-        .unwrap();
-
-        let fixtures = [
-            OpFixture {
-            txstr: "02000000010000000000000000000000000000000000000000000000000000000000000000ffffffff00ffffffff0300000000000000004f6a4c4c69643e000000000000053900dc18d08e2ee9f476a89c4c195edd402610176bb6264ec56f3f9e42e7386c543846e09282b6f03495c663c8509df7c97ffbcd2adc537bbabe23abd828a52bc8cd390500000000000022512000000000000000000000000000000000000000000000000000000000000000002a00000000000000225120000000000000000000000000000000000000000000000000000000000000000000000000",
-            signer: StacksAddress::from_string("ST3W2ATS1H9RF29DMYW5QP7NYJ643WNP2YFT4Z45C").unwrap(),
-            result: Ok(PegOutRequestOp {
-                amount: 1337,
-                recipient: PoxAddress::Addr32(false, PoxAddressType32::P2TR, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
-                signature: MessageSignature::from_hex("00dc18d08e2ee9f476a89c4c195edd402610176bb6264ec56f3f9e42e7386c543846e09282b6f03495c663c8509df7c97ffbcd2adc537bbabe23abd828a52bc8cd").unwrap(),
-                peg_wallet_address: PoxAddress::Addr32(false, PoxAddressType32::P2TR, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
-                fulfillment_fee: 42, memo: vec![], txid: Txid::from_hex("44a2aea3936f7764b4c089d3245b001069e0961e501fcb0024277ea9dedb2fea").unwrap(),
-                vtxindex: 1,
-                block_height: 0,
-                burn_header_hash: BurnchainHeaderHash::from_hex("0000000000000000000000000000000000000000000000000000000000000000").unwrap() }),
-            },
-            OpFixture {
-            txstr: "02000000010000000000000000000000000000000000000000000000000000000000000000ffffffff00ffffffff030000000000000000536a4c5069643e000000000000053900dc18d08e2ee9f476a89c4c195edd402610176bb6264ec56f3f9e42e7386c543846e09282b6f03495c663c8509df7c97ffbcd2adc537bbabe23abd828a52bc8cddeadbeef390500000000000022512000000000000000000000000000000000000000000000000000000000000000002a00000000000000225120000000000000000000000000000000000000000000000000000000000000000000000000",
-            signer: StacksAddress::from_string("ST3W2ATS1H9RF29DMYW5QP7NYJ643WNP2YFT4Z45C").unwrap(),
-            result: Ok(PegOutRequestOp {
-                amount: 1337,
-                recipient: PoxAddress::Addr32(false, PoxAddressType32::P2TR, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
-                signature: MessageSignature::from_hex("00dc18d08e2ee9f476a89c4c195edd402610176bb6264ec56f3f9e42e7386c543846e09282b6f03495c663c8509df7c97ffbcd2adc537bbabe23abd828a52bc8cd").unwrap(),
-                peg_wallet_address: PoxAddress::Addr32(false, PoxAddressType32::P2TR, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
-                fulfillment_fee: 42, memo: vec![222, 173, 190, 239], txid: Txid::from_hex("7431035f255c4ce215b66883d67e593f392b0b2026c24186e650019872b6f095").unwrap(),
-                vtxindex: 1,
-                block_height: 0,
-                burn_header_hash: BurnchainHeaderHash::from_hex("0000000000000000000000000000000000000000000000000000000000000000").unwrap() }),
-            },
-        ];
-
-        let parser = BitcoinBlockParser::new(BitcoinNetworkType::Testnet, BLOCKSTACK_MAGIC_MAINNET);
-
-        for fixture in fixtures {
-            let tx = make_tx(&fixture.txstr).unwrap();
-            let burnchain_tx = BurnchainTransaction::Bitcoin(
-                parser
-                    .parse_tx(&tx, vtxindex as usize, StacksEpochId::Epoch21)
-                    .unwrap(),
-            );
-
-            let header = match fixture.result {
-                Ok(ref op) => BurnchainBlockHeader {
-                    block_height: op.block_height,
-                    block_hash: op.burn_header_hash.clone(),
-                    parent_block_hash: op.burn_header_hash.clone(),
-                    num_txs: 1,
-                    timestamp: 0,
-                },
-                Err(_) => BurnchainBlockHeader {
-                    block_height: 0,
-                    block_hash: BurnchainHeaderHash::zero(),
-                    parent_block_hash: BurnchainHeaderHash::zero(),
-                    num_txs: 0,
-                    timestamp: 0,
-                },
-            };
-
-            let result = PegOutRequestOp::from_tx(&header, &burnchain_tx);
-
-            match (result, fixture.result) {
-                (Ok(actual), Ok(expected)) => {
-                    assert_eq!(actual, expected);
-                    assert_eq!(
-                        actual
-                            .stx_address(C32_ADDRESS_VERSION_TESTNET_SINGLESIG)
-                            .unwrap(),
-                        fixture.signer
-                    );
-                }
-                _ => panic!("Unsupported test scenario"),
-            }
-        }
-    }
-
-    pub struct OpFixture {
-        txstr: &'static str,
-        signer: StacksAddress,
-        result: Result<PegOutRequestOp, OpError>,
-    }
-
-    fn make_tx(hex_str: &str) -> Result<Transaction, &'static str> {
-        let tx_bin = hex_bytes(hex_str).map_err(|_e| "failed to decode hex string")?;
-        let tx = deserialize(&tx_bin.to_vec()).map_err(|_e| "failed to deserialize")?;
-        Ok(tx)
-    }
-}
diff --git a/stackslib/src/chainstate/burn/operations/test/serialization.rs b/stackslib/src/chainstate/burn/operations/test/serialization.rs
index 7340393e42..768f67b995 100644
--- a/stackslib/src/chainstate/burn/operations/test/serialization.rs
+++ b/stackslib/src/chainstate/burn/operations/test/serialization.rs
@@ -10,11 +10,10 @@ use stacks_common::util::secp256k1::MessageSignature;
 
 use crate::burnchains::Txid;
 use crate::chainstate::burn::operations::{
-    BlockstackOperationType, DelegateStxOp, PegInOp, PegOutFulfillOp, PegOutRequestOp, PreStxOp,
+    BlockstackOperationType, DelegateStxOp, PreStxOp,
     StackStxOp, TransferStxOp,
 };
 use crate::chainstate::stacks::address::{PoxAddress, PoxAddressType32};
-use crate::net::BurnchainOps;
 
 #[test]
 fn test_serialization_transfer_stx_op() {
@@ -178,475 +177,4 @@ fn test_serialization_delegate_stx_op() {
     });
 
     assert_json_diff::assert_json_eq!(serialized_json, constructed_json);
-}
-
-#[test]
-/// Test the serialization and deserialization of PegIn operations in `BurnchainOps`
-///  using JSON string fixtures
-fn serialization_peg_in_in_ops() {
-    let test_cases = [
-        (
-            r#"
-                {
-                    "peg_in": [
-                    {
-                        "amount": 1337,
-                        "block_height": 218,
-                        "burn_header_hash": "3292a7d2a7e941499b5c0dcff2a5656c159010718450948a60c2be9e1c221dc4",
-                        "memo": "0001020304",
-                        "peg_wallet_address": "1111111111111111111114oLvT2",
-                        "recipient": "S0000000000000000000002AA028H.awesome_contract",
-                        "txid": "d81bec73a0ea0bdcf9bc011f567944eb1eae5889bf002bf7ae641d7096157771",
-                        "vtxindex": 2
-                    }
-                    ]
-                }
-            "#,
-            PegInOp {
-                recipient: PrincipalData::parse("S0000000000000000000002AA028H.awesome_contract")
-                    .unwrap(),
-                peg_wallet_address: PoxAddress::Standard(StacksAddress::burn_address(true), None),
-                amount: 1337,
-                memo: vec![0, 1, 2, 3, 4],
-                txid: Txid::from_hex(
-                    "d81bec73a0ea0bdcf9bc011f567944eb1eae5889bf002bf7ae641d7096157771",
-                )
-                .unwrap(),
-                vtxindex: 2,
-                block_height: 218,
-                burn_header_hash: BurnchainHeaderHash::from_hex(
-                    "3292a7d2a7e941499b5c0dcff2a5656c159010718450948a60c2be9e1c221dc4",
-                )
-                .unwrap(),
-            },
-        ),
-        (
-            r#"
-                {
-                    "peg_in": [
-                    {
-                        "amount": 1337,
-                        "block_height": 218,
-                        "burn_header_hash": "3292a7d2a7e941499b5c0dcff2a5656c159010718450948a60c2be9e1c221dc4",
-                        "memo": "",
-                        "peg_wallet_address": "tb1pqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqkgkkf5",
-                        "recipient": "S0000000000000000000002AA028H.awesome_contract",
-                        "txid": "d81bec73a0ea0bdcf9bc011f567944eb1eae5889bf002bf7ae641d7096157771",
-                        "vtxindex": 2
-                    }
-                    ]
-                }
-            "#,
-            PegInOp {
-                recipient: PrincipalData::parse("S0000000000000000000002AA028H.awesome_contract")
-                    .unwrap(),
-                peg_wallet_address: PoxAddress::Addr32(false, PoxAddressType32::P2TR, [0; 32]),
-                amount: 1337,
-                memo: vec![],
-                txid: Txid::from_hex(
-                    "d81bec73a0ea0bdcf9bc011f567944eb1eae5889bf002bf7ae641d7096157771",
-                )
-                .unwrap(),
-                vtxindex: 2,
-                block_height: 218,
-                burn_header_hash: BurnchainHeaderHash::from_hex(
-                    "3292a7d2a7e941499b5c0dcff2a5656c159010718450948a60c2be9e1c221dc4",
-                )
-                .unwrap(),
-            },
-        ),
-        (
-            r#"
-                {
-                    "peg_in": [
-                    {
-                        "amount": 1337,
-                        "block_height": 218,
-                        "burn_header_hash": "3292a7d2a7e941499b5c0dcff2a5656c159010718450948a60c2be9e1c221dc4",
-                        "memo": "",
-                        "peg_wallet_address": "tb1qqvpsxqcrqvpsxqcrqvpsxqcrqvpsxqcrqvpsxqcrqvpsxqcrqvps3f3cyq",
-                        "recipient": "S0000000000000000000002AA028H",
-                        "txid": "d81bec73a0ea0bdcf9bc011f567944eb1eae5889bf002bf7ae641d7096157771",
-                        "vtxindex": 2
-                    }
-                    ]
-                }
-            "#,
-            PegInOp {
-                recipient: PrincipalData::parse("S0000000000000000000002AA028H").unwrap(),
-                peg_wallet_address: PoxAddress::Addr32(false, PoxAddressType32::P2WSH, [3; 32]),
-                amount: 1337,
-                memo: vec![],
-                txid: Txid::from_hex(
-                    "d81bec73a0ea0bdcf9bc011f567944eb1eae5889bf002bf7ae641d7096157771",
-                )
-                .unwrap(),
-                vtxindex: 2,
-                block_height: 218,
-                burn_header_hash: BurnchainHeaderHash::from_hex(
-                    "3292a7d2a7e941499b5c0dcff2a5656c159010718450948a60c2be9e1c221dc4",
-                )
-                .unwrap(),
-            },
-        ),
-    ];
-
-    for (expected_json, op) in test_cases {
-        // Test that op serializes to a JSON value equal to expected_json
-        assert_json_diff::assert_json_eq!(
-            serde_json::from_str::<Value>(expected_json).unwrap(),
-            BurnchainOps::PegIn(vec![op.clone()])
-        );
-
-        // Test that expected JSON deserializes into a BurnchainOps that is equal to op
-        assert_eq!(
-            serde_json::from_str::<BurnchainOps>(expected_json).unwrap(),
-            BurnchainOps::PegIn(vec![op])
-        );
-    }
-}
-
-#[test]
-/// Test the serialization of PegIn operations via
-/// `blockstack_op_to_json()` using JSON string fixtures
-fn serialization_peg_in() {
-    let test_cases = [
-        (
-            r#"
-            {
-                "peg_in":
-                {
-                    "amount": 1337,
-                    "block_height": 218,
-                    "burn_header_hash": "3292a7d2a7e941499b5c0dcff2a5656c159010718450948a60c2be9e1c221dc4",
-                    "memo": "0001020304",
-                    "peg_wallet_address": "1111111111111111111114oLvT2",
-                    "recipient": "S0000000000000000000002AA028H.awesome_contract",
-                    "txid": "d81bec73a0ea0bdcf9bc011f567944eb1eae5889bf002bf7ae641d7096157771",
-                    "vtxindex": 2
-                }
-            }
-        "#,
-            PegInOp {
-                recipient: PrincipalData::parse("S0000000000000000000002AA028H.awesome_contract")
-                    .unwrap(),
-                peg_wallet_address: PoxAddress::standard_burn_address(true),
-                amount: 1337,
-                memo: vec![0, 1, 2, 3, 4],
-                txid: Txid::from_hex(
-                    "d81bec73a0ea0bdcf9bc011f567944eb1eae5889bf002bf7ae641d7096157771",
-                )
-                .unwrap(),
-                vtxindex: 2,
-                block_height: 218,
-                burn_header_hash: BurnchainHeaderHash::from_hex(
-                    "3292a7d2a7e941499b5c0dcff2a5656c159010718450948a60c2be9e1c221dc4",
-                )
-                .unwrap(),
-            },
-        ),
-        (
-            r#"
-            {
-                "peg_in":
-                {
-                    "amount": 1337,
-                    "block_height": 218,
-                    "burn_header_hash": "3292a7d2a7e941499b5c0dcff2a5656c159010718450948a60c2be9e1c221dc4",
-                    "memo": "",
-                    "peg_wallet_address": "tb1pqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqkgkkf5",
-                    "recipient": "S0000000000000000000002AA028H.awesome_contract",
-                    "txid": "d81bec73a0ea0bdcf9bc011f567944eb1eae5889bf002bf7ae641d7096157771",
-                    "vtxindex": 2
-                }
-            }
-            "#,
-            PegInOp {
-                recipient: PrincipalData::parse("S0000000000000000000002AA028H.awesome_contract")
-                    .unwrap(),
-                peg_wallet_address: PoxAddress::Addr32(false, PoxAddressType32::P2TR, [0; 32]),
-                amount: 1337,
-                memo: vec![],
-                txid: Txid::from_hex(
-                    "d81bec73a0ea0bdcf9bc011f567944eb1eae5889bf002bf7ae641d7096157771",
-                )
-                .unwrap(),
-                vtxindex: 2,
-                block_height: 218,
-                burn_header_hash: BurnchainHeaderHash::from_hex(
-                    "3292a7d2a7e941499b5c0dcff2a5656c159010718450948a60c2be9e1c221dc4",
-                )
-                .unwrap(),
-            },
-        ),
-        (
-            r#"
-            {
-                "peg_in":
-                {
-                    "amount": 1337,
-                    "block_height": 218,
-                    "burn_header_hash": "3292a7d2a7e941499b5c0dcff2a5656c159010718450948a60c2be9e1c221dc4",
-                    "memo": "",
-                    "peg_wallet_address": "tb1qqvpsxqcrqvpsxqcrqvpsxqcrqvpsxqcrqvpsxqcrqvpsxqcrqvps3f3cyq",
-                    "recipient": "S0000000000000000000002AA028H",
-                    "txid": "d81bec73a0ea0bdcf9bc011f567944eb1eae5889bf002bf7ae641d7096157771",
-                    "vtxindex": 2
-                }
-            }
-            "#,
-            PegInOp {
-                recipient: PrincipalData::parse("S0000000000000000000002AA028H").unwrap(),
-                peg_wallet_address: PoxAddress::Addr32(false, PoxAddressType32::P2WSH, [3; 32]),
-                amount: 1337,
-                memo: vec![],
-                txid: Txid::from_hex(
-                    "d81bec73a0ea0bdcf9bc011f567944eb1eae5889bf002bf7ae641d7096157771",
-                )
-                .unwrap(),
-                vtxindex: 2,
-                block_height: 218,
-                burn_header_hash: BurnchainHeaderHash::from_hex(
-                    "3292a7d2a7e941499b5c0dcff2a5656c159010718450948a60c2be9e1c221dc4",
-                )
-                .unwrap(),
-            },
-        ),
-    ];
-
-    for (expected_json, op) in test_cases {
-        // Test that op serializes to a JSON value equal to expected_json
-        assert_json_diff::assert_json_eq!(
-            serde_json::from_str::<Value>(expected_json).unwrap(),
-            BlockstackOperationType::PegIn(op).blockstack_op_to_json()
-        );
-    }
-}
-
-#[test]
-/// Test the serialization and deserialization of PegOutRequest operations in `BurnchainOps`
-///  using JSON string fixtures
-fn serialization_peg_out_request_in_ops() {
-    let test_cases = [(
-        r#"
-            {
-                "peg_out_request": [{
-                    "amount": 1337,
-                    "recipient": "1BixGeiRyKT7NTkJAHpWuP197KXUNqhCU9",
-                    "block_height": 218,
-                    "burn_header_hash": "3292a7d2a7e941499b5c0dcff2a5656c159010718450948a60c2be9e1c221dc4",
-                    "peg_wallet_address": "tb1qqvpsxqcrqvpsxqcrqvpsxqcrqvpsxqcrqvpsxqcrqvpsxqcrqvps3f3cyq",
-                    "txid": "d81bec73a0ea0bdcf9bc011f567944eb1eae5889bf002bf7ae641d7096157771",
-                    "vtxindex": 2,
-                    "signature": "0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d",
-                    "fulfillment_fee": 0,
-                    "memo": "00010203"
-                }]
-            }
-        "#,
-        PegOutRequestOp {
-            amount: 1337,
-            recipient: PoxAddress::Standard(
-                StacksAddress::from_string("SP1TT0WQYZMEBX1XJ8QF4BH4A93TWZK7X9R76Z3SZ").unwrap(),
-                None,
-            ),
-            signature: MessageSignature([13; 65]),
-            peg_wallet_address: PoxAddress::Addr32(false, PoxAddressType32::P2WSH, [3; 32]),
-            fulfillment_fee: 0,
-            memo: vec![0, 1, 2, 3],
-            txid: Txid::from_hex(
-                "d81bec73a0ea0bdcf9bc011f567944eb1eae5889bf002bf7ae641d7096157771",
-            )
-            .unwrap(),
-            vtxindex: 2,
-            block_height: 218,
-            burn_header_hash: BurnchainHeaderHash::from_hex(
-                "3292a7d2a7e941499b5c0dcff2a5656c159010718450948a60c2be9e1c221dc4",
-            )
-            .unwrap(),
-        },
-    )];
-
-    for (expected_json, op) in test_cases {
-        // Test that op serializes to a JSON value equal to expected_json
-        assert_json_diff::assert_json_eq!(
-            serde_json::from_str::<Value>(expected_json).unwrap(),
-            BurnchainOps::PegOutRequest(vec![op.clone()])
-        );
-
-        // Test that expected JSON deserializes into a BurnchainOps that is equal to op
-        assert_eq!(
-            serde_json::from_str::<BurnchainOps>(expected_json).unwrap(),
-            BurnchainOps::PegOutRequest(vec![op])
-        );
-    }
-}
-
-#[test]
-/// Test the serialization of PegOutRequest operations via
-/// `blockstack_op_to_json()` using JSON string fixtures
-fn serialization_peg_out_request() {
-    let test_cases = [(
-        r#"
-            {
-                "peg_out_request":
-                {
-                    "amount": 1337,
-                    "recipient": "1BixGeiRyKT7NTkJAHpWuP197KXUNqhCU9",
-                    "block_height": 218,
-                    "burn_header_hash": "3292a7d2a7e941499b5c0dcff2a5656c159010718450948a60c2be9e1c221dc4",
-                    "peg_wallet_address": "tb1qqvpsxqcrqvpsxqcrqvpsxqcrqvpsxqcrqvpsxqcrqvpsxqcrqvps3f3cyq",
-                    "txid": "d81bec73a0ea0bdcf9bc011f567944eb1eae5889bf002bf7ae641d7096157771",
-                    "vtxindex": 2,
-                    "signature": "0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d",
-                    "fulfillment_fee": 0,
-                    "memo": "00010203"
-                }
-            }
-        "#,
-        PegOutRequestOp {
-            amount: 1337,
-            recipient: PoxAddress::Standard(
-                StacksAddress::from_string("SP1TT0WQYZMEBX1XJ8QF4BH4A93TWZK7X9R76Z3SZ").unwrap(),
-                None,
-            ),
-            signature: MessageSignature([13; 65]),
-            peg_wallet_address: PoxAddress::Addr32(false, PoxAddressType32::P2WSH, [3; 32]),
-            fulfillment_fee: 0,
-            memo: vec![0, 1, 2, 3],
-            txid: Txid::from_hex(
-                "d81bec73a0ea0bdcf9bc011f567944eb1eae5889bf002bf7ae641d7096157771",
-            )
-            .unwrap(),
-            vtxindex: 2,
-            block_height: 218,
-            burn_header_hash: BurnchainHeaderHash::from_hex(
-                "3292a7d2a7e941499b5c0dcff2a5656c159010718450948a60c2be9e1c221dc4",
-            )
-            .unwrap(),
-        },
-    )];
-
-    for (expected_json, op) in test_cases {
-        // Test that op serializes to a JSON value equal to expected_json
-        assert_json_diff::assert_json_eq!(
-            serde_json::from_str::<Value>(expected_json).unwrap(),
-            BlockstackOperationType::PegOutRequest(op).blockstack_op_to_json()
-        );
-    }
-}
-
-#[test]
-/// Test the serialization and deserialization of PegOutFulfill operations in `BurnchainOps`
-///  using JSON string fixtures
-fn serialization_peg_out_fulfill_in_ops() {
-    let test_cases = [(
-        r#"
-            {
-                "peg_out_fulfill": [{
-                    "chain_tip": "0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e",
-                    "amount": 1337,
-                    "recipient": "1BixGeiRyKT7NTkJAHpWuP197KXUNqhCU9",
-                    "request_ref": "e81bec73a0ea0bdcf9bc011f567944eb1eae5889bf002bf7ae641d7096157772",
-                    "burn_header_hash": "3292a7d2a7e941499b5c0dcff2a5656c159010718450948a60c2be9e1c221dc4",
-                    "txid": "d81bec73a0ea0bdcf9bc011f567944eb1eae5889bf002bf7ae641d7096157771",
-                    "block_height": 218,
-                    "vtxindex": 2,
-                    "memo": "00010203"
-                }]
-            }
-        "#,
-        PegOutFulfillOp {
-            chain_tip: StacksBlockId([14; 32]),
-            amount: 1337,
-            recipient: PoxAddress::Standard(
-                StacksAddress::from_string("SP1TT0WQYZMEBX1XJ8QF4BH4A93TWZK7X9R76Z3SZ").unwrap(),
-                None,
-            ),
-            request_ref: Txid::from_hex(
-                "e81bec73a0ea0bdcf9bc011f567944eb1eae5889bf002bf7ae641d7096157772",
-            )
-            .unwrap(),
-            memo: vec![0, 1, 2, 3],
-            txid: Txid::from_hex(
-                "d81bec73a0ea0bdcf9bc011f567944eb1eae5889bf002bf7ae641d7096157771",
-            )
-            .unwrap(),
-            vtxindex: 2,
-            block_height: 218,
-            burn_header_hash: BurnchainHeaderHash::from_hex(
-                "3292a7d2a7e941499b5c0dcff2a5656c159010718450948a60c2be9e1c221dc4",
-            )
-            .unwrap(),
-        },
-    )];
-
-    for (expected_json, op) in test_cases {
-        // Test that op serializes to a JSON value equal to expected_json
-        assert_json_diff::assert_json_eq!(
-            serde_json::from_str::<Value>(expected_json).unwrap(),
-            BurnchainOps::PegOutFulfill(vec![op.clone()])
-        );
-
-        // Test that expected JSON deserializes into a BurnchainOps that is equal to op
-        assert_eq!(
-            serde_json::from_str::<BurnchainOps>(expected_json).unwrap(),
-            BurnchainOps::PegOutFulfill(vec![op])
-        );
-    }
-}
-
-#[test]
-/// Test the serialization of PegOutFulfill operations via
-/// `blockstack_op_to_json()` using JSON string fixtures
-fn serialization_peg_out_fulfill() {
-    let test_cases = [(
-        r#"
-            {
-                "peg_out_fulfill":
-                {
-                    "chain_tip": "0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e0e",
-                    "amount": 1337,
-                    "recipient": "1BixGeiRyKT7NTkJAHpWuP197KXUNqhCU9",
-                    "request_ref": "e81bec73a0ea0bdcf9bc011f567944eb1eae5889bf002bf7ae641d7096157772",
-                    "burn_header_hash": "3292a7d2a7e941499b5c0dcff2a5656c159010718450948a60c2be9e1c221dc4",
-                    "txid": "d81bec73a0ea0bdcf9bc011f567944eb1eae5889bf002bf7ae641d7096157771",
-                    "block_height": 218,
-                    "vtxindex": 2,
-                    "memo": "00010203"
-                }
-            }
-        "#,
-        PegOutFulfillOp {
-            chain_tip: StacksBlockId([14; 32]),
-            amount: 1337,
-            recipient: PoxAddress::Standard(
-                StacksAddress::from_string("SP1TT0WQYZMEBX1XJ8QF4BH4A93TWZK7X9R76Z3SZ").unwrap(),
-                None,
-            ),
-            request_ref: Txid::from_hex(
-                "e81bec73a0ea0bdcf9bc011f567944eb1eae5889bf002bf7ae641d7096157772",
-            )
-            .unwrap(),
-            memo: vec![0, 1, 2, 3],
-            txid: Txid::from_hex(
-                "d81bec73a0ea0bdcf9bc011f567944eb1eae5889bf002bf7ae641d7096157771",
-            )
-            .unwrap(),
-            vtxindex: 2,
-            block_height: 218,
-            burn_header_hash: BurnchainHeaderHash::from_hex(
-                "3292a7d2a7e941499b5c0dcff2a5656c159010718450948a60c2be9e1c221dc4",
-            )
-            .unwrap(),
-        },
-    )];
-
-    for (expected_json, op) in test_cases {
-        // Test that op serializes to a JSON value equal to expected_json
-        assert_json_diff::assert_json_eq!(
-            serde_json::from_str::<Value>(expected_json).unwrap(),
-            BlockstackOperationType::PegOutFulfill(op).blockstack_op_to_json()
-        );
-    }
-}
+}
\ No newline at end of file
diff --git a/stackslib/src/chainstate/coordinator/tests.rs b/stackslib/src/chainstate/coordinator/tests.rs
index 7e94c4bbc3..f5655c356b 100644
--- a/stackslib/src/chainstate/coordinator/tests.rs
+++ b/stackslib/src/chainstate/coordinator/tests.rs
@@ -3323,281 +3323,6 @@ fn test_stx_transfer_btc_ops() {
     }
 }
 
-#[test]
-fn test_sbtc_ops() {
-    let path = "/tmp/stacks-blockchain-sbtc-ops";
-    let _r = std::fs::remove_dir_all(path);
-
-    let pox_v1_unlock_ht = 12;
-    let pox_v2_unlock_ht = 14;
-    let pox_v3_unlock_ht = 16;
-    let pox_3_activation_ht = 15;
-    let pox_4_activation_ht = 16;
-    let sunset_ht = 8000;
-    let pox_consts = Some(PoxConstants::new(
-        100,
-        3,
-        3,
-        25,
-        5,
-        7010,
-        sunset_ht,
-        pox_v1_unlock_ht,
-        pox_v2_unlock_ht,
-        pox_v3_unlock_ht,
-        pox_3_activation_ht,
-        pox_4_activation_ht,
-    ));
-    let burnchain_conf = get_burnchain(path, pox_consts.clone());
-
-    let vrf_keys: Vec<_> = (0..50).map(|_| VRFPrivateKey::new()).collect();
-    let committers: Vec<_> = (0..50).map(|_| StacksPrivateKey::new()).collect();
-
-    let stacker = p2pkh_from(&StacksPrivateKey::new());
-    let recipient = p2pkh_from(&StacksPrivateKey::new());
-    let balance = 6_000_000_000 * (core::MICROSTACKS_PER_STACKS as u64);
-    let transfer_amt = 1_000_000_000 * (core::MICROSTACKS_PER_STACKS as u128);
-    let initial_balances = vec![(stacker.clone().into(), balance)];
-
-    setup_states(
-        &[path],
-        &vrf_keys,
-        &committers,
-        pox_consts.clone(),
-        Some(initial_balances),
-        StacksEpochId::Epoch24,
-    );
-
-    let mut coord = make_coordinator(path, Some(burnchain_conf.clone()));
-
-    coord.handle_new_burnchain_block().unwrap();
-
-    let sort_db = get_sortition_db(path, pox_consts.clone());
-
-    let tip = SortitionDB::get_canonical_burn_chain_tip(sort_db.conn()).unwrap();
-    assert_eq!(tip.block_height, 1);
-    assert_eq!(tip.sortition, false);
-    let (_, ops) = sort_db
-        .get_sortition_result(&tip.sortition_id)
-        .unwrap()
-        .unwrap();
-
-    // we should have all the VRF registrations accepted
-    assert_eq!(ops.accepted_ops.len(), vrf_keys.len());
-    assert_eq!(ops.consumed_leader_keys.len(), 0);
-
-    // process sequential blocks, and their sortitions...
-    let mut stacks_blocks: Vec<(SortitionId, StacksBlock)> = vec![];
-    let mut burnchain_block_hashes = vec![];
-
-    let first_peg_in_memo = vec![1, 3, 3, 7];
-    let second_peg_in_memo = vec![4, 2];
-
-    let first_peg_out_request_memo = vec![1, 3, 3, 8];
-    let second_peg_out_request_memo = vec![4, 3];
-
-    let peg_out_fulfill_memo = vec![1, 3, 3, 8];
-
-    for ix in 0..vrf_keys.len() {
-        let vrf_key = &vrf_keys[ix];
-        let miner = &committers[ix];
-
-        let mut burnchain = get_burnchain_db(path, pox_consts.clone());
-        let mut chainstate = get_chainstate(path);
-
-        let parent = if ix == 0 {
-            BlockHeaderHash([0; 32])
-        } else {
-            stacks_blocks[ix - 1].1.header.block_hash()
-        };
-
-        let burnchain_tip = burnchain.get_canonical_chain_tip().unwrap();
-        let next_mock_header = BurnchainBlockHeader {
-            block_height: burnchain_tip.block_height + 1,
-            block_hash: BurnchainHeaderHash([0; 32]),
-            parent_block_hash: burnchain_tip.block_hash,
-            num_txs: 0,
-            timestamp: 1,
-        };
-
-        let b = get_burnchain(path, pox_consts.clone());
-        let (good_op, block) = if ix == 0 {
-            make_genesis_block_with_recipients(
-                &sort_db,
-                &mut chainstate,
-                &parent,
-                miner,
-                10000,
-                vrf_key,
-                ix as u32,
-                None,
-            )
-        } else {
-            make_stacks_block_with_recipients(
-                &sort_db,
-                &mut chainstate,
-                &b,
-                &parent,
-                burnchain_tip.block_height,
-                miner,
-                1000,
-                vrf_key,
-                ix as u32,
-                None,
-            )
-        };
-
-        let expected_winner = good_op.txid();
-        let mut ops = vec![good_op];
-        let peg_wallet_address = PoxAddress::Addr32(false, PoxAddressType32::P2TR, [0; 32]);
-        let recipient_btc_address = PoxAddress::Standard(stacker.into(), None);
-        let canonical_chain_tip_snapshot =
-            SortitionDB::get_canonical_burn_chain_tip(sort_db.conn()).unwrap();
-
-        let chain_tip = StacksBlockId::new(
-            &canonical_chain_tip_snapshot.consensus_hash,
-            &canonical_chain_tip_snapshot.winning_stacks_block_hash,
-        );
-
-        match ix {
-            0 => {
-                ops.push(BlockstackOperationType::PegIn(PegInOp {
-                    recipient: stacker.into(),
-                    peg_wallet_address,
-                    amount: 1337,
-                    memo: first_peg_in_memo.clone(),
-                    txid: next_txid(),
-                    vtxindex: 5,
-                    block_height: 0,
-                    burn_header_hash: BurnchainHeaderHash([0; 32]),
-                }));
-            }
-            1 => {
-                // Shouldn't be accepted -- amount must be positive
-                ops.push(BlockstackOperationType::PegIn(PegInOp {
-                    recipient: stacker.into(),
-                    peg_wallet_address,
-                    amount: 0,
-                    memo: second_peg_in_memo.clone(),
-                    txid: next_txid(),
-                    vtxindex: 5,
-                    block_height: 0,
-                    burn_header_hash: BurnchainHeaderHash([0; 32]),
-                }));
-            }
-            2 => {
-                // Shouldn't be accepted -- amount must be positive
-                ops.push(BlockstackOperationType::PegOutRequest(PegOutRequestOp {
-                    recipient: recipient_btc_address,
-                    signature: MessageSignature([0; 65]),
-                    amount: 0,
-                    peg_wallet_address,
-                    fulfillment_fee: 3,
-                    memo: first_peg_out_request_memo.clone(),
-                    txid: next_txid(),
-                    vtxindex: 5,
-                    block_height: 0,
-                    burn_header_hash: BurnchainHeaderHash([0; 32]),
-                }));
-            }
-            3 => {
-                // Add a valid peg-out request op
-                ops.push(BlockstackOperationType::PegOutRequest(PegOutRequestOp {
-                    recipient: recipient_btc_address,
-                    signature: MessageSignature([0; 65]),
-                    amount: 5,
-                    peg_wallet_address,
-                    fulfillment_fee: 3,
-                    txid: Txid([0x13; 32]),
-                    memo: second_peg_out_request_memo.clone(),
-                    vtxindex: 8,
-                    block_height: 0,
-                    burn_header_hash: BurnchainHeaderHash([0; 32]),
-                }));
-            }
-            4 => {
-                // Fulfill the peg-out request
-                ops.push(BlockstackOperationType::PegOutFulfill(PegOutFulfillOp {
-                    recipient: recipient_btc_address,
-                    amount: 3,
-                    chain_tip,
-                    memo: peg_out_fulfill_memo.clone(),
-                    request_ref: Txid([0x13; 32]),
-                    txid: next_txid(),
-                    vtxindex: 6,
-                    block_height: 0,
-                    burn_header_hash: BurnchainHeaderHash([0; 32]),
-                }));
-            }
-            _ => {}
-        };
-
-        let burnchain_tip = burnchain.get_canonical_chain_tip().unwrap();
-        produce_burn_block(
-            &b,
-            &mut burnchain,
-            &burnchain_tip.block_hash,
-            ops,
-            vec![].iter_mut(),
-        );
-
-        burnchain_block_hashes.push(burnchain_tip.block_hash);
-        // handle the sortition
-        coord.handle_new_burnchain_block().unwrap();
-
-        let tip = SortitionDB::get_canonical_burn_chain_tip(sort_db.conn()).unwrap();
-        assert_eq!(&tip.winning_block_txid, &expected_winner);
-
-        // load the block into staging
-        let block_hash = block.header.block_hash();
-
-        assert_eq!(&tip.winning_stacks_block_hash, &block_hash);
-        stacks_blocks.push((tip.sortition_id.clone(), block.clone()));
-
-        preprocess_block(&mut chainstate, &sort_db, &tip, block);
-
-        // handle the stacks block
-        coord.handle_new_stacks_block().unwrap();
-    }
-
-    let peg_in_ops: Vec<_> = burnchain_block_hashes
-        .iter()
-        .flat_map(|block_hash| {
-            SortitionDB::get_peg_in_ops(&sort_db.conn(), block_hash)
-                .expect("Failed to get peg in ops")
-        })
-        .collect();
-
-    let peg_out_request_ops: Vec<_> = burnchain_block_hashes
-        .iter()
-        .flat_map(|block_hash| {
-            SortitionDB::get_peg_out_request_ops(&sort_db.conn(), block_hash)
-                .expect("Failed to get peg out request ops")
-        })
-        .collect();
-
-    let peg_out_fulfill_ops: Vec<_> = burnchain_block_hashes
-        .iter()
-        .flat_map(|block_hash| {
-            SortitionDB::get_peg_out_fulfill_ops(&sort_db.conn(), block_hash)
-                .expect("Failed to get peg out fulfillment ops")
-        })
-        .collect();
-
-    assert_eq!(peg_in_ops.len(), 1);
-    assert_eq!(peg_in_ops[0].memo, first_peg_in_memo);
-
-    assert_eq!(peg_out_request_ops.len(), 1);
-    assert_eq!(peg_out_request_ops[0].memo, second_peg_out_request_memo);
-
-    assert_eq!(peg_out_fulfill_ops.len(), 1);
-    assert_eq!(peg_out_fulfill_ops[0].memo, peg_out_fulfill_memo);
-    assert_eq!(
-        peg_out_fulfill_ops[0].request_ref,
-        peg_out_request_ops[0].txid
-    );
-}
-
 // This helper function retrieves the delegation info from the delegate address
 // from the pox-2 contract.
 // Given an address, it retrieves the fields `amount-ustx` and `pox-addr` from the map
diff --git a/stackslib/src/net/mod.rs b/stackslib/src/net/mod.rs
index 414691d37d..17f9837cad 100644
--- a/stackslib/src/net/mod.rs
+++ b/stackslib/src/net/mod.rs
@@ -64,7 +64,6 @@ use self::dns::*;
 use crate::burnchains::affirmation::AffirmationMap;
 use crate::burnchains::{Error as burnchain_error, Txid};
 use crate::chainstate::burn::db::sortdb::SortitionDB;
-use crate::chainstate::burn::operations::{PegInOp, PegOutFulfillOp, PegOutRequestOp};
 use crate::chainstate::burn::{ConsensusHash, Opcodes};
 use crate::chainstate::coordinator::Error as coordinator_error;
 use crate::chainstate::nakamoto::NakamotoChainState;
@@ -1121,18 +1120,6 @@ pub enum StacksMessageID {
     Reserved = 255,
 }
 
-/// This enum wraps Vecs of a single kind of `BlockstackOperationType`.
-/// This allows `handle_get_burn_ops` to use an enum for the different operation
-///  types without having to buffer and re-structure a `Vec<BlockstackOperationType>`
-///  from a, e.g., `Vec<PegInOp>`
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
-#[serde(rename_all = "snake_case")]
-pub enum BurnchainOps {
-    PegIn(Vec<PegInOp>),
-    PegOutRequest(Vec<PegOutRequestOp>),
-    PegOutFulfill(Vec<PegOutFulfillOp>),
-}
-
 /// Message type for all P2P Stacks network messages
 #[derive(Debug, Clone, PartialEq)]
 pub struct StacksMessage {
@@ -1638,10 +1625,7 @@ pub mod test {
                 BlockstackOperationType::TransferStx(_)
                 | BlockstackOperationType::DelegateStx(_)
                 | BlockstackOperationType::PreStx(_)
-                | BlockstackOperationType::StackStx(_)
-                | BlockstackOperationType::PegIn(_)
-                | BlockstackOperationType::PegOutRequest(_)
-                | BlockstackOperationType::PegOutFulfill(_) => Ok(()),
+                | BlockstackOperationType::StackStx(_) => Ok(()),
             }
         }
 
diff --git a/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs b/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
index 5c52581b8f..d8dd4d93bc 100644
--- a/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
+++ b/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
@@ -29,8 +29,7 @@ use stacks::burnchains::{
 };
 use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::burn::operations::{
-    BlockstackOperationType, DelegateStxOp, LeaderBlockCommitOp, LeaderKeyRegisterOp, PegInOp,
-    PegOutFulfillOp, PegOutRequestOp, PreStxOp, TransferStxOp, UserBurnSupportOp,
+    BlockstackOperationType, DelegateStxOp, LeaderBlockCommitOp, LeaderKeyRegisterOp, PreStxOp, TransferStxOp, UserBurnSupportOp,
 };
 #[cfg(test)]
 use stacks::chainstate::burn::Opcodes;
@@ -924,9 +923,7 @@ impl BitcoinRegtestController {
             | BlockstackOperationType::LeaderKeyRegister(_)
             | BlockstackOperationType::StackStx(_)
             | BlockstackOperationType::DelegateStx(_)
-            | BlockstackOperationType::UserBurnSupport(_)
-            | BlockstackOperationType::PegOutRequest(_)
-            | BlockstackOperationType::PegIn(_) => {
+            | BlockstackOperationType::UserBurnSupport(_) => {
                 unimplemented!();
             }
             BlockstackOperationType::PreStx(payload) => {
@@ -935,9 +932,6 @@ impl BitcoinRegtestController {
             BlockstackOperationType::TransferStx(payload) => {
                 self.build_transfer_stacks_tx(epoch_id, payload, op_signer, utxo)
             }
-            BlockstackOperationType::PegOutFulfill(payload) => {
-                self.build_peg_out_fulfill_tx(epoch_id, payload, op_signer, utxo)
-            }
         }?;
 
         let ser_transaction = SerializedTx::new(transaction.clone());
@@ -1180,227 +1174,6 @@ impl BitcoinRegtestController {
         Some(tx)
     }
 
-    #[cfg(not(test))]
-    fn build_peg_in_tx(
-        &mut self,
-        _epoch_id: StacksEpochId,
-        _payload: PegInOp,
-        _signer: &mut BurnchainOpSigner,
-    ) -> Option<Transaction> {
-        unimplemented!()
-    }
-
-    #[cfg(test)]
-    fn build_peg_in_tx(
-        &mut self,
-        epoch_id: StacksEpochId,
-        payload: PegInOp,
-        signer: &mut BurnchainOpSigner,
-    ) -> Option<Transaction> {
-        let public_key = signer.get_public_key();
-        let max_tx_size = 230;
-
-        let output_amt = DUST_UTXO_LIMIT
-            + max_tx_size * self.config.burnchain.satoshis_per_byte
-            + payload.amount;
-        let (mut tx, mut utxos) =
-            self.prepare_tx(epoch_id, &public_key, output_amt, None, None, 0)?;
-
-        let op_bytes = {
-            let mut bytes = self.config.burnchain.magic_bytes.as_bytes().to_vec();
-            bytes.push(Opcodes::PegIn as u8);
-            let (recipient_address, contract_name): (StacksAddress, String) =
-                match payload.recipient {
-                    PrincipalData::Standard(standard_principal) => {
-                        (standard_principal.into(), String::new())
-                    }
-                    PrincipalData::Contract(contract_identifier) => (
-                        contract_identifier.issuer.into(),
-                        contract_identifier.name.into(),
-                    ),
-                };
-            bytes.push(recipient_address.version);
-            bytes.extend_from_slice(recipient_address.bytes.as_bytes());
-            bytes.extend_from_slice(contract_name.as_bytes());
-            bytes
-        };
-
-        let peg_in_address_output = TxOut {
-            value: 0,
-            script_pubkey: Builder::new()
-                .push_opcode(opcodes::All::OP_RETURN)
-                .push_slice(&op_bytes)
-                .into_script(),
-        };
-
-        tx.output = vec![peg_in_address_output];
-        tx.output
-            .push(payload.peg_wallet_address.to_bitcoin_tx_out(payload.amount));
-
-        self.finalize_tx(
-            epoch_id,
-            &mut tx,
-            payload.amount,
-            0,
-            max_tx_size,
-            self.config.burnchain.satoshis_per_byte,
-            &mut utxos,
-            signer,
-        )?;
-
-        increment_btc_ops_sent_counter();
-
-        info!("Miner node: submitting peg-in op - {}", public_key.to_hex());
-
-        Some(tx)
-    }
-
-    #[cfg(not(test))]
-    fn build_peg_out_request_tx(
-        &mut self,
-        _epoch_id: StacksEpochId,
-        _payload: PegOutRequestOp,
-        _signer: &mut BurnchainOpSigner,
-    ) -> Option<Transaction> {
-        unimplemented!()
-    }
-
-    #[cfg(test)]
-    fn build_peg_out_request_tx(
-        &mut self,
-        epoch_id: StacksEpochId,
-        payload: PegOutRequestOp,
-        signer: &mut BurnchainOpSigner,
-    ) -> Option<Transaction> {
-        let public_key = signer.get_public_key();
-        let max_tx_size = 230;
-        let dust_amount = 10000;
-
-        let output_amt = DUST_UTXO_LIMIT
-            + dust_amount
-            + max_tx_size * self.config.burnchain.satoshis_per_byte
-            + payload.fulfillment_fee;
-        let (mut tx, mut utxos) =
-            self.prepare_tx(epoch_id, &public_key, output_amt, None, None, 0)?;
-
-        let op_bytes = {
-            let mut bytes = self.config.burnchain.magic_bytes.as_bytes().to_vec();
-            bytes.push(Opcodes::PegOutRequest as u8);
-            bytes.extend_from_slice(&payload.amount.to_be_bytes());
-            bytes.extend_from_slice(payload.signature.as_bytes());
-            bytes
-        };
-
-        let amount_and_signature_output = TxOut {
-            value: 0,
-            script_pubkey: Builder::new()
-                .push_opcode(opcodes::All::OP_RETURN)
-                .push_slice(&op_bytes)
-                .into_script(),
-        };
-
-        tx.output = vec![amount_and_signature_output];
-        tx.output
-            .push(payload.recipient.to_bitcoin_tx_out(dust_amount));
-        tx.output.push(
-            payload
-                .peg_wallet_address
-                .to_bitcoin_tx_out(payload.fulfillment_fee),
-        );
-
-        self.finalize_tx(
-            epoch_id,
-            &mut tx,
-            payload.fulfillment_fee,
-            0,
-            max_tx_size,
-            self.config.burnchain.satoshis_per_byte,
-            &mut utxos,
-            signer,
-        )?;
-
-        increment_btc_ops_sent_counter();
-
-        info!(
-            "Miner node: submitting peg-out request op - {}",
-            public_key.to_hex()
-        );
-
-        Some(tx)
-    }
-
-    #[cfg(not(test))]
-    fn build_peg_out_fulfill_tx(
-        &mut self,
-        _epoch_id: StacksEpochId,
-        _payload: PegOutFulfillOp,
-        _signer: &mut BurnchainOpSigner,
-        _utxo_to_use: Option<UTXO>,
-    ) -> Option<Transaction> {
-        unimplemented!()
-    }
-
-    #[cfg(test)]
-    fn build_peg_out_fulfill_tx(
-        &mut self,
-        epoch_id: StacksEpochId,
-        payload: PegOutFulfillOp,
-        signer: &mut BurnchainOpSigner,
-        utxo_to_use: Option<UTXO>,
-    ) -> Option<Transaction> {
-        let public_key = signer.get_public_key();
-        let max_tx_size = 230;
-
-        let output_amt = DUST_UTXO_LIMIT
-            + max_tx_size * self.config.burnchain.satoshis_per_byte
-            + payload.amount;
-        let (mut tx, mut utxos) =
-            self.prepare_tx(epoch_id, &public_key, output_amt, None, None, 0)?;
-
-        if let Some(utxo) = utxo_to_use {
-            utxos.utxos.insert(0, utxo);
-        }
-
-        let op_bytes = {
-            let mut bytes = self.config.burnchain.magic_bytes.as_bytes().to_vec();
-            bytes.push(Opcodes::PegOutFulfill as u8);
-            bytes.extend_from_slice(payload.chain_tip.as_bytes());
-            bytes
-        };
-
-        let block_header_output = TxOut {
-            value: 0,
-            script_pubkey: Builder::new()
-                .push_opcode(opcodes::All::OP_RETURN)
-                .push_slice(&op_bytes)
-                .into_script(),
-        };
-
-        tx.output = vec![block_header_output];
-        tx.output
-            .push(payload.recipient.to_bitcoin_tx_out(payload.amount));
-
-        self.finalize_tx(
-            epoch_id,
-            &mut tx,
-            payload.amount,
-            0,
-            max_tx_size,
-            self.config.burnchain.satoshis_per_byte,
-            &mut utxos,
-            signer,
-        )?;
-
-        increment_btc_ops_sent_counter();
-
-        info!(
-            "Miner node: submitting peg-out fulfill op - {}",
-            public_key.to_hex()
-        );
-
-        Some(tx)
-    }
-
     fn send_block_commit_operation(
         &mut self,
         epoch_id: StacksEpochId,
@@ -2076,15 +1849,6 @@ impl BitcoinRegtestController {
             BlockstackOperationType::TransferStx(payload) => {
                 self.build_transfer_stacks_tx(epoch_id, payload, op_signer, None)
             }
-            BlockstackOperationType::PegIn(payload) => {
-                self.build_peg_in_tx(epoch_id, payload, op_signer)
-            }
-            BlockstackOperationType::PegOutRequest(payload) => {
-                self.build_peg_out_request_tx(epoch_id, payload, op_signer)
-            }
-            BlockstackOperationType::PegOutFulfill(payload) => {
-                self.build_peg_out_fulfill_tx(epoch_id, payload, op_signer, None)
-            }
             BlockstackOperationType::StackStx(_payload) => unimplemented!(),
             BlockstackOperationType::DelegateStx(payload) => {
                 self.build_delegate_stacks_tx(epoch_id, payload, op_signer, None)
diff --git a/testnet/stacks-node/src/burnchains/mocknet_controller.rs b/testnet/stacks-node/src/burnchains/mocknet_controller.rs
index 4726413854..a9471a6606 100644
--- a/testnet/stacks-node/src/burnchains/mocknet_controller.rs
+++ b/testnet/stacks-node/src/burnchains/mocknet_controller.rs
@@ -9,8 +9,7 @@ use stacks::burnchains::{
 use stacks::chainstate::burn::db::sortdb::{SortitionDB, SortitionHandleTx};
 use stacks::chainstate::burn::operations::leader_block_commit::BURN_BLOCK_MINED_AT_MODULUS;
 use stacks::chainstate::burn::operations::{
-    BlockstackOperationType, DelegateStxOp, LeaderBlockCommitOp, LeaderKeyRegisterOp, PegInOp,
-    PegOutFulfillOp, PegOutRequestOp, PreStxOp, StackStxOp, TransferStxOp, UserBurnSupportOp,
+    BlockstackOperationType, DelegateStxOp, LeaderBlockCommitOp, LeaderKeyRegisterOp, PreStxOp, StackStxOp, TransferStxOp, UserBurnSupportOp,
 };
 use stacks::chainstate::burn::BlockSnapshot;
 use stacks::core::{
@@ -264,27 +263,6 @@ impl BurnchainController for MocknetController {
                         ..payload
                     })
                 }
-                BlockstackOperationType::PegIn(payload) => {
-                    BlockstackOperationType::PegIn(PegInOp {
-                        block_height: next_block_header.block_height,
-                        burn_header_hash: next_block_header.block_hash,
-                        ..payload
-                    })
-                }
-                BlockstackOperationType::PegOutRequest(payload) => {
-                    BlockstackOperationType::PegOutRequest(PegOutRequestOp {
-                        block_height: next_block_header.block_height,
-                        burn_header_hash: next_block_header.block_hash,
-                        ..payload
-                    })
-                }
-                BlockstackOperationType::PegOutFulfill(payload) => {
-                    BlockstackOperationType::PegOutFulfill(PegOutFulfillOp {
-                        block_height: next_block_header.block_height,
-                        burn_header_hash: next_block_header.block_hash,
-                        ..payload
-                    })
-                }
             };
             ops.push(op);
         }
diff --git a/testnet/stacks-node/src/tests/neon_integrations.rs b/testnet/stacks-node/src/tests/neon_integrations.rs
index 6378b4882b..c79c66e848 100644
--- a/testnet/stacks-node/src/tests/neon_integrations.rs
+++ b/testnet/stacks-node/src/tests/neon_integrations.rs
@@ -20,7 +20,7 @@ use stacks::burnchains::db::BurnchainDB;
 use stacks::burnchains::{Address, Burnchain, PoxConstants, Txid};
 use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::burn::operations::{
-    BlockstackOperationType, DelegateStxOp, PegInOp, PegOutFulfillOp, PegOutRequestOp, PreStxOp,
+    BlockstackOperationType, DelegateStxOp, PreStxOp,
     TransferStxOp,
 };
 use stacks::chainstate::burn::ConsensusHash;
@@ -54,7 +54,6 @@ use stacks::net::atlas::{
     AtlasConfig, AtlasDB, GetAttachmentResponse, GetAttachmentsInvResponse,
     MAX_ATTACHMENT_INV_PAGES_PER_REQUEST,
 };
-use stacks::net::BurnchainOps;
 use stacks::util_lib::boot::boot_code_id;
 use stacks::util_lib::db::{query_row_columns, query_rows, u64_to_sql};
 use stacks_common::address::C32_ADDRESS_VERSION_TESTNET_SINGLESIG;
@@ -790,18 +789,6 @@ fn get_tip_anchored_block(conf: &Config) -> (ConsensusHash, StacksBlock) {
     (stacks_tip_consensus_hash, block)
 }
 
-fn get_peg_in_ops(conf: &Config, height: u64) -> BurnchainOps {
-    let http_origin = format!("http://{}", &conf.node.rpc_bind);
-    let path = format!("{}/v2/burn_ops/{}/peg_in", &http_origin, height);
-    let client = reqwest::blocking::Client::new();
-
-    let response: serde_json::Value = client.get(&path).send().unwrap().json().unwrap();
-
-    eprintln!("{}", response);
-
-    serde_json::from_value(response).unwrap()
-}
-
 fn find_microblock_privkey(
     conf: &Config,
     pubkey_hash: &Hash160,
@@ -10905,436 +10892,4 @@ fn microblock_miner_multiple_attempts() {
     }
 
     channel.stop_chains_coordinator();
-}
-
-#[test]
-#[ignore]
-fn test_submit_and_observe_sbtc_ops() {
-    if env::var("BITCOIND_TEST") != Ok("1".into()) {
-        return;
-    }
-
-    let recipient_stx_addr =
-        StacksAddress::new(C32_ADDRESS_VERSION_TESTNET_SINGLESIG, Hash160([0; 20]));
-    let receiver_contract_name = ContractName::from("awesome_contract");
-    let receiver_contract_principal: PrincipalData =
-        QualifiedContractIdentifier::new(recipient_stx_addr.into(), receiver_contract_name).into();
-    let receiver_standard_principal: PrincipalData =
-        StandardPrincipalData::from(recipient_stx_addr).into();
-
-    let peg_wallet_sk = StacksPrivateKey::from_hex(SK_1).unwrap();
-    let peg_wallet_address = PoxAddress::Standard(to_addr(&peg_wallet_sk), None);
-
-    let recipient_btc_addr = PoxAddress::Standard(recipient_stx_addr, None);
-
-    let (mut conf, _) = neon_integration_test_conf();
-
-    let epoch_2_05 = 210;
-    let epoch_2_1 = 215;
-
-    let mut epochs = core::STACKS_EPOCHS_REGTEST.to_vec();
-    epochs[1].end_height = epoch_2_05;
-    epochs[2].start_height = epoch_2_05;
-    epochs[2].end_height = epoch_2_1;
-    epochs[3].start_height = epoch_2_1;
-
-    conf.node.mine_microblocks = false;
-    conf.burnchain.max_rbf = 1000000;
-    conf.miner.first_attempt_time_ms = 5_000;
-    conf.miner.subsequent_attempt_time_ms = 10_000;
-    conf.miner.segwit = false;
-    conf.node.wait_time_for_blocks = 0;
-
-    conf.burnchain.epochs = Some(epochs);
-
-    let mut btcd_controller = BitcoinCoreController::new(conf.clone());
-    let mut run_loop = neon::RunLoop::new(conf.clone());
-
-    btcd_controller
-        .start_bitcoind()
-        .ok()
-        .expect("Failed starting bitcoind");
-
-    let mut btc_regtest_controller = BitcoinRegtestController::new(conf.clone(), None);
-    btc_regtest_controller.bootstrap_chain(216);
-
-    let blocks_processed = run_loop.get_blocks_processed_arc();
-    let run_loop_coordinator_channel = run_loop.get_coordinator_channel().unwrap();
-
-    thread::spawn(move || run_loop.start(None, 0));
-
-    // give the run loop some time to start up!
-    wait_for_runloop(&blocks_processed);
-
-    // first block wakes up the run loop
-    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
-
-    // first block will hold our VRF registration
-    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
-
-    // second block will be the first mined Stacks block
-    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
-    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
-
-    // Let's send some sBTC ops.
-    let peg_in_op_standard = PegInOp {
-        recipient: receiver_standard_principal,
-        peg_wallet_address: peg_wallet_address.clone(),
-        amount: 133700,
-        memo: Vec::new(),
-        // filled in later
-        txid: Txid([0u8; 32]),
-        vtxindex: 0,
-        block_height: 0,
-        burn_header_hash: BurnchainHeaderHash([0u8; 32]),
-    };
-
-    let peg_in_op_contract = PegInOp {
-        recipient: receiver_contract_principal,
-        peg_wallet_address: peg_wallet_address.clone(),
-        amount: 133700,
-        memo: Vec::new(),
-        // filled in later
-        txid: Txid([1u8; 32]),
-        vtxindex: 0,
-        block_height: 0,
-        burn_header_hash: BurnchainHeaderHash([0u8; 32]),
-    };
-
-    let peg_out_request_op = PegOutRequestOp {
-        recipient: recipient_btc_addr.clone(),
-        signature: MessageSignature([0; 65]),
-        amount: 133700,
-        peg_wallet_address,
-        fulfillment_fee: 1_000_000,
-        memo: Vec::new(),
-        // filled in later
-        txid: Txid([2u8; 32]),
-        vtxindex: 0,
-        block_height: 0,
-        burn_header_hash: BurnchainHeaderHash([0u8; 32]),
-    };
-
-    let peg_out_fulfill_op = PegOutFulfillOp {
-        chain_tip: StacksBlockId([0; 32]),
-        recipient: recipient_btc_addr,
-        amount: 133700,
-        request_ref: Txid([2u8; 32]),
-        memo: Vec::new(),
-        // filled in later
-        txid: Txid([3u8; 32]),
-        vtxindex: 0,
-        block_height: 0,
-        burn_header_hash: BurnchainHeaderHash([0u8; 32]),
-    };
-
-    let mut miner_signer = Keychain::default(conf.node.seed.clone()).generate_op_signer();
-    assert!(
-        btc_regtest_controller
-            .submit_operation(
-                StacksEpochId::Epoch21,
-                BlockstackOperationType::PegIn(peg_in_op_standard.clone()),
-                &mut miner_signer,
-                1
-            )
-            .is_some(),
-        "Peg-in operation should submit successfully"
-    );
-
-    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
-
-    let parsed_peg_in_op_standard = {
-        let sortdb = btc_regtest_controller.sortdb_mut();
-        let tip = SortitionDB::get_canonical_burn_chain_tip(&sortdb.conn()).unwrap();
-        let mut ops = SortitionDB::get_peg_in_ops(&sortdb.conn(), &tip.burn_header_hash)
-            .expect("Failed to get peg in ops");
-        assert_eq!(ops.len(), 1);
-
-        ops.pop().unwrap()
-    };
-
-    let mut miner_signer = Keychain::default(conf.node.seed.clone()).generate_op_signer();
-    assert!(
-        btc_regtest_controller
-            .submit_operation(
-                StacksEpochId::Epoch21,
-                BlockstackOperationType::PegIn(peg_in_op_contract.clone()),
-                &mut miner_signer,
-                1
-            )
-            .is_some(),
-        "Peg-in operation should submit successfully"
-    );
-
-    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
-
-    let parsed_peg_in_op_contract = {
-        let sortdb = btc_regtest_controller.sortdb_mut();
-        let tip = SortitionDB::get_canonical_burn_chain_tip(&sortdb.conn()).unwrap();
-        let mut ops = SortitionDB::get_peg_in_ops(&sortdb.conn(), &tip.burn_header_hash)
-            .expect("Failed to get peg in ops");
-        assert_eq!(ops.len(), 1);
-
-        ops.pop().unwrap()
-    };
-
-    let mut miner_signer = Keychain::default(conf.node.seed.clone()).generate_op_signer();
-
-    let peg_out_request_txid = btc_regtest_controller
-        .submit_operation(
-            StacksEpochId::Epoch21,
-            BlockstackOperationType::PegOutRequest(peg_out_request_op.clone()),
-            &mut miner_signer,
-            1,
-        )
-        .expect("Peg-out request operation should submit successfully");
-
-    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
-
-    let parsed_peg_out_request_op = {
-        let sortdb = btc_regtest_controller.sortdb_mut();
-        let tip = SortitionDB::get_canonical_burn_chain_tip(&sortdb.conn()).unwrap();
-        let mut ops = SortitionDB::get_peg_out_request_ops(&sortdb.conn(), &tip.burn_header_hash)
-            .expect("Failed to get peg out request ops");
-        assert_eq!(ops.len(), 1);
-
-        ops.pop().unwrap()
-    };
-
-    let peg_out_request_tx = btc_regtest_controller.get_raw_transaction(&peg_out_request_txid);
-
-    // synthesize the UTXO for this txout, which will be consumed by the peg-out fulfillment tx
-    let peg_out_request_utxo = UTXO {
-        txid: peg_out_request_tx.txid(),
-        vout: 2,
-        script_pub_key: peg_out_request_tx.output[2].script_pubkey.clone(),
-        amount: peg_out_request_tx.output[2].value,
-        confirmations: 0,
-    };
-
-    let mut peg_wallet_signer = BurnchainOpSigner::new(peg_wallet_sk.clone(), false);
-
-    assert!(
-        btc_regtest_controller
-            .submit_manual(
-                StacksEpochId::Epoch21,
-                BlockstackOperationType::PegOutFulfill(peg_out_fulfill_op.clone()),
-                &mut peg_wallet_signer,
-                Some(peg_out_request_utxo),
-            )
-            .is_some(),
-        "Peg-out fulfill operation should submit successfully"
-    );
-
-    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
-
-    let parsed_peg_out_fulfill_op = {
-        let sortdb = btc_regtest_controller.sortdb_mut();
-        let tip = SortitionDB::get_canonical_burn_chain_tip(&sortdb.conn()).unwrap();
-        let mut ops = SortitionDB::get_peg_out_fulfill_ops(&sortdb.conn(), &tip.burn_header_hash)
-            .expect("Failed to get peg out fulfill ops");
-        assert_eq!(ops.len(), 1);
-
-        ops.pop().unwrap()
-    };
-
-    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
-
-    assert_eq!(
-        parsed_peg_in_op_standard.recipient,
-        peg_in_op_standard.recipient
-    );
-    assert_eq!(parsed_peg_in_op_standard.amount, peg_in_op_standard.amount);
-    assert_eq!(
-        parsed_peg_in_op_standard.peg_wallet_address,
-        peg_in_op_standard.peg_wallet_address
-    );
-
-    assert_eq!(
-        parsed_peg_in_op_contract.recipient,
-        peg_in_op_contract.recipient
-    );
-    assert_eq!(parsed_peg_in_op_contract.amount, peg_in_op_contract.amount);
-    assert_eq!(
-        parsed_peg_in_op_contract.peg_wallet_address,
-        peg_in_op_contract.peg_wallet_address
-    );
-
-    // now test that the responses from the RPC endpoint match the data
-    //  from the DB
-
-    let query_height_op_contract = parsed_peg_in_op_contract.block_height;
-    let parsed_resp = get_peg_in_ops(&conf, query_height_op_contract);
-
-    let parsed_peg_in_op_contract = match parsed_resp {
-        BurnchainOps::PegIn(mut vec) => {
-            assert_eq!(vec.len(), 1);
-            vec.pop().unwrap()
-        }
-        _ => panic!("Unexpected op"),
-    };
-
-    let query_height_op_standard = parsed_peg_in_op_standard.block_height;
-    let parsed_resp = get_peg_in_ops(&conf, query_height_op_standard);
-
-    let parsed_peg_in_op_standard = match parsed_resp {
-        BurnchainOps::PegIn(mut vec) => {
-            assert_eq!(vec.len(), 1);
-            vec.pop().unwrap()
-        }
-        _ => panic!("Unexpected op"),
-    };
-
-    assert_eq!(
-        parsed_peg_in_op_standard.recipient,
-        peg_in_op_standard.recipient
-    );
-    assert_eq!(parsed_peg_in_op_standard.amount, peg_in_op_standard.amount);
-    assert_eq!(
-        parsed_peg_in_op_standard.peg_wallet_address,
-        peg_in_op_standard.peg_wallet_address
-    );
-
-    assert_eq!(
-        parsed_peg_in_op_contract.recipient,
-        peg_in_op_contract.recipient
-    );
-    assert_eq!(parsed_peg_in_op_contract.amount, peg_in_op_contract.amount);
-    assert_eq!(
-        parsed_peg_in_op_contract.peg_wallet_address,
-        peg_in_op_contract.peg_wallet_address
-    );
-
-    assert_eq!(
-        parsed_peg_out_request_op.recipient,
-        peg_out_request_op.recipient
-    );
-    assert_eq!(parsed_peg_out_request_op.amount, peg_out_request_op.amount);
-    assert_eq!(
-        parsed_peg_out_request_op.signature,
-        peg_out_request_op.signature
-    );
-    assert_eq!(
-        parsed_peg_out_request_op.peg_wallet_address,
-        peg_out_request_op.peg_wallet_address
-    );
-    assert_eq!(
-        parsed_peg_out_request_op.fulfillment_fee,
-        peg_out_request_op.fulfillment_fee
-    );
-
-    assert_eq!(
-        parsed_peg_out_fulfill_op.recipient,
-        peg_out_fulfill_op.recipient
-    );
-    assert_eq!(parsed_peg_out_fulfill_op.amount, peg_out_fulfill_op.amount);
-    assert_eq!(
-        parsed_peg_out_fulfill_op.chain_tip,
-        peg_out_fulfill_op.chain_tip
-    );
-
-    let http_origin = format!("http://{}", &conf.node.rpc_bind);
-    let get_path =
-        |op, block_height| format!("{}/v2/burn_ops/{}/{}", &http_origin, block_height, op);
-    let client = reqwest::blocking::Client::new();
-
-    // Test peg in
-    let response: serde_json::Value = client
-        .get(&get_path("peg_in", parsed_peg_in_op_standard.block_height))
-        .send()
-        .unwrap()
-        .json()
-        .unwrap();
-    eprintln!("{}", response);
-
-    let parsed_resp: BurnchainOps = serde_json::from_value(response).unwrap();
-
-    let parsed_peg_in_op = match parsed_resp {
-        BurnchainOps::PegIn(mut vec) => {
-            assert_eq!(vec.len(), 1);
-            vec.pop().unwrap()
-        }
-        _ => panic!("Op not peg_in"),
-    };
-
-    // Test peg out request
-    let response: serde_json::Value = client
-        .get(&get_path(
-            "peg_out_request",
-            parsed_peg_out_request_op.block_height,
-        ))
-        .send()
-        .unwrap()
-        .json()
-        .unwrap();
-    eprintln!("{}", response);
-
-    let parsed_resp: BurnchainOps = serde_json::from_value(response).unwrap();
-
-    let parsed_peg_out_request_op = match parsed_resp {
-        BurnchainOps::PegOutRequest(mut vec) => {
-            assert_eq!(vec.len(), 1);
-            vec.pop().unwrap()
-        }
-        _ => panic!("Op not peg_out_request"),
-    };
-
-    // Test peg out fulfill
-    let response: serde_json::Value = client
-        .get(&get_path(
-            "peg_out_fulfill",
-            parsed_peg_out_fulfill_op.block_height,
-        ))
-        .send()
-        .unwrap()
-        .json()
-        .unwrap();
-    eprintln!("{}", response);
-
-    let parsed_resp: BurnchainOps = serde_json::from_value(response).unwrap();
-
-    let parsed_peg_out_fulfill_op = match parsed_resp {
-        BurnchainOps::PegOutFulfill(mut vec) => {
-            assert_eq!(vec.len(), 1);
-            vec.pop().unwrap()
-        }
-        _ => panic!("Op not peg_out_fulfill"),
-    };
-
-    assert_eq!(parsed_peg_in_op.recipient, peg_in_op_standard.recipient);
-    assert_eq!(parsed_peg_in_op.amount, peg_in_op_standard.amount);
-    assert_eq!(
-        parsed_peg_in_op.peg_wallet_address,
-        peg_in_op_standard.peg_wallet_address
-    );
-
-    assert_eq!(
-        parsed_peg_out_request_op.recipient,
-        peg_out_request_op.recipient
-    );
-    assert_eq!(parsed_peg_out_request_op.amount, peg_out_request_op.amount);
-    assert_eq!(
-        parsed_peg_out_request_op.signature,
-        peg_out_request_op.signature
-    );
-    assert_eq!(
-        parsed_peg_out_request_op.peg_wallet_address,
-        peg_out_request_op.peg_wallet_address
-    );
-    assert_eq!(
-        parsed_peg_out_request_op.fulfillment_fee,
-        peg_out_request_op.fulfillment_fee
-    );
-
-    assert_eq!(
-        parsed_peg_out_fulfill_op.recipient,
-        peg_out_fulfill_op.recipient
-    );
-    assert_eq!(parsed_peg_out_fulfill_op.amount, peg_out_fulfill_op.amount);
-    assert_eq!(
-        parsed_peg_out_fulfill_op.chain_tip,
-        peg_out_fulfill_op.chain_tip
-    );
-
-    run_loop_coordinator_channel.stop_chains_coordinator();
-}
+}
\ No newline at end of file

From 3d5ca9149940029687274814090f822dba9e9e31 Mon Sep 17 00:00:00 2001
From: soju-drinker <takashi.hatake@outlook.com>
Date: Mon, 4 Dec 2023 10:36:56 -0500
Subject: [PATCH 0134/1166] removing schemas

---
 stackslib/src/chainstate/burn/db/sortdb.rs | 52 +---------------------
 1 file changed, 1 insertion(+), 51 deletions(-)

diff --git a/stackslib/src/chainstate/burn/db/sortdb.rs b/stackslib/src/chainstate/burn/db/sortdb.rs
index 435ea412be..abad1f3f9a 100644
--- a/stackslib/src/chainstate/burn/db/sortdb.rs
+++ b/stackslib/src/chainstate/burn/db/sortdb.rs
@@ -708,55 +708,8 @@ const SORTITION_DB_SCHEMA_6: &'static [&'static str] = &[r#"
 const SORTITION_DB_SCHEMA_7: &'static [&'static str] = &[r#"
      DELETE FROM epochs;"#];
 
-// update this to add new indexes
-const LAST_SORTITION_DB_INDEX: &'static str = "index_peg_out_fulfill_burn_header_hash ";
-
+const LAST_SORTITION_DB_INDEX: &'static str = "index_delegate_stx_burn_header_hash";
 const SORTITION_DB_SCHEMA_8: &'static [&'static str] = &[
-    r#"
-    CREATE TABLE peg_in (
-        txid TEXT NOT NULL,
-        vtxindex INTEGER NOT NULL,
-        block_height INTEGER NOT NULL,
-        burn_header_hash TEXT NOT NULL,
-
-        recipient TEXT NOT NULL,            -- Stacks principal to receive the sBTC, can also be a contract principal
-        peg_wallet_address TEXT NOT NULL,
-        amount TEXT NOT NULL,
-        memo TEXT,
-
-        PRIMARY KEY(txid, burn_header_hash)
-    );"#,
-    r#"
-    CREATE TABLE peg_out_requests (
-        txid TEXT NOT NULL,
-        vtxindex INTEGER NOT NULL,
-        block_height INTEGER NOT NULL,
-        burn_header_hash TEXT NOT NULL,
-
-        amount TEXT NOT NULL,
-        recipient TEXT NOT NULL,
-        signature TEXT NOT NULL,
-        peg_wallet_address TEXT NOT NULL,
-        fulfillment_fee TEXT NOT NULL,
-        memo TEXT,
-
-        PRIMARY KEY(txid, burn_header_hash)
-    );"#,
-    r#"
-    CREATE TABLE peg_out_fulfillments (
-        txid TEXT NOT NULL,
-        vtxindex INTEGER NOT NULL,
-        block_height INTEGER NOT NULL,
-        burn_header_hash TEXT NOT NULL,
-
-        chain_tip TEXT NOT NULL,
-        amount TEXT NOT NULL,
-        recipient TEXT NOT NULL,
-        request_ref TEXT NOT NULL,
-        memo TEXT,
-
-        PRIMARY KEY(txid, burn_header_hash)
-    );"#,
     r#"ALTER TABLE snapshots ADD miner_pk_hash TEXT DEFAULT NULL"#,
     r#"
     -- eagerly-processed reward sets, before they're applied to the start of the next reward cycle
@@ -798,9 +751,6 @@ const SORTITION_DB_INDEXES: &'static [&'static str] = &[
     "CREATE INDEX IF NOT EXISTS index_pox_payouts ON snapshots(pox_payouts);",
     "CREATE INDEX IF NOT EXISTS index_burn_header_hash_pox_valid ON snapshots(burn_header_hash,pox_valid);",
     "CREATE INDEX IF NOT EXISTS index_delegate_stx_burn_header_hash ON delegate_stx(burn_header_hash);",
-    "CREATE INDEX IF NOT EXISTS index_peg_in_burn_header_hash ON peg_in(burn_header_hash);",
-    "CREATE INDEX IF NOT EXISTS index_peg_out_request_burn_header_hash ON peg_out_requests(burn_header_hash);",
-    "CREATE INDEX IF NOT EXISTS index_peg_out_fulfill_burn_header_hash ON peg_out_fulfillments(burn_header_hash);",
 ];
 
 pub struct SortitionDB {

From 8155592bea469a0c0fe09020e6f4ab83ba2eb727 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Mon, 11 Dec 2023 15:57:02 -0500
Subject: [PATCH 0135/1166] chore: extend
 SortitionDB::get_canonical_stacks_tip_block_hash to also return the height,
 and add a backwards-compatible wrapper.  In addition, add a test method for
 setting the canonical tip

---
 stackslib/src/chainstate/burn/db/sortdb.rs | 35 ++++++++++++++++++----
 1 file changed, 30 insertions(+), 5 deletions(-)

diff --git a/stackslib/src/chainstate/burn/db/sortdb.rs b/stackslib/src/chainstate/burn/db/sortdb.rs
index 5b8d4b9c21..08f268e1ab 100644
--- a/stackslib/src/chainstate/burn/db/sortdb.rs
+++ b/stackslib/src/chainstate/burn/db/sortdb.rs
@@ -1820,6 +1820,23 @@ impl<'a> SortitionHandleTx<'a> {
         Ok(())
     }
 
+    /// Update the canonical Stacks tip (testing only)
+    #[cfg(test)]
+    pub fn test_update_canonical_stacks_tip(
+        &mut self,
+        sort_id: &SortitionId,
+        consensus_hash: &ConsensusHash,
+        stacks_block_hash: &BlockHeaderHash,
+        stacks_block_height: u64,
+    ) -> Result<(), db_error> {
+        self.update_canonical_stacks_tip(
+            sort_id,
+            consensus_hash,
+            stacks_block_hash,
+            stacks_block_height,
+        )
+    }
+
     /// Mark an existing snapshot's stacks block as accepted at a particular burn chain tip within a PoX fork (identified by the consensus hash),
     /// and calculate and store its arrival index.
     /// If this Stacks block extends the canonical stacks chain tip, then also update the memoized canonical
@@ -4590,9 +4607,9 @@ impl SortitionDB {
     }
 
     /// Get the canonical Stacks chain tip -- this gets memoized on the canonical burn chain tip.
-    pub fn get_canonical_stacks_chain_tip_hash(
+    pub fn get_canonical_stacks_chain_tip_hash_and_height(
         conn: &Connection,
-    ) -> Result<(ConsensusHash, BlockHeaderHash), db_error> {
+    ) -> Result<(ConsensusHash, BlockHeaderHash, u64), db_error> {
         let sn = SortitionDB::get_canonical_burn_chain_tip(conn)?;
         let cur_epoch = SortitionDB::get_stacks_epoch(conn, sn.block_height)?.expect(&format!(
             "FATAL: no epoch defined for burn height {}",
@@ -4605,9 +4622,9 @@ impl SortitionDB {
             let mut cursor = sn;
             loop {
                 let result_at_tip = conn.query_row_and_then(
-                    "SELECT consensus_hash,block_hash FROM stacks_chain_tips WHERE sortition_id = ?",
+                    "SELECT consensus_hash,block_hash,block_height FROM stacks_chain_tips WHERE sortition_id = ?",
                     &[&cursor.sortition_id],
-                    |row| Ok((row.get_unwrap(0), row.get_unwrap(1))),
+                    |row| Ok((row.get_unwrap(0), row.get_unwrap(1), (u64::try_from(row.get_unwrap::<_, i64>(2)).expect("FATAL: block height too high"))))
                 ).optional()?;
                 if let Some(stacks_tip) = result_at_tip {
                     return Ok(stacks_tip);
@@ -4620,8 +4637,16 @@ impl SortitionDB {
         // epoch 2.x behavior -- look at the snapshot itself
         let stacks_block_hash = sn.canonical_stacks_tip_hash;
         let consensus_hash = sn.canonical_stacks_tip_consensus_hash;
+        let stacks_block_height = sn.canonical_stacks_tip_height;
+        Ok((consensus_hash, stacks_block_hash, stacks_block_height))
+    }
 
-        Ok((consensus_hash, stacks_block_hash))
+    /// Get the canonical Stacks chain tip -- this gets memoized on the canonical burn chain tip.
+    pub fn get_canonical_stacks_chain_tip_hash(
+        conn: &Connection,
+    ) -> Result<(ConsensusHash, BlockHeaderHash), db_error> {
+        Self::get_canonical_stacks_chain_tip_hash_and_height(conn)
+            .map(|(ch, bhh, _height)| (ch, bhh))
     }
 
     /// Get the maximum arrival index for any known snapshot.

From ded3b54147cf746c918255700b2615eefaeda583 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Mon, 11 Dec 2023 15:57:32 -0500
Subject: [PATCH 0136/1166] chore: modify tests to work with new
 NakamotoChainState::get_highest_processed_tenure()

---
 .../chainstate/nakamoto/coordinator/tests.rs  | 46 ++++++++++++++++++-
 1 file changed, 44 insertions(+), 2 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index 6fcf5b1498..6fcea6260f 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -19,6 +19,7 @@ use clarity::vm::types::PrincipalData;
 use rand::prelude::SliceRandom;
 use rand::{thread_rng, Rng, RngCore};
 use stacks_common::address::{AddressHashMode, C32_ADDRESS_VERSION_TESTNET_SINGLESIG};
+use stacks_common::consts::{FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH};
 use stacks_common::types::chainstate::{
     StacksAddress, StacksBlockId, StacksPrivateKey, StacksPublicKey,
 };
@@ -26,7 +27,7 @@ use stacks_common::types::{Address, StacksEpoch};
 use stacks_common::util::vrf::VRFProof;
 use wsts::curve::point::Point;
 
-use crate::chainstate::burn::db::sortdb::SortitionDB;
+use crate::chainstate::burn::db::sortdb::{SortitionDB, SortitionHandle};
 use crate::chainstate::burn::operations::BlockstackOperationType;
 use crate::chainstate::coordinator::tests::p2pkh_from;
 use crate::chainstate::nakamoto::tests::get_account;
@@ -624,13 +625,26 @@ fn test_nakamoto_chainstate_getters() {
         .unwrap()
         .is_none());
 
+        let cur_burn_tip = SortitionDB::get_canonical_burn_chain_tip(sort_tx.sqlite()).unwrap();
+        let (cur_stacks_ch, cur_stacks_bhh, cur_stacks_height) =
+            SortitionDB::get_canonical_stacks_chain_tip_hash_and_height(sort_tx.sqlite()).unwrap();
+        sort_tx
+            .test_update_canonical_stacks_tip(
+                &cur_burn_tip.sortition_id,
+                &FIRST_BURNCHAIN_CONSENSUS_HASH,
+                &FIRST_STACKS_BLOCK_HASH,
+                0,
+            )
+            .unwrap();
+
+        // drop the highest tenure, so this check can pass
         NakamotoChainState::delete_nakamoto_tenure(
             chainstate.db(),
             &blocks[0].header.consensus_hash,
         )
         .unwrap();
 
-        // drop the highest tenure, so this check can pass
+        // check works (this would be the first tenure)
         assert!(NakamotoChainState::check_nakamoto_tenure(
             chainstate.db(),
             &mut sort_tx,
@@ -641,6 +655,14 @@ fn test_nakamoto_chainstate_getters() {
         .is_some());
 
         // restore
+        sort_tx
+            .test_update_canonical_stacks_tip(
+                &cur_burn_tip.sortition_id,
+                &cur_stacks_ch,
+                &cur_stacks_bhh,
+                cur_stacks_height,
+            )
+            .unwrap();
         NakamotoChainState::insert_nakamoto_tenure(
             chainstate.db(),
             &blocks[0].header,
@@ -808,6 +830,18 @@ fn test_nakamoto_chainstate_getters() {
         .unwrap()
         .is_some());
 
+        let cur_burn_tip = SortitionDB::get_canonical_burn_chain_tip(sort_tx.sqlite()).unwrap();
+        let (cur_stacks_ch, cur_stacks_bhh, cur_stacks_height) =
+            SortitionDB::get_canonical_stacks_chain_tip_hash_and_height(sort_tx.sqlite()).unwrap();
+        sort_tx
+            .test_update_canonical_stacks_tip(
+                &cur_burn_tip.sortition_id,
+                &blocks[9].header.consensus_hash,
+                &blocks[9].header.block_hash(),
+                blocks[9].header.chain_length,
+            )
+            .unwrap();
+
         NakamotoChainState::delete_nakamoto_tenure(
             chainstate.db(),
             &new_blocks[0].header.consensus_hash,
@@ -834,6 +868,14 @@ fn test_nakamoto_chainstate_getters() {
         .is_none());
 
         // restore
+        sort_tx
+            .test_update_canonical_stacks_tip(
+                &cur_burn_tip.sortition_id,
+                &cur_stacks_ch,
+                &cur_stacks_bhh,
+                cur_stacks_height,
+            )
+            .unwrap();
         NakamotoChainState::insert_nakamoto_tenure(
             chainstate.db(),
             &new_blocks[0].header,

From 30dab5b02e1c82a4bd1943b389a41f2335fc36e2 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Mon, 11 Dec 2023 16:23:58 -0500
Subject: [PATCH 0137/1166] Run rust fmt

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stackslib/src/burnchains/burnchain.rs                        | 3 ++-
 stackslib/src/chainstate/burn/db/sortdb.rs                   | 3 ++-
 .../src/chainstate/burn/operations/test/serialization.rs     | 5 ++---
 .../stacks-node/src/burnchains/bitcoin_regtest_controller.rs | 3 ++-
 testnet/stacks-node/src/burnchains/mocknet_controller.rs     | 3 ++-
 testnet/stacks-node/src/tests/neon_integrations.rs           | 5 ++---
 6 files changed, 12 insertions(+), 10 deletions(-)

diff --git a/stackslib/src/burnchains/burnchain.rs b/stackslib/src/burnchains/burnchain.rs
index f4cbd01dbb..b11866f6cd 100644
--- a/stackslib/src/burnchains/burnchain.rs
+++ b/stackslib/src/burnchains/burnchain.rs
@@ -54,7 +54,8 @@ use crate::chainstate::burn::db::sortdb::{
 use crate::chainstate::burn::distribution::BurnSamplePoint;
 use crate::chainstate::burn::operations::leader_block_commit::MissedBlockCommit;
 use crate::chainstate::burn::operations::{
-    BlockstackOperationType, DelegateStxOp, LeaderBlockCommitOp, LeaderKeyRegisterOp, PreStxOp, StackStxOp, TransferStxOp, UserBurnSupportOp,
+    BlockstackOperationType, DelegateStxOp, LeaderBlockCommitOp, LeaderKeyRegisterOp, PreStxOp,
+    StackStxOp, TransferStxOp, UserBurnSupportOp,
 };
 use crate::chainstate::burn::{BlockSnapshot, Opcodes};
 use crate::chainstate::coordinator::comm::CoordinatorChannels;
diff --git a/stackslib/src/chainstate/burn/db/sortdb.rs b/stackslib/src/chainstate/burn/db/sortdb.rs
index abad1f3f9a..bbbcc3ad70 100644
--- a/stackslib/src/chainstate/burn/db/sortdb.rs
+++ b/stackslib/src/chainstate/burn/db/sortdb.rs
@@ -58,7 +58,8 @@ use crate::chainstate::burn::operations::leader_block_commit::{
     MissedBlockCommit, RewardSetInfo, OUTPUTS_PER_COMMIT,
 };
 use crate::chainstate::burn::operations::{
-    BlockstackOperationType, DelegateStxOp, LeaderBlockCommitOp, LeaderKeyRegisterOp, PreStxOp, StackStxOp, TransferStxOp, UserBurnSupportOp,
+    BlockstackOperationType, DelegateStxOp, LeaderBlockCommitOp, LeaderKeyRegisterOp, PreStxOp,
+    StackStxOp, TransferStxOp, UserBurnSupportOp,
 };
 use crate::chainstate::burn::{
     BlockSnapshot, ConsensusHash, ConsensusHashExtensions, Opcodes, OpsHash, SortitionHash,
diff --git a/stackslib/src/chainstate/burn/operations/test/serialization.rs b/stackslib/src/chainstate/burn/operations/test/serialization.rs
index 768f67b995..5e2d03514a 100644
--- a/stackslib/src/chainstate/burn/operations/test/serialization.rs
+++ b/stackslib/src/chainstate/burn/operations/test/serialization.rs
@@ -10,8 +10,7 @@ use stacks_common::util::secp256k1::MessageSignature;
 
 use crate::burnchains::Txid;
 use crate::chainstate::burn::operations::{
-    BlockstackOperationType, DelegateStxOp, PreStxOp,
-    StackStxOp, TransferStxOp,
+    BlockstackOperationType, DelegateStxOp, PreStxOp, StackStxOp, TransferStxOp,
 };
 use crate::chainstate::stacks::address::{PoxAddress, PoxAddressType32};
 
@@ -177,4 +176,4 @@ fn test_serialization_delegate_stx_op() {
     });
 
     assert_json_diff::assert_json_eq!(serialized_json, constructed_json);
-}
\ No newline at end of file
+}
diff --git a/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs b/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
index d8dd4d93bc..d70fca1c02 100644
--- a/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
+++ b/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
@@ -29,7 +29,8 @@ use stacks::burnchains::{
 };
 use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::burn::operations::{
-    BlockstackOperationType, DelegateStxOp, LeaderBlockCommitOp, LeaderKeyRegisterOp, PreStxOp, TransferStxOp, UserBurnSupportOp,
+    BlockstackOperationType, DelegateStxOp, LeaderBlockCommitOp, LeaderKeyRegisterOp, PreStxOp,
+    TransferStxOp, UserBurnSupportOp,
 };
 #[cfg(test)]
 use stacks::chainstate::burn::Opcodes;
diff --git a/testnet/stacks-node/src/burnchains/mocknet_controller.rs b/testnet/stacks-node/src/burnchains/mocknet_controller.rs
index a9471a6606..0c1ae9c84e 100644
--- a/testnet/stacks-node/src/burnchains/mocknet_controller.rs
+++ b/testnet/stacks-node/src/burnchains/mocknet_controller.rs
@@ -9,7 +9,8 @@ use stacks::burnchains::{
 use stacks::chainstate::burn::db::sortdb::{SortitionDB, SortitionHandleTx};
 use stacks::chainstate::burn::operations::leader_block_commit::BURN_BLOCK_MINED_AT_MODULUS;
 use stacks::chainstate::burn::operations::{
-    BlockstackOperationType, DelegateStxOp, LeaderBlockCommitOp, LeaderKeyRegisterOp, PreStxOp, StackStxOp, TransferStxOp, UserBurnSupportOp,
+    BlockstackOperationType, DelegateStxOp, LeaderBlockCommitOp, LeaderKeyRegisterOp, PreStxOp,
+    StackStxOp, TransferStxOp, UserBurnSupportOp,
 };
 use stacks::chainstate::burn::BlockSnapshot;
 use stacks::core::{
diff --git a/testnet/stacks-node/src/tests/neon_integrations.rs b/testnet/stacks-node/src/tests/neon_integrations.rs
index c79c66e848..b1e68d26d7 100644
--- a/testnet/stacks-node/src/tests/neon_integrations.rs
+++ b/testnet/stacks-node/src/tests/neon_integrations.rs
@@ -20,8 +20,7 @@ use stacks::burnchains::db::BurnchainDB;
 use stacks::burnchains::{Address, Burnchain, PoxConstants, Txid};
 use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::burn::operations::{
-    BlockstackOperationType, DelegateStxOp, PreStxOp,
-    TransferStxOp,
+    BlockstackOperationType, DelegateStxOp, PreStxOp, TransferStxOp,
 };
 use stacks::chainstate::burn::ConsensusHash;
 use stacks::chainstate::coordinator::comm::CoordinatorChannels;
@@ -10892,4 +10891,4 @@ fn microblock_miner_multiple_attempts() {
     }
 
     channel.stop_chains_coordinator();
-}
\ No newline at end of file
+}

From 86cd0cd41f0a274d01ae3239eb391736c1f18032 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Mon, 11 Dec 2023 14:20:10 -0500
Subject: [PATCH 0138/1166] Remove PoisonMicroBlocks from will_admit_mempool_tx
 check

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stackslib/src/chainstate/stacks/db/blocks.rs | 75 +++-----------------
 1 file changed, 8 insertions(+), 67 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/db/blocks.rs b/stackslib/src/chainstate/stacks/db/blocks.rs
index 4412c9d1ea..44ee696b26 100644
--- a/stackslib/src/chainstate/stacks/db/blocks.rs
+++ b/stackslib/src/chainstate/stacks/db/blocks.rs
@@ -6329,83 +6329,24 @@ impl StacksChainState {
         let is_mainnet = self.clarity_state.is_mainnet();
         StacksChainState::can_admit_mempool_semantic(tx, is_mainnet)?;
 
-        let conf = self.config();
-        let staging_height =
-            match self.get_stacks_block_height(current_consensus_hash, current_block) {
-                Ok(Some(height)) => height,
-                Ok(None) => {
-                    if *current_consensus_hash == FIRST_BURNCHAIN_CONSENSUS_HASH {
-                        0
-                    } else {
-                        return Err(MemPoolRejection::NoSuchChainTip(
-                            current_consensus_hash.clone(),
-                            current_block.clone(),
-                        ));
-                    }
-                }
-                Err(_e) => {
-                    panic!("DB CORRUPTION: failed to query block height");
-                }
-            };
-
-        let has_microblock_pubk = match tx.payload {
-            TransactionPayload::PoisonMicroblock(ref microblock_header_1, _) => {
-                let microblock_pkh_1 = microblock_header_1
-                    .check_recover_pubkey()
-                    .map_err(|_e| MemPoolRejection::InvalidMicroblocks)?;
+        if matches!(tx.payload, TransactionPayload::PoisonMicroblock(..)) {
+            return Err(MemPoolRejection::Other(
+                "PoisonMicroblock transactions not accepted via mempool".into(),
+            ));
+        }
 
-                StacksChainState::has_blocks_with_microblock_pubkh(
-                    &self.db(),
-                    &microblock_pkh_1,
-                    staging_height as i64,
-                )
-            }
-            _ => false, // unused
-        };
+        let conf = self.config();
 
         let current_tip =
             StacksChainState::get_parent_index_block(current_consensus_hash, current_block);
-        let res = match self.with_read_only_clarity_tx(burn_state_db, &current_tip, |conn| {
-            StacksChainState::can_include_tx(conn, &conf, has_microblock_pubk, tx, tx_size)
+        match self.with_read_only_clarity_tx(burn_state_db, &current_tip, |conn| {
+            StacksChainState::can_include_tx(conn, &conf, false, tx, tx_size)
         }) {
             Some(r) => r,
             None => Err(MemPoolRejection::NoSuchChainTip(
                 current_consensus_hash.clone(),
                 current_block.clone(),
             )),
-        };
-
-        match res {
-            Ok(x) => Ok(x),
-            Err(MemPoolRejection::BadNonces(mismatch_error)) => {
-                // try again, but against the _unconfirmed_ chain tip, if we
-                // (a) have one, and (b) the expected nonce is less than the given one.
-                if self.unconfirmed_state.is_some()
-                    && mismatch_error.expected < mismatch_error.actual
-                {
-                    debug!("Transaction {} is unminable in the confirmed chain tip due to nonce {} != {}; trying the unconfirmed chain tip",
-                           &tx.txid(), mismatch_error.expected, mismatch_error.actual);
-                    self.with_read_only_unconfirmed_clarity_tx(burn_state_db, |conn| {
-                        StacksChainState::can_include_tx(
-                            conn,
-                            &conf,
-                            has_microblock_pubk,
-                            tx,
-                            tx_size,
-                        )
-                    })
-                    .map_err(|_| {
-                        MemPoolRejection::NoSuchChainTip(
-                            current_consensus_hash.clone(),
-                            current_block.clone(),
-                        )
-                    })?
-                    .expect("BUG: do not have unconfirmed state, despite being Some(..)")
-                } else {
-                    Err(MemPoolRejection::BadNonces(mismatch_error))
-                }
-            }
-            Err(e) => Err(e),
         }
     }
 

From d28e4e9d374e45eb50445f68ab110368e5a74d49 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Mon, 11 Dec 2023 14:20:16 -0500
Subject: [PATCH 0139/1166] Add a test to check rpc submit tx mempool admission
 checks pass

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 testnet/stacks-node/src/mockamoto/tests.rs | 89 +++++++++++++++++++++-
 1 file changed, 88 insertions(+), 1 deletion(-)

diff --git a/testnet/stacks-node/src/mockamoto/tests.rs b/testnet/stacks-node/src/mockamoto/tests.rs
index d1f3696418..99c7d34cc8 100644
--- a/testnet/stacks-node/src/mockamoto/tests.rs
+++ b/testnet/stacks-node/src/mockamoto/tests.rs
@@ -11,7 +11,7 @@ use stacks_common::util::hash::to_hex;
 use super::MockamotoNode;
 use crate::config::{EventKeyType, EventObserverConfig};
 use crate::neon_node::PeerThread;
-use crate::tests::neon_integrations::test_observer;
+use crate::tests::neon_integrations::{submit_tx, test_observer};
 use crate::tests::{make_stacks_transfer, to_addr};
 use crate::{Config, ConfigFile};
 
@@ -75,6 +75,7 @@ fn observe_100_blocks() {
             let tip = NakamotoChainState::get_canonical_block_header(chainstate.db(), &sortdb)
                 .unwrap()
                 .unwrap();
+            // Bypass admission checks
             mempool
                 .submit_raw(
                     &mut chainstate,
@@ -120,3 +121,89 @@ fn observe_100_blocks() {
         .join()
         .expect("Failed to join node thread to exit");
 }
+
+#[test]
+fn mempool_rpc_submit() {
+    let mut conf = Config::from_config_file(ConfigFile::mockamoto()).unwrap();
+    conf.node.mockamoto_time_ms = 10;
+
+    let submitter_sk = StacksPrivateKey::from_seed(&[1]);
+    let submitter_addr = to_addr(&submitter_sk);
+    conf.add_initial_balance(submitter_addr.to_string(), 1_000);
+    let recipient_addr = StacksAddress::burn_address(false).into();
+
+    test_observer::spawn();
+    let observer_port = test_observer::EVENT_OBSERVER_PORT;
+    conf.events_observers.insert(EventObserverConfig {
+        endpoint: format!("localhost:{observer_port}"),
+        events_keys: vec![EventKeyType::AnyEvent],
+    });
+
+    let mut mockamoto = MockamotoNode::new(&conf).unwrap();
+    let globals = mockamoto.globals.clone();
+
+    let http_origin = format!("http://{}", &conf.node.rpc_bind);
+
+    let start = Instant::now();
+
+    let node_thread = thread::Builder::new()
+        .name("mockamoto-main".into())
+        .spawn(move || mockamoto.run())
+        .expect("FATAL: failed to start mockamoto main thread");
+
+    // make a transfer tx to test that the mockamoto miner picks up txs from the mempool
+    let tx_fee = 200;
+    let transfer_tx = make_stacks_transfer(&submitter_sk, 0, tx_fee, &recipient_addr, 100);
+    let transfer_tx_hex = format!("0x{}", to_hex(&transfer_tx));
+
+    // complete within 2 minutes or abort
+    let completed = loop {
+        if Instant::now().duration_since(start) > Duration::from_secs(120) {
+            break false;
+        }
+        let latest_block = test_observer::get_blocks().pop();
+        thread::sleep(Duration::from_secs(1));
+        let Some(ref latest_block) = latest_block else {
+            info!("No block observed yet!");
+            continue;
+        };
+        let stacks_block_height = latest_block.get("block_height").unwrap().as_u64().unwrap();
+        info!("Block height observed: {stacks_block_height}");
+
+        if stacks_block_height == 1 {
+            // Enforce admission checks by utilizing the RPC endpoint
+            submit_tx(&http_origin, &transfer_tx);
+        }
+
+        if stacks_block_height >= 100 {
+            break true;
+        }
+    };
+
+    globals.signal_stop();
+
+    let transfer_tx_included = test_observer::get_blocks()
+        .into_iter()
+        .find(|block_json| {
+            block_json["transactions"]
+                .as_array()
+                .unwrap()
+                .iter()
+                .find(|tx_json| tx_json["raw_tx"].as_str() == Some(&transfer_tx_hex))
+                .is_some()
+        })
+        .is_some();
+
+    assert!(
+        transfer_tx_included,
+        "Mockamoto node failed to include the transfer tx"
+    );
+
+    assert!(
+        completed,
+        "Mockamoto node failed to produce and announce 100 blocks before timeout"
+    );
+    node_thread
+        .join()
+        .expect("Failed to join node thread to exit");
+}

From f697611b10e56a20fee36abf03339ca174d80493 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 1 Dec 2023 09:00:16 -0500
Subject: [PATCH 0140/1166] Create a boot contract to initialize pre-pox-4
 aggregate key

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stackslib/src/chainstate/stacks/boot/mod.rs |  5 +++
 testnet/stacks-node/src/mockamoto.rs        | 46 +++++++++++++++++++--
 2 files changed, 47 insertions(+), 4 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 2f2cc637c7..2dfcef0b53 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -81,6 +81,11 @@ const POX_4_BODY: &'static str = std::include_str!("pox-4.clar");
 pub const COSTS_1_NAME: &'static str = "costs";
 pub const COSTS_2_NAME: &'static str = "costs-2";
 pub const COSTS_3_NAME: &'static str = "costs-3";
+/// This contract name is used in testnet **only** to lookup an initial
+///  setting for the pox-4 aggregate key. This contract should contain a `define-read-only`
+///  function called `aggregate-key` with zero arguments which returns a (buff 33)
+pub const BOOT_TEST_POX_4_AGG_KEY_CONTRACT: &'static str = "pox-4-agg-test-booter";
+pub const BOOT_TEST_POX_4_AGG_KEY_FNAME: &'static str = "aggregate-key";
 
 pub mod docs;
 
diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index 20bd7106b8..114f6c0418 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -5,8 +5,10 @@ use std::thread;
 use std::thread::{sleep, JoinHandle};
 use std::time::Duration;
 
+use clarity::boot_util::boot_code_id;
 use clarity::vm::ast::ASTRules;
-use clarity::vm::Value as ClarityValue;
+use clarity::vm::clarity::TransactionConnection;
+use clarity::vm::{ClarityVersion, Value as ClarityValue};
 use lazy_static::lazy_static;
 use stacks::burnchains::bitcoin::address::{
     BitcoinAddress, LegacyBitcoinAddress, LegacyBitcoinAddressType,
@@ -33,6 +35,9 @@ use stacks::chainstate::nakamoto::{
     NakamotoBlock, NakamotoBlockHeader, NakamotoChainState, SetupBlockResult,
 };
 use stacks::chainstate::stacks::address::PoxAddress;
+use stacks::chainstate::stacks::boot::{
+    BOOT_TEST_POX_4_AGG_KEY_CONTRACT, BOOT_TEST_POX_4_AGG_KEY_FNAME,
+};
 use stacks::chainstate::stacks::db::{ChainStateBootData, ClarityTx, StacksChainState};
 use stacks::chainstate::stacks::miner::{
     BlockBuilder, BlockBuilderSettings, BlockLimitFunction, MinerStatus, TransactionResult,
@@ -64,7 +69,7 @@ use stacks_common::types::chainstate::{
     StacksPrivateKey, VRFSeed,
 };
 use stacks_common::types::{PrivateKey, StacksEpochId};
-use stacks_common::util::hash::{Hash160, MerkleTree, Sha512Trunc256Sum};
+use stacks_common::util::hash::{to_hex, Hash160, MerkleTree, Sha512Trunc256Sum};
 use stacks_common::util::secp256k1::{MessageSignature, SchnorrSignature, Secp256k1PublicKey};
 use stacks_common::util::vrf::{VRFPrivateKey, VRFProof, VRFPublicKey, VRF};
 
@@ -405,7 +410,40 @@ impl MockamotoNode {
 
         initial_balances.push((stacker.into(), 100_000_000_000_000));
 
-        let mut boot_data = ChainStateBootData::new(&burnchain, initial_balances, None);
+        // Create a boot contract to initialize the aggregate public key prior to Pox-4 activation
+        let self_signer = SelfSigner::single_signer();
+        let agg_pub_key = to_hex(&self_signer.aggregate_public_key.compress().data);
+        info!("Mockamoto node setting agg public key"; "agg_pub_key" => &agg_pub_key);
+        let callback = move |clarity_tx: &mut ClarityTx| {
+            let contract_content = format!(
+                "(define-read-only ({}) 0x{})",
+                BOOT_TEST_POX_4_AGG_KEY_FNAME, agg_pub_key
+            );
+            let contract_id = boot_code_id(BOOT_TEST_POX_4_AGG_KEY_CONTRACT, false);
+            clarity_tx.connection().as_transaction(|clarity| {
+                let (ast, analysis) = clarity
+                    .analyze_smart_contract(
+                        &contract_id,
+                        ClarityVersion::Clarity2,
+                        &contract_content,
+                        ASTRules::PrecheckSize,
+                    )
+                    .unwrap();
+                clarity
+                    .initialize_smart_contract(
+                        &contract_id,
+                        ClarityVersion::Clarity2,
+                        &ast,
+                        &contract_content,
+                        None,
+                        |_, _| false,
+                    )
+                    .unwrap();
+                clarity.save_analysis(&contract_id, &analysis).unwrap();
+            })
+        };
+        let mut boot_data =
+            ChainStateBootData::new(&burnchain, initial_balances, Some(Box::new(callback)));
         let (chainstate, boot_receipts) = StacksChainState::open_and_exec(
             config.is_mainnet(),
             config.burnchain.chain_id,
@@ -446,7 +484,7 @@ impl MockamotoNode {
 
         Ok(MockamotoNode {
             sortdb,
-            self_signer: SelfSigner::single_signer(),
+            self_signer,
             chainstate,
             miner_key,
             vrf_key,

From 8783eab434aca97e81719d5dc57c62bad23e280e Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 1 Dec 2023 09:04:22 -0500
Subject: [PATCH 0141/1166] Retrieve boot contract init agg key and set all
 pre-pox-4 cycles to it

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stackslib/src/clarity_vm/clarity.rs | 75 +++++++++++++++++++++++++++--
 1 file changed, 71 insertions(+), 4 deletions(-)

diff --git a/stackslib/src/clarity_vm/clarity.rs b/stackslib/src/clarity_vm/clarity.rs
index aed3bb9947..59b5463d79 100644
--- a/stackslib/src/clarity_vm/clarity.rs
+++ b/stackslib/src/clarity_vm/clarity.rs
@@ -38,16 +38,17 @@ use clarity::vm::types::{
 use clarity::vm::{analysis, ast, ClarityVersion, ContractName};
 use stacks_common::consts::CHAIN_ID_TESTNET;
 use stacks_common::types::chainstate::{
-    BlockHeaderHash, BurnchainHeaderHash, SortitionId, StacksBlockId, TrieHash,
+    BlockHeaderHash, BurnchainHeaderHash, SortitionId, StacksAddress, StacksBlockId, TrieHash,
 };
 use stacks_common::util::secp256k1::MessageSignature;
 
 use crate::burnchains::{Burnchain, PoxConstants};
 use crate::chainstate::stacks::boot::{
     BOOT_CODE_COSTS, BOOT_CODE_COSTS_2, BOOT_CODE_COSTS_2_TESTNET, BOOT_CODE_COSTS_3,
-    BOOT_CODE_COST_VOTING_TESTNET as BOOT_CODE_COST_VOTING, BOOT_CODE_POX_TESTNET, COSTS_2_NAME,
-    COSTS_3_NAME, POX_2_MAINNET_CODE, POX_2_NAME, POX_2_TESTNET_CODE, POX_3_MAINNET_CODE,
-    POX_3_NAME, POX_3_TESTNET_CODE, POX_4_MAINNET_CODE, POX_4_NAME, POX_4_TESTNET_CODE,
+    BOOT_CODE_COST_VOTING_TESTNET as BOOT_CODE_COST_VOTING, BOOT_CODE_POX_TESTNET,
+    BOOT_TEST_POX_4_AGG_KEY_CONTRACT, BOOT_TEST_POX_4_AGG_KEY_FNAME, COSTS_2_NAME, COSTS_3_NAME,
+    POX_2_MAINNET_CODE, POX_2_NAME, POX_2_TESTNET_CODE, POX_3_MAINNET_CODE, POX_3_NAME,
+    POX_3_TESTNET_CODE, POX_4_MAINNET_CODE, POX_4_NAME, POX_4_TESTNET_CODE,
 };
 use crate::chainstate::stacks::db::{StacksAccount, StacksChainState};
 use crate::chainstate::stacks::events::{StacksTransactionEvent, StacksTransactionReceipt};
@@ -1343,6 +1344,32 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
             let pox_4_contract_tx =
                 StacksTransaction::new(tx_version.clone(), boot_code_auth.clone(), payload);
 
+            let initialized_agg_key = if !mainnet {
+                self.with_readonly_clarity_env(
+                    false,
+                    self.chain_id,
+                    ClarityVersion::Clarity2,
+                    StacksAddress::burn_address(false).into(),
+                    None,
+                    LimitedCostTracker::Free,
+                    |vm_env| {
+                        vm_env.execute_contract_allow_private(
+                            &boot_code_id(BOOT_TEST_POX_4_AGG_KEY_CONTRACT, false),
+                            BOOT_TEST_POX_4_AGG_KEY_FNAME,
+                            &[],
+                            true,
+                        )
+                    },
+                )
+                .ok()
+                .map(|agg_key_value| {
+                    Value::buff_from(agg_key_value.expect_buff(33))
+                        .expect("failed to reconstruct buffer")
+                })
+            } else {
+                None
+            };
+
             let pox_4_initialization_receipt = self.as_transaction(|tx_conn| {
                 // initialize with a synthetic transaction
                 debug!("Instantiate {} contract", &pox_4_contract_id);
@@ -1375,6 +1402,46 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
                     )
                     .expect("Failed to set burnchain parameters in PoX-3 contract");
 
+                // set the aggregate public key for all pre-pox-4 cycles, if in testnet, and can fetch a boot-setting
+                if !mainnet {
+                    if let Some(ref agg_pub_key) = initialized_agg_key {
+                        for set_in_reward_cycle in 0..pox_4_first_cycle {
+                            info!(
+                                "Setting initial aggregate-public-key in PoX-4";
+                                "agg_pub_key" => %agg_pub_key,
+                                "reward_cycle" => set_in_reward_cycle,
+                            );
+                            tx_conn
+                                .with_abort_callback(
+                                    |vm_env| {
+                                        vm_env.execute_in_env(
+                                            StacksAddress::burn_address(false).into(),
+                                            None,
+                                            None,
+                                            |env| {
+                                                env.execute_contract_allow_private(
+                                                    &pox_4_contract_id,
+                                                    "set-aggregate-public-key",
+                                                    &[
+                                                        SymbolicExpression::atom_value(
+                                                            Value::UInt(set_in_reward_cycle.into()),
+                                                        ),
+                                                        SymbolicExpression::atom_value(
+                                                            agg_pub_key.clone(),
+                                                        ),
+                                                    ],
+                                                    false,
+                                                )
+                                            },
+                                        )
+                                    },
+                                    |_, _| false,
+                                )
+                                .unwrap();
+                        }
+                    }
+                }
+
                 receipt
             });
 

From 24a16cdd3a309d9a845aea3b6bdcb9d8508f918a Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 1 Dec 2023 09:25:20 -0500
Subject: [PATCH 0142/1166] Only use the self_signer aggregate pub key for
 genesis blocks

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 testnet/stacks-node/src/mockamoto.rs | 23 ++++++++++++++++++++++-
 1 file changed, 22 insertions(+), 1 deletion(-)

diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index 114f6c0418..14f538ab4d 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -998,7 +998,28 @@ impl MockamotoNode {
         let config = self.chainstate.config();
         let chain_length = block.header.chain_length;
         let sortition_handle = self.sortdb.index_handle_at_tip();
-        let aggregate_public_key = self.self_signer.aggregate_public_key;
+        let aggregate_public_key = if chain_length <= 1 {
+            self.self_signer.aggregate_public_key
+        } else {
+            let block_sn = SortitionDB::get_block_snapshot_consensus(
+                sortition_handle.conn(),
+                &block.header.consensus_hash,
+            )?
+            .ok_or(ChainstateError::DBError(DBError::NotFoundError))?;
+            // TODO: https://github.com/stacks-network/stacks-core/issues/4109
+            // Update this to retrieve the last block in the last reward cycle rather than chain tip
+            let aggregate_key_block_header =
+                NakamotoChainState::get_canonical_block_header(self.chainstate.db(), &self.sortdb)?
+                    .unwrap();
+            let aggregate_public_key = NakamotoChainState::get_aggregate_public_key(
+                &self.sortdb,
+                &sortition_handle,
+                &mut self.chainstate,
+                block_sn.block_height,
+                &aggregate_key_block_header.index_block_hash(),
+            )?;
+            aggregate_public_key
+        };
         self.self_signer.sign_nakamoto_block(&mut block);
         let staging_tx = self.chainstate.staging_db_tx_begin()?;
         NakamotoChainState::accept_block(

From cad57dc91abbedcac3719547dde6fd92b2047fd3 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 1 Dec 2023 09:57:16 -0500
Subject: [PATCH 0143/1166] Set the aggregate public key for the NEXT reward
 cycle in every block

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 testnet/stacks-node/src/mockamoto.rs | 45 +++++++++++++++++++++++++++-
 1 file changed, 44 insertions(+), 1 deletion(-)

diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index 14f538ab4d..c3f9511ba1 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -904,7 +904,50 @@ impl MockamotoNode {
             parent_chain_length + 1,
         )?;
 
-        let txs = vec![tenure_tx, coinbase_tx, stacks_stx_tx];
+        // Set the aggregate public key for the NEXT reward cycle hence +1
+        let reward_cycle = self
+            .sortdb
+            .pox_constants
+            .block_height_to_reward_cycle(
+                self.sortdb.first_block_height,
+                sortition_tip.block_height,
+            )
+            .expect(
+                format!(
+                    "Failed to determine reward cycle of block height: {}",
+                    sortition_tip.block_height
+                )
+                .as_str(),
+            )
+            + 1;
+        let aggregate_payload = TransactionPayload::ContractCall(TransactionContractCall {
+            address: StacksAddress::burn_address(false),
+            contract_name: "pox-4".try_into().unwrap(),
+            function_name: "set-aggregate-public-key".try_into().unwrap(),
+            function_args: vec![
+                ClarityValue::UInt(u128::from(reward_cycle)),
+                ClarityValue::buff_from(
+                    self.self_signer
+                        .aggregate_public_key
+                        .compress()
+                        .data
+                        .to_vec(),
+                )
+                .expect("Failed to serialize aggregate public key"),
+            ],
+        });
+        let mut aggregate_tx: StacksTransaction = StacksTransaction::new(
+            TransactionVersion::Testnet,
+            TransactionAuth::from_p2pkh(&self.miner_key).unwrap(),
+            aggregate_payload,
+        );
+        aggregate_tx.chain_id = chain_id;
+        aggregate_tx.set_origin_nonce(miner_nonce + 3);
+        let mut aggregate_tx_signer = StacksTransactionSigner::new(&aggregate_tx);
+        aggregate_tx_signer.sign_origin(&self.miner_key).unwrap();
+        let aggregate_tx = aggregate_tx_signer.get_tx().unwrap();
+
+        let txs = vec![tenure_tx, coinbase_tx, stacks_stx_tx, aggregate_tx];
 
         let _ = match StacksChainState::process_block_transactions(
             &mut clarity_tx,

From 76ccefa8250ee2ec8e717fb8aea0308be59477bc Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 1 Dec 2023 10:41:45 -0500
Subject: [PATCH 0144/1166] Cleanup mine_stacks_block by pulling transaction
 construction into sep functions

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 testnet/stacks-node/src/mockamoto.rs | 270 +++++++++++++++------------
 1 file changed, 150 insertions(+), 120 deletions(-)

diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index c3f9511ba1..dee2af6049 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -36,7 +36,7 @@ use stacks::chainstate::nakamoto::{
 };
 use stacks::chainstate::stacks::address::PoxAddress;
 use stacks::chainstate::stacks::boot::{
-    BOOT_TEST_POX_4_AGG_KEY_CONTRACT, BOOT_TEST_POX_4_AGG_KEY_FNAME,
+    BOOT_TEST_POX_4_AGG_KEY_CONTRACT, BOOT_TEST_POX_4_AGG_KEY_FNAME, POX_4_NAME,
 };
 use stacks::chainstate::stacks::db::{ChainStateBootData, ClarityTx, StacksChainState};
 use stacks::chainstate::stacks::miner::{
@@ -72,6 +72,7 @@ use stacks_common::types::{PrivateKey, StacksEpochId};
 use stacks_common::util::hash::{to_hex, Hash160, MerkleTree, Sha512Trunc256Sum};
 use stacks_common::util::secp256k1::{MessageSignature, SchnorrSignature, Secp256k1PublicKey};
 use stacks_common::util::vrf::{VRFPrivateKey, VRFProof, VRFPublicKey, VRF};
+use wsts::curve::point::Point;
 
 use self::signer::SelfSigner;
 use crate::neon::Counters;
@@ -800,86 +801,46 @@ impl MockamotoNode {
             "chain_tip_ch" => %chain_tip_ch, "miner_account" => %miner_principal, "miner_nonce" => %miner_nonce,
         );
 
-        let vrf_proof = VRF::prove(&self.vrf_key, sortition_tip.sortition_hash.as_bytes());
-        let coinbase_tx_payload =
-            TransactionPayload::Coinbase(CoinbasePayload([1; 32]), None, Some(vrf_proof));
-        let mut coinbase_tx = StacksTransaction::new(
-            TransactionVersion::Testnet,
-            TransactionAuth::from_p2pkh(&self.miner_key).unwrap(),
-            coinbase_tx_payload,
-        );
-        coinbase_tx.chain_id = chain_id;
-        coinbase_tx.set_origin_nonce(miner_nonce + 1);
-        let mut coinbase_tx_signer = StacksTransactionSigner::new(&coinbase_tx);
-        coinbase_tx_signer.sign_origin(&self.miner_key).unwrap();
-        let coinbase_tx = coinbase_tx_signer.get_tx().unwrap();
-
         // Add a tenure change transaction to the block:
         //  as of now every mockamoto block is a tenure-change.
         // If mockamoto mode changes to support non-tenure-changing blocks, this will have
         //  to be gated.
-        let tenure_change_tx_payload = TransactionPayload::TenureChange(
-            TenureChangePayload {
-                previous_tenure_end: parent_block_id,
-                previous_tenure_blocks: 1,
-                cause: TenureChangeCause::BlockFound,
-                pubkey_hash: Hash160([0; 20]),
-
-                signers: vec![],
-            },
-            ThresholdSignature::mock(),
-        );
-        let mut tenure_tx = StacksTransaction::new(
-            TransactionVersion::Testnet,
-            TransactionAuth::from_p2pkh(&self.miner_key).unwrap(),
-            tenure_change_tx_payload,
-        );
-        tenure_tx.chain_id = chain_id;
-        tenure_tx.set_origin_nonce(miner_nonce);
-        let mut tenure_tx_signer = StacksTransactionSigner::new(&tenure_tx);
-        tenure_tx_signer.sign_origin(&self.miner_key).unwrap();
-        let tenure_tx = tenure_tx_signer.get_tx().unwrap();
-
-        let pox_address = PoxAddress::Standard(
-            StacksAddress::burn_address(false),
-            Some(AddressHashMode::SerializeP2PKH),
+        let tenure_tx =
+            make_tenure_change_tx(&self.miner_key, miner_nonce, chain_id, parent_block_id);
+        let vrf_proof = VRF::prove(&self.vrf_key, sortition_tip.sortition_hash.as_bytes());
+        let coinbase_tx =
+            make_coinbase_tx(&self.miner_key, miner_nonce + 1, chain_id, Some(vrf_proof));
+        let stacks_stx_tx = make_stacks_stx_tx(
+            &self.miner_key,
+            miner_nonce + 2,
+            chain_id,
+            parent_chain_length,
+            parent_burn_height,
         );
-
-        let stack_stx_payload = if parent_chain_length < 2 {
-            TransactionPayload::ContractCall(TransactionContractCall {
-                address: StacksAddress::burn_address(false),
-                contract_name: "pox-4".try_into().unwrap(),
-                function_name: "stack-stx".try_into().unwrap(),
-                function_args: vec![
-                    ClarityValue::UInt(99_000_000_000_000),
-                    pox_address.as_clarity_tuple().unwrap().into(),
-                    ClarityValue::UInt(u128::from(parent_burn_height)),
-                    ClarityValue::UInt(12),
-                ],
-            })
-        } else {
-            // NOTE: stack-extend doesn't currently work, because the PoX-4 lockup
-            //  special functions have not been implemented.
-            TransactionPayload::ContractCall(TransactionContractCall {
-                address: StacksAddress::burn_address(false),
-                contract_name: "pox-4".try_into().unwrap(),
-                function_name: "stack-extend".try_into().unwrap(),
-                function_args: vec![
-                    ClarityValue::UInt(5),
-                    pox_address.as_clarity_tuple().unwrap().into(),
-                ],
-            })
-        };
-        let mut stack_stx_tx = StacksTransaction::new(
-            TransactionVersion::Testnet,
-            TransactionAuth::from_p2pkh(&self.miner_key).unwrap(),
-            stack_stx_payload,
+        // Set the aggregate public key for the NEXT reward cycle hence +1
+        let reward_cycle = self
+            .sortdb
+            .pox_constants
+            .block_height_to_reward_cycle(
+                self.sortdb.first_block_height,
+                sortition_tip.block_height,
+            )
+            .expect(
+                format!(
+                    "Failed to determine reward cycle of block height: {}",
+                    sortition_tip.block_height
+                )
+                .as_str(),
+            )
+            + 1;
+        let aggregate_tx = make_aggregate_tx(
+            &self.miner_key,
+            miner_nonce + 3,
+            chain_id,
+            &self.self_signer.aggregate_public_key,
+            reward_cycle,
         );
-        stack_stx_tx.chain_id = chain_id;
-        stack_stx_tx.set_origin_nonce(miner_nonce + 2);
-        let mut stack_stx_tx_signer = StacksTransactionSigner::new(&stack_stx_tx);
-        stack_stx_tx_signer.sign_origin(&self.miner_key).unwrap();
-        let stacks_stx_tx = stack_stx_tx_signer.get_tx().unwrap();
+        let txs = vec![tenure_tx, coinbase_tx, stacks_stx_tx, aggregate_tx];
 
         let sortdb_handle = self.sortdb.index_conn();
         let SetupBlockResult {
@@ -904,51 +865,6 @@ impl MockamotoNode {
             parent_chain_length + 1,
         )?;
 
-        // Set the aggregate public key for the NEXT reward cycle hence +1
-        let reward_cycle = self
-            .sortdb
-            .pox_constants
-            .block_height_to_reward_cycle(
-                self.sortdb.first_block_height,
-                sortition_tip.block_height,
-            )
-            .expect(
-                format!(
-                    "Failed to determine reward cycle of block height: {}",
-                    sortition_tip.block_height
-                )
-                .as_str(),
-            )
-            + 1;
-        let aggregate_payload = TransactionPayload::ContractCall(TransactionContractCall {
-            address: StacksAddress::burn_address(false),
-            contract_name: "pox-4".try_into().unwrap(),
-            function_name: "set-aggregate-public-key".try_into().unwrap(),
-            function_args: vec![
-                ClarityValue::UInt(u128::from(reward_cycle)),
-                ClarityValue::buff_from(
-                    self.self_signer
-                        .aggregate_public_key
-                        .compress()
-                        .data
-                        .to_vec(),
-                )
-                .expect("Failed to serialize aggregate public key"),
-            ],
-        });
-        let mut aggregate_tx: StacksTransaction = StacksTransaction::new(
-            TransactionVersion::Testnet,
-            TransactionAuth::from_p2pkh(&self.miner_key).unwrap(),
-            aggregate_payload,
-        );
-        aggregate_tx.chain_id = chain_id;
-        aggregate_tx.set_origin_nonce(miner_nonce + 3);
-        let mut aggregate_tx_signer = StacksTransactionSigner::new(&aggregate_tx);
-        aggregate_tx_signer.sign_origin(&self.miner_key).unwrap();
-        let aggregate_tx = aggregate_tx_signer.get_tx().unwrap();
-
-        let txs = vec![tenure_tx, coinbase_tx, stacks_stx_tx, aggregate_tx];
-
         let _ = match StacksChainState::process_block_transactions(
             &mut clarity_tx,
             &txs,
@@ -1076,3 +992,117 @@ impl MockamotoNode {
         Ok(chain_length)
     }
 }
+
+// Helper function to make a signed tenure change transaction
+fn make_tenure_change_tx(
+    key: &StacksPrivateKey,
+    miner_nonce: u64,
+    chain_id: u32,
+    parent_block_id: StacksBlockId,
+) -> StacksTransaction {
+    let tenure_change_tx_payload = TransactionPayload::TenureChange(
+        TenureChangePayload {
+            previous_tenure_end: parent_block_id,
+            previous_tenure_blocks: 1,
+            cause: TenureChangeCause::BlockFound,
+            pubkey_hash: Hash160([0; 20]),
+            signers: vec![],
+        },
+        ThresholdSignature::mock(),
+    );
+    make_tx(key, miner_nonce, tenure_change_tx_payload, chain_id)
+}
+
+// Helper function to make a signed coinbase transaction
+fn make_coinbase_tx(
+    key: &StacksPrivateKey,
+    miner_nonce: u64,
+    chain_id: u32,
+    vrf_proof: Option<VRFProof>,
+) -> StacksTransaction {
+    let coinbase_tx_payload =
+        TransactionPayload::Coinbase(CoinbasePayload([1; 32]), None, vrf_proof);
+    make_tx(key, miner_nonce, coinbase_tx_payload, chain_id)
+}
+
+// Helper function to make a signed stacks-stx transaction
+fn make_stacks_stx_tx(
+    key: &StacksPrivateKey,
+    miner_nonce: u64,
+    chain_id: u32,
+    parent_chain_length: u64,
+    parent_burn_height: u32,
+) -> StacksTransaction {
+    let pox_address = PoxAddress::Standard(
+        StacksAddress::burn_address(false),
+        Some(AddressHashMode::SerializeP2PKH),
+    );
+
+    let stack_stx_payload = if parent_chain_length < 2 {
+        TransactionPayload::ContractCall(TransactionContractCall {
+            address: StacksAddress::burn_address(false),
+            contract_name: POX_4_NAME.into(),
+            function_name: "stack-stx".try_into().unwrap(),
+            function_args: vec![
+                ClarityValue::UInt(99_000_000_000_000),
+                pox_address.as_clarity_tuple().unwrap().into(),
+                ClarityValue::UInt(u128::from(parent_burn_height)),
+                ClarityValue::UInt(12),
+            ],
+        })
+    } else {
+        // NOTE: stack-extend doesn't currently work, because the PoX-4 lockup
+        //  special functions have not been implemented.
+        TransactionPayload::ContractCall(TransactionContractCall {
+            address: StacksAddress::burn_address(false),
+            contract_name: POX_4_NAME.into(),
+            function_name: "stack-extend".try_into().unwrap(),
+            function_args: vec![
+                ClarityValue::UInt(5),
+                pox_address.as_clarity_tuple().unwrap().into(),
+            ],
+        })
+    };
+    make_tx(key, miner_nonce, stack_stx_payload, chain_id)
+}
+
+/// Helper function to make a set-aggregate-public-key transaction
+fn make_aggregate_tx(
+    key: &StacksPrivateKey,
+    nonce: u64,
+    chain_id: u32,
+    aggregate_public_key: &Point,
+    reward_cycle: u64,
+) -> StacksTransaction {
+    let aggregate_payload = TransactionPayload::ContractCall(TransactionContractCall {
+        address: StacksAddress::burn_address(false),
+        contract_name: POX_4_NAME.into(),
+        function_name: "set-aggregate-public-key".try_into().unwrap(),
+        function_args: vec![
+            ClarityValue::UInt(u128::from(reward_cycle)),
+            ClarityValue::buff_from(aggregate_public_key.compress().data.to_vec())
+                .expect("Failed to serialize aggregate public key"),
+        ],
+    });
+    make_tx(&key, nonce, aggregate_payload, chain_id)
+}
+
+/// Helper function to create a zero fee transaction
+/// TODO: this is duplicated in so many places. We should have a utils fn for this
+fn make_tx(
+    key: &StacksPrivateKey,
+    nonce: u64,
+    tx_payload: TransactionPayload,
+    chain_id: u32,
+) -> StacksTransaction {
+    let mut tx = StacksTransaction::new(
+        TransactionVersion::Testnet,
+        TransactionAuth::from_p2pkh(&key).unwrap(),
+        tx_payload,
+    );
+    tx.chain_id = chain_id;
+    tx.set_origin_nonce(nonce);
+    let mut tx_signer = StacksTransactionSigner::new(&tx);
+    tx_signer.sign_origin(&key).unwrap();
+    tx_signer.get_tx().unwrap()
+}

From 03848a3341597a68954178a2af1fcc54ac44fec5 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Mon, 4 Dec 2023 10:38:44 -0500
Subject: [PATCH 0145/1166] CRC: add test to set and get the aggregate public
 key

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 testnet/stacks-node/src/mockamoto/tests.rs | 162 ++++++++++++++++++++-
 1 file changed, 161 insertions(+), 1 deletion(-)

diff --git a/testnet/stacks-node/src/mockamoto/tests.rs b/testnet/stacks-node/src/mockamoto/tests.rs
index d1f3696418..91325431c2 100644
--- a/testnet/stacks-node/src/mockamoto/tests.rs
+++ b/testnet/stacks-node/src/mockamoto/tests.rs
@@ -1,18 +1,25 @@
 use std::thread;
 use std::time::{Duration, Instant};
 
+use clarity::boot_util::boot_code_addr;
 use clarity::vm::costs::ExecutionCost;
+use clarity::vm::Value;
+use rand_core::OsRng;
+use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::nakamoto::NakamotoChainState;
+use stacks::chainstate::stacks::boot::POX_4_NAME;
 use stacks::chainstate::stacks::db::StacksChainState;
 use stacks_common::types::chainstate::{StacksAddress, StacksPrivateKey};
 use stacks_common::types::StacksEpochId;
 use stacks_common::util::hash::to_hex;
+use wsts::curve::point::Point;
+use wsts::curve::scalar::Scalar;
 
 use super::MockamotoNode;
 use crate::config::{EventKeyType, EventObserverConfig};
 use crate::neon_node::PeerThread;
 use crate::tests::neon_integrations::test_observer;
-use crate::tests::{make_stacks_transfer, to_addr};
+use crate::tests::{make_contract_call, make_stacks_transfer, to_addr};
 use crate::{Config, ConfigFile};
 
 #[test]
@@ -120,3 +127,156 @@ fn observe_100_blocks() {
         .join()
         .expect("Failed to join node thread to exit");
 }
+
+#[test]
+fn observe_set_aggregate_tx() {
+    let mut conf = Config::from_config_file(ConfigFile::mockamoto()).unwrap();
+    conf.node.mockamoto_time_ms = 10;
+
+    let submitter_sk = StacksPrivateKey::from_seed(&[1]);
+    let submitter_addr = to_addr(&submitter_sk);
+    conf.add_initial_balance(submitter_addr.to_string(), 1_000);
+
+    test_observer::spawn();
+    let observer_port = test_observer::EVENT_OBSERVER_PORT;
+    conf.events_observers.push(EventObserverConfig {
+        endpoint: format!("localhost:{observer_port}"),
+        events_keys: vec![EventKeyType::AnyEvent],
+    });
+
+    let mut mockamoto = MockamotoNode::new(&conf).unwrap();
+
+    let globals = mockamoto.globals.clone();
+
+    let mut mempool = PeerThread::connect_mempool_db(&conf);
+    let (mut chainstate, _) = StacksChainState::open(
+        conf.is_mainnet(),
+        conf.burnchain.chain_id,
+        &conf.get_chainstate_path_str(),
+        None,
+    )
+    .unwrap();
+    let burnchain = conf.get_burnchain();
+    let sortdb = burnchain.open_sortition_db(true).unwrap();
+    let sortition_tip = SortitionDB::get_canonical_burn_chain_tip(mockamoto.sortdb.conn()).unwrap();
+
+    let start = Instant::now();
+    // Get a reward cycle to compare against
+    let reward_cycle = mockamoto
+        .sortdb
+        .pox_constants
+        .block_height_to_reward_cycle(
+            mockamoto.sortdb.first_block_height,
+            sortition_tip.block_height,
+        )
+        .expect(
+            format!(
+                "Failed to determine reward cycle of block height: {}",
+                sortition_tip.block_height
+            )
+            .as_str(),
+        );
+
+    let node_thread = thread::Builder::new()
+        .name("mockamoto-main".into())
+        .spawn(move || {
+            mockamoto.run();
+            let aggregate_key_block_header = NakamotoChainState::get_canonical_block_header(
+                mockamoto.chainstate.db(),
+                &mockamoto.sortdb,
+            )
+            .unwrap()
+            .unwrap();
+            // Get the aggregate public key to later verify that it was set correctly
+            mockamoto
+                .chainstate
+                .get_aggregate_public_key_pox_4(
+                    &mockamoto.sortdb,
+                    &aggregate_key_block_header.index_block_hash(),
+                    reward_cycle,
+                )
+                .unwrap()
+        })
+        .expect("FATAL: failed to start mockamoto main thread");
+
+    // Create a "set-aggregate-public-key" tx to verify it sets correctly
+    let mut rng = OsRng::default();
+    let x = Scalar::random(&mut rng);
+    let random_key = Point::from(x);
+
+    let aggregate_public_key = Value::buff_from(random_key.compress().data.to_vec())
+        .expect("Failed to serialize aggregate public key");
+    let aggregate_tx = make_contract_call(
+        &submitter_sk,
+        0,
+        10,
+        &boot_code_addr(false),
+        POX_4_NAME,
+        "set-aggregate-public-key",
+        &[Value::UInt(u128::from(reward_cycle)), aggregate_public_key],
+    );
+    let aggregate_tx_hex = format!("0x{}", to_hex(&aggregate_tx));
+
+    // complete within 5 seconds or abort (we are only observing one block)
+    let completed = loop {
+        if Instant::now().duration_since(start) > Duration::from_secs(5) {
+            break false;
+        }
+        let latest_block = test_observer::get_blocks().pop();
+        thread::sleep(Duration::from_secs(1));
+        let Some(ref latest_block) = latest_block else {
+            info!("No block observed yet!");
+            continue;
+        };
+        let stacks_block_height = latest_block.get("block_height").unwrap().as_u64().unwrap();
+        info!("Block height observed: {stacks_block_height}");
+
+        // Submit the aggregate tx for processing to update the aggregate public key
+        let tip = NakamotoChainState::get_canonical_block_header(chainstate.db(), &sortdb)
+            .unwrap()
+            .unwrap();
+        mempool
+            .submit_raw(
+                &mut chainstate,
+                &sortdb,
+                &tip.consensus_hash,
+                &tip.anchored_header.block_hash(),
+                aggregate_tx.clone(),
+                &ExecutionCost::max_value(),
+                &StacksEpochId::Epoch30,
+            )
+            .unwrap();
+        break true;
+    };
+
+    globals.signal_stop();
+
+    let aggregate_key = node_thread
+        .join()
+        .expect("Failed to join node thread to exit");
+
+    // Did we set and retrieve the aggregate key correctly?
+    assert_eq!(aggregate_key.unwrap(), random_key);
+
+    let aggregate_tx_included = test_observer::get_blocks()
+        .into_iter()
+        .find(|block_json| {
+            block_json["transactions"]
+                .as_array()
+                .unwrap()
+                .iter()
+                .find(|tx_json| tx_json["raw_tx"].as_str() == Some(&aggregate_tx_hex))
+                .is_some()
+        })
+        .is_some();
+
+    assert!(
+        aggregate_tx_included,
+        "Mockamoto node failed to include the aggregate tx"
+    );
+
+    assert!(
+        completed,
+        "Mockamoto node failed to produce and announce its block before timeout"
+    );
+}

From 90dce75a6dc27670fc48b02dce7ae41d0eaac155 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Mon, 4 Dec 2023 16:59:00 -0500
Subject: [PATCH 0146/1166] CRC: check that the initial aggregate key was set
 correctly

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 testnet/stacks-node/src/mockamoto/tests.rs | 34 ++++++++++++++++------
 1 file changed, 25 insertions(+), 9 deletions(-)

diff --git a/testnet/stacks-node/src/mockamoto/tests.rs b/testnet/stacks-node/src/mockamoto/tests.rs
index 91325431c2..aab08337ac 100644
--- a/testnet/stacks-node/src/mockamoto/tests.rs
+++ b/testnet/stacks-node/src/mockamoto/tests.rs
@@ -145,6 +145,8 @@ fn observe_set_aggregate_tx() {
     });
 
     let mut mockamoto = MockamotoNode::new(&conf).unwrap();
+    // Get the aggregate public key of the original reward cycle to compare against
+    let orig_key = mockamoto.self_signer.aggregate_public_key;
 
     let globals = mockamoto.globals.clone();
 
@@ -161,7 +163,7 @@ fn observe_set_aggregate_tx() {
     let sortition_tip = SortitionDB::get_canonical_burn_chain_tip(mockamoto.sortdb.conn()).unwrap();
 
     let start = Instant::now();
-    // Get a reward cycle to compare against
+    // Get the reward cycle of the sortition tip
     let reward_cycle = mockamoto
         .sortdb
         .pox_constants
@@ -187,15 +189,25 @@ fn observe_set_aggregate_tx() {
             )
             .unwrap()
             .unwrap();
-            // Get the aggregate public key to later verify that it was set correctly
-            mockamoto
+            // Get the aggregate public key of the original reward cycle
+            let orig_aggregate_key = mockamoto
                 .chainstate
                 .get_aggregate_public_key_pox_4(
                     &mockamoto.sortdb,
                     &aggregate_key_block_header.index_block_hash(),
                     reward_cycle,
                 )
-                .unwrap()
+                .unwrap();
+            // Get the aggregate public key of the next reward cycle that we manually overwrote
+            let new_aggregate_key = mockamoto
+                .chainstate
+                .get_aggregate_public_key_pox_4(
+                    &mockamoto.sortdb,
+                    &aggregate_key_block_header.index_block_hash(),
+                    reward_cycle + 1,
+                )
+                .unwrap();
+            (orig_aggregate_key, new_aggregate_key)
         })
         .expect("FATAL: failed to start mockamoto main thread");
 
@@ -213,7 +225,10 @@ fn observe_set_aggregate_tx() {
         &boot_code_addr(false),
         POX_4_NAME,
         "set-aggregate-public-key",
-        &[Value::UInt(u128::from(reward_cycle)), aggregate_public_key],
+        &[
+            Value::UInt(u128::from(reward_cycle + 1)),
+            aggregate_public_key,
+        ],
     );
     let aggregate_tx_hex = format!("0x{}", to_hex(&aggregate_tx));
 
@@ -251,13 +266,10 @@ fn observe_set_aggregate_tx() {
 
     globals.signal_stop();
 
-    let aggregate_key = node_thread
+    let (orig_aggregate_key, new_aggregate_key) = node_thread
         .join()
         .expect("Failed to join node thread to exit");
 
-    // Did we set and retrieve the aggregate key correctly?
-    assert_eq!(aggregate_key.unwrap(), random_key);
-
     let aggregate_tx_included = test_observer::get_blocks()
         .into_iter()
         .find(|block_json| {
@@ -279,4 +291,8 @@ fn observe_set_aggregate_tx() {
         completed,
         "Mockamoto node failed to produce and announce its block before timeout"
     );
+
+    // Did we set and retrieve the aggregate key correctly?
+    assert_eq!(orig_aggregate_key.unwrap(), orig_key);
+    assert_eq!(new_aggregate_key.unwrap(), random_key);
 }

From b79762aabe65ba95d7af82b69b8703dcd0c9607a Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Thu, 7 Dec 2023 07:53:37 -0500
Subject: [PATCH 0147/1166] Fix failed rebase by updating mockamoto tests.rs to
 use insert instead of push

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 testnet/stacks-node/src/mockamoto/tests.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/testnet/stacks-node/src/mockamoto/tests.rs b/testnet/stacks-node/src/mockamoto/tests.rs
index aab08337ac..915833ea20 100644
--- a/testnet/stacks-node/src/mockamoto/tests.rs
+++ b/testnet/stacks-node/src/mockamoto/tests.rs
@@ -139,7 +139,7 @@ fn observe_set_aggregate_tx() {
 
     test_observer::spawn();
     let observer_port = test_observer::EVENT_OBSERVER_PORT;
-    conf.events_observers.push(EventObserverConfig {
+    conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{observer_port}"),
         events_keys: vec![EventKeyType::AnyEvent],
     });

From 863ae14f02508cd52957f0aec68a5846afcdbac5 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Mon, 11 Dec 2023 17:15:27 -0500
Subject: [PATCH 0148/1166] chore: pull forward canonical block header pointer

---
 stackslib/src/chainstate/burn/db/sortdb.rs | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/stackslib/src/chainstate/burn/db/sortdb.rs b/stackslib/src/chainstate/burn/db/sortdb.rs
index 08f268e1ab..84c095526b 100644
--- a/stackslib/src/chainstate/burn/db/sortdb.rs
+++ b/stackslib/src/chainstate/burn/db/sortdb.rs
@@ -9012,9 +9012,10 @@ pub mod tests {
                 stacks_block_accepted: false,
                 stacks_block_height: 0,
                 arrival_index: 0,
-                canonical_stacks_tip_height: 0,
-                canonical_stacks_tip_hash: BlockHeaderHash([0u8; 32]),
-                canonical_stacks_tip_consensus_hash: ConsensusHash([0u8; 20]),
+                canonical_stacks_tip_height: last_snapshot.canonical_stacks_tip_height,
+                canonical_stacks_tip_hash: last_snapshot.canonical_stacks_tip_hash,
+                canonical_stacks_tip_consensus_hash: last_snapshot
+                    .canonical_stacks_tip_consensus_hash,
                 miner_pk_hash: None,
             };
             new_snapshots.push(snapshot.clone());

From 5dfbb254c135ff55f638267d01e35de003c3e767 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Mon, 11 Dec 2023 17:15:52 -0500
Subject: [PATCH 0149/1166] chore: API sync

---
 .../chainstate/nakamoto/coordinator/tests.rs  | 24 ++++++++-----------
 1 file changed, 10 insertions(+), 14 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index 6fcea6260f..cbea297bc6 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -430,7 +430,7 @@ fn test_nakamoto_chainstate_getters() {
 
         // no tenures yet
         assert!(
-            NakamotoChainState::get_highest_nakamoto_tenure(chainstate.db(), &mut sort_tx)
+            NakamotoChainState::get_highest_nakamoto_tenure(chainstate.db(), sort_tx.sqlite())
                 .unwrap()
                 .is_none()
         );
@@ -563,7 +563,7 @@ fn test_nakamoto_chainstate_getters() {
 
         // we now have a tenure, and it confirms the last epoch2 block
         let highest_tenure =
-            NakamotoChainState::get_highest_nakamoto_tenure(chainstate.db(), &mut sort_tx)
+            NakamotoChainState::get_highest_nakamoto_tenure(chainstate.db(), sort_tx.sqlite())
                 .unwrap()
                 .unwrap();
         assert_eq!(highest_tenure.coinbase_height, 12);
@@ -591,7 +591,7 @@ fn test_nakamoto_chainstate_getters() {
         .is_some());
         assert!(NakamotoChainState::check_tenure_continuity(
             chainstate.db(),
-            &mut sort_tx,
+            sort_tx.sqlite(),
             &blocks[0].header.consensus_hash,
             &blocks[1].header
         )
@@ -755,7 +755,7 @@ fn test_nakamoto_chainstate_getters() {
 
         // we now have a new highest tenure
         let highest_tenure =
-            NakamotoChainState::get_highest_nakamoto_tenure(chainstate.db(), &mut sort_tx)
+            NakamotoChainState::get_highest_nakamoto_tenure(chainstate.db(), sort_tx.sqlite())
                 .unwrap()
                 .unwrap();
         assert_eq!(highest_tenure.coinbase_height, 13);
@@ -780,14 +780,14 @@ fn test_nakamoto_chainstate_getters() {
         .is_none());
         assert!(NakamotoChainState::check_tenure_continuity(
             chainstate.db(),
-            &mut sort_tx,
+            sort_tx.sqlite(),
             &new_blocks[0].header.consensus_hash,
             &new_blocks[1].header
         )
         .unwrap());
         assert!(!NakamotoChainState::check_tenure_continuity(
             chainstate.db(),
-            &mut sort_tx,
+            sort_tx.sqlite(),
             &blocks[0].header.consensus_hash,
             &new_blocks[1].header
         )
@@ -1306,9 +1306,8 @@ fn test_simple_nakamoto_coordinator_2_tenures_3_sortitions() {
         let chainstate = &mut peer.stacks_node.as_mut().unwrap().chainstate;
         let sort_db = peer.sortdb.as_mut().unwrap();
         let tip = SortitionDB::get_canonical_burn_chain_tip(sort_db.conn()).unwrap();
-        let mut sort_handle = sort_db.index_handle(&tip.sortition_id);
         let tenure =
-            NakamotoChainState::get_highest_nakamoto_tenure(chainstate.db(), &mut sort_handle)
+            NakamotoChainState::get_highest_nakamoto_tenure(chainstate.db(), sort_db.conn())
                 .unwrap()
                 .unwrap();
         (tenure, tip)
@@ -1399,9 +1398,8 @@ fn test_simple_nakamoto_coordinator_2_tenures_3_sortitions() {
         let chainstate = &mut peer.stacks_node.as_mut().unwrap().chainstate;
         let sort_db = peer.sortdb.as_mut().unwrap();
         let tip = SortitionDB::get_canonical_burn_chain_tip(sort_db.conn()).unwrap();
-        let mut sort_handle = sort_db.index_handle(&tip.sortition_id);
         let tenure =
-            NakamotoChainState::get_highest_nakamoto_tenure(chainstate.db(), &mut sort_handle)
+            NakamotoChainState::get_highest_nakamoto_tenure(chainstate.db(), sort_db.conn())
                 .unwrap()
                 .unwrap();
         (tenure, tip)
@@ -1495,9 +1493,8 @@ fn test_simple_nakamoto_coordinator_2_tenures_3_sortitions() {
         let chainstate = &mut peer.stacks_node.as_mut().unwrap().chainstate;
         let sort_db = peer.sortdb.as_mut().unwrap();
         let tip = SortitionDB::get_canonical_burn_chain_tip(sort_db.conn()).unwrap();
-        let mut sort_handle = sort_db.index_handle(&tip.sortition_id);
         let tenure =
-            NakamotoChainState::get_highest_nakamoto_tenure(chainstate.db(), &mut sort_handle)
+            NakamotoChainState::get_highest_nakamoto_tenure(chainstate.db(), sort_db.conn())
                 .unwrap()
                 .unwrap();
         (tenure, tip)
@@ -1641,9 +1638,8 @@ fn test_simple_nakamoto_coordinator_10_tenures_and_extensions_10_blocks() {
             let chainstate = &mut peer.stacks_node.as_mut().unwrap().chainstate;
             let sort_db = peer.sortdb.as_mut().unwrap();
             let tip = SortitionDB::get_canonical_burn_chain_tip(sort_db.conn()).unwrap();
-            let mut sort_handle = sort_db.index_handle(&tip.sortition_id);
             let tenure =
-                NakamotoChainState::get_highest_nakamoto_tenure(chainstate.db(), &mut sort_handle)
+                NakamotoChainState::get_highest_nakamoto_tenure(chainstate.db(), sort_db.conn())
                     .unwrap()
                     .unwrap();
             (tenure, tip)

From 6934d7df44ee17f1bfd01dfb273042d75786f1bd Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Mon, 11 Dec 2023 17:16:01 -0500
Subject: [PATCH 0150/1166] chore: remove dead code

---
 stackslib/src/chainstate/nakamoto/mod.rs | 26 ++----------------------
 1 file changed, 2 insertions(+), 24 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index 6d6bb8b6ab..2ae02a4e93 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -1479,29 +1479,6 @@ impl NakamotoChainState {
                     ChainstateError::NoSuchBlockError
                 })?;
         Ok(burn_view_sn.total_burn)
-        /*
-        let target_ch = if let Some(tenure_payload) = block.get_tenure_tx_payload() {
-            tenure_payload.burn_view_consensus_hash
-        } else if let Some(highest_tenure) =
-            Self::get_highest_nakamoto_tenure(chainstate_conn, sort_handle)?
-        {
-            highest_tenure.burn_view_consensus_hash
-        } else {
-            // no nakamoto tenures yet, so this is the consensus hash of the canonical stacks tip
-            let (consensus_hash, _) =
-                SortitionDB::get_canonical_stacks_chain_tip_hash(sort_handle.sqlite())?;
-            consensus_hash
-        };
-
-        let Some(sn) = SortitionDB::get_block_snapshot_consensus(sort_handle.sqlite(), &target_ch)?
-        else {
-            warn!("Unacceptable Nakamoto block -- no sortition for tenure";
-                  "burn_view_consensus_hash" => %target_ch
-            );
-            return Ok(None);
-        };
-        Ok(Some(sn.total_burn))
-        */
     }
 
     /// Validate that a Nakamoto block attaches to the burn chain state.
@@ -2615,7 +2592,7 @@ impl NakamotoChainState {
                 // this block is mined in the ongoing tenure.
                 if !Self::check_tenure_continuity(
                     chainstate_tx,
-                    burn_dbconn,
+                    burn_dbconn.sqlite(),
                     &parent_ch,
                     &block.header,
                 )? {
@@ -2909,6 +2886,7 @@ impl NakamotoChainState {
                     sn.burn_header_timestamp,
                 )
             };
+
         let epoch_receipt = StacksEpochReceipt {
             header: new_tip,
             tx_receipts,

From e52e57020356367f4d52d496fda22d244cc3e17b Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Mon, 11 Dec 2023 17:16:12 -0500
Subject: [PATCH 0151/1166] chore: query highest tenure from memoized canonical
 stacks chain tip

---
 stackslib/src/chainstate/nakamoto/tenure.rs | 85 ++++-----------------
 1 file changed, 16 insertions(+), 69 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/tenure.rs b/stackslib/src/chainstate/nakamoto/tenure.rs
index 8496e74fd6..3fa254b977 100644
--- a/stackslib/src/chainstate/nakamoto/tenure.rs
+++ b/stackslib/src/chainstate/nakamoto/tenure.rs
@@ -510,73 +510,20 @@ impl NakamotoChainState {
     }
 
     /// Get the highest processed tenure on the canonical sortition history.
-    pub fn get_highest_nakamoto_tenure<SH: SortitionHandle>(
-        conn: &Connection,
-        sort_handle: &mut SH,
+    pub fn get_highest_nakamoto_tenure(
+        headers_conn: &Connection,
+        sortdb_conn: &Connection,
     ) -> Result<Option<NakamotoTenure>, ChainstateError> {
-        let mut max_search_coinbase_height = u64::try_from(i64::MAX - 1).expect("infallible");
-        while max_search_coinbase_height > 0 {
-            let Some(max_coinbase_height) =
-                Self::get_highest_nakamoto_coinbase_height(conn, max_search_coinbase_height)?
-            else {
-                // no tenures yet
-                test_debug!(
-                    "No tenures yet (max search height was {})",
-                    max_search_coinbase_height
-                );
-                return Ok(None);
-            };
-
-            let sql = "SELECT * FROM nakamoto_tenures WHERE coinbase_height = ?1 ORDER BY tenure_index DESC";
-            let args: &[&dyn ToSql] = &[&u64_to_sql(max_coinbase_height)?];
-            let tenures: Vec<NakamotoTenure> = query_rows(conn, sql, args)?;
-
-            test_debug!(
-                "Found {} tenures at coinbase height {}",
-                tenures.len(),
-                max_coinbase_height
-            );
-
-            // find the one that's in the canonical sortition history
-            for tenure in tenures.into_iter() {
-                // check the tenure consensus and the sortition consensus
-                let mut canonical = true;
-                for ch in &[
-                    &tenure.tenure_id_consensus_hash,
-                    &tenure.burn_view_consensus_hash,
-                ] {
-                    let Some(sn) =
-                        SortitionDB::get_block_snapshot_consensus(sort_handle.sqlite(), ch)?
-                    else {
-                        // not in sortition DB.
-                        // This is unreachable, but be defensive and just skip it.
-                        canonical = false;
-                        break;
-                    };
-                    let Some(ancestor_snapshot) =
-                        sort_handle.get_block_snapshot_by_height(sn.block_height)?
-                    else {
-                        // not canonical
-                        canonical = false;
-                        break;
-                    };
-                    if ancestor_snapshot.sortition_id != sn.sortition_id {
-                        // not canonical
-                        canonical = false;
-                        break;
-                    }
-                }
-                if canonical {
-                    return Ok(Some(tenure));
-                }
-            }
-
-            // no tenures at max_search_coinbase_height were canonical,
-            // but lower ones may be!
-            max_search_coinbase_height = max_coinbase_height.saturating_sub(1);
+        // find the tenure for the Stacks chain tip
+        let (tip_ch, tip_bhh) = SortitionDB::get_canonical_stacks_chain_tip_hash(sortdb_conn)?;
+        if tip_ch == FIRST_BURNCHAIN_CONSENSUS_HASH || tip_bhh == FIRST_STACKS_BLOCK_HASH {
+            // no chain tip, so no tenure
+            return Ok(None);
         }
-        // no tenures at all were canonical
-        Ok(None)
+        let sql = "SELECT * FROM nakamoto_tenures WHERE tenure_id_consensus_hash = ?1 ORDER BY tenure_index DESC LIMIT 1";
+        let args: &[&dyn ToSql] = &[&tip_ch];
+        let tenure_opt: Option<NakamotoTenure> = query_row(headers_conn, sql, args)?;
+        Ok(tenure_opt)
     }
 
     /// Verify that a tenure change tx is a valid first-ever tenure change.  It must connect to an
@@ -761,7 +708,7 @@ impl NakamotoChainState {
         }
 
         let Some(highest_processed_tenure) =
-            Self::get_highest_nakamoto_tenure(headers_conn, sort_handle)?
+            Self::get_highest_nakamoto_tenure(headers_conn, sort_handle.sqlite())?
         else {
             // no previous tenures.  This is the first tenure change.  It should point to an epoch
             // 2.x block.
@@ -914,9 +861,9 @@ impl NakamotoChainState {
     ///
     /// Returns Ok(bool) to indicate whether or not this block is in the same tenure as its parent.
     /// Returns Err(..) on DB error
-    pub(crate) fn check_tenure_continuity<SH: SortitionHandle>(
+    pub(crate) fn check_tenure_continuity(
         headers_conn: &Connection,
-        sort_handle: &mut SH,
+        sortdb_conn: &Connection,
         parent_ch: &ConsensusHash,
         block_header: &NakamotoBlockHeader,
     ) -> Result<bool, ChainstateError> {
@@ -926,7 +873,7 @@ impl NakamotoChainState {
         }
 
         // block must be in the same tenure as the highest-processed tenure.
-        let Some(highest_tenure) = Self::get_highest_nakamoto_tenure(headers_conn, sort_handle)?
+        let Some(highest_tenure) = Self::get_highest_nakamoto_tenure(headers_conn, sortdb_conn)?
         else {
             // no tenures yet, so definitely not continuous
             return Ok(false);

From 375db58e2fd621ce9049098fb69f869694c52bb1 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Mon, 11 Dec 2023 17:16:35 -0500
Subject: [PATCH 0152/1166] fix: get fork test to work with new highest-tenure
 query

---
 .../src/chainstate/nakamoto/tests/mod.rs      | 114 +++++++++++++++---
 1 file changed, 95 insertions(+), 19 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/tests/mod.rs b/stackslib/src/chainstate/nakamoto/tests/mod.rs
index 8731258938..a5eb5c7c2f 100644
--- a/stackslib/src/chainstate/nakamoto/tests/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/mod.rs
@@ -27,6 +27,7 @@ use stacks_common::types::chainstate::{
     StacksPublicKey, StacksWorkScore, TrieHash,
 };
 use stacks_common::types::{Address, PrivateKey, StacksEpoch, StacksEpochId};
+use stacks_common::util::get_epoch_time_secs;
 use stacks_common::util::hash::{hex_bytes, Hash160, MerkleTree, Sha512Trunc256Sum};
 use stacks_common::util::secp256k1::{MessageSignature, Secp256k1PublicKey};
 use stacks_common::util::vrf::{VRFPrivateKey, VRFProof, VRFPublicKey, VRF};
@@ -35,7 +36,7 @@ use stx_genesis::GenesisData;
 
 use crate::burnchains::{PoxConstants, Txid};
 use crate::chainstate::burn::db::sortdb::tests::make_fork_run;
-use crate::chainstate::burn::db::sortdb::SortitionDB;
+use crate::chainstate::burn::db::sortdb::{SortitionDB, SortitionHandleTx};
 use crate::chainstate::burn::{BlockSnapshot, OpsHash, SortitionHash};
 use crate::chainstate::coordinator::tests::{
     get_burnchain, get_burnchain_db, get_chainstate, get_rw_sortdb, get_sortition_db, p2pkh_from,
@@ -1438,6 +1439,72 @@ fn test_nakamoto_block_static_verification() {
         .is_err());
 }
 
+/// Mock block arrivals
+fn make_fork_run_with_arrivals(
+    sort_db: &mut SortitionDB,
+    start_snapshot: &BlockSnapshot,
+    length: u64,
+    bit_pattern: u8,
+) -> Vec<BlockSnapshot> {
+    let mut last_snapshot = start_snapshot.clone();
+    let mut new_snapshots = vec![];
+    for i in last_snapshot.block_height..(last_snapshot.block_height + length) {
+        let snapshot = BlockSnapshot {
+            accumulated_coinbase_ustx: 0,
+            pox_valid: true,
+            block_height: last_snapshot.block_height + 1,
+            burn_header_timestamp: get_epoch_time_secs(),
+            burn_header_hash: BurnchainHeaderHash([(i as u8) | bit_pattern; 32]),
+            sortition_id: SortitionId([(i as u8) | bit_pattern; 32]),
+            parent_sortition_id: last_snapshot.sortition_id.clone(),
+            parent_burn_header_hash: last_snapshot.burn_header_hash.clone(),
+            consensus_hash: ConsensusHash([((i + 1) as u8) | bit_pattern; 20]),
+            ops_hash: OpsHash([(i as u8) | bit_pattern; 32]),
+            total_burn: 0,
+            sortition: true,
+            sortition_hash: SortitionHash([(i as u8) | bit_pattern; 32]),
+            winning_block_txid: Txid([(i as u8) | bit_pattern; 32]),
+            winning_stacks_block_hash: BlockHeaderHash([(i as u8) | bit_pattern; 32]),
+            index_root: TrieHash([0u8; 32]),
+            num_sortitions: last_snapshot.num_sortitions + 1,
+            stacks_block_accepted: false,
+            stacks_block_height: 0,
+            arrival_index: 0,
+            canonical_stacks_tip_height: last_snapshot.canonical_stacks_tip_height + 10,
+            canonical_stacks_tip_hash: BlockHeaderHash([((i + 1) as u8) | bit_pattern; 32]),
+            canonical_stacks_tip_consensus_hash: ConsensusHash([((i + 1) as u8) | bit_pattern; 20]),
+            miner_pk_hash: None,
+        };
+        new_snapshots.push(snapshot.clone());
+        {
+            let mut tx = SortitionHandleTx::begin(sort_db, &last_snapshot.sortition_id).unwrap();
+            let _index_root = tx
+                .append_chain_tip_snapshot(
+                    &last_snapshot,
+                    &snapshot,
+                    &vec![],
+                    &vec![],
+                    None,
+                    None,
+                    None,
+                )
+                .unwrap();
+            tx.test_update_canonical_stacks_tip(
+                &snapshot.sortition_id,
+                &snapshot.canonical_stacks_tip_consensus_hash,
+                &snapshot.canonical_stacks_tip_hash,
+                snapshot.canonical_stacks_tip_height,
+            )
+            .unwrap();
+            tx.commit().unwrap();
+        }
+        last_snapshot = SortitionDB::get_block_snapshot(sort_db.conn(), &snapshot.sortition_id)
+            .unwrap()
+            .unwrap();
+    }
+    new_snapshots
+}
+
 /// Tests that getting the highest nakamoto tenure works in the presence of forks
 #[test]
 pub fn test_get_highest_nakamoto_tenure() {
@@ -1450,7 +1517,10 @@ pub fn test_get_highest_nakamoto_tenure() {
 
     // seed a single fork of tenures
     let last_snapshot = SortitionDB::get_canonical_burn_chain_tip(sort_db.conn()).unwrap();
-    let snapshots = make_fork_run(sort_db, &last_snapshot, 5, 0);
+
+    // mock block arrivals
+    let snapshots = make_fork_run_with_arrivals(sort_db, &last_snapshot, 5, 0);
+
     let mut last_header: Option<NakamotoBlockHeader> = None;
     let mut last_tenure_change: Option<TenureChangePayload> = None;
     let mut all_headers = vec![];
@@ -1458,7 +1528,7 @@ pub fn test_get_highest_nakamoto_tenure() {
     for (i, sn) in snapshots.iter().enumerate() {
         let block_header = NakamotoBlockHeader {
             version: 0,
-            chain_length: i as u64,
+            chain_length: sn.canonical_stacks_tip_height,
             burn_spent: i as u64,
             consensus_hash: sn.consensus_hash.clone(),
             parent_block_id: last_header
@@ -1475,10 +1545,10 @@ pub fn test_get_highest_nakamoto_tenure() {
             prev_tenure_consensus_hash: last_tenure_change
                 .as_ref()
                 .map(|tc| tc.tenure_consensus_hash.clone())
-                .unwrap_or(FIRST_BURNCHAIN_CONSENSUS_HASH.clone()),
+                .unwrap_or(last_snapshot.consensus_hash.clone()),
             burn_view_consensus_hash: sn.consensus_hash.clone(),
             previous_tenure_end: block_header.block_id(),
-            previous_tenure_blocks: 1,
+            previous_tenure_blocks: 10,
             cause: TenureChangeCause::BlockFound,
             pubkey_hash: Hash160([0x00; 20]),
             signature: ThresholdSignature::mock(),
@@ -1505,13 +1575,17 @@ pub fn test_get_highest_nakamoto_tenure() {
 
     // highest tenure should be the last one we inserted
     let tip = SortitionDB::get_canonical_burn_chain_tip(sort_db.conn()).unwrap();
+    let (stacks_ch, stacks_bhh, stacks_height) =
+        SortitionDB::get_canonical_stacks_chain_tip_hash_and_height(sort_db.conn()).unwrap();
     debug!("tip = {:?}", &tip);
-    let highest_tenure = NakamotoChainState::get_highest_nakamoto_tenure(
-        chainstate.db(),
-        &mut sort_db.index_handle(&tip.sortition_id),
-    )
-    .unwrap()
-    .unwrap();
+    debug!(
+        "stacks tip = {},{},{}",
+        &stacks_ch, &stacks_bhh, stacks_height
+    );
+    let highest_tenure =
+        NakamotoChainState::get_highest_nakamoto_tenure(chainstate.db(), sort_db.conn())
+            .unwrap()
+            .unwrap();
 
     let last_tenure_change = last_tenure_change.unwrap();
     let last_header = last_header.unwrap();
@@ -1532,7 +1606,7 @@ pub fn test_get_highest_nakamoto_tenure() {
     assert_eq!(highest_tenure.block_id, last_header.block_id());
     assert_eq!(highest_tenure.coinbase_height, 5);
     assert_eq!(highest_tenure.tenure_index, 5);
-    assert_eq!(highest_tenure.num_blocks_confirmed, 1);
+    assert_eq!(highest_tenure.num_blocks_confirmed, 10);
 
     // uh oh, a bitcoin fork!
     let last_snapshot = snapshots[2].clone();
@@ -1540,14 +1614,16 @@ pub fn test_get_highest_nakamoto_tenure() {
 
     let new_tip = SortitionDB::get_canonical_burn_chain_tip(sort_db.conn()).unwrap();
     debug!("tip = {:?}", &new_tip);
+    debug!(
+        "stacks tip = {},{},{}",
+        &stacks_ch, &stacks_bhh, stacks_height
+    );
 
     // new tip doesn't include the last two tenures
-    let highest_tenure = NakamotoChainState::get_highest_nakamoto_tenure(
-        chainstate.db(),
-        &mut sort_db.index_handle(&new_tip.sortition_id),
-    )
-    .unwrap()
-    .unwrap();
+    let highest_tenure =
+        NakamotoChainState::get_highest_nakamoto_tenure(chainstate.db(), sort_db.conn())
+            .unwrap()
+            .unwrap();
     let last_tenure_change = &all_tenure_changes[2];
     let last_header = &all_headers[2];
     assert_eq!(
@@ -1567,5 +1643,5 @@ pub fn test_get_highest_nakamoto_tenure() {
     assert_eq!(highest_tenure.block_id, last_header.block_id());
     assert_eq!(highest_tenure.coinbase_height, 3);
     assert_eq!(highest_tenure.tenure_index, 3);
-    assert_eq!(highest_tenure.num_blocks_confirmed, 1);
+    assert_eq!(highest_tenure.num_blocks_confirmed, 10);
 }

From 287c19b8398dcbd770638aaa58d7e5ddc1d2cfb5 Mon Sep 17 00:00:00 2001
From: Joey Yandle <xoloki@gmail.com>
Date: Fri, 1 Dec 2023 13:15:40 -0500
Subject: [PATCH 0153/1166] make set-aggregate-public-key private in the pox4
 contract

call set-aggregate-public-key during append_block

pass reward cycle and agg pubkey as symbolic expressions to private contract call

read aggregate public key from parent reward cycle then set it in the following

remove TODO comment referencing the issue being fixed

use from instead of as for explicit cast

fmt fixes
---
 stackslib/src/chainstate/nakamoto/mod.rs      | 83 ++++++++++++++++++-
 .../src/chainstate/stacks/boot/pox-4.clar     |  3 +-
 2 files changed, 81 insertions(+), 5 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index a7ca6e6a79..1560106a07 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -18,10 +18,11 @@ use std::collections::HashSet;
 use std::ops::DerefMut;
 
 use clarity::vm::ast::ASTRules;
-use clarity::vm::costs::ExecutionCost;
+use clarity::vm::costs::{ExecutionCost, LimitedCostTracker};
 use clarity::vm::database::BurnStateDB;
 use clarity::vm::events::StacksTransactionEvent;
 use clarity::vm::types::StacksAddressExtensions;
+use clarity::vm::{ClarityVersion, SymbolicExpression, Value};
 use lazy_static::{__Deref, lazy_static};
 use rusqlite::types::{FromSql, FromSqlError};
 use rusqlite::{params, Connection, OptionalExtension, ToSql, NO_PARAMS};
@@ -33,8 +34,8 @@ use stacks_common::consts::{
     FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH, MINER_REWARD_MATURITY,
 };
 use stacks_common::types::chainstate::{
-    BlockHeaderHash, BurnchainHeaderHash, ConsensusHash, StacksBlockId, StacksPrivateKey,
-    StacksPublicKey, TrieHash, VRFSeed,
+    BlockHeaderHash, BurnchainHeaderHash, ConsensusHash, StacksAddress, StacksBlockId,
+    StacksPrivateKey, StacksPublicKey, TrieHash, VRFSeed,
 };
 use stacks_common::types::{PrivateKey, StacksEpochId};
 use stacks_common::util::get_epoch_time_secs;
@@ -62,13 +63,16 @@ use crate::chainstate::burn::db::sortdb::SortitionDB;
 use crate::chainstate::burn::operations::{LeaderBlockCommitOp, LeaderKeyRegisterOp};
 use crate::chainstate::burn::BlockSnapshot;
 use crate::chainstate::coordinator::{BlockEventDispatcher, Error};
+use crate::chainstate::stacks::boot::POX_4_NAME;
 use crate::chainstate::stacks::db::{DBConfig as ChainstateConfig, StacksChainState};
 use crate::chainstate::stacks::{MINER_BLOCK_CONSENSUS_HASH, MINER_BLOCK_HEADER_HASH};
+use crate::clarity::vm::clarity::ClarityConnection;
 use crate::clarity_vm::clarity::{ClarityInstance, PreCommitClarityBlock};
 use crate::clarity_vm::database::SortitionDBRef;
 use crate::core::BOOT_BLOCK_HASH;
 use crate::monitoring;
 use crate::net::Error as net_error;
+use crate::util_lib::boot::boot_code_id;
 use crate::util_lib::db::{
     query_row, query_row_panic, query_rows, u64_to_sql, DBConn, Error as DBError, FromRow,
 };
@@ -2380,6 +2384,7 @@ impl NakamotoChainState {
 
         let ast_rules = ASTRules::PrecheckSize;
         let mainnet = chainstate_tx.get_config().mainnet;
+        let chain_id = chainstate_tx.get_config().chain_id;
         let next_block_height = block.header.chain_length;
 
         let (parent_ch, parent_block_hash) = if block.is_first_mined() {
@@ -2514,6 +2519,78 @@ impl NakamotoChainState {
             tenure_height,
         )?;
 
+        if !block.is_first_mined() {
+            let parent_reward_cycle = pox_constants
+                .block_height_to_reward_cycle(
+                    burn_dbconn.context.first_block_height,
+                    parent_chain_tip
+                        .burn_header_height
+                        .try_into()
+                        .expect("Burn block height exceeded u32"),
+                )
+                .unwrap();
+            let my_reward_cycle = pox_constants
+                .block_height_to_reward_cycle(
+                    burn_dbconn.context.first_block_height,
+                    burn_header_height,
+                )
+                .unwrap();
+            if parent_reward_cycle != my_reward_cycle {
+                // execute `set-aggregate-public-key` using `clarity-tx`
+                let aggregate_public_key = clarity_tx
+                    .connection()
+                    .with_readonly_clarity_env(
+                        false,
+                        chain_id,
+                        ClarityVersion::Clarity2,
+                        StacksAddress::burn_address(false).into(),
+                        None,
+                        LimitedCostTracker::Free,
+                        |vm_env| {
+                            vm_env.execute_contract_allow_private(
+                                &boot_code_id(POX_4_NAME, false),
+                                "get-aggregate-public-key",
+                                &vec![SymbolicExpression::atom_value(Value::UInt(u128::from(
+                                    parent_reward_cycle,
+                                )))],
+                                true,
+                            )
+                        },
+                    )
+                    .ok()
+                    .map(|agg_key_value| {
+                        Value::buff_from(agg_key_value.expect_buff(33))
+                            .expect("failed to reconstruct buffer")
+                    })
+                    .expect("get-aggregate-public-key returned None");
+
+                clarity_tx
+                    .connection()
+                    .with_readonly_clarity_env(
+                        false,
+                        chain_id,
+                        ClarityVersion::Clarity2,
+                        StacksAddress::burn_address(false).into(),
+                        None,
+                        LimitedCostTracker::Free,
+                        |vm_env| {
+                            vm_env.execute_contract_allow_private(
+                                &boot_code_id(POX_4_NAME, false),
+                                "set-aggregate-public-key",
+                                &vec![
+                                    SymbolicExpression::atom_value(Value::UInt(u128::from(
+                                        my_reward_cycle,
+                                    ))),
+                                    SymbolicExpression::atom_value(aggregate_public_key),
+                                ],
+                                false,
+                            )
+                        },
+                    )
+                    .ok();
+            }
+        }
+
         let starting_cost = clarity_tx.cost_so_far();
 
         debug!(
diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index 6766e4022e..ffb4bc7f0c 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -1330,9 +1330,8 @@
 )
 
 ;; Set the aggregate public key to the provided value
-;; TODO: https://github.com/stacks-network/stacks-core/issues/4101
 ;; *New in Stacks 3.0*
-(define-public (set-aggregate-public-key (reward-cycle uint) (aggregate-public-key (buff 33)))
+(define-private (set-aggregate-public-key (reward-cycle uint) (aggregate-public-key (buff 33)))
     (begin
         (ok (map-set aggregate-public-keys reward-cycle aggregate-public-key))
     )

From 5998f3b0884bd2fb9797499b059972535ae3a66b Mon Sep 17 00:00:00 2001
From: Joey Yandle <xoloki@gmail.com>
Date: Thu, 7 Dec 2023 04:50:30 -0500
Subject: [PATCH 0154/1166] replace manual set-aggregate-public-key test with
 one that checks to see if the key is set automatically for a new reward cycle

---
 testnet/stacks-node/src/mockamoto/tests.rs | 57 +---------------------
 1 file changed, 2 insertions(+), 55 deletions(-)

diff --git a/testnet/stacks-node/src/mockamoto/tests.rs b/testnet/stacks-node/src/mockamoto/tests.rs
index 915833ea20..f9376c9b71 100644
--- a/testnet/stacks-node/src/mockamoto/tests.rs
+++ b/testnet/stacks-node/src/mockamoto/tests.rs
@@ -129,7 +129,7 @@ fn observe_100_blocks() {
 }
 
 #[test]
-fn observe_set_aggregate_tx() {
+fn observe_set_aggregate_key() {
     let mut conf = Config::from_config_file(ConfigFile::mockamoto()).unwrap();
     conf.node.mockamoto_time_ms = 10;
 
@@ -211,27 +211,6 @@ fn observe_set_aggregate_tx() {
         })
         .expect("FATAL: failed to start mockamoto main thread");
 
-    // Create a "set-aggregate-public-key" tx to verify it sets correctly
-    let mut rng = OsRng::default();
-    let x = Scalar::random(&mut rng);
-    let random_key = Point::from(x);
-
-    let aggregate_public_key = Value::buff_from(random_key.compress().data.to_vec())
-        .expect("Failed to serialize aggregate public key");
-    let aggregate_tx = make_contract_call(
-        &submitter_sk,
-        0,
-        10,
-        &boot_code_addr(false),
-        POX_4_NAME,
-        "set-aggregate-public-key",
-        &[
-            Value::UInt(u128::from(reward_cycle + 1)),
-            aggregate_public_key,
-        ],
-    );
-    let aggregate_tx_hex = format!("0x{}", to_hex(&aggregate_tx));
-
     // complete within 5 seconds or abort (we are only observing one block)
     let completed = loop {
         if Instant::now().duration_since(start) > Duration::from_secs(5) {
@@ -246,21 +225,6 @@ fn observe_set_aggregate_tx() {
         let stacks_block_height = latest_block.get("block_height").unwrap().as_u64().unwrap();
         info!("Block height observed: {stacks_block_height}");
 
-        // Submit the aggregate tx for processing to update the aggregate public key
-        let tip = NakamotoChainState::get_canonical_block_header(chainstate.db(), &sortdb)
-            .unwrap()
-            .unwrap();
-        mempool
-            .submit_raw(
-                &mut chainstate,
-                &sortdb,
-                &tip.consensus_hash,
-                &tip.anchored_header.block_hash(),
-                aggregate_tx.clone(),
-                &ExecutionCost::max_value(),
-                &StacksEpochId::Epoch30,
-            )
-            .unwrap();
         break true;
     };
 
@@ -270,23 +234,6 @@ fn observe_set_aggregate_tx() {
         .join()
         .expect("Failed to join node thread to exit");
 
-    let aggregate_tx_included = test_observer::get_blocks()
-        .into_iter()
-        .find(|block_json| {
-            block_json["transactions"]
-                .as_array()
-                .unwrap()
-                .iter()
-                .find(|tx_json| tx_json["raw_tx"].as_str() == Some(&aggregate_tx_hex))
-                .is_some()
-        })
-        .is_some();
-
-    assert!(
-        aggregate_tx_included,
-        "Mockamoto node failed to include the aggregate tx"
-    );
-
     assert!(
         completed,
         "Mockamoto node failed to produce and announce its block before timeout"
@@ -294,5 +241,5 @@ fn observe_set_aggregate_tx() {
 
     // Did we set and retrieve the aggregate key correctly?
     assert_eq!(orig_aggregate_key.unwrap(), orig_key);
-    assert_eq!(new_aggregate_key.unwrap(), random_key);
+    assert_eq!(new_aggregate_key.unwrap(), orig_key);
 }

From 9865cb6845b768e4be9d2cb7ea1554598bb9353d Mon Sep 17 00:00:00 2001
From: Joey Yandle <xoloki@gmail.com>
Date: Mon, 11 Dec 2023 17:19:46 -0500
Subject: [PATCH 0155/1166] execute private contract call using
 as_transaction/with_abort_callback/execute_in_env context chain

---
 stackslib/src/chainstate/nakamoto/mod.rs   | 44 +++++++++++-----------
 testnet/stacks-node/src/mockamoto/tests.rs |  7 ++--
 2 files changed, 27 insertions(+), 24 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index 1560106a07..f6eaf1651b 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -66,7 +66,7 @@ use crate::chainstate::coordinator::{BlockEventDispatcher, Error};
 use crate::chainstate::stacks::boot::POX_4_NAME;
 use crate::chainstate::stacks::db::{DBConfig as ChainstateConfig, StacksChainState};
 use crate::chainstate::stacks::{MINER_BLOCK_CONSENSUS_HASH, MINER_BLOCK_HEADER_HASH};
-use crate::clarity::vm::clarity::ClarityConnection;
+use crate::clarity::vm::clarity::{ClarityConnection, TransactionConnection};
 use crate::clarity_vm::clarity::{ClarityInstance, PreCommitClarityBlock};
 use crate::clarity_vm::database::SortitionDBRef;
 use crate::core::BOOT_BLOCK_HASH;
@@ -2564,30 +2564,32 @@ impl NakamotoChainState {
                     })
                     .expect("get-aggregate-public-key returned None");
 
-                clarity_tx
-                    .connection()
-                    .with_readonly_clarity_env(
-                        false,
-                        chain_id,
-                        ClarityVersion::Clarity2,
-                        StacksAddress::burn_address(false).into(),
-                        None,
-                        LimitedCostTracker::Free,
+                clarity_tx.connection().as_transaction(|tx| {
+                    tx.with_abort_callback(
                         |vm_env| {
-                            vm_env.execute_contract_allow_private(
-                                &boot_code_id(POX_4_NAME, false),
-                                "set-aggregate-public-key",
-                                &vec![
-                                    SymbolicExpression::atom_value(Value::UInt(u128::from(
-                                        my_reward_cycle,
-                                    ))),
-                                    SymbolicExpression::atom_value(aggregate_public_key),
-                                ],
-                                false,
+                            vm_env.execute_in_env(
+                                StacksAddress::burn_address(false).into(),
+                                None,
+                                None,
+                                |vm_env| {
+                                    vm_env.execute_contract_allow_private(
+                                        &boot_code_id(POX_4_NAME, false),
+                                        "set-aggregate-public-key",
+                                        &vec![
+                                            SymbolicExpression::atom_value(Value::UInt(
+                                                u128::from(my_reward_cycle),
+                                            )),
+                                            SymbolicExpression::atom_value(aggregate_public_key),
+                                        ],
+                                        false,
+                                    )
+                                },
                             )
                         },
+                        |_, _| false,
                     )
-                    .ok();
+                    .expect("FATAL: `ust-liquid-supply` overflowed")
+                });
             }
         }
 
diff --git a/testnet/stacks-node/src/mockamoto/tests.rs b/testnet/stacks-node/src/mockamoto/tests.rs
index f9376c9b71..a1a1b3cdf8 100644
--- a/testnet/stacks-node/src/mockamoto/tests.rs
+++ b/testnet/stacks-node/src/mockamoto/tests.rs
@@ -213,7 +213,7 @@ fn observe_set_aggregate_key() {
 
     // complete within 5 seconds or abort (we are only observing one block)
     let completed = loop {
-        if Instant::now().duration_since(start) > Duration::from_secs(5) {
+        if Instant::now().duration_since(start) > Duration::from_secs(120) {
             break false;
         }
         let latest_block = test_observer::get_blocks().pop();
@@ -224,8 +224,9 @@ fn observe_set_aggregate_key() {
         };
         let stacks_block_height = latest_block.get("block_height").unwrap().as_u64().unwrap();
         info!("Block height observed: {stacks_block_height}");
-
-        break true;
+        if stacks_block_height >= 100 {
+            break true;
+        }
     };
 
     globals.signal_stop();

From ec56c3f57a78602728ac0ec4eabdfbf804a3bcbf Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Wed, 29 Nov 2023 14:13:05 -0500
Subject: [PATCH 0156/1166] feat: Create `pox_4.rs` from `pox_3.rs` and remove
 `#[allow(clippy::needless_return)]`

---
 pox-locking/src/lib.rs   |  11 ++
 pox-locking/src/pox_4.rs | 395 +++++++++++++++++++++++++++++++++++++++
 2 files changed, 406 insertions(+)
 create mode 100644 pox-locking/src/pox_4.rs

diff --git a/pox-locking/src/lib.rs b/pox-locking/src/lib.rs
index b195f4cc9b..05303a4d9b 100644
--- a/pox-locking/src/lib.rs
+++ b/pox-locking/src/lib.rs
@@ -38,6 +38,7 @@ mod events;
 mod pox_1;
 mod pox_2;
 mod pox_3;
+mod pox_4;
 
 #[derive(Debug)]
 pub enum LockingError {
@@ -52,6 +53,7 @@ pub enum LockingError {
 pub const POX_1_NAME: &str = "pox";
 pub const POX_2_NAME: &str = "pox-2";
 pub const POX_3_NAME: &str = "pox-3";
+pub const POX_4_NAME: &str = "pox-4";
 
 /// Handle special cases of contract-calls -- namely, those into PoX that should lock up STX
 pub fn handle_contract_call_special_cases(
@@ -113,6 +115,15 @@ pub fn handle_contract_call_special_cases(
             args,
             result,
         );
+    } else if *contract_id == boot_code_id(POX_4_NAME, global_context.mainnet) {
+        return pox_4::handle_contract_call(
+            global_context,
+            sender,
+            contract_id,
+            function_name,
+            args,
+            result,
+        );
     }
 
     Ok(())
diff --git a/pox-locking/src/pox_4.rs b/pox-locking/src/pox_4.rs
new file mode 100644
index 0000000000..82bf38cdb1
--- /dev/null
+++ b/pox-locking/src/pox_4.rs
@@ -0,0 +1,395 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020-2023 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+use clarity::boot_util::boot_code_id;
+use clarity::vm::contexts::GlobalContext;
+use clarity::vm::costs::cost_functions::ClarityCostFunction;
+use clarity::vm::costs::runtime_cost;
+use clarity::vm::database::{ClarityDatabase, STXBalance};
+use clarity::vm::errors::{Error as ClarityError, RuntimeErrorType};
+use clarity::vm::events::{STXEventType, STXLockEventData, StacksTransactionEvent};
+use clarity::vm::types::{PrincipalData, QualifiedContractIdentifier};
+use clarity::vm::{Environment, Value};
+use slog::{slog_debug, slog_error};
+use stacks_common::{debug, error};
+
+use crate::events::synthesize_pox_2_or_3_event_info;
+// Note: PoX-4 uses the same contract-call result parsing routines as PoX-2
+use crate::pox_2::{parse_pox_extend_result, parse_pox_increase, parse_pox_stacking_result};
+use crate::{LockingError, POX_4_NAME};
+
+/////////////////////// PoX-4 /////////////////////////////////
+
+/// Lock up STX for PoX for a time.  Does NOT touch the account nonce.
+pub fn pox_lock_v4(
+    db: &mut ClarityDatabase,
+    principal: &PrincipalData,
+    lock_amount: u128,
+    unlock_burn_height: u64,
+) -> Result<(), LockingError> {
+    assert!(unlock_burn_height > 0);
+    assert!(lock_amount > 0);
+
+    let mut snapshot = db.get_stx_balance_snapshot(principal);
+
+    if snapshot.has_locked_tokens() {
+        return Err(LockingError::PoxAlreadyLocked);
+    }
+    if !snapshot.can_transfer(lock_amount) {
+        return Err(LockingError::PoxInsufficientBalance);
+    }
+    snapshot.lock_tokens_v4(lock_amount, unlock_burn_height);
+
+    debug!(
+        "PoX v4 lock applied";
+        "pox_locked_ustx" => snapshot.balance().amount_locked(),
+        "available_ustx" => snapshot.balance().amount_unlocked(),
+        "unlock_burn_height" => unlock_burn_height,
+        "account" => %principal,
+    );
+
+    snapshot.save();
+    Ok(())
+}
+
+/// Extend a STX lock up for PoX for a time.  Does NOT touch the account nonce.
+/// Returns Ok(lock_amount) when successful
+///
+/// # Errors
+/// - Returns Error::PoxExtendNotLocked if this function was called on an account
+///     which isn't locked. This *should* have been checked by the PoX v4 contract,
+///     so this should surface in a panic.
+pub fn pox_lock_extend_v4(
+    db: &mut ClarityDatabase,
+    principal: &PrincipalData,
+    unlock_burn_height: u64,
+) -> Result<u128, LockingError> {
+    assert!(unlock_burn_height > 0);
+
+    let mut snapshot = db.get_stx_balance_snapshot(principal);
+
+    if !snapshot.has_locked_tokens() {
+        return Err(LockingError::PoxExtendNotLocked);
+    }
+
+    snapshot.extend_lock_v4(unlock_burn_height);
+
+    let amount_locked = snapshot.balance().amount_locked();
+
+    debug!(
+        "PoX v4 lock applied";
+        "pox_locked_ustx" => amount_locked,
+        "available_ustx" => snapshot.balance().amount_unlocked(),
+        "unlock_burn_height" => unlock_burn_height,
+        "account" => %principal,
+    );
+
+    snapshot.save();
+    Ok(amount_locked)
+}
+
+/// Increase a STX lock up for PoX-4.  Does NOT touch the account nonce.
+/// Returns Ok( account snapshot ) when successful
+///
+/// # Errors
+/// - Returns Error::PoxExtendNotLocked if this function was called on an account
+///     which isn't locked. This *should* have been checked by the PoX v4 contract,
+///     so this should surface in a panic.
+pub fn pox_lock_increase_v4(
+    db: &mut ClarityDatabase,
+    principal: &PrincipalData,
+    new_total_locked: u128,
+) -> Result<STXBalance, LockingError> {
+    assert!(new_total_locked > 0);
+
+    let mut snapshot = db.get_stx_balance_snapshot(principal);
+
+    if !snapshot.has_locked_tokens() {
+        return Err(LockingError::PoxExtendNotLocked);
+    }
+
+    let bal = snapshot.canonical_balance_repr();
+    let total_amount = bal
+        .amount_unlocked()
+        .checked_add(bal.amount_locked())
+        .expect("STX balance overflowed u128");
+    if total_amount < new_total_locked {
+        return Err(LockingError::PoxInsufficientBalance);
+    }
+
+    if bal.amount_locked() > new_total_locked {
+        return Err(LockingError::PoxInvalidIncrease);
+    }
+
+    snapshot.increase_lock_v4(new_total_locked);
+
+    let out_balance = snapshot.canonical_balance_repr();
+
+    debug!(
+        "PoX v4 lock increased";
+        "pox_locked_ustx" => out_balance.amount_locked(),
+        "available_ustx" => out_balance.amount_unlocked(),
+        "unlock_burn_height" => out_balance.unlock_height(),
+        "account" => %principal,
+    );
+
+    snapshot.save();
+    Ok(out_balance)
+}
+
+/////////////// PoX-4 //////////////////////////////////////////
+
+/// Handle responses from stack-stx and delegate-stack-stx in pox-4 -- functions that *lock up* STX
+fn handle_stack_lockup_pox_v4(
+    global_context: &mut GlobalContext,
+    function_name: &str,
+    value: &Value,
+) -> Result<Option<StacksTransactionEvent>, ClarityError> {
+    debug!(
+        "Handle special-case contract-call to {:?} {function_name} (which returned {value:?})",
+        boot_code_id(POX_4_NAME, global_context.mainnet)
+    );
+    // applying a pox lock at this point is equivalent to evaluating a transfer
+    runtime_cost(
+        ClarityCostFunction::StxTransfer,
+        &mut global_context.cost_track,
+        1,
+    )?;
+
+    let (stacker, locked_amount, unlock_height) = match parse_pox_stacking_result(value) {
+        Ok(x) => x,
+        Err(_) => {
+            // nothing to do -- the function failed
+            return Ok(None);
+        }
+    };
+
+    match pox_lock_v4(
+        &mut global_context.database,
+        &stacker,
+        locked_amount,
+        unlock_height,
+    ) {
+        Ok(_) => {
+            let event =
+                StacksTransactionEvent::STXEvent(STXEventType::STXLockEvent(STXLockEventData {
+                    locked_amount,
+                    unlock_height,
+                    locked_address: stacker,
+                    contract_identifier: boot_code_id(POX_4_NAME, global_context.mainnet),
+                }));
+            Ok(Some(event))
+        }
+        Err(LockingError::DefunctPoxContract) => Err(ClarityError::Runtime(
+            RuntimeErrorType::DefunctPoxContract,
+            None,
+        )),
+        Err(LockingError::PoxAlreadyLocked) => {
+            // the caller tried to lock tokens into multiple pox contracts
+            Err(ClarityError::Runtime(
+                RuntimeErrorType::PoxAlreadyLocked,
+                None,
+            ))
+        }
+        Err(e) => {
+            panic!(
+                "FATAL: failed to lock {locked_amount} from {stacker} until {unlock_height}: '{e:?}'"
+            );
+        }
+    }
+}
+
+/// Handle responses from stack-extend and delegate-stack-extend in pox-4 -- functions that *extend
+/// already-locked* STX.
+fn handle_stack_lockup_extension_pox_v4(
+    global_context: &mut GlobalContext,
+    function_name: &str,
+    value: &Value,
+) -> Result<Option<StacksTransactionEvent>, ClarityError> {
+    // in this branch case, the PoX-4 contract has stored the extension information
+    //  and performed the extension checks. Now, the VM needs to update the account locks
+    //  (because the locks cannot be applied directly from the Clarity code itself)
+    // applying a pox lock at this point is equivalent to evaluating a transfer
+    debug!(
+        "Handle special-case contract-call to {:?} {function_name} (which returned {value:?})",
+        boot_code_id("pox-4", global_context.mainnet),
+    );
+
+    runtime_cost(
+        ClarityCostFunction::StxTransfer,
+        &mut global_context.cost_track,
+        1,
+    )?;
+
+    let (stacker, unlock_height) = match parse_pox_extend_result(value) {
+        Ok(x) => x,
+        Err(_) => {
+            // The stack-extend function returned an error: we do not need to apply a lock
+            //  in this case, and can just return and let the normal VM codepath surface the
+            //  error response type.
+            return Ok(None);
+        }
+    };
+
+    match pox_lock_extend_v4(&mut global_context.database, &stacker, unlock_height) {
+        Ok(locked_amount) => {
+            let event =
+                StacksTransactionEvent::STXEvent(STXEventType::STXLockEvent(STXLockEventData {
+                    locked_amount,
+                    unlock_height,
+                    locked_address: stacker,
+                    contract_identifier: boot_code_id(POX_4_NAME, global_context.mainnet),
+                }));
+            Ok(Some(event))
+        }
+        Err(LockingError::DefunctPoxContract) => Err(ClarityError::Runtime(
+            RuntimeErrorType::DefunctPoxContract,
+            None,
+        )),
+        Err(e) => {
+            // Error results *other* than a DefunctPoxContract panic, because
+            //  those errors should have been caught by the PoX contract before
+            //  getting to this code path.
+            panic!("FATAL: failed to extend lock from {stacker} until {unlock_height}: '{e:?}'");
+        }
+    }
+}
+
+/// Handle responses from stack-increase and delegate-stack-increase in PoX-4 -- functions
+/// that *increase already-locked* STX amounts.
+fn handle_stack_lockup_increase_pox_v4(
+    global_context: &mut GlobalContext,
+    function_name: &str,
+    value: &Value,
+) -> Result<Option<StacksTransactionEvent>, ClarityError> {
+    // in this branch case, the PoX-4 contract has stored the increase information
+    //  and performed the increase checks. Now, the VM needs to update the account locks
+    //  (because the locks cannot be applied directly from the Clarity code itself)
+    // applying a pox lock at this point is equivalent to evaluating a transfer
+    debug!(
+        "Handle special-case contract-call";
+        "contract" => ?boot_code_id("pox-4", global_context.mainnet),
+        "function" => function_name,
+        "return-value" => %value,
+    );
+
+    runtime_cost(
+        ClarityCostFunction::StxTransfer,
+        &mut global_context.cost_track,
+        1,
+    )?;
+
+    let (stacker, total_locked) = match parse_pox_increase(value) {
+        Ok(x) => x,
+        Err(_) => {
+            // nothing to do -- function failed
+            return Ok(None);
+        }
+    };
+    match pox_lock_increase_v4(&mut global_context.database, &stacker, total_locked) {
+        Ok(new_balance) => {
+            let event =
+                StacksTransactionEvent::STXEvent(STXEventType::STXLockEvent(STXLockEventData {
+                    locked_amount: new_balance.amount_locked(),
+                    unlock_height: new_balance.unlock_height(),
+                    locked_address: stacker,
+                    contract_identifier: boot_code_id(POX_4_NAME, global_context.mainnet),
+                }));
+
+            Ok(Some(event))
+        }
+        Err(LockingError::DefunctPoxContract) => Err(ClarityError::Runtime(
+            RuntimeErrorType::DefunctPoxContract,
+            None,
+        )),
+        Err(e) => {
+            // Error results *other* than a DefunctPoxContract panic, because
+            //  those errors should have been caught by the PoX contract before
+            //  getting to this code path.
+            panic!("FATAL: failed to increase lock from {stacker}: '{e:?}'");
+        }
+    }
+}
+
+/// Handle special cases when calling into the PoX-4 API contract
+pub fn handle_contract_call(
+    global_context: &mut GlobalContext,
+    sender_opt: Option<&PrincipalData>,
+    contract_id: &QualifiedContractIdentifier,
+    function_name: &str,
+    args: &[Value],
+    value: &Value,
+) -> Result<(), ClarityError> {
+    // Generate a synthetic print event for all functions that alter stacking state
+    let print_event_opt = if let Value::Response(response) = value {
+        if response.committed {
+            // method succeeded.  Synthesize event info, but default to no event report if we fail
+            // for some reason.
+            // Failure to synthesize an event due to a bug is *NOT* an excuse to crash the whole
+            // network!  Event capture is not consensus-critical.
+            let event_info_opt = match synthesize_pox_2_or_3_event_info(
+                global_context,
+                contract_id,
+                sender_opt,
+                function_name,
+                args,
+            ) {
+                Ok(Some(event_info)) => Some(event_info),
+                Ok(None) => None,
+                Err(e) => {
+                    error!("Failed to synthesize PoX-4 event info: {e:?}");
+                    None
+                }
+            };
+            if let Some(event_info) = event_info_opt {
+                let event_response =
+                    Value::okay(event_info).expect("FATAL: failed to construct (ok event-info)");
+                let tx_event =
+                    Environment::construct_print_transaction_event(contract_id, &event_response);
+                Some(tx_event)
+            } else {
+                None
+            }
+        } else {
+            None
+        }
+    } else {
+        None
+    };
+
+    // Execute function specific logic to complete the lock-up
+    let lock_event_opt = if function_name == "stack-stx" || function_name == "delegate-stack-stx" {
+        handle_stack_lockup_pox_v4(global_context, function_name, value)?
+    } else if function_name == "stack-extend" || function_name == "delegate-stack-extend" {
+        handle_stack_lockup_extension_pox_v4(global_context, function_name, value)?
+    } else if function_name == "stack-increase" || function_name == "delegate-stack-increase" {
+        handle_stack_lockup_increase_pox_v4(global_context, function_name, value)?
+    } else {
+        None
+    };
+
+    // append the lockup event, so it looks as if the print event happened before the lock-up
+    if let Some(batch) = global_context.event_batches.last_mut() {
+        if let Some(print_event) = print_event_opt {
+            batch.events.push(print_event);
+        }
+        if let Some(lock_event) = lock_event_opt {
+            batch.events.push(lock_event);
+        }
+    }
+
+    Ok(())
+}

From 075a06adaff9095b92ce6f563098073cadf6b988 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Wed, 29 Nov 2023 16:46:26 -0500
Subject: [PATCH 0157/1166] Fix broken tests and clean up some logic in
 `pox_3_tests.rs`

---
 clarity/src/vm/database/structures.rs         | 13 ++++++----
 .../chainstate/nakamoto/coordinator/tests.rs  | 22 ++++++++++++-----
 stackslib/src/chainstate/stacks/boot/mod.rs   |  2 +-
 .../src/chainstate/stacks/boot/pox_3_tests.rs | 24 +++++++++----------
 4 files changed, 38 insertions(+), 23 deletions(-)

diff --git a/clarity/src/vm/database/structures.rs b/clarity/src/vm/database/structures.rs
index e1454d8a1e..97feec42cb 100644
--- a/clarity/src/vm/database/structures.rs
+++ b/clarity/src/vm/database/structures.rs
@@ -284,9 +284,12 @@ impl ClarityDeserializable<STXBalance> for STXBalance {
                     unlock_height,
                 }
             }
-        } else if bytes.len() == STXBalance::v2_and_v3_size {
+        } else if bytes.len() == STXBalance::v2_to_v4_size {
             let version = &bytes[0];
-            if version != &STXBalance::pox_2_version && version != &STXBalance::pox_3_version {
+            if version != &STXBalance::pox_2_version
+                && version != &STXBalance::pox_3_version
+                && version != &STXBalance::pox_4_version
+            {
                 panic!(
                     "Bad version byte in STX Balance serialization = {}",
                     version
@@ -331,7 +334,9 @@ impl ClarityDeserializable<STXBalance> for STXBalance {
                     unlock_height,
                 }
             } else {
-                unreachable!("Version is checked for pox_3 or pox_2 version compliance above");
+                unreachable!(
+                    "Version is checked for pox_4, pox_3 or pox_2 version compliance above"
+                );
             }
         } else {
             panic!("Bad STX Balance serialization size = {}", bytes.len());
@@ -902,7 +907,7 @@ impl<'db, 'conn> STXBalanceSnapshot<'db, 'conn> {
 // NOTE: do _not_ add mutation methods to this struct. Put them in STXBalanceSnapshot!
 impl STXBalance {
     pub const unlocked_and_v1_size: usize = 40;
-    pub const v2_and_v3_size: usize = 41;
+    pub const v2_to_v4_size: usize = 41;
     pub const pox_2_version: u8 = 0;
     pub const pox_3_version: u8 = 1;
     pub const pox_4_version: u8 = 2;
diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index 312aa86c24..f421cf4ec6 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -282,9 +282,7 @@ fn test_simple_nakamoto_coordinator_bootup() {
 /// Mine a single Nakamoto tenure with 10 Nakamoto blocks
 #[test]
 fn test_simple_nakamoto_coordinator_1_tenure_10_blocks() {
-    let mut test_signers = TestSigners::default();
-    let mut peer = boot_nakamoto(function_name!(), vec![], test_signers.aggregate_public_key);
-    let private_key = peer.config.private_key.clone();
+    let private_key = StacksPrivateKey::new();
     let addr = StacksAddress::from_public_keys(
         C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
         &AddressHashMode::SerializeP2PKH,
@@ -293,6 +291,13 @@ fn test_simple_nakamoto_coordinator_1_tenure_10_blocks() {
     )
     .unwrap();
 
+    let mut test_signers = TestSigners::default();
+    let mut peer = boot_nakamoto(
+        function_name!(),
+        vec![(addr.into(), 10_000)],
+        test_signers.aggregate_public_key,
+    );
+
     let (burn_ops, tenure_change, miner_key) =
         peer.begin_nakamoto_tenure(TenureChangeCause::BlockFound);
     let (_, _, consensus_hash) = peer.next_burnchain_block(burn_ops.clone());
@@ -383,9 +388,7 @@ fn test_simple_nakamoto_coordinator_1_tenure_10_blocks() {
 /// Mine a 10 Nakamoto tenures with 10 Nakamoto blocks
 #[test]
 fn test_simple_nakamoto_coordinator_10_tenures_10_blocks() {
-    let mut test_signers = TestSigners::default();
-    let mut peer = boot_nakamoto(function_name!(), vec![], test_signers.aggregate_public_key);
-    let private_key = peer.config.private_key.clone();
+    let private_key = StacksPrivateKey::new();
     let addr = StacksAddress::from_public_keys(
         C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
         &AddressHashMode::SerializeP2PKH,
@@ -394,6 +397,13 @@ fn test_simple_nakamoto_coordinator_10_tenures_10_blocks() {
     )
     .unwrap();
 
+    let mut test_signers = TestSigners::default();
+    let mut peer = boot_nakamoto(
+        function_name!(),
+        vec![(addr.into(), 11_000)],
+        test_signers.aggregate_public_key,
+    );
+
     let mut all_blocks = vec![];
     let mut all_burn_ops = vec![];
     let mut rc_blocks = vec![];
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 2f2cc637c7..dbff3818ac 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -1441,7 +1441,7 @@ pub mod test {
             .unwrap(),
         ];
 
-        let addrs: Vec<StacksAddress> = keys.iter().map(|ref pk| key_to_stacks_addr(pk)).collect();
+        let addrs: Vec<StacksAddress> = keys.iter().map(|pk| key_to_stacks_addr(pk)).collect();
 
         let balances: Vec<(PrincipalData, u64)> = addrs
             .clone()
diff --git a/stackslib/src/chainstate/stacks/boot/pox_3_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_3_tests.rs
index d0cbadbe4b..b358f4310b 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_3_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_3_tests.rs
@@ -68,7 +68,7 @@ fn get_tip(sortdb: Option<&SortitionDB>) -> BlockSnapshot {
 
 fn make_test_epochs_pox() -> (Vec<StacksEpoch>, PoxConstants) {
     let EMPTY_SORTITIONS = 25;
-    let EPOCH_2_1_HEIGHT = 11; // 36
+    let EPOCH_2_1_HEIGHT = EMPTY_SORTITIONS + 11; // 36
     let EPOCH_2_2_HEIGHT = EPOCH_2_1_HEIGHT + 14; // 50
     let EPOCH_2_3_HEIGHT = EPOCH_2_2_HEIGHT + 2; // 52
                                                  // epoch-2.4 will start at the first block of cycle 11!
@@ -95,34 +95,34 @@ fn make_test_epochs_pox() -> (Vec<StacksEpoch>, PoxConstants) {
         StacksEpoch {
             epoch_id: StacksEpochId::Epoch2_05,
             start_height: 0,
-            end_height: EMPTY_SORTITIONS + EPOCH_2_1_HEIGHT,
+            end_height: EPOCH_2_1_HEIGHT,
             block_limit: ExecutionCost::max_value(),
             network_epoch: PEER_VERSION_EPOCH_2_05,
         },
         StacksEpoch {
             epoch_id: StacksEpochId::Epoch21,
-            start_height: EMPTY_SORTITIONS + EPOCH_2_1_HEIGHT,
-            end_height: EMPTY_SORTITIONS + EPOCH_2_2_HEIGHT,
+            start_height: EPOCH_2_1_HEIGHT,
+            end_height: EPOCH_2_2_HEIGHT,
             block_limit: ExecutionCost::max_value(),
             network_epoch: PEER_VERSION_EPOCH_2_1,
         },
         StacksEpoch {
             epoch_id: StacksEpochId::Epoch22,
-            start_height: EMPTY_SORTITIONS + EPOCH_2_2_HEIGHT,
-            end_height: EMPTY_SORTITIONS + EPOCH_2_3_HEIGHT,
+            start_height: EPOCH_2_2_HEIGHT,
+            end_height: EPOCH_2_3_HEIGHT,
             block_limit: ExecutionCost::max_value(),
             network_epoch: PEER_VERSION_EPOCH_2_2,
         },
         StacksEpoch {
             epoch_id: StacksEpochId::Epoch23,
-            start_height: EMPTY_SORTITIONS + EPOCH_2_3_HEIGHT,
-            end_height: EMPTY_SORTITIONS + EPOCH_2_4_HEIGHT,
+            start_height: EPOCH_2_3_HEIGHT,
+            end_height: EPOCH_2_4_HEIGHT,
             block_limit: ExecutionCost::max_value(),
             network_epoch: PEER_VERSION_EPOCH_2_3,
         },
         StacksEpoch {
             epoch_id: StacksEpochId::Epoch24,
-            start_height: EMPTY_SORTITIONS + EPOCH_2_4_HEIGHT,
+            start_height: EPOCH_2_4_HEIGHT,
             end_height: STACKS_EPOCH_MAX,
             block_limit: ExecutionCost::max_value(),
             network_epoch: PEER_VERSION_EPOCH_2_4,
@@ -133,10 +133,10 @@ fn make_test_epochs_pox() -> (Vec<StacksEpoch>, PoxConstants) {
     pox_constants.reward_cycle_length = 5;
     pox_constants.prepare_length = 2;
     pox_constants.anchor_threshold = 1;
-    pox_constants.v1_unlock_height = (EMPTY_SORTITIONS + EPOCH_2_1_HEIGHT + 1) as u32;
-    pox_constants.v2_unlock_height = (EMPTY_SORTITIONS + EPOCH_2_2_HEIGHT + 1) as u32;
+    pox_constants.v1_unlock_height = (EPOCH_2_1_HEIGHT + 1) as u32;
+    pox_constants.v2_unlock_height = (EPOCH_2_2_HEIGHT + 1) as u32;
     pox_constants.v3_unlock_height = u32::MAX;
-    pox_constants.pox_3_activation_height = (EMPTY_SORTITIONS + EPOCH_2_4_HEIGHT + 1) as u32;
+    pox_constants.pox_3_activation_height = (EPOCH_2_4_HEIGHT + 1) as u32;
     pox_constants.pox_4_activation_height = u32::MAX;
 
     (epochs, pox_constants)

From b16a5a1cc6815e426951d105881edd2167a09c36 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Mon, 4 Dec 2023 13:14:05 -0500
Subject: [PATCH 0158/1166] Add `pox_4_tests.rs`

---
 stackslib/src/chainstate/stacks/boot/mod.rs   |    2 +
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 4423 +++++++++++++++++
 2 files changed, 4425 insertions(+)
 create mode 100644 stackslib/src/chainstate/stacks/boot/pox_4_tests.rs

diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index dbff3818ac..52eef5813c 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -1168,6 +1168,8 @@ pub mod contract_tests;
 pub mod pox_2_tests;
 #[cfg(test)]
 pub mod pox_3_tests;
+#[cfg(test)]
+pub mod pox_4_tests;
 
 #[cfg(test)]
 pub mod test {
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
new file mode 100644
index 0000000000..02fa4758c2
--- /dev/null
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -0,0 +1,4423 @@
+use std::collections::{HashMap, HashSet, VecDeque};
+use std::convert::{TryFrom, TryInto};
+
+use clarity::vm::clarity::ClarityConnection;
+use clarity::vm::contexts::OwnedEnvironment;
+use clarity::vm::contracts::Contract;
+use clarity::vm::costs::{CostOverflowingMath, LimitedCostTracker};
+use clarity::vm::database::*;
+use clarity::vm::errors::{
+    CheckErrors, Error, IncomparableError, InterpreterError, InterpreterResult, RuntimeErrorType,
+};
+use clarity::vm::eval;
+use clarity::vm::events::StacksTransactionEvent;
+use clarity::vm::representations::SymbolicExpression;
+use clarity::vm::tests::{execute, is_committed, is_err_code, symbols_from_values};
+use clarity::vm::types::Value::Response;
+use clarity::vm::types::{
+    BuffData, OptionalData, PrincipalData, QualifiedContractIdentifier, ResponseData, SequenceData,
+    StacksAddressExtensions, StandardPrincipalData, TupleData, TupleTypeSignature, TypeSignature,
+    Value, NONE,
+};
+use stacks_common::address::AddressHashMode;
+use stacks_common::types::chainstate::{
+    BlockHeaderHash, BurnchainHeaderHash, StacksAddress, StacksBlockId, VRFSeed,
+};
+use stacks_common::types::Address;
+use stacks_common::util::hash::{hex_bytes, to_hex, Sha256Sum, Sha512Trunc256Sum};
+
+use super::test::*;
+use super::RawRewardSetEntry;
+use crate::burnchains::{Burnchain, PoxConstants};
+use crate::chainstate::burn::db::sortdb::SortitionDB;
+use crate::chainstate::burn::operations::*;
+use crate::chainstate::burn::{BlockSnapshot, ConsensusHash};
+use crate::chainstate::stacks::address::{PoxAddress, PoxAddressType20, PoxAddressType32};
+use crate::chainstate::stacks::boot::pox_2_tests::{
+    check_pox_print_event, check_stacking_state_invariants, generate_pox_clarity_value,
+    get_partial_stacked, get_reward_cycle_total, get_reward_set_entries_at, get_stacking_state_pox,
+    get_stacking_state_pox_2, get_stx_account_at, PoxPrintFields, StackingStateCheckData,
+};
+use crate::chainstate::stacks::boot::{
+    BOOT_CODE_COST_VOTING_TESTNET as BOOT_CODE_COST_VOTING, BOOT_CODE_POX_TESTNET, POX_2_NAME,
+    POX_3_NAME,
+};
+use crate::chainstate::stacks::db::{
+    MinerPaymentSchedule, StacksChainState, StacksHeaderInfo, MINER_REWARD_MATURITY,
+};
+use crate::chainstate::stacks::events::TransactionOrigin;
+use crate::chainstate::stacks::index::marf::MarfConnection;
+use crate::chainstate::stacks::index::MarfTrieId;
+use crate::chainstate::stacks::tests::make_coinbase;
+use crate::chainstate::stacks::*;
+use crate::clarity_vm::clarity::{ClarityBlockConnection, Error as ClarityError};
+use crate::clarity_vm::database::marf::{MarfedKV, WritableMarfStore};
+use crate::clarity_vm::database::HeadersDBConn;
+use crate::core::*;
+use crate::net::test::{TestEventObserver, TestPeer};
+use crate::util_lib::boot::boot_code_id;
+use crate::util_lib::db::{DBConn, FromRow};
+
+const USTX_PER_HOLDER: u128 = 1_000_000;
+
+/// Return the BlockSnapshot for the latest sortition in the provided
+///  SortitionDB option-reference. Panics on any errors.
+fn get_tip(sortdb: Option<&SortitionDB>) -> BlockSnapshot {
+    SortitionDB::get_canonical_burn_chain_tip(&sortdb.unwrap().conn()).unwrap()
+}
+
+fn make_test_epochs_pox() -> (Vec<StacksEpoch>, PoxConstants) {
+    let EMPTY_SORTITIONS = 25;
+    let EPOCH_2_1_HEIGHT = EMPTY_SORTITIONS + 11; // 36
+    let EPOCH_2_2_HEIGHT = EPOCH_2_1_HEIGHT + 14; // 50
+    let EPOCH_2_3_HEIGHT = EPOCH_2_2_HEIGHT + 2; // 52
+                                                 // epoch-2.4 will start at the first block of cycle 11!
+                                                 //  this means that cycle 11 should also be treated like a "burn"
+    let EPOCH_2_4_HEIGHT = EPOCH_2_2_HEIGHT + 6; // 56
+    let EPOCH_2_5_HEIGHT = EPOCH_2_4_HEIGHT + 13; // 69
+    let EPOCH_3_0_HEIGHT = EPOCH_2_5_HEIGHT + 7; // 76
+
+    let epochs = vec![
+        StacksEpoch {
+            epoch_id: StacksEpochId::Epoch10,
+            start_height: 0,
+            end_height: 0,
+            block_limit: ExecutionCost::max_value(),
+            network_epoch: PEER_VERSION_EPOCH_1_0,
+        },
+        StacksEpoch {
+            epoch_id: StacksEpochId::Epoch20,
+            start_height: 0,
+            end_height: 0,
+            block_limit: ExecutionCost::max_value(),
+            network_epoch: PEER_VERSION_EPOCH_2_0,
+        },
+        StacksEpoch {
+            epoch_id: StacksEpochId::Epoch2_05,
+            start_height: 0,
+            end_height: EPOCH_2_1_HEIGHT,
+            block_limit: ExecutionCost::max_value(),
+            network_epoch: PEER_VERSION_EPOCH_2_05,
+        },
+        StacksEpoch {
+            epoch_id: StacksEpochId::Epoch21,
+            start_height: EPOCH_2_1_HEIGHT,
+            end_height: EPOCH_2_2_HEIGHT,
+            block_limit: ExecutionCost::max_value(),
+            network_epoch: PEER_VERSION_EPOCH_2_1,
+        },
+        StacksEpoch {
+            epoch_id: StacksEpochId::Epoch22,
+            start_height: EPOCH_2_2_HEIGHT,
+            end_height: EPOCH_2_3_HEIGHT,
+            block_limit: ExecutionCost::max_value(),
+            network_epoch: PEER_VERSION_EPOCH_2_2,
+        },
+        StacksEpoch {
+            epoch_id: StacksEpochId::Epoch23,
+            start_height: EPOCH_2_3_HEIGHT,
+            end_height: EPOCH_2_4_HEIGHT,
+            block_limit: ExecutionCost::max_value(),
+            network_epoch: PEER_VERSION_EPOCH_2_3,
+        },
+        StacksEpoch {
+            epoch_id: StacksEpochId::Epoch24,
+            start_height: EPOCH_2_4_HEIGHT,
+            end_height: EPOCH_2_5_HEIGHT,
+            block_limit: ExecutionCost::max_value(),
+            network_epoch: PEER_VERSION_EPOCH_2_4,
+        },
+        StacksEpoch {
+            epoch_id: StacksEpochId::Epoch25,
+            start_height: EPOCH_2_5_HEIGHT,
+            end_height: EPOCH_3_0_HEIGHT,
+            block_limit: ExecutionCost::max_value(),
+            network_epoch: PEER_VERSION_EPOCH_2_5,
+        },
+        StacksEpoch {
+            epoch_id: StacksEpochId::Epoch30,
+            start_height: EPOCH_3_0_HEIGHT,
+            end_height: STACKS_EPOCH_MAX,
+            block_limit: ExecutionCost::max_value(),
+            network_epoch: PEER_VERSION_EPOCH_3_0,
+        },
+    ];
+
+    let mut pox_constants = PoxConstants::mainnet_default();
+    pox_constants.reward_cycle_length = 5;
+    pox_constants.prepare_length = 2;
+    pox_constants.anchor_threshold = 1;
+    pox_constants.v1_unlock_height = (EPOCH_2_1_HEIGHT + 1) as u32;
+    pox_constants.v2_unlock_height = (EPOCH_2_2_HEIGHT + 1) as u32;
+    pox_constants.v3_unlock_height = (EPOCH_2_5_HEIGHT + 1) as u32;
+    pox_constants.pox_3_activation_height = (EPOCH_2_4_HEIGHT + 1) as u32;
+    pox_constants.pox_4_activation_height = (EPOCH_3_0_HEIGHT + 1) as u32;
+
+    (epochs, pox_constants)
+}
+
+/// In this test case, two Stackers, Alice and Bob stack and interact with the
+///  PoX v1 contract and PoX v2 contract across the epoch transition and then
+///  again with the PoX v3 contract.
+///
+/// Alice: stacks via PoX v1 for 4 cycles. The third of these cycles occurs after
+///        the PoX v1 -> v2 transition, and so Alice gets "early unlocked".
+///        After the early unlock, Alice re-stacks in PoX v2
+/// Bob:   stacks via PoX v2 for 6 cycles. He attempted to stack via PoX v1 as well,
+///        but is forbidden because he has already placed an account lock via PoX v2.
+///        
+/// After the PoX-3 contract is instantiated, Alice and Bob both stack via PoX v3.
+///
+#[test]
+fn simple_pox_lockup_transition_pox_2() {
+    let EXPECTED_FIRST_V2_CYCLE = 8;
+    // the sim environment produces 25 empty sortitions before
+    //  tenures start being tracked.
+    let EMPTY_SORTITIONS = 25;
+
+    let (epochs, pox_constants) = make_test_epochs_pox();
+
+    let mut burnchain = Burnchain::default_unittest(
+        0,
+        &BurnchainHeaderHash::from_hex(BITCOIN_REGTEST_FIRST_BLOCK_HASH).unwrap(),
+    );
+    burnchain.pox_constants = pox_constants.clone();
+
+    let first_v2_cycle = burnchain
+        .block_height_to_reward_cycle(burnchain.pox_constants.v1_unlock_height as u64)
+        .unwrap()
+        + 1;
+
+    assert_eq!(first_v2_cycle, EXPECTED_FIRST_V2_CYCLE);
+
+    eprintln!("First v2 cycle = {}", first_v2_cycle);
+
+    let observer = TestEventObserver::new();
+
+    let (mut peer, mut keys) = instantiate_pox_peer_with_epoch(
+        &burnchain,
+        function_name!(),
+        Some(epochs.clone()),
+        Some(&observer),
+    );
+
+    peer.config.check_pox_invariants =
+        Some((EXPECTED_FIRST_V2_CYCLE, EXPECTED_FIRST_V2_CYCLE + 20));
+
+    let alice = keys.pop().unwrap();
+    let bob = keys.pop().unwrap();
+    let charlie = keys.pop().unwrap();
+
+    let EXPECTED_ALICE_FIRST_REWARD_CYCLE = 6;
+
+    let mut coinbase_nonce = 0;
+
+    // our "tenure counter" is now at 0
+    let tip = get_tip(peer.sortdb.as_ref());
+    assert_eq!(tip.block_height, 0 + EMPTY_SORTITIONS as u64);
+
+    // first tenure is empty
+    peer.tenure_with_txs(&[], &mut coinbase_nonce);
+
+    let alice_balance = get_balance(&mut peer, &key_to_stacks_addr(&alice).into());
+    assert_eq!(alice_balance, 1024 * POX_THRESHOLD_STEPS_USTX);
+
+    let alice_account = get_account(&mut peer, &key_to_stacks_addr(&alice).into());
+    assert_eq!(
+        alice_account.stx_balance.amount_unlocked(),
+        1024 * POX_THRESHOLD_STEPS_USTX
+    );
+    assert_eq!(alice_account.stx_balance.amount_locked(), 0);
+    assert_eq!(alice_account.stx_balance.unlock_height(), 0);
+
+    // next tenure include Alice's lockup
+    let tip = get_tip(peer.sortdb.as_ref());
+    let alice_lockup = make_pox_lockup(
+        &alice,
+        0,
+        1024 * POX_THRESHOLD_STEPS_USTX,
+        AddressHashMode::SerializeP2PKH,
+        key_to_stacks_addr(&alice).bytes,
+        4,
+        tip.block_height,
+    );
+
+    // our "tenure counter" is now at 1
+    assert_eq!(tip.block_height, 1 + EMPTY_SORTITIONS as u64);
+
+    let tip_index_block = peer.tenure_with_txs(&[alice_lockup], &mut coinbase_nonce);
+
+    // check the stacking minimum
+    let total_liquid_ustx = get_liquid_ustx(&mut peer);
+    let min_ustx = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
+        chainstate.get_stacking_minimum(sortdb, &tip_index_block)
+    })
+    .unwrap();
+    assert_eq!(
+        min_ustx,
+        total_liquid_ustx / POX_TESTNET_STACKING_THRESHOLD_25
+    );
+
+    // no reward addresses
+    let reward_addrs = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
+        get_reward_addresses_with_par_tip(chainstate, &burnchain, sortdb, &tip_index_block)
+    })
+    .unwrap();
+    assert_eq!(reward_addrs.len(), 0);
+
+    // check the first reward cycle when Alice's tokens get stacked
+    let tip_burn_block_height = get_par_burn_block_height(peer.chainstate(), &tip_index_block);
+    let alice_first_reward_cycle = 1 + burnchain
+        .block_height_to_reward_cycle(tip_burn_block_height)
+        .unwrap() as u128;
+
+    assert_eq!(alice_first_reward_cycle, EXPECTED_ALICE_FIRST_REWARD_CYCLE);
+
+    // alice locked, so balance should be 0
+    let alice_balance = get_balance(&mut peer, &key_to_stacks_addr(&alice).into());
+    assert_eq!(alice_balance, 0);
+
+    // produce blocks until immediately before the 2.1 epoch switch
+    while get_tip(peer.sortdb.as_ref()).block_height < epochs[3].start_height {
+        peer.tenure_with_txs(&[], &mut coinbase_nonce);
+
+        // alice is still locked, balance should be 0
+        let alice_balance = get_balance(&mut peer, &key_to_stacks_addr(&alice).into());
+        assert_eq!(alice_balance, 0);
+    }
+
+    // Have Charlie try to use the PoX2 contract. This transaction
+    //  should be accepted (checked via the tx receipt). Also, importantly,
+    //  the cost tracker should assign costs to Charlie's transaction.
+    //  This is also checked by the transaction receipt.
+    let tip = get_tip(peer.sortdb.as_ref());
+
+    let test = make_pox_2_contract_call(
+        &charlie,
+        0,
+        "delegate-stx",
+        vec![
+            Value::UInt(1_000_000),
+            PrincipalData::from(key_to_stacks_addr(&charlie)).into(),
+            Value::none(),
+            Value::none(),
+        ],
+    );
+    peer.tenure_with_txs(&[test], &mut coinbase_nonce);
+
+    // alice is still locked, balance should be 0
+    let alice_balance = get_balance(&mut peer, &key_to_stacks_addr(&alice).into());
+    assert_eq!(alice_balance, 0);
+
+    // in the next tenure, PoX 2 should now exist.
+    // Lets have Bob lock up for v2
+    // this will lock for cycles 8, 9, 10, and 11
+    //  the first v2 cycle will be 8
+    let tip = get_tip(peer.sortdb.as_ref());
+
+    let bob_lockup = make_pox_2_lockup(
+        &bob,
+        0,
+        512 * POX_THRESHOLD_STEPS_USTX,
+        PoxAddress::from_legacy(
+            AddressHashMode::SerializeP2PKH,
+            key_to_stacks_addr(&bob).bytes,
+        ),
+        6,
+        tip.block_height,
+    );
+
+    let block_id = peer.tenure_with_txs(&[bob_lockup], &mut coinbase_nonce);
+
+    assert_eq!(
+        get_tip(peer.sortdb.as_ref()).block_height as u32,
+        pox_constants.v1_unlock_height + 1,
+        "Test should have reached 1 + PoX-v1 unlock height"
+    );
+
+    // Auto unlock height is reached, Alice balance should be unlocked
+    let alice_balance = get_balance(&mut peer, &key_to_stacks_addr(&alice).into());
+    assert_eq!(alice_balance, 1024 * POX_THRESHOLD_STEPS_USTX);
+
+    // Now, Bob tries to lock in PoX v1 too, but it shouldn't work!
+    let tip = get_tip(peer.sortdb.as_ref());
+
+    let bob_lockup = make_pox_lockup(
+        &bob,
+        1,
+        512 * POX_THRESHOLD_STEPS_USTX,
+        AddressHashMode::SerializeP2PKH,
+        key_to_stacks_addr(&bob).bytes,
+        4,
+        tip.block_height,
+    );
+
+    let block_id = peer.tenure_with_txs(&[bob_lockup], &mut coinbase_nonce);
+
+    // At this point, the auto unlock height for v1 accounts has been reached.
+    //  let Alice stack in PoX v2
+    let tip = get_tip(peer.sortdb.as_ref());
+
+    let alice_lockup = make_pox_2_lockup(
+        &alice,
+        1,
+        512 * POX_THRESHOLD_STEPS_USTX,
+        PoxAddress::from_legacy(
+            AddressHashMode::SerializeP2PKH,
+            key_to_stacks_addr(&alice).bytes,
+        ),
+        12,
+        tip.block_height,
+    );
+    peer.tenure_with_txs(&[alice_lockup], &mut coinbase_nonce);
+
+    // Alice locked half her balance in PoX 2
+    let alice_balance = get_balance(&mut peer, &key_to_stacks_addr(&alice).into());
+    assert_eq!(alice_balance, 512 * POX_THRESHOLD_STEPS_USTX);
+
+    // now, let's roll the chain forward until just before Epoch-2.2
+    while get_tip(peer.sortdb.as_ref()).block_height < epochs[4].start_height {
+        peer.tenure_with_txs(&[], &mut coinbase_nonce);
+        // at this point, alice's balance should always include this half lockup
+        let alice_balance = get_balance(&mut peer, &key_to_stacks_addr(&alice).into());
+        assert_eq!(alice_balance, 512 * POX_THRESHOLD_STEPS_USTX);
+    }
+
+    // this block is mined in epoch-2.2
+    peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    let alice_balance = get_balance(&mut peer, &key_to_stacks_addr(&alice).into());
+    assert_eq!(alice_balance, 512 * POX_THRESHOLD_STEPS_USTX);
+    // this block should unlock alice's balance
+    peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    let alice_balance = get_balance(&mut peer, &key_to_stacks_addr(&alice).into());
+    assert_eq!(alice_balance, 1024 * POX_THRESHOLD_STEPS_USTX);
+
+    // now, roll the chain forward to Epoch-2.4
+    while get_tip(peer.sortdb.as_ref()).block_height <= epochs[6].start_height {
+        peer.tenure_with_txs(&[], &mut coinbase_nonce);
+        // at this point, alice's balance should always be unlocked
+        let alice_balance = get_balance(&mut peer, &key_to_stacks_addr(&alice).into());
+        assert_eq!(alice_balance, 1024 * POX_THRESHOLD_STEPS_USTX);
+    }
+
+    let tip = get_tip(peer.sortdb.as_ref()).block_height;
+    let bob_lockup = make_pox_3_lockup(
+        &bob,
+        2,
+        512 * POX_THRESHOLD_STEPS_USTX,
+        PoxAddress::from_legacy(
+            AddressHashMode::SerializeP2PKH,
+            key_to_stacks_addr(&bob).bytes,
+        ),
+        6,
+        tip,
+    );
+
+    let alice_lockup = make_pox_3_lockup(
+        &alice,
+        2,
+        512 * POX_THRESHOLD_STEPS_USTX,
+        PoxAddress::from_legacy(
+            AddressHashMode::SerializeP2PKH,
+            key_to_stacks_addr(&alice).bytes,
+        ),
+        6,
+        tip,
+    );
+
+    peer.tenure_with_txs(&[bob_lockup, alice_lockup], &mut coinbase_nonce);
+
+    let alice_balance = get_balance(&mut peer, &key_to_stacks_addr(&alice).into());
+    assert_eq!(alice_balance, 512 * POX_THRESHOLD_STEPS_USTX);
+    let bob_balance = get_balance(&mut peer, &key_to_stacks_addr(&bob).into());
+    assert_eq!(bob_balance, 512 * POX_THRESHOLD_STEPS_USTX);
+
+    // now let's check some tx receipts
+
+    let alice_address = key_to_stacks_addr(&alice);
+    let bob_address = key_to_stacks_addr(&bob);
+    let blocks = observer.get_blocks();
+
+    let mut alice_txs = HashMap::new();
+    let mut bob_txs = HashMap::new();
+    let mut charlie_txs = HashMap::new();
+
+    debug!("Alice addr: {}, Bob addr: {}", alice_address, bob_address);
+
+    let mut tested_charlie = false;
+
+    for b in blocks.into_iter() {
+        for r in b.receipts.into_iter() {
+            if let TransactionOrigin::Stacks(ref t) = r.transaction {
+                let addr = t.auth.origin().address_testnet();
+                debug!("Transaction addr: {}", addr);
+                if addr == alice_address {
+                    alice_txs.insert(t.auth.get_origin_nonce(), r);
+                } else if addr == bob_address {
+                    bob_txs.insert(t.auth.get_origin_nonce(), r);
+                } else if addr == key_to_stacks_addr(&charlie) {
+                    assert!(
+                        r.execution_cost != ExecutionCost::zero(),
+                        "Execution cost is not zero!"
+                    );
+                    charlie_txs.insert(t.auth.get_origin_nonce(), r);
+
+                    tested_charlie = true;
+                }
+            }
+        }
+    }
+
+    assert!(tested_charlie, "Charlie TX must be tested");
+    // Alice should have three accepted transactions:
+    //  TX0 -> Alice's initial lockup in PoX 1
+    //  TX1 -> Alice's PoX 2 lockup
+    //  TX2 -> Alice's PoX 3 lockup
+    assert_eq!(alice_txs.len(), 3, "Alice should have 3 confirmed txs");
+    // Bob should have two accepted transactions:
+    //  TX0 -> Bob's initial lockup in PoX 2
+    //  TX1 -> Bob's attempt to lock again in PoX 1 -- this one should fail
+    //         because PoX 1 is now defunct. Checked via the tx receipt.
+    //  TX2 -> Bob's PoX 3 lockup
+    assert_eq!(bob_txs.len(), 3, "Bob should have 3 confirmed txs");
+    // Charlie should have one accepted transactions:
+    //  TX0 -> Charlie's delegation in PoX 2. This tx just checks that the
+    //         initialization code tracks costs in txs that occur after the
+    //         initialization code (which uses a free tracker).
+    assert_eq!(charlie_txs.len(), 1, "Charlie should have 1 confirmed txs");
+
+    //  TX0 -> Alice's initial lockup in PoX 1
+    assert!(
+        match alice_txs.get(&0).unwrap().result {
+            Value::Response(ref r) => r.committed,
+            _ => false,
+        },
+        "Alice tx0 should have committed okay"
+    );
+
+    //  TX1 -> Alice's PoX 2 lockup
+    assert!(
+        match alice_txs.get(&1).unwrap().result {
+            Value::Response(ref r) => r.committed,
+            _ => false,
+        },
+        "Alice tx1 should have committed okay"
+    );
+
+    //  TX2 -> Alice's PoX 3 lockup
+    assert!(
+        match alice_txs.get(&1).unwrap().result {
+            Value::Response(ref r) => r.committed,
+            _ => false,
+        },
+        "Alice tx3 should have committed okay"
+    );
+
+    //  TX0 -> Bob's initial lockup in PoX 2
+    assert!(
+        match bob_txs.get(&0).unwrap().result {
+            Value::Response(ref r) => r.committed,
+            _ => false,
+        },
+        "Bob tx0 should have committed okay"
+    );
+
+    //  TX1 -> Bob's attempt to lock again in PoX 1 -- this one should fail
+    //         because PoX 1 is now defunct. Checked via the tx receipt.
+    assert_eq!(
+        bob_txs.get(&1).unwrap().result,
+        Value::err_none(),
+        "Bob tx1 should have resulted in a runtime error"
+    );
+
+    //  TX0 -> Charlie's delegation in PoX 2. This tx just checks that the
+    //         initialization code tracks costs in txs that occur after the
+    //         initialization code (which uses a free tracker).
+    assert!(
+        match charlie_txs.get(&0).unwrap().result {
+            Value::Response(ref r) => r.committed,
+            _ => false,
+        },
+        "Charlie tx0 should have committed okay"
+    );
+}
+
+#[test]
+fn pox_auto_unlock_ab() {
+    pox_auto_unlock(true)
+}
+
+#[test]
+fn pox_auto_unlock_ba() {
+    pox_auto_unlock(false)
+}
+
+/// In this test case, two Stackers, Alice and Bob stack and interact with the
+///  PoX v1 contract and PoX v2 contract across the epoch transition, and then again
+///  in PoX v3.
+///
+/// Alice: stacks via PoX v1 for 4 cycles. The third of these cycles occurs after
+///        the PoX v1 -> v2 transition, and so Alice gets "early unlocked".
+///        After the early unlock, Alice re-stacks in PoX v2
+/// Bob:   stacks via PoX v2 for 6 cycles. He attempted to stack via PoX v1 as well,
+///        but is forbidden because he has already placed an account lock via PoX v2.
+///
+/// Note: this test is symmetric over the order of alice and bob's stacking calls.
+///       when alice goes first, the auto-unlock code doesn't need to perform a "move"
+///       when bob goes first, the auto-unlock code does need to perform a "move"
+fn pox_auto_unlock(alice_first: bool) {
+    let EXPECTED_FIRST_V2_CYCLE = 8;
+    // the sim environment produces 25 empty sortitions before
+    //  tenures start being tracked.
+    let EMPTY_SORTITIONS = 25;
+
+    let (epochs, pox_constants) = make_test_epochs_pox();
+
+    let mut burnchain = Burnchain::default_unittest(
+        0,
+        &BurnchainHeaderHash::from_hex(BITCOIN_REGTEST_FIRST_BLOCK_HASH).unwrap(),
+    );
+    burnchain.pox_constants = pox_constants.clone();
+
+    let first_v2_cycle = burnchain
+        .block_height_to_reward_cycle(burnchain.pox_constants.v1_unlock_height as u64)
+        .unwrap()
+        + 1;
+
+    let first_v3_cycle = burnchain
+        .block_height_to_reward_cycle(burnchain.pox_constants.pox_3_activation_height as u64)
+        .unwrap()
+        + 1;
+
+    assert_eq!(first_v2_cycle, EXPECTED_FIRST_V2_CYCLE);
+
+    eprintln!("First v2 cycle = {}", first_v2_cycle);
+
+    let observer = TestEventObserver::new();
+
+    let (mut peer, mut keys) = instantiate_pox_peer_with_epoch(
+        &burnchain,
+        &format!("{}-{}", function_name!(), alice_first),
+        Some(epochs.clone()),
+        Some(&observer),
+    );
+
+    peer.config.check_pox_invariants =
+        Some((EXPECTED_FIRST_V2_CYCLE, EXPECTED_FIRST_V2_CYCLE + 10));
+
+    let alice = keys.pop().unwrap();
+    let bob = keys.pop().unwrap();
+
+    let mut coinbase_nonce = 0;
+
+    // produce blocks until epoch 2.1
+    while get_tip(peer.sortdb.as_ref()).block_height <= epochs[3].start_height {
+        peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    }
+
+    // in the next tenure, PoX 2 should now exist.
+    // Lets have Bob lock up for v2
+    // this will lock for cycles 8, 9, 10, and 11
+    //  the first v2 cycle will be 8
+    let tip = get_tip(peer.sortdb.as_ref());
+
+    let alice_lockup = make_pox_2_lockup(
+        &alice,
+        0,
+        1024 * POX_THRESHOLD_STEPS_USTX,
+        PoxAddress::from_legacy(
+            AddressHashMode::SerializeP2PKH,
+            key_to_stacks_addr(&alice).bytes,
+        ),
+        6,
+        tip.block_height,
+    );
+
+    let bob_lockup = make_pox_2_lockup(
+        &bob,
+        0,
+        1 * POX_THRESHOLD_STEPS_USTX,
+        PoxAddress::from_legacy(
+            AddressHashMode::SerializeP2PKH,
+            key_to_stacks_addr(&bob).bytes,
+        ),
+        6,
+        tip.block_height,
+    );
+
+    let txs = if alice_first {
+        [alice_lockup, bob_lockup]
+    } else {
+        [bob_lockup, alice_lockup]
+    };
+    let mut latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
+
+    // check that the "raw" reward set will contain entries for alice and bob
+    //  for the pox-2 cycles
+    for cycle_number in EXPECTED_FIRST_V2_CYCLE..first_v3_cycle {
+        let cycle_start = burnchain.reward_cycle_to_block_height(cycle_number);
+        let reward_set_entries = get_reward_set_entries_at(&mut peer, &latest_block, cycle_start);
+        assert_eq!(reward_set_entries.len(), 2);
+        assert_eq!(
+            reward_set_entries[0].reward_address.bytes(),
+            key_to_stacks_addr(&bob).bytes.0.to_vec()
+        );
+        assert_eq!(
+            reward_set_entries[1].reward_address.bytes(),
+            key_to_stacks_addr(&alice).bytes.0.to_vec()
+        );
+    }
+
+    // we'll produce blocks until the next reward cycle gets through the "handled start" code
+    //  this is one block after the reward cycle starts
+    let height_target = burnchain.reward_cycle_to_block_height(EXPECTED_FIRST_V2_CYCLE) + 1;
+
+    // but first, check that bob has locked tokens at (height_target + 1)
+    let bob_bal = get_stx_account_at(
+        &mut peer,
+        &latest_block,
+        &key_to_stacks_addr(&bob).to_account_principal(),
+    );
+    assert_eq!(bob_bal.amount_locked(), POX_THRESHOLD_STEPS_USTX);
+
+    while get_tip(peer.sortdb.as_ref()).block_height < height_target {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    }
+
+    let first_auto_unlock_coinbase = height_target - 1 - EMPTY_SORTITIONS;
+
+    // check that the "raw" reward sets for all cycles just contains entries for alice
+    //  at the cycle start
+    for cycle_number in EXPECTED_FIRST_V2_CYCLE..first_v3_cycle {
+        let cycle_start = burnchain.reward_cycle_to_block_height(cycle_number);
+        let reward_set_entries = get_reward_set_entries_at(&mut peer, &latest_block, cycle_start);
+        assert_eq!(reward_set_entries.len(), 1);
+        assert_eq!(
+            reward_set_entries[0].reward_address.bytes(),
+            key_to_stacks_addr(&alice).bytes.0.to_vec()
+        );
+    }
+
+    // now check that bob has an unlock height of `height_target`
+    let bob_bal = get_stx_account_at(
+        &mut peer,
+        &latest_block,
+        &key_to_stacks_addr(&bob).to_account_principal(),
+    );
+    assert_eq!(bob_bal.unlock_height(), height_target);
+
+    // but bob's still locked at (height_target): the unlock is accelerated to the "next" burn block
+    assert_eq!(bob_bal.amount_locked(), 10000000000);
+
+    // check that the total reward cycle amounts have decremented correctly
+    for cycle_number in EXPECTED_FIRST_V2_CYCLE..first_v3_cycle {
+        assert_eq!(
+            get_reward_cycle_total(&mut peer, &latest_block, cycle_number),
+            1024 * POX_THRESHOLD_STEPS_USTX
+        );
+    }
+
+    // check that bob is fully unlocked at next block
+    latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+
+    let bob_bal = get_stx_account_at(
+        &mut peer,
+        &latest_block,
+        &key_to_stacks_addr(&bob).to_account_principal(),
+    );
+    assert_eq!(bob_bal.unlock_height(), 0);
+    assert_eq!(bob_bal.amount_locked(), 0);
+
+    // check that the total reward cycle amounts have decremented correctly
+    for cycle_number in EXPECTED_FIRST_V2_CYCLE..first_v3_cycle {
+        assert_eq!(
+            get_reward_cycle_total(&mut peer, &latest_block, cycle_number),
+            1024 * POX_THRESHOLD_STEPS_USTX
+        );
+    }
+
+    // check that bob's stacking-state is gone and alice's stacking-state is correct
+    assert!(
+        get_stacking_state_pox_2(
+            &mut peer,
+            &latest_block,
+            &key_to_stacks_addr(&bob).to_account_principal()
+        )
+        .is_none(),
+        "Bob should not have a stacking-state entry"
+    );
+
+    let alice_state = get_stacking_state_pox_2(
+        &mut peer,
+        &latest_block,
+        &key_to_stacks_addr(&alice).to_account_principal(),
+    )
+    .expect("Alice should have stacking-state entry")
+    .expect_tuple();
+    let reward_indexes_str = format!("{}", alice_state.get("reward-set-indexes").unwrap());
+    assert_eq!(reward_indexes_str, "(u0 u0 u0 u0 u0 u0)");
+
+    // now, lets check behavior in Epochs 2.2-2.4, with pox-3 auto unlock tests
+
+    // produce blocks until epoch 2.2
+    while get_tip(peer.sortdb.as_ref()).block_height <= epochs[4].start_height {
+        peer.tenure_with_txs(&[], &mut coinbase_nonce);
+        let alice_balance = get_balance(&mut peer, &key_to_stacks_addr(&alice).into());
+        assert_eq!(alice_balance, 0);
+    }
+
+    // check that alice is unlocked now
+    peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    let alice_balance = get_balance(&mut peer, &key_to_stacks_addr(&alice).into());
+    assert_eq!(alice_balance, 1024 * POX_THRESHOLD_STEPS_USTX);
+
+    // produce blocks until epoch 2.4
+    while get_tip(peer.sortdb.as_ref()).block_height <= epochs[6].start_height {
+        peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    }
+
+    // repeat the lockups as before, so we can test the pox-3 auto unlock behavior
+    let tip = get_tip(peer.sortdb.as_ref());
+
+    let alice_lockup = make_pox_3_lockup(
+        &alice,
+        1,
+        1024 * POX_THRESHOLD_STEPS_USTX,
+        PoxAddress::from_legacy(
+            AddressHashMode::SerializeP2PKH,
+            key_to_stacks_addr(&alice).bytes,
+        ),
+        6,
+        tip.block_height,
+    );
+
+    let bob_lockup = make_pox_3_lockup(
+        &bob,
+        1,
+        1 * POX_THRESHOLD_STEPS_USTX,
+        PoxAddress::from_legacy(
+            AddressHashMode::SerializeP2PKH,
+            key_to_stacks_addr(&bob).bytes,
+        ),
+        6,
+        tip.block_height,
+    );
+
+    let txs = if alice_first {
+        [alice_lockup, bob_lockup]
+    } else {
+        [bob_lockup, alice_lockup]
+    };
+    latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
+
+    // check that the "raw" reward set will contain entries for alice and bob
+    //  for the pox-3 cycles
+    for cycle_number in first_v3_cycle..(first_v3_cycle + 6) {
+        let cycle_start = burnchain.reward_cycle_to_block_height(cycle_number);
+        let reward_set_entries = get_reward_set_entries_at(&mut peer, &latest_block, cycle_start);
+        assert_eq!(reward_set_entries.len(), 2);
+        assert_eq!(
+            reward_set_entries[0].reward_address.bytes(),
+            key_to_stacks_addr(&bob).bytes.0.to_vec()
+        );
+        assert_eq!(
+            reward_set_entries[1].reward_address.bytes(),
+            key_to_stacks_addr(&alice).bytes.0.to_vec()
+        );
+    }
+
+    // we'll produce blocks until the next reward cycle gets through the "handled start" code
+    //  this is one block after the reward cycle starts
+    let height_target = burnchain.reward_cycle_to_block_height(first_v3_cycle) + 1;
+    let second_auto_unlock_coinbase = height_target - 1 - EMPTY_SORTITIONS;
+
+    // but first, check that bob has locked tokens at (height_target + 1)
+    let bob_bal = get_stx_account_at(
+        &mut peer,
+        &latest_block,
+        &key_to_stacks_addr(&bob).to_account_principal(),
+    );
+    assert_eq!(bob_bal.amount_locked(), POX_THRESHOLD_STEPS_USTX);
+
+    while get_tip(peer.sortdb.as_ref()).block_height < height_target {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    }
+
+    // check that the "raw" reward sets for all cycles just contains entries for alice
+    //  at the cycle start
+    for cycle_number in first_v3_cycle..(first_v3_cycle + 6) {
+        let cycle_start = burnchain.reward_cycle_to_block_height(cycle_number);
+        let reward_set_entries = get_reward_set_entries_at(&mut peer, &latest_block, cycle_start);
+        assert_eq!(reward_set_entries.len(), 1);
+        assert_eq!(
+            reward_set_entries[0].reward_address.bytes(),
+            key_to_stacks_addr(&alice).bytes.0.to_vec()
+        );
+    }
+
+    // now check that bob has an unlock height of `height_target`
+    let bob_bal = get_stx_account_at(
+        &mut peer,
+        &latest_block,
+        &key_to_stacks_addr(&bob).to_account_principal(),
+    );
+    assert_eq!(bob_bal.unlock_height(), height_target);
+    // but bob's still locked at (height_target): the unlock is accelerated to the "next" burn block
+    assert_eq!(bob_bal.amount_locked(), 10000000000);
+
+    // check that the total reward cycle amounts have decremented correctly
+    for cycle_number in first_v3_cycle..(first_v3_cycle + 6) {
+        assert_eq!(
+            get_reward_cycle_total(&mut peer, &latest_block, cycle_number),
+            1024 * POX_THRESHOLD_STEPS_USTX
+        );
+    }
+
+    // check that bob's stacking-state is gone and alice's stacking-state is correct
+    assert!(
+        get_stacking_state_pox(
+            &mut peer,
+            &latest_block,
+            &key_to_stacks_addr(&bob).to_account_principal(),
+            POX_3_NAME,
+        )
+        .is_none(),
+        "Bob should not have a stacking-state entry"
+    );
+
+    let alice_state = get_stacking_state_pox(
+        &mut peer,
+        &latest_block,
+        &key_to_stacks_addr(&alice).to_account_principal(),
+        POX_3_NAME,
+    )
+    .expect("Alice should have stacking-state entry")
+    .expect_tuple();
+    let reward_indexes_str = format!("{}", alice_state.get("reward-set-indexes").unwrap());
+    assert_eq!(reward_indexes_str, "(u0 u0 u0 u0 u0 u0)");
+
+    // check that bob is fully unlocked at next block
+    latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+
+    let bob_bal = get_stx_account_at(
+        &mut peer,
+        &latest_block,
+        &key_to_stacks_addr(&bob).to_account_principal(),
+    );
+    assert_eq!(bob_bal.unlock_height(), 0);
+    assert_eq!(bob_bal.amount_locked(), 0);
+
+    // now let's check some tx receipts
+
+    let alice_address = key_to_stacks_addr(&alice);
+    let bob_address = key_to_stacks_addr(&bob);
+    let blocks = observer.get_blocks();
+
+    let mut alice_txs = HashMap::new();
+    let mut bob_txs = HashMap::new();
+    let mut coinbase_txs = vec![];
+
+    for b in blocks.into_iter() {
+        for (i, r) in b.receipts.into_iter().enumerate() {
+            if i == 0 {
+                coinbase_txs.push(r);
+                continue;
+            }
+            match r.transaction {
+                TransactionOrigin::Stacks(ref t) => {
+                    let addr = t.auth.origin().address_testnet();
+                    if addr == alice_address {
+                        alice_txs.insert(t.auth.get_origin_nonce(), r);
+                    } else if addr == bob_address {
+                        bob_txs.insert(t.auth.get_origin_nonce(), r);
+                    }
+                }
+                _ => {}
+            }
+        }
+    }
+
+    assert_eq!(alice_txs.len(), 2);
+    assert_eq!(bob_txs.len(), 2);
+
+    //  TX0 -> Bob's initial lockup in PoX 2
+    assert!(
+        match bob_txs.get(&0).unwrap().result {
+            Value::Response(ref r) => r.committed,
+            _ => false,
+        },
+        "Bob tx0 should have committed okay"
+    );
+
+    assert_eq!(coinbase_txs.len(), 38);
+
+    info!(
+        "Expected first auto-unlock coinbase index: {}",
+        first_auto_unlock_coinbase
+    );
+
+    // Check that the event produced by "handle-unlock" has a well-formed print event
+    // and that this event is included as part of the coinbase tx
+    for unlock_coinbase_index in [first_auto_unlock_coinbase, second_auto_unlock_coinbase] {
+        // expect the unlock to occur 1 block after the handle-unlock method was invoked.
+        let expected_unlock_height = unlock_coinbase_index + EMPTY_SORTITIONS + 1;
+        let expected_cycle = pox_constants
+            .block_height_to_reward_cycle(0, expected_unlock_height)
+            .unwrap();
+
+        let auto_unlock_tx = coinbase_txs[unlock_coinbase_index as usize].events[0].clone();
+        let pox_addr_val = generate_pox_clarity_value("60c59ab11f7063ef44c16d3dc856f76bbb915eba");
+        let auto_unlock_op_data = HashMap::from([
+            ("first-cycle-locked", Value::UInt(expected_cycle.into())),
+            ("first-unlocked-cycle", Value::UInt(expected_cycle.into())),
+            ("pox-addr", pox_addr_val),
+        ]);
+        let common_data = PoxPrintFields {
+            op_name: "handle-unlock".to_string(),
+            stacker: Value::Principal(
+                StacksAddress::from_string("ST1GCB6NH3XR67VT4R5PKVJ2PYXNVQ4AYQATXNP4P")
+                    .unwrap()
+                    .to_account_principal(),
+            ),
+            balance: Value::UInt(10230000000000),
+            locked: Value::UInt(10000000000),
+            burnchain_unlock_height: Value::UInt(expected_unlock_height.into()),
+        };
+        check_pox_print_event(&auto_unlock_tx, common_data, auto_unlock_op_data);
+    }
+}
+
+/// In this test case, Alice delegates to Bob.
+///  Bob stacks Alice's funds via PoX v2 for 6 cycles. In the third cycle,
+///  Bob increases Alice's stacking amount.
+///
+#[test]
+fn delegate_stack_increase() {
+    let EXPECTED_FIRST_V2_CYCLE = 8;
+    // the sim environment produces 25 empty sortitions before
+    //  tenures start being tracked.
+    let EMPTY_SORTITIONS = 25;
+
+    let (epochs, pox_constants) = make_test_epochs_pox();
+
+    let mut burnchain = Burnchain::default_unittest(
+        0,
+        &BurnchainHeaderHash::from_hex(BITCOIN_REGTEST_FIRST_BLOCK_HASH).unwrap(),
+    );
+    burnchain.pox_constants = pox_constants.clone();
+
+    let first_v2_cycle = burnchain
+        .block_height_to_reward_cycle(burnchain.pox_constants.v1_unlock_height as u64)
+        .unwrap()
+        + 1;
+
+    let first_v3_cycle = burnchain
+        .block_height_to_reward_cycle(burnchain.pox_constants.pox_3_activation_height as u64)
+        .unwrap()
+        + 1;
+
+    assert_eq!(first_v2_cycle, EXPECTED_FIRST_V2_CYCLE);
+
+    let observer = TestEventObserver::new();
+
+    let (mut peer, mut keys) = instantiate_pox_peer_with_epoch(
+        &burnchain,
+        function_name!(),
+        Some(epochs.clone()),
+        Some(&observer),
+    );
+
+    peer.config.check_pox_invariants =
+        Some((EXPECTED_FIRST_V2_CYCLE, EXPECTED_FIRST_V2_CYCLE + 10));
+
+    let num_blocks = 35;
+
+    let alice = keys.pop().unwrap();
+    let alice_address = key_to_stacks_addr(&alice);
+    let alice_principal = PrincipalData::from(alice_address.clone());
+    let bob = keys.pop().unwrap();
+    let bob_address = key_to_stacks_addr(&bob);
+    let bob_principal = PrincipalData::from(bob_address.clone());
+    let bob_pox_addr = make_pox_addr(AddressHashMode::SerializeP2PKH, bob_address.bytes.clone());
+    let mut alice_nonce = 0;
+    let mut bob_nonce = 0;
+
+    let alice_delegation_amount = 1023 * POX_THRESHOLD_STEPS_USTX;
+    let alice_first_lock_amount = 512 * POX_THRESHOLD_STEPS_USTX;
+
+    let mut coinbase_nonce = 0;
+
+    // produce blocks until epoch 2.1
+    while get_tip(peer.sortdb.as_ref()).block_height <= epochs[3].start_height {
+        peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    }
+
+    // in the next tenure, PoX 2 should now exist.
+    let tip = get_tip(peer.sortdb.as_ref());
+
+    // submit delegation tx
+    let alice_delegation_1 = make_pox_2_contract_call(
+        &alice,
+        alice_nonce,
+        "delegate-stx",
+        vec![
+            Value::UInt(alice_delegation_amount),
+            bob_principal.clone().into(),
+            Value::none(),
+            Value::none(),
+        ],
+    );
+
+    let alice_delegation_pox_2_nonce = alice_nonce;
+    alice_nonce += 1;
+
+    let delegate_stack_tx = make_pox_2_contract_call(
+        &bob,
+        bob_nonce,
+        "delegate-stack-stx",
+        vec![
+            alice_principal.clone().into(),
+            Value::UInt(alice_first_lock_amount),
+            bob_pox_addr.clone(),
+            Value::UInt(tip.block_height as u128),
+            Value::UInt(6),
+        ],
+    );
+
+    bob_nonce += 1;
+
+    let mut latest_block = peer.tenure_with_txs(
+        &[alice_delegation_1, delegate_stack_tx],
+        &mut coinbase_nonce,
+    );
+
+    let expected_pox_2_unlock_ht =
+        burnchain.reward_cycle_to_block_height(EXPECTED_FIRST_V2_CYCLE + 6) - 1;
+    let alice_bal = get_stx_account_at(&mut peer, &latest_block, &alice_principal);
+    assert_eq!(alice_bal.amount_locked(), alice_first_lock_amount);
+    assert_eq!(alice_bal.unlock_height(), expected_pox_2_unlock_ht);
+
+    // check that the partial stacking state contains entries for bob
+    for cycle_number in EXPECTED_FIRST_V2_CYCLE..(EXPECTED_FIRST_V2_CYCLE + 6) {
+        let partial_stacked = get_partial_stacked(
+            &mut peer,
+            &latest_block,
+            &bob_pox_addr,
+            cycle_number,
+            &bob_principal,
+            POX_2_NAME,
+        );
+        assert_eq!(partial_stacked, 512 * POX_THRESHOLD_STEPS_USTX);
+    }
+
+    // we'll produce blocks until the 1st reward cycle gets through the "handled start" code
+    //  this is one block after the reward cycle starts
+    let height_target = burnchain.reward_cycle_to_block_height(EXPECTED_FIRST_V2_CYCLE + 1) + 1;
+
+    while get_tip(peer.sortdb.as_ref()).block_height < height_target {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    }
+
+    let alice_bal = get_stx_account_at(&mut peer, &latest_block, &alice_principal);
+
+    assert_eq!(alice_bal.amount_locked(), alice_first_lock_amount);
+
+    // check that the partial stacking state contains entries for bob
+    for cycle_number in EXPECTED_FIRST_V2_CYCLE..(EXPECTED_FIRST_V2_CYCLE + 6) {
+        let partial_stacked = get_partial_stacked(
+            &mut peer,
+            &latest_block,
+            &bob_pox_addr,
+            cycle_number,
+            &bob_principal,
+            POX_2_NAME,
+        );
+        assert_eq!(partial_stacked, 512 * POX_THRESHOLD_STEPS_USTX);
+    }
+
+    let mut txs_to_submit = vec![];
+
+    let fail_direct_increase_delegation = alice_nonce;
+    txs_to_submit.push(make_pox_2_contract_call(
+        &alice,
+        alice_nonce,
+        "stack-increase",
+        vec![Value::UInt(1)],
+    ));
+    alice_nonce += 1;
+
+    let fail_delegate_too_much_locked = bob_nonce;
+    txs_to_submit.push(make_pox_2_contract_call(
+        &bob,
+        bob_nonce,
+        "delegate-stack-increase",
+        vec![
+            alice_principal.clone().into(),
+            bob_pox_addr.clone(),
+            Value::UInt(alice_delegation_amount - alice_first_lock_amount + 1),
+        ],
+    ));
+    bob_nonce += 1;
+
+    let fail_invalid_amount = bob_nonce;
+    txs_to_submit.push(make_pox_2_contract_call(
+        &bob,
+        bob_nonce,
+        "delegate-stack-increase",
+        vec![
+            alice_principal.clone().into(),
+            bob_pox_addr.clone(),
+            Value::UInt(0),
+        ],
+    ));
+    bob_nonce += 1;
+
+    let fail_insufficient_funds = bob_nonce;
+    txs_to_submit.push(make_pox_2_contract_call(
+        &bob,
+        bob_nonce,
+        "delegate-stack-increase",
+        vec![
+            alice_principal.clone().into(),
+            bob_pox_addr.clone(),
+            Value::UInt(alice_bal.amount_unlocked() + 1),
+        ],
+    ));
+    bob_nonce += 1;
+
+    txs_to_submit.push(make_pox_2_contract_call(
+        &bob,
+        bob_nonce,
+        "delegate-stack-increase",
+        vec![
+            alice_principal.clone().into(),
+            bob_pox_addr.clone(),
+            Value::UInt(alice_delegation_amount - alice_first_lock_amount),
+        ],
+    ));
+    let bob_delegate_increase_pox_2_nonce = bob_nonce;
+    bob_nonce += 1;
+
+    latest_block = peer.tenure_with_txs(&txs_to_submit, &mut coinbase_nonce);
+
+    let alice_bal = get_stx_account_at(&mut peer, &latest_block, &alice_principal);
+    assert_eq!(alice_bal.amount_locked(), alice_delegation_amount);
+    assert_eq!(alice_bal.unlock_height(), expected_pox_2_unlock_ht);
+
+    // check that the partial stacking state contains entries for bob and they've incremented correctly
+    for cycle_number in (EXPECTED_FIRST_V2_CYCLE)..(EXPECTED_FIRST_V2_CYCLE + 2) {
+        let partial_stacked = get_partial_stacked(
+            &mut peer,
+            &latest_block,
+            &bob_pox_addr,
+            cycle_number,
+            &bob_principal,
+            POX_2_NAME,
+        );
+        assert_eq!(partial_stacked, alice_first_lock_amount);
+    }
+
+    for cycle_number in (EXPECTED_FIRST_V2_CYCLE + 2)..(EXPECTED_FIRST_V2_CYCLE + 6) {
+        let partial_stacked = get_partial_stacked(
+            &mut peer,
+            &latest_block,
+            &bob_pox_addr,
+            cycle_number,
+            &bob_principal,
+            POX_2_NAME,
+        );
+        assert_eq!(partial_stacked, alice_delegation_amount,);
+    }
+
+    // okay, now let's progress through epochs 2.2-2.4, and perform the delegation tests
+    //  on pox-3
+
+    // roll the chain forward until just before Epoch-2.2
+    while get_tip(peer.sortdb.as_ref()).block_height < epochs[4].start_height {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+        // at this point, alice's balance should always include this half lockup
+        assert_eq!(
+            get_stx_account_at(&mut peer, &latest_block, &alice_principal).amount_locked(),
+            alice_delegation_amount
+        );
+        assert_eq!(
+            get_stx_account_at(&mut peer, &latest_block, &bob_principal).amount_locked(),
+            0,
+        );
+    }
+
+    // this block is mined in epoch-2.2
+    latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    assert_eq!(
+        get_stx_account_at(&mut peer, &latest_block, &alice_principal).amount_locked(),
+        alice_delegation_amount
+    );
+    assert_eq!(
+        get_stx_account_at(&mut peer, &latest_block, &bob_principal).amount_locked(),
+        0,
+    );
+    // this block should unlock alice's balance
+    latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    assert_eq!(
+        get_stx_account_at(&mut peer, &latest_block, &alice_principal).amount_locked(),
+        0,
+    );
+    assert_eq!(
+        get_stx_account_at(&mut peer, &latest_block, &bob_principal).amount_locked(),
+        0,
+    );
+    assert_eq!(
+        get_stx_account_at(&mut peer, &latest_block, &alice_principal).amount_unlocked(),
+        1024 * POX_THRESHOLD_STEPS_USTX
+    );
+    assert_eq!(
+        get_stx_account_at(&mut peer, &latest_block, &bob_principal).amount_unlocked(),
+        1024 * POX_THRESHOLD_STEPS_USTX
+    );
+
+    // Roll to Epoch-2.4 and re-do the above tests
+    while get_tip(peer.sortdb.as_ref()).block_height <= epochs[6].start_height {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    }
+
+    let tip = get_tip(peer.sortdb.as_ref());
+
+    // submit delegation tx
+    let alice_delegation_1 = make_pox_3_contract_call(
+        &alice,
+        alice_nonce,
+        "delegate-stx",
+        vec![
+            Value::UInt(alice_delegation_amount),
+            bob_principal.clone().into(),
+            Value::none(),
+            Value::none(),
+        ],
+    );
+    let alice_delegation_pox_3_nonce = alice_nonce;
+    alice_nonce += 1;
+
+    let delegate_stack_tx = make_pox_3_contract_call(
+        &bob,
+        bob_nonce,
+        "delegate-stack-stx",
+        vec![
+            alice_principal.clone().into(),
+            Value::UInt(alice_first_lock_amount),
+            bob_pox_addr.clone(),
+            Value::UInt(tip.block_height as u128),
+            Value::UInt(6),
+        ],
+    );
+
+    bob_nonce += 1;
+
+    latest_block = peer.tenure_with_txs(
+        &[alice_delegation_1, delegate_stack_tx],
+        &mut coinbase_nonce,
+    );
+
+    let expected_pox_3_unlock_ht = burnchain.reward_cycle_to_block_height(first_v3_cycle + 6) - 1;
+    let alice_bal = get_stx_account_at(&mut peer, &latest_block, &alice_principal);
+    assert_eq!(alice_bal.amount_locked(), alice_first_lock_amount);
+    assert_eq!(alice_bal.unlock_height(), expected_pox_3_unlock_ht);
+
+    // check that the partial stacking state contains entries for bob
+    for cycle_number in first_v3_cycle..(first_v3_cycle + 6) {
+        let partial_stacked = get_partial_stacked(
+            &mut peer,
+            &latest_block,
+            &bob_pox_addr,
+            cycle_number,
+            &bob_principal,
+            POX_3_NAME,
+        );
+        assert_eq!(partial_stacked, 512 * POX_THRESHOLD_STEPS_USTX);
+    }
+
+    // we'll produce blocks until the 3rd reward cycle gets through the "handled start" code
+    //  this is one block after the reward cycle starts
+    let height_target = burnchain.reward_cycle_to_block_height(first_v3_cycle + 3) + 1;
+
+    while get_tip(peer.sortdb.as_ref()).block_height < height_target {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    }
+
+    let alice_bal = get_stx_account_at(&mut peer, &latest_block, &alice_principal);
+    assert_eq!(alice_bal.amount_locked(), alice_first_lock_amount);
+    let bob_bal = get_stx_account_at(&mut peer, &latest_block, &bob_principal);
+    assert_eq!(bob_bal.amount_locked(), 0);
+
+    // check that the partial stacking state contains entries for bob
+    for cycle_number in first_v3_cycle..(first_v3_cycle + 6) {
+        let partial_stacked = get_partial_stacked(
+            &mut peer,
+            &latest_block,
+            &bob_pox_addr,
+            cycle_number,
+            &bob_principal,
+            POX_3_NAME,
+        );
+        assert_eq!(partial_stacked, 512 * POX_THRESHOLD_STEPS_USTX);
+    }
+
+    let mut txs_to_submit = vec![];
+
+    let pox_3_fail_direct_increase_delegation = alice_nonce;
+    txs_to_submit.push(make_pox_3_contract_call(
+        &alice,
+        alice_nonce,
+        "stack-increase",
+        vec![Value::UInt(1)],
+    ));
+    alice_nonce += 1;
+
+    let pox_3_fail_delegate_too_much_locked = bob_nonce;
+    txs_to_submit.push(make_pox_3_contract_call(
+        &bob,
+        bob_nonce,
+        "delegate-stack-increase",
+        vec![
+            alice_principal.clone().into(),
+            bob_pox_addr.clone(),
+            Value::UInt(alice_delegation_amount - alice_first_lock_amount + 1),
+        ],
+    ));
+    bob_nonce += 1;
+
+    let pox_3_fail_invalid_amount = bob_nonce;
+    txs_to_submit.push(make_pox_3_contract_call(
+        &bob,
+        bob_nonce,
+        "delegate-stack-increase",
+        vec![
+            alice_principal.clone().into(),
+            bob_pox_addr.clone(),
+            Value::UInt(0),
+        ],
+    ));
+    bob_nonce += 1;
+
+    let pox_3_fail_insufficient_funds = bob_nonce;
+    txs_to_submit.push(make_pox_3_contract_call(
+        &bob,
+        bob_nonce,
+        "delegate-stack-increase",
+        vec![
+            alice_principal.clone().into(),
+            bob_pox_addr.clone(),
+            Value::UInt(alice_bal.amount_unlocked() + 1),
+        ],
+    ));
+    bob_nonce += 1;
+
+    txs_to_submit.push(make_pox_3_contract_call(
+        &bob,
+        bob_nonce,
+        "delegate-stack-increase",
+        vec![
+            alice_principal.clone().into(),
+            bob_pox_addr.clone(),
+            Value::UInt(alice_delegation_amount - alice_first_lock_amount),
+        ],
+    ));
+    let bob_delegate_increase_pox_3_nonce = bob_nonce;
+    bob_nonce += 1;
+
+    latest_block = peer.tenure_with_txs(&txs_to_submit, &mut coinbase_nonce);
+
+    assert_eq!(
+        get_stx_account_at(&mut peer, &latest_block, &alice_principal).amount_locked(),
+        alice_delegation_amount
+    );
+
+    assert_eq!(
+        get_stx_account_at(&mut peer, &latest_block, &alice_principal).unlock_height(),
+        expected_pox_3_unlock_ht,
+    );
+
+    // check that the partial stacking state contains entries for bob and they've incremented correctly
+    for cycle_number in first_v3_cycle..(first_v3_cycle + 4) {
+        let partial_stacked = get_partial_stacked(
+            &mut peer,
+            &latest_block,
+            &bob_pox_addr,
+            cycle_number,
+            &bob_principal,
+            POX_3_NAME,
+        );
+        assert_eq!(
+            partial_stacked,
+            alice_first_lock_amount,
+            "Unexpected partially stacked amount in cycle: {} = {} + {}",
+            cycle_number,
+            first_v3_cycle,
+            first_v3_cycle - cycle_number,
+        );
+    }
+
+    for cycle_number in (first_v3_cycle + 4)..(first_v3_cycle + 6) {
+        let partial_stacked = get_partial_stacked(
+            &mut peer,
+            &latest_block,
+            &bob_pox_addr,
+            cycle_number,
+            &bob_principal,
+            POX_3_NAME,
+        );
+        assert_eq!(partial_stacked, alice_delegation_amount);
+    }
+
+    // now let's check some tx receipts
+
+    let alice_address = key_to_stacks_addr(&alice);
+    let blocks = observer.get_blocks();
+
+    let mut alice_txs = HashMap::new();
+    let mut bob_txs = HashMap::new();
+
+    for b in blocks.into_iter() {
+        for r in b.receipts.into_iter() {
+            if let TransactionOrigin::Stacks(ref t) = r.transaction {
+                let addr = t.auth.origin().address_testnet();
+                if addr == alice_address {
+                    alice_txs.insert(t.auth.get_origin_nonce(), r);
+                } else if addr == bob_address {
+                    bob_txs.insert(t.auth.get_origin_nonce(), r);
+                }
+            }
+        }
+    }
+
+    assert_eq!(alice_txs.len() as u64, 4);
+    assert_eq!(bob_txs.len() as u64, 10);
+
+    // transaction should fail because Alice cannot increase her own stacking amount while delegating
+    assert_eq!(
+        &alice_txs[&fail_direct_increase_delegation]
+            .result
+            .to_string(),
+        "(err 20)"
+    );
+
+    // transaction should fail because Alice did not delegate enough funds to Bob
+    assert_eq!(
+        &bob_txs[&fail_delegate_too_much_locked].result.to_string(),
+        "(err 22)"
+    );
+
+    // transaction should fail because Alice doesn't have enough funds
+    assert_eq!(
+        &bob_txs[&fail_insufficient_funds].result.to_string(),
+        "(err 1)"
+    );
+
+    // transaction should fail because the amount supplied is invalid (i.e., 0)
+    assert_eq!(
+        &bob_txs[&fail_invalid_amount].result.to_string(),
+        "(err 18)"
+    );
+
+    assert_eq!(
+        &alice_txs[&pox_3_fail_direct_increase_delegation]
+            .result
+            .to_string(),
+        "(err 30)"
+    );
+
+    // transaction should fail because Alice did not delegate enough funds to Bob
+    assert_eq!(
+        &bob_txs[&pox_3_fail_delegate_too_much_locked]
+            .result
+            .to_string(),
+        "(err 22)"
+    );
+
+    // transaction should fail because Alice doesn't have enough funds
+    assert_eq!(
+        &bob_txs[&pox_3_fail_insufficient_funds].result.to_string(),
+        "(err 1)"
+    );
+
+    // transaction should fail because the amount supplied is invalid (i.e., 0)
+    assert_eq!(
+        &bob_txs[&pox_3_fail_invalid_amount].result.to_string(),
+        "(err 18)"
+    );
+
+    for delegation_nonce in [alice_delegation_pox_2_nonce, alice_delegation_pox_3_nonce] {
+        let delegate_stx_tx = &alice_txs.get(&delegation_nonce).unwrap().clone().events[0];
+        let delegate_stx_op_data = HashMap::from([
+            ("pox-addr", Value::none()),
+            ("amount-ustx", Value::UInt(10230000000000)),
+            ("unlock-burn-height", Value::none()),
+            (
+                "delegate-to",
+                Value::Principal(
+                    StacksAddress::from_string("ST1GCB6NH3XR67VT4R5PKVJ2PYXNVQ4AYQATXNP4P")
+                        .unwrap()
+                        .to_account_principal(),
+                ),
+            ),
+        ]);
+        let common_data = PoxPrintFields {
+            op_name: "delegate-stx".to_string(),
+            stacker: Value::Principal(
+                StacksAddress::from_string("ST2Q1B4S2DY2Y96KYNZTVCCZZD1V9AGWCS5MFXM4C")
+                    .unwrap()
+                    .to_account_principal(),
+            ),
+            balance: Value::UInt(10240000000000),
+            locked: Value::UInt(0),
+            burnchain_unlock_height: Value::UInt(0),
+        };
+        check_pox_print_event(delegate_stx_tx, common_data, delegate_stx_op_data);
+    }
+
+    // Check that the call to `delegate-stack-increase` has a well-formed print event.
+    for (unlock_height, del_increase_nonce) in [
+        (expected_pox_2_unlock_ht, bob_delegate_increase_pox_2_nonce),
+        (expected_pox_3_unlock_ht, bob_delegate_increase_pox_3_nonce),
+    ] {
+        let delegate_stack_increase_tx =
+            &bob_txs.get(&del_increase_nonce).unwrap().clone().events[0];
+        let pox_addr_val = generate_pox_clarity_value("60c59ab11f7063ef44c16d3dc856f76bbb915eba");
+        let delegate_op_data = HashMap::from([
+            ("pox-addr", pox_addr_val),
+            ("increase-by", Value::UInt(5110000000000)),
+            ("total-locked", Value::UInt(10230000000000)),
+            (
+                "delegator",
+                Value::Principal(
+                    StacksAddress::from_string("ST1GCB6NH3XR67VT4R5PKVJ2PYXNVQ4AYQATXNP4P")
+                        .unwrap()
+                        .to_account_principal(),
+                ),
+            ),
+        ]);
+        let common_data = PoxPrintFields {
+            op_name: "delegate-stack-increase".to_string(),
+            stacker: Value::Principal(
+                StacksAddress::from_string("ST2Q1B4S2DY2Y96KYNZTVCCZZD1V9AGWCS5MFXM4C")
+                    .unwrap()
+                    .to_account_principal(),
+            ),
+            balance: Value::UInt(5120000000000),
+            locked: Value::UInt(5120000000000),
+            burnchain_unlock_height: Value::UInt(unlock_height.into()),
+        };
+        check_pox_print_event(delegate_stack_increase_tx, common_data, delegate_op_data);
+    }
+}
+
+#[test]
+fn stack_increase() {
+    let EXPECTED_FIRST_V2_CYCLE = 8;
+    // the sim environment produces 25 empty sortitions before
+    //  tenures start being tracked.
+    let EMPTY_SORTITIONS = 25;
+
+    let (epochs, pox_constants) = make_test_epochs_pox();
+
+    let mut burnchain = Burnchain::default_unittest(
+        0,
+        &BurnchainHeaderHash::from_hex(BITCOIN_REGTEST_FIRST_BLOCK_HASH).unwrap(),
+    );
+    burnchain.pox_constants = pox_constants.clone();
+
+    let first_v2_cycle = burnchain
+        .block_height_to_reward_cycle(burnchain.pox_constants.v1_unlock_height as u64)
+        .unwrap()
+        + 1;
+
+    let first_v3_cycle = burnchain
+        .block_height_to_reward_cycle(burnchain.pox_constants.pox_3_activation_height as u64)
+        .unwrap()
+        + 1;
+
+    assert_eq!(first_v2_cycle, EXPECTED_FIRST_V2_CYCLE);
+
+    let observer = TestEventObserver::new();
+
+    let (mut peer, mut keys) = instantiate_pox_peer_with_epoch(
+        &burnchain,
+        function_name!(),
+        Some(epochs.clone()),
+        Some(&observer),
+    );
+
+    peer.config.check_pox_invariants =
+        Some((EXPECTED_FIRST_V2_CYCLE, EXPECTED_FIRST_V2_CYCLE + 10));
+
+    let num_blocks = 35;
+
+    let alice = keys.pop().unwrap();
+    let alice_address = key_to_stacks_addr(&alice);
+    let alice_principal = PrincipalData::from(alice_address.clone());
+    let mut alice_nonce = 0;
+
+    let mut coinbase_nonce = 0;
+
+    let first_lockup_amt = 512 * POX_THRESHOLD_STEPS_USTX;
+    let total_balance = 1024 * POX_THRESHOLD_STEPS_USTX;
+    let increase_amt = total_balance - first_lockup_amt;
+
+    // produce blocks until epoch 2.1
+    while get_tip(peer.sortdb.as_ref()).block_height <= epochs[3].start_height {
+        peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    }
+
+    // in the next tenure, PoX 2 should now exist.
+    let tip = get_tip(peer.sortdb.as_ref());
+
+    // submit an increase: this should fail, because Alice is not yet locked
+    let fail_no_lock_tx = alice_nonce;
+    let alice_increase = make_pox_2_increase(&alice, alice_nonce, increase_amt);
+    alice_nonce += 1;
+
+    let alice_lockup = make_pox_2_lockup(
+        &alice,
+        alice_nonce,
+        first_lockup_amt,
+        PoxAddress::from_legacy(
+            AddressHashMode::SerializeP2PKH,
+            key_to_stacks_addr(&alice).bytes,
+        ),
+        6,
+        tip.block_height,
+    );
+    alice_nonce += 1;
+
+    let mut latest_block =
+        peer.tenure_with_txs(&[alice_increase, alice_lockup], &mut coinbase_nonce);
+
+    let expected_pox_2_unlock_ht =
+        burnchain.reward_cycle_to_block_height(EXPECTED_FIRST_V2_CYCLE + 6) - 1;
+    let alice_bal = get_stx_account_at(&mut peer, &latest_block, &alice_principal);
+    assert_eq!(alice_bal.amount_locked(), first_lockup_amt);
+    assert_eq!(alice_bal.unlock_height(), expected_pox_2_unlock_ht);
+    assert_eq!(alice_bal.get_total_balance(), total_balance,);
+
+    // check that the "raw" reward set will contain entries for alice at the cycle start
+    for cycle_number in EXPECTED_FIRST_V2_CYCLE..first_v3_cycle {
+        let cycle_start = burnchain.reward_cycle_to_block_height(cycle_number);
+        let reward_set_entries = get_reward_set_entries_at(&mut peer, &latest_block, cycle_start);
+        assert_eq!(reward_set_entries.len(), 1);
+        assert_eq!(
+            reward_set_entries[0].reward_address.bytes(),
+            key_to_stacks_addr(&alice).bytes.0.to_vec()
+        );
+        assert_eq!(reward_set_entries[0].amount_stacked, first_lockup_amt,);
+    }
+
+    // we'll produce blocks until the 1st reward cycle gets through the "handled start" code
+    //  this is one block after the reward cycle starts
+    let height_target = burnchain.reward_cycle_to_block_height(EXPECTED_FIRST_V2_CYCLE + 1) + 1;
+
+    while get_tip(peer.sortdb.as_ref()).block_height < height_target {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    }
+
+    // check that the "raw" reward sets for all cycles contains entries for alice
+    for cycle_number in EXPECTED_FIRST_V2_CYCLE..first_v3_cycle {
+        let cycle_start = burnchain.reward_cycle_to_block_height(cycle_number);
+        let reward_set_entries = get_reward_set_entries_at(&mut peer, &latest_block, cycle_start);
+        assert_eq!(reward_set_entries.len(), 1);
+        assert_eq!(
+            reward_set_entries[0].reward_address.bytes(),
+            key_to_stacks_addr(&alice).bytes.0.to_vec()
+        );
+        assert_eq!(reward_set_entries[0].amount_stacked, first_lockup_amt,);
+    }
+
+    let mut txs_to_submit = vec![];
+    let fail_bad_amount = alice_nonce;
+    txs_to_submit.push(make_pox_2_increase(&alice, alice_nonce, 0));
+    alice_nonce += 1;
+
+    // this stack-increase tx should work
+    let pox_2_success_increase = alice_nonce;
+    txs_to_submit.push(make_pox_2_increase(&alice, alice_nonce, increase_amt));
+    alice_nonce += 1;
+
+    // increase by an amount we don't have!
+    let fail_not_enough_funds = alice_nonce;
+    txs_to_submit.push(make_pox_2_increase(&alice, alice_nonce, 1));
+    alice_nonce += 1;
+
+    latest_block = peer.tenure_with_txs(&txs_to_submit, &mut coinbase_nonce);
+
+    let alice_bal = get_stx_account_at(&mut peer, &latest_block, &alice_principal);
+    assert_eq!(alice_bal.amount_locked(), first_lockup_amt + increase_amt,);
+    assert_eq!(alice_bal.unlock_height(), expected_pox_2_unlock_ht);
+    assert_eq!(alice_bal.get_total_balance(), total_balance,);
+
+    // check that the total reward cycle amounts have incremented correctly
+    for cycle_number in first_v2_cycle..(first_v2_cycle + 2) {
+        assert_eq!(
+            get_reward_cycle_total(&mut peer, &latest_block, cycle_number),
+            first_lockup_amt,
+        );
+        let cycle_start = burnchain.reward_cycle_to_block_height(cycle_number);
+        let reward_set_entries = get_reward_set_entries_at(&mut peer, &latest_block, cycle_start);
+        assert_eq!(reward_set_entries.len(), 1);
+        assert_eq!(
+            reward_set_entries[0].reward_address.bytes(),
+            key_to_stacks_addr(&alice).bytes.0.to_vec()
+        );
+        assert_eq!(reward_set_entries[0].amount_stacked, first_lockup_amt,);
+    }
+
+    assert!(
+        first_v2_cycle + 2 < first_v3_cycle,
+        "Make sure that we can actually test a stack-increase in pox-2 before pox-3 activates"
+    );
+
+    for cycle_number in (first_v2_cycle + 2)..first_v3_cycle {
+        assert_eq!(
+            get_reward_cycle_total(&mut peer, &latest_block, cycle_number),
+            first_lockup_amt + increase_amt,
+        );
+        let cycle_start = burnchain.reward_cycle_to_block_height(cycle_number);
+        let reward_set_entries = get_reward_set_entries_at(&mut peer, &latest_block, cycle_start);
+        assert_eq!(reward_set_entries.len(), 1);
+        assert_eq!(
+            reward_set_entries[0].reward_address.bytes(),
+            key_to_stacks_addr(&alice).bytes.0.to_vec()
+        );
+        assert_eq!(
+            reward_set_entries[0].amount_stacked,
+            first_lockup_amt + increase_amt,
+        );
+    }
+
+    // Roll to Epoch-2.4 and re-do the above tests
+    // okay, now let's progress through epochs 2.2-2.4, and perform the delegation tests
+    //  on pox-3
+
+    // roll the chain forward until just before Epoch-2.2
+    while get_tip(peer.sortdb.as_ref()).block_height < epochs[4].start_height {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+        // at this point, alice's balance should always include this half lockup
+        assert_eq!(
+            get_stx_account_at(&mut peer, &latest_block, &alice_principal).amount_locked(),
+            first_lockup_amt + increase_amt,
+        );
+    }
+
+    // this block is mined in epoch-2.2
+    latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    assert_eq!(
+        get_stx_account_at(&mut peer, &latest_block, &alice_principal).amount_locked(),
+        first_lockup_amt + increase_amt,
+    );
+
+    // this block should unlock alice's balance
+
+    latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    assert_eq!(
+        get_stx_account_at(&mut peer, &latest_block, &alice_principal).amount_locked(),
+        0,
+    );
+    assert_eq!(
+        get_stx_account_at(&mut peer, &latest_block, &alice_principal).amount_unlocked(),
+        total_balance,
+    );
+
+    // Roll to Epoch-2.4 and re-do the above stack-increase tests
+    while get_tip(peer.sortdb.as_ref()).block_height <= epochs[6].start_height {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    }
+
+    // in the next tenure, PoX 3 should now exist.
+    let tip = get_tip(peer.sortdb.as_ref());
+
+    // submit an increase: this should fail, because Alice is not yet locked
+    let pox_3_fail_no_lock_tx = alice_nonce;
+    let alice_increase = make_pox_3_contract_call(
+        &alice,
+        alice_nonce,
+        "stack-increase",
+        vec![Value::UInt(increase_amt)],
+    );
+    alice_nonce += 1;
+
+    let alice_lockup = make_pox_3_lockup(
+        &alice,
+        alice_nonce,
+        first_lockup_amt,
+        PoxAddress::from_legacy(
+            AddressHashMode::SerializeP2PKH,
+            key_to_stacks_addr(&alice).bytes,
+        ),
+        6,
+        tip.block_height,
+    );
+    alice_nonce += 1;
+
+    let mut latest_block =
+        peer.tenure_with_txs(&[alice_increase, alice_lockup], &mut coinbase_nonce);
+
+    let expected_pox_3_unlock_ht = burnchain.reward_cycle_to_block_height(first_v3_cycle + 6) - 1;
+    let alice_bal = get_stx_account_at(&mut peer, &latest_block, &alice_principal);
+    assert_eq!(alice_bal.amount_locked(), first_lockup_amt);
+    assert_eq!(alice_bal.unlock_height(), expected_pox_3_unlock_ht);
+    assert_eq!(alice_bal.get_total_balance(), total_balance,);
+
+    // check that the "raw" reward set will contain entries for alice at the cycle start
+    for cycle_number in first_v3_cycle..(first_v3_cycle + 6) {
+        let cycle_start = burnchain.reward_cycle_to_block_height(cycle_number);
+        let reward_set_entries = get_reward_set_entries_at(&mut peer, &latest_block, cycle_start);
+        assert_eq!(reward_set_entries.len(), 1);
+        assert_eq!(
+            reward_set_entries[0].reward_address.bytes(),
+            key_to_stacks_addr(&alice).bytes.0.to_vec()
+        );
+        assert_eq!(reward_set_entries[0].amount_stacked, first_lockup_amt,);
+    }
+
+    // we'll produce blocks until the 3rd reward cycle gets through the "handled start" code
+    //  this is one block after the reward cycle starts
+    let height_target = burnchain.reward_cycle_to_block_height(first_v3_cycle + 3) + 1;
+
+    while get_tip(peer.sortdb.as_ref()).block_height < height_target {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    }
+
+    // check that the "raw" reward set will contain entries for alice at the cycle start
+    for cycle_number in first_v3_cycle..(first_v3_cycle + 6) {
+        let cycle_start = burnchain.reward_cycle_to_block_height(cycle_number);
+        let reward_set_entries = get_reward_set_entries_at(&mut peer, &latest_block, cycle_start);
+        assert_eq!(reward_set_entries.len(), 1);
+        assert_eq!(
+            reward_set_entries[0].reward_address.bytes(),
+            key_to_stacks_addr(&alice).bytes.0.to_vec()
+        );
+        assert_eq!(reward_set_entries[0].amount_stacked, first_lockup_amt,);
+    }
+
+    let mut txs_to_submit = vec![];
+    let pox_3_fail_bad_amount = alice_nonce;
+    let bad_amount_tx =
+        make_pox_3_contract_call(&alice, alice_nonce, "stack-increase", vec![Value::UInt(0)]);
+    txs_to_submit.push(bad_amount_tx);
+    alice_nonce += 1;
+
+    // this stack-increase tx should work
+    let pox_3_success_increase = alice_nonce;
+    let good_amount_tx = make_pox_3_contract_call(
+        &alice,
+        alice_nonce,
+        "stack-increase",
+        vec![Value::UInt(increase_amt)],
+    );
+    txs_to_submit.push(good_amount_tx);
+    alice_nonce += 1;
+
+    // increase by an amount we don't have!
+    let pox_3_fail_not_enough_funds = alice_nonce;
+    let not_enough_tx =
+        make_pox_3_contract_call(&alice, alice_nonce, "stack-increase", vec![Value::UInt(1)]);
+    txs_to_submit.push(not_enough_tx);
+    alice_nonce += 1;
+
+    latest_block = peer.tenure_with_txs(&txs_to_submit, &mut coinbase_nonce);
+
+    let alice_bal = get_stx_account_at(&mut peer, &latest_block, &alice_principal);
+    assert_eq!(alice_bal.amount_locked(), first_lockup_amt + increase_amt,);
+    assert_eq!(alice_bal.unlock_height(), expected_pox_3_unlock_ht);
+    assert_eq!(alice_bal.get_total_balance(), total_balance,);
+
+    // check that the total reward cycle amounts have incremented correctly
+    for cycle_number in first_v3_cycle..(first_v3_cycle + 4) {
+        assert_eq!(
+            get_reward_cycle_total(&mut peer, &latest_block, cycle_number),
+            first_lockup_amt,
+        );
+        let cycle_start = burnchain.reward_cycle_to_block_height(cycle_number);
+        let reward_set_entries = get_reward_set_entries_at(&mut peer, &latest_block, cycle_start);
+        assert_eq!(reward_set_entries.len(), 1);
+        assert_eq!(
+            reward_set_entries[0].reward_address.bytes(),
+            key_to_stacks_addr(&alice).bytes.0.to_vec()
+        );
+        assert_eq!(reward_set_entries[0].amount_stacked, first_lockup_amt,);
+    }
+
+    for cycle_number in (first_v3_cycle + 4)..(first_v3_cycle + 6) {
+        assert_eq!(
+            get_reward_cycle_total(&mut peer, &latest_block, cycle_number),
+            first_lockup_amt + increase_amt,
+        );
+        let cycle_start = burnchain.reward_cycle_to_block_height(cycle_number);
+        let reward_set_entries = get_reward_set_entries_at(&mut peer, &latest_block, cycle_start);
+        assert_eq!(reward_set_entries.len(), 1);
+        assert_eq!(
+            reward_set_entries[0].reward_address.bytes(),
+            key_to_stacks_addr(&alice).bytes.0.to_vec()
+        );
+        assert_eq!(
+            reward_set_entries[0].amount_stacked,
+            first_lockup_amt + increase_amt,
+        );
+    }
+
+    // now let's check some tx receipts
+    let blocks = observer.get_blocks();
+
+    let mut alice_txs = HashMap::new();
+
+    for b in blocks.into_iter() {
+        for r in b.receipts.into_iter() {
+            if let TransactionOrigin::Stacks(ref t) = r.transaction {
+                let addr = t.auth.origin().address_testnet();
+                if addr == alice_address {
+                    alice_txs.insert(t.auth.get_origin_nonce(), r);
+                }
+            }
+        }
+    }
+
+    assert_eq!(alice_txs.len() as u64, alice_nonce);
+
+    // transaction should fail because lock isn't applied
+    assert_eq!(&alice_txs[&fail_no_lock_tx].result.to_string(), "(err 27)");
+
+    // transaction should fail because Alice doesn't have enough funds
+    assert_eq!(
+        &alice_txs[&fail_not_enough_funds].result.to_string(),
+        "(err 1)"
+    );
+
+    // transaction should fail because the amount supplied is invalid (i.e., 0)
+    assert_eq!(&alice_txs[&fail_bad_amount].result.to_string(), "(err 18)");
+
+    // transaction should fail because lock isn't applied
+    assert_eq!(
+        &alice_txs[&pox_3_fail_no_lock_tx].result.to_string(),
+        "(err 27)"
+    );
+
+    // transaction should fail because Alice doesn't have enough funds
+    assert_eq!(
+        &alice_txs[&pox_3_fail_not_enough_funds].result.to_string(),
+        "(err 1)"
+    );
+
+    // transaction should fail because the amount supplied is invalid (i.e., 0)
+    assert_eq!(
+        &alice_txs[&pox_3_fail_bad_amount].result.to_string(),
+        "(err 18)"
+    );
+
+    // Check that the call to `stack-increase` has a well-formed print event.
+    for (increase_nonce, unlock_height) in [
+        (pox_2_success_increase, expected_pox_2_unlock_ht),
+        (pox_3_success_increase, expected_pox_3_unlock_ht),
+    ] {
+        let stack_increase_tx = &alice_txs.get(&increase_nonce).unwrap().clone().events[0];
+        let pox_addr_val = generate_pox_clarity_value("ae1593226f85e49a7eaff5b633ff687695438cc9");
+        let stack_op_data = HashMap::from([
+            ("increase-by", Value::UInt(5120000000000)),
+            ("total-locked", Value::UInt(10240000000000)),
+            ("pox-addr", pox_addr_val),
+        ]);
+        let common_data = PoxPrintFields {
+            op_name: "stack-increase".to_string(),
+            stacker: Value::Principal(
+                StacksAddress::from_string("ST2Q1B4S2DY2Y96KYNZTVCCZZD1V9AGWCS5MFXM4C")
+                    .unwrap()
+                    .to_account_principal(),
+            ),
+            balance: Value::UInt(5120000000000),
+            locked: Value::UInt(5120000000000),
+            burnchain_unlock_height: Value::UInt(unlock_height.into()),
+        };
+        check_pox_print_event(stack_increase_tx, common_data, stack_op_data);
+    }
+}
+
+#[test]
+fn pox_extend_transition() {
+    let EXPECTED_FIRST_V2_CYCLE = 8;
+    // the sim environment produces 25 empty sortitions before
+    //  tenures start being tracked.
+    let EMPTY_SORTITIONS = 25;
+
+    let (epochs, pox_constants) = make_test_epochs_pox();
+
+    let mut burnchain = Burnchain::default_unittest(
+        0,
+        &BurnchainHeaderHash::from_hex(BITCOIN_REGTEST_FIRST_BLOCK_HASH).unwrap(),
+    );
+    burnchain.pox_constants = pox_constants.clone();
+
+    let first_v2_cycle = burnchain
+        .block_height_to_reward_cycle(burnchain.pox_constants.v1_unlock_height as u64)
+        .unwrap()
+        + 1;
+
+    let first_v3_cycle = burnchain
+        .block_height_to_reward_cycle(burnchain.pox_constants.pox_3_activation_height as u64)
+        .unwrap()
+        + 1;
+
+    assert_eq!(first_v2_cycle, EXPECTED_FIRST_V2_CYCLE);
+
+    let observer = TestEventObserver::new();
+
+    let (mut peer, mut keys) = instantiate_pox_peer_with_epoch(
+        &burnchain,
+        function_name!(),
+        Some(epochs.clone()),
+        Some(&observer),
+    );
+
+    peer.config.check_pox_invariants =
+        Some((EXPECTED_FIRST_V2_CYCLE, EXPECTED_FIRST_V2_CYCLE + 10));
+
+    let alice = keys.pop().unwrap();
+    let bob = keys.pop().unwrap();
+    let alice_address = key_to_stacks_addr(&alice);
+    let alice_principal = PrincipalData::from(alice_address.clone());
+    let bob_address = key_to_stacks_addr(&bob);
+    let bob_principal = PrincipalData::from(bob_address.clone());
+
+    let EXPECTED_ALICE_FIRST_REWARD_CYCLE = 6;
+    let mut coinbase_nonce = 0;
+
+    let INITIAL_BALANCE = 1024 * POX_THRESHOLD_STEPS_USTX;
+    let ALICE_LOCKUP = 1024 * POX_THRESHOLD_STEPS_USTX;
+    let BOB_LOCKUP = 512 * POX_THRESHOLD_STEPS_USTX;
+
+    // these checks should pass between Alice's first reward cycle,
+    //  and the start of V2 reward cycles
+    let alice_rewards_to_v2_start_checks = |tip_index_block, peer: &mut TestPeer| {
+        let tip_burn_block_height = get_par_burn_block_height(peer.chainstate(), &tip_index_block);
+        let cur_reward_cycle = burnchain
+            .block_height_to_reward_cycle(tip_burn_block_height)
+            .unwrap() as u128;
+        let (min_ustx, reward_addrs, total_stacked) = with_sortdb(peer, |ref mut c, ref sortdb| {
+            (
+                c.get_stacking_minimum(sortdb, &tip_index_block).unwrap(),
+                get_reward_addresses_with_par_tip(c, &burnchain, sortdb, &tip_index_block).unwrap(),
+                c.test_get_total_ustx_stacked(sortdb, &tip_index_block, cur_reward_cycle)
+                    .unwrap(),
+            )
+        });
+
+        assert!(
+            cur_reward_cycle >= EXPECTED_ALICE_FIRST_REWARD_CYCLE
+                && cur_reward_cycle < first_v2_cycle as u128
+        );
+        //  Alice is the only Stacker, so check that.
+        let (amount_ustx, pox_addr, lock_period, first_reward_cycle) =
+            get_stacker_info(peer, &key_to_stacks_addr(&alice).into()).unwrap();
+        eprintln!(
+            "\nAlice: {} uSTX stacked for {} cycle(s); addr is {:?}; first reward cycle is {}\n",
+            amount_ustx, lock_period, &pox_addr, first_reward_cycle
+        );
+
+        // one reward address, and it's Alice's
+        // either way, there's a single reward address
+        assert_eq!(reward_addrs.len(), 1);
+        assert_eq!(
+            (reward_addrs[0].0).version(),
+            AddressHashMode::SerializeP2PKH as u8
+        );
+        assert_eq!(
+            (reward_addrs[0].0).hash160(),
+            key_to_stacks_addr(&alice).bytes
+        );
+        assert_eq!(reward_addrs[0].1, ALICE_LOCKUP);
+    };
+
+    // these checks should pass after the start of V2 reward cycles
+    let v2_rewards_checks = |tip_index_block, peer: &mut TestPeer| {
+        let tip_burn_block_height = get_par_burn_block_height(peer.chainstate(), &tip_index_block);
+        let cur_reward_cycle = burnchain
+            .block_height_to_reward_cycle(tip_burn_block_height)
+            .unwrap() as u128;
+        let (min_ustx, reward_addrs, total_stacked) = with_sortdb(peer, |ref mut c, ref sortdb| {
+            (
+                c.get_stacking_minimum(sortdb, &tip_index_block).unwrap(),
+                get_reward_addresses_with_par_tip(c, &burnchain, sortdb, &tip_index_block).unwrap(),
+                c.test_get_total_ustx_stacked(sortdb, &tip_index_block, cur_reward_cycle)
+                    .unwrap(),
+            )
+        });
+
+        eprintln!(
+            "reward_cycle = {}, reward_addrs = {}, total_stacked = {}",
+            cur_reward_cycle,
+            reward_addrs.len(),
+            total_stacked
+        );
+
+        assert!(cur_reward_cycle >= first_v2_cycle as u128);
+        // v2 reward cycles have begun, so reward addrs should be read from PoX2 which is Bob + Alice
+        assert_eq!(reward_addrs.len(), 2);
+        assert_eq!(
+            (reward_addrs[0].0).version(),
+            AddressHashMode::SerializeP2PKH as u8
+        );
+        assert_eq!(
+            (reward_addrs[0].0).hash160(),
+            key_to_stacks_addr(&bob).bytes
+        );
+        assert_eq!(reward_addrs[0].1, BOB_LOCKUP);
+
+        assert_eq!(
+            (reward_addrs[1].0).version(),
+            AddressHashMode::SerializeP2PKH as u8
+        );
+        assert_eq!(
+            (reward_addrs[1].0).hash160(),
+            key_to_stacks_addr(&alice).bytes
+        );
+        assert_eq!(reward_addrs[1].1, ALICE_LOCKUP);
+    };
+
+    // first tenure is empty
+    let mut latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+
+    let alice_account = get_account(&mut peer, &key_to_stacks_addr(&alice).into());
+    assert_eq!(alice_account.stx_balance.amount_unlocked(), INITIAL_BALANCE);
+    assert_eq!(alice_account.stx_balance.amount_locked(), 0);
+    assert_eq!(alice_account.stx_balance.unlock_height(), 0);
+
+    // next tenure include Alice's lockup
+    let tip = get_tip(peer.sortdb.as_ref());
+    let alice_lockup = make_pox_lockup(
+        &alice,
+        0,
+        ALICE_LOCKUP,
+        AddressHashMode::SerializeP2PKH,
+        key_to_stacks_addr(&alice).bytes,
+        4,
+        tip.block_height,
+    );
+
+    let tip_index_block = peer.tenure_with_txs(&[alice_lockup], &mut coinbase_nonce);
+
+    // check the stacking minimum
+    let total_liquid_ustx = get_liquid_ustx(&mut peer);
+    let min_ustx = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
+        chainstate.get_stacking_minimum(sortdb, &tip_index_block)
+    })
+    .unwrap();
+    assert_eq!(
+        min_ustx,
+        total_liquid_ustx / POX_TESTNET_STACKING_THRESHOLD_25
+    );
+
+    // no reward addresses
+    let reward_addrs = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
+        get_reward_addresses_with_par_tip(chainstate, &burnchain, sortdb, &tip_index_block)
+    })
+    .unwrap();
+    assert_eq!(reward_addrs.len(), 0);
+
+    // check the first reward cycle when Alice's tokens get stacked
+    let tip_burn_block_height = get_par_burn_block_height(peer.chainstate(), &tip_index_block);
+    let alice_first_reward_cycle = 1 + burnchain
+        .block_height_to_reward_cycle(tip_burn_block_height)
+        .unwrap();
+
+    assert_eq!(
+        alice_first_reward_cycle as u128,
+        EXPECTED_ALICE_FIRST_REWARD_CYCLE
+    );
+    let height_target = burnchain.reward_cycle_to_block_height(alice_first_reward_cycle) + 1;
+
+    // alice locked, so balance should be 0
+    let alice_balance = get_balance(&mut peer, &key_to_stacks_addr(&alice).into());
+    assert_eq!(alice_balance, 0);
+
+    while get_tip(peer.sortdb.as_ref()).block_height < height_target {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    }
+
+    // produce blocks until epoch 2.1
+    while get_tip(peer.sortdb.as_ref()).block_height < epochs[3].start_height {
+        peer.tenure_with_txs(&[], &mut coinbase_nonce);
+        alice_rewards_to_v2_start_checks(latest_block, &mut peer);
+    }
+
+    // in the next tenure, PoX 2 should now exist.
+    // Lets have Bob lock up for v2
+    // this will lock for cycles 8, 9, 10
+    //  the first v2 cycle will be 8
+    let tip = get_tip(peer.sortdb.as_ref());
+
+    let bob_lockup = make_pox_2_lockup(
+        &bob,
+        0,
+        BOB_LOCKUP,
+        PoxAddress::from_legacy(
+            AddressHashMode::SerializeP2PKH,
+            key_to_stacks_addr(&bob).bytes,
+        ),
+        3,
+        tip.block_height,
+    );
+
+    // Alice _will_ auto-unlock: she can stack-extend in PoX v2
+    let alice_lockup = make_pox_2_extend(
+        &alice,
+        1,
+        PoxAddress::from_legacy(
+            AddressHashMode::SerializeP2PKH,
+            key_to_stacks_addr(&alice).bytes,
+        ),
+        6,
+    );
+
+    latest_block = peer.tenure_with_txs(&[bob_lockup, alice_lockup], &mut coinbase_nonce);
+    alice_rewards_to_v2_start_checks(latest_block, &mut peer);
+
+    // Extend bob's lockup via `stack-extend` for 1 more cycle
+    let bob_extend = make_pox_2_extend(
+        &bob,
+        1,
+        PoxAddress::from_legacy(
+            AddressHashMode::SerializeP2PKH,
+            key_to_stacks_addr(&bob).bytes,
+        ),
+        1,
+    );
+
+    latest_block = peer.tenure_with_txs(&[bob_extend], &mut coinbase_nonce);
+
+    alice_rewards_to_v2_start_checks(latest_block, &mut peer);
+
+    // produce blocks until the v2 reward cycles start
+    let height_target = burnchain.reward_cycle_to_block_height(first_v2_cycle) - 1;
+    while get_tip(peer.sortdb.as_ref()).block_height < height_target {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+        // alice is still locked, balance should be 0
+        let alice_balance = get_balance(&mut peer, &key_to_stacks_addr(&alice).into());
+        assert_eq!(alice_balance, 0);
+
+        alice_rewards_to_v2_start_checks(latest_block, &mut peer);
+    }
+
+    latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    v2_rewards_checks(latest_block, &mut peer);
+
+    // Roll to Epoch-2.4 and re-do the above tests
+
+    // roll the chain forward until just before Epoch-2.2
+    while get_tip(peer.sortdb.as_ref()).block_height < epochs[4].start_height {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+        // at this point, alice's balance should be locked, and so should bob's
+        let alice_balance = get_balance(&mut peer, &key_to_stacks_addr(&alice).into());
+        assert_eq!(alice_balance, 0);
+        let bob_balance = get_balance(&mut peer, &key_to_stacks_addr(&bob).into());
+        assert_eq!(bob_balance, 512 * POX_THRESHOLD_STEPS_USTX);
+    }
+
+    // this block is mined in epoch-2.2
+    latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    let alice_balance = get_balance(&mut peer, &key_to_stacks_addr(&alice).into());
+    assert_eq!(alice_balance, 0);
+    let bob_balance = get_balance(&mut peer, &key_to_stacks_addr(&bob).into());
+    assert_eq!(bob_balance, 512 * POX_THRESHOLD_STEPS_USTX);
+
+    // this block should unlock alice and bob's balance
+
+    latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    let alice_account = get_stx_account_at(&mut peer, &latest_block, &alice_principal);
+    let bob_account = get_stx_account_at(&mut peer, &latest_block, &bob_principal);
+    assert_eq!(alice_account.amount_locked(), 0);
+    assert_eq!(alice_account.amount_unlocked(), INITIAL_BALANCE);
+    assert_eq!(bob_account.amount_locked(), 0);
+    assert_eq!(bob_account.amount_unlocked(), INITIAL_BALANCE);
+
+    // Roll to Epoch-2.4 and re-do the above stack-extend tests
+    while get_tip(peer.sortdb.as_ref()).block_height <= epochs[6].start_height {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    }
+
+    let tip = get_tip(peer.sortdb.as_ref());
+    let alice_lockup = make_pox_3_lockup(
+        &alice,
+        2,
+        ALICE_LOCKUP,
+        PoxAddress::from_legacy(
+            AddressHashMode::SerializeP2PKH,
+            key_to_stacks_addr(&alice).bytes,
+        ),
+        4,
+        tip.block_height,
+    );
+    let alice_pox_3_lock_nonce = 2;
+    let alice_first_pox_3_unlock_height =
+        burnchain.reward_cycle_to_block_height(first_v3_cycle + 4) - 1;
+    let alice_pox_3_start_burn_height = tip.block_height;
+
+    latest_block = peer.tenure_with_txs(&[alice_lockup], &mut coinbase_nonce);
+
+    // check that the "raw" reward set will contain entries for alice at the cycle start
+    for cycle_number in first_v3_cycle..(first_v3_cycle + 4) {
+        let cycle_start = burnchain.reward_cycle_to_block_height(cycle_number);
+        let reward_set_entries = get_reward_set_entries_at(&mut peer, &latest_block, cycle_start);
+        assert_eq!(reward_set_entries.len(), 1);
+        assert_eq!(
+            reward_set_entries[0].reward_address.bytes(),
+            key_to_stacks_addr(&alice).bytes.0.to_vec()
+        );
+        assert_eq!(reward_set_entries[0].amount_stacked, ALICE_LOCKUP,);
+    }
+
+    // check the first reward cycle when Alice's tokens get stacked
+    let tip_burn_block_height = get_par_burn_block_height(peer.chainstate(), &latest_block);
+    let alice_first_v3_reward_cycle = 1 + burnchain
+        .block_height_to_reward_cycle(tip_burn_block_height)
+        .unwrap();
+
+    let height_target = burnchain.reward_cycle_to_block_height(alice_first_v3_reward_cycle) + 1;
+
+    // alice locked, so balance should be 0
+    let alice_balance = get_balance(&mut peer, &alice_principal);
+    assert_eq!(alice_balance, 0);
+
+    // advance to the first v3 reward cycle
+    while get_tip(peer.sortdb.as_ref()).block_height < height_target {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    }
+
+    let tip = get_tip(peer.sortdb.as_ref());
+    let bob_lockup = make_pox_3_lockup(
+        &bob,
+        2,
+        BOB_LOCKUP,
+        PoxAddress::from_legacy(
+            AddressHashMode::SerializeP2PKH,
+            key_to_stacks_addr(&bob).bytes,
+        ),
+        3,
+        tip.block_height,
+    );
+
+    // Alice can stack-extend in PoX v2
+    let alice_lockup = make_pox_3_extend(
+        &alice,
+        3,
+        PoxAddress::from_legacy(
+            AddressHashMode::SerializeP2PKH,
+            key_to_stacks_addr(&alice).bytes,
+        ),
+        6,
+    );
+
+    let alice_pox_3_extend_nonce = 3;
+    let alice_extend_pox_3_unlock_height =
+        burnchain.reward_cycle_to_block_height(first_v3_cycle + 10) - 1;
+
+    latest_block = peer.tenure_with_txs(&[bob_lockup, alice_lockup], &mut coinbase_nonce);
+
+    // check that the "raw" reward set will contain entries for alice at the cycle start
+    for cycle_number in first_v3_cycle..(first_v3_cycle + 1) {
+        let cycle_start = burnchain.reward_cycle_to_block_height(cycle_number);
+        let reward_set_entries = get_reward_set_entries_at(&mut peer, &latest_block, cycle_start);
+        assert_eq!(reward_set_entries.len(), 1);
+        assert_eq!(
+            reward_set_entries[0].reward_address.bytes(),
+            key_to_stacks_addr(&alice).bytes.0.to_vec()
+        );
+        assert_eq!(reward_set_entries[0].amount_stacked, ALICE_LOCKUP,);
+    }
+
+    for cycle_number in (first_v3_cycle + 1)..(first_v3_cycle + 4) {
+        let cycle_start = burnchain.reward_cycle_to_block_height(cycle_number);
+        let reward_set_entries = get_reward_set_entries_at(&mut peer, &latest_block, cycle_start);
+        assert_eq!(reward_set_entries.len(), 2);
+        assert_eq!(
+            reward_set_entries[1].reward_address.bytes(),
+            key_to_stacks_addr(&alice).bytes.0.to_vec()
+        );
+        assert_eq!(reward_set_entries[1].amount_stacked, ALICE_LOCKUP,);
+        assert_eq!(
+            reward_set_entries[0].reward_address.bytes(),
+            key_to_stacks_addr(&bob).bytes.0.to_vec()
+        );
+        assert_eq!(reward_set_entries[0].amount_stacked, BOB_LOCKUP,);
+    }
+
+    for cycle_number in (first_v3_cycle + 4)..(first_v3_cycle + 10) {
+        let cycle_start = burnchain.reward_cycle_to_block_height(cycle_number);
+        let reward_set_entries = get_reward_set_entries_at(&mut peer, &latest_block, cycle_start);
+        assert_eq!(reward_set_entries.len(), 1);
+        assert_eq!(
+            reward_set_entries[0].reward_address.bytes(),
+            key_to_stacks_addr(&alice).bytes.0.to_vec()
+        );
+        assert_eq!(reward_set_entries[0].amount_stacked, ALICE_LOCKUP,);
+    }
+
+    // now let's check some tx receipts
+
+    let alice_address = key_to_stacks_addr(&alice);
+    let bob_address = key_to_stacks_addr(&bob);
+    let blocks = observer.get_blocks();
+
+    let mut alice_txs = HashMap::new();
+    let mut bob_txs = HashMap::new();
+
+    for b in blocks.into_iter() {
+        for r in b.receipts.into_iter() {
+            if let TransactionOrigin::Stacks(ref t) = r.transaction {
+                let addr = t.auth.origin().address_testnet();
+                eprintln!("TX addr: {}", addr);
+                if addr == alice_address {
+                    alice_txs.insert(t.auth.get_origin_nonce(), r);
+                } else if addr == bob_address {
+                    bob_txs.insert(t.auth.get_origin_nonce(), r);
+                }
+            }
+        }
+    }
+
+    assert_eq!(alice_txs.len(), 4);
+    assert_eq!(bob_txs.len(), 3);
+
+    for tx in alice_txs.iter() {
+        assert!(
+            if let Value::Response(ref r) = tx.1.result {
+                r.committed
+            } else {
+                false
+            },
+            "Alice txs should all have committed okay"
+        );
+    }
+
+    for tx in bob_txs.iter() {
+        assert!(
+            if let Value::Response(ref r) = tx.1.result {
+                r.committed
+            } else {
+                false
+            },
+            "Bob txs should all have committed okay"
+        );
+    }
+
+    // Check that the call to `stack-stx` has a well-formed print event.
+    let stack_tx = &alice_txs
+        .get(&alice_pox_3_lock_nonce)
+        .unwrap()
+        .clone()
+        .events[0];
+    let pox_addr_val = generate_pox_clarity_value("ae1593226f85e49a7eaff5b633ff687695438cc9");
+    let stack_op_data = HashMap::from([
+        ("lock-amount", Value::UInt(ALICE_LOCKUP)),
+        (
+            "unlock-burn-height",
+            Value::UInt(alice_first_pox_3_unlock_height.into()),
+        ),
+        (
+            "start-burn-height",
+            Value::UInt(alice_pox_3_start_burn_height.into()),
+        ),
+        ("pox-addr", pox_addr_val.clone()),
+        ("lock-period", Value::UInt(4)),
+    ]);
+    let common_data = PoxPrintFields {
+        op_name: "stack-stx".to_string(),
+        stacker: Value::Principal(alice_principal.clone()),
+        balance: Value::UInt(10240000000000),
+        locked: Value::UInt(0),
+        burnchain_unlock_height: Value::UInt(0),
+    };
+    check_pox_print_event(stack_tx, common_data, stack_op_data);
+
+    // Check that the call to `stack-extend` has a well-formed print event.
+    let stack_extend_tx = &alice_txs
+        .get(&alice_pox_3_extend_nonce)
+        .unwrap()
+        .clone()
+        .events[0];
+    let stack_ext_op_data = HashMap::from([
+        ("extend-count", Value::UInt(6)),
+        ("pox-addr", pox_addr_val),
+        (
+            "unlock-burn-height",
+            Value::UInt(alice_extend_pox_3_unlock_height.into()),
+        ),
+    ]);
+    let common_data = PoxPrintFields {
+        op_name: "stack-extend".to_string(),
+        stacker: Value::Principal(alice_principal.clone()),
+        balance: Value::UInt(0),
+        locked: Value::UInt(ALICE_LOCKUP),
+        burnchain_unlock_height: Value::UInt(alice_first_pox_3_unlock_height.into()),
+    };
+    check_pox_print_event(stack_extend_tx, common_data, stack_ext_op_data);
+}
+
+#[test]
+fn delegate_extend_pox_3() {
+    // the sim environment produces 25 empty sortitions before
+    //  tenures start being tracked.
+    let EMPTY_SORTITIONS = 25;
+
+    let (epochs, pox_constants) = make_test_epochs_pox();
+
+    let mut burnchain = Burnchain::default_unittest(
+        0,
+        &BurnchainHeaderHash::from_hex(BITCOIN_REGTEST_FIRST_BLOCK_HASH).unwrap(),
+    );
+    burnchain.pox_constants = pox_constants.clone();
+
+    let first_v3_cycle = burnchain
+        .block_height_to_reward_cycle(burnchain.pox_constants.pox_3_activation_height as u64)
+        .unwrap()
+        + 1;
+
+    let observer = TestEventObserver::new();
+
+    let (mut peer, mut keys) = instantiate_pox_peer_with_epoch(
+        &burnchain,
+        function_name!(),
+        Some(epochs.clone()),
+        Some(&observer),
+    );
+
+    peer.config.check_pox_invariants = Some((first_v3_cycle, first_v3_cycle + 10));
+
+    let alice = keys.pop().unwrap();
+    let bob = keys.pop().unwrap();
+    let charlie = keys.pop().unwrap();
+
+    let alice_address = key_to_stacks_addr(&alice);
+    let bob_address = key_to_stacks_addr(&bob);
+    let charlie_address = key_to_stacks_addr(&charlie);
+
+    let mut coinbase_nonce = 0;
+
+    let INITIAL_BALANCE = 1024 * POX_THRESHOLD_STEPS_USTX;
+    let LOCKUP_AMT = 1024 * POX_THRESHOLD_STEPS_USTX;
+
+    // our "tenure counter" is now at 0
+    let tip = get_tip(peer.sortdb.as_ref());
+    assert_eq!(tip.block_height, 0 + EMPTY_SORTITIONS as u64);
+
+    // first tenure is empty
+    let mut latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+
+    // Roll to Epoch-2.4 and perform the delegate-stack-extend tests
+    while get_tip(peer.sortdb.as_ref()).block_height <= epochs[6].start_height {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    }
+
+    // in the next tenure, PoX 3 should now exist.
+    //  charlie will lock bob and alice through the delegation interface
+    let tip = get_tip(peer.sortdb.as_ref());
+
+    let mut alice_nonce = 0;
+    let mut bob_nonce = 0;
+    let mut charlie_nonce = 0;
+
+    let bob_delegate_tx = make_pox_3_contract_call(
+        &bob,
+        bob_nonce,
+        "delegate-stx",
+        vec![
+            Value::UInt(2048 * POX_THRESHOLD_STEPS_USTX),
+            PrincipalData::from(charlie_address.clone()).into(),
+            Value::none(),
+            Value::none(),
+        ],
+    );
+    bob_nonce += 1;
+
+    let alice_delegate_tx = make_pox_3_contract_call(
+        &alice,
+        alice_nonce,
+        "delegate-stx",
+        vec![
+            Value::UInt(2048 * POX_THRESHOLD_STEPS_USTX),
+            PrincipalData::from(charlie_address.clone()).into(),
+            Value::none(),
+            Value::none(),
+        ],
+    );
+    alice_nonce += 1;
+
+    let delegate_stack_tx = make_pox_3_contract_call(
+        &charlie,
+        charlie_nonce,
+        "delegate-stack-stx",
+        vec![
+            PrincipalData::from(bob_address.clone()).into(),
+            Value::UInt(LOCKUP_AMT),
+            make_pox_addr(
+                AddressHashMode::SerializeP2PKH,
+                charlie_address.bytes.clone(),
+            ),
+            Value::UInt(tip.block_height as u128),
+            Value::UInt(3),
+        ],
+    );
+    let delegate_stack_stx_nonce = charlie_nonce;
+    let delegate_stack_stx_unlock_ht =
+        burnchain.reward_cycle_to_block_height(first_v3_cycle + 3) - 1;
+    let delegate_stack_stx_lock_ht = tip.block_height;
+    charlie_nonce += 1;
+
+    let delegate_alice_stack_tx = make_pox_3_contract_call(
+        &charlie,
+        charlie_nonce,
+        "delegate-stack-stx",
+        vec![
+            PrincipalData::from(alice_address.clone()).into(),
+            Value::UInt(LOCKUP_AMT),
+            make_pox_addr(
+                AddressHashMode::SerializeP2PKH,
+                charlie_address.bytes.clone(),
+            ),
+            Value::UInt(tip.block_height as u128),
+            Value::UInt(6),
+        ],
+    );
+    charlie_nonce += 1;
+
+    // Charlie agg commits the first 3 cycles, but wait until delegate-extended bob to
+    //   agg commit the 4th cycle
+    // aggregate commit to each cycle delegate-stack-stx locked for (cycles 6, 7, 8, 9)
+    let agg_commit_txs = [0, 1, 2].map(|ix| {
+        let tx = make_pox_3_contract_call(
+            &charlie,
+            charlie_nonce,
+            "stack-aggregation-commit",
+            vec![
+                make_pox_addr(
+                    AddressHashMode::SerializeP2PKH,
+                    charlie_address.bytes.clone(),
+                ),
+                Value::UInt(first_v3_cycle as u128 + ix),
+            ],
+        );
+        charlie_nonce += 1;
+        tx
+    });
+    let mut txs = vec![
+        bob_delegate_tx,
+        alice_delegate_tx,
+        delegate_stack_tx,
+        delegate_alice_stack_tx,
+    ];
+
+    txs.extend(agg_commit_txs);
+
+    latest_block = peer.tenure_with_txs(txs.as_slice(), &mut coinbase_nonce);
+
+    for cycle_number in first_v3_cycle..(first_v3_cycle + 3) {
+        let cycle_start = burnchain.reward_cycle_to_block_height(cycle_number);
+        let reward_set_entries = get_reward_set_entries_at(&mut peer, &latest_block, cycle_start);
+        assert_eq!(reward_set_entries.len(), 1);
+        assert_eq!(
+            reward_set_entries[0].reward_address.bytes(),
+            key_to_stacks_addr(&charlie).bytes.0.to_vec()
+        );
+        assert_eq!(reward_set_entries[0].amount_stacked, 2 * LOCKUP_AMT);
+    }
+
+    for cycle_number in (first_v3_cycle + 3)..(first_v3_cycle + 6) {
+        let cycle_start = burnchain.reward_cycle_to_block_height(cycle_number);
+        let reward_set_entries = get_reward_set_entries_at(&mut peer, &latest_block, cycle_start);
+        assert_eq!(reward_set_entries.len(), 0);
+    }
+
+    let alice_principal = alice_address.clone().into();
+    let bob_principal = bob_address.clone().into();
+    let charlie_principal: PrincipalData = charlie_address.clone().into();
+
+    let StackingStateCheckData {
+        first_cycle: alice_first_cycle,
+        lock_period: alice_lock_period,
+        ..
+    } = check_stacking_state_invariants(
+        &mut peer,
+        &latest_block,
+        &alice_principal,
+        false,
+        POX_3_NAME,
+    );
+    let StackingStateCheckData {
+        first_cycle: bob_first_cycle,
+        lock_period: bob_lock_period,
+        ..
+    } = check_stacking_state_invariants(
+        &mut peer,
+        &latest_block,
+        &bob_principal,
+        false,
+        POX_3_NAME,
+    );
+
+    assert_eq!(
+        alice_first_cycle as u64, first_v3_cycle,
+        "Alice's first cycle in PoX-3 stacking state is the next cycle, which is 12"
+    );
+    assert_eq!(alice_lock_period, 6);
+    assert_eq!(
+        bob_first_cycle as u64, first_v3_cycle,
+        "Bob's first cycle in PoX-3 stacking state is the next cycle, which is 12"
+    );
+    assert_eq!(bob_lock_period, 3);
+
+    // Extend bob's lockup via `delegate-stack-extend` for 1 more cycle
+    let delegate_extend_tx = make_pox_3_contract_call(
+        &charlie,
+        charlie_nonce,
+        "delegate-stack-extend",
+        vec![
+            PrincipalData::from(bob_address.clone()).into(),
+            make_pox_addr(
+                AddressHashMode::SerializeP2PKH,
+                charlie_address.bytes.clone(),
+            ),
+            Value::UInt(1),
+        ],
+    );
+    let delegate_stack_extend_nonce = charlie_nonce;
+    let delegate_stack_extend_unlock_ht =
+        burnchain.reward_cycle_to_block_height(first_v3_cycle + 4) - 1;
+    charlie_nonce += 1;
+
+    let agg_commit_tx = make_pox_3_contract_call(
+        &charlie,
+        charlie_nonce,
+        "stack-aggregation-commit",
+        vec![
+            make_pox_addr(
+                AddressHashMode::SerializeP2PKH,
+                charlie_address.bytes.clone(),
+            ),
+            Value::UInt(first_v3_cycle as u128 + 3),
+        ],
+    );
+    let stack_agg_nonce = charlie_nonce;
+    let stack_agg_cycle = first_v3_cycle + 3;
+    let delegate_stack_extend_unlock_ht =
+        burnchain.reward_cycle_to_block_height(first_v3_cycle + 4) - 1;
+    charlie_nonce += 1;
+
+    latest_block = peer.tenure_with_txs(&[delegate_extend_tx, agg_commit_tx], &mut coinbase_nonce);
+    let StackingStateCheckData {
+        first_cycle: alice_first_cycle,
+        lock_period: alice_lock_period,
+        ..
+    } = check_stacking_state_invariants(
+        &mut peer,
+        &latest_block,
+        &alice_principal,
+        false,
+        POX_3_NAME,
+    );
+    let StackingStateCheckData {
+        first_cycle: bob_first_cycle,
+        lock_period: bob_lock_period,
+        ..
+    } = check_stacking_state_invariants(
+        &mut peer,
+        &latest_block,
+        &bob_principal,
+        false,
+        POX_3_NAME,
+    );
+
+    assert_eq!(
+        alice_first_cycle as u64, first_v3_cycle,
+        "Alice's first cycle in PoX-2 stacking state is the next cycle, which is 8"
+    );
+    assert_eq!(alice_lock_period, 6);
+    assert_eq!(
+        bob_first_cycle as u64, first_v3_cycle,
+        "Bob's first cycle in PoX-2 stacking state is the next cycle, which is 8"
+    );
+    assert_eq!(bob_lock_period, 4);
+
+    for cycle_number in first_v3_cycle..(first_v3_cycle + 4) {
+        let cycle_start = burnchain.reward_cycle_to_block_height(cycle_number);
+        let reward_set_entries = get_reward_set_entries_at(&mut peer, &latest_block, cycle_start);
+        assert_eq!(reward_set_entries.len(), 1);
+        assert_eq!(
+            reward_set_entries[0].reward_address.bytes(),
+            key_to_stacks_addr(&charlie).bytes.0.to_vec()
+        );
+        assert_eq!(reward_set_entries[0].amount_stacked, 2 * LOCKUP_AMT);
+    }
+
+    let height_target = burnchain.reward_cycle_to_block_height(first_v3_cycle) + 1;
+    while get_tip(peer.sortdb.as_ref()).block_height < height_target {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+        let alice_balance = get_balance(&mut peer, &key_to_stacks_addr(&alice).into());
+        assert_eq!(alice_balance, 0);
+    }
+
+    let tip = get_tip(peer.sortdb.as_ref());
+
+    // Extend bob's lockup via `delegate-stack-extend` for 1 more cycle
+    //  so that we can check the first-reward-cycle is correctly updated
+    let delegate_extend_tx = make_pox_3_contract_call(
+        &charlie,
+        charlie_nonce,
+        "delegate-stack-extend",
+        vec![
+            PrincipalData::from(bob_address.clone()).into(),
+            make_pox_addr(
+                AddressHashMode::SerializeP2PKH,
+                charlie_address.bytes.clone(),
+            ),
+            Value::UInt(3),
+        ],
+    );
+    charlie_nonce += 1;
+
+    latest_block = peer.tenure_with_txs(&[delegate_extend_tx], &mut coinbase_nonce);
+    let StackingStateCheckData {
+        first_cycle: alice_first_cycle,
+        lock_period: alice_lock_period,
+        ..
+    } = check_stacking_state_invariants(
+        &mut peer,
+        &latest_block,
+        &alice_principal,
+        false,
+        POX_3_NAME,
+    );
+    let StackingStateCheckData {
+        first_cycle: bob_first_cycle,
+        lock_period: bob_lock_period,
+        ..
+    } = check_stacking_state_invariants(
+        &mut peer,
+        &latest_block,
+        &bob_principal,
+        false,
+        POX_3_NAME,
+    );
+
+    assert_eq!(
+        alice_first_cycle as u64, first_v3_cycle,
+        "Alice's first cycle in PoX-2 stacking state is the next cycle, which is 8"
+    );
+    assert_eq!(alice_lock_period, 6);
+    assert_eq!(
+        bob_first_cycle as u64, first_v3_cycle,
+        "Bob's first cycle in PoX-2 stacking state is the next cycle, which is 8"
+    );
+    assert_eq!(bob_lock_period, 7);
+
+    // now let's check some tx receipts
+    let blocks = observer.get_blocks();
+
+    let mut alice_txs = HashMap::new();
+    let mut bob_txs = HashMap::new();
+    let mut charlie_txs = HashMap::new();
+
+    for b in blocks.into_iter() {
+        for r in b.receipts.into_iter() {
+            if let TransactionOrigin::Stacks(ref t) = r.transaction {
+                let addr = t.auth.origin().address_testnet();
+                eprintln!("TX addr: {}", addr);
+                if addr == alice_address {
+                    alice_txs.insert(t.auth.get_origin_nonce(), r);
+                } else if addr == bob_address {
+                    bob_txs.insert(t.auth.get_origin_nonce(), r);
+                } else if addr == charlie_address {
+                    charlie_txs.insert(t.auth.get_origin_nonce(), r);
+                }
+            }
+        }
+    }
+
+    assert_eq!(alice_txs.len(), alice_nonce as usize);
+    assert_eq!(bob_txs.len(), bob_nonce as usize);
+    assert_eq!(charlie_txs.len(), charlie_nonce as usize);
+
+    for tx in alice_txs.iter() {
+        assert!(
+            if let Value::Response(ref r) = tx.1.result {
+                r.committed
+            } else {
+                false
+            },
+            "Alice txs should all have committed okay"
+        );
+    }
+    for tx in bob_txs.iter() {
+        assert!(
+            if let Value::Response(ref r) = tx.1.result {
+                r.committed
+            } else {
+                false
+            },
+            "Bob txs should all have committed okay"
+        );
+    }
+    for tx in charlie_txs.iter() {
+        assert!(
+            if let Value::Response(ref r) = tx.1.result {
+                r.committed
+            } else {
+                false
+            },
+            "Charlie txs should all have committed okay"
+        );
+    }
+
+    // Check that the call to `delegate-stack-stx` has a well-formed print event.
+    let delegate_stack_tx = &charlie_txs
+        .get(&delegate_stack_stx_nonce)
+        .unwrap()
+        .clone()
+        .events[0];
+    let pox_addr_val = generate_pox_clarity_value("12d93ae7b61e5b7d905c85828d4320e7c221f433");
+    let delegate_op_data = HashMap::from([
+        ("lock-amount", Value::UInt(LOCKUP_AMT)),
+        (
+            "unlock-burn-height",
+            Value::UInt(delegate_stack_stx_unlock_ht.into()),
+        ),
+        (
+            "start-burn-height",
+            Value::UInt(delegate_stack_stx_lock_ht.into()),
+        ),
+        ("pox-addr", pox_addr_val.clone()),
+        ("lock-period", Value::UInt(3)),
+        ("delegator", Value::Principal(charlie_principal.clone())),
+    ]);
+    let common_data = PoxPrintFields {
+        op_name: "delegate-stack-stx".to_string(),
+        stacker: Value::Principal(bob_principal.clone()),
+        balance: Value::UInt(LOCKUP_AMT),
+        locked: Value::UInt(0),
+        burnchain_unlock_height: Value::UInt(0),
+    };
+    check_pox_print_event(delegate_stack_tx, common_data, delegate_op_data);
+
+    // Check that the call to `delegate-stack-extend` has a well-formed print event.
+    let delegate_stack_extend_tx = &charlie_txs
+        .get(&delegate_stack_extend_nonce)
+        .unwrap()
+        .clone()
+        .events[0];
+    let delegate_ext_op_data = HashMap::from([
+        ("pox-addr", pox_addr_val.clone()),
+        (
+            "unlock-burn-height",
+            Value::UInt(delegate_stack_extend_unlock_ht.into()),
+        ),
+        ("extend-count", Value::UInt(1)),
+        ("delegator", Value::Principal(charlie_principal.clone())),
+    ]);
+    let common_data = PoxPrintFields {
+        op_name: "delegate-stack-extend".to_string(),
+        stacker: Value::Principal(bob_principal.clone()),
+        balance: Value::UInt(0),
+        locked: Value::UInt(LOCKUP_AMT),
+        burnchain_unlock_height: Value::UInt(delegate_stack_stx_unlock_ht.into()),
+    };
+    check_pox_print_event(delegate_stack_extend_tx, common_data, delegate_ext_op_data);
+
+    // Check that the call to `stack-aggregation-commit` has a well-formed print event.
+    let stack_agg_commit_tx = &charlie_txs.get(&stack_agg_nonce).unwrap().clone().events[0];
+    let stack_agg_commit_op_data = HashMap::from([
+        ("pox-addr", pox_addr_val),
+        ("reward-cycle", Value::UInt(stack_agg_cycle.into())),
+        ("amount-ustx", Value::UInt(2 * LOCKUP_AMT)),
+    ]);
+    let common_data = PoxPrintFields {
+        op_name: "stack-aggregation-commit".to_string(),
+        stacker: Value::Principal(charlie_principal.clone()),
+        balance: Value::UInt(LOCKUP_AMT),
+        locked: Value::UInt(0),
+        burnchain_unlock_height: Value::UInt(0),
+    };
+    check_pox_print_event(stack_agg_commit_tx, common_data, stack_agg_commit_op_data);
+}
+
+#[test]
+fn pox_3_getters() {
+    // the sim environment produces 25 empty sortitions before
+    //  tenures start being tracked.
+    let EMPTY_SORTITIONS = 25;
+
+    let (epochs, pox_constants) = make_test_epochs_pox();
+
+    let mut burnchain = Burnchain::default_unittest(
+        0,
+        &BurnchainHeaderHash::from_hex(BITCOIN_REGTEST_FIRST_BLOCK_HASH).unwrap(),
+    );
+    burnchain.pox_constants = pox_constants.clone();
+
+    let first_v3_cycle = burnchain
+        .block_height_to_reward_cycle(burnchain.pox_constants.pox_3_activation_height as u64)
+        .unwrap()
+        + 1;
+
+    let observer = TestEventObserver::new();
+
+    let (mut peer, mut keys) = instantiate_pox_peer_with_epoch(
+        &burnchain,
+        function_name!(),
+        Some(epochs.clone()),
+        Some(&observer),
+    );
+
+    peer.config.check_pox_invariants = Some((first_v3_cycle, first_v3_cycle + 10));
+
+    let alice = keys.pop().unwrap();
+    let bob = keys.pop().unwrap();
+    let charlie = keys.pop().unwrap();
+    let danielle = keys.pop().unwrap();
+
+    let alice_address = key_to_stacks_addr(&alice);
+    let bob_address = key_to_stacks_addr(&bob);
+    let charlie_address = key_to_stacks_addr(&charlie);
+    let mut coinbase_nonce = 0;
+
+    let mut latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    // Roll to Epoch-2.4 and perform the delegate-stack-extend tests
+    while get_tip(peer.sortdb.as_ref()).block_height <= epochs[6].start_height {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    }
+
+    let tip = get_tip(peer.sortdb.as_ref());
+    let LOCKUP_AMT = 1024 * POX_THRESHOLD_STEPS_USTX;
+
+    // alice locks in v2
+    let alice_lockup = make_pox_3_lockup(
+        &alice,
+        0,
+        LOCKUP_AMT,
+        PoxAddress::from_legacy(
+            AddressHashMode::SerializeP2PKH,
+            key_to_stacks_addr(&alice).bytes,
+        ),
+        4,
+        tip.block_height,
+    );
+
+    // bob deleates to charlie
+    let bob_delegate_tx = make_pox_3_contract_call(
+        &bob,
+        0,
+        "delegate-stx",
+        vec![
+            Value::UInt(LOCKUP_AMT),
+            PrincipalData::from(charlie_address.clone()).into(),
+            Value::none(),
+            Value::none(),
+        ],
+    );
+
+    // charlie calls delegate-stack-stx for bob
+    let charlie_delegate_stack_tx = make_pox_3_contract_call(
+        &charlie,
+        0,
+        "delegate-stack-stx",
+        vec![
+            PrincipalData::from(bob_address.clone()).into(),
+            Value::UInt(LOCKUP_AMT),
+            make_pox_addr(
+                AddressHashMode::SerializeP2PKH,
+                charlie_address.bytes.clone(),
+            ),
+            Value::UInt(tip.block_height as u128),
+            Value::UInt(4),
+        ],
+    );
+
+    let agg_commit_tx_1 = make_pox_3_contract_call(
+        &charlie,
+        1,
+        "stack-aggregation-commit",
+        vec![
+            make_pox_addr(
+                AddressHashMode::SerializeP2PKH,
+                charlie_address.bytes.clone(),
+            ),
+            Value::UInt(first_v3_cycle as u128),
+        ],
+    );
+
+    let agg_commit_tx_2 = make_pox_3_contract_call(
+        &charlie,
+        2,
+        "stack-aggregation-commit",
+        vec![
+            make_pox_addr(
+                AddressHashMode::SerializeP2PKH,
+                charlie_address.bytes.clone(),
+            ),
+            Value::UInt(first_v3_cycle as u128 + 1),
+        ],
+    );
+
+    let agg_commit_tx_3 = make_pox_3_contract_call(
+        &charlie,
+        3,
+        "stack-aggregation-commit",
+        vec![
+            make_pox_addr(
+                AddressHashMode::SerializeP2PKH,
+                charlie_address.bytes.clone(),
+            ),
+            Value::UInt(first_v3_cycle as u128 + 2),
+        ],
+    );
+
+    let reject_pox = make_pox_3_contract_call(&danielle, 0, "reject-pox", vec![]);
+
+    peer.tenure_with_txs(
+        &[
+            alice_lockup,
+            bob_delegate_tx,
+            charlie_delegate_stack_tx,
+            agg_commit_tx_1,
+            agg_commit_tx_2,
+            agg_commit_tx_3,
+            reject_pox,
+        ],
+        &mut coinbase_nonce,
+    );
+
+    let result = eval_at_tip(&mut peer, "pox-3", &format!("
+    {{
+        ;; should be none
+        get-delegation-info-alice: (get-delegation-info '{}),
+        ;; should be (some $charlie_address)
+        get-delegation-info-bob: (get-delegation-info '{}),
+        ;; should be none
+        get-allowance-contract-callers: (get-allowance-contract-callers '{} '{}),
+        ;; should be 1
+        get-num-reward-set-pox-addresses-current: (get-num-reward-set-pox-addresses u{}),
+        ;; should be 0
+        get-num-reward-set-pox-addresses-future: (get-num-reward-set-pox-addresses u1000),
+        ;; should be 0
+        get-partial-stacked-by-cycle-bob-0: (get-partial-stacked-by-cycle {{ version: 0x00, hashbytes: 0x{} }} u{} '{}),
+        get-partial-stacked-by-cycle-bob-1: (get-partial-stacked-by-cycle {{ version: 0x00, hashbytes: 0x{} }} u{} '{}),
+        get-partial-stacked-by-cycle-bob-2: (get-partial-stacked-by-cycle {{ version: 0x00, hashbytes: 0x{} }} u{} '{}),
+        ;; should be LOCKUP_AMT
+        get-partial-stacked-by-cycle-bob-3: (get-partial-stacked-by-cycle {{ version: 0x00, hashbytes: 0x{} }} u{} '{}),
+        ;; should be LOCKUP_AMT
+        get-total-pox-rejection-now: (get-total-pox-rejection u{}),
+        ;; should be 0
+        get-total-pox-rejection-next: (get-total-pox-rejection u{}),
+        ;; should be 0
+        get-total-pox-rejection-future: (get-total-pox-rejection u{})
+    }}", &alice_address,
+        &bob_address,
+        &bob_address, &format!("{}.hello-world", &charlie_address), first_v3_cycle + 1,
+        &charlie_address.bytes, first_v3_cycle + 0, &charlie_address,
+        &charlie_address.bytes, first_v3_cycle + 1, &charlie_address,
+        &charlie_address.bytes, first_v3_cycle + 2, &charlie_address,
+        &charlie_address.bytes, first_v3_cycle + 3, &charlie_address,
+        first_v3_cycle,
+        first_v3_cycle + 1,
+        first_v3_cycle + 2,
+    ));
+
+    eprintln!("{}", &result);
+    let data = result.expect_tuple().data_map;
+
+    let alice_delegation_info = data
+        .get("get-delegation-info-alice")
+        .cloned()
+        .unwrap()
+        .expect_optional();
+    assert!(alice_delegation_info.is_none());
+
+    let bob_delegation_info = data
+        .get("get-delegation-info-bob")
+        .cloned()
+        .unwrap()
+        .expect_optional()
+        .unwrap()
+        .expect_tuple()
+        .data_map;
+    let bob_delegation_addr = bob_delegation_info
+        .get("delegated-to")
+        .cloned()
+        .unwrap()
+        .expect_principal();
+    let bob_delegation_amt = bob_delegation_info
+        .get("amount-ustx")
+        .cloned()
+        .unwrap()
+        .expect_u128();
+    let bob_pox_addr_opt = bob_delegation_info
+        .get("pox-addr")
+        .cloned()
+        .unwrap()
+        .expect_optional();
+    assert_eq!(bob_delegation_addr, charlie_address.to_account_principal());
+    assert_eq!(bob_delegation_amt, LOCKUP_AMT as u128);
+    assert!(bob_pox_addr_opt.is_none());
+
+    let allowance = data
+        .get("get-allowance-contract-callers")
+        .cloned()
+        .unwrap()
+        .expect_optional();
+    assert!(allowance.is_none());
+
+    let current_num_reward_addrs = data
+        .get("get-num-reward-set-pox-addresses-current")
+        .cloned()
+        .unwrap()
+        .expect_u128();
+    assert_eq!(current_num_reward_addrs, 2);
+
+    let future_num_reward_addrs = data
+        .get("get-num-reward-set-pox-addresses-future")
+        .cloned()
+        .unwrap()
+        .expect_u128();
+    assert_eq!(future_num_reward_addrs, 0);
+
+    for i in 0..3 {
+        let key =
+            ClarityName::try_from(format!("get-partial-stacked-by-cycle-bob-{}", &i)).unwrap();
+        let partial_stacked = data.get(&key).cloned().unwrap().expect_optional();
+        assert!(partial_stacked.is_none());
+    }
+    let partial_stacked = data
+        .get("get-partial-stacked-by-cycle-bob-3")
+        .cloned()
+        .unwrap()
+        .expect_optional()
+        .unwrap()
+        .expect_tuple()
+        .data_map
+        .get("stacked-amount")
+        .cloned()
+        .unwrap()
+        .expect_u128();
+    assert_eq!(partial_stacked, LOCKUP_AMT as u128);
+
+    let rejected = data
+        .get("get-total-pox-rejection-now")
+        .cloned()
+        .unwrap()
+        .expect_u128();
+    assert_eq!(rejected, LOCKUP_AMT as u128);
+
+    let rejected = data
+        .get("get-total-pox-rejection-next")
+        .cloned()
+        .unwrap()
+        .expect_u128();
+    assert_eq!(rejected, 0);
+
+    let rejected = data
+        .get("get-total-pox-rejection-future")
+        .cloned()
+        .unwrap()
+        .expect_u128();
+    assert_eq!(rejected, 0);
+}
+
+fn get_burn_pox_addr_info(peer: &mut TestPeer) -> (Vec<PoxAddress>, u128) {
+    let tip = get_tip(peer.sortdb.as_ref());
+    let tip_index_block = tip.get_canonical_stacks_block_id();
+    let burn_height = tip.block_height - 1;
+    let addrs_and_payout = with_sortdb(peer, |ref mut chainstate, ref mut sortdb| {
+        let addrs = chainstate
+            .maybe_read_only_clarity_tx(&sortdb.index_conn(), &tip_index_block, |clarity_tx| {
+                clarity_tx
+                    .with_readonly_clarity_env(
+                        false,
+                        0x80000000,
+                        ClarityVersion::Clarity2,
+                        PrincipalData::Standard(StandardPrincipalData::transient()),
+                        None,
+                        LimitedCostTracker::new_free(),
+                        |env| {
+                            env.eval_read_only(
+                                &boot_code_id("pox-2", false),
+                                &format!("(get-burn-block-info? pox-addrs u{})", &burn_height),
+                            )
+                        },
+                    )
+                    .unwrap()
+            })
+            .unwrap();
+        addrs
+    })
+    .unwrap()
+    .expect_optional()
+    .expect("FATAL: expected list")
+    .expect_tuple();
+
+    let addrs = addrs_and_payout
+        .get("addrs")
+        .unwrap()
+        .to_owned()
+        .expect_list()
+        .into_iter()
+        .map(|tuple| PoxAddress::try_from_pox_tuple(false, &tuple).unwrap())
+        .collect();
+
+    let payout = addrs_and_payout
+        .get("payout")
+        .unwrap()
+        .to_owned()
+        .expect_u128();
+    (addrs, payout)
+}
+
+#[test]
+fn get_pox_addrs() {
+    // the sim environment produces 25 empty sortitions before
+    //  tenures start being tracked.
+    let EMPTY_SORTITIONS = 25;
+
+    let (epochs, pox_constants) = make_test_epochs_pox();
+
+    let mut burnchain = Burnchain::default_unittest(
+        0,
+        &BurnchainHeaderHash::from_hex(BITCOIN_REGTEST_FIRST_BLOCK_HASH).unwrap(),
+    );
+    burnchain.pox_constants = pox_constants.clone();
+
+    let first_v2_cycle = burnchain
+        .block_height_to_reward_cycle(burnchain.pox_constants.v1_unlock_height as u64)
+        .unwrap()
+        + 1;
+
+    let first_v3_cycle = burnchain
+        .block_height_to_reward_cycle(burnchain.pox_constants.pox_3_activation_height as u64)
+        .unwrap()
+        + 1;
+
+    let (mut peer, keys) =
+        instantiate_pox_peer_with_epoch(&burnchain, function_name!(), Some(epochs.clone()), None);
+
+    assert_eq!(burnchain.pox_constants.reward_slots(), 6);
+    let mut coinbase_nonce = 0;
+
+    let assert_latest_was_burn = |peer: &mut TestPeer| {
+        let tip = get_tip(peer.sortdb.as_ref());
+        let tip_index_block = tip.get_canonical_stacks_block_id();
+        let burn_height = tip.block_height - 1;
+
+        let conn = peer.sortdb().conn();
+
+        // check the *parent* burn block, because that's what we'll be
+        //  checking with get_burn_pox_addr_info
+        let mut burn_ops =
+            SortitionDB::get_block_commits_by_block(conn, &tip.parent_sortition_id).unwrap();
+        assert_eq!(burn_ops.len(), 1);
+        let commit = burn_ops.pop().unwrap();
+        assert!(commit.all_outputs_burn());
+        assert!(commit.burn_fee > 0);
+
+        let (addrs, payout) = get_burn_pox_addr_info(peer);
+        let tip = get_tip(peer.sortdb.as_ref());
+        let tip_index_block = tip.get_canonical_stacks_block_id();
+        let burn_height = tip.block_height - 1;
+        info!("Checking burn outputs at burn_height = {}", burn_height);
+        if peer.config.burnchain.is_in_prepare_phase(burn_height) {
+            assert_eq!(addrs.len(), 1);
+            assert_eq!(payout, 1000);
+            assert!(addrs[0].is_burn());
+        } else {
+            assert_eq!(addrs.len(), 2);
+            assert_eq!(payout, 500);
+            assert!(addrs[0].is_burn());
+            assert!(addrs[1].is_burn());
+        }
+    };
+
+    let assert_latest_was_pox = |peer: &mut TestPeer| {
+        let tip = get_tip(peer.sortdb.as_ref());
+        let tip_index_block = tip.get_canonical_stacks_block_id();
+        let burn_height = tip.block_height - 1;
+
+        let conn = peer.sortdb().conn();
+
+        // check the *parent* burn block, because that's what we'll be
+        //  checking with get_burn_pox_addr_info
+        let mut burn_ops =
+            SortitionDB::get_block_commits_by_block(conn, &tip.parent_sortition_id).unwrap();
+        assert_eq!(burn_ops.len(), 1);
+        let commit = burn_ops.pop().unwrap();
+        assert!(!commit.all_outputs_burn());
+        let commit_addrs = commit.commit_outs;
+
+        let (addrs, payout) = get_burn_pox_addr_info(peer);
+        info!(
+            "Checking pox outputs at burn_height = {}, commit_addrs = {:?}, fetch_addrs = {:?}",
+            burn_height, commit_addrs, addrs
+        );
+        assert_eq!(addrs.len(), 2);
+        assert_eq!(payout, 500);
+        assert!(commit_addrs.contains(&addrs[0]));
+        assert!(commit_addrs.contains(&addrs[1]));
+        addrs
+    };
+
+    // Wait to pox 3 and lock STX
+    let target_height = burnchain.pox_constants.pox_3_activation_height;
+    while get_tip(peer.sortdb.as_ref()).block_height <= u64::from(target_height) {
+        peer.tenure_with_txs(&[], &mut coinbase_nonce);
+        // if we reach epoch 2.1, perform the check
+        if get_tip(peer.sortdb.as_ref()).block_height > epochs[3].start_height {
+            assert_latest_was_burn(&mut peer);
+        }
+    }
+
+    let mut txs = vec![];
+    let tip_height = get_tip(peer.sortdb.as_ref()).block_height;
+    let stackers: Vec<_> = keys
+        .iter()
+        .zip([
+            AddressHashMode::SerializeP2PKH,
+            AddressHashMode::SerializeP2SH,
+            AddressHashMode::SerializeP2WPKH,
+            AddressHashMode::SerializeP2WSH,
+        ])
+        .map(|(key, hash_mode)| {
+            let pox_addr = PoxAddress::from_legacy(hash_mode, key_to_stacks_addr(key).bytes);
+            txs.push(make_pox_3_lockup(
+                key,
+                0,
+                1024 * POX_THRESHOLD_STEPS_USTX,
+                pox_addr.clone(),
+                1000,
+                tip_height,
+            ));
+            pox_addr
+        })
+        .collect();
+
+    let mut latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
+    assert_latest_was_burn(&mut peer);
+
+    // Wait to almost pox 4 and lock STX
+    let target_height =
+        burnchain.pox_constants.pox_4_activation_height - burnchain.pox_constants.prepare_length;
+    // produce blocks until the first reward phase that everyone should be in
+    while get_tip(peer.sortdb.as_ref()).block_height < u64::from(target_height) {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    }
+
+    let mut txs = vec![];
+    let tip_height = get_tip(peer.sortdb.as_ref()).block_height;
+    let stackers: Vec<_> = keys
+        .iter()
+        .zip([
+            AddressHashMode::SerializeP2PKH,
+            AddressHashMode::SerializeP2SH,
+            AddressHashMode::SerializeP2WPKH,
+            AddressHashMode::SerializeP2WSH,
+        ])
+        .map(|(key, hash_mode)| {
+            let pox_addr = PoxAddress::from_legacy(hash_mode, key_to_stacks_addr(key).bytes);
+            txs.push(make_pox_4_lockup(
+                key,
+                0,
+                1024 * POX_THRESHOLD_STEPS_USTX,
+                pox_addr.clone(),
+                1000,
+                tip_height,
+            ));
+            pox_addr
+        })
+        .collect();
+
+    let mut latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
+
+    return;
+
+    // now we should be in the reward phase, produce the reward blocks
+    let reward_blocks =
+        burnchain.pox_constants.reward_cycle_length - burnchain.pox_constants.prepare_length;
+    let mut rewarded = HashSet::new();
+    for i in 0..reward_blocks {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+        // only the first 2 reward blocks contain pox outputs, because there are 6 slots and only 4 are occuppied
+        if i < 2 {
+            assert_latest_was_pox(&mut peer)
+                .into_iter()
+                .filter(|addr| !addr.is_burn())
+                .for_each(|addr| {
+                    rewarded.insert(addr);
+                });
+        } else {
+            assert_latest_was_burn(&mut peer);
+        }
+    }
+
+    assert_eq!(rewarded.len(), 4);
+    for stacker in stackers.iter() {
+        assert!(
+            rewarded.contains(stacker),
+            "Reward cycle should include {}",
+            stacker
+        );
+    }
+
+    // now we should be back in a prepare phase
+    for _i in 0..burnchain.pox_constants.prepare_length {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+        assert_latest_was_burn(&mut peer);
+    }
+
+    // now we should be in the reward phase, produce the reward blocks
+    let mut rewarded = HashSet::new();
+    for i in 0..reward_blocks {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+        // only the first 2 reward blocks contain pox outputs, because there are 6 slots and only 4 are occuppied
+        if i < 2 {
+            assert_latest_was_pox(&mut peer)
+                .into_iter()
+                .filter(|addr| !addr.is_burn())
+                .for_each(|addr| {
+                    rewarded.insert(addr);
+                });
+        } else {
+            assert_latest_was_burn(&mut peer);
+        }
+    }
+
+    assert_eq!(rewarded.len(), 4);
+    for stacker in stackers.iter() {
+        assert!(
+            rewarded.contains(stacker),
+            "Reward cycle should include {}",
+            stacker
+        );
+    }
+
+    // now we should be back in a prepare phase
+    for _i in 0..burnchain.pox_constants.prepare_length {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+        assert_latest_was_burn(&mut peer);
+    }
+
+    // now we're in the next reward cycle, but everyone is unstacked
+    for _i in 0..burnchain.pox_constants.reward_cycle_length {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+        assert_latest_was_burn(&mut peer);
+    }
+}
+
+#[test]
+fn stack_with_segwit() {
+    // the sim environment produces 25 empty sortitions before
+    //  tenures start being tracked.
+    let EMPTY_SORTITIONS = 25;
+
+    let (epochs, pox_constants) = make_test_epochs_pox();
+
+    let mut burnchain = Burnchain::default_unittest(
+        0,
+        &BurnchainHeaderHash::from_hex(BITCOIN_REGTEST_FIRST_BLOCK_HASH).unwrap(),
+    );
+    burnchain.pox_constants = pox_constants.clone();
+
+    let first_v2_cycle = burnchain
+        .block_height_to_reward_cycle(burnchain.pox_constants.v1_unlock_height as u64)
+        .unwrap()
+        + 1;
+
+    let first_v3_cycle = burnchain
+        .block_height_to_reward_cycle(burnchain.pox_constants.pox_3_activation_height as u64)
+        .unwrap()
+        + 1;
+
+    let (mut peer, keys) =
+        instantiate_pox_peer_with_epoch(&burnchain, function_name!(), Some(epochs.clone()), None);
+
+    peer.config.check_pox_invariants = Some((first_v3_cycle, first_v3_cycle + 10));
+
+    assert_eq!(burnchain.pox_constants.reward_slots(), 6);
+    let mut coinbase_nonce = 0;
+
+    let assert_latest_was_burn = |peer: &mut TestPeer| {
+        let tip = get_tip(peer.sortdb.as_ref());
+        let tip_index_block = tip.get_canonical_stacks_block_id();
+        let burn_height = tip.block_height - 1;
+
+        let conn = peer.sortdb().conn();
+
+        // check the *parent* burn block, because that's what we'll be
+        //  checking with get_burn_pox_addr_info
+        let mut burn_ops =
+            SortitionDB::get_block_commits_by_block(conn, &tip.parent_sortition_id).unwrap();
+        assert_eq!(burn_ops.len(), 1);
+        let commit = burn_ops.pop().unwrap();
+        assert!(commit.all_outputs_burn());
+        assert!(commit.burn_fee > 0);
+
+        let (addrs, payout) = get_burn_pox_addr_info(peer);
+        let tip = get_tip(peer.sortdb.as_ref());
+        let tip_index_block = tip.get_canonical_stacks_block_id();
+        let burn_height = tip.block_height - 1;
+        info!("Checking burn outputs at burn_height = {}", burn_height);
+        if peer.config.burnchain.is_in_prepare_phase(burn_height) {
+            assert_eq!(addrs.len(), 1);
+            assert_eq!(payout, 1000);
+            assert!(addrs[0].is_burn());
+        } else {
+            assert_eq!(addrs.len(), 2);
+            assert_eq!(payout, 500);
+            assert!(addrs[0].is_burn());
+            assert!(addrs[1].is_burn());
+        }
+    };
+
+    let assert_latest_was_pox = |peer: &mut TestPeer| {
+        let tip = get_tip(peer.sortdb.as_ref());
+        let tip_index_block = tip.get_canonical_stacks_block_id();
+        let burn_height = tip.block_height - 1;
+
+        let conn = peer.sortdb().conn();
+
+        // check the *parent* burn block, because that's what we'll be
+        //  checking with get_burn_pox_addr_info
+        let mut burn_ops =
+            SortitionDB::get_block_commits_by_block(conn, &tip.parent_sortition_id).unwrap();
+        assert_eq!(burn_ops.len(), 1);
+        let commit = burn_ops.pop().unwrap();
+        assert!(!commit.all_outputs_burn());
+        let commit_addrs = commit.commit_outs;
+
+        let (addrs, payout) = get_burn_pox_addr_info(peer);
+        info!(
+            "Checking pox outputs at burn_height = {}, commit_addrs = {:?}, fetch_addrs = {:?}",
+            burn_height, commit_addrs, addrs
+        );
+        assert_eq!(addrs.len(), 2);
+        assert_eq!(payout, 500);
+        assert!(commit_addrs.contains(&addrs[0]));
+        assert!(commit_addrs.contains(&addrs[1]));
+        addrs
+    };
+
+    // produce blocks until epoch 2.2
+    while get_tip(peer.sortdb.as_ref()).block_height <= epochs[6].start_height {
+        peer.tenure_with_txs(&[], &mut coinbase_nonce);
+        // if we reach epoch 2.1, perform the check
+        if get_tip(peer.sortdb.as_ref()).block_height > epochs[3].start_height {
+            assert_latest_was_burn(&mut peer);
+        }
+    }
+
+    let mut txs = vec![];
+    let tip_height = get_tip(peer.sortdb.as_ref()).block_height;
+    let stackers: Vec<_> = keys
+        .iter()
+        .zip([
+            PoxAddress::Addr20(false, PoxAddressType20::P2WPKH, [0x01; 20]),
+            PoxAddress::Addr32(false, PoxAddressType32::P2WSH, [0x02; 32]),
+            PoxAddress::Addr32(false, PoxAddressType32::P2TR, [0x03; 32]),
+            PoxAddress::from_legacy(AddressHashMode::SerializeP2PKH, Hash160([0x04; 20])),
+        ])
+        .map(|(key, pox_addr)| {
+            txs.push(make_pox_3_lockup(
+                key,
+                0,
+                1024 * POX_THRESHOLD_STEPS_USTX,
+                pox_addr.clone(),
+                2,
+                tip_height,
+            ));
+            pox_addr
+        })
+        .collect();
+
+    let mut latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
+    assert_latest_was_burn(&mut peer);
+
+    let target_height = burnchain.reward_cycle_to_block_height(first_v3_cycle);
+    // produce blocks until the first reward phase that everyone should be in
+    while get_tip(peer.sortdb.as_ref()).block_height < target_height {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+        assert_latest_was_burn(&mut peer);
+    }
+
+    // now we should be in the reward phase, produce the reward blocks
+    let reward_blocks =
+        burnchain.pox_constants.reward_cycle_length - burnchain.pox_constants.prepare_length;
+    let mut rewarded = HashSet::new();
+    for i in 0..reward_blocks {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+        // only the first 2 reward blocks contain pox outputs, because there are 6 slots and only 4 are occuppied
+        if i < 2 {
+            assert_latest_was_pox(&mut peer)
+                .into_iter()
+                .filter(|addr| !addr.is_burn())
+                .for_each(|addr| {
+                    rewarded.insert(addr);
+                });
+        } else {
+            assert_latest_was_burn(&mut peer);
+        }
+    }
+
+    assert_eq!(rewarded.len(), 4);
+    for stacker in stackers.iter() {
+        assert!(
+            rewarded.contains(stacker),
+            "Reward cycle should include {}",
+            stacker
+        );
+    }
+
+    // now we should be back in a prepare phase
+    for _i in 0..burnchain.pox_constants.prepare_length {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+        assert_latest_was_burn(&mut peer);
+    }
+
+    // now we should be in the reward phase, produce the reward blocks
+    let mut rewarded = HashSet::new();
+    for i in 0..reward_blocks {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+        // only the first 2 reward blocks contain pox outputs, because there are 6 slots and only 4 are occuppied
+        if i < 2 {
+            assert_latest_was_pox(&mut peer)
+                .into_iter()
+                .filter(|addr| !addr.is_burn())
+                .for_each(|addr| {
+                    rewarded.insert(addr);
+                });
+        } else {
+            assert_latest_was_burn(&mut peer);
+        }
+    }
+
+    assert_eq!(rewarded.len(), 4);
+    for stacker in stackers.iter() {
+        assert!(
+            rewarded.contains(stacker),
+            "Reward cycle should include {}",
+            stacker
+        );
+    }
+
+    // now we should be back in a prepare phase
+    for _i in 0..burnchain.pox_constants.prepare_length {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+        assert_latest_was_burn(&mut peer);
+    }
+
+    // now we're in the next reward cycle, but everyone is unstacked
+    for _i in 0..burnchain.pox_constants.reward_cycle_length {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+        assert_latest_was_burn(&mut peer);
+    }
+}
+
+/// In this test case, Alice delegates to Bob.
+///  Bob stacks Alice's funds via PoX v2 for 6 cycles. In the third cycle,
+///  Bob increases Alice's stacking amount by less than the stacking min.
+///  Bob is able to increase the pool's aggregate amount anyway.
+///
+#[test]
+fn stack_aggregation_increase() {
+    // the sim environment produces 25 empty sortitions before
+    //  tenures start being tracked.
+    let EMPTY_SORTITIONS = 25;
+
+    let (epochs, pox_constants) = make_test_epochs_pox();
+
+    let mut burnchain = Burnchain::default_unittest(
+        0,
+        &BurnchainHeaderHash::from_hex(BITCOIN_REGTEST_FIRST_BLOCK_HASH).unwrap(),
+    );
+    burnchain.pox_constants = pox_constants.clone();
+
+    let first_v3_cycle = burnchain
+        .block_height_to_reward_cycle(burnchain.pox_constants.pox_3_activation_height as u64)
+        .unwrap()
+        + 1;
+
+    let observer = TestEventObserver::new();
+
+    let (mut peer, mut keys) = instantiate_pox_peer_with_epoch(
+        &burnchain,
+        function_name!(),
+        Some(epochs.clone()),
+        Some(&observer),
+    );
+
+    peer.config.check_pox_invariants = Some((first_v3_cycle, first_v3_cycle + 10));
+
+    let alice = keys.pop().unwrap();
+    let alice_address = key_to_stacks_addr(&alice);
+    let alice_principal = PrincipalData::from(alice_address.clone());
+    let bob = keys.pop().unwrap();
+    let bob_address = key_to_stacks_addr(&bob);
+    let bob_principal = PrincipalData::from(bob_address.clone());
+    let bob_pox_addr = make_pox_addr(AddressHashMode::SerializeP2PKH, bob_address.bytes.clone());
+    let charlie = keys.pop().unwrap();
+    let charlie_address = key_to_stacks_addr(&charlie);
+    let charlie_pox_addr = make_pox_addr(
+        AddressHashMode::SerializeP2PKH,
+        charlie_address.bytes.clone(),
+    );
+    let dan = keys.pop().unwrap();
+    let dan_address = key_to_stacks_addr(&dan);
+    let dan_principal = PrincipalData::from(dan_address.clone());
+    let dan_pox_addr = make_pox_addr(AddressHashMode::SerializeP2PKH, dan_address.bytes.clone());
+    let alice_nonce = 0;
+    let mut bob_nonce = 0;
+    let mut charlie_nonce = 0;
+    let mut dan_nonce = 0;
+
+    let alice_first_lock_amount = 512 * POX_THRESHOLD_STEPS_USTX;
+    let alice_delegation_amount = alice_first_lock_amount + 1;
+    let dan_delegation_amount = alice_first_lock_amount + 1;
+    let dan_stack_amount = 511 * POX_THRESHOLD_STEPS_USTX;
+
+    let mut coinbase_nonce = 0;
+
+    // first tenure is empty
+    let mut latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+
+    // Roll to Epoch-2.4 and perform the delegate-stack-extend tests
+    while get_tip(peer.sortdb.as_ref()).block_height <= epochs[6].start_height {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    }
+
+    let tip = get_tip(peer.sortdb.as_ref());
+
+    // submit delegation tx for alice
+    let alice_delegation_1 = make_pox_3_contract_call(
+        &alice,
+        alice_nonce,
+        "delegate-stx",
+        vec![
+            Value::UInt(alice_delegation_amount),
+            bob_principal.clone().into(),
+            Value::none(),
+            Value::none(),
+        ],
+    );
+
+    // bob locks some of alice's tokens
+    let delegate_stack_tx_bob = make_pox_3_contract_call(
+        &bob,
+        bob_nonce,
+        "delegate-stack-stx",
+        vec![
+            alice_principal.clone().into(),
+            Value::UInt(alice_first_lock_amount),
+            bob_pox_addr.clone(),
+            Value::UInt(tip.block_height as u128),
+            Value::UInt(6),
+        ],
+    );
+    bob_nonce += 1;
+
+    // dan stacks some tokens
+    let stack_tx_dan = make_pox_3_lockup(
+        &dan,
+        dan_nonce,
+        dan_stack_amount,
+        PoxAddress::from_legacy(AddressHashMode::SerializeP2PKH, dan_address.bytes.clone()),
+        12,
+        tip.block_height,
+    );
+    dan_nonce += 1;
+
+    latest_block = peer.tenure_with_txs(
+        &[alice_delegation_1, delegate_stack_tx_bob, stack_tx_dan],
+        &mut coinbase_nonce,
+    );
+
+    // check that the partial stacking state contains entries for bob
+    for cycle_number in first_v3_cycle..(first_v3_cycle + 6) {
+        let partial_stacked = get_partial_stacked(
+            &mut peer,
+            &latest_block,
+            &bob_pox_addr,
+            cycle_number,
+            &bob_principal,
+            POX_3_NAME,
+        );
+        assert_eq!(partial_stacked, 512 * POX_THRESHOLD_STEPS_USTX);
+    }
+
+    // we'll produce blocks until the 3rd reward cycle gets through the "handled start" code
+    //  this is one block after the reward cycle starts
+    let height_target = burnchain.reward_cycle_to_block_height(first_v3_cycle + 3) + 1;
+
+    while get_tip(peer.sortdb.as_ref()).block_height < height_target {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    }
+
+    let expected_alice_unlock = burnchain.reward_cycle_to_block_height(first_v3_cycle + 6) - 1;
+    let expected_dan_unlock = burnchain.reward_cycle_to_block_height(first_v3_cycle + 12) - 1;
+
+    let alice_bal = get_stx_account_at(&mut peer, &latest_block, &alice_principal);
+    assert_eq!(alice_bal.amount_locked(), alice_first_lock_amount);
+    assert_eq!(alice_bal.unlock_height(), expected_alice_unlock);
+
+    let dan_bal = get_stx_account_at(&mut peer, &latest_block, &dan_principal);
+    assert_eq!(dan_bal.amount_locked(), dan_stack_amount);
+    assert_eq!(dan_bal.unlock_height(), expected_dan_unlock);
+
+    // check that the partial stacking state still contains entries for bob
+    for cycle_number in first_v3_cycle..(first_v3_cycle + 6) {
+        let partial_stacked = get_partial_stacked(
+            &mut peer,
+            &latest_block,
+            &bob_pox_addr,
+            cycle_number,
+            &bob_principal,
+            POX_3_NAME,
+        );
+        assert_eq!(partial_stacked, 512 * POX_THRESHOLD_STEPS_USTX);
+    }
+
+    let tip = get_tip(peer.sortdb.as_ref());
+    let cur_reward_cycle = burnchain
+        .block_height_to_reward_cycle(tip.block_height)
+        .unwrap();
+
+    let mut txs_to_submit = vec![];
+
+    // bob locks in alice's tokens to a PoX address,
+    // which clears the partially-stacked state
+    txs_to_submit.push(make_pox_3_contract_call(
+        &bob,
+        bob_nonce,
+        "stack-aggregation-commit-indexed",
+        vec![
+            bob_pox_addr.clone(),
+            Value::UInt((cur_reward_cycle + 1) as u128),
+        ],
+    ));
+    let bob_stack_aggregation_commit_indexed = bob_nonce;
+    bob_nonce += 1;
+
+    // bob tries to lock tokens in a reward cycle that's already committed (should fail with
+    // ERR_STACKING_NO_SUCH_PRINCIPAL)
+    txs_to_submit.push(make_pox_3_contract_call(
+        &bob,
+        bob_nonce,
+        "stack-aggregation-increase",
+        vec![
+            bob_pox_addr.clone(),
+            Value::UInt((cur_reward_cycle + 1) as u128),
+            Value::UInt(0),
+        ],
+    ));
+    let bob_err_stacking_no_such_principal = bob_nonce;
+    bob_nonce += 1;
+
+    // bob locks up 1 more of alice's tokens
+    // takes effect in the _next_ reward cycle
+    txs_to_submit.push(make_pox_3_contract_call(
+        &bob,
+        bob_nonce,
+        "delegate-stack-increase",
+        vec![
+            alice_principal.clone().into(),
+            bob_pox_addr.clone(),
+            Value::UInt(1),
+        ],
+    ));
+    bob_nonce += 1;
+
+    latest_block = peer.tenure_with_txs(&txs_to_submit, &mut coinbase_nonce);
+    let tip = get_tip(peer.sortdb.as_ref());
+    let cur_reward_cycle = burnchain
+        .block_height_to_reward_cycle(tip.block_height)
+        .unwrap();
+
+    // locked up more tokens, but unlock height is unchanged
+    let alice_bal = get_stx_account_at(&mut peer, &latest_block, &alice_principal);
+    assert_eq!(alice_bal.amount_locked(), alice_delegation_amount);
+    assert_eq!(alice_bal.unlock_height(), expected_alice_unlock);
+
+    // only 1 uSTX to lock in this next cycle for Alice
+    let partial_stacked = get_partial_stacked(
+        &mut peer,
+        &latest_block,
+        &bob_pox_addr,
+        cur_reward_cycle + 1,
+        &bob_principal,
+        POX_3_NAME,
+    );
+    assert_eq!(partial_stacked, 1);
+
+    for cycle_number in (cur_reward_cycle + 2)..(first_v3_cycle + 6) {
+        // alice has 512 * POX_THRESHOLD_STEPS_USTX partially-stacked STX in all cycles after
+        let partial_stacked = get_partial_stacked(
+            &mut peer,
+            &latest_block,
+            &bob_pox_addr,
+            cycle_number,
+            &bob_principal,
+            POX_3_NAME,
+        );
+        assert_eq!(partial_stacked, alice_delegation_amount);
+    }
+
+    let mut txs_to_submit = vec![];
+
+    // charlie tries to lock alice's additional tokens to his own PoX address (should fail with
+    // ERR_STACKING_NO_SUCH_PRINCIPAL)
+    txs_to_submit.push(make_pox_3_contract_call(
+        &charlie,
+        charlie_nonce,
+        "stack-aggregation-increase",
+        vec![
+            charlie_pox_addr.clone(),
+            Value::UInt(cur_reward_cycle as u128),
+            Value::UInt(0),
+        ],
+    ));
+    let charlie_err_stacking_no_principal = charlie_nonce;
+    charlie_nonce += 1;
+
+    // charlie tries to lock alice's additional tokens to bob's PoX address (should fail with
+    // ERR_STACKING_NO_SUCH_PRINCIPAL)
+    txs_to_submit.push(make_pox_3_contract_call(
+        &charlie,
+        charlie_nonce,
+        "stack-aggregation-increase",
+        vec![
+            bob_pox_addr.clone(),
+            Value::UInt(cur_reward_cycle as u128),
+            Value::UInt(0),
+        ],
+    ));
+    let charlie_err_stacking_no_principal_2 = charlie_nonce;
+    charlie_nonce += 1;
+
+    // bob tries to retcon a reward cycle lockup (should fail with ERR_STACKING_INVALID_LOCK_PERIOD)
+    txs_to_submit.push(make_pox_3_contract_call(
+        &bob,
+        bob_nonce,
+        "stack-aggregation-increase",
+        vec![
+            bob_pox_addr.clone(),
+            Value::UInt(cur_reward_cycle as u128),
+            Value::UInt(0),
+        ],
+    ));
+    let bob_err_stacking_invalid_lock_period = bob_nonce;
+    bob_nonce += 1;
+
+    // bob tries to lock tokens in a reward cycle that has no tokens stacked in it yet (should
+    // fail with ERR_DELEGATION_NO_REWARD_CYCLE)
+    txs_to_submit.push(make_pox_3_contract_call(
+        &bob,
+        bob_nonce,
+        "stack-aggregation-increase",
+        vec![
+            bob_pox_addr.clone(),
+            Value::UInt((cur_reward_cycle + 13) as u128),
+            Value::UInt(0),
+        ],
+    ));
+    let bob_err_delegation_no_reward_cycle = bob_nonce;
+    bob_nonce += 1;
+
+    // bob tries to lock tokens to a non-existant PoX reward address (should fail with
+    // ERR_DELEGATION_NO_REWARD_SLOT)
+    txs_to_submit.push(make_pox_3_contract_call(
+        &bob,
+        bob_nonce,
+        "stack-aggregation-increase",
+        vec![
+            bob_pox_addr.clone(),
+            Value::UInt((cur_reward_cycle + 1) as u128),
+            Value::UInt(2),
+        ],
+    ));
+    let bob_err_delegation_no_reward_slot = bob_nonce;
+    bob_nonce += 1;
+
+    // bob tries to lock tokens to the wrong PoX address (should fail with ERR_DELEGATION_WRONG_REWARD_SLOT).
+    // slot 0 belongs to dan.
+    txs_to_submit.push(make_pox_3_contract_call(
+        &bob,
+        bob_nonce,
+        "stack-aggregation-increase",
+        vec![
+            bob_pox_addr.clone(),
+            Value::UInt((cur_reward_cycle + 1) as u128),
+            Value::UInt(0),
+        ],
+    ));
+    let bob_err_delegation_wrong_reward_slot = bob_nonce;
+    bob_nonce += 1;
+
+    // bob locks tokens for Alice (bob's previous stack-aggregation-commit put his PoX address in
+    // slot 1 for this reward cycle)
+    txs_to_submit.push(make_pox_3_contract_call(
+        &bob,
+        bob_nonce,
+        "stack-aggregation-increase",
+        vec![
+            bob_pox_addr.clone(),
+            Value::UInt((cur_reward_cycle + 1) as u128),
+            Value::UInt(1),
+        ],
+    ));
+    bob_nonce += 1;
+
+    latest_block = peer.tenure_with_txs(&txs_to_submit, &mut coinbase_nonce);
+
+    assert_eq!(
+        get_stx_account_at(&mut peer, &latest_block, &alice_principal).amount_locked(),
+        alice_delegation_amount
+    );
+
+    // now let's check some tx receipts
+
+    let alice_address = key_to_stacks_addr(&alice);
+    let blocks = observer.get_blocks();
+
+    let mut alice_txs = HashMap::new();
+    let mut bob_txs = HashMap::new();
+    let mut charlie_txs = HashMap::new();
+
+    for b in blocks.into_iter() {
+        for r in b.receipts.into_iter() {
+            if let TransactionOrigin::Stacks(ref t) = r.transaction {
+                let addr = t.auth.origin().address_testnet();
+                if addr == alice_address {
+                    alice_txs.insert(t.auth.get_origin_nonce(), r);
+                } else if addr == bob_address {
+                    bob_txs.insert(t.auth.get_origin_nonce(), r);
+                } else if addr == charlie_address {
+                    charlie_txs.insert(t.auth.get_origin_nonce(), r);
+                }
+            }
+        }
+    }
+
+    assert_eq!(alice_txs.len(), 1);
+    assert_eq!(bob_txs.len(), 9);
+    assert_eq!(charlie_txs.len(), 2);
+
+    // bob's stack-aggregation-commit-indexed succeeded and returned the right index
+    assert_eq!(
+        &bob_txs[&bob_stack_aggregation_commit_indexed]
+            .result
+            .to_string(),
+        "(ok u1)"
+    );
+
+    // check bob's errors
+    assert_eq!(
+        &bob_txs[&bob_err_stacking_no_such_principal]
+            .result
+            .to_string(),
+        "(err 4)"
+    );
+    assert_eq!(
+        &bob_txs[&bob_err_stacking_invalid_lock_period]
+            .result
+            .to_string(),
+        "(err 2)"
+    );
+    assert_eq!(
+        &bob_txs[&bob_err_delegation_no_reward_cycle]
+            .result
+            .to_string(),
+        "(err 4)"
+    );
+    assert_eq!(
+        &bob_txs[&bob_err_delegation_no_reward_slot]
+            .result
+            .to_string(),
+        "(err 28)"
+    );
+    assert_eq!(
+        &bob_txs[&bob_err_delegation_wrong_reward_slot]
+            .result
+            .to_string(),
+        "(err 29)"
+    );
+
+    // check charlie's errors
+    assert_eq!(
+        &charlie_txs[&charlie_err_stacking_no_principal]
+            .result
+            .to_string(),
+        "(err 4)"
+    );
+    assert_eq!(
+        &charlie_txs[&charlie_err_stacking_no_principal_2]
+            .result
+            .to_string(),
+        "(err 4)"
+    );
+}
+
+/// Verify that delegate-stx validates the PoX addr, if given
+#[test]
+fn pox_3_delegate_stx_addr_validation() {
+    // the sim environment produces 25 empty sortitions before
+    //  tenures start being tracked.
+    let EMPTY_SORTITIONS = 25;
+
+    let (epochs, pox_constants) = make_test_epochs_pox();
+
+    let mut burnchain = Burnchain::default_unittest(
+        0,
+        &BurnchainHeaderHash::from_hex(BITCOIN_REGTEST_FIRST_BLOCK_HASH).unwrap(),
+    );
+    burnchain.pox_constants = pox_constants.clone();
+
+    let first_v3_cycle = burnchain
+        .block_height_to_reward_cycle(burnchain.pox_constants.pox_3_activation_height as u64)
+        .unwrap()
+        + 1;
+
+    let (mut peer, mut keys) =
+        instantiate_pox_peer_with_epoch(&burnchain, function_name!(), Some(epochs.clone()), None);
+
+    peer.config.check_pox_invariants = Some((first_v3_cycle, first_v3_cycle + 10));
+
+    let mut coinbase_nonce = 0;
+    let alice = keys.pop().unwrap();
+    let bob = keys.pop().unwrap();
+    let charlie = keys.pop().unwrap();
+    let danielle = keys.pop().unwrap();
+    let alice_address = key_to_stacks_addr(&alice);
+    let bob_address = key_to_stacks_addr(&bob);
+    let charlie_address = key_to_stacks_addr(&charlie);
+    let LOCKUP_AMT = 1024 * POX_THRESHOLD_STEPS_USTX;
+
+    // first tenure is empty
+    let mut latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+
+    // Roll to Epoch-2.4 and perform the delegate-stack-extend tests
+    while get_tip(peer.sortdb.as_ref()).block_height <= epochs[6].start_height {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    }
+
+    let tip = get_tip(peer.sortdb.as_ref());
+    let cur_reward_cycle = burnchain
+        .block_height_to_reward_cycle(tip.block_height)
+        .unwrap();
+
+    // alice delegates to charlie in v3 to a valid address
+    let alice_delegation = make_pox_3_contract_call(
+        &alice,
+        0,
+        "delegate-stx",
+        vec![
+            Value::UInt(LOCKUP_AMT),
+            PrincipalData::from(charlie_address.clone()).into(),
+            Value::none(),
+            Value::some(make_pox_addr(
+                AddressHashMode::SerializeP2PKH,
+                alice_address.bytes.clone(),
+            ))
+            .unwrap(),
+        ],
+    );
+
+    let bob_bad_pox_addr = Value::Tuple(
+        TupleData::from_data(vec![
+            (
+                ClarityName::try_from("version".to_owned()).unwrap(),
+                Value::buff_from_byte(0xff),
+            ),
+            (
+                ClarityName::try_from("hashbytes".to_owned()).unwrap(),
+                Value::Sequence(SequenceData::Buffer(BuffData {
+                    data: bob_address.bytes.as_bytes().to_vec(),
+                })),
+            ),
+        ])
+        .unwrap(),
+    );
+
+    // bob delegates to charlie in v3 with an invalid address
+    let bob_delegation = make_pox_3_contract_call(
+        &bob,
+        0,
+        "delegate-stx",
+        vec![
+            Value::UInt(LOCKUP_AMT),
+            PrincipalData::from(charlie_address.clone()).into(),
+            Value::none(),
+            Value::some(bob_bad_pox_addr).unwrap(),
+        ],
+    );
+
+    peer.tenure_with_txs(&[alice_delegation, bob_delegation], &mut coinbase_nonce);
+
+    let result = eval_at_tip(
+        &mut peer,
+        "pox-3",
+        &format!(
+            "
+    {{
+        ;; should be (some $charlie_address)
+        get-delegation-info-alice: (get-delegation-info '{}),
+        ;; should be none
+        get-delegation-info-bob: (get-delegation-info '{}),
+    }}",
+            &alice_address, &bob_address,
+        ),
+    );
+
+    eprintln!("{}", &result);
+    let data = result.expect_tuple().data_map;
+
+    // bob had an invalid PoX address
+    let bob_delegation_info = data
+        .get("get-delegation-info-bob")
+        .cloned()
+        .unwrap()
+        .expect_optional();
+    assert!(bob_delegation_info.is_none());
+
+    // alice was valid
+    let alice_delegation_info = data
+        .get("get-delegation-info-alice")
+        .cloned()
+        .unwrap()
+        .expect_optional()
+        .unwrap()
+        .expect_tuple()
+        .data_map;
+    let alice_delegation_addr = alice_delegation_info
+        .get("delegated-to")
+        .cloned()
+        .unwrap()
+        .expect_principal();
+    let alice_delegation_amt = alice_delegation_info
+        .get("amount-ustx")
+        .cloned()
+        .unwrap()
+        .expect_u128();
+    let alice_pox_addr_opt = alice_delegation_info
+        .get("pox-addr")
+        .cloned()
+        .unwrap()
+        .expect_optional();
+    assert_eq!(
+        alice_delegation_addr,
+        charlie_address.to_account_principal()
+    );
+    assert_eq!(alice_delegation_amt, LOCKUP_AMT as u128);
+    assert!(alice_pox_addr_opt.is_some());
+
+    let alice_pox_addr = alice_pox_addr_opt.unwrap();
+
+    assert_eq!(
+        alice_pox_addr,
+        make_pox_addr(AddressHashMode::SerializeP2PKH, alice_address.bytes.clone(),)
+    );
+}

From d7ed20ea7e6107e55c96d7aa127aa3efbcbb8606 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Mon, 4 Dec 2023 17:29:20 -0500
Subject: [PATCH 0159/1166] fix: `pox_4_tests::get_pox_addrs()` works

---
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 60 ++++++-------------
 1 file changed, 18 insertions(+), 42 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 02fa4758c2..cd039f1c59 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -74,8 +74,7 @@ fn make_test_epochs_pox() -> (Vec<StacksEpoch>, PoxConstants) {
                                                  // epoch-2.4 will start at the first block of cycle 11!
                                                  //  this means that cycle 11 should also be treated like a "burn"
     let EPOCH_2_4_HEIGHT = EPOCH_2_2_HEIGHT + 6; // 56
-    let EPOCH_2_5_HEIGHT = EPOCH_2_4_HEIGHT + 13; // 69
-    let EPOCH_3_0_HEIGHT = EPOCH_2_5_HEIGHT + 7; // 76
+    let EPOCH_2_5_HEIGHT = EPOCH_2_4_HEIGHT + 14; // 70
 
     let epochs = vec![
         StacksEpoch {
@@ -130,16 +129,9 @@ fn make_test_epochs_pox() -> (Vec<StacksEpoch>, PoxConstants) {
         StacksEpoch {
             epoch_id: StacksEpochId::Epoch25,
             start_height: EPOCH_2_5_HEIGHT,
-            end_height: EPOCH_3_0_HEIGHT,
-            block_limit: ExecutionCost::max_value(),
-            network_epoch: PEER_VERSION_EPOCH_2_5,
-        },
-        StacksEpoch {
-            epoch_id: StacksEpochId::Epoch30,
-            start_height: EPOCH_3_0_HEIGHT,
             end_height: STACKS_EPOCH_MAX,
             block_limit: ExecutionCost::max_value(),
-            network_epoch: PEER_VERSION_EPOCH_3_0,
+            network_epoch: PEER_VERSION_EPOCH_2_5,
         },
     ];
 
@@ -151,7 +143,7 @@ fn make_test_epochs_pox() -> (Vec<StacksEpoch>, PoxConstants) {
     pox_constants.v2_unlock_height = (EPOCH_2_2_HEIGHT + 1) as u32;
     pox_constants.v3_unlock_height = (EPOCH_2_5_HEIGHT + 1) as u32;
     pox_constants.pox_3_activation_height = (EPOCH_2_4_HEIGHT + 1) as u32;
-    pox_constants.pox_4_activation_height = (EPOCH_3_0_HEIGHT + 1) as u32;
+    pox_constants.pox_4_activation_height = (EPOCH_2_5_HEIGHT + 1 + 14) as u32; // Activate pox4 in epoch 2.5, avoids nakamoto blocks
 
     (epochs, pox_constants)
 }
@@ -3397,6 +3389,11 @@ fn get_pox_addrs() {
         .unwrap()
         + 1;
 
+    let first_v4_cycle = burnchain
+        .block_height_to_reward_cycle(burnchain.pox_constants.pox_4_activation_height as u64)
+        .unwrap()
+        + 1;
+
     let (mut peer, keys) =
         instantiate_pox_peer_with_epoch(&burnchain, function_name!(), Some(epochs.clone()), None);
 
@@ -3474,36 +3471,10 @@ fn get_pox_addrs() {
         }
     }
 
-    let mut txs = vec![];
-    let tip_height = get_tip(peer.sortdb.as_ref()).block_height;
-    let stackers: Vec<_> = keys
-        .iter()
-        .zip([
-            AddressHashMode::SerializeP2PKH,
-            AddressHashMode::SerializeP2SH,
-            AddressHashMode::SerializeP2WPKH,
-            AddressHashMode::SerializeP2WSH,
-        ])
-        .map(|(key, hash_mode)| {
-            let pox_addr = PoxAddress::from_legacy(hash_mode, key_to_stacks_addr(key).bytes);
-            txs.push(make_pox_3_lockup(
-                key,
-                0,
-                1024 * POX_THRESHOLD_STEPS_USTX,
-                pox_addr.clone(),
-                1000,
-                tip_height,
-            ));
-            pox_addr
-        })
-        .collect();
-
-    let mut latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
-    assert_latest_was_burn(&mut peer);
+    let mut latest_block;
 
     // Wait to almost pox 4 and lock STX
-    let target_height =
-        burnchain.pox_constants.pox_4_activation_height - burnchain.pox_constants.prepare_length;
+    let target_height = burnchain.reward_cycle_to_block_height(first_v4_cycle) - 3;
     // produce blocks until the first reward phase that everyone should be in
     while get_tip(peer.sortdb.as_ref()).block_height < u64::from(target_height) {
         latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
@@ -3526,16 +3497,21 @@ fn get_pox_addrs() {
                 0,
                 1024 * POX_THRESHOLD_STEPS_USTX,
                 pox_addr.clone(),
-                1000,
+                3,
                 tip_height,
             ));
             pox_addr
         })
         .collect();
 
-    let mut latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
+    // Submit txs
+    latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
 
-    return;
+    // Go into PoX4
+    let target_height = burnchain.reward_cycle_to_block_height(first_v4_cycle) + 5;
+    while get_tip(peer.sortdb.as_ref()).block_height < u64::from(target_height) {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    }
 
     // now we should be in the reward phase, produce the reward blocks
     let reward_blocks =

From 9f4ec0c9d91a2481745ccd964df35890b1aa69d4 Mon Sep 17 00:00:00 2001
From: Nikos Baxevanis <nikos.baxevanis@gmail.com>
Date: Tue, 5 Dec 2023 17:14:06 +0100
Subject: [PATCH 0160/1166] cleanup: Remove obsolete cycle calculation code for
 versions 2 and 3

---
 stackslib/src/chainstate/stacks/boot/pox_4_tests.rs | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index cd039f1c59..78e0af60d8 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -3379,16 +3379,6 @@ fn get_pox_addrs() {
     );
     burnchain.pox_constants = pox_constants.clone();
 
-    let first_v2_cycle = burnchain
-        .block_height_to_reward_cycle(burnchain.pox_constants.v1_unlock_height as u64)
-        .unwrap()
-        + 1;
-
-    let first_v3_cycle = burnchain
-        .block_height_to_reward_cycle(burnchain.pox_constants.pox_3_activation_height as u64)
-        .unwrap()
-        + 1;
-
     let first_v4_cycle = burnchain
         .block_height_to_reward_cycle(burnchain.pox_constants.pox_4_activation_height as u64)
         .unwrap()

From 55791ef5bc4c62e54f2117534598702967dd51ee Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Thu, 7 Dec 2023 12:50:54 -0500
Subject: [PATCH 0161/1166] Cleanup `pox_4_tests::get_pox_addrs()`

---
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 123 ++++++------------
 1 file changed, 43 insertions(+), 80 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 78e0af60d8..afd225bf9c 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -3365,11 +3365,13 @@ fn get_burn_pox_addr_info(peer: &mut TestPeer) -> (Vec<PoxAddress>, u128) {
     (addrs, payout)
 }
 
+/// Test that we can lock STX for a couple cycles after pox4 starts,
+/// and that it unlocks after the desired number of cycles
 #[test]
 fn get_pox_addrs() {
-    // the sim environment produces 25 empty sortitions before
-    //  tenures start being tracked.
-    let EMPTY_SORTITIONS = 25;
+    // Config for this test
+    // We are going to try locking for 2 reward cycles (10 blocks)
+    let lock_period = 2;
 
     let (epochs, pox_constants) = make_test_epochs_pox();
 
@@ -3379,11 +3381,6 @@ fn get_pox_addrs() {
     );
     burnchain.pox_constants = pox_constants.clone();
 
-    let first_v4_cycle = burnchain
-        .block_height_to_reward_cycle(burnchain.pox_constants.pox_4_activation_height as u64)
-        .unwrap()
-        + 1;
-
     let (mut peer, keys) =
         instantiate_pox_peer_with_epoch(&burnchain, function_name!(), Some(epochs.clone()), None);
 
@@ -3451,23 +3448,17 @@ fn get_pox_addrs() {
         addrs
     };
 
-    // Wait to pox 3 and lock STX
-    let target_height = burnchain.pox_constants.pox_3_activation_height;
-    while get_tip(peer.sortdb.as_ref()).block_height <= u64::from(target_height) {
-        peer.tenure_with_txs(&[], &mut coinbase_nonce);
-        // if we reach epoch 2.1, perform the check
-        if get_tip(peer.sortdb.as_ref()).block_height > epochs[3].start_height {
-            assert_latest_was_burn(&mut peer);
-        }
-    }
-
     let mut latest_block;
 
-    // Wait to almost pox 4 and lock STX
-    let target_height = burnchain.reward_cycle_to_block_height(first_v4_cycle) - 3;
+    // Advance into pox4
+    let target_height = burnchain.pox_constants.pox_4_activation_height;
     // produce blocks until the first reward phase that everyone should be in
     while get_tip(peer.sortdb.as_ref()).block_height < u64::from(target_height) {
         latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+        // if we reach epoch 2.1, perform the check
+        if get_tip(peer.sortdb.as_ref()).block_height > epochs[3].start_height {
+            assert_latest_was_burn(&mut peer);
+        }
     }
 
     let mut txs = vec![];
@@ -3487,18 +3478,18 @@ fn get_pox_addrs() {
                 0,
                 1024 * POX_THRESHOLD_STEPS_USTX,
                 pox_addr.clone(),
-                3,
+                lock_period,
                 tip_height,
             ));
             pox_addr
         })
         .collect();
 
-    // Submit txs
+    // Submit stacking txs
     latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
 
-    // Go into PoX4
-    let target_height = burnchain.reward_cycle_to_block_height(first_v4_cycle) + 5;
+    // Advance to start of rewards cycle stackers are participating in
+    let target_height = burnchain.pox_constants.pox_4_activation_height + 6;
     while get_tip(peer.sortdb.as_ref()).block_height < u64::from(target_height) {
         latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
     }
@@ -3507,69 +3498,41 @@ fn get_pox_addrs() {
     let reward_blocks =
         burnchain.pox_constants.reward_cycle_length - burnchain.pox_constants.prepare_length;
     let mut rewarded = HashSet::new();
-    for i in 0..reward_blocks {
-        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-        // only the first 2 reward blocks contain pox outputs, because there are 6 slots and only 4 are occuppied
-        if i < 2 {
-            assert_latest_was_pox(&mut peer)
-                .into_iter()
-                .filter(|addr| !addr.is_burn())
-                .for_each(|addr| {
-                    rewarded.insert(addr);
-                });
-        } else {
-            assert_latest_was_burn(&mut peer);
-        }
-    }
 
-    assert_eq!(rewarded.len(), 4);
-    for stacker in stackers.iter() {
-        assert!(
-            rewarded.contains(stacker),
-            "Reward cycle should include {}",
-            stacker
-        );
-    }
+    // Check that STX are locked for 2 reward cycles
+    for _ in 0..lock_period {
+        for i in 0..reward_blocks {
+            latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+            // only the first 2 reward blocks contain pox outputs, because there are 6 slots and only 4 are occuppied
+            if i < 2 {
+                assert_latest_was_pox(&mut peer)
+                    .into_iter()
+                    .filter(|addr| !addr.is_burn())
+                    .for_each(|addr| {
+                        rewarded.insert(addr);
+                    });
+            } else {
+                assert_latest_was_burn(&mut peer);
+            }
+        }
 
-    // now we should be back in a prepare phase
-    for _i in 0..burnchain.pox_constants.prepare_length {
-        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-        assert_latest_was_burn(&mut peer);
-    }
+        assert_eq!(rewarded.len(), 4);
+        for stacker in stackers.iter() {
+            assert!(
+                rewarded.contains(stacker),
+                "Reward cycle should include {}",
+                stacker
+            );
+        }
 
-    // now we should be in the reward phase, produce the reward blocks
-    let mut rewarded = HashSet::new();
-    for i in 0..reward_blocks {
-        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-        // only the first 2 reward blocks contain pox outputs, because there are 6 slots and only 4 are occuppied
-        if i < 2 {
-            assert_latest_was_pox(&mut peer)
-                .into_iter()
-                .filter(|addr| !addr.is_burn())
-                .for_each(|addr| {
-                    rewarded.insert(addr);
-                });
-        } else {
+        // now we should be back in a prepare phase
+        for _i in 0..burnchain.pox_constants.prepare_length {
+            latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
             assert_latest_was_burn(&mut peer);
         }
     }
 
-    assert_eq!(rewarded.len(), 4);
-    for stacker in stackers.iter() {
-        assert!(
-            rewarded.contains(stacker),
-            "Reward cycle should include {}",
-            stacker
-        );
-    }
-
-    // now we should be back in a prepare phase
-    for _i in 0..burnchain.pox_constants.prepare_length {
-        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-        assert_latest_was_burn(&mut peer);
-    }
-
-    // now we're in the next reward cycle, but everyone is unstacked
+    // STX should now be unlocked after 2 cycles
     for _i in 0..burnchain.pox_constants.reward_cycle_length {
         latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
         assert_latest_was_burn(&mut peer);

From 9278b000b4bc6940e762c9bce9d4191bf4ccd909 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Fri, 8 Dec 2023 09:08:15 -0500
Subject: [PATCH 0162/1166] Adjust `EPOCH_2_5_HEIGHT` to make `pox_4_tests`
 pass

---
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 103 +++++++++++-------
 1 file changed, 64 insertions(+), 39 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index afd225bf9c..fc9ecc03e2 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -73,8 +73,8 @@ fn make_test_epochs_pox() -> (Vec<StacksEpoch>, PoxConstants) {
     let EPOCH_2_3_HEIGHT = EPOCH_2_2_HEIGHT + 2; // 52
                                                  // epoch-2.4 will start at the first block of cycle 11!
                                                  //  this means that cycle 11 should also be treated like a "burn"
-    let EPOCH_2_4_HEIGHT = EPOCH_2_2_HEIGHT + 6; // 56
-    let EPOCH_2_5_HEIGHT = EPOCH_2_4_HEIGHT + 14; // 70
+    let EPOCH_2_4_HEIGHT = EPOCH_2_3_HEIGHT + 4; // 56
+    let EPOCH_2_5_HEIGHT = EPOCH_2_4_HEIGHT + 44; // 100
 
     let epochs = vec![
         StacksEpoch {
@@ -2194,7 +2194,7 @@ fn pox_extend_transition() {
 
     // check the stacking minimum
     let total_liquid_ustx = get_liquid_ustx(&mut peer);
-    let min_ustx = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
+    let min_ustx = with_sortdb(&mut peer, |chainstate, sortdb| {
         chainstate.get_stacking_minimum(sortdb, &tip_index_block)
     })
     .unwrap();
@@ -2204,7 +2204,7 @@ fn pox_extend_transition() {
     );
 
     // no reward addresses
-    let reward_addrs = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
+    let reward_addrs = with_sortdb(&mut peer, |chainstate, sortdb| {
         get_reward_addresses_with_par_tip(chainstate, &burnchain, sortdb, &tip_index_block)
     })
     .unwrap();
@@ -2418,7 +2418,7 @@ fn pox_extend_transition() {
             reward_set_entries[0].reward_address.bytes(),
             key_to_stacks_addr(&alice).bytes.0.to_vec()
         );
-        assert_eq!(reward_set_entries[0].amount_stacked, ALICE_LOCKUP,);
+        assert_eq!(reward_set_entries[0].amount_stacked, ALICE_LOCKUP);
     }
 
     for cycle_number in (first_v3_cycle + 1)..(first_v3_cycle + 4) {
@@ -2429,12 +2429,12 @@ fn pox_extend_transition() {
             reward_set_entries[1].reward_address.bytes(),
             key_to_stacks_addr(&alice).bytes.0.to_vec()
         );
-        assert_eq!(reward_set_entries[1].amount_stacked, ALICE_LOCKUP,);
+        assert_eq!(reward_set_entries[1].amount_stacked, ALICE_LOCKUP);
         assert_eq!(
             reward_set_entries[0].reward_address.bytes(),
             key_to_stacks_addr(&bob).bytes.0.to_vec()
         );
-        assert_eq!(reward_set_entries[0].amount_stacked, BOB_LOCKUP,);
+        assert_eq!(reward_set_entries[0].amount_stacked, BOB_LOCKUP);
     }
 
     for cycle_number in (first_v3_cycle + 4)..(first_v3_cycle + 10) {
@@ -2445,7 +2445,7 @@ fn pox_extend_transition() {
             reward_set_entries[0].reward_address.bytes(),
             key_to_stacks_addr(&alice).bytes.0.to_vec()
         );
-        assert_eq!(reward_set_entries[0].amount_stacked, ALICE_LOCKUP,);
+        assert_eq!(reward_set_entries[0].amount_stacked, ALICE_LOCKUP);
     }
 
     // now let's check some tx receipts
@@ -3369,10 +3369,6 @@ fn get_burn_pox_addr_info(peer: &mut TestPeer) -> (Vec<PoxAddress>, u128) {
 /// and that it unlocks after the desired number of cycles
 #[test]
 fn get_pox_addrs() {
-    // Config for this test
-    // We are going to try locking for 2 reward cycles (10 blocks)
-    let lock_period = 2;
-
     let (epochs, pox_constants) = make_test_epochs_pox();
 
     let mut burnchain = Burnchain::default_unittest(
@@ -3478,7 +3474,7 @@ fn get_pox_addrs() {
                 0,
                 1024 * POX_THRESHOLD_STEPS_USTX,
                 pox_addr.clone(),
-                lock_period,
+                2,
                 tip_height,
             ));
             pox_addr
@@ -3499,39 +3495,68 @@ fn get_pox_addrs() {
         burnchain.pox_constants.reward_cycle_length - burnchain.pox_constants.prepare_length;
     let mut rewarded = HashSet::new();
 
-    // Check that STX are locked for 2 reward cycles
-    for _ in 0..lock_period {
-        for i in 0..reward_blocks {
-            latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-            // only the first 2 reward blocks contain pox outputs, because there are 6 slots and only 4 are occuppied
-            if i < 2 {
-                assert_latest_was_pox(&mut peer)
-                    .into_iter()
-                    .filter(|addr| !addr.is_burn())
-                    .for_each(|addr| {
-                        rewarded.insert(addr);
-                    });
-            } else {
-                assert_latest_was_burn(&mut peer);
-            }
+    // Check that STX are locked for first reward cycle
+    for i in 0..reward_blocks {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+        // only the first 2 reward blocks contain pox outputs, because there are 6 slots and only 4 are occuppied
+        if i < 2 {
+            assert_latest_was_pox(&mut peer)
+                .into_iter()
+                .filter(|addr| !addr.is_burn())
+                .for_each(|addr| {
+                    rewarded.insert(addr);
+                });
+        } else {
+            assert_latest_was_burn(&mut peer);
         }
+    }
 
-        assert_eq!(rewarded.len(), 4);
-        for stacker in stackers.iter() {
-            assert!(
-                rewarded.contains(stacker),
-                "Reward cycle should include {}",
-                stacker
-            );
-        }
+    assert_eq!(rewarded.len(), 4);
+    for stacker in stackers.iter() {
+        assert!(
+            rewarded.contains(stacker),
+            "Reward cycle should include {}",
+            stacker
+        );
+    }
+
+    // now we should be back in a prepare phase
+    for _i in 0..burnchain.pox_constants.prepare_length {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+        assert_latest_was_burn(&mut peer);
+    }
 
-        // now we should be back in a prepare phase
-        for _i in 0..burnchain.pox_constants.prepare_length {
-            latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    // Check that STX are locked for second reward cycle
+    for i in 0..reward_blocks {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+        // only the first 2 reward blocks contain pox outputs, because there are 6 slots and only 4 are occuppied
+        if i < 2 {
+            assert_latest_was_pox(&mut peer)
+                .into_iter()
+                .filter(|addr| !addr.is_burn())
+                .for_each(|addr| {
+                    rewarded.insert(addr);
+                });
+        } else {
             assert_latest_was_burn(&mut peer);
         }
     }
 
+    assert_eq!(rewarded.len(), 4);
+    for stacker in stackers.iter() {
+        assert!(
+            rewarded.contains(stacker),
+            "Reward cycle should include {}",
+            stacker
+        );
+    }
+
+    // now we should be back in a prepare phase
+    for _i in 0..burnchain.pox_constants.prepare_length {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+        assert_latest_was_burn(&mut peer);
+    }
+
     // STX should now be unlocked after 2 cycles
     for _i in 0..burnchain.pox_constants.reward_cycle_length {
         latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);

From 769ff95469c93a596a8314b4d3d828bea1e22e91 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Fri, 8 Dec 2023 10:52:40 -0500
Subject: [PATCH 0163/1166] Add logs in `pox_4_addrs`

---
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 96 ++++++++-----------
 1 file changed, 38 insertions(+), 58 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index fc9ecc03e2..fceb6e9ef0 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -3369,6 +3369,9 @@ fn get_burn_pox_addr_info(peer: &mut TestPeer) -> (Vec<PoxAddress>, u128) {
 /// and that it unlocks after the desired number of cycles
 #[test]
 fn get_pox_addrs() {
+    // Config for this test
+    // We are going to try locking for 2 reward cycles (10 blocks)
+    let lock_period = 2;
     let (epochs, pox_constants) = make_test_epochs_pox();
 
     let mut burnchain = Burnchain::default_unittest(
@@ -3457,6 +3460,8 @@ fn get_pox_addrs() {
         }
     }
 
+    info!("Block height: {}", get_tip(peer.sortdb.as_ref()).block_height);
+
     let mut txs = vec![];
     let tip_height = get_tip(peer.sortdb.as_ref()).block_height;
     let stackers: Vec<_> = keys
@@ -3474,14 +3479,14 @@ fn get_pox_addrs() {
                 0,
                 1024 * POX_THRESHOLD_STEPS_USTX,
                 pox_addr.clone(),
-                2,
+                lock_period,
                 tip_height,
             ));
             pox_addr
         })
         .collect();
 
-    // Submit stacking txs
+    info!("Submitting stacking txs");
     latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
 
     // Advance to start of rewards cycle stackers are participating in
@@ -3490,74 +3495,49 @@ fn get_pox_addrs() {
         latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
     }
 
+    info!("Block height: {}", get_tip(peer.sortdb.as_ref()).block_height);
+
     // now we should be in the reward phase, produce the reward blocks
     let reward_blocks =
         burnchain.pox_constants.reward_cycle_length - burnchain.pox_constants.prepare_length;
     let mut rewarded = HashSet::new();
 
-    // Check that STX are locked for first reward cycle
-    for i in 0..reward_blocks {
-        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-        // only the first 2 reward blocks contain pox outputs, because there are 6 slots and only 4 are occuppied
-        if i < 2 {
-            assert_latest_was_pox(&mut peer)
-                .into_iter()
-                .filter(|addr| !addr.is_burn())
-                .for_each(|addr| {
-                    rewarded.insert(addr);
-                });
-        } else {
-            assert_latest_was_burn(&mut peer);
+    // Check that STX are locked for 2 reward cycles
+    for c in 0..lock_period {
+        info!("Checking STX locked for cycle {c}");
+        for i in 0..reward_blocks {
+            latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+            // only the first 2 reward blocks contain pox outputs, because there are 6 slots and only 4 are occuppied
+            if i < 2 {
+                assert_latest_was_pox(&mut peer)
+                    .into_iter()
+                    .filter(|addr| !addr.is_burn())
+                    .for_each(|addr| {
+                        rewarded.insert(addr);
+                    });
+            } else {
+                assert_latest_was_burn(&mut peer);
+            }
         }
-    }
 
-    assert_eq!(rewarded.len(), 4);
-    for stacker in stackers.iter() {
-        assert!(
-            rewarded.contains(stacker),
-            "Reward cycle should include {}",
-            stacker
-        );
-    }
-
-    // now we should be back in a prepare phase
-    for _i in 0..burnchain.pox_constants.prepare_length {
-        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-        assert_latest_was_burn(&mut peer);
-    }
+        assert_eq!(rewarded.len(), 4);
+        for stacker in stackers.iter() {
+            assert!(
+                rewarded.contains(stacker),
+                "Reward cycle should include {}",
+                stacker
+            );
+        }
 
-    // Check that STX are locked for second reward cycle
-    for i in 0..reward_blocks {
-        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-        // only the first 2 reward blocks contain pox outputs, because there are 6 slots and only 4 are occuppied
-        if i < 2 {
-            assert_latest_was_pox(&mut peer)
-                .into_iter()
-                .filter(|addr| !addr.is_burn())
-                .for_each(|addr| {
-                    rewarded.insert(addr);
-                });
-        } else {
+        // now we should be back in a prepare phase
+        info!("Checking we are in prepare phase");
+        for _i in 0..burnchain.pox_constants.prepare_length {
+            latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
             assert_latest_was_burn(&mut peer);
         }
     }
 
-    assert_eq!(rewarded.len(), 4);
-    for stacker in stackers.iter() {
-        assert!(
-            rewarded.contains(stacker),
-            "Reward cycle should include {}",
-            stacker
-        );
-    }
-
-    // now we should be back in a prepare phase
-    for _i in 0..burnchain.pox_constants.prepare_length {
-        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-        assert_latest_was_burn(&mut peer);
-    }
-
-    // STX should now be unlocked after 2 cycles
+    info!("Checking STX unlocked after {lock_period} cycles");
     for _i in 0..burnchain.pox_constants.reward_cycle_length {
         latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
         assert_latest_was_burn(&mut peer);

From 4e9220b953b48dc53b294516beef30d737fd732b Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Fri, 8 Dec 2023 13:58:10 -0500
Subject: [PATCH 0164/1166] Modify `pox_extend_transition()` to use pox4

---
 stackslib/src/chainstate/stacks/boot/mod.rs   | 18 ++++
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 82 ++++++++++++-------
 2 files changed, 69 insertions(+), 31 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 52eef5813c..887dd20900 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -1782,6 +1782,24 @@ pub mod test {
         make_tx(key, nonce, 0, payload)
     }
 
+    pub fn make_pox_4_extend(
+        key: &StacksPrivateKey,
+        nonce: u64,
+        addr: PoxAddress,
+        lock_period: u128,
+    ) -> StacksTransaction {
+        let addr_tuple = Value::Tuple(addr.as_clarity_tuple().unwrap());
+        let payload = TransactionPayload::new_contract_call(
+            boot_code_test_addr(),
+            POX_4_NAME,
+            "stack-extend",
+            vec![Value::UInt(lock_period), addr_tuple],
+        )
+        .unwrap();
+
+        make_tx(key, nonce, 0, payload)
+    }
+
     fn make_tx(
         key: &StacksPrivateKey,
         nonce: u64,
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index fceb6e9ef0..f563d92186 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -143,7 +143,10 @@ fn make_test_epochs_pox() -> (Vec<StacksEpoch>, PoxConstants) {
     pox_constants.v2_unlock_height = (EPOCH_2_2_HEIGHT + 1) as u32;
     pox_constants.v3_unlock_height = (EPOCH_2_5_HEIGHT + 1) as u32;
     pox_constants.pox_3_activation_height = (EPOCH_2_4_HEIGHT + 1) as u32;
-    pox_constants.pox_4_activation_height = (EPOCH_2_5_HEIGHT + 1 + 14) as u32; // Activate pox4 in epoch 2.5, avoids nakamoto blocks
+    // Activate pox4 2 cycles into epoch 2.5
+    // Don't use Epoch 3.0 in order to avoid nakamoto blocks
+    pox_constants.pox_4_activation_height =
+        (EPOCH_2_5_HEIGHT as u32) + 1 + (2 * pox_constants.reward_cycle_length);
 
     (epochs, pox_constants)
 }
@@ -2054,6 +2057,11 @@ fn pox_extend_transition() {
         .unwrap()
         + 1;
 
+    let first_v4_cycle = burnchain
+        .block_height_to_reward_cycle(burnchain.pox_constants.pox_4_activation_height as u64)
+        .unwrap()
+        + 1;
+
     assert_eq!(first_v2_cycle, EXPECTED_FIRST_V2_CYCLE);
 
     let observer = TestEventObserver::new();
@@ -2297,8 +2305,6 @@ fn pox_extend_transition() {
     latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
     v2_rewards_checks(latest_block, &mut peer);
 
-    // Roll to Epoch-2.4 and re-do the above tests
-
     // roll the chain forward until just before Epoch-2.2
     while get_tip(peer.sortdb.as_ref()).block_height < epochs[4].start_height {
         latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
@@ -2326,13 +2332,15 @@ fn pox_extend_transition() {
     assert_eq!(bob_account.amount_locked(), 0);
     assert_eq!(bob_account.amount_unlocked(), INITIAL_BALANCE);
 
-    // Roll to Epoch-2.4 and re-do the above stack-extend tests
-    while get_tip(peer.sortdb.as_ref()).block_height <= epochs[6].start_height {
+    // Roll to pox4 activation and re-do the above stack-extend tests
+    while get_tip(peer.sortdb.as_ref()).block_height
+        < u64::from(burnchain.pox_constants.pox_4_activation_height)
+    {
         latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
     }
 
     let tip = get_tip(peer.sortdb.as_ref());
-    let alice_lockup = make_pox_3_lockup(
+    let alice_lockup = make_pox_4_lockup(
         &alice,
         2,
         ALICE_LOCKUP,
@@ -2343,17 +2351,23 @@ fn pox_extend_transition() {
         4,
         tip.block_height,
     );
-    let alice_pox_3_lock_nonce = 2;
-    let alice_first_pox_3_unlock_height =
-        burnchain.reward_cycle_to_block_height(first_v3_cycle + 4) - 1;
-    let alice_pox_3_start_burn_height = tip.block_height;
+    let alice_pox_4_lock_nonce = 2;
+    let alice_first_pox_4_unlock_height =
+        burnchain.reward_cycle_to_block_height(first_v4_cycle + 4) - 1;
+    let alice_pox_4_start_burn_height = tip.block_height;
 
     latest_block = peer.tenure_with_txs(&[alice_lockup], &mut coinbase_nonce);
 
+    info!(
+        "Block height: {}",
+        get_tip(peer.sortdb.as_ref()).block_height
+    );
+
     // check that the "raw" reward set will contain entries for alice at the cycle start
-    for cycle_number in first_v3_cycle..(first_v3_cycle + 4) {
+    for cycle_number in first_v4_cycle..(first_v4_cycle + 4) {
         let cycle_start = burnchain.reward_cycle_to_block_height(cycle_number);
         let reward_set_entries = get_reward_set_entries_at(&mut peer, &latest_block, cycle_start);
+        info!("----- {cycle_number} -----");
         assert_eq!(reward_set_entries.len(), 1);
         assert_eq!(
             reward_set_entries[0].reward_address.bytes(),
@@ -2364,11 +2378,11 @@ fn pox_extend_transition() {
 
     // check the first reward cycle when Alice's tokens get stacked
     let tip_burn_block_height = get_par_burn_block_height(peer.chainstate(), &latest_block);
-    let alice_first_v3_reward_cycle = 1 + burnchain
+    let alice_first_v4_reward_cycle = 1 + burnchain
         .block_height_to_reward_cycle(tip_burn_block_height)
         .unwrap();
 
-    let height_target = burnchain.reward_cycle_to_block_height(alice_first_v3_reward_cycle) + 1;
+    let height_target = burnchain.reward_cycle_to_block_height(alice_first_v4_reward_cycle) + 1;
 
     // alice locked, so balance should be 0
     let alice_balance = get_balance(&mut peer, &alice_principal);
@@ -2380,7 +2394,7 @@ fn pox_extend_transition() {
     }
 
     let tip = get_tip(peer.sortdb.as_ref());
-    let bob_lockup = make_pox_3_lockup(
+    let bob_lockup = make_pox_4_lockup(
         &bob,
         2,
         BOB_LOCKUP,
@@ -2393,7 +2407,7 @@ fn pox_extend_transition() {
     );
 
     // Alice can stack-extend in PoX v2
-    let alice_lockup = make_pox_3_extend(
+    let alice_lockup = make_pox_4_extend(
         &alice,
         3,
         PoxAddress::from_legacy(
@@ -2403,14 +2417,14 @@ fn pox_extend_transition() {
         6,
     );
 
-    let alice_pox_3_extend_nonce = 3;
-    let alice_extend_pox_3_unlock_height =
-        burnchain.reward_cycle_to_block_height(first_v3_cycle + 10) - 1;
+    let alice_pox_4_extend_nonce = 3;
+    let alice_extend_pox_4_unlock_height =
+        burnchain.reward_cycle_to_block_height(first_v4_cycle + 10) - 1;
 
     latest_block = peer.tenure_with_txs(&[bob_lockup, alice_lockup], &mut coinbase_nonce);
 
     // check that the "raw" reward set will contain entries for alice at the cycle start
-    for cycle_number in first_v3_cycle..(first_v3_cycle + 1) {
+    for cycle_number in first_v4_cycle..(first_v4_cycle + 1) {
         let cycle_start = burnchain.reward_cycle_to_block_height(cycle_number);
         let reward_set_entries = get_reward_set_entries_at(&mut peer, &latest_block, cycle_start);
         assert_eq!(reward_set_entries.len(), 1);
@@ -2421,7 +2435,7 @@ fn pox_extend_transition() {
         assert_eq!(reward_set_entries[0].amount_stacked, ALICE_LOCKUP);
     }
 
-    for cycle_number in (first_v3_cycle + 1)..(first_v3_cycle + 4) {
+    for cycle_number in (first_v4_cycle + 1)..(first_v4_cycle + 4) {
         let cycle_start = burnchain.reward_cycle_to_block_height(cycle_number);
         let reward_set_entries = get_reward_set_entries_at(&mut peer, &latest_block, cycle_start);
         assert_eq!(reward_set_entries.len(), 2);
@@ -2437,7 +2451,7 @@ fn pox_extend_transition() {
         assert_eq!(reward_set_entries[0].amount_stacked, BOB_LOCKUP);
     }
 
-    for cycle_number in (first_v3_cycle + 4)..(first_v3_cycle + 10) {
+    for cycle_number in (first_v4_cycle + 4)..(first_v4_cycle + 10) {
         let cycle_start = burnchain.reward_cycle_to_block_height(cycle_number);
         let reward_set_entries = get_reward_set_entries_at(&mut peer, &latest_block, cycle_start);
         assert_eq!(reward_set_entries.len(), 1);
@@ -2498,7 +2512,7 @@ fn pox_extend_transition() {
 
     // Check that the call to `stack-stx` has a well-formed print event.
     let stack_tx = &alice_txs
-        .get(&alice_pox_3_lock_nonce)
+        .get(&alice_pox_4_lock_nonce)
         .unwrap()
         .clone()
         .events[0];
@@ -2507,11 +2521,11 @@ fn pox_extend_transition() {
         ("lock-amount", Value::UInt(ALICE_LOCKUP)),
         (
             "unlock-burn-height",
-            Value::UInt(alice_first_pox_3_unlock_height.into()),
+            Value::UInt(alice_first_pox_4_unlock_height.into()),
         ),
         (
             "start-burn-height",
-            Value::UInt(alice_pox_3_start_burn_height.into()),
+            Value::UInt(alice_pox_4_start_burn_height.into()),
         ),
         ("pox-addr", pox_addr_val.clone()),
         ("lock-period", Value::UInt(4)),
@@ -2527,7 +2541,7 @@ fn pox_extend_transition() {
 
     // Check that the call to `stack-extend` has a well-formed print event.
     let stack_extend_tx = &alice_txs
-        .get(&alice_pox_3_extend_nonce)
+        .get(&alice_pox_4_extend_nonce)
         .unwrap()
         .clone()
         .events[0];
@@ -2536,7 +2550,7 @@ fn pox_extend_transition() {
         ("pox-addr", pox_addr_val),
         (
             "unlock-burn-height",
-            Value::UInt(alice_extend_pox_3_unlock_height.into()),
+            Value::UInt(alice_extend_pox_4_unlock_height.into()),
         ),
     ]);
     let common_data = PoxPrintFields {
@@ -2544,7 +2558,7 @@ fn pox_extend_transition() {
         stacker: Value::Principal(alice_principal.clone()),
         balance: Value::UInt(0),
         locked: Value::UInt(ALICE_LOCKUP),
-        burnchain_unlock_height: Value::UInt(alice_first_pox_3_unlock_height.into()),
+        burnchain_unlock_height: Value::UInt(alice_first_pox_4_unlock_height.into()),
     };
     check_pox_print_event(stack_extend_tx, common_data, stack_ext_op_data);
 }
@@ -3460,7 +3474,10 @@ fn get_pox_addrs() {
         }
     }
 
-    info!("Block height: {}", get_tip(peer.sortdb.as_ref()).block_height);
+    info!(
+        "Block height: {}",
+        get_tip(peer.sortdb.as_ref()).block_height
+    );
 
     let mut txs = vec![];
     let tip_height = get_tip(peer.sortdb.as_ref()).block_height;
@@ -3490,12 +3507,15 @@ fn get_pox_addrs() {
     latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
 
     // Advance to start of rewards cycle stackers are participating in
-    let target_height = burnchain.pox_constants.pox_4_activation_height + 6;
+    let target_height = burnchain.pox_constants.pox_4_activation_height + 5;
     while get_tip(peer.sortdb.as_ref()).block_height < u64::from(target_height) {
         latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
     }
 
-    info!("Block height: {}", get_tip(peer.sortdb.as_ref()).block_height);
+    info!(
+        "Block height: {}",
+        get_tip(peer.sortdb.as_ref()).block_height
+    );
 
     // now we should be in the reward phase, produce the reward blocks
     let reward_blocks =
@@ -3504,7 +3524,7 @@ fn get_pox_addrs() {
 
     // Check that STX are locked for 2 reward cycles
     for c in 0..lock_period {
-        info!("Checking STX locked for cycle {c}");
+        info!("Checking STX locked, iteration {}", c + 1);
         for i in 0..reward_blocks {
             latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
             // only the first 2 reward blocks contain pox outputs, because there are 6 slots and only 4 are occuppied

From ecefdf38dbc74a6e44e520244c55b19c4b877e50 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Fri, 8 Dec 2023 14:17:23 -0500
Subject: [PATCH 0165/1166] Rename `get_pox_addrs()` -> `pox_lock_unlock()`

---
 stackslib/src/chainstate/stacks/boot/pox_4_tests.rs | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index f563d92186..2624a7b650 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -989,9 +989,6 @@ fn pox_auto_unlock(alice_first: bool) {
 #[test]
 fn delegate_stack_increase() {
     let EXPECTED_FIRST_V2_CYCLE = 8;
-    // the sim environment produces 25 empty sortitions before
-    //  tenures start being tracked.
-    let EMPTY_SORTITIONS = 25;
 
     let (epochs, pox_constants) = make_test_epochs_pox();
 
@@ -3382,7 +3379,7 @@ fn get_burn_pox_addr_info(peer: &mut TestPeer) -> (Vec<PoxAddress>, u128) {
 /// Test that we can lock STX for a couple cycles after pox4 starts,
 /// and that it unlocks after the desired number of cycles
 #[test]
-fn get_pox_addrs() {
+fn pox_lock_unlock() {
     // Config for this test
     // We are going to try locking for 2 reward cycles (10 blocks)
     let lock_period = 2;

From b85e18af10c4466000f3f16039e6e985b7dc360f Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Fri, 8 Dec 2023 14:41:09 -0500
Subject: [PATCH 0166/1166] Add `pox_3_fails()`

---
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 165 ++++++++++++++++++
 1 file changed, 165 insertions(+)

diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 2624a7b650..beb4ecf9f9 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -3561,6 +3561,171 @@ fn pox_lock_unlock() {
     }
 }
 
+/// Test that pox3 methods fail once pox4 is activated
+#[test]
+fn pox_3_fails() {
+    // Config for this test
+    // We are going to try locking for 2 reward cycles (10 blocks)
+    let lock_period = 2;
+    let (epochs, pox_constants) = make_test_epochs_pox();
+
+    let mut burnchain = Burnchain::default_unittest(
+        0,
+        &BurnchainHeaderHash::from_hex(BITCOIN_REGTEST_FIRST_BLOCK_HASH).unwrap(),
+    );
+    burnchain.pox_constants = pox_constants.clone();
+
+    let (mut peer, keys) =
+        instantiate_pox_peer_with_epoch(&burnchain, function_name!(), Some(epochs.clone()), None);
+
+    assert_eq!(burnchain.pox_constants.reward_slots(), 6);
+    let mut coinbase_nonce = 0;
+
+    let assert_latest_was_burn = |peer: &mut TestPeer| {
+        let tip = get_tip(peer.sortdb.as_ref());
+        let tip_index_block = tip.get_canonical_stacks_block_id();
+        let burn_height = tip.block_height - 1;
+
+        let conn = peer.sortdb().conn();
+
+        // check the *parent* burn block, because that's what we'll be
+        //  checking with get_burn_pox_addr_info
+        let mut burn_ops =
+            SortitionDB::get_block_commits_by_block(conn, &tip.parent_sortition_id).unwrap();
+        assert_eq!(burn_ops.len(), 1);
+        let commit = burn_ops.pop().unwrap();
+        assert!(commit.all_outputs_burn());
+        assert!(commit.burn_fee > 0);
+
+        let (addrs, payout) = get_burn_pox_addr_info(peer);
+        let tip = get_tip(peer.sortdb.as_ref());
+        let tip_index_block = tip.get_canonical_stacks_block_id();
+        let burn_height = tip.block_height - 1;
+        info!("Checking burn outputs at burn_height = {}", burn_height);
+        if peer.config.burnchain.is_in_prepare_phase(burn_height) {
+            assert_eq!(addrs.len(), 1);
+            assert_eq!(payout, 1000);
+            assert!(addrs[0].is_burn());
+        } else {
+            assert_eq!(addrs.len(), 2);
+            assert_eq!(payout, 500);
+            assert!(addrs[0].is_burn());
+            assert!(addrs[1].is_burn());
+        }
+    };
+
+    let assert_latest_was_pox = |peer: &mut TestPeer| {
+        let tip = get_tip(peer.sortdb.as_ref());
+        let tip_index_block = tip.get_canonical_stacks_block_id();
+        let burn_height = tip.block_height - 1;
+
+        let conn = peer.sortdb().conn();
+
+        // check the *parent* burn block, because that's what we'll be
+        //  checking with get_burn_pox_addr_info
+        let mut burn_ops =
+            SortitionDB::get_block_commits_by_block(conn, &tip.parent_sortition_id).unwrap();
+        assert_eq!(burn_ops.len(), 1);
+        let commit = burn_ops.pop().unwrap();
+        assert!(!commit.all_outputs_burn());
+        let commit_addrs = commit.commit_outs;
+
+        let (addrs, payout) = get_burn_pox_addr_info(peer);
+        info!(
+            "Checking pox outputs at burn_height = {}, commit_addrs = {:?}, fetch_addrs = {:?}",
+            burn_height, commit_addrs, addrs
+        );
+        assert_eq!(addrs.len(), 2);
+        assert_eq!(payout, 500);
+        assert!(commit_addrs.contains(&addrs[0]));
+        assert!(commit_addrs.contains(&addrs[1]));
+        addrs
+    };
+
+    let mut latest_block;
+
+    // Advance into pox4
+    let target_height = burnchain.pox_constants.pox_4_activation_height;
+    // produce blocks until the first reward phase that everyone should be in
+    while get_tip(peer.sortdb.as_ref()).block_height < u64::from(target_height) {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+        // if we reach epoch 2.1, perform the check
+        if get_tip(peer.sortdb.as_ref()).block_height > epochs[3].start_height {
+            assert_latest_was_burn(&mut peer);
+        }
+    }
+
+    info!(
+        "Block height: {}",
+        get_tip(peer.sortdb.as_ref()).block_height
+    );
+
+    let mut txs = vec![];
+    let tip_height = get_tip(peer.sortdb.as_ref()).block_height;
+    let stackers: Vec<_> = keys
+        .iter()
+        .zip([
+            AddressHashMode::SerializeP2PKH,
+            AddressHashMode::SerializeP2SH,
+            AddressHashMode::SerializeP2WPKH,
+            AddressHashMode::SerializeP2WSH,
+        ])
+        .map(|(key, hash_mode)| {
+            let pox_addr = PoxAddress::from_legacy(hash_mode, key_to_stacks_addr(key).bytes);
+            txs.push(make_pox_3_lockup(
+                key,
+                0,
+                1024 * POX_THRESHOLD_STEPS_USTX,
+                pox_addr.clone(),
+                lock_period,
+                tip_height,
+            ));
+            pox_addr
+        })
+        .collect();
+
+    info!("Submitting stacking txs with pox3");
+    latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
+
+    // Advance to start of rewards cycle stackers are participating in
+    let target_height = burnchain.pox_constants.pox_4_activation_height + 5;
+    while get_tip(peer.sortdb.as_ref()).block_height < u64::from(target_height) {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    }
+
+    info!(
+        "Block height: {}",
+        get_tip(peer.sortdb.as_ref()).block_height
+    );
+
+    // now we should be in the reward phase, produce the reward blocks
+    let reward_blocks =
+        burnchain.pox_constants.reward_cycle_length - burnchain.pox_constants.prepare_length;
+
+    // Check 2 reward cycles
+    for c in 0..lock_period {
+        info!("Checking no stackers this cycle, iteration {}", c + 1);
+        for i in 0..reward_blocks {
+            latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+            // Should all be burn because no stackers
+            assert_latest_was_burn(&mut peer);
+        }
+
+        // now we should be back in a prepare phase
+        info!("Checking we are in prepare phase");
+        for _i in 0..burnchain.pox_constants.prepare_length {
+            latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+            assert_latest_was_burn(&mut peer);
+        }
+    }
+
+    info!("Checking STX unlocked after {lock_period} cycles");
+    for _i in 0..burnchain.pox_constants.reward_cycle_length {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+        assert_latest_was_burn(&mut peer);
+    }
+}
+
 #[test]
 fn stack_with_segwit() {
     // the sim environment produces 25 empty sortitions before

From 210cd66bc11128d67dbe5ad70cfc78e550f2a054 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Fri, 8 Dec 2023 14:53:53 -0500
Subject: [PATCH 0167/1166] Factor out lambda functions
 `assert_latest_was_burn` and `asset_latest_was_pox`

---
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 245 +++++-------------
 1 file changed, 60 insertions(+), 185 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index beb4ecf9f9..7132c7f93f 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -3396,68 +3396,6 @@ fn pox_lock_unlock() {
 
     assert_eq!(burnchain.pox_constants.reward_slots(), 6);
     let mut coinbase_nonce = 0;
-
-    let assert_latest_was_burn = |peer: &mut TestPeer| {
-        let tip = get_tip(peer.sortdb.as_ref());
-        let tip_index_block = tip.get_canonical_stacks_block_id();
-        let burn_height = tip.block_height - 1;
-
-        let conn = peer.sortdb().conn();
-
-        // check the *parent* burn block, because that's what we'll be
-        //  checking with get_burn_pox_addr_info
-        let mut burn_ops =
-            SortitionDB::get_block_commits_by_block(conn, &tip.parent_sortition_id).unwrap();
-        assert_eq!(burn_ops.len(), 1);
-        let commit = burn_ops.pop().unwrap();
-        assert!(commit.all_outputs_burn());
-        assert!(commit.burn_fee > 0);
-
-        let (addrs, payout) = get_burn_pox_addr_info(peer);
-        let tip = get_tip(peer.sortdb.as_ref());
-        let tip_index_block = tip.get_canonical_stacks_block_id();
-        let burn_height = tip.block_height - 1;
-        info!("Checking burn outputs at burn_height = {}", burn_height);
-        if peer.config.burnchain.is_in_prepare_phase(burn_height) {
-            assert_eq!(addrs.len(), 1);
-            assert_eq!(payout, 1000);
-            assert!(addrs[0].is_burn());
-        } else {
-            assert_eq!(addrs.len(), 2);
-            assert_eq!(payout, 500);
-            assert!(addrs[0].is_burn());
-            assert!(addrs[1].is_burn());
-        }
-    };
-
-    let assert_latest_was_pox = |peer: &mut TestPeer| {
-        let tip = get_tip(peer.sortdb.as_ref());
-        let tip_index_block = tip.get_canonical_stacks_block_id();
-        let burn_height = tip.block_height - 1;
-
-        let conn = peer.sortdb().conn();
-
-        // check the *parent* burn block, because that's what we'll be
-        //  checking with get_burn_pox_addr_info
-        let mut burn_ops =
-            SortitionDB::get_block_commits_by_block(conn, &tip.parent_sortition_id).unwrap();
-        assert_eq!(burn_ops.len(), 1);
-        let commit = burn_ops.pop().unwrap();
-        assert!(!commit.all_outputs_burn());
-        let commit_addrs = commit.commit_outs;
-
-        let (addrs, payout) = get_burn_pox_addr_info(peer);
-        info!(
-            "Checking pox outputs at burn_height = {}, commit_addrs = {:?}, fetch_addrs = {:?}",
-            burn_height, commit_addrs, addrs
-        );
-        assert_eq!(addrs.len(), 2);
-        assert_eq!(payout, 500);
-        assert!(commit_addrs.contains(&addrs[0]));
-        assert!(commit_addrs.contains(&addrs[1]));
-        addrs
-    };
-
     let mut latest_block;
 
     // Advance into pox4
@@ -3580,68 +3518,6 @@ fn pox_3_fails() {
 
     assert_eq!(burnchain.pox_constants.reward_slots(), 6);
     let mut coinbase_nonce = 0;
-
-    let assert_latest_was_burn = |peer: &mut TestPeer| {
-        let tip = get_tip(peer.sortdb.as_ref());
-        let tip_index_block = tip.get_canonical_stacks_block_id();
-        let burn_height = tip.block_height - 1;
-
-        let conn = peer.sortdb().conn();
-
-        // check the *parent* burn block, because that's what we'll be
-        //  checking with get_burn_pox_addr_info
-        let mut burn_ops =
-            SortitionDB::get_block_commits_by_block(conn, &tip.parent_sortition_id).unwrap();
-        assert_eq!(burn_ops.len(), 1);
-        let commit = burn_ops.pop().unwrap();
-        assert!(commit.all_outputs_burn());
-        assert!(commit.burn_fee > 0);
-
-        let (addrs, payout) = get_burn_pox_addr_info(peer);
-        let tip = get_tip(peer.sortdb.as_ref());
-        let tip_index_block = tip.get_canonical_stacks_block_id();
-        let burn_height = tip.block_height - 1;
-        info!("Checking burn outputs at burn_height = {}", burn_height);
-        if peer.config.burnchain.is_in_prepare_phase(burn_height) {
-            assert_eq!(addrs.len(), 1);
-            assert_eq!(payout, 1000);
-            assert!(addrs[0].is_burn());
-        } else {
-            assert_eq!(addrs.len(), 2);
-            assert_eq!(payout, 500);
-            assert!(addrs[0].is_burn());
-            assert!(addrs[1].is_burn());
-        }
-    };
-
-    let assert_latest_was_pox = |peer: &mut TestPeer| {
-        let tip = get_tip(peer.sortdb.as_ref());
-        let tip_index_block = tip.get_canonical_stacks_block_id();
-        let burn_height = tip.block_height - 1;
-
-        let conn = peer.sortdb().conn();
-
-        // check the *parent* burn block, because that's what we'll be
-        //  checking with get_burn_pox_addr_info
-        let mut burn_ops =
-            SortitionDB::get_block_commits_by_block(conn, &tip.parent_sortition_id).unwrap();
-        assert_eq!(burn_ops.len(), 1);
-        let commit = burn_ops.pop().unwrap();
-        assert!(!commit.all_outputs_burn());
-        let commit_addrs = commit.commit_outs;
-
-        let (addrs, payout) = get_burn_pox_addr_info(peer);
-        info!(
-            "Checking pox outputs at burn_height = {}, commit_addrs = {:?}, fetch_addrs = {:?}",
-            burn_height, commit_addrs, addrs
-        );
-        assert_eq!(addrs.len(), 2);
-        assert_eq!(payout, 500);
-        assert!(commit_addrs.contains(&addrs[0]));
-        assert!(commit_addrs.contains(&addrs[1]));
-        addrs
-    };
-
     let mut latest_block;
 
     // Advance into pox4
@@ -3758,67 +3634,6 @@ fn stack_with_segwit() {
     assert_eq!(burnchain.pox_constants.reward_slots(), 6);
     let mut coinbase_nonce = 0;
 
-    let assert_latest_was_burn = |peer: &mut TestPeer| {
-        let tip = get_tip(peer.sortdb.as_ref());
-        let tip_index_block = tip.get_canonical_stacks_block_id();
-        let burn_height = tip.block_height - 1;
-
-        let conn = peer.sortdb().conn();
-
-        // check the *parent* burn block, because that's what we'll be
-        //  checking with get_burn_pox_addr_info
-        let mut burn_ops =
-            SortitionDB::get_block_commits_by_block(conn, &tip.parent_sortition_id).unwrap();
-        assert_eq!(burn_ops.len(), 1);
-        let commit = burn_ops.pop().unwrap();
-        assert!(commit.all_outputs_burn());
-        assert!(commit.burn_fee > 0);
-
-        let (addrs, payout) = get_burn_pox_addr_info(peer);
-        let tip = get_tip(peer.sortdb.as_ref());
-        let tip_index_block = tip.get_canonical_stacks_block_id();
-        let burn_height = tip.block_height - 1;
-        info!("Checking burn outputs at burn_height = {}", burn_height);
-        if peer.config.burnchain.is_in_prepare_phase(burn_height) {
-            assert_eq!(addrs.len(), 1);
-            assert_eq!(payout, 1000);
-            assert!(addrs[0].is_burn());
-        } else {
-            assert_eq!(addrs.len(), 2);
-            assert_eq!(payout, 500);
-            assert!(addrs[0].is_burn());
-            assert!(addrs[1].is_burn());
-        }
-    };
-
-    let assert_latest_was_pox = |peer: &mut TestPeer| {
-        let tip = get_tip(peer.sortdb.as_ref());
-        let tip_index_block = tip.get_canonical_stacks_block_id();
-        let burn_height = tip.block_height - 1;
-
-        let conn = peer.sortdb().conn();
-
-        // check the *parent* burn block, because that's what we'll be
-        //  checking with get_burn_pox_addr_info
-        let mut burn_ops =
-            SortitionDB::get_block_commits_by_block(conn, &tip.parent_sortition_id).unwrap();
-        assert_eq!(burn_ops.len(), 1);
-        let commit = burn_ops.pop().unwrap();
-        assert!(!commit.all_outputs_burn());
-        let commit_addrs = commit.commit_outs;
-
-        let (addrs, payout) = get_burn_pox_addr_info(peer);
-        info!(
-            "Checking pox outputs at burn_height = {}, commit_addrs = {:?}, fetch_addrs = {:?}",
-            burn_height, commit_addrs, addrs
-        );
-        assert_eq!(addrs.len(), 2);
-        assert_eq!(payout, 500);
-        assert!(commit_addrs.contains(&addrs[0]));
-        assert!(commit_addrs.contains(&addrs[1]));
-        addrs
-    };
-
     // produce blocks until epoch 2.2
     while get_tip(peer.sortdb.as_ref()).block_height <= epochs[6].start_height {
         peer.tenure_with_txs(&[], &mut coinbase_nonce);
@@ -4537,3 +4352,63 @@ fn pox_3_delegate_stx_addr_validation() {
         make_pox_addr(AddressHashMode::SerializeP2PKH, alice_address.bytes.clone(),)
     );
 }
+
+fn assert_latest_was_burn(peer: &mut TestPeer) {
+    let tip = get_tip(peer.sortdb.as_ref());
+    let tip_index_block = tip.get_canonical_stacks_block_id();
+    let burn_height = tip.block_height - 1;
+
+    let conn = peer.sortdb().conn();
+
+    // check the *parent* burn block, because that's what we'll be
+    //  checking with get_burn_pox_addr_info
+    let mut burn_ops =
+        SortitionDB::get_block_commits_by_block(conn, &tip.parent_sortition_id).unwrap();
+    assert_eq!(burn_ops.len(), 1);
+    let commit = burn_ops.pop().unwrap();
+    assert!(commit.all_outputs_burn());
+    assert!(commit.burn_fee > 0);
+
+    let (addrs, payout) = get_burn_pox_addr_info(peer);
+    let tip = get_tip(peer.sortdb.as_ref());
+    let tip_index_block = tip.get_canonical_stacks_block_id();
+    let burn_height = tip.block_height - 1;
+    info!("Checking burn outputs at burn_height = {burn_height}");
+    if peer.config.burnchain.is_in_prepare_phase(burn_height) {
+        assert_eq!(addrs.len(), 1);
+        assert_eq!(payout, 1000);
+        assert!(addrs[0].is_burn());
+    } else {
+        assert_eq!(addrs.len(), 2);
+        assert_eq!(payout, 500);
+        assert!(addrs[0].is_burn());
+        assert!(addrs[1].is_burn());
+    }
+}
+
+fn assert_latest_was_pox(peer: &mut TestPeer) -> Vec<PoxAddress> {
+    let tip = get_tip(peer.sortdb.as_ref());
+    let tip_index_block = tip.get_canonical_stacks_block_id();
+    let burn_height = tip.block_height - 1;
+
+    let conn = peer.sortdb().conn();
+
+    // check the *parent* burn block, because that's what we'll be
+    //  checking with get_burn_pox_addr_info
+    let mut burn_ops =
+        SortitionDB::get_block_commits_by_block(conn, &tip.parent_sortition_id).unwrap();
+    assert_eq!(burn_ops.len(), 1);
+    let commit = burn_ops.pop().unwrap();
+    assert!(!commit.all_outputs_burn());
+    let commit_addrs = commit.commit_outs;
+
+    let (addrs, payout) = get_burn_pox_addr_info(peer);
+    info!(
+        "Checking pox outputs at burn_height = {burn_height}, commit_addrs = {commit_addrs:?}, fetch_addrs = {addrs:?}"
+    );
+    assert_eq!(addrs.len(), 2);
+    assert_eq!(payout, 500);
+    assert!(commit_addrs.contains(&addrs[0]));
+    assert!(commit_addrs.contains(&addrs[1]));
+    addrs
+}

From 51070f3a4e7e9f0c3e7bcd20d448c9cf0e4af6b7 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Mon, 11 Dec 2023 10:14:48 -0500
Subject: [PATCH 0168/1166] Add `pox_4_tests::pox_3_unlocks()`

---
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 162 ++++++++++++++++--
 1 file changed, 146 insertions(+), 16 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 7132c7f93f..b45bcb4faa 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -3458,8 +3458,12 @@ fn pox_lock_unlock() {
     let mut rewarded = HashSet::new();
 
     // Check that STX are locked for 2 reward cycles
-    for c in 0..lock_period {
-        info!("Checking STX locked, iteration {}", c + 1);
+    for _ in 0..lock_period {
+        let tip = get_tip(peer.sortdb.as_ref());
+        let cycle = burnchain
+            .block_height_to_reward_cycle(tip.block_height)
+            .unwrap();
+        info!("Checking no stackers for cycle {cycle}");
         for i in 0..reward_blocks {
             latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
             // only the first 2 reward blocks contain pox outputs, because there are 6 slots and only 4 are occuppied
@@ -3479,21 +3483,20 @@ fn pox_lock_unlock() {
         for stacker in stackers.iter() {
             assert!(
                 rewarded.contains(stacker),
-                "Reward cycle should include {}",
-                stacker
+                "Reward cycle should include {stacker}"
             );
         }
 
         // now we should be back in a prepare phase
         info!("Checking we are in prepare phase");
-        for _i in 0..burnchain.pox_constants.prepare_length {
+        for _ in 0..burnchain.pox_constants.prepare_length {
             latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
             assert_latest_was_burn(&mut peer);
         }
     }
 
     info!("Checking STX unlocked after {lock_period} cycles");
-    for _i in 0..burnchain.pox_constants.reward_cycle_length {
+    for _ in 0..burnchain.pox_constants.reward_cycle_length {
         latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
         assert_latest_was_burn(&mut peer);
     }
@@ -3578,27 +3581,153 @@ fn pox_3_fails() {
     let reward_blocks =
         burnchain.pox_constants.reward_cycle_length - burnchain.pox_constants.prepare_length;
 
-    // Check 2 reward cycles
-    for c in 0..lock_period {
-        info!("Checking no stackers this cycle, iteration {}", c + 1);
-        for i in 0..reward_blocks {
+    // Check next 3 reward cycles
+    for _ in 0..=lock_period {
+        let tip = get_tip(peer.sortdb.as_ref());
+        let cycle = burnchain
+            .block_height_to_reward_cycle(tip.block_height)
+            .unwrap();
+        info!("Checking no stackers for cycle {cycle}");
+        for _ in 0..burnchain.pox_constants.reward_cycle_length {
             latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
             // Should all be burn because no stackers
             assert_latest_was_burn(&mut peer);
         }
+    }
+}
+
+/// Test that we can lock STX for a couple cycles after pox4 starts,
+/// and that it unlocks after the desired number of cycles
+#[test]
+fn pox_3_unlocks() {
+    // Config for this test
+    // We are going to try locking for 4 reward cycles (20 blocks)
+    let lock_period = 4;
+    let (epochs, pox_constants) = make_test_epochs_pox();
+
+    let mut burnchain = Burnchain::default_unittest(
+        0,
+        &BurnchainHeaderHash::from_hex(BITCOIN_REGTEST_FIRST_BLOCK_HASH).unwrap(),
+    );
+    burnchain.pox_constants = pox_constants.clone();
+
+    let (mut peer, keys) =
+        instantiate_pox_peer_with_epoch(&burnchain, function_name!(), Some(epochs.clone()), None);
+
+    assert_eq!(burnchain.pox_constants.reward_slots(), 6);
+    let mut coinbase_nonce = 0;
+    let mut latest_block;
+
+    // Advance to a few blocks before pox 3 unlock
+    let target_height = burnchain.pox_constants.v3_unlock_height - 14;
+    // produce blocks until the first reward phase that everyone should be in
+    while get_tip(peer.sortdb.as_ref()).block_height < u64::from(target_height) {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+        // if we reach epoch 2.1, perform the check
+        if get_tip(peer.sortdb.as_ref()).block_height > epochs[3].start_height {
+            assert_latest_was_burn(&mut peer);
+        }
+    }
+
+    info!( "Block height: {}", get_tip(peer.sortdb.as_ref()).block_height);
+
+    let mut txs = vec![];
+    let tip_height = get_tip(peer.sortdb.as_ref()).block_height;
+    let stackers: Vec<_> = keys
+        .iter()
+        .zip([
+            AddressHashMode::SerializeP2PKH,
+            AddressHashMode::SerializeP2SH,
+            AddressHashMode::SerializeP2WPKH,
+            AddressHashMode::SerializeP2WSH,
+        ])
+        .map(|(key, hash_mode)| {
+            let pox_addr = PoxAddress::from_legacy(hash_mode, key_to_stacks_addr(key).bytes);
+            txs.push(make_pox_3_lockup(
+                key,
+                0,
+                1024 * POX_THRESHOLD_STEPS_USTX,
+                pox_addr.clone(),
+                lock_period,
+                tip_height,
+            ));
+            pox_addr
+        })
+        .collect();
+
+    info!("Submitting stacking txs");
+    latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
+
+    // Advance a couple more blocks
+    for _ in 0..3 {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    }
+
+    // now we should be in the reward phase, produce the reward blocks
+    let reward_blocks =
+        burnchain.pox_constants.reward_cycle_length - burnchain.pox_constants.prepare_length;
+    let mut rewarded = HashSet::new();
+
+    // Check that STX are locked for 2 reward cycles
+    for _ in 0..2 {
+        let tip = get_tip(peer.sortdb.as_ref());
+        let cycle = burnchain
+            .block_height_to_reward_cycle(tip.block_height)
+            .unwrap();
+        info!("Checking STX locked for cycle {cycle}");
+        for i in 0..reward_blocks {
+            latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+            // only the first 2 reward blocks contain pox outputs, because there are 6 slots and only 4 are occuppied
+            if i < 2 {
+                assert_latest_was_pox(&mut peer)
+                    .into_iter()
+                    .filter(|addr| !addr.is_burn())
+                    .for_each(|addr| {
+                        rewarded.insert(addr);
+                    });
+            } else {
+                assert_latest_was_burn(&mut peer);
+            }
+        }
+
+        assert_eq!(rewarded.len(), 4);
+        for stacker in stackers.iter() {
+            assert!(
+                rewarded.contains(stacker),
+                "Reward cycle should include {stacker}"
+            );
+        }
 
         // now we should be back in a prepare phase
         info!("Checking we are in prepare phase");
-        for _i in 0..burnchain.pox_constants.prepare_length {
+        for _ in 0..burnchain.pox_constants.prepare_length {
             latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
             assert_latest_was_burn(&mut peer);
         }
     }
 
-    info!("Checking STX unlocked after {lock_period} cycles");
-    for _i in 0..burnchain.pox_constants.reward_cycle_length {
+    // Advance to v3 unlock
+    let target_height = burnchain.pox_constants.v3_unlock_height;
+    while get_tip(peer.sortdb.as_ref()).block_height < u64::from(target_height) {
         latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-        assert_latest_was_burn(&mut peer);
+    }
+
+    info!(
+        "Block height: {}",
+        get_tip(peer.sortdb.as_ref()).block_height
+    );
+
+    // Check that STX are not locked for 3 reward cycles after pox4 starts
+    for _ in 0..3 {
+        let tip = get_tip(peer.sortdb.as_ref());
+        let cycle = burnchain
+            .block_height_to_reward_cycle(tip.block_height)
+            .unwrap();
+        info!("Checking no stackers for cycle {cycle}");
+        for _ in 0..burnchain.pox_constants.reward_cycle_length {
+            latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+            assert_latest_was_burn(&mut peer);
+        }
     }
 }
 
@@ -4353,7 +4482,8 @@ fn pox_3_delegate_stx_addr_validation() {
     );
 }
 
-fn assert_latest_was_burn(peer: &mut TestPeer) {
+
+fn assert_latest_was_burn (peer: &mut TestPeer) {
     let tip = get_tip(peer.sortdb.as_ref());
     let tip_index_block = tip.get_canonical_stacks_block_id();
     let burn_height = tip.block_height - 1;
@@ -4386,7 +4516,7 @@ fn assert_latest_was_burn(peer: &mut TestPeer) {
     }
 }
 
-fn assert_latest_was_pox(peer: &mut TestPeer) -> Vec<PoxAddress> {
+fn assert_latest_was_pox (peer: &mut TestPeer) -> Vec<PoxAddress> {
     let tip = get_tip(peer.sortdb.as_ref());
     let tip_index_block = tip.get_canonical_stacks_block_id();
     let burn_height = tip.block_height - 1;

From aac81ab43e98190595979f0722d71757a64e0a6a Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Mon, 11 Dec 2023 10:42:21 -0500
Subject: [PATCH 0169/1166] Remove `pox_4_tests` which had not been modified
 for pox4

---
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 4415 ++---------------
 1 file changed, 509 insertions(+), 3906 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index b45bcb4faa..e48094b5bb 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -151,20 +151,8 @@ fn make_test_epochs_pox() -> (Vec<StacksEpoch>, PoxConstants) {
     (epochs, pox_constants)
 }
 
-/// In this test case, two Stackers, Alice and Bob stack and interact with the
-///  PoX v1 contract and PoX v2 contract across the epoch transition and then
-///  again with the PoX v3 contract.
-///
-/// Alice: stacks via PoX v1 for 4 cycles. The third of these cycles occurs after
-///        the PoX v1 -> v2 transition, and so Alice gets "early unlocked".
-///        After the early unlock, Alice re-stacks in PoX v2
-/// Bob:   stacks via PoX v2 for 6 cycles. He attempted to stack via PoX v1 as well,
-///        but is forbidden because he has already placed an account lock via PoX v2.
-///        
-/// After the PoX-3 contract is instantiated, Alice and Bob both stack via PoX v3.
-///
 #[test]
-fn simple_pox_lockup_transition_pox_2() {
+fn pox_extend_transition() {
     let EXPECTED_FIRST_V2_CYCLE = 8;
     // the sim environment produces 25 empty sortitions before
     //  tenures start being tracked.
@@ -183,9 +171,17 @@ fn simple_pox_lockup_transition_pox_2() {
         .unwrap()
         + 1;
 
-    assert_eq!(first_v2_cycle, EXPECTED_FIRST_V2_CYCLE);
+    let first_v3_cycle = burnchain
+        .block_height_to_reward_cycle(burnchain.pox_constants.pox_3_activation_height as u64)
+        .unwrap()
+        + 1;
+
+    let first_v4_cycle = burnchain
+        .block_height_to_reward_cycle(burnchain.pox_constants.pox_4_activation_height as u64)
+        .unwrap()
+        + 1;
 
-    eprintln!("First v2 cycle = {}", first_v2_cycle);
+    assert_eq!(first_v2_cycle, EXPECTED_FIRST_V2_CYCLE);
 
     let observer = TestEventObserver::new();
 
@@ -197,31 +193,115 @@ fn simple_pox_lockup_transition_pox_2() {
     );
 
     peer.config.check_pox_invariants =
-        Some((EXPECTED_FIRST_V2_CYCLE, EXPECTED_FIRST_V2_CYCLE + 20));
+        Some((EXPECTED_FIRST_V2_CYCLE, EXPECTED_FIRST_V2_CYCLE + 10));
 
     let alice = keys.pop().unwrap();
     let bob = keys.pop().unwrap();
-    let charlie = keys.pop().unwrap();
+    let alice_address = key_to_stacks_addr(&alice);
+    let alice_principal = PrincipalData::from(alice_address.clone());
+    let bob_address = key_to_stacks_addr(&bob);
+    let bob_principal = PrincipalData::from(bob_address.clone());
 
     let EXPECTED_ALICE_FIRST_REWARD_CYCLE = 6;
-
     let mut coinbase_nonce = 0;
 
-    // our "tenure counter" is now at 0
-    let tip = get_tip(peer.sortdb.as_ref());
-    assert_eq!(tip.block_height, 0 + EMPTY_SORTITIONS as u64);
+    let INITIAL_BALANCE = 1024 * POX_THRESHOLD_STEPS_USTX;
+    let ALICE_LOCKUP = 1024 * POX_THRESHOLD_STEPS_USTX;
+    let BOB_LOCKUP = 512 * POX_THRESHOLD_STEPS_USTX;
 
-    // first tenure is empty
-    peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    // these checks should pass between Alice's first reward cycle,
+    //  and the start of V2 reward cycles
+    let alice_rewards_to_v2_start_checks = |tip_index_block, peer: &mut TestPeer| {
+        let tip_burn_block_height = get_par_burn_block_height(peer.chainstate(), &tip_index_block);
+        let cur_reward_cycle = burnchain
+            .block_height_to_reward_cycle(tip_burn_block_height)
+            .unwrap() as u128;
+        let (min_ustx, reward_addrs, total_stacked) = with_sortdb(peer, |ref mut c, ref sortdb| {
+            (
+                c.get_stacking_minimum(sortdb, &tip_index_block).unwrap(),
+                get_reward_addresses_with_par_tip(c, &burnchain, sortdb, &tip_index_block).unwrap(),
+                c.test_get_total_ustx_stacked(sortdb, &tip_index_block, cur_reward_cycle)
+                    .unwrap(),
+            )
+        });
 
-    let alice_balance = get_balance(&mut peer, &key_to_stacks_addr(&alice).into());
-    assert_eq!(alice_balance, 1024 * POX_THRESHOLD_STEPS_USTX);
+        assert!(
+            cur_reward_cycle >= EXPECTED_ALICE_FIRST_REWARD_CYCLE
+                && cur_reward_cycle < first_v2_cycle as u128
+        );
+        //  Alice is the only Stacker, so check that.
+        let (amount_ustx, pox_addr, lock_period, first_reward_cycle) =
+            get_stacker_info(peer, &key_to_stacks_addr(&alice).into()).unwrap();
+        eprintln!(
+            "\nAlice: {} uSTX stacked for {} cycle(s); addr is {:?}; first reward cycle is {}\n",
+            amount_ustx, lock_period, &pox_addr, first_reward_cycle
+        );
+
+        // one reward address, and it's Alice's
+        // either way, there's a single reward address
+        assert_eq!(reward_addrs.len(), 1);
+        assert_eq!(
+            (reward_addrs[0].0).version(),
+            AddressHashMode::SerializeP2PKH as u8
+        );
+        assert_eq!(
+            (reward_addrs[0].0).hash160(),
+            key_to_stacks_addr(&alice).bytes
+        );
+        assert_eq!(reward_addrs[0].1, ALICE_LOCKUP);
+    };
+
+    // these checks should pass after the start of V2 reward cycles
+    let v2_rewards_checks = |tip_index_block, peer: &mut TestPeer| {
+        let tip_burn_block_height = get_par_burn_block_height(peer.chainstate(), &tip_index_block);
+        let cur_reward_cycle = burnchain
+            .block_height_to_reward_cycle(tip_burn_block_height)
+            .unwrap() as u128;
+        let (min_ustx, reward_addrs, total_stacked) = with_sortdb(peer, |ref mut c, ref sortdb| {
+            (
+                c.get_stacking_minimum(sortdb, &tip_index_block).unwrap(),
+                get_reward_addresses_with_par_tip(c, &burnchain, sortdb, &tip_index_block).unwrap(),
+                c.test_get_total_ustx_stacked(sortdb, &tip_index_block, cur_reward_cycle)
+                    .unwrap(),
+            )
+        });
+
+        eprintln!(
+            "reward_cycle = {}, reward_addrs = {}, total_stacked = {}",
+            cur_reward_cycle,
+            reward_addrs.len(),
+            total_stacked
+        );
+
+        assert!(cur_reward_cycle >= first_v2_cycle as u128);
+        // v2 reward cycles have begun, so reward addrs should be read from PoX2 which is Bob + Alice
+        assert_eq!(reward_addrs.len(), 2);
+        assert_eq!(
+            (reward_addrs[0].0).version(),
+            AddressHashMode::SerializeP2PKH as u8
+        );
+        assert_eq!(
+            (reward_addrs[0].0).hash160(),
+            key_to_stacks_addr(&bob).bytes
+        );
+        assert_eq!(reward_addrs[0].1, BOB_LOCKUP);
+
+        assert_eq!(
+            (reward_addrs[1].0).version(),
+            AddressHashMode::SerializeP2PKH as u8
+        );
+        assert_eq!(
+            (reward_addrs[1].0).hash160(),
+            key_to_stacks_addr(&alice).bytes
+        );
+        assert_eq!(reward_addrs[1].1, ALICE_LOCKUP);
+    };
+
+    // first tenure is empty
+    let mut latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
 
     let alice_account = get_account(&mut peer, &key_to_stacks_addr(&alice).into());
-    assert_eq!(
-        alice_account.stx_balance.amount_unlocked(),
-        1024 * POX_THRESHOLD_STEPS_USTX
-    );
+    assert_eq!(alice_account.stx_balance.amount_unlocked(), INITIAL_BALANCE);
     assert_eq!(alice_account.stx_balance.amount_locked(), 0);
     assert_eq!(alice_account.stx_balance.unlock_height(), 0);
 
@@ -230,21 +310,18 @@ fn simple_pox_lockup_transition_pox_2() {
     let alice_lockup = make_pox_lockup(
         &alice,
         0,
-        1024 * POX_THRESHOLD_STEPS_USTX,
+        ALICE_LOCKUP,
         AddressHashMode::SerializeP2PKH,
         key_to_stacks_addr(&alice).bytes,
         4,
         tip.block_height,
     );
 
-    // our "tenure counter" is now at 1
-    assert_eq!(tip.block_height, 1 + EMPTY_SORTITIONS as u64);
-
     let tip_index_block = peer.tenure_with_txs(&[alice_lockup], &mut coinbase_nonce);
 
     // check the stacking minimum
     let total_liquid_ustx = get_liquid_ustx(&mut peer);
-    let min_ustx = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
+    let min_ustx = with_sortdb(&mut peer, |chainstate, sortdb| {
         chainstate.get_stacking_minimum(sortdb, &tip_index_block)
     })
     .unwrap();
@@ -254,7 +331,7 @@ fn simple_pox_lockup_transition_pox_2() {
     );
 
     // no reward addresses
-    let reward_addrs = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
+    let reward_addrs = with_sortdb(&mut peer, |chainstate, sortdb| {
         get_reward_addresses_with_par_tip(chainstate, &burnchain, sortdb, &tip_index_block)
     })
     .unwrap();
@@ -264,426 +341,209 @@ fn simple_pox_lockup_transition_pox_2() {
     let tip_burn_block_height = get_par_burn_block_height(peer.chainstate(), &tip_index_block);
     let alice_first_reward_cycle = 1 + burnchain
         .block_height_to_reward_cycle(tip_burn_block_height)
-        .unwrap() as u128;
+        .unwrap();
 
-    assert_eq!(alice_first_reward_cycle, EXPECTED_ALICE_FIRST_REWARD_CYCLE);
+    assert_eq!(
+        alice_first_reward_cycle as u128,
+        EXPECTED_ALICE_FIRST_REWARD_CYCLE
+    );
+    let height_target = burnchain.reward_cycle_to_block_height(alice_first_reward_cycle) + 1;
 
     // alice locked, so balance should be 0
     let alice_balance = get_balance(&mut peer, &key_to_stacks_addr(&alice).into());
     assert_eq!(alice_balance, 0);
 
-    // produce blocks until immediately before the 2.1 epoch switch
+    while get_tip(peer.sortdb.as_ref()).block_height < height_target {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    }
+
+    // produce blocks until epoch 2.1
     while get_tip(peer.sortdb.as_ref()).block_height < epochs[3].start_height {
         peer.tenure_with_txs(&[], &mut coinbase_nonce);
-
-        // alice is still locked, balance should be 0
-        let alice_balance = get_balance(&mut peer, &key_to_stacks_addr(&alice).into());
-        assert_eq!(alice_balance, 0);
+        alice_rewards_to_v2_start_checks(latest_block, &mut peer);
     }
 
-    // Have Charlie try to use the PoX2 contract. This transaction
-    //  should be accepted (checked via the tx receipt). Also, importantly,
-    //  the cost tracker should assign costs to Charlie's transaction.
-    //  This is also checked by the transaction receipt.
-    let tip = get_tip(peer.sortdb.as_ref());
-
-    let test = make_pox_2_contract_call(
-        &charlie,
-        0,
-        "delegate-stx",
-        vec![
-            Value::UInt(1_000_000),
-            PrincipalData::from(key_to_stacks_addr(&charlie)).into(),
-            Value::none(),
-            Value::none(),
-        ],
-    );
-    peer.tenure_with_txs(&[test], &mut coinbase_nonce);
-
-    // alice is still locked, balance should be 0
-    let alice_balance = get_balance(&mut peer, &key_to_stacks_addr(&alice).into());
-    assert_eq!(alice_balance, 0);
-
     // in the next tenure, PoX 2 should now exist.
     // Lets have Bob lock up for v2
-    // this will lock for cycles 8, 9, 10, and 11
+    // this will lock for cycles 8, 9, 10
     //  the first v2 cycle will be 8
     let tip = get_tip(peer.sortdb.as_ref());
 
     let bob_lockup = make_pox_2_lockup(
         &bob,
         0,
-        512 * POX_THRESHOLD_STEPS_USTX,
+        BOB_LOCKUP,
         PoxAddress::from_legacy(
             AddressHashMode::SerializeP2PKH,
             key_to_stacks_addr(&bob).bytes,
         ),
-        6,
+        3,
         tip.block_height,
     );
 
-    let block_id = peer.tenure_with_txs(&[bob_lockup], &mut coinbase_nonce);
-
-    assert_eq!(
-        get_tip(peer.sortdb.as_ref()).block_height as u32,
-        pox_constants.v1_unlock_height + 1,
-        "Test should have reached 1 + PoX-v1 unlock height"
-    );
-
-    // Auto unlock height is reached, Alice balance should be unlocked
-    let alice_balance = get_balance(&mut peer, &key_to_stacks_addr(&alice).into());
-    assert_eq!(alice_balance, 1024 * POX_THRESHOLD_STEPS_USTX);
-
-    // Now, Bob tries to lock in PoX v1 too, but it shouldn't work!
-    let tip = get_tip(peer.sortdb.as_ref());
-
-    let bob_lockup = make_pox_lockup(
-        &bob,
+    // Alice _will_ auto-unlock: she can stack-extend in PoX v2
+    let alice_lockup = make_pox_2_extend(
+        &alice,
         1,
-        512 * POX_THRESHOLD_STEPS_USTX,
-        AddressHashMode::SerializeP2PKH,
-        key_to_stacks_addr(&bob).bytes,
-        4,
-        tip.block_height,
+        PoxAddress::from_legacy(
+            AddressHashMode::SerializeP2PKH,
+            key_to_stacks_addr(&alice).bytes,
+        ),
+        6,
     );
 
-    let block_id = peer.tenure_with_txs(&[bob_lockup], &mut coinbase_nonce);
-
-    // At this point, the auto unlock height for v1 accounts has been reached.
-    //  let Alice stack in PoX v2
-    let tip = get_tip(peer.sortdb.as_ref());
+    latest_block = peer.tenure_with_txs(&[bob_lockup, alice_lockup], &mut coinbase_nonce);
+    alice_rewards_to_v2_start_checks(latest_block, &mut peer);
 
-    let alice_lockup = make_pox_2_lockup(
-        &alice,
+    // Extend bob's lockup via `stack-extend` for 1 more cycle
+    let bob_extend = make_pox_2_extend(
+        &bob,
         1,
-        512 * POX_THRESHOLD_STEPS_USTX,
         PoxAddress::from_legacy(
             AddressHashMode::SerializeP2PKH,
-            key_to_stacks_addr(&alice).bytes,
+            key_to_stacks_addr(&bob).bytes,
         ),
-        12,
-        tip.block_height,
+        1,
     );
-    peer.tenure_with_txs(&[alice_lockup], &mut coinbase_nonce);
 
-    // Alice locked half her balance in PoX 2
-    let alice_balance = get_balance(&mut peer, &key_to_stacks_addr(&alice).into());
-    assert_eq!(alice_balance, 512 * POX_THRESHOLD_STEPS_USTX);
+    latest_block = peer.tenure_with_txs(&[bob_extend], &mut coinbase_nonce);
+
+    alice_rewards_to_v2_start_checks(latest_block, &mut peer);
+
+    // produce blocks until the v2 reward cycles start
+    let height_target = burnchain.reward_cycle_to_block_height(first_v2_cycle) - 1;
+    while get_tip(peer.sortdb.as_ref()).block_height < height_target {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+        // alice is still locked, balance should be 0
+        let alice_balance = get_balance(&mut peer, &key_to_stacks_addr(&alice).into());
+        assert_eq!(alice_balance, 0);
 
-    // now, let's roll the chain forward until just before Epoch-2.2
+        alice_rewards_to_v2_start_checks(latest_block, &mut peer);
+    }
+
+    latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    v2_rewards_checks(latest_block, &mut peer);
+
+    // roll the chain forward until just before Epoch-2.2
     while get_tip(peer.sortdb.as_ref()).block_height < epochs[4].start_height {
-        peer.tenure_with_txs(&[], &mut coinbase_nonce);
-        // at this point, alice's balance should always include this half lockup
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+        // at this point, alice's balance should be locked, and so should bob's
         let alice_balance = get_balance(&mut peer, &key_to_stacks_addr(&alice).into());
-        assert_eq!(alice_balance, 512 * POX_THRESHOLD_STEPS_USTX);
+        assert_eq!(alice_balance, 0);
+        let bob_balance = get_balance(&mut peer, &key_to_stacks_addr(&bob).into());
+        assert_eq!(bob_balance, 512 * POX_THRESHOLD_STEPS_USTX);
     }
 
     // this block is mined in epoch-2.2
-    peer.tenure_with_txs(&[], &mut coinbase_nonce);
-    let alice_balance = get_balance(&mut peer, &key_to_stacks_addr(&alice).into());
-    assert_eq!(alice_balance, 512 * POX_THRESHOLD_STEPS_USTX);
-    // this block should unlock alice's balance
-    peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
     let alice_balance = get_balance(&mut peer, &key_to_stacks_addr(&alice).into());
-    assert_eq!(alice_balance, 1024 * POX_THRESHOLD_STEPS_USTX);
+    assert_eq!(alice_balance, 0);
+    let bob_balance = get_balance(&mut peer, &key_to_stacks_addr(&bob).into());
+    assert_eq!(bob_balance, 512 * POX_THRESHOLD_STEPS_USTX);
 
-    // now, roll the chain forward to Epoch-2.4
-    while get_tip(peer.sortdb.as_ref()).block_height <= epochs[6].start_height {
-        peer.tenure_with_txs(&[], &mut coinbase_nonce);
-        // at this point, alice's balance should always be unlocked
-        let alice_balance = get_balance(&mut peer, &key_to_stacks_addr(&alice).into());
-        assert_eq!(alice_balance, 1024 * POX_THRESHOLD_STEPS_USTX);
-    }
+    // this block should unlock alice and bob's balance
 
-    let tip = get_tip(peer.sortdb.as_ref()).block_height;
-    let bob_lockup = make_pox_3_lockup(
-        &bob,
-        2,
-        512 * POX_THRESHOLD_STEPS_USTX,
-        PoxAddress::from_legacy(
-            AddressHashMode::SerializeP2PKH,
-            key_to_stacks_addr(&bob).bytes,
-        ),
-        6,
-        tip,
-    );
+    latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    let alice_account = get_stx_account_at(&mut peer, &latest_block, &alice_principal);
+    let bob_account = get_stx_account_at(&mut peer, &latest_block, &bob_principal);
+    assert_eq!(alice_account.amount_locked(), 0);
+    assert_eq!(alice_account.amount_unlocked(), INITIAL_BALANCE);
+    assert_eq!(bob_account.amount_locked(), 0);
+    assert_eq!(bob_account.amount_unlocked(), INITIAL_BALANCE);
+
+    // Roll to pox4 activation and re-do the above stack-extend tests
+    while get_tip(peer.sortdb.as_ref()).block_height
+        < u64::from(burnchain.pox_constants.pox_4_activation_height)
+    {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    }
 
-    let alice_lockup = make_pox_3_lockup(
+    let tip = get_tip(peer.sortdb.as_ref());
+    let alice_lockup = make_pox_4_lockup(
         &alice,
         2,
-        512 * POX_THRESHOLD_STEPS_USTX,
+        ALICE_LOCKUP,
         PoxAddress::from_legacy(
             AddressHashMode::SerializeP2PKH,
             key_to_stacks_addr(&alice).bytes,
         ),
-        6,
-        tip,
+        4,
+        tip.block_height,
     );
+    let alice_pox_4_lock_nonce = 2;
+    let alice_first_pox_4_unlock_height =
+        burnchain.reward_cycle_to_block_height(first_v4_cycle + 4) - 1;
+    let alice_pox_4_start_burn_height = tip.block_height;
 
-    peer.tenure_with_txs(&[bob_lockup, alice_lockup], &mut coinbase_nonce);
-
-    let alice_balance = get_balance(&mut peer, &key_to_stacks_addr(&alice).into());
-    assert_eq!(alice_balance, 512 * POX_THRESHOLD_STEPS_USTX);
-    let bob_balance = get_balance(&mut peer, &key_to_stacks_addr(&bob).into());
-    assert_eq!(bob_balance, 512 * POX_THRESHOLD_STEPS_USTX);
+    latest_block = peer.tenure_with_txs(&[alice_lockup], &mut coinbase_nonce);
 
-    // now let's check some tx receipts
+    info!(
+        "Block height: {}",
+        get_tip(peer.sortdb.as_ref()).block_height
+    );
 
-    let alice_address = key_to_stacks_addr(&alice);
-    let bob_address = key_to_stacks_addr(&bob);
-    let blocks = observer.get_blocks();
-
-    let mut alice_txs = HashMap::new();
-    let mut bob_txs = HashMap::new();
-    let mut charlie_txs = HashMap::new();
-
-    debug!("Alice addr: {}, Bob addr: {}", alice_address, bob_address);
-
-    let mut tested_charlie = false;
-
-    for b in blocks.into_iter() {
-        for r in b.receipts.into_iter() {
-            if let TransactionOrigin::Stacks(ref t) = r.transaction {
-                let addr = t.auth.origin().address_testnet();
-                debug!("Transaction addr: {}", addr);
-                if addr == alice_address {
-                    alice_txs.insert(t.auth.get_origin_nonce(), r);
-                } else if addr == bob_address {
-                    bob_txs.insert(t.auth.get_origin_nonce(), r);
-                } else if addr == key_to_stacks_addr(&charlie) {
-                    assert!(
-                        r.execution_cost != ExecutionCost::zero(),
-                        "Execution cost is not zero!"
-                    );
-                    charlie_txs.insert(t.auth.get_origin_nonce(), r);
-
-                    tested_charlie = true;
-                }
-            }
-        }
+    // check that the "raw" reward set will contain entries for alice at the cycle start
+    for cycle_number in first_v4_cycle..(first_v4_cycle + 4) {
+        let cycle_start = burnchain.reward_cycle_to_block_height(cycle_number);
+        let reward_set_entries = get_reward_set_entries_at(&mut peer, &latest_block, cycle_start);
+        info!("----- {cycle_number} -----");
+        assert_eq!(reward_set_entries.len(), 1);
+        assert_eq!(
+            reward_set_entries[0].reward_address.bytes(),
+            key_to_stacks_addr(&alice).bytes.0.to_vec()
+        );
+        assert_eq!(reward_set_entries[0].amount_stacked, ALICE_LOCKUP,);
     }
 
-    assert!(tested_charlie, "Charlie TX must be tested");
-    // Alice should have three accepted transactions:
-    //  TX0 -> Alice's initial lockup in PoX 1
-    //  TX1 -> Alice's PoX 2 lockup
-    //  TX2 -> Alice's PoX 3 lockup
-    assert_eq!(alice_txs.len(), 3, "Alice should have 3 confirmed txs");
-    // Bob should have two accepted transactions:
-    //  TX0 -> Bob's initial lockup in PoX 2
-    //  TX1 -> Bob's attempt to lock again in PoX 1 -- this one should fail
-    //         because PoX 1 is now defunct. Checked via the tx receipt.
-    //  TX2 -> Bob's PoX 3 lockup
-    assert_eq!(bob_txs.len(), 3, "Bob should have 3 confirmed txs");
-    // Charlie should have one accepted transactions:
-    //  TX0 -> Charlie's delegation in PoX 2. This tx just checks that the
-    //         initialization code tracks costs in txs that occur after the
-    //         initialization code (which uses a free tracker).
-    assert_eq!(charlie_txs.len(), 1, "Charlie should have 1 confirmed txs");
-
-    //  TX0 -> Alice's initial lockup in PoX 1
-    assert!(
-        match alice_txs.get(&0).unwrap().result {
-            Value::Response(ref r) => r.committed,
-            _ => false,
-        },
-        "Alice tx0 should have committed okay"
-    );
-
-    //  TX1 -> Alice's PoX 2 lockup
-    assert!(
-        match alice_txs.get(&1).unwrap().result {
-            Value::Response(ref r) => r.committed,
-            _ => false,
-        },
-        "Alice tx1 should have committed okay"
-    );
-
-    //  TX2 -> Alice's PoX 3 lockup
-    assert!(
-        match alice_txs.get(&1).unwrap().result {
-            Value::Response(ref r) => r.committed,
-            _ => false,
-        },
-        "Alice tx3 should have committed okay"
-    );
-
-    //  TX0 -> Bob's initial lockup in PoX 2
-    assert!(
-        match bob_txs.get(&0).unwrap().result {
-            Value::Response(ref r) => r.committed,
-            _ => false,
-        },
-        "Bob tx0 should have committed okay"
-    );
-
-    //  TX1 -> Bob's attempt to lock again in PoX 1 -- this one should fail
-    //         because PoX 1 is now defunct. Checked via the tx receipt.
-    assert_eq!(
-        bob_txs.get(&1).unwrap().result,
-        Value::err_none(),
-        "Bob tx1 should have resulted in a runtime error"
-    );
-
-    //  TX0 -> Charlie's delegation in PoX 2. This tx just checks that the
-    //         initialization code tracks costs in txs that occur after the
-    //         initialization code (which uses a free tracker).
-    assert!(
-        match charlie_txs.get(&0).unwrap().result {
-            Value::Response(ref r) => r.committed,
-            _ => false,
-        },
-        "Charlie tx0 should have committed okay"
-    );
-}
-
-#[test]
-fn pox_auto_unlock_ab() {
-    pox_auto_unlock(true)
-}
-
-#[test]
-fn pox_auto_unlock_ba() {
-    pox_auto_unlock(false)
-}
-
-/// In this test case, two Stackers, Alice and Bob stack and interact with the
-///  PoX v1 contract and PoX v2 contract across the epoch transition, and then again
-///  in PoX v3.
-///
-/// Alice: stacks via PoX v1 for 4 cycles. The third of these cycles occurs after
-///        the PoX v1 -> v2 transition, and so Alice gets "early unlocked".
-///        After the early unlock, Alice re-stacks in PoX v2
-/// Bob:   stacks via PoX v2 for 6 cycles. He attempted to stack via PoX v1 as well,
-///        but is forbidden because he has already placed an account lock via PoX v2.
-///
-/// Note: this test is symmetric over the order of alice and bob's stacking calls.
-///       when alice goes first, the auto-unlock code doesn't need to perform a "move"
-///       when bob goes first, the auto-unlock code does need to perform a "move"
-fn pox_auto_unlock(alice_first: bool) {
-    let EXPECTED_FIRST_V2_CYCLE = 8;
-    // the sim environment produces 25 empty sortitions before
-    //  tenures start being tracked.
-    let EMPTY_SORTITIONS = 25;
-
-    let (epochs, pox_constants) = make_test_epochs_pox();
-
-    let mut burnchain = Burnchain::default_unittest(
-        0,
-        &BurnchainHeaderHash::from_hex(BITCOIN_REGTEST_FIRST_BLOCK_HASH).unwrap(),
-    );
-    burnchain.pox_constants = pox_constants.clone();
-
-    let first_v2_cycle = burnchain
-        .block_height_to_reward_cycle(burnchain.pox_constants.v1_unlock_height as u64)
-        .unwrap()
-        + 1;
-
-    let first_v3_cycle = burnchain
-        .block_height_to_reward_cycle(burnchain.pox_constants.pox_3_activation_height as u64)
-        .unwrap()
-        + 1;
-
-    assert_eq!(first_v2_cycle, EXPECTED_FIRST_V2_CYCLE);
-
-    eprintln!("First v2 cycle = {}", first_v2_cycle);
-
-    let observer = TestEventObserver::new();
-
-    let (mut peer, mut keys) = instantiate_pox_peer_with_epoch(
-        &burnchain,
-        &format!("{}-{}", function_name!(), alice_first),
-        Some(epochs.clone()),
-        Some(&observer),
-    );
-
-    peer.config.check_pox_invariants =
-        Some((EXPECTED_FIRST_V2_CYCLE, EXPECTED_FIRST_V2_CYCLE + 10));
+    // check the first reward cycle when Alice's tokens get stacked
+    let tip_burn_block_height = get_par_burn_block_height(peer.chainstate(), &latest_block);
+    let alice_first_v4_reward_cycle = 1 + burnchain
+        .block_height_to_reward_cycle(tip_burn_block_height)
+        .unwrap();
 
-    let alice = keys.pop().unwrap();
-    let bob = keys.pop().unwrap();
+    let height_target = burnchain.reward_cycle_to_block_height(alice_first_v4_reward_cycle) + 1;
 
-    let mut coinbase_nonce = 0;
+    // alice locked, so balance should be 0
+    let alice_balance = get_balance(&mut peer, &alice_principal);
+    assert_eq!(alice_balance, 0);
 
-    // produce blocks until epoch 2.1
-    while get_tip(peer.sortdb.as_ref()).block_height <= epochs[3].start_height {
-        peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    // advance to the first v3 reward cycle
+    while get_tip(peer.sortdb.as_ref()).block_height < height_target {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
     }
 
-    // in the next tenure, PoX 2 should now exist.
-    // Lets have Bob lock up for v2
-    // this will lock for cycles 8, 9, 10, and 11
-    //  the first v2 cycle will be 8
     let tip = get_tip(peer.sortdb.as_ref());
-
-    let alice_lockup = make_pox_2_lockup(
-        &alice,
-        0,
-        1024 * POX_THRESHOLD_STEPS_USTX,
+    let bob_lockup = make_pox_4_lockup(
+        &bob,
+        2,
+        BOB_LOCKUP,
         PoxAddress::from_legacy(
             AddressHashMode::SerializeP2PKH,
-            key_to_stacks_addr(&alice).bytes,
+            key_to_stacks_addr(&bob).bytes,
         ),
-        6,
+        3,
         tip.block_height,
     );
 
-    let bob_lockup = make_pox_2_lockup(
-        &bob,
-        0,
-        1 * POX_THRESHOLD_STEPS_USTX,
+    // Alice can stack-extend in PoX v2
+    let alice_lockup = make_pox_4_extend(
+        &alice,
+        3,
         PoxAddress::from_legacy(
             AddressHashMode::SerializeP2PKH,
-            key_to_stacks_addr(&bob).bytes,
+            key_to_stacks_addr(&alice).bytes,
         ),
         6,
-        tip.block_height,
-    );
-
-    let txs = if alice_first {
-        [alice_lockup, bob_lockup]
-    } else {
-        [bob_lockup, alice_lockup]
-    };
-    let mut latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
-
-    // check that the "raw" reward set will contain entries for alice and bob
-    //  for the pox-2 cycles
-    for cycle_number in EXPECTED_FIRST_V2_CYCLE..first_v3_cycle {
-        let cycle_start = burnchain.reward_cycle_to_block_height(cycle_number);
-        let reward_set_entries = get_reward_set_entries_at(&mut peer, &latest_block, cycle_start);
-        assert_eq!(reward_set_entries.len(), 2);
-        assert_eq!(
-            reward_set_entries[0].reward_address.bytes(),
-            key_to_stacks_addr(&bob).bytes.0.to_vec()
-        );
-        assert_eq!(
-            reward_set_entries[1].reward_address.bytes(),
-            key_to_stacks_addr(&alice).bytes.0.to_vec()
-        );
-    }
-
-    // we'll produce blocks until the next reward cycle gets through the "handled start" code
-    //  this is one block after the reward cycle starts
-    let height_target = burnchain.reward_cycle_to_block_height(EXPECTED_FIRST_V2_CYCLE) + 1;
-
-    // but first, check that bob has locked tokens at (height_target + 1)
-    let bob_bal = get_stx_account_at(
-        &mut peer,
-        &latest_block,
-        &key_to_stacks_addr(&bob).to_account_principal(),
     );
-    assert_eq!(bob_bal.amount_locked(), POX_THRESHOLD_STEPS_USTX);
 
-    while get_tip(peer.sortdb.as_ref()).block_height < height_target {
-        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-    }
+    let alice_pox_4_extend_nonce = 3;
+    let alice_extend_pox_4_unlock_height =
+        burnchain.reward_cycle_to_block_height(first_v4_cycle + 10) - 1;
 
-    let first_auto_unlock_coinbase = height_target - 1 - EMPTY_SORTITIONS;
+    latest_block = peer.tenure_with_txs(&[bob_lockup, alice_lockup], &mut coinbase_nonce);
 
-    // check that the "raw" reward sets for all cycles just contains entries for alice
-    //  at the cycle start
-    for cycle_number in EXPECTED_FIRST_V2_CYCLE..first_v3_cycle {
+    // check that the "raw" reward set will contain entries for alice at the cycle start
+    for cycle_number in first_v4_cycle..(first_v4_cycle + 1) {
         let cycle_start = burnchain.reward_cycle_to_block_height(cycle_number);
         let reward_set_entries = get_reward_set_entries_at(&mut peer, &latest_block, cycle_start);
         assert_eq!(reward_set_entries.len(), 1);
@@ -691,156 +551,26 @@ fn pox_auto_unlock(alice_first: bool) {
             reward_set_entries[0].reward_address.bytes(),
             key_to_stacks_addr(&alice).bytes.0.to_vec()
         );
+        assert_eq!(reward_set_entries[0].amount_stacked, ALICE_LOCKUP);
     }
 
-    // now check that bob has an unlock height of `height_target`
-    let bob_bal = get_stx_account_at(
-        &mut peer,
-        &latest_block,
-        &key_to_stacks_addr(&bob).to_account_principal(),
-    );
-    assert_eq!(bob_bal.unlock_height(), height_target);
-
-    // but bob's still locked at (height_target): the unlock is accelerated to the "next" burn block
-    assert_eq!(bob_bal.amount_locked(), 10000000000);
-
-    // check that the total reward cycle amounts have decremented correctly
-    for cycle_number in EXPECTED_FIRST_V2_CYCLE..first_v3_cycle {
-        assert_eq!(
-            get_reward_cycle_total(&mut peer, &latest_block, cycle_number),
-            1024 * POX_THRESHOLD_STEPS_USTX
-        );
-    }
-
-    // check that bob is fully unlocked at next block
-    latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-
-    let bob_bal = get_stx_account_at(
-        &mut peer,
-        &latest_block,
-        &key_to_stacks_addr(&bob).to_account_principal(),
-    );
-    assert_eq!(bob_bal.unlock_height(), 0);
-    assert_eq!(bob_bal.amount_locked(), 0);
-
-    // check that the total reward cycle amounts have decremented correctly
-    for cycle_number in EXPECTED_FIRST_V2_CYCLE..first_v3_cycle {
-        assert_eq!(
-            get_reward_cycle_total(&mut peer, &latest_block, cycle_number),
-            1024 * POX_THRESHOLD_STEPS_USTX
-        );
-    }
-
-    // check that bob's stacking-state is gone and alice's stacking-state is correct
-    assert!(
-        get_stacking_state_pox_2(
-            &mut peer,
-            &latest_block,
-            &key_to_stacks_addr(&bob).to_account_principal()
-        )
-        .is_none(),
-        "Bob should not have a stacking-state entry"
-    );
-
-    let alice_state = get_stacking_state_pox_2(
-        &mut peer,
-        &latest_block,
-        &key_to_stacks_addr(&alice).to_account_principal(),
-    )
-    .expect("Alice should have stacking-state entry")
-    .expect_tuple();
-    let reward_indexes_str = format!("{}", alice_state.get("reward-set-indexes").unwrap());
-    assert_eq!(reward_indexes_str, "(u0 u0 u0 u0 u0 u0)");
-
-    // now, lets check behavior in Epochs 2.2-2.4, with pox-3 auto unlock tests
-
-    // produce blocks until epoch 2.2
-    while get_tip(peer.sortdb.as_ref()).block_height <= epochs[4].start_height {
-        peer.tenure_with_txs(&[], &mut coinbase_nonce);
-        let alice_balance = get_balance(&mut peer, &key_to_stacks_addr(&alice).into());
-        assert_eq!(alice_balance, 0);
-    }
-
-    // check that alice is unlocked now
-    peer.tenure_with_txs(&[], &mut coinbase_nonce);
-    let alice_balance = get_balance(&mut peer, &key_to_stacks_addr(&alice).into());
-    assert_eq!(alice_balance, 1024 * POX_THRESHOLD_STEPS_USTX);
-
-    // produce blocks until epoch 2.4
-    while get_tip(peer.sortdb.as_ref()).block_height <= epochs[6].start_height {
-        peer.tenure_with_txs(&[], &mut coinbase_nonce);
-    }
-
-    // repeat the lockups as before, so we can test the pox-3 auto unlock behavior
-    let tip = get_tip(peer.sortdb.as_ref());
-
-    let alice_lockup = make_pox_3_lockup(
-        &alice,
-        1,
-        1024 * POX_THRESHOLD_STEPS_USTX,
-        PoxAddress::from_legacy(
-            AddressHashMode::SerializeP2PKH,
-            key_to_stacks_addr(&alice).bytes,
-        ),
-        6,
-        tip.block_height,
-    );
-
-    let bob_lockup = make_pox_3_lockup(
-        &bob,
-        1,
-        1 * POX_THRESHOLD_STEPS_USTX,
-        PoxAddress::from_legacy(
-            AddressHashMode::SerializeP2PKH,
-            key_to_stacks_addr(&bob).bytes,
-        ),
-        6,
-        tip.block_height,
-    );
-
-    let txs = if alice_first {
-        [alice_lockup, bob_lockup]
-    } else {
-        [bob_lockup, alice_lockup]
-    };
-    latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
-
-    // check that the "raw" reward set will contain entries for alice and bob
-    //  for the pox-3 cycles
-    for cycle_number in first_v3_cycle..(first_v3_cycle + 6) {
+    for cycle_number in (first_v4_cycle + 1)..(first_v4_cycle + 4) {
         let cycle_start = burnchain.reward_cycle_to_block_height(cycle_number);
         let reward_set_entries = get_reward_set_entries_at(&mut peer, &latest_block, cycle_start);
         assert_eq!(reward_set_entries.len(), 2);
-        assert_eq!(
-            reward_set_entries[0].reward_address.bytes(),
-            key_to_stacks_addr(&bob).bytes.0.to_vec()
-        );
         assert_eq!(
             reward_set_entries[1].reward_address.bytes(),
             key_to_stacks_addr(&alice).bytes.0.to_vec()
         );
+        assert_eq!(reward_set_entries[1].amount_stacked, ALICE_LOCKUP);
+        assert_eq!(
+            reward_set_entries[0].reward_address.bytes(),
+            key_to_stacks_addr(&bob).bytes.0.to_vec()
+        );
+        assert_eq!(reward_set_entries[0].amount_stacked, BOB_LOCKUP);
     }
 
-    // we'll produce blocks until the next reward cycle gets through the "handled start" code
-    //  this is one block after the reward cycle starts
-    let height_target = burnchain.reward_cycle_to_block_height(first_v3_cycle) + 1;
-    let second_auto_unlock_coinbase = height_target - 1 - EMPTY_SORTITIONS;
-
-    // but first, check that bob has locked tokens at (height_target + 1)
-    let bob_bal = get_stx_account_at(
-        &mut peer,
-        &latest_block,
-        &key_to_stacks_addr(&bob).to_account_principal(),
-    );
-    assert_eq!(bob_bal.amount_locked(), POX_THRESHOLD_STEPS_USTX);
-
-    while get_tip(peer.sortdb.as_ref()).block_height < height_target {
-        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-    }
-
-    // check that the "raw" reward sets for all cycles just contains entries for alice
-    //  at the cycle start
-    for cycle_number in first_v3_cycle..(first_v3_cycle + 6) {
+    for cycle_number in (first_v4_cycle + 4)..(first_v4_cycle + 10) {
         let cycle_start = burnchain.reward_cycle_to_block_height(cycle_number);
         let reward_set_entries = get_reward_set_entries_at(&mut peer, &latest_block, cycle_start);
         assert_eq!(reward_set_entries.len(), 1);
@@ -848,60 +578,9 @@ fn pox_auto_unlock(alice_first: bool) {
             reward_set_entries[0].reward_address.bytes(),
             key_to_stacks_addr(&alice).bytes.0.to_vec()
         );
+        assert_eq!(reward_set_entries[0].amount_stacked, ALICE_LOCKUP);
     }
 
-    // now check that bob has an unlock height of `height_target`
-    let bob_bal = get_stx_account_at(
-        &mut peer,
-        &latest_block,
-        &key_to_stacks_addr(&bob).to_account_principal(),
-    );
-    assert_eq!(bob_bal.unlock_height(), height_target);
-    // but bob's still locked at (height_target): the unlock is accelerated to the "next" burn block
-    assert_eq!(bob_bal.amount_locked(), 10000000000);
-
-    // check that the total reward cycle amounts have decremented correctly
-    for cycle_number in first_v3_cycle..(first_v3_cycle + 6) {
-        assert_eq!(
-            get_reward_cycle_total(&mut peer, &latest_block, cycle_number),
-            1024 * POX_THRESHOLD_STEPS_USTX
-        );
-    }
-
-    // check that bob's stacking-state is gone and alice's stacking-state is correct
-    assert!(
-        get_stacking_state_pox(
-            &mut peer,
-            &latest_block,
-            &key_to_stacks_addr(&bob).to_account_principal(),
-            POX_3_NAME,
-        )
-        .is_none(),
-        "Bob should not have a stacking-state entry"
-    );
-
-    let alice_state = get_stacking_state_pox(
-        &mut peer,
-        &latest_block,
-        &key_to_stacks_addr(&alice).to_account_principal(),
-        POX_3_NAME,
-    )
-    .expect("Alice should have stacking-state entry")
-    .expect_tuple();
-    let reward_indexes_str = format!("{}", alice_state.get("reward-set-indexes").unwrap());
-    assert_eq!(reward_indexes_str, "(u0 u0 u0 u0 u0 u0)");
-
-    // check that bob is fully unlocked at next block
-    latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-
-    let bob_bal = get_stx_account_at(
-        &mut peer,
-        &latest_block,
-        &key_to_stacks_addr(&bob).to_account_principal(),
-    );
-    assert_eq!(bob_bal.unlock_height(), 0);
-    assert_eq!(bob_bal.amount_locked(), 0);
-
     // now let's check some tx receipts
 
     let alice_address = key_to_stacks_addr(&alice);
@@ -910,2018 +589,6 @@ fn pox_auto_unlock(alice_first: bool) {
 
     let mut alice_txs = HashMap::new();
     let mut bob_txs = HashMap::new();
-    let mut coinbase_txs = vec![];
-
-    for b in blocks.into_iter() {
-        for (i, r) in b.receipts.into_iter().enumerate() {
-            if i == 0 {
-                coinbase_txs.push(r);
-                continue;
-            }
-            match r.transaction {
-                TransactionOrigin::Stacks(ref t) => {
-                    let addr = t.auth.origin().address_testnet();
-                    if addr == alice_address {
-                        alice_txs.insert(t.auth.get_origin_nonce(), r);
-                    } else if addr == bob_address {
-                        bob_txs.insert(t.auth.get_origin_nonce(), r);
-                    }
-                }
-                _ => {}
-            }
-        }
-    }
-
-    assert_eq!(alice_txs.len(), 2);
-    assert_eq!(bob_txs.len(), 2);
-
-    //  TX0 -> Bob's initial lockup in PoX 2
-    assert!(
-        match bob_txs.get(&0).unwrap().result {
-            Value::Response(ref r) => r.committed,
-            _ => false,
-        },
-        "Bob tx0 should have committed okay"
-    );
-
-    assert_eq!(coinbase_txs.len(), 38);
-
-    info!(
-        "Expected first auto-unlock coinbase index: {}",
-        first_auto_unlock_coinbase
-    );
-
-    // Check that the event produced by "handle-unlock" has a well-formed print event
-    // and that this event is included as part of the coinbase tx
-    for unlock_coinbase_index in [first_auto_unlock_coinbase, second_auto_unlock_coinbase] {
-        // expect the unlock to occur 1 block after the handle-unlock method was invoked.
-        let expected_unlock_height = unlock_coinbase_index + EMPTY_SORTITIONS + 1;
-        let expected_cycle = pox_constants
-            .block_height_to_reward_cycle(0, expected_unlock_height)
-            .unwrap();
-
-        let auto_unlock_tx = coinbase_txs[unlock_coinbase_index as usize].events[0].clone();
-        let pox_addr_val = generate_pox_clarity_value("60c59ab11f7063ef44c16d3dc856f76bbb915eba");
-        let auto_unlock_op_data = HashMap::from([
-            ("first-cycle-locked", Value::UInt(expected_cycle.into())),
-            ("first-unlocked-cycle", Value::UInt(expected_cycle.into())),
-            ("pox-addr", pox_addr_val),
-        ]);
-        let common_data = PoxPrintFields {
-            op_name: "handle-unlock".to_string(),
-            stacker: Value::Principal(
-                StacksAddress::from_string("ST1GCB6NH3XR67VT4R5PKVJ2PYXNVQ4AYQATXNP4P")
-                    .unwrap()
-                    .to_account_principal(),
-            ),
-            balance: Value::UInt(10230000000000),
-            locked: Value::UInt(10000000000),
-            burnchain_unlock_height: Value::UInt(expected_unlock_height.into()),
-        };
-        check_pox_print_event(&auto_unlock_tx, common_data, auto_unlock_op_data);
-    }
-}
-
-/// In this test case, Alice delegates to Bob.
-///  Bob stacks Alice's funds via PoX v2 for 6 cycles. In the third cycle,
-///  Bob increases Alice's stacking amount.
-///
-#[test]
-fn delegate_stack_increase() {
-    let EXPECTED_FIRST_V2_CYCLE = 8;
-
-    let (epochs, pox_constants) = make_test_epochs_pox();
-
-    let mut burnchain = Burnchain::default_unittest(
-        0,
-        &BurnchainHeaderHash::from_hex(BITCOIN_REGTEST_FIRST_BLOCK_HASH).unwrap(),
-    );
-    burnchain.pox_constants = pox_constants.clone();
-
-    let first_v2_cycle = burnchain
-        .block_height_to_reward_cycle(burnchain.pox_constants.v1_unlock_height as u64)
-        .unwrap()
-        + 1;
-
-    let first_v3_cycle = burnchain
-        .block_height_to_reward_cycle(burnchain.pox_constants.pox_3_activation_height as u64)
-        .unwrap()
-        + 1;
-
-    assert_eq!(first_v2_cycle, EXPECTED_FIRST_V2_CYCLE);
-
-    let observer = TestEventObserver::new();
-
-    let (mut peer, mut keys) = instantiate_pox_peer_with_epoch(
-        &burnchain,
-        function_name!(),
-        Some(epochs.clone()),
-        Some(&observer),
-    );
-
-    peer.config.check_pox_invariants =
-        Some((EXPECTED_FIRST_V2_CYCLE, EXPECTED_FIRST_V2_CYCLE + 10));
-
-    let num_blocks = 35;
-
-    let alice = keys.pop().unwrap();
-    let alice_address = key_to_stacks_addr(&alice);
-    let alice_principal = PrincipalData::from(alice_address.clone());
-    let bob = keys.pop().unwrap();
-    let bob_address = key_to_stacks_addr(&bob);
-    let bob_principal = PrincipalData::from(bob_address.clone());
-    let bob_pox_addr = make_pox_addr(AddressHashMode::SerializeP2PKH, bob_address.bytes.clone());
-    let mut alice_nonce = 0;
-    let mut bob_nonce = 0;
-
-    let alice_delegation_amount = 1023 * POX_THRESHOLD_STEPS_USTX;
-    let alice_first_lock_amount = 512 * POX_THRESHOLD_STEPS_USTX;
-
-    let mut coinbase_nonce = 0;
-
-    // produce blocks until epoch 2.1
-    while get_tip(peer.sortdb.as_ref()).block_height <= epochs[3].start_height {
-        peer.tenure_with_txs(&[], &mut coinbase_nonce);
-    }
-
-    // in the next tenure, PoX 2 should now exist.
-    let tip = get_tip(peer.sortdb.as_ref());
-
-    // submit delegation tx
-    let alice_delegation_1 = make_pox_2_contract_call(
-        &alice,
-        alice_nonce,
-        "delegate-stx",
-        vec![
-            Value::UInt(alice_delegation_amount),
-            bob_principal.clone().into(),
-            Value::none(),
-            Value::none(),
-        ],
-    );
-
-    let alice_delegation_pox_2_nonce = alice_nonce;
-    alice_nonce += 1;
-
-    let delegate_stack_tx = make_pox_2_contract_call(
-        &bob,
-        bob_nonce,
-        "delegate-stack-stx",
-        vec![
-            alice_principal.clone().into(),
-            Value::UInt(alice_first_lock_amount),
-            bob_pox_addr.clone(),
-            Value::UInt(tip.block_height as u128),
-            Value::UInt(6),
-        ],
-    );
-
-    bob_nonce += 1;
-
-    let mut latest_block = peer.tenure_with_txs(
-        &[alice_delegation_1, delegate_stack_tx],
-        &mut coinbase_nonce,
-    );
-
-    let expected_pox_2_unlock_ht =
-        burnchain.reward_cycle_to_block_height(EXPECTED_FIRST_V2_CYCLE + 6) - 1;
-    let alice_bal = get_stx_account_at(&mut peer, &latest_block, &alice_principal);
-    assert_eq!(alice_bal.amount_locked(), alice_first_lock_amount);
-    assert_eq!(alice_bal.unlock_height(), expected_pox_2_unlock_ht);
-
-    // check that the partial stacking state contains entries for bob
-    for cycle_number in EXPECTED_FIRST_V2_CYCLE..(EXPECTED_FIRST_V2_CYCLE + 6) {
-        let partial_stacked = get_partial_stacked(
-            &mut peer,
-            &latest_block,
-            &bob_pox_addr,
-            cycle_number,
-            &bob_principal,
-            POX_2_NAME,
-        );
-        assert_eq!(partial_stacked, 512 * POX_THRESHOLD_STEPS_USTX);
-    }
-
-    // we'll produce blocks until the 1st reward cycle gets through the "handled start" code
-    //  this is one block after the reward cycle starts
-    let height_target = burnchain.reward_cycle_to_block_height(EXPECTED_FIRST_V2_CYCLE + 1) + 1;
-
-    while get_tip(peer.sortdb.as_ref()).block_height < height_target {
-        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-    }
-
-    let alice_bal = get_stx_account_at(&mut peer, &latest_block, &alice_principal);
-
-    assert_eq!(alice_bal.amount_locked(), alice_first_lock_amount);
-
-    // check that the partial stacking state contains entries for bob
-    for cycle_number in EXPECTED_FIRST_V2_CYCLE..(EXPECTED_FIRST_V2_CYCLE + 6) {
-        let partial_stacked = get_partial_stacked(
-            &mut peer,
-            &latest_block,
-            &bob_pox_addr,
-            cycle_number,
-            &bob_principal,
-            POX_2_NAME,
-        );
-        assert_eq!(partial_stacked, 512 * POX_THRESHOLD_STEPS_USTX);
-    }
-
-    let mut txs_to_submit = vec![];
-
-    let fail_direct_increase_delegation = alice_nonce;
-    txs_to_submit.push(make_pox_2_contract_call(
-        &alice,
-        alice_nonce,
-        "stack-increase",
-        vec![Value::UInt(1)],
-    ));
-    alice_nonce += 1;
-
-    let fail_delegate_too_much_locked = bob_nonce;
-    txs_to_submit.push(make_pox_2_contract_call(
-        &bob,
-        bob_nonce,
-        "delegate-stack-increase",
-        vec![
-            alice_principal.clone().into(),
-            bob_pox_addr.clone(),
-            Value::UInt(alice_delegation_amount - alice_first_lock_amount + 1),
-        ],
-    ));
-    bob_nonce += 1;
-
-    let fail_invalid_amount = bob_nonce;
-    txs_to_submit.push(make_pox_2_contract_call(
-        &bob,
-        bob_nonce,
-        "delegate-stack-increase",
-        vec![
-            alice_principal.clone().into(),
-            bob_pox_addr.clone(),
-            Value::UInt(0),
-        ],
-    ));
-    bob_nonce += 1;
-
-    let fail_insufficient_funds = bob_nonce;
-    txs_to_submit.push(make_pox_2_contract_call(
-        &bob,
-        bob_nonce,
-        "delegate-stack-increase",
-        vec![
-            alice_principal.clone().into(),
-            bob_pox_addr.clone(),
-            Value::UInt(alice_bal.amount_unlocked() + 1),
-        ],
-    ));
-    bob_nonce += 1;
-
-    txs_to_submit.push(make_pox_2_contract_call(
-        &bob,
-        bob_nonce,
-        "delegate-stack-increase",
-        vec![
-            alice_principal.clone().into(),
-            bob_pox_addr.clone(),
-            Value::UInt(alice_delegation_amount - alice_first_lock_amount),
-        ],
-    ));
-    let bob_delegate_increase_pox_2_nonce = bob_nonce;
-    bob_nonce += 1;
-
-    latest_block = peer.tenure_with_txs(&txs_to_submit, &mut coinbase_nonce);
-
-    let alice_bal = get_stx_account_at(&mut peer, &latest_block, &alice_principal);
-    assert_eq!(alice_bal.amount_locked(), alice_delegation_amount);
-    assert_eq!(alice_bal.unlock_height(), expected_pox_2_unlock_ht);
-
-    // check that the partial stacking state contains entries for bob and they've incremented correctly
-    for cycle_number in (EXPECTED_FIRST_V2_CYCLE)..(EXPECTED_FIRST_V2_CYCLE + 2) {
-        let partial_stacked = get_partial_stacked(
-            &mut peer,
-            &latest_block,
-            &bob_pox_addr,
-            cycle_number,
-            &bob_principal,
-            POX_2_NAME,
-        );
-        assert_eq!(partial_stacked, alice_first_lock_amount);
-    }
-
-    for cycle_number in (EXPECTED_FIRST_V2_CYCLE + 2)..(EXPECTED_FIRST_V2_CYCLE + 6) {
-        let partial_stacked = get_partial_stacked(
-            &mut peer,
-            &latest_block,
-            &bob_pox_addr,
-            cycle_number,
-            &bob_principal,
-            POX_2_NAME,
-        );
-        assert_eq!(partial_stacked, alice_delegation_amount,);
-    }
-
-    // okay, now let's progress through epochs 2.2-2.4, and perform the delegation tests
-    //  on pox-3
-
-    // roll the chain forward until just before Epoch-2.2
-    while get_tip(peer.sortdb.as_ref()).block_height < epochs[4].start_height {
-        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-        // at this point, alice's balance should always include this half lockup
-        assert_eq!(
-            get_stx_account_at(&mut peer, &latest_block, &alice_principal).amount_locked(),
-            alice_delegation_amount
-        );
-        assert_eq!(
-            get_stx_account_at(&mut peer, &latest_block, &bob_principal).amount_locked(),
-            0,
-        );
-    }
-
-    // this block is mined in epoch-2.2
-    latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-    assert_eq!(
-        get_stx_account_at(&mut peer, &latest_block, &alice_principal).amount_locked(),
-        alice_delegation_amount
-    );
-    assert_eq!(
-        get_stx_account_at(&mut peer, &latest_block, &bob_principal).amount_locked(),
-        0,
-    );
-    // this block should unlock alice's balance
-    latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-    assert_eq!(
-        get_stx_account_at(&mut peer, &latest_block, &alice_principal).amount_locked(),
-        0,
-    );
-    assert_eq!(
-        get_stx_account_at(&mut peer, &latest_block, &bob_principal).amount_locked(),
-        0,
-    );
-    assert_eq!(
-        get_stx_account_at(&mut peer, &latest_block, &alice_principal).amount_unlocked(),
-        1024 * POX_THRESHOLD_STEPS_USTX
-    );
-    assert_eq!(
-        get_stx_account_at(&mut peer, &latest_block, &bob_principal).amount_unlocked(),
-        1024 * POX_THRESHOLD_STEPS_USTX
-    );
-
-    // Roll to Epoch-2.4 and re-do the above tests
-    while get_tip(peer.sortdb.as_ref()).block_height <= epochs[6].start_height {
-        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-    }
-
-    let tip = get_tip(peer.sortdb.as_ref());
-
-    // submit delegation tx
-    let alice_delegation_1 = make_pox_3_contract_call(
-        &alice,
-        alice_nonce,
-        "delegate-stx",
-        vec![
-            Value::UInt(alice_delegation_amount),
-            bob_principal.clone().into(),
-            Value::none(),
-            Value::none(),
-        ],
-    );
-    let alice_delegation_pox_3_nonce = alice_nonce;
-    alice_nonce += 1;
-
-    let delegate_stack_tx = make_pox_3_contract_call(
-        &bob,
-        bob_nonce,
-        "delegate-stack-stx",
-        vec![
-            alice_principal.clone().into(),
-            Value::UInt(alice_first_lock_amount),
-            bob_pox_addr.clone(),
-            Value::UInt(tip.block_height as u128),
-            Value::UInt(6),
-        ],
-    );
-
-    bob_nonce += 1;
-
-    latest_block = peer.tenure_with_txs(
-        &[alice_delegation_1, delegate_stack_tx],
-        &mut coinbase_nonce,
-    );
-
-    let expected_pox_3_unlock_ht = burnchain.reward_cycle_to_block_height(first_v3_cycle + 6) - 1;
-    let alice_bal = get_stx_account_at(&mut peer, &latest_block, &alice_principal);
-    assert_eq!(alice_bal.amount_locked(), alice_first_lock_amount);
-    assert_eq!(alice_bal.unlock_height(), expected_pox_3_unlock_ht);
-
-    // check that the partial stacking state contains entries for bob
-    for cycle_number in first_v3_cycle..(first_v3_cycle + 6) {
-        let partial_stacked = get_partial_stacked(
-            &mut peer,
-            &latest_block,
-            &bob_pox_addr,
-            cycle_number,
-            &bob_principal,
-            POX_3_NAME,
-        );
-        assert_eq!(partial_stacked, 512 * POX_THRESHOLD_STEPS_USTX);
-    }
-
-    // we'll produce blocks until the 3rd reward cycle gets through the "handled start" code
-    //  this is one block after the reward cycle starts
-    let height_target = burnchain.reward_cycle_to_block_height(first_v3_cycle + 3) + 1;
-
-    while get_tip(peer.sortdb.as_ref()).block_height < height_target {
-        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-    }
-
-    let alice_bal = get_stx_account_at(&mut peer, &latest_block, &alice_principal);
-    assert_eq!(alice_bal.amount_locked(), alice_first_lock_amount);
-    let bob_bal = get_stx_account_at(&mut peer, &latest_block, &bob_principal);
-    assert_eq!(bob_bal.amount_locked(), 0);
-
-    // check that the partial stacking state contains entries for bob
-    for cycle_number in first_v3_cycle..(first_v3_cycle + 6) {
-        let partial_stacked = get_partial_stacked(
-            &mut peer,
-            &latest_block,
-            &bob_pox_addr,
-            cycle_number,
-            &bob_principal,
-            POX_3_NAME,
-        );
-        assert_eq!(partial_stacked, 512 * POX_THRESHOLD_STEPS_USTX);
-    }
-
-    let mut txs_to_submit = vec![];
-
-    let pox_3_fail_direct_increase_delegation = alice_nonce;
-    txs_to_submit.push(make_pox_3_contract_call(
-        &alice,
-        alice_nonce,
-        "stack-increase",
-        vec![Value::UInt(1)],
-    ));
-    alice_nonce += 1;
-
-    let pox_3_fail_delegate_too_much_locked = bob_nonce;
-    txs_to_submit.push(make_pox_3_contract_call(
-        &bob,
-        bob_nonce,
-        "delegate-stack-increase",
-        vec![
-            alice_principal.clone().into(),
-            bob_pox_addr.clone(),
-            Value::UInt(alice_delegation_amount - alice_first_lock_amount + 1),
-        ],
-    ));
-    bob_nonce += 1;
-
-    let pox_3_fail_invalid_amount = bob_nonce;
-    txs_to_submit.push(make_pox_3_contract_call(
-        &bob,
-        bob_nonce,
-        "delegate-stack-increase",
-        vec![
-            alice_principal.clone().into(),
-            bob_pox_addr.clone(),
-            Value::UInt(0),
-        ],
-    ));
-    bob_nonce += 1;
-
-    let pox_3_fail_insufficient_funds = bob_nonce;
-    txs_to_submit.push(make_pox_3_contract_call(
-        &bob,
-        bob_nonce,
-        "delegate-stack-increase",
-        vec![
-            alice_principal.clone().into(),
-            bob_pox_addr.clone(),
-            Value::UInt(alice_bal.amount_unlocked() + 1),
-        ],
-    ));
-    bob_nonce += 1;
-
-    txs_to_submit.push(make_pox_3_contract_call(
-        &bob,
-        bob_nonce,
-        "delegate-stack-increase",
-        vec![
-            alice_principal.clone().into(),
-            bob_pox_addr.clone(),
-            Value::UInt(alice_delegation_amount - alice_first_lock_amount),
-        ],
-    ));
-    let bob_delegate_increase_pox_3_nonce = bob_nonce;
-    bob_nonce += 1;
-
-    latest_block = peer.tenure_with_txs(&txs_to_submit, &mut coinbase_nonce);
-
-    assert_eq!(
-        get_stx_account_at(&mut peer, &latest_block, &alice_principal).amount_locked(),
-        alice_delegation_amount
-    );
-
-    assert_eq!(
-        get_stx_account_at(&mut peer, &latest_block, &alice_principal).unlock_height(),
-        expected_pox_3_unlock_ht,
-    );
-
-    // check that the partial stacking state contains entries for bob and they've incremented correctly
-    for cycle_number in first_v3_cycle..(first_v3_cycle + 4) {
-        let partial_stacked = get_partial_stacked(
-            &mut peer,
-            &latest_block,
-            &bob_pox_addr,
-            cycle_number,
-            &bob_principal,
-            POX_3_NAME,
-        );
-        assert_eq!(
-            partial_stacked,
-            alice_first_lock_amount,
-            "Unexpected partially stacked amount in cycle: {} = {} + {}",
-            cycle_number,
-            first_v3_cycle,
-            first_v3_cycle - cycle_number,
-        );
-    }
-
-    for cycle_number in (first_v3_cycle + 4)..(first_v3_cycle + 6) {
-        let partial_stacked = get_partial_stacked(
-            &mut peer,
-            &latest_block,
-            &bob_pox_addr,
-            cycle_number,
-            &bob_principal,
-            POX_3_NAME,
-        );
-        assert_eq!(partial_stacked, alice_delegation_amount);
-    }
-
-    // now let's check some tx receipts
-
-    let alice_address = key_to_stacks_addr(&alice);
-    let blocks = observer.get_blocks();
-
-    let mut alice_txs = HashMap::new();
-    let mut bob_txs = HashMap::new();
-
-    for b in blocks.into_iter() {
-        for r in b.receipts.into_iter() {
-            if let TransactionOrigin::Stacks(ref t) = r.transaction {
-                let addr = t.auth.origin().address_testnet();
-                if addr == alice_address {
-                    alice_txs.insert(t.auth.get_origin_nonce(), r);
-                } else if addr == bob_address {
-                    bob_txs.insert(t.auth.get_origin_nonce(), r);
-                }
-            }
-        }
-    }
-
-    assert_eq!(alice_txs.len() as u64, 4);
-    assert_eq!(bob_txs.len() as u64, 10);
-
-    // transaction should fail because Alice cannot increase her own stacking amount while delegating
-    assert_eq!(
-        &alice_txs[&fail_direct_increase_delegation]
-            .result
-            .to_string(),
-        "(err 20)"
-    );
-
-    // transaction should fail because Alice did not delegate enough funds to Bob
-    assert_eq!(
-        &bob_txs[&fail_delegate_too_much_locked].result.to_string(),
-        "(err 22)"
-    );
-
-    // transaction should fail because Alice doesn't have enough funds
-    assert_eq!(
-        &bob_txs[&fail_insufficient_funds].result.to_string(),
-        "(err 1)"
-    );
-
-    // transaction should fail because the amount supplied is invalid (i.e., 0)
-    assert_eq!(
-        &bob_txs[&fail_invalid_amount].result.to_string(),
-        "(err 18)"
-    );
-
-    assert_eq!(
-        &alice_txs[&pox_3_fail_direct_increase_delegation]
-            .result
-            .to_string(),
-        "(err 30)"
-    );
-
-    // transaction should fail because Alice did not delegate enough funds to Bob
-    assert_eq!(
-        &bob_txs[&pox_3_fail_delegate_too_much_locked]
-            .result
-            .to_string(),
-        "(err 22)"
-    );
-
-    // transaction should fail because Alice doesn't have enough funds
-    assert_eq!(
-        &bob_txs[&pox_3_fail_insufficient_funds].result.to_string(),
-        "(err 1)"
-    );
-
-    // transaction should fail because the amount supplied is invalid (i.e., 0)
-    assert_eq!(
-        &bob_txs[&pox_3_fail_invalid_amount].result.to_string(),
-        "(err 18)"
-    );
-
-    for delegation_nonce in [alice_delegation_pox_2_nonce, alice_delegation_pox_3_nonce] {
-        let delegate_stx_tx = &alice_txs.get(&delegation_nonce).unwrap().clone().events[0];
-        let delegate_stx_op_data = HashMap::from([
-            ("pox-addr", Value::none()),
-            ("amount-ustx", Value::UInt(10230000000000)),
-            ("unlock-burn-height", Value::none()),
-            (
-                "delegate-to",
-                Value::Principal(
-                    StacksAddress::from_string("ST1GCB6NH3XR67VT4R5PKVJ2PYXNVQ4AYQATXNP4P")
-                        .unwrap()
-                        .to_account_principal(),
-                ),
-            ),
-        ]);
-        let common_data = PoxPrintFields {
-            op_name: "delegate-stx".to_string(),
-            stacker: Value::Principal(
-                StacksAddress::from_string("ST2Q1B4S2DY2Y96KYNZTVCCZZD1V9AGWCS5MFXM4C")
-                    .unwrap()
-                    .to_account_principal(),
-            ),
-            balance: Value::UInt(10240000000000),
-            locked: Value::UInt(0),
-            burnchain_unlock_height: Value::UInt(0),
-        };
-        check_pox_print_event(delegate_stx_tx, common_data, delegate_stx_op_data);
-    }
-
-    // Check that the call to `delegate-stack-increase` has a well-formed print event.
-    for (unlock_height, del_increase_nonce) in [
-        (expected_pox_2_unlock_ht, bob_delegate_increase_pox_2_nonce),
-        (expected_pox_3_unlock_ht, bob_delegate_increase_pox_3_nonce),
-    ] {
-        let delegate_stack_increase_tx =
-            &bob_txs.get(&del_increase_nonce).unwrap().clone().events[0];
-        let pox_addr_val = generate_pox_clarity_value("60c59ab11f7063ef44c16d3dc856f76bbb915eba");
-        let delegate_op_data = HashMap::from([
-            ("pox-addr", pox_addr_val),
-            ("increase-by", Value::UInt(5110000000000)),
-            ("total-locked", Value::UInt(10230000000000)),
-            (
-                "delegator",
-                Value::Principal(
-                    StacksAddress::from_string("ST1GCB6NH3XR67VT4R5PKVJ2PYXNVQ4AYQATXNP4P")
-                        .unwrap()
-                        .to_account_principal(),
-                ),
-            ),
-        ]);
-        let common_data = PoxPrintFields {
-            op_name: "delegate-stack-increase".to_string(),
-            stacker: Value::Principal(
-                StacksAddress::from_string("ST2Q1B4S2DY2Y96KYNZTVCCZZD1V9AGWCS5MFXM4C")
-                    .unwrap()
-                    .to_account_principal(),
-            ),
-            balance: Value::UInt(5120000000000),
-            locked: Value::UInt(5120000000000),
-            burnchain_unlock_height: Value::UInt(unlock_height.into()),
-        };
-        check_pox_print_event(delegate_stack_increase_tx, common_data, delegate_op_data);
-    }
-}
-
-#[test]
-fn stack_increase() {
-    let EXPECTED_FIRST_V2_CYCLE = 8;
-    // the sim environment produces 25 empty sortitions before
-    //  tenures start being tracked.
-    let EMPTY_SORTITIONS = 25;
-
-    let (epochs, pox_constants) = make_test_epochs_pox();
-
-    let mut burnchain = Burnchain::default_unittest(
-        0,
-        &BurnchainHeaderHash::from_hex(BITCOIN_REGTEST_FIRST_BLOCK_HASH).unwrap(),
-    );
-    burnchain.pox_constants = pox_constants.clone();
-
-    let first_v2_cycle = burnchain
-        .block_height_to_reward_cycle(burnchain.pox_constants.v1_unlock_height as u64)
-        .unwrap()
-        + 1;
-
-    let first_v3_cycle = burnchain
-        .block_height_to_reward_cycle(burnchain.pox_constants.pox_3_activation_height as u64)
-        .unwrap()
-        + 1;
-
-    assert_eq!(first_v2_cycle, EXPECTED_FIRST_V2_CYCLE);
-
-    let observer = TestEventObserver::new();
-
-    let (mut peer, mut keys) = instantiate_pox_peer_with_epoch(
-        &burnchain,
-        function_name!(),
-        Some(epochs.clone()),
-        Some(&observer),
-    );
-
-    peer.config.check_pox_invariants =
-        Some((EXPECTED_FIRST_V2_CYCLE, EXPECTED_FIRST_V2_CYCLE + 10));
-
-    let num_blocks = 35;
-
-    let alice = keys.pop().unwrap();
-    let alice_address = key_to_stacks_addr(&alice);
-    let alice_principal = PrincipalData::from(alice_address.clone());
-    let mut alice_nonce = 0;
-
-    let mut coinbase_nonce = 0;
-
-    let first_lockup_amt = 512 * POX_THRESHOLD_STEPS_USTX;
-    let total_balance = 1024 * POX_THRESHOLD_STEPS_USTX;
-    let increase_amt = total_balance - first_lockup_amt;
-
-    // produce blocks until epoch 2.1
-    while get_tip(peer.sortdb.as_ref()).block_height <= epochs[3].start_height {
-        peer.tenure_with_txs(&[], &mut coinbase_nonce);
-    }
-
-    // in the next tenure, PoX 2 should now exist.
-    let tip = get_tip(peer.sortdb.as_ref());
-
-    // submit an increase: this should fail, because Alice is not yet locked
-    let fail_no_lock_tx = alice_nonce;
-    let alice_increase = make_pox_2_increase(&alice, alice_nonce, increase_amt);
-    alice_nonce += 1;
-
-    let alice_lockup = make_pox_2_lockup(
-        &alice,
-        alice_nonce,
-        first_lockup_amt,
-        PoxAddress::from_legacy(
-            AddressHashMode::SerializeP2PKH,
-            key_to_stacks_addr(&alice).bytes,
-        ),
-        6,
-        tip.block_height,
-    );
-    alice_nonce += 1;
-
-    let mut latest_block =
-        peer.tenure_with_txs(&[alice_increase, alice_lockup], &mut coinbase_nonce);
-
-    let expected_pox_2_unlock_ht =
-        burnchain.reward_cycle_to_block_height(EXPECTED_FIRST_V2_CYCLE + 6) - 1;
-    let alice_bal = get_stx_account_at(&mut peer, &latest_block, &alice_principal);
-    assert_eq!(alice_bal.amount_locked(), first_lockup_amt);
-    assert_eq!(alice_bal.unlock_height(), expected_pox_2_unlock_ht);
-    assert_eq!(alice_bal.get_total_balance(), total_balance,);
-
-    // check that the "raw" reward set will contain entries for alice at the cycle start
-    for cycle_number in EXPECTED_FIRST_V2_CYCLE..first_v3_cycle {
-        let cycle_start = burnchain.reward_cycle_to_block_height(cycle_number);
-        let reward_set_entries = get_reward_set_entries_at(&mut peer, &latest_block, cycle_start);
-        assert_eq!(reward_set_entries.len(), 1);
-        assert_eq!(
-            reward_set_entries[0].reward_address.bytes(),
-            key_to_stacks_addr(&alice).bytes.0.to_vec()
-        );
-        assert_eq!(reward_set_entries[0].amount_stacked, first_lockup_amt,);
-    }
-
-    // we'll produce blocks until the 1st reward cycle gets through the "handled start" code
-    //  this is one block after the reward cycle starts
-    let height_target = burnchain.reward_cycle_to_block_height(EXPECTED_FIRST_V2_CYCLE + 1) + 1;
-
-    while get_tip(peer.sortdb.as_ref()).block_height < height_target {
-        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-    }
-
-    // check that the "raw" reward sets for all cycles contains entries for alice
-    for cycle_number in EXPECTED_FIRST_V2_CYCLE..first_v3_cycle {
-        let cycle_start = burnchain.reward_cycle_to_block_height(cycle_number);
-        let reward_set_entries = get_reward_set_entries_at(&mut peer, &latest_block, cycle_start);
-        assert_eq!(reward_set_entries.len(), 1);
-        assert_eq!(
-            reward_set_entries[0].reward_address.bytes(),
-            key_to_stacks_addr(&alice).bytes.0.to_vec()
-        );
-        assert_eq!(reward_set_entries[0].amount_stacked, first_lockup_amt,);
-    }
-
-    let mut txs_to_submit = vec![];
-    let fail_bad_amount = alice_nonce;
-    txs_to_submit.push(make_pox_2_increase(&alice, alice_nonce, 0));
-    alice_nonce += 1;
-
-    // this stack-increase tx should work
-    let pox_2_success_increase = alice_nonce;
-    txs_to_submit.push(make_pox_2_increase(&alice, alice_nonce, increase_amt));
-    alice_nonce += 1;
-
-    // increase by an amount we don't have!
-    let fail_not_enough_funds = alice_nonce;
-    txs_to_submit.push(make_pox_2_increase(&alice, alice_nonce, 1));
-    alice_nonce += 1;
-
-    latest_block = peer.tenure_with_txs(&txs_to_submit, &mut coinbase_nonce);
-
-    let alice_bal = get_stx_account_at(&mut peer, &latest_block, &alice_principal);
-    assert_eq!(alice_bal.amount_locked(), first_lockup_amt + increase_amt,);
-    assert_eq!(alice_bal.unlock_height(), expected_pox_2_unlock_ht);
-    assert_eq!(alice_bal.get_total_balance(), total_balance,);
-
-    // check that the total reward cycle amounts have incremented correctly
-    for cycle_number in first_v2_cycle..(first_v2_cycle + 2) {
-        assert_eq!(
-            get_reward_cycle_total(&mut peer, &latest_block, cycle_number),
-            first_lockup_amt,
-        );
-        let cycle_start = burnchain.reward_cycle_to_block_height(cycle_number);
-        let reward_set_entries = get_reward_set_entries_at(&mut peer, &latest_block, cycle_start);
-        assert_eq!(reward_set_entries.len(), 1);
-        assert_eq!(
-            reward_set_entries[0].reward_address.bytes(),
-            key_to_stacks_addr(&alice).bytes.0.to_vec()
-        );
-        assert_eq!(reward_set_entries[0].amount_stacked, first_lockup_amt,);
-    }
-
-    assert!(
-        first_v2_cycle + 2 < first_v3_cycle,
-        "Make sure that we can actually test a stack-increase in pox-2 before pox-3 activates"
-    );
-
-    for cycle_number in (first_v2_cycle + 2)..first_v3_cycle {
-        assert_eq!(
-            get_reward_cycle_total(&mut peer, &latest_block, cycle_number),
-            first_lockup_amt + increase_amt,
-        );
-        let cycle_start = burnchain.reward_cycle_to_block_height(cycle_number);
-        let reward_set_entries = get_reward_set_entries_at(&mut peer, &latest_block, cycle_start);
-        assert_eq!(reward_set_entries.len(), 1);
-        assert_eq!(
-            reward_set_entries[0].reward_address.bytes(),
-            key_to_stacks_addr(&alice).bytes.0.to_vec()
-        );
-        assert_eq!(
-            reward_set_entries[0].amount_stacked,
-            first_lockup_amt + increase_amt,
-        );
-    }
-
-    // Roll to Epoch-2.4 and re-do the above tests
-    // okay, now let's progress through epochs 2.2-2.4, and perform the delegation tests
-    //  on pox-3
-
-    // roll the chain forward until just before Epoch-2.2
-    while get_tip(peer.sortdb.as_ref()).block_height < epochs[4].start_height {
-        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-        // at this point, alice's balance should always include this half lockup
-        assert_eq!(
-            get_stx_account_at(&mut peer, &latest_block, &alice_principal).amount_locked(),
-            first_lockup_amt + increase_amt,
-        );
-    }
-
-    // this block is mined in epoch-2.2
-    latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-    assert_eq!(
-        get_stx_account_at(&mut peer, &latest_block, &alice_principal).amount_locked(),
-        first_lockup_amt + increase_amt,
-    );
-
-    // this block should unlock alice's balance
-
-    latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-    assert_eq!(
-        get_stx_account_at(&mut peer, &latest_block, &alice_principal).amount_locked(),
-        0,
-    );
-    assert_eq!(
-        get_stx_account_at(&mut peer, &latest_block, &alice_principal).amount_unlocked(),
-        total_balance,
-    );
-
-    // Roll to Epoch-2.4 and re-do the above stack-increase tests
-    while get_tip(peer.sortdb.as_ref()).block_height <= epochs[6].start_height {
-        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-    }
-
-    // in the next tenure, PoX 3 should now exist.
-    let tip = get_tip(peer.sortdb.as_ref());
-
-    // submit an increase: this should fail, because Alice is not yet locked
-    let pox_3_fail_no_lock_tx = alice_nonce;
-    let alice_increase = make_pox_3_contract_call(
-        &alice,
-        alice_nonce,
-        "stack-increase",
-        vec![Value::UInt(increase_amt)],
-    );
-    alice_nonce += 1;
-
-    let alice_lockup = make_pox_3_lockup(
-        &alice,
-        alice_nonce,
-        first_lockup_amt,
-        PoxAddress::from_legacy(
-            AddressHashMode::SerializeP2PKH,
-            key_to_stacks_addr(&alice).bytes,
-        ),
-        6,
-        tip.block_height,
-    );
-    alice_nonce += 1;
-
-    let mut latest_block =
-        peer.tenure_with_txs(&[alice_increase, alice_lockup], &mut coinbase_nonce);
-
-    let expected_pox_3_unlock_ht = burnchain.reward_cycle_to_block_height(first_v3_cycle + 6) - 1;
-    let alice_bal = get_stx_account_at(&mut peer, &latest_block, &alice_principal);
-    assert_eq!(alice_bal.amount_locked(), first_lockup_amt);
-    assert_eq!(alice_bal.unlock_height(), expected_pox_3_unlock_ht);
-    assert_eq!(alice_bal.get_total_balance(), total_balance,);
-
-    // check that the "raw" reward set will contain entries for alice at the cycle start
-    for cycle_number in first_v3_cycle..(first_v3_cycle + 6) {
-        let cycle_start = burnchain.reward_cycle_to_block_height(cycle_number);
-        let reward_set_entries = get_reward_set_entries_at(&mut peer, &latest_block, cycle_start);
-        assert_eq!(reward_set_entries.len(), 1);
-        assert_eq!(
-            reward_set_entries[0].reward_address.bytes(),
-            key_to_stacks_addr(&alice).bytes.0.to_vec()
-        );
-        assert_eq!(reward_set_entries[0].amount_stacked, first_lockup_amt,);
-    }
-
-    // we'll produce blocks until the 3rd reward cycle gets through the "handled start" code
-    //  this is one block after the reward cycle starts
-    let height_target = burnchain.reward_cycle_to_block_height(first_v3_cycle + 3) + 1;
-
-    while get_tip(peer.sortdb.as_ref()).block_height < height_target {
-        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-    }
-
-    // check that the "raw" reward set will contain entries for alice at the cycle start
-    for cycle_number in first_v3_cycle..(first_v3_cycle + 6) {
-        let cycle_start = burnchain.reward_cycle_to_block_height(cycle_number);
-        let reward_set_entries = get_reward_set_entries_at(&mut peer, &latest_block, cycle_start);
-        assert_eq!(reward_set_entries.len(), 1);
-        assert_eq!(
-            reward_set_entries[0].reward_address.bytes(),
-            key_to_stacks_addr(&alice).bytes.0.to_vec()
-        );
-        assert_eq!(reward_set_entries[0].amount_stacked, first_lockup_amt,);
-    }
-
-    let mut txs_to_submit = vec![];
-    let pox_3_fail_bad_amount = alice_nonce;
-    let bad_amount_tx =
-        make_pox_3_contract_call(&alice, alice_nonce, "stack-increase", vec![Value::UInt(0)]);
-    txs_to_submit.push(bad_amount_tx);
-    alice_nonce += 1;
-
-    // this stack-increase tx should work
-    let pox_3_success_increase = alice_nonce;
-    let good_amount_tx = make_pox_3_contract_call(
-        &alice,
-        alice_nonce,
-        "stack-increase",
-        vec![Value::UInt(increase_amt)],
-    );
-    txs_to_submit.push(good_amount_tx);
-    alice_nonce += 1;
-
-    // increase by an amount we don't have!
-    let pox_3_fail_not_enough_funds = alice_nonce;
-    let not_enough_tx =
-        make_pox_3_contract_call(&alice, alice_nonce, "stack-increase", vec![Value::UInt(1)]);
-    txs_to_submit.push(not_enough_tx);
-    alice_nonce += 1;
-
-    latest_block = peer.tenure_with_txs(&txs_to_submit, &mut coinbase_nonce);
-
-    let alice_bal = get_stx_account_at(&mut peer, &latest_block, &alice_principal);
-    assert_eq!(alice_bal.amount_locked(), first_lockup_amt + increase_amt,);
-    assert_eq!(alice_bal.unlock_height(), expected_pox_3_unlock_ht);
-    assert_eq!(alice_bal.get_total_balance(), total_balance,);
-
-    // check that the total reward cycle amounts have incremented correctly
-    for cycle_number in first_v3_cycle..(first_v3_cycle + 4) {
-        assert_eq!(
-            get_reward_cycle_total(&mut peer, &latest_block, cycle_number),
-            first_lockup_amt,
-        );
-        let cycle_start = burnchain.reward_cycle_to_block_height(cycle_number);
-        let reward_set_entries = get_reward_set_entries_at(&mut peer, &latest_block, cycle_start);
-        assert_eq!(reward_set_entries.len(), 1);
-        assert_eq!(
-            reward_set_entries[0].reward_address.bytes(),
-            key_to_stacks_addr(&alice).bytes.0.to_vec()
-        );
-        assert_eq!(reward_set_entries[0].amount_stacked, first_lockup_amt,);
-    }
-
-    for cycle_number in (first_v3_cycle + 4)..(first_v3_cycle + 6) {
-        assert_eq!(
-            get_reward_cycle_total(&mut peer, &latest_block, cycle_number),
-            first_lockup_amt + increase_amt,
-        );
-        let cycle_start = burnchain.reward_cycle_to_block_height(cycle_number);
-        let reward_set_entries = get_reward_set_entries_at(&mut peer, &latest_block, cycle_start);
-        assert_eq!(reward_set_entries.len(), 1);
-        assert_eq!(
-            reward_set_entries[0].reward_address.bytes(),
-            key_to_stacks_addr(&alice).bytes.0.to_vec()
-        );
-        assert_eq!(
-            reward_set_entries[0].amount_stacked,
-            first_lockup_amt + increase_amt,
-        );
-    }
-
-    // now let's check some tx receipts
-    let blocks = observer.get_blocks();
-
-    let mut alice_txs = HashMap::new();
-
-    for b in blocks.into_iter() {
-        for r in b.receipts.into_iter() {
-            if let TransactionOrigin::Stacks(ref t) = r.transaction {
-                let addr = t.auth.origin().address_testnet();
-                if addr == alice_address {
-                    alice_txs.insert(t.auth.get_origin_nonce(), r);
-                }
-            }
-        }
-    }
-
-    assert_eq!(alice_txs.len() as u64, alice_nonce);
-
-    // transaction should fail because lock isn't applied
-    assert_eq!(&alice_txs[&fail_no_lock_tx].result.to_string(), "(err 27)");
-
-    // transaction should fail because Alice doesn't have enough funds
-    assert_eq!(
-        &alice_txs[&fail_not_enough_funds].result.to_string(),
-        "(err 1)"
-    );
-
-    // transaction should fail because the amount supplied is invalid (i.e., 0)
-    assert_eq!(&alice_txs[&fail_bad_amount].result.to_string(), "(err 18)");
-
-    // transaction should fail because lock isn't applied
-    assert_eq!(
-        &alice_txs[&pox_3_fail_no_lock_tx].result.to_string(),
-        "(err 27)"
-    );
-
-    // transaction should fail because Alice doesn't have enough funds
-    assert_eq!(
-        &alice_txs[&pox_3_fail_not_enough_funds].result.to_string(),
-        "(err 1)"
-    );
-
-    // transaction should fail because the amount supplied is invalid (i.e., 0)
-    assert_eq!(
-        &alice_txs[&pox_3_fail_bad_amount].result.to_string(),
-        "(err 18)"
-    );
-
-    // Check that the call to `stack-increase` has a well-formed print event.
-    for (increase_nonce, unlock_height) in [
-        (pox_2_success_increase, expected_pox_2_unlock_ht),
-        (pox_3_success_increase, expected_pox_3_unlock_ht),
-    ] {
-        let stack_increase_tx = &alice_txs.get(&increase_nonce).unwrap().clone().events[0];
-        let pox_addr_val = generate_pox_clarity_value("ae1593226f85e49a7eaff5b633ff687695438cc9");
-        let stack_op_data = HashMap::from([
-            ("increase-by", Value::UInt(5120000000000)),
-            ("total-locked", Value::UInt(10240000000000)),
-            ("pox-addr", pox_addr_val),
-        ]);
-        let common_data = PoxPrintFields {
-            op_name: "stack-increase".to_string(),
-            stacker: Value::Principal(
-                StacksAddress::from_string("ST2Q1B4S2DY2Y96KYNZTVCCZZD1V9AGWCS5MFXM4C")
-                    .unwrap()
-                    .to_account_principal(),
-            ),
-            balance: Value::UInt(5120000000000),
-            locked: Value::UInt(5120000000000),
-            burnchain_unlock_height: Value::UInt(unlock_height.into()),
-        };
-        check_pox_print_event(stack_increase_tx, common_data, stack_op_data);
-    }
-}
-
-#[test]
-fn pox_extend_transition() {
-    let EXPECTED_FIRST_V2_CYCLE = 8;
-    // the sim environment produces 25 empty sortitions before
-    //  tenures start being tracked.
-    let EMPTY_SORTITIONS = 25;
-
-    let (epochs, pox_constants) = make_test_epochs_pox();
-
-    let mut burnchain = Burnchain::default_unittest(
-        0,
-        &BurnchainHeaderHash::from_hex(BITCOIN_REGTEST_FIRST_BLOCK_HASH).unwrap(),
-    );
-    burnchain.pox_constants = pox_constants.clone();
-
-    let first_v2_cycle = burnchain
-        .block_height_to_reward_cycle(burnchain.pox_constants.v1_unlock_height as u64)
-        .unwrap()
-        + 1;
-
-    let first_v3_cycle = burnchain
-        .block_height_to_reward_cycle(burnchain.pox_constants.pox_3_activation_height as u64)
-        .unwrap()
-        + 1;
-
-    let first_v4_cycle = burnchain
-        .block_height_to_reward_cycle(burnchain.pox_constants.pox_4_activation_height as u64)
-        .unwrap()
-        + 1;
-
-    assert_eq!(first_v2_cycle, EXPECTED_FIRST_V2_CYCLE);
-
-    let observer = TestEventObserver::new();
-
-    let (mut peer, mut keys) = instantiate_pox_peer_with_epoch(
-        &burnchain,
-        function_name!(),
-        Some(epochs.clone()),
-        Some(&observer),
-    );
-
-    peer.config.check_pox_invariants =
-        Some((EXPECTED_FIRST_V2_CYCLE, EXPECTED_FIRST_V2_CYCLE + 10));
-
-    let alice = keys.pop().unwrap();
-    let bob = keys.pop().unwrap();
-    let alice_address = key_to_stacks_addr(&alice);
-    let alice_principal = PrincipalData::from(alice_address.clone());
-    let bob_address = key_to_stacks_addr(&bob);
-    let bob_principal = PrincipalData::from(bob_address.clone());
-
-    let EXPECTED_ALICE_FIRST_REWARD_CYCLE = 6;
-    let mut coinbase_nonce = 0;
-
-    let INITIAL_BALANCE = 1024 * POX_THRESHOLD_STEPS_USTX;
-    let ALICE_LOCKUP = 1024 * POX_THRESHOLD_STEPS_USTX;
-    let BOB_LOCKUP = 512 * POX_THRESHOLD_STEPS_USTX;
-
-    // these checks should pass between Alice's first reward cycle,
-    //  and the start of V2 reward cycles
-    let alice_rewards_to_v2_start_checks = |tip_index_block, peer: &mut TestPeer| {
-        let tip_burn_block_height = get_par_burn_block_height(peer.chainstate(), &tip_index_block);
-        let cur_reward_cycle = burnchain
-            .block_height_to_reward_cycle(tip_burn_block_height)
-            .unwrap() as u128;
-        let (min_ustx, reward_addrs, total_stacked) = with_sortdb(peer, |ref mut c, ref sortdb| {
-            (
-                c.get_stacking_minimum(sortdb, &tip_index_block).unwrap(),
-                get_reward_addresses_with_par_tip(c, &burnchain, sortdb, &tip_index_block).unwrap(),
-                c.test_get_total_ustx_stacked(sortdb, &tip_index_block, cur_reward_cycle)
-                    .unwrap(),
-            )
-        });
-
-        assert!(
-            cur_reward_cycle >= EXPECTED_ALICE_FIRST_REWARD_CYCLE
-                && cur_reward_cycle < first_v2_cycle as u128
-        );
-        //  Alice is the only Stacker, so check that.
-        let (amount_ustx, pox_addr, lock_period, first_reward_cycle) =
-            get_stacker_info(peer, &key_to_stacks_addr(&alice).into()).unwrap();
-        eprintln!(
-            "\nAlice: {} uSTX stacked for {} cycle(s); addr is {:?}; first reward cycle is {}\n",
-            amount_ustx, lock_period, &pox_addr, first_reward_cycle
-        );
-
-        // one reward address, and it's Alice's
-        // either way, there's a single reward address
-        assert_eq!(reward_addrs.len(), 1);
-        assert_eq!(
-            (reward_addrs[0].0).version(),
-            AddressHashMode::SerializeP2PKH as u8
-        );
-        assert_eq!(
-            (reward_addrs[0].0).hash160(),
-            key_to_stacks_addr(&alice).bytes
-        );
-        assert_eq!(reward_addrs[0].1, ALICE_LOCKUP);
-    };
-
-    // these checks should pass after the start of V2 reward cycles
-    let v2_rewards_checks = |tip_index_block, peer: &mut TestPeer| {
-        let tip_burn_block_height = get_par_burn_block_height(peer.chainstate(), &tip_index_block);
-        let cur_reward_cycle = burnchain
-            .block_height_to_reward_cycle(tip_burn_block_height)
-            .unwrap() as u128;
-        let (min_ustx, reward_addrs, total_stacked) = with_sortdb(peer, |ref mut c, ref sortdb| {
-            (
-                c.get_stacking_minimum(sortdb, &tip_index_block).unwrap(),
-                get_reward_addresses_with_par_tip(c, &burnchain, sortdb, &tip_index_block).unwrap(),
-                c.test_get_total_ustx_stacked(sortdb, &tip_index_block, cur_reward_cycle)
-                    .unwrap(),
-            )
-        });
-
-        eprintln!(
-            "reward_cycle = {}, reward_addrs = {}, total_stacked = {}",
-            cur_reward_cycle,
-            reward_addrs.len(),
-            total_stacked
-        );
-
-        assert!(cur_reward_cycle >= first_v2_cycle as u128);
-        // v2 reward cycles have begun, so reward addrs should be read from PoX2 which is Bob + Alice
-        assert_eq!(reward_addrs.len(), 2);
-        assert_eq!(
-            (reward_addrs[0].0).version(),
-            AddressHashMode::SerializeP2PKH as u8
-        );
-        assert_eq!(
-            (reward_addrs[0].0).hash160(),
-            key_to_stacks_addr(&bob).bytes
-        );
-        assert_eq!(reward_addrs[0].1, BOB_LOCKUP);
-
-        assert_eq!(
-            (reward_addrs[1].0).version(),
-            AddressHashMode::SerializeP2PKH as u8
-        );
-        assert_eq!(
-            (reward_addrs[1].0).hash160(),
-            key_to_stacks_addr(&alice).bytes
-        );
-        assert_eq!(reward_addrs[1].1, ALICE_LOCKUP);
-    };
-
-    // first tenure is empty
-    let mut latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-
-    let alice_account = get_account(&mut peer, &key_to_stacks_addr(&alice).into());
-    assert_eq!(alice_account.stx_balance.amount_unlocked(), INITIAL_BALANCE);
-    assert_eq!(alice_account.stx_balance.amount_locked(), 0);
-    assert_eq!(alice_account.stx_balance.unlock_height(), 0);
-
-    // next tenure include Alice's lockup
-    let tip = get_tip(peer.sortdb.as_ref());
-    let alice_lockup = make_pox_lockup(
-        &alice,
-        0,
-        ALICE_LOCKUP,
-        AddressHashMode::SerializeP2PKH,
-        key_to_stacks_addr(&alice).bytes,
-        4,
-        tip.block_height,
-    );
-
-    let tip_index_block = peer.tenure_with_txs(&[alice_lockup], &mut coinbase_nonce);
-
-    // check the stacking minimum
-    let total_liquid_ustx = get_liquid_ustx(&mut peer);
-    let min_ustx = with_sortdb(&mut peer, |chainstate, sortdb| {
-        chainstate.get_stacking_minimum(sortdb, &tip_index_block)
-    })
-    .unwrap();
-    assert_eq!(
-        min_ustx,
-        total_liquid_ustx / POX_TESTNET_STACKING_THRESHOLD_25
-    );
-
-    // no reward addresses
-    let reward_addrs = with_sortdb(&mut peer, |chainstate, sortdb| {
-        get_reward_addresses_with_par_tip(chainstate, &burnchain, sortdb, &tip_index_block)
-    })
-    .unwrap();
-    assert_eq!(reward_addrs.len(), 0);
-
-    // check the first reward cycle when Alice's tokens get stacked
-    let tip_burn_block_height = get_par_burn_block_height(peer.chainstate(), &tip_index_block);
-    let alice_first_reward_cycle = 1 + burnchain
-        .block_height_to_reward_cycle(tip_burn_block_height)
-        .unwrap();
-
-    assert_eq!(
-        alice_first_reward_cycle as u128,
-        EXPECTED_ALICE_FIRST_REWARD_CYCLE
-    );
-    let height_target = burnchain.reward_cycle_to_block_height(alice_first_reward_cycle) + 1;
-
-    // alice locked, so balance should be 0
-    let alice_balance = get_balance(&mut peer, &key_to_stacks_addr(&alice).into());
-    assert_eq!(alice_balance, 0);
-
-    while get_tip(peer.sortdb.as_ref()).block_height < height_target {
-        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-    }
-
-    // produce blocks until epoch 2.1
-    while get_tip(peer.sortdb.as_ref()).block_height < epochs[3].start_height {
-        peer.tenure_with_txs(&[], &mut coinbase_nonce);
-        alice_rewards_to_v2_start_checks(latest_block, &mut peer);
-    }
-
-    // in the next tenure, PoX 2 should now exist.
-    // Lets have Bob lock up for v2
-    // this will lock for cycles 8, 9, 10
-    //  the first v2 cycle will be 8
-    let tip = get_tip(peer.sortdb.as_ref());
-
-    let bob_lockup = make_pox_2_lockup(
-        &bob,
-        0,
-        BOB_LOCKUP,
-        PoxAddress::from_legacy(
-            AddressHashMode::SerializeP2PKH,
-            key_to_stacks_addr(&bob).bytes,
-        ),
-        3,
-        tip.block_height,
-    );
-
-    // Alice _will_ auto-unlock: she can stack-extend in PoX v2
-    let alice_lockup = make_pox_2_extend(
-        &alice,
-        1,
-        PoxAddress::from_legacy(
-            AddressHashMode::SerializeP2PKH,
-            key_to_stacks_addr(&alice).bytes,
-        ),
-        6,
-    );
-
-    latest_block = peer.tenure_with_txs(&[bob_lockup, alice_lockup], &mut coinbase_nonce);
-    alice_rewards_to_v2_start_checks(latest_block, &mut peer);
-
-    // Extend bob's lockup via `stack-extend` for 1 more cycle
-    let bob_extend = make_pox_2_extend(
-        &bob,
-        1,
-        PoxAddress::from_legacy(
-            AddressHashMode::SerializeP2PKH,
-            key_to_stacks_addr(&bob).bytes,
-        ),
-        1,
-    );
-
-    latest_block = peer.tenure_with_txs(&[bob_extend], &mut coinbase_nonce);
-
-    alice_rewards_to_v2_start_checks(latest_block, &mut peer);
-
-    // produce blocks until the v2 reward cycles start
-    let height_target = burnchain.reward_cycle_to_block_height(first_v2_cycle) - 1;
-    while get_tip(peer.sortdb.as_ref()).block_height < height_target {
-        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-        // alice is still locked, balance should be 0
-        let alice_balance = get_balance(&mut peer, &key_to_stacks_addr(&alice).into());
-        assert_eq!(alice_balance, 0);
-
-        alice_rewards_to_v2_start_checks(latest_block, &mut peer);
-    }
-
-    latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-    v2_rewards_checks(latest_block, &mut peer);
-
-    // roll the chain forward until just before Epoch-2.2
-    while get_tip(peer.sortdb.as_ref()).block_height < epochs[4].start_height {
-        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-        // at this point, alice's balance should be locked, and so should bob's
-        let alice_balance = get_balance(&mut peer, &key_to_stacks_addr(&alice).into());
-        assert_eq!(alice_balance, 0);
-        let bob_balance = get_balance(&mut peer, &key_to_stacks_addr(&bob).into());
-        assert_eq!(bob_balance, 512 * POX_THRESHOLD_STEPS_USTX);
-    }
-
-    // this block is mined in epoch-2.2
-    latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-    let alice_balance = get_balance(&mut peer, &key_to_stacks_addr(&alice).into());
-    assert_eq!(alice_balance, 0);
-    let bob_balance = get_balance(&mut peer, &key_to_stacks_addr(&bob).into());
-    assert_eq!(bob_balance, 512 * POX_THRESHOLD_STEPS_USTX);
-
-    // this block should unlock alice and bob's balance
-
-    latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-    let alice_account = get_stx_account_at(&mut peer, &latest_block, &alice_principal);
-    let bob_account = get_stx_account_at(&mut peer, &latest_block, &bob_principal);
-    assert_eq!(alice_account.amount_locked(), 0);
-    assert_eq!(alice_account.amount_unlocked(), INITIAL_BALANCE);
-    assert_eq!(bob_account.amount_locked(), 0);
-    assert_eq!(bob_account.amount_unlocked(), INITIAL_BALANCE);
-
-    // Roll to pox4 activation and re-do the above stack-extend tests
-    while get_tip(peer.sortdb.as_ref()).block_height
-        < u64::from(burnchain.pox_constants.pox_4_activation_height)
-    {
-        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-    }
-
-    let tip = get_tip(peer.sortdb.as_ref());
-    let alice_lockup = make_pox_4_lockup(
-        &alice,
-        2,
-        ALICE_LOCKUP,
-        PoxAddress::from_legacy(
-            AddressHashMode::SerializeP2PKH,
-            key_to_stacks_addr(&alice).bytes,
-        ),
-        4,
-        tip.block_height,
-    );
-    let alice_pox_4_lock_nonce = 2;
-    let alice_first_pox_4_unlock_height =
-        burnchain.reward_cycle_to_block_height(first_v4_cycle + 4) - 1;
-    let alice_pox_4_start_burn_height = tip.block_height;
-
-    latest_block = peer.tenure_with_txs(&[alice_lockup], &mut coinbase_nonce);
-
-    info!(
-        "Block height: {}",
-        get_tip(peer.sortdb.as_ref()).block_height
-    );
-
-    // check that the "raw" reward set will contain entries for alice at the cycle start
-    for cycle_number in first_v4_cycle..(first_v4_cycle + 4) {
-        let cycle_start = burnchain.reward_cycle_to_block_height(cycle_number);
-        let reward_set_entries = get_reward_set_entries_at(&mut peer, &latest_block, cycle_start);
-        info!("----- {cycle_number} -----");
-        assert_eq!(reward_set_entries.len(), 1);
-        assert_eq!(
-            reward_set_entries[0].reward_address.bytes(),
-            key_to_stacks_addr(&alice).bytes.0.to_vec()
-        );
-        assert_eq!(reward_set_entries[0].amount_stacked, ALICE_LOCKUP,);
-    }
-
-    // check the first reward cycle when Alice's tokens get stacked
-    let tip_burn_block_height = get_par_burn_block_height(peer.chainstate(), &latest_block);
-    let alice_first_v4_reward_cycle = 1 + burnchain
-        .block_height_to_reward_cycle(tip_burn_block_height)
-        .unwrap();
-
-    let height_target = burnchain.reward_cycle_to_block_height(alice_first_v4_reward_cycle) + 1;
-
-    // alice locked, so balance should be 0
-    let alice_balance = get_balance(&mut peer, &alice_principal);
-    assert_eq!(alice_balance, 0);
-
-    // advance to the first v3 reward cycle
-    while get_tip(peer.sortdb.as_ref()).block_height < height_target {
-        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-    }
-
-    let tip = get_tip(peer.sortdb.as_ref());
-    let bob_lockup = make_pox_4_lockup(
-        &bob,
-        2,
-        BOB_LOCKUP,
-        PoxAddress::from_legacy(
-            AddressHashMode::SerializeP2PKH,
-            key_to_stacks_addr(&bob).bytes,
-        ),
-        3,
-        tip.block_height,
-    );
-
-    // Alice can stack-extend in PoX v2
-    let alice_lockup = make_pox_4_extend(
-        &alice,
-        3,
-        PoxAddress::from_legacy(
-            AddressHashMode::SerializeP2PKH,
-            key_to_stacks_addr(&alice).bytes,
-        ),
-        6,
-    );
-
-    let alice_pox_4_extend_nonce = 3;
-    let alice_extend_pox_4_unlock_height =
-        burnchain.reward_cycle_to_block_height(first_v4_cycle + 10) - 1;
-
-    latest_block = peer.tenure_with_txs(&[bob_lockup, alice_lockup], &mut coinbase_nonce);
-
-    // check that the "raw" reward set will contain entries for alice at the cycle start
-    for cycle_number in first_v4_cycle..(first_v4_cycle + 1) {
-        let cycle_start = burnchain.reward_cycle_to_block_height(cycle_number);
-        let reward_set_entries = get_reward_set_entries_at(&mut peer, &latest_block, cycle_start);
-        assert_eq!(reward_set_entries.len(), 1);
-        assert_eq!(
-            reward_set_entries[0].reward_address.bytes(),
-            key_to_stacks_addr(&alice).bytes.0.to_vec()
-        );
-        assert_eq!(reward_set_entries[0].amount_stacked, ALICE_LOCKUP);
-    }
-
-    for cycle_number in (first_v4_cycle + 1)..(first_v4_cycle + 4) {
-        let cycle_start = burnchain.reward_cycle_to_block_height(cycle_number);
-        let reward_set_entries = get_reward_set_entries_at(&mut peer, &latest_block, cycle_start);
-        assert_eq!(reward_set_entries.len(), 2);
-        assert_eq!(
-            reward_set_entries[1].reward_address.bytes(),
-            key_to_stacks_addr(&alice).bytes.0.to_vec()
-        );
-        assert_eq!(reward_set_entries[1].amount_stacked, ALICE_LOCKUP);
-        assert_eq!(
-            reward_set_entries[0].reward_address.bytes(),
-            key_to_stacks_addr(&bob).bytes.0.to_vec()
-        );
-        assert_eq!(reward_set_entries[0].amount_stacked, BOB_LOCKUP);
-    }
-
-    for cycle_number in (first_v4_cycle + 4)..(first_v4_cycle + 10) {
-        let cycle_start = burnchain.reward_cycle_to_block_height(cycle_number);
-        let reward_set_entries = get_reward_set_entries_at(&mut peer, &latest_block, cycle_start);
-        assert_eq!(reward_set_entries.len(), 1);
-        assert_eq!(
-            reward_set_entries[0].reward_address.bytes(),
-            key_to_stacks_addr(&alice).bytes.0.to_vec()
-        );
-        assert_eq!(reward_set_entries[0].amount_stacked, ALICE_LOCKUP);
-    }
-
-    // now let's check some tx receipts
-
-    let alice_address = key_to_stacks_addr(&alice);
-    let bob_address = key_to_stacks_addr(&bob);
-    let blocks = observer.get_blocks();
-
-    let mut alice_txs = HashMap::new();
-    let mut bob_txs = HashMap::new();
-
-    for b in blocks.into_iter() {
-        for r in b.receipts.into_iter() {
-            if let TransactionOrigin::Stacks(ref t) = r.transaction {
-                let addr = t.auth.origin().address_testnet();
-                eprintln!("TX addr: {}", addr);
-                if addr == alice_address {
-                    alice_txs.insert(t.auth.get_origin_nonce(), r);
-                } else if addr == bob_address {
-                    bob_txs.insert(t.auth.get_origin_nonce(), r);
-                }
-            }
-        }
-    }
-
-    assert_eq!(alice_txs.len(), 4);
-    assert_eq!(bob_txs.len(), 3);
-
-    for tx in alice_txs.iter() {
-        assert!(
-            if let Value::Response(ref r) = tx.1.result {
-                r.committed
-            } else {
-                false
-            },
-            "Alice txs should all have committed okay"
-        );
-    }
-
-    for tx in bob_txs.iter() {
-        assert!(
-            if let Value::Response(ref r) = tx.1.result {
-                r.committed
-            } else {
-                false
-            },
-            "Bob txs should all have committed okay"
-        );
-    }
-
-    // Check that the call to `stack-stx` has a well-formed print event.
-    let stack_tx = &alice_txs
-        .get(&alice_pox_4_lock_nonce)
-        .unwrap()
-        .clone()
-        .events[0];
-    let pox_addr_val = generate_pox_clarity_value("ae1593226f85e49a7eaff5b633ff687695438cc9");
-    let stack_op_data = HashMap::from([
-        ("lock-amount", Value::UInt(ALICE_LOCKUP)),
-        (
-            "unlock-burn-height",
-            Value::UInt(alice_first_pox_4_unlock_height.into()),
-        ),
-        (
-            "start-burn-height",
-            Value::UInt(alice_pox_4_start_burn_height.into()),
-        ),
-        ("pox-addr", pox_addr_val.clone()),
-        ("lock-period", Value::UInt(4)),
-    ]);
-    let common_data = PoxPrintFields {
-        op_name: "stack-stx".to_string(),
-        stacker: Value::Principal(alice_principal.clone()),
-        balance: Value::UInt(10240000000000),
-        locked: Value::UInt(0),
-        burnchain_unlock_height: Value::UInt(0),
-    };
-    check_pox_print_event(stack_tx, common_data, stack_op_data);
-
-    // Check that the call to `stack-extend` has a well-formed print event.
-    let stack_extend_tx = &alice_txs
-        .get(&alice_pox_4_extend_nonce)
-        .unwrap()
-        .clone()
-        .events[0];
-    let stack_ext_op_data = HashMap::from([
-        ("extend-count", Value::UInt(6)),
-        ("pox-addr", pox_addr_val),
-        (
-            "unlock-burn-height",
-            Value::UInt(alice_extend_pox_4_unlock_height.into()),
-        ),
-    ]);
-    let common_data = PoxPrintFields {
-        op_name: "stack-extend".to_string(),
-        stacker: Value::Principal(alice_principal.clone()),
-        balance: Value::UInt(0),
-        locked: Value::UInt(ALICE_LOCKUP),
-        burnchain_unlock_height: Value::UInt(alice_first_pox_4_unlock_height.into()),
-    };
-    check_pox_print_event(stack_extend_tx, common_data, stack_ext_op_data);
-}
-
-#[test]
-fn delegate_extend_pox_3() {
-    // the sim environment produces 25 empty sortitions before
-    //  tenures start being tracked.
-    let EMPTY_SORTITIONS = 25;
-
-    let (epochs, pox_constants) = make_test_epochs_pox();
-
-    let mut burnchain = Burnchain::default_unittest(
-        0,
-        &BurnchainHeaderHash::from_hex(BITCOIN_REGTEST_FIRST_BLOCK_HASH).unwrap(),
-    );
-    burnchain.pox_constants = pox_constants.clone();
-
-    let first_v3_cycle = burnchain
-        .block_height_to_reward_cycle(burnchain.pox_constants.pox_3_activation_height as u64)
-        .unwrap()
-        + 1;
-
-    let observer = TestEventObserver::new();
-
-    let (mut peer, mut keys) = instantiate_pox_peer_with_epoch(
-        &burnchain,
-        function_name!(),
-        Some(epochs.clone()),
-        Some(&observer),
-    );
-
-    peer.config.check_pox_invariants = Some((first_v3_cycle, first_v3_cycle + 10));
-
-    let alice = keys.pop().unwrap();
-    let bob = keys.pop().unwrap();
-    let charlie = keys.pop().unwrap();
-
-    let alice_address = key_to_stacks_addr(&alice);
-    let bob_address = key_to_stacks_addr(&bob);
-    let charlie_address = key_to_stacks_addr(&charlie);
-
-    let mut coinbase_nonce = 0;
-
-    let INITIAL_BALANCE = 1024 * POX_THRESHOLD_STEPS_USTX;
-    let LOCKUP_AMT = 1024 * POX_THRESHOLD_STEPS_USTX;
-
-    // our "tenure counter" is now at 0
-    let tip = get_tip(peer.sortdb.as_ref());
-    assert_eq!(tip.block_height, 0 + EMPTY_SORTITIONS as u64);
-
-    // first tenure is empty
-    let mut latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-
-    // Roll to Epoch-2.4 and perform the delegate-stack-extend tests
-    while get_tip(peer.sortdb.as_ref()).block_height <= epochs[6].start_height {
-        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-    }
-
-    // in the next tenure, PoX 3 should now exist.
-    //  charlie will lock bob and alice through the delegation interface
-    let tip = get_tip(peer.sortdb.as_ref());
-
-    let mut alice_nonce = 0;
-    let mut bob_nonce = 0;
-    let mut charlie_nonce = 0;
-
-    let bob_delegate_tx = make_pox_3_contract_call(
-        &bob,
-        bob_nonce,
-        "delegate-stx",
-        vec![
-            Value::UInt(2048 * POX_THRESHOLD_STEPS_USTX),
-            PrincipalData::from(charlie_address.clone()).into(),
-            Value::none(),
-            Value::none(),
-        ],
-    );
-    bob_nonce += 1;
-
-    let alice_delegate_tx = make_pox_3_contract_call(
-        &alice,
-        alice_nonce,
-        "delegate-stx",
-        vec![
-            Value::UInt(2048 * POX_THRESHOLD_STEPS_USTX),
-            PrincipalData::from(charlie_address.clone()).into(),
-            Value::none(),
-            Value::none(),
-        ],
-    );
-    alice_nonce += 1;
-
-    let delegate_stack_tx = make_pox_3_contract_call(
-        &charlie,
-        charlie_nonce,
-        "delegate-stack-stx",
-        vec![
-            PrincipalData::from(bob_address.clone()).into(),
-            Value::UInt(LOCKUP_AMT),
-            make_pox_addr(
-                AddressHashMode::SerializeP2PKH,
-                charlie_address.bytes.clone(),
-            ),
-            Value::UInt(tip.block_height as u128),
-            Value::UInt(3),
-        ],
-    );
-    let delegate_stack_stx_nonce = charlie_nonce;
-    let delegate_stack_stx_unlock_ht =
-        burnchain.reward_cycle_to_block_height(first_v3_cycle + 3) - 1;
-    let delegate_stack_stx_lock_ht = tip.block_height;
-    charlie_nonce += 1;
-
-    let delegate_alice_stack_tx = make_pox_3_contract_call(
-        &charlie,
-        charlie_nonce,
-        "delegate-stack-stx",
-        vec![
-            PrincipalData::from(alice_address.clone()).into(),
-            Value::UInt(LOCKUP_AMT),
-            make_pox_addr(
-                AddressHashMode::SerializeP2PKH,
-                charlie_address.bytes.clone(),
-            ),
-            Value::UInt(tip.block_height as u128),
-            Value::UInt(6),
-        ],
-    );
-    charlie_nonce += 1;
-
-    // Charlie agg commits the first 3 cycles, but wait until delegate-extended bob to
-    //   agg commit the 4th cycle
-    // aggregate commit to each cycle delegate-stack-stx locked for (cycles 6, 7, 8, 9)
-    let agg_commit_txs = [0, 1, 2].map(|ix| {
-        let tx = make_pox_3_contract_call(
-            &charlie,
-            charlie_nonce,
-            "stack-aggregation-commit",
-            vec![
-                make_pox_addr(
-                    AddressHashMode::SerializeP2PKH,
-                    charlie_address.bytes.clone(),
-                ),
-                Value::UInt(first_v3_cycle as u128 + ix),
-            ],
-        );
-        charlie_nonce += 1;
-        tx
-    });
-    let mut txs = vec![
-        bob_delegate_tx,
-        alice_delegate_tx,
-        delegate_stack_tx,
-        delegate_alice_stack_tx,
-    ];
-
-    txs.extend(agg_commit_txs);
-
-    latest_block = peer.tenure_with_txs(txs.as_slice(), &mut coinbase_nonce);
-
-    for cycle_number in first_v3_cycle..(first_v3_cycle + 3) {
-        let cycle_start = burnchain.reward_cycle_to_block_height(cycle_number);
-        let reward_set_entries = get_reward_set_entries_at(&mut peer, &latest_block, cycle_start);
-        assert_eq!(reward_set_entries.len(), 1);
-        assert_eq!(
-            reward_set_entries[0].reward_address.bytes(),
-            key_to_stacks_addr(&charlie).bytes.0.to_vec()
-        );
-        assert_eq!(reward_set_entries[0].amount_stacked, 2 * LOCKUP_AMT);
-    }
-
-    for cycle_number in (first_v3_cycle + 3)..(first_v3_cycle + 6) {
-        let cycle_start = burnchain.reward_cycle_to_block_height(cycle_number);
-        let reward_set_entries = get_reward_set_entries_at(&mut peer, &latest_block, cycle_start);
-        assert_eq!(reward_set_entries.len(), 0);
-    }
-
-    let alice_principal = alice_address.clone().into();
-    let bob_principal = bob_address.clone().into();
-    let charlie_principal: PrincipalData = charlie_address.clone().into();
-
-    let StackingStateCheckData {
-        first_cycle: alice_first_cycle,
-        lock_period: alice_lock_period,
-        ..
-    } = check_stacking_state_invariants(
-        &mut peer,
-        &latest_block,
-        &alice_principal,
-        false,
-        POX_3_NAME,
-    );
-    let StackingStateCheckData {
-        first_cycle: bob_first_cycle,
-        lock_period: bob_lock_period,
-        ..
-    } = check_stacking_state_invariants(
-        &mut peer,
-        &latest_block,
-        &bob_principal,
-        false,
-        POX_3_NAME,
-    );
-
-    assert_eq!(
-        alice_first_cycle as u64, first_v3_cycle,
-        "Alice's first cycle in PoX-3 stacking state is the next cycle, which is 12"
-    );
-    assert_eq!(alice_lock_period, 6);
-    assert_eq!(
-        bob_first_cycle as u64, first_v3_cycle,
-        "Bob's first cycle in PoX-3 stacking state is the next cycle, which is 12"
-    );
-    assert_eq!(bob_lock_period, 3);
-
-    // Extend bob's lockup via `delegate-stack-extend` for 1 more cycle
-    let delegate_extend_tx = make_pox_3_contract_call(
-        &charlie,
-        charlie_nonce,
-        "delegate-stack-extend",
-        vec![
-            PrincipalData::from(bob_address.clone()).into(),
-            make_pox_addr(
-                AddressHashMode::SerializeP2PKH,
-                charlie_address.bytes.clone(),
-            ),
-            Value::UInt(1),
-        ],
-    );
-    let delegate_stack_extend_nonce = charlie_nonce;
-    let delegate_stack_extend_unlock_ht =
-        burnchain.reward_cycle_to_block_height(first_v3_cycle + 4) - 1;
-    charlie_nonce += 1;
-
-    let agg_commit_tx = make_pox_3_contract_call(
-        &charlie,
-        charlie_nonce,
-        "stack-aggregation-commit",
-        vec![
-            make_pox_addr(
-                AddressHashMode::SerializeP2PKH,
-                charlie_address.bytes.clone(),
-            ),
-            Value::UInt(first_v3_cycle as u128 + 3),
-        ],
-    );
-    let stack_agg_nonce = charlie_nonce;
-    let stack_agg_cycle = first_v3_cycle + 3;
-    let delegate_stack_extend_unlock_ht =
-        burnchain.reward_cycle_to_block_height(first_v3_cycle + 4) - 1;
-    charlie_nonce += 1;
-
-    latest_block = peer.tenure_with_txs(&[delegate_extend_tx, agg_commit_tx], &mut coinbase_nonce);
-    let StackingStateCheckData {
-        first_cycle: alice_first_cycle,
-        lock_period: alice_lock_period,
-        ..
-    } = check_stacking_state_invariants(
-        &mut peer,
-        &latest_block,
-        &alice_principal,
-        false,
-        POX_3_NAME,
-    );
-    let StackingStateCheckData {
-        first_cycle: bob_first_cycle,
-        lock_period: bob_lock_period,
-        ..
-    } = check_stacking_state_invariants(
-        &mut peer,
-        &latest_block,
-        &bob_principal,
-        false,
-        POX_3_NAME,
-    );
-
-    assert_eq!(
-        alice_first_cycle as u64, first_v3_cycle,
-        "Alice's first cycle in PoX-2 stacking state is the next cycle, which is 8"
-    );
-    assert_eq!(alice_lock_period, 6);
-    assert_eq!(
-        bob_first_cycle as u64, first_v3_cycle,
-        "Bob's first cycle in PoX-2 stacking state is the next cycle, which is 8"
-    );
-    assert_eq!(bob_lock_period, 4);
-
-    for cycle_number in first_v3_cycle..(first_v3_cycle + 4) {
-        let cycle_start = burnchain.reward_cycle_to_block_height(cycle_number);
-        let reward_set_entries = get_reward_set_entries_at(&mut peer, &latest_block, cycle_start);
-        assert_eq!(reward_set_entries.len(), 1);
-        assert_eq!(
-            reward_set_entries[0].reward_address.bytes(),
-            key_to_stacks_addr(&charlie).bytes.0.to_vec()
-        );
-        assert_eq!(reward_set_entries[0].amount_stacked, 2 * LOCKUP_AMT);
-    }
-
-    let height_target = burnchain.reward_cycle_to_block_height(first_v3_cycle) + 1;
-    while get_tip(peer.sortdb.as_ref()).block_height < height_target {
-        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-        let alice_balance = get_balance(&mut peer, &key_to_stacks_addr(&alice).into());
-        assert_eq!(alice_balance, 0);
-    }
-
-    let tip = get_tip(peer.sortdb.as_ref());
-
-    // Extend bob's lockup via `delegate-stack-extend` for 1 more cycle
-    //  so that we can check the first-reward-cycle is correctly updated
-    let delegate_extend_tx = make_pox_3_contract_call(
-        &charlie,
-        charlie_nonce,
-        "delegate-stack-extend",
-        vec![
-            PrincipalData::from(bob_address.clone()).into(),
-            make_pox_addr(
-                AddressHashMode::SerializeP2PKH,
-                charlie_address.bytes.clone(),
-            ),
-            Value::UInt(3),
-        ],
-    );
-    charlie_nonce += 1;
-
-    latest_block = peer.tenure_with_txs(&[delegate_extend_tx], &mut coinbase_nonce);
-    let StackingStateCheckData {
-        first_cycle: alice_first_cycle,
-        lock_period: alice_lock_period,
-        ..
-    } = check_stacking_state_invariants(
-        &mut peer,
-        &latest_block,
-        &alice_principal,
-        false,
-        POX_3_NAME,
-    );
-    let StackingStateCheckData {
-        first_cycle: bob_first_cycle,
-        lock_period: bob_lock_period,
-        ..
-    } = check_stacking_state_invariants(
-        &mut peer,
-        &latest_block,
-        &bob_principal,
-        false,
-        POX_3_NAME,
-    );
-
-    assert_eq!(
-        alice_first_cycle as u64, first_v3_cycle,
-        "Alice's first cycle in PoX-2 stacking state is the next cycle, which is 8"
-    );
-    assert_eq!(alice_lock_period, 6);
-    assert_eq!(
-        bob_first_cycle as u64, first_v3_cycle,
-        "Bob's first cycle in PoX-2 stacking state is the next cycle, which is 8"
-    );
-    assert_eq!(bob_lock_period, 7);
-
-    // now let's check some tx receipts
-    let blocks = observer.get_blocks();
-
-    let mut alice_txs = HashMap::new();
-    let mut bob_txs = HashMap::new();
-    let mut charlie_txs = HashMap::new();
 
     for b in blocks.into_iter() {
         for r in b.receipts.into_iter() {
@@ -2932,16 +599,13 @@ fn delegate_extend_pox_3() {
                     alice_txs.insert(t.auth.get_origin_nonce(), r);
                 } else if addr == bob_address {
                     bob_txs.insert(t.auth.get_origin_nonce(), r);
-                } else if addr == charlie_address {
-                    charlie_txs.insert(t.auth.get_origin_nonce(), r);
                 }
             }
         }
     }
 
-    assert_eq!(alice_txs.len(), alice_nonce as usize);
-    assert_eq!(bob_txs.len(), bob_nonce as usize);
-    assert_eq!(charlie_txs.len(), charlie_nonce as usize);
+    assert_eq!(alice_txs.len(), 4);
+    assert_eq!(bob_txs.len(), 3);
 
     for tx in alice_txs.iter() {
         assert!(
@@ -2953,6 +617,7 @@ fn delegate_extend_pox_3() {
             "Alice txs should all have committed okay"
         );
     }
+
     for tx in bob_txs.iter() {
         assert!(
             if let Value::Response(ref r) = tx.1.result {
@@ -2963,368 +628,58 @@ fn delegate_extend_pox_3() {
             "Bob txs should all have committed okay"
         );
     }
-    for tx in charlie_txs.iter() {
-        assert!(
-            if let Value::Response(ref r) = tx.1.result {
-                r.committed
-            } else {
-                false
-            },
-            "Charlie txs should all have committed okay"
-        );
-    }
 
-    // Check that the call to `delegate-stack-stx` has a well-formed print event.
-    let delegate_stack_tx = &charlie_txs
-        .get(&delegate_stack_stx_nonce)
+    // Check that the call to `stack-stx` has a well-formed print event.
+    let stack_tx = &alice_txs
+        .get(&alice_pox_4_lock_nonce)
         .unwrap()
         .clone()
         .events[0];
-    let pox_addr_val = generate_pox_clarity_value("12d93ae7b61e5b7d905c85828d4320e7c221f433");
-    let delegate_op_data = HashMap::from([
-        ("lock-amount", Value::UInt(LOCKUP_AMT)),
+    let pox_addr_val = generate_pox_clarity_value("ae1593226f85e49a7eaff5b633ff687695438cc9");
+    let stack_op_data = HashMap::from([
+        ("lock-amount", Value::UInt(ALICE_LOCKUP)),
         (
             "unlock-burn-height",
-            Value::UInt(delegate_stack_stx_unlock_ht.into()),
+            Value::UInt(alice_first_pox_4_unlock_height.into()),
         ),
         (
             "start-burn-height",
-            Value::UInt(delegate_stack_stx_lock_ht.into()),
+            Value::UInt(alice_pox_4_start_burn_height.into()),
         ),
         ("pox-addr", pox_addr_val.clone()),
-        ("lock-period", Value::UInt(3)),
-        ("delegator", Value::Principal(charlie_principal.clone())),
-    ]);
-    let common_data = PoxPrintFields {
-        op_name: "delegate-stack-stx".to_string(),
-        stacker: Value::Principal(bob_principal.clone()),
-        balance: Value::UInt(LOCKUP_AMT),
-        locked: Value::UInt(0),
-        burnchain_unlock_height: Value::UInt(0),
-    };
-    check_pox_print_event(delegate_stack_tx, common_data, delegate_op_data);
-
-    // Check that the call to `delegate-stack-extend` has a well-formed print event.
-    let delegate_stack_extend_tx = &charlie_txs
-        .get(&delegate_stack_extend_nonce)
-        .unwrap()
-        .clone()
-        .events[0];
-    let delegate_ext_op_data = HashMap::from([
-        ("pox-addr", pox_addr_val.clone()),
-        (
-            "unlock-burn-height",
-            Value::UInt(delegate_stack_extend_unlock_ht.into()),
-        ),
-        ("extend-count", Value::UInt(1)),
-        ("delegator", Value::Principal(charlie_principal.clone())),
-    ]);
-    let common_data = PoxPrintFields {
-        op_name: "delegate-stack-extend".to_string(),
-        stacker: Value::Principal(bob_principal.clone()),
-        balance: Value::UInt(0),
-        locked: Value::UInt(LOCKUP_AMT),
-        burnchain_unlock_height: Value::UInt(delegate_stack_stx_unlock_ht.into()),
-    };
-    check_pox_print_event(delegate_stack_extend_tx, common_data, delegate_ext_op_data);
-
-    // Check that the call to `stack-aggregation-commit` has a well-formed print event.
-    let stack_agg_commit_tx = &charlie_txs.get(&stack_agg_nonce).unwrap().clone().events[0];
-    let stack_agg_commit_op_data = HashMap::from([
-        ("pox-addr", pox_addr_val),
-        ("reward-cycle", Value::UInt(stack_agg_cycle.into())),
-        ("amount-ustx", Value::UInt(2 * LOCKUP_AMT)),
+        ("lock-period", Value::UInt(4)),
     ]);
     let common_data = PoxPrintFields {
-        op_name: "stack-aggregation-commit".to_string(),
-        stacker: Value::Principal(charlie_principal.clone()),
-        balance: Value::UInt(LOCKUP_AMT),
+        op_name: "stack-stx".to_string(),
+        stacker: Value::Principal(alice_principal.clone()),
+        balance: Value::UInt(10240000000000),
         locked: Value::UInt(0),
         burnchain_unlock_height: Value::UInt(0),
     };
-    check_pox_print_event(stack_agg_commit_tx, common_data, stack_agg_commit_op_data);
-}
-
-#[test]
-fn pox_3_getters() {
-    // the sim environment produces 25 empty sortitions before
-    //  tenures start being tracked.
-    let EMPTY_SORTITIONS = 25;
-
-    let (epochs, pox_constants) = make_test_epochs_pox();
-
-    let mut burnchain = Burnchain::default_unittest(
-        0,
-        &BurnchainHeaderHash::from_hex(BITCOIN_REGTEST_FIRST_BLOCK_HASH).unwrap(),
-    );
-    burnchain.pox_constants = pox_constants.clone();
-
-    let first_v3_cycle = burnchain
-        .block_height_to_reward_cycle(burnchain.pox_constants.pox_3_activation_height as u64)
-        .unwrap()
-        + 1;
-
-    let observer = TestEventObserver::new();
-
-    let (mut peer, mut keys) = instantiate_pox_peer_with_epoch(
-        &burnchain,
-        function_name!(),
-        Some(epochs.clone()),
-        Some(&observer),
-    );
-
-    peer.config.check_pox_invariants = Some((first_v3_cycle, first_v3_cycle + 10));
-
-    let alice = keys.pop().unwrap();
-    let bob = keys.pop().unwrap();
-    let charlie = keys.pop().unwrap();
-    let danielle = keys.pop().unwrap();
-
-    let alice_address = key_to_stacks_addr(&alice);
-    let bob_address = key_to_stacks_addr(&bob);
-    let charlie_address = key_to_stacks_addr(&charlie);
-    let mut coinbase_nonce = 0;
-
-    let mut latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-    // Roll to Epoch-2.4 and perform the delegate-stack-extend tests
-    while get_tip(peer.sortdb.as_ref()).block_height <= epochs[6].start_height {
-        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-    }
-
-    let tip = get_tip(peer.sortdb.as_ref());
-    let LOCKUP_AMT = 1024 * POX_THRESHOLD_STEPS_USTX;
-
-    // alice locks in v2
-    let alice_lockup = make_pox_3_lockup(
-        &alice,
-        0,
-        LOCKUP_AMT,
-        PoxAddress::from_legacy(
-            AddressHashMode::SerializeP2PKH,
-            key_to_stacks_addr(&alice).bytes,
-        ),
-        4,
-        tip.block_height,
-    );
-
-    // bob deleates to charlie
-    let bob_delegate_tx = make_pox_3_contract_call(
-        &bob,
-        0,
-        "delegate-stx",
-        vec![
-            Value::UInt(LOCKUP_AMT),
-            PrincipalData::from(charlie_address.clone()).into(),
-            Value::none(),
-            Value::none(),
-        ],
-    );
-
-    // charlie calls delegate-stack-stx for bob
-    let charlie_delegate_stack_tx = make_pox_3_contract_call(
-        &charlie,
-        0,
-        "delegate-stack-stx",
-        vec![
-            PrincipalData::from(bob_address.clone()).into(),
-            Value::UInt(LOCKUP_AMT),
-            make_pox_addr(
-                AddressHashMode::SerializeP2PKH,
-                charlie_address.bytes.clone(),
-            ),
-            Value::UInt(tip.block_height as u128),
-            Value::UInt(4),
-        ],
-    );
-
-    let agg_commit_tx_1 = make_pox_3_contract_call(
-        &charlie,
-        1,
-        "stack-aggregation-commit",
-        vec![
-            make_pox_addr(
-                AddressHashMode::SerializeP2PKH,
-                charlie_address.bytes.clone(),
-            ),
-            Value::UInt(first_v3_cycle as u128),
-        ],
-    );
-
-    let agg_commit_tx_2 = make_pox_3_contract_call(
-        &charlie,
-        2,
-        "stack-aggregation-commit",
-        vec![
-            make_pox_addr(
-                AddressHashMode::SerializeP2PKH,
-                charlie_address.bytes.clone(),
-            ),
-            Value::UInt(first_v3_cycle as u128 + 1),
-        ],
-    );
-
-    let agg_commit_tx_3 = make_pox_3_contract_call(
-        &charlie,
-        3,
-        "stack-aggregation-commit",
-        vec![
-            make_pox_addr(
-                AddressHashMode::SerializeP2PKH,
-                charlie_address.bytes.clone(),
-            ),
-            Value::UInt(first_v3_cycle as u128 + 2),
-        ],
-    );
-
-    let reject_pox = make_pox_3_contract_call(&danielle, 0, "reject-pox", vec![]);
-
-    peer.tenure_with_txs(
-        &[
-            alice_lockup,
-            bob_delegate_tx,
-            charlie_delegate_stack_tx,
-            agg_commit_tx_1,
-            agg_commit_tx_2,
-            agg_commit_tx_3,
-            reject_pox,
-        ],
-        &mut coinbase_nonce,
-    );
-
-    let result = eval_at_tip(&mut peer, "pox-3", &format!("
-    {{
-        ;; should be none
-        get-delegation-info-alice: (get-delegation-info '{}),
-        ;; should be (some $charlie_address)
-        get-delegation-info-bob: (get-delegation-info '{}),
-        ;; should be none
-        get-allowance-contract-callers: (get-allowance-contract-callers '{} '{}),
-        ;; should be 1
-        get-num-reward-set-pox-addresses-current: (get-num-reward-set-pox-addresses u{}),
-        ;; should be 0
-        get-num-reward-set-pox-addresses-future: (get-num-reward-set-pox-addresses u1000),
-        ;; should be 0
-        get-partial-stacked-by-cycle-bob-0: (get-partial-stacked-by-cycle {{ version: 0x00, hashbytes: 0x{} }} u{} '{}),
-        get-partial-stacked-by-cycle-bob-1: (get-partial-stacked-by-cycle {{ version: 0x00, hashbytes: 0x{} }} u{} '{}),
-        get-partial-stacked-by-cycle-bob-2: (get-partial-stacked-by-cycle {{ version: 0x00, hashbytes: 0x{} }} u{} '{}),
-        ;; should be LOCKUP_AMT
-        get-partial-stacked-by-cycle-bob-3: (get-partial-stacked-by-cycle {{ version: 0x00, hashbytes: 0x{} }} u{} '{}),
-        ;; should be LOCKUP_AMT
-        get-total-pox-rejection-now: (get-total-pox-rejection u{}),
-        ;; should be 0
-        get-total-pox-rejection-next: (get-total-pox-rejection u{}),
-        ;; should be 0
-        get-total-pox-rejection-future: (get-total-pox-rejection u{})
-    }}", &alice_address,
-        &bob_address,
-        &bob_address, &format!("{}.hello-world", &charlie_address), first_v3_cycle + 1,
-        &charlie_address.bytes, first_v3_cycle + 0, &charlie_address,
-        &charlie_address.bytes, first_v3_cycle + 1, &charlie_address,
-        &charlie_address.bytes, first_v3_cycle + 2, &charlie_address,
-        &charlie_address.bytes, first_v3_cycle + 3, &charlie_address,
-        first_v3_cycle,
-        first_v3_cycle + 1,
-        first_v3_cycle + 2,
-    ));
-
-    eprintln!("{}", &result);
-    let data = result.expect_tuple().data_map;
-
-    let alice_delegation_info = data
-        .get("get-delegation-info-alice")
-        .cloned()
-        .unwrap()
-        .expect_optional();
-    assert!(alice_delegation_info.is_none());
-
-    let bob_delegation_info = data
-        .get("get-delegation-info-bob")
-        .cloned()
-        .unwrap()
-        .expect_optional()
-        .unwrap()
-        .expect_tuple()
-        .data_map;
-    let bob_delegation_addr = bob_delegation_info
-        .get("delegated-to")
-        .cloned()
-        .unwrap()
-        .expect_principal();
-    let bob_delegation_amt = bob_delegation_info
-        .get("amount-ustx")
-        .cloned()
-        .unwrap()
-        .expect_u128();
-    let bob_pox_addr_opt = bob_delegation_info
-        .get("pox-addr")
-        .cloned()
-        .unwrap()
-        .expect_optional();
-    assert_eq!(bob_delegation_addr, charlie_address.to_account_principal());
-    assert_eq!(bob_delegation_amt, LOCKUP_AMT as u128);
-    assert!(bob_pox_addr_opt.is_none());
-
-    let allowance = data
-        .get("get-allowance-contract-callers")
-        .cloned()
-        .unwrap()
-        .expect_optional();
-    assert!(allowance.is_none());
-
-    let current_num_reward_addrs = data
-        .get("get-num-reward-set-pox-addresses-current")
-        .cloned()
-        .unwrap()
-        .expect_u128();
-    assert_eq!(current_num_reward_addrs, 2);
-
-    let future_num_reward_addrs = data
-        .get("get-num-reward-set-pox-addresses-future")
-        .cloned()
-        .unwrap()
-        .expect_u128();
-    assert_eq!(future_num_reward_addrs, 0);
-
-    for i in 0..3 {
-        let key =
-            ClarityName::try_from(format!("get-partial-stacked-by-cycle-bob-{}", &i)).unwrap();
-        let partial_stacked = data.get(&key).cloned().unwrap().expect_optional();
-        assert!(partial_stacked.is_none());
-    }
-    let partial_stacked = data
-        .get("get-partial-stacked-by-cycle-bob-3")
-        .cloned()
-        .unwrap()
-        .expect_optional()
-        .unwrap()
-        .expect_tuple()
-        .data_map
-        .get("stacked-amount")
-        .cloned()
-        .unwrap()
-        .expect_u128();
-    assert_eq!(partial_stacked, LOCKUP_AMT as u128);
-
-    let rejected = data
-        .get("get-total-pox-rejection-now")
-        .cloned()
-        .unwrap()
-        .expect_u128();
-    assert_eq!(rejected, LOCKUP_AMT as u128);
-
-    let rejected = data
-        .get("get-total-pox-rejection-next")
-        .cloned()
-        .unwrap()
-        .expect_u128();
-    assert_eq!(rejected, 0);
+    check_pox_print_event(stack_tx, common_data, stack_op_data);
 
-    let rejected = data
-        .get("get-total-pox-rejection-future")
-        .cloned()
+    // Check that the call to `stack-extend` has a well-formed print event.
+    let stack_extend_tx = &alice_txs
+        .get(&alice_pox_4_extend_nonce)
         .unwrap()
-        .expect_u128();
-    assert_eq!(rejected, 0);
+        .clone()
+        .events[0];
+    let stack_ext_op_data = HashMap::from([
+        ("extend-count", Value::UInt(6)),
+        ("pox-addr", pox_addr_val),
+        (
+            "unlock-burn-height",
+            Value::UInt(alice_extend_pox_4_unlock_height.into()),
+        ),
+    ]);
+    let common_data = PoxPrintFields {
+        op_name: "stack-extend".to_string(),
+        stacker: Value::Principal(alice_principal.clone()),
+        balance: Value::UInt(0),
+        locked: Value::UInt(ALICE_LOCKUP),
+        burnchain_unlock_height: Value::UInt(alice_first_pox_4_unlock_height.into()),
+    };
+    check_pox_print_event(stack_extend_tx, common_data, stack_ext_op_data);
 }
 
 fn get_burn_pox_addr_info(peer: &mut TestPeer) -> (Vec<PoxAddress>, u128) {
@@ -3358,251 +713,31 @@ fn get_burn_pox_addr_info(peer: &mut TestPeer) -> (Vec<PoxAddress>, u128) {
     .expect_optional()
     .expect("FATAL: expected list")
     .expect_tuple();
-
-    let addrs = addrs_and_payout
-        .get("addrs")
-        .unwrap()
-        .to_owned()
-        .expect_list()
-        .into_iter()
-        .map(|tuple| PoxAddress::try_from_pox_tuple(false, &tuple).unwrap())
-        .collect();
-
-    let payout = addrs_and_payout
-        .get("payout")
-        .unwrap()
-        .to_owned()
-        .expect_u128();
-    (addrs, payout)
-}
-
-/// Test that we can lock STX for a couple cycles after pox4 starts,
-/// and that it unlocks after the desired number of cycles
-#[test]
-fn pox_lock_unlock() {
-    // Config for this test
-    // We are going to try locking for 2 reward cycles (10 blocks)
-    let lock_period = 2;
-    let (epochs, pox_constants) = make_test_epochs_pox();
-
-    let mut burnchain = Burnchain::default_unittest(
-        0,
-        &BurnchainHeaderHash::from_hex(BITCOIN_REGTEST_FIRST_BLOCK_HASH).unwrap(),
-    );
-    burnchain.pox_constants = pox_constants.clone();
-
-    let (mut peer, keys) =
-        instantiate_pox_peer_with_epoch(&burnchain, function_name!(), Some(epochs.clone()), None);
-
-    assert_eq!(burnchain.pox_constants.reward_slots(), 6);
-    let mut coinbase_nonce = 0;
-    let mut latest_block;
-
-    // Advance into pox4
-    let target_height = burnchain.pox_constants.pox_4_activation_height;
-    // produce blocks until the first reward phase that everyone should be in
-    while get_tip(peer.sortdb.as_ref()).block_height < u64::from(target_height) {
-        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-        // if we reach epoch 2.1, perform the check
-        if get_tip(peer.sortdb.as_ref()).block_height > epochs[3].start_height {
-            assert_latest_was_burn(&mut peer);
-        }
-    }
-
-    info!(
-        "Block height: {}",
-        get_tip(peer.sortdb.as_ref()).block_height
-    );
-
-    let mut txs = vec![];
-    let tip_height = get_tip(peer.sortdb.as_ref()).block_height;
-    let stackers: Vec<_> = keys
-        .iter()
-        .zip([
-            AddressHashMode::SerializeP2PKH,
-            AddressHashMode::SerializeP2SH,
-            AddressHashMode::SerializeP2WPKH,
-            AddressHashMode::SerializeP2WSH,
-        ])
-        .map(|(key, hash_mode)| {
-            let pox_addr = PoxAddress::from_legacy(hash_mode, key_to_stacks_addr(key).bytes);
-            txs.push(make_pox_4_lockup(
-                key,
-                0,
-                1024 * POX_THRESHOLD_STEPS_USTX,
-                pox_addr.clone(),
-                lock_period,
-                tip_height,
-            ));
-            pox_addr
-        })
-        .collect();
-
-    info!("Submitting stacking txs");
-    latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
-
-    // Advance to start of rewards cycle stackers are participating in
-    let target_height = burnchain.pox_constants.pox_4_activation_height + 5;
-    while get_tip(peer.sortdb.as_ref()).block_height < u64::from(target_height) {
-        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-    }
-
-    info!(
-        "Block height: {}",
-        get_tip(peer.sortdb.as_ref()).block_height
-    );
-
-    // now we should be in the reward phase, produce the reward blocks
-    let reward_blocks =
-        burnchain.pox_constants.reward_cycle_length - burnchain.pox_constants.prepare_length;
-    let mut rewarded = HashSet::new();
-
-    // Check that STX are locked for 2 reward cycles
-    for _ in 0..lock_period {
-        let tip = get_tip(peer.sortdb.as_ref());
-        let cycle = burnchain
-            .block_height_to_reward_cycle(tip.block_height)
-            .unwrap();
-        info!("Checking no stackers for cycle {cycle}");
-        for i in 0..reward_blocks {
-            latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-            // only the first 2 reward blocks contain pox outputs, because there are 6 slots and only 4 are occuppied
-            if i < 2 {
-                assert_latest_was_pox(&mut peer)
-                    .into_iter()
-                    .filter(|addr| !addr.is_burn())
-                    .for_each(|addr| {
-                        rewarded.insert(addr);
-                    });
-            } else {
-                assert_latest_was_burn(&mut peer);
-            }
-        }
-
-        assert_eq!(rewarded.len(), 4);
-        for stacker in stackers.iter() {
-            assert!(
-                rewarded.contains(stacker),
-                "Reward cycle should include {stacker}"
-            );
-        }
-
-        // now we should be back in a prepare phase
-        info!("Checking we are in prepare phase");
-        for _ in 0..burnchain.pox_constants.prepare_length {
-            latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-            assert_latest_was_burn(&mut peer);
-        }
-    }
-
-    info!("Checking STX unlocked after {lock_period} cycles");
-    for _ in 0..burnchain.pox_constants.reward_cycle_length {
-        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-        assert_latest_was_burn(&mut peer);
-    }
-}
-
-/// Test that pox3 methods fail once pox4 is activated
-#[test]
-fn pox_3_fails() {
-    // Config for this test
-    // We are going to try locking for 2 reward cycles (10 blocks)
-    let lock_period = 2;
-    let (epochs, pox_constants) = make_test_epochs_pox();
-
-    let mut burnchain = Burnchain::default_unittest(
-        0,
-        &BurnchainHeaderHash::from_hex(BITCOIN_REGTEST_FIRST_BLOCK_HASH).unwrap(),
-    );
-    burnchain.pox_constants = pox_constants.clone();
-
-    let (mut peer, keys) =
-        instantiate_pox_peer_with_epoch(&burnchain, function_name!(), Some(epochs.clone()), None);
-
-    assert_eq!(burnchain.pox_constants.reward_slots(), 6);
-    let mut coinbase_nonce = 0;
-    let mut latest_block;
-
-    // Advance into pox4
-    let target_height = burnchain.pox_constants.pox_4_activation_height;
-    // produce blocks until the first reward phase that everyone should be in
-    while get_tip(peer.sortdb.as_ref()).block_height < u64::from(target_height) {
-        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-        // if we reach epoch 2.1, perform the check
-        if get_tip(peer.sortdb.as_ref()).block_height > epochs[3].start_height {
-            assert_latest_was_burn(&mut peer);
-        }
-    }
-
-    info!(
-        "Block height: {}",
-        get_tip(peer.sortdb.as_ref()).block_height
-    );
-
-    let mut txs = vec![];
-    let tip_height = get_tip(peer.sortdb.as_ref()).block_height;
-    let stackers: Vec<_> = keys
-        .iter()
-        .zip([
-            AddressHashMode::SerializeP2PKH,
-            AddressHashMode::SerializeP2SH,
-            AddressHashMode::SerializeP2WPKH,
-            AddressHashMode::SerializeP2WSH,
-        ])
-        .map(|(key, hash_mode)| {
-            let pox_addr = PoxAddress::from_legacy(hash_mode, key_to_stacks_addr(key).bytes);
-            txs.push(make_pox_3_lockup(
-                key,
-                0,
-                1024 * POX_THRESHOLD_STEPS_USTX,
-                pox_addr.clone(),
-                lock_period,
-                tip_height,
-            ));
-            pox_addr
-        })
-        .collect();
-
-    info!("Submitting stacking txs with pox3");
-    latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
-
-    // Advance to start of rewards cycle stackers are participating in
-    let target_height = burnchain.pox_constants.pox_4_activation_height + 5;
-    while get_tip(peer.sortdb.as_ref()).block_height < u64::from(target_height) {
-        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-    }
-
-    info!(
-        "Block height: {}",
-        get_tip(peer.sortdb.as_ref()).block_height
-    );
-
-    // now we should be in the reward phase, produce the reward blocks
-    let reward_blocks =
-        burnchain.pox_constants.reward_cycle_length - burnchain.pox_constants.prepare_length;
-
-    // Check next 3 reward cycles
-    for _ in 0..=lock_period {
-        let tip = get_tip(peer.sortdb.as_ref());
-        let cycle = burnchain
-            .block_height_to_reward_cycle(tip.block_height)
-            .unwrap();
-        info!("Checking no stackers for cycle {cycle}");
-        for _ in 0..burnchain.pox_constants.reward_cycle_length {
-            latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-            // Should all be burn because no stackers
-            assert_latest_was_burn(&mut peer);
-        }
-    }
+
+    let addrs = addrs_and_payout
+        .get("addrs")
+        .unwrap()
+        .to_owned()
+        .expect_list()
+        .into_iter()
+        .map(|tuple| PoxAddress::try_from_pox_tuple(false, &tuple).unwrap())
+        .collect();
+
+    let payout = addrs_and_payout
+        .get("payout")
+        .unwrap()
+        .to_owned()
+        .expect_u128();
+    (addrs, payout)
 }
 
 /// Test that we can lock STX for a couple cycles after pox4 starts,
 /// and that it unlocks after the desired number of cycles
 #[test]
-fn pox_3_unlocks() {
+fn pox_lock_unlock() {
     // Config for this test
-    // We are going to try locking for 4 reward cycles (20 blocks)
-    let lock_period = 4;
+    // We are going to try locking for 2 reward cycles (10 blocks)
+    let lock_period = 2;
     let (epochs, pox_constants) = make_test_epochs_pox();
 
     let mut burnchain = Burnchain::default_unittest(
@@ -3618,8 +753,8 @@ fn pox_3_unlocks() {
     let mut coinbase_nonce = 0;
     let mut latest_block;
 
-    // Advance to a few blocks before pox 3 unlock
-    let target_height = burnchain.pox_constants.v3_unlock_height - 14;
+    // Advance into pox4
+    let target_height = burnchain.pox_constants.pox_4_activation_height;
     // produce blocks until the first reward phase that everyone should be in
     while get_tip(peer.sortdb.as_ref()).block_height < u64::from(target_height) {
         latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
@@ -3629,7 +764,10 @@ fn pox_3_unlocks() {
         }
     }
 
-    info!( "Block height: {}", get_tip(peer.sortdb.as_ref()).block_height);
+    info!(
+        "Block height: {}",
+        get_tip(peer.sortdb.as_ref()).block_height
+    );
 
     let mut txs = vec![];
     let tip_height = get_tip(peer.sortdb.as_ref()).block_height;
@@ -3643,7 +781,7 @@ fn pox_3_unlocks() {
         ])
         .map(|(key, hash_mode)| {
             let pox_addr = PoxAddress::from_legacy(hash_mode, key_to_stacks_addr(key).bytes);
-            txs.push(make_pox_3_lockup(
+            txs.push(make_pox_4_lockup(
                 key,
                 0,
                 1024 * POX_THRESHOLD_STEPS_USTX,
@@ -3658,23 +796,29 @@ fn pox_3_unlocks() {
     info!("Submitting stacking txs");
     latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
 
-    // Advance a couple more blocks
-    for _ in 0..3 {
+    // Advance to start of rewards cycle stackers are participating in
+    let target_height = burnchain.pox_constants.pox_4_activation_height + 5;
+    while get_tip(peer.sortdb.as_ref()).block_height < u64::from(target_height) {
         latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
     }
 
+    info!(
+        "Block height: {}",
+        get_tip(peer.sortdb.as_ref()).block_height
+    );
+
     // now we should be in the reward phase, produce the reward blocks
     let reward_blocks =
         burnchain.pox_constants.reward_cycle_length - burnchain.pox_constants.prepare_length;
     let mut rewarded = HashSet::new();
 
     // Check that STX are locked for 2 reward cycles
-    for _ in 0..2 {
+    for _ in 0..lock_period {
         let tip = get_tip(peer.sortdb.as_ref());
         let cycle = burnchain
             .block_height_to_reward_cycle(tip.block_height)
             .unwrap();
-        info!("Checking STX locked for cycle {cycle}");
+        info!("Checking no stackers for cycle {cycle}");
         for i in 0..reward_blocks {
             latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
             // only the first 2 reward blocks contain pox outputs, because there are 6 slots and only 4 are occuppied
@@ -3706,628 +850,114 @@ fn pox_3_unlocks() {
         }
     }
 
-    // Advance to v3 unlock
-    let target_height = burnchain.pox_constants.v3_unlock_height;
-    while get_tip(peer.sortdb.as_ref()).block_height < u64::from(target_height) {
-        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-    }
-
-    info!(
-        "Block height: {}",
-        get_tip(peer.sortdb.as_ref()).block_height
-    );
-
-    // Check that STX are not locked for 3 reward cycles after pox4 starts
-    for _ in 0..3 {
-        let tip = get_tip(peer.sortdb.as_ref());
-        let cycle = burnchain
-            .block_height_to_reward_cycle(tip.block_height)
-            .unwrap();
-        info!("Checking no stackers for cycle {cycle}");
-        for _ in 0..burnchain.pox_constants.reward_cycle_length {
-            latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-            assert_latest_was_burn(&mut peer);
-        }
-    }
-}
-
-#[test]
-fn stack_with_segwit() {
-    // the sim environment produces 25 empty sortitions before
-    //  tenures start being tracked.
-    let EMPTY_SORTITIONS = 25;
-
-    let (epochs, pox_constants) = make_test_epochs_pox();
-
-    let mut burnchain = Burnchain::default_unittest(
-        0,
-        &BurnchainHeaderHash::from_hex(BITCOIN_REGTEST_FIRST_BLOCK_HASH).unwrap(),
-    );
-    burnchain.pox_constants = pox_constants.clone();
-
-    let first_v2_cycle = burnchain
-        .block_height_to_reward_cycle(burnchain.pox_constants.v1_unlock_height as u64)
-        .unwrap()
-        + 1;
-
-    let first_v3_cycle = burnchain
-        .block_height_to_reward_cycle(burnchain.pox_constants.pox_3_activation_height as u64)
-        .unwrap()
-        + 1;
-
-    let (mut peer, keys) =
-        instantiate_pox_peer_with_epoch(&burnchain, function_name!(), Some(epochs.clone()), None);
-
-    peer.config.check_pox_invariants = Some((first_v3_cycle, first_v3_cycle + 10));
-
-    assert_eq!(burnchain.pox_constants.reward_slots(), 6);
-    let mut coinbase_nonce = 0;
-
-    // produce blocks until epoch 2.2
-    while get_tip(peer.sortdb.as_ref()).block_height <= epochs[6].start_height {
-        peer.tenure_with_txs(&[], &mut coinbase_nonce);
-        // if we reach epoch 2.1, perform the check
-        if get_tip(peer.sortdb.as_ref()).block_height > epochs[3].start_height {
-            assert_latest_was_burn(&mut peer);
-        }
-    }
-
-    let mut txs = vec![];
-    let tip_height = get_tip(peer.sortdb.as_ref()).block_height;
-    let stackers: Vec<_> = keys
-        .iter()
-        .zip([
-            PoxAddress::Addr20(false, PoxAddressType20::P2WPKH, [0x01; 20]),
-            PoxAddress::Addr32(false, PoxAddressType32::P2WSH, [0x02; 32]),
-            PoxAddress::Addr32(false, PoxAddressType32::P2TR, [0x03; 32]),
-            PoxAddress::from_legacy(AddressHashMode::SerializeP2PKH, Hash160([0x04; 20])),
-        ])
-        .map(|(key, pox_addr)| {
-            txs.push(make_pox_3_lockup(
-                key,
-                0,
-                1024 * POX_THRESHOLD_STEPS_USTX,
-                pox_addr.clone(),
-                2,
-                tip_height,
-            ));
-            pox_addr
-        })
-        .collect();
-
-    let mut latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
-    assert_latest_was_burn(&mut peer);
-
-    let target_height = burnchain.reward_cycle_to_block_height(first_v3_cycle);
-    // produce blocks until the first reward phase that everyone should be in
-    while get_tip(peer.sortdb.as_ref()).block_height < target_height {
-        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-        assert_latest_was_burn(&mut peer);
-    }
-
-    // now we should be in the reward phase, produce the reward blocks
-    let reward_blocks =
-        burnchain.pox_constants.reward_cycle_length - burnchain.pox_constants.prepare_length;
-    let mut rewarded = HashSet::new();
-    for i in 0..reward_blocks {
-        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-        // only the first 2 reward blocks contain pox outputs, because there are 6 slots and only 4 are occuppied
-        if i < 2 {
-            assert_latest_was_pox(&mut peer)
-                .into_iter()
-                .filter(|addr| !addr.is_burn())
-                .for_each(|addr| {
-                    rewarded.insert(addr);
-                });
-        } else {
-            assert_latest_was_burn(&mut peer);
-        }
-    }
-
-    assert_eq!(rewarded.len(), 4);
-    for stacker in stackers.iter() {
-        assert!(
-            rewarded.contains(stacker),
-            "Reward cycle should include {}",
-            stacker
-        );
-    }
-
-    // now we should be back in a prepare phase
-    for _i in 0..burnchain.pox_constants.prepare_length {
-        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-        assert_latest_was_burn(&mut peer);
-    }
-
-    // now we should be in the reward phase, produce the reward blocks
-    let mut rewarded = HashSet::new();
-    for i in 0..reward_blocks {
-        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-        // only the first 2 reward blocks contain pox outputs, because there are 6 slots and only 4 are occuppied
-        if i < 2 {
-            assert_latest_was_pox(&mut peer)
-                .into_iter()
-                .filter(|addr| !addr.is_burn())
-                .for_each(|addr| {
-                    rewarded.insert(addr);
-                });
-        } else {
-            assert_latest_was_burn(&mut peer);
-        }
-    }
-
-    assert_eq!(rewarded.len(), 4);
-    for stacker in stackers.iter() {
-        assert!(
-            rewarded.contains(stacker),
-            "Reward cycle should include {}",
-            stacker
-        );
-    }
-
-    // now we should be back in a prepare phase
-    for _i in 0..burnchain.pox_constants.prepare_length {
-        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-        assert_latest_was_burn(&mut peer);
-    }
-
-    // now we're in the next reward cycle, but everyone is unstacked
-    for _i in 0..burnchain.pox_constants.reward_cycle_length {
+    info!("Checking STX unlocked after {lock_period} cycles");
+    for _ in 0..burnchain.pox_constants.reward_cycle_length {
         latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
         assert_latest_was_burn(&mut peer);
     }
 }
 
-/// In this test case, Alice delegates to Bob.
-///  Bob stacks Alice's funds via PoX v2 for 6 cycles. In the third cycle,
-///  Bob increases Alice's stacking amount by less than the stacking min.
-///  Bob is able to increase the pool's aggregate amount anyway.
-///
+/// Test that pox3 methods fail once pox4 is activated
 #[test]
-fn stack_aggregation_increase() {
-    // the sim environment produces 25 empty sortitions before
-    //  tenures start being tracked.
-    let EMPTY_SORTITIONS = 25;
-
-    let (epochs, pox_constants) = make_test_epochs_pox();
-
-    let mut burnchain = Burnchain::default_unittest(
-        0,
-        &BurnchainHeaderHash::from_hex(BITCOIN_REGTEST_FIRST_BLOCK_HASH).unwrap(),
-    );
-    burnchain.pox_constants = pox_constants.clone();
-
-    let first_v3_cycle = burnchain
-        .block_height_to_reward_cycle(burnchain.pox_constants.pox_3_activation_height as u64)
-        .unwrap()
-        + 1;
-
-    let observer = TestEventObserver::new();
-
-    let (mut peer, mut keys) = instantiate_pox_peer_with_epoch(
-        &burnchain,
-        function_name!(),
-        Some(epochs.clone()),
-        Some(&observer),
-    );
-
-    peer.config.check_pox_invariants = Some((first_v3_cycle, first_v3_cycle + 10));
-
-    let alice = keys.pop().unwrap();
-    let alice_address = key_to_stacks_addr(&alice);
-    let alice_principal = PrincipalData::from(alice_address.clone());
-    let bob = keys.pop().unwrap();
-    let bob_address = key_to_stacks_addr(&bob);
-    let bob_principal = PrincipalData::from(bob_address.clone());
-    let bob_pox_addr = make_pox_addr(AddressHashMode::SerializeP2PKH, bob_address.bytes.clone());
-    let charlie = keys.pop().unwrap();
-    let charlie_address = key_to_stacks_addr(&charlie);
-    let charlie_pox_addr = make_pox_addr(
-        AddressHashMode::SerializeP2PKH,
-        charlie_address.bytes.clone(),
-    );
-    let dan = keys.pop().unwrap();
-    let dan_address = key_to_stacks_addr(&dan);
-    let dan_principal = PrincipalData::from(dan_address.clone());
-    let dan_pox_addr = make_pox_addr(AddressHashMode::SerializeP2PKH, dan_address.bytes.clone());
-    let alice_nonce = 0;
-    let mut bob_nonce = 0;
-    let mut charlie_nonce = 0;
-    let mut dan_nonce = 0;
-
-    let alice_first_lock_amount = 512 * POX_THRESHOLD_STEPS_USTX;
-    let alice_delegation_amount = alice_first_lock_amount + 1;
-    let dan_delegation_amount = alice_first_lock_amount + 1;
-    let dan_stack_amount = 511 * POX_THRESHOLD_STEPS_USTX;
-
-    let mut coinbase_nonce = 0;
-
-    // first tenure is empty
-    let mut latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-
-    // Roll to Epoch-2.4 and perform the delegate-stack-extend tests
-    while get_tip(peer.sortdb.as_ref()).block_height <= epochs[6].start_height {
-        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-    }
-
-    let tip = get_tip(peer.sortdb.as_ref());
-
-    // submit delegation tx for alice
-    let alice_delegation_1 = make_pox_3_contract_call(
-        &alice,
-        alice_nonce,
-        "delegate-stx",
-        vec![
-            Value::UInt(alice_delegation_amount),
-            bob_principal.clone().into(),
-            Value::none(),
-            Value::none(),
-        ],
-    );
-
-    // bob locks some of alice's tokens
-    let delegate_stack_tx_bob = make_pox_3_contract_call(
-        &bob,
-        bob_nonce,
-        "delegate-stack-stx",
-        vec![
-            alice_principal.clone().into(),
-            Value::UInt(alice_first_lock_amount),
-            bob_pox_addr.clone(),
-            Value::UInt(tip.block_height as u128),
-            Value::UInt(6),
-        ],
-    );
-    bob_nonce += 1;
-
-    // dan stacks some tokens
-    let stack_tx_dan = make_pox_3_lockup(
-        &dan,
-        dan_nonce,
-        dan_stack_amount,
-        PoxAddress::from_legacy(AddressHashMode::SerializeP2PKH, dan_address.bytes.clone()),
-        12,
-        tip.block_height,
-    );
-    dan_nonce += 1;
-
-    latest_block = peer.tenure_with_txs(
-        &[alice_delegation_1, delegate_stack_tx_bob, stack_tx_dan],
-        &mut coinbase_nonce,
-    );
-
-    // check that the partial stacking state contains entries for bob
-    for cycle_number in first_v3_cycle..(first_v3_cycle + 6) {
-        let partial_stacked = get_partial_stacked(
-            &mut peer,
-            &latest_block,
-            &bob_pox_addr,
-            cycle_number,
-            &bob_principal,
-            POX_3_NAME,
-        );
-        assert_eq!(partial_stacked, 512 * POX_THRESHOLD_STEPS_USTX);
-    }
-
-    // we'll produce blocks until the 3rd reward cycle gets through the "handled start" code
-    //  this is one block after the reward cycle starts
-    let height_target = burnchain.reward_cycle_to_block_height(first_v3_cycle + 3) + 1;
-
-    while get_tip(peer.sortdb.as_ref()).block_height < height_target {
-        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-    }
-
-    let expected_alice_unlock = burnchain.reward_cycle_to_block_height(first_v3_cycle + 6) - 1;
-    let expected_dan_unlock = burnchain.reward_cycle_to_block_height(first_v3_cycle + 12) - 1;
-
-    let alice_bal = get_stx_account_at(&mut peer, &latest_block, &alice_principal);
-    assert_eq!(alice_bal.amount_locked(), alice_first_lock_amount);
-    assert_eq!(alice_bal.unlock_height(), expected_alice_unlock);
-
-    let dan_bal = get_stx_account_at(&mut peer, &latest_block, &dan_principal);
-    assert_eq!(dan_bal.amount_locked(), dan_stack_amount);
-    assert_eq!(dan_bal.unlock_height(), expected_dan_unlock);
-
-    // check that the partial stacking state still contains entries for bob
-    for cycle_number in first_v3_cycle..(first_v3_cycle + 6) {
-        let partial_stacked = get_partial_stacked(
-            &mut peer,
-            &latest_block,
-            &bob_pox_addr,
-            cycle_number,
-            &bob_principal,
-            POX_3_NAME,
-        );
-        assert_eq!(partial_stacked, 512 * POX_THRESHOLD_STEPS_USTX);
-    }
-
-    let tip = get_tip(peer.sortdb.as_ref());
-    let cur_reward_cycle = burnchain
-        .block_height_to_reward_cycle(tip.block_height)
-        .unwrap();
-
-    let mut txs_to_submit = vec![];
-
-    // bob locks in alice's tokens to a PoX address,
-    // which clears the partially-stacked state
-    txs_to_submit.push(make_pox_3_contract_call(
-        &bob,
-        bob_nonce,
-        "stack-aggregation-commit-indexed",
-        vec![
-            bob_pox_addr.clone(),
-            Value::UInt((cur_reward_cycle + 1) as u128),
-        ],
-    ));
-    let bob_stack_aggregation_commit_indexed = bob_nonce;
-    bob_nonce += 1;
-
-    // bob tries to lock tokens in a reward cycle that's already committed (should fail with
-    // ERR_STACKING_NO_SUCH_PRINCIPAL)
-    txs_to_submit.push(make_pox_3_contract_call(
-        &bob,
-        bob_nonce,
-        "stack-aggregation-increase",
-        vec![
-            bob_pox_addr.clone(),
-            Value::UInt((cur_reward_cycle + 1) as u128),
-            Value::UInt(0),
-        ],
-    ));
-    let bob_err_stacking_no_such_principal = bob_nonce;
-    bob_nonce += 1;
-
-    // bob locks up 1 more of alice's tokens
-    // takes effect in the _next_ reward cycle
-    txs_to_submit.push(make_pox_3_contract_call(
-        &bob,
-        bob_nonce,
-        "delegate-stack-increase",
-        vec![
-            alice_principal.clone().into(),
-            bob_pox_addr.clone(),
-            Value::UInt(1),
-        ],
-    ));
-    bob_nonce += 1;
-
-    latest_block = peer.tenure_with_txs(&txs_to_submit, &mut coinbase_nonce);
-    let tip = get_tip(peer.sortdb.as_ref());
-    let cur_reward_cycle = burnchain
-        .block_height_to_reward_cycle(tip.block_height)
-        .unwrap();
-
-    // locked up more tokens, but unlock height is unchanged
-    let alice_bal = get_stx_account_at(&mut peer, &latest_block, &alice_principal);
-    assert_eq!(alice_bal.amount_locked(), alice_delegation_amount);
-    assert_eq!(alice_bal.unlock_height(), expected_alice_unlock);
-
-    // only 1 uSTX to lock in this next cycle for Alice
-    let partial_stacked = get_partial_stacked(
-        &mut peer,
-        &latest_block,
-        &bob_pox_addr,
-        cur_reward_cycle + 1,
-        &bob_principal,
-        POX_3_NAME,
-    );
-    assert_eq!(partial_stacked, 1);
-
-    for cycle_number in (cur_reward_cycle + 2)..(first_v3_cycle + 6) {
-        // alice has 512 * POX_THRESHOLD_STEPS_USTX partially-stacked STX in all cycles after
-        let partial_stacked = get_partial_stacked(
-            &mut peer,
-            &latest_block,
-            &bob_pox_addr,
-            cycle_number,
-            &bob_principal,
-            POX_3_NAME,
-        );
-        assert_eq!(partial_stacked, alice_delegation_amount);
-    }
-
-    let mut txs_to_submit = vec![];
-
-    // charlie tries to lock alice's additional tokens to his own PoX address (should fail with
-    // ERR_STACKING_NO_SUCH_PRINCIPAL)
-    txs_to_submit.push(make_pox_3_contract_call(
-        &charlie,
-        charlie_nonce,
-        "stack-aggregation-increase",
-        vec![
-            charlie_pox_addr.clone(),
-            Value::UInt(cur_reward_cycle as u128),
-            Value::UInt(0),
-        ],
-    ));
-    let charlie_err_stacking_no_principal = charlie_nonce;
-    charlie_nonce += 1;
-
-    // charlie tries to lock alice's additional tokens to bob's PoX address (should fail with
-    // ERR_STACKING_NO_SUCH_PRINCIPAL)
-    txs_to_submit.push(make_pox_3_contract_call(
-        &charlie,
-        charlie_nonce,
-        "stack-aggregation-increase",
-        vec![
-            bob_pox_addr.clone(),
-            Value::UInt(cur_reward_cycle as u128),
-            Value::UInt(0),
-        ],
-    ));
-    let charlie_err_stacking_no_principal_2 = charlie_nonce;
-    charlie_nonce += 1;
-
-    // bob tries to retcon a reward cycle lockup (should fail with ERR_STACKING_INVALID_LOCK_PERIOD)
-    txs_to_submit.push(make_pox_3_contract_call(
-        &bob,
-        bob_nonce,
-        "stack-aggregation-increase",
-        vec![
-            bob_pox_addr.clone(),
-            Value::UInt(cur_reward_cycle as u128),
-            Value::UInt(0),
-        ],
-    ));
-    let bob_err_stacking_invalid_lock_period = bob_nonce;
-    bob_nonce += 1;
-
-    // bob tries to lock tokens in a reward cycle that has no tokens stacked in it yet (should
-    // fail with ERR_DELEGATION_NO_REWARD_CYCLE)
-    txs_to_submit.push(make_pox_3_contract_call(
-        &bob,
-        bob_nonce,
-        "stack-aggregation-increase",
-        vec![
-            bob_pox_addr.clone(),
-            Value::UInt((cur_reward_cycle + 13) as u128),
-            Value::UInt(0),
-        ],
-    ));
-    let bob_err_delegation_no_reward_cycle = bob_nonce;
-    bob_nonce += 1;
-
-    // bob tries to lock tokens to a non-existant PoX reward address (should fail with
-    // ERR_DELEGATION_NO_REWARD_SLOT)
-    txs_to_submit.push(make_pox_3_contract_call(
-        &bob,
-        bob_nonce,
-        "stack-aggregation-increase",
-        vec![
-            bob_pox_addr.clone(),
-            Value::UInt((cur_reward_cycle + 1) as u128),
-            Value::UInt(2),
-        ],
-    ));
-    let bob_err_delegation_no_reward_slot = bob_nonce;
-    bob_nonce += 1;
-
-    // bob tries to lock tokens to the wrong PoX address (should fail with ERR_DELEGATION_WRONG_REWARD_SLOT).
-    // slot 0 belongs to dan.
-    txs_to_submit.push(make_pox_3_contract_call(
-        &bob,
-        bob_nonce,
-        "stack-aggregation-increase",
-        vec![
-            bob_pox_addr.clone(),
-            Value::UInt((cur_reward_cycle + 1) as u128),
-            Value::UInt(0),
-        ],
-    ));
-    let bob_err_delegation_wrong_reward_slot = bob_nonce;
-    bob_nonce += 1;
-
-    // bob locks tokens for Alice (bob's previous stack-aggregation-commit put his PoX address in
-    // slot 1 for this reward cycle)
-    txs_to_submit.push(make_pox_3_contract_call(
-        &bob,
-        bob_nonce,
-        "stack-aggregation-increase",
-        vec![
-            bob_pox_addr.clone(),
-            Value::UInt((cur_reward_cycle + 1) as u128),
-            Value::UInt(1),
-        ],
-    ));
-    bob_nonce += 1;
-
-    latest_block = peer.tenure_with_txs(&txs_to_submit, &mut coinbase_nonce);
+fn pox_3_fails() {
+    // Config for this test
+    // We are going to try locking for 2 reward cycles (10 blocks)
+    let lock_period = 2;
+    let (epochs, pox_constants) = make_test_epochs_pox();
 
-    assert_eq!(
-        get_stx_account_at(&mut peer, &latest_block, &alice_principal).amount_locked(),
-        alice_delegation_amount
+    let mut burnchain = Burnchain::default_unittest(
+        0,
+        &BurnchainHeaderHash::from_hex(BITCOIN_REGTEST_FIRST_BLOCK_HASH).unwrap(),
     );
+    burnchain.pox_constants = pox_constants.clone();
 
-    // now let's check some tx receipts
-
-    let alice_address = key_to_stacks_addr(&alice);
-    let blocks = observer.get_blocks();
+    let (mut peer, keys) =
+        instantiate_pox_peer_with_epoch(&burnchain, function_name!(), Some(epochs.clone()), None);
 
-    let mut alice_txs = HashMap::new();
-    let mut bob_txs = HashMap::new();
-    let mut charlie_txs = HashMap::new();
+    assert_eq!(burnchain.pox_constants.reward_slots(), 6);
+    let mut coinbase_nonce = 0;
+    let mut latest_block;
 
-    for b in blocks.into_iter() {
-        for r in b.receipts.into_iter() {
-            if let TransactionOrigin::Stacks(ref t) = r.transaction {
-                let addr = t.auth.origin().address_testnet();
-                if addr == alice_address {
-                    alice_txs.insert(t.auth.get_origin_nonce(), r);
-                } else if addr == bob_address {
-                    bob_txs.insert(t.auth.get_origin_nonce(), r);
-                } else if addr == charlie_address {
-                    charlie_txs.insert(t.auth.get_origin_nonce(), r);
-                }
-            }
+    // Advance into pox4
+    let target_height = burnchain.pox_constants.pox_4_activation_height;
+    // produce blocks until the first reward phase that everyone should be in
+    while get_tip(peer.sortdb.as_ref()).block_height < u64::from(target_height) {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+        // if we reach epoch 2.1, perform the check
+        if get_tip(peer.sortdb.as_ref()).block_height > epochs[3].start_height {
+            assert_latest_was_burn(&mut peer);
         }
     }
 
-    assert_eq!(alice_txs.len(), 1);
-    assert_eq!(bob_txs.len(), 9);
-    assert_eq!(charlie_txs.len(), 2);
-
-    // bob's stack-aggregation-commit-indexed succeeded and returned the right index
-    assert_eq!(
-        &bob_txs[&bob_stack_aggregation_commit_indexed]
-            .result
-            .to_string(),
-        "(ok u1)"
+    info!(
+        "Block height: {}",
+        get_tip(peer.sortdb.as_ref()).block_height
     );
 
-    // check bob's errors
-    assert_eq!(
-        &bob_txs[&bob_err_stacking_no_such_principal]
-            .result
-            .to_string(),
-        "(err 4)"
-    );
-    assert_eq!(
-        &bob_txs[&bob_err_stacking_invalid_lock_period]
-            .result
-            .to_string(),
-        "(err 2)"
-    );
-    assert_eq!(
-        &bob_txs[&bob_err_delegation_no_reward_cycle]
-            .result
-            .to_string(),
-        "(err 4)"
-    );
-    assert_eq!(
-        &bob_txs[&bob_err_delegation_no_reward_slot]
-            .result
-            .to_string(),
-        "(err 28)"
-    );
-    assert_eq!(
-        &bob_txs[&bob_err_delegation_wrong_reward_slot]
-            .result
-            .to_string(),
-        "(err 29)"
-    );
+    let mut txs = vec![];
+    let tip_height = get_tip(peer.sortdb.as_ref()).block_height;
+    let stackers: Vec<_> = keys
+        .iter()
+        .zip([
+            AddressHashMode::SerializeP2PKH,
+            AddressHashMode::SerializeP2SH,
+            AddressHashMode::SerializeP2WPKH,
+            AddressHashMode::SerializeP2WSH,
+        ])
+        .map(|(key, hash_mode)| {
+            let pox_addr = PoxAddress::from_legacy(hash_mode, key_to_stacks_addr(key).bytes);
+            txs.push(make_pox_3_lockup(
+                key,
+                0,
+                1024 * POX_THRESHOLD_STEPS_USTX,
+                pox_addr.clone(),
+                lock_period,
+                tip_height,
+            ));
+            pox_addr
+        })
+        .collect();
 
-    // check charlie's errors
-    assert_eq!(
-        &charlie_txs[&charlie_err_stacking_no_principal]
-            .result
-            .to_string(),
-        "(err 4)"
-    );
-    assert_eq!(
-        &charlie_txs[&charlie_err_stacking_no_principal_2]
-            .result
-            .to_string(),
-        "(err 4)"
+    info!("Submitting stacking txs with pox3");
+    latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
+
+    // Advance to start of rewards cycle stackers are participating in
+    let target_height = burnchain.pox_constants.pox_4_activation_height + 5;
+    while get_tip(peer.sortdb.as_ref()).block_height < u64::from(target_height) {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    }
+
+    info!(
+        "Block height: {}",
+        get_tip(peer.sortdb.as_ref()).block_height
     );
+
+    // now we should be in the reward phase, produce the reward blocks
+    let reward_blocks =
+        burnchain.pox_constants.reward_cycle_length - burnchain.pox_constants.prepare_length;
+
+    // Check next 3 reward cycles
+    for _ in 0..=lock_period {
+        let tip = get_tip(peer.sortdb.as_ref());
+        let cycle = burnchain
+            .block_height_to_reward_cycle(tip.block_height)
+            .unwrap();
+        info!("Checking no stackers for cycle {cycle}");
+        for _ in 0..burnchain.pox_constants.reward_cycle_length {
+            latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+            // Should all be burn because no stackers
+            assert_latest_was_burn(&mut peer);
+        }
+    }
 }
 
-/// Verify that delegate-stx validates the PoX addr, if given
+/// Test that we can lock STX for a couple cycles after pox4 starts,
+/// and that it unlocks after the desired number of cycles
 #[test]
-fn pox_3_delegate_stx_addr_validation() {
-    // the sim environment produces 25 empty sortitions before
-    //  tenures start being tracked.
-    let EMPTY_SORTITIONS = 25;
-
+fn pox_3_unlocks() {
+    // Config for this test
+    // We are going to try locking for 4 reward cycles (20 blocks)
+    let lock_period = 4;
     let (epochs, pox_constants) = make_test_epochs_pox();
 
     let mut burnchain = Burnchain::default_unittest(
@@ -4336,152 +966,125 @@ fn pox_3_delegate_stx_addr_validation() {
     );
     burnchain.pox_constants = pox_constants.clone();
 
-    let first_v3_cycle = burnchain
-        .block_height_to_reward_cycle(burnchain.pox_constants.pox_3_activation_height as u64)
-        .unwrap()
-        + 1;
-
-    let (mut peer, mut keys) =
+    let (mut peer, keys) =
         instantiate_pox_peer_with_epoch(&burnchain, function_name!(), Some(epochs.clone()), None);
 
-    peer.config.check_pox_invariants = Some((first_v3_cycle, first_v3_cycle + 10));
-
+    assert_eq!(burnchain.pox_constants.reward_slots(), 6);
     let mut coinbase_nonce = 0;
-    let alice = keys.pop().unwrap();
-    let bob = keys.pop().unwrap();
-    let charlie = keys.pop().unwrap();
-    let danielle = keys.pop().unwrap();
-    let alice_address = key_to_stacks_addr(&alice);
-    let bob_address = key_to_stacks_addr(&bob);
-    let charlie_address = key_to_stacks_addr(&charlie);
-    let LOCKUP_AMT = 1024 * POX_THRESHOLD_STEPS_USTX;
-
-    // first tenure is empty
-    let mut latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    let mut latest_block;
 
-    // Roll to Epoch-2.4 and perform the delegate-stack-extend tests
-    while get_tip(peer.sortdb.as_ref()).block_height <= epochs[6].start_height {
+    // Advance to a few blocks before pox 3 unlock
+    let target_height = burnchain.pox_constants.v3_unlock_height - 14;
+    // produce blocks until the first reward phase that everyone should be in
+    while get_tip(peer.sortdb.as_ref()).block_height < u64::from(target_height) {
         latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+        // if we reach epoch 2.1, perform the check
+        if get_tip(peer.sortdb.as_ref()).block_height > epochs[3].start_height {
+            assert_latest_was_burn(&mut peer);
+        }
     }
 
-    let tip = get_tip(peer.sortdb.as_ref());
-    let cur_reward_cycle = burnchain
-        .block_height_to_reward_cycle(tip.block_height)
-        .unwrap();
-
-    // alice delegates to charlie in v3 to a valid address
-    let alice_delegation = make_pox_3_contract_call(
-        &alice,
-        0,
-        "delegate-stx",
-        vec![
-            Value::UInt(LOCKUP_AMT),
-            PrincipalData::from(charlie_address.clone()).into(),
-            Value::none(),
-            Value::some(make_pox_addr(
-                AddressHashMode::SerializeP2PKH,
-                alice_address.bytes.clone(),
-            ))
-            .unwrap(),
-        ],
-    );
+    info!( "Block height: {}", get_tip(peer.sortdb.as_ref()).block_height);
 
-    let bob_bad_pox_addr = Value::Tuple(
-        TupleData::from_data(vec![
-            (
-                ClarityName::try_from("version".to_owned()).unwrap(),
-                Value::buff_from_byte(0xff),
-            ),
-            (
-                ClarityName::try_from("hashbytes".to_owned()).unwrap(),
-                Value::Sequence(SequenceData::Buffer(BuffData {
-                    data: bob_address.bytes.as_bytes().to_vec(),
-                })),
-            ),
+    let mut txs = vec![];
+    let tip_height = get_tip(peer.sortdb.as_ref()).block_height;
+    let stackers: Vec<_> = keys
+        .iter()
+        .zip([
+            AddressHashMode::SerializeP2PKH,
+            AddressHashMode::SerializeP2SH,
+            AddressHashMode::SerializeP2WPKH,
+            AddressHashMode::SerializeP2WSH,
         ])
-        .unwrap(),
-    );
+        .map(|(key, hash_mode)| {
+            let pox_addr = PoxAddress::from_legacy(hash_mode, key_to_stacks_addr(key).bytes);
+            txs.push(make_pox_3_lockup(
+                key,
+                0,
+                1024 * POX_THRESHOLD_STEPS_USTX,
+                pox_addr.clone(),
+                lock_period,
+                tip_height,
+            ));
+            pox_addr
+        })
+        .collect();
 
-    // bob delegates to charlie in v3 with an invalid address
-    let bob_delegation = make_pox_3_contract_call(
-        &bob,
-        0,
-        "delegate-stx",
-        vec![
-            Value::UInt(LOCKUP_AMT),
-            PrincipalData::from(charlie_address.clone()).into(),
-            Value::none(),
-            Value::some(bob_bad_pox_addr).unwrap(),
-        ],
-    );
+    info!("Submitting stacking txs");
+    latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
 
-    peer.tenure_with_txs(&[alice_delegation, bob_delegation], &mut coinbase_nonce);
-
-    let result = eval_at_tip(
-        &mut peer,
-        "pox-3",
-        &format!(
-            "
-    {{
-        ;; should be (some $charlie_address)
-        get-delegation-info-alice: (get-delegation-info '{}),
-        ;; should be none
-        get-delegation-info-bob: (get-delegation-info '{}),
-    }}",
-            &alice_address, &bob_address,
-        ),
-    );
+    // Advance a couple more blocks
+    for _ in 0..3 {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    }
 
-    eprintln!("{}", &result);
-    let data = result.expect_tuple().data_map;
+    // now we should be in the reward phase, produce the reward blocks
+    let reward_blocks =
+        burnchain.pox_constants.reward_cycle_length - burnchain.pox_constants.prepare_length;
+    let mut rewarded = HashSet::new();
 
-    // bob had an invalid PoX address
-    let bob_delegation_info = data
-        .get("get-delegation-info-bob")
-        .cloned()
-        .unwrap()
-        .expect_optional();
-    assert!(bob_delegation_info.is_none());
+    // Check that STX are locked for 2 reward cycles
+    for _ in 0..2 {
+        let tip = get_tip(peer.sortdb.as_ref());
+        let cycle = burnchain
+            .block_height_to_reward_cycle(tip.block_height)
+            .unwrap();
+        info!("Checking STX locked for cycle {cycle}");
+        for i in 0..reward_blocks {
+            latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+            // only the first 2 reward blocks contain pox outputs, because there are 6 slots and only 4 are occuppied
+            if i < 2 {
+                assert_latest_was_pox(&mut peer)
+                    .into_iter()
+                    .filter(|addr| !addr.is_burn())
+                    .for_each(|addr| {
+                        rewarded.insert(addr);
+                    });
+            } else {
+                assert_latest_was_burn(&mut peer);
+            }
+        }
 
-    // alice was valid
-    let alice_delegation_info = data
-        .get("get-delegation-info-alice")
-        .cloned()
-        .unwrap()
-        .expect_optional()
-        .unwrap()
-        .expect_tuple()
-        .data_map;
-    let alice_delegation_addr = alice_delegation_info
-        .get("delegated-to")
-        .cloned()
-        .unwrap()
-        .expect_principal();
-    let alice_delegation_amt = alice_delegation_info
-        .get("amount-ustx")
-        .cloned()
-        .unwrap()
-        .expect_u128();
-    let alice_pox_addr_opt = alice_delegation_info
-        .get("pox-addr")
-        .cloned()
-        .unwrap()
-        .expect_optional();
-    assert_eq!(
-        alice_delegation_addr,
-        charlie_address.to_account_principal()
-    );
-    assert_eq!(alice_delegation_amt, LOCKUP_AMT as u128);
-    assert!(alice_pox_addr_opt.is_some());
+        assert_eq!(rewarded.len(), 4);
+        for stacker in stackers.iter() {
+            assert!(
+                rewarded.contains(stacker),
+                "Reward cycle should include {stacker}"
+            );
+        }
+
+        // now we should be back in a prepare phase
+        info!("Checking we are in prepare phase");
+        for _ in 0..burnchain.pox_constants.prepare_length {
+            latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+            assert_latest_was_burn(&mut peer);
+        }
+    }
 
-    let alice_pox_addr = alice_pox_addr_opt.unwrap();
+    // Advance to v3 unlock
+    let target_height = burnchain.pox_constants.v3_unlock_height;
+    while get_tip(peer.sortdb.as_ref()).block_height < u64::from(target_height) {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    }
 
-    assert_eq!(
-        alice_pox_addr,
-        make_pox_addr(AddressHashMode::SerializeP2PKH, alice_address.bytes.clone(),)
+    info!(
+        "Block height: {}",
+        get_tip(peer.sortdb.as_ref()).block_height
     );
-}
 
+    // Check that STX are not locked for 3 reward cycles after pox4 starts
+    for _ in 0..3 {
+        let tip = get_tip(peer.sortdb.as_ref());
+        let cycle = burnchain
+            .block_height_to_reward_cycle(tip.block_height)
+            .unwrap();
+        info!("Checking no stackers for cycle {cycle}");
+        for _ in 0..burnchain.pox_constants.reward_cycle_length {
+            latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+            assert_latest_was_burn(&mut peer);
+        }
+    }
+}
 
 fn assert_latest_was_burn (peer: &mut TestPeer) {
     let tip = get_tip(peer.sortdb.as_ref());

From bfc37237f2e2aa6fa79e2cb6b4fb981bfc8377dc Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Mon, 11 Dec 2023 10:45:10 -0500
Subject: [PATCH 0170/1166] Run `cargo fmt-stacks`

---
 stackslib/src/chainstate/stacks/boot/pox_4_tests.rs | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index e48094b5bb..014aeaaed2 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -984,7 +984,10 @@ fn pox_3_unlocks() {
         }
     }
 
-    info!( "Block height: {}", get_tip(peer.sortdb.as_ref()).block_height);
+    info!(
+        "Block height: {}",
+        get_tip(peer.sortdb.as_ref()).block_height
+    );
 
     let mut txs = vec![];
     let tip_height = get_tip(peer.sortdb.as_ref()).block_height;
@@ -1086,7 +1089,7 @@ fn pox_3_unlocks() {
     }
 }
 
-fn assert_latest_was_burn (peer: &mut TestPeer) {
+fn assert_latest_was_burn(peer: &mut TestPeer) {
     let tip = get_tip(peer.sortdb.as_ref());
     let tip_index_block = tip.get_canonical_stacks_block_id();
     let burn_height = tip.block_height - 1;
@@ -1119,7 +1122,7 @@ fn assert_latest_was_burn (peer: &mut TestPeer) {
     }
 }
 
-fn assert_latest_was_pox (peer: &mut TestPeer) -> Vec<PoxAddress> {
+fn assert_latest_was_pox(peer: &mut TestPeer) -> Vec<PoxAddress> {
     let tip = get_tip(peer.sortdb.as_ref());
     let tip_index_block = tip.get_canonical_stacks_block_id();
     let burn_height = tip.block_height - 1;

From f28d4075edd90780b69fcd166a06dd728bc6eaec Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Mon, 11 Dec 2023 11:42:39 -0500
Subject: [PATCH 0171/1166] Address PR feedback

---
 .../src/chainstate/nakamoto/coordinator/tests.rs |  4 ++--
 .../src/chainstate/stacks/boot/pox_2_tests.rs    | 16 ++++++++++++++++
 .../src/chainstate/stacks/boot/pox_3_tests.rs    | 16 ++++++++++++++++
 .../src/chainstate/stacks/boot/pox_4_tests.rs    | 16 ++++++++++++++++
 4 files changed, 50 insertions(+), 2 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index f421cf4ec6..3e65cecfa9 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -282,7 +282,7 @@ fn test_simple_nakamoto_coordinator_bootup() {
 /// Mine a single Nakamoto tenure with 10 Nakamoto blocks
 #[test]
 fn test_simple_nakamoto_coordinator_1_tenure_10_blocks() {
-    let private_key = StacksPrivateKey::new();
+    let private_key = StacksPrivateKey::from_seed(&[2]);
     let addr = StacksAddress::from_public_keys(
         C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
         &AddressHashMode::SerializeP2PKH,
@@ -388,7 +388,7 @@ fn test_simple_nakamoto_coordinator_1_tenure_10_blocks() {
 /// Mine a 10 Nakamoto tenures with 10 Nakamoto blocks
 #[test]
 fn test_simple_nakamoto_coordinator_10_tenures_10_blocks() {
-    let private_key = StacksPrivateKey::new();
+    let private_key = StacksPrivateKey::from_seed(&[2]);
     let addr = StacksAddress::from_public_keys(
         C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
         &AddressHashMode::SerializeP2PKH,
diff --git a/stackslib/src/chainstate/stacks/boot/pox_2_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_2_tests.rs
index b7700eee58..a7ce85cdf6 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_2_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_2_tests.rs
@@ -1,3 +1,19 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020-2023 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
 use std::collections::{HashMap, HashSet, VecDeque};
 use std::convert::{TryFrom, TryInto};
 
diff --git a/stackslib/src/chainstate/stacks/boot/pox_3_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_3_tests.rs
index b358f4310b..fe41632f6e 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_3_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_3_tests.rs
@@ -1,3 +1,19 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020-2023 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
 use std::collections::{HashMap, HashSet, VecDeque};
 use std::convert::{TryFrom, TryInto};
 
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 014aeaaed2..1dd42efcb3 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -1,3 +1,19 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020-2023 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
 use std::collections::{HashMap, HashSet, VecDeque};
 use std::convert::{TryFrom, TryInto};
 

From 1c5d743a3bc3920f96e779abab77007d1b147197 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Mon, 11 Dec 2023 14:26:38 -0500
Subject: [PATCH 0172/1166] Address PR feedback; Add explicit account balance
 checks

---
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 46 ++++++++++++++++++-
 1 file changed, 44 insertions(+), 2 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 1dd42efcb3..987ab35a4c 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -41,6 +41,7 @@ use stacks_common::types::chainstate::{
 };
 use stacks_common::types::Address;
 use stacks_common::util::hash::{hex_bytes, to_hex, Sha256Sum, Sha512Trunc256Sum};
+use stacks_common::util::secp256k1::Secp256k1PrivateKey;
 
 use super::test::*;
 use super::RawRewardSetEntry;
@@ -834,7 +835,13 @@ fn pox_lock_unlock() {
         let cycle = burnchain
             .block_height_to_reward_cycle(tip.block_height)
             .unwrap();
-        info!("Checking no stackers for cycle {cycle}");
+
+        info!("Checking that stackers have STX locked for cycle {cycle}");
+        let balances = balances_from_keys(&mut peer, &latest_block, &keys);
+        assert!(balances[0].amount_locked() > 0);
+        assert!(balances[1].amount_locked() > 0);
+
+        info!("Checking we have 2 stackers for cycle {cycle}");
         for i in 0..reward_blocks {
             latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
             // only the first 2 reward blocks contain pox outputs, because there are 6 slots and only 4 are occuppied
@@ -871,11 +878,16 @@ fn pox_lock_unlock() {
         latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
         assert_latest_was_burn(&mut peer);
     }
+
+    info!("Checking that stackers have no STX locked");
+    let balances = balances_from_keys(&mut peer, &latest_block, &keys);
+    assert_eq!(balances[0].amount_locked(), 0);
+    assert_eq!(balances[1].amount_locked(), 0);
 }
 
 /// Test that pox3 methods fail once pox4 is activated
 #[test]
-fn pox_3_fails() {
+fn pox_3_defunct() {
     // Config for this test
     // We are going to try locking for 2 reward cycles (10 blocks)
     let lock_period = 2;
@@ -958,6 +970,12 @@ fn pox_3_fails() {
         let cycle = burnchain
             .block_height_to_reward_cycle(tip.block_height)
             .unwrap();
+
+        info!("Checking that stackers have no STX locked for cycle {cycle}");
+        let balances = balances_from_keys(&mut peer, &latest_block, &keys);
+        assert_eq!(balances[0].amount_locked(), 0);
+        assert_eq!(balances[1].amount_locked(), 0);
+
         info!("Checking no stackers for cycle {cycle}");
         for _ in 0..burnchain.pox_constants.reward_cycle_length {
             latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
@@ -1048,6 +1066,12 @@ fn pox_3_unlocks() {
         let cycle = burnchain
             .block_height_to_reward_cycle(tip.block_height)
             .unwrap();
+
+        info!("Checking that stackers have STX locked for cycle {cycle}");
+        let balances = balances_from_keys(&mut peer, &latest_block, &keys);
+        assert!(balances[0].amount_locked() > 0);
+        assert!(balances[1].amount_locked() > 0);
+
         info!("Checking STX locked for cycle {cycle}");
         for i in 0..reward_blocks {
             latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
@@ -1097,11 +1121,17 @@ fn pox_3_unlocks() {
         let cycle = burnchain
             .block_height_to_reward_cycle(tip.block_height)
             .unwrap();
+
         info!("Checking no stackers for cycle {cycle}");
         for _ in 0..burnchain.pox_constants.reward_cycle_length {
             latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
             assert_latest_was_burn(&mut peer);
         }
+
+        info!("Checking that stackers have no STX locked after cycle {cycle}");
+        let balances = balances_from_keys(&mut peer, &latest_block, &keys);
+        assert_eq!(balances[0].amount_locked(), 0);
+        assert_eq!(balances[1].amount_locked(), 0);
     }
 }
 
@@ -1164,3 +1194,15 @@ fn assert_latest_was_pox(peer: &mut TestPeer) -> Vec<PoxAddress> {
     assert!(commit_addrs.contains(&addrs[1]));
     addrs
 }
+
+fn balances_from_keys(
+    peer: &mut TestPeer,
+    tip: &StacksBlockId,
+    keys: &[Secp256k1PrivateKey],
+) -> Vec<STXBalance> {
+    keys.iter()
+        .map(|key| key_to_stacks_addr(key))
+        .map(|addr| PrincipalData::from(addr))
+        .map(|principal| get_stx_account_at(peer, tip, &principal))
+        .collect()
+}

From 2d3fbc84256099c4f8a7304480fa5ff3140cba92 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Mon, 11 Dec 2023 14:43:54 -0500
Subject: [PATCH 0173/1166] Address PR feedback in `pox_4.rs`

---
 pox-locking/src/events.rs | 2 +-
 pox-locking/src/pox_2.rs  | 4 ++--
 pox-locking/src/pox_3.rs  | 4 ++--
 pox-locking/src/pox_4.rs  | 6 ++----
 4 files changed, 7 insertions(+), 9 deletions(-)

diff --git a/pox-locking/src/events.rs b/pox-locking/src/events.rs
index 9f44330c33..c9865961dd 100644
--- a/pox-locking/src/events.rs
+++ b/pox-locking/src/events.rs
@@ -342,7 +342,7 @@ fn create_event_info_data_code(function_name: &str, args: &[Value]) -> String {
 /// Synthesize an events data tuple to return on the successful execution of a pox-2 or pox-3 stacking
 /// function.  It runs a series of Clarity queries against the PoX contract's data space (including
 /// calling PoX functions).
-pub fn synthesize_pox_2_or_3_event_info(
+pub fn synthesize_pox_event_info(
     global_context: &mut GlobalContext,
     contract_id: &QualifiedContractIdentifier,
     sender_opt: Option<&PrincipalData>,
diff --git a/pox-locking/src/pox_2.rs b/pox-locking/src/pox_2.rs
index 34c2f3a957..551af09a88 100644
--- a/pox-locking/src/pox_2.rs
+++ b/pox-locking/src/pox_2.rs
@@ -26,7 +26,7 @@ use clarity::vm::{Environment, Value};
 use slog::{slog_debug, slog_error};
 use stacks_common::{debug, error};
 
-use crate::events::synthesize_pox_2_or_3_event_info;
+use crate::events::synthesize_pox_event_info;
 use crate::LockingError;
 
 /// is a PoX-2 function call read only?
@@ -478,7 +478,7 @@ pub fn handle_contract_call(
             // for some reason.
             // Failure to synthesize an event due to a bug is *NOT* an excuse to crash the whole
             // network!  Event capture is not consensus-critical.
-            let event_info_opt = match synthesize_pox_2_or_3_event_info(
+            let event_info_opt = match synthesize_pox_event_info(
                 global_context,
                 contract_id,
                 sender_opt,
diff --git a/pox-locking/src/pox_3.rs b/pox-locking/src/pox_3.rs
index cccfbb2644..3323a27e34 100644
--- a/pox-locking/src/pox_3.rs
+++ b/pox-locking/src/pox_3.rs
@@ -26,7 +26,7 @@ use clarity::vm::{Environment, Value};
 use slog::{slog_debug, slog_error};
 use stacks_common::{debug, error};
 
-use crate::events::synthesize_pox_2_or_3_event_info;
+use crate::events::synthesize_pox_event_info;
 // Note: PoX-3 uses the same contract-call result parsing routines as PoX-2
 use crate::pox_2::{parse_pox_extend_result, parse_pox_increase, parse_pox_stacking_result};
 use crate::{LockingError, POX_3_NAME};
@@ -360,7 +360,7 @@ pub fn handle_contract_call(
             // for some reason.
             // Failure to synthesize an event due to a bug is *NOT* an excuse to crash the whole
             // network!  Event capture is not consensus-critical.
-            let event_info_opt = match synthesize_pox_2_or_3_event_info(
+            let event_info_opt = match synthesize_pox_event_info(
                 global_context,
                 contract_id,
                 sender_opt,
diff --git a/pox-locking/src/pox_4.rs b/pox-locking/src/pox_4.rs
index 82bf38cdb1..9fec335bf7 100644
--- a/pox-locking/src/pox_4.rs
+++ b/pox-locking/src/pox_4.rs
@@ -26,7 +26,7 @@ use clarity::vm::{Environment, Value};
 use slog::{slog_debug, slog_error};
 use stacks_common::{debug, error};
 
-use crate::events::synthesize_pox_2_or_3_event_info;
+use crate::events::synthesize_pox_event_info;
 // Note: PoX-4 uses the same contract-call result parsing routines as PoX-2
 use crate::pox_2::{parse_pox_extend_result, parse_pox_increase, parse_pox_stacking_result};
 use crate::{LockingError, POX_4_NAME};
@@ -150,8 +150,6 @@ pub fn pox_lock_increase_v4(
     Ok(out_balance)
 }
 
-/////////////// PoX-4 //////////////////////////////////////////
-
 /// Handle responses from stack-stx and delegate-stack-stx in pox-4 -- functions that *lock up* STX
 fn handle_stack_lockup_pox_v4(
     global_context: &mut GlobalContext,
@@ -340,7 +338,7 @@ pub fn handle_contract_call(
             // for some reason.
             // Failure to synthesize an event due to a bug is *NOT* an excuse to crash the whole
             // network!  Event capture is not consensus-critical.
-            let event_info_opt = match synthesize_pox_2_or_3_event_info(
+            let event_info_opt = match synthesize_pox_event_info(
                 global_context,
                 contract_id,
                 sender_opt,

From 7fb7a07884b2901fda1d89e6e6288277106cae2f Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Mon, 11 Dec 2023 18:24:39 -0500
Subject: [PATCH 0174/1166] Return error for pox3 calls in Epoch 2.5

---
 pox-locking/src/lib.rs                        | 14 ++++++++
 pox-locking/src/pox_3.rs                      | 27 ++++++++++++++
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 35 ++++++++++++++++---
 3 files changed, 72 insertions(+), 4 deletions(-)

diff --git a/pox-locking/src/lib.rs b/pox-locking/src/lib.rs
index 05303a4d9b..1127e6b667 100644
--- a/pox-locking/src/lib.rs
+++ b/pox-locking/src/lib.rs
@@ -107,6 +107,20 @@ pub fn handle_contract_call_special_cases(
             result,
         );
     } else if *contract_id == boot_code_id(POX_3_NAME, global_context.mainnet) {
+        if !pox_3::is_read_only(function_name) && global_context.epoch_id >= StacksEpochId::Epoch25
+        {
+            warn!("PoX-3 function call attempted on an account after Epoch 2.5";
+                  "v3_unlock_ht" => global_context.database.get_v3_unlock_height(),
+                  "current_burn_ht" => global_context.database.get_current_burnchain_block_height(),
+                  "function_name" => function_name,
+                  "contract_id" => %contract_id
+            );
+            return Err(ClarityError::Runtime(
+                RuntimeErrorType::DefunctPoxContract,
+                None,
+            ));
+        }
+
         return pox_3::handle_contract_call(
             global_context,
             sender,
diff --git a/pox-locking/src/pox_3.rs b/pox-locking/src/pox_3.rs
index 3323a27e34..cdfd0c740c 100644
--- a/pox-locking/src/pox_3.rs
+++ b/pox-locking/src/pox_3.rs
@@ -33,6 +33,33 @@ use crate::{LockingError, POX_3_NAME};
 
 /////////////////////// PoX-3 /////////////////////////////////
 
+/// is a PoX-3 function call read only?
+pub(crate) fn is_read_only(func_name: &str) -> bool {
+    "get-pox-rejection" == func_name
+        || "is-pox-active" == func_name
+        || "burn-height-to-reward-cycle" == func_name
+        || "reward-cycle-to-burn-height" == func_name
+        || "current-pox-reward-cycle" == func_name
+        || "get-stacker-info" == func_name
+        || "get-check-delegation" == func_name
+        || "get-reward-set-size" == func_name
+        || "next-cycle-rejection-votes" == func_name
+        || "get-total-ustx-stacked" == func_name
+        || "get-reward-set-pox-address" == func_name
+        || "get-stacking-minimum" == func_name
+        || "check-pox-addr-version" == func_name
+        || "check-pox-addr-hashbytes" == func_name
+        || "check-pox-lock-period" == func_name
+        || "can-stack-stx" == func_name
+        || "minimal-can-stack-stx" == func_name
+        || "get-pox-info" == func_name
+        || "get-delegation-info" == func_name
+        || "get-allowance-contract-callers" == func_name
+        || "get-num-reward-set-pox-addresses" == func_name
+        || "get-partial-stacked-by-cycle" == func_name
+        || "get-total-pox-rejection" == func_name
+}
+
 /// Lock up STX for PoX for a time.  Does NOT touch the account nonce.
 pub fn pox_lock_v3(
     db: &mut ClarityDatabase,
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 987ab35a4c..9193fb80f5 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -899,8 +899,14 @@ fn pox_3_defunct() {
     );
     burnchain.pox_constants = pox_constants.clone();
 
-    let (mut peer, keys) =
-        instantiate_pox_peer_with_epoch(&burnchain, function_name!(), Some(epochs.clone()), None);
+    let observer = TestEventObserver::new();
+
+    let (mut peer, keys) = instantiate_pox_peer_with_epoch(
+        &burnchain,
+        function_name!(),
+        Some(epochs.clone()),
+        Some(&observer),
+    );
 
     assert_eq!(burnchain.pox_constants.reward_slots(), 6);
     let mut coinbase_nonce = 0;
@@ -949,6 +955,28 @@ fn pox_3_defunct() {
     info!("Submitting stacking txs with pox3");
     latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
 
+    info!("Checking that stackers have no STX locked");
+    let balances = balances_from_keys(&mut peer, &latest_block, &keys);
+    assert_eq!(balances[0].amount_locked(), 0);
+    assert_eq!(balances[1].amount_locked(), 0);
+
+    info!("Checking tx receipts, all `pox3` calls should have returned `(err ...)`");
+    let last_observer_block = observer
+        .get_blocks()
+        .last()
+        .unwrap()
+        .clone();
+
+    let receipts = last_observer_block.receipts
+        .iter()
+        .filter(|receipt| match &receipt.result {
+            Value::Response(r) => !r.committed,
+            _ => false,
+        })
+        .collect::<Vec<_>>();
+
+    assert_eq!(receipts.len(), 4);
+
     // Advance to start of rewards cycle stackers are participating in
     let target_height = burnchain.pox_constants.pox_4_activation_height + 5;
     while get_tip(peer.sortdb.as_ref()).block_height < u64::from(target_height) {
@@ -985,8 +1013,7 @@ fn pox_3_defunct() {
     }
 }
 
-/// Test that we can lock STX for a couple cycles after pox4 starts,
-/// and that it unlocks after the desired number of cycles
+// Test that STX locked in pox3 automatically unlocks at `v3_unlock_height`
 #[test]
 fn pox_3_unlocks() {
     // Config for this test

From 18fafdd43ad943324f751c816805247c0cde6898 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 1 Dec 2023 09:00:16 -0500
Subject: [PATCH 0175/1166] Create a boot contract to initialize pre-pox-4
 aggregate key

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stackslib/src/chainstate/stacks/boot/mod.rs |  5 +++
 testnet/stacks-node/src/mockamoto.rs        | 46 +++++++++++++++++++--
 2 files changed, 47 insertions(+), 4 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 2f2cc637c7..2dfcef0b53 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -81,6 +81,11 @@ const POX_4_BODY: &'static str = std::include_str!("pox-4.clar");
 pub const COSTS_1_NAME: &'static str = "costs";
 pub const COSTS_2_NAME: &'static str = "costs-2";
 pub const COSTS_3_NAME: &'static str = "costs-3";
+/// This contract name is used in testnet **only** to lookup an initial
+///  setting for the pox-4 aggregate key. This contract should contain a `define-read-only`
+///  function called `aggregate-key` with zero arguments which returns a (buff 33)
+pub const BOOT_TEST_POX_4_AGG_KEY_CONTRACT: &'static str = "pox-4-agg-test-booter";
+pub const BOOT_TEST_POX_4_AGG_KEY_FNAME: &'static str = "aggregate-key";
 
 pub mod docs;
 
diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index 20bd7106b8..114f6c0418 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -5,8 +5,10 @@ use std::thread;
 use std::thread::{sleep, JoinHandle};
 use std::time::Duration;
 
+use clarity::boot_util::boot_code_id;
 use clarity::vm::ast::ASTRules;
-use clarity::vm::Value as ClarityValue;
+use clarity::vm::clarity::TransactionConnection;
+use clarity::vm::{ClarityVersion, Value as ClarityValue};
 use lazy_static::lazy_static;
 use stacks::burnchains::bitcoin::address::{
     BitcoinAddress, LegacyBitcoinAddress, LegacyBitcoinAddressType,
@@ -33,6 +35,9 @@ use stacks::chainstate::nakamoto::{
     NakamotoBlock, NakamotoBlockHeader, NakamotoChainState, SetupBlockResult,
 };
 use stacks::chainstate::stacks::address::PoxAddress;
+use stacks::chainstate::stacks::boot::{
+    BOOT_TEST_POX_4_AGG_KEY_CONTRACT, BOOT_TEST_POX_4_AGG_KEY_FNAME,
+};
 use stacks::chainstate::stacks::db::{ChainStateBootData, ClarityTx, StacksChainState};
 use stacks::chainstate::stacks::miner::{
     BlockBuilder, BlockBuilderSettings, BlockLimitFunction, MinerStatus, TransactionResult,
@@ -64,7 +69,7 @@ use stacks_common::types::chainstate::{
     StacksPrivateKey, VRFSeed,
 };
 use stacks_common::types::{PrivateKey, StacksEpochId};
-use stacks_common::util::hash::{Hash160, MerkleTree, Sha512Trunc256Sum};
+use stacks_common::util::hash::{to_hex, Hash160, MerkleTree, Sha512Trunc256Sum};
 use stacks_common::util::secp256k1::{MessageSignature, SchnorrSignature, Secp256k1PublicKey};
 use stacks_common::util::vrf::{VRFPrivateKey, VRFProof, VRFPublicKey, VRF};
 
@@ -405,7 +410,40 @@ impl MockamotoNode {
 
         initial_balances.push((stacker.into(), 100_000_000_000_000));
 
-        let mut boot_data = ChainStateBootData::new(&burnchain, initial_balances, None);
+        // Create a boot contract to initialize the aggregate public key prior to Pox-4 activation
+        let self_signer = SelfSigner::single_signer();
+        let agg_pub_key = to_hex(&self_signer.aggregate_public_key.compress().data);
+        info!("Mockamoto node setting agg public key"; "agg_pub_key" => &agg_pub_key);
+        let callback = move |clarity_tx: &mut ClarityTx| {
+            let contract_content = format!(
+                "(define-read-only ({}) 0x{})",
+                BOOT_TEST_POX_4_AGG_KEY_FNAME, agg_pub_key
+            );
+            let contract_id = boot_code_id(BOOT_TEST_POX_4_AGG_KEY_CONTRACT, false);
+            clarity_tx.connection().as_transaction(|clarity| {
+                let (ast, analysis) = clarity
+                    .analyze_smart_contract(
+                        &contract_id,
+                        ClarityVersion::Clarity2,
+                        &contract_content,
+                        ASTRules::PrecheckSize,
+                    )
+                    .unwrap();
+                clarity
+                    .initialize_smart_contract(
+                        &contract_id,
+                        ClarityVersion::Clarity2,
+                        &ast,
+                        &contract_content,
+                        None,
+                        |_, _| false,
+                    )
+                    .unwrap();
+                clarity.save_analysis(&contract_id, &analysis).unwrap();
+            })
+        };
+        let mut boot_data =
+            ChainStateBootData::new(&burnchain, initial_balances, Some(Box::new(callback)));
         let (chainstate, boot_receipts) = StacksChainState::open_and_exec(
             config.is_mainnet(),
             config.burnchain.chain_id,
@@ -446,7 +484,7 @@ impl MockamotoNode {
 
         Ok(MockamotoNode {
             sortdb,
-            self_signer: SelfSigner::single_signer(),
+            self_signer,
             chainstate,
             miner_key,
             vrf_key,

From f2772d22b29102e208dfa7259e48316ac591af52 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 1 Dec 2023 09:04:22 -0500
Subject: [PATCH 0176/1166] Retrieve boot contract init agg key and set all
 pre-pox-4 cycles to it

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stackslib/src/clarity_vm/clarity.rs | 75 +++++++++++++++++++++++++++--
 1 file changed, 71 insertions(+), 4 deletions(-)

diff --git a/stackslib/src/clarity_vm/clarity.rs b/stackslib/src/clarity_vm/clarity.rs
index aed3bb9947..59b5463d79 100644
--- a/stackslib/src/clarity_vm/clarity.rs
+++ b/stackslib/src/clarity_vm/clarity.rs
@@ -38,16 +38,17 @@ use clarity::vm::types::{
 use clarity::vm::{analysis, ast, ClarityVersion, ContractName};
 use stacks_common::consts::CHAIN_ID_TESTNET;
 use stacks_common::types::chainstate::{
-    BlockHeaderHash, BurnchainHeaderHash, SortitionId, StacksBlockId, TrieHash,
+    BlockHeaderHash, BurnchainHeaderHash, SortitionId, StacksAddress, StacksBlockId, TrieHash,
 };
 use stacks_common::util::secp256k1::MessageSignature;
 
 use crate::burnchains::{Burnchain, PoxConstants};
 use crate::chainstate::stacks::boot::{
     BOOT_CODE_COSTS, BOOT_CODE_COSTS_2, BOOT_CODE_COSTS_2_TESTNET, BOOT_CODE_COSTS_3,
-    BOOT_CODE_COST_VOTING_TESTNET as BOOT_CODE_COST_VOTING, BOOT_CODE_POX_TESTNET, COSTS_2_NAME,
-    COSTS_3_NAME, POX_2_MAINNET_CODE, POX_2_NAME, POX_2_TESTNET_CODE, POX_3_MAINNET_CODE,
-    POX_3_NAME, POX_3_TESTNET_CODE, POX_4_MAINNET_CODE, POX_4_NAME, POX_4_TESTNET_CODE,
+    BOOT_CODE_COST_VOTING_TESTNET as BOOT_CODE_COST_VOTING, BOOT_CODE_POX_TESTNET,
+    BOOT_TEST_POX_4_AGG_KEY_CONTRACT, BOOT_TEST_POX_4_AGG_KEY_FNAME, COSTS_2_NAME, COSTS_3_NAME,
+    POX_2_MAINNET_CODE, POX_2_NAME, POX_2_TESTNET_CODE, POX_3_MAINNET_CODE, POX_3_NAME,
+    POX_3_TESTNET_CODE, POX_4_MAINNET_CODE, POX_4_NAME, POX_4_TESTNET_CODE,
 };
 use crate::chainstate::stacks::db::{StacksAccount, StacksChainState};
 use crate::chainstate::stacks::events::{StacksTransactionEvent, StacksTransactionReceipt};
@@ -1343,6 +1344,32 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
             let pox_4_contract_tx =
                 StacksTransaction::new(tx_version.clone(), boot_code_auth.clone(), payload);
 
+            let initialized_agg_key = if !mainnet {
+                self.with_readonly_clarity_env(
+                    false,
+                    self.chain_id,
+                    ClarityVersion::Clarity2,
+                    StacksAddress::burn_address(false).into(),
+                    None,
+                    LimitedCostTracker::Free,
+                    |vm_env| {
+                        vm_env.execute_contract_allow_private(
+                            &boot_code_id(BOOT_TEST_POX_4_AGG_KEY_CONTRACT, false),
+                            BOOT_TEST_POX_4_AGG_KEY_FNAME,
+                            &[],
+                            true,
+                        )
+                    },
+                )
+                .ok()
+                .map(|agg_key_value| {
+                    Value::buff_from(agg_key_value.expect_buff(33))
+                        .expect("failed to reconstruct buffer")
+                })
+            } else {
+                None
+            };
+
             let pox_4_initialization_receipt = self.as_transaction(|tx_conn| {
                 // initialize with a synthetic transaction
                 debug!("Instantiate {} contract", &pox_4_contract_id);
@@ -1375,6 +1402,46 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
                     )
                     .expect("Failed to set burnchain parameters in PoX-3 contract");
 
+                // set the aggregate public key for all pre-pox-4 cycles, if in testnet, and can fetch a boot-setting
+                if !mainnet {
+                    if let Some(ref agg_pub_key) = initialized_agg_key {
+                        for set_in_reward_cycle in 0..pox_4_first_cycle {
+                            info!(
+                                "Setting initial aggregate-public-key in PoX-4";
+                                "agg_pub_key" => %agg_pub_key,
+                                "reward_cycle" => set_in_reward_cycle,
+                            );
+                            tx_conn
+                                .with_abort_callback(
+                                    |vm_env| {
+                                        vm_env.execute_in_env(
+                                            StacksAddress::burn_address(false).into(),
+                                            None,
+                                            None,
+                                            |env| {
+                                                env.execute_contract_allow_private(
+                                                    &pox_4_contract_id,
+                                                    "set-aggregate-public-key",
+                                                    &[
+                                                        SymbolicExpression::atom_value(
+                                                            Value::UInt(set_in_reward_cycle.into()),
+                                                        ),
+                                                        SymbolicExpression::atom_value(
+                                                            agg_pub_key.clone(),
+                                                        ),
+                                                    ],
+                                                    false,
+                                                )
+                                            },
+                                        )
+                                    },
+                                    |_, _| false,
+                                )
+                                .unwrap();
+                        }
+                    }
+                }
+
                 receipt
             });
 

From 949e0fd5be478251b0117551ed87881cea72bdca Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 1 Dec 2023 09:25:20 -0500
Subject: [PATCH 0177/1166] Only use the self_signer aggregate pub key for
 genesis blocks

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 testnet/stacks-node/src/mockamoto.rs | 23 ++++++++++++++++++++++-
 1 file changed, 22 insertions(+), 1 deletion(-)

diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index 114f6c0418..14f538ab4d 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -998,7 +998,28 @@ impl MockamotoNode {
         let config = self.chainstate.config();
         let chain_length = block.header.chain_length;
         let sortition_handle = self.sortdb.index_handle_at_tip();
-        let aggregate_public_key = self.self_signer.aggregate_public_key;
+        let aggregate_public_key = if chain_length <= 1 {
+            self.self_signer.aggregate_public_key
+        } else {
+            let block_sn = SortitionDB::get_block_snapshot_consensus(
+                sortition_handle.conn(),
+                &block.header.consensus_hash,
+            )?
+            .ok_or(ChainstateError::DBError(DBError::NotFoundError))?;
+            // TODO: https://github.com/stacks-network/stacks-core/issues/4109
+            // Update this to retrieve the last block in the last reward cycle rather than chain tip
+            let aggregate_key_block_header =
+                NakamotoChainState::get_canonical_block_header(self.chainstate.db(), &self.sortdb)?
+                    .unwrap();
+            let aggregate_public_key = NakamotoChainState::get_aggregate_public_key(
+                &self.sortdb,
+                &sortition_handle,
+                &mut self.chainstate,
+                block_sn.block_height,
+                &aggregate_key_block_header.index_block_hash(),
+            )?;
+            aggregate_public_key
+        };
         self.self_signer.sign_nakamoto_block(&mut block);
         let staging_tx = self.chainstate.staging_db_tx_begin()?;
         NakamotoChainState::accept_block(

From c2f3c5f5ba77ee9bf1598ac7bdc6adb9eb4466ed Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 1 Dec 2023 09:57:16 -0500
Subject: [PATCH 0178/1166] Set the aggregate public key for the NEXT reward
 cycle in every block

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 testnet/stacks-node/src/mockamoto.rs | 45 +++++++++++++++++++++++++++-
 1 file changed, 44 insertions(+), 1 deletion(-)

diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index 14f538ab4d..c3f9511ba1 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -904,7 +904,50 @@ impl MockamotoNode {
             parent_chain_length + 1,
         )?;
 
-        let txs = vec![tenure_tx, coinbase_tx, stacks_stx_tx];
+        // Set the aggregate public key for the NEXT reward cycle hence +1
+        let reward_cycle = self
+            .sortdb
+            .pox_constants
+            .block_height_to_reward_cycle(
+                self.sortdb.first_block_height,
+                sortition_tip.block_height,
+            )
+            .expect(
+                format!(
+                    "Failed to determine reward cycle of block height: {}",
+                    sortition_tip.block_height
+                )
+                .as_str(),
+            )
+            + 1;
+        let aggregate_payload = TransactionPayload::ContractCall(TransactionContractCall {
+            address: StacksAddress::burn_address(false),
+            contract_name: "pox-4".try_into().unwrap(),
+            function_name: "set-aggregate-public-key".try_into().unwrap(),
+            function_args: vec![
+                ClarityValue::UInt(u128::from(reward_cycle)),
+                ClarityValue::buff_from(
+                    self.self_signer
+                        .aggregate_public_key
+                        .compress()
+                        .data
+                        .to_vec(),
+                )
+                .expect("Failed to serialize aggregate public key"),
+            ],
+        });
+        let mut aggregate_tx: StacksTransaction = StacksTransaction::new(
+            TransactionVersion::Testnet,
+            TransactionAuth::from_p2pkh(&self.miner_key).unwrap(),
+            aggregate_payload,
+        );
+        aggregate_tx.chain_id = chain_id;
+        aggregate_tx.set_origin_nonce(miner_nonce + 3);
+        let mut aggregate_tx_signer = StacksTransactionSigner::new(&aggregate_tx);
+        aggregate_tx_signer.sign_origin(&self.miner_key).unwrap();
+        let aggregate_tx = aggregate_tx_signer.get_tx().unwrap();
+
+        let txs = vec![tenure_tx, coinbase_tx, stacks_stx_tx, aggregate_tx];
 
         let _ = match StacksChainState::process_block_transactions(
             &mut clarity_tx,

From ef6b7f4b18db94dd8751157a569955b3dcdf1eb7 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 1 Dec 2023 10:41:45 -0500
Subject: [PATCH 0179/1166] Cleanup mine_stacks_block by pulling transaction
 construction into sep functions

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 testnet/stacks-node/src/mockamoto.rs | 270 +++++++++++++++------------
 1 file changed, 150 insertions(+), 120 deletions(-)

diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index c3f9511ba1..dee2af6049 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -36,7 +36,7 @@ use stacks::chainstate::nakamoto::{
 };
 use stacks::chainstate::stacks::address::PoxAddress;
 use stacks::chainstate::stacks::boot::{
-    BOOT_TEST_POX_4_AGG_KEY_CONTRACT, BOOT_TEST_POX_4_AGG_KEY_FNAME,
+    BOOT_TEST_POX_4_AGG_KEY_CONTRACT, BOOT_TEST_POX_4_AGG_KEY_FNAME, POX_4_NAME,
 };
 use stacks::chainstate::stacks::db::{ChainStateBootData, ClarityTx, StacksChainState};
 use stacks::chainstate::stacks::miner::{
@@ -72,6 +72,7 @@ use stacks_common::types::{PrivateKey, StacksEpochId};
 use stacks_common::util::hash::{to_hex, Hash160, MerkleTree, Sha512Trunc256Sum};
 use stacks_common::util::secp256k1::{MessageSignature, SchnorrSignature, Secp256k1PublicKey};
 use stacks_common::util::vrf::{VRFPrivateKey, VRFProof, VRFPublicKey, VRF};
+use wsts::curve::point::Point;
 
 use self::signer::SelfSigner;
 use crate::neon::Counters;
@@ -800,86 +801,46 @@ impl MockamotoNode {
             "chain_tip_ch" => %chain_tip_ch, "miner_account" => %miner_principal, "miner_nonce" => %miner_nonce,
         );
 
-        let vrf_proof = VRF::prove(&self.vrf_key, sortition_tip.sortition_hash.as_bytes());
-        let coinbase_tx_payload =
-            TransactionPayload::Coinbase(CoinbasePayload([1; 32]), None, Some(vrf_proof));
-        let mut coinbase_tx = StacksTransaction::new(
-            TransactionVersion::Testnet,
-            TransactionAuth::from_p2pkh(&self.miner_key).unwrap(),
-            coinbase_tx_payload,
-        );
-        coinbase_tx.chain_id = chain_id;
-        coinbase_tx.set_origin_nonce(miner_nonce + 1);
-        let mut coinbase_tx_signer = StacksTransactionSigner::new(&coinbase_tx);
-        coinbase_tx_signer.sign_origin(&self.miner_key).unwrap();
-        let coinbase_tx = coinbase_tx_signer.get_tx().unwrap();
-
         // Add a tenure change transaction to the block:
         //  as of now every mockamoto block is a tenure-change.
         // If mockamoto mode changes to support non-tenure-changing blocks, this will have
         //  to be gated.
-        let tenure_change_tx_payload = TransactionPayload::TenureChange(
-            TenureChangePayload {
-                previous_tenure_end: parent_block_id,
-                previous_tenure_blocks: 1,
-                cause: TenureChangeCause::BlockFound,
-                pubkey_hash: Hash160([0; 20]),
-
-                signers: vec![],
-            },
-            ThresholdSignature::mock(),
-        );
-        let mut tenure_tx = StacksTransaction::new(
-            TransactionVersion::Testnet,
-            TransactionAuth::from_p2pkh(&self.miner_key).unwrap(),
-            tenure_change_tx_payload,
-        );
-        tenure_tx.chain_id = chain_id;
-        tenure_tx.set_origin_nonce(miner_nonce);
-        let mut tenure_tx_signer = StacksTransactionSigner::new(&tenure_tx);
-        tenure_tx_signer.sign_origin(&self.miner_key).unwrap();
-        let tenure_tx = tenure_tx_signer.get_tx().unwrap();
-
-        let pox_address = PoxAddress::Standard(
-            StacksAddress::burn_address(false),
-            Some(AddressHashMode::SerializeP2PKH),
+        let tenure_tx =
+            make_tenure_change_tx(&self.miner_key, miner_nonce, chain_id, parent_block_id);
+        let vrf_proof = VRF::prove(&self.vrf_key, sortition_tip.sortition_hash.as_bytes());
+        let coinbase_tx =
+            make_coinbase_tx(&self.miner_key, miner_nonce + 1, chain_id, Some(vrf_proof));
+        let stacks_stx_tx = make_stacks_stx_tx(
+            &self.miner_key,
+            miner_nonce + 2,
+            chain_id,
+            parent_chain_length,
+            parent_burn_height,
         );
-
-        let stack_stx_payload = if parent_chain_length < 2 {
-            TransactionPayload::ContractCall(TransactionContractCall {
-                address: StacksAddress::burn_address(false),
-                contract_name: "pox-4".try_into().unwrap(),
-                function_name: "stack-stx".try_into().unwrap(),
-                function_args: vec![
-                    ClarityValue::UInt(99_000_000_000_000),
-                    pox_address.as_clarity_tuple().unwrap().into(),
-                    ClarityValue::UInt(u128::from(parent_burn_height)),
-                    ClarityValue::UInt(12),
-                ],
-            })
-        } else {
-            // NOTE: stack-extend doesn't currently work, because the PoX-4 lockup
-            //  special functions have not been implemented.
-            TransactionPayload::ContractCall(TransactionContractCall {
-                address: StacksAddress::burn_address(false),
-                contract_name: "pox-4".try_into().unwrap(),
-                function_name: "stack-extend".try_into().unwrap(),
-                function_args: vec![
-                    ClarityValue::UInt(5),
-                    pox_address.as_clarity_tuple().unwrap().into(),
-                ],
-            })
-        };
-        let mut stack_stx_tx = StacksTransaction::new(
-            TransactionVersion::Testnet,
-            TransactionAuth::from_p2pkh(&self.miner_key).unwrap(),
-            stack_stx_payload,
+        // Set the aggregate public key for the NEXT reward cycle hence +1
+        let reward_cycle = self
+            .sortdb
+            .pox_constants
+            .block_height_to_reward_cycle(
+                self.sortdb.first_block_height,
+                sortition_tip.block_height,
+            )
+            .expect(
+                format!(
+                    "Failed to determine reward cycle of block height: {}",
+                    sortition_tip.block_height
+                )
+                .as_str(),
+            )
+            + 1;
+        let aggregate_tx = make_aggregate_tx(
+            &self.miner_key,
+            miner_nonce + 3,
+            chain_id,
+            &self.self_signer.aggregate_public_key,
+            reward_cycle,
         );
-        stack_stx_tx.chain_id = chain_id;
-        stack_stx_tx.set_origin_nonce(miner_nonce + 2);
-        let mut stack_stx_tx_signer = StacksTransactionSigner::new(&stack_stx_tx);
-        stack_stx_tx_signer.sign_origin(&self.miner_key).unwrap();
-        let stacks_stx_tx = stack_stx_tx_signer.get_tx().unwrap();
+        let txs = vec![tenure_tx, coinbase_tx, stacks_stx_tx, aggregate_tx];
 
         let sortdb_handle = self.sortdb.index_conn();
         let SetupBlockResult {
@@ -904,51 +865,6 @@ impl MockamotoNode {
             parent_chain_length + 1,
         )?;
 
-        // Set the aggregate public key for the NEXT reward cycle hence +1
-        let reward_cycle = self
-            .sortdb
-            .pox_constants
-            .block_height_to_reward_cycle(
-                self.sortdb.first_block_height,
-                sortition_tip.block_height,
-            )
-            .expect(
-                format!(
-                    "Failed to determine reward cycle of block height: {}",
-                    sortition_tip.block_height
-                )
-                .as_str(),
-            )
-            + 1;
-        let aggregate_payload = TransactionPayload::ContractCall(TransactionContractCall {
-            address: StacksAddress::burn_address(false),
-            contract_name: "pox-4".try_into().unwrap(),
-            function_name: "set-aggregate-public-key".try_into().unwrap(),
-            function_args: vec![
-                ClarityValue::UInt(u128::from(reward_cycle)),
-                ClarityValue::buff_from(
-                    self.self_signer
-                        .aggregate_public_key
-                        .compress()
-                        .data
-                        .to_vec(),
-                )
-                .expect("Failed to serialize aggregate public key"),
-            ],
-        });
-        let mut aggregate_tx: StacksTransaction = StacksTransaction::new(
-            TransactionVersion::Testnet,
-            TransactionAuth::from_p2pkh(&self.miner_key).unwrap(),
-            aggregate_payload,
-        );
-        aggregate_tx.chain_id = chain_id;
-        aggregate_tx.set_origin_nonce(miner_nonce + 3);
-        let mut aggregate_tx_signer = StacksTransactionSigner::new(&aggregate_tx);
-        aggregate_tx_signer.sign_origin(&self.miner_key).unwrap();
-        let aggregate_tx = aggregate_tx_signer.get_tx().unwrap();
-
-        let txs = vec![tenure_tx, coinbase_tx, stacks_stx_tx, aggregate_tx];
-
         let _ = match StacksChainState::process_block_transactions(
             &mut clarity_tx,
             &txs,
@@ -1076,3 +992,117 @@ impl MockamotoNode {
         Ok(chain_length)
     }
 }
+
+// Helper function to make a signed tenure change transaction
+fn make_tenure_change_tx(
+    key: &StacksPrivateKey,
+    miner_nonce: u64,
+    chain_id: u32,
+    parent_block_id: StacksBlockId,
+) -> StacksTransaction {
+    let tenure_change_tx_payload = TransactionPayload::TenureChange(
+        TenureChangePayload {
+            previous_tenure_end: parent_block_id,
+            previous_tenure_blocks: 1,
+            cause: TenureChangeCause::BlockFound,
+            pubkey_hash: Hash160([0; 20]),
+            signers: vec![],
+        },
+        ThresholdSignature::mock(),
+    );
+    make_tx(key, miner_nonce, tenure_change_tx_payload, chain_id)
+}
+
+// Helper function to make a signed coinbase transaction
+fn make_coinbase_tx(
+    key: &StacksPrivateKey,
+    miner_nonce: u64,
+    chain_id: u32,
+    vrf_proof: Option<VRFProof>,
+) -> StacksTransaction {
+    let coinbase_tx_payload =
+        TransactionPayload::Coinbase(CoinbasePayload([1; 32]), None, vrf_proof);
+    make_tx(key, miner_nonce, coinbase_tx_payload, chain_id)
+}
+
+// Helper function to make a signed stacks-stx transaction
+fn make_stacks_stx_tx(
+    key: &StacksPrivateKey,
+    miner_nonce: u64,
+    chain_id: u32,
+    parent_chain_length: u64,
+    parent_burn_height: u32,
+) -> StacksTransaction {
+    let pox_address = PoxAddress::Standard(
+        StacksAddress::burn_address(false),
+        Some(AddressHashMode::SerializeP2PKH),
+    );
+
+    let stack_stx_payload = if parent_chain_length < 2 {
+        TransactionPayload::ContractCall(TransactionContractCall {
+            address: StacksAddress::burn_address(false),
+            contract_name: POX_4_NAME.into(),
+            function_name: "stack-stx".try_into().unwrap(),
+            function_args: vec![
+                ClarityValue::UInt(99_000_000_000_000),
+                pox_address.as_clarity_tuple().unwrap().into(),
+                ClarityValue::UInt(u128::from(parent_burn_height)),
+                ClarityValue::UInt(12),
+            ],
+        })
+    } else {
+        // NOTE: stack-extend doesn't currently work, because the PoX-4 lockup
+        //  special functions have not been implemented.
+        TransactionPayload::ContractCall(TransactionContractCall {
+            address: StacksAddress::burn_address(false),
+            contract_name: POX_4_NAME.into(),
+            function_name: "stack-extend".try_into().unwrap(),
+            function_args: vec![
+                ClarityValue::UInt(5),
+                pox_address.as_clarity_tuple().unwrap().into(),
+            ],
+        })
+    };
+    make_tx(key, miner_nonce, stack_stx_payload, chain_id)
+}
+
+/// Helper function to make a set-aggregate-public-key transaction
+fn make_aggregate_tx(
+    key: &StacksPrivateKey,
+    nonce: u64,
+    chain_id: u32,
+    aggregate_public_key: &Point,
+    reward_cycle: u64,
+) -> StacksTransaction {
+    let aggregate_payload = TransactionPayload::ContractCall(TransactionContractCall {
+        address: StacksAddress::burn_address(false),
+        contract_name: POX_4_NAME.into(),
+        function_name: "set-aggregate-public-key".try_into().unwrap(),
+        function_args: vec![
+            ClarityValue::UInt(u128::from(reward_cycle)),
+            ClarityValue::buff_from(aggregate_public_key.compress().data.to_vec())
+                .expect("Failed to serialize aggregate public key"),
+        ],
+    });
+    make_tx(&key, nonce, aggregate_payload, chain_id)
+}
+
+/// Helper function to create a zero fee transaction
+/// TODO: this is duplicated in so many places. We should have a utils fn for this
+fn make_tx(
+    key: &StacksPrivateKey,
+    nonce: u64,
+    tx_payload: TransactionPayload,
+    chain_id: u32,
+) -> StacksTransaction {
+    let mut tx = StacksTransaction::new(
+        TransactionVersion::Testnet,
+        TransactionAuth::from_p2pkh(&key).unwrap(),
+        tx_payload,
+    );
+    tx.chain_id = chain_id;
+    tx.set_origin_nonce(nonce);
+    let mut tx_signer = StacksTransactionSigner::new(&tx);
+    tx_signer.sign_origin(&key).unwrap();
+    tx_signer.get_tx().unwrap()
+}

From e9f99740bc91e460697ece110f7fab74946caefb Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Mon, 4 Dec 2023 10:38:44 -0500
Subject: [PATCH 0180/1166] CRC: add test to set and get the aggregate public
 key

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 testnet/stacks-node/src/mockamoto/tests.rs | 166 ++++++++++++++++++++-
 1 file changed, 164 insertions(+), 2 deletions(-)

diff --git a/testnet/stacks-node/src/mockamoto/tests.rs b/testnet/stacks-node/src/mockamoto/tests.rs
index 99c7d34cc8..a1f3785111 100644
--- a/testnet/stacks-node/src/mockamoto/tests.rs
+++ b/testnet/stacks-node/src/mockamoto/tests.rs
@@ -1,18 +1,25 @@
 use std::thread;
 use std::time::{Duration, Instant};
 
+use clarity::boot_util::boot_code_addr;
 use clarity::vm::costs::ExecutionCost;
+use clarity::vm::Value;
+use rand_core::OsRng;
+use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::nakamoto::NakamotoChainState;
+use stacks::chainstate::stacks::boot::POX_4_NAME;
 use stacks::chainstate::stacks::db::StacksChainState;
 use stacks_common::types::chainstate::{StacksAddress, StacksPrivateKey};
 use stacks_common::types::StacksEpochId;
 use stacks_common::util::hash::to_hex;
+use wsts::curve::point::Point;
+use wsts::curve::scalar::Scalar;
 
 use super::MockamotoNode;
 use crate::config::{EventKeyType, EventObserverConfig};
 use crate::neon_node::PeerThread;
 use crate::tests::neon_integrations::{submit_tx, test_observer};
-use crate::tests::{make_stacks_transfer, to_addr};
+use crate::tests::{make_contract_call, make_stacks_transfer, to_addr};
 use crate::{Config, ConfigFile};
 
 #[test]
@@ -54,7 +61,8 @@ fn observe_100_blocks() {
         .expect("FATAL: failed to start mockamoto main thread");
 
     // make a transfer tx to test that the mockamoto miner picks up txs from the mempool
-    let transfer_tx = make_stacks_transfer(&submitter_sk, 0, 10, &recipient_addr, 100);
+    let tx_fee = 200;
+    let transfer_tx = make_stacks_transfer(&submitter_sk, 0, tx_fee, &recipient_addr, 100);
     let transfer_tx_hex = format!("0x{}", to_hex(&transfer_tx));
 
     // complete within 2 minutes or abort
@@ -122,6 +130,160 @@ fn observe_100_blocks() {
         .expect("Failed to join node thread to exit");
 }
 
+#[test]
+fn observe_set_aggregate_tx() {
+    let mut conf = Config::from_config_file(ConfigFile::mockamoto()).unwrap();
+    conf.node.mockamoto_time_ms = 10;
+
+    let submitter_sk = StacksPrivateKey::from_seed(&[1]);
+    let submitter_addr = to_addr(&submitter_sk);
+    conf.add_initial_balance(submitter_addr.to_string(), 1_000);
+
+    test_observer::spawn();
+    let observer_port = test_observer::EVENT_OBSERVER_PORT;
+    conf.events_observers.insert(EventObserverConfig {
+        endpoint: format!("localhost:{observer_port}"),
+        events_keys: vec![EventKeyType::AnyEvent],
+    });
+
+    let mut mockamoto = MockamotoNode::new(&conf).unwrap();
+
+    let globals = mockamoto.globals.clone();
+
+    let mut mempool = PeerThread::connect_mempool_db(&conf);
+    let (mut chainstate, _) = StacksChainState::open(
+        conf.is_mainnet(),
+        conf.burnchain.chain_id,
+        &conf.get_chainstate_path_str(),
+        None,
+    )
+    .unwrap();
+    let burnchain = conf.get_burnchain();
+    let sortdb = burnchain.open_sortition_db(true).unwrap();
+    let sortition_tip = SortitionDB::get_canonical_burn_chain_tip(mockamoto.sortdb.conn()).unwrap();
+
+    let start = Instant::now();
+    // Get a reward cycle to compare against
+    let reward_cycle = mockamoto
+        .sortdb
+        .pox_constants
+        .block_height_to_reward_cycle(
+            mockamoto.sortdb.first_block_height,
+            sortition_tip.block_height,
+        )
+        .expect(
+            format!(
+                "Failed to determine reward cycle of block height: {}",
+                sortition_tip.block_height
+            )
+            .as_str(),
+        );
+
+    let node_thread = thread::Builder::new()
+        .name("mockamoto-main".into())
+        .spawn(move || {
+            mockamoto.run();
+            let aggregate_key_block_header = NakamotoChainState::get_canonical_block_header(
+                mockamoto.chainstate.db(),
+                &mockamoto.sortdb,
+            )
+            .unwrap()
+            .unwrap();
+            // Get the aggregate public key to later verify that it was set correctly
+            mockamoto
+                .chainstate
+                .get_aggregate_public_key_pox_4(
+                    &mockamoto.sortdb,
+                    &aggregate_key_block_header.index_block_hash(),
+                    reward_cycle,
+                )
+                .unwrap()
+        })
+        .expect("FATAL: failed to start mockamoto main thread");
+
+    // Create a "set-aggregate-public-key" tx to verify it sets correctly
+    let mut rng = OsRng::default();
+    let x = Scalar::random(&mut rng);
+    let random_key = Point::from(x);
+
+    let tx_fee = 200;
+    let aggregate_public_key = Value::buff_from(random_key.compress().data.to_vec())
+        .expect("Failed to serialize aggregate public key");
+    let aggregate_tx = make_contract_call(
+        &submitter_sk,
+        0,
+        tx_fee,
+        &boot_code_addr(false),
+        POX_4_NAME,
+        "set-aggregate-public-key",
+        &[Value::UInt(u128::from(reward_cycle)), aggregate_public_key],
+    );
+    let aggregate_tx_hex = format!("0x{}", to_hex(&aggregate_tx));
+
+    // complete within 5 seconds or abort (we are only observing one block)
+    let completed = loop {
+        if Instant::now().duration_since(start) > Duration::from_secs(5) {
+            break false;
+        }
+        let latest_block = test_observer::get_blocks().pop();
+        thread::sleep(Duration::from_secs(1));
+        let Some(ref latest_block) = latest_block else {
+            info!("No block observed yet!");
+            continue;
+        };
+        let stacks_block_height = latest_block.get("block_height").unwrap().as_u64().unwrap();
+        info!("Block height observed: {stacks_block_height}");
+
+        // Submit the aggregate tx for processing to update the aggregate public key
+        let tip = NakamotoChainState::get_canonical_block_header(chainstate.db(), &sortdb)
+            .unwrap()
+            .unwrap();
+        mempool
+            .submit_raw(
+                &mut chainstate,
+                &sortdb,
+                &tip.consensus_hash,
+                &tip.anchored_header.block_hash(),
+                aggregate_tx.clone(),
+                &ExecutionCost::max_value(),
+                &StacksEpochId::Epoch30,
+            )
+            .unwrap();
+        break true;
+    };
+
+    globals.signal_stop();
+
+    let aggregate_key = node_thread
+        .join()
+        .expect("Failed to join node thread to exit");
+
+    // Did we set and retrieve the aggregate key correctly?
+    assert_eq!(aggregate_key.unwrap(), random_key);
+
+    let aggregate_tx_included = test_observer::get_blocks()
+        .into_iter()
+        .find(|block_json| {
+            block_json["transactions"]
+                .as_array()
+                .unwrap()
+                .iter()
+                .find(|tx_json| tx_json["raw_tx"].as_str() == Some(&aggregate_tx_hex))
+                .is_some()
+        })
+        .is_some();
+
+    assert!(
+        aggregate_tx_included,
+        "Mockamoto node failed to include the aggregate tx"
+    );
+
+    assert!(
+        completed,
+        "Mockamoto node failed to produce and announce its block before timeout"
+    );
+}
+
 #[test]
 fn mempool_rpc_submit() {
     let mut conf = Config::from_config_file(ConfigFile::mockamoto()).unwrap();

From 76eea0a0865e76ca52fd1d65669bedc86af5e49e Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Mon, 4 Dec 2023 16:59:00 -0500
Subject: [PATCH 0181/1166] CRC: check that the initial aggregate key was set
 correctly

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 testnet/stacks-node/src/mockamoto/tests.rs | 34 ++++++++++++++++------
 1 file changed, 25 insertions(+), 9 deletions(-)

diff --git a/testnet/stacks-node/src/mockamoto/tests.rs b/testnet/stacks-node/src/mockamoto/tests.rs
index a1f3785111..38e4976f14 100644
--- a/testnet/stacks-node/src/mockamoto/tests.rs
+++ b/testnet/stacks-node/src/mockamoto/tests.rs
@@ -147,6 +147,8 @@ fn observe_set_aggregate_tx() {
     });
 
     let mut mockamoto = MockamotoNode::new(&conf).unwrap();
+    // Get the aggregate public key of the original reward cycle to compare against
+    let orig_key = mockamoto.self_signer.aggregate_public_key;
 
     let globals = mockamoto.globals.clone();
 
@@ -163,7 +165,7 @@ fn observe_set_aggregate_tx() {
     let sortition_tip = SortitionDB::get_canonical_burn_chain_tip(mockamoto.sortdb.conn()).unwrap();
 
     let start = Instant::now();
-    // Get a reward cycle to compare against
+    // Get the reward cycle of the sortition tip
     let reward_cycle = mockamoto
         .sortdb
         .pox_constants
@@ -189,15 +191,25 @@ fn observe_set_aggregate_tx() {
             )
             .unwrap()
             .unwrap();
-            // Get the aggregate public key to later verify that it was set correctly
-            mockamoto
+            // Get the aggregate public key of the original reward cycle
+            let orig_aggregate_key = mockamoto
                 .chainstate
                 .get_aggregate_public_key_pox_4(
                     &mockamoto.sortdb,
                     &aggregate_key_block_header.index_block_hash(),
                     reward_cycle,
                 )
-                .unwrap()
+                .unwrap();
+            // Get the aggregate public key of the next reward cycle that we manually overwrote
+            let new_aggregate_key = mockamoto
+                .chainstate
+                .get_aggregate_public_key_pox_4(
+                    &mockamoto.sortdb,
+                    &aggregate_key_block_header.index_block_hash(),
+                    reward_cycle + 1,
+                )
+                .unwrap();
+            (orig_aggregate_key, new_aggregate_key)
         })
         .expect("FATAL: failed to start mockamoto main thread");
 
@@ -216,7 +228,10 @@ fn observe_set_aggregate_tx() {
         &boot_code_addr(false),
         POX_4_NAME,
         "set-aggregate-public-key",
-        &[Value::UInt(u128::from(reward_cycle)), aggregate_public_key],
+        &[
+            Value::UInt(u128::from(reward_cycle + 1)),
+            aggregate_public_key,
+        ],
     );
     let aggregate_tx_hex = format!("0x{}", to_hex(&aggregate_tx));
 
@@ -254,13 +269,10 @@ fn observe_set_aggregate_tx() {
 
     globals.signal_stop();
 
-    let aggregate_key = node_thread
+    let (orig_aggregate_key, new_aggregate_key) = node_thread
         .join()
         .expect("Failed to join node thread to exit");
 
-    // Did we set and retrieve the aggregate key correctly?
-    assert_eq!(aggregate_key.unwrap(), random_key);
-
     let aggregate_tx_included = test_observer::get_blocks()
         .into_iter()
         .find(|block_json| {
@@ -282,6 +294,10 @@ fn observe_set_aggregate_tx() {
         completed,
         "Mockamoto node failed to produce and announce its block before timeout"
     );
+
+    // Did we set and retrieve the aggregate key correctly?
+    assert_eq!(orig_aggregate_key.unwrap(), orig_key);
+    assert_eq!(new_aggregate_key.unwrap(), random_key);
 }
 
 #[test]

From 96911d0b39e3dea15ca96528c66e72df6c8d04f9 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Mon, 11 Dec 2023 19:45:06 -0500
Subject: [PATCH 0182/1166] Make sure thread exits before looking for transfer
 tx

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 testnet/stacks-node/src/mockamoto/tests.rs | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/testnet/stacks-node/src/mockamoto/tests.rs b/testnet/stacks-node/src/mockamoto/tests.rs
index 38e4976f14..a93cd887a9 100644
--- a/testnet/stacks-node/src/mockamoto/tests.rs
+++ b/testnet/stacks-node/src/mockamoto/tests.rs
@@ -104,6 +104,10 @@ fn observe_100_blocks() {
 
     globals.signal_stop();
 
+    node_thread
+        .join()
+        .expect("Failed to join node thread to exit");
+
     let transfer_tx_included = test_observer::get_blocks()
         .into_iter()
         .find(|block_json| {
@@ -125,9 +129,6 @@ fn observe_100_blocks() {
         completed,
         "Mockamoto node failed to produce and announce 100 blocks before timeout"
     );
-    node_thread
-        .join()
-        .expect("Failed to join node thread to exit");
 }
 
 #[test]
@@ -360,6 +361,10 @@ fn mempool_rpc_submit() {
 
     globals.signal_stop();
 
+    node_thread
+        .join()
+        .expect("Failed to join node thread to exit");
+
     let transfer_tx_included = test_observer::get_blocks()
         .into_iter()
         .find(|block_json| {
@@ -381,7 +386,4 @@ fn mempool_rpc_submit() {
         completed,
         "Mockamoto node failed to produce and announce 100 blocks before timeout"
     );
-    node_thread
-        .join()
-        .expect("Failed to join node thread to exit");
 }

From b747597645b989f73f5fceb1a2b0846c123206c2 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Mon, 11 Dec 2023 22:43:29 -0500
Subject: [PATCH 0183/1166] Address PR comments in `pox_3_defunct()`

---
 .../src/chainstate/stacks/boot/pox_4_tests.rs   | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 9193fb80f5..5e42e1bd54 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -960,14 +960,11 @@ fn pox_3_defunct() {
     assert_eq!(balances[0].amount_locked(), 0);
     assert_eq!(balances[1].amount_locked(), 0);
 
-    info!("Checking tx receipts, all `pox3` calls should have returned `(err ...)`");
-    let last_observer_block = observer
-        .get_blocks()
-        .last()
-        .unwrap()
-        .clone();
+    info!("Checking tx receipts, all `pox3` calls should have returned `(err none)`");
+    let last_observer_block = observer.get_blocks().last().unwrap().clone();
 
-    let receipts = last_observer_block.receipts
+    let receipts = last_observer_block
+        .receipts
         .iter()
         .filter(|receipt| match &receipt.result {
             Value::Response(r) => !r.committed,
@@ -975,7 +972,11 @@ fn pox_3_defunct() {
         })
         .collect::<Vec<_>>();
 
-    assert_eq!(receipts.len(), 4);
+    assert_eq!(receipts.len(), txs.len());
+    for r in receipts.iter() {
+        let err = r.result.clone().expect_result_err().expect_optional();
+        assert!(err.is_none());
+    }
 
     // Advance to start of rewards cycle stackers are participating in
     let target_height = burnchain.pox_constants.pox_4_activation_height + 5;

From dcd522fc813c19a1f903118c19905d320f2a8107 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Mon, 4 Dec 2023 16:21:33 -0600
Subject: [PATCH 0184/1166] feat: add nakamoto_node, nakamoto-neon mode

* Refactor some of the reused structs from `neon_node`
* Fix a logic-bug in `nakamoto::coordinator`: the first prepare phase information will be a Epoch2x block, so the reward set calculation has to handle that.
* Add `nakamoto_node` module based on `neon_node`
* Add simple integration test for `nakamoto_node`
---
 .../chainstate/nakamoto/coordinator/mod.rs    |   40 +-
 stackslib/src/chainstate/nakamoto/miner.rs    |    8 +-
 stackslib/src/chainstate/stacks/miner.rs      |   17 +-
 .../burnchains/bitcoin_regtest_controller.rs  |    9 +-
 testnet/stacks-node/src/config.rs             |   17 +-
 testnet/stacks-node/src/globals.rs            |  266 +++++
 testnet/stacks-node/src/keychain.rs           |   24 +-
 testnet/stacks-node/src/main.rs               |    6 +
 testnet/stacks-node/src/mockamoto.rs          |    8 +-
 testnet/stacks-node/src/nakamoto_node.rs      |  683 +++++++++++
 .../stacks-node/src/nakamoto_node/miner.rs    |  645 +++++++++++
 testnet/stacks-node/src/nakamoto_node/peer.rs |  418 +++++++
 .../stacks-node/src/nakamoto_node/relayer.rs  |  961 +++++++++++++++
 testnet/stacks-node/src/neon_node.rs          |  266 +----
 testnet/stacks-node/src/run_loop/mod.rs       |    1 +
 testnet/stacks-node/src/run_loop/nakamoto.rs  | 1029 +++++++++++++++++
 testnet/stacks-node/src/run_loop/neon.rs      |   55 +-
 .../stacks-node/src/tests/bitcoin_regtest.rs  |    1 +
 testnet/stacks-node/src/tests/mod.rs          |    1 +
 .../src/tests/nakamoto_integrations.rs        |  322 ++++++
 .../src/tests/neon_integrations.rs            |    4 +-
 21 files changed, 4480 insertions(+), 301 deletions(-)
 create mode 100644 testnet/stacks-node/src/globals.rs
 create mode 100644 testnet/stacks-node/src/nakamoto_node.rs
 create mode 100644 testnet/stacks-node/src/nakamoto_node/miner.rs
 create mode 100644 testnet/stacks-node/src/nakamoto_node/peer.rs
 create mode 100644 testnet/stacks-node/src/nakamoto_node/relayer.rs
 create mode 100644 testnet/stacks-node/src/run_loop/nakamoto.rs
 create mode 100644 testnet/stacks-node/src/tests/nakamoto_integrations.rs

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
index 462662d4d9..6dde267bc2 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
@@ -169,7 +169,7 @@ pub fn get_nakamoto_reward_cycle_info<U: RewardSetProvider>(
         .epoch_id;
 
     assert!(
-        epoch_at_height >= StacksEpochId::Epoch30,
+        epoch_at_height >= StacksEpochId::Epoch25,
         "FATAL: called a nakamoto function outside of epoch 3"
     );
 
@@ -216,22 +216,40 @@ pub fn get_nakamoto_reward_cycle_info<U: RewardSetProvider>(
         }
 
         // find the first Stacks block processed in the prepare phase
-        let Some(prepare_start_block_header) =
+        let parent_block_id = if let Some(nakamoto_start_block) =
             NakamotoChainState::get_nakamoto_tenure_start_block_header(
                 chain_state.db(),
                 &sn.consensus_hash,
+            )? {
+            nakamoto_start_block
+                .anchored_header
+                .as_stacks_nakamoto()
+                // TODO: maybe `get_nakamoto_tenure_start_block_header` should
+                //       return a type that doesn't require this unwrapping?
+                .expect("FATAL: queried non-Nakamoto tenure start header")
+                .parent_block_id
+        } else {
+            let Some(block_header) =
+                StacksChainState::get_stacks_block_header_info_by_consensus_hash(
+                    chain_state.db(),
+                    &sn.consensus_hash,
+                )?
+            else {
+                // no header for this snapshot (possibly invalid)
+                debug!("Failed to find block by consensus hash"; "consensus_hash" => %sn.consensus_hash);
+                continue;
+            };
+            let Some(parent_block_id) = StacksChainState::get_parent_block_id(
+                chain_state.db(),
+                &block_header.index_block_hash(),
             )?
-        else {
-            // no header for this snapshot (possibly invalid)
-            continue;
+            else {
+                debug!("Failed to get parent block"; "block_id" => %block_header.index_block_hash());
+                continue;
+            };
+            parent_block_id
         };
 
-        let parent_block_id = &prepare_start_block_header
-            .anchored_header
-            .as_stacks_nakamoto()
-            .expect("FATAL: queried non-Nakamoto tenure start header")
-            .parent_block_id;
-
         // find the tenure-start block of the tenure of the parent of this Stacks block.
         // in epoch 2, this is the preceding anchor block
         // in nakamoto, this is the tenure-start block of the preceding tenure
diff --git a/stackslib/src/chainstate/nakamoto/miner.rs b/stackslib/src/chainstate/nakamoto/miner.rs
index 82b6d34b93..1f75cd55ac 100644
--- a/stackslib/src/chainstate/nakamoto/miner.rs
+++ b/stackslib/src/chainstate/nakamoto/miner.rs
@@ -498,7 +498,7 @@ impl NakamotoBlockBuilder {
             state_root_hash
         );
 
-        info!(
+        debug!(
             "Miner: mined Nakamoto block";
             "consensus_hash" => %block.header.consensus_hash,
             "block_hash" => %block.header.block_hash(),
@@ -570,13 +570,15 @@ impl NakamotoBlockBuilder {
             .block_limit()
             .expect("Failed to obtain block limit from miner's block connection");
 
+        let initial_txs: Vec<_> = 
+            [new_tenure_info.tenure_change_tx.cloned(),
+             new_tenure_info.coinbase_tx.cloned()].into_iter().filter_map(|x| x).collect();
         let (blocked, tx_events) = match StacksBlockBuilder::select_and_apply_transactions(
             &mut tenure_tx,
             &mut builder,
             mempool,
             parent_stacks_header.stacks_block_height,
-            tenure_info.tenure_change_tx(),
-            tenure_info.coinbase_tx(),
+            &initial_txs,
             settings,
             event_observer,
             ASTRules::PrecheckSize,
diff --git a/stackslib/src/chainstate/stacks/miner.rs b/stackslib/src/chainstate/stacks/miner.rs
index a9cfacf929..3eb1ea36cc 100644
--- a/stackslib/src/chainstate/stacks/miner.rs
+++ b/stackslib/src/chainstate/stacks/miner.rs
@@ -2139,8 +2139,7 @@ impl StacksBlockBuilder {
         builder: &mut B,
         mempool: &mut MemPoolDB,
         tip_height: u64,
-        tenure_change_tx: Option<&StacksTransaction>,
-        coinbase_tx: Option<&StacksTransaction>,
+        initial_txs: &[StacksTransaction],
         settings: BlockBuilderSettings,
         event_observer: Option<&dyn MemPoolEventDispatcher>,
         ast_rules: ASTRules,
@@ -2155,17 +2154,10 @@ impl StacksBlockBuilder {
 
         let mut tx_events = Vec::new();
 
-        if let Some(tenure_tx) = tenure_change_tx {
+        for initial_tx in initial_txs.iter() {
             tx_events.push(
                 builder
-                    .try_mine_tx(epoch_tx, tenure_tx, ast_rules.clone())?
-                    .convert_to_event(),
-            );
-        }
-        if let Some(coinbase_tx) = coinbase_tx {
-            tx_events.push(
-                builder
-                    .try_mine_tx(epoch_tx, coinbase_tx, ast_rules.clone())?
+                    .try_mine_tx(epoch_tx, initial_tx, ast_rules.clone())?
                     .convert_to_event(),
             );
         }
@@ -2442,8 +2434,7 @@ impl StacksBlockBuilder {
             &mut builder,
             mempool,
             parent_stacks_header.stacks_block_height,
-            None,
-            Some(coinbase_tx),
+            &[coinbase_tx.clone()],
             settings,
             event_observer,
             ast_rules,
diff --git a/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs b/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
index d70fca1c02..ad83dd6f57 100644
--- a/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
+++ b/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
@@ -8,7 +8,7 @@ use async_h1::client;
 use async_std::io::ReadExt;
 use async_std::net::TcpStream;
 use base64::encode;
-use clarity::vm::types::PrincipalData;
+
 use http_types::{Method, Request, Url};
 use serde::Serialize;
 use serde_json::json;
@@ -50,11 +50,16 @@ use stacks_common::deps_common::bitcoin::network::encodable::ConsensusEncodable;
 use stacks_common::deps_common::bitcoin::network::serialize::deserialize as btc_deserialize;
 use stacks_common::deps_common::bitcoin::network::serialize::RawEncoder;
 use stacks_common::deps_common::bitcoin::util::hash::Sha256dHash;
-use stacks_common::types::chainstate::{BurnchainHeaderHash, StacksAddress};
+use stacks_common::types::chainstate::BurnchainHeaderHash;
 use stacks_common::util::hash::{hex_bytes, Hash160};
 use stacks_common::util::secp256k1::Secp256k1PublicKey;
 use stacks_common::util::sleep_ms;
 
+#[cfg(test)]
+use clarity::vm::types::PrincipalData;
+#[cfg(test)]
+use stacks_common::types::chainstate::StacksAddress;
+
 use super::super::operations::BurnchainOpSigner;
 use super::super::Config;
 use super::{BurnchainController, BurnchainTip, Error as BurnchainControllerError};
diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index f634f526c8..feaa0208ac 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -35,6 +35,8 @@ use stacks_common::util::get_epoch_time_ms;
 use stacks_common::util::hash::hex_bytes;
 use stacks_common::util::secp256k1::{Secp256k1PrivateKey, Secp256k1PublicKey};
 
+use crate::mockamoto::signer::SelfSigner;
+
 pub const DEFAULT_SATS_PER_VB: u64 = 50;
 const DEFAULT_MAX_RBF_RATE: u64 = 150; // 1.5x
 const DEFAULT_RBF_FEE_RATE_INCREMENT: u64 = 5;
@@ -491,6 +493,13 @@ lazy_static! {
 }
 
 impl Config {
+    pub fn self_signing(&self) -> Option<SelfSigner> {
+        if !(self.burnchain.mode == "nakamoto-neon" || self.burnchain.mode == "mockamoto") {
+            return None;
+        }
+        self.miner.self_signing_key.clone()
+    }
+
     /// get the up-to-date burnchain from the config
     pub fn get_burnchain_config(&self) -> Result<BurnchainConfig, String> {
         if let Some(path) = &self.config_path {
@@ -1095,6 +1104,7 @@ impl Config {
                     .as_ref()
                     .map(|x| Secp256k1PrivateKey::from_hex(x))
                     .transpose()?,
+                self_signing_key: None,
             },
             None => miner_default_config,
         };
@@ -1108,6 +1118,7 @@ impl Config {
             "xenon",
             "mainnet",
             "mockamoto",
+            "nakamoto-neon",
         ];
 
         if !supported_modes.contains(&burnchain.mode.as_str()) {
@@ -1629,10 +1640,10 @@ impl BurnchainConfig {
         match self.mode.as_str() {
             "mainnet" => ("mainnet".to_string(), BitcoinNetworkType::Mainnet),
             "xenon" => ("testnet".to_string(), BitcoinNetworkType::Testnet),
-            "helium" | "neon" | "argon" | "krypton" | "mocknet" | "mockamoto" => {
+            "helium" | "neon" | "argon" | "krypton" | "mocknet" | "mockamoto" | "nakamoto-neon" => {
                 ("regtest".to_string(), BitcoinNetworkType::Regtest)
             }
-            _ => panic!("Invalid bitcoin mode -- expected mainnet, testnet, or regtest"),
+            other => panic!("Invalid stacks-node mode: {other}"),
         }
     }
 }
@@ -2116,6 +2127,7 @@ pub struct MinerConfig {
     pub candidate_retry_cache_size: u64,
     pub unprocessed_block_deadline_secs: u64,
     pub mining_key: Option<Secp256k1PrivateKey>,
+    pub self_signing_key: Option<SelfSigner>,
 }
 
 impl MinerConfig {
@@ -2133,6 +2145,7 @@ impl MinerConfig {
             candidate_retry_cache_size: 10_000,
             unprocessed_block_deadline_secs: 30,
             mining_key: None,
+            self_signing_key: None,
         }
     }
 }
diff --git a/testnet/stacks-node/src/globals.rs b/testnet/stacks-node/src/globals.rs
new file mode 100644
index 0000000000..acace012f8
--- /dev/null
+++ b/testnet/stacks-node/src/globals.rs
@@ -0,0 +1,266 @@
+use std::sync::atomic::AtomicBool;
+use std::sync::atomic::Ordering;
+use std::sync::mpsc::SyncSender;
+use std::sync::Arc;
+use std::sync::Mutex;
+
+use stacks::burnchains::Txid;
+use stacks::chainstate::burn::operations::LeaderKeyRegisterOp;
+use stacks::chainstate::burn::BlockSnapshot;
+use stacks::chainstate::coordinator::comm::CoordinatorChannels;
+use stacks::chainstate::stacks::db::unconfirmed::UnconfirmedTxMap;
+use stacks::chainstate::stacks::db::StacksChainState;
+use stacks::chainstate::stacks::miner::MinerStatus;
+use stacks::net::NetworkResult;
+use stacks_common::types::chainstate::BlockHeaderHash;
+use stacks_common::types::chainstate::BurnchainHeaderHash;
+use stacks_common::types::chainstate::ConsensusHash;
+
+use crate::neon::Counters;
+use crate::run_loop::RegisteredKey;
+use crate::syncctl::PoxSyncWatchdogComms;
+
+use crate::neon_node::LeaderKeyRegistrationState;
+
+/// Command types for the relayer thread, issued to it by other threads
+pub enum RelayerDirective {
+    /// Handle some new data that arrived on the network (such as blocks, transactions, and
+    HandleNetResult(NetworkResult),
+    /// Announce a new sortition.  Process and broadcast the block if we won.
+    ProcessTenure(ConsensusHash, BurnchainHeaderHash, BlockHeaderHash),
+    /// Try to mine a block
+    RunTenure(RegisteredKey, BlockSnapshot, u128), // (vrf key, chain tip, time of issuance in ms)
+    /// A nakamoto tenure's first block has been processed.
+    NakamotoTenureStartProcessed(ConsensusHash, BlockHeaderHash),
+    /// Try to register a VRF public key
+    RegisterKey(BlockSnapshot),
+    /// Stop the relayer thread
+    Exit,
+}
+
+/// Inter-thread communication structure, shared between threads
+#[derive(Clone)]
+pub struct Globals {
+    /// Last sortition processed
+    last_sortition: Arc<Mutex<Option<BlockSnapshot>>>,
+    /// Status of the miner
+    miner_status: Arc<Mutex<MinerStatus>>,
+    /// Communication link to the coordinator thread
+    pub(crate) coord_comms: CoordinatorChannels,
+    /// Unconfirmed transactions (shared between the relayer and p2p threads)
+    unconfirmed_txs: Arc<Mutex<UnconfirmedTxMap>>,
+    /// Writer endpoint to the relayer thread
+    pub relay_send: SyncSender<RelayerDirective>,
+    /// Cointer state in the main thread
+    pub counters: Counters,
+    /// Connection to the PoX sync watchdog
+    pub sync_comms: PoxSyncWatchdogComms,
+    /// Global flag to see if we should keep running
+    pub should_keep_running: Arc<AtomicBool>,
+    /// Status of our VRF key registration state (shared between the main thread and the relayer)
+    leader_key_registration_state: Arc<Mutex<LeaderKeyRegistrationState>>,
+}
+
+impl Globals {
+    pub fn new(
+        coord_comms: CoordinatorChannels,
+        miner_status: Arc<Mutex<MinerStatus>>,
+        relay_send: SyncSender<RelayerDirective>,
+        counters: Counters,
+        sync_comms: PoxSyncWatchdogComms,
+        should_keep_running: Arc<AtomicBool>,
+    ) -> Globals {
+        Globals {
+            last_sortition: Arc::new(Mutex::new(None)),
+            miner_status,
+            coord_comms,
+            unconfirmed_txs: Arc::new(Mutex::new(UnconfirmedTxMap::new())),
+            relay_send,
+            counters,
+            sync_comms,
+            should_keep_running,
+            leader_key_registration_state: Arc::new(Mutex::new(
+                LeaderKeyRegistrationState::Inactive,
+            )),
+        }
+    }
+
+    /// Get the last sortition processed by the relayer thread
+    pub fn get_last_sortition(&self) -> Option<BlockSnapshot> {
+        self.last_sortition
+            .lock()
+            .unwrap_or_else(|_| {
+                error!("Sortition mutex poisoned!");
+                panic!();
+            })
+            .clone()
+    }
+
+    /// Set the last sortition processed
+    pub fn set_last_sortition(&self, block_snapshot: BlockSnapshot) {
+        let mut last_sortition = self.last_sortition.lock().unwrap_or_else(|_| {
+            error!("Sortition mutex poisoned!");
+            panic!();
+        });
+        last_sortition.replace(block_snapshot);
+    }
+
+    /// Get the status of the miner (blocked or ready)
+    pub fn get_miner_status(&self) -> Arc<Mutex<MinerStatus>> {
+        self.miner_status.clone()
+    }
+
+    pub fn block_miner(&self) {
+        self.miner_status
+            .lock()
+            .expect("FATAL: mutex poisoned")
+            .add_blocked()
+    }
+
+    pub fn unblock_miner(&self) {
+        self.miner_status
+            .lock()
+            .expect("FATAL: mutex poisoned")
+            .remove_blocked()
+    }
+
+    /// Get the main thread's counters
+    pub fn get_counters(&self) -> Counters {
+        self.counters.clone()
+    }
+
+    /// Called by the relayer to pass unconfirmed txs to the p2p thread, so the p2p thread doesn't
+    /// need to do the disk I/O needed to instantiate the unconfirmed state trie they represent.
+    /// Clears the unconfirmed transactions, and replaces them with the chainstate's.
+    pub fn send_unconfirmed_txs(&self, chainstate: &StacksChainState) {
+        let Some(ref unconfirmed) = chainstate.unconfirmed_state else {
+            return;
+        };
+        let mut txs = self.unconfirmed_txs.lock().unwrap_or_else(|e| {
+            // can only happen due to a thread panic in the relayer
+            error!("FATAL: unconfirmed tx arc mutex is poisoned: {e:?}");
+            panic!();
+        });
+        txs.clear();
+        txs.extend(unconfirmed.mined_txs.clone());
+    }
+
+    /// Called by the p2p thread to accept the unconfirmed tx state processed by the relayer.
+    /// Puts the shared unconfirmed transactions to chainstate.
+    pub fn recv_unconfirmed_txs(&self, chainstate: &mut StacksChainState) {
+        let Some(ref mut unconfirmed) = chainstate.unconfirmed_state else {
+            return;
+        };
+        let txs = self.unconfirmed_txs.lock().unwrap_or_else(|e| {
+            // can only happen due to a thread panic in the relayer
+            error!("FATAL: unconfirmed tx arc mutex is poisoned: {e:?}");
+            panic!();
+        });
+        unconfirmed.mined_txs.clear();
+        unconfirmed.mined_txs.extend(txs.clone());
+    }
+
+    /// Signal system-wide stop
+    pub fn signal_stop(&self) {
+        self.should_keep_running.store(false, Ordering::SeqCst);
+    }
+
+    /// Should we keep running?
+    pub fn keep_running(&self) -> bool {
+        self.should_keep_running.load(Ordering::SeqCst)
+    }
+
+    /// Get the handle to the coordinator
+    pub fn coord(&self) -> &CoordinatorChannels {
+        &self.coord_comms
+    }
+
+    /// Get the current leader key registration state.
+    /// Called from the runloop thread and relayer thread.
+    pub fn get_leader_key_registration_state(&self) -> LeaderKeyRegistrationState {
+        let key_state = self
+            .leader_key_registration_state
+            .lock()
+            .unwrap_or_else(|e| {
+                // can only happen due to a thread panic in the relayer
+                error!("FATAL: leader key registration mutex is poisoned: {e:?}");
+                panic!();
+            });
+        key_state.clone()
+    }
+
+    /// Set the initial leader key registration state.
+    /// Called from the runloop thread when booting up.
+    pub fn set_initial_leader_key_registration_state(&self, new_state: LeaderKeyRegistrationState) {
+        let mut key_state = self
+            .leader_key_registration_state
+            .lock()
+            .unwrap_or_else(|e| {
+                // can only happen due to a thread panic in the relayer
+                error!("FATAL: leader key registration mutex is poisoned: {e:?}");
+                panic!();
+            });
+        *key_state = new_state;
+    }
+
+    /// Advance the leader key registration state to pending, given a txid we just sent.
+    /// Only the relayer thread calls this.
+    pub fn set_pending_leader_key_registration(&self, target_block_height: u64, txid: Txid) {
+        let mut key_state = self
+            .leader_key_registration_state
+            .lock()
+            .unwrap_or_else(|_e| {
+                error!("FATAL: failed to lock leader key registration state mutex");
+                panic!();
+            });
+        *key_state = LeaderKeyRegistrationState::Pending(target_block_height, txid);
+    }
+
+    /// Advance the leader key registration state to active, given the VRF key registration ops
+    /// we've discovered in a given snapshot.
+    /// The runloop thread calls this whenever it processes a sortition.
+    pub fn try_activate_leader_key_registration(
+        &self,
+        burn_block_height: u64,
+        key_registers: Vec<LeaderKeyRegisterOp>,
+    ) -> bool {
+        let mut activated = false;
+        let mut key_state = self
+            .leader_key_registration_state
+            .lock()
+            .unwrap_or_else(|e| {
+                // can only happen due to a thread panic in the relayer
+                error!("FATAL: leader key registration mutex is poisoned: {e:?}");
+                panic!();
+            });
+        // if key_state is anything but pending, then we don't activate
+        let LeaderKeyRegistrationState::Pending(target_block_height, txid) = *key_state else {
+            return false;
+        };
+        for op in key_registers.into_iter() {
+            info!(
+                "Processing burnchain block with key_register_op";
+                "burn_block_height" => burn_block_height,
+                "txid" => %op.txid,
+                "checking_txid" => %txid,
+            );
+
+            if txid == op.txid {
+                *key_state = LeaderKeyRegistrationState::Active(RegisteredKey {
+                    target_block_height,
+                    vrf_public_key: op.public_key,
+                    block_height: u64::from(op.block_height),
+                    op_vtxindex: u32::from(op.vtxindex),
+                });
+                activated = true;
+            } else {
+                debug!(
+                    "key_register_op {} does not match our pending op {}",
+                    txid, &op.txid
+                );
+            }
+        }
+
+        activated
+    }
+}
diff --git a/testnet/stacks-node/src/keychain.rs b/testnet/stacks-node/src/keychain.rs
index 7ea3b90556..712fa0b662 100644
--- a/testnet/stacks-node/src/keychain.rs
+++ b/testnet/stacks-node/src/keychain.rs
@@ -7,7 +7,7 @@ use stacks_common::address::{
 };
 use stacks_common::types::chainstate::StacksAddress;
 use stacks_common::util::hash::{Hash160, Sha256Sum};
-use stacks_common::util::secp256k1::Secp256k1PublicKey;
+use stacks_common::util::secp256k1::{Secp256k1PrivateKey, Secp256k1PublicKey};
 use stacks_common::util::vrf::{VRFPrivateKey, VRFProof, VRFPublicKey, VRF};
 
 use super::operations::BurnchainOpSigner;
@@ -16,6 +16,7 @@ use super::operations::BurnchainOpSigner;
 #[derive(Clone)]
 pub struct Keychain {
     secret_state: Vec<u8>,
+    nakamoto_mining_key: Secp256k1PrivateKey,
 }
 
 impl Keychain {
@@ -44,10 +45,27 @@ impl Keychain {
         StacksPrivateKey::from_slice(&sk_bytes[..]).expect("FATAL: Keychain::make_secret_key_bytes() returned bytes that could not be parsed into a secp256k1 secret key!")
     }
 
-    /// Create a default keychain from the seed
+    /// Get the public key hash of the nakamoto mining key (i.e., Hash160(pubkey))
+    pub fn get_nakamoto_pkh(&self) -> Hash160 {
+        let pk = Secp256k1PublicKey::from_private(&self.nakamoto_mining_key);
+        Hash160::from_node_public_key(&pk)
+    }
+
+    /// Get the secrete key of the nakamoto mining key
+    pub fn get_nakamoto_sk(&self) -> &Secp256k1PrivateKey {
+        &self.nakamoto_mining_key
+    }
+
+    /// Create a default keychain from the seed, with a default nakamoto mining key derived
+    ///  from the same seed (
     pub fn default(seed: Vec<u8>) -> Keychain {
+        let secret_state = Self::make_secret_key_bytes(&seed);
+        // re-hash secret_state to use as a default seed for the nakamoto mining key
+        let nakamoto_mining_key =
+            Secp256k1PrivateKey::from_seed(Sha256Sum::from_data(&secret_state).as_bytes());
         Keychain {
-            secret_state: Keychain::make_secret_key_bytes(&seed),
+            secret_state,
+            nakamoto_mining_key,
         }
     }
 
diff --git a/testnet/stacks-node/src/main.rs b/testnet/stacks-node/src/main.rs
index 6addce37a1..8675b43132 100644
--- a/testnet/stacks-node/src/main.rs
+++ b/testnet/stacks-node/src/main.rs
@@ -19,8 +19,10 @@ pub mod burnchains;
 pub mod config;
 pub mod event_dispatcher;
 pub mod genesis_data;
+pub mod globals;
 pub mod keychain;
 pub mod mockamoto;
+pub mod nakamoto_node;
 pub mod neon_node;
 pub mod node;
 pub mod operations;
@@ -44,6 +46,7 @@ pub use self::node::{ChainTip, Node};
 pub use self::run_loop::{helium, neon};
 pub use self::tenure::Tenure;
 use crate::mockamoto::MockamotoNode;
+use crate::run_loop::nakamoto;
 
 fn main() {
     panic::set_hook(Box::new(|panic_info| {
@@ -209,6 +212,9 @@ fn main() {
     } else if conf.burnchain.mode == "mockamoto" {
         let mut mockamoto = MockamotoNode::new(&conf).unwrap();
         mockamoto.run();
+    } else if conf.burnchain.mode == "nakamoto-neon" {
+        let mut run_loop = nakamoto::RunLoop::new(conf);
+        run_loop.start(None, 0);
     } else {
         println!("Burnchain mode '{}' not supported", conf.burnchain.mode);
     }
diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index 6c5e7ca878..78bc2ae491 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -69,10 +69,9 @@ use stacks_common::util::secp256k1::{MessageSignature, Secp256k1PublicKey};
 use stacks_common::util::vrf::{VRFPrivateKey, VRFProof, VRFPublicKey, VRF};
 
 use self::signer::SelfSigner;
+use crate::globals::{Globals, RelayerDirective};
 use crate::neon::Counters;
-use crate::neon_node::{
-    Globals, PeerThread, RelayerDirective, StacksNode, BLOCK_PROCESSOR_STACK_SIZE,
-};
+use crate::neon_node::{PeerThread, StacksNode, BLOCK_PROCESSOR_STACK_SIZE};
 use crate::syncctl::PoxSyncWatchdogComms;
 use crate::{Config, EventDispatcher};
 
@@ -891,8 +890,7 @@ impl MockamotoNode {
             &mut builder,
             &mut self.mempool,
             parent_chain_length,
-            None,
-            None,
+            &[],
             BlockBuilderSettings {
                 max_miner_time_ms: 15_000,
                 mempool_settings: MemPoolWalkSettings::default(),
diff --git a/testnet/stacks-node/src/nakamoto_node.rs b/testnet/stacks-node/src/nakamoto_node.rs
new file mode 100644
index 0000000000..1c71b09045
--- /dev/null
+++ b/testnet/stacks-node/src/nakamoto_node.rs
@@ -0,0 +1,683 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+use std::collections::HashMap;
+use std::convert::TryFrom;
+use std::net::SocketAddr;
+use std::sync::mpsc::Receiver;
+use std::thread;
+use std::thread::JoinHandle;
+
+use super::{Config, EventDispatcher, Keychain};
+use crate::burnchains::bitcoin_regtest_controller::addr2str;
+use crate::globals::Globals;
+use crate::globals::RelayerDirective;
+use crate::neon_node::LeaderKeyRegistrationState;
+use crate::run_loop::nakamoto::RunLoop;
+use crate::run_loop::RegisteredKey;
+use clarity::vm::ast::ASTRules;
+use clarity::vm::types::QualifiedContractIdentifier;
+use stacks::burnchains::{Burnchain, BurnchainSigner, Txid};
+use stacks::chainstate::burn::db::sortdb::SortitionDB;
+use stacks::chainstate::burn::BlockSnapshot;
+use stacks::chainstate::stacks::db::StacksChainState;
+use stacks::chainstate::stacks::Error as ChainstateError;
+use stacks::core::mempool::MemPoolDB;
+use stacks::cost_estimates::metrics::UnitMetric;
+use stacks::cost_estimates::UnitEstimator;
+use stacks::monitoring;
+use stacks::monitoring::update_active_miners_count_gauge;
+use stacks::net::atlas::{AtlasConfig, AtlasDB};
+use stacks::net::db::PeerDB;
+use stacks::net::p2p::PeerNetwork;
+use stacks::net::relay::Relayer;
+use stacks::net::stackerdb::{StackerDBConfig, StackerDBSync, StackerDBs};
+use stacks::net::{Error as NetError, PeerNetworkComms, ServiceFlags};
+use stacks::util_lib::strings::{UrlString, VecDisplay};
+use stacks_common::types::chainstate::SortitionId;
+use stacks_common::types::net::PeerAddress;
+use stacks_common::types::StacksEpochId;
+use stacks_common::util::get_epoch_time_secs;
+use stacks_common::util::secp256k1::Secp256k1PrivateKey;
+
+pub mod miner;
+pub mod peer;
+pub mod relayer;
+
+use self::peer::PeerThread;
+use self::relayer::RelayerThread;
+
+pub const RELAYER_MAX_BUFFER: usize = 100;
+const VRF_MOCK_MINER_KEY: u64 = 1;
+
+pub const BLOCK_PROCESSOR_STACK_SIZE: usize = 32 * 1024 * 1024; // 32 MB
+
+pub type BlockCommits = HashMap<Txid, ()>;
+
+/// Node implementation for both miners and followers.
+/// This struct is used to set up the node proper and launch the p2p thread and relayer thread.
+/// It is further used by the main thread to communicate with these two threads.
+pub struct StacksNode {
+    /// Atlas network configuration
+    pub atlas_config: AtlasConfig,
+    /// Global inter-thread communication handle
+    pub globals: Globals,
+    /// True if we're a miner
+    is_miner: bool,
+    /// handle to the p2p thread
+    pub p2p_thread_handle: JoinHandle<()>,
+    /// handle to the relayer thread
+    pub relayer_thread_handle: JoinHandle<()>,
+}
+
+/// Fault injection logic to artificially increase the length of a tenure.
+/// Only used in testing
+#[cfg(test)]
+fn fault_injection_long_tenure() {
+    // simulated slow block
+    match std::env::var("STX_TEST_SLOW_TENURE") {
+        Ok(tenure_str) => match tenure_str.parse::<u64>() {
+            Ok(tenure_time) => {
+                info!(
+                    "Fault injection: sleeping for {} milliseconds to simulate a long tenure",
+                    tenure_time
+                );
+                stacks_common::util::sleep_ms(tenure_time);
+            }
+            Err(_) => {
+                error!("Parse error for STX_TEST_SLOW_TENURE");
+                panic!();
+            }
+        },
+        _ => {}
+    }
+}
+
+#[cfg(not(test))]
+fn fault_injection_long_tenure() {}
+
+/// Fault injection to skip mining in this bitcoin block height
+/// Only used in testing
+#[cfg(test)]
+fn fault_injection_skip_mining(rpc_bind: &str, target_burn_height: u64) -> bool {
+    match std::env::var("STACKS_DISABLE_MINER") {
+        Ok(disable_heights) => {
+            let disable_schedule: serde_json::Value =
+                serde_json::from_str(&disable_heights).unwrap();
+            let disable_schedule = disable_schedule.as_array().unwrap();
+            for disabled in disable_schedule {
+                let target_miner_rpc_bind = disabled
+                    .get("rpc_bind")
+                    .unwrap()
+                    .as_str()
+                    .unwrap()
+                    .to_string();
+                if target_miner_rpc_bind != rpc_bind {
+                    continue;
+                }
+                let target_block_heights = disabled.get("blocks").unwrap().as_array().unwrap();
+                for target_block_value in target_block_heights {
+                    let target_block = target_block_value.as_i64().unwrap() as u64;
+                    if target_block == target_burn_height {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
+        Err(_) => {
+            return false;
+        }
+    }
+}
+
+#[cfg(not(test))]
+fn fault_injection_skip_mining(_rpc_bind: &str, _target_burn_height: u64) -> bool {
+    false
+}
+
+/// Open the chainstate, and inject faults from the config file
+pub(crate) fn open_chainstate_with_faults(
+    config: &Config,
+) -> Result<StacksChainState, ChainstateError> {
+    let stacks_chainstate_path = config.get_chainstate_path_str();
+    let (mut chainstate, _) = StacksChainState::open(
+        config.is_mainnet(),
+        config.burnchain.chain_id,
+        &stacks_chainstate_path,
+        Some(config.node.get_marf_opts()),
+    )?;
+
+    chainstate.fault_injection.hide_blocks = config.node.fault_injection_hide_blocks;
+    Ok(chainstate)
+}
+
+/// Types of errors that can arise during mining
+#[derive(Debug)]
+enum Error {
+    /// Can't find the block sortition snapshot for the chain tip
+    SnapshotNotFoundForChainTip,
+    /// The burnchain tip changed while this operation was in progress
+    BurnchainTipChanged,
+    SpawnError(std::io::Error),
+    FaultInjection,
+    MissedMiningOpportunity,
+    /// Attempted to mine while there was no active VRF key
+    NoVRFKeyActive,
+    /// The parent block or tenure could not be found
+    ParentNotFound,
+    /// Something unexpected happened (e.g., hash mismatches)
+    UnexpectedChainState,
+    /// A burnchain operation failed when submitting it to the burnchain
+    BurnchainSubmissionFailed,
+    NewParentDiscovered,
+}
+
+impl StacksNode {
+    /// Set up the AST size-precheck height, if configured
+    fn setup_ast_size_precheck(config: &Config, sortdb: &mut SortitionDB) {
+        if let Some(ast_precheck_size_height) = config.burnchain.ast_precheck_size_height {
+            info!(
+                "Override burnchain height of {:?} to {}",
+                ASTRules::PrecheckSize,
+                ast_precheck_size_height
+            );
+            let mut tx = sortdb
+                .tx_begin()
+                .expect("FATAL: failed to begin tx on sortition DB");
+            SortitionDB::override_ast_rule_height(
+                &mut tx,
+                ASTRules::PrecheckSize,
+                ast_precheck_size_height,
+            )
+            .expect("FATAL: failed to override AST PrecheckSize rule height");
+            tx.commit()
+                .expect("FATAL: failed to commit sortition DB transaction");
+        }
+    }
+
+    /// Set up the mempool DB by making sure it exists.
+    /// Panics on failure.
+    fn setup_mempool_db(config: &Config) -> MemPoolDB {
+        // force early mempool instantiation
+        let cost_estimator = config
+            .make_cost_estimator()
+            .unwrap_or_else(|| Box::new(UnitEstimator));
+        let metric = config
+            .make_cost_metric()
+            .unwrap_or_else(|| Box::new(UnitMetric));
+
+        let mempool = MemPoolDB::open(
+            config.is_mainnet(),
+            config.burnchain.chain_id,
+            &config.get_chainstate_path_str(),
+            cost_estimator,
+            metric,
+        )
+        .expect("BUG: failed to instantiate mempool");
+
+        mempool
+    }
+
+    /// Set up the Peer DB and update any soft state from the config file.  This includes:
+    /// * blacklisted/whitelisted nodes
+    /// * node keys
+    /// * bootstrap nodes
+    /// Returns the instantiated PeerDB
+    /// Panics on failure.
+    fn setup_peer_db(
+        config: &Config,
+        burnchain: &Burnchain,
+        stackerdb_contract_ids: &[QualifiedContractIdentifier],
+    ) -> PeerDB {
+        let data_url = UrlString::try_from(format!("{}", &config.node.data_url)).unwrap();
+        let initial_neighbors = config.node.bootstrap_node.clone();
+        if initial_neighbors.len() > 0 {
+            info!(
+                "Will bootstrap from peers {}",
+                VecDisplay(&initial_neighbors)
+            );
+        } else {
+            warn!("Without a peer to bootstrap from, the node will start mining a new chain");
+        }
+
+        let p2p_sock: SocketAddr = config.node.p2p_bind.parse().expect(&format!(
+            "Failed to parse socket: {}",
+            &config.node.p2p_bind
+        ));
+        let p2p_addr: SocketAddr = config.node.p2p_address.parse().expect(&format!(
+            "Failed to parse socket: {}",
+            &config.node.p2p_address
+        ));
+        let node_privkey = Secp256k1PrivateKey::from_seed(&config.node.local_peer_seed);
+
+        let mut peerdb = PeerDB::connect(
+            &config.get_peer_db_file_path(),
+            true,
+            config.burnchain.chain_id,
+            burnchain.network_id,
+            Some(node_privkey),
+            config.connection_options.private_key_lifetime.clone(),
+            PeerAddress::from_socketaddr(&p2p_addr),
+            p2p_sock.port(),
+            data_url,
+            &[],
+            Some(&initial_neighbors),
+            stackerdb_contract_ids,
+        )
+        .map_err(|e| {
+            eprintln!(
+                "Failed to open {}: {:?}",
+                &config.get_peer_db_file_path(),
+                &e
+            );
+            panic!();
+        })
+        .unwrap();
+
+        // allow all bootstrap nodes
+        {
+            let mut tx = peerdb.tx_begin().unwrap();
+            for initial_neighbor in initial_neighbors.iter() {
+                // update peer in case public key changed
+                PeerDB::update_peer(&mut tx, &initial_neighbor).unwrap();
+                PeerDB::set_allow_peer(
+                    &mut tx,
+                    initial_neighbor.addr.network_id,
+                    &initial_neighbor.addr.addrbytes,
+                    initial_neighbor.addr.port,
+                    -1,
+                )
+                .unwrap();
+            }
+            tx.commit().unwrap();
+        }
+
+        if !config.node.deny_nodes.is_empty() {
+            warn!("Will ignore nodes {:?}", &config.node.deny_nodes);
+        }
+
+        // deny all config-denied peers
+        {
+            let mut tx = peerdb.tx_begin().unwrap();
+            for denied in config.node.deny_nodes.iter() {
+                PeerDB::set_deny_peer(
+                    &mut tx,
+                    denied.addr.network_id,
+                    &denied.addr.addrbytes,
+                    denied.addr.port,
+                    get_epoch_time_secs() + 24 * 365 * 3600,
+                )
+                .unwrap();
+            }
+            tx.commit().unwrap();
+        }
+
+        // update services to indicate we can support mempool sync
+        {
+            let mut tx = peerdb.tx_begin().unwrap();
+            PeerDB::set_local_services(
+                &mut tx,
+                (ServiceFlags::RPC as u16) | (ServiceFlags::RELAY as u16),
+            )
+            .unwrap();
+            tx.commit().unwrap();
+        }
+
+        peerdb
+    }
+
+    /// Set up the PeerNetwork, but do not bind it.
+    pub fn setup_peer_network(
+        config: &Config,
+        atlas_config: &AtlasConfig,
+        burnchain: Burnchain,
+    ) -> PeerNetwork {
+        let sortdb = SortitionDB::open(
+            &config.get_burn_db_file_path(),
+            true,
+            burnchain.pox_constants.clone(),
+        )
+        .expect("Error while instantiating sor/tition db");
+
+        let epochs = SortitionDB::get_stacks_epochs(sortdb.conn())
+            .expect("Error while loading stacks epochs");
+
+        let view = {
+            let sortition_tip = SortitionDB::get_canonical_burn_chain_tip(&sortdb.conn())
+                .expect("Failed to get sortition tip");
+            SortitionDB::get_burnchain_view(&sortdb.index_conn(), &burnchain, &sortition_tip)
+                .unwrap()
+        };
+
+        let atlasdb =
+            AtlasDB::connect(atlas_config.clone(), &config.get_atlas_db_file_path(), true).unwrap();
+
+        let stackerdbs = StackerDBs::connect(&config.get_stacker_db_file_path(), true).unwrap();
+
+        let mut chainstate =
+            open_chainstate_with_faults(config).expect("FATAL: could not open chainstate DB");
+
+        let mut stackerdb_machines = HashMap::new();
+        for stackerdb_contract_id in config.node.stacker_dbs.iter() {
+            // attempt to load the config
+            let (instantiate, stacker_db_config) = match StackerDBConfig::from_smart_contract(
+                &mut chainstate,
+                &sortdb,
+                stackerdb_contract_id,
+            ) {
+                Ok(c) => (true, c),
+                Err(e) => {
+                    warn!(
+                        "Failed to load StackerDB config for {}: {:?}",
+                        stackerdb_contract_id, &e
+                    );
+                    (false, StackerDBConfig::noop())
+                }
+            };
+            let mut stackerdbs =
+                StackerDBs::connect(&config.get_stacker_db_file_path(), true).unwrap();
+
+            if instantiate {
+                match stackerdbs.get_stackerdb_id(stackerdb_contract_id) {
+                    Ok(..) => {
+                        // reconfigure
+                        let tx = stackerdbs.tx_begin(stacker_db_config.clone()).unwrap();
+                        tx.reconfigure_stackerdb(stackerdb_contract_id, &stacker_db_config.signers)
+                            .expect(&format!(
+                                "FATAL: failed to reconfigure StackerDB replica {}",
+                                stackerdb_contract_id
+                            ));
+                        tx.commit().unwrap();
+                    }
+                    Err(NetError::NoSuchStackerDB(..)) => {
+                        // instantiate replica
+                        let tx = stackerdbs.tx_begin(stacker_db_config.clone()).unwrap();
+                        tx.create_stackerdb(stackerdb_contract_id, &stacker_db_config.signers)
+                            .expect(&format!(
+                                "FATAL: failed to instantiate StackerDB replica {}",
+                                stackerdb_contract_id
+                            ));
+                        tx.commit().unwrap();
+                    }
+                    Err(e) => {
+                        panic!("FATAL: failed to query StackerDB state: {:?}", &e);
+                    }
+                }
+            }
+            let stacker_db_sync = match StackerDBSync::new(
+                stackerdb_contract_id.clone(),
+                &stacker_db_config,
+                PeerNetworkComms::new(),
+                stackerdbs,
+            ) {
+                Ok(s) => s,
+                Err(e) => {
+                    warn!(
+                        "Failed to instantiate StackerDB sync machine for {}: {:?}",
+                        stackerdb_contract_id, &e
+                    );
+                    continue;
+                }
+            };
+
+            stackerdb_machines.insert(
+                stackerdb_contract_id.clone(),
+                (stacker_db_config, stacker_db_sync),
+            );
+        }
+
+        let stackerdb_contract_ids: Vec<_> =
+            stackerdb_machines.keys().map(|sc| sc.clone()).collect();
+        let peerdb = Self::setup_peer_db(config, &burnchain, &stackerdb_contract_ids);
+
+        let local_peer = match PeerDB::get_local_peer(peerdb.conn()) {
+            Ok(local_peer) => local_peer,
+            _ => panic!("Unable to retrieve local peer"),
+        };
+
+        let p2p_net = PeerNetwork::new(
+            peerdb,
+            atlasdb,
+            stackerdbs,
+            local_peer,
+            config.burnchain.peer_version,
+            burnchain,
+            view,
+            config.connection_options.clone(),
+            stackerdb_machines,
+            epochs,
+        );
+
+        p2p_net
+    }
+
+    /// This function sets the global var `GLOBAL_BURNCHAIN_SIGNER`.
+    ///
+    /// This variable is used for prometheus monitoring (which only
+    /// runs when the feature flag `monitoring_prom` is activated).
+    /// The address is set using the single-signature BTC address
+    /// associated with `keychain`'s public key. This address always
+    /// assumes Epoch-2.1 rules for the miner address: if the
+    /// node is configured for segwit, then the miner address generated
+    /// is a segwit address, otherwise it is a p2pkh.
+    ///
+    fn set_monitoring_miner_address(keychain: &Keychain, relayer_thread: &RelayerThread) {
+        let public_key = keychain.get_pub_key();
+        let miner_addr = relayer_thread
+            .bitcoin_controller
+            .get_miner_address(StacksEpochId::Epoch21, &public_key);
+        let miner_addr_str = addr2str(&miner_addr);
+        let _ = monitoring::set_burnchain_signer(BurnchainSigner(miner_addr_str)).map_err(|e| {
+            warn!("Failed to set global burnchain signer: {:?}", &e);
+            e
+        });
+    }
+
+    pub fn spawn(
+        runloop: &RunLoop,
+        globals: Globals,
+        // relay receiver endpoint for the p2p thread, so the relayer can feed it data to push
+        relay_recv: Receiver<RelayerDirective>,
+    ) -> StacksNode {
+        let config = runloop.config().clone();
+        let is_miner = runloop.is_miner();
+        let burnchain = runloop.get_burnchain();
+        let atlas_config = config.atlas.clone();
+        let keychain = Keychain::default(config.node.seed.clone());
+
+        // we can call _open_ here rather than _connect_, since connect is first called in
+        //   make_genesis_block
+        let mut sortdb = SortitionDB::open(
+            &config.get_burn_db_file_path(),
+            true,
+            burnchain.pox_constants.clone(),
+        )
+        .expect("Error while instantiating sortition db");
+
+        Self::setup_ast_size_precheck(&config, &mut sortdb);
+
+        let _ = Self::setup_mempool_db(&config);
+
+        let mut p2p_net = Self::setup_peer_network(&config, &atlas_config, burnchain.clone());
+
+        let stackerdbs = StackerDBs::connect(&config.get_stacker_db_file_path(), true)
+            .expect("FATAL: failed to connect to stacker DB");
+
+        let relayer = Relayer::from_p2p(&mut p2p_net, stackerdbs);
+
+        let local_peer = p2p_net.local_peer.clone();
+
+        // setup initial key registration
+        let leader_key_registration_state = if config.node.mock_mining {
+            // mock mining, pretend to have a registered key
+            let (vrf_public_key, _) = keychain.make_vrf_keypair(VRF_MOCK_MINER_KEY);
+            LeaderKeyRegistrationState::Active(RegisteredKey {
+                target_block_height: VRF_MOCK_MINER_KEY,
+                block_height: 1,
+                op_vtxindex: 1,
+                vrf_public_key,
+            })
+        } else {
+            LeaderKeyRegistrationState::Inactive
+        };
+        globals.set_initial_leader_key_registration_state(leader_key_registration_state);
+
+        let relayer_thread = RelayerThread::new(runloop, local_peer.clone(), relayer);
+
+        StacksNode::set_monitoring_miner_address(&keychain, &relayer_thread);
+
+        let relayer_thread_handle = thread::Builder::new()
+            .name(format!("relayer-{}", &local_peer.data_url))
+            .stack_size(BLOCK_PROCESSOR_STACK_SIZE)
+            .spawn(move || {
+                relayer_thread.main(relay_recv);
+            })
+            .expect("FATAL: failed to start relayer thread");
+
+        let p2p_event_dispatcher = runloop.get_event_dispatcher();
+        let p2p_thread = PeerThread::new(runloop, p2p_net);
+        let p2p_thread_handle = thread::Builder::new()
+            .stack_size(BLOCK_PROCESSOR_STACK_SIZE)
+            .name(format!(
+                "p2p-({},{})",
+                &config.node.p2p_bind, &config.node.rpc_bind
+            ))
+            .spawn(move || {
+                p2p_thread.main(p2p_event_dispatcher);
+            })
+            .expect("FATAL: failed to start p2p thread");
+
+        info!("Start HTTP server on: {}", &config.node.rpc_bind);
+        info!("Start P2P server on: {}", &config.node.p2p_bind);
+
+        StacksNode {
+            atlas_config,
+            globals,
+            is_miner,
+            p2p_thread_handle,
+            relayer_thread_handle,
+        }
+    }
+
+    /// Notify the relayer that a new burn block has been processed by the sortition db,
+    ///  telling it to process the block and begin mining if this miner won.
+    /// returns _false_ if the relayer hung up the channel.
+    /// Called from the main thread.
+    pub fn relayer_burnchain_notify(&self) -> bool {
+        if !self.is_miner {
+            // node is a follower, don't try to process my own tenure.
+            return true;
+        }
+
+        let Some(snapshot) = self.globals.get_last_sortition() else {
+            debug!("Tenure: Notify sortition! No last burn block");
+            return true;
+        };
+
+        debug!(
+            "Tenure: Notify sortition!";
+            "consensus_hash" => %snapshot.consensus_hash,
+            "burn_block_hash" => %snapshot.burn_header_hash,
+            "winning_stacks_block_hash" => %snapshot.winning_stacks_block_hash,
+            "burn_block_height" => &snapshot.block_height,
+            "sortition_id" => %snapshot.sortition_id
+        );
+
+        // unlike in neon_node, the nakamoto node should *always* notify the relayer of
+        //  a new burnchain block
+
+        return self
+            .globals
+            .relay_send
+            .send(RelayerDirective::ProcessTenure(
+                snapshot.consensus_hash.clone(),
+                snapshot.parent_burn_header_hash.clone(),
+                snapshot.winning_stacks_block_hash.clone(),
+            ))
+            .is_ok();
+    }
+
+    /// Process a state coming from the burnchain, by extracting the validated KeyRegisterOp
+    /// and inspecting if a sortition was won.
+    /// `ibd`: boolean indicating whether or not we are in the initial block download
+    /// Called from the main thread.
+    pub fn process_burnchain_state(
+        &mut self,
+        sortdb: &SortitionDB,
+        sort_id: &SortitionId,
+        ibd: bool,
+    ) -> Option<BlockSnapshot> {
+        let mut last_sortitioned_block = None;
+
+        let ic = sortdb.index_conn();
+
+        let block_snapshot = SortitionDB::get_block_snapshot(&ic, sort_id)
+            .expect("Failed to obtain block snapshot for processed burn block.")
+            .expect("Failed to obtain block snapshot for processed burn block.");
+        let block_height = block_snapshot.block_height;
+
+        let block_commits =
+            SortitionDB::get_block_commits_by_block(&ic, &block_snapshot.sortition_id)
+                .expect("Unexpected SortitionDB error fetching block commits");
+
+        let num_block_commits = block_commits.len();
+
+        update_active_miners_count_gauge(block_commits.len() as i64);
+
+        for op in block_commits.into_iter() {
+            if op.txid == block_snapshot.winning_block_txid {
+                info!(
+                    "Received burnchain block #{} including block_commit_op (winning) - {} ({})",
+                    block_height, op.apparent_sender, &op.block_header_hash
+                );
+                last_sortitioned_block = Some((block_snapshot.clone(), op.vtxindex));
+            } else {
+                if self.is_miner {
+                    info!(
+                        "Received burnchain block #{} including block_commit_op - {} ({})",
+                        block_height, op.apparent_sender, &op.block_header_hash
+                    );
+                }
+            }
+        }
+
+        let key_registers =
+            SortitionDB::get_leader_keys_by_block(&ic, &block_snapshot.sortition_id)
+                .expect("Unexpected SortitionDB error fetching key registers");
+
+        let num_key_registers = key_registers.len();
+
+        self.globals
+            .try_activate_leader_key_registration(block_height, key_registers);
+
+        debug!(
+            "Processed burnchain state";
+            "burn_height" => block_height,
+            "leader_keys_count" => num_key_registers,
+            "block_commits_count" => num_block_commits,
+            "in_initial_block_download?" => ibd,
+        );
+
+        self.globals.set_last_sortition(block_snapshot);
+        last_sortitioned_block.map(|x| x.0)
+    }
+
+    /// Join all inner threads
+    pub fn join(self) {
+        self.relayer_thread_handle.join().unwrap();
+        self.p2p_thread_handle.join().unwrap();
+    }
+}
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
new file mode 100644
index 0000000000..cb9942d451
--- /dev/null
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -0,0 +1,645 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+use std::convert::TryFrom;
+use std::thread;
+use std::thread::JoinHandle;
+use std::time::Instant;
+
+use super::relayer::RelayerThread;
+use super::Error as NakamotoNodeError;
+use super::{Config, EventDispatcher, Keychain};
+use crate::globals::Globals;
+use crate::mockamoto::signer::SelfSigner;
+use crate::nakamoto_node::VRF_MOCK_MINER_KEY;
+use crate::run_loop::RegisteredKey;
+use crate::ChainTip;
+use clarity::vm::types::PrincipalData;
+use stacks::burnchains::{Burnchain, BurnchainParameters};
+use stacks::chainstate::burn::db::sortdb::SortitionDB;
+use stacks::chainstate::burn::{BlockSnapshot, ConsensusHash};
+use stacks::chainstate::nakamoto::miner::{NakamotoBlockBuilder, NakamotoTenureStart};
+use stacks::chainstate::nakamoto::{NakamotoBlock, NakamotoChainState};
+use stacks::chainstate::stacks::db::{StacksChainState, StacksHeaderInfo};
+use stacks::chainstate::stacks::Error as ChainstateError;
+use stacks::chainstate::stacks::TenureChangeCause;
+use stacks::chainstate::stacks::TenureChangePayload;
+use stacks::chainstate::stacks::ThresholdSignature;
+use stacks::chainstate::stacks::{
+    CoinbasePayload, StacksTransaction, StacksTransactionSigner, TransactionAnchorMode,
+    TransactionPayload, TransactionVersion,
+};
+use stacks::core::mempool::MemPoolDB;
+use stacks::core::FIRST_BURNCHAIN_CONSENSUS_HASH;
+use stacks::cost_estimates::metrics::UnitMetric;
+use stacks::cost_estimates::UnitEstimator;
+use stacks_common::types::chainstate::{StacksAddress, StacksBlockId};
+use stacks_common::types::PrivateKey;
+use stacks_common::types::StacksEpochId;
+use stacks_common::util::hash::Hash160;
+use stacks_common::util::vrf::VRFProof;
+
+pub enum MinerDirective {
+    /// The miner won sortition so they should begin a new tenure
+    BeginTenure {
+        parent_tenure_start: StacksBlockId,
+        burnchain_tip: BlockSnapshot,
+    },
+    /// The miner should try to continue their tenure if they are the active miner
+    ContinueTenure { new_burn_view: ConsensusHash },
+    /// The miner did not win sortition
+    StopTenure,
+}
+
+struct ParentTenureInfo {
+    #[allow(dead_code)]
+    parent_tenure_start: StacksBlockId,
+    parent_tenure_blocks: u64,
+}
+
+/// Metadata required for beginning a new tenure
+struct ParentStacksBlockInfo {
+    /// Header metadata for the Stacks block we're going to build on top of
+    stacks_parent_header: StacksHeaderInfo,
+    /// the total amount burned in the sortition that selected the Stacks block parent
+    parent_block_total_burn: u64,
+    /// nonce to use for this new block's coinbase transaction
+    coinbase_nonce: u64,
+    parent_tenure: Option<ParentTenureInfo>,
+}
+
+pub struct BlockMinerThread {
+    /// node config struct
+    config: Config,
+    /// handle to global state
+    globals: Globals,
+    /// copy of the node's keychain
+    keychain: Keychain,
+    /// burnchain configuration
+    burnchain: Burnchain,
+    /// Set of blocks that we have mined, but are still potentially-broadcastable
+    /// (copied from RelayerThread since we need the info to determine the strategy for mining the
+    /// next block during this tenure).
+    last_mined_blocks: Vec<NakamotoBlock>,
+    /// Copy of the node's registered VRF key
+    registered_key: RegisteredKey,
+    /// Burnchain block snapshot which elected this miner
+    burn_block: BlockSnapshot,
+    /// The start of the parent tenure for this tenure
+    parent_tenure_id: StacksBlockId,
+    /// Handle to the node's event dispatcher
+    event_dispatcher: EventDispatcher,
+}
+
+impl BlockMinerThread {
+    /// Instantiate the miner thread
+    pub fn new(
+        rt: &RelayerThread,
+        registered_key: RegisteredKey,
+        burn_block: BlockSnapshot,
+        parent_tenure_id: StacksBlockId,
+    ) -> BlockMinerThread {
+        BlockMinerThread {
+            config: rt.config.clone(),
+            globals: rt.globals.clone(),
+            keychain: rt.keychain.clone(),
+            burnchain: rt.burnchain.clone(),
+            last_mined_blocks: vec![],
+            registered_key,
+            burn_block,
+            event_dispatcher: rt.event_dispatcher.clone(),
+            parent_tenure_id,
+        }
+    }
+
+    /// Stop a miner tenure by blocking the miner and then joining the tenure thread
+    pub fn stop_miner(globals: &Globals, prior_miner: JoinHandle<()>) {
+        globals.block_miner();
+        prior_miner
+            .join()
+            .expect("FATAL: IO failure joining prior mining thread");
+        globals.unblock_miner();
+    }
+
+    pub fn run_miner(mut self, prior_miner: Option<JoinHandle<()>>) {
+        // when starting a new tenure, block the mining thread if its currently running.
+        // the new mining thread will join it (so that the new mining thread stalls, not the relayer)
+        if let Some(prior_miner) = prior_miner {
+            Self::stop_miner(&self.globals, prior_miner);
+        }
+
+        // now, actually run this tenure
+        let Some(new_block) = self.mine_block() else {
+            warn!("Failed to mine block");
+            return;
+        };
+
+        if let Some(self_signer) = self.config.self_signing() {
+            if let Err(e) = self.self_sign_and_broadcast(self_signer, new_block.clone()) {
+                warn!("Error self-signing block: {e:?}");
+            } else {
+                self.globals.coord().announce_new_stacks_block();
+            }
+        } else {
+            warn!("Not self-signing: nakamoto node does not support stacker-signer-protocol yet");
+        }
+
+        self.globals.counters.bump_naka_mined_blocks();
+        self.last_mined_blocks.push(new_block);
+    }
+
+    fn self_sign_and_broadcast(
+        &self,
+        mut signer: SelfSigner,
+        mut block: NakamotoBlock,
+    ) -> Result<(), ChainstateError> {
+        signer.sign_nakamoto_block(&mut block);
+        let mut chain_state = super::open_chainstate_with_faults(&self.config)
+            .expect("FATAL: could not open chainstate DB");
+        let chainstate_config = chain_state.config();
+        let sort_db = SortitionDB::open(
+            &self.config.get_burn_db_file_path(),
+            true,
+            self.burnchain.pox_constants.clone(),
+        )
+        .expect("FATAL: could not open sortition DB");
+        let sortition_handle = sort_db.index_handle_at_tip();
+        let staging_tx = chain_state.staging_db_tx_begin()?;
+        NakamotoChainState::accept_block(
+            &chainstate_config,
+            block,
+            &sortition_handle,
+            &staging_tx,
+            &signer.aggregate_public_key,
+        )?;
+        staging_tx.commit()?;
+        Ok(())
+    }
+
+    /// Get the coinbase recipient address, if set in the config and if allowed in this epoch
+    fn get_coinbase_recipient(&self, epoch_id: StacksEpochId) -> Option<PrincipalData> {
+        if epoch_id < StacksEpochId::Epoch21 && self.config.miner.block_reward_recipient.is_some() {
+            warn!("Coinbase pay-to-contract is not supported in the current epoch");
+            None
+        } else {
+            self.config.miner.block_reward_recipient.clone()
+        }
+    }
+
+    fn generate_tenure_change_tx(
+        &mut self,
+        nonce: u64,
+        parent_block_id: StacksBlockId,
+        parent_tenure_blocks: u64,
+        miner_pkh: Hash160,
+    ) -> Option<StacksTransaction> {
+        if self.config.self_signing().is_none() {
+            // if we're not self-signing, then we can't generate a tenure change tx: it has to come from the signers.
+            return None;
+        }
+        let is_mainnet = self.config.is_mainnet();
+        let chain_id = self.config.burnchain.chain_id;
+        let tenure_change_tx_payload = TransactionPayload::TenureChange(
+            TenureChangePayload {
+                previous_tenure_end: parent_block_id,
+                previous_tenure_blocks: u32::try_from(parent_tenure_blocks)
+                    .expect("FATAL: more than u32 blocks in a tenure"),
+                cause: TenureChangeCause::BlockFound,
+                pubkey_hash: miner_pkh,
+                signers: vec![],
+            },
+            ThresholdSignature::mock(),
+        );
+
+        let mut tx_auth = self.keychain.get_transaction_auth().unwrap();
+        tx_auth.set_origin_nonce(nonce);
+
+        let version = if is_mainnet {
+            TransactionVersion::Mainnet
+        } else {
+            TransactionVersion::Testnet
+        };
+
+        let mut tx = StacksTransaction::new(version, tx_auth, tenure_change_tx_payload);
+
+        tx.chain_id = chain_id;
+        tx.anchor_mode = TransactionAnchorMode::OnChainOnly;
+        let mut tx_signer = StacksTransactionSigner::new(&tx);
+        self.keychain.sign_as_origin(&mut tx_signer);
+
+        Some(tx_signer.get_tx().unwrap())
+    }
+
+    /// Create a coinbase transaction.
+    fn generate_coinbase_tx(
+        &mut self,
+        nonce: u64,
+        epoch_id: StacksEpochId,
+        vrf_proof: VRFProof,
+    ) -> StacksTransaction {
+        let is_mainnet = self.config.is_mainnet();
+        let chain_id = self.config.burnchain.chain_id;
+        let mut tx_auth = self.keychain.get_transaction_auth().unwrap();
+        tx_auth.set_origin_nonce(nonce);
+
+        let version = if is_mainnet {
+            TransactionVersion::Mainnet
+        } else {
+            TransactionVersion::Testnet
+        };
+
+        let recipient_opt = self.get_coinbase_recipient(epoch_id);
+
+        let mut tx = StacksTransaction::new(
+            version,
+            tx_auth,
+            TransactionPayload::Coinbase(
+                CoinbasePayload([0u8; 32]),
+                recipient_opt,
+                Some(vrf_proof),
+            ),
+        );
+        tx.chain_id = chain_id;
+        tx.anchor_mode = TransactionAnchorMode::OnChainOnly;
+        let mut tx_signer = StacksTransactionSigner::new(&tx);
+        self.keychain.sign_as_origin(&mut tx_signer);
+
+        tx_signer.get_tx().unwrap()
+    }
+
+    /// Load up the parent block info for mining.
+    /// If there's no parent because this is the first block, then return the genesis block's info.
+    /// If we can't find the parent in the DB but we expect one, return None.
+    fn load_block_parent_info(
+        &self,
+        burn_db: &mut SortitionDB,
+        chain_state: &mut StacksChainState,
+    ) -> Option<ParentStacksBlockInfo> {
+        let Some(stacks_tip) =
+            NakamotoChainState::get_canonical_block_header(chain_state.db(), burn_db)
+                .expect("FATAL: could not query chain tip")
+        else {
+            debug!("No Stacks chain tip known, will return a genesis block");
+            let (network, _) = self.config.burnchain.get_bitcoin_network();
+            let burnchain_params =
+                BurnchainParameters::from_params(&self.config.burnchain.chain, &network)
+                    .expect("Bitcoin network unsupported");
+
+            let chain_tip = ChainTip::genesis(
+                &burnchain_params.first_block_hash,
+                burnchain_params.first_block_height.into(),
+                burnchain_params.first_block_timestamp.into(),
+            );
+
+            return Some(ParentStacksBlockInfo {
+                parent_tenure: Some(ParentTenureInfo {
+                    parent_tenure_start: chain_tip.metadata.index_block_hash(),
+                    parent_tenure_blocks: 0,
+                }),
+                stacks_parent_header: chain_tip.metadata,
+                parent_block_total_burn: 0,
+                coinbase_nonce: 0,
+            });
+        };
+
+        let miner_address = self
+            .keychain
+            .origin_address(self.config.is_mainnet())
+            .unwrap();
+        match ParentStacksBlockInfo::lookup(
+            chain_state,
+            burn_db,
+            &self.burn_block,
+            miner_address,
+            &self.parent_tenure_id,
+            stacks_tip,
+        ) {
+            Ok(parent_info) => Some(parent_info),
+            Err(NakamotoNodeError::BurnchainTipChanged) => {
+                self.globals.counters.bump_missed_tenures();
+                None
+            }
+            Err(..) => None,
+        }
+    }
+
+    /// Generate the VRF proof for the block we're going to build.
+    /// Returns Some(proof) if we could make the proof
+    /// Return None if we could not make the proof
+    fn make_vrf_proof(&mut self) -> Option<VRFProof> {
+        // if we're a mock miner, then make sure that the keychain has a keypair for the mocked VRF
+        // key
+        let vrf_proof = if self.config.node.mock_mining {
+            self.keychain.generate_proof(
+                VRF_MOCK_MINER_KEY,
+                self.burn_block.sortition_hash.as_bytes(),
+            )
+        } else {
+            self.keychain.generate_proof(
+                self.registered_key.target_block_height,
+                self.burn_block.sortition_hash.as_bytes(),
+            )
+        };
+
+        debug!(
+            "Generated VRF Proof: {} over {} ({},{}) with key {}",
+            vrf_proof.to_hex(),
+            &self.burn_block.sortition_hash,
+            &self.burn_block.block_height,
+            &self.burn_block.burn_header_hash,
+            &self.registered_key.vrf_public_key.to_hex()
+        );
+        Some(vrf_proof)
+    }
+
+    /// Try to mine a Stacks block by assembling one from mempool transactions and sending a
+    /// burnchain block-commit transaction.  If we succeed, then return the assembled block data as
+    /// well as the microblock private key to use to produce microblocks.
+    /// Return None if we couldn't build a block for whatever reason.
+    fn mine_block(&mut self) -> Option<NakamotoBlock> {
+        debug!("block miner thread ID is {:?}", thread::current().id());
+        super::fault_injection_long_tenure();
+
+        let burn_db_path = self.config.get_burn_db_file_path();
+        let stacks_chainstate_path = self.config.get_chainstate_path_str();
+
+        let cost_estimator = self
+            .config
+            .make_cost_estimator()
+            .unwrap_or_else(|| Box::new(UnitEstimator));
+        let metric = self
+            .config
+            .make_cost_metric()
+            .unwrap_or_else(|| Box::new(UnitMetric));
+
+        // NOTE: read-write access is needed in order to be able to query the recipient set.
+        // This is an artifact of the way the MARF is built (see #1449)
+        let mut burn_db =
+            SortitionDB::open(&burn_db_path, true, self.burnchain.pox_constants.clone())
+                .expect("FATAL: could not open sortition DB");
+
+        let mut chain_state = super::open_chainstate_with_faults(&self.config)
+            .expect("FATAL: could not open chainstate DB");
+
+        let mut mem_pool = MemPoolDB::open(
+            self.config.is_mainnet(),
+            self.config.burnchain.chain_id,
+            &stacks_chainstate_path,
+            cost_estimator,
+            metric,
+        )
+        .expect("Database failure opening mempool");
+
+        let assembly_start = Instant::now();
+
+        let target_epoch_id =
+            SortitionDB::get_stacks_epoch(burn_db.conn(), self.burn_block.block_height + 1)
+                .ok()?
+                .expect("FATAL: no epoch defined")
+                .epoch_id;
+        let mut parent_block_info = self.load_block_parent_info(&mut burn_db, &mut chain_state)?;
+        let vrf_proof = self.make_vrf_proof()?;
+
+        if self.last_mined_blocks.is_empty() {
+            if parent_block_info.parent_tenure.is_none() {
+                warn!(
+                    "Miner should be starting a new tenure, but failed to load parent tenure info"
+                );
+                return None;
+            }
+        }
+
+        // create our coinbase if this is the first block we've mined this tenure
+        let tenure_start_info = if let Some(ref par_tenure_info) = parent_block_info.parent_tenure {
+            let parent_block_id = parent_block_info.stacks_parent_header.index_block_hash();
+            let current_miner_nonce = parent_block_info.coinbase_nonce;
+            let tenure_change_tx = self.generate_tenure_change_tx(
+                current_miner_nonce,
+                parent_block_id,
+                par_tenure_info.parent_tenure_blocks,
+                self.keychain.get_nakamoto_pkh(),
+            )?;
+            let coinbase_tx = self.generate_coinbase_tx(
+                current_miner_nonce + 1,
+                target_epoch_id,
+                vrf_proof.clone(),
+            );
+            Some(NakamotoTenureStart {
+                coinbase_tx,
+                // TODO (refactor): the nakamoto block builder doesn't use this VRF proof,
+                //  it has to be included in the coinbase tx, which is an arg to the builder.
+                //  we should probably just remove this from the nakamoto block builder.
+                vrf_proof: vrf_proof.clone(),
+                tenure_change_tx,
+            })
+        } else {
+            None
+        };
+
+        parent_block_info.stacks_parent_header.microblock_tail = None;
+
+        // build the block itself
+        let (mut block, _, _) = match NakamotoBlockBuilder::build_nakamoto_block(
+            &chain_state,
+            &burn_db.index_conn(),
+            &mut mem_pool,
+            // TODO (refactor): the nakamoto block builder doesn't use the parent tenure ID,
+            //  it has to be included in the tenure change tx, which is an arg to the builder.
+            //  we should probably just remove this from the nakamoto block builder, so that
+            //  there isn't duplicated or unused logic here
+            &self.parent_tenure_id,
+            &parent_block_info.stacks_parent_header,
+            &self.burn_block.consensus_hash,
+            self.burn_block.total_burn,
+            tenure_start_info,
+            self.config.make_block_builder_settings(
+                // TODO: the attempt counter needs a different configuration approach in nakamoto
+                1,
+                false,
+                self.globals.get_miner_status(),
+            ),
+            Some(&self.event_dispatcher),
+        ) {
+            Ok(block) => block,
+            Err(e) => {
+                error!("Relayer: Failure mining anchored block: {}", e);
+                return None;
+            }
+        };
+
+        let mining_key = self.keychain.get_nakamoto_sk();
+        let miner_signature = mining_key
+            .sign(block.header.signature_hash().ok()?.as_bytes())
+            .ok()?;
+        block.header.miner_signature = miner_signature;
+
+        info!(
+            "Miner: Succeeded assembling {} block #{}: {}, with {} txs",
+            if parent_block_info.parent_block_total_burn == 0 {
+                "Genesis"
+            } else {
+                "Stacks"
+            },
+            block.header.chain_length,
+            block.header.block_hash(),
+            block.txs.len(),
+        );
+
+        // last chance -- confirm that the stacks tip is unchanged (since it could have taken long
+        // enough to build this block that another block could have arrived), and confirm that all
+        // Stacks blocks with heights higher than the canoincal tip are processed.
+        let cur_burn_chain_tip = SortitionDB::get_canonical_burn_chain_tip(burn_db.conn())
+            .expect("FATAL: failed to query sortition DB for canonical burn chain tip");
+
+        if cur_burn_chain_tip.consensus_hash != block.header.consensus_hash {
+            info!("Miner: Cancel block assembly; burnchain tip has changed");
+            self.globals.counters.bump_missed_tenures();
+            return None;
+        }
+
+        Some(block)
+    }
+}
+
+impl ParentStacksBlockInfo {
+    /// Determine where in the set of forks to attempt to mine the next anchored block.
+    /// `mine_tip_ch` and `mine_tip_bhh` identify the parent block on top of which to mine.
+    /// `check_burn_block` identifies what we believe to be the burn chain's sortition history tip.
+    /// This is used to mitigate (but not eliminate) a TOCTTOU issue with mining: the caller's
+    /// conception of the sortition history tip may have become stale by the time they call this
+    /// method, in which case, mining should *not* happen (since the block will be invalid).
+    pub fn lookup(
+        chain_state: &mut StacksChainState,
+        burn_db: &mut SortitionDB,
+        check_burn_block: &BlockSnapshot,
+        miner_address: StacksAddress,
+        parent_tenure_id: &StacksBlockId,
+        stacks_tip_header: StacksHeaderInfo,
+    ) -> Result<ParentStacksBlockInfo, NakamotoNodeError> {
+        // the stacks block I'm mining off of's burn header hash and vtxindex:
+        let parent_snapshot = SortitionDB::get_block_snapshot_consensus(
+            burn_db.conn(),
+            &stacks_tip_header.consensus_hash,
+        )
+        .expect("Failed to look up block's parent snapshot")
+        .expect("Failed to look up block's parent snapshot");
+
+        let parent_sortition_id = &parent_snapshot.sortition_id;
+
+        let parent_block_total_burn =
+            if &stacks_tip_header.consensus_hash == &FIRST_BURNCHAIN_CONSENSUS_HASH {
+                0
+            } else {
+                let parent_burn_block =
+                    SortitionDB::get_block_snapshot(burn_db.conn(), parent_sortition_id)
+                        .expect("SortitionDB failure.")
+                        .ok_or_else(|| {
+                            error!(
+                                "Failed to find block snapshot for the parent sortition";
+                                "parent_sortition_id" => %parent_sortition_id
+                            );
+                            NakamotoNodeError::SnapshotNotFoundForChainTip
+                        })?;
+
+                parent_burn_block.total_burn
+            };
+
+        // don't mine off of an old burnchain block
+        let burn_chain_tip = SortitionDB::get_canonical_burn_chain_tip(burn_db.conn())
+            .expect("FATAL: failed to query sortition DB for canonical burn chain tip");
+
+        if burn_chain_tip.consensus_hash != check_burn_block.consensus_hash {
+            info!(
+                "New canonical burn chain tip detected. Will not try to mine.";
+                "new_consensus_hash" => %burn_chain_tip.consensus_hash,
+                "old_consensus_hash" => %check_burn_block.consensus_hash,
+                "new_burn_height" => burn_chain_tip.block_height,
+                "old_burn_height" => check_burn_block.block_height
+            );
+            return Err(NakamotoNodeError::BurnchainTipChanged);
+        }
+
+        let Ok(Some(parent_tenure_header)) =
+            NakamotoChainState::get_block_header(chain_state.db(), &parent_tenure_id)
+        else {
+            warn!("Failed loading parent tenure ID"; "parent_tenure_id" => %parent_tenure_id);
+            return Err(NakamotoNodeError::ParentNotFound);
+        };
+
+        // check if we're mining a first tenure block (by checking if our parent block is in the tenure of parent_tenure_id)
+        //  and if so, figure out how many blocks there were in the parent tenure
+        let parent_tenure_info = if stacks_tip_header.consensus_hash
+            == parent_tenure_header.consensus_hash
+        {
+            let parent_tenure_blocks = if parent_tenure_header
+                .anchored_header
+                .as_stacks_nakamoto()
+                .is_some()
+            {
+                let Ok(Some(last_parent_tenure_header)) =
+                    NakamotoChainState::get_nakamoto_tenure_finish_block_header(
+                        chain_state.db(),
+                        &parent_tenure_header.consensus_hash,
+                    )
+                else {
+                    warn!("Failed loading last block of parent tenure"; "parent_tenure_id" => %parent_tenure_id);
+                    return Err(NakamotoNodeError::ParentNotFound);
+                };
+                // the last known tenure block of our parent should be the stacks_tip. if not, error.
+                if stacks_tip_header.index_block_hash()
+                    != last_parent_tenure_header.index_block_hash()
+                {
+                    return Err(NakamotoNodeError::NewParentDiscovered);
+                }
+                1 + last_parent_tenure_header.stacks_block_height
+                    - parent_tenure_header.stacks_block_height
+            } else {
+                1
+            };
+            Some(ParentTenureInfo {
+                parent_tenure_start: parent_tenure_id.clone(),
+                parent_tenure_blocks,
+            })
+        } else {
+            None
+        };
+
+        debug!("Mining tenure's last consensus hash: {} (height {} hash {}), stacks tip consensus hash: {} (height {} hash {})",
+               &check_burn_block.consensus_hash, check_burn_block.block_height, &check_burn_block.burn_header_hash,
+               &parent_snapshot.consensus_hash, parent_snapshot.block_height, &parent_snapshot.burn_header_hash);
+
+        let coinbase_nonce = {
+            let principal = miner_address.into();
+            let account = chain_state
+                .with_read_only_clarity_tx(
+                    &burn_db.index_conn(),
+                    &stacks_tip_header.index_block_hash(),
+                    |conn| StacksChainState::get_account(conn, &principal),
+                )
+                .expect(&format!(
+                    "BUG: stacks tip block {} no longer exists after we queried it",
+                    &stacks_tip_header.index_block_hash(),
+                ));
+            account.nonce
+        };
+
+        Ok(ParentStacksBlockInfo {
+            stacks_parent_header: stacks_tip_header,
+            parent_block_total_burn,
+            coinbase_nonce,
+            parent_tenure: parent_tenure_info,
+        })
+    }
+}
diff --git a/testnet/stacks-node/src/nakamoto_node/peer.rs b/testnet/stacks-node/src/nakamoto_node/peer.rs
new file mode 100644
index 0000000000..8fe688972e
--- /dev/null
+++ b/testnet/stacks-node/src/nakamoto_node/peer.rs
@@ -0,0 +1,418 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+use std::cmp;
+use std::collections::VecDeque;
+
+use std::default::Default;
+use std::net::SocketAddr;
+use std::sync::mpsc::TrySendError;
+
+use std::thread;
+use std::time::Duration;
+
+use stacks::burnchains::db::BurnchainHeaderReader;
+use stacks::burnchains::PoxConstants;
+use stacks::chainstate::burn::db::sortdb::SortitionDB;
+
+use stacks::chainstate::stacks::db::StacksChainState;
+use stacks::chainstate::stacks::miner::signal_mining_blocked;
+
+use stacks::core::mempool::MemPoolDB;
+
+use stacks::cost_estimates::metrics::{CostMetric, UnitMetric};
+use stacks::cost_estimates::{CostEstimator, FeeEstimator, UnitEstimator};
+
+use stacks::net::dns::{DNSClient, DNSResolver};
+use stacks::net::p2p::PeerNetwork;
+
+use stacks::net::RPCHandlerArgs;
+
+use stacks_common::util::hash::Sha256Sum;
+
+use crate::burnchains::make_bitcoin_indexer;
+use crate::globals::Globals;
+use crate::globals::RelayerDirective;
+
+use crate::run_loop::nakamoto::RunLoop;
+
+use crate::{Config, EventDispatcher};
+
+use super::open_chainstate_with_faults;
+
+/// Thread that runs the network state machine, handling both p2p and http requests.
+pub struct PeerThread {
+    /// Node config
+    config: Config,
+    /// instance of the peer network. Made optional in order to trick the borrow checker.
+    net: Option<PeerNetwork>,
+    /// handle to global inter-thread comms
+    globals: Globals,
+    /// how long to wait for network messages on each poll, in millis
+    poll_timeout: u64,
+    /// handle to the sortition DB (optional so we can take/replace it)
+    sortdb: Option<SortitionDB>,
+    /// handle to the chainstate DB (optional so we can take/replace it)
+    chainstate: Option<StacksChainState>,
+    /// handle to the mempool DB (optional so we can take/replace it)
+    mempool: Option<MemPoolDB>,
+    /// buffer of relayer commands with block data that couldn't be sent to the relayer just yet
+    /// (i.e. due to backpressure).  We track this separately, instead of just using a bigger
+    /// channel, because we need to know when backpressure occurs in order to throttle the p2p
+    /// thread's downloader.
+    results_with_data: VecDeque<RelayerDirective>,
+    /// total number of p2p state-machine passes so far. Used to signal when to download the next
+    /// reward cycle of blocks
+    num_p2p_state_machine_passes: u64,
+    /// total number of inventory state-machine passes so far. Used to signal when to download the
+    /// next reward cycle of blocks.
+    num_inv_sync_passes: u64,
+    /// total number of download state-machine passes so far. Used to signal when to download the
+    /// next reward cycle of blocks.
+    num_download_passes: u64,
+    /// last burnchain block seen in the PeerNetwork's chain view since the last run
+    last_burn_block_height: u64,
+}
+
+impl PeerThread {
+    /// Main loop of the p2p thread.
+    /// Runs in a separate thread.
+    /// Continuously receives, until told otherwise.
+    pub fn main(mut self, event_dispatcher: EventDispatcher) {
+        debug!("p2p thread ID is {:?}", thread::current().id());
+        let should_keep_running = self.globals.should_keep_running.clone();
+        let (mut dns_resolver, mut dns_client) = DNSResolver::new(10);
+
+        // spawn a daemon thread that runs the DNS resolver.
+        // It will die when the rest of the system dies.
+        {
+            let _jh = thread::Builder::new()
+                .name("dns-resolver".to_string())
+                .spawn(move || {
+                    debug!("DNS resolver thread ID is {:?}", thread::current().id());
+                    dns_resolver.thread_main();
+                })
+                .unwrap();
+        }
+
+        // NOTE: these must be instantiated in the thread context, since it can't be safely sent
+        // between threads
+        let fee_estimator_opt = self.config.make_fee_estimator();
+        let cost_estimator = self
+            .config
+            .make_cost_estimator()
+            .unwrap_or_else(|| Box::new(UnitEstimator));
+        let cost_metric = self
+            .config
+            .make_cost_metric()
+            .unwrap_or_else(|| Box::new(UnitMetric));
+
+        let indexer = make_bitcoin_indexer(&self.config, Some(should_keep_running));
+
+        // receive until we can't reach the receiver thread
+        loop {
+            if !self.globals.keep_running() {
+                break;
+            }
+            if !self.run_one_pass(
+                &indexer,
+                Some(&mut dns_client),
+                &event_dispatcher,
+                &cost_estimator,
+                &cost_metric,
+                fee_estimator_opt.as_ref(),
+            ) {
+                break;
+            }
+        }
+
+        // kill miner
+        signal_mining_blocked(self.globals.get_miner_status());
+
+        // set termination flag so other threads die
+        self.globals.signal_stop();
+
+        // thread exited, so signal to the relayer thread to die.
+        while let Err(TrySendError::Full(_)) =
+            self.globals.relay_send.try_send(RelayerDirective::Exit)
+        {
+            warn!("Failed to direct relayer thread to exit, sleeping and trying again");
+            thread::sleep(Duration::from_secs(5));
+        }
+        info!("P2P thread exit!");
+    }
+
+    /// set up the mempool DB connection
+    pub fn connect_mempool_db(config: &Config) -> MemPoolDB {
+        // create estimators, metric instances for RPC handler
+        let cost_estimator = config
+            .make_cost_estimator()
+            .unwrap_or_else(|| Box::new(UnitEstimator));
+        let metric = config
+            .make_cost_metric()
+            .unwrap_or_else(|| Box::new(UnitMetric));
+
+        let mempool = MemPoolDB::open(
+            config.is_mainnet(),
+            config.burnchain.chain_id,
+            &config.get_chainstate_path_str(),
+            cost_estimator,
+            metric,
+        )
+        .expect("Database failure opening mempool");
+
+        mempool
+    }
+
+    /// Instantiate the p2p thread.
+    /// Binds the addresses in the config (which may panic if the port is blocked).
+    /// This is so the node will crash "early" before any new threads start if there's going to be
+    /// a bind error anyway.
+    pub fn new(runloop: &RunLoop, net: PeerNetwork) -> PeerThread {
+        Self::new_all(
+            runloop.get_globals(),
+            runloop.config(),
+            runloop.get_burnchain().pox_constants,
+            net,
+        )
+    }
+
+    pub fn new_all(
+        globals: Globals,
+        config: &Config,
+        pox_constants: PoxConstants,
+        mut net: PeerNetwork,
+    ) -> Self {
+        let config = config.clone();
+        let mempool = Self::connect_mempool_db(&config);
+        let burn_db_path = config.get_burn_db_file_path();
+
+        let sortdb = SortitionDB::open(&burn_db_path, false, pox_constants)
+            .expect("FATAL: could not open sortition DB");
+
+        let chainstate =
+            open_chainstate_with_faults(&config).expect("FATAL: could not open chainstate DB");
+
+        let p2p_sock: SocketAddr = config.node.p2p_bind.parse().expect(&format!(
+            "Failed to parse socket: {}",
+            &config.node.p2p_bind
+        ));
+        let rpc_sock = config.node.rpc_bind.parse().expect(&format!(
+            "Failed to parse socket: {}",
+            &config.node.rpc_bind
+        ));
+
+        net.bind(&p2p_sock, &rpc_sock)
+            .expect("BUG: PeerNetwork could not bind or is already bound");
+
+        let poll_timeout = cmp::min(5000, config.miner.first_attempt_time_ms / 2);
+
+        PeerThread {
+            config,
+            net: Some(net),
+            globals,
+            poll_timeout,
+            sortdb: Some(sortdb),
+            chainstate: Some(chainstate),
+            mempool: Some(mempool),
+            results_with_data: VecDeque::new(),
+            num_p2p_state_machine_passes: 0,
+            num_inv_sync_passes: 0,
+            num_download_passes: 0,
+            last_burn_block_height: 0,
+        }
+    }
+
+    /// Do something with mutable references to the mempool, sortdb, and chainstate
+    /// Fools the borrow checker.
+    /// NOT COMPOSIBLE
+    fn with_chainstate<F, R>(&mut self, func: F) -> R
+    where
+        F: FnOnce(&mut PeerThread, &mut SortitionDB, &mut StacksChainState, &mut MemPoolDB) -> R,
+    {
+        let mut sortdb = self.sortdb.take().expect("BUG: sortdb already taken");
+        let mut chainstate = self
+            .chainstate
+            .take()
+            .expect("BUG: chainstate already taken");
+        let mut mempool = self.mempool.take().expect("BUG: mempool already taken");
+
+        let res = func(self, &mut sortdb, &mut chainstate, &mut mempool);
+
+        self.sortdb = Some(sortdb);
+        self.chainstate = Some(chainstate);
+        self.mempool = Some(mempool);
+
+        res
+    }
+
+    /// Get an immutable ref to the inner network.
+    /// DO NOT USE WITHIN with_network()
+    fn get_network(&self) -> &PeerNetwork {
+        self.net.as_ref().expect("BUG: did not replace net")
+    }
+
+    /// Do something with mutable references to the network.
+    /// Fools the borrow checker.
+    /// NOT COMPOSIBLE. DO NOT CALL THIS OR get_network() IN func
+    fn with_network<F, R>(&mut self, func: F) -> R
+    where
+        F: FnOnce(&mut PeerThread, &mut PeerNetwork) -> R,
+    {
+        let mut net = self.net.take().expect("BUG: net already taken");
+
+        let res = func(self, &mut net);
+
+        self.net = Some(net);
+        res
+    }
+
+    /// Run one pass of the p2p/http state machine
+    /// Return true if we should continue running passes; false if not
+    pub fn run_one_pass<B: BurnchainHeaderReader>(
+        &mut self,
+        indexer: &B,
+        dns_client_opt: Option<&mut DNSClient>,
+        event_dispatcher: &EventDispatcher,
+        cost_estimator: &Box<dyn CostEstimator>,
+        cost_metric: &Box<dyn CostMetric>,
+        fee_estimator: Option<&Box<dyn FeeEstimator>>,
+    ) -> bool {
+        // initial block download?
+        let ibd = self.globals.sync_comms.get_ibd();
+        let download_backpressure = self.results_with_data.len() > 0;
+        let poll_ms = if !download_backpressure && self.get_network().has_more_downloads() {
+            // keep getting those blocks -- drive the downloader state-machine
+            debug!(
+                "P2P: backpressure: {}, more downloads: {}",
+                download_backpressure,
+                self.get_network().has_more_downloads()
+            );
+            1
+        } else {
+            self.poll_timeout
+        };
+
+        // do one pass
+        let p2p_res = self.with_chainstate(|p2p_thread, sortdb, chainstate, mempool| {
+            // NOTE: handler_args must be created such that it outlives the inner net.run() call and
+            // doesn't ref anything within p2p_thread.
+            let handler_args = RPCHandlerArgs {
+                exit_at_block_height: p2p_thread
+                    .config
+                    .burnchain
+                    .process_exit_at_block_height
+                    .clone(),
+                genesis_chainstate_hash: Sha256Sum::from_hex(stx_genesis::GENESIS_CHAINSTATE_HASH)
+                    .unwrap(),
+                event_observer: Some(event_dispatcher),
+                cost_estimator: Some(cost_estimator.as_ref()),
+                cost_metric: Some(cost_metric.as_ref()),
+                fee_estimator: fee_estimator.map(|boxed_estimator| boxed_estimator.as_ref()),
+                ..RPCHandlerArgs::default()
+            };
+            p2p_thread.with_network(|_, net| {
+                net.run(
+                    indexer,
+                    sortdb,
+                    chainstate,
+                    mempool,
+                    dns_client_opt,
+                    download_backpressure,
+                    ibd,
+                    poll_ms,
+                    &handler_args,
+                )
+            })
+        });
+
+        match p2p_res {
+            Ok(network_result) => {
+                let mut have_update = false;
+                if self.num_p2p_state_machine_passes < network_result.num_state_machine_passes {
+                    // p2p state-machine did a full pass. Notify anyone listening.
+                    self.globals.sync_comms.notify_p2p_state_pass();
+                    self.num_p2p_state_machine_passes = network_result.num_state_machine_passes;
+                }
+
+                if self.num_inv_sync_passes < network_result.num_inv_sync_passes {
+                    // inv-sync state-machine did a full pass. Notify anyone listening.
+                    self.globals.sync_comms.notify_inv_sync_pass();
+                    self.num_inv_sync_passes = network_result.num_inv_sync_passes;
+
+                    // the relayer cares about the number of inventory passes, so pass this along
+                    have_update = true;
+                }
+
+                if self.num_download_passes < network_result.num_download_passes {
+                    // download state-machine did a full pass.  Notify anyone listening.
+                    self.globals.sync_comms.notify_download_pass();
+                    self.num_download_passes = network_result.num_download_passes;
+
+                    // the relayer cares about the number of download passes, so pass this along
+                    have_update = true;
+                }
+
+                if network_result.has_data_to_store()
+                    || self.last_burn_block_height != network_result.burn_height
+                    || have_update
+                {
+                    // pass along if we have blocks, microblocks, or transactions, or a status
+                    // update on the network's view of the burnchain
+                    self.last_burn_block_height = network_result.burn_height;
+                    self.results_with_data
+                        .push_back(RelayerDirective::HandleNetResult(network_result));
+                }
+            }
+            Err(e) => {
+                // this is only reachable if the network is not instantiated correctly --
+                // i.e. you didn't connect it
+                panic!("P2P: Failed to process network dispatch: {:?}", &e);
+            }
+        };
+
+        while let Some(next_result) = self.results_with_data.pop_front() {
+            // have blocks, microblocks, and/or transactions (don't care about anything else),
+            // or a directive to mine microblocks
+            if let Err(e) = self.globals.relay_send.try_send(next_result) {
+                debug!(
+                    "P2P: {:?}: download backpressure detected (bufferred {})",
+                    &self.get_network().local_peer,
+                    self.results_with_data.len()
+                );
+                match e {
+                    TrySendError::Full(directive) => {
+                        if let RelayerDirective::RunTenure(..) = directive {
+                            // can drop this
+                        } else {
+                            // don't lose this data -- just try it again
+                            self.results_with_data.push_front(directive);
+                        }
+                        break;
+                    }
+                    TrySendError::Disconnected(_) => {
+                        info!("P2P: Relayer hang up with p2p channel");
+                        self.globals.signal_stop();
+                        return false;
+                    }
+                }
+            } else {
+                debug!("P2P: Dispatched result to Relayer!");
+            }
+        }
+
+        true
+    }
+}
diff --git a/testnet/stacks-node/src/nakamoto_node/relayer.rs b/testnet/stacks-node/src/nakamoto_node/relayer.rs
new file mode 100644
index 0000000000..a90b17866f
--- /dev/null
+++ b/testnet/stacks-node/src/nakamoto_node/relayer.rs
@@ -0,0 +1,961 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+use stacks::burnchains::{Burnchain, Txid};
+use stacks::chainstate::burn::db::sortdb::SortitionDB;
+use stacks::chainstate::burn::operations::leader_block_commit::{
+    RewardSetInfo, BURN_BLOCK_MINED_AT_MODULUS,
+};
+use stacks::chainstate::burn::operations::{
+    BlockstackOperationType, LeaderBlockCommitOp, LeaderKeyRegisterOp,
+};
+use stacks::chainstate::burn::{BlockSnapshot, ConsensusHash};
+use stacks::chainstate::coordinator::{get_next_recipients, OnChainRewardSetProvider};
+use stacks::chainstate::nakamoto::NakamotoChainState;
+use stacks::chainstate::stacks::address::PoxAddress;
+use stacks::chainstate::stacks::db::StacksChainState;
+use stacks::chainstate::stacks::miner::{
+    get_mining_spend_amount, signal_mining_blocked, signal_mining_ready,
+};
+use stacks::core::mempool::MemPoolDB;
+use stacks::core::FIRST_BURNCHAIN_CONSENSUS_HASH;
+use stacks::core::FIRST_STACKS_BLOCK_HASH;
+use stacks::core::STACKS_EPOCH_3_0_MARKER;
+use stacks::cost_estimates::metrics::UnitMetric;
+use stacks::cost_estimates::UnitEstimator;
+use stacks::monitoring::increment_stx_blocks_mined_counter;
+use stacks::net::db::LocalPeer;
+use stacks::net::relay::Relayer;
+use stacks::net::NetworkResult;
+use stacks_common::types::chainstate::{
+    BlockHeaderHash, BurnchainHeaderHash, StacksBlockId, VRFSeed,
+};
+use stacks_common::types::StacksEpochId;
+use stacks_common::util::get_epoch_time_ms;
+use stacks_common::util::hash::Hash160;
+use stacks_common::util::vrf::{VRFProof, VRFPublicKey};
+use std::collections::HashMap;
+use std::sync::mpsc::Receiver;
+use std::sync::mpsc::RecvTimeoutError;
+use std::thread::JoinHandle;
+use std::time::Duration;
+use std::time::Instant;
+
+use super::Error as NakamotoNodeError;
+use super::{
+    fault_injection_skip_mining, open_chainstate_with_faults, BlockCommits, Config,
+    EventDispatcher, Keychain, BLOCK_PROCESSOR_STACK_SIZE,
+};
+use crate::burnchains::BurnchainController;
+use crate::globals::Globals;
+use crate::globals::RelayerDirective;
+use crate::nakamoto_node::miner::{BlockMinerThread, MinerDirective};
+use crate::neon_node::LeaderKeyRegistrationState;
+use crate::run_loop::nakamoto::RunLoop;
+use crate::run_loop::RegisteredKey;
+use crate::BitcoinRegtestController;
+
+/// Relayer thread
+/// * accepts network results and stores blocks and microblocks
+/// * forwards new blocks, microblocks, and transactions to the p2p thread
+/// * processes burnchain state
+/// * if mining, runs the miner and broadcasts blocks (via a subordinate MinerThread)
+pub struct RelayerThread {
+    /// Node config
+    pub(crate) config: Config,
+    /// Handle to the sortition DB (optional so we can take/replace it)
+    sortdb: Option<SortitionDB>,
+    /// Handle to the chainstate DB (optional so we can take/replace it)
+    chainstate: Option<StacksChainState>,
+    /// Handle to the mempool DB (optional so we can take/replace it)
+    mempool: Option<MemPoolDB>,
+    /// Handle to global state and inter-thread communication channels
+    pub(crate) globals: Globals,
+    /// Authoritative copy of the keychain state
+    pub(crate) keychain: Keychain,
+    /// Burnchian configuration
+    pub(crate) burnchain: Burnchain,
+    /// height of last VRF key registration request
+    last_vrf_key_burn_height: Option<u64>,
+    /// Set of blocks that we have mined, but are still potentially-broadcastable
+    // TODO: this field is a slow leak!
+    pub(crate) last_commits: BlockCommits,
+    /// client to the burnchain (used only for sending block-commits)
+    pub(crate) bitcoin_controller: BitcoinRegtestController,
+    /// client to the event dispatcher
+    pub(crate) event_dispatcher: EventDispatcher,
+    /// copy of the local peer state
+    local_peer: LocalPeer,
+    /// last observed burnchain block height from the p2p thread (obtained from network results)
+    last_network_block_height: u64,
+    /// time at which we observed a change in the network block height (epoch time in millis)
+    last_network_block_height_ts: u128,
+    /// last observed number of downloader state-machine passes from the p2p thread (obtained from
+    /// network results)
+    last_network_download_passes: u64,
+    /// last observed number of inventory state-machine passes from the p2p thread (obtained from
+    /// network results)
+    last_network_inv_passes: u64,
+    /// minimum number of downloader state-machine passes that must take place before mining (this
+    /// is used to ensure that the p2p thread attempts to download new Stacks block data before
+    /// this thread tries to mine a block)
+    min_network_download_passes: u64,
+    /// minimum number of inventory state-machine passes that must take place before mining (this
+    /// is used to ensure that the p2p thread attempts to download new Stacks block data before
+    /// this thread tries to mine a block)
+    min_network_inv_passes: u64,
+
+    /// Inner relayer instance for forwarding broadcasted data back to the p2p thread for dispatch
+    /// to neighbors
+    relayer: Relayer,
+
+    /// handle to the subordinate miner thread
+    miner_thread: Option<JoinHandle<()>>,
+    /// The relayer thread reads directives from the relay_rcv, but it also periodically wakes up
+    ///  to check if it should issue a block commit or try to register a VRF key
+    next_initiative: Instant,
+    is_miner: bool,
+    /// This is the last snapshot in which the relayer committed
+    last_committed_at: Option<BlockSnapshot>,
+}
+
+impl RelayerThread {
+    /// Instantiate off of a StacksNode, a runloop, and a relayer.
+    pub fn new(runloop: &RunLoop, local_peer: LocalPeer, relayer: Relayer) -> RelayerThread {
+        let config = runloop.config().clone();
+        let globals = runloop.get_globals();
+        let burn_db_path = config.get_burn_db_file_path();
+        let stacks_chainstate_path = config.get_chainstate_path_str();
+        let is_mainnet = config.is_mainnet();
+        let chain_id = config.burnchain.chain_id;
+        let is_miner = runloop.is_miner();
+
+        let sortdb = SortitionDB::open(&burn_db_path, true, runloop.get_burnchain().pox_constants)
+            .expect("FATAL: failed to open burnchain DB");
+
+        let chainstate =
+            open_chainstate_with_faults(&config).expect("FATAL: failed to open chainstate DB");
+
+        let cost_estimator = config
+            .make_cost_estimator()
+            .unwrap_or_else(|| Box::new(UnitEstimator));
+        let metric = config
+            .make_cost_metric()
+            .unwrap_or_else(|| Box::new(UnitMetric));
+
+        let mempool = MemPoolDB::open(
+            is_mainnet,
+            chain_id,
+            &stacks_chainstate_path,
+            cost_estimator,
+            metric,
+        )
+        .expect("Database failure opening mempool");
+
+        let keychain = Keychain::default(config.node.seed.clone());
+        let bitcoin_controller = BitcoinRegtestController::new_dummy(config.clone());
+
+        RelayerThread {
+            config: config.clone(),
+            sortdb: Some(sortdb),
+            chainstate: Some(chainstate),
+            mempool: Some(mempool),
+            globals,
+            keychain,
+            burnchain: runloop.get_burnchain(),
+            last_vrf_key_burn_height: None,
+            last_commits: HashMap::new(),
+            bitcoin_controller,
+            event_dispatcher: runloop.get_event_dispatcher(),
+            local_peer,
+
+            last_network_block_height: 0,
+            last_network_block_height_ts: 0,
+            last_network_download_passes: 0,
+            min_network_download_passes: 0,
+            last_network_inv_passes: 0,
+            min_network_inv_passes: 0,
+
+            relayer,
+
+            miner_thread: None,
+            is_miner,
+            next_initiative: Instant::now() + Duration::from_secs(10),
+            last_committed_at: None,
+        }
+    }
+
+    /// Get an immutible ref to the sortdb
+    pub fn sortdb_ref(&self) -> &SortitionDB {
+        self.sortdb
+            .as_ref()
+            .expect("FATAL: tried to access sortdb while taken")
+    }
+
+    /// Get an immutible ref to the chainstate
+    pub fn chainstate_ref(&self) -> &StacksChainState {
+        self.chainstate
+            .as_ref()
+            .expect("FATAL: tried to access chainstate while it was taken")
+    }
+
+    /// Fool the borrow checker into letting us do something with the chainstate databases.
+    /// DOES NOT COMPOSE -- do NOT call this, or self.sortdb_ref(), or self.chainstate_ref(), within
+    /// `func`.  You will get a runtime panic.
+    pub fn with_chainstate<F, R>(&mut self, func: F) -> R
+    where
+        F: FnOnce(&mut RelayerThread, &mut SortitionDB, &mut StacksChainState, &mut MemPoolDB) -> R,
+    {
+        let mut sortdb = self
+            .sortdb
+            .take()
+            .expect("FATAL: tried to take sortdb while taken");
+        let mut chainstate = self
+            .chainstate
+            .take()
+            .expect("FATAL: tried to take chainstate while taken");
+        let mut mempool = self
+            .mempool
+            .take()
+            .expect("FATAL: tried to take mempool while taken");
+        let res = func(self, &mut sortdb, &mut chainstate, &mut mempool);
+        self.sortdb = Some(sortdb);
+        self.chainstate = Some(chainstate);
+        self.mempool = Some(mempool);
+        res
+    }
+
+    /// have we waited for the right conditions under which to start mining a block off of our
+    /// chain tip?
+    pub fn has_waited_for_latest_blocks(&self) -> bool {
+        // a network download pass took place
+        (self.min_network_download_passes <= self.last_network_download_passes
+        // a network inv pass took place
+        && self.min_network_download_passes <= self.last_network_download_passes)
+        // we waited long enough for a download pass, but timed out waiting
+        || self.last_network_block_height_ts + (self.config.node.wait_time_for_blocks as u128) < get_epoch_time_ms()
+        // we're not supposed to wait at all
+        || !self.config.miner.wait_for_block_download
+    }
+
+    /// Return debug string for waiting for latest blocks
+    pub fn debug_waited_for_latest_blocks(&self) -> String {
+        format!(
+            "({} <= {} && {} <= {}) || {} + {} < {} || {}",
+            self.min_network_download_passes,
+            self.last_network_download_passes,
+            self.min_network_inv_passes,
+            self.last_network_inv_passes,
+            self.last_network_block_height_ts,
+            self.config.node.wait_time_for_blocks,
+            get_epoch_time_ms(),
+            self.config.miner.wait_for_block_download
+        )
+    }
+
+    /// Handle a NetworkResult from the p2p/http state machine.  Usually this is the act of
+    /// * preprocessing and storing new blocks and microblocks
+    /// * relaying blocks, microblocks, and transacctions
+    /// * updating unconfirmed state views
+    pub fn process_network_result(&mut self, mut net_result: NetworkResult) {
+        debug!(
+            "Relayer: Handle network result (from {})",
+            net_result.burn_height
+        );
+
+        if self.last_network_block_height != net_result.burn_height {
+            // burnchain advanced; disable mining until we also do a download pass.
+            self.last_network_block_height = net_result.burn_height;
+            self.min_network_download_passes = net_result.num_download_passes + 1;
+            self.min_network_inv_passes = net_result.num_inv_sync_passes + 1;
+            self.last_network_block_height_ts = get_epoch_time_ms();
+            debug!(
+                "Relayer: block mining until the next download pass {}",
+                self.min_network_download_passes
+            );
+            signal_mining_blocked(self.globals.get_miner_status());
+        }
+
+        let net_receipts = self.with_chainstate(|relayer_thread, sortdb, chainstate, mempool| {
+            relayer_thread
+                .relayer
+                .process_network_result(
+                    &relayer_thread.local_peer,
+                    &mut net_result,
+                    sortdb,
+                    chainstate,
+                    mempool,
+                    relayer_thread.globals.sync_comms.get_ibd(),
+                    Some(&relayer_thread.globals.coord_comms),
+                    Some(&relayer_thread.event_dispatcher),
+                )
+                .expect("BUG: failure processing network results")
+        });
+
+        if net_receipts.num_new_blocks > 0 || net_receipts.num_new_confirmed_microblocks > 0 {
+            // if we received any new block data that could invalidate our view of the chain tip,
+            // then stop mining until we process it
+            debug!("Relayer: block mining to process newly-arrived blocks or microblocks");
+            signal_mining_blocked(self.globals.get_miner_status());
+        }
+
+        let mempool_txs_added = net_receipts.mempool_txs_added.len();
+        if mempool_txs_added > 0 {
+            self.event_dispatcher
+                .process_new_mempool_txs(net_receipts.mempool_txs_added);
+        }
+
+        let num_unconfirmed_microblock_tx_receipts =
+            net_receipts.processed_unconfirmed_state.receipts.len();
+        if num_unconfirmed_microblock_tx_receipts > 0 {
+            if let Some(unconfirmed_state) = self.chainstate_ref().unconfirmed_state.as_ref() {
+                let canonical_tip = unconfirmed_state.confirmed_chain_tip.clone();
+                self.event_dispatcher.process_new_microblocks(
+                    canonical_tip,
+                    net_receipts.processed_unconfirmed_state,
+                );
+            } else {
+                warn!("Relayer: oops, unconfirmed state is uninitialized but there are microblock events");
+            }
+        }
+
+        // Dispatch retrieved attachments, if any.
+        if net_result.has_attachments() {
+            self.event_dispatcher
+                .process_new_attachments(&net_result.attachments);
+        }
+
+        // synchronize unconfirmed tx index to p2p thread
+        self.with_chainstate(|relayer_thread, _sortdb, chainstate, _mempool| {
+            relayer_thread.globals.send_unconfirmed_txs(chainstate);
+        });
+
+        // resume mining if we blocked it, and if we've done the requisite download
+        // passes
+        self.last_network_download_passes = net_result.num_download_passes;
+        self.last_network_inv_passes = net_result.num_inv_sync_passes;
+        if self.has_waited_for_latest_blocks() {
+            debug!("Relayer: did a download pass, so unblocking mining");
+            signal_mining_ready(self.globals.get_miner_status());
+        }
+    }
+
+    /// Given the pointer to a recently processed sortition, see if we won the sortition.
+    ///
+    /// Returns `true` if we won this last sortition.
+    pub fn process_sortition(
+        &mut self,
+        consensus_hash: ConsensusHash,
+        burn_hash: BurnchainHeaderHash,
+        committed_index_hash: StacksBlockId,
+    ) -> MinerDirective {
+        let sn =
+            SortitionDB::get_block_snapshot_consensus(self.sortdb_ref().conn(), &consensus_hash)
+                .expect("FATAL: failed to query sortition DB")
+                .expect("FATAL: unknown consensus hash");
+
+        self.globals.set_last_sortition(sn.clone());
+
+        let won_sortition =
+            sn.sortition && self.last_commits.remove(&sn.winning_block_txid).is_some();
+
+        info!(
+            "Relayer: Process sortition";
+            "sortition_ch" => %consensus_hash,
+            "burn_hash" => %burn_hash,
+            "burn_height" => sn.block_height,
+            "winning_txid" => %sn.winning_block_txid,
+            "committed_parent" => %committed_index_hash,
+            "won_sortition?" => won_sortition,
+        );
+
+        if won_sortition {
+            increment_stx_blocks_mined_counter();
+        }
+
+        if sn.sortition {
+            if won_sortition {
+                MinerDirective::BeginTenure {
+                    parent_tenure_start: committed_index_hash,
+                    burnchain_tip: sn,
+                }
+            } else {
+                MinerDirective::StopTenure
+            }
+        } else {
+            MinerDirective::ContinueTenure {
+                new_burn_view: consensus_hash,
+            }
+        }
+    }
+
+    /// Constructs and returns a LeaderKeyRegisterOp out of the provided params
+    fn make_key_register_op(
+        vrf_public_key: VRFPublicKey,
+        consensus_hash: &ConsensusHash,
+        miner_pkh: &Hash160,
+    ) -> BlockstackOperationType {
+        BlockstackOperationType::LeaderKeyRegister(LeaderKeyRegisterOp {
+            public_key: vrf_public_key,
+            memo: miner_pkh.as_bytes().to_vec(),
+            consensus_hash: consensus_hash.clone(),
+            vtxindex: 0,
+            txid: Txid([0u8; 32]),
+            block_height: 0,
+            burn_header_hash: BurnchainHeaderHash::zero(),
+        })
+    }
+
+    /// Create and broadcast a VRF public key registration transaction.
+    /// Returns true if we succeed in doing so; false if not.
+    pub fn rotate_vrf_and_register(&mut self, burn_block: &BlockSnapshot) {
+        if self.last_vrf_key_burn_height.is_some() {
+            // already in-flight
+            return;
+        }
+        let cur_epoch =
+            SortitionDB::get_stacks_epoch(self.sortdb_ref().conn(), burn_block.block_height)
+                .expect("FATAL: failed to query sortition DB")
+                .expect("FATAL: no epoch defined")
+                .epoch_id;
+        let (vrf_pk, _) = self.keychain.make_vrf_keypair(burn_block.block_height);
+        let burnchain_tip_consensus_hash = &burn_block.consensus_hash;
+        let miner_pkh = self.keychain.get_nakamoto_pkh();
+
+        debug!(
+            "Submitting LeaderKeyRegister";
+            "vrf_pk" => vrf_pk.to_hex(),
+            "burn_block_height" => burn_block.block_height,
+            "miner_pkh" => miner_pkh.to_hex(),
+        );
+
+        let op = Self::make_key_register_op(vrf_pk, burnchain_tip_consensus_hash, &miner_pkh);
+
+        let mut op_signer = self.keychain.generate_op_signer();
+        if let Some(txid) =
+            self.bitcoin_controller
+                .submit_operation(cur_epoch, op, &mut op_signer, 1)
+        {
+            // advance key registration state
+            self.last_vrf_key_burn_height = Some(burn_block.block_height);
+            self.globals
+                .set_pending_leader_key_registration(burn_block.block_height, txid);
+            self.globals.counters.bump_naka_submitted_vrfs();
+        }
+    }
+
+    /// Produce the block-commit for this anchored block, if we can.
+    /// `target_ch` is the consensus-hash of the Tenure we will build off
+    /// `target_bh` is the block hash of the Tenure we will build off
+    /// Returns the (the most recent burn snapshot, the expected epoch, the commit-op) on success
+    /// Returns None if we fail somehow.
+    fn make_block_commit(
+        &mut self,
+        target_ch: &ConsensusHash,
+        target_bh: &BlockHeaderHash,
+    ) -> Result<(BlockSnapshot, StacksEpochId, LeaderBlockCommitOp), NakamotoNodeError> {
+        let chain_state = self
+            .chainstate
+            .as_mut()
+            .expect("FATAL: Failed to load chain state");
+        let sort_db = self.sortdb.as_mut().expect("FATAL: Failed to load sortdb");
+        let sort_tip = SortitionDB::get_canonical_burn_chain_tip(sort_db.conn())
+            .map_err(|_| NakamotoNodeError::SnapshotNotFoundForChainTip)?;
+
+        let parent_vrf_proof =
+            NakamotoChainState::get_block_vrf_proof(chain_state.db(), &target_ch)
+                .map_err(|_e| NakamotoNodeError::ParentNotFound)?
+                .unwrap_or_else(|| VRFProof::empty());
+
+        // let's figure out the recipient set!
+        let recipients = get_next_recipients(
+            &sort_tip,
+            chain_state,
+            sort_db,
+            &self.burnchain,
+            &OnChainRewardSetProvider(),
+            self.config.node.always_use_affirmation_maps,
+        )
+        .map_err(|e| {
+            error!("Relayer: Failure fetching recipient set: {:?}", e);
+            NakamotoNodeError::SnapshotNotFoundForChainTip
+        })?;
+
+        let block_header =
+            NakamotoChainState::get_block_header_by_consensus_hash(chain_state.db(), target_ch)
+                .map_err(|e| {
+                    error!("Relayer: Failed to get block header for parent tenure: {e:?}");
+                    NakamotoNodeError::ParentNotFound
+                })?
+                .ok_or_else(|| {
+                    error!("Relayer: Failed to find block header for parent tenure");
+                    NakamotoNodeError::ParentNotFound
+                })?;
+
+        let parent_block_id = block_header.index_block_hash();
+        if parent_block_id != StacksBlockId::new(target_ch, target_bh) {
+            error!("Relayer: Found block header for parent tenure, but mismatched block id";
+                   "expected_block_id" => %StacksBlockId::new(target_ch, target_bh),
+                   "found_block_id" => %parent_block_id);
+            return Err(NakamotoNodeError::UnexpectedChainState);
+        }
+
+        let Ok(Some(parent_sortition)) =
+            SortitionDB::get_block_snapshot_consensus(sort_db.conn(), target_ch)
+        else {
+            error!("Relayer: Failed to lookup the block snapshot of parent tenure ID"; "tenure_consensus_hash" => %target_ch);
+            return Err(NakamotoNodeError::ParentNotFound);
+        };
+
+        let Ok(Some(target_epoch)) =
+            SortitionDB::get_stacks_epoch(sort_db.conn(), sort_tip.block_height + 1)
+        else {
+            error!("Relayer: Failed to lookup its epoch"; "target_height" => sort_tip.block_height + 1);
+            return Err(NakamotoNodeError::SnapshotNotFoundForChainTip);
+        };
+
+        let parent_block_burn_height = parent_sortition.block_height;
+        let Ok(Some(parent_winning_tx)) = SortitionDB::get_block_commit(
+            sort_db.conn(),
+            &parent_sortition.winning_block_txid,
+            &parent_sortition.sortition_id,
+        ) else {
+            error!("Relayer: Failed to lookup the block commit of parent tenure ID"; "tenure_consensus_hash" => %target_ch);
+            return Err(NakamotoNodeError::SnapshotNotFoundForChainTip);
+        };
+
+        let parent_winning_vtxindex = parent_winning_tx.vtxindex;
+
+        // let burn_fee_cap = self.config.burnchain.burn_fee_cap;
+        let burn_fee_cap = get_mining_spend_amount(self.globals.get_miner_status());
+        let sunset_burn = self.burnchain.expected_sunset_burn(
+            sort_tip.block_height + 1,
+            burn_fee_cap,
+            target_epoch.epoch_id,
+        );
+        let rest_commit = burn_fee_cap - sunset_burn;
+
+        let commit_outs = if !self
+            .burnchain
+            .pox_constants
+            .is_after_pox_sunset_end(sort_tip.block_height, target_epoch.epoch_id)
+            && !self
+                .burnchain
+                .is_in_prepare_phase(sort_tip.block_height + 1)
+        {
+            RewardSetInfo::into_commit_outs(recipients, self.config.is_mainnet())
+        } else {
+            vec![PoxAddress::standard_burn_address(self.config.is_mainnet())]
+        };
+
+        // let's commit, but target the current burnchain tip with our modulus
+        let burn_parent_modulus = u8::try_from(sort_tip.block_height % BURN_BLOCK_MINED_AT_MODULUS)
+            .map_err(|_| {
+                error!("Relayer: Block mining modulus is not u8");
+                NakamotoNodeError::UnexpectedChainState
+            })?;
+        let sender = self.keychain.get_burnchain_signer();
+        let key = self
+            .globals
+            .get_leader_key_registration_state()
+            .get_active()
+            .ok_or_else(|| NakamotoNodeError::NoVRFKeyActive)?;
+        let op = LeaderBlockCommitOp {
+            sunset_burn,
+            block_header_hash: BlockHeaderHash(parent_block_id.0),
+            burn_fee: rest_commit,
+            input: (Txid([0; 32]), 0),
+            apparent_sender: sender,
+            key_block_ptr: u32::try_from(key.block_height)
+                .expect("FATAL: burn block height exceeded u32"),
+            key_vtxindex: u16::try_from(key.op_vtxindex).expect("FATAL: vtxindex exceeded u16"),
+            memo: vec![STACKS_EPOCH_3_0_MARKER],
+            new_seed: VRFSeed::from_proof(&parent_vrf_proof),
+            parent_block_ptr: u32::try_from(parent_block_burn_height)
+                .expect("FATAL: burn block height exceeded u32"),
+            parent_vtxindex: u16::try_from(parent_winning_vtxindex)
+                .expect("FATAL: vtxindex exceeded u16"),
+            vtxindex: 0,
+            txid: Txid([0u8; 32]),
+            block_height: 0,
+            burn_header_hash: BurnchainHeaderHash::zero(),
+            burn_parent_modulus,
+            commit_outs,
+        };
+
+        Ok((sort_tip, target_epoch.epoch_id, op))
+    }
+
+    /// Create the block miner thread state.
+    /// Only proceeds if all of the following are true:
+    /// * the miner is not blocked
+    /// * last_burn_block corresponds to the canonical sortition DB's chain tip
+    /// * the time of issuance is sufficiently recent
+    /// * there are no unprocessed stacks blocks in the staging DB
+    /// * the relayer has already tried a download scan that included this sortition (which, if a
+    /// block was found, would have placed it into the staging DB and marked it as
+    /// unprocessed)
+    /// * a miner thread is not running already
+    fn create_block_miner(
+        &mut self,
+        registered_key: RegisteredKey,
+        last_burn_block: BlockSnapshot,
+        parent_tenure_id: StacksBlockId,
+    ) -> Result<BlockMinerThread, NakamotoNodeError> {
+        if fault_injection_skip_mining(&self.config.node.rpc_bind, last_burn_block.block_height) {
+            debug!(
+                "Relayer: fault injection skip mining at block height {}",
+                last_burn_block.block_height
+            );
+            return Err(NakamotoNodeError::FaultInjection);
+        }
+
+        let burn_header_hash = last_burn_block.burn_header_hash.clone();
+        let burn_chain_sn = SortitionDB::get_canonical_burn_chain_tip(self.sortdb_ref().conn())
+            .expect("FATAL: failed to query sortition DB for canonical burn chain tip");
+
+        let burn_chain_tip = burn_chain_sn.burn_header_hash.clone();
+
+        if burn_chain_tip != burn_header_hash {
+            debug!(
+                "Relayer: Drop stale RunTenure for {}: current sortition is for {}",
+                &burn_header_hash, &burn_chain_tip
+            );
+            self.globals.counters.bump_missed_tenures();
+            return Err(NakamotoNodeError::MissedMiningOpportunity);
+        }
+
+        debug!(
+            "Relayer: Spawn tenure thread";
+            "height" => last_burn_block.block_height,
+            "burn_header_hash" => %burn_header_hash,
+        );
+
+        let miner_thread_state =
+            BlockMinerThread::new(self, registered_key, last_burn_block, parent_tenure_id);
+        Ok(miner_thread_state)
+    }
+
+    fn start_new_tenure(
+        &mut self,
+        parent_tenure_start: StacksBlockId,
+        burn_tip: BlockSnapshot,
+    ) -> Result<(), NakamotoNodeError> {
+        // when starting a new tenure, block the mining thread if its currently running.
+        // the new mining thread will join it (so that the new mining thread stalls, not the relayer)
+        let prior_tenure_thread = self.miner_thread.take();
+        let vrf_key = self
+            .globals
+            .get_leader_key_registration_state()
+            .get_active()
+            .ok_or_else(|| {
+                warn!("Trying to start new tenure, but no VRF key active");
+                NakamotoNodeError::NoVRFKeyActive
+            })?;
+        let new_miner_state = self.create_block_miner(vrf_key, burn_tip, parent_tenure_start)?;
+
+        let new_miner_handle = std::thread::Builder::new()
+            .name(format!("miner-{}", self.local_peer.data_url))
+            .stack_size(BLOCK_PROCESSOR_STACK_SIZE)
+            .spawn(move || new_miner_state.run_miner(prior_tenure_thread))
+            .map_err(|e| {
+                error!("Relayer: Failed to start tenure thread: {:?}", &e);
+                NakamotoNodeError::SpawnError(e)
+            })?;
+
+        self.miner_thread.replace(new_miner_handle);
+
+        Ok(())
+    }
+
+    fn stop_tenure(&mut self) -> Result<(), NakamotoNodeError> {
+        // when stopping a tenure, block the mining thread if its currently running, then join it.
+        // do this in a new thread will (so that the new thread stalls, not the relayer)
+        let Some(prior_tenure_thread) = self.miner_thread.take() else {
+            return Ok(());
+        };
+        let globals = self.globals.clone();
+
+        let stop_handle = std::thread::Builder::new()
+            .name(format!("tenure-stop-{}", self.local_peer.data_url))
+            .spawn(move || BlockMinerThread::stop_miner(&globals, prior_tenure_thread))
+            .map_err(|e| {
+                error!("Relayer: Failed to spawn a stop-tenure thread: {:?}", &e);
+                NakamotoNodeError::SpawnError(e)
+            })?;
+
+        self.miner_thread.replace(stop_handle);
+
+        Ok(())
+    }
+
+    fn handle_sortition(
+        &mut self,
+        consensus_hash: ConsensusHash,
+        burn_hash: BurnchainHeaderHash,
+        committed_index_hash: StacksBlockId,
+    ) -> bool {
+        let miner_instruction =
+            self.process_sortition(consensus_hash, burn_hash, committed_index_hash);
+
+        match miner_instruction {
+            MinerDirective::BeginTenure {
+                parent_tenure_start,
+                burnchain_tip,
+            } => {
+                let _ = self.start_new_tenure(parent_tenure_start, burnchain_tip);
+            }
+            MinerDirective::ContinueTenure { new_burn_view: _ } => {
+                // TODO: in this case, we eventually want to undergo a tenure
+                //  change to switch to the new burn view, but right now, we will
+                //  simply end our current tenure if it exists
+                let _ = self.stop_tenure();
+            }
+            MinerDirective::StopTenure => {
+                let _ = self.stop_tenure();
+            }
+        }
+
+        true
+    }
+
+    fn issue_block_commit(
+        &mut self,
+        tenure_start_ch: ConsensusHash,
+        tenure_start_bh: BlockHeaderHash,
+    ) -> Result<(), NakamotoNodeError> {
+        let (last_committed_at, target_epoch_id, commit) =
+            self.make_block_commit(&tenure_start_ch, &tenure_start_bh)?;
+        let mut op_signer = self.keychain.generate_op_signer();
+        let txid = self
+            .bitcoin_controller
+            .submit_operation(
+                target_epoch_id,
+                BlockstackOperationType::LeaderBlockCommit(commit),
+                &mut op_signer,
+                1,
+            )
+            .ok_or_else(|| {
+                warn!("Failed to submit block-commit bitcoin transaction");
+                NakamotoNodeError::BurnchainSubmissionFailed
+            })?;
+        info!(
+            "Relayer: Submitted block-commit";
+            "parent_consensus_hash" => %tenure_start_ch,
+            "parent_block_hash" => %tenure_start_bh,
+            "txid" => %txid,
+        );
+
+        self.last_commits.insert(txid, ());
+        self.last_committed_at = Some(last_committed_at);
+        self.globals.counters.bump_naka_submitted_commits();
+
+        Ok(())
+    }
+
+    fn initiative(&mut self) -> Option<RelayerDirective> {
+        if !self.is_miner {
+            return None;
+        }
+
+        // TODO (nakamoto): the miner shouldn't issue either of these directives
+        //   if we're still in IBD!
+
+        // do we need a VRF key registration?
+        if matches!(
+            self.globals.get_leader_key_registration_state(),
+            LeaderKeyRegistrationState::Inactive
+        ) {
+            let Ok(sort_tip) = SortitionDB::get_canonical_burn_chain_tip(self.sortdb_ref().conn())
+            else {
+                warn!("Failed to fetch sortition tip while needing to register VRF key");
+                return None;
+            };
+            return Some(RelayerDirective::RegisterKey(sort_tip));
+        }
+
+        // are we still waiting on a pending registration?
+        if !matches!(
+            self.globals.get_leader_key_registration_state(),
+            LeaderKeyRegistrationState::Active(_)
+        ) {
+            return None;
+        }
+
+        // has there been a new sortition
+        let Ok(sort_tip) = SortitionDB::get_canonical_burn_chain_tip(self.sortdb_ref().conn())
+        else {
+            return None;
+        };
+
+        let should_commit = if let Some(last_committed_at) = self.last_committed_at.as_ref() {
+            // if the new sortition tip has a different consesus hash than the last commit,
+            //  issue a new commit
+            sort_tip.consensus_hash != last_committed_at.consensus_hash
+        } else {
+            // if there was no last commit, issue a new commit
+            true
+        };
+
+        let Ok(Some(chain_tip_header)) = NakamotoChainState::get_canonical_block_header(
+            self.chainstate_ref().db(),
+            self.sortdb_ref(),
+        ) else {
+            info!("No known canonical tip, will issue a genesis block commit");
+            return Some(RelayerDirective::NakamotoTenureStartProcessed(
+                FIRST_BURNCHAIN_CONSENSUS_HASH,
+                FIRST_STACKS_BLOCK_HASH,
+            ));
+        };
+
+        if should_commit {
+            // TODO: just use `get_block_header_by_consensus_hash`?
+            let first_block_hash = if chain_tip_header
+                .anchored_header
+                .as_stacks_nakamoto()
+                .is_some()
+            {
+                // if the parent block is a nakamoto block, find the starting block of its tenure
+                let Ok(Some(first_block)) =
+                    NakamotoChainState::get_nakamoto_tenure_start_block_header(
+                        self.chainstate_ref().db(),
+                        &chain_tip_header.consensus_hash,
+                    )
+                else {
+                    warn!("Failure getting the first block of tenure in order to assemble block commit";
+                          "tenure_consensus_hash" => %chain_tip_header.consensus_hash,
+                          "tip_block_hash" => %chain_tip_header.anchored_header.block_hash());
+                    return None;
+                };
+                first_block.anchored_header.block_hash()
+            } else {
+                // otherwise the parent block is a epoch2 block, just return its hash directly
+                chain_tip_header.anchored_header.block_hash()
+            };
+            return Some(RelayerDirective::NakamotoTenureStartProcessed(
+                chain_tip_header.consensus_hash,
+                first_block_hash,
+            ));
+        }
+
+        return None;
+    }
+
+    /// Main loop of the relayer.
+    /// Runs in a separate thread.
+    /// Continuously receives
+    pub fn main(mut self, relay_rcv: Receiver<RelayerDirective>) {
+        debug!("relayer thread ID is {:?}", std::thread::current().id());
+
+        self.next_initiative = Instant::now() + Duration::from_secs(10);
+        while self.globals.keep_running() {
+            let directive = if Instant::now() >= self.next_initiative {
+                self.next_initiative = Instant::now() + Duration::from_secs(10);
+                self.initiative()
+            } else {
+                None
+            };
+
+            let Some(timeout) = self.next_initiative.checked_duration_since(Instant::now()) else {
+                // next_initiative timeout occurred, so go to next loop iteration.
+                continue;
+            };
+
+            let directive = if let Some(directive) = directive {
+                directive
+            } else {
+                match relay_rcv.recv_timeout(timeout) {
+                    Ok(directive) => directive,
+                    // timed out, so go to next loop iteration
+                    Err(RecvTimeoutError::Timeout) => continue,
+                    Err(RecvTimeoutError::Disconnected) => break,
+                }
+            };
+
+            if !self.handle_directive(directive) {
+                break;
+            }
+        }
+
+        // kill miner if it's running
+        signal_mining_blocked(self.globals.get_miner_status());
+
+        // set termination flag so other threads die
+        self.globals.signal_stop();
+
+        debug!("Relayer exit!");
+    }
+
+    /// Top-level dispatcher
+    pub fn handle_directive(&mut self, directive: RelayerDirective) -> bool {
+        let continue_running = match directive {
+            RelayerDirective::HandleNetResult(net_result) => {
+                debug!("Relayer: directive Handle network result");
+                self.process_network_result(net_result);
+                debug!("Relayer: directive Handled network result");
+                true
+            }
+            // RegisterKey directives mean that the relayer should try to register a new VRF key.
+            // These are triggered by the relayer waking up without an active VRF key.
+            RelayerDirective::RegisterKey(last_burn_block) => {
+                if !self.is_miner {
+                    return true;
+                }
+                debug!("Relayer: directive Register VRF key");
+                self.rotate_vrf_and_register(&last_burn_block);
+                self.globals.counters.bump_blocks_processed();
+                debug!("Relayer: directive Registered VRF key");
+                true
+            }
+            // ProcessTenure directives correspond to a new sortition occurring.
+            //  relayer should invoke `handle_sortition` to determine if they won the sortition,
+            //  and to start their miner, or stop their miner if an active tenure is now ending
+            RelayerDirective::ProcessTenure(consensus_hash, burn_hash, block_header_hash) => {
+                if !self.is_miner {
+                    return true;
+                }
+                info!("Relayer: directive Process tenures");
+                let res = self.handle_sortition(
+                    consensus_hash,
+                    burn_hash,
+                    StacksBlockId(block_header_hash.0),
+                );
+                info!("Relayer: directive Processed tenures");
+                res
+            }
+            // NakamotoTenureStartProcessed directives mean that a new tenure start has been processed
+            // These are triggered by the relayer waking up, seeing a new consensus hash *and* a new first tenure block
+            RelayerDirective::NakamotoTenureStartProcessed(consensus_hash, block_hash) => {
+                if !self.is_miner {
+                    return true;
+                }
+                debug!("Relayer: Nakamoto Tenure Start");
+                if let Err(e) = self.issue_block_commit(consensus_hash, block_hash) {
+                    warn!("Relayer failed to issue block commit"; "err" => ?e);
+                }
+                debug!("Relayer: Nakamoto Tenure Start");
+                true
+            }
+            RelayerDirective::RunTenure(..) => {
+                // No Op: the nakamoto node does not use the RunTenure directive to control its
+                //   miner thread.
+                true
+            }
+            RelayerDirective::Exit => false,
+        };
+
+        continue_running
+    }
+}
diff --git a/testnet/stacks-node/src/neon_node.rs b/testnet/stacks-node/src/neon_node.rs
index 5ef68a4c28..c23bf1fc19 100644
--- a/testnet/stacks-node/src/neon_node.rs
+++ b/testnet/stacks-node/src/neon_node.rs
@@ -142,9 +142,7 @@ use std::collections::{HashMap, VecDeque};
 use std::convert::{TryFrom, TryInto};
 use std::default::Default;
 use std::net::SocketAddr;
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::mpsc::{Receiver, SyncSender, TrySendError};
-use std::sync::{Arc, Mutex};
+use std::sync::mpsc::{Receiver, TrySendError};
 use std::thread::JoinHandle;
 use std::time::Duration;
 use std::{mem, thread};
@@ -162,15 +160,13 @@ use stacks::chainstate::burn::operations::{
     BlockstackOperationType, LeaderBlockCommitOp, LeaderKeyRegisterOp,
 };
 use stacks::chainstate::burn::{BlockSnapshot, ConsensusHash};
-use stacks::chainstate::coordinator::comm::CoordinatorChannels;
 use stacks::chainstate::coordinator::{get_next_recipients, OnChainRewardSetProvider};
 use stacks::chainstate::nakamoto::NakamotoChainState;
 use stacks::chainstate::stacks::address::PoxAddress;
-use stacks::chainstate::stacks::db::unconfirmed::UnconfirmedTxMap;
 use stacks::chainstate::stacks::db::{StacksChainState, StacksHeaderInfo, MINER_REWARD_MATURITY};
 use stacks::chainstate::stacks::miner::{
     get_mining_spend_amount, signal_mining_blocked, signal_mining_ready, BlockBuilderSettings,
-    MinerStatus, StacksMicroblockBuilder,
+    StacksMicroblockBuilder,
 };
 use stacks::chainstate::stacks::{
     CoinbasePayload, Error as ChainstateError, StacksBlock, StacksBlockBuilder, StacksBlockHeader,
@@ -210,9 +206,10 @@ use crate::burnchains::bitcoin_regtest_controller::{
     addr2str, BitcoinRegtestController, OngoingBlockCommit,
 };
 use crate::burnchains::make_bitcoin_indexer;
-use crate::run_loop::neon::{Counters, RunLoop};
+use crate::globals::Globals;
+use crate::globals::RelayerDirective;
+use crate::run_loop::neon::RunLoop;
 use crate::run_loop::RegisteredKey;
-use crate::syncctl::PoxSyncWatchdogComms;
 use crate::ChainTip;
 
 pub const RELAYER_MAX_BUFFER: usize = 100;
@@ -256,44 +253,6 @@ struct AssembledAnchorBlock {
     tenure_begin: u128,
 }
 
-/// Command types for the relayer thread, issued to it by other threads
-pub enum RelayerDirective {
-    /// Handle some new data that arrived on the network (such as blocks, transactions, and
-    /// microblocks)
-    HandleNetResult(NetworkResult),
-    /// Announce a new sortition.  Process and broadcast the block if we won.
-    ProcessTenure(ConsensusHash, BurnchainHeaderHash, BlockHeaderHash),
-    /// Try to mine a block
-    RunTenure(RegisteredKey, BlockSnapshot, u128), // (vrf key, chain tip, time of issuance in ms)
-    /// Try to register a VRF public key
-    RegisterKey(BlockSnapshot),
-    /// Stop the relayer thread
-    Exit,
-}
-
-/// Inter-thread communication structure, shared between threads
-#[derive(Clone)]
-pub struct Globals {
-    /// Last sortition processed
-    last_sortition: Arc<Mutex<Option<BlockSnapshot>>>,
-    /// Status of the miner
-    miner_status: Arc<Mutex<MinerStatus>>,
-    /// Communication link to the coordinator thread
-    coord_comms: CoordinatorChannels,
-    /// Unconfirmed transactions (shared between the relayer and p2p threads)
-    unconfirmed_txs: Arc<Mutex<UnconfirmedTxMap>>,
-    /// Writer endpoint to the relayer thread
-    relay_send: SyncSender<RelayerDirective>,
-    /// Cointer state in the main thread
-    counters: Counters,
-    /// Connection to the PoX sync watchdog
-    sync_comms: PoxSyncWatchdogComms,
-    /// Global flag to see if we should keep running
-    pub should_keep_running: Arc<AtomicBool>,
-    /// Status of our VRF key registration state (shared between the main thread and the relayer)
-    leader_key_registration_state: Arc<Mutex<LeaderKeyRegistrationState>>,
-}
-
 /// Miner chain tip, on top of which to build microblocks
 #[derive(Debug, Clone, PartialEq)]
 pub struct MinerTip {
@@ -327,205 +286,6 @@ impl MinerTip {
     }
 }
 
-impl Globals {
-    pub fn new(
-        coord_comms: CoordinatorChannels,
-        miner_status: Arc<Mutex<MinerStatus>>,
-        relay_send: SyncSender<RelayerDirective>,
-        counters: Counters,
-        sync_comms: PoxSyncWatchdogComms,
-        should_keep_running: Arc<AtomicBool>,
-    ) -> Globals {
-        Globals {
-            last_sortition: Arc::new(Mutex::new(None)),
-            miner_status,
-            coord_comms,
-            unconfirmed_txs: Arc::new(Mutex::new(UnconfirmedTxMap::new())),
-            relay_send,
-            counters,
-            sync_comms,
-            should_keep_running,
-            leader_key_registration_state: Arc::new(Mutex::new(
-                LeaderKeyRegistrationState::Inactive,
-            )),
-        }
-    }
-
-    /// Get the last sortition processed by the relayer thread
-    pub fn get_last_sortition(&self) -> Option<BlockSnapshot> {
-        match self.last_sortition.lock() {
-            Ok(sort_opt) => sort_opt.clone(),
-            Err(_) => {
-                error!("Sortition mutex poisoned!");
-                panic!();
-            }
-        }
-    }
-
-    /// Set the last sortition processed
-    pub fn set_last_sortition(&self, block_snapshot: BlockSnapshot) {
-        match self.last_sortition.lock() {
-            Ok(mut sortition_opt) => {
-                sortition_opt.replace(block_snapshot);
-            }
-            Err(_) => {
-                error!("Sortition mutex poisoned!");
-                panic!();
-            }
-        };
-    }
-
-    /// Get the status of the miner (blocked or ready)
-    pub fn get_miner_status(&self) -> Arc<Mutex<MinerStatus>> {
-        self.miner_status.clone()
-    }
-
-    /// Get the main thread's counters
-    pub fn get_counters(&self) -> Counters {
-        self.counters.clone()
-    }
-
-    /// Called by the relayer to pass unconfirmed txs to the p2p thread, so the p2p thread doesn't
-    /// need to do the disk I/O needed to instantiate the unconfirmed state trie they represent.
-    /// Clears the unconfirmed transactions, and replaces them with the chainstate's.
-    pub fn send_unconfirmed_txs(&self, chainstate: &StacksChainState) {
-        if let Some(ref unconfirmed) = chainstate.unconfirmed_state {
-            match self.unconfirmed_txs.lock() {
-                Ok(mut txs) => {
-                    txs.clear();
-                    txs.extend(unconfirmed.mined_txs.clone());
-                }
-                Err(e) => {
-                    // can only happen due to a thread panic in the relayer
-                    error!("FATAL: unconfirmed tx arc mutex is poisoned: {:?}", &e);
-                    panic!();
-                }
-            };
-        }
-    }
-
-    /// Called by the p2p thread to accept the unconfirmed tx state processed by the relayer.
-    /// Puts the shared unconfirmed transactions to chainstate.
-    pub fn recv_unconfirmed_txs(&self, chainstate: &mut StacksChainState) {
-        if let Some(ref mut unconfirmed) = chainstate.unconfirmed_state {
-            match self.unconfirmed_txs.lock() {
-                Ok(txs) => {
-                    unconfirmed.mined_txs.clear();
-                    unconfirmed.mined_txs.extend(txs.clone());
-                }
-                Err(e) => {
-                    // can only happen due to a thread panic in the relayer
-                    error!("FATAL: unconfirmed arc mutex is poisoned: {:?}", &e);
-                    panic!();
-                }
-            };
-        }
-    }
-
-    /// Signal system-wide stop
-    pub fn signal_stop(&self) {
-        self.should_keep_running.store(false, Ordering::SeqCst);
-    }
-
-    /// Should we keep running?
-    pub fn keep_running(&self) -> bool {
-        self.should_keep_running.load(Ordering::SeqCst)
-    }
-
-    /// Get the handle to the coordinator
-    pub fn coord(&self) -> &CoordinatorChannels {
-        &self.coord_comms
-    }
-
-    /// Get the current leader key registration state.
-    /// Called from the runloop thread and relayer thread.
-    fn get_leader_key_registration_state(&self) -> LeaderKeyRegistrationState {
-        match self.leader_key_registration_state.lock() {
-            Ok(state) => (*state).clone(),
-            Err(e) => {
-                // can only happen due to a thread panic in the relayer
-                error!("FATAL: leader key registration mutex is poisoned: {:?}", &e);
-                panic!();
-            }
-        }
-    }
-
-    /// Set the initial leader key registration state.
-    /// Called from the runloop thread when booting up.
-    fn set_initial_leader_key_registration_state(&self, new_state: LeaderKeyRegistrationState) {
-        match self.leader_key_registration_state.lock() {
-            Ok(mut state) => {
-                *state = new_state;
-            }
-            Err(e) => {
-                // can only happen due to a thread panic in the relayer
-                error!("FATAL: leader key registration mutex is poisoned: {:?}", &e);
-                panic!();
-            }
-        }
-    }
-
-    /// Advance the leader key registration state to pending, given a txid we just sent.
-    /// Only the relayer thread calls this.
-    fn set_pending_leader_key_registration(&self, target_block_height: u64, txid: Txid) {
-        match self.leader_key_registration_state.lock() {
-            Ok(ref mut leader_key_registration_state) => {
-                **leader_key_registration_state =
-                    LeaderKeyRegistrationState::Pending(target_block_height, txid);
-            }
-            Err(_e) => {
-                error!("FATAL: failed to lock leader key registration state mutex");
-                panic!();
-            }
-        }
-    }
-
-    /// Advance the leader key registration state to active, given the VRF key registration ops
-    /// we've discovered in a given snapshot.
-    /// The runloop thread calls this whenever it processes a sortition.
-    pub fn try_activate_leader_key_registration(
-        &self,
-        burn_block_height: u64,
-        key_registers: Vec<LeaderKeyRegisterOp>,
-    ) -> bool {
-        let mut activated = false;
-        match self.leader_key_registration_state.lock() {
-            Ok(ref mut leader_key_registration_state) => {
-                for op in key_registers.into_iter() {
-                    if let LeaderKeyRegistrationState::Pending(target_block_height, txid) =
-                        **leader_key_registration_state
-                    {
-                        info!(
-                            "Received burnchain block #{} including key_register_op - {}",
-                            burn_block_height, txid
-                        );
-                        if txid == op.txid {
-                            **leader_key_registration_state =
-                                LeaderKeyRegistrationState::Active(RegisteredKey {
-                                    target_block_height,
-                                    vrf_public_key: op.public_key,
-                                    block_height: u64::from(op.block_height),
-                                    op_vtxindex: u32::from(op.vtxindex),
-                                });
-                            activated = true;
-                        } else {
-                            debug!(
-                                "key_register_op {} does not match our pending op {}",
-                                txid, &op.txid
-                            );
-                        }
-                    }
-                }
-            }
-            Err(_e) => {
-                error!("FATAL: failed to lock leader key registration state mutex");
-                panic!();
-            }
-        }
-        activated
-    }
-}
-
 /// Node implementation for both miners and followers.
 /// This struct is used to set up the node proper and launch the p2p thread and relayer thread.
 /// It is further used by the main thread to communicate with these two threads.
@@ -653,7 +413,7 @@ struct ParentStacksBlockInfo {
 }
 
 #[derive(Clone)]
-enum LeaderKeyRegistrationState {
+pub enum LeaderKeyRegistrationState {
     /// Not started yet
     Inactive,
     /// Waiting for burnchain confirmation
@@ -664,6 +424,16 @@ enum LeaderKeyRegistrationState {
     Active(RegisteredKey),
 }
 
+impl LeaderKeyRegistrationState {
+    pub fn get_active(&self) -> Option<RegisteredKey> {
+        if let Self::Active(registered_key) = self {
+            Some(registered_key.clone())
+        } else {
+            None
+        }
+    }
+}
+
 /// Relayer thread
 /// * accepts network results and stores blocks and microblocks
 /// * forwards new blocks, microblocks, and transactions to the p2p thread
@@ -3407,6 +3177,10 @@ impl RelayerThread {
                 debug!("Relayer: directive Ran tenure");
                 true
             }
+            RelayerDirective::NakamotoTenureStartProcessed(_, _) => {
+                warn!("Relayer: Nakamoto tenure start notification received while still operating 2.x neon node");
+                true
+            }
             RelayerDirective::Exit => false,
         };
         if !continue_running {
diff --git a/testnet/stacks-node/src/run_loop/mod.rs b/testnet/stacks-node/src/run_loop/mod.rs
index c7aaf87b56..abfbe37c37 100644
--- a/testnet/stacks-node/src/run_loop/mod.rs
+++ b/testnet/stacks-node/src/run_loop/mod.rs
@@ -1,4 +1,5 @@
 pub mod helium;
+pub mod nakamoto;
 pub mod neon;
 
 use clarity::vm::costs::ExecutionCost;
diff --git a/testnet/stacks-node/src/run_loop/nakamoto.rs b/testnet/stacks-node/src/run_loop/nakamoto.rs
new file mode 100644
index 0000000000..f758a65d33
--- /dev/null
+++ b/testnet/stacks-node/src/run_loop/nakamoto.rs
@@ -0,0 +1,1029 @@
+use std::sync::atomic::AtomicBool;
+use std::sync::mpsc::sync_channel;
+use std::sync::{Arc, Mutex};
+use std::thread::JoinHandle;
+use std::{cmp, thread};
+
+use stacks::burnchains::bitcoin::address::{BitcoinAddress, LegacyBitcoinAddressType};
+use stacks::burnchains::Burnchain;
+use stacks::chainstate::burn::db::sortdb::SortitionDB;
+use stacks::chainstate::burn::BlockSnapshot;
+use stacks::chainstate::coordinator::comm::{CoordinatorChannels, CoordinatorReceivers};
+use stacks::chainstate::coordinator::{
+    static_get_canonical_affirmation_map, static_get_heaviest_affirmation_map,
+    static_get_stacks_tip_affirmation_map, ChainsCoordinator, ChainsCoordinatorConfig,
+    CoordinatorCommunication,
+};
+use stacks::chainstate::stacks::db::{ChainStateBootData, StacksChainState};
+use stacks::chainstate::stacks::miner::{signal_mining_blocked, signal_mining_ready, MinerStatus};
+use stacks::core::StacksEpochId;
+use stacks::net::atlas::{AtlasConfig, AtlasDB, Attachment};
+use stacks_common::types::PublicKey;
+use stacks_common::util::hash::Hash160;
+use stacks_common::util::{get_epoch_time_secs, sleep_ms};
+use stx_genesis::GenesisData;
+
+use super::RunLoopCallbacks;
+use crate::burnchains::make_bitcoin_indexer;
+use crate::globals::Globals;
+use crate::monitoring::start_serving_monitoring_metrics;
+use crate::nakamoto_node::{StacksNode, BLOCK_PROCESSOR_STACK_SIZE, RELAYER_MAX_BUFFER};
+use crate::neon::RunLoopCounter;
+use crate::node::{
+    get_account_balances, get_account_lockups, get_names, get_namespaces,
+    use_test_genesis_chainstate,
+};
+use crate::run_loop::neon;
+use crate::run_loop::neon::Counters;
+use crate::syncctl::{PoxSyncWatchdog, PoxSyncWatchdogComms};
+use crate::{
+    run_loop, BitcoinRegtestController, BurnchainController, Config, EventDispatcher, Keychain,
+};
+
+pub const STDERR: i32 = 2;
+
+#[cfg(test)]
+const UNCONDITIONAL_CHAIN_LIVENESS_CHECK: u64 = 30;
+
+#[cfg(not(test))]
+const UNCONDITIONAL_CHAIN_LIVENESS_CHECK: u64 = 300;
+
+/// Coordinating a node running in neon mode.
+pub struct RunLoop {
+    config: Config,
+    pub callbacks: RunLoopCallbacks,
+    globals: Option<Globals>,
+    counters: Counters,
+    coordinator_channels: Option<(CoordinatorReceivers, CoordinatorChannels)>,
+    should_keep_running: Arc<AtomicBool>,
+    event_dispatcher: EventDispatcher,
+    pox_watchdog: Option<PoxSyncWatchdog>, // can't be instantiated until .start() is called
+    is_miner: Option<bool>,                // not known until .start() is called
+    burnchain: Option<Burnchain>,          // not known until .start() is called
+    pox_watchdog_comms: PoxSyncWatchdogComms,
+    /// NOTE: this is duplicated in self.globals, but it needs to be accessible before globals is
+    /// instantiated (namely, so the test framework can access it).
+    miner_status: Arc<Mutex<MinerStatus>>,
+}
+
+impl RunLoop {
+    /// Sets up a runloop and node, given a config.
+    pub fn new(config: Config) -> Self {
+        let channels = CoordinatorCommunication::instantiate();
+        let should_keep_running = Arc::new(AtomicBool::new(true));
+        let pox_watchdog_comms = PoxSyncWatchdogComms::new(should_keep_running.clone());
+        let miner_status = Arc::new(Mutex::new(MinerStatus::make_ready(
+            config.burnchain.burn_fee_cap,
+        )));
+
+        let mut event_dispatcher = EventDispatcher::new();
+        for observer in config.events_observers.iter() {
+            event_dispatcher.register_observer(observer);
+        }
+
+        Self {
+            config,
+            globals: None,
+            coordinator_channels: Some(channels),
+            callbacks: RunLoopCallbacks::new(),
+            counters: Counters::new(),
+            should_keep_running,
+            event_dispatcher,
+            pox_watchdog: None,
+            is_miner: None,
+            burnchain: None,
+            pox_watchdog_comms,
+            miner_status,
+        }
+    }
+
+    pub fn get_globals(&self) -> Globals {
+        self.globals
+            .clone()
+            .expect("FATAL: globals not instantiated")
+    }
+
+    fn set_globals(&mut self, globals: Globals) {
+        self.globals = Some(globals);
+    }
+
+    pub fn get_coordinator_channel(&self) -> Option<CoordinatorChannels> {
+        self.coordinator_channels.as_ref().map(|x| x.1.clone())
+    }
+
+    pub fn get_blocks_processed_arc(&self) -> RunLoopCounter {
+        self.counters.blocks_processed.clone()
+    }
+
+    pub fn submitted_commits(&self) -> RunLoopCounter {
+        self.counters.naka_submitted_commits.clone()
+    }
+
+    pub fn submitted_vrfs(&self) -> RunLoopCounter {
+        self.counters.naka_submitted_vrfs.clone()
+    }
+
+    pub fn mined_blocks(&self) -> RunLoopCounter {
+        self.counters.naka_mined_blocks.clone()
+    }
+
+    pub fn get_counters(&self) -> Counters {
+        self.counters.clone()
+    }
+
+    pub fn config(&self) -> &Config {
+        &self.config
+    }
+
+    pub fn get_event_dispatcher(&self) -> EventDispatcher {
+        self.event_dispatcher.clone()
+    }
+
+    pub fn is_miner(&self) -> bool {
+        self.is_miner.unwrap_or(false)
+    }
+
+    pub fn get_pox_sync_comms(&self) -> PoxSyncWatchdogComms {
+        self.pox_watchdog_comms.clone()
+    }
+
+    pub fn get_termination_switch(&self) -> Arc<AtomicBool> {
+        self.should_keep_running.clone()
+    }
+
+    pub fn get_burnchain(&self) -> Burnchain {
+        self.burnchain
+            .clone()
+            .expect("FATAL: tried to get runloop burnchain before calling .start()")
+    }
+
+    pub fn get_pox_watchdog(&mut self) -> &mut PoxSyncWatchdog {
+        self.pox_watchdog
+            .as_mut()
+            .expect("FATAL: tried to get PoX watchdog before calling .start()")
+    }
+
+    pub fn get_miner_status(&self) -> Arc<Mutex<MinerStatus>> {
+        self.miner_status.clone()
+    }
+
+    /// Determine if we're the miner.
+    /// If there's a network error, then assume that we're not a miner.
+    fn check_is_miner(&mut self, burnchain: &mut BitcoinRegtestController) -> bool {
+        if self.config.node.miner {
+            let keychain = Keychain::default(self.config.node.seed.clone());
+            let mut op_signer = keychain.generate_op_signer();
+            match burnchain.create_wallet_if_dne() {
+                Err(e) => warn!("Error when creating wallet: {:?}", e),
+                _ => {}
+            }
+            let mut btc_addrs = vec![(
+                StacksEpochId::Epoch2_05,
+                // legacy
+                BitcoinAddress::from_bytes_legacy(
+                    self.config.burnchain.get_bitcoin_network().1,
+                    LegacyBitcoinAddressType::PublicKeyHash,
+                    &Hash160::from_data(&op_signer.get_public_key().to_bytes()).0,
+                )
+                .expect("FATAL: failed to construct legacy bitcoin address"),
+            )];
+            if self.config.miner.segwit {
+                btc_addrs.push((
+                    StacksEpochId::Epoch21,
+                    // segwit p2wpkh
+                    BitcoinAddress::from_bytes_segwit_p2wpkh(
+                        self.config.burnchain.get_bitcoin_network().1,
+                        &Hash160::from_data(&op_signer.get_public_key().to_bytes_compressed()).0,
+                    )
+                    .expect("FATAL: failed to construct segwit p2wpkh address"),
+                ));
+            }
+
+            for (epoch_id, btc_addr) in btc_addrs.into_iter() {
+                info!("Miner node: checking UTXOs at address: {}", &btc_addr);
+                let utxos = burnchain.get_utxos(epoch_id, &op_signer.get_public_key(), 1, None, 0);
+                if utxos.is_none() {
+                    warn!("UTXOs not found for {}. If this is unexpected, please ensure that your bitcoind instance is indexing transactions for the address {} (importaddress)", btc_addr, btc_addr);
+                } else {
+                    info!("UTXOs found - will run as a Miner node");
+                    return true;
+                }
+            }
+            if self.config.node.mock_mining {
+                info!("No UTXOs found, but configured to mock mine");
+                return true;
+            } else {
+                return false;
+            }
+        } else {
+            info!("Will run as a Follower node");
+            false
+        }
+    }
+
+    /// Boot up the stacks chainstate.
+    /// Instantiate the chainstate and push out the boot receipts to observers
+    /// This is only public so we can test it.
+    pub fn boot_chainstate(&mut self, burnchain_config: &Burnchain) -> StacksChainState {
+        let use_test_genesis_data = use_test_genesis_chainstate(&self.config);
+
+        // load up genesis balances
+        let initial_balances = self
+            .config
+            .initial_balances
+            .iter()
+            .map(|e| (e.address.clone(), e.amount))
+            .collect();
+
+        // TODO (nakamoto-neon): check if we're trying to setup a self-signing network
+        //  and set the right genesis data
+
+        // instantiate chainstate
+        let mut boot_data = ChainStateBootData {
+            initial_balances,
+            post_flight_callback: None,
+            first_burnchain_block_hash: burnchain_config.first_block_hash,
+            first_burnchain_block_height: burnchain_config.first_block_height as u32,
+            first_burnchain_block_timestamp: burnchain_config.first_block_timestamp,
+            pox_constants: burnchain_config.pox_constants.clone(),
+            get_bulk_initial_lockups: Some(Box::new(move || {
+                get_account_lockups(use_test_genesis_data)
+            })),
+            get_bulk_initial_balances: Some(Box::new(move || {
+                get_account_balances(use_test_genesis_data)
+            })),
+            get_bulk_initial_namespaces: Some(Box::new(move || {
+                get_namespaces(use_test_genesis_data)
+            })),
+            get_bulk_initial_names: Some(Box::new(move || get_names(use_test_genesis_data))),
+        };
+
+        let (chain_state_db, receipts) = StacksChainState::open_and_exec(
+            self.config.is_mainnet(),
+            self.config.burnchain.chain_id,
+            &self.config.get_chainstate_path_str(),
+            Some(&mut boot_data),
+            Some(self.config.node.get_marf_opts()),
+        )
+        .unwrap();
+        run_loop::announce_boot_receipts(
+            &mut self.event_dispatcher,
+            &chain_state_db,
+            &burnchain_config.pox_constants,
+            &receipts,
+        );
+        chain_state_db
+    }
+
+    /// Instantiate the Stacks chain state and start the chains coordinator thread.
+    /// Returns the coordinator thread handle, and the receiving end of the coordinator's atlas
+    /// attachment channel.
+    fn spawn_chains_coordinator(
+        &mut self,
+        burnchain_config: &Burnchain,
+        coordinator_receivers: CoordinatorReceivers,
+        miner_status: Arc<Mutex<MinerStatus>>,
+    ) -> JoinHandle<()> {
+        let use_test_genesis_data = use_test_genesis_chainstate(&self.config);
+
+        // load up genesis Atlas attachments
+        let mut atlas_config = AtlasConfig::new(self.config.is_mainnet());
+        let genesis_attachments = GenesisData::new(use_test_genesis_data)
+            .read_name_zonefiles()
+            .into_iter()
+            .map(|z| Attachment::new(z.zonefile_content.as_bytes().to_vec()))
+            .collect();
+        atlas_config.genesis_attachments = Some(genesis_attachments);
+
+        let chain_state_db = self.boot_chainstate(burnchain_config);
+
+        // NOTE: re-instantiate AtlasConfig so we don't have to keep the genesis attachments around
+        let moved_atlas_config = self.config.atlas.clone();
+        let moved_config = self.config.clone();
+        let moved_burnchain_config = burnchain_config.clone();
+        let mut coordinator_dispatcher = self.event_dispatcher.clone();
+        let atlas_db = AtlasDB::connect(
+            moved_atlas_config.clone(),
+            &self.config.get_atlas_db_file_path(),
+            true,
+        )
+        .expect("Failed to connect Atlas DB during startup");
+        let coordinator_indexer =
+            make_bitcoin_indexer(&self.config, Some(self.should_keep_running.clone()));
+
+        let coordinator_thread_handle = thread::Builder::new()
+            .name(format!(
+                "chains-coordinator-{}",
+                &moved_config.node.rpc_bind
+            ))
+            .stack_size(BLOCK_PROCESSOR_STACK_SIZE)
+            .spawn(move || {
+                debug!(
+                    "chains-coordinator thread ID is {:?}",
+                    thread::current().id()
+                );
+                let mut cost_estimator = moved_config.make_cost_estimator();
+                let mut fee_estimator = moved_config.make_fee_estimator();
+
+                let coord_config = ChainsCoordinatorConfig {
+                    always_use_affirmation_maps: moved_config.node.always_use_affirmation_maps,
+                    require_affirmed_anchor_blocks: moved_config
+                        .node
+                        .require_affirmed_anchor_blocks,
+                    ..ChainsCoordinatorConfig::new()
+                };
+                ChainsCoordinator::run(
+                    coord_config,
+                    chain_state_db,
+                    moved_burnchain_config,
+                    &mut coordinator_dispatcher,
+                    coordinator_receivers,
+                    moved_atlas_config,
+                    cost_estimator.as_deref_mut(),
+                    fee_estimator.as_deref_mut(),
+                    miner_status,
+                    coordinator_indexer,
+                    atlas_db,
+                );
+            })
+            .expect("FATAL: failed to start chains coordinator thread");
+
+        coordinator_thread_handle
+    }
+
+    /// Start Prometheus logging
+    fn start_prometheus(&mut self) {
+        let prometheus_bind = self.config.node.prometheus_bind.clone();
+        if let Some(prometheus_bind) = prometheus_bind {
+            thread::Builder::new()
+                .name("prometheus".to_string())
+                .spawn(move || {
+                    debug!("prometheus thread ID is {:?}", thread::current().id());
+                    start_serving_monitoring_metrics(prometheus_bind);
+                })
+                .unwrap();
+        }
+    }
+
+    /// Get the sortition DB's highest block height, aligned to a reward cycle boundary, and the
+    /// highest sortition.
+    /// Returns (height at rc start, sortition)
+    fn get_reward_cycle_sortition_db_height(
+        sortdb: &SortitionDB,
+        burnchain_config: &Burnchain,
+    ) -> (u64, BlockSnapshot) {
+        let (stacks_ch, _) = SortitionDB::get_canonical_stacks_chain_tip_hash(sortdb.conn())
+            .expect("BUG: failed to load canonical stacks chain tip hash");
+
+        let sn = match SortitionDB::get_block_snapshot_consensus(sortdb.conn(), &stacks_ch)
+            .expect("BUG: failed to query sortition DB")
+        {
+            Some(sn) => sn,
+            None => {
+                debug!("No canonical stacks chain tip hash present");
+                let sn = SortitionDB::get_first_block_snapshot(&sortdb.conn())
+                    .expect("BUG: failed to get first-ever block snapshot");
+                sn
+            }
+        };
+
+        (
+            burnchain_config.reward_cycle_to_block_height(
+                burnchain_config
+                    .block_height_to_reward_cycle(sn.block_height)
+                    .expect("BUG: snapshot preceeds first reward cycle"),
+            ),
+            sn,
+        )
+    }
+
+    /// Wake up and drive stacks block processing if there's been a PoX reorg.
+    /// Be careful not to saturate calls to announce new stacks blocks, because that will disable
+    /// mining (which would prevent a miner attempting to fix a hidden PoX anchor block from making
+    /// progress).
+    fn drive_pox_reorg_stacks_block_processing(
+        globals: &Globals,
+        config: &Config,
+        burnchain: &Burnchain,
+        sortdb: &SortitionDB,
+        last_stacks_pox_reorg_recover_time: &mut u128,
+    ) {
+        let delay = cmp::max(
+            config.node.chain_liveness_poll_time_secs,
+            cmp::max(
+                config.miner.first_attempt_time_ms,
+                config.miner.subsequent_attempt_time_ms,
+            ) / 1000,
+        );
+
+        if *last_stacks_pox_reorg_recover_time + (delay as u128) >= get_epoch_time_secs().into() {
+            // too soon
+            return;
+        }
+
+        // compare stacks and heaviest AMs
+        let burnchain_db = burnchain
+            .open_burnchain_db(false)
+            .expect("FATAL: failed to open burnchain DB");
+
+        let sn = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn())
+            .expect("FATAL: could not read sortition DB");
+
+        let indexer = make_bitcoin_indexer(config, Some(globals.should_keep_running.clone()));
+
+        let heaviest_affirmation_map = match static_get_heaviest_affirmation_map(
+            &burnchain,
+            &indexer,
+            &burnchain_db,
+            sortdb,
+            &sn.sortition_id,
+        ) {
+            Ok(am) => am,
+            Err(e) => {
+                warn!("Failed to find heaviest affirmation map: {:?}", &e);
+                return;
+            }
+        };
+
+        let highest_sn = SortitionDB::get_highest_known_burn_chain_tip(sortdb.conn())
+            .expect("FATAL: could not read sortition DB");
+
+        let canonical_burnchain_tip = burnchain_db
+            .get_canonical_chain_tip()
+            .expect("FATAL: could not read burnchain DB");
+
+        let sortition_tip_affirmation_map =
+            match SortitionDB::find_sortition_tip_affirmation_map(sortdb, &sn.sortition_id) {
+                Ok(am) => am,
+                Err(e) => {
+                    warn!("Failed to find sortition affirmation map: {:?}", &e);
+                    return;
+                }
+            };
+
+        let stacks_tip_affirmation_map = static_get_stacks_tip_affirmation_map(
+            &burnchain_db,
+            sortdb,
+            &sn.sortition_id,
+            &sn.canonical_stacks_tip_consensus_hash,
+            &sn.canonical_stacks_tip_hash,
+        )
+        .expect("FATAL: could not query stacks DB");
+
+        if stacks_tip_affirmation_map.len() < heaviest_affirmation_map.len()
+            || stacks_tip_affirmation_map
+                .find_divergence(&heaviest_affirmation_map)
+                .is_some()
+        {
+            // the sortition affirmation map might also be inconsistent, so we'll need to fix that
+            // (i.e. the underlying sortitions) before we can fix the stacks fork
+            if sortition_tip_affirmation_map.len() < heaviest_affirmation_map.len()
+                || sortition_tip_affirmation_map
+                    .find_divergence(&heaviest_affirmation_map)
+                    .is_some()
+            {
+                debug!("Drive burn block processing: possible PoX reorg (sortition tip: {}, heaviest: {})", &sortition_tip_affirmation_map, &heaviest_affirmation_map);
+                globals.coord().announce_new_burn_block();
+            } else if highest_sn.block_height == sn.block_height
+                && sn.block_height == canonical_burnchain_tip.block_height
+            {
+                // need to force an affirmation reorg because there will be no more burn block
+                // announcements.
+                debug!("Drive burn block processing: possible PoX reorg (sortition tip: {}, heaviest: {}, burn height {})", &sortition_tip_affirmation_map, &heaviest_affirmation_map, sn.block_height);
+                globals.coord().announce_new_burn_block();
+            }
+
+            debug!(
+                "Drive stacks block processing: possible PoX reorg (stacks tip: {}, heaviest: {})",
+                &stacks_tip_affirmation_map, &heaviest_affirmation_map
+            );
+            globals.coord().announce_new_stacks_block();
+        } else {
+            debug!(
+                "Drive stacks block processing: no need (stacks tip: {}, heaviest: {})",
+                &stacks_tip_affirmation_map, &heaviest_affirmation_map
+            );
+
+            // announce a new stacks block to force the chains coordinator
+            //  to wake up anyways. this isn't free, so we have to make sure
+            //  the chain-liveness thread doesn't wake up too often
+            globals.coord().announce_new_stacks_block();
+        }
+
+        *last_stacks_pox_reorg_recover_time = get_epoch_time_secs().into();
+    }
+
+    /// Wake up and drive sortition processing if there's been a PoX reorg.
+    /// Be careful not to saturate calls to announce new burn blocks, because that will disable
+    /// mining (which would prevent a miner attempting to fix a hidden PoX anchor block from making
+    /// progress).
+    ///
+    /// only call if no in ibd
+    fn drive_pox_reorg_burn_block_processing(
+        globals: &Globals,
+        config: &Config,
+        burnchain: &Burnchain,
+        sortdb: &SortitionDB,
+        chain_state_db: &StacksChainState,
+        last_burn_pox_reorg_recover_time: &mut u128,
+        last_announce_time: &mut u128,
+    ) {
+        let delay = cmp::max(
+            config.node.chain_liveness_poll_time_secs,
+            cmp::max(
+                config.miner.first_attempt_time_ms,
+                config.miner.subsequent_attempt_time_ms,
+            ) / 1000,
+        );
+
+        if *last_burn_pox_reorg_recover_time + (delay as u128) >= get_epoch_time_secs().into() {
+            // too soon
+            return;
+        }
+
+        // compare sortition and heaviest AMs
+        let burnchain_db = burnchain
+            .open_burnchain_db(false)
+            .expect("FATAL: failed to open burnchain DB");
+
+        let highest_sn = SortitionDB::get_highest_known_burn_chain_tip(sortdb.conn())
+            .expect("FATAL: could not read sortition DB");
+
+        let canonical_burnchain_tip = burnchain_db
+            .get_canonical_chain_tip()
+            .expect("FATAL: could not read burnchain DB");
+
+        if canonical_burnchain_tip.block_height > highest_sn.block_height {
+            // still processing sortitions
+            test_debug!(
+                "Drive burn block processing: still processing sortitions ({} > {})",
+                canonical_burnchain_tip.block_height,
+                highest_sn.block_height
+            );
+            return;
+        }
+
+        // NOTE: this could be lower than the highest_sn
+        let sn = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn())
+            .expect("FATAL: could not read sortition DB");
+
+        let sortition_tip_affirmation_map =
+            match SortitionDB::find_sortition_tip_affirmation_map(sortdb, &sn.sortition_id) {
+                Ok(am) => am,
+                Err(e) => {
+                    warn!("Failed to find sortition affirmation map: {:?}", &e);
+                    return;
+                }
+            };
+
+        let indexer = make_bitcoin_indexer(config, Some(globals.should_keep_running.clone()));
+
+        let heaviest_affirmation_map = match static_get_heaviest_affirmation_map(
+            &burnchain,
+            &indexer,
+            &burnchain_db,
+            sortdb,
+            &sn.sortition_id,
+        ) {
+            Ok(am) => am,
+            Err(e) => {
+                warn!("Failed to find heaviest affirmation map: {:?}", &e);
+                return;
+            }
+        };
+
+        let canonical_affirmation_map = match static_get_canonical_affirmation_map(
+            &burnchain,
+            &indexer,
+            &burnchain_db,
+            sortdb,
+            &chain_state_db,
+            &sn.sortition_id,
+        ) {
+            Ok(am) => am,
+            Err(e) => {
+                warn!("Failed to find canonical affirmation map: {:?}", &e);
+                return;
+            }
+        };
+
+        if sortition_tip_affirmation_map.len() < heaviest_affirmation_map.len()
+            || sortition_tip_affirmation_map
+                .find_divergence(&heaviest_affirmation_map)
+                .is_some()
+            || sn.block_height < highest_sn.block_height
+        {
+            debug!("Drive burn block processing: possible PoX reorg (sortition tip: {}, heaviest: {}, {} <? {})", &sortition_tip_affirmation_map, &heaviest_affirmation_map, sn.block_height, highest_sn.block_height);
+            globals.coord().announce_new_burn_block();
+            globals.coord().announce_new_stacks_block();
+            *last_announce_time = get_epoch_time_secs().into();
+        } else if sortition_tip_affirmation_map.len() >= heaviest_affirmation_map.len()
+            && sortition_tip_affirmation_map.len() <= canonical_affirmation_map.len()
+        {
+            if let Some(divergence_rc) =
+                canonical_affirmation_map.find_divergence(&sortition_tip_affirmation_map)
+            {
+                if divergence_rc + 1 >= (heaviest_affirmation_map.len() as u64) {
+                    // we have unaffirmed PoX anchor blocks that are not yet processed in the sortition history
+                    debug!("Drive burnchain processing: possible PoX reorg from unprocessed anchor block(s) (sortition tip: {}, heaviest: {}, canonical: {})", &sortition_tip_affirmation_map, &heaviest_affirmation_map, &canonical_affirmation_map);
+                    globals.coord().announce_new_burn_block();
+                    globals.coord().announce_new_stacks_block();
+                    *last_announce_time = get_epoch_time_secs().into();
+                }
+            }
+        } else {
+            debug!(
+                "Drive burn block processing: no need (sortition tip: {}, heaviest: {}, {} </ {})",
+                &sortition_tip_affirmation_map,
+                &heaviest_affirmation_map,
+                sn.block_height,
+                highest_sn.block_height
+            );
+        }
+
+        *last_burn_pox_reorg_recover_time = get_epoch_time_secs().into();
+
+        // unconditionally bump every 5 minutes, just in case.
+        // this can get the node un-stuck if we're short on sortition processing but are unable to
+        // sync with the remote node because it keeps NACK'ing us, leading to a runloop stall.
+        if *last_announce_time + (UNCONDITIONAL_CHAIN_LIVENESS_CHECK as u128)
+            < get_epoch_time_secs().into()
+        {
+            debug!("Drive burnchain processing: unconditional bump");
+            globals.coord().announce_new_burn_block();
+            globals.coord().announce_new_stacks_block();
+            *last_announce_time = get_epoch_time_secs().into();
+        }
+    }
+
+    /// In a separate thread, periodically drive coordinator liveness by checking to see if there's
+    /// a pending reorg and if so, waking up the coordinator to go and process new blocks
+    fn drive_chain_liveness(
+        globals: Globals,
+        config: Config,
+        burnchain: Burnchain,
+        sortdb: SortitionDB,
+        chain_state_db: StacksChainState,
+    ) {
+        let mut last_burn_pox_reorg_recover_time = 0;
+        let mut last_stacks_pox_reorg_recover_time = 0;
+        let mut last_burn_announce_time = 0;
+
+        debug!("Chain-liveness thread start!");
+
+        while globals.keep_running() {
+            debug!("Chain-liveness checkup");
+            Self::drive_pox_reorg_burn_block_processing(
+                &globals,
+                &config,
+                &burnchain,
+                &sortdb,
+                &chain_state_db,
+                &mut last_burn_pox_reorg_recover_time,
+                &mut last_burn_announce_time,
+            );
+            Self::drive_pox_reorg_stacks_block_processing(
+                &globals,
+                &config,
+                &burnchain,
+                &sortdb,
+                &mut last_stacks_pox_reorg_recover_time,
+            );
+
+            sleep_ms(3000);
+        }
+
+        debug!("Chain-liveness thread exit!");
+    }
+
+    /// Spawn a thread to drive chain liveness
+    fn spawn_chain_liveness_thread(&self, globals: Globals) -> JoinHandle<()> {
+        let config = self.config.clone();
+        let burnchain = self.get_burnchain();
+        let sortdb = burnchain
+            .open_sortition_db(true)
+            .expect("FATAL: could not open sortition DB");
+
+        let (chain_state_db, _) = StacksChainState::open(
+            config.is_mainnet(),
+            config.burnchain.chain_id,
+            &config.get_chainstate_path_str(),
+            Some(config.node.get_marf_opts()),
+        )
+        .unwrap();
+
+        let liveness_thread_handle = thread::Builder::new()
+            .name(format!("chain-liveness-{}", config.node.rpc_bind))
+            .stack_size(BLOCK_PROCESSOR_STACK_SIZE)
+            .spawn(move || {
+                Self::drive_chain_liveness(globals, config, burnchain, sortdb, chain_state_db)
+            })
+            .expect("FATAL: failed to spawn chain liveness thread");
+
+        liveness_thread_handle
+    }
+
+    /// Starts the node runloop.
+    ///
+    /// This function will block by looping infinitely.
+    /// It will start the burnchain (separate thread), set-up a channel in
+    /// charge of coordinating the new blocks coming from the burnchain and
+    /// the nodes, taking turns on tenures.  
+    pub fn start(&mut self, burnchain_opt: Option<Burnchain>, mut mine_start: u64) {
+        let (coordinator_receivers, coordinator_senders) = self
+            .coordinator_channels
+            .take()
+            .expect("Run loop already started, can only start once after initialization.");
+
+        neon::RunLoop::setup_termination_handler(self.should_keep_running.clone());
+        let mut burnchain = neon::RunLoop::instantiate_burnchain_state(
+            &self.config,
+            self.should_keep_running.clone(),
+            burnchain_opt,
+            coordinator_senders.clone(),
+        );
+
+        let burnchain_config = burnchain.get_burnchain();
+        self.burnchain = Some(burnchain_config.clone());
+
+        // can we mine?
+        let is_miner = self.check_is_miner(&mut burnchain);
+        self.is_miner = Some(is_miner);
+
+        // relayer linkup
+        let (relay_send, relay_recv) = sync_channel(RELAYER_MAX_BUFFER);
+
+        // set up globals so other subsystems can instantiate off of the runloop state.
+        let globals = Globals::new(
+            coordinator_senders,
+            self.get_miner_status(),
+            relay_send,
+            self.counters.clone(),
+            self.pox_watchdog_comms.clone(),
+            self.should_keep_running.clone(),
+        );
+        self.set_globals(globals.clone());
+
+        // have headers; boot up the chains coordinator and instantiate the chain state
+        let coordinator_thread_handle = self.spawn_chains_coordinator(
+            &burnchain_config,
+            coordinator_receivers,
+            globals.get_miner_status(),
+        );
+        self.start_prometheus();
+
+        // We announce a new burn block so that the chains coordinator
+        // can resume prior work and handle eventual unprocessed sortitions
+        // stored during a previous session.
+        globals.coord().announce_new_burn_block();
+
+        // Make sure at least one sortition has happened, and make sure it's globally available
+        let sortdb = burnchain.sortdb_mut();
+        let (rc_aligned_height, sn) =
+            RunLoop::get_reward_cycle_sortition_db_height(&sortdb, &burnchain_config);
+
+        let burnchain_tip_snapshot = if sn.block_height == burnchain_config.first_block_height {
+            // need at least one sortition to happen.
+            burnchain
+                .wait_for_sortitions(globals.coord().clone(), sn.block_height + 1)
+                .expect("Unable to get burnchain tip")
+                .block_snapshot
+        } else {
+            sn
+        };
+
+        globals.set_last_sortition(burnchain_tip_snapshot.clone());
+
+        // Boot up the p2p network and relayer, and figure out how many sortitions we have so far
+        // (it could be non-zero if the node is resuming from chainstate)
+        let mut node = StacksNode::spawn(self, globals.clone(), relay_recv);
+        let liveness_thread = self.spawn_chain_liveness_thread(globals.clone());
+
+        // Wait for all pending sortitions to process
+        let burnchain_db = burnchain_config
+            .open_burnchain_db(false)
+            .expect("FATAL: failed to open burnchain DB");
+        let burnchain_db_tip = burnchain_db
+            .get_canonical_chain_tip()
+            .expect("FATAL: failed to query burnchain DB");
+        let mut burnchain_tip = burnchain
+            .wait_for_sortitions(globals.coord().clone(), burnchain_db_tip.block_height)
+            .expect("Unable to get burnchain tip");
+
+        // Start the runloop
+        debug!("Runloop: Begin run loop");
+        self.counters.bump_blocks_processed();
+
+        let mut sortition_db_height = rc_aligned_height;
+        let mut burnchain_height = sortition_db_height;
+        let mut num_sortitions_in_last_cycle;
+
+        // prepare to fetch the first reward cycle!
+        let mut target_burnchain_block_height = cmp::min(
+            burnchain_config.reward_cycle_to_block_height(
+                burnchain_config
+                    .block_height_to_reward_cycle(burnchain_height)
+                    .expect("BUG: block height is not in a reward cycle")
+                    + 1,
+            ),
+            burnchain.get_headers_height() - 1,
+        );
+
+        debug!(
+            "Runloop: Begin main runloop starting a burnchain block {}",
+            sortition_db_height
+        );
+
+        let mut last_tenure_sortition_height = 0;
+
+        loop {
+            if !globals.keep_running() {
+                // The p2p thread relies on the same atomic_bool, it will
+                // discontinue its execution after completing its ongoing runloop epoch.
+                info!("Terminating p2p process");
+                info!("Terminating relayer");
+                info!("Terminating chains-coordinator");
+
+                globals.coord().stop_chains_coordinator();
+                coordinator_thread_handle.join().unwrap();
+                node.join();
+                liveness_thread.join().unwrap();
+
+                info!("Exiting stacks-node");
+                break;
+            }
+
+            let remote_chain_height = burnchain.get_headers_height() - 1;
+
+            // wait for the p2p state-machine to do at least one pass
+            debug!("Runloop: Wait until Stacks block downloads reach a quiescent state before processing more burnchain blocks"; "remote_chain_height" => remote_chain_height, "local_chain_height" => burnchain_height);
+
+            let ibd = false;
+
+            // calculate burnchain sync percentage
+            let percent: f64 = if remote_chain_height > 0 {
+                burnchain_tip.block_snapshot.block_height as f64 / remote_chain_height as f64
+            } else {
+                0.0
+            };
+
+            // Download each burnchain block and process their sortitions.  This, in turn, will
+            // cause the node's p2p and relayer threads to go fetch and download Stacks blocks and
+            // process them.  This loop runs for one reward cycle, so that the next pass of the
+            // runloop will cause the PoX sync watchdog to wait until it believes that the node has
+            // obtained all the Stacks blocks it can.
+            debug!(
+                "Runloop: Download burnchain blocks up to reward cycle #{} (height {})",
+                burnchain_config
+                    .block_height_to_reward_cycle(target_burnchain_block_height)
+                    .expect("FATAL: target burnchain block height does not have a reward cycle"),
+                target_burnchain_block_height;
+                "total_burn_sync_percent" => %percent,
+                "local_burn_height" => burnchain_tip.block_snapshot.block_height,
+                "remote_tip_height" => remote_chain_height
+            );
+
+            loop {
+                if !globals.keep_running() {
+                    break;
+                }
+
+                let (next_burnchain_tip, tip_burnchain_height) =
+                    match burnchain.sync(Some(target_burnchain_block_height)) {
+                        Ok(x) => x,
+                        Err(e) => {
+                            warn!("Runloop: Burnchain controller stopped: {}", e);
+                            continue;
+                        }
+                    };
+
+                // *now* we know the burnchain height
+                burnchain_tip = next_burnchain_tip;
+                burnchain_height = tip_burnchain_height;
+
+                let sortition_tip = &burnchain_tip.block_snapshot.sortition_id;
+                let next_sortition_height = burnchain_tip.block_snapshot.block_height;
+
+                if next_sortition_height != last_tenure_sortition_height {
+                    info!(
+                        "Runloop: Downloaded burnchain blocks up to height {}; target height is {}; remote_chain_height = {} next_sortition_height = {}, sortition_db_height = {}",
+                        burnchain_height, target_burnchain_block_height, remote_chain_height, next_sortition_height, sortition_db_height
+                    );
+                }
+
+                if next_sortition_height > sortition_db_height {
+                    debug!(
+                        "Runloop: New burnchain block height {} > {}",
+                        next_sortition_height, sortition_db_height
+                    );
+
+                    let mut sort_count = 0;
+
+                    debug!("Runloop: block mining until we process all sortitions");
+                    signal_mining_blocked(globals.get_miner_status());
+
+                    // first, let's process all blocks in (sortition_db_height, next_sortition_height]
+                    for block_to_process in (sortition_db_height + 1)..(next_sortition_height + 1) {
+                        // stop mining so we can advance the sortition DB and so our
+                        // ProcessTenure() directive (sent by relayer_sortition_notify() below)
+                        // will be unblocked.
+
+                        let block = {
+                            let ic = burnchain.sortdb_ref().index_conn();
+                            SortitionDB::get_ancestor_snapshot(&ic, block_to_process, sortition_tip)
+                                .unwrap()
+                                .expect(
+                                    "Failed to find block in fork processed by burnchain indexer",
+                                )
+                        };
+                        if block.sortition {
+                            sort_count += 1;
+                        }
+
+                        let sortition_id = &block.sortition_id;
+
+                        // Have the node process the new block, that can include, or not, a sortition.
+                        node.process_burnchain_state(burnchain.sortdb_mut(), sortition_id, ibd);
+
+                        // Now, tell the relayer to check if it won a sortition during this block,
+                        // and, if so, to process and advertize the block.  This is basically a
+                        // no-op during boot-up.
+                        //
+                        // _this will block if the relayer's buffer is full_
+                        if !node.relayer_burnchain_notify() {
+                            // relayer hung up, exit.
+                            error!("Runloop: Block relayer and miner hung up, exiting.");
+                            return;
+                        }
+                    }
+
+                    debug!("Runloop: enable miner after processing sortitions");
+                    signal_mining_ready(globals.get_miner_status());
+
+                    num_sortitions_in_last_cycle = sort_count;
+                    debug!(
+                        "Runloop: Synchronized sortitions up to block height {} from {} (chain tip height is {}); {} sortitions",
+                        next_sortition_height, sortition_db_height, burnchain_height, num_sortitions_in_last_cycle;
+                    );
+
+                    sortition_db_height = next_sortition_height;
+                } else if ibd {
+                    // drive block processing after we reach the burnchain tip.
+                    // we may have downloaded all the blocks already,
+                    // so we can't rely on the relayer alone to
+                    // drive it.
+                    globals.coord().announce_new_stacks_block();
+                }
+
+                if burnchain_height >= target_burnchain_block_height
+                    || burnchain_height >= remote_chain_height
+                {
+                    break;
+                }
+            }
+
+            // advance one reward cycle at a time.
+            // If we're still downloading, then this is simply target_burnchain_block_height + reward_cycle_len.
+            // Otherwise, this is burnchain_tip + reward_cycle_len
+            let next_target_burnchain_block_height = cmp::min(
+                burnchain_config.reward_cycle_to_block_height(
+                    burnchain_config
+                        .block_height_to_reward_cycle(target_burnchain_block_height)
+                        .expect("FATAL: burnchain height before system start")
+                        + 1,
+                ),
+                remote_chain_height,
+            );
+
+            debug!("Runloop: Advance target burnchain block height from {} to {} (sortition height {})", target_burnchain_block_height, next_target_burnchain_block_height, sortition_db_height);
+            target_burnchain_block_height = next_target_burnchain_block_height;
+
+            if sortition_db_height >= burnchain_height && !ibd {
+                let canonical_stacks_tip_height =
+                    SortitionDB::get_canonical_burn_chain_tip(burnchain.sortdb_ref().conn())
+                        .map(|snapshot| snapshot.canonical_stacks_tip_height)
+                        .unwrap_or(0);
+                if canonical_stacks_tip_height < mine_start {
+                    info!(
+                        "Runloop: Synchronized full burnchain, but stacks tip height is {}, and we are trying to boot to {}, not mining until reaching chain tip",
+                        canonical_stacks_tip_height,
+                        mine_start
+                    );
+                } else {
+                    // once we've synced to the chain tip once, don't apply this check again.
+                    //  this prevents a possible corner case in the event of a PoX fork.
+                    mine_start = 0;
+
+                    // at tip, and not downloading. proceed to mine.
+                    if last_tenure_sortition_height != sortition_db_height {
+                        info!(
+                            "Runloop: Synchronized full burnchain up to height {}. Proceeding to mine blocks",
+                            sortition_db_height
+                        );
+                        last_tenure_sortition_height = sortition_db_height;
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/testnet/stacks-node/src/run_loop/neon.rs b/testnet/stacks-node/src/run_loop/neon.rs
index c9368e9e3a..c10c9b88c3 100644
--- a/testnet/stacks-node/src/run_loop/neon.rs
+++ b/testnet/stacks-node/src/run_loop/neon.rs
@@ -31,8 +31,9 @@ use stx_genesis::GenesisData;
 
 use super::RunLoopCallbacks;
 use crate::burnchains::make_bitcoin_indexer;
+use crate::globals::Globals;
 use crate::monitoring::start_serving_monitoring_metrics;
-use crate::neon_node::{Globals, StacksNode, BLOCK_PROCESSOR_STACK_SIZE, RELAYER_MAX_BUFFER};
+use crate::neon_node::{StacksNode, BLOCK_PROCESSOR_STACK_SIZE, RELAYER_MAX_BUFFER};
 use crate::node::{
     get_account_balances, get_account_lockups, get_names, get_namespaces,
     use_test_genesis_chainstate,
@@ -63,6 +64,10 @@ pub struct Counters {
     pub missed_tenures: RunLoopCounter,
     pub missed_microblock_tenures: RunLoopCounter,
     pub cancelled_commits: RunLoopCounter,
+
+    pub naka_submitted_vrfs: RunLoopCounter,
+    pub naka_submitted_commits: RunLoopCounter,
+    pub naka_mined_blocks: RunLoopCounter,
 }
 
 impl Counters {
@@ -74,6 +79,9 @@ impl Counters {
             missed_tenures: RunLoopCounter::new(AtomicU64::new(0)),
             missed_microblock_tenures: RunLoopCounter::new(AtomicU64::new(0)),
             cancelled_commits: RunLoopCounter::new(AtomicU64::new(0)),
+            naka_submitted_vrfs: RunLoopCounter::new(AtomicU64::new(0)),
+            naka_submitted_commits: RunLoopCounter::new(AtomicU64::new(0)),
+            naka_mined_blocks: RunLoopCounter::new(AtomicU64::new(0)),
         }
     }
 
@@ -85,6 +93,9 @@ impl Counters {
             missed_tenures: (),
             missed_microblock_tenures: (),
             cancelled_commits: (),
+            naka_submitted_vrfs: (),
+            naka_submitted_commits: (),
+            naka_mined_blocks: (),
         }
     }
 
@@ -124,6 +135,18 @@ impl Counters {
         Counters::inc(&self.cancelled_commits);
     }
 
+    pub fn bump_naka_submitted_vrfs(&self) {
+        Counters::inc(&self.naka_submitted_vrfs);
+    }
+
+    pub fn bump_naka_submitted_commits(&self) {
+        Counters::inc(&self.naka_submitted_commits);
+    }
+
+    pub fn bump_naka_mined_blocks(&self) {
+        Counters::inc(&self.naka_mined_blocks);
+    }
+
     pub fn set_microblocks_processed(&self, value: u64) {
         Counters::set(&self.microblocks_processed, value)
     }
@@ -251,7 +274,7 @@ impl RunLoop {
     }
 
     pub fn get_termination_switch(&self) -> Arc<AtomicBool> {
-        self.get_globals().should_keep_running.clone()
+        self.should_keep_running.clone()
     }
 
     pub fn get_burnchain(&self) -> Burnchain {
@@ -272,8 +295,7 @@ impl RunLoop {
 
     /// Set up termination handler.  Have a signal set the `should_keep_running` atomic bool to
     /// false.  Panics of called more than once.
-    fn setup_termination_handler(&self) {
-        let keep_running_writer = self.should_keep_running.clone();
+    pub fn setup_termination_handler(keep_running_writer: Arc<AtomicBool>) {
         let install = termination::set_handler(move |sig_id| match sig_id {
             SignalId::Bus => {
                 let msg = "Caught SIGBUS; crashing immediately and dumping core\n";
@@ -355,17 +377,18 @@ impl RunLoop {
     /// Instantiate the burnchain client and databases.
     /// Fetches headers and instantiates the burnchain.
     /// Panics on failure.
-    fn instantiate_burnchain_state(
-        &mut self,
+    pub fn instantiate_burnchain_state(
+        config: &Config,
+        should_keep_running: Arc<AtomicBool>,
         burnchain_opt: Option<Burnchain>,
         coordinator_senders: CoordinatorChannels,
     ) -> BitcoinRegtestController {
         // Initialize and start the burnchain.
         let mut burnchain_controller = BitcoinRegtestController::with_burnchain(
-            self.config.clone(),
+            config.clone(),
             Some(coordinator_senders),
             burnchain_opt,
-            Some(self.should_keep_running.clone()),
+            Some(should_keep_running.clone()),
         );
 
         let burnchain = burnchain_controller.get_burnchain();
@@ -377,9 +400,9 @@ impl RunLoop {
         // Upgrade chainstate databases if they exist already
         match migrate_chainstate_dbs(
             &epochs,
-            &self.config.get_burn_db_file_path(),
-            &self.config.get_chainstate_path_str(),
-            Some(self.config.node.get_marf_opts()),
+            &config.get_burn_db_file_path(),
+            &config.get_chainstate_path_str(),
+            Some(config.node.get_marf_opts()),
         ) {
             Ok(_) => {}
             Err(coord_error::DBError(db_error::TooOldForEpoch)) => {
@@ -951,9 +974,13 @@ impl RunLoop {
             .take()
             .expect("Run loop already started, can only start once after initialization.");
 
-        self.setup_termination_handler();
-        let mut burnchain =
-            self.instantiate_burnchain_state(burnchain_opt, coordinator_senders.clone());
+        Self::setup_termination_handler(self.should_keep_running.clone());
+        let mut burnchain = Self::instantiate_burnchain_state(
+            &self.config,
+            self.should_keep_running.clone(),
+            burnchain_opt,
+            coordinator_senders.clone(),
+        );
 
         let burnchain_config = burnchain.get_burnchain();
         self.burnchain = Some(burnchain_config.clone());
diff --git a/testnet/stacks-node/src/tests/bitcoin_regtest.rs b/testnet/stacks-node/src/tests/bitcoin_regtest.rs
index fdb09dd22c..454e92b50b 100644
--- a/testnet/stacks-node/src/tests/bitcoin_regtest.rs
+++ b/testnet/stacks-node/src/tests/bitcoin_regtest.rs
@@ -16,6 +16,7 @@ use crate::helium::RunLoop;
 use crate::tests::to_addr;
 use crate::Config;
 
+#[derive(Debug)]
 pub enum BitcoinCoreError {
     SpawnFailed(String),
 }
diff --git a/testnet/stacks-node/src/tests/mod.rs b/testnet/stacks-node/src/tests/mod.rs
index faea7f99d9..8ac9fcff53 100644
--- a/testnet/stacks-node/src/tests/mod.rs
+++ b/testnet/stacks-node/src/tests/mod.rs
@@ -43,6 +43,7 @@ mod epoch_23;
 mod epoch_24;
 mod integrations;
 mod mempool;
+mod nakamoto_integrations;
 pub mod neon_integrations;
 mod signer;
 mod stackerdb;
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
new file mode 100644
index 0000000000..efa36ea1e5
--- /dev/null
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -0,0 +1,322 @@
+use clarity::vm::types::PrincipalData;
+use stacks::burnchains::MagicBytes;
+use stacks::chainstate::nakamoto::NakamotoChainState;
+use stacks::chainstate::stacks::db::StacksChainState;
+use stacks::core::{
+    StacksEpoch, StacksEpochId, BLOCK_LIMIT_MAINNET_10, HELIUM_BLOCK_LIMIT_20,
+    PEER_VERSION_EPOCH_1_0, PEER_VERSION_EPOCH_2_0, PEER_VERSION_EPOCH_2_05,
+    PEER_VERSION_EPOCH_2_1, PEER_VERSION_EPOCH_2_2, PEER_VERSION_EPOCH_2_3, PEER_VERSION_EPOCH_2_4,
+    PEER_VERSION_EPOCH_2_5, PEER_VERSION_EPOCH_3_0,
+};
+use stacks_common::address::AddressHashMode;
+use stacks_common::consts::STACKS_EPOCH_MAX;
+use stacks_common::types::chainstate::StacksAddress;
+use stacks_common::util::hash::to_hex;
+use stacks_common::util::secp256k1::Secp256k1PrivateKey;
+use std::sync::atomic::Ordering;
+use std::time::{Duration, Instant};
+use std::{env, thread};
+
+use super::bitcoin_regtest::BitcoinCoreController;
+use crate::mockamoto::signer::SelfSigner;
+use crate::run_loop::nakamoto;
+use crate::tests::neon_integrations::{
+    next_block_and_wait, run_until_burnchain_height, submit_tx, wait_for_runloop,
+};
+use crate::{
+    neon, tests, BitcoinRegtestController, BurnchainController, Config, ConfigFile, Keychain,
+};
+use lazy_static::lazy_static;
+
+lazy_static! {
+    pub static ref NAKAMOTO_INTEGRATION_EPOCHS: [StacksEpoch; 9] = [
+        StacksEpoch {
+            epoch_id: StacksEpochId::Epoch10,
+            start_height: 0,
+            end_height: 0,
+            block_limit: BLOCK_LIMIT_MAINNET_10.clone(),
+            network_epoch: PEER_VERSION_EPOCH_1_0
+        },
+        StacksEpoch {
+            epoch_id: StacksEpochId::Epoch20,
+            start_height: 0,
+            end_height: 1,
+            block_limit: HELIUM_BLOCK_LIMIT_20.clone(),
+            network_epoch: PEER_VERSION_EPOCH_2_0
+        },
+        StacksEpoch {
+            epoch_id: StacksEpochId::Epoch2_05,
+            start_height: 1,
+            end_height: 2,
+            block_limit: HELIUM_BLOCK_LIMIT_20.clone(),
+            network_epoch: PEER_VERSION_EPOCH_2_05
+        },
+        StacksEpoch {
+            epoch_id: StacksEpochId::Epoch21,
+            start_height: 2,
+            end_height: 3,
+            block_limit: HELIUM_BLOCK_LIMIT_20.clone(),
+            network_epoch: PEER_VERSION_EPOCH_2_1
+        },
+        StacksEpoch {
+            epoch_id: StacksEpochId::Epoch22,
+            start_height: 3,
+            end_height: 4,
+            block_limit: HELIUM_BLOCK_LIMIT_20.clone(),
+            network_epoch: PEER_VERSION_EPOCH_2_2
+        },
+        StacksEpoch {
+            epoch_id: StacksEpochId::Epoch23,
+            start_height: 4,
+            end_height: 5,
+            block_limit: HELIUM_BLOCK_LIMIT_20.clone(),
+            network_epoch: PEER_VERSION_EPOCH_2_3
+        },
+        StacksEpoch {
+            epoch_id: StacksEpochId::Epoch24,
+            start_height: 5,
+            end_height: 6,
+            block_limit: HELIUM_BLOCK_LIMIT_20.clone(),
+            network_epoch: PEER_VERSION_EPOCH_2_4
+        },
+        StacksEpoch {
+            epoch_id: StacksEpochId::Epoch25,
+            start_height: 6,
+            end_height: 220,
+            block_limit: HELIUM_BLOCK_LIMIT_20.clone(),
+            network_epoch: PEER_VERSION_EPOCH_2_5
+        },
+        StacksEpoch {
+            epoch_id: StacksEpochId::Epoch30,
+            start_height: 220,
+            end_height: STACKS_EPOCH_MAX,
+            block_limit: HELIUM_BLOCK_LIMIT_20.clone(),
+            network_epoch: PEER_VERSION_EPOCH_3_0
+        },
+    ];
+}
+
+/// Return a working nakamoto-neon config and the miner's bitcoin address to fund
+pub fn naka_neon_integration_conf(seed: Option<&[u8]>) -> (Config, StacksAddress) {
+    let mut conf = super::new_test_conf();
+    conf.burnchain.mode = "nakamoto-neon".into();
+
+    // tests can override this, but these tests run with epoch 2.05 by default
+    conf.burnchain.epochs = Some(NAKAMOTO_INTEGRATION_EPOCHS.to_vec());
+
+    if let Some(seed) = seed {
+        conf.node.seed = seed.to_vec();
+    }
+
+    // instantiate the keychain so we can fund the bitcoin op signer
+    let keychain = Keychain::default(conf.node.seed.clone());
+
+    let mining_key = Secp256k1PrivateKey::from_seed(&[1]);
+    conf.miner.mining_key = Some(mining_key);
+    conf.miner.self_signing_key = Some(SelfSigner::single_signer());
+
+    conf.node.miner = true;
+    conf.node.wait_time_for_microblocks = 500;
+    conf.burnchain.burn_fee_cap = 20000;
+
+    conf.burnchain.username = Some("neon-tester".into());
+    conf.burnchain.password = Some("neon-tester-pass".into());
+    conf.burnchain.peer_host = "127.0.0.1".into();
+    conf.burnchain.local_mining_public_key =
+        Some(keychain.generate_op_signer().get_public_key().to_hex());
+    conf.burnchain.commit_anchor_block_within = 0;
+
+    // test to make sure config file parsing is correct
+    let mut cfile = ConfigFile::xenon();
+    cfile.node.as_mut().map(|node| node.bootstrap_node.take());
+
+    if let Some(burnchain) = cfile.burnchain.as_mut() {
+        burnchain.peer_host = Some("127.0.0.1".to_string());
+    }
+
+    conf.burnchain.magic_bytes = MagicBytes::from(['T' as u8, '3' as u8].as_ref());
+    conf.burnchain.poll_time_secs = 1;
+    conf.node.pox_sync_sample_secs = 0;
+
+    conf.miner.min_tx_fee = 1;
+    conf.miner.first_attempt_time_ms = i64::max_value() as u64;
+    conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
+
+    // if there's just one node, then this must be true for tests to pass
+    conf.miner.wait_for_block_download = false;
+
+    conf.node.mine_microblocks = false;
+    conf.miner.microblock_attempt_time_ms = 10;
+    conf.node.microblock_frequency = 0;
+    conf.node.wait_time_for_blocks = 200;
+
+    let miner_account = keychain.origin_address(conf.is_mainnet()).unwrap();
+
+    conf.burnchain.pox_prepare_length = Some(5);
+    conf.burnchain.pox_reward_length = Some(20);
+
+    (conf, miner_account)
+}
+
+pub fn next_block_and<F>(
+    btc_controller: &mut BitcoinRegtestController,
+    timeout_secs: u64,
+    mut check: F,
+) -> Result<(), String>
+where
+    F: FnMut() -> Result<bool, String>,
+{
+    eprintln!("Issuing bitcoin block");
+    btc_controller.build_next_block(1);
+    let start = Instant::now();
+    while !check()? {
+        if start.elapsed() > Duration::from_secs(timeout_secs) {
+            error!("Timed out waiting for block to process, trying to continue test");
+            return Err("Timed out".into());
+        }
+        thread::sleep(Duration::from_millis(100));
+    }
+    Ok(())
+}
+
+#[test]
+#[ignore]
+fn simple_neon_integration() {
+    if env::var("BITCOIND_TEST") != Ok("1".into()) {
+        return;
+    }
+
+    let (mut naka_conf, _miner_account) = naka_neon_integration_conf(None);
+    let stacker_sk = Secp256k1PrivateKey::new();
+    let stacker_address = tests::to_addr(&stacker_sk);
+    naka_conf.add_initial_balance(
+        PrincipalData::from(stacker_address.clone()).to_string(),
+        100_000_000_000_000,
+    );
+
+    let epoch_2_conf = naka_conf.clone();
+
+    let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone());
+    btcd_controller
+        .start_bitcoind()
+        .expect("Failed starting bitcoind");
+
+    let mut btc_regtest_controller = BitcoinRegtestController::new(naka_conf.clone(), None);
+    let http_origin = format!("http://{}", &naka_conf.node.rpc_bind);
+    btc_regtest_controller.bootstrap_chain(201);
+
+    info!("Chain bootstrapped to bitcoin block 201, starting a epoch-2x miner");
+
+    let mut run_loop = neon::RunLoop::new(epoch_2_conf.clone());
+
+    let epoch_2_stopper = run_loop.get_termination_switch();
+    let blocks_processed = run_loop.get_blocks_processed_arc();
+    let epoch_2_thread = thread::spawn(move || run_loop.start(None, 0));
+    wait_for_runloop(&blocks_processed);
+    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+    // first mined stacks block
+    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+    // stack enough to activate pox-4
+    let pox_addr_tuple = clarity::vm::tests::execute(&format!(
+        "{{ hashbytes: 0x{}, version: 0x{:02x} }}",
+        to_hex(&[0; 20]),
+        AddressHashMode::SerializeP2PKH as u8,
+    ));
+
+    let stacking_tx = tests::make_contract_call(
+        &stacker_sk,
+        0,
+        1000,
+        &StacksAddress::burn_address(false),
+        "pox-4",
+        "stack-stx",
+        &[
+            clarity::vm::Value::UInt(99_000_000_000_000),
+            pox_addr_tuple,
+            clarity::vm::Value::UInt(205),
+            clarity::vm::Value::UInt(12),
+        ],
+    );
+
+    submit_tx(&http_origin, &stacking_tx);
+
+    run_until_burnchain_height(
+        &mut btc_regtest_controller,
+        &blocks_processed,
+        219,
+        &epoch_2_conf,
+    );
+
+    info!("Bootstrapped to Epoch-3.0 boundary, starting nakamoto miner");
+    epoch_2_stopper.store(false, Ordering::SeqCst);
+
+    epoch_2_thread.join().unwrap();
+
+    let mut run_loop = nakamoto::RunLoop::new(naka_conf.clone());
+    let epoch_3_stopper = run_loop.get_termination_switch();
+    let blocks_processed = run_loop.get_blocks_processed_arc();
+    let vrfs_submitted = run_loop.submitted_vrfs();
+    let commits_submitted = run_loop.submitted_commits();
+    let blocks_mined = run_loop.submitted_commits();
+    let coord_channel = run_loop.get_coordinator_channel().unwrap();
+
+    let epoch_3_thread = thread::spawn(move || run_loop.start(None, 0));
+
+    wait_for_runloop(&blocks_processed);
+    info!("Nakamoto miner started...");
+    // first block wakes up the run loop, wait until a key registration has been submitted.
+    next_block_and(&mut btc_regtest_controller, 60, || {
+        let vrf_count = vrfs_submitted.load(Ordering::SeqCst);
+        Ok(vrf_count >= 1)
+    })
+    .unwrap();
+
+    // second block should confirm the VRF register, wait until a block commit is submitted
+    next_block_and(&mut btc_regtest_controller, 60, || {
+        let commits_count = commits_submitted.load(Ordering::SeqCst);
+        Ok(commits_count >= 1)
+    })
+    .unwrap();
+
+    let blocks_processed_before_mining = coord_channel.get_stacks_blocks_processed();
+
+    // this block should perform the sortition, wait until a block is mined
+    next_block_and(&mut btc_regtest_controller, 60, || {
+        let mined_count = blocks_mined.load(Ordering::SeqCst);
+        Ok(mined_count >= 1)
+    })
+    .unwrap();
+
+    // wait until the coordinator has processed the new block(s)
+    while coord_channel.get_stacks_blocks_processed() <= blocks_processed_before_mining {
+        thread::sleep(Duration::from_secs(1));
+    }
+
+    // load the chain tip, and assert that it is a nakamoto block
+
+    let burnchain = naka_conf.get_burnchain();
+    let sortdb = burnchain.open_sortition_db(true).unwrap();
+    let (chainstate, _) = StacksChainState::open(
+        naka_conf.is_mainnet(),
+        naka_conf.burnchain.chain_id,
+        &naka_conf.get_chainstate_path_str(),
+        None,
+    )
+    .unwrap();
+
+    let tip = NakamotoChainState::get_canonical_block_header(chainstate.db(), &sortdb)
+        .unwrap()
+        .unwrap();
+    info!(
+        "Latest tip";
+        "is_nakamoto" => tip.anchored_header.as_stacks_nakamoto().is_some(),
+    );
+
+    assert!(tip.anchored_header.as_stacks_nakamoto().is_some());
+
+    coord_channel.stop_chains_coordinator();
+
+    epoch_3_stopper.store(false, Ordering::SeqCst);
+    epoch_3_thread.join().unwrap();
+}
diff --git a/testnet/stacks-node/src/tests/neon_integrations.rs b/testnet/stacks-node/src/tests/neon_integrations.rs
index b1e68d26d7..455e414208 100644
--- a/testnet/stacks-node/src/tests/neon_integrations.rs
+++ b/testnet/stacks-node/src/tests/neon_integrations.rs
@@ -483,7 +483,7 @@ pub mod test_observer {
     }
 }
 
-const PANIC_TIMEOUT_SECS: u64 = 600;
+const PANIC_TIMEOUT_SECS: u64 = 30;
 
 /// Returns `false` on a timeout, true otherwise.
 pub fn next_block_and_wait(
@@ -556,7 +556,7 @@ pub fn next_block_and_iterate(
 /// reaches *exactly* `target_height`.
 ///
 /// Returns `false` if `next_block_and_wait` times out.
-fn run_until_burnchain_height(
+pub fn run_until_burnchain_height(
     btc_regtest_controller: &mut BitcoinRegtestController,
     blocks_processed: &Arc<AtomicU64>,
     target_height: u64,

From 7f0e1d4ad31169691dcf9a17dcf8242e1fcb9263 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Thu, 7 Dec 2023 14:13:34 -0600
Subject: [PATCH 0185/1166] expand first nakamoto-neon test, update block
 commit logic to issue commits at tenure_id changes, cargo fmt-stacks

---
 .../burnchains/bitcoin_regtest_controller.rs  |  10 +-
 testnet/stacks-node/src/globals.rs            |  13 +-
 testnet/stacks-node/src/nakamoto_node.rs      |  14 +-
 .../stacks-node/src/nakamoto_node/miner.rs    |  26 +-
 testnet/stacks-node/src/nakamoto_node/peer.rs |  19 +-
 .../stacks-node/src/nakamoto_node/relayer.rs  |  95 +++----
 testnet/stacks-node/src/neon_node.rs          |   3 +-
 .../src/tests/nakamoto_integrations.rs        | 255 ++++++++++++++----
 8 files changed, 285 insertions(+), 150 deletions(-)

diff --git a/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs b/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
index ad83dd6f57..0ed1bb0e03 100644
--- a/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
+++ b/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
@@ -8,7 +8,8 @@ use async_h1::client;
 use async_std::io::ReadExt;
 use async_std::net::TcpStream;
 use base64::encode;
-
+#[cfg(test)]
+use clarity::vm::types::PrincipalData;
 use http_types::{Method, Request, Url};
 use serde::Serialize;
 use serde_json::json;
@@ -51,15 +52,12 @@ use stacks_common::deps_common::bitcoin::network::serialize::deserialize as btc_
 use stacks_common::deps_common::bitcoin::network::serialize::RawEncoder;
 use stacks_common::deps_common::bitcoin::util::hash::Sha256dHash;
 use stacks_common::types::chainstate::BurnchainHeaderHash;
+#[cfg(test)]
+use stacks_common::types::chainstate::StacksAddress;
 use stacks_common::util::hash::{hex_bytes, Hash160};
 use stacks_common::util::secp256k1::Secp256k1PublicKey;
 use stacks_common::util::sleep_ms;
 
-#[cfg(test)]
-use clarity::vm::types::PrincipalData;
-#[cfg(test)]
-use stacks_common::types::chainstate::StacksAddress;
-
 use super::super::operations::BurnchainOpSigner;
 use super::super::Config;
 use super::{BurnchainController, BurnchainTip, Error as BurnchainControllerError};
diff --git a/testnet/stacks-node/src/globals.rs b/testnet/stacks-node/src/globals.rs
index acace012f8..7e9e47a8fe 100644
--- a/testnet/stacks-node/src/globals.rs
+++ b/testnet/stacks-node/src/globals.rs
@@ -1,8 +1,6 @@
-use std::sync::atomic::AtomicBool;
-use std::sync::atomic::Ordering;
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::mpsc::SyncSender;
-use std::sync::Arc;
-use std::sync::Mutex;
+use std::sync::{Arc, Mutex};
 
 use stacks::burnchains::Txid;
 use stacks::chainstate::burn::operations::LeaderKeyRegisterOp;
@@ -12,16 +10,13 @@ use stacks::chainstate::stacks::db::unconfirmed::UnconfirmedTxMap;
 use stacks::chainstate::stacks::db::StacksChainState;
 use stacks::chainstate::stacks::miner::MinerStatus;
 use stacks::net::NetworkResult;
-use stacks_common::types::chainstate::BlockHeaderHash;
-use stacks_common::types::chainstate::BurnchainHeaderHash;
-use stacks_common::types::chainstate::ConsensusHash;
+use stacks_common::types::chainstate::{BlockHeaderHash, BurnchainHeaderHash, ConsensusHash};
 
 use crate::neon::Counters;
+use crate::neon_node::LeaderKeyRegistrationState;
 use crate::run_loop::RegisteredKey;
 use crate::syncctl::PoxSyncWatchdogComms;
 
-use crate::neon_node::LeaderKeyRegistrationState;
-
 /// Command types for the relayer thread, issued to it by other threads
 pub enum RelayerDirective {
     /// Handle some new data that arrived on the network (such as blocks, transactions, and
diff --git a/testnet/stacks-node/src/nakamoto_node.rs b/testnet/stacks-node/src/nakamoto_node.rs
index 1c71b09045..de0d04cfb5 100644
--- a/testnet/stacks-node/src/nakamoto_node.rs
+++ b/testnet/stacks-node/src/nakamoto_node.rs
@@ -20,13 +20,6 @@ use std::sync::mpsc::Receiver;
 use std::thread;
 use std::thread::JoinHandle;
 
-use super::{Config, EventDispatcher, Keychain};
-use crate::burnchains::bitcoin_regtest_controller::addr2str;
-use crate::globals::Globals;
-use crate::globals::RelayerDirective;
-use crate::neon_node::LeaderKeyRegistrationState;
-use crate::run_loop::nakamoto::RunLoop;
-use crate::run_loop::RegisteredKey;
 use clarity::vm::ast::ASTRules;
 use clarity::vm::types::QualifiedContractIdentifier;
 use stacks::burnchains::{Burnchain, BurnchainSigner, Txid};
@@ -52,6 +45,13 @@ use stacks_common::types::StacksEpochId;
 use stacks_common::util::get_epoch_time_secs;
 use stacks_common::util::secp256k1::Secp256k1PrivateKey;
 
+use super::{Config, EventDispatcher, Keychain};
+use crate::burnchains::bitcoin_regtest_controller::addr2str;
+use crate::globals::{Globals, RelayerDirective};
+use crate::neon_node::LeaderKeyRegistrationState;
+use crate::run_loop::nakamoto::RunLoop;
+use crate::run_loop::RegisteredKey;
+
 pub mod miner;
 pub mod peer;
 pub mod relayer;
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index cb9942d451..2d2d88293a 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -18,14 +18,6 @@ use std::thread;
 use std::thread::JoinHandle;
 use std::time::Instant;
 
-use super::relayer::RelayerThread;
-use super::Error as NakamotoNodeError;
-use super::{Config, EventDispatcher, Keychain};
-use crate::globals::Globals;
-use crate::mockamoto::signer::SelfSigner;
-use crate::nakamoto_node::VRF_MOCK_MINER_KEY;
-use crate::run_loop::RegisteredKey;
-use crate::ChainTip;
 use clarity::vm::types::PrincipalData;
 use stacks::burnchains::{Burnchain, BurnchainParameters};
 use stacks::chainstate::burn::db::sortdb::SortitionDB;
@@ -33,12 +25,9 @@ use stacks::chainstate::burn::{BlockSnapshot, ConsensusHash};
 use stacks::chainstate::nakamoto::miner::{NakamotoBlockBuilder, NakamotoTenureStart};
 use stacks::chainstate::nakamoto::{NakamotoBlock, NakamotoChainState};
 use stacks::chainstate::stacks::db::{StacksChainState, StacksHeaderInfo};
-use stacks::chainstate::stacks::Error as ChainstateError;
-use stacks::chainstate::stacks::TenureChangeCause;
-use stacks::chainstate::stacks::TenureChangePayload;
-use stacks::chainstate::stacks::ThresholdSignature;
 use stacks::chainstate::stacks::{
-    CoinbasePayload, StacksTransaction, StacksTransactionSigner, TransactionAnchorMode,
+    CoinbasePayload, Error as ChainstateError, StacksTransaction, StacksTransactionSigner,
+    TenureChangeCause, TenureChangePayload, ThresholdSignature, TransactionAnchorMode,
     TransactionPayload, TransactionVersion,
 };
 use stacks::core::mempool::MemPoolDB;
@@ -46,11 +35,18 @@ use stacks::core::FIRST_BURNCHAIN_CONSENSUS_HASH;
 use stacks::cost_estimates::metrics::UnitMetric;
 use stacks::cost_estimates::UnitEstimator;
 use stacks_common::types::chainstate::{StacksAddress, StacksBlockId};
-use stacks_common::types::PrivateKey;
-use stacks_common::types::StacksEpochId;
+use stacks_common::types::{PrivateKey, StacksEpochId};
 use stacks_common::util::hash::Hash160;
 use stacks_common::util::vrf::VRFProof;
 
+use super::relayer::RelayerThread;
+use super::{Config, Error as NakamotoNodeError, EventDispatcher, Keychain};
+use crate::globals::Globals;
+use crate::mockamoto::signer::SelfSigner;
+use crate::nakamoto_node::VRF_MOCK_MINER_KEY;
+use crate::run_loop::RegisteredKey;
+use crate::ChainTip;
+
 pub enum MinerDirective {
     /// The miner won sortition so they should begin a new tenure
     BeginTenure {
diff --git a/testnet/stacks-node/src/nakamoto_node/peer.rs b/testnet/stacks-node/src/nakamoto_node/peer.rs
index 8fe688972e..9f2a37c50d 100644
--- a/testnet/stacks-node/src/nakamoto_node/peer.rs
+++ b/testnet/stacks-node/src/nakamoto_node/peer.rs
@@ -13,45 +13,32 @@
 //
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
-use std::cmp;
 use std::collections::VecDeque;
-
 use std::default::Default;
 use std::net::SocketAddr;
 use std::sync::mpsc::TrySendError;
-
-use std::thread;
 use std::time::Duration;
+use std::{cmp, thread};
 
 use stacks::burnchains::db::BurnchainHeaderReader;
 use stacks::burnchains::PoxConstants;
 use stacks::chainstate::burn::db::sortdb::SortitionDB;
-
 use stacks::chainstate::stacks::db::StacksChainState;
 use stacks::chainstate::stacks::miner::signal_mining_blocked;
-
 use stacks::core::mempool::MemPoolDB;
-
 use stacks::cost_estimates::metrics::{CostMetric, UnitMetric};
 use stacks::cost_estimates::{CostEstimator, FeeEstimator, UnitEstimator};
-
 use stacks::net::dns::{DNSClient, DNSResolver};
 use stacks::net::p2p::PeerNetwork;
-
 use stacks::net::RPCHandlerArgs;
-
 use stacks_common::util::hash::Sha256Sum;
 
+use super::open_chainstate_with_faults;
 use crate::burnchains::make_bitcoin_indexer;
-use crate::globals::Globals;
-use crate::globals::RelayerDirective;
-
+use crate::globals::{Globals, RelayerDirective};
 use crate::run_loop::nakamoto::RunLoop;
-
 use crate::{Config, EventDispatcher};
 
-use super::open_chainstate_with_faults;
-
 /// Thread that runs the network state machine, handling both p2p and http requests.
 pub struct PeerThread {
     /// Node config
diff --git a/testnet/stacks-node/src/nakamoto_node/relayer.rs b/testnet/stacks-node/src/nakamoto_node/relayer.rs
index a90b17866f..6aa4568d0b 100644
--- a/testnet/stacks-node/src/nakamoto_node/relayer.rs
+++ b/testnet/stacks-node/src/nakamoto_node/relayer.rs
@@ -13,6 +13,11 @@
 //
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
+use std::collections::HashMap;
+use std::sync::mpsc::{Receiver, RecvTimeoutError};
+use std::thread::JoinHandle;
+use std::time::{Duration, Instant};
+
 use stacks::burnchains::{Burnchain, Txid};
 use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::burn::operations::leader_block_commit::{
@@ -30,9 +35,9 @@ use stacks::chainstate::stacks::miner::{
     get_mining_spend_amount, signal_mining_blocked, signal_mining_ready,
 };
 use stacks::core::mempool::MemPoolDB;
-use stacks::core::FIRST_BURNCHAIN_CONSENSUS_HASH;
-use stacks::core::FIRST_STACKS_BLOCK_HASH;
-use stacks::core::STACKS_EPOCH_3_0_MARKER;
+use stacks::core::{
+    FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH, STACKS_EPOCH_3_0_MARKER,
+};
 use stacks::cost_estimates::metrics::UnitMetric;
 use stacks::cost_estimates::UnitEstimator;
 use stacks::monitoring::increment_stx_blocks_mined_counter;
@@ -46,21 +51,13 @@ use stacks_common::types::StacksEpochId;
 use stacks_common::util::get_epoch_time_ms;
 use stacks_common::util::hash::Hash160;
 use stacks_common::util::vrf::{VRFProof, VRFPublicKey};
-use std::collections::HashMap;
-use std::sync::mpsc::Receiver;
-use std::sync::mpsc::RecvTimeoutError;
-use std::thread::JoinHandle;
-use std::time::Duration;
-use std::time::Instant;
 
-use super::Error as NakamotoNodeError;
 use super::{
     fault_injection_skip_mining, open_chainstate_with_faults, BlockCommits, Config,
-    EventDispatcher, Keychain, BLOCK_PROCESSOR_STACK_SIZE,
+    Error as NakamotoNodeError, EventDispatcher, Keychain, BLOCK_PROCESSOR_STACK_SIZE,
 };
 use crate::burnchains::BurnchainController;
-use crate::globals::Globals;
-use crate::globals::RelayerDirective;
+use crate::globals::{Globals, RelayerDirective};
 use crate::nakamoto_node::miner::{BlockMinerThread, MinerDirective};
 use crate::neon_node::LeaderKeyRegistrationState;
 use crate::run_loop::nakamoto::RunLoop;
@@ -127,8 +124,9 @@ pub struct RelayerThread {
     ///  to check if it should issue a block commit or try to register a VRF key
     next_initiative: Instant,
     is_miner: bool,
-    /// This is the last snapshot in which the relayer committed
-    last_committed_at: Option<BlockSnapshot>,
+    /// This is the last snapshot in which the relayer committed, and the parent_tenure_id
+    ///  which was committed to
+    last_committed: Option<(BlockSnapshot, StacksBlockId)>,
 }
 
 impl RelayerThread {
@@ -193,7 +191,7 @@ impl RelayerThread {
             miner_thread: None,
             is_miner,
             next_initiative: Instant::now() + Duration::from_secs(10),
-            last_committed_at: None,
+            last_committed: None,
         }
     }
 
@@ -759,7 +757,10 @@ impl RelayerThread {
         );
 
         self.last_commits.insert(txid, ());
-        self.last_committed_at = Some(last_committed_at);
+        self.last_committed = Some((
+            last_committed_at,
+            StacksBlockId::new(&tenure_start_ch, &tenure_start_bh),
+        ));
         self.globals.counters.bump_naka_submitted_commits();
 
         Ok(())
@@ -800,7 +801,10 @@ impl RelayerThread {
             return None;
         };
 
-        let should_commit = if let Some(last_committed_at) = self.last_committed_at.as_ref() {
+        // check if the burnchain changed, if so, we should issue a commit.
+        //  if not, we may still want to update a commit if we've received a new tenure start block
+        let burnchain_changed = if let Some((last_committed_at, ..)) = self.last_committed.as_ref()
+        {
             // if the new sortition tip has a different consesus hash than the last commit,
             //  issue a new commit
             sort_tip.consensus_hash != last_committed_at.consensus_hash
@@ -820,37 +824,38 @@ impl RelayerThread {
             ));
         };
 
-        if should_commit {
-            // TODO: just use `get_block_header_by_consensus_hash`?
-            let first_block_hash = if chain_tip_header
-                .anchored_header
-                .as_stacks_nakamoto()
-                .is_some()
-            {
-                // if the parent block is a nakamoto block, find the starting block of its tenure
-                let Ok(Some(first_block)) =
-                    NakamotoChainState::get_nakamoto_tenure_start_block_header(
-                        self.chainstate_ref().db(),
-                        &chain_tip_header.consensus_hash,
-                    )
-                else {
-                    warn!("Failure getting the first block of tenure in order to assemble block commit";
-                          "tenure_consensus_hash" => %chain_tip_header.consensus_hash,
-                          "tip_block_hash" => %chain_tip_header.anchored_header.block_hash());
-                    return None;
-                };
-                first_block.anchored_header.block_hash()
+        // get the starting block of the chain tip's tenure
+        let Ok(Some(chain_tip_tenure_start)) =
+            NakamotoChainState::get_block_header_by_consensus_hash(
+                self.chainstate_ref().db(),
+                &chain_tip_header.consensus_hash,
+            )
+        else {
+            warn!("Failure getting the first block of tenure in order to assemble block commit";
+                  "tenure_consensus_hash" => %chain_tip_header.consensus_hash,
+                  "tip_block_hash" => %chain_tip_header.anchored_header.block_hash());
+            return None;
+        };
+
+        let chain_tip_tenure_id = chain_tip_tenure_start.index_block_hash();
+        let should_commit = burnchain_changed
+            || if let Some((_, last_committed_tenure_id)) = self.last_committed.as_ref() {
+                // if the tenure ID of the chain tip has changed, issue a new commit
+                last_committed_tenure_id != &chain_tip_tenure_id
             } else {
-                // otherwise the parent block is a epoch2 block, just return its hash directly
-                chain_tip_header.anchored_header.block_hash()
+                // should be unreachable, but either way, if
+                //  `self.last_committed` is None, we should issue a commit
+                true
             };
-            return Some(RelayerDirective::NakamotoTenureStartProcessed(
+
+        if should_commit {
+            Some(RelayerDirective::NakamotoTenureStartProcessed(
                 chain_tip_header.consensus_hash,
-                first_block_hash,
-            ));
+                chain_tip_header.anchored_header.block_hash(),
+            ))
+        } else {
+            None
         }
-
-        return None;
     }
 
     /// Main loop of the relayer.
diff --git a/testnet/stacks-node/src/neon_node.rs b/testnet/stacks-node/src/neon_node.rs
index c23bf1fc19..a3821fae2b 100644
--- a/testnet/stacks-node/src/neon_node.rs
+++ b/testnet/stacks-node/src/neon_node.rs
@@ -206,8 +206,7 @@ use crate::burnchains::bitcoin_regtest_controller::{
     addr2str, BitcoinRegtestController, OngoingBlockCommit,
 };
 use crate::burnchains::make_bitcoin_indexer;
-use crate::globals::Globals;
-use crate::globals::RelayerDirective;
+use crate::globals::{Globals, RelayerDirective};
 use crate::run_loop::neon::RunLoop;
 use crate::run_loop::RegisteredKey;
 use crate::ChainTip;
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index efa36ea1e5..a7be83272f 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -1,32 +1,43 @@
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::Arc;
+use std::time::{Duration, Instant};
+use std::{env, thread};
+
+use clarity::vm::costs::ExecutionCost;
 use clarity::vm::types::PrincipalData;
+use lazy_static::lazy_static;
 use stacks::burnchains::MagicBytes;
+use stacks::chainstate::coordinator::comm::CoordinatorChannels;
 use stacks::chainstate::nakamoto::NakamotoChainState;
 use stacks::chainstate::stacks::db::StacksChainState;
 use stacks::core::{
-    StacksEpoch, StacksEpochId, BLOCK_LIMIT_MAINNET_10, HELIUM_BLOCK_LIMIT_20,
+    MemPoolDB, StacksEpoch, StacksEpochId, BLOCK_LIMIT_MAINNET_10, HELIUM_BLOCK_LIMIT_20,
     PEER_VERSION_EPOCH_1_0, PEER_VERSION_EPOCH_2_0, PEER_VERSION_EPOCH_2_05,
     PEER_VERSION_EPOCH_2_1, PEER_VERSION_EPOCH_2_2, PEER_VERSION_EPOCH_2_3, PEER_VERSION_EPOCH_2_4,
     PEER_VERSION_EPOCH_2_5, PEER_VERSION_EPOCH_3_0,
 };
+use stacks::cost_estimates::metrics::UnitMetric;
+use stacks::cost_estimates::UnitEstimator;
 use stacks_common::address::AddressHashMode;
 use stacks_common::consts::STACKS_EPOCH_MAX;
 use stacks_common::types::chainstate::StacksAddress;
 use stacks_common::util::hash::to_hex;
 use stacks_common::util::secp256k1::Secp256k1PrivateKey;
-use std::sync::atomic::Ordering;
-use std::time::{Duration, Instant};
-use std::{env, thread};
 
 use super::bitcoin_regtest::BitcoinCoreController;
+use crate::config::{EventKeyType, EventObserverConfig};
 use crate::mockamoto::signer::SelfSigner;
 use crate::run_loop::nakamoto;
+use crate::tests::make_stacks_transfer;
 use crate::tests::neon_integrations::{
-    next_block_and_wait, run_until_burnchain_height, submit_tx, wait_for_runloop,
+    next_block_and_wait, run_until_burnchain_height, submit_tx, test_observer, wait_for_runloop,
 };
 use crate::{
     neon, tests, BitcoinRegtestController, BurnchainController, Config, ConfigFile, Keychain,
 };
-use lazy_static::lazy_static;
+
+static POX_4_DEFAULT_STACKER_BALANCE: u64 = 100_000_000_000_000;
+static POX_4_DEFAULT_STACKER_STX_AMT: u128 = 99_000_000_000_000;
 
 lazy_static! {
     pub static ref NAKAMOTO_INTEGRATION_EPOCHS: [StacksEpoch; 9] = [
@@ -179,44 +190,83 @@ where
     Ok(())
 }
 
-#[test]
-#[ignore]
-fn simple_neon_integration() {
-    if env::var("BITCOIND_TEST") != Ok("1".into()) {
-        return;
-    }
+/// Mine a bitcoin block, and wait until:
+///  (1) a new block has been processed by the coordinator
+///  (2) 2 block commits have been issued ** or ** more than 10 seconds have
+///      passed since (1) occurred
+fn next_block_and_mine_commit(
+    btc_controller: &mut BitcoinRegtestController,
+    timeout_secs: u64,
+    coord_channels: &CoordinatorChannels,
+    commits_submitted: &Arc<AtomicU64>,
+) -> Result<(), String> {
+    let commits_submitted = commits_submitted.clone();
+    let blocks_processed_before = coord_channels.get_stacks_blocks_processed();
+    let commits_before = commits_submitted.load(Ordering::SeqCst);
+    let mut block_processed_time: Option<Instant> = None;
+    next_block_and(btc_controller, timeout_secs, || {
+        if let Some(block_processed_time) = block_processed_time.as_ref() {
+            let commits_sent = commits_submitted.load(Ordering::SeqCst);
+            if commits_sent >= commits_before + 2 {
+                return Ok(true);
+            }
+            if commits_sent >= commits_before + 1
+                && block_processed_time.elapsed() > Duration::from_secs(10)
+            {
+                return Ok(true);
+            }
+            Ok(false)
+        } else {
+            let blocks_processed = coord_channels.get_stacks_blocks_processed();
+            if blocks_processed > blocks_processed_before {
+                block_processed_time.replace(Instant::now());
+            }
+            Ok(false)
+        }
+    })
+}
 
-    let (mut naka_conf, _miner_account) = naka_neon_integration_conf(None);
+fn setup_stacker(naka_conf: &mut Config) -> Secp256k1PrivateKey {
     let stacker_sk = Secp256k1PrivateKey::new();
     let stacker_address = tests::to_addr(&stacker_sk);
     naka_conf.add_initial_balance(
         PrincipalData::from(stacker_address.clone()).to_string(),
-        100_000_000_000_000,
+        POX_4_DEFAULT_STACKER_BALANCE,
     );
+    stacker_sk
+}
 
+///
+/// * `stacker_sk` - must be a private key for sending a large `stack-stx` transaction in order
+///   for pox-4 to activate
+fn boot_to_epoch_3(
+    naka_conf: &Config,
+    stacker_sk: Secp256k1PrivateKey,
+    btc_regtest_controller: &mut BitcoinRegtestController,
+) {
     let epoch_2_conf = naka_conf.clone();
-
-    let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone());
-    btcd_controller
-        .start_bitcoind()
-        .expect("Failed starting bitcoind");
-
-    let mut btc_regtest_controller = BitcoinRegtestController::new(naka_conf.clone(), None);
-    let http_origin = format!("http://{}", &naka_conf.node.rpc_bind);
     btc_regtest_controller.bootstrap_chain(201);
 
-    info!("Chain bootstrapped to bitcoin block 201, starting a epoch-2x miner");
+    let epochs = epoch_2_conf.burnchain.epochs.clone().unwrap();
 
+    let epoch_3 = &epochs[StacksEpoch::find_epoch_by_id(&epochs, StacksEpochId::Epoch30).unwrap()];
+
+    info!(
+        "Chain bootstrapped to bitcoin block 201, starting Epoch 2x miner";
+        "Epoch 3.0 Boundary" => (epoch_3.start_height - 1),
+    );
+    let http_origin = format!("http://{}", &epoch_2_conf.node.rpc_bind);
     let mut run_loop = neon::RunLoop::new(epoch_2_conf.clone());
 
     let epoch_2_stopper = run_loop.get_termination_switch();
     let blocks_processed = run_loop.get_blocks_processed_arc();
     let epoch_2_thread = thread::spawn(move || run_loop.start(None, 0));
     wait_for_runloop(&blocks_processed);
-    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
-    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+    next_block_and_wait(btc_regtest_controller, &blocks_processed);
+    next_block_and_wait(btc_regtest_controller, &blocks_processed);
     // first mined stacks block
-    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+    next_block_and_wait(btc_regtest_controller, &blocks_processed);
+
     // stack enough to activate pox-4
     let pox_addr_tuple = clarity::vm::tests::execute(&format!(
         "{{ hashbytes: 0x{}, version: 0x{:02x} }}",
@@ -232,7 +282,7 @@ fn simple_neon_integration() {
         "pox-4",
         "stack-stx",
         &[
-            clarity::vm::Value::UInt(99_000_000_000_000),
+            clarity::vm::Value::UInt(POX_4_DEFAULT_STACKER_STX_AMT),
             pox_addr_tuple,
             clarity::vm::Value::UInt(205),
             clarity::vm::Value::UInt(12),
@@ -242,23 +292,82 @@ fn simple_neon_integration() {
     submit_tx(&http_origin, &stacking_tx);
 
     run_until_burnchain_height(
-        &mut btc_regtest_controller,
+        btc_regtest_controller,
         &blocks_processed,
-        219,
+        epoch_3.start_height - 1,
         &epoch_2_conf,
     );
 
-    info!("Bootstrapped to Epoch-3.0 boundary, starting nakamoto miner");
+    info!("Bootstrapped to Epoch-3.0 boundary, stopping Epoch2x miner");
     epoch_2_stopper.store(false, Ordering::SeqCst);
-
     epoch_2_thread.join().unwrap();
+}
+
+#[test]
+#[ignore]
+/// This test spins up a nakamoto-neon node.
+/// It starts in Epoch 2.0, mines with `neon_node` to Epoch 3.0, and then switches
+///  to Nakamoto operation (activating pox-4 by submitting a stack-stx tx).
+/// This test makes three assertions:
+///  * 30 blocks are mined after 3.0 starts. This is enough to mine across 2 reward cycles
+///  * A transaction submitted to the mempool in 3.0 will be mined in 3.0
+///  * The final chain tip is a nakamoto block
+fn simple_neon_integration() {
+    if env::var("BITCOIND_TEST") != Ok("1".into()) {
+        return;
+    }
+
+    let (mut naka_conf, _miner_account) = naka_neon_integration_conf(None);
+    let sender_sk = Secp256k1PrivateKey::new();
+    // setup sender + recipient for a test stx transfer
+    let sender_addr = tests::to_addr(&sender_sk);
+    let send_amt = 1000;
+    let send_fee = 100;
+    naka_conf.add_initial_balance(
+        PrincipalData::from(sender_addr.clone()).to_string(),
+        send_amt + send_fee,
+    );
+    let recipient = PrincipalData::from(StacksAddress::burn_address(false));
+    let stacker_sk = setup_stacker(&mut naka_conf);
+
+    let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone());
+    btcd_controller
+        .start_bitcoind()
+        .expect("Failed starting bitcoind");
+    let mut btc_regtest_controller = BitcoinRegtestController::new(naka_conf.clone(), None);
+
+    boot_to_epoch_3(&naka_conf, stacker_sk, &mut btc_regtest_controller);
+
+    info!("Bootstrapped to Epoch-3.0 boundary, starting nakamoto miner");
+
+    let burnchain = naka_conf.get_burnchain();
+    let sortdb = burnchain.open_sortition_db(true).unwrap();
+    let (mut chainstate, _) = StacksChainState::open(
+        naka_conf.is_mainnet(),
+        naka_conf.burnchain.chain_id,
+        &naka_conf.get_chainstate_path_str(),
+        None,
+    )
+    .unwrap();
+
+    let block_height_pre_3_0 =
+        NakamotoChainState::get_canonical_block_header(chainstate.db(), &sortdb)
+            .unwrap()
+            .unwrap()
+            .stacks_block_height;
+
+    test_observer::spawn();
+    let observer_port = test_observer::EVENT_OBSERVER_PORT;
+    naka_conf.events_observers.insert(EventObserverConfig {
+        endpoint: format!("localhost:{observer_port}"),
+        events_keys: vec![EventKeyType::AnyEvent],
+    });
 
     let mut run_loop = nakamoto::RunLoop::new(naka_conf.clone());
     let epoch_3_stopper = run_loop.get_termination_switch();
     let blocks_processed = run_loop.get_blocks_processed_arc();
     let vrfs_submitted = run_loop.submitted_vrfs();
     let commits_submitted = run_loop.submitted_commits();
-    let blocks_mined = run_loop.submitted_commits();
     let coord_channel = run_loop.get_coordinator_channel().unwrap();
 
     let epoch_3_thread = thread::spawn(move || run_loop.start(None, 0));
@@ -279,41 +388,87 @@ fn simple_neon_integration() {
     })
     .unwrap();
 
-    let blocks_processed_before_mining = coord_channel.get_stacks_blocks_processed();
-
-    // this block should perform the sortition, wait until a block is mined
-    next_block_and(&mut btc_regtest_controller, 60, || {
-        let mined_count = blocks_mined.load(Ordering::SeqCst);
-        Ok(mined_count >= 1)
-    })
-    .unwrap();
-
-    // wait until the coordinator has processed the new block(s)
-    while coord_channel.get_stacks_blocks_processed() <= blocks_processed_before_mining {
-        thread::sleep(Duration::from_secs(1));
+    // Mine 15 nakamoto tenures
+    for _i in 0..15 {
+        next_block_and_mine_commit(
+            &mut btc_regtest_controller,
+            60,
+            &coord_channel,
+            &commits_submitted,
+        )
+        .unwrap();
     }
 
-    // load the chain tip, and assert that it is a nakamoto block
+    // Submit a TX
+    let transfer_tx = make_stacks_transfer(&sender_sk, 0, send_fee, &recipient, send_amt);
+    let transfer_tx_hex = format!("0x{}", to_hex(&transfer_tx));
 
-    let burnchain = naka_conf.get_burnchain();
-    let sortdb = burnchain.open_sortition_db(true).unwrap();
-    let (chainstate, _) = StacksChainState::open(
+    let tip = NakamotoChainState::get_canonical_block_header(chainstate.db(), &sortdb)
+        .unwrap()
+        .unwrap();
+
+    let mut mempool = MemPoolDB::open(
         naka_conf.is_mainnet(),
         naka_conf.burnchain.chain_id,
         &naka_conf.get_chainstate_path_str(),
-        None,
+        Box::new(UnitEstimator),
+        Box::new(UnitMetric),
     )
-    .unwrap();
+    .expect("Database failure opening mempool");
+
+    mempool
+        .submit_raw(
+            &mut chainstate,
+            &sortdb,
+            &tip.consensus_hash,
+            &tip.anchored_header.block_hash(),
+            transfer_tx.clone(),
+            &ExecutionCost::max_value(),
+            &StacksEpochId::Epoch30,
+        )
+        .unwrap();
 
+    // Mine 15 more nakamoto tenures
+    for _i in 0..15 {
+        next_block_and_mine_commit(
+            &mut btc_regtest_controller,
+            60,
+            &coord_channel,
+            &commits_submitted,
+        )
+        .unwrap();
+    }
+
+    // load the chain tip, and assert that it is a nakamoto block and at least 30 blocks have advanced in epoch 3
     let tip = NakamotoChainState::get_canonical_block_header(chainstate.db(), &sortdb)
         .unwrap()
         .unwrap();
     info!(
         "Latest tip";
+        "height" => tip.stacks_block_height,
         "is_nakamoto" => tip.anchored_header.as_stacks_nakamoto().is_some(),
     );
 
+    // assert that the transfer tx was observed
+    let transfer_tx_included = test_observer::get_blocks()
+        .into_iter()
+        .find(|block_json| {
+            block_json["transactions"]
+                .as_array()
+                .unwrap()
+                .iter()
+                .find(|tx_json| tx_json["raw_tx"].as_str() == Some(&transfer_tx_hex))
+                .is_some()
+        })
+        .is_some();
+
+    assert!(
+        transfer_tx_included,
+        "Nakamoto node failed to include the transfer tx"
+    );
+
     assert!(tip.anchored_header.as_stacks_nakamoto().is_some());
+    assert!(tip.stacks_block_height >= block_height_pre_3_0 + 30);
 
     coord_channel.stop_chains_coordinator();
 

From 25d1b52d7396c2617802ae1bd8fd32cfbf967247 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Sat, 9 Dec 2023 13:02:21 -0600
Subject: [PATCH 0186/1166] feat: add boot_nakamoto to wrap the 2.x/3.x node
 handoff

---
 stackslib/src/burnchains/bitcoin/indexer.rs   |  13 +-
 stackslib/src/core/mod.rs                     |  27 +++
 testnet/stacks-node/src/main.rs               |   4 +-
 .../stacks-node/src/nakamoto_node/miner.rs    |   3 -
 .../stacks-node/src/run_loop/boot_nakamoto.rs | 205 ++++++++++++++++++
 testnet/stacks-node/src/run_loop/mod.rs       |   1 +
 testnet/stacks-node/src/run_loop/nakamoto.rs  |  11 +-
 .../src/tests/nakamoto_integrations.rs        |  99 +++++----
 8 files changed, 300 insertions(+), 63 deletions(-)
 create mode 100644 testnet/stacks-node/src/run_loop/boot_nakamoto.rs

diff --git a/stackslib/src/burnchains/bitcoin/indexer.rs b/stackslib/src/burnchains/bitcoin/indexer.rs
index c273a38de4..6f6b82ceec 100644
--- a/stackslib/src/burnchains/bitcoin/indexer.rs
+++ b/stackslib/src/burnchains/bitcoin/indexer.rs
@@ -46,7 +46,8 @@ use crate::burnchains::{
     Burnchain, BurnchainBlockHeader, Error as burnchain_error, MagicBytes, BLOCKSTACK_MAGIC_MAINNET,
 };
 use crate::core::{
-    StacksEpoch, STACKS_EPOCHS_MAINNET, STACKS_EPOCHS_REGTEST, STACKS_EPOCHS_TESTNET,
+    StacksEpoch, StacksEpochExtension, STACKS_EPOCHS_MAINNET, STACKS_EPOCHS_REGTEST,
+    STACKS_EPOCHS_TESTNET,
 };
 use crate::util_lib::db::Error as DBError;
 
@@ -91,7 +92,7 @@ impl TryFrom<u32> for BitcoinNetworkType {
 /// Get the default epochs definitions for the given BitcoinNetworkType.
 /// Should *not* be used except by the BitcoinIndexer when no epochs vector
 /// was specified.
-fn get_bitcoin_stacks_epochs(network_id: BitcoinNetworkType) -> Vec<StacksEpoch> {
+pub fn get_bitcoin_stacks_epochs(network_id: BitcoinNetworkType) -> Vec<StacksEpoch> {
     match network_id {
         BitcoinNetworkType::Mainnet => STACKS_EPOCHS_MAINNET.to_vec(),
         BitcoinNetworkType::Testnet => STACKS_EPOCHS_TESTNET.to_vec(),
@@ -1030,13 +1031,7 @@ impl BurnchainIndexer for BitcoinIndexer {
     ///
     /// It is an error (panic) to set custom epochs if running on `Mainnet`.
     fn get_stacks_epochs(&self) -> Vec<StacksEpoch> {
-        match self.config.epochs {
-            Some(ref epochs) => {
-                assert!(self.runtime.network_id != BitcoinNetworkType::Mainnet);
-                epochs.clone()
-            }
-            None => get_bitcoin_stacks_epochs(self.runtime.network_id),
-        }
+        StacksEpoch::get_epochs(self.runtime.network_id, self.config.epochs.as_ref())
     }
 
     /// Read downloaded headers within a range
diff --git a/stackslib/src/core/mod.rs b/stackslib/src/core/mod.rs
index b03fe0c8e0..38f383194e 100644
--- a/stackslib/src/core/mod.rs
+++ b/stackslib/src/core/mod.rs
@@ -25,6 +25,8 @@ pub use stacks_common::types::StacksEpochId;
 use stacks_common::util::log;
 
 pub use self::mempool::MemPoolDB;
+use crate::burnchains::bitcoin::indexer::get_bitcoin_stacks_epochs;
+use crate::burnchains::bitcoin::BitcoinNetworkType;
 use crate::burnchains::{Burnchain, Error as burnchain_error};
 use crate::chainstate::burn::ConsensusHash;
 pub mod mempool;
@@ -604,9 +606,34 @@ pub trait StacksEpochExtension {
         epoch_2_1_block_height: u64,
     ) -> Vec<StacksEpoch>;
     fn validate_epochs(epochs: &[StacksEpoch]) -> Vec<StacksEpoch>;
+    /// This method gets the epoch vector.
+    ///
+    /// Choose according to:
+    /// 1) Use the custom epochs defined on the underlying `BitcoinIndexerConfig`, if they exist.
+    /// 2) Use hard-coded static values, otherwise.
+    ///
+    /// It is an error (panic) to set custom epochs if running on `Mainnet`.
+    ///
+    fn get_epochs(
+        bitcoin_network: BitcoinNetworkType,
+        configured_epochs: Option<&Vec<StacksEpoch>>,
+    ) -> Vec<StacksEpoch>;
 }
 
 impl StacksEpochExtension for StacksEpoch {
+    fn get_epochs(
+        bitcoin_network: BitcoinNetworkType,
+        configured_epochs: Option<&Vec<StacksEpoch>>,
+    ) -> Vec<StacksEpoch> {
+        match configured_epochs {
+            Some(epochs) => {
+                assert!(bitcoin_network != BitcoinNetworkType::Mainnet);
+                epochs.clone()
+            }
+            None => get_bitcoin_stacks_epochs(bitcoin_network),
+        }
+    }
+
     #[cfg(test)]
     fn unit_test_pre_2_05(first_burnchain_height: u64) -> Vec<StacksEpoch> {
         info!(
diff --git a/testnet/stacks-node/src/main.rs b/testnet/stacks-node/src/main.rs
index 8675b43132..d180aead8b 100644
--- a/testnet/stacks-node/src/main.rs
+++ b/testnet/stacks-node/src/main.rs
@@ -46,7 +46,7 @@ pub use self::node::{ChainTip, Node};
 pub use self::run_loop::{helium, neon};
 pub use self::tenure::Tenure;
 use crate::mockamoto::MockamotoNode;
-use crate::run_loop::nakamoto;
+use crate::run_loop::boot_nakamoto;
 
 fn main() {
     panic::set_hook(Box::new(|panic_info| {
@@ -213,7 +213,7 @@ fn main() {
         let mut mockamoto = MockamotoNode::new(&conf).unwrap();
         mockamoto.run();
     } else if conf.burnchain.mode == "nakamoto-neon" {
-        let mut run_loop = nakamoto::RunLoop::new(conf);
+        let mut run_loop = boot_nakamoto::BootRunLoop::new(conf).unwrap();
         run_loop.start(None, 0);
     } else {
         println!("Burnchain mode '{}' not supported", conf.burnchain.mode);
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index 2d2d88293a..bc684a07bf 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -16,7 +16,6 @@
 use std::convert::TryFrom;
 use std::thread;
 use std::thread::JoinHandle;
-use std::time::Instant;
 
 use clarity::vm::types::PrincipalData;
 use stacks::burnchains::{Burnchain, BurnchainParameters};
@@ -398,8 +397,6 @@ impl BlockMinerThread {
         )
         .expect("Database failure opening mempool");
 
-        let assembly_start = Instant::now();
-
         let target_epoch_id =
             SortitionDB::get_stacks_epoch(burn_db.conn(), self.burn_block.block_height + 1)
                 .ok()?
diff --git a/testnet/stacks-node/src/run_loop/boot_nakamoto.rs b/testnet/stacks-node/src/run_loop/boot_nakamoto.rs
new file mode 100644
index 0000000000..1b54c24f5a
--- /dev/null
+++ b/testnet/stacks-node/src/run_loop/boot_nakamoto.rs
@@ -0,0 +1,205 @@
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Arc, Mutex};
+use std::thread::JoinHandle;
+use std::time::Duration;
+use std::{fs, thread};
+
+use stacks::burnchains::Burnchain;
+use stacks::chainstate::burn::db::sortdb::SortitionDB;
+use stacks::chainstate::coordinator::comm::CoordinatorChannels;
+use stacks::core::StacksEpochExtension;
+use stacks_common::types::{StacksEpoch, StacksEpochId};
+
+use crate::neon::Counters;
+use crate::run_loop::nakamoto::RunLoop as NakaRunLoop;
+use crate::run_loop::neon::RunLoop as NeonRunLoop;
+use crate::Config;
+
+/// This runloop handles booting to Nakamoto:
+/// During epochs [1.0, 2.5], it runs a neon run_loop.
+/// Once epoch 3.0 is reached, it stops the neon run_loop
+///  and starts nakamoto.
+pub struct BootRunLoop {
+    config: Config,
+    active_loop: InnerLoops,
+    coordinator_channels: Arc<Mutex<CoordinatorChannels>>,
+}
+
+enum InnerLoops {
+    Epoch2(NeonRunLoop),
+    Epoch3(NakaRunLoop),
+}
+
+impl BootRunLoop {
+    pub fn new(config: Config) -> Result<Self, String> {
+        let (coordinator_channels, active_loop) = if !Self::reached_epoch_30_transition(&config)? {
+            let neon = NeonRunLoop::new(config.clone());
+            (
+                neon.get_coordinator_channel().unwrap(),
+                InnerLoops::Epoch2(neon),
+            )
+        } else {
+            let naka = NakaRunLoop::new(config.clone(), None, None);
+            (
+                naka.get_coordinator_channel().unwrap(),
+                InnerLoops::Epoch3(naka),
+            )
+        };
+
+        Ok(BootRunLoop {
+            config,
+            active_loop,
+            coordinator_channels: Arc::new(Mutex::new(coordinator_channels)),
+        })
+    }
+
+    /// Get a mutex-guarded pointer to this run-loops coordinator channels.
+    ///  The reason this must be mutex guarded is that the run loop will switch
+    ///  from a "neon" coordinator to a "nakamoto" coordinator, and update the
+    ///  backing coordinator channel. That way, anyone still holding the Arc<>
+    ///  should be able to query the new coordinator channel.
+    pub fn coordinator_channels(&self) -> Arc<Mutex<CoordinatorChannels>> {
+        self.coordinator_channels.clone()
+    }
+
+    /// Get the runtime counters for the inner runloop. The nakamoto
+    ///  runloop inherits the counters object from the neon node,
+    ///  so no need for another layer of indirection/mutex.
+    pub fn counters(&self) -> Counters {
+        match &self.active_loop {
+            InnerLoops::Epoch2(x) => x.get_counters(),
+            InnerLoops::Epoch3(x) => x.get_counters(),
+        }
+    }
+
+    /// Get the termination switch from the active run loop.
+    pub fn get_termination_switch(&self) -> Arc<AtomicBool> {
+        match &self.active_loop {
+            InnerLoops::Epoch2(x) => x.get_termination_switch(),
+            InnerLoops::Epoch3(x) => x.get_termination_switch(),
+        }
+    }
+
+    /// The main entry point for the run loop. This starts either a 2.x-neon or 3.x-nakamoto
+    /// node depending on the current burnchain height.
+    pub fn start(&mut self, burnchain_opt: Option<Burnchain>, mine_start: u64) {
+        match self.active_loop {
+            InnerLoops::Epoch2(_) => return self.start_from_neon(burnchain_opt, mine_start),
+            InnerLoops::Epoch3(_) => return self.start_from_naka(burnchain_opt, mine_start),
+        }
+    }
+
+    fn start_from_naka(&mut self, burnchain_opt: Option<Burnchain>, mine_start: u64) {
+        let InnerLoops::Epoch3(ref mut naka_loop) = self.active_loop else {
+            panic!("FATAL: unexpectedly invoked start_from_naka when active loop wasn't nakamoto");
+        };
+        naka_loop.start(burnchain_opt, mine_start)
+    }
+
+    fn start_from_neon(&mut self, burnchain_opt: Option<Burnchain>, mine_start: u64) {
+        let InnerLoops::Epoch2(ref mut neon_loop) = self.active_loop else {
+            panic!("FATAL: unexpectedly invoked start_from_neon when active loop wasn't neon");
+        };
+        let termination_switch = neon_loop.get_termination_switch();
+        let counters = neon_loop.get_counters();
+
+        let boot_thread = Self::spawn_stopper(&self.config, neon_loop)
+            .expect("FATAL: failed to spawn epoch-2/3-boot thread");
+        neon_loop.start(burnchain_opt.clone(), mine_start);
+
+        // did we exit because of the epoch-3.0 transition, or some other reason?
+        let exited_for_transition = boot_thread
+            .join()
+            .expect("FATAL: failed to join epoch-2/3-boot thread");
+        if !exited_for_transition {
+            info!("Shutting down epoch-2/3 transition thread");
+            return;
+        }
+        info!("Reached Epoch-3.0 boundary, starting nakamoto node");
+        termination_switch.store(true, Ordering::SeqCst);
+        let naka = NakaRunLoop::new(
+            self.config.clone(),
+            Some(termination_switch),
+            Some(counters),
+        );
+        let new_coord_channels = naka
+            .get_coordinator_channel()
+            .expect("FATAL: should have coordinator channel in newly instantiated runloop");
+        {
+            let mut coord_channel = self.coordinator_channels.lock().expect("Mutex poisoned");
+            *coord_channel = new_coord_channels;
+        }
+        self.active_loop = InnerLoops::Epoch3(naka);
+        let InnerLoops::Epoch3(ref mut naka_loop) = self.active_loop else {
+            panic!("FATAL: unexpectedly found epoch2 loop after setting epoch3 active");
+        };
+        naka_loop.start(burnchain_opt, mine_start)
+    }
+
+    fn spawn_stopper(
+        config: &Config,
+        neon: &NeonRunLoop,
+    ) -> Result<JoinHandle<bool>, std::io::Error> {
+        let neon_term_switch = neon.get_termination_switch();
+        let config = config.clone();
+        thread::Builder::new()
+            .name("epoch-2/3-boot".into())
+            .spawn(move || {
+                loop {
+                    let do_transition = Self::reached_epoch_30_transition(&config)
+                        .unwrap_or_else(|err| {
+                            warn!("Error checking for Epoch-3.0 transition: {err:?}. Assuming transition did not occur yet.");
+                            false
+                        });
+                    if do_transition {
+                        break;
+                    }
+                    if !neon_term_switch.load(Ordering::SeqCst) {
+                        info!("Stop requested, exiting epoch-2/3-boot thread");
+                        return false;
+                    }
+                    thread::sleep(Duration::from_secs(1));
+                }
+                // if loop exited, do the transition
+                info!("Epoch-3.0 boundary reached, stopping Epoch-2.x run loop");
+                neon_term_switch.store(false, Ordering::SeqCst);
+                return true
+            })
+    }
+
+    fn reached_epoch_30_transition(config: &Config) -> Result<bool, String> {
+        let burn_height = Self::get_burn_height(config)?;
+        let epochs = StacksEpoch::get_epochs(
+            config.burnchain.get_bitcoin_network().1,
+            config.burnchain.epochs.as_ref(),
+        );
+        let epoch_3 = &epochs[StacksEpoch::find_epoch_by_id(&epochs, StacksEpochId::Epoch30)
+            .ok_or("No Epoch-3.0 defined")?];
+
+        Ok(u64::from(burn_height) >= epoch_3.start_height - 1)
+    }
+
+    fn get_burn_height(config: &Config) -> Result<u32, String> {
+        let burnchain = config.get_burnchain();
+        let sortdb_path = config.get_burn_db_file_path();
+        if fs::metadata(&sortdb_path).is_err() {
+            // if the sortition db doesn't exist yet, don't try to open() it, because that creates the
+            // db file even if it doesn't instantiate the tables, which breaks connect() logic.
+            info!("Failed to open Sortition DB while checking current burn height, assuming height = 0");
+            return Ok(0);
+        }
+
+        let Ok(sortdb) = SortitionDB::open(&sortdb_path, false, burnchain.pox_constants.clone())
+        else {
+            info!("Failed to open Sortition DB while checking current burn height, assuming height = 0");
+            return Ok(0);
+        };
+
+        let Ok(tip_sn) = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn()) else {
+            info!("Failed to query Sortition DB for current burn height, assuming height = 0");
+            return Ok(0);
+        };
+
+        Ok(u32::try_from(tip_sn.block_height).expect("FATAL: burn height exceeded u32"))
+    }
+}
diff --git a/testnet/stacks-node/src/run_loop/mod.rs b/testnet/stacks-node/src/run_loop/mod.rs
index abfbe37c37..9ad4fd583e 100644
--- a/testnet/stacks-node/src/run_loop/mod.rs
+++ b/testnet/stacks-node/src/run_loop/mod.rs
@@ -1,3 +1,4 @@
+pub mod boot_nakamoto;
 pub mod helium;
 pub mod nakamoto;
 pub mod neon;
diff --git a/testnet/stacks-node/src/run_loop/nakamoto.rs b/testnet/stacks-node/src/run_loop/nakamoto.rs
index f758a65d33..e6a835abb8 100644
--- a/testnet/stacks-node/src/run_loop/nakamoto.rs
+++ b/testnet/stacks-node/src/run_loop/nakamoto.rs
@@ -68,9 +68,14 @@ pub struct RunLoop {
 
 impl RunLoop {
     /// Sets up a runloop and node, given a config.
-    pub fn new(config: Config) -> Self {
+    pub fn new(
+        config: Config,
+        should_keep_running: Option<Arc<AtomicBool>>,
+        counters: Option<Counters>,
+    ) -> Self {
         let channels = CoordinatorCommunication::instantiate();
-        let should_keep_running = Arc::new(AtomicBool::new(true));
+        let should_keep_running =
+            should_keep_running.unwrap_or_else(|| Arc::new(AtomicBool::new(true)));
         let pox_watchdog_comms = PoxSyncWatchdogComms::new(should_keep_running.clone());
         let miner_status = Arc::new(Mutex::new(MinerStatus::make_ready(
             config.burnchain.burn_fee_cap,
@@ -86,7 +91,7 @@ impl RunLoop {
             globals: None,
             coordinator_channels: Some(channels),
             callbacks: RunLoopCallbacks::new(),
-            counters: Counters::new(),
+            counters: counters.unwrap_or_else(|| Counters::new()),
             should_keep_running,
             event_dispatcher,
             pox_watchdog: None,
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index a7be83272f..ad9c473992 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -1,5 +1,5 @@
 use std::sync::atomic::{AtomicU64, Ordering};
-use std::sync::Arc;
+use std::sync::{Arc, Mutex};
 use std::time::{Duration, Instant};
 use std::{env, thread};
 
@@ -27,14 +27,13 @@ use stacks_common::util::secp256k1::Secp256k1PrivateKey;
 use super::bitcoin_regtest::BitcoinCoreController;
 use crate::config::{EventKeyType, EventObserverConfig};
 use crate::mockamoto::signer::SelfSigner;
-use crate::run_loop::nakamoto;
+use crate::neon::{Counters, RunLoopCounter};
+use crate::run_loop::boot_nakamoto;
 use crate::tests::make_stacks_transfer;
 use crate::tests::neon_integrations::{
     next_block_and_wait, run_until_burnchain_height, submit_tx, test_observer, wait_for_runloop,
 };
-use crate::{
-    neon, tests, BitcoinRegtestController, BurnchainController, Config, ConfigFile, Keychain,
-};
+use crate::{tests, BitcoinRegtestController, BurnchainController, Config, ConfigFile, Keychain};
 
 static POX_4_DEFAULT_STACKER_BALANCE: u64 = 100_000_000_000_000;
 static POX_4_DEFAULT_STACKER_STX_AMT: u128 = 99_000_000_000_000;
@@ -197,11 +196,14 @@ where
 fn next_block_and_mine_commit(
     btc_controller: &mut BitcoinRegtestController,
     timeout_secs: u64,
-    coord_channels: &CoordinatorChannels,
+    coord_channels: &Arc<Mutex<CoordinatorChannels>>,
     commits_submitted: &Arc<AtomicU64>,
 ) -> Result<(), String> {
     let commits_submitted = commits_submitted.clone();
-    let blocks_processed_before = coord_channels.get_stacks_blocks_processed();
+    let blocks_processed_before = coord_channels
+        .lock()
+        .expect("Mutex poisoned")
+        .get_stacks_blocks_processed();
     let commits_before = commits_submitted.load(Ordering::SeqCst);
     let mut block_processed_time: Option<Instant> = None;
     next_block_and(btc_controller, timeout_secs, || {
@@ -217,7 +219,10 @@ fn next_block_and_mine_commit(
             }
             Ok(false)
         } else {
-            let blocks_processed = coord_channels.get_stacks_blocks_processed();
+            let blocks_processed = coord_channels
+                .lock()
+                .expect("Mutex poisoned")
+                .get_stacks_blocks_processed();
             if blocks_processed > blocks_processed_before {
                 block_processed_time.replace(Instant::now());
             }
@@ -241,27 +246,18 @@ fn setup_stacker(naka_conf: &mut Config) -> Secp256k1PrivateKey {
 ///   for pox-4 to activate
 fn boot_to_epoch_3(
     naka_conf: &Config,
+    blocks_processed: &RunLoopCounter,
     stacker_sk: Secp256k1PrivateKey,
     btc_regtest_controller: &mut BitcoinRegtestController,
 ) {
-    let epoch_2_conf = naka_conf.clone();
-    btc_regtest_controller.bootstrap_chain(201);
-
-    let epochs = epoch_2_conf.burnchain.epochs.clone().unwrap();
-
+    let epochs = naka_conf.burnchain.epochs.clone().unwrap();
     let epoch_3 = &epochs[StacksEpoch::find_epoch_by_id(&epochs, StacksEpochId::Epoch30).unwrap()];
 
     info!(
         "Chain bootstrapped to bitcoin block 201, starting Epoch 2x miner";
         "Epoch 3.0 Boundary" => (epoch_3.start_height - 1),
     );
-    let http_origin = format!("http://{}", &epoch_2_conf.node.rpc_bind);
-    let mut run_loop = neon::RunLoop::new(epoch_2_conf.clone());
-
-    let epoch_2_stopper = run_loop.get_termination_switch();
-    let blocks_processed = run_loop.get_blocks_processed_arc();
-    let epoch_2_thread = thread::spawn(move || run_loop.start(None, 0));
-    wait_for_runloop(&blocks_processed);
+    let http_origin = format!("http://{}", &naka_conf.node.rpc_bind);
     next_block_and_wait(btc_regtest_controller, &blocks_processed);
     next_block_and_wait(btc_regtest_controller, &blocks_processed);
     // first mined stacks block
@@ -295,19 +291,18 @@ fn boot_to_epoch_3(
         btc_regtest_controller,
         &blocks_processed,
         epoch_3.start_height - 1,
-        &epoch_2_conf,
+        &naka_conf,
     );
 
-    info!("Bootstrapped to Epoch-3.0 boundary, stopping Epoch2x miner");
-    epoch_2_stopper.store(false, Ordering::SeqCst);
-    epoch_2_thread.join().unwrap();
+    info!("Bootstrapped to Epoch-3.0 boundary, Epoch2x miner should stop");
 }
 
 #[test]
 #[ignore]
 /// This test spins up a nakamoto-neon node.
 /// It starts in Epoch 2.0, mines with `neon_node` to Epoch 3.0, and then switches
-///  to Nakamoto operation (activating pox-4 by submitting a stack-stx tx).
+///  to Nakamoto operation (activating pox-4 by submitting a stack-stx tx). The BootLoop
+///  struct handles the epoch-2/3 tear-down and spin-up.
 /// This test makes three assertions:
 ///  * 30 blocks are mined after 3.0 starts. This is enough to mine across 2 reward cycles
 ///  * A transaction submitted to the mempool in 3.0 will be mined in 3.0
@@ -330,13 +325,39 @@ fn simple_neon_integration() {
     let recipient = PrincipalData::from(StacksAddress::burn_address(false));
     let stacker_sk = setup_stacker(&mut naka_conf);
 
+    test_observer::spawn();
+    let observer_port = test_observer::EVENT_OBSERVER_PORT;
+    naka_conf.events_observers.insert(EventObserverConfig {
+        endpoint: format!("localhost:{observer_port}"),
+        events_keys: vec![EventKeyType::AnyEvent],
+    });
+
     let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone());
     btcd_controller
         .start_bitcoind()
         .expect("Failed starting bitcoind");
     let mut btc_regtest_controller = BitcoinRegtestController::new(naka_conf.clone(), None);
+    btc_regtest_controller.bootstrap_chain(201);
+
+    let mut run_loop = boot_nakamoto::BootRunLoop::new(naka_conf.clone()).unwrap();
+    let run_loop_stopper = run_loop.get_termination_switch();
+    let Counters {
+        blocks_processed,
+        naka_submitted_vrfs: vrfs_submitted,
+        naka_submitted_commits: commits_submitted,
+        ..
+    } = run_loop.counters();
 
-    boot_to_epoch_3(&naka_conf, stacker_sk, &mut btc_regtest_controller);
+    let coord_channel = run_loop.coordinator_channels();
+
+    let run_loop_thread = thread::spawn(move || run_loop.start(None, 0));
+    wait_for_runloop(&blocks_processed);
+    boot_to_epoch_3(
+        &naka_conf,
+        &blocks_processed,
+        stacker_sk,
+        &mut btc_regtest_controller,
+    );
 
     info!("Bootstrapped to Epoch-3.0 boundary, starting nakamoto miner");
 
@@ -356,23 +377,6 @@ fn simple_neon_integration() {
             .unwrap()
             .stacks_block_height;
 
-    test_observer::spawn();
-    let observer_port = test_observer::EVENT_OBSERVER_PORT;
-    naka_conf.events_observers.insert(EventObserverConfig {
-        endpoint: format!("localhost:{observer_port}"),
-        events_keys: vec![EventKeyType::AnyEvent],
-    });
-
-    let mut run_loop = nakamoto::RunLoop::new(naka_conf.clone());
-    let epoch_3_stopper = run_loop.get_termination_switch();
-    let blocks_processed = run_loop.get_blocks_processed_arc();
-    let vrfs_submitted = run_loop.submitted_vrfs();
-    let commits_submitted = run_loop.submitted_commits();
-    let coord_channel = run_loop.get_coordinator_channel().unwrap();
-
-    let epoch_3_thread = thread::spawn(move || run_loop.start(None, 0));
-
-    wait_for_runloop(&blocks_processed);
     info!("Nakamoto miner started...");
     // first block wakes up the run loop, wait until a key registration has been submitted.
     next_block_and(&mut btc_regtest_controller, 60, || {
@@ -470,8 +474,11 @@ fn simple_neon_integration() {
     assert!(tip.anchored_header.as_stacks_nakamoto().is_some());
     assert!(tip.stacks_block_height >= block_height_pre_3_0 + 30);
 
-    coord_channel.stop_chains_coordinator();
+    coord_channel
+        .lock()
+        .expect("Mutex poisoned")
+        .stop_chains_coordinator();
+    run_loop_stopper.store(false, Ordering::SeqCst);
 
-    epoch_3_stopper.store(false, Ordering::SeqCst);
-    epoch_3_thread.join().unwrap();
+    run_loop_thread.join().unwrap();
 }

From b5bb4ac64de189760e735c78ad3e82a9e4d76a97 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Sat, 9 Dec 2023 15:05:14 -0600
Subject: [PATCH 0187/1166] add copyright headers, some code cleanup

---
 testnet/stacks-node/src/config.rs             |  29 +-
 testnet/stacks-node/src/globals.rs            |  32 +-
 testnet/stacks-node/src/mockamoto.rs          |  17 +-
 testnet/stacks-node/src/nakamoto_node.rs      | 401 +-----------------
 .../stacks-node/src/nakamoto_node/miner.rs    |  37 +-
 testnet/stacks-node/src/nakamoto_node/peer.rs | 149 ++-----
 .../stacks-node/src/nakamoto_node/relayer.rs  | 196 ++++-----
 testnet/stacks-node/src/neon_node.rs          |  88 ++--
 .../stacks-node/src/run_loop/boot_nakamoto.rs |  15 +
 testnet/stacks-node/src/run_loop/nakamoto.rs  |  37 +-
 testnet/stacks-node/src/run_loop/neon.rs      |   2 +-
 .../src/tests/nakamoto_integrations.rs        |  30 +-
 12 files changed, 295 insertions(+), 738 deletions(-)

diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index feaa0208ac..526c2a90da 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -17,17 +17,18 @@ use stacks::chainstate::stacks::miner::{BlockBuilderSettings, MinerStatus};
 use stacks::chainstate::stacks::MAX_BLOCK_LEN;
 use stacks::core::mempool::MemPoolWalkSettings;
 use stacks::core::{
-    StacksEpoch, StacksEpochExtension, StacksEpochId, CHAIN_ID_MAINNET, CHAIN_ID_TESTNET,
-    PEER_VERSION_MAINNET, PEER_VERSION_TESTNET,
+    MemPoolDB, StacksEpoch, StacksEpochExtension, StacksEpochId, CHAIN_ID_MAINNET,
+    CHAIN_ID_TESTNET, PEER_VERSION_MAINNET, PEER_VERSION_TESTNET,
 };
 use stacks::cost_estimates::fee_medians::WeightedMedianFeeRateEstimator;
 use stacks::cost_estimates::fee_rate_fuzzer::FeeRateFuzzer;
 use stacks::cost_estimates::fee_scalar::ScalarFeeRateEstimator;
-use stacks::cost_estimates::metrics::{CostMetric, ProportionalDotProduct};
-use stacks::cost_estimates::{CostEstimator, FeeEstimator, PessimisticEstimator};
+use stacks::cost_estimates::metrics::{CostMetric, ProportionalDotProduct, UnitMetric};
+use stacks::cost_estimates::{CostEstimator, FeeEstimator, PessimisticEstimator, UnitEstimator};
 use stacks::net::atlas::AtlasConfig;
 use stacks::net::connection::ConnectionOptions;
 use stacks::net::{Neighbor, NeighborKey};
+use stacks::util_lib::db::Error as DBError;
 use stacks_common::address::{AddressHashMode, C32_ADDRESS_VERSION_TESTNET_SINGLESIG};
 use stacks_common::types::chainstate::StacksAddress;
 use stacks_common::types::net::PeerAddress;
@@ -510,6 +511,26 @@ impl Config {
             Ok(self.burnchain.clone())
         }
     }
+
+    /// Connect to the MempoolDB using the configured cost estimation
+    pub fn connect_mempool_db(&self) -> Result<MemPoolDB, DBError> {
+        // create estimators, metric instances for RPC handler
+        let cost_estimator = self
+            .make_cost_estimator()
+            .unwrap_or_else(|| Box::new(UnitEstimator));
+        let metric = self
+            .make_cost_metric()
+            .unwrap_or_else(|| Box::new(UnitMetric));
+
+        MemPoolDB::open(
+            self.is_mainnet(),
+            self.burnchain.chain_id,
+            &self.get_chainstate_path_str(),
+            cost_estimator,
+            metric,
+        )
+    }
+
     /// Apply any test settings to this burnchain config struct
     fn apply_test_settings(&self, burnchain: &mut Burnchain) {
         if self.burnchain.get_bitcoin_network().1 == BitcoinNetworkType::Mainnet {
diff --git a/testnet/stacks-node/src/globals.rs b/testnet/stacks-node/src/globals.rs
index 7e9e47a8fe..6c60e9a591 100644
--- a/testnet/stacks-node/src/globals.rs
+++ b/testnet/stacks-node/src/globals.rs
@@ -17,6 +17,8 @@ use crate::neon_node::LeaderKeyRegistrationState;
 use crate::run_loop::RegisteredKey;
 use crate::syncctl::PoxSyncWatchdogComms;
 
+pub type NeonGlobals = Globals<RelayerDirective>;
+
 /// Command types for the relayer thread, issued to it by other threads
 pub enum RelayerDirective {
     /// Handle some new data that arrived on the network (such as blocks, transactions, and
@@ -34,8 +36,7 @@ pub enum RelayerDirective {
 }
 
 /// Inter-thread communication structure, shared between threads
-#[derive(Clone)]
-pub struct Globals {
+pub struct Globals<T> {
     /// Last sortition processed
     last_sortition: Arc<Mutex<Option<BlockSnapshot>>>,
     /// Status of the miner
@@ -45,7 +46,7 @@ pub struct Globals {
     /// Unconfirmed transactions (shared between the relayer and p2p threads)
     unconfirmed_txs: Arc<Mutex<UnconfirmedTxMap>>,
     /// Writer endpoint to the relayer thread
-    pub relay_send: SyncSender<RelayerDirective>,
+    pub relay_send: SyncSender<T>,
     /// Cointer state in the main thread
     pub counters: Counters,
     /// Connection to the PoX sync watchdog
@@ -56,15 +57,34 @@ pub struct Globals {
     leader_key_registration_state: Arc<Mutex<LeaderKeyRegistrationState>>,
 }
 
-impl Globals {
+// Need to manually implement Clone, because [derive(Clone)] requires
+//  all trait bounds to implement Clone, even though T doesn't need Clone
+//  because it's behind SyncSender.
+impl<T> Clone for Globals<T> {
+    fn clone(&self) -> Self {
+        Self {
+            last_sortition: self.last_sortition.clone(),
+            miner_status: self.miner_status.clone(),
+            coord_comms: self.coord_comms.clone(),
+            unconfirmed_txs: self.unconfirmed_txs.clone(),
+            relay_send: self.relay_send.clone(),
+            counters: self.counters.clone(),
+            sync_comms: self.sync_comms.clone(),
+            should_keep_running: self.should_keep_running.clone(),
+            leader_key_registration_state: self.leader_key_registration_state.clone(),
+        }
+    }
+}
+
+impl<T> Globals<T> {
     pub fn new(
         coord_comms: CoordinatorChannels,
         miner_status: Arc<Mutex<MinerStatus>>,
-        relay_send: SyncSender<RelayerDirective>,
+        relay_send: SyncSender<T>,
         counters: Counters,
         sync_comms: PoxSyncWatchdogComms,
         should_keep_running: Arc<AtomicBool>,
-    ) -> Globals {
+    ) -> Globals<T> {
         Globals {
             last_sortition: Arc::new(Mutex::new(None)),
             miner_status,
diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index 78bc2ae491..7b56c2afb8 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -1,3 +1,18 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020-2023 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
 use std::sync::atomic::AtomicBool;
 use std::sync::mpsc::{sync_channel, Receiver, RecvTimeoutError};
 use std::sync::{Arc, Mutex};
@@ -69,7 +84,7 @@ use stacks_common::util::secp256k1::{MessageSignature, Secp256k1PublicKey};
 use stacks_common::util::vrf::{VRFPrivateKey, VRFProof, VRFPublicKey, VRF};
 
 use self::signer::SelfSigner;
-use crate::globals::{Globals, RelayerDirective};
+use crate::globals::{NeonGlobals as Globals, RelayerDirective};
 use crate::neon::Counters;
 use crate::neon_node::{PeerThread, StacksNode, BLOCK_PROCESSOR_STACK_SIZE};
 use crate::syncctl::PoxSyncWatchdogComms;
diff --git a/testnet/stacks-node/src/nakamoto_node.rs b/testnet/stacks-node/src/nakamoto_node.rs
index de0d04cfb5..0482bbfb05 100644
--- a/testnet/stacks-node/src/nakamoto_node.rs
+++ b/testnet/stacks-node/src/nakamoto_node.rs
@@ -1,5 +1,5 @@
 // Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
-// Copyright (C) 2020 Stacks Open Internet Foundation
+// Copyright (C) 2020-2023 Stacks Open Internet Foundation
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -14,42 +14,25 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 use std::collections::HashMap;
-use std::convert::TryFrom;
-use std::net::SocketAddr;
 use std::sync::mpsc::Receiver;
 use std::thread;
 use std::thread::JoinHandle;
 
-use clarity::vm::ast::ASTRules;
-use clarity::vm::types::QualifiedContractIdentifier;
-use stacks::burnchains::{Burnchain, BurnchainSigner, Txid};
+use stacks::burnchains::{BurnchainSigner, Txid};
 use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::burn::BlockSnapshot;
-use stacks::chainstate::stacks::db::StacksChainState;
-use stacks::chainstate::stacks::Error as ChainstateError;
-use stacks::core::mempool::MemPoolDB;
-use stacks::cost_estimates::metrics::UnitMetric;
-use stacks::cost_estimates::UnitEstimator;
 use stacks::monitoring;
 use stacks::monitoring::update_active_miners_count_gauge;
-use stacks::net::atlas::{AtlasConfig, AtlasDB};
-use stacks::net::db::PeerDB;
-use stacks::net::p2p::PeerNetwork;
+use stacks::net::atlas::AtlasConfig;
 use stacks::net::relay::Relayer;
-use stacks::net::stackerdb::{StackerDBConfig, StackerDBSync, StackerDBs};
-use stacks::net::{Error as NetError, PeerNetworkComms, ServiceFlags};
-use stacks::util_lib::strings::{UrlString, VecDisplay};
+use stacks::net::stackerdb::StackerDBs;
 use stacks_common::types::chainstate::SortitionId;
-use stacks_common::types::net::PeerAddress;
 use stacks_common::types::StacksEpochId;
-use stacks_common::util::get_epoch_time_secs;
-use stacks_common::util::secp256k1::Secp256k1PrivateKey;
 
 use super::{Config, EventDispatcher, Keychain};
 use crate::burnchains::bitcoin_regtest_controller::addr2str;
-use crate::globals::{Globals, RelayerDirective};
-use crate::neon_node::LeaderKeyRegistrationState;
-use crate::run_loop::nakamoto::RunLoop;
+use crate::neon_node::{LeaderKeyRegistrationState, StacksNode as NeonNode};
+use crate::run_loop::nakamoto::{Globals, RunLoop};
 use crate::run_loop::RegisteredKey;
 
 pub mod miner;
@@ -57,7 +40,7 @@ pub mod peer;
 pub mod relayer;
 
 use self::peer::PeerThread;
-use self::relayer::RelayerThread;
+use self::relayer::{RelayerDirective, RelayerThread};
 
 pub const RELAYER_MAX_BUFFER: usize = 100;
 const VRF_MOCK_MINER_KEY: u64 = 1;
@@ -82,88 +65,6 @@ pub struct StacksNode {
     pub relayer_thread_handle: JoinHandle<()>,
 }
 
-/// Fault injection logic to artificially increase the length of a tenure.
-/// Only used in testing
-#[cfg(test)]
-fn fault_injection_long_tenure() {
-    // simulated slow block
-    match std::env::var("STX_TEST_SLOW_TENURE") {
-        Ok(tenure_str) => match tenure_str.parse::<u64>() {
-            Ok(tenure_time) => {
-                info!(
-                    "Fault injection: sleeping for {} milliseconds to simulate a long tenure",
-                    tenure_time
-                );
-                stacks_common::util::sleep_ms(tenure_time);
-            }
-            Err(_) => {
-                error!("Parse error for STX_TEST_SLOW_TENURE");
-                panic!();
-            }
-        },
-        _ => {}
-    }
-}
-
-#[cfg(not(test))]
-fn fault_injection_long_tenure() {}
-
-/// Fault injection to skip mining in this bitcoin block height
-/// Only used in testing
-#[cfg(test)]
-fn fault_injection_skip_mining(rpc_bind: &str, target_burn_height: u64) -> bool {
-    match std::env::var("STACKS_DISABLE_MINER") {
-        Ok(disable_heights) => {
-            let disable_schedule: serde_json::Value =
-                serde_json::from_str(&disable_heights).unwrap();
-            let disable_schedule = disable_schedule.as_array().unwrap();
-            for disabled in disable_schedule {
-                let target_miner_rpc_bind = disabled
-                    .get("rpc_bind")
-                    .unwrap()
-                    .as_str()
-                    .unwrap()
-                    .to_string();
-                if target_miner_rpc_bind != rpc_bind {
-                    continue;
-                }
-                let target_block_heights = disabled.get("blocks").unwrap().as_array().unwrap();
-                for target_block_value in target_block_heights {
-                    let target_block = target_block_value.as_i64().unwrap() as u64;
-                    if target_block == target_burn_height {
-                        return true;
-                    }
-                }
-            }
-            return false;
-        }
-        Err(_) => {
-            return false;
-        }
-    }
-}
-
-#[cfg(not(test))]
-fn fault_injection_skip_mining(_rpc_bind: &str, _target_burn_height: u64) -> bool {
-    false
-}
-
-/// Open the chainstate, and inject faults from the config file
-pub(crate) fn open_chainstate_with_faults(
-    config: &Config,
-) -> Result<StacksChainState, ChainstateError> {
-    let stacks_chainstate_path = config.get_chainstate_path_str();
-    let (mut chainstate, _) = StacksChainState::open(
-        config.is_mainnet(),
-        config.burnchain.chain_id,
-        &stacks_chainstate_path,
-        Some(config.node.get_marf_opts()),
-    )?;
-
-    chainstate.fault_injection.hide_blocks = config.node.fault_injection_hide_blocks;
-    Ok(chainstate)
-}
-
 /// Types of errors that can arise during mining
 #[derive(Debug)]
 enum Error {
@@ -186,284 +87,6 @@ enum Error {
 }
 
 impl StacksNode {
-    /// Set up the AST size-precheck height, if configured
-    fn setup_ast_size_precheck(config: &Config, sortdb: &mut SortitionDB) {
-        if let Some(ast_precheck_size_height) = config.burnchain.ast_precheck_size_height {
-            info!(
-                "Override burnchain height of {:?} to {}",
-                ASTRules::PrecheckSize,
-                ast_precheck_size_height
-            );
-            let mut tx = sortdb
-                .tx_begin()
-                .expect("FATAL: failed to begin tx on sortition DB");
-            SortitionDB::override_ast_rule_height(
-                &mut tx,
-                ASTRules::PrecheckSize,
-                ast_precheck_size_height,
-            )
-            .expect("FATAL: failed to override AST PrecheckSize rule height");
-            tx.commit()
-                .expect("FATAL: failed to commit sortition DB transaction");
-        }
-    }
-
-    /// Set up the mempool DB by making sure it exists.
-    /// Panics on failure.
-    fn setup_mempool_db(config: &Config) -> MemPoolDB {
-        // force early mempool instantiation
-        let cost_estimator = config
-            .make_cost_estimator()
-            .unwrap_or_else(|| Box::new(UnitEstimator));
-        let metric = config
-            .make_cost_metric()
-            .unwrap_or_else(|| Box::new(UnitMetric));
-
-        let mempool = MemPoolDB::open(
-            config.is_mainnet(),
-            config.burnchain.chain_id,
-            &config.get_chainstate_path_str(),
-            cost_estimator,
-            metric,
-        )
-        .expect("BUG: failed to instantiate mempool");
-
-        mempool
-    }
-
-    /// Set up the Peer DB and update any soft state from the config file.  This includes:
-    /// * blacklisted/whitelisted nodes
-    /// * node keys
-    /// * bootstrap nodes
-    /// Returns the instantiated PeerDB
-    /// Panics on failure.
-    fn setup_peer_db(
-        config: &Config,
-        burnchain: &Burnchain,
-        stackerdb_contract_ids: &[QualifiedContractIdentifier],
-    ) -> PeerDB {
-        let data_url = UrlString::try_from(format!("{}", &config.node.data_url)).unwrap();
-        let initial_neighbors = config.node.bootstrap_node.clone();
-        if initial_neighbors.len() > 0 {
-            info!(
-                "Will bootstrap from peers {}",
-                VecDisplay(&initial_neighbors)
-            );
-        } else {
-            warn!("Without a peer to bootstrap from, the node will start mining a new chain");
-        }
-
-        let p2p_sock: SocketAddr = config.node.p2p_bind.parse().expect(&format!(
-            "Failed to parse socket: {}",
-            &config.node.p2p_bind
-        ));
-        let p2p_addr: SocketAddr = config.node.p2p_address.parse().expect(&format!(
-            "Failed to parse socket: {}",
-            &config.node.p2p_address
-        ));
-        let node_privkey = Secp256k1PrivateKey::from_seed(&config.node.local_peer_seed);
-
-        let mut peerdb = PeerDB::connect(
-            &config.get_peer_db_file_path(),
-            true,
-            config.burnchain.chain_id,
-            burnchain.network_id,
-            Some(node_privkey),
-            config.connection_options.private_key_lifetime.clone(),
-            PeerAddress::from_socketaddr(&p2p_addr),
-            p2p_sock.port(),
-            data_url,
-            &[],
-            Some(&initial_neighbors),
-            stackerdb_contract_ids,
-        )
-        .map_err(|e| {
-            eprintln!(
-                "Failed to open {}: {:?}",
-                &config.get_peer_db_file_path(),
-                &e
-            );
-            panic!();
-        })
-        .unwrap();
-
-        // allow all bootstrap nodes
-        {
-            let mut tx = peerdb.tx_begin().unwrap();
-            for initial_neighbor in initial_neighbors.iter() {
-                // update peer in case public key changed
-                PeerDB::update_peer(&mut tx, &initial_neighbor).unwrap();
-                PeerDB::set_allow_peer(
-                    &mut tx,
-                    initial_neighbor.addr.network_id,
-                    &initial_neighbor.addr.addrbytes,
-                    initial_neighbor.addr.port,
-                    -1,
-                )
-                .unwrap();
-            }
-            tx.commit().unwrap();
-        }
-
-        if !config.node.deny_nodes.is_empty() {
-            warn!("Will ignore nodes {:?}", &config.node.deny_nodes);
-        }
-
-        // deny all config-denied peers
-        {
-            let mut tx = peerdb.tx_begin().unwrap();
-            for denied in config.node.deny_nodes.iter() {
-                PeerDB::set_deny_peer(
-                    &mut tx,
-                    denied.addr.network_id,
-                    &denied.addr.addrbytes,
-                    denied.addr.port,
-                    get_epoch_time_secs() + 24 * 365 * 3600,
-                )
-                .unwrap();
-            }
-            tx.commit().unwrap();
-        }
-
-        // update services to indicate we can support mempool sync
-        {
-            let mut tx = peerdb.tx_begin().unwrap();
-            PeerDB::set_local_services(
-                &mut tx,
-                (ServiceFlags::RPC as u16) | (ServiceFlags::RELAY as u16),
-            )
-            .unwrap();
-            tx.commit().unwrap();
-        }
-
-        peerdb
-    }
-
-    /// Set up the PeerNetwork, but do not bind it.
-    pub fn setup_peer_network(
-        config: &Config,
-        atlas_config: &AtlasConfig,
-        burnchain: Burnchain,
-    ) -> PeerNetwork {
-        let sortdb = SortitionDB::open(
-            &config.get_burn_db_file_path(),
-            true,
-            burnchain.pox_constants.clone(),
-        )
-        .expect("Error while instantiating sor/tition db");
-
-        let epochs = SortitionDB::get_stacks_epochs(sortdb.conn())
-            .expect("Error while loading stacks epochs");
-
-        let view = {
-            let sortition_tip = SortitionDB::get_canonical_burn_chain_tip(&sortdb.conn())
-                .expect("Failed to get sortition tip");
-            SortitionDB::get_burnchain_view(&sortdb.index_conn(), &burnchain, &sortition_tip)
-                .unwrap()
-        };
-
-        let atlasdb =
-            AtlasDB::connect(atlas_config.clone(), &config.get_atlas_db_file_path(), true).unwrap();
-
-        let stackerdbs = StackerDBs::connect(&config.get_stacker_db_file_path(), true).unwrap();
-
-        let mut chainstate =
-            open_chainstate_with_faults(config).expect("FATAL: could not open chainstate DB");
-
-        let mut stackerdb_machines = HashMap::new();
-        for stackerdb_contract_id in config.node.stacker_dbs.iter() {
-            // attempt to load the config
-            let (instantiate, stacker_db_config) = match StackerDBConfig::from_smart_contract(
-                &mut chainstate,
-                &sortdb,
-                stackerdb_contract_id,
-            ) {
-                Ok(c) => (true, c),
-                Err(e) => {
-                    warn!(
-                        "Failed to load StackerDB config for {}: {:?}",
-                        stackerdb_contract_id, &e
-                    );
-                    (false, StackerDBConfig::noop())
-                }
-            };
-            let mut stackerdbs =
-                StackerDBs::connect(&config.get_stacker_db_file_path(), true).unwrap();
-
-            if instantiate {
-                match stackerdbs.get_stackerdb_id(stackerdb_contract_id) {
-                    Ok(..) => {
-                        // reconfigure
-                        let tx = stackerdbs.tx_begin(stacker_db_config.clone()).unwrap();
-                        tx.reconfigure_stackerdb(stackerdb_contract_id, &stacker_db_config.signers)
-                            .expect(&format!(
-                                "FATAL: failed to reconfigure StackerDB replica {}",
-                                stackerdb_contract_id
-                            ));
-                        tx.commit().unwrap();
-                    }
-                    Err(NetError::NoSuchStackerDB(..)) => {
-                        // instantiate replica
-                        let tx = stackerdbs.tx_begin(stacker_db_config.clone()).unwrap();
-                        tx.create_stackerdb(stackerdb_contract_id, &stacker_db_config.signers)
-                            .expect(&format!(
-                                "FATAL: failed to instantiate StackerDB replica {}",
-                                stackerdb_contract_id
-                            ));
-                        tx.commit().unwrap();
-                    }
-                    Err(e) => {
-                        panic!("FATAL: failed to query StackerDB state: {:?}", &e);
-                    }
-                }
-            }
-            let stacker_db_sync = match StackerDBSync::new(
-                stackerdb_contract_id.clone(),
-                &stacker_db_config,
-                PeerNetworkComms::new(),
-                stackerdbs,
-            ) {
-                Ok(s) => s,
-                Err(e) => {
-                    warn!(
-                        "Failed to instantiate StackerDB sync machine for {}: {:?}",
-                        stackerdb_contract_id, &e
-                    );
-                    continue;
-                }
-            };
-
-            stackerdb_machines.insert(
-                stackerdb_contract_id.clone(),
-                (stacker_db_config, stacker_db_sync),
-            );
-        }
-
-        let stackerdb_contract_ids: Vec<_> =
-            stackerdb_machines.keys().map(|sc| sc.clone()).collect();
-        let peerdb = Self::setup_peer_db(config, &burnchain, &stackerdb_contract_ids);
-
-        let local_peer = match PeerDB::get_local_peer(peerdb.conn()) {
-            Ok(local_peer) => local_peer,
-            _ => panic!("Unable to retrieve local peer"),
-        };
-
-        let p2p_net = PeerNetwork::new(
-            peerdb,
-            atlasdb,
-            stackerdbs,
-            local_peer,
-            config.burnchain.peer_version,
-            burnchain,
-            view,
-            config.connection_options.clone(),
-            stackerdb_machines,
-            epochs,
-        );
-
-        p2p_net
-    }
-
     /// This function sets the global var `GLOBAL_BURNCHAIN_SIGNER`.
     ///
     /// This variable is used for prometheus monitoring (which only
@@ -507,11 +130,13 @@ impl StacksNode {
         )
         .expect("Error while instantiating sortition db");
 
-        Self::setup_ast_size_precheck(&config, &mut sortdb);
+        NeonNode::setup_ast_size_precheck(&config, &mut sortdb);
 
-        let _ = Self::setup_mempool_db(&config);
+        let _ = config
+            .connect_mempool_db()
+            .expect("FATAL: database failure opening mempool");
 
-        let mut p2p_net = Self::setup_peer_network(&config, &atlas_config, burnchain.clone());
+        let mut p2p_net = NeonNode::setup_peer_network(&config, &atlas_config, burnchain.clone());
 
         let stackerdbs = StackerDBs::connect(&config.get_stacker_db_file_path(), true)
             .expect("FATAL: failed to connect to stacker DB");
@@ -602,7 +227,7 @@ impl StacksNode {
         return self
             .globals
             .relay_send
-            .send(RelayerDirective::ProcessTenure(
+            .send(RelayerDirective::ProcessedBurnBlock(
                 snapshot.consensus_hash.clone(),
                 snapshot.parent_burn_header_hash.clone(),
                 snapshot.winning_stacks_block_hash.clone(),
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index bc684a07bf..ae2781ce7b 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -1,5 +1,5 @@
 // Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
-// Copyright (C) 2020 Stacks Open Internet Foundation
+// Copyright (C) 2020-2023 Stacks Open Internet Foundation
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -29,10 +29,7 @@ use stacks::chainstate::stacks::{
     TenureChangeCause, TenureChangePayload, ThresholdSignature, TransactionAnchorMode,
     TransactionPayload, TransactionVersion,
 };
-use stacks::core::mempool::MemPoolDB;
 use stacks::core::FIRST_BURNCHAIN_CONSENSUS_HASH;
-use stacks::cost_estimates::metrics::UnitMetric;
-use stacks::cost_estimates::UnitEstimator;
 use stacks_common::types::chainstate::{StacksAddress, StacksBlockId};
 use stacks_common::types::{PrivateKey, StacksEpochId};
 use stacks_common::util::hash::Hash160;
@@ -40,11 +37,11 @@ use stacks_common::util::vrf::VRFProof;
 
 use super::relayer::RelayerThread;
 use super::{Config, Error as NakamotoNodeError, EventDispatcher, Keychain};
-use crate::globals::Globals;
 use crate::mockamoto::signer::SelfSigner;
 use crate::nakamoto_node::VRF_MOCK_MINER_KEY;
+use crate::run_loop::nakamoto::Globals;
 use crate::run_loop::RegisteredKey;
-use crate::ChainTip;
+use crate::{neon_node, ChainTip};
 
 pub enum MinerDirective {
     /// The miner won sortition so they should begin a new tenure
@@ -161,7 +158,7 @@ impl BlockMinerThread {
         mut block: NakamotoBlock,
     ) -> Result<(), ChainstateError> {
         signer.sign_nakamoto_block(&mut block);
-        let mut chain_state = super::open_chainstate_with_faults(&self.config)
+        let mut chain_state = neon_node::open_chainstate_with_faults(&self.config)
             .expect("FATAL: could not open chainstate DB");
         let chainstate_config = chain_state.config();
         let sort_db = SortitionDB::open(
@@ -365,19 +362,9 @@ impl BlockMinerThread {
     /// Return None if we couldn't build a block for whatever reason.
     fn mine_block(&mut self) -> Option<NakamotoBlock> {
         debug!("block miner thread ID is {:?}", thread::current().id());
-        super::fault_injection_long_tenure();
+        neon_node::fault_injection_long_tenure();
 
         let burn_db_path = self.config.get_burn_db_file_path();
-        let stacks_chainstate_path = self.config.get_chainstate_path_str();
-
-        let cost_estimator = self
-            .config
-            .make_cost_estimator()
-            .unwrap_or_else(|| Box::new(UnitEstimator));
-        let metric = self
-            .config
-            .make_cost_metric()
-            .unwrap_or_else(|| Box::new(UnitMetric));
 
         // NOTE: read-write access is needed in order to be able to query the recipient set.
         // This is an artifact of the way the MARF is built (see #1449)
@@ -385,17 +372,13 @@ impl BlockMinerThread {
             SortitionDB::open(&burn_db_path, true, self.burnchain.pox_constants.clone())
                 .expect("FATAL: could not open sortition DB");
 
-        let mut chain_state = super::open_chainstate_with_faults(&self.config)
+        let mut chain_state = neon_node::open_chainstate_with_faults(&self.config)
             .expect("FATAL: could not open chainstate DB");
 
-        let mut mem_pool = MemPoolDB::open(
-            self.config.is_mainnet(),
-            self.config.burnchain.chain_id,
-            &stacks_chainstate_path,
-            cost_estimator,
-            metric,
-        )
-        .expect("Database failure opening mempool");
+        let mut mem_pool = self
+            .config
+            .connect_mempool_db()
+            .expect("Database failure opening mempool");
 
         let target_epoch_id =
             SortitionDB::get_stacks_epoch(burn_db.conn(), self.burn_block.block_height + 1)
diff --git a/testnet/stacks-node/src/nakamoto_node/peer.rs b/testnet/stacks-node/src/nakamoto_node/peer.rs
index 9f2a37c50d..762aa45eda 100644
--- a/testnet/stacks-node/src/nakamoto_node/peer.rs
+++ b/testnet/stacks-node/src/nakamoto_node/peer.rs
@@ -1,5 +1,5 @@
 // Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
-// Copyright (C) 2020 Stacks Open Internet Foundation
+// Copyright (C) 2020-2023 Stacks Open Internet Foundation
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -33,10 +33,10 @@ use stacks::net::p2p::PeerNetwork;
 use stacks::net::RPCHandlerArgs;
 use stacks_common::util::hash::Sha256Sum;
 
-use super::open_chainstate_with_faults;
 use crate::burnchains::make_bitcoin_indexer;
-use crate::globals::{Globals, RelayerDirective};
-use crate::run_loop::nakamoto::RunLoop;
+use crate::nakamoto_node::relayer::RelayerDirective;
+use crate::neon_node::open_chainstate_with_faults;
+use crate::run_loop::nakamoto::{Globals, RunLoop};
 use crate::{Config, EventDispatcher};
 
 /// Thread that runs the network state machine, handling both p2p and http requests.
@@ -44,17 +44,17 @@ pub struct PeerThread {
     /// Node config
     config: Config,
     /// instance of the peer network. Made optional in order to trick the borrow checker.
-    net: Option<PeerNetwork>,
+    net: PeerNetwork,
     /// handle to global inter-thread comms
     globals: Globals,
     /// how long to wait for network messages on each poll, in millis
     poll_timeout: u64,
-    /// handle to the sortition DB (optional so we can take/replace it)
-    sortdb: Option<SortitionDB>,
-    /// handle to the chainstate DB (optional so we can take/replace it)
-    chainstate: Option<StacksChainState>,
-    /// handle to the mempool DB (optional so we can take/replace it)
-    mempool: Option<MemPoolDB>,
+    /// handle to the sortition DB
+    sortdb: SortitionDB,
+    /// handle to the chainstate DB
+    chainstate: StacksChainState,
+    /// handle to the mempool DB
+    mempool: MemPoolDB,
     /// buffer of relayer commands with block data that couldn't be sent to the relayer just yet
     /// (i.e. due to backpressure).  We track this separately, instead of just using a bigger
     /// channel, because we need to know when backpressure occurs in order to throttle the p2p
@@ -141,28 +141,6 @@ impl PeerThread {
         info!("P2P thread exit!");
     }
 
-    /// set up the mempool DB connection
-    pub fn connect_mempool_db(config: &Config) -> MemPoolDB {
-        // create estimators, metric instances for RPC handler
-        let cost_estimator = config
-            .make_cost_estimator()
-            .unwrap_or_else(|| Box::new(UnitEstimator));
-        let metric = config
-            .make_cost_metric()
-            .unwrap_or_else(|| Box::new(UnitMetric));
-
-        let mempool = MemPoolDB::open(
-            config.is_mainnet(),
-            config.burnchain.chain_id,
-            &config.get_chainstate_path_str(),
-            cost_estimator,
-            metric,
-        )
-        .expect("Database failure opening mempool");
-
-        mempool
-    }
-
     /// Instantiate the p2p thread.
     /// Binds the addresses in the config (which may panic if the port is blocked).
     /// This is so the node will crash "early" before any new threads start if there's going to be
@@ -183,7 +161,9 @@ impl PeerThread {
         mut net: PeerNetwork,
     ) -> Self {
         let config = config.clone();
-        let mempool = Self::connect_mempool_db(&config);
+        let mempool = config
+            .connect_mempool_db()
+            .expect("FATAL: database failure opening mempool");
         let burn_db_path = config.get_burn_db_file_path();
 
         let sortdb = SortitionDB::open(&burn_db_path, false, pox_constants)
@@ -208,12 +188,12 @@ impl PeerThread {
 
         PeerThread {
             config,
-            net: Some(net),
+            net,
             globals,
             poll_timeout,
-            sortdb: Some(sortdb),
-            chainstate: Some(chainstate),
-            mempool: Some(mempool),
+            sortdb,
+            chainstate,
+            mempool,
             results_with_data: VecDeque::new(),
             num_p2p_state_machine_passes: 0,
             num_inv_sync_passes: 0,
@@ -222,50 +202,6 @@ impl PeerThread {
         }
     }
 
-    /// Do something with mutable references to the mempool, sortdb, and chainstate
-    /// Fools the borrow checker.
-    /// NOT COMPOSIBLE
-    fn with_chainstate<F, R>(&mut self, func: F) -> R
-    where
-        F: FnOnce(&mut PeerThread, &mut SortitionDB, &mut StacksChainState, &mut MemPoolDB) -> R,
-    {
-        let mut sortdb = self.sortdb.take().expect("BUG: sortdb already taken");
-        let mut chainstate = self
-            .chainstate
-            .take()
-            .expect("BUG: chainstate already taken");
-        let mut mempool = self.mempool.take().expect("BUG: mempool already taken");
-
-        let res = func(self, &mut sortdb, &mut chainstate, &mut mempool);
-
-        self.sortdb = Some(sortdb);
-        self.chainstate = Some(chainstate);
-        self.mempool = Some(mempool);
-
-        res
-    }
-
-    /// Get an immutable ref to the inner network.
-    /// DO NOT USE WITHIN with_network()
-    fn get_network(&self) -> &PeerNetwork {
-        self.net.as_ref().expect("BUG: did not replace net")
-    }
-
-    /// Do something with mutable references to the network.
-    /// Fools the borrow checker.
-    /// NOT COMPOSIBLE. DO NOT CALL THIS OR get_network() IN func
-    fn with_network<F, R>(&mut self, func: F) -> R
-    where
-        F: FnOnce(&mut PeerThread, &mut PeerNetwork) -> R,
-    {
-        let mut net = self.net.take().expect("BUG: net already taken");
-
-        let res = func(self, &mut net);
-
-        self.net = Some(net);
-        res
-    }
-
     /// Run one pass of the p2p/http state machine
     /// Return true if we should continue running passes; false if not
     pub fn run_one_pass<B: BurnchainHeaderReader>(
@@ -280,12 +216,12 @@ impl PeerThread {
         // initial block download?
         let ibd = self.globals.sync_comms.get_ibd();
         let download_backpressure = self.results_with_data.len() > 0;
-        let poll_ms = if !download_backpressure && self.get_network().has_more_downloads() {
+        let poll_ms = if !download_backpressure && self.net.has_more_downloads() {
             // keep getting those blocks -- drive the downloader state-machine
             debug!(
                 "P2P: backpressure: {}, more downloads: {}",
                 download_backpressure,
-                self.get_network().has_more_downloads()
+                self.net.has_more_downloads()
             );
             1
         } else {
@@ -293,15 +229,11 @@ impl PeerThread {
         };
 
         // do one pass
-        let p2p_res = self.with_chainstate(|p2p_thread, sortdb, chainstate, mempool| {
+        let p2p_res = {
             // NOTE: handler_args must be created such that it outlives the inner net.run() call and
             // doesn't ref anything within p2p_thread.
             let handler_args = RPCHandlerArgs {
-                exit_at_block_height: p2p_thread
-                    .config
-                    .burnchain
-                    .process_exit_at_block_height
-                    .clone(),
+                exit_at_block_height: self.config.burnchain.process_exit_at_block_height.clone(),
                 genesis_chainstate_hash: Sha256Sum::from_hex(stx_genesis::GENESIS_CHAINSTATE_HASH)
                     .unwrap(),
                 event_observer: Some(event_dispatcher),
@@ -310,21 +242,18 @@ impl PeerThread {
                 fee_estimator: fee_estimator.map(|boxed_estimator| boxed_estimator.as_ref()),
                 ..RPCHandlerArgs::default()
             };
-            p2p_thread.with_network(|_, net| {
-                net.run(
-                    indexer,
-                    sortdb,
-                    chainstate,
-                    mempool,
-                    dns_client_opt,
-                    download_backpressure,
-                    ibd,
-                    poll_ms,
-                    &handler_args,
-                )
-            })
-        });
-
+            self.net.run(
+                indexer,
+                &self.sortdb,
+                &mut self.chainstate,
+                &mut self.mempool,
+                dns_client_opt,
+                download_backpressure,
+                ibd,
+                poll_ms,
+                &handler_args,
+            )
+        };
         match p2p_res {
             Ok(network_result) => {
                 let mut have_update = false;
@@ -376,17 +305,13 @@ impl PeerThread {
             if let Err(e) = self.globals.relay_send.try_send(next_result) {
                 debug!(
                     "P2P: {:?}: download backpressure detected (bufferred {})",
-                    &self.get_network().local_peer,
+                    &self.net.local_peer,
                     self.results_with_data.len()
                 );
                 match e {
                     TrySendError::Full(directive) => {
-                        if let RelayerDirective::RunTenure(..) = directive {
-                            // can drop this
-                        } else {
-                            // don't lose this data -- just try it again
-                            self.results_with_data.push_front(directive);
-                        }
+                        // don't lose this data -- just try it again
+                        self.results_with_data.push_front(directive);
                         break;
                     }
                     TrySendError::Disconnected(_) => {
diff --git a/testnet/stacks-node/src/nakamoto_node/relayer.rs b/testnet/stacks-node/src/nakamoto_node/relayer.rs
index 6aa4568d0b..04f04241e0 100644
--- a/testnet/stacks-node/src/nakamoto_node/relayer.rs
+++ b/testnet/stacks-node/src/nakamoto_node/relayer.rs
@@ -1,5 +1,5 @@
 // Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
-// Copyright (C) 2020 Stacks Open Internet Foundation
+// Copyright (C) 2020-2023 Stacks Open Internet Foundation
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -53,17 +53,35 @@ use stacks_common::util::hash::Hash160;
 use stacks_common::util::vrf::{VRFProof, VRFPublicKey};
 
 use super::{
-    fault_injection_skip_mining, open_chainstate_with_faults, BlockCommits, Config,
-    Error as NakamotoNodeError, EventDispatcher, Keychain, BLOCK_PROCESSOR_STACK_SIZE,
+    BlockCommits, Config, Error as NakamotoNodeError, EventDispatcher, Keychain,
+    BLOCK_PROCESSOR_STACK_SIZE,
 };
 use crate::burnchains::BurnchainController;
-use crate::globals::{Globals, RelayerDirective};
 use crate::nakamoto_node::miner::{BlockMinerThread, MinerDirective};
-use crate::neon_node::LeaderKeyRegistrationState;
-use crate::run_loop::nakamoto::RunLoop;
+use crate::neon_node::{
+    fault_injection_skip_mining, open_chainstate_with_faults, LeaderKeyRegistrationState,
+};
+use crate::run_loop::nakamoto::{Globals, RunLoop};
 use crate::run_loop::RegisteredKey;
 use crate::BitcoinRegtestController;
 
+/// Command types for the Nakamoto relayer thread, issued to it by other threads
+pub enum RelayerDirective {
+    /// Handle some new data that arrived on the network (such as blocks, transactions, and
+    HandleNetResult(NetworkResult),
+    /// A new burn block has been processed by the SortitionDB, check if this miner won sortition,
+    ///  and if so, start the miner thread
+    ProcessedBurnBlock(ConsensusHash, BurnchainHeaderHash, BlockHeaderHash),
+    /// Either a new burn block has been processed (without a miner active yet) or a
+    ///  nakamoto tenure's first block has been processed, so the relayer should issue
+    ///  a block commit
+    IssueBlockCommit(ConsensusHash, BlockHeaderHash),
+    /// Try to register a VRF public key
+    RegisterKey(BlockSnapshot),
+    /// Stop the relayer thread
+    Exit,
+}
+
 /// Relayer thread
 /// * accepts network results and stores blocks and microblocks
 /// * forwards new blocks, microblocks, and transactions to the p2p thread
@@ -72,12 +90,12 @@ use crate::BitcoinRegtestController;
 pub struct RelayerThread {
     /// Node config
     pub(crate) config: Config,
-    /// Handle to the sortition DB (optional so we can take/replace it)
-    sortdb: Option<SortitionDB>,
-    /// Handle to the chainstate DB (optional so we can take/replace it)
-    chainstate: Option<StacksChainState>,
-    /// Handle to the mempool DB (optional so we can take/replace it)
-    mempool: Option<MemPoolDB>,
+    /// Handle to the sortition DB
+    sortdb: SortitionDB,
+    /// Handle to the chainstate DB
+    chainstate: StacksChainState,
+    /// Handle to the mempool DB
+    mempool: MemPoolDB,
     /// Handle to global state and inter-thread communication channels
     pub(crate) globals: Globals,
     /// Authoritative copy of the keychain state
@@ -167,9 +185,9 @@ impl RelayerThread {
 
         RelayerThread {
             config: config.clone(),
-            sortdb: Some(sortdb),
-            chainstate: Some(chainstate),
-            mempool: Some(mempool),
+            sortdb,
+            chainstate,
+            mempool,
             globals,
             keychain,
             burnchain: runloop.get_burnchain(),
@@ -195,46 +213,6 @@ impl RelayerThread {
         }
     }
 
-    /// Get an immutible ref to the sortdb
-    pub fn sortdb_ref(&self) -> &SortitionDB {
-        self.sortdb
-            .as_ref()
-            .expect("FATAL: tried to access sortdb while taken")
-    }
-
-    /// Get an immutible ref to the chainstate
-    pub fn chainstate_ref(&self) -> &StacksChainState {
-        self.chainstate
-            .as_ref()
-            .expect("FATAL: tried to access chainstate while it was taken")
-    }
-
-    /// Fool the borrow checker into letting us do something with the chainstate databases.
-    /// DOES NOT COMPOSE -- do NOT call this, or self.sortdb_ref(), or self.chainstate_ref(), within
-    /// `func`.  You will get a runtime panic.
-    pub fn with_chainstate<F, R>(&mut self, func: F) -> R
-    where
-        F: FnOnce(&mut RelayerThread, &mut SortitionDB, &mut StacksChainState, &mut MemPoolDB) -> R,
-    {
-        let mut sortdb = self
-            .sortdb
-            .take()
-            .expect("FATAL: tried to take sortdb while taken");
-        let mut chainstate = self
-            .chainstate
-            .take()
-            .expect("FATAL: tried to take chainstate while taken");
-        let mut mempool = self
-            .mempool
-            .take()
-            .expect("FATAL: tried to take mempool while taken");
-        let res = func(self, &mut sortdb, &mut chainstate, &mut mempool);
-        self.sortdb = Some(sortdb);
-        self.chainstate = Some(chainstate);
-        self.mempool = Some(mempool);
-        res
-    }
-
     /// have we waited for the right conditions under which to start mining a block off of our
     /// chain tip?
     pub fn has_waited_for_latest_blocks(&self) -> bool {
@@ -286,21 +264,19 @@ impl RelayerThread {
             signal_mining_blocked(self.globals.get_miner_status());
         }
 
-        let net_receipts = self.with_chainstate(|relayer_thread, sortdb, chainstate, mempool| {
-            relayer_thread
-                .relayer
-                .process_network_result(
-                    &relayer_thread.local_peer,
-                    &mut net_result,
-                    sortdb,
-                    chainstate,
-                    mempool,
-                    relayer_thread.globals.sync_comms.get_ibd(),
-                    Some(&relayer_thread.globals.coord_comms),
-                    Some(&relayer_thread.event_dispatcher),
-                )
-                .expect("BUG: failure processing network results")
-        });
+        let net_receipts = self
+            .relayer
+            .process_network_result(
+                &self.local_peer,
+                &mut net_result,
+                &mut self.sortdb,
+                &mut self.chainstate,
+                &mut self.mempool,
+                self.globals.sync_comms.get_ibd(),
+                Some(&self.globals.coord_comms),
+                Some(&self.event_dispatcher),
+            )
+            .expect("BUG: failure processing network results");
 
         if net_receipts.num_new_blocks > 0 || net_receipts.num_new_confirmed_microblocks > 0 {
             // if we received any new block data that could invalidate our view of the chain tip,
@@ -318,7 +294,7 @@ impl RelayerThread {
         let num_unconfirmed_microblock_tx_receipts =
             net_receipts.processed_unconfirmed_state.receipts.len();
         if num_unconfirmed_microblock_tx_receipts > 0 {
-            if let Some(unconfirmed_state) = self.chainstate_ref().unconfirmed_state.as_ref() {
+            if let Some(unconfirmed_state) = self.chainstate.unconfirmed_state.as_ref() {
                 let canonical_tip = unconfirmed_state.confirmed_chain_tip.clone();
                 self.event_dispatcher.process_new_microblocks(
                     canonical_tip,
@@ -336,16 +312,14 @@ impl RelayerThread {
         }
 
         // synchronize unconfirmed tx index to p2p thread
-        self.with_chainstate(|relayer_thread, _sortdb, chainstate, _mempool| {
-            relayer_thread.globals.send_unconfirmed_txs(chainstate);
-        });
+        self.globals.send_unconfirmed_txs(&self.chainstate);
 
         // resume mining if we blocked it, and if we've done the requisite download
         // passes
         self.last_network_download_passes = net_result.num_download_passes;
         self.last_network_inv_passes = net_result.num_inv_sync_passes;
         if self.has_waited_for_latest_blocks() {
-            debug!("Relayer: did a download pass, so unblocking mining");
+            info!("Relayer: did a download pass, so unblocking mining");
             signal_mining_ready(self.globals.get_miner_status());
         }
     }
@@ -359,10 +333,9 @@ impl RelayerThread {
         burn_hash: BurnchainHeaderHash,
         committed_index_hash: StacksBlockId,
     ) -> MinerDirective {
-        let sn =
-            SortitionDB::get_block_snapshot_consensus(self.sortdb_ref().conn(), &consensus_hash)
-                .expect("FATAL: failed to query sortition DB")
-                .expect("FATAL: unknown consensus hash");
+        let sn = SortitionDB::get_block_snapshot_consensus(self.sortdb.conn(), &consensus_hash)
+            .expect("FATAL: failed to query sortition DB")
+            .expect("FATAL: unknown consensus hash");
 
         self.globals.set_last_sortition(sn.clone());
 
@@ -423,11 +396,10 @@ impl RelayerThread {
             // already in-flight
             return;
         }
-        let cur_epoch =
-            SortitionDB::get_stacks_epoch(self.sortdb_ref().conn(), burn_block.block_height)
-                .expect("FATAL: failed to query sortition DB")
-                .expect("FATAL: no epoch defined")
-                .epoch_id;
+        let cur_epoch = SortitionDB::get_stacks_epoch(self.sortdb.conn(), burn_block.block_height)
+            .expect("FATAL: failed to query sortition DB")
+            .expect("FATAL: no epoch defined")
+            .epoch_id;
         let (vrf_pk, _) = self.keychain.make_vrf_keypair(burn_block.block_height);
         let burnchain_tip_consensus_hash = &burn_block.consensus_hash;
         let miner_pkh = self.keychain.get_nakamoto_pkh();
@@ -464,24 +436,19 @@ impl RelayerThread {
         target_ch: &ConsensusHash,
         target_bh: &BlockHeaderHash,
     ) -> Result<(BlockSnapshot, StacksEpochId, LeaderBlockCommitOp), NakamotoNodeError> {
-        let chain_state = self
-            .chainstate
-            .as_mut()
-            .expect("FATAL: Failed to load chain state");
-        let sort_db = self.sortdb.as_mut().expect("FATAL: Failed to load sortdb");
-        let sort_tip = SortitionDB::get_canonical_burn_chain_tip(sort_db.conn())
+        let sort_tip = SortitionDB::get_canonical_burn_chain_tip(self.sortdb.conn())
             .map_err(|_| NakamotoNodeError::SnapshotNotFoundForChainTip)?;
 
         let parent_vrf_proof =
-            NakamotoChainState::get_block_vrf_proof(chain_state.db(), &target_ch)
+            NakamotoChainState::get_block_vrf_proof(self.chainstate.db(), &target_ch)
                 .map_err(|_e| NakamotoNodeError::ParentNotFound)?
                 .unwrap_or_else(|| VRFProof::empty());
 
         // let's figure out the recipient set!
         let recipients = get_next_recipients(
             &sort_tip,
-            chain_state,
-            sort_db,
+            &mut self.chainstate,
+            &mut self.sortdb,
             &self.burnchain,
             &OnChainRewardSetProvider(),
             self.config.node.always_use_affirmation_maps,
@@ -492,7 +459,7 @@ impl RelayerThread {
         })?;
 
         let block_header =
-            NakamotoChainState::get_block_header_by_consensus_hash(chain_state.db(), target_ch)
+            NakamotoChainState::get_block_header_by_consensus_hash(self.chainstate.db(), target_ch)
                 .map_err(|e| {
                     error!("Relayer: Failed to get block header for parent tenure: {e:?}");
                     NakamotoNodeError::ParentNotFound
@@ -511,14 +478,14 @@ impl RelayerThread {
         }
 
         let Ok(Some(parent_sortition)) =
-            SortitionDB::get_block_snapshot_consensus(sort_db.conn(), target_ch)
+            SortitionDB::get_block_snapshot_consensus(self.sortdb.conn(), target_ch)
         else {
             error!("Relayer: Failed to lookup the block snapshot of parent tenure ID"; "tenure_consensus_hash" => %target_ch);
             return Err(NakamotoNodeError::ParentNotFound);
         };
 
         let Ok(Some(target_epoch)) =
-            SortitionDB::get_stacks_epoch(sort_db.conn(), sort_tip.block_height + 1)
+            SortitionDB::get_stacks_epoch(self.sortdb.conn(), sort_tip.block_height + 1)
         else {
             error!("Relayer: Failed to lookup its epoch"; "target_height" => sort_tip.block_height + 1);
             return Err(NakamotoNodeError::SnapshotNotFoundForChainTip);
@@ -526,7 +493,7 @@ impl RelayerThread {
 
         let parent_block_burn_height = parent_sortition.block_height;
         let Ok(Some(parent_winning_tx)) = SortitionDB::get_block_commit(
-            sort_db.conn(),
+            self.sortdb.conn(),
             &parent_sortition.winning_block_txid,
             &parent_sortition.sortition_id,
         ) else {
@@ -621,7 +588,7 @@ impl RelayerThread {
         }
 
         let burn_header_hash = last_burn_block.burn_header_hash.clone();
-        let burn_chain_sn = SortitionDB::get_canonical_burn_chain_tip(self.sortdb_ref().conn())
+        let burn_chain_sn = SortitionDB::get_canonical_burn_chain_tip(self.sortdb.conn())
             .expect("FATAL: failed to query sortition DB for canonical burn chain tip");
 
         let burn_chain_tip = burn_chain_sn.burn_header_hash.clone();
@@ -779,8 +746,7 @@ impl RelayerThread {
             self.globals.get_leader_key_registration_state(),
             LeaderKeyRegistrationState::Inactive
         ) {
-            let Ok(sort_tip) = SortitionDB::get_canonical_burn_chain_tip(self.sortdb_ref().conn())
-            else {
+            let Ok(sort_tip) = SortitionDB::get_canonical_burn_chain_tip(self.sortdb.conn()) else {
                 warn!("Failed to fetch sortition tip while needing to register VRF key");
                 return None;
             };
@@ -796,8 +762,7 @@ impl RelayerThread {
         }
 
         // has there been a new sortition
-        let Ok(sort_tip) = SortitionDB::get_canonical_burn_chain_tip(self.sortdb_ref().conn())
-        else {
+        let Ok(sort_tip) = SortitionDB::get_canonical_burn_chain_tip(self.sortdb.conn()) else {
             return None;
         };
 
@@ -813,12 +778,11 @@ impl RelayerThread {
             true
         };
 
-        let Ok(Some(chain_tip_header)) = NakamotoChainState::get_canonical_block_header(
-            self.chainstate_ref().db(),
-            self.sortdb_ref(),
-        ) else {
+        let Ok(Some(chain_tip_header)) =
+            NakamotoChainState::get_canonical_block_header(self.chainstate.db(), &self.sortdb)
+        else {
             info!("No known canonical tip, will issue a genesis block commit");
-            return Some(RelayerDirective::NakamotoTenureStartProcessed(
+            return Some(RelayerDirective::IssueBlockCommit(
                 FIRST_BURNCHAIN_CONSENSUS_HASH,
                 FIRST_STACKS_BLOCK_HASH,
             ));
@@ -827,7 +791,7 @@ impl RelayerThread {
         // get the starting block of the chain tip's tenure
         let Ok(Some(chain_tip_tenure_start)) =
             NakamotoChainState::get_block_header_by_consensus_hash(
-                self.chainstate_ref().db(),
+                self.chainstate.db(),
                 &chain_tip_header.consensus_hash,
             )
         else {
@@ -849,7 +813,7 @@ impl RelayerThread {
             };
 
         if should_commit {
-            Some(RelayerDirective::NakamotoTenureStartProcessed(
+            Some(RelayerDirective::IssueBlockCommit(
                 chain_tip_header.consensus_hash,
                 chain_tip_header.anchored_header.block_hash(),
             ))
@@ -924,10 +888,10 @@ impl RelayerThread {
                 debug!("Relayer: directive Registered VRF key");
                 true
             }
-            // ProcessTenure directives correspond to a new sortition occurring.
+            // ProcessedBurnBlock directives correspond to a new sortition perhaps occurring.
             //  relayer should invoke `handle_sortition` to determine if they won the sortition,
             //  and to start their miner, or stop their miner if an active tenure is now ending
-            RelayerDirective::ProcessTenure(consensus_hash, burn_hash, block_header_hash) => {
+            RelayerDirective::ProcessedBurnBlock(consensus_hash, burn_hash, block_header_hash) => {
                 if !self.is_miner {
                     return true;
                 }
@@ -940,9 +904,8 @@ impl RelayerThread {
                 info!("Relayer: directive Processed tenures");
                 res
             }
-            // NakamotoTenureStartProcessed directives mean that a new tenure start has been processed
-            // These are triggered by the relayer waking up, seeing a new consensus hash *and* a new first tenure block
-            RelayerDirective::NakamotoTenureStartProcessed(consensus_hash, block_hash) => {
+            // These are triggered by the relayer waking up, seeing a new consensus hash *or* a new first tenure block
+            RelayerDirective::IssueBlockCommit(consensus_hash, block_hash) => {
                 if !self.is_miner {
                     return true;
                 }
@@ -953,11 +916,6 @@ impl RelayerThread {
                 debug!("Relayer: Nakamoto Tenure Start");
                 true
             }
-            RelayerDirective::RunTenure(..) => {
-                // No Op: the nakamoto node does not use the RunTenure directive to control its
-                //   miner thread.
-                true
-            }
             RelayerDirective::Exit => false,
         };
 
diff --git a/testnet/stacks-node/src/neon_node.rs b/testnet/stacks-node/src/neon_node.rs
index a3821fae2b..284d63a1c3 100644
--- a/testnet/stacks-node/src/neon_node.rs
+++ b/testnet/stacks-node/src/neon_node.rs
@@ -206,7 +206,7 @@ use crate::burnchains::bitcoin_regtest_controller::{
     addr2str, BitcoinRegtestController, OngoingBlockCommit,
 };
 use crate::burnchains::make_bitcoin_indexer;
-use crate::globals::{Globals, RelayerDirective};
+use crate::globals::{NeonGlobals as Globals, RelayerDirective};
 use crate::run_loop::neon::RunLoop;
 use crate::run_loop::RegisteredKey;
 use crate::ChainTip;
@@ -304,71 +304,59 @@ pub struct StacksNode {
 /// Fault injection logic to artificially increase the length of a tenure.
 /// Only used in testing
 #[cfg(test)]
-fn fault_injection_long_tenure() {
+pub(crate) fn fault_injection_long_tenure() {
     // simulated slow block
-    match std::env::var("STX_TEST_SLOW_TENURE") {
-        Ok(tenure_str) => match tenure_str.parse::<u64>() {
-            Ok(tenure_time) => {
-                info!(
-                    "Fault injection: sleeping for {} milliseconds to simulate a long tenure",
-                    tenure_time
-                );
-                stacks_common::util::sleep_ms(tenure_time);
-            }
-            Err(_) => {
-                error!("Parse error for STX_TEST_SLOW_TENURE");
-                panic!();
-            }
-        },
-        _ => {}
-    }
+    let Ok(tenure_str) = std::env::var("STX_TEST_SLOW_TENURE") else {
+        return;
+    };
+    let Ok(tenure_time) = tenure_str.parse::<u64>() else {
+        error!("Parse error for STX_TEST_SLOW_TENURE");
+        panic!();
+    };
+    info!(
+        "Fault injection: sleeping for {} milliseconds to simulate a long tenure",
+        tenure_time
+    );
+    stacks_common::util::sleep_ms(tenure_time);
 }
 
 #[cfg(not(test))]
-fn fault_injection_long_tenure() {}
+pub(crate) fn fault_injection_long_tenure() {}
 
 /// Fault injection to skip mining in this bitcoin block height
 /// Only used in testing
 #[cfg(test)]
-fn fault_injection_skip_mining(rpc_bind: &str, target_burn_height: u64) -> bool {
-    match std::env::var("STACKS_DISABLE_MINER") {
-        Ok(disable_heights) => {
-            let disable_schedule: serde_json::Value =
-                serde_json::from_str(&disable_heights).unwrap();
-            let disable_schedule = disable_schedule.as_array().unwrap();
-            for disabled in disable_schedule {
-                let target_miner_rpc_bind = disabled
-                    .get("rpc_bind")
-                    .unwrap()
-                    .as_str()
-                    .unwrap()
-                    .to_string();
-                if target_miner_rpc_bind != rpc_bind {
-                    continue;
-                }
-                let target_block_heights = disabled.get("blocks").unwrap().as_array().unwrap();
-                for target_block_value in target_block_heights {
-                    let target_block = target_block_value.as_i64().unwrap() as u64;
-                    if target_block == target_burn_height {
-                        return true;
-                    }
-                }
-            }
-            return false;
+pub(crate) fn fault_injection_skip_mining(rpc_bind: &str, target_burn_height: u64) -> bool {
+    let Ok(disable_heights) = std::env::var("STACKS_DISABLE_MINER") else {
+        return false;
+    };
+    let disable_schedule: serde_json::Value = serde_json::from_str(&disable_heights).unwrap();
+    let disable_schedule = disable_schedule.as_array().unwrap();
+    for disabled in disable_schedule {
+        let target_miner_rpc_bind = disabled.get("rpc_bind").unwrap().as_str().unwrap();
+        if target_miner_rpc_bind != rpc_bind {
+            continue;
         }
-        Err(_) => {
-            return false;
+        let target_block_heights = disabled.get("blocks").unwrap().as_array().unwrap();
+        for target_block_value in target_block_heights {
+            let target_block = u64::try_from(target_block_value.as_i64().unwrap()).unwrap();
+            if target_block == target_burn_height {
+                return true;
+            }
         }
     }
+    false
 }
 
 #[cfg(not(test))]
-fn fault_injection_skip_mining(_rpc_bind: &str, _target_burn_height: u64) -> bool {
+pub(crate) fn fault_injection_skip_mining(_rpc_bind: &str, _target_burn_height: u64) -> bool {
     false
 }
 
 /// Open the chainstate, and inject faults from the config file
-fn open_chainstate_with_faults(config: &Config) -> Result<StacksChainState, ChainstateError> {
+pub(crate) fn open_chainstate_with_faults(
+    config: &Config,
+) -> Result<StacksChainState, ChainstateError> {
     let stacks_chainstate_path = config.get_chainstate_path_str();
     let (mut chainstate, _) = StacksChainState::open(
         config.is_mainnet(),
@@ -3635,7 +3623,7 @@ impl StacksNode {
     }
 
     /// Set up the AST size-precheck height, if configured
-    fn setup_ast_size_precheck(config: &Config, sortdb: &mut SortitionDB) {
+    pub(crate) fn setup_ast_size_precheck(config: &Config, sortdb: &mut SortitionDB) {
         if let Some(ast_precheck_size_height) = config.burnchain.ast_precheck_size_height {
             info!(
                 "Override burnchain height of {:?} to {}",
@@ -3788,7 +3776,7 @@ impl StacksNode {
     }
 
     /// Set up the PeerNetwork, but do not bind it.
-    pub fn setup_peer_network(
+    pub(crate) fn setup_peer_network(
         config: &Config,
         atlas_config: &AtlasConfig,
         burnchain: Burnchain,
diff --git a/testnet/stacks-node/src/run_loop/boot_nakamoto.rs b/testnet/stacks-node/src/run_loop/boot_nakamoto.rs
index 1b54c24f5a..e70784ce42 100644
--- a/testnet/stacks-node/src/run_loop/boot_nakamoto.rs
+++ b/testnet/stacks-node/src/run_loop/boot_nakamoto.rs
@@ -1,3 +1,18 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020-2023 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Mutex};
 use std::thread::JoinHandle;
diff --git a/testnet/stacks-node/src/run_loop/nakamoto.rs b/testnet/stacks-node/src/run_loop/nakamoto.rs
index e6a835abb8..b3458a4ce6 100644
--- a/testnet/stacks-node/src/run_loop/nakamoto.rs
+++ b/testnet/stacks-node/src/run_loop/nakamoto.rs
@@ -1,3 +1,18 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020-2023 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
 use std::sync::atomic::AtomicBool;
 use std::sync::mpsc::sync_channel;
 use std::sync::{Arc, Mutex};
@@ -25,10 +40,9 @@ use stx_genesis::GenesisData;
 
 use super::RunLoopCallbacks;
 use crate::burnchains::make_bitcoin_indexer;
-use crate::globals::Globals;
+use crate::globals::Globals as GenericGlobals;
 use crate::monitoring::start_serving_monitoring_metrics;
-use crate::nakamoto_node::{StacksNode, BLOCK_PROCESSOR_STACK_SIZE, RELAYER_MAX_BUFFER};
-use crate::neon::RunLoopCounter;
+use crate::nakamoto_node::{self, StacksNode, BLOCK_PROCESSOR_STACK_SIZE, RELAYER_MAX_BUFFER};
 use crate::node::{
     get_account_balances, get_account_lockups, get_names, get_namespaces,
     use_test_genesis_chainstate,
@@ -41,6 +55,7 @@ use crate::{
 };
 
 pub const STDERR: i32 = 2;
+pub type Globals = GenericGlobals<nakamoto_node::relayer::RelayerDirective>;
 
 #[cfg(test)]
 const UNCONDITIONAL_CHAIN_LIVENESS_CHECK: u64 = 30;
@@ -116,22 +131,6 @@ impl RunLoop {
         self.coordinator_channels.as_ref().map(|x| x.1.clone())
     }
 
-    pub fn get_blocks_processed_arc(&self) -> RunLoopCounter {
-        self.counters.blocks_processed.clone()
-    }
-
-    pub fn submitted_commits(&self) -> RunLoopCounter {
-        self.counters.naka_submitted_commits.clone()
-    }
-
-    pub fn submitted_vrfs(&self) -> RunLoopCounter {
-        self.counters.naka_submitted_vrfs.clone()
-    }
-
-    pub fn mined_blocks(&self) -> RunLoopCounter {
-        self.counters.naka_mined_blocks.clone()
-    }
-
     pub fn get_counters(&self) -> Counters {
         self.counters.clone()
     }
diff --git a/testnet/stacks-node/src/run_loop/neon.rs b/testnet/stacks-node/src/run_loop/neon.rs
index c10c9b88c3..cffcd1aa10 100644
--- a/testnet/stacks-node/src/run_loop/neon.rs
+++ b/testnet/stacks-node/src/run_loop/neon.rs
@@ -31,7 +31,7 @@ use stx_genesis::GenesisData;
 
 use super::RunLoopCallbacks;
 use crate::burnchains::make_bitcoin_indexer;
-use crate::globals::Globals;
+use crate::globals::NeonGlobals as Globals;
 use crate::monitoring::start_serving_monitoring_metrics;
 use crate::neon_node::{StacksNode, BLOCK_PROCESSOR_STACK_SIZE, RELAYER_MAX_BUFFER};
 use crate::node::{
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index ad9c473992..2b4fdfa540 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -1,3 +1,18 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020-2023 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
 use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::{Arc, Mutex};
 use std::time::{Duration, Instant};
@@ -11,13 +26,11 @@ use stacks::chainstate::coordinator::comm::CoordinatorChannels;
 use stacks::chainstate::nakamoto::NakamotoChainState;
 use stacks::chainstate::stacks::db::StacksChainState;
 use stacks::core::{
-    MemPoolDB, StacksEpoch, StacksEpochId, BLOCK_LIMIT_MAINNET_10, HELIUM_BLOCK_LIMIT_20,
+    StacksEpoch, StacksEpochId, BLOCK_LIMIT_MAINNET_10, HELIUM_BLOCK_LIMIT_20,
     PEER_VERSION_EPOCH_1_0, PEER_VERSION_EPOCH_2_0, PEER_VERSION_EPOCH_2_05,
     PEER_VERSION_EPOCH_2_1, PEER_VERSION_EPOCH_2_2, PEER_VERSION_EPOCH_2_3, PEER_VERSION_EPOCH_2_4,
     PEER_VERSION_EPOCH_2_5, PEER_VERSION_EPOCH_3_0,
 };
-use stacks::cost_estimates::metrics::UnitMetric;
-use stacks::cost_estimates::UnitEstimator;
 use stacks_common::address::AddressHashMode;
 use stacks_common::consts::STACKS_EPOCH_MAX;
 use stacks_common::types::chainstate::StacksAddress;
@@ -411,14 +424,9 @@ fn simple_neon_integration() {
         .unwrap()
         .unwrap();
 
-    let mut mempool = MemPoolDB::open(
-        naka_conf.is_mainnet(),
-        naka_conf.burnchain.chain_id,
-        &naka_conf.get_chainstate_path_str(),
-        Box::new(UnitEstimator),
-        Box::new(UnitMetric),
-    )
-    .expect("Database failure opening mempool");
+    let mut mempool = naka_conf
+        .connect_mempool_db()
+        .expect("Database failure opening mempool");
 
     mempool
         .submit_raw(

From b84b483fa5089c755dea1f630d6c8d5610fecfd0 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Sun, 10 Dec 2023 09:58:40 -0600
Subject: [PATCH 0188/1166] chore: comments, cleanup unused functions

---
 testnet/stacks-node/src/globals.rs            | 10 +-
 testnet/stacks-node/src/nakamoto_node.rs      | 59 ++++++------
 testnet/stacks-node/src/nakamoto_node/peer.rs |  4 +-
 .../stacks-node/src/nakamoto_node/relayer.rs  | 91 ++++++++-----------
 testnet/stacks-node/src/run_loop/nakamoto.rs  | 62 ++++++-------
 5 files changed, 102 insertions(+), 124 deletions(-)

diff --git a/testnet/stacks-node/src/globals.rs b/testnet/stacks-node/src/globals.rs
index 6c60e9a591..bd1560477c 100644
--- a/testnet/stacks-node/src/globals.rs
+++ b/testnet/stacks-node/src/globals.rs
@@ -35,7 +35,9 @@ pub enum RelayerDirective {
     Exit,
 }
 
-/// Inter-thread communication structure, shared between threads
+/// Inter-thread communication structure, shared between threads. This
+/// is generic over the relayer communication channel: nakamoto and
+/// neon nodes use different relayer directives.
 pub struct Globals<T> {
     /// Last sortition processed
     last_sortition: Arc<Mutex<Option<BlockSnapshot>>>,
@@ -100,6 +102,12 @@ impl<T> Globals<T> {
         }
     }
 
+    /// Does the inventory sync watcher think we still need to
+    /// catch up to the chain tip?
+    pub fn in_initial_block_download(&self) -> bool {
+        self.sync_comms.get_ibd()
+    }
+
     /// Get the last sortition processed by the relayer thread
     pub fn get_last_sortition(&self) -> Option<BlockSnapshot> {
         self.last_sortition
diff --git a/testnet/stacks-node/src/nakamoto_node.rs b/testnet/stacks-node/src/nakamoto_node.rs
index 0482bbfb05..3584a5d864 100644
--- a/testnet/stacks-node/src/nakamoto_node.rs
+++ b/testnet/stacks-node/src/nakamoto_node.rs
@@ -65,15 +65,18 @@ pub struct StacksNode {
     pub relayer_thread_handle: JoinHandle<()>,
 }
 
-/// Types of errors that can arise during mining
+/// Types of errors that can arise during Nakamoto StacksNode operation
 #[derive(Debug)]
-enum Error {
+pub enum Error {
     /// Can't find the block sortition snapshot for the chain tip
     SnapshotNotFoundForChainTip,
     /// The burnchain tip changed while this operation was in progress
     BurnchainTipChanged,
+    /// Error while spawning a subordinate thread
     SpawnError(std::io::Error),
+    /// Injected testing errors
     FaultInjection,
+    /// This miner was elected, but another sortition occurred before mining started
     MissedMiningOpportunity,
     /// Attempted to mine while there was no active VRF key
     NoVRFKeyActive,
@@ -83,7 +86,10 @@ enum Error {
     UnexpectedChainState,
     /// A burnchain operation failed when submitting it to the burnchain
     BurnchainSubmissionFailed,
+    /// A new parent has been discovered since mining started
     NewParentDiscovered,
+    // The thread that we tried to send to has closed
+    ChannelClosed,
 }
 
 impl StacksNode {
@@ -201,19 +207,14 @@ impl StacksNode {
     ///  telling it to process the block and begin mining if this miner won.
     /// returns _false_ if the relayer hung up the channel.
     /// Called from the main thread.
-    pub fn relayer_burnchain_notify(&self) -> bool {
+    fn relayer_burnchain_notify(&self, snapshot: BlockSnapshot) -> Result<(), Error> {
         if !self.is_miner {
-            // node is a follower, don't try to process my own tenure.
-            return true;
+            // node is a follower, don't need to notify the relayer of these events.
+            return Ok(());
         }
 
-        let Some(snapshot) = self.globals.get_last_sortition() else {
-            debug!("Tenure: Notify sortition! No last burn block");
-            return true;
-        };
-
-        debug!(
-            "Tenure: Notify sortition!";
+        info!(
+            "Tenure: Notify burn block!";
             "consensus_hash" => %snapshot.consensus_hash,
             "burn_block_hash" => %snapshot.burn_header_hash,
             "winning_stacks_block_hash" => %snapshot.winning_stacks_block_hash,
@@ -224,15 +225,14 @@ impl StacksNode {
         // unlike in neon_node, the nakamoto node should *always* notify the relayer of
         //  a new burnchain block
 
-        return self
-            .globals
+        self.globals
             .relay_send
             .send(RelayerDirective::ProcessedBurnBlock(
-                snapshot.consensus_hash.clone(),
-                snapshot.parent_burn_header_hash.clone(),
-                snapshot.winning_stacks_block_hash.clone(),
+                snapshot.consensus_hash,
+                snapshot.parent_burn_header_hash,
+                snapshot.winning_stacks_block_hash,
             ))
-            .is_ok();
+            .map_err(|_| Error::ChannelClosed)
     }
 
     /// Process a state coming from the burnchain, by extracting the validated KeyRegisterOp
@@ -244,9 +244,7 @@ impl StacksNode {
         sortdb: &SortitionDB,
         sort_id: &SortitionId,
         ibd: bool,
-    ) -> Option<BlockSnapshot> {
-        let mut last_sortitioned_block = None;
-
+    ) -> Result<(), Error> {
         let ic = sortdb.index_conn();
 
         let block_snapshot = SortitionDB::get_block_snapshot(&ic, sort_id)
@@ -268,14 +266,11 @@ impl StacksNode {
                     "Received burnchain block #{} including block_commit_op (winning) - {} ({})",
                     block_height, op.apparent_sender, &op.block_header_hash
                 );
-                last_sortitioned_block = Some((block_snapshot.clone(), op.vtxindex));
-            } else {
-                if self.is_miner {
-                    info!(
-                        "Received burnchain block #{} including block_commit_op - {} ({})",
-                        block_height, op.apparent_sender, &op.block_header_hash
-                    );
-                }
+            } else if self.is_miner {
+                info!(
+                    "Received burnchain block #{} including block_commit_op - {} ({})",
+                    block_height, op.apparent_sender, &op.block_header_hash
+                );
             }
         }
 
@@ -296,8 +291,10 @@ impl StacksNode {
             "in_initial_block_download?" => ibd,
         );
 
-        self.globals.set_last_sortition(block_snapshot);
-        last_sortitioned_block.map(|x| x.0)
+        self.globals.set_last_sortition(block_snapshot.clone());
+
+        // notify the relayer thread of the new sortition state
+        self.relayer_burnchain_notify(block_snapshot)
     }
 
     /// Join all inner threads
diff --git a/testnet/stacks-node/src/nakamoto_node/peer.rs b/testnet/stacks-node/src/nakamoto_node/peer.rs
index 762aa45eda..376c437723 100644
--- a/testnet/stacks-node/src/nakamoto_node/peer.rs
+++ b/testnet/stacks-node/src/nakamoto_node/peer.rs
@@ -154,7 +154,7 @@ impl PeerThread {
         )
     }
 
-    pub fn new_all(
+    fn new_all(
         globals: Globals,
         config: &Config,
         pox_constants: PoxConstants,
@@ -204,7 +204,7 @@ impl PeerThread {
 
     /// Run one pass of the p2p/http state machine
     /// Return true if we should continue running passes; false if not
-    pub fn run_one_pass<B: BurnchainHeaderReader>(
+    pub(crate) fn run_one_pass<B: BurnchainHeaderReader>(
         &mut self,
         indexer: &B,
         dns_client_opt: Option<&mut DNSClient>,
diff --git a/testnet/stacks-node/src/nakamoto_node/relayer.rs b/testnet/stacks-node/src/nakamoto_node/relayer.rs
index 04f04241e0..68ca5d723a 100644
--- a/testnet/stacks-node/src/nakamoto_node/relayer.rs
+++ b/testnet/stacks-node/src/nakamoto_node/relayer.rs
@@ -1,3 +1,4 @@
+use core::fmt;
 // Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
 // Copyright (C) 2020-2023 Stacks Open Internet Foundation
 //
@@ -38,8 +39,6 @@ use stacks::core::mempool::MemPoolDB;
 use stacks::core::{
     FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH, STACKS_EPOCH_3_0_MARKER,
 };
-use stacks::cost_estimates::metrics::UnitMetric;
-use stacks::cost_estimates::UnitEstimator;
 use stacks::monitoring::increment_stx_blocks_mined_counter;
 use stacks::net::db::LocalPeer;
 use stacks::net::relay::Relayer;
@@ -82,10 +81,23 @@ pub enum RelayerDirective {
     Exit,
 }
 
+impl fmt::Display for RelayerDirective {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            RelayerDirective::HandleNetResult(_) => write!(f, "HandleNetResult"),
+            RelayerDirective::ProcessedBurnBlock(_, _, _) => write!(f, "ProcessedBurnBlock"),
+            RelayerDirective::IssueBlockCommit(_, _) => write!(f, "IssueBlockCommit"),
+            RelayerDirective::RegisterKey(_) => write!(f, "RegisterKey"),
+            RelayerDirective::Exit => write!(f, "Exit"),
+        }
+    }
+}
+
 /// Relayer thread
 /// * accepts network results and stores blocks and microblocks
 /// * forwards new blocks, microblocks, and transactions to the p2p thread
-/// * processes burnchain state
+/// * issues (and re-issues) block commits to participate as a miner
+/// * processes burnchain state to determine if selected as a miner
 /// * if mining, runs the miner and broadcasts blocks (via a subordinate MinerThread)
 pub struct RelayerThread {
     /// Node config
@@ -148,14 +160,12 @@ pub struct RelayerThread {
 }
 
 impl RelayerThread {
-    /// Instantiate off of a StacksNode, a runloop, and a relayer.
+    /// Instantiate relayer thread.
+    /// Uses `runloop` to obtain globals, config, and `is_miner`` status
     pub fn new(runloop: &RunLoop, local_peer: LocalPeer, relayer: Relayer) -> RelayerThread {
         let config = runloop.config().clone();
         let globals = runloop.get_globals();
         let burn_db_path = config.get_burn_db_file_path();
-        let stacks_chainstate_path = config.get_chainstate_path_str();
-        let is_mainnet = config.is_mainnet();
-        let chain_id = config.burnchain.chain_id;
         let is_miner = runloop.is_miner();
 
         let sortdb = SortitionDB::open(&burn_db_path, true, runloop.get_burnchain().pox_constants)
@@ -164,21 +174,9 @@ impl RelayerThread {
         let chainstate =
             open_chainstate_with_faults(&config).expect("FATAL: failed to open chainstate DB");
 
-        let cost_estimator = config
-            .make_cost_estimator()
-            .unwrap_or_else(|| Box::new(UnitEstimator));
-        let metric = config
-            .make_cost_metric()
-            .unwrap_or_else(|| Box::new(UnitMetric));
-
-        let mempool = MemPoolDB::open(
-            is_mainnet,
-            chain_id,
-            &stacks_chainstate_path,
-            cost_estimator,
-            metric,
-        )
-        .expect("Database failure opening mempool");
+        let mempool = config
+            .connect_mempool_db()
+            .expect("Database failure opening mempool");
 
         let keychain = Keychain::default(config.node.seed.clone());
         let bitcoin_controller = BitcoinRegtestController::new_dummy(config.clone());
@@ -215,7 +213,7 @@ impl RelayerThread {
 
     /// have we waited for the right conditions under which to start mining a block off of our
     /// chain tip?
-    pub fn has_waited_for_latest_blocks(&self) -> bool {
+    fn has_waited_for_latest_blocks(&self) -> bool {
         // a network download pass took place
         (self.min_network_download_passes <= self.last_network_download_passes
         // a network inv pass took place
@@ -226,21 +224,6 @@ impl RelayerThread {
         || !self.config.miner.wait_for_block_download
     }
 
-    /// Return debug string for waiting for latest blocks
-    pub fn debug_waited_for_latest_blocks(&self) -> String {
-        format!(
-            "({} <= {} && {} <= {}) || {} + {} < {} || {}",
-            self.min_network_download_passes,
-            self.last_network_download_passes,
-            self.min_network_inv_passes,
-            self.last_network_inv_passes,
-            self.last_network_block_height_ts,
-            self.config.node.wait_time_for_blocks,
-            get_epoch_time_ms(),
-            self.config.miner.wait_for_block_download
-        )
-    }
-
     /// Handle a NetworkResult from the p2p/http state machine.  Usually this is the act of
     /// * preprocessing and storing new blocks and microblocks
     /// * relaying blocks, microblocks, and transacctions
@@ -503,7 +486,6 @@ impl RelayerThread {
 
         let parent_winning_vtxindex = parent_winning_tx.vtxindex;
 
-        // let burn_fee_cap = self.config.burnchain.burn_fee_cap;
         let burn_fee_cap = get_mining_spend_amount(self.globals.get_miner_status());
         let sunset_burn = self.burnchain.expected_sunset_burn(
             sort_tip.block_height + 1,
@@ -738,9 +720,6 @@ impl RelayerThread {
             return None;
         }
 
-        // TODO (nakamoto): the miner shouldn't issue either of these directives
-        //   if we're still in IBD!
-
         // do we need a VRF key registration?
         if matches!(
             self.globals.get_leader_key_registration_state(),
@@ -869,11 +848,10 @@ impl RelayerThread {
 
     /// Top-level dispatcher
     pub fn handle_directive(&mut self, directive: RelayerDirective) -> bool {
+        info!("Relayer: handling directive"; "directive" => %directive);
         let continue_running = match directive {
             RelayerDirective::HandleNetResult(net_result) => {
-                debug!("Relayer: directive Handle network result");
                 self.process_network_result(net_result);
-                debug!("Relayer: directive Handled network result");
                 true
             }
             // RegisterKey directives mean that the relayer should try to register a new VRF key.
@@ -882,10 +860,12 @@ impl RelayerThread {
                 if !self.is_miner {
                     return true;
                 }
-                debug!("Relayer: directive Register VRF key");
+                if self.globals.in_initial_block_download() {
+                    info!("In initial block download, will not submit VRF registration");
+                    return true;
+                }
                 self.rotate_vrf_and_register(&last_burn_block);
                 self.globals.counters.bump_blocks_processed();
-                debug!("Relayer: directive Registered VRF key");
                 true
             }
             // ProcessedBurnBlock directives correspond to a new sortition perhaps occurring.
@@ -895,30 +875,33 @@ impl RelayerThread {
                 if !self.is_miner {
                     return true;
                 }
-                info!("Relayer: directive Process tenures");
-                let res = self.handle_sortition(
+                if self.globals.in_initial_block_download() {
+                    debug!("In initial block download, will not check sortition for miner");
+                    return true;
+                }
+                self.handle_sortition(
                     consensus_hash,
                     burn_hash,
                     StacksBlockId(block_header_hash.0),
-                );
-                info!("Relayer: directive Processed tenures");
-                res
+                )
             }
             // These are triggered by the relayer waking up, seeing a new consensus hash *or* a new first tenure block
             RelayerDirective::IssueBlockCommit(consensus_hash, block_hash) => {
                 if !self.is_miner {
                     return true;
                 }
-                debug!("Relayer: Nakamoto Tenure Start");
+                if self.globals.in_initial_block_download() {
+                    debug!("In initial block download, will not issue block commit");
+                    return true;
+                }
                 if let Err(e) = self.issue_block_commit(consensus_hash, block_hash) {
                     warn!("Relayer failed to issue block commit"; "err" => ?e);
                 }
-                debug!("Relayer: Nakamoto Tenure Start");
                 true
             }
             RelayerDirective::Exit => false,
         };
-
+        debug!("Relayer: handled directive"; "continue_running" => continue_running);
         continue_running
     }
 }
diff --git a/testnet/stacks-node/src/run_loop/nakamoto.rs b/testnet/stacks-node/src/run_loop/nakamoto.rs
index b3458a4ce6..e429e79c91 100644
--- a/testnet/stacks-node/src/run_loop/nakamoto.rs
+++ b/testnet/stacks-node/src/run_loop/nakamoto.rs
@@ -38,7 +38,6 @@ use stacks_common::util::hash::Hash160;
 use stacks_common::util::{get_epoch_time_secs, sleep_ms};
 use stx_genesis::GenesisData;
 
-use super::RunLoopCallbacks;
 use crate::burnchains::make_bitcoin_indexer;
 use crate::globals::Globals as GenericGlobals;
 use crate::monitoring::start_serving_monitoring_metrics;
@@ -63,18 +62,18 @@ const UNCONDITIONAL_CHAIN_LIVENESS_CHECK: u64 = 30;
 #[cfg(not(test))]
 const UNCONDITIONAL_CHAIN_LIVENESS_CHECK: u64 = 300;
 
-/// Coordinating a node running in neon mode.
+/// Coordinating a node running in nakamoto mode. This runloop operates very similarly to the neon runloop.
 pub struct RunLoop {
     config: Config,
-    pub callbacks: RunLoopCallbacks,
     globals: Option<Globals>,
     counters: Counters,
     coordinator_channels: Option<(CoordinatorReceivers, CoordinatorChannels)>,
     should_keep_running: Arc<AtomicBool>,
     event_dispatcher: EventDispatcher,
+    #[allow(dead_code)]
     pox_watchdog: Option<PoxSyncWatchdog>, // can't be instantiated until .start() is called
-    is_miner: Option<bool>,                // not known until .start() is called
-    burnchain: Option<Burnchain>,          // not known until .start() is called
+    is_miner: Option<bool>,       // not known until .start() is called
+    burnchain: Option<Burnchain>, // not known until .start() is called
     pox_watchdog_comms: PoxSyncWatchdogComms,
     /// NOTE: this is duplicated in self.globals, but it needs to be accessible before globals is
     /// instantiated (namely, so the test framework can access it).
@@ -105,7 +104,6 @@ impl RunLoop {
             config,
             globals: None,
             coordinator_channels: Some(channels),
-            callbacks: RunLoopCallbacks::new(),
             counters: counters.unwrap_or_else(|| Counters::new()),
             should_keep_running,
             event_dispatcher,
@@ -117,7 +115,7 @@ impl RunLoop {
         }
     }
 
-    pub fn get_globals(&self) -> Globals {
+    pub(crate) fn get_globals(&self) -> Globals {
         self.globals
             .clone()
             .expect("FATAL: globals not instantiated")
@@ -127,47 +125,37 @@ impl RunLoop {
         self.globals = Some(globals);
     }
 
-    pub fn get_coordinator_channel(&self) -> Option<CoordinatorChannels> {
+    pub(crate) fn get_coordinator_channel(&self) -> Option<CoordinatorChannels> {
         self.coordinator_channels.as_ref().map(|x| x.1.clone())
     }
 
-    pub fn get_counters(&self) -> Counters {
+    pub(crate) fn get_counters(&self) -> Counters {
         self.counters.clone()
     }
 
-    pub fn config(&self) -> &Config {
+    pub(crate) fn config(&self) -> &Config {
         &self.config
     }
 
-    pub fn get_event_dispatcher(&self) -> EventDispatcher {
+    pub(crate) fn get_event_dispatcher(&self) -> EventDispatcher {
         self.event_dispatcher.clone()
     }
 
-    pub fn is_miner(&self) -> bool {
+    pub(crate) fn is_miner(&self) -> bool {
         self.is_miner.unwrap_or(false)
     }
 
-    pub fn get_pox_sync_comms(&self) -> PoxSyncWatchdogComms {
-        self.pox_watchdog_comms.clone()
-    }
-
-    pub fn get_termination_switch(&self) -> Arc<AtomicBool> {
+    pub(crate) fn get_termination_switch(&self) -> Arc<AtomicBool> {
         self.should_keep_running.clone()
     }
 
-    pub fn get_burnchain(&self) -> Burnchain {
+    pub(crate) fn get_burnchain(&self) -> Burnchain {
         self.burnchain
             .clone()
             .expect("FATAL: tried to get runloop burnchain before calling .start()")
     }
 
-    pub fn get_pox_watchdog(&mut self) -> &mut PoxSyncWatchdog {
-        self.pox_watchdog
-            .as_mut()
-            .expect("FATAL: tried to get PoX watchdog before calling .start()")
-    }
-
-    pub fn get_miner_status(&self) -> Arc<Mutex<MinerStatus>> {
+    pub(crate) fn get_miner_status(&self) -> Arc<Mutex<MinerStatus>> {
         self.miner_status.clone()
     }
 
@@ -228,7 +216,7 @@ impl RunLoop {
     /// Boot up the stacks chainstate.
     /// Instantiate the chainstate and push out the boot receipts to observers
     /// This is only public so we can test it.
-    pub fn boot_chainstate(&mut self, burnchain_config: &Burnchain) -> StacksChainState {
+    fn boot_chainstate(&mut self, burnchain_config: &Burnchain) -> StacksChainState {
         let use_test_genesis_data = use_test_genesis_chainstate(&self.config);
 
         // load up genesis balances
@@ -862,7 +850,14 @@ impl RunLoop {
             // wait for the p2p state-machine to do at least one pass
             debug!("Runloop: Wait until Stacks block downloads reach a quiescent state before processing more burnchain blocks"; "remote_chain_height" => remote_chain_height, "local_chain_height" => burnchain_height);
 
+            // TODO: for now, we just set initial block download false.
+            //   I think that the sync watchdog probably needs to change a fair bit
+            //   for nakamoto. There may be some opportunity to refactor this runloop
+            //   as well (e.g., the `mine_start` should be integrated with the
+            //   watchdog so that there's just one source of truth about ibd),
+            //   but I think all of this can be saved for post-neon work.
             let ibd = false;
+            self.pox_watchdog_comms.set_ibd(ibd);
 
             // calculate burnchain sync percentage
             let percent: f64 = if remote_chain_height > 0 {
@@ -947,16 +942,11 @@ impl RunLoop {
                         let sortition_id = &block.sortition_id;
 
                         // Have the node process the new block, that can include, or not, a sortition.
-                        node.process_burnchain_state(burnchain.sortdb_mut(), sortition_id, ibd);
-
-                        // Now, tell the relayer to check if it won a sortition during this block,
-                        // and, if so, to process and advertize the block.  This is basically a
-                        // no-op during boot-up.
-                        //
-                        // _this will block if the relayer's buffer is full_
-                        if !node.relayer_burnchain_notify() {
-                            // relayer hung up, exit.
-                            error!("Runloop: Block relayer and miner hung up, exiting.");
+                        if let Err(e) =
+                            node.process_burnchain_state(burnchain.sortdb_mut(), sortition_id, ibd)
+                        {
+                            // relayer errored, exit.
+                            error!("Runloop: Block relayer and miner errored, exiting."; "err" => ?e);
                             return;
                         }
                     }

From 5877771980e6addb6ce23f900d66ee55b04ff20a Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Mon, 11 Dec 2023 19:57:33 -0500
Subject: [PATCH 0189/1166] Fix broken mempool_setup_chainstate test

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 testnet/stacks-node/src/tests/mempool.rs | 28 ++++++------------------
 1 file changed, 7 insertions(+), 21 deletions(-)

diff --git a/testnet/stacks-node/src/tests/mempool.rs b/testnet/stacks-node/src/tests/mempool.rs
index d6ed3af47e..cc1f3d8228 100644
--- a/testnet/stacks-node/src/tests/mempool.rs
+++ b/testnet/stacks-node/src/tests/mempool.rs
@@ -699,13 +699,7 @@ fn mempool_setup_chainstate() {
                     )
                     .unwrap_err();
                 eprintln!("Err: {:?}", e);
-                assert!(
-                    if let MemPoolRejection::PoisonMicroblocksDoNotConflict = e {
-                        true
-                    } else {
-                        false
-                    }
-                );
+                assert!(matches!(e, MemPoolRejection::Other(_)));
 
                 let microblock_1 = StacksMicroblockHeader {
                     version: 0,
@@ -736,11 +730,7 @@ fn mempool_setup_chainstate() {
                     )
                     .unwrap_err();
                 eprintln!("Err: {:?}", e);
-                assert!(if let MemPoolRejection::InvalidMicroblocks = e {
-                    true
-                } else {
-                    false
-                });
+                assert!(matches!(e, MemPoolRejection::Other(_)));
 
                 let mut microblock_1 = StacksMicroblockHeader {
                     version: 0,
@@ -774,13 +764,7 @@ fn mempool_setup_chainstate() {
                     )
                     .unwrap_err();
                 eprintln!("Err: {:?}", e);
-                assert!(
-                    if let MemPoolRejection::NoAnchorBlockWithPubkeyHash(_) = e {
-                        true
-                    } else {
-                        false
-                    }
-                );
+                assert!(matches!(e, MemPoolRejection::Other(_)));
 
                 let tx_bytes = make_coinbase(&contract_sk, 5, 1000);
                 let tx =
@@ -843,7 +827,7 @@ fn mempool_setup_chainstate() {
                 let tx_bytes = make_poison(&contract_sk, 5, 1000, microblock_1, microblock_2);
                 let tx =
                     StacksTransaction::consensus_deserialize(&mut tx_bytes.as_slice()).unwrap();
-                chain_state
+                let e = chain_state
                     .will_admit_mempool_tx(
                         &NULL_BURN_STATE_DB,
                         consensus_hash,
@@ -851,7 +835,9 @@ fn mempool_setup_chainstate() {
                         &tx,
                         tx_bytes.len() as u64,
                     )
-                    .unwrap();
+                    .unwrap_err();
+                eprintln!("Err: {:?}", e);
+                assert!(matches!(e, MemPoolRejection::Other(_)));
 
                 let contract_id = QualifiedContractIdentifier::new(
                     StandardPrincipalData::from(contract_addr.clone()),

From aa5ca438829a59bcbba7c392a95193a5e0ae2435 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Tue, 12 Dec 2023 09:48:21 -0600
Subject: [PATCH 0190/1166] chore: handle merge/rebase artifacts, address PR
 feedback

---
 Cargo.lock                                    |   4 +
 stackslib/src/chainstate/nakamoto/miner.rs    |  10 +-
 testnet/stacks-node/src/mockamoto.rs          |   2 +-
 .../stacks-node/src/nakamoto_node/miner.rs    |  56 +--
 testnet/stacks-node/src/run_loop/nakamoto.rs  | 339 +-----------------
 5 files changed, 42 insertions(+), 369 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index a90cb48536..b9f59752b4 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2354,6 +2354,8 @@ checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39"
 [[package]]
 name = "p256k1"
 version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5afcf536d20c074ef45371ee9a654dcfc46fb2dde18ecc54ec30c936eb850fa2"
 dependencies = [
  "bindgen",
  "bitvec",
@@ -4711,6 +4713,8 @@ dependencies = [
 [[package]]
 name = "wsts"
 version = "5.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2c250118354755b4abb091a83cb8d659b511c0ae211ccdb3b1254e3db199cb86"
 dependencies = [
  "aes-gcm 0.10.2",
  "bs58 0.5.0",
diff --git a/stackslib/src/chainstate/nakamoto/miner.rs b/stackslib/src/chainstate/nakamoto/miner.rs
index 1f75cd55ac..5b511f6aa2 100644
--- a/stackslib/src/chainstate/nakamoto/miner.rs
+++ b/stackslib/src/chainstate/nakamoto/miner.rs
@@ -570,9 +570,13 @@ impl NakamotoBlockBuilder {
             .block_limit()
             .expect("Failed to obtain block limit from miner's block connection");
 
-        let initial_txs: Vec<_> = 
-            [new_tenure_info.tenure_change_tx.cloned(),
-             new_tenure_info.coinbase_tx.cloned()].into_iter().filter_map(|x| x).collect();
+        let initial_txs: Vec<_> = [
+            tenure_info.tenure_change_tx.clone(),
+            tenure_info.coinbase_tx.clone(),
+        ]
+        .into_iter()
+        .filter_map(|x| x)
+        .collect();
         let (blocked, tx_events) = match StacksBlockBuilder::select_and_apply_transactions(
             &mut tenure_tx,
             &mut builder,
diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index 7b56c2afb8..373bcab8f2 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -797,7 +797,7 @@ impl MockamotoNode {
         let tenure_change_tx_payload = TransactionPayload::TenureChange(TenureChangePayload {
             tenure_consensus_hash: sortition_tip.consensus_hash.clone(),
             prev_tenure_consensus_hash: chain_tip_ch.clone(),
-            sortition_consensus_hash: sortition_tip.consensus_hash,
+            burn_view_consensus_hash: sortition_tip.consensus_hash,
             previous_tenure_end: parent_block_id,
             previous_tenure_blocks: 1,
             cause: TenureChangeCause::BlockFound,
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index ae2781ce7b..07efbedaca 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -21,7 +21,7 @@ use clarity::vm::types::PrincipalData;
 use stacks::burnchains::{Burnchain, BurnchainParameters};
 use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::burn::{BlockSnapshot, ConsensusHash};
-use stacks::chainstate::nakamoto::miner::{NakamotoBlockBuilder, NakamotoTenureStart};
+use stacks::chainstate::nakamoto::miner::{NakamotoBlockBuilder, NakamotoTenureInfo};
 use stacks::chainstate::nakamoto::{NakamotoBlock, NakamotoChainState};
 use stacks::chainstate::stacks::db::{StacksChainState, StacksHeaderInfo};
 use stacks::chainstate::stacks::{
@@ -56,9 +56,8 @@ pub enum MinerDirective {
 }
 
 struct ParentTenureInfo {
-    #[allow(dead_code)]
-    parent_tenure_start: StacksBlockId,
     parent_tenure_blocks: u64,
+    parent_tenure_consensus_hash: ConsensusHash,
 }
 
 /// Metadata required for beginning a new tenure
@@ -167,12 +166,12 @@ impl BlockMinerThread {
             self.burnchain.pox_constants.clone(),
         )
         .expect("FATAL: could not open sortition DB");
-        let sortition_handle = sort_db.index_handle_at_tip();
+        let mut sortition_handle = sort_db.index_handle_at_tip();
         let staging_tx = chain_state.staging_db_tx_begin()?;
         NakamotoChainState::accept_block(
             &chainstate_config,
             block,
-            &sortition_handle,
+            &mut sortition_handle,
             &staging_tx,
             &signer.aggregate_public_key,
         )?;
@@ -194,6 +193,7 @@ impl BlockMinerThread {
         &mut self,
         nonce: u64,
         parent_block_id: StacksBlockId,
+        parent_tenure_consensus_hash: ConsensusHash,
         parent_tenure_blocks: u64,
         miner_pkh: Hash160,
     ) -> Option<StacksTransaction> {
@@ -203,17 +203,18 @@ impl BlockMinerThread {
         }
         let is_mainnet = self.config.is_mainnet();
         let chain_id = self.config.burnchain.chain_id;
-        let tenure_change_tx_payload = TransactionPayload::TenureChange(
-            TenureChangePayload {
-                previous_tenure_end: parent_block_id,
-                previous_tenure_blocks: u32::try_from(parent_tenure_blocks)
-                    .expect("FATAL: more than u32 blocks in a tenure"),
-                cause: TenureChangeCause::BlockFound,
-                pubkey_hash: miner_pkh,
-                signers: vec![],
-            },
-            ThresholdSignature::mock(),
-        );
+        let tenure_change_tx_payload = TransactionPayload::TenureChange(TenureChangePayload {
+            tenure_consensus_hash: self.burn_block.consensus_hash.clone(),
+            prev_tenure_consensus_hash: parent_tenure_consensus_hash,
+            burn_view_consensus_hash: self.burn_block.consensus_hash.clone(),
+            previous_tenure_end: parent_block_id,
+            previous_tenure_blocks: u32::try_from(parent_tenure_blocks)
+                .expect("FATAL: more than u32 blocks in a tenure"),
+            cause: TenureChangeCause::BlockFound,
+            pubkey_hash: miner_pkh,
+            signers: vec![],
+            signature: ThresholdSignature::mock(),
+        });
 
         let mut tx_auth = self.keychain.get_transaction_auth().unwrap();
         tx_auth.set_origin_nonce(nonce);
@@ -297,7 +298,7 @@ impl BlockMinerThread {
 
             return Some(ParentStacksBlockInfo {
                 parent_tenure: Some(ParentTenureInfo {
-                    parent_tenure_start: chain_tip.metadata.index_block_hash(),
+                    parent_tenure_consensus_hash: chain_tip.metadata.consensus_hash,
                     parent_tenure_blocks: 0,
                 }),
                 stacks_parent_header: chain_tip.metadata,
@@ -404,6 +405,7 @@ impl BlockMinerThread {
             let tenure_change_tx = self.generate_tenure_change_tx(
                 current_miner_nonce,
                 parent_block_id,
+                par_tenure_info.parent_tenure_consensus_hash,
                 par_tenure_info.parent_tenure_blocks,
                 self.keychain.get_nakamoto_pkh(),
             )?;
@@ -412,16 +414,15 @@ impl BlockMinerThread {
                 target_epoch_id,
                 vrf_proof.clone(),
             );
-            Some(NakamotoTenureStart {
-                coinbase_tx,
-                // TODO (refactor): the nakamoto block builder doesn't use this VRF proof,
-                //  it has to be included in the coinbase tx, which is an arg to the builder.
-                //  we should probably just remove this from the nakamoto block builder.
-                vrf_proof: vrf_proof.clone(),
-                tenure_change_tx,
-            })
+            NakamotoTenureInfo {
+                coinbase_tx: Some(coinbase_tx),
+                tenure_change_tx: Some(tenure_change_tx),
+            }
         } else {
-            None
+            NakamotoTenureInfo {
+                coinbase_tx: None,
+                tenure_change_tx: None,
+            }
         };
 
         parent_block_info.stacks_parent_header.microblock_tail = None;
@@ -584,9 +585,10 @@ impl ParentStacksBlockInfo {
             } else {
                 1
             };
+            let parent_tenure_consensus_hash = parent_tenure_header.consensus_hash.clone();
             Some(ParentTenureInfo {
-                parent_tenure_start: parent_tenure_id.clone(),
                 parent_tenure_blocks,
+                parent_tenure_consensus_hash,
             })
         } else {
             None
diff --git a/testnet/stacks-node/src/run_loop/nakamoto.rs b/testnet/stacks-node/src/run_loop/nakamoto.rs
index e429e79c91..83382f869e 100644
--- a/testnet/stacks-node/src/run_loop/nakamoto.rs
+++ b/testnet/stacks-node/src/run_loop/nakamoto.rs
@@ -25,9 +25,7 @@ use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::burn::BlockSnapshot;
 use stacks::chainstate::coordinator::comm::{CoordinatorChannels, CoordinatorReceivers};
 use stacks::chainstate::coordinator::{
-    static_get_canonical_affirmation_map, static_get_heaviest_affirmation_map,
-    static_get_stacks_tip_affirmation_map, ChainsCoordinator, ChainsCoordinatorConfig,
-    CoordinatorCommunication,
+    ChainsCoordinator, ChainsCoordinatorConfig, CoordinatorCommunication,
 };
 use stacks::chainstate::stacks::db::{ChainStateBootData, StacksChainState};
 use stacks::chainstate::stacks::miner::{signal_mining_blocked, signal_mining_ready, MinerStatus};
@@ -35,7 +33,6 @@ use stacks::core::StacksEpochId;
 use stacks::net::atlas::{AtlasConfig, AtlasDB, Attachment};
 use stacks_common::types::PublicKey;
 use stacks_common::util::hash::Hash160;
-use stacks_common::util::{get_epoch_time_secs, sleep_ms};
 use stx_genesis::GenesisData;
 
 use crate::burnchains::make_bitcoin_indexer;
@@ -56,12 +53,6 @@ use crate::{
 pub const STDERR: i32 = 2;
 pub type Globals = GenericGlobals<nakamoto_node::relayer::RelayerDirective>;
 
-#[cfg(test)]
-const UNCONDITIONAL_CHAIN_LIVENESS_CHECK: u64 = 30;
-
-#[cfg(not(test))]
-const UNCONDITIONAL_CHAIN_LIVENESS_CHECK: u64 = 300;
-
 /// Coordinating a node running in nakamoto mode. This runloop operates very similarly to the neon runloop.
 pub struct RunLoop {
     config: Config,
@@ -389,332 +380,6 @@ impl RunLoop {
         )
     }
 
-    /// Wake up and drive stacks block processing if there's been a PoX reorg.
-    /// Be careful not to saturate calls to announce new stacks blocks, because that will disable
-    /// mining (which would prevent a miner attempting to fix a hidden PoX anchor block from making
-    /// progress).
-    fn drive_pox_reorg_stacks_block_processing(
-        globals: &Globals,
-        config: &Config,
-        burnchain: &Burnchain,
-        sortdb: &SortitionDB,
-        last_stacks_pox_reorg_recover_time: &mut u128,
-    ) {
-        let delay = cmp::max(
-            config.node.chain_liveness_poll_time_secs,
-            cmp::max(
-                config.miner.first_attempt_time_ms,
-                config.miner.subsequent_attempt_time_ms,
-            ) / 1000,
-        );
-
-        if *last_stacks_pox_reorg_recover_time + (delay as u128) >= get_epoch_time_secs().into() {
-            // too soon
-            return;
-        }
-
-        // compare stacks and heaviest AMs
-        let burnchain_db = burnchain
-            .open_burnchain_db(false)
-            .expect("FATAL: failed to open burnchain DB");
-
-        let sn = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn())
-            .expect("FATAL: could not read sortition DB");
-
-        let indexer = make_bitcoin_indexer(config, Some(globals.should_keep_running.clone()));
-
-        let heaviest_affirmation_map = match static_get_heaviest_affirmation_map(
-            &burnchain,
-            &indexer,
-            &burnchain_db,
-            sortdb,
-            &sn.sortition_id,
-        ) {
-            Ok(am) => am,
-            Err(e) => {
-                warn!("Failed to find heaviest affirmation map: {:?}", &e);
-                return;
-            }
-        };
-
-        let highest_sn = SortitionDB::get_highest_known_burn_chain_tip(sortdb.conn())
-            .expect("FATAL: could not read sortition DB");
-
-        let canonical_burnchain_tip = burnchain_db
-            .get_canonical_chain_tip()
-            .expect("FATAL: could not read burnchain DB");
-
-        let sortition_tip_affirmation_map =
-            match SortitionDB::find_sortition_tip_affirmation_map(sortdb, &sn.sortition_id) {
-                Ok(am) => am,
-                Err(e) => {
-                    warn!("Failed to find sortition affirmation map: {:?}", &e);
-                    return;
-                }
-            };
-
-        let stacks_tip_affirmation_map = static_get_stacks_tip_affirmation_map(
-            &burnchain_db,
-            sortdb,
-            &sn.sortition_id,
-            &sn.canonical_stacks_tip_consensus_hash,
-            &sn.canonical_stacks_tip_hash,
-        )
-        .expect("FATAL: could not query stacks DB");
-
-        if stacks_tip_affirmation_map.len() < heaviest_affirmation_map.len()
-            || stacks_tip_affirmation_map
-                .find_divergence(&heaviest_affirmation_map)
-                .is_some()
-        {
-            // the sortition affirmation map might also be inconsistent, so we'll need to fix that
-            // (i.e. the underlying sortitions) before we can fix the stacks fork
-            if sortition_tip_affirmation_map.len() < heaviest_affirmation_map.len()
-                || sortition_tip_affirmation_map
-                    .find_divergence(&heaviest_affirmation_map)
-                    .is_some()
-            {
-                debug!("Drive burn block processing: possible PoX reorg (sortition tip: {}, heaviest: {})", &sortition_tip_affirmation_map, &heaviest_affirmation_map);
-                globals.coord().announce_new_burn_block();
-            } else if highest_sn.block_height == sn.block_height
-                && sn.block_height == canonical_burnchain_tip.block_height
-            {
-                // need to force an affirmation reorg because there will be no more burn block
-                // announcements.
-                debug!("Drive burn block processing: possible PoX reorg (sortition tip: {}, heaviest: {}, burn height {})", &sortition_tip_affirmation_map, &heaviest_affirmation_map, sn.block_height);
-                globals.coord().announce_new_burn_block();
-            }
-
-            debug!(
-                "Drive stacks block processing: possible PoX reorg (stacks tip: {}, heaviest: {})",
-                &stacks_tip_affirmation_map, &heaviest_affirmation_map
-            );
-            globals.coord().announce_new_stacks_block();
-        } else {
-            debug!(
-                "Drive stacks block processing: no need (stacks tip: {}, heaviest: {})",
-                &stacks_tip_affirmation_map, &heaviest_affirmation_map
-            );
-
-            // announce a new stacks block to force the chains coordinator
-            //  to wake up anyways. this isn't free, so we have to make sure
-            //  the chain-liveness thread doesn't wake up too often
-            globals.coord().announce_new_stacks_block();
-        }
-
-        *last_stacks_pox_reorg_recover_time = get_epoch_time_secs().into();
-    }
-
-    /// Wake up and drive sortition processing if there's been a PoX reorg.
-    /// Be careful not to saturate calls to announce new burn blocks, because that will disable
-    /// mining (which would prevent a miner attempting to fix a hidden PoX anchor block from making
-    /// progress).
-    ///
-    /// only call if no in ibd
-    fn drive_pox_reorg_burn_block_processing(
-        globals: &Globals,
-        config: &Config,
-        burnchain: &Burnchain,
-        sortdb: &SortitionDB,
-        chain_state_db: &StacksChainState,
-        last_burn_pox_reorg_recover_time: &mut u128,
-        last_announce_time: &mut u128,
-    ) {
-        let delay = cmp::max(
-            config.node.chain_liveness_poll_time_secs,
-            cmp::max(
-                config.miner.first_attempt_time_ms,
-                config.miner.subsequent_attempt_time_ms,
-            ) / 1000,
-        );
-
-        if *last_burn_pox_reorg_recover_time + (delay as u128) >= get_epoch_time_secs().into() {
-            // too soon
-            return;
-        }
-
-        // compare sortition and heaviest AMs
-        let burnchain_db = burnchain
-            .open_burnchain_db(false)
-            .expect("FATAL: failed to open burnchain DB");
-
-        let highest_sn = SortitionDB::get_highest_known_burn_chain_tip(sortdb.conn())
-            .expect("FATAL: could not read sortition DB");
-
-        let canonical_burnchain_tip = burnchain_db
-            .get_canonical_chain_tip()
-            .expect("FATAL: could not read burnchain DB");
-
-        if canonical_burnchain_tip.block_height > highest_sn.block_height {
-            // still processing sortitions
-            test_debug!(
-                "Drive burn block processing: still processing sortitions ({} > {})",
-                canonical_burnchain_tip.block_height,
-                highest_sn.block_height
-            );
-            return;
-        }
-
-        // NOTE: this could be lower than the highest_sn
-        let sn = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn())
-            .expect("FATAL: could not read sortition DB");
-
-        let sortition_tip_affirmation_map =
-            match SortitionDB::find_sortition_tip_affirmation_map(sortdb, &sn.sortition_id) {
-                Ok(am) => am,
-                Err(e) => {
-                    warn!("Failed to find sortition affirmation map: {:?}", &e);
-                    return;
-                }
-            };
-
-        let indexer = make_bitcoin_indexer(config, Some(globals.should_keep_running.clone()));
-
-        let heaviest_affirmation_map = match static_get_heaviest_affirmation_map(
-            &burnchain,
-            &indexer,
-            &burnchain_db,
-            sortdb,
-            &sn.sortition_id,
-        ) {
-            Ok(am) => am,
-            Err(e) => {
-                warn!("Failed to find heaviest affirmation map: {:?}", &e);
-                return;
-            }
-        };
-
-        let canonical_affirmation_map = match static_get_canonical_affirmation_map(
-            &burnchain,
-            &indexer,
-            &burnchain_db,
-            sortdb,
-            &chain_state_db,
-            &sn.sortition_id,
-        ) {
-            Ok(am) => am,
-            Err(e) => {
-                warn!("Failed to find canonical affirmation map: {:?}", &e);
-                return;
-            }
-        };
-
-        if sortition_tip_affirmation_map.len() < heaviest_affirmation_map.len()
-            || sortition_tip_affirmation_map
-                .find_divergence(&heaviest_affirmation_map)
-                .is_some()
-            || sn.block_height < highest_sn.block_height
-        {
-            debug!("Drive burn block processing: possible PoX reorg (sortition tip: {}, heaviest: {}, {} <? {})", &sortition_tip_affirmation_map, &heaviest_affirmation_map, sn.block_height, highest_sn.block_height);
-            globals.coord().announce_new_burn_block();
-            globals.coord().announce_new_stacks_block();
-            *last_announce_time = get_epoch_time_secs().into();
-        } else if sortition_tip_affirmation_map.len() >= heaviest_affirmation_map.len()
-            && sortition_tip_affirmation_map.len() <= canonical_affirmation_map.len()
-        {
-            if let Some(divergence_rc) =
-                canonical_affirmation_map.find_divergence(&sortition_tip_affirmation_map)
-            {
-                if divergence_rc + 1 >= (heaviest_affirmation_map.len() as u64) {
-                    // we have unaffirmed PoX anchor blocks that are not yet processed in the sortition history
-                    debug!("Drive burnchain processing: possible PoX reorg from unprocessed anchor block(s) (sortition tip: {}, heaviest: {}, canonical: {})", &sortition_tip_affirmation_map, &heaviest_affirmation_map, &canonical_affirmation_map);
-                    globals.coord().announce_new_burn_block();
-                    globals.coord().announce_new_stacks_block();
-                    *last_announce_time = get_epoch_time_secs().into();
-                }
-            }
-        } else {
-            debug!(
-                "Drive burn block processing: no need (sortition tip: {}, heaviest: {}, {} </ {})",
-                &sortition_tip_affirmation_map,
-                &heaviest_affirmation_map,
-                sn.block_height,
-                highest_sn.block_height
-            );
-        }
-
-        *last_burn_pox_reorg_recover_time = get_epoch_time_secs().into();
-
-        // unconditionally bump every 5 minutes, just in case.
-        // this can get the node un-stuck if we're short on sortition processing but are unable to
-        // sync with the remote node because it keeps NACK'ing us, leading to a runloop stall.
-        if *last_announce_time + (UNCONDITIONAL_CHAIN_LIVENESS_CHECK as u128)
-            < get_epoch_time_secs().into()
-        {
-            debug!("Drive burnchain processing: unconditional bump");
-            globals.coord().announce_new_burn_block();
-            globals.coord().announce_new_stacks_block();
-            *last_announce_time = get_epoch_time_secs().into();
-        }
-    }
-
-    /// In a separate thread, periodically drive coordinator liveness by checking to see if there's
-    /// a pending reorg and if so, waking up the coordinator to go and process new blocks
-    fn drive_chain_liveness(
-        globals: Globals,
-        config: Config,
-        burnchain: Burnchain,
-        sortdb: SortitionDB,
-        chain_state_db: StacksChainState,
-    ) {
-        let mut last_burn_pox_reorg_recover_time = 0;
-        let mut last_stacks_pox_reorg_recover_time = 0;
-        let mut last_burn_announce_time = 0;
-
-        debug!("Chain-liveness thread start!");
-
-        while globals.keep_running() {
-            debug!("Chain-liveness checkup");
-            Self::drive_pox_reorg_burn_block_processing(
-                &globals,
-                &config,
-                &burnchain,
-                &sortdb,
-                &chain_state_db,
-                &mut last_burn_pox_reorg_recover_time,
-                &mut last_burn_announce_time,
-            );
-            Self::drive_pox_reorg_stacks_block_processing(
-                &globals,
-                &config,
-                &burnchain,
-                &sortdb,
-                &mut last_stacks_pox_reorg_recover_time,
-            );
-
-            sleep_ms(3000);
-        }
-
-        debug!("Chain-liveness thread exit!");
-    }
-
-    /// Spawn a thread to drive chain liveness
-    fn spawn_chain_liveness_thread(&self, globals: Globals) -> JoinHandle<()> {
-        let config = self.config.clone();
-        let burnchain = self.get_burnchain();
-        let sortdb = burnchain
-            .open_sortition_db(true)
-            .expect("FATAL: could not open sortition DB");
-
-        let (chain_state_db, _) = StacksChainState::open(
-            config.is_mainnet(),
-            config.burnchain.chain_id,
-            &config.get_chainstate_path_str(),
-            Some(config.node.get_marf_opts()),
-        )
-        .unwrap();
-
-        let liveness_thread_handle = thread::Builder::new()
-            .name(format!("chain-liveness-{}", config.node.rpc_bind))
-            .stack_size(BLOCK_PROCESSOR_STACK_SIZE)
-            .spawn(move || {
-                Self::drive_chain_liveness(globals, config, burnchain, sortdb, chain_state_db)
-            })
-            .expect("FATAL: failed to spawn chain liveness thread");
-
-        liveness_thread_handle
-    }
-
     /// Starts the node runloop.
     ///
     /// This function will block by looping infinitely.
@@ -789,7 +454,6 @@ impl RunLoop {
         // Boot up the p2p network and relayer, and figure out how many sortitions we have so far
         // (it could be non-zero if the node is resuming from chainstate)
         let mut node = StacksNode::spawn(self, globals.clone(), relay_recv);
-        let liveness_thread = self.spawn_chain_liveness_thread(globals.clone());
 
         // Wait for all pending sortitions to process
         let burnchain_db = burnchain_config
@@ -839,7 +503,6 @@ impl RunLoop {
                 globals.coord().stop_chains_coordinator();
                 coordinator_thread_handle.join().unwrap();
                 node.join();
-                liveness_thread.join().unwrap();
 
                 info!("Exiting stacks-node");
                 break;

From ae72f7cf5aa8f1b59c1e8c9785ef92d00f2c14a3 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 12 Dec 2023 11:10:50 -0500
Subject: [PATCH 0191/1166] fix: burn_view_consensus_hash

---
 testnet/stacks-node/src/mockamoto.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index 6c5e7ca878..760ff19f05 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -783,7 +783,7 @@ impl MockamotoNode {
         let tenure_change_tx_payload = TransactionPayload::TenureChange(TenureChangePayload {
             tenure_consensus_hash: sortition_tip.consensus_hash.clone(),
             prev_tenure_consensus_hash: chain_tip_ch.clone(),
-            sortition_consensus_hash: sortition_tip.consensus_hash,
+            burn_view_consensus_hash: sortition_tip.consensus_hash,
             previous_tenure_end: parent_block_id,
             previous_tenure_blocks: 1,
             cause: TenureChangeCause::BlockFound,

From fc147df85b2a738d3418f86a9e303fb681d46e56 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Tue, 12 Dec 2023 10:21:33 -0600
Subject: [PATCH 0192/1166] remove unconfirmed tx handling in nakamoto
 RelayerThread

---
 .../stacks-node/src/nakamoto_node/relayer.rs  | 21 ++-----------------
 1 file changed, 2 insertions(+), 19 deletions(-)

diff --git a/testnet/stacks-node/src/nakamoto_node/relayer.rs b/testnet/stacks-node/src/nakamoto_node/relayer.rs
index 68ca5d723a..8c83bb35b9 100644
--- a/testnet/stacks-node/src/nakamoto_node/relayer.rs
+++ b/testnet/stacks-node/src/nakamoto_node/relayer.rs
@@ -1,4 +1,3 @@
-use core::fmt;
 // Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
 // Copyright (C) 2020-2023 Stacks Open Internet Foundation
 //
@@ -14,6 +13,7 @@ use core::fmt;
 //
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
+use core::fmt;
 use std::collections::HashMap;
 use std::sync::mpsc::{Receiver, RecvTimeoutError};
 use std::thread::JoinHandle;
@@ -261,7 +261,7 @@ impl RelayerThread {
             )
             .expect("BUG: failure processing network results");
 
-        if net_receipts.num_new_blocks > 0 || net_receipts.num_new_confirmed_microblocks > 0 {
+        if net_receipts.num_new_blocks > 0 {
             // if we received any new block data that could invalidate our view of the chain tip,
             // then stop mining until we process it
             debug!("Relayer: block mining to process newly-arrived blocks or microblocks");
@@ -274,29 +274,12 @@ impl RelayerThread {
                 .process_new_mempool_txs(net_receipts.mempool_txs_added);
         }
 
-        let num_unconfirmed_microblock_tx_receipts =
-            net_receipts.processed_unconfirmed_state.receipts.len();
-        if num_unconfirmed_microblock_tx_receipts > 0 {
-            if let Some(unconfirmed_state) = self.chainstate.unconfirmed_state.as_ref() {
-                let canonical_tip = unconfirmed_state.confirmed_chain_tip.clone();
-                self.event_dispatcher.process_new_microblocks(
-                    canonical_tip,
-                    net_receipts.processed_unconfirmed_state,
-                );
-            } else {
-                warn!("Relayer: oops, unconfirmed state is uninitialized but there are microblock events");
-            }
-        }
-
         // Dispatch retrieved attachments, if any.
         if net_result.has_attachments() {
             self.event_dispatcher
                 .process_new_attachments(&net_result.attachments);
         }
 
-        // synchronize unconfirmed tx index to p2p thread
-        self.globals.send_unconfirmed_txs(&self.chainstate);
-
         // resume mining if we blocked it, and if we've done the requisite download
         // passes
         self.last_network_download_passes = net_result.num_download_passes;

From 16bb6887f84a299b5bbbe4c469337169849ce6ed Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Tue, 12 Dec 2023 11:49:11 -0600
Subject: [PATCH 0193/1166] add epoch-3.0 burnchain configuration assertions

---
 testnet/stacks-node/src/config.rs             | 25 +++++++++++++++++++
 .../src/tests/nakamoto_integrations.rs        |  6 ++---
 2 files changed, 28 insertions(+), 3 deletions(-)

diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index 526c2a90da..8b1f7a8578 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -624,6 +624,31 @@ impl Config {
             );
             burnchain.pox_constants.sunset_end = sunset_end.into();
         }
+
+        // check if the Epoch 3.0 burnchain settings as configured are going to be valid.
+        let epochs = StacksEpoch::get_epochs(
+            self.burnchain.get_bitcoin_network().1,
+            self.burnchain.epochs.as_ref(),
+        );
+        let Some(epoch_30) = StacksEpoch::find_epoch_by_id(&epochs, StacksEpochId::Epoch30)
+            .map(|epoch_ix| epochs[epoch_ix].clone())
+        else {
+            // no Epoch 3.0, so just return
+            return;
+        };
+        if burnchain.pox_constants.prepare_length < 3 {
+            panic!(
+                "FATAL: Nakamoto rules require a prepare length >= 3. Prepare length set to {}",
+                burnchain.pox_constants.prepare_length
+            );
+        }
+        if burnchain.is_in_prepare_phase(epoch_30.start_height) {
+            panic!(
+                "FATAL: Epoch 3.0 must start *during* a reward phase, not a prepare phase. Epoch 3.0 start set to: {}. PoX Parameters: {:?}",
+                epoch_30.start_height,
+                &burnchain.pox_constants
+            );
+        }
     }
 
     /// Load up a Burnchain and apply config settings to it.
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 2b4fdfa540..0b1d79ffa3 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -105,13 +105,13 @@ lazy_static! {
         StacksEpoch {
             epoch_id: StacksEpochId::Epoch25,
             start_height: 6,
-            end_height: 220,
+            end_height: 221,
             block_limit: HELIUM_BLOCK_LIMIT_20.clone(),
             network_epoch: PEER_VERSION_EPOCH_2_5
         },
         StacksEpoch {
             epoch_id: StacksEpochId::Epoch30,
-            start_height: 220,
+            start_height: 221,
             end_height: STACKS_EPOCH_MAX,
             block_limit: HELIUM_BLOCK_LIMIT_20.clone(),
             network_epoch: PEER_VERSION_EPOCH_3_0
@@ -226,7 +226,7 @@ fn next_block_and_mine_commit(
                 return Ok(true);
             }
             if commits_sent >= commits_before + 1
-                && block_processed_time.elapsed() > Duration::from_secs(10)
+                && block_processed_time.elapsed() > Duration::from_secs(6)
             {
                 return Ok(true);
             }

From e406a97df89ad4ee1d7548b3ebb04c7f5041b421 Mon Sep 17 00:00:00 2001
From: wileyj <2847772+wileyj@users.noreply.github.com>
Date: Tue, 12 Dec 2023 10:09:34 -0800
Subject: [PATCH 0194/1166] use pull_request to trigger ci runs

---
 .github/workflows/ci.yml | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 2c86c6dcb1..aadda50df2 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -15,11 +15,12 @@ on:
       tag:
         description: "The tag to create (optional)"
         required: false
-  pull_request_target:
+  pull_request:
     types:
       - opened
       - reopened
       - synchronize
+      - ready_for_review
     paths-ignore:
       - "**.md"
       - "**.yml"
@@ -143,7 +144,7 @@ jobs:
             github.event.review.state == 'approved'
           ) ||
           github.event_name == 'workflow_dispatch' ||
-          github.event_name == 'pull_request_target' ||
+          github.event_name == 'pull_request' ||
           (
             contains('
               refs/heads/master

From ababc91e21a7dbbd9653a4a67a077c6226d33ac1 Mon Sep 17 00:00:00 2001
From: wileyj <2847772+wileyj@users.noreply.github.com>
Date: Tue, 12 Dec 2023 10:11:17 -0800
Subject: [PATCH 0195/1166] use pull_request to trigger ci runs

---
 .github/workflows/ci.yml | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 2c86c6dcb1..aadda50df2 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -15,11 +15,12 @@ on:
       tag:
         description: "The tag to create (optional)"
         required: false
-  pull_request_target:
+  pull_request:
     types:
       - opened
       - reopened
       - synchronize
+      - ready_for_review
     paths-ignore:
       - "**.md"
       - "**.yml"
@@ -143,7 +144,7 @@ jobs:
             github.event.review.state == 'approved'
           ) ||
           github.event_name == 'workflow_dispatch' ||
-          github.event_name == 'pull_request_target' ||
+          github.event_name == 'pull_request' ||
           (
             contains('
               refs/heads/master

From 09e8c2c9e1ad16ea38f3b4edf536b993b4cbd93e Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 12 Dec 2023 15:16:02 -0500
Subject: [PATCH 0196/1166] fix: fix failing nakamoto coordinator tests

---
 .../chainstate/nakamoto/coordinator/tests.rs  | 34 +++++++++++++------
 .../src/chainstate/nakamoto/tests/mod.rs      | 13 -------
 2 files changed, 23 insertions(+), 24 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index 990b0128b3..578fd5d6a9 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -302,7 +302,7 @@ fn test_simple_nakamoto_coordinator_1_tenure_10_blocks() {
     let mut test_signers = TestSigners::default();
     let mut peer = boot_nakamoto(
         function_name!(),
-        vec![(addr.into(), 10_000)],
+        vec![(addr.into(), 100_000_000)],
         test_signers.aggregate_public_key,
     );
 
@@ -412,9 +412,7 @@ fn test_simple_nakamoto_coordinator_1_tenure_10_blocks() {
 /// * check_tenure_continuity
 #[test]
 fn test_nakamoto_chainstate_getters() {
-    let mut test_signers = TestSigners::default();
-    let mut peer = boot_nakamoto(function_name!(), vec![], test_signers.aggregate_public_key);
-    let private_key = peer.config.private_key.clone();
+    let private_key = StacksPrivateKey::from_seed(&[2]);
     let addr = StacksAddress::from_public_keys(
         C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
         &AddressHashMode::SerializeP2PKH,
@@ -422,6 +420,12 @@ fn test_nakamoto_chainstate_getters() {
         &vec![StacksPublicKey::from_private(&private_key)],
     )
     .unwrap();
+    let mut test_signers = TestSigners::default();
+    let mut peer = boot_nakamoto(
+        function_name!(),
+        vec![(addr.into(), 100_000_000)],
+        test_signers.aggregate_public_key,
+    );
 
     let sort_tip = {
         let sort_db = peer.sortdb.as_ref().unwrap();
@@ -908,7 +912,7 @@ fn test_simple_nakamoto_coordinator_10_tenures_10_blocks() {
     let mut test_signers = TestSigners::default();
     let mut peer = boot_nakamoto(
         function_name!(),
-        vec![(addr.into(), 11_000)],
+        vec![(addr.into(), 100_000_000)],
         test_signers.aggregate_public_key,
     );
 
@@ -1225,9 +1229,7 @@ fn test_simple_nakamoto_coordinator_10_tenures_10_blocks() {
 /// 20 blocks in the first tenure (10 before the second sortiton, and 10 after)
 #[test]
 fn test_simple_nakamoto_coordinator_2_tenures_3_sortitions() {
-    let mut test_signers = TestSigners::default();
-    let mut peer = boot_nakamoto(function_name!(), vec![], test_signers.aggregate_public_key);
-    let private_key = peer.config.private_key.clone();
+    let private_key = StacksPrivateKey::from_seed(&[2]);
     let addr = StacksAddress::from_public_keys(
         C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
         &AddressHashMode::SerializeP2PKH,
@@ -1235,6 +1237,12 @@ fn test_simple_nakamoto_coordinator_2_tenures_3_sortitions() {
         &vec![StacksPublicKey::from_private(&private_key)],
     )
     .unwrap();
+    let mut test_signers = TestSigners::default();
+    let mut peer = boot_nakamoto(
+        function_name!(),
+        vec![(addr.into(), 100_000_000)],
+        test_signers.aggregate_public_key,
+    );
 
     let mut rc_burn_ops = vec![];
     let mut all_blocks = vec![];
@@ -1549,9 +1557,7 @@ fn test_simple_nakamoto_coordinator_2_tenures_3_sortitions() {
 /// Mine a 10 Nakamoto tenures with 10 Nakamoto blocks, but do a tenure-extend in each block
 #[test]
 fn test_simple_nakamoto_coordinator_10_tenures_and_extensions_10_blocks() {
-    let mut test_signers = TestSigners::default();
-    let mut peer = boot_nakamoto(function_name!(), vec![], test_signers.aggregate_public_key);
-    let private_key = peer.config.private_key.clone();
+    let private_key = StacksPrivateKey::from_seed(&[2]);
     let addr = StacksAddress::from_public_keys(
         C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
         &AddressHashMode::SerializeP2PKH,
@@ -1559,6 +1565,12 @@ fn test_simple_nakamoto_coordinator_10_tenures_and_extensions_10_blocks() {
         &vec![StacksPublicKey::from_private(&private_key)],
     )
     .unwrap();
+    let mut test_signers = TestSigners::default();
+    let mut peer = boot_nakamoto(
+        function_name!(),
+        vec![(addr.into(), 100_000_000)],
+        test_signers.aggregate_public_key,
+    );
 
     let mut all_blocks = vec![];
     let mut all_burn_ops = vec![];
diff --git a/stackslib/src/chainstate/nakamoto/tests/mod.rs b/stackslib/src/chainstate/nakamoto/tests/mod.rs
index a5eb5c7c2f..e2d702830a 100644
--- a/stackslib/src/chainstate/nakamoto/tests/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/mod.rs
@@ -781,19 +781,6 @@ pub fn test_load_store_update_nakamoto_blocks() {
         .unwrap()
         .is_some());
 
-        // this will fail without a tenure (e.g. due to foreign key constraints)
-        NakamotoChainState::insert_stacks_block_header(
-            &tx,
-            &nakamoto_header_info,
-            &nakamoto_header,
-            Some(&nakamoto_proof),
-            &nakamoto_execution_cost,
-            &nakamoto_execution_cost,
-            true,
-            300,
-        )
-        .unwrap_err();
-
         // no tenure yet, so zero blocks
         assert_eq!(
             NakamotoChainState::get_nakamoto_tenure_length(

From c5a19132d80812f122ad562084f61c2dc76bec28 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 12 Dec 2023 15:16:32 -0500
Subject: [PATCH 0197/1166] fix: fix failing mockamoto integration tests

---
 testnet/stacks-node/src/mockamoto.rs       |  5 ++++-
 testnet/stacks-node/src/mockamoto/tests.rs | 15 +++++++++++----
 2 files changed, 15 insertions(+), 5 deletions(-)

diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index 760ff19f05..8f17aae677 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -776,6 +776,9 @@ impl MockamotoNode {
         coinbase_tx_signer.sign_origin(&self.miner_key).unwrap();
         let coinbase_tx = coinbase_tx_signer.get_tx().unwrap();
 
+        let miner_pk = Secp256k1PublicKey::from_private(&self.miner_key);
+        let miner_pk_hash = Hash160::from_node_public_key(&miner_pk);
+
         // Add a tenure change transaction to the block:
         //  as of now every mockamoto block is a tenure-change.
         // If mockamoto mode changes to support non-tenure-changing blocks, this will have
@@ -787,7 +790,7 @@ impl MockamotoNode {
             previous_tenure_end: parent_block_id,
             previous_tenure_blocks: 1,
             cause: TenureChangeCause::BlockFound,
-            pubkey_hash: Hash160([0; 20]),
+            pubkey_hash: miner_pk_hash,
             signature: ThresholdSignature::mock(),
             signers: vec![],
         });
diff --git a/testnet/stacks-node/src/mockamoto/tests.rs b/testnet/stacks-node/src/mockamoto/tests.rs
index 99c7d34cc8..b7914dcba8 100644
--- a/testnet/stacks-node/src/mockamoto/tests.rs
+++ b/testnet/stacks-node/src/mockamoto/tests.rs
@@ -22,7 +22,7 @@ fn observe_100_blocks() {
 
     let submitter_sk = StacksPrivateKey::from_seed(&[1]);
     let submitter_addr = to_addr(&submitter_sk);
-    conf.add_initial_balance(submitter_addr.to_string(), 1_000);
+    conf.add_initial_balance(submitter_addr.to_string(), 1_000_000);
     let recipient_addr = StacksAddress::burn_address(false).into();
 
     test_observer::spawn();
@@ -54,9 +54,11 @@ fn observe_100_blocks() {
         .expect("FATAL: failed to start mockamoto main thread");
 
     // make a transfer tx to test that the mockamoto miner picks up txs from the mempool
-    let transfer_tx = make_stacks_transfer(&submitter_sk, 0, 10, &recipient_addr, 100);
+    let transfer_tx = make_stacks_transfer(&submitter_sk, 0, 300, &recipient_addr, 100);
     let transfer_tx_hex = format!("0x{}", to_hex(&transfer_tx));
 
+    let mut sent_tx = false;
+
     // complete within 2 minutes or abort
     let completed = loop {
         if Instant::now().duration_since(start) > Duration::from_secs(120) {
@@ -71,7 +73,7 @@ fn observe_100_blocks() {
         let stacks_block_height = latest_block.get("block_height").unwrap().as_u64().unwrap();
         info!("Block height observed: {stacks_block_height}");
 
-        if stacks_block_height == 1 {
+        if stacks_block_height >= 1 && !sent_tx {
             let tip = NakamotoChainState::get_canonical_block_header(chainstate.db(), &sortdb)
                 .unwrap()
                 .unwrap();
@@ -87,6 +89,8 @@ fn observe_100_blocks() {
                     &StacksEpochId::Epoch30,
                 )
                 .unwrap();
+
+            sent_tx = true;
         }
 
         if stacks_block_height >= 100 {
@@ -156,6 +160,8 @@ fn mempool_rpc_submit() {
     let transfer_tx = make_stacks_transfer(&submitter_sk, 0, tx_fee, &recipient_addr, 100);
     let transfer_tx_hex = format!("0x{}", to_hex(&transfer_tx));
 
+    let mut sent_tx = false;
+
     // complete within 2 minutes or abort
     let completed = loop {
         if Instant::now().duration_since(start) > Duration::from_secs(120) {
@@ -170,9 +176,10 @@ fn mempool_rpc_submit() {
         let stacks_block_height = latest_block.get("block_height").unwrap().as_u64().unwrap();
         info!("Block height observed: {stacks_block_height}");
 
-        if stacks_block_height == 1 {
+        if stacks_block_height >= 1 && !sent_tx {
             // Enforce admission checks by utilizing the RPC endpoint
             submit_tx(&http_origin, &transfer_tx);
+            sent_tx = true;
         }
 
         if stacks_block_height >= 100 {

From bfb2d825844b32772426f7b4f885a530fd64270e Mon Sep 17 00:00:00 2001
From: friedger <mail@friedger.de>
Date: Wed, 13 Dec 2023 10:36:00 +0100
Subject: [PATCH 0198/1166] feat: remove pox-reject in pox-4

---
 Cargo.lock                                    |  4 +
 stackslib/src/chainstate/stacks/boot/docs.rs  |  2 +-
 stackslib/src/chainstate/stacks/boot/mod.rs   | 16 ----
 .../src/chainstate/stacks/boot/pox-4.clar     | 86 +++----------------
 4 files changed, 15 insertions(+), 93 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index a90cb48536..b9f59752b4 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2354,6 +2354,8 @@ checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39"
 [[package]]
 name = "p256k1"
 version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5afcf536d20c074ef45371ee9a654dcfc46fb2dde18ecc54ec30c936eb850fa2"
 dependencies = [
  "bindgen",
  "bitvec",
@@ -4711,6 +4713,8 @@ dependencies = [
 [[package]]
 name = "wsts"
 version = "5.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2c250118354755b4abb091a83cb8d659b511c0ae211ccdb3b1254e3db199cb86"
 dependencies = [
  "aes-gcm 0.10.2",
  "bs58 0.5.0",
diff --git a/stackslib/src/chainstate/stacks/boot/docs.rs b/stackslib/src/chainstate/stacks/boot/docs.rs
index 802146ffeb..3bf3f3cae4 100644
--- a/stackslib/src/chainstate/stacks/boot/docs.rs
+++ b/stackslib/src/chainstate/stacks/boot/docs.rs
@@ -43,7 +43,7 @@ This ensures that each entry in the reward set returned to the stacks-node is gr
   but does not require it be all locked up within a single transaction"),
         ("reject-pox", "Reject Stacking for this reward cycle.
 `tx-sender` votes all its uSTX for rejection.
-Note that unlike Stacking, rejecting PoX does not lock the tx-sender's tokens: PoX rejection acts like a coin vote."),
+Note that unlike Stacking, rejecting PoX does not lock the tx-sender's tokens: PoX rejection acts like a coin vote. Removed in pox-4."),
         ("can-stack-stx", "Evaluate if a participant can stack an amount of STX for a given period."),
         ("get-stacking-minimum", "Returns the absolute minimum amount that could be validly Stacked (the threshold to Stack in
 a given reward cycle may be higher than this"),
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 887dd20900..2280555e7a 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -985,14 +985,6 @@ impl StacksChainState {
         block_id: &StacksBlockId,
         reward_cycle: u64,
     ) -> Result<Vec<RawRewardSetEntry>, Error> {
-        if !self.is_pox_active(sortdb, block_id, u128::from(reward_cycle), POX_4_NAME)? {
-            debug!(
-                "PoX was voted disabled in block {} (reward cycle {})",
-                block_id, reward_cycle
-            );
-            return Ok(vec![]);
-        }
-
         // how many in this cycle?
         let num_addrs = self
             .eval_boot_code_read_only(
@@ -1135,14 +1127,6 @@ impl StacksChainState {
         block_id: &StacksBlockId,
         reward_cycle: u64,
     ) -> Result<Option<Point>, Error> {
-        if !self.is_pox_active(sortdb, block_id, u128::from(reward_cycle), POX_4_NAME)? {
-            debug!(
-                "PoX was voted disabled in block {} (reward cycle {})",
-                block_id, reward_cycle
-            );
-            return Ok(None);
-        }
-
         let aggregate_public_key = self
             .eval_boot_code_read_only(
                 sortdb,
diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index 6766e4022e..d8847244b3 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -12,7 +12,7 @@
 (define-constant ERR_STACKING_THRESHOLD_NOT_MET 11)
 (define-constant ERR_STACKING_POX_ADDRESS_IN_USE 12)
 (define-constant ERR_STACKING_INVALID_POX_ADDRESS 13)
-(define-constant ERR_STACKING_ALREADY_REJECTED 17)
+
 (define-constant ERR_STACKING_INVALID_AMOUNT 18)
 (define-constant ERR_NOT_ALLOWED 19)
 (define-constant ERR_STACKING_ALREADY_DELEGATED 20)
@@ -28,9 +28,6 @@
 (define-constant ERR_STACKING_IS_DELEGATED 30)
 (define-constant ERR_STACKING_NOT_DELEGATED 31)
 
-;; PoX disabling threshold (a percent)
-(define-constant POX_REJECTION_FRACTION u25)
-
 ;; Valid values for burnchain address versions.
 ;; These first four correspond to address hash modes in Stacks 2.1,
 ;; and are defined in pox-mainnet.clar and pox-testnet.clar (so they
@@ -57,7 +54,6 @@
 ;; used in e.g. test harnesses.
 (define-data-var pox-prepare-cycle-length uint PREPARE_CYCLE_LENGTH)
 (define-data-var pox-reward-cycle-length uint REWARD_CYCLE_LENGTH)
-(define-data-var pox-rejection-fraction uint POX_REJECTION_FRACTION)
 (define-data-var first-burnchain-block-height uint u0)
 (define-data-var configured bool false)
 (define-data-var first-2-1-reward-cycle uint u0)
@@ -73,7 +69,6 @@
         (var-set first-burnchain-block-height first-burn-height)
         (var-set pox-prepare-cycle-length prepare-cycle-length)
         (var-set pox-reward-cycle-length reward-cycle-length)
-        (var-set pox-rejection-fraction rejection-fraction)
         (var-set first-2-1-reward-cycle begin-2-1-reward-cycle)
         (var-set configured true)
         (ok true))
@@ -190,37 +185,19 @@
     { stacked-amount: uint }
 )
 
-;; Amount of uSTX that reject PoX, by reward cycle
-(define-map stacking-rejection
-    { reward-cycle: uint }
-    { amount: uint }
-)
-
-;; Who rejected in which reward cycle
-(define-map stacking-rejectors
-    { stacker: principal, reward-cycle: uint }
-    { amount: uint }
-)
-
 ;; The stackers' aggregate public key
 ;;   for the given reward cycle
 (define-map aggregate-public-keys uint (buff 33))
 
 ;; Getter for stacking-rejectors
+;; always return none for backwards compatibility
 (define-read-only (get-pox-rejection (stacker principal) (reward-cycle uint))
-    (map-get? stacking-rejectors { stacker: stacker, reward-cycle: reward-cycle }))
+    none)
 
-;; Has PoX been rejected in the given reward cycle?
+;; Has PoX not been rejected in the given reward cycle?
+;; always return true for backwards compatibility
 (define-read-only (is-pox-active (reward-cycle uint))
-    (let (
-        (reject-votes
-            (default-to
-                u0
-                (get amount (map-get? stacking-rejection { reward-cycle: reward-cycle }))))
-    )
-    ;; (100 * reject-votes) / stx-liquid-supply < pox-rejection-fraction
-    (< (* u100 reject-votes)
-       (* (var-get pox-rejection-fraction) stx-liquid-supply)))
+    true
 )
 
 ;; What's the reward cycle number of the burnchain block height?
@@ -288,12 +265,6 @@
         u0
         (get len (map-get? reward-cycle-pox-address-list-len { reward-cycle: reward-cycle }))))
 
-;; How many rejection votes have we been accumulating for the next block
-(define-read-only (next-cycle-rejection-votes)
-    (default-to
-        u0
-        (get amount (map-get? stacking-rejection { reward-cycle: (+ u1 (current-pox-reward-cycle)) }))))
-
 ;; Add a single PoX address to a single reward cycle.
 ;; Used to build up a set of per-reward-cycle PoX addresses.
 ;; No checking will be done -- don't call if this PoX address is already registered in this reward cycle!
@@ -537,10 +508,6 @@
     (asserts! (> amount-ustx u0)
               (err ERR_STACKING_INVALID_AMOUNT))
 
-    ;; sender principal must not have rejected in this upcoming reward cycle
-    (asserts! (is-none (get-pox-rejection tx-sender first-reward-cycle))
-              (err ERR_STACKING_ALREADY_REJECTED))
-
     ;; lock period must be in acceptable range.
     (asserts! (check-pox-lock-period num-cycles)
               (err ERR_STACKING_INVALID_LOCK_PERIOD))
@@ -892,38 +859,6 @@
             lock-amount: amount-ustx,
             unlock-burn-height: unlock-burn-height })))
 
-;; Reject Stacking for this reward cycle.
-;; tx-sender votes all its uSTX for rejection.
-;; Note that unlike PoX, rejecting PoX does not lock the tx-sender's
-;; tokens.  PoX rejection acts like a coin vote.
-(define-public (reject-pox)
-    (let (
-        (balance (stx-get-balance tx-sender))
-        (vote-reward-cycle (+ u1 (current-pox-reward-cycle)))
-    )
-
-    ;; tx-sender principal must not have rejected in this upcoming reward cycle
-    (asserts! (is-none (get-pox-rejection tx-sender vote-reward-cycle))
-        (err ERR_STACKING_ALREADY_REJECTED))
-
-    ;; tx-sender can't be a stacker
-    (asserts! (is-none (get-stacker-info tx-sender))
-        (err ERR_STACKING_ALREADY_STACKED))
-
-    ;; vote for rejection
-    (map-set stacking-rejection
-        { reward-cycle: vote-reward-cycle }
-        { amount: (+ (next-cycle-rejection-votes) balance) }
-    )
-
-    ;; mark voted
-    (map-set stacking-rejectors
-        { stacker: tx-sender, reward-cycle: vote-reward-cycle }
-        { amount: balance }
-    )
-
-    (ok true))
-)
 
 ;; Used for PoX parameters discovery
 (define-read-only (get-pox-info)
@@ -933,8 +868,6 @@
         prepare-cycle-length: (var-get pox-prepare-cycle-length),
         first-burnchain-block-height: (var-get first-burnchain-block-height),
         reward-cycle-length: (var-get pox-reward-cycle-length),
-        rejection-fraction: (var-get pox-rejection-fraction),
-        current-rejection-votes: (next-cycle-rejection-votes),
         total-liquid-supply-ustx: stx-liquid-supply,
     })
 )
@@ -1315,11 +1248,12 @@
 
 ;; How many uSTX have voted to reject PoX in a given reward cycle?
 ;; *New in Stacks 2.1*
+;; always return 0 for backwards compatibility
 (define-read-only (get-total-pox-rejection (reward-cycle uint))
-    (match (map-get? stacking-rejection { reward-cycle: reward-cycle })
-        rejected
-            (get amount rejected)
         u0
+        u0
+    )
+    u0
     )
 )
 

From 622bcebed733e467d373f4450f93b9d2e266a06c Mon Sep 17 00:00:00 2001
From: friedger <mail@friedger.de>
Date: Wed, 13 Dec 2023 10:44:21 +0100
Subject: [PATCH 0199/1166] feat: remove rejection fraction

---
 .../src/chainstate/stacks/boot/pox-4.clar     | 29 ++-----------------
 stackslib/src/clarity_vm/clarity.rs           |  1 -
 2 files changed, 3 insertions(+), 27 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index d8847244b3..2e5f744411 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -56,20 +56,19 @@
 (define-data-var pox-reward-cycle-length uint REWARD_CYCLE_LENGTH)
 (define-data-var first-burnchain-block-height uint u0)
 (define-data-var configured bool false)
-(define-data-var first-2-1-reward-cycle uint u0)
+(define-data-var first-pox-4-reward-cycle uint u0)
 
 ;; This function can only be called once, when it boots up
 (define-public (set-burnchain-parameters (first-burn-height uint)
                                          (prepare-cycle-length uint)
                                          (reward-cycle-length uint)
-                                         (rejection-fraction uint)
-                                         (begin-2-1-reward-cycle uint))
+                                         (begin-pox-4-reward-cycle uint))
     (begin
         (asserts! (not (var-get configured)) (err ERR_NOT_ALLOWED))
         (var-set first-burnchain-block-height first-burn-height)
         (var-set pox-prepare-cycle-length prepare-cycle-length)
         (var-set pox-reward-cycle-length reward-cycle-length)
-        (var-set first-2-1-reward-cycle begin-2-1-reward-cycle)
+        (var-set first-pox-4-reward-cycle begin-pox-4-reward-cycle)
         (var-set configured true)
         (ok true))
 )
@@ -189,17 +188,6 @@
 ;;   for the given reward cycle
 (define-map aggregate-public-keys uint (buff 33))
 
-;; Getter for stacking-rejectors
-;; always return none for backwards compatibility
-(define-read-only (get-pox-rejection (stacker principal) (reward-cycle uint))
-    none)
-
-;; Has PoX not been rejected in the given reward cycle?
-;; always return true for backwards compatibility
-(define-read-only (is-pox-active (reward-cycle uint))
-    true
-)
-
 ;; What's the reward cycle number of the burnchain block height?
 ;; Will runtime-abort if height is less than the first burnchain block (this is intentional)
 (define-read-only (burn-height-to-reward-cycle (height uint))
@@ -1246,17 +1234,6 @@
     (map-get? partial-stacked-by-cycle { pox-addr: pox-addr, reward-cycle: reward-cycle, sender: sender })
 )
 
-;; How many uSTX have voted to reject PoX in a given reward cycle?
-;; *New in Stacks 2.1*
-;; always return 0 for backwards compatibility
-(define-read-only (get-total-pox-rejection (reward-cycle uint))
-        u0
-        u0
-    )
-    u0
-    )
-)
-
 ;; What is the given reward cycle's stackers' aggregate public key?
 ;; *New in Stacks 3.0*
 (define-read-only (get-aggregate-public-key (reward-cycle uint))
diff --git a/stackslib/src/clarity_vm/clarity.rs b/stackslib/src/clarity_vm/clarity.rs
index aed3bb9947..00974298fd 100644
--- a/stackslib/src/clarity_vm/clarity.rs
+++ b/stackslib/src/clarity_vm/clarity.rs
@@ -1360,7 +1360,6 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
                     Value::UInt(u128::from(first_block_height)),
                     Value::UInt(u128::from(pox_prepare_length)),
                     Value::UInt(u128::from(pox_reward_cycle_length)),
-                    Value::UInt(u128::from(pox_rejection_fraction)),
                     Value::UInt(u128::from(pox_4_first_cycle)),
                 ];
 

From cfd1a123a9c1da0114ca2fe5582a271a45655309 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Mon, 4 Dec 2023 16:21:33 -0600
Subject: [PATCH 0200/1166] feat: add nakamoto_node, nakamoto-neon mode

* Refactor some of the reused structs from `neon_node`
* Fix a logic-bug in `nakamoto::coordinator`: the first prepare phase information will be a Epoch2x block, so the reward set calculation has to handle that.
* Add `nakamoto_node` module based on `neon_node`
* Add simple integration test for `nakamoto_node`
---
 .../chainstate/nakamoto/coordinator/mod.rs    |   40 +-
 stackslib/src/chainstate/nakamoto/miner.rs    |    8 +-
 stackslib/src/chainstate/stacks/miner.rs      |   17 +-
 .../burnchains/bitcoin_regtest_controller.rs  |    9 +-
 testnet/stacks-node/src/config.rs             |   17 +-
 testnet/stacks-node/src/globals.rs            |  266 +++++
 testnet/stacks-node/src/keychain.rs           |   24 +-
 testnet/stacks-node/src/main.rs               |    6 +
 testnet/stacks-node/src/mockamoto.rs          |    8 +-
 testnet/stacks-node/src/nakamoto_node.rs      |  683 +++++++++++
 .../stacks-node/src/nakamoto_node/miner.rs    |  645 +++++++++++
 testnet/stacks-node/src/nakamoto_node/peer.rs |  418 +++++++
 .../stacks-node/src/nakamoto_node/relayer.rs  |  961 +++++++++++++++
 testnet/stacks-node/src/neon_node.rs          |  266 +----
 testnet/stacks-node/src/run_loop/mod.rs       |    1 +
 testnet/stacks-node/src/run_loop/nakamoto.rs  | 1029 +++++++++++++++++
 testnet/stacks-node/src/run_loop/neon.rs      |   55 +-
 .../stacks-node/src/tests/bitcoin_regtest.rs  |    1 +
 testnet/stacks-node/src/tests/mod.rs          |    1 +
 .../src/tests/nakamoto_integrations.rs        |  322 ++++++
 .../src/tests/neon_integrations.rs            |    4 +-
 21 files changed, 4480 insertions(+), 301 deletions(-)
 create mode 100644 testnet/stacks-node/src/globals.rs
 create mode 100644 testnet/stacks-node/src/nakamoto_node.rs
 create mode 100644 testnet/stacks-node/src/nakamoto_node/miner.rs
 create mode 100644 testnet/stacks-node/src/nakamoto_node/peer.rs
 create mode 100644 testnet/stacks-node/src/nakamoto_node/relayer.rs
 create mode 100644 testnet/stacks-node/src/run_loop/nakamoto.rs
 create mode 100644 testnet/stacks-node/src/tests/nakamoto_integrations.rs

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
index 462662d4d9..6dde267bc2 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
@@ -169,7 +169,7 @@ pub fn get_nakamoto_reward_cycle_info<U: RewardSetProvider>(
         .epoch_id;
 
     assert!(
-        epoch_at_height >= StacksEpochId::Epoch30,
+        epoch_at_height >= StacksEpochId::Epoch25,
         "FATAL: called a nakamoto function outside of epoch 3"
     );
 
@@ -216,22 +216,40 @@ pub fn get_nakamoto_reward_cycle_info<U: RewardSetProvider>(
         }
 
         // find the first Stacks block processed in the prepare phase
-        let Some(prepare_start_block_header) =
+        let parent_block_id = if let Some(nakamoto_start_block) =
             NakamotoChainState::get_nakamoto_tenure_start_block_header(
                 chain_state.db(),
                 &sn.consensus_hash,
+            )? {
+            nakamoto_start_block
+                .anchored_header
+                .as_stacks_nakamoto()
+                // TODO: maybe `get_nakamoto_tenure_start_block_header` should
+                //       return a type that doesn't require this unwrapping?
+                .expect("FATAL: queried non-Nakamoto tenure start header")
+                .parent_block_id
+        } else {
+            let Some(block_header) =
+                StacksChainState::get_stacks_block_header_info_by_consensus_hash(
+                    chain_state.db(),
+                    &sn.consensus_hash,
+                )?
+            else {
+                // no header for this snapshot (possibly invalid)
+                debug!("Failed to find block by consensus hash"; "consensus_hash" => %sn.consensus_hash);
+                continue;
+            };
+            let Some(parent_block_id) = StacksChainState::get_parent_block_id(
+                chain_state.db(),
+                &block_header.index_block_hash(),
             )?
-        else {
-            // no header for this snapshot (possibly invalid)
-            continue;
+            else {
+                debug!("Failed to get parent block"; "block_id" => %block_header.index_block_hash());
+                continue;
+            };
+            parent_block_id
         };
 
-        let parent_block_id = &prepare_start_block_header
-            .anchored_header
-            .as_stacks_nakamoto()
-            .expect("FATAL: queried non-Nakamoto tenure start header")
-            .parent_block_id;
-
         // find the tenure-start block of the tenure of the parent of this Stacks block.
         // in epoch 2, this is the preceding anchor block
         // in nakamoto, this is the tenure-start block of the preceding tenure
diff --git a/stackslib/src/chainstate/nakamoto/miner.rs b/stackslib/src/chainstate/nakamoto/miner.rs
index 82b6d34b93..1f75cd55ac 100644
--- a/stackslib/src/chainstate/nakamoto/miner.rs
+++ b/stackslib/src/chainstate/nakamoto/miner.rs
@@ -498,7 +498,7 @@ impl NakamotoBlockBuilder {
             state_root_hash
         );
 
-        info!(
+        debug!(
             "Miner: mined Nakamoto block";
             "consensus_hash" => %block.header.consensus_hash,
             "block_hash" => %block.header.block_hash(),
@@ -570,13 +570,15 @@ impl NakamotoBlockBuilder {
             .block_limit()
             .expect("Failed to obtain block limit from miner's block connection");
 
+        let initial_txs: Vec<_> = 
+            [new_tenure_info.tenure_change_tx.cloned(),
+             new_tenure_info.coinbase_tx.cloned()].into_iter().filter_map(|x| x).collect();
         let (blocked, tx_events) = match StacksBlockBuilder::select_and_apply_transactions(
             &mut tenure_tx,
             &mut builder,
             mempool,
             parent_stacks_header.stacks_block_height,
-            tenure_info.tenure_change_tx(),
-            tenure_info.coinbase_tx(),
+            &initial_txs,
             settings,
             event_observer,
             ASTRules::PrecheckSize,
diff --git a/stackslib/src/chainstate/stacks/miner.rs b/stackslib/src/chainstate/stacks/miner.rs
index a9cfacf929..3eb1ea36cc 100644
--- a/stackslib/src/chainstate/stacks/miner.rs
+++ b/stackslib/src/chainstate/stacks/miner.rs
@@ -2139,8 +2139,7 @@ impl StacksBlockBuilder {
         builder: &mut B,
         mempool: &mut MemPoolDB,
         tip_height: u64,
-        tenure_change_tx: Option<&StacksTransaction>,
-        coinbase_tx: Option<&StacksTransaction>,
+        initial_txs: &[StacksTransaction],
         settings: BlockBuilderSettings,
         event_observer: Option<&dyn MemPoolEventDispatcher>,
         ast_rules: ASTRules,
@@ -2155,17 +2154,10 @@ impl StacksBlockBuilder {
 
         let mut tx_events = Vec::new();
 
-        if let Some(tenure_tx) = tenure_change_tx {
+        for initial_tx in initial_txs.iter() {
             tx_events.push(
                 builder
-                    .try_mine_tx(epoch_tx, tenure_tx, ast_rules.clone())?
-                    .convert_to_event(),
-            );
-        }
-        if let Some(coinbase_tx) = coinbase_tx {
-            tx_events.push(
-                builder
-                    .try_mine_tx(epoch_tx, coinbase_tx, ast_rules.clone())?
+                    .try_mine_tx(epoch_tx, initial_tx, ast_rules.clone())?
                     .convert_to_event(),
             );
         }
@@ -2442,8 +2434,7 @@ impl StacksBlockBuilder {
             &mut builder,
             mempool,
             parent_stacks_header.stacks_block_height,
-            None,
-            Some(coinbase_tx),
+            &[coinbase_tx.clone()],
             settings,
             event_observer,
             ast_rules,
diff --git a/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs b/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
index d70fca1c02..ad83dd6f57 100644
--- a/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
+++ b/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
@@ -8,7 +8,7 @@ use async_h1::client;
 use async_std::io::ReadExt;
 use async_std::net::TcpStream;
 use base64::encode;
-use clarity::vm::types::PrincipalData;
+
 use http_types::{Method, Request, Url};
 use serde::Serialize;
 use serde_json::json;
@@ -50,11 +50,16 @@ use stacks_common::deps_common::bitcoin::network::encodable::ConsensusEncodable;
 use stacks_common::deps_common::bitcoin::network::serialize::deserialize as btc_deserialize;
 use stacks_common::deps_common::bitcoin::network::serialize::RawEncoder;
 use stacks_common::deps_common::bitcoin::util::hash::Sha256dHash;
-use stacks_common::types::chainstate::{BurnchainHeaderHash, StacksAddress};
+use stacks_common::types::chainstate::BurnchainHeaderHash;
 use stacks_common::util::hash::{hex_bytes, Hash160};
 use stacks_common::util::secp256k1::Secp256k1PublicKey;
 use stacks_common::util::sleep_ms;
 
+#[cfg(test)]
+use clarity::vm::types::PrincipalData;
+#[cfg(test)]
+use stacks_common::types::chainstate::StacksAddress;
+
 use super::super::operations::BurnchainOpSigner;
 use super::super::Config;
 use super::{BurnchainController, BurnchainTip, Error as BurnchainControllerError};
diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index f634f526c8..feaa0208ac 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -35,6 +35,8 @@ use stacks_common::util::get_epoch_time_ms;
 use stacks_common::util::hash::hex_bytes;
 use stacks_common::util::secp256k1::{Secp256k1PrivateKey, Secp256k1PublicKey};
 
+use crate::mockamoto::signer::SelfSigner;
+
 pub const DEFAULT_SATS_PER_VB: u64 = 50;
 const DEFAULT_MAX_RBF_RATE: u64 = 150; // 1.5x
 const DEFAULT_RBF_FEE_RATE_INCREMENT: u64 = 5;
@@ -491,6 +493,13 @@ lazy_static! {
 }
 
 impl Config {
+    pub fn self_signing(&self) -> Option<SelfSigner> {
+        if !(self.burnchain.mode == "nakamoto-neon" || self.burnchain.mode == "mockamoto") {
+            return None;
+        }
+        self.miner.self_signing_key.clone()
+    }
+
     /// get the up-to-date burnchain from the config
     pub fn get_burnchain_config(&self) -> Result<BurnchainConfig, String> {
         if let Some(path) = &self.config_path {
@@ -1095,6 +1104,7 @@ impl Config {
                     .as_ref()
                     .map(|x| Secp256k1PrivateKey::from_hex(x))
                     .transpose()?,
+                self_signing_key: None,
             },
             None => miner_default_config,
         };
@@ -1108,6 +1118,7 @@ impl Config {
             "xenon",
             "mainnet",
             "mockamoto",
+            "nakamoto-neon",
         ];
 
         if !supported_modes.contains(&burnchain.mode.as_str()) {
@@ -1629,10 +1640,10 @@ impl BurnchainConfig {
         match self.mode.as_str() {
             "mainnet" => ("mainnet".to_string(), BitcoinNetworkType::Mainnet),
             "xenon" => ("testnet".to_string(), BitcoinNetworkType::Testnet),
-            "helium" | "neon" | "argon" | "krypton" | "mocknet" | "mockamoto" => {
+            "helium" | "neon" | "argon" | "krypton" | "mocknet" | "mockamoto" | "nakamoto-neon" => {
                 ("regtest".to_string(), BitcoinNetworkType::Regtest)
             }
-            _ => panic!("Invalid bitcoin mode -- expected mainnet, testnet, or regtest"),
+            other => panic!("Invalid stacks-node mode: {other}"),
         }
     }
 }
@@ -2116,6 +2127,7 @@ pub struct MinerConfig {
     pub candidate_retry_cache_size: u64,
     pub unprocessed_block_deadline_secs: u64,
     pub mining_key: Option<Secp256k1PrivateKey>,
+    pub self_signing_key: Option<SelfSigner>,
 }
 
 impl MinerConfig {
@@ -2133,6 +2145,7 @@ impl MinerConfig {
             candidate_retry_cache_size: 10_000,
             unprocessed_block_deadline_secs: 30,
             mining_key: None,
+            self_signing_key: None,
         }
     }
 }
diff --git a/testnet/stacks-node/src/globals.rs b/testnet/stacks-node/src/globals.rs
new file mode 100644
index 0000000000..acace012f8
--- /dev/null
+++ b/testnet/stacks-node/src/globals.rs
@@ -0,0 +1,266 @@
+use std::sync::atomic::AtomicBool;
+use std::sync::atomic::Ordering;
+use std::sync::mpsc::SyncSender;
+use std::sync::Arc;
+use std::sync::Mutex;
+
+use stacks::burnchains::Txid;
+use stacks::chainstate::burn::operations::LeaderKeyRegisterOp;
+use stacks::chainstate::burn::BlockSnapshot;
+use stacks::chainstate::coordinator::comm::CoordinatorChannels;
+use stacks::chainstate::stacks::db::unconfirmed::UnconfirmedTxMap;
+use stacks::chainstate::stacks::db::StacksChainState;
+use stacks::chainstate::stacks::miner::MinerStatus;
+use stacks::net::NetworkResult;
+use stacks_common::types::chainstate::BlockHeaderHash;
+use stacks_common::types::chainstate::BurnchainHeaderHash;
+use stacks_common::types::chainstate::ConsensusHash;
+
+use crate::neon::Counters;
+use crate::run_loop::RegisteredKey;
+use crate::syncctl::PoxSyncWatchdogComms;
+
+use crate::neon_node::LeaderKeyRegistrationState;
+
+/// Command types for the relayer thread, issued to it by other threads
+pub enum RelayerDirective {
+    /// Handle some new data that arrived on the network (such as blocks, transactions, and
+    HandleNetResult(NetworkResult),
+    /// Announce a new sortition.  Process and broadcast the block if we won.
+    ProcessTenure(ConsensusHash, BurnchainHeaderHash, BlockHeaderHash),
+    /// Try to mine a block
+    RunTenure(RegisteredKey, BlockSnapshot, u128), // (vrf key, chain tip, time of issuance in ms)
+    /// A nakamoto tenure's first block has been processed.
+    NakamotoTenureStartProcessed(ConsensusHash, BlockHeaderHash),
+    /// Try to register a VRF public key
+    RegisterKey(BlockSnapshot),
+    /// Stop the relayer thread
+    Exit,
+}
+
+/// Inter-thread communication structure, shared between threads
+#[derive(Clone)]
+pub struct Globals {
+    /// Last sortition processed
+    last_sortition: Arc<Mutex<Option<BlockSnapshot>>>,
+    /// Status of the miner
+    miner_status: Arc<Mutex<MinerStatus>>,
+    /// Communication link to the coordinator thread
+    pub(crate) coord_comms: CoordinatorChannels,
+    /// Unconfirmed transactions (shared between the relayer and p2p threads)
+    unconfirmed_txs: Arc<Mutex<UnconfirmedTxMap>>,
+    /// Writer endpoint to the relayer thread
+    pub relay_send: SyncSender<RelayerDirective>,
+    /// Cointer state in the main thread
+    pub counters: Counters,
+    /// Connection to the PoX sync watchdog
+    pub sync_comms: PoxSyncWatchdogComms,
+    /// Global flag to see if we should keep running
+    pub should_keep_running: Arc<AtomicBool>,
+    /// Status of our VRF key registration state (shared between the main thread and the relayer)
+    leader_key_registration_state: Arc<Mutex<LeaderKeyRegistrationState>>,
+}
+
+impl Globals {
+    pub fn new(
+        coord_comms: CoordinatorChannels,
+        miner_status: Arc<Mutex<MinerStatus>>,
+        relay_send: SyncSender<RelayerDirective>,
+        counters: Counters,
+        sync_comms: PoxSyncWatchdogComms,
+        should_keep_running: Arc<AtomicBool>,
+    ) -> Globals {
+        Globals {
+            last_sortition: Arc::new(Mutex::new(None)),
+            miner_status,
+            coord_comms,
+            unconfirmed_txs: Arc::new(Mutex::new(UnconfirmedTxMap::new())),
+            relay_send,
+            counters,
+            sync_comms,
+            should_keep_running,
+            leader_key_registration_state: Arc::new(Mutex::new(
+                LeaderKeyRegistrationState::Inactive,
+            )),
+        }
+    }
+
+    /// Get the last sortition processed by the relayer thread
+    pub fn get_last_sortition(&self) -> Option<BlockSnapshot> {
+        self.last_sortition
+            .lock()
+            .unwrap_or_else(|_| {
+                error!("Sortition mutex poisoned!");
+                panic!();
+            })
+            .clone()
+    }
+
+    /// Set the last sortition processed
+    pub fn set_last_sortition(&self, block_snapshot: BlockSnapshot) {
+        let mut last_sortition = self.last_sortition.lock().unwrap_or_else(|_| {
+            error!("Sortition mutex poisoned!");
+            panic!();
+        });
+        last_sortition.replace(block_snapshot);
+    }
+
+    /// Get the status of the miner (blocked or ready)
+    pub fn get_miner_status(&self) -> Arc<Mutex<MinerStatus>> {
+        self.miner_status.clone()
+    }
+
+    pub fn block_miner(&self) {
+        self.miner_status
+            .lock()
+            .expect("FATAL: mutex poisoned")
+            .add_blocked()
+    }
+
+    pub fn unblock_miner(&self) {
+        self.miner_status
+            .lock()
+            .expect("FATAL: mutex poisoned")
+            .remove_blocked()
+    }
+
+    /// Get the main thread's counters
+    pub fn get_counters(&self) -> Counters {
+        self.counters.clone()
+    }
+
+    /// Called by the relayer to pass unconfirmed txs to the p2p thread, so the p2p thread doesn't
+    /// need to do the disk I/O needed to instantiate the unconfirmed state trie they represent.
+    /// Clears the unconfirmed transactions, and replaces them with the chainstate's.
+    pub fn send_unconfirmed_txs(&self, chainstate: &StacksChainState) {
+        let Some(ref unconfirmed) = chainstate.unconfirmed_state else {
+            return;
+        };
+        let mut txs = self.unconfirmed_txs.lock().unwrap_or_else(|e| {
+            // can only happen due to a thread panic in the relayer
+            error!("FATAL: unconfirmed tx arc mutex is poisoned: {e:?}");
+            panic!();
+        });
+        txs.clear();
+        txs.extend(unconfirmed.mined_txs.clone());
+    }
+
+    /// Called by the p2p thread to accept the unconfirmed tx state processed by the relayer.
+    /// Puts the shared unconfirmed transactions to chainstate.
+    pub fn recv_unconfirmed_txs(&self, chainstate: &mut StacksChainState) {
+        let Some(ref mut unconfirmed) = chainstate.unconfirmed_state else {
+            return;
+        };
+        let txs = self.unconfirmed_txs.lock().unwrap_or_else(|e| {
+            // can only happen due to a thread panic in the relayer
+            error!("FATAL: unconfirmed tx arc mutex is poisoned: {e:?}");
+            panic!();
+        });
+        unconfirmed.mined_txs.clear();
+        unconfirmed.mined_txs.extend(txs.clone());
+    }
+
+    /// Signal system-wide stop
+    pub fn signal_stop(&self) {
+        self.should_keep_running.store(false, Ordering::SeqCst);
+    }
+
+    /// Should we keep running?
+    pub fn keep_running(&self) -> bool {
+        self.should_keep_running.load(Ordering::SeqCst)
+    }
+
+    /// Get the handle to the coordinator
+    pub fn coord(&self) -> &CoordinatorChannels {
+        &self.coord_comms
+    }
+
+    /// Get the current leader key registration state.
+    /// Called from the runloop thread and relayer thread.
+    pub fn get_leader_key_registration_state(&self) -> LeaderKeyRegistrationState {
+        let key_state = self
+            .leader_key_registration_state
+            .lock()
+            .unwrap_or_else(|e| {
+                // can only happen due to a thread panic in the relayer
+                error!("FATAL: leader key registration mutex is poisoned: {e:?}");
+                panic!();
+            });
+        key_state.clone()
+    }
+
+    /// Set the initial leader key registration state.
+    /// Called from the runloop thread when booting up.
+    pub fn set_initial_leader_key_registration_state(&self, new_state: LeaderKeyRegistrationState) {
+        let mut key_state = self
+            .leader_key_registration_state
+            .lock()
+            .unwrap_or_else(|e| {
+                // can only happen due to a thread panic in the relayer
+                error!("FATAL: leader key registration mutex is poisoned: {e:?}");
+                panic!();
+            });
+        *key_state = new_state;
+    }
+
+    /// Advance the leader key registration state to pending, given a txid we just sent.
+    /// Only the relayer thread calls this.
+    pub fn set_pending_leader_key_registration(&self, target_block_height: u64, txid: Txid) {
+        let mut key_state = self
+            .leader_key_registration_state
+            .lock()
+            .unwrap_or_else(|_e| {
+                error!("FATAL: failed to lock leader key registration state mutex");
+                panic!();
+            });
+        *key_state = LeaderKeyRegistrationState::Pending(target_block_height, txid);
+    }
+
+    /// Advance the leader key registration state to active, given the VRF key registration ops
+    /// we've discovered in a given snapshot.
+    /// The runloop thread calls this whenever it processes a sortition.
+    pub fn try_activate_leader_key_registration(
+        &self,
+        burn_block_height: u64,
+        key_registers: Vec<LeaderKeyRegisterOp>,
+    ) -> bool {
+        let mut activated = false;
+        let mut key_state = self
+            .leader_key_registration_state
+            .lock()
+            .unwrap_or_else(|e| {
+                // can only happen due to a thread panic in the relayer
+                error!("FATAL: leader key registration mutex is poisoned: {e:?}");
+                panic!();
+            });
+        // if key_state is anything but pending, then we don't activate
+        let LeaderKeyRegistrationState::Pending(target_block_height, txid) = *key_state else {
+            return false;
+        };
+        for op in key_registers.into_iter() {
+            info!(
+                "Processing burnchain block with key_register_op";
+                "burn_block_height" => burn_block_height,
+                "txid" => %op.txid,
+                "checking_txid" => %txid,
+            );
+
+            if txid == op.txid {
+                *key_state = LeaderKeyRegistrationState::Active(RegisteredKey {
+                    target_block_height,
+                    vrf_public_key: op.public_key,
+                    block_height: u64::from(op.block_height),
+                    op_vtxindex: u32::from(op.vtxindex),
+                });
+                activated = true;
+            } else {
+                debug!(
+                    "key_register_op {} does not match our pending op {}",
+                    txid, &op.txid
+                );
+            }
+        }
+
+        activated
+    }
+}
diff --git a/testnet/stacks-node/src/keychain.rs b/testnet/stacks-node/src/keychain.rs
index 7ea3b90556..712fa0b662 100644
--- a/testnet/stacks-node/src/keychain.rs
+++ b/testnet/stacks-node/src/keychain.rs
@@ -7,7 +7,7 @@ use stacks_common::address::{
 };
 use stacks_common::types::chainstate::StacksAddress;
 use stacks_common::util::hash::{Hash160, Sha256Sum};
-use stacks_common::util::secp256k1::Secp256k1PublicKey;
+use stacks_common::util::secp256k1::{Secp256k1PrivateKey, Secp256k1PublicKey};
 use stacks_common::util::vrf::{VRFPrivateKey, VRFProof, VRFPublicKey, VRF};
 
 use super::operations::BurnchainOpSigner;
@@ -16,6 +16,7 @@ use super::operations::BurnchainOpSigner;
 #[derive(Clone)]
 pub struct Keychain {
     secret_state: Vec<u8>,
+    nakamoto_mining_key: Secp256k1PrivateKey,
 }
 
 impl Keychain {
@@ -44,10 +45,27 @@ impl Keychain {
         StacksPrivateKey::from_slice(&sk_bytes[..]).expect("FATAL: Keychain::make_secret_key_bytes() returned bytes that could not be parsed into a secp256k1 secret key!")
     }
 
-    /// Create a default keychain from the seed
+    /// Get the public key hash of the nakamoto mining key (i.e., Hash160(pubkey))
+    pub fn get_nakamoto_pkh(&self) -> Hash160 {
+        let pk = Secp256k1PublicKey::from_private(&self.nakamoto_mining_key);
+        Hash160::from_node_public_key(&pk)
+    }
+
+    /// Get the secrete key of the nakamoto mining key
+    pub fn get_nakamoto_sk(&self) -> &Secp256k1PrivateKey {
+        &self.nakamoto_mining_key
+    }
+
+    /// Create a default keychain from the seed, with a default nakamoto mining key derived
+    ///  from the same seed (
     pub fn default(seed: Vec<u8>) -> Keychain {
+        let secret_state = Self::make_secret_key_bytes(&seed);
+        // re-hash secret_state to use as a default seed for the nakamoto mining key
+        let nakamoto_mining_key =
+            Secp256k1PrivateKey::from_seed(Sha256Sum::from_data(&secret_state).as_bytes());
         Keychain {
-            secret_state: Keychain::make_secret_key_bytes(&seed),
+            secret_state,
+            nakamoto_mining_key,
         }
     }
 
diff --git a/testnet/stacks-node/src/main.rs b/testnet/stacks-node/src/main.rs
index 6addce37a1..8675b43132 100644
--- a/testnet/stacks-node/src/main.rs
+++ b/testnet/stacks-node/src/main.rs
@@ -19,8 +19,10 @@ pub mod burnchains;
 pub mod config;
 pub mod event_dispatcher;
 pub mod genesis_data;
+pub mod globals;
 pub mod keychain;
 pub mod mockamoto;
+pub mod nakamoto_node;
 pub mod neon_node;
 pub mod node;
 pub mod operations;
@@ -44,6 +46,7 @@ pub use self::node::{ChainTip, Node};
 pub use self::run_loop::{helium, neon};
 pub use self::tenure::Tenure;
 use crate::mockamoto::MockamotoNode;
+use crate::run_loop::nakamoto;
 
 fn main() {
     panic::set_hook(Box::new(|panic_info| {
@@ -209,6 +212,9 @@ fn main() {
     } else if conf.burnchain.mode == "mockamoto" {
         let mut mockamoto = MockamotoNode::new(&conf).unwrap();
         mockamoto.run();
+    } else if conf.burnchain.mode == "nakamoto-neon" {
+        let mut run_loop = nakamoto::RunLoop::new(conf);
+        run_loop.start(None, 0);
     } else {
         println!("Burnchain mode '{}' not supported", conf.burnchain.mode);
     }
diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index 8f17aae677..845f838828 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -69,10 +69,9 @@ use stacks_common::util::secp256k1::{MessageSignature, Secp256k1PublicKey};
 use stacks_common::util::vrf::{VRFPrivateKey, VRFProof, VRFPublicKey, VRF};
 
 use self::signer::SelfSigner;
+use crate::globals::{Globals, RelayerDirective};
 use crate::neon::Counters;
-use crate::neon_node::{
-    Globals, PeerThread, RelayerDirective, StacksNode, BLOCK_PROCESSOR_STACK_SIZE,
-};
+use crate::neon_node::{PeerThread, StacksNode, BLOCK_PROCESSOR_STACK_SIZE};
 use crate::syncctl::PoxSyncWatchdogComms;
 use crate::{Config, EventDispatcher};
 
@@ -894,8 +893,7 @@ impl MockamotoNode {
             &mut builder,
             &mut self.mempool,
             parent_chain_length,
-            None,
-            None,
+            &[],
             BlockBuilderSettings {
                 max_miner_time_ms: 15_000,
                 mempool_settings: MemPoolWalkSettings::default(),
diff --git a/testnet/stacks-node/src/nakamoto_node.rs b/testnet/stacks-node/src/nakamoto_node.rs
new file mode 100644
index 0000000000..1c71b09045
--- /dev/null
+++ b/testnet/stacks-node/src/nakamoto_node.rs
@@ -0,0 +1,683 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+use std::collections::HashMap;
+use std::convert::TryFrom;
+use std::net::SocketAddr;
+use std::sync::mpsc::Receiver;
+use std::thread;
+use std::thread::JoinHandle;
+
+use super::{Config, EventDispatcher, Keychain};
+use crate::burnchains::bitcoin_regtest_controller::addr2str;
+use crate::globals::Globals;
+use crate::globals::RelayerDirective;
+use crate::neon_node::LeaderKeyRegistrationState;
+use crate::run_loop::nakamoto::RunLoop;
+use crate::run_loop::RegisteredKey;
+use clarity::vm::ast::ASTRules;
+use clarity::vm::types::QualifiedContractIdentifier;
+use stacks::burnchains::{Burnchain, BurnchainSigner, Txid};
+use stacks::chainstate::burn::db::sortdb::SortitionDB;
+use stacks::chainstate::burn::BlockSnapshot;
+use stacks::chainstate::stacks::db::StacksChainState;
+use stacks::chainstate::stacks::Error as ChainstateError;
+use stacks::core::mempool::MemPoolDB;
+use stacks::cost_estimates::metrics::UnitMetric;
+use stacks::cost_estimates::UnitEstimator;
+use stacks::monitoring;
+use stacks::monitoring::update_active_miners_count_gauge;
+use stacks::net::atlas::{AtlasConfig, AtlasDB};
+use stacks::net::db::PeerDB;
+use stacks::net::p2p::PeerNetwork;
+use stacks::net::relay::Relayer;
+use stacks::net::stackerdb::{StackerDBConfig, StackerDBSync, StackerDBs};
+use stacks::net::{Error as NetError, PeerNetworkComms, ServiceFlags};
+use stacks::util_lib::strings::{UrlString, VecDisplay};
+use stacks_common::types::chainstate::SortitionId;
+use stacks_common::types::net::PeerAddress;
+use stacks_common::types::StacksEpochId;
+use stacks_common::util::get_epoch_time_secs;
+use stacks_common::util::secp256k1::Secp256k1PrivateKey;
+
+pub mod miner;
+pub mod peer;
+pub mod relayer;
+
+use self::peer::PeerThread;
+use self::relayer::RelayerThread;
+
+pub const RELAYER_MAX_BUFFER: usize = 100;
+const VRF_MOCK_MINER_KEY: u64 = 1;
+
+pub const BLOCK_PROCESSOR_STACK_SIZE: usize = 32 * 1024 * 1024; // 32 MB
+
+pub type BlockCommits = HashMap<Txid, ()>;
+
+/// Node implementation for both miners and followers.
+/// This struct is used to set up the node proper and launch the p2p thread and relayer thread.
+/// It is further used by the main thread to communicate with these two threads.
+pub struct StacksNode {
+    /// Atlas network configuration
+    pub atlas_config: AtlasConfig,
+    /// Global inter-thread communication handle
+    pub globals: Globals,
+    /// True if we're a miner
+    is_miner: bool,
+    /// handle to the p2p thread
+    pub p2p_thread_handle: JoinHandle<()>,
+    /// handle to the relayer thread
+    pub relayer_thread_handle: JoinHandle<()>,
+}
+
+/// Fault injection logic to artificially increase the length of a tenure.
+/// Only used in testing
+#[cfg(test)]
+fn fault_injection_long_tenure() {
+    // simulated slow block
+    match std::env::var("STX_TEST_SLOW_TENURE") {
+        Ok(tenure_str) => match tenure_str.parse::<u64>() {
+            Ok(tenure_time) => {
+                info!(
+                    "Fault injection: sleeping for {} milliseconds to simulate a long tenure",
+                    tenure_time
+                );
+                stacks_common::util::sleep_ms(tenure_time);
+            }
+            Err(_) => {
+                error!("Parse error for STX_TEST_SLOW_TENURE");
+                panic!();
+            }
+        },
+        _ => {}
+    }
+}
+
+#[cfg(not(test))]
+fn fault_injection_long_tenure() {}
+
+/// Fault injection to skip mining in this bitcoin block height
+/// Only used in testing
+#[cfg(test)]
+fn fault_injection_skip_mining(rpc_bind: &str, target_burn_height: u64) -> bool {
+    match std::env::var("STACKS_DISABLE_MINER") {
+        Ok(disable_heights) => {
+            let disable_schedule: serde_json::Value =
+                serde_json::from_str(&disable_heights).unwrap();
+            let disable_schedule = disable_schedule.as_array().unwrap();
+            for disabled in disable_schedule {
+                let target_miner_rpc_bind = disabled
+                    .get("rpc_bind")
+                    .unwrap()
+                    .as_str()
+                    .unwrap()
+                    .to_string();
+                if target_miner_rpc_bind != rpc_bind {
+                    continue;
+                }
+                let target_block_heights = disabled.get("blocks").unwrap().as_array().unwrap();
+                for target_block_value in target_block_heights {
+                    let target_block = target_block_value.as_i64().unwrap() as u64;
+                    if target_block == target_burn_height {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
+        Err(_) => {
+            return false;
+        }
+    }
+}
+
+#[cfg(not(test))]
+fn fault_injection_skip_mining(_rpc_bind: &str, _target_burn_height: u64) -> bool {
+    false
+}
+
+/// Open the chainstate, and inject faults from the config file
+pub(crate) fn open_chainstate_with_faults(
+    config: &Config,
+) -> Result<StacksChainState, ChainstateError> {
+    let stacks_chainstate_path = config.get_chainstate_path_str();
+    let (mut chainstate, _) = StacksChainState::open(
+        config.is_mainnet(),
+        config.burnchain.chain_id,
+        &stacks_chainstate_path,
+        Some(config.node.get_marf_opts()),
+    )?;
+
+    chainstate.fault_injection.hide_blocks = config.node.fault_injection_hide_blocks;
+    Ok(chainstate)
+}
+
+/// Types of errors that can arise during mining
+#[derive(Debug)]
+enum Error {
+    /// Can't find the block sortition snapshot for the chain tip
+    SnapshotNotFoundForChainTip,
+    /// The burnchain tip changed while this operation was in progress
+    BurnchainTipChanged,
+    SpawnError(std::io::Error),
+    FaultInjection,
+    MissedMiningOpportunity,
+    /// Attempted to mine while there was no active VRF key
+    NoVRFKeyActive,
+    /// The parent block or tenure could not be found
+    ParentNotFound,
+    /// Something unexpected happened (e.g., hash mismatches)
+    UnexpectedChainState,
+    /// A burnchain operation failed when submitting it to the burnchain
+    BurnchainSubmissionFailed,
+    NewParentDiscovered,
+}
+
+impl StacksNode {
+    /// Set up the AST size-precheck height, if configured
+    fn setup_ast_size_precheck(config: &Config, sortdb: &mut SortitionDB) {
+        if let Some(ast_precheck_size_height) = config.burnchain.ast_precheck_size_height {
+            info!(
+                "Override burnchain height of {:?} to {}",
+                ASTRules::PrecheckSize,
+                ast_precheck_size_height
+            );
+            let mut tx = sortdb
+                .tx_begin()
+                .expect("FATAL: failed to begin tx on sortition DB");
+            SortitionDB::override_ast_rule_height(
+                &mut tx,
+                ASTRules::PrecheckSize,
+                ast_precheck_size_height,
+            )
+            .expect("FATAL: failed to override AST PrecheckSize rule height");
+            tx.commit()
+                .expect("FATAL: failed to commit sortition DB transaction");
+        }
+    }
+
+    /// Set up the mempool DB by making sure it exists.
+    /// Panics on failure.
+    fn setup_mempool_db(config: &Config) -> MemPoolDB {
+        // force early mempool instantiation
+        let cost_estimator = config
+            .make_cost_estimator()
+            .unwrap_or_else(|| Box::new(UnitEstimator));
+        let metric = config
+            .make_cost_metric()
+            .unwrap_or_else(|| Box::new(UnitMetric));
+
+        let mempool = MemPoolDB::open(
+            config.is_mainnet(),
+            config.burnchain.chain_id,
+            &config.get_chainstate_path_str(),
+            cost_estimator,
+            metric,
+        )
+        .expect("BUG: failed to instantiate mempool");
+
+        mempool
+    }
+
+    /// Set up the Peer DB and update any soft state from the config file.  This includes:
+    /// * blacklisted/whitelisted nodes
+    /// * node keys
+    /// * bootstrap nodes
+    /// Returns the instantiated PeerDB
+    /// Panics on failure.
+    fn setup_peer_db(
+        config: &Config,
+        burnchain: &Burnchain,
+        stackerdb_contract_ids: &[QualifiedContractIdentifier],
+    ) -> PeerDB {
+        let data_url = UrlString::try_from(format!("{}", &config.node.data_url)).unwrap();
+        let initial_neighbors = config.node.bootstrap_node.clone();
+        if initial_neighbors.len() > 0 {
+            info!(
+                "Will bootstrap from peers {}",
+                VecDisplay(&initial_neighbors)
+            );
+        } else {
+            warn!("Without a peer to bootstrap from, the node will start mining a new chain");
+        }
+
+        let p2p_sock: SocketAddr = config.node.p2p_bind.parse().expect(&format!(
+            "Failed to parse socket: {}",
+            &config.node.p2p_bind
+        ));
+        let p2p_addr: SocketAddr = config.node.p2p_address.parse().expect(&format!(
+            "Failed to parse socket: {}",
+            &config.node.p2p_address
+        ));
+        let node_privkey = Secp256k1PrivateKey::from_seed(&config.node.local_peer_seed);
+
+        let mut peerdb = PeerDB::connect(
+            &config.get_peer_db_file_path(),
+            true,
+            config.burnchain.chain_id,
+            burnchain.network_id,
+            Some(node_privkey),
+            config.connection_options.private_key_lifetime.clone(),
+            PeerAddress::from_socketaddr(&p2p_addr),
+            p2p_sock.port(),
+            data_url,
+            &[],
+            Some(&initial_neighbors),
+            stackerdb_contract_ids,
+        )
+        .map_err(|e| {
+            eprintln!(
+                "Failed to open {}: {:?}",
+                &config.get_peer_db_file_path(),
+                &e
+            );
+            panic!();
+        })
+        .unwrap();
+
+        // allow all bootstrap nodes
+        {
+            let mut tx = peerdb.tx_begin().unwrap();
+            for initial_neighbor in initial_neighbors.iter() {
+                // update peer in case public key changed
+                PeerDB::update_peer(&mut tx, &initial_neighbor).unwrap();
+                PeerDB::set_allow_peer(
+                    &mut tx,
+                    initial_neighbor.addr.network_id,
+                    &initial_neighbor.addr.addrbytes,
+                    initial_neighbor.addr.port,
+                    -1,
+                )
+                .unwrap();
+            }
+            tx.commit().unwrap();
+        }
+
+        if !config.node.deny_nodes.is_empty() {
+            warn!("Will ignore nodes {:?}", &config.node.deny_nodes);
+        }
+
+        // deny all config-denied peers
+        {
+            let mut tx = peerdb.tx_begin().unwrap();
+            for denied in config.node.deny_nodes.iter() {
+                PeerDB::set_deny_peer(
+                    &mut tx,
+                    denied.addr.network_id,
+                    &denied.addr.addrbytes,
+                    denied.addr.port,
+                    get_epoch_time_secs() + 24 * 365 * 3600,
+                )
+                .unwrap();
+            }
+            tx.commit().unwrap();
+        }
+
+        // update services to indicate we can support mempool sync
+        {
+            let mut tx = peerdb.tx_begin().unwrap();
+            PeerDB::set_local_services(
+                &mut tx,
+                (ServiceFlags::RPC as u16) | (ServiceFlags::RELAY as u16),
+            )
+            .unwrap();
+            tx.commit().unwrap();
+        }
+
+        peerdb
+    }
+
+    /// Set up the PeerNetwork, but do not bind it.
+    pub fn setup_peer_network(
+        config: &Config,
+        atlas_config: &AtlasConfig,
+        burnchain: Burnchain,
+    ) -> PeerNetwork {
+        let sortdb = SortitionDB::open(
+            &config.get_burn_db_file_path(),
+            true,
+            burnchain.pox_constants.clone(),
+        )
+        .expect("Error while instantiating sor/tition db");
+
+        let epochs = SortitionDB::get_stacks_epochs(sortdb.conn())
+            .expect("Error while loading stacks epochs");
+
+        let view = {
+            let sortition_tip = SortitionDB::get_canonical_burn_chain_tip(&sortdb.conn())
+                .expect("Failed to get sortition tip");
+            SortitionDB::get_burnchain_view(&sortdb.index_conn(), &burnchain, &sortition_tip)
+                .unwrap()
+        };
+
+        let atlasdb =
+            AtlasDB::connect(atlas_config.clone(), &config.get_atlas_db_file_path(), true).unwrap();
+
+        let stackerdbs = StackerDBs::connect(&config.get_stacker_db_file_path(), true).unwrap();
+
+        let mut chainstate =
+            open_chainstate_with_faults(config).expect("FATAL: could not open chainstate DB");
+
+        let mut stackerdb_machines = HashMap::new();
+        for stackerdb_contract_id in config.node.stacker_dbs.iter() {
+            // attempt to load the config
+            let (instantiate, stacker_db_config) = match StackerDBConfig::from_smart_contract(
+                &mut chainstate,
+                &sortdb,
+                stackerdb_contract_id,
+            ) {
+                Ok(c) => (true, c),
+                Err(e) => {
+                    warn!(
+                        "Failed to load StackerDB config for {}: {:?}",
+                        stackerdb_contract_id, &e
+                    );
+                    (false, StackerDBConfig::noop())
+                }
+            };
+            let mut stackerdbs =
+                StackerDBs::connect(&config.get_stacker_db_file_path(), true).unwrap();
+
+            if instantiate {
+                match stackerdbs.get_stackerdb_id(stackerdb_contract_id) {
+                    Ok(..) => {
+                        // reconfigure
+                        let tx = stackerdbs.tx_begin(stacker_db_config.clone()).unwrap();
+                        tx.reconfigure_stackerdb(stackerdb_contract_id, &stacker_db_config.signers)
+                            .expect(&format!(
+                                "FATAL: failed to reconfigure StackerDB replica {}",
+                                stackerdb_contract_id
+                            ));
+                        tx.commit().unwrap();
+                    }
+                    Err(NetError::NoSuchStackerDB(..)) => {
+                        // instantiate replica
+                        let tx = stackerdbs.tx_begin(stacker_db_config.clone()).unwrap();
+                        tx.create_stackerdb(stackerdb_contract_id, &stacker_db_config.signers)
+                            .expect(&format!(
+                                "FATAL: failed to instantiate StackerDB replica {}",
+                                stackerdb_contract_id
+                            ));
+                        tx.commit().unwrap();
+                    }
+                    Err(e) => {
+                        panic!("FATAL: failed to query StackerDB state: {:?}", &e);
+                    }
+                }
+            }
+            let stacker_db_sync = match StackerDBSync::new(
+                stackerdb_contract_id.clone(),
+                &stacker_db_config,
+                PeerNetworkComms::new(),
+                stackerdbs,
+            ) {
+                Ok(s) => s,
+                Err(e) => {
+                    warn!(
+                        "Failed to instantiate StackerDB sync machine for {}: {:?}",
+                        stackerdb_contract_id, &e
+                    );
+                    continue;
+                }
+            };
+
+            stackerdb_machines.insert(
+                stackerdb_contract_id.clone(),
+                (stacker_db_config, stacker_db_sync),
+            );
+        }
+
+        let stackerdb_contract_ids: Vec<_> =
+            stackerdb_machines.keys().map(|sc| sc.clone()).collect();
+        let peerdb = Self::setup_peer_db(config, &burnchain, &stackerdb_contract_ids);
+
+        let local_peer = match PeerDB::get_local_peer(peerdb.conn()) {
+            Ok(local_peer) => local_peer,
+            _ => panic!("Unable to retrieve local peer"),
+        };
+
+        let p2p_net = PeerNetwork::new(
+            peerdb,
+            atlasdb,
+            stackerdbs,
+            local_peer,
+            config.burnchain.peer_version,
+            burnchain,
+            view,
+            config.connection_options.clone(),
+            stackerdb_machines,
+            epochs,
+        );
+
+        p2p_net
+    }
+
+    /// This function sets the global var `GLOBAL_BURNCHAIN_SIGNER`.
+    ///
+    /// This variable is used for prometheus monitoring (which only
+    /// runs when the feature flag `monitoring_prom` is activated).
+    /// The address is set using the single-signature BTC address
+    /// associated with `keychain`'s public key. This address always
+    /// assumes Epoch-2.1 rules for the miner address: if the
+    /// node is configured for segwit, then the miner address generated
+    /// is a segwit address, otherwise it is a p2pkh.
+    ///
+    fn set_monitoring_miner_address(keychain: &Keychain, relayer_thread: &RelayerThread) {
+        let public_key = keychain.get_pub_key();
+        let miner_addr = relayer_thread
+            .bitcoin_controller
+            .get_miner_address(StacksEpochId::Epoch21, &public_key);
+        let miner_addr_str = addr2str(&miner_addr);
+        let _ = monitoring::set_burnchain_signer(BurnchainSigner(miner_addr_str)).map_err(|e| {
+            warn!("Failed to set global burnchain signer: {:?}", &e);
+            e
+        });
+    }
+
+    pub fn spawn(
+        runloop: &RunLoop,
+        globals: Globals,
+        // relay receiver endpoint for the p2p thread, so the relayer can feed it data to push
+        relay_recv: Receiver<RelayerDirective>,
+    ) -> StacksNode {
+        let config = runloop.config().clone();
+        let is_miner = runloop.is_miner();
+        let burnchain = runloop.get_burnchain();
+        let atlas_config = config.atlas.clone();
+        let keychain = Keychain::default(config.node.seed.clone());
+
+        // we can call _open_ here rather than _connect_, since connect is first called in
+        //   make_genesis_block
+        let mut sortdb = SortitionDB::open(
+            &config.get_burn_db_file_path(),
+            true,
+            burnchain.pox_constants.clone(),
+        )
+        .expect("Error while instantiating sortition db");
+
+        Self::setup_ast_size_precheck(&config, &mut sortdb);
+
+        let _ = Self::setup_mempool_db(&config);
+
+        let mut p2p_net = Self::setup_peer_network(&config, &atlas_config, burnchain.clone());
+
+        let stackerdbs = StackerDBs::connect(&config.get_stacker_db_file_path(), true)
+            .expect("FATAL: failed to connect to stacker DB");
+
+        let relayer = Relayer::from_p2p(&mut p2p_net, stackerdbs);
+
+        let local_peer = p2p_net.local_peer.clone();
+
+        // setup initial key registration
+        let leader_key_registration_state = if config.node.mock_mining {
+            // mock mining, pretend to have a registered key
+            let (vrf_public_key, _) = keychain.make_vrf_keypair(VRF_MOCK_MINER_KEY);
+            LeaderKeyRegistrationState::Active(RegisteredKey {
+                target_block_height: VRF_MOCK_MINER_KEY,
+                block_height: 1,
+                op_vtxindex: 1,
+                vrf_public_key,
+            })
+        } else {
+            LeaderKeyRegistrationState::Inactive
+        };
+        globals.set_initial_leader_key_registration_state(leader_key_registration_state);
+
+        let relayer_thread = RelayerThread::new(runloop, local_peer.clone(), relayer);
+
+        StacksNode::set_monitoring_miner_address(&keychain, &relayer_thread);
+
+        let relayer_thread_handle = thread::Builder::new()
+            .name(format!("relayer-{}", &local_peer.data_url))
+            .stack_size(BLOCK_PROCESSOR_STACK_SIZE)
+            .spawn(move || {
+                relayer_thread.main(relay_recv);
+            })
+            .expect("FATAL: failed to start relayer thread");
+
+        let p2p_event_dispatcher = runloop.get_event_dispatcher();
+        let p2p_thread = PeerThread::new(runloop, p2p_net);
+        let p2p_thread_handle = thread::Builder::new()
+            .stack_size(BLOCK_PROCESSOR_STACK_SIZE)
+            .name(format!(
+                "p2p-({},{})",
+                &config.node.p2p_bind, &config.node.rpc_bind
+            ))
+            .spawn(move || {
+                p2p_thread.main(p2p_event_dispatcher);
+            })
+            .expect("FATAL: failed to start p2p thread");
+
+        info!("Start HTTP server on: {}", &config.node.rpc_bind);
+        info!("Start P2P server on: {}", &config.node.p2p_bind);
+
+        StacksNode {
+            atlas_config,
+            globals,
+            is_miner,
+            p2p_thread_handle,
+            relayer_thread_handle,
+        }
+    }
+
+    /// Notify the relayer that a new burn block has been processed by the sortition db,
+    ///  telling it to process the block and begin mining if this miner won.
+    /// returns _false_ if the relayer hung up the channel.
+    /// Called from the main thread.
+    pub fn relayer_burnchain_notify(&self) -> bool {
+        if !self.is_miner {
+            // node is a follower, don't try to process my own tenure.
+            return true;
+        }
+
+        let Some(snapshot) = self.globals.get_last_sortition() else {
+            debug!("Tenure: Notify sortition! No last burn block");
+            return true;
+        };
+
+        debug!(
+            "Tenure: Notify sortition!";
+            "consensus_hash" => %snapshot.consensus_hash,
+            "burn_block_hash" => %snapshot.burn_header_hash,
+            "winning_stacks_block_hash" => %snapshot.winning_stacks_block_hash,
+            "burn_block_height" => &snapshot.block_height,
+            "sortition_id" => %snapshot.sortition_id
+        );
+
+        // unlike in neon_node, the nakamoto node should *always* notify the relayer of
+        //  a new burnchain block
+
+        return self
+            .globals
+            .relay_send
+            .send(RelayerDirective::ProcessTenure(
+                snapshot.consensus_hash.clone(),
+                snapshot.parent_burn_header_hash.clone(),
+                snapshot.winning_stacks_block_hash.clone(),
+            ))
+            .is_ok();
+    }
+
+    /// Process a state coming from the burnchain, by extracting the validated KeyRegisterOp
+    /// and inspecting if a sortition was won.
+    /// `ibd`: boolean indicating whether or not we are in the initial block download
+    /// Called from the main thread.
+    pub fn process_burnchain_state(
+        &mut self,
+        sortdb: &SortitionDB,
+        sort_id: &SortitionId,
+        ibd: bool,
+    ) -> Option<BlockSnapshot> {
+        let mut last_sortitioned_block = None;
+
+        let ic = sortdb.index_conn();
+
+        let block_snapshot = SortitionDB::get_block_snapshot(&ic, sort_id)
+            .expect("Failed to obtain block snapshot for processed burn block.")
+            .expect("Failed to obtain block snapshot for processed burn block.");
+        let block_height = block_snapshot.block_height;
+
+        let block_commits =
+            SortitionDB::get_block_commits_by_block(&ic, &block_snapshot.sortition_id)
+                .expect("Unexpected SortitionDB error fetching block commits");
+
+        let num_block_commits = block_commits.len();
+
+        update_active_miners_count_gauge(block_commits.len() as i64);
+
+        for op in block_commits.into_iter() {
+            if op.txid == block_snapshot.winning_block_txid {
+                info!(
+                    "Received burnchain block #{} including block_commit_op (winning) - {} ({})",
+                    block_height, op.apparent_sender, &op.block_header_hash
+                );
+                last_sortitioned_block = Some((block_snapshot.clone(), op.vtxindex));
+            } else {
+                if self.is_miner {
+                    info!(
+                        "Received burnchain block #{} including block_commit_op - {} ({})",
+                        block_height, op.apparent_sender, &op.block_header_hash
+                    );
+                }
+            }
+        }
+
+        let key_registers =
+            SortitionDB::get_leader_keys_by_block(&ic, &block_snapshot.sortition_id)
+                .expect("Unexpected SortitionDB error fetching key registers");
+
+        let num_key_registers = key_registers.len();
+
+        self.globals
+            .try_activate_leader_key_registration(block_height, key_registers);
+
+        debug!(
+            "Processed burnchain state";
+            "burn_height" => block_height,
+            "leader_keys_count" => num_key_registers,
+            "block_commits_count" => num_block_commits,
+            "in_initial_block_download?" => ibd,
+        );
+
+        self.globals.set_last_sortition(block_snapshot);
+        last_sortitioned_block.map(|x| x.0)
+    }
+
+    /// Join all inner threads
+    pub fn join(self) {
+        self.relayer_thread_handle.join().unwrap();
+        self.p2p_thread_handle.join().unwrap();
+    }
+}
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
new file mode 100644
index 0000000000..cb9942d451
--- /dev/null
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -0,0 +1,645 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+use std::convert::TryFrom;
+use std::thread;
+use std::thread::JoinHandle;
+use std::time::Instant;
+
+use super::relayer::RelayerThread;
+use super::Error as NakamotoNodeError;
+use super::{Config, EventDispatcher, Keychain};
+use crate::globals::Globals;
+use crate::mockamoto::signer::SelfSigner;
+use crate::nakamoto_node::VRF_MOCK_MINER_KEY;
+use crate::run_loop::RegisteredKey;
+use crate::ChainTip;
+use clarity::vm::types::PrincipalData;
+use stacks::burnchains::{Burnchain, BurnchainParameters};
+use stacks::chainstate::burn::db::sortdb::SortitionDB;
+use stacks::chainstate::burn::{BlockSnapshot, ConsensusHash};
+use stacks::chainstate::nakamoto::miner::{NakamotoBlockBuilder, NakamotoTenureStart};
+use stacks::chainstate::nakamoto::{NakamotoBlock, NakamotoChainState};
+use stacks::chainstate::stacks::db::{StacksChainState, StacksHeaderInfo};
+use stacks::chainstate::stacks::Error as ChainstateError;
+use stacks::chainstate::stacks::TenureChangeCause;
+use stacks::chainstate::stacks::TenureChangePayload;
+use stacks::chainstate::stacks::ThresholdSignature;
+use stacks::chainstate::stacks::{
+    CoinbasePayload, StacksTransaction, StacksTransactionSigner, TransactionAnchorMode,
+    TransactionPayload, TransactionVersion,
+};
+use stacks::core::mempool::MemPoolDB;
+use stacks::core::FIRST_BURNCHAIN_CONSENSUS_HASH;
+use stacks::cost_estimates::metrics::UnitMetric;
+use stacks::cost_estimates::UnitEstimator;
+use stacks_common::types::chainstate::{StacksAddress, StacksBlockId};
+use stacks_common::types::PrivateKey;
+use stacks_common::types::StacksEpochId;
+use stacks_common::util::hash::Hash160;
+use stacks_common::util::vrf::VRFProof;
+
+pub enum MinerDirective {
+    /// The miner won sortition so they should begin a new tenure
+    BeginTenure {
+        parent_tenure_start: StacksBlockId,
+        burnchain_tip: BlockSnapshot,
+    },
+    /// The miner should try to continue their tenure if they are the active miner
+    ContinueTenure { new_burn_view: ConsensusHash },
+    /// The miner did not win sortition
+    StopTenure,
+}
+
+struct ParentTenureInfo {
+    #[allow(dead_code)]
+    parent_tenure_start: StacksBlockId,
+    parent_tenure_blocks: u64,
+}
+
+/// Metadata required for beginning a new tenure
+struct ParentStacksBlockInfo {
+    /// Header metadata for the Stacks block we're going to build on top of
+    stacks_parent_header: StacksHeaderInfo,
+    /// the total amount burned in the sortition that selected the Stacks block parent
+    parent_block_total_burn: u64,
+    /// nonce to use for this new block's coinbase transaction
+    coinbase_nonce: u64,
+    parent_tenure: Option<ParentTenureInfo>,
+}
+
+pub struct BlockMinerThread {
+    /// node config struct
+    config: Config,
+    /// handle to global state
+    globals: Globals,
+    /// copy of the node's keychain
+    keychain: Keychain,
+    /// burnchain configuration
+    burnchain: Burnchain,
+    /// Set of blocks that we have mined, but are still potentially-broadcastable
+    /// (copied from RelayerThread since we need the info to determine the strategy for mining the
+    /// next block during this tenure).
+    last_mined_blocks: Vec<NakamotoBlock>,
+    /// Copy of the node's registered VRF key
+    registered_key: RegisteredKey,
+    /// Burnchain block snapshot which elected this miner
+    burn_block: BlockSnapshot,
+    /// The start of the parent tenure for this tenure
+    parent_tenure_id: StacksBlockId,
+    /// Handle to the node's event dispatcher
+    event_dispatcher: EventDispatcher,
+}
+
+impl BlockMinerThread {
+    /// Instantiate the miner thread
+    pub fn new(
+        rt: &RelayerThread,
+        registered_key: RegisteredKey,
+        burn_block: BlockSnapshot,
+        parent_tenure_id: StacksBlockId,
+    ) -> BlockMinerThread {
+        BlockMinerThread {
+            config: rt.config.clone(),
+            globals: rt.globals.clone(),
+            keychain: rt.keychain.clone(),
+            burnchain: rt.burnchain.clone(),
+            last_mined_blocks: vec![],
+            registered_key,
+            burn_block,
+            event_dispatcher: rt.event_dispatcher.clone(),
+            parent_tenure_id,
+        }
+    }
+
+    /// Stop a miner tenure by blocking the miner and then joining the tenure thread
+    pub fn stop_miner(globals: &Globals, prior_miner: JoinHandle<()>) {
+        globals.block_miner();
+        prior_miner
+            .join()
+            .expect("FATAL: IO failure joining prior mining thread");
+        globals.unblock_miner();
+    }
+
+    pub fn run_miner(mut self, prior_miner: Option<JoinHandle<()>>) {
+        // when starting a new tenure, block the mining thread if its currently running.
+        // the new mining thread will join it (so that the new mining thread stalls, not the relayer)
+        if let Some(prior_miner) = prior_miner {
+            Self::stop_miner(&self.globals, prior_miner);
+        }
+
+        // now, actually run this tenure
+        let Some(new_block) = self.mine_block() else {
+            warn!("Failed to mine block");
+            return;
+        };
+
+        if let Some(self_signer) = self.config.self_signing() {
+            if let Err(e) = self.self_sign_and_broadcast(self_signer, new_block.clone()) {
+                warn!("Error self-signing block: {e:?}");
+            } else {
+                self.globals.coord().announce_new_stacks_block();
+            }
+        } else {
+            warn!("Not self-signing: nakamoto node does not support stacker-signer-protocol yet");
+        }
+
+        self.globals.counters.bump_naka_mined_blocks();
+        self.last_mined_blocks.push(new_block);
+    }
+
+    fn self_sign_and_broadcast(
+        &self,
+        mut signer: SelfSigner,
+        mut block: NakamotoBlock,
+    ) -> Result<(), ChainstateError> {
+        signer.sign_nakamoto_block(&mut block);
+        let mut chain_state = super::open_chainstate_with_faults(&self.config)
+            .expect("FATAL: could not open chainstate DB");
+        let chainstate_config = chain_state.config();
+        let sort_db = SortitionDB::open(
+            &self.config.get_burn_db_file_path(),
+            true,
+            self.burnchain.pox_constants.clone(),
+        )
+        .expect("FATAL: could not open sortition DB");
+        let sortition_handle = sort_db.index_handle_at_tip();
+        let staging_tx = chain_state.staging_db_tx_begin()?;
+        NakamotoChainState::accept_block(
+            &chainstate_config,
+            block,
+            &sortition_handle,
+            &staging_tx,
+            &signer.aggregate_public_key,
+        )?;
+        staging_tx.commit()?;
+        Ok(())
+    }
+
+    /// Get the coinbase recipient address, if set in the config and if allowed in this epoch
+    fn get_coinbase_recipient(&self, epoch_id: StacksEpochId) -> Option<PrincipalData> {
+        if epoch_id < StacksEpochId::Epoch21 && self.config.miner.block_reward_recipient.is_some() {
+            warn!("Coinbase pay-to-contract is not supported in the current epoch");
+            None
+        } else {
+            self.config.miner.block_reward_recipient.clone()
+        }
+    }
+
+    fn generate_tenure_change_tx(
+        &mut self,
+        nonce: u64,
+        parent_block_id: StacksBlockId,
+        parent_tenure_blocks: u64,
+        miner_pkh: Hash160,
+    ) -> Option<StacksTransaction> {
+        if self.config.self_signing().is_none() {
+            // if we're not self-signing, then we can't generate a tenure change tx: it has to come from the signers.
+            return None;
+        }
+        let is_mainnet = self.config.is_mainnet();
+        let chain_id = self.config.burnchain.chain_id;
+        let tenure_change_tx_payload = TransactionPayload::TenureChange(
+            TenureChangePayload {
+                previous_tenure_end: parent_block_id,
+                previous_tenure_blocks: u32::try_from(parent_tenure_blocks)
+                    .expect("FATAL: more than u32 blocks in a tenure"),
+                cause: TenureChangeCause::BlockFound,
+                pubkey_hash: miner_pkh,
+                signers: vec![],
+            },
+            ThresholdSignature::mock(),
+        );
+
+        let mut tx_auth = self.keychain.get_transaction_auth().unwrap();
+        tx_auth.set_origin_nonce(nonce);
+
+        let version = if is_mainnet {
+            TransactionVersion::Mainnet
+        } else {
+            TransactionVersion::Testnet
+        };
+
+        let mut tx = StacksTransaction::new(version, tx_auth, tenure_change_tx_payload);
+
+        tx.chain_id = chain_id;
+        tx.anchor_mode = TransactionAnchorMode::OnChainOnly;
+        let mut tx_signer = StacksTransactionSigner::new(&tx);
+        self.keychain.sign_as_origin(&mut tx_signer);
+
+        Some(tx_signer.get_tx().unwrap())
+    }
+
+    /// Create a coinbase transaction.
+    fn generate_coinbase_tx(
+        &mut self,
+        nonce: u64,
+        epoch_id: StacksEpochId,
+        vrf_proof: VRFProof,
+    ) -> StacksTransaction {
+        let is_mainnet = self.config.is_mainnet();
+        let chain_id = self.config.burnchain.chain_id;
+        let mut tx_auth = self.keychain.get_transaction_auth().unwrap();
+        tx_auth.set_origin_nonce(nonce);
+
+        let version = if is_mainnet {
+            TransactionVersion::Mainnet
+        } else {
+            TransactionVersion::Testnet
+        };
+
+        let recipient_opt = self.get_coinbase_recipient(epoch_id);
+
+        let mut tx = StacksTransaction::new(
+            version,
+            tx_auth,
+            TransactionPayload::Coinbase(
+                CoinbasePayload([0u8; 32]),
+                recipient_opt,
+                Some(vrf_proof),
+            ),
+        );
+        tx.chain_id = chain_id;
+        tx.anchor_mode = TransactionAnchorMode::OnChainOnly;
+        let mut tx_signer = StacksTransactionSigner::new(&tx);
+        self.keychain.sign_as_origin(&mut tx_signer);
+
+        tx_signer.get_tx().unwrap()
+    }
+
+    /// Load up the parent block info for mining.
+    /// If there's no parent because this is the first block, then return the genesis block's info.
+    /// If we can't find the parent in the DB but we expect one, return None.
+    fn load_block_parent_info(
+        &self,
+        burn_db: &mut SortitionDB,
+        chain_state: &mut StacksChainState,
+    ) -> Option<ParentStacksBlockInfo> {
+        let Some(stacks_tip) =
+            NakamotoChainState::get_canonical_block_header(chain_state.db(), burn_db)
+                .expect("FATAL: could not query chain tip")
+        else {
+            debug!("No Stacks chain tip known, will return a genesis block");
+            let (network, _) = self.config.burnchain.get_bitcoin_network();
+            let burnchain_params =
+                BurnchainParameters::from_params(&self.config.burnchain.chain, &network)
+                    .expect("Bitcoin network unsupported");
+
+            let chain_tip = ChainTip::genesis(
+                &burnchain_params.first_block_hash,
+                burnchain_params.first_block_height.into(),
+                burnchain_params.first_block_timestamp.into(),
+            );
+
+            return Some(ParentStacksBlockInfo {
+                parent_tenure: Some(ParentTenureInfo {
+                    parent_tenure_start: chain_tip.metadata.index_block_hash(),
+                    parent_tenure_blocks: 0,
+                }),
+                stacks_parent_header: chain_tip.metadata,
+                parent_block_total_burn: 0,
+                coinbase_nonce: 0,
+            });
+        };
+
+        let miner_address = self
+            .keychain
+            .origin_address(self.config.is_mainnet())
+            .unwrap();
+        match ParentStacksBlockInfo::lookup(
+            chain_state,
+            burn_db,
+            &self.burn_block,
+            miner_address,
+            &self.parent_tenure_id,
+            stacks_tip,
+        ) {
+            Ok(parent_info) => Some(parent_info),
+            Err(NakamotoNodeError::BurnchainTipChanged) => {
+                self.globals.counters.bump_missed_tenures();
+                None
+            }
+            Err(..) => None,
+        }
+    }
+
+    /// Generate the VRF proof for the block we're going to build.
+    /// Returns Some(proof) if we could make the proof
+    /// Return None if we could not make the proof
+    fn make_vrf_proof(&mut self) -> Option<VRFProof> {
+        // if we're a mock miner, then make sure that the keychain has a keypair for the mocked VRF
+        // key
+        let vrf_proof = if self.config.node.mock_mining {
+            self.keychain.generate_proof(
+                VRF_MOCK_MINER_KEY,
+                self.burn_block.sortition_hash.as_bytes(),
+            )
+        } else {
+            self.keychain.generate_proof(
+                self.registered_key.target_block_height,
+                self.burn_block.sortition_hash.as_bytes(),
+            )
+        };
+
+        debug!(
+            "Generated VRF Proof: {} over {} ({},{}) with key {}",
+            vrf_proof.to_hex(),
+            &self.burn_block.sortition_hash,
+            &self.burn_block.block_height,
+            &self.burn_block.burn_header_hash,
+            &self.registered_key.vrf_public_key.to_hex()
+        );
+        Some(vrf_proof)
+    }
+
+    /// Try to mine a Stacks block by assembling one from mempool transactions and sending a
+    /// burnchain block-commit transaction.  If we succeed, then return the assembled block data as
+    /// well as the microblock private key to use to produce microblocks.
+    /// Return None if we couldn't build a block for whatever reason.
+    fn mine_block(&mut self) -> Option<NakamotoBlock> {
+        debug!("block miner thread ID is {:?}", thread::current().id());
+        super::fault_injection_long_tenure();
+
+        let burn_db_path = self.config.get_burn_db_file_path();
+        let stacks_chainstate_path = self.config.get_chainstate_path_str();
+
+        let cost_estimator = self
+            .config
+            .make_cost_estimator()
+            .unwrap_or_else(|| Box::new(UnitEstimator));
+        let metric = self
+            .config
+            .make_cost_metric()
+            .unwrap_or_else(|| Box::new(UnitMetric));
+
+        // NOTE: read-write access is needed in order to be able to query the recipient set.
+        // This is an artifact of the way the MARF is built (see #1449)
+        let mut burn_db =
+            SortitionDB::open(&burn_db_path, true, self.burnchain.pox_constants.clone())
+                .expect("FATAL: could not open sortition DB");
+
+        let mut chain_state = super::open_chainstate_with_faults(&self.config)
+            .expect("FATAL: could not open chainstate DB");
+
+        let mut mem_pool = MemPoolDB::open(
+            self.config.is_mainnet(),
+            self.config.burnchain.chain_id,
+            &stacks_chainstate_path,
+            cost_estimator,
+            metric,
+        )
+        .expect("Database failure opening mempool");
+
+        let assembly_start = Instant::now();
+
+        let target_epoch_id =
+            SortitionDB::get_stacks_epoch(burn_db.conn(), self.burn_block.block_height + 1)
+                .ok()?
+                .expect("FATAL: no epoch defined")
+                .epoch_id;
+        let mut parent_block_info = self.load_block_parent_info(&mut burn_db, &mut chain_state)?;
+        let vrf_proof = self.make_vrf_proof()?;
+
+        if self.last_mined_blocks.is_empty() {
+            if parent_block_info.parent_tenure.is_none() {
+                warn!(
+                    "Miner should be starting a new tenure, but failed to load parent tenure info"
+                );
+                return None;
+            }
+        }
+
+        // create our coinbase if this is the first block we've mined this tenure
+        let tenure_start_info = if let Some(ref par_tenure_info) = parent_block_info.parent_tenure {
+            let parent_block_id = parent_block_info.stacks_parent_header.index_block_hash();
+            let current_miner_nonce = parent_block_info.coinbase_nonce;
+            let tenure_change_tx = self.generate_tenure_change_tx(
+                current_miner_nonce,
+                parent_block_id,
+                par_tenure_info.parent_tenure_blocks,
+                self.keychain.get_nakamoto_pkh(),
+            )?;
+            let coinbase_tx = self.generate_coinbase_tx(
+                current_miner_nonce + 1,
+                target_epoch_id,
+                vrf_proof.clone(),
+            );
+            Some(NakamotoTenureStart {
+                coinbase_tx,
+                // TODO (refactor): the nakamoto block builder doesn't use this VRF proof,
+                //  it has to be included in the coinbase tx, which is an arg to the builder.
+                //  we should probably just remove this from the nakamoto block builder.
+                vrf_proof: vrf_proof.clone(),
+                tenure_change_tx,
+            })
+        } else {
+            None
+        };
+
+        parent_block_info.stacks_parent_header.microblock_tail = None;
+
+        // build the block itself
+        let (mut block, _, _) = match NakamotoBlockBuilder::build_nakamoto_block(
+            &chain_state,
+            &burn_db.index_conn(),
+            &mut mem_pool,
+            // TODO (refactor): the nakamoto block builder doesn't use the parent tenure ID,
+            //  it has to be included in the tenure change tx, which is an arg to the builder.
+            //  we should probably just remove this from the nakamoto block builder, so that
+            //  there isn't duplicated or unused logic here
+            &self.parent_tenure_id,
+            &parent_block_info.stacks_parent_header,
+            &self.burn_block.consensus_hash,
+            self.burn_block.total_burn,
+            tenure_start_info,
+            self.config.make_block_builder_settings(
+                // TODO: the attempt counter needs a different configuration approach in nakamoto
+                1,
+                false,
+                self.globals.get_miner_status(),
+            ),
+            Some(&self.event_dispatcher),
+        ) {
+            Ok(block) => block,
+            Err(e) => {
+                error!("Relayer: Failure mining anchored block: {}", e);
+                return None;
+            }
+        };
+
+        let mining_key = self.keychain.get_nakamoto_sk();
+        let miner_signature = mining_key
+            .sign(block.header.signature_hash().ok()?.as_bytes())
+            .ok()?;
+        block.header.miner_signature = miner_signature;
+
+        info!(
+            "Miner: Succeeded assembling {} block #{}: {}, with {} txs",
+            if parent_block_info.parent_block_total_burn == 0 {
+                "Genesis"
+            } else {
+                "Stacks"
+            },
+            block.header.chain_length,
+            block.header.block_hash(),
+            block.txs.len(),
+        );
+
+        // last chance -- confirm that the stacks tip is unchanged (since it could have taken long
+        // enough to build this block that another block could have arrived), and confirm that all
+        // Stacks blocks with heights higher than the canoincal tip are processed.
+        let cur_burn_chain_tip = SortitionDB::get_canonical_burn_chain_tip(burn_db.conn())
+            .expect("FATAL: failed to query sortition DB for canonical burn chain tip");
+
+        if cur_burn_chain_tip.consensus_hash != block.header.consensus_hash {
+            info!("Miner: Cancel block assembly; burnchain tip has changed");
+            self.globals.counters.bump_missed_tenures();
+            return None;
+        }
+
+        Some(block)
+    }
+}
+
+impl ParentStacksBlockInfo {
+    /// Determine where in the set of forks to attempt to mine the next anchored block.
+    /// `mine_tip_ch` and `mine_tip_bhh` identify the parent block on top of which to mine.
+    /// `check_burn_block` identifies what we believe to be the burn chain's sortition history tip.
+    /// This is used to mitigate (but not eliminate) a TOCTTOU issue with mining: the caller's
+    /// conception of the sortition history tip may have become stale by the time they call this
+    /// method, in which case, mining should *not* happen (since the block will be invalid).
+    pub fn lookup(
+        chain_state: &mut StacksChainState,
+        burn_db: &mut SortitionDB,
+        check_burn_block: &BlockSnapshot,
+        miner_address: StacksAddress,
+        parent_tenure_id: &StacksBlockId,
+        stacks_tip_header: StacksHeaderInfo,
+    ) -> Result<ParentStacksBlockInfo, NakamotoNodeError> {
+        // the stacks block I'm mining off of's burn header hash and vtxindex:
+        let parent_snapshot = SortitionDB::get_block_snapshot_consensus(
+            burn_db.conn(),
+            &stacks_tip_header.consensus_hash,
+        )
+        .expect("Failed to look up block's parent snapshot")
+        .expect("Failed to look up block's parent snapshot");
+
+        let parent_sortition_id = &parent_snapshot.sortition_id;
+
+        let parent_block_total_burn =
+            if &stacks_tip_header.consensus_hash == &FIRST_BURNCHAIN_CONSENSUS_HASH {
+                0
+            } else {
+                let parent_burn_block =
+                    SortitionDB::get_block_snapshot(burn_db.conn(), parent_sortition_id)
+                        .expect("SortitionDB failure.")
+                        .ok_or_else(|| {
+                            error!(
+                                "Failed to find block snapshot for the parent sortition";
+                                "parent_sortition_id" => %parent_sortition_id
+                            );
+                            NakamotoNodeError::SnapshotNotFoundForChainTip
+                        })?;
+
+                parent_burn_block.total_burn
+            };
+
+        // don't mine off of an old burnchain block
+        let burn_chain_tip = SortitionDB::get_canonical_burn_chain_tip(burn_db.conn())
+            .expect("FATAL: failed to query sortition DB for canonical burn chain tip");
+
+        if burn_chain_tip.consensus_hash != check_burn_block.consensus_hash {
+            info!(
+                "New canonical burn chain tip detected. Will not try to mine.";
+                "new_consensus_hash" => %burn_chain_tip.consensus_hash,
+                "old_consensus_hash" => %check_burn_block.consensus_hash,
+                "new_burn_height" => burn_chain_tip.block_height,
+                "old_burn_height" => check_burn_block.block_height
+            );
+            return Err(NakamotoNodeError::BurnchainTipChanged);
+        }
+
+        let Ok(Some(parent_tenure_header)) =
+            NakamotoChainState::get_block_header(chain_state.db(), &parent_tenure_id)
+        else {
+            warn!("Failed loading parent tenure ID"; "parent_tenure_id" => %parent_tenure_id);
+            return Err(NakamotoNodeError::ParentNotFound);
+        };
+
+        // check if we're mining a first tenure block (by checking if our parent block is in the tenure of parent_tenure_id)
+        //  and if so, figure out how many blocks there were in the parent tenure
+        let parent_tenure_info = if stacks_tip_header.consensus_hash
+            == parent_tenure_header.consensus_hash
+        {
+            let parent_tenure_blocks = if parent_tenure_header
+                .anchored_header
+                .as_stacks_nakamoto()
+                .is_some()
+            {
+                let Ok(Some(last_parent_tenure_header)) =
+                    NakamotoChainState::get_nakamoto_tenure_finish_block_header(
+                        chain_state.db(),
+                        &parent_tenure_header.consensus_hash,
+                    )
+                else {
+                    warn!("Failed loading last block of parent tenure"; "parent_tenure_id" => %parent_tenure_id);
+                    return Err(NakamotoNodeError::ParentNotFound);
+                };
+                // the last known tenure block of our parent should be the stacks_tip. if not, error.
+                if stacks_tip_header.index_block_hash()
+                    != last_parent_tenure_header.index_block_hash()
+                {
+                    return Err(NakamotoNodeError::NewParentDiscovered);
+                }
+                1 + last_parent_tenure_header.stacks_block_height
+                    - parent_tenure_header.stacks_block_height
+            } else {
+                1
+            };
+            Some(ParentTenureInfo {
+                parent_tenure_start: parent_tenure_id.clone(),
+                parent_tenure_blocks,
+            })
+        } else {
+            None
+        };
+
+        debug!("Mining tenure's last consensus hash: {} (height {} hash {}), stacks tip consensus hash: {} (height {} hash {})",
+               &check_burn_block.consensus_hash, check_burn_block.block_height, &check_burn_block.burn_header_hash,
+               &parent_snapshot.consensus_hash, parent_snapshot.block_height, &parent_snapshot.burn_header_hash);
+
+        let coinbase_nonce = {
+            let principal = miner_address.into();
+            let account = chain_state
+                .with_read_only_clarity_tx(
+                    &burn_db.index_conn(),
+                    &stacks_tip_header.index_block_hash(),
+                    |conn| StacksChainState::get_account(conn, &principal),
+                )
+                .expect(&format!(
+                    "BUG: stacks tip block {} no longer exists after we queried it",
+                    &stacks_tip_header.index_block_hash(),
+                ));
+            account.nonce
+        };
+
+        Ok(ParentStacksBlockInfo {
+            stacks_parent_header: stacks_tip_header,
+            parent_block_total_burn,
+            coinbase_nonce,
+            parent_tenure: parent_tenure_info,
+        })
+    }
+}
diff --git a/testnet/stacks-node/src/nakamoto_node/peer.rs b/testnet/stacks-node/src/nakamoto_node/peer.rs
new file mode 100644
index 0000000000..8fe688972e
--- /dev/null
+++ b/testnet/stacks-node/src/nakamoto_node/peer.rs
@@ -0,0 +1,418 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+use std::cmp;
+use std::collections::VecDeque;
+
+use std::default::Default;
+use std::net::SocketAddr;
+use std::sync::mpsc::TrySendError;
+
+use std::thread;
+use std::time::Duration;
+
+use stacks::burnchains::db::BurnchainHeaderReader;
+use stacks::burnchains::PoxConstants;
+use stacks::chainstate::burn::db::sortdb::SortitionDB;
+
+use stacks::chainstate::stacks::db::StacksChainState;
+use stacks::chainstate::stacks::miner::signal_mining_blocked;
+
+use stacks::core::mempool::MemPoolDB;
+
+use stacks::cost_estimates::metrics::{CostMetric, UnitMetric};
+use stacks::cost_estimates::{CostEstimator, FeeEstimator, UnitEstimator};
+
+use stacks::net::dns::{DNSClient, DNSResolver};
+use stacks::net::p2p::PeerNetwork;
+
+use stacks::net::RPCHandlerArgs;
+
+use stacks_common::util::hash::Sha256Sum;
+
+use crate::burnchains::make_bitcoin_indexer;
+use crate::globals::Globals;
+use crate::globals::RelayerDirective;
+
+use crate::run_loop::nakamoto::RunLoop;
+
+use crate::{Config, EventDispatcher};
+
+use super::open_chainstate_with_faults;
+
+/// Thread that runs the network state machine, handling both p2p and http requests.
+pub struct PeerThread {
+    /// Node config
+    config: Config,
+    /// instance of the peer network. Made optional in order to trick the borrow checker.
+    net: Option<PeerNetwork>,
+    /// handle to global inter-thread comms
+    globals: Globals,
+    /// how long to wait for network messages on each poll, in millis
+    poll_timeout: u64,
+    /// handle to the sortition DB (optional so we can take/replace it)
+    sortdb: Option<SortitionDB>,
+    /// handle to the chainstate DB (optional so we can take/replace it)
+    chainstate: Option<StacksChainState>,
+    /// handle to the mempool DB (optional so we can take/replace it)
+    mempool: Option<MemPoolDB>,
+    /// buffer of relayer commands with block data that couldn't be sent to the relayer just yet
+    /// (i.e. due to backpressure).  We track this separately, instead of just using a bigger
+    /// channel, because we need to know when backpressure occurs in order to throttle the p2p
+    /// thread's downloader.
+    results_with_data: VecDeque<RelayerDirective>,
+    /// total number of p2p state-machine passes so far. Used to signal when to download the next
+    /// reward cycle of blocks
+    num_p2p_state_machine_passes: u64,
+    /// total number of inventory state-machine passes so far. Used to signal when to download the
+    /// next reward cycle of blocks.
+    num_inv_sync_passes: u64,
+    /// total number of download state-machine passes so far. Used to signal when to download the
+    /// next reward cycle of blocks.
+    num_download_passes: u64,
+    /// last burnchain block seen in the PeerNetwork's chain view since the last run
+    last_burn_block_height: u64,
+}
+
+impl PeerThread {
+    /// Main loop of the p2p thread.
+    /// Runs in a separate thread.
+    /// Continuously receives, until told otherwise.
+    pub fn main(mut self, event_dispatcher: EventDispatcher) {
+        debug!("p2p thread ID is {:?}", thread::current().id());
+        let should_keep_running = self.globals.should_keep_running.clone();
+        let (mut dns_resolver, mut dns_client) = DNSResolver::new(10);
+
+        // spawn a daemon thread that runs the DNS resolver.
+        // It will die when the rest of the system dies.
+        {
+            let _jh = thread::Builder::new()
+                .name("dns-resolver".to_string())
+                .spawn(move || {
+                    debug!("DNS resolver thread ID is {:?}", thread::current().id());
+                    dns_resolver.thread_main();
+                })
+                .unwrap();
+        }
+
+        // NOTE: these must be instantiated in the thread context, since it can't be safely sent
+        // between threads
+        let fee_estimator_opt = self.config.make_fee_estimator();
+        let cost_estimator = self
+            .config
+            .make_cost_estimator()
+            .unwrap_or_else(|| Box::new(UnitEstimator));
+        let cost_metric = self
+            .config
+            .make_cost_metric()
+            .unwrap_or_else(|| Box::new(UnitMetric));
+
+        let indexer = make_bitcoin_indexer(&self.config, Some(should_keep_running));
+
+        // receive until we can't reach the receiver thread
+        loop {
+            if !self.globals.keep_running() {
+                break;
+            }
+            if !self.run_one_pass(
+                &indexer,
+                Some(&mut dns_client),
+                &event_dispatcher,
+                &cost_estimator,
+                &cost_metric,
+                fee_estimator_opt.as_ref(),
+            ) {
+                break;
+            }
+        }
+
+        // kill miner
+        signal_mining_blocked(self.globals.get_miner_status());
+
+        // set termination flag so other threads die
+        self.globals.signal_stop();
+
+        // thread exited, so signal to the relayer thread to die.
+        while let Err(TrySendError::Full(_)) =
+            self.globals.relay_send.try_send(RelayerDirective::Exit)
+        {
+            warn!("Failed to direct relayer thread to exit, sleeping and trying again");
+            thread::sleep(Duration::from_secs(5));
+        }
+        info!("P2P thread exit!");
+    }
+
+    /// set up the mempool DB connection
+    pub fn connect_mempool_db(config: &Config) -> MemPoolDB {
+        // create estimators, metric instances for RPC handler
+        let cost_estimator = config
+            .make_cost_estimator()
+            .unwrap_or_else(|| Box::new(UnitEstimator));
+        let metric = config
+            .make_cost_metric()
+            .unwrap_or_else(|| Box::new(UnitMetric));
+
+        let mempool = MemPoolDB::open(
+            config.is_mainnet(),
+            config.burnchain.chain_id,
+            &config.get_chainstate_path_str(),
+            cost_estimator,
+            metric,
+        )
+        .expect("Database failure opening mempool");
+
+        mempool
+    }
+
+    /// Instantiate the p2p thread.
+    /// Binds the addresses in the config (which may panic if the port is blocked).
+    /// This is so the node will crash "early" before any new threads start if there's going to be
+    /// a bind error anyway.
+    pub fn new(runloop: &RunLoop, net: PeerNetwork) -> PeerThread {
+        Self::new_all(
+            runloop.get_globals(),
+            runloop.config(),
+            runloop.get_burnchain().pox_constants,
+            net,
+        )
+    }
+
+    pub fn new_all(
+        globals: Globals,
+        config: &Config,
+        pox_constants: PoxConstants,
+        mut net: PeerNetwork,
+    ) -> Self {
+        let config = config.clone();
+        let mempool = Self::connect_mempool_db(&config);
+        let burn_db_path = config.get_burn_db_file_path();
+
+        let sortdb = SortitionDB::open(&burn_db_path, false, pox_constants)
+            .expect("FATAL: could not open sortition DB");
+
+        let chainstate =
+            open_chainstate_with_faults(&config).expect("FATAL: could not open chainstate DB");
+
+        let p2p_sock: SocketAddr = config.node.p2p_bind.parse().expect(&format!(
+            "Failed to parse socket: {}",
+            &config.node.p2p_bind
+        ));
+        let rpc_sock = config.node.rpc_bind.parse().expect(&format!(
+            "Failed to parse socket: {}",
+            &config.node.rpc_bind
+        ));
+
+        net.bind(&p2p_sock, &rpc_sock)
+            .expect("BUG: PeerNetwork could not bind or is already bound");
+
+        let poll_timeout = cmp::min(5000, config.miner.first_attempt_time_ms / 2);
+
+        PeerThread {
+            config,
+            net: Some(net),
+            globals,
+            poll_timeout,
+            sortdb: Some(sortdb),
+            chainstate: Some(chainstate),
+            mempool: Some(mempool),
+            results_with_data: VecDeque::new(),
+            num_p2p_state_machine_passes: 0,
+            num_inv_sync_passes: 0,
+            num_download_passes: 0,
+            last_burn_block_height: 0,
+        }
+    }
+
+    /// Do something with mutable references to the mempool, sortdb, and chainstate
+    /// Fools the borrow checker.
+    /// NOT COMPOSIBLE
+    fn with_chainstate<F, R>(&mut self, func: F) -> R
+    where
+        F: FnOnce(&mut PeerThread, &mut SortitionDB, &mut StacksChainState, &mut MemPoolDB) -> R,
+    {
+        let mut sortdb = self.sortdb.take().expect("BUG: sortdb already taken");
+        let mut chainstate = self
+            .chainstate
+            .take()
+            .expect("BUG: chainstate already taken");
+        let mut mempool = self.mempool.take().expect("BUG: mempool already taken");
+
+        let res = func(self, &mut sortdb, &mut chainstate, &mut mempool);
+
+        self.sortdb = Some(sortdb);
+        self.chainstate = Some(chainstate);
+        self.mempool = Some(mempool);
+
+        res
+    }
+
+    /// Get an immutable ref to the inner network.
+    /// DO NOT USE WITHIN with_network()
+    fn get_network(&self) -> &PeerNetwork {
+        self.net.as_ref().expect("BUG: did not replace net")
+    }
+
+    /// Do something with mutable references to the network.
+    /// Fools the borrow checker.
+    /// NOT COMPOSIBLE. DO NOT CALL THIS OR get_network() IN func
+    fn with_network<F, R>(&mut self, func: F) -> R
+    where
+        F: FnOnce(&mut PeerThread, &mut PeerNetwork) -> R,
+    {
+        let mut net = self.net.take().expect("BUG: net already taken");
+
+        let res = func(self, &mut net);
+
+        self.net = Some(net);
+        res
+    }
+
+    /// Run one pass of the p2p/http state machine
+    /// Return true if we should continue running passes; false if not
+    pub fn run_one_pass<B: BurnchainHeaderReader>(
+        &mut self,
+        indexer: &B,
+        dns_client_opt: Option<&mut DNSClient>,
+        event_dispatcher: &EventDispatcher,
+        cost_estimator: &Box<dyn CostEstimator>,
+        cost_metric: &Box<dyn CostMetric>,
+        fee_estimator: Option<&Box<dyn FeeEstimator>>,
+    ) -> bool {
+        // initial block download?
+        let ibd = self.globals.sync_comms.get_ibd();
+        let download_backpressure = self.results_with_data.len() > 0;
+        let poll_ms = if !download_backpressure && self.get_network().has_more_downloads() {
+            // keep getting those blocks -- drive the downloader state-machine
+            debug!(
+                "P2P: backpressure: {}, more downloads: {}",
+                download_backpressure,
+                self.get_network().has_more_downloads()
+            );
+            1
+        } else {
+            self.poll_timeout
+        };
+
+        // do one pass
+        let p2p_res = self.with_chainstate(|p2p_thread, sortdb, chainstate, mempool| {
+            // NOTE: handler_args must be created such that it outlives the inner net.run() call and
+            // doesn't ref anything within p2p_thread.
+            let handler_args = RPCHandlerArgs {
+                exit_at_block_height: p2p_thread
+                    .config
+                    .burnchain
+                    .process_exit_at_block_height
+                    .clone(),
+                genesis_chainstate_hash: Sha256Sum::from_hex(stx_genesis::GENESIS_CHAINSTATE_HASH)
+                    .unwrap(),
+                event_observer: Some(event_dispatcher),
+                cost_estimator: Some(cost_estimator.as_ref()),
+                cost_metric: Some(cost_metric.as_ref()),
+                fee_estimator: fee_estimator.map(|boxed_estimator| boxed_estimator.as_ref()),
+                ..RPCHandlerArgs::default()
+            };
+            p2p_thread.with_network(|_, net| {
+                net.run(
+                    indexer,
+                    sortdb,
+                    chainstate,
+                    mempool,
+                    dns_client_opt,
+                    download_backpressure,
+                    ibd,
+                    poll_ms,
+                    &handler_args,
+                )
+            })
+        });
+
+        match p2p_res {
+            Ok(network_result) => {
+                let mut have_update = false;
+                if self.num_p2p_state_machine_passes < network_result.num_state_machine_passes {
+                    // p2p state-machine did a full pass. Notify anyone listening.
+                    self.globals.sync_comms.notify_p2p_state_pass();
+                    self.num_p2p_state_machine_passes = network_result.num_state_machine_passes;
+                }
+
+                if self.num_inv_sync_passes < network_result.num_inv_sync_passes {
+                    // inv-sync state-machine did a full pass. Notify anyone listening.
+                    self.globals.sync_comms.notify_inv_sync_pass();
+                    self.num_inv_sync_passes = network_result.num_inv_sync_passes;
+
+                    // the relayer cares about the number of inventory passes, so pass this along
+                    have_update = true;
+                }
+
+                if self.num_download_passes < network_result.num_download_passes {
+                    // download state-machine did a full pass.  Notify anyone listening.
+                    self.globals.sync_comms.notify_download_pass();
+                    self.num_download_passes = network_result.num_download_passes;
+
+                    // the relayer cares about the number of download passes, so pass this along
+                    have_update = true;
+                }
+
+                if network_result.has_data_to_store()
+                    || self.last_burn_block_height != network_result.burn_height
+                    || have_update
+                {
+                    // pass along if we have blocks, microblocks, or transactions, or a status
+                    // update on the network's view of the burnchain
+                    self.last_burn_block_height = network_result.burn_height;
+                    self.results_with_data
+                        .push_back(RelayerDirective::HandleNetResult(network_result));
+                }
+            }
+            Err(e) => {
+                // this is only reachable if the network is not instantiated correctly --
+                // i.e. you didn't connect it
+                panic!("P2P: Failed to process network dispatch: {:?}", &e);
+            }
+        };
+
+        while let Some(next_result) = self.results_with_data.pop_front() {
+            // have blocks, microblocks, and/or transactions (don't care about anything else),
+            // or a directive to mine microblocks
+            if let Err(e) = self.globals.relay_send.try_send(next_result) {
+                debug!(
+                    "P2P: {:?}: download backpressure detected (bufferred {})",
+                    &self.get_network().local_peer,
+                    self.results_with_data.len()
+                );
+                match e {
+                    TrySendError::Full(directive) => {
+                        if let RelayerDirective::RunTenure(..) = directive {
+                            // can drop this
+                        } else {
+                            // don't lose this data -- just try it again
+                            self.results_with_data.push_front(directive);
+                        }
+                        break;
+                    }
+                    TrySendError::Disconnected(_) => {
+                        info!("P2P: Relayer hang up with p2p channel");
+                        self.globals.signal_stop();
+                        return false;
+                    }
+                }
+            } else {
+                debug!("P2P: Dispatched result to Relayer!");
+            }
+        }
+
+        true
+    }
+}
diff --git a/testnet/stacks-node/src/nakamoto_node/relayer.rs b/testnet/stacks-node/src/nakamoto_node/relayer.rs
new file mode 100644
index 0000000000..a90b17866f
--- /dev/null
+++ b/testnet/stacks-node/src/nakamoto_node/relayer.rs
@@ -0,0 +1,961 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+use stacks::burnchains::{Burnchain, Txid};
+use stacks::chainstate::burn::db::sortdb::SortitionDB;
+use stacks::chainstate::burn::operations::leader_block_commit::{
+    RewardSetInfo, BURN_BLOCK_MINED_AT_MODULUS,
+};
+use stacks::chainstate::burn::operations::{
+    BlockstackOperationType, LeaderBlockCommitOp, LeaderKeyRegisterOp,
+};
+use stacks::chainstate::burn::{BlockSnapshot, ConsensusHash};
+use stacks::chainstate::coordinator::{get_next_recipients, OnChainRewardSetProvider};
+use stacks::chainstate::nakamoto::NakamotoChainState;
+use stacks::chainstate::stacks::address::PoxAddress;
+use stacks::chainstate::stacks::db::StacksChainState;
+use stacks::chainstate::stacks::miner::{
+    get_mining_spend_amount, signal_mining_blocked, signal_mining_ready,
+};
+use stacks::core::mempool::MemPoolDB;
+use stacks::core::FIRST_BURNCHAIN_CONSENSUS_HASH;
+use stacks::core::FIRST_STACKS_BLOCK_HASH;
+use stacks::core::STACKS_EPOCH_3_0_MARKER;
+use stacks::cost_estimates::metrics::UnitMetric;
+use stacks::cost_estimates::UnitEstimator;
+use stacks::monitoring::increment_stx_blocks_mined_counter;
+use stacks::net::db::LocalPeer;
+use stacks::net::relay::Relayer;
+use stacks::net::NetworkResult;
+use stacks_common::types::chainstate::{
+    BlockHeaderHash, BurnchainHeaderHash, StacksBlockId, VRFSeed,
+};
+use stacks_common::types::StacksEpochId;
+use stacks_common::util::get_epoch_time_ms;
+use stacks_common::util::hash::Hash160;
+use stacks_common::util::vrf::{VRFProof, VRFPublicKey};
+use std::collections::HashMap;
+use std::sync::mpsc::Receiver;
+use std::sync::mpsc::RecvTimeoutError;
+use std::thread::JoinHandle;
+use std::time::Duration;
+use std::time::Instant;
+
+use super::Error as NakamotoNodeError;
+use super::{
+    fault_injection_skip_mining, open_chainstate_with_faults, BlockCommits, Config,
+    EventDispatcher, Keychain, BLOCK_PROCESSOR_STACK_SIZE,
+};
+use crate::burnchains::BurnchainController;
+use crate::globals::Globals;
+use crate::globals::RelayerDirective;
+use crate::nakamoto_node::miner::{BlockMinerThread, MinerDirective};
+use crate::neon_node::LeaderKeyRegistrationState;
+use crate::run_loop::nakamoto::RunLoop;
+use crate::run_loop::RegisteredKey;
+use crate::BitcoinRegtestController;
+
+/// Relayer thread
+/// * accepts network results and stores blocks and microblocks
+/// * forwards new blocks, microblocks, and transactions to the p2p thread
+/// * processes burnchain state
+/// * if mining, runs the miner and broadcasts blocks (via a subordinate MinerThread)
+pub struct RelayerThread {
+    /// Node config
+    pub(crate) config: Config,
+    /// Handle to the sortition DB (optional so we can take/replace it)
+    sortdb: Option<SortitionDB>,
+    /// Handle to the chainstate DB (optional so we can take/replace it)
+    chainstate: Option<StacksChainState>,
+    /// Handle to the mempool DB (optional so we can take/replace it)
+    mempool: Option<MemPoolDB>,
+    /// Handle to global state and inter-thread communication channels
+    pub(crate) globals: Globals,
+    /// Authoritative copy of the keychain state
+    pub(crate) keychain: Keychain,
+    /// Burnchian configuration
+    pub(crate) burnchain: Burnchain,
+    /// height of last VRF key registration request
+    last_vrf_key_burn_height: Option<u64>,
+    /// Set of blocks that we have mined, but are still potentially-broadcastable
+    // TODO: this field is a slow leak!
+    pub(crate) last_commits: BlockCommits,
+    /// client to the burnchain (used only for sending block-commits)
+    pub(crate) bitcoin_controller: BitcoinRegtestController,
+    /// client to the event dispatcher
+    pub(crate) event_dispatcher: EventDispatcher,
+    /// copy of the local peer state
+    local_peer: LocalPeer,
+    /// last observed burnchain block height from the p2p thread (obtained from network results)
+    last_network_block_height: u64,
+    /// time at which we observed a change in the network block height (epoch time in millis)
+    last_network_block_height_ts: u128,
+    /// last observed number of downloader state-machine passes from the p2p thread (obtained from
+    /// network results)
+    last_network_download_passes: u64,
+    /// last observed number of inventory state-machine passes from the p2p thread (obtained from
+    /// network results)
+    last_network_inv_passes: u64,
+    /// minimum number of downloader state-machine passes that must take place before mining (this
+    /// is used to ensure that the p2p thread attempts to download new Stacks block data before
+    /// this thread tries to mine a block)
+    min_network_download_passes: u64,
+    /// minimum number of inventory state-machine passes that must take place before mining (this
+    /// is used to ensure that the p2p thread attempts to download new Stacks block data before
+    /// this thread tries to mine a block)
+    min_network_inv_passes: u64,
+
+    /// Inner relayer instance for forwarding broadcasted data back to the p2p thread for dispatch
+    /// to neighbors
+    relayer: Relayer,
+
+    /// handle to the subordinate miner thread
+    miner_thread: Option<JoinHandle<()>>,
+    /// The relayer thread reads directives from the relay_rcv, but it also periodically wakes up
+    ///  to check if it should issue a block commit or try to register a VRF key
+    next_initiative: Instant,
+    is_miner: bool,
+    /// This is the last snapshot in which the relayer committed
+    last_committed_at: Option<BlockSnapshot>,
+}
+
+impl RelayerThread {
+    /// Instantiate off of a StacksNode, a runloop, and a relayer.
+    pub fn new(runloop: &RunLoop, local_peer: LocalPeer, relayer: Relayer) -> RelayerThread {
+        let config = runloop.config().clone();
+        let globals = runloop.get_globals();
+        let burn_db_path = config.get_burn_db_file_path();
+        let stacks_chainstate_path = config.get_chainstate_path_str();
+        let is_mainnet = config.is_mainnet();
+        let chain_id = config.burnchain.chain_id;
+        let is_miner = runloop.is_miner();
+
+        let sortdb = SortitionDB::open(&burn_db_path, true, runloop.get_burnchain().pox_constants)
+            .expect("FATAL: failed to open burnchain DB");
+
+        let chainstate =
+            open_chainstate_with_faults(&config).expect("FATAL: failed to open chainstate DB");
+
+        let cost_estimator = config
+            .make_cost_estimator()
+            .unwrap_or_else(|| Box::new(UnitEstimator));
+        let metric = config
+            .make_cost_metric()
+            .unwrap_or_else(|| Box::new(UnitMetric));
+
+        let mempool = MemPoolDB::open(
+            is_mainnet,
+            chain_id,
+            &stacks_chainstate_path,
+            cost_estimator,
+            metric,
+        )
+        .expect("Database failure opening mempool");
+
+        let keychain = Keychain::default(config.node.seed.clone());
+        let bitcoin_controller = BitcoinRegtestController::new_dummy(config.clone());
+
+        RelayerThread {
+            config: config.clone(),
+            sortdb: Some(sortdb),
+            chainstate: Some(chainstate),
+            mempool: Some(mempool),
+            globals,
+            keychain,
+            burnchain: runloop.get_burnchain(),
+            last_vrf_key_burn_height: None,
+            last_commits: HashMap::new(),
+            bitcoin_controller,
+            event_dispatcher: runloop.get_event_dispatcher(),
+            local_peer,
+
+            last_network_block_height: 0,
+            last_network_block_height_ts: 0,
+            last_network_download_passes: 0,
+            min_network_download_passes: 0,
+            last_network_inv_passes: 0,
+            min_network_inv_passes: 0,
+
+            relayer,
+
+            miner_thread: None,
+            is_miner,
+            next_initiative: Instant::now() + Duration::from_secs(10),
+            last_committed_at: None,
+        }
+    }
+
+    /// Get an immutible ref to the sortdb
+    pub fn sortdb_ref(&self) -> &SortitionDB {
+        self.sortdb
+            .as_ref()
+            .expect("FATAL: tried to access sortdb while taken")
+    }
+
+    /// Get an immutible ref to the chainstate
+    pub fn chainstate_ref(&self) -> &StacksChainState {
+        self.chainstate
+            .as_ref()
+            .expect("FATAL: tried to access chainstate while it was taken")
+    }
+
+    /// Fool the borrow checker into letting us do something with the chainstate databases.
+    /// DOES NOT COMPOSE -- do NOT call this, or self.sortdb_ref(), or self.chainstate_ref(), within
+    /// `func`.  You will get a runtime panic.
+    pub fn with_chainstate<F, R>(&mut self, func: F) -> R
+    where
+        F: FnOnce(&mut RelayerThread, &mut SortitionDB, &mut StacksChainState, &mut MemPoolDB) -> R,
+    {
+        let mut sortdb = self
+            .sortdb
+            .take()
+            .expect("FATAL: tried to take sortdb while taken");
+        let mut chainstate = self
+            .chainstate
+            .take()
+            .expect("FATAL: tried to take chainstate while taken");
+        let mut mempool = self
+            .mempool
+            .take()
+            .expect("FATAL: tried to take mempool while taken");
+        let res = func(self, &mut sortdb, &mut chainstate, &mut mempool);
+        self.sortdb = Some(sortdb);
+        self.chainstate = Some(chainstate);
+        self.mempool = Some(mempool);
+        res
+    }
+
+    /// have we waited for the right conditions under which to start mining a block off of our
+    /// chain tip?
+    pub fn has_waited_for_latest_blocks(&self) -> bool {
+        // a network download pass took place
+        (self.min_network_download_passes <= self.last_network_download_passes
+        // a network inv pass took place
+        && self.min_network_download_passes <= self.last_network_download_passes)
+        // we waited long enough for a download pass, but timed out waiting
+        || self.last_network_block_height_ts + (self.config.node.wait_time_for_blocks as u128) < get_epoch_time_ms()
+        // we're not supposed to wait at all
+        || !self.config.miner.wait_for_block_download
+    }
+
+    /// Return debug string for waiting for latest blocks
+    pub fn debug_waited_for_latest_blocks(&self) -> String {
+        format!(
+            "({} <= {} && {} <= {}) || {} + {} < {} || {}",
+            self.min_network_download_passes,
+            self.last_network_download_passes,
+            self.min_network_inv_passes,
+            self.last_network_inv_passes,
+            self.last_network_block_height_ts,
+            self.config.node.wait_time_for_blocks,
+            get_epoch_time_ms(),
+            self.config.miner.wait_for_block_download
+        )
+    }
+
+    /// Handle a NetworkResult from the p2p/http state machine.  Usually this is the act of
+    /// * preprocessing and storing new blocks and microblocks
+    /// * relaying blocks, microblocks, and transacctions
+    /// * updating unconfirmed state views
+    pub fn process_network_result(&mut self, mut net_result: NetworkResult) {
+        debug!(
+            "Relayer: Handle network result (from {})",
+            net_result.burn_height
+        );
+
+        if self.last_network_block_height != net_result.burn_height {
+            // burnchain advanced; disable mining until we also do a download pass.
+            self.last_network_block_height = net_result.burn_height;
+            self.min_network_download_passes = net_result.num_download_passes + 1;
+            self.min_network_inv_passes = net_result.num_inv_sync_passes + 1;
+            self.last_network_block_height_ts = get_epoch_time_ms();
+            debug!(
+                "Relayer: block mining until the next download pass {}",
+                self.min_network_download_passes
+            );
+            signal_mining_blocked(self.globals.get_miner_status());
+        }
+
+        let net_receipts = self.with_chainstate(|relayer_thread, sortdb, chainstate, mempool| {
+            relayer_thread
+                .relayer
+                .process_network_result(
+                    &relayer_thread.local_peer,
+                    &mut net_result,
+                    sortdb,
+                    chainstate,
+                    mempool,
+                    relayer_thread.globals.sync_comms.get_ibd(),
+                    Some(&relayer_thread.globals.coord_comms),
+                    Some(&relayer_thread.event_dispatcher),
+                )
+                .expect("BUG: failure processing network results")
+        });
+
+        if net_receipts.num_new_blocks > 0 || net_receipts.num_new_confirmed_microblocks > 0 {
+            // if we received any new block data that could invalidate our view of the chain tip,
+            // then stop mining until we process it
+            debug!("Relayer: block mining to process newly-arrived blocks or microblocks");
+            signal_mining_blocked(self.globals.get_miner_status());
+        }
+
+        let mempool_txs_added = net_receipts.mempool_txs_added.len();
+        if mempool_txs_added > 0 {
+            self.event_dispatcher
+                .process_new_mempool_txs(net_receipts.mempool_txs_added);
+        }
+
+        let num_unconfirmed_microblock_tx_receipts =
+            net_receipts.processed_unconfirmed_state.receipts.len();
+        if num_unconfirmed_microblock_tx_receipts > 0 {
+            if let Some(unconfirmed_state) = self.chainstate_ref().unconfirmed_state.as_ref() {
+                let canonical_tip = unconfirmed_state.confirmed_chain_tip.clone();
+                self.event_dispatcher.process_new_microblocks(
+                    canonical_tip,
+                    net_receipts.processed_unconfirmed_state,
+                );
+            } else {
+                warn!("Relayer: oops, unconfirmed state is uninitialized but there are microblock events");
+            }
+        }
+
+        // Dispatch retrieved attachments, if any.
+        if net_result.has_attachments() {
+            self.event_dispatcher
+                .process_new_attachments(&net_result.attachments);
+        }
+
+        // synchronize unconfirmed tx index to p2p thread
+        self.with_chainstate(|relayer_thread, _sortdb, chainstate, _mempool| {
+            relayer_thread.globals.send_unconfirmed_txs(chainstate);
+        });
+
+        // resume mining if we blocked it, and if we've done the requisite download
+        // passes
+        self.last_network_download_passes = net_result.num_download_passes;
+        self.last_network_inv_passes = net_result.num_inv_sync_passes;
+        if self.has_waited_for_latest_blocks() {
+            debug!("Relayer: did a download pass, so unblocking mining");
+            signal_mining_ready(self.globals.get_miner_status());
+        }
+    }
+
+    /// Given the pointer to a recently processed sortition, see if we won the sortition.
+    ///
+    /// Returns `true` if we won this last sortition.
+    pub fn process_sortition(
+        &mut self,
+        consensus_hash: ConsensusHash,
+        burn_hash: BurnchainHeaderHash,
+        committed_index_hash: StacksBlockId,
+    ) -> MinerDirective {
+        let sn =
+            SortitionDB::get_block_snapshot_consensus(self.sortdb_ref().conn(), &consensus_hash)
+                .expect("FATAL: failed to query sortition DB")
+                .expect("FATAL: unknown consensus hash");
+
+        self.globals.set_last_sortition(sn.clone());
+
+        let won_sortition =
+            sn.sortition && self.last_commits.remove(&sn.winning_block_txid).is_some();
+
+        info!(
+            "Relayer: Process sortition";
+            "sortition_ch" => %consensus_hash,
+            "burn_hash" => %burn_hash,
+            "burn_height" => sn.block_height,
+            "winning_txid" => %sn.winning_block_txid,
+            "committed_parent" => %committed_index_hash,
+            "won_sortition?" => won_sortition,
+        );
+
+        if won_sortition {
+            increment_stx_blocks_mined_counter();
+        }
+
+        if sn.sortition {
+            if won_sortition {
+                MinerDirective::BeginTenure {
+                    parent_tenure_start: committed_index_hash,
+                    burnchain_tip: sn,
+                }
+            } else {
+                MinerDirective::StopTenure
+            }
+        } else {
+            MinerDirective::ContinueTenure {
+                new_burn_view: consensus_hash,
+            }
+        }
+    }
+
+    /// Constructs and returns a LeaderKeyRegisterOp out of the provided params
+    fn make_key_register_op(
+        vrf_public_key: VRFPublicKey,
+        consensus_hash: &ConsensusHash,
+        miner_pkh: &Hash160,
+    ) -> BlockstackOperationType {
+        BlockstackOperationType::LeaderKeyRegister(LeaderKeyRegisterOp {
+            public_key: vrf_public_key,
+            memo: miner_pkh.as_bytes().to_vec(),
+            consensus_hash: consensus_hash.clone(),
+            vtxindex: 0,
+            txid: Txid([0u8; 32]),
+            block_height: 0,
+            burn_header_hash: BurnchainHeaderHash::zero(),
+        })
+    }
+
+    /// Create and broadcast a VRF public key registration transaction.
+    /// Returns true if we succeed in doing so; false if not.
+    pub fn rotate_vrf_and_register(&mut self, burn_block: &BlockSnapshot) {
+        if self.last_vrf_key_burn_height.is_some() {
+            // already in-flight
+            return;
+        }
+        let cur_epoch =
+            SortitionDB::get_stacks_epoch(self.sortdb_ref().conn(), burn_block.block_height)
+                .expect("FATAL: failed to query sortition DB")
+                .expect("FATAL: no epoch defined")
+                .epoch_id;
+        let (vrf_pk, _) = self.keychain.make_vrf_keypair(burn_block.block_height);
+        let burnchain_tip_consensus_hash = &burn_block.consensus_hash;
+        let miner_pkh = self.keychain.get_nakamoto_pkh();
+
+        debug!(
+            "Submitting LeaderKeyRegister";
+            "vrf_pk" => vrf_pk.to_hex(),
+            "burn_block_height" => burn_block.block_height,
+            "miner_pkh" => miner_pkh.to_hex(),
+        );
+
+        let op = Self::make_key_register_op(vrf_pk, burnchain_tip_consensus_hash, &miner_pkh);
+
+        let mut op_signer = self.keychain.generate_op_signer();
+        if let Some(txid) =
+            self.bitcoin_controller
+                .submit_operation(cur_epoch, op, &mut op_signer, 1)
+        {
+            // advance key registration state
+            self.last_vrf_key_burn_height = Some(burn_block.block_height);
+            self.globals
+                .set_pending_leader_key_registration(burn_block.block_height, txid);
+            self.globals.counters.bump_naka_submitted_vrfs();
+        }
+    }
+
+    /// Produce the block-commit for this anchored block, if we can.
+    /// `target_ch` is the consensus-hash of the Tenure we will build off
+    /// `target_bh` is the block hash of the Tenure we will build off
+    /// Returns the (the most recent burn snapshot, the expected epoch, the commit-op) on success
+    /// Returns None if we fail somehow.
+    fn make_block_commit(
+        &mut self,
+        target_ch: &ConsensusHash,
+        target_bh: &BlockHeaderHash,
+    ) -> Result<(BlockSnapshot, StacksEpochId, LeaderBlockCommitOp), NakamotoNodeError> {
+        let chain_state = self
+            .chainstate
+            .as_mut()
+            .expect("FATAL: Failed to load chain state");
+        let sort_db = self.sortdb.as_mut().expect("FATAL: Failed to load sortdb");
+        let sort_tip = SortitionDB::get_canonical_burn_chain_tip(sort_db.conn())
+            .map_err(|_| NakamotoNodeError::SnapshotNotFoundForChainTip)?;
+
+        let parent_vrf_proof =
+            NakamotoChainState::get_block_vrf_proof(chain_state.db(), &target_ch)
+                .map_err(|_e| NakamotoNodeError::ParentNotFound)?
+                .unwrap_or_else(|| VRFProof::empty());
+
+        // let's figure out the recipient set!
+        let recipients = get_next_recipients(
+            &sort_tip,
+            chain_state,
+            sort_db,
+            &self.burnchain,
+            &OnChainRewardSetProvider(),
+            self.config.node.always_use_affirmation_maps,
+        )
+        .map_err(|e| {
+            error!("Relayer: Failure fetching recipient set: {:?}", e);
+            NakamotoNodeError::SnapshotNotFoundForChainTip
+        })?;
+
+        let block_header =
+            NakamotoChainState::get_block_header_by_consensus_hash(chain_state.db(), target_ch)
+                .map_err(|e| {
+                    error!("Relayer: Failed to get block header for parent tenure: {e:?}");
+                    NakamotoNodeError::ParentNotFound
+                })?
+                .ok_or_else(|| {
+                    error!("Relayer: Failed to find block header for parent tenure");
+                    NakamotoNodeError::ParentNotFound
+                })?;
+
+        let parent_block_id = block_header.index_block_hash();
+        if parent_block_id != StacksBlockId::new(target_ch, target_bh) {
+            error!("Relayer: Found block header for parent tenure, but mismatched block id";
+                   "expected_block_id" => %StacksBlockId::new(target_ch, target_bh),
+                   "found_block_id" => %parent_block_id);
+            return Err(NakamotoNodeError::UnexpectedChainState);
+        }
+
+        let Ok(Some(parent_sortition)) =
+            SortitionDB::get_block_snapshot_consensus(sort_db.conn(), target_ch)
+        else {
+            error!("Relayer: Failed to lookup the block snapshot of parent tenure ID"; "tenure_consensus_hash" => %target_ch);
+            return Err(NakamotoNodeError::ParentNotFound);
+        };
+
+        let Ok(Some(target_epoch)) =
+            SortitionDB::get_stacks_epoch(sort_db.conn(), sort_tip.block_height + 1)
+        else {
+            error!("Relayer: Failed to lookup its epoch"; "target_height" => sort_tip.block_height + 1);
+            return Err(NakamotoNodeError::SnapshotNotFoundForChainTip);
+        };
+
+        let parent_block_burn_height = parent_sortition.block_height;
+        let Ok(Some(parent_winning_tx)) = SortitionDB::get_block_commit(
+            sort_db.conn(),
+            &parent_sortition.winning_block_txid,
+            &parent_sortition.sortition_id,
+        ) else {
+            error!("Relayer: Failed to lookup the block commit of parent tenure ID"; "tenure_consensus_hash" => %target_ch);
+            return Err(NakamotoNodeError::SnapshotNotFoundForChainTip);
+        };
+
+        let parent_winning_vtxindex = parent_winning_tx.vtxindex;
+
+        // let burn_fee_cap = self.config.burnchain.burn_fee_cap;
+        let burn_fee_cap = get_mining_spend_amount(self.globals.get_miner_status());
+        let sunset_burn = self.burnchain.expected_sunset_burn(
+            sort_tip.block_height + 1,
+            burn_fee_cap,
+            target_epoch.epoch_id,
+        );
+        let rest_commit = burn_fee_cap - sunset_burn;
+
+        let commit_outs = if !self
+            .burnchain
+            .pox_constants
+            .is_after_pox_sunset_end(sort_tip.block_height, target_epoch.epoch_id)
+            && !self
+                .burnchain
+                .is_in_prepare_phase(sort_tip.block_height + 1)
+        {
+            RewardSetInfo::into_commit_outs(recipients, self.config.is_mainnet())
+        } else {
+            vec![PoxAddress::standard_burn_address(self.config.is_mainnet())]
+        };
+
+        // let's commit, but target the current burnchain tip with our modulus
+        let burn_parent_modulus = u8::try_from(sort_tip.block_height % BURN_BLOCK_MINED_AT_MODULUS)
+            .map_err(|_| {
+                error!("Relayer: Block mining modulus is not u8");
+                NakamotoNodeError::UnexpectedChainState
+            })?;
+        let sender = self.keychain.get_burnchain_signer();
+        let key = self
+            .globals
+            .get_leader_key_registration_state()
+            .get_active()
+            .ok_or_else(|| NakamotoNodeError::NoVRFKeyActive)?;
+        let op = LeaderBlockCommitOp {
+            sunset_burn,
+            block_header_hash: BlockHeaderHash(parent_block_id.0),
+            burn_fee: rest_commit,
+            input: (Txid([0; 32]), 0),
+            apparent_sender: sender,
+            key_block_ptr: u32::try_from(key.block_height)
+                .expect("FATAL: burn block height exceeded u32"),
+            key_vtxindex: u16::try_from(key.op_vtxindex).expect("FATAL: vtxindex exceeded u16"),
+            memo: vec![STACKS_EPOCH_3_0_MARKER],
+            new_seed: VRFSeed::from_proof(&parent_vrf_proof),
+            parent_block_ptr: u32::try_from(parent_block_burn_height)
+                .expect("FATAL: burn block height exceeded u32"),
+            parent_vtxindex: u16::try_from(parent_winning_vtxindex)
+                .expect("FATAL: vtxindex exceeded u16"),
+            vtxindex: 0,
+            txid: Txid([0u8; 32]),
+            block_height: 0,
+            burn_header_hash: BurnchainHeaderHash::zero(),
+            burn_parent_modulus,
+            commit_outs,
+        };
+
+        Ok((sort_tip, target_epoch.epoch_id, op))
+    }
+
+    /// Create the block miner thread state.
+    /// Only proceeds if all of the following are true:
+    /// * the miner is not blocked
+    /// * last_burn_block corresponds to the canonical sortition DB's chain tip
+    /// * the time of issuance is sufficiently recent
+    /// * there are no unprocessed stacks blocks in the staging DB
+    /// * the relayer has already tried a download scan that included this sortition (which, if a
+    /// block was found, would have placed it into the staging DB and marked it as
+    /// unprocessed)
+    /// * a miner thread is not running already
+    fn create_block_miner(
+        &mut self,
+        registered_key: RegisteredKey,
+        last_burn_block: BlockSnapshot,
+        parent_tenure_id: StacksBlockId,
+    ) -> Result<BlockMinerThread, NakamotoNodeError> {
+        if fault_injection_skip_mining(&self.config.node.rpc_bind, last_burn_block.block_height) {
+            debug!(
+                "Relayer: fault injection skip mining at block height {}",
+                last_burn_block.block_height
+            );
+            return Err(NakamotoNodeError::FaultInjection);
+        }
+
+        let burn_header_hash = last_burn_block.burn_header_hash.clone();
+        let burn_chain_sn = SortitionDB::get_canonical_burn_chain_tip(self.sortdb_ref().conn())
+            .expect("FATAL: failed to query sortition DB for canonical burn chain tip");
+
+        let burn_chain_tip = burn_chain_sn.burn_header_hash.clone();
+
+        if burn_chain_tip != burn_header_hash {
+            debug!(
+                "Relayer: Drop stale RunTenure for {}: current sortition is for {}",
+                &burn_header_hash, &burn_chain_tip
+            );
+            self.globals.counters.bump_missed_tenures();
+            return Err(NakamotoNodeError::MissedMiningOpportunity);
+        }
+
+        debug!(
+            "Relayer: Spawn tenure thread";
+            "height" => last_burn_block.block_height,
+            "burn_header_hash" => %burn_header_hash,
+        );
+
+        let miner_thread_state =
+            BlockMinerThread::new(self, registered_key, last_burn_block, parent_tenure_id);
+        Ok(miner_thread_state)
+    }
+
+    fn start_new_tenure(
+        &mut self,
+        parent_tenure_start: StacksBlockId,
+        burn_tip: BlockSnapshot,
+    ) -> Result<(), NakamotoNodeError> {
+        // when starting a new tenure, block the mining thread if its currently running.
+        // the new mining thread will join it (so that the new mining thread stalls, not the relayer)
+        let prior_tenure_thread = self.miner_thread.take();
+        let vrf_key = self
+            .globals
+            .get_leader_key_registration_state()
+            .get_active()
+            .ok_or_else(|| {
+                warn!("Trying to start new tenure, but no VRF key active");
+                NakamotoNodeError::NoVRFKeyActive
+            })?;
+        let new_miner_state = self.create_block_miner(vrf_key, burn_tip, parent_tenure_start)?;
+
+        let new_miner_handle = std::thread::Builder::new()
+            .name(format!("miner-{}", self.local_peer.data_url))
+            .stack_size(BLOCK_PROCESSOR_STACK_SIZE)
+            .spawn(move || new_miner_state.run_miner(prior_tenure_thread))
+            .map_err(|e| {
+                error!("Relayer: Failed to start tenure thread: {:?}", &e);
+                NakamotoNodeError::SpawnError(e)
+            })?;
+
+        self.miner_thread.replace(new_miner_handle);
+
+        Ok(())
+    }
+
+    fn stop_tenure(&mut self) -> Result<(), NakamotoNodeError> {
+        // when stopping a tenure, block the mining thread if its currently running, then join it.
+        // do this in a new thread will (so that the new thread stalls, not the relayer)
+        let Some(prior_tenure_thread) = self.miner_thread.take() else {
+            return Ok(());
+        };
+        let globals = self.globals.clone();
+
+        let stop_handle = std::thread::Builder::new()
+            .name(format!("tenure-stop-{}", self.local_peer.data_url))
+            .spawn(move || BlockMinerThread::stop_miner(&globals, prior_tenure_thread))
+            .map_err(|e| {
+                error!("Relayer: Failed to spawn a stop-tenure thread: {:?}", &e);
+                NakamotoNodeError::SpawnError(e)
+            })?;
+
+        self.miner_thread.replace(stop_handle);
+
+        Ok(())
+    }
+
+    fn handle_sortition(
+        &mut self,
+        consensus_hash: ConsensusHash,
+        burn_hash: BurnchainHeaderHash,
+        committed_index_hash: StacksBlockId,
+    ) -> bool {
+        let miner_instruction =
+            self.process_sortition(consensus_hash, burn_hash, committed_index_hash);
+
+        match miner_instruction {
+            MinerDirective::BeginTenure {
+                parent_tenure_start,
+                burnchain_tip,
+            } => {
+                let _ = self.start_new_tenure(parent_tenure_start, burnchain_tip);
+            }
+            MinerDirective::ContinueTenure { new_burn_view: _ } => {
+                // TODO: in this case, we eventually want to undergo a tenure
+                //  change to switch to the new burn view, but right now, we will
+                //  simply end our current tenure if it exists
+                let _ = self.stop_tenure();
+            }
+            MinerDirective::StopTenure => {
+                let _ = self.stop_tenure();
+            }
+        }
+
+        true
+    }
+
+    fn issue_block_commit(
+        &mut self,
+        tenure_start_ch: ConsensusHash,
+        tenure_start_bh: BlockHeaderHash,
+    ) -> Result<(), NakamotoNodeError> {
+        let (last_committed_at, target_epoch_id, commit) =
+            self.make_block_commit(&tenure_start_ch, &tenure_start_bh)?;
+        let mut op_signer = self.keychain.generate_op_signer();
+        let txid = self
+            .bitcoin_controller
+            .submit_operation(
+                target_epoch_id,
+                BlockstackOperationType::LeaderBlockCommit(commit),
+                &mut op_signer,
+                1,
+            )
+            .ok_or_else(|| {
+                warn!("Failed to submit block-commit bitcoin transaction");
+                NakamotoNodeError::BurnchainSubmissionFailed
+            })?;
+        info!(
+            "Relayer: Submitted block-commit";
+            "parent_consensus_hash" => %tenure_start_ch,
+            "parent_block_hash" => %tenure_start_bh,
+            "txid" => %txid,
+        );
+
+        self.last_commits.insert(txid, ());
+        self.last_committed_at = Some(last_committed_at);
+        self.globals.counters.bump_naka_submitted_commits();
+
+        Ok(())
+    }
+
+    fn initiative(&mut self) -> Option<RelayerDirective> {
+        if !self.is_miner {
+            return None;
+        }
+
+        // TODO (nakamoto): the miner shouldn't issue either of these directives
+        //   if we're still in IBD!
+
+        // do we need a VRF key registration?
+        if matches!(
+            self.globals.get_leader_key_registration_state(),
+            LeaderKeyRegistrationState::Inactive
+        ) {
+            let Ok(sort_tip) = SortitionDB::get_canonical_burn_chain_tip(self.sortdb_ref().conn())
+            else {
+                warn!("Failed to fetch sortition tip while needing to register VRF key");
+                return None;
+            };
+            return Some(RelayerDirective::RegisterKey(sort_tip));
+        }
+
+        // are we still waiting on a pending registration?
+        if !matches!(
+            self.globals.get_leader_key_registration_state(),
+            LeaderKeyRegistrationState::Active(_)
+        ) {
+            return None;
+        }
+
+        // has there been a new sortition
+        let Ok(sort_tip) = SortitionDB::get_canonical_burn_chain_tip(self.sortdb_ref().conn())
+        else {
+            return None;
+        };
+
+        let should_commit = if let Some(last_committed_at) = self.last_committed_at.as_ref() {
+            // if the new sortition tip has a different consesus hash than the last commit,
+            //  issue a new commit
+            sort_tip.consensus_hash != last_committed_at.consensus_hash
+        } else {
+            // if there was no last commit, issue a new commit
+            true
+        };
+
+        let Ok(Some(chain_tip_header)) = NakamotoChainState::get_canonical_block_header(
+            self.chainstate_ref().db(),
+            self.sortdb_ref(),
+        ) else {
+            info!("No known canonical tip, will issue a genesis block commit");
+            return Some(RelayerDirective::NakamotoTenureStartProcessed(
+                FIRST_BURNCHAIN_CONSENSUS_HASH,
+                FIRST_STACKS_BLOCK_HASH,
+            ));
+        };
+
+        if should_commit {
+            // TODO: just use `get_block_header_by_consensus_hash`?
+            let first_block_hash = if chain_tip_header
+                .anchored_header
+                .as_stacks_nakamoto()
+                .is_some()
+            {
+                // if the parent block is a nakamoto block, find the starting block of its tenure
+                let Ok(Some(first_block)) =
+                    NakamotoChainState::get_nakamoto_tenure_start_block_header(
+                        self.chainstate_ref().db(),
+                        &chain_tip_header.consensus_hash,
+                    )
+                else {
+                    warn!("Failure getting the first block of tenure in order to assemble block commit";
+                          "tenure_consensus_hash" => %chain_tip_header.consensus_hash,
+                          "tip_block_hash" => %chain_tip_header.anchored_header.block_hash());
+                    return None;
+                };
+                first_block.anchored_header.block_hash()
+            } else {
+                // otherwise the parent block is a epoch2 block, just return its hash directly
+                chain_tip_header.anchored_header.block_hash()
+            };
+            return Some(RelayerDirective::NakamotoTenureStartProcessed(
+                chain_tip_header.consensus_hash,
+                first_block_hash,
+            ));
+        }
+
+        return None;
+    }
+
+    /// Main loop of the relayer.
+    /// Runs in a separate thread.
+    /// Continuously receives
+    pub fn main(mut self, relay_rcv: Receiver<RelayerDirective>) {
+        debug!("relayer thread ID is {:?}", std::thread::current().id());
+
+        self.next_initiative = Instant::now() + Duration::from_secs(10);
+        while self.globals.keep_running() {
+            let directive = if Instant::now() >= self.next_initiative {
+                self.next_initiative = Instant::now() + Duration::from_secs(10);
+                self.initiative()
+            } else {
+                None
+            };
+
+            let Some(timeout) = self.next_initiative.checked_duration_since(Instant::now()) else {
+                // next_initiative timeout occurred, so go to next loop iteration.
+                continue;
+            };
+
+            let directive = if let Some(directive) = directive {
+                directive
+            } else {
+                match relay_rcv.recv_timeout(timeout) {
+                    Ok(directive) => directive,
+                    // timed out, so go to next loop iteration
+                    Err(RecvTimeoutError::Timeout) => continue,
+                    Err(RecvTimeoutError::Disconnected) => break,
+                }
+            };
+
+            if !self.handle_directive(directive) {
+                break;
+            }
+        }
+
+        // kill miner if it's running
+        signal_mining_blocked(self.globals.get_miner_status());
+
+        // set termination flag so other threads die
+        self.globals.signal_stop();
+
+        debug!("Relayer exit!");
+    }
+
+    /// Top-level dispatcher
+    pub fn handle_directive(&mut self, directive: RelayerDirective) -> bool {
+        let continue_running = match directive {
+            RelayerDirective::HandleNetResult(net_result) => {
+                debug!("Relayer: directive Handle network result");
+                self.process_network_result(net_result);
+                debug!("Relayer: directive Handled network result");
+                true
+            }
+            // RegisterKey directives mean that the relayer should try to register a new VRF key.
+            // These are triggered by the relayer waking up without an active VRF key.
+            RelayerDirective::RegisterKey(last_burn_block) => {
+                if !self.is_miner {
+                    return true;
+                }
+                debug!("Relayer: directive Register VRF key");
+                self.rotate_vrf_and_register(&last_burn_block);
+                self.globals.counters.bump_blocks_processed();
+                debug!("Relayer: directive Registered VRF key");
+                true
+            }
+            // ProcessTenure directives correspond to a new sortition occurring.
+            //  relayer should invoke `handle_sortition` to determine if they won the sortition,
+            //  and to start their miner, or stop their miner if an active tenure is now ending
+            RelayerDirective::ProcessTenure(consensus_hash, burn_hash, block_header_hash) => {
+                if !self.is_miner {
+                    return true;
+                }
+                info!("Relayer: directive Process tenures");
+                let res = self.handle_sortition(
+                    consensus_hash,
+                    burn_hash,
+                    StacksBlockId(block_header_hash.0),
+                );
+                info!("Relayer: directive Processed tenures");
+                res
+            }
+            // NakamotoTenureStartProcessed directives mean that a new tenure start has been processed
+            // These are triggered by the relayer waking up, seeing a new consensus hash *and* a new first tenure block
+            RelayerDirective::NakamotoTenureStartProcessed(consensus_hash, block_hash) => {
+                if !self.is_miner {
+                    return true;
+                }
+                debug!("Relayer: Nakamoto Tenure Start");
+                if let Err(e) = self.issue_block_commit(consensus_hash, block_hash) {
+                    warn!("Relayer failed to issue block commit"; "err" => ?e);
+                }
+                debug!("Relayer: Nakamoto Tenure Start");
+                true
+            }
+            RelayerDirective::RunTenure(..) => {
+                // No Op: the nakamoto node does not use the RunTenure directive to control its
+                //   miner thread.
+                true
+            }
+            RelayerDirective::Exit => false,
+        };
+
+        continue_running
+    }
+}
diff --git a/testnet/stacks-node/src/neon_node.rs b/testnet/stacks-node/src/neon_node.rs
index 5ef68a4c28..c23bf1fc19 100644
--- a/testnet/stacks-node/src/neon_node.rs
+++ b/testnet/stacks-node/src/neon_node.rs
@@ -142,9 +142,7 @@ use std::collections::{HashMap, VecDeque};
 use std::convert::{TryFrom, TryInto};
 use std::default::Default;
 use std::net::SocketAddr;
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::mpsc::{Receiver, SyncSender, TrySendError};
-use std::sync::{Arc, Mutex};
+use std::sync::mpsc::{Receiver, TrySendError};
 use std::thread::JoinHandle;
 use std::time::Duration;
 use std::{mem, thread};
@@ -162,15 +160,13 @@ use stacks::chainstate::burn::operations::{
     BlockstackOperationType, LeaderBlockCommitOp, LeaderKeyRegisterOp,
 };
 use stacks::chainstate::burn::{BlockSnapshot, ConsensusHash};
-use stacks::chainstate::coordinator::comm::CoordinatorChannels;
 use stacks::chainstate::coordinator::{get_next_recipients, OnChainRewardSetProvider};
 use stacks::chainstate::nakamoto::NakamotoChainState;
 use stacks::chainstate::stacks::address::PoxAddress;
-use stacks::chainstate::stacks::db::unconfirmed::UnconfirmedTxMap;
 use stacks::chainstate::stacks::db::{StacksChainState, StacksHeaderInfo, MINER_REWARD_MATURITY};
 use stacks::chainstate::stacks::miner::{
     get_mining_spend_amount, signal_mining_blocked, signal_mining_ready, BlockBuilderSettings,
-    MinerStatus, StacksMicroblockBuilder,
+    StacksMicroblockBuilder,
 };
 use stacks::chainstate::stacks::{
     CoinbasePayload, Error as ChainstateError, StacksBlock, StacksBlockBuilder, StacksBlockHeader,
@@ -210,9 +206,10 @@ use crate::burnchains::bitcoin_regtest_controller::{
     addr2str, BitcoinRegtestController, OngoingBlockCommit,
 };
 use crate::burnchains::make_bitcoin_indexer;
-use crate::run_loop::neon::{Counters, RunLoop};
+use crate::globals::Globals;
+use crate::globals::RelayerDirective;
+use crate::run_loop::neon::RunLoop;
 use crate::run_loop::RegisteredKey;
-use crate::syncctl::PoxSyncWatchdogComms;
 use crate::ChainTip;
 
 pub const RELAYER_MAX_BUFFER: usize = 100;
@@ -256,44 +253,6 @@ struct AssembledAnchorBlock {
     tenure_begin: u128,
 }
 
-/// Command types for the relayer thread, issued to it by other threads
-pub enum RelayerDirective {
-    /// Handle some new data that arrived on the network (such as blocks, transactions, and
-    /// microblocks)
-    HandleNetResult(NetworkResult),
-    /// Announce a new sortition.  Process and broadcast the block if we won.
-    ProcessTenure(ConsensusHash, BurnchainHeaderHash, BlockHeaderHash),
-    /// Try to mine a block
-    RunTenure(RegisteredKey, BlockSnapshot, u128), // (vrf key, chain tip, time of issuance in ms)
-    /// Try to register a VRF public key
-    RegisterKey(BlockSnapshot),
-    /// Stop the relayer thread
-    Exit,
-}
-
-/// Inter-thread communication structure, shared between threads
-#[derive(Clone)]
-pub struct Globals {
-    /// Last sortition processed
-    last_sortition: Arc<Mutex<Option<BlockSnapshot>>>,
-    /// Status of the miner
-    miner_status: Arc<Mutex<MinerStatus>>,
-    /// Communication link to the coordinator thread
-    coord_comms: CoordinatorChannels,
-    /// Unconfirmed transactions (shared between the relayer and p2p threads)
-    unconfirmed_txs: Arc<Mutex<UnconfirmedTxMap>>,
-    /// Writer endpoint to the relayer thread
-    relay_send: SyncSender<RelayerDirective>,
-    /// Cointer state in the main thread
-    counters: Counters,
-    /// Connection to the PoX sync watchdog
-    sync_comms: PoxSyncWatchdogComms,
-    /// Global flag to see if we should keep running
-    pub should_keep_running: Arc<AtomicBool>,
-    /// Status of our VRF key registration state (shared between the main thread and the relayer)
-    leader_key_registration_state: Arc<Mutex<LeaderKeyRegistrationState>>,
-}
-
 /// Miner chain tip, on top of which to build microblocks
 #[derive(Debug, Clone, PartialEq)]
 pub struct MinerTip {
@@ -327,205 +286,6 @@ impl MinerTip {
     }
 }
 
-impl Globals {
-    pub fn new(
-        coord_comms: CoordinatorChannels,
-        miner_status: Arc<Mutex<MinerStatus>>,
-        relay_send: SyncSender<RelayerDirective>,
-        counters: Counters,
-        sync_comms: PoxSyncWatchdogComms,
-        should_keep_running: Arc<AtomicBool>,
-    ) -> Globals {
-        Globals {
-            last_sortition: Arc::new(Mutex::new(None)),
-            miner_status,
-            coord_comms,
-            unconfirmed_txs: Arc::new(Mutex::new(UnconfirmedTxMap::new())),
-            relay_send,
-            counters,
-            sync_comms,
-            should_keep_running,
-            leader_key_registration_state: Arc::new(Mutex::new(
-                LeaderKeyRegistrationState::Inactive,
-            )),
-        }
-    }
-
-    /// Get the last sortition processed by the relayer thread
-    pub fn get_last_sortition(&self) -> Option<BlockSnapshot> {
-        match self.last_sortition.lock() {
-            Ok(sort_opt) => sort_opt.clone(),
-            Err(_) => {
-                error!("Sortition mutex poisoned!");
-                panic!();
-            }
-        }
-    }
-
-    /// Set the last sortition processed
-    pub fn set_last_sortition(&self, block_snapshot: BlockSnapshot) {
-        match self.last_sortition.lock() {
-            Ok(mut sortition_opt) => {
-                sortition_opt.replace(block_snapshot);
-            }
-            Err(_) => {
-                error!("Sortition mutex poisoned!");
-                panic!();
-            }
-        };
-    }
-
-    /// Get the status of the miner (blocked or ready)
-    pub fn get_miner_status(&self) -> Arc<Mutex<MinerStatus>> {
-        self.miner_status.clone()
-    }
-
-    /// Get the main thread's counters
-    pub fn get_counters(&self) -> Counters {
-        self.counters.clone()
-    }
-
-    /// Called by the relayer to pass unconfirmed txs to the p2p thread, so the p2p thread doesn't
-    /// need to do the disk I/O needed to instantiate the unconfirmed state trie they represent.
-    /// Clears the unconfirmed transactions, and replaces them with the chainstate's.
-    pub fn send_unconfirmed_txs(&self, chainstate: &StacksChainState) {
-        if let Some(ref unconfirmed) = chainstate.unconfirmed_state {
-            match self.unconfirmed_txs.lock() {
-                Ok(mut txs) => {
-                    txs.clear();
-                    txs.extend(unconfirmed.mined_txs.clone());
-                }
-                Err(e) => {
-                    // can only happen due to a thread panic in the relayer
-                    error!("FATAL: unconfirmed tx arc mutex is poisoned: {:?}", &e);
-                    panic!();
-                }
-            };
-        }
-    }
-
-    /// Called by the p2p thread to accept the unconfirmed tx state processed by the relayer.
-    /// Puts the shared unconfirmed transactions to chainstate.
-    pub fn recv_unconfirmed_txs(&self, chainstate: &mut StacksChainState) {
-        if let Some(ref mut unconfirmed) = chainstate.unconfirmed_state {
-            match self.unconfirmed_txs.lock() {
-                Ok(txs) => {
-                    unconfirmed.mined_txs.clear();
-                    unconfirmed.mined_txs.extend(txs.clone());
-                }
-                Err(e) => {
-                    // can only happen due to a thread panic in the relayer
-                    error!("FATAL: unconfirmed arc mutex is poisoned: {:?}", &e);
-                    panic!();
-                }
-            };
-        }
-    }
-
-    /// Signal system-wide stop
-    pub fn signal_stop(&self) {
-        self.should_keep_running.store(false, Ordering::SeqCst);
-    }
-
-    /// Should we keep running?
-    pub fn keep_running(&self) -> bool {
-        self.should_keep_running.load(Ordering::SeqCst)
-    }
-
-    /// Get the handle to the coordinator
-    pub fn coord(&self) -> &CoordinatorChannels {
-        &self.coord_comms
-    }
-
-    /// Get the current leader key registration state.
-    /// Called from the runloop thread and relayer thread.
-    fn get_leader_key_registration_state(&self) -> LeaderKeyRegistrationState {
-        match self.leader_key_registration_state.lock() {
-            Ok(state) => (*state).clone(),
-            Err(e) => {
-                // can only happen due to a thread panic in the relayer
-                error!("FATAL: leader key registration mutex is poisoned: {:?}", &e);
-                panic!();
-            }
-        }
-    }
-
-    /// Set the initial leader key registration state.
-    /// Called from the runloop thread when booting up.
-    fn set_initial_leader_key_registration_state(&self, new_state: LeaderKeyRegistrationState) {
-        match self.leader_key_registration_state.lock() {
-            Ok(mut state) => {
-                *state = new_state;
-            }
-            Err(e) => {
-                // can only happen due to a thread panic in the relayer
-                error!("FATAL: leader key registration mutex is poisoned: {:?}", &e);
-                panic!();
-            }
-        }
-    }
-
-    /// Advance the leader key registration state to pending, given a txid we just sent.
-    /// Only the relayer thread calls this.
-    fn set_pending_leader_key_registration(&self, target_block_height: u64, txid: Txid) {
-        match self.leader_key_registration_state.lock() {
-            Ok(ref mut leader_key_registration_state) => {
-                **leader_key_registration_state =
-                    LeaderKeyRegistrationState::Pending(target_block_height, txid);
-            }
-            Err(_e) => {
-                error!("FATAL: failed to lock leader key registration state mutex");
-                panic!();
-            }
-        }
-    }
-
-    /// Advance the leader key registration state to active, given the VRF key registration ops
-    /// we've discovered in a given snapshot.
-    /// The runloop thread calls this whenever it processes a sortition.
-    pub fn try_activate_leader_key_registration(
-        &self,
-        burn_block_height: u64,
-        key_registers: Vec<LeaderKeyRegisterOp>,
-    ) -> bool {
-        let mut activated = false;
-        match self.leader_key_registration_state.lock() {
-            Ok(ref mut leader_key_registration_state) => {
-                for op in key_registers.into_iter() {
-                    if let LeaderKeyRegistrationState::Pending(target_block_height, txid) =
-                        **leader_key_registration_state
-                    {
-                        info!(
-                            "Received burnchain block #{} including key_register_op - {}",
-                            burn_block_height, txid
-                        );
-                        if txid == op.txid {
-                            **leader_key_registration_state =
-                                LeaderKeyRegistrationState::Active(RegisteredKey {
-                                    target_block_height,
-                                    vrf_public_key: op.public_key,
-                                    block_height: u64::from(op.block_height),
-                                    op_vtxindex: u32::from(op.vtxindex),
-                                });
-                            activated = true;
-                        } else {
-                            debug!(
-                                "key_register_op {} does not match our pending op {}",
-                                txid, &op.txid
-                            );
-                        }
-                    }
-                }
-            }
-            Err(_e) => {
-                error!("FATAL: failed to lock leader key registration state mutex");
-                panic!();
-            }
-        }
-        activated
-    }
-}
-
 /// Node implementation for both miners and followers.
 /// This struct is used to set up the node proper and launch the p2p thread and relayer thread.
 /// It is further used by the main thread to communicate with these two threads.
@@ -653,7 +413,7 @@ struct ParentStacksBlockInfo {
 }
 
 #[derive(Clone)]
-enum LeaderKeyRegistrationState {
+pub enum LeaderKeyRegistrationState {
     /// Not started yet
     Inactive,
     /// Waiting for burnchain confirmation
@@ -664,6 +424,16 @@ enum LeaderKeyRegistrationState {
     Active(RegisteredKey),
 }
 
+impl LeaderKeyRegistrationState {
+    pub fn get_active(&self) -> Option<RegisteredKey> {
+        if let Self::Active(registered_key) = self {
+            Some(registered_key.clone())
+        } else {
+            None
+        }
+    }
+}
+
 /// Relayer thread
 /// * accepts network results and stores blocks and microblocks
 /// * forwards new blocks, microblocks, and transactions to the p2p thread
@@ -3407,6 +3177,10 @@ impl RelayerThread {
                 debug!("Relayer: directive Ran tenure");
                 true
             }
+            RelayerDirective::NakamotoTenureStartProcessed(_, _) => {
+                warn!("Relayer: Nakamoto tenure start notification received while still operating 2.x neon node");
+                true
+            }
             RelayerDirective::Exit => false,
         };
         if !continue_running {
diff --git a/testnet/stacks-node/src/run_loop/mod.rs b/testnet/stacks-node/src/run_loop/mod.rs
index c7aaf87b56..abfbe37c37 100644
--- a/testnet/stacks-node/src/run_loop/mod.rs
+++ b/testnet/stacks-node/src/run_loop/mod.rs
@@ -1,4 +1,5 @@
 pub mod helium;
+pub mod nakamoto;
 pub mod neon;
 
 use clarity::vm::costs::ExecutionCost;
diff --git a/testnet/stacks-node/src/run_loop/nakamoto.rs b/testnet/stacks-node/src/run_loop/nakamoto.rs
new file mode 100644
index 0000000000..f758a65d33
--- /dev/null
+++ b/testnet/stacks-node/src/run_loop/nakamoto.rs
@@ -0,0 +1,1029 @@
+use std::sync::atomic::AtomicBool;
+use std::sync::mpsc::sync_channel;
+use std::sync::{Arc, Mutex};
+use std::thread::JoinHandle;
+use std::{cmp, thread};
+
+use stacks::burnchains::bitcoin::address::{BitcoinAddress, LegacyBitcoinAddressType};
+use stacks::burnchains::Burnchain;
+use stacks::chainstate::burn::db::sortdb::SortitionDB;
+use stacks::chainstate::burn::BlockSnapshot;
+use stacks::chainstate::coordinator::comm::{CoordinatorChannels, CoordinatorReceivers};
+use stacks::chainstate::coordinator::{
+    static_get_canonical_affirmation_map, static_get_heaviest_affirmation_map,
+    static_get_stacks_tip_affirmation_map, ChainsCoordinator, ChainsCoordinatorConfig,
+    CoordinatorCommunication,
+};
+use stacks::chainstate::stacks::db::{ChainStateBootData, StacksChainState};
+use stacks::chainstate::stacks::miner::{signal_mining_blocked, signal_mining_ready, MinerStatus};
+use stacks::core::StacksEpochId;
+use stacks::net::atlas::{AtlasConfig, AtlasDB, Attachment};
+use stacks_common::types::PublicKey;
+use stacks_common::util::hash::Hash160;
+use stacks_common::util::{get_epoch_time_secs, sleep_ms};
+use stx_genesis::GenesisData;
+
+use super::RunLoopCallbacks;
+use crate::burnchains::make_bitcoin_indexer;
+use crate::globals::Globals;
+use crate::monitoring::start_serving_monitoring_metrics;
+use crate::nakamoto_node::{StacksNode, BLOCK_PROCESSOR_STACK_SIZE, RELAYER_MAX_BUFFER};
+use crate::neon::RunLoopCounter;
+use crate::node::{
+    get_account_balances, get_account_lockups, get_names, get_namespaces,
+    use_test_genesis_chainstate,
+};
+use crate::run_loop::neon;
+use crate::run_loop::neon::Counters;
+use crate::syncctl::{PoxSyncWatchdog, PoxSyncWatchdogComms};
+use crate::{
+    run_loop, BitcoinRegtestController, BurnchainController, Config, EventDispatcher, Keychain,
+};
+
+pub const STDERR: i32 = 2;
+
+#[cfg(test)]
+const UNCONDITIONAL_CHAIN_LIVENESS_CHECK: u64 = 30;
+
+#[cfg(not(test))]
+const UNCONDITIONAL_CHAIN_LIVENESS_CHECK: u64 = 300;
+
+/// Coordinating a node running in neon mode.
+pub struct RunLoop {
+    config: Config,
+    pub callbacks: RunLoopCallbacks,
+    globals: Option<Globals>,
+    counters: Counters,
+    coordinator_channels: Option<(CoordinatorReceivers, CoordinatorChannels)>,
+    should_keep_running: Arc<AtomicBool>,
+    event_dispatcher: EventDispatcher,
+    pox_watchdog: Option<PoxSyncWatchdog>, // can't be instantiated until .start() is called
+    is_miner: Option<bool>,                // not known until .start() is called
+    burnchain: Option<Burnchain>,          // not known until .start() is called
+    pox_watchdog_comms: PoxSyncWatchdogComms,
+    /// NOTE: this is duplicated in self.globals, but it needs to be accessible before globals is
+    /// instantiated (namely, so the test framework can access it).
+    miner_status: Arc<Mutex<MinerStatus>>,
+}
+
+impl RunLoop {
+    /// Sets up a runloop and node, given a config.
+    pub fn new(config: Config) -> Self {
+        let channels = CoordinatorCommunication::instantiate();
+        let should_keep_running = Arc::new(AtomicBool::new(true));
+        let pox_watchdog_comms = PoxSyncWatchdogComms::new(should_keep_running.clone());
+        let miner_status = Arc::new(Mutex::new(MinerStatus::make_ready(
+            config.burnchain.burn_fee_cap,
+        )));
+
+        let mut event_dispatcher = EventDispatcher::new();
+        for observer in config.events_observers.iter() {
+            event_dispatcher.register_observer(observer);
+        }
+
+        Self {
+            config,
+            globals: None,
+            coordinator_channels: Some(channels),
+            callbacks: RunLoopCallbacks::new(),
+            counters: Counters::new(),
+            should_keep_running,
+            event_dispatcher,
+            pox_watchdog: None,
+            is_miner: None,
+            burnchain: None,
+            pox_watchdog_comms,
+            miner_status,
+        }
+    }
+
+    pub fn get_globals(&self) -> Globals {
+        self.globals
+            .clone()
+            .expect("FATAL: globals not instantiated")
+    }
+
+    fn set_globals(&mut self, globals: Globals) {
+        self.globals = Some(globals);
+    }
+
+    pub fn get_coordinator_channel(&self) -> Option<CoordinatorChannels> {
+        self.coordinator_channels.as_ref().map(|x| x.1.clone())
+    }
+
+    pub fn get_blocks_processed_arc(&self) -> RunLoopCounter {
+        self.counters.blocks_processed.clone()
+    }
+
+    pub fn submitted_commits(&self) -> RunLoopCounter {
+        self.counters.naka_submitted_commits.clone()
+    }
+
+    pub fn submitted_vrfs(&self) -> RunLoopCounter {
+        self.counters.naka_submitted_vrfs.clone()
+    }
+
+    pub fn mined_blocks(&self) -> RunLoopCounter {
+        self.counters.naka_mined_blocks.clone()
+    }
+
+    pub fn get_counters(&self) -> Counters {
+        self.counters.clone()
+    }
+
+    pub fn config(&self) -> &Config {
+        &self.config
+    }
+
+    pub fn get_event_dispatcher(&self) -> EventDispatcher {
+        self.event_dispatcher.clone()
+    }
+
+    pub fn is_miner(&self) -> bool {
+        self.is_miner.unwrap_or(false)
+    }
+
+    pub fn get_pox_sync_comms(&self) -> PoxSyncWatchdogComms {
+        self.pox_watchdog_comms.clone()
+    }
+
+    pub fn get_termination_switch(&self) -> Arc<AtomicBool> {
+        self.should_keep_running.clone()
+    }
+
+    pub fn get_burnchain(&self) -> Burnchain {
+        self.burnchain
+            .clone()
+            .expect("FATAL: tried to get runloop burnchain before calling .start()")
+    }
+
+    pub fn get_pox_watchdog(&mut self) -> &mut PoxSyncWatchdog {
+        self.pox_watchdog
+            .as_mut()
+            .expect("FATAL: tried to get PoX watchdog before calling .start()")
+    }
+
+    pub fn get_miner_status(&self) -> Arc<Mutex<MinerStatus>> {
+        self.miner_status.clone()
+    }
+
+    /// Determine if we're the miner.
+    /// If there's a network error, then assume that we're not a miner.
+    fn check_is_miner(&mut self, burnchain: &mut BitcoinRegtestController) -> bool {
+        if self.config.node.miner {
+            let keychain = Keychain::default(self.config.node.seed.clone());
+            let mut op_signer = keychain.generate_op_signer();
+            match burnchain.create_wallet_if_dne() {
+                Err(e) => warn!("Error when creating wallet: {:?}", e),
+                _ => {}
+            }
+            let mut btc_addrs = vec![(
+                StacksEpochId::Epoch2_05,
+                // legacy
+                BitcoinAddress::from_bytes_legacy(
+                    self.config.burnchain.get_bitcoin_network().1,
+                    LegacyBitcoinAddressType::PublicKeyHash,
+                    &Hash160::from_data(&op_signer.get_public_key().to_bytes()).0,
+                )
+                .expect("FATAL: failed to construct legacy bitcoin address"),
+            )];
+            if self.config.miner.segwit {
+                btc_addrs.push((
+                    StacksEpochId::Epoch21,
+                    // segwit p2wpkh
+                    BitcoinAddress::from_bytes_segwit_p2wpkh(
+                        self.config.burnchain.get_bitcoin_network().1,
+                        &Hash160::from_data(&op_signer.get_public_key().to_bytes_compressed()).0,
+                    )
+                    .expect("FATAL: failed to construct segwit p2wpkh address"),
+                ));
+            }
+
+            for (epoch_id, btc_addr) in btc_addrs.into_iter() {
+                info!("Miner node: checking UTXOs at address: {}", &btc_addr);
+                let utxos = burnchain.get_utxos(epoch_id, &op_signer.get_public_key(), 1, None, 0);
+                if utxos.is_none() {
+                    warn!("UTXOs not found for {}. If this is unexpected, please ensure that your bitcoind instance is indexing transactions for the address {} (importaddress)", btc_addr, btc_addr);
+                } else {
+                    info!("UTXOs found - will run as a Miner node");
+                    return true;
+                }
+            }
+            if self.config.node.mock_mining {
+                info!("No UTXOs found, but configured to mock mine");
+                return true;
+            } else {
+                return false;
+            }
+        } else {
+            info!("Will run as a Follower node");
+            false
+        }
+    }
+
+    /// Boot up the stacks chainstate.
+    /// Instantiate the chainstate and push out the boot receipts to observers
+    /// This is only public so we can test it.
+    pub fn boot_chainstate(&mut self, burnchain_config: &Burnchain) -> StacksChainState {
+        let use_test_genesis_data = use_test_genesis_chainstate(&self.config);
+
+        // load up genesis balances
+        let initial_balances = self
+            .config
+            .initial_balances
+            .iter()
+            .map(|e| (e.address.clone(), e.amount))
+            .collect();
+
+        // TODO (nakamoto-neon): check if we're trying to setup a self-signing network
+        //  and set the right genesis data
+
+        // instantiate chainstate
+        let mut boot_data = ChainStateBootData {
+            initial_balances,
+            post_flight_callback: None,
+            first_burnchain_block_hash: burnchain_config.first_block_hash,
+            first_burnchain_block_height: burnchain_config.first_block_height as u32,
+            first_burnchain_block_timestamp: burnchain_config.first_block_timestamp,
+            pox_constants: burnchain_config.pox_constants.clone(),
+            get_bulk_initial_lockups: Some(Box::new(move || {
+                get_account_lockups(use_test_genesis_data)
+            })),
+            get_bulk_initial_balances: Some(Box::new(move || {
+                get_account_balances(use_test_genesis_data)
+            })),
+            get_bulk_initial_namespaces: Some(Box::new(move || {
+                get_namespaces(use_test_genesis_data)
+            })),
+            get_bulk_initial_names: Some(Box::new(move || get_names(use_test_genesis_data))),
+        };
+
+        let (chain_state_db, receipts) = StacksChainState::open_and_exec(
+            self.config.is_mainnet(),
+            self.config.burnchain.chain_id,
+            &self.config.get_chainstate_path_str(),
+            Some(&mut boot_data),
+            Some(self.config.node.get_marf_opts()),
+        )
+        .unwrap();
+        run_loop::announce_boot_receipts(
+            &mut self.event_dispatcher,
+            &chain_state_db,
+            &burnchain_config.pox_constants,
+            &receipts,
+        );
+        chain_state_db
+    }
+
+    /// Instantiate the Stacks chain state and start the chains coordinator thread.
+    /// Returns the coordinator thread handle, and the receiving end of the coordinator's atlas
+    /// attachment channel.
+    fn spawn_chains_coordinator(
+        &mut self,
+        burnchain_config: &Burnchain,
+        coordinator_receivers: CoordinatorReceivers,
+        miner_status: Arc<Mutex<MinerStatus>>,
+    ) -> JoinHandle<()> {
+        let use_test_genesis_data = use_test_genesis_chainstate(&self.config);
+
+        // load up genesis Atlas attachments
+        let mut atlas_config = AtlasConfig::new(self.config.is_mainnet());
+        let genesis_attachments = GenesisData::new(use_test_genesis_data)
+            .read_name_zonefiles()
+            .into_iter()
+            .map(|z| Attachment::new(z.zonefile_content.as_bytes().to_vec()))
+            .collect();
+        atlas_config.genesis_attachments = Some(genesis_attachments);
+
+        let chain_state_db = self.boot_chainstate(burnchain_config);
+
+        // NOTE: re-instantiate AtlasConfig so we don't have to keep the genesis attachments around
+        let moved_atlas_config = self.config.atlas.clone();
+        let moved_config = self.config.clone();
+        let moved_burnchain_config = burnchain_config.clone();
+        let mut coordinator_dispatcher = self.event_dispatcher.clone();
+        let atlas_db = AtlasDB::connect(
+            moved_atlas_config.clone(),
+            &self.config.get_atlas_db_file_path(),
+            true,
+        )
+        .expect("Failed to connect Atlas DB during startup");
+        let coordinator_indexer =
+            make_bitcoin_indexer(&self.config, Some(self.should_keep_running.clone()));
+
+        let coordinator_thread_handle = thread::Builder::new()
+            .name(format!(
+                "chains-coordinator-{}",
+                &moved_config.node.rpc_bind
+            ))
+            .stack_size(BLOCK_PROCESSOR_STACK_SIZE)
+            .spawn(move || {
+                debug!(
+                    "chains-coordinator thread ID is {:?}",
+                    thread::current().id()
+                );
+                let mut cost_estimator = moved_config.make_cost_estimator();
+                let mut fee_estimator = moved_config.make_fee_estimator();
+
+                let coord_config = ChainsCoordinatorConfig {
+                    always_use_affirmation_maps: moved_config.node.always_use_affirmation_maps,
+                    require_affirmed_anchor_blocks: moved_config
+                        .node
+                        .require_affirmed_anchor_blocks,
+                    ..ChainsCoordinatorConfig::new()
+                };
+                ChainsCoordinator::run(
+                    coord_config,
+                    chain_state_db,
+                    moved_burnchain_config,
+                    &mut coordinator_dispatcher,
+                    coordinator_receivers,
+                    moved_atlas_config,
+                    cost_estimator.as_deref_mut(),
+                    fee_estimator.as_deref_mut(),
+                    miner_status,
+                    coordinator_indexer,
+                    atlas_db,
+                );
+            })
+            .expect("FATAL: failed to start chains coordinator thread");
+
+        coordinator_thread_handle
+    }
+
+    /// Start Prometheus logging
+    fn start_prometheus(&mut self) {
+        let prometheus_bind = self.config.node.prometheus_bind.clone();
+        if let Some(prometheus_bind) = prometheus_bind {
+            thread::Builder::new()
+                .name("prometheus".to_string())
+                .spawn(move || {
+                    debug!("prometheus thread ID is {:?}", thread::current().id());
+                    start_serving_monitoring_metrics(prometheus_bind);
+                })
+                .unwrap();
+        }
+    }
+
+    /// Get the sortition DB's highest block height, aligned to a reward cycle boundary, and the
+    /// highest sortition.
+    /// Returns (height at rc start, sortition)
+    fn get_reward_cycle_sortition_db_height(
+        sortdb: &SortitionDB,
+        burnchain_config: &Burnchain,
+    ) -> (u64, BlockSnapshot) {
+        let (stacks_ch, _) = SortitionDB::get_canonical_stacks_chain_tip_hash(sortdb.conn())
+            .expect("BUG: failed to load canonical stacks chain tip hash");
+
+        let sn = match SortitionDB::get_block_snapshot_consensus(sortdb.conn(), &stacks_ch)
+            .expect("BUG: failed to query sortition DB")
+        {
+            Some(sn) => sn,
+            None => {
+                debug!("No canonical stacks chain tip hash present");
+                let sn = SortitionDB::get_first_block_snapshot(&sortdb.conn())
+                    .expect("BUG: failed to get first-ever block snapshot");
+                sn
+            }
+        };
+
+        (
+            burnchain_config.reward_cycle_to_block_height(
+                burnchain_config
+                    .block_height_to_reward_cycle(sn.block_height)
+                    .expect("BUG: snapshot preceeds first reward cycle"),
+            ),
+            sn,
+        )
+    }
+
+    /// Wake up and drive stacks block processing if there's been a PoX reorg.
+    /// Be careful not to saturate calls to announce new stacks blocks, because that will disable
+    /// mining (which would prevent a miner attempting to fix a hidden PoX anchor block from making
+    /// progress).
+    fn drive_pox_reorg_stacks_block_processing(
+        globals: &Globals,
+        config: &Config,
+        burnchain: &Burnchain,
+        sortdb: &SortitionDB,
+        last_stacks_pox_reorg_recover_time: &mut u128,
+    ) {
+        let delay = cmp::max(
+            config.node.chain_liveness_poll_time_secs,
+            cmp::max(
+                config.miner.first_attempt_time_ms,
+                config.miner.subsequent_attempt_time_ms,
+            ) / 1000,
+        );
+
+        if *last_stacks_pox_reorg_recover_time + (delay as u128) >= get_epoch_time_secs().into() {
+            // too soon
+            return;
+        }
+
+        // compare stacks and heaviest AMs
+        let burnchain_db = burnchain
+            .open_burnchain_db(false)
+            .expect("FATAL: failed to open burnchain DB");
+
+        let sn = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn())
+            .expect("FATAL: could not read sortition DB");
+
+        let indexer = make_bitcoin_indexer(config, Some(globals.should_keep_running.clone()));
+
+        let heaviest_affirmation_map = match static_get_heaviest_affirmation_map(
+            &burnchain,
+            &indexer,
+            &burnchain_db,
+            sortdb,
+            &sn.sortition_id,
+        ) {
+            Ok(am) => am,
+            Err(e) => {
+                warn!("Failed to find heaviest affirmation map: {:?}", &e);
+                return;
+            }
+        };
+
+        let highest_sn = SortitionDB::get_highest_known_burn_chain_tip(sortdb.conn())
+            .expect("FATAL: could not read sortition DB");
+
+        let canonical_burnchain_tip = burnchain_db
+            .get_canonical_chain_tip()
+            .expect("FATAL: could not read burnchain DB");
+
+        let sortition_tip_affirmation_map =
+            match SortitionDB::find_sortition_tip_affirmation_map(sortdb, &sn.sortition_id) {
+                Ok(am) => am,
+                Err(e) => {
+                    warn!("Failed to find sortition affirmation map: {:?}", &e);
+                    return;
+                }
+            };
+
+        let stacks_tip_affirmation_map = static_get_stacks_tip_affirmation_map(
+            &burnchain_db,
+            sortdb,
+            &sn.sortition_id,
+            &sn.canonical_stacks_tip_consensus_hash,
+            &sn.canonical_stacks_tip_hash,
+        )
+        .expect("FATAL: could not query stacks DB");
+
+        if stacks_tip_affirmation_map.len() < heaviest_affirmation_map.len()
+            || stacks_tip_affirmation_map
+                .find_divergence(&heaviest_affirmation_map)
+                .is_some()
+        {
+            // the sortition affirmation map might also be inconsistent, so we'll need to fix that
+            // (i.e. the underlying sortitions) before we can fix the stacks fork
+            if sortition_tip_affirmation_map.len() < heaviest_affirmation_map.len()
+                || sortition_tip_affirmation_map
+                    .find_divergence(&heaviest_affirmation_map)
+                    .is_some()
+            {
+                debug!("Drive burn block processing: possible PoX reorg (sortition tip: {}, heaviest: {})", &sortition_tip_affirmation_map, &heaviest_affirmation_map);
+                globals.coord().announce_new_burn_block();
+            } else if highest_sn.block_height == sn.block_height
+                && sn.block_height == canonical_burnchain_tip.block_height
+            {
+                // need to force an affirmation reorg because there will be no more burn block
+                // announcements.
+                debug!("Drive burn block processing: possible PoX reorg (sortition tip: {}, heaviest: {}, burn height {})", &sortition_tip_affirmation_map, &heaviest_affirmation_map, sn.block_height);
+                globals.coord().announce_new_burn_block();
+            }
+
+            debug!(
+                "Drive stacks block processing: possible PoX reorg (stacks tip: {}, heaviest: {})",
+                &stacks_tip_affirmation_map, &heaviest_affirmation_map
+            );
+            globals.coord().announce_new_stacks_block();
+        } else {
+            debug!(
+                "Drive stacks block processing: no need (stacks tip: {}, heaviest: {})",
+                &stacks_tip_affirmation_map, &heaviest_affirmation_map
+            );
+
+            // announce a new stacks block to force the chains coordinator
+            //  to wake up anyways. this isn't free, so we have to make sure
+            //  the chain-liveness thread doesn't wake up too often
+            globals.coord().announce_new_stacks_block();
+        }
+
+        *last_stacks_pox_reorg_recover_time = get_epoch_time_secs().into();
+    }
+
+    /// Wake up and drive sortition processing if there's been a PoX reorg.
+    /// Be careful not to saturate calls to announce new burn blocks, because that will disable
+    /// mining (which would prevent a miner attempting to fix a hidden PoX anchor block from making
+    /// progress).
+    ///
+    /// only call if no in ibd
+    fn drive_pox_reorg_burn_block_processing(
+        globals: &Globals,
+        config: &Config,
+        burnchain: &Burnchain,
+        sortdb: &SortitionDB,
+        chain_state_db: &StacksChainState,
+        last_burn_pox_reorg_recover_time: &mut u128,
+        last_announce_time: &mut u128,
+    ) {
+        let delay = cmp::max(
+            config.node.chain_liveness_poll_time_secs,
+            cmp::max(
+                config.miner.first_attempt_time_ms,
+                config.miner.subsequent_attempt_time_ms,
+            ) / 1000,
+        );
+
+        if *last_burn_pox_reorg_recover_time + (delay as u128) >= get_epoch_time_secs().into() {
+            // too soon
+            return;
+        }
+
+        // compare sortition and heaviest AMs
+        let burnchain_db = burnchain
+            .open_burnchain_db(false)
+            .expect("FATAL: failed to open burnchain DB");
+
+        let highest_sn = SortitionDB::get_highest_known_burn_chain_tip(sortdb.conn())
+            .expect("FATAL: could not read sortition DB");
+
+        let canonical_burnchain_tip = burnchain_db
+            .get_canonical_chain_tip()
+            .expect("FATAL: could not read burnchain DB");
+
+        if canonical_burnchain_tip.block_height > highest_sn.block_height {
+            // still processing sortitions
+            test_debug!(
+                "Drive burn block processing: still processing sortitions ({} > {})",
+                canonical_burnchain_tip.block_height,
+                highest_sn.block_height
+            );
+            return;
+        }
+
+        // NOTE: this could be lower than the highest_sn
+        let sn = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn())
+            .expect("FATAL: could not read sortition DB");
+
+        let sortition_tip_affirmation_map =
+            match SortitionDB::find_sortition_tip_affirmation_map(sortdb, &sn.sortition_id) {
+                Ok(am) => am,
+                Err(e) => {
+                    warn!("Failed to find sortition affirmation map: {:?}", &e);
+                    return;
+                }
+            };
+
+        let indexer = make_bitcoin_indexer(config, Some(globals.should_keep_running.clone()));
+
+        let heaviest_affirmation_map = match static_get_heaviest_affirmation_map(
+            &burnchain,
+            &indexer,
+            &burnchain_db,
+            sortdb,
+            &sn.sortition_id,
+        ) {
+            Ok(am) => am,
+            Err(e) => {
+                warn!("Failed to find heaviest affirmation map: {:?}", &e);
+                return;
+            }
+        };
+
+        let canonical_affirmation_map = match static_get_canonical_affirmation_map(
+            &burnchain,
+            &indexer,
+            &burnchain_db,
+            sortdb,
+            &chain_state_db,
+            &sn.sortition_id,
+        ) {
+            Ok(am) => am,
+            Err(e) => {
+                warn!("Failed to find canonical affirmation map: {:?}", &e);
+                return;
+            }
+        };
+
+        if sortition_tip_affirmation_map.len() < heaviest_affirmation_map.len()
+            || sortition_tip_affirmation_map
+                .find_divergence(&heaviest_affirmation_map)
+                .is_some()
+            || sn.block_height < highest_sn.block_height
+        {
+            debug!("Drive burn block processing: possible PoX reorg (sortition tip: {}, heaviest: {}, {} <? {})", &sortition_tip_affirmation_map, &heaviest_affirmation_map, sn.block_height, highest_sn.block_height);
+            globals.coord().announce_new_burn_block();
+            globals.coord().announce_new_stacks_block();
+            *last_announce_time = get_epoch_time_secs().into();
+        } else if sortition_tip_affirmation_map.len() >= heaviest_affirmation_map.len()
+            && sortition_tip_affirmation_map.len() <= canonical_affirmation_map.len()
+        {
+            if let Some(divergence_rc) =
+                canonical_affirmation_map.find_divergence(&sortition_tip_affirmation_map)
+            {
+                if divergence_rc + 1 >= (heaviest_affirmation_map.len() as u64) {
+                    // we have unaffirmed PoX anchor blocks that are not yet processed in the sortition history
+                    debug!("Drive burnchain processing: possible PoX reorg from unprocessed anchor block(s) (sortition tip: {}, heaviest: {}, canonical: {})", &sortition_tip_affirmation_map, &heaviest_affirmation_map, &canonical_affirmation_map);
+                    globals.coord().announce_new_burn_block();
+                    globals.coord().announce_new_stacks_block();
+                    *last_announce_time = get_epoch_time_secs().into();
+                }
+            }
+        } else {
+            debug!(
+                "Drive burn block processing: no need (sortition tip: {}, heaviest: {}, {} </ {})",
+                &sortition_tip_affirmation_map,
+                &heaviest_affirmation_map,
+                sn.block_height,
+                highest_sn.block_height
+            );
+        }
+
+        *last_burn_pox_reorg_recover_time = get_epoch_time_secs().into();
+
+        // unconditionally bump every 5 minutes, just in case.
+        // this can get the node un-stuck if we're short on sortition processing but are unable to
+        // sync with the remote node because it keeps NACK'ing us, leading to a runloop stall.
+        if *last_announce_time + (UNCONDITIONAL_CHAIN_LIVENESS_CHECK as u128)
+            < get_epoch_time_secs().into()
+        {
+            debug!("Drive burnchain processing: unconditional bump");
+            globals.coord().announce_new_burn_block();
+            globals.coord().announce_new_stacks_block();
+            *last_announce_time = get_epoch_time_secs().into();
+        }
+    }
+
+    /// In a separate thread, periodically drive coordinator liveness by checking to see if there's
+    /// a pending reorg and if so, waking up the coordinator to go and process new blocks
+    fn drive_chain_liveness(
+        globals: Globals,
+        config: Config,
+        burnchain: Burnchain,
+        sortdb: SortitionDB,
+        chain_state_db: StacksChainState,
+    ) {
+        let mut last_burn_pox_reorg_recover_time = 0;
+        let mut last_stacks_pox_reorg_recover_time = 0;
+        let mut last_burn_announce_time = 0;
+
+        debug!("Chain-liveness thread start!");
+
+        while globals.keep_running() {
+            debug!("Chain-liveness checkup");
+            Self::drive_pox_reorg_burn_block_processing(
+                &globals,
+                &config,
+                &burnchain,
+                &sortdb,
+                &chain_state_db,
+                &mut last_burn_pox_reorg_recover_time,
+                &mut last_burn_announce_time,
+            );
+            Self::drive_pox_reorg_stacks_block_processing(
+                &globals,
+                &config,
+                &burnchain,
+                &sortdb,
+                &mut last_stacks_pox_reorg_recover_time,
+            );
+
+            sleep_ms(3000);
+        }
+
+        debug!("Chain-liveness thread exit!");
+    }
+
+    /// Spawn a thread to drive chain liveness
+    fn spawn_chain_liveness_thread(&self, globals: Globals) -> JoinHandle<()> {
+        let config = self.config.clone();
+        let burnchain = self.get_burnchain();
+        let sortdb = burnchain
+            .open_sortition_db(true)
+            .expect("FATAL: could not open sortition DB");
+
+        let (chain_state_db, _) = StacksChainState::open(
+            config.is_mainnet(),
+            config.burnchain.chain_id,
+            &config.get_chainstate_path_str(),
+            Some(config.node.get_marf_opts()),
+        )
+        .unwrap();
+
+        let liveness_thread_handle = thread::Builder::new()
+            .name(format!("chain-liveness-{}", config.node.rpc_bind))
+            .stack_size(BLOCK_PROCESSOR_STACK_SIZE)
+            .spawn(move || {
+                Self::drive_chain_liveness(globals, config, burnchain, sortdb, chain_state_db)
+            })
+            .expect("FATAL: failed to spawn chain liveness thread");
+
+        liveness_thread_handle
+    }
+
+    /// Starts the node runloop.
+    ///
+    /// This function will block by looping infinitely.
+    /// It will start the burnchain (separate thread), set-up a channel in
+    /// charge of coordinating the new blocks coming from the burnchain and
+    /// the nodes, taking turns on tenures.  
+    pub fn start(&mut self, burnchain_opt: Option<Burnchain>, mut mine_start: u64) {
+        let (coordinator_receivers, coordinator_senders) = self
+            .coordinator_channels
+            .take()
+            .expect("Run loop already started, can only start once after initialization.");
+
+        neon::RunLoop::setup_termination_handler(self.should_keep_running.clone());
+        let mut burnchain = neon::RunLoop::instantiate_burnchain_state(
+            &self.config,
+            self.should_keep_running.clone(),
+            burnchain_opt,
+            coordinator_senders.clone(),
+        );
+
+        let burnchain_config = burnchain.get_burnchain();
+        self.burnchain = Some(burnchain_config.clone());
+
+        // can we mine?
+        let is_miner = self.check_is_miner(&mut burnchain);
+        self.is_miner = Some(is_miner);
+
+        // relayer linkup
+        let (relay_send, relay_recv) = sync_channel(RELAYER_MAX_BUFFER);
+
+        // set up globals so other subsystems can instantiate off of the runloop state.
+        let globals = Globals::new(
+            coordinator_senders,
+            self.get_miner_status(),
+            relay_send,
+            self.counters.clone(),
+            self.pox_watchdog_comms.clone(),
+            self.should_keep_running.clone(),
+        );
+        self.set_globals(globals.clone());
+
+        // have headers; boot up the chains coordinator and instantiate the chain state
+        let coordinator_thread_handle = self.spawn_chains_coordinator(
+            &burnchain_config,
+            coordinator_receivers,
+            globals.get_miner_status(),
+        );
+        self.start_prometheus();
+
+        // We announce a new burn block so that the chains coordinator
+        // can resume prior work and handle eventual unprocessed sortitions
+        // stored during a previous session.
+        globals.coord().announce_new_burn_block();
+
+        // Make sure at least one sortition has happened, and make sure it's globally available
+        let sortdb = burnchain.sortdb_mut();
+        let (rc_aligned_height, sn) =
+            RunLoop::get_reward_cycle_sortition_db_height(&sortdb, &burnchain_config);
+
+        let burnchain_tip_snapshot = if sn.block_height == burnchain_config.first_block_height {
+            // need at least one sortition to happen.
+            burnchain
+                .wait_for_sortitions(globals.coord().clone(), sn.block_height + 1)
+                .expect("Unable to get burnchain tip")
+                .block_snapshot
+        } else {
+            sn
+        };
+
+        globals.set_last_sortition(burnchain_tip_snapshot.clone());
+
+        // Boot up the p2p network and relayer, and figure out how many sortitions we have so far
+        // (it could be non-zero if the node is resuming from chainstate)
+        let mut node = StacksNode::spawn(self, globals.clone(), relay_recv);
+        let liveness_thread = self.spawn_chain_liveness_thread(globals.clone());
+
+        // Wait for all pending sortitions to process
+        let burnchain_db = burnchain_config
+            .open_burnchain_db(false)
+            .expect("FATAL: failed to open burnchain DB");
+        let burnchain_db_tip = burnchain_db
+            .get_canonical_chain_tip()
+            .expect("FATAL: failed to query burnchain DB");
+        let mut burnchain_tip = burnchain
+            .wait_for_sortitions(globals.coord().clone(), burnchain_db_tip.block_height)
+            .expect("Unable to get burnchain tip");
+
+        // Start the runloop
+        debug!("Runloop: Begin run loop");
+        self.counters.bump_blocks_processed();
+
+        let mut sortition_db_height = rc_aligned_height;
+        let mut burnchain_height = sortition_db_height;
+        let mut num_sortitions_in_last_cycle;
+
+        // prepare to fetch the first reward cycle!
+        let mut target_burnchain_block_height = cmp::min(
+            burnchain_config.reward_cycle_to_block_height(
+                burnchain_config
+                    .block_height_to_reward_cycle(burnchain_height)
+                    .expect("BUG: block height is not in a reward cycle")
+                    + 1,
+            ),
+            burnchain.get_headers_height() - 1,
+        );
+
+        debug!(
+            "Runloop: Begin main runloop starting a burnchain block {}",
+            sortition_db_height
+        );
+
+        let mut last_tenure_sortition_height = 0;
+
+        loop {
+            if !globals.keep_running() {
+                // The p2p thread relies on the same atomic_bool, it will
+                // discontinue its execution after completing its ongoing runloop epoch.
+                info!("Terminating p2p process");
+                info!("Terminating relayer");
+                info!("Terminating chains-coordinator");
+
+                globals.coord().stop_chains_coordinator();
+                coordinator_thread_handle.join().unwrap();
+                node.join();
+                liveness_thread.join().unwrap();
+
+                info!("Exiting stacks-node");
+                break;
+            }
+
+            let remote_chain_height = burnchain.get_headers_height() - 1;
+
+            // wait for the p2p state-machine to do at least one pass
+            debug!("Runloop: Wait until Stacks block downloads reach a quiescent state before processing more burnchain blocks"; "remote_chain_height" => remote_chain_height, "local_chain_height" => burnchain_height);
+
+            let ibd = false;
+
+            // calculate burnchain sync percentage
+            let percent: f64 = if remote_chain_height > 0 {
+                burnchain_tip.block_snapshot.block_height as f64 / remote_chain_height as f64
+            } else {
+                0.0
+            };
+
+            // Download each burnchain block and process their sortitions.  This, in turn, will
+            // cause the node's p2p and relayer threads to go fetch and download Stacks blocks and
+            // process them.  This loop runs for one reward cycle, so that the next pass of the
+            // runloop will cause the PoX sync watchdog to wait until it believes that the node has
+            // obtained all the Stacks blocks it can.
+            debug!(
+                "Runloop: Download burnchain blocks up to reward cycle #{} (height {})",
+                burnchain_config
+                    .block_height_to_reward_cycle(target_burnchain_block_height)
+                    .expect("FATAL: target burnchain block height does not have a reward cycle"),
+                target_burnchain_block_height;
+                "total_burn_sync_percent" => %percent,
+                "local_burn_height" => burnchain_tip.block_snapshot.block_height,
+                "remote_tip_height" => remote_chain_height
+            );
+
+            loop {
+                if !globals.keep_running() {
+                    break;
+                }
+
+                let (next_burnchain_tip, tip_burnchain_height) =
+                    match burnchain.sync(Some(target_burnchain_block_height)) {
+                        Ok(x) => x,
+                        Err(e) => {
+                            warn!("Runloop: Burnchain controller stopped: {}", e);
+                            continue;
+                        }
+                    };
+
+                // *now* we know the burnchain height
+                burnchain_tip = next_burnchain_tip;
+                burnchain_height = tip_burnchain_height;
+
+                let sortition_tip = &burnchain_tip.block_snapshot.sortition_id;
+                let next_sortition_height = burnchain_tip.block_snapshot.block_height;
+
+                if next_sortition_height != last_tenure_sortition_height {
+                    info!(
+                        "Runloop: Downloaded burnchain blocks up to height {}; target height is {}; remote_chain_height = {} next_sortition_height = {}, sortition_db_height = {}",
+                        burnchain_height, target_burnchain_block_height, remote_chain_height, next_sortition_height, sortition_db_height
+                    );
+                }
+
+                if next_sortition_height > sortition_db_height {
+                    debug!(
+                        "Runloop: New burnchain block height {} > {}",
+                        next_sortition_height, sortition_db_height
+                    );
+
+                    let mut sort_count = 0;
+
+                    debug!("Runloop: block mining until we process all sortitions");
+                    signal_mining_blocked(globals.get_miner_status());
+
+                    // first, let's process all blocks in (sortition_db_height, next_sortition_height]
+                    for block_to_process in (sortition_db_height + 1)..(next_sortition_height + 1) {
+                        // stop mining so we can advance the sortition DB and so our
+                        // ProcessTenure() directive (sent by relayer_sortition_notify() below)
+                        // will be unblocked.
+
+                        let block = {
+                            let ic = burnchain.sortdb_ref().index_conn();
+                            SortitionDB::get_ancestor_snapshot(&ic, block_to_process, sortition_tip)
+                                .unwrap()
+                                .expect(
+                                    "Failed to find block in fork processed by burnchain indexer",
+                                )
+                        };
+                        if block.sortition {
+                            sort_count += 1;
+                        }
+
+                        let sortition_id = &block.sortition_id;
+
+                        // Have the node process the new block, that can include, or not, a sortition.
+                        node.process_burnchain_state(burnchain.sortdb_mut(), sortition_id, ibd);
+
+                        // Now, tell the relayer to check if it won a sortition during this block,
+                        // and, if so, to process and advertize the block.  This is basically a
+                        // no-op during boot-up.
+                        //
+                        // _this will block if the relayer's buffer is full_
+                        if !node.relayer_burnchain_notify() {
+                            // relayer hung up, exit.
+                            error!("Runloop: Block relayer and miner hung up, exiting.");
+                            return;
+                        }
+                    }
+
+                    debug!("Runloop: enable miner after processing sortitions");
+                    signal_mining_ready(globals.get_miner_status());
+
+                    num_sortitions_in_last_cycle = sort_count;
+                    debug!(
+                        "Runloop: Synchronized sortitions up to block height {} from {} (chain tip height is {}); {} sortitions",
+                        next_sortition_height, sortition_db_height, burnchain_height, num_sortitions_in_last_cycle;
+                    );
+
+                    sortition_db_height = next_sortition_height;
+                } else if ibd {
+                    // drive block processing after we reach the burnchain tip.
+                    // we may have downloaded all the blocks already,
+                    // so we can't rely on the relayer alone to
+                    // drive it.
+                    globals.coord().announce_new_stacks_block();
+                }
+
+                if burnchain_height >= target_burnchain_block_height
+                    || burnchain_height >= remote_chain_height
+                {
+                    break;
+                }
+            }
+
+            // advance one reward cycle at a time.
+            // If we're still downloading, then this is simply target_burnchain_block_height + reward_cycle_len.
+            // Otherwise, this is burnchain_tip + reward_cycle_len
+            let next_target_burnchain_block_height = cmp::min(
+                burnchain_config.reward_cycle_to_block_height(
+                    burnchain_config
+                        .block_height_to_reward_cycle(target_burnchain_block_height)
+                        .expect("FATAL: burnchain height before system start")
+                        + 1,
+                ),
+                remote_chain_height,
+            );
+
+            debug!("Runloop: Advance target burnchain block height from {} to {} (sortition height {})", target_burnchain_block_height, next_target_burnchain_block_height, sortition_db_height);
+            target_burnchain_block_height = next_target_burnchain_block_height;
+
+            if sortition_db_height >= burnchain_height && !ibd {
+                let canonical_stacks_tip_height =
+                    SortitionDB::get_canonical_burn_chain_tip(burnchain.sortdb_ref().conn())
+                        .map(|snapshot| snapshot.canonical_stacks_tip_height)
+                        .unwrap_or(0);
+                if canonical_stacks_tip_height < mine_start {
+                    info!(
+                        "Runloop: Synchronized full burnchain, but stacks tip height is {}, and we are trying to boot to {}, not mining until reaching chain tip",
+                        canonical_stacks_tip_height,
+                        mine_start
+                    );
+                } else {
+                    // once we've synced to the chain tip once, don't apply this check again.
+                    //  this prevents a possible corner case in the event of a PoX fork.
+                    mine_start = 0;
+
+                    // at tip, and not downloading. proceed to mine.
+                    if last_tenure_sortition_height != sortition_db_height {
+                        info!(
+                            "Runloop: Synchronized full burnchain up to height {}. Proceeding to mine blocks",
+                            sortition_db_height
+                        );
+                        last_tenure_sortition_height = sortition_db_height;
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/testnet/stacks-node/src/run_loop/neon.rs b/testnet/stacks-node/src/run_loop/neon.rs
index c9368e9e3a..c10c9b88c3 100644
--- a/testnet/stacks-node/src/run_loop/neon.rs
+++ b/testnet/stacks-node/src/run_loop/neon.rs
@@ -31,8 +31,9 @@ use stx_genesis::GenesisData;
 
 use super::RunLoopCallbacks;
 use crate::burnchains::make_bitcoin_indexer;
+use crate::globals::Globals;
 use crate::monitoring::start_serving_monitoring_metrics;
-use crate::neon_node::{Globals, StacksNode, BLOCK_PROCESSOR_STACK_SIZE, RELAYER_MAX_BUFFER};
+use crate::neon_node::{StacksNode, BLOCK_PROCESSOR_STACK_SIZE, RELAYER_MAX_BUFFER};
 use crate::node::{
     get_account_balances, get_account_lockups, get_names, get_namespaces,
     use_test_genesis_chainstate,
@@ -63,6 +64,10 @@ pub struct Counters {
     pub missed_tenures: RunLoopCounter,
     pub missed_microblock_tenures: RunLoopCounter,
     pub cancelled_commits: RunLoopCounter,
+
+    pub naka_submitted_vrfs: RunLoopCounter,
+    pub naka_submitted_commits: RunLoopCounter,
+    pub naka_mined_blocks: RunLoopCounter,
 }
 
 impl Counters {
@@ -74,6 +79,9 @@ impl Counters {
             missed_tenures: RunLoopCounter::new(AtomicU64::new(0)),
             missed_microblock_tenures: RunLoopCounter::new(AtomicU64::new(0)),
             cancelled_commits: RunLoopCounter::new(AtomicU64::new(0)),
+            naka_submitted_vrfs: RunLoopCounter::new(AtomicU64::new(0)),
+            naka_submitted_commits: RunLoopCounter::new(AtomicU64::new(0)),
+            naka_mined_blocks: RunLoopCounter::new(AtomicU64::new(0)),
         }
     }
 
@@ -85,6 +93,9 @@ impl Counters {
             missed_tenures: (),
             missed_microblock_tenures: (),
             cancelled_commits: (),
+            naka_submitted_vrfs: (),
+            naka_submitted_commits: (),
+            naka_mined_blocks: (),
         }
     }
 
@@ -124,6 +135,18 @@ impl Counters {
         Counters::inc(&self.cancelled_commits);
     }
 
+    pub fn bump_naka_submitted_vrfs(&self) {
+        Counters::inc(&self.naka_submitted_vrfs);
+    }
+
+    pub fn bump_naka_submitted_commits(&self) {
+        Counters::inc(&self.naka_submitted_commits);
+    }
+
+    pub fn bump_naka_mined_blocks(&self) {
+        Counters::inc(&self.naka_mined_blocks);
+    }
+
     pub fn set_microblocks_processed(&self, value: u64) {
         Counters::set(&self.microblocks_processed, value)
     }
@@ -251,7 +274,7 @@ impl RunLoop {
     }
 
     pub fn get_termination_switch(&self) -> Arc<AtomicBool> {
-        self.get_globals().should_keep_running.clone()
+        self.should_keep_running.clone()
     }
 
     pub fn get_burnchain(&self) -> Burnchain {
@@ -272,8 +295,7 @@ impl RunLoop {
 
     /// Set up termination handler.  Have a signal set the `should_keep_running` atomic bool to
     /// false.  Panics of called more than once.
-    fn setup_termination_handler(&self) {
-        let keep_running_writer = self.should_keep_running.clone();
+    pub fn setup_termination_handler(keep_running_writer: Arc<AtomicBool>) {
         let install = termination::set_handler(move |sig_id| match sig_id {
             SignalId::Bus => {
                 let msg = "Caught SIGBUS; crashing immediately and dumping core\n";
@@ -355,17 +377,18 @@ impl RunLoop {
     /// Instantiate the burnchain client and databases.
     /// Fetches headers and instantiates the burnchain.
     /// Panics on failure.
-    fn instantiate_burnchain_state(
-        &mut self,
+    pub fn instantiate_burnchain_state(
+        config: &Config,
+        should_keep_running: Arc<AtomicBool>,
         burnchain_opt: Option<Burnchain>,
         coordinator_senders: CoordinatorChannels,
     ) -> BitcoinRegtestController {
         // Initialize and start the burnchain.
         let mut burnchain_controller = BitcoinRegtestController::with_burnchain(
-            self.config.clone(),
+            config.clone(),
             Some(coordinator_senders),
             burnchain_opt,
-            Some(self.should_keep_running.clone()),
+            Some(should_keep_running.clone()),
         );
 
         let burnchain = burnchain_controller.get_burnchain();
@@ -377,9 +400,9 @@ impl RunLoop {
         // Upgrade chainstate databases if they exist already
         match migrate_chainstate_dbs(
             &epochs,
-            &self.config.get_burn_db_file_path(),
-            &self.config.get_chainstate_path_str(),
-            Some(self.config.node.get_marf_opts()),
+            &config.get_burn_db_file_path(),
+            &config.get_chainstate_path_str(),
+            Some(config.node.get_marf_opts()),
         ) {
             Ok(_) => {}
             Err(coord_error::DBError(db_error::TooOldForEpoch)) => {
@@ -951,9 +974,13 @@ impl RunLoop {
             .take()
             .expect("Run loop already started, can only start once after initialization.");
 
-        self.setup_termination_handler();
-        let mut burnchain =
-            self.instantiate_burnchain_state(burnchain_opt, coordinator_senders.clone());
+        Self::setup_termination_handler(self.should_keep_running.clone());
+        let mut burnchain = Self::instantiate_burnchain_state(
+            &self.config,
+            self.should_keep_running.clone(),
+            burnchain_opt,
+            coordinator_senders.clone(),
+        );
 
         let burnchain_config = burnchain.get_burnchain();
         self.burnchain = Some(burnchain_config.clone());
diff --git a/testnet/stacks-node/src/tests/bitcoin_regtest.rs b/testnet/stacks-node/src/tests/bitcoin_regtest.rs
index fdb09dd22c..454e92b50b 100644
--- a/testnet/stacks-node/src/tests/bitcoin_regtest.rs
+++ b/testnet/stacks-node/src/tests/bitcoin_regtest.rs
@@ -16,6 +16,7 @@ use crate::helium::RunLoop;
 use crate::tests::to_addr;
 use crate::Config;
 
+#[derive(Debug)]
 pub enum BitcoinCoreError {
     SpawnFailed(String),
 }
diff --git a/testnet/stacks-node/src/tests/mod.rs b/testnet/stacks-node/src/tests/mod.rs
index faea7f99d9..8ac9fcff53 100644
--- a/testnet/stacks-node/src/tests/mod.rs
+++ b/testnet/stacks-node/src/tests/mod.rs
@@ -43,6 +43,7 @@ mod epoch_23;
 mod epoch_24;
 mod integrations;
 mod mempool;
+mod nakamoto_integrations;
 pub mod neon_integrations;
 mod signer;
 mod stackerdb;
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
new file mode 100644
index 0000000000..efa36ea1e5
--- /dev/null
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -0,0 +1,322 @@
+use clarity::vm::types::PrincipalData;
+use stacks::burnchains::MagicBytes;
+use stacks::chainstate::nakamoto::NakamotoChainState;
+use stacks::chainstate::stacks::db::StacksChainState;
+use stacks::core::{
+    StacksEpoch, StacksEpochId, BLOCK_LIMIT_MAINNET_10, HELIUM_BLOCK_LIMIT_20,
+    PEER_VERSION_EPOCH_1_0, PEER_VERSION_EPOCH_2_0, PEER_VERSION_EPOCH_2_05,
+    PEER_VERSION_EPOCH_2_1, PEER_VERSION_EPOCH_2_2, PEER_VERSION_EPOCH_2_3, PEER_VERSION_EPOCH_2_4,
+    PEER_VERSION_EPOCH_2_5, PEER_VERSION_EPOCH_3_0,
+};
+use stacks_common::address::AddressHashMode;
+use stacks_common::consts::STACKS_EPOCH_MAX;
+use stacks_common::types::chainstate::StacksAddress;
+use stacks_common::util::hash::to_hex;
+use stacks_common::util::secp256k1::Secp256k1PrivateKey;
+use std::sync::atomic::Ordering;
+use std::time::{Duration, Instant};
+use std::{env, thread};
+
+use super::bitcoin_regtest::BitcoinCoreController;
+use crate::mockamoto::signer::SelfSigner;
+use crate::run_loop::nakamoto;
+use crate::tests::neon_integrations::{
+    next_block_and_wait, run_until_burnchain_height, submit_tx, wait_for_runloop,
+};
+use crate::{
+    neon, tests, BitcoinRegtestController, BurnchainController, Config, ConfigFile, Keychain,
+};
+use lazy_static::lazy_static;
+
+lazy_static! {
+    pub static ref NAKAMOTO_INTEGRATION_EPOCHS: [StacksEpoch; 9] = [
+        StacksEpoch {
+            epoch_id: StacksEpochId::Epoch10,
+            start_height: 0,
+            end_height: 0,
+            block_limit: BLOCK_LIMIT_MAINNET_10.clone(),
+            network_epoch: PEER_VERSION_EPOCH_1_0
+        },
+        StacksEpoch {
+            epoch_id: StacksEpochId::Epoch20,
+            start_height: 0,
+            end_height: 1,
+            block_limit: HELIUM_BLOCK_LIMIT_20.clone(),
+            network_epoch: PEER_VERSION_EPOCH_2_0
+        },
+        StacksEpoch {
+            epoch_id: StacksEpochId::Epoch2_05,
+            start_height: 1,
+            end_height: 2,
+            block_limit: HELIUM_BLOCK_LIMIT_20.clone(),
+            network_epoch: PEER_VERSION_EPOCH_2_05
+        },
+        StacksEpoch {
+            epoch_id: StacksEpochId::Epoch21,
+            start_height: 2,
+            end_height: 3,
+            block_limit: HELIUM_BLOCK_LIMIT_20.clone(),
+            network_epoch: PEER_VERSION_EPOCH_2_1
+        },
+        StacksEpoch {
+            epoch_id: StacksEpochId::Epoch22,
+            start_height: 3,
+            end_height: 4,
+            block_limit: HELIUM_BLOCK_LIMIT_20.clone(),
+            network_epoch: PEER_VERSION_EPOCH_2_2
+        },
+        StacksEpoch {
+            epoch_id: StacksEpochId::Epoch23,
+            start_height: 4,
+            end_height: 5,
+            block_limit: HELIUM_BLOCK_LIMIT_20.clone(),
+            network_epoch: PEER_VERSION_EPOCH_2_3
+        },
+        StacksEpoch {
+            epoch_id: StacksEpochId::Epoch24,
+            start_height: 5,
+            end_height: 6,
+            block_limit: HELIUM_BLOCK_LIMIT_20.clone(),
+            network_epoch: PEER_VERSION_EPOCH_2_4
+        },
+        StacksEpoch {
+            epoch_id: StacksEpochId::Epoch25,
+            start_height: 6,
+            end_height: 220,
+            block_limit: HELIUM_BLOCK_LIMIT_20.clone(),
+            network_epoch: PEER_VERSION_EPOCH_2_5
+        },
+        StacksEpoch {
+            epoch_id: StacksEpochId::Epoch30,
+            start_height: 220,
+            end_height: STACKS_EPOCH_MAX,
+            block_limit: HELIUM_BLOCK_LIMIT_20.clone(),
+            network_epoch: PEER_VERSION_EPOCH_3_0
+        },
+    ];
+}
+
+/// Return a working nakamoto-neon config and the miner's bitcoin address to fund
+pub fn naka_neon_integration_conf(seed: Option<&[u8]>) -> (Config, StacksAddress) {
+    let mut conf = super::new_test_conf();
+    conf.burnchain.mode = "nakamoto-neon".into();
+
+    // tests can override this, but these tests run with epoch 2.05 by default
+    conf.burnchain.epochs = Some(NAKAMOTO_INTEGRATION_EPOCHS.to_vec());
+
+    if let Some(seed) = seed {
+        conf.node.seed = seed.to_vec();
+    }
+
+    // instantiate the keychain so we can fund the bitcoin op signer
+    let keychain = Keychain::default(conf.node.seed.clone());
+
+    let mining_key = Secp256k1PrivateKey::from_seed(&[1]);
+    conf.miner.mining_key = Some(mining_key);
+    conf.miner.self_signing_key = Some(SelfSigner::single_signer());
+
+    conf.node.miner = true;
+    conf.node.wait_time_for_microblocks = 500;
+    conf.burnchain.burn_fee_cap = 20000;
+
+    conf.burnchain.username = Some("neon-tester".into());
+    conf.burnchain.password = Some("neon-tester-pass".into());
+    conf.burnchain.peer_host = "127.0.0.1".into();
+    conf.burnchain.local_mining_public_key =
+        Some(keychain.generate_op_signer().get_public_key().to_hex());
+    conf.burnchain.commit_anchor_block_within = 0;
+
+    // test to make sure config file parsing is correct
+    let mut cfile = ConfigFile::xenon();
+    cfile.node.as_mut().map(|node| node.bootstrap_node.take());
+
+    if let Some(burnchain) = cfile.burnchain.as_mut() {
+        burnchain.peer_host = Some("127.0.0.1".to_string());
+    }
+
+    conf.burnchain.magic_bytes = MagicBytes::from(['T' as u8, '3' as u8].as_ref());
+    conf.burnchain.poll_time_secs = 1;
+    conf.node.pox_sync_sample_secs = 0;
+
+    conf.miner.min_tx_fee = 1;
+    conf.miner.first_attempt_time_ms = i64::max_value() as u64;
+    conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
+
+    // if there's just one node, then this must be true for tests to pass
+    conf.miner.wait_for_block_download = false;
+
+    conf.node.mine_microblocks = false;
+    conf.miner.microblock_attempt_time_ms = 10;
+    conf.node.microblock_frequency = 0;
+    conf.node.wait_time_for_blocks = 200;
+
+    let miner_account = keychain.origin_address(conf.is_mainnet()).unwrap();
+
+    conf.burnchain.pox_prepare_length = Some(5);
+    conf.burnchain.pox_reward_length = Some(20);
+
+    (conf, miner_account)
+}
+
+pub fn next_block_and<F>(
+    btc_controller: &mut BitcoinRegtestController,
+    timeout_secs: u64,
+    mut check: F,
+) -> Result<(), String>
+where
+    F: FnMut() -> Result<bool, String>,
+{
+    eprintln!("Issuing bitcoin block");
+    btc_controller.build_next_block(1);
+    let start = Instant::now();
+    while !check()? {
+        if start.elapsed() > Duration::from_secs(timeout_secs) {
+            error!("Timed out waiting for block to process, trying to continue test");
+            return Err("Timed out".into());
+        }
+        thread::sleep(Duration::from_millis(100));
+    }
+    Ok(())
+}
+
+#[test]
+#[ignore]
+fn simple_neon_integration() {
+    if env::var("BITCOIND_TEST") != Ok("1".into()) {
+        return;
+    }
+
+    let (mut naka_conf, _miner_account) = naka_neon_integration_conf(None);
+    let stacker_sk = Secp256k1PrivateKey::new();
+    let stacker_address = tests::to_addr(&stacker_sk);
+    naka_conf.add_initial_balance(
+        PrincipalData::from(stacker_address.clone()).to_string(),
+        100_000_000_000_000,
+    );
+
+    let epoch_2_conf = naka_conf.clone();
+
+    let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone());
+    btcd_controller
+        .start_bitcoind()
+        .expect("Failed starting bitcoind");
+
+    let mut btc_regtest_controller = BitcoinRegtestController::new(naka_conf.clone(), None);
+    let http_origin = format!("http://{}", &naka_conf.node.rpc_bind);
+    btc_regtest_controller.bootstrap_chain(201);
+
+    info!("Chain bootstrapped to bitcoin block 201, starting a epoch-2x miner");
+
+    let mut run_loop = neon::RunLoop::new(epoch_2_conf.clone());
+
+    let epoch_2_stopper = run_loop.get_termination_switch();
+    let blocks_processed = run_loop.get_blocks_processed_arc();
+    let epoch_2_thread = thread::spawn(move || run_loop.start(None, 0));
+    wait_for_runloop(&blocks_processed);
+    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+    // first mined stacks block
+    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+    // stack enough to activate pox-4
+    let pox_addr_tuple = clarity::vm::tests::execute(&format!(
+        "{{ hashbytes: 0x{}, version: 0x{:02x} }}",
+        to_hex(&[0; 20]),
+        AddressHashMode::SerializeP2PKH as u8,
+    ));
+
+    let stacking_tx = tests::make_contract_call(
+        &stacker_sk,
+        0,
+        1000,
+        &StacksAddress::burn_address(false),
+        "pox-4",
+        "stack-stx",
+        &[
+            clarity::vm::Value::UInt(99_000_000_000_000),
+            pox_addr_tuple,
+            clarity::vm::Value::UInt(205),
+            clarity::vm::Value::UInt(12),
+        ],
+    );
+
+    submit_tx(&http_origin, &stacking_tx);
+
+    run_until_burnchain_height(
+        &mut btc_regtest_controller,
+        &blocks_processed,
+        219,
+        &epoch_2_conf,
+    );
+
+    info!("Bootstrapped to Epoch-3.0 boundary, starting nakamoto miner");
+    epoch_2_stopper.store(false, Ordering::SeqCst);
+
+    epoch_2_thread.join().unwrap();
+
+    let mut run_loop = nakamoto::RunLoop::new(naka_conf.clone());
+    let epoch_3_stopper = run_loop.get_termination_switch();
+    let blocks_processed = run_loop.get_blocks_processed_arc();
+    let vrfs_submitted = run_loop.submitted_vrfs();
+    let commits_submitted = run_loop.submitted_commits();
+    let blocks_mined = run_loop.submitted_commits();
+    let coord_channel = run_loop.get_coordinator_channel().unwrap();
+
+    let epoch_3_thread = thread::spawn(move || run_loop.start(None, 0));
+
+    wait_for_runloop(&blocks_processed);
+    info!("Nakamoto miner started...");
+    // first block wakes up the run loop, wait until a key registration has been submitted.
+    next_block_and(&mut btc_regtest_controller, 60, || {
+        let vrf_count = vrfs_submitted.load(Ordering::SeqCst);
+        Ok(vrf_count >= 1)
+    })
+    .unwrap();
+
+    // second block should confirm the VRF register, wait until a block commit is submitted
+    next_block_and(&mut btc_regtest_controller, 60, || {
+        let commits_count = commits_submitted.load(Ordering::SeqCst);
+        Ok(commits_count >= 1)
+    })
+    .unwrap();
+
+    let blocks_processed_before_mining = coord_channel.get_stacks_blocks_processed();
+
+    // this block should perform the sortition, wait until a block is mined
+    next_block_and(&mut btc_regtest_controller, 60, || {
+        let mined_count = blocks_mined.load(Ordering::SeqCst);
+        Ok(mined_count >= 1)
+    })
+    .unwrap();
+
+    // wait until the coordinator has processed the new block(s)
+    while coord_channel.get_stacks_blocks_processed() <= blocks_processed_before_mining {
+        thread::sleep(Duration::from_secs(1));
+    }
+
+    // load the chain tip, and assert that it is a nakamoto block
+
+    let burnchain = naka_conf.get_burnchain();
+    let sortdb = burnchain.open_sortition_db(true).unwrap();
+    let (chainstate, _) = StacksChainState::open(
+        naka_conf.is_mainnet(),
+        naka_conf.burnchain.chain_id,
+        &naka_conf.get_chainstate_path_str(),
+        None,
+    )
+    .unwrap();
+
+    let tip = NakamotoChainState::get_canonical_block_header(chainstate.db(), &sortdb)
+        .unwrap()
+        .unwrap();
+    info!(
+        "Latest tip";
+        "is_nakamoto" => tip.anchored_header.as_stacks_nakamoto().is_some(),
+    );
+
+    assert!(tip.anchored_header.as_stacks_nakamoto().is_some());
+
+    coord_channel.stop_chains_coordinator();
+
+    epoch_3_stopper.store(false, Ordering::SeqCst);
+    epoch_3_thread.join().unwrap();
+}
diff --git a/testnet/stacks-node/src/tests/neon_integrations.rs b/testnet/stacks-node/src/tests/neon_integrations.rs
index b1e68d26d7..455e414208 100644
--- a/testnet/stacks-node/src/tests/neon_integrations.rs
+++ b/testnet/stacks-node/src/tests/neon_integrations.rs
@@ -483,7 +483,7 @@ pub mod test_observer {
     }
 }
 
-const PANIC_TIMEOUT_SECS: u64 = 600;
+const PANIC_TIMEOUT_SECS: u64 = 30;
 
 /// Returns `false` on a timeout, true otherwise.
 pub fn next_block_and_wait(
@@ -556,7 +556,7 @@ pub fn next_block_and_iterate(
 /// reaches *exactly* `target_height`.
 ///
 /// Returns `false` if `next_block_and_wait` times out.
-fn run_until_burnchain_height(
+pub fn run_until_burnchain_height(
     btc_regtest_controller: &mut BitcoinRegtestController,
     blocks_processed: &Arc<AtomicU64>,
     target_height: u64,

From c0ab89f312d8aa110ef7cdb29393603f380feeb2 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Thu, 7 Dec 2023 14:13:34 -0600
Subject: [PATCH 0201/1166] expand first nakamoto-neon test, update block
 commit logic to issue commits at tenure_id changes, cargo fmt-stacks

---
 .../burnchains/bitcoin_regtest_controller.rs  |  10 +-
 testnet/stacks-node/src/globals.rs            |  13 +-
 testnet/stacks-node/src/nakamoto_node.rs      |  14 +-
 .../stacks-node/src/nakamoto_node/miner.rs    |  26 +-
 testnet/stacks-node/src/nakamoto_node/peer.rs |  19 +-
 .../stacks-node/src/nakamoto_node/relayer.rs  |  95 +++----
 testnet/stacks-node/src/neon_node.rs          |   3 +-
 .../src/tests/nakamoto_integrations.rs        | 255 ++++++++++++++----
 8 files changed, 285 insertions(+), 150 deletions(-)

diff --git a/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs b/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
index ad83dd6f57..0ed1bb0e03 100644
--- a/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
+++ b/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
@@ -8,7 +8,8 @@ use async_h1::client;
 use async_std::io::ReadExt;
 use async_std::net::TcpStream;
 use base64::encode;
-
+#[cfg(test)]
+use clarity::vm::types::PrincipalData;
 use http_types::{Method, Request, Url};
 use serde::Serialize;
 use serde_json::json;
@@ -51,15 +52,12 @@ use stacks_common::deps_common::bitcoin::network::serialize::deserialize as btc_
 use stacks_common::deps_common::bitcoin::network::serialize::RawEncoder;
 use stacks_common::deps_common::bitcoin::util::hash::Sha256dHash;
 use stacks_common::types::chainstate::BurnchainHeaderHash;
+#[cfg(test)]
+use stacks_common::types::chainstate::StacksAddress;
 use stacks_common::util::hash::{hex_bytes, Hash160};
 use stacks_common::util::secp256k1::Secp256k1PublicKey;
 use stacks_common::util::sleep_ms;
 
-#[cfg(test)]
-use clarity::vm::types::PrincipalData;
-#[cfg(test)]
-use stacks_common::types::chainstate::StacksAddress;
-
 use super::super::operations::BurnchainOpSigner;
 use super::super::Config;
 use super::{BurnchainController, BurnchainTip, Error as BurnchainControllerError};
diff --git a/testnet/stacks-node/src/globals.rs b/testnet/stacks-node/src/globals.rs
index acace012f8..7e9e47a8fe 100644
--- a/testnet/stacks-node/src/globals.rs
+++ b/testnet/stacks-node/src/globals.rs
@@ -1,8 +1,6 @@
-use std::sync::atomic::AtomicBool;
-use std::sync::atomic::Ordering;
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::mpsc::SyncSender;
-use std::sync::Arc;
-use std::sync::Mutex;
+use std::sync::{Arc, Mutex};
 
 use stacks::burnchains::Txid;
 use stacks::chainstate::burn::operations::LeaderKeyRegisterOp;
@@ -12,16 +10,13 @@ use stacks::chainstate::stacks::db::unconfirmed::UnconfirmedTxMap;
 use stacks::chainstate::stacks::db::StacksChainState;
 use stacks::chainstate::stacks::miner::MinerStatus;
 use stacks::net::NetworkResult;
-use stacks_common::types::chainstate::BlockHeaderHash;
-use stacks_common::types::chainstate::BurnchainHeaderHash;
-use stacks_common::types::chainstate::ConsensusHash;
+use stacks_common::types::chainstate::{BlockHeaderHash, BurnchainHeaderHash, ConsensusHash};
 
 use crate::neon::Counters;
+use crate::neon_node::LeaderKeyRegistrationState;
 use crate::run_loop::RegisteredKey;
 use crate::syncctl::PoxSyncWatchdogComms;
 
-use crate::neon_node::LeaderKeyRegistrationState;
-
 /// Command types for the relayer thread, issued to it by other threads
 pub enum RelayerDirective {
     /// Handle some new data that arrived on the network (such as blocks, transactions, and
diff --git a/testnet/stacks-node/src/nakamoto_node.rs b/testnet/stacks-node/src/nakamoto_node.rs
index 1c71b09045..de0d04cfb5 100644
--- a/testnet/stacks-node/src/nakamoto_node.rs
+++ b/testnet/stacks-node/src/nakamoto_node.rs
@@ -20,13 +20,6 @@ use std::sync::mpsc::Receiver;
 use std::thread;
 use std::thread::JoinHandle;
 
-use super::{Config, EventDispatcher, Keychain};
-use crate::burnchains::bitcoin_regtest_controller::addr2str;
-use crate::globals::Globals;
-use crate::globals::RelayerDirective;
-use crate::neon_node::LeaderKeyRegistrationState;
-use crate::run_loop::nakamoto::RunLoop;
-use crate::run_loop::RegisteredKey;
 use clarity::vm::ast::ASTRules;
 use clarity::vm::types::QualifiedContractIdentifier;
 use stacks::burnchains::{Burnchain, BurnchainSigner, Txid};
@@ -52,6 +45,13 @@ use stacks_common::types::StacksEpochId;
 use stacks_common::util::get_epoch_time_secs;
 use stacks_common::util::secp256k1::Secp256k1PrivateKey;
 
+use super::{Config, EventDispatcher, Keychain};
+use crate::burnchains::bitcoin_regtest_controller::addr2str;
+use crate::globals::{Globals, RelayerDirective};
+use crate::neon_node::LeaderKeyRegistrationState;
+use crate::run_loop::nakamoto::RunLoop;
+use crate::run_loop::RegisteredKey;
+
 pub mod miner;
 pub mod peer;
 pub mod relayer;
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index cb9942d451..2d2d88293a 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -18,14 +18,6 @@ use std::thread;
 use std::thread::JoinHandle;
 use std::time::Instant;
 
-use super::relayer::RelayerThread;
-use super::Error as NakamotoNodeError;
-use super::{Config, EventDispatcher, Keychain};
-use crate::globals::Globals;
-use crate::mockamoto::signer::SelfSigner;
-use crate::nakamoto_node::VRF_MOCK_MINER_KEY;
-use crate::run_loop::RegisteredKey;
-use crate::ChainTip;
 use clarity::vm::types::PrincipalData;
 use stacks::burnchains::{Burnchain, BurnchainParameters};
 use stacks::chainstate::burn::db::sortdb::SortitionDB;
@@ -33,12 +25,9 @@ use stacks::chainstate::burn::{BlockSnapshot, ConsensusHash};
 use stacks::chainstate::nakamoto::miner::{NakamotoBlockBuilder, NakamotoTenureStart};
 use stacks::chainstate::nakamoto::{NakamotoBlock, NakamotoChainState};
 use stacks::chainstate::stacks::db::{StacksChainState, StacksHeaderInfo};
-use stacks::chainstate::stacks::Error as ChainstateError;
-use stacks::chainstate::stacks::TenureChangeCause;
-use stacks::chainstate::stacks::TenureChangePayload;
-use stacks::chainstate::stacks::ThresholdSignature;
 use stacks::chainstate::stacks::{
-    CoinbasePayload, StacksTransaction, StacksTransactionSigner, TransactionAnchorMode,
+    CoinbasePayload, Error as ChainstateError, StacksTransaction, StacksTransactionSigner,
+    TenureChangeCause, TenureChangePayload, ThresholdSignature, TransactionAnchorMode,
     TransactionPayload, TransactionVersion,
 };
 use stacks::core::mempool::MemPoolDB;
@@ -46,11 +35,18 @@ use stacks::core::FIRST_BURNCHAIN_CONSENSUS_HASH;
 use stacks::cost_estimates::metrics::UnitMetric;
 use stacks::cost_estimates::UnitEstimator;
 use stacks_common::types::chainstate::{StacksAddress, StacksBlockId};
-use stacks_common::types::PrivateKey;
-use stacks_common::types::StacksEpochId;
+use stacks_common::types::{PrivateKey, StacksEpochId};
 use stacks_common::util::hash::Hash160;
 use stacks_common::util::vrf::VRFProof;
 
+use super::relayer::RelayerThread;
+use super::{Config, Error as NakamotoNodeError, EventDispatcher, Keychain};
+use crate::globals::Globals;
+use crate::mockamoto::signer::SelfSigner;
+use crate::nakamoto_node::VRF_MOCK_MINER_KEY;
+use crate::run_loop::RegisteredKey;
+use crate::ChainTip;
+
 pub enum MinerDirective {
     /// The miner won sortition so they should begin a new tenure
     BeginTenure {
diff --git a/testnet/stacks-node/src/nakamoto_node/peer.rs b/testnet/stacks-node/src/nakamoto_node/peer.rs
index 8fe688972e..9f2a37c50d 100644
--- a/testnet/stacks-node/src/nakamoto_node/peer.rs
+++ b/testnet/stacks-node/src/nakamoto_node/peer.rs
@@ -13,45 +13,32 @@
 //
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
-use std::cmp;
 use std::collections::VecDeque;
-
 use std::default::Default;
 use std::net::SocketAddr;
 use std::sync::mpsc::TrySendError;
-
-use std::thread;
 use std::time::Duration;
+use std::{cmp, thread};
 
 use stacks::burnchains::db::BurnchainHeaderReader;
 use stacks::burnchains::PoxConstants;
 use stacks::chainstate::burn::db::sortdb::SortitionDB;
-
 use stacks::chainstate::stacks::db::StacksChainState;
 use stacks::chainstate::stacks::miner::signal_mining_blocked;
-
 use stacks::core::mempool::MemPoolDB;
-
 use stacks::cost_estimates::metrics::{CostMetric, UnitMetric};
 use stacks::cost_estimates::{CostEstimator, FeeEstimator, UnitEstimator};
-
 use stacks::net::dns::{DNSClient, DNSResolver};
 use stacks::net::p2p::PeerNetwork;
-
 use stacks::net::RPCHandlerArgs;
-
 use stacks_common::util::hash::Sha256Sum;
 
+use super::open_chainstate_with_faults;
 use crate::burnchains::make_bitcoin_indexer;
-use crate::globals::Globals;
-use crate::globals::RelayerDirective;
-
+use crate::globals::{Globals, RelayerDirective};
 use crate::run_loop::nakamoto::RunLoop;
-
 use crate::{Config, EventDispatcher};
 
-use super::open_chainstate_with_faults;
-
 /// Thread that runs the network state machine, handling both p2p and http requests.
 pub struct PeerThread {
     /// Node config
diff --git a/testnet/stacks-node/src/nakamoto_node/relayer.rs b/testnet/stacks-node/src/nakamoto_node/relayer.rs
index a90b17866f..6aa4568d0b 100644
--- a/testnet/stacks-node/src/nakamoto_node/relayer.rs
+++ b/testnet/stacks-node/src/nakamoto_node/relayer.rs
@@ -13,6 +13,11 @@
 //
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
+use std::collections::HashMap;
+use std::sync::mpsc::{Receiver, RecvTimeoutError};
+use std::thread::JoinHandle;
+use std::time::{Duration, Instant};
+
 use stacks::burnchains::{Burnchain, Txid};
 use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::burn::operations::leader_block_commit::{
@@ -30,9 +35,9 @@ use stacks::chainstate::stacks::miner::{
     get_mining_spend_amount, signal_mining_blocked, signal_mining_ready,
 };
 use stacks::core::mempool::MemPoolDB;
-use stacks::core::FIRST_BURNCHAIN_CONSENSUS_HASH;
-use stacks::core::FIRST_STACKS_BLOCK_HASH;
-use stacks::core::STACKS_EPOCH_3_0_MARKER;
+use stacks::core::{
+    FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH, STACKS_EPOCH_3_0_MARKER,
+};
 use stacks::cost_estimates::metrics::UnitMetric;
 use stacks::cost_estimates::UnitEstimator;
 use stacks::monitoring::increment_stx_blocks_mined_counter;
@@ -46,21 +51,13 @@ use stacks_common::types::StacksEpochId;
 use stacks_common::util::get_epoch_time_ms;
 use stacks_common::util::hash::Hash160;
 use stacks_common::util::vrf::{VRFProof, VRFPublicKey};
-use std::collections::HashMap;
-use std::sync::mpsc::Receiver;
-use std::sync::mpsc::RecvTimeoutError;
-use std::thread::JoinHandle;
-use std::time::Duration;
-use std::time::Instant;
 
-use super::Error as NakamotoNodeError;
 use super::{
     fault_injection_skip_mining, open_chainstate_with_faults, BlockCommits, Config,
-    EventDispatcher, Keychain, BLOCK_PROCESSOR_STACK_SIZE,
+    Error as NakamotoNodeError, EventDispatcher, Keychain, BLOCK_PROCESSOR_STACK_SIZE,
 };
 use crate::burnchains::BurnchainController;
-use crate::globals::Globals;
-use crate::globals::RelayerDirective;
+use crate::globals::{Globals, RelayerDirective};
 use crate::nakamoto_node::miner::{BlockMinerThread, MinerDirective};
 use crate::neon_node::LeaderKeyRegistrationState;
 use crate::run_loop::nakamoto::RunLoop;
@@ -127,8 +124,9 @@ pub struct RelayerThread {
     ///  to check if it should issue a block commit or try to register a VRF key
     next_initiative: Instant,
     is_miner: bool,
-    /// This is the last snapshot in which the relayer committed
-    last_committed_at: Option<BlockSnapshot>,
+    /// This is the last snapshot in which the relayer committed, and the parent_tenure_id
+    ///  which was committed to
+    last_committed: Option<(BlockSnapshot, StacksBlockId)>,
 }
 
 impl RelayerThread {
@@ -193,7 +191,7 @@ impl RelayerThread {
             miner_thread: None,
             is_miner,
             next_initiative: Instant::now() + Duration::from_secs(10),
-            last_committed_at: None,
+            last_committed: None,
         }
     }
 
@@ -759,7 +757,10 @@ impl RelayerThread {
         );
 
         self.last_commits.insert(txid, ());
-        self.last_committed_at = Some(last_committed_at);
+        self.last_committed = Some((
+            last_committed_at,
+            StacksBlockId::new(&tenure_start_ch, &tenure_start_bh),
+        ));
         self.globals.counters.bump_naka_submitted_commits();
 
         Ok(())
@@ -800,7 +801,10 @@ impl RelayerThread {
             return None;
         };
 
-        let should_commit = if let Some(last_committed_at) = self.last_committed_at.as_ref() {
+        // check if the burnchain changed, if so, we should issue a commit.
+        //  if not, we may still want to update a commit if we've received a new tenure start block
+        let burnchain_changed = if let Some((last_committed_at, ..)) = self.last_committed.as_ref()
+        {
             // if the new sortition tip has a different consesus hash than the last commit,
             //  issue a new commit
             sort_tip.consensus_hash != last_committed_at.consensus_hash
@@ -820,37 +824,38 @@ impl RelayerThread {
             ));
         };
 
-        if should_commit {
-            // TODO: just use `get_block_header_by_consensus_hash`?
-            let first_block_hash = if chain_tip_header
-                .anchored_header
-                .as_stacks_nakamoto()
-                .is_some()
-            {
-                // if the parent block is a nakamoto block, find the starting block of its tenure
-                let Ok(Some(first_block)) =
-                    NakamotoChainState::get_nakamoto_tenure_start_block_header(
-                        self.chainstate_ref().db(),
-                        &chain_tip_header.consensus_hash,
-                    )
-                else {
-                    warn!("Failure getting the first block of tenure in order to assemble block commit";
-                          "tenure_consensus_hash" => %chain_tip_header.consensus_hash,
-                          "tip_block_hash" => %chain_tip_header.anchored_header.block_hash());
-                    return None;
-                };
-                first_block.anchored_header.block_hash()
+        // get the starting block of the chain tip's tenure
+        let Ok(Some(chain_tip_tenure_start)) =
+            NakamotoChainState::get_block_header_by_consensus_hash(
+                self.chainstate_ref().db(),
+                &chain_tip_header.consensus_hash,
+            )
+        else {
+            warn!("Failure getting the first block of tenure in order to assemble block commit";
+                  "tenure_consensus_hash" => %chain_tip_header.consensus_hash,
+                  "tip_block_hash" => %chain_tip_header.anchored_header.block_hash());
+            return None;
+        };
+
+        let chain_tip_tenure_id = chain_tip_tenure_start.index_block_hash();
+        let should_commit = burnchain_changed
+            || if let Some((_, last_committed_tenure_id)) = self.last_committed.as_ref() {
+                // if the tenure ID of the chain tip has changed, issue a new commit
+                last_committed_tenure_id != &chain_tip_tenure_id
             } else {
-                // otherwise the parent block is a epoch2 block, just return its hash directly
-                chain_tip_header.anchored_header.block_hash()
+                // should be unreachable, but either way, if
+                //  `self.last_committed` is None, we should issue a commit
+                true
             };
-            return Some(RelayerDirective::NakamotoTenureStartProcessed(
+
+        if should_commit {
+            Some(RelayerDirective::NakamotoTenureStartProcessed(
                 chain_tip_header.consensus_hash,
-                first_block_hash,
-            ));
+                chain_tip_header.anchored_header.block_hash(),
+            ))
+        } else {
+            None
         }
-
-        return None;
     }
 
     /// Main loop of the relayer.
diff --git a/testnet/stacks-node/src/neon_node.rs b/testnet/stacks-node/src/neon_node.rs
index c23bf1fc19..a3821fae2b 100644
--- a/testnet/stacks-node/src/neon_node.rs
+++ b/testnet/stacks-node/src/neon_node.rs
@@ -206,8 +206,7 @@ use crate::burnchains::bitcoin_regtest_controller::{
     addr2str, BitcoinRegtestController, OngoingBlockCommit,
 };
 use crate::burnchains::make_bitcoin_indexer;
-use crate::globals::Globals;
-use crate::globals::RelayerDirective;
+use crate::globals::{Globals, RelayerDirective};
 use crate::run_loop::neon::RunLoop;
 use crate::run_loop::RegisteredKey;
 use crate::ChainTip;
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index efa36ea1e5..a7be83272f 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -1,32 +1,43 @@
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::Arc;
+use std::time::{Duration, Instant};
+use std::{env, thread};
+
+use clarity::vm::costs::ExecutionCost;
 use clarity::vm::types::PrincipalData;
+use lazy_static::lazy_static;
 use stacks::burnchains::MagicBytes;
+use stacks::chainstate::coordinator::comm::CoordinatorChannels;
 use stacks::chainstate::nakamoto::NakamotoChainState;
 use stacks::chainstate::stacks::db::StacksChainState;
 use stacks::core::{
-    StacksEpoch, StacksEpochId, BLOCK_LIMIT_MAINNET_10, HELIUM_BLOCK_LIMIT_20,
+    MemPoolDB, StacksEpoch, StacksEpochId, BLOCK_LIMIT_MAINNET_10, HELIUM_BLOCK_LIMIT_20,
     PEER_VERSION_EPOCH_1_0, PEER_VERSION_EPOCH_2_0, PEER_VERSION_EPOCH_2_05,
     PEER_VERSION_EPOCH_2_1, PEER_VERSION_EPOCH_2_2, PEER_VERSION_EPOCH_2_3, PEER_VERSION_EPOCH_2_4,
     PEER_VERSION_EPOCH_2_5, PEER_VERSION_EPOCH_3_0,
 };
+use stacks::cost_estimates::metrics::UnitMetric;
+use stacks::cost_estimates::UnitEstimator;
 use stacks_common::address::AddressHashMode;
 use stacks_common::consts::STACKS_EPOCH_MAX;
 use stacks_common::types::chainstate::StacksAddress;
 use stacks_common::util::hash::to_hex;
 use stacks_common::util::secp256k1::Secp256k1PrivateKey;
-use std::sync::atomic::Ordering;
-use std::time::{Duration, Instant};
-use std::{env, thread};
 
 use super::bitcoin_regtest::BitcoinCoreController;
+use crate::config::{EventKeyType, EventObserverConfig};
 use crate::mockamoto::signer::SelfSigner;
 use crate::run_loop::nakamoto;
+use crate::tests::make_stacks_transfer;
 use crate::tests::neon_integrations::{
-    next_block_and_wait, run_until_burnchain_height, submit_tx, wait_for_runloop,
+    next_block_and_wait, run_until_burnchain_height, submit_tx, test_observer, wait_for_runloop,
 };
 use crate::{
     neon, tests, BitcoinRegtestController, BurnchainController, Config, ConfigFile, Keychain,
 };
-use lazy_static::lazy_static;
+
+static POX_4_DEFAULT_STACKER_BALANCE: u64 = 100_000_000_000_000;
+static POX_4_DEFAULT_STACKER_STX_AMT: u128 = 99_000_000_000_000;
 
 lazy_static! {
     pub static ref NAKAMOTO_INTEGRATION_EPOCHS: [StacksEpoch; 9] = [
@@ -179,44 +190,83 @@ where
     Ok(())
 }
 
-#[test]
-#[ignore]
-fn simple_neon_integration() {
-    if env::var("BITCOIND_TEST") != Ok("1".into()) {
-        return;
-    }
+/// Mine a bitcoin block, and wait until:
+///  (1) a new block has been processed by the coordinator
+///  (2) 2 block commits have been issued ** or ** more than 10 seconds have
+///      passed since (1) occurred
+fn next_block_and_mine_commit(
+    btc_controller: &mut BitcoinRegtestController,
+    timeout_secs: u64,
+    coord_channels: &CoordinatorChannels,
+    commits_submitted: &Arc<AtomicU64>,
+) -> Result<(), String> {
+    let commits_submitted = commits_submitted.clone();
+    let blocks_processed_before = coord_channels.get_stacks_blocks_processed();
+    let commits_before = commits_submitted.load(Ordering::SeqCst);
+    let mut block_processed_time: Option<Instant> = None;
+    next_block_and(btc_controller, timeout_secs, || {
+        if let Some(block_processed_time) = block_processed_time.as_ref() {
+            let commits_sent = commits_submitted.load(Ordering::SeqCst);
+            if commits_sent >= commits_before + 2 {
+                return Ok(true);
+            }
+            if commits_sent >= commits_before + 1
+                && block_processed_time.elapsed() > Duration::from_secs(10)
+            {
+                return Ok(true);
+            }
+            Ok(false)
+        } else {
+            let blocks_processed = coord_channels.get_stacks_blocks_processed();
+            if blocks_processed > blocks_processed_before {
+                block_processed_time.replace(Instant::now());
+            }
+            Ok(false)
+        }
+    })
+}
 
-    let (mut naka_conf, _miner_account) = naka_neon_integration_conf(None);
+fn setup_stacker(naka_conf: &mut Config) -> Secp256k1PrivateKey {
     let stacker_sk = Secp256k1PrivateKey::new();
     let stacker_address = tests::to_addr(&stacker_sk);
     naka_conf.add_initial_balance(
         PrincipalData::from(stacker_address.clone()).to_string(),
-        100_000_000_000_000,
+        POX_4_DEFAULT_STACKER_BALANCE,
     );
+    stacker_sk
+}
 
+///
+/// * `stacker_sk` - must be a private key for sending a large `stack-stx` transaction in order
+///   for pox-4 to activate
+fn boot_to_epoch_3(
+    naka_conf: &Config,
+    stacker_sk: Secp256k1PrivateKey,
+    btc_regtest_controller: &mut BitcoinRegtestController,
+) {
     let epoch_2_conf = naka_conf.clone();
-
-    let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone());
-    btcd_controller
-        .start_bitcoind()
-        .expect("Failed starting bitcoind");
-
-    let mut btc_regtest_controller = BitcoinRegtestController::new(naka_conf.clone(), None);
-    let http_origin = format!("http://{}", &naka_conf.node.rpc_bind);
     btc_regtest_controller.bootstrap_chain(201);
 
-    info!("Chain bootstrapped to bitcoin block 201, starting a epoch-2x miner");
+    let epochs = epoch_2_conf.burnchain.epochs.clone().unwrap();
 
+    let epoch_3 = &epochs[StacksEpoch::find_epoch_by_id(&epochs, StacksEpochId::Epoch30).unwrap()];
+
+    info!(
+        "Chain bootstrapped to bitcoin block 201, starting Epoch 2x miner";
+        "Epoch 3.0 Boundary" => (epoch_3.start_height - 1),
+    );
+    let http_origin = format!("http://{}", &epoch_2_conf.node.rpc_bind);
     let mut run_loop = neon::RunLoop::new(epoch_2_conf.clone());
 
     let epoch_2_stopper = run_loop.get_termination_switch();
     let blocks_processed = run_loop.get_blocks_processed_arc();
     let epoch_2_thread = thread::spawn(move || run_loop.start(None, 0));
     wait_for_runloop(&blocks_processed);
-    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
-    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+    next_block_and_wait(btc_regtest_controller, &blocks_processed);
+    next_block_and_wait(btc_regtest_controller, &blocks_processed);
     // first mined stacks block
-    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+    next_block_and_wait(btc_regtest_controller, &blocks_processed);
+
     // stack enough to activate pox-4
     let pox_addr_tuple = clarity::vm::tests::execute(&format!(
         "{{ hashbytes: 0x{}, version: 0x{:02x} }}",
@@ -232,7 +282,7 @@ fn simple_neon_integration() {
         "pox-4",
         "stack-stx",
         &[
-            clarity::vm::Value::UInt(99_000_000_000_000),
+            clarity::vm::Value::UInt(POX_4_DEFAULT_STACKER_STX_AMT),
             pox_addr_tuple,
             clarity::vm::Value::UInt(205),
             clarity::vm::Value::UInt(12),
@@ -242,23 +292,82 @@ fn simple_neon_integration() {
     submit_tx(&http_origin, &stacking_tx);
 
     run_until_burnchain_height(
-        &mut btc_regtest_controller,
+        btc_regtest_controller,
         &blocks_processed,
-        219,
+        epoch_3.start_height - 1,
         &epoch_2_conf,
     );
 
-    info!("Bootstrapped to Epoch-3.0 boundary, starting nakamoto miner");
+    info!("Bootstrapped to Epoch-3.0 boundary, stopping Epoch2x miner");
     epoch_2_stopper.store(false, Ordering::SeqCst);
-
     epoch_2_thread.join().unwrap();
+}
+
+#[test]
+#[ignore]
+/// This test spins up a nakamoto-neon node.
+/// It starts in Epoch 2.0, mines with `neon_node` to Epoch 3.0, and then switches
+///  to Nakamoto operation (activating pox-4 by submitting a stack-stx tx).
+/// This test makes three assertions:
+///  * 30 blocks are mined after 3.0 starts. This is enough to mine across 2 reward cycles
+///  * A transaction submitted to the mempool in 3.0 will be mined in 3.0
+///  * The final chain tip is a nakamoto block
+fn simple_neon_integration() {
+    if env::var("BITCOIND_TEST") != Ok("1".into()) {
+        return;
+    }
+
+    let (mut naka_conf, _miner_account) = naka_neon_integration_conf(None);
+    let sender_sk = Secp256k1PrivateKey::new();
+    // setup sender + recipient for a test stx transfer
+    let sender_addr = tests::to_addr(&sender_sk);
+    let send_amt = 1000;
+    let send_fee = 100;
+    naka_conf.add_initial_balance(
+        PrincipalData::from(sender_addr.clone()).to_string(),
+        send_amt + send_fee,
+    );
+    let recipient = PrincipalData::from(StacksAddress::burn_address(false));
+    let stacker_sk = setup_stacker(&mut naka_conf);
+
+    let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone());
+    btcd_controller
+        .start_bitcoind()
+        .expect("Failed starting bitcoind");
+    let mut btc_regtest_controller = BitcoinRegtestController::new(naka_conf.clone(), None);
+
+    boot_to_epoch_3(&naka_conf, stacker_sk, &mut btc_regtest_controller);
+
+    info!("Bootstrapped to Epoch-3.0 boundary, starting nakamoto miner");
+
+    let burnchain = naka_conf.get_burnchain();
+    let sortdb = burnchain.open_sortition_db(true).unwrap();
+    let (mut chainstate, _) = StacksChainState::open(
+        naka_conf.is_mainnet(),
+        naka_conf.burnchain.chain_id,
+        &naka_conf.get_chainstate_path_str(),
+        None,
+    )
+    .unwrap();
+
+    let block_height_pre_3_0 =
+        NakamotoChainState::get_canonical_block_header(chainstate.db(), &sortdb)
+            .unwrap()
+            .unwrap()
+            .stacks_block_height;
+
+    test_observer::spawn();
+    let observer_port = test_observer::EVENT_OBSERVER_PORT;
+    naka_conf.events_observers.insert(EventObserverConfig {
+        endpoint: format!("localhost:{observer_port}"),
+        events_keys: vec![EventKeyType::AnyEvent],
+    });
 
     let mut run_loop = nakamoto::RunLoop::new(naka_conf.clone());
     let epoch_3_stopper = run_loop.get_termination_switch();
     let blocks_processed = run_loop.get_blocks_processed_arc();
     let vrfs_submitted = run_loop.submitted_vrfs();
     let commits_submitted = run_loop.submitted_commits();
-    let blocks_mined = run_loop.submitted_commits();
     let coord_channel = run_loop.get_coordinator_channel().unwrap();
 
     let epoch_3_thread = thread::spawn(move || run_loop.start(None, 0));
@@ -279,41 +388,87 @@ fn simple_neon_integration() {
     })
     .unwrap();
 
-    let blocks_processed_before_mining = coord_channel.get_stacks_blocks_processed();
-
-    // this block should perform the sortition, wait until a block is mined
-    next_block_and(&mut btc_regtest_controller, 60, || {
-        let mined_count = blocks_mined.load(Ordering::SeqCst);
-        Ok(mined_count >= 1)
-    })
-    .unwrap();
-
-    // wait until the coordinator has processed the new block(s)
-    while coord_channel.get_stacks_blocks_processed() <= blocks_processed_before_mining {
-        thread::sleep(Duration::from_secs(1));
+    // Mine 15 nakamoto tenures
+    for _i in 0..15 {
+        next_block_and_mine_commit(
+            &mut btc_regtest_controller,
+            60,
+            &coord_channel,
+            &commits_submitted,
+        )
+        .unwrap();
     }
 
-    // load the chain tip, and assert that it is a nakamoto block
+    // Submit a TX
+    let transfer_tx = make_stacks_transfer(&sender_sk, 0, send_fee, &recipient, send_amt);
+    let transfer_tx_hex = format!("0x{}", to_hex(&transfer_tx));
 
-    let burnchain = naka_conf.get_burnchain();
-    let sortdb = burnchain.open_sortition_db(true).unwrap();
-    let (chainstate, _) = StacksChainState::open(
+    let tip = NakamotoChainState::get_canonical_block_header(chainstate.db(), &sortdb)
+        .unwrap()
+        .unwrap();
+
+    let mut mempool = MemPoolDB::open(
         naka_conf.is_mainnet(),
         naka_conf.burnchain.chain_id,
         &naka_conf.get_chainstate_path_str(),
-        None,
+        Box::new(UnitEstimator),
+        Box::new(UnitMetric),
     )
-    .unwrap();
+    .expect("Database failure opening mempool");
+
+    mempool
+        .submit_raw(
+            &mut chainstate,
+            &sortdb,
+            &tip.consensus_hash,
+            &tip.anchored_header.block_hash(),
+            transfer_tx.clone(),
+            &ExecutionCost::max_value(),
+            &StacksEpochId::Epoch30,
+        )
+        .unwrap();
 
+    // Mine 15 more nakamoto tenures
+    for _i in 0..15 {
+        next_block_and_mine_commit(
+            &mut btc_regtest_controller,
+            60,
+            &coord_channel,
+            &commits_submitted,
+        )
+        .unwrap();
+    }
+
+    // load the chain tip, and assert that it is a nakamoto block and at least 30 blocks have advanced in epoch 3
     let tip = NakamotoChainState::get_canonical_block_header(chainstate.db(), &sortdb)
         .unwrap()
         .unwrap();
     info!(
         "Latest tip";
+        "height" => tip.stacks_block_height,
         "is_nakamoto" => tip.anchored_header.as_stacks_nakamoto().is_some(),
     );
 
+    // assert that the transfer tx was observed
+    let transfer_tx_included = test_observer::get_blocks()
+        .into_iter()
+        .find(|block_json| {
+            block_json["transactions"]
+                .as_array()
+                .unwrap()
+                .iter()
+                .find(|tx_json| tx_json["raw_tx"].as_str() == Some(&transfer_tx_hex))
+                .is_some()
+        })
+        .is_some();
+
+    assert!(
+        transfer_tx_included,
+        "Nakamoto node failed to include the transfer tx"
+    );
+
     assert!(tip.anchored_header.as_stacks_nakamoto().is_some());
+    assert!(tip.stacks_block_height >= block_height_pre_3_0 + 30);
 
     coord_channel.stop_chains_coordinator();
 

From 7b7a5101de7ddf634ffe787f46d9ccdd4ffe436f Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Sat, 9 Dec 2023 13:02:21 -0600
Subject: [PATCH 0202/1166] feat: add boot_nakamoto to wrap the 2.x/3.x node
 handoff

---
 stackslib/src/burnchains/bitcoin/indexer.rs   |  13 +-
 stackslib/src/core/mod.rs                     |  27 +++
 testnet/stacks-node/src/main.rs               |   4 +-
 .../stacks-node/src/nakamoto_node/miner.rs    |   3 -
 .../stacks-node/src/run_loop/boot_nakamoto.rs | 205 ++++++++++++++++++
 testnet/stacks-node/src/run_loop/mod.rs       |   1 +
 testnet/stacks-node/src/run_loop/nakamoto.rs  |  11 +-
 .../src/tests/nakamoto_integrations.rs        |  99 +++++----
 8 files changed, 300 insertions(+), 63 deletions(-)
 create mode 100644 testnet/stacks-node/src/run_loop/boot_nakamoto.rs

diff --git a/stackslib/src/burnchains/bitcoin/indexer.rs b/stackslib/src/burnchains/bitcoin/indexer.rs
index c273a38de4..6f6b82ceec 100644
--- a/stackslib/src/burnchains/bitcoin/indexer.rs
+++ b/stackslib/src/burnchains/bitcoin/indexer.rs
@@ -46,7 +46,8 @@ use crate::burnchains::{
     Burnchain, BurnchainBlockHeader, Error as burnchain_error, MagicBytes, BLOCKSTACK_MAGIC_MAINNET,
 };
 use crate::core::{
-    StacksEpoch, STACKS_EPOCHS_MAINNET, STACKS_EPOCHS_REGTEST, STACKS_EPOCHS_TESTNET,
+    StacksEpoch, StacksEpochExtension, STACKS_EPOCHS_MAINNET, STACKS_EPOCHS_REGTEST,
+    STACKS_EPOCHS_TESTNET,
 };
 use crate::util_lib::db::Error as DBError;
 
@@ -91,7 +92,7 @@ impl TryFrom<u32> for BitcoinNetworkType {
 /// Get the default epochs definitions for the given BitcoinNetworkType.
 /// Should *not* be used except by the BitcoinIndexer when no epochs vector
 /// was specified.
-fn get_bitcoin_stacks_epochs(network_id: BitcoinNetworkType) -> Vec<StacksEpoch> {
+pub fn get_bitcoin_stacks_epochs(network_id: BitcoinNetworkType) -> Vec<StacksEpoch> {
     match network_id {
         BitcoinNetworkType::Mainnet => STACKS_EPOCHS_MAINNET.to_vec(),
         BitcoinNetworkType::Testnet => STACKS_EPOCHS_TESTNET.to_vec(),
@@ -1030,13 +1031,7 @@ impl BurnchainIndexer for BitcoinIndexer {
     ///
     /// It is an error (panic) to set custom epochs if running on `Mainnet`.
     fn get_stacks_epochs(&self) -> Vec<StacksEpoch> {
-        match self.config.epochs {
-            Some(ref epochs) => {
-                assert!(self.runtime.network_id != BitcoinNetworkType::Mainnet);
-                epochs.clone()
-            }
-            None => get_bitcoin_stacks_epochs(self.runtime.network_id),
-        }
+        StacksEpoch::get_epochs(self.runtime.network_id, self.config.epochs.as_ref())
     }
 
     /// Read downloaded headers within a range
diff --git a/stackslib/src/core/mod.rs b/stackslib/src/core/mod.rs
index b03fe0c8e0..38f383194e 100644
--- a/stackslib/src/core/mod.rs
+++ b/stackslib/src/core/mod.rs
@@ -25,6 +25,8 @@ pub use stacks_common::types::StacksEpochId;
 use stacks_common::util::log;
 
 pub use self::mempool::MemPoolDB;
+use crate::burnchains::bitcoin::indexer::get_bitcoin_stacks_epochs;
+use crate::burnchains::bitcoin::BitcoinNetworkType;
 use crate::burnchains::{Burnchain, Error as burnchain_error};
 use crate::chainstate::burn::ConsensusHash;
 pub mod mempool;
@@ -604,9 +606,34 @@ pub trait StacksEpochExtension {
         epoch_2_1_block_height: u64,
     ) -> Vec<StacksEpoch>;
     fn validate_epochs(epochs: &[StacksEpoch]) -> Vec<StacksEpoch>;
+    /// This method gets the epoch vector.
+    ///
+    /// Choose according to:
+    /// 1) Use the custom epochs defined on the underlying `BitcoinIndexerConfig`, if they exist.
+    /// 2) Use hard-coded static values, otherwise.
+    ///
+    /// It is an error (panic) to set custom epochs if running on `Mainnet`.
+    ///
+    fn get_epochs(
+        bitcoin_network: BitcoinNetworkType,
+        configured_epochs: Option<&Vec<StacksEpoch>>,
+    ) -> Vec<StacksEpoch>;
 }
 
 impl StacksEpochExtension for StacksEpoch {
+    fn get_epochs(
+        bitcoin_network: BitcoinNetworkType,
+        configured_epochs: Option<&Vec<StacksEpoch>>,
+    ) -> Vec<StacksEpoch> {
+        match configured_epochs {
+            Some(epochs) => {
+                assert!(bitcoin_network != BitcoinNetworkType::Mainnet);
+                epochs.clone()
+            }
+            None => get_bitcoin_stacks_epochs(bitcoin_network),
+        }
+    }
+
     #[cfg(test)]
     fn unit_test_pre_2_05(first_burnchain_height: u64) -> Vec<StacksEpoch> {
         info!(
diff --git a/testnet/stacks-node/src/main.rs b/testnet/stacks-node/src/main.rs
index 8675b43132..d180aead8b 100644
--- a/testnet/stacks-node/src/main.rs
+++ b/testnet/stacks-node/src/main.rs
@@ -46,7 +46,7 @@ pub use self::node::{ChainTip, Node};
 pub use self::run_loop::{helium, neon};
 pub use self::tenure::Tenure;
 use crate::mockamoto::MockamotoNode;
-use crate::run_loop::nakamoto;
+use crate::run_loop::boot_nakamoto;
 
 fn main() {
     panic::set_hook(Box::new(|panic_info| {
@@ -213,7 +213,7 @@ fn main() {
         let mut mockamoto = MockamotoNode::new(&conf).unwrap();
         mockamoto.run();
     } else if conf.burnchain.mode == "nakamoto-neon" {
-        let mut run_loop = nakamoto::RunLoop::new(conf);
+        let mut run_loop = boot_nakamoto::BootRunLoop::new(conf).unwrap();
         run_loop.start(None, 0);
     } else {
         println!("Burnchain mode '{}' not supported", conf.burnchain.mode);
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index 2d2d88293a..bc684a07bf 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -16,7 +16,6 @@
 use std::convert::TryFrom;
 use std::thread;
 use std::thread::JoinHandle;
-use std::time::Instant;
 
 use clarity::vm::types::PrincipalData;
 use stacks::burnchains::{Burnchain, BurnchainParameters};
@@ -398,8 +397,6 @@ impl BlockMinerThread {
         )
         .expect("Database failure opening mempool");
 
-        let assembly_start = Instant::now();
-
         let target_epoch_id =
             SortitionDB::get_stacks_epoch(burn_db.conn(), self.burn_block.block_height + 1)
                 .ok()?
diff --git a/testnet/stacks-node/src/run_loop/boot_nakamoto.rs b/testnet/stacks-node/src/run_loop/boot_nakamoto.rs
new file mode 100644
index 0000000000..1b54c24f5a
--- /dev/null
+++ b/testnet/stacks-node/src/run_loop/boot_nakamoto.rs
@@ -0,0 +1,205 @@
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Arc, Mutex};
+use std::thread::JoinHandle;
+use std::time::Duration;
+use std::{fs, thread};
+
+use stacks::burnchains::Burnchain;
+use stacks::chainstate::burn::db::sortdb::SortitionDB;
+use stacks::chainstate::coordinator::comm::CoordinatorChannels;
+use stacks::core::StacksEpochExtension;
+use stacks_common::types::{StacksEpoch, StacksEpochId};
+
+use crate::neon::Counters;
+use crate::run_loop::nakamoto::RunLoop as NakaRunLoop;
+use crate::run_loop::neon::RunLoop as NeonRunLoop;
+use crate::Config;
+
+/// This runloop handles booting to Nakamoto:
+/// During epochs [1.0, 2.5], it runs a neon run_loop.
+/// Once epoch 3.0 is reached, it stops the neon run_loop
+///  and starts nakamoto.
+pub struct BootRunLoop {
+    config: Config,
+    active_loop: InnerLoops,
+    coordinator_channels: Arc<Mutex<CoordinatorChannels>>,
+}
+
+enum InnerLoops {
+    Epoch2(NeonRunLoop),
+    Epoch3(NakaRunLoop),
+}
+
+impl BootRunLoop {
+    pub fn new(config: Config) -> Result<Self, String> {
+        let (coordinator_channels, active_loop) = if !Self::reached_epoch_30_transition(&config)? {
+            let neon = NeonRunLoop::new(config.clone());
+            (
+                neon.get_coordinator_channel().unwrap(),
+                InnerLoops::Epoch2(neon),
+            )
+        } else {
+            let naka = NakaRunLoop::new(config.clone(), None, None);
+            (
+                naka.get_coordinator_channel().unwrap(),
+                InnerLoops::Epoch3(naka),
+            )
+        };
+
+        Ok(BootRunLoop {
+            config,
+            active_loop,
+            coordinator_channels: Arc::new(Mutex::new(coordinator_channels)),
+        })
+    }
+
+    /// Get a mutex-guarded pointer to this run-loops coordinator channels.
+    ///  The reason this must be mutex guarded is that the run loop will switch
+    ///  from a "neon" coordinator to a "nakamoto" coordinator, and update the
+    ///  backing coordinator channel. That way, anyone still holding the Arc<>
+    ///  should be able to query the new coordinator channel.
+    pub fn coordinator_channels(&self) -> Arc<Mutex<CoordinatorChannels>> {
+        self.coordinator_channels.clone()
+    }
+
+    /// Get the runtime counters for the inner runloop. The nakamoto
+    ///  runloop inherits the counters object from the neon node,
+    ///  so no need for another layer of indirection/mutex.
+    pub fn counters(&self) -> Counters {
+        match &self.active_loop {
+            InnerLoops::Epoch2(x) => x.get_counters(),
+            InnerLoops::Epoch3(x) => x.get_counters(),
+        }
+    }
+
+    /// Get the termination switch from the active run loop.
+    pub fn get_termination_switch(&self) -> Arc<AtomicBool> {
+        match &self.active_loop {
+            InnerLoops::Epoch2(x) => x.get_termination_switch(),
+            InnerLoops::Epoch3(x) => x.get_termination_switch(),
+        }
+    }
+
+    /// The main entry point for the run loop. This starts either a 2.x-neon or 3.x-nakamoto
+    /// node depending on the current burnchain height.
+    pub fn start(&mut self, burnchain_opt: Option<Burnchain>, mine_start: u64) {
+        match self.active_loop {
+            InnerLoops::Epoch2(_) => return self.start_from_neon(burnchain_opt, mine_start),
+            InnerLoops::Epoch3(_) => return self.start_from_naka(burnchain_opt, mine_start),
+        }
+    }
+
+    fn start_from_naka(&mut self, burnchain_opt: Option<Burnchain>, mine_start: u64) {
+        let InnerLoops::Epoch3(ref mut naka_loop) = self.active_loop else {
+            panic!("FATAL: unexpectedly invoked start_from_naka when active loop wasn't nakamoto");
+        };
+        naka_loop.start(burnchain_opt, mine_start)
+    }
+
+    fn start_from_neon(&mut self, burnchain_opt: Option<Burnchain>, mine_start: u64) {
+        let InnerLoops::Epoch2(ref mut neon_loop) = self.active_loop else {
+            panic!("FATAL: unexpectedly invoked start_from_neon when active loop wasn't neon");
+        };
+        let termination_switch = neon_loop.get_termination_switch();
+        let counters = neon_loop.get_counters();
+
+        let boot_thread = Self::spawn_stopper(&self.config, neon_loop)
+            .expect("FATAL: failed to spawn epoch-2/3-boot thread");
+        neon_loop.start(burnchain_opt.clone(), mine_start);
+
+        // did we exit because of the epoch-3.0 transition, or some other reason?
+        let exited_for_transition = boot_thread
+            .join()
+            .expect("FATAL: failed to join epoch-2/3-boot thread");
+        if !exited_for_transition {
+            info!("Shutting down epoch-2/3 transition thread");
+            return;
+        }
+        info!("Reached Epoch-3.0 boundary, starting nakamoto node");
+        termination_switch.store(true, Ordering::SeqCst);
+        let naka = NakaRunLoop::new(
+            self.config.clone(),
+            Some(termination_switch),
+            Some(counters),
+        );
+        let new_coord_channels = naka
+            .get_coordinator_channel()
+            .expect("FATAL: should have coordinator channel in newly instantiated runloop");
+        {
+            let mut coord_channel = self.coordinator_channels.lock().expect("Mutex poisoned");
+            *coord_channel = new_coord_channels;
+        }
+        self.active_loop = InnerLoops::Epoch3(naka);
+        let InnerLoops::Epoch3(ref mut naka_loop) = self.active_loop else {
+            panic!("FATAL: unexpectedly found epoch2 loop after setting epoch3 active");
+        };
+        naka_loop.start(burnchain_opt, mine_start)
+    }
+
+    fn spawn_stopper(
+        config: &Config,
+        neon: &NeonRunLoop,
+    ) -> Result<JoinHandle<bool>, std::io::Error> {
+        let neon_term_switch = neon.get_termination_switch();
+        let config = config.clone();
+        thread::Builder::new()
+            .name("epoch-2/3-boot".into())
+            .spawn(move || {
+                loop {
+                    let do_transition = Self::reached_epoch_30_transition(&config)
+                        .unwrap_or_else(|err| {
+                            warn!("Error checking for Epoch-3.0 transition: {err:?}. Assuming transition did not occur yet.");
+                            false
+                        });
+                    if do_transition {
+                        break;
+                    }
+                    if !neon_term_switch.load(Ordering::SeqCst) {
+                        info!("Stop requested, exiting epoch-2/3-boot thread");
+                        return false;
+                    }
+                    thread::sleep(Duration::from_secs(1));
+                }
+                // if loop exited, do the transition
+                info!("Epoch-3.0 boundary reached, stopping Epoch-2.x run loop");
+                neon_term_switch.store(false, Ordering::SeqCst);
+                return true
+            })
+    }
+
+    fn reached_epoch_30_transition(config: &Config) -> Result<bool, String> {
+        let burn_height = Self::get_burn_height(config)?;
+        let epochs = StacksEpoch::get_epochs(
+            config.burnchain.get_bitcoin_network().1,
+            config.burnchain.epochs.as_ref(),
+        );
+        let epoch_3 = &epochs[StacksEpoch::find_epoch_by_id(&epochs, StacksEpochId::Epoch30)
+            .ok_or("No Epoch-3.0 defined")?];
+
+        Ok(u64::from(burn_height) >= epoch_3.start_height - 1)
+    }
+
+    fn get_burn_height(config: &Config) -> Result<u32, String> {
+        let burnchain = config.get_burnchain();
+        let sortdb_path = config.get_burn_db_file_path();
+        if fs::metadata(&sortdb_path).is_err() {
+            // if the sortition db doesn't exist yet, don't try to open() it, because that creates the
+            // db file even if it doesn't instantiate the tables, which breaks connect() logic.
+            info!("Failed to open Sortition DB while checking current burn height, assuming height = 0");
+            return Ok(0);
+        }
+
+        let Ok(sortdb) = SortitionDB::open(&sortdb_path, false, burnchain.pox_constants.clone())
+        else {
+            info!("Failed to open Sortition DB while checking current burn height, assuming height = 0");
+            return Ok(0);
+        };
+
+        let Ok(tip_sn) = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn()) else {
+            info!("Failed to query Sortition DB for current burn height, assuming height = 0");
+            return Ok(0);
+        };
+
+        Ok(u32::try_from(tip_sn.block_height).expect("FATAL: burn height exceeded u32"))
+    }
+}
diff --git a/testnet/stacks-node/src/run_loop/mod.rs b/testnet/stacks-node/src/run_loop/mod.rs
index abfbe37c37..9ad4fd583e 100644
--- a/testnet/stacks-node/src/run_loop/mod.rs
+++ b/testnet/stacks-node/src/run_loop/mod.rs
@@ -1,3 +1,4 @@
+pub mod boot_nakamoto;
 pub mod helium;
 pub mod nakamoto;
 pub mod neon;
diff --git a/testnet/stacks-node/src/run_loop/nakamoto.rs b/testnet/stacks-node/src/run_loop/nakamoto.rs
index f758a65d33..e6a835abb8 100644
--- a/testnet/stacks-node/src/run_loop/nakamoto.rs
+++ b/testnet/stacks-node/src/run_loop/nakamoto.rs
@@ -68,9 +68,14 @@ pub struct RunLoop {
 
 impl RunLoop {
     /// Sets up a runloop and node, given a config.
-    pub fn new(config: Config) -> Self {
+    pub fn new(
+        config: Config,
+        should_keep_running: Option<Arc<AtomicBool>>,
+        counters: Option<Counters>,
+    ) -> Self {
         let channels = CoordinatorCommunication::instantiate();
-        let should_keep_running = Arc::new(AtomicBool::new(true));
+        let should_keep_running =
+            should_keep_running.unwrap_or_else(|| Arc::new(AtomicBool::new(true)));
         let pox_watchdog_comms = PoxSyncWatchdogComms::new(should_keep_running.clone());
         let miner_status = Arc::new(Mutex::new(MinerStatus::make_ready(
             config.burnchain.burn_fee_cap,
@@ -86,7 +91,7 @@ impl RunLoop {
             globals: None,
             coordinator_channels: Some(channels),
             callbacks: RunLoopCallbacks::new(),
-            counters: Counters::new(),
+            counters: counters.unwrap_or_else(|| Counters::new()),
             should_keep_running,
             event_dispatcher,
             pox_watchdog: None,
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index a7be83272f..ad9c473992 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -1,5 +1,5 @@
 use std::sync::atomic::{AtomicU64, Ordering};
-use std::sync::Arc;
+use std::sync::{Arc, Mutex};
 use std::time::{Duration, Instant};
 use std::{env, thread};
 
@@ -27,14 +27,13 @@ use stacks_common::util::secp256k1::Secp256k1PrivateKey;
 use super::bitcoin_regtest::BitcoinCoreController;
 use crate::config::{EventKeyType, EventObserverConfig};
 use crate::mockamoto::signer::SelfSigner;
-use crate::run_loop::nakamoto;
+use crate::neon::{Counters, RunLoopCounter};
+use crate::run_loop::boot_nakamoto;
 use crate::tests::make_stacks_transfer;
 use crate::tests::neon_integrations::{
     next_block_and_wait, run_until_burnchain_height, submit_tx, test_observer, wait_for_runloop,
 };
-use crate::{
-    neon, tests, BitcoinRegtestController, BurnchainController, Config, ConfigFile, Keychain,
-};
+use crate::{tests, BitcoinRegtestController, BurnchainController, Config, ConfigFile, Keychain};
 
 static POX_4_DEFAULT_STACKER_BALANCE: u64 = 100_000_000_000_000;
 static POX_4_DEFAULT_STACKER_STX_AMT: u128 = 99_000_000_000_000;
@@ -197,11 +196,14 @@ where
 fn next_block_and_mine_commit(
     btc_controller: &mut BitcoinRegtestController,
     timeout_secs: u64,
-    coord_channels: &CoordinatorChannels,
+    coord_channels: &Arc<Mutex<CoordinatorChannels>>,
     commits_submitted: &Arc<AtomicU64>,
 ) -> Result<(), String> {
     let commits_submitted = commits_submitted.clone();
-    let blocks_processed_before = coord_channels.get_stacks_blocks_processed();
+    let blocks_processed_before = coord_channels
+        .lock()
+        .expect("Mutex poisoned")
+        .get_stacks_blocks_processed();
     let commits_before = commits_submitted.load(Ordering::SeqCst);
     let mut block_processed_time: Option<Instant> = None;
     next_block_and(btc_controller, timeout_secs, || {
@@ -217,7 +219,10 @@ fn next_block_and_mine_commit(
             }
             Ok(false)
         } else {
-            let blocks_processed = coord_channels.get_stacks_blocks_processed();
+            let blocks_processed = coord_channels
+                .lock()
+                .expect("Mutex poisoned")
+                .get_stacks_blocks_processed();
             if blocks_processed > blocks_processed_before {
                 block_processed_time.replace(Instant::now());
             }
@@ -241,27 +246,18 @@ fn setup_stacker(naka_conf: &mut Config) -> Secp256k1PrivateKey {
 ///   for pox-4 to activate
 fn boot_to_epoch_3(
     naka_conf: &Config,
+    blocks_processed: &RunLoopCounter,
     stacker_sk: Secp256k1PrivateKey,
     btc_regtest_controller: &mut BitcoinRegtestController,
 ) {
-    let epoch_2_conf = naka_conf.clone();
-    btc_regtest_controller.bootstrap_chain(201);
-
-    let epochs = epoch_2_conf.burnchain.epochs.clone().unwrap();
-
+    let epochs = naka_conf.burnchain.epochs.clone().unwrap();
     let epoch_3 = &epochs[StacksEpoch::find_epoch_by_id(&epochs, StacksEpochId::Epoch30).unwrap()];
 
     info!(
         "Chain bootstrapped to bitcoin block 201, starting Epoch 2x miner";
         "Epoch 3.0 Boundary" => (epoch_3.start_height - 1),
     );
-    let http_origin = format!("http://{}", &epoch_2_conf.node.rpc_bind);
-    let mut run_loop = neon::RunLoop::new(epoch_2_conf.clone());
-
-    let epoch_2_stopper = run_loop.get_termination_switch();
-    let blocks_processed = run_loop.get_blocks_processed_arc();
-    let epoch_2_thread = thread::spawn(move || run_loop.start(None, 0));
-    wait_for_runloop(&blocks_processed);
+    let http_origin = format!("http://{}", &naka_conf.node.rpc_bind);
     next_block_and_wait(btc_regtest_controller, &blocks_processed);
     next_block_and_wait(btc_regtest_controller, &blocks_processed);
     // first mined stacks block
@@ -295,19 +291,18 @@ fn boot_to_epoch_3(
         btc_regtest_controller,
         &blocks_processed,
         epoch_3.start_height - 1,
-        &epoch_2_conf,
+        &naka_conf,
     );
 
-    info!("Bootstrapped to Epoch-3.0 boundary, stopping Epoch2x miner");
-    epoch_2_stopper.store(false, Ordering::SeqCst);
-    epoch_2_thread.join().unwrap();
+    info!("Bootstrapped to Epoch-3.0 boundary, Epoch2x miner should stop");
 }
 
 #[test]
 #[ignore]
 /// This test spins up a nakamoto-neon node.
 /// It starts in Epoch 2.0, mines with `neon_node` to Epoch 3.0, and then switches
-///  to Nakamoto operation (activating pox-4 by submitting a stack-stx tx).
+///  to Nakamoto operation (activating pox-4 by submitting a stack-stx tx). The BootLoop
+///  struct handles the epoch-2/3 tear-down and spin-up.
 /// This test makes three assertions:
 ///  * 30 blocks are mined after 3.0 starts. This is enough to mine across 2 reward cycles
 ///  * A transaction submitted to the mempool in 3.0 will be mined in 3.0
@@ -330,13 +325,39 @@ fn simple_neon_integration() {
     let recipient = PrincipalData::from(StacksAddress::burn_address(false));
     let stacker_sk = setup_stacker(&mut naka_conf);
 
+    test_observer::spawn();
+    let observer_port = test_observer::EVENT_OBSERVER_PORT;
+    naka_conf.events_observers.insert(EventObserverConfig {
+        endpoint: format!("localhost:{observer_port}"),
+        events_keys: vec![EventKeyType::AnyEvent],
+    });
+
     let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone());
     btcd_controller
         .start_bitcoind()
         .expect("Failed starting bitcoind");
     let mut btc_regtest_controller = BitcoinRegtestController::new(naka_conf.clone(), None);
+    btc_regtest_controller.bootstrap_chain(201);
+
+    let mut run_loop = boot_nakamoto::BootRunLoop::new(naka_conf.clone()).unwrap();
+    let run_loop_stopper = run_loop.get_termination_switch();
+    let Counters {
+        blocks_processed,
+        naka_submitted_vrfs: vrfs_submitted,
+        naka_submitted_commits: commits_submitted,
+        ..
+    } = run_loop.counters();
 
-    boot_to_epoch_3(&naka_conf, stacker_sk, &mut btc_regtest_controller);
+    let coord_channel = run_loop.coordinator_channels();
+
+    let run_loop_thread = thread::spawn(move || run_loop.start(None, 0));
+    wait_for_runloop(&blocks_processed);
+    boot_to_epoch_3(
+        &naka_conf,
+        &blocks_processed,
+        stacker_sk,
+        &mut btc_regtest_controller,
+    );
 
     info!("Bootstrapped to Epoch-3.0 boundary, starting nakamoto miner");
 
@@ -356,23 +377,6 @@ fn simple_neon_integration() {
             .unwrap()
             .stacks_block_height;
 
-    test_observer::spawn();
-    let observer_port = test_observer::EVENT_OBSERVER_PORT;
-    naka_conf.events_observers.insert(EventObserverConfig {
-        endpoint: format!("localhost:{observer_port}"),
-        events_keys: vec![EventKeyType::AnyEvent],
-    });
-
-    let mut run_loop = nakamoto::RunLoop::new(naka_conf.clone());
-    let epoch_3_stopper = run_loop.get_termination_switch();
-    let blocks_processed = run_loop.get_blocks_processed_arc();
-    let vrfs_submitted = run_loop.submitted_vrfs();
-    let commits_submitted = run_loop.submitted_commits();
-    let coord_channel = run_loop.get_coordinator_channel().unwrap();
-
-    let epoch_3_thread = thread::spawn(move || run_loop.start(None, 0));
-
-    wait_for_runloop(&blocks_processed);
     info!("Nakamoto miner started...");
     // first block wakes up the run loop, wait until a key registration has been submitted.
     next_block_and(&mut btc_regtest_controller, 60, || {
@@ -470,8 +474,11 @@ fn simple_neon_integration() {
     assert!(tip.anchored_header.as_stacks_nakamoto().is_some());
     assert!(tip.stacks_block_height >= block_height_pre_3_0 + 30);
 
-    coord_channel.stop_chains_coordinator();
+    coord_channel
+        .lock()
+        .expect("Mutex poisoned")
+        .stop_chains_coordinator();
+    run_loop_stopper.store(false, Ordering::SeqCst);
 
-    epoch_3_stopper.store(false, Ordering::SeqCst);
-    epoch_3_thread.join().unwrap();
+    run_loop_thread.join().unwrap();
 }

From 50a6a115b916fa52ce1e7816469b464f685bc6b7 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Sat, 9 Dec 2023 15:05:14 -0600
Subject: [PATCH 0203/1166] add copyright headers, some code cleanup

---
 testnet/stacks-node/src/config.rs             |  29 +-
 testnet/stacks-node/src/globals.rs            |  32 +-
 testnet/stacks-node/src/mockamoto.rs          |  17 +-
 testnet/stacks-node/src/nakamoto_node.rs      | 401 +-----------------
 .../stacks-node/src/nakamoto_node/miner.rs    |  37 +-
 testnet/stacks-node/src/nakamoto_node/peer.rs | 149 ++-----
 .../stacks-node/src/nakamoto_node/relayer.rs  | 196 ++++-----
 testnet/stacks-node/src/neon_node.rs          |  88 ++--
 .../stacks-node/src/run_loop/boot_nakamoto.rs |  15 +
 testnet/stacks-node/src/run_loop/nakamoto.rs  |  37 +-
 testnet/stacks-node/src/run_loop/neon.rs      |   2 +-
 .../src/tests/nakamoto_integrations.rs        |  30 +-
 12 files changed, 295 insertions(+), 738 deletions(-)

diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index feaa0208ac..526c2a90da 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -17,17 +17,18 @@ use stacks::chainstate::stacks::miner::{BlockBuilderSettings, MinerStatus};
 use stacks::chainstate::stacks::MAX_BLOCK_LEN;
 use stacks::core::mempool::MemPoolWalkSettings;
 use stacks::core::{
-    StacksEpoch, StacksEpochExtension, StacksEpochId, CHAIN_ID_MAINNET, CHAIN_ID_TESTNET,
-    PEER_VERSION_MAINNET, PEER_VERSION_TESTNET,
+    MemPoolDB, StacksEpoch, StacksEpochExtension, StacksEpochId, CHAIN_ID_MAINNET,
+    CHAIN_ID_TESTNET, PEER_VERSION_MAINNET, PEER_VERSION_TESTNET,
 };
 use stacks::cost_estimates::fee_medians::WeightedMedianFeeRateEstimator;
 use stacks::cost_estimates::fee_rate_fuzzer::FeeRateFuzzer;
 use stacks::cost_estimates::fee_scalar::ScalarFeeRateEstimator;
-use stacks::cost_estimates::metrics::{CostMetric, ProportionalDotProduct};
-use stacks::cost_estimates::{CostEstimator, FeeEstimator, PessimisticEstimator};
+use stacks::cost_estimates::metrics::{CostMetric, ProportionalDotProduct, UnitMetric};
+use stacks::cost_estimates::{CostEstimator, FeeEstimator, PessimisticEstimator, UnitEstimator};
 use stacks::net::atlas::AtlasConfig;
 use stacks::net::connection::ConnectionOptions;
 use stacks::net::{Neighbor, NeighborKey};
+use stacks::util_lib::db::Error as DBError;
 use stacks_common::address::{AddressHashMode, C32_ADDRESS_VERSION_TESTNET_SINGLESIG};
 use stacks_common::types::chainstate::StacksAddress;
 use stacks_common::types::net::PeerAddress;
@@ -510,6 +511,26 @@ impl Config {
             Ok(self.burnchain.clone())
         }
     }
+
+    /// Connect to the MempoolDB using the configured cost estimation
+    pub fn connect_mempool_db(&self) -> Result<MemPoolDB, DBError> {
+        // create estimators, metric instances for RPC handler
+        let cost_estimator = self
+            .make_cost_estimator()
+            .unwrap_or_else(|| Box::new(UnitEstimator));
+        let metric = self
+            .make_cost_metric()
+            .unwrap_or_else(|| Box::new(UnitMetric));
+
+        MemPoolDB::open(
+            self.is_mainnet(),
+            self.burnchain.chain_id,
+            &self.get_chainstate_path_str(),
+            cost_estimator,
+            metric,
+        )
+    }
+
     /// Apply any test settings to this burnchain config struct
     fn apply_test_settings(&self, burnchain: &mut Burnchain) {
         if self.burnchain.get_bitcoin_network().1 == BitcoinNetworkType::Mainnet {
diff --git a/testnet/stacks-node/src/globals.rs b/testnet/stacks-node/src/globals.rs
index 7e9e47a8fe..6c60e9a591 100644
--- a/testnet/stacks-node/src/globals.rs
+++ b/testnet/stacks-node/src/globals.rs
@@ -17,6 +17,8 @@ use crate::neon_node::LeaderKeyRegistrationState;
 use crate::run_loop::RegisteredKey;
 use crate::syncctl::PoxSyncWatchdogComms;
 
+pub type NeonGlobals = Globals<RelayerDirective>;
+
 /// Command types for the relayer thread, issued to it by other threads
 pub enum RelayerDirective {
     /// Handle some new data that arrived on the network (such as blocks, transactions, and
@@ -34,8 +36,7 @@ pub enum RelayerDirective {
 }
 
 /// Inter-thread communication structure, shared between threads
-#[derive(Clone)]
-pub struct Globals {
+pub struct Globals<T> {
     /// Last sortition processed
     last_sortition: Arc<Mutex<Option<BlockSnapshot>>>,
     /// Status of the miner
@@ -45,7 +46,7 @@ pub struct Globals {
     /// Unconfirmed transactions (shared between the relayer and p2p threads)
     unconfirmed_txs: Arc<Mutex<UnconfirmedTxMap>>,
     /// Writer endpoint to the relayer thread
-    pub relay_send: SyncSender<RelayerDirective>,
+    pub relay_send: SyncSender<T>,
     /// Cointer state in the main thread
     pub counters: Counters,
     /// Connection to the PoX sync watchdog
@@ -56,15 +57,34 @@ pub struct Globals {
     leader_key_registration_state: Arc<Mutex<LeaderKeyRegistrationState>>,
 }
 
-impl Globals {
+// Need to manually implement Clone, because [derive(Clone)] requires
+//  all trait bounds to implement Clone, even though T doesn't need Clone
+//  because it's behind SyncSender.
+impl<T> Clone for Globals<T> {
+    fn clone(&self) -> Self {
+        Self {
+            last_sortition: self.last_sortition.clone(),
+            miner_status: self.miner_status.clone(),
+            coord_comms: self.coord_comms.clone(),
+            unconfirmed_txs: self.unconfirmed_txs.clone(),
+            relay_send: self.relay_send.clone(),
+            counters: self.counters.clone(),
+            sync_comms: self.sync_comms.clone(),
+            should_keep_running: self.should_keep_running.clone(),
+            leader_key_registration_state: self.leader_key_registration_state.clone(),
+        }
+    }
+}
+
+impl<T> Globals<T> {
     pub fn new(
         coord_comms: CoordinatorChannels,
         miner_status: Arc<Mutex<MinerStatus>>,
-        relay_send: SyncSender<RelayerDirective>,
+        relay_send: SyncSender<T>,
         counters: Counters,
         sync_comms: PoxSyncWatchdogComms,
         should_keep_running: Arc<AtomicBool>,
-    ) -> Globals {
+    ) -> Globals<T> {
         Globals {
             last_sortition: Arc::new(Mutex::new(None)),
             miner_status,
diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index 845f838828..0929a67743 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -1,3 +1,18 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020-2023 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
 use std::sync::atomic::AtomicBool;
 use std::sync::mpsc::{sync_channel, Receiver, RecvTimeoutError};
 use std::sync::{Arc, Mutex};
@@ -69,7 +84,7 @@ use stacks_common::util::secp256k1::{MessageSignature, Secp256k1PublicKey};
 use stacks_common::util::vrf::{VRFPrivateKey, VRFProof, VRFPublicKey, VRF};
 
 use self::signer::SelfSigner;
-use crate::globals::{Globals, RelayerDirective};
+use crate::globals::{NeonGlobals as Globals, RelayerDirective};
 use crate::neon::Counters;
 use crate::neon_node::{PeerThread, StacksNode, BLOCK_PROCESSOR_STACK_SIZE};
 use crate::syncctl::PoxSyncWatchdogComms;
diff --git a/testnet/stacks-node/src/nakamoto_node.rs b/testnet/stacks-node/src/nakamoto_node.rs
index de0d04cfb5..0482bbfb05 100644
--- a/testnet/stacks-node/src/nakamoto_node.rs
+++ b/testnet/stacks-node/src/nakamoto_node.rs
@@ -1,5 +1,5 @@
 // Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
-// Copyright (C) 2020 Stacks Open Internet Foundation
+// Copyright (C) 2020-2023 Stacks Open Internet Foundation
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -14,42 +14,25 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 use std::collections::HashMap;
-use std::convert::TryFrom;
-use std::net::SocketAddr;
 use std::sync::mpsc::Receiver;
 use std::thread;
 use std::thread::JoinHandle;
 
-use clarity::vm::ast::ASTRules;
-use clarity::vm::types::QualifiedContractIdentifier;
-use stacks::burnchains::{Burnchain, BurnchainSigner, Txid};
+use stacks::burnchains::{BurnchainSigner, Txid};
 use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::burn::BlockSnapshot;
-use stacks::chainstate::stacks::db::StacksChainState;
-use stacks::chainstate::stacks::Error as ChainstateError;
-use stacks::core::mempool::MemPoolDB;
-use stacks::cost_estimates::metrics::UnitMetric;
-use stacks::cost_estimates::UnitEstimator;
 use stacks::monitoring;
 use stacks::monitoring::update_active_miners_count_gauge;
-use stacks::net::atlas::{AtlasConfig, AtlasDB};
-use stacks::net::db::PeerDB;
-use stacks::net::p2p::PeerNetwork;
+use stacks::net::atlas::AtlasConfig;
 use stacks::net::relay::Relayer;
-use stacks::net::stackerdb::{StackerDBConfig, StackerDBSync, StackerDBs};
-use stacks::net::{Error as NetError, PeerNetworkComms, ServiceFlags};
-use stacks::util_lib::strings::{UrlString, VecDisplay};
+use stacks::net::stackerdb::StackerDBs;
 use stacks_common::types::chainstate::SortitionId;
-use stacks_common::types::net::PeerAddress;
 use stacks_common::types::StacksEpochId;
-use stacks_common::util::get_epoch_time_secs;
-use stacks_common::util::secp256k1::Secp256k1PrivateKey;
 
 use super::{Config, EventDispatcher, Keychain};
 use crate::burnchains::bitcoin_regtest_controller::addr2str;
-use crate::globals::{Globals, RelayerDirective};
-use crate::neon_node::LeaderKeyRegistrationState;
-use crate::run_loop::nakamoto::RunLoop;
+use crate::neon_node::{LeaderKeyRegistrationState, StacksNode as NeonNode};
+use crate::run_loop::nakamoto::{Globals, RunLoop};
 use crate::run_loop::RegisteredKey;
 
 pub mod miner;
@@ -57,7 +40,7 @@ pub mod peer;
 pub mod relayer;
 
 use self::peer::PeerThread;
-use self::relayer::RelayerThread;
+use self::relayer::{RelayerDirective, RelayerThread};
 
 pub const RELAYER_MAX_BUFFER: usize = 100;
 const VRF_MOCK_MINER_KEY: u64 = 1;
@@ -82,88 +65,6 @@ pub struct StacksNode {
     pub relayer_thread_handle: JoinHandle<()>,
 }
 
-/// Fault injection logic to artificially increase the length of a tenure.
-/// Only used in testing
-#[cfg(test)]
-fn fault_injection_long_tenure() {
-    // simulated slow block
-    match std::env::var("STX_TEST_SLOW_TENURE") {
-        Ok(tenure_str) => match tenure_str.parse::<u64>() {
-            Ok(tenure_time) => {
-                info!(
-                    "Fault injection: sleeping for {} milliseconds to simulate a long tenure",
-                    tenure_time
-                );
-                stacks_common::util::sleep_ms(tenure_time);
-            }
-            Err(_) => {
-                error!("Parse error for STX_TEST_SLOW_TENURE");
-                panic!();
-            }
-        },
-        _ => {}
-    }
-}
-
-#[cfg(not(test))]
-fn fault_injection_long_tenure() {}
-
-/// Fault injection to skip mining in this bitcoin block height
-/// Only used in testing
-#[cfg(test)]
-fn fault_injection_skip_mining(rpc_bind: &str, target_burn_height: u64) -> bool {
-    match std::env::var("STACKS_DISABLE_MINER") {
-        Ok(disable_heights) => {
-            let disable_schedule: serde_json::Value =
-                serde_json::from_str(&disable_heights).unwrap();
-            let disable_schedule = disable_schedule.as_array().unwrap();
-            for disabled in disable_schedule {
-                let target_miner_rpc_bind = disabled
-                    .get("rpc_bind")
-                    .unwrap()
-                    .as_str()
-                    .unwrap()
-                    .to_string();
-                if target_miner_rpc_bind != rpc_bind {
-                    continue;
-                }
-                let target_block_heights = disabled.get("blocks").unwrap().as_array().unwrap();
-                for target_block_value in target_block_heights {
-                    let target_block = target_block_value.as_i64().unwrap() as u64;
-                    if target_block == target_burn_height {
-                        return true;
-                    }
-                }
-            }
-            return false;
-        }
-        Err(_) => {
-            return false;
-        }
-    }
-}
-
-#[cfg(not(test))]
-fn fault_injection_skip_mining(_rpc_bind: &str, _target_burn_height: u64) -> bool {
-    false
-}
-
-/// Open the chainstate, and inject faults from the config file
-pub(crate) fn open_chainstate_with_faults(
-    config: &Config,
-) -> Result<StacksChainState, ChainstateError> {
-    let stacks_chainstate_path = config.get_chainstate_path_str();
-    let (mut chainstate, _) = StacksChainState::open(
-        config.is_mainnet(),
-        config.burnchain.chain_id,
-        &stacks_chainstate_path,
-        Some(config.node.get_marf_opts()),
-    )?;
-
-    chainstate.fault_injection.hide_blocks = config.node.fault_injection_hide_blocks;
-    Ok(chainstate)
-}
-
 /// Types of errors that can arise during mining
 #[derive(Debug)]
 enum Error {
@@ -186,284 +87,6 @@ enum Error {
 }
 
 impl StacksNode {
-    /// Set up the AST size-precheck height, if configured
-    fn setup_ast_size_precheck(config: &Config, sortdb: &mut SortitionDB) {
-        if let Some(ast_precheck_size_height) = config.burnchain.ast_precheck_size_height {
-            info!(
-                "Override burnchain height of {:?} to {}",
-                ASTRules::PrecheckSize,
-                ast_precheck_size_height
-            );
-            let mut tx = sortdb
-                .tx_begin()
-                .expect("FATAL: failed to begin tx on sortition DB");
-            SortitionDB::override_ast_rule_height(
-                &mut tx,
-                ASTRules::PrecheckSize,
-                ast_precheck_size_height,
-            )
-            .expect("FATAL: failed to override AST PrecheckSize rule height");
-            tx.commit()
-                .expect("FATAL: failed to commit sortition DB transaction");
-        }
-    }
-
-    /// Set up the mempool DB by making sure it exists.
-    /// Panics on failure.
-    fn setup_mempool_db(config: &Config) -> MemPoolDB {
-        // force early mempool instantiation
-        let cost_estimator = config
-            .make_cost_estimator()
-            .unwrap_or_else(|| Box::new(UnitEstimator));
-        let metric = config
-            .make_cost_metric()
-            .unwrap_or_else(|| Box::new(UnitMetric));
-
-        let mempool = MemPoolDB::open(
-            config.is_mainnet(),
-            config.burnchain.chain_id,
-            &config.get_chainstate_path_str(),
-            cost_estimator,
-            metric,
-        )
-        .expect("BUG: failed to instantiate mempool");
-
-        mempool
-    }
-
-    /// Set up the Peer DB and update any soft state from the config file.  This includes:
-    /// * blacklisted/whitelisted nodes
-    /// * node keys
-    /// * bootstrap nodes
-    /// Returns the instantiated PeerDB
-    /// Panics on failure.
-    fn setup_peer_db(
-        config: &Config,
-        burnchain: &Burnchain,
-        stackerdb_contract_ids: &[QualifiedContractIdentifier],
-    ) -> PeerDB {
-        let data_url = UrlString::try_from(format!("{}", &config.node.data_url)).unwrap();
-        let initial_neighbors = config.node.bootstrap_node.clone();
-        if initial_neighbors.len() > 0 {
-            info!(
-                "Will bootstrap from peers {}",
-                VecDisplay(&initial_neighbors)
-            );
-        } else {
-            warn!("Without a peer to bootstrap from, the node will start mining a new chain");
-        }
-
-        let p2p_sock: SocketAddr = config.node.p2p_bind.parse().expect(&format!(
-            "Failed to parse socket: {}",
-            &config.node.p2p_bind
-        ));
-        let p2p_addr: SocketAddr = config.node.p2p_address.parse().expect(&format!(
-            "Failed to parse socket: {}",
-            &config.node.p2p_address
-        ));
-        let node_privkey = Secp256k1PrivateKey::from_seed(&config.node.local_peer_seed);
-
-        let mut peerdb = PeerDB::connect(
-            &config.get_peer_db_file_path(),
-            true,
-            config.burnchain.chain_id,
-            burnchain.network_id,
-            Some(node_privkey),
-            config.connection_options.private_key_lifetime.clone(),
-            PeerAddress::from_socketaddr(&p2p_addr),
-            p2p_sock.port(),
-            data_url,
-            &[],
-            Some(&initial_neighbors),
-            stackerdb_contract_ids,
-        )
-        .map_err(|e| {
-            eprintln!(
-                "Failed to open {}: {:?}",
-                &config.get_peer_db_file_path(),
-                &e
-            );
-            panic!();
-        })
-        .unwrap();
-
-        // allow all bootstrap nodes
-        {
-            let mut tx = peerdb.tx_begin().unwrap();
-            for initial_neighbor in initial_neighbors.iter() {
-                // update peer in case public key changed
-                PeerDB::update_peer(&mut tx, &initial_neighbor).unwrap();
-                PeerDB::set_allow_peer(
-                    &mut tx,
-                    initial_neighbor.addr.network_id,
-                    &initial_neighbor.addr.addrbytes,
-                    initial_neighbor.addr.port,
-                    -1,
-                )
-                .unwrap();
-            }
-            tx.commit().unwrap();
-        }
-
-        if !config.node.deny_nodes.is_empty() {
-            warn!("Will ignore nodes {:?}", &config.node.deny_nodes);
-        }
-
-        // deny all config-denied peers
-        {
-            let mut tx = peerdb.tx_begin().unwrap();
-            for denied in config.node.deny_nodes.iter() {
-                PeerDB::set_deny_peer(
-                    &mut tx,
-                    denied.addr.network_id,
-                    &denied.addr.addrbytes,
-                    denied.addr.port,
-                    get_epoch_time_secs() + 24 * 365 * 3600,
-                )
-                .unwrap();
-            }
-            tx.commit().unwrap();
-        }
-
-        // update services to indicate we can support mempool sync
-        {
-            let mut tx = peerdb.tx_begin().unwrap();
-            PeerDB::set_local_services(
-                &mut tx,
-                (ServiceFlags::RPC as u16) | (ServiceFlags::RELAY as u16),
-            )
-            .unwrap();
-            tx.commit().unwrap();
-        }
-
-        peerdb
-    }
-
-    /// Set up the PeerNetwork, but do not bind it.
-    pub fn setup_peer_network(
-        config: &Config,
-        atlas_config: &AtlasConfig,
-        burnchain: Burnchain,
-    ) -> PeerNetwork {
-        let sortdb = SortitionDB::open(
-            &config.get_burn_db_file_path(),
-            true,
-            burnchain.pox_constants.clone(),
-        )
-        .expect("Error while instantiating sor/tition db");
-
-        let epochs = SortitionDB::get_stacks_epochs(sortdb.conn())
-            .expect("Error while loading stacks epochs");
-
-        let view = {
-            let sortition_tip = SortitionDB::get_canonical_burn_chain_tip(&sortdb.conn())
-                .expect("Failed to get sortition tip");
-            SortitionDB::get_burnchain_view(&sortdb.index_conn(), &burnchain, &sortition_tip)
-                .unwrap()
-        };
-
-        let atlasdb =
-            AtlasDB::connect(atlas_config.clone(), &config.get_atlas_db_file_path(), true).unwrap();
-
-        let stackerdbs = StackerDBs::connect(&config.get_stacker_db_file_path(), true).unwrap();
-
-        let mut chainstate =
-            open_chainstate_with_faults(config).expect("FATAL: could not open chainstate DB");
-
-        let mut stackerdb_machines = HashMap::new();
-        for stackerdb_contract_id in config.node.stacker_dbs.iter() {
-            // attempt to load the config
-            let (instantiate, stacker_db_config) = match StackerDBConfig::from_smart_contract(
-                &mut chainstate,
-                &sortdb,
-                stackerdb_contract_id,
-            ) {
-                Ok(c) => (true, c),
-                Err(e) => {
-                    warn!(
-                        "Failed to load StackerDB config for {}: {:?}",
-                        stackerdb_contract_id, &e
-                    );
-                    (false, StackerDBConfig::noop())
-                }
-            };
-            let mut stackerdbs =
-                StackerDBs::connect(&config.get_stacker_db_file_path(), true).unwrap();
-
-            if instantiate {
-                match stackerdbs.get_stackerdb_id(stackerdb_contract_id) {
-                    Ok(..) => {
-                        // reconfigure
-                        let tx = stackerdbs.tx_begin(stacker_db_config.clone()).unwrap();
-                        tx.reconfigure_stackerdb(stackerdb_contract_id, &stacker_db_config.signers)
-                            .expect(&format!(
-                                "FATAL: failed to reconfigure StackerDB replica {}",
-                                stackerdb_contract_id
-                            ));
-                        tx.commit().unwrap();
-                    }
-                    Err(NetError::NoSuchStackerDB(..)) => {
-                        // instantiate replica
-                        let tx = stackerdbs.tx_begin(stacker_db_config.clone()).unwrap();
-                        tx.create_stackerdb(stackerdb_contract_id, &stacker_db_config.signers)
-                            .expect(&format!(
-                                "FATAL: failed to instantiate StackerDB replica {}",
-                                stackerdb_contract_id
-                            ));
-                        tx.commit().unwrap();
-                    }
-                    Err(e) => {
-                        panic!("FATAL: failed to query StackerDB state: {:?}", &e);
-                    }
-                }
-            }
-            let stacker_db_sync = match StackerDBSync::new(
-                stackerdb_contract_id.clone(),
-                &stacker_db_config,
-                PeerNetworkComms::new(),
-                stackerdbs,
-            ) {
-                Ok(s) => s,
-                Err(e) => {
-                    warn!(
-                        "Failed to instantiate StackerDB sync machine for {}: {:?}",
-                        stackerdb_contract_id, &e
-                    );
-                    continue;
-                }
-            };
-
-            stackerdb_machines.insert(
-                stackerdb_contract_id.clone(),
-                (stacker_db_config, stacker_db_sync),
-            );
-        }
-
-        let stackerdb_contract_ids: Vec<_> =
-            stackerdb_machines.keys().map(|sc| sc.clone()).collect();
-        let peerdb = Self::setup_peer_db(config, &burnchain, &stackerdb_contract_ids);
-
-        let local_peer = match PeerDB::get_local_peer(peerdb.conn()) {
-            Ok(local_peer) => local_peer,
-            _ => panic!("Unable to retrieve local peer"),
-        };
-
-        let p2p_net = PeerNetwork::new(
-            peerdb,
-            atlasdb,
-            stackerdbs,
-            local_peer,
-            config.burnchain.peer_version,
-            burnchain,
-            view,
-            config.connection_options.clone(),
-            stackerdb_machines,
-            epochs,
-        );
-
-        p2p_net
-    }
-
     /// This function sets the global var `GLOBAL_BURNCHAIN_SIGNER`.
     ///
     /// This variable is used for prometheus monitoring (which only
@@ -507,11 +130,13 @@ impl StacksNode {
         )
         .expect("Error while instantiating sortition db");
 
-        Self::setup_ast_size_precheck(&config, &mut sortdb);
+        NeonNode::setup_ast_size_precheck(&config, &mut sortdb);
 
-        let _ = Self::setup_mempool_db(&config);
+        let _ = config
+            .connect_mempool_db()
+            .expect("FATAL: database failure opening mempool");
 
-        let mut p2p_net = Self::setup_peer_network(&config, &atlas_config, burnchain.clone());
+        let mut p2p_net = NeonNode::setup_peer_network(&config, &atlas_config, burnchain.clone());
 
         let stackerdbs = StackerDBs::connect(&config.get_stacker_db_file_path(), true)
             .expect("FATAL: failed to connect to stacker DB");
@@ -602,7 +227,7 @@ impl StacksNode {
         return self
             .globals
             .relay_send
-            .send(RelayerDirective::ProcessTenure(
+            .send(RelayerDirective::ProcessedBurnBlock(
                 snapshot.consensus_hash.clone(),
                 snapshot.parent_burn_header_hash.clone(),
                 snapshot.winning_stacks_block_hash.clone(),
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index bc684a07bf..ae2781ce7b 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -1,5 +1,5 @@
 // Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
-// Copyright (C) 2020 Stacks Open Internet Foundation
+// Copyright (C) 2020-2023 Stacks Open Internet Foundation
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -29,10 +29,7 @@ use stacks::chainstate::stacks::{
     TenureChangeCause, TenureChangePayload, ThresholdSignature, TransactionAnchorMode,
     TransactionPayload, TransactionVersion,
 };
-use stacks::core::mempool::MemPoolDB;
 use stacks::core::FIRST_BURNCHAIN_CONSENSUS_HASH;
-use stacks::cost_estimates::metrics::UnitMetric;
-use stacks::cost_estimates::UnitEstimator;
 use stacks_common::types::chainstate::{StacksAddress, StacksBlockId};
 use stacks_common::types::{PrivateKey, StacksEpochId};
 use stacks_common::util::hash::Hash160;
@@ -40,11 +37,11 @@ use stacks_common::util::vrf::VRFProof;
 
 use super::relayer::RelayerThread;
 use super::{Config, Error as NakamotoNodeError, EventDispatcher, Keychain};
-use crate::globals::Globals;
 use crate::mockamoto::signer::SelfSigner;
 use crate::nakamoto_node::VRF_MOCK_MINER_KEY;
+use crate::run_loop::nakamoto::Globals;
 use crate::run_loop::RegisteredKey;
-use crate::ChainTip;
+use crate::{neon_node, ChainTip};
 
 pub enum MinerDirective {
     /// The miner won sortition so they should begin a new tenure
@@ -161,7 +158,7 @@ impl BlockMinerThread {
         mut block: NakamotoBlock,
     ) -> Result<(), ChainstateError> {
         signer.sign_nakamoto_block(&mut block);
-        let mut chain_state = super::open_chainstate_with_faults(&self.config)
+        let mut chain_state = neon_node::open_chainstate_with_faults(&self.config)
             .expect("FATAL: could not open chainstate DB");
         let chainstate_config = chain_state.config();
         let sort_db = SortitionDB::open(
@@ -365,19 +362,9 @@ impl BlockMinerThread {
     /// Return None if we couldn't build a block for whatever reason.
     fn mine_block(&mut self) -> Option<NakamotoBlock> {
         debug!("block miner thread ID is {:?}", thread::current().id());
-        super::fault_injection_long_tenure();
+        neon_node::fault_injection_long_tenure();
 
         let burn_db_path = self.config.get_burn_db_file_path();
-        let stacks_chainstate_path = self.config.get_chainstate_path_str();
-
-        let cost_estimator = self
-            .config
-            .make_cost_estimator()
-            .unwrap_or_else(|| Box::new(UnitEstimator));
-        let metric = self
-            .config
-            .make_cost_metric()
-            .unwrap_or_else(|| Box::new(UnitMetric));
 
         // NOTE: read-write access is needed in order to be able to query the recipient set.
         // This is an artifact of the way the MARF is built (see #1449)
@@ -385,17 +372,13 @@ impl BlockMinerThread {
             SortitionDB::open(&burn_db_path, true, self.burnchain.pox_constants.clone())
                 .expect("FATAL: could not open sortition DB");
 
-        let mut chain_state = super::open_chainstate_with_faults(&self.config)
+        let mut chain_state = neon_node::open_chainstate_with_faults(&self.config)
             .expect("FATAL: could not open chainstate DB");
 
-        let mut mem_pool = MemPoolDB::open(
-            self.config.is_mainnet(),
-            self.config.burnchain.chain_id,
-            &stacks_chainstate_path,
-            cost_estimator,
-            metric,
-        )
-        .expect("Database failure opening mempool");
+        let mut mem_pool = self
+            .config
+            .connect_mempool_db()
+            .expect("Database failure opening mempool");
 
         let target_epoch_id =
             SortitionDB::get_stacks_epoch(burn_db.conn(), self.burn_block.block_height + 1)
diff --git a/testnet/stacks-node/src/nakamoto_node/peer.rs b/testnet/stacks-node/src/nakamoto_node/peer.rs
index 9f2a37c50d..762aa45eda 100644
--- a/testnet/stacks-node/src/nakamoto_node/peer.rs
+++ b/testnet/stacks-node/src/nakamoto_node/peer.rs
@@ -1,5 +1,5 @@
 // Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
-// Copyright (C) 2020 Stacks Open Internet Foundation
+// Copyright (C) 2020-2023 Stacks Open Internet Foundation
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -33,10 +33,10 @@ use stacks::net::p2p::PeerNetwork;
 use stacks::net::RPCHandlerArgs;
 use stacks_common::util::hash::Sha256Sum;
 
-use super::open_chainstate_with_faults;
 use crate::burnchains::make_bitcoin_indexer;
-use crate::globals::{Globals, RelayerDirective};
-use crate::run_loop::nakamoto::RunLoop;
+use crate::nakamoto_node::relayer::RelayerDirective;
+use crate::neon_node::open_chainstate_with_faults;
+use crate::run_loop::nakamoto::{Globals, RunLoop};
 use crate::{Config, EventDispatcher};
 
 /// Thread that runs the network state machine, handling both p2p and http requests.
@@ -44,17 +44,17 @@ pub struct PeerThread {
     /// Node config
     config: Config,
     /// instance of the peer network. Made optional in order to trick the borrow checker.
-    net: Option<PeerNetwork>,
+    net: PeerNetwork,
     /// handle to global inter-thread comms
     globals: Globals,
     /// how long to wait for network messages on each poll, in millis
     poll_timeout: u64,
-    /// handle to the sortition DB (optional so we can take/replace it)
-    sortdb: Option<SortitionDB>,
-    /// handle to the chainstate DB (optional so we can take/replace it)
-    chainstate: Option<StacksChainState>,
-    /// handle to the mempool DB (optional so we can take/replace it)
-    mempool: Option<MemPoolDB>,
+    /// handle to the sortition DB
+    sortdb: SortitionDB,
+    /// handle to the chainstate DB
+    chainstate: StacksChainState,
+    /// handle to the mempool DB
+    mempool: MemPoolDB,
     /// buffer of relayer commands with block data that couldn't be sent to the relayer just yet
     /// (i.e. due to backpressure).  We track this separately, instead of just using a bigger
     /// channel, because we need to know when backpressure occurs in order to throttle the p2p
@@ -141,28 +141,6 @@ impl PeerThread {
         info!("P2P thread exit!");
     }
 
-    /// set up the mempool DB connection
-    pub fn connect_mempool_db(config: &Config) -> MemPoolDB {
-        // create estimators, metric instances for RPC handler
-        let cost_estimator = config
-            .make_cost_estimator()
-            .unwrap_or_else(|| Box::new(UnitEstimator));
-        let metric = config
-            .make_cost_metric()
-            .unwrap_or_else(|| Box::new(UnitMetric));
-
-        let mempool = MemPoolDB::open(
-            config.is_mainnet(),
-            config.burnchain.chain_id,
-            &config.get_chainstate_path_str(),
-            cost_estimator,
-            metric,
-        )
-        .expect("Database failure opening mempool");
-
-        mempool
-    }
-
     /// Instantiate the p2p thread.
     /// Binds the addresses in the config (which may panic if the port is blocked).
     /// This is so the node will crash "early" before any new threads start if there's going to be
@@ -183,7 +161,9 @@ impl PeerThread {
         mut net: PeerNetwork,
     ) -> Self {
         let config = config.clone();
-        let mempool = Self::connect_mempool_db(&config);
+        let mempool = config
+            .connect_mempool_db()
+            .expect("FATAL: database failure opening mempool");
         let burn_db_path = config.get_burn_db_file_path();
 
         let sortdb = SortitionDB::open(&burn_db_path, false, pox_constants)
@@ -208,12 +188,12 @@ impl PeerThread {
 
         PeerThread {
             config,
-            net: Some(net),
+            net,
             globals,
             poll_timeout,
-            sortdb: Some(sortdb),
-            chainstate: Some(chainstate),
-            mempool: Some(mempool),
+            sortdb,
+            chainstate,
+            mempool,
             results_with_data: VecDeque::new(),
             num_p2p_state_machine_passes: 0,
             num_inv_sync_passes: 0,
@@ -222,50 +202,6 @@ impl PeerThread {
         }
     }
 
-    /// Do something with mutable references to the mempool, sortdb, and chainstate
-    /// Fools the borrow checker.
-    /// NOT COMPOSIBLE
-    fn with_chainstate<F, R>(&mut self, func: F) -> R
-    where
-        F: FnOnce(&mut PeerThread, &mut SortitionDB, &mut StacksChainState, &mut MemPoolDB) -> R,
-    {
-        let mut sortdb = self.sortdb.take().expect("BUG: sortdb already taken");
-        let mut chainstate = self
-            .chainstate
-            .take()
-            .expect("BUG: chainstate already taken");
-        let mut mempool = self.mempool.take().expect("BUG: mempool already taken");
-
-        let res = func(self, &mut sortdb, &mut chainstate, &mut mempool);
-
-        self.sortdb = Some(sortdb);
-        self.chainstate = Some(chainstate);
-        self.mempool = Some(mempool);
-
-        res
-    }
-
-    /// Get an immutable ref to the inner network.
-    /// DO NOT USE WITHIN with_network()
-    fn get_network(&self) -> &PeerNetwork {
-        self.net.as_ref().expect("BUG: did not replace net")
-    }
-
-    /// Do something with mutable references to the network.
-    /// Fools the borrow checker.
-    /// NOT COMPOSIBLE. DO NOT CALL THIS OR get_network() IN func
-    fn with_network<F, R>(&mut self, func: F) -> R
-    where
-        F: FnOnce(&mut PeerThread, &mut PeerNetwork) -> R,
-    {
-        let mut net = self.net.take().expect("BUG: net already taken");
-
-        let res = func(self, &mut net);
-
-        self.net = Some(net);
-        res
-    }
-
     /// Run one pass of the p2p/http state machine
     /// Return true if we should continue running passes; false if not
     pub fn run_one_pass<B: BurnchainHeaderReader>(
@@ -280,12 +216,12 @@ impl PeerThread {
         // initial block download?
         let ibd = self.globals.sync_comms.get_ibd();
         let download_backpressure = self.results_with_data.len() > 0;
-        let poll_ms = if !download_backpressure && self.get_network().has_more_downloads() {
+        let poll_ms = if !download_backpressure && self.net.has_more_downloads() {
             // keep getting those blocks -- drive the downloader state-machine
             debug!(
                 "P2P: backpressure: {}, more downloads: {}",
                 download_backpressure,
-                self.get_network().has_more_downloads()
+                self.net.has_more_downloads()
             );
             1
         } else {
@@ -293,15 +229,11 @@ impl PeerThread {
         };
 
         // do one pass
-        let p2p_res = self.with_chainstate(|p2p_thread, sortdb, chainstate, mempool| {
+        let p2p_res = {
             // NOTE: handler_args must be created such that it outlives the inner net.run() call and
             // doesn't ref anything within p2p_thread.
             let handler_args = RPCHandlerArgs {
-                exit_at_block_height: p2p_thread
-                    .config
-                    .burnchain
-                    .process_exit_at_block_height
-                    .clone(),
+                exit_at_block_height: self.config.burnchain.process_exit_at_block_height.clone(),
                 genesis_chainstate_hash: Sha256Sum::from_hex(stx_genesis::GENESIS_CHAINSTATE_HASH)
                     .unwrap(),
                 event_observer: Some(event_dispatcher),
@@ -310,21 +242,18 @@ impl PeerThread {
                 fee_estimator: fee_estimator.map(|boxed_estimator| boxed_estimator.as_ref()),
                 ..RPCHandlerArgs::default()
             };
-            p2p_thread.with_network(|_, net| {
-                net.run(
-                    indexer,
-                    sortdb,
-                    chainstate,
-                    mempool,
-                    dns_client_opt,
-                    download_backpressure,
-                    ibd,
-                    poll_ms,
-                    &handler_args,
-                )
-            })
-        });
-
+            self.net.run(
+                indexer,
+                &self.sortdb,
+                &mut self.chainstate,
+                &mut self.mempool,
+                dns_client_opt,
+                download_backpressure,
+                ibd,
+                poll_ms,
+                &handler_args,
+            )
+        };
         match p2p_res {
             Ok(network_result) => {
                 let mut have_update = false;
@@ -376,17 +305,13 @@ impl PeerThread {
             if let Err(e) = self.globals.relay_send.try_send(next_result) {
                 debug!(
                     "P2P: {:?}: download backpressure detected (bufferred {})",
-                    &self.get_network().local_peer,
+                    &self.net.local_peer,
                     self.results_with_data.len()
                 );
                 match e {
                     TrySendError::Full(directive) => {
-                        if let RelayerDirective::RunTenure(..) = directive {
-                            // can drop this
-                        } else {
-                            // don't lose this data -- just try it again
-                            self.results_with_data.push_front(directive);
-                        }
+                        // don't lose this data -- just try it again
+                        self.results_with_data.push_front(directive);
                         break;
                     }
                     TrySendError::Disconnected(_) => {
diff --git a/testnet/stacks-node/src/nakamoto_node/relayer.rs b/testnet/stacks-node/src/nakamoto_node/relayer.rs
index 6aa4568d0b..04f04241e0 100644
--- a/testnet/stacks-node/src/nakamoto_node/relayer.rs
+++ b/testnet/stacks-node/src/nakamoto_node/relayer.rs
@@ -1,5 +1,5 @@
 // Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
-// Copyright (C) 2020 Stacks Open Internet Foundation
+// Copyright (C) 2020-2023 Stacks Open Internet Foundation
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -53,17 +53,35 @@ use stacks_common::util::hash::Hash160;
 use stacks_common::util::vrf::{VRFProof, VRFPublicKey};
 
 use super::{
-    fault_injection_skip_mining, open_chainstate_with_faults, BlockCommits, Config,
-    Error as NakamotoNodeError, EventDispatcher, Keychain, BLOCK_PROCESSOR_STACK_SIZE,
+    BlockCommits, Config, Error as NakamotoNodeError, EventDispatcher, Keychain,
+    BLOCK_PROCESSOR_STACK_SIZE,
 };
 use crate::burnchains::BurnchainController;
-use crate::globals::{Globals, RelayerDirective};
 use crate::nakamoto_node::miner::{BlockMinerThread, MinerDirective};
-use crate::neon_node::LeaderKeyRegistrationState;
-use crate::run_loop::nakamoto::RunLoop;
+use crate::neon_node::{
+    fault_injection_skip_mining, open_chainstate_with_faults, LeaderKeyRegistrationState,
+};
+use crate::run_loop::nakamoto::{Globals, RunLoop};
 use crate::run_loop::RegisteredKey;
 use crate::BitcoinRegtestController;
 
+/// Command types for the Nakamoto relayer thread, issued to it by other threads
+pub enum RelayerDirective {
+    /// Handle some new data that arrived on the network (such as blocks, transactions, and
+    HandleNetResult(NetworkResult),
+    /// A new burn block has been processed by the SortitionDB, check if this miner won sortition,
+    ///  and if so, start the miner thread
+    ProcessedBurnBlock(ConsensusHash, BurnchainHeaderHash, BlockHeaderHash),
+    /// Either a new burn block has been processed (without a miner active yet) or a
+    ///  nakamoto tenure's first block has been processed, so the relayer should issue
+    ///  a block commit
+    IssueBlockCommit(ConsensusHash, BlockHeaderHash),
+    /// Try to register a VRF public key
+    RegisterKey(BlockSnapshot),
+    /// Stop the relayer thread
+    Exit,
+}
+
 /// Relayer thread
 /// * accepts network results and stores blocks and microblocks
 /// * forwards new blocks, microblocks, and transactions to the p2p thread
@@ -72,12 +90,12 @@ use crate::BitcoinRegtestController;
 pub struct RelayerThread {
     /// Node config
     pub(crate) config: Config,
-    /// Handle to the sortition DB (optional so we can take/replace it)
-    sortdb: Option<SortitionDB>,
-    /// Handle to the chainstate DB (optional so we can take/replace it)
-    chainstate: Option<StacksChainState>,
-    /// Handle to the mempool DB (optional so we can take/replace it)
-    mempool: Option<MemPoolDB>,
+    /// Handle to the sortition DB
+    sortdb: SortitionDB,
+    /// Handle to the chainstate DB
+    chainstate: StacksChainState,
+    /// Handle to the mempool DB
+    mempool: MemPoolDB,
     /// Handle to global state and inter-thread communication channels
     pub(crate) globals: Globals,
     /// Authoritative copy of the keychain state
@@ -167,9 +185,9 @@ impl RelayerThread {
 
         RelayerThread {
             config: config.clone(),
-            sortdb: Some(sortdb),
-            chainstate: Some(chainstate),
-            mempool: Some(mempool),
+            sortdb,
+            chainstate,
+            mempool,
             globals,
             keychain,
             burnchain: runloop.get_burnchain(),
@@ -195,46 +213,6 @@ impl RelayerThread {
         }
     }
 
-    /// Get an immutible ref to the sortdb
-    pub fn sortdb_ref(&self) -> &SortitionDB {
-        self.sortdb
-            .as_ref()
-            .expect("FATAL: tried to access sortdb while taken")
-    }
-
-    /// Get an immutible ref to the chainstate
-    pub fn chainstate_ref(&self) -> &StacksChainState {
-        self.chainstate
-            .as_ref()
-            .expect("FATAL: tried to access chainstate while it was taken")
-    }
-
-    /// Fool the borrow checker into letting us do something with the chainstate databases.
-    /// DOES NOT COMPOSE -- do NOT call this, or self.sortdb_ref(), or self.chainstate_ref(), within
-    /// `func`.  You will get a runtime panic.
-    pub fn with_chainstate<F, R>(&mut self, func: F) -> R
-    where
-        F: FnOnce(&mut RelayerThread, &mut SortitionDB, &mut StacksChainState, &mut MemPoolDB) -> R,
-    {
-        let mut sortdb = self
-            .sortdb
-            .take()
-            .expect("FATAL: tried to take sortdb while taken");
-        let mut chainstate = self
-            .chainstate
-            .take()
-            .expect("FATAL: tried to take chainstate while taken");
-        let mut mempool = self
-            .mempool
-            .take()
-            .expect("FATAL: tried to take mempool while taken");
-        let res = func(self, &mut sortdb, &mut chainstate, &mut mempool);
-        self.sortdb = Some(sortdb);
-        self.chainstate = Some(chainstate);
-        self.mempool = Some(mempool);
-        res
-    }
-
     /// have we waited for the right conditions under which to start mining a block off of our
     /// chain tip?
     pub fn has_waited_for_latest_blocks(&self) -> bool {
@@ -286,21 +264,19 @@ impl RelayerThread {
             signal_mining_blocked(self.globals.get_miner_status());
         }
 
-        let net_receipts = self.with_chainstate(|relayer_thread, sortdb, chainstate, mempool| {
-            relayer_thread
-                .relayer
-                .process_network_result(
-                    &relayer_thread.local_peer,
-                    &mut net_result,
-                    sortdb,
-                    chainstate,
-                    mempool,
-                    relayer_thread.globals.sync_comms.get_ibd(),
-                    Some(&relayer_thread.globals.coord_comms),
-                    Some(&relayer_thread.event_dispatcher),
-                )
-                .expect("BUG: failure processing network results")
-        });
+        let net_receipts = self
+            .relayer
+            .process_network_result(
+                &self.local_peer,
+                &mut net_result,
+                &mut self.sortdb,
+                &mut self.chainstate,
+                &mut self.mempool,
+                self.globals.sync_comms.get_ibd(),
+                Some(&self.globals.coord_comms),
+                Some(&self.event_dispatcher),
+            )
+            .expect("BUG: failure processing network results");
 
         if net_receipts.num_new_blocks > 0 || net_receipts.num_new_confirmed_microblocks > 0 {
             // if we received any new block data that could invalidate our view of the chain tip,
@@ -318,7 +294,7 @@ impl RelayerThread {
         let num_unconfirmed_microblock_tx_receipts =
             net_receipts.processed_unconfirmed_state.receipts.len();
         if num_unconfirmed_microblock_tx_receipts > 0 {
-            if let Some(unconfirmed_state) = self.chainstate_ref().unconfirmed_state.as_ref() {
+            if let Some(unconfirmed_state) = self.chainstate.unconfirmed_state.as_ref() {
                 let canonical_tip = unconfirmed_state.confirmed_chain_tip.clone();
                 self.event_dispatcher.process_new_microblocks(
                     canonical_tip,
@@ -336,16 +312,14 @@ impl RelayerThread {
         }
 
         // synchronize unconfirmed tx index to p2p thread
-        self.with_chainstate(|relayer_thread, _sortdb, chainstate, _mempool| {
-            relayer_thread.globals.send_unconfirmed_txs(chainstate);
-        });
+        self.globals.send_unconfirmed_txs(&self.chainstate);
 
         // resume mining if we blocked it, and if we've done the requisite download
         // passes
         self.last_network_download_passes = net_result.num_download_passes;
         self.last_network_inv_passes = net_result.num_inv_sync_passes;
         if self.has_waited_for_latest_blocks() {
-            debug!("Relayer: did a download pass, so unblocking mining");
+            info!("Relayer: did a download pass, so unblocking mining");
             signal_mining_ready(self.globals.get_miner_status());
         }
     }
@@ -359,10 +333,9 @@ impl RelayerThread {
         burn_hash: BurnchainHeaderHash,
         committed_index_hash: StacksBlockId,
     ) -> MinerDirective {
-        let sn =
-            SortitionDB::get_block_snapshot_consensus(self.sortdb_ref().conn(), &consensus_hash)
-                .expect("FATAL: failed to query sortition DB")
-                .expect("FATAL: unknown consensus hash");
+        let sn = SortitionDB::get_block_snapshot_consensus(self.sortdb.conn(), &consensus_hash)
+            .expect("FATAL: failed to query sortition DB")
+            .expect("FATAL: unknown consensus hash");
 
         self.globals.set_last_sortition(sn.clone());
 
@@ -423,11 +396,10 @@ impl RelayerThread {
             // already in-flight
             return;
         }
-        let cur_epoch =
-            SortitionDB::get_stacks_epoch(self.sortdb_ref().conn(), burn_block.block_height)
-                .expect("FATAL: failed to query sortition DB")
-                .expect("FATAL: no epoch defined")
-                .epoch_id;
+        let cur_epoch = SortitionDB::get_stacks_epoch(self.sortdb.conn(), burn_block.block_height)
+            .expect("FATAL: failed to query sortition DB")
+            .expect("FATAL: no epoch defined")
+            .epoch_id;
         let (vrf_pk, _) = self.keychain.make_vrf_keypair(burn_block.block_height);
         let burnchain_tip_consensus_hash = &burn_block.consensus_hash;
         let miner_pkh = self.keychain.get_nakamoto_pkh();
@@ -464,24 +436,19 @@ impl RelayerThread {
         target_ch: &ConsensusHash,
         target_bh: &BlockHeaderHash,
     ) -> Result<(BlockSnapshot, StacksEpochId, LeaderBlockCommitOp), NakamotoNodeError> {
-        let chain_state = self
-            .chainstate
-            .as_mut()
-            .expect("FATAL: Failed to load chain state");
-        let sort_db = self.sortdb.as_mut().expect("FATAL: Failed to load sortdb");
-        let sort_tip = SortitionDB::get_canonical_burn_chain_tip(sort_db.conn())
+        let sort_tip = SortitionDB::get_canonical_burn_chain_tip(self.sortdb.conn())
             .map_err(|_| NakamotoNodeError::SnapshotNotFoundForChainTip)?;
 
         let parent_vrf_proof =
-            NakamotoChainState::get_block_vrf_proof(chain_state.db(), &target_ch)
+            NakamotoChainState::get_block_vrf_proof(self.chainstate.db(), &target_ch)
                 .map_err(|_e| NakamotoNodeError::ParentNotFound)?
                 .unwrap_or_else(|| VRFProof::empty());
 
         // let's figure out the recipient set!
         let recipients = get_next_recipients(
             &sort_tip,
-            chain_state,
-            sort_db,
+            &mut self.chainstate,
+            &mut self.sortdb,
             &self.burnchain,
             &OnChainRewardSetProvider(),
             self.config.node.always_use_affirmation_maps,
@@ -492,7 +459,7 @@ impl RelayerThread {
         })?;
 
         let block_header =
-            NakamotoChainState::get_block_header_by_consensus_hash(chain_state.db(), target_ch)
+            NakamotoChainState::get_block_header_by_consensus_hash(self.chainstate.db(), target_ch)
                 .map_err(|e| {
                     error!("Relayer: Failed to get block header for parent tenure: {e:?}");
                     NakamotoNodeError::ParentNotFound
@@ -511,14 +478,14 @@ impl RelayerThread {
         }
 
         let Ok(Some(parent_sortition)) =
-            SortitionDB::get_block_snapshot_consensus(sort_db.conn(), target_ch)
+            SortitionDB::get_block_snapshot_consensus(self.sortdb.conn(), target_ch)
         else {
             error!("Relayer: Failed to lookup the block snapshot of parent tenure ID"; "tenure_consensus_hash" => %target_ch);
             return Err(NakamotoNodeError::ParentNotFound);
         };
 
         let Ok(Some(target_epoch)) =
-            SortitionDB::get_stacks_epoch(sort_db.conn(), sort_tip.block_height + 1)
+            SortitionDB::get_stacks_epoch(self.sortdb.conn(), sort_tip.block_height + 1)
         else {
             error!("Relayer: Failed to lookup its epoch"; "target_height" => sort_tip.block_height + 1);
             return Err(NakamotoNodeError::SnapshotNotFoundForChainTip);
@@ -526,7 +493,7 @@ impl RelayerThread {
 
         let parent_block_burn_height = parent_sortition.block_height;
         let Ok(Some(parent_winning_tx)) = SortitionDB::get_block_commit(
-            sort_db.conn(),
+            self.sortdb.conn(),
             &parent_sortition.winning_block_txid,
             &parent_sortition.sortition_id,
         ) else {
@@ -621,7 +588,7 @@ impl RelayerThread {
         }
 
         let burn_header_hash = last_burn_block.burn_header_hash.clone();
-        let burn_chain_sn = SortitionDB::get_canonical_burn_chain_tip(self.sortdb_ref().conn())
+        let burn_chain_sn = SortitionDB::get_canonical_burn_chain_tip(self.sortdb.conn())
             .expect("FATAL: failed to query sortition DB for canonical burn chain tip");
 
         let burn_chain_tip = burn_chain_sn.burn_header_hash.clone();
@@ -779,8 +746,7 @@ impl RelayerThread {
             self.globals.get_leader_key_registration_state(),
             LeaderKeyRegistrationState::Inactive
         ) {
-            let Ok(sort_tip) = SortitionDB::get_canonical_burn_chain_tip(self.sortdb_ref().conn())
-            else {
+            let Ok(sort_tip) = SortitionDB::get_canonical_burn_chain_tip(self.sortdb.conn()) else {
                 warn!("Failed to fetch sortition tip while needing to register VRF key");
                 return None;
             };
@@ -796,8 +762,7 @@ impl RelayerThread {
         }
 
         // has there been a new sortition
-        let Ok(sort_tip) = SortitionDB::get_canonical_burn_chain_tip(self.sortdb_ref().conn())
-        else {
+        let Ok(sort_tip) = SortitionDB::get_canonical_burn_chain_tip(self.sortdb.conn()) else {
             return None;
         };
 
@@ -813,12 +778,11 @@ impl RelayerThread {
             true
         };
 
-        let Ok(Some(chain_tip_header)) = NakamotoChainState::get_canonical_block_header(
-            self.chainstate_ref().db(),
-            self.sortdb_ref(),
-        ) else {
+        let Ok(Some(chain_tip_header)) =
+            NakamotoChainState::get_canonical_block_header(self.chainstate.db(), &self.sortdb)
+        else {
             info!("No known canonical tip, will issue a genesis block commit");
-            return Some(RelayerDirective::NakamotoTenureStartProcessed(
+            return Some(RelayerDirective::IssueBlockCommit(
                 FIRST_BURNCHAIN_CONSENSUS_HASH,
                 FIRST_STACKS_BLOCK_HASH,
             ));
@@ -827,7 +791,7 @@ impl RelayerThread {
         // get the starting block of the chain tip's tenure
         let Ok(Some(chain_tip_tenure_start)) =
             NakamotoChainState::get_block_header_by_consensus_hash(
-                self.chainstate_ref().db(),
+                self.chainstate.db(),
                 &chain_tip_header.consensus_hash,
             )
         else {
@@ -849,7 +813,7 @@ impl RelayerThread {
             };
 
         if should_commit {
-            Some(RelayerDirective::NakamotoTenureStartProcessed(
+            Some(RelayerDirective::IssueBlockCommit(
                 chain_tip_header.consensus_hash,
                 chain_tip_header.anchored_header.block_hash(),
             ))
@@ -924,10 +888,10 @@ impl RelayerThread {
                 debug!("Relayer: directive Registered VRF key");
                 true
             }
-            // ProcessTenure directives correspond to a new sortition occurring.
+            // ProcessedBurnBlock directives correspond to a new sortition perhaps occurring.
             //  relayer should invoke `handle_sortition` to determine if they won the sortition,
             //  and to start their miner, or stop their miner if an active tenure is now ending
-            RelayerDirective::ProcessTenure(consensus_hash, burn_hash, block_header_hash) => {
+            RelayerDirective::ProcessedBurnBlock(consensus_hash, burn_hash, block_header_hash) => {
                 if !self.is_miner {
                     return true;
                 }
@@ -940,9 +904,8 @@ impl RelayerThread {
                 info!("Relayer: directive Processed tenures");
                 res
             }
-            // NakamotoTenureStartProcessed directives mean that a new tenure start has been processed
-            // These are triggered by the relayer waking up, seeing a new consensus hash *and* a new first tenure block
-            RelayerDirective::NakamotoTenureStartProcessed(consensus_hash, block_hash) => {
+            // These are triggered by the relayer waking up, seeing a new consensus hash *or* a new first tenure block
+            RelayerDirective::IssueBlockCommit(consensus_hash, block_hash) => {
                 if !self.is_miner {
                     return true;
                 }
@@ -953,11 +916,6 @@ impl RelayerThread {
                 debug!("Relayer: Nakamoto Tenure Start");
                 true
             }
-            RelayerDirective::RunTenure(..) => {
-                // No Op: the nakamoto node does not use the RunTenure directive to control its
-                //   miner thread.
-                true
-            }
             RelayerDirective::Exit => false,
         };
 
diff --git a/testnet/stacks-node/src/neon_node.rs b/testnet/stacks-node/src/neon_node.rs
index a3821fae2b..284d63a1c3 100644
--- a/testnet/stacks-node/src/neon_node.rs
+++ b/testnet/stacks-node/src/neon_node.rs
@@ -206,7 +206,7 @@ use crate::burnchains::bitcoin_regtest_controller::{
     addr2str, BitcoinRegtestController, OngoingBlockCommit,
 };
 use crate::burnchains::make_bitcoin_indexer;
-use crate::globals::{Globals, RelayerDirective};
+use crate::globals::{NeonGlobals as Globals, RelayerDirective};
 use crate::run_loop::neon::RunLoop;
 use crate::run_loop::RegisteredKey;
 use crate::ChainTip;
@@ -304,71 +304,59 @@ pub struct StacksNode {
 /// Fault injection logic to artificially increase the length of a tenure.
 /// Only used in testing
 #[cfg(test)]
-fn fault_injection_long_tenure() {
+pub(crate) fn fault_injection_long_tenure() {
     // simulated slow block
-    match std::env::var("STX_TEST_SLOW_TENURE") {
-        Ok(tenure_str) => match tenure_str.parse::<u64>() {
-            Ok(tenure_time) => {
-                info!(
-                    "Fault injection: sleeping for {} milliseconds to simulate a long tenure",
-                    tenure_time
-                );
-                stacks_common::util::sleep_ms(tenure_time);
-            }
-            Err(_) => {
-                error!("Parse error for STX_TEST_SLOW_TENURE");
-                panic!();
-            }
-        },
-        _ => {}
-    }
+    let Ok(tenure_str) = std::env::var("STX_TEST_SLOW_TENURE") else {
+        return;
+    };
+    let Ok(tenure_time) = tenure_str.parse::<u64>() else {
+        error!("Parse error for STX_TEST_SLOW_TENURE");
+        panic!();
+    };
+    info!(
+        "Fault injection: sleeping for {} milliseconds to simulate a long tenure",
+        tenure_time
+    );
+    stacks_common::util::sleep_ms(tenure_time);
 }
 
 #[cfg(not(test))]
-fn fault_injection_long_tenure() {}
+pub(crate) fn fault_injection_long_tenure() {}
 
 /// Fault injection to skip mining in this bitcoin block height
 /// Only used in testing
 #[cfg(test)]
-fn fault_injection_skip_mining(rpc_bind: &str, target_burn_height: u64) -> bool {
-    match std::env::var("STACKS_DISABLE_MINER") {
-        Ok(disable_heights) => {
-            let disable_schedule: serde_json::Value =
-                serde_json::from_str(&disable_heights).unwrap();
-            let disable_schedule = disable_schedule.as_array().unwrap();
-            for disabled in disable_schedule {
-                let target_miner_rpc_bind = disabled
-                    .get("rpc_bind")
-                    .unwrap()
-                    .as_str()
-                    .unwrap()
-                    .to_string();
-                if target_miner_rpc_bind != rpc_bind {
-                    continue;
-                }
-                let target_block_heights = disabled.get("blocks").unwrap().as_array().unwrap();
-                for target_block_value in target_block_heights {
-                    let target_block = target_block_value.as_i64().unwrap() as u64;
-                    if target_block == target_burn_height {
-                        return true;
-                    }
-                }
-            }
-            return false;
+pub(crate) fn fault_injection_skip_mining(rpc_bind: &str, target_burn_height: u64) -> bool {
+    let Ok(disable_heights) = std::env::var("STACKS_DISABLE_MINER") else {
+        return false;
+    };
+    let disable_schedule: serde_json::Value = serde_json::from_str(&disable_heights).unwrap();
+    let disable_schedule = disable_schedule.as_array().unwrap();
+    for disabled in disable_schedule {
+        let target_miner_rpc_bind = disabled.get("rpc_bind").unwrap().as_str().unwrap();
+        if target_miner_rpc_bind != rpc_bind {
+            continue;
         }
-        Err(_) => {
-            return false;
+        let target_block_heights = disabled.get("blocks").unwrap().as_array().unwrap();
+        for target_block_value in target_block_heights {
+            let target_block = u64::try_from(target_block_value.as_i64().unwrap()).unwrap();
+            if target_block == target_burn_height {
+                return true;
+            }
         }
     }
+    false
 }
 
 #[cfg(not(test))]
-fn fault_injection_skip_mining(_rpc_bind: &str, _target_burn_height: u64) -> bool {
+pub(crate) fn fault_injection_skip_mining(_rpc_bind: &str, _target_burn_height: u64) -> bool {
     false
 }
 
 /// Open the chainstate, and inject faults from the config file
-fn open_chainstate_with_faults(config: &Config) -> Result<StacksChainState, ChainstateError> {
+pub(crate) fn open_chainstate_with_faults(
+    config: &Config,
+) -> Result<StacksChainState, ChainstateError> {
     let stacks_chainstate_path = config.get_chainstate_path_str();
     let (mut chainstate, _) = StacksChainState::open(
         config.is_mainnet(),
@@ -3635,7 +3623,7 @@ impl StacksNode {
     }
 
     /// Set up the AST size-precheck height, if configured
-    fn setup_ast_size_precheck(config: &Config, sortdb: &mut SortitionDB) {
+    pub(crate) fn setup_ast_size_precheck(config: &Config, sortdb: &mut SortitionDB) {
         if let Some(ast_precheck_size_height) = config.burnchain.ast_precheck_size_height {
             info!(
                 "Override burnchain height of {:?} to {}",
@@ -3788,7 +3776,7 @@ impl StacksNode {
     }
 
     /// Set up the PeerNetwork, but do not bind it.
-    pub fn setup_peer_network(
+    pub(crate) fn setup_peer_network(
         config: &Config,
         atlas_config: &AtlasConfig,
         burnchain: Burnchain,
diff --git a/testnet/stacks-node/src/run_loop/boot_nakamoto.rs b/testnet/stacks-node/src/run_loop/boot_nakamoto.rs
index 1b54c24f5a..e70784ce42 100644
--- a/testnet/stacks-node/src/run_loop/boot_nakamoto.rs
+++ b/testnet/stacks-node/src/run_loop/boot_nakamoto.rs
@@ -1,3 +1,18 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020-2023 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Mutex};
 use std::thread::JoinHandle;
diff --git a/testnet/stacks-node/src/run_loop/nakamoto.rs b/testnet/stacks-node/src/run_loop/nakamoto.rs
index e6a835abb8..b3458a4ce6 100644
--- a/testnet/stacks-node/src/run_loop/nakamoto.rs
+++ b/testnet/stacks-node/src/run_loop/nakamoto.rs
@@ -1,3 +1,18 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020-2023 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
 use std::sync::atomic::AtomicBool;
 use std::sync::mpsc::sync_channel;
 use std::sync::{Arc, Mutex};
@@ -25,10 +40,9 @@ use stx_genesis::GenesisData;
 
 use super::RunLoopCallbacks;
 use crate::burnchains::make_bitcoin_indexer;
-use crate::globals::Globals;
+use crate::globals::Globals as GenericGlobals;
 use crate::monitoring::start_serving_monitoring_metrics;
-use crate::nakamoto_node::{StacksNode, BLOCK_PROCESSOR_STACK_SIZE, RELAYER_MAX_BUFFER};
-use crate::neon::RunLoopCounter;
+use crate::nakamoto_node::{self, StacksNode, BLOCK_PROCESSOR_STACK_SIZE, RELAYER_MAX_BUFFER};
 use crate::node::{
     get_account_balances, get_account_lockups, get_names, get_namespaces,
     use_test_genesis_chainstate,
@@ -41,6 +55,7 @@ use crate::{
 };
 
 pub const STDERR: i32 = 2;
+pub type Globals = GenericGlobals<nakamoto_node::relayer::RelayerDirective>;
 
 #[cfg(test)]
 const UNCONDITIONAL_CHAIN_LIVENESS_CHECK: u64 = 30;
@@ -116,22 +131,6 @@ impl RunLoop {
         self.coordinator_channels.as_ref().map(|x| x.1.clone())
     }
 
-    pub fn get_blocks_processed_arc(&self) -> RunLoopCounter {
-        self.counters.blocks_processed.clone()
-    }
-
-    pub fn submitted_commits(&self) -> RunLoopCounter {
-        self.counters.naka_submitted_commits.clone()
-    }
-
-    pub fn submitted_vrfs(&self) -> RunLoopCounter {
-        self.counters.naka_submitted_vrfs.clone()
-    }
-
-    pub fn mined_blocks(&self) -> RunLoopCounter {
-        self.counters.naka_mined_blocks.clone()
-    }
-
     pub fn get_counters(&self) -> Counters {
         self.counters.clone()
     }
diff --git a/testnet/stacks-node/src/run_loop/neon.rs b/testnet/stacks-node/src/run_loop/neon.rs
index c10c9b88c3..cffcd1aa10 100644
--- a/testnet/stacks-node/src/run_loop/neon.rs
+++ b/testnet/stacks-node/src/run_loop/neon.rs
@@ -31,7 +31,7 @@ use stx_genesis::GenesisData;
 
 use super::RunLoopCallbacks;
 use crate::burnchains::make_bitcoin_indexer;
-use crate::globals::Globals;
+use crate::globals::NeonGlobals as Globals;
 use crate::monitoring::start_serving_monitoring_metrics;
 use crate::neon_node::{StacksNode, BLOCK_PROCESSOR_STACK_SIZE, RELAYER_MAX_BUFFER};
 use crate::node::{
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index ad9c473992..2b4fdfa540 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -1,3 +1,18 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020-2023 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
 use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::{Arc, Mutex};
 use std::time::{Duration, Instant};
@@ -11,13 +26,11 @@ use stacks::chainstate::coordinator::comm::CoordinatorChannels;
 use stacks::chainstate::nakamoto::NakamotoChainState;
 use stacks::chainstate::stacks::db::StacksChainState;
 use stacks::core::{
-    MemPoolDB, StacksEpoch, StacksEpochId, BLOCK_LIMIT_MAINNET_10, HELIUM_BLOCK_LIMIT_20,
+    StacksEpoch, StacksEpochId, BLOCK_LIMIT_MAINNET_10, HELIUM_BLOCK_LIMIT_20,
     PEER_VERSION_EPOCH_1_0, PEER_VERSION_EPOCH_2_0, PEER_VERSION_EPOCH_2_05,
     PEER_VERSION_EPOCH_2_1, PEER_VERSION_EPOCH_2_2, PEER_VERSION_EPOCH_2_3, PEER_VERSION_EPOCH_2_4,
     PEER_VERSION_EPOCH_2_5, PEER_VERSION_EPOCH_3_0,
 };
-use stacks::cost_estimates::metrics::UnitMetric;
-use stacks::cost_estimates::UnitEstimator;
 use stacks_common::address::AddressHashMode;
 use stacks_common::consts::STACKS_EPOCH_MAX;
 use stacks_common::types::chainstate::StacksAddress;
@@ -411,14 +424,9 @@ fn simple_neon_integration() {
         .unwrap()
         .unwrap();
 
-    let mut mempool = MemPoolDB::open(
-        naka_conf.is_mainnet(),
-        naka_conf.burnchain.chain_id,
-        &naka_conf.get_chainstate_path_str(),
-        Box::new(UnitEstimator),
-        Box::new(UnitMetric),
-    )
-    .expect("Database failure opening mempool");
+    let mut mempool = naka_conf
+        .connect_mempool_db()
+        .expect("Database failure opening mempool");
 
     mempool
         .submit_raw(

From f075a99fc7b554479d8b43834ab2d6a94d3cfa75 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Sun, 10 Dec 2023 09:58:40 -0600
Subject: [PATCH 0204/1166] chore: comments, cleanup unused functions

---
 testnet/stacks-node/src/globals.rs            | 10 +-
 testnet/stacks-node/src/nakamoto_node.rs      | 59 ++++++------
 testnet/stacks-node/src/nakamoto_node/peer.rs |  4 +-
 .../stacks-node/src/nakamoto_node/relayer.rs  | 91 ++++++++-----------
 testnet/stacks-node/src/run_loop/nakamoto.rs  | 62 ++++++-------
 5 files changed, 102 insertions(+), 124 deletions(-)

diff --git a/testnet/stacks-node/src/globals.rs b/testnet/stacks-node/src/globals.rs
index 6c60e9a591..bd1560477c 100644
--- a/testnet/stacks-node/src/globals.rs
+++ b/testnet/stacks-node/src/globals.rs
@@ -35,7 +35,9 @@ pub enum RelayerDirective {
     Exit,
 }
 
-/// Inter-thread communication structure, shared between threads
+/// Inter-thread communication structure, shared between threads. This
+/// is generic over the relayer communication channel: nakamoto and
+/// neon nodes use different relayer directives.
 pub struct Globals<T> {
     /// Last sortition processed
     last_sortition: Arc<Mutex<Option<BlockSnapshot>>>,
@@ -100,6 +102,12 @@ impl<T> Globals<T> {
         }
     }
 
+    /// Does the inventory sync watcher think we still need to
+    /// catch up to the chain tip?
+    pub fn in_initial_block_download(&self) -> bool {
+        self.sync_comms.get_ibd()
+    }
+
     /// Get the last sortition processed by the relayer thread
     pub fn get_last_sortition(&self) -> Option<BlockSnapshot> {
         self.last_sortition
diff --git a/testnet/stacks-node/src/nakamoto_node.rs b/testnet/stacks-node/src/nakamoto_node.rs
index 0482bbfb05..3584a5d864 100644
--- a/testnet/stacks-node/src/nakamoto_node.rs
+++ b/testnet/stacks-node/src/nakamoto_node.rs
@@ -65,15 +65,18 @@ pub struct StacksNode {
     pub relayer_thread_handle: JoinHandle<()>,
 }
 
-/// Types of errors that can arise during mining
+/// Types of errors that can arise during Nakamoto StacksNode operation
 #[derive(Debug)]
-enum Error {
+pub enum Error {
     /// Can't find the block sortition snapshot for the chain tip
     SnapshotNotFoundForChainTip,
     /// The burnchain tip changed while this operation was in progress
     BurnchainTipChanged,
+    /// Error while spawning a subordinate thread
     SpawnError(std::io::Error),
+    /// Injected testing errors
     FaultInjection,
+    /// This miner was elected, but another sortition occurred before mining started
     MissedMiningOpportunity,
     /// Attempted to mine while there was no active VRF key
     NoVRFKeyActive,
@@ -83,7 +86,10 @@ enum Error {
     UnexpectedChainState,
     /// A burnchain operation failed when submitting it to the burnchain
     BurnchainSubmissionFailed,
+    /// A new parent has been discovered since mining started
     NewParentDiscovered,
+    // The thread that we tried to send to has closed
+    ChannelClosed,
 }
 
 impl StacksNode {
@@ -201,19 +207,14 @@ impl StacksNode {
     ///  telling it to process the block and begin mining if this miner won.
     /// returns _false_ if the relayer hung up the channel.
     /// Called from the main thread.
-    pub fn relayer_burnchain_notify(&self) -> bool {
+    fn relayer_burnchain_notify(&self, snapshot: BlockSnapshot) -> Result<(), Error> {
         if !self.is_miner {
-            // node is a follower, don't try to process my own tenure.
-            return true;
+            // node is a follower, don't need to notify the relayer of these events.
+            return Ok(());
         }
 
-        let Some(snapshot) = self.globals.get_last_sortition() else {
-            debug!("Tenure: Notify sortition! No last burn block");
-            return true;
-        };
-
-        debug!(
-            "Tenure: Notify sortition!";
+        info!(
+            "Tenure: Notify burn block!";
             "consensus_hash" => %snapshot.consensus_hash,
             "burn_block_hash" => %snapshot.burn_header_hash,
             "winning_stacks_block_hash" => %snapshot.winning_stacks_block_hash,
@@ -224,15 +225,14 @@ impl StacksNode {
         // unlike in neon_node, the nakamoto node should *always* notify the relayer of
         //  a new burnchain block
 
-        return self
-            .globals
+        self.globals
             .relay_send
             .send(RelayerDirective::ProcessedBurnBlock(
-                snapshot.consensus_hash.clone(),
-                snapshot.parent_burn_header_hash.clone(),
-                snapshot.winning_stacks_block_hash.clone(),
+                snapshot.consensus_hash,
+                snapshot.parent_burn_header_hash,
+                snapshot.winning_stacks_block_hash,
             ))
-            .is_ok();
+            .map_err(|_| Error::ChannelClosed)
     }
 
     /// Process a state coming from the burnchain, by extracting the validated KeyRegisterOp
@@ -244,9 +244,7 @@ impl StacksNode {
         sortdb: &SortitionDB,
         sort_id: &SortitionId,
         ibd: bool,
-    ) -> Option<BlockSnapshot> {
-        let mut last_sortitioned_block = None;
-
+    ) -> Result<(), Error> {
         let ic = sortdb.index_conn();
 
         let block_snapshot = SortitionDB::get_block_snapshot(&ic, sort_id)
@@ -268,14 +266,11 @@ impl StacksNode {
                     "Received burnchain block #{} including block_commit_op (winning) - {} ({})",
                     block_height, op.apparent_sender, &op.block_header_hash
                 );
-                last_sortitioned_block = Some((block_snapshot.clone(), op.vtxindex));
-            } else {
-                if self.is_miner {
-                    info!(
-                        "Received burnchain block #{} including block_commit_op - {} ({})",
-                        block_height, op.apparent_sender, &op.block_header_hash
-                    );
-                }
+            } else if self.is_miner {
+                info!(
+                    "Received burnchain block #{} including block_commit_op - {} ({})",
+                    block_height, op.apparent_sender, &op.block_header_hash
+                );
             }
         }
 
@@ -296,8 +291,10 @@ impl StacksNode {
             "in_initial_block_download?" => ibd,
         );
 
-        self.globals.set_last_sortition(block_snapshot);
-        last_sortitioned_block.map(|x| x.0)
+        self.globals.set_last_sortition(block_snapshot.clone());
+
+        // notify the relayer thread of the new sortition state
+        self.relayer_burnchain_notify(block_snapshot)
     }
 
     /// Join all inner threads
diff --git a/testnet/stacks-node/src/nakamoto_node/peer.rs b/testnet/stacks-node/src/nakamoto_node/peer.rs
index 762aa45eda..376c437723 100644
--- a/testnet/stacks-node/src/nakamoto_node/peer.rs
+++ b/testnet/stacks-node/src/nakamoto_node/peer.rs
@@ -154,7 +154,7 @@ impl PeerThread {
         )
     }
 
-    pub fn new_all(
+    fn new_all(
         globals: Globals,
         config: &Config,
         pox_constants: PoxConstants,
@@ -204,7 +204,7 @@ impl PeerThread {
 
     /// Run one pass of the p2p/http state machine
     /// Return true if we should continue running passes; false if not
-    pub fn run_one_pass<B: BurnchainHeaderReader>(
+    pub(crate) fn run_one_pass<B: BurnchainHeaderReader>(
         &mut self,
         indexer: &B,
         dns_client_opt: Option<&mut DNSClient>,
diff --git a/testnet/stacks-node/src/nakamoto_node/relayer.rs b/testnet/stacks-node/src/nakamoto_node/relayer.rs
index 04f04241e0..68ca5d723a 100644
--- a/testnet/stacks-node/src/nakamoto_node/relayer.rs
+++ b/testnet/stacks-node/src/nakamoto_node/relayer.rs
@@ -1,3 +1,4 @@
+use core::fmt;
 // Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
 // Copyright (C) 2020-2023 Stacks Open Internet Foundation
 //
@@ -38,8 +39,6 @@ use stacks::core::mempool::MemPoolDB;
 use stacks::core::{
     FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH, STACKS_EPOCH_3_0_MARKER,
 };
-use stacks::cost_estimates::metrics::UnitMetric;
-use stacks::cost_estimates::UnitEstimator;
 use stacks::monitoring::increment_stx_blocks_mined_counter;
 use stacks::net::db::LocalPeer;
 use stacks::net::relay::Relayer;
@@ -82,10 +81,23 @@ pub enum RelayerDirective {
     Exit,
 }
 
+impl fmt::Display for RelayerDirective {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            RelayerDirective::HandleNetResult(_) => write!(f, "HandleNetResult"),
+            RelayerDirective::ProcessedBurnBlock(_, _, _) => write!(f, "ProcessedBurnBlock"),
+            RelayerDirective::IssueBlockCommit(_, _) => write!(f, "IssueBlockCommit"),
+            RelayerDirective::RegisterKey(_) => write!(f, "RegisterKey"),
+            RelayerDirective::Exit => write!(f, "Exit"),
+        }
+    }
+}
+
 /// Relayer thread
 /// * accepts network results and stores blocks and microblocks
 /// * forwards new blocks, microblocks, and transactions to the p2p thread
-/// * processes burnchain state
+/// * issues (and re-issues) block commits to participate as a miner
+/// * processes burnchain state to determine if selected as a miner
 /// * if mining, runs the miner and broadcasts blocks (via a subordinate MinerThread)
 pub struct RelayerThread {
     /// Node config
@@ -148,14 +160,12 @@ pub struct RelayerThread {
 }
 
 impl RelayerThread {
-    /// Instantiate off of a StacksNode, a runloop, and a relayer.
+    /// Instantiate relayer thread.
+    /// Uses `runloop` to obtain globals, config, and `is_miner`` status
     pub fn new(runloop: &RunLoop, local_peer: LocalPeer, relayer: Relayer) -> RelayerThread {
         let config = runloop.config().clone();
         let globals = runloop.get_globals();
         let burn_db_path = config.get_burn_db_file_path();
-        let stacks_chainstate_path = config.get_chainstate_path_str();
-        let is_mainnet = config.is_mainnet();
-        let chain_id = config.burnchain.chain_id;
         let is_miner = runloop.is_miner();
 
         let sortdb = SortitionDB::open(&burn_db_path, true, runloop.get_burnchain().pox_constants)
@@ -164,21 +174,9 @@ impl RelayerThread {
         let chainstate =
             open_chainstate_with_faults(&config).expect("FATAL: failed to open chainstate DB");
 
-        let cost_estimator = config
-            .make_cost_estimator()
-            .unwrap_or_else(|| Box::new(UnitEstimator));
-        let metric = config
-            .make_cost_metric()
-            .unwrap_or_else(|| Box::new(UnitMetric));
-
-        let mempool = MemPoolDB::open(
-            is_mainnet,
-            chain_id,
-            &stacks_chainstate_path,
-            cost_estimator,
-            metric,
-        )
-        .expect("Database failure opening mempool");
+        let mempool = config
+            .connect_mempool_db()
+            .expect("Database failure opening mempool");
 
         let keychain = Keychain::default(config.node.seed.clone());
         let bitcoin_controller = BitcoinRegtestController::new_dummy(config.clone());
@@ -215,7 +213,7 @@ impl RelayerThread {
 
     /// have we waited for the right conditions under which to start mining a block off of our
     /// chain tip?
-    pub fn has_waited_for_latest_blocks(&self) -> bool {
+    fn has_waited_for_latest_blocks(&self) -> bool {
         // a network download pass took place
         (self.min_network_download_passes <= self.last_network_download_passes
         // a network inv pass took place
@@ -226,21 +224,6 @@ impl RelayerThread {
         || !self.config.miner.wait_for_block_download
     }
 
-    /// Return debug string for waiting for latest blocks
-    pub fn debug_waited_for_latest_blocks(&self) -> String {
-        format!(
-            "({} <= {} && {} <= {}) || {} + {} < {} || {}",
-            self.min_network_download_passes,
-            self.last_network_download_passes,
-            self.min_network_inv_passes,
-            self.last_network_inv_passes,
-            self.last_network_block_height_ts,
-            self.config.node.wait_time_for_blocks,
-            get_epoch_time_ms(),
-            self.config.miner.wait_for_block_download
-        )
-    }
-
     /// Handle a NetworkResult from the p2p/http state machine.  Usually this is the act of
     /// * preprocessing and storing new blocks and microblocks
     /// * relaying blocks, microblocks, and transacctions
@@ -503,7 +486,6 @@ impl RelayerThread {
 
         let parent_winning_vtxindex = parent_winning_tx.vtxindex;
 
-        // let burn_fee_cap = self.config.burnchain.burn_fee_cap;
         let burn_fee_cap = get_mining_spend_amount(self.globals.get_miner_status());
         let sunset_burn = self.burnchain.expected_sunset_burn(
             sort_tip.block_height + 1,
@@ -738,9 +720,6 @@ impl RelayerThread {
             return None;
         }
 
-        // TODO (nakamoto): the miner shouldn't issue either of these directives
-        //   if we're still in IBD!
-
         // do we need a VRF key registration?
         if matches!(
             self.globals.get_leader_key_registration_state(),
@@ -869,11 +848,10 @@ impl RelayerThread {
 
     /// Top-level dispatcher
     pub fn handle_directive(&mut self, directive: RelayerDirective) -> bool {
+        info!("Relayer: handling directive"; "directive" => %directive);
         let continue_running = match directive {
             RelayerDirective::HandleNetResult(net_result) => {
-                debug!("Relayer: directive Handle network result");
                 self.process_network_result(net_result);
-                debug!("Relayer: directive Handled network result");
                 true
             }
             // RegisterKey directives mean that the relayer should try to register a new VRF key.
@@ -882,10 +860,12 @@ impl RelayerThread {
                 if !self.is_miner {
                     return true;
                 }
-                debug!("Relayer: directive Register VRF key");
+                if self.globals.in_initial_block_download() {
+                    info!("In initial block download, will not submit VRF registration");
+                    return true;
+                }
                 self.rotate_vrf_and_register(&last_burn_block);
                 self.globals.counters.bump_blocks_processed();
-                debug!("Relayer: directive Registered VRF key");
                 true
             }
             // ProcessedBurnBlock directives correspond to a new sortition perhaps occurring.
@@ -895,30 +875,33 @@ impl RelayerThread {
                 if !self.is_miner {
                     return true;
                 }
-                info!("Relayer: directive Process tenures");
-                let res = self.handle_sortition(
+                if self.globals.in_initial_block_download() {
+                    debug!("In initial block download, will not check sortition for miner");
+                    return true;
+                }
+                self.handle_sortition(
                     consensus_hash,
                     burn_hash,
                     StacksBlockId(block_header_hash.0),
-                );
-                info!("Relayer: directive Processed tenures");
-                res
+                )
             }
             // These are triggered by the relayer waking up, seeing a new consensus hash *or* a new first tenure block
             RelayerDirective::IssueBlockCommit(consensus_hash, block_hash) => {
                 if !self.is_miner {
                     return true;
                 }
-                debug!("Relayer: Nakamoto Tenure Start");
+                if self.globals.in_initial_block_download() {
+                    debug!("In initial block download, will not issue block commit");
+                    return true;
+                }
                 if let Err(e) = self.issue_block_commit(consensus_hash, block_hash) {
                     warn!("Relayer failed to issue block commit"; "err" => ?e);
                 }
-                debug!("Relayer: Nakamoto Tenure Start");
                 true
             }
             RelayerDirective::Exit => false,
         };
-
+        debug!("Relayer: handled directive"; "continue_running" => continue_running);
         continue_running
     }
 }
diff --git a/testnet/stacks-node/src/run_loop/nakamoto.rs b/testnet/stacks-node/src/run_loop/nakamoto.rs
index b3458a4ce6..e429e79c91 100644
--- a/testnet/stacks-node/src/run_loop/nakamoto.rs
+++ b/testnet/stacks-node/src/run_loop/nakamoto.rs
@@ -38,7 +38,6 @@ use stacks_common::util::hash::Hash160;
 use stacks_common::util::{get_epoch_time_secs, sleep_ms};
 use stx_genesis::GenesisData;
 
-use super::RunLoopCallbacks;
 use crate::burnchains::make_bitcoin_indexer;
 use crate::globals::Globals as GenericGlobals;
 use crate::monitoring::start_serving_monitoring_metrics;
@@ -63,18 +62,18 @@ const UNCONDITIONAL_CHAIN_LIVENESS_CHECK: u64 = 30;
 #[cfg(not(test))]
 const UNCONDITIONAL_CHAIN_LIVENESS_CHECK: u64 = 300;
 
-/// Coordinating a node running in neon mode.
+/// Coordinating a node running in nakamoto mode. This runloop operates very similarly to the neon runloop.
 pub struct RunLoop {
     config: Config,
-    pub callbacks: RunLoopCallbacks,
     globals: Option<Globals>,
     counters: Counters,
     coordinator_channels: Option<(CoordinatorReceivers, CoordinatorChannels)>,
     should_keep_running: Arc<AtomicBool>,
     event_dispatcher: EventDispatcher,
+    #[allow(dead_code)]
     pox_watchdog: Option<PoxSyncWatchdog>, // can't be instantiated until .start() is called
-    is_miner: Option<bool>,                // not known until .start() is called
-    burnchain: Option<Burnchain>,          // not known until .start() is called
+    is_miner: Option<bool>,       // not known until .start() is called
+    burnchain: Option<Burnchain>, // not known until .start() is called
     pox_watchdog_comms: PoxSyncWatchdogComms,
     /// NOTE: this is duplicated in self.globals, but it needs to be accessible before globals is
     /// instantiated (namely, so the test framework can access it).
@@ -105,7 +104,6 @@ impl RunLoop {
             config,
             globals: None,
             coordinator_channels: Some(channels),
-            callbacks: RunLoopCallbacks::new(),
             counters: counters.unwrap_or_else(|| Counters::new()),
             should_keep_running,
             event_dispatcher,
@@ -117,7 +115,7 @@ impl RunLoop {
         }
     }
 
-    pub fn get_globals(&self) -> Globals {
+    pub(crate) fn get_globals(&self) -> Globals {
         self.globals
             .clone()
             .expect("FATAL: globals not instantiated")
@@ -127,47 +125,37 @@ impl RunLoop {
         self.globals = Some(globals);
     }
 
-    pub fn get_coordinator_channel(&self) -> Option<CoordinatorChannels> {
+    pub(crate) fn get_coordinator_channel(&self) -> Option<CoordinatorChannels> {
         self.coordinator_channels.as_ref().map(|x| x.1.clone())
     }
 
-    pub fn get_counters(&self) -> Counters {
+    pub(crate) fn get_counters(&self) -> Counters {
         self.counters.clone()
     }
 
-    pub fn config(&self) -> &Config {
+    pub(crate) fn config(&self) -> &Config {
         &self.config
     }
 
-    pub fn get_event_dispatcher(&self) -> EventDispatcher {
+    pub(crate) fn get_event_dispatcher(&self) -> EventDispatcher {
         self.event_dispatcher.clone()
     }
 
-    pub fn is_miner(&self) -> bool {
+    pub(crate) fn is_miner(&self) -> bool {
         self.is_miner.unwrap_or(false)
     }
 
-    pub fn get_pox_sync_comms(&self) -> PoxSyncWatchdogComms {
-        self.pox_watchdog_comms.clone()
-    }
-
-    pub fn get_termination_switch(&self) -> Arc<AtomicBool> {
+    pub(crate) fn get_termination_switch(&self) -> Arc<AtomicBool> {
         self.should_keep_running.clone()
     }
 
-    pub fn get_burnchain(&self) -> Burnchain {
+    pub(crate) fn get_burnchain(&self) -> Burnchain {
         self.burnchain
             .clone()
             .expect("FATAL: tried to get runloop burnchain before calling .start()")
     }
 
-    pub fn get_pox_watchdog(&mut self) -> &mut PoxSyncWatchdog {
-        self.pox_watchdog
-            .as_mut()
-            .expect("FATAL: tried to get PoX watchdog before calling .start()")
-    }
-
-    pub fn get_miner_status(&self) -> Arc<Mutex<MinerStatus>> {
+    pub(crate) fn get_miner_status(&self) -> Arc<Mutex<MinerStatus>> {
         self.miner_status.clone()
     }
 
@@ -228,7 +216,7 @@ impl RunLoop {
     /// Boot up the stacks chainstate.
     /// Instantiate the chainstate and push out the boot receipts to observers
     /// This is only public so we can test it.
-    pub fn boot_chainstate(&mut self, burnchain_config: &Burnchain) -> StacksChainState {
+    fn boot_chainstate(&mut self, burnchain_config: &Burnchain) -> StacksChainState {
         let use_test_genesis_data = use_test_genesis_chainstate(&self.config);
 
         // load up genesis balances
@@ -862,7 +850,14 @@ impl RunLoop {
             // wait for the p2p state-machine to do at least one pass
             debug!("Runloop: Wait until Stacks block downloads reach a quiescent state before processing more burnchain blocks"; "remote_chain_height" => remote_chain_height, "local_chain_height" => burnchain_height);
 
+            // TODO: for now, we just set initial block download false.
+            //   I think that the sync watchdog probably needs to change a fair bit
+            //   for nakamoto. There may be some opportunity to refactor this runloop
+            //   as well (e.g., the `mine_start` should be integrated with the
+            //   watchdog so that there's just one source of truth about ibd),
+            //   but I think all of this can be saved for post-neon work.
             let ibd = false;
+            self.pox_watchdog_comms.set_ibd(ibd);
 
             // calculate burnchain sync percentage
             let percent: f64 = if remote_chain_height > 0 {
@@ -947,16 +942,11 @@ impl RunLoop {
                         let sortition_id = &block.sortition_id;
 
                         // Have the node process the new block, that can include, or not, a sortition.
-                        node.process_burnchain_state(burnchain.sortdb_mut(), sortition_id, ibd);
-
-                        // Now, tell the relayer to check if it won a sortition during this block,
-                        // and, if so, to process and advertize the block.  This is basically a
-                        // no-op during boot-up.
-                        //
-                        // _this will block if the relayer's buffer is full_
-                        if !node.relayer_burnchain_notify() {
-                            // relayer hung up, exit.
-                            error!("Runloop: Block relayer and miner hung up, exiting.");
+                        if let Err(e) =
+                            node.process_burnchain_state(burnchain.sortdb_mut(), sortition_id, ibd)
+                        {
+                            // relayer errored, exit.
+                            error!("Runloop: Block relayer and miner errored, exiting."; "err" => ?e);
                             return;
                         }
                     }

From 54916105fd6dfcf3341c64b68efa9a53c33248fc Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Tue, 12 Dec 2023 09:48:21 -0600
Subject: [PATCH 0205/1166] chore: handle merge/rebase artifacts, address PR
 feedback

---
 Cargo.lock                                    |   4 +
 stackslib/src/chainstate/nakamoto/miner.rs    |  10 +-
 .../stacks-node/src/nakamoto_node/miner.rs    |  56 +--
 testnet/stacks-node/src/run_loop/nakamoto.rs  | 339 +-----------------
 4 files changed, 41 insertions(+), 368 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index a90cb48536..b9f59752b4 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2354,6 +2354,8 @@ checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39"
 [[package]]
 name = "p256k1"
 version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5afcf536d20c074ef45371ee9a654dcfc46fb2dde18ecc54ec30c936eb850fa2"
 dependencies = [
  "bindgen",
  "bitvec",
@@ -4711,6 +4713,8 @@ dependencies = [
 [[package]]
 name = "wsts"
 version = "5.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2c250118354755b4abb091a83cb8d659b511c0ae211ccdb3b1254e3db199cb86"
 dependencies = [
  "aes-gcm 0.10.2",
  "bs58 0.5.0",
diff --git a/stackslib/src/chainstate/nakamoto/miner.rs b/stackslib/src/chainstate/nakamoto/miner.rs
index 1f75cd55ac..5b511f6aa2 100644
--- a/stackslib/src/chainstate/nakamoto/miner.rs
+++ b/stackslib/src/chainstate/nakamoto/miner.rs
@@ -570,9 +570,13 @@ impl NakamotoBlockBuilder {
             .block_limit()
             .expect("Failed to obtain block limit from miner's block connection");
 
-        let initial_txs: Vec<_> = 
-            [new_tenure_info.tenure_change_tx.cloned(),
-             new_tenure_info.coinbase_tx.cloned()].into_iter().filter_map(|x| x).collect();
+        let initial_txs: Vec<_> = [
+            tenure_info.tenure_change_tx.clone(),
+            tenure_info.coinbase_tx.clone(),
+        ]
+        .into_iter()
+        .filter_map(|x| x)
+        .collect();
         let (blocked, tx_events) = match StacksBlockBuilder::select_and_apply_transactions(
             &mut tenure_tx,
             &mut builder,
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index ae2781ce7b..07efbedaca 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -21,7 +21,7 @@ use clarity::vm::types::PrincipalData;
 use stacks::burnchains::{Burnchain, BurnchainParameters};
 use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::burn::{BlockSnapshot, ConsensusHash};
-use stacks::chainstate::nakamoto::miner::{NakamotoBlockBuilder, NakamotoTenureStart};
+use stacks::chainstate::nakamoto::miner::{NakamotoBlockBuilder, NakamotoTenureInfo};
 use stacks::chainstate::nakamoto::{NakamotoBlock, NakamotoChainState};
 use stacks::chainstate::stacks::db::{StacksChainState, StacksHeaderInfo};
 use stacks::chainstate::stacks::{
@@ -56,9 +56,8 @@ pub enum MinerDirective {
 }
 
 struct ParentTenureInfo {
-    #[allow(dead_code)]
-    parent_tenure_start: StacksBlockId,
     parent_tenure_blocks: u64,
+    parent_tenure_consensus_hash: ConsensusHash,
 }
 
 /// Metadata required for beginning a new tenure
@@ -167,12 +166,12 @@ impl BlockMinerThread {
             self.burnchain.pox_constants.clone(),
         )
         .expect("FATAL: could not open sortition DB");
-        let sortition_handle = sort_db.index_handle_at_tip();
+        let mut sortition_handle = sort_db.index_handle_at_tip();
         let staging_tx = chain_state.staging_db_tx_begin()?;
         NakamotoChainState::accept_block(
             &chainstate_config,
             block,
-            &sortition_handle,
+            &mut sortition_handle,
             &staging_tx,
             &signer.aggregate_public_key,
         )?;
@@ -194,6 +193,7 @@ impl BlockMinerThread {
         &mut self,
         nonce: u64,
         parent_block_id: StacksBlockId,
+        parent_tenure_consensus_hash: ConsensusHash,
         parent_tenure_blocks: u64,
         miner_pkh: Hash160,
     ) -> Option<StacksTransaction> {
@@ -203,17 +203,18 @@ impl BlockMinerThread {
         }
         let is_mainnet = self.config.is_mainnet();
         let chain_id = self.config.burnchain.chain_id;
-        let tenure_change_tx_payload = TransactionPayload::TenureChange(
-            TenureChangePayload {
-                previous_tenure_end: parent_block_id,
-                previous_tenure_blocks: u32::try_from(parent_tenure_blocks)
-                    .expect("FATAL: more than u32 blocks in a tenure"),
-                cause: TenureChangeCause::BlockFound,
-                pubkey_hash: miner_pkh,
-                signers: vec![],
-            },
-            ThresholdSignature::mock(),
-        );
+        let tenure_change_tx_payload = TransactionPayload::TenureChange(TenureChangePayload {
+            tenure_consensus_hash: self.burn_block.consensus_hash.clone(),
+            prev_tenure_consensus_hash: parent_tenure_consensus_hash,
+            burn_view_consensus_hash: self.burn_block.consensus_hash.clone(),
+            previous_tenure_end: parent_block_id,
+            previous_tenure_blocks: u32::try_from(parent_tenure_blocks)
+                .expect("FATAL: more than u32 blocks in a tenure"),
+            cause: TenureChangeCause::BlockFound,
+            pubkey_hash: miner_pkh,
+            signers: vec![],
+            signature: ThresholdSignature::mock(),
+        });
 
         let mut tx_auth = self.keychain.get_transaction_auth().unwrap();
         tx_auth.set_origin_nonce(nonce);
@@ -297,7 +298,7 @@ impl BlockMinerThread {
 
             return Some(ParentStacksBlockInfo {
                 parent_tenure: Some(ParentTenureInfo {
-                    parent_tenure_start: chain_tip.metadata.index_block_hash(),
+                    parent_tenure_consensus_hash: chain_tip.metadata.consensus_hash,
                     parent_tenure_blocks: 0,
                 }),
                 stacks_parent_header: chain_tip.metadata,
@@ -404,6 +405,7 @@ impl BlockMinerThread {
             let tenure_change_tx = self.generate_tenure_change_tx(
                 current_miner_nonce,
                 parent_block_id,
+                par_tenure_info.parent_tenure_consensus_hash,
                 par_tenure_info.parent_tenure_blocks,
                 self.keychain.get_nakamoto_pkh(),
             )?;
@@ -412,16 +414,15 @@ impl BlockMinerThread {
                 target_epoch_id,
                 vrf_proof.clone(),
             );
-            Some(NakamotoTenureStart {
-                coinbase_tx,
-                // TODO (refactor): the nakamoto block builder doesn't use this VRF proof,
-                //  it has to be included in the coinbase tx, which is an arg to the builder.
-                //  we should probably just remove this from the nakamoto block builder.
-                vrf_proof: vrf_proof.clone(),
-                tenure_change_tx,
-            })
+            NakamotoTenureInfo {
+                coinbase_tx: Some(coinbase_tx),
+                tenure_change_tx: Some(tenure_change_tx),
+            }
         } else {
-            None
+            NakamotoTenureInfo {
+                coinbase_tx: None,
+                tenure_change_tx: None,
+            }
         };
 
         parent_block_info.stacks_parent_header.microblock_tail = None;
@@ -584,9 +585,10 @@ impl ParentStacksBlockInfo {
             } else {
                 1
             };
+            let parent_tenure_consensus_hash = parent_tenure_header.consensus_hash.clone();
             Some(ParentTenureInfo {
-                parent_tenure_start: parent_tenure_id.clone(),
                 parent_tenure_blocks,
+                parent_tenure_consensus_hash,
             })
         } else {
             None
diff --git a/testnet/stacks-node/src/run_loop/nakamoto.rs b/testnet/stacks-node/src/run_loop/nakamoto.rs
index e429e79c91..83382f869e 100644
--- a/testnet/stacks-node/src/run_loop/nakamoto.rs
+++ b/testnet/stacks-node/src/run_loop/nakamoto.rs
@@ -25,9 +25,7 @@ use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::burn::BlockSnapshot;
 use stacks::chainstate::coordinator::comm::{CoordinatorChannels, CoordinatorReceivers};
 use stacks::chainstate::coordinator::{
-    static_get_canonical_affirmation_map, static_get_heaviest_affirmation_map,
-    static_get_stacks_tip_affirmation_map, ChainsCoordinator, ChainsCoordinatorConfig,
-    CoordinatorCommunication,
+    ChainsCoordinator, ChainsCoordinatorConfig, CoordinatorCommunication,
 };
 use stacks::chainstate::stacks::db::{ChainStateBootData, StacksChainState};
 use stacks::chainstate::stacks::miner::{signal_mining_blocked, signal_mining_ready, MinerStatus};
@@ -35,7 +33,6 @@ use stacks::core::StacksEpochId;
 use stacks::net::atlas::{AtlasConfig, AtlasDB, Attachment};
 use stacks_common::types::PublicKey;
 use stacks_common::util::hash::Hash160;
-use stacks_common::util::{get_epoch_time_secs, sleep_ms};
 use stx_genesis::GenesisData;
 
 use crate::burnchains::make_bitcoin_indexer;
@@ -56,12 +53,6 @@ use crate::{
 pub const STDERR: i32 = 2;
 pub type Globals = GenericGlobals<nakamoto_node::relayer::RelayerDirective>;
 
-#[cfg(test)]
-const UNCONDITIONAL_CHAIN_LIVENESS_CHECK: u64 = 30;
-
-#[cfg(not(test))]
-const UNCONDITIONAL_CHAIN_LIVENESS_CHECK: u64 = 300;
-
 /// Coordinating a node running in nakamoto mode. This runloop operates very similarly to the neon runloop.
 pub struct RunLoop {
     config: Config,
@@ -389,332 +380,6 @@ impl RunLoop {
         )
     }
 
-    /// Wake up and drive stacks block processing if there's been a PoX reorg.
-    /// Be careful not to saturate calls to announce new stacks blocks, because that will disable
-    /// mining (which would prevent a miner attempting to fix a hidden PoX anchor block from making
-    /// progress).
-    fn drive_pox_reorg_stacks_block_processing(
-        globals: &Globals,
-        config: &Config,
-        burnchain: &Burnchain,
-        sortdb: &SortitionDB,
-        last_stacks_pox_reorg_recover_time: &mut u128,
-    ) {
-        let delay = cmp::max(
-            config.node.chain_liveness_poll_time_secs,
-            cmp::max(
-                config.miner.first_attempt_time_ms,
-                config.miner.subsequent_attempt_time_ms,
-            ) / 1000,
-        );
-
-        if *last_stacks_pox_reorg_recover_time + (delay as u128) >= get_epoch_time_secs().into() {
-            // too soon
-            return;
-        }
-
-        // compare stacks and heaviest AMs
-        let burnchain_db = burnchain
-            .open_burnchain_db(false)
-            .expect("FATAL: failed to open burnchain DB");
-
-        let sn = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn())
-            .expect("FATAL: could not read sortition DB");
-
-        let indexer = make_bitcoin_indexer(config, Some(globals.should_keep_running.clone()));
-
-        let heaviest_affirmation_map = match static_get_heaviest_affirmation_map(
-            &burnchain,
-            &indexer,
-            &burnchain_db,
-            sortdb,
-            &sn.sortition_id,
-        ) {
-            Ok(am) => am,
-            Err(e) => {
-                warn!("Failed to find heaviest affirmation map: {:?}", &e);
-                return;
-            }
-        };
-
-        let highest_sn = SortitionDB::get_highest_known_burn_chain_tip(sortdb.conn())
-            .expect("FATAL: could not read sortition DB");
-
-        let canonical_burnchain_tip = burnchain_db
-            .get_canonical_chain_tip()
-            .expect("FATAL: could not read burnchain DB");
-
-        let sortition_tip_affirmation_map =
-            match SortitionDB::find_sortition_tip_affirmation_map(sortdb, &sn.sortition_id) {
-                Ok(am) => am,
-                Err(e) => {
-                    warn!("Failed to find sortition affirmation map: {:?}", &e);
-                    return;
-                }
-            };
-
-        let stacks_tip_affirmation_map = static_get_stacks_tip_affirmation_map(
-            &burnchain_db,
-            sortdb,
-            &sn.sortition_id,
-            &sn.canonical_stacks_tip_consensus_hash,
-            &sn.canonical_stacks_tip_hash,
-        )
-        .expect("FATAL: could not query stacks DB");
-
-        if stacks_tip_affirmation_map.len() < heaviest_affirmation_map.len()
-            || stacks_tip_affirmation_map
-                .find_divergence(&heaviest_affirmation_map)
-                .is_some()
-        {
-            // the sortition affirmation map might also be inconsistent, so we'll need to fix that
-            // (i.e. the underlying sortitions) before we can fix the stacks fork
-            if sortition_tip_affirmation_map.len() < heaviest_affirmation_map.len()
-                || sortition_tip_affirmation_map
-                    .find_divergence(&heaviest_affirmation_map)
-                    .is_some()
-            {
-                debug!("Drive burn block processing: possible PoX reorg (sortition tip: {}, heaviest: {})", &sortition_tip_affirmation_map, &heaviest_affirmation_map);
-                globals.coord().announce_new_burn_block();
-            } else if highest_sn.block_height == sn.block_height
-                && sn.block_height == canonical_burnchain_tip.block_height
-            {
-                // need to force an affirmation reorg because there will be no more burn block
-                // announcements.
-                debug!("Drive burn block processing: possible PoX reorg (sortition tip: {}, heaviest: {}, burn height {})", &sortition_tip_affirmation_map, &heaviest_affirmation_map, sn.block_height);
-                globals.coord().announce_new_burn_block();
-            }
-
-            debug!(
-                "Drive stacks block processing: possible PoX reorg (stacks tip: {}, heaviest: {})",
-                &stacks_tip_affirmation_map, &heaviest_affirmation_map
-            );
-            globals.coord().announce_new_stacks_block();
-        } else {
-            debug!(
-                "Drive stacks block processing: no need (stacks tip: {}, heaviest: {})",
-                &stacks_tip_affirmation_map, &heaviest_affirmation_map
-            );
-
-            // announce a new stacks block to force the chains coordinator
-            //  to wake up anyways. this isn't free, so we have to make sure
-            //  the chain-liveness thread doesn't wake up too often
-            globals.coord().announce_new_stacks_block();
-        }
-
-        *last_stacks_pox_reorg_recover_time = get_epoch_time_secs().into();
-    }
-
-    /// Wake up and drive sortition processing if there's been a PoX reorg.
-    /// Be careful not to saturate calls to announce new burn blocks, because that will disable
-    /// mining (which would prevent a miner attempting to fix a hidden PoX anchor block from making
-    /// progress).
-    ///
-    /// only call if no in ibd
-    fn drive_pox_reorg_burn_block_processing(
-        globals: &Globals,
-        config: &Config,
-        burnchain: &Burnchain,
-        sortdb: &SortitionDB,
-        chain_state_db: &StacksChainState,
-        last_burn_pox_reorg_recover_time: &mut u128,
-        last_announce_time: &mut u128,
-    ) {
-        let delay = cmp::max(
-            config.node.chain_liveness_poll_time_secs,
-            cmp::max(
-                config.miner.first_attempt_time_ms,
-                config.miner.subsequent_attempt_time_ms,
-            ) / 1000,
-        );
-
-        if *last_burn_pox_reorg_recover_time + (delay as u128) >= get_epoch_time_secs().into() {
-            // too soon
-            return;
-        }
-
-        // compare sortition and heaviest AMs
-        let burnchain_db = burnchain
-            .open_burnchain_db(false)
-            .expect("FATAL: failed to open burnchain DB");
-
-        let highest_sn = SortitionDB::get_highest_known_burn_chain_tip(sortdb.conn())
-            .expect("FATAL: could not read sortition DB");
-
-        let canonical_burnchain_tip = burnchain_db
-            .get_canonical_chain_tip()
-            .expect("FATAL: could not read burnchain DB");
-
-        if canonical_burnchain_tip.block_height > highest_sn.block_height {
-            // still processing sortitions
-            test_debug!(
-                "Drive burn block processing: still processing sortitions ({} > {})",
-                canonical_burnchain_tip.block_height,
-                highest_sn.block_height
-            );
-            return;
-        }
-
-        // NOTE: this could be lower than the highest_sn
-        let sn = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn())
-            .expect("FATAL: could not read sortition DB");
-
-        let sortition_tip_affirmation_map =
-            match SortitionDB::find_sortition_tip_affirmation_map(sortdb, &sn.sortition_id) {
-                Ok(am) => am,
-                Err(e) => {
-                    warn!("Failed to find sortition affirmation map: {:?}", &e);
-                    return;
-                }
-            };
-
-        let indexer = make_bitcoin_indexer(config, Some(globals.should_keep_running.clone()));
-
-        let heaviest_affirmation_map = match static_get_heaviest_affirmation_map(
-            &burnchain,
-            &indexer,
-            &burnchain_db,
-            sortdb,
-            &sn.sortition_id,
-        ) {
-            Ok(am) => am,
-            Err(e) => {
-                warn!("Failed to find heaviest affirmation map: {:?}", &e);
-                return;
-            }
-        };
-
-        let canonical_affirmation_map = match static_get_canonical_affirmation_map(
-            &burnchain,
-            &indexer,
-            &burnchain_db,
-            sortdb,
-            &chain_state_db,
-            &sn.sortition_id,
-        ) {
-            Ok(am) => am,
-            Err(e) => {
-                warn!("Failed to find canonical affirmation map: {:?}", &e);
-                return;
-            }
-        };
-
-        if sortition_tip_affirmation_map.len() < heaviest_affirmation_map.len()
-            || sortition_tip_affirmation_map
-                .find_divergence(&heaviest_affirmation_map)
-                .is_some()
-            || sn.block_height < highest_sn.block_height
-        {
-            debug!("Drive burn block processing: possible PoX reorg (sortition tip: {}, heaviest: {}, {} <? {})", &sortition_tip_affirmation_map, &heaviest_affirmation_map, sn.block_height, highest_sn.block_height);
-            globals.coord().announce_new_burn_block();
-            globals.coord().announce_new_stacks_block();
-            *last_announce_time = get_epoch_time_secs().into();
-        } else if sortition_tip_affirmation_map.len() >= heaviest_affirmation_map.len()
-            && sortition_tip_affirmation_map.len() <= canonical_affirmation_map.len()
-        {
-            if let Some(divergence_rc) =
-                canonical_affirmation_map.find_divergence(&sortition_tip_affirmation_map)
-            {
-                if divergence_rc + 1 >= (heaviest_affirmation_map.len() as u64) {
-                    // we have unaffirmed PoX anchor blocks that are not yet processed in the sortition history
-                    debug!("Drive burnchain processing: possible PoX reorg from unprocessed anchor block(s) (sortition tip: {}, heaviest: {}, canonical: {})", &sortition_tip_affirmation_map, &heaviest_affirmation_map, &canonical_affirmation_map);
-                    globals.coord().announce_new_burn_block();
-                    globals.coord().announce_new_stacks_block();
-                    *last_announce_time = get_epoch_time_secs().into();
-                }
-            }
-        } else {
-            debug!(
-                "Drive burn block processing: no need (sortition tip: {}, heaviest: {}, {} </ {})",
-                &sortition_tip_affirmation_map,
-                &heaviest_affirmation_map,
-                sn.block_height,
-                highest_sn.block_height
-            );
-        }
-
-        *last_burn_pox_reorg_recover_time = get_epoch_time_secs().into();
-
-        // unconditionally bump every 5 minutes, just in case.
-        // this can get the node un-stuck if we're short on sortition processing but are unable to
-        // sync with the remote node because it keeps NACK'ing us, leading to a runloop stall.
-        if *last_announce_time + (UNCONDITIONAL_CHAIN_LIVENESS_CHECK as u128)
-            < get_epoch_time_secs().into()
-        {
-            debug!("Drive burnchain processing: unconditional bump");
-            globals.coord().announce_new_burn_block();
-            globals.coord().announce_new_stacks_block();
-            *last_announce_time = get_epoch_time_secs().into();
-        }
-    }
-
-    /// In a separate thread, periodically drive coordinator liveness by checking to see if there's
-    /// a pending reorg and if so, waking up the coordinator to go and process new blocks
-    fn drive_chain_liveness(
-        globals: Globals,
-        config: Config,
-        burnchain: Burnchain,
-        sortdb: SortitionDB,
-        chain_state_db: StacksChainState,
-    ) {
-        let mut last_burn_pox_reorg_recover_time = 0;
-        let mut last_stacks_pox_reorg_recover_time = 0;
-        let mut last_burn_announce_time = 0;
-
-        debug!("Chain-liveness thread start!");
-
-        while globals.keep_running() {
-            debug!("Chain-liveness checkup");
-            Self::drive_pox_reorg_burn_block_processing(
-                &globals,
-                &config,
-                &burnchain,
-                &sortdb,
-                &chain_state_db,
-                &mut last_burn_pox_reorg_recover_time,
-                &mut last_burn_announce_time,
-            );
-            Self::drive_pox_reorg_stacks_block_processing(
-                &globals,
-                &config,
-                &burnchain,
-                &sortdb,
-                &mut last_stacks_pox_reorg_recover_time,
-            );
-
-            sleep_ms(3000);
-        }
-
-        debug!("Chain-liveness thread exit!");
-    }
-
-    /// Spawn a thread to drive chain liveness
-    fn spawn_chain_liveness_thread(&self, globals: Globals) -> JoinHandle<()> {
-        let config = self.config.clone();
-        let burnchain = self.get_burnchain();
-        let sortdb = burnchain
-            .open_sortition_db(true)
-            .expect("FATAL: could not open sortition DB");
-
-        let (chain_state_db, _) = StacksChainState::open(
-            config.is_mainnet(),
-            config.burnchain.chain_id,
-            &config.get_chainstate_path_str(),
-            Some(config.node.get_marf_opts()),
-        )
-        .unwrap();
-
-        let liveness_thread_handle = thread::Builder::new()
-            .name(format!("chain-liveness-{}", config.node.rpc_bind))
-            .stack_size(BLOCK_PROCESSOR_STACK_SIZE)
-            .spawn(move || {
-                Self::drive_chain_liveness(globals, config, burnchain, sortdb, chain_state_db)
-            })
-            .expect("FATAL: failed to spawn chain liveness thread");
-
-        liveness_thread_handle
-    }
-
     /// Starts the node runloop.
     ///
     /// This function will block by looping infinitely.
@@ -789,7 +454,6 @@ impl RunLoop {
         // Boot up the p2p network and relayer, and figure out how many sortitions we have so far
         // (it could be non-zero if the node is resuming from chainstate)
         let mut node = StacksNode::spawn(self, globals.clone(), relay_recv);
-        let liveness_thread = self.spawn_chain_liveness_thread(globals.clone());
 
         // Wait for all pending sortitions to process
         let burnchain_db = burnchain_config
@@ -839,7 +503,6 @@ impl RunLoop {
                 globals.coord().stop_chains_coordinator();
                 coordinator_thread_handle.join().unwrap();
                 node.join();
-                liveness_thread.join().unwrap();
 
                 info!("Exiting stacks-node");
                 break;

From 1ec878f6c0f4b8c2c75cc32fb229ff7cbe79babf Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Tue, 12 Dec 2023 10:21:33 -0600
Subject: [PATCH 0206/1166] remove unconfirmed tx handling in nakamoto
 RelayerThread

---
 .../stacks-node/src/nakamoto_node/relayer.rs  | 21 ++-----------------
 1 file changed, 2 insertions(+), 19 deletions(-)

diff --git a/testnet/stacks-node/src/nakamoto_node/relayer.rs b/testnet/stacks-node/src/nakamoto_node/relayer.rs
index 68ca5d723a..8c83bb35b9 100644
--- a/testnet/stacks-node/src/nakamoto_node/relayer.rs
+++ b/testnet/stacks-node/src/nakamoto_node/relayer.rs
@@ -1,4 +1,3 @@
-use core::fmt;
 // Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
 // Copyright (C) 2020-2023 Stacks Open Internet Foundation
 //
@@ -14,6 +13,7 @@ use core::fmt;
 //
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
+use core::fmt;
 use std::collections::HashMap;
 use std::sync::mpsc::{Receiver, RecvTimeoutError};
 use std::thread::JoinHandle;
@@ -261,7 +261,7 @@ impl RelayerThread {
             )
             .expect("BUG: failure processing network results");
 
-        if net_receipts.num_new_blocks > 0 || net_receipts.num_new_confirmed_microblocks > 0 {
+        if net_receipts.num_new_blocks > 0 {
             // if we received any new block data that could invalidate our view of the chain tip,
             // then stop mining until we process it
             debug!("Relayer: block mining to process newly-arrived blocks or microblocks");
@@ -274,29 +274,12 @@ impl RelayerThread {
                 .process_new_mempool_txs(net_receipts.mempool_txs_added);
         }
 
-        let num_unconfirmed_microblock_tx_receipts =
-            net_receipts.processed_unconfirmed_state.receipts.len();
-        if num_unconfirmed_microblock_tx_receipts > 0 {
-            if let Some(unconfirmed_state) = self.chainstate.unconfirmed_state.as_ref() {
-                let canonical_tip = unconfirmed_state.confirmed_chain_tip.clone();
-                self.event_dispatcher.process_new_microblocks(
-                    canonical_tip,
-                    net_receipts.processed_unconfirmed_state,
-                );
-            } else {
-                warn!("Relayer: oops, unconfirmed state is uninitialized but there are microblock events");
-            }
-        }
-
         // Dispatch retrieved attachments, if any.
         if net_result.has_attachments() {
             self.event_dispatcher
                 .process_new_attachments(&net_result.attachments);
         }
 
-        // synchronize unconfirmed tx index to p2p thread
-        self.globals.send_unconfirmed_txs(&self.chainstate);
-
         // resume mining if we blocked it, and if we've done the requisite download
         // passes
         self.last_network_download_passes = net_result.num_download_passes;

From be055d1a7ba01d730b79d9b90c7bc82a68f21935 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Tue, 12 Dec 2023 11:49:11 -0600
Subject: [PATCH 0207/1166] add epoch-3.0 burnchain configuration assertions

---
 testnet/stacks-node/src/config.rs             | 25 +++++++++++++++++++
 .../src/tests/nakamoto_integrations.rs        |  6 ++---
 2 files changed, 28 insertions(+), 3 deletions(-)

diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index 526c2a90da..8b1f7a8578 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -624,6 +624,31 @@ impl Config {
             );
             burnchain.pox_constants.sunset_end = sunset_end.into();
         }
+
+        // check if the Epoch 3.0 burnchain settings as configured are going to be valid.
+        let epochs = StacksEpoch::get_epochs(
+            self.burnchain.get_bitcoin_network().1,
+            self.burnchain.epochs.as_ref(),
+        );
+        let Some(epoch_30) = StacksEpoch::find_epoch_by_id(&epochs, StacksEpochId::Epoch30)
+            .map(|epoch_ix| epochs[epoch_ix].clone())
+        else {
+            // no Epoch 3.0, so just return
+            return;
+        };
+        if burnchain.pox_constants.prepare_length < 3 {
+            panic!(
+                "FATAL: Nakamoto rules require a prepare length >= 3. Prepare length set to {}",
+                burnchain.pox_constants.prepare_length
+            );
+        }
+        if burnchain.is_in_prepare_phase(epoch_30.start_height) {
+            panic!(
+                "FATAL: Epoch 3.0 must start *during* a reward phase, not a prepare phase. Epoch 3.0 start set to: {}. PoX Parameters: {:?}",
+                epoch_30.start_height,
+                &burnchain.pox_constants
+            );
+        }
     }
 
     /// Load up a Burnchain and apply config settings to it.
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 2b4fdfa540..0b1d79ffa3 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -105,13 +105,13 @@ lazy_static! {
         StacksEpoch {
             epoch_id: StacksEpochId::Epoch25,
             start_height: 6,
-            end_height: 220,
+            end_height: 221,
             block_limit: HELIUM_BLOCK_LIMIT_20.clone(),
             network_epoch: PEER_VERSION_EPOCH_2_5
         },
         StacksEpoch {
             epoch_id: StacksEpochId::Epoch30,
-            start_height: 220,
+            start_height: 221,
             end_height: STACKS_EPOCH_MAX,
             block_limit: HELIUM_BLOCK_LIMIT_20.clone(),
             network_epoch: PEER_VERSION_EPOCH_3_0
@@ -226,7 +226,7 @@ fn next_block_and_mine_commit(
                 return Ok(true);
             }
             if commits_sent >= commits_before + 1
-                && block_processed_time.elapsed() > Duration::from_secs(10)
+                && block_processed_time.elapsed() > Duration::from_secs(6)
             {
                 return Ok(true);
             }

From 636230795a167b8ecf5f34a384ce27e815d6f3b1 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Tue, 12 Dec 2023 14:58:03 -0600
Subject: [PATCH 0208/1166] requirements for configuring nakamoto-neon via
 CLI/toml

---
 Cargo.lock                                    |  3 +-
 Cargo.toml                                    |  2 +
 testnet/stacks-node/Cargo.toml                |  3 +-
 testnet/stacks-node/src/config.rs             |  7 ++-
 testnet/stacks-node/src/keychain.rs           |  7 ++-
 testnet/stacks-node/src/mockamoto/signer.rs   | 13 ++++-
 testnet/stacks-node/src/nakamoto_node.rs      | 14 ++++-
 .../stacks-node/src/nakamoto_node/miner.rs    | 52 ++++++++++++-------
 .../stacks-node/src/nakamoto_node/relayer.rs  |  8 ++-
 testnet/stacks-node/src/run_loop/nakamoto.rs  |  3 +-
 testnet/stacks-node/src/run_loop/neon.rs      |  7 +--
 11 files changed, 83 insertions(+), 36 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index b9f59752b4..78c3a9e1e6 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3551,8 +3551,7 @@ dependencies = [
  "libc",
  "libsigner",
  "pico-args",
- "rand 0.7.3",
- "rand_core 0.6.4",
+ "rand 0.8.5",
  "regex",
  "reqwest",
  "ring",
diff --git a/Cargo.toml b/Cargo.toml
index a861f143e9..3d2d9d066d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -15,6 +15,8 @@ members = [
 # Dependencies we want to keep the same between workspace members
 [workspace.dependencies]  
 wsts = "5.0"
+rand_core = "0.6"
+rand = "0.8"
 
 # Use a bit more than default optimization for
 #  dev builds to speed up test execution
diff --git a/testnet/stacks-node/Cargo.toml b/testnet/stacks-node/Cargo.toml
index 780b65116e..9e0c8a74e7 100644
--- a/testnet/stacks-node/Cargo.toml
+++ b/testnet/stacks-node/Cargo.toml
@@ -9,7 +9,6 @@ rust-version = "1.61"
 [dependencies]
 lazy_static = "1.4.0"
 pico-args = "0.3.1"
-rand = "0.7.3"
 serde = "1"
 serde_derive = "1"
 serde_json = { version = "1.0", features = ["arbitrary_precision", "raw_value"] }
@@ -29,7 +28,7 @@ chrono = "0.4.19"
 regex = "1"
 libsigner = { path = "../../libsigner" }
 wsts = { workspace = true }
-rand_core = "0.6"
+rand = { workspace = true }
 
 [dev-dependencies]
 ring = "0.16.19"
diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index 8b1f7a8578..9018511b5a 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -1150,7 +1150,11 @@ impl Config {
                     .as_ref()
                     .map(|x| Secp256k1PrivateKey::from_hex(x))
                     .transpose()?,
-                self_signing_key: None,
+                self_signing_key: miner
+                    .self_signing_seed
+                    .as_ref()
+                    .map(|x| SelfSigner::from_seed(*x))
+                    .or(miner_default_config.self_signing_key),
             },
             None => miner_default_config,
         };
@@ -2300,6 +2304,7 @@ pub struct MinerConfigFile {
     pub candidate_retry_cache_size: Option<u64>,
     pub unprocessed_block_deadline_secs: Option<u64>,
     pub mining_key: Option<String>,
+    pub self_signing_seed: Option<u64>,
 }
 
 #[derive(Clone, Deserialize, Default, Debug)]
diff --git a/testnet/stacks-node/src/keychain.rs b/testnet/stacks-node/src/keychain.rs
index 712fa0b662..d2575cb2b9 100644
--- a/testnet/stacks-node/src/keychain.rs
+++ b/testnet/stacks-node/src/keychain.rs
@@ -51,11 +51,16 @@ impl Keychain {
         Hash160::from_node_public_key(&pk)
     }
 
-    /// Get the secrete key of the nakamoto mining key
+    /// Get the secret key of the nakamoto mining key
     pub fn get_nakamoto_sk(&self) -> &Secp256k1PrivateKey {
         &self.nakamoto_mining_key
     }
 
+    /// Set the secret key of the nakamoto mining key
+    pub fn set_nakamoto_sk(&mut self, mining_key: Secp256k1PrivateKey) {
+        self.nakamoto_mining_key = mining_key;
+    }
+
     /// Create a default keychain from the seed, with a default nakamoto mining key derived
     ///  from the same seed (
     pub fn default(seed: Vec<u8>) -> Keychain {
diff --git a/testnet/stacks-node/src/mockamoto/signer.rs b/testnet/stacks-node/src/mockamoto/signer.rs
index c0d4af0b69..7e577b24f2 100644
--- a/testnet/stacks-node/src/mockamoto/signer.rs
+++ b/testnet/stacks-node/src/mockamoto/signer.rs
@@ -1,3 +1,4 @@
+use rand::{CryptoRng, RngCore, SeedableRng};
 use stacks::chainstate::nakamoto::NakamotoBlock;
 use stacks::chainstate::stacks::ThresholdSignature;
 use wsts::curve::point::Point;
@@ -22,9 +23,17 @@ pub struct SelfSigner {
 }
 
 impl SelfSigner {
+    pub fn from_seed(seed: u64) -> Self {
+        let rng = rand::rngs::StdRng::seed_from_u64(seed);
+        Self::from_rng::<rand::rngs::StdRng>(rng)
+    }
+
     pub fn single_signer() -> Self {
-        let mut rng = rand_core::OsRng::default();
+        let rng = rand::rngs::OsRng::default();
+        Self::from_rng::<rand::rngs::OsRng>(rng)
+    }
 
+    fn from_rng<RNG: RngCore + CryptoRng>(mut rng: RNG) -> Self {
         // Create the parties
         let mut signer_parties = [wsts::v2::Party::new(0, &[0], 1, 1, 1, &mut rng)];
 
@@ -54,7 +63,7 @@ impl SelfSigner {
     }
 
     pub fn sign_nakamoto_block(&mut self, block: &mut NakamotoBlock) {
-        let mut rng = rand_core::OsRng;
+        let mut rng = rand::rngs::OsRng::default();
         let msg = block
             .header
             .signer_signature_hash()
diff --git a/testnet/stacks-node/src/nakamoto_node.rs b/testnet/stacks-node/src/nakamoto_node.rs
index 3584a5d864..cf88877e10 100644
--- a/testnet/stacks-node/src/nakamoto_node.rs
+++ b/testnet/stacks-node/src/nakamoto_node.rs
@@ -21,6 +21,7 @@ use std::thread::JoinHandle;
 use stacks::burnchains::{BurnchainSigner, Txid};
 use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::burn::BlockSnapshot;
+use stacks::chainstate::stacks::Error as ChainstateError;
 use stacks::monitoring;
 use stacks::monitoring::update_active_miners_count_gauge;
 use stacks::net::atlas::AtlasConfig;
@@ -88,6 +89,11 @@ pub enum Error {
     BurnchainSubmissionFailed,
     /// A new parent has been discovered since mining started
     NewParentDiscovered,
+    /// A failure occurred while constructing a VRF Proof
+    BadVrfConstruction,
+    CannotSelfSign,
+    MiningFailure(ChainstateError),
+    SigningError(&'static str),
     // The thread that we tried to send to has closed
     ChannelClosed,
 }
@@ -125,7 +131,10 @@ impl StacksNode {
         let is_miner = runloop.is_miner();
         let burnchain = runloop.get_burnchain();
         let atlas_config = config.atlas.clone();
-        let keychain = Keychain::default(config.node.seed.clone());
+        let mut keychain = Keychain::default(config.node.seed.clone());
+        if let Some(mining_key) = config.miner.mining_key.clone() {
+            keychain.set_nakamoto_sk(mining_key);
+        }
 
         // we can call _open_ here rather than _connect_, since connect is first called in
         //   make_genesis_block
@@ -166,7 +175,8 @@ impl StacksNode {
         };
         globals.set_initial_leader_key_registration_state(leader_key_registration_state);
 
-        let relayer_thread = RelayerThread::new(runloop, local_peer.clone(), relayer);
+        let relayer_thread =
+            RelayerThread::new(runloop, local_peer.clone(), relayer, keychain.clone());
 
         StacksNode::set_monitoring_miner_address(&keychain, &relayer_thread);
 
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index 07efbedaca..b38225f31f 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -132,9 +132,12 @@ impl BlockMinerThread {
         }
 
         // now, actually run this tenure
-        let Some(new_block) = self.mine_block() else {
-            warn!("Failed to mine block");
-            return;
+        let new_block = match self.mine_block() {
+            Ok(x) => x,
+            Err(e) => {
+                warn!("Failed to mine block: {e:?}");
+                return;
+            }
         };
 
         if let Some(self_signer) = self.config.self_signing() {
@@ -196,10 +199,11 @@ impl BlockMinerThread {
         parent_tenure_consensus_hash: ConsensusHash,
         parent_tenure_blocks: u64,
         miner_pkh: Hash160,
-    ) -> Option<StacksTransaction> {
+    ) -> Result<StacksTransaction, NakamotoNodeError> {
         if self.config.self_signing().is_none() {
             // if we're not self-signing, then we can't generate a tenure change tx: it has to come from the signers.
-            return None;
+            warn!("Tried to generate a tenure change transaction, but we aren't self-signing");
+            return Err(NakamotoNodeError::CannotSelfSign);
         }
         let is_mainnet = self.config.is_mainnet();
         let chain_id = self.config.burnchain.chain_id;
@@ -232,7 +236,7 @@ impl BlockMinerThread {
         let mut tx_signer = StacksTransactionSigner::new(&tx);
         self.keychain.sign_as_origin(&mut tx_signer);
 
-        Some(tx_signer.get_tx().unwrap())
+        Ok(tx_signer.get_tx().unwrap())
     }
 
     /// Create a coinbase transaction.
@@ -279,7 +283,7 @@ impl BlockMinerThread {
         &self,
         burn_db: &mut SortitionDB,
         chain_state: &mut StacksChainState,
-    ) -> Option<ParentStacksBlockInfo> {
+    ) -> Result<ParentStacksBlockInfo, NakamotoNodeError> {
         let Some(stacks_tip) =
             NakamotoChainState::get_canonical_block_header(chain_state.db(), burn_db)
                 .expect("FATAL: could not query chain tip")
@@ -296,7 +300,7 @@ impl BlockMinerThread {
                 burnchain_params.first_block_timestamp.into(),
             );
 
-            return Some(ParentStacksBlockInfo {
+            return Ok(ParentStacksBlockInfo {
                 parent_tenure: Some(ParentTenureInfo {
                     parent_tenure_consensus_hash: chain_tip.metadata.consensus_hash,
                     parent_tenure_blocks: 0,
@@ -319,12 +323,12 @@ impl BlockMinerThread {
             &self.parent_tenure_id,
             stacks_tip,
         ) {
-            Ok(parent_info) => Some(parent_info),
+            Ok(parent_info) => Ok(parent_info),
             Err(NakamotoNodeError::BurnchainTipChanged) => {
                 self.globals.counters.bump_missed_tenures();
-                None
+                Err(NakamotoNodeError::BurnchainTipChanged)
             }
-            Err(..) => None,
+            Err(e) => Err(e),
         }
     }
 
@@ -361,7 +365,7 @@ impl BlockMinerThread {
     /// burnchain block-commit transaction.  If we succeed, then return the assembled block data as
     /// well as the microblock private key to use to produce microblocks.
     /// Return None if we couldn't build a block for whatever reason.
-    fn mine_block(&mut self) -> Option<NakamotoBlock> {
+    fn mine_block(&mut self) -> Result<NakamotoBlock, NakamotoNodeError> {
         debug!("block miner thread ID is {:?}", thread::current().id());
         neon_node::fault_injection_long_tenure();
 
@@ -383,18 +387,20 @@ impl BlockMinerThread {
 
         let target_epoch_id =
             SortitionDB::get_stacks_epoch(burn_db.conn(), self.burn_block.block_height + 1)
-                .ok()?
+                .map_err(|_| NakamotoNodeError::SnapshotNotFoundForChainTip)?
                 .expect("FATAL: no epoch defined")
                 .epoch_id;
         let mut parent_block_info = self.load_block_parent_info(&mut burn_db, &mut chain_state)?;
-        let vrf_proof = self.make_vrf_proof()?;
+        let vrf_proof = self
+            .make_vrf_proof()
+            .ok_or_else(|| NakamotoNodeError::BadVrfConstruction)?;
 
         if self.last_mined_blocks.is_empty() {
             if parent_block_info.parent_tenure.is_none() {
                 warn!(
                     "Miner should be starting a new tenure, but failed to load parent tenure info"
                 );
-                return None;
+                return Err(NakamotoNodeError::ParentNotFound);
             }
         }
 
@@ -452,14 +458,20 @@ impl BlockMinerThread {
             Ok(block) => block,
             Err(e) => {
                 error!("Relayer: Failure mining anchored block: {}", e);
-                return None;
+                return Err(NakamotoNodeError::MiningFailure(e));
             }
         };
 
         let mining_key = self.keychain.get_nakamoto_sk();
         let miner_signature = mining_key
-            .sign(block.header.signature_hash().ok()?.as_bytes())
-            .ok()?;
+            .sign(
+                block
+                    .header
+                    .signature_hash()
+                    .map_err(|_| NakamotoNodeError::SigningError("Could not create sighash"))?
+                    .as_bytes(),
+            )
+            .map_err(NakamotoNodeError::SigningError)?;
         block.header.miner_signature = miner_signature;
 
         info!(
@@ -483,10 +495,10 @@ impl BlockMinerThread {
         if cur_burn_chain_tip.consensus_hash != block.header.consensus_hash {
             info!("Miner: Cancel block assembly; burnchain tip has changed");
             self.globals.counters.bump_missed_tenures();
-            return None;
+            return Err(NakamotoNodeError::BurnchainTipChanged);
         }
 
-        Some(block)
+        Ok(block)
     }
 }
 
diff --git a/testnet/stacks-node/src/nakamoto_node/relayer.rs b/testnet/stacks-node/src/nakamoto_node/relayer.rs
index 8c83bb35b9..b4aac584bb 100644
--- a/testnet/stacks-node/src/nakamoto_node/relayer.rs
+++ b/testnet/stacks-node/src/nakamoto_node/relayer.rs
@@ -162,7 +162,12 @@ pub struct RelayerThread {
 impl RelayerThread {
     /// Instantiate relayer thread.
     /// Uses `runloop` to obtain globals, config, and `is_miner`` status
-    pub fn new(runloop: &RunLoop, local_peer: LocalPeer, relayer: Relayer) -> RelayerThread {
+    pub fn new(
+        runloop: &RunLoop,
+        local_peer: LocalPeer,
+        relayer: Relayer,
+        keychain: Keychain,
+    ) -> RelayerThread {
         let config = runloop.config().clone();
         let globals = runloop.get_globals();
         let burn_db_path = config.get_burn_db_file_path();
@@ -178,7 +183,6 @@ impl RelayerThread {
             .connect_mempool_db()
             .expect("Database failure opening mempool");
 
-        let keychain = Keychain::default(config.node.seed.clone());
         let bitcoin_controller = BitcoinRegtestController::new_dummy(config.clone());
 
         RelayerThread {
diff --git a/testnet/stacks-node/src/run_loop/nakamoto.rs b/testnet/stacks-node/src/run_loop/nakamoto.rs
index 83382f869e..f18f236da6 100644
--- a/testnet/stacks-node/src/run_loop/nakamoto.rs
+++ b/testnet/stacks-node/src/run_loop/nakamoto.rs
@@ -392,7 +392,8 @@ impl RunLoop {
             .take()
             .expect("Run loop already started, can only start once after initialization.");
 
-        neon::RunLoop::setup_termination_handler(self.should_keep_running.clone());
+        // setup the termination handler, allow it to error if a prior runloop already set it
+        neon::RunLoop::setup_termination_handler(self.should_keep_running.clone(), true);
         let mut burnchain = neon::RunLoop::instantiate_burnchain_state(
             &self.config,
             self.should_keep_running.clone(),
diff --git a/testnet/stacks-node/src/run_loop/neon.rs b/testnet/stacks-node/src/run_loop/neon.rs
index cffcd1aa10..68e13dc511 100644
--- a/testnet/stacks-node/src/run_loop/neon.rs
+++ b/testnet/stacks-node/src/run_loop/neon.rs
@@ -295,7 +295,7 @@ impl RunLoop {
 
     /// Set up termination handler.  Have a signal set the `should_keep_running` atomic bool to
     /// false.  Panics of called more than once.
-    pub fn setup_termination_handler(keep_running_writer: Arc<AtomicBool>) {
+    pub fn setup_termination_handler(keep_running_writer: Arc<AtomicBool>, allow_err: bool) {
         let install = termination::set_handler(move |sig_id| match sig_id {
             SignalId::Bus => {
                 let msg = "Caught SIGBUS; crashing immediately and dumping core\n";
@@ -313,7 +313,8 @@ impl RunLoop {
 
         if let Err(e) = install {
             // integration tests can do this
-            if cfg!(test) {
+            if cfg!(test) || allow_err {
+                info!("Error setting up signal handler, may have already been set");
             } else {
                 panic!("FATAL: error setting termination handler - {}", e);
             }
@@ -974,7 +975,7 @@ impl RunLoop {
             .take()
             .expect("Run loop already started, can only start once after initialization.");
 
-        Self::setup_termination_handler(self.should_keep_running.clone());
+        Self::setup_termination_handler(self.should_keep_running.clone(), false);
         let mut burnchain = Self::instantiate_burnchain_state(
             &self.config,
             self.should_keep_running.clone(),

From 02c64574834ae87dd441ff8b6826715a04d7f8df Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Wed, 13 Dec 2023 07:58:12 -0600
Subject: [PATCH 0209/1166] hashmap -> hashset

---
 testnet/stacks-node/src/nakamoto_node.rs         | 4 ++--
 testnet/stacks-node/src/nakamoto_node/relayer.rs | 9 ++++-----
 2 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/testnet/stacks-node/src/nakamoto_node.rs b/testnet/stacks-node/src/nakamoto_node.rs
index cf88877e10..ddcbc197f7 100644
--- a/testnet/stacks-node/src/nakamoto_node.rs
+++ b/testnet/stacks-node/src/nakamoto_node.rs
@@ -13,7 +13,7 @@
 //
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
-use std::collections::HashMap;
+use std::collections::HashSet;
 use std::sync::mpsc::Receiver;
 use std::thread;
 use std::thread::JoinHandle;
@@ -48,7 +48,7 @@ const VRF_MOCK_MINER_KEY: u64 = 1;
 
 pub const BLOCK_PROCESSOR_STACK_SIZE: usize = 32 * 1024 * 1024; // 32 MB
 
-pub type BlockCommits = HashMap<Txid, ()>;
+pub type BlockCommits = HashSet<Txid>;
 
 /// Node implementation for both miners and followers.
 /// This struct is used to set up the node proper and launch the p2p thread and relayer thread.
diff --git a/testnet/stacks-node/src/nakamoto_node/relayer.rs b/testnet/stacks-node/src/nakamoto_node/relayer.rs
index b4aac584bb..f10a327b60 100644
--- a/testnet/stacks-node/src/nakamoto_node/relayer.rs
+++ b/testnet/stacks-node/src/nakamoto_node/relayer.rs
@@ -14,7 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 use core::fmt;
-use std::collections::HashMap;
+use std::collections::HashSet;
 use std::sync::mpsc::{Receiver, RecvTimeoutError};
 use std::thread::JoinHandle;
 use std::time::{Duration, Instant};
@@ -194,7 +194,7 @@ impl RelayerThread {
             keychain,
             burnchain: runloop.get_burnchain(),
             last_vrf_key_burn_height: None,
-            last_commits: HashMap::new(),
+            last_commits: HashSet::new(),
             bitcoin_controller,
             event_dispatcher: runloop.get_event_dispatcher(),
             local_peer,
@@ -309,8 +309,7 @@ impl RelayerThread {
 
         self.globals.set_last_sortition(sn.clone());
 
-        let won_sortition =
-            sn.sortition && self.last_commits.remove(&sn.winning_block_txid).is_some();
+        let won_sortition = sn.sortition && self.last_commits.remove(&sn.winning_block_txid);
 
         info!(
             "Relayer: Process sortition";
@@ -692,7 +691,7 @@ impl RelayerThread {
             "txid" => %txid,
         );
 
-        self.last_commits.insert(txid, ());
+        self.last_commits.insert(txid);
         self.last_committed = Some((
             last_committed_at,
             StacksBlockId::new(&tenure_start_ch, &tenure_start_bh),

From 81c163f954db6ed6ec5ab1f0b56a93ecae3c0469 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Wed, 13 Dec 2023 10:17:29 -0500
Subject: [PATCH 0210/1166] chore: put set-aggregate-public-key call into
 NakamotoChainState::setup_block() and call it on every block

---
 stackslib/src/chainstate/nakamoto/miner.rs |   1 +
 stackslib/src/chainstate/nakamoto/mod.rs   | 155 ++++++++++++---------
 2 files changed, 90 insertions(+), 66 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/miner.rs b/stackslib/src/chainstate/nakamoto/miner.rs
index 5b511f6aa2..2a0799ae71 100644
--- a/stackslib/src/chainstate/nakamoto/miner.rs
+++ b/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,
diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index 076384d1b7..1301486eac 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -1754,24 +1754,28 @@ impl NakamotoChainState {
         sortdb: &SortitionDB,
         sort_handle: &SortitionHandleConn,
         chainstate: &mut StacksChainState,
-        for_block_height: u64,
+        for_burn_block_height: u64,
         at_block_id: &StacksBlockId,
     ) -> Result<Point, ChainstateError> {
         // Get the current reward cycle
         let Some(reward_cycle) = sort_handle
             .context
             .pox_constants
-            .block_height_to_reward_cycle(sort_handle.context.first_block_height, for_block_height)
+            .block_height_to_reward_cycle(
+                sort_handle.context.first_block_height,
+                for_burn_block_height,
+            )
         else {
             // This should be unreachable, but we'll return an error just in case.
             let msg = format!(
-                "BUG: Failed to determine reward cycle of block height: {}.",
-                for_block_height
+                "BUG: Failed to determine reward cycle of burn block height: {}.",
+                for_burn_block_height
             );
             warn!("{msg}");
             return Err(ChainstateError::InvalidStacksBlock(msg));
         };
 
+        debug!("get-aggregate-public-key {} {}", at_block_id, reward_cycle);
         chainstate
             .get_aggregate_public_key_pox_4(sortdb, at_block_id, reward_cycle)?
             .ok_or_else(|| {
@@ -2342,6 +2346,7 @@ impl NakamotoChainState {
         chainstate_tx: &'b mut ChainstateTx,
         clarity_instance: &'a mut ClarityInstance,
         sortition_dbconn: &'b dyn SortitionDBRef,
+        first_block_height: u64,
         pox_constants: &PoxConstants,
         parent_consensus_hash: ConsensusHash,
         parent_header_hash: BlockHeaderHash,
@@ -2488,6 +2493,16 @@ impl NakamotoChainState {
             );
         }
 
+        if !clarity_tx.config.mainnet {
+            Self::set_aggregate_public_key(
+                &mut clarity_tx,
+                first_block_height,
+                pox_constants,
+                parent_burn_height.into(),
+                burn_header_height.into(),
+            );
+        }
+
         debug!(
             "Setup block: completed setup";
             "parent_consensus_hash" => %parent_consensus_hash,
@@ -2537,8 +2552,9 @@ impl NakamotoChainState {
         Ok(lockup_events)
     }
 
-    /// (TESTNET ONLY) Set the aggregate public key for verifying stacker signatures.
-    /// Do not call in mainnet
+    /// Set the aggregate public key for verifying stacker signatures.
+    /// TODO: rely on signer voting instead
+    /// DO NOT USE IN MAINNET
     pub(crate) fn set_aggregate_public_key(
         clarity_tx: &mut ClarityTx,
         first_block_height: u64,
@@ -2548,6 +2564,7 @@ impl NakamotoChainState {
     ) {
         let mainnet = clarity_tx.config.mainnet;
         let chain_id = clarity_tx.config.chain_id;
+        assert!(!mainnet);
 
         let parent_reward_cycle = pox_constants
             .block_height_to_reward_cycle(
@@ -2565,62 +2582,71 @@ impl NakamotoChainState {
                     .expect("Burn block height exceeded u32"),
             )
             .expect("FATAL: block height occurs before first block height");
-        if parent_reward_cycle != my_reward_cycle {
-            // execute `set-aggregate-public-key` using `clarity-tx`
-            let aggregate_public_key = clarity_tx
-                .connection()
-                .with_readonly_clarity_env(
-                    false,
-                    chain_id,
-                    ClarityVersion::Clarity2,
-                    StacksAddress::burn_address(mainnet).into(),
-                    None,
-                    LimitedCostTracker::Free,
-                    |vm_env| {
-                        vm_env.execute_contract_allow_private(
-                            &boot_code_id(POX_4_NAME, mainnet),
-                            "get-aggregate-public-key",
-                            &vec![SymbolicExpression::atom_value(Value::UInt(u128::from(
-                                parent_reward_cycle,
-                            )))],
-                            true,
-                        )
-                    },
-                )
-                .ok()
-                .map(|agg_key_value| {
-                    Value::buff_from(agg_key_value.expect_buff(33))
-                        .expect("failed to reconstruct buffer")
-                })
-                .expect("get-aggregate-public-key returned None");
-
-            clarity_tx.connection().as_transaction(|tx| {
-                tx.with_abort_callback(
-                    |vm_env| {
-                        vm_env.execute_in_env(
-                            StacksAddress::burn_address(mainnet).into(),
-                            None,
-                            None,
-                            |vm_env| {
-                                vm_env.execute_contract_allow_private(
-                                    &boot_code_id(POX_4_NAME, mainnet),
-                                    "set-aggregate-public-key",
-                                    &vec![
-                                        SymbolicExpression::atom_value(Value::UInt(
-                                            u128::from(my_reward_cycle),
-                                        )),
-                                        SymbolicExpression::atom_value(aggregate_public_key),
-                                    ],
-                                    false,
-                                )
-                            },
-                        )
-                    },
-                    |_, _| false,
-                )
-                .expect("FATAL: failed to set aggregate public key")
-            });
-        }
+
+        // carry forward the aggregate public key in the past reward cycle to the current
+        // reward cycle.
+        // TODO: replace with signer voting
+        debug!(
+            "Setting aggregate public key in reward cycle {}",
+            my_reward_cycle
+        );
+        // execute `set-aggregate-public-key` using `clarity-tx`
+        let aggregate_public_key = clarity_tx
+            .connection()
+            .with_readonly_clarity_env(
+                mainnet,
+                chain_id,
+                ClarityVersion::Clarity2,
+                StacksAddress::burn_address(mainnet).into(),
+                None,
+                LimitedCostTracker::Free,
+                |vm_env| {
+                    vm_env.execute_contract_allow_private(
+                        &boot_code_id(POX_4_NAME, mainnet),
+                        "get-aggregate-public-key",
+                        &vec![SymbolicExpression::atom_value(Value::UInt(u128::from(
+                            parent_reward_cycle,
+                        )))],
+                        true,
+                    )
+                },
+            )
+            .ok()
+            .map(|agg_key_value| {
+                let agg_key_opt = agg_key_value.expect_optional();
+                let agg_key_buff =
+                    agg_key_opt.expect("FATAL: aggregate public key not set in boot code");
+                Value::buff_from(agg_key_buff.expect_buff(33))
+                    .expect("failed to reconstruct buffer")
+            })
+            .expect("get-aggregate-public-key returned None");
+
+        clarity_tx.connection().as_transaction(|tx| {
+            tx.with_abort_callback(
+                |vm_env| {
+                    vm_env.execute_in_env(
+                        StacksAddress::burn_address(mainnet).into(),
+                        None,
+                        None,
+                        |vm_env| {
+                            vm_env.execute_contract_allow_private(
+                                &boot_code_id(POX_4_NAME, mainnet),
+                                "set-aggregate-public-key",
+                                &vec![
+                                    SymbolicExpression::atom_value(Value::UInt(u128::from(
+                                        my_reward_cycle,
+                                    ))),
+                                    SymbolicExpression::atom_value(aggregate_public_key),
+                                ],
+                                false,
+                            )
+                        },
+                    )
+                },
+                |_, _| false,
+            )
+            .expect("FATAL: failed to set aggregate public key")
+        });
     }
 
     /// Append a Nakamoto Stacks block to the Stacks chain state.
@@ -2792,6 +2818,7 @@ impl NakamotoChainState {
             chainstate_tx,
             clarity_instance,
             burn_dbconn,
+            first_block_height,
             pox_constants,
             parent_ch,
             parent_block_hash,
@@ -2806,10 +2833,6 @@ impl NakamotoChainState {
             tenure_extend,
         )?;
 
-        if !block.is_first_mined() && !clarity_tx.config.mainnet {
-            Self::set_aggregate_public_key(&mut clarity_tx, first_block_height, pox_constants, parent_chain_tip.burn_header_height.into(), burn_header_height);
-        }
-
         let starting_cost = clarity_tx.cost_so_far();
 
         debug!(

From 4ce8f729153b7fced4814d806458a6e7b905fe1e Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Wed, 13 Dec 2023 10:18:06 -0500
Subject: [PATCH 0211/1166] fix: reward cycle prepare phase length of 3

---
 testnet/stacks-node/src/config.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index 8b1f7a8578..5ab9a46e6a 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -316,7 +316,7 @@ impl ConfigFile {
             password: Some("blockstacksystem".into()),
             magic_bytes: Some("M3".into()),
             epochs: Some(epochs),
-            pox_prepare_length: Some(2),
+            pox_prepare_length: Some(3),
             pox_reward_length: Some(36),
             ..BurnchainConfigFile::default()
         };

From eb043c673e1fccadaa6b0f9c7f6334a940dd19bd Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Wed, 13 Dec 2023 10:18:26 -0500
Subject: [PATCH 0212/1166] fix: get aggregate public key from sortition tip
 parent height

---
 testnet/stacks-node/src/mockamoto.rs | 17 +++++++++++------
 1 file changed, 11 insertions(+), 6 deletions(-)

diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index e414916eca..495120a4c0 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -828,7 +828,7 @@ impl MockamotoNode {
         let mut coinbase_tx_signer = StacksTransactionSigner::new(&coinbase_tx);
         coinbase_tx_signer.sign_origin(&self.miner_key).unwrap();
         let coinbase_tx = coinbase_tx_signer.get_tx().unwrap();
-        
+
         let miner_pk = Secp256k1PublicKey::from_private(&self.miner_key);
         let miner_pk_hash = Hash160::from_node_public_key(&miner_pk);
 
@@ -855,6 +855,12 @@ impl MockamotoNode {
             TransactionAuth::from_p2pkh(&self.miner_key).unwrap(),
             tenure_change_tx_payload,
         );
+        tenure_tx.chain_id = chain_id;
+        tenure_tx.set_origin_nonce(miner_nonce);
+        let mut tenure_tx_signer = StacksTransactionSigner::new(&tenure_tx);
+        tenure_tx_signer.sign_origin(&self.miner_key).unwrap();
+        let tenure_tx = tenure_tx_signer.get_tx().unwrap();
+
         let pox_address = PoxAddress::Standard(
             StacksAddress::burn_address(false),
             Some(AddressHashMode::SerializeP2PKH),
@@ -905,6 +911,7 @@ impl MockamotoNode {
             &mut chainstate_tx,
             clarity_instance,
             &sortdb_handle,
+            self.sortdb.first_block_height,
             &self.sortdb.pox_constants,
             chain_tip_ch.clone(),
             chain_tip_bh.clone(),
@@ -918,7 +925,7 @@ impl MockamotoNode {
             parent_chain_length + 1,
             false,
         )?;
-        
+
         let txs = vec![tenure_tx, coinbase_tx, stacks_stx_tx];
 
         let _ = match StacksChainState::process_block_transactions(
@@ -1021,16 +1028,15 @@ impl MockamotoNode {
                 &block.header.consensus_hash,
             )?
             .ok_or(ChainstateError::DBError(DBError::NotFoundError))?;
-            // TODO: https://github.com/stacks-network/stacks-core/issues/4109
-            // Update this to retrieve the last block in the last reward cycle rather than chain tip
             let aggregate_key_block_header =
                 NakamotoChainState::get_canonical_block_header(self.chainstate.db(), &self.sortdb)?
                     .unwrap();
+
             let aggregate_public_key = NakamotoChainState::get_aggregate_public_key(
                 &self.sortdb,
                 &sortition_handle,
                 &mut self.chainstate,
-                block_sn.block_height,
+                block_sn.block_height.saturating_sub(1),
                 &aggregate_key_block_header.index_block_hash(),
             )?;
             aggregate_public_key
@@ -1048,4 +1054,3 @@ impl MockamotoNode {
         Ok(chain_length)
     }
 }
-

From bc5f9f0930001f248dcbf334eb93244ba667fd30 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Wed, 13 Dec 2023 10:18:58 -0500
Subject: [PATCH 0213/1166] chore: delete old test -- we can't set the
 aggregate public key via a tx

---
 testnet/stacks-node/src/mockamoto/tests.rs | 170 ---------------------
 1 file changed, 170 deletions(-)

diff --git a/testnet/stacks-node/src/mockamoto/tests.rs b/testnet/stacks-node/src/mockamoto/tests.rs
index 7a7f03365f..7282271e19 100644
--- a/testnet/stacks-node/src/mockamoto/tests.rs
+++ b/testnet/stacks-node/src/mockamoto/tests.rs
@@ -135,176 +135,6 @@ fn observe_100_blocks() {
     );
 }
 
-#[test]
-fn observe_set_aggregate_tx() {
-    let mut conf = Config::from_config_file(ConfigFile::mockamoto()).unwrap();
-    conf.node.mockamoto_time_ms = 10;
-
-    let submitter_sk = StacksPrivateKey::from_seed(&[1]);
-    let submitter_addr = to_addr(&submitter_sk);
-    conf.add_initial_balance(submitter_addr.to_string(), 1_000);
-
-    test_observer::spawn();
-    let observer_port = test_observer::EVENT_OBSERVER_PORT;
-    conf.events_observers.insert(EventObserverConfig {
-        endpoint: format!("localhost:{observer_port}"),
-        events_keys: vec![EventKeyType::AnyEvent],
-    });
-
-    let mut mockamoto = MockamotoNode::new(&conf).unwrap();
-    // Get the aggregate public key of the original reward cycle to compare against
-    let orig_key = mockamoto.self_signer.aggregate_public_key;
-
-    let globals = mockamoto.globals.clone();
-
-    let mut mempool = PeerThread::connect_mempool_db(&conf);
-    let (mut chainstate, _) = StacksChainState::open(
-        conf.is_mainnet(),
-        conf.burnchain.chain_id,
-        &conf.get_chainstate_path_str(),
-        None,
-    )
-    .unwrap();
-    let burnchain = conf.get_burnchain();
-    let sortdb = burnchain.open_sortition_db(true).unwrap();
-    let sortition_tip = SortitionDB::get_canonical_burn_chain_tip(mockamoto.sortdb.conn()).unwrap();
-
-    let start = Instant::now();
-    // Get the reward cycle of the sortition tip
-    let reward_cycle = mockamoto
-        .sortdb
-        .pox_constants
-        .block_height_to_reward_cycle(
-            mockamoto.sortdb.first_block_height,
-            sortition_tip.block_height,
-        )
-        .expect(
-            format!(
-                "Failed to determine reward cycle of block height: {}",
-                sortition_tip.block_height
-            )
-            .as_str(),
-        );
-
-    let node_thread = thread::Builder::new()
-        .name("mockamoto-main".into())
-        .spawn(move || {
-            mockamoto.run();
-            let aggregate_key_block_header = NakamotoChainState::get_canonical_block_header(
-                mockamoto.chainstate.db(),
-                &mockamoto.sortdb,
-            )
-            .unwrap()
-            .unwrap();
-            // Get the aggregate public key of the original reward cycle
-            let orig_aggregate_key = mockamoto
-                .chainstate
-                .get_aggregate_public_key_pox_4(
-                    &mockamoto.sortdb,
-                    &aggregate_key_block_header.index_block_hash(),
-                    reward_cycle,
-                )
-                .unwrap();
-            // Get the aggregate public key of the next reward cycle that we manually overwrote
-            let new_aggregate_key = mockamoto
-                .chainstate
-                .get_aggregate_public_key_pox_4(
-                    &mockamoto.sortdb,
-                    &aggregate_key_block_header.index_block_hash(),
-                    reward_cycle + 1,
-                )
-                .unwrap();
-            (orig_aggregate_key, new_aggregate_key)
-        })
-        .expect("FATAL: failed to start mockamoto main thread");
-
-    // Create a "set-aggregate-public-key" tx to verify it sets correctly
-    let mut rng = OsRng::default();
-    let x = Scalar::random(&mut rng);
-    let random_key = Point::from(x);
-
-    let tx_fee = 200;
-    let aggregate_public_key = Value::buff_from(random_key.compress().data.to_vec())
-        .expect("Failed to serialize aggregate public key");
-    let aggregate_tx = make_contract_call(
-        &submitter_sk,
-        0,
-        tx_fee,
-        &boot_code_addr(false),
-        POX_4_NAME,
-        "set-aggregate-public-key",
-        &[
-            Value::UInt(u128::from(reward_cycle + 1)),
-            aggregate_public_key,
-        ],
-    );
-    let aggregate_tx_hex = format!("0x{}", to_hex(&aggregate_tx));
-
-    // complete within 5 seconds or abort (we are only observing one block)
-    let completed = loop {
-        if Instant::now().duration_since(start) > Duration::from_secs(5) {
-            break false;
-        }
-        let latest_block = test_observer::get_blocks().pop();
-        thread::sleep(Duration::from_secs(1));
-        let Some(ref latest_block) = latest_block else {
-            info!("No block observed yet!");
-            continue;
-        };
-        let stacks_block_height = latest_block.get("block_height").unwrap().as_u64().unwrap();
-        info!("Block height observed: {stacks_block_height}");
-
-        // Submit the aggregate tx for processing to update the aggregate public key
-        let tip = NakamotoChainState::get_canonical_block_header(chainstate.db(), &sortdb)
-            .unwrap()
-            .unwrap();
-        mempool
-            .submit_raw(
-                &mut chainstate,
-                &sortdb,
-                &tip.consensus_hash,
-                &tip.anchored_header.block_hash(),
-                aggregate_tx.clone(),
-                &ExecutionCost::max_value(),
-                &StacksEpochId::Epoch30,
-            )
-            .unwrap();
-        break true;
-    };
-
-    globals.signal_stop();
-
-    let (orig_aggregate_key, new_aggregate_key) = node_thread
-        .join()
-        .expect("Failed to join node thread to exit");
-
-    let aggregate_tx_included = test_observer::get_blocks()
-        .into_iter()
-        .find(|block_json| {
-            block_json["transactions"]
-                .as_array()
-                .unwrap()
-                .iter()
-                .find(|tx_json| tx_json["raw_tx"].as_str() == Some(&aggregate_tx_hex))
-                .is_some()
-        })
-        .is_some();
-
-    assert!(
-        aggregate_tx_included,
-        "Mockamoto node failed to include the aggregate tx"
-    );
-
-    assert!(
-        completed,
-        "Mockamoto node failed to produce and announce its block before timeout"
-    );
-
-    // Did we set and retrieve the aggregate key correctly?
-    assert_eq!(orig_aggregate_key.unwrap(), orig_key);
-    assert_eq!(new_aggregate_key.unwrap(), random_key);
-}
-
 #[test]
 fn mempool_rpc_submit() {
     let mut conf = Config::from_config_file(ConfigFile::mockamoto()).unwrap();

From 21aa307f7d2f7158591970d1126dd3adf0dabed7 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Wed, 13 Dec 2023 10:19:17 -0500
Subject: [PATCH 0214/1166] chore: load aggregate public key from clarity

---
 .../stacks-node/src/nakamoto_node/miner.rs    | 25 ++++++++++++++++++-
 1 file changed, 24 insertions(+), 1 deletion(-)

diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index 07efbedaca..592de7817d 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -30,6 +30,7 @@ use stacks::chainstate::stacks::{
     TransactionPayload, TransactionVersion,
 };
 use stacks::core::FIRST_BURNCHAIN_CONSENSUS_HASH;
+use stacks::util_lib::db::Error as DBError;
 use stacks_common::types::chainstate::{StacksAddress, StacksBlockId};
 use stacks_common::types::{PrivateKey, StacksEpochId};
 use stacks_common::util::hash::Hash160;
@@ -167,13 +168,35 @@ impl BlockMinerThread {
         )
         .expect("FATAL: could not open sortition DB");
         let mut sortition_handle = sort_db.index_handle_at_tip();
+        let aggregate_public_key = if block.header.chain_length <= 1 {
+            signer.aggregate_public_key.clone()
+        } else {
+            let block_sn = SortitionDB::get_block_snapshot_consensus(
+                sortition_handle.conn(),
+                &block.header.consensus_hash,
+            )?
+            .ok_or(ChainstateError::DBError(DBError::NotFoundError))?;
+            let aggregate_key_block_header =
+                NakamotoChainState::get_canonical_block_header(chain_state.db(), &sort_db)?
+                    .unwrap();
+
+            let aggregate_public_key = NakamotoChainState::get_aggregate_public_key(
+                &sort_db,
+                &sortition_handle,
+                &mut chain_state,
+                block_sn.block_height.saturating_sub(1),
+                &aggregate_key_block_header.index_block_hash(),
+            )?;
+            aggregate_public_key
+        };
+
         let staging_tx = chain_state.staging_db_tx_begin()?;
         NakamotoChainState::accept_block(
             &chainstate_config,
             block,
             &mut sortition_handle,
             &staging_tx,
-            &signer.aggregate_public_key,
+            &aggregate_public_key,
         )?;
         staging_tx.commit()?;
         Ok(())

From a4c2a7d128a1719e4f018df145f881841699a04c Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Wed, 13 Dec 2023 10:19:29 -0500
Subject: [PATCH 0215/1166] chore: set aggregate public key smart contract on
 bootup

---
 testnet/stacks-node/src/run_loop/nakamoto.rs | 53 ++++++++++++++++++--
 1 file changed, 48 insertions(+), 5 deletions(-)

diff --git a/testnet/stacks-node/src/run_loop/nakamoto.rs b/testnet/stacks-node/src/run_loop/nakamoto.rs
index 83382f869e..eb8bbdc501 100644
--- a/testnet/stacks-node/src/run_loop/nakamoto.rs
+++ b/testnet/stacks-node/src/run_loop/nakamoto.rs
@@ -19,6 +19,10 @@ use std::sync::{Arc, Mutex};
 use std::thread::JoinHandle;
 use std::{cmp, thread};
 
+use clarity::boot_util::boot_code_id;
+use clarity::vm::ast::ASTRules;
+use clarity::vm::clarity::TransactionConnection;
+use clarity::vm::ClarityVersion;
 use stacks::burnchains::bitcoin::address::{BitcoinAddress, LegacyBitcoinAddressType};
 use stacks::burnchains::Burnchain;
 use stacks::chainstate::burn::db::sortdb::SortitionDB;
@@ -27,12 +31,15 @@ use stacks::chainstate::coordinator::comm::{CoordinatorChannels, CoordinatorRece
 use stacks::chainstate::coordinator::{
     ChainsCoordinator, ChainsCoordinatorConfig, CoordinatorCommunication,
 };
-use stacks::chainstate::stacks::db::{ChainStateBootData, StacksChainState};
+use stacks::chainstate::stacks::boot::{
+    BOOT_TEST_POX_4_AGG_KEY_CONTRACT, BOOT_TEST_POX_4_AGG_KEY_FNAME,
+};
+use stacks::chainstate::stacks::db::{ChainStateBootData, ClarityTx, StacksChainState};
 use stacks::chainstate::stacks::miner::{signal_mining_blocked, signal_mining_ready, MinerStatus};
 use stacks::core::StacksEpochId;
 use stacks::net::atlas::{AtlasConfig, AtlasDB, Attachment};
 use stacks_common::types::PublicKey;
-use stacks_common::util::hash::Hash160;
+use stacks_common::util::hash::{to_hex, Hash160};
 use stx_genesis::GenesisData;
 
 use crate::burnchains::make_bitcoin_indexer;
@@ -218,13 +225,49 @@ impl RunLoop {
             .map(|e| (e.address.clone(), e.amount))
             .collect();
 
-        // TODO (nakamoto-neon): check if we're trying to setup a self-signing network
-        //  and set the right genesis data
+        let agg_pubkey_boot_callback = if let Some(self_signer) = self.config.self_signing() {
+            let agg_pub_key = to_hex(&self_signer.aggregate_public_key.compress().data);
+            info!("Mockamoto node setting agg public key"; "agg_pub_key" => &agg_pub_key);
+            let callback = Box::new(move |clarity_tx: &mut ClarityTx| {
+                let contract_content = format!(
+                    "(define-read-only ({}) 0x{})",
+                    BOOT_TEST_POX_4_AGG_KEY_FNAME, agg_pub_key
+                );
+                // NOTE: this defaults to a testnet address to prevent it from ever working on
+                // mainnet
+                let contract_id = boot_code_id(BOOT_TEST_POX_4_AGG_KEY_CONTRACT, false);
+                clarity_tx.connection().as_transaction(|clarity| {
+                    let (ast, analysis) = clarity
+                        .analyze_smart_contract(
+                            &contract_id,
+                            ClarityVersion::Clarity2,
+                            &contract_content,
+                            ASTRules::PrecheckSize,
+                        )
+                        .unwrap();
+                    clarity
+                        .initialize_smart_contract(
+                            &contract_id,
+                            ClarityVersion::Clarity2,
+                            &ast,
+                            &contract_content,
+                            None,
+                            |_, _| false,
+                        )
+                        .unwrap();
+                    clarity.save_analysis(&contract_id, &analysis).unwrap();
+                })
+            }) as Box<dyn FnOnce(&mut ClarityTx)>;
+            Some(callback)
+        } else {
+            warn!("Self-signing is not supported yet");
+            None
+        };
 
         // instantiate chainstate
         let mut boot_data = ChainStateBootData {
             initial_balances,
-            post_flight_callback: None,
+            post_flight_callback: agg_pubkey_boot_callback,
             first_burnchain_block_hash: burnchain_config.first_block_hash,
             first_burnchain_block_height: burnchain_config.first_block_height as u32,
             first_burnchain_block_timestamp: burnchain_config.first_block_timestamp,

From 52a5cd353cbe191f0c002a6a4e3c7da0b35dce6a Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Wed, 13 Dec 2023 10:29:41 -0600
Subject: [PATCH 0216/1166] fix: mockamoto config must pass config assertions

---
 .../burnchains/bitcoin_regtest_controller.rs  |  4 ----
 testnet/stacks-node/src/config.rs             |  2 +-
 testnet/stacks-node/src/mockamoto/tests.rs    | 21 +++++++++++++++----
 .../src/tests/neon_integrations.rs            | 18 ++++++++++------
 4 files changed, 30 insertions(+), 15 deletions(-)

diff --git a/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs b/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
index 0ed1bb0e03..7d1a2aec08 100644
--- a/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
+++ b/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
@@ -8,8 +8,6 @@ use async_h1::client;
 use async_std::io::ReadExt;
 use async_std::net::TcpStream;
 use base64::encode;
-#[cfg(test)]
-use clarity::vm::types::PrincipalData;
 use http_types::{Method, Request, Url};
 use serde::Serialize;
 use serde_json::json;
@@ -52,8 +50,6 @@ use stacks_common::deps_common::bitcoin::network::serialize::deserialize as btc_
 use stacks_common::deps_common::bitcoin::network::serialize::RawEncoder;
 use stacks_common::deps_common::bitcoin::util::hash::Sha256dHash;
 use stacks_common::types::chainstate::BurnchainHeaderHash;
-#[cfg(test)]
-use stacks_common::types::chainstate::StacksAddress;
 use stacks_common::util::hash::{hex_bytes, Hash160};
 use stacks_common::util::secp256k1::Secp256k1PublicKey;
 use stacks_common::util::sleep_ms;
diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index 9018511b5a..87c9169676 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -316,7 +316,7 @@ impl ConfigFile {
             password: Some("blockstacksystem".into()),
             magic_bytes: Some("M3".into()),
             epochs: Some(epochs),
-            pox_prepare_length: Some(2),
+            pox_prepare_length: Some(3),
             pox_reward_length: Some(36),
             ..BurnchainConfigFile::default()
         };
diff --git a/testnet/stacks-node/src/mockamoto/tests.rs b/testnet/stacks-node/src/mockamoto/tests.rs
index b7914dcba8..7d7f65f852 100644
--- a/testnet/stacks-node/src/mockamoto/tests.rs
+++ b/testnet/stacks-node/src/mockamoto/tests.rs
@@ -6,6 +6,7 @@ use stacks::chainstate::nakamoto::NakamotoChainState;
 use stacks::chainstate::stacks::db::StacksChainState;
 use stacks_common::types::chainstate::{StacksAddress, StacksPrivateKey};
 use stacks_common::types::StacksEpochId;
+use stacks_common::util::get_epoch_time_secs;
 use stacks_common::util::hash::to_hex;
 
 use super::MockamotoNode;
@@ -18,6 +19,12 @@ use crate::{Config, ConfigFile};
 #[test]
 fn observe_100_blocks() {
     let mut conf = Config::from_config_file(ConfigFile::mockamoto()).unwrap();
+    conf.node.working_dir = format!(
+        "/tmp/stacks-node-tests/mock_observe_100_blocks-{}",
+        get_epoch_time_secs()
+    );
+    conf.node.rpc_bind = "127.0.0.1:19343".into();
+    conf.node.p2p_bind = "127.0.0.1:19344".into();
     conf.node.mockamoto_time_ms = 10;
 
     let submitter_sk = StacksPrivateKey::from_seed(&[1]);
@@ -25,8 +32,8 @@ fn observe_100_blocks() {
     conf.add_initial_balance(submitter_addr.to_string(), 1_000_000);
     let recipient_addr = StacksAddress::burn_address(false).into();
 
-    test_observer::spawn();
-    let observer_port = test_observer::EVENT_OBSERVER_PORT;
+    let observer_port = 19300;
+    test_observer::spawn_at(observer_port);
     conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{observer_port}"),
         events_keys: vec![EventKeyType::AnyEvent],
@@ -129,6 +136,12 @@ fn observe_100_blocks() {
 #[test]
 fn mempool_rpc_submit() {
     let mut conf = Config::from_config_file(ConfigFile::mockamoto()).unwrap();
+    conf.node.working_dir = format!(
+        "/tmp/stacks-node-tests/mempool_rpc_submit-{}",
+        get_epoch_time_secs()
+    );
+    conf.node.rpc_bind = "127.0.0.1:19743".into();
+    conf.node.p2p_bind = "127.0.0.1:19744".into();
     conf.node.mockamoto_time_ms = 10;
 
     let submitter_sk = StacksPrivateKey::from_seed(&[1]);
@@ -136,8 +149,8 @@ fn mempool_rpc_submit() {
     conf.add_initial_balance(submitter_addr.to_string(), 1_000);
     let recipient_addr = StacksAddress::burn_address(false).into();
 
-    test_observer::spawn();
-    let observer_port = test_observer::EVENT_OBSERVER_PORT;
+    let observer_port = 19800;
+    test_observer::spawn_at(observer_port);
     conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{observer_port}"),
         events_keys: vec![EventKeyType::AnyEvent],
diff --git a/testnet/stacks-node/src/tests/neon_integrations.rs b/testnet/stacks-node/src/tests/neon_integrations.rs
index 455e414208..8915e53020 100644
--- a/testnet/stacks-node/src/tests/neon_integrations.rs
+++ b/testnet/stacks-node/src/tests/neon_integrations.rs
@@ -9,7 +9,7 @@ use std::{cmp, env, fs, thread};
 use clarity::vm::ast::stack_depth_checker::AST_CALL_STACK_DEPTH_BUFFER;
 use clarity::vm::ast::ASTRules;
 use clarity::vm::costs::ExecutionCost;
-use clarity::vm::types::{PrincipalData, QualifiedContractIdentifier, StandardPrincipalData};
+use clarity::vm::types::PrincipalData;
 use clarity::vm::{ClarityName, ClarityVersion, ContractName, Value, MAX_CALL_STACK_DEPTH};
 use rand::Rng;
 use rusqlite::types::ToSql;
@@ -24,7 +24,6 @@ use stacks::chainstate::burn::operations::{
 };
 use stacks::chainstate::burn::ConsensusHash;
 use stacks::chainstate::coordinator::comm::CoordinatorChannels;
-use stacks::chainstate::stacks::address::PoxAddress;
 use stacks::chainstate::stacks::db::StacksChainState;
 use stacks::chainstate::stacks::miner::{
     signal_mining_blocked, signal_mining_ready, TransactionErrorEvent, TransactionEvent,
@@ -55,7 +54,6 @@ use stacks::net::atlas::{
 };
 use stacks::util_lib::boot::boot_code_id;
 use stacks::util_lib::db::{query_row_columns, query_rows, u64_to_sql};
-use stacks_common::address::C32_ADDRESS_VERSION_TESTNET_SINGLESIG;
 use stacks_common::codec::StacksMessageCodec;
 use stacks_common::types::chainstate::{
     BlockHeaderHash, BurnchainHeaderHash, StacksAddress, StacksBlockId,
@@ -403,7 +401,7 @@ pub mod test_observer {
     }
 
     /// each path here should correspond to one of the paths listed in `event_dispatcher.rs`
-    async fn serve() {
+    async fn serve(port: u16) {
         let new_blocks = warp::path!("new_block")
             .and(warp::post())
             .and(warp::body::json())
@@ -458,7 +456,7 @@ pub mod test_observer {
                 .or(mined_nakamoto_blocks)
                 .or(new_stackerdb_chunks),
         )
-        .run(([127, 0, 0, 1], EVENT_OBSERVER_PORT))
+        .run(([127, 0, 0, 1], port))
         .await
     }
 
@@ -466,7 +464,15 @@ pub mod test_observer {
         clear();
         thread::spawn(|| {
             let rt = tokio::runtime::Runtime::new().expect("Failed to initialize tokio");
-            rt.block_on(serve());
+            rt.block_on(serve(EVENT_OBSERVER_PORT));
+        });
+    }
+
+    pub fn spawn_at(port: u16) {
+        clear();
+        thread::spawn(move || {
+            let rt = tokio::runtime::Runtime::new().expect("Failed to initialize tokio");
+            rt.block_on(serve(port));
         });
     }
 

From e26c1fe4d799f9c031a3203cb9edd8cc8714098e Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Wed, 13 Dec 2023 10:36:13 -0600
Subject: [PATCH 0217/1166] ci: add
 tests::nakamoto_integrations::simple_neon_integration to the CI

---
 .github/workflows/epoch-tests.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/workflows/epoch-tests.yml b/.github/workflows/epoch-tests.yml
index a50e0d344d..eabd635246 100644
--- a/.github/workflows/epoch-tests.yml
+++ b/.github/workflows/epoch-tests.yml
@@ -54,6 +54,7 @@ jobs:
           - tests::epoch_23::trait_invocation_behavior
           - tests::epoch_24::fix_to_pox_contract
           - tests::epoch_24::verify_auto_unlock_behavior
+          - tests::nakamoto_integrations::simple_neon_integration
     steps:
       ## Setup test environment
       - name: Setup Test Environment

From d37bf3bda1e9ef9f5655b69eb9e06e2ec421dc54 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Wed, 13 Dec 2023 11:17:18 -0600
Subject: [PATCH 0218/1166] fix: change PANIC_TIMEOUT_SECS back to original
 setting, move the nakamoto_integrations test to bitcoin-tests group

---
 .github/workflows/bitcoin-tests.yml                | 1 +
 testnet/stacks-node/src/tests/neon_integrations.rs | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/bitcoin-tests.yml b/.github/workflows/bitcoin-tests.yml
index 4acac1c8a0..069857ed44 100644
--- a/.github/workflows/bitcoin-tests.yml
+++ b/.github/workflows/bitcoin-tests.yml
@@ -69,6 +69,7 @@ jobs:
           - tests::neon_integrations::test_problematic_txs_are_not_stored
           - tests::neon_integrations::use_latest_tip_integration_test
           - tests::should_succeed_handling_malformed_and_valid_txs
+          - tests::nakamoto_integrations::simple_neon_integration
     steps:
       ## Setup test environment
       - name: Setup Test Environment
diff --git a/testnet/stacks-node/src/tests/neon_integrations.rs b/testnet/stacks-node/src/tests/neon_integrations.rs
index 8915e53020..5676d1bb12 100644
--- a/testnet/stacks-node/src/tests/neon_integrations.rs
+++ b/testnet/stacks-node/src/tests/neon_integrations.rs
@@ -489,7 +489,7 @@ pub mod test_observer {
     }
 }
 
-const PANIC_TIMEOUT_SECS: u64 = 30;
+const PANIC_TIMEOUT_SECS: u64 = 600;
 
 /// Returns `false` on a timeout, true otherwise.
 pub fn next_block_and_wait(

From 3785db73a8f9fc06f6d4fe57231c70e7124b485f Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Wed, 13 Dec 2023 12:45:04 -0500
Subject: [PATCH 0219/1166] fix: when searching for the aggregate public key,
 search _all prior reward cycles_ because integration tests can run in epoch
 2.x for many reward cycles before the epoch 3 transition (and, the neon boot
 code sets the initial aggregate public key)

---
 .../chainstate/nakamoto/coordinator/tests.rs  |  61 ++----
 stackslib/src/chainstate/nakamoto/mod.rs      | 190 ++++++++++--------
 .../src/chainstate/nakamoto/tests/mod.rs      |   6 +-
 stackslib/src/net/mod.rs                      |  48 +++++
 stackslib/src/net/relay.rs                    |   2 -
 5 files changed, 182 insertions(+), 125 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index 578fd5d6a9..3e9231e614 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/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);
     }
diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index 1301486eac..fc3a7b8f01 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -1775,17 +1775,32 @@ impl NakamotoChainState {
             return Err(ChainstateError::InvalidStacksBlock(msg));
         };
 
-        debug!("get-aggregate-public-key {} {}", at_block_id, reward_cycle);
-        chainstate
-            .get_aggregate_public_key_pox_4(sortdb, at_block_id, reward_cycle)?
-            .ok_or_else(|| {
-                warn!(
-                    "Failed to get aggregate public key";
-                    "block_id" => %at_block_id,
-                    "reward_cycle" => reward_cycle,
-                );
-                ChainstateError::InvalidStacksBlock("Failed to get aggregate public key".into())
-            })
+        // need to search back because the set-aggregate-public-key call only happens in nakamoto
+        // TODO: this will be removed once there's aggregate public key voting
+        for rc in (0..=reward_cycle).rev() {
+            debug!("get-aggregate-public-key {} {}", at_block_id, rc);
+            match chainstate.get_aggregate_public_key_pox_4(sortdb, at_block_id, rc)? {
+                Some(agg_key) => {
+                    return Ok(agg_key);
+                }
+                None => {
+                    debug!(
+                        "No aggregate public key set; trying in a lower cycle";
+                        "block_id" => %at_block_id,
+                        "reward_cycle" => rc,
+                    );
+                    continue;
+                }
+            }
+        }
+        warn!(
+            "Failed to get aggregate public key";
+            "block_id" => %at_block_id,
+            "reward_cycle" => reward_cycle,
+        );
+        Err(ChainstateError::InvalidStacksBlock(
+            "Failed to get aggregate public key".into(),
+        ))
     }
 
     /// Return the total ExecutionCost consumed during the tenure up to and including
@@ -2498,7 +2513,6 @@ impl NakamotoChainState {
                 &mut clarity_tx,
                 first_block_height,
                 pox_constants,
-                parent_burn_height.into(),
                 burn_header_height.into(),
             );
         }
@@ -2559,21 +2573,12 @@ impl NakamotoChainState {
         clarity_tx: &mut ClarityTx,
         first_block_height: u64,
         pox_constants: &PoxConstants,
-        parent_burn_header_height: u64,
         burn_header_height: u64,
     ) {
         let mainnet = clarity_tx.config.mainnet;
         let chain_id = clarity_tx.config.chain_id;
         assert!(!mainnet);
 
-        let parent_reward_cycle = pox_constants
-            .block_height_to_reward_cycle(
-                first_block_height,
-                parent_burn_header_height
-                    .try_into()
-                    .expect("Burn block height exceeded u32"),
-            )
-            .expect("FATAL: block height occurs before first block height");
         let my_reward_cycle = pox_constants
             .block_height_to_reward_cycle(
                 first_block_height,
@@ -2583,70 +2588,89 @@ impl NakamotoChainState {
             )
             .expect("FATAL: block height occurs before first block height");
 
-        // carry forward the aggregate public key in the past reward cycle to the current
-        // reward cycle.
-        // TODO: replace with signer voting
-        debug!(
-            "Setting aggregate public key in reward cycle {}",
+        for parent_reward_cycle in (0..my_reward_cycle).rev() {
+            // carry forward the aggregate public key in the past reward cycle to the current
+            // reward cycle.  It may be several cycles back, such as in integration tests where
+            // nakamoto boots up several reward cycles after the initial aggregate public key was set.
+            // TODO: replace with signer voting
+            debug!(
+                "Try setting aggregate public key in reward cycle {}, parent {}",
+                my_reward_cycle, parent_reward_cycle
+            );
+            // execute `set-aggregate-public-key` using `clarity-tx`
+            let Some(aggregate_public_key) = clarity_tx
+                .connection()
+                .with_readonly_clarity_env(
+                    mainnet,
+                    chain_id,
+                    ClarityVersion::Clarity2,
+                    StacksAddress::burn_address(mainnet).into(),
+                    None,
+                    LimitedCostTracker::Free,
+                    |vm_env| {
+                        vm_env.execute_contract_allow_private(
+                            &boot_code_id(POX_4_NAME, mainnet),
+                            "get-aggregate-public-key",
+                            &vec![SymbolicExpression::atom_value(Value::UInt(u128::from(
+                                parent_reward_cycle,
+                            )))],
+                            true,
+                        )
+                    },
+                )
+                .ok()
+                .map(|agg_key_value| {
+                    let agg_key_opt = agg_key_value.expect_optional().map(|agg_key_buff| {
+                        Value::buff_from(agg_key_buff.expect_buff(33))
+                            .expect("failed to reconstruct buffer")
+                    });
+                    agg_key_opt
+                })
+                .flatten()
+            else {
+                debug!(
+                    "No aggregate public key in parent cycle {}",
+                    parent_reward_cycle
+                );
+                continue;
+            };
+
+            clarity_tx.connection().as_transaction(|tx| {
+                tx.with_abort_callback(
+                    |vm_env| {
+                        vm_env.execute_in_env(
+                            StacksAddress::burn_address(mainnet).into(),
+                            None,
+                            None,
+                            |vm_env| {
+                                vm_env.execute_contract_allow_private(
+                                    &boot_code_id(POX_4_NAME, mainnet),
+                                    "set-aggregate-public-key",
+                                    &vec![
+                                        SymbolicExpression::atom_value(Value::UInt(u128::from(
+                                            my_reward_cycle,
+                                        ))),
+                                        SymbolicExpression::atom_value(aggregate_public_key),
+                                    ],
+                                    false,
+                                )
+                            },
+                        )
+                    },
+                    |_, _| false,
+                )
+                .expect("FATAL: failed to set aggregate public key")
+            });
+
+            // success!
+            return;
+        }
+
+        // if we get here, then we didn't ever set the initial aggregate public key
+        panic!(
+            "FATAL: no aggregate public key in pox-4 in any reward cycle between 0 and {}",
             my_reward_cycle
         );
-        // execute `set-aggregate-public-key` using `clarity-tx`
-        let aggregate_public_key = clarity_tx
-            .connection()
-            .with_readonly_clarity_env(
-                mainnet,
-                chain_id,
-                ClarityVersion::Clarity2,
-                StacksAddress::burn_address(mainnet).into(),
-                None,
-                LimitedCostTracker::Free,
-                |vm_env| {
-                    vm_env.execute_contract_allow_private(
-                        &boot_code_id(POX_4_NAME, mainnet),
-                        "get-aggregate-public-key",
-                        &vec![SymbolicExpression::atom_value(Value::UInt(u128::from(
-                            parent_reward_cycle,
-                        )))],
-                        true,
-                    )
-                },
-            )
-            .ok()
-            .map(|agg_key_value| {
-                let agg_key_opt = agg_key_value.expect_optional();
-                let agg_key_buff =
-                    agg_key_opt.expect("FATAL: aggregate public key not set in boot code");
-                Value::buff_from(agg_key_buff.expect_buff(33))
-                    .expect("failed to reconstruct buffer")
-            })
-            .expect("get-aggregate-public-key returned None");
-
-        clarity_tx.connection().as_transaction(|tx| {
-            tx.with_abort_callback(
-                |vm_env| {
-                    vm_env.execute_in_env(
-                        StacksAddress::burn_address(mainnet).into(),
-                        None,
-                        None,
-                        |vm_env| {
-                            vm_env.execute_contract_allow_private(
-                                &boot_code_id(POX_4_NAME, mainnet),
-                                "set-aggregate-public-key",
-                                &vec![
-                                    SymbolicExpression::atom_value(Value::UInt(u128::from(
-                                        my_reward_cycle,
-                                    ))),
-                                    SymbolicExpression::atom_value(aggregate_public_key),
-                                ],
-                                false,
-                            )
-                        },
-                    )
-                },
-                |_, _| false,
-            )
-            .expect("FATAL: failed to set aggregate public key")
-        });
     }
 
     /// Append a Nakamoto Stacks block to the Stacks chain state.
diff --git a/stackslib/src/chainstate/nakamoto/tests/mod.rs b/stackslib/src/chainstate/nakamoto/tests/mod.rs
index e2d702830a..a494e0be9d 100644
--- a/stackslib/src/chainstate/nakamoto/tests/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/mod.rs
@@ -1496,7 +1496,11 @@ fn make_fork_run_with_arrivals(
 #[test]
 pub fn test_get_highest_nakamoto_tenure() {
     let 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(),
+    );
 
     // extract chainstate and sortdb -- we don't need the peer anymore
     let chainstate = &mut peer.stacks_node.as_mut().unwrap().chainstate;
diff --git a/stackslib/src/net/mod.rs b/stackslib/src/net/mod.rs
index 17f9837cad..e1fcc76c34 100644
--- a/stackslib/src/net/mod.rs
+++ b/stackslib/src/net/mod.rs
@@ -67,6 +67,9 @@ use crate::chainstate::burn::db::sortdb::SortitionDB;
 use crate::chainstate::burn::{ConsensusHash, Opcodes};
 use crate::chainstate::coordinator::Error as coordinator_error;
 use crate::chainstate::nakamoto::NakamotoChainState;
+use crate::chainstate::stacks::boot::{
+    BOOT_TEST_POX_4_AGG_KEY_CONTRACT, BOOT_TEST_POX_4_AGG_KEY_FNAME,
+};
 use crate::chainstate::stacks::db::blocks::MemPoolRejection;
 use crate::chainstate::stacks::db::StacksChainState;
 use crate::chainstate::stacks::index::Error as marf_error;
@@ -1555,6 +1558,7 @@ pub mod test {
     use std::sync::Mutex;
     use std::{fs, io, thread};
 
+    use clarity::boot_util::boot_code_id;
     use clarity::vm::ast::ASTRules;
     use clarity::vm::costs::ExecutionCost;
     use clarity::vm::database::STXBalance;
@@ -1571,6 +1575,7 @@ pub mod test {
     use stacks_common::util::secp256k1::*;
     use stacks_common::util::uint::*;
     use stacks_common::util::vrf::*;
+    use wsts::curve::point::Point;
     use {mio, rand};
 
     use super::*;
@@ -1601,6 +1606,7 @@ pub mod test {
     use crate::chainstate::stacks::tests::*;
     use crate::chainstate::stacks::{StacksMicroblockHeader, *};
     use crate::chainstate::*;
+    use crate::clarity::vm::clarity::TransactionConnection;
     use crate::core::{StacksEpoch, StacksEpochExtension, NETWORK_P2P_PORT};
     use crate::net::asn::*;
     use crate::net::atlas::*;
@@ -1911,6 +1917,8 @@ pub mod test {
         pub stacker_db_configs: Vec<Option<StackerDBConfig>>,
         /// What services should this peer support?
         pub services: u16,
+        /// aggregate public key to use
+        pub aggregate_public_key: Option<Point>,
     }
 
     impl TestPeerConfig {
@@ -1974,6 +1982,7 @@ pub mod test {
                 services: (ServiceFlags::RELAY as u16)
                     | (ServiceFlags::RPC as u16)
                     | (ServiceFlags::STACKERDB as u16),
+                aggregate_public_key: None,
             }
         }
 
@@ -2249,9 +2258,48 @@ pub mod test {
             let atlasdb_path = format!("{}/atlas.sqlite", &test_path);
             let atlasdb = AtlasDB::connect(AtlasConfig::new(false), &atlasdb_path, true).unwrap();
 
+            let agg_pub_key_opt = config
+                .aggregate_public_key
+                .as_ref()
+                .map(|apk| to_hex(&apk.compress().data));
+
             let conf = config.clone();
             let post_flight_callback = move |clarity_tx: &mut ClarityTx| {
                 let mut receipts = vec![];
+
+                if let Some(agg_pub_key) = agg_pub_key_opt {
+                    debug!("Setting aggregate public key to {}", &agg_pub_key);
+                    // instantiate aggregate public key
+                    let contract_content = format!(
+                        "(define-read-only ({}) 0x{})",
+                        BOOT_TEST_POX_4_AGG_KEY_FNAME, agg_pub_key
+                    );
+                    let contract_id = boot_code_id(BOOT_TEST_POX_4_AGG_KEY_CONTRACT, false);
+                    clarity_tx.connection().as_transaction(|clarity| {
+                        let (ast, analysis) = clarity
+                            .analyze_smart_contract(
+                                &contract_id,
+                                ClarityVersion::Clarity2,
+                                &contract_content,
+                                ASTRules::PrecheckSize,
+                            )
+                            .unwrap();
+                        clarity
+                            .initialize_smart_contract(
+                                &contract_id,
+                                ClarityVersion::Clarity2,
+                                &ast,
+                                &contract_content,
+                                None,
+                                |_, _| false,
+                            )
+                            .unwrap();
+                        clarity.save_analysis(&contract_id, &analysis).unwrap();
+                    });
+                } else {
+                    debug!("Not setting aggregate public key");
+                }
+                // add test-specific boot code
                 if conf.setup_code.len() > 0 {
                     let receipt = clarity_tx.connection().as_transaction(|clarity| {
                         let boot_code_addr = boot_code_test_addr();
diff --git a/stackslib/src/net/relay.rs b/stackslib/src/net/relay.rs
index d1f787b667..82455c78d4 100644
--- a/stackslib/src/net/relay.rs
+++ b/stackslib/src/net/relay.rs
@@ -718,8 +718,6 @@ impl Relayer {
             &block.header.block_hash()
         );
 
-        // TODO: https://github.com/stacks-network/stacks-core/issues/4109
-        // Update this to retrieve the last block in the last reward cycle rather than chain tip
         let Some(canonical_block_header) =
             NakamotoChainState::get_canonical_block_header(chainstate.db(), &sortdb)?
         else {

From 0a6aa26aec657972080a086d769a7758f9bb323a Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Wed, 13 Dec 2023 12:46:01 -0500
Subject: [PATCH 0220/1166] fix: install initial aggregate public key to neon,
 not nakamoto

---
 testnet/stacks-node/src/mockamoto.rs          |  2 +-
 .../stacks-node/src/nakamoto_node/miner.rs    |  2 +-
 testnet/stacks-node/src/run_loop/nakamoto.rs  | 41 +-------------
 testnet/stacks-node/src/run_loop/neon.rs      | 53 +++++++++++++++++--
 4 files changed, 53 insertions(+), 45 deletions(-)

diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index 495120a4c0..9777995f9f 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -1036,7 +1036,7 @@ impl MockamotoNode {
                 &self.sortdb,
                 &sortition_handle,
                 &mut self.chainstate,
-                block_sn.block_height.saturating_sub(1),
+                block_sn.block_height,
                 &aggregate_key_block_header.index_block_hash(),
             )?;
             aggregate_public_key
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index 592de7817d..83fc419f59 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -184,7 +184,7 @@ impl BlockMinerThread {
                 &sort_db,
                 &sortition_handle,
                 &mut chain_state,
-                block_sn.block_height.saturating_sub(1),
+                block_sn.block_height,
                 &aggregate_key_block_header.index_block_hash(),
             )?;
             aggregate_public_key
diff --git a/testnet/stacks-node/src/run_loop/nakamoto.rs b/testnet/stacks-node/src/run_loop/nakamoto.rs
index eb8bbdc501..e729a5160f 100644
--- a/testnet/stacks-node/src/run_loop/nakamoto.rs
+++ b/testnet/stacks-node/src/run_loop/nakamoto.rs
@@ -225,49 +225,10 @@ impl RunLoop {
             .map(|e| (e.address.clone(), e.amount))
             .collect();
 
-        let agg_pubkey_boot_callback = if let Some(self_signer) = self.config.self_signing() {
-            let agg_pub_key = to_hex(&self_signer.aggregate_public_key.compress().data);
-            info!("Mockamoto node setting agg public key"; "agg_pub_key" => &agg_pub_key);
-            let callback = Box::new(move |clarity_tx: &mut ClarityTx| {
-                let contract_content = format!(
-                    "(define-read-only ({}) 0x{})",
-                    BOOT_TEST_POX_4_AGG_KEY_FNAME, agg_pub_key
-                );
-                // NOTE: this defaults to a testnet address to prevent it from ever working on
-                // mainnet
-                let contract_id = boot_code_id(BOOT_TEST_POX_4_AGG_KEY_CONTRACT, false);
-                clarity_tx.connection().as_transaction(|clarity| {
-                    let (ast, analysis) = clarity
-                        .analyze_smart_contract(
-                            &contract_id,
-                            ClarityVersion::Clarity2,
-                            &contract_content,
-                            ASTRules::PrecheckSize,
-                        )
-                        .unwrap();
-                    clarity
-                        .initialize_smart_contract(
-                            &contract_id,
-                            ClarityVersion::Clarity2,
-                            &ast,
-                            &contract_content,
-                            None,
-                            |_, _| false,
-                        )
-                        .unwrap();
-                    clarity.save_analysis(&contract_id, &analysis).unwrap();
-                })
-            }) as Box<dyn FnOnce(&mut ClarityTx)>;
-            Some(callback)
-        } else {
-            warn!("Self-signing is not supported yet");
-            None
-        };
-
         // instantiate chainstate
         let mut boot_data = ChainStateBootData {
             initial_balances,
-            post_flight_callback: agg_pubkey_boot_callback,
+            post_flight_callback: None,
             first_burnchain_block_hash: burnchain_config.first_block_hash,
             first_burnchain_block_height: burnchain_config.first_block_height as u32,
             first_burnchain_block_timestamp: burnchain_config.first_block_timestamp,
diff --git a/testnet/stacks-node/src/run_loop/neon.rs b/testnet/stacks-node/src/run_loop/neon.rs
index cffcd1aa10..8517df4264 100644
--- a/testnet/stacks-node/src/run_loop/neon.rs
+++ b/testnet/stacks-node/src/run_loop/neon.rs
@@ -6,6 +6,10 @@ use std::sync::{Arc, Mutex};
 use std::thread::JoinHandle;
 use std::{cmp, thread};
 
+use clarity::boot_util::boot_code_id;
+use clarity::vm::ast::ASTRules;
+use clarity::vm::clarity::TransactionConnection;
+use clarity::vm::ClarityVersion;
 use libc;
 use stacks::burnchains::bitcoin::address::{BitcoinAddress, LegacyBitcoinAddressType};
 use stacks::burnchains::Burnchain;
@@ -17,7 +21,10 @@ use stacks::chainstate::coordinator::{
     static_get_heaviest_affirmation_map, static_get_stacks_tip_affirmation_map, ChainsCoordinator,
     ChainsCoordinatorConfig, CoordinatorCommunication, Error as coord_error,
 };
-use stacks::chainstate::stacks::db::{ChainStateBootData, StacksChainState};
+use stacks::chainstate::stacks::boot::{
+    BOOT_TEST_POX_4_AGG_KEY_CONTRACT, BOOT_TEST_POX_4_AGG_KEY_FNAME,
+};
+use stacks::chainstate::stacks::db::{ChainStateBootData, ClarityTx, StacksChainState};
 use stacks::chainstate::stacks::miner::{signal_mining_blocked, signal_mining_ready, MinerStatus};
 use stacks::core::StacksEpochId;
 use stacks::net::atlas::{AtlasConfig, AtlasDB, Attachment};
@@ -25,7 +32,7 @@ use stacks::util_lib::db::Error as db_error;
 use stacks_common::deps_common::ctrlc as termination;
 use stacks_common::deps_common::ctrlc::SignalId;
 use stacks_common::types::PublicKey;
-use stacks_common::util::hash::Hash160;
+use stacks_common::util::hash::{to_hex, Hash160};
 use stacks_common::util::{get_epoch_time_secs, sleep_ms};
 use stx_genesis::GenesisData;
 
@@ -470,10 +477,50 @@ impl RunLoop {
             .map(|e| (e.address.clone(), e.amount))
             .collect();
 
+        // TODO: delete this once aggregate public key voting is working
+        let agg_pubkey_boot_callback = if let Some(self_signer) = self.config.self_signing() {
+            let agg_pub_key = to_hex(&self_signer.aggregate_public_key.compress().data);
+            info!("Mockamoto node setting agg public key"; "agg_pub_key" => &agg_pub_key);
+            let callback = Box::new(move |clarity_tx: &mut ClarityTx| {
+                let contract_content = format!(
+                    "(define-read-only ({}) 0x{})",
+                    BOOT_TEST_POX_4_AGG_KEY_FNAME, agg_pub_key
+                );
+                // NOTE: this defaults to a testnet address to prevent it from ever working on
+                // mainnet
+                let contract_id = boot_code_id(BOOT_TEST_POX_4_AGG_KEY_CONTRACT, false);
+                clarity_tx.connection().as_transaction(|clarity| {
+                    let (ast, analysis) = clarity
+                        .analyze_smart_contract(
+                            &contract_id,
+                            ClarityVersion::Clarity2,
+                            &contract_content,
+                            ASTRules::PrecheckSize,
+                        )
+                        .unwrap();
+                    clarity
+                        .initialize_smart_contract(
+                            &contract_id,
+                            ClarityVersion::Clarity2,
+                            &ast,
+                            &contract_content,
+                            None,
+                            |_, _| false,
+                        )
+                        .unwrap();
+                    clarity.save_analysis(&contract_id, &analysis).unwrap();
+                })
+            }) as Box<dyn FnOnce(&mut ClarityTx)>;
+            Some(callback)
+        } else {
+            warn!("Self-signing is not supported yet");
+            None
+        };
+
         // instantiate chainstate
         let mut boot_data = ChainStateBootData {
             initial_balances,
-            post_flight_callback: None,
+            post_flight_callback: agg_pubkey_boot_callback,
             first_burnchain_block_hash: burnchain_config.first_block_hash,
             first_burnchain_block_height: burnchain_config.first_block_height as u32,
             first_burnchain_block_timestamp: burnchain_config.first_block_timestamp,

From e409b0af05c7b5f390d83b32aba3920b8ba63a21 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Wed, 13 Dec 2023 13:34:22 -0500
Subject: [PATCH 0221/1166] fix: search reward cycle 0 as well

---
 stackslib/src/chainstate/nakamoto/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index fc3a7b8f01..ae74db5fd0 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -2588,7 +2588,7 @@ impl NakamotoChainState {
             )
             .expect("FATAL: block height occurs before first block height");
 
-        for parent_reward_cycle in (0..my_reward_cycle).rev() {
+        for parent_reward_cycle in (0..=my_reward_cycle).rev() {
             // carry forward the aggregate public key in the past reward cycle to the current
             // reward cycle.  It may be several cycles back, such as in integration tests where
             // nakamoto boots up several reward cycles after the initial aggregate public key was set.

From a7aa3f517b97d73689745eea61555064c551d937 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Wed, 13 Dec 2023 12:35:31 -0600
Subject: [PATCH 0222/1166] chore: only check config settings in nakamoto-neon,
 mockamoto

---
 .github/workflows/epoch-tests.yml | 1 -
 testnet/stacks-node/src/config.rs | 6 ++++++
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/epoch-tests.yml b/.github/workflows/epoch-tests.yml
index eabd635246..a50e0d344d 100644
--- a/.github/workflows/epoch-tests.yml
+++ b/.github/workflows/epoch-tests.yml
@@ -54,7 +54,6 @@ jobs:
           - tests::epoch_23::trait_invocation_behavior
           - tests::epoch_24::fix_to_pox_contract
           - tests::epoch_24::verify_auto_unlock_behavior
-          - tests::nakamoto_integrations::simple_neon_integration
     steps:
       ## Setup test environment
       - name: Setup Test Environment
diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index 87c9169676..1d80c92bf7 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -626,6 +626,12 @@ impl Config {
         }
 
         // check if the Epoch 3.0 burnchain settings as configured are going to be valid.
+        if self.burnchain.mode == "nakamoto-neon" || self.burnchain.mode == "mockamoto" {
+            self.check_nakamoto_config(&burnchain);
+        }
+    }
+
+    fn check_nakamoto_config(&self, burnchain: &Burnchain) {
         let epochs = StacksEpoch::get_epochs(
             self.burnchain.get_bitcoin_network().1,
             self.burnchain.epochs.as_ref(),

From 7a910e78f1bd67d487030887af0c8f4f88638b46 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Wed, 13 Dec 2023 13:48:11 -0500
Subject: [PATCH 0223/1166] fix: expect to wait up to 10 minutes for a block to
 be processed (not 30s)

---
 testnet/stacks-node/src/tests/neon_integrations.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/testnet/stacks-node/src/tests/neon_integrations.rs b/testnet/stacks-node/src/tests/neon_integrations.rs
index 455e414208..a37ca24ec7 100644
--- a/testnet/stacks-node/src/tests/neon_integrations.rs
+++ b/testnet/stacks-node/src/tests/neon_integrations.rs
@@ -483,7 +483,7 @@ pub mod test_observer {
     }
 }
 
-const PANIC_TIMEOUT_SECS: u64 = 30;
+const PANIC_TIMEOUT_SECS: u64 = 600;
 
 /// Returns `false` on a timeout, true otherwise.
 pub fn next_block_and_wait(

From ea7b165363a80a1f008e434c6c2e2f7abac658fc Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Wed, 13 Dec 2023 15:07:10 -0500
Subject: [PATCH 0224/1166] chore: address PR feedback

---
 Cargo.lock                                    |  1 +
 stackslib/src/chainstate/burn/db/sortdb.rs    | 22 ++++++
 stackslib/src/chainstate/nakamoto/mod.rs      | 78 ++++++++++++++++---
 stackslib/src/net/mod.rs                      | 36 ++-------
 stackslib/src/net/relay.rs                    | 23 +-----
 testnet/stacks-node/src/mockamoto.rs          | 45 ++---------
 .../stacks-node/src/nakamoto_node/miner.rs    | 14 +---
 testnet/stacks-node/src/run_loop/nakamoto.rs  |  3 -
 testnet/stacks-node/src/run_loop/neon.rs      | 37 +--------
 9 files changed, 109 insertions(+), 150 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 78c3a9e1e6..e3c09a8bbb 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3552,6 +3552,7 @@ dependencies = [
  "libsigner",
  "pico-args",
  "rand 0.8.5",
+ "rand_core 0.6.4",
  "regex",
  "reqwest",
  "ring",
diff --git a/stackslib/src/chainstate/burn/db/sortdb.rs b/stackslib/src/chainstate/burn/db/sortdb.rs
index 6554dccc1e..ffef8a7782 100644
--- a/stackslib/src/chainstate/burn/db/sortdb.rs
+++ b/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()
     }
diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index ae74db5fd0..45d1200ced 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -54,6 +54,7 @@ use super::burn::db::sortdb::{
     SortitionHandleConn, SortitionHandleTx,
 };
 use super::burn::operations::{DelegateStxOp, StackStxOp, TransferStxOp};
+use super::stacks::boot::{BOOT_TEST_POX_4_AGG_KEY_CONTRACT, BOOT_TEST_POX_4_AGG_KEY_FNAME};
 use super::stacks::db::accounts::MinerReward;
 use super::stacks::db::blocks::StagingUserBurnSupport;
 use super::stacks::db::{
@@ -1749,23 +1750,19 @@ impl NakamotoChainState {
         Ok(true)
     }
 
-    /// Get the aggregate public key for the given block.
-    pub fn get_aggregate_public_key(
+    /// Get the aggregate public key for the given block from the pox-4 contract
+    fn load_aggregate_public_key<SH: SortitionHandle>(
         sortdb: &SortitionDB,
-        sort_handle: &SortitionHandleConn,
+        sort_handle: &SH,
         chainstate: &mut StacksChainState,
         for_burn_block_height: u64,
         at_block_id: &StacksBlockId,
     ) -> Result<Point, ChainstateError> {
         // Get the current reward cycle
-        let Some(reward_cycle) = sort_handle
-            .context
-            .pox_constants
-            .block_height_to_reward_cycle(
-                sort_handle.context.first_block_height,
-                for_burn_block_height,
-            )
-        else {
+        let Some(reward_cycle) = sort_handle.pox_constants().block_height_to_reward_cycle(
+            sort_handle.first_burn_block_height(),
+            for_burn_block_height,
+        ) else {
             // This should be unreachable, but we'll return an error just in case.
             let msg = format!(
                 "BUG: Failed to determine reward cycle of burn block height: {}.",
@@ -1803,6 +1800,29 @@ impl NakamotoChainState {
         ))
     }
 
+    /// Get the aggregate public key for a block
+    pub fn get_aggregate_public_key<SH: SortitionHandle>(
+        chainstate: &mut StacksChainState,
+        sortdb: &SortitionDB,
+        sort_handle: &SH,
+        block: &NakamotoBlock,
+    ) -> Result<Point, ChainstateError> {
+        let block_sn =
+            SortitionDB::get_block_snapshot_consensus(sortdb.conn(), &block.header.consensus_hash)?
+                .ok_or(ChainstateError::DBError(DBError::NotFoundError))?;
+        let aggregate_key_block_header =
+            Self::get_canonical_block_header(chainstate.db(), sortdb)?.unwrap();
+
+        let aggregate_public_key = Self::load_aggregate_public_key(
+            sortdb,
+            sort_handle,
+            chainstate,
+            block_sn.block_height,
+            &aggregate_key_block_header.index_block_hash(),
+        )?;
+        Ok(aggregate_public_key)
+    }
+
     /// Return the total ExecutionCost consumed during the tenure up to and including
     ///  `block`
     pub fn get_total_tenure_cost_at(
@@ -3047,6 +3067,42 @@ impl NakamotoChainState {
 
         Ok((epoch_receipt, clarity_commit))
     }
+
+    /// Boot code instantiation for the aggregate public key.
+    /// TODO: This should be removed once it's possible for stackers to vote on the aggregate
+    /// public key
+    /// DO NOT USE IN MAINNET
+    pub fn aggregate_public_key_bootcode(clarity_tx: &mut ClarityTx, apk: &Point) {
+        let agg_pub_key = to_hex(&apk.compress().data);
+        let contract_content = format!(
+            "(define-read-only ({}) 0x{})",
+            BOOT_TEST_POX_4_AGG_KEY_FNAME, agg_pub_key
+        );
+        // NOTE: this defaults to a testnet address to prevent it from ever working on
+        // mainnet
+        let contract_id = boot_code_id(BOOT_TEST_POX_4_AGG_KEY_CONTRACT, false);
+        clarity_tx.connection().as_transaction(|clarity| {
+            let (ast, analysis) = clarity
+                .analyze_smart_contract(
+                    &contract_id,
+                    ClarityVersion::Clarity2,
+                    &contract_content,
+                    ASTRules::PrecheckSize,
+                )
+                .unwrap();
+            clarity
+                .initialize_smart_contract(
+                    &contract_id,
+                    ClarityVersion::Clarity2,
+                    &ast,
+                    &contract_content,
+                    None,
+                    |_, _| false,
+                )
+                .unwrap();
+            clarity.save_analysis(&contract_id, &analysis).unwrap();
+        })
+    }
 }
 
 impl StacksMessageCodec for NakamotoBlock {
diff --git a/stackslib/src/net/mod.rs b/stackslib/src/net/mod.rs
index e1fcc76c34..d237fb1f89 100644
--- a/stackslib/src/net/mod.rs
+++ b/stackslib/src/net/mod.rs
@@ -2258,44 +2258,18 @@ pub mod test {
             let atlasdb_path = format!("{}/atlas.sqlite", &test_path);
             let atlasdb = AtlasDB::connect(AtlasConfig::new(false), &atlasdb_path, true).unwrap();
 
-            let agg_pub_key_opt = config
-                .aggregate_public_key
-                .as_ref()
-                .map(|apk| to_hex(&apk.compress().data));
+            let agg_pub_key_opt = config.aggregate_public_key.clone();
 
             let conf = config.clone();
             let post_flight_callback = move |clarity_tx: &mut ClarityTx| {
                 let mut receipts = vec![];
 
                 if let Some(agg_pub_key) = agg_pub_key_opt {
-                    debug!("Setting aggregate public key to {}", &agg_pub_key);
-                    // instantiate aggregate public key
-                    let contract_content = format!(
-                        "(define-read-only ({}) 0x{})",
-                        BOOT_TEST_POX_4_AGG_KEY_FNAME, agg_pub_key
+                    debug!(
+                        "Setting aggregate public key to {}",
+                        &to_hex(&agg_pub_key.compress().data)
                     );
-                    let contract_id = boot_code_id(BOOT_TEST_POX_4_AGG_KEY_CONTRACT, false);
-                    clarity_tx.connection().as_transaction(|clarity| {
-                        let (ast, analysis) = clarity
-                            .analyze_smart_contract(
-                                &contract_id,
-                                ClarityVersion::Clarity2,
-                                &contract_content,
-                                ASTRules::PrecheckSize,
-                            )
-                            .unwrap();
-                        clarity
-                            .initialize_smart_contract(
-                                &contract_id,
-                                ClarityVersion::Clarity2,
-                                &ast,
-                                &contract_content,
-                                None,
-                                |_, _| false,
-                            )
-                            .unwrap();
-                        clarity.save_analysis(&contract_id, &analysis).unwrap();
-                    });
+                    NakamotoChainState::aggregate_public_key_bootcode(clarity_tx, &agg_pub_key);
                 } else {
                     debug!("Not setting aggregate public key");
                 }
diff --git a/stackslib/src/net/relay.rs b/stackslib/src/net/relay.rs
index 82455c78d4..0d47942abf 100644
--- a/stackslib/src/net/relay.rs
+++ b/stackslib/src/net/relay.rs
@@ -718,27 +718,10 @@ impl Relayer {
             &block.header.block_hash()
         );
 
-        let Some(canonical_block_header) =
-            NakamotoChainState::get_canonical_block_header(chainstate.db(), &sortdb)?
-        else {
-            warn!(
-                "Failed to find Nakamoto canonical block header.  Will not store or relay";
-                "stacks_block_hash" => %block.header.block_hash(),
-                "consensus_hash" => %block.header.consensus_hash,
-                "burn_height" => block.header.chain_length,
-                "sortition_height" => block_sn.block_height,
-            );
-            return Ok(false);
-        };
-
         let config = chainstate.config();
-        let Ok(aggregate_public_key) = NakamotoChainState::get_aggregate_public_key(
-            &sortdb,
-            &sort_handle,
-            chainstate,
-            block_sn.block_height,
-            &canonical_block_header.index_block_hash(),
-        ) else {
+        let Ok(aggregate_public_key) =
+            NakamotoChainState::get_aggregate_public_key(chainstate, &sortdb, sort_handle, &block)
+        else {
             warn!("Failed to get aggregate public key. Will not store or relay";
                 "stacks_block_hash" => %block.header.block_hash(),
                 "consensus_hash" => %block.header.consensus_hash,
diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index 9777995f9f..0654e99fad 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -427,35 +427,10 @@ impl MockamotoNode {
 
         // Create a boot contract to initialize the aggregate public key prior to Pox-4 activation
         let self_signer = SelfSigner::single_signer();
-        let agg_pub_key = to_hex(&self_signer.aggregate_public_key.compress().data);
-        info!("Mockamoto node setting agg public key"; "agg_pub_key" => &agg_pub_key);
+        let agg_pub_key = self_signer.aggregate_public_key.clone();
+        info!("Mockamoto node setting agg public key"; "agg_pub_key" => %to_hex(&self_signer.aggregate_public_key.compress().data));
         let callback = move |clarity_tx: &mut ClarityTx| {
-            let contract_content = format!(
-                "(define-read-only ({}) 0x{})",
-                BOOT_TEST_POX_4_AGG_KEY_FNAME, agg_pub_key
-            );
-            let contract_id = boot_code_id(BOOT_TEST_POX_4_AGG_KEY_CONTRACT, false);
-            clarity_tx.connection().as_transaction(|clarity| {
-                let (ast, analysis) = clarity
-                    .analyze_smart_contract(
-                        &contract_id,
-                        ClarityVersion::Clarity2,
-                        &contract_content,
-                        ASTRules::PrecheckSize,
-                    )
-                    .unwrap();
-                clarity
-                    .initialize_smart_contract(
-                        &contract_id,
-                        ClarityVersion::Clarity2,
-                        &ast,
-                        &contract_content,
-                        None,
-                        |_, _| false,
-                    )
-                    .unwrap();
-                clarity.save_analysis(&contract_id, &analysis).unwrap();
-            })
+            NakamotoChainState::aggregate_public_key_bootcode(clarity_tx, &agg_pub_key);
         };
         let mut boot_data =
             ChainStateBootData::new(&burnchain, initial_balances, Some(Box::new(callback)));
@@ -1023,21 +998,11 @@ impl MockamotoNode {
         let aggregate_public_key = if chain_length <= 1 {
             self.self_signer.aggregate_public_key
         } else {
-            let block_sn = SortitionDB::get_block_snapshot_consensus(
-                sortition_handle.conn(),
-                &block.header.consensus_hash,
-            )?
-            .ok_or(ChainstateError::DBError(DBError::NotFoundError))?;
-            let aggregate_key_block_header =
-                NakamotoChainState::get_canonical_block_header(self.chainstate.db(), &self.sortdb)?
-                    .unwrap();
-
             let aggregate_public_key = NakamotoChainState::get_aggregate_public_key(
+                &mut self.chainstate,
                 &self.sortdb,
                 &sortition_handle,
-                &mut self.chainstate,
-                block_sn.block_height,
-                &aggregate_key_block_header.index_block_hash(),
+                &block,
             )?;
             aggregate_public_key
         };
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index 24a8cfbb62..fd4919b44b 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -174,21 +174,11 @@ impl BlockMinerThread {
         let aggregate_public_key = if block.header.chain_length <= 1 {
             signer.aggregate_public_key.clone()
         } else {
-            let block_sn = SortitionDB::get_block_snapshot_consensus(
-                sortition_handle.conn(),
-                &block.header.consensus_hash,
-            )?
-            .ok_or(ChainstateError::DBError(DBError::NotFoundError))?;
-            let aggregate_key_block_header =
-                NakamotoChainState::get_canonical_block_header(chain_state.db(), &sort_db)?
-                    .unwrap();
-
             let aggregate_public_key = NakamotoChainState::get_aggregate_public_key(
+                &mut chain_state,
                 &sort_db,
                 &sortition_handle,
-                &mut chain_state,
-                block_sn.block_height,
-                &aggregate_key_block_header.index_block_hash(),
+                &block,
             )?;
             aggregate_public_key
         };
diff --git a/testnet/stacks-node/src/run_loop/nakamoto.rs b/testnet/stacks-node/src/run_loop/nakamoto.rs
index 5e9e36c648..df93e79ea2 100644
--- a/testnet/stacks-node/src/run_loop/nakamoto.rs
+++ b/testnet/stacks-node/src/run_loop/nakamoto.rs
@@ -31,9 +31,6 @@ use stacks::chainstate::coordinator::comm::{CoordinatorChannels, CoordinatorRece
 use stacks::chainstate::coordinator::{
     ChainsCoordinator, ChainsCoordinatorConfig, CoordinatorCommunication,
 };
-use stacks::chainstate::stacks::boot::{
-    BOOT_TEST_POX_4_AGG_KEY_CONTRACT, BOOT_TEST_POX_4_AGG_KEY_FNAME,
-};
 use stacks::chainstate::stacks::db::{ChainStateBootData, ClarityTx, StacksChainState};
 use stacks::chainstate::stacks::miner::{signal_mining_blocked, signal_mining_ready, MinerStatus};
 use stacks::core::StacksEpochId;
diff --git a/testnet/stacks-node/src/run_loop/neon.rs b/testnet/stacks-node/src/run_loop/neon.rs
index 3ac8c35edc..d3053415d9 100644
--- a/testnet/stacks-node/src/run_loop/neon.rs
+++ b/testnet/stacks-node/src/run_loop/neon.rs
@@ -21,9 +21,7 @@ use stacks::chainstate::coordinator::{
     static_get_heaviest_affirmation_map, static_get_stacks_tip_affirmation_map, ChainsCoordinator,
     ChainsCoordinatorConfig, CoordinatorCommunication, Error as coord_error,
 };
-use stacks::chainstate::stacks::boot::{
-    BOOT_TEST_POX_4_AGG_KEY_CONTRACT, BOOT_TEST_POX_4_AGG_KEY_FNAME,
-};
+use stacks::chainstate::nakamoto::NakamotoChainState;
 use stacks::chainstate::stacks::db::{ChainStateBootData, ClarityTx, StacksChainState};
 use stacks::chainstate::stacks::miner::{signal_mining_blocked, signal_mining_ready, MinerStatus};
 use stacks::core::StacksEpochId;
@@ -480,37 +478,10 @@ impl RunLoop {
 
         // TODO: delete this once aggregate public key voting is working
         let agg_pubkey_boot_callback = if let Some(self_signer) = self.config.self_signing() {
-            let agg_pub_key = to_hex(&self_signer.aggregate_public_key.compress().data);
-            info!("Mockamoto node setting agg public key"; "agg_pub_key" => &agg_pub_key);
+            let agg_pub_key = self_signer.aggregate_public_key.clone();
+            info!("Neon node setting agg public key"; "agg_pub_key" => %to_hex(&agg_pub_key.compress().data));
             let callback = Box::new(move |clarity_tx: &mut ClarityTx| {
-                let contract_content = format!(
-                    "(define-read-only ({}) 0x{})",
-                    BOOT_TEST_POX_4_AGG_KEY_FNAME, agg_pub_key
-                );
-                // NOTE: this defaults to a testnet address to prevent it from ever working on
-                // mainnet
-                let contract_id = boot_code_id(BOOT_TEST_POX_4_AGG_KEY_CONTRACT, false);
-                clarity_tx.connection().as_transaction(|clarity| {
-                    let (ast, analysis) = clarity
-                        .analyze_smart_contract(
-                            &contract_id,
-                            ClarityVersion::Clarity2,
-                            &contract_content,
-                            ASTRules::PrecheckSize,
-                        )
-                        .unwrap();
-                    clarity
-                        .initialize_smart_contract(
-                            &contract_id,
-                            ClarityVersion::Clarity2,
-                            &ast,
-                            &contract_content,
-                            None,
-                            |_, _| false,
-                        )
-                        .unwrap();
-                    clarity.save_analysis(&contract_id, &analysis).unwrap();
-                })
+                NakamotoChainState::aggregate_public_key_bootcode(clarity_tx, &agg_pub_key)
             }) as Box<dyn FnOnce(&mut ClarityTx)>;
             Some(callback)
         } else {

From b63ca2155876bbbfd200bd4c27c06d0bf18e044d Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Wed, 13 Dec 2023 18:12:12 -0500
Subject: [PATCH 0225/1166] chore: address PR feedback and force epoch 2.5 to
 begin after the integration test framework has mined some blocks

---
 stackslib/src/chainstate/nakamoto/mod.rs      | 197 ++++++++----------
 stackslib/src/clarity_vm/clarity.rs           |   3 +-
 testnet/stacks-node/src/config.rs             |   2 +-
 .../src/tests/nakamoto_integrations.rs        |   8 +-
 4 files changed, 97 insertions(+), 113 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index 45d1200ced..28d71caa1a 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -1759,7 +1759,7 @@ impl NakamotoChainState {
         at_block_id: &StacksBlockId,
     ) -> Result<Point, ChainstateError> {
         // Get the current reward cycle
-        let Some(reward_cycle) = sort_handle.pox_constants().block_height_to_reward_cycle(
+        let Some(rc) = sort_handle.pox_constants().block_height_to_reward_cycle(
             sort_handle.first_burn_block_height(),
             for_burn_block_height,
         ) else {
@@ -1772,35 +1772,32 @@ impl NakamotoChainState {
             return Err(ChainstateError::InvalidStacksBlock(msg));
         };
 
-        // need to search back because the set-aggregate-public-key call only happens in nakamoto
-        // TODO: this will be removed once there's aggregate public key voting
-        for rc in (0..=reward_cycle).rev() {
-            debug!("get-aggregate-public-key {} {}", at_block_id, rc);
-            match chainstate.get_aggregate_public_key_pox_4(sortdb, at_block_id, rc)? {
-                Some(agg_key) => {
-                    return Ok(agg_key);
-                }
-                None => {
-                    debug!(
-                        "No aggregate public key set; trying in a lower cycle";
-                        "block_id" => %at_block_id,
-                        "reward_cycle" => rc,
-                    );
-                    continue;
-                }
+        debug!("get-aggregate-public-key {} {}", at_block_id, rc);
+        match chainstate.get_aggregate_public_key_pox_4(sortdb, at_block_id, rc)? {
+            Some(key) => Ok(key),
+            None => {
+                // if this is the first block in its reward cycle, it'll contain the effects of
+                // setting the aggregate public key for `rc`, but there will currently be no key
+                // for `rc`.  So, check `rc - 1`
+                chainstate
+                    .get_aggregate_public_key_pox_4(sortdb, at_block_id, rc.saturating_sub(1))?
+                    .ok_or_else(|| {
+                        warn!(
+                            "Failed to get aggregate public key";
+                            "block_id" => %at_block_id,
+                            "reward_cycle" => rc,
+                        );
+                        ChainstateError::InvalidStacksBlock(
+                            "Failed to get aggregate public key".into(),
+                        )
+                    })
             }
         }
-        warn!(
-            "Failed to get aggregate public key";
-            "block_id" => %at_block_id,
-            "reward_cycle" => reward_cycle,
-        );
-        Err(ChainstateError::InvalidStacksBlock(
-            "Failed to get aggregate public key".into(),
-        ))
     }
 
-    /// Get the aggregate public key for a block
+    /// Get the aggregate public key for a block.
+    /// TODO: The block at which the aggregate public key is queried needs to be better defined.
+    /// See https://github.com/stacks-network/stacks-core/issues/4109
     pub fn get_aggregate_public_key<SH: SortitionHandle>(
         chainstate: &mut StacksChainState,
         sortdb: &SortitionDB,
@@ -2608,89 +2605,75 @@ impl NakamotoChainState {
             )
             .expect("FATAL: block height occurs before first block height");
 
-        for parent_reward_cycle in (0..=my_reward_cycle).rev() {
-            // carry forward the aggregate public key in the past reward cycle to the current
-            // reward cycle.  It may be several cycles back, such as in integration tests where
-            // nakamoto boots up several reward cycles after the initial aggregate public key was set.
-            // TODO: replace with signer voting
-            debug!(
-                "Try setting aggregate public key in reward cycle {}, parent {}",
-                my_reward_cycle, parent_reward_cycle
-            );
-            // execute `set-aggregate-public-key` using `clarity-tx`
-            let Some(aggregate_public_key) = clarity_tx
-                .connection()
-                .with_readonly_clarity_env(
-                    mainnet,
-                    chain_id,
-                    ClarityVersion::Clarity2,
-                    StacksAddress::burn_address(mainnet).into(),
-                    None,
-                    LimitedCostTracker::Free,
-                    |vm_env| {
-                        vm_env.execute_contract_allow_private(
-                            &boot_code_id(POX_4_NAME, mainnet),
-                            "get-aggregate-public-key",
-                            &vec![SymbolicExpression::atom_value(Value::UInt(u128::from(
-                                parent_reward_cycle,
-                            )))],
-                            true,
-                        )
-                    },
-                )
-                .ok()
-                .map(|agg_key_value| {
-                    let agg_key_opt = agg_key_value.expect_optional().map(|agg_key_buff| {
-                        Value::buff_from(agg_key_buff.expect_buff(33))
-                            .expect("failed to reconstruct buffer")
-                    });
-                    agg_key_opt
-                })
-                .flatten()
-            else {
-                debug!(
-                    "No aggregate public key in parent cycle {}",
-                    parent_reward_cycle
-                );
-                continue;
-            };
-
-            clarity_tx.connection().as_transaction(|tx| {
-                tx.with_abort_callback(
-                    |vm_env| {
-                        vm_env.execute_in_env(
-                            StacksAddress::burn_address(mainnet).into(),
-                            None,
-                            None,
-                            |vm_env| {
-                                vm_env.execute_contract_allow_private(
-                                    &boot_code_id(POX_4_NAME, mainnet),
-                                    "set-aggregate-public-key",
-                                    &vec![
-                                        SymbolicExpression::atom_value(Value::UInt(u128::from(
-                                            my_reward_cycle,
-                                        ))),
-                                        SymbolicExpression::atom_value(aggregate_public_key),
-                                    ],
-                                    false,
-                                )
-                            },
-                        )
-                    },
-                    |_, _| false,
-                )
-                .expect("FATAL: failed to set aggregate public key")
-            });
+        let parent_reward_cycle = my_reward_cycle.saturating_sub(1);
+        debug!(
+            "Try setting aggregate public key in reward cycle {}, parent {}",
+            my_reward_cycle, parent_reward_cycle
+        );
 
-            // success!
-            return;
-        }
+        // execute `set-aggregate-public-key` using `clarity-tx`
+        let Some(aggregate_public_key) = clarity_tx
+            .connection()
+            .with_readonly_clarity_env(
+                mainnet,
+                chain_id,
+                ClarityVersion::Clarity2,
+                StacksAddress::burn_address(mainnet).into(),
+                None,
+                LimitedCostTracker::Free,
+                |vm_env| {
+                    vm_env.execute_contract_allow_private(
+                        &boot_code_id(POX_4_NAME, mainnet),
+                        "get-aggregate-public-key",
+                        &vec![SymbolicExpression::atom_value(Value::UInt(u128::from(
+                            parent_reward_cycle,
+                        )))],
+                        true,
+                    )
+                },
+            )
+            .ok()
+            .map(|agg_key_value| {
+                let agg_key_opt = agg_key_value.expect_optional().map(|agg_key_buff| {
+                    Value::buff_from(agg_key_buff.expect_buff(33))
+                        .expect("failed to reconstruct buffer")
+                });
+                agg_key_opt
+            })
+            .flatten()
+        else {
+            panic!(
+                "No aggregate public key in parent cycle {}",
+                parent_reward_cycle
+            );
+        };
 
-        // if we get here, then we didn't ever set the initial aggregate public key
-        panic!(
-            "FATAL: no aggregate public key in pox-4 in any reward cycle between 0 and {}",
-            my_reward_cycle
-        );
+        clarity_tx.connection().as_transaction(|tx| {
+            tx.with_abort_callback(
+                |vm_env| {
+                    vm_env.execute_in_env(
+                        StacksAddress::burn_address(mainnet).into(),
+                        None,
+                        None,
+                        |vm_env| {
+                            vm_env.execute_contract_allow_private(
+                                &boot_code_id(POX_4_NAME, mainnet),
+                                "set-aggregate-public-key",
+                                &vec![
+                                    SymbolicExpression::atom_value(Value::UInt(u128::from(
+                                        my_reward_cycle,
+                                    ))),
+                                    SymbolicExpression::atom_value(aggregate_public_key),
+                                ],
+                                false,
+                            )
+                        },
+                    )
+                },
+                |_, _| false,
+            )
+            .expect("FATAL: failed to set aggregate public key")
+        });
     }
 
     /// Append a Nakamoto Stacks block to the Stacks chain state.
diff --git a/stackslib/src/clarity_vm/clarity.rs b/stackslib/src/clarity_vm/clarity.rs
index 59b5463d79..ae2dfbddc6 100644
--- a/stackslib/src/clarity_vm/clarity.rs
+++ b/stackslib/src/clarity_vm/clarity.rs
@@ -1405,11 +1405,12 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
                 // set the aggregate public key for all pre-pox-4 cycles, if in testnet, and can fetch a boot-setting
                 if !mainnet {
                     if let Some(ref agg_pub_key) = initialized_agg_key {
-                        for set_in_reward_cycle in 0..pox_4_first_cycle {
+                        for set_in_reward_cycle in 0..=pox_4_first_cycle {
                             info!(
                                 "Setting initial aggregate-public-key in PoX-4";
                                 "agg_pub_key" => %agg_pub_key,
                                 "reward_cycle" => set_in_reward_cycle,
+                                "pox_4_first_cycle" => pox_4_first_cycle,
                             );
                             tx_conn
                                 .with_abort_callback(
diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index 1d80c92bf7..72b208eb6f 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -599,7 +599,7 @@ impl Config {
                 .iter()
                 .find(|epoch| epoch.epoch_id == StacksEpochId::Epoch25)
             {
-                // Override pox_3_activation_height to the start_height of epoch2.5
+                // Override pox_4_activation_height to the start_height of epoch2.5
                 debug!(
                     "Override pox_4_activation_height from {} to {}",
                     burnchain.pox_constants.pox_4_activation_height, epoch.start_height
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 0b1d79ffa3..6666b1eac9 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -98,20 +98,20 @@ lazy_static! {
         StacksEpoch {
             epoch_id: StacksEpochId::Epoch24,
             start_height: 5,
-            end_height: 6,
+            end_height: 201,
             block_limit: HELIUM_BLOCK_LIMIT_20.clone(),
             network_epoch: PEER_VERSION_EPOCH_2_4
         },
         StacksEpoch {
             epoch_id: StacksEpochId::Epoch25,
-            start_height: 6,
-            end_height: 221,
+            start_height: 201,
+            end_height: 231,
             block_limit: HELIUM_BLOCK_LIMIT_20.clone(),
             network_epoch: PEER_VERSION_EPOCH_2_5
         },
         StacksEpoch {
             epoch_id: StacksEpochId::Epoch30,
-            start_height: 221,
+            start_height: 231,
             end_height: STACKS_EPOCH_MAX,
             block_limit: HELIUM_BLOCK_LIMIT_20.clone(),
             network_epoch: PEER_VERSION_EPOCH_3_0

From 879b9dbc54106654c49581e65816d1bb36db79d7 Mon Sep 17 00:00:00 2001
From: Mitchell Cuevas <6131188+cuevasm@users.noreply.github.com>
Date: Thu, 14 Dec 2023 19:13:11 -0500
Subject: [PATCH 0226/1166] Update CODE_OF_CONDUCT.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Adding secret code so users in our community onboarding flows and contests can find it. This will bring some additional attention the repo 🙏
---
 CODE_OF_CONDUCT.md | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md
index 81c865506e..150aa9d023 100644
--- a/CODE_OF_CONDUCT.md
+++ b/CODE_OF_CONDUCT.md
@@ -71,6 +71,9 @@ Community leaders will follow these Community Impact Guidelines in determining t
 
 **Consequence**: A permanent ban from any sort of public interaction within the community.
 
+### Secret Code: 
+The code to the contest is: BITCOINL2
+
 ## Attribution
 
 This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 2.0,

From 7c91912ba6f0c38ae3f95ed77ae03697d814dbdd Mon Sep 17 00:00:00 2001
From: ASuciuX <asuciu@hiro.so>
Date: Fri, 15 Dec 2023 16:24:04 +0200
Subject: [PATCH 0227/1166] feat: keep only filter pr workflow file

---
 .github/workflows/logger-mutants.yml | 30 ----------------------------
 1 file changed, 30 deletions(-)
 delete mode 100644 .github/workflows/logger-mutants.yml

diff --git a/.github/workflows/logger-mutants.yml b/.github/workflows/logger-mutants.yml
deleted file mode 100644
index 1db813ffed..0000000000
--- a/.github/workflows/logger-mutants.yml
+++ /dev/null
@@ -1,30 +0,0 @@
-name: Logging Mutants
-
-# only run on push in order to update the cache output
-# flow:
-# restore cache
-# install cargo-mutants crate in order to run the 'cargo mutants' command
-# create a file with the current commit hash if a previous one doesn't exist, then print it
-# run the script that handles the 'cargo mutants' command on the differences between the latest updates and the last commit where it was ran
-# overwrite the previous commit hash with the current one for the following run
-# delete the old cache
-# save the new cache with the updated mutants
-# upload artifact to easily check it for the given commit
-
-on:
-  push:
-    branches:
-      - master
-      - develop
-      - next
-
-jobs:
-  save_cache:
-    runs-on: ubuntu-latest
-
-    # test
-    steps:
-      - name: Run logging mutants from actions
-        uses: stacks-network/actions/mutation-testing/logger@feat/mutation-testing
-        with:
-          gh-token: ${{ secrets.GITHUB_TOKEN }}

From 491557d607ce07cb7ed80672dbf575bd370e4753 Mon Sep 17 00:00:00 2001
From: ASuciuX <asuciu@hiro.so>
Date: Fri, 15 Dec 2023 16:42:51 +0200
Subject: [PATCH 0228/1166] added specific triggers for the CI action on PR

---
 .github/workflows/filter-pr-mutants.yml | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/.github/workflows/filter-pr-mutants.yml b/.github/workflows/filter-pr-mutants.yml
index 5956e9579f..c0a9c0b1ec 100644
--- a/.github/workflows/filter-pr-mutants.yml
+++ b/.github/workflows/filter-pr-mutants.yml
@@ -2,6 +2,13 @@ name: Tracking PR Mutants
 
 on:
   pull_request:
+    types:
+      - opened
+      - reopened
+      - synchronize
+      - ready_for_review
+    paths:
+      - '**.rs'
 
 jobs:
   # Mutants testing: Execute on PR on packages that have functions modified, and fail the workflow if there are missed or timeout mutations

From aabce29f222c2322b164440b22714f9d42780367 Mon Sep 17 00:00:00 2001
From: friedger <mail@friedger.de>
Date: Sat, 16 Dec 2023 14:52:10 +0100
Subject: [PATCH 0229/1166] chore: remove stack-stx, stack-extend,
 stack-increase from pox-4

---
 .../src/chainstate/stacks/boot/pox-4.clar     | 188 +-----------------
 1 file changed, 2 insertions(+), 186 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index 2e5f744411..cbd0b0b1c1 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -74,8 +74,7 @@
 )
 
 ;; The Stacking lock-up state and associated metadata.
-;; Records are inserted into this map via `stack-stx`, `delegate-stack-stx`, `stack-extend`
-;;  `delegate-stack-extend` and burnchain transactions for invoking `stack-stx`, etc.
+;; Records are inserted into this map via `delegate-stack-stx` and `delegate-stack-extend`.
 ;; Records will be deleted from this map when auto-unlocks are processed
 ;;
 ;; This map de-normalizes some state from the `reward-cycle-pox-address-list` map
@@ -108,7 +107,7 @@
         ;; these indexes are only valid looking forward from
         ;;  `first-reward-cycle` (i.e., they do not correspond
         ;;  to entries in the reward set that may have been from
-        ;;  previous stack-stx calls, or prior to an extend)
+        ;;  previous stacking calls, or prior to an extend)
         reward-set-indexes: (list 12 uint),
         ;; principal of the delegate, if stacker has delegated
         delegated-to: (optional principal)
@@ -529,65 +528,6 @@
                { sender: tx-sender, contract-caller: caller }
                { until-burn-ht: until-burn-ht }))))
 
-;; Lock up some uSTX for stacking!  Note that the given amount here is in micro-STX (uSTX).
-;; The STX will be locked for the given number of reward cycles (lock-period).
-;; This is the self-service interface.  tx-sender will be the Stacker.
-;;
-;; * The given stacker cannot currently be stacking.
-;; * You will need the minimum uSTX threshold.  This will be determined by (get-stacking-minimum)
-;; at the time this method is called.
-;; * You may need to increase the amount of uSTX locked up later, since the minimum uSTX threshold
-;; may increase between reward cycles.
-;; * The Stacker will receive rewards in the reward cycle following `start-burn-ht`.
-;; Importantly, `start-burn-ht` may not be further into the future than the next reward cycle,
-;; and in most cases should be set to the current burn block height.
-;;
-;; The tokens will unlock and be returned to the Stacker (tx-sender) automatically.
-(define-public (stack-stx (amount-ustx uint)
-                          (pox-addr (tuple (version (buff 1)) (hashbytes (buff 32))))
-                          (start-burn-ht uint)
-                          (lock-period uint))
-    ;; this stacker's first reward cycle is the _next_ reward cycle
-    (let ((first-reward-cycle (+ u1 (current-pox-reward-cycle)))
-          (specified-reward-cycle (+ u1 (burn-height-to-reward-cycle start-burn-ht))))
-      ;; the start-burn-ht must result in the next reward cycle, do not allow stackers
-      ;;  to "post-date" their `stack-stx` transaction
-      (asserts! (is-eq first-reward-cycle specified-reward-cycle)
-                (err ERR_INVALID_START_BURN_HEIGHT))
-
-      ;; must be called directly by the tx-sender or by an allowed contract-caller
-      (asserts! (check-caller-allowed)
-                (err ERR_STACKING_PERMISSION_DENIED))
-
-      ;; tx-sender principal must not be stacking
-      (asserts! (is-none (get-stacker-info tx-sender))
-        (err ERR_STACKING_ALREADY_STACKED))
-
-      ;; tx-sender must not be delegating
-      (asserts! (is-none (get-check-delegation tx-sender))
-        (err ERR_STACKING_ALREADY_DELEGATED))
-
-      ;; the Stacker must have sufficient unlocked funds
-      (asserts! (>= (stx-get-balance tx-sender) amount-ustx)
-        (err ERR_STACKING_INSUFFICIENT_FUNDS))
-
-      ;; ensure that stacking can be performed
-      (try! (can-stack-stx pox-addr amount-ustx first-reward-cycle lock-period))
-
-      ;; register the PoX address with the amount stacked
-      (let ((reward-set-indexes (try! (add-pox-addr-to-reward-cycles pox-addr first-reward-cycle lock-period amount-ustx tx-sender))))
-          ;; add stacker record
-         (map-set stacking-state
-           { stacker: tx-sender }
-           { pox-addr: pox-addr,
-             reward-set-indexes: reward-set-indexes,
-             first-reward-cycle: first-reward-cycle,
-             lock-period: lock-period,
-             delegated-to: none })
-
-          ;; return the lock-up information, so the node can actually carry out the lock.
-          (ok { stacker: tx-sender, lock-amount: amount-ustx, unlock-burn-height: (reward-cycle-to-burn-height (+ first-reward-cycle lock-period)) }))))
-
 (define-public (revoke-delegate-stx)
   (begin
     ;; must be called directly by the tx-sender or by an allowed contract-caller
@@ -895,130 +835,6 @@
                     stacker: (get stacker data),
                     add-amount: (get add-amount data) })))))
 
-;; Increase the number of STX locked.
-;; *New in Stacks 2.1*
-;; This method locks up an additional amount of STX from `tx-sender`'s, indicated
-;; by `increase-by`.  The `tx-sender` must already be Stacking.
-(define-public (stack-increase (increase-by uint))
-   (let ((stacker-info (stx-account tx-sender))
-         (amount-stacked (get locked stacker-info))
-         (amount-unlocked (get unlocked stacker-info))
-         (unlock-height (get unlock-height stacker-info))
-         (cur-cycle (current-pox-reward-cycle))
-         (first-increased-cycle (+ cur-cycle u1))
-         (stacker-state (unwrap! (map-get? stacking-state
-                                          { stacker: tx-sender })
-                                          (err ERR_STACK_INCREASE_NOT_LOCKED))))
-      ;; tx-sender must be currently locked
-      (asserts! (> amount-stacked u0)
-                (err ERR_STACK_INCREASE_NOT_LOCKED))
-      ;; must be called with positive `increase-by`
-      (asserts! (>= increase-by u1)
-                (err ERR_STACKING_INVALID_AMOUNT))
-      ;; stacker must have enough stx to lock
-      (asserts! (>= amount-unlocked increase-by)
-                (err ERR_STACKING_INSUFFICIENT_FUNDS))
-      ;; must be called directly by the tx-sender or by an allowed contract-caller
-      (asserts! (check-caller-allowed)
-                (err ERR_STACKING_PERMISSION_DENIED))
-      ;; stacker must be directly stacking
-      (asserts! (> (len (get reward-set-indexes stacker-state)) u0)
-                (err ERR_STACKING_IS_DELEGATED))
-      ;; stacker must not be delegating
-      (asserts! (is-none (get delegated-to stacker-state))
-                (err ERR_STACKING_IS_DELEGATED))
-      ;; update reward cycle amounts
-      (asserts! (is-some (fold increase-reward-cycle-entry
-            (get reward-set-indexes stacker-state)
-            (some { first-cycle: first-increased-cycle,
-                    reward-cycle: (get first-reward-cycle stacker-state),
-                    stacker: tx-sender,
-                    add-amount: increase-by })))
-            (err ERR_STACKING_UNREACHABLE))
-      ;; NOTE: stacking-state map is unchanged: it does not track amount-stacked in PoX-4
-      (ok { stacker: tx-sender, total-locked: (+ amount-stacked increase-by)})))
-
-;; Extend an active Stacking lock.
-;; *New in Stacks 2.1*
-;; This method extends the `tx-sender`'s current lockup for an additional `extend-count`
-;;    and associates `pox-addr` with the rewards
-(define-public (stack-extend (extend-count uint)
-                             (pox-addr { version: (buff 1), hashbytes: (buff 32) }))
-   (let ((stacker-info (stx-account tx-sender))
-         ;; to extend, there must already be an etry in the stacking-state
-         (stacker-state (unwrap! (get-stacker-info tx-sender) (err ERR_STACK_EXTEND_NOT_LOCKED)))
-         (amount-ustx (get locked stacker-info))
-         (unlock-height (get unlock-height stacker-info))
-         (cur-cycle (current-pox-reward-cycle))
-         ;; first-extend-cycle will be the cycle in which tx-sender *would have* unlocked
-         (first-extend-cycle (burn-height-to-reward-cycle unlock-height))
-         ;; new first cycle should be max(cur-cycle, stacker-state.first-reward-cycle)
-         (cur-first-reward-cycle (get first-reward-cycle stacker-state))
-         (first-reward-cycle (if (> cur-cycle cur-first-reward-cycle) cur-cycle cur-first-reward-cycle)))
-
-    ;; must be called with positive extend-count
-    (asserts! (>= extend-count u1)
-              (err ERR_STACKING_INVALID_LOCK_PERIOD))
-
-    ;; stacker must be directly stacking
-      (asserts! (> (len (get reward-set-indexes stacker-state)) u0)
-                (err ERR_STACKING_IS_DELEGATED))
-
-    ;; stacker must not be delegating
-    (asserts! (is-none (get delegated-to stacker-state))
-              (err ERR_STACKING_IS_DELEGATED))
-
-    ;; TODO: add more assertions to sanity check the `stacker-info` values with
-    ;;       the `stacker-state` values
-
-    (let ((last-extend-cycle  (- (+ first-extend-cycle extend-count) u1))
-          (lock-period (+ u1 (- last-extend-cycle first-reward-cycle)))
-          (new-unlock-ht (reward-cycle-to-burn-height (+ u1 last-extend-cycle))))
-
-      ;; first cycle must be after the current cycle
-      (asserts! (> first-extend-cycle cur-cycle) (err ERR_STACKING_INVALID_LOCK_PERIOD))
-      ;; lock period must be positive
-      (asserts! (> lock-period u0) (err ERR_STACKING_INVALID_LOCK_PERIOD))
-
-      ;; must be called directly by the tx-sender or by an allowed contract-caller
-      (asserts! (check-caller-allowed)
-                (err ERR_STACKING_PERMISSION_DENIED))
-
-      ;; tx-sender must be locked
-      (asserts! (> amount-ustx u0)
-        (err ERR_STACK_EXTEND_NOT_LOCKED))
-
-      ;; tx-sender must not be delegating
-      (asserts! (is-none (get-check-delegation tx-sender))
-        (err ERR_STACKING_ALREADY_DELEGATED))
-
-      ;; standard can-stack-stx checks
-      (try! (can-stack-stx pox-addr amount-ustx first-extend-cycle lock-period))
-
-      ;; register the PoX address with the amount stacked
-      ;;   for the new cycles
-      (let ((extended-reward-set-indexes (try! (add-pox-addr-to-reward-cycles pox-addr first-extend-cycle extend-count amount-ustx tx-sender)))
-            (reward-set-indexes
-                ;; use the active stacker state and extend the existing reward-set-indexes
-                (let ((cur-cycle-index (- first-reward-cycle (get first-reward-cycle stacker-state)))
-                      (old-indexes (get reward-set-indexes stacker-state))
-                      ;; build index list by taking the old-indexes starting from cur cycle
-                      ;;  and adding the new indexes to it. this way, the index is valid starting from the current cycle
-                      (new-list (concat (default-to (list) (slice? old-indexes cur-cycle-index (len old-indexes)))
-                                        extended-reward-set-indexes)))
-                  (unwrap-panic (as-max-len? new-list u12)))))
-          ;; update stacker record
-          (map-set stacking-state
-            { stacker: tx-sender }
-            { pox-addr: pox-addr,
-              reward-set-indexes: reward-set-indexes,
-              first-reward-cycle: first-reward-cycle,
-              lock-period: lock-period,
-              delegated-to: none })
-
-        ;; return lock-up information
-        (ok { stacker: tx-sender, unlock-burn-height: new-unlock-ht })))))
-
 ;; As a delegator, increase an active Stacking lock, issuing a "partial commitment" for the
 ;;   increased cycles.
 ;; *New in Stacks 2.1*

From 83ee2f2e5df32d67c3915aa37bf99fb891462c07 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Mon, 18 Dec 2023 14:57:06 -0600
Subject: [PATCH 0230/1166] chore: fix on-exit corner case trigger inf-loop
 instead of exit

---
 stackslib/src/burnchains/bitcoin/indexer.rs | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/stackslib/src/burnchains/bitcoin/indexer.rs b/stackslib/src/burnchains/bitcoin/indexer.rs
index 6f6b82ceec..c3346b7bab 100644
--- a/stackslib/src/burnchains/bitcoin/indexer.rs
+++ b/stackslib/src/burnchains/bitcoin/indexer.rs
@@ -18,7 +18,7 @@ use std::convert::TryFrom;
 use std::net::Shutdown;
 use std::ops::{Deref, DerefMut};
 use std::path::PathBuf;
-use std::sync::atomic::AtomicBool;
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
 use std::time::Duration;
 use std::{cmp, fs, net, path, time};
@@ -339,6 +339,12 @@ impl BitcoinIndexer {
         let mut initiated = false;
 
         while keep_going {
+            if let Some(ref should_keep_running) = self.should_keep_running {
+                if !should_keep_running.load(Ordering::SeqCst) {
+                    return Err(btc_error::TimedOut);
+                }
+            }
+
             if do_handshake {
                 debug!("(Re)establish peer connection");
 

From ddb2b38542c3d58cb3b1e450c9044f61bd355c40 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Mon, 18 Dec 2023 14:58:26 -0600
Subject: [PATCH 0231/1166] feat: implement interim block mining in naka-node,
 add test case

---
 .github/workflows/bitcoin-tests.yml           |   1 +
 stacks-signer/src/runloop.rs                  |   1 -
 .../burnchains/bitcoin_regtest_controller.rs  |   4 -
 testnet/stacks-node/src/config.rs             |  15 +-
 testnet/stacks-node/src/mockamoto.rs          |  11 +-
 testnet/stacks-node/src/mockamoto/tests.rs    |  13 +-
 .../stacks-node/src/nakamoto_node/miner.rs    | 125 +++++++----
 testnet/stacks-node/src/run_loop/nakamoto.rs  |   8 +-
 testnet/stacks-node/src/run_loop/neon.rs      |  11 +-
 .../src/tests/nakamoto_integrations.rs        | 195 +++++++++++++++++-
 10 files changed, 297 insertions(+), 87 deletions(-)

diff --git a/.github/workflows/bitcoin-tests.yml b/.github/workflows/bitcoin-tests.yml
index 069857ed44..64a1101e40 100644
--- a/.github/workflows/bitcoin-tests.yml
+++ b/.github/workflows/bitcoin-tests.yml
@@ -70,6 +70,7 @@ jobs:
           - tests::neon_integrations::use_latest_tip_integration_test
           - tests::should_succeed_handling_malformed_and_valid_txs
           - tests::nakamoto_integrations::simple_neon_integration
+          - tests::nakamoto_integrations::mine_multiple_per_tenure_integration
     steps:
       ## Setup test environment
       - name: Setup Test Environment
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index e4a6e5c01b..c99c6296d1 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -2,7 +2,6 @@ use std::collections::VecDeque;
 use std::sync::mpsc::Sender;
 use std::time::Duration;
 
-use backoff::default;
 use libsigner::{SignerRunLoop, StackerDBChunksEvent};
 use slog::{slog_debug, slog_error, slog_info, slog_warn};
 use stacks_common::{debug, error, info, warn};
diff --git a/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs b/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
index 0ed1bb0e03..7d1a2aec08 100644
--- a/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
+++ b/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
@@ -8,8 +8,6 @@ use async_h1::client;
 use async_std::io::ReadExt;
 use async_std::net::TcpStream;
 use base64::encode;
-#[cfg(test)]
-use clarity::vm::types::PrincipalData;
 use http_types::{Method, Request, Url};
 use serde::Serialize;
 use serde_json::json;
@@ -52,8 +50,6 @@ use stacks_common::deps_common::bitcoin::network::serialize::deserialize as btc_
 use stacks_common::deps_common::bitcoin::network::serialize::RawEncoder;
 use stacks_common::deps_common::bitcoin::util::hash::Sha256dHash;
 use stacks_common::types::chainstate::BurnchainHeaderHash;
-#[cfg(test)]
-use stacks_common::types::chainstate::StacksAddress;
 use stacks_common::util::hash::{hex_bytes, Hash160};
 use stacks_common::util::secp256k1::Secp256k1PublicKey;
 use stacks_common::util::sleep_ms;
diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index 72b208eb6f..e61c011e33 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -4,6 +4,7 @@ use std::fs;
 use std::net::{SocketAddr, ToSocketAddrs};
 use std::path::PathBuf;
 use std::sync::{Arc, Mutex};
+use std::time::Duration;
 
 use clarity::vm::costs::ExecutionCost;
 use clarity::vm::types::{AssetIdentifier, PrincipalData, QualifiedContractIdentifier};
@@ -1161,6 +1162,10 @@ impl Config {
                     .as_ref()
                     .map(|x| SelfSigner::from_seed(*x))
                     .or(miner_default_config.self_signing_key),
+                wait_on_interim_blocks: miner
+                    .wait_on_interim_blocks_ms
+                    .map(Duration::from_millis)
+                    .unwrap_or(miner_default_config.wait_on_interim_blocks),
             },
             None => miner_default_config,
         };
@@ -2166,7 +2171,7 @@ impl NodeConfig {
     }
 }
 
-#[derive(Clone, Debug, Default)]
+#[derive(Clone, Debug)]
 pub struct MinerConfig {
     pub min_tx_fee: u64,
     pub first_attempt_time_ms: u64,
@@ -2184,10 +2189,12 @@ pub struct MinerConfig {
     pub unprocessed_block_deadline_secs: u64,
     pub mining_key: Option<Secp256k1PrivateKey>,
     pub self_signing_key: Option<SelfSigner>,
+    /// Amount of time while mining in nakamoto to wait in between mining interim blocks
+    pub wait_on_interim_blocks: Duration,
 }
 
-impl MinerConfig {
-    pub fn default() -> MinerConfig {
+impl Default for MinerConfig {
+    fn default() -> MinerConfig {
         MinerConfig {
             min_tx_fee: 1,
             first_attempt_time_ms: 5_000,
@@ -2202,6 +2209,7 @@ impl MinerConfig {
             unprocessed_block_deadline_secs: 30,
             mining_key: None,
             self_signing_key: None,
+            wait_on_interim_blocks: Duration::from_millis(2_500),
         }
     }
 }
@@ -2311,6 +2319,7 @@ pub struct MinerConfigFile {
     pub unprocessed_block_deadline_secs: Option<u64>,
     pub mining_key: Option<String>,
     pub self_signing_seed: Option<u64>,
+    pub wait_on_interim_blocks_ms: Option<u64>,
 }
 
 #[derive(Clone, Deserialize, Default, Debug)]
diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index 0654e99fad..e9ffe0ed6f 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -20,10 +20,8 @@ use std::thread;
 use std::thread::{sleep, JoinHandle};
 use std::time::Duration;
 
-use clarity::boot_util::boot_code_id;
 use clarity::vm::ast::ASTRules;
-use clarity::vm::clarity::TransactionConnection;
-use clarity::vm::{ClarityVersion, Value as ClarityValue};
+use clarity::vm::Value as ClarityValue;
 use lazy_static::lazy_static;
 use stacks::burnchains::bitcoin::address::{
     BitcoinAddress, LegacyBitcoinAddress, LegacyBitcoinAddressType,
@@ -50,9 +48,6 @@ use stacks::chainstate::nakamoto::{
     NakamotoBlock, NakamotoBlockHeader, NakamotoChainState, SetupBlockResult,
 };
 use stacks::chainstate::stacks::address::PoxAddress;
-use stacks::chainstate::stacks::boot::{
-    BOOT_TEST_POX_4_AGG_KEY_CONTRACT, BOOT_TEST_POX_4_AGG_KEY_FNAME, POX_4_NAME,
-};
 use stacks::chainstate::stacks::db::{ChainStateBootData, ClarityTx, StacksChainState};
 use stacks::chainstate::stacks::miner::{
     BlockBuilder, BlockBuilderSettings, BlockLimitFunction, MinerStatus, TransactionResult,
@@ -87,7 +82,6 @@ use stacks_common::types::{PrivateKey, StacksEpochId};
 use stacks_common::util::hash::{to_hex, Hash160, MerkleTree, Sha512Trunc256Sum};
 use stacks_common::util::secp256k1::{MessageSignature, Secp256k1PublicKey};
 use stacks_common::util::vrf::{VRFPrivateKey, VRFProof, VRFPublicKey, VRF};
-use wsts::curve::point::Point;
 
 use self::signer::SelfSigner;
 use crate::globals::{NeonGlobals as Globals, RelayerDirective};
@@ -807,9 +801,6 @@ impl MockamotoNode {
         let miner_pk = Secp256k1PublicKey::from_private(&self.miner_key);
         let miner_pk_hash = Hash160::from_node_public_key(&miner_pk);
 
-        let miner_pk = Secp256k1PublicKey::from_private(&self.miner_key);
-        let miner_pk_hash = Hash160::from_node_public_key(&miner_pk);
-
         // Add a tenure change transaction to the block:
         //  as of now every mockamoto block is a tenure-change.
         // If mockamoto mode changes to support non-tenure-changing blocks, this will have
diff --git a/testnet/stacks-node/src/mockamoto/tests.rs b/testnet/stacks-node/src/mockamoto/tests.rs
index 2c7df7000f..c8f784a6a1 100644
--- a/testnet/stacks-node/src/mockamoto/tests.rs
+++ b/testnet/stacks-node/src/mockamoto/tests.rs
@@ -1,26 +1,20 @@
 use std::thread;
 use std::time::{Duration, Instant};
 
-use clarity::boot_util::boot_code_addr;
 use clarity::vm::costs::ExecutionCost;
-use clarity::vm::Value;
-use rand_core::OsRng;
 use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::nakamoto::NakamotoChainState;
-use stacks::chainstate::stacks::boot::POX_4_NAME;
 use stacks::chainstate::stacks::db::StacksChainState;
 use stacks_common::types::chainstate::{StacksAddress, StacksPrivateKey};
 use stacks_common::types::StacksEpochId;
 use stacks_common::util::get_epoch_time_secs;
 use stacks_common::util::hash::to_hex;
-use wsts::curve::point::Point;
-use wsts::curve::scalar::Scalar;
 
 use super::MockamotoNode;
 use crate::config::{EventKeyType, EventObserverConfig};
 use crate::neon_node::PeerThread;
 use crate::tests::neon_integrations::{submit_tx, test_observer};
-use crate::tests::{make_contract_call, make_stacks_transfer, to_addr};
+use crate::tests::{make_stacks_transfer, to_addr};
 use crate::{Config, ConfigFile};
 
 #[test]
@@ -260,16 +254,13 @@ fn observe_set_aggregate_key() {
 
     let globals = mockamoto.globals.clone();
 
-    let mut mempool = PeerThread::connect_mempool_db(&conf);
-    let (mut chainstate, _) = StacksChainState::open(
+    StacksChainState::open(
         conf.is_mainnet(),
         conf.burnchain.chain_id,
         &conf.get_chainstate_path_str(),
         None,
     )
     .unwrap();
-    let burnchain = conf.get_burnchain();
-    let sortdb = burnchain.open_sortition_db(true).unwrap();
     let sortition_tip = SortitionDB::get_canonical_burn_chain_tip(mockamoto.sortdb.conn()).unwrap();
 
     let start = Instant::now();
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index fd4919b44b..68f77d57d5 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -16,6 +16,7 @@
 use std::convert::TryFrom;
 use std::thread;
 use std::thread::JoinHandle;
+use std::time::{Duration, Instant};
 
 use clarity::vm::types::PrincipalData;
 use stacks::burnchains::{Burnchain, BurnchainParameters};
@@ -30,7 +31,6 @@ use stacks::chainstate::stacks::{
     TransactionPayload, TransactionVersion,
 };
 use stacks::core::FIRST_BURNCHAIN_CONSENSUS_HASH;
-use stacks::util_lib::db::Error as DBError;
 use stacks_common::types::chainstate::{StacksAddress, StacksBlockId};
 use stacks_common::types::{PrivateKey, StacksEpochId};
 use stacks_common::util::hash::Hash160;
@@ -44,6 +44,10 @@ use crate::run_loop::nakamoto::Globals;
 use crate::run_loop::RegisteredKey;
 use crate::{neon_node, ChainTip};
 
+/// If the miner was interrupted while mining a block, how long should the
+///  miner thread sleep before trying again?
+const ABORT_TRY_AGAIN_MS: u64 = 200;
+
 pub enum MinerDirective {
     /// The miner won sortition so they should begin a new tenure
     BeginTenure {
@@ -81,10 +85,8 @@ pub struct BlockMinerThread {
     keychain: Keychain,
     /// burnchain configuration
     burnchain: Burnchain,
-    /// Set of blocks that we have mined, but are still potentially-broadcastable
-    /// (copied from RelayerThread since we need the info to determine the strategy for mining the
-    /// next block during this tenure).
-    last_mined_blocks: Vec<NakamotoBlock>,
+    /// Set of blocks that we have mined
+    mined_blocks: Vec<NakamotoBlock>,
     /// Copy of the node's registered VRF key
     registered_key: RegisteredKey,
     /// Burnchain block snapshot which elected this miner
@@ -108,7 +110,7 @@ impl BlockMinerThread {
             globals: rt.globals.clone(),
             keychain: rt.keychain.clone(),
             burnchain: rt.burnchain.clone(),
-            last_mined_blocks: vec![],
+            mined_blocks: vec![],
             registered_key,
             burn_block,
             event_dispatcher: rt.event_dispatcher.clone(),
@@ -133,26 +135,57 @@ impl BlockMinerThread {
         }
 
         // now, actually run this tenure
-        let new_block = match self.mine_block() {
-            Ok(x) => x,
-            Err(e) => {
-                warn!("Failed to mine block: {e:?}");
-                return;
+        loop {
+            let new_block = loop {
+                match self.mine_block() {
+                    Ok(x) => break x,
+                    Err(NakamotoNodeError::MiningFailure(ChainstateError::MinerAborted)) => {
+                        info!("Miner interrupted while mining, will try again");
+                        // sleep, and try again. if the miner was interrupted because the burnchain
+                        // view changed, the next `mine_block()` invocation will error
+                        thread::sleep(Duration::from_millis(ABORT_TRY_AGAIN_MS));
+                        continue;
+                    }
+                    Err(e) => {
+                        warn!("Failed to mine block: {e:?}");
+                        return;
+                    }
+                }
+            };
+
+            if let Some(new_block) = new_block {
+                if let Some(self_signer) = self.config.self_signing() {
+                    if let Err(e) = self.self_sign_and_broadcast(self_signer, new_block.clone()) {
+                        warn!("Error self-signing block: {e:?}");
+                    } else {
+                        self.globals.coord().announce_new_stacks_block();
+                    }
+                } else {
+                    warn!("Not self-signing: nakamoto node does not support stacker-signer-protocol yet");
+                }
+
+                self.globals.counters.bump_naka_mined_blocks();
+                if self.mined_blocks.is_empty() {
+                    // this is the first block of the tenure, bump tenure counter
+                    self.globals.counters.bump_naka_mined_tenures();
+                }
+                self.mined_blocks.push(new_block);
             }
-        };
 
-        if let Some(self_signer) = self.config.self_signing() {
-            if let Err(e) = self.self_sign_and_broadcast(self_signer, new_block.clone()) {
-                warn!("Error self-signing block: {e:?}");
-            } else {
-                self.globals.coord().announce_new_stacks_block();
+            let wait_start = Instant::now();
+            let sort_db = SortitionDB::open(
+                &self.config.get_burn_db_file_path(),
+                true,
+                self.burnchain.pox_constants.clone(),
+            )
+            .expect("FATAL: could not open sortition DB");
+            while wait_start.elapsed() < self.config.miner.wait_on_interim_blocks {
+                thread::sleep(Duration::from_millis(ABORT_TRY_AGAIN_MS));
+                if self.check_burn_tip_changed(&sort_db).is_err() {
+                    return;
+                }
             }
-        } else {
-            warn!("Not self-signing: nakamoto node does not support stacker-signer-protocol yet");
         }
-
-        self.globals.counters.bump_naka_mined_blocks();
-        self.last_mined_blocks.push(new_block);
     }
 
     fn self_sign_and_broadcast(
@@ -378,9 +411,8 @@ impl BlockMinerThread {
     /// burnchain block-commit transaction.  If we succeed, then return the assembled block data as
     /// well as the microblock private key to use to produce microblocks.
     /// Return None if we couldn't build a block for whatever reason.
-    fn mine_block(&mut self) -> Result<NakamotoBlock, NakamotoNodeError> {
+    fn mine_block(&mut self) -> Result<Option<NakamotoBlock>, NakamotoNodeError> {
         debug!("block miner thread ID is {:?}", thread::current().id());
-        neon_node::fault_injection_long_tenure();
 
         let burn_db_path = self.config.get_burn_db_file_path();
 
@@ -390,6 +422,9 @@ impl BlockMinerThread {
             SortitionDB::open(&burn_db_path, true, self.burnchain.pox_constants.clone())
                 .expect("FATAL: could not open sortition DB");
 
+        self.check_burn_tip_changed(&burn_db)?;
+        neon_node::fault_injection_long_tenure();
+
         let mut chain_state = neon_node::open_chainstate_with_faults(&self.config)
             .expect("FATAL: could not open chainstate DB");
 
@@ -408,7 +443,7 @@ impl BlockMinerThread {
             .make_vrf_proof()
             .ok_or_else(|| NakamotoNodeError::BadVrfConstruction)?;
 
-        if self.last_mined_blocks.is_empty() {
+        if self.mined_blocks.is_empty() {
             if parent_block_info.parent_tenure.is_none() {
                 warn!(
                     "Miner should be starting a new tenure, but failed to load parent tenure info"
@@ -446,8 +481,11 @@ impl BlockMinerThread {
 
         parent_block_info.stacks_parent_header.microblock_tail = None;
 
+        let block_num = u64::try_from(self.mined_blocks.len())
+            .map_err(|_| NakamotoNodeError::UnexpectedChainState)?
+            .saturating_add(1);
         // build the block itself
-        let (mut block, _, _) = match NakamotoBlockBuilder::build_nakamoto_block(
+        let (mut block, _, _) = NakamotoBlockBuilder::build_nakamoto_block(
             &chain_state,
             &burn_db.index_conn(),
             &mut mem_pool,
@@ -461,19 +499,22 @@ impl BlockMinerThread {
             self.burn_block.total_burn,
             tenure_start_info,
             self.config.make_block_builder_settings(
-                // TODO: the attempt counter needs a different configuration approach in nakamoto
-                1,
+                block_num,
                 false,
                 self.globals.get_miner_status(),
             ),
             Some(&self.event_dispatcher),
-        ) {
-            Ok(block) => block,
-            Err(e) => {
-                error!("Relayer: Failure mining anchored block: {}", e);
-                return Err(NakamotoNodeError::MiningFailure(e));
+        )
+        .map_err(|e| {
+            if !matches!(e, ChainstateError::MinerAborted) {
+                error!("Relayer: Failure mining anchored block: {e}");
             }
-        };
+            NakamotoNodeError::MiningFailure(e)
+        })?;
+
+        if block.txs.is_empty() {
+            return Ok(None);
+        }
 
         let mining_key = self.keychain.get_nakamoto_sk();
         let miner_signature = mining_key
@@ -502,16 +543,22 @@ impl BlockMinerThread {
         // last chance -- confirm that the stacks tip is unchanged (since it could have taken long
         // enough to build this block that another block could have arrived), and confirm that all
         // Stacks blocks with heights higher than the canoincal tip are processed.
-        let cur_burn_chain_tip = SortitionDB::get_canonical_burn_chain_tip(burn_db.conn())
+        self.check_burn_tip_changed(&burn_db)?;
+        Ok(Some(block))
+    }
+
+    /// Check if the tenure needs to change -- if so, return a BurnchainTipChanged error
+    fn check_burn_tip_changed(&self, sortdb: &SortitionDB) -> Result<(), NakamotoNodeError> {
+        let cur_burn_chain_tip = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn())
             .expect("FATAL: failed to query sortition DB for canonical burn chain tip");
 
-        if cur_burn_chain_tip.consensus_hash != block.header.consensus_hash {
+        if cur_burn_chain_tip.consensus_hash != self.burn_block.consensus_hash {
             info!("Miner: Cancel block assembly; burnchain tip has changed");
             self.globals.counters.bump_missed_tenures();
-            return Err(NakamotoNodeError::BurnchainTipChanged);
+            Err(NakamotoNodeError::BurnchainTipChanged)
+        } else {
+            Ok(())
         }
-
-        Ok(block)
     }
 }
 
diff --git a/testnet/stacks-node/src/run_loop/nakamoto.rs b/testnet/stacks-node/src/run_loop/nakamoto.rs
index df93e79ea2..945e9fece0 100644
--- a/testnet/stacks-node/src/run_loop/nakamoto.rs
+++ b/testnet/stacks-node/src/run_loop/nakamoto.rs
@@ -19,10 +19,6 @@ use std::sync::{Arc, Mutex};
 use std::thread::JoinHandle;
 use std::{cmp, thread};
 
-use clarity::boot_util::boot_code_id;
-use clarity::vm::ast::ASTRules;
-use clarity::vm::clarity::TransactionConnection;
-use clarity::vm::ClarityVersion;
 use stacks::burnchains::bitcoin::address::{BitcoinAddress, LegacyBitcoinAddressType};
 use stacks::burnchains::Burnchain;
 use stacks::chainstate::burn::db::sortdb::SortitionDB;
@@ -31,12 +27,12 @@ use stacks::chainstate::coordinator::comm::{CoordinatorChannels, CoordinatorRece
 use stacks::chainstate::coordinator::{
     ChainsCoordinator, ChainsCoordinatorConfig, CoordinatorCommunication,
 };
-use stacks::chainstate::stacks::db::{ChainStateBootData, ClarityTx, StacksChainState};
+use stacks::chainstate::stacks::db::{ChainStateBootData, StacksChainState};
 use stacks::chainstate::stacks::miner::{signal_mining_blocked, signal_mining_ready, MinerStatus};
 use stacks::core::StacksEpochId;
 use stacks::net::atlas::{AtlasConfig, AtlasDB, Attachment};
 use stacks_common::types::PublicKey;
-use stacks_common::util::hash::{to_hex, Hash160};
+use stacks_common::util::hash::Hash160;
 use stx_genesis::GenesisData;
 
 use crate::burnchains::make_bitcoin_indexer;
diff --git a/testnet/stacks-node/src/run_loop/neon.rs b/testnet/stacks-node/src/run_loop/neon.rs
index d3053415d9..f04874110b 100644
--- a/testnet/stacks-node/src/run_loop/neon.rs
+++ b/testnet/stacks-node/src/run_loop/neon.rs
@@ -6,10 +6,6 @@ use std::sync::{Arc, Mutex};
 use std::thread::JoinHandle;
 use std::{cmp, thread};
 
-use clarity::boot_util::boot_code_id;
-use clarity::vm::ast::ASTRules;
-use clarity::vm::clarity::TransactionConnection;
-use clarity::vm::ClarityVersion;
 use libc;
 use stacks::burnchains::bitcoin::address::{BitcoinAddress, LegacyBitcoinAddressType};
 use stacks::burnchains::Burnchain;
@@ -73,6 +69,7 @@ pub struct Counters {
     pub naka_submitted_vrfs: RunLoopCounter,
     pub naka_submitted_commits: RunLoopCounter,
     pub naka_mined_blocks: RunLoopCounter,
+    pub naka_mined_tenures: RunLoopCounter,
 }
 
 impl Counters {
@@ -87,6 +84,7 @@ impl Counters {
             naka_submitted_vrfs: RunLoopCounter::new(AtomicU64::new(0)),
             naka_submitted_commits: RunLoopCounter::new(AtomicU64::new(0)),
             naka_mined_blocks: RunLoopCounter::new(AtomicU64::new(0)),
+            naka_mined_tenures: RunLoopCounter::new(AtomicU64::new(0)),
         }
     }
 
@@ -101,6 +99,7 @@ impl Counters {
             naka_submitted_vrfs: (),
             naka_submitted_commits: (),
             naka_mined_blocks: (),
+            naka_mined_tenures: (),
         }
     }
 
@@ -152,6 +151,10 @@ impl Counters {
         Counters::inc(&self.naka_mined_blocks);
     }
 
+    pub fn bump_naka_mined_tenures(&self) {
+        Counters::inc(&self.naka_mined_tenures);
+    }
+
     pub fn set_microblocks_processed(&self, value: u64) {
         Counters::set(&self.microblocks_processed, value)
     }
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 6666b1eac9..31204f28f0 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -220,8 +220,19 @@ fn next_block_and_mine_commit(
     let commits_before = commits_submitted.load(Ordering::SeqCst);
     let mut block_processed_time: Option<Instant> = None;
     next_block_and(btc_controller, timeout_secs, || {
-        if let Some(block_processed_time) = block_processed_time.as_ref() {
-            let commits_sent = commits_submitted.load(Ordering::SeqCst);
+        let commits_sent = commits_submitted.load(Ordering::SeqCst);
+        let blocks_processed = coord_channels
+            .lock()
+            .expect("Mutex poisoned")
+            .get_stacks_blocks_processed();
+
+        if blocks_processed > blocks_processed_before && block_processed_time.is_none() {
+            block_processed_time.replace(Instant::now());
+        }
+        if blocks_processed > blocks_processed_before {
+            let block_processed_time = block_processed_time
+                .as_ref()
+                .ok_or("TEST-ERROR: Processed time wasn't set")?;
             if commits_sent >= commits_before + 2 {
                 return Ok(true);
             }
@@ -232,13 +243,6 @@ fn next_block_and_mine_commit(
             }
             Ok(false)
         } else {
-            let blocks_processed = coord_channels
-                .lock()
-                .expect("Mutex poisoned")
-                .get_stacks_blocks_processed();
-            if blocks_processed > blocks_processed_before {
-                block_processed_time.replace(Instant::now());
-            }
             Ok(false)
         }
     })
@@ -326,6 +330,7 @@ fn simple_neon_integration() {
     }
 
     let (mut naka_conf, _miner_account) = naka_neon_integration_conf(None);
+    naka_conf.miner.wait_on_interim_blocks = Duration::from_secs(1000);
     let sender_sk = Secp256k1PrivateKey::new();
     // setup sender + recipient for a test stx transfer
     let sender_addr = tests::to_addr(&sender_sk);
@@ -490,3 +495,175 @@ fn simple_neon_integration() {
 
     run_loop_thread.join().unwrap();
 }
+
+#[test]
+#[ignore]
+/// This test spins up a nakamoto-neon node.
+/// It starts in Epoch 2.0, mines with `neon_node` to Epoch 3.0, and then switches
+///  to Nakamoto operation (activating pox-4 by submitting a stack-stx tx). The BootLoop
+///  struct handles the epoch-2/3 tear-down and spin-up.
+/// This test makes three assertions:
+///  * 10 tenures are mined after 3.0 starts
+///  * Each tenure has 2 blocks
+fn mine_multiple_per_tenure_integration() {
+    if env::var("BITCOIND_TEST") != Ok("1".into()) {
+        return;
+    }
+
+    let (mut naka_conf, _miner_account) = naka_neon_integration_conf(None);
+    naka_conf.miner.wait_on_interim_blocks = Duration::from_secs(5);
+    let sender_sk = Secp256k1PrivateKey::new();
+    // setup sender + recipient for a test stx transfer
+    let tenure_count = 10;
+    let sender_addr = tests::to_addr(&sender_sk);
+    let send_amt = 1000;
+    let send_fee = 100;
+    naka_conf.add_initial_balance(
+        PrincipalData::from(sender_addr.clone()).to_string(),
+        (send_amt + send_fee) * tenure_count,
+    );
+    let recipient = PrincipalData::from(StacksAddress::burn_address(false));
+    let stacker_sk = setup_stacker(&mut naka_conf);
+
+    test_observer::spawn();
+    let observer_port = test_observer::EVENT_OBSERVER_PORT;
+    naka_conf.events_observers.insert(EventObserverConfig {
+        endpoint: format!("localhost:{observer_port}"),
+        events_keys: vec![EventKeyType::AnyEvent],
+    });
+
+    let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone());
+    btcd_controller
+        .start_bitcoind()
+        .expect("Failed starting bitcoind");
+    let mut btc_regtest_controller = BitcoinRegtestController::new(naka_conf.clone(), None);
+    btc_regtest_controller.bootstrap_chain(201);
+
+    let mut run_loop = boot_nakamoto::BootRunLoop::new(naka_conf.clone()).unwrap();
+    let run_loop_stopper = run_loop.get_termination_switch();
+    let Counters {
+        blocks_processed,
+        naka_submitted_vrfs: vrfs_submitted,
+        naka_submitted_commits: commits_submitted,
+        ..
+    } = run_loop.counters();
+
+    let coord_channel = run_loop.coordinator_channels();
+
+    let run_loop_thread = thread::Builder::new()
+        .name("run_loop".into())
+        .spawn(move || run_loop.start(None, 0))
+        .unwrap();
+    wait_for_runloop(&blocks_processed);
+    boot_to_epoch_3(
+        &naka_conf,
+        &blocks_processed,
+        stacker_sk,
+        &mut btc_regtest_controller,
+    );
+
+    info!("Bootstrapped to Epoch-3.0 boundary, starting nakamoto miner");
+
+    let burnchain = naka_conf.get_burnchain();
+    let sortdb = burnchain.open_sortition_db(true).unwrap();
+    let (mut chainstate, _) = StacksChainState::open(
+        naka_conf.is_mainnet(),
+        naka_conf.burnchain.chain_id,
+        &naka_conf.get_chainstate_path_str(),
+        None,
+    )
+    .unwrap();
+
+    let block_height_pre_3_0 =
+        NakamotoChainState::get_canonical_block_header(chainstate.db(), &sortdb)
+            .unwrap()
+            .unwrap()
+            .stacks_block_height;
+
+    info!("Nakamoto miner started...");
+    // first block wakes up the run loop, wait until a key registration has been submitted.
+    next_block_and(&mut btc_regtest_controller, 60, || {
+        let vrf_count = vrfs_submitted.load(Ordering::SeqCst);
+        Ok(vrf_count >= 1)
+    })
+    .unwrap();
+
+    // second block should confirm the VRF register, wait until a block commit is submitted
+    next_block_and(&mut btc_regtest_controller, 60, || {
+        let commits_count = commits_submitted.load(Ordering::SeqCst);
+        Ok(commits_count >= 1)
+    })
+    .unwrap();
+
+    // Mine 10 nakamoto tenures
+    for sender_nonce in 0..tenure_count {
+        next_block_and_mine_commit(
+            &mut btc_regtest_controller,
+            60,
+            &coord_channel,
+            &commits_submitted,
+        )
+        .unwrap();
+
+        let blocks_processed_before = coord_channel
+            .lock()
+            .expect("Mutex poisoned")
+            .get_stacks_blocks_processed();
+
+        // submit a tx so that the miner will mine an extra block
+        let transfer_tx =
+            make_stacks_transfer(&sender_sk, sender_nonce, send_fee, &recipient, send_amt);
+        // let transfer_tx_hex = format!("0x{}", to_hex(&transfer_tx));
+        let tip = NakamotoChainState::get_canonical_block_header(chainstate.db(), &sortdb)
+            .unwrap()
+            .unwrap();
+
+        let mut mempool = naka_conf
+            .connect_mempool_db()
+            .expect("Database failure opening mempool");
+
+        mempool
+            .submit_raw(
+                &mut chainstate,
+                &sortdb,
+                &tip.consensus_hash,
+                &tip.anchored_header.block_hash(),
+                transfer_tx.clone(),
+                &ExecutionCost::max_value(),
+                &StacksEpochId::Epoch30,
+            )
+            .unwrap();
+
+        loop {
+            let blocks_processed = coord_channel
+                .lock()
+                .expect("Mutex poisoned")
+                .get_stacks_blocks_processed();
+            if blocks_processed > blocks_processed_before {
+                break;
+            }
+            thread::sleep(Duration::from_millis(100));
+        }
+    }
+
+    // load the chain tip, and assert that it is a nakamoto block and at least 30 blocks have advanced in epoch 3
+    let tip = NakamotoChainState::get_canonical_block_header(chainstate.db(), &sortdb)
+        .unwrap()
+        .unwrap();
+    info!(
+        "Latest tip";
+        "height" => tip.stacks_block_height,
+        "is_nakamoto" => tip.anchored_header.as_stacks_nakamoto().is_some(),
+    );
+
+    assert!(tip.anchored_header.as_stacks_nakamoto().is_some());
+    assert!(tip.stacks_block_height >= block_height_pre_3_0 + 20);
+
+    coord_channel
+        .lock()
+        .expect("Mutex poisoned")
+        .stop_chains_coordinator();
+    run_loop_stopper.store(false, Ordering::SeqCst);
+
+    run_loop_thread.join().unwrap();
+}

From c3584279c3e48b4bcd8519756c6f44c4f15f0df2 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Mon, 18 Dec 2023 15:58:28 -0600
Subject: [PATCH 0232/1166] refactor: nakamoto::miner interface to match usage

---
 stackslib/src/chainstate/nakamoto/miner.rs    | 355 ++++--------------
 .../src/chainstate/nakamoto/tests/node.rs     |  86 ++++-
 .../stacks-node/src/nakamoto_node/miner.rs    |   5 -
 3 files changed, 148 insertions(+), 298 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/miner.rs b/stackslib/src/chainstate/nakamoto/miner.rs
index 2a0799ae71..66d723652b 100644
--- a/stackslib/src/chainstate/nakamoto/miner.rs
+++ b/stackslib/src/chainstate/nakamoto/miner.rs
@@ -53,8 +53,8 @@ use crate::chainstate::stacks::db::transactions::{
     handle_clarity_runtime_error, ClarityRuntimeTxError,
 };
 use crate::chainstate::stacks::db::{
-    ChainstateTx, ClarityTx, MinerRewardInfo, StacksChainState, StacksHeaderInfo,
-    MINER_REWARD_MATURITY,
+    ChainstateTx, ClarityTx, MinerRewardInfo, StacksBlockHeaderTypes, StacksChainState,
+    StacksHeaderInfo, MINER_REWARD_MATURITY,
 };
 use crate::chainstate::stacks::events::{StacksTransactionEvent, StacksTransactionReceipt};
 use crate::chainstate::stacks::miner::{
@@ -99,22 +99,18 @@ impl NakamotoTenureInfo {
 }
 
 pub struct NakamotoBlockBuilder {
-    /// if this is building atop an epoch 2 block, then this is that block's header
-    epoch2_parent_header: Option<(StacksBlockHeader, ConsensusHash)>,
-    /// if this is building atop an epoch 3 block, then this is that block's header
-    nakamoto_parent_header: Option<NakamotoBlockHeader>,
+    /// If there's a parent (i.e., not a genesis), this is Some(parent_header)    
+    parent_header: Option<StacksHeaderInfo>,
     /// Signed coinbase tx, if starting a new tenure
     coinbase_tx: Option<StacksTransaction>,
     /// Tenure change tx, if starting or extending a tenure
     tenure_tx: Option<StacksTransaction>,
     /// Total burn this block represents
     total_burn: u64,
-    /// parent block-commit hash value
-    parent_commit_hash_value: BlockHeaderHash,
     /// Matured miner rewards to process, if any.
     matured_miner_rewards_opt: Option<MaturedMinerRewards>,
     /// bytes of space consumed so far
-    bytes_so_far: u64,
+    pub bytes_so_far: u64,
     /// transactions selected
     txs: Vec<StacksTransaction>,
     /// header we're filling in
@@ -138,102 +134,16 @@ pub struct MinerTenureInfo<'a> {
 }
 
 impl NakamotoBlockBuilder {
-    /// Make a block builder atop a Nakamoto parent for a new tenure
-    pub fn new_tenure_from_nakamoto_parent(
-        parent_tenure_id: &StacksBlockId,
-        parent: &NakamotoBlockHeader,
-        tenure_id_consensus_hash: &ConsensusHash,
-        total_burn: u64,
-        tenure_change: &StacksTransaction,
-        coinbase: &StacksTransaction,
-    ) -> NakamotoBlockBuilder {
-        let parent_commit_hash_value = BlockHeaderHash(parent_tenure_id.0.clone());
-        NakamotoBlockBuilder {
-            epoch2_parent_header: None,
-            nakamoto_parent_header: Some(parent.clone()),
-            total_burn,
-            coinbase_tx: Some(coinbase.clone()),
-            tenure_tx: Some(tenure_change.clone()),
-            parent_commit_hash_value,
-            matured_miner_rewards_opt: None,
-            bytes_so_far: 0,
-            txs: vec![],
-            header: NakamotoBlockHeader::from_parent_empty(
-                parent.chain_length + 1,
-                total_burn,
-                tenure_id_consensus_hash.clone(),
-                parent.block_id(),
-            ),
-        }
-    }
-
-    /// Make a block builder atop a Nakamoto parent for a new block within a tenure
-    pub fn continue_tenure_from_nakamoto_parent(
-        parent: &NakamotoBlockHeader,
-        tenure_id_consensus_hash: &ConsensusHash,
-        total_burn: u64,
-        tenure_extend: Option<&StacksTransaction>,
-    ) -> NakamotoBlockBuilder {
-        let parent_commit_hash_value = BlockHeaderHash(parent.block_id().0.clone());
-        NakamotoBlockBuilder {
-            epoch2_parent_header: None,
-            nakamoto_parent_header: Some(parent.clone()),
-            total_burn,
-            coinbase_tx: None,
-            tenure_tx: tenure_extend.cloned(),
-            parent_commit_hash_value,
-            matured_miner_rewards_opt: None,
-            bytes_so_far: 0,
-            txs: vec![],
-            header: NakamotoBlockHeader::from_parent_empty(
-                parent.chain_length + 1,
-                total_burn,
-                tenure_id_consensus_hash.clone(),
-                parent.block_id(),
-            ),
-        }
-    }
-
-    /// Make a block builder atop an epoch 2 parent for a new tenure
-    pub fn new_tenure_from_epoch2_parent(
-        parent: &StacksBlockHeader,
-        parent_tenure_id_consensus_hash: &ConsensusHash,
-        tenure_id_consensus_hash: &ConsensusHash,
-        total_burn: u64,
-        tenure_change: &StacksTransaction,
-        coinbase: &StacksTransaction,
-    ) -> NakamotoBlockBuilder {
-        NakamotoBlockBuilder {
-            epoch2_parent_header: Some((parent.clone(), parent_tenure_id_consensus_hash.clone())),
-            nakamoto_parent_header: None,
-            total_burn,
-            coinbase_tx: Some(coinbase.clone()),
-            tenure_tx: Some(tenure_change.clone()),
-            parent_commit_hash_value: parent.block_hash(),
-            matured_miner_rewards_opt: None,
-            bytes_so_far: 0,
-            txs: vec![],
-            header: NakamotoBlockHeader::from_parent_empty(
-                parent.total_work.work + 1,
-                total_burn,
-                tenure_id_consensus_hash.clone(),
-                StacksBlockId::new(parent_tenure_id_consensus_hash, &parent.block_hash()),
-            ),
-        }
-    }
-
     /// Make a block builder from genesis (testing only)
-    pub fn new_tenure_from_genesis(
+    pub fn new_first_block(
         tenure_change: &StacksTransaction,
         coinbase: &StacksTransaction,
     ) -> NakamotoBlockBuilder {
         NakamotoBlockBuilder {
-            epoch2_parent_header: None,
-            nakamoto_parent_header: None,
+            parent_header: None,
             total_burn: 0,
             coinbase_tx: Some(coinbase.clone()),
             tenure_tx: Some(tenure_change.clone()),
-            parent_commit_hash_value: FIRST_STACKS_BLOCK_HASH.clone(),
             matured_miner_rewards_opt: None,
             bytes_so_far: 0,
             txs: vec![],
@@ -242,72 +152,59 @@ impl NakamotoBlockBuilder {
     }
 
     /// Make a Nakamoto block builder appropriate for building atop the given block header
-    pub fn new_from_parent(
-        // tenure ID -- this is the index block hash of the start block of the last tenure (i.e.
-        // the data we committed to in the block-commit).  If this is an epoch 2.x parent, then
-        // this is just the index block hash of the parent Stacks block.
-        parent_tenure_id: &StacksBlockId,
-        // Stacks header we're building off of.
+    ///
+    /// * `parent_stacker_header` - the stacks header this builder's block will build off
+    ///
+    /// * `tenure_id_consensus_hash` - consensus hash of this tenure's burnchain block.
+    ///    This is the consensus hash that goes into the block header.
+    ///
+    /// * `total_burn` - total BTC burnt so far in this fork.
+    ///
+    /// * `tenure_change` - the TenureChange tx if this is going to start or
+    ///    extend a tenure
+    ///
+    /// * `coinbase` - the coinbase tx if this is going to start a new tenure
+    ///
+    pub fn new(
         parent_stacks_header: &StacksHeaderInfo,
-        // consensus hash of this tenure's burnchain block. This is the consensus hash that goes
-        // into the block header.
         tenure_id_consensus_hash: &ConsensusHash,
-        // total BTC burn so far
         total_burn: u64,
-        // tenure change, if we're starting or extending a tenure
         tenure_change: Option<&StacksTransaction>,
-        // coinbase, if we're starting a new tenure
         coinbase: Option<&StacksTransaction>,
     ) -> Result<NakamotoBlockBuilder, Error> {
-        let builder = if let Some(parent_nakamoto_header) =
-            parent_stacks_header.anchored_header.as_stacks_nakamoto()
-        {
-            // building atop a nakamoto block
-            // new tenure?
-            if coinbase.is_some() && tenure_change.is_some() {
-                NakamotoBlockBuilder::new_tenure_from_nakamoto_parent(
-                    parent_tenure_id,
-                    parent_nakamoto_header,
-                    tenure_id_consensus_hash,
-                    total_burn,
-                    tenure_change.ok_or(Error::ExpectedTenureChange)?,
-                    coinbase.ok_or(Error::ExpectedTenureChange)?,
-                )
-            } else {
-                NakamotoBlockBuilder::continue_tenure_from_nakamoto_parent(
-                    parent_nakamoto_header,
-                    tenure_id_consensus_hash,
-                    total_burn,
-                    tenure_change,
-                )
-            }
-        } else if let Some(parent_epoch2_header) =
-            parent_stacks_header.anchored_header.as_stacks_epoch2()
-        {
+        let next_height = parent_stacks_header
+            .anchored_header
+            .height()
+            .checked_add(1)
+            .ok_or_else(|| Error::InvalidStacksBlock("Block height exceeded u64".into()))?;
+        if matches!(
+            parent_stacks_header.anchored_header,
+            StacksBlockHeaderTypes::Epoch2(_)
+        ) {
             // building atop a stacks 2.x block.
             // we are necessarily starting a new tenure
-            if tenure_change.is_some() && coinbase.is_some() {
-                NakamotoBlockBuilder::new_tenure_from_epoch2_parent(
-                    parent_epoch2_header,
-                    &parent_stacks_header.consensus_hash,
-                    tenure_id_consensus_hash,
-                    total_burn,
-                    tenure_change.ok_or(Error::ExpectedTenureChange)?,
-                    coinbase.ok_or(Error::ExpectedTenureChange)?,
-                )
-            } else {
+            if tenure_change.is_none() || coinbase.is_none() {
                 // not allowed
                 warn!("Failed to start a Nakamoto tenure atop a Stacks 2.x block -- missing a coinbase and/or tenure");
                 return Err(Error::ExpectedTenureChange);
             }
-        } else {
-            // not reachable -- no other choices
-            return Err(Error::InvalidStacksBlock(
-                "Parent is neither a Nakamoto block nor a Stacks 2.x block".into(),
-            ));
-        };
+        }
 
-        Ok(builder)
+        Ok(NakamotoBlockBuilder {
+            parent_header: Some(parent_stacks_header.clone()),
+            total_burn,
+            coinbase_tx: coinbase.cloned(),
+            tenure_tx: tenure_change.cloned(),
+            matured_miner_rewards_opt: None,
+            bytes_so_far: 0,
+            txs: vec![],
+            header: NakamotoBlockHeader::from_parent_empty(
+                next_height,
+                total_burn,
+                tenure_id_consensus_hash.clone(),
+                parent_stacks_header.index_block_hash(),
+            ),
+        })
     }
 
     /// This function should be called before `tenure_begin`.
@@ -330,74 +227,36 @@ impl NakamotoBlockBuilder {
 
         let mainnet = chainstate.config().mainnet;
 
-        let (chain_tip, parent_tenure_id_consensus_hash, parent_header_hash) =
-            if let Some(nakamoto_parent_header) = self.nakamoto_parent_header.as_ref() {
-                // parent is a nakamoto block
-                let parent_header_info = NakamotoChainState::get_block_header(
-                    chainstate.db(),
-                    &StacksBlockId::new(
-                        &nakamoto_parent_header.consensus_hash,
-                        &nakamoto_parent_header.block_hash(),
-                    ),
-                )?
-                .ok_or(Error::NoSuchBlockError)
-                .map_err(|e| {
-                    warn!(
-                        "No such Nakamoto parent block {}/{} ({})",
-                        &nakamoto_parent_header.consensus_hash,
-                        &nakamoto_parent_header.block_hash(),
-                        &nakamoto_parent_header.block_id()
-                    );
-                    e
-                })?;
-
-                (
-                    parent_header_info,
-                    nakamoto_parent_header.consensus_hash.clone(),
-                    nakamoto_parent_header.block_hash(),
-                )
-            } else if let Some((stacks_header, consensus_hash)) = self.epoch2_parent_header.as_ref()
-            {
-                // parent is a Stacks epoch2 block
-                let parent_header_info = NakamotoChainState::get_block_header(
-                    chainstate.db(),
-                    &StacksBlockId::new(consensus_hash, &stacks_header.block_hash()),
-                )?
-                .ok_or(Error::NoSuchBlockError)
-                .map_err(|e| {
-                    warn!(
-                        "No such Stacks 2.x parent block {}/{} ({})",
-                        &consensus_hash,
-                        &stacks_header.block_hash(),
-                        &StacksBlockId::new(&consensus_hash, &stacks_header.block_hash())
-                    );
-                    e
-                })?;
-
-                (
-                    parent_header_info,
-                    consensus_hash.clone(),
-                    stacks_header.block_hash(),
-                )
-            } else {
+        let (chain_tip, parent_consensus_hash, parent_header_hash) = match self.parent_header {
+            Some(ref header_info) => (
+                header_info.clone(),
+                header_info.consensus_hash.clone(),
+                header_info.anchored_header.block_hash(),
+            ),
+            None => {
                 // parent is genesis (testing only)
                 (
                     StacksHeaderInfo::regtest_genesis(),
                     FIRST_BURNCHAIN_CONSENSUS_HASH.clone(),
                     FIRST_STACKS_BLOCK_HASH.clone(),
                 )
-            };
+            }
+        };
 
-        let coinbase_height = if let Ok(Some(parent_coinbase_height)) =
-            NakamotoChainState::get_coinbase_height(
-                chainstate.db(),
-                &StacksBlockId::new(&parent_tenure_id_consensus_hash, &parent_header_hash),
-            ) {
+        let parent_block_id = StacksBlockId::new(&parent_consensus_hash, &parent_header_hash);
+        let parent_coinbase_height =
+            NakamotoChainState::get_coinbase_height(chainstate.db(), &parent_block_id)
+                .ok()
+                .flatten()
+                .unwrap_or(0);
+
+        let new_tenure = cause == Some(TenureChangeCause::BlockFound);
+        let coinbase_height = if new_tenure {
             parent_coinbase_height
                 .checked_add(1)
                 .expect("Blockchain overflow")
         } else {
-            0
+            parent_coinbase_height
         };
 
         // data won't be committed, so do a concurrent transaction
@@ -409,7 +268,7 @@ impl NakamotoBlockBuilder {
             burn_tip,
             burn_tip_height,
             mainnet,
-            parent_consensus_hash: parent_tenure_id_consensus_hash,
+            parent_consensus_hash,
             parent_header_hash,
             parent_stacks_block_height: chain_tip.stacks_block_height,
             parent_burn_block_height: chain_tip.burn_header_height,
@@ -526,9 +385,6 @@ impl NakamotoBlockBuilder {
         chainstate_handle: &StacksChainState,
         burn_dbconn: &SortitionDBConn,
         mempool: &mut MemPoolDB,
-        // tenure ID -- this is the index block hash of the start block of the last tenure (i.e.
-        // the data we committed to in the block-commit)
-        parent_tenure_id: &StacksBlockId,
         // Stacks header we're building off of.
         parent_stacks_header: &StacksHeaderInfo,
         // tenure ID consensus hash of this block
@@ -552,8 +408,7 @@ impl NakamotoBlockBuilder {
 
         let (mut chainstate, _) = chainstate_handle.reopen()?;
 
-        let mut builder = NakamotoBlockBuilder::new_from_parent(
-            parent_tenure_id,
+        let mut builder = NakamotoBlockBuilder::new(
             parent_stacks_header,
             tenure_id_consensus_hash,
             total_burn,
@@ -639,80 +494,6 @@ impl NakamotoBlockBuilder {
 
         Ok((block, consumed, size))
     }
-
-    #[cfg(test)]
-    pub fn make_nakamoto_block_from_txs(
-        mut self,
-        chainstate_handle: &StacksChainState,
-        burn_dbconn: &SortitionDBConn,
-        mut txs: Vec<StacksTransaction>,
-    ) -> Result<(NakamotoBlock, u64, ExecutionCost), Error> {
-        debug!("Build Nakamoto block from {} transactions", txs.len());
-        let (mut chainstate, _) = chainstate_handle.reopen()?;
-
-        let mut tenure_cause = None;
-        for tx in txs.iter() {
-            let TransactionPayload::TenureChange(payload) = &tx.payload else {
-                continue;
-            };
-            tenure_cause = Some(payload.cause);
-            break;
-        }
-
-        let mut miner_tenure_info =
-            self.load_tenure_info(&mut chainstate, burn_dbconn, tenure_cause)?;
-        let mut tenure_tx = self.tenure_begin(burn_dbconn, &mut miner_tenure_info)?;
-        for tx in txs.drain(..) {
-            let tx_len = tx.tx_len();
-            match self.try_mine_tx_with_len(
-                &mut tenure_tx,
-                &tx,
-                tx_len,
-                &BlockLimitFunction::NO_LIMIT_HIT,
-                ASTRules::PrecheckSize,
-            ) {
-                TransactionResult::Success(..) => {
-                    debug!("Included {}", &tx.txid());
-                }
-                TransactionResult::Skipped(TransactionSkipped { error, .. })
-                | TransactionResult::ProcessingError(TransactionError { error, .. }) => {
-                    match error {
-                        Error::BlockTooBigError => {
-                            // done mining -- our execution budget is exceeded.
-                            // Make the block from the transactions we did manage to get
-                            debug!("Block budget exceeded on tx {}", &tx.txid());
-                        }
-                        Error::InvalidStacksTransaction(_emsg, true) => {
-                            // if we have an invalid transaction that was quietly ignored, don't warn here either
-                            test_debug!(
-                                "Failed to apply tx {}: InvalidStacksTransaction '{:?}'",
-                                &tx.txid(),
-                                &_emsg
-                            );
-                            continue;
-                        }
-                        Error::ProblematicTransaction(txid) => {
-                            test_debug!("Encountered problematic transaction. Aborting");
-                            return Err(Error::ProblematicTransaction(txid));
-                        }
-                        e => {
-                            warn!("Failed to apply tx {}: {:?}", &tx.txid(), &e);
-                            continue;
-                        }
-                    }
-                }
-                TransactionResult::Problematic(TransactionProblematic { tx, .. }) => {
-                    // drop from the mempool
-                    debug!("Encountered problematic transaction {}", &tx.txid());
-                    return Err(Error::ProblematicTransaction(tx.txid()));
-                }
-            }
-        }
-        let block = self.mine_nakamoto_block(&mut tenure_tx);
-        let size = self.bytes_so_far;
-        let cost = self.tenure_finish(tenure_tx);
-        Ok((block, size, cost))
-    }
 }
 
 impl BlockBuilder for NakamotoBlockBuilder {
diff --git a/stackslib/src/chainstate/nakamoto/tests/node.rs b/stackslib/src/chainstate/nakamoto/tests/node.rs
index 73ef55c360..e1a12230f8 100644
--- a/stackslib/src/chainstate/nakamoto/tests/node.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/node.rs
@@ -555,8 +555,7 @@ impl TestStacksNode {
 
             // make a block
             let builder = if let Some(parent_tip) = parent_tip_opt {
-                NakamotoBlockBuilder::new_from_parent(
-                    &parent_tip.index_block_hash(),
+                NakamotoBlockBuilder::new(
                     &parent_tip,
                     tenure_id_consensus_hash,
                     burn_tip.total_burn,
@@ -573,7 +572,7 @@ impl TestStacksNode {
                 )
                 .unwrap()
             } else {
-                NakamotoBlockBuilder::new_tenure_from_genesis(
+                NakamotoBlockBuilder::new_first_block(
                     &tenure_change.clone().unwrap(),
                     &coinbase.clone().unwrap(),
                 )
@@ -582,9 +581,9 @@ impl TestStacksNode {
             tenure_change = None;
             coinbase = None;
 
-            let (mut nakamoto_block, size, cost) = builder
-                .make_nakamoto_block_from_txs(chainstate, &sortdb.index_conn(), txs)
-                .unwrap();
+            let (mut nakamoto_block, size, cost) =
+                Self::make_nakamoto_block_from_txs(builder, chainstate, &sortdb.index_conn(), txs)
+                    .unwrap();
             miner.sign_nakamoto_block(&mut nakamoto_block);
             signers.sign_nakamoto_block(&mut nakamoto_block);
 
@@ -638,6 +637,81 @@ impl TestStacksNode {
         }
         blocks
     }
+
+    pub fn make_nakamoto_block_from_txs(
+        mut builder: NakamotoBlockBuilder,
+        chainstate_handle: &StacksChainState,
+        burn_dbconn: &SortitionDBConn,
+        mut txs: Vec<StacksTransaction>,
+    ) -> Result<(NakamotoBlock, u64, ExecutionCost), ChainstateError> {
+        use clarity::vm::ast::ASTRules;
+
+        debug!("Build Nakamoto block from {} transactions", txs.len());
+        let (mut chainstate, _) = chainstate_handle.reopen()?;
+
+        let mut tenure_cause = None;
+        for tx in txs.iter() {
+            let TransactionPayload::TenureChange(payload) = &tx.payload else {
+                continue;
+            };
+            tenure_cause = Some(payload.cause);
+            break;
+        }
+
+        let mut miner_tenure_info =
+            builder.load_tenure_info(&mut chainstate, burn_dbconn, tenure_cause)?;
+        let mut tenure_tx = builder.tenure_begin(burn_dbconn, &mut miner_tenure_info)?;
+        for tx in txs.drain(..) {
+            let tx_len = tx.tx_len();
+            match builder.try_mine_tx_with_len(
+                &mut tenure_tx,
+                &tx,
+                tx_len,
+                &BlockLimitFunction::NO_LIMIT_HIT,
+                ASTRules::PrecheckSize,
+            ) {
+                TransactionResult::Success(..) => {
+                    debug!("Included {}", &tx.txid());
+                }
+                TransactionResult::Skipped(TransactionSkipped { error, .. })
+                | TransactionResult::ProcessingError(TransactionError { error, .. }) => {
+                    match error {
+                        ChainstateError::BlockTooBigError => {
+                            // done mining -- our execution budget is exceeded.
+                            // Make the block from the transactions we did manage to get
+                            debug!("Block budget exceeded on tx {}", &tx.txid());
+                        }
+                        ChainstateError::InvalidStacksTransaction(_emsg, true) => {
+                            // if we have an invalid transaction that was quietly ignored, don't warn here either
+                            test_debug!(
+                                "Failed to apply tx {}: InvalidStacksTransaction '{:?}'",
+                                &tx.txid(),
+                                &_emsg
+                            );
+                            continue;
+                        }
+                        ChainstateError::ProblematicTransaction(txid) => {
+                            test_debug!("Encountered problematic transaction. Aborting");
+                            return Err(ChainstateError::ProblematicTransaction(txid));
+                        }
+                        e => {
+                            warn!("Failed to apply tx {}: {:?}", &tx.txid(), &e);
+                            continue;
+                        }
+                    }
+                }
+                TransactionResult::Problematic(TransactionProblematic { tx, .. }) => {
+                    // drop from the mempool
+                    debug!("Encountered problematic transaction {}", &tx.txid());
+                    return Err(ChainstateError::ProblematicTransaction(tx.txid()));
+                }
+            }
+        }
+        let block = builder.mine_nakamoto_block(&mut tenure_tx);
+        let size = builder.bytes_so_far;
+        let cost = builder.tenure_finish(tenure_tx);
+        Ok((block, size, cost))
+    }
 }
 
 impl<'a> TestPeer<'a> {
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index 68f77d57d5..0489038ca1 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -489,11 +489,6 @@ impl BlockMinerThread {
             &chain_state,
             &burn_db.index_conn(),
             &mut mem_pool,
-            // TODO (refactor): the nakamoto block builder doesn't use the parent tenure ID,
-            //  it has to be included in the tenure change tx, which is an arg to the builder.
-            //  we should probably just remove this from the nakamoto block builder, so that
-            //  there isn't duplicated or unused logic here
-            &self.parent_tenure_id,
             &parent_block_info.stacks_parent_header,
             &self.burn_block.consensus_hash,
             self.burn_block.total_burn,

From 6bb0547846718cedd456f32f6bf2073f21878977 Mon Sep 17 00:00:00 2001
From: friedger <mail@friedger.de>
Date: Wed, 13 Dec 2023 10:36:00 +0100
Subject: [PATCH 0233/1166] feat: remove pox-reject in pox-4

---
 stackslib/src/chainstate/stacks/boot/docs.rs  |  2 +-
 stackslib/src/chainstate/stacks/boot/mod.rs   | 16 ----
 .../src/chainstate/stacks/boot/pox-4.clar     | 86 +++----------------
 3 files changed, 11 insertions(+), 93 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/docs.rs b/stackslib/src/chainstate/stacks/boot/docs.rs
index 802146ffeb..3bf3f3cae4 100644
--- a/stackslib/src/chainstate/stacks/boot/docs.rs
+++ b/stackslib/src/chainstate/stacks/boot/docs.rs
@@ -43,7 +43,7 @@ This ensures that each entry in the reward set returned to the stacks-node is gr
   but does not require it be all locked up within a single transaction"),
         ("reject-pox", "Reject Stacking for this reward cycle.
 `tx-sender` votes all its uSTX for rejection.
-Note that unlike Stacking, rejecting PoX does not lock the tx-sender's tokens: PoX rejection acts like a coin vote."),
+Note that unlike Stacking, rejecting PoX does not lock the tx-sender's tokens: PoX rejection acts like a coin vote. Removed in pox-4."),
         ("can-stack-stx", "Evaluate if a participant can stack an amount of STX for a given period."),
         ("get-stacking-minimum", "Returns the absolute minimum amount that could be validly Stacked (the threshold to Stack in
 a given reward cycle may be higher than this"),
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 9f08e103bf..975f3ab986 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -990,14 +990,6 @@ impl StacksChainState {
         block_id: &StacksBlockId,
         reward_cycle: u64,
     ) -> Result<Vec<RawRewardSetEntry>, Error> {
-        if !self.is_pox_active(sortdb, block_id, u128::from(reward_cycle), POX_4_NAME)? {
-            debug!(
-                "PoX was voted disabled in block {} (reward cycle {})",
-                block_id, reward_cycle
-            );
-            return Ok(vec![]);
-        }
-
         // how many in this cycle?
         let num_addrs = self
             .eval_boot_code_read_only(
@@ -1140,14 +1132,6 @@ impl StacksChainState {
         block_id: &StacksBlockId,
         reward_cycle: u64,
     ) -> Result<Option<Point>, Error> {
-        if !self.is_pox_active(sortdb, block_id, u128::from(reward_cycle), POX_4_NAME)? {
-            debug!(
-                "PoX was voted disabled in block {} (reward cycle {})",
-                block_id, reward_cycle
-            );
-            return Ok(None);
-        }
-
         let aggregate_public_key = self
             .eval_boot_code_read_only(
                 sortdb,
diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index ffb4bc7f0c..9f41e4a667 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -12,7 +12,7 @@
 (define-constant ERR_STACKING_THRESHOLD_NOT_MET 11)
 (define-constant ERR_STACKING_POX_ADDRESS_IN_USE 12)
 (define-constant ERR_STACKING_INVALID_POX_ADDRESS 13)
-(define-constant ERR_STACKING_ALREADY_REJECTED 17)
+
 (define-constant ERR_STACKING_INVALID_AMOUNT 18)
 (define-constant ERR_NOT_ALLOWED 19)
 (define-constant ERR_STACKING_ALREADY_DELEGATED 20)
@@ -28,9 +28,6 @@
 (define-constant ERR_STACKING_IS_DELEGATED 30)
 (define-constant ERR_STACKING_NOT_DELEGATED 31)
 
-;; PoX disabling threshold (a percent)
-(define-constant POX_REJECTION_FRACTION u25)
-
 ;; Valid values for burnchain address versions.
 ;; These first four correspond to address hash modes in Stacks 2.1,
 ;; and are defined in pox-mainnet.clar and pox-testnet.clar (so they
@@ -57,7 +54,6 @@
 ;; used in e.g. test harnesses.
 (define-data-var pox-prepare-cycle-length uint PREPARE_CYCLE_LENGTH)
 (define-data-var pox-reward-cycle-length uint REWARD_CYCLE_LENGTH)
-(define-data-var pox-rejection-fraction uint POX_REJECTION_FRACTION)
 (define-data-var first-burnchain-block-height uint u0)
 (define-data-var configured bool false)
 (define-data-var first-2-1-reward-cycle uint u0)
@@ -73,7 +69,6 @@
         (var-set first-burnchain-block-height first-burn-height)
         (var-set pox-prepare-cycle-length prepare-cycle-length)
         (var-set pox-reward-cycle-length reward-cycle-length)
-        (var-set pox-rejection-fraction rejection-fraction)
         (var-set first-2-1-reward-cycle begin-2-1-reward-cycle)
         (var-set configured true)
         (ok true))
@@ -190,37 +185,19 @@
     { stacked-amount: uint }
 )
 
-;; Amount of uSTX that reject PoX, by reward cycle
-(define-map stacking-rejection
-    { reward-cycle: uint }
-    { amount: uint }
-)
-
-;; Who rejected in which reward cycle
-(define-map stacking-rejectors
-    { stacker: principal, reward-cycle: uint }
-    { amount: uint }
-)
-
 ;; The stackers' aggregate public key
 ;;   for the given reward cycle
 (define-map aggregate-public-keys uint (buff 33))
 
 ;; Getter for stacking-rejectors
+;; always return none for backwards compatibility
 (define-read-only (get-pox-rejection (stacker principal) (reward-cycle uint))
-    (map-get? stacking-rejectors { stacker: stacker, reward-cycle: reward-cycle }))
+    none)
 
-;; Has PoX been rejected in the given reward cycle?
+;; Has PoX not been rejected in the given reward cycle?
+;; always return true for backwards compatibility
 (define-read-only (is-pox-active (reward-cycle uint))
-    (let (
-        (reject-votes
-            (default-to
-                u0
-                (get amount (map-get? stacking-rejection { reward-cycle: reward-cycle }))))
-    )
-    ;; (100 * reject-votes) / stx-liquid-supply < pox-rejection-fraction
-    (< (* u100 reject-votes)
-       (* (var-get pox-rejection-fraction) stx-liquid-supply)))
+    true
 )
 
 ;; What's the reward cycle number of the burnchain block height?
@@ -288,12 +265,6 @@
         u0
         (get len (map-get? reward-cycle-pox-address-list-len { reward-cycle: reward-cycle }))))
 
-;; How many rejection votes have we been accumulating for the next block
-(define-read-only (next-cycle-rejection-votes)
-    (default-to
-        u0
-        (get amount (map-get? stacking-rejection { reward-cycle: (+ u1 (current-pox-reward-cycle)) }))))
-
 ;; Add a single PoX address to a single reward cycle.
 ;; Used to build up a set of per-reward-cycle PoX addresses.
 ;; No checking will be done -- don't call if this PoX address is already registered in this reward cycle!
@@ -537,10 +508,6 @@
     (asserts! (> amount-ustx u0)
               (err ERR_STACKING_INVALID_AMOUNT))
 
-    ;; sender principal must not have rejected in this upcoming reward cycle
-    (asserts! (is-none (get-pox-rejection tx-sender first-reward-cycle))
-              (err ERR_STACKING_ALREADY_REJECTED))
-
     ;; lock period must be in acceptable range.
     (asserts! (check-pox-lock-period num-cycles)
               (err ERR_STACKING_INVALID_LOCK_PERIOD))
@@ -892,38 +859,6 @@
             lock-amount: amount-ustx,
             unlock-burn-height: unlock-burn-height })))
 
-;; Reject Stacking for this reward cycle.
-;; tx-sender votes all its uSTX for rejection.
-;; Note that unlike PoX, rejecting PoX does not lock the tx-sender's
-;; tokens.  PoX rejection acts like a coin vote.
-(define-public (reject-pox)
-    (let (
-        (balance (stx-get-balance tx-sender))
-        (vote-reward-cycle (+ u1 (current-pox-reward-cycle)))
-    )
-
-    ;; tx-sender principal must not have rejected in this upcoming reward cycle
-    (asserts! (is-none (get-pox-rejection tx-sender vote-reward-cycle))
-        (err ERR_STACKING_ALREADY_REJECTED))
-
-    ;; tx-sender can't be a stacker
-    (asserts! (is-none (get-stacker-info tx-sender))
-        (err ERR_STACKING_ALREADY_STACKED))
-
-    ;; vote for rejection
-    (map-set stacking-rejection
-        { reward-cycle: vote-reward-cycle }
-        { amount: (+ (next-cycle-rejection-votes) balance) }
-    )
-
-    ;; mark voted
-    (map-set stacking-rejectors
-        { stacker: tx-sender, reward-cycle: vote-reward-cycle }
-        { amount: balance }
-    )
-
-    (ok true))
-)
 
 ;; Used for PoX parameters discovery
 (define-read-only (get-pox-info)
@@ -933,8 +868,6 @@
         prepare-cycle-length: (var-get pox-prepare-cycle-length),
         first-burnchain-block-height: (var-get first-burnchain-block-height),
         reward-cycle-length: (var-get pox-reward-cycle-length),
-        rejection-fraction: (var-get pox-rejection-fraction),
-        current-rejection-votes: (next-cycle-rejection-votes),
         total-liquid-supply-ustx: stx-liquid-supply,
     })
 )
@@ -1315,11 +1248,12 @@
 
 ;; How many uSTX have voted to reject PoX in a given reward cycle?
 ;; *New in Stacks 2.1*
+;; always return 0 for backwards compatibility
 (define-read-only (get-total-pox-rejection (reward-cycle uint))
-    (match (map-get? stacking-rejection { reward-cycle: reward-cycle })
-        rejected
-            (get amount rejected)
         u0
+        u0
+    )
+    u0
     )
 )
 

From 4eed0bd5b3c91a6e5f82d46b4b77367c92f772b0 Mon Sep 17 00:00:00 2001
From: friedger <mail@friedger.de>
Date: Wed, 13 Dec 2023 10:44:21 +0100
Subject: [PATCH 0234/1166] feat: remove rejection fraction

---
 .../src/chainstate/stacks/boot/pox-4.clar     | 29 ++-----------------
 stackslib/src/clarity_vm/clarity.rs           |  1 -
 2 files changed, 3 insertions(+), 27 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index 9f41e4a667..d5c1b1e77f 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -56,20 +56,19 @@
 (define-data-var pox-reward-cycle-length uint REWARD_CYCLE_LENGTH)
 (define-data-var first-burnchain-block-height uint u0)
 (define-data-var configured bool false)
-(define-data-var first-2-1-reward-cycle uint u0)
+(define-data-var first-pox-4-reward-cycle uint u0)
 
 ;; This function can only be called once, when it boots up
 (define-public (set-burnchain-parameters (first-burn-height uint)
                                          (prepare-cycle-length uint)
                                          (reward-cycle-length uint)
-                                         (rejection-fraction uint)
-                                         (begin-2-1-reward-cycle uint))
+                                         (begin-pox-4-reward-cycle uint))
     (begin
         (asserts! (not (var-get configured)) (err ERR_NOT_ALLOWED))
         (var-set first-burnchain-block-height first-burn-height)
         (var-set pox-prepare-cycle-length prepare-cycle-length)
         (var-set pox-reward-cycle-length reward-cycle-length)
-        (var-set first-2-1-reward-cycle begin-2-1-reward-cycle)
+        (var-set first-pox-4-reward-cycle begin-pox-4-reward-cycle)
         (var-set configured true)
         (ok true))
 )
@@ -189,17 +188,6 @@
 ;;   for the given reward cycle
 (define-map aggregate-public-keys uint (buff 33))
 
-;; Getter for stacking-rejectors
-;; always return none for backwards compatibility
-(define-read-only (get-pox-rejection (stacker principal) (reward-cycle uint))
-    none)
-
-;; Has PoX not been rejected in the given reward cycle?
-;; always return true for backwards compatibility
-(define-read-only (is-pox-active (reward-cycle uint))
-    true
-)
-
 ;; What's the reward cycle number of the burnchain block height?
 ;; Will runtime-abort if height is less than the first burnchain block (this is intentional)
 (define-read-only (burn-height-to-reward-cycle (height uint))
@@ -1246,17 +1234,6 @@
     (map-get? partial-stacked-by-cycle { pox-addr: pox-addr, reward-cycle: reward-cycle, sender: sender })
 )
 
-;; How many uSTX have voted to reject PoX in a given reward cycle?
-;; *New in Stacks 2.1*
-;; always return 0 for backwards compatibility
-(define-read-only (get-total-pox-rejection (reward-cycle uint))
-        u0
-        u0
-    )
-    u0
-    )
-)
-
 ;; What is the given reward cycle's stackers' aggregate public key?
 ;; *New in Stacks 3.0*
 (define-read-only (get-aggregate-public-key (reward-cycle uint))
diff --git a/stackslib/src/clarity_vm/clarity.rs b/stackslib/src/clarity_vm/clarity.rs
index ae2dfbddc6..bb448c6d7c 100644
--- a/stackslib/src/clarity_vm/clarity.rs
+++ b/stackslib/src/clarity_vm/clarity.rs
@@ -1387,7 +1387,6 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
                     Value::UInt(u128::from(first_block_height)),
                     Value::UInt(u128::from(pox_prepare_length)),
                     Value::UInt(u128::from(pox_reward_cycle_length)),
-                    Value::UInt(u128::from(pox_rejection_fraction)),
                     Value::UInt(u128::from(pox_4_first_cycle)),
                 ];
 

From 3cef3b4da38bfc9bfb2fe94763a179d3603e53ca Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Mon, 18 Dec 2023 21:35:39 -0600
Subject: [PATCH 0235/1166] test: naka::mine_multiple to mine 9 interim blocks.
 move empty block check to stackslib::miner assembly.

chore: fix typo
---
 stackslib/src/chainstate/nakamoto/miner.rs    |  4 +
 .../stacks-node/src/nakamoto_node/miner.rs    | 25 ++++--
 .../src/tests/nakamoto_integrations.rs        | 83 +++++++++----------
 3 files changed, 58 insertions(+), 54 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/miner.rs b/stackslib/src/chainstate/nakamoto/miner.rs
index 66d723652b..adadbbca05 100644
--- a/stackslib/src/chainstate/nakamoto/miner.rs
+++ b/stackslib/src/chainstate/nakamoto/miner.rs
@@ -459,6 +459,10 @@ impl NakamotoBlockBuilder {
             return Err(Error::MinerAborted);
         }
 
+        if builder.txs.is_empty() {
+            return Err(Error::NoTransactionsToMine);
+        }
+
         // save the block so we can build microblocks off of it
         let block = builder.mine_nakamoto_block(&mut tenure_tx);
         let size = builder.bytes_so_far;
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index 0489038ca1..c497c0e843 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -138,7 +138,7 @@ impl BlockMinerThread {
         loop {
             let new_block = loop {
                 match self.mine_block() {
-                    Ok(x) => break x,
+                    Ok(x) => break Some(x),
                     Err(NakamotoNodeError::MiningFailure(ChainstateError::MinerAborted)) => {
                         info!("Miner interrupted while mining, will try again");
                         // sleep, and try again. if the miner was interrupted because the burnchain
@@ -146,6 +146,12 @@ impl BlockMinerThread {
                         thread::sleep(Duration::from_millis(ABORT_TRY_AGAIN_MS));
                         continue;
                     }
+                    Err(NakamotoNodeError::MiningFailure(
+                        ChainstateError::NoTransactionsToMine,
+                    )) => {
+                        debug!("Miner did not find any transactions to mine");
+                        break None;
+                    }
                     Err(e) => {
                         warn!("Failed to mine block: {e:?}");
                         return;
@@ -408,10 +414,8 @@ impl BlockMinerThread {
     }
 
     /// Try to mine a Stacks block by assembling one from mempool transactions and sending a
-    /// burnchain block-commit transaction.  If we succeed, then return the assembled block data as
-    /// well as the microblock private key to use to produce microblocks.
-    /// Return None if we couldn't build a block for whatever reason.
-    fn mine_block(&mut self) -> Result<Option<NakamotoBlock>, NakamotoNodeError> {
+    /// burnchain block-commit transaction.  If we succeed, then return the assembled block.
+    fn mine_block(&mut self) -> Result<NakamotoBlock, NakamotoNodeError> {
         debug!("block miner thread ID is {:?}", thread::current().id());
 
         let burn_db_path = self.config.get_burn_db_file_path();
@@ -501,14 +505,19 @@ impl BlockMinerThread {
             Some(&self.event_dispatcher),
         )
         .map_err(|e| {
-            if !matches!(e, ChainstateError::MinerAborted) {
+            if !matches!(
+                e,
+                ChainstateError::MinerAborted | ChainstateError::NoTransactionsToMine
+            ) {
                 error!("Relayer: Failure mining anchored block: {e}");
             }
             NakamotoNodeError::MiningFailure(e)
         })?;
 
         if block.txs.is_empty() {
-            return Ok(None);
+            return Err(NakamotoNodeError::MiningFailure(
+                ChainstateError::NoTransactionsToMine,
+            ));
         }
 
         let mining_key = self.keychain.get_nakamoto_sk();
@@ -539,7 +548,7 @@ impl BlockMinerThread {
         // enough to build this block that another block could have arrived), and confirm that all
         // Stacks blocks with heights higher than the canoincal tip are processed.
         self.check_burn_tip_changed(&burn_db)?;
-        Ok(Some(block))
+        Ok(block)
     }
 
     /// Check if the tenure needs to change -- if so, return a BurnchainTipChanged error
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 31204f28f0..ad011309b7 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -503,24 +503,27 @@ fn simple_neon_integration() {
 ///  to Nakamoto operation (activating pox-4 by submitting a stack-stx tx). The BootLoop
 ///  struct handles the epoch-2/3 tear-down and spin-up.
 /// This test makes three assertions:
-///  * 10 tenures are mined after 3.0 starts
-///  * Each tenure has 2 blocks
+///  * 5 tenures are mined after 3.0 starts
+///  * Each tenure has 10 blocks (the coinbase block and 9 interim blocks)
 fn mine_multiple_per_tenure_integration() {
     if env::var("BITCOIND_TEST") != Ok("1".into()) {
         return;
     }
 
     let (mut naka_conf, _miner_account) = naka_neon_integration_conf(None);
-    naka_conf.miner.wait_on_interim_blocks = Duration::from_secs(5);
+    let http_origin = format!("http://{}", &naka_conf.node.rpc_bind);
+    naka_conf.miner.wait_on_interim_blocks = Duration::from_secs(1);
     let sender_sk = Secp256k1PrivateKey::new();
-    // setup sender + recipient for a test stx transfer
-    let tenure_count = 10;
+    let tenure_count = 5;
+    let inter_blocks_per_tenure = 9;
+    // setup sender + recipient for some test stx transfers
+    // these are necessary for the interim blocks to get mined at all
     let sender_addr = tests::to_addr(&sender_sk);
-    let send_amt = 1000;
-    let send_fee = 100;
+    let send_amt = 100;
+    let send_fee = 180;
     naka_conf.add_initial_balance(
         PrincipalData::from(sender_addr.clone()).to_string(),
-        (send_amt + send_fee) * tenure_count,
+        (send_amt + send_fee) * tenure_count * inter_blocks_per_tenure,
     );
     let recipient = PrincipalData::from(StacksAddress::burn_address(false));
     let stacker_sk = setup_stacker(&mut naka_conf);
@@ -566,7 +569,7 @@ fn mine_multiple_per_tenure_integration() {
 
     let burnchain = naka_conf.get_burnchain();
     let sortdb = burnchain.open_sortition_db(true).unwrap();
-    let (mut chainstate, _) = StacksChainState::open(
+    let (chainstate, _) = StacksChainState::open(
         naka_conf.is_mainnet(),
         naka_conf.burnchain.chain_id,
         &naka_conf.get_chainstate_path_str(),
@@ -595,8 +598,8 @@ fn mine_multiple_per_tenure_integration() {
     })
     .unwrap();
 
-    // Mine 10 nakamoto tenures
-    for sender_nonce in 0..tenure_count {
+    // Mine `tenure_count` nakamoto tenures
+    for tenure_ix in 0..tenure_count {
         next_block_and_mine_commit(
             &mut btc_regtest_controller,
             60,
@@ -605,44 +608,28 @@ fn mine_multiple_per_tenure_integration() {
         )
         .unwrap();
 
-        let blocks_processed_before = coord_channel
-            .lock()
-            .expect("Mutex poisoned")
-            .get_stacks_blocks_processed();
-
-        // submit a tx so that the miner will mine an extra block
-        let transfer_tx =
-            make_stacks_transfer(&sender_sk, sender_nonce, send_fee, &recipient, send_amt);
-        // let transfer_tx_hex = format!("0x{}", to_hex(&transfer_tx));
-        let tip = NakamotoChainState::get_canonical_block_header(chainstate.db(), &sortdb)
-            .unwrap()
-            .unwrap();
-
-        let mut mempool = naka_conf
-            .connect_mempool_db()
-            .expect("Database failure opening mempool");
-
-        mempool
-            .submit_raw(
-                &mut chainstate,
-                &sortdb,
-                &tip.consensus_hash,
-                &tip.anchored_header.block_hash(),
-                transfer_tx.clone(),
-                &ExecutionCost::max_value(),
-                &StacksEpochId::Epoch30,
-            )
-            .unwrap();
-
-        loop {
-            let blocks_processed = coord_channel
+        // mine the interim blocks
+        for interim_block_ix in 0..inter_blocks_per_tenure {
+            let blocks_processed_before = coord_channel
                 .lock()
                 .expect("Mutex poisoned")
                 .get_stacks_blocks_processed();
-            if blocks_processed > blocks_processed_before {
-                break;
+            // submit a tx so that the miner will mine an extra block
+            let sender_nonce = tenure_ix * inter_blocks_per_tenure + interim_block_ix;
+            let transfer_tx =
+                make_stacks_transfer(&sender_sk, sender_nonce, send_fee, &recipient, send_amt);
+            submit_tx(&http_origin, &transfer_tx);
+
+            loop {
+                let blocks_processed = coord_channel
+                    .lock()
+                    .expect("Mutex poisoned")
+                    .get_stacks_blocks_processed();
+                if blocks_processed > blocks_processed_before {
+                    break;
+                }
+                thread::sleep(Duration::from_millis(100));
             }
-            thread::sleep(Duration::from_millis(100));
         }
     }
 
@@ -657,7 +644,11 @@ fn mine_multiple_per_tenure_integration() {
     );
 
     assert!(tip.anchored_header.as_stacks_nakamoto().is_some());
-    assert!(tip.stacks_block_height >= block_height_pre_3_0 + 20);
+    assert_eq!(
+        tip.stacks_block_height,
+        block_height_pre_3_0 + ((inter_blocks_per_tenure + 1) * tenure_count),
+        "Should have mined (1 + interim_blocks_per_tenure) * tenure_count nakamoto blocks"
+    );
 
     coord_channel
         .lock()

From 7ceefe0e3ddf0dec5d52ea591abd5db06df86ce9 Mon Sep 17 00:00:00 2001
From: Joey Yandle <xoloki@gmail.com>
Date: Thu, 14 Dec 2023 15:32:45 -0500
Subject: [PATCH 0236/1166] switch stacks-signer to use byzantine fire
 coordinator rather than default frost coordinator

---
 stacks-signer/src/main.rs               | 2 +-
 stacks-signer/src/runloop.rs            | 2 +-
 testnet/stacks-node/src/tests/signer.rs | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/stacks-signer/src/main.rs b/stacks-signer/src/main.rs
index a2fdac84eb..5ec478c27c 100644
--- a/stacks-signer/src/main.rs
+++ b/stacks-signer/src/main.rs
@@ -52,7 +52,7 @@ use stacks_signer::runloop::{RunLoop, RunLoopCommand};
 use stacks_signer::utils::{build_signer_config_tomls, build_stackerdb_contract};
 use tracing_subscriber::prelude::*;
 use tracing_subscriber::{fmt, EnvFilter};
-use wsts::state_machine::coordinator::frost::Coordinator as FrostCoordinator;
+use wsts::state_machine::coordinator::fire::Coordinator as FrostCoordinator;
 use wsts::state_machine::OperationResult;
 use wsts::v2;
 
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index c99c6296d1..8247f7a2ba 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -8,7 +8,7 @@ use stacks_common::{debug, error, info, warn};
 use wsts::common::MerkleRoot;
 use wsts::curve::ecdsa;
 use wsts::net::{Message, Packet, Signable};
-use wsts::state_machine::coordinator::frost::Coordinator as FrostCoordinator;
+use wsts::state_machine::coordinator::fire::Coordinator as FrostCoordinator;
 use wsts::state_machine::coordinator::{Config as CoordinatorConfig, Coordinator};
 use wsts::state_machine::signer::Signer;
 use wsts::state_machine::{OperationResult, PublicKeys};
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index c7256c5abb..2f5a6d33ad 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -11,7 +11,7 @@ use stacks_signer::runloop::RunLoopCommand;
 use stacks_signer::utils::{build_signer_config_tomls, build_stackerdb_contract};
 use tracing_subscriber::prelude::*;
 use tracing_subscriber::{fmt, EnvFilter};
-use wsts::state_machine::coordinator::frost::Coordinator as FrostCoordinator;
+use wsts::state_machine::coordinator::fire::Coordinator as FrostCoordinator;
 use wsts::state_machine::OperationResult;
 use wsts::v2;
 

From 4a1ff2296186aa0009cee4fc0fc095c9d52d1d4a Mon Sep 17 00:00:00 2001
From: Joey Yandle <xoloki@gmail.com>
Date: Mon, 18 Dec 2023 13:36:00 -0500
Subject: [PATCH 0237/1166] add timeouts to stacks-signer config struct; pass
 timeouts and construct HashSet based signer_key_ids when creating
 CoordinatorConfig

---
 stacks-signer/src/config.rs  | 12 ++++++++++++
 stacks-signer/src/runloop.rs | 15 ++++++++++++++-
 2 files changed, 26 insertions(+), 1 deletion(-)

diff --git a/stacks-signer/src/config.rs b/stacks-signer/src/config.rs
index 4991fb3fff..190a6f82c8 100644
--- a/stacks-signer/src/config.rs
+++ b/stacks-signer/src/config.rs
@@ -119,6 +119,14 @@ pub struct Config {
     pub signer_id: u32,
     /// The time to wait for a response from the stacker-db instance
     pub event_timeout: Duration,
+    /// timeout to gather DkgPublicShares messages
+    pub dkg_public_timeout: Option<Duration>,
+    /// timeout to gather DkgEnd messages
+    pub dkg_end_timeout: Option<Duration>,
+    /// timeout to gather nonces
+    pub nonce_timeout: Option<Duration>,
+    /// timeout to gather signature shares
+    pub sign_timeout: Option<Duration>,
 }
 
 /// Internal struct for loading up the config file signer data
@@ -290,6 +298,10 @@ impl TryFrom<RawConfigFile> for Config {
             signer_id: raw_data.signer_id,
             signer_key_ids,
             event_timeout,
+            dkg_end_timeout: None,
+            dkg_public_timeout: None,
+            nonce_timeout: None,
+            sign_timeout: None,
         })
     }
 }
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 8247f7a2ba..c1fb92720b 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -1,3 +1,4 @@
+use hashbrown::{HashMap, HashSet};
 use std::collections::VecDeque;
 use std::sync::mpsc::Sender;
 use std::time::Duration;
@@ -233,12 +234,24 @@ impl From<&Config> for RunLoop<FrostCoordinator<v2::Aggregator>> {
             .iter()
             .map(|i| i - 1) // Signer::new (unlike Signer::from) doesn't do this
             .collect::<Vec<u32>>();
+        // signer uses a Vec<u32> for its key_ids, but coordinator uses a HashSet for each signer since it needs to do lots of lookups
+        let mut signer_key_ids = HashMap::new();
+        for (signer_id, key_ids) in &config.signer_key_ids {
+            let id = signer_id - 1;
+            let ids = key_ids.iter().map(|i| *i).collect::<HashSet<u32>>();
+
+            signer_key_ids.insert(id, ids);
+        }
         let coordinator_config = CoordinatorConfig {
             threshold,
             num_signers: total_signers,
             num_keys: total_keys,
             message_private_key: config.message_private_key,
-            ..Default::default()
+            dkg_public_timeout: config.dkg_public_timeout,
+            dkg_end_timeout: config.dkg_end_timeout,
+            nonce_timeout: config.nonce_timeout,
+            sign_timeout: config.sign_timeout,
+            signer_key_ids,
         };
         let coordinator = FrostCoordinator::new(coordinator_config);
         let signing_round = Signer::new(

From d93fc575bbd2d0d536f307d3b634b120fdb917ab Mon Sep 17 00:00:00 2001
From: Joey Yandle <xoloki@gmail.com>
Date: Mon, 18 Dec 2023 13:40:24 -0500
Subject: [PATCH 0238/1166] need to subtract 1 from each key_id not signer_id

---
 stacks-signer/src/runloop.rs | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index c1fb92720b..9b83db1529 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -237,10 +237,9 @@ impl From<&Config> for RunLoop<FrostCoordinator<v2::Aggregator>> {
         // signer uses a Vec<u32> for its key_ids, but coordinator uses a HashSet for each signer since it needs to do lots of lookups
         let mut signer_key_ids = HashMap::new();
         for (signer_id, key_ids) in &config.signer_key_ids {
-            let id = signer_id - 1;
-            let ids = key_ids.iter().map(|i| *i).collect::<HashSet<u32>>();
+            let ids = key_ids.iter().map(|i| *i - 1).collect::<HashSet<u32>>();
 
-            signer_key_ids.insert(id, ids);
+            signer_key_ids.insert(*signer_id, ids);
         }
         let coordinator_config = CoordinatorConfig {
             threshold,

From b82724bbff2bfe56f6ec26c159a0460c3d0ca1ad Mon Sep 17 00:00:00 2001
From: Joey Yandle <xoloki@gmail.com>
Date: Tue, 19 Dec 2023 02:58:31 -0500
Subject: [PATCH 0239/1166] panic stacks-signer if it receives an error
 operation result

---
 stacks-signer/src/main.rs | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

diff --git a/stacks-signer/src/main.rs b/stacks-signer/src/main.rs
index 5ec478c27c..7581b0428a 100644
--- a/stacks-signer/src/main.rs
+++ b/stacks-signer/src/main.rs
@@ -124,8 +124,11 @@ fn process_dkg_result(dkg_res: &[OperationResult]) {
                 &schnorr_proof.r, &schnorr_proof.s,
             );
         }
-        OperationResult::DkgError(..) | OperationResult::SignError(..) => {
-            todo!()
+        OperationResult::DkgError(dkg_error) => {
+            panic!("Received DkgError {}", dkg_error);
+        }
+        OperationResult::SignError(sign_error) => {
+            panic!("Received SignError {}", sign_error);
         }
     }
 }
@@ -150,8 +153,11 @@ fn process_sign_result(sign_res: &[OperationResult]) {
                 &schnorr_proof.r, &schnorr_proof.s,
             );
         }
-        OperationResult::DkgError(..) | OperationResult::SignError(..) => {
-            todo!()
+        OperationResult::DkgError(dkg_error) => {
+            panic!("Received DkgError {}", dkg_error);
+        }
+        OperationResult::SignError(sign_error) => {
+            panic!("Received SignError {}", sign_error);
         }
     }
 }

From e8f428835bc86d857f2c2df50d549626cdbda951 Mon Sep 17 00:00:00 2001
From: Joey Yandle <xoloki@gmail.com>
Date: Tue, 19 Dec 2023 03:01:17 -0500
Subject: [PATCH 0240/1166] panic test_stackerdb_dkg if it receives an error
 operation result

---
 testnet/stacks-node/src/tests/signer.rs | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index 2f5a6d33ad..4cb09d3f0f 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -312,8 +312,11 @@ fn test_stackerdb_dkg() {
                         info!("Received SchnorrProof ({},{})", &proof.r, &proof.s);
                         schnorr_proof = Some(proof);
                     }
-                    OperationResult::DkgError(..) | OperationResult::SignError(..) => {
-                        todo!()
+                    OperationResult::DkgError(dkg_error) => {
+                        panic!("Received DkgError {}", dkg_error);
+                    }
+                    OperationResult::SignError(sign_error) => {
+                        panic!("Received SignError {}", sign_error);
                     }
                 }
             }

From 09b8fa55000aea4d9dd24f8df24035431f0d91d0 Mon Sep 17 00:00:00 2001
From: Joey Yandle <xoloki@gmail.com>
Date: Tue, 19 Dec 2023 12:34:41 -0500
Subject: [PATCH 0241/1166] rename FrostCoordinator to FireCoordinator since it
 isn't a subclass

---
 stacks-signer/src/main.rs               | 6 +++---
 stacks-signer/src/runloop.rs            | 6 +++---
 testnet/stacks-node/src/tests/signer.rs | 6 +++---
 3 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/stacks-signer/src/main.rs b/stacks-signer/src/main.rs
index 7581b0428a..4f6c762c1e 100644
--- a/stacks-signer/src/main.rs
+++ b/stacks-signer/src/main.rs
@@ -52,7 +52,7 @@ use stacks_signer::runloop::{RunLoop, RunLoopCommand};
 use stacks_signer::utils::{build_signer_config_tomls, build_stackerdb_contract};
 use tracing_subscriber::prelude::*;
 use tracing_subscriber::{fmt, EnvFilter};
-use wsts::state_machine::coordinator::fire::Coordinator as FrostCoordinator;
+use wsts::state_machine::coordinator::fire::Coordinator as FireCoordinator;
 use wsts::state_machine::OperationResult;
 use wsts::v2;
 
@@ -88,11 +88,11 @@ fn spawn_running_signer(path: &PathBuf) -> SpawnedSigner {
     let (cmd_send, cmd_recv) = channel();
     let (res_send, res_recv) = channel();
     let ev = StackerDBEventReceiver::new(vec![config.stackerdb_contract_id.clone()]);
-    let runloop: RunLoop<FrostCoordinator<v2::Aggregator>> = RunLoop::from(&config);
+    let runloop: RunLoop<FireCoordinator<v2::Aggregator>> = RunLoop::from(&config);
     let mut signer: Signer<
         RunLoopCommand,
         Vec<OperationResult>,
-        RunLoop<FrostCoordinator<v2::Aggregator>>,
+        RunLoop<FireCoordinator<v2::Aggregator>>,
         StackerDBEventReceiver,
     > = Signer::new(runloop, ev, cmd_recv, res_send);
     let endpoint = config.endpoint;
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 9b83db1529..6b37f48afe 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -9,7 +9,7 @@ use stacks_common::{debug, error, info, warn};
 use wsts::common::MerkleRoot;
 use wsts::curve::ecdsa;
 use wsts::net::{Message, Packet, Signable};
-use wsts::state_machine::coordinator::fire::Coordinator as FrostCoordinator;
+use wsts::state_machine::coordinator::fire::Coordinator as FireCoordinator;
 use wsts::state_machine::coordinator::{Config as CoordinatorConfig, Coordinator};
 use wsts::state_machine::signer::Signer;
 use wsts::state_machine::{OperationResult, PublicKeys};
@@ -207,7 +207,7 @@ impl<C: Coordinator> RunLoop<C> {
     }
 }
 
-impl From<&Config> for RunLoop<FrostCoordinator<v2::Aggregator>> {
+impl From<&Config> for RunLoop<FireCoordinator<v2::Aggregator>> {
     /// Creates new runloop from a config
     fn from(config: &Config) -> Self {
         // TODO: this should be a config option
@@ -252,7 +252,7 @@ impl From<&Config> for RunLoop<FrostCoordinator<v2::Aggregator>> {
             sign_timeout: config.sign_timeout,
             signer_key_ids,
         };
-        let coordinator = FrostCoordinator::new(coordinator_config);
+        let coordinator = FireCoordinator::new(coordinator_config);
         let signing_round = Signer::new(
             threshold,
             total_signers,
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index 4cb09d3f0f..9779e84a62 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -11,7 +11,7 @@ use stacks_signer::runloop::RunLoopCommand;
 use stacks_signer::utils::{build_signer_config_tomls, build_stackerdb_contract};
 use tracing_subscriber::prelude::*;
 use tracing_subscriber::{fmt, EnvFilter};
-use wsts::state_machine::coordinator::fire::Coordinator as FrostCoordinator;
+use wsts::state_machine::coordinator::fire::Coordinator as FireCoordinator;
 use wsts::state_machine::OperationResult;
 use wsts::v2;
 
@@ -39,12 +39,12 @@ fn spawn_signer(
 ) -> RunningSigner<StackerDBEventReceiver, Vec<OperationResult>> {
     let config = stacks_signer::config::Config::load_from_str(data).unwrap();
     let ev = StackerDBEventReceiver::new(vec![config.stackerdb_contract_id.clone()]);
-    let runloop: stacks_signer::runloop::RunLoop<FrostCoordinator<v2::Aggregator>> =
+    let runloop: stacks_signer::runloop::RunLoop<FireCoordinator<v2::Aggregator>> =
         stacks_signer::runloop::RunLoop::from(&config);
     let mut signer: Signer<
         RunLoopCommand,
         Vec<OperationResult>,
-        stacks_signer::runloop::RunLoop<FrostCoordinator<v2::Aggregator>>,
+        stacks_signer::runloop::RunLoop<FireCoordinator<v2::Aggregator>>,
         StackerDBEventReceiver,
     > = Signer::new(runloop, ev, receiver, sender);
     let endpoint = config.endpoint;

From fa97aa83cbb9d45c8e6ff0f65646e281d60af9bc Mon Sep 17 00:00:00 2001
From: Joey Yandle <xoloki@gmail.com>
Date: Tue, 19 Dec 2023 12:44:19 -0500
Subject: [PATCH 0242/1166] rework loop into nested map

---
 stacks-signer/src/runloop.rs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 6b37f48afe..9aac0ca227 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -235,12 +235,12 @@ impl From<&Config> for RunLoop<FireCoordinator<v2::Aggregator>> {
             .map(|i| i - 1) // Signer::new (unlike Signer::from) doesn't do this
             .collect::<Vec<u32>>();
         // signer uses a Vec<u32> for its key_ids, but coordinator uses a HashSet for each signer since it needs to do lots of lookups
-        let mut signer_key_ids = HashMap::new();
-        for (signer_id, key_ids) in &config.signer_key_ids {
-            let ids = key_ids.iter().map(|i| *i - 1).collect::<HashSet<u32>>();
+        let signer_key_ids = config
+            .signer_key_ids
+            .iter()
+            .map(|(i, ids)| (*i, ids.iter().map(|id| id - 1).collect::<HashSet<u32>>()))
+            .collect::<HashMap<u32, HashSet<u32>>>();
 
-            signer_key_ids.insert(*signer_id, ids);
-        }
         let coordinator_config = CoordinatorConfig {
             threshold,
             num_signers: total_signers,

From 19f67b26b974a312160c83ca79be5c053b798508 Mon Sep 17 00:00:00 2001
From: friedger <mail@friedger.de>
Date: Tue, 19 Dec 2023 23:43:04 +0100
Subject: [PATCH 0243/1166] chore: add boot/pox-4.clar to Clarinet.toml

---
 contrib/core-contract-tests/Clarinet.toml     | 13 ++++++++++++
 .../contracts/pox/pox-helper.clar             |  2 ++
 stackslib/src/chainstate/stacks/boot/mod.rs   |  6 ++----
 .../src/chainstate/stacks/boot/pox-4.clar     | 21 ++++++++++++++++---
 4 files changed, 35 insertions(+), 7 deletions(-)
 create mode 100644 contrib/core-contract-tests/contracts/pox/pox-helper.clar

diff --git a/contrib/core-contract-tests/Clarinet.toml b/contrib/core-contract-tests/Clarinet.toml
index 5cdea76a4c..b3ee805eb0 100644
--- a/contrib/core-contract-tests/Clarinet.toml
+++ b/contrib/core-contract-tests/Clarinet.toml
@@ -8,3 +8,16 @@ costs_version = 1
 [contracts.bns]
 path = "../../stackslib/src/chainstate/stacks/boot/bns.clar"
 depends_on = []
+epoch = 2.4
+
+[contracts.pox-4]
+path = "../../stackslib/src/chainstate/stacks/boot/pox-4.clar"
+depends_on = []
+clarity = 2
+epoch = 2.4
+
+[contracts.pox-helper]
+path = "./contracts/pox/pox-helper.clar"
+depends_on = []
+clarity = 2
+epoch = 2.4
\ No newline at end of file
diff --git a/contrib/core-contract-tests/contracts/pox/pox-helper.clar b/contrib/core-contract-tests/contracts/pox/pox-helper.clar
new file mode 100644
index 0000000000..d67f17a017
--- /dev/null
+++ b/contrib/core-contract-tests/contracts/pox/pox-helper.clar
@@ -0,0 +1,2 @@
+(define-read-only (get-bbh)
+    burn-block-height)
\ No newline at end of file
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 9f08e103bf..8a6620caee 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -102,10 +102,8 @@ lazy_static! {
         format!("{}\n{}", BOOT_CODE_POX_MAINNET_CONSTS, POX_3_BODY);
     pub static ref POX_3_TESTNET_CODE: String =
         format!("{}\n{}", BOOT_CODE_POX_TESTNET_CONSTS, POX_3_BODY);
-    pub static ref POX_4_MAINNET_CODE: String =
-        format!("{}\n{}", BOOT_CODE_POX_MAINNET_CONSTS, POX_4_BODY);
-    pub static ref POX_4_TESTNET_CODE: String =
-        format!("{}\n{}", BOOT_CODE_POX_TESTNET_CONSTS, POX_4_BODY);
+    pub static ref POX_4_MAINNET_CODE: String = format!("{}", POX_4_BODY);
+    pub static ref POX_4_TESTNET_CODE: String = format!("{}", POX_4_BODY);
     pub static ref BOOT_CODE_COST_VOTING_TESTNET: String = make_testnet_cost_voting();
     pub static ref STACKS_BOOT_CODE_MAINNET: [(&'static str, &'static str); 6] = [
         ("pox", &BOOT_CODE_POX_MAINNET),
diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index ffb4bc7f0c..dc6f66ab28 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -39,9 +39,9 @@
 ;; (define-constant ADDRESS_VERSION_P2SH 0x01)
 ;; (define-constant ADDRESS_VERSION_P2WPKH 0x02)
 ;; (define-constant ADDRESS_VERSION_P2WSH 0x03)
-(define-constant ADDRESS_VERSION_NATIVE_P2WPKH 0x04)
-(define-constant ADDRESS_VERSION_NATIVE_P2WSH 0x05)
-(define-constant ADDRESS_VERSION_NATIVE_P2TR 0x06)
+;; (define-constant ADDRESS_VERSION_NATIVE_P2WPKH 0x04)
+;; (define-constant ADDRESS_VERSION_NATIVE_P2WSH 0x05)
+;; (define-constant ADDRESS_VERSION_NATIVE_P2TR 0x06)
 ;; Keep these constants in lock-step with the address version buffs above
 ;; Maximum value of an address version as a uint
 (define-constant MAX_ADDRESS_VERSION u6)
@@ -52,6 +52,21 @@
 ;; (0x05 and 0x06 have 32-byte hashbytes)
 (define-constant MAX_ADDRESS_VERSION_BUFF_32 u6)
 
+;; PoX mainnet constants
+;; Min/max number of reward cycles uSTX can be locked for
+(define-constant MIN_POX_REWARD_CYCLES u1)
+(define-constant MAX_POX_REWARD_CYCLES u12)
+
+;; Default length of the PoX registration window, in burnchain blocks.
+(define-constant PREPARE_CYCLE_LENGTH (if is-in-mainnet u100 u50))
+
+;; Default length of the PoX reward cycle, in burnchain blocks.
+(define-constant REWARD_CYCLE_LENGTH (if is-in-mainnet u2100 u1050))
+
+;; Stacking thresholds
+(define-constant STACKING_THRESHOLD_25 (if is-in-mainnet u20000 u8000))
+(define-constant STACKING_THRESHOLD_100 (if is-in-mainnet u5000 u2000))
+
 ;; Data vars that store a copy of the burnchain configuration.
 ;; Implemented as data-vars, so that different configurations can be
 ;; used in e.g. test harnesses.

From b0d9d02fe0cb2d5f47ad4c9f1d5d3adb76a4b4b7 Mon Sep 17 00:00:00 2001
From: friedger <mail@friedger.de>
Date: Tue, 19 Dec 2023 23:48:42 +0100
Subject: [PATCH 0244/1166] chore: remove pox-helper.clar

---
 contrib/core-contract-tests/Clarinet.toml                 | 6 ------
 contrib/core-contract-tests/contracts/pox/pox-helper.clar | 2 --
 2 files changed, 8 deletions(-)
 delete mode 100644 contrib/core-contract-tests/contracts/pox/pox-helper.clar

diff --git a/contrib/core-contract-tests/Clarinet.toml b/contrib/core-contract-tests/Clarinet.toml
index b3ee805eb0..075681d4ef 100644
--- a/contrib/core-contract-tests/Clarinet.toml
+++ b/contrib/core-contract-tests/Clarinet.toml
@@ -15,9 +15,3 @@ path = "../../stackslib/src/chainstate/stacks/boot/pox-4.clar"
 depends_on = []
 clarity = 2
 epoch = 2.4
-
-[contracts.pox-helper]
-path = "./contracts/pox/pox-helper.clar"
-depends_on = []
-clarity = 2
-epoch = 2.4
\ No newline at end of file
diff --git a/contrib/core-contract-tests/contracts/pox/pox-helper.clar b/contrib/core-contract-tests/contracts/pox/pox-helper.clar
deleted file mode 100644
index d67f17a017..0000000000
--- a/contrib/core-contract-tests/contracts/pox/pox-helper.clar
+++ /dev/null
@@ -1,2 +0,0 @@
-(define-read-only (get-bbh)
-    burn-block-height)
\ No newline at end of file

From 756441e7045d32ad74255f8f58603af721b3ad30 Mon Sep 17 00:00:00 2001
From: friedger <mail@friedger.de>
Date: Wed, 20 Dec 2023 00:03:02 +0100
Subject: [PATCH 0245/1166] fix: make pox rejection optional, add tests

---
 stackslib/src/clarity_vm/clarity.rs           |  1 -
 stackslib/src/net/api/getpoxinfo.rs           | 51 ++++++++-------
 testnet/stacks-node/src/mockamoto/tests.rs    | 62 ++++++++++++++++++-
 .../src/tests/neon_integrations.rs            |  6 +-
 4 files changed, 94 insertions(+), 26 deletions(-)

diff --git a/stackslib/src/clarity_vm/clarity.rs b/stackslib/src/clarity_vm/clarity.rs
index bb448c6d7c..534183ba87 100644
--- a/stackslib/src/clarity_vm/clarity.rs
+++ b/stackslib/src/clarity_vm/clarity.rs
@@ -1282,7 +1282,6 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
             let first_block_height = self.burn_state_db.get_burn_start_height();
             let pox_prepare_length = self.burn_state_db.get_pox_prepare_length();
             let pox_reward_cycle_length = self.burn_state_db.get_pox_reward_cycle_length();
-            let pox_rejection_fraction = self.burn_state_db.get_pox_rejection_fraction();
             let pox_4_activation_height = self.burn_state_db.get_pox_4_activation_height();
 
             let pox_4_first_cycle = PoxConstants::static_block_height_to_reward_cycle(
diff --git a/stackslib/src/net/api/getpoxinfo.rs b/stackslib/src/net/api/getpoxinfo.rs
index 0987b9edef..32c9ed6dbf 100644
--- a/stackslib/src/net/api/getpoxinfo.rs
+++ b/stackslib/src/net/api/getpoxinfo.rs
@@ -70,7 +70,7 @@ pub struct RPCPoxNextCycleInfo {
     pub blocks_until_prepare_phase: i64,
     pub reward_phase_start_block_height: u64,
     pub blocks_until_reward_phase: u64,
-    pub ustx_until_pox_rejection: u64,
+    pub ustx_until_pox_rejection: Option<u64>,
 }
 
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
@@ -90,7 +90,7 @@ pub struct RPCPoxInfoData {
     pub prepare_phase_block_length: u64,
     pub reward_phase_block_length: u64,
     pub reward_slots: u64,
-    pub rejection_fraction: u64,
+    pub rejection_fraction: Option<u64>,
     pub total_liquid_supply_ustx: u64,
     pub current_cycle: RPCPoxCurrentCycleInfo,
     pub next_cycle: RPCPoxNextCycleInfo,
@@ -100,7 +100,7 @@ pub struct RPCPoxInfoData {
     pub prepare_cycle_length: u64,
     pub reward_cycle_id: u64,
     pub reward_cycle_length: u64,
-    pub rejection_votes_left_required: u64,
+    pub rejection_votes_left_required: Option<u64>,
     pub next_reward_cycle_in: u64,
 
     // Information specific to each PoX contract version
@@ -202,12 +202,6 @@ impl RPCPoxInfoData {
             .to_owned()
             .expect_u128() as u64;
 
-        let rejection_fraction = res
-            .get("rejection-fraction")
-            .expect(&format!("FATAL: no 'rejection-fraction'"))
-            .to_owned()
-            .expect_u128() as u64;
-
         let reward_cycle_id = res
             .get("reward-cycle-id")
             .expect(&format!("FATAL: no 'reward-cycle-id'"))
@@ -220,24 +214,39 @@ impl RPCPoxInfoData {
             .to_owned()
             .expect_u128() as u64;
 
-        let current_rejection_votes = res
-            .get("current-rejection-votes")
-            .expect(&format!("FATAL: no 'current-rejection-votes'"))
-            .to_owned()
-            .expect_u128() as u64;
-
         let total_liquid_supply_ustx = res
             .get("total-liquid-supply-ustx")
             .expect(&format!("FATAL: no 'total-liquid-supply-ustx'"))
             .to_owned()
             .expect_u128() as u64;
 
-        let total_required = (total_liquid_supply_ustx as u128 / 100)
-            .checked_mul(rejection_fraction as u128)
-            .ok_or_else(|| NetError::DBError(DBError::Overflow))?
-            as u64;
-
-        let rejection_votes_left_required = total_required.saturating_sub(current_rejection_votes);
+        let has_rejection_data = pox_contract_name == POX_1_NAME
+            || pox_contract_name == POX_2_NAME
+            || pox_contract_name == POX_3_NAME;
+
+        let (rejection_fraction, rejection_votes_left_required) = if has_rejection_data {
+            let rejection_fraction = res
+                .get("rejection-fraction")
+                .expect(&format!("FATAL: no 'rejection-fraction'"))
+                .to_owned()
+                .expect_u128() as u64;
+
+            let current_rejection_votes = res
+                .get("current-rejection-votes")
+                .expect(&format!("FATAL: no 'current-rejection-votes'"))
+                .to_owned()
+                .expect_u128() as u64;
+
+            let total_required = (total_liquid_supply_ustx as u128 / 100)
+                .checked_mul(rejection_fraction as u128)
+                .ok_or_else(|| NetError::DBError(DBError::Overflow))?
+                as u64;
+
+            let votes_left = total_required.saturating_sub(current_rejection_votes);
+            (Some(rejection_fraction), Some(votes_left))
+        } else {
+            (None, None)
+        };
 
         let burnchain_tip = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn())?;
 
diff --git a/testnet/stacks-node/src/mockamoto/tests.rs b/testnet/stacks-node/src/mockamoto/tests.rs
index 2c7df7000f..a2d43f4f75 100644
--- a/testnet/stacks-node/src/mockamoto/tests.rs
+++ b/testnet/stacks-node/src/mockamoto/tests.rs
@@ -19,7 +19,7 @@ use wsts::curve::scalar::Scalar;
 use super::MockamotoNode;
 use crate::config::{EventKeyType, EventObserverConfig};
 use crate::neon_node::PeerThread;
-use crate::tests::neon_integrations::{submit_tx, test_observer};
+use crate::tests::neon_integrations::{get_pox_info, submit_tx, test_observer};
 use crate::tests::{make_contract_call, make_stacks_transfer, to_addr};
 use crate::{Config, ConfigFile};
 
@@ -354,3 +354,63 @@ fn observe_set_aggregate_key() {
     assert_eq!(orig_aggregate_key.unwrap(), orig_key);
     assert_eq!(new_aggregate_key.unwrap(), orig_key);
 }
+
+#[test]
+fn rpc_pox_info() {
+    let mut conf = Config::from_config_file(ConfigFile::mockamoto()).unwrap();
+    conf.node.mockamoto_time_ms = 10;
+    conf.node.rpc_bind = "127.0.0.1:19543".into();
+    conf.node.p2p_bind = "127.0.0.1:19544".into();
+
+    let observer_port = 19500;
+    test_observer::spawn_at(observer_port);
+    conf.events_observers.insert(EventObserverConfig {
+        endpoint: format!("localhost:{observer_port}"),
+        events_keys: vec![EventKeyType::AnyEvent],
+    });
+
+    let mut mockamoto = MockamotoNode::new(&conf).unwrap();
+    let globals = mockamoto.globals.clone();
+
+    let http_origin = format!("http://{}", &conf.node.rpc_bind);
+
+    let start = Instant::now();
+
+    let node_thread = thread::Builder::new()
+        .name("mockamoto-main".into())
+        .spawn(move || mockamoto.run())
+        .expect("FATAL: failed to start mockamoto main thread");
+
+    // mine 5 blocks
+    let completed = loop {
+        // complete within 2 minutes or abort
+        if Instant::now().duration_since(start) > Duration::from_secs(120) {
+            break false;
+        }
+        let latest_block = test_observer::get_blocks().pop();
+        thread::sleep(Duration::from_secs(1));
+        let Some(ref latest_block) = latest_block else {
+            info!("No block observed yet!");
+            continue;
+        };
+        let stacks_block_height = latest_block.get("block_height").unwrap().as_u64().unwrap();
+        info!("Block height observed: {stacks_block_height}");
+
+        if stacks_block_height >= 5 {
+            break true;
+        }
+    };
+
+    // fetch rpc poxinfo
+    let _pox_info = get_pox_info(&http_origin);
+
+    globals.signal_stop();
+
+    assert!(
+        completed,
+        "Mockamoto node failed to produce and announce 100 blocks before timeout"
+    );
+    node_thread
+        .join()
+        .expect("Failed to join node thread to exit");
+}
diff --git a/testnet/stacks-node/src/tests/neon_integrations.rs b/testnet/stacks-node/src/tests/neon_integrations.rs
index 5676d1bb12..db507e48c4 100644
--- a/testnet/stacks-node/src/tests/neon_integrations.rs
+++ b/testnet/stacks-node/src/tests/neon_integrations.rs
@@ -5992,7 +5992,7 @@ fn pox_integration_test() {
     );
     assert_eq!(
         pox_info.rejection_fraction,
-        pox_constants.pox_rejection_fraction
+        Some(pox_constants.pox_rejection_fraction)
     );
     assert_eq!(pox_info.reward_cycle_id, 0);
     assert_eq!(pox_info.current_cycle.id, 0);
@@ -6060,7 +6060,7 @@ fn pox_integration_test() {
     );
     assert_eq!(
         pox_info.rejection_fraction,
-        pox_constants.pox_rejection_fraction
+        Some(pox_constants.pox_rejection_fraction)
     );
     assert_eq!(pox_info.reward_cycle_id, 14);
     assert_eq!(pox_info.current_cycle.id, 14);
@@ -6191,7 +6191,7 @@ fn pox_integration_test() {
     );
     assert_eq!(
         pox_info.rejection_fraction,
-        pox_constants.pox_rejection_fraction
+        Some(pox_constants.pox_rejection_fraction)
     );
     assert_eq!(pox_info.reward_cycle_id, 14);
     assert_eq!(pox_info.current_cycle.id, 14);

From 44efe57e099448ab629eb7560bcccca98dbf5344 Mon Sep 17 00:00:00 2001
From: friedger <mail@friedger.de>
Date: Wed, 20 Dec 2023 08:31:05 +0100
Subject: [PATCH 0246/1166] chore: remove unused imports

---
 testnet/stacks-node/src/mockamoto/tests.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/testnet/stacks-node/src/mockamoto/tests.rs b/testnet/stacks-node/src/mockamoto/tests.rs
index 4cd3695889..f1020cf35f 100644
--- a/testnet/stacks-node/src/mockamoto/tests.rs
+++ b/testnet/stacks-node/src/mockamoto/tests.rs
@@ -14,7 +14,7 @@ use super::MockamotoNode;
 use crate::config::{EventKeyType, EventObserverConfig};
 use crate::neon_node::PeerThread;
 use crate::tests::neon_integrations::{get_pox_info, submit_tx, test_observer};
-use crate::tests::{make_contract_call, make_stacks_transfer, to_addr};
+use crate::tests::{make_stacks_transfer, to_addr};
 use crate::{Config, ConfigFile};
 
 #[test]

From dbca59e9971e00521c8709d23272272a1e796581 Mon Sep 17 00:00:00 2001
From: "brady.ouren" <tippenein@gmail.com>
Date: Sun, 10 Dec 2023 18:09:02 -0800
Subject: [PATCH 0247/1166] change the wording around the signature description

---
 clarity/src/vm/docs/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/clarity/src/vm/docs/mod.rs b/clarity/src/vm/docs/mod.rs
index 9a019dbbc9..749dc645f9 100644
--- a/clarity/src/vm/docs/mod.rs
+++ b/clarity/src/vm/docs/mod.rs
@@ -1996,7 +1996,7 @@ const DEFINE_TRAIT_API: DefineAPI = DefineAPI {
 can implement a given trait and then have their contract identifier being passed as a function argument in order to be called
 dynamically with `contract-call?`.
 
-Traits are defined with a name, and a list functions, defined with a name, a list of argument types, and return type.
+Traits are defined with a name, a list of functions, and a return type. The list of functions here is defined with a name and the list of argument types.
 
 In Clarity 1, a trait type can be used to specify the type of a function parameter. A parameter with a trait type can
 be used as the target of a dynamic `contract-call?`. A principal literal (e.g. `ST1PQHQKV0RJXZFY1DGX8MNSNYVE3VGZJSRTPGZGM.foo`)

From 30f3b4294e29da4ccbaa81c3a37f49ced434a60b Mon Sep 17 00:00:00 2001
From: "brady.ouren" <tippenein@gmail.com>
Date: Tue, 12 Dec 2023 10:32:24 -0800
Subject: [PATCH 0248/1166] use @obycode copy

---
 clarity/src/vm/docs/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/clarity/src/vm/docs/mod.rs b/clarity/src/vm/docs/mod.rs
index 749dc645f9..3aac226086 100644
--- a/clarity/src/vm/docs/mod.rs
+++ b/clarity/src/vm/docs/mod.rs
@@ -1996,7 +1996,7 @@ const DEFINE_TRAIT_API: DefineAPI = DefineAPI {
 can implement a given trait and then have their contract identifier being passed as a function argument in order to be called
 dynamically with `contract-call?`.
 
-Traits are defined with a name, a list of functions, and a return type. The list of functions here is defined with a name and the list of argument types.
+Traits are defined with a name, and a list functions, where each function is defined with a name, a list of argument types, and a return type.
 
 In Clarity 1, a trait type can be used to specify the type of a function parameter. A parameter with a trait type can
 be used as the target of a dynamic `contract-call?`. A principal literal (e.g. `ST1PQHQKV0RJXZFY1DGX8MNSNYVE3VGZJSRTPGZGM.foo`)

From 846171498eea65d21c76219ace8646b58baf028a Mon Sep 17 00:00:00 2001
From: "brady.ouren" <tippenein@gmail.com>
Date: Tue, 12 Dec 2023 11:55:48 -0800
Subject: [PATCH 0249/1166] 'list of functions'

---
 clarity/src/vm/docs/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/clarity/src/vm/docs/mod.rs b/clarity/src/vm/docs/mod.rs
index 3aac226086..fe84f2600a 100644
--- a/clarity/src/vm/docs/mod.rs
+++ b/clarity/src/vm/docs/mod.rs
@@ -1996,7 +1996,7 @@ const DEFINE_TRAIT_API: DefineAPI = DefineAPI {
 can implement a given trait and then have their contract identifier being passed as a function argument in order to be called
 dynamically with `contract-call?`.
 
-Traits are defined with a name, and a list functions, where each function is defined with a name, a list of argument types, and a return type.
+Traits are defined with a name, and a list of functions, where each function is defined with a name, a list of argument types, and a return type.
 
 In Clarity 1, a trait type can be used to specify the type of a function parameter. A parameter with a trait type can
 be used as the target of a dynamic `contract-call?`. A principal literal (e.g. `ST1PQHQKV0RJXZFY1DGX8MNSNYVE3VGZJSRTPGZGM.foo`)

From 80ce2409e33f70007b571e39780fae9bbd81ea87 Mon Sep 17 00:00:00 2001
From: friedger <mail@friedger.de>
Date: Wed, 20 Dec 2023 17:47:36 +0100
Subject: [PATCH 0250/1166] Revert "chore: remove stack-stx, stack-extend,
 stack-increase from pox-4"

This reverts commit aabce29f222c2322b164440b22714f9d42780367.
---
 .../src/chainstate/stacks/boot/pox-4.clar     | 188 +++++++++++++++++-
 1 file changed, 186 insertions(+), 2 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index 04d5acdd11..d5c1b1e77f 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -74,7 +74,8 @@
 )
 
 ;; The Stacking lock-up state and associated metadata.
-;; Records are inserted into this map via `delegate-stack-stx` and `delegate-stack-extend`.
+;; Records are inserted into this map via `stack-stx`, `delegate-stack-stx`, `stack-extend`
+;;  `delegate-stack-extend` and burnchain transactions for invoking `stack-stx`, etc.
 ;; Records will be deleted from this map when auto-unlocks are processed
 ;;
 ;; This map de-normalizes some state from the `reward-cycle-pox-address-list` map
@@ -107,7 +108,7 @@
         ;; these indexes are only valid looking forward from
         ;;  `first-reward-cycle` (i.e., they do not correspond
         ;;  to entries in the reward set that may have been from
-        ;;  previous stacking calls, or prior to an extend)
+        ;;  previous stack-stx calls, or prior to an extend)
         reward-set-indexes: (list 12 uint),
         ;; principal of the delegate, if stacker has delegated
         delegated-to: (optional principal)
@@ -528,6 +529,65 @@
                { sender: tx-sender, contract-caller: caller }
                { until-burn-ht: until-burn-ht }))))
 
+;; Lock up some uSTX for stacking!  Note that the given amount here is in micro-STX (uSTX).
+;; The STX will be locked for the given number of reward cycles (lock-period).
+;; This is the self-service interface.  tx-sender will be the Stacker.
+;;
+;; * The given stacker cannot currently be stacking.
+;; * You will need the minimum uSTX threshold.  This will be determined by (get-stacking-minimum)
+;; at the time this method is called.
+;; * You may need to increase the amount of uSTX locked up later, since the minimum uSTX threshold
+;; may increase between reward cycles.
+;; * The Stacker will receive rewards in the reward cycle following `start-burn-ht`.
+;; Importantly, `start-burn-ht` may not be further into the future than the next reward cycle,
+;; and in most cases should be set to the current burn block height.
+;;
+;; The tokens will unlock and be returned to the Stacker (tx-sender) automatically.
+(define-public (stack-stx (amount-ustx uint)
+                          (pox-addr (tuple (version (buff 1)) (hashbytes (buff 32))))
+                          (start-burn-ht uint)
+                          (lock-period uint))
+    ;; this stacker's first reward cycle is the _next_ reward cycle
+    (let ((first-reward-cycle (+ u1 (current-pox-reward-cycle)))
+          (specified-reward-cycle (+ u1 (burn-height-to-reward-cycle start-burn-ht))))
+      ;; the start-burn-ht must result in the next reward cycle, do not allow stackers
+      ;;  to "post-date" their `stack-stx` transaction
+      (asserts! (is-eq first-reward-cycle specified-reward-cycle)
+                (err ERR_INVALID_START_BURN_HEIGHT))
+
+      ;; must be called directly by the tx-sender or by an allowed contract-caller
+      (asserts! (check-caller-allowed)
+                (err ERR_STACKING_PERMISSION_DENIED))
+
+      ;; tx-sender principal must not be stacking
+      (asserts! (is-none (get-stacker-info tx-sender))
+        (err ERR_STACKING_ALREADY_STACKED))
+
+      ;; tx-sender must not be delegating
+      (asserts! (is-none (get-check-delegation tx-sender))
+        (err ERR_STACKING_ALREADY_DELEGATED))
+
+      ;; the Stacker must have sufficient unlocked funds
+      (asserts! (>= (stx-get-balance tx-sender) amount-ustx)
+        (err ERR_STACKING_INSUFFICIENT_FUNDS))
+
+      ;; ensure that stacking can be performed
+      (try! (can-stack-stx pox-addr amount-ustx first-reward-cycle lock-period))
+
+      ;; register the PoX address with the amount stacked
+      (let ((reward-set-indexes (try! (add-pox-addr-to-reward-cycles pox-addr first-reward-cycle lock-period amount-ustx tx-sender))))
+          ;; add stacker record
+         (map-set stacking-state
+           { stacker: tx-sender }
+           { pox-addr: pox-addr,
+             reward-set-indexes: reward-set-indexes,
+             first-reward-cycle: first-reward-cycle,
+             lock-period: lock-period,
+             delegated-to: none })
+
+          ;; return the lock-up information, so the node can actually carry out the lock.
+          (ok { stacker: tx-sender, lock-amount: amount-ustx, unlock-burn-height: (reward-cycle-to-burn-height (+ first-reward-cycle lock-period)) }))))
+
 (define-public (revoke-delegate-stx)
   (begin
     ;; must be called directly by the tx-sender or by an allowed contract-caller
@@ -835,6 +895,130 @@
                     stacker: (get stacker data),
                     add-amount: (get add-amount data) })))))
 
+;; Increase the number of STX locked.
+;; *New in Stacks 2.1*
+;; This method locks up an additional amount of STX from `tx-sender`'s, indicated
+;; by `increase-by`.  The `tx-sender` must already be Stacking.
+(define-public (stack-increase (increase-by uint))
+   (let ((stacker-info (stx-account tx-sender))
+         (amount-stacked (get locked stacker-info))
+         (amount-unlocked (get unlocked stacker-info))
+         (unlock-height (get unlock-height stacker-info))
+         (cur-cycle (current-pox-reward-cycle))
+         (first-increased-cycle (+ cur-cycle u1))
+         (stacker-state (unwrap! (map-get? stacking-state
+                                          { stacker: tx-sender })
+                                          (err ERR_STACK_INCREASE_NOT_LOCKED))))
+      ;; tx-sender must be currently locked
+      (asserts! (> amount-stacked u0)
+                (err ERR_STACK_INCREASE_NOT_LOCKED))
+      ;; must be called with positive `increase-by`
+      (asserts! (>= increase-by u1)
+                (err ERR_STACKING_INVALID_AMOUNT))
+      ;; stacker must have enough stx to lock
+      (asserts! (>= amount-unlocked increase-by)
+                (err ERR_STACKING_INSUFFICIENT_FUNDS))
+      ;; must be called directly by the tx-sender or by an allowed contract-caller
+      (asserts! (check-caller-allowed)
+                (err ERR_STACKING_PERMISSION_DENIED))
+      ;; stacker must be directly stacking
+      (asserts! (> (len (get reward-set-indexes stacker-state)) u0)
+                (err ERR_STACKING_IS_DELEGATED))
+      ;; stacker must not be delegating
+      (asserts! (is-none (get delegated-to stacker-state))
+                (err ERR_STACKING_IS_DELEGATED))
+      ;; update reward cycle amounts
+      (asserts! (is-some (fold increase-reward-cycle-entry
+            (get reward-set-indexes stacker-state)
+            (some { first-cycle: first-increased-cycle,
+                    reward-cycle: (get first-reward-cycle stacker-state),
+                    stacker: tx-sender,
+                    add-amount: increase-by })))
+            (err ERR_STACKING_UNREACHABLE))
+      ;; NOTE: stacking-state map is unchanged: it does not track amount-stacked in PoX-4
+      (ok { stacker: tx-sender, total-locked: (+ amount-stacked increase-by)})))
+
+;; Extend an active Stacking lock.
+;; *New in Stacks 2.1*
+;; This method extends the `tx-sender`'s current lockup for an additional `extend-count`
+;;    and associates `pox-addr` with the rewards
+(define-public (stack-extend (extend-count uint)
+                             (pox-addr { version: (buff 1), hashbytes: (buff 32) }))
+   (let ((stacker-info (stx-account tx-sender))
+         ;; to extend, there must already be an etry in the stacking-state
+         (stacker-state (unwrap! (get-stacker-info tx-sender) (err ERR_STACK_EXTEND_NOT_LOCKED)))
+         (amount-ustx (get locked stacker-info))
+         (unlock-height (get unlock-height stacker-info))
+         (cur-cycle (current-pox-reward-cycle))
+         ;; first-extend-cycle will be the cycle in which tx-sender *would have* unlocked
+         (first-extend-cycle (burn-height-to-reward-cycle unlock-height))
+         ;; new first cycle should be max(cur-cycle, stacker-state.first-reward-cycle)
+         (cur-first-reward-cycle (get first-reward-cycle stacker-state))
+         (first-reward-cycle (if (> cur-cycle cur-first-reward-cycle) cur-cycle cur-first-reward-cycle)))
+
+    ;; must be called with positive extend-count
+    (asserts! (>= extend-count u1)
+              (err ERR_STACKING_INVALID_LOCK_PERIOD))
+
+    ;; stacker must be directly stacking
+      (asserts! (> (len (get reward-set-indexes stacker-state)) u0)
+                (err ERR_STACKING_IS_DELEGATED))
+
+    ;; stacker must not be delegating
+    (asserts! (is-none (get delegated-to stacker-state))
+              (err ERR_STACKING_IS_DELEGATED))
+
+    ;; TODO: add more assertions to sanity check the `stacker-info` values with
+    ;;       the `stacker-state` values
+
+    (let ((last-extend-cycle  (- (+ first-extend-cycle extend-count) u1))
+          (lock-period (+ u1 (- last-extend-cycle first-reward-cycle)))
+          (new-unlock-ht (reward-cycle-to-burn-height (+ u1 last-extend-cycle))))
+
+      ;; first cycle must be after the current cycle
+      (asserts! (> first-extend-cycle cur-cycle) (err ERR_STACKING_INVALID_LOCK_PERIOD))
+      ;; lock period must be positive
+      (asserts! (> lock-period u0) (err ERR_STACKING_INVALID_LOCK_PERIOD))
+
+      ;; must be called directly by the tx-sender or by an allowed contract-caller
+      (asserts! (check-caller-allowed)
+                (err ERR_STACKING_PERMISSION_DENIED))
+
+      ;; tx-sender must be locked
+      (asserts! (> amount-ustx u0)
+        (err ERR_STACK_EXTEND_NOT_LOCKED))
+
+      ;; tx-sender must not be delegating
+      (asserts! (is-none (get-check-delegation tx-sender))
+        (err ERR_STACKING_ALREADY_DELEGATED))
+
+      ;; standard can-stack-stx checks
+      (try! (can-stack-stx pox-addr amount-ustx first-extend-cycle lock-period))
+
+      ;; register the PoX address with the amount stacked
+      ;;   for the new cycles
+      (let ((extended-reward-set-indexes (try! (add-pox-addr-to-reward-cycles pox-addr first-extend-cycle extend-count amount-ustx tx-sender)))
+            (reward-set-indexes
+                ;; use the active stacker state and extend the existing reward-set-indexes
+                (let ((cur-cycle-index (- first-reward-cycle (get first-reward-cycle stacker-state)))
+                      (old-indexes (get reward-set-indexes stacker-state))
+                      ;; build index list by taking the old-indexes starting from cur cycle
+                      ;;  and adding the new indexes to it. this way, the index is valid starting from the current cycle
+                      (new-list (concat (default-to (list) (slice? old-indexes cur-cycle-index (len old-indexes)))
+                                        extended-reward-set-indexes)))
+                  (unwrap-panic (as-max-len? new-list u12)))))
+          ;; update stacker record
+          (map-set stacking-state
+            { stacker: tx-sender }
+            { pox-addr: pox-addr,
+              reward-set-indexes: reward-set-indexes,
+              first-reward-cycle: first-reward-cycle,
+              lock-period: lock-period,
+              delegated-to: none })
+
+        ;; return lock-up information
+        (ok { stacker: tx-sender, unlock-burn-height: new-unlock-ht })))))
+
 ;; As a delegator, increase an active Stacking lock, issuing a "partial commitment" for the
 ;;   increased cycles.
 ;; *New in Stacks 2.1*

From c96c9456f15fa7ee93fefb03daf418ca296e746d Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Wed, 20 Dec 2023 12:53:15 -0600
Subject: [PATCH 0251/1166] fix: nakamoto_node::relayer to send IssueCommit
 directives w/ tenure start, not chain tip

---
 stacks-signer/src/runloop.rs                  |  2 +-
 .../stacks-node/src/nakamoto_node/relayer.rs  |  4 +-
 .../src/tests/nakamoto_integrations.rs        | 66 +++++++++++++++----
 3 files changed, 57 insertions(+), 15 deletions(-)

diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 9aac0ca227..a0691168b3 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -1,8 +1,8 @@
-use hashbrown::{HashMap, HashSet};
 use std::collections::VecDeque;
 use std::sync::mpsc::Sender;
 use std::time::Duration;
 
+use hashbrown::{HashMap, HashSet};
 use libsigner::{SignerRunLoop, StackerDBChunksEvent};
 use slog::{slog_debug, slog_error, slog_info, slog_warn};
 use stacks_common::{debug, error, info, warn};
diff --git a/testnet/stacks-node/src/nakamoto_node/relayer.rs b/testnet/stacks-node/src/nakamoto_node/relayer.rs
index f10a327b60..cf1e71ede2 100644
--- a/testnet/stacks-node/src/nakamoto_node/relayer.rs
+++ b/testnet/stacks-node/src/nakamoto_node/relayer.rs
@@ -779,8 +779,8 @@ impl RelayerThread {
 
         if should_commit {
             Some(RelayerDirective::IssueBlockCommit(
-                chain_tip_header.consensus_hash,
-                chain_tip_header.anchored_header.block_hash(),
+                chain_tip_tenure_start.consensus_hash,
+                chain_tip_tenure_start.anchored_header.block_hash(),
             ))
         } else {
             None
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index ad011309b7..a188d81937 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -202,6 +202,29 @@ where
     Ok(())
 }
 
+/// Mine a bitcoin block, and wait until:
+///  (1) a new block has been processed by the coordinator
+fn next_block_and_process_new_stacks_block(
+    btc_controller: &mut BitcoinRegtestController,
+    timeout_secs: u64,
+    coord_channels: &Arc<Mutex<CoordinatorChannels>>,
+) -> Result<(), String> {
+    let blocks_processed_before = coord_channels
+        .lock()
+        .expect("Mutex poisoned")
+        .get_stacks_blocks_processed();
+    next_block_and(btc_controller, timeout_secs, || {
+        let blocks_processed = coord_channels
+            .lock()
+            .expect("Mutex poisoned")
+            .get_stacks_blocks_processed();
+        if blocks_processed > blocks_processed_before {
+            return Ok(true);
+        }
+        Ok(false)
+    })
+}
+
 /// Mine a bitcoin block, and wait until:
 ///  (1) a new block has been processed by the coordinator
 ///  (2) 2 block commits have been issued ** or ** more than 10 seconds have
@@ -219,26 +242,41 @@ fn next_block_and_mine_commit(
         .get_stacks_blocks_processed();
     let commits_before = commits_submitted.load(Ordering::SeqCst);
     let mut block_processed_time: Option<Instant> = None;
+    let mut commit_sent_time: Option<Instant> = None;
     next_block_and(btc_controller, timeout_secs, || {
         let commits_sent = commits_submitted.load(Ordering::SeqCst);
         let blocks_processed = coord_channels
             .lock()
             .expect("Mutex poisoned")
             .get_stacks_blocks_processed();
-
+        let now = Instant::now();
         if blocks_processed > blocks_processed_before && block_processed_time.is_none() {
-            block_processed_time.replace(Instant::now());
+            block_processed_time.replace(now);
+        }
+        if commits_sent > commits_before && commit_sent_time.is_none() {
+            commit_sent_time.replace(now);
         }
         if blocks_processed > blocks_processed_before {
             let block_processed_time = block_processed_time
                 .as_ref()
                 .ok_or("TEST-ERROR: Processed time wasn't set")?;
+            if commits_sent <= commits_before {
+                return Ok(false);
+            }
+            let commit_sent_time = commit_sent_time
+                .as_ref()
+                .ok_or("TEST-ERROR: Processed time wasn't set")?;
+            // try to ensure the commit was sent after the block was processed
+            if commit_sent_time > block_processed_time {
+                return Ok(true);
+            }
+            // if two commits have been sent, one of them must have been after
             if commits_sent >= commits_before + 2 {
                 return Ok(true);
             }
-            if commits_sent >= commits_before + 1
-                && block_processed_time.elapsed() > Duration::from_secs(6)
-            {
+            // otherwise, just timeout if the commit was sent and its been long enough
+            //  for a new commit pass to have occurred
+            if block_processed_time.elapsed() > Duration::from_secs(10) {
                 return Ok(true);
             }
             Ok(false)
@@ -600,13 +638,9 @@ fn mine_multiple_per_tenure_integration() {
 
     // Mine `tenure_count` nakamoto tenures
     for tenure_ix in 0..tenure_count {
-        next_block_and_mine_commit(
-            &mut btc_regtest_controller,
-            60,
-            &coord_channel,
-            &commits_submitted,
-        )
-        .unwrap();
+        let commits_before = commits_submitted.load(Ordering::SeqCst);
+        next_block_and_process_new_stacks_block(&mut btc_regtest_controller, 60, &coord_channel)
+            .unwrap();
 
         // mine the interim blocks
         for interim_block_ix in 0..inter_blocks_per_tenure {
@@ -631,6 +665,14 @@ fn mine_multiple_per_tenure_integration() {
                 thread::sleep(Duration::from_millis(100));
             }
         }
+
+        let start_time = Instant::now();
+        while commits_submitted.load(Ordering::SeqCst) <= commits_before {
+            if start_time.elapsed() >= Duration::from_secs(20) {
+                panic!("Timed out waiting for block-commit");
+            }
+            thread::sleep(Duration::from_millis(100));
+        }
     }
 
     // load the chain tip, and assert that it is a nakamoto block and at least 30 blocks have advanced in epoch 3

From d0882a7ac6bfdd970b1366ead6cc725d79c8f91d Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Wed, 20 Dec 2023 13:20:10 -0600
Subject: [PATCH 0252/1166] fix: coinbase_height, not stacks_height

---
 stackslib/src/chainstate/nakamoto/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index 28d71caa1a..16525cd806 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -2435,7 +2435,7 @@ impl NakamotoChainState {
                 Self::calculate_matured_miner_rewards(
                     &mut clarity_tx,
                     sortition_dbconn.sqlite_conn(),
-                    parent_stacks_height,
+                    coinbase_height,
                     matured_rewards_schedule,
                 )
             })

From ed2ae3abedba23de03c3a084445a1b72954ff4a5 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Thu, 21 Dec 2023 13:53:56 -0600
Subject: [PATCH 0253/1166] fix: RBF-mechanism should check bitcoin RPC to see
 if ongoing_op confirmed

---
 .github/workflows/bitcoin-tests.yml           |  1 +
 .../burnchains/bitcoin_regtest_controller.rs  | 70 ++++++++++---
 .../src/tests/neon_integrations.rs            | 99 ++++++++++++++++++-
 3 files changed, 156 insertions(+), 14 deletions(-)

diff --git a/.github/workflows/bitcoin-tests.yml b/.github/workflows/bitcoin-tests.yml
index 64a1101e40..fb77c94624 100644
--- a/.github/workflows/bitcoin-tests.yml
+++ b/.github/workflows/bitcoin-tests.yml
@@ -68,6 +68,7 @@ jobs:
           - tests::neon_integrations::test_problematic_microblocks_are_not_relayed_or_stored
           - tests::neon_integrations::test_problematic_txs_are_not_stored
           - tests::neon_integrations::use_latest_tip_integration_test
+          - tests::neon_integrations::confirm_unparsed_ongoing_ops
           - tests::should_succeed_handling_malformed_and_valid_txs
           - tests::nakamoto_integrations::simple_neon_integration
           - tests::nakamoto_integrations::mine_multiple_per_tenure_integration
diff --git a/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs b/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
index 7d1a2aec08..24b99f2795 100644
--- a/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
+++ b/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
@@ -64,6 +64,10 @@ use super::{BurnchainController, BurnchainTip, Error as BurnchainControllerError
 const UTXO_CACHE_STALENESS_LIMIT: u64 = 6;
 const DUST_UTXO_LIMIT: u64 = 5500;
 
+#[cfg(test)]
+// Used to inject invalid block commits during testing.
+pub static TEST_MAGIC_BYTES: std::sync::Mutex<Option<[u8; 2]>> = std::sync::Mutex::new(None);
+
 pub struct BitcoinRegtestController {
     config: Config,
     indexer: BitcoinIndexer,
@@ -1174,6 +1178,20 @@ impl BitcoinRegtestController {
         Some(tx)
     }
 
+    fn magic_bytes(&self) -> Vec<u8> {
+        #[cfg(test)]
+        {
+            if let Some(set_bytes) = TEST_MAGIC_BYTES
+                .lock()
+                .expect("FATAL: test magic bytes mutex poisoned")
+                .clone()
+            {
+                return set_bytes.to_vec();
+            }
+        }
+        self.config.burnchain.magic_bytes.as_bytes().to_vec()
+    }
+
     fn send_block_commit_operation(
         &mut self,
         epoch_id: StacksEpochId,
@@ -1205,7 +1223,7 @@ impl BitcoinRegtestController {
         // Serialize the payload
         let op_bytes = {
             let mut buffer = vec![];
-            let mut magic_bytes = self.config.burnchain.magic_bytes.as_bytes().to_vec();
+            let mut magic_bytes = self.magic_bytes();
             buffer.append(&mut magic_bytes);
             payload
                 .consensus_serialize(&mut buffer)
@@ -1302,10 +1320,18 @@ impl BitcoinRegtestController {
         let burnchain_db = self.burnchain_db.as_ref().expect("BurnchainDB not opened");
 
         for txid in ongoing_op.txids.iter() {
+            // check if ongoing_op is in the burnchain_db *or* has been confirmed via the bitcoin RPC
             let mined_op = burnchain_db.find_burnchain_op(&self.indexer, txid);
-            if mined_op.is_some() {
-                // Good to go, the transaction in progress was mined
-                debug!("Was able to retrieve ongoing TXID - {}", txid);
+            let ongoing_tx_confirmed = mined_op.is_some()
+                || matches!(
+                    BitcoinRPCRequest::check_transaction_confirmed(&self.config, txid),
+                    Ok(true)
+                );
+            if ongoing_tx_confirmed {
+                debug!(
+                    "Was able to retrieve confirmation of ongoing burnchain TXID - {}",
+                    txid
+                );
                 let res = self.send_block_commit_operation(
                     epoch_id,
                     payload,
@@ -1318,7 +1344,7 @@ impl BitcoinRegtestController {
                 return res;
             } else {
                 debug!("Was unable to retrieve ongoing TXID - {}", txid);
-            }
+            };
         }
 
         // Did a re-org occur since we fetched our UTXOs, or are the UTXOs so stale that they should be abandoned?
@@ -1818,14 +1844,6 @@ impl BitcoinRegtestController {
         self.config.miner.segwit = segwit;
     }
 
-    #[cfg(test)]
-    pub fn set_allow_rbf(&mut self, val: bool) {
-        self.allow_rbf = val;
-    }
-
-    #[cfg(not(test))]
-    pub fn set_allow_rbf(&mut self, _val: bool) {}
-
     pub fn make_operation_tx(
         &mut self,
         epoch_id: StacksEpochId,
@@ -2213,6 +2231,32 @@ impl BitcoinRPCRequest {
         Ok(res.get("result").unwrap().as_str().unwrap().to_string())
     }
 
+    /// Was a given transaction ID confirmed by the burnchain?
+    pub fn check_transaction_confirmed(config: &Config, txid: &Txid) -> RPCResult<bool> {
+        let payload = BitcoinRPCRequest {
+            method: "gettransaction".to_string(),
+            params: vec![format!("{}", txid).into()],
+            id: "stacks".to_string(),
+            jsonrpc: "2.0".to_string(),
+        };
+        let res = BitcoinRPCRequest::send(&config, payload)?;
+        let confirmations = res
+            .get("result")
+            .ok_or_else(|| RPCError::Parsing("No 'result' field in bitcoind RPC response".into()))?
+            .get("confirmations")
+            .ok_or_else(|| {
+                RPCError::Parsing("No 'confirmations' field in bitcoind RPC response".into())
+            })?
+            .as_i64()
+            .ok_or_else(|| {
+                RPCError::Parsing(
+                    "Expected 'confirmations' field to be numeric in bitcoind RPC response".into(),
+                )
+            })?;
+
+        Ok(confirmations >= 1)
+    }
+
     pub fn generate_to_address(config: &Config, num_blocks: u64, address: String) -> RPCResult<()> {
         debug!("Generate {} blocks to {}", num_blocks, &address);
         let payload = BitcoinRPCRequest {
diff --git a/testnet/stacks-node/src/tests/neon_integrations.rs b/testnet/stacks-node/src/tests/neon_integrations.rs
index 5676d1bb12..fb1a085b1b 100644
--- a/testnet/stacks-node/src/tests/neon_integrations.rs
+++ b/testnet/stacks-node/src/tests/neon_integrations.rs
@@ -68,7 +68,7 @@ use super::{
     make_microblock, make_stacks_transfer, make_stacks_transfer_mblock_only, to_addr, ADDR_4, SK_1,
     SK_2,
 };
-use crate::burnchains::bitcoin_regtest_controller::{BitcoinRPCRequest, UTXO};
+use crate::burnchains::bitcoin_regtest_controller::{self, BitcoinRPCRequest, UTXO};
 use crate::config::{EventKeyType, EventObserverConfig, FeeEstimatorName, InitialBalance};
 use crate::operations::BurnchainOpSigner;
 use crate::stacks_common::types::PrivateKey;
@@ -928,6 +928,103 @@ fn bitcoind_integration_test() {
     channel.stop_chains_coordinator();
 }
 
+#[test]
+#[ignore]
+/// Test that the RBF/ongoing_ops mechanism can detect that a submitted
+/// tx has been confirmed even if the burnchaindb doesn't parse it.
+/// This test forces the neon_node to submit a block commit with bad
+///  magic bytes, and then checks if mining can continue afterwards.
+fn confirm_unparsed_ongoing_ops() {
+    if env::var("BITCOIND_TEST") != Ok("1".into()) {
+        return;
+    }
+
+    let (mut conf, miner_account) = neon_integration_test_conf();
+    conf.node.wait_time_for_blocks = 1000;
+    conf.burnchain.pox_reward_length = Some(500);
+    conf.burnchain.max_rbf = 1000000;
+
+    test_observer::spawn();
+
+    conf.events_observers.insert(EventObserverConfig {
+        endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
+        events_keys: vec![EventKeyType::AnyEvent],
+    });
+
+    let mut btcd_controller = BitcoinCoreController::new(conf.clone());
+    btcd_controller
+        .start_bitcoind()
+        .map_err(|_e| ())
+        .expect("Failed starting bitcoind");
+
+    let mut btc_regtest_controller = BitcoinRegtestController::new(conf.clone(), None);
+    let http_origin = format!("http://{}", &conf.node.rpc_bind);
+
+    btc_regtest_controller.bootstrap_chain(201);
+
+    eprintln!("Chain bootstrapped...");
+
+    let mut run_loop = neon::RunLoop::new(conf);
+    let blocks_processed = run_loop.get_blocks_processed_arc();
+
+    let channel = run_loop.get_coordinator_channel().unwrap();
+
+    thread::spawn(move || run_loop.start(None, 0));
+
+    // give the run loop some time to start up!
+    wait_for_runloop(&blocks_processed);
+
+    // first block wakes up the run loop
+    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+
+    // this block will hold our VRF registration
+    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+
+    // second bitcoin block will contain the first mined Stacks block, and then issue a 2nd valid commit
+    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+
+    // now, let's alter the miner's magic bytes
+    bitcoin_regtest_controller::TEST_MAGIC_BYTES
+        .lock()
+        .unwrap()
+        .replace(['Z' as u8, 'Z' as u8]);
+
+    // let's trigger another mining loop: this should create an invalid block commit.
+    // this bitcoin block will contain the valid commit created before (so, a second stacks block)
+    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+
+    // reset the miner's magic bytes
+    bitcoin_regtest_controller::TEST_MAGIC_BYTES
+        .lock()
+        .unwrap()
+        .take()
+        .unwrap();
+
+    // trigger another mining loop: this will mine the invalid block commit into a bitcoin block
+    //  if the block wasn't created in 25 seconds, just timeout -- the test will fail
+    //  at the final checks
+    // in correct behavior, this will create a 3rd valid block commit
+    next_block_and_wait_with_timeout(&mut btc_regtest_controller, &blocks_processed, 25);
+
+    // trigger another mining loop: this will mine the last valid block commit. after this,
+    //  the node *should* see 3 stacks blocks.
+    next_block_and_wait_with_timeout(&mut btc_regtest_controller, &blocks_processed, 25);
+
+    // query the miner's account nonce
+
+    eprintln!("Miner account: {}", miner_account);
+
+    let account = get_account(&http_origin, &miner_account);
+    assert_eq!(account.balance, 0);
+    assert_eq!(
+        account.nonce, 3,
+        "Miner should have mined 3 coinbases -- one should be invalid"
+    );
+
+    test_observer::clear();
+    channel.stop_chains_coordinator();
+}
+
 #[test]
 #[ignore]
 fn most_recent_utxo_integration_test() {

From 4fbe89f67cccd2fb49e9f4ab6877c90346028f63 Mon Sep 17 00:00:00 2001
From: friedger <mail@friedger.de>
Date: Tue, 26 Dec 2023 14:05:54 +0100
Subject: [PATCH 0254/1166] chore: remove unused constant

---
 stackslib/src/chainstate/stacks/boot/pox-4.clar | 1 -
 1 file changed, 1 deletion(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index dc6f66ab28..402c25c507 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -65,7 +65,6 @@
 
 ;; Stacking thresholds
 (define-constant STACKING_THRESHOLD_25 (if is-in-mainnet u20000 u8000))
-(define-constant STACKING_THRESHOLD_100 (if is-in-mainnet u5000 u2000))
 
 ;; Data vars that store a copy of the burnchain configuration.
 ;; Implemented as data-vars, so that different configurations can be

From 1e9e53b5055e735ca3cee05508d265c65aee1f80 Mon Sep 17 00:00:00 2001
From: MarvinJanssen <MarvinJanssen@users.noreply.github.com>
Date: Fri, 22 Dec 2023 00:21:28 +0100
Subject: [PATCH 0255/1166] feat: pox4 signer key read/write with base Rust
 tests

---
 .../chainstate/nakamoto/coordinator/tests.rs  | 157 ++++----
 stackslib/src/chainstate/stacks/boot/mod.rs   | 323 ++++++++-------
 .../src/chainstate/stacks/boot/pox-4.clar     |  78 +++-
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 377 +++++++++++++++++-
 4 files changed, 677 insertions(+), 258 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index 3e9231e614..978d338010 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -56,7 +56,7 @@ fn advance_to_nakamoto(peer: &mut TestPeer) {
         1,
         &vec![StacksPublicKey::from_private(&private_key)],
     )
-    .unwrap();
+        .unwrap();
 
     for sortition_height in 0..11 {
         // stack to pox-3 in cycle 7
@@ -68,6 +68,7 @@ fn advance_to_nakamoto(peer: &mut TestPeer) {
                 1_000_000_000_000_000_000,
                 PoxAddress::from_legacy(AddressHashMode::SerializeP2PKH, addr.bytes.clone()),
                 12,
+                vec![0; 33],
                 34,
             );
             vec![stack_tx]
@@ -97,7 +98,7 @@ pub fn boot_nakamoto(
         1,
         &vec![StacksPublicKey::from_private(&private_key)],
     )
-    .unwrap();
+        .unwrap();
 
     // reward cycles are 5 blocks long
     // first 25 blocks are boot-up
@@ -141,8 +142,8 @@ fn make_replay_peer<'a>(peer: &'a mut TestPeer<'a>) -> TestPeer<'a> {
             replay_tip.block_height,
             &tip.sortition_id,
         )
-        .unwrap()
-        .unwrap();
+            .unwrap()
+            .unwrap();
         ancestor_tip
     };
 
@@ -220,7 +221,7 @@ fn replay_reward_cycle(
             &mut node.chainstate,
             block.clone(),
         )
-        .unwrap();
+            .unwrap();
         if accepted {
             test_debug!("Accepted Nakamoto block {block_id}");
             peer.coord.handle_new_nakamoto_stacks_block().unwrap();
@@ -296,7 +297,7 @@ fn test_simple_nakamoto_coordinator_1_tenure_10_blocks() {
         1,
         &vec![StacksPublicKey::from_private(&private_key)],
     )
-    .unwrap();
+        .unwrap();
 
     let mut test_signers = TestSigners::default();
     let mut peer = boot_nakamoto(
@@ -418,7 +419,7 @@ fn test_nakamoto_chainstate_getters() {
         1,
         &vec![StacksPublicKey::from_private(&private_key)],
     )
-    .unwrap();
+        .unwrap();
     let mut test_signers = TestSigners::default();
     let mut peer = boot_nakamoto(
         function_name!(),
@@ -542,16 +543,16 @@ fn test_nakamoto_chainstate_getters() {
                 &tip.index_block_hash(),
                 coinbase_height,
             )
-            .unwrap();
+                .unwrap();
             let header = header_opt.expect("No tenure");
 
             if coinbase_height
                 <= tip
-                    .anchored_header
-                    .as_stacks_nakamoto()
-                    .unwrap()
-                    .chain_length
-                    - 10
+                .anchored_header
+                .as_stacks_nakamoto()
+                .unwrap()
+                .chain_length
+                - 10
             {
                 // all tenures except the last are epoch2
                 assert!(header.anchored_header.as_stacks_epoch2().is_some());
@@ -585,53 +586,53 @@ fn test_nakamoto_chainstate_getters() {
             sort_tx.tx(),
             &highest_tenure.tenure_id_consensus_hash,
         )
-        .unwrap()
-        .unwrap();
+            .unwrap()
+            .unwrap();
 
         // this tenure's TC tx is the first-ever TC
         let tenure_change_payload = blocks[0].get_tenure_change_tx_payload().unwrap().clone();
 
         assert!(NakamotoChainState::check_first_nakamoto_tenure_change(
             chainstate.db(),
-            &tenure_change_payload
+            &tenure_change_payload,
         )
-        .unwrap()
-        .is_some());
+            .unwrap()
+            .is_some());
         assert!(NakamotoChainState::check_tenure_continuity(
             chainstate.db(),
             sort_tx.sqlite(),
             &blocks[0].header.consensus_hash,
-            &blocks[1].header
+            &blocks[1].header,
         )
-        .unwrap());
+            .unwrap());
         assert!(NakamotoChainState::check_valid_consensus_hash(
             &mut sort_tx,
-            &tenure_change_payload.tenure_consensus_hash
+            &tenure_change_payload.tenure_consensus_hash,
         )
-        .unwrap()
-        .is_some());
+            .unwrap()
+            .is_some());
         assert!(NakamotoChainState::check_valid_consensus_hash(
             &mut sort_tx,
-            &tenure_change_payload.prev_tenure_consensus_hash
+            &tenure_change_payload.prev_tenure_consensus_hash,
         )
-        .unwrap()
-        .is_some());
+            .unwrap()
+            .is_some());
         assert!(NakamotoChainState::check_valid_consensus_hash(
             &mut sort_tx,
-            &tenure_change_payload.burn_view_consensus_hash
+            &tenure_change_payload.burn_view_consensus_hash,
         )
-        .unwrap()
-        .is_some());
+            .unwrap()
+            .is_some());
 
         // this should fail, since it's not idempotent -- the highest tenure _is_ this tenure
         assert!(NakamotoChainState::check_nakamoto_tenure(
             chainstate.db(),
             &mut sort_tx,
             &blocks[0].header,
-            &tenure_change_payload
+            &tenure_change_payload,
         )
-        .unwrap()
-        .is_none());
+            .unwrap()
+            .is_none());
 
         let cur_burn_tip = SortitionDB::get_canonical_burn_chain_tip(sort_tx.sqlite()).unwrap();
         let (cur_stacks_ch, cur_stacks_bhh, cur_stacks_height) =
@@ -650,17 +651,17 @@ fn test_nakamoto_chainstate_getters() {
             chainstate.db(),
             &blocks[0].header.consensus_hash,
         )
-        .unwrap();
+            .unwrap();
 
         // check works (this would be the first tenure)
         assert!(NakamotoChainState::check_nakamoto_tenure(
             chainstate.db(),
             &mut sort_tx,
             &blocks[0].header,
-            &tenure_change_payload
+            &tenure_change_payload,
         )
-        .unwrap()
-        .is_some());
+            .unwrap()
+            .is_some());
 
         // restore
         sort_tx
@@ -678,7 +679,7 @@ fn test_nakamoto_chainstate_getters() {
             1,
             &tenure_change_payload,
         )
-        .unwrap();
+            .unwrap();
     }
 
     debug!("\n======================================\nBegin second tenure\n===========================================\n");
@@ -715,7 +716,7 @@ fn test_nakamoto_chainstate_getters() {
         &next_consensus_hash,
         &txid,
     )
-    .unwrap();
+        .unwrap();
     assert_eq!(parent_vrf_proof, vrf_proof);
 
     // make the second tenure's blocks
@@ -782,61 +783,61 @@ fn test_nakamoto_chainstate_getters() {
 
         assert!(NakamotoChainState::check_first_nakamoto_tenure_change(
             chainstate.db(),
-            &tenure_change_payload
+            &tenure_change_payload,
         )
-        .unwrap()
-        .is_none());
+            .unwrap()
+            .is_none());
         assert!(NakamotoChainState::check_tenure_continuity(
             chainstate.db(),
             sort_tx.sqlite(),
             &new_blocks[0].header.consensus_hash,
-            &new_blocks[1].header
+            &new_blocks[1].header,
         )
-        .unwrap());
+            .unwrap());
         assert!(!NakamotoChainState::check_tenure_continuity(
             chainstate.db(),
             sort_tx.sqlite(),
             &blocks[0].header.consensus_hash,
-            &new_blocks[1].header
+            &new_blocks[1].header,
         )
-        .unwrap());
+            .unwrap());
 
         assert!(NakamotoChainState::check_valid_consensus_hash(
             &mut sort_tx,
-            &tenure_change_payload.tenure_consensus_hash
+            &tenure_change_payload.tenure_consensus_hash,
         )
-        .unwrap()
-        .is_some());
+            .unwrap()
+            .is_some());
         assert!(NakamotoChainState::check_valid_consensus_hash(
             &mut sort_tx,
-            &tenure_change_payload.prev_tenure_consensus_hash
+            &tenure_change_payload.prev_tenure_consensus_hash,
         )
-        .unwrap()
-        .is_some());
+            .unwrap()
+            .is_some());
         assert!(NakamotoChainState::check_valid_consensus_hash(
             &mut sort_tx,
-            &tenure_change_payload.burn_view_consensus_hash
+            &tenure_change_payload.burn_view_consensus_hash,
         )
-        .unwrap()
-        .is_some());
+            .unwrap()
+            .is_some());
         assert!(NakamotoChainState::check_valid_consensus_hash(
             &mut sort_tx,
-            &old_tenure_change_payload.tenure_consensus_hash
+            &old_tenure_change_payload.tenure_consensus_hash,
         )
-        .unwrap()
-        .is_some());
+            .unwrap()
+            .is_some());
         assert!(NakamotoChainState::check_valid_consensus_hash(
             &mut sort_tx,
-            &old_tenure_change_payload.prev_tenure_consensus_hash
+            &old_tenure_change_payload.prev_tenure_consensus_hash,
         )
-        .unwrap()
-        .is_some());
+            .unwrap()
+            .is_some());
         assert!(NakamotoChainState::check_valid_consensus_hash(
             &mut sort_tx,
-            &old_tenure_change_payload.burn_view_consensus_hash
+            &old_tenure_change_payload.burn_view_consensus_hash,
         )
-        .unwrap()
-        .is_some());
+            .unwrap()
+            .is_some());
 
         let cur_burn_tip = SortitionDB::get_canonical_burn_chain_tip(sort_tx.sqlite()).unwrap();
         let (cur_stacks_ch, cur_stacks_bhh, cur_stacks_height) =
@@ -854,26 +855,26 @@ fn test_nakamoto_chainstate_getters() {
             chainstate.db(),
             &new_blocks[0].header.consensus_hash,
         )
-        .unwrap();
+            .unwrap();
 
         assert!(NakamotoChainState::check_nakamoto_tenure(
             chainstate.db(),
             &mut sort_tx,
             &new_blocks[0].header,
-            &tenure_change_payload
+            &tenure_change_payload,
         )
-        .unwrap()
-        .is_some());
+            .unwrap()
+            .is_some());
 
         // checks on older confired tenures continue to fail
         assert!(NakamotoChainState::check_nakamoto_tenure(
             chainstate.db(),
             &mut sort_tx,
             &blocks[0].header,
-            &old_tenure_change_payload
+            &old_tenure_change_payload,
         )
-        .unwrap()
-        .is_none());
+            .unwrap()
+            .is_none());
 
         // restore
         sort_tx
@@ -891,7 +892,7 @@ fn test_nakamoto_chainstate_getters() {
             2,
             &tenure_change_payload,
         )
-        .unwrap();
+            .unwrap();
     }
 }
 
@@ -906,7 +907,7 @@ fn test_simple_nakamoto_coordinator_10_tenures_10_blocks() {
         1,
         &vec![StacksPublicKey::from_private(&private_key)],
     )
-    .unwrap();
+        .unwrap();
 
     let mut test_signers = TestSigners::default();
     let mut peer = boot_nakamoto(
@@ -929,7 +930,7 @@ fn test_simple_nakamoto_coordinator_10_tenures_10_blocks() {
         1,
         &vec![StacksPublicKey::from_private(&private_key)],
     )
-    .unwrap();
+        .unwrap();
 
     for i in 0..10 {
         let (burn_ops, mut tenure_change, miner_key) =
@@ -1112,7 +1113,7 @@ fn test_simple_nakamoto_coordinator_10_tenures_10_blocks() {
                 &tip.index_block_hash(),
                 i,
             )
-            .unwrap();
+                .unwrap();
             matured_rewards.push(matured_reward_opt);
         }
     }
@@ -1132,7 +1133,7 @@ fn test_simple_nakamoto_coordinator_10_tenures_10_blocks() {
                 matured_reward.parent_miner.tx_fees,
                 MinerPaymentTxFees::Epoch2 {
                     anchored: 0,
-                    streamed: 0
+                    streamed: 0,
                 }
             );
         } else if i == 11 {
@@ -1166,7 +1167,7 @@ fn test_simple_nakamoto_coordinator_10_tenures_10_blocks() {
                 miner_reward.tx_fees,
                 MinerPaymentTxFees::Epoch2 {
                     anchored: 0,
-                    streamed: 0
+                    streamed: 0,
                 }
             );
         } else if i == 10 {
@@ -1227,7 +1228,7 @@ fn test_simple_nakamoto_coordinator_2_tenures_3_sortitions() {
         1,
         &vec![StacksPublicKey::from_private(&private_key)],
     )
-    .unwrap();
+        .unwrap();
     let mut test_signers = TestSigners::default();
     let mut peer = boot_nakamoto(
         function_name!(),
@@ -1555,7 +1556,7 @@ fn test_simple_nakamoto_coordinator_10_tenures_and_extensions_10_blocks() {
         1,
         &vec![StacksPublicKey::from_private(&private_key)],
     )
-    .unwrap();
+        .unwrap();
     let mut test_signers = TestSigners::default();
     let mut peer = boot_nakamoto(
         function_name!(),
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 975f3ab986..5f0f5d3352 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -246,12 +246,12 @@ impl StacksChainState {
                         &format!(r#"
                             (unwrap-panic (map-get? stacking-state {{ stacker: '{unlocked_principal} }}))
                             "#,
-                            unlocked_principal = Value::Principal(principal.clone())
+                                 unlocked_principal = Value::Principal(principal.clone())
                         ),
-                        ASTRules::PrecheckSize
+                        ASTRules::PrecheckSize,
                     )
                 })
-                .expect("FATAL: failed to query unlocked principal");
+            .expect("FATAL: failed to query unlocked principal");
 
         user_stacking_state.expect_tuple()
     }
@@ -499,7 +499,7 @@ impl StacksChainState {
             "pox",
             &format!("(get-stacking-minimum)"),
         )
-        .map(|value| value.expect_u128())
+            .map(|value| value.expect_u128())
     }
 
     pub fn get_total_ustx_stacked(
@@ -553,7 +553,7 @@ impl StacksChainState {
             "pox",
             &format!("(get-total-ustx-stacked u{})", reward_cycle),
         )
-        .map(|value| value.expect_u128())
+            .map(|value| value.expect_u128())
     }
 
     /// Is PoX active in the given reward cycle?
@@ -570,7 +570,7 @@ impl StacksChainState {
             pox_contract,
             &format!("(is-pox-active u{})", reward_cycle),
         )
-        .map(|value| value.expect_bool())
+            .map(|value| value.expect_bool())
     }
 
     /// Given a threshold and set of registered addresses, return a reward set where
@@ -592,10 +592,10 @@ impl StacksChainState {
             addresses.sort_by_cached_key(|k| k.reward_address.to_burnchain_repr());
         }
         while let Some(RawRewardSetEntry {
-            reward_address: address,
-            amount_stacked: mut stacked_amt,
-            stacker,
-        }) = addresses.pop()
+                           reward_address: address,
+                           amount_stacked: mut stacked_amt,
+                           stacker,
+                       }) = addresses.pop()
         {
             let mut contributed_stackers = vec![];
             if let Some(stacker) = stacker.as_ref() {
@@ -1116,8 +1116,8 @@ impl StacksChainState {
         // there hasn't yet been a Stacks block.
         match result {
             Err(Error::ClarityError(ClarityError::Interpreter(VmError::Unchecked(
-                CheckErrors::NoSuchContract(_),
-            )))) => {
+                                                                  CheckErrors::NoSuchContract(_),
+                                                              )))) => {
                 warn!("Reward cycle attempted to calculate rewards before the PoX contract was instantiated");
                 return Ok(vec![]);
             }
@@ -1269,9 +1269,9 @@ pub mod test {
             StacksChainState::get_reward_threshold_and_participation(
                 &test_pox_constants,
                 &[],
-                liquid
+                liquid,
             )
-            .0,
+                .0,
             POX_THRESHOLD_STEPS_USTX
         );
         assert_eq!(
@@ -1280,11 +1280,11 @@ pub mod test {
                 &[RawRewardSetEntry {
                     reward_address: rand_pox_addr(),
                     amount_stacked: liquid,
-                    stacker: None
+                    stacker: None,
                 }],
-                liquid
+                liquid,
             )
-            .0,
+                .0,
             POX_THRESHOLD_STEPS_USTX
         );
 
@@ -1294,9 +1294,9 @@ pub mod test {
             StacksChainState::get_reward_threshold_and_participation(
                 &test_pox_constants,
                 &[],
-                liquid
+                liquid,
             )
-            .0,
+                .0,
             50_000 * MICROSTACKS_PER_STACKS as u128
         );
         // should be the same at 25% participation
@@ -1306,11 +1306,11 @@ pub mod test {
                 &[RawRewardSetEntry {
                     reward_address: rand_pox_addr(),
                     amount_stacked: liquid / 4,
-                    stacker: None
+                    stacker: None,
                 }],
-                liquid
+                liquid,
             )
-            .0,
+                .0,
             50_000 * MICROSTACKS_PER_STACKS as u128
         );
         // but not at 30% participation
@@ -1321,17 +1321,17 @@ pub mod test {
                     RawRewardSetEntry {
                         reward_address: rand_pox_addr(),
                         amount_stacked: liquid / 4,
-                        stacker: None
+                        stacker: None,
                     },
                     RawRewardSetEntry {
                         reward_address: rand_pox_addr(),
                         amount_stacked: 10_000_000 * (MICROSTACKS_PER_STACKS as u128),
-                        stacker: None
+                        stacker: None,
                     },
                 ],
-                liquid
+                liquid,
             )
-            .0,
+                .0,
             60_000 * MICROSTACKS_PER_STACKS as u128
         );
 
@@ -1343,17 +1343,17 @@ pub mod test {
                     RawRewardSetEntry {
                         reward_address: rand_pox_addr(),
                         amount_stacked: liquid / 4,
-                        stacker: None
+                        stacker: None,
                     },
                     RawRewardSetEntry {
                         reward_address: rand_pox_addr(),
                         amount_stacked: MICROSTACKS_PER_STACKS as u128,
-                        stacker: None
+                        stacker: None,
                     },
                 ],
-                liquid
+                liquid,
             )
-            .0,
+                .0,
             60_000 * MICROSTACKS_PER_STACKS as u128
         );
 
@@ -1364,11 +1364,11 @@ pub mod test {
                 &[RawRewardSetEntry {
                     reward_address: rand_pox_addr(),
                     amount_stacked: liquid,
-                    stacker: None
+                    stacker: None,
                 }],
-                liquid
+                liquid,
             )
-            .0,
+                .0,
             200_000 * MICROSTACKS_PER_STACKS as u128
         );
     }
@@ -1384,7 +1384,7 @@ pub mod test {
             1,
             &vec![StacksPublicKey::from_private(key)],
         )
-        .unwrap()
+            .unwrap()
     }
 
     pub fn instantiate_pox_peer<'a>(
@@ -1417,19 +1417,19 @@ pub mod test {
             StacksPrivateKey::from_hex(
                 "7e3ee1f2a0ae11b785a1f0e725a9b3ab0a5fd6cc057d43763b0a85f256fdec5d01",
             )
-            .unwrap(),
+                .unwrap(),
             StacksPrivateKey::from_hex(
                 "11d055ac8b0ab4f04c5eb5ea4b4def9c60ae338355d81c9411b27b4f49da2a8301",
             )
-            .unwrap(),
+                .unwrap(),
             StacksPrivateKey::from_hex(
                 "00eed368626b96e482944e02cc136979973367491ea923efb57c482933dd7c0b01",
             )
-            .unwrap(),
+                .unwrap(),
             StacksPrivateKey::from_hex(
                 "00380ff3c05350ee313f60f30313acb4b5fc21e50db4151bf0de4cd565eb823101",
             )
-            .unwrap(),
+                .unwrap(),
         ];
 
         let addrs: Vec<StacksAddress> = keys.iter().map(|pk| key_to_stacks_addr(pk)).collect();
@@ -1541,8 +1541,8 @@ pub mod test {
     }
 
     pub fn with_sortdb<F, R>(peer: &mut TestPeer, todo: F) -> R
-    where
-        F: FnOnce(&mut StacksChainState, &SortitionDB) -> R,
+        where
+            F: FnOnce(&mut StacksChainState, &SortitionDB) -> R,
     {
         let sortdb = peer.sortdb.take().unwrap();
         let r = todo(peer.chainstate(), &sortdb);
@@ -1592,7 +1592,7 @@ pub mod test {
                     })),
                 ),
             ])
-            .unwrap(),
+                .unwrap(),
         )
     }
 
@@ -1640,20 +1640,15 @@ pub mod test {
         make_pox_2_or_3_lockup(key, nonce, amount, addr, lock_period, burn_ht, POX_3_NAME)
     }
 
-    /// TODO: add signer key
     pub fn make_pox_4_lockup(
         key: &StacksPrivateKey,
         nonce: u64,
         amount: u128,
         addr: PoxAddress,
         lock_period: u128,
+        signer_key: Vec<u8>,
         burn_ht: u64,
     ) -> StacksTransaction {
-        // ;; TODO: add signer key
-        // (define-public (stack-stx (amount-ustx uint)
-        //                           (pox-addr (tuple (version (buff 1)) (hashbytes (buff 32))))
-        //                           (burn-height uint)
-        //                           (lock-period uint))
         let addr_tuple = Value::Tuple(addr.as_clarity_tuple().unwrap());
         let payload = TransactionPayload::new_contract_call(
             boot_code_test_addr(),
@@ -1664,9 +1659,10 @@ pub mod test {
                 addr_tuple,
                 Value::UInt(burn_ht as u128),
                 Value::UInt(lock_period),
+                Value::buff_from(signer_key).unwrap(),
             ],
         )
-        .unwrap();
+            .unwrap();
 
         make_tx(key, nonce, 0, payload)
     }
@@ -1696,7 +1692,7 @@ pub mod test {
                 Value::UInt(lock_period),
             ],
         )
-        .unwrap();
+            .unwrap();
 
         make_tx(key, nonce, 0, payload)
     }
@@ -1715,7 +1711,7 @@ pub mod test {
             "set-aggregate-public-key",
             vec![Value::UInt(reward_cycle as u128), aggregate_public_key],
         )
-        .unwrap();
+            .unwrap();
         make_tx(key, nonce, 0, payload)
     }
 
@@ -1730,7 +1726,7 @@ pub mod test {
             "stack-increase",
             vec![Value::UInt(amount)],
         )
-        .unwrap();
+            .unwrap();
 
         make_tx(key, nonce, 0, payload)
     }
@@ -1748,7 +1744,7 @@ pub mod test {
             "stack-extend",
             vec![Value::UInt(lock_period), addr_tuple],
         )
-        .unwrap();
+            .unwrap();
 
         make_tx(key, nonce, 0, payload)
     }
@@ -1766,7 +1762,7 @@ pub mod test {
             "stack-extend",
             vec![Value::UInt(lock_period), addr_tuple],
         )
-        .unwrap();
+            .unwrap();
 
         make_tx(key, nonce, 0, payload)
     }
@@ -1776,15 +1772,16 @@ pub mod test {
         nonce: u64,
         addr: PoxAddress,
         lock_period: u128,
+        signer_key: Vec<u8>,
     ) -> StacksTransaction {
         let addr_tuple = Value::Tuple(addr.as_clarity_tuple().unwrap());
         let payload = TransactionPayload::new_contract_call(
             boot_code_test_addr(),
             POX_4_NAME,
             "stack-extend",
-            vec![Value::UInt(lock_period), addr_tuple],
+            vec![Value::UInt(lock_period), addr_tuple, Value::buff_from(signer_key).unwrap()],
         )
-        .unwrap();
+            .unwrap();
 
         make_tx(key, nonce, 0, payload)
     }
@@ -1820,7 +1817,7 @@ pub mod test {
             function_name,
             args,
         )
-        .unwrap();
+            .unwrap();
 
         make_tx(key, nonce, 0, payload)
     }
@@ -1837,7 +1834,7 @@ pub mod test {
             function_name,
             args,
         )
-        .unwrap();
+            .unwrap();
 
         make_tx(key, nonce, 0, payload)
     }
@@ -1854,7 +1851,24 @@ pub mod test {
             function_name,
             args,
         )
-        .unwrap();
+            .unwrap();
+
+        make_tx(key, nonce, 0, payload)
+    }
+
+    pub fn make_pox_4_contract_call(
+        key: &StacksPrivateKey,
+        nonce: u64,
+        function_name: &str,
+        args: Vec<Value>,
+    ) -> StacksTransaction {
+        let payload = TransactionPayload::new_contract_call(
+            boot_code_test_addr(),
+            POX_4_NAME,
+            function_name,
+            args,
+        )
+            .unwrap();
 
         make_tx(key, nonce, 0, payload)
     }
@@ -1880,7 +1894,7 @@ pub mod test {
                     })),
                 ),
             ])
-            .unwrap(),
+                .unwrap(),
         );
 
         let generator = |amount, pox_addr, lock_period, nonce| {
@@ -2006,7 +2020,7 @@ pub mod test {
                 Value::UInt(lock_period),
             ],
         )
-        .unwrap();
+            .unwrap();
         make_tx(key, nonce, 0, payload)
     }
 
@@ -2024,7 +2038,7 @@ pub mod test {
             "withdraw-stx",
             vec![Value::UInt(amount)],
         )
-        .unwrap();
+            .unwrap();
         make_tx(key, nonce, 0, payload)
     }
 
@@ -2080,15 +2094,15 @@ pub mod test {
                     &tip.sortition_id,
                     &block.block_hash(),
                 )
-                .unwrap()
-                .unwrap(); // succeeds because we don't fork
+                    .unwrap()
+                    .unwrap(); // succeeds because we don't fork
                 StacksChainState::get_anchored_block_header_info(
                     chainstate.db(),
                     &snapshot.consensus_hash,
                     &snapshot.winning_stacks_block_hash,
                 )
-                .unwrap()
-                .unwrap()
+                    .unwrap()
+                    .unwrap()
             }
         };
         parent_tip
@@ -2142,7 +2156,7 @@ pub mod test {
                         tip.total_burn,
                         microblock_pubkeyhash,
                     )
-                    .unwrap();
+                        .unwrap();
                     let (anchored_block, _size, _cost) =
                         StacksBlockBuilder::make_anchored_block_from_txs(
                             block_builder,
@@ -2150,7 +2164,7 @@ pub mod test {
                             &sortdb.index_conn(),
                             block_txs,
                         )
-                        .unwrap();
+                            .unwrap();
                     (anchored_block, vec![])
                 },
             );
@@ -2264,7 +2278,7 @@ pub mod test {
                         tip.total_burn,
                         microblock_pubkeyhash,
                     )
-                    .unwrap();
+                        .unwrap();
                     let (anchored_block, _size, _cost) =
                         StacksBlockBuilder::make_anchored_block_from_txs(
                             block_builder,
@@ -2272,7 +2286,7 @@ pub mod test {
                             &sortdb.index_conn(),
                             block_txs,
                         )
-                        .unwrap();
+                            .unwrap();
                     (anchored_block, vec![])
                 },
             );
@@ -2351,7 +2365,6 @@ pub mod test {
                     let tx = make_tx(&alice, 7, 0, cc_payload.clone()); // should be allowed!
                     block_txs.push(alice_allowance);
                     block_txs.push(tx);
-
                 }
 
                 let block_builder = StacksBlockBuilder::make_regtest_block_builder(&parent_tip, vrf_proof, tip.total_burn, microblock_pubkeyhash).unwrap();
@@ -2455,7 +2468,7 @@ pub mod test {
                         tip.total_burn,
                         microblock_pubkeyhash,
                     )
-                    .unwrap();
+                        .unwrap();
                     let (anchored_block, _size, _cost) =
                         StacksBlockBuilder::make_anchored_block_from_txs(
                             block_builder,
@@ -2463,7 +2476,7 @@ pub mod test {
                             &sortdb.index_conn(),
                             block_txs,
                         )
-                        .unwrap();
+                            .unwrap();
                     (anchored_block, vec![])
                 },
             );
@@ -2499,8 +2512,8 @@ pub mod test {
                 state.db(),
                 &parent_block_id,
             )
-            .unwrap()
-            .unwrap();
+                .unwrap()
+                .unwrap();
 
         parent_header_info.burn_header_height as u64
     }
@@ -2565,7 +2578,7 @@ pub mod test {
                         tip.total_burn,
                         microblock_pubkeyhash,
                     )
-                    .unwrap();
+                        .unwrap();
                     let (anchored_block, _size, _cost) =
                         StacksBlockBuilder::make_anchored_block_from_txs(
                             block_builder,
@@ -2573,7 +2586,7 @@ pub mod test {
                             &sortdb.index_conn(),
                             block_txs,
                         )
-                        .unwrap();
+                            .unwrap();
                     (anchored_block, vec![])
                 },
             );
@@ -2601,7 +2614,7 @@ pub mod test {
                 let min_ustx = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                     chainstate.get_stacking_minimum(sortdb, &tip_index_block)
                 })
-                .unwrap();
+                    .unwrap();
                 assert_eq!(min_ustx, total_liquid_ustx / TESTNET_STACKING_THRESHOLD_25);
 
                 // no reward addresses
@@ -2613,7 +2626,7 @@ pub mod test {
                         &tip_index_block,
                     )
                 })
-                .unwrap();
+                    .unwrap();
                 assert_eq!(reward_addrs.len(), 0);
 
                 // record the first reward cycle when Alice's tokens get stacked
@@ -2645,7 +2658,7 @@ pub mod test {
                 let min_ustx = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                     chainstate.get_stacking_minimum(sortdb, &tip_index_block)
                 })
-                .unwrap();
+                    .unwrap();
                 let reward_addrs = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                     get_reward_addresses_with_par_tip(
                         chainstate,
@@ -2654,7 +2667,7 @@ pub mod test {
                         &tip_index_block,
                     )
                 })
-                .unwrap();
+                    .unwrap();
                 let total_stacked = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                     chainstate.test_get_total_ustx_stacked(
                         sortdb,
@@ -2662,7 +2675,7 @@ pub mod test {
                         cur_reward_cycle,
                     )
                 })
-                .unwrap();
+                    .unwrap();
 
                 eprintln!("\ntenure: {}\nreward cycle: {}\nmin-uSTX: {}\naddrs: {:?}\ntotal_liquid_ustx: {}\ntotal-stacked: {}\n", tenure_id, cur_reward_cycle, min_ustx, &reward_addrs, total_liquid_ustx, total_stacked);
 
@@ -2782,7 +2795,7 @@ pub mod test {
                         tip.total_burn,
                         microblock_pubkeyhash,
                     )
-                    .unwrap();
+                        .unwrap();
                     let (anchored_block, _size, _cost) =
                         StacksBlockBuilder::make_anchored_block_from_txs(
                             block_builder,
@@ -2790,7 +2803,7 @@ pub mod test {
                             &sortdb.index_conn(),
                             block_txs,
                         )
-                        .unwrap();
+                            .unwrap();
                     (anchored_block, vec![])
                 },
             );
@@ -2852,7 +2865,7 @@ pub mod test {
                 let min_ustx = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                     chainstate.get_stacking_minimum(sortdb, &tip_index_block)
                 })
-                .unwrap();
+                    .unwrap();
                 assert_eq!(min_ustx, total_liquid_ustx / TESTNET_STACKING_THRESHOLD_25);
 
                 // no reward addresses
@@ -2864,7 +2877,7 @@ pub mod test {
                         &tip_index_block,
                     )
                 })
-                .unwrap();
+                    .unwrap();
                 assert_eq!(reward_addrs.len(), 0);
 
                 // record the first reward cycle when tokens get stacked
@@ -2898,7 +2911,7 @@ pub mod test {
                 let min_ustx = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                     chainstate.get_stacking_minimum(sortdb, &tip_index_block)
                 })
-                .unwrap();
+                    .unwrap();
                 let reward_addrs = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                     get_reward_addresses_with_par_tip(
                         chainstate,
@@ -2907,7 +2920,7 @@ pub mod test {
                         &tip_index_block,
                     )
                 })
-                .unwrap();
+                    .unwrap();
                 let total_stacked = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                     chainstate.test_get_total_ustx_stacked(
                         sortdb,
@@ -2915,7 +2928,7 @@ pub mod test {
                         cur_reward_cycle,
                     )
                 })
-                .unwrap();
+                    .unwrap();
 
                 eprintln!("\ntenure: {}\nreward cycle: {}\nmin-uSTX: {}\naddrs: {:?}\ntotal_liquid_ustx: {}\ntotal-stacked: {}\n", tenure_id, cur_reward_cycle, min_ustx, &reward_addrs, total_liquid_ustx, total_stacked);
 
@@ -3039,7 +3052,7 @@ pub mod test {
                         tip.total_burn,
                         microblock_pubkeyhash,
                     )
-                    .unwrap();
+                        .unwrap();
                     let (anchored_block, _size, _cost) =
                         StacksBlockBuilder::make_anchored_block_from_txs(
                             block_builder,
@@ -3047,7 +3060,7 @@ pub mod test {
                             &sortdb.index_conn(),
                             block_txs,
                         )
-                        .unwrap();
+                            .unwrap();
                     (anchored_block, vec![])
                 },
             );
@@ -3067,7 +3080,7 @@ pub mod test {
                 let min_ustx = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                     chainstate.get_stacking_minimum(sortdb, &tip_index_block)
                 })
-                .unwrap();
+                    .unwrap();
                 assert_eq!(min_ustx, total_liquid_ustx / TESTNET_STACKING_THRESHOLD_25);
 
                 // no reward addresses
@@ -3079,7 +3092,7 @@ pub mod test {
                         &tip_index_block,
                     )
                 })
-                .unwrap();
+                    .unwrap();
                 assert_eq!(reward_addrs.len(), 0);
 
                 // record the first reward cycle when Alice's tokens get stacked
@@ -3110,7 +3123,7 @@ pub mod test {
                 let min_ustx = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                     chainstate.get_stacking_minimum(sortdb, &tip_index_block)
                 })
-                .unwrap();
+                    .unwrap();
                 let reward_addrs = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                     get_reward_addresses_with_par_tip(
                         chainstate,
@@ -3119,7 +3132,7 @@ pub mod test {
                         &tip_index_block,
                     )
                 })
-                .unwrap();
+                    .unwrap();
                 let total_stacked = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                     chainstate.test_get_total_ustx_stacked(
                         sortdb,
@@ -3127,7 +3140,7 @@ pub mod test {
                         cur_reward_cycle,
                     )
                 })
-                .unwrap();
+                    .unwrap();
 
                 eprintln!("\ntenure: {}\nreward cycle: {}\nmin-uSTX: {}\naddrs: {:?}\ntotal_liquid_ustx: {}\ntotal-stacked: {}\n", tenure_id, cur_reward_cycle, min_ustx, &reward_addrs, total_liquid_ustx, total_stacked);
 
@@ -3162,7 +3175,7 @@ pub mod test {
                                 &mut peer,
                                 &make_contract_id(&key_to_stacks_addr(&bob), "do-lockup").into(),
                             )
-                            .unwrap();
+                                .unwrap();
                         eprintln!("\nContract: {} uSTX stacked for {} cycle(s); addr is {:?}; first reward cycle is {}\n", amount_ustx, lock_period, &pox_addr, first_reward_cycle);
 
                         // should be consistent with the API call
@@ -3313,7 +3326,7 @@ pub mod test {
                         tip.total_burn,
                         microblock_pubkeyhash,
                     )
-                    .unwrap();
+                        .unwrap();
                     let (anchored_block, _size, _cost) =
                         StacksBlockBuilder::make_anchored_block_from_txs(
                             block_builder,
@@ -3321,7 +3334,7 @@ pub mod test {
                             &sortdb.index_conn(),
                             block_txs,
                         )
-                        .unwrap();
+                            .unwrap();
                     (anchored_block, vec![])
                 },
             );
@@ -3346,7 +3359,7 @@ pub mod test {
                 let min_ustx = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                     chainstate.get_stacking_minimum(sortdb, &tip_index_block)
                 })
-                .unwrap();
+                    .unwrap();
                 assert_eq!(min_ustx, total_liquid_ustx / TESTNET_STACKING_THRESHOLD_25);
 
                 // no reward addresses
@@ -3358,7 +3371,7 @@ pub mod test {
                         &tip_index_block,
                     )
                 })
-                .unwrap();
+                    .unwrap();
                 assert_eq!(reward_addrs.len(), 0);
 
                 // record the first reward cycle when Alice's tokens get stacked
@@ -3396,7 +3409,7 @@ pub mod test {
                 let min_ustx = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                     chainstate.get_stacking_minimum(sortdb, &tip_index_block)
                 })
-                .unwrap();
+                    .unwrap();
                 let reward_addrs = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                     get_reward_addresses_with_par_tip(
                         chainstate,
@@ -3405,7 +3418,7 @@ pub mod test {
                         &tip_index_block,
                     )
                 })
-                .unwrap();
+                    .unwrap();
 
                 eprintln!(
                     "\nreward cycle: {}\nmin-uSTX: {}\naddrs: {:?}\ntotal_liquid_ustx: {}\n",
@@ -3595,7 +3608,7 @@ pub mod test {
                         &tip_index_block,
                     )
                 })
-                .unwrap();
+                    .unwrap();
                 assert_eq!(reward_addrs.len(), 0);
 
                 // record the first reward cycle when Alice's tokens get stacked
@@ -3728,7 +3741,7 @@ pub mod test {
                         tip.total_burn,
                         microblock_pubkeyhash,
                     )
-                    .unwrap();
+                        .unwrap();
                     let (anchored_block, _size, _cost) =
                         StacksBlockBuilder::make_anchored_block_from_txs(
                             block_builder,
@@ -3736,7 +3749,7 @@ pub mod test {
                             &sortdb.index_conn(),
                             block_txs,
                         )
-                        .unwrap();
+                            .unwrap();
                     (anchored_block, vec![])
                 },
             );
@@ -3757,7 +3770,7 @@ pub mod test {
                 let min_ustx = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                     chainstate.get_stacking_minimum(sortdb, &tip_index_block)
                 })
-                .unwrap();
+                    .unwrap();
                 assert_eq!(min_ustx, total_liquid_ustx / TESTNET_STACKING_THRESHOLD_25);
 
                 // no reward addresses
@@ -3769,7 +3782,7 @@ pub mod test {
                         &tip_index_block,
                     )
                 })
-                .unwrap();
+                    .unwrap();
                 assert_eq!(reward_addrs.len(), 0);
 
                 // record the first reward cycle when Alice's tokens get stacked
@@ -3799,7 +3812,7 @@ pub mod test {
                 let min_ustx = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                     chainstate.get_stacking_minimum(sortdb, &tip_index_block)
                 })
-                .unwrap();
+                    .unwrap();
                 let reward_addrs = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                     get_reward_addresses_with_par_tip(
                         chainstate,
@@ -3808,7 +3821,7 @@ pub mod test {
                         &tip_index_block,
                     )
                 })
-                .unwrap();
+                    .unwrap();
                 let total_stacked = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                     chainstate.test_get_total_ustx_stacked(
                         sortdb,
@@ -3816,7 +3829,7 @@ pub mod test {
                         cur_reward_cycle,
                     )
                 })
-                .unwrap();
+                    .unwrap();
 
                 eprintln!("\ntenure: {}\nreward cycle: {}\nmin-uSTX: {}\naddrs: {:?}\ntotal_liquid_ustx: {}\ntotal-stacked: {}\n", tenure_id, cur_reward_cycle, min_ustx, &reward_addrs, total_liquid_ustx, total_stacked);
 
@@ -4026,7 +4039,7 @@ pub mod test {
                         tip.total_burn,
                         microblock_pubkeyhash,
                     )
-                    .unwrap();
+                        .unwrap();
                     let (anchored_block, _size, _cost) =
                         StacksBlockBuilder::make_anchored_block_from_txs(
                             block_builder,
@@ -4034,7 +4047,7 @@ pub mod test {
                             &sortdb.index_conn(),
                             block_txs,
                         )
-                        .unwrap();
+                            .unwrap();
                     (anchored_block, vec![])
                 },
             );
@@ -4060,15 +4073,15 @@ pub mod test {
             let reward_addrs = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                 get_reward_addresses_with_par_tip(chainstate, &burnchain, sortdb, &tip_index_block)
             })
-            .unwrap();
+                .unwrap();
             let min_ustx = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                 chainstate.get_stacking_minimum(sortdb, &tip_index_block)
             })
-            .unwrap();
+                .unwrap();
             let total_stacked = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                 chainstate.test_get_total_ustx_stacked(sortdb, &tip_index_block, cur_reward_cycle)
             })
-            .unwrap();
+                .unwrap();
 
             if tenure_id <= 1 {
                 if tenure_id < 1 {
@@ -4082,7 +4095,7 @@ pub mod test {
                 let min_ustx = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                     chainstate.get_stacking_minimum(sortdb, &tip_index_block)
                 })
-                .unwrap();
+                    .unwrap();
                 assert_eq!(min_ustx, total_liquid_ustx / TESTNET_STACKING_THRESHOLD_25);
 
                 // no reward addresses
@@ -4118,7 +4131,7 @@ pub mod test {
                 let min_ustx = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                     chainstate.get_stacking_minimum(sortdb, &tip_index_block)
                 })
-                .unwrap();
+                    .unwrap();
                 assert_eq!(min_ustx, total_liquid_ustx / TESTNET_STACKING_THRESHOLD_25);
 
                 // no reward addresses
@@ -4169,7 +4182,7 @@ pub mod test {
                             &mut peer,
                             &make_contract_id(&key_to_stacks_addr(&bob), "do-lockup").into(),
                         )
-                        .unwrap();
+                            .unwrap();
                     eprintln!("\nCharlie: {} uSTX stacked for {} cycle(s); addr is {:?}; first reward cycle is {}\n", amount_ustx, lock_period, &pox_addr, first_reward_cycle);
 
                     assert_eq!(first_reward_cycle, first_pox_reward_cycle);
@@ -4245,9 +4258,9 @@ pub mod test {
                     );
                     assert!(get_stacker_info(
                         &mut peer,
-                        &make_contract_id(&key_to_stacks_addr(&bob), "do-lockup").into()
+                        &make_contract_id(&key_to_stacks_addr(&bob), "do-lockup").into(),
                     )
-                    .is_none());
+                        .is_none());
 
                     // empty reward cycle
                     assert_eq!(reward_addrs.len(), 0);
@@ -4296,7 +4309,7 @@ pub mod test {
                             &mut peer,
                             &make_contract_id(&key_to_stacks_addr(&bob), "do-lockup").into(),
                         )
-                        .unwrap();
+                            .unwrap();
                     eprintln!("\nCharlie: {} uSTX stacked for {} cycle(s); addr is {:?}; second reward cycle is {}\n", amount_ustx, lock_period, &pox_addr, second_reward_cycle);
 
                     assert_eq!(first_pox_reward_cycle, second_reward_cycle);
@@ -4378,9 +4391,9 @@ pub mod test {
                     );
                     assert!(get_stacker_info(
                         &mut peer,
-                        &make_contract_id(&key_to_stacks_addr(&bob), "do-lockup").into()
+                        &make_contract_id(&key_to_stacks_addr(&bob), "do-lockup").into(),
                     )
-                    .is_none());
+                        .is_none());
 
                     // empty reward cycle
                     assert_eq!(reward_addrs.len(), 0);
@@ -4606,7 +4619,7 @@ pub mod test {
                         tip.total_burn,
                         microblock_pubkeyhash,
                     )
-                    .unwrap();
+                        .unwrap();
                     let (anchored_block, _size, _cost) =
                         StacksBlockBuilder::make_anchored_block_from_txs(
                             block_builder,
@@ -4614,7 +4627,7 @@ pub mod test {
                             &sortdb.index_conn(),
                             block_txs,
                         )
-                        .unwrap();
+                            .unwrap();
                     (anchored_block, vec![])
                 },
             );
@@ -4704,15 +4717,15 @@ pub mod test {
             let min_ustx = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                 chainstate.get_stacking_minimum(sortdb, &tip_index_block)
             })
-            .unwrap();
+                .unwrap();
             let reward_addrs = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                 get_reward_addresses_with_par_tip(chainstate, &burnchain, sortdb, &tip_index_block)
             })
-            .unwrap();
+                .unwrap();
             let total_stacked = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                 chainstate.test_get_total_ustx_stacked(sortdb, &tip_index_block, cur_reward_cycle)
             })
-            .unwrap();
+                .unwrap();
 
             eprintln!("\ntenure: {}\nreward cycle: {}\nmin-uSTX: {}\naddrs: {:?}\ntotal_liquid_ustx: {}\ntotal-stacked: {}\n", tenure_id, cur_reward_cycle, min_ustx, &reward_addrs, total_liquid_ustx, total_stacked);
 
@@ -4720,7 +4733,7 @@ pub mod test {
                 if tenure_id < 1 {
                     // no one has locked
                     for (balance, expected_balance) in
-                        balances.iter().zip(balances_before_stacking.iter())
+                    balances.iter().zip(balances_before_stacking.iter())
                     {
                         assert_eq!(balance, expected_balance);
                     }
@@ -4736,7 +4749,7 @@ pub mod test {
                         &tip_index_block,
                     )
                 })
-                .unwrap();
+                    .unwrap();
                 assert_eq!(reward_addrs.len(), 0);
 
                 // record the first reward cycle when Alice's tokens get stacked
@@ -4754,9 +4767,9 @@ pub mod test {
                 // alice did _NOT_ spend
                 assert!(get_contract(
                     &mut peer,
-                    &make_contract_id(&key_to_stacks_addr(&alice), "alice-try-spend").into()
+                    &make_contract_id(&key_to_stacks_addr(&alice), "alice-try-spend").into(),
                 )
-                .is_none());
+                    .is_none());
             }
 
             if reward_cycle > 0 {
@@ -4775,7 +4788,7 @@ pub mod test {
 
                     // in stacker order
                     for (i, (pox_addr, expected_stacked)) in
-                        sorted_expected_pox_info.iter().enumerate()
+                    sorted_expected_pox_info.iter().enumerate()
                     {
                         assert_eq!((reward_addrs[i].0).version(), pox_addr.0);
                         assert_eq!((reward_addrs[i].0).hash160(), pox_addr.1);
@@ -4794,14 +4807,14 @@ pub mod test {
 
                     // all tokens locked
                     for (balance, expected_balance) in
-                        balances.iter().zip(balances_during_stacking.iter())
+                    balances.iter().zip(balances_during_stacking.iter())
                     {
                         assert_eq!(balance, expected_balance);
                     }
 
                     // Lock-up is consistent with stacker state
                     for (addr, expected_balance) in
-                        stacker_addrs.iter().zip(balances_stacked.iter())
+                    stacker_addrs.iter().zip(balances_stacked.iter())
                     {
                         let account = get_account(&mut peer, addr);
                         assert_eq!(account.stx_balance.amount_unlocked(), 0);
@@ -4819,14 +4832,14 @@ pub mod test {
                     if tenure_id < 11 {
                         // all balances should have been restored
                         for (balance, expected_balance) in
-                            balances.iter().zip(balances_after_stacking.iter())
+                        balances.iter().zip(balances_after_stacking.iter())
                         {
                             assert_eq!(balance, expected_balance);
                         }
                     } else {
                         // some balances reduced, but none are zero
                         for (balance, expected_balance) in
-                            balances.iter().zip(balances_after_spending.iter())
+                        balances.iter().zip(balances_after_spending.iter())
                         {
                             assert_eq!(balance, expected_balance);
                         }
@@ -4848,7 +4861,7 @@ pub mod test {
             if tenure_id >= 11 {
                 // all balances are restored
                 for (addr, expected_balance) in
-                    stacker_addrs.iter().zip(balances_after_spending.iter())
+                stacker_addrs.iter().zip(balances_after_spending.iter())
                 {
                     let account = get_account(&mut peer, addr);
                     assert_eq!(account.stx_balance.amount_unlocked(), *expected_balance);
@@ -4943,12 +4956,12 @@ pub mod test {
                     // Charlie tries to stack, but it should fail.
                     // Specifically, (stack-stx) should fail with (err 17).
                     let charlie_stack = make_bare_contract(&charlie, 2, 0, "charlie-try-stack",
-                        &format!(
-                            "(define-data-var test-passed bool false)
+                                                           &format!(
+                                                               "(define-data-var test-passed bool false)
                              (var-set test-passed (is-eq
                                (err 17)
                                (print (contract-call? '{}.pox stack-stx u10240000000000 {{ version: 0x01, hashbytes: 0x1111111111111111111111111111111111111111 }} burn-block-height u1))))",
-                               boot_code_test_addr()));
+                                                               boot_code_test_addr()));
 
                     block_txs.push(charlie_stack);
 
@@ -4957,24 +4970,24 @@ pub mod test {
                     // stacked.
                     // If it's the case, then this tx will NOT be mined
                     let alice_reject = make_bare_contract(&alice, 1, 0, "alice-try-reject",
-                        &format!(
-                            "(define-data-var test-passed bool false)
+                                                          &format!(
+                                                              "(define-data-var test-passed bool false)
                              (var-set test-passed (is-eq
                                (err 3)
                                (print (contract-call? '{}.pox reject-pox))))",
-                               boot_code_test_addr()));
+                                                              boot_code_test_addr()));
 
                     block_txs.push(alice_reject);
 
                     // Charlie tries to reject again, but it should fail.
                     // Specifically, (reject-pox) should fail with (err 17).
                     let charlie_reject = make_bare_contract(&charlie, 3, 0, "charlie-try-reject",
-                        &format!(
-                            "(define-data-var test-passed bool false)
+                                                            &format!(
+                                                                "(define-data-var test-passed bool false)
                              (var-set test-passed (is-eq
                                (err 17)
                                (print (contract-call? '{}.pox reject-pox))))",
-                               boot_code_test_addr()));
+                                                                boot_code_test_addr()));
 
                     block_txs.push(charlie_reject);
                 }
@@ -5006,15 +5019,15 @@ pub mod test {
             let min_ustx = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                 chainstate.get_stacking_minimum(sortdb, &tip_index_block)
             })
-            .unwrap();
+                .unwrap();
             let reward_addrs = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                 get_reward_addresses_with_par_tip(chainstate, &burnchain, sortdb, &tip_index_block)
             })
-            .unwrap();
+                .unwrap();
             let total_stacked = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                 chainstate.test_get_total_ustx_stacked(sortdb, &tip_index_block, cur_reward_cycle)
             })
-            .unwrap();
+                .unwrap();
             let total_stacked_next = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                 chainstate.test_get_total_ustx_stacked(
                     sortdb,
@@ -5022,9 +5035,9 @@ pub mod test {
                     cur_reward_cycle + 1,
                 )
             })
-            .unwrap();
+                .unwrap();
 
-            eprintln!("\ntenure: {}\nreward cycle: {}\nmin-uSTX: {}\naddrs: {:?}\ntotal_liquid_ustx: {}\ntotal-stacked: {}\ntotal-stacked next: {}\n", 
+            eprintln!("\ntenure: {}\nreward cycle: {}\nmin-uSTX: {}\naddrs: {:?}\ntotal_liquid_ustx: {}\ntotal-stacked: {}\ntotal-stacked next: {}\n",
                       tenure_id, cur_reward_cycle, min_ustx, &reward_addrs, total_liquid_ustx, total_stacked, total_stacked_next);
 
             if tenure_id <= 1 {
@@ -5067,7 +5080,7 @@ pub mod test {
                         "charlie-try-stack",
                         "(var-get test-passed)",
                     )
-                    .expect_bool();
+                        .expect_bool();
                     assert!(result, "charlie-try-stack test should be `true`");
                     let result = eval_contract_at_tip(
                         &mut peer,
@@ -5075,7 +5088,7 @@ pub mod test {
                         "charlie-try-reject",
                         "(var-get test-passed)",
                     )
-                    .expect_bool();
+                        .expect_bool();
                     assert!(result, "charlie-try-reject test should be `true`");
                     let result = eval_contract_at_tip(
                         &mut peer,
@@ -5083,7 +5096,7 @@ pub mod test {
                         "alice-try-reject",
                         "(var-get test-passed)",
                     )
-                    .expect_bool();
+                        .expect_bool();
                     assert!(result, "alice-try-reject test should be `true`");
                 }
 
diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index d5c1b1e77f..0530ff65b4 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -27,6 +27,8 @@
 (define-constant ERR_DELEGATION_WRONG_REWARD_SLOT 29)
 (define-constant ERR_STACKING_IS_DELEGATED 30)
 (define-constant ERR_STACKING_NOT_DELEGATED 31)
+(define-constant ERR_INVALID_SIGNER_KEY 32)
+(define-constant ERR_REQUESTED_SIGNER_KEY_MISMATCH 33)
 
 ;; Valid values for burnchain address versions.
 ;; These first four correspond to address hash modes in Stacks 2.1,
@@ -111,7 +113,8 @@
         ;;  previous stack-stx calls, or prior to an extend)
         reward-set-indexes: (list 12 uint),
         ;; principal of the delegate, if stacker has delegated
-        delegated-to: (optional principal)
+        delegated-to: (optional principal),
+        signer-key: (buff 33)
     }
 )
 
@@ -124,7 +127,8 @@
         until-burn-ht: (optional uint), ;; how long does the delegation last?
         ;; does the delegate _need_ to use a specific
         ;; pox recipient address?
-        pox-addr: (optional { version: (buff 1), hashbytes: (buff 32) })
+        pox-addr: (optional { version: (buff 1), hashbytes: (buff 32) }),
+        signer-key: (optional (buff 33))
     }
 )
 
@@ -538,6 +542,7 @@
 ;; at the time this method is called.
 ;; * You may need to increase the amount of uSTX locked up later, since the minimum uSTX threshold
 ;; may increase between reward cycles.
+;; * You need to provide a signer key to be used in the signer DKG process.
 ;; * The Stacker will receive rewards in the reward cycle following `start-burn-ht`.
 ;; Importantly, `start-burn-ht` may not be further into the future than the next reward cycle,
 ;; and in most cases should be set to the current burn block height.
@@ -546,7 +551,8 @@
 (define-public (stack-stx (amount-ustx uint)
                           (pox-addr (tuple (version (buff 1)) (hashbytes (buff 32))))
                           (start-burn-ht uint)
-                          (lock-period uint))
+                          (lock-period uint)
+                          (signer-key (buff 33)))
     ;; this stacker's first reward cycle is the _next_ reward cycle
     (let ((first-reward-cycle (+ u1 (current-pox-reward-cycle)))
           (specified-reward-cycle (+ u1 (burn-height-to-reward-cycle start-burn-ht))))
@@ -574,6 +580,9 @@
       ;; ensure that stacking can be performed
       (try! (can-stack-stx pox-addr amount-ustx first-reward-cycle lock-period))
 
+      ;; ensure the signer key is valid
+      (try! (is-signer-key-valid signer-key))
+
       ;; register the PoX address with the amount stacked
       (let ((reward-set-indexes (try! (add-pox-addr-to-reward-cycles pox-addr first-reward-cycle lock-period amount-ustx tx-sender))))
           ;; add stacker record
@@ -583,10 +592,11 @@
              reward-set-indexes: reward-set-indexes,
              first-reward-cycle: first-reward-cycle,
              lock-period: lock-period,
-             delegated-to: none })
+             delegated-to: none,
+             signer-key: signer-key })
 
           ;; return the lock-up information, so the node can actually carry out the lock.
-          (ok { stacker: tx-sender, lock-amount: amount-ustx, unlock-burn-height: (reward-cycle-to-burn-height (+ first-reward-cycle lock-period)) }))))
+          (ok { stacker: tx-sender, lock-amount: amount-ustx, signer-key: signer-key, unlock-burn-height: (reward-cycle-to-burn-height (+ first-reward-cycle lock-period)) }))))
 
 (define-public (revoke-delegate-stx)
   (begin
@@ -602,11 +612,12 @@
 ;;   * amount-ustx: the total amount of ustx the delegate may be allowed to lock
 ;;   * until-burn-ht: an optional burn height at which this delegation expires
 ;;   * pox-addr: an optional address to which any rewards *must* be sent
+;;   * signer-key: an optional signer key, that when set the delegate must use.
 (define-public (delegate-stx (amount-ustx uint)
                              (delegate-to principal)
                              (until-burn-ht (optional uint))
-                             (pox-addr (optional { version: (buff 1),
-                                                   hashbytes: (buff 32) })))
+                             (pox-addr (optional { version: (buff 1), hashbytes: (buff 32) }))
+                             (signer-key (optional (buff 33))))
     (begin
       ;; must be called directly by the tx-sender or by an allowed contract-caller
       (asserts! (check-caller-allowed)
@@ -631,13 +642,17 @@
       (asserts! (is-none (get-check-delegation tx-sender))
         (err ERR_STACKING_ALREADY_DELEGATED))
 
+      ;; ensure the signer key is valid, if it is set
+      (match signer-key key (try! (is-signer-key-valid key)) true)
+
       ;; add delegation record
       (map-set delegation-state
         { stacker: tx-sender }
         { amount-ustx: amount-ustx,
           delegated-to: delegate-to,
           until-burn-ht: until-burn-ht,
-          pox-addr: pox-addr })
+          pox-addr: pox-addr,
+          signer-key: signer-key })
 
       (ok true)))
 
@@ -784,7 +799,8 @@
                                    (amount-ustx uint)
                                    (pox-addr { version: (buff 1), hashbytes: (buff 32) })
                                    (start-burn-ht uint)
-                                   (lock-period uint))
+                                   (lock-period uint)
+                                   (signer-key (buff 33)))
     ;; this stacker's first reward cycle is the _next_ reward cycle
     (let ((first-reward-cycle (+ u1 (current-pox-reward-cycle)))
           (specified-reward-cycle (+ u1 (burn-height-to-reward-cycle start-burn-ht)))
@@ -816,7 +832,12 @@
                          until-burn-ht (>= until-burn-ht
                                            unlock-burn-height)
                       true)
-                  (err ERR_DELEGATION_EXPIRES_DURING_LOCK)))
+                  (err ERR_DELEGATION_EXPIRES_DURING_LOCK))
+        ;; if the delegatee set a signer-key, it must be equal to the delegate signer-key
+        (asserts!
+            (or (is-none (get signer-key delegation-info)) (is-eq (get signer-key delegation-info) (some signer-key)))
+            (err ERR_REQUESTED_SIGNER_KEY_MISMATCH)
+        ))
 
       ;; stacker principal must not be stacking
       (asserts! (is-none (get-stacker-info stacker))
@@ -826,6 +847,9 @@
       (asserts! (>= (stx-get-balance stacker) amount-ustx)
         (err ERR_STACKING_INSUFFICIENT_FUNDS))
 
+      ;; ensure the signer key is valid
+      (try! (is-signer-key-valid signer-key))
+
       ;; ensure that stacking can be performed
       (try! (minimal-can-stack-stx pox-addr amount-ustx first-reward-cycle lock-period))
 
@@ -840,7 +864,8 @@
           first-reward-cycle: first-reward-cycle,
           reward-set-indexes: (list),
           lock-period: lock-period,
-          delegated-to: (some tx-sender) })
+          delegated-to: (some tx-sender),
+          signer-key: signer-key })
 
       ;; return the lock-up information, so the node can actually carry out the lock.
       (ok { stacker: stacker,
@@ -941,9 +966,11 @@
 ;; Extend an active Stacking lock.
 ;; *New in Stacks 2.1*
 ;; This method extends the `tx-sender`'s current lockup for an additional `extend-count`
-;;    and associates `pox-addr` with the rewards
+;;    and associates `pox-addr` with the rewards, The `signer-key` will be the key
+;;    used for signing. The `tx-sender` can thus decide to change the key when extending.
 (define-public (stack-extend (extend-count uint)
-                             (pox-addr { version: (buff 1), hashbytes: (buff 32) }))
+                             (pox-addr { version: (buff 1), hashbytes: (buff 32) })
+                             (signer-key (buff 33)))
    (let ((stacker-info (stx-account tx-sender))
          ;; to extend, there must already be an etry in the stacking-state
          (stacker-state (unwrap! (get-stacker-info tx-sender) (err ERR_STACK_EXTEND_NOT_LOCKED)))
@@ -968,6 +995,9 @@
     (asserts! (is-none (get delegated-to stacker-state))
               (err ERR_STACKING_IS_DELEGATED))
 
+    ;; ensure the signer key is valid
+    (try! (is-signer-key-valid signer-key))
+
     ;; TODO: add more assertions to sanity check the `stacker-info` values with
     ;;       the `stacker-state` values
 
@@ -1014,7 +1044,8 @@
               reward-set-indexes: reward-set-indexes,
               first-reward-cycle: first-reward-cycle,
               lock-period: lock-period,
-              delegated-to: none })
+              delegated-to: none,
+              signer-key: signer-key })
 
         ;; return lock-up information
         (ok { stacker: tx-sender, unlock-burn-height: new-unlock-ht })))))
@@ -1115,6 +1146,7 @@
 (define-public (delegate-stack-extend
                     (stacker principal)
                     (pox-addr { version: (buff 1), hashbytes: (buff 32) })
+                    (signer-key (buff 33))
                     (extend-count uint))
     (let ((stacker-info (stx-account stacker))
           ;; to extend, there must already be an entry in the stacking-state
@@ -1181,7 +1213,12 @@
                          until-burn-ht (>= until-burn-ht
                                            new-unlock-ht)
                       true)
-                  (err ERR_DELEGATION_EXPIRES_DURING_LOCK)))
+                  (err ERR_DELEGATION_EXPIRES_DURING_LOCK))
+        ;; if the stacker set a signer-key, it must be equal to the delegate signer-key
+        (asserts!
+            (or (is-none (get signer-key delegation-info)) (is-eq (get signer-key delegation-info) (some signer-key)))
+            (err ERR_REQUESTED_SIGNER_KEY_MISMATCH)
+        ))
 
       ;; delegate stacking does minimal-can-stack-stx
       (try! (minimal-can-stack-stx pox-addr amount-ustx first-extend-cycle lock-period))
@@ -1196,7 +1233,8 @@
           reward-set-indexes: (list),
           first-reward-cycle: first-reward-cycle,
           lock-period: lock-period,
-          delegated-to: (some tx-sender) })
+          delegated-to: (some tx-sender),
+          signer-key: signer-key })
 
       ;; return the lock-up information, so the node can actually carry out the lock.
       (ok { stacker: stacker,
@@ -1246,4 +1284,10 @@
     (begin
         (ok (map-set aggregate-public-keys reward-cycle aggregate-public-key))
     )
-)
\ No newline at end of file
+)
+
+;; Check if a provided signer key is valid. For now it only asserts length.
+;; *New in Stacks 3.0*
+(define-read-only (is-signer-key-valid (signer-key (buff 33)))
+    (ok (asserts! (is-eq (len signer-key) u33) (err ERR_INVALID_SIGNER_KEY)))
+)
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 5e42e1bd54..2a583b0ddd 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -88,8 +88,8 @@ fn make_test_epochs_pox() -> (Vec<StacksEpoch>, PoxConstants) {
     let EPOCH_2_1_HEIGHT = EMPTY_SORTITIONS + 11; // 36
     let EPOCH_2_2_HEIGHT = EPOCH_2_1_HEIGHT + 14; // 50
     let EPOCH_2_3_HEIGHT = EPOCH_2_2_HEIGHT + 2; // 52
-                                                 // epoch-2.4 will start at the first block of cycle 11!
-                                                 //  this means that cycle 11 should also be treated like a "burn"
+    // epoch-2.4 will start at the first block of cycle 11!
+    //  this means that cycle 11 should also be treated like a "burn"
     let EPOCH_2_4_HEIGHT = EPOCH_2_3_HEIGHT + 4; // 56
     let EPOCH_2_5_HEIGHT = EPOCH_2_4_HEIGHT + 44; // 100
 
@@ -341,7 +341,7 @@ fn pox_extend_transition() {
     let min_ustx = with_sortdb(&mut peer, |chainstate, sortdb| {
         chainstate.get_stacking_minimum(sortdb, &tip_index_block)
     })
-    .unwrap();
+        .unwrap();
     assert_eq!(
         min_ustx,
         total_liquid_ustx / POX_TESTNET_STACKING_THRESHOLD_25
@@ -351,7 +351,7 @@ fn pox_extend_transition() {
     let reward_addrs = with_sortdb(&mut peer, |chainstate, sortdb| {
         get_reward_addresses_with_par_tip(chainstate, &burnchain, sortdb, &tip_index_block)
     })
-    .unwrap();
+        .unwrap();
     assert_eq!(reward_addrs.len(), 0);
 
     // check the first reward cycle when Alice's tokens get stacked
@@ -485,6 +485,7 @@ fn pox_extend_transition() {
             key_to_stacks_addr(&alice).bytes,
         ),
         4,
+        vec![0; 33],
         tip.block_height,
     );
     let alice_pox_4_lock_nonce = 2;
@@ -529,6 +530,9 @@ fn pox_extend_transition() {
         latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
     }
 
+    let bob_signer_key = vec![0x02, 0xb6, 0x19, 0x6d, 0xe8, 0x8b, 0xce, 0xe7, 0x93, 0xfa, 0x9a, 0x8a, 0x85, 0x96, 0x9b, 0x64, 0x7f, 0x84, 0xc9, 0x0e, 0x9d, 0x13, 0xf9, 0xc8, 0xb8, 0xce, 0x42, 0x6c, 0xc8, 0x1a, 0x59, 0x98, 0x3c];
+    let alice_signer_key = vec![0x03, 0xa0, 0xf9, 0x81, 0x8e, 0xa8, 0xc1, 0x4a, 0x82, 0x7b, 0xb1, 0x44, 0xae, 0xc9, 0xcf, 0xba, 0xeb, 0xa2, 0x25, 0xaf, 0x22, 0xbe, 0x18, 0xed, 0x78, 0xa2, 0xf2, 0x98, 0x10, 0x6f, 0x4e, 0x28, 0x1b];
+
     let tip = get_tip(peer.sortdb.as_ref());
     let bob_lockup = make_pox_4_lockup(
         &bob,
@@ -539,6 +543,7 @@ fn pox_extend_transition() {
             key_to_stacks_addr(&bob).bytes,
         ),
         3,
+        bob_signer_key,
         tip.block_height,
     );
 
@@ -551,6 +556,7 @@ fn pox_extend_transition() {
             key_to_stacks_addr(&alice).bytes,
         ),
         6,
+        alice_signer_key,
     );
 
     let alice_pox_4_extend_nonce = 3;
@@ -726,10 +732,10 @@ fn get_burn_pox_addr_info(peer: &mut TestPeer) -> (Vec<PoxAddress>, u128) {
             .unwrap();
         addrs
     })
-    .unwrap()
-    .expect_optional()
-    .expect("FATAL: expected list")
-    .expect_tuple();
+        .unwrap()
+        .expect_optional()
+        .expect("FATAL: expected list")
+        .expect_tuple();
 
     let addrs = addrs_and_payout
         .get("addrs")
@@ -804,6 +810,7 @@ fn pox_lock_unlock() {
                 1024 * POX_THRESHOLD_STEPS_USTX,
                 pox_addr.clone(),
                 lock_period,
+                vec![0; 33],
                 tip_height,
             ));
             pox_addr
@@ -1234,3 +1241,357 @@ fn balances_from_keys(
         .map(|principal| get_stx_account_at(peer, tip, &principal))
         .collect()
 }
+
+#[test]
+fn stack_stx_signer_key() {
+    let lock_period = 2;
+    let (
+        burnchain,
+        mut peer,
+        keys,
+        latest_block,
+        block_height,
+        mut coinbase_nonce) = prepare_pox4_test(function_name!());
+
+    let stacker_nonce = 0;
+    let stacker_key = &keys[0];
+    let min_ustx = get_stacking_minimum(&mut peer, &latest_block);
+
+    // (define-public (stack-stx (amount-ustx uint)
+    //                       (pox-addr (tuple (version (buff 1)) (hashbytes (buff 32))))
+    //                       (start-burn-ht uint)
+    //                       (lock-period uint)
+    //                       (signer-key (buff 33)))
+    let pox_addr = make_pox_addr(AddressHashMode::SerializeP2WSH, key_to_stacks_addr(stacker_key).bytes);
+    let signer_key_val = Value::buff_from(vec![0x03, 0xa0, 0xf9, 0x81, 0x8e, 0xa8, 0xc1, 0x4a, 0x82, 0x7b, 0xb1, 0x44, 0xae, 0xc9, 0xcf, 0xba, 0xeb, 0xa2, 0x25, 0xaf, 0x22, 0xbe, 0x18, 0xed, 0x78, 0xa2, 0xf2, 0x98, 0x10, 0x6f, 0x4e, 0x28, 0x1b]).unwrap();
+    let txs = vec![make_pox_4_contract_call(
+        stacker_key,
+        stacker_nonce,
+        "stack-stx",
+        vec![
+            Value::UInt(min_ustx),
+            pox_addr,
+            Value::UInt(block_height as u128),
+            Value::UInt(2),
+            signer_key_val.clone(),
+        ],
+    )];
+
+    let latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
+    let stacking_state = get_stacking_state_pox_4(
+        &mut peer,
+        &latest_block,
+        &key_to_stacks_addr(stacker_key).to_account_principal(),
+    )
+        .expect("No stacking state, stack-stx failed")
+        .expect_tuple();
+
+    let state_signer_key = stacking_state.get("signer-key").unwrap();
+    assert_eq!(state_signer_key.to_string(), signer_key_val.to_string());
+}
+
+#[test]
+fn delegate_stx_signer_key() {
+    let lock_period = 2;
+    let (
+        burnchain,
+        mut peer,
+        keys,
+        latest_block,
+        block_height,
+        mut coinbase_nonce) = prepare_pox4_test(function_name!());
+
+    let stacker_nonce = 0;
+    let stacker_key = &keys[0];
+    let delegate_key = &keys[1];
+    let delegate_principal = PrincipalData::from(key_to_stacks_addr(delegate_key));
+
+    // (define-public (delegate-stx (amount-ustx uint)
+    //                          (delegate-to principal)
+    //                          (until-burn-ht (optional uint))
+    //                          (pox-addr (optional { version: (buff 1), hashbytes: (buff 32) }))
+    //                          (signer-key (optional (buff 33))))
+    let pox_addr = make_pox_addr(AddressHashMode::SerializeP2WSH, key_to_stacks_addr(delegate_key).bytes);
+    let signer_key_val = Value::buff_from(vec![0x03, 0xa0, 0xf9, 0x81, 0x8e, 0xa8, 0xc1, 0x4a, 0x82, 0x7b, 0xb1, 0x44, 0xae, 0xc9, 0xcf, 0xba, 0xeb, 0xa2, 0x25, 0xaf, 0x22, 0xbe, 0x18, 0xed, 0x78, 0xa2, 0xf2, 0x98, 0x10, 0x6f, 0x4e, 0x28, 0x1b]).unwrap();
+    let txs = vec![make_pox_4_contract_call(
+        stacker_key,
+        stacker_nonce,
+        "delegate-stx",
+        vec![
+            Value::UInt(100),
+            delegate_principal.clone().into(),
+            Value::none(),
+            Value::Optional(OptionalData { data: Some(Box::new(pox_addr)) }),
+            Value::Optional(OptionalData { data: Some(signer_key_val.clone().into()) }),
+        ],
+    )];
+
+    let latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
+    let delegation_state = get_delegation_state_pox_4(
+        &mut peer,
+        &latest_block,
+        &key_to_stacks_addr(stacker_key).to_account_principal(),
+    )
+        .expect("No delegation state, delegate-stx failed")
+        .expect_tuple();
+
+    let state_signer_key_optional = delegation_state.get("signer-key").unwrap();
+    assert_eq!(
+        state_signer_key_optional.to_string(),
+        Value::Optional(OptionalData { data: Some(Box::new(signer_key_val)) }).to_string()
+    );
+}
+
+#[test]
+fn stack_extend_signer_key() {
+    let lock_period = 2;
+    let (
+        burnchain,
+        mut peer,
+        keys,
+        latest_block,
+        block_height,
+        mut coinbase_nonce) = prepare_pox4_test(function_name!());
+
+    let mut stacker_nonce = 0;
+    let stacker_key = &keys[0];
+    let min_ustx = get_stacking_minimum(&mut peer, &latest_block) * 2;
+
+    let pox_addr = make_pox_addr(AddressHashMode::SerializeP2WSH, key_to_stacks_addr(stacker_key).bytes);
+
+    let signer_key_val = Value::buff_from(vec![0x03, 0xa0, 0xf9, 0x81, 0x8e, 0xa8, 0xc1, 0x4a, 0x82, 0x7b, 0xb1, 0x44, 0xae, 0xc9, 0xcf, 0xba, 0xeb, 0xa2, 0x25, 0xaf, 0x22, 0xbe, 0x18, 0xed, 0x78, 0xa2, 0xf2, 0x98, 0x10, 0x6f, 0x4e, 0x28, 0x1b]).unwrap();
+    let txs = vec![make_pox_4_contract_call(
+        stacker_key,
+        stacker_nonce,
+        "stack-stx",
+        vec![
+            Value::UInt(min_ustx),
+            pox_addr.clone(),
+            Value::UInt(block_height as u128),
+            Value::UInt(2),
+            signer_key_val.clone(),
+        ],
+    )];
+
+    stacker_nonce += 1;
+
+    let mut latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
+    let stacking_state = get_stacking_state_pox_4(
+        &mut peer,
+        &latest_block,
+        &key_to_stacks_addr(stacker_key).to_account_principal(),
+    )
+        .expect("No stacking state, stack-stx failed")
+        .expect_tuple();
+
+    let state_signer_key = stacking_state.get("signer-key").unwrap();
+    assert_eq!(state_signer_key.to_string(), signer_key_val.to_string());
+
+    // now stack-extend with a new signer-key
+    let signer_key_new_val = Value::buff_from(vec![0x02, 0xb6, 0x19, 0x6d, 0xe8, 0x8b, 0xce, 0xe7, 0x93, 0xfa, 0x9a, 0x8a, 0x85, 0x96, 0x9b, 0x64, 0x7f, 0x84, 0xc9, 0x0e, 0x9d, 0x13, 0xf9, 0xc8, 0xb8, 0xce, 0x42, 0x6c, 0xc8, 0x1a, 0x59, 0x98, 0x3c]).unwrap();
+
+    // (define-public (stack-extend (extend-count uint)
+    //                          (pox-addr { version: (buff 1), hashbytes: (buff 32) })
+    //                          (signer-key (buff 33)))
+    let update_txs = vec![make_pox_4_contract_call(
+        stacker_key,
+        stacker_nonce,
+        "stack-extend",
+        vec![
+            Value::UInt(1),
+            pox_addr,
+            signer_key_new_val.clone(),
+        ],
+    )];
+
+    latest_block = peer.tenure_with_txs(&update_txs, &mut coinbase_nonce);
+    let new_stacking_state = get_stacking_state_pox_4(
+        &mut peer,
+        &latest_block,
+        &key_to_stacks_addr(stacker_key).to_account_principal(),
+    )
+        .unwrap()
+        .expect_tuple();
+
+    let state_signer_key_new = new_stacking_state.get("signer-key").unwrap();
+    assert_eq!(state_signer_key_new.to_string(), signer_key_new_val.to_string());
+}
+
+#[test]
+fn delegate_stack_stx_signer_key() {
+    let lock_period = 2;
+    let (
+        burnchain,
+        mut peer,
+        keys,
+        latest_block,
+        block_height,
+        mut coinbase_nonce) = prepare_pox4_test(function_name!());
+
+    let stacker_nonce = 0;
+    let stacker_key = &keys[0];
+    let delegate_nonce = 0;
+    let delegate_key = &keys[1];
+    let delegate_principal = PrincipalData::from(key_to_stacks_addr(delegate_key));
+
+    // (define-public (delegate-stx (amount-ustx uint)
+    //                          (delegate-to principal)
+    //                          (until-burn-ht (optional uint))
+    //                          (pox-addr (optional { version: (buff 1), hashbytes: (buff 32) }))
+    //                          (signer-key (optional (buff 33))))
+    let pox_addr = make_pox_addr(AddressHashMode::SerializeP2WSH, key_to_stacks_addr(delegate_key).bytes);
+    let signer_key_val = Value::buff_from(vec![0x03, 0xa0, 0xf9, 0x81, 0x8e, 0xa8, 0xc1, 0x4a, 0x82, 0x7b, 0xb1, 0x44, 0xae, 0xc9, 0xcf, 0xba, 0xeb, 0xa2, 0x25, 0xaf, 0x22, 0xbe, 0x18, 0xed, 0x78, 0xa2, 0xf2, 0x98, 0x10, 0x6f, 0x4e, 0x28, 0x1b]).unwrap();
+    let txs = vec![make_pox_4_contract_call(
+        stacker_key,
+        stacker_nonce,
+        "delegate-stx",
+        vec![
+            Value::UInt(100),
+            delegate_principal.clone().into(),
+            Value::none(),
+            Value::Optional(OptionalData { data: Some(Box::new(pox_addr.clone())) }),
+            Value::Optional(OptionalData { data: Some(signer_key_val.clone().into()) }),
+        ],
+    ), make_pox_4_contract_call(
+        delegate_key,
+        delegate_nonce,
+        "delegate-stack-stx",
+        vec![
+            PrincipalData::from(key_to_stacks_addr(stacker_key)).into(),
+            Value::UInt(100),
+            pox_addr,
+            Value::UInt(block_height as u128),
+            Value::UInt(lock_period),
+            signer_key_val.clone(),
+        ],
+    )];
+    // (define-public (delegate-stack-stx (stacker principal)
+    //                                (amount-ustx uint)
+    //                                (pox-addr { version: (buff 1), hashbytes: (buff 32) })
+    //                                (start-burn-ht uint)
+    //                                (lock-period uint)
+    //                                (signer-key (buff 33)))
+
+    let latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
+    let delegation_state = get_delegation_state_pox_4(
+        &mut peer,
+        &latest_block,
+        &key_to_stacks_addr(stacker_key).to_account_principal(),
+    )
+        .expect("No delegation state, delegate-stx failed")
+        .expect_tuple();
+
+    let state_signer_key_optional = delegation_state.get("signer-key").unwrap();
+    assert_eq!(
+        state_signer_key_optional.to_string(),
+        Value::Optional(OptionalData { data: Some(Box::new(signer_key_val.clone())) }).to_string()
+    );
+
+    let stacking_state = get_stacking_state_pox_4(
+        &mut peer,
+        &latest_block,
+        &key_to_stacks_addr(stacker_key).to_account_principal(),
+    )
+        .expect("No stacking state, stack-stx failed")
+        .expect_tuple();
+
+    let state_signer_key = stacking_state.get("signer-key").unwrap();
+    assert_eq!(state_signer_key.to_string(), signer_key_val.to_string());
+}
+
+pub fn get_stacking_state_pox_4(
+    peer: &mut TestPeer,
+    tip: &StacksBlockId,
+    account: &PrincipalData,
+) -> Option<Value> {
+    with_clarity_db_ro(peer, tip, |db| {
+        let lookup_tuple = Value::Tuple(
+            TupleData::from_data(vec![("stacker".into(), account.clone().into())]).unwrap(),
+        );
+        let epoch = db.get_clarity_epoch_version();
+        db.fetch_entry_unknown_descriptor(
+            &boot_code_id(boot::POX_4_NAME, false),
+            "stacking-state",
+            &lookup_tuple,
+            &epoch,
+        )
+            .unwrap()
+            .expect_optional()
+    })
+}
+
+pub fn get_delegation_state_pox_4(
+    peer: &mut TestPeer,
+    tip: &StacksBlockId,
+    account: &PrincipalData,
+) -> Option<Value> {
+    with_clarity_db_ro(peer, tip, |db| {
+        let lookup_tuple = Value::Tuple(
+            TupleData::from_data(vec![("stacker".into(), account.clone().into())]).unwrap(),
+        );
+        let epoch = db.get_clarity_epoch_version();
+        db.fetch_entry_unknown_descriptor(
+            &boot_code_id(boot::POX_4_NAME, false),
+            "delegation-state",
+            &lookup_tuple,
+            &epoch,
+        )
+            .unwrap()
+            .expect_optional()
+    })
+}
+
+pub fn with_clarity_db_ro<F, R>(peer: &mut TestPeer, tip: &StacksBlockId, todo: F) -> R
+    where
+        F: FnOnce(&mut ClarityDatabase) -> R,
+{
+    with_sortdb(peer, |ref mut c, ref sortdb| {
+        let headers_db = HeadersDBConn(c.state_index.sqlite_conn());
+        let burn_db = sortdb.index_conn();
+        let mut read_only_clar = c
+            .clarity_state
+            .read_only_connection(tip, &headers_db, &burn_db);
+        read_only_clar.with_clarity_db_readonly(todo)
+    })
+}
+
+pub fn get_stacking_minimum(peer: &mut TestPeer, latest_block: &StacksBlockId) -> u128 {
+    with_sortdb(peer, |ref mut chainstate, ref sortdb| {
+        chainstate.get_stacking_minimum(sortdb, &latest_block)
+    }).unwrap()
+}
+
+pub fn prepare_pox4_test<'a>(test_name: &str) -> (Burnchain, TestPeer<'a>, Vec<StacksPrivateKey>, StacksBlockId, u64, usize) {
+    let (epochs, pox_constants) = make_test_epochs_pox();
+
+    let mut burnchain = Burnchain::default_unittest(
+        0,
+        &BurnchainHeaderHash::from_hex(BITCOIN_REGTEST_FIRST_BLOCK_HASH).unwrap(),
+    );
+    burnchain.pox_constants = pox_constants.clone();
+
+    let (mut peer, keys) = instantiate_pox_peer_with_epoch(&burnchain, test_name, Some(epochs.clone()), None);
+
+    assert_eq!(burnchain.pox_constants.reward_slots(), 6);
+    let mut coinbase_nonce = 0;
+
+    // Advance into pox4
+    let target_height = burnchain.pox_constants.pox_4_activation_height;
+    let mut latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    while get_tip(peer.sortdb.as_ref()).block_height < u64::from(target_height) {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+        // if we reach epoch 2.1, perform the check
+        if get_tip(peer.sortdb.as_ref()).block_height > epochs[3].start_height {
+            assert_latest_was_burn(&mut peer);
+        }
+    }
+
+    let block_height = get_tip(peer.sortdb.as_ref()).block_height;
+
+    info!(
+        "Block height: {}",
+        block_height
+    );
+
+    (burnchain, peer, keys, latest_block, block_height, coinbase_nonce)
+}
\ No newline at end of file

From ca50421ff6732439b9863e78b64e52473a3548a7 Mon Sep 17 00:00:00 2001
From: MarvinJanssen <MarvinJanssen@users.noreply.github.com>
Date: Fri, 22 Dec 2023 08:33:58 +0100
Subject: [PATCH 0256/1166] chore: auto-format

---
 .../chainstate/nakamoto/coordinator/tests.rs  | 116 ++++----
 stackslib/src/chainstate/stacks/boot/mod.rs   | 242 ++++++++--------
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 272 +++++++++++-------
 3 files changed, 345 insertions(+), 285 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index 978d338010..3a8237a778 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -56,7 +56,7 @@ fn advance_to_nakamoto(peer: &mut TestPeer) {
         1,
         &vec![StacksPublicKey::from_private(&private_key)],
     )
-        .unwrap();
+    .unwrap();
 
     for sortition_height in 0..11 {
         // stack to pox-3 in cycle 7
@@ -98,7 +98,7 @@ pub fn boot_nakamoto(
         1,
         &vec![StacksPublicKey::from_private(&private_key)],
     )
-        .unwrap();
+    .unwrap();
 
     // reward cycles are 5 blocks long
     // first 25 blocks are boot-up
@@ -142,8 +142,8 @@ fn make_replay_peer<'a>(peer: &'a mut TestPeer<'a>) -> TestPeer<'a> {
             replay_tip.block_height,
             &tip.sortition_id,
         )
-            .unwrap()
-            .unwrap();
+        .unwrap()
+        .unwrap();
         ancestor_tip
     };
 
@@ -221,7 +221,7 @@ fn replay_reward_cycle(
             &mut node.chainstate,
             block.clone(),
         )
-            .unwrap();
+        .unwrap();
         if accepted {
             test_debug!("Accepted Nakamoto block {block_id}");
             peer.coord.handle_new_nakamoto_stacks_block().unwrap();
@@ -297,7 +297,7 @@ fn test_simple_nakamoto_coordinator_1_tenure_10_blocks() {
         1,
         &vec![StacksPublicKey::from_private(&private_key)],
     )
-        .unwrap();
+    .unwrap();
 
     let mut test_signers = TestSigners::default();
     let mut peer = boot_nakamoto(
@@ -419,7 +419,7 @@ fn test_nakamoto_chainstate_getters() {
         1,
         &vec![StacksPublicKey::from_private(&private_key)],
     )
-        .unwrap();
+    .unwrap();
     let mut test_signers = TestSigners::default();
     let mut peer = boot_nakamoto(
         function_name!(),
@@ -543,16 +543,16 @@ fn test_nakamoto_chainstate_getters() {
                 &tip.index_block_hash(),
                 coinbase_height,
             )
-                .unwrap();
+            .unwrap();
             let header = header_opt.expect("No tenure");
 
             if coinbase_height
                 <= tip
-                .anchored_header
-                .as_stacks_nakamoto()
-                .unwrap()
-                .chain_length
-                - 10
+                    .anchored_header
+                    .as_stacks_nakamoto()
+                    .unwrap()
+                    .chain_length
+                    - 10
             {
                 // all tenures except the last are epoch2
                 assert!(header.anchored_header.as_stacks_epoch2().is_some());
@@ -586,8 +586,8 @@ fn test_nakamoto_chainstate_getters() {
             sort_tx.tx(),
             &highest_tenure.tenure_id_consensus_hash,
         )
-            .unwrap()
-            .unwrap();
+        .unwrap()
+        .unwrap();
 
         // this tenure's TC tx is the first-ever TC
         let tenure_change_payload = blocks[0].get_tenure_change_tx_payload().unwrap().clone();
@@ -596,33 +596,33 @@ fn test_nakamoto_chainstate_getters() {
             chainstate.db(),
             &tenure_change_payload,
         )
-            .unwrap()
-            .is_some());
+        .unwrap()
+        .is_some());
         assert!(NakamotoChainState::check_tenure_continuity(
             chainstate.db(),
             sort_tx.sqlite(),
             &blocks[0].header.consensus_hash,
             &blocks[1].header,
         )
-            .unwrap());
+        .unwrap());
         assert!(NakamotoChainState::check_valid_consensus_hash(
             &mut sort_tx,
             &tenure_change_payload.tenure_consensus_hash,
         )
-            .unwrap()
-            .is_some());
+        .unwrap()
+        .is_some());
         assert!(NakamotoChainState::check_valid_consensus_hash(
             &mut sort_tx,
             &tenure_change_payload.prev_tenure_consensus_hash,
         )
-            .unwrap()
-            .is_some());
+        .unwrap()
+        .is_some());
         assert!(NakamotoChainState::check_valid_consensus_hash(
             &mut sort_tx,
             &tenure_change_payload.burn_view_consensus_hash,
         )
-            .unwrap()
-            .is_some());
+        .unwrap()
+        .is_some());
 
         // this should fail, since it's not idempotent -- the highest tenure _is_ this tenure
         assert!(NakamotoChainState::check_nakamoto_tenure(
@@ -631,8 +631,8 @@ fn test_nakamoto_chainstate_getters() {
             &blocks[0].header,
             &tenure_change_payload,
         )
-            .unwrap()
-            .is_none());
+        .unwrap()
+        .is_none());
 
         let cur_burn_tip = SortitionDB::get_canonical_burn_chain_tip(sort_tx.sqlite()).unwrap();
         let (cur_stacks_ch, cur_stacks_bhh, cur_stacks_height) =
@@ -651,7 +651,7 @@ fn test_nakamoto_chainstate_getters() {
             chainstate.db(),
             &blocks[0].header.consensus_hash,
         )
-            .unwrap();
+        .unwrap();
 
         // check works (this would be the first tenure)
         assert!(NakamotoChainState::check_nakamoto_tenure(
@@ -660,8 +660,8 @@ fn test_nakamoto_chainstate_getters() {
             &blocks[0].header,
             &tenure_change_payload,
         )
-            .unwrap()
-            .is_some());
+        .unwrap()
+        .is_some());
 
         // restore
         sort_tx
@@ -679,7 +679,7 @@ fn test_nakamoto_chainstate_getters() {
             1,
             &tenure_change_payload,
         )
-            .unwrap();
+        .unwrap();
     }
 
     debug!("\n======================================\nBegin second tenure\n===========================================\n");
@@ -716,7 +716,7 @@ fn test_nakamoto_chainstate_getters() {
         &next_consensus_hash,
         &txid,
     )
-        .unwrap();
+    .unwrap();
     assert_eq!(parent_vrf_proof, vrf_proof);
 
     // make the second tenure's blocks
@@ -785,59 +785,59 @@ fn test_nakamoto_chainstate_getters() {
             chainstate.db(),
             &tenure_change_payload,
         )
-            .unwrap()
-            .is_none());
+        .unwrap()
+        .is_none());
         assert!(NakamotoChainState::check_tenure_continuity(
             chainstate.db(),
             sort_tx.sqlite(),
             &new_blocks[0].header.consensus_hash,
             &new_blocks[1].header,
         )
-            .unwrap());
+        .unwrap());
         assert!(!NakamotoChainState::check_tenure_continuity(
             chainstate.db(),
             sort_tx.sqlite(),
             &blocks[0].header.consensus_hash,
             &new_blocks[1].header,
         )
-            .unwrap());
+        .unwrap());
 
         assert!(NakamotoChainState::check_valid_consensus_hash(
             &mut sort_tx,
             &tenure_change_payload.tenure_consensus_hash,
         )
-            .unwrap()
-            .is_some());
+        .unwrap()
+        .is_some());
         assert!(NakamotoChainState::check_valid_consensus_hash(
             &mut sort_tx,
             &tenure_change_payload.prev_tenure_consensus_hash,
         )
-            .unwrap()
-            .is_some());
+        .unwrap()
+        .is_some());
         assert!(NakamotoChainState::check_valid_consensus_hash(
             &mut sort_tx,
             &tenure_change_payload.burn_view_consensus_hash,
         )
-            .unwrap()
-            .is_some());
+        .unwrap()
+        .is_some());
         assert!(NakamotoChainState::check_valid_consensus_hash(
             &mut sort_tx,
             &old_tenure_change_payload.tenure_consensus_hash,
         )
-            .unwrap()
-            .is_some());
+        .unwrap()
+        .is_some());
         assert!(NakamotoChainState::check_valid_consensus_hash(
             &mut sort_tx,
             &old_tenure_change_payload.prev_tenure_consensus_hash,
         )
-            .unwrap()
-            .is_some());
+        .unwrap()
+        .is_some());
         assert!(NakamotoChainState::check_valid_consensus_hash(
             &mut sort_tx,
             &old_tenure_change_payload.burn_view_consensus_hash,
         )
-            .unwrap()
-            .is_some());
+        .unwrap()
+        .is_some());
 
         let cur_burn_tip = SortitionDB::get_canonical_burn_chain_tip(sort_tx.sqlite()).unwrap();
         let (cur_stacks_ch, cur_stacks_bhh, cur_stacks_height) =
@@ -855,7 +855,7 @@ fn test_nakamoto_chainstate_getters() {
             chainstate.db(),
             &new_blocks[0].header.consensus_hash,
         )
-            .unwrap();
+        .unwrap();
 
         assert!(NakamotoChainState::check_nakamoto_tenure(
             chainstate.db(),
@@ -863,8 +863,8 @@ fn test_nakamoto_chainstate_getters() {
             &new_blocks[0].header,
             &tenure_change_payload,
         )
-            .unwrap()
-            .is_some());
+        .unwrap()
+        .is_some());
 
         // checks on older confired tenures continue to fail
         assert!(NakamotoChainState::check_nakamoto_tenure(
@@ -873,8 +873,8 @@ fn test_nakamoto_chainstate_getters() {
             &blocks[0].header,
             &old_tenure_change_payload,
         )
-            .unwrap()
-            .is_none());
+        .unwrap()
+        .is_none());
 
         // restore
         sort_tx
@@ -892,7 +892,7 @@ fn test_nakamoto_chainstate_getters() {
             2,
             &tenure_change_payload,
         )
-            .unwrap();
+        .unwrap();
     }
 }
 
@@ -907,7 +907,7 @@ fn test_simple_nakamoto_coordinator_10_tenures_10_blocks() {
         1,
         &vec![StacksPublicKey::from_private(&private_key)],
     )
-        .unwrap();
+    .unwrap();
 
     let mut test_signers = TestSigners::default();
     let mut peer = boot_nakamoto(
@@ -930,7 +930,7 @@ fn test_simple_nakamoto_coordinator_10_tenures_10_blocks() {
         1,
         &vec![StacksPublicKey::from_private(&private_key)],
     )
-        .unwrap();
+    .unwrap();
 
     for i in 0..10 {
         let (burn_ops, mut tenure_change, miner_key) =
@@ -1113,7 +1113,7 @@ fn test_simple_nakamoto_coordinator_10_tenures_10_blocks() {
                 &tip.index_block_hash(),
                 i,
             )
-                .unwrap();
+            .unwrap();
             matured_rewards.push(matured_reward_opt);
         }
     }
@@ -1228,7 +1228,7 @@ fn test_simple_nakamoto_coordinator_2_tenures_3_sortitions() {
         1,
         &vec![StacksPublicKey::from_private(&private_key)],
     )
-        .unwrap();
+    .unwrap();
     let mut test_signers = TestSigners::default();
     let mut peer = boot_nakamoto(
         function_name!(),
@@ -1556,7 +1556,7 @@ fn test_simple_nakamoto_coordinator_10_tenures_and_extensions_10_blocks() {
         1,
         &vec![StacksPublicKey::from_private(&private_key)],
     )
-        .unwrap();
+    .unwrap();
     let mut test_signers = TestSigners::default();
     let mut peer = boot_nakamoto(
         function_name!(),
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 5f0f5d3352..aa022d2c12 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -499,7 +499,7 @@ impl StacksChainState {
             "pox",
             &format!("(get-stacking-minimum)"),
         )
-            .map(|value| value.expect_u128())
+        .map(|value| value.expect_u128())
     }
 
     pub fn get_total_ustx_stacked(
@@ -553,7 +553,7 @@ impl StacksChainState {
             "pox",
             &format!("(get-total-ustx-stacked u{})", reward_cycle),
         )
-            .map(|value| value.expect_u128())
+        .map(|value| value.expect_u128())
     }
 
     /// Is PoX active in the given reward cycle?
@@ -570,7 +570,7 @@ impl StacksChainState {
             pox_contract,
             &format!("(is-pox-active u{})", reward_cycle),
         )
-            .map(|value| value.expect_bool())
+        .map(|value| value.expect_bool())
     }
 
     /// Given a threshold and set of registered addresses, return a reward set where
@@ -592,10 +592,10 @@ impl StacksChainState {
             addresses.sort_by_cached_key(|k| k.reward_address.to_burnchain_repr());
         }
         while let Some(RawRewardSetEntry {
-                           reward_address: address,
-                           amount_stacked: mut stacked_amt,
-                           stacker,
-                       }) = addresses.pop()
+            reward_address: address,
+            amount_stacked: mut stacked_amt,
+            stacker,
+        }) = addresses.pop()
         {
             let mut contributed_stackers = vec![];
             if let Some(stacker) = stacker.as_ref() {
@@ -1116,8 +1116,8 @@ impl StacksChainState {
         // there hasn't yet been a Stacks block.
         match result {
             Err(Error::ClarityError(ClarityError::Interpreter(VmError::Unchecked(
-                                                                  CheckErrors::NoSuchContract(_),
-                                                              )))) => {
+                CheckErrors::NoSuchContract(_),
+            )))) => {
                 warn!("Reward cycle attempted to calculate rewards before the PoX contract was instantiated");
                 return Ok(vec![]);
             }
@@ -1271,7 +1271,7 @@ pub mod test {
                 &[],
                 liquid,
             )
-                .0,
+            .0,
             POX_THRESHOLD_STEPS_USTX
         );
         assert_eq!(
@@ -1284,7 +1284,7 @@ pub mod test {
                 }],
                 liquid,
             )
-                .0,
+            .0,
             POX_THRESHOLD_STEPS_USTX
         );
 
@@ -1296,7 +1296,7 @@ pub mod test {
                 &[],
                 liquid,
             )
-                .0,
+            .0,
             50_000 * MICROSTACKS_PER_STACKS as u128
         );
         // should be the same at 25% participation
@@ -1310,7 +1310,7 @@ pub mod test {
                 }],
                 liquid,
             )
-                .0,
+            .0,
             50_000 * MICROSTACKS_PER_STACKS as u128
         );
         // but not at 30% participation
@@ -1331,7 +1331,7 @@ pub mod test {
                 ],
                 liquid,
             )
-                .0,
+            .0,
             60_000 * MICROSTACKS_PER_STACKS as u128
         );
 
@@ -1353,7 +1353,7 @@ pub mod test {
                 ],
                 liquid,
             )
-                .0,
+            .0,
             60_000 * MICROSTACKS_PER_STACKS as u128
         );
 
@@ -1368,7 +1368,7 @@ pub mod test {
                 }],
                 liquid,
             )
-                .0,
+            .0,
             200_000 * MICROSTACKS_PER_STACKS as u128
         );
     }
@@ -1384,7 +1384,7 @@ pub mod test {
             1,
             &vec![StacksPublicKey::from_private(key)],
         )
-            .unwrap()
+        .unwrap()
     }
 
     pub fn instantiate_pox_peer<'a>(
@@ -1417,19 +1417,19 @@ pub mod test {
             StacksPrivateKey::from_hex(
                 "7e3ee1f2a0ae11b785a1f0e725a9b3ab0a5fd6cc057d43763b0a85f256fdec5d01",
             )
-                .unwrap(),
+            .unwrap(),
             StacksPrivateKey::from_hex(
                 "11d055ac8b0ab4f04c5eb5ea4b4def9c60ae338355d81c9411b27b4f49da2a8301",
             )
-                .unwrap(),
+            .unwrap(),
             StacksPrivateKey::from_hex(
                 "00eed368626b96e482944e02cc136979973367491ea923efb57c482933dd7c0b01",
             )
-                .unwrap(),
+            .unwrap(),
             StacksPrivateKey::from_hex(
                 "00380ff3c05350ee313f60f30313acb4b5fc21e50db4151bf0de4cd565eb823101",
             )
-                .unwrap(),
+            .unwrap(),
         ];
 
         let addrs: Vec<StacksAddress> = keys.iter().map(|pk| key_to_stacks_addr(pk)).collect();
@@ -1541,8 +1541,8 @@ pub mod test {
     }
 
     pub fn with_sortdb<F, R>(peer: &mut TestPeer, todo: F) -> R
-        where
-            F: FnOnce(&mut StacksChainState, &SortitionDB) -> R,
+    where
+        F: FnOnce(&mut StacksChainState, &SortitionDB) -> R,
     {
         let sortdb = peer.sortdb.take().unwrap();
         let r = todo(peer.chainstate(), &sortdb);
@@ -1592,7 +1592,7 @@ pub mod test {
                     })),
                 ),
             ])
-                .unwrap(),
+            .unwrap(),
         )
     }
 
@@ -1662,7 +1662,7 @@ pub mod test {
                 Value::buff_from(signer_key).unwrap(),
             ],
         )
-            .unwrap();
+        .unwrap();
 
         make_tx(key, nonce, 0, payload)
     }
@@ -1692,7 +1692,7 @@ pub mod test {
                 Value::UInt(lock_period),
             ],
         )
-            .unwrap();
+        .unwrap();
 
         make_tx(key, nonce, 0, payload)
     }
@@ -1711,7 +1711,7 @@ pub mod test {
             "set-aggregate-public-key",
             vec![Value::UInt(reward_cycle as u128), aggregate_public_key],
         )
-            .unwrap();
+        .unwrap();
         make_tx(key, nonce, 0, payload)
     }
 
@@ -1726,7 +1726,7 @@ pub mod test {
             "stack-increase",
             vec![Value::UInt(amount)],
         )
-            .unwrap();
+        .unwrap();
 
         make_tx(key, nonce, 0, payload)
     }
@@ -1744,7 +1744,7 @@ pub mod test {
             "stack-extend",
             vec![Value::UInt(lock_period), addr_tuple],
         )
-            .unwrap();
+        .unwrap();
 
         make_tx(key, nonce, 0, payload)
     }
@@ -1762,7 +1762,7 @@ pub mod test {
             "stack-extend",
             vec![Value::UInt(lock_period), addr_tuple],
         )
-            .unwrap();
+        .unwrap();
 
         make_tx(key, nonce, 0, payload)
     }
@@ -1779,9 +1779,13 @@ pub mod test {
             boot_code_test_addr(),
             POX_4_NAME,
             "stack-extend",
-            vec![Value::UInt(lock_period), addr_tuple, Value::buff_from(signer_key).unwrap()],
+            vec![
+                Value::UInt(lock_period),
+                addr_tuple,
+                Value::buff_from(signer_key).unwrap(),
+            ],
         )
-            .unwrap();
+        .unwrap();
 
         make_tx(key, nonce, 0, payload)
     }
@@ -1817,7 +1821,7 @@ pub mod test {
             function_name,
             args,
         )
-            .unwrap();
+        .unwrap();
 
         make_tx(key, nonce, 0, payload)
     }
@@ -1834,7 +1838,7 @@ pub mod test {
             function_name,
             args,
         )
-            .unwrap();
+        .unwrap();
 
         make_tx(key, nonce, 0, payload)
     }
@@ -1851,7 +1855,7 @@ pub mod test {
             function_name,
             args,
         )
-            .unwrap();
+        .unwrap();
 
         make_tx(key, nonce, 0, payload)
     }
@@ -1868,7 +1872,7 @@ pub mod test {
             function_name,
             args,
         )
-            .unwrap();
+        .unwrap();
 
         make_tx(key, nonce, 0, payload)
     }
@@ -1894,7 +1898,7 @@ pub mod test {
                     })),
                 ),
             ])
-                .unwrap(),
+            .unwrap(),
         );
 
         let generator = |amount, pox_addr, lock_period, nonce| {
@@ -2020,7 +2024,7 @@ pub mod test {
                 Value::UInt(lock_period),
             ],
         )
-            .unwrap();
+        .unwrap();
         make_tx(key, nonce, 0, payload)
     }
 
@@ -2038,7 +2042,7 @@ pub mod test {
             "withdraw-stx",
             vec![Value::UInt(amount)],
         )
-            .unwrap();
+        .unwrap();
         make_tx(key, nonce, 0, payload)
     }
 
@@ -2094,15 +2098,15 @@ pub mod test {
                     &tip.sortition_id,
                     &block.block_hash(),
                 )
-                    .unwrap()
-                    .unwrap(); // succeeds because we don't fork
+                .unwrap()
+                .unwrap(); // succeeds because we don't fork
                 StacksChainState::get_anchored_block_header_info(
                     chainstate.db(),
                     &snapshot.consensus_hash,
                     &snapshot.winning_stacks_block_hash,
                 )
-                    .unwrap()
-                    .unwrap()
+                .unwrap()
+                .unwrap()
             }
         };
         parent_tip
@@ -2156,7 +2160,7 @@ pub mod test {
                         tip.total_burn,
                         microblock_pubkeyhash,
                     )
-                        .unwrap();
+                    .unwrap();
                     let (anchored_block, _size, _cost) =
                         StacksBlockBuilder::make_anchored_block_from_txs(
                             block_builder,
@@ -2164,7 +2168,7 @@ pub mod test {
                             &sortdb.index_conn(),
                             block_txs,
                         )
-                            .unwrap();
+                        .unwrap();
                     (anchored_block, vec![])
                 },
             );
@@ -2278,7 +2282,7 @@ pub mod test {
                         tip.total_burn,
                         microblock_pubkeyhash,
                     )
-                        .unwrap();
+                    .unwrap();
                     let (anchored_block, _size, _cost) =
                         StacksBlockBuilder::make_anchored_block_from_txs(
                             block_builder,
@@ -2286,7 +2290,7 @@ pub mod test {
                             &sortdb.index_conn(),
                             block_txs,
                         )
-                            .unwrap();
+                        .unwrap();
                     (anchored_block, vec![])
                 },
             );
@@ -2468,7 +2472,7 @@ pub mod test {
                         tip.total_burn,
                         microblock_pubkeyhash,
                     )
-                        .unwrap();
+                    .unwrap();
                     let (anchored_block, _size, _cost) =
                         StacksBlockBuilder::make_anchored_block_from_txs(
                             block_builder,
@@ -2476,7 +2480,7 @@ pub mod test {
                             &sortdb.index_conn(),
                             block_txs,
                         )
-                            .unwrap();
+                        .unwrap();
                     (anchored_block, vec![])
                 },
             );
@@ -2512,8 +2516,8 @@ pub mod test {
                 state.db(),
                 &parent_block_id,
             )
-                .unwrap()
-                .unwrap();
+            .unwrap()
+            .unwrap();
 
         parent_header_info.burn_header_height as u64
     }
@@ -2578,7 +2582,7 @@ pub mod test {
                         tip.total_burn,
                         microblock_pubkeyhash,
                     )
-                        .unwrap();
+                    .unwrap();
                     let (anchored_block, _size, _cost) =
                         StacksBlockBuilder::make_anchored_block_from_txs(
                             block_builder,
@@ -2586,7 +2590,7 @@ pub mod test {
                             &sortdb.index_conn(),
                             block_txs,
                         )
-                            .unwrap();
+                        .unwrap();
                     (anchored_block, vec![])
                 },
             );
@@ -2614,7 +2618,7 @@ pub mod test {
                 let min_ustx = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                     chainstate.get_stacking_minimum(sortdb, &tip_index_block)
                 })
-                    .unwrap();
+                .unwrap();
                 assert_eq!(min_ustx, total_liquid_ustx / TESTNET_STACKING_THRESHOLD_25);
 
                 // no reward addresses
@@ -2626,7 +2630,7 @@ pub mod test {
                         &tip_index_block,
                     )
                 })
-                    .unwrap();
+                .unwrap();
                 assert_eq!(reward_addrs.len(), 0);
 
                 // record the first reward cycle when Alice's tokens get stacked
@@ -2658,7 +2662,7 @@ pub mod test {
                 let min_ustx = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                     chainstate.get_stacking_minimum(sortdb, &tip_index_block)
                 })
-                    .unwrap();
+                .unwrap();
                 let reward_addrs = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                     get_reward_addresses_with_par_tip(
                         chainstate,
@@ -2667,7 +2671,7 @@ pub mod test {
                         &tip_index_block,
                     )
                 })
-                    .unwrap();
+                .unwrap();
                 let total_stacked = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                     chainstate.test_get_total_ustx_stacked(
                         sortdb,
@@ -2675,7 +2679,7 @@ pub mod test {
                         cur_reward_cycle,
                     )
                 })
-                    .unwrap();
+                .unwrap();
 
                 eprintln!("\ntenure: {}\nreward cycle: {}\nmin-uSTX: {}\naddrs: {:?}\ntotal_liquid_ustx: {}\ntotal-stacked: {}\n", tenure_id, cur_reward_cycle, min_ustx, &reward_addrs, total_liquid_ustx, total_stacked);
 
@@ -2795,7 +2799,7 @@ pub mod test {
                         tip.total_burn,
                         microblock_pubkeyhash,
                     )
-                        .unwrap();
+                    .unwrap();
                     let (anchored_block, _size, _cost) =
                         StacksBlockBuilder::make_anchored_block_from_txs(
                             block_builder,
@@ -2803,7 +2807,7 @@ pub mod test {
                             &sortdb.index_conn(),
                             block_txs,
                         )
-                            .unwrap();
+                        .unwrap();
                     (anchored_block, vec![])
                 },
             );
@@ -2865,7 +2869,7 @@ pub mod test {
                 let min_ustx = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                     chainstate.get_stacking_minimum(sortdb, &tip_index_block)
                 })
-                    .unwrap();
+                .unwrap();
                 assert_eq!(min_ustx, total_liquid_ustx / TESTNET_STACKING_THRESHOLD_25);
 
                 // no reward addresses
@@ -2877,7 +2881,7 @@ pub mod test {
                         &tip_index_block,
                     )
                 })
-                    .unwrap();
+                .unwrap();
                 assert_eq!(reward_addrs.len(), 0);
 
                 // record the first reward cycle when tokens get stacked
@@ -2911,7 +2915,7 @@ pub mod test {
                 let min_ustx = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                     chainstate.get_stacking_minimum(sortdb, &tip_index_block)
                 })
-                    .unwrap();
+                .unwrap();
                 let reward_addrs = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                     get_reward_addresses_with_par_tip(
                         chainstate,
@@ -2920,7 +2924,7 @@ pub mod test {
                         &tip_index_block,
                     )
                 })
-                    .unwrap();
+                .unwrap();
                 let total_stacked = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                     chainstate.test_get_total_ustx_stacked(
                         sortdb,
@@ -2928,7 +2932,7 @@ pub mod test {
                         cur_reward_cycle,
                     )
                 })
-                    .unwrap();
+                .unwrap();
 
                 eprintln!("\ntenure: {}\nreward cycle: {}\nmin-uSTX: {}\naddrs: {:?}\ntotal_liquid_ustx: {}\ntotal-stacked: {}\n", tenure_id, cur_reward_cycle, min_ustx, &reward_addrs, total_liquid_ustx, total_stacked);
 
@@ -3052,7 +3056,7 @@ pub mod test {
                         tip.total_burn,
                         microblock_pubkeyhash,
                     )
-                        .unwrap();
+                    .unwrap();
                     let (anchored_block, _size, _cost) =
                         StacksBlockBuilder::make_anchored_block_from_txs(
                             block_builder,
@@ -3060,7 +3064,7 @@ pub mod test {
                             &sortdb.index_conn(),
                             block_txs,
                         )
-                            .unwrap();
+                        .unwrap();
                     (anchored_block, vec![])
                 },
             );
@@ -3080,7 +3084,7 @@ pub mod test {
                 let min_ustx = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                     chainstate.get_stacking_minimum(sortdb, &tip_index_block)
                 })
-                    .unwrap();
+                .unwrap();
                 assert_eq!(min_ustx, total_liquid_ustx / TESTNET_STACKING_THRESHOLD_25);
 
                 // no reward addresses
@@ -3092,7 +3096,7 @@ pub mod test {
                         &tip_index_block,
                     )
                 })
-                    .unwrap();
+                .unwrap();
                 assert_eq!(reward_addrs.len(), 0);
 
                 // record the first reward cycle when Alice's tokens get stacked
@@ -3123,7 +3127,7 @@ pub mod test {
                 let min_ustx = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                     chainstate.get_stacking_minimum(sortdb, &tip_index_block)
                 })
-                    .unwrap();
+                .unwrap();
                 let reward_addrs = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                     get_reward_addresses_with_par_tip(
                         chainstate,
@@ -3132,7 +3136,7 @@ pub mod test {
                         &tip_index_block,
                     )
                 })
-                    .unwrap();
+                .unwrap();
                 let total_stacked = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                     chainstate.test_get_total_ustx_stacked(
                         sortdb,
@@ -3140,7 +3144,7 @@ pub mod test {
                         cur_reward_cycle,
                     )
                 })
-                    .unwrap();
+                .unwrap();
 
                 eprintln!("\ntenure: {}\nreward cycle: {}\nmin-uSTX: {}\naddrs: {:?}\ntotal_liquid_ustx: {}\ntotal-stacked: {}\n", tenure_id, cur_reward_cycle, min_ustx, &reward_addrs, total_liquid_ustx, total_stacked);
 
@@ -3175,7 +3179,7 @@ pub mod test {
                                 &mut peer,
                                 &make_contract_id(&key_to_stacks_addr(&bob), "do-lockup").into(),
                             )
-                                .unwrap();
+                            .unwrap();
                         eprintln!("\nContract: {} uSTX stacked for {} cycle(s); addr is {:?}; first reward cycle is {}\n", amount_ustx, lock_period, &pox_addr, first_reward_cycle);
 
                         // should be consistent with the API call
@@ -3326,7 +3330,7 @@ pub mod test {
                         tip.total_burn,
                         microblock_pubkeyhash,
                     )
-                        .unwrap();
+                    .unwrap();
                     let (anchored_block, _size, _cost) =
                         StacksBlockBuilder::make_anchored_block_from_txs(
                             block_builder,
@@ -3334,7 +3338,7 @@ pub mod test {
                             &sortdb.index_conn(),
                             block_txs,
                         )
-                            .unwrap();
+                        .unwrap();
                     (anchored_block, vec![])
                 },
             );
@@ -3359,7 +3363,7 @@ pub mod test {
                 let min_ustx = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                     chainstate.get_stacking_minimum(sortdb, &tip_index_block)
                 })
-                    .unwrap();
+                .unwrap();
                 assert_eq!(min_ustx, total_liquid_ustx / TESTNET_STACKING_THRESHOLD_25);
 
                 // no reward addresses
@@ -3371,7 +3375,7 @@ pub mod test {
                         &tip_index_block,
                     )
                 })
-                    .unwrap();
+                .unwrap();
                 assert_eq!(reward_addrs.len(), 0);
 
                 // record the first reward cycle when Alice's tokens get stacked
@@ -3409,7 +3413,7 @@ pub mod test {
                 let min_ustx = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                     chainstate.get_stacking_minimum(sortdb, &tip_index_block)
                 })
-                    .unwrap();
+                .unwrap();
                 let reward_addrs = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                     get_reward_addresses_with_par_tip(
                         chainstate,
@@ -3418,7 +3422,7 @@ pub mod test {
                         &tip_index_block,
                     )
                 })
-                    .unwrap();
+                .unwrap();
 
                 eprintln!(
                     "\nreward cycle: {}\nmin-uSTX: {}\naddrs: {:?}\ntotal_liquid_ustx: {}\n",
@@ -3608,7 +3612,7 @@ pub mod test {
                         &tip_index_block,
                     )
                 })
-                    .unwrap();
+                .unwrap();
                 assert_eq!(reward_addrs.len(), 0);
 
                 // record the first reward cycle when Alice's tokens get stacked
@@ -3741,7 +3745,7 @@ pub mod test {
                         tip.total_burn,
                         microblock_pubkeyhash,
                     )
-                        .unwrap();
+                    .unwrap();
                     let (anchored_block, _size, _cost) =
                         StacksBlockBuilder::make_anchored_block_from_txs(
                             block_builder,
@@ -3749,7 +3753,7 @@ pub mod test {
                             &sortdb.index_conn(),
                             block_txs,
                         )
-                            .unwrap();
+                        .unwrap();
                     (anchored_block, vec![])
                 },
             );
@@ -3770,7 +3774,7 @@ pub mod test {
                 let min_ustx = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                     chainstate.get_stacking_minimum(sortdb, &tip_index_block)
                 })
-                    .unwrap();
+                .unwrap();
                 assert_eq!(min_ustx, total_liquid_ustx / TESTNET_STACKING_THRESHOLD_25);
 
                 // no reward addresses
@@ -3782,7 +3786,7 @@ pub mod test {
                         &tip_index_block,
                     )
                 })
-                    .unwrap();
+                .unwrap();
                 assert_eq!(reward_addrs.len(), 0);
 
                 // record the first reward cycle when Alice's tokens get stacked
@@ -3812,7 +3816,7 @@ pub mod test {
                 let min_ustx = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                     chainstate.get_stacking_minimum(sortdb, &tip_index_block)
                 })
-                    .unwrap();
+                .unwrap();
                 let reward_addrs = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                     get_reward_addresses_with_par_tip(
                         chainstate,
@@ -3821,7 +3825,7 @@ pub mod test {
                         &tip_index_block,
                     )
                 })
-                    .unwrap();
+                .unwrap();
                 let total_stacked = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                     chainstate.test_get_total_ustx_stacked(
                         sortdb,
@@ -3829,7 +3833,7 @@ pub mod test {
                         cur_reward_cycle,
                     )
                 })
-                    .unwrap();
+                .unwrap();
 
                 eprintln!("\ntenure: {}\nreward cycle: {}\nmin-uSTX: {}\naddrs: {:?}\ntotal_liquid_ustx: {}\ntotal-stacked: {}\n", tenure_id, cur_reward_cycle, min_ustx, &reward_addrs, total_liquid_ustx, total_stacked);
 
@@ -4039,7 +4043,7 @@ pub mod test {
                         tip.total_burn,
                         microblock_pubkeyhash,
                     )
-                        .unwrap();
+                    .unwrap();
                     let (anchored_block, _size, _cost) =
                         StacksBlockBuilder::make_anchored_block_from_txs(
                             block_builder,
@@ -4047,7 +4051,7 @@ pub mod test {
                             &sortdb.index_conn(),
                             block_txs,
                         )
-                            .unwrap();
+                        .unwrap();
                     (anchored_block, vec![])
                 },
             );
@@ -4073,15 +4077,15 @@ pub mod test {
             let reward_addrs = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                 get_reward_addresses_with_par_tip(chainstate, &burnchain, sortdb, &tip_index_block)
             })
-                .unwrap();
+            .unwrap();
             let min_ustx = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                 chainstate.get_stacking_minimum(sortdb, &tip_index_block)
             })
-                .unwrap();
+            .unwrap();
             let total_stacked = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                 chainstate.test_get_total_ustx_stacked(sortdb, &tip_index_block, cur_reward_cycle)
             })
-                .unwrap();
+            .unwrap();
 
             if tenure_id <= 1 {
                 if tenure_id < 1 {
@@ -4095,7 +4099,7 @@ pub mod test {
                 let min_ustx = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                     chainstate.get_stacking_minimum(sortdb, &tip_index_block)
                 })
-                    .unwrap();
+                .unwrap();
                 assert_eq!(min_ustx, total_liquid_ustx / TESTNET_STACKING_THRESHOLD_25);
 
                 // no reward addresses
@@ -4131,7 +4135,7 @@ pub mod test {
                 let min_ustx = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                     chainstate.get_stacking_minimum(sortdb, &tip_index_block)
                 })
-                    .unwrap();
+                .unwrap();
                 assert_eq!(min_ustx, total_liquid_ustx / TESTNET_STACKING_THRESHOLD_25);
 
                 // no reward addresses
@@ -4182,7 +4186,7 @@ pub mod test {
                             &mut peer,
                             &make_contract_id(&key_to_stacks_addr(&bob), "do-lockup").into(),
                         )
-                            .unwrap();
+                        .unwrap();
                     eprintln!("\nCharlie: {} uSTX stacked for {} cycle(s); addr is {:?}; first reward cycle is {}\n", amount_ustx, lock_period, &pox_addr, first_reward_cycle);
 
                     assert_eq!(first_reward_cycle, first_pox_reward_cycle);
@@ -4260,7 +4264,7 @@ pub mod test {
                         &mut peer,
                         &make_contract_id(&key_to_stacks_addr(&bob), "do-lockup").into(),
                     )
-                        .is_none());
+                    .is_none());
 
                     // empty reward cycle
                     assert_eq!(reward_addrs.len(), 0);
@@ -4309,7 +4313,7 @@ pub mod test {
                             &mut peer,
                             &make_contract_id(&key_to_stacks_addr(&bob), "do-lockup").into(),
                         )
-                            .unwrap();
+                        .unwrap();
                     eprintln!("\nCharlie: {} uSTX stacked for {} cycle(s); addr is {:?}; second reward cycle is {}\n", amount_ustx, lock_period, &pox_addr, second_reward_cycle);
 
                     assert_eq!(first_pox_reward_cycle, second_reward_cycle);
@@ -4393,7 +4397,7 @@ pub mod test {
                         &mut peer,
                         &make_contract_id(&key_to_stacks_addr(&bob), "do-lockup").into(),
                     )
-                        .is_none());
+                    .is_none());
 
                     // empty reward cycle
                     assert_eq!(reward_addrs.len(), 0);
@@ -4619,7 +4623,7 @@ pub mod test {
                         tip.total_burn,
                         microblock_pubkeyhash,
                     )
-                        .unwrap();
+                    .unwrap();
                     let (anchored_block, _size, _cost) =
                         StacksBlockBuilder::make_anchored_block_from_txs(
                             block_builder,
@@ -4627,7 +4631,7 @@ pub mod test {
                             &sortdb.index_conn(),
                             block_txs,
                         )
-                            .unwrap();
+                        .unwrap();
                     (anchored_block, vec![])
                 },
             );
@@ -4717,15 +4721,15 @@ pub mod test {
             let min_ustx = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                 chainstate.get_stacking_minimum(sortdb, &tip_index_block)
             })
-                .unwrap();
+            .unwrap();
             let reward_addrs = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                 get_reward_addresses_with_par_tip(chainstate, &burnchain, sortdb, &tip_index_block)
             })
-                .unwrap();
+            .unwrap();
             let total_stacked = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                 chainstate.test_get_total_ustx_stacked(sortdb, &tip_index_block, cur_reward_cycle)
             })
-                .unwrap();
+            .unwrap();
 
             eprintln!("\ntenure: {}\nreward cycle: {}\nmin-uSTX: {}\naddrs: {:?}\ntotal_liquid_ustx: {}\ntotal-stacked: {}\n", tenure_id, cur_reward_cycle, min_ustx, &reward_addrs, total_liquid_ustx, total_stacked);
 
@@ -4733,7 +4737,7 @@ pub mod test {
                 if tenure_id < 1 {
                     // no one has locked
                     for (balance, expected_balance) in
-                    balances.iter().zip(balances_before_stacking.iter())
+                        balances.iter().zip(balances_before_stacking.iter())
                     {
                         assert_eq!(balance, expected_balance);
                     }
@@ -4749,7 +4753,7 @@ pub mod test {
                         &tip_index_block,
                     )
                 })
-                    .unwrap();
+                .unwrap();
                 assert_eq!(reward_addrs.len(), 0);
 
                 // record the first reward cycle when Alice's tokens get stacked
@@ -4769,7 +4773,7 @@ pub mod test {
                     &mut peer,
                     &make_contract_id(&key_to_stacks_addr(&alice), "alice-try-spend").into(),
                 )
-                    .is_none());
+                .is_none());
             }
 
             if reward_cycle > 0 {
@@ -4788,7 +4792,7 @@ pub mod test {
 
                     // in stacker order
                     for (i, (pox_addr, expected_stacked)) in
-                    sorted_expected_pox_info.iter().enumerate()
+                        sorted_expected_pox_info.iter().enumerate()
                     {
                         assert_eq!((reward_addrs[i].0).version(), pox_addr.0);
                         assert_eq!((reward_addrs[i].0).hash160(), pox_addr.1);
@@ -4807,14 +4811,14 @@ pub mod test {
 
                     // all tokens locked
                     for (balance, expected_balance) in
-                    balances.iter().zip(balances_during_stacking.iter())
+                        balances.iter().zip(balances_during_stacking.iter())
                     {
                         assert_eq!(balance, expected_balance);
                     }
 
                     // Lock-up is consistent with stacker state
                     for (addr, expected_balance) in
-                    stacker_addrs.iter().zip(balances_stacked.iter())
+                        stacker_addrs.iter().zip(balances_stacked.iter())
                     {
                         let account = get_account(&mut peer, addr);
                         assert_eq!(account.stx_balance.amount_unlocked(), 0);
@@ -4832,14 +4836,14 @@ pub mod test {
                     if tenure_id < 11 {
                         // all balances should have been restored
                         for (balance, expected_balance) in
-                        balances.iter().zip(balances_after_stacking.iter())
+                            balances.iter().zip(balances_after_stacking.iter())
                         {
                             assert_eq!(balance, expected_balance);
                         }
                     } else {
                         // some balances reduced, but none are zero
                         for (balance, expected_balance) in
-                        balances.iter().zip(balances_after_spending.iter())
+                            balances.iter().zip(balances_after_spending.iter())
                         {
                             assert_eq!(balance, expected_balance);
                         }
@@ -4861,7 +4865,7 @@ pub mod test {
             if tenure_id >= 11 {
                 // all balances are restored
                 for (addr, expected_balance) in
-                stacker_addrs.iter().zip(balances_after_spending.iter())
+                    stacker_addrs.iter().zip(balances_after_spending.iter())
                 {
                     let account = get_account(&mut peer, addr);
                     assert_eq!(account.stx_balance.amount_unlocked(), *expected_balance);
@@ -5019,15 +5023,15 @@ pub mod test {
             let min_ustx = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                 chainstate.get_stacking_minimum(sortdb, &tip_index_block)
             })
-                .unwrap();
+            .unwrap();
             let reward_addrs = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                 get_reward_addresses_with_par_tip(chainstate, &burnchain, sortdb, &tip_index_block)
             })
-                .unwrap();
+            .unwrap();
             let total_stacked = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                 chainstate.test_get_total_ustx_stacked(sortdb, &tip_index_block, cur_reward_cycle)
             })
-                .unwrap();
+            .unwrap();
             let total_stacked_next = with_sortdb(&mut peer, |ref mut chainstate, ref sortdb| {
                 chainstate.test_get_total_ustx_stacked(
                     sortdb,
@@ -5035,7 +5039,7 @@ pub mod test {
                     cur_reward_cycle + 1,
                 )
             })
-                .unwrap();
+            .unwrap();
 
             eprintln!("\ntenure: {}\nreward cycle: {}\nmin-uSTX: {}\naddrs: {:?}\ntotal_liquid_ustx: {}\ntotal-stacked: {}\ntotal-stacked next: {}\n",
                       tenure_id, cur_reward_cycle, min_ustx, &reward_addrs, total_liquid_ustx, total_stacked, total_stacked_next);
@@ -5080,7 +5084,7 @@ pub mod test {
                         "charlie-try-stack",
                         "(var-get test-passed)",
                     )
-                        .expect_bool();
+                    .expect_bool();
                     assert!(result, "charlie-try-stack test should be `true`");
                     let result = eval_contract_at_tip(
                         &mut peer,
@@ -5088,7 +5092,7 @@ pub mod test {
                         "charlie-try-reject",
                         "(var-get test-passed)",
                     )
-                        .expect_bool();
+                    .expect_bool();
                     assert!(result, "charlie-try-reject test should be `true`");
                     let result = eval_contract_at_tip(
                         &mut peer,
@@ -5096,7 +5100,7 @@ pub mod test {
                         "alice-try-reject",
                         "(var-get test-passed)",
                     )
-                        .expect_bool();
+                    .expect_bool();
                     assert!(result, "alice-try-reject test should be `true`");
                 }
 
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 2a583b0ddd..67f13aabae 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -88,8 +88,8 @@ fn make_test_epochs_pox() -> (Vec<StacksEpoch>, PoxConstants) {
     let EPOCH_2_1_HEIGHT = EMPTY_SORTITIONS + 11; // 36
     let EPOCH_2_2_HEIGHT = EPOCH_2_1_HEIGHT + 14; // 50
     let EPOCH_2_3_HEIGHT = EPOCH_2_2_HEIGHT + 2; // 52
-    // epoch-2.4 will start at the first block of cycle 11!
-    //  this means that cycle 11 should also be treated like a "burn"
+                                                 // epoch-2.4 will start at the first block of cycle 11!
+                                                 //  this means that cycle 11 should also be treated like a "burn"
     let EPOCH_2_4_HEIGHT = EPOCH_2_3_HEIGHT + 4; // 56
     let EPOCH_2_5_HEIGHT = EPOCH_2_4_HEIGHT + 44; // 100
 
@@ -341,7 +341,7 @@ fn pox_extend_transition() {
     let min_ustx = with_sortdb(&mut peer, |chainstate, sortdb| {
         chainstate.get_stacking_minimum(sortdb, &tip_index_block)
     })
-        .unwrap();
+    .unwrap();
     assert_eq!(
         min_ustx,
         total_liquid_ustx / POX_TESTNET_STACKING_THRESHOLD_25
@@ -351,7 +351,7 @@ fn pox_extend_transition() {
     let reward_addrs = with_sortdb(&mut peer, |chainstate, sortdb| {
         get_reward_addresses_with_par_tip(chainstate, &burnchain, sortdb, &tip_index_block)
     })
-        .unwrap();
+    .unwrap();
     assert_eq!(reward_addrs.len(), 0);
 
     // check the first reward cycle when Alice's tokens get stacked
@@ -530,8 +530,16 @@ fn pox_extend_transition() {
         latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
     }
 
-    let bob_signer_key = vec![0x02, 0xb6, 0x19, 0x6d, 0xe8, 0x8b, 0xce, 0xe7, 0x93, 0xfa, 0x9a, 0x8a, 0x85, 0x96, 0x9b, 0x64, 0x7f, 0x84, 0xc9, 0x0e, 0x9d, 0x13, 0xf9, 0xc8, 0xb8, 0xce, 0x42, 0x6c, 0xc8, 0x1a, 0x59, 0x98, 0x3c];
-    let alice_signer_key = vec![0x03, 0xa0, 0xf9, 0x81, 0x8e, 0xa8, 0xc1, 0x4a, 0x82, 0x7b, 0xb1, 0x44, 0xae, 0xc9, 0xcf, 0xba, 0xeb, 0xa2, 0x25, 0xaf, 0x22, 0xbe, 0x18, 0xed, 0x78, 0xa2, 0xf2, 0x98, 0x10, 0x6f, 0x4e, 0x28, 0x1b];
+    let bob_signer_key = vec![
+        0x02, 0xb6, 0x19, 0x6d, 0xe8, 0x8b, 0xce, 0xe7, 0x93, 0xfa, 0x9a, 0x8a, 0x85, 0x96, 0x9b,
+        0x64, 0x7f, 0x84, 0xc9, 0x0e, 0x9d, 0x13, 0xf9, 0xc8, 0xb8, 0xce, 0x42, 0x6c, 0xc8, 0x1a,
+        0x59, 0x98, 0x3c,
+    ];
+    let alice_signer_key = vec![
+        0x03, 0xa0, 0xf9, 0x81, 0x8e, 0xa8, 0xc1, 0x4a, 0x82, 0x7b, 0xb1, 0x44, 0xae, 0xc9, 0xcf,
+        0xba, 0xeb, 0xa2, 0x25, 0xaf, 0x22, 0xbe, 0x18, 0xed, 0x78, 0xa2, 0xf2, 0x98, 0x10, 0x6f,
+        0x4e, 0x28, 0x1b,
+    ];
 
     let tip = get_tip(peer.sortdb.as_ref());
     let bob_lockup = make_pox_4_lockup(
@@ -732,10 +740,10 @@ fn get_burn_pox_addr_info(peer: &mut TestPeer) -> (Vec<PoxAddress>, u128) {
             .unwrap();
         addrs
     })
-        .unwrap()
-        .expect_optional()
-        .expect("FATAL: expected list")
-        .expect_tuple();
+    .unwrap()
+    .expect_optional()
+    .expect("FATAL: expected list")
+    .expect_tuple();
 
     let addrs = addrs_and_payout
         .get("addrs")
@@ -1245,13 +1253,8 @@ fn balances_from_keys(
 #[test]
 fn stack_stx_signer_key() {
     let lock_period = 2;
-    let (
-        burnchain,
-        mut peer,
-        keys,
-        latest_block,
-        block_height,
-        mut coinbase_nonce) = prepare_pox4_test(function_name!());
+    let (burnchain, mut peer, keys, latest_block, block_height, mut coinbase_nonce) =
+        prepare_pox4_test(function_name!());
 
     let stacker_nonce = 0;
     let stacker_key = &keys[0];
@@ -1262,8 +1265,16 @@ fn stack_stx_signer_key() {
     //                       (start-burn-ht uint)
     //                       (lock-period uint)
     //                       (signer-key (buff 33)))
-    let pox_addr = make_pox_addr(AddressHashMode::SerializeP2WSH, key_to_stacks_addr(stacker_key).bytes);
-    let signer_key_val = Value::buff_from(vec![0x03, 0xa0, 0xf9, 0x81, 0x8e, 0xa8, 0xc1, 0x4a, 0x82, 0x7b, 0xb1, 0x44, 0xae, 0xc9, 0xcf, 0xba, 0xeb, 0xa2, 0x25, 0xaf, 0x22, 0xbe, 0x18, 0xed, 0x78, 0xa2, 0xf2, 0x98, 0x10, 0x6f, 0x4e, 0x28, 0x1b]).unwrap();
+    let pox_addr = make_pox_addr(
+        AddressHashMode::SerializeP2WSH,
+        key_to_stacks_addr(stacker_key).bytes,
+    );
+    let signer_key_val = Value::buff_from(vec![
+        0x03, 0xa0, 0xf9, 0x81, 0x8e, 0xa8, 0xc1, 0x4a, 0x82, 0x7b, 0xb1, 0x44, 0xae, 0xc9, 0xcf,
+        0xba, 0xeb, 0xa2, 0x25, 0xaf, 0x22, 0xbe, 0x18, 0xed, 0x78, 0xa2, 0xf2, 0x98, 0x10, 0x6f,
+        0x4e, 0x28, 0x1b,
+    ])
+    .unwrap();
     let txs = vec![make_pox_4_contract_call(
         stacker_key,
         stacker_nonce,
@@ -1283,8 +1294,8 @@ fn stack_stx_signer_key() {
         &latest_block,
         &key_to_stacks_addr(stacker_key).to_account_principal(),
     )
-        .expect("No stacking state, stack-stx failed")
-        .expect_tuple();
+    .expect("No stacking state, stack-stx failed")
+    .expect_tuple();
 
     let state_signer_key = stacking_state.get("signer-key").unwrap();
     assert_eq!(state_signer_key.to_string(), signer_key_val.to_string());
@@ -1293,13 +1304,8 @@ fn stack_stx_signer_key() {
 #[test]
 fn delegate_stx_signer_key() {
     let lock_period = 2;
-    let (
-        burnchain,
-        mut peer,
-        keys,
-        latest_block,
-        block_height,
-        mut coinbase_nonce) = prepare_pox4_test(function_name!());
+    let (burnchain, mut peer, keys, latest_block, block_height, mut coinbase_nonce) =
+        prepare_pox4_test(function_name!());
 
     let stacker_nonce = 0;
     let stacker_key = &keys[0];
@@ -1311,8 +1317,16 @@ fn delegate_stx_signer_key() {
     //                          (until-burn-ht (optional uint))
     //                          (pox-addr (optional { version: (buff 1), hashbytes: (buff 32) }))
     //                          (signer-key (optional (buff 33))))
-    let pox_addr = make_pox_addr(AddressHashMode::SerializeP2WSH, key_to_stacks_addr(delegate_key).bytes);
-    let signer_key_val = Value::buff_from(vec![0x03, 0xa0, 0xf9, 0x81, 0x8e, 0xa8, 0xc1, 0x4a, 0x82, 0x7b, 0xb1, 0x44, 0xae, 0xc9, 0xcf, 0xba, 0xeb, 0xa2, 0x25, 0xaf, 0x22, 0xbe, 0x18, 0xed, 0x78, 0xa2, 0xf2, 0x98, 0x10, 0x6f, 0x4e, 0x28, 0x1b]).unwrap();
+    let pox_addr = make_pox_addr(
+        AddressHashMode::SerializeP2WSH,
+        key_to_stacks_addr(delegate_key).bytes,
+    );
+    let signer_key_val = Value::buff_from(vec![
+        0x03, 0xa0, 0xf9, 0x81, 0x8e, 0xa8, 0xc1, 0x4a, 0x82, 0x7b, 0xb1, 0x44, 0xae, 0xc9, 0xcf,
+        0xba, 0xeb, 0xa2, 0x25, 0xaf, 0x22, 0xbe, 0x18, 0xed, 0x78, 0xa2, 0xf2, 0x98, 0x10, 0x6f,
+        0x4e, 0x28, 0x1b,
+    ])
+    .unwrap();
     let txs = vec![make_pox_4_contract_call(
         stacker_key,
         stacker_nonce,
@@ -1321,8 +1335,12 @@ fn delegate_stx_signer_key() {
             Value::UInt(100),
             delegate_principal.clone().into(),
             Value::none(),
-            Value::Optional(OptionalData { data: Some(Box::new(pox_addr)) }),
-            Value::Optional(OptionalData { data: Some(signer_key_val.clone().into()) }),
+            Value::Optional(OptionalData {
+                data: Some(Box::new(pox_addr)),
+            }),
+            Value::Optional(OptionalData {
+                data: Some(signer_key_val.clone().into()),
+            }),
         ],
     )];
 
@@ -1332,34 +1350,40 @@ fn delegate_stx_signer_key() {
         &latest_block,
         &key_to_stacks_addr(stacker_key).to_account_principal(),
     )
-        .expect("No delegation state, delegate-stx failed")
-        .expect_tuple();
+    .expect("No delegation state, delegate-stx failed")
+    .expect_tuple();
 
     let state_signer_key_optional = delegation_state.get("signer-key").unwrap();
     assert_eq!(
         state_signer_key_optional.to_string(),
-        Value::Optional(OptionalData { data: Some(Box::new(signer_key_val)) }).to_string()
+        Value::Optional(OptionalData {
+            data: Some(Box::new(signer_key_val))
+        })
+        .to_string()
     );
 }
 
 #[test]
 fn stack_extend_signer_key() {
     let lock_period = 2;
-    let (
-        burnchain,
-        mut peer,
-        keys,
-        latest_block,
-        block_height,
-        mut coinbase_nonce) = prepare_pox4_test(function_name!());
+    let (burnchain, mut peer, keys, latest_block, block_height, mut coinbase_nonce) =
+        prepare_pox4_test(function_name!());
 
     let mut stacker_nonce = 0;
     let stacker_key = &keys[0];
     let min_ustx = get_stacking_minimum(&mut peer, &latest_block) * 2;
 
-    let pox_addr = make_pox_addr(AddressHashMode::SerializeP2WSH, key_to_stacks_addr(stacker_key).bytes);
+    let pox_addr = make_pox_addr(
+        AddressHashMode::SerializeP2WSH,
+        key_to_stacks_addr(stacker_key).bytes,
+    );
 
-    let signer_key_val = Value::buff_from(vec![0x03, 0xa0, 0xf9, 0x81, 0x8e, 0xa8, 0xc1, 0x4a, 0x82, 0x7b, 0xb1, 0x44, 0xae, 0xc9, 0xcf, 0xba, 0xeb, 0xa2, 0x25, 0xaf, 0x22, 0xbe, 0x18, 0xed, 0x78, 0xa2, 0xf2, 0x98, 0x10, 0x6f, 0x4e, 0x28, 0x1b]).unwrap();
+    let signer_key_val = Value::buff_from(vec![
+        0x03, 0xa0, 0xf9, 0x81, 0x8e, 0xa8, 0xc1, 0x4a, 0x82, 0x7b, 0xb1, 0x44, 0xae, 0xc9, 0xcf,
+        0xba, 0xeb, 0xa2, 0x25, 0xaf, 0x22, 0xbe, 0x18, 0xed, 0x78, 0xa2, 0xf2, 0x98, 0x10, 0x6f,
+        0x4e, 0x28, 0x1b,
+    ])
+    .unwrap();
     let txs = vec![make_pox_4_contract_call(
         stacker_key,
         stacker_nonce,
@@ -1381,14 +1405,19 @@ fn stack_extend_signer_key() {
         &latest_block,
         &key_to_stacks_addr(stacker_key).to_account_principal(),
     )
-        .expect("No stacking state, stack-stx failed")
-        .expect_tuple();
+    .expect("No stacking state, stack-stx failed")
+    .expect_tuple();
 
     let state_signer_key = stacking_state.get("signer-key").unwrap();
     assert_eq!(state_signer_key.to_string(), signer_key_val.to_string());
 
     // now stack-extend with a new signer-key
-    let signer_key_new_val = Value::buff_from(vec![0x02, 0xb6, 0x19, 0x6d, 0xe8, 0x8b, 0xce, 0xe7, 0x93, 0xfa, 0x9a, 0x8a, 0x85, 0x96, 0x9b, 0x64, 0x7f, 0x84, 0xc9, 0x0e, 0x9d, 0x13, 0xf9, 0xc8, 0xb8, 0xce, 0x42, 0x6c, 0xc8, 0x1a, 0x59, 0x98, 0x3c]).unwrap();
+    let signer_key_new_val = Value::buff_from(vec![
+        0x02, 0xb6, 0x19, 0x6d, 0xe8, 0x8b, 0xce, 0xe7, 0x93, 0xfa, 0x9a, 0x8a, 0x85, 0x96, 0x9b,
+        0x64, 0x7f, 0x84, 0xc9, 0x0e, 0x9d, 0x13, 0xf9, 0xc8, 0xb8, 0xce, 0x42, 0x6c, 0xc8, 0x1a,
+        0x59, 0x98, 0x3c,
+    ])
+    .unwrap();
 
     // (define-public (stack-extend (extend-count uint)
     //                          (pox-addr { version: (buff 1), hashbytes: (buff 32) })
@@ -1397,11 +1426,7 @@ fn stack_extend_signer_key() {
         stacker_key,
         stacker_nonce,
         "stack-extend",
-        vec![
-            Value::UInt(1),
-            pox_addr,
-            signer_key_new_val.clone(),
-        ],
+        vec![Value::UInt(1), pox_addr, signer_key_new_val.clone()],
     )];
 
     latest_block = peer.tenure_with_txs(&update_txs, &mut coinbase_nonce);
@@ -1410,23 +1435,21 @@ fn stack_extend_signer_key() {
         &latest_block,
         &key_to_stacks_addr(stacker_key).to_account_principal(),
     )
-        .unwrap()
-        .expect_tuple();
+    .unwrap()
+    .expect_tuple();
 
     let state_signer_key_new = new_stacking_state.get("signer-key").unwrap();
-    assert_eq!(state_signer_key_new.to_string(), signer_key_new_val.to_string());
+    assert_eq!(
+        state_signer_key_new.to_string(),
+        signer_key_new_val.to_string()
+    );
 }
 
 #[test]
 fn delegate_stack_stx_signer_key() {
     let lock_period = 2;
-    let (
-        burnchain,
-        mut peer,
-        keys,
-        latest_block,
-        block_height,
-        mut coinbase_nonce) = prepare_pox4_test(function_name!());
+    let (burnchain, mut peer, keys, latest_block, block_height, mut coinbase_nonce) =
+        prepare_pox4_test(function_name!());
 
     let stacker_nonce = 0;
     let stacker_key = &keys[0];
@@ -1439,32 +1462,47 @@ fn delegate_stack_stx_signer_key() {
     //                          (until-burn-ht (optional uint))
     //                          (pox-addr (optional { version: (buff 1), hashbytes: (buff 32) }))
     //                          (signer-key (optional (buff 33))))
-    let pox_addr = make_pox_addr(AddressHashMode::SerializeP2WSH, key_to_stacks_addr(delegate_key).bytes);
-    let signer_key_val = Value::buff_from(vec![0x03, 0xa0, 0xf9, 0x81, 0x8e, 0xa8, 0xc1, 0x4a, 0x82, 0x7b, 0xb1, 0x44, 0xae, 0xc9, 0xcf, 0xba, 0xeb, 0xa2, 0x25, 0xaf, 0x22, 0xbe, 0x18, 0xed, 0x78, 0xa2, 0xf2, 0x98, 0x10, 0x6f, 0x4e, 0x28, 0x1b]).unwrap();
-    let txs = vec![make_pox_4_contract_call(
-        stacker_key,
-        stacker_nonce,
-        "delegate-stx",
-        vec![
-            Value::UInt(100),
-            delegate_principal.clone().into(),
-            Value::none(),
-            Value::Optional(OptionalData { data: Some(Box::new(pox_addr.clone())) }),
-            Value::Optional(OptionalData { data: Some(signer_key_val.clone().into()) }),
-        ],
-    ), make_pox_4_contract_call(
-        delegate_key,
-        delegate_nonce,
-        "delegate-stack-stx",
-        vec![
-            PrincipalData::from(key_to_stacks_addr(stacker_key)).into(),
-            Value::UInt(100),
-            pox_addr,
-            Value::UInt(block_height as u128),
-            Value::UInt(lock_period),
-            signer_key_val.clone(),
-        ],
-    )];
+    let pox_addr = make_pox_addr(
+        AddressHashMode::SerializeP2WSH,
+        key_to_stacks_addr(delegate_key).bytes,
+    );
+    let signer_key_val = Value::buff_from(vec![
+        0x03, 0xa0, 0xf9, 0x81, 0x8e, 0xa8, 0xc1, 0x4a, 0x82, 0x7b, 0xb1, 0x44, 0xae, 0xc9, 0xcf,
+        0xba, 0xeb, 0xa2, 0x25, 0xaf, 0x22, 0xbe, 0x18, 0xed, 0x78, 0xa2, 0xf2, 0x98, 0x10, 0x6f,
+        0x4e, 0x28, 0x1b,
+    ])
+    .unwrap();
+    let txs = vec![
+        make_pox_4_contract_call(
+            stacker_key,
+            stacker_nonce,
+            "delegate-stx",
+            vec![
+                Value::UInt(100),
+                delegate_principal.clone().into(),
+                Value::none(),
+                Value::Optional(OptionalData {
+                    data: Some(Box::new(pox_addr.clone())),
+                }),
+                Value::Optional(OptionalData {
+                    data: Some(signer_key_val.clone().into()),
+                }),
+            ],
+        ),
+        make_pox_4_contract_call(
+            delegate_key,
+            delegate_nonce,
+            "delegate-stack-stx",
+            vec![
+                PrincipalData::from(key_to_stacks_addr(stacker_key)).into(),
+                Value::UInt(100),
+                pox_addr,
+                Value::UInt(block_height as u128),
+                Value::UInt(lock_period),
+                signer_key_val.clone(),
+            ],
+        ),
+    ];
     // (define-public (delegate-stack-stx (stacker principal)
     //                                (amount-ustx uint)
     //                                (pox-addr { version: (buff 1), hashbytes: (buff 32) })
@@ -1478,13 +1516,16 @@ fn delegate_stack_stx_signer_key() {
         &latest_block,
         &key_to_stacks_addr(stacker_key).to_account_principal(),
     )
-        .expect("No delegation state, delegate-stx failed")
-        .expect_tuple();
+    .expect("No delegation state, delegate-stx failed")
+    .expect_tuple();
 
     let state_signer_key_optional = delegation_state.get("signer-key").unwrap();
     assert_eq!(
         state_signer_key_optional.to_string(),
-        Value::Optional(OptionalData { data: Some(Box::new(signer_key_val.clone())) }).to_string()
+        Value::Optional(OptionalData {
+            data: Some(Box::new(signer_key_val.clone()))
+        })
+        .to_string()
     );
 
     let stacking_state = get_stacking_state_pox_4(
@@ -1492,8 +1533,8 @@ fn delegate_stack_stx_signer_key() {
         &latest_block,
         &key_to_stacks_addr(stacker_key).to_account_principal(),
     )
-        .expect("No stacking state, stack-stx failed")
-        .expect_tuple();
+    .expect("No stacking state, stack-stx failed")
+    .expect_tuple();
 
     let state_signer_key = stacking_state.get("signer-key").unwrap();
     assert_eq!(state_signer_key.to_string(), signer_key_val.to_string());
@@ -1515,8 +1556,8 @@ pub fn get_stacking_state_pox_4(
             &lookup_tuple,
             &epoch,
         )
-            .unwrap()
-            .expect_optional()
+        .unwrap()
+        .expect_optional()
     })
 }
 
@@ -1536,14 +1577,14 @@ pub fn get_delegation_state_pox_4(
             &lookup_tuple,
             &epoch,
         )
-            .unwrap()
-            .expect_optional()
+        .unwrap()
+        .expect_optional()
     })
 }
 
 pub fn with_clarity_db_ro<F, R>(peer: &mut TestPeer, tip: &StacksBlockId, todo: F) -> R
-    where
-        F: FnOnce(&mut ClarityDatabase) -> R,
+where
+    F: FnOnce(&mut ClarityDatabase) -> R,
 {
     with_sortdb(peer, |ref mut c, ref sortdb| {
         let headers_db = HeadersDBConn(c.state_index.sqlite_conn());
@@ -1558,10 +1599,20 @@ pub fn with_clarity_db_ro<F, R>(peer: &mut TestPeer, tip: &StacksBlockId, todo:
 pub fn get_stacking_minimum(peer: &mut TestPeer, latest_block: &StacksBlockId) -> u128 {
     with_sortdb(peer, |ref mut chainstate, ref sortdb| {
         chainstate.get_stacking_minimum(sortdb, &latest_block)
-    }).unwrap()
+    })
+    .unwrap()
 }
 
-pub fn prepare_pox4_test<'a>(test_name: &str) -> (Burnchain, TestPeer<'a>, Vec<StacksPrivateKey>, StacksBlockId, u64, usize) {
+pub fn prepare_pox4_test<'a>(
+    test_name: &str,
+) -> (
+    Burnchain,
+    TestPeer<'a>,
+    Vec<StacksPrivateKey>,
+    StacksBlockId,
+    u64,
+    usize,
+) {
     let (epochs, pox_constants) = make_test_epochs_pox();
 
     let mut burnchain = Burnchain::default_unittest(
@@ -1570,7 +1621,8 @@ pub fn prepare_pox4_test<'a>(test_name: &str) -> (Burnchain, TestPeer<'a>, Vec<S
     );
     burnchain.pox_constants = pox_constants.clone();
 
-    let (mut peer, keys) = instantiate_pox_peer_with_epoch(&burnchain, test_name, Some(epochs.clone()), None);
+    let (mut peer, keys) =
+        instantiate_pox_peer_with_epoch(&burnchain, test_name, Some(epochs.clone()), None);
 
     assert_eq!(burnchain.pox_constants.reward_slots(), 6);
     let mut coinbase_nonce = 0;
@@ -1588,10 +1640,14 @@ pub fn prepare_pox4_test<'a>(test_name: &str) -> (Burnchain, TestPeer<'a>, Vec<S
 
     let block_height = get_tip(peer.sortdb.as_ref()).block_height;
 
-    info!(
-        "Block height: {}",
-        block_height
-    );
+    info!("Block height: {}", block_height);
 
-    (burnchain, peer, keys, latest_block, block_height, coinbase_nonce)
-}
\ No newline at end of file
+    (
+        burnchain,
+        peer,
+        keys,
+        latest_block,
+        block_height,
+        coinbase_nonce,
+    )
+}

From c5e07547bee1c3ee7afc3a737f4cea746f27c7a3 Mon Sep 17 00:00:00 2001
From: MarvinJanssen <MarvinJanssen@users.noreply.github.com>
Date: Fri, 22 Dec 2023 10:17:37 +0100
Subject: [PATCH 0257/1166] chore: fix ignored test

---
 testnet/stacks-node/src/tests/nakamoto_integrations.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index a188d81937..f8250f58cb 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -337,6 +337,7 @@ fn boot_to_epoch_3(
             pox_addr_tuple,
             clarity::vm::Value::UInt(205),
             clarity::vm::Value::UInt(12),
+            clarity::vm::Value::buff_from(vec![0; 33]).unwrap(), // TODO: replace once signer key calculation is implemented
         ],
     );
 

From 47196c79c30f0eb7595e22a262c169e335c0ff08 Mon Sep 17 00:00:00 2001
From: MarvinJanssen <MarvinJanssen@users.noreply.github.com>
Date: Fri, 22 Dec 2023 15:34:48 +0100
Subject: [PATCH 0258/1166] chore: Vec<u8> to Point

---
 .../src/chainstate/nakamoto/coordinator/tests.rs    |  2 +-
 stackslib/src/chainstate/stacks/boot/mod.rs         |  8 ++++----
 stackslib/src/chainstate/stacks/boot/pox_4_tests.rs | 13 +++++++------
 3 files changed, 12 insertions(+), 11 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index 3a8237a778..362b9c536a 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -68,7 +68,7 @@ fn advance_to_nakamoto(peer: &mut TestPeer) {
                 1_000_000_000_000_000_000,
                 PoxAddress::from_legacy(AddressHashMode::SerializeP2PKH, addr.bytes.clone()),
                 12,
-                vec![0; 33],
+                Point::default(),
                 34,
             );
             vec![stack_tx]
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index aa022d2c12..99deff0063 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -1646,7 +1646,7 @@ pub mod test {
         amount: u128,
         addr: PoxAddress,
         lock_period: u128,
-        signer_key: Vec<u8>,
+        signer_key: Point,
         burn_ht: u64,
     ) -> StacksTransaction {
         let addr_tuple = Value::Tuple(addr.as_clarity_tuple().unwrap());
@@ -1659,7 +1659,7 @@ pub mod test {
                 addr_tuple,
                 Value::UInt(burn_ht as u128),
                 Value::UInt(lock_period),
-                Value::buff_from(signer_key).unwrap(),
+                Value::buff_from(signer_key.compress().data.into()).unwrap(),
             ],
         )
         .unwrap();
@@ -1772,7 +1772,7 @@ pub mod test {
         nonce: u64,
         addr: PoxAddress,
         lock_period: u128,
-        signer_key: Vec<u8>,
+        signer_key: Point,
     ) -> StacksTransaction {
         let addr_tuple = Value::Tuple(addr.as_clarity_tuple().unwrap());
         let payload = TransactionPayload::new_contract_call(
@@ -1782,7 +1782,7 @@ pub mod test {
             vec![
                 Value::UInt(lock_period),
                 addr_tuple,
-                Value::buff_from(signer_key).unwrap(),
+                Value::buff_from(signer_key.compress().data.into()).unwrap(),
             ],
         )
         .unwrap();
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 67f13aabae..ab3b0f22f2 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -42,6 +42,7 @@ use stacks_common::types::chainstate::{
 use stacks_common::types::Address;
 use stacks_common::util::hash::{hex_bytes, to_hex, Sha256Sum, Sha512Trunc256Sum};
 use stacks_common::util::secp256k1::Secp256k1PrivateKey;
+use wsts::curve::point::{Compressed, Point};
 
 use super::test::*;
 use super::RawRewardSetEntry;
@@ -485,7 +486,7 @@ fn pox_extend_transition() {
             key_to_stacks_addr(&alice).bytes,
         ),
         4,
-        vec![0; 33],
+        Point::default(),
         tip.block_height,
     );
     let alice_pox_4_lock_nonce = 2;
@@ -530,12 +531,12 @@ fn pox_extend_transition() {
         latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
     }
 
-    let bob_signer_key = vec![
+    let bob_signer_key: [u8; 33] = [
         0x02, 0xb6, 0x19, 0x6d, 0xe8, 0x8b, 0xce, 0xe7, 0x93, 0xfa, 0x9a, 0x8a, 0x85, 0x96, 0x9b,
         0x64, 0x7f, 0x84, 0xc9, 0x0e, 0x9d, 0x13, 0xf9, 0xc8, 0xb8, 0xce, 0x42, 0x6c, 0xc8, 0x1a,
         0x59, 0x98, 0x3c,
     ];
-    let alice_signer_key = vec![
+    let alice_signer_key: [u8; 33] = [
         0x03, 0xa0, 0xf9, 0x81, 0x8e, 0xa8, 0xc1, 0x4a, 0x82, 0x7b, 0xb1, 0x44, 0xae, 0xc9, 0xcf,
         0xba, 0xeb, 0xa2, 0x25, 0xaf, 0x22, 0xbe, 0x18, 0xed, 0x78, 0xa2, 0xf2, 0x98, 0x10, 0x6f,
         0x4e, 0x28, 0x1b,
@@ -551,7 +552,7 @@ fn pox_extend_transition() {
             key_to_stacks_addr(&bob).bytes,
         ),
         3,
-        bob_signer_key,
+        Point::try_from(&Compressed::from(bob_signer_key)).unwrap(),
         tip.block_height,
     );
 
@@ -564,7 +565,7 @@ fn pox_extend_transition() {
             key_to_stacks_addr(&alice).bytes,
         ),
         6,
-        alice_signer_key,
+        Point::try_from(&Compressed::from(alice_signer_key)).unwrap(),
     );
 
     let alice_pox_4_extend_nonce = 3;
@@ -818,7 +819,7 @@ fn pox_lock_unlock() {
                 1024 * POX_THRESHOLD_STEPS_USTX,
                 pox_addr.clone(),
                 lock_period,
-                vec![0; 33],
+                Point::default(),
                 tip_height,
             ));
             pox_addr

From aa99809d9c09c65bf7623da99ed4e4f5d55e2183 Mon Sep 17 00:00:00 2001
From: MarvinJanssen <MarvinJanssen@users.noreply.github.com>
Date: Sat, 23 Dec 2023 22:50:06 +0100
Subject: [PATCH 0259/1166] chore: Point to StacksPublicKey

---
 stackslib/src/chainstate/nakamoto/coordinator/tests.rs | 8 +++++++-
 stackslib/src/chainstate/stacks/boot/mod.rs            | 8 ++++----
 stackslib/src/chainstate/stacks/boot/pox_4_tests.rs    | 8 ++++----
 3 files changed, 15 insertions(+), 9 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index 362b9c536a..c19b7622ef 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -50,6 +50,12 @@ use crate::net::test::{TestPeer, TestPeerConfig};
 fn advance_to_nakamoto(peer: &mut TestPeer) {
     let mut peer_nonce = 0;
     let private_key = peer.config.private_key.clone();
+    let signer_key = StacksPublicKey::from_slice(&[
+        0x02, 0xb6, 0x19, 0x6d, 0xe8, 0x8b, 0xce, 0xe7, 0x93, 0xfa, 0x9a, 0x8a, 0x85, 0x96, 0x9b,
+        0x64, 0x7f, 0x84, 0xc9, 0x0e, 0x9d, 0x13, 0xf9, 0xc8, 0xb8, 0xce, 0x42, 0x6c, 0xc8, 0x1a,
+        0x59, 0x98, 0x3c,
+    ])
+    .unwrap();
     let addr = StacksAddress::from_public_keys(
         C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
         &AddressHashMode::SerializeP2PKH,
@@ -68,7 +74,7 @@ fn advance_to_nakamoto(peer: &mut TestPeer) {
                 1_000_000_000_000_000_000,
                 PoxAddress::from_legacy(AddressHashMode::SerializeP2PKH, addr.bytes.clone()),
                 12,
-                Point::default(),
+                signer_key,
                 34,
             );
             vec![stack_tx]
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 99deff0063..146bdd1f38 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -1646,7 +1646,7 @@ pub mod test {
         amount: u128,
         addr: PoxAddress,
         lock_period: u128,
-        signer_key: Point,
+        signer_key: StacksPublicKey,
         burn_ht: u64,
     ) -> StacksTransaction {
         let addr_tuple = Value::Tuple(addr.as_clarity_tuple().unwrap());
@@ -1659,7 +1659,7 @@ pub mod test {
                 addr_tuple,
                 Value::UInt(burn_ht as u128),
                 Value::UInt(lock_period),
-                Value::buff_from(signer_key.compress().data.into()).unwrap(),
+                Value::buff_from(signer_key.to_bytes_compressed()).unwrap(),
             ],
         )
         .unwrap();
@@ -1772,7 +1772,7 @@ pub mod test {
         nonce: u64,
         addr: PoxAddress,
         lock_period: u128,
-        signer_key: Point,
+        signer_key: StacksPublicKey,
     ) -> StacksTransaction {
         let addr_tuple = Value::Tuple(addr.as_clarity_tuple().unwrap());
         let payload = TransactionPayload::new_contract_call(
@@ -1782,7 +1782,7 @@ pub mod test {
             vec![
                 Value::UInt(lock_period),
                 addr_tuple,
-                Value::buff_from(signer_key.compress().data.into()).unwrap(),
+                Value::buff_from(signer_key.to_bytes_compressed()).unwrap(),
             ],
         )
         .unwrap();
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index ab3b0f22f2..a60af59c33 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -486,7 +486,7 @@ fn pox_extend_transition() {
             key_to_stacks_addr(&alice).bytes,
         ),
         4,
-        Point::default(),
+        StacksPublicKey::default(),
         tip.block_height,
     );
     let alice_pox_4_lock_nonce = 2;
@@ -552,7 +552,7 @@ fn pox_extend_transition() {
             key_to_stacks_addr(&bob).bytes,
         ),
         3,
-        Point::try_from(&Compressed::from(bob_signer_key)).unwrap(),
+        StacksPublicKey::from_slice(&bob_signer_key).unwrap(),
         tip.block_height,
     );
 
@@ -565,7 +565,7 @@ fn pox_extend_transition() {
             key_to_stacks_addr(&alice).bytes,
         ),
         6,
-        Point::try_from(&Compressed::from(alice_signer_key)).unwrap(),
+        StacksPublicKey::from_slice(&alice_signer_key).unwrap(),
     );
 
     let alice_pox_4_extend_nonce = 3;
@@ -819,7 +819,7 @@ fn pox_lock_unlock() {
                 1024 * POX_THRESHOLD_STEPS_USTX,
                 pox_addr.clone(),
                 lock_period,
-                Point::default(),
+                StacksPublicKey::default(),
                 tip_height,
             ));
             pox_addr

From bf7f841f2bf21c6669b5f085422c2cb4472bf3b0 Mon Sep 17 00:00:00 2001
From: MarvinJanssen <MarvinJanssen@users.noreply.github.com>
Date: Sat, 23 Dec 2023 23:45:09 +0100
Subject: [PATCH 0260/1166] fix: remove signer-key from delegate-stx and update
 tests

---
 .../src/chainstate/stacks/boot/pox-4.clar     | 25 +----
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 98 +------------------
 2 files changed, 10 insertions(+), 113 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index 0530ff65b4..ebc67dd125 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -127,8 +127,7 @@
         until-burn-ht: (optional uint), ;; how long does the delegation last?
         ;; does the delegate _need_ to use a specific
         ;; pox recipient address?
-        pox-addr: (optional { version: (buff 1), hashbytes: (buff 32) }),
-        signer-key: (optional (buff 33))
+        pox-addr: (optional { version: (buff 1), hashbytes: (buff 32) })
     }
 )
 
@@ -612,12 +611,10 @@
 ;;   * amount-ustx: the total amount of ustx the delegate may be allowed to lock
 ;;   * until-burn-ht: an optional burn height at which this delegation expires
 ;;   * pox-addr: an optional address to which any rewards *must* be sent
-;;   * signer-key: an optional signer key, that when set the delegate must use.
 (define-public (delegate-stx (amount-ustx uint)
                              (delegate-to principal)
                              (until-burn-ht (optional uint))
-                             (pox-addr (optional { version: (buff 1), hashbytes: (buff 32) }))
-                             (signer-key (optional (buff 33))))
+                             (pox-addr (optional { version: (buff 1), hashbytes: (buff 32) })))
     (begin
       ;; must be called directly by the tx-sender or by an allowed contract-caller
       (asserts! (check-caller-allowed)
@@ -642,17 +639,13 @@
       (asserts! (is-none (get-check-delegation tx-sender))
         (err ERR_STACKING_ALREADY_DELEGATED))
 
-      ;; ensure the signer key is valid, if it is set
-      (match signer-key key (try! (is-signer-key-valid key)) true)
-
       ;; add delegation record
       (map-set delegation-state
         { stacker: tx-sender }
         { amount-ustx: amount-ustx,
           delegated-to: delegate-to,
           until-burn-ht: until-burn-ht,
-          pox-addr: pox-addr,
-          signer-key: signer-key })
+          pox-addr: pox-addr })
 
       (ok true)))
 
@@ -833,11 +826,7 @@
                                            unlock-burn-height)
                       true)
                   (err ERR_DELEGATION_EXPIRES_DURING_LOCK))
-        ;; if the delegatee set a signer-key, it must be equal to the delegate signer-key
-        (asserts!
-            (or (is-none (get signer-key delegation-info)) (is-eq (get signer-key delegation-info) (some signer-key)))
-            (err ERR_REQUESTED_SIGNER_KEY_MISMATCH)
-        ))
+        )
 
       ;; stacker principal must not be stacking
       (asserts! (is-none (get-stacker-info stacker))
@@ -1214,11 +1203,7 @@
                                            new-unlock-ht)
                       true)
                   (err ERR_DELEGATION_EXPIRES_DURING_LOCK))
-        ;; if the stacker set a signer-key, it must be equal to the delegate signer-key
-        (asserts!
-            (or (is-none (get signer-key delegation-info)) (is-eq (get signer-key delegation-info) (some signer-key)))
-            (err ERR_REQUESTED_SIGNER_KEY_MISMATCH)
-        ))
+        )
 
       ;; delegate stacking does minimal-can-stack-stx
       (try! (minimal-can-stack-stx pox-addr amount-ustx first-extend-cycle lock-period))
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index a60af59c33..9db720fe77 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -52,9 +52,9 @@ use crate::chainstate::burn::operations::*;
 use crate::chainstate::burn::{BlockSnapshot, ConsensusHash};
 use crate::chainstate::stacks::address::{PoxAddress, PoxAddressType20, PoxAddressType32};
 use crate::chainstate::stacks::boot::pox_2_tests::{
-    check_pox_print_event, check_stacking_state_invariants, generate_pox_clarity_value,
-    get_partial_stacked, get_reward_cycle_total, get_reward_set_entries_at, get_stacking_state_pox,
-    get_stacking_state_pox_2, get_stx_account_at, PoxPrintFields, StackingStateCheckData,
+    check_pox_print_event, generate_pox_clarity_value, get_reward_set_entries_at,
+    get_stacking_state_pox, get_stx_account_at, with_clarity_db_ro, PoxPrintFields,
+    StackingStateCheckData,
 };
 use crate::chainstate::stacks::boot::{
     BOOT_CODE_COST_VOTING_TESTNET as BOOT_CODE_COST_VOTING, BOOT_CODE_POX_TESTNET, POX_2_NAME,
@@ -1302,68 +1302,6 @@ fn stack_stx_signer_key() {
     assert_eq!(state_signer_key.to_string(), signer_key_val.to_string());
 }
 
-#[test]
-fn delegate_stx_signer_key() {
-    let lock_period = 2;
-    let (burnchain, mut peer, keys, latest_block, block_height, mut coinbase_nonce) =
-        prepare_pox4_test(function_name!());
-
-    let stacker_nonce = 0;
-    let stacker_key = &keys[0];
-    let delegate_key = &keys[1];
-    let delegate_principal = PrincipalData::from(key_to_stacks_addr(delegate_key));
-
-    // (define-public (delegate-stx (amount-ustx uint)
-    //                          (delegate-to principal)
-    //                          (until-burn-ht (optional uint))
-    //                          (pox-addr (optional { version: (buff 1), hashbytes: (buff 32) }))
-    //                          (signer-key (optional (buff 33))))
-    let pox_addr = make_pox_addr(
-        AddressHashMode::SerializeP2WSH,
-        key_to_stacks_addr(delegate_key).bytes,
-    );
-    let signer_key_val = Value::buff_from(vec![
-        0x03, 0xa0, 0xf9, 0x81, 0x8e, 0xa8, 0xc1, 0x4a, 0x82, 0x7b, 0xb1, 0x44, 0xae, 0xc9, 0xcf,
-        0xba, 0xeb, 0xa2, 0x25, 0xaf, 0x22, 0xbe, 0x18, 0xed, 0x78, 0xa2, 0xf2, 0x98, 0x10, 0x6f,
-        0x4e, 0x28, 0x1b,
-    ])
-    .unwrap();
-    let txs = vec![make_pox_4_contract_call(
-        stacker_key,
-        stacker_nonce,
-        "delegate-stx",
-        vec![
-            Value::UInt(100),
-            delegate_principal.clone().into(),
-            Value::none(),
-            Value::Optional(OptionalData {
-                data: Some(Box::new(pox_addr)),
-            }),
-            Value::Optional(OptionalData {
-                data: Some(signer_key_val.clone().into()),
-            }),
-        ],
-    )];
-
-    let latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
-    let delegation_state = get_delegation_state_pox_4(
-        &mut peer,
-        &latest_block,
-        &key_to_stacks_addr(stacker_key).to_account_principal(),
-    )
-    .expect("No delegation state, delegate-stx failed")
-    .expect_tuple();
-
-    let state_signer_key_optional = delegation_state.get("signer-key").unwrap();
-    assert_eq!(
-        state_signer_key_optional.to_string(),
-        Value::Optional(OptionalData {
-            data: Some(Box::new(signer_key_val))
-        })
-        .to_string()
-    );
-}
-
 #[test]
 fn stack_extend_signer_key() {
     let lock_period = 2;
@@ -1461,8 +1399,7 @@ fn delegate_stack_stx_signer_key() {
     // (define-public (delegate-stx (amount-ustx uint)
     //                          (delegate-to principal)
     //                          (until-burn-ht (optional uint))
-    //                          (pox-addr (optional { version: (buff 1), hashbytes: (buff 32) }))
-    //                          (signer-key (optional (buff 33))))
+    //                          (pox-addr (optional { version: (buff 1), hashbytes: (buff 32) })))
     let pox_addr = make_pox_addr(
         AddressHashMode::SerializeP2WSH,
         key_to_stacks_addr(delegate_key).bytes,
@@ -1473,6 +1410,7 @@ fn delegate_stack_stx_signer_key() {
         0x4e, 0x28, 0x1b,
     ])
     .unwrap();
+
     let txs = vec![
         make_pox_4_contract_call(
             stacker_key,
@@ -1485,9 +1423,6 @@ fn delegate_stack_stx_signer_key() {
                 Value::Optional(OptionalData {
                     data: Some(Box::new(pox_addr.clone())),
                 }),
-                Value::Optional(OptionalData {
-                    data: Some(signer_key_val.clone().into()),
-                }),
             ],
         ),
         make_pox_4_contract_call(
@@ -1520,15 +1455,6 @@ fn delegate_stack_stx_signer_key() {
     .expect("No delegation state, delegate-stx failed")
     .expect_tuple();
 
-    let state_signer_key_optional = delegation_state.get("signer-key").unwrap();
-    assert_eq!(
-        state_signer_key_optional.to_string(),
-        Value::Optional(OptionalData {
-            data: Some(Box::new(signer_key_val.clone()))
-        })
-        .to_string()
-    );
-
     let stacking_state = get_stacking_state_pox_4(
         &mut peer,
         &latest_block,
@@ -1583,20 +1509,6 @@ pub fn get_delegation_state_pox_4(
     })
 }
 
-pub fn with_clarity_db_ro<F, R>(peer: &mut TestPeer, tip: &StacksBlockId, todo: F) -> R
-where
-    F: FnOnce(&mut ClarityDatabase) -> R,
-{
-    with_sortdb(peer, |ref mut c, ref sortdb| {
-        let headers_db = HeadersDBConn(c.state_index.sqlite_conn());
-        let burn_db = sortdb.index_conn();
-        let mut read_only_clar = c
-            .clarity_state
-            .read_only_connection(tip, &headers_db, &burn_db);
-        read_only_clar.with_clarity_db_readonly(todo)
-    })
-}
-
 pub fn get_stacking_minimum(peer: &mut TestPeer, latest_block: &StacksBlockId) -> u128 {
     with_sortdb(peer, |ref mut chainstate, ref sortdb| {
         chainstate.get_stacking_minimum(sortdb, &latest_block)

From 7c5c4b3e83cff41c67a74e9be87aa420be70ce73 Mon Sep 17 00:00:00 2001
From: MarvinJanssen <MarvinJanssen@users.noreply.github.com>
Date: Thu, 28 Dec 2023 12:50:57 +0100
Subject: [PATCH 0261/1166] feat: disallow signer key reuse and add Rust test

---
 .../src/chainstate/stacks/boot/pox-4.clar     | 25 ++++---
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 71 +++++++++++++++++++
 2 files changed, 87 insertions(+), 9 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index ebc67dd125..45f2b6f16d 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -28,7 +28,7 @@
 (define-constant ERR_STACKING_IS_DELEGATED 30)
 (define-constant ERR_STACKING_NOT_DELEGATED 31)
 (define-constant ERR_INVALID_SIGNER_KEY 32)
-(define-constant ERR_REQUESTED_SIGNER_KEY_MISMATCH 33)
+(define-constant ERR_REUSED_SIGNER_KEY 33)
 
 ;; Valid values for burnchain address versions.
 ;; These first four correspond to address hash modes in Stacks 2.1,
@@ -187,6 +187,9 @@
     { stacked-amount: uint }
 )
 
+;; Stackers' signer keys that have been used before.
+ (define-map used-signer-keys (buff 33) uint)
+
 ;; The stackers' aggregate public key
 ;;   for the given reward cycle
 (define-map aggregate-public-keys uint (buff 33))
@@ -579,8 +582,8 @@
       ;; ensure that stacking can be performed
       (try! (can-stack-stx pox-addr amount-ustx first-reward-cycle lock-period))
 
-      ;; ensure the signer key is valid
-      (try! (is-signer-key-valid signer-key))
+      ;; ensure the signer key can be used
+      (try! (insert-signer-key signer-key))
 
       ;; register the PoX address with the amount stacked
       (let ((reward-set-indexes (try! (add-pox-addr-to-reward-cycles pox-addr first-reward-cycle lock-period amount-ustx tx-sender))))
@@ -836,8 +839,8 @@
       (asserts! (>= (stx-get-balance stacker) amount-ustx)
         (err ERR_STACKING_INSUFFICIENT_FUNDS))
 
-      ;; ensure the signer key is valid
-      (try! (is-signer-key-valid signer-key))
+      ;; ensure the signer key can be used
+      (try! (insert-signer-key signer-key))
 
       ;; ensure that stacking can be performed
       (try! (minimal-can-stack-stx pox-addr amount-ustx first-reward-cycle lock-period))
@@ -984,8 +987,8 @@
     (asserts! (is-none (get delegated-to stacker-state))
               (err ERR_STACKING_IS_DELEGATED))
 
-    ;; ensure the signer key is valid
-    (try! (is-signer-key-valid signer-key))
+    ;; ensure the signer key can be used
+    (try! (insert-signer-key signer-key))
 
     ;; TODO: add more assertions to sanity check the `stacker-info` values with
     ;;       the `stacker-state` values
@@ -1273,6 +1276,10 @@
 
 ;; Check if a provided signer key is valid. For now it only asserts length.
 ;; *New in Stacks 3.0*
-(define-read-only (is-signer-key-valid (signer-key (buff 33)))
-    (ok (asserts! (is-eq (len signer-key) u33) (err ERR_INVALID_SIGNER_KEY)))
+(define-private (insert-signer-key (signer-key (buff 33)))
+    (begin
+      (asserts! (is-eq (len signer-key) u33) (err ERR_INVALID_SIGNER_KEY))
+      (asserts! (map-insert used-signer-keys signer-key burn-block-height) (err ERR_REUSED_SIGNER_KEY))
+      (ok true)
+    )
 )
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 9db720fe77..05ecf21c49 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -1302,6 +1302,77 @@ fn stack_stx_signer_key() {
     assert_eq!(state_signer_key.to_string(), signer_key_val.to_string());
 }
 
+#[test]
+fn stack_stx_signer_key_no_reuse() {
+    let lock_period = 2;
+    let (burnchain, mut peer, keys, latest_block, block_height, mut coinbase_nonce) =
+        prepare_pox4_test(function_name!());
+
+    let first_stacker_nonce = 0;
+    let second_stacker_nonce = 0;
+    let first_stacker_key = &keys[0];
+    let second_stacker_key = &keys[1];
+    let min_ustx = get_stacking_minimum(&mut peer, &latest_block);
+
+    let pox_addr = make_pox_addr(
+        AddressHashMode::SerializeP2WSH,
+        key_to_stacks_addr(first_stacker_key).bytes,
+    );
+    let signer_key_val = Value::buff_from(vec![
+        0x03, 0xa0, 0xf9, 0x81, 0x8e, 0xa8, 0xc1, 0x4a, 0x82, 0x7b, 0xb1, 0x44, 0xae, 0xc9, 0xcf,
+        0xba, 0xeb, 0xa2, 0x25, 0xaf, 0x22, 0xbe, 0x18, 0xed, 0x78, 0xa2, 0xf2, 0x98, 0x10, 0x6f,
+        0x4e, 0x28, 0x1b,
+    ])
+    .unwrap();
+    let txs = vec![
+        make_pox_4_contract_call(
+            first_stacker_key,
+            first_stacker_nonce,
+            "stack-stx",
+            vec![
+                Value::UInt(min_ustx),
+                pox_addr.clone(),
+                Value::UInt(block_height as u128),
+                Value::UInt(2),
+                signer_key_val.clone(),
+            ],
+        ),
+        make_pox_4_contract_call(
+            second_stacker_key,
+            second_stacker_nonce,
+            "stack-stx",
+            vec![
+                Value::UInt(min_ustx),
+                pox_addr,
+                Value::UInt(block_height as u128),
+                Value::UInt(2),
+                signer_key_val.clone(),
+            ],
+        ),
+    ];
+
+    let latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
+    let first_stacking_state = get_stacking_state_pox_4(
+        &mut peer,
+        &latest_block,
+        &key_to_stacks_addr(first_stacker_key).to_account_principal(),
+    )
+    .expect("No stacking state, stack-stx failed")
+    .expect_tuple();
+
+    let state_signer_key = first_stacking_state.get("signer-key").unwrap();
+    assert_eq!(state_signer_key.to_string(), signer_key_val.to_string());
+    assert!(
+        get_stacking_state_pox_4(
+            &mut peer,
+            &latest_block,
+            &key_to_stacks_addr(second_stacker_key).to_account_principal(),
+        )
+        .is_none(),
+        "second stacking state should have been none"
+    );
+}
+
 #[test]
 fn stack_extend_signer_key() {
     let lock_period = 2;

From aaeb43e0b73e5ffbc7a6da039fab10f6e5db58bb Mon Sep 17 00:00:00 2001
From: MarvinJanssen <MarvinJanssen@users.noreply.github.com>
Date: Fri, 29 Dec 2023 21:39:28 +0100
Subject: [PATCH 0262/1166] address @jcnelson feedback

---
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 60 +++++++++++++------
 .../src/tests/nakamoto_integrations.rs        |  9 ++-
 2 files changed, 49 insertions(+), 20 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 05ecf21c49..3fd4ee1736 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -63,7 +63,7 @@ use crate::chainstate::stacks::boot::{
 use crate::chainstate::stacks::db::{
     MinerPaymentSchedule, StacksChainState, StacksHeaderInfo, MINER_REWARD_MATURITY,
 };
-use crate::chainstate::stacks::events::TransactionOrigin;
+use crate::chainstate::stacks::events::{StacksTransactionReceipt, TransactionOrigin};
 use crate::chainstate::stacks::index::marf::MarfConnection;
 use crate::chainstate::stacks::index::MarfTrieId;
 use crate::chainstate::stacks::tests::make_coinbase;
@@ -78,6 +78,8 @@ use crate::util_lib::db::{DBConn, FromRow};
 
 const USTX_PER_HOLDER: u128 = 1_000_000;
 
+const ERR_REUSED_SIGNER_KEY: i128 = 33;
+
 /// Return the BlockSnapshot for the latest sortition in the provided
 ///  SortitionDB option-reference. Panics on any errors.
 fn get_tip(sortdb: Option<&SortitionDB>) -> BlockSnapshot {
@@ -1255,7 +1257,7 @@ fn balances_from_keys(
 fn stack_stx_signer_key() {
     let lock_period = 2;
     let (burnchain, mut peer, keys, latest_block, block_height, mut coinbase_nonce) =
-        prepare_pox4_test(function_name!());
+        prepare_pox4_test(function_name!(), None);
 
     let stacker_nonce = 0;
     let stacker_key = &keys[0];
@@ -1305,13 +1307,15 @@ fn stack_stx_signer_key() {
 #[test]
 fn stack_stx_signer_key_no_reuse() {
     let lock_period = 2;
+    let observer = TestEventObserver::new();
     let (burnchain, mut peer, keys, latest_block, block_height, mut coinbase_nonce) =
-        prepare_pox4_test(function_name!());
+        prepare_pox4_test(function_name!(), Some(&observer));
 
     let first_stacker_nonce = 0;
     let second_stacker_nonce = 0;
     let first_stacker_key = &keys[0];
     let second_stacker_key = &keys[1];
+    let second_stacker_address = key_to_stacks_addr(second_stacker_key);
     let min_ustx = get_stacking_minimum(&mut peer, &latest_block);
 
     let pox_addr = make_pox_addr(
@@ -1343,7 +1347,7 @@ fn stack_stx_signer_key_no_reuse() {
             "stack-stx",
             vec![
                 Value::UInt(min_ustx),
-                pox_addr,
+                pox_addr.clone(),
                 Value::UInt(block_height as u128),
                 Value::UInt(2),
                 signer_key_val.clone(),
@@ -1360,24 +1364,24 @@ fn stack_stx_signer_key_no_reuse() {
     .expect("No stacking state, stack-stx failed")
     .expect_tuple();
 
-    let state_signer_key = first_stacking_state.get("signer-key").unwrap();
-    assert_eq!(state_signer_key.to_string(), signer_key_val.to_string());
-    assert!(
-        get_stacking_state_pox_4(
-            &mut peer,
-            &latest_block,
-            &key_to_stacks_addr(second_stacker_key).to_account_principal(),
-        )
-        .is_none(),
-        "second stacking state should have been none"
-    );
+    let second_stacker_transactions =
+        get_last_block_sender_transactions(&observer, second_stacker_address);
+
+    assert_eq!(second_stacker_transactions.len(), 1);
+    assert_eq!(
+        second_stacker_transactions
+            .get(0)
+            .expect("Stacker should have one transaction")
+            .result,
+        Value::error(Value::Int(ERR_REUSED_SIGNER_KEY)).unwrap()
+    )
 }
 
 #[test]
 fn stack_extend_signer_key() {
     let lock_period = 2;
     let (burnchain, mut peer, keys, latest_block, block_height, mut coinbase_nonce) =
-        prepare_pox4_test(function_name!());
+        prepare_pox4_test(function_name!(), None);
 
     let mut stacker_nonce = 0;
     let stacker_key = &keys[0];
@@ -1459,7 +1463,7 @@ fn stack_extend_signer_key() {
 fn delegate_stack_stx_signer_key() {
     let lock_period = 2;
     let (burnchain, mut peer, keys, latest_block, block_height, mut coinbase_nonce) =
-        prepare_pox4_test(function_name!());
+        prepare_pox4_test(function_name!(), None);
 
     let stacker_nonce = 0;
     let stacker_key = &keys[0];
@@ -1589,6 +1593,7 @@ pub fn get_stacking_minimum(peer: &mut TestPeer, latest_block: &StacksBlockId) -
 
 pub fn prepare_pox4_test<'a>(
     test_name: &str,
+    observer: Option<&'a TestEventObserver>,
 ) -> (
     Burnchain,
     TestPeer<'a>,
@@ -1606,7 +1611,7 @@ pub fn prepare_pox4_test<'a>(
     burnchain.pox_constants = pox_constants.clone();
 
     let (mut peer, keys) =
-        instantiate_pox_peer_with_epoch(&burnchain, test_name, Some(epochs.clone()), None);
+        instantiate_pox_peer_with_epoch(&burnchain, test_name, Some(epochs.clone()), observer);
 
     assert_eq!(burnchain.pox_constants.reward_slots(), 6);
     let mut coinbase_nonce = 0;
@@ -1635,3 +1640,22 @@ pub fn prepare_pox4_test<'a>(
         coinbase_nonce,
     )
 }
+pub fn get_last_block_sender_transactions(
+    observer: &TestEventObserver,
+    address: StacksAddress,
+) -> Vec<StacksTransactionReceipt> {
+    observer
+        .get_blocks()
+        .last()
+        .unwrap()
+        .clone()
+        .receipts
+        .into_iter()
+        .filter(|receipt| {
+            if let TransactionOrigin::Stacks(ref transaction) = receipt.transaction {
+                return transaction.auth.origin().address_testnet() == address;
+            }
+            false
+        })
+        .collect::<Vec<_>>()
+}
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index f8250f58cb..9825bc4495 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -33,7 +33,7 @@ use stacks::core::{
 };
 use stacks_common::address::AddressHashMode;
 use stacks_common::consts::STACKS_EPOCH_MAX;
-use stacks_common::types::chainstate::StacksAddress;
+use stacks_common::types::chainstate::{StacksAddress, StacksPublicKey};
 use stacks_common::util::hash::to_hex;
 use stacks_common::util::secp256k1::Secp256k1PrivateKey;
 
@@ -303,6 +303,7 @@ fn boot_to_epoch_3(
     naka_conf: &Config,
     blocks_processed: &RunLoopCounter,
     stacker_sk: Secp256k1PrivateKey,
+    signer_pk: StacksPublicKey,
     btc_regtest_controller: &mut BitcoinRegtestController,
 ) {
     let epochs = naka_conf.burnchain.epochs.clone().unwrap();
@@ -337,7 +338,7 @@ fn boot_to_epoch_3(
             pox_addr_tuple,
             clarity::vm::Value::UInt(205),
             clarity::vm::Value::UInt(12),
-            clarity::vm::Value::buff_from(vec![0; 33]).unwrap(), // TODO: replace once signer key calculation is implemented
+            clarity::vm::Value::buff_from(signer_pk.to_bytes_compressed()).unwrap(),
         ],
     );
 
@@ -373,6 +374,7 @@ fn simple_neon_integration() {
     let sender_sk = Secp256k1PrivateKey::new();
     // setup sender + recipient for a test stx transfer
     let sender_addr = tests::to_addr(&sender_sk);
+    let sender_signer_key = StacksPublicKey::new();
     let send_amt = 1000;
     let send_fee = 100;
     naka_conf.add_initial_balance(
@@ -413,6 +415,7 @@ fn simple_neon_integration() {
         &naka_conf,
         &blocks_processed,
         stacker_sk,
+        sender_signer_key,
         &mut btc_regtest_controller,
     );
 
@@ -553,6 +556,7 @@ fn mine_multiple_per_tenure_integration() {
     let http_origin = format!("http://{}", &naka_conf.node.rpc_bind);
     naka_conf.miner.wait_on_interim_blocks = Duration::from_secs(1);
     let sender_sk = Secp256k1PrivateKey::new();
+    let sender_signer_key = StacksPublicKey::new();
     let tenure_count = 5;
     let inter_blocks_per_tenure = 9;
     // setup sender + recipient for some test stx transfers
@@ -601,6 +605,7 @@ fn mine_multiple_per_tenure_integration() {
         &naka_conf,
         &blocks_processed,
         stacker_sk,
+        sender_signer_key,
         &mut btc_regtest_controller,
     );
 

From 8e9cf99dda421ba7d51627db2c81a2d4e1889bcf Mon Sep 17 00:00:00 2001
From: MarvinJanssen <MarvinJanssen@users.noreply.github.com>
Date: Fri, 29 Dec 2023 22:16:38 +0100
Subject: [PATCH 0263/1166] fix: mockamoto pox4 contract call signer key

---
 testnet/stacks-node/src/mockamoto.rs | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index e9ffe0ed6f..d924b4a712 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -832,6 +832,9 @@ impl MockamotoNode {
             Some(AddressHashMode::SerializeP2PKH),
         );
 
+        let mut signer_key = miner_nonce.to_be_bytes().to_vec();
+        signer_key.resize(33, 0);
+
         let stack_stx_payload = if parent_chain_length < 2 {
             TransactionPayload::ContractCall(TransactionContractCall {
                 address: StacksAddress::burn_address(false),
@@ -842,6 +845,7 @@ impl MockamotoNode {
                     pox_address.as_clarity_tuple().unwrap().into(),
                     ClarityValue::UInt(u128::from(parent_burn_height)),
                     ClarityValue::UInt(12),
+                    ClarityValue::buff_from(signer_key).unwrap(),
                 ],
             })
         } else {
@@ -854,6 +858,7 @@ impl MockamotoNode {
                 function_args: vec![
                     ClarityValue::UInt(5),
                     pox_address.as_clarity_tuple().unwrap().into(),
+                    ClarityValue::buff_from(signer_key).unwrap(),
                 ],
             })
         };

From 816d69cd021719a1ee9c214d5f392f2eff88c01e Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Mon, 1 Jan 2024 13:17:55 -0500
Subject: [PATCH 0264/1166] fix: minor bug in fee-estimate.py

---
 contrib/side-cars/fee-estimate.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/contrib/side-cars/fee-estimate.py b/contrib/side-cars/fee-estimate.py
index 62dff1579d..17caf0b82f 100644
--- a/contrib/side-cars/fee-estimate.py
+++ b/contrib/side-cars/fee-estimate.py
@@ -139,7 +139,7 @@ def update_config_fee(toml_file_location: str, polling_delay_seconds: int):
         with open(toml_file_location, 'w') as toml_file:
             toml.dump(toml_data, toml_file)
 
-        time.sleep()
+        time.sleep(polling_delay_seconds)
 
 def read_config(config_location: str):
     """

From b6f86693b42cc7a5a38d527628ebd859cdee5608 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Tue, 2 Jan 2024 13:36:32 -0600
Subject: [PATCH 0265/1166] fix: do not panic async task on prometheus bind
 failure, pass prom thread to naka runloop

---
 testnet/stacks-node/src/monitoring/mod.rs     | 19 ++++++++--
 .../stacks-node/src/monitoring/prometheus.rs  | 37 +++++++++++--------
 .../stacks-node/src/run_loop/boot_nakamoto.rs |  4 +-
 testnet/stacks-node/src/run_loop/nakamoto.rs  | 29 ++++++++++-----
 testnet/stacks-node/src/run_loop/neon.rs      | 30 +++++++++------
 .../src/tests/nakamoto_integrations.rs        | 32 ++++++++++++++++
 6 files changed, 109 insertions(+), 42 deletions(-)

diff --git a/testnet/stacks-node/src/monitoring/mod.rs b/testnet/stacks-node/src/monitoring/mod.rs
index 165937b4a3..4c254681e8 100644
--- a/testnet/stacks-node/src/monitoring/mod.rs
+++ b/testnet/stacks-node/src/monitoring/mod.rs
@@ -5,8 +5,19 @@ pub use stacks::monitoring::{increment_errors_emitted_counter, increment_warning
 #[cfg(feature = "monitoring_prom")]
 mod prometheus;
 
-pub fn start_serving_monitoring_metrics(bind_address: String) {
-    info!("Start serving prometheus metrics");
-    #[cfg(feature = "monitoring_prom")]
-    prometheus::start_serving_prometheus_metrics(bind_address);
+#[derive(Debug)]
+pub enum MonitoringError {
+    AlreadyBound,
+    UnableToGetAddress,
+}
+
+#[cfg(feature = "monitoring_prom")]
+pub fn start_serving_monitoring_metrics(bind_address: String) -> Result<(), MonitoringError> {
+    prometheus::start_serving_prometheus_metrics(bind_address)
+}
+
+#[cfg(not(feature = "monitoring_prom"))]
+pub fn start_serving_monitoring_metrics(bind_address: String) -> Result<(), MonitoringError> {
+    warn!("Attempted to start monitoring service at bind_address = {bind_address}, but stacks-node was built without `monitoring_prom` feature.");
+    Ok(())
 }
diff --git a/testnet/stacks-node/src/monitoring/prometheus.rs b/testnet/stacks-node/src/monitoring/prometheus.rs
index 65c427d2bc..e9705142d0 100644
--- a/testnet/stacks-node/src/monitoring/prometheus.rs
+++ b/testnet/stacks-node/src/monitoring/prometheus.rs
@@ -4,20 +4,26 @@ use async_std::task;
 use http_types::{Body, Response, StatusCode};
 use stacks::prometheus::{gather, Encoder, TextEncoder};
 
-pub fn start_serving_prometheus_metrics(bind_address: String) {
-    let addr = bind_address.clone();
+use super::MonitoringError;
 
-    async_std::task::block_on(async {
-        let listener = TcpListener::bind(addr)
+pub fn start_serving_prometheus_metrics(bind_address: String) -> Result<(), MonitoringError> {
+    task::block_on(async {
+        let listener = TcpListener::bind(bind_address)
             .await
-            .expect("Prometheus monitoring: unable to bind address");
-        let addr = format!(
-            "http://{}",
-            listener
+            .map_err(|_| {
+                warn!("Prometheus monitoring: unable to bind address, will not spawn prometheus endpoint service.");
+                MonitoringError::AlreadyBound
+            })?;
+        let local_addr = listener
                 .local_addr()
-                .expect("Prometheus monitoring: unable to get addr")
+                .map_err(|_| {
+                    warn!("Prometheus monitoring: unable to get local bind address, will not spawn prometheus endpoint service.");
+                    MonitoringError::UnableToGetAddress
+                })?;
+        info!(
+            "Prometheus monitoring: server listening on http://{}",
+            local_addr
         );
-        info!("Prometheus monitoring: server listening on {}", addr);
 
         let mut incoming = listener.incoming();
         while let Some(stream) = incoming.next().await {
@@ -25,21 +31,20 @@ pub fn start_serving_prometheus_metrics(bind_address: String) {
                 Ok(stream) => stream,
                 Err(err) => {
                     error!(
-                        "Prometheus monitoring: unable to open socket and serve metrics - {:?}",
-                        err
+                        "Prometheus monitoring: unable to open socket and serve metrics - {err:?}",
                     );
                     continue;
                 }
             };
-            let addr = addr.clone();
-
             task::spawn(async {
                 if let Err(err) = accept(stream).await {
-                    eprintln!("{}", err);
+                    error!("{err}");
                 }
             });
         }
-    });
+
+        Ok::<_, MonitoringError>(())
+    })
 }
 
 async fn accept(stream: TcpStream) -> http_types::Result<()> {
diff --git a/testnet/stacks-node/src/run_loop/boot_nakamoto.rs b/testnet/stacks-node/src/run_loop/boot_nakamoto.rs
index e70784ce42..4485a4cace 100644
--- a/testnet/stacks-node/src/run_loop/boot_nakamoto.rs
+++ b/testnet/stacks-node/src/run_loop/boot_nakamoto.rs
@@ -54,7 +54,7 @@ impl BootRunLoop {
                 InnerLoops::Epoch2(neon),
             )
         } else {
-            let naka = NakaRunLoop::new(config.clone(), None, None);
+            let naka = NakaRunLoop::new(config.clone(), None, None, None);
             (
                 naka.get_coordinator_channel().unwrap(),
                 InnerLoops::Epoch3(naka),
@@ -122,6 +122,7 @@ impl BootRunLoop {
             .expect("FATAL: failed to spawn epoch-2/3-boot thread");
         neon_loop.start(burnchain_opt.clone(), mine_start);
 
+        let monitoring_thread = neon_loop.take_monitoring_thread();
         // did we exit because of the epoch-3.0 transition, or some other reason?
         let exited_for_transition = boot_thread
             .join()
@@ -136,6 +137,7 @@ impl BootRunLoop {
             self.config.clone(),
             Some(termination_switch),
             Some(counters),
+            monitoring_thread,
         );
         let new_coord_channels = naka
             .get_coordinator_channel()
diff --git a/testnet/stacks-node/src/run_loop/nakamoto.rs b/testnet/stacks-node/src/run_loop/nakamoto.rs
index 945e9fece0..d5e57646a0 100644
--- a/testnet/stacks-node/src/run_loop/nakamoto.rs
+++ b/testnet/stacks-node/src/run_loop/nakamoto.rs
@@ -37,7 +37,7 @@ use stx_genesis::GenesisData;
 
 use crate::burnchains::make_bitcoin_indexer;
 use crate::globals::Globals as GenericGlobals;
-use crate::monitoring::start_serving_monitoring_metrics;
+use crate::monitoring::{start_serving_monitoring_metrics, MonitoringError};
 use crate::nakamoto_node::{self, StacksNode, BLOCK_PROCESSOR_STACK_SIZE, RELAYER_MAX_BUFFER};
 use crate::node::{
     get_account_balances, get_account_lockups, get_names, get_namespaces,
@@ -69,6 +69,7 @@ pub struct RunLoop {
     /// NOTE: this is duplicated in self.globals, but it needs to be accessible before globals is
     /// instantiated (namely, so the test framework can access it).
     miner_status: Arc<Mutex<MinerStatus>>,
+    monitoring_thread: Option<JoinHandle<Result<(), MonitoringError>>>,
 }
 
 impl RunLoop {
@@ -77,6 +78,7 @@ impl RunLoop {
         config: Config,
         should_keep_running: Option<Arc<AtomicBool>>,
         counters: Option<Counters>,
+        monitoring_thread: Option<JoinHandle<Result<(), MonitoringError>>>,
     ) -> Self {
         let channels = CoordinatorCommunication::instantiate();
         let should_keep_running =
@@ -103,6 +105,7 @@ impl RunLoop {
             burnchain: None,
             pox_watchdog_comms,
             miner_status,
+            monitoring_thread,
         }
     }
 
@@ -333,16 +336,22 @@ impl RunLoop {
 
     /// Start Prometheus logging
     fn start_prometheus(&mut self) {
-        let prometheus_bind = self.config.node.prometheus_bind.clone();
-        if let Some(prometheus_bind) = prometheus_bind {
-            thread::Builder::new()
-                .name("prometheus".to_string())
-                .spawn(move || {
-                    debug!("prometheus thread ID is {:?}", thread::current().id());
-                    start_serving_monitoring_metrics(prometheus_bind);
-                })
-                .unwrap();
+        if self.monitoring_thread.is_some() {
+            info!("Monitoring thread already running, nakamoto run-loop will not restart it");
+            return;
         }
+        let Some(prometheus_bind) = self.config.node.prometheus_bind.clone() else {
+            return;
+        };
+        let monitoring_thread = thread::Builder::new()
+            .name("prometheus".to_string())
+            .spawn(move || {
+                debug!("prometheus thread ID is {:?}", thread::current().id());
+                start_serving_monitoring_metrics(prometheus_bind)
+            })
+            .expect("FATAL: failed to start monitoring thread");
+
+        self.monitoring_thread.replace(monitoring_thread);
     }
 
     /// Get the sortition DB's highest block height, aligned to a reward cycle boundary, and the
diff --git a/testnet/stacks-node/src/run_loop/neon.rs b/testnet/stacks-node/src/run_loop/neon.rs
index f04874110b..f86c2b48ff 100644
--- a/testnet/stacks-node/src/run_loop/neon.rs
+++ b/testnet/stacks-node/src/run_loop/neon.rs
@@ -33,7 +33,7 @@ use stx_genesis::GenesisData;
 use super::RunLoopCallbacks;
 use crate::burnchains::make_bitcoin_indexer;
 use crate::globals::NeonGlobals as Globals;
-use crate::monitoring::start_serving_monitoring_metrics;
+use crate::monitoring::{start_serving_monitoring_metrics, MonitoringError};
 use crate::neon_node::{StacksNode, BLOCK_PROCESSOR_STACK_SIZE, RELAYER_MAX_BUFFER};
 use crate::node::{
     get_account_balances, get_account_lockups, get_names, get_namespaces,
@@ -176,6 +176,7 @@ pub struct RunLoop {
     /// NOTE: this is duplicated in self.globals, but it needs to be accessible before globals is
     /// instantiated (namely, so the test framework can access it).
     miner_status: Arc<Mutex<MinerStatus>>,
+    monitoring_thread: Option<JoinHandle<Result<(), MonitoringError>>>,
 }
 
 /// Write to stderr in an async-safe manner.
@@ -224,6 +225,7 @@ impl RunLoop {
             burnchain: None,
             pox_watchdog_comms,
             miner_status,
+            monitoring_thread: None,
         }
     }
 
@@ -614,16 +616,22 @@ impl RunLoop {
 
     /// Start Prometheus logging
     fn start_prometheus(&mut self) {
-        let prometheus_bind = self.config.node.prometheus_bind.clone();
-        if let Some(prometheus_bind) = prometheus_bind {
-            thread::Builder::new()
-                .name("prometheus".to_string())
-                .spawn(move || {
-                    debug!("prometheus thread ID is {:?}", thread::current().id());
-                    start_serving_monitoring_metrics(prometheus_bind);
-                })
-                .unwrap();
-        }
+        let Some(prometheus_bind) = self.config.node.prometheus_bind.clone() else {
+            return;
+        };
+        let monitoring_thread = thread::Builder::new()
+            .name("prometheus".to_string())
+            .spawn(move || {
+                debug!("prometheus thread ID is {:?}", thread::current().id());
+                start_serving_monitoring_metrics(prometheus_bind)
+            })
+            .expect("FATAL: failed to start monitoring thread");
+
+        self.monitoring_thread.replace(monitoring_thread);
+    }
+
+    pub fn take_monitoring_thread(&mut self) -> Option<JoinHandle<Result<(), MonitoringError>>> {
+        self.monitoring_thread.take()
     }
 
     /// Get the sortition DB's highest block height, aligned to a reward cycle boundary, and the
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 9825bc4495..ca464cb106 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -370,6 +370,8 @@ fn simple_neon_integration() {
     }
 
     let (mut naka_conf, _miner_account) = naka_neon_integration_conf(None);
+    let prom_bind = format!("{}:{}", "127.0.0.1", 6000);
+    naka_conf.node.prometheus_bind = Some(prom_bind.clone());
     naka_conf.miner.wait_on_interim_blocks = Duration::from_secs(1000);
     let sender_sk = Secp256k1PrivateKey::new();
     // setup sender + recipient for a test stx transfer
@@ -437,6 +439,21 @@ fn simple_neon_integration() {
             .unwrap()
             .stacks_block_height;
 
+    // query for prometheus metrics
+    #[cfg(feature = "monitoring_prom")]
+    {
+        let prom_http_origin = format!("http://{}", prom_bind);
+        let client = reqwest::blocking::Client::new();
+        let res = client
+            .get(&prom_http_origin)
+            .send()
+            .unwrap()
+            .text()
+            .unwrap();
+        let expected_result = format!("stacks_node_stacks_tip_height {block_height_pre_3_0}");
+        assert!(res.contains(&expected_result));
+    }
+
     info!("Nakamoto miner started...");
     // first block wakes up the run loop, wait until a key registration has been submitted.
     next_block_and(&mut btc_regtest_controller, 60, || {
@@ -529,6 +546,21 @@ fn simple_neon_integration() {
     assert!(tip.anchored_header.as_stacks_nakamoto().is_some());
     assert!(tip.stacks_block_height >= block_height_pre_3_0 + 30);
 
+    // make sure prometheus returns an updated height
+    #[cfg(feature = "monitoring_prom")]
+    {
+        let prom_http_origin = format!("http://{}", prom_bind);
+        let client = reqwest::blocking::Client::new();
+        let res = client
+            .get(&prom_http_origin)
+            .send()
+            .unwrap()
+            .text()
+            .unwrap();
+        let expected_result = format!("stacks_node_stacks_tip_height {}", tip.stacks_block_height);
+        assert!(res.contains(&expected_result));
+    }
+
     coord_channel
         .lock()
         .expect("Mutex poisoned")

From 2d7f9edcd19e7130c321048c925c7eaec4bea96c Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Tue, 2 Jan 2024 15:21:02 -0500
Subject: [PATCH 0266/1166] chore: set confidence parameter to 0.9 for
 bitcoiner.live API

---
 contrib/side-cars/fee-estimate.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/contrib/side-cars/fee-estimate.py b/contrib/side-cars/fee-estimate.py
index 17caf0b82f..478ab5be3b 100644
--- a/contrib/side-cars/fee-estimate.py
+++ b/contrib/side-cars/fee-estimate.py
@@ -23,7 +23,7 @@
 FEE_ESTIMATIONS = [
     # Bitcoiner Live API
     (
-        'https://bitcoiner.live/api/fees/estimates/latest',
+        'https://bitcoiner.live/api/fees/estimates/latest?confidence=0.9',
         lambda response_json: response_json["estimates"]["30"]["sat_per_vbyte"],
     ),
 

From 20188c8052c08b777cac78a9b31bd88a2aa04673 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Sat, 23 Dec 2023 15:53:14 -0600
Subject: [PATCH 0267/1166] fix: nakamoto-node to use
 get_nakamoto_next_recipients

---
 stackslib/src/chainstate/coordinator/mod.rs   | 193 ++++++++--------
 .../chainstate/nakamoto/coordinator/mod.rs    |  21 +-
 stackslib/src/chainstate/nakamoto/mod.rs      |   2 +-
 stackslib/src/net/p2p.rs                      |  16 +-
 .../stacks-node/src/nakamoto_node/relayer.rs  |  23 +-
 testnet/stacks-node/src/tests/epoch_21.rs     |  14 +-
 testnet/stacks-node/src/tests/epoch_24.rs     |   4 +-
 .../src/tests/nakamoto_integrations.rs        | 210 +++++++++++++++++-
 .../src/tests/neon_integrations.rs            |  17 +-
 9 files changed, 350 insertions(+), 150 deletions(-)

diff --git a/stackslib/src/chainstate/coordinator/mod.rs b/stackslib/src/chainstate/coordinator/mod.rs
index 0e813d1e71..e045f0d3ed 100644
--- a/stackslib/src/chainstate/coordinator/mod.rs
+++ b/stackslib/src/chainstate/coordinator/mod.rs
@@ -248,6 +248,7 @@ pub enum Error {
     NotInPreparePhase,
     RewardSetAlreadyProcessed,
     PoXAnchorBlockRequired,
+    PoXNotProcessedYet,
 }
 
 impl From<BurnchainError> for Error {
@@ -675,124 +676,112 @@ pub fn get_reward_cycle_info<U: RewardSetProvider>(
     let epoch_at_height = SortitionDB::get_stacks_epoch(sort_db.conn(), burn_height)?.expect(
         &format!("FATAL: no epoch defined for burn height {}", burn_height),
     );
-    let reward_cycle_info = if burnchain.is_reward_cycle_start(burn_height) {
-        let reward_cycle = burnchain
-            .block_height_to_reward_cycle(burn_height)
-            .expect("FATAL: no reward cycle for burn height");
+    if !burnchain.is_reward_cycle_start(burn_height) {
+        return Ok(None);
+    }
 
-        if burnchain
-            .pox_constants
-            .is_after_pox_sunset_end(burn_height, epoch_at_height.epoch_id)
-        {
-            return Ok(Some(RewardCycleInfo {
-                reward_cycle,
-                anchor_status: PoxAnchorBlockStatus::NotSelected,
-            }));
-        }
+    let reward_cycle = burnchain
+        .block_height_to_reward_cycle(burn_height)
+        .expect("FATAL: no reward cycle for burn height");
 
-        debug!("Beginning reward cycle";
-              "burn_height" => burn_height,
-              "reward_cycle" => reward_cycle,
-              "reward_cycle_length" => burnchain.pox_constants.reward_cycle_length,
-              "prepare_phase_length" => burnchain.pox_constants.prepare_length);
+    if burnchain
+        .pox_constants
+        .is_after_pox_sunset_end(burn_height, epoch_at_height.epoch_id)
+    {
+        return Ok(Some(RewardCycleInfo {
+            reward_cycle,
+            anchor_status: PoxAnchorBlockStatus::NotSelected,
+        }));
+    }
 
-        let reward_cycle_info = {
-            let ic = sort_db.index_handle(sortition_tip);
-            let burnchain_db_conn_opt = if epoch_at_height.epoch_id >= StacksEpochId::Epoch21
-                || always_use_affirmation_maps
-            {
+    debug!("Beginning reward cycle";
+           "burn_height" => burn_height,
+           "reward_cycle" => reward_cycle,
+           "reward_cycle_length" => burnchain.pox_constants.reward_cycle_length,
+           "prepare_phase_length" => burnchain.pox_constants.prepare_length);
+
+    let reward_cycle_info = {
+        let ic = sort_db.index_handle(sortition_tip);
+        let burnchain_db_conn_opt =
+            if epoch_at_height.epoch_id >= StacksEpochId::Epoch21 || always_use_affirmation_maps {
                 // use the new block-commit-based PoX anchor block selection rules
                 Some(burnchain_db.conn())
             } else {
                 None
             };
 
-            ic.get_chosen_pox_anchor(burnchain_db_conn_opt, &parent_bhh, &burnchain.pox_constants)
-        }?;
-        if let Some((consensus_hash, stacks_block_hash, txid)) = reward_cycle_info {
-            debug!(
-                "Chosen PoX anchor is {}/{} txid {} for reward cycle starting {} at burn height {}",
-                &consensus_hash, &stacks_block_hash, &txid, reward_cycle, burn_height
-            );
-            info!(
-                "Anchor block selected for cycle {}: {}/{} (txid {})",
-                reward_cycle, &consensus_hash, &stacks_block_hash, &txid
-            );
-
-            let anchor_block_known = StacksChainState::is_stacks_block_processed(
-                &chain_state.db(),
-                &consensus_hash,
-                &stacks_block_hash,
-            )?;
-            let anchor_status = if anchor_block_known {
-                let block_id = StacksBlockId::new(&consensus_hash, &stacks_block_hash);
-                let reward_set = provider.get_reward_set(
-                    burn_height,
-                    chain_state,
-                    burnchain,
-                    sort_db,
-                    &block_id,
-                )?;
-                debug!(
-                    "Stacks anchor block {}/{} cycle {} txid {} is processed",
-                    &consensus_hash, &stacks_block_hash, reward_cycle, &txid
-                );
-                PoxAnchorBlockStatus::SelectedAndKnown(stacks_block_hash, txid, reward_set)
-            } else {
-                debug!(
-                    "Stacks anchor block {}/{} cycle {} txid {} is NOT processed",
-                    &consensus_hash, &stacks_block_hash, reward_cycle, &txid
-                );
-                PoxAnchorBlockStatus::SelectedAndUnknown(stacks_block_hash, txid)
-            };
-            Ok(Some(RewardCycleInfo {
-                reward_cycle,
-                anchor_status,
-            }))
+        ic.get_chosen_pox_anchor(burnchain_db_conn_opt, &parent_bhh, &burnchain.pox_constants)
+    }?;
+    let reward_cycle_info = if let Some((consensus_hash, stacks_block_hash, txid)) =
+        reward_cycle_info
+    {
+        let anchor_block_known = StacksChainState::is_stacks_block_processed(
+            &chain_state.db(),
+            &consensus_hash,
+            &stacks_block_hash,
+        )?;
+        info!(
+            "PoX Anchor block selected";
+            "cycle" => reward_cycle,
+            "consensus_hash" => %consensus_hash,
+            "block_hash" => %stacks_block_hash,
+            "block_id" => %StacksBlockId::new(&consensus_hash, &stacks_block_hash),
+            "is_known" => anchor_block_known,
+            "commit_txid" => %txid,
+            "cycle_burn_height" => burn_height
+        );
+        let anchor_status = if anchor_block_known {
+            let block_id = StacksBlockId::new(&consensus_hash, &stacks_block_hash);
+            let reward_set =
+                provider.get_reward_set(burn_height, chain_state, burnchain, sort_db, &block_id)?;
+            PoxAnchorBlockStatus::SelectedAndKnown(stacks_block_hash, txid, reward_set)
         } else {
-            debug!(
-                "PoX anchor block NOT chosen for reward cycle {} at burn height {}",
-                reward_cycle, burn_height
-            );
-            Ok(Some(RewardCycleInfo {
-                reward_cycle,
-                anchor_status: PoxAnchorBlockStatus::NotSelected,
-            }))
+            PoxAnchorBlockStatus::SelectedAndUnknown(stacks_block_hash, txid)
+        };
+        RewardCycleInfo {
+            reward_cycle,
+            anchor_status,
         }
     } else {
-        Ok(None)
+        info!(
+            "PoX anchor block NOT chosen for reward cycle {} at burn height {}",
+            reward_cycle, burn_height
+        );
+        RewardCycleInfo {
+            reward_cycle,
+            anchor_status: PoxAnchorBlockStatus::NotSelected,
+        }
     };
 
-    if let Ok(Some(reward_cycle_info)) = reward_cycle_info.as_ref() {
-        // cache the reward cycle info as of the first sortition in the prepare phase, so that
-        // the Nakamoto epoch can go find it later
-        let ic = sort_db.index_handle(sortition_tip);
-        let prev_reward_cycle = burnchain
-            .block_height_to_reward_cycle(burn_height)
-            .expect("FATAL: no reward cycle for burn height");
-
-        if prev_reward_cycle > 1 {
-            let prepare_phase_start = burnchain
-                .pox_constants
-                .prepare_phase_start(burnchain.first_block_height, prev_reward_cycle - 1);
-            let first_prepare_sn =
-                SortitionDB::get_ancestor_snapshot(&ic, prepare_phase_start, sortition_tip)?
-                    .expect("FATAL: no start-of-prepare-phase sortition");
-
-            let mut tx = sort_db.tx_begin()?;
-            if SortitionDB::get_preprocessed_reward_set(&mut tx, &first_prepare_sn.sortition_id)?
-                .is_none()
-            {
-                SortitionDB::store_preprocessed_reward_set(
-                    &mut tx,
-                    &first_prepare_sn.sortition_id,
-                    &reward_cycle_info,
-                )?;
-            }
-            tx.commit()?;
+    // cache the reward cycle info as of the first sortition in the prepare phase, so that
+    // the Nakamoto epoch can go find it later
+    let ic = sort_db.index_handle(sortition_tip);
+    let prev_reward_cycle = burnchain
+        .block_height_to_reward_cycle(burn_height)
+        .expect("FATAL: no reward cycle for burn height");
+
+    if prev_reward_cycle > 1 {
+        let prepare_phase_start = burnchain
+            .pox_constants
+            .prepare_phase_start(burnchain.first_block_height, prev_reward_cycle - 1);
+        let first_prepare_sn =
+            SortitionDB::get_ancestor_snapshot(&ic, prepare_phase_start, sortition_tip)?
+                .expect("FATAL: no start-of-prepare-phase sortition");
+
+        let mut tx = sort_db.tx_begin()?;
+        if SortitionDB::get_preprocessed_reward_set(&mut tx, &first_prepare_sn.sortition_id)?
+            .is_none()
+        {
+            SortitionDB::store_preprocessed_reward_set(
+                &mut tx,
+                &first_prepare_sn.sortition_id,
+                &reward_cycle_info,
+            )?;
         }
+        tx.commit()?;
     }
-    reward_cycle_info
+
+    Ok(Some(reward_cycle_info))
 }
 
 /// PoX payout event to be sent to connected event observers
diff --git a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
index 6dde267bc2..a59bb8e038 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
@@ -343,14 +343,21 @@ pub fn get_nakamoto_next_recipients(
         debug!("Get pre-processed reward set";
                "sortition_id" => %first_sn.sortition_id);
 
-        // NOTE: if we don't panic here, we'll panic later in a more obscure way
-        Some(
+        // NOTE: don't panic here. The only caller of this method is a stacks-node miner,
+        //  and they *may* have invoked this before they've processed the prepare phase.
+        //  That's recoverable by simply waiting to mine until they've processed those
+        //   blocks.
+        let reward_set =
             SortitionDB::get_preprocessed_reward_set(sort_db.conn(), &first_sn.sortition_id)?
-                .expect(&format!(
-                    "No reward set for start of reward cycle beginning with block {}",
-                    &sortition_tip.block_height
-                )),
-        )
+                .ok_or_else(|| {
+                    warn!(
+                        "No preprocessed reward set found";
+                        "reward_cycle_start" => sortition_tip.block_height + 1,
+                        "first_prepare_sortition_id" => %first_sn.sortition_id
+                    );
+                    Error::PoXNotProcessedYet
+                })?;
+        Some(reward_set)
     } else {
         None
     };
diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index 16525cd806..3af4293a22 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -2382,7 +2382,7 @@ impl NakamotoChainState {
         pox_constants: &PoxConstants,
         parent_consensus_hash: ConsensusHash,
         parent_header_hash: BlockHeaderHash,
-        parent_stacks_height: u64,
+        _parent_stacks_height: u64,
         parent_burn_height: u32,
         burn_header_hash: BurnchainHeaderHash,
         burn_header_height: u32,
diff --git a/stackslib/src/net/p2p.rs b/stackslib/src/net/p2p.rs
index 01a4efb899..3bc52fb4b3 100644
--- a/stackslib/src/net/p2p.rs
+++ b/stackslib/src/net/p2p.rs
@@ -2694,10 +2694,18 @@ impl PeerNetwork {
                 }
             }
             Err(e) => {
-                warn!(
-                    "{:?}: failed to learn public IP: {:?}",
-                    &self.local_peer, &e
-                );
+                if !self
+                    .local_peer
+                    .addrbytes
+                    .to_socketaddr(80)
+                    .ip()
+                    .is_loopback()
+                {
+                    warn!(
+                        "{:?}: failed to learn public IP: {:?}",
+                        &self.local_peer, &e
+                    );
+                }
                 self.public_ip_reset();
                 return true;
             }
diff --git a/testnet/stacks-node/src/nakamoto_node/relayer.rs b/testnet/stacks-node/src/nakamoto_node/relayer.rs
index cf1e71ede2..1fb8462648 100644
--- a/testnet/stacks-node/src/nakamoto_node/relayer.rs
+++ b/testnet/stacks-node/src/nakamoto_node/relayer.rs
@@ -28,7 +28,7 @@ use stacks::chainstate::burn::operations::{
     BlockstackOperationType, LeaderBlockCommitOp, LeaderKeyRegisterOp,
 };
 use stacks::chainstate::burn::{BlockSnapshot, ConsensusHash};
-use stacks::chainstate::coordinator::{get_next_recipients, OnChainRewardSetProvider};
+use stacks::chainstate::nakamoto::coordinator::get_nakamoto_next_recipients;
 use stacks::chainstate::nakamoto::NakamotoChainState;
 use stacks::chainstate::stacks::address::PoxAddress;
 use stacks::chainstate::stacks::db::StacksChainState;
@@ -289,7 +289,7 @@ impl RelayerThread {
         self.last_network_download_passes = net_result.num_download_passes;
         self.last_network_inv_passes = net_result.num_inv_sync_passes;
         if self.has_waited_for_latest_blocks() {
-            info!("Relayer: did a download pass, so unblocking mining");
+            debug!("Relayer: did a download pass, so unblocking mining");
             signal_mining_ready(self.globals.get_miner_status());
         }
     }
@@ -414,18 +414,11 @@ impl RelayerThread {
                 .unwrap_or_else(|| VRFProof::empty());
 
         // let's figure out the recipient set!
-        let recipients = get_next_recipients(
-            &sort_tip,
-            &mut self.chainstate,
-            &mut self.sortdb,
-            &self.burnchain,
-            &OnChainRewardSetProvider(),
-            self.config.node.always_use_affirmation_maps,
-        )
-        .map_err(|e| {
-            error!("Relayer: Failure fetching recipient set: {:?}", e);
-            NakamotoNodeError::SnapshotNotFoundForChainTip
-        })?;
+        let recipients = get_nakamoto_next_recipients(&sort_tip, &mut self.sortdb, &self.burnchain)
+            .map_err(|e| {
+                error!("Relayer: Failure fetching recipient set: {:?}", e);
+                NakamotoNodeError::SnapshotNotFoundForChainTip
+            })?;
 
         let block_header =
             NakamotoChainState::get_block_header_by_consensus_hash(self.chainstate.db(), target_ch)
@@ -834,7 +827,7 @@ impl RelayerThread {
 
     /// Top-level dispatcher
     pub fn handle_directive(&mut self, directive: RelayerDirective) -> bool {
-        info!("Relayer: handling directive"; "directive" => %directive);
+        debug!("Relayer: handling directive"; "directive" => %directive);
         let continue_running = match directive {
             RelayerDirective::HandleNetResult(net_result) => {
                 self.process_network_result(net_result);
diff --git a/testnet/stacks-node/src/tests/epoch_21.rs b/testnet/stacks-node/src/tests/epoch_21.rs
index 4c4a64c5d4..39e0007440 100644
--- a/testnet/stacks-node/src/tests/epoch_21.rs
+++ b/testnet/stacks-node/src/tests/epoch_21.rs
@@ -199,7 +199,7 @@ fn advance_to_2_1(
     // these should all succeed across the epoch 2.1 boundary
     for _i in 0..5 {
         let tip_info = get_chain_info(&conf);
-        let pox_info = get_pox_info(&http_origin);
+        let pox_info = get_pox_info(&http_origin).unwrap();
 
         eprintln!(
             "\nPoX info at {}\n{:?}\n\n",
@@ -1573,7 +1573,7 @@ fn transition_removes_pox_sunset() {
     assert_eq!(account.balance, first_bal as u128);
     assert_eq!(account.nonce, 0);
 
-    let pox_info = get_pox_info(&http_origin);
+    let pox_info = get_pox_info(&http_origin).unwrap();
 
     assert_eq!(
         &pox_info.contract_id,
@@ -1616,7 +1616,7 @@ fn transition_removes_pox_sunset() {
     }
 
     // pox must activate
-    let pox_info = get_pox_info(&http_origin);
+    let pox_info = get_pox_info(&http_origin).unwrap();
     eprintln!("pox_info in pox-1 = {:?}", &pox_info);
     assert_eq!(pox_info.current_cycle.is_pox_active, true);
     assert_eq!(
@@ -1631,7 +1631,7 @@ fn transition_removes_pox_sunset() {
         eprintln!("Sort height pox-1: {} <= {}", sort_height, epoch_21);
     }
 
-    let pox_info = get_pox_info(&http_origin);
+    let pox_info = get_pox_info(&http_origin).unwrap();
 
     // pox is still "active" despite unlock, because there's enough participation, and also even
     // though the v1 block height has passed, the pox-2 contract won't be managing reward sets
@@ -1676,7 +1676,7 @@ fn transition_removes_pox_sunset() {
         sort_height
     );
 
-    let pox_info = get_pox_info(&http_origin);
+    let pox_info = get_pox_info(&http_origin).unwrap();
     assert_eq!(pox_info.current_cycle.is_pox_active, true);
 
     // get pox back online
@@ -1686,7 +1686,7 @@ fn transition_removes_pox_sunset() {
         eprintln!("Sort height pox-2: {}", sort_height);
     }
 
-    let pox_info = get_pox_info(&http_origin);
+    let pox_info = get_pox_info(&http_origin).unwrap();
     eprintln!("pox_info = {:?}", &pox_info);
     assert_eq!(pox_info.current_cycle.is_pox_active, true);
 
@@ -1864,7 +1864,7 @@ fn transition_empty_blocks() {
         // also, make *huge* block-commits with invalid marker bytes once we reach the new
         // epoch, and verify that it fails.
         let tip_info = get_chain_info(&conf);
-        let pox_info = get_pox_info(&http_origin);
+        let pox_info = get_pox_info(&http_origin).unwrap();
 
         eprintln!(
             "\nPoX info at {}\n{:?}\n\n",
diff --git a/testnet/stacks-node/src/tests/epoch_24.rs b/testnet/stacks-node/src/tests/epoch_24.rs
index dfaf6e16ff..d3b3dfbd67 100644
--- a/testnet/stacks-node/src/tests/epoch_24.rs
+++ b/testnet/stacks-node/src/tests/epoch_24.rs
@@ -984,7 +984,7 @@ fn verify_auto_unlock_behavior() {
         }
         next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
 
-        let pox_info = get_pox_info(&http_origin);
+        let pox_info = get_pox_info(&http_origin).unwrap();
         info!(
             "curr height: {}, curr cycle id: {}, pox active: {}",
             tip_info.burn_block_height,
@@ -1003,7 +1003,7 @@ fn verify_auto_unlock_behavior() {
         }
         next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
 
-        let pox_info = get_pox_info(&http_origin);
+        let pox_info = get_pox_info(&http_origin).unwrap();
         info!(
             "curr height: {}, curr cycle id: {}, pox active: {}",
             tip_info.burn_block_height,
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 9825bc4495..4551bac597 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -22,6 +22,7 @@ use clarity::vm::costs::ExecutionCost;
 use clarity::vm::types::PrincipalData;
 use lazy_static::lazy_static;
 use stacks::burnchains::MagicBytes;
+use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::coordinator::comm::CoordinatorChannels;
 use stacks::chainstate::nakamoto::NakamotoChainState;
 use stacks::chainstate::stacks::db::StacksChainState;
@@ -44,7 +45,8 @@ use crate::neon::{Counters, RunLoopCounter};
 use crate::run_loop::boot_nakamoto;
 use crate::tests::make_stacks_transfer;
 use crate::tests::neon_integrations::{
-    next_block_and_wait, run_until_burnchain_height, submit_tx, test_observer, wait_for_runloop,
+    get_account, get_pox_info, next_block_and_wait, run_until_burnchain_height, submit_tx,
+    test_observer, wait_for_runloop,
 };
 use crate::{tests, BitcoinRegtestController, BurnchainController, Config, ConfigFile, Keychain};
 
@@ -706,3 +708,209 @@ fn mine_multiple_per_tenure_integration() {
 
     run_loop_thread.join().unwrap();
 }
+
+#[test]
+#[ignore]
+fn correct_burn_outs() {
+    if env::var("BITCOIND_TEST") != Ok("1".into()) {
+        return;
+    }
+
+    let (mut naka_conf, _miner_account) = naka_neon_integration_conf(None);
+    naka_conf.burnchain.pox_reward_length = Some(10);
+    naka_conf.burnchain.pox_prepare_length = Some(3);
+
+    {
+        let epochs = naka_conf.burnchain.epochs.as_mut().unwrap();
+        let epoch_24_ix = StacksEpoch::find_epoch_by_id(&epochs, StacksEpochId::Epoch24).unwrap();
+        let epoch_25_ix = StacksEpoch::find_epoch_by_id(&epochs, StacksEpochId::Epoch25).unwrap();
+        let epoch_30_ix = StacksEpoch::find_epoch_by_id(&epochs, StacksEpochId::Epoch30).unwrap();
+        epochs[epoch_24_ix].end_height = 208;
+        epochs[epoch_25_ix].start_height = 208;
+        epochs[epoch_25_ix].end_height = 225;
+        epochs[epoch_30_ix].start_height = 225;
+    }
+
+    naka_conf.miner.wait_on_interim_blocks = Duration::from_secs(1000);
+    naka_conf.initial_balances.clear();
+    let accounts: Vec<_> = (0..8)
+        .map(|ix| {
+            let sk = Secp256k1PrivateKey::from_seed(&[ix, ix, ix, ix]);
+            let address = PrincipalData::from(tests::to_addr(&sk));
+            (sk, address)
+        })
+        .collect();
+    for (_, ref addr) in accounts.iter() {
+        naka_conf.add_initial_balance(addr.to_string(), 10000000000000000);
+    }
+
+    let stacker_accounts = accounts[0..3].to_vec();
+
+    test_observer::spawn();
+    let observer_port = test_observer::EVENT_OBSERVER_PORT;
+    naka_conf.events_observers.insert(EventObserverConfig {
+        endpoint: format!("localhost:{observer_port}"),
+        events_keys: vec![EventKeyType::AnyEvent],
+    });
+
+    let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone());
+    btcd_controller
+        .start_bitcoind()
+        .expect("Failed starting bitcoind");
+    let mut btc_regtest_controller = BitcoinRegtestController::new(naka_conf.clone(), None);
+    btc_regtest_controller.bootstrap_chain(201);
+
+    let mut run_loop = boot_nakamoto::BootRunLoop::new(naka_conf.clone()).unwrap();
+    let run_loop_stopper = run_loop.get_termination_switch();
+    let Counters {
+        blocks_processed,
+        naka_submitted_vrfs: vrfs_submitted,
+        naka_submitted_commits: commits_submitted,
+        ..
+    } = run_loop.counters();
+
+    let coord_channel = run_loop.coordinator_channels();
+
+    let run_loop_thread = thread::Builder::new()
+        .name("run_loop".into())
+        .spawn(move || run_loop.start(None, 0))
+        .unwrap();
+    wait_for_runloop(&blocks_processed);
+
+    let epochs = naka_conf.burnchain.epochs.clone().unwrap();
+    let epoch_3 = &epochs[StacksEpoch::find_epoch_by_id(&epochs, StacksEpochId::Epoch30).unwrap()];
+    let epoch_25 = &epochs[StacksEpoch::find_epoch_by_id(&epochs, StacksEpochId::Epoch25).unwrap()];
+
+    info!(
+        "Chain bootstrapped to bitcoin block 201, starting Epoch 2x miner";
+        "Epoch 3.0 Boundary" => (epoch_3.start_height - 1),
+    );
+
+    run_until_burnchain_height(
+        &mut btc_regtest_controller,
+        &blocks_processed,
+        epoch_25.start_height + 1,
+        &naka_conf,
+    );
+
+    info!("Chain bootstrapped to Epoch 2.5, submitting stacker transaction");
+
+    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+
+    let http_origin = format!("http://{}", &naka_conf.node.rpc_bind);
+    let _stacker_thread = thread::Builder::new()
+        .name("stacker".into())
+        .spawn(move || loop {
+            thread::sleep(Duration::from_secs(2));
+            debug!("Checking for stacker-necessity");
+            let Some(pox_info) = get_pox_info(&http_origin) else {
+                warn!("Failed to get pox_info, waiting.");
+                continue;
+            };
+            if !pox_info.contract_id.ends_with(".pox-4") {
+                continue;
+            }
+            let next_cycle_stx = pox_info.next_cycle.stacked_ustx;
+            let min_stx = pox_info.next_cycle.min_threshold_ustx;
+            let min_stx = (min_stx * 3) / 2;
+            if next_cycle_stx >= min_stx {
+                debug!(
+                    "Next cycle has enough stacked, skipping stacking";
+                    "stacked" => next_cycle_stx,
+                    "min" => min_stx,
+                );
+                continue;
+            }
+            let Some(account) = stacker_accounts.iter().find_map(|(sk, addr)| {
+                let account = get_account(&http_origin, &addr);
+                if account.locked == 0 {
+                    Some((sk, addr, account))
+                } else {
+                    None
+                }
+            }) else {
+                continue;
+            };
+
+            let pox_addr_tuple = clarity::vm::tests::execute(&format!(
+                "{{ hashbytes: 0x{}, version: 0x{:02x} }}",
+                tests::to_addr(&account.0).bytes.to_hex(),
+                AddressHashMode::SerializeP2PKH as u8,
+            ));
+
+            let stacking_tx = tests::make_contract_call(
+                &account.0,
+                account.2.nonce,
+                1000,
+                &StacksAddress::burn_address(false),
+                "pox-4",
+                "stack-stx",
+                &[
+                    clarity::vm::Value::UInt(min_stx.into()),
+                    pox_addr_tuple,
+                    clarity::vm::Value::UInt(pox_info.current_burnchain_block_height.into()),
+                    clarity::vm::Value::UInt(1),
+                ],
+            );
+            let txid = submit_tx(&http_origin, &stacking_tx);
+            info!("Submitted stacking transaction: {txid}");
+            thread::sleep(Duration::from_secs(10));
+        })
+        .unwrap();
+
+    run_until_burnchain_height(
+        &mut btc_regtest_controller,
+        &blocks_processed,
+        epoch_3.start_height - 1,
+        &naka_conf,
+    );
+
+    info!("Bootstrapped to Epoch-3.0 boundary, Epoch2x miner should stop");
+
+    // first block wakes up the run loop, wait until a key registration has been submitted.
+    next_block_and(&mut btc_regtest_controller, 60, || {
+        let vrf_count = vrfs_submitted.load(Ordering::SeqCst);
+        Ok(vrf_count >= 1)
+    })
+    .unwrap();
+
+    // second block should confirm the VRF register, wait until a block commit is submitted
+    next_block_and(&mut btc_regtest_controller, 60, || {
+        let commits_count = commits_submitted.load(Ordering::SeqCst);
+        Ok(commits_count >= 1)
+    })
+    .unwrap();
+
+    info!("Bootstrapped to Epoch-3.0 boundary, mining nakamoto blocks");
+
+    let burnchain = naka_conf.get_burnchain();
+    let sortdb = burnchain.open_sortition_db(true).unwrap();
+
+    // Mine nakamoto tenures
+    for _i in 0..30 {
+        if let Err(e) = next_block_and_mine_commit(
+            &mut btc_regtest_controller,
+            30,
+            &coord_channel,
+            &commits_submitted,
+        ) {
+            warn!(
+                "Error while minting a bitcoin block and waiting for stacks-node activity: {e:?}"
+            );
+        }
+
+        let tip_sn = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn()).unwrap();
+        assert!(
+            tip_sn.sortition,
+            "The new chain tip must have had a sortition"
+        );
+    }
+
+    coord_channel
+        .lock()
+        .expect("Mutex poisoned")
+        .stop_chains_coordinator();
+    run_loop_stopper.store(false, Ordering::SeqCst);
+
+    run_loop_thread.join().unwrap();
+}
diff --git a/testnet/stacks-node/src/tests/neon_integrations.rs b/testnet/stacks-node/src/tests/neon_integrations.rs
index 60c43c9b24..f5e6d91fbf 100644
--- a/testnet/stacks-node/src/tests/neon_integrations.rs
+++ b/testnet/stacks-node/src/tests/neon_integrations.rs
@@ -1169,15 +1169,10 @@ pub fn get_account<F: std::fmt::Display>(http_origin: &str, account: &F) -> Acco
     }
 }
 
-pub fn get_pox_info(http_origin: &str) -> RPCPoxInfoData {
+pub fn get_pox_info(http_origin: &str) -> Option<RPCPoxInfoData> {
     let client = reqwest::blocking::Client::new();
     let path = format!("{}/v2/pox", http_origin);
-    client
-        .get(&path)
-        .send()
-        .unwrap()
-        .json::<RPCPoxInfoData>()
-        .unwrap()
+    client.get(&path).send().ok()?.json::<RPCPoxInfoData>().ok()
 }
 
 fn get_chain_tip(http_origin: &str) -> (ConsensusHash, BlockHeaderHash) {
@@ -6067,7 +6062,7 @@ fn pox_integration_test() {
     assert_eq!(account.balance, first_bal as u128);
     assert_eq!(account.nonce, 0);
 
-    let pox_info = get_pox_info(&http_origin);
+    let pox_info = get_pox_info(&http_origin).unwrap();
 
     assert_eq!(
         &pox_info.contract_id,
@@ -6135,7 +6130,7 @@ fn pox_integration_test() {
         eprintln!("Sort height: {}", sort_height);
     }
 
-    let pox_info = get_pox_info(&http_origin);
+    let pox_info = get_pox_info(&http_origin).unwrap();
 
     assert_eq!(
         &pox_info.contract_id,
@@ -6266,7 +6261,7 @@ fn pox_integration_test() {
         eprintln!("Sort height: {}", sort_height);
     }
 
-    let pox_info = get_pox_info(&http_origin);
+    let pox_info = get_pox_info(&http_origin).unwrap();
 
     assert_eq!(
         &pox_info.contract_id,
@@ -6321,7 +6316,7 @@ fn pox_integration_test() {
         eprintln!("Sort height: {}", sort_height);
     }
 
-    let pox_info = get_pox_info(&http_origin);
+    let pox_info = get_pox_info(&http_origin).unwrap();
 
     assert_eq!(
         &pox_info.contract_id,

From 2dafa18d8530b45c2f032a0aa81174fb18cdde90 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Sat, 23 Dec 2023 18:10:21 -0600
Subject: [PATCH 0268/1166] refactor: pass cycle_start_height to get_reward_set
 in both 2.x and nakamoto

---
 stackslib/src/chainstate/coordinator/mod.rs   | 15 +++----
 .../chainstate/nakamoto/coordinator/mod.rs    | 39 ++++++++++++-------
 2 files changed, 32 insertions(+), 22 deletions(-)

diff --git a/stackslib/src/chainstate/coordinator/mod.rs b/stackslib/src/chainstate/coordinator/mod.rs
index e045f0d3ed..8f7b5c80bc 100644
--- a/stackslib/src/chainstate/coordinator/mod.rs
+++ b/stackslib/src/chainstate/coordinator/mod.rs
@@ -285,20 +285,21 @@ pub struct OnChainRewardSetProvider();
 impl RewardSetProvider for OnChainRewardSetProvider {
     fn get_reward_set(
         &self,
-        // Todo: `current_burn_height` is a misleading name: should be the `cycle_start_burn_height`
-        current_burn_height: u64,
+        cycle_start_burn_height: u64,
         chainstate: &mut StacksChainState,
         burnchain: &Burnchain,
         sortdb: &SortitionDB,
         block_id: &StacksBlockId,
     ) -> Result<RewardSet, Error> {
-        let cur_epoch = SortitionDB::get_stacks_epoch(sortdb.conn(), current_burn_height)?.expect(
-            &format!("FATAL: no epoch for burn height {}", current_burn_height),
-        );
+        let cur_epoch = SortitionDB::get_stacks_epoch(sortdb.conn(), cycle_start_burn_height)?
+            .expect(&format!(
+                "FATAL: no epoch for burn height {}",
+                cycle_start_burn_height
+            ));
         if cur_epoch.epoch_id < StacksEpochId::Epoch30 {
             // Stacks 2.x epoch
             return self.get_reward_set_epoch2(
-                current_burn_height,
+                cycle_start_burn_height,
                 chainstate,
                 burnchain,
                 sortdb,
@@ -308,7 +309,7 @@ impl RewardSetProvider for OnChainRewardSetProvider {
         } else {
             // Nakamoto epoch
             return self.get_reward_set_nakamoto(
-                current_burn_height,
+                cycle_start_burn_height,
                 chainstate,
                 burnchain,
                 sortdb,
diff --git a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
index a59bb8e038..e46c16c660 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
@@ -53,18 +53,15 @@ pub mod tests;
 impl OnChainRewardSetProvider {
     pub fn get_reward_set_nakamoto(
         &self,
-        // NOTE: this value is the first burnchain block in the prepare phase which has a Stacks
-        // block (unlike in Stacks 2.x, where this is the first block of the reward phase)
-        current_burn_height: u64,
+        cycle_start_burn_height: u64,
         chainstate: &mut StacksChainState,
         burnchain: &Burnchain,
         sortdb: &SortitionDB,
         block_id: &StacksBlockId,
     ) -> Result<RewardSet, Error> {
         let cycle = burnchain
-            .block_height_to_reward_cycle(current_burn_height)
-            .expect("FATAL: no reward cycle for burn height")
-            + 1;
+            .block_height_to_reward_cycle(cycle_start_burn_height)
+            .expect("FATAL: no reward cycle for burn height");
 
         let registered_addrs =
             chainstate.get_reward_addresses_in_cycle(burnchain, sortdb, cycle, block_id)?;
@@ -77,10 +74,10 @@ impl OnChainRewardSetProvider {
             liquid_ustx,
         );
 
-        let cur_epoch =
-            SortitionDB::get_stacks_epoch(sortdb.conn(), current_burn_height)?.expect(&format!(
+        let cur_epoch = SortitionDB::get_stacks_epoch(sortdb.conn(), cycle_start_burn_height)?
+            .expect(&format!(
                 "FATAL: no epoch defined for burn height {}",
-                current_burn_height
+                cycle_start_burn_height
             ));
 
         if cur_epoch.epoch_id >= StacksEpochId::Epoch30 && participation == 0 {
@@ -90,7 +87,7 @@ impl OnChainRewardSetProvider {
         }
 
         info!("PoX reward cycle threshold computed";
-              "burn_height" => current_burn_height,
+              "burn_height" => cycle_start_burn_height,
               "threshold" => threshold,
               "participation" => participation,
               "liquid_ustx" => liquid_ustx,
@@ -182,6 +179,7 @@ pub fn get_nakamoto_reward_cycle_info<U: RewardSetProvider>(
         .block_height_to_reward_cycle(burn_height)
         .expect("FATAL: no reward cycle for burn height")
         + 1;
+    let reward_start_height = burnchain.reward_cycle_to_block_height(reward_cycle);
 
     debug!("Processing reward set for Nakamoto reward cycle";
           "burn_height" => burn_height,
@@ -258,7 +256,7 @@ pub fn get_nakamoto_reward_cycle_info<U: RewardSetProvider>(
                 .expect("FATAL: no parent for processed Stacks block in prepare phase");
 
         let anchor_block_header = match &parent_block_header.anchored_header {
-            StacksBlockHeaderTypes::Epoch2(..) => parent_block_header,
+            StacksBlockHeaderTypes::Epoch2(..) => parent_block_header.clone(),
             StacksBlockHeaderTypes::Nakamoto(..) => {
                 NakamotoChainState::get_nakamoto_tenure_start_block_header(
                     chain_state.db(),
@@ -289,12 +287,23 @@ pub fn get_nakamoto_reward_cycle_info<U: RewardSetProvider>(
         let txid = anchor_block_sn.winning_block_txid;
 
         info!(
-            "Anchor block selected for cycle {}: (ch {}) {}",
-            reward_cycle, &anchor_block_header.consensus_hash, &block_id
+            "Anchor block selected";
+            "cycle" => reward_cycle,
+            "block_id" => %block_id,
+            "consensus_hash" => %anchor_block_header.consensus_hash,
+            "burn_height" => anchor_block_header.burn_header_height,
+            "anchor_chain_tip" => %parent_block_header.index_block_hash(),
+            "anchor_chain_tip_height" => %parent_block_header.burn_header_height,
+            "first_prepare_sortition_id" => %first_sortition_id
         );
 
-        let reward_set =
-            provider.get_reward_set(burn_height, chain_state, burnchain, sort_db, &block_id)?;
+        let reward_set = provider.get_reward_set(
+            reward_start_height,
+            chain_state,
+            burnchain,
+            sort_db,
+            &block_id,
+        )?;
         debug!(
             "Stacks anchor block (ch {}) {} cycle {} is processed",
             &anchor_block_header.consensus_hash, &block_id, reward_cycle

From 3e21883fba3e80a98a849b7f159df0db913b662b Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 3 Jan 2024 14:30:19 -0500
Subject: [PATCH 0269/1166] Update wsts version to 6.0 and use Packet::verify
 function

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 Cargo.lock                   |   4 +-
 Cargo.toml                   |   2 +-
 stacks-signer/src/runloop.rs | 120 +++--------------------------------
 3 files changed, 11 insertions(+), 115 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index e3c09a8bbb..135236c411 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4712,9 +4712,9 @@ dependencies = [
 
 [[package]]
 name = "wsts"
-version = "5.0.0"
+version = "6.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c250118354755b4abb091a83cb8d659b511c0ae211ccdb3b1254e3db199cb86"
+checksum = "1b2cb1ef1b26d526daae40c1ee657c83bbedaeefd7196f827b40ca79d13f0f34"
 dependencies = [
  "aes-gcm 0.10.2",
  "bs58 0.5.0",
diff --git a/Cargo.toml b/Cargo.toml
index 3d2d9d066d..e409b94158 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -14,7 +14,7 @@ members = [
 
 # Dependencies we want to keep the same between workspace members
 [workspace.dependencies]  
-wsts = "5.0"
+wsts = "6.0"
 rand_core = "0.6"
 rand = "0.8"
 
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index a0691168b3..f109e2ce02 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -8,7 +8,7 @@ use slog::{slog_debug, slog_error, slog_info, slog_warn};
 use stacks_common::{debug, error, info, warn};
 use wsts::common::MerkleRoot;
 use wsts::curve::ecdsa;
-use wsts::net::{Message, Packet, Signable};
+use wsts::net::Packet;
 use wsts::state_machine::coordinator::fire::Coordinator as FireCoordinator;
 use wsts::state_machine::coordinator::{Config as CoordinatorConfig, Coordinator};
 use wsts::state_machine::signer::Signer;
@@ -177,13 +177,9 @@ impl<C: Coordinator> RunLoop<C> {
             .modified_slots
             .iter()
             .filter_map(|chunk| {
-                let message = bincode::deserialize::<Packet>(&chunk.data).ok()?;
-                if verify_msg(
-                    &message,
-                    &self.signing_round.public_keys,
-                    coordinator_public_key,
-                ) {
-                    Some(message)
+                let packet = bincode::deserialize::<Packet>(&chunk.data).ok()?;
+                if packet.verify(&self.signing_round.public_keys, coordinator_public_key) {
+                    Some(packet)
                 } else {
                     None
                 }
@@ -215,6 +211,9 @@ impl From<&Config> for RunLoop<FireCoordinator<v2::Aggregator>> {
         let threshold = ((config.signer_ids_public_keys.key_ids.len() * 7) / 10)
             .try_into()
             .unwrap();
+        let dkg_threshold = ((config.signer_ids_public_keys.key_ids.len() * 9) / 10)
+            .try_into()
+            .unwrap();
         let total_signers = config
             .signer_ids_public_keys
             .signers
@@ -243,6 +242,7 @@ impl From<&Config> for RunLoop<FireCoordinator<v2::Aggregator>> {
 
         let coordinator_config = CoordinatorConfig {
             threshold,
+            dkg_threshold,
             num_signers: total_signers,
             num_keys: total_keys,
             message_private_key: config.message_private_key,
@@ -345,107 +345,3 @@ fn calculate_coordinator(public_keys: &PublicKeys) -> (u32, &ecdsa::PublicKey) {
     // Mockamato just uses the first signer_id as the coordinator for now
     (0, public_keys.signers.get(&0).unwrap())
 }
-
-/// TODO: this should not be here.
-/// Temporary copy paste from frost-signer
-/// See: https://github.com/stacks-network/stacks-blockchain/issues/3913
-fn verify_msg(
-    m: &Packet,
-    public_keys: &PublicKeys,
-    coordinator_public_key: &ecdsa::PublicKey,
-) -> bool {
-    match &m.msg {
-        Message::DkgBegin(msg) | Message::DkgPrivateBegin(msg) => {
-            if !msg.verify(&m.sig, coordinator_public_key) {
-                warn!("Received a DkgPrivateBegin message with an invalid signature.");
-                return false;
-            }
-        }
-        Message::DkgEnd(msg) => {
-            if let Some(public_key) = public_keys.signers.get(&msg.signer_id) {
-                if !msg.verify(&m.sig, public_key) {
-                    warn!("Received a DkgPublicEnd message with an invalid signature.");
-                    return false;
-                }
-            } else {
-                warn!(
-                    "Received a DkgPublicEnd message with an unknown id: {}",
-                    msg.signer_id
-                );
-                return false;
-            }
-        }
-        Message::DkgPublicShares(msg) => {
-            if let Some(public_key) = public_keys.signers.get(&msg.signer_id) {
-                if !msg.verify(&m.sig, public_key) {
-                    warn!("Received a DkgPublicShares message with an invalid signature.");
-                    return false;
-                }
-            } else {
-                warn!(
-                    "Received a DkgPublicShares message with an unknown id: {}",
-                    msg.signer_id
-                );
-                return false;
-            }
-        }
-        Message::DkgPrivateShares(msg) => {
-            // Private shares have key IDs from [0, N) to reference IDs from [1, N]
-            // in Frost V4 to enable easy indexing hence ID + 1
-            // TODO: Once Frost V5 is released, this off by one adjustment will no longer be required
-            if let Some(public_key) = public_keys.signers.get(&msg.signer_id) {
-                if !msg.verify(&m.sig, public_key) {
-                    warn!("Received a DkgPrivateShares message with an invalid signature from signer_id {} key {}", msg.signer_id, &public_key);
-                    return false;
-                }
-            } else {
-                warn!(
-                    "Received a DkgPrivateShares message with an unknown id: {}",
-                    msg.signer_id
-                );
-                return false;
-            }
-        }
-        Message::NonceRequest(msg) => {
-            if !msg.verify(&m.sig, coordinator_public_key) {
-                warn!("Received a NonceRequest message with an invalid signature.");
-                return false;
-            }
-        }
-        Message::NonceResponse(msg) => {
-            if let Some(public_key) = public_keys.signers.get(&msg.signer_id) {
-                if !msg.verify(&m.sig, public_key) {
-                    warn!("Received a NonceResponse message with an invalid signature.");
-                    return false;
-                }
-            } else {
-                warn!(
-                    "Received a NonceResponse message with an unknown id: {}",
-                    msg.signer_id
-                );
-                return false;
-            }
-        }
-        Message::SignatureShareRequest(msg) => {
-            if !msg.verify(&m.sig, coordinator_public_key) {
-                warn!("Received a SignatureShareRequest message with an invalid signature.");
-                return false;
-            }
-        }
-        Message::SignatureShareResponse(msg) => {
-            if let Some(public_key) = public_keys.signers.get(&msg.signer_id) {
-                if !msg.verify(&m.sig, public_key) {
-                    warn!("Received a SignatureShareResponse message with an invalid signature.");
-                    return false;
-                }
-            } else {
-                warn!(
-                    "Received a SignatureShareResponse message with an unknown id: {}",
-                    msg.signer_id
-                );
-                return false;
-            }
-        }
-    }
-    true
-}

From fba9fa45feea7c2f20161c33d05a2508db1fede6 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Fri, 5 Jan 2024 12:56:20 -0500
Subject: [PATCH 0270/1166] chore: update coordinator tests to return the
 TestPeer they create, so it can be used in other unit tests with instantiated
 chainstate

---
 .../chainstate/nakamoto/coordinator/tests.rs  | 32 +++++++++++++++----
 1 file changed, 25 insertions(+), 7 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index 3e9231e614..8f52011f13 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -117,7 +117,7 @@ pub fn boot_nakamoto(
 }
 
 /// Make a replay peer, used for replaying the blockchain
-fn make_replay_peer<'a>(peer: &'a mut TestPeer<'a>) -> TestPeer<'a> {
+fn make_replay_peer<'a>(peer: &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;
@@ -897,8 +897,7 @@ fn test_nakamoto_chainstate_getters() {
 
 /// Mine a 10 Nakamoto tenures with between 1 and 10 Nakamoto blocks each.
 /// Checks the matured mining rewards as well.
-#[test]
-fn test_simple_nakamoto_coordinator_10_tenures_10_blocks() {
+pub fn simple_nakamoto_coordinator_10_tenures_10_sortitions<'a>() -> TestPeer<'a> {
     let private_key = StacksPrivateKey::from_seed(&[2]);
     let addr = StacksAddress::from_public_keys(
         C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
@@ -1185,6 +1184,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);
@@ -1211,6 +1211,12 @@ fn test_simple_nakamoto_coordinator_10_tenures_10_blocks() {
         tip.anchored_header.as_stacks_nakamoto().unwrap(),
         &rc_blocks.last().unwrap().last().unwrap().header
     );
+    return peer;
+}
+
+#[test]
+fn test_nakamoto_coordinator_10_tenures_10_sortitions() {
+    simple_nakamoto_coordinator_10_tenures_10_sortitions();
 }
 
 /// Mine two tenures across three sortitions, using a tenure-extend to allow the first tenure to
@@ -1218,8 +1224,7 @@ fn test_simple_nakamoto_coordinator_10_tenures_10_blocks() {
 ///
 /// Use a tenure-extend to grant the miner of the first tenure the ability to mine
 /// 20 blocks in the first tenure (10 before the second sortiton, and 10 after)
-#[test]
-fn test_simple_nakamoto_coordinator_2_tenures_3_sortitions() {
+pub fn simple_nakamoto_coordinator_2_tenures_3_sortitions<'a>() -> TestPeer<'a> {
     let private_key = StacksPrivateKey::from_seed(&[2]);
     let addr = StacksAddress::from_public_keys(
         C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
@@ -1543,11 +1548,17 @@ fn test_simple_nakamoto_coordinator_2_tenures_3_sortitions() {
         tip.anchored_header.as_stacks_nakamoto().unwrap(),
         &blocks.last().unwrap().header
     );
+
+    return peer;
 }
 
-/// Mine a 10 Nakamoto tenures with 10 Nakamoto blocks, but do a tenure-extend in each block
 #[test]
-fn test_simple_nakamoto_coordinator_10_tenures_and_extensions_10_blocks() {
+fn test_nakamoto_coordinator_2_tenures_3_sortitions() {
+    simple_nakamoto_coordinator_2_tenures_3_sortitions();
+}
+
+/// Mine a 10 Nakamoto tenures with 10 Nakamoto blocks, but do a tenure-extend in each block
+pub fn simple_nakamoto_coordinator_10_extended_tenures_10_sortitions() -> TestPeer<'static> {
     let private_key = StacksPrivateKey::from_seed(&[2]);
     let addr = StacksAddress::from_public_keys(
         C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
@@ -1799,4 +1810,11 @@ fn test_simple_nakamoto_coordinator_10_tenures_and_extensions_10_blocks() {
         tip.anchored_header.as_stacks_nakamoto().unwrap(),
         &rc_blocks.last().unwrap().last().unwrap().header
     );
+
+    return peer;
+}
+
+#[test]
+fn test_nakamoto_coordinator_10_tenures_and_extensions_10_blocks() {
+    simple_nakamoto_coordinator_10_extended_tenures_10_sortitions();
 }

From cc07739ebddf989f754c9a558f7251c0e3958f54 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Fri, 5 Jan 2024 12:56:48 -0500
Subject: [PATCH 0271/1166] feat: new function to get the highest
 NakamotoTenure for a given tenure ID consensus hash

---
 stackslib/src/chainstate/nakamoto/tenure.rs | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/stackslib/src/chainstate/nakamoto/tenure.rs b/stackslib/src/chainstate/nakamoto/tenure.rs
index 3fa254b977..4f14ba6447 100644
--- a/stackslib/src/chainstate/nakamoto/tenure.rs
+++ b/stackslib/src/chainstate/nakamoto/tenure.rs
@@ -509,6 +509,21 @@ impl NakamotoChainState {
         }
     }
 
+    /// Get a nakamoto tenure-change by its tenure ID consensus hash.
+    /// Get the highest such record.
+    pub fn get_highest_nakamoto_tenure_change_by_tenure_id(
+        headers_conn: &Connection,
+        tenure_id_consensus_hash: &ConsensusHash,
+    ) -> Result<Option<NakamotoTenure>, ChainstateError> {
+        let sql = "SELECT * FROM nakamoto_tenures WHERE tenure_id_consensus_hash = ?1 AND cause = ?2 ORDER BY tenure_index DESC LIMIT 1";
+        let args: &[&dyn ToSql] = &[
+            tenure_id_consensus_hash,
+            &TenureChangeCause::BlockFound.as_u8(),
+        ];
+        let tenure_opt: Option<NakamotoTenure> = query_row(headers_conn, sql, args)?;
+        Ok(tenure_opt)
+    }
+
     /// Get the highest processed tenure on the canonical sortition history.
     pub fn get_highest_nakamoto_tenure(
         headers_conn: &Connection,

From 17aa9e63f148e278bbe690331bd620a04a89048b Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Fri, 5 Jan 2024 12:57:08 -0500
Subject: [PATCH 0272/1166] feat: add handler for GetNakamotoInv messages and
 consolidate some code between it and the handler for GetBlocksInv

---
 stackslib/src/net/chat.rs | 473 ++++++++++++++++++++++++++++++++++----
 1 file changed, 433 insertions(+), 40 deletions(-)

diff --git a/stackslib/src/net/chat.rs b/stackslib/src/net/chat.rs
index 664ab52c30..1939d41269 100644
--- a/stackslib/src/net/chat.rs
+++ b/stackslib/src/net/chat.rs
@@ -33,6 +33,7 @@ use stacks_common::util::{get_epoch_time_secs, log};
 use crate::burnchains::{Burnchain, BurnchainView, PublicKey};
 use crate::chainstate::burn::db::sortdb;
 use crate::chainstate::burn::db::sortdb::{BlockHeaderCache, SortitionDB};
+use crate::chainstate::burn::BlockSnapshot;
 use crate::chainstate::stacks::db::StacksChainState;
 use crate::chainstate::stacks::StacksPublicKey;
 use crate::core::{StacksEpoch, PEER_VERSION_EPOCH_2_2, PEER_VERSION_EPOCH_2_3};
@@ -1452,6 +1453,60 @@ impl ConversationP2P {
         Ok(reply_handle)
     }
 
+    /// Verify that a given consensus hash corresponds to a valid PoX sortition and is aligned to
+    /// the start of a reward cycle boundary.  Used to validate both GetBlocksInv and
+    /// GetNakamotoInv messages.
+    /// Returns Ok(Ok(snapshot-for-consensus-hash)) if valid
+    /// Returns Ok(Err(message)) if invalid, in which case, `message` should be replied
+    /// Returns Err(..) on DB errors
+    fn validate_consensus_hash_reward_cycle_start(
+        _local_peer: &LocalPeer,
+        sortdb: &SortitionDB,
+        consensus_hash: &ConsensusHash,
+    ) -> Result<Result<BlockSnapshot, StacksMessageType>, net_error> {
+        // request must correspond to valid PoX fork and must be aligned to reward cycle
+        let Some(base_snapshot) =
+            SortitionDB::get_block_snapshot_consensus(sortdb.conn(), consensus_hash)?
+        else {
+            debug!(
+                "{:?}: No such block snapshot for {}",
+                _local_peer, consensus_hash
+            );
+            return Ok(Err(StacksMessageType::Nack(NackData::new(
+                NackErrorCodes::NoSuchBurnchainBlock,
+            ))));
+        };
+
+        // must be on the main PoX fork
+        if !base_snapshot.pox_valid {
+            debug!(
+                "{:?}: Snapshot for {:?} is not on the valid PoX fork",
+                _local_peer, base_snapshot.consensus_hash
+            );
+            return Ok(Err(StacksMessageType::Nack(NackData::new(
+                NackErrorCodes::InvalidPoxFork,
+            ))));
+        }
+
+        // must be aligned to the start of a reward cycle
+        // (note that the first reward cycle bit doesn't count)
+        if base_snapshot.block_height > sortdb.first_block_height + 1
+            && !sortdb
+                .pox_constants
+                .is_reward_cycle_start(sortdb.first_block_height, base_snapshot.block_height)
+        {
+            warn!(
+                "{:?}: Snapshot for {:?} is at height {}, which is not aligned to a reward cycle",
+                _local_peer, base_snapshot.consensus_hash, base_snapshot.block_height
+            );
+            return Ok(Err(StacksMessageType::Nack(NackData::new(
+                NackErrorCodes::InvalidPoxFork,
+            ))));
+        }
+
+        Ok(Ok(base_snapshot))
+    }
+
     /// Handle an inbound GetBlocksInv request.
     /// Returns a reply handle to the generated message (possibly a nack)
     /// Only returns up to $reward_cycle_length bits
@@ -1473,50 +1528,18 @@ impl ConversationP2P {
             )));
         }
 
-        // request must correspond to valid PoX fork and must be aligned to reward cycle
-        let base_snapshot = match SortitionDB::get_block_snapshot_consensus(
-            sortdb.conn(),
+        let base_snapshot_or_nack = Self::validate_consensus_hash_reward_cycle_start(
+            &_local_peer,
+            sortdb,
             &get_blocks_inv.consensus_hash,
-        )? {
-            Some(sn) => sn,
-            None => {
-                debug!(
-                    "{:?}: No such block snapshot for {}",
-                    &_local_peer, &get_blocks_inv.consensus_hash
-                );
-                return Ok(StacksMessageType::Nack(NackData::new(
-                    NackErrorCodes::NoSuchBurnchainBlock,
-                )));
+        )?;
+        let base_snapshot = match base_snapshot_or_nack {
+            Ok(sn) => sn,
+            Err(msg) => {
+                return Ok(msg);
             }
         };
 
-        // must be on the main PoX fork
-        if !base_snapshot.pox_valid {
-            debug!(
-                "{:?}: Snapshot for {:?} is not on the valid PoX fork",
-                _local_peer, base_snapshot.consensus_hash
-            );
-            return Ok(StacksMessageType::Nack(NackData::new(
-                NackErrorCodes::InvalidPoxFork,
-            )));
-        }
-
-        // must be aligned to the start of a reward cycle
-        // (note that the first reward cycle bit doesn't count)
-        if base_snapshot.block_height > network.get_burnchain().first_block_height + 1
-            && !network
-                .get_burnchain()
-                .is_reward_cycle_start(base_snapshot.block_height)
-        {
-            warn!(
-                "{:?}: Snapshot for {:?} is at height {}, which is not aligned to a reward cycle",
-                _local_peer, base_snapshot.consensus_hash, base_snapshot.block_height
-            );
-            return Ok(StacksMessageType::Nack(NackData::new(
-                NackErrorCodes::InvalidPoxFork,
-            )));
-        }
-
         // find the tail end of this range on the canonical fork.
         let tip_snapshot = {
             let tip_sort_id = SortitionDB::get_canonical_sortition_tip(sortdb.conn())?;
@@ -1654,6 +1677,96 @@ impl ConversationP2P {
         )
     }
 
+    /// Handle an inbound GetNakamotoInv request.
+    /// Returns a reply handle to the generated message (possibly a nack)
+    /// Only returns up to $reward_cycle_length bits
+    pub fn make_getnakamotoinv_response(
+        network: &mut PeerNetwork,
+        sortdb: &SortitionDB,
+        chainstate: &StacksChainState,
+        get_nakamoto_inv: &GetNakamotoInvData,
+    ) -> Result<StacksMessageType, net_error> {
+        let _local_peer = network.get_local_peer();
+
+        let base_snapshot_or_nack = Self::validate_consensus_hash_reward_cycle_start(
+            &_local_peer,
+            sortdb,
+            &get_nakamoto_inv.consensus_hash,
+        )?;
+        let base_snapshot = match base_snapshot_or_nack {
+            Ok(sn) => sn,
+            Err(msg) => {
+                return Ok(msg);
+            }
+        };
+
+        let tip = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn())?;
+        let reward_cycle = sortdb
+            .pox_constants
+            .block_height_to_reward_cycle(sortdb.first_block_height, base_snapshot.block_height)
+            .ok_or(net_error::InvalidMessage)?;
+
+        let bitvec_bools = network.nakamoto_inv_generator.make_tenure_bitvector(
+            &tip,
+            sortdb,
+            chainstate,
+            reward_cycle,
+        )?;
+        let bitvec = NakamotoInvData::bools_to_bitvec(&bitvec_bools);
+
+        Ok(StacksMessageType::NakamotoInv(NakamotoInvData {
+            tenures: bitvec,
+            bitlen: u16::try_from(bitvec_bools.len()).expect("reward cycle length exceeds u16"),
+        }))
+    }
+
+    /// Handle an inbound GetNakamotoInv request.
+    /// Returns a reply handle to the generated message (possibly a nack)
+    fn handle_getnakamotoinv(
+        &mut self,
+        network: &mut PeerNetwork,
+        sortdb: &SortitionDB,
+        chainstate: &mut StacksChainState,
+        preamble: &Preamble,
+        get_nakamoto_inv: &GetNakamotoInvData,
+    ) -> Result<ReplyHandleP2P, net_error> {
+        monitoring::increment_msg_counter("p2p_get_nakamoto_inv".to_string());
+
+        let mut response = ConversationP2P::make_getnakamotoinv_response(
+            network,
+            sortdb,
+            chainstate,
+            get_nakamoto_inv,
+        )?;
+
+        if let StacksMessageType::NakamotoInv(ref mut tenure_inv_data) = &mut response {
+            debug!(
+                "{:?}: Handled GetNakamotoInv. Reply {:?} to request {:?}",
+                &network.get_local_peer(),
+                &tenure_inv_data,
+                get_nakamoto_inv
+            );
+
+            if self.connection.options.disable_inv_chat {
+                // never reply that we have blocks
+                test_debug!(
+                    "{:?}: Disable inv chat -- pretend like we have nothing",
+                    network.get_local_peer()
+                );
+                for i in 0..tenure_inv_data.tenures.len() {
+                    tenure_inv_data.tenures[i] = 0;
+                }
+            }
+        }
+
+        self.sign_and_reply(
+            network.get_local_peer(),
+            network.get_chain_view(),
+            preamble,
+            response,
+        )
+    }
+
     /// Create a response an inbound GetPoxInv request, but unsigned.
     /// Returns a reply handle to the generated message (possibly a nack)
     pub fn make_getpoxinv_response(
@@ -2101,6 +2214,13 @@ impl ConversationP2P {
             StacksMessageType::GetBlocksInv(ref get_blocks_inv) => {
                 self.handle_getblocksinv(network, sortdb, chainstate, &msg.preamble, get_blocks_inv)
             }
+            StacksMessageType::GetNakamotoInv(ref get_nakamoto_inv) => self.handle_getnakamotoinv(
+                network,
+                sortdb,
+                chainstate,
+                &msg.preamble,
+                get_nakamoto_inv,
+            ),
             StacksMessageType::Blocks(_) => {
                 monitoring::increment_stx_blocks_received_counter();
 
@@ -5276,6 +5396,279 @@ mod test {
         })
     }
 
+    #[test]
+    fn convo_handshake_getnakamotoinv() {
+        with_timeout(100, || {
+            let conn_opts = ConnectionOptions::default();
+
+            let socketaddr_1 = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);
+            let socketaddr_2 = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(1, 2, 3, 4)), 8081);
+
+            let first_burn_hash = BurnchainHeaderHash::from_hex(
+                "0000000000000000000000000000000000000000000000000000000000000000",
+            )
+            .unwrap();
+
+            let burnchain = testing_burnchain_config();
+
+            let mut chain_view = BurnchainView {
+                burn_block_height: 12331,
+                burn_block_hash: BurnchainHeaderHash([0x11; 32]),
+                burn_stable_block_height: 12331 - 7,
+                burn_stable_block_hash: BurnchainHeaderHash([0x22; 32]),
+                last_burn_block_hashes: HashMap::new(),
+                rc_consensus_hash: ConsensusHash([0x33; 20]),
+            };
+            chain_view.make_test_data();
+
+            let test_name_1 = "convo_handshake_getnakamotoinv_1";
+            let test_name_2 = "convo_handshake_getnakamotoinv_2";
+            let (mut peerdb_1, mut sortdb_1, stackerdbs_1, pox_id_1, mut chainstate_1) =
+                make_test_chain_dbs(
+                    test_name_1,
+                    &burnchain,
+                    0x9abcdef0,
+                    12350,
+                    "http://peer1.com".into(),
+                    &vec![],
+                    &vec![],
+                    DEFAULT_SERVICES,
+                );
+            let (mut peerdb_2, mut sortdb_2, stackerdbs_2, pox_id_2, mut chainstate_2) =
+                make_test_chain_dbs(
+                    test_name_2,
+                    &burnchain,
+                    0x9abcdef0,
+                    12351,
+                    "http://peer2.com".into(),
+                    &vec![],
+                    &vec![],
+                    DEFAULT_SERVICES,
+                );
+
+            let mut net_1 = db_setup(
+                &test_name_1,
+                &burnchain,
+                0x9abcdef0,
+                &mut peerdb_1,
+                &mut sortdb_1,
+                &socketaddr_1,
+                &chain_view,
+            );
+            let mut net_2 = db_setup(
+                &test_name_2,
+                &burnchain,
+                0x9abcdef0,
+                &mut peerdb_2,
+                &mut sortdb_2,
+                &socketaddr_2,
+                &chain_view,
+            );
+
+            let local_peer_1 = PeerDB::get_local_peer(&peerdb_1.conn()).unwrap();
+            let local_peer_2 = PeerDB::get_local_peer(&peerdb_2.conn()).unwrap();
+
+            let mut convo_1 = ConversationP2P::new(
+                123,
+                456,
+                &burnchain,
+                &socketaddr_2,
+                &conn_opts,
+                true,
+                0,
+                StacksEpoch::unit_test_pre_2_05(0),
+            );
+            let mut convo_2 = ConversationP2P::new(
+                123,
+                456,
+                &burnchain,
+                &socketaddr_1,
+                &conn_opts,
+                true,
+                0,
+                StacksEpoch::unit_test_pre_2_05(0),
+            );
+
+            // no peer public keys known yet
+            assert!(convo_1.connection.get_public_key().is_none());
+            assert!(convo_2.connection.get_public_key().is_none());
+
+            // convo_1 sends a handshake to convo_2
+            let handshake_data_1 = HandshakeData::from_local_peer(&local_peer_1);
+            let handshake_1 = convo_1
+                .sign_message(
+                    &chain_view,
+                    &local_peer_1.private_key,
+                    StacksMessageType::Handshake(handshake_data_1.clone()),
+                )
+                .unwrap();
+            let mut rh_1 = convo_1.send_signed_request(handshake_1, 1000000).unwrap();
+
+            // convo_2 receives it and processes it, and since no one is waiting for it, will forward
+            // it along to the chat caller (us)
+            test_debug!("send handshake");
+            convo_send_recv(&mut convo_1, vec![&mut rh_1], &mut convo_2);
+            let unhandled_2 = convo_2
+                .chat(&mut net_2, &sortdb_2, &mut chainstate_2)
+                .unwrap();
+
+            // convo_1 has a handshakeaccept
+            test_debug!("send handshake-accept");
+            convo_send_recv(&mut convo_2, vec![&mut rh_1], &mut convo_1);
+            let unhandled_1 = convo_1
+                .chat(&mut net_1, &sortdb_1, &mut chainstate_1)
+                .unwrap();
+
+            let reply_1 = rh_1.recv(0).unwrap();
+
+            assert_eq!(unhandled_1.len(), 0);
+            assert_eq!(unhandled_2.len(), 1);
+
+            // convo 2 returns the handshake from convo 1
+            match unhandled_2[0].payload {
+                StacksMessageType::Handshake(ref data) => {
+                    assert_eq!(handshake_data_1, *data);
+                }
+                _ => {
+                    assert!(false);
+                }
+            };
+
+            // received a valid HandshakeAccept from peer 2
+            match reply_1.payload {
+                StacksMessageType::HandshakeAccept(ref data)
+                | StacksMessageType::StackerDBHandshakeAccept(ref data, ..) => {
+                    assert_eq!(data.handshake.addrbytes, local_peer_2.addrbytes);
+                    assert_eq!(data.handshake.port, local_peer_2.port);
+                    assert_eq!(data.handshake.services, local_peer_2.services);
+                    assert_eq!(
+                        data.handshake.node_public_key,
+                        StacksPublicKeyBuffer::from_public_key(&Secp256k1PublicKey::from_private(
+                            &local_peer_2.private_key
+                        ))
+                    );
+                    assert_eq!(
+                        data.handshake.expire_block_height,
+                        local_peer_2.private_key_expire
+                    );
+                    assert_eq!(data.handshake.data_url, "http://peer2.com".into());
+                    assert_eq!(data.heartbeat_interval, conn_opts.heartbeat);
+                }
+                _ => {
+                    assert!(false);
+                }
+            };
+
+            // convo_1 sends a getnakamotoinv to convo_2 for all the tenures in the last reward cycle
+            let convo_1_chaintip =
+                SortitionDB::get_canonical_burn_chain_tip(sortdb_1.conn()).unwrap();
+            let convo_1_ancestor = {
+                let ic = sortdb_1.index_conn();
+                SortitionDB::get_ancestor_snapshot(
+                    &ic,
+                    convo_1_chaintip.block_height - 10 - 1,
+                    &convo_1_chaintip.sortition_id,
+                )
+                .unwrap()
+                .unwrap()
+            };
+
+            let getnakamotodata_1 = GetNakamotoInvData {
+                consensus_hash: convo_1_ancestor.consensus_hash,
+            };
+            let getnakamotodata_1_msg = convo_1
+                .sign_message(
+                    &chain_view,
+                    &local_peer_1.private_key,
+                    StacksMessageType::GetNakamotoInv(getnakamotodata_1.clone()),
+                )
+                .unwrap();
+            let mut rh_1 = convo_1
+                .send_signed_request(getnakamotodata_1_msg, 10000000)
+                .unwrap();
+
+            // convo_2 receives it, and handles it
+            test_debug!("send getnakamotoinv");
+            convo_send_recv(&mut convo_1, vec![&mut rh_1], &mut convo_2);
+            let unhandled_2 = convo_2
+                .chat(&mut net_2, &sortdb_2, &mut chainstate_2)
+                .unwrap();
+
+            // convo_1 gets back a nakamotoinv message
+            test_debug!("send nakamotoinv");
+            convo_send_recv(&mut convo_2, vec![&mut rh_1], &mut convo_1);
+            let unhandled_1 = convo_1
+                .chat(&mut net_1, &sortdb_1, &mut chainstate_1)
+                .unwrap();
+
+            let reply_1 = rh_1.recv(0).unwrap();
+
+            // no unhandled messages forwarded
+            assert_eq!(unhandled_1, vec![]);
+            assert_eq!(unhandled_2, vec![]);
+
+            // convo 2 returned a tenure-inv for all tenures
+            match reply_1.payload {
+                StacksMessageType::NakamotoInv(ref data) => {
+                    assert_eq!(data.bitlen, 10);
+                    test_debug!("data: {:?}", data);
+
+                    // all burn blocks had sortitions, but we have no tenures :(
+                    assert_eq!(data.tenures, vec![0, 0]);
+                }
+                x => {
+                    error!("received invalid payload: {:?}", &x);
+                    assert!(false);
+                }
+            }
+
+            // request for a non-existent consensus hash
+            let getnakamotodata_diverged_1 = GetNakamotoInvData {
+                consensus_hash: ConsensusHash([0xff; 20]),
+            };
+            let getnakamotodata_diverged_1_msg = convo_1
+                .sign_message(
+                    &chain_view,
+                    &local_peer_1.private_key,
+                    StacksMessageType::GetNakamotoInv(getnakamotodata_diverged_1.clone()),
+                )
+                .unwrap();
+            let mut rh_1 = convo_1
+                .send_signed_request(getnakamotodata_diverged_1_msg, 10000000)
+                .unwrap();
+
+            // convo_2 receives it, and handles it
+            test_debug!("send getnakamotoinv (diverged)");
+            convo_send_recv(&mut convo_1, vec![&mut rh_1], &mut convo_2);
+            let unhandled_2 = convo_2
+                .chat(&mut net_2, &sortdb_2, &mut chainstate_2)
+                .unwrap();
+
+            // convo_1 gets back a nack message
+            test_debug!("send nack (diverged)");
+            convo_send_recv(&mut convo_2, vec![&mut rh_1], &mut convo_1);
+            let unhandled_1 = convo_1
+                .chat(&mut net_1, &sortdb_1, &mut chainstate_1)
+                .unwrap();
+
+            let reply_1 = rh_1.recv(0).unwrap();
+
+            // no unhandled messages forwarded
+            assert_eq!(unhandled_1, vec![]);
+            assert_eq!(unhandled_2, vec![]);
+
+            // convo 2 returned a nack with the appropriate error message
+            match reply_1.payload {
+                StacksMessageType::Nack(ref data) => {
+                    assert_eq!(data.error_code, NackErrorCodes::NoSuchBurnchainBlock);
+                }
+                _ => {
+                    assert!(false);
+                }
+            }
+        })
+    }
+
     #[test]
     fn convo_natpunch() {
         let conn_opts = ConnectionOptions::default();

From f7cec20824cace6028420e6ed086c465ab705917 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Fri, 5 Jan 2024 12:57:31 -0500
Subject: [PATCH 0273/1166] chore: codec for GetNakamotoInv/NakamotoInv

---
 stackslib/src/net/codec.rs | 104 +++++++++++++++++++++++++++++--------
 1 file changed, 83 insertions(+), 21 deletions(-)

diff --git a/stackslib/src/net/codec.rs b/stackslib/src/net/codec.rs
index a9de074061..1bfd244cd1 100644
--- a/stackslib/src/net/codec.rs
+++ b/stackslib/src/net/codec.rs
@@ -272,27 +272,7 @@ impl BlocksInvData {
     }
 
     pub fn compress_bools(bits: &Vec<bool>) -> Vec<u8> {
-        let mut bitvec = vec![];
-        for i in 0..(bits.len() / 8) {
-            let mut next_octet = 0;
-            for j in 0..8 {
-                if bits[8 * i + j] {
-                    next_octet |= 1 << j;
-                }
-            }
-            bitvec.push(next_octet);
-        }
-        if bits.len() % 8 != 0 {
-            let mut last_octet = 0;
-            let idx = (bits.len() as u64) & 0xfffffffffffffff8; // (bits.len() / 8) * 8
-            for (j, bit) in bits[(idx as usize)..].iter().enumerate() {
-                if *bit {
-                    last_octet |= 1 << j;
-                }
-            }
-            bitvec.push(last_octet);
-        }
-        bitvec
+        NakamotoInvData::bools_to_bitvec(bits)
     }
 
     pub fn has_ith_block(&self, block_index: u16) -> bool {
@@ -316,6 +296,66 @@ impl BlocksInvData {
     }
 }
 
+impl StacksMessageCodec for GetNakamotoInvData {
+    fn consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), codec_error> {
+        write_next(fd, &self.consensus_hash)?;
+        Ok(())
+    }
+
+    fn consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, codec_error> {
+        let consensus_hash: ConsensusHash = read_next(fd)?;
+        Ok(Self { consensus_hash })
+    }
+}
+
+impl StacksMessageCodec for NakamotoInvData {
+    fn consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), codec_error> {
+        write_next(fd, &self.bitlen)?;
+        write_next(fd, &self.tenures)?;
+        Ok(())
+    }
+
+    fn consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, codec_error> {
+        let bitlen: u16 = read_next(fd)?;
+        if bitlen == 0 {
+            return Err(codec_error::DeserializeError(
+                "BlocksInv must contain at least one block/microblock bit".to_string(),
+            ));
+        }
+
+        let tenures: Vec<u8> = read_next_exact::<_, u8>(fd, BITVEC_LEN!(bitlen))?;
+        Ok(Self { bitlen, tenures })
+    }
+}
+
+impl NakamotoInvData {
+    pub fn empty() -> Self {
+        Self {
+            bitlen: 0,
+            tenures: vec![],
+        }
+    }
+
+    pub fn bools_to_bitvec(bits: &[bool]) -> Vec<u8> {
+        let mut bitvec = vec![0u8; (bits.len() / 8) + (if bits.len() % 8 != 0 { 1 } else { 0 })];
+        for (i, bit) in bits.iter().enumerate() {
+            if *bit {
+                bitvec[i / 8] |= 1u8 << (i % 8);
+            }
+        }
+        bitvec
+    }
+
+    pub fn has_ith_tenure(&self, tenure_index: u16) -> bool {
+        if tenure_index >= self.bitlen {
+            return false;
+        }
+        let idx =
+            usize::try_from(tenure_index).expect("can't get usize from u16 on this architecture");
+        self.tenures[idx / 8] & (1 << (tenure_index % 8)) != 0
+    }
+}
+
 impl StacksMessageCodec for GetPoxInv {
     fn consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), codec_error> {
         write_next(fd, &self.consensus_hash)?;
@@ -891,6 +931,8 @@ impl StacksMessageType {
             StacksMessageType::StackerDBGetChunk(ref _m) => StacksMessageID::StackerDBGetChunk,
             StacksMessageType::StackerDBChunk(ref _m) => StacksMessageID::StackerDBChunk,
             StacksMessageType::StackerDBPushChunk(ref _m) => StacksMessageID::StackerDBPushChunk,
+            StacksMessageType::GetNakamotoInv(ref _m) => StacksMessageID::GetNakamotoInv,
+            StacksMessageType::NakamotoInv(ref _m) => StacksMessageID::NakamotoInv,
         }
     }
 
@@ -923,6 +965,8 @@ impl StacksMessageType {
             StacksMessageType::StackerDBGetChunk(ref _m) => "StackerDBGetChunk",
             StacksMessageType::StackerDBChunk(ref _m) => "StackerDBChunk",
             StacksMessageType::StackerDBPushChunk(ref _m) => "StackerDBPushChunk",
+            StacksMessageType::GetNakamotoInv(ref _m) => "GetNakamotoInv",
+            StacksMessageType::NakamotoInv(ref _m) => "NakamotoInv",
         }
     }
 
@@ -1024,6 +1068,12 @@ impl StacksMessageType {
                     m.chunk_data.data.len()
                 )
             }
+            StacksMessageType::GetNakamotoInv(ref m) => {
+                format!("GetNakamotoInv({})", &m.consensus_hash,)
+            }
+            StacksMessageType::NakamotoInv(ref m) => {
+                format!("NakamotoInv({},{:?})", m.bitlen, &m.tenures)
+            }
         }
     }
 }
@@ -1073,6 +1123,8 @@ impl StacksMessageCodec for StacksMessageID {
             x if x == StacksMessageID::StackerDBPushChunk as u8 => {
                 StacksMessageID::StackerDBPushChunk
             }
+            x if x == StacksMessageID::GetNakamotoInv as u8 => StacksMessageID::GetNakamotoInv,
+            x if x == StacksMessageID::NakamotoInv as u8 => StacksMessageID::NakamotoInv,
             _ => {
                 return Err(codec_error::DeserializeError(
                     "Unknown message ID".to_string(),
@@ -1115,6 +1167,8 @@ impl StacksMessageCodec for StacksMessageType {
             StacksMessageType::StackerDBGetChunk(ref m) => write_next(fd, m)?,
             StacksMessageType::StackerDBChunk(ref m) => write_next(fd, m)?,
             StacksMessageType::StackerDBPushChunk(ref m) => write_next(fd, m)?,
+            StacksMessageType::GetNakamotoInv(ref m) => write_next(fd, m)?,
+            StacksMessageType::NakamotoInv(ref m) => write_next(fd, m)?,
         }
         Ok(())
     }
@@ -1217,6 +1271,14 @@ impl StacksMessageCodec for StacksMessageType {
                 let m: StackerDBPushChunkData = read_next(fd)?;
                 StacksMessageType::StackerDBPushChunk(m)
             }
+            StacksMessageID::GetNakamotoInv => {
+                let m: GetNakamotoInvData = read_next(fd)?;
+                StacksMessageType::GetNakamotoInv(m)
+            }
+            StacksMessageID::NakamotoInv => {
+                let m: NakamotoInvData = read_next(fd)?;
+                StacksMessageType::NakamotoInv(m)
+            }
             StacksMessageID::Reserved => {
                 return Err(codec_error::DeserializeError(
                     "Unsupported message ID 'reserved'".to_string(),

From 6096d2b10d69b415c5161531681280bbdda17937 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Fri, 5 Jan 2024 12:57:48 -0500
Subject: [PATCH 0274/1166] chore: API sync with imports

---
 stackslib/src/net/download.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/stackslib/src/net/download.rs b/stackslib/src/net/download.rs
index 33efa07120..65e0ff616d 100644
--- a/stackslib/src/net/download.rs
+++ b/stackslib/src/net/download.rs
@@ -48,7 +48,7 @@ use crate::net::db::{PeerDB, *};
 use crate::net::dns::*;
 use crate::net::http::HttpRequestContents;
 use crate::net::httpcore::{StacksHttpRequest, StacksHttpResponse};
-use crate::net::inv::InvState;
+use crate::net::inv::inv2x::InvState;
 use crate::net::neighbors::MAX_NEIGHBOR_BLOCK_DELAY;
 use crate::net::p2p::PeerNetwork;
 use crate::net::rpc::*;
@@ -2527,7 +2527,7 @@ pub mod test {
     use crate::chainstate::stacks::tests::*;
     use crate::chainstate::stacks::*;
     use crate::net::codec::*;
-    use crate::net::inv::*;
+    use crate::net::inv::inv2x::*;
     use crate::net::relay::*;
     use crate::net::test::*;
     use crate::net::*;

From 1bb1a5dd6d01386b09e97374e04c9b3b8e7f73c8 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Fri, 5 Jan 2024 12:58:11 -0500
Subject: [PATCH 0275/1166] feat: GetNakamotoInv/NakamotoInv message types

---
 stackslib/src/net/mod.rs | 103 ++++++++++++++++++++++++++++++++++++---
 1 file changed, 96 insertions(+), 7 deletions(-)

diff --git a/stackslib/src/net/mod.rs b/stackslib/src/net/mod.rs
index d237fb1f89..e746934a01 100644
--- a/stackslib/src/net/mod.rs
+++ b/stackslib/src/net/mod.rs
@@ -836,19 +836,47 @@ pub struct Preamble {
 
 /// Request for a block inventory or a list of blocks.
 /// Aligned to a PoX reward cycle.
+/// This struct is used only in Stacks 2.x for Stacks 2.x inventories
 #[derive(Debug, Clone, PartialEq)]
 pub struct GetBlocksInv {
-    pub consensus_hash: ConsensusHash, // consensus hash at the start of the reward cycle
-    pub num_blocks: u16,               // number of blocks to ask for
+    /// Consensus hash at thestart of the reward cycle
+    pub consensus_hash: ConsensusHash,
+    /// Number of sortitions to ask for. Can be up to the reward cycle length.
+    pub num_blocks: u16,
 }
 
 /// A bit vector that describes which block and microblock data node has data for in a given burn
-/// chain block range.  Sent in reply to a GetBlocksInv.
+/// chain block range.  Sent in reply to a GetBlocksInv for Stacks 2.x block data.
 #[derive(Debug, Clone, PartialEq)]
 pub struct BlocksInvData {
-    pub bitlen: u16, // number of bits represented in bitvec (not to exceed PoX reward cycle length).  Bits correspond to sortitions on the canonical burn chain fork.
-    pub block_bitvec: Vec<u8>, // bitmap of which blocks the peer has, in sortition order.  block_bitvec[i] & (1 << j) != 0 means that this peer has the block for sortition 8*i + j
-    pub microblocks_bitvec: Vec<u8>, // bitmap of which confirmed micrblocks the peer has, in sortition order.  microblocks_bitvec[i] & (1 << j) != 0 means that this peer has the microblocks produced by sortition 8*i + j
+    /// Number of bits in the block bit vector (not to exceed the reward cycle length)
+    pub bitlen: u16,
+    /// The block bitvector. block_bitvec[i] & (1 << j) != 0 means that this peer has the block for
+    /// sortition 8*i + j.
+    pub block_bitvec: Vec<u8>,
+    /// The microblock bitvector. microblocks_bitvec[i] & (1 << j) != 0 means that this peer has
+    /// the microblocks for sortition 8*i + j
+    pub microblocks_bitvec: Vec<u8>,
+}
+
+/// Request for a tenure inventroy.
+/// Aligned to a PoX reward cycle.
+/// This struct is used only in Nakamoto, for Nakamoto inventories
+#[derive(Debug, Clone, PartialEq)]
+pub struct GetNakamotoInvData {
+    /// Consensus hash at the start of the reward cycle
+    pub consensus_hash: ConsensusHash,
+}
+
+/// A bit vector that describes Nakamoto tenure availability.  Sent in reply for GetBlocksInv for
+/// Nakamoto block data.
+#[derive(Debug, Clone, PartialEq)]
+pub struct NakamotoInvData {
+    /// Number of bits this tenure bit vector has (not to exceed the reward cycle length).
+    pub bitlen: u16,
+    /// The tenure bitvector.  tenures[i] & (1 << j) != 0 means that this peer has all the blocks
+    /// for the tenure which began in sortition 8*i + j.
+    pub tenures: Vec<u8>,
 }
 
 /// Request for a PoX bitvector range.
@@ -1088,6 +1116,9 @@ pub enum StacksMessageType {
     StackerDBGetChunk(StackerDBGetChunkData),
     StackerDBChunk(StackerDBChunkData),
     StackerDBPushChunk(StackerDBPushChunkData),
+    // Nakamoto-specific
+    GetNakamotoInv(GetNakamotoInvData),
+    NakamotoInv(NakamotoInvData),
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -1119,6 +1150,9 @@ pub enum StacksMessageID {
     StackerDBGetChunk = 23,
     StackerDBChunk = 24,
     StackerDBPushChunk = 25,
+    // nakamoto
+    GetNakamotoInv = 26,
+    NakamotoInv = 27,
     // reserved
     Reserved = 255,
 }
@@ -2441,10 +2475,22 @@ pub mod test {
             let indexer = BitcoinIndexer::new_unit_test(&config.burnchain.working_dir);
 
             // extract bound ports (which may be different from what's in the config file, if e.g.
-            // they were 0
+            // they were 0)
             let p2p_port = peer_network.bound_neighbor_key().port;
             let http_port = peer_network.http.as_ref().unwrap().http_server_addr.port();
 
+            peer_network.local_peer.port = p2p_port;
+            peer_network
+                .peerdb
+                .update_local_peer(
+                    peer_network.local_peer.network_id,
+                    peer_network.local_peer.parent_network_id,
+                    peer_network.local_peer.data_url.clone(),
+                    peer_network.local_peer.port,
+                    &config.stacker_dbs,
+                )
+                .unwrap();
+
             config.server_port = p2p_port;
             config.http_port = http_port;
 
@@ -3503,6 +3549,49 @@ pub mod test {
             debug!("{:#?}", &peers);
             debug!("--- END ALL PEERS ({}) -----", peers.len());
         }
+
+        pub fn p2p_socketaddr(&self) -> SocketAddr {
+            SocketAddr::new(
+                IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)),
+                self.config.server_port,
+            )
+        }
+
+        pub fn make_client_convo(&self) -> ConversationP2P {
+            ConversationP2P::new(
+                self.config.network_id,
+                self.config.peer_version,
+                &self.config.burnchain,
+                &SocketAddr::new(
+                    IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)),
+                    self.config.server_port,
+                ),
+                &self.config.connection_opts,
+                false,
+                0,
+                self.config
+                    .epochs
+                    .clone()
+                    .unwrap_or(StacksEpoch::unit_test_3_0(0)),
+            )
+        }
+
+        pub fn make_client_local_peer(&self, privk: StacksPrivateKey) -> LocalPeer {
+            LocalPeer::new(
+                self.config.network_id,
+                self.network.local_peer.parent_network_id,
+                PeerAddress::from_socketaddr(&SocketAddr::new(
+                    IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)),
+                    self.config.server_port,
+                )),
+                self.config.server_port,
+                Some(privk),
+                u64::MAX,
+                UrlString::try_from(format!("http://127.0.0.1:{}", self.config.http_port).as_str())
+                    .unwrap(),
+                vec![],
+            )
+        }
     }
 
     pub fn to_addr(sk: &StacksPrivateKey) -> StacksAddress {

From 8524b69a6d480a932fc537a5ff0a997198111093 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Fri, 5 Jan 2024 12:58:29 -0500
Subject: [PATCH 0276/1166] feat: cache NakamotoInv data with PeerNetwork
 (instead of chainstate, like we do with BlocksInv data)

---
 stackslib/src/net/p2p.rs | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/stackslib/src/net/p2p.rs b/stackslib/src/net/p2p.rs
index 01a4efb899..e90822d651 100644
--- a/stackslib/src/net/p2p.rs
+++ b/stackslib/src/net/p2p.rs
@@ -56,7 +56,8 @@ use crate::net::db::{LocalPeer, PeerDB};
 use crate::net::download::BlockDownloader;
 use crate::net::http::HttpRequestContents;
 use crate::net::httpcore::StacksHttpRequest;
-use crate::net::inv::*;
+use crate::net::inv::inv2x::*;
+use crate::net::inv::nakamoto::InvGenerator;
 use crate::net::neighbors::*;
 use crate::net::poll::{NetworkPollState, NetworkState};
 use crate::net::prune::*;
@@ -346,6 +347,10 @@ pub struct PeerNetwork {
 
     // fault injection -- force disconnects
     fault_last_disconnect: u64,
+
+    /// Nakamoto-specific cache for sortition and tenure data, for the purposes of generating
+    /// tenure inventories
+    pub nakamoto_inv_generator: InvGenerator,
 }
 
 impl PeerNetwork {
@@ -492,6 +497,8 @@ impl PeerNetwork {
             pending_messages: HashMap::new(),
 
             fault_last_disconnect: 0,
+
+            nakamoto_inv_generator: InvGenerator::new(),
         };
 
         network.init_block_downloader();

From 4b0f7ff9fb028586f1039209b8e3faaa1a6f2a67 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Fri, 5 Jan 2024 12:58:59 -0500
Subject: [PATCH 0277/1166] chore: API sync inv imports

---
 stackslib/src/net/relay.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stackslib/src/net/relay.rs b/stackslib/src/net/relay.rs
index 0d47942abf..80a43eeb0f 100644
--- a/stackslib/src/net/relay.rs
+++ b/stackslib/src/net/relay.rs
@@ -2613,7 +2613,7 @@ pub mod test {
     use crate::net::download::*;
     use crate::net::http::{HttpRequestContents, HttpRequestPreamble};
     use crate::net::httpcore::StacksHttpMessage;
-    use crate::net::inv::*;
+    use crate::net::inv::inv2x::*;
     use crate::net::test::*;
     use crate::net::*;
     use crate::util_lib::test::*;

From 0d7f2ff7967c458313e8a5cefebe20e745db565a Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Fri, 5 Jan 2024 12:59:41 -0500
Subject: [PATCH 0278/1166] refactor: move epoch 2.x inventory state machine
 and tests into `src/net/inv/` module and name their files `epoch2x.rs`

---
 stackslib/src/net/{inv.rs => inv/epoch2x.rs} | 2021 +-----------------
 stackslib/src/net/inv/mod.rs                 |   26 +
 stackslib/src/net/inv/tests/epoch2x.rs       | 1990 +++++++++++++++++
 stackslib/src/net/inv/tests/mod.rs           |   18 +
 4 files changed, 2036 insertions(+), 2019 deletions(-)
 rename stackslib/src/net/{inv.rs => inv/epoch2x.rs} (57%)
 create mode 100644 stackslib/src/net/inv/mod.rs
 create mode 100644 stackslib/src/net/inv/tests/epoch2x.rs
 create mode 100644 stackslib/src/net/inv/tests/mod.rs

diff --git a/stackslib/src/net/inv.rs b/stackslib/src/net/inv/epoch2x.rs
similarity index 57%
rename from stackslib/src/net/inv.rs
rename to stackslib/src/net/inv/epoch2x.rs
index bce6297611..27147f36a5 100644
--- a/stackslib/src/net/inv.rs
+++ b/stackslib/src/net/inv/epoch2x.rs
@@ -594,7 +594,7 @@ impl NeighborBlockStats {
     }
 
     /// Determine what to do with a NACK response.
-    fn diagnose_nack(
+    pub(crate) fn diagnose_nack(
         _nk: &NeighborKey,
         nack_data: NackData,
         chain_view: &BurnchainView,
@@ -2629,2021 +2629,4 @@ impl PeerNetwork {
 }
 
 #[cfg(test)]
-mod test {
-    use std::collections::HashMap;
-
-    use stacks_common::deps_common::bitcoin::network::serialize::BitcoinHash;
-
-    use super::*;
-    use crate::burnchains::bitcoin::indexer::BitcoinIndexer;
-    use crate::burnchains::db::BurnchainHeaderReader;
-    use crate::burnchains::tests::BURNCHAIN_TEST_BLOCK_TIME;
-    use crate::burnchains::{BurnchainBlockHeader, PoxConstants};
-    use crate::chainstate::coordinator::tests::get_burnchain;
-    use crate::chainstate::stacks::*;
-    use crate::net::test::*;
-    use crate::net::*;
-    use crate::util_lib::test::*;
-
-    #[test]
-    fn peerblocksinv_has_ith_block() {
-        let peer_inv =
-            PeerBlocksInv::new(vec![0x55, 0x77], vec![0x11, 0x22], vec![0x01], 16, 1, 12345);
-        let has_blocks = vec![
-            true, false, true, false, true, false, true, false, true, true, true, false, true,
-            true, true, false,
-        ];
-        let has_microblocks = vec![
-            true, false, false, false, true, false, false, false, false, true, false, false, false,
-            true, false, false,
-        ];
-
-        assert!(!peer_inv.has_ith_block(12344));
-        assert!(!peer_inv.has_ith_block(12345 + 17));
-
-        assert!(!peer_inv.has_ith_microblock_stream(12344));
-        assert!(!peer_inv.has_ith_microblock_stream(12345 + 17));
-
-        for i in 0..16 {
-            assert_eq!(has_blocks[i], peer_inv.has_ith_block((12345 + i) as u64));
-            assert_eq!(
-                has_microblocks[i],
-                peer_inv.has_ith_microblock_stream((12345 + i) as u64)
-            );
-        }
-    }
-
-    #[test]
-    fn peerblocksinv_merge() {
-        let peer_inv = PeerBlocksInv::new(
-            vec![0x00, 0x00, 0x55, 0x77],
-            vec![0x00, 0x00, 0x55, 0x77],
-            vec![0x01],
-            32,
-            1,
-            12345,
-        );
-
-        // merge below, aligned
-        let mut peer_inv_below = peer_inv.clone();
-        let (new_blocks, new_microblocks) =
-            peer_inv_below.merge_blocks_inv(12345, 16, vec![0x11, 0x22], vec![0x11, 0x22], false);
-        assert_eq!(new_blocks, 4);
-        assert_eq!(new_microblocks, 4);
-        assert_eq!(peer_inv_below.num_sortitions, 32);
-        assert_eq!(peer_inv_below.block_inv, vec![0x11, 0x22, 0x55, 0x77]);
-        assert_eq!(peer_inv_below.microblocks_inv, vec![0x11, 0x22, 0x55, 0x77]);
-
-        // merge below, overlapping, aligned
-        let mut peer_inv_below_overlap = peer_inv.clone();
-        let (new_blocks, new_microblocks) = peer_inv_below_overlap.merge_blocks_inv(
-            12345 + 8,
-            16,
-            vec![0x11, 0x22],
-            vec![0x11, 0x22],
-            false,
-        );
-        assert_eq!(new_blocks, 4);
-        assert_eq!(new_microblocks, 4);
-        assert_eq!(peer_inv_below_overlap.num_sortitions, 32);
-        assert_eq!(
-            peer_inv_below_overlap.block_inv,
-            vec![0x00, 0x11, 0x22 | 0x55, 0x77]
-        );
-        assert_eq!(
-            peer_inv_below_overlap.microblocks_inv,
-            vec![0x00, 0x11, 0x22 | 0x55, 0x77]
-        );
-
-        // merge equal, overlapping, aligned
-        let mut peer_inv_equal = peer_inv.clone();
-        let (new_blocks, new_microblocks) = peer_inv_equal.merge_blocks_inv(
-            12345 + 16,
-            16,
-            vec![0x11, 0x22],
-            vec![0x11, 0x22],
-            false,
-        );
-        assert_eq!(new_blocks, 0);
-        assert_eq!(new_microblocks, 0);
-        assert_eq!(peer_inv_equal.num_sortitions, 32);
-        assert_eq!(
-            peer_inv_equal.block_inv,
-            vec![0x00, 0x00, 0x11 | 0x55, 0x22 | 0x77]
-        );
-        assert_eq!(
-            peer_inv_equal.microblocks_inv,
-            vec![0x00, 0x00, 0x11 | 0x55, 0x22 | 0x77]
-        );
-
-        // merge above, overlapping, aligned
-        let mut peer_inv_above_overlap = peer_inv.clone();
-        let (new_blocks, new_microblocks) = peer_inv_above_overlap.merge_blocks_inv(
-            12345 + 24,
-            16,
-            vec![0x11, 0x22],
-            vec![0x11, 0x22],
-            false,
-        );
-        assert_eq!(new_blocks, 2);
-        assert_eq!(new_microblocks, 2);
-        assert_eq!(peer_inv_above_overlap.num_sortitions, 40);
-        assert_eq!(
-            peer_inv_above_overlap.block_inv,
-            vec![0x00, 0x00, 0x55, 0x77 | 0x11, 0x22]
-        );
-        assert_eq!(
-            peer_inv_above_overlap.microblocks_inv,
-            vec![0x00, 0x00, 0x55, 0x77 | 0x11, 0x22]
-        );
-
-        // merge above, non-overlapping, aligned
-        let mut peer_inv_above = peer_inv.clone();
-        let (new_blocks, new_microblocks) = peer_inv_above.merge_blocks_inv(
-            12345 + 32,
-            16,
-            vec![0x11, 0x22],
-            vec![0x11, 0x22],
-            false,
-        );
-        assert_eq!(peer_inv_above.num_sortitions, 48);
-        assert_eq!(new_blocks, 4);
-        assert_eq!(new_microblocks, 4);
-        assert_eq!(
-            peer_inv_above.block_inv,
-            vec![0x00, 0x00, 0x55, 0x77, 0x11, 0x22]
-        );
-        assert_eq!(
-            peer_inv_above.microblocks_inv,
-            vec![0x00, 0x00, 0x55, 0x77, 0x11, 0x22]
-        );
-
-        // try merging unaligned
-        let mut peer_inv = PeerBlocksInv::new(
-            vec![0x00, 0x00, 0x00, 0x00],
-            vec![0x00, 0x00, 0x00, 0x00],
-            vec![0x01],
-            32,
-            1,
-            12345,
-        );
-        for i in 0..32 {
-            let (new_blocks, new_microblocks) =
-                peer_inv.merge_blocks_inv(12345 + i, 1, vec![0x01], vec![0x01], false);
-            assert_eq!(new_blocks, 1);
-            assert_eq!(new_microblocks, 1);
-            assert_eq!(peer_inv.num_sortitions, 32);
-            for j in 0..i + 1 {
-                assert!(peer_inv.has_ith_block(12345 + j));
-                assert!(peer_inv.has_ith_microblock_stream(12345 + j));
-            }
-            for j in i + 1..32 {
-                assert!(!peer_inv.has_ith_block(12345 + j));
-                assert!(!peer_inv.has_ith_microblock_stream(12345 + j));
-            }
-        }
-
-        // try merging unaligned, with multiple blocks
-        let mut peer_inv = PeerBlocksInv::new(
-            vec![0x00, 0x00, 0x00, 0x00],
-            vec![0x00, 0x00, 0x00, 0x00],
-            vec![0x01],
-            32,
-            1,
-            12345,
-        );
-        for i in 0..16 {
-            let (new_blocks, new_microblocks) = peer_inv.merge_blocks_inv(
-                12345 + i,
-                32,
-                vec![0x01, 0x00, 0x01, 0x00],
-                vec![0x01, 0x00, 0x01, 0x00],
-                false,
-            );
-            assert_eq!(new_blocks, 2);
-            assert_eq!(new_microblocks, 2);
-            assert_eq!(peer_inv.num_sortitions, 32 + i);
-            for j in 0..i + 1 {
-                assert!(peer_inv.has_ith_block(12345 + j));
-                assert!(peer_inv.has_ith_block(12345 + j + 16));
-
-                assert!(peer_inv.has_ith_microblock_stream(12345 + j));
-                assert!(peer_inv.has_ith_microblock_stream(12345 + j + 16));
-            }
-            for j in i + 1..16 {
-                assert!(!peer_inv.has_ith_block(12345 + j));
-                assert!(!peer_inv.has_ith_block(12345 + j + 16));
-
-                assert!(!peer_inv.has_ith_microblock_stream(12345 + j));
-                assert!(!peer_inv.has_ith_microblock_stream(12345 + j + 16));
-            }
-        }
-
-        // merge 0's grows the bitvec
-        let mut peer_inv = PeerBlocksInv::new(
-            vec![0x00, 0x00, 0x00, 0x00],
-            vec![0x00, 0x00, 0x00, 0x00],
-            vec![0x01],
-            32,
-            1,
-            12345,
-        );
-        let (new_blocks, new_microblocks) =
-            peer_inv.merge_blocks_inv(12345 + 24, 16, vec![0x00, 0x00], vec![0x00, 0x00], false);
-        assert_eq!(new_blocks, 0);
-        assert_eq!(new_microblocks, 0);
-        assert_eq!(peer_inv.num_sortitions, 40);
-        assert_eq!(peer_inv.block_inv, vec![0x00, 0x00, 0x00, 0x00, 0x00]);
-        assert_eq!(peer_inv.microblocks_inv, vec![0x00, 0x00, 0x00, 0x00, 0x00]);
-    }
-
-    #[test]
-    fn peerblocksinv_merge_clear_bits() {
-        let peer_inv = PeerBlocksInv::new(
-            vec![0x00, 0x00, 0x55, 0x77],
-            vec![0x00, 0x00, 0x55, 0x77],
-            vec![0x01],
-            32,
-            1,
-            12345,
-        );
-
-        // merge below, aligned
-        let mut peer_inv_below = peer_inv.clone();
-        let (new_blocks, new_microblocks) =
-            peer_inv_below.merge_blocks_inv(12345, 16, vec![0x11, 0x22], vec![0x11, 0x22], true);
-        assert_eq!(new_blocks, 4);
-        assert_eq!(new_microblocks, 4);
-        assert_eq!(peer_inv_below.num_sortitions, 32);
-        assert_eq!(peer_inv_below.block_inv, vec![0x11, 0x22, 0x55, 0x77]);
-        assert_eq!(peer_inv_below.microblocks_inv, vec![0x11, 0x22, 0x55, 0x77]);
-
-        // merge below, overlapping, aligned
-        let mut peer_inv_below_overlap = peer_inv.clone();
-        let (new_blocks, new_microblocks) = peer_inv_below_overlap.merge_blocks_inv(
-            12345 + 8,
-            16,
-            vec![0x11, 0x22],
-            vec![0x11, 0x22],
-            true,
-        );
-        assert_eq!(new_blocks, 4);
-        assert_eq!(new_microblocks, 4);
-        assert_eq!(peer_inv_below_overlap.num_sortitions, 32);
-        assert_eq!(
-            peer_inv_below_overlap.block_inv,
-            vec![0x00, 0x11, 0x22, 0x77]
-        );
-        assert_eq!(
-            peer_inv_below_overlap.microblocks_inv,
-            vec![0x00, 0x11, 0x22, 0x77]
-        );
-
-        // merge equal, overlapping, aligned
-        let mut peer_inv_equal = peer_inv.clone();
-        let (new_blocks, new_microblocks) = peer_inv_equal.merge_blocks_inv(
-            12345 + 16,
-            16,
-            vec![0x11, 0x22],
-            vec![0x11, 0x22],
-            true,
-        );
-        assert_eq!(new_blocks, 0);
-        assert_eq!(new_microblocks, 0);
-        assert_eq!(peer_inv_equal.num_sortitions, 32);
-        assert_eq!(peer_inv_equal.block_inv, vec![0x00, 0x00, 0x11, 0x22]);
-        assert_eq!(peer_inv_equal.microblocks_inv, vec![0x00, 0x00, 0x11, 0x22]);
-
-        // merge above, overlapping, aligned
-        let mut peer_inv_above_overlap = peer_inv.clone();
-        let (new_blocks, new_microblocks) = peer_inv_above_overlap.merge_blocks_inv(
-            12345 + 24,
-            16,
-            vec![0x11, 0x22],
-            vec![0x11, 0x22],
-            true,
-        );
-        assert_eq!(new_blocks, 2);
-        assert_eq!(new_microblocks, 2);
-        assert_eq!(peer_inv_above_overlap.num_sortitions, 40);
-        assert_eq!(
-            peer_inv_above_overlap.block_inv,
-            vec![0x00, 0x00, 0x55, 0x11, 0x22]
-        );
-        assert_eq!(
-            peer_inv_above_overlap.microblocks_inv,
-            vec![0x00, 0x00, 0x55, 0x11, 0x22]
-        );
-
-        // merge above, non-overlapping, aligned
-        let mut peer_inv_above = peer_inv.clone();
-        let (new_blocks, new_microblocks) = peer_inv_above.merge_blocks_inv(
-            12345 + 32,
-            16,
-            vec![0x11, 0x22],
-            vec![0x11, 0x22],
-            true,
-        );
-        assert_eq!(peer_inv_above.num_sortitions, 48);
-        assert_eq!(new_blocks, 4);
-        assert_eq!(new_microblocks, 4);
-        assert_eq!(
-            peer_inv_above.block_inv,
-            vec![0x00, 0x00, 0x55, 0x77, 0x11, 0x22]
-        );
-        assert_eq!(
-            peer_inv_above.microblocks_inv,
-            vec![0x00, 0x00, 0x55, 0x77, 0x11, 0x22]
-        );
-
-        // try merging unaligned
-        let mut peer_inv = PeerBlocksInv::new(
-            vec![0x00, 0x00, 0x00, 0x00],
-            vec![0x00, 0x00, 0x00, 0x00],
-            vec![0x01],
-            32,
-            1,
-            12345,
-        );
-        for i in 0..32 {
-            let (new_blocks, new_microblocks) =
-                peer_inv.merge_blocks_inv(12345 + i, 1, vec![0x01], vec![0x01], true);
-            assert_eq!(new_blocks, 1);
-            assert_eq!(new_microblocks, 1);
-            assert_eq!(peer_inv.num_sortitions, 32);
-            for j in 0..i + 1 {
-                assert!(peer_inv.has_ith_block(12345 + j));
-                assert!(peer_inv.has_ith_microblock_stream(12345 + j));
-            }
-            for j in i + 1..32 {
-                assert!(!peer_inv.has_ith_block(12345 + j));
-                assert!(!peer_inv.has_ith_microblock_stream(12345 + j));
-            }
-        }
-
-        // try merging unaligned, with multiple blocks
-        let mut peer_inv = PeerBlocksInv::new(
-            vec![0x00, 0x00, 0x00, 0x00],
-            vec![0x00, 0x00, 0x00, 0x00],
-            vec![0x01],
-            32,
-            1,
-            12345,
-        );
-        for i in 0..16 {
-            let (new_blocks, new_microblocks) = peer_inv.merge_blocks_inv(
-                12345 + i,
-                32,
-                vec![0x01, 0x00, 0x01, 0x00],
-                vec![0x01, 0x00, 0x01, 0x00],
-                true,
-            );
-            assert_eq!(new_blocks, 2);
-            assert_eq!(new_microblocks, 2);
-            assert_eq!(peer_inv.num_sortitions, 32 + i);
-            for j in 0..i {
-                assert!(peer_inv.has_ith_block(12345 + j));
-                assert!(!peer_inv.has_ith_block(12345 + j + 16));
-
-                assert!(peer_inv.has_ith_microblock_stream(12345 + j));
-                assert!(!peer_inv.has_ith_microblock_stream(12345 + j + 16));
-            }
-
-            assert!(peer_inv.has_ith_block(12345 + i));
-            assert!(peer_inv.has_ith_block(12345 + i + 16));
-
-            assert!(peer_inv.has_ith_microblock_stream(12345 + i));
-            assert!(peer_inv.has_ith_microblock_stream(12345 + i + 16));
-
-            for j in i + 1..16 {
-                assert!(!peer_inv.has_ith_block(12345 + j));
-                assert!(!peer_inv.has_ith_block(12345 + j + 16));
-
-                assert!(!peer_inv.has_ith_microblock_stream(12345 + j));
-                assert!(!peer_inv.has_ith_microblock_stream(12345 + j + 16));
-            }
-        }
-
-        // merge 0's grows the bitvec
-        let mut peer_inv = PeerBlocksInv::new(
-            vec![0x00, 0x00, 0x00, 0x00],
-            vec![0x00, 0x00, 0x00, 0x00],
-            vec![0x01],
-            32,
-            1,
-            12345,
-        );
-        let (new_blocks, new_microblocks) =
-            peer_inv.merge_blocks_inv(12345 + 24, 16, vec![0x00, 0x00], vec![0x00, 0x00], true);
-        assert_eq!(new_blocks, 0);
-        assert_eq!(new_microblocks, 0);
-        assert_eq!(peer_inv.num_sortitions, 40);
-        assert_eq!(peer_inv.block_inv, vec![0x00, 0x00, 0x00, 0x00, 0x00]);
-        assert_eq!(peer_inv.microblocks_inv, vec![0x00, 0x00, 0x00, 0x00, 0x00]);
-    }
-
-    #[test]
-    fn test_inv_set_block_microblock_bits() {
-        let mut peer_inv = PeerBlocksInv::new(vec![0x01], vec![0x01], vec![0x01], 1, 1, 12345);
-
-        assert!(peer_inv.set_block_bit(12345 + 1));
-        assert_eq!(peer_inv.block_inv, vec![0x03]);
-        assert_eq!(peer_inv.num_sortitions, 2);
-        assert!(!peer_inv.set_block_bit(12345 + 1));
-        assert_eq!(peer_inv.block_inv, vec![0x03]);
-        assert_eq!(peer_inv.num_sortitions, 2);
-
-        assert!(peer_inv.set_microblocks_bit(12345 + 1));
-        assert_eq!(peer_inv.microblocks_inv, vec![0x03]);
-        assert_eq!(peer_inv.num_sortitions, 2);
-        assert!(!peer_inv.set_microblocks_bit(12345 + 1));
-        assert_eq!(peer_inv.microblocks_inv, vec![0x03]);
-        assert_eq!(peer_inv.num_sortitions, 2);
-
-        assert!(peer_inv.set_block_bit(12345 + 1 + 16));
-        assert_eq!(peer_inv.block_inv, vec![0x03, 0x00, 0x02]);
-        assert_eq!(peer_inv.microblocks_inv, vec![0x03, 0x00, 0x00]);
-        assert_eq!(peer_inv.num_sortitions, 18);
-        assert!(!peer_inv.set_block_bit(12345 + 1 + 16));
-        assert_eq!(peer_inv.block_inv, vec![0x03, 0x00, 0x02]);
-        assert_eq!(peer_inv.microblocks_inv, vec![0x03, 0x00, 0x00]);
-        assert_eq!(peer_inv.num_sortitions, 18);
-
-        assert!(peer_inv.set_microblocks_bit(12345 + 1 + 32));
-        assert_eq!(peer_inv.block_inv, vec![0x03, 0x00, 0x02, 0x00, 0x00]);
-        assert_eq!(peer_inv.microblocks_inv, vec![0x03, 0x00, 0x00, 0x00, 0x02]);
-        assert_eq!(peer_inv.num_sortitions, 34);
-        assert!(!peer_inv.set_microblocks_bit(12345 + 1 + 32));
-        assert_eq!(peer_inv.block_inv, vec![0x03, 0x00, 0x02, 0x00, 0x00]);
-        assert_eq!(peer_inv.microblocks_inv, vec![0x03, 0x00, 0x00, 0x00, 0x02]);
-        assert_eq!(peer_inv.num_sortitions, 34);
-    }
-
-    #[test]
-    fn test_inv_merge_pox_inv() {
-        let mut burnchain = Burnchain::regtest("unused");
-        burnchain.pox_constants = PoxConstants::new(
-            5,
-            3,
-            3,
-            25,
-            5,
-            u64::MAX,
-            u64::MAX,
-            u32::MAX,
-            u32::MAX,
-            u32::MAX,
-            u32::MAX,
-            u32::MAX,
-        );
-
-        let mut peer_inv = PeerBlocksInv::new(vec![0x01], vec![0x01], vec![0x01], 1, 1, 0);
-        for i in 0..32 {
-            let bit_flipped = peer_inv
-                .merge_pox_inv(&burnchain, i + 1, 1, vec![0x01], false)
-                .unwrap();
-            assert_eq!(bit_flipped, i + 1);
-            assert_eq!(peer_inv.num_reward_cycles, i + 2);
-        }
-
-        assert_eq!(peer_inv.pox_inv, vec![0xff, 0xff, 0xff, 0xff, 0x01]);
-        assert_eq!(peer_inv.num_reward_cycles, 33);
-    }
-
-    #[test]
-    fn test_inv_truncate_pox_inv() {
-        let mut burnchain = Burnchain::regtest("unused");
-        burnchain.pox_constants = PoxConstants::new(
-            5,
-            3,
-            3,
-            25,
-            5,
-            u64::MAX,
-            u64::MAX,
-            u32::MAX,
-            u32::MAX,
-            u32::MAX,
-            u32::MAX,
-            u32::MAX,
-        );
-
-        let mut peer_inv = PeerBlocksInv::new(vec![0x01], vec![0x01], vec![0x01], 1, 1, 0);
-        for i in 0..5 {
-            let bit_flipped_opt = peer_inv.merge_pox_inv(&burnchain, i + 1, 1, vec![0x00], false);
-            assert!(bit_flipped_opt.is_none());
-            assert_eq!(peer_inv.num_reward_cycles, i + 2);
-        }
-
-        assert_eq!(peer_inv.pox_inv, vec![0x01]); // 0000 0001
-        assert_eq!(peer_inv.num_reward_cycles, 6);
-
-        for i in 0..(6 * burnchain.pox_constants.reward_cycle_length) {
-            peer_inv.set_block_bit(i as u64);
-            peer_inv.set_microblocks_bit(i as u64);
-        }
-
-        // 30 bits set, since the reward cycle is 5 blocks long
-        assert_eq!(peer_inv.block_inv, vec![0xff, 0xff, 0xff, 0x3f]);
-        assert_eq!(peer_inv.microblocks_inv, vec![0xff, 0xff, 0xff, 0x3f]);
-        assert_eq!(
-            peer_inv.num_sortitions,
-            (6 * burnchain.pox_constants.reward_cycle_length) as u64
-        );
-
-        // PoX bit 3 flipped
-        let bit_flipped = peer_inv
-            .merge_pox_inv(&burnchain, 3, 1, vec![0x01], false)
-            .unwrap();
-        assert_eq!(bit_flipped, 3);
-
-        assert_eq!(peer_inv.pox_inv, vec![0x9]); // 0000 1001
-        assert_eq!(peer_inv.num_reward_cycles, 6);
-
-        // truncate happened -- only reward cycles 0, 1, and 2 remain (3 * 5 = 15 bits)
-        // BUT: reward cycles start on the _first_ block, so the first bit doesn't count!
-        // The expected bit vector (grouped by reward cycle) is actually 1 11111 11111 11111.
-        assert_eq!(peer_inv.block_inv, vec![0xff, 0xff, 0x00, 0x00]);
-        assert_eq!(peer_inv.microblocks_inv, vec![0xff, 0xff, 0x00, 0x00]);
-        assert_eq!(
-            peer_inv.num_sortitions,
-            (3 * burnchain.pox_constants.reward_cycle_length + 1) as u64
-        );
-    }
-
-    #[test]
-    fn test_sync_inv_set_blocks_microblocks_available() {
-        let mut peer_1_config = TestPeerConfig::new(function_name!(), 31981, 41981);
-        let mut peer_2_config = TestPeerConfig::new(function_name!(), 31982, 41982);
-
-        let peer_1_test_path = TestPeer::make_test_path(&peer_1_config);
-        let peer_2_test_path = TestPeer::make_test_path(&peer_2_config);
-
-        let mut peer_1 = TestPeer::new(peer_1_config.clone());
-        let mut peer_2 = TestPeer::new(peer_2_config.clone());
-
-        for (test_path, burnchain) in [
-            (peer_1_test_path, &mut peer_1.config.burnchain),
-            (peer_2_test_path, &mut peer_2.config.burnchain),
-        ]
-        .iter_mut()
-        {
-            let working_dir = get_burnchain(&test_path, None).working_dir;
-
-            // pre-populate headers
-            let mut indexer = BitcoinIndexer::new_unit_test(&working_dir);
-            let now = BURNCHAIN_TEST_BLOCK_TIME;
-
-            for header_height in 1..6 {
-                let parent_hdr = indexer
-                    .read_burnchain_header(header_height - 1)
-                    .unwrap()
-                    .unwrap();
-
-                let block_header_hash = BurnchainHeaderHash::from_bitcoin_hash(
-                    &BitcoinIndexer::mock_bitcoin_header(&parent_hdr.block_hash, now as u32)
-                        .bitcoin_hash(),
-                );
-
-                let block_header = BurnchainBlockHeader {
-                    block_height: header_height,
-                    block_hash: block_header_hash.clone(),
-                    parent_block_hash: parent_hdr.block_hash.clone(),
-                    num_txs: 0,
-                    timestamp: now,
-                };
-
-                test_debug!(
-                    "Pre-populate block header for {}-{} ({})",
-                    &block_header.block_hash,
-                    &block_header.parent_block_hash,
-                    block_header.block_height
-                );
-                indexer.raw_store_header(block_header.clone()).unwrap();
-            }
-
-            let hdr = indexer
-                .read_burnchain_header(burnchain.first_block_height)
-                .unwrap()
-                .unwrap();
-            burnchain.first_block_hash = hdr.block_hash;
-        }
-
-        peer_1_config.burnchain.first_block_height = 5;
-        peer_2_config.burnchain.first_block_height = 5;
-        peer_1.config.burnchain.first_block_height = 5;
-        peer_2.config.burnchain.first_block_height = 5;
-
-        assert_eq!(
-            peer_1_config.burnchain.first_block_hash,
-            peer_2_config.burnchain.first_block_hash
-        );
-
-        let burnchain = peer_1_config.burnchain.clone();
-
-        let num_blocks = 5;
-        let first_stacks_block_height = {
-            let sn =
-                SortitionDB::get_canonical_burn_chain_tip(&peer_1.sortdb.as_ref().unwrap().conn())
-                    .unwrap();
-            sn.block_height
-        };
-
-        for i in 0..num_blocks {
-            let (burn_ops, stacks_block, microblocks) = peer_2.make_default_tenure();
-
-            peer_1.next_burnchain_block(burn_ops.clone());
-            peer_2.next_burnchain_block(burn_ops.clone());
-            peer_2.process_stacks_epoch_at_tip(&stacks_block, &microblocks);
-        }
-
-        let (tip, num_burn_blocks) = {
-            let sn =
-                SortitionDB::get_canonical_burn_chain_tip(peer_1.sortdb.as_ref().unwrap().conn())
-                    .unwrap();
-            let num_burn_blocks = sn.block_height - peer_1.config.burnchain.first_block_height;
-            (sn, num_burn_blocks)
-        };
-
-        let nk = peer_1.to_neighbor().addr;
-
-        let sortdb = peer_1.sortdb.take().unwrap();
-        peer_1.network.init_inv_sync(&sortdb);
-        match peer_1.network.inv_state {
-            Some(ref mut inv) => {
-                inv.add_peer(nk.clone(), true);
-            }
-            None => {
-                panic!("No inv state");
-            }
-        };
-        peer_1.sortdb = Some(sortdb);
-
-        for i in 0..num_blocks {
-            let sortdb = peer_1.sortdb.take().unwrap();
-            let sn = {
-                let ic = sortdb.index_conn();
-                let sn = SortitionDB::get_ancestor_snapshot(
-                    &ic,
-                    i + 1 + first_stacks_block_height,
-                    &tip.sortition_id,
-                )
-                .unwrap()
-                .unwrap();
-                eprintln!("{:?}", &sn);
-                sn
-            };
-            peer_1.sortdb = Some(sortdb);
-        }
-
-        for i in 0..num_blocks {
-            let sortdb = peer_1.sortdb.take().unwrap();
-            match peer_1.network.inv_state {
-                Some(ref mut inv) => {
-                    assert!(!inv
-                        .block_stats
-                        .get(&nk)
-                        .unwrap()
-                        .inv
-                        .has_ith_block(i + first_stacks_block_height + 1));
-                    assert!(!inv
-                        .block_stats
-                        .get(&nk)
-                        .unwrap()
-                        .inv
-                        .has_ith_microblock_stream(i + first_stacks_block_height + 1));
-
-                    let sn = {
-                        let ic = sortdb.index_conn();
-                        let sn = SortitionDB::get_ancestor_snapshot(
-                            &ic,
-                            i + first_stacks_block_height + 1,
-                            &tip.sortition_id,
-                        )
-                        .unwrap()
-                        .unwrap();
-                        eprintln!("{:?}", &sn);
-                        sn
-                    };
-
-                    // non-existent consensus has
-                    let sh = inv.set_block_available(
-                        &burnchain,
-                        &nk,
-                        &sortdb,
-                        &ConsensusHash([0xfe; 20]),
-                    );
-                    assert_eq!(Err(net_error::NotFoundError), sh);
-                    assert!(!inv
-                        .block_stats
-                        .get(&nk)
-                        .unwrap()
-                        .inv
-                        .has_ith_block(i + first_stacks_block_height + 1));
-                    assert!(!inv
-                        .block_stats
-                        .get(&nk)
-                        .unwrap()
-                        .inv
-                        .has_ith_microblock_stream(i + first_stacks_block_height + 1));
-
-                    // existing consensus hash (mock num_reward_cycles)
-                    inv.block_stats.get_mut(&nk).unwrap().inv.num_reward_cycles = 10;
-                    let sh = inv
-                        .set_block_available(&burnchain, &nk, &sortdb, &sn.consensus_hash)
-                        .unwrap();
-
-                    assert_eq!(
-                        Some(i + first_stacks_block_height - sortdb.first_block_height + 1),
-                        sh
-                    );
-                    assert!(inv
-                        .block_stats
-                        .get(&nk)
-                        .unwrap()
-                        .inv
-                        .has_ith_block(i + first_stacks_block_height + 1));
-
-                    // idempotent
-                    let sh = inv
-                        .set_microblocks_available(&burnchain, &nk, &sortdb, &sn.consensus_hash)
-                        .unwrap();
-
-                    assert_eq!(
-                        Some(i + first_stacks_block_height - sortdb.first_block_height + 1),
-                        sh
-                    );
-                    assert!(inv
-                        .block_stats
-                        .get(&nk)
-                        .unwrap()
-                        .inv
-                        .has_ith_microblock_stream(i + first_stacks_block_height + 1));
-
-                    assert!(inv
-                        .set_block_available(&burnchain, &nk, &sortdb, &sn.consensus_hash)
-                        .unwrap()
-                        .is_none());
-                    assert!(inv
-                        .set_microblocks_available(&burnchain, &nk, &sortdb, &sn.consensus_hash)
-                        .unwrap()
-                        .is_none());
-
-                    // existing consensus hash, but too far ahead (mock)
-                    inv.block_stats.get_mut(&nk).unwrap().inv.num_reward_cycles = 0;
-                    let sh = inv.set_block_available(&burnchain, &nk, &sortdb, &sn.consensus_hash);
-                    assert_eq!(Err(net_error::NotFoundError), sh);
-
-                    let sh =
-                        inv.set_microblocks_available(&burnchain, &nk, &sortdb, &sn.consensus_hash);
-                    assert_eq!(Err(net_error::NotFoundError), sh);
-                }
-                None => {
-                    panic!("No inv state");
-                }
-            }
-            peer_1.sortdb = Some(sortdb);
-        }
-    }
-
-    #[test]
-    fn test_sync_inv_make_inv_messages() {
-        let peer_1_config = TestPeerConfig::new(function_name!(), 31985, 41986);
-
-        let indexer = BitcoinIndexer::new_unit_test(&peer_1_config.burnchain.working_dir);
-        let reward_cycle_length = peer_1_config.burnchain.pox_constants.reward_cycle_length;
-        let num_blocks = peer_1_config.burnchain.pox_constants.reward_cycle_length * 2;
-
-        assert_eq!(reward_cycle_length, 5);
-
-        let mut peer_1 = TestPeer::new(peer_1_config);
-
-        let first_stacks_block_height = {
-            let sn =
-                SortitionDB::get_canonical_burn_chain_tip(&peer_1.sortdb.as_ref().unwrap().conn())
-                    .unwrap();
-            sn.block_height
-        };
-
-        for i in 0..num_blocks {
-            let (burn_ops, stacks_block, microblocks) = peer_1.make_default_tenure();
-
-            peer_1.next_burnchain_block(burn_ops.clone());
-            peer_1.process_stacks_epoch_at_tip(&stacks_block, &microblocks);
-        }
-
-        let (tip, num_burn_blocks) = {
-            let sn =
-                SortitionDB::get_canonical_burn_chain_tip(peer_1.sortdb.as_ref().unwrap().conn())
-                    .unwrap();
-            let num_burn_blocks = sn.block_height - peer_1.config.burnchain.first_block_height;
-            (sn, num_burn_blocks)
-        };
-
-        peer_1
-            .with_network_state(|sortdb, chainstate, network, _relayer, _mempool| {
-                network.refresh_local_peer().unwrap();
-                network
-                    .refresh_burnchain_view(&indexer, sortdb, chainstate, false)
-                    .unwrap();
-                network.refresh_sortition_view(sortdb).unwrap();
-                Ok(())
-            })
-            .unwrap();
-
-        // simulate a getpoxinv / poxinv for one reward cycle
-        let getpoxinv_request = peer_1
-            .with_network_state(|sortdb, _chainstate, network, _relayer, _mempool| {
-                let height = network.burnchain.reward_cycle_to_block_height(1);
-                let sn = {
-                    let ic = sortdb.index_conn();
-                    let sn = SortitionDB::get_ancestor_snapshot(&ic, height, &tip.sortition_id)
-                        .unwrap()
-                        .unwrap();
-                    sn
-                };
-                let getpoxinv = GetPoxInv {
-                    consensus_hash: sn.consensus_hash,
-                    num_cycles: 1,
-                };
-                Ok(getpoxinv)
-            })
-            .unwrap();
-
-        test_debug!("\n\nSend {:?}\n\n", &getpoxinv_request);
-
-        let reply = peer_1
-            .with_network_state(|sortdb, _chainstate, network, _relayer, _mempool| {
-                ConversationP2P::make_getpoxinv_response(network, sortdb, &getpoxinv_request)
-            })
-            .unwrap();
-
-        test_debug!("\n\nReply {:?}\n\n", &reply);
-
-        match reply {
-            StacksMessageType::PoxInv(poxinv) => {
-                assert_eq!(poxinv.bitlen, 1);
-                assert_eq!(poxinv.pox_bitvec, vec![0x01]);
-            }
-            x => {
-                error!("Did not get PoxInv, but got {:?}", &x);
-                assert!(false);
-            }
-        }
-
-        // simulate a getpoxinv / poxinv for several reward cycles, including more than we have
-        // (10, but only have 7)
-        let getpoxinv_request = peer_1
-            .with_network_state(|sortdb, _chainstate, network, _relayer, _mempool| {
-                let height = network.burnchain.reward_cycle_to_block_height(1);
-                let sn = {
-                    let ic = sortdb.index_conn();
-                    let sn = SortitionDB::get_ancestor_snapshot(&ic, height, &tip.sortition_id)
-                        .unwrap()
-                        .unwrap();
-                    sn
-                };
-                let getpoxinv = GetPoxInv {
-                    consensus_hash: sn.consensus_hash,
-                    num_cycles: 10,
-                };
-                Ok(getpoxinv)
-            })
-            .unwrap();
-
-        test_debug!("\n\nSend {:?}\n\n", &getpoxinv_request);
-
-        let reply = peer_1
-            .with_network_state(|sortdb, _chainstate, network, _relayer, _mempool| {
-                ConversationP2P::make_getpoxinv_response(network, sortdb, &getpoxinv_request)
-            })
-            .unwrap();
-
-        test_debug!("\n\nReply {:?}\n\n", &reply);
-
-        match reply {
-            StacksMessageType::PoxInv(poxinv) => {
-                assert_eq!(poxinv.bitlen, 7); // 2 reward cycles we generated, plus 5 reward cycles when booted up (1 reward cycle = 5 blocks).  1st one is free
-                assert_eq!(poxinv.pox_bitvec, vec![0x7f]);
-            }
-            x => {
-                error!("Did not get PoxInv, but got {:?}", &x);
-                assert!(false);
-            }
-        }
-
-        // ask for a PoX vector off of an unknown consensus hash
-        let getpoxinv_request = peer_1
-            .with_network_state(|sortdb, _chainstate, network, _relayer, _mempool| {
-                let getpoxinv = GetPoxInv {
-                    consensus_hash: ConsensusHash([0xaa; 20]),
-                    num_cycles: 10,
-                };
-                Ok(getpoxinv)
-            })
-            .unwrap();
-
-        test_debug!("\n\nSend {:?}\n\n", &getpoxinv_request);
-
-        let reply = peer_1
-            .with_network_state(|sortdb, _chainstate, network, _relayer, _mempool| {
-                ConversationP2P::make_getpoxinv_response(network, sortdb, &getpoxinv_request)
-            })
-            .unwrap();
-
-        test_debug!("\n\nReply {:?}\n\n", &reply);
-
-        match reply {
-            StacksMessageType::Nack(nack_data) => {
-                assert_eq!(nack_data.error_code, NackErrorCodes::InvalidPoxFork);
-            }
-            x => {
-                error!("Did not get PoxInv, but got {:?}", &x);
-                assert!(false);
-            }
-        }
-
-        // ask for a getblocksinv, aligned on a reward cycle.
-        let getblocksinv_request = peer_1
-            .with_network_state(|sortdb, _chainstate, network, _relayer, _mempool| {
-                let height = network.burnchain.reward_cycle_to_block_height(
-                    network
-                        .burnchain
-                        .block_height_to_reward_cycle(first_stacks_block_height)
-                        .unwrap(),
-                );
-                let sn = {
-                    let ic = sortdb.index_conn();
-                    let sn = SortitionDB::get_ancestor_snapshot(&ic, height, &tip.sortition_id)
-                        .unwrap()
-                        .unwrap();
-                    sn
-                };
-                let getblocksinv = GetBlocksInv {
-                    consensus_hash: sn.consensus_hash,
-                    num_blocks: reward_cycle_length as u16,
-                };
-                Ok(getblocksinv)
-            })
-            .unwrap();
-
-        test_debug!("\n\nSend {:?}\n\n", &getblocksinv_request);
-
-        let reply = peer_1
-            .with_network_state(|sortdb, chainstate, network, _relayer, _mempool| {
-                ConversationP2P::make_getblocksinv_response(
-                    network,
-                    sortdb,
-                    chainstate,
-                    &getblocksinv_request,
-                )
-            })
-            .unwrap();
-
-        test_debug!("\n\nReply {:?}\n\n", &reply);
-
-        match reply {
-            StacksMessageType::BlocksInv(blocksinv) => {
-                assert_eq!(blocksinv.bitlen, reward_cycle_length as u16);
-                assert_eq!(blocksinv.block_bitvec, vec![0x1f]);
-                assert_eq!(blocksinv.microblocks_bitvec, vec![0x1e]);
-            }
-            x => {
-                error!("Did not get BlocksInv, but got {:?}", &x);
-                assert!(false);
-            }
-        };
-
-        // ask for a getblocksinv, right at the first Stacks block height
-        let getblocksinv_request = peer_1
-            .with_network_state(|sortdb, _chainstate, network, _relayer, _mempool| {
-                let height = network.burnchain.reward_cycle_to_block_height(
-                    network
-                        .burnchain
-                        .block_height_to_reward_cycle(first_stacks_block_height)
-                        .unwrap(),
-                );
-                test_debug!("Ask for inv at height {}", height);
-                let sn = {
-                    let ic = sortdb.index_conn();
-                    let sn = SortitionDB::get_ancestor_snapshot(&ic, height, &tip.sortition_id)
-                        .unwrap()
-                        .unwrap();
-                    sn
-                };
-                let getblocksinv = GetBlocksInv {
-                    consensus_hash: sn.consensus_hash,
-                    num_blocks: reward_cycle_length as u16,
-                };
-                Ok(getblocksinv)
-            })
-            .unwrap();
-
-        test_debug!("\n\nSend {:?}\n\n", &getblocksinv_request);
-
-        let reply = peer_1
-            .with_network_state(|sortdb, chainstate, network, _relayer, _mempool| {
-                ConversationP2P::make_getblocksinv_response(
-                    network,
-                    sortdb,
-                    chainstate,
-                    &getblocksinv_request,
-                )
-            })
-            .unwrap();
-
-        test_debug!("\n\nReply {:?}\n\n", &reply);
-
-        match reply {
-            StacksMessageType::BlocksInv(blocksinv) => {
-                assert_eq!(blocksinv.bitlen, reward_cycle_length as u16);
-                assert_eq!(blocksinv.block_bitvec, vec![0x1f]);
-                assert_eq!(blocksinv.microblocks_bitvec, vec![0x1e]);
-            }
-            x => {
-                error!("Did not get Nack, but got {:?}", &x);
-                assert!(false);
-            }
-        };
-
-        // ask for a getblocksinv, prior to the first Stacks block height
-        let getblocksinv_request = peer_1
-            .with_network_state(|sortdb, _chainstate, network, _relayer, _mempool| {
-                let height = network.burnchain.reward_cycle_to_block_height(
-                    network
-                        .burnchain
-                        .block_height_to_reward_cycle(first_stacks_block_height)
-                        .unwrap()
-                        - 1,
-                );
-                test_debug!("Ask for inv at height {}", height);
-                let sn = {
-                    let ic = sortdb.index_conn();
-                    let sn = SortitionDB::get_ancestor_snapshot(&ic, height, &tip.sortition_id)
-                        .unwrap()
-                        .unwrap();
-                    sn
-                };
-                let getblocksinv = GetBlocksInv {
-                    consensus_hash: sn.consensus_hash,
-                    num_blocks: reward_cycle_length as u16,
-                };
-                Ok(getblocksinv)
-            })
-            .unwrap();
-
-        test_debug!("\n\nSend {:?}\n\n", &getblocksinv_request);
-
-        let reply = peer_1
-            .with_network_state(|sortdb, chainstate, network, _relayer, _mempool| {
-                ConversationP2P::make_getblocksinv_response(
-                    network,
-                    sortdb,
-                    chainstate,
-                    &getblocksinv_request,
-                )
-            })
-            .unwrap();
-
-        test_debug!("\n\nReply {:?}\n\n", &reply);
-
-        match reply {
-            StacksMessageType::BlocksInv(blocksinv) => {
-                assert_eq!(blocksinv.bitlen, reward_cycle_length as u16);
-                assert_eq!(blocksinv.block_bitvec, vec![0x0]);
-                assert_eq!(blocksinv.microblocks_bitvec, vec![0x0]);
-            }
-            x => {
-                error!("Did not get BlocksInv, but got {:?}", &x);
-                assert!(false);
-            }
-        };
-
-        // ask for a getblocksinv, unaligned to a reward cycle
-        let getblocksinv_request = peer_1
-            .with_network_state(|sortdb, _chainstate, network, _relayer, _mempool| {
-                let height = network.burnchain.reward_cycle_to_block_height(
-                    network
-                        .burnchain
-                        .block_height_to_reward_cycle(first_stacks_block_height)
-                        .unwrap(),
-                ) + 1;
-                let sn = {
-                    let ic = sortdb.index_conn();
-                    let sn = SortitionDB::get_ancestor_snapshot(&ic, height, &tip.sortition_id)
-                        .unwrap()
-                        .unwrap();
-                    sn
-                };
-                let getblocksinv = GetBlocksInv {
-                    consensus_hash: sn.consensus_hash,
-                    num_blocks: reward_cycle_length as u16,
-                };
-                Ok(getblocksinv)
-            })
-            .unwrap();
-
-        test_debug!("\n\nSend {:?}\n\n", &getblocksinv_request);
-
-        let reply = peer_1
-            .with_network_state(|sortdb, chainstate, network, _relayer, _mempool| {
-                ConversationP2P::make_getblocksinv_response(
-                    network,
-                    sortdb,
-                    chainstate,
-                    &getblocksinv_request,
-                )
-            })
-            .unwrap();
-
-        test_debug!("\n\nReply {:?}\n\n", &reply);
-
-        match reply {
-            StacksMessageType::Nack(nack_data) => {
-                assert_eq!(nack_data.error_code, NackErrorCodes::InvalidPoxFork);
-            }
-            x => {
-                error!("Did not get Nack, but got {:?}", &x);
-                assert!(false);
-            }
-        };
-
-        // ask for a getblocksinv, for an unknown consensus hash
-        let getblocksinv_request = peer_1
-            .with_network_state(|sortdb, _chainstate, network, _relayer, _mempool| {
-                let getblocksinv = GetBlocksInv {
-                    consensus_hash: ConsensusHash([0xaa; 20]),
-                    num_blocks: reward_cycle_length as u16,
-                };
-                Ok(getblocksinv)
-            })
-            .unwrap();
-
-        test_debug!("\n\nSend {:?}\n\n", &getblocksinv_request);
-
-        let reply = peer_1
-            .with_network_state(|sortdb, chainstate, network, _relayer, _mempool| {
-                ConversationP2P::make_getblocksinv_response(
-                    network,
-                    sortdb,
-                    chainstate,
-                    &getblocksinv_request,
-                )
-            })
-            .unwrap();
-
-        test_debug!("\n\nReply {:?}\n\n", &reply);
-
-        match reply {
-            StacksMessageType::Nack(nack_data) => {
-                assert_eq!(nack_data.error_code, NackErrorCodes::NoSuchBurnchainBlock);
-            }
-            x => {
-                error!("Did not get Nack, but got {:?}", &x);
-                assert!(false);
-            }
-        };
-    }
-
-    #[test]
-    fn test_sync_inv_diagnose_nack() {
-        let peer_config = TestPeerConfig::new(function_name!(), 31983, 41983);
-        let neighbor = peer_config.to_neighbor();
-        let neighbor_key = neighbor.addr.clone();
-        let nack_no_block = NackData {
-            error_code: NackErrorCodes::NoSuchBurnchainBlock,
-        };
-
-        let mut burnchain_view = BurnchainView {
-            burn_block_height: 12346,
-            burn_block_hash: BurnchainHeaderHash([0x11; 32]),
-            burn_stable_block_height: 12340,
-            burn_stable_block_hash: BurnchainHeaderHash([0x22; 32]),
-            last_burn_block_hashes: HashMap::new(),
-            rc_consensus_hash: ConsensusHash([0x33; 20]),
-        };
-
-        burnchain_view.make_test_data();
-        let ch_12345 = burnchain_view
-            .last_burn_block_hashes
-            .get(&12345)
-            .unwrap()
-            .clone();
-        let ch_12340 = burnchain_view
-            .last_burn_block_hashes
-            .get(&12340)
-            .unwrap()
-            .clone();
-        let ch_12341 = burnchain_view
-            .last_burn_block_hashes
-            .get(&12341)
-            .unwrap()
-            .clone();
-        let ch_12339 = burnchain_view
-            .last_burn_block_hashes
-            .get(&12339)
-            .unwrap()
-            .clone();
-        let ch_12334 = burnchain_view
-            .last_burn_block_hashes
-            .get(&12334)
-            .unwrap()
-            .clone();
-
-        // should be stable; but got nacked (so this would be inappropriate)
-        assert_eq!(
-            NodeStatus::Diverged,
-            NeighborBlockStats::diagnose_nack(
-                &neighbor_key,
-                nack_no_block.clone(),
-                &burnchain_view,
-                12346,
-                12340,
-                &BurnchainHeaderHash([0x11; 32]),
-                &BurnchainHeaderHash([0x22; 32]),
-                false
-            )
-        );
-
-        assert_eq!(
-            NodeStatus::Diverged,
-            NeighborBlockStats::diagnose_nack(
-                &neighbor_key,
-                nack_no_block.clone(),
-                &burnchain_view,
-                12346,
-                12340,
-                &BurnchainHeaderHash([0x11; 32]),
-                &BurnchainHeaderHash([0x22; 32]),
-                true
-            )
-        );
-
-        // should be stale
-        assert_eq!(
-            NodeStatus::Stale,
-            NeighborBlockStats::diagnose_nack(
-                &neighbor_key,
-                nack_no_block.clone(),
-                &burnchain_view,
-                12345,
-                12339,
-                &ch_12345.clone(),
-                &ch_12339.clone(),
-                false
-            )
-        );
-
-        // should be diverged -- different stable burn block hash
-        assert_eq!(
-            NodeStatus::Diverged,
-            NeighborBlockStats::diagnose_nack(
-                &neighbor_key,
-                nack_no_block.clone(),
-                &burnchain_view,
-                12346,
-                12340,
-                &BurnchainHeaderHash([0x12; 32]),
-                &BurnchainHeaderHash([0x23; 32]),
-                false
-            )
-        );
-    }
-
-    #[test]
-    #[ignore]
-    fn test_sync_inv_2_peers_plain() {
-        with_timeout(600, || {
-            let mut peer_1_config = TestPeerConfig::new(function_name!(), 31992, 41992);
-            let mut peer_2_config = TestPeerConfig::new(function_name!(), 31993, 41993);
-
-            peer_1_config.add_neighbor(&peer_2_config.to_neighbor());
-            peer_2_config.add_neighbor(&peer_1_config.to_neighbor());
-
-            let mut peer_1 = TestPeer::new(peer_1_config);
-            let mut peer_2 = TestPeer::new(peer_2_config);
-
-            let num_blocks = (GETPOXINV_MAX_BITLEN * 2) as u64;
-            let first_stacks_block_height = {
-                let sn = SortitionDB::get_canonical_burn_chain_tip(
-                    &peer_1.sortdb.as_ref().unwrap().conn(),
-                )
-                .unwrap();
-                sn.block_height + 1
-            };
-
-            for i in 0..num_blocks {
-                let (burn_ops, stacks_block, microblocks) = peer_2.make_default_tenure();
-
-                peer_1.next_burnchain_block(burn_ops.clone());
-                peer_2.next_burnchain_block(burn_ops.clone());
-
-                peer_1.process_stacks_epoch_at_tip(&stacks_block, &microblocks);
-                peer_2.process_stacks_epoch_at_tip(&stacks_block, &microblocks);
-            }
-
-            let num_burn_blocks = {
-                let sn = SortitionDB::get_canonical_burn_chain_tip(
-                    peer_1.sortdb.as_ref().unwrap().conn(),
-                )
-                .unwrap();
-                sn.block_height + 1
-            };
-
-            let mut round = 0;
-            let mut inv_1_count = 0;
-            let mut inv_2_count = 0;
-
-            while inv_1_count < num_blocks || inv_2_count < num_blocks {
-                let _ = peer_1.step();
-                let _ = peer_2.step();
-
-                inv_1_count = match peer_1.network.inv_state {
-                    Some(ref inv) => {
-                        info!("Peer 1 stats: {:?}", &inv.block_stats);
-                        inv.get_inv_num_blocks(&peer_2.to_neighbor().addr)
-                    }
-                    None => 0,
-                };
-
-                inv_2_count = match peer_2.network.inv_state {
-                    Some(ref inv) => {
-                        info!("Peer 2 stats: {:?}", &inv.block_stats);
-                        inv.get_inv_num_blocks(&peer_1.to_neighbor().addr)
-                    }
-                    None => 0,
-                };
-
-                // nothing should break
-                match peer_1.network.inv_state {
-                    Some(ref inv) => {
-                        assert_eq!(inv.get_broken_peers().len(), 0);
-                        assert_eq!(inv.get_dead_peers().len(), 0);
-                        assert_eq!(inv.get_diverged_peers().len(), 0);
-                    }
-                    None => {}
-                }
-
-                match peer_2.network.inv_state {
-                    Some(ref inv) => {
-                        assert_eq!(inv.get_broken_peers().len(), 0);
-                        assert_eq!(inv.get_dead_peers().len(), 0);
-                        assert_eq!(inv.get_diverged_peers().len(), 0);
-                    }
-                    None => {}
-                }
-
-                round += 1;
-
-                info!("Peer 1: {}, Peer 2: {}", inv_1_count, inv_2_count);
-            }
-
-            info!("Completed walk round {} step(s)", round);
-
-            peer_1.dump_frontier();
-            peer_2.dump_frontier();
-
-            info!(
-                "Peer 1 stats: {:?}",
-                &peer_1.network.inv_state.as_ref().unwrap().block_stats
-            );
-            info!(
-                "Peer 2 stats: {:?}",
-                &peer_2.network.inv_state.as_ref().unwrap().block_stats
-            );
-
-            let peer_1_inv = peer_2
-                .network
-                .inv_state
-                .as_ref()
-                .unwrap()
-                .block_stats
-                .get(&peer_1.to_neighbor().addr)
-                .unwrap()
-                .inv
-                .clone();
-            let peer_2_inv = peer_1
-                .network
-                .inv_state
-                .as_ref()
-                .unwrap()
-                .block_stats
-                .get(&peer_2.to_neighbor().addr)
-                .unwrap()
-                .inv
-                .clone();
-
-            info!("Peer 1 inv: {:?}", &peer_1_inv);
-            info!("Peer 2 inv: {:?}", &peer_2_inv);
-
-            info!("peer 1's view of peer 2: {:?}", &peer_2_inv);
-
-            assert_eq!(peer_2_inv.num_sortitions, num_burn_blocks);
-
-            // peer 1 should have learned that peer 2 has all the blocks
-            for i in 0..num_blocks {
-                assert!(
-                    peer_2_inv.has_ith_block(i + first_stacks_block_height),
-                    "Missing block {} (+ {})",
-                    i,
-                    first_stacks_block_height
-                );
-            }
-
-            // peer 1 should have learned that peer 2 has all the microblock streams
-            for i in 1..(num_blocks - 1) {
-                assert!(
-                    peer_2_inv.has_ith_microblock_stream(i + first_stacks_block_height),
-                    "Missing microblock {} (+ {})",
-                    i,
-                    first_stacks_block_height
-                );
-            }
-
-            let peer_1_inv = peer_2
-                .network
-                .inv_state
-                .as_ref()
-                .unwrap()
-                .block_stats
-                .get(&peer_1.to_neighbor().addr)
-                .unwrap()
-                .inv
-                .clone();
-            test_debug!("peer 2's view of peer 1: {:?}", &peer_1_inv);
-
-            assert_eq!(peer_1_inv.num_sortitions, num_burn_blocks);
-
-            // peer 2 should have learned that peer 1 has all the blocks as well
-            for i in 0..num_blocks {
-                assert!(
-                    peer_1_inv.has_ith_block(i + first_stacks_block_height),
-                    "Missing block {} (+ {})",
-                    i,
-                    first_stacks_block_height
-                );
-            }
-        })
-    }
-
-    #[test]
-    #[ignore]
-    fn test_sync_inv_2_peers_stale() {
-        with_timeout(600, || {
-            let mut peer_1_config = TestPeerConfig::new(function_name!(), 31994, 41995);
-            let mut peer_2_config = TestPeerConfig::new(function_name!(), 31995, 41996);
-
-            peer_1_config.add_neighbor(&peer_2_config.to_neighbor());
-            peer_2_config.add_neighbor(&peer_1_config.to_neighbor());
-
-            let mut peer_1 = TestPeer::new(peer_1_config);
-            let mut peer_2 = TestPeer::new(peer_2_config);
-
-            let num_blocks = (GETPOXINV_MAX_BITLEN * 2) as u64;
-            let first_stacks_block_height = {
-                let sn = SortitionDB::get_canonical_burn_chain_tip(
-                    &peer_1.sortdb.as_ref().unwrap().conn(),
-                )
-                .unwrap();
-                sn.block_height + 1
-            };
-
-            for i in 0..num_blocks {
-                let (burn_ops, stacks_block, microblocks) = peer_2.make_default_tenure();
-
-                peer_2.next_burnchain_block(burn_ops.clone());
-                peer_2.process_stacks_epoch_at_tip(&stacks_block, &microblocks);
-            }
-
-            let mut round = 0;
-            let mut inv_1_count = 0;
-            let mut inv_2_count = 0;
-
-            let mut peer_1_check = false;
-            let mut peer_2_check = false;
-
-            while !peer_1_check || !peer_2_check {
-                let _ = peer_1.step();
-                let _ = peer_2.step();
-
-                inv_1_count = match peer_1.network.inv_state {
-                    Some(ref inv) => inv.get_inv_sortitions(&peer_2.to_neighbor().addr),
-                    None => 0,
-                };
-
-                inv_2_count = match peer_2.network.inv_state {
-                    Some(ref inv) => inv.get_inv_sortitions(&peer_1.to_neighbor().addr),
-                    None => 0,
-                };
-
-                match peer_1.network.inv_state {
-                    Some(ref inv) => {
-                        info!("Peer 1 stats: {:?}", &inv.block_stats);
-                        assert_eq!(inv.get_broken_peers().len(), 0);
-                        assert_eq!(inv.get_dead_peers().len(), 0);
-                        assert_eq!(inv.get_diverged_peers().len(), 0);
-
-                        if let Some(ref peer_2_inv) =
-                            inv.block_stats.get(&peer_2.to_neighbor().addr)
-                        {
-                            if peer_2_inv.inv.num_sortitions
-                                == first_stacks_block_height
-                                    - peer_1.config.burnchain.first_block_height
-                            {
-                                for i in 0..first_stacks_block_height {
-                                    assert!(!peer_2_inv.inv.has_ith_block(i));
-                                    assert!(!peer_2_inv.inv.has_ith_microblock_stream(i));
-                                }
-                                peer_2_check = true;
-                            }
-                        }
-                    }
-                    None => {}
-                }
-
-                match peer_2.network.inv_state {
-                    Some(ref inv) => {
-                        info!("Peer 2 stats: {:?}", &inv.block_stats);
-                        assert_eq!(inv.get_broken_peers().len(), 0);
-                        assert_eq!(inv.get_dead_peers().len(), 0);
-                        assert_eq!(inv.get_diverged_peers().len(), 0);
-
-                        if let Some(ref peer_1_inv) =
-                            inv.block_stats.get(&peer_1.to_neighbor().addr)
-                        {
-                            if peer_1_inv.inv.num_sortitions
-                                == first_stacks_block_height
-                                    - peer_1.config.burnchain.first_block_height
-                            {
-                                peer_1_check = true;
-                            }
-                        }
-                    }
-                    None => {}
-                }
-
-                round += 1;
-
-                test_debug!("\n\npeer_1_check = {}, peer_2_check = {}, inv_1_count = {}, inv_2_count = {}, first_stacks_block_height = {}\n\n", peer_1_check, peer_2_check, inv_1_count, inv_2_count, first_stacks_block_height);
-            }
-
-            info!("Completed walk round {} step(s)", round);
-
-            peer_1.dump_frontier();
-            peer_2.dump_frontier();
-        })
-    }
-
-    #[test]
-    #[ignore]
-    fn test_sync_inv_2_peers_unstable() {
-        with_timeout(600, || {
-            let mut peer_1_config = TestPeerConfig::new(function_name!(), 31996, 41997);
-            let mut peer_2_config = TestPeerConfig::new(function_name!(), 31997, 41998);
-
-            let stable_confs = peer_1_config.burnchain.stable_confirmations as u64;
-
-            peer_1_config.add_neighbor(&peer_2_config.to_neighbor());
-            peer_2_config.add_neighbor(&peer_1_config.to_neighbor());
-
-            let mut peer_1 = TestPeer::new(peer_1_config);
-            let mut peer_2 = TestPeer::new(peer_2_config);
-
-            let num_blocks = (GETPOXINV_MAX_BITLEN * 2) as u64;
-
-            let first_stacks_block_height = {
-                let sn = SortitionDB::get_canonical_burn_chain_tip(
-                    &peer_1.sortdb.as_ref().unwrap().conn(),
-                )
-                .unwrap();
-                sn.block_height + 1
-            };
-
-            // only peer 2 makes progress after the point of stability.
-            for i in 0..num_blocks {
-                let (mut burn_ops, stacks_block, microblocks) = peer_2.make_default_tenure();
-
-                let (_, burn_header_hash, consensus_hash) =
-                    peer_2.next_burnchain_block(burn_ops.clone());
-                peer_2.process_stacks_epoch_at_tip(&stacks_block, &microblocks);
-
-                TestPeer::set_ops_burn_header_hash(&mut burn_ops, &burn_header_hash);
-
-                // NOTE: the nodes only differ by one block -- they agree on the same PoX vector
-                if i + 1 < num_blocks {
-                    peer_1.next_burnchain_block_raw(burn_ops.clone());
-                    peer_1.process_stacks_epoch_at_tip(&stacks_block, &microblocks);
-                } else {
-                    // peer 1 diverges
-                    test_debug!("Peer 1 diverges at {}", i + first_stacks_block_height);
-                    peer_1.next_burnchain_block(vec![]);
-                }
-            }
-
-            // tips must differ
-            {
-                let sn1 = SortitionDB::get_canonical_burn_chain_tip(
-                    peer_1.sortdb.as_ref().unwrap().conn(),
-                )
-                .unwrap();
-                let sn2 = SortitionDB::get_canonical_burn_chain_tip(
-                    peer_2.sortdb.as_ref().unwrap().conn(),
-                )
-                .unwrap();
-                assert_ne!(sn1.burn_header_hash, sn2.burn_header_hash);
-            }
-
-            let num_stable_blocks = num_blocks - stable_confs;
-
-            let num_burn_blocks = {
-                let sn = SortitionDB::get_canonical_burn_chain_tip(
-                    peer_1.sortdb.as_ref().unwrap().conn(),
-                )
-                .unwrap();
-                sn.block_height + 1
-            };
-
-            let mut round = 0;
-            let mut inv_1_count = 0;
-            let mut inv_2_count = 0;
-
-            let mut peer_1_pox_cycle_start = false;
-            let mut peer_1_block_cycle_start = false;
-            let mut peer_2_pox_cycle_start = false;
-            let mut peer_2_block_cycle_start = false;
-
-            let mut peer_1_pox_cycle = false;
-            let mut peer_1_block_cycle = false;
-            let mut peer_2_pox_cycle = false;
-            let mut peer_2_block_cycle = false;
-
-            while inv_1_count < num_stable_blocks || inv_2_count < num_stable_blocks {
-                let _ = peer_1.step();
-                let _ = peer_2.step();
-
-                inv_1_count = match peer_1.network.inv_state {
-                    Some(ref inv) => inv.get_inv_num_blocks(&peer_2.to_neighbor().addr),
-                    None => 0,
-                };
-
-                inv_2_count = match peer_2.network.inv_state {
-                    Some(ref inv) => inv.get_inv_num_blocks(&peer_1.to_neighbor().addr),
-                    None => 0,
-                };
-
-                match peer_1.network.inv_state {
-                    Some(ref inv) => {
-                        info!("Peer 1 stats: {:?}", &inv.block_stats);
-                        assert_eq!(inv.get_broken_peers().len(), 0);
-                        assert_eq!(inv.get_dead_peers().len(), 0);
-                        assert_eq!(inv.get_diverged_peers().len(), 0);
-
-                        if let Some(stats) = inv.get_stats(&peer_2.to_neighbor().addr) {
-                            if stats.target_pox_reward_cycle > 0 {
-                                peer_1_pox_cycle_start = true;
-                            }
-                            if stats.target_block_reward_cycle > 0 {
-                                peer_1_block_cycle_start = true;
-                            }
-                            if stats.target_pox_reward_cycle == 0 && peer_1_pox_cycle_start {
-                                peer_1_pox_cycle = true;
-                            }
-                            if stats.target_block_reward_cycle == 0 && peer_1_block_cycle_start {
-                                peer_1_block_cycle = true;
-                            }
-                        }
-                    }
-                    None => {}
-                }
-
-                match peer_2.network.inv_state {
-                    Some(ref inv) => {
-                        info!("Peer 2 stats: {:?}", &inv.block_stats);
-                        assert_eq!(inv.get_broken_peers().len(), 0);
-                        assert_eq!(inv.get_dead_peers().len(), 0);
-                        assert_eq!(inv.get_diverged_peers().len(), 0);
-
-                        if let Some(stats) = inv.get_stats(&peer_1.to_neighbor().addr) {
-                            if stats.target_pox_reward_cycle > 0 {
-                                peer_2_pox_cycle_start = true;
-                            }
-                            if stats.target_block_reward_cycle > 0 {
-                                peer_2_block_cycle_start = true;
-                            }
-                            if stats.target_pox_reward_cycle == 0 && peer_2_pox_cycle_start {
-                                peer_2_pox_cycle = true;
-                            }
-                            if stats.target_block_reward_cycle == 0 && peer_2_block_cycle_start {
-                                peer_2_block_cycle = true;
-                            }
-                        }
-                    }
-                    None => {}
-                }
-
-                round += 1;
-
-                test_debug!(
-                    "\n\ninv_1_count = {}, inv_2_count = {}, num_stable_blocks = {}\n\n",
-                    inv_1_count,
-                    inv_2_count,
-                    num_stable_blocks
-                );
-            }
-
-            info!("Completed walk round {} step(s)", round);
-
-            peer_1.dump_frontier();
-            peer_2.dump_frontier();
-
-            let peer_2_inv = peer_1
-                .network
-                .inv_state
-                .as_ref()
-                .unwrap()
-                .block_stats
-                .get(&peer_2.to_neighbor().addr)
-                .unwrap()
-                .inv
-                .clone();
-            test_debug!("peer 1's view of peer 2: {:?}", &peer_2_inv);
-
-            let peer_1_inv = peer_2
-                .network
-                .inv_state
-                .as_ref()
-                .unwrap()
-                .block_stats
-                .get(&peer_1.to_neighbor().addr)
-                .unwrap()
-                .inv
-                .clone();
-            test_debug!("peer 2's view of peer 1: {:?}", &peer_1_inv);
-
-            assert_eq!(peer_2_inv.num_sortitions, num_burn_blocks - stable_confs);
-            assert_eq!(peer_1_inv.num_sortitions, num_burn_blocks - stable_confs);
-
-            // only 8 reward cycles -- we couldn't agree on the 9th
-            assert_eq!(peer_1_inv.pox_inv, vec![255]);
-            assert_eq!(peer_2_inv.pox_inv, vec![255]);
-
-            // peer 1 should have learned that peer 2 has all the blocks, up to the point of
-            // instability
-            for i in 0..(num_blocks - stable_confs) {
-                assert!(peer_2_inv.has_ith_block(i + first_stacks_block_height));
-                if i > 0 {
-                    assert!(peer_2_inv.has_ith_microblock_stream(i + first_stacks_block_height));
-                } else {
-                    assert!(!peer_2_inv.has_ith_microblock_stream(i + first_stacks_block_height));
-                }
-            }
-
-            for i in 0..(num_blocks - stable_confs) {
-                assert!(peer_1_inv.has_ith_block(i + first_stacks_block_height));
-            }
-
-            assert!(!peer_2_inv.has_ith_block(num_blocks - stable_confs));
-            assert!(!peer_2_inv.has_ith_microblock_stream(num_blocks - stable_confs));
-        })
-    }
-
-    #[test]
-    #[ignore]
-    fn test_sync_inv_2_peers_different_pox_vectors() {
-        with_timeout(600, || {
-            let mut peer_1_config = TestPeerConfig::new(function_name!(), 31998, 41998);
-            let mut peer_2_config = TestPeerConfig::new(function_name!(), 31999, 41999);
-
-            peer_1_config.add_neighbor(&peer_2_config.to_neighbor());
-            peer_2_config.add_neighbor(&peer_1_config.to_neighbor());
-
-            let reward_cycle_length =
-                peer_1_config.burnchain.pox_constants.reward_cycle_length as u64;
-            assert_eq!(reward_cycle_length, 5);
-
-            let mut peer_1 = TestPeer::new(peer_1_config);
-            let mut peer_2 = TestPeer::new(peer_2_config);
-
-            let num_blocks = (GETPOXINV_MAX_BITLEN * 3) as u64;
-
-            let first_stacks_block_height = {
-                let sn = SortitionDB::get_canonical_burn_chain_tip(
-                    &peer_1.sortdb.as_ref().unwrap().conn(),
-                )
-                .unwrap();
-                sn.block_height + 1
-            };
-
-            // only peer 2 makes progress after the point of stability.
-            for i in 0..num_blocks {
-                let (mut burn_ops, stacks_block, microblocks) = peer_2.make_default_tenure();
-
-                let (_, burn_header_hash, consensus_hash) =
-                    peer_2.next_burnchain_block(burn_ops.clone());
-                peer_2.process_stacks_epoch_at_tip(&stacks_block, &microblocks);
-
-                TestPeer::set_ops_burn_header_hash(&mut burn_ops, &burn_header_hash);
-
-                peer_1.next_burnchain_block_raw(burn_ops.clone());
-                if i < num_blocks - reward_cycle_length * 2 {
-                    peer_1.process_stacks_epoch_at_tip(&stacks_block, &microblocks);
-                }
-            }
-
-            let peer_1_pox_id = {
-                let tip_sort_id = SortitionDB::get_canonical_sortition_tip(
-                    peer_1.sortdb.as_ref().unwrap().conn(),
-                )
-                .unwrap();
-                let ic = peer_1.sortdb.as_ref().unwrap().index_conn();
-                let sortdb_reader = SortitionHandleConn::open_reader(&ic, &tip_sort_id).unwrap();
-                sortdb_reader.get_pox_id().unwrap()
-            };
-
-            let peer_2_pox_id = {
-                let tip_sort_id = SortitionDB::get_canonical_sortition_tip(
-                    peer_2.sortdb.as_ref().unwrap().conn(),
-                )
-                .unwrap();
-                let ic = peer_2.sortdb.as_ref().unwrap().index_conn();
-                let sortdb_reader = SortitionHandleConn::open_reader(&ic, &tip_sort_id).unwrap();
-                sortdb_reader.get_pox_id().unwrap()
-            };
-
-            // peers must have different PoX bit vectors -- peer 1 didn't see the last reward cycle
-            assert_eq!(
-                peer_1_pox_id,
-                PoxId::from_bools(vec![
-                    true, true, true, true, true, true, true, true, true, true, false
-                ])
-            );
-            assert_eq!(
-                peer_2_pox_id,
-                PoxId::from_bools(vec![
-                    true, true, true, true, true, true, true, true, true, true, true
-                ])
-            );
-
-            let num_burn_blocks = {
-                let sn = SortitionDB::get_canonical_burn_chain_tip(
-                    peer_1.sortdb.as_ref().unwrap().conn(),
-                )
-                .unwrap();
-                sn.block_height + 1
-            };
-
-            let mut round = 0;
-            let mut inv_1_count = 0;
-            let mut inv_2_count = 0;
-            let mut peer_1_sorts = 0;
-            let mut peer_2_sorts = 0;
-
-            while inv_1_count < reward_cycle_length * 4
-                || inv_2_count < num_blocks - reward_cycle_length * 2
-                || peer_1_sorts < reward_cycle_length * 9 + 1
-                || peer_2_sorts < reward_cycle_length * 9 + 1
-            {
-                let _ = peer_1.step();
-                let _ = peer_2.step();
-
-                // peer 1 should see that peer 2 has all blocks for reward cycles 5 through 9
-                match peer_1.network.inv_state {
-                    Some(ref inv) => {
-                        inv_1_count = inv.get_inv_num_blocks(&peer_2.to_neighbor().addr);
-                        peer_1_sorts = inv.get_inv_sortitions(&peer_2.to_neighbor().addr);
-                    }
-                    None => {}
-                };
-
-                // peer 2 should see that peer 1 has all blocks up to where we stopped feeding them to
-                // it
-                match peer_2.network.inv_state {
-                    Some(ref inv) => {
-                        inv_2_count = inv.get_inv_num_blocks(&peer_1.to_neighbor().addr);
-                        peer_2_sorts = inv.get_inv_sortitions(&peer_1.to_neighbor().addr);
-                    }
-                    None => {}
-                };
-
-                match peer_1.network.inv_state {
-                    Some(ref inv) => {
-                        info!("Peer 1 stats: {:?}", &inv.block_stats);
-                        assert_eq!(inv.get_broken_peers().len(), 0);
-                        assert_eq!(inv.get_dead_peers().len(), 0);
-                        assert_eq!(inv.get_diverged_peers().len(), 0);
-                    }
-                    None => {}
-                }
-
-                match peer_2.network.inv_state {
-                    Some(ref inv) => {
-                        info!("Peer 2 stats: {:?}", &inv.block_stats);
-                        assert_eq!(inv.get_broken_peers().len(), 0);
-                        assert_eq!(inv.get_dead_peers().len(), 0);
-                        assert_eq!(inv.get_diverged_peers().len(), 0);
-                    }
-                    None => {}
-                }
-
-                round += 1;
-
-                test_debug!(
-                    "\n\ninv_1_count = {} <? {}, inv_2_count = {} <? {}, peer_1_sorts = {} <? {}, peer_2_sorts = {} <? {}",
-                    inv_1_count,
-                    reward_cycle_length * 4,
-                    inv_2_count,
-                    num_blocks - reward_cycle_length * 2,
-                    peer_1_sorts,
-                    reward_cycle_length * 9 + 1,
-                    peer_2_sorts,
-                    reward_cycle_length * 9 + 1
-                );
-            }
-
-            info!("Completed walk round {} step(s)", round);
-
-            peer_1.dump_frontier();
-            peer_2.dump_frontier();
-
-            let peer_1_pox_id = {
-                let tip_sort_id = SortitionDB::get_canonical_sortition_tip(
-                    peer_1.sortdb.as_ref().unwrap().conn(),
-                )
-                .unwrap();
-                let ic = peer_1.sortdb.as_ref().unwrap().index_conn();
-                let sortdb_reader = SortitionHandleConn::open_reader(&ic, &tip_sort_id).unwrap();
-                sortdb_reader.get_pox_id().unwrap()
-            };
-
-            let peer_2_pox_id = {
-                let tip_sort_id = SortitionDB::get_canonical_sortition_tip(
-                    peer_2.sortdb.as_ref().unwrap().conn(),
-                )
-                .unwrap();
-                let ic = peer_2.sortdb.as_ref().unwrap().index_conn();
-                let sortdb_reader = SortitionHandleConn::open_reader(&ic, &tip_sort_id).unwrap();
-                sortdb_reader.get_pox_id().unwrap()
-            };
-
-            let peer_2_inv = peer_1
-                .network
-                .inv_state
-                .as_ref()
-                .unwrap()
-                .block_stats
-                .get(&peer_2.to_neighbor().addr)
-                .unwrap()
-                .inv
-                .clone();
-            test_debug!("peer 1's view of peer 2: {:?}", &peer_2_inv);
-            test_debug!("peer 1's PoX bit vector is {:?}", &peer_1_pox_id);
-
-            let peer_1_inv = peer_2
-                .network
-                .inv_state
-                .as_ref()
-                .unwrap()
-                .block_stats
-                .get(&peer_1.to_neighbor().addr)
-                .unwrap()
-                .inv
-                .clone();
-            test_debug!("peer 2's view of peer 1: {:?}", &peer_1_inv);
-            test_debug!("peer 2's PoX bit vector is {:?}", &peer_2_pox_id);
-
-            // nodes only learn about the prefix of their PoX bit vectors that they agree on
-            assert_eq!(peer_2_inv.num_sortitions, reward_cycle_length * 9 + 1);
-            assert_eq!(peer_1_inv.num_sortitions, reward_cycle_length * 9 + 1);
-
-            // only 9 reward cycles -- we couldn't agree on the 10th
-            assert_eq!(peer_1_inv.pox_inv, vec![255, 1]);
-            assert_eq!(peer_2_inv.pox_inv, vec![255, 1]);
-
-            // peer 1 should have learned that peer 2 has all the blocks, up to the point of
-            // PoX instability between the two
-            for i in 0..(reward_cycle_length * 4) {
-                assert!(peer_2_inv.has_ith_block(i + first_stacks_block_height));
-                if i > 0 {
-                    assert!(peer_2_inv.has_ith_microblock_stream(i + first_stacks_block_height));
-                } else {
-                    assert!(!peer_2_inv.has_ith_microblock_stream(i + first_stacks_block_height));
-                }
-            }
-
-            // peer 2 should have learned about all of peer 1's blocks
-            for i in 0..(num_blocks - 2 * reward_cycle_length) {
-                assert!(peer_1_inv.has_ith_block(i + first_stacks_block_height));
-                if i > 0 && i != num_blocks - 2 * reward_cycle_length - 1 {
-                    // peer 1 doesn't have the final microblock stream, since no anchor block confirmed it
-                    assert!(peer_1_inv.has_ith_microblock_stream(i + first_stacks_block_height));
-                }
-            }
-
-            assert!(!peer_1_inv.has_ith_block(reward_cycle_length * 4));
-            assert!(!peer_1_inv.has_ith_microblock_stream(reward_cycle_length * 4));
-
-            assert!(!peer_2_inv.has_ith_block(num_blocks - 2 * reward_cycle_length));
-            assert!(!peer_2_inv.has_ith_microblock_stream(num_blocks - 2 * reward_cycle_length));
-        })
-    }
-}
+mod test {}
diff --git a/stackslib/src/net/inv/mod.rs b/stackslib/src/net/inv/mod.rs
new file mode 100644
index 0000000000..6bb5f9e88d
--- /dev/null
+++ b/stackslib/src/net/inv/mod.rs
@@ -0,0 +1,26 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020-2023 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+pub mod epoch2x;
+pub mod nakamoto;
+
+#[cfg(test)]
+pub mod tests;
+
+// Stacks 2.x inventory state machine
+pub use crate::net::inv::epoch2x as inv2x;
+
+pub use inv2x::{INV_REWARD_CYCLES, INV_SYNC_INTERVAL};
diff --git a/stackslib/src/net/inv/tests/epoch2x.rs b/stackslib/src/net/inv/tests/epoch2x.rs
new file mode 100644
index 0000000000..9862024f4a
--- /dev/null
+++ b/stackslib/src/net/inv/tests/epoch2x.rs
@@ -0,0 +1,1990 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020-2023 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+use std::collections::HashMap;
+
+use stacks_common::deps_common::bitcoin::network::serialize::BitcoinHash;
+
+use crate::burnchains::bitcoin::indexer::BitcoinIndexer;
+use crate::burnchains::db::BurnchainHeaderReader;
+use crate::burnchains::tests::BURNCHAIN_TEST_BLOCK_TIME;
+use crate::burnchains::Burnchain;
+use crate::burnchains::BurnchainView;
+use crate::burnchains::{BurnchainBlockHeader, PoxConstants};
+use crate::chainstate::burn::db::sortdb::SortitionHandleConn;
+use crate::chainstate::coordinator::tests::get_burnchain;
+use crate::chainstate::stacks::*;
+use crate::net::chat::ConversationP2P;
+use crate::net::inv::inv2x::*;
+use crate::net::test::*;
+use crate::net::Error as net_error;
+use crate::net::*;
+use crate::util_lib::test::*;
+
+#[test]
+fn peerblocksinv_has_ith_block() {
+    let peer_inv = PeerBlocksInv::new(vec![0x55, 0x77], vec![0x11, 0x22], vec![0x01], 16, 1, 12345);
+    let has_blocks = vec![
+        true, false, true, false, true, false, true, false, true, true, true, false, true, true,
+        true, false,
+    ];
+    let has_microblocks = vec![
+        true, false, false, false, true, false, false, false, false, true, false, false, false,
+        true, false, false,
+    ];
+
+    assert!(!peer_inv.has_ith_block(12344));
+    assert!(!peer_inv.has_ith_block(12345 + 17));
+
+    assert!(!peer_inv.has_ith_microblock_stream(12344));
+    assert!(!peer_inv.has_ith_microblock_stream(12345 + 17));
+
+    for i in 0..16 {
+        assert_eq!(has_blocks[i], peer_inv.has_ith_block((12345 + i) as u64));
+        assert_eq!(
+            has_microblocks[i],
+            peer_inv.has_ith_microblock_stream((12345 + i) as u64)
+        );
+    }
+}
+
+#[test]
+fn peerblocksinv_merge() {
+    let peer_inv = PeerBlocksInv::new(
+        vec![0x00, 0x00, 0x55, 0x77],
+        vec![0x00, 0x00, 0x55, 0x77],
+        vec![0x01],
+        32,
+        1,
+        12345,
+    );
+
+    // merge below, aligned
+    let mut peer_inv_below = peer_inv.clone();
+    let (new_blocks, new_microblocks) =
+        peer_inv_below.merge_blocks_inv(12345, 16, vec![0x11, 0x22], vec![0x11, 0x22], false);
+    assert_eq!(new_blocks, 4);
+    assert_eq!(new_microblocks, 4);
+    assert_eq!(peer_inv_below.num_sortitions, 32);
+    assert_eq!(peer_inv_below.block_inv, vec![0x11, 0x22, 0x55, 0x77]);
+    assert_eq!(peer_inv_below.microblocks_inv, vec![0x11, 0x22, 0x55, 0x77]);
+
+    // merge below, overlapping, aligned
+    let mut peer_inv_below_overlap = peer_inv.clone();
+    let (new_blocks, new_microblocks) = peer_inv_below_overlap.merge_blocks_inv(
+        12345 + 8,
+        16,
+        vec![0x11, 0x22],
+        vec![0x11, 0x22],
+        false,
+    );
+    assert_eq!(new_blocks, 4);
+    assert_eq!(new_microblocks, 4);
+    assert_eq!(peer_inv_below_overlap.num_sortitions, 32);
+    assert_eq!(
+        peer_inv_below_overlap.block_inv,
+        vec![0x00, 0x11, 0x22 | 0x55, 0x77]
+    );
+    assert_eq!(
+        peer_inv_below_overlap.microblocks_inv,
+        vec![0x00, 0x11, 0x22 | 0x55, 0x77]
+    );
+
+    // merge equal, overlapping, aligned
+    let mut peer_inv_equal = peer_inv.clone();
+    let (new_blocks, new_microblocks) =
+        peer_inv_equal.merge_blocks_inv(12345 + 16, 16, vec![0x11, 0x22], vec![0x11, 0x22], false);
+    assert_eq!(new_blocks, 0);
+    assert_eq!(new_microblocks, 0);
+    assert_eq!(peer_inv_equal.num_sortitions, 32);
+    assert_eq!(
+        peer_inv_equal.block_inv,
+        vec![0x00, 0x00, 0x11 | 0x55, 0x22 | 0x77]
+    );
+    assert_eq!(
+        peer_inv_equal.microblocks_inv,
+        vec![0x00, 0x00, 0x11 | 0x55, 0x22 | 0x77]
+    );
+
+    // merge above, overlapping, aligned
+    let mut peer_inv_above_overlap = peer_inv.clone();
+    let (new_blocks, new_microblocks) = peer_inv_above_overlap.merge_blocks_inv(
+        12345 + 24,
+        16,
+        vec![0x11, 0x22],
+        vec![0x11, 0x22],
+        false,
+    );
+    assert_eq!(new_blocks, 2);
+    assert_eq!(new_microblocks, 2);
+    assert_eq!(peer_inv_above_overlap.num_sortitions, 40);
+    assert_eq!(
+        peer_inv_above_overlap.block_inv,
+        vec![0x00, 0x00, 0x55, 0x77 | 0x11, 0x22]
+    );
+    assert_eq!(
+        peer_inv_above_overlap.microblocks_inv,
+        vec![0x00, 0x00, 0x55, 0x77 | 0x11, 0x22]
+    );
+
+    // merge above, non-overlapping, aligned
+    let mut peer_inv_above = peer_inv.clone();
+    let (new_blocks, new_microblocks) =
+        peer_inv_above.merge_blocks_inv(12345 + 32, 16, vec![0x11, 0x22], vec![0x11, 0x22], false);
+    assert_eq!(peer_inv_above.num_sortitions, 48);
+    assert_eq!(new_blocks, 4);
+    assert_eq!(new_microblocks, 4);
+    assert_eq!(
+        peer_inv_above.block_inv,
+        vec![0x00, 0x00, 0x55, 0x77, 0x11, 0x22]
+    );
+    assert_eq!(
+        peer_inv_above.microblocks_inv,
+        vec![0x00, 0x00, 0x55, 0x77, 0x11, 0x22]
+    );
+
+    // try merging unaligned
+    let mut peer_inv = PeerBlocksInv::new(
+        vec![0x00, 0x00, 0x00, 0x00],
+        vec![0x00, 0x00, 0x00, 0x00],
+        vec![0x01],
+        32,
+        1,
+        12345,
+    );
+    for i in 0..32 {
+        let (new_blocks, new_microblocks) =
+            peer_inv.merge_blocks_inv(12345 + i, 1, vec![0x01], vec![0x01], false);
+        assert_eq!(new_blocks, 1);
+        assert_eq!(new_microblocks, 1);
+        assert_eq!(peer_inv.num_sortitions, 32);
+        for j in 0..i + 1 {
+            assert!(peer_inv.has_ith_block(12345 + j));
+            assert!(peer_inv.has_ith_microblock_stream(12345 + j));
+        }
+        for j in i + 1..32 {
+            assert!(!peer_inv.has_ith_block(12345 + j));
+            assert!(!peer_inv.has_ith_microblock_stream(12345 + j));
+        }
+    }
+
+    // try merging unaligned, with multiple blocks
+    let mut peer_inv = PeerBlocksInv::new(
+        vec![0x00, 0x00, 0x00, 0x00],
+        vec![0x00, 0x00, 0x00, 0x00],
+        vec![0x01],
+        32,
+        1,
+        12345,
+    );
+    for i in 0..16 {
+        let (new_blocks, new_microblocks) = peer_inv.merge_blocks_inv(
+            12345 + i,
+            32,
+            vec![0x01, 0x00, 0x01, 0x00],
+            vec![0x01, 0x00, 0x01, 0x00],
+            false,
+        );
+        assert_eq!(new_blocks, 2);
+        assert_eq!(new_microblocks, 2);
+        assert_eq!(peer_inv.num_sortitions, 32 + i);
+        for j in 0..i + 1 {
+            assert!(peer_inv.has_ith_block(12345 + j));
+            assert!(peer_inv.has_ith_block(12345 + j + 16));
+
+            assert!(peer_inv.has_ith_microblock_stream(12345 + j));
+            assert!(peer_inv.has_ith_microblock_stream(12345 + j + 16));
+        }
+        for j in i + 1..16 {
+            assert!(!peer_inv.has_ith_block(12345 + j));
+            assert!(!peer_inv.has_ith_block(12345 + j + 16));
+
+            assert!(!peer_inv.has_ith_microblock_stream(12345 + j));
+            assert!(!peer_inv.has_ith_microblock_stream(12345 + j + 16));
+        }
+    }
+
+    // merge 0's grows the bitvec
+    let mut peer_inv = PeerBlocksInv::new(
+        vec![0x00, 0x00, 0x00, 0x00],
+        vec![0x00, 0x00, 0x00, 0x00],
+        vec![0x01],
+        32,
+        1,
+        12345,
+    );
+    let (new_blocks, new_microblocks) =
+        peer_inv.merge_blocks_inv(12345 + 24, 16, vec![0x00, 0x00], vec![0x00, 0x00], false);
+    assert_eq!(new_blocks, 0);
+    assert_eq!(new_microblocks, 0);
+    assert_eq!(peer_inv.num_sortitions, 40);
+    assert_eq!(peer_inv.block_inv, vec![0x00, 0x00, 0x00, 0x00, 0x00]);
+    assert_eq!(peer_inv.microblocks_inv, vec![0x00, 0x00, 0x00, 0x00, 0x00]);
+}
+
+#[test]
+fn peerblocksinv_merge_clear_bits() {
+    let peer_inv = PeerBlocksInv::new(
+        vec![0x00, 0x00, 0x55, 0x77],
+        vec![0x00, 0x00, 0x55, 0x77],
+        vec![0x01],
+        32,
+        1,
+        12345,
+    );
+
+    // merge below, aligned
+    let mut peer_inv_below = peer_inv.clone();
+    let (new_blocks, new_microblocks) =
+        peer_inv_below.merge_blocks_inv(12345, 16, vec![0x11, 0x22], vec![0x11, 0x22], true);
+    assert_eq!(new_blocks, 4);
+    assert_eq!(new_microblocks, 4);
+    assert_eq!(peer_inv_below.num_sortitions, 32);
+    assert_eq!(peer_inv_below.block_inv, vec![0x11, 0x22, 0x55, 0x77]);
+    assert_eq!(peer_inv_below.microblocks_inv, vec![0x11, 0x22, 0x55, 0x77]);
+
+    // merge below, overlapping, aligned
+    let mut peer_inv_below_overlap = peer_inv.clone();
+    let (new_blocks, new_microblocks) = peer_inv_below_overlap.merge_blocks_inv(
+        12345 + 8,
+        16,
+        vec![0x11, 0x22],
+        vec![0x11, 0x22],
+        true,
+    );
+    assert_eq!(new_blocks, 4);
+    assert_eq!(new_microblocks, 4);
+    assert_eq!(peer_inv_below_overlap.num_sortitions, 32);
+    assert_eq!(
+        peer_inv_below_overlap.block_inv,
+        vec![0x00, 0x11, 0x22, 0x77]
+    );
+    assert_eq!(
+        peer_inv_below_overlap.microblocks_inv,
+        vec![0x00, 0x11, 0x22, 0x77]
+    );
+
+    // merge equal, overlapping, aligned
+    let mut peer_inv_equal = peer_inv.clone();
+    let (new_blocks, new_microblocks) =
+        peer_inv_equal.merge_blocks_inv(12345 + 16, 16, vec![0x11, 0x22], vec![0x11, 0x22], true);
+    assert_eq!(new_blocks, 0);
+    assert_eq!(new_microblocks, 0);
+    assert_eq!(peer_inv_equal.num_sortitions, 32);
+    assert_eq!(peer_inv_equal.block_inv, vec![0x00, 0x00, 0x11, 0x22]);
+    assert_eq!(peer_inv_equal.microblocks_inv, vec![0x00, 0x00, 0x11, 0x22]);
+
+    // merge above, overlapping, aligned
+    let mut peer_inv_above_overlap = peer_inv.clone();
+    let (new_blocks, new_microblocks) = peer_inv_above_overlap.merge_blocks_inv(
+        12345 + 24,
+        16,
+        vec![0x11, 0x22],
+        vec![0x11, 0x22],
+        true,
+    );
+    assert_eq!(new_blocks, 2);
+    assert_eq!(new_microblocks, 2);
+    assert_eq!(peer_inv_above_overlap.num_sortitions, 40);
+    assert_eq!(
+        peer_inv_above_overlap.block_inv,
+        vec![0x00, 0x00, 0x55, 0x11, 0x22]
+    );
+    assert_eq!(
+        peer_inv_above_overlap.microblocks_inv,
+        vec![0x00, 0x00, 0x55, 0x11, 0x22]
+    );
+
+    // merge above, non-overlapping, aligned
+    let mut peer_inv_above = peer_inv.clone();
+    let (new_blocks, new_microblocks) =
+        peer_inv_above.merge_blocks_inv(12345 + 32, 16, vec![0x11, 0x22], vec![0x11, 0x22], true);
+    assert_eq!(peer_inv_above.num_sortitions, 48);
+    assert_eq!(new_blocks, 4);
+    assert_eq!(new_microblocks, 4);
+    assert_eq!(
+        peer_inv_above.block_inv,
+        vec![0x00, 0x00, 0x55, 0x77, 0x11, 0x22]
+    );
+    assert_eq!(
+        peer_inv_above.microblocks_inv,
+        vec![0x00, 0x00, 0x55, 0x77, 0x11, 0x22]
+    );
+
+    // try merging unaligned
+    let mut peer_inv = PeerBlocksInv::new(
+        vec![0x00, 0x00, 0x00, 0x00],
+        vec![0x00, 0x00, 0x00, 0x00],
+        vec![0x01],
+        32,
+        1,
+        12345,
+    );
+    for i in 0..32 {
+        let (new_blocks, new_microblocks) =
+            peer_inv.merge_blocks_inv(12345 + i, 1, vec![0x01], vec![0x01], true);
+        assert_eq!(new_blocks, 1);
+        assert_eq!(new_microblocks, 1);
+        assert_eq!(peer_inv.num_sortitions, 32);
+        for j in 0..i + 1 {
+            assert!(peer_inv.has_ith_block(12345 + j));
+            assert!(peer_inv.has_ith_microblock_stream(12345 + j));
+        }
+        for j in i + 1..32 {
+            assert!(!peer_inv.has_ith_block(12345 + j));
+            assert!(!peer_inv.has_ith_microblock_stream(12345 + j));
+        }
+    }
+
+    // try merging unaligned, with multiple blocks
+    let mut peer_inv = PeerBlocksInv::new(
+        vec![0x00, 0x00, 0x00, 0x00],
+        vec![0x00, 0x00, 0x00, 0x00],
+        vec![0x01],
+        32,
+        1,
+        12345,
+    );
+    for i in 0..16 {
+        let (new_blocks, new_microblocks) = peer_inv.merge_blocks_inv(
+            12345 + i,
+            32,
+            vec![0x01, 0x00, 0x01, 0x00],
+            vec![0x01, 0x00, 0x01, 0x00],
+            true,
+        );
+        assert_eq!(new_blocks, 2);
+        assert_eq!(new_microblocks, 2);
+        assert_eq!(peer_inv.num_sortitions, 32 + i);
+        for j in 0..i {
+            assert!(peer_inv.has_ith_block(12345 + j));
+            assert!(!peer_inv.has_ith_block(12345 + j + 16));
+
+            assert!(peer_inv.has_ith_microblock_stream(12345 + j));
+            assert!(!peer_inv.has_ith_microblock_stream(12345 + j + 16));
+        }
+
+        assert!(peer_inv.has_ith_block(12345 + i));
+        assert!(peer_inv.has_ith_block(12345 + i + 16));
+
+        assert!(peer_inv.has_ith_microblock_stream(12345 + i));
+        assert!(peer_inv.has_ith_microblock_stream(12345 + i + 16));
+
+        for j in i + 1..16 {
+            assert!(!peer_inv.has_ith_block(12345 + j));
+            assert!(!peer_inv.has_ith_block(12345 + j + 16));
+
+            assert!(!peer_inv.has_ith_microblock_stream(12345 + j));
+            assert!(!peer_inv.has_ith_microblock_stream(12345 + j + 16));
+        }
+    }
+
+    // merge 0's grows the bitvec
+    let mut peer_inv = PeerBlocksInv::new(
+        vec![0x00, 0x00, 0x00, 0x00],
+        vec![0x00, 0x00, 0x00, 0x00],
+        vec![0x01],
+        32,
+        1,
+        12345,
+    );
+    let (new_blocks, new_microblocks) =
+        peer_inv.merge_blocks_inv(12345 + 24, 16, vec![0x00, 0x00], vec![0x00, 0x00], true);
+    assert_eq!(new_blocks, 0);
+    assert_eq!(new_microblocks, 0);
+    assert_eq!(peer_inv.num_sortitions, 40);
+    assert_eq!(peer_inv.block_inv, vec![0x00, 0x00, 0x00, 0x00, 0x00]);
+    assert_eq!(peer_inv.microblocks_inv, vec![0x00, 0x00, 0x00, 0x00, 0x00]);
+}
+
+#[test]
+fn test_inv_set_block_microblock_bits() {
+    let mut peer_inv = PeerBlocksInv::new(vec![0x01], vec![0x01], vec![0x01], 1, 1, 12345);
+
+    assert!(peer_inv.set_block_bit(12345 + 1));
+    assert_eq!(peer_inv.block_inv, vec![0x03]);
+    assert_eq!(peer_inv.num_sortitions, 2);
+    assert!(!peer_inv.set_block_bit(12345 + 1));
+    assert_eq!(peer_inv.block_inv, vec![0x03]);
+    assert_eq!(peer_inv.num_sortitions, 2);
+
+    assert!(peer_inv.set_microblocks_bit(12345 + 1));
+    assert_eq!(peer_inv.microblocks_inv, vec![0x03]);
+    assert_eq!(peer_inv.num_sortitions, 2);
+    assert!(!peer_inv.set_microblocks_bit(12345 + 1));
+    assert_eq!(peer_inv.microblocks_inv, vec![0x03]);
+    assert_eq!(peer_inv.num_sortitions, 2);
+
+    assert!(peer_inv.set_block_bit(12345 + 1 + 16));
+    assert_eq!(peer_inv.block_inv, vec![0x03, 0x00, 0x02]);
+    assert_eq!(peer_inv.microblocks_inv, vec![0x03, 0x00, 0x00]);
+    assert_eq!(peer_inv.num_sortitions, 18);
+    assert!(!peer_inv.set_block_bit(12345 + 1 + 16));
+    assert_eq!(peer_inv.block_inv, vec![0x03, 0x00, 0x02]);
+    assert_eq!(peer_inv.microblocks_inv, vec![0x03, 0x00, 0x00]);
+    assert_eq!(peer_inv.num_sortitions, 18);
+
+    assert!(peer_inv.set_microblocks_bit(12345 + 1 + 32));
+    assert_eq!(peer_inv.block_inv, vec![0x03, 0x00, 0x02, 0x00, 0x00]);
+    assert_eq!(peer_inv.microblocks_inv, vec![0x03, 0x00, 0x00, 0x00, 0x02]);
+    assert_eq!(peer_inv.num_sortitions, 34);
+    assert!(!peer_inv.set_microblocks_bit(12345 + 1 + 32));
+    assert_eq!(peer_inv.block_inv, vec![0x03, 0x00, 0x02, 0x00, 0x00]);
+    assert_eq!(peer_inv.microblocks_inv, vec![0x03, 0x00, 0x00, 0x00, 0x02]);
+    assert_eq!(peer_inv.num_sortitions, 34);
+}
+
+#[test]
+fn test_inv_merge_pox_inv() {
+    let mut burnchain = Burnchain::regtest("unused");
+    burnchain.pox_constants = PoxConstants::new(
+        5,
+        3,
+        3,
+        25,
+        5,
+        u64::MAX,
+        u64::MAX,
+        u32::MAX,
+        u32::MAX,
+        u32::MAX,
+        u32::MAX,
+        u32::MAX,
+    );
+
+    let mut peer_inv = PeerBlocksInv::new(vec![0x01], vec![0x01], vec![0x01], 1, 1, 0);
+    for i in 0..32 {
+        let bit_flipped = peer_inv
+            .merge_pox_inv(&burnchain, i + 1, 1, vec![0x01], false)
+            .unwrap();
+        assert_eq!(bit_flipped, i + 1);
+        assert_eq!(peer_inv.num_reward_cycles, i + 2);
+    }
+
+    assert_eq!(peer_inv.pox_inv, vec![0xff, 0xff, 0xff, 0xff, 0x01]);
+    assert_eq!(peer_inv.num_reward_cycles, 33);
+}
+
+#[test]
+fn test_inv_truncate_pox_inv() {
+    let mut burnchain = Burnchain::regtest("unused");
+    burnchain.pox_constants = PoxConstants::new(
+        5,
+        3,
+        3,
+        25,
+        5,
+        u64::MAX,
+        u64::MAX,
+        u32::MAX,
+        u32::MAX,
+        u32::MAX,
+        u32::MAX,
+        u32::MAX,
+    );
+
+    let mut peer_inv = PeerBlocksInv::new(vec![0x01], vec![0x01], vec![0x01], 1, 1, 0);
+    for i in 0..5 {
+        let bit_flipped_opt = peer_inv.merge_pox_inv(&burnchain, i + 1, 1, vec![0x00], false);
+        assert!(bit_flipped_opt.is_none());
+        assert_eq!(peer_inv.num_reward_cycles, i + 2);
+    }
+
+    assert_eq!(peer_inv.pox_inv, vec![0x01]); // 0000 0001
+    assert_eq!(peer_inv.num_reward_cycles, 6);
+
+    for i in 0..(6 * burnchain.pox_constants.reward_cycle_length) {
+        peer_inv.set_block_bit(i as u64);
+        peer_inv.set_microblocks_bit(i as u64);
+    }
+
+    // 30 bits set, since the reward cycle is 5 blocks long
+    assert_eq!(peer_inv.block_inv, vec![0xff, 0xff, 0xff, 0x3f]);
+    assert_eq!(peer_inv.microblocks_inv, vec![0xff, 0xff, 0xff, 0x3f]);
+    assert_eq!(
+        peer_inv.num_sortitions,
+        (6 * burnchain.pox_constants.reward_cycle_length) as u64
+    );
+
+    // PoX bit 3 flipped
+    let bit_flipped = peer_inv
+        .merge_pox_inv(&burnchain, 3, 1, vec![0x01], false)
+        .unwrap();
+    assert_eq!(bit_flipped, 3);
+
+    assert_eq!(peer_inv.pox_inv, vec![0x9]); // 0000 1001
+    assert_eq!(peer_inv.num_reward_cycles, 6);
+
+    // truncate happened -- only reward cycles 0, 1, and 2 remain (3 * 5 = 15 bits)
+    // BUT: reward cycles start on the _first_ block, so the first bit doesn't count!
+    // The expected bit vector (grouped by reward cycle) is actually 1 11111 11111 11111.
+    assert_eq!(peer_inv.block_inv, vec![0xff, 0xff, 0x00, 0x00]);
+    assert_eq!(peer_inv.microblocks_inv, vec![0xff, 0xff, 0x00, 0x00]);
+    assert_eq!(
+        peer_inv.num_sortitions,
+        (3 * burnchain.pox_constants.reward_cycle_length + 1) as u64
+    );
+}
+
+#[test]
+fn test_sync_inv_set_blocks_microblocks_available() {
+    let mut peer_1_config = TestPeerConfig::new(function_name!(), 0, 0);
+    let mut peer_2_config = TestPeerConfig::new(function_name!(), 0, 0);
+
+    let peer_1_test_path = TestPeer::make_test_path(&peer_1_config);
+    let peer_2_test_path = TestPeer::make_test_path(&peer_2_config);
+
+    let mut peer_1 = TestPeer::new(peer_1_config.clone());
+    let mut peer_2 = TestPeer::new(peer_2_config.clone());
+
+    for (test_path, burnchain) in [
+        (peer_1_test_path, &mut peer_1.config.burnchain),
+        (peer_2_test_path, &mut peer_2.config.burnchain),
+    ]
+    .iter_mut()
+    {
+        let working_dir = get_burnchain(&test_path, None).working_dir;
+
+        // pre-populate headers
+        let mut indexer = BitcoinIndexer::new_unit_test(&working_dir);
+        let now = BURNCHAIN_TEST_BLOCK_TIME;
+
+        for header_height in 1..6 {
+            let parent_hdr = indexer
+                .read_burnchain_header(header_height - 1)
+                .unwrap()
+                .unwrap();
+
+            let block_header_hash = BurnchainHeaderHash::from_bitcoin_hash(
+                &BitcoinIndexer::mock_bitcoin_header(&parent_hdr.block_hash, now as u32)
+                    .bitcoin_hash(),
+            );
+
+            let block_header = BurnchainBlockHeader {
+                block_height: header_height,
+                block_hash: block_header_hash.clone(),
+                parent_block_hash: parent_hdr.block_hash.clone(),
+                num_txs: 0,
+                timestamp: now,
+            };
+
+            test_debug!(
+                "Pre-populate block header for {}-{} ({})",
+                &block_header.block_hash,
+                &block_header.parent_block_hash,
+                block_header.block_height
+            );
+            indexer.raw_store_header(block_header.clone()).unwrap();
+        }
+
+        let hdr = indexer
+            .read_burnchain_header(burnchain.first_block_height)
+            .unwrap()
+            .unwrap();
+        burnchain.first_block_hash = hdr.block_hash;
+    }
+
+    peer_1_config.burnchain.first_block_height = 5;
+    peer_2_config.burnchain.first_block_height = 5;
+    peer_1.config.burnchain.first_block_height = 5;
+    peer_2.config.burnchain.first_block_height = 5;
+
+    assert_eq!(
+        peer_1_config.burnchain.first_block_hash,
+        peer_2_config.burnchain.first_block_hash
+    );
+
+    let burnchain = peer_1_config.burnchain.clone();
+
+    let num_blocks = 5;
+    let first_stacks_block_height = {
+        let sn = SortitionDB::get_canonical_burn_chain_tip(&peer_1.sortdb.as_ref().unwrap().conn())
+            .unwrap();
+        sn.block_height
+    };
+
+    for i in 0..num_blocks {
+        let (burn_ops, stacks_block, microblocks) = peer_2.make_default_tenure();
+
+        peer_1.next_burnchain_block(burn_ops.clone());
+        peer_2.next_burnchain_block(burn_ops.clone());
+        peer_2.process_stacks_epoch_at_tip(&stacks_block, &microblocks);
+    }
+
+    let (tip, num_burn_blocks) = {
+        let sn = SortitionDB::get_canonical_burn_chain_tip(peer_1.sortdb.as_ref().unwrap().conn())
+            .unwrap();
+        let num_burn_blocks = sn.block_height - peer_1.config.burnchain.first_block_height;
+        (sn, num_burn_blocks)
+    };
+
+    let nk = peer_1.to_neighbor().addr;
+
+    let sortdb = peer_1.sortdb.take().unwrap();
+    peer_1.network.init_inv_sync(&sortdb);
+    match peer_1.network.inv_state {
+        Some(ref mut inv) => {
+            inv.add_peer(nk.clone(), true);
+        }
+        None => {
+            panic!("No inv state");
+        }
+    };
+    peer_1.sortdb = Some(sortdb);
+
+    for i in 0..num_blocks {
+        let sortdb = peer_1.sortdb.take().unwrap();
+        let sn = {
+            let ic = sortdb.index_conn();
+            let sn = SortitionDB::get_ancestor_snapshot(
+                &ic,
+                i + 1 + first_stacks_block_height,
+                &tip.sortition_id,
+            )
+            .unwrap()
+            .unwrap();
+            eprintln!("{:?}", &sn);
+            sn
+        };
+        peer_1.sortdb = Some(sortdb);
+    }
+
+    for i in 0..num_blocks {
+        let sortdb = peer_1.sortdb.take().unwrap();
+        match peer_1.network.inv_state {
+            Some(ref mut inv) => {
+                assert!(!inv
+                    .block_stats
+                    .get(&nk)
+                    .unwrap()
+                    .inv
+                    .has_ith_block(i + first_stacks_block_height + 1));
+                assert!(!inv
+                    .block_stats
+                    .get(&nk)
+                    .unwrap()
+                    .inv
+                    .has_ith_microblock_stream(i + first_stacks_block_height + 1));
+
+                let sn = {
+                    let ic = sortdb.index_conn();
+                    let sn = SortitionDB::get_ancestor_snapshot(
+                        &ic,
+                        i + first_stacks_block_height + 1,
+                        &tip.sortition_id,
+                    )
+                    .unwrap()
+                    .unwrap();
+                    eprintln!("{:?}", &sn);
+                    sn
+                };
+
+                // non-existent consensus has
+                let sh =
+                    inv.set_block_available(&burnchain, &nk, &sortdb, &ConsensusHash([0xfe; 20]));
+                assert_eq!(Err(net_error::NotFoundError), sh);
+                assert!(!inv
+                    .block_stats
+                    .get(&nk)
+                    .unwrap()
+                    .inv
+                    .has_ith_block(i + first_stacks_block_height + 1));
+                assert!(!inv
+                    .block_stats
+                    .get(&nk)
+                    .unwrap()
+                    .inv
+                    .has_ith_microblock_stream(i + first_stacks_block_height + 1));
+
+                // existing consensus hash (mock num_reward_cycles)
+                inv.block_stats.get_mut(&nk).unwrap().inv.num_reward_cycles = 10;
+                let sh = inv
+                    .set_block_available(&burnchain, &nk, &sortdb, &sn.consensus_hash)
+                    .unwrap();
+
+                assert_eq!(
+                    Some(i + first_stacks_block_height - sortdb.first_block_height + 1),
+                    sh
+                );
+                assert!(inv
+                    .block_stats
+                    .get(&nk)
+                    .unwrap()
+                    .inv
+                    .has_ith_block(i + first_stacks_block_height + 1));
+
+                // idempotent
+                let sh = inv
+                    .set_microblocks_available(&burnchain, &nk, &sortdb, &sn.consensus_hash)
+                    .unwrap();
+
+                assert_eq!(
+                    Some(i + first_stacks_block_height - sortdb.first_block_height + 1),
+                    sh
+                );
+                assert!(inv
+                    .block_stats
+                    .get(&nk)
+                    .unwrap()
+                    .inv
+                    .has_ith_microblock_stream(i + first_stacks_block_height + 1));
+
+                assert!(inv
+                    .set_block_available(&burnchain, &nk, &sortdb, &sn.consensus_hash)
+                    .unwrap()
+                    .is_none());
+                assert!(inv
+                    .set_microblocks_available(&burnchain, &nk, &sortdb, &sn.consensus_hash)
+                    .unwrap()
+                    .is_none());
+
+                // existing consensus hash, but too far ahead (mock)
+                inv.block_stats.get_mut(&nk).unwrap().inv.num_reward_cycles = 0;
+                let sh = inv.set_block_available(&burnchain, &nk, &sortdb, &sn.consensus_hash);
+                assert_eq!(Err(net_error::NotFoundError), sh);
+
+                let sh =
+                    inv.set_microblocks_available(&burnchain, &nk, &sortdb, &sn.consensus_hash);
+                assert_eq!(Err(net_error::NotFoundError), sh);
+            }
+            None => {
+                panic!("No inv state");
+            }
+        }
+        peer_1.sortdb = Some(sortdb);
+    }
+}
+
+#[test]
+fn test_sync_inv_make_inv_messages() {
+    let peer_1_config = TestPeerConfig::new(function_name!(), 0, 0);
+
+    let indexer = BitcoinIndexer::new_unit_test(&peer_1_config.burnchain.working_dir);
+    let reward_cycle_length = peer_1_config.burnchain.pox_constants.reward_cycle_length;
+    let num_blocks = peer_1_config.burnchain.pox_constants.reward_cycle_length * 2;
+
+    assert_eq!(reward_cycle_length, 5);
+
+    let mut peer_1 = TestPeer::new(peer_1_config);
+
+    let first_stacks_block_height = {
+        let sn = SortitionDB::get_canonical_burn_chain_tip(&peer_1.sortdb.as_ref().unwrap().conn())
+            .unwrap();
+        sn.block_height
+    };
+
+    for i in 0..num_blocks {
+        let (burn_ops, stacks_block, microblocks) = peer_1.make_default_tenure();
+
+        peer_1.next_burnchain_block(burn_ops.clone());
+        peer_1.process_stacks_epoch_at_tip(&stacks_block, &microblocks);
+    }
+
+    let (tip, num_burn_blocks) = {
+        let sn = SortitionDB::get_canonical_burn_chain_tip(peer_1.sortdb.as_ref().unwrap().conn())
+            .unwrap();
+        let num_burn_blocks = sn.block_height - peer_1.config.burnchain.first_block_height;
+        (sn, num_burn_blocks)
+    };
+
+    peer_1
+        .with_network_state(|sortdb, chainstate, network, _relayer, _mempool| {
+            network.refresh_local_peer().unwrap();
+            network
+                .refresh_burnchain_view(&indexer, sortdb, chainstate, false)
+                .unwrap();
+            network.refresh_sortition_view(sortdb).unwrap();
+            Ok(())
+        })
+        .unwrap();
+
+    // simulate a getpoxinv / poxinv for one reward cycle
+    let getpoxinv_request = peer_1
+        .with_network_state(|sortdb, _chainstate, network, _relayer, _mempool| {
+            let height = network.burnchain.reward_cycle_to_block_height(1);
+            let sn = {
+                let ic = sortdb.index_conn();
+                let sn = SortitionDB::get_ancestor_snapshot(&ic, height, &tip.sortition_id)
+                    .unwrap()
+                    .unwrap();
+                sn
+            };
+            let getpoxinv = GetPoxInv {
+                consensus_hash: sn.consensus_hash,
+                num_cycles: 1,
+            };
+            Ok(getpoxinv)
+        })
+        .unwrap();
+
+    test_debug!("\n\nSend {:?}\n\n", &getpoxinv_request);
+
+    let reply = peer_1
+        .with_network_state(|sortdb, _chainstate, network, _relayer, _mempool| {
+            ConversationP2P::make_getpoxinv_response(network, sortdb, &getpoxinv_request)
+        })
+        .unwrap();
+
+    test_debug!("\n\nReply {:?}\n\n", &reply);
+
+    match reply {
+        StacksMessageType::PoxInv(poxinv) => {
+            assert_eq!(poxinv.bitlen, 1);
+            assert_eq!(poxinv.pox_bitvec, vec![0x01]);
+        }
+        x => {
+            error!("Did not get PoxInv, but got {:?}", &x);
+            assert!(false);
+        }
+    }
+
+    // simulate a getpoxinv / poxinv for several reward cycles, including more than we have
+    // (10, but only have 7)
+    let getpoxinv_request = peer_1
+        .with_network_state(|sortdb, _chainstate, network, _relayer, _mempool| {
+            let height = network.burnchain.reward_cycle_to_block_height(1);
+            let sn = {
+                let ic = sortdb.index_conn();
+                let sn = SortitionDB::get_ancestor_snapshot(&ic, height, &tip.sortition_id)
+                    .unwrap()
+                    .unwrap();
+                sn
+            };
+            let getpoxinv = GetPoxInv {
+                consensus_hash: sn.consensus_hash,
+                num_cycles: 10,
+            };
+            Ok(getpoxinv)
+        })
+        .unwrap();
+
+    test_debug!("\n\nSend {:?}\n\n", &getpoxinv_request);
+
+    let reply = peer_1
+        .with_network_state(|sortdb, _chainstate, network, _relayer, _mempool| {
+            ConversationP2P::make_getpoxinv_response(network, sortdb, &getpoxinv_request)
+        })
+        .unwrap();
+
+    test_debug!("\n\nReply {:?}\n\n", &reply);
+
+    match reply {
+        StacksMessageType::PoxInv(poxinv) => {
+            assert_eq!(poxinv.bitlen, 7); // 2 reward cycles we generated, plus 5 reward cycles when booted up (1 reward cycle = 5 blocks).  1st one is free
+            assert_eq!(poxinv.pox_bitvec, vec![0x7f]);
+        }
+        x => {
+            error!("Did not get PoxInv, but got {:?}", &x);
+            assert!(false);
+        }
+    }
+
+    // ask for a PoX vector off of an unknown consensus hash
+    let getpoxinv_request = peer_1
+        .with_network_state(|sortdb, _chainstate, network, _relayer, _mempool| {
+            let getpoxinv = GetPoxInv {
+                consensus_hash: ConsensusHash([0xaa; 20]),
+                num_cycles: 10,
+            };
+            Ok(getpoxinv)
+        })
+        .unwrap();
+
+    test_debug!("\n\nSend {:?}\n\n", &getpoxinv_request);
+
+    let reply = peer_1
+        .with_network_state(|sortdb, _chainstate, network, _relayer, _mempool| {
+            ConversationP2P::make_getpoxinv_response(network, sortdb, &getpoxinv_request)
+        })
+        .unwrap();
+
+    test_debug!("\n\nReply {:?}\n\n", &reply);
+
+    match reply {
+        StacksMessageType::Nack(nack_data) => {
+            assert_eq!(nack_data.error_code, NackErrorCodes::InvalidPoxFork);
+        }
+        x => {
+            error!("Did not get PoxInv, but got {:?}", &x);
+            assert!(false);
+        }
+    }
+
+    // ask for a getblocksinv, aligned on a reward cycle.
+    let getblocksinv_request = peer_1
+        .with_network_state(|sortdb, _chainstate, network, _relayer, _mempool| {
+            let height = network.burnchain.reward_cycle_to_block_height(
+                network
+                    .burnchain
+                    .block_height_to_reward_cycle(first_stacks_block_height)
+                    .unwrap(),
+            );
+            let sn = {
+                let ic = sortdb.index_conn();
+                let sn = SortitionDB::get_ancestor_snapshot(&ic, height, &tip.sortition_id)
+                    .unwrap()
+                    .unwrap();
+                sn
+            };
+            let getblocksinv = GetBlocksInv {
+                consensus_hash: sn.consensus_hash,
+                num_blocks: reward_cycle_length as u16,
+            };
+            Ok(getblocksinv)
+        })
+        .unwrap();
+
+    test_debug!("\n\nSend {:?}\n\n", &getblocksinv_request);
+
+    let reply = peer_1
+        .with_network_state(|sortdb, chainstate, network, _relayer, _mempool| {
+            ConversationP2P::make_getblocksinv_response(
+                network,
+                sortdb,
+                chainstate,
+                &getblocksinv_request,
+            )
+        })
+        .unwrap();
+
+    test_debug!("\n\nReply {:?}\n\n", &reply);
+
+    match reply {
+        StacksMessageType::BlocksInv(blocksinv) => {
+            assert_eq!(blocksinv.bitlen, reward_cycle_length as u16);
+            assert_eq!(blocksinv.block_bitvec, vec![0x1f]);
+            assert_eq!(blocksinv.microblocks_bitvec, vec![0x1e]);
+        }
+        x => {
+            error!("Did not get BlocksInv, but got {:?}", &x);
+            assert!(false);
+        }
+    };
+
+    // ask for a getblocksinv, right at the first Stacks block height
+    let getblocksinv_request = peer_1
+        .with_network_state(|sortdb, _chainstate, network, _relayer, _mempool| {
+            let height = network.burnchain.reward_cycle_to_block_height(
+                network
+                    .burnchain
+                    .block_height_to_reward_cycle(first_stacks_block_height)
+                    .unwrap(),
+            );
+            test_debug!("Ask for inv at height {}", height);
+            let sn = {
+                let ic = sortdb.index_conn();
+                let sn = SortitionDB::get_ancestor_snapshot(&ic, height, &tip.sortition_id)
+                    .unwrap()
+                    .unwrap();
+                sn
+            };
+            let getblocksinv = GetBlocksInv {
+                consensus_hash: sn.consensus_hash,
+                num_blocks: reward_cycle_length as u16,
+            };
+            Ok(getblocksinv)
+        })
+        .unwrap();
+
+    test_debug!("\n\nSend {:?}\n\n", &getblocksinv_request);
+
+    let reply = peer_1
+        .with_network_state(|sortdb, chainstate, network, _relayer, _mempool| {
+            ConversationP2P::make_getblocksinv_response(
+                network,
+                sortdb,
+                chainstate,
+                &getblocksinv_request,
+            )
+        })
+        .unwrap();
+
+    test_debug!("\n\nReply {:?}\n\n", &reply);
+
+    match reply {
+        StacksMessageType::BlocksInv(blocksinv) => {
+            assert_eq!(blocksinv.bitlen, reward_cycle_length as u16);
+            assert_eq!(blocksinv.block_bitvec, vec![0x1f]);
+            assert_eq!(blocksinv.microblocks_bitvec, vec![0x1e]);
+        }
+        x => {
+            error!("Did not get Nack, but got {:?}", &x);
+            assert!(false);
+        }
+    };
+
+    // ask for a getblocksinv, prior to the first Stacks block height
+    let getblocksinv_request = peer_1
+        .with_network_state(|sortdb, _chainstate, network, _relayer, _mempool| {
+            let height = network.burnchain.reward_cycle_to_block_height(
+                network
+                    .burnchain
+                    .block_height_to_reward_cycle(first_stacks_block_height)
+                    .unwrap()
+                    - 1,
+            );
+            test_debug!("Ask for inv at height {}", height);
+            let sn = {
+                let ic = sortdb.index_conn();
+                let sn = SortitionDB::get_ancestor_snapshot(&ic, height, &tip.sortition_id)
+                    .unwrap()
+                    .unwrap();
+                sn
+            };
+            let getblocksinv = GetBlocksInv {
+                consensus_hash: sn.consensus_hash,
+                num_blocks: reward_cycle_length as u16,
+            };
+            Ok(getblocksinv)
+        })
+        .unwrap();
+
+    test_debug!("\n\nSend {:?}\n\n", &getblocksinv_request);
+
+    let reply = peer_1
+        .with_network_state(|sortdb, chainstate, network, _relayer, _mempool| {
+            ConversationP2P::make_getblocksinv_response(
+                network,
+                sortdb,
+                chainstate,
+                &getblocksinv_request,
+            )
+        })
+        .unwrap();
+
+    test_debug!("\n\nReply {:?}\n\n", &reply);
+
+    match reply {
+        StacksMessageType::BlocksInv(blocksinv) => {
+            assert_eq!(blocksinv.bitlen, reward_cycle_length as u16);
+            assert_eq!(blocksinv.block_bitvec, vec![0x0]);
+            assert_eq!(blocksinv.microblocks_bitvec, vec![0x0]);
+        }
+        x => {
+            error!("Did not get BlocksInv, but got {:?}", &x);
+            assert!(false);
+        }
+    };
+
+    // ask for a getblocksinv, unaligned to a reward cycle
+    let getblocksinv_request = peer_1
+        .with_network_state(|sortdb, _chainstate, network, _relayer, _mempool| {
+            let height = network.burnchain.reward_cycle_to_block_height(
+                network
+                    .burnchain
+                    .block_height_to_reward_cycle(first_stacks_block_height)
+                    .unwrap(),
+            ) + 1;
+            let sn = {
+                let ic = sortdb.index_conn();
+                let sn = SortitionDB::get_ancestor_snapshot(&ic, height, &tip.sortition_id)
+                    .unwrap()
+                    .unwrap();
+                sn
+            };
+            let getblocksinv = GetBlocksInv {
+                consensus_hash: sn.consensus_hash,
+                num_blocks: reward_cycle_length as u16,
+            };
+            Ok(getblocksinv)
+        })
+        .unwrap();
+
+    test_debug!("\n\nSend {:?}\n\n", &getblocksinv_request);
+
+    let reply = peer_1
+        .with_network_state(|sortdb, chainstate, network, _relayer, _mempool| {
+            ConversationP2P::make_getblocksinv_response(
+                network,
+                sortdb,
+                chainstate,
+                &getblocksinv_request,
+            )
+        })
+        .unwrap();
+
+    test_debug!("\n\nReply {:?}\n\n", &reply);
+
+    match reply {
+        StacksMessageType::Nack(nack_data) => {
+            assert_eq!(nack_data.error_code, NackErrorCodes::InvalidPoxFork);
+        }
+        x => {
+            error!("Did not get Nack, but got {:?}", &x);
+            assert!(false);
+        }
+    };
+
+    // ask for a getblocksinv, for an unknown consensus hash
+    let getblocksinv_request = peer_1
+        .with_network_state(|sortdb, _chainstate, network, _relayer, _mempool| {
+            let getblocksinv = GetBlocksInv {
+                consensus_hash: ConsensusHash([0xaa; 20]),
+                num_blocks: reward_cycle_length as u16,
+            };
+            Ok(getblocksinv)
+        })
+        .unwrap();
+
+    test_debug!("\n\nSend {:?}\n\n", &getblocksinv_request);
+
+    let reply = peer_1
+        .with_network_state(|sortdb, chainstate, network, _relayer, _mempool| {
+            ConversationP2P::make_getblocksinv_response(
+                network,
+                sortdb,
+                chainstate,
+                &getblocksinv_request,
+            )
+        })
+        .unwrap();
+
+    test_debug!("\n\nReply {:?}\n\n", &reply);
+
+    match reply {
+        StacksMessageType::Nack(nack_data) => {
+            assert_eq!(nack_data.error_code, NackErrorCodes::NoSuchBurnchainBlock);
+        }
+        x => {
+            error!("Did not get Nack, but got {:?}", &x);
+            assert!(false);
+        }
+    };
+}
+
+#[test]
+fn test_sync_inv_diagnose_nack() {
+    let peer_config = TestPeerConfig::new(function_name!(), 0, 0);
+    let neighbor = peer_config.to_neighbor();
+    let neighbor_key = neighbor.addr.clone();
+    let nack_no_block = NackData {
+        error_code: NackErrorCodes::NoSuchBurnchainBlock,
+    };
+
+    let mut burnchain_view = BurnchainView {
+        burn_block_height: 12346,
+        burn_block_hash: BurnchainHeaderHash([0x11; 32]),
+        burn_stable_block_height: 12340,
+        burn_stable_block_hash: BurnchainHeaderHash([0x22; 32]),
+        last_burn_block_hashes: HashMap::new(),
+        rc_consensus_hash: ConsensusHash([0x33; 20]),
+    };
+
+    burnchain_view.make_test_data();
+    let ch_12345 = burnchain_view
+        .last_burn_block_hashes
+        .get(&12345)
+        .unwrap()
+        .clone();
+    let ch_12340 = burnchain_view
+        .last_burn_block_hashes
+        .get(&12340)
+        .unwrap()
+        .clone();
+    let ch_12341 = burnchain_view
+        .last_burn_block_hashes
+        .get(&12341)
+        .unwrap()
+        .clone();
+    let ch_12339 = burnchain_view
+        .last_burn_block_hashes
+        .get(&12339)
+        .unwrap()
+        .clone();
+    let ch_12334 = burnchain_view
+        .last_burn_block_hashes
+        .get(&12334)
+        .unwrap()
+        .clone();
+
+    // should be stable; but got nacked (so this would be inappropriate)
+    assert_eq!(
+        NodeStatus::Diverged,
+        NeighborBlockStats::diagnose_nack(
+            &neighbor_key,
+            nack_no_block.clone(),
+            &burnchain_view,
+            12346,
+            12340,
+            &BurnchainHeaderHash([0x11; 32]),
+            &BurnchainHeaderHash([0x22; 32]),
+            false
+        )
+    );
+
+    assert_eq!(
+        NodeStatus::Diverged,
+        NeighborBlockStats::diagnose_nack(
+            &neighbor_key,
+            nack_no_block.clone(),
+            &burnchain_view,
+            12346,
+            12340,
+            &BurnchainHeaderHash([0x11; 32]),
+            &BurnchainHeaderHash([0x22; 32]),
+            true
+        )
+    );
+
+    // should be stale
+    assert_eq!(
+        NodeStatus::Stale,
+        NeighborBlockStats::diagnose_nack(
+            &neighbor_key,
+            nack_no_block.clone(),
+            &burnchain_view,
+            12345,
+            12339,
+            &ch_12345.clone(),
+            &ch_12339.clone(),
+            false
+        )
+    );
+
+    // should be diverged -- different stable burn block hash
+    assert_eq!(
+        NodeStatus::Diverged,
+        NeighborBlockStats::diagnose_nack(
+            &neighbor_key,
+            nack_no_block.clone(),
+            &burnchain_view,
+            12346,
+            12340,
+            &BurnchainHeaderHash([0x12; 32]),
+            &BurnchainHeaderHash([0x23; 32]),
+            false
+        )
+    );
+}
+
+#[test]
+#[ignore]
+fn test_sync_inv_2_peers_plain() {
+    with_timeout(600, || {
+        let mut peer_1_config = TestPeerConfig::new(function_name!(), 0, 0);
+        let mut peer_2_config = TestPeerConfig::new(function_name!(), 0, 0);
+
+        peer_1_config.add_neighbor(&peer_2_config.to_neighbor());
+        peer_2_config.add_neighbor(&peer_1_config.to_neighbor());
+
+        let mut peer_1 = TestPeer::new(peer_1_config);
+        let mut peer_2 = TestPeer::new(peer_2_config);
+
+        let num_blocks = (GETPOXINV_MAX_BITLEN * 2) as u64;
+        let first_stacks_block_height = {
+            let sn =
+                SortitionDB::get_canonical_burn_chain_tip(&peer_1.sortdb.as_ref().unwrap().conn())
+                    .unwrap();
+            sn.block_height + 1
+        };
+
+        for i in 0..num_blocks {
+            let (burn_ops, stacks_block, microblocks) = peer_2.make_default_tenure();
+
+            peer_1.next_burnchain_block(burn_ops.clone());
+            peer_2.next_burnchain_block(burn_ops.clone());
+
+            peer_1.process_stacks_epoch_at_tip(&stacks_block, &microblocks);
+            peer_2.process_stacks_epoch_at_tip(&stacks_block, &microblocks);
+        }
+
+        let num_burn_blocks = {
+            let sn =
+                SortitionDB::get_canonical_burn_chain_tip(peer_1.sortdb.as_ref().unwrap().conn())
+                    .unwrap();
+            sn.block_height + 1
+        };
+
+        let mut round = 0;
+        let mut inv_1_count = 0;
+        let mut inv_2_count = 0;
+
+        while inv_1_count < num_blocks || inv_2_count < num_blocks {
+            let _ = peer_1.step();
+            let _ = peer_2.step();
+
+            inv_1_count = match peer_1.network.inv_state {
+                Some(ref inv) => {
+                    info!("Peer 1 stats: {:?}", &inv.block_stats);
+                    inv.get_inv_num_blocks(&peer_2.to_neighbor().addr)
+                }
+                None => 0,
+            };
+
+            inv_2_count = match peer_2.network.inv_state {
+                Some(ref inv) => {
+                    info!("Peer 2 stats: {:?}", &inv.block_stats);
+                    inv.get_inv_num_blocks(&peer_1.to_neighbor().addr)
+                }
+                None => 0,
+            };
+
+            // nothing should break
+            match peer_1.network.inv_state {
+                Some(ref inv) => {
+                    assert_eq!(inv.get_broken_peers().len(), 0);
+                    assert_eq!(inv.get_dead_peers().len(), 0);
+                    assert_eq!(inv.get_diverged_peers().len(), 0);
+                }
+                None => {}
+            }
+
+            match peer_2.network.inv_state {
+                Some(ref inv) => {
+                    assert_eq!(inv.get_broken_peers().len(), 0);
+                    assert_eq!(inv.get_dead_peers().len(), 0);
+                    assert_eq!(inv.get_diverged_peers().len(), 0);
+                }
+                None => {}
+            }
+
+            round += 1;
+
+            info!("Peer 1: {}, Peer 2: {}", inv_1_count, inv_2_count);
+        }
+
+        info!("Completed walk round {} step(s)", round);
+
+        peer_1.dump_frontier();
+        peer_2.dump_frontier();
+
+        info!(
+            "Peer 1 stats: {:?}",
+            &peer_1.network.inv_state.as_ref().unwrap().block_stats
+        );
+        info!(
+            "Peer 2 stats: {:?}",
+            &peer_2.network.inv_state.as_ref().unwrap().block_stats
+        );
+
+        let peer_1_inv = peer_2
+            .network
+            .inv_state
+            .as_ref()
+            .unwrap()
+            .block_stats
+            .get(&peer_1.to_neighbor().addr)
+            .unwrap()
+            .inv
+            .clone();
+        let peer_2_inv = peer_1
+            .network
+            .inv_state
+            .as_ref()
+            .unwrap()
+            .block_stats
+            .get(&peer_2.to_neighbor().addr)
+            .unwrap()
+            .inv
+            .clone();
+
+        info!("Peer 1 inv: {:?}", &peer_1_inv);
+        info!("Peer 2 inv: {:?}", &peer_2_inv);
+
+        info!("peer 1's view of peer 2: {:?}", &peer_2_inv);
+
+        assert_eq!(peer_2_inv.num_sortitions, num_burn_blocks);
+
+        // peer 1 should have learned that peer 2 has all the blocks
+        for i in 0..num_blocks {
+            assert!(
+                peer_2_inv.has_ith_block(i + first_stacks_block_height),
+                "Missing block {} (+ {})",
+                i,
+                first_stacks_block_height
+            );
+        }
+
+        // peer 1 should have learned that peer 2 has all the microblock streams
+        for i in 1..(num_blocks - 1) {
+            assert!(
+                peer_2_inv.has_ith_microblock_stream(i + first_stacks_block_height),
+                "Missing microblock {} (+ {})",
+                i,
+                first_stacks_block_height
+            );
+        }
+
+        let peer_1_inv = peer_2
+            .network
+            .inv_state
+            .as_ref()
+            .unwrap()
+            .block_stats
+            .get(&peer_1.to_neighbor().addr)
+            .unwrap()
+            .inv
+            .clone();
+        test_debug!("peer 2's view of peer 1: {:?}", &peer_1_inv);
+
+        assert_eq!(peer_1_inv.num_sortitions, num_burn_blocks);
+
+        // peer 2 should have learned that peer 1 has all the blocks as well
+        for i in 0..num_blocks {
+            assert!(
+                peer_1_inv.has_ith_block(i + first_stacks_block_height),
+                "Missing block {} (+ {})",
+                i,
+                first_stacks_block_height
+            );
+        }
+    })
+}
+
+#[test]
+#[ignore]
+fn test_sync_inv_2_peers_stale() {
+    with_timeout(600, || {
+        let mut peer_1_config = TestPeerConfig::new(function_name!(), 0, 0);
+        let mut peer_2_config = TestPeerConfig::new(function_name!(), 0, 0);
+
+        peer_1_config.add_neighbor(&peer_2_config.to_neighbor());
+        peer_2_config.add_neighbor(&peer_1_config.to_neighbor());
+
+        let mut peer_1 = TestPeer::new(peer_1_config);
+        let mut peer_2 = TestPeer::new(peer_2_config);
+
+        let num_blocks = (GETPOXINV_MAX_BITLEN * 2) as u64;
+        let first_stacks_block_height = {
+            let sn =
+                SortitionDB::get_canonical_burn_chain_tip(&peer_1.sortdb.as_ref().unwrap().conn())
+                    .unwrap();
+            sn.block_height + 1
+        };
+
+        for i in 0..num_blocks {
+            let (burn_ops, stacks_block, microblocks) = peer_2.make_default_tenure();
+
+            peer_2.next_burnchain_block(burn_ops.clone());
+            peer_2.process_stacks_epoch_at_tip(&stacks_block, &microblocks);
+        }
+
+        let mut round = 0;
+        let mut inv_1_count = 0;
+        let mut inv_2_count = 0;
+
+        let mut peer_1_check = false;
+        let mut peer_2_check = false;
+
+        while !peer_1_check || !peer_2_check {
+            let _ = peer_1.step();
+            let _ = peer_2.step();
+
+            inv_1_count = match peer_1.network.inv_state {
+                Some(ref inv) => inv.get_inv_sortitions(&peer_2.to_neighbor().addr),
+                None => 0,
+            };
+
+            inv_2_count = match peer_2.network.inv_state {
+                Some(ref inv) => inv.get_inv_sortitions(&peer_1.to_neighbor().addr),
+                None => 0,
+            };
+
+            match peer_1.network.inv_state {
+                Some(ref inv) => {
+                    info!("Peer 1 stats: {:?}", &inv.block_stats);
+                    assert_eq!(inv.get_broken_peers().len(), 0);
+                    assert_eq!(inv.get_dead_peers().len(), 0);
+                    assert_eq!(inv.get_diverged_peers().len(), 0);
+
+                    if let Some(ref peer_2_inv) = inv.block_stats.get(&peer_2.to_neighbor().addr) {
+                        if peer_2_inv.inv.num_sortitions
+                            == first_stacks_block_height
+                                - peer_1.config.burnchain.first_block_height
+                        {
+                            for i in 0..first_stacks_block_height {
+                                assert!(!peer_2_inv.inv.has_ith_block(i));
+                                assert!(!peer_2_inv.inv.has_ith_microblock_stream(i));
+                            }
+                            peer_2_check = true;
+                        }
+                    }
+                }
+                None => {}
+            }
+
+            match peer_2.network.inv_state {
+                Some(ref inv) => {
+                    info!("Peer 2 stats: {:?}", &inv.block_stats);
+                    assert_eq!(inv.get_broken_peers().len(), 0);
+                    assert_eq!(inv.get_dead_peers().len(), 0);
+                    assert_eq!(inv.get_diverged_peers().len(), 0);
+
+                    if let Some(ref peer_1_inv) = inv.block_stats.get(&peer_1.to_neighbor().addr) {
+                        if peer_1_inv.inv.num_sortitions
+                            == first_stacks_block_height
+                                - peer_1.config.burnchain.first_block_height
+                        {
+                            peer_1_check = true;
+                        }
+                    }
+                }
+                None => {}
+            }
+
+            round += 1;
+
+            test_debug!("\n\npeer_1_check = {}, peer_2_check = {}, inv_1_count = {}, inv_2_count = {}, first_stacks_block_height = {}\n\n", peer_1_check, peer_2_check, inv_1_count, inv_2_count, first_stacks_block_height);
+        }
+
+        info!("Completed walk round {} step(s)", round);
+
+        peer_1.dump_frontier();
+        peer_2.dump_frontier();
+    })
+}
+
+#[test]
+#[ignore]
+fn test_sync_inv_2_peers_unstable() {
+    with_timeout(600, || {
+        let mut peer_1_config = TestPeerConfig::new(function_name!(), 0, 0);
+        let mut peer_2_config = TestPeerConfig::new(function_name!(), 0, 0);
+
+        let stable_confs = peer_1_config.burnchain.stable_confirmations as u64;
+
+        peer_1_config.add_neighbor(&peer_2_config.to_neighbor());
+        peer_2_config.add_neighbor(&peer_1_config.to_neighbor());
+
+        let mut peer_1 = TestPeer::new(peer_1_config);
+        let mut peer_2 = TestPeer::new(peer_2_config);
+
+        let num_blocks = (GETPOXINV_MAX_BITLEN * 2) as u64;
+
+        let first_stacks_block_height = {
+            let sn =
+                SortitionDB::get_canonical_burn_chain_tip(&peer_1.sortdb.as_ref().unwrap().conn())
+                    .unwrap();
+            sn.block_height + 1
+        };
+
+        // only peer 2 makes progress after the point of stability.
+        for i in 0..num_blocks {
+            let (mut burn_ops, stacks_block, microblocks) = peer_2.make_default_tenure();
+
+            let (_, burn_header_hash, consensus_hash) =
+                peer_2.next_burnchain_block(burn_ops.clone());
+            peer_2.process_stacks_epoch_at_tip(&stacks_block, &microblocks);
+
+            TestPeer::set_ops_burn_header_hash(&mut burn_ops, &burn_header_hash);
+
+            // NOTE: the nodes only differ by one block -- they agree on the same PoX vector
+            if i + 1 < num_blocks {
+                peer_1.next_burnchain_block_raw(burn_ops.clone());
+                peer_1.process_stacks_epoch_at_tip(&stacks_block, &microblocks);
+            } else {
+                // peer 1 diverges
+                test_debug!("Peer 1 diverges at {}", i + first_stacks_block_height);
+                peer_1.next_burnchain_block(vec![]);
+            }
+        }
+
+        // tips must differ
+        {
+            let sn1 =
+                SortitionDB::get_canonical_burn_chain_tip(peer_1.sortdb.as_ref().unwrap().conn())
+                    .unwrap();
+            let sn2 =
+                SortitionDB::get_canonical_burn_chain_tip(peer_2.sortdb.as_ref().unwrap().conn())
+                    .unwrap();
+            assert_ne!(sn1.burn_header_hash, sn2.burn_header_hash);
+        }
+
+        let num_stable_blocks = num_blocks - stable_confs;
+
+        let num_burn_blocks = {
+            let sn =
+                SortitionDB::get_canonical_burn_chain_tip(peer_1.sortdb.as_ref().unwrap().conn())
+                    .unwrap();
+            sn.block_height + 1
+        };
+
+        let mut round = 0;
+        let mut inv_1_count = 0;
+        let mut inv_2_count = 0;
+
+        let mut peer_1_pox_cycle_start = false;
+        let mut peer_1_block_cycle_start = false;
+        let mut peer_2_pox_cycle_start = false;
+        let mut peer_2_block_cycle_start = false;
+
+        let mut peer_1_pox_cycle = false;
+        let mut peer_1_block_cycle = false;
+        let mut peer_2_pox_cycle = false;
+        let mut peer_2_block_cycle = false;
+
+        while inv_1_count < num_stable_blocks || inv_2_count < num_stable_blocks {
+            let _ = peer_1.step();
+            let _ = peer_2.step();
+
+            inv_1_count = match peer_1.network.inv_state {
+                Some(ref inv) => inv.get_inv_num_blocks(&peer_2.to_neighbor().addr),
+                None => 0,
+            };
+
+            inv_2_count = match peer_2.network.inv_state {
+                Some(ref inv) => inv.get_inv_num_blocks(&peer_1.to_neighbor().addr),
+                None => 0,
+            };
+
+            match peer_1.network.inv_state {
+                Some(ref inv) => {
+                    info!("Peer 1 stats: {:?}", &inv.block_stats);
+                    assert_eq!(inv.get_broken_peers().len(), 0);
+                    assert_eq!(inv.get_dead_peers().len(), 0);
+                    assert_eq!(inv.get_diverged_peers().len(), 0);
+
+                    if let Some(stats) = inv.get_stats(&peer_2.to_neighbor().addr) {
+                        if stats.target_pox_reward_cycle > 0 {
+                            peer_1_pox_cycle_start = true;
+                        }
+                        if stats.target_block_reward_cycle > 0 {
+                            peer_1_block_cycle_start = true;
+                        }
+                        if stats.target_pox_reward_cycle == 0 && peer_1_pox_cycle_start {
+                            peer_1_pox_cycle = true;
+                        }
+                        if stats.target_block_reward_cycle == 0 && peer_1_block_cycle_start {
+                            peer_1_block_cycle = true;
+                        }
+                    }
+                }
+                None => {}
+            }
+
+            match peer_2.network.inv_state {
+                Some(ref inv) => {
+                    info!("Peer 2 stats: {:?}", &inv.block_stats);
+                    assert_eq!(inv.get_broken_peers().len(), 0);
+                    assert_eq!(inv.get_dead_peers().len(), 0);
+                    assert_eq!(inv.get_diverged_peers().len(), 0);
+
+                    if let Some(stats) = inv.get_stats(&peer_1.to_neighbor().addr) {
+                        if stats.target_pox_reward_cycle > 0 {
+                            peer_2_pox_cycle_start = true;
+                        }
+                        if stats.target_block_reward_cycle > 0 {
+                            peer_2_block_cycle_start = true;
+                        }
+                        if stats.target_pox_reward_cycle == 0 && peer_2_pox_cycle_start {
+                            peer_2_pox_cycle = true;
+                        }
+                        if stats.target_block_reward_cycle == 0 && peer_2_block_cycle_start {
+                            peer_2_block_cycle = true;
+                        }
+                    }
+                }
+                None => {}
+            }
+
+            round += 1;
+
+            test_debug!(
+                "\n\ninv_1_count = {}, inv_2_count = {}, num_stable_blocks = {}\n\n",
+                inv_1_count,
+                inv_2_count,
+                num_stable_blocks
+            );
+        }
+
+        info!("Completed walk round {} step(s)", round);
+
+        peer_1.dump_frontier();
+        peer_2.dump_frontier();
+
+        let peer_2_inv = peer_1
+            .network
+            .inv_state
+            .as_ref()
+            .unwrap()
+            .block_stats
+            .get(&peer_2.to_neighbor().addr)
+            .unwrap()
+            .inv
+            .clone();
+        test_debug!("peer 1's view of peer 2: {:?}", &peer_2_inv);
+
+        let peer_1_inv = peer_2
+            .network
+            .inv_state
+            .as_ref()
+            .unwrap()
+            .block_stats
+            .get(&peer_1.to_neighbor().addr)
+            .unwrap()
+            .inv
+            .clone();
+        test_debug!("peer 2's view of peer 1: {:?}", &peer_1_inv);
+
+        assert_eq!(peer_2_inv.num_sortitions, num_burn_blocks - stable_confs);
+        assert_eq!(peer_1_inv.num_sortitions, num_burn_blocks - stable_confs);
+
+        // only 8 reward cycles -- we couldn't agree on the 9th
+        assert_eq!(peer_1_inv.pox_inv, vec![255]);
+        assert_eq!(peer_2_inv.pox_inv, vec![255]);
+
+        // peer 1 should have learned that peer 2 has all the blocks, up to the point of
+        // instability
+        for i in 0..(num_blocks - stable_confs) {
+            assert!(peer_2_inv.has_ith_block(i + first_stacks_block_height));
+            if i > 0 {
+                assert!(peer_2_inv.has_ith_microblock_stream(i + first_stacks_block_height));
+            } else {
+                assert!(!peer_2_inv.has_ith_microblock_stream(i + first_stacks_block_height));
+            }
+        }
+
+        for i in 0..(num_blocks - stable_confs) {
+            assert!(peer_1_inv.has_ith_block(i + first_stacks_block_height));
+        }
+
+        assert!(!peer_2_inv.has_ith_block(num_blocks - stable_confs));
+        assert!(!peer_2_inv.has_ith_microblock_stream(num_blocks - stable_confs));
+    })
+}
+
+#[test]
+#[ignore]
+fn test_sync_inv_2_peers_different_pox_vectors() {
+    with_timeout(600, || {
+        let mut peer_1_config = TestPeerConfig::new(function_name!(), 0, 0);
+        let mut peer_2_config = TestPeerConfig::new(function_name!(), 0, 0);
+
+        peer_1_config.add_neighbor(&peer_2_config.to_neighbor());
+        peer_2_config.add_neighbor(&peer_1_config.to_neighbor());
+
+        let reward_cycle_length = peer_1_config.burnchain.pox_constants.reward_cycle_length as u64;
+        assert_eq!(reward_cycle_length, 5);
+
+        let mut peer_1 = TestPeer::new(peer_1_config);
+        let mut peer_2 = TestPeer::new(peer_2_config);
+
+        let num_blocks = (GETPOXINV_MAX_BITLEN * 3) as u64;
+
+        let first_stacks_block_height = {
+            let sn =
+                SortitionDB::get_canonical_burn_chain_tip(&peer_1.sortdb.as_ref().unwrap().conn())
+                    .unwrap();
+            sn.block_height + 1
+        };
+
+        // only peer 2 makes progress after the point of stability.
+        for i in 0..num_blocks {
+            let (mut burn_ops, stacks_block, microblocks) = peer_2.make_default_tenure();
+
+            let (_, burn_header_hash, consensus_hash) =
+                peer_2.next_burnchain_block(burn_ops.clone());
+            peer_2.process_stacks_epoch_at_tip(&stacks_block, &microblocks);
+
+            TestPeer::set_ops_burn_header_hash(&mut burn_ops, &burn_header_hash);
+
+            peer_1.next_burnchain_block_raw(burn_ops.clone());
+            if i < num_blocks - reward_cycle_length * 2 {
+                peer_1.process_stacks_epoch_at_tip(&stacks_block, &microblocks);
+            }
+        }
+
+        let peer_1_pox_id = {
+            let tip_sort_id =
+                SortitionDB::get_canonical_sortition_tip(peer_1.sortdb.as_ref().unwrap().conn())
+                    .unwrap();
+            let ic = peer_1.sortdb.as_ref().unwrap().index_conn();
+            let sortdb_reader = SortitionHandleConn::open_reader(&ic, &tip_sort_id).unwrap();
+            sortdb_reader.get_pox_id().unwrap()
+        };
+
+        let peer_2_pox_id = {
+            let tip_sort_id =
+                SortitionDB::get_canonical_sortition_tip(peer_2.sortdb.as_ref().unwrap().conn())
+                    .unwrap();
+            let ic = peer_2.sortdb.as_ref().unwrap().index_conn();
+            let sortdb_reader = SortitionHandleConn::open_reader(&ic, &tip_sort_id).unwrap();
+            sortdb_reader.get_pox_id().unwrap()
+        };
+
+        // peers must have different PoX bit vectors -- peer 1 didn't see the last reward cycle
+        assert_eq!(
+            peer_1_pox_id,
+            PoxId::from_bools(vec![
+                true, true, true, true, true, true, true, true, true, true, false
+            ])
+        );
+        assert_eq!(
+            peer_2_pox_id,
+            PoxId::from_bools(vec![
+                true, true, true, true, true, true, true, true, true, true, true
+            ])
+        );
+
+        let num_burn_blocks = {
+            let sn =
+                SortitionDB::get_canonical_burn_chain_tip(peer_1.sortdb.as_ref().unwrap().conn())
+                    .unwrap();
+            sn.block_height + 1
+        };
+
+        let mut round = 0;
+        let mut inv_1_count = 0;
+        let mut inv_2_count = 0;
+        let mut peer_1_sorts = 0;
+        let mut peer_2_sorts = 0;
+
+        while inv_1_count < reward_cycle_length * 4
+            || inv_2_count < num_blocks - reward_cycle_length * 2
+            || peer_1_sorts < reward_cycle_length * 9 + 1
+            || peer_2_sorts < reward_cycle_length * 9 + 1
+        {
+            let _ = peer_1.step();
+            let _ = peer_2.step();
+
+            // peer 1 should see that peer 2 has all blocks for reward cycles 5 through 9
+            match peer_1.network.inv_state {
+                Some(ref inv) => {
+                    inv_1_count = inv.get_inv_num_blocks(&peer_2.to_neighbor().addr);
+                    peer_1_sorts = inv.get_inv_sortitions(&peer_2.to_neighbor().addr);
+                }
+                None => {}
+            };
+
+            // peer 2 should see that peer 1 has all blocks up to where we stopped feeding them to
+            // it
+            match peer_2.network.inv_state {
+                Some(ref inv) => {
+                    inv_2_count = inv.get_inv_num_blocks(&peer_1.to_neighbor().addr);
+                    peer_2_sorts = inv.get_inv_sortitions(&peer_1.to_neighbor().addr);
+                }
+                None => {}
+            };
+
+            match peer_1.network.inv_state {
+                Some(ref inv) => {
+                    info!("Peer 1 stats: {:?}", &inv.block_stats);
+                    assert_eq!(inv.get_broken_peers().len(), 0);
+                    assert_eq!(inv.get_dead_peers().len(), 0);
+                    assert_eq!(inv.get_diverged_peers().len(), 0);
+                }
+                None => {}
+            }
+
+            match peer_2.network.inv_state {
+                Some(ref inv) => {
+                    info!("Peer 2 stats: {:?}", &inv.block_stats);
+                    assert_eq!(inv.get_broken_peers().len(), 0);
+                    assert_eq!(inv.get_dead_peers().len(), 0);
+                    assert_eq!(inv.get_diverged_peers().len(), 0);
+                }
+                None => {}
+            }
+
+            round += 1;
+
+            test_debug!(
+                "\n\ninv_1_count = {} <? {}, inv_2_count = {} <? {}, peer_1_sorts = {} <? {}, peer_2_sorts = {} <? {}",
+                inv_1_count,
+                reward_cycle_length * 4,
+                inv_2_count,
+                num_blocks - reward_cycle_length * 2,
+                peer_1_sorts,
+                reward_cycle_length * 9 + 1,
+                peer_2_sorts,
+                reward_cycle_length * 9 + 1
+            );
+        }
+
+        info!("Completed walk round {} step(s)", round);
+
+        peer_1.dump_frontier();
+        peer_2.dump_frontier();
+
+        let peer_1_pox_id = {
+            let tip_sort_id =
+                SortitionDB::get_canonical_sortition_tip(peer_1.sortdb.as_ref().unwrap().conn())
+                    .unwrap();
+            let ic = peer_1.sortdb.as_ref().unwrap().index_conn();
+            let sortdb_reader = SortitionHandleConn::open_reader(&ic, &tip_sort_id).unwrap();
+            sortdb_reader.get_pox_id().unwrap()
+        };
+
+        let peer_2_pox_id = {
+            let tip_sort_id =
+                SortitionDB::get_canonical_sortition_tip(peer_2.sortdb.as_ref().unwrap().conn())
+                    .unwrap();
+            let ic = peer_2.sortdb.as_ref().unwrap().index_conn();
+            let sortdb_reader = SortitionHandleConn::open_reader(&ic, &tip_sort_id).unwrap();
+            sortdb_reader.get_pox_id().unwrap()
+        };
+
+        let peer_2_inv = peer_1
+            .network
+            .inv_state
+            .as_ref()
+            .unwrap()
+            .block_stats
+            .get(&peer_2.to_neighbor().addr)
+            .unwrap()
+            .inv
+            .clone();
+        test_debug!("peer 1's view of peer 2: {:?}", &peer_2_inv);
+        test_debug!("peer 1's PoX bit vector is {:?}", &peer_1_pox_id);
+
+        let peer_1_inv = peer_2
+            .network
+            .inv_state
+            .as_ref()
+            .unwrap()
+            .block_stats
+            .get(&peer_1.to_neighbor().addr)
+            .unwrap()
+            .inv
+            .clone();
+        test_debug!("peer 2's view of peer 1: {:?}", &peer_1_inv);
+        test_debug!("peer 2's PoX bit vector is {:?}", &peer_2_pox_id);
+
+        // nodes only learn about the prefix of their PoX bit vectors that they agree on
+        assert_eq!(peer_2_inv.num_sortitions, reward_cycle_length * 9 + 1);
+        assert_eq!(peer_1_inv.num_sortitions, reward_cycle_length * 9 + 1);
+
+        // only 9 reward cycles -- we couldn't agree on the 10th
+        assert_eq!(peer_1_inv.pox_inv, vec![255, 1]);
+        assert_eq!(peer_2_inv.pox_inv, vec![255, 1]);
+
+        // peer 1 should have learned that peer 2 has all the blocks, up to the point of
+        // PoX instability between the two
+        for i in 0..(reward_cycle_length * 4) {
+            assert!(peer_2_inv.has_ith_block(i + first_stacks_block_height));
+            if i > 0 {
+                assert!(peer_2_inv.has_ith_microblock_stream(i + first_stacks_block_height));
+            } else {
+                assert!(!peer_2_inv.has_ith_microblock_stream(i + first_stacks_block_height));
+            }
+        }
+
+        // peer 2 should have learned about all of peer 1's blocks
+        for i in 0..(num_blocks - 2 * reward_cycle_length) {
+            assert!(peer_1_inv.has_ith_block(i + first_stacks_block_height));
+            if i > 0 && i != num_blocks - 2 * reward_cycle_length - 1 {
+                // peer 1 doesn't have the final microblock stream, since no anchor block confirmed it
+                assert!(peer_1_inv.has_ith_microblock_stream(i + first_stacks_block_height));
+            }
+        }
+
+        assert!(!peer_1_inv.has_ith_block(reward_cycle_length * 4));
+        assert!(!peer_1_inv.has_ith_microblock_stream(reward_cycle_length * 4));
+
+        assert!(!peer_2_inv.has_ith_block(num_blocks - 2 * reward_cycle_length));
+        assert!(!peer_2_inv.has_ith_microblock_stream(num_blocks - 2 * reward_cycle_length));
+    })
+}
diff --git a/stackslib/src/net/inv/tests/mod.rs b/stackslib/src/net/inv/tests/mod.rs
new file mode 100644
index 0000000000..04e8e0fd4f
--- /dev/null
+++ b/stackslib/src/net/inv/tests/mod.rs
@@ -0,0 +1,18 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020-2023 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+pub mod epoch2x;
+pub mod nakamoto;

From 7e907f4456097ef07667736fe7c9d18a0b7d9a0c Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Fri, 5 Jan 2024 13:00:15 -0500
Subject: [PATCH 0279/1166] feat: implement inventory query interface and
 inventory message builder for Nakamoto, and add unit tests

---
 stackslib/src/net/inv/nakamoto.rs       | 219 +++++++++++++++++
 stackslib/src/net/inv/tests/nakamoto.rs | 309 ++++++++++++++++++++++++
 2 files changed, 528 insertions(+)
 create mode 100644 stackslib/src/net/inv/nakamoto.rs
 create mode 100644 stackslib/src/net/inv/tests/nakamoto.rs

diff --git a/stackslib/src/net/inv/nakamoto.rs b/stackslib/src/net/inv/nakamoto.rs
new file mode 100644
index 0000000000..a56ce11867
--- /dev/null
+++ b/stackslib/src/net/inv/nakamoto.rs
@@ -0,0 +1,219 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020-2023 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+use std::collections::HashMap;
+
+use crate::chainstate::burn::db::sortdb::SortitionDB;
+use crate::chainstate::burn::BlockSnapshot;
+use crate::chainstate::burn::ConsensusHash;
+
+use crate::chainstate::nakamoto::NakamotoChainState;
+use crate::chainstate::stacks::db::StacksChainState;
+use crate::net::Error as NetError;
+use crate::net::NakamotoInvData;
+
+use crate::util_lib::db::Error as DBError;
+
+/// Cached data for a sortition in the sortition DB.
+/// Caching this allows us to avoid calls to `SortitionDB::get_block_snapshot_consensus()`.
+#[derive(Clone, Debug, PartialEq)]
+pub(crate) struct InvSortitionInfo {
+    parent_consensus_hash: ConsensusHash,
+    block_height: u64,
+}
+
+impl InvSortitionInfo {
+    /// Load up cacheable sortition state for a given consensus hash
+    pub fn load(
+        sortdb: &SortitionDB,
+        consensus_hash: &ConsensusHash,
+    ) -> Result<InvSortitionInfo, NetError> {
+        let sn = SortitionDB::get_block_snapshot_consensus(sortdb.conn(), consensus_hash)?
+            .ok_or(DBError::NotFoundError)?;
+
+        let parent_sn = SortitionDB::get_block_snapshot(sortdb.conn(), &sn.parent_sortition_id)?
+            .ok_or(DBError::NotFoundError)?;
+
+        Ok(Self {
+            parent_consensus_hash: parent_sn.consensus_hash,
+            block_height: sn.block_height,
+        })
+    }
+}
+
+/// Cached data for a TenureChange transaction caused by a BlockFound event.
+#[derive(Clone, Debug, PartialEq)]
+pub(crate) struct InvTenureInfo {
+    /// This tenure's start-block consensus hash
+    tenure_id_consensus_hash: ConsensusHash,
+    /// This tenure's parent's start-block consensus hash
+    parent_tenure_id_consensus_hash: ConsensusHash,
+}
+
+impl InvTenureInfo {
+    /// Load up cacheable tenure state for a given tenure-ID consensus hash.
+    /// This only returns Ok(Some(..)) if there was a tenure-change tx for this consensus hash.
+    pub fn load(
+        chainstate: &StacksChainState,
+        consensus_hash: &ConsensusHash,
+    ) -> Result<Option<InvTenureInfo>, NetError> {
+        Ok(
+            NakamotoChainState::get_highest_nakamoto_tenure_change_by_tenure_id(
+                chainstate.db(),
+                consensus_hash,
+            )?
+            .map(|tenure| Self {
+                tenure_id_consensus_hash: tenure.tenure_id_consensus_hash,
+                parent_tenure_id_consensus_hash: tenure.prev_tenure_id_consensus_hash,
+            }),
+        )
+    }
+}
+
+/// This struct represents cached inventory data loaded from Nakamoto headers.
+/// It is of the utmost importance that inventory message generation is _fast_, and incurs as
+/// little I/O overhead as possible, given how essential these messages are to nodes trying to keep
+/// in sync.  By caching (immutable) tenure data in this struct, we can enusre that this happens
+/// all the time except for during node bootup.
+pub struct InvGenerator {
+    processed_tenures: HashMap<ConsensusHash, Option<InvTenureInfo>>,
+    sortitions: HashMap<ConsensusHash, InvSortitionInfo>,
+}
+
+impl InvGenerator {
+    pub fn new() -> Self {
+        Self {
+            processed_tenures: HashMap::new(),
+            sortitions: HashMap::new(),
+        }
+    }
+
+    /// Get a processed tenure. If it's not cached, then load it.
+    /// Returns Some(..) if there existed a tenure-change tx for this given consensus hash
+    fn get_processed_tenure(
+        &mut self,
+        chainstate: &StacksChainState,
+        tenure_id_consensus_hash: &ConsensusHash,
+    ) -> Result<Option<InvTenureInfo>, NetError> {
+        let cur_tenure_info_opt =
+            if let Some(info_opt) = self.processed_tenures.get(&tenure_id_consensus_hash) {
+                Ok((*info_opt).clone())
+            } else {
+                let loaded_info_opt = InvTenureInfo::load(chainstate, &tenure_id_consensus_hash)?;
+                self.processed_tenures
+                    .insert(tenure_id_consensus_hash.clone(), loaded_info_opt.clone());
+                Ok(loaded_info_opt)
+            };
+        cur_tenure_info_opt
+    }
+
+    /// Generate an block inventory bit vector for a reward cycle.
+    /// The bit vector is "big-endian" -- the first bit is the oldest sortition, and the last bit is
+    /// the newest sortition.  It is structured as follows:
+    /// * Bit 0 is the sortition at the start of the given reward cycle
+    /// * Bit i is 1 if there was a tenure-start for the ith sortition in the reward cycle, and 0
+    /// if not.
+    ///
+    /// Populate the cached data lazily.
+    ///
+    /// * `tip` is the canonical sortition tip
+    /// * `chainstate` is a handle to the chainstate DB
+    /// * `reward_cycle` is the reward cycle for which to generate the inventory
+    ///
+    /// The resulting bitvector will be truncated if `reward_cycle` is the current reward cycle.
+    pub fn make_tenure_bitvector(
+        &mut self,
+        tip: &BlockSnapshot,
+        sortdb: &SortitionDB,
+        chainstate: &StacksChainState,
+        reward_cycle: u64,
+    ) -> Result<Vec<bool>, NetError> {
+        let ih = sortdb.index_handle(&tip.sortition_id);
+        let reward_cycle_end_height = sortdb
+            .pox_constants
+            .reward_cycle_to_block_height(sortdb.first_block_height, reward_cycle + 1)
+            - 2;
+        let reward_cycle_end_tip = if tip.block_height <= reward_cycle_end_height {
+            tip.clone()
+        } else {
+            ih.get_block_snapshot_by_height(reward_cycle_end_height)?
+                .ok_or(NetError::NotFoundError)?
+        };
+
+        let mut tenure_status = vec![];
+        let mut cur_height = reward_cycle_end_tip.block_height;
+        let mut cur_consensus_hash = reward_cycle_end_tip.consensus_hash;
+
+        let mut cur_tenure_opt = self.get_processed_tenure(chainstate, &cur_consensus_hash)?;
+
+        loop {
+            let cur_reward_cycle = sortdb
+                .pox_constants
+                .block_height_to_reward_cycle(sortdb.first_block_height, cur_height)
+                .ok_or(NetError::ChainstateError(
+                    "block height comes before system start".into(),
+                ))?;
+            if cur_reward_cycle < reward_cycle {
+                // done scanning this reward cycle
+                break;
+            }
+            let cur_sortition_info = if let Some(info) = self.sortitions.get(&cur_consensus_hash) {
+                info
+            } else {
+                let loaded_info = InvSortitionInfo::load(sortdb, &cur_consensus_hash)?;
+                self.sortitions
+                    .insert(cur_consensus_hash.clone(), loaded_info);
+                self.sortitions
+                    .get(&cur_consensus_hash)
+                    .expect("infallbile: just inserted this data".into())
+            };
+            let parent_sortition_consensus_hash = cur_sortition_info.parent_consensus_hash.clone();
+
+            debug!("Get sortition and tenure info for height {}. cur_consensus_hash = {}, cur_tenure_info = {:?}, cur_sortition_info = {:?}", cur_height, &cur_consensus_hash, &cur_tenure_opt, cur_sortition_info);
+
+            if let Some(cur_tenure_info) = cur_tenure_opt.as_ref() {
+                // a tenure was active when this sortition happened...
+                if cur_tenure_info.tenure_id_consensus_hash == cur_consensus_hash {
+                    // ...and this tenure started in this sortition
+                    tenure_status.push(true);
+                    cur_tenure_opt = self.get_processed_tenure(
+                        chainstate,
+                        &cur_tenure_info.parent_tenure_id_consensus_hash,
+                    )?;
+                } else {
+                    // ...but this tenure did not start in this sortition
+                    tenure_status.push(false);
+                }
+            } else {
+                // no active tenure during this sortition. Check the parent sortition to see if a
+                // tenure begain there.
+                tenure_status.push(false);
+                cur_tenure_opt =
+                    self.get_processed_tenure(chainstate, &parent_sortition_consensus_hash)?;
+            }
+
+            // next sortition
+            cur_consensus_hash = parent_sortition_consensus_hash;
+            if cur_height == 0 {
+                break;
+            }
+            cur_height = cur_height.saturating_sub(1);
+        }
+
+        tenure_status.reverse();
+        Ok(tenure_status)
+    }
+}
diff --git a/stackslib/src/net/inv/tests/nakamoto.rs b/stackslib/src/net/inv/tests/nakamoto.rs
new file mode 100644
index 0000000000..a4b9b6b95e
--- /dev/null
+++ b/stackslib/src/net/inv/tests/nakamoto.rs
@@ -0,0 +1,309 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020-2023 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+use std::collections::HashMap;
+use std::net::TcpStream;
+use std::sync::mpsc::sync_channel;
+use std::thread;
+use std::thread::JoinHandle;
+
+use crate::chainstate::burn::db::sortdb::SortitionDB;
+use crate::chainstate::burn::ConsensusHash;
+
+use crate::chainstate::nakamoto::coordinator::tests::{
+    simple_nakamoto_coordinator_10_extended_tenures_10_sortitions,
+    simple_nakamoto_coordinator_10_tenures_10_sortitions,
+    simple_nakamoto_coordinator_2_tenures_3_sortitions,
+};
+use crate::chainstate::nakamoto::NakamotoChainState;
+
+use crate::chainstate::stacks::db::StacksChainState;
+use crate::net::Error as NetError;
+use crate::net::GetNakamotoInvData;
+use crate::net::HandshakeData;
+use crate::net::NakamotoInvData;
+use crate::util_lib::db::Error as DBError;
+
+use stacks_common::codec::read_next;
+use stacks_common::codec::StacksMessageCodec;
+use stacks_common::types::chainstate::StacksPrivateKey;
+
+use crate::net::inv::nakamoto::InvGenerator;
+use crate::net::test::TestPeer;
+use crate::net::StacksMessage;
+use crate::net::StacksMessageType;
+
+use crate::core::StacksEpochExtension;
+use stacks_common::types::StacksEpoch;
+
+/// Handshake with and get the reward cycle inventories for a range of reward cycles
+fn peer_get_nakamoto_invs(
+    mut peer: TestPeer<'static>,
+    reward_cycles: &[u64],
+) -> (TestPeer<'static>, Vec<StacksMessageType>) {
+    let privk = StacksPrivateKey::new();
+    let mut convo = peer.make_client_convo();
+    let client_peer = peer.make_client_local_peer(privk.clone());
+    let peer_addr = peer.p2p_socketaddr();
+    let chain_view = peer.network.get_chain_view().clone();
+
+    let mut get_nakamoto_invs = vec![];
+    for reward_cycle in reward_cycles {
+        let consensus_hash = {
+            let sortdb = peer.sortdb();
+            let reward_cycle_start_height = sortdb
+                .pox_constants
+                .reward_cycle_to_block_height(sortdb.first_block_height, *reward_cycle);
+            let ih = sortdb.index_handle_at_tip();
+            let Some(rc_start_sn) = ih
+                .get_block_snapshot_by_height(reward_cycle_start_height)
+                .unwrap()
+            else {
+                continue;
+            };
+            rc_start_sn.consensus_hash
+        };
+
+        let get_nakamoto_inv =
+            StacksMessageType::GetNakamotoInv(GetNakamotoInvData { consensus_hash });
+        let signed_get_nakamoto_inv = convo
+            .sign_message(&chain_view, &privk, get_nakamoto_inv)
+            .unwrap();
+        get_nakamoto_invs.push(signed_get_nakamoto_inv);
+    }
+
+    let (shutdown_send, shutdown_recv) = sync_channel(1);
+    let join_handle = thread::spawn(move || {
+        loop {
+            peer.step_with_ibd(false).unwrap();
+            if let Ok(..) = shutdown_recv.try_recv() {
+                break;
+            }
+        }
+        peer
+    });
+
+    let mut tcp_socket = TcpStream::connect(peer_addr).unwrap();
+
+    // first, handshake
+    let handshake_data = StacksMessageType::Handshake(HandshakeData::from_local_peer(&client_peer));
+    let signed_handshake_data = convo
+        .sign_message(&chain_view, &privk, handshake_data)
+        .unwrap();
+    signed_handshake_data
+        .consensus_serialize(&mut tcp_socket)
+        .unwrap();
+
+    // read back handshake-accept
+    let msg: StacksMessage = read_next(&mut tcp_socket).unwrap();
+    match msg.payload {
+        StacksMessageType::HandshakeAccept(..)
+        | StacksMessageType::StackerDBHandshakeAccept(..) => {}
+        x => {
+            error!("Peer returned {:?}", &x);
+            panic!();
+        }
+    }
+
+    let mut replies = vec![];
+    for get_nakamoto_inv in get_nakamoto_invs {
+        // send getnakamotoinv
+        get_nakamoto_inv
+            .consensus_serialize(&mut tcp_socket)
+            .unwrap();
+
+        loop {
+            // read back the message
+            let msg: StacksMessage = read_next(&mut tcp_socket).unwrap();
+            let is_inv_reply = if let StacksMessageType::NakamotoInv(..) = &msg.payload {
+                true
+            } else {
+                false
+            };
+            if is_inv_reply {
+                replies.push(msg.payload);
+                break;
+            } else {
+                debug!("Got spurious meessage {:?}", &msg);
+            }
+        }
+    }
+
+    shutdown_send.send(true).unwrap();
+    let peer = join_handle.join().unwrap();
+
+    (peer, replies)
+}
+
+#[test]
+fn test_nakamoto_inv_10_tenures_10_sortitions() {
+    let peer = simple_nakamoto_coordinator_10_tenures_10_sortitions();
+
+    // sanity check -- nakamoto begins at height 37
+    assert_eq!(
+        peer.config.epochs,
+        Some(StacksEpoch::unit_test_3_0_only(37))
+    );
+
+    let (mut peer, reward_cycle_invs) =
+        peer_get_nakamoto_invs(peer, &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]);
+    assert_eq!(reward_cycle_invs.len(), 10);
+
+    let chainstate = &mut peer.stacks_node.as_mut().unwrap().chainstate;
+    let sort_db = peer.sortdb.as_mut().unwrap();
+
+    let mut inv_generator = InvGenerator::new();
+
+    // processed 10 tenures
+    let tip = SortitionDB::get_canonical_burn_chain_tip(sort_db.conn()).unwrap();
+    assert_eq!(tip.block_height, 46);
+
+    // check the reward cycles
+    for (rc, inv) in reward_cycle_invs.into_iter().enumerate() {
+        let bitvec = inv_generator
+            .make_tenure_bitvector(&tip, sort_db, chainstate, rc as u64)
+            .unwrap();
+        debug!(
+            "At reward cycle {}: {:?}, mesasge = {:?}",
+            rc, &bitvec, &inv
+        );
+
+        if rc <= 6 {
+            // prior to start of nakamoto
+            assert_eq!(bitvec, vec![false, false, false, false, false]);
+        } else if rc == 7 {
+            // first Nakamoto tenure starts at block 37
+            assert_eq!(bitvec, vec![false, false, true, true, true]);
+        } else if rc == 8 {
+            // full reward cycle of nakamoto
+            assert_eq!(bitvec, vec![true, true, true, true, true]);
+        } else if rc == 9 {
+            // we stopped at height 46
+            assert_eq!(bitvec, vec![true, true]);
+        } else if rc >= 10 {
+            // haven't processed this high yet
+            assert_eq!(bitvec.len(), 0);
+        }
+
+        let StacksMessageType::NakamotoInv(inv) = inv else {
+            panic!("Did not receive an inv for reward cycle {}", rc);
+        };
+        assert_eq!(NakamotoInvData::bools_to_bitvec(&bitvec), inv.tenures);
+        assert_eq!(bitvec.len() as u16, inv.bitlen);
+    }
+}
+
+#[test]
+fn test_nakamoto_inv_2_tenures_3_sortitions() {
+    let peer = simple_nakamoto_coordinator_2_tenures_3_sortitions();
+
+    // sanity check -- nakamoto begins at height 37
+    assert_eq!(
+        peer.config.epochs,
+        Some(StacksEpoch::unit_test_3_0_only(37))
+    );
+
+    let (mut peer, reward_cycle_invs) =
+        peer_get_nakamoto_invs(peer, &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]);
+    assert_eq!(reward_cycle_invs.len(), 8);
+
+    let chainstate = &mut peer.stacks_node.as_mut().unwrap().chainstate;
+    let sort_db = peer.sortdb.as_mut().unwrap();
+
+    let mut inv_generator = InvGenerator::new();
+
+    // processed 3 sortitions
+    let tip = SortitionDB::get_canonical_burn_chain_tip(sort_db.conn()).unwrap();
+    assert_eq!(tip.block_height, 39);
+
+    for (rc, inv) in reward_cycle_invs.into_iter().enumerate() {
+        let bitvec = inv_generator
+            .make_tenure_bitvector(&tip, sort_db, chainstate, rc as u64)
+            .unwrap();
+        debug!(
+            "At reward cycle {}: {:?}, mesasge = {:?}",
+            rc, &bitvec, &inv
+        );
+
+        if rc <= 6 {
+            // prior to start of nakamoto
+            assert_eq!(bitvec, vec![false, false, false, false, false]);
+        } else if rc == 7 {
+            // nakamoto starts at height 37, but we skipeed the sortition at 38
+            assert_eq!(bitvec, vec![false, false, true, false, true]);
+        } else {
+            assert_eq!(bitvec.len(), 0);
+        }
+        let StacksMessageType::NakamotoInv(inv) = inv else {
+            panic!("Did not receive an inv for reward cycle {}", rc);
+        };
+        assert_eq!(NakamotoInvData::bools_to_bitvec(&bitvec), inv.tenures);
+        assert_eq!(bitvec.len() as u16, inv.bitlen);
+    }
+}
+
+#[test]
+fn test_nakamoto_inv_10_extended_tenures_10_sortitions() {
+    let peer = simple_nakamoto_coordinator_10_extended_tenures_10_sortitions();
+
+    // sanity check -- nakamoto begins at height 37
+    assert_eq!(
+        peer.config.epochs,
+        Some(StacksEpoch::unit_test_3_0_only(37))
+    );
+
+    let (mut peer, reward_cycle_invs) =
+        peer_get_nakamoto_invs(peer, &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]);
+    assert_eq!(reward_cycle_invs.len(), 10);
+
+    let chainstate = &mut peer.stacks_node.as_mut().unwrap().chainstate;
+    let sort_db = peer.sortdb.as_mut().unwrap();
+
+    let mut inv_generator = InvGenerator::new();
+
+    // processed 10 tenures
+    let tip = SortitionDB::get_canonical_burn_chain_tip(sort_db.conn()).unwrap();
+    assert_eq!(tip.block_height, 46);
+
+    for (rc, inv) in reward_cycle_invs.into_iter().enumerate() {
+        let bitvec = inv_generator
+            .make_tenure_bitvector(&tip, sort_db, chainstate, rc as u64)
+            .unwrap();
+        debug!("At reward cycle {}: {:?}", rc, &bitvec);
+
+        if rc <= 6 {
+            // prior to start of nakamoto
+            assert_eq!(bitvec, vec![false, false, false, false, false]);
+        } else if rc == 7 {
+            // first Nakamoto tenure starts at block 37
+            assert_eq!(bitvec, vec![false, false, true, true, true]);
+        } else if rc == 8 {
+            // full reward cycle of nakamoto
+            assert_eq!(bitvec, vec![true, true, true, true, true]);
+        } else if rc == 9 {
+            // we stopped at height 46
+            assert_eq!(bitvec, vec![true, true]);
+        } else if rc >= 10 {
+            // haven't processed this high yet
+            assert_eq!(bitvec.len(), 0);
+        }
+        let StacksMessageType::NakamotoInv(inv) = inv else {
+            panic!("Did not receive an inv for reward cycle {}", rc);
+        };
+        assert_eq!(NakamotoInvData::bools_to_bitvec(&bitvec), inv.tenures);
+        assert_eq!(bitvec.len() as u16, inv.bitlen);
+    }
+}

From afcc25356137ec801215c94b16bbd67a7149ed11 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Fri, 5 Jan 2024 13:20:56 -0500
Subject: [PATCH 0280/1166] chore: test codes for GetNakamotoInv and
 NakamotoInv

---
 stackslib/src/net/codec.rs | 75 ++++++++++++++++++++++++++++++++++++--
 1 file changed, 71 insertions(+), 4 deletions(-)

diff --git a/stackslib/src/net/codec.rs b/stackslib/src/net/codec.rs
index 1bfd244cd1..8742924832 100644
--- a/stackslib/src/net/codec.rs
+++ b/stackslib/src/net/codec.rs
@@ -1561,6 +1561,7 @@ pub mod test {
     use stacks_common::util::secp256k1::*;
 
     use super::*;
+    use crate::net::{GetNakamotoInvData, NakamotoInvData};
 
     fn check_overflow<T>(r: Result<T, net_error>) -> bool {
         match r {
@@ -1958,10 +1959,7 @@ pub mod test {
             0x00, 0x00, 0x00, 0x00,
         ];
 
-        check_codec_and_corruption::<BlocksInvData>(
-            &maximal_blocksinvdata,
-            &maximal_blocksinvdata_bytes,
-        );
+        assert!(check_deserialize_failure::<BlocksInvData>(&empty_inv));
     }
 
     #[test]
@@ -2368,6 +2366,68 @@ pub mod test {
         check_codec_and_corruption::<StackerDBPushChunkData>(&push_data, &bytes);
     }
 
+    #[test]
+    fn codec_GetNakamotoInv() {
+        let get_nakamoto_inv = GetNakamotoInvData {
+            consensus_hash: ConsensusHash([0x55; 20]),
+        };
+
+        let get_nakamoto_inv_bytes: Vec<u8> = vec![
+            // consensus hash
+            0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
+            0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
+        ];
+
+        check_codec_and_corruption::<GetNakamotoInvData>(
+            &get_nakamoto_inv,
+            &get_nakamoto_inv_bytes,
+        );
+    }
+
+    #[test]
+    fn codec_NakamotoInv() {
+        let nakamoto_inv = NakamotoInvData {
+            tenures: vec![0xdd, 0xee, 0xaa, 0xdd, 0xbb, 0xee, 0xee, 0xff],
+            bitlen: 64,
+        };
+
+        let nakamoto_inv_bytes = vec![
+            // bitlen
+            0x00, 0x40, // tenures.len()
+            0x00, 0x00, 0x00, 0x08, // tenures
+            0xdd, 0xee, 0xaa, 0xdd, 0xbb, 0xee, 0xee, 0xff,
+        ];
+
+        check_codec_and_corruption::<NakamotoInvData>(&nakamoto_inv, &nakamoto_inv_bytes);
+
+        // test that read_next_exact() works for the tenures bitvec
+        let long_bitlen = NakamotoInvData {
+            bitlen: 1,
+            tenures: vec![0xff, 0x01],
+        };
+        assert!(check_deserialize_failure::<NakamotoInvData>(&long_bitlen));
+
+        let short_bitlen = NakamotoInvData {
+            bitlen: 9,
+            tenures: vec![0xff],
+        };
+        assert!(check_deserialize_failure::<NakamotoInvData>(&short_bitlen));
+
+        // works for empty ones
+        let nakamoto_inv = NakamotoInvData {
+            tenures: vec![],
+            bitlen: 0,
+        };
+
+        let nakamoto_inv_bytes = vec![
+            // bitlen
+            0x00, 0x00, // tenures.len()
+            0x00, 0x00, 0x00, 0x00,
+        ];
+
+        assert!(check_deserialize_failure::<NakamotoInvData>(&nakamoto_inv));
+    }
+
     #[test]
     fn codec_StacksMessage() {
         let payloads: Vec<StacksMessageType> = vec![
@@ -2541,6 +2601,13 @@ pub mod test {
                     data: vec![0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff]
                 }
             }),
+            StacksMessageType::GetNakamotoInv(GetNakamotoInvData {
+                consensus_hash: ConsensusHash([0x01; 20]),
+            }),
+            StacksMessageType::NakamotoInv(NakamotoInvData {
+                tenures: vec![0xdd, 0xee, 0xaa, 0xdd, 0xbb, 0xee, 0xee, 0xff],
+                bitlen: 64
+            }),
         ];
 
         let mut maximal_relayers: Vec<RelayData> = vec![];

From ead0b733adfb13d81c0e183800f208de3573435a Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Fri, 5 Jan 2024 13:21:26 -0500
Subject: [PATCH 0281/1166] chore: cargo fmt

---
 stackslib/src/net/inv/mod.rs            |  4 ++--
 stackslib/src/net/inv/nakamoto.rs       | 10 +++------
 stackslib/src/net/inv/tests/epoch2x.rs  |  7 ++-----
 stackslib/src/net/inv/tests/nakamoto.rs | 27 +++++++++----------------
 4 files changed, 17 insertions(+), 31 deletions(-)

diff --git a/stackslib/src/net/inv/mod.rs b/stackslib/src/net/inv/mod.rs
index 6bb5f9e88d..5a80e682a8 100644
--- a/stackslib/src/net/inv/mod.rs
+++ b/stackslib/src/net/inv/mod.rs
@@ -21,6 +21,6 @@ pub mod nakamoto;
 pub mod tests;
 
 // Stacks 2.x inventory state machine
-pub use crate::net::inv::epoch2x as inv2x;
-
 pub use inv2x::{INV_REWARD_CYCLES, INV_SYNC_INTERVAL};
+
+pub use crate::net::inv::epoch2x as inv2x;
diff --git a/stackslib/src/net/inv/nakamoto.rs b/stackslib/src/net/inv/nakamoto.rs
index a56ce11867..eecefbc041 100644
--- a/stackslib/src/net/inv/nakamoto.rs
+++ b/stackslib/src/net/inv/nakamoto.rs
@@ -17,14 +17,10 @@
 use std::collections::HashMap;
 
 use crate::chainstate::burn::db::sortdb::SortitionDB;
-use crate::chainstate::burn::BlockSnapshot;
-use crate::chainstate::burn::ConsensusHash;
-
+use crate::chainstate::burn::{BlockSnapshot, ConsensusHash};
 use crate::chainstate::nakamoto::NakamotoChainState;
 use crate::chainstate::stacks::db::StacksChainState;
-use crate::net::Error as NetError;
-use crate::net::NakamotoInvData;
-
+use crate::net::{Error as NetError, NakamotoInvData};
 use crate::util_lib::db::Error as DBError;
 
 /// Cached data for a sortition in the sortition DB.
@@ -182,7 +178,7 @@ impl InvGenerator {
             };
             let parent_sortition_consensus_hash = cur_sortition_info.parent_consensus_hash.clone();
 
-            debug!("Get sortition and tenure info for height {}. cur_consensus_hash = {}, cur_tenure_info = {:?}, cur_sortition_info = {:?}", cur_height, &cur_consensus_hash, &cur_tenure_opt, cur_sortition_info);
+            test_debug!("Get sortition and tenure info for height {}. cur_consensus_hash = {}, cur_tenure_info = {:?}, cur_sortition_info = {:?}", cur_height, &cur_consensus_hash, &cur_tenure_opt, cur_sortition_info);
 
             if let Some(cur_tenure_info) = cur_tenure_opt.as_ref() {
                 // a tenure was active when this sortition happened...
diff --git a/stackslib/src/net/inv/tests/epoch2x.rs b/stackslib/src/net/inv/tests/epoch2x.rs
index 9862024f4a..e672cf7961 100644
--- a/stackslib/src/net/inv/tests/epoch2x.rs
+++ b/stackslib/src/net/inv/tests/epoch2x.rs
@@ -21,17 +21,14 @@ use stacks_common::deps_common::bitcoin::network::serialize::BitcoinHash;
 use crate::burnchains::bitcoin::indexer::BitcoinIndexer;
 use crate::burnchains::db::BurnchainHeaderReader;
 use crate::burnchains::tests::BURNCHAIN_TEST_BLOCK_TIME;
-use crate::burnchains::Burnchain;
-use crate::burnchains::BurnchainView;
-use crate::burnchains::{BurnchainBlockHeader, PoxConstants};
+use crate::burnchains::{Burnchain, BurnchainBlockHeader, BurnchainView, PoxConstants};
 use crate::chainstate::burn::db::sortdb::SortitionHandleConn;
 use crate::chainstate::coordinator::tests::get_burnchain;
 use crate::chainstate::stacks::*;
 use crate::net::chat::ConversationP2P;
 use crate::net::inv::inv2x::*;
 use crate::net::test::*;
-use crate::net::Error as net_error;
-use crate::net::*;
+use crate::net::{Error as net_error, *};
 use crate::util_lib::test::*;
 
 #[test]
diff --git a/stackslib/src/net/inv/tests/nakamoto.rs b/stackslib/src/net/inv/tests/nakamoto.rs
index a4b9b6b95e..f962123d1c 100644
--- a/stackslib/src/net/inv/tests/nakamoto.rs
+++ b/stackslib/src/net/inv/tests/nakamoto.rs
@@ -20,34 +20,27 @@ use std::sync::mpsc::sync_channel;
 use std::thread;
 use std::thread::JoinHandle;
 
+use stacks_common::codec::{read_next, StacksMessageCodec};
+use stacks_common::types::chainstate::StacksPrivateKey;
+use stacks_common::types::StacksEpoch;
+
 use crate::chainstate::burn::db::sortdb::SortitionDB;
 use crate::chainstate::burn::ConsensusHash;
-
 use crate::chainstate::nakamoto::coordinator::tests::{
     simple_nakamoto_coordinator_10_extended_tenures_10_sortitions,
     simple_nakamoto_coordinator_10_tenures_10_sortitions,
     simple_nakamoto_coordinator_2_tenures_3_sortitions,
 };
 use crate::chainstate::nakamoto::NakamotoChainState;
-
 use crate::chainstate::stacks::db::StacksChainState;
-use crate::net::Error as NetError;
-use crate::net::GetNakamotoInvData;
-use crate::net::HandshakeData;
-use crate::net::NakamotoInvData;
-use crate::util_lib::db::Error as DBError;
-
-use stacks_common::codec::read_next;
-use stacks_common::codec::StacksMessageCodec;
-use stacks_common::types::chainstate::StacksPrivateKey;
-
+use crate::core::StacksEpochExtension;
 use crate::net::inv::nakamoto::InvGenerator;
 use crate::net::test::TestPeer;
-use crate::net::StacksMessage;
-use crate::net::StacksMessageType;
-
-use crate::core::StacksEpochExtension;
-use stacks_common::types::StacksEpoch;
+use crate::net::{
+    Error as NetError, GetNakamotoInvData, HandshakeData, NakamotoInvData, StacksMessage,
+    StacksMessageType,
+};
+use crate::util_lib::db::Error as DBError;
 
 /// Handshake with and get the reward cycle inventories for a range of reward cycles
 fn peer_get_nakamoto_invs(

From 0a5370f68218e869c1d39afa789e9009fba04418 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Fri, 5 Jan 2024 14:16:20 -0500
Subject: [PATCH 0282/1166] fix: ensure test names for test peers don't depend
 on ports

---
 stackslib/src/net/inv/tests/epoch2x.rs | 8 +++++---
 stackslib/src/net/mod.rs               | 7 +++++--
 2 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/stackslib/src/net/inv/tests/epoch2x.rs b/stackslib/src/net/inv/tests/epoch2x.rs
index e672cf7961..4f0072ba08 100644
--- a/stackslib/src/net/inv/tests/epoch2x.rs
+++ b/stackslib/src/net/inv/tests/epoch2x.rs
@@ -541,12 +541,14 @@ fn test_sync_inv_set_blocks_microblocks_available() {
     let mut peer_1_config = TestPeerConfig::new(function_name!(), 0, 0);
     let mut peer_2_config = TestPeerConfig::new(function_name!(), 0, 0);
 
-    let peer_1_test_path = TestPeer::make_test_path(&peer_1_config);
-    let peer_2_test_path = TestPeer::make_test_path(&peer_2_config);
-
     let mut peer_1 = TestPeer::new(peer_1_config.clone());
     let mut peer_2 = TestPeer::new(peer_2_config.clone());
 
+    let peer_1_test_path = TestPeer::make_test_path(&peer_1.config);
+    let peer_2_test_path = TestPeer::make_test_path(&peer_2.config);
+
+    assert!(peer_1_test_path != peer_2_test_path);
+
     for (test_path, burnchain) in [
         (peer_1_test_path, &mut peer_1.config.burnchain),
         (peer_2_test_path, &mut peer_2.config.burnchain),
diff --git a/stackslib/src/net/mod.rs b/stackslib/src/net/mod.rs
index e746934a01..eb2a41077e 100644
--- a/stackslib/src/net/mod.rs
+++ b/stackslib/src/net/mod.rs
@@ -1598,7 +1598,7 @@ pub mod test {
     use clarity::vm::database::STXBalance;
     use clarity::vm::types::*;
     use clarity::vm::ClarityVersion;
-    use rand::RngCore;
+    use rand::{Rng, RngCore};
     use stacks_common::address::*;
     use stacks_common::codec::StacksMessageCodec;
     use stacks_common::deps_common::bitcoin::network::serialize::BitcoinHash;
@@ -2146,9 +2146,11 @@ pub mod test {
         }
 
         pub fn test_path(config: &TestPeerConfig) -> String {
+            let random = thread_rng().gen::<u64>();
+            let random_bytes = to_hex(&random.to_be_bytes());
             format!(
                 "/tmp/stacks-node-tests/units-test-peer/{}-{}",
-                &config.test_name, config.server_port
+                &config.test_name, random_bytes
             )
         }
 
@@ -2491,6 +2493,7 @@ pub mod test {
                 )
                 .unwrap();
 
+            debug!("Bound to (p2p={}, http={})", p2p_port, http_port);
             config.server_port = p2p_port;
             config.http_port = http_port;
 

From ff3124efc02f133e4dc5f135360af6ca2c27f286 Mon Sep 17 00:00:00 2001
From: ASuciuX <asuciu@hiro.so>
Date: Sun, 7 Jan 2024 22:55:12 +0200
Subject: [PATCH 0283/1166] modularize mutants' runs for different package size
 cases

Cases:
- if >= 16 mutants on big packages => run big packages using 8 shards
- else run big packages without shards

- if >= 16 mutants on big packages and >= 120 mutants on small packages => run small packages using 4 shards
- else if < 16 mutants on big packages and >= 80 mutants on small packages => run small packages using 4 shards
- else run small packages without shards
---
 .github/workflows/filter-pr-mutants.yml | 351 +++++++++++++++++++++++-
 1 file changed, 346 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/filter-pr-mutants.yml b/.github/workflows/filter-pr-mutants.yml
index c0a9c0b1ec..a8c40e0ff3 100644
--- a/.github/workflows/filter-pr-mutants.yml
+++ b/.github/workflows/filter-pr-mutants.yml
@@ -8,15 +8,356 @@ on:
       - synchronize
       - ready_for_review
     paths:
-      - '**.rs'
+      - "**.rs"
+
+concurrency:
+  group: filter-pr-${{ github.head_ref || github.ref || github.run_id }}
+  # Always cancel duplicate jobs
+  cancel-in-progress: true
 
 jobs:
-  # Mutants testing: Execute on PR on packages that have functions modified, and fail the workflow if there are missed or timeout mutations
-  incremental-mutants:
-    name: Incremental Mutants Testing
+  # Check and output whether to run big (`stacks-node`/`stackslib`) or small (others) packages with or without shards
+  check-big-packages-and-shards:
+    name: Check Packages and Shards
 
     runs-on: ubuntu-latest
 
+    outputs:
+      run_big_packages: ${{ steps.check_packages_and_shards.outputs.run_big_packages }}
+      big_packages_with_shards: ${{ steps.check_packages_and_shards.outputs.big_packages_with_shards }}
+      run_small_packages: ${{ steps.check_packages_and_shards.outputs.run_small_packages }}
+      small_packages_with_shards: ${{ steps.check_packages_and_shards.outputs.small_packages_with_shards }}
+
     steps:
-      - name: Run filtering pr mutants from actions
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - run: cargo install --version 23.12.2 cargo-mutants
+
+      - name: Relative diff
+        run: |
+          git diff origin/${{ github.base_ref }}.. > git.diff
+
+      - name: Remove deleted file's lines from git.diff file
+        run: |
+          input_file="git.diff"
+          temp_file="temp_diff_file.diff"
+
+          # Reverse the file, remove 4 lines after '+++ /dev/null', then reverse it back (editors can't go backwards - to remove lines above)
+          tac "$input_file" > "$temp_file" && mv "$temp_file" "$input_file"
+          sed '/+++ \/dev\/null/{n;N;N;N;d;}' "$input_file" > "$temp_file" && mv "$temp_file" "$input_file"
+          tac "$input_file" > "$temp_file" && mv "$temp_file" "$input_file"
+
+          # Remove the lines between '+++ /dev/null' (included) and 'diff --git a/'
+          awk '
+            BEGIN { in_block=0 }
+            /\+\+\+ \/dev\/null/ { in_block=1; next }
+            in_block && /diff --git a\// { in_block=0; print; next }
+            !in_block
+          ' "$input_file" > "$temp_file" && mv "$temp_file" "$input_file"
+
+      - name: Split diffs into big and small packages
+        run: |
+          cargo mutants --in-diff git.diff --list > all_mutants.txt
+          mkdir -p mutants_by_packages
+
+          # Split the differences from git into 2 parts, big packages ('stacks-node' and 'stackslib') and small packages (all others) and put them into separate files
+          while IFS= read -r line; do
+            package=$(echo "$line" | cut -d'/' -f1)
+            if [[ $package == "testnet" || $package == "stackslib" ]]; then
+              echo "$line" >> "mutants_by_packages/big_packages.txt"
+            else
+              echo "$line" >> "mutants_by_packages/small_packages.txt"
+            fi
+          done < all_mutants.txt
+
+      - id: check_packages_and_shards
+        run: |
+          number_of_big_mutants=0
+          number_of_small_mutants=0
+
+          # If big_packages file exists, count how many mutants there are
+          if [[ -s mutants_by_packages/big_packages.txt ]]; then
+            number_of_big_mutants=$(cat mutants_by_packages/big_packages.txt | awk 'END { print NR }' | tr -d '[:space:]')
+          fi
+
+          # If small_packages file exists, count how many mutants there are
+          if [[ -s mutants_by_packages/small_packages.txt ]]; then
+            number_of_small_mutants=$(cat mutants_by_packages/small_packages.txt | awk 'END { print NR }' | tr -d '[:space:]')
+          fi
+
+          # Set the mutants limit for when to run with shards on the small packages
+          if [[ $number_of_big_mutants -gt 15 ]]; then
+            small_packages_shard_limit=119
+          else
+            small_packages_shard_limit=79
+          fi
+
+          # If there are mutants from big packages, check whether to run with or without shards, otherwise there's nothing to run
+          if [[ $number_of_big_mutants -ne 0 ]]; then
+            echo "run_big_packages=true" >> "$GITHUB_OUTPUT"
+            if [[ $number_of_big_mutants -gt 15 ]]; then
+              echo "big_packages_with_shards=true" >> "$GITHUB_OUTPUT"
+            else
+              echo "big_packages_with_shards=false" >> "$GITHUB_OUTPUT"
+            fi
+          else
+            echo "run_big_packages=false" >> "$GITHUB_OUTPUT"
+          fi
+
+          # If there are mutants from small packages, check whether to run with or without shards, otherwise there's nothing to run
+          if [[ $number_of_small_mutants -ne 0 ]]; then
+            echo "run_small_packages=true" >> "$GITHUB_OUTPUT"
+            if [[ $number_of_small_mutants -gt $small_packages_shard_limit ]]; then
+              echo "small_packages_with_shards=true" >> "$GITHUB_OUTPUT"
+            else
+              echo "small_packages_with_shards=false" >> "$GITHUB_OUTPUT"
+            fi
+          else
+            echo "run_small_packages=false" >> "$GITHUB_OUTPUT"
+          fi
+
+  # Mutation testing - Execute on PR on small packages that have functions modified (normal run, no shards)
+  filter-pr-mutants-small-normal:
+    name: Mutation Testing - Normal, Small
+
+    needs: check-big-packages-and-shards
+
+    if: ${{ needs.check-big-packages-and-shards.outputs.run_small_packages == 'true' && needs.check-big-packages-and-shards.outputs.small_packages_with_shards == 'false' }}
+
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Run filtering pr mutants from actions - no shards, small packages
         uses: stacks-network/actions/mutation-testing/filter-pr@feat/mutation-testing
+        with:
+          package-dimension: "small"
+
+  # Mutation testing - Execute on PR on small packages that have functions modified (run with strategy matrix shards)
+  filter-pr-mutants-small-shards:
+    name: Mutation Testing - Shards, Small
+
+    needs: check-big-packages-and-shards
+
+    if: ${{ needs.check-big-packages-and-shards.outputs.run_small_packages == 'true' && needs.check-big-packages-and-shards.outputs.small_packages_with_shards == 'true' }}
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      fail-fast: false
+      matrix:
+        shard: [0, 1, 2, 3]
+
+    steps:
+      - name: Run filtering pr mutants from actions - with shards, small packages
+        uses: stacks-network/actions/mutation-testing/filter-pr@feat/mutation-testing
+        with:
+          shard: ${{ matrix.shard }}
+          package-dimension: "small"
+
+  # Mutation testing - Execute on PR on big packages that have functions modified (normal run, no shards)
+  filter-pr-mutants-big-normal:
+    name: Mutation Testing - Normal, Big
+
+    needs: check-big-packages-and-shards
+
+    if: ${{ needs.check-big-packages-and-shards.outputs.run_big_packages == 'true' && needs.check-big-packages-and-shards.outputs.big_packages_with_shards == 'false' }}
+
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Run filtering pr mutants from actions - no shards, big packages
+        env:
+          BITCOIND_TEST: 1
+          RUST_BACKTRACE: full
+        uses: stacks-network/actions/mutation-testing/filter-pr@feat/mutation-testing
+        with:
+          package-dimension: "big"
+
+  # Mutation testing - Execute on PR on big packages that have functions modified (run with strategy matrix shards)
+  filter-pr-mutants-big-shards:
+    name: Mutation Testing - Shards, Big
+
+    needs: check-big-packages-and-shards
+
+    if: ${{ needs.check-big-packages-and-shards.outputs.run_big_packages == 'true' && needs.check-big-packages-and-shards.outputs.big_packages_with_shards == 'true' }}
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      fail-fast: false
+      matrix:
+        shard: [0, 1, 2, 3, 4, 5, 6, 7]
+
+    steps:
+      - name: Run filtering pr mutants from actions - with shards, big packages
+        env:
+          BITCOIND_TEST: 1
+          RUST_BACKTRACE: full
+        uses: stacks-network/actions/mutation-testing/filter-pr@feat/mutation-testing
+        with:
+          shard: ${{ matrix.shard }}
+          package-dimension: "big"
+
+  # Output the mutants and fail the workflow if there are missed/timeout/unviable mutants
+  output-mutants:
+    name: Output Mutants
+
+    runs-on: ubuntu-latest
+
+    if: always()
+    needs:
+      [
+        filter-pr-mutants-small-normal,
+        filter-pr-mutants-small-shards,
+        filter-pr-mutants-big-normal,
+        filter-pr-mutants-big-shards,
+      ]
+
+    steps:
+      - name: Download all workflow run artifacts
+        uses: actions/download-artifact@v3
+
+      - name: Append output from all shards
+        run: |
+          folders=("mutants-shard-big--1" "mutants-shard-big-0" "mutants-shard-big-1" "mutants-shard-big-2" "mutants-shard-big-3" "mutants-shard-big-4" "mutants-shard-big-5" "mutants-shard-big-6" "mutants-shard-big-7" "mutants-shard-small--1" "mutants-shard-small-0" "mutants-shard-small-1" "mutants-shard-small-2" "mutants-shard-small-3")
+          files=("missed.txt" "caught.txt" "timeout.txt" "unviable.txt")
+          mkdir -p mutants-shards
+
+          for file in "${files[@]}"; do
+            for folder in "${folders[@]}"; do
+              if [[ -s "$folder/$file" ]]; then
+                cat "$folder/$file" >> "mutants-shards/$file"
+              fi
+            done
+          done
+
+          for folder in "${folders[@]}"; do
+            if [[ -s "$folder" ]]; then
+              exit_code=$(<"${folder}/exit_code.txt")
+              most_relevant_exit_code=0
+
+              case $exit_code in
+              4)
+                most_relevant_exit_code=4
+                ;;
+              1)
+                [ "$most_relevant_exit_code" -eq 0 ] && most_relevant_exit_code=1
+                ;;
+              2)
+                [ "$most_relevant_exit_code" -eq 0 ] && most_relevant_exit_code=2
+                ;;
+              3)
+                [ "$most_relevant_exit_code" -eq 0 ] && most_relevant_exit_code=3
+                ;;
+              0)
+                ;;
+              *)
+                echo "Unknown exit code $exit_code"
+                most_relevant_exit_code=$exit_code
+                ;;
+              esac
+            fi
+          done
+
+          echo "$most_relevant_exit_code" > './mutants-shards/exit_code.txt'
+
+      - name: Print mutants and handle exit codes
+        run: |
+          server_url="${{ github.server_url }}"
+          organisation="${{ github.repository_owner }}"
+          repository="${{ github.event.repository.name }}"
+          commit="${{ github.sha }}"
+
+          write_section() {
+            local section_title=$1
+            local file_name=$2
+
+            if [ -s "$file_name" ]; then
+              if [[ "$section_title" != "" ]]; then
+                echo "## $section_title" >> "$GITHUB_STEP_SUMMARY"
+              fi
+
+              if [[ "$section_title" == "Missed:" ]]; then
+                echo "<details>" >> "$GITHUB_STEP_SUMMARY"
+                echo "<summary>What are missed mutants?</summary>" >> "$GITHUB_STEP_SUMMARY"
+                echo "<br>" >> "$GITHUB_STEP_SUMMARY"
+                echo "No test failed with this mutation applied, which seems to indicate a gap in test coverage. Or, it may be that the mutant is undistinguishable from the correct code. You may wish to add a better test, or mark that the function should be skipped." >> "$GITHUB_STEP_SUMMARY"
+                echo "</details>" >> "$GITHUB_STEP_SUMMARY"
+                echo "" >> "$GITHUB_STEP_SUMMARY"
+              elif [[ "$section_title" == "Timeout:" ]]; then
+                echo "<details>" >> "$GITHUB_STEP_SUMMARY"
+                echo "<summary>What are timeout mutants?</summary>" >> "$GITHUB_STEP_SUMMARY"
+                echo "<br>" >> "$GITHUB_STEP_SUMMARY"
+                echo "The mutation caused the test suite to run for a long time, until it was eventually killed. You might want to investigate the cause and potentially mark the function to be skipped." >> "$GITHUB_STEP_SUMMARY"
+                echo "</details>" >> "$GITHUB_STEP_SUMMARY"
+                echo "" >> "$GITHUB_STEP_SUMMARY"
+              elif [[ "$section_title" == "Unviable:" ]]; then
+                echo "<details>" >> "$GITHUB_STEP_SUMMARY"
+                echo "<summary>What are unviable mutants?</summary>" >> "$GITHUB_STEP_SUMMARY"
+                echo "<br>" >> "$GITHUB_STEP_SUMMARY"
+                echo "The attempted mutation doesn't compile. This is inconclusive about test coverage and no action is needed, unless you wish to test the specific function, in which case you may wish to add a 'Default::default()' implementation for the specific return type." >> "$GITHUB_STEP_SUMMARY"
+                echo "</details>" >> "$GITHUB_STEP_SUMMARY"
+                echo "" >> "$GITHUB_STEP_SUMMARY"
+              fi
+
+              if [[ "$section_title" != "" ]]; then
+                awk -F':' '{printf "- [ ] " "[" $0 "]"; file_path=$1; line=$2; $1=""; $2=""; printf "(" "'"$server_url"'/'"$organisation"'/'"$repository"'/blob/'"$commit"'/" file_path "#L" line-1 ")\n\n"}' "$file_name" >> "$GITHUB_STEP_SUMMARY"
+              else
+                awk -F':' '{printf "- [x] " "[" $0 "]"; file_path=$1; line=$2; $1=""; $2=""; printf "(" "'"$server_url"'/'"$organisation"'/'"$repository"'/blob/'"$commit"'/" file_path "#L" line-1 ")\n\n"}' "$file_name" >> "$GITHUB_STEP_SUMMARY"
+              fi
+
+              if [[ "$section_title" == "Missed:" ]]; then
+                echo "### To resolve this issue, consider one of the following options:" >> "$GITHUB_STEP_SUMMARY"
+                echo "- Modify or add tests including this function." >> "$GITHUB_STEP_SUMMARY"
+                echo "- If you are absolutely certain that this function should not undergo mutation testing, add '#[mutants::skip]' or '#[cfg_attr(test, mutants::skip)]' function header to skip it." >> "$GITHUB_STEP_SUMMARY"
+              elif [[ "$section_title" == "Timeout:" ]]; then
+                echo "### To resolve this issue, consider one of the following options:" >> "$GITHUB_STEP_SUMMARY"
+                echo "- Modify the tests that include this funcion." >> "$GITHUB_STEP_SUMMARY"
+                echo "- Add '#[mutants::skip]' or '#[cfg_attr(test, mutants::skip)]' function header to skip it." >> "$GITHUB_STEP_SUMMARY"
+              elif [[ "$section_title" == "Unviable:" ]]; then
+                echo "### To resolve this issue, consider one of the following options:" >> "$GITHUB_STEP_SUMMARY"
+                echo "- Create 'Default::default()' implementation for the specific structure." >> "$GITHUB_STEP_SUMMARY"
+                echo "- Add '#[mutants::skip]' or '#[cfg_attr(test, mutants::skip)]' function header to skip it." >> "$GITHUB_STEP_SUMMARY"
+              fi
+
+              echo >> "$GITHUB_STEP_SUMMARY"
+            fi
+          }
+
+          echo "# Uncaught Mutants" >> "$GITHUB_STEP_SUMMARY"
+          write_section "Missed:" "./mutants-shards/missed.txt"
+          write_section "Timeout:" "./mutants-shards/timeout.txt"
+          write_section "Unviable:" "./mutants-shards/unviable.txt"
+            
+          echo "# Caught Mutants" >> "$GITHUB_STEP_SUMMARY"
+          write_section "" "./mutants-shards/caught.txt"
+
+          exit_code=$(<"mutants-shards/exit_code.txt")
+
+          case $exit_code in
+            0)
+                if [ -s ./mutants-shards/unviable.txt ]; then
+                  echo "Found unviable mutants!"
+                  exit 1
+                fi
+              echo "All new and updated functions are caught!"
+              ;;
+            1)
+              echo "Invalid command line arguments!"
+              exit 1
+              ;;
+            2 | 3)
+              echo "Found missed/timeout/unviable mutants!"
+              exit 1
+              ;;
+            4)
+              echo "Building the packages failed without any mutations!"
+              exit 1
+              ;;
+            *)
+              echo "Unknown exit code: $exit_code"
+              exit 1
+            ;;
+          esac

From b90dc0644755528069aa84236169087565a2e6c3 Mon Sep 17 00:00:00 2001
From: ASuciuX <asuciu@hiro.so>
Date: Mon, 8 Jan 2024 16:39:42 +0200
Subject: [PATCH 0284/1166] feat: rename from `filter-pr` to `pr-differences`

---
 ...mutants.yml => pr-differences-mutants.yml} | 36 +++++++++----------
 1 file changed, 18 insertions(+), 18 deletions(-)
 rename .github/workflows/{filter-pr-mutants.yml => pr-differences-mutants.yml} (93%)

diff --git a/.github/workflows/filter-pr-mutants.yml b/.github/workflows/pr-differences-mutants.yml
similarity index 93%
rename from .github/workflows/filter-pr-mutants.yml
rename to .github/workflows/pr-differences-mutants.yml
index a8c40e0ff3..61ec540b65 100644
--- a/.github/workflows/filter-pr-mutants.yml
+++ b/.github/workflows/pr-differences-mutants.yml
@@ -1,4 +1,4 @@
-name: Tracking PR Mutants
+name: PR Differences Mutants
 
 on:
   pull_request:
@@ -11,7 +11,7 @@ on:
       - "**.rs"
 
 concurrency:
-  group: filter-pr-${{ github.head_ref || github.ref || github.run_id }}
+  group: pr-differences-${{ github.head_ref || github.ref || github.run_id }}
   # Always cancel duplicate jobs
   cancel-in-progress: true
 
@@ -119,7 +119,7 @@ jobs:
           fi
 
   # Mutation testing - Execute on PR on small packages that have functions modified (normal run, no shards)
-  filter-pr-mutants-small-normal:
+  pr-differences-mutants-small-normal:
     name: Mutation Testing - Normal, Small
 
     needs: check-big-packages-and-shards
@@ -129,13 +129,13 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - name: Run filtering pr mutants from actions - no shards, small packages
-        uses: stacks-network/actions/mutation-testing/filter-pr@feat/mutation-testing
+      - name: Run pr differences mutants from actions - no shards, small packages
+        uses: stacks-network/actions/mutation-testing/pr-differences@feat/mutation-testing
         with:
           package-dimension: "small"
 
   # Mutation testing - Execute on PR on small packages that have functions modified (run with strategy matrix shards)
-  filter-pr-mutants-small-shards:
+  pr-differences-mutants-small-shards:
     name: Mutation Testing - Shards, Small
 
     needs: check-big-packages-and-shards
@@ -150,14 +150,14 @@ jobs:
         shard: [0, 1, 2, 3]
 
     steps:
-      - name: Run filtering pr mutants from actions - with shards, small packages
-        uses: stacks-network/actions/mutation-testing/filter-pr@feat/mutation-testing
+      - name: Run pr differences mutants from actions - with shards, small packages
+        uses: stacks-network/actions/mutation-testing/pr-differences@feat/mutation-testing
         with:
           shard: ${{ matrix.shard }}
           package-dimension: "small"
 
   # Mutation testing - Execute on PR on big packages that have functions modified (normal run, no shards)
-  filter-pr-mutants-big-normal:
+  pr-differences-mutants-big-normal:
     name: Mutation Testing - Normal, Big
 
     needs: check-big-packages-and-shards
@@ -167,16 +167,16 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - name: Run filtering pr mutants from actions - no shards, big packages
+      - name: Run pr differences mutants from actions - no shards, big packages
         env:
           BITCOIND_TEST: 1
           RUST_BACKTRACE: full
-        uses: stacks-network/actions/mutation-testing/filter-pr@feat/mutation-testing
+        uses: stacks-network/actions/mutation-testing/pr-differences@feat/mutation-testing
         with:
           package-dimension: "big"
 
   # Mutation testing - Execute on PR on big packages that have functions modified (run with strategy matrix shards)
-  filter-pr-mutants-big-shards:
+  pr-differences-mutants-big-shards:
     name: Mutation Testing - Shards, Big
 
     needs: check-big-packages-and-shards
@@ -191,11 +191,11 @@ jobs:
         shard: [0, 1, 2, 3, 4, 5, 6, 7]
 
     steps:
-      - name: Run filtering pr mutants from actions - with shards, big packages
+      - name: Run pr differences mutants from actions - with shards, big packages
         env:
           BITCOIND_TEST: 1
           RUST_BACKTRACE: full
-        uses: stacks-network/actions/mutation-testing/filter-pr@feat/mutation-testing
+        uses: stacks-network/actions/mutation-testing/pr-differences@feat/mutation-testing
         with:
           shard: ${{ matrix.shard }}
           package-dimension: "big"
@@ -209,10 +209,10 @@ jobs:
     if: always()
     needs:
       [
-        filter-pr-mutants-small-normal,
-        filter-pr-mutants-small-shards,
-        filter-pr-mutants-big-normal,
-        filter-pr-mutants-big-shards,
+        pr-differences-mutants-small-normal,
+        pr-differences-mutants-small-shards,
+        pr-differences-mutants-big-normal,
+        pr-differences-mutants-big-shards,
       ]
 
     steps:

From a4e190afe7e8ac8159ffcbea69dcab79c85324f9 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Wed, 22 Nov 2023 16:37:30 -0500
Subject: [PATCH 0285/1166] feat: Add file for `/v2/block_proposal` endpoint

---
 stackslib/src/chainstate/nakamoto/mod.rs    |   4 +-
 stackslib/src/net/api/mod.rs                |   4 +-
 stackslib/src/net/api/postblock_proposal.rs | 228 ++++++++++++++++++++
 stackslib/src/net/api/posttransaction.rs    |   2 +-
 4 files changed, 234 insertions(+), 4 deletions(-)
 create mode 100644 stackslib/src/net/api/postblock_proposal.rs

diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index 3af4293a22..7a44f3e35a 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -287,7 +287,7 @@ pub struct SetupBlockResult<'a, 'b> {
     pub auto_unlock_events: Vec<StacksTransactionEvent>,
 }
 
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct NakamotoBlockHeader {
     pub version: u8,
     /// The total number of StacksBlock and NakamotoBlocks preceding
@@ -343,7 +343,7 @@ impl FromRow<NakamotoBlockHeader> for NakamotoBlockHeader {
     }
 }
 
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct NakamotoBlock {
     pub header: NakamotoBlockHeader,
     pub txs: Vec<StacksTransaction>,
diff --git a/stackslib/src/net/api/mod.rs b/stackslib/src/net/api/mod.rs
index 3eaa6148d2..5c8f6d9cf1 100644
--- a/stackslib/src/net/api/mod.rs
+++ b/stackslib/src/net/api/mod.rs
@@ -56,6 +56,7 @@ pub mod getstackerdbmetadata;
 pub mod getstxtransfercost;
 pub mod gettransaction_unconfirmed;
 pub mod postblock;
+pub mod postblock_proposal;
 pub mod postfeerate;
 pub mod postmempoolquery;
 pub mod postmicroblock;
@@ -107,6 +108,7 @@ impl StacksHttp {
             gettransaction_unconfirmed::RPCGetTransactionUnconfirmedRequestHandler::new(),
         );
         self.register_rpc_endpoint(postblock::RPCPostBlockRequestHandler::new());
+        self.register_rpc_endpoint(postblock_proposal::RPCBlockProposalRequestHandler::new());
         self.register_rpc_endpoint(postfeerate::RPCPostFeeRateRequestHandler::new());
         self.register_rpc_endpoint(postmempoolquery::RPCMempoolQueryRequestHandler::new());
         self.register_rpc_endpoint(postmicroblock::RPCPostMicroblockRequestHandler::new());
@@ -120,7 +122,7 @@ impl From<NetError> for Error {
     fn from(e: NetError) -> Error {
         match e {
             NetError::Http(e) => e,
-            x => Error::AppError(format!("{:?}", &x)),
+            x => Error::AppError(format!("{x:?}")),
         }
     }
 }
diff --git a/stackslib/src/net/api/postblock_proposal.rs b/stackslib/src/net/api/postblock_proposal.rs
new file mode 100644
index 0000000000..fbd7a12e54
--- /dev/null
+++ b/stackslib/src/net/api/postblock_proposal.rs
@@ -0,0 +1,228 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020-2023 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+use std::io::{Read, Write};
+
+use clarity::vm::costs::ExecutionCost;
+use regex::{Captures, Regex};
+use stacks_common::codec::{
+    read_next, write_next, Error as CodecError, StacksMessageCodec, MAX_PAYLOAD_LEN,
+};
+use stacks_common::types::chainstate::{
+    BlockHeaderHash, BurnchainHeaderHash, ConsensusHash, StacksBlockId, StacksPublicKey,
+};
+use stacks_common::types::net::PeerHost;
+use stacks_common::types::StacksPublicKeyBuffer;
+use stacks_common::util::hash::{hex_bytes, Hash160, Sha256Sum};
+use stacks_common::util::retry::BoundReader;
+
+use crate::burnchains::affirmation::AffirmationMap;
+use crate::burnchains::Txid;
+use crate::chainstate::burn::db::sortdb::SortitionDB;
+use crate::chainstate::nakamoto::NakamotoBlock;
+use crate::chainstate::stacks::db::blocks::MINIMUM_TX_FEE_RATE_PER_BYTE;
+use crate::chainstate::stacks::db::StacksChainState;
+use crate::chainstate::stacks::{
+    StacksBlock, StacksBlockHeader, StacksTransaction, TransactionPayload,
+};
+use crate::core::mempool::MemPoolDB;
+use crate::cost_estimates::FeeRateEstimate;
+use crate::net::http::{
+    parse_json, Error, HttpBadRequest, HttpContentType, HttpNotFound, HttpRequest,
+    HttpRequestContents, HttpRequestPreamble, HttpResponse, HttpResponseContents,
+    HttpResponsePayload, HttpResponsePreamble, HttpServerError,
+};
+use crate::net::httpcore::{
+    request, HttpPreambleExtensions, HttpRequestContentsExtensions, RPCRequestHandler,
+    StacksHttpRequest, StacksHttpResponse,
+};
+use crate::net::p2p::PeerNetwork;
+use crate::net::relay::Relayer;
+use crate::net::{
+    Attachment, BlocksData, BlocksDatum, Error as NetError, StacksMessageType, StacksNodeState,
+};
+
+/// Represents a block proposed to the `v2/block_proposal` endpoint for validation
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct NakamotoBlockProposal {
+    /// Proposed block
+    pub block: NakamotoBlock,
+    /// Identify the stacks/burnchain fork we are on
+    pub parent_consensus_hash: ConsensusHash,
+    /// These are all the microblocks that the proposed block
+    /// will confirm.
+    pub burn_tip: BurnchainHeaderHash,
+    /// This refers to the burn block that was the current tip
+    ///  at the time this proposal was constructed. In most cases,
+    ///  if this proposal is accepted, it will be "mined" in the next
+    ///  burn block.
+    pub burn_tip_height: u32,
+    /// Mainnet, Testnet, etc.
+    pub chain_id: u32,
+}
+
+impl StacksMessageCodec for NakamotoBlockProposal {
+    fn consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), CodecError> {
+        write_next(fd, &self.block)?;
+        write_next(fd, &self.parent_consensus_hash)?;
+        write_next(fd, &self.burn_tip)?;
+        write_next(fd, &self.burn_tip_height)?;
+        write_next(fd, &self.chain_id)
+    }
+
+    fn consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, CodecError> {
+        Ok(Self {
+            block: read_next(fd)?,
+            parent_consensus_hash: read_next(fd)?,
+            burn_tip: read_next(fd)?,
+            burn_tip_height: read_next(fd)?,
+            chain_id: read_next(fd)?,
+        })
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct NakamotoBlockProposalResponse {}
+
+#[derive(Clone, Default)]
+pub struct RPCBlockProposalRequestHandler {
+    pub block_proposal: Option<NakamotoBlockProposal>,
+}
+
+impl RPCBlockProposalRequestHandler {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Decode a bare transaction from the body
+    fn parse_posttransaction_octets(mut body: &[u8]) -> Result<NakamotoBlockProposal, Error> {
+        NakamotoBlockProposal::consensus_deserialize(&mut body).map_err(|e| match e {
+            CodecError::DeserializeError(msg) => {
+                Error::DecodeError(format!("Failed to deserialize posted transaction: {msg}"))
+            }
+            _ => e.into(),
+        })
+    }
+
+    /// Decode a JSON-encoded transaction
+    fn parse_posttransaction_json(body: &[u8]) -> Result<NakamotoBlockProposal, Error> {
+        serde_json::from_slice(body).map_err(|_| Error::DecodeError("Failed to parse body".into()))
+    }
+}
+
+/// Decode the HTTP request
+impl HttpRequest for RPCBlockProposalRequestHandler {
+    fn verb(&self) -> &'static str {
+        "POST"
+    }
+
+    fn path_regex(&self) -> Regex {
+        Regex::new(r#"^/v2/block_proposal$"#).unwrap()
+    }
+
+    /// Try to decode this request.
+    /// There's nothing to load here, so just make sure the request is well-formed.
+    fn try_parse_request(
+        &mut self,
+        preamble: &HttpRequestPreamble,
+        captures: &Captures,
+        query: Option<&str>,
+        body: &[u8],
+    ) -> Result<HttpRequestContents, Error> {
+        if preamble.get_content_length() == 0 {
+            return Err(Error::DecodeError(
+                "Invalid Http request: expected non-zero-length body for PostBlock".to_string(),
+            ));
+        }
+
+        if preamble.get_content_length() > MAX_PAYLOAD_LEN {
+            return Err(Error::DecodeError(
+                "Invalid Http request: BlockProposal body is too big".to_string(),
+            ));
+        }
+
+        match preamble.content_type {
+            None => {
+                return Err(Error::DecodeError(
+                    "Missing Content-Type for transaction".to_string(),
+                ));
+            }
+            Some(HttpContentType::Bytes) => {
+                // expect a bare transaction
+                let block_proposal = Self::parse_posttransaction_octets(body)?;
+                self.block_proposal = Some(block_proposal);
+            }
+            Some(HttpContentType::JSON) => {
+                // expect a transaction and an attachment
+                let block_proposal = Self::parse_posttransaction_json(body)?;
+                self.block_proposal = Some(block_proposal);
+            }
+            _ => {
+                return Err(Error::DecodeError(
+                    "Wrong Content-Type for transaction; expected application/json or application/octet-stream".to_string(),
+                ));
+            }
+        }
+
+        Ok(HttpRequestContents::new().query_string(query))
+    }
+}
+
+impl RPCRequestHandler for RPCBlockProposalRequestHandler {
+    /// Reset internal state
+    fn restart(&mut self) {
+        todo!()
+    }
+
+    /// Make the response
+    fn try_handle_request(
+        &mut self,
+        preamble: HttpRequestPreamble,
+        _contents: HttpRequestContents,
+        node: &mut StacksNodeState,
+    ) -> Result<(HttpResponsePreamble, HttpResponseContents), NetError> {
+        todo!()
+    }
+}
+
+/// Decode the HTTP response
+impl HttpResponse for RPCBlockProposalRequestHandler {
+    fn try_parse_response(
+        &self,
+        preamble: &HttpResponsePreamble,
+        body: &[u8],
+    ) -> Result<HttpResponsePayload, Error> {
+        todo!()
+    }
+}
+
+impl StacksHttpRequest {
+    /// Make a new post-block request
+    pub fn new_post_block_proposal(
+        host: PeerHost,
+        proposal: NakamotoBlockProposal,
+    ) -> StacksHttpRequest {
+        todo!()
+    }
+}
+
+impl StacksHttpResponse {
+    pub fn decode_stacks_block_proposal_accepted(
+        self,
+    ) -> Result<NakamotoBlockProposalResponse, NetError> {
+        todo!()
+    }
+}
diff --git a/stackslib/src/net/api/posttransaction.rs b/stackslib/src/net/api/posttransaction.rs
index 3958550e16..70682b0839 100644
--- a/stackslib/src/net/api/posttransaction.rs
+++ b/stackslib/src/net/api/posttransaction.rs
@@ -162,7 +162,7 @@ impl HttpRequest for RPCPostTransactionRequestHandler {
             }
             _ => {
                 return Err(Error::DecodeError(
-                    "Wrong Content-Type for transaction; expected application/json".to_string(),
+                    "Wrong Content-Type for transaction; expected application/json or application/octet-stream".to_string(),
                 ));
             }
         }

From 90c820e9f3cd7e536830df8e52d5d7fc21ffdfa3 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Mon, 27 Nov 2023 16:56:53 -0500
Subject: [PATCH 0286/1166] Fill in some functions for `/v2/block_proposal`
 endpoint

---
 stacks-common/src/types/net.rs              | 15 +++++
 stackslib/src/net/api/postblock_proposal.rs | 63 +++++++++++++++++++--
 2 files changed, 73 insertions(+), 5 deletions(-)

diff --git a/stacks-common/src/types/net.rs b/stacks-common/src/types/net.rs
index 25c86a82de..5288cd17c5 100644
--- a/stacks-common/src/types/net.rs
+++ b/stacks-common/src/types/net.rs
@@ -218,6 +218,21 @@ impl PeerAddress {
         }
     }
 
+    /// Is this a local loopback address?
+    pub fn is_loopback(&self) -> bool {
+        if self.is_ipv4() {
+            // 127.0.0.0/8
+            self.0[12] == 127
+        } else {
+            // ::1/128
+            *self
+                == PeerAddress([
+                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                    0x00, 0x00, 0x01,
+                ])
+        }
+    }
+
     pub fn to_bin(&self) -> String {
         to_bin(&self.0)
     }
diff --git a/stackslib/src/net/api/postblock_proposal.rs b/stackslib/src/net/api/postblock_proposal.rs
index fbd7a12e54..56b7b22581 100644
--- a/stackslib/src/net/api/postblock_proposal.rs
+++ b/stackslib/src/net/api/postblock_proposal.rs
@@ -94,8 +94,43 @@ impl StacksMessageCodec for NakamotoBlockProposal {
     }
 }
 
+/// This enum is used to supply a `reason_code` for validation
+///  rejection responses. This is serialized as an enum with string
+///  type (in jsonschema terminology).
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct NakamotoBlockProposalResponse {}
+pub enum ValidateRejectCode {
+    BadBlockHash,
+    BadTransaction,
+    InvalidBlock,
+    ChainstateError,
+    UnknownParent,
+}
+
+/// A response for block proposal validation
+///  that the stacks-node thinks should be rejected.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct BlockValidateReject {
+    pub reason: String,
+    pub reason_code: ValidateRejectCode,
+}
+
+/// A response for block proposal validation
+///  that the stacks-node thinks is acceptable.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct BlockValidateOk {
+    pub block: StacksBlock,
+    pub cost: ExecutionCost,
+    pub size: u64,
+}
+
+/// This enum is used for serializing the response to block
+/// proposal validation.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(tag = "Result")]
+pub enum NakamotoBlockProposalResponse {
+    Ok(BlockValidateOk),
+    Reject(BlockValidateReject),
+}
 
 #[derive(Clone, Default)]
 pub struct RPCBlockProposalRequestHandler {
@@ -184,7 +219,7 @@ impl HttpRequest for RPCBlockProposalRequestHandler {
 impl RPCRequestHandler for RPCBlockProposalRequestHandler {
     /// Reset internal state
     fn restart(&mut self) {
-        todo!()
+        self.block_proposal = None
     }
 
     /// Make the response
@@ -194,6 +229,16 @@ impl RPCRequestHandler for RPCBlockProposalRequestHandler {
         _contents: HttpRequestContents,
         node: &mut StacksNodeState,
     ) -> Result<(HttpResponsePreamble, HttpResponseContents), NetError> {
+        let is_loopback = match preamble.host {
+            // Should never be DNS
+            PeerHost::DNS(..) => false,
+            PeerHost::IP(addr, ..) => addr.is_loopback(),
+        };
+
+        if !is_loopback {
+            return Err(NetError::Http(Error::Http(403, "Forbidden".into())));
+        }
+
         todo!()
     }
 }
@@ -205,17 +250,25 @@ impl HttpResponse for RPCBlockProposalRequestHandler {
         preamble: &HttpResponsePreamble,
         body: &[u8],
     ) -> Result<HttpResponsePayload, Error> {
-        todo!()
+        let response: NakamotoBlockProposalResponse = parse_json(preamble, body)?;
+        HttpResponsePayload::try_from_json(response)
     }
 }
 
 impl StacksHttpRequest {
     /// Make a new post-block request
+    #[cfg(test)]
     pub fn new_post_block_proposal(
         host: PeerHost,
-        proposal: NakamotoBlockProposal,
+        proposal: &NakamotoBlockProposal,
     ) -> StacksHttpRequest {
-        todo!()
+        StacksHttpRequest::new_for_peer(
+            host,
+            "POST".into(),
+            "/v2/block_proposal".into(),
+            HttpRequestContents::new().payload_stacks(proposal),
+        )
+        .expect("FATAL: failed to construct request from infallible data")
     }
 }
 

From 4aa56b6e46f6f9f86ac2e65926ceba997a7afda7 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Wed, 29 Nov 2023 09:28:18 -0500
Subject: [PATCH 0287/1166] Partial validation of `NakamotoBlockProposal` using
 `validate_nakamoto_block_burnchain()`

---
 stackslib/src/chainstate/nakamoto/mod.rs      |   9 +-
 stackslib/src/chainstate/nakamoto/proposal.rs | 203 ++++++++++++++++++
 stackslib/src/net/api/postblock_proposal.rs   | 140 +++---------
 3 files changed, 242 insertions(+), 110 deletions(-)
 create mode 100644 stackslib/src/chainstate/nakamoto/proposal.rs

diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index 7a44f3e35a..e4e153ce2d 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -17,10 +17,6 @@
 use std::collections::HashSet;
 use std::ops::DerefMut;
 
-pub mod coordinator;
-pub mod miner;
-pub mod tenure;
-
 use clarity::vm::ast::ASTRules;
 use clarity::vm::costs::{ExecutionCost, LimitedCostTracker};
 use clarity::vm::database::BurnStateDB;
@@ -89,6 +85,11 @@ use crate::util_lib::db::{
     FromRow,
 };
 
+pub mod coordinator;
+pub mod miner;
+pub mod proposal;
+pub mod tenure;
+
 #[cfg(test)]
 pub mod tests;
 
diff --git a/stackslib/src/chainstate/nakamoto/proposal.rs b/stackslib/src/chainstate/nakamoto/proposal.rs
new file mode 100644
index 0000000000..a21b681b0c
--- /dev/null
+++ b/stackslib/src/chainstate/nakamoto/proposal.rs
@@ -0,0 +1,203 @@
+use std::collections::{HashMap, HashSet};
+use std::convert::From;
+use std::io::{Read, Write};
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Arc, Mutex};
+use std::thread::ThreadId;
+use std::{cmp, fs, mem};
+
+use clarity::vm::analysis::{CheckError, CheckErrors};
+use clarity::vm::ast::errors::ParseErrors;
+use clarity::vm::ast::ASTRules;
+use clarity::vm::clarity::TransactionConnection;
+use clarity::vm::costs::ExecutionCost;
+use clarity::vm::database::BurnStateDB;
+use clarity::vm::errors::Error as InterpreterError;
+use clarity::vm::types::TypeSignature;
+use serde::Deserialize;
+use stacks_common::codec::{
+    read_next, write_next, Error as CodecError, StacksMessageCodec, MAX_PAYLOAD_LEN,
+};
+use stacks_common::types::chainstate::{
+    BlockHeaderHash, BurnchainHeaderHash, ConsensusHash, StacksAddress, StacksBlockId, TrieHash,
+};
+use stacks_common::types::StacksPublicKeyBuffer;
+use stacks_common::util::get_epoch_time_ms;
+use stacks_common::util::hash::{Hash160, MerkleTree, Sha512Trunc256Sum};
+use stacks_common::util::secp256k1::{MessageSignature, Secp256k1PrivateKey};
+use stacks_common::util::vrf::*;
+
+use crate::burnchains::{PrivateKey, PublicKey};
+use crate::chainstate::burn::db::sortdb::{SortitionDB, SortitionDBConn, SortitionHandleTx};
+use crate::chainstate::burn::operations::*;
+use crate::chainstate::burn::*;
+use crate::chainstate::nakamoto::{
+    NakamotoBlock, NakamotoBlockHeader, NakamotoChainState, SetupBlockResult,
+};
+use crate::chainstate::stacks::address::StacksAddressExtensions;
+use crate::chainstate::stacks::db::accounts::MinerReward;
+use crate::chainstate::stacks::db::blocks::MemPoolRejection;
+use crate::chainstate::stacks::db::transactions::{
+    handle_clarity_runtime_error, ClarityRuntimeTxError,
+};
+use crate::chainstate::stacks::db::{
+    ChainstateTx, ClarityTx, MinerRewardInfo, StacksChainState, StacksHeaderInfo,
+    MINER_REWARD_MATURITY,
+};
+use crate::chainstate::stacks::events::{StacksTransactionEvent, StacksTransactionReceipt};
+use crate::chainstate::stacks::miner::{
+    BlockBuilder, BlockBuilderSettings, BlockLimitFunction, TransactionError,
+    TransactionProblematic, TransactionResult, TransactionSkipped,
+};
+use crate::chainstate::stacks::{Error, StacksBlockHeader, *};
+use crate::clarity_vm::clarity::{ClarityConnection, ClarityInstance, Error as clarity_error};
+use crate::core::mempool::*;
+use crate::core::*;
+use crate::cost_estimates::metrics::CostMetric;
+use crate::cost_estimates::CostEstimator;
+use crate::monitoring::{
+    set_last_mined_block_transaction_count, set_last_mined_execution_cost_observed,
+};
+use crate::net::relay::Relayer;
+use crate::net::Error as net_error;
+use crate::util_lib::db::Error as DBError;
+
+/// This enum is used to supply a `reason_code` for validation
+///  rejection responses. This is serialized as an enum with string
+///  type (in jsonschema terminology).
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub enum ValidateRejectCode {
+    BadBlockHash,
+    BadTransaction,
+    InvalidBlock,
+    ChainstateError,
+    UnknownParent,
+}
+
+/// A response for block proposal validation
+///  that the stacks-node thinks should be rejected.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct BlockValidateReject {
+    pub reason: String,
+    pub reason_code: ValidateRejectCode,
+}
+
+/// A response for block proposal validation
+///  that the stacks-node thinks is acceptable.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct BlockValidateOk {
+    pub block: NakamotoBlock,
+    pub cost: ExecutionCost,
+    pub size: u64,
+}
+
+/// This enum is used for serializing the response to block
+/// proposal validation.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(tag = "Result")]
+pub enum BlockValidateResponse {
+    Ok(BlockValidateOk),
+    Reject(BlockValidateReject),
+}
+
+impl From<Result<BlockValidateOk, BlockValidateReject>> for BlockValidateResponse {
+    fn from(value: Result<BlockValidateOk, BlockValidateReject>) -> Self {
+        match value {
+            Ok(o) => BlockValidateResponse::Ok(o),
+            Err(e) => BlockValidateResponse::Reject(e),
+        }
+    }
+}
+
+impl From<Error> for BlockValidateReject {
+    fn from(value: Error) -> Self {
+        BlockValidateReject {
+            reason: format!("Chainstate Error: {value}"),
+            reason_code: ValidateRejectCode::ChainstateError,
+        }
+    }
+}
+
+impl From<DBError> for BlockValidateReject {
+    fn from(value: DBError) -> Self {
+        Error::from(value).into()
+    }
+}
+
+/// Represents a block proposed to the `v2/block_proposal` endpoint for validation
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct NakamotoBlockProposal {
+    /// Proposed block
+    pub block: NakamotoBlock,
+    /// Identify the stacks/burnchain fork we are on
+    pub parent_consensus_hash: ConsensusHash,
+    /// Most recent burnchain block hash
+    pub burn_tip: BurnchainHeaderHash,
+    /// This refers to the burn block that was the current tip
+    ///  at the time this proposal was constructed. In most cases,
+    ///  if this proposal is accepted, it will be "mined" in the next
+    ///  burn block.
+    pub burn_tip_height: u32,
+    /// Identifies which chain block is for (Mainnet, Testnet, etc.)
+    pub chain_id: u32,
+}
+
+impl StacksMessageCodec for NakamotoBlockProposal {
+    fn consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), CodecError> {
+        write_next(fd, &self.block)?;
+        write_next(fd, &self.parent_consensus_hash)?;
+        write_next(fd, &self.burn_tip)?;
+        write_next(fd, &self.burn_tip_height)?;
+        write_next(fd, &self.chain_id)
+    }
+
+    fn consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, CodecError> {
+        Ok(Self {
+            block: read_next(fd)?,
+            parent_consensus_hash: read_next(fd)?,
+            burn_tip: read_next(fd)?,
+            burn_tip_height: read_next(fd)?,
+            chain_id: read_next(fd)?,
+        })
+    }
+}
+
+impl NakamotoBlockProposal {
+    /// Test this block proposal against the current chain state and
+    /// either accept or reject the proposal.
+    pub fn validate(
+        &self,
+        sortdb: &SortitionDB,
+        chainstate: &mut StacksChainState, // not directly used; used as a handle to open other chainstates
+    ) -> Result<BlockValidateOk, BlockValidateReject> {
+        let mainnet = self.chain_id == CHAIN_ID_MAINNET;
+        if self.chain_id != chainstate.chain_id || mainnet != chainstate.mainnet {
+            return Err(BlockValidateReject {
+                reason_code: ValidateRejectCode::InvalidBlock,
+                reason: "Wrong netowrk/chain_id".into(),
+            });
+        }
+
+        let sort_tip = SortitionDB::get_canonical_sortition_tip(sortdb.conn())?;
+        let mut db_handle = sortdb.index_handle(&sort_tip);
+        let (chainstate_tx, _clarity_instance) = chainstate.chainstate_tx_begin()?;
+        let expected_burn =
+            NakamotoChainState::get_expected_burns(&mut db_handle, &chainstate_tx, &self.block)?;
+
+        NakamotoChainState::validate_nakamoto_block_burnchain(
+            &db_handle,
+            expected_burn,
+            &self.block,
+            mainnet,
+            self.chain_id,
+        )?;
+
+        // TODO: Validate block txs against chainstate
+
+        Ok(BlockValidateOk {
+            block: self.block.clone(),
+            cost: ExecutionCost::zero(),
+            size: 0, // TODO
+        })
+    }
+}
diff --git a/stackslib/src/net/api/postblock_proposal.rs b/stackslib/src/net/api/postblock_proposal.rs
index 56b7b22581..2bb26906f8 100644
--- a/stackslib/src/net/api/postblock_proposal.rs
+++ b/stackslib/src/net/api/postblock_proposal.rs
@@ -32,6 +32,7 @@ use stacks_common::util::retry::BoundReader;
 use crate::burnchains::affirmation::AffirmationMap;
 use crate::burnchains::Txid;
 use crate::chainstate::burn::db::sortdb::SortitionDB;
+use crate::chainstate::nakamoto::proposal::{BlockValidateResponse, NakamotoBlockProposal};
 use crate::chainstate::nakamoto::NakamotoBlock;
 use crate::chainstate::stacks::db::blocks::MINIMUM_TX_FEE_RATE_PER_BYTE;
 use crate::chainstate::stacks::db::StacksChainState;
@@ -55,83 +56,6 @@ use crate::net::{
     Attachment, BlocksData, BlocksDatum, Error as NetError, StacksMessageType, StacksNodeState,
 };
 
-/// Represents a block proposed to the `v2/block_proposal` endpoint for validation
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct NakamotoBlockProposal {
-    /// Proposed block
-    pub block: NakamotoBlock,
-    /// Identify the stacks/burnchain fork we are on
-    pub parent_consensus_hash: ConsensusHash,
-    /// These are all the microblocks that the proposed block
-    /// will confirm.
-    pub burn_tip: BurnchainHeaderHash,
-    /// This refers to the burn block that was the current tip
-    ///  at the time this proposal was constructed. In most cases,
-    ///  if this proposal is accepted, it will be "mined" in the next
-    ///  burn block.
-    pub burn_tip_height: u32,
-    /// Mainnet, Testnet, etc.
-    pub chain_id: u32,
-}
-
-impl StacksMessageCodec for NakamotoBlockProposal {
-    fn consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), CodecError> {
-        write_next(fd, &self.block)?;
-        write_next(fd, &self.parent_consensus_hash)?;
-        write_next(fd, &self.burn_tip)?;
-        write_next(fd, &self.burn_tip_height)?;
-        write_next(fd, &self.chain_id)
-    }
-
-    fn consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, CodecError> {
-        Ok(Self {
-            block: read_next(fd)?,
-            parent_consensus_hash: read_next(fd)?,
-            burn_tip: read_next(fd)?,
-            burn_tip_height: read_next(fd)?,
-            chain_id: read_next(fd)?,
-        })
-    }
-}
-
-/// This enum is used to supply a `reason_code` for validation
-///  rejection responses. This is serialized as an enum with string
-///  type (in jsonschema terminology).
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub enum ValidateRejectCode {
-    BadBlockHash,
-    BadTransaction,
-    InvalidBlock,
-    ChainstateError,
-    UnknownParent,
-}
-
-/// A response for block proposal validation
-///  that the stacks-node thinks should be rejected.
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct BlockValidateReject {
-    pub reason: String,
-    pub reason_code: ValidateRejectCode,
-}
-
-/// A response for block proposal validation
-///  that the stacks-node thinks is acceptable.
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct BlockValidateOk {
-    pub block: StacksBlock,
-    pub cost: ExecutionCost,
-    pub size: u64,
-}
-
-/// This enum is used for serializing the response to block
-/// proposal validation.
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(tag = "Result")]
-pub enum NakamotoBlockProposalResponse {
-    Ok(BlockValidateOk),
-    Reject(BlockValidateReject),
-}
-
 #[derive(Clone, Default)]
 pub struct RPCBlockProposalRequestHandler {
     pub block_proposal: Option<NakamotoBlockProposal>,
@@ -177,6 +101,17 @@ impl HttpRequest for RPCBlockProposalRequestHandler {
         query: Option<&str>,
         body: &[u8],
     ) -> Result<HttpRequestContents, Error> {
+        // Only accept requests from localhost
+        let is_loopback = match preamble.host {
+            // Should never be DNS
+            PeerHost::DNS(..) => false,
+            PeerHost::IP(addr, ..) => addr.is_loopback(),
+        };
+
+        if !is_loopback {
+            return Err(Error::Http(403, "Forbidden".into()));
+        }
+
         if preamble.get_content_length() == 0 {
             return Err(Error::DecodeError(
                 "Invalid Http request: expected non-zero-length body for PostBlock".to_string(),
@@ -189,29 +124,22 @@ impl HttpRequest for RPCBlockProposalRequestHandler {
             ));
         }
 
-        match preamble.content_type {
+        let block_proposal = match preamble.content_type {
+            Some(HttpContentType::Bytes) => Self::parse_posttransaction_octets(body)?,
+            Some(HttpContentType::JSON) => Self::parse_posttransaction_json(body)?,
             None => {
                 return Err(Error::DecodeError(
                     "Missing Content-Type for transaction".to_string(),
-                ));
-            }
-            Some(HttpContentType::Bytes) => {
-                // expect a bare transaction
-                let block_proposal = Self::parse_posttransaction_octets(body)?;
-                self.block_proposal = Some(block_proposal);
-            }
-            Some(HttpContentType::JSON) => {
-                // expect a transaction and an attachment
-                let block_proposal = Self::parse_posttransaction_json(body)?;
-                self.block_proposal = Some(block_proposal);
+                ))
             }
             _ => {
                 return Err(Error::DecodeError(
                     "Wrong Content-Type for transaction; expected application/json or application/octet-stream".to_string(),
-                ));
+                ))
             }
-        }
+        };
 
+        self.block_proposal = Some(block_proposal);
         Ok(HttpRequestContents::new().query_string(query))
     }
 }
@@ -229,17 +157,19 @@ impl RPCRequestHandler for RPCBlockProposalRequestHandler {
         _contents: HttpRequestContents,
         node: &mut StacksNodeState,
     ) -> Result<(HttpResponsePreamble, HttpResponseContents), NetError> {
-        let is_loopback = match preamble.host {
-            // Should never be DNS
-            PeerHost::DNS(..) => false,
-            PeerHost::IP(addr, ..) => addr.is_loopback(),
-        };
-
-        if !is_loopback {
-            return Err(NetError::Http(Error::Http(403, "Forbidden".into())));
-        }
-
-        todo!()
+        let block_proposal = self
+            .block_proposal
+            .take()
+            .ok_or(NetError::SendError("`block_proposal` not set".into()))?;
+
+        let resp = node.with_node_state(|_network, sortdb, chainstate, _mempool, _rpc_args| {
+            block_proposal.validate(sortdb, chainstate)
+        });
+
+        let mut preamble = HttpResponsePreamble::ok_json(&preamble);
+        preamble.set_canonical_stacks_tip_height(Some(node.canonical_stacks_tip_height()));
+        let body = HttpResponseContents::try_from_json(&resp)?;
+        Ok((preamble, body))
     }
 }
 
@@ -250,7 +180,7 @@ impl HttpResponse for RPCBlockProposalRequestHandler {
         preamble: &HttpResponsePreamble,
         body: &[u8],
     ) -> Result<HttpResponsePayload, Error> {
-        let response: NakamotoBlockProposalResponse = parse_json(preamble, body)?;
+        let response: BlockValidateResponse = parse_json(preamble, body)?;
         HttpResponsePayload::try_from_json(response)
     }
 }
@@ -273,9 +203,7 @@ impl StacksHttpRequest {
 }
 
 impl StacksHttpResponse {
-    pub fn decode_stacks_block_proposal_accepted(
-        self,
-    ) -> Result<NakamotoBlockProposalResponse, NetError> {
+    pub fn decode_stacks_block_proposal_accepted(self) -> Result<BlockValidateResponse, NetError> {
         todo!()
     }
 }

From 8a10cf6a8517a36fd2c5604b5d4d501390268153 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Wed, 13 Dec 2023 15:50:23 -0500
Subject: [PATCH 0288/1166] Validate `NakamotoBlockProposal` against chainstate

---
 stackslib/src/chainstate/nakamoto/miner.rs    |   4 +
 stackslib/src/chainstate/nakamoto/mod.rs      |   4 +-
 stackslib/src/chainstate/nakamoto/proposal.rs | 153 ++++++++++++++++--
 stackslib/src/chainstate/stacks/miner.rs      |  12 +-
 stackslib/src/net/api/postblock_proposal.rs   |   2 +-
 5 files changed, 153 insertions(+), 22 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/miner.rs b/stackslib/src/chainstate/nakamoto/miner.rs
index adadbbca05..62b0da4133 100644
--- a/stackslib/src/chainstate/nakamoto/miner.rs
+++ b/stackslib/src/chainstate/nakamoto/miner.rs
@@ -498,6 +498,10 @@ impl NakamotoBlockBuilder {
 
         Ok((block, consumed, size))
     }
+
+    pub fn get_bytes_so_far(&self) -> u64 {
+        self.bytes_so_far
+    }
 }
 
 impl BlockBuilder for NakamotoBlockBuilder {
diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index e4e153ce2d..c1dacf57ab 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -1568,7 +1568,7 @@ impl NakamotoChainState {
                 "Invalid Nakamoto block, could not validate on burnchain";
                 "consensus_hash" => %consensus_hash,
                 "block_hash" => %block_hash,
-                "error" => format!("{:?}", &e)
+                "error" => ?e
             );
 
             return Err(e);
@@ -1700,7 +1700,7 @@ impl NakamotoChainState {
         ) {
             warn!("Unacceptable Nakamoto block; will not store";
                   "block_id" => %block.block_id(),
-                  "error" => format!("{:?}", &e)
+                  "error" => ?e
             );
             return Ok(false);
         };
diff --git a/stackslib/src/chainstate/nakamoto/proposal.rs b/stackslib/src/chainstate/nakamoto/proposal.rs
index a21b681b0c..c1f3e19388 100644
--- a/stackslib/src/chainstate/nakamoto/proposal.rs
+++ b/stackslib/src/chainstate/nakamoto/proposal.rs
@@ -31,6 +31,7 @@ use crate::burnchains::{PrivateKey, PublicKey};
 use crate::chainstate::burn::db::sortdb::{SortitionDB, SortitionDBConn, SortitionHandleTx};
 use crate::chainstate::burn::operations::*;
 use crate::chainstate::burn::*;
+use crate::chainstate::nakamoto::miner::NakamotoBlockBuilder;
 use crate::chainstate::nakamoto::{
     NakamotoBlock, NakamotoBlockHeader, NakamotoChainState, SetupBlockResult,
 };
@@ -129,8 +130,10 @@ impl From<DBError> for BlockValidateReject {
 pub struct NakamotoBlockProposal {
     /// Proposed block
     pub block: NakamotoBlock,
-    /// Identify the stacks/burnchain fork we are on
-    pub parent_consensus_hash: ConsensusHash,
+    // tenure ID -- this is the index block hash of the start block of the last tenure (i.e.
+    // the data we committed to in the block-commit).  If this is an epoch 2.x parent, then
+    // this is just the index block hash of the parent Stacks block.
+    pub tenure_start_block: StacksBlockId,
     /// Most recent burnchain block hash
     pub burn_tip: BurnchainHeaderHash,
     /// This refers to the burn block that was the current tip
@@ -140,36 +143,51 @@ pub struct NakamotoBlockProposal {
     pub burn_tip_height: u32,
     /// Identifies which chain block is for (Mainnet, Testnet, etc.)
     pub chain_id: u32,
+    /// total BTC burn so far
+    pub total_burn: u64,
 }
 
 impl StacksMessageCodec for NakamotoBlockProposal {
     fn consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), CodecError> {
         write_next(fd, &self.block)?;
-        write_next(fd, &self.parent_consensus_hash)?;
+        write_next(fd, &self.tenure_start_block)?;
         write_next(fd, &self.burn_tip)?;
         write_next(fd, &self.burn_tip_height)?;
-        write_next(fd, &self.chain_id)
+        write_next(fd, &self.chain_id)?;
+        write_next(fd, &self.total_burn)
     }
 
     fn consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, CodecError> {
         Ok(Self {
             block: read_next(fd)?,
-            parent_consensus_hash: read_next(fd)?,
+            tenure_start_block: read_next(fd)?,
             burn_tip: read_next(fd)?,
             burn_tip_height: read_next(fd)?,
             chain_id: read_next(fd)?,
+            total_burn: read_next(fd)?,
         })
     }
 }
 
 impl NakamotoBlockProposal {
     /// Test this block proposal against the current chain state and
-    /// either accept or reject the proposal.
+    /// either accept or reject the proposal
+    ///
+    /// This is done in 2 steps:
+    /// - Static validation of the block, which checks the following:
+    ///   - Block is well-formed
+    ///   - Transactions are well-formed
+    ///   - Miner signature is valid
+    /// - Validation of transactions by executing them agains current chainstate.
+    ///   This is resource intensive, and therefore done only if previous checks pass
     pub fn validate(
         &self,
         sortdb: &SortitionDB,
         chainstate: &mut StacksChainState, // not directly used; used as a handle to open other chainstates
     ) -> Result<BlockValidateOk, BlockValidateReject> {
+        // Time this function
+        let ts_start = get_epoch_time_ms();
+
         let mainnet = self.chain_id == CHAIN_ID_MAINNET;
         if self.chain_id != chainstate.chain_id || mainnet != chainstate.mainnet {
             return Err(BlockValidateReject {
@@ -178,12 +196,16 @@ impl NakamotoBlockProposal {
             });
         }
 
+        let burn_dbconn = sortdb.index_conn();
         let sort_tip = SortitionDB::get_canonical_sortition_tip(sortdb.conn())?;
         let mut db_handle = sortdb.index_handle(&sort_tip);
-        let (chainstate_tx, _clarity_instance) = chainstate.chainstate_tx_begin()?;
+        // Is this safe?
+        let mut _chainstate = chainstate.reopen()?.0;
+        let (chainstate_tx, _clarity_instance) = _chainstate.chainstate_tx_begin()?;
         let expected_burn =
             NakamotoChainState::get_expected_burns(&mut db_handle, &chainstate_tx, &self.block)?;
 
+        // Static validation checks
         NakamotoChainState::validate_nakamoto_block_burnchain(
             &db_handle,
             expected_burn,
@@ -192,12 +214,117 @@ impl NakamotoBlockProposal {
             self.chain_id,
         )?;
 
-        // TODO: Validate block txs against chainstate
+        // Validate block txs against chainstate
+        let parent_stacks_header = NakamotoChainState::get_block_header(
+            &chainstate_tx,
+            &self.block.header.parent_block_id,
+        )?
+        .ok_or_else(|| BlockValidateReject {
+            reason_code: ValidateRejectCode::InvalidBlock,
+            reason: "Invalid parent block".into(),
+        })?;
+        let tenure_change = self
+            .block
+            .txs
+            .iter()
+            .find(|tx| matches!(tx.payload, TransactionPayload::TenureChange(..)));
+        let coinbase = self
+            .block
+            .txs
+            .iter()
+            .find(|tx| matches!(tx.payload, TransactionPayload::Coinbase(..)));
+        let tenure_cause = tenure_change.and_then(|tx| match &tx.payload {
+            TransactionPayload::TenureChange(tc) => Some(tc.cause),
+            _ => None,
+        });
 
-        Ok(BlockValidateOk {
-            block: self.block.clone(),
-            cost: ExecutionCost::zero(),
-            size: 0, // TODO
-        })
+        let mut builder = NakamotoBlockBuilder::new_from_parent(
+            &self.tenure_start_block,
+            &parent_stacks_header,
+            &self.block.header.consensus_hash,
+            self.total_burn,
+            tenure_change,
+            coinbase,
+        )?;
+
+        let mut miner_tenure_info =
+            builder.load_tenure_info(chainstate, &burn_dbconn, tenure_cause)?;
+        let mut tenure_tx = builder.tenure_begin(&burn_dbconn, &mut miner_tenure_info)?;
+
+        for (i, tx) in self.block.txs.iter().enumerate() {
+            let tx_len = tx.tx_len();
+            let tx_result = builder.try_mine_tx_with_len(
+                &mut tenure_tx,
+                &tx,
+                tx_len,
+                &BlockLimitFunction::NO_LIMIT_HIT,
+                ASTRules::PrecheckSize,
+            );
+            let err = match tx_result {
+                TransactionResult::Success(_) => Ok(()),
+                TransactionResult::Skipped(s) => Err(format!("tx {i} skipped: {}", s.error)),
+                TransactionResult::ProcessingError(e) => {
+                    Err(format!("Error processing tx {i}: {}", e.error))
+                }
+                TransactionResult::Problematic(p) => {
+                    Err(format!("Problematic tx {i}: {}", p.error))
+                }
+            };
+            if let Err(reason) = err {
+                warn!(
+                    "Rejected block proposal";
+                    "reason" => %reason,
+                    "tx" => ?tx,
+                );
+                return Err(BlockValidateReject {
+                    reason,
+                    reason_code: ValidateRejectCode::BadTransaction,
+                });
+            }
+        }
+
+        let mut block = builder.mine_nakamoto_block(&mut tenure_tx);
+        let size = builder.get_bytes_so_far();
+        let cost = builder.tenure_finish(tenure_tx);
+
+        // Clone signatures from block proposal
+        // These have already been validated by `validate_nakamoto_block_burnchain()``
+        block.header.miner_signature = self.block.header.miner_signature.clone();
+        block.header.signer_signature = self.block.header.signer_signature.clone();
+
+        // Assuming `tx_nerkle_root` has been checked we don't need to hash the whole block
+        let expected_block_header_hash = self.block.header.block_hash();
+        let computed_block_header_hash = block.header.block_hash();
+
+        if computed_block_header_hash != expected_block_header_hash {
+            warn!(
+                "Rejected block proposal";
+                "reason" => "Block hash is not as expected",
+                "expected_block_header_hash" => %expected_block_header_hash,
+                "computed_block_header_hash" => %computed_block_header_hash,
+            );
+            return Err(BlockValidateReject {
+                reason: "Block hash is not as expected".into(),
+                reason_code: ValidateRejectCode::BadBlockHash,
+            });
+        }
+
+        let ts_end = get_epoch_time_ms();
+
+        info!(
+            "Participant: validated anchored block";
+            "block_header_hash" => %computed_block_header_hash,
+            "height" => block.header.chain_length,
+            "tx_count" => block.txs.len(),
+            "parent_stacks_block_id" => %block.header.parent_block_id,
+            "block_size" => size,
+            "execution_cost" => %cost,
+            "validation_time_ms" => ts_end.saturating_sub(ts_start),
+            "tx_fees_microstacks" => block.txs.iter().fold(0, |agg: u64, tx| {
+                agg.saturating_add(tx.get_tx_fee())
+            })
+        );
+
+        Ok(BlockValidateOk { block, cost, size })
     }
 }
diff --git a/stackslib/src/chainstate/stacks/miner.rs b/stackslib/src/chainstate/stacks/miner.rs
index 3eb1ea36cc..52c484ae1d 100644
--- a/stackslib/src/chainstate/stacks/miner.rs
+++ b/stackslib/src/chainstate/stacks/miner.rs
@@ -409,8 +409,8 @@ impl TransactionResult {
         Self::log_transaction_success(transaction);
         Self::Success(TransactionSuccess {
             tx: transaction.clone(),
-            fee: fee,
-            receipt: receipt,
+            fee,
+            receipt,
         })
     }
 
@@ -420,7 +420,7 @@ impl TransactionResult {
         Self::log_transaction_error(transaction, &error);
         TransactionResult::ProcessingError(TransactionError {
             tx: transaction.clone(),
-            error: error,
+            error,
         })
     }
 
@@ -433,7 +433,7 @@ impl TransactionResult {
         Self::log_transaction_skipped(transaction, &error);
         TransactionResult::Skipped(TransactionSkipped {
             tx: transaction.clone(),
-            error: error,
+            error,
         })
     }
 
@@ -446,7 +446,7 @@ impl TransactionResult {
         Self::log_transaction_skipped(transaction, &error);
         TransactionResult::Skipped(TransactionSkipped {
             tx: transaction.clone(),
-            error: error,
+            error,
         })
     }
 
@@ -456,7 +456,7 @@ impl TransactionResult {
         Self::log_transaction_problematic(transaction, &error);
         TransactionResult::Problematic(TransactionProblematic {
             tx: transaction.clone(),
-            error: error,
+            error,
         })
     }
 
diff --git a/stackslib/src/net/api/postblock_proposal.rs b/stackslib/src/net/api/postblock_proposal.rs
index 2bb26906f8..057cc9f8d9 100644
--- a/stackslib/src/net/api/postblock_proposal.rs
+++ b/stackslib/src/net/api/postblock_proposal.rs
@@ -97,7 +97,7 @@ impl HttpRequest for RPCBlockProposalRequestHandler {
     fn try_parse_request(
         &mut self,
         preamble: &HttpRequestPreamble,
-        captures: &Captures,
+        _captures: &Captures,
         query: Option<&str>,
         body: &[u8],
     ) -> Result<HttpRequestContents, Error> {

From ef6e133cbbb20245c46d8629a5e7d9aada1a4b71 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Wed, 13 Dec 2023 16:52:27 -0500
Subject: [PATCH 0289/1166] docs: Update CHANGELOG and `rpc-endpoints.md`

---
 CHANGELOG.md          |  2 ++
 docs/rpc-endpoints.md | 60 +++++++++++++++++++++++++++++++++----------
 2 files changed, 48 insertions(+), 14 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5ceb41364a..62cdd25a6b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -53,6 +53,8 @@ the log message (PR #3784).
 - Added 3 new public and regionally diverse bootstrap nodes: est.stacksnodes.org, cet.stacksnodes.org, sgt.stacksnodes.org
 - satoshis_per_byte can be changed in the config file and miners will always use
   the most up to date value
+- New RPC endpoint at /v2/block_proposal for miner to validate proposed block.
+  Only accessible on local loopback interface
 
 ### Changed
 
diff --git a/docs/rpc-endpoints.md b/docs/rpc-endpoints.md
index 5bc06babf5..139701e308 100644
--- a/docs/rpc-endpoints.md
+++ b/docs/rpc-endpoints.md
@@ -6,7 +6,7 @@ This endpoint is for posting _raw_ transaction data to the node's mempool.
 
 Rejections result in a 400 error, with JSON data in the form:
 
-```
+```json
 {
   "error": "transaction rejected",
   "reason": "BadNonce",
@@ -101,7 +101,7 @@ Returns a
 vector with length up to [Count] that contains a list of the following SIP-003-encoded
 structures:
 
-```
+```rust
 struct ExtendedStacksHeader {
     consensus_hash: ConsensusHash,
     header: StacksBlockHeader,
@@ -115,7 +115,7 @@ Where `StacksBlockId` is a 32-byte byte buffer.
 
 Where `StacksBlockHeader` is the following SIP-003-encoded structure:
 
-```
+```rust
 struct StacksBlockHeader {
     version: u8,
     total_work: StacksWorkScore,
@@ -136,14 +136,14 @@ Where `Hash160` is a 20-byte byte buffer.
 
 Where `StacksWorkScore` and `VRFProof` are the following SIP-003-encoded structures:
 
-```
+```rust
 struct StacksWorkScore {
     burn: u64,
     work: u64,
 }
 ```
 
-```
+```rust
 struct VRFProof {
     Gamma: [u8; 32]
     c: [u8; 16]
@@ -179,7 +179,7 @@ The principal string is either a Stacks address or a Contract identifier (e.g.,
 
 Returns JSON data in the form:
 
-```
+```json
 {
  "balance": "0x100..",
  "nonce": 1,
@@ -205,7 +205,7 @@ Attempt to vetch a data var from a contract. The contract is identified with [St
  
 Returns JSON data in the form:
 
-```
+```json
 {
  "data": "0x01ce...",
  "proof": "0x01ab...",
@@ -222,7 +222,8 @@ Attempt to fetch a constant from a contract. The contract is identified with [St
  [Contract Name] in the URL path. The constant is identified with [Constant Name].
 
 Returns JSON data in the form:
-```
+
+```json
 {
   "data": "0x01ce...",
 }
@@ -240,7 +241,7 @@ serialization of the key (which should be a Clarity value). Note, this is a _JSO
 
 Returns JSON data in the form:
 
-```
+```json
 {
  "data": "0x01ce...",
  "proof": "0x01ab...",
@@ -264,7 +265,7 @@ Fetch the contract interface for a given contract, identified by [Stacks Address
 
 This returns a JSON object of the form:
 
-```
+```json
 {
   "functions": [
     {
@@ -414,7 +415,7 @@ This returns a JSON object of the form:
 Fetch the source for a smart contract, along with the block height it was
 published in, and the MARF proof for the data.
 
-```
+```json
 {
  "source": "(define-private ...",
  "publish_height": 1,
@@ -433,7 +434,7 @@ Call a read-only public function on a given smart contract.
 The smart contract and function are specified using the URL path. The arguments and
 the simulated `tx-sender` are supplied via the POST body in the following JSON format:
 
-```
+```json
 {
   "sender": "SP31DA6FTSJX2WGTZ69SFY11BH51NZMB0ZW97B5P0.get-info",
   "arguments": [ "0x0011...", "0x00231..." ]
@@ -445,7 +446,7 @@ is an array of hex serialized Clarity values.
 
 This endpoint returns a JSON object of the following form:
 
-```
+```json
 {
   "okay": true,
   "result": "0x0011..."
@@ -458,7 +459,7 @@ hex serialization of the Clarity return value.
 If an error occurs in processing the function call, this endpoint returns a 200 response with a JSON
 object of the following form:
 
-```
+```json
 {
   "okay": false,
   "cause": "Unchecked(PublicFunctionNotReadOnly(..."
@@ -470,3 +471,34 @@ object of the following form:
 Determine whether a given trait is implemented within the specified contract (either explicitly or implicitly).
 
 See OpenAPI [spec](./rpc/openapi.yaml) for details.
+
+### POST /v2/block_proposal
+
+Used by miner to validate a proposed Stacks block.
+Can accept either JSON or binary encoding
+
+**This endpoint will only accept requests over the local loopback network interface.**
+
+This endpoint takes as input the following struct from `chainstate/stacks/miner.rs`:
+
+```rust
+pub struct NakamotoBlockProposal {
+    /// Proposed block
+    pub block: NakamotoBlock,
+    // tenure ID -- this is the index block hash of the start block of the last tenure (i.e.
+    // the data we committed to in the block-commit).  If this is an epoch 2.x parent, then
+    // this is just the index block hash of the parent Stacks block.
+    pub tenure_start_block: StacksBlockId,
+    /// Most recent burnchain block hash
+    pub burn_tip: BurnchainHeaderHash,
+    /// This refers to the burn block that was the current tip
+    ///  at the time this proposal was constructed. In most cases,
+    ///  if this proposal is accepted, it will be "mined" in the next
+    ///  burn block.
+    pub burn_tip_height: u32,
+    /// Identifies which chain block is for (Mainnet, Testnet, etc.)
+    pub chain_id: u32,
+    /// total BTC burn so far
+    pub total_burn: u64,
+}
+```
\ No newline at end of file

From 7cfd9c4a90b7ba5a3452fff75452215553a025b5 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Wed, 13 Dec 2023 17:19:42 -0500
Subject: [PATCH 0290/1166] Remove unused fields from `NakamotoBlockProposal`;
 Update OpenAPI doc

---
 docs/rpc-endpoints.md                         |  7 ---
 docs/rpc/openapi.yaml                         | 44 +++++++++++++++++++
 stackslib/src/chainstate/nakamoto/proposal.rs | 11 -----
 3 files changed, 44 insertions(+), 18 deletions(-)

diff --git a/docs/rpc-endpoints.md b/docs/rpc-endpoints.md
index 139701e308..82abf05627 100644
--- a/docs/rpc-endpoints.md
+++ b/docs/rpc-endpoints.md
@@ -489,13 +489,6 @@ pub struct NakamotoBlockProposal {
     // the data we committed to in the block-commit).  If this is an epoch 2.x parent, then
     // this is just the index block hash of the parent Stacks block.
     pub tenure_start_block: StacksBlockId,
-    /// Most recent burnchain block hash
-    pub burn_tip: BurnchainHeaderHash,
-    /// This refers to the burn block that was the current tip
-    ///  at the time this proposal was constructed. In most cases,
-    ///  if this proposal is accepted, it will be "mined" in the next
-    ///  burn block.
-    pub burn_tip_height: u32,
     /// Identifies which chain block is for (Mainnet, Testnet, etc.)
     pub chain_id: u32,
     /// total BTC burn so far
diff --git a/docs/rpc/openapi.yaml b/docs/rpc/openapi.yaml
index e80853514e..cfaa1d7eb4 100644
--- a/docs/rpc/openapi.yaml
+++ b/docs/rpc/openapi.yaml
@@ -551,3 +551,47 @@ paths:
             type: string
           description: The Stacks chain tip to query from. If tip == latest, the query will be run from the latest
             known tip (includes unconfirmed state).
+
+  /v2/block_proposal:
+    post:
+      summary: Validate a proposed Stacks block
+      tags:
+        - Mining
+      #operationId: ???
+      description: |
+        Used by miner to validate a proposed Stacks block.
+        Can accept either JSON or binary encoding.
+        
+        **This endpoint will only accept requests over the local loopback network interface.**
+      responses:
+        202:
+          description: Block proposal is valid
+        400:
+          description: Bad request
+        403:
+          description: Request not over loopback interface
+        429:
+          description: Too many requests
+      parameters:
+        - name: block
+          in: query
+          required: true
+          description: Proposed Block. Must match Rust struct `NakamotoBlock`
+        - name: tenure_start_block
+          in: query
+          required: true
+          description: `StacksBlockId` for block at the start of current mining tenure
+          schema:
+            type: string
+        - name: chain_id
+          in: query
+          required: true
+          description: Identifies which chain block is for (Mainnet, Testnet, etc.)
+          schema:
+            type: integer
+        - name: total_burn
+          in: query
+          required: true
+          description: Total BTC burn so far
+          schema:
+            type: integer
\ No newline at end of file
diff --git a/stackslib/src/chainstate/nakamoto/proposal.rs b/stackslib/src/chainstate/nakamoto/proposal.rs
index c1f3e19388..98c1d89d14 100644
--- a/stackslib/src/chainstate/nakamoto/proposal.rs
+++ b/stackslib/src/chainstate/nakamoto/proposal.rs
@@ -134,13 +134,6 @@ pub struct NakamotoBlockProposal {
     // the data we committed to in the block-commit).  If this is an epoch 2.x parent, then
     // this is just the index block hash of the parent Stacks block.
     pub tenure_start_block: StacksBlockId,
-    /// Most recent burnchain block hash
-    pub burn_tip: BurnchainHeaderHash,
-    /// This refers to the burn block that was the current tip
-    ///  at the time this proposal was constructed. In most cases,
-    ///  if this proposal is accepted, it will be "mined" in the next
-    ///  burn block.
-    pub burn_tip_height: u32,
     /// Identifies which chain block is for (Mainnet, Testnet, etc.)
     pub chain_id: u32,
     /// total BTC burn so far
@@ -151,8 +144,6 @@ impl StacksMessageCodec for NakamotoBlockProposal {
     fn consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), CodecError> {
         write_next(fd, &self.block)?;
         write_next(fd, &self.tenure_start_block)?;
-        write_next(fd, &self.burn_tip)?;
-        write_next(fd, &self.burn_tip_height)?;
         write_next(fd, &self.chain_id)?;
         write_next(fd, &self.total_burn)
     }
@@ -161,8 +152,6 @@ impl StacksMessageCodec for NakamotoBlockProposal {
         Ok(Self {
             block: read_next(fd)?,
             tenure_start_block: read_next(fd)?,
-            burn_tip: read_next(fd)?,
-            burn_tip_height: read_next(fd)?,
             chain_id: read_next(fd)?,
             total_burn: read_next(fd)?,
         })

From 86eda2cdd2b28a5d5a8354158f3d62ec3ecbc2de Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Thu, 14 Dec 2023 15:59:36 -0500
Subject: [PATCH 0291/1166] Add two simple test cases for `/v2/block_proposal`
 (not passing)

---
 docs/rpc/openapi.yaml                         |   8 +-
 stackslib/src/chainstate/nakamoto/miner.rs    | 272 ++++++++++++++-
 stackslib/src/chainstate/nakamoto/mod.rs      |  15 +-
 stackslib/src/chainstate/nakamoto/proposal.rs | 319 ------------------
 .../src/chainstate/stacks/boot/pox_4_tests.rs |   3 +-
 .../src/chainstate/stacks/transaction.rs      |   4 +-
 stackslib/src/net/api/postblock_proposal.rs   |  25 +-
 stackslib/src/net/http/response.rs            |  19 +-
 .../src/tests/nakamoto_integrations.rs        | 271 ++++++++++++++-
 .../src/tests/neon_integrations.rs            |  34 +-
 10 files changed, 586 insertions(+), 384 deletions(-)
 delete mode 100644 stackslib/src/chainstate/nakamoto/proposal.rs

diff --git a/docs/rpc/openapi.yaml b/docs/rpc/openapi.yaml
index cfaa1d7eb4..51fe3444e1 100644
--- a/docs/rpc/openapi.yaml
+++ b/docs/rpc/openapi.yaml
@@ -576,22 +576,22 @@ paths:
         - name: block
           in: query
           required: true
-          description: Proposed Block. Must match Rust struct `NakamotoBlock`
+          description: 'Proposed Block. Must match Rust struct `NakamotoBlock`'
         - name: tenure_start_block
           in: query
           required: true
-          description: `StacksBlockId` for block at the start of current mining tenure
+          description: '`StacksBlockId` for block at the start of current mining tenure'
           schema:
             type: string
         - name: chain_id
           in: query
           required: true
-          description: Identifies which chain block is for (Mainnet, Testnet, etc.)
+          description: 'Identifies which chain block is for (Mainnet, Testnet, etc.)'
           schema:
             type: integer
         - name: total_burn
           in: query
           required: true
-          description: Total BTC burn so far
+          description: 'Total BTC burn so far'
           schema:
             type: integer
\ No newline at end of file
diff --git a/stackslib/src/chainstate/nakamoto/miner.rs b/stackslib/src/chainstate/nakamoto/miner.rs
index 62b0da4133..ee30337a13 100644
--- a/stackslib/src/chainstate/nakamoto/miner.rs
+++ b/stackslib/src/chainstate/nakamoto/miner.rs
@@ -15,7 +15,7 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::collections::{HashMap, HashSet};
-use std::convert::From;
+use std::io::{Read, Write};
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Mutex};
 use std::thread::ThreadId;
@@ -30,7 +30,9 @@ use clarity::vm::database::BurnStateDB;
 use clarity::vm::errors::Error as InterpreterError;
 use clarity::vm::types::TypeSignature;
 use serde::Deserialize;
-use stacks_common::codec::{read_next, write_next, StacksMessageCodec};
+use stacks_common::codec::{
+    read_next, write_next, Error as CodecError, StacksMessageCodec, MAX_PAYLOAD_LEN,
+};
 use stacks_common::types::chainstate::{
     BlockHeaderHash, BurnchainHeaderHash, ConsensusHash, StacksAddress, StacksBlockId, TrieHash,
 };
@@ -62,7 +64,7 @@ use crate::chainstate::stacks::miner::{
     TransactionProblematic, TransactionResult, TransactionSkipped,
 };
 use crate::chainstate::stacks::{Error, StacksBlockHeader, *};
-use crate::clarity_vm::clarity::{ClarityConnection, ClarityInstance, Error as clarity_error};
+use crate::clarity_vm::clarity::{ClarityConnection, ClarityInstance};
 use crate::core::mempool::*;
 use crate::core::*;
 use crate::cost_estimates::metrics::CostMetric;
@@ -71,7 +73,7 @@ use crate::monitoring::{
     set_last_mined_block_transaction_count, set_last_mined_execution_cost_observed,
 };
 use crate::net::relay::Relayer;
-use crate::net::Error as net_error;
+use crate::util_lib::db::Error as DBError;
 
 /// Nakamaoto tenure information
 pub struct NakamotoTenureInfo {
@@ -502,6 +504,16 @@ impl NakamotoBlockBuilder {
     pub fn get_bytes_so_far(&self) -> u64 {
         self.bytes_so_far
     }
+
+    /// Add tx to block with no safety checks
+    /// For testing purposes only
+    ///
+    /// FIXME: Why does this not work in `nakamoto_integrations.rs` with `#[cfg(test)]`
+    //#[cfg(test)]
+    pub fn mine_tx_no_checks(&mut self, tx: StacksTransaction) {
+        self.bytes_so_far += tx.tx_len();
+        self.txs.push(tx)
+    }
 }
 
 impl BlockBuilder for NakamotoBlockBuilder {
@@ -623,3 +635,255 @@ impl BlockBuilder for NakamotoBlockBuilder {
         result
     }
 }
+
+/// This enum is used to supply a `reason_code` for validation
+///  rejection responses. This is serialized as an enum with string
+///  type (in jsonschema terminology).
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub enum ValidateRejectCode {
+    BadBlockHash,
+    BadTransaction,
+    InvalidBlock,
+    ChainstateError,
+    UnknownParent,
+}
+
+/// A response for block proposal validation
+///  that the stacks-node thinks should be rejected.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct BlockValidateReject {
+    pub reason: String,
+    pub reason_code: ValidateRejectCode,
+}
+
+/// A response for block proposal validation
+///  that the stacks-node thinks is acceptable.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct BlockValidateOk {
+    pub block: NakamotoBlock,
+    pub cost: ExecutionCost,
+    pub size: u64,
+}
+
+/// This enum is used for serializing the response to block
+/// proposal validation.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(tag = "Result")]
+pub enum BlockValidateResponse {
+    Ok(BlockValidateOk),
+    Reject(BlockValidateReject),
+}
+
+impl From<Result<BlockValidateOk, BlockValidateReject>> for BlockValidateResponse {
+    fn from(value: Result<BlockValidateOk, BlockValidateReject>) -> Self {
+        match value {
+            Ok(o) => BlockValidateResponse::Ok(o),
+            Err(e) => BlockValidateResponse::Reject(e),
+        }
+    }
+}
+
+impl From<Error> for BlockValidateReject {
+    fn from(value: Error) -> Self {
+        BlockValidateReject {
+            reason: format!("Chainstate Error: {value}"),
+            reason_code: ValidateRejectCode::ChainstateError,
+        }
+    }
+}
+
+impl From<DBError> for BlockValidateReject {
+    fn from(value: DBError) -> Self {
+        Error::from(value).into()
+    }
+}
+
+/// Represents a block proposed to the `v2/block_proposal` endpoint for validation
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct NakamotoBlockProposal {
+    /// Proposed block
+    pub block: NakamotoBlock,
+    // tenure ID -- this is the index block hash of the start block of the last tenure (i.e.
+    // the data we committed to in the block-commit).  If this is an epoch 2.x parent, then
+    // this is just the index block hash of the parent Stacks block.
+    pub tenure_start_block: StacksBlockId,
+    /// Identifies which chain block is for (Mainnet, Testnet, etc.)
+    pub chain_id: u32,
+    /// total BTC burn so far
+    pub total_burn: u64,
+}
+
+impl StacksMessageCodec for NakamotoBlockProposal {
+    fn consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), CodecError> {
+        write_next(fd, &self.block)?;
+        write_next(fd, &self.tenure_start_block)?;
+        write_next(fd, &self.chain_id)?;
+        write_next(fd, &self.total_burn)
+    }
+
+    fn consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, CodecError> {
+        Ok(Self {
+            block: read_next(fd)?,
+            tenure_start_block: read_next(fd)?,
+            chain_id: read_next(fd)?,
+            total_burn: read_next(fd)?,
+        })
+    }
+}
+
+impl NakamotoBlockProposal {
+    /// Test this block proposal against the current chain state and
+    /// either accept or reject the proposal
+    ///
+    /// This is done in 2 steps:
+    /// - Static validation of the block, which checks the following:
+    ///   - Block is well-formed
+    ///   - Transactions are well-formed
+    ///   - Miner signature is valid
+    /// - Validation of transactions by executing them agains current chainstate.
+    ///   This is resource intensive, and therefore done only if previous checks pass
+    pub fn validate(
+        &self,
+        sortdb: &SortitionDB,
+        chainstate: &mut StacksChainState, // not directly used; used as a handle to open other chainstates
+    ) -> Result<BlockValidateOk, BlockValidateReject> {
+        let ts_start = get_epoch_time_ms();
+        // Measure time from start of function
+        let time_elapsed = || get_epoch_time_ms().saturating_sub(ts_start);
+
+        let mainnet = self.chain_id == CHAIN_ID_MAINNET;
+        if self.chain_id != chainstate.chain_id || mainnet != chainstate.mainnet {
+            return Err(BlockValidateReject {
+                reason_code: ValidateRejectCode::InvalidBlock,
+                reason: "Wrong netowrk/chain_id".into(),
+            });
+        }
+
+        let burn_dbconn = sortdb.index_conn();
+        let sort_tip = SortitionDB::get_canonical_sortition_tip(sortdb.conn())?;
+        let mut db_handle = sortdb.index_handle(&sort_tip);
+        let expected_burn =
+            NakamotoChainState::get_expected_burns(&mut db_handle, chainstate.db(), &self.block)?;
+
+        // Static validation checks
+        NakamotoChainState::validate_nakamoto_block_burnchain(
+            &db_handle,
+            expected_burn,
+            &self.block,
+            mainnet,
+            self.chain_id,
+        )?;
+
+        // Validate block txs against chainstate
+        let parent_stacks_header = NakamotoChainState::get_block_header(
+            chainstate.db(),
+            &self.block.header.parent_block_id,
+        )?
+        .ok_or_else(|| BlockValidateReject {
+            reason_code: ValidateRejectCode::InvalidBlock,
+            reason: "Invalid parent block".into(),
+        })?;
+        let tenure_change = self
+            .block
+            .txs
+            .iter()
+            .find(|tx| matches!(tx.payload, TransactionPayload::TenureChange(..)));
+        let coinbase = self
+            .block
+            .txs
+            .iter()
+            .find(|tx| matches!(tx.payload, TransactionPayload::Coinbase(..)));
+        let tenure_cause = tenure_change.and_then(|tx| match &tx.payload {
+            TransactionPayload::TenureChange(tc) => Some(tc.cause),
+            _ => None,
+        });
+
+        let mut builder = NakamotoBlockBuilder::new(
+            &parent_stacks_header,
+            &self.block.header.consensus_hash,
+            self.total_burn,
+            tenure_change,
+            coinbase,
+        )?;
+
+        let mut miner_tenure_info =
+            builder.load_tenure_info(chainstate, &burn_dbconn, tenure_cause)?;
+        let mut tenure_tx = builder.tenure_begin(&burn_dbconn, &mut miner_tenure_info)?;
+
+        for (i, tx) in self.block.txs.iter().enumerate() {
+            let tx_len = tx.tx_len();
+            let tx_result = builder.try_mine_tx_with_len(
+                &mut tenure_tx,
+                &tx,
+                tx_len,
+                &BlockLimitFunction::NO_LIMIT_HIT,
+                ASTRules::PrecheckSize,
+            );
+            let err = match tx_result {
+                TransactionResult::Success(_) => Ok(()),
+                TransactionResult::Skipped(s) => Err(format!("tx {i} skipped: {}", s.error)),
+                TransactionResult::ProcessingError(e) => {
+                    Err(format!("Error processing tx {i}: {}", e.error))
+                }
+                TransactionResult::Problematic(p) => {
+                    Err(format!("Problematic tx {i}: {}", p.error))
+                }
+            };
+            if let Err(reason) = err {
+                warn!(
+                    "Rejected block proposal";
+                    "reason" => %reason,
+                    "tx" => ?tx,
+                );
+                return Err(BlockValidateReject {
+                    reason,
+                    reason_code: ValidateRejectCode::BadTransaction,
+                });
+            }
+        }
+
+        let mut block = builder.mine_nakamoto_block(&mut tenure_tx);
+        let size = builder.get_bytes_so_far();
+        let cost = builder.tenure_finish(tenure_tx);
+
+        // Clone signatures from block proposal
+        // These have already been validated by `validate_nakamoto_block_burnchain()``
+        block.header.miner_signature = self.block.header.miner_signature.clone();
+        block.header.signer_signature = self.block.header.signer_signature.clone();
+
+        // Assuming `tx_nerkle_root` has been checked we don't need to hash the whole block
+        let expected_block_header_hash = self.block.header.block_hash();
+        let computed_block_header_hash = block.header.block_hash();
+
+        if computed_block_header_hash != expected_block_header_hash {
+            warn!(
+                "Rejected block proposal";
+                "reason" => "Block hash is not as expected",
+                "expected_block_header_hash" => %expected_block_header_hash,
+                "computed_block_header_hash" => %computed_block_header_hash,
+                "expected_block" => %serde_json::to_string(&serde_json::to_value(&self.block).unwrap()).unwrap(),
+                "computed_block" => %serde_json::to_string(&serde_json::to_value(&block).unwrap()).unwrap(),
+            );
+            return Err(BlockValidateReject {
+                reason: "Block hash is not as expected".into(),
+                reason_code: ValidateRejectCode::BadBlockHash,
+            });
+        }
+
+        info!(
+            "Participant: validated anchored block";
+            "block_header_hash" => %computed_block_header_hash,
+            "height" => block.header.chain_length,
+            "tx_count" => block.txs.len(),
+            "parent_stacks_block_id" => %block.header.parent_block_id,
+            "block_size" => size,
+            "execution_cost" => %cost,
+            "validation_time_ms" => time_elapsed(),
+            "tx_fees_microstacks" => block.txs.iter().fold(0, |agg: u64, tx| {
+                agg.saturating_add(tx.get_tx_fee())
+            })
+        );
+
+        Ok(BlockValidateOk { block, cost, size })
+    }
+}
diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index c1dacf57ab..d3a3e26a0f 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -87,7 +87,6 @@ use crate::util_lib::db::{
 
 pub mod coordinator;
 pub mod miner;
-pub mod proposal;
 pub mod tenure;
 
 #[cfg(test)]
@@ -577,13 +576,9 @@ impl NakamotoBlock {
 
         // there is one coinbase.
         // go find it.
-        self.txs.iter().find(|tx| {
-            if let TransactionPayload::Coinbase(..) = &tx.payload {
-                true
-            } else {
-                false
-            }
-        })
+        self.txs
+            .iter()
+            .find(|tx| matches!(tx.payload, TransactionPayload::Coinbase(..)))
     }
 
     /// Get the VRF proof from this block.
@@ -1051,7 +1046,7 @@ impl NakamotoBlock {
             .map_err(|e| {
                 warn!(
                     "Leader key did not contain a hash160 of the miner signing public key";
-                    "leader_key" => format!("{:?}", &leader_key),
+                    "leader_key" => ?leader_key,
                 );
                 e
             })?;
@@ -2165,7 +2160,7 @@ impl NakamotoChainState {
             total_tenure_cost,
             &tenure_tx_fees.to_string(),
             &header.parent_block_id,
-            if tenure_changed { &1i64 } else { &0 },
+            if tenure_changed { &1i64 } else { &0i64 },
             &vrf_proof_bytes.as_ref(),
         ];
 
diff --git a/stackslib/src/chainstate/nakamoto/proposal.rs b/stackslib/src/chainstate/nakamoto/proposal.rs
deleted file mode 100644
index 98c1d89d14..0000000000
--- a/stackslib/src/chainstate/nakamoto/proposal.rs
+++ /dev/null
@@ -1,319 +0,0 @@
-use std::collections::{HashMap, HashSet};
-use std::convert::From;
-use std::io::{Read, Write};
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::{Arc, Mutex};
-use std::thread::ThreadId;
-use std::{cmp, fs, mem};
-
-use clarity::vm::analysis::{CheckError, CheckErrors};
-use clarity::vm::ast::errors::ParseErrors;
-use clarity::vm::ast::ASTRules;
-use clarity::vm::clarity::TransactionConnection;
-use clarity::vm::costs::ExecutionCost;
-use clarity::vm::database::BurnStateDB;
-use clarity::vm::errors::Error as InterpreterError;
-use clarity::vm::types::TypeSignature;
-use serde::Deserialize;
-use stacks_common::codec::{
-    read_next, write_next, Error as CodecError, StacksMessageCodec, MAX_PAYLOAD_LEN,
-};
-use stacks_common::types::chainstate::{
-    BlockHeaderHash, BurnchainHeaderHash, ConsensusHash, StacksAddress, StacksBlockId, TrieHash,
-};
-use stacks_common::types::StacksPublicKeyBuffer;
-use stacks_common::util::get_epoch_time_ms;
-use stacks_common::util::hash::{Hash160, MerkleTree, Sha512Trunc256Sum};
-use stacks_common::util::secp256k1::{MessageSignature, Secp256k1PrivateKey};
-use stacks_common::util::vrf::*;
-
-use crate::burnchains::{PrivateKey, PublicKey};
-use crate::chainstate::burn::db::sortdb::{SortitionDB, SortitionDBConn, SortitionHandleTx};
-use crate::chainstate::burn::operations::*;
-use crate::chainstate::burn::*;
-use crate::chainstate::nakamoto::miner::NakamotoBlockBuilder;
-use crate::chainstate::nakamoto::{
-    NakamotoBlock, NakamotoBlockHeader, NakamotoChainState, SetupBlockResult,
-};
-use crate::chainstate::stacks::address::StacksAddressExtensions;
-use crate::chainstate::stacks::db::accounts::MinerReward;
-use crate::chainstate::stacks::db::blocks::MemPoolRejection;
-use crate::chainstate::stacks::db::transactions::{
-    handle_clarity_runtime_error, ClarityRuntimeTxError,
-};
-use crate::chainstate::stacks::db::{
-    ChainstateTx, ClarityTx, MinerRewardInfo, StacksChainState, StacksHeaderInfo,
-    MINER_REWARD_MATURITY,
-};
-use crate::chainstate::stacks::events::{StacksTransactionEvent, StacksTransactionReceipt};
-use crate::chainstate::stacks::miner::{
-    BlockBuilder, BlockBuilderSettings, BlockLimitFunction, TransactionError,
-    TransactionProblematic, TransactionResult, TransactionSkipped,
-};
-use crate::chainstate::stacks::{Error, StacksBlockHeader, *};
-use crate::clarity_vm::clarity::{ClarityConnection, ClarityInstance, Error as clarity_error};
-use crate::core::mempool::*;
-use crate::core::*;
-use crate::cost_estimates::metrics::CostMetric;
-use crate::cost_estimates::CostEstimator;
-use crate::monitoring::{
-    set_last_mined_block_transaction_count, set_last_mined_execution_cost_observed,
-};
-use crate::net::relay::Relayer;
-use crate::net::Error as net_error;
-use crate::util_lib::db::Error as DBError;
-
-/// This enum is used to supply a `reason_code` for validation
-///  rejection responses. This is serialized as an enum with string
-///  type (in jsonschema terminology).
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub enum ValidateRejectCode {
-    BadBlockHash,
-    BadTransaction,
-    InvalidBlock,
-    ChainstateError,
-    UnknownParent,
-}
-
-/// A response for block proposal validation
-///  that the stacks-node thinks should be rejected.
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct BlockValidateReject {
-    pub reason: String,
-    pub reason_code: ValidateRejectCode,
-}
-
-/// A response for block proposal validation
-///  that the stacks-node thinks is acceptable.
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct BlockValidateOk {
-    pub block: NakamotoBlock,
-    pub cost: ExecutionCost,
-    pub size: u64,
-}
-
-/// This enum is used for serializing the response to block
-/// proposal validation.
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(tag = "Result")]
-pub enum BlockValidateResponse {
-    Ok(BlockValidateOk),
-    Reject(BlockValidateReject),
-}
-
-impl From<Result<BlockValidateOk, BlockValidateReject>> for BlockValidateResponse {
-    fn from(value: Result<BlockValidateOk, BlockValidateReject>) -> Self {
-        match value {
-            Ok(o) => BlockValidateResponse::Ok(o),
-            Err(e) => BlockValidateResponse::Reject(e),
-        }
-    }
-}
-
-impl From<Error> for BlockValidateReject {
-    fn from(value: Error) -> Self {
-        BlockValidateReject {
-            reason: format!("Chainstate Error: {value}"),
-            reason_code: ValidateRejectCode::ChainstateError,
-        }
-    }
-}
-
-impl From<DBError> for BlockValidateReject {
-    fn from(value: DBError) -> Self {
-        Error::from(value).into()
-    }
-}
-
-/// Represents a block proposed to the `v2/block_proposal` endpoint for validation
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct NakamotoBlockProposal {
-    /// Proposed block
-    pub block: NakamotoBlock,
-    // tenure ID -- this is the index block hash of the start block of the last tenure (i.e.
-    // the data we committed to in the block-commit).  If this is an epoch 2.x parent, then
-    // this is just the index block hash of the parent Stacks block.
-    pub tenure_start_block: StacksBlockId,
-    /// Identifies which chain block is for (Mainnet, Testnet, etc.)
-    pub chain_id: u32,
-    /// total BTC burn so far
-    pub total_burn: u64,
-}
-
-impl StacksMessageCodec for NakamotoBlockProposal {
-    fn consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), CodecError> {
-        write_next(fd, &self.block)?;
-        write_next(fd, &self.tenure_start_block)?;
-        write_next(fd, &self.chain_id)?;
-        write_next(fd, &self.total_burn)
-    }
-
-    fn consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, CodecError> {
-        Ok(Self {
-            block: read_next(fd)?,
-            tenure_start_block: read_next(fd)?,
-            chain_id: read_next(fd)?,
-            total_burn: read_next(fd)?,
-        })
-    }
-}
-
-impl NakamotoBlockProposal {
-    /// Test this block proposal against the current chain state and
-    /// either accept or reject the proposal
-    ///
-    /// This is done in 2 steps:
-    /// - Static validation of the block, which checks the following:
-    ///   - Block is well-formed
-    ///   - Transactions are well-formed
-    ///   - Miner signature is valid
-    /// - Validation of transactions by executing them agains current chainstate.
-    ///   This is resource intensive, and therefore done only if previous checks pass
-    pub fn validate(
-        &self,
-        sortdb: &SortitionDB,
-        chainstate: &mut StacksChainState, // not directly used; used as a handle to open other chainstates
-    ) -> Result<BlockValidateOk, BlockValidateReject> {
-        // Time this function
-        let ts_start = get_epoch_time_ms();
-
-        let mainnet = self.chain_id == CHAIN_ID_MAINNET;
-        if self.chain_id != chainstate.chain_id || mainnet != chainstate.mainnet {
-            return Err(BlockValidateReject {
-                reason_code: ValidateRejectCode::InvalidBlock,
-                reason: "Wrong netowrk/chain_id".into(),
-            });
-        }
-
-        let burn_dbconn = sortdb.index_conn();
-        let sort_tip = SortitionDB::get_canonical_sortition_tip(sortdb.conn())?;
-        let mut db_handle = sortdb.index_handle(&sort_tip);
-        // Is this safe?
-        let mut _chainstate = chainstate.reopen()?.0;
-        let (chainstate_tx, _clarity_instance) = _chainstate.chainstate_tx_begin()?;
-        let expected_burn =
-            NakamotoChainState::get_expected_burns(&mut db_handle, &chainstate_tx, &self.block)?;
-
-        // Static validation checks
-        NakamotoChainState::validate_nakamoto_block_burnchain(
-            &db_handle,
-            expected_burn,
-            &self.block,
-            mainnet,
-            self.chain_id,
-        )?;
-
-        // Validate block txs against chainstate
-        let parent_stacks_header = NakamotoChainState::get_block_header(
-            &chainstate_tx,
-            &self.block.header.parent_block_id,
-        )?
-        .ok_or_else(|| BlockValidateReject {
-            reason_code: ValidateRejectCode::InvalidBlock,
-            reason: "Invalid parent block".into(),
-        })?;
-        let tenure_change = self
-            .block
-            .txs
-            .iter()
-            .find(|tx| matches!(tx.payload, TransactionPayload::TenureChange(..)));
-        let coinbase = self
-            .block
-            .txs
-            .iter()
-            .find(|tx| matches!(tx.payload, TransactionPayload::Coinbase(..)));
-        let tenure_cause = tenure_change.and_then(|tx| match &tx.payload {
-            TransactionPayload::TenureChange(tc) => Some(tc.cause),
-            _ => None,
-        });
-
-        let mut builder = NakamotoBlockBuilder::new_from_parent(
-            &self.tenure_start_block,
-            &parent_stacks_header,
-            &self.block.header.consensus_hash,
-            self.total_burn,
-            tenure_change,
-            coinbase,
-        )?;
-
-        let mut miner_tenure_info =
-            builder.load_tenure_info(chainstate, &burn_dbconn, tenure_cause)?;
-        let mut tenure_tx = builder.tenure_begin(&burn_dbconn, &mut miner_tenure_info)?;
-
-        for (i, tx) in self.block.txs.iter().enumerate() {
-            let tx_len = tx.tx_len();
-            let tx_result = builder.try_mine_tx_with_len(
-                &mut tenure_tx,
-                &tx,
-                tx_len,
-                &BlockLimitFunction::NO_LIMIT_HIT,
-                ASTRules::PrecheckSize,
-            );
-            let err = match tx_result {
-                TransactionResult::Success(_) => Ok(()),
-                TransactionResult::Skipped(s) => Err(format!("tx {i} skipped: {}", s.error)),
-                TransactionResult::ProcessingError(e) => {
-                    Err(format!("Error processing tx {i}: {}", e.error))
-                }
-                TransactionResult::Problematic(p) => {
-                    Err(format!("Problematic tx {i}: {}", p.error))
-                }
-            };
-            if let Err(reason) = err {
-                warn!(
-                    "Rejected block proposal";
-                    "reason" => %reason,
-                    "tx" => ?tx,
-                );
-                return Err(BlockValidateReject {
-                    reason,
-                    reason_code: ValidateRejectCode::BadTransaction,
-                });
-            }
-        }
-
-        let mut block = builder.mine_nakamoto_block(&mut tenure_tx);
-        let size = builder.get_bytes_so_far();
-        let cost = builder.tenure_finish(tenure_tx);
-
-        // Clone signatures from block proposal
-        // These have already been validated by `validate_nakamoto_block_burnchain()``
-        block.header.miner_signature = self.block.header.miner_signature.clone();
-        block.header.signer_signature = self.block.header.signer_signature.clone();
-
-        // Assuming `tx_nerkle_root` has been checked we don't need to hash the whole block
-        let expected_block_header_hash = self.block.header.block_hash();
-        let computed_block_header_hash = block.header.block_hash();
-
-        if computed_block_header_hash != expected_block_header_hash {
-            warn!(
-                "Rejected block proposal";
-                "reason" => "Block hash is not as expected",
-                "expected_block_header_hash" => %expected_block_header_hash,
-                "computed_block_header_hash" => %computed_block_header_hash,
-            );
-            return Err(BlockValidateReject {
-                reason: "Block hash is not as expected".into(),
-                reason_code: ValidateRejectCode::BadBlockHash,
-            });
-        }
-
-        let ts_end = get_epoch_time_ms();
-
-        info!(
-            "Participant: validated anchored block";
-            "block_header_hash" => %computed_block_header_hash,
-            "height" => block.header.chain_length,
-            "tx_count" => block.txs.len(),
-            "parent_stacks_block_id" => %block.header.parent_block_id,
-            "block_size" => size,
-            "execution_cost" => %cost,
-            "validation_time_ms" => ts_end.saturating_sub(ts_start),
-            "tx_fees_microstacks" => block.txs.iter().fold(0, |agg: u64, tx| {
-                agg.saturating_add(tx.get_tx_fee())
-            })
-        );
-
-        Ok(BlockValidateOk { block, cost, size })
-    }
-}
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 3fd4ee1736..1051a97e0f 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -507,7 +507,7 @@ fn pox_extend_transition() {
     for cycle_number in first_v4_cycle..(first_v4_cycle + 4) {
         let cycle_start = burnchain.reward_cycle_to_block_height(cycle_number);
         let reward_set_entries = get_reward_set_entries_at(&mut peer, &latest_block, cycle_start);
-        info!("----- {cycle_number} -----");
+        //info!("----- {cycle_number} -----");
         assert_eq!(reward_set_entries.len(), 1);
         assert_eq!(
             reward_set_entries[0].reward_address.bytes(),
@@ -607,6 +607,7 @@ fn pox_extend_transition() {
     for cycle_number in (first_v4_cycle + 4)..(first_v4_cycle + 10) {
         let cycle_start = burnchain.reward_cycle_to_block_height(cycle_number);
         let reward_set_entries = get_reward_set_entries_at(&mut peer, &latest_block, cycle_start);
+        info!("----- {cycle_number} -----");
         assert_eq!(reward_set_entries.len(), 1);
         assert_eq!(
             reward_set_entries[0].reward_address.bytes(),
diff --git a/stackslib/src/chainstate/stacks/transaction.rs b/stackslib/src/chainstate/stacks/transaction.rs
index ff9efc7724..cf46bb7f42 100644
--- a/stackslib/src/chainstate/stacks/transaction.rs
+++ b/stackslib/src/chainstate/stacks/transaction.rs
@@ -710,7 +710,7 @@ impl StacksTransaction {
         &self,
     ) -> Option<(&CoinbasePayload, Option<&PrincipalData>, Option<&VRFProof>)> {
         match &self.payload {
-            TransactionPayload::Coinbase(ref payload, ref recipient_opt, ref vrf_proof_opt) => {
+            TransactionPayload::Coinbase(payload, recipient_opt, vrf_proof_opt) => {
                 Some((payload, recipient_opt.as_ref(), vrf_proof_opt.as_ref()))
             }
             _ => None,
@@ -720,7 +720,7 @@ impl StacksTransaction {
     /// Try to convert to a tenure change payload
     pub fn try_as_tenure_change(&self) -> Option<&TenureChangePayload> {
         match &self.payload {
-            TransactionPayload::TenureChange(ref tc_payload) => Some(tc_payload),
+            TransactionPayload::TenureChange(tc_payload) => Some(tc_payload),
             _ => None,
         }
     }
diff --git a/stackslib/src/net/api/postblock_proposal.rs b/stackslib/src/net/api/postblock_proposal.rs
index 057cc9f8d9..345b3ccde6 100644
--- a/stackslib/src/net/api/postblock_proposal.rs
+++ b/stackslib/src/net/api/postblock_proposal.rs
@@ -32,7 +32,7 @@ use stacks_common::util::retry::BoundReader;
 use crate::burnchains::affirmation::AffirmationMap;
 use crate::burnchains::Txid;
 use crate::chainstate::burn::db::sortdb::SortitionDB;
-use crate::chainstate::nakamoto::proposal::{BlockValidateResponse, NakamotoBlockProposal};
+use crate::chainstate::nakamoto::miner::{BlockValidateResponse, NakamotoBlockProposal};
 use crate::chainstate::nakamoto::NakamotoBlock;
 use crate::chainstate::stacks::db::blocks::MINIMUM_TX_FEE_RATE_PER_BYTE;
 use crate::chainstate::stacks::db::StacksChainState;
@@ -42,7 +42,7 @@ use crate::chainstate::stacks::{
 use crate::core::mempool::MemPoolDB;
 use crate::cost_estimates::FeeRateEstimate;
 use crate::net::http::{
-    parse_json, Error, HttpBadRequest, HttpContentType, HttpNotFound, HttpRequest,
+    http_reason, parse_json, Error, HttpBadRequest, HttpContentType, HttpNotFound, HttpRequest,
     HttpRequestContents, HttpRequestPreamble, HttpResponse, HttpResponseContents,
     HttpResponsePayload, HttpResponsePreamble, HttpServerError,
 };
@@ -162,14 +162,25 @@ impl RPCRequestHandler for RPCBlockProposalRequestHandler {
             .take()
             .ok_or(NetError::SendError("`block_proposal` not set".into()))?;
 
-        let resp = node.with_node_state(|_network, sortdb, chainstate, _mempool, _rpc_args| {
+        let res = node.with_node_state(|_network, sortdb, chainstate, _mempool, _rpc_args| {
             block_proposal.validate(sortdb, chainstate)
         });
 
-        let mut preamble = HttpResponsePreamble::ok_json(&preamble);
-        preamble.set_canonical_stacks_tip_height(Some(node.canonical_stacks_tip_height()));
-        let body = HttpResponseContents::try_from_json(&resp)?;
-        Ok((preamble, body))
+        match res {
+            Ok(ok) => {
+                let mut preamble = HttpResponsePreamble::accepted_json(&preamble);
+                preamble.set_canonical_stacks_tip_height(Some(node.canonical_stacks_tip_height()));
+                let body = HttpResponseContents::try_from_json(&ok)?;
+                Ok((preamble, body))
+            }
+            Err(err) => {
+                let code = 400;
+                let mut preamble = HttpResponsePreamble::error_json(code, http_reason(code));
+                preamble.set_canonical_stacks_tip_height(Some(node.canonical_stacks_tip_height()));
+                let body = HttpResponseContents::try_from_json(&err)?;
+                Ok((preamble, body))
+            }
+        }
     }
 }
 
diff --git a/stackslib/src/net/http/response.rs b/stackslib/src/net/http/response.rs
index 57a1afb2ce..6c2a610663 100644
--- a/stackslib/src/net/http/response.rs
+++ b/stackslib/src/net/http/response.rs
@@ -34,7 +34,7 @@ use crate::net::http::common::{
 };
 use crate::net::http::request::{HttpRequestContents, HttpRequestPreamble};
 use crate::net::http::stream::HttpChunkGenerator;
-use crate::net::http::{write_headers, Error, HttpContentType, HttpVersion};
+use crate::net::http::{http_reason, write_headers, Error, HttpContentType, HttpVersion};
 
 /// HTTP response preamble.  This captures all HTTP header information, but in a way that
 /// certain fields that nodes rely on are guaranteed to have correct, sensible values.
@@ -185,17 +185,28 @@ impl HttpResponsePreamble {
         )
     }
 
-    pub fn ok_json(preamble: &HttpRequestPreamble) -> HttpResponsePreamble {
+    pub fn success_2xx_json(
+        preamble: &HttpRequestPreamble,
+        status_code: u16,
+    ) -> HttpResponsePreamble {
         HttpResponsePreamble::new(
             preamble.version,
-            200,
-            "OK".to_string(),
+            status_code,
+            http_reason(status_code).to_string(),
             None,
             HttpContentType::JSON,
             preamble.keep_alive,
         )
     }
 
+    pub fn ok_json(preamble: &HttpRequestPreamble) -> HttpResponsePreamble {
+        Self::success_2xx_json(preamble, 200)
+    }
+
+    pub fn accepted_json(preamble: &HttpRequestPreamble) -> HttpResponsePreamble {
+        Self::success_2xx_json(preamble, 202)
+    }
+
     pub fn raw_ok_json(version: HttpVersion, keep_alive: bool) -> HttpResponsePreamble {
         HttpResponsePreamble::new(
             version,
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 3ca0b69493..8d45251bf9 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -18,14 +18,19 @@ use std::sync::{Arc, Mutex};
 use std::time::{Duration, Instant};
 use std::{env, thread};
 
+use clarity::vm::ast::ASTRules;
 use clarity::vm::costs::ExecutionCost;
 use clarity::vm::types::PrincipalData;
 use lazy_static::lazy_static;
+//use stacks::burnchains::tests::TestMinerFactory;
 use stacks::burnchains::MagicBytes;
 use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::coordinator::comm::CoordinatorChannels;
+use stacks::chainstate::nakamoto::miner::{NakamotoBlockBuilder, NakamotoBlockProposal};
 use stacks::chainstate::nakamoto::NakamotoChainState;
 use stacks::chainstate::stacks::db::StacksChainState;
+use stacks::chainstate::stacks::miner::{BlockBuilder, BlockLimitFunction, TransactionResult};
+use stacks::chainstate::stacks::{StacksTransaction, TransactionPayload};
 use stacks::core::{
     StacksEpoch, StacksEpochId, BLOCK_LIMIT_MAINNET_10, HELIUM_BLOCK_LIMIT_20,
     PEER_VERSION_EPOCH_1_0, PEER_VERSION_EPOCH_2_0, PEER_VERSION_EPOCH_2_05,
@@ -33,21 +38,22 @@ use stacks::core::{
     PEER_VERSION_EPOCH_2_5, PEER_VERSION_EPOCH_3_0,
 };
 use stacks_common::address::AddressHashMode;
+use stacks_common::codec::StacksMessageCodec;
 use stacks_common::consts::STACKS_EPOCH_MAX;
-use stacks_common::types::chainstate::{StacksAddress, StacksPublicKey};
+use stacks_common::types::chainstate::{StacksAddress, StacksPrivateKey, StacksPublicKey};
 use stacks_common::util::hash::to_hex;
 use stacks_common::util::secp256k1::Secp256k1PrivateKey;
 
 use super::bitcoin_regtest::BitcoinCoreController;
-use crate::config::{EventKeyType, EventObserverConfig};
+use crate::config::{EventKeyType, EventObserverConfig, InitialBalance};
 use crate::mockamoto::signer::SelfSigner;
 use crate::neon::{Counters, RunLoopCounter};
 use crate::run_loop::boot_nakamoto;
-use crate::tests::make_stacks_transfer;
 use crate::tests::neon_integrations::{
     get_account, get_pox_info, next_block_and_wait, run_until_burnchain_height, submit_tx,
     test_observer, wait_for_runloop,
 };
+use crate::tests::{make_stacks_transfer, to_addr};
 use crate::{tests, BitcoinRegtestController, BurnchainController, Config, ConfigFile, Keychain};
 
 static POX_4_DEFAULT_STACKER_BALANCE: u64 = 100_000_000_000_000;
@@ -121,9 +127,27 @@ lazy_static! {
     ];
 }
 
+pub fn add_initial_balances(conf: &mut Config, accounts: usize) -> Vec<StacksPrivateKey> {
+    (0..accounts)
+        .map(|i| {
+            let privk = StacksPrivateKey::from_seed(&[5, 5, 5, i as u8]);
+
+            conf.initial_balances.push(InitialBalance {
+                address: to_addr(&privk).into(),
+                amount: 100000,
+            });
+            privk
+        })
+        .collect()
+}
+
 /// Return a working nakamoto-neon config and the miner's bitcoin address to fund
-pub fn naka_neon_integration_conf(seed: Option<&[u8]>) -> (Config, StacksAddress) {
+pub fn naka_neon_integration_conf(
+    seed: Option<&[u8]>,
+) -> (Config, StacksAddress, Vec<StacksPrivateKey>) {
     let mut conf = super::new_test_conf();
+    let account_keys = add_initial_balances(&mut conf, 10);
+
     conf.burnchain.mode = "nakamoto-neon".into();
 
     // tests can override this, but these tests run with epoch 2.05 by default
@@ -138,7 +162,7 @@ pub fn naka_neon_integration_conf(seed: Option<&[u8]>) -> (Config, StacksAddress
 
     let mining_key = Secp256k1PrivateKey::from_seed(&[1]);
     conf.miner.mining_key = Some(mining_key);
-    conf.miner.self_signing_key = Some(SelfSigner::single_signer());
+    conf.miner.self_signing_key = Some(SelfSigner::from_seed(7));
 
     conf.node.miner = true;
     conf.node.wait_time_for_microblocks = 500;
@@ -180,7 +204,7 @@ pub fn naka_neon_integration_conf(seed: Option<&[u8]>) -> (Config, StacksAddress
     conf.burnchain.pox_prepare_length = Some(5);
     conf.burnchain.pox_reward_length = Some(20);
 
-    (conf, miner_account)
+    (conf, miner_account, account_keys)
 }
 
 pub fn next_block_and<F>(
@@ -371,7 +395,7 @@ fn simple_neon_integration() {
         return;
     }
 
-    let (mut naka_conf, _miner_account) = naka_neon_integration_conf(None);
+    let (mut naka_conf, _miner_account, _account_keys) = naka_neon_integration_conf(None);
     let prom_bind = format!("{}:{}", "127.0.0.1", 6000);
     naka_conf.node.prometheus_bind = Some(prom_bind.clone());
     naka_conf.miner.wait_on_interim_blocks = Duration::from_secs(1000);
@@ -586,7 +610,7 @@ fn mine_multiple_per_tenure_integration() {
         return;
     }
 
-    let (mut naka_conf, _miner_account) = naka_neon_integration_conf(None);
+    let (mut naka_conf, _miner_account, _account_keys) = naka_neon_integration_conf(None);
     let http_origin = format!("http://{}", &naka_conf.node.rpc_bind);
     naka_conf.miner.wait_on_interim_blocks = Duration::from_secs(1);
     let sender_sk = Secp256k1PrivateKey::new();
@@ -946,3 +970,234 @@ fn correct_burn_outs() {
 
     run_loop_thread.join().unwrap();
 }
+
+/// Test `/v2/block_proposal` API endpoint
+///
+/// This endpoint allows miners to propose Nakamoto blocks to a node,
+/// and test if they would be accepted or rejected
+#[test]
+#[ignore]
+fn block_proposal_api_endpoint() {
+    if env::var("BITCOIND_TEST") != Ok("1".into()) {
+        return;
+    }
+
+    let (mut conf, _miner_account, account_keys) = naka_neon_integration_conf(None);
+    let sender_sk = Secp256k1PrivateKey::new();
+    // setup sender + recipient for a test stx transfer
+    let sender_addr = tests::to_addr(&sender_sk);
+    let send_amt = 1000;
+    let send_fee = 100;
+    conf.add_initial_balance(
+        PrincipalData::from(sender_addr.clone()).to_string(),
+        send_amt + send_fee,
+    );
+    let _recipient = PrincipalData::from(StacksAddress::burn_address(false));
+    let stacker_sk = setup_stacker(&mut conf);
+
+    test_observer::spawn();
+    let observer_port = test_observer::EVENT_OBSERVER_PORT;
+    conf.events_observers.insert(EventObserverConfig {
+        endpoint: format!("localhost:{observer_port}"),
+        events_keys: vec![EventKeyType::AnyEvent],
+    });
+
+    let mut btcd_controller = BitcoinCoreController::new(conf.clone());
+    btcd_controller
+        .start_bitcoind()
+        .expect("Failed starting bitcoind");
+    let mut btc_regtest_controller = BitcoinRegtestController::new(conf.clone(), None);
+    btc_regtest_controller.bootstrap_chain(201);
+
+    let mut run_loop = boot_nakamoto::BootRunLoop::new(conf.clone()).unwrap();
+    let run_loop_stopper = run_loop.get_termination_switch();
+    let Counters {
+        blocks_processed,
+        naka_submitted_vrfs: vrfs_submitted,
+        naka_submitted_commits: commits_submitted,
+        ..
+    } = run_loop.counters();
+
+    let coord_channel = run_loop.coordinator_channels();
+
+    let run_loop_thread = thread::spawn(move || run_loop.start(None, 0));
+    wait_for_runloop(&blocks_processed);
+    boot_to_epoch_3(
+        &conf,
+        &blocks_processed,
+        stacker_sk,
+        &mut btc_regtest_controller,
+    );
+
+    info!("Bootstrapped to Epoch-3.0 boundary, starting nakamoto miner");
+
+    let burnchain = conf.get_burnchain();
+    let sortdb = burnchain.open_sortition_db(true).unwrap();
+    let (mut chainstate, _) = StacksChainState::open(
+        conf.is_mainnet(),
+        conf.burnchain.chain_id,
+        &conf.get_chainstate_path_str(),
+        None,
+    )
+    .unwrap();
+
+    let _block_height_pre_3_0 =
+        NakamotoChainState::get_canonical_block_header(chainstate.db(), &sortdb)
+            .unwrap()
+            .unwrap()
+            .stacks_block_height;
+
+    info!("Nakamoto miner started...");
+
+    // first block wakes up the run loop, wait until a key registration has been submitted.
+    next_block_and(&mut btc_regtest_controller, 60, || {
+        let vrf_count = vrfs_submitted.load(Ordering::SeqCst);
+        Ok(vrf_count >= 1)
+    })
+    .unwrap();
+
+    // second block should confirm the VRF register, wait until a block commit is submitted
+    next_block_and(&mut btc_regtest_controller, 60, || {
+        let commits_count = commits_submitted.load(Ordering::SeqCst);
+        Ok(commits_count >= 1)
+    })
+    .unwrap();
+
+    // Mine 15 nakamoto tenures
+    for _ in 0..15 {
+        next_block_and_mine_commit(
+            &mut btc_regtest_controller,
+            60,
+            &coord_channel,
+            &commits_submitted,
+        )
+        .unwrap();
+    }
+
+    // TODO (hack) instantiate the sortdb in the burnchain
+    _ = btc_regtest_controller.sortdb_mut();
+
+    // Set up test signer
+    let signer = conf.miner.self_signing_key.as_mut().unwrap();
+
+    // ----- Setup boilerplate finished, test block proposal API endpoint -----
+
+    let tip = NakamotoChainState::get_canonical_block_header(chainstate.db(), &sortdb)
+        .unwrap()
+        .unwrap();
+
+    let privk = conf.miner.mining_key.unwrap().clone();
+    let parent_block_id = tip.index_block_hash();
+    // TODO
+    let total_burn = 640000;
+    let tenure_change = None;
+    let coinbase = None;
+
+    let tenure_cause = tenure_change.and_then(|tx: &StacksTransaction| match &tx.payload {
+        TransactionPayload::TenureChange(tc) => Some(tc.cause),
+        _ => None,
+    });
+
+    // Apply both miner/stacker signatures
+    let mut sign = |mut p: NakamotoBlockProposal| {
+        p.block
+            .header
+            .sign_miner(&privk)
+            .expect("Miner failed to sign");
+        signer.sign_nakamoto_block(&mut p.block);
+        p
+    };
+
+    // Put block builder in code block so any database locks expire at the end
+    let block = {
+        let mut builder = NakamotoBlockBuilder::new(
+            &tip,
+            &tip.consensus_hash,
+            total_burn,
+            tenure_change,
+            coinbase,
+        )
+        .expect("Failed to build Nakamoto block");
+
+        let burn_dbconn = btc_regtest_controller.sortdb_ref().index_conn();
+        let mut miner_tenure_info = builder
+            .load_tenure_info(&mut chainstate, &burn_dbconn, tenure_cause)
+            .unwrap();
+        let mut tenure_tx = builder
+            .tenure_begin(&burn_dbconn, &mut miner_tenure_info)
+            .unwrap();
+
+        let tx = make_stacks_transfer(
+            &account_keys[0],
+            0,
+            100,
+            &to_addr(&account_keys[1]).into(),
+            10000,
+        );
+        let tx = StacksTransaction::consensus_deserialize(&mut &tx[..])
+            .expect("Failed to deserialize transaction");
+        let tx_len = tx.tx_len();
+
+        let res = builder.try_mine_tx_with_len(
+            &mut tenure_tx,
+            &tx,
+            tx_len,
+            &BlockLimitFunction::NO_LIMIT_HIT,
+            ASTRules::PrecheckSize,
+        );
+        assert!(
+            matches!(res, TransactionResult::Success(..)),
+            "Transaction failed"
+        );
+        builder.mine_nakamoto_block(&mut tenure_tx)
+    };
+
+    // Construct a valid proposal. Make alterations to this to test failure cases
+    let proposal = NakamotoBlockProposal {
+        block,
+        tenure_start_block: parent_block_id,
+        chain_id: chainstate.chain_id,
+        total_burn,
+    };
+
+    const HTTP_ACCEPTED: u16 = 202;
+    const HTTP_BADREQUEST: u16 = 400;
+    let test_cases = [
+        ("No signature", proposal.clone(), HTTP_BADREQUEST),
+        ("Signed", sign(proposal.clone()), HTTP_ACCEPTED),
+    ];
+
+    // Build HTTP client
+    let client = reqwest::blocking::Client::builder()
+        .timeout(Duration::from_secs(60))
+        .build()
+        .expect("Failed to build reqwest::Client");
+    // Build URL
+    let http_origin = format!("http://{}", &conf.node.rpc_bind);
+    let path = format!("{http_origin}/v2/block_proposal");
+
+    for (test_description, block_proposal, expected_response) in test_cases {
+        eprintln!("test_block_proposal(): {test_description}");
+        eprintln!("{block_proposal:?}");
+
+        // Send POST request
+        let response = client
+            .post(&path)
+            .header("Content-Type", "application/json")
+            .json(&block_proposal)
+            .send()
+            .expect("Failed to POST");
+
+        eprintln!("{response:?}");
+        assert_eq!(response.status().as_u16(), expected_response);
+    }
+
+    // Clean up
+    coord_channel
+        .lock()
+        .expect("Mutex poisoned")
+        .stop_chains_coordinator();
+    run_loop_stopper.store(false, Ordering::SeqCst);
+
+    run_loop_thread.join().unwrap();
+}
diff --git a/testnet/stacks-node/src/tests/neon_integrations.rs b/testnet/stacks-node/src/tests/neon_integrations.rs
index f5e6d91fbf..b9de6d1d6d 100644
--- a/testnet/stacks-node/src/tests/neon_integrations.rs
+++ b/testnet/stacks-node/src/tests/neon_integrations.rs
@@ -66,14 +66,13 @@ use super::bitcoin_regtest::BitcoinCoreController;
 use super::{
     make_contract_call, make_contract_publish, make_contract_publish_microblock_only,
     make_microblock, make_stacks_transfer, make_stacks_transfer_mblock_only, to_addr, ADDR_4, SK_1,
-    SK_2,
+    SK_2, SK_3,
 };
 use crate::burnchains::bitcoin_regtest_controller::{self, BitcoinRPCRequest, UTXO};
 use crate::config::{EventKeyType, EventObserverConfig, FeeEstimatorName, InitialBalance};
 use crate::operations::BurnchainOpSigner;
 use crate::stacks_common::types::PrivateKey;
 use crate::syncctl::PoxSyncWatchdogComms;
-use crate::tests::SK_3;
 use crate::util::hash::{MerkleTree, Sha512Trunc256Sum};
 use crate::util::secp256k1::MessageSignature;
 use crate::{neon, BitcoinRegtestController, BurnchainController, Config, ConfigFile, Keychain};
@@ -742,39 +741,24 @@ pub fn get_block(http_origin: &str, block_id: &StacksBlockId) -> Option<StacksBl
     }
 }
 
-pub fn get_chain_info(conf: &Config) -> RPCPeerInfoData {
+pub fn get_chain_info_result(conf: &Config) -> Result<RPCPeerInfoData, reqwest::Error> {
     let http_origin = format!("http://{}", &conf.node.rpc_bind);
     let client = reqwest::blocking::Client::new();
 
     // get the canonical chain tip
-    let path = format!("{}/v2/info", &http_origin);
-    let tip_info = client
-        .get(&path)
-        .send()
-        .unwrap()
-        .json::<RPCPeerInfoData>()
-        .unwrap();
-
-    tip_info
+    let path = format!("{http_origin}/v2/info");
+    client.get(&path).send().unwrap().json::<RPCPeerInfoData>()
 }
 
 pub fn get_chain_info_opt(conf: &Config) -> Option<RPCPeerInfoData> {
-    let http_origin = format!("http://{}", &conf.node.rpc_bind);
-    let client = reqwest::blocking::Client::new();
-
-    // get the canonical chain tip
-    let path = format!("{}/v2/info", &http_origin);
-    let tip_info_opt = client
-        .get(&path)
-        .send()
-        .unwrap()
-        .json::<RPCPeerInfoData>()
-        .ok();
+    get_chain_info_result(conf).ok()
+}
 
-    tip_info_opt
+pub fn get_chain_info(conf: &Config) -> RPCPeerInfoData {
+    get_chain_info_result(conf).unwrap()
 }
 
-fn get_tip_anchored_block(conf: &Config) -> (ConsensusHash, StacksBlock) {
+pub fn get_tip_anchored_block(conf: &Config) -> (ConsensusHash, StacksBlock) {
     let tip_info = get_chain_info(conf);
 
     // get the canonical chain tip

From 9d5fe9f7ef1d298b5b7413148fe0d6edd541cb90 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Thu, 21 Dec 2023 12:23:31 -0500
Subject: [PATCH 0292/1166] Add a couple test cases

---
 stackslib/src/chainstate/nakamoto/miner.rs    | 14 +--
 .../src/tests/nakamoto_integrations.rs        | 88 +++++++++++++------
 2 files changed, 63 insertions(+), 39 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/miner.rs b/stackslib/src/chainstate/nakamoto/miner.rs
index ee30337a13..34381bff60 100644
--- a/stackslib/src/chainstate/nakamoto/miner.rs
+++ b/stackslib/src/chainstate/nakamoto/miner.rs
@@ -504,16 +504,6 @@ impl NakamotoBlockBuilder {
     pub fn get_bytes_so_far(&self) -> u64 {
         self.bytes_so_far
     }
-
-    /// Add tx to block with no safety checks
-    /// For testing purposes only
-    ///
-    /// FIXME: Why does this not work in `nakamoto_integrations.rs` with `#[cfg(test)]`
-    //#[cfg(test)]
-    pub fn mine_tx_no_checks(&mut self, tx: StacksTransaction) {
-        self.bytes_so_far += tx.tx_len();
-        self.txs.push(tx)
-    }
 }
 
 impl BlockBuilder for NakamotoBlockBuilder {
@@ -861,8 +851,8 @@ impl NakamotoBlockProposal {
                 "reason" => "Block hash is not as expected",
                 "expected_block_header_hash" => %expected_block_header_hash,
                 "computed_block_header_hash" => %computed_block_header_hash,
-                "expected_block" => %serde_json::to_string(&serde_json::to_value(&self.block).unwrap()).unwrap(),
-                "computed_block" => %serde_json::to_string(&serde_json::to_value(&block).unwrap()).unwrap(),
+                //"expected_block" => %serde_json::to_string(&serde_json::to_value(&self.block).unwrap()).unwrap(),
+                //"computed_block" => %serde_json::to_string(&serde_json::to_value(&block).unwrap()).unwrap(),
             );
             return Err(BlockValidateReject {
                 reason: "Block hash is not as expected".into(),
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 8d45251bf9..eb3b45ef10 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -127,26 +127,26 @@ lazy_static! {
     ];
 }
 
-pub fn add_initial_balances(conf: &mut Config, accounts: usize) -> Vec<StacksPrivateKey> {
+pub fn add_initial_balances(
+    conf: &mut Config,
+    accounts: usize,
+    amount: u64,
+) -> Vec<StacksPrivateKey> {
     (0..accounts)
         .map(|i| {
             let privk = StacksPrivateKey::from_seed(&[5, 5, 5, i as u8]);
+            let address = to_addr(&privk).into();
 
-            conf.initial_balances.push(InitialBalance {
-                address: to_addr(&privk).into(),
-                amount: 100000,
-            });
+            conf.initial_balances
+                .push(InitialBalance { address, amount });
             privk
         })
         .collect()
 }
 
 /// Return a working nakamoto-neon config and the miner's bitcoin address to fund
-pub fn naka_neon_integration_conf(
-    seed: Option<&[u8]>,
-) -> (Config, StacksAddress, Vec<StacksPrivateKey>) {
+pub fn naka_neon_integration_conf(seed: Option<&[u8]>) -> (Config, StacksAddress) {
     let mut conf = super::new_test_conf();
-    let account_keys = add_initial_balances(&mut conf, 10);
 
     conf.burnchain.mode = "nakamoto-neon".into();
 
@@ -204,7 +204,7 @@ pub fn naka_neon_integration_conf(
     conf.burnchain.pox_prepare_length = Some(5);
     conf.burnchain.pox_reward_length = Some(20);
 
-    (conf, miner_account, account_keys)
+    (conf, miner_account)
 }
 
 pub fn next_block_and<F>(
@@ -395,7 +395,7 @@ fn simple_neon_integration() {
         return;
     }
 
-    let (mut naka_conf, _miner_account, _account_keys) = naka_neon_integration_conf(None);
+    let (mut naka_conf, _miner_account) = naka_neon_integration_conf(None);
     let prom_bind = format!("{}:{}", "127.0.0.1", 6000);
     naka_conf.node.prometheus_bind = Some(prom_bind.clone());
     naka_conf.miner.wait_on_interim_blocks = Duration::from_secs(1000);
@@ -610,7 +610,7 @@ fn mine_multiple_per_tenure_integration() {
         return;
     }
 
-    let (mut naka_conf, _miner_account, _account_keys) = naka_neon_integration_conf(None);
+    let (mut naka_conf, _miner_account) = naka_neon_integration_conf(None);
     let http_origin = format!("http://{}", &naka_conf.node.rpc_bind);
     naka_conf.miner.wait_on_interim_blocks = Duration::from_secs(1);
     let sender_sk = Secp256k1PrivateKey::new();
@@ -975,6 +975,9 @@ fn correct_burn_outs() {
 ///
 /// This endpoint allows miners to propose Nakamoto blocks to a node,
 /// and test if they would be accepted or rejected
+///
+/// Notes:
+/// - The `tenure_start_block` supplied doesn't seem to matter. It is required by `NakamotoBlockBuilder` but not used/checked?
 #[test]
 #[ignore]
 fn block_proposal_api_endpoint() {
@@ -982,17 +985,8 @@ fn block_proposal_api_endpoint() {
         return;
     }
 
-    let (mut conf, _miner_account, account_keys) = naka_neon_integration_conf(None);
-    let sender_sk = Secp256k1PrivateKey::new();
-    // setup sender + recipient for a test stx transfer
-    let sender_addr = tests::to_addr(&sender_sk);
-    let send_amt = 1000;
-    let send_fee = 100;
-    conf.add_initial_balance(
-        PrincipalData::from(sender_addr.clone()).to_string(),
-        send_amt + send_fee,
-    );
-    let _recipient = PrincipalData::from(StacksAddress::burn_address(false));
+    let (mut conf, _miner_account) = naka_neon_integration_conf(None);
+    let account_keys = add_initial_balances(&mut conf, 10, 1000000);
     let stacker_sk = setup_stacker(&mut conf);
 
     test_observer::spawn();
@@ -1088,7 +1082,7 @@ fn block_proposal_api_endpoint() {
 
     let privk = conf.miner.mining_key.unwrap().clone();
     let parent_block_id = tip.index_block_hash();
-    // TODO
+    // TODO: Get current `total_burn` from somewhere
     let total_burn = 640000;
     let tenure_change = None;
     let coinbase = None;
@@ -1108,7 +1102,6 @@ fn block_proposal_api_endpoint() {
         p
     };
 
-    // Put block builder in code block so any database locks expire at the end
     let block = {
         let mut builder = NakamotoBlockBuilder::new(
             &tip,
@@ -1162,9 +1155,50 @@ fn block_proposal_api_endpoint() {
 
     const HTTP_ACCEPTED: u16 = 202;
     const HTTP_BADREQUEST: u16 = 400;
+    // TODO: Check error codes?
     let test_cases = [
-        ("No signature", proposal.clone(), HTTP_BADREQUEST),
-        ("Signed", sign(proposal.clone()), HTTP_ACCEPTED),
+        (
+            "Valid Nakamoto block proposal",
+            sign(proposal.clone()),
+            HTTP_ACCEPTED,
+        ),
+        (
+            "Corrupted (bit flipped after signing)",
+            (|| {
+                let mut sp = sign(proposal.clone());
+                sp.block.header.consensus_hash.0[3] ^= 0x07;
+                sp
+            })(),
+            HTTP_BADREQUEST,
+        ),
+        (
+            "`total_burn` too low",
+            (|| {
+                let mut p = proposal.clone();
+                p.total_burn -= 100;
+                sign(p)
+            })(),
+            HTTP_BADREQUEST,
+        ),
+        (
+            "`total_burn` too high",
+            (|| {
+                let mut p = proposal.clone();
+                p.total_burn += 100;
+                sign(p)
+            })(),
+            HTTP_BADREQUEST,
+        ),
+        (
+            // FIXME: Why does `NakamotoBlockBuilder` not check this?
+            "Invalid `tenure_start_block`",
+            (|| {
+                let mut p = proposal.clone();
+                p.tenure_start_block.0[8] ^= 0x55;
+                sign(p)
+            })(),
+            HTTP_ACCEPTED,
+        ),
     ];
 
     // Build HTTP client

From 28ae1679fd31b10b63ec88365fea670e565c0a8b Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Thu, 21 Dec 2023 12:39:11 -0500
Subject: [PATCH 0293/1166] Remove `total_burn` from `NakamotoBlockProposal`

---
 docs/rpc-endpoints.md                         |  4 +---
 docs/rpc/openapi.yaml                         |  6 ------
 stackslib/src/chainstate/nakamoto/miner.rs    |  8 ++------
 .../src/tests/nakamoto_integrations.rs        | 19 -------------------
 4 files changed, 3 insertions(+), 34 deletions(-)

diff --git a/docs/rpc-endpoints.md b/docs/rpc-endpoints.md
index 82abf05627..59e3ba2234 100644
--- a/docs/rpc-endpoints.md
+++ b/docs/rpc-endpoints.md
@@ -491,7 +491,5 @@ pub struct NakamotoBlockProposal {
     pub tenure_start_block: StacksBlockId,
     /// Identifies which chain block is for (Mainnet, Testnet, etc.)
     pub chain_id: u32,
-    /// total BTC burn so far
-    pub total_burn: u64,
 }
-```
\ No newline at end of file
+```
diff --git a/docs/rpc/openapi.yaml b/docs/rpc/openapi.yaml
index 51fe3444e1..cf7c741c09 100644
--- a/docs/rpc/openapi.yaml
+++ b/docs/rpc/openapi.yaml
@@ -589,9 +589,3 @@ paths:
           description: 'Identifies which chain block is for (Mainnet, Testnet, etc.)'
           schema:
             type: integer
-        - name: total_burn
-          in: query
-          required: true
-          description: 'Total BTC burn so far'
-          schema:
-            type: integer
\ No newline at end of file
diff --git a/stackslib/src/chainstate/nakamoto/miner.rs b/stackslib/src/chainstate/nakamoto/miner.rs
index 34381bff60..7d92bb32cf 100644
--- a/stackslib/src/chainstate/nakamoto/miner.rs
+++ b/stackslib/src/chainstate/nakamoto/miner.rs
@@ -699,16 +699,13 @@ pub struct NakamotoBlockProposal {
     pub tenure_start_block: StacksBlockId,
     /// Identifies which chain block is for (Mainnet, Testnet, etc.)
     pub chain_id: u32,
-    /// total BTC burn so far
-    pub total_burn: u64,
 }
 
 impl StacksMessageCodec for NakamotoBlockProposal {
     fn consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), CodecError> {
         write_next(fd, &self.block)?;
         write_next(fd, &self.tenure_start_block)?;
-        write_next(fd, &self.chain_id)?;
-        write_next(fd, &self.total_burn)
+        write_next(fd, &self.chain_id)
     }
 
     fn consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, CodecError> {
@@ -716,7 +713,6 @@ impl StacksMessageCodec for NakamotoBlockProposal {
             block: read_next(fd)?,
             tenure_start_block: read_next(fd)?,
             chain_id: read_next(fd)?,
-            total_burn: read_next(fd)?,
         })
     }
 }
@@ -791,7 +787,7 @@ impl NakamotoBlockProposal {
         let mut builder = NakamotoBlockBuilder::new(
             &parent_stacks_header,
             &self.block.header.consensus_hash,
-            self.total_burn,
+            self.block.header.burn_spent,
             tenure_change,
             coinbase,
         )?;
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index eb3b45ef10..88cf765d31 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -1150,7 +1150,6 @@ fn block_proposal_api_endpoint() {
         block,
         tenure_start_block: parent_block_id,
         chain_id: chainstate.chain_id,
-        total_burn,
     };
 
     const HTTP_ACCEPTED: u16 = 202;
@@ -1171,24 +1170,6 @@ fn block_proposal_api_endpoint() {
             })(),
             HTTP_BADREQUEST,
         ),
-        (
-            "`total_burn` too low",
-            (|| {
-                let mut p = proposal.clone();
-                p.total_burn -= 100;
-                sign(p)
-            })(),
-            HTTP_BADREQUEST,
-        ),
-        (
-            "`total_burn` too high",
-            (|| {
-                let mut p = proposal.clone();
-                p.total_burn += 100;
-                sign(p)
-            })(),
-            HTTP_BADREQUEST,
-        ),
         (
             // FIXME: Why does `NakamotoBlockBuilder` not check this?
             "Invalid `tenure_start_block`",

From 73eac46279c71beb6acd18ac0ef6bb8c210bfaf1 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Fri, 22 Dec 2023 17:06:12 -0500
Subject: [PATCH 0294/1166] chore: Address a couple PR comments

---
 stackslib/src/chainstate/stacks/boot/pox_4_tests.rs    | 4 ++--
 stackslib/src/net/api/postblock_proposal.rs            | 8 ++++----
 testnet/stacks-node/src/tests/nakamoto_integrations.rs | 1 -
 3 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 1051a97e0f..779b8e6434 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -507,7 +507,7 @@ fn pox_extend_transition() {
     for cycle_number in first_v4_cycle..(first_v4_cycle + 4) {
         let cycle_start = burnchain.reward_cycle_to_block_height(cycle_number);
         let reward_set_entries = get_reward_set_entries_at(&mut peer, &latest_block, cycle_start);
-        //info!("----- {cycle_number} -----");
+
         assert_eq!(reward_set_entries.len(), 1);
         assert_eq!(
             reward_set_entries[0].reward_address.bytes(),
@@ -607,7 +607,7 @@ fn pox_extend_transition() {
     for cycle_number in (first_v4_cycle + 4)..(first_v4_cycle + 10) {
         let cycle_start = burnchain.reward_cycle_to_block_height(cycle_number);
         let reward_set_entries = get_reward_set_entries_at(&mut peer, &latest_block, cycle_start);
-        info!("----- {cycle_number} -----");
+
         assert_eq!(reward_set_entries.len(), 1);
         assert_eq!(
             reward_set_entries[0].reward_address.bytes(),
diff --git a/stackslib/src/net/api/postblock_proposal.rs b/stackslib/src/net/api/postblock_proposal.rs
index 345b3ccde6..d856ee2d8e 100644
--- a/stackslib/src/net/api/postblock_proposal.rs
+++ b/stackslib/src/net/api/postblock_proposal.rs
@@ -67,7 +67,7 @@ impl RPCBlockProposalRequestHandler {
     }
 
     /// Decode a bare transaction from the body
-    fn parse_posttransaction_octets(mut body: &[u8]) -> Result<NakamotoBlockProposal, Error> {
+    fn parse_octets(mut body: &[u8]) -> Result<NakamotoBlockProposal, Error> {
         NakamotoBlockProposal::consensus_deserialize(&mut body).map_err(|e| match e {
             CodecError::DeserializeError(msg) => {
                 Error::DecodeError(format!("Failed to deserialize posted transaction: {msg}"))
@@ -77,7 +77,7 @@ impl RPCBlockProposalRequestHandler {
     }
 
     /// Decode a JSON-encoded transaction
-    fn parse_posttransaction_json(body: &[u8]) -> Result<NakamotoBlockProposal, Error> {
+    fn parse_json(body: &[u8]) -> Result<NakamotoBlockProposal, Error> {
         serde_json::from_slice(body).map_err(|_| Error::DecodeError("Failed to parse body".into()))
     }
 }
@@ -125,8 +125,8 @@ impl HttpRequest for RPCBlockProposalRequestHandler {
         }
 
         let block_proposal = match preamble.content_type {
-            Some(HttpContentType::Bytes) => Self::parse_posttransaction_octets(body)?,
-            Some(HttpContentType::JSON) => Self::parse_posttransaction_json(body)?,
+            Some(HttpContentType::Bytes) => Self::parse_octets(body)?,
+            Some(HttpContentType::JSON) => Self::parse_json(body)?,
             None => {
                 return Err(Error::DecodeError(
                     "Missing Content-Type for transaction".to_string(),
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 88cf765d31..00be5cad0f 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -22,7 +22,6 @@ use clarity::vm::ast::ASTRules;
 use clarity::vm::costs::ExecutionCost;
 use clarity::vm::types::PrincipalData;
 use lazy_static::lazy_static;
-//use stacks::burnchains::tests::TestMinerFactory;
 use stacks::burnchains::MagicBytes;
 use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::coordinator::comm::CoordinatorChannels;

From 28fb11c001f7c907bedcae65f88c93e288a6e6b8 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Tue, 26 Dec 2023 10:45:39 -0500
Subject: [PATCH 0295/1166] chore: Replace hardcoded `total_burn` value

---
 .../stacks-node/src/tests/nakamoto_integrations.rs | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 00be5cad0f..d16b215060 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -1082,7 +1082,19 @@ fn block_proposal_api_endpoint() {
     let privk = conf.miner.mining_key.unwrap().clone();
     let parent_block_id = tip.index_block_hash();
     // TODO: Get current `total_burn` from somewhere
-    let total_burn = 640000;
+    let sort_tip = SortitionDB::get_canonical_sortition_tip(sortdb.conn())
+        .expect("Failed to get sortition tip");
+    let db_handle = sortdb.index_handle(&sort_tip);
+    let snapshot = db_handle
+        .get_block_snapshot(&tip.burn_header_hash)
+        .expect("Failed to get block snapshot")
+        .expect("No snapshot");
+    // Double check we got the right sortition
+    assert_eq!(
+        snapshot.consensus_hash, tip.consensus_hash,
+        "Found incorrect block snapshot"
+    );
+    let total_burn = snapshot.total_burn;
     let tenure_change = None;
     let coinbase = None;
 

From ddb5e0b2b8405e89aad2e1a1d1b191728d849050 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Tue, 26 Dec 2023 13:52:40 -0500
Subject: [PATCH 0296/1166] docs: Add JSON schema for `/v2/block_proposal`

---
 .../post-block-proposal-response.error.json   | 17 +++++++++++++++
 .../post-block-proposal-response.schema.json  | 21 +++++++++++++++++++
 docs/rpc/openapi.yaml                         | 18 +++++++++++++++-
 3 files changed, 55 insertions(+), 1 deletion(-)
 create mode 100644 docs/rpc/api/core-node/post-block-proposal-response.error.json
 create mode 100644 docs/rpc/api/core-node/post-block-proposal-response.schema.json

diff --git a/docs/rpc/api/core-node/post-block-proposal-response.error.json b/docs/rpc/api/core-node/post-block-proposal-response.error.json
new file mode 100644
index 0000000000..6f463e5492
--- /dev/null
+++ b/docs/rpc/api/core-node/post-block-proposal-response.error.json
@@ -0,0 +1,17 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "description": "Returned on successful POST to /v2/block_proposal",
+  "title": "PostCoreNodeBlockProposalError",
+  "type": "object",
+  "required": ["reason", "reason_code"],
+  "properties": {
+    "reason": {
+      "type": "string",
+      "description": "Error description"
+    },
+    "reason_code": {
+      "type": "string",
+      "description": "String representation of error code enum"
+    }
+  }
+}
diff --git a/docs/rpc/api/core-node/post-block-proposal-response.schema.json b/docs/rpc/api/core-node/post-block-proposal-response.schema.json
new file mode 100644
index 0000000000..d997a3c0a3
--- /dev/null
+++ b/docs/rpc/api/core-node/post-block-proposal-response.schema.json
@@ -0,0 +1,21 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "description": "Returned on successful POST to /v2/block_proposal",
+  "title": "PostCoreNodeBlockProposalResponse",
+  "type": "object",
+  "required": ["block", "cost", "size"],
+  "properties": {
+    "block": {
+      "type": "object",
+      "description": "Nakamoto block"
+    },
+    "cost": {
+      "type": "object",
+      "description": "Total execution costs for transactions in the block"
+    },
+    "size": {
+      "type": "integer",
+      "description": "Size of block in bytes"
+    }
+  }
+}
diff --git a/docs/rpc/openapi.yaml b/docs/rpc/openapi.yaml
index cf7c741c09..fa690a26a6 100644
--- a/docs/rpc/openapi.yaml
+++ b/docs/rpc/openapi.yaml
@@ -566,12 +566,28 @@ paths:
       responses:
         202:
           description: Block proposal is valid
+          content:
+            application/json:
+              schema:
+                $ref: ./api/core-node/post-block-proposal-response.schema.json
         400:
-          description: Bad request
+          description: Block proposal not valid
+          content:
+            application/json:
+              schema:
+                $ref: ./api/core-node/post-block-proposal-error.schema.json
         403:
           description: Request not over loopback interface
+          content:
+            application/json:
+              schema:
+                $ref: ./api/core-node/post-block-proposal-error.schema.json
         429:
           description: Too many requests
+          content:
+            application/json:
+              schema:
+                $ref: ./api/core-node/post-block-proposal-error.schema.json
       parameters:
         - name: block
           in: query

From 628178222ab72753d6ceedd354bc1dc274798d5b Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Thu, 28 Dec 2023 20:13:46 -0500
Subject: [PATCH 0297/1166] Move `NakamotoBlockProposal` into
 postblock_proposal.rs

---
 stackslib/src/chainstate/nakamoto/miner.rs    | 252 +----------------
 stackslib/src/net/api/postblock_proposal.rs   | 259 +++++++++++++++++-
 .../src/tests/nakamoto_integrations.rs        |   3 +-
 3 files changed, 259 insertions(+), 255 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/miner.rs b/stackslib/src/chainstate/nakamoto/miner.rs
index 7d92bb32cf..346b2a1ef8 100644
--- a/stackslib/src/chainstate/nakamoto/miner.rs
+++ b/stackslib/src/chainstate/nakamoto/miner.rs
@@ -30,9 +30,6 @@ use clarity::vm::database::BurnStateDB;
 use clarity::vm::errors::Error as InterpreterError;
 use clarity::vm::types::TypeSignature;
 use serde::Deserialize;
-use stacks_common::codec::{
-    read_next, write_next, Error as CodecError, StacksMessageCodec, MAX_PAYLOAD_LEN,
-};
 use stacks_common::types::chainstate::{
     BlockHeaderHash, BurnchainHeaderHash, ConsensusHash, StacksAddress, StacksBlockId, TrieHash,
 };
@@ -65,6 +62,7 @@ use crate::chainstate::stacks::miner::{
 };
 use crate::chainstate::stacks::{Error, StacksBlockHeader, *};
 use crate::clarity_vm::clarity::{ClarityConnection, ClarityInstance};
+use crate::codec::Error as CodecError;
 use crate::core::mempool::*;
 use crate::core::*;
 use crate::cost_estimates::metrics::CostMetric;
@@ -625,251 +623,3 @@ impl BlockBuilder for NakamotoBlockBuilder {
         result
     }
 }
-
-/// This enum is used to supply a `reason_code` for validation
-///  rejection responses. This is serialized as an enum with string
-///  type (in jsonschema terminology).
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub enum ValidateRejectCode {
-    BadBlockHash,
-    BadTransaction,
-    InvalidBlock,
-    ChainstateError,
-    UnknownParent,
-}
-
-/// A response for block proposal validation
-///  that the stacks-node thinks should be rejected.
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct BlockValidateReject {
-    pub reason: String,
-    pub reason_code: ValidateRejectCode,
-}
-
-/// A response for block proposal validation
-///  that the stacks-node thinks is acceptable.
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct BlockValidateOk {
-    pub block: NakamotoBlock,
-    pub cost: ExecutionCost,
-    pub size: u64,
-}
-
-/// This enum is used for serializing the response to block
-/// proposal validation.
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(tag = "Result")]
-pub enum BlockValidateResponse {
-    Ok(BlockValidateOk),
-    Reject(BlockValidateReject),
-}
-
-impl From<Result<BlockValidateOk, BlockValidateReject>> for BlockValidateResponse {
-    fn from(value: Result<BlockValidateOk, BlockValidateReject>) -> Self {
-        match value {
-            Ok(o) => BlockValidateResponse::Ok(o),
-            Err(e) => BlockValidateResponse::Reject(e),
-        }
-    }
-}
-
-impl From<Error> for BlockValidateReject {
-    fn from(value: Error) -> Self {
-        BlockValidateReject {
-            reason: format!("Chainstate Error: {value}"),
-            reason_code: ValidateRejectCode::ChainstateError,
-        }
-    }
-}
-
-impl From<DBError> for BlockValidateReject {
-    fn from(value: DBError) -> Self {
-        Error::from(value).into()
-    }
-}
-
-/// Represents a block proposed to the `v2/block_proposal` endpoint for validation
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct NakamotoBlockProposal {
-    /// Proposed block
-    pub block: NakamotoBlock,
-    // tenure ID -- this is the index block hash of the start block of the last tenure (i.e.
-    // the data we committed to in the block-commit).  If this is an epoch 2.x parent, then
-    // this is just the index block hash of the parent Stacks block.
-    pub tenure_start_block: StacksBlockId,
-    /// Identifies which chain block is for (Mainnet, Testnet, etc.)
-    pub chain_id: u32,
-}
-
-impl StacksMessageCodec for NakamotoBlockProposal {
-    fn consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), CodecError> {
-        write_next(fd, &self.block)?;
-        write_next(fd, &self.tenure_start_block)?;
-        write_next(fd, &self.chain_id)
-    }
-
-    fn consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, CodecError> {
-        Ok(Self {
-            block: read_next(fd)?,
-            tenure_start_block: read_next(fd)?,
-            chain_id: read_next(fd)?,
-        })
-    }
-}
-
-impl NakamotoBlockProposal {
-    /// Test this block proposal against the current chain state and
-    /// either accept or reject the proposal
-    ///
-    /// This is done in 2 steps:
-    /// - Static validation of the block, which checks the following:
-    ///   - Block is well-formed
-    ///   - Transactions are well-formed
-    ///   - Miner signature is valid
-    /// - Validation of transactions by executing them agains current chainstate.
-    ///   This is resource intensive, and therefore done only if previous checks pass
-    pub fn validate(
-        &self,
-        sortdb: &SortitionDB,
-        chainstate: &mut StacksChainState, // not directly used; used as a handle to open other chainstates
-    ) -> Result<BlockValidateOk, BlockValidateReject> {
-        let ts_start = get_epoch_time_ms();
-        // Measure time from start of function
-        let time_elapsed = || get_epoch_time_ms().saturating_sub(ts_start);
-
-        let mainnet = self.chain_id == CHAIN_ID_MAINNET;
-        if self.chain_id != chainstate.chain_id || mainnet != chainstate.mainnet {
-            return Err(BlockValidateReject {
-                reason_code: ValidateRejectCode::InvalidBlock,
-                reason: "Wrong netowrk/chain_id".into(),
-            });
-        }
-
-        let burn_dbconn = sortdb.index_conn();
-        let sort_tip = SortitionDB::get_canonical_sortition_tip(sortdb.conn())?;
-        let mut db_handle = sortdb.index_handle(&sort_tip);
-        let expected_burn =
-            NakamotoChainState::get_expected_burns(&mut db_handle, chainstate.db(), &self.block)?;
-
-        // Static validation checks
-        NakamotoChainState::validate_nakamoto_block_burnchain(
-            &db_handle,
-            expected_burn,
-            &self.block,
-            mainnet,
-            self.chain_id,
-        )?;
-
-        // Validate block txs against chainstate
-        let parent_stacks_header = NakamotoChainState::get_block_header(
-            chainstate.db(),
-            &self.block.header.parent_block_id,
-        )?
-        .ok_or_else(|| BlockValidateReject {
-            reason_code: ValidateRejectCode::InvalidBlock,
-            reason: "Invalid parent block".into(),
-        })?;
-        let tenure_change = self
-            .block
-            .txs
-            .iter()
-            .find(|tx| matches!(tx.payload, TransactionPayload::TenureChange(..)));
-        let coinbase = self
-            .block
-            .txs
-            .iter()
-            .find(|tx| matches!(tx.payload, TransactionPayload::Coinbase(..)));
-        let tenure_cause = tenure_change.and_then(|tx| match &tx.payload {
-            TransactionPayload::TenureChange(tc) => Some(tc.cause),
-            _ => None,
-        });
-
-        let mut builder = NakamotoBlockBuilder::new(
-            &parent_stacks_header,
-            &self.block.header.consensus_hash,
-            self.block.header.burn_spent,
-            tenure_change,
-            coinbase,
-        )?;
-
-        let mut miner_tenure_info =
-            builder.load_tenure_info(chainstate, &burn_dbconn, tenure_cause)?;
-        let mut tenure_tx = builder.tenure_begin(&burn_dbconn, &mut miner_tenure_info)?;
-
-        for (i, tx) in self.block.txs.iter().enumerate() {
-            let tx_len = tx.tx_len();
-            let tx_result = builder.try_mine_tx_with_len(
-                &mut tenure_tx,
-                &tx,
-                tx_len,
-                &BlockLimitFunction::NO_LIMIT_HIT,
-                ASTRules::PrecheckSize,
-            );
-            let err = match tx_result {
-                TransactionResult::Success(_) => Ok(()),
-                TransactionResult::Skipped(s) => Err(format!("tx {i} skipped: {}", s.error)),
-                TransactionResult::ProcessingError(e) => {
-                    Err(format!("Error processing tx {i}: {}", e.error))
-                }
-                TransactionResult::Problematic(p) => {
-                    Err(format!("Problematic tx {i}: {}", p.error))
-                }
-            };
-            if let Err(reason) = err {
-                warn!(
-                    "Rejected block proposal";
-                    "reason" => %reason,
-                    "tx" => ?tx,
-                );
-                return Err(BlockValidateReject {
-                    reason,
-                    reason_code: ValidateRejectCode::BadTransaction,
-                });
-            }
-        }
-
-        let mut block = builder.mine_nakamoto_block(&mut tenure_tx);
-        let size = builder.get_bytes_so_far();
-        let cost = builder.tenure_finish(tenure_tx);
-
-        // Clone signatures from block proposal
-        // These have already been validated by `validate_nakamoto_block_burnchain()``
-        block.header.miner_signature = self.block.header.miner_signature.clone();
-        block.header.signer_signature = self.block.header.signer_signature.clone();
-
-        // Assuming `tx_nerkle_root` has been checked we don't need to hash the whole block
-        let expected_block_header_hash = self.block.header.block_hash();
-        let computed_block_header_hash = block.header.block_hash();
-
-        if computed_block_header_hash != expected_block_header_hash {
-            warn!(
-                "Rejected block proposal";
-                "reason" => "Block hash is not as expected",
-                "expected_block_header_hash" => %expected_block_header_hash,
-                "computed_block_header_hash" => %computed_block_header_hash,
-                //"expected_block" => %serde_json::to_string(&serde_json::to_value(&self.block).unwrap()).unwrap(),
-                //"computed_block" => %serde_json::to_string(&serde_json::to_value(&block).unwrap()).unwrap(),
-            );
-            return Err(BlockValidateReject {
-                reason: "Block hash is not as expected".into(),
-                reason_code: ValidateRejectCode::BadBlockHash,
-            });
-        }
-
-        info!(
-            "Participant: validated anchored block";
-            "block_header_hash" => %computed_block_header_hash,
-            "height" => block.header.chain_length,
-            "tx_count" => block.txs.len(),
-            "parent_stacks_block_id" => %block.header.parent_block_id,
-            "block_size" => size,
-            "execution_cost" => %cost,
-            "validation_time_ms" => time_elapsed(),
-            "tx_fees_microstacks" => block.txs.iter().fold(0, |agg: u64, tx| {
-                agg.saturating_add(tx.get_tx_fee())
-            })
-        );
-
-        Ok(BlockValidateOk { block, cost, size })
-    }
-}
diff --git a/stackslib/src/net/api/postblock_proposal.rs b/stackslib/src/net/api/postblock_proposal.rs
index d856ee2d8e..ba401c8629 100644
--- a/stackslib/src/net/api/postblock_proposal.rs
+++ b/stackslib/src/net/api/postblock_proposal.rs
@@ -16,28 +16,32 @@
 
 use std::io::{Read, Write};
 
+use clarity::vm::ast::ASTRules;
 use clarity::vm::costs::ExecutionCost;
 use regex::{Captures, Regex};
 use stacks_common::codec::{
     read_next, write_next, Error as CodecError, StacksMessageCodec, MAX_PAYLOAD_LEN,
 };
+use stacks_common::consts::CHAIN_ID_MAINNET;
 use stacks_common::types::chainstate::{
     BlockHeaderHash, BurnchainHeaderHash, ConsensusHash, StacksBlockId, StacksPublicKey,
 };
 use stacks_common::types::net::PeerHost;
 use stacks_common::types::StacksPublicKeyBuffer;
+use stacks_common::util::get_epoch_time_ms;
 use stacks_common::util::hash::{hex_bytes, Hash160, Sha256Sum};
 use stacks_common::util::retry::BoundReader;
 
 use crate::burnchains::affirmation::AffirmationMap;
 use crate::burnchains::Txid;
 use crate::chainstate::burn::db::sortdb::SortitionDB;
-use crate::chainstate::nakamoto::miner::{BlockValidateResponse, NakamotoBlockProposal};
-use crate::chainstate::nakamoto::NakamotoBlock;
+use crate::chainstate::nakamoto::miner::NakamotoBlockBuilder;
+use crate::chainstate::nakamoto::{NakamotoBlock, NakamotoChainState};
 use crate::chainstate::stacks::db::blocks::MINIMUM_TX_FEE_RATE_PER_BYTE;
 use crate::chainstate::stacks::db::StacksChainState;
+use crate::chainstate::stacks::miner::{BlockBuilder, BlockLimitFunction, TransactionResult};
 use crate::chainstate::stacks::{
-    StacksBlock, StacksBlockHeader, StacksTransaction, TransactionPayload,
+    Error as ChainError, StacksBlock, StacksBlockHeader, StacksTransaction, TransactionPayload,
 };
 use crate::core::mempool::MemPoolDB;
 use crate::cost_estimates::FeeRateEstimate;
@@ -55,6 +59,255 @@ use crate::net::relay::Relayer;
 use crate::net::{
     Attachment, BlocksData, BlocksDatum, Error as NetError, StacksMessageType, StacksNodeState,
 };
+use crate::util_lib::db::Error as DBError;
+
+/// This enum is used to supply a `reason_code` for validation
+///  rejection responses. This is serialized as an enum with string
+///  type (in jsonschema terminology).
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub enum ValidateRejectCode {
+    BadBlockHash,
+    BadTransaction,
+    InvalidBlock,
+    ChainstateError,
+    UnknownParent,
+}
+
+/// A response for block proposal validation
+///  that the stacks-node thinks should be rejected.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct BlockValidateReject {
+    pub reason: String,
+    pub reason_code: ValidateRejectCode,
+}
+
+/// A response for block proposal validation
+///  that the stacks-node thinks is acceptable.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct BlockValidateOk {
+    pub block: NakamotoBlock,
+    pub cost: ExecutionCost,
+    pub size: u64,
+}
+
+/// This enum is used for serializing the response to block
+/// proposal validation.
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(tag = "Result")]
+pub enum BlockValidateResponse {
+    Ok(BlockValidateOk),
+    Reject(BlockValidateReject),
+}
+
+impl From<Result<BlockValidateOk, BlockValidateReject>> for BlockValidateResponse {
+    fn from(value: Result<BlockValidateOk, BlockValidateReject>) -> Self {
+        match value {
+            Ok(o) => BlockValidateResponse::Ok(o),
+            Err(e) => BlockValidateResponse::Reject(e),
+        }
+    }
+}
+
+impl From<ChainError> for BlockValidateReject {
+    fn from(value: ChainError) -> Self {
+        BlockValidateReject {
+            reason: format!("Chainstate Error: {value}"),
+            reason_code: ValidateRejectCode::ChainstateError,
+        }
+    }
+}
+
+impl From<DBError> for BlockValidateReject {
+    fn from(value: DBError) -> Self {
+        ChainError::from(value).into()
+    }
+}
+
+/// Represents a block proposed to the `v2/block_proposal` endpoint for validation
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct NakamotoBlockProposal {
+    /// Proposed block
+    pub block: NakamotoBlock,
+    // tenure ID -- this is the index block hash of the start block of the last tenure (i.e.
+    // the data we committed to in the block-commit).  If this is an epoch 2.x parent, then
+    // this is just the index block hash of the parent Stacks block.
+    pub tenure_start_block: StacksBlockId,
+    /// Identifies which chain block is for (Mainnet, Testnet, etc.)
+    pub chain_id: u32,
+}
+
+impl StacksMessageCodec for NakamotoBlockProposal {
+    fn consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), CodecError> {
+        write_next(fd, &self.block)?;
+        write_next(fd, &self.tenure_start_block)?;
+        write_next(fd, &self.chain_id)
+    }
+
+    fn consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, CodecError> {
+        Ok(Self {
+            block: read_next(fd)?,
+            tenure_start_block: read_next(fd)?,
+            chain_id: read_next(fd)?,
+        })
+    }
+}
+
+impl NakamotoBlockProposal {
+    /// Test this block proposal against the current chain state and
+    /// either accept or reject the proposal
+    ///
+    /// This is done in 2 steps:
+    /// - Static validation of the block, which checks the following:
+    ///   - Block is well-formed
+    ///   - Transactions are well-formed
+    ///   - Miner signature is valid
+    /// - Validation of transactions by executing them agains current chainstate.
+    ///   This is resource intensive, and therefore done only if previous checks pass
+    pub fn validate(
+        &self,
+        sortdb: &SortitionDB,
+        chainstate: &mut StacksChainState, // not directly used; used as a handle to open other chainstates
+    ) -> Result<BlockValidateOk, BlockValidateReject> {
+        let ts_start = get_epoch_time_ms();
+        // Measure time from start of function
+        let time_elapsed = || get_epoch_time_ms().saturating_sub(ts_start);
+
+        let mainnet = self.chain_id == CHAIN_ID_MAINNET;
+        if self.chain_id != chainstate.chain_id || mainnet != chainstate.mainnet {
+            return Err(BlockValidateReject {
+                reason_code: ValidateRejectCode::InvalidBlock,
+                reason: "Wrong netowrk/chain_id".into(),
+            });
+        }
+
+        let burn_dbconn = sortdb.index_conn();
+        let sort_tip = SortitionDB::get_canonical_sortition_tip(sortdb.conn())?;
+        let mut db_handle = sortdb.index_handle(&sort_tip);
+        let expected_burn =
+            NakamotoChainState::get_expected_burns(&mut db_handle, chainstate.db(), &self.block)?;
+
+        // Static validation checks
+        NakamotoChainState::validate_nakamoto_block_burnchain(
+            &db_handle,
+            expected_burn,
+            &self.block,
+            mainnet,
+            self.chain_id,
+        )?;
+
+        // Validate block txs against chainstate
+        let parent_stacks_header = NakamotoChainState::get_block_header(
+            chainstate.db(),
+            &self.block.header.parent_block_id,
+        )?
+        .ok_or_else(|| BlockValidateReject {
+            reason_code: ValidateRejectCode::InvalidBlock,
+            reason: "Invalid parent block".into(),
+        })?;
+        let tenure_change = self
+            .block
+            .txs
+            .iter()
+            .find(|tx| matches!(tx.payload, TransactionPayload::TenureChange(..)));
+        let coinbase = self
+            .block
+            .txs
+            .iter()
+            .find(|tx| matches!(tx.payload, TransactionPayload::Coinbase(..)));
+        let tenure_cause = tenure_change.and_then(|tx| match &tx.payload {
+            TransactionPayload::TenureChange(tc) => Some(tc.cause),
+            _ => None,
+        });
+
+        let mut builder = NakamotoBlockBuilder::new(
+            &parent_stacks_header,
+            &self.block.header.consensus_hash,
+            self.block.header.burn_spent,
+            tenure_change,
+            coinbase,
+        )?;
+
+        let mut miner_tenure_info =
+            builder.load_tenure_info(chainstate, &burn_dbconn, tenure_cause)?;
+        let mut tenure_tx = builder.tenure_begin(&burn_dbconn, &mut miner_tenure_info)?;
+
+        for (i, tx) in self.block.txs.iter().enumerate() {
+            let tx_len = tx.tx_len();
+            let tx_result = builder.try_mine_tx_with_len(
+                &mut tenure_tx,
+                &tx,
+                tx_len,
+                &BlockLimitFunction::NO_LIMIT_HIT,
+                ASTRules::PrecheckSize,
+            );
+            let err = match tx_result {
+                TransactionResult::Success(_) => Ok(()),
+                TransactionResult::Skipped(s) => Err(format!("tx {i} skipped: {}", s.error)),
+                TransactionResult::ProcessingError(e) => {
+                    Err(format!("Error processing tx {i}: {}", e.error))
+                }
+                TransactionResult::Problematic(p) => {
+                    Err(format!("Problematic tx {i}: {}", p.error))
+                }
+            };
+            if let Err(reason) = err {
+                warn!(
+                    "Rejected block proposal";
+                    "reason" => %reason,
+                    "tx" => ?tx,
+                );
+                return Err(BlockValidateReject {
+                    reason,
+                    reason_code: ValidateRejectCode::BadTransaction,
+                });
+            }
+        }
+
+        let mut block = builder.mine_nakamoto_block(&mut tenure_tx);
+        let size = builder.get_bytes_so_far();
+        let cost = builder.tenure_finish(tenure_tx);
+
+        // Clone signatures from block proposal
+        // These have already been validated by `validate_nakamoto_block_burnchain()``
+        block.header.miner_signature = self.block.header.miner_signature.clone();
+        block.header.signer_signature = self.block.header.signer_signature.clone();
+
+        // Assuming `tx_nerkle_root` has been checked we don't need to hash the whole block
+        let expected_block_header_hash = self.block.header.block_hash();
+        let computed_block_header_hash = block.header.block_hash();
+
+        if computed_block_header_hash != expected_block_header_hash {
+            warn!(
+                "Rejected block proposal";
+                "reason" => "Block hash is not as expected",
+                "expected_block_header_hash" => %expected_block_header_hash,
+                "computed_block_header_hash" => %computed_block_header_hash,
+                //"expected_block" => %serde_json::to_string(&serde_json::to_value(&self.block).unwrap()).unwrap(),
+                //"computed_block" => %serde_json::to_string(&serde_json::to_value(&block).unwrap()).unwrap(),
+            );
+            return Err(BlockValidateReject {
+                reason: "Block hash is not as expected".into(),
+                reason_code: ValidateRejectCode::BadBlockHash,
+            });
+        }
+
+        info!(
+            "Participant: validated anchored block";
+            "block_header_hash" => %computed_block_header_hash,
+            "height" => block.header.chain_length,
+            "tx_count" => block.txs.len(),
+            "parent_stacks_block_id" => %block.header.parent_block_id,
+            "block_size" => size,
+            "execution_cost" => %cost,
+            "validation_time_ms" => time_elapsed(),
+            "tx_fees_microstacks" => block.txs.iter().fold(0, |agg: u64, tx| {
+                agg.saturating_add(tx.get_tx_fee())
+            })
+        );
+
+        Ok(BlockValidateOk { block, cost, size })
+    }
+}
 
 #[derive(Clone, Default)]
 pub struct RPCBlockProposalRequestHandler {
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index d16b215060..8292f908df 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -25,7 +25,7 @@ use lazy_static::lazy_static;
 use stacks::burnchains::MagicBytes;
 use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::coordinator::comm::CoordinatorChannels;
-use stacks::chainstate::nakamoto::miner::{NakamotoBlockBuilder, NakamotoBlockProposal};
+use stacks::chainstate::nakamoto::miner::NakamotoBlockBuilder;
 use stacks::chainstate::nakamoto::NakamotoChainState;
 use stacks::chainstate::stacks::db::StacksChainState;
 use stacks::chainstate::stacks::miner::{BlockBuilder, BlockLimitFunction, TransactionResult};
@@ -36,6 +36,7 @@ use stacks::core::{
     PEER_VERSION_EPOCH_2_1, PEER_VERSION_EPOCH_2_2, PEER_VERSION_EPOCH_2_3, PEER_VERSION_EPOCH_2_4,
     PEER_VERSION_EPOCH_2_5, PEER_VERSION_EPOCH_3_0,
 };
+use stacks::net::api::postblock_proposal::NakamotoBlockProposal;
 use stacks_common::address::AddressHashMode;
 use stacks_common::codec::StacksMessageCodec;
 use stacks_common::consts::STACKS_EPOCH_MAX;

From 4fda146620c6641b805e4b742fb127a9e083cf8a Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Thu, 28 Dec 2023 20:55:59 -0500
Subject: [PATCH 0298/1166] Remove `decode_stacks_block_proposal_accepted()`

---
 stackslib/src/net/api/postblock_proposal.rs | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/stackslib/src/net/api/postblock_proposal.rs b/stackslib/src/net/api/postblock_proposal.rs
index ba401c8629..2fe98bedcc 100644
--- a/stackslib/src/net/api/postblock_proposal.rs
+++ b/stackslib/src/net/api/postblock_proposal.rs
@@ -465,9 +465,3 @@ impl StacksHttpRequest {
         .expect("FATAL: failed to construct request from infallible data")
     }
 }
-
-impl StacksHttpResponse {
-    pub fn decode_stacks_block_proposal_accepted(self) -> Result<BlockValidateResponse, NetError> {
-        todo!()
-    }
-}

From 41ad95bb034758d7cc83f5a76a5c6a3e04089440 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Thu, 28 Dec 2023 21:01:09 -0500
Subject: [PATCH 0299/1166] Add `/v2/block_proposal` integration test to
 bitcoin-tests.yml

---
 .github/workflows/bitcoin-tests.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/workflows/bitcoin-tests.yml b/.github/workflows/bitcoin-tests.yml
index fb77c94624..04c66bfae7 100644
--- a/.github/workflows/bitcoin-tests.yml
+++ b/.github/workflows/bitcoin-tests.yml
@@ -72,6 +72,7 @@ jobs:
           - tests::should_succeed_handling_malformed_and_valid_txs
           - tests::nakamoto_integrations::simple_neon_integration
           - tests::nakamoto_integrations::mine_multiple_per_tenure_integration
+          - tests::nakamoto_integrations::block_proposal_api_endpoint
     steps:
       ## Setup test environment
       - name: Setup Test Environment

From ed8b42533af55086f941be918be1f7cbc802dee6 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Wed, 3 Jan 2024 10:35:32 -0500
Subject: [PATCH 0300/1166] chore: Address PR comments

---
 docs/rpc-endpoints.md                                |  4 ----
 docs/rpc/openapi.yaml                                | 12 ------------
 stacks-common/src/types/net.rs                       | 12 +-----------
 stackslib/src/net/api/postblock_proposal.rs          |  6 ------
 .../stacks-node/src/tests/nakamoto_integrations.rs   | 12 +++---------
 5 files changed, 4 insertions(+), 42 deletions(-)

diff --git a/docs/rpc-endpoints.md b/docs/rpc-endpoints.md
index 59e3ba2234..353af3d1c6 100644
--- a/docs/rpc-endpoints.md
+++ b/docs/rpc-endpoints.md
@@ -485,10 +485,6 @@ This endpoint takes as input the following struct from `chainstate/stacks/miner.
 pub struct NakamotoBlockProposal {
     /// Proposed block
     pub block: NakamotoBlock,
-    // tenure ID -- this is the index block hash of the start block of the last tenure (i.e.
-    // the data we committed to in the block-commit).  If this is an epoch 2.x parent, then
-    // this is just the index block hash of the parent Stacks block.
-    pub tenure_start_block: StacksBlockId,
     /// Identifies which chain block is for (Mainnet, Testnet, etc.)
     pub chain_id: u32,
 }
diff --git a/docs/rpc/openapi.yaml b/docs/rpc/openapi.yaml
index fa690a26a6..f6396c88cd 100644
--- a/docs/rpc/openapi.yaml
+++ b/docs/rpc/openapi.yaml
@@ -582,23 +582,11 @@ paths:
             application/json:
               schema:
                 $ref: ./api/core-node/post-block-proposal-error.schema.json
-        429:
-          description: Too many requests
-          content:
-            application/json:
-              schema:
-                $ref: ./api/core-node/post-block-proposal-error.schema.json
       parameters:
         - name: block
           in: query
           required: true
           description: 'Proposed Block. Must match Rust struct `NakamotoBlock`'
-        - name: tenure_start_block
-          in: query
-          required: true
-          description: '`StacksBlockId` for block at the start of current mining tenure'
-          schema:
-            type: string
         - name: chain_id
           in: query
           required: true
diff --git a/stacks-common/src/types/net.rs b/stacks-common/src/types/net.rs
index 5288cd17c5..1c77fab65c 100644
--- a/stacks-common/src/types/net.rs
+++ b/stacks-common/src/types/net.rs
@@ -220,17 +220,7 @@ impl PeerAddress {
 
     /// Is this a local loopback address?
     pub fn is_loopback(&self) -> bool {
-        if self.is_ipv4() {
-            // 127.0.0.0/8
-            self.0[12] == 127
-        } else {
-            // ::1/128
-            *self
-                == PeerAddress([
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                    0x00, 0x00, 0x01,
-                ])
-        }
+        self.to_socketaddr(0).ip().is_loopback()
     }
 
     pub fn to_bin(&self) -> String {
diff --git a/stackslib/src/net/api/postblock_proposal.rs b/stackslib/src/net/api/postblock_proposal.rs
index 2fe98bedcc..3e066ed39b 100644
--- a/stackslib/src/net/api/postblock_proposal.rs
+++ b/stackslib/src/net/api/postblock_proposal.rs
@@ -128,10 +128,6 @@ impl From<DBError> for BlockValidateReject {
 pub struct NakamotoBlockProposal {
     /// Proposed block
     pub block: NakamotoBlock,
-    // tenure ID -- this is the index block hash of the start block of the last tenure (i.e.
-    // the data we committed to in the block-commit).  If this is an epoch 2.x parent, then
-    // this is just the index block hash of the parent Stacks block.
-    pub tenure_start_block: StacksBlockId,
     /// Identifies which chain block is for (Mainnet, Testnet, etc.)
     pub chain_id: u32,
 }
@@ -139,14 +135,12 @@ pub struct NakamotoBlockProposal {
 impl StacksMessageCodec for NakamotoBlockProposal {
     fn consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), CodecError> {
         write_next(fd, &self.block)?;
-        write_next(fd, &self.tenure_start_block)?;
         write_next(fd, &self.chain_id)
     }
 
     fn consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, CodecError> {
         Ok(Self {
             block: read_next(fd)?,
-            tenure_start_block: read_next(fd)?,
             chain_id: read_next(fd)?,
         })
     }
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 8292f908df..222f942ac0 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -975,9 +975,6 @@ fn correct_burn_outs() {
 ///
 /// This endpoint allows miners to propose Nakamoto blocks to a node,
 /// and test if they would be accepted or rejected
-///
-/// Notes:
-/// - The `tenure_start_block` supplied doesn't seem to matter. It is required by `NakamotoBlockBuilder` but not used/checked?
 #[test]
 #[ignore]
 fn block_proposal_api_endpoint() {
@@ -1081,7 +1078,6 @@ fn block_proposal_api_endpoint() {
         .unwrap();
 
     let privk = conf.miner.mining_key.unwrap().clone();
-    let parent_block_id = tip.index_block_hash();
     // TODO: Get current `total_burn` from somewhere
     let sort_tip = SortitionDB::get_canonical_sortition_tip(sortdb.conn())
         .expect("Failed to get sortition tip");
@@ -1160,7 +1156,6 @@ fn block_proposal_api_endpoint() {
     // Construct a valid proposal. Make alterations to this to test failure cases
     let proposal = NakamotoBlockProposal {
         block,
-        tenure_start_block: parent_block_id,
         chain_id: chainstate.chain_id,
     };
 
@@ -1183,14 +1178,13 @@ fn block_proposal_api_endpoint() {
             HTTP_BADREQUEST,
         ),
         (
-            // FIXME: Why does `NakamotoBlockBuilder` not check this?
-            "Invalid `tenure_start_block`",
+            "Invalid `chain_id`",
             (|| {
                 let mut p = proposal.clone();
-                p.tenure_start_block.0[8] ^= 0x55;
+                p.chain_id ^= 0xFFFFFFFF;
                 sign(p)
             })(),
-            HTTP_ACCEPTED,
+            HTTP_BADREQUEST,
         ),
     ];
 

From 03c525ce438cb645d5a66c8bccc009fa0011b285 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Wed, 3 Jan 2024 12:55:57 -0500
Subject: [PATCH 0301/1166] test: Add more checking of HTTP responses in
 `block_proposal_api_endpoint()`

---
 .../src/tests/nakamoto_integrations.rs        | 40 +++++++++++++++----
 1 file changed, 33 insertions(+), 7 deletions(-)

diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 222f942ac0..1791c592ef 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -36,7 +36,9 @@ use stacks::core::{
     PEER_VERSION_EPOCH_2_1, PEER_VERSION_EPOCH_2_2, PEER_VERSION_EPOCH_2_3, PEER_VERSION_EPOCH_2_4,
     PEER_VERSION_EPOCH_2_5, PEER_VERSION_EPOCH_3_0,
 };
-use stacks::net::api::postblock_proposal::NakamotoBlockProposal;
+use stacks::net::api::postblock_proposal::{
+    BlockValidateOk, BlockValidateReject, NakamotoBlockProposal, ValidateRejectCode,
+};
 use stacks_common::address::AddressHashMode;
 use stacks_common::codec::StacksMessageCodec;
 use stacks_common::consts::STACKS_EPOCH_MAX;
@@ -1161,21 +1163,22 @@ fn block_proposal_api_endpoint() {
 
     const HTTP_ACCEPTED: u16 = 202;
     const HTTP_BADREQUEST: u16 = 400;
-    // TODO: Check error codes?
     let test_cases = [
         (
             "Valid Nakamoto block proposal",
             sign(proposal.clone()),
             HTTP_ACCEPTED,
+            None,
         ),
         (
-            "Corrupted (bit flipped after signing)",
+            "Corrupted message (bit flipped after signing)",
             (|| {
                 let mut sp = sign(proposal.clone());
                 sp.block.header.consensus_hash.0[3] ^= 0x07;
                 sp
             })(),
             HTTP_BADREQUEST,
+            Some(ValidateRejectCode::ChainstateError),
         ),
         (
             "Invalid `chain_id`",
@@ -1185,6 +1188,7 @@ fn block_proposal_api_endpoint() {
                 sign(p)
             })(),
             HTTP_BADREQUEST,
+            Some(ValidateRejectCode::InvalidBlock),
         ),
     ];
 
@@ -1192,13 +1196,19 @@ fn block_proposal_api_endpoint() {
     let client = reqwest::blocking::Client::builder()
         .timeout(Duration::from_secs(60))
         .build()
-        .expect("Failed to build reqwest::Client");
+        .expect("Failed to build `reqwest::Client`");
     // Build URL
     let http_origin = format!("http://{}", &conf.node.rpc_bind);
     let path = format!("{http_origin}/v2/block_proposal");
 
-    for (test_description, block_proposal, expected_response) in test_cases {
-        eprintln!("test_block_proposal(): {test_description}");
+    for (
+        test_description,
+        block_proposal,
+        expected_http_code,
+        expected_block_validate_reject_code,
+    ) in test_cases
+    {
+        eprintln!("block_proposal_api_endpoint(): {test_description}");
         eprintln!("{block_proposal:?}");
 
         // Send POST request
@@ -1210,7 +1220,23 @@ fn block_proposal_api_endpoint() {
             .expect("Failed to POST");
 
         eprintln!("{response:?}");
-        assert_eq!(response.status().as_u16(), expected_response);
+        assert_eq!(response.status().as_u16(), expected_http_code);
+
+        let response_text = response.text().expect("No response text");
+        match expected_block_validate_reject_code {
+            // If okay, check that response is same as block sent
+            Some(reject_code) => {
+                let reject = serde_json::from_str::<BlockValidateReject>(&response_text)
+                    .expect("Expected response of type `BlockValidateReject`");
+                assert_eq!(reject.reason_code, reject_code);
+            }
+            // If okay, check that response is same as block sent
+            None => {
+                let ok = serde_json::from_str::<BlockValidateOk>(&response_text)
+                    .expect("Expected response of type `BlockValidateOk`");
+                assert_eq!(ok.block, block_proposal.block);
+            }
+        }
     }
 
     // Clean up

From db7a836b4865b0f706319c383a36d1e7114837ce Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Wed, 3 Jan 2024 14:02:17 -0500
Subject: [PATCH 0302/1166] test: Add test case for `/v2/block_proposal`

---
 .../src/tests/nakamoto_integrations.rs        | 20 +++++++++++++++----
 1 file changed, 16 insertions(+), 4 deletions(-)

diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 1791c592ef..35348d5eed 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -37,7 +37,8 @@ use stacks::core::{
     PEER_VERSION_EPOCH_2_5, PEER_VERSION_EPOCH_3_0,
 };
 use stacks::net::api::postblock_proposal::{
-    BlockValidateOk, BlockValidateReject, NakamotoBlockProposal, ValidateRejectCode,
+    BlockValidateOk, BlockValidateReject, NakamotoBlockProposal,
+    ValidateRejectCode,
 };
 use stacks_common::address::AddressHashMode;
 use stacks_common::codec::StacksMessageCodec;
@@ -985,7 +986,7 @@ fn block_proposal_api_endpoint() {
     }
 
     let (mut conf, _miner_account) = naka_neon_integration_conf(None);
-    let account_keys = add_initial_balances(&mut conf, 10, 1000000);
+    let account_keys = add_initial_balances(&mut conf, 10, 1_000_000);
     let stacker_sk = setup_stacker(&mut conf);
 
     test_observer::spawn();
@@ -1190,6 +1191,16 @@ fn block_proposal_api_endpoint() {
             HTTP_BADREQUEST,
             Some(ValidateRejectCode::InvalidBlock),
         ),
+        (
+            "Invalid `miner_signature`",
+            (|| {
+                let mut sp = sign(proposal.clone());
+                sp.block.header.miner_signature.0[1] ^= 0x80;
+                sp
+            })(),
+            HTTP_BADREQUEST,
+            Some(ValidateRejectCode::ChainstateError),
+        ),
     ];
 
     // Build HTTP client
@@ -1209,7 +1220,7 @@ fn block_proposal_api_endpoint() {
     ) in test_cases
     {
         eprintln!("block_proposal_api_endpoint(): {test_description}");
-        eprintln!("{block_proposal:?}");
+        eprintln!("block_proposal={block_proposal:?}");
 
         // Send POST request
         let response = client
@@ -1219,10 +1230,11 @@ fn block_proposal_api_endpoint() {
             .send()
             .expect("Failed to POST");
 
-        eprintln!("{response:?}");
+        eprintln!("response={response:?}");
         assert_eq!(response.status().as_u16(), expected_http_code);
 
         let response_text = response.text().expect("No response text");
+        eprintln!("response_text={response_text:?}");
         match expected_block_validate_reject_code {
             // If okay, check that response is same as block sent
             Some(reject_code) => {

From 357219471fd32097e16f2af3667c3a41b5a4ccb0 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Wed, 3 Jan 2024 16:19:58 -0500
Subject: [PATCH 0303/1166] feat: Add threshold signature validation to
 `/v2/block_proposal`

---
 stackslib/src/net/api/postblock_proposal.rs   | 60 ++++++++++++++-----
 .../src/tests/nakamoto_integrations.rs        | 16 ++++-
 2 files changed, 59 insertions(+), 17 deletions(-)

diff --git a/stackslib/src/net/api/postblock_proposal.rs b/stackslib/src/net/api/postblock_proposal.rs
index 3e066ed39b..e3a9243222 100644
--- a/stackslib/src/net/api/postblock_proposal.rs
+++ b/stackslib/src/net/api/postblock_proposal.rs
@@ -108,21 +108,19 @@ impl From<Result<BlockValidateOk, BlockValidateReject>> for BlockValidateRespons
     }
 }
 
-impl From<ChainError> for BlockValidateReject {
-    fn from(value: ChainError) -> Self {
+impl<T> From<T> for BlockValidateReject
+where
+    T: Into<ChainError>,
+{
+    fn from(value: T) -> Self {
+        let ce: ChainError = value.into();
         BlockValidateReject {
-            reason: format!("Chainstate Error: {value}"),
+            reason: format!("Chainstate Error: {ce}"),
             reason_code: ValidateRejectCode::ChainstateError,
         }
     }
 }
 
-impl From<DBError> for BlockValidateReject {
-    fn from(value: DBError) -> Self {
-        ChainError::from(value).into()
-    }
-}
-
 /// Represents a block proposed to the `v2/block_proposal` endpoint for validation
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct NakamotoBlockProposal {
@@ -150,11 +148,12 @@ impl NakamotoBlockProposal {
     /// Test this block proposal against the current chain state and
     /// either accept or reject the proposal
     ///
-    /// This is done in 2 steps:
+    /// This is done in 3 stages:
     /// - Static validation of the block, which checks the following:
-    ///   - Block is well-formed
+    ///   - Block header is well-formed
     ///   - Transactions are well-formed
     ///   - Miner signature is valid
+    /// - Validate threshold signature of stackers
     /// - Validation of transactions by executing them agains current chainstate.
     ///   This is resource intensive, and therefore done only if previous checks pass
     pub fn validate(
@@ -180,7 +179,7 @@ impl NakamotoBlockProposal {
         let expected_burn =
             NakamotoChainState::get_expected_burns(&mut db_handle, chainstate.db(), &self.block)?;
 
-        // Static validation checks
+        // Stage 1: Static validation checks
         NakamotoChainState::validate_nakamoto_block_burnchain(
             &db_handle,
             expected_burn,
@@ -189,7 +188,39 @@ impl NakamotoBlockProposal {
             self.chain_id,
         )?;
 
-        // Validate block txs against chainstate
+        // Stage 2: Validate stacker threshold signature
+        let sort_handle = sortdb.index_handle(&sort_tip);
+        let Ok(aggregate_public_key) = NakamotoChainState::get_aggregate_public_key(
+            chainstate,
+            &sortdb,
+            &sort_handle,
+            &self.block,
+        ) else {
+            warn!("Failed to get aggregate public key";
+                "block_hash" => %self.block.header.block_hash(),
+                "consensus_hash" => %self.block.header.consensus_hash,
+                "chain_length" => self.block.header.chain_length,
+            );
+            return Err(BlockValidateReject {
+                reason: "Failed to get aggregate public key".into(),
+                reason_code: ValidateRejectCode::ChainstateError,
+            });
+        };
+        if !db_handle.expects_signer_signature(
+            &self.block.header.consensus_hash,
+            &self.block.header.signer_signature.0,
+            &self.block.header.signer_signature_hash()?.0,
+            &aggregate_public_key,
+        )? {
+            return Err(BlockValidateReject {
+                reason:
+                    "Stacker signature does not match aggregate pubkey for current stacking cycle"
+                        .into(),
+                reason_code: ValidateRejectCode::InvalidBlock,
+            });
+        }
+
+        // Stage 3: Validate txs against chainstate
         let parent_stacks_header = NakamotoChainState::get_block_header(
             chainstate.db(),
             &self.block.header.parent_block_id,
@@ -325,7 +356,8 @@ impl RPCBlockProposalRequestHandler {
 
     /// Decode a JSON-encoded transaction
     fn parse_json(body: &[u8]) -> Result<NakamotoBlockProposal, Error> {
-        serde_json::from_slice(body).map_err(|_| Error::DecodeError("Failed to parse body".into()))
+        serde_json::from_slice(body)
+            .map_err(|e| Error::DecodeError(format!("Failed to parse body: {e}")))
     }
 }
 
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 35348d5eed..5f17980b22 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -29,7 +29,7 @@ use stacks::chainstate::nakamoto::miner::NakamotoBlockBuilder;
 use stacks::chainstate::nakamoto::NakamotoChainState;
 use stacks::chainstate::stacks::db::StacksChainState;
 use stacks::chainstate::stacks::miner::{BlockBuilder, BlockLimitFunction, TransactionResult};
-use stacks::chainstate::stacks::{StacksTransaction, TransactionPayload};
+use stacks::chainstate::stacks::{StacksTransaction, ThresholdSignature, TransactionPayload};
 use stacks::core::{
     StacksEpoch, StacksEpochId, BLOCK_LIMIT_MAINNET_10, HELIUM_BLOCK_LIMIT_20,
     PEER_VERSION_EPOCH_1_0, PEER_VERSION_EPOCH_2_0, PEER_VERSION_EPOCH_2_05,
@@ -37,8 +37,7 @@ use stacks::core::{
     PEER_VERSION_EPOCH_2_5, PEER_VERSION_EPOCH_3_0,
 };
 use stacks::net::api::postblock_proposal::{
-    BlockValidateOk, BlockValidateReject, NakamotoBlockProposal,
-    ValidateRejectCode,
+    BlockValidateOk, BlockValidateReject, NakamotoBlockProposal, ValidateRejectCode,
 };
 use stacks_common::address::AddressHashMode;
 use stacks_common::codec::StacksMessageCodec;
@@ -1020,6 +1019,7 @@ fn block_proposal_api_endpoint() {
         &conf,
         &blocks_processed,
         stacker_sk,
+        StacksPublicKey::new(),
         &mut btc_regtest_controller,
     );
 
@@ -1201,6 +1201,16 @@ fn block_proposal_api_endpoint() {
             HTTP_BADREQUEST,
             Some(ValidateRejectCode::ChainstateError),
         ),
+        (
+            "Invalid `signer_signature`",
+            (|| {
+                let mut sp = sign(proposal.clone());
+                sp.block.header.signer_signature = ThresholdSignature::mock();
+                sp
+            })(),
+            HTTP_BADREQUEST,
+            Some(ValidateRejectCode::InvalidBlock),
+        ),
     ];
 
     // Build HTTP client

From 682d19c387a6911873551f87c76442f36820a3be Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Wed, 3 Jan 2024 21:07:29 -0600
Subject: [PATCH 0304/1166] feat: implement async block proposal interface

---
 stackslib/src/chainstate/burn/db/sortdb.rs    |  11 ++
 stackslib/src/core/mempool.rs                 |   6 +
 stackslib/src/net/api/postblock_proposal.rs   |  72 +++++++++--
 stackslib/src/net/p2p.rs                      |  23 ++++
 testnet/stacks-node/src/config.rs             |   5 +
 testnet/stacks-node/src/event_dispatcher.rs   |  62 ++++++++-
 .../src/tests/nakamoto_integrations.rs        | 121 ++++++++++++------
 .../src/tests/neon_integrations.rs            |  49 ++++---
 8 files changed, 285 insertions(+), 64 deletions(-)

diff --git a/stackslib/src/chainstate/burn/db/sortdb.rs b/stackslib/src/chainstate/burn/db/sortdb.rs
index ffef8a7782..0be1c77487 100644
--- a/stackslib/src/chainstate/burn/db/sortdb.rs
+++ b/stackslib/src/chainstate/burn/db/sortdb.rs
@@ -760,6 +760,7 @@ pub struct SortitionDB {
     pub first_block_height: u64,
     pub first_burn_header_hash: BurnchainHeaderHash,
     pub pox_constants: PoxConstants,
+    pub path: String,
 }
 
 #[derive(Clone)]
@@ -2662,6 +2663,7 @@ impl SortitionDB {
         let first_snapshot = SortitionDB::get_first_block_snapshot(marf.sqlite_conn())?;
 
         let mut db = SortitionDB {
+            path: path.to_string(),
             marf,
             readwrite,
             pox_constants,
@@ -2673,6 +2675,12 @@ impl SortitionDB {
         Ok(db)
     }
 
+    /// Open a new copy of this SortitionDB. Will use the same `readwrite` flag
+    ///  of `self`.
+    pub fn reopen(&self) -> Result<SortitionDB, db_error> {
+        Self::open(&self.path, self.readwrite, self.pox_constants.clone())
+    }
+
     /// Open the burn database at the given path.  Open read-only or read/write.
     /// If opened for read/write and it doesn't exist, instantiate it.
     pub fn connect(
@@ -2711,6 +2719,7 @@ impl SortitionDB {
         let marf = SortitionDB::open_index(&index_path)?;
 
         let mut db = SortitionDB {
+            path: path.to_string(),
             marf,
             readwrite,
             first_block_height,
@@ -2824,6 +2833,7 @@ impl SortitionDB {
         let marf = SortitionDB::open_index(&index_path)?;
 
         let mut db = SortitionDB {
+            path: path.to_string(),
             marf,
             readwrite,
             first_block_height,
@@ -3389,6 +3399,7 @@ impl SortitionDB {
             let index_path = db_mkdirs(path)?;
             let marf = SortitionDB::open_index(&index_path)?;
             let mut db = SortitionDB {
+                path: path.to_string(),
                 marf,
                 readwrite: true,
                 // not used by migration logic
diff --git a/stackslib/src/core/mempool.rs b/stackslib/src/core/mempool.rs
index f85a0e0ef9..e4af1e069b 100644
--- a/stackslib/src/core/mempool.rs
+++ b/stackslib/src/core/mempool.rs
@@ -59,6 +59,7 @@ use crate::core::{
 use crate::cost_estimates::metrics::{CostMetric, UnitMetric};
 use crate::cost_estimates::{CostEstimator, EstimatorError, UnitEstimator};
 use crate::monitoring::increment_stx_mempool_gc;
+use crate::net::api::postblock_proposal::{BlockValidateOk, BlockValidateReject};
 use crate::net::Error as net_error;
 use crate::util_lib::bloom::{BloomCounter, BloomFilter, BloomNodeHasher};
 use crate::util_lib::db::{
@@ -364,7 +365,12 @@ impl std::fmt::Display for MemPoolDropReason {
     }
 }
 
+pub trait ProposalCallbackReceiver: Send {
+    fn notify_proposal_result(&self, result: Result<BlockValidateOk, BlockValidateReject>);
+}
+
 pub trait MemPoolEventDispatcher {
+    fn get_proposal_callback_receiver(&self) -> Option<Box<dyn ProposalCallbackReceiver>>;
     fn mempool_txs_dropped(&self, txids: Vec<Txid>, reason: MemPoolDropReason);
     fn mined_block_event(
         &self,
diff --git a/stackslib/src/net/api/postblock_proposal.rs b/stackslib/src/net/api/postblock_proposal.rs
index e3a9243222..9cbbbc5204 100644
--- a/stackslib/src/net/api/postblock_proposal.rs
+++ b/stackslib/src/net/api/postblock_proposal.rs
@@ -15,6 +15,7 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::io::{Read, Write};
+use std::thread::{self, JoinHandle, Thread};
 
 use clarity::vm::ast::ASTRules;
 use clarity::vm::costs::ExecutionCost;
@@ -43,7 +44,7 @@ use crate::chainstate::stacks::miner::{BlockBuilder, BlockLimitFunction, Transac
 use crate::chainstate::stacks::{
     Error as ChainError, StacksBlock, StacksBlockHeader, StacksTransaction, TransactionPayload,
 };
-use crate::core::mempool::MemPoolDB;
+use crate::core::mempool::{MemPoolDB, ProposalCallbackReceiver};
 use crate::cost_estimates::FeeRateEstimate;
 use crate::net::http::{
     http_reason, parse_json, Error, HttpBadRequest, HttpContentType, HttpNotFound, HttpRequest,
@@ -145,6 +146,20 @@ impl StacksMessageCodec for NakamotoBlockProposal {
 }
 
 impl NakamotoBlockProposal {
+    fn spawn_validation_thread(
+        self,
+        sortdb: SortitionDB,
+        mut chainstate: StacksChainState,
+        receiver: Box<dyn ProposalCallbackReceiver>,
+    ) -> Result<JoinHandle<()>, std::io::Error> {
+        thread::Builder::new()
+            .name("block-proposal".into())
+            .spawn(move || {
+                let result = self.validate(&sortdb, &mut chainstate);
+                receiver.notify_proposal_result(result);
+            })
+    }
+
     /// Test this block proposal against the current chain state and
     /// either accept or reject the proposal
     ///
@@ -423,6 +438,12 @@ impl HttpRequest for RPCBlockProposalRequestHandler {
     }
 }
 
+struct ProposalThreadInfo {
+    sortdb: SortitionDB,
+    chainstate: StacksChainState,
+    receiver: Box<dyn ProposalCallbackReceiver>,
+}
+
 impl RPCRequestHandler for RPCBlockProposalRequestHandler {
     /// Reset internal state
     fn restart(&mut self) {
@@ -441,22 +462,57 @@ impl RPCRequestHandler for RPCBlockProposalRequestHandler {
             .take()
             .ok_or(NetError::SendError("`block_proposal` not set".into()))?;
 
-        let res = node.with_node_state(|_network, sortdb, chainstate, _mempool, _rpc_args| {
-            block_proposal.validate(sortdb, chainstate)
+        let res = node.with_node_state(|network, sortdb, chainstate, _mempool, rpc_args| {
+            if network.is_proposal_thread_running() {
+                return Err((
+                    429,
+                    NetError::SendError("Proposal currently being evaluated".into()),
+                ));
+            }
+            let (chainstate, _) = chainstate.reopen().map_err(|e| (400, NetError::from(e)))?;
+            let sortdb = sortdb.reopen().map_err(|e| (400, NetError::from(e)))?;
+            let receiver = rpc_args
+                .event_observer
+                .and_then(|observer| observer.get_proposal_callback_receiver())
+                .ok_or_else(|| {
+                    (
+                        400,
+                        NetError::SendError(
+                            "No `observer` registered for receiving proposal callbacks".into(),
+                        ),
+                    )
+                })?;
+            let thread_info = block_proposal
+                .spawn_validation_thread(sortdb, chainstate, receiver)
+                .map_err(|_e| {
+                    (
+                        429,
+                        NetError::SendError(
+                            "IO error while spawning proposal callback thread".into(),
+                        ),
+                    )
+                })?;
+            network.set_proposal_thread(thread_info);
+            Ok(())
         });
 
         match res {
-            Ok(ok) => {
+            Ok(_) => {
                 let mut preamble = HttpResponsePreamble::accepted_json(&preamble);
                 preamble.set_canonical_stacks_tip_height(Some(node.canonical_stacks_tip_height()));
-                let body = HttpResponseContents::try_from_json(&ok)?;
+                let body = HttpResponseContents::try_from_json(&serde_json::json!({
+                    "result": "Accepted",
+                    "message": "Block proposal is processing, result will be returned via the event observer"
+                }))?;
                 Ok((preamble, body))
             }
-            Err(err) => {
-                let code = 400;
+            Err((code, err)) => {
                 let mut preamble = HttpResponsePreamble::error_json(code, http_reason(code));
                 preamble.set_canonical_stacks_tip_height(Some(node.canonical_stacks_tip_height()));
-                let body = HttpResponseContents::try_from_json(&err)?;
+                let body = HttpResponseContents::try_from_json(&serde_json::json!({
+                    "result": "Error",
+                    "message": format!("Could not process block proposal request: {err}")
+                }))?;
                 Ok((preamble, body))
             }
         }
diff --git a/stackslib/src/net/p2p.rs b/stackslib/src/net/p2p.rs
index 3bc52fb4b3..74657ec8ad 100644
--- a/stackslib/src/net/p2p.rs
+++ b/stackslib/src/net/p2p.rs
@@ -20,6 +20,7 @@ use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr};
 use std::sync::mpsc::{
     sync_channel, Receiver, RecvError, SendError, SyncSender, TryRecvError, TrySendError,
 };
+use std::thread::JoinHandle;
 use std::{cmp, mem};
 
 use clarity::vm::ast::ASTRules;
@@ -346,6 +347,9 @@ pub struct PeerNetwork {
 
     // fault injection -- force disconnects
     fault_last_disconnect: u64,
+
+    /// Thread handle for the async block proposal endpoint.
+    block_proposal_thread: Option<JoinHandle<()>>,
 }
 
 impl PeerNetwork {
@@ -492,6 +496,8 @@ impl PeerNetwork {
             pending_messages: HashMap::new(),
 
             fault_last_disconnect: 0,
+
+            block_proposal_thread: None,
         };
 
         network.init_block_downloader();
@@ -500,6 +506,23 @@ impl PeerNetwork {
         network
     }
 
+    pub fn set_proposal_thread(&mut self, thread: JoinHandle<()>) {
+        self.block_proposal_thread = Some(thread);
+    }
+
+    pub fn is_proposal_thread_running(&mut self) -> bool {
+        let Some(block_proposal_thread) = self.block_proposal_thread.take() else {
+            // if block_proposal_thread is None, then no proposal thread is running
+            return false;
+        };
+        if block_proposal_thread.is_finished() {
+            return false;
+        } else {
+            self.block_proposal_thread = Some(block_proposal_thread);
+            return true;
+        }
+    }
+
     /// Get the current epoch
     pub fn get_current_epoch(&self) -> StacksEpoch {
         let epoch_index = StacksEpoch::find_epoch(&self.epochs, self.chain_view.burn_block_height)
diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index e61c011e33..ac6d4e733d 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -2374,6 +2374,7 @@ pub enum EventKeyType {
     MinedBlocks,
     MinedMicroblocks,
     StackerDBChunks,
+    BlockProposal,
 }
 
 impl EventKeyType {
@@ -2402,6 +2403,10 @@ impl EventKeyType {
             return Some(EventKeyType::StackerDBChunks);
         }
 
+        if raw_key == "block_proposal" {
+            return Some(EventKeyType::BlockProposal);
+        }
+
         let comps: Vec<_> = raw_key.split("::").collect();
         if comps.len() == 1 {
             let split: Vec<_> = comps[0].split(".").collect();
diff --git a/testnet/stacks-node/src/event_dispatcher.rs b/testnet/stacks-node/src/event_dispatcher.rs
index a6621bbc9d..3619970fc0 100644
--- a/testnet/stacks-node/src/event_dispatcher.rs
+++ b/testnet/stacks-node/src/event_dispatcher.rs
@@ -28,8 +28,11 @@ use stacks::chainstate::stacks::miner::TransactionEvent;
 use stacks::chainstate::stacks::{
     StacksBlock, StacksMicroblock, StacksTransaction, TransactionPayload,
 };
-use stacks::core::mempool::{MemPoolDropReason, MemPoolEventDispatcher};
+use stacks::core::mempool::{MemPoolDropReason, MemPoolEventDispatcher, ProposalCallbackReceiver};
 use stacks::libstackerdb::StackerDBChunkData;
+use stacks::net::api::postblock_proposal::{
+    BlockValidateOk, BlockValidateReject, BlockValidateResponse,
+};
 use stacks::net::atlas::{Attachment, AttachmentInstance};
 use stacks::net::stackerdb::StackerDBEventDispatcher;
 use stacks_common::codec::StacksMessageCodec;
@@ -67,6 +70,7 @@ pub const PATH_STACKERDB_CHUNKS: &str = "stackerdb_chunks";
 pub const PATH_BURN_BLOCK_SUBMIT: &str = "new_burn_block";
 pub const PATH_BLOCK_PROCESSED: &str = "new_block";
 pub const PATH_ATTACHMENT_PROCESSED: &str = "attachments/new";
+pub const PATH_PROPOSAL_RESPONSE: &str = "proposal_response";
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct MinedBlockEvent {
@@ -436,6 +440,31 @@ pub struct EventDispatcher {
     miner_observers_lookup: HashSet<u16>,
     mined_microblocks_observers_lookup: HashSet<u16>,
     stackerdb_observers_lookup: HashSet<u16>,
+    block_proposal_observers_lookup: HashSet<u16>,
+}
+
+/// This struct is used specifically for receiving proposal responses.
+/// It's constructed separately to play nicely with threading.
+struct ProposalCallbackHandler {
+    observers: Vec<EventObserver>,
+}
+
+impl ProposalCallbackReceiver for ProposalCallbackHandler {
+    fn notify_proposal_result(&self, result: Result<BlockValidateOk, BlockValidateReject>) {
+        let response = match serde_json::to_value(BlockValidateResponse::from(result)) {
+            Ok(x) => x,
+            Err(e) => {
+                error!(
+                    "Failed to serialize block proposal validation response, will not notify over event observer";
+                    "error" => ?e
+                );
+                return;
+            }
+        };
+        for observer in self.observers.iter() {
+            observer.send_payload(&response, PATH_PROPOSAL_RESPONSE);
+        }
+    }
 }
 
 impl MemPoolEventDispatcher for EventDispatcher {
@@ -495,6 +524,33 @@ impl MemPoolEventDispatcher for EventDispatcher {
             tx_events,
         )
     }
+
+    fn get_proposal_callback_receiver(&self) -> Option<Box<dyn ProposalCallbackReceiver>> {
+        let callback_receivers: Vec<_> = self
+            .block_proposal_observers_lookup
+            .iter()
+            .filter_map(|observer_ix|
+                match self.registered_observers.get(usize::from(*observer_ix)) {
+                    Some(x) => Some(x.clone()),
+                    None => {
+                        warn!(
+                            "Event observer index not found in registered observers. Ignoring that index.";
+                            "index" => observer_ix,
+                            "observers_len" => self.registered_observers.len()
+                        );
+                        None
+                    }
+                }
+            )
+            .collect();
+        if callback_receivers.is_empty() {
+            return None;
+        }
+        let handler = ProposalCallbackHandler {
+            observers: callback_receivers,
+        };
+        Some(Box::new(handler))
+    }
 }
 
 impl StackerDBEventDispatcher for EventDispatcher {
@@ -574,6 +630,7 @@ impl EventDispatcher {
             miner_observers_lookup: HashSet::new(),
             mined_microblocks_observers_lookup: HashSet::new(),
             stackerdb_observers_lookup: HashSet::new(),
+            block_proposal_observers_lookup: HashSet::new(),
         }
     }
 
@@ -1139,6 +1196,9 @@ impl EventDispatcher {
                 EventKeyType::StackerDBChunks => {
                     self.stackerdb_observers_lookup.insert(observer_index);
                 }
+                EventKeyType::BlockProposal => {
+                    self.block_proposal_observers_lookup.insert(observer_index);
+                }
             }
         }
 
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 5f17980b22..7e6a00036f 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -37,7 +37,7 @@ use stacks::core::{
     PEER_VERSION_EPOCH_2_5, PEER_VERSION_EPOCH_3_0,
 };
 use stacks::net::api::postblock_proposal::{
-    BlockValidateOk, BlockValidateReject, NakamotoBlockProposal, ValidateRejectCode,
+    BlockValidateReject, BlockValidateResponse, NakamotoBlockProposal, ValidateRejectCode,
 };
 use stacks_common::address::AddressHashMode;
 use stacks_common::codec::StacksMessageCodec;
@@ -988,11 +988,12 @@ fn block_proposal_api_endpoint() {
     let account_keys = add_initial_balances(&mut conf, 10, 1_000_000);
     let stacker_sk = setup_stacker(&mut conf);
 
+    // only subscribe to the block proposal events
     test_observer::spawn();
     let observer_port = test_observer::EVENT_OBSERVER_PORT;
     conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{observer_port}"),
-        events_keys: vec![EventKeyType::AnyEvent],
+        events_keys: vec![EventKeyType::BlockProposal],
     });
 
     let mut btcd_controller = BitcoinCoreController::new(conf.clone());
@@ -1057,8 +1058,8 @@ fn block_proposal_api_endpoint() {
     })
     .unwrap();
 
-    // Mine 15 nakamoto tenures
-    for _ in 0..15 {
+    // Mine 3 nakamoto tenures
+    for _ in 0..3 {
         next_block_and_mine_commit(
             &mut btc_regtest_controller,
             60,
@@ -1163,23 +1164,24 @@ fn block_proposal_api_endpoint() {
     };
 
     const HTTP_ACCEPTED: u16 = 202;
-    const HTTP_BADREQUEST: u16 = 400;
+    const HTTP_TOO_MANY: u16 = 429;
     let test_cases = [
         (
             "Valid Nakamoto block proposal",
             sign(proposal.clone()),
             HTTP_ACCEPTED,
-            None,
+            Some(Ok(())),
         ),
+        ("Must wait", sign(proposal.clone()), HTTP_TOO_MANY, None),
         (
-            "Corrupted message (bit flipped after signing)",
+            "Corrupted (bit flipped after signing)",
             (|| {
                 let mut sp = sign(proposal.clone());
                 sp.block.header.consensus_hash.0[3] ^= 0x07;
                 sp
             })(),
-            HTTP_BADREQUEST,
-            Some(ValidateRejectCode::ChainstateError),
+            HTTP_ACCEPTED,
+            Some(Err(ValidateRejectCode::ChainstateError)),
         ),
         (
             "Invalid `chain_id`",
@@ -1188,8 +1190,8 @@ fn block_proposal_api_endpoint() {
                 p.chain_id ^= 0xFFFFFFFF;
                 sign(p)
             })(),
-            HTTP_BADREQUEST,
-            Some(ValidateRejectCode::InvalidBlock),
+            HTTP_ACCEPTED,
+            Some(Err(ValidateRejectCode::InvalidBlock)),
         ),
         (
             "Invalid `miner_signature`",
@@ -1198,8 +1200,8 @@ fn block_proposal_api_endpoint() {
                 sp.block.header.miner_signature.0[1] ^= 0x80;
                 sp
             })(),
-            HTTP_BADREQUEST,
-            Some(ValidateRejectCode::ChainstateError),
+            HTTP_ACCEPTED,
+            Some(Err(ValidateRejectCode::ChainstateError)),
         ),
         (
             "Invalid `signer_signature`",
@@ -1208,8 +1210,8 @@ fn block_proposal_api_endpoint() {
                 sp.block.header.signer_signature = ThresholdSignature::mock();
                 sp
             })(),
-            HTTP_BADREQUEST,
-            Some(ValidateRejectCode::InvalidBlock),
+            HTTP_ACCEPTED,
+            Some(Err(ValidateRejectCode::InvalidBlock)),
         ),
     ];
 
@@ -1222,43 +1224,84 @@ fn block_proposal_api_endpoint() {
     let http_origin = format!("http://{}", &conf.node.rpc_bind);
     let path = format!("{http_origin}/v2/block_proposal");
 
-    for (
-        test_description,
-        block_proposal,
-        expected_http_code,
-        expected_block_validate_reject_code,
-    ) in test_cases
+    let mut hold_proposal_mutex = Some(test_observer::PROPOSAL_RESPONSES.lock().unwrap());
+    for (ix, (test_description, block_proposal, expected_http_code, _)) in
+        test_cases.iter().enumerate()
     {
         eprintln!("block_proposal_api_endpoint(): {test_description}");
         eprintln!("block_proposal={block_proposal:?}");
 
         // Send POST request
-        let response = client
+        let mut response = client
             .post(&path)
             .header("Content-Type", "application/json")
-            .json(&block_proposal)
+            .json(block_proposal)
             .send()
             .expect("Failed to POST");
+        let start_time = Instant::now();
+        while ix != 1 && response.status().as_u16() == HTTP_TOO_MANY {
+            if start_time.elapsed() > Duration::from_secs(30) {
+                error!("Took over 30 seconds to process pending proposal, panicking test");
+                panic!();
+            }
+            info!("Waiting for prior request to finish processing, and then resubmitting");
+            thread::sleep(Duration::from_secs(5));
+            response = client
+                .post(&path)
+                .header("Content-Type", "application/json")
+                .json(block_proposal)
+                .send()
+                .expect("Failed to POST");
+        }
+
+        let response_code = response.status().as_u16();
+        let response_json = response.json::<serde_json::Value>();
+        eprintln!("Response JSON: {response_json:?}");
+        eprintln!("Response STATUS: {response_code}");
 
-        eprintln!("response={response:?}");
-        assert_eq!(response.status().as_u16(), expected_http_code);
-
-        let response_text = response.text().expect("No response text");
-        eprintln!("response_text={response_text:?}");
-        match expected_block_validate_reject_code {
-            // If okay, check that response is same as block sent
-            Some(reject_code) => {
-                let reject = serde_json::from_str::<BlockValidateReject>(&response_text)
-                    .expect("Expected response of type `BlockValidateReject`");
-                assert_eq!(reject.reason_code, reject_code);
+        assert_eq!(response_code, *expected_http_code);
+
+        if ix == 1 {
+            // release the test observer mutex so that the handler from 0 can finish!
+            hold_proposal_mutex.take();
+        }
+    }
+
+    let expected_proposal_responses: Vec<_> = test_cases
+        .iter()
+        .filter_map(|(_, _, _, expected_response)| expected_response.as_ref())
+        .collect();
+
+    let mut proposal_responses = test_observer::get_proposal_responses();
+    let start_time = Instant::now();
+    while proposal_responses.len() < expected_proposal_responses.len() {
+        if start_time.elapsed() > Duration::from_secs(30) {
+            error!("Took over 30 seconds to process pending proposal, panicking test");
+            panic!();
+        }
+        info!("Waiting for prior request to finish processing");
+        thread::sleep(Duration::from_secs(5));
+        proposal_responses = test_observer::get_proposal_responses();
+    }
+
+    for (expected_response, response) in expected_proposal_responses
+        .iter()
+        .zip(proposal_responses.iter())
+    {
+        match expected_response {
+            Ok(_) => {
+                assert!(matches!(response, BlockValidateResponse::Ok(_)));
             }
-            // If okay, check that response is same as block sent
-            None => {
-                let ok = serde_json::from_str::<BlockValidateOk>(&response_text)
-                    .expect("Expected response of type `BlockValidateOk`");
-                assert_eq!(ok.block, block_proposal.block);
+            Err(expected_reject_code) => {
+                assert!(matches!(
+                    response,
+                    BlockValidateResponse::Reject(
+                        BlockValidateReject { reason_code, .. })
+                        if reason_code == expected_reject_code
+                ));
             }
         }
+        info!("Proposal response: {response:?}");
     }
 
     // Clean up
diff --git a/testnet/stacks-node/src/tests/neon_integrations.rs b/testnet/stacks-node/src/tests/neon_integrations.rs
index b9de6d1d6d..c41889ee2b 100644
--- a/testnet/stacks-node/src/tests/neon_integrations.rs
+++ b/testnet/stacks-node/src/tests/neon_integrations.rs
@@ -177,7 +177,7 @@ pub mod test_observer {
     use std::sync::Mutex;
     use std::thread;
 
-    use lazy_static::lazy_static;
+    use stacks::net::api::postblock_proposal::BlockValidateResponse;
     use warp::Filter;
     use {tokio, warp};
 
@@ -187,19 +187,26 @@ pub mod test_observer {
 
     pub const EVENT_OBSERVER_PORT: u16 = 50303;
 
-    lazy_static! {
-        pub static ref NEW_BLOCKS: Mutex<Vec<serde_json::Value>> = Mutex::new(Vec::new());
-        pub static ref MINED_BLOCKS: Mutex<Vec<MinedBlockEvent>> = Mutex::new(Vec::new());
-        pub static ref MINED_MICROBLOCKS: Mutex<Vec<MinedMicroblockEvent>> = Mutex::new(Vec::new());
-        pub static ref MINED_NAKAMOTO_BLOCKS: Mutex<Vec<MinedNakamotoBlockEvent>> =
-            Mutex::new(Vec::new());
-        pub static ref NEW_MICROBLOCKS: Mutex<Vec<serde_json::Value>> = Mutex::new(Vec::new());
-        pub static ref NEW_STACKERDB_CHUNKS: Mutex<Vec<StackerDBChunksEvent>> =
-            Mutex::new(Vec::new());
-        pub static ref BURN_BLOCKS: Mutex<Vec<serde_json::Value>> = Mutex::new(Vec::new());
-        pub static ref MEMTXS: Mutex<Vec<String>> = Mutex::new(Vec::new());
-        pub static ref MEMTXS_DROPPED: Mutex<Vec<(String, String)>> = Mutex::new(Vec::new());
-        pub static ref ATTACHMENTS: Mutex<Vec<serde_json::Value>> = Mutex::new(Vec::new());
+    pub static NEW_BLOCKS: Mutex<Vec<serde_json::Value>> = Mutex::new(Vec::new());
+    pub static MINED_BLOCKS: Mutex<Vec<MinedBlockEvent>> = Mutex::new(Vec::new());
+    pub static MINED_MICROBLOCKS: Mutex<Vec<MinedMicroblockEvent>> = Mutex::new(Vec::new());
+    pub static MINED_NAKAMOTO_BLOCKS: Mutex<Vec<MinedNakamotoBlockEvent>> = Mutex::new(Vec::new());
+    pub static NEW_MICROBLOCKS: Mutex<Vec<serde_json::Value>> = Mutex::new(Vec::new());
+    pub static NEW_STACKERDB_CHUNKS: Mutex<Vec<StackerDBChunksEvent>> = Mutex::new(Vec::new());
+    pub static BURN_BLOCKS: Mutex<Vec<serde_json::Value>> = Mutex::new(Vec::new());
+    pub static MEMTXS: Mutex<Vec<String>> = Mutex::new(Vec::new());
+    pub static MEMTXS_DROPPED: Mutex<Vec<(String, String)>> = Mutex::new(Vec::new());
+    pub static ATTACHMENTS: Mutex<Vec<serde_json::Value>> = Mutex::new(Vec::new());
+    pub static PROPOSAL_RESPONSES: Mutex<Vec<BlockValidateResponse>> = Mutex::new(Vec::new());
+
+    async fn handle_proposal_response(
+        response: serde_json::Value,
+    ) -> Result<impl warp::Reply, Infallible> {
+        PROPOSAL_RESPONSES.lock().unwrap().push(
+            serde_json::from_value(response)
+                .expect("Failed to deserialize JSON into BlockValidateResponse"),
+        );
+        Ok(warp::http::StatusCode::OK)
     }
 
     async fn handle_burn_block(
@@ -399,6 +406,10 @@ pub mod test_observer {
         NEW_STACKERDB_CHUNKS.lock().unwrap().clone()
     }
 
+    pub fn get_proposal_responses() -> Vec<BlockValidateResponse> {
+        PROPOSAL_RESPONSES.lock().unwrap().clone()
+    }
+
     /// each path here should correspond to one of the paths listed in `event_dispatcher.rs`
     async fn serve(port: u16) {
         let new_blocks = warp::path!("new_block")
@@ -441,8 +452,12 @@ pub mod test_observer {
             .and(warp::post())
             .and(warp::body::json())
             .and_then(handle_stackerdb_chunks);
+        let block_proposals = warp::path!("proposal_response")
+            .and(warp::post())
+            .and(warp::body::json())
+            .and_then(handle_proposal_response);
 
-        info!("Spawning warp server");
+        info!("Spawning event-observer warp server");
         warp::serve(
             new_blocks
                 .or(mempool_txs)
@@ -453,7 +468,8 @@ pub mod test_observer {
                 .or(mined_blocks)
                 .or(mined_microblocks)
                 .or(mined_nakamoto_blocks)
-                .or(new_stackerdb_chunks),
+                .or(new_stackerdb_chunks)
+                .or(block_proposals),
         )
         .run(([127, 0, 0, 1], port))
         .await
@@ -485,6 +501,7 @@ pub mod test_observer {
         MEMTXS.lock().unwrap().clear();
         MEMTXS_DROPPED.lock().unwrap().clear();
         ATTACHMENTS.lock().unwrap().clear();
+        PROPOSAL_RESPONSES.lock().unwrap().clear();
     }
 }
 

From a63c6a3da7a391caafd495c1f791555831d12b6e Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Thu, 4 Jan 2024 15:20:50 -0600
Subject: [PATCH 0305/1166] remove stacker verification from block proposal
 check, update docs

---
 docs/rpc-endpoints.md                         |  55 ++++++++-
 .../post-block-proposal-req.example.json      |   4 +
 .../post-block-proposal-response.429.json     |   4 +
 .../post-block-proposal-response.error.json   |  17 ---
 .../post-block-proposal-response.example.json |   4 +
 .../post-block-proposal-response.schema.json  |  21 ----
 docs/rpc/openapi.yaml                         |  38 +++----
 stackslib/src/chainstate/stacks/mod.rs        |  18 ++-
 stackslib/src/net/api/postblock_proposal.rs   | 104 ++++--------------
 .../src/tests/nakamoto_integrations.rs        |  26 ++---
 .../src/tests/neon_integrations.rs            |   1 +
 11 files changed, 128 insertions(+), 164 deletions(-)
 create mode 100644 docs/rpc/api/core-node/post-block-proposal-req.example.json
 create mode 100644 docs/rpc/api/core-node/post-block-proposal-response.429.json
 delete mode 100644 docs/rpc/api/core-node/post-block-proposal-response.error.json
 create mode 100644 docs/rpc/api/core-node/post-block-proposal-response.example.json
 delete mode 100644 docs/rpc/api/core-node/post-block-proposal-response.schema.json

diff --git a/docs/rpc-endpoints.md b/docs/rpc-endpoints.md
index 353af3d1c6..bb8a4b28f8 100644
--- a/docs/rpc-endpoints.md
+++ b/docs/rpc-endpoints.md
@@ -474,8 +474,7 @@ See OpenAPI [spec](./rpc/openapi.yaml) for details.
 
 ### POST /v2/block_proposal
 
-Used by miner to validate a proposed Stacks block.
-Can accept either JSON or binary encoding
+Used by miner to validate a proposed Stacks block using JSON encoding.
 
 **This endpoint will only accept requests over the local loopback network interface.**
 
@@ -489,3 +488,55 @@ pub struct NakamotoBlockProposal {
     pub chain_id: u32,
 }
 ```
+
+#### Responses over the Event Observer Interface
+
+This endpoint returns asynchronous results to the caller via the event observer interface.
+A caller must have registered an event observer using the `block_proposal` key in the stacks-node
+config file.
+
+The result is issued via POSTing the response JSON over the `/proposal_response` endpoint on the
+registered observer.
+
+Ok response example:
+
+```json
+{
+    "result": "Ok",
+    "block": "00000000000000001f00000000000927c08fb5ae5bf80e39e4168f6a3fddb0407a069d21ee68465e6856393254d2a66194f44bb01070666d5effcfb2436e209a75878fe80a04b4258a8cd34ab97c38a8dde331a2a509dd7e4b90590726866172cc138c18e80567737667f55d3f9817ce4714c91d1adfd36101141829dc0b5ea0c4944668c0005ddb6f9e2718f60014f21932a42a36ffaf58e88e77b217b2af366c15dd59e6b136ca773729832dcfc5875ec0830d04012dd5a4fa77a196646ea2b356289116fd02558c034b62d63f8a65bdd20d7ffc3fec6c266cd974be776a9e92759b90f288dcc2525b6b6bd5622c5f02e0922440e9ad1095c19b4467fd94566caa9755669d8e0000000180800000000400f64081ae6209dce9245753a4f764d6f168aae1af00000000000000000000000000000064000041dbcc7391991c1a18371eb49b879240247a3ec7f281328f53976c1218ffd65421dbb101e59370e2c972b29f48dc674b2de5e1b65acbd41d5d2689124d42c16c01010000000000051a346048df62be3a52bb6236e11394e8600229e27b000000000000271000000000000000000000000000000000000000000000000000000000000000000000",
+    "cost": {
+        "read_count": 8,
+        "read_length":133954,
+        "runtime":139720,
+        "write_count":2,
+        "write_length":114
+    },
+    "size": 180
+}
+```
+
+Error examples:
+
+```json
+{
+  "result": "Reject",
+  "reason": "Chainstate Error: No sortition for block's consensus hash",
+  "reason_code": "ChainstateError"
+}
+```
+
+```json
+{
+  "result": "Reject",
+  "reason": "Wrong network/chain_id",
+  "reason_code": "InvalidBlock"
+}
+```
+
+```json
+{
+  "result": "Reject",
+  "reason": "Chainstate Error: Invalid miner signature",
+  "reason_code": "ChainstateError"
+}
+```
diff --git a/docs/rpc/api/core-node/post-block-proposal-req.example.json b/docs/rpc/api/core-node/post-block-proposal-req.example.json
new file mode 100644
index 0000000000..d32f2b6e53
--- /dev/null
+++ b/docs/rpc/api/core-node/post-block-proposal-req.example.json
@@ -0,0 +1,4 @@
+{
+  "block": "00000000000000001f00000000000927c08fb5ae5bf80e39e4168f6a3fddb0407a069d21ee68465e6856393254d2a66194f44bb01070666d5effcfb2436e209a75878fe80a04b4258a8cd34ab97c38a8dde331a2a509dd7e4b90590726866172cc138c18e80567737667f55d3f9817ce4714c91d1adfd36101141829dc0b5ea0c4944668c0005ddb6f9e2718f60014f21932a42a36ffaf58e88e77b217b2af366c15dd59e6b136ca773729832dcfc5875ec0830d04012dd5a4fa77a196646ea2b356289116fd02558c034b62d63f8a65bdd20d7ffc3fec6c266cd974be776a9e92759b90f288dcc2525b6b6bd5622c5f02e0922440e9ad1095c19b4467fd94566caa9755669d8e0000000180800000000400f64081ae6209dce9245753a4f764d6f168aae1af00000000000000000000000000000064000041dbcc7391991c1a18371eb49b879240247a3ec7f281328f53976c1218ffd65421dbb101e59370e2c972b29f48dc674b2de5e1b65acbd41d5d2689124d42c16c01010000000000051a346048df62be3a52bb6236e11394e8600229e27b000000000000271000000000000000000000000000000000000000000000000000000000000000000000",
+  "chain_id": 2147483648
+}
diff --git a/docs/rpc/api/core-node/post-block-proposal-response.429.json b/docs/rpc/api/core-node/post-block-proposal-response.429.json
new file mode 100644
index 0000000000..f6e5b85070
--- /dev/null
+++ b/docs/rpc/api/core-node/post-block-proposal-response.429.json
@@ -0,0 +1,4 @@
+{
+  "message": "Could not process block proposal request: Proposal currently being evaluated",
+  "result": "Error"
+}
diff --git a/docs/rpc/api/core-node/post-block-proposal-response.error.json b/docs/rpc/api/core-node/post-block-proposal-response.error.json
deleted file mode 100644
index 6f463e5492..0000000000
--- a/docs/rpc/api/core-node/post-block-proposal-response.error.json
+++ /dev/null
@@ -1,17 +0,0 @@
-{
-  "$schema": "http://json-schema.org/draft-07/schema#",
-  "description": "Returned on successful POST to /v2/block_proposal",
-  "title": "PostCoreNodeBlockProposalError",
-  "type": "object",
-  "required": ["reason", "reason_code"],
-  "properties": {
-    "reason": {
-      "type": "string",
-      "description": "Error description"
-    },
-    "reason_code": {
-      "type": "string",
-      "description": "String representation of error code enum"
-    }
-  }
-}
diff --git a/docs/rpc/api/core-node/post-block-proposal-response.example.json b/docs/rpc/api/core-node/post-block-proposal-response.example.json
new file mode 100644
index 0000000000..b2f9c8e518
--- /dev/null
+++ b/docs/rpc/api/core-node/post-block-proposal-response.example.json
@@ -0,0 +1,4 @@
+{
+  "message": "Block proposal is processing, result will be returned via the event observer",
+  "result": "Accepted"
+} 
diff --git a/docs/rpc/api/core-node/post-block-proposal-response.schema.json b/docs/rpc/api/core-node/post-block-proposal-response.schema.json
deleted file mode 100644
index d997a3c0a3..0000000000
--- a/docs/rpc/api/core-node/post-block-proposal-response.schema.json
+++ /dev/null
@@ -1,21 +0,0 @@
-{
-  "$schema": "http://json-schema.org/draft-07/schema#",
-  "description": "Returned on successful POST to /v2/block_proposal",
-  "title": "PostCoreNodeBlockProposalResponse",
-  "type": "object",
-  "required": ["block", "cost", "size"],
-  "properties": {
-    "block": {
-      "type": "object",
-      "description": "Nakamoto block"
-    },
-    "cost": {
-      "type": "object",
-      "description": "Total execution costs for transactions in the block"
-    },
-    "size": {
-      "type": "integer",
-      "description": "Size of block in bytes"
-    }
-  }
-}
diff --git a/docs/rpc/openapi.yaml b/docs/rpc/openapi.yaml
index f6396c88cd..7f23276cee 100644
--- a/docs/rpc/openapi.yaml
+++ b/docs/rpc/openapi.yaml
@@ -557,10 +557,9 @@ paths:
       summary: Validate a proposed Stacks block
       tags:
         - Mining
-      #operationId: ???
+      operationId: post_block_proposal
       description: |
-        Used by miner to validate a proposed Stacks block.
-        Can accept either JSON or binary encoding.
+        Used by stackers to validate a proposed Stacks block from a miner.
         
         **This endpoint will only accept requests over the local loopback network interface.**
       responses:
@@ -568,28 +567,19 @@ paths:
           description: Block proposal is valid
           content:
             application/json:
-              schema:
-                $ref: ./api/core-node/post-block-proposal-response.schema.json
-        400:
-          description: Block proposal not valid
-          content:
-            application/json:
-              schema:
-                $ref: ./api/core-node/post-block-proposal-error.schema.json
+              example:
+                $ref: ./api/core-node/post-block-proposal-response.example.json
         403:
           description: Request not over loopback interface
+        429:
+          description: There is an ongoing proposal validation being processed, the new request cannot be accepted
+            until the prior request has been processed.
           content:
             application/json:
-              schema:
-                $ref: ./api/core-node/post-block-proposal-error.schema.json
-      parameters:
-        - name: block
-          in: query
-          required: true
-          description: 'Proposed Block. Must match Rust struct `NakamotoBlock`'
-        - name: chain_id
-          in: query
-          required: true
-          description: 'Identifies which chain block is for (Mainnet, Testnet, etc.)'
-          schema:
-            type: integer
+              example:
+                $ref: ./api/core-node/post-block-proposal-429.example.json
+      requestBody:
+        content:
+          application/json:
+            example:
+              $ref: ./api/core-node/post-block-proposal-req.example.json
diff --git a/stackslib/src/chainstate/stacks/mod.rs b/stackslib/src/chainstate/stacks/mod.rs
index eec991157a..e1f07efc92 100644
--- a/stackslib/src/chainstate/stacks/mod.rs
+++ b/stackslib/src/chainstate/stacks/mod.rs
@@ -673,7 +673,7 @@ pub enum TenureChangeError {
 }
 
 /// Schnorr threshold signature using types from `wsts`
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct ThresholdSignature(pub wsts::common::Signature);
 impl FromSql for ThresholdSignature {
     fn column_result(value: ValueRef) -> FromSqlResult<ThresholdSignature> {
@@ -693,6 +693,22 @@ impl ToSql for ThresholdSignature {
     }
 }
 
+impl serde::Serialize for ThresholdSignature {
+    fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
+        let bytes = self.serialize_to_vec();
+        s.serialize_str(&to_hex(&bytes))
+    }
+}
+
+impl<'de> serde::Deserialize<'de> for ThresholdSignature {
+    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
+        let hex_str = String::deserialize(d)?;
+        let bytes = hex_bytes(&hex_str).map_err(serde::de::Error::custom)?;
+        ThresholdSignature::consensus_deserialize(&mut bytes.as_slice())
+            .map_err(serde::de::Error::custom)
+    }
+}
+
 /// A transaction from Stackers to signal new mining tenure
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct TenureChangePayload {
diff --git a/stackslib/src/net/api/postblock_proposal.rs b/stackslib/src/net/api/postblock_proposal.rs
index 9cbbbc5204..872d1343bf 100644
--- a/stackslib/src/net/api/postblock_proposal.rs
+++ b/stackslib/src/net/api/postblock_proposal.rs
@@ -20,6 +20,7 @@ use std::thread::{self, JoinHandle, Thread};
 use clarity::vm::ast::ASTRules;
 use clarity::vm::costs::ExecutionCost;
 use regex::{Captures, Regex};
+use serde::Deserialize;
 use stacks_common::codec::{
     read_next, write_next, Error as CodecError, StacksMessageCodec, MAX_PAYLOAD_LEN,
 };
@@ -30,7 +31,7 @@ use stacks_common::types::chainstate::{
 use stacks_common::types::net::PeerHost;
 use stacks_common::types::StacksPublicKeyBuffer;
 use stacks_common::util::get_epoch_time_ms;
-use stacks_common::util::hash::{hex_bytes, Hash160, Sha256Sum};
+use stacks_common::util::hash::{hex_bytes, to_hex, Hash160, Sha256Sum};
 use stacks_common::util::retry::BoundReader;
 
 use crate::burnchains::affirmation::AffirmationMap;
@@ -74,6 +75,17 @@ pub enum ValidateRejectCode {
     UnknownParent,
 }
 
+fn hex_ser_block<S: serde::Serializer>(b: &NakamotoBlock, s: S) -> Result<S::Ok, S::Error> {
+    let inst = to_hex(&b.serialize_to_vec());
+    s.serialize_str(inst.as_str())
+}
+
+fn hex_deser_block<'de, D: serde::Deserializer<'de>>(d: D) -> Result<NakamotoBlock, D::Error> {
+    let inst_str = String::deserialize(d)?;
+    let bytes = hex_bytes(&inst_str).map_err(serde::de::Error::custom)?;
+    NakamotoBlock::consensus_deserialize(&mut bytes.as_slice()).map_err(serde::de::Error::custom)
+}
+
 /// A response for block proposal validation
 ///  that the stacks-node thinks should be rejected.
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
@@ -86,6 +98,7 @@ pub struct BlockValidateReject {
 ///  that the stacks-node thinks is acceptable.
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct BlockValidateOk {
+    #[serde(serialize_with = "hex_ser_block", deserialize_with = "hex_deser_block")]
     pub block: NakamotoBlock,
     pub cost: ExecutionCost,
     pub size: u64,
@@ -94,7 +107,7 @@ pub struct BlockValidateOk {
 /// This enum is used for serializing the response to block
 /// proposal validation.
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(tag = "Result")]
+#[serde(tag = "result")]
 pub enum BlockValidateResponse {
     Ok(BlockValidateOk),
     Reject(BlockValidateReject),
@@ -126,25 +139,12 @@ where
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct NakamotoBlockProposal {
     /// Proposed block
+    #[serde(serialize_with = "hex_ser_block", deserialize_with = "hex_deser_block")]
     pub block: NakamotoBlock,
     /// Identifies which chain block is for (Mainnet, Testnet, etc.)
     pub chain_id: u32,
 }
 
-impl StacksMessageCodec for NakamotoBlockProposal {
-    fn consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), CodecError> {
-        write_next(fd, &self.block)?;
-        write_next(fd, &self.chain_id)
-    }
-
-    fn consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, CodecError> {
-        Ok(Self {
-            block: read_next(fd)?,
-            chain_id: read_next(fd)?,
-        })
-    }
-}
-
 impl NakamotoBlockProposal {
     fn spawn_validation_thread(
         self,
@@ -168,7 +168,6 @@ impl NakamotoBlockProposal {
     ///   - Block header is well-formed
     ///   - Transactions are well-formed
     ///   - Miner signature is valid
-    /// - Validate threshold signature of stackers
     /// - Validation of transactions by executing them agains current chainstate.
     ///   This is resource intensive, and therefore done only if previous checks pass
     pub fn validate(
@@ -184,7 +183,7 @@ impl NakamotoBlockProposal {
         if self.chain_id != chainstate.chain_id || mainnet != chainstate.mainnet {
             return Err(BlockValidateReject {
                 reason_code: ValidateRejectCode::InvalidBlock,
-                reason: "Wrong netowrk/chain_id".into(),
+                reason: "Wrong network/chain_id".into(),
             });
         }
 
@@ -203,38 +202,6 @@ impl NakamotoBlockProposal {
             self.chain_id,
         )?;
 
-        // Stage 2: Validate stacker threshold signature
-        let sort_handle = sortdb.index_handle(&sort_tip);
-        let Ok(aggregate_public_key) = NakamotoChainState::get_aggregate_public_key(
-            chainstate,
-            &sortdb,
-            &sort_handle,
-            &self.block,
-        ) else {
-            warn!("Failed to get aggregate public key";
-                "block_hash" => %self.block.header.block_hash(),
-                "consensus_hash" => %self.block.header.consensus_hash,
-                "chain_length" => self.block.header.chain_length,
-            );
-            return Err(BlockValidateReject {
-                reason: "Failed to get aggregate public key".into(),
-                reason_code: ValidateRejectCode::ChainstateError,
-            });
-        };
-        if !db_handle.expects_signer_signature(
-            &self.block.header.consensus_hash,
-            &self.block.header.signer_signature.0,
-            &self.block.header.signer_signature_hash()?.0,
-            &aggregate_public_key,
-        )? {
-            return Err(BlockValidateReject {
-                reason:
-                    "Stacker signature does not match aggregate pubkey for current stacking cycle"
-                        .into(),
-                reason_code: ValidateRejectCode::InvalidBlock,
-            });
-        }
-
         // Stage 3: Validate txs against chainstate
         let parent_stacks_header = NakamotoChainState::get_block_header(
             chainstate.db(),
@@ -359,17 +326,7 @@ impl RPCBlockProposalRequestHandler {
         Self::default()
     }
 
-    /// Decode a bare transaction from the body
-    fn parse_octets(mut body: &[u8]) -> Result<NakamotoBlockProposal, Error> {
-        NakamotoBlockProposal::consensus_deserialize(&mut body).map_err(|e| match e {
-            CodecError::DeserializeError(msg) => {
-                Error::DecodeError(format!("Failed to deserialize posted transaction: {msg}"))
-            }
-            _ => e.into(),
-        })
-    }
-
-    /// Decode a JSON-encoded transaction
+    /// Decode a JSON-encoded block proposal
     fn parse_json(body: &[u8]) -> Result<NakamotoBlockProposal, Error> {
         serde_json::from_slice(body)
             .map_err(|e| Error::DecodeError(format!("Failed to parse body: {e}")))
@@ -408,7 +365,8 @@ impl HttpRequest for RPCBlockProposalRequestHandler {
 
         if preamble.get_content_length() == 0 {
             return Err(Error::DecodeError(
-                "Invalid Http request: expected non-zero-length body for PostBlock".to_string(),
+                "Invalid Http request: expected non-zero-length body for block proposal endpoint"
+                    .to_string(),
             ));
         }
 
@@ -419,16 +377,15 @@ impl HttpRequest for RPCBlockProposalRequestHandler {
         }
 
         let block_proposal = match preamble.content_type {
-            Some(HttpContentType::Bytes) => Self::parse_octets(body)?,
             Some(HttpContentType::JSON) => Self::parse_json(body)?,
             None => {
                 return Err(Error::DecodeError(
-                    "Missing Content-Type for transaction".to_string(),
+                    "Missing Content-Type for block proposal".to_string(),
                 ))
             }
             _ => {
                 return Err(Error::DecodeError(
-                    "Wrong Content-Type for transaction; expected application/json or application/octet-stream".to_string(),
+                    "Wrong Content-Type for block proposal; expected application/json".to_string(),
                 ))
             }
         };
@@ -530,20 +487,3 @@ impl HttpResponse for RPCBlockProposalRequestHandler {
         HttpResponsePayload::try_from_json(response)
     }
 }
-
-impl StacksHttpRequest {
-    /// Make a new post-block request
-    #[cfg(test)]
-    pub fn new_post_block_proposal(
-        host: PeerHost,
-        proposal: &NakamotoBlockProposal,
-    ) -> StacksHttpRequest {
-        StacksHttpRequest::new_for_peer(
-            host,
-            "POST".into(),
-            "/v2/block_proposal".into(),
-            HttpRequestContents::new().payload_stacks(proposal),
-        )
-        .expect("FATAL: failed to construct request from infallible data")
-    }
-}
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 7e6a00036f..d72914d047 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -1082,7 +1082,6 @@ fn block_proposal_api_endpoint() {
         .unwrap();
 
     let privk = conf.miner.mining_key.unwrap().clone();
-    // TODO: Get current `total_burn` from somewhere
     let sort_tip = SortitionDB::get_canonical_sortition_tip(sortdb.conn())
         .expect("Failed to get sortition tip");
     let db_handle = sortdb.index_handle(&sort_tip);
@@ -1203,16 +1202,6 @@ fn block_proposal_api_endpoint() {
             HTTP_ACCEPTED,
             Some(Err(ValidateRejectCode::ChainstateError)),
         ),
-        (
-            "Invalid `signer_signature`",
-            (|| {
-                let mut sp = sign(proposal.clone());
-                sp.block.header.signer_signature = ThresholdSignature::mock();
-                sp
-            })(),
-            HTTP_ACCEPTED,
-            Some(Err(ValidateRejectCode::InvalidBlock)),
-        ),
     ];
 
     // Build HTTP client
@@ -1228,9 +1217,6 @@ fn block_proposal_api_endpoint() {
     for (ix, (test_description, block_proposal, expected_http_code, _)) in
         test_cases.iter().enumerate()
     {
-        eprintln!("block_proposal_api_endpoint(): {test_description}");
-        eprintln!("block_proposal={block_proposal:?}");
-
         // Send POST request
         let mut response = client
             .post(&path)
@@ -1256,8 +1242,14 @@ fn block_proposal_api_endpoint() {
 
         let response_code = response.status().as_u16();
         let response_json = response.json::<serde_json::Value>();
-        eprintln!("Response JSON: {response_json:?}");
-        eprintln!("Response STATUS: {response_code}");
+
+        info!(
+            "Block proposal submitted and checked for HTTP response";
+            "response_json" => %response_json.unwrap(),
+            "request_json" => serde_json::to_string(block_proposal).unwrap(),
+            "response_code" => response_code,
+            "test_description" => test_description,
+        );
 
         assert_eq!(response_code, *expected_http_code);
 
@@ -1301,7 +1293,7 @@ fn block_proposal_api_endpoint() {
                 ));
             }
         }
-        info!("Proposal response: {response:?}");
+        info!("Proposal response {response:?}");
     }
 
     // Clean up
diff --git a/testnet/stacks-node/src/tests/neon_integrations.rs b/testnet/stacks-node/src/tests/neon_integrations.rs
index c41889ee2b..2bee326418 100644
--- a/testnet/stacks-node/src/tests/neon_integrations.rs
+++ b/testnet/stacks-node/src/tests/neon_integrations.rs
@@ -202,6 +202,7 @@ pub mod test_observer {
     async fn handle_proposal_response(
         response: serde_json::Value,
     ) -> Result<impl warp::Reply, Infallible> {
+        info!("Proposal response received"; "response" => %response);
         PROPOSAL_RESPONSES.lock().unwrap().push(
             serde_json::from_value(response)
                 .expect("Failed to deserialize JSON into BlockValidateResponse"),

From 96c4f9bc1f5ed57021917ae9e80736c8ef85ad0d Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Sat, 6 Jan 2024 13:29:04 -0600
Subject: [PATCH 0306/1166] fix openapi error

---
 docs/rpc/openapi.yaml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/rpc/openapi.yaml b/docs/rpc/openapi.yaml
index 7f23276cee..02c8dcdfdf 100644
--- a/docs/rpc/openapi.yaml
+++ b/docs/rpc/openapi.yaml
@@ -577,7 +577,7 @@ paths:
           content:
             application/json:
               example:
-                $ref: ./api/core-node/post-block-proposal-429.example.json
+                $ref: ./api/core-node/post-block-proposal-response.429.json
       requestBody:
         content:
           application/json:

From dc82c12a2a4a8326751c8902e10908cca3785445 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Mon, 8 Jan 2024 12:49:52 -0600
Subject: [PATCH 0307/1166] address PR reviews

---
 docs/rpc/openapi.yaml                       |  2 +-
 stackslib/src/net/api/postblock_proposal.rs | 12 ++++++------
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/docs/rpc/openapi.yaml b/docs/rpc/openapi.yaml
index 02c8dcdfdf..d554b96242 100644
--- a/docs/rpc/openapi.yaml
+++ b/docs/rpc/openapi.yaml
@@ -564,7 +564,7 @@ paths:
         **This endpoint will only accept requests over the local loopback network interface.**
       responses:
         202:
-          description: Block proposal is valid
+          description: Block proposal has been accepted for processing. The result will be returned via the event observer.
           content:
             application/json:
               example:
diff --git a/stackslib/src/net/api/postblock_proposal.rs b/stackslib/src/net/api/postblock_proposal.rs
index 872d1343bf..b2416d7a6e 100644
--- a/stackslib/src/net/api/postblock_proposal.rs
+++ b/stackslib/src/net/api/postblock_proposal.rs
@@ -193,7 +193,7 @@ impl NakamotoBlockProposal {
         let expected_burn =
             NakamotoChainState::get_expected_burns(&mut db_handle, chainstate.db(), &self.block)?;
 
-        // Stage 1: Static validation checks
+        // Static validation checks
         NakamotoChainState::validate_nakamoto_block_burnchain(
             &db_handle,
             expected_burn,
@@ -202,7 +202,7 @@ impl NakamotoBlockProposal {
             self.chain_id,
         )?;
 
-        // Stage 3: Validate txs against chainstate
+        // Validate txs against chainstate
         let parent_stacks_header = NakamotoChainState::get_block_header(
             chainstate.db(),
             &self.block.header.parent_block_id,
@@ -378,14 +378,14 @@ impl HttpRequest for RPCBlockProposalRequestHandler {
 
         let block_proposal = match preamble.content_type {
             Some(HttpContentType::JSON) => Self::parse_json(body)?,
-            None => {
+            Some(_) => {
                 return Err(Error::DecodeError(
-                    "Missing Content-Type for block proposal".to_string(),
+                    "Wrong Content-Type for block proposal; expected application/json".to_string(),
                 ))
             }
-            _ => {
+            None => {
                 return Err(Error::DecodeError(
-                    "Wrong Content-Type for block proposal; expected application/json".to_string(),
+                    "Missing Content-Type for block proposal".to_string(),
                 ))
             }
         };

From 13f71976d5d5fc8f68128defa6fac72f0f9c8290 Mon Sep 17 00:00:00 2001
From: ASuciuX <asuciu@hiro.so>
Date: Tue, 9 Jan 2024 01:08:22 +0200
Subject: [PATCH 0308/1166] feat: shorter names for steps

---
 .github/workflows/pr-differences-mutants.yml | 27 +++++++++++---------
 1 file changed, 15 insertions(+), 12 deletions(-)

diff --git a/.github/workflows/pr-differences-mutants.yml b/.github/workflows/pr-differences-mutants.yml
index 61ec540b65..f97cf00e9f 100644
--- a/.github/workflows/pr-differences-mutants.yml
+++ b/.github/workflows/pr-differences-mutants.yml
@@ -29,17 +29,19 @@ jobs:
       small_packages_with_shards: ${{ steps.check_packages_and_shards.outputs.small_packages_with_shards }}
 
     steps:
-      - uses: actions/checkout@v3
+      - name: Checkout repo
+        uses: actions/checkout@v3
         with:
           fetch-depth: 0
 
-      - run: cargo install --version 23.12.2 cargo-mutants
+      - name: Install cargo-mutants
+        run: cargo install --version 23.12.2 cargo-mutants
 
       - name: Relative diff
         run: |
           git diff origin/${{ github.base_ref }}.. > git.diff
 
-      - name: Remove deleted file's lines from git.diff file
+      - name: Update git diff
         run: |
           input_file="git.diff"
           temp_file="temp_diff_file.diff"
@@ -57,7 +59,7 @@ jobs:
             !in_block
           ' "$input_file" > "$temp_file" && mv "$temp_file" "$input_file"
 
-      - name: Split diffs into big and small packages
+      - name: Split diffs
         run: |
           cargo mutants --in-diff git.diff --list > all_mutants.txt
           mkdir -p mutants_by_packages
@@ -72,7 +74,8 @@ jobs:
             fi
           done < all_mutants.txt
 
-      - id: check_packages_and_shards
+      - name: Check packages and shards
+        id: check_packages_and_shards
         run: |
           number_of_big_mutants=0
           number_of_small_mutants=0
@@ -129,7 +132,7 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - name: Run pr differences mutants from actions - no shards, small packages
+      - name: Run mutants on diffs
         uses: stacks-network/actions/mutation-testing/pr-differences@feat/mutation-testing
         with:
           package-dimension: "small"
@@ -150,7 +153,7 @@ jobs:
         shard: [0, 1, 2, 3]
 
     steps:
-      - name: Run pr differences mutants from actions - with shards, small packages
+      - name: Run mutants on diffs
         uses: stacks-network/actions/mutation-testing/pr-differences@feat/mutation-testing
         with:
           shard: ${{ matrix.shard }}
@@ -167,7 +170,7 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - name: Run pr differences mutants from actions - no shards, big packages
+      - name: Run Run mutants on diffs
         env:
           BITCOIND_TEST: 1
           RUST_BACKTRACE: full
@@ -191,7 +194,7 @@ jobs:
         shard: [0, 1, 2, 3, 4, 5, 6, 7]
 
     steps:
-      - name: Run pr differences mutants from actions - with shards, big packages
+      - name: Run mutants on diffs
         env:
           BITCOIND_TEST: 1
           RUST_BACKTRACE: full
@@ -216,10 +219,10 @@ jobs:
       ]
 
     steps:
-      - name: Download all workflow run artifacts
+      - name: Download artifacts
         uses: actions/download-artifact@v3
 
-      - name: Append output from all shards
+      - name: Append output from shards
         run: |
           folders=("mutants-shard-big--1" "mutants-shard-big-0" "mutants-shard-big-1" "mutants-shard-big-2" "mutants-shard-big-3" "mutants-shard-big-4" "mutants-shard-big-5" "mutants-shard-big-6" "mutants-shard-big-7" "mutants-shard-small--1" "mutants-shard-small-0" "mutants-shard-small-1" "mutants-shard-small-2" "mutants-shard-small-3")
           files=("missed.txt" "caught.txt" "timeout.txt" "unviable.txt")
@@ -263,7 +266,7 @@ jobs:
 
           echo "$most_relevant_exit_code" > './mutants-shards/exit_code.txt'
 
-      - name: Print mutants and handle exit codes
+      - name: Print mutants
         run: |
           server_url="${{ github.server_url }}"
           organisation="${{ github.repository_owner }}"

From 921a01dd161ba8f2d0c204c2d07814c7949ded50 Mon Sep 17 00:00:00 2001
From: ASuciuX <asuciu@hiro.so>
Date: Tue, 9 Jan 2024 01:41:29 +0200
Subject: [PATCH 0309/1166] feat: check if `tac`, `awk` and `sed` commands
 exist on host

---
 .github/workflows/pr-differences-mutants.yml | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/.github/workflows/pr-differences-mutants.yml b/.github/workflows/pr-differences-mutants.yml
index f97cf00e9f..a392d0f73e 100644
--- a/.github/workflows/pr-differences-mutants.yml
+++ b/.github/workflows/pr-differences-mutants.yml
@@ -46,6 +46,11 @@ jobs:
           input_file="git.diff"
           temp_file="temp_diff_file.diff"
 
+          # Check if the commands exist on the host
+          for cmd in tac awk sed; do
+            command -v "${cmd}" > /dev/null 2>&1 || echo "Missing command: ${cmd}"
+          done
+
           # Reverse the file, remove 4 lines after '+++ /dev/null', then reverse it back (editors can't go backwards - to remove lines above)
           tac "$input_file" > "$temp_file" && mv "$temp_file" "$input_file"
           sed '/+++ \/dev\/null/{n;N;N;N;d;}' "$input_file" > "$temp_file" && mv "$temp_file" "$input_file"

From c6927a72233cd59ab43b9fdfdee1589b7bac1630 Mon Sep 17 00:00:00 2001
From: ASuciuX <asuciu@hiro.so>
Date: Tue, 9 Jan 2024 02:06:27 +0200
Subject: [PATCH 0310/1166] feat: check files before accessing them

---
 .github/workflows/pr-differences-mutants.yml | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/pr-differences-mutants.yml b/.github/workflows/pr-differences-mutants.yml
index a392d0f73e..d2aed12962 100644
--- a/.github/workflows/pr-differences-mutants.yml
+++ b/.github/workflows/pr-differences-mutants.yml
@@ -69,6 +69,12 @@ jobs:
           cargo mutants --in-diff git.diff --list > all_mutants.txt
           mkdir -p mutants_by_packages
 
+          # Check that the file exists before performing actions on it
+          if [ -s all_mutants.txt ]; then
+            echo "The file containing mutants is missing or empty!"
+            exit 1
+          fi
+
           # Split the differences from git into 2 parts, big packages ('stacks-node' and 'stackslib') and small packages (all others) and put them into separate files
           while IFS= read -r line; do
             package=$(echo "$line" | cut -d'/' -f1)
@@ -242,7 +248,7 @@ jobs:
           done
 
           for folder in "${folders[@]}"; do
-            if [[ -s "$folder" ]]; then
+            if [[ -s "$folder/exit_code.txt" ]]; then
               exit_code=$(<"${folder}/exit_code.txt")
               most_relevant_exit_code=0
 
@@ -346,7 +352,7 @@ jobs:
 
           case $exit_code in
             0)
-                if [ -s ./mutants-shards/unviable.txt ]; then
+                if [[ -f ./mutants-shards/unviable.txt ]]; then
                   echo "Found unviable mutants!"
                   exit 1
                 fi

From 0ac3ff0f178dbc76497574c5ead2a72c817349e6 Mon Sep 17 00:00:00 2001
From: friedger <mail@friedger.de>
Date: Tue, 9 Jan 2024 15:34:46 +0100
Subject: [PATCH 0311/1166] chore: simplify constants

---
 stackslib/src/chainstate/stacks/boot/mod.rs     |  3 +--
 stackslib/src/chainstate/stacks/boot/pox-4.clar | 14 +++++++-------
 stackslib/src/clarity_vm/clarity.rs             |  9 ++-------
 3 files changed, 10 insertions(+), 16 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 25df4d5dca..aa8bbd313b 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -102,8 +102,7 @@ lazy_static! {
         format!("{}\n{}", BOOT_CODE_POX_MAINNET_CONSTS, POX_3_BODY);
     pub static ref POX_3_TESTNET_CODE: String =
         format!("{}\n{}", BOOT_CODE_POX_TESTNET_CONSTS, POX_3_BODY);
-    pub static ref POX_4_MAINNET_CODE: String = format!("{}", POX_4_BODY);
-    pub static ref POX_4_TESTNET_CODE: String = format!("{}", POX_4_BODY);
+    pub static ref POX_4_CODE: String = format!("{}", POX_4_BODY);
     pub static ref BOOT_CODE_COST_VOTING_TESTNET: String = make_testnet_cost_voting();
     pub static ref STACKS_BOOT_CODE_MAINNET: [(&'static str, &'static str); 6] = [
         ("pox", &BOOT_CODE_POX_MAINNET),
diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index ba54a8d4c8..89ffded0ca 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -34,13 +34,13 @@
 ;; These first four correspond to address hash modes in Stacks 2.1,
 ;; and are defined in pox-mainnet.clar and pox-testnet.clar (so they
 ;; cannot be defined here again).
-;; (define-constant ADDRESS_VERSION_P2PKH 0x00)
-;; (define-constant ADDRESS_VERSION_P2SH 0x01)
-;; (define-constant ADDRESS_VERSION_P2WPKH 0x02)
-;; (define-constant ADDRESS_VERSION_P2WSH 0x03)
-;; (define-constant ADDRESS_VERSION_NATIVE_P2WPKH 0x04)
-;; (define-constant ADDRESS_VERSION_NATIVE_P2WSH 0x05)
-;; (define-constant ADDRESS_VERSION_NATIVE_P2TR 0x06)
+(define-constant ADDRESS_VERSION_P2PKH 0x00)
+(define-constant ADDRESS_VERSION_P2SH 0x01)
+(define-constant ADDRESS_VERSION_P2WPKH 0x02)
+(define-constant ADDRESS_VERSION_P2WSH 0x03)
+(define-constant ADDRESS_VERSION_NATIVE_P2WPKH 0x04)
+(define-constant ADDRESS_VERSION_NATIVE_P2WSH 0x05)
+(define-constant ADDRESS_VERSION_NATIVE_P2TR 0x06)
 ;; Keep these constants in lock-step with the address version buffs above
 ;; Maximum value of an address version as a uint
 (define-constant MAX_ADDRESS_VERSION u6)
diff --git a/stackslib/src/clarity_vm/clarity.rs b/stackslib/src/clarity_vm/clarity.rs
index 534183ba87..20af5cbc89 100644
--- a/stackslib/src/clarity_vm/clarity.rs
+++ b/stackslib/src/clarity_vm/clarity.rs
@@ -48,7 +48,7 @@ use crate::chainstate::stacks::boot::{
     BOOT_CODE_COST_VOTING_TESTNET as BOOT_CODE_COST_VOTING, BOOT_CODE_POX_TESTNET,
     BOOT_TEST_POX_4_AGG_KEY_CONTRACT, BOOT_TEST_POX_4_AGG_KEY_FNAME, COSTS_2_NAME, COSTS_3_NAME,
     POX_2_MAINNET_CODE, POX_2_NAME, POX_2_TESTNET_CODE, POX_3_MAINNET_CODE, POX_3_NAME,
-    POX_3_TESTNET_CODE, POX_4_MAINNET_CODE, POX_4_NAME, POX_4_TESTNET_CODE,
+    POX_3_TESTNET_CODE, POX_4_CODE, POX_4_NAME,
 };
 use crate::chainstate::stacks::db::{StacksAccount, StacksChainState};
 use crate::chainstate::stacks::events::{StacksTransactionEvent, StacksTransactionReceipt};
@@ -1322,12 +1322,7 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
                 stx_balance: STXBalance::zero(),
             };
 
-            let pox_4_code = if mainnet {
-                &*POX_4_MAINNET_CODE
-            } else {
-                &*POX_4_TESTNET_CODE
-            };
-
+            let pox_4_code = &*POX_4_MAINNET_CODE;
             let pox_4_contract_id = boot_code_id(POX_4_NAME, mainnet);
 
             let payload = TransactionPayload::SmartContract(

From 23ef4ce8394764757b5d6ebcaa7895bcbbf0979f Mon Sep 17 00:00:00 2001
From: CharlieC3 <2747302+CharlieC3@users.noreply.github.com>
Date: Tue, 9 Jan 2024 11:18:39 -0500
Subject: [PATCH 0312/1166] chore: update default testnet hiro bootstrap node

---
 testnet/stacks-node/conf/testnet-follower-conf.toml | 2 +-
 testnet/stacks-node/conf/testnet-miner-conf.toml    | 2 +-
 testnet/stacks-node/src/config.rs                   | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/testnet/stacks-node/conf/testnet-follower-conf.toml b/testnet/stacks-node/conf/testnet-follower-conf.toml
index 6872666a2c..cb23477b27 100644
--- a/testnet/stacks-node/conf/testnet-follower-conf.toml
+++ b/testnet/stacks-node/conf/testnet-follower-conf.toml
@@ -2,7 +2,7 @@
 # working_dir = "/dir/to/save/chainstate"
 rpc_bind = "0.0.0.0:20443"
 p2p_bind = "0.0.0.0:20444"
-bootstrap_node = "029266faff4c8e0ca4f934f34996a96af481df94a89b0c9bd515f3536a95682ddc@seed.testnet.hiro.so:20444"
+bootstrap_node = "029266faff4c8e0ca4f934f34996a96af481df94a89b0c9bd515f3536a95682ddc@seed.testnet.hiro.so:30444"
 wait_time_for_microblocks = 10000
 
 [burnchain]
diff --git a/testnet/stacks-node/conf/testnet-miner-conf.toml b/testnet/stacks-node/conf/testnet-miner-conf.toml
index 379cbd3822..ca52b33a23 100644
--- a/testnet/stacks-node/conf/testnet-miner-conf.toml
+++ b/testnet/stacks-node/conf/testnet-miner-conf.toml
@@ -5,7 +5,7 @@ p2p_bind = "0.0.0.0:20444"
 seed = "<YOUR_SEED>"
 local_peer_seed = "<YOUR_SEED>"
 miner = true
-bootstrap_node = "029266faff4c8e0ca4f934f34996a96af481df94a89b0c9bd515f3536a95682ddc@seed.testnet.hiro.so:20444"
+bootstrap_node = "029266faff4c8e0ca4f934f34996a96af481df94a89b0c9bd515f3536a95682ddc@seed.testnet.hiro.so:30444"
 wait_time_for_microblocks = 10000
 
 [burnchain]
diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index e8bb392cfd..bb1c4e91d1 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -203,7 +203,7 @@ impl ConfigFile {
         };
 
         let node = NodeConfigFile {
-            bootstrap_node: Some("029266faff4c8e0ca4f934f34996a96af481df94a89b0c9bd515f3536a95682ddc@seed.testnet.hiro.so:20444".to_string()),
+            bootstrap_node: Some("029266faff4c8e0ca4f934f34996a96af481df94a89b0c9bd515f3536a95682ddc@seed.testnet.hiro.so:30444".to_string()),
             miner: Some(false),
             ..NodeConfigFile::default()
         };

From ec243648b3476ba0dc9c59b4edd14b9842d6a439 Mon Sep 17 00:00:00 2001
From: CharlieC3 <2747302+CharlieC3@users.noreply.github.com>
Date: Tue, 9 Jan 2024 11:18:39 -0500
Subject: [PATCH 0313/1166] chore: update default testnet hiro bootstrap node

---
 testnet/stacks-node/conf/testnet-follower-conf.toml | 2 +-
 testnet/stacks-node/conf/testnet-miner-conf.toml    | 2 +-
 testnet/stacks-node/src/config.rs                   | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/testnet/stacks-node/conf/testnet-follower-conf.toml b/testnet/stacks-node/conf/testnet-follower-conf.toml
index 6872666a2c..cb23477b27 100644
--- a/testnet/stacks-node/conf/testnet-follower-conf.toml
+++ b/testnet/stacks-node/conf/testnet-follower-conf.toml
@@ -2,7 +2,7 @@
 # working_dir = "/dir/to/save/chainstate"
 rpc_bind = "0.0.0.0:20443"
 p2p_bind = "0.0.0.0:20444"
-bootstrap_node = "029266faff4c8e0ca4f934f34996a96af481df94a89b0c9bd515f3536a95682ddc@seed.testnet.hiro.so:20444"
+bootstrap_node = "029266faff4c8e0ca4f934f34996a96af481df94a89b0c9bd515f3536a95682ddc@seed.testnet.hiro.so:30444"
 wait_time_for_microblocks = 10000
 
 [burnchain]
diff --git a/testnet/stacks-node/conf/testnet-miner-conf.toml b/testnet/stacks-node/conf/testnet-miner-conf.toml
index 379cbd3822..ca52b33a23 100644
--- a/testnet/stacks-node/conf/testnet-miner-conf.toml
+++ b/testnet/stacks-node/conf/testnet-miner-conf.toml
@@ -5,7 +5,7 @@ p2p_bind = "0.0.0.0:20444"
 seed = "<YOUR_SEED>"
 local_peer_seed = "<YOUR_SEED>"
 miner = true
-bootstrap_node = "029266faff4c8e0ca4f934f34996a96af481df94a89b0c9bd515f3536a95682ddc@seed.testnet.hiro.so:20444"
+bootstrap_node = "029266faff4c8e0ca4f934f34996a96af481df94a89b0c9bd515f3536a95682ddc@seed.testnet.hiro.so:30444"
 wait_time_for_microblocks = 10000
 
 [burnchain]
diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index c7b47f2aad..d2c152478e 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -206,7 +206,7 @@ impl ConfigFile {
         };
 
         let node = NodeConfigFile {
-            bootstrap_node: Some("029266faff4c8e0ca4f934f34996a96af481df94a89b0c9bd515f3536a95682ddc@seed.testnet.hiro.so:20444".to_string()),
+            bootstrap_node: Some("029266faff4c8e0ca4f934f34996a96af481df94a89b0c9bd515f3536a95682ddc@seed.testnet.hiro.so:30444".to_string()),
             miner: Some(false),
             ..NodeConfigFile::default()
         };

From c77969b0a320a76ee3e85a37d8ba36914fd8f2b2 Mon Sep 17 00:00:00 2001
From: friedger <mail@friedger.de>
Date: Wed, 20 Sep 2023 10:53:37 +0200
Subject: [PATCH 0314/1166] feat: add check-not-prepare-phase to pox-4

chore: add check for stacking during prepare phase

chore: re-add deleted code

feat: add revoke-delegate-stx event

chore: re-add deleted code

feat: add check for delegation state in revoke-delegate-stx

chore: move revoke tests to pox-4

chore: add test for revoke event

chore: fmt

feat: revoke-delegate-stx fails also after expiry

fix: use correct type

fix: make revoke-delegate-stx event backwards compatible

chore: revert unwanted changes

chore: remove unwanted changes
---
 pox-locking/src/events.rs                     |  50 ++++--
 pox-locking/src/pox_2.rs                      |   1 +
 pox-locking/src/pox_3.rs                      |   1 +
 pox-locking/src/pox_4.rs                      |   1 +
 .../src/chainstate/stacks/boot/pox_3_tests.rs |   2 +-
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 158 ++++++++++++++++++
 6 files changed, 201 insertions(+), 12 deletions(-)

diff --git a/pox-locking/src/events.rs b/pox-locking/src/events.rs
index c9865961dd..32909f47b1 100644
--- a/pox-locking/src/events.rs
+++ b/pox-locking/src/events.rs
@@ -17,7 +17,7 @@
 use clarity::vm::ast::ASTRules;
 use clarity::vm::contexts::GlobalContext;
 use clarity::vm::errors::Error as ClarityError;
-use clarity::vm::types::{PrincipalData, QualifiedContractIdentifier, TupleData};
+use clarity::vm::types::{PrincipalData, QualifiedContractIdentifier, ResponseData, TupleData};
 use clarity::vm::Value;
 #[cfg(test)]
 use slog::slog_debug;
@@ -31,9 +31,11 @@ use stacks_common::{error, test_debug};
 /// - for delegate stacking functions, it's the first argument
 fn get_stacker(sender: &PrincipalData, function_name: &str, args: &[Value]) -> Value {
     match function_name {
-        "stack-stx" | "stack-increase" | "stack-extend" | "delegate-stx" => {
-            Value::Principal(sender.clone())
-        }
+        "stack-stx"
+        | "stack-increase"
+        | "stack-extend"
+        | "delegate-stx"
+        | "revoke-delegate-stx" => Value::Principal(sender.clone()),
         _ => args[0].clone(),
     }
 }
@@ -100,7 +102,11 @@ fn create_event_info_aggregation_code(function_name: &str) -> String {
 }
 
 /// Craft the code snippet to generate the method-specific `data` payload
-fn create_event_info_data_code(function_name: &str, args: &[Value]) -> String {
+fn create_event_info_data_code(
+    function_name: &str,
+    args: &[Value],
+    response: &ResponseData,
+) -> String {
     match function_name {
         "stack-stx" => {
             format!(
@@ -335,11 +341,31 @@ fn create_event_info_data_code(function_name: &str, args: &[Value]) -> String {
                 pox_addr = &args[3],
             )
         }
-        _ => "{{ data: {{ unimplemented: true }} }}".into(),
+        "revoke-delegate-stx" => {
+            if let Value::Optional(opt) = *response.data.clone() {
+                format!(
+                    r#"
+                    {{
+                        data: {{ delegate-to: '{delegate_to} }}
+                    }}
+                    "#,
+                    delegate_to = opt
+                        .data
+                        .map(|boxed_value| *boxed_value)
+                        .unwrap()
+                        .expect_tuple()
+                        .get("delegated-to")
+                        .unwrap()
+                )
+            } else {
+                "{data: {unimplemented: true}}".into()
+            }
+        }
+        _ => "{data: {unimplemented: true}}".into(),
     }
 }
 
-/// Synthesize an events data tuple to return on the successful execution of a pox-2 or pox-3 stacking
+/// Synthesize an events data tuple to return on the successful execution of a pox-2 or pox-3 or pox-4 stacking
 /// function.  It runs a series of Clarity queries against the PoX contract's data space (including
 /// calling PoX functions).
 pub fn synthesize_pox_event_info(
@@ -348,6 +374,7 @@ pub fn synthesize_pox_event_info(
     sender_opt: Option<&PrincipalData>,
     function_name: &str,
     args: &[Value],
+    response: &ResponseData,
 ) -> Result<Option<Value>, ClarityError> {
     let sender = match sender_opt {
         Some(sender) => sender,
@@ -362,7 +389,8 @@ pub fn synthesize_pox_event_info(
         | "delegate-stack-extend"
         | "stack-increase"
         | "delegate-stack-increase"
-        | "delegate-stx" => Some(create_event_info_stack_or_delegate_code(
+        | "delegate-stx"
+        | "revoke-delegate-stx" => Some(create_event_info_stack_or_delegate_code(
             sender,
             function_name,
             args,
@@ -377,12 +405,12 @@ pub fn synthesize_pox_event_info(
         None => return Ok(None),
     };
 
-    let data_snippet = create_event_info_data_code(function_name, args);
+    let data_snippet = create_event_info_data_code(function_name, args, response);
 
     test_debug!("Evaluate snippet:\n{}", &code_snippet);
     test_debug!("Evaluate data code:\n{}", &data_snippet);
 
-    let pox_2_contract = global_context
+    let pox_contract = global_context
         .database
         .get_contract(contract_id)
         .expect("FATAL: could not load PoX contract metadata");
@@ -391,7 +419,7 @@ pub fn synthesize_pox_event_info(
         .special_cc_handler_execute_read_only(
             sender.clone(),
             None,
-            pox_2_contract.contract_context,
+            pox_contract.contract_context,
             |env| {
                 let base_event_info = env
                     .eval_read_only_with_rules(contract_id, &code_snippet, ASTRules::PrecheckSize)
diff --git a/pox-locking/src/pox_2.rs b/pox-locking/src/pox_2.rs
index 551af09a88..78530fa822 100644
--- a/pox-locking/src/pox_2.rs
+++ b/pox-locking/src/pox_2.rs
@@ -484,6 +484,7 @@ pub fn handle_contract_call(
                 sender_opt,
                 function_name,
                 args,
+                response,
             ) {
                 Ok(Some(event_info)) => Some(event_info),
                 Ok(None) => None,
diff --git a/pox-locking/src/pox_3.rs b/pox-locking/src/pox_3.rs
index cdfd0c740c..d09f5c385d 100644
--- a/pox-locking/src/pox_3.rs
+++ b/pox-locking/src/pox_3.rs
@@ -393,6 +393,7 @@ pub fn handle_contract_call(
                 sender_opt,
                 function_name,
                 args,
+                response,
             ) {
                 Ok(Some(event_info)) => Some(event_info),
                 Ok(None) => None,
diff --git a/pox-locking/src/pox_4.rs b/pox-locking/src/pox_4.rs
index 9fec335bf7..b21df2408f 100644
--- a/pox-locking/src/pox_4.rs
+++ b/pox-locking/src/pox_4.rs
@@ -344,6 +344,7 @@ pub fn handle_contract_call(
                 sender_opt,
                 function_name,
                 args,
+                response,
             ) {
                 Ok(Some(event_info)) => Some(event_info),
                 Ok(None) => None,
diff --git a/stackslib/src/chainstate/stacks/boot/pox_3_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_3_tests.rs
index fe41632f6e..dfe23eb0e2 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_3_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_3_tests.rs
@@ -3106,7 +3106,7 @@ fn pox_3_getters() {
         tip.block_height,
     );
 
-    // bob deleates to charlie
+    // bob delegates to charlie
     let bob_delegate_tx = make_pox_3_contract_call(
         &bob,
         0,
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 3fd4ee1736..9de1b3789e 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -1181,6 +1181,164 @@ fn pox_3_unlocks() {
     }
 }
 
+// test that revoke-delegate-stx calls emit an event and
+// test that revoke-delegate-stx is only successfull if user has delegated.
+#[test]
+fn pox_4_revoke_delegate_stx_events() {
+    // Config for this test
+    let (epochs, pox_constants) = make_test_epochs_pox();
+
+    let mut burnchain = Burnchain::default_unittest(
+        0,
+        &BurnchainHeaderHash::from_hex(BITCOIN_REGTEST_FIRST_BLOCK_HASH).unwrap(),
+    );
+    burnchain.pox_constants = pox_constants.clone();
+
+    let observer = TestEventObserver::new();
+
+    let (mut peer, mut keys) = instantiate_pox_peer_with_epoch(
+        &burnchain,
+        function_name!(),
+        Some(epochs.clone()),
+        Some(&observer),
+    );
+
+    assert_eq!(burnchain.pox_constants.reward_slots(), 6);
+    let mut coinbase_nonce = 0;
+    let mut latest_block;
+
+    // alice
+    let alice = keys.pop().unwrap();
+    let alice_address = key_to_stacks_addr(&alice);
+    let alice_principal = PrincipalData::from(alice_address.clone());
+
+    // bob
+    let bob = keys.pop().unwrap();
+    let bob_address = key_to_stacks_addr(&bob);
+    let bob_principal = PrincipalData::from(bob_address.clone());
+    let bob_pox_addr = make_pox_addr(AddressHashMode::SerializeP2PKH, bob_address.bytes.clone());
+
+    let mut alice_nonce = 0;
+
+    // Advance into pox4
+    let target_height = burnchain.pox_constants.pox_4_activation_height;
+    // produce blocks until the first reward phase that everyone should be in
+    while get_tip(peer.sortdb.as_ref()).block_height < u64::from(target_height) {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    }
+
+    info!(
+        "Block height: {}",
+        get_tip(peer.sortdb.as_ref()).block_height
+    );
+
+    // alice delegates 100 STX to Bob
+    let alice_delegation_amount = 100_000_000;
+    let alice_delegate = make_pox_4_delegate_stx(
+        &alice,
+        alice_nonce,
+        alice_delegation_amount,
+        bob_principal,
+        None,
+        None,
+    );
+    let alice_delegate_nonce = alice_nonce;
+    alice_nonce += 1;
+
+    let alice_revoke = make_pox_4_revoke_delegate_stx(&alice, alice_nonce);
+    let alice_revoke_nonce = alice_nonce;
+    alice_nonce += 1;
+
+    let alice_revoke_2 = make_pox_4_revoke_delegate_stx(&alice, alice_nonce);
+    let alice_revoke_2_nonce = alice_nonce;
+    alice_nonce += 1;
+
+    peer.tenure_with_txs(
+        &[alice_delegate, alice_revoke, alice_revoke_2],
+        &mut coinbase_nonce,
+    );
+
+    // check delegate with expiry
+
+    let target_height = get_tip(peer.sortdb.as_ref()).block_height + 10;
+    let alice_delegate_2 = make_pox_4_delegate_stx(
+        &alice,
+        alice_nonce,
+        alice_delegation_amount,
+        PrincipalData::from(bob_address.clone()),
+        Some(target_height as u128),
+        None,
+    );
+    let alice_delegate_2_nonce = alice_nonce;
+    alice_nonce += 1;
+
+    peer.tenure_with_txs(&[alice_delegate_2], &mut coinbase_nonce);
+
+    // produce blocks until delegation expired
+    while get_tip(peer.sortdb.as_ref()).block_height <= u64::from(target_height) {
+        peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    }
+
+    let alice_revoke_3 = make_pox_4_revoke_delegate_stx(&alice, alice_nonce);
+    let alice_revoke_3_nonce = alice_nonce;
+    alice_nonce += 1;
+
+    peer.tenure_with_txs(&[alice_revoke_3], &mut coinbase_nonce);
+
+    let blocks = observer.get_blocks();
+    let mut alice_txs = HashMap::new();
+
+    for b in blocks.into_iter() {
+        for r in b.receipts.into_iter() {
+            if let TransactionOrigin::Stacks(ref t) = r.transaction {
+                let addr = t.auth.origin().address_testnet();
+                if addr == alice_address {
+                    alice_txs.insert(t.auth.get_origin_nonce(), r);
+                }
+            }
+        }
+    }
+    assert_eq!(alice_txs.len() as u64, 5);
+
+    // check event for first revoke delegation tx
+    let revoke_delegation_tx_events = &alice_txs.get(&alice_revoke_nonce).unwrap().clone().events;
+    assert_eq!(revoke_delegation_tx_events.len() as u64, 1);
+    let revoke_delegation_tx_event = &revoke_delegation_tx_events[0];
+    let revoke_delegate_stx_op_data = HashMap::from([(
+        "delegate-to",
+        Value::Principal(PrincipalData::from(bob_address.clone())),
+    )]);
+    let common_data = PoxPrintFields {
+        op_name: "revoke-delegate-stx".to_string(),
+        stacker: alice_principal.clone().into(),
+        balance: Value::UInt(10240000000000),
+        locked: Value::UInt(0),
+        burnchain_unlock_height: Value::UInt(0),
+    };
+    check_pox_print_event(
+        revoke_delegation_tx_event,
+        common_data,
+        revoke_delegate_stx_op_data,
+    );
+
+    // second revoke transaction should fail
+    assert_eq!(
+        &alice_txs[&alice_revoke_2_nonce].result.to_string(),
+        "(err 33)"
+    );
+
+    // second delegate transaction should succeed
+    assert_eq!(
+        &alice_txs[&alice_delegate_2_nonce].result.to_string(),
+        "(ok true)"
+    );
+    // third revoke transaction should fail
+    assert_eq!(
+        &alice_txs[&alice_revoke_3_nonce].result.to_string(),
+        "(err 33)"
+    );
+}
+
 fn assert_latest_was_burn(peer: &mut TestPeer) {
     let tip = get_tip(peer.sortdb.as_ref());
     let tip_index_block = tip.get_canonical_stacks_block_id();

From 712eaafb358efdd9468a5a84781d9ba8e0186f60 Mon Sep 17 00:00:00 2001
From: friedger <mail@friedger.de>
Date: Tue, 9 Jan 2024 18:01:06 +0100
Subject: [PATCH 0315/1166] fix: use correct constant

---
 stackslib/src/clarity_vm/clarity.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stackslib/src/clarity_vm/clarity.rs b/stackslib/src/clarity_vm/clarity.rs
index 20af5cbc89..e18ee76ef6 100644
--- a/stackslib/src/clarity_vm/clarity.rs
+++ b/stackslib/src/clarity_vm/clarity.rs
@@ -1322,7 +1322,7 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
                 stx_balance: STXBalance::zero(),
             };
 
-            let pox_4_code = &*POX_4_MAINNET_CODE;
+            let pox_4_code = &*POX_4_CODE;
             let pox_4_contract_id = boot_code_id(POX_4_NAME, mainnet);
 
             let payload = TransactionPayload::SmartContract(

From 57a8694b9699f7b57423ab4f58f9cff35fae9623 Mon Sep 17 00:00:00 2001
From: friedger <mail@friedger.de>
Date: Tue, 9 Jan 2024 18:13:11 +0100
Subject: [PATCH 0316/1166] chore: add missing method

---
 stackslib/src/chainstate/stacks/boot/mod.rs | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 146bdd1f38..cdd16e8e85 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -1790,6 +1790,18 @@ pub mod test {
         make_tx(key, nonce, 0, payload)
     }
 
+    pub fn make_pox_4_revoke_delegate_stx(key: &StacksPrivateKey, nonce: u64) -> StacksTransaction {
+        let payload = TransactionPayload::new_contract_call(
+            boot_code_test_addr(),
+            POX_4_NAME,
+            "revoke-delegate-stx",
+            vec![],
+        )
+        .unwrap();
+
+        make_tx(key, nonce, 0, payload)
+    }
+
     fn make_tx(
         key: &StacksPrivateKey,
         nonce: u64,

From 204919dfceb86ead5592110a31d69f2cf79085f5 Mon Sep 17 00:00:00 2001
From: friedger <mail@friedger.de>
Date: Tue, 9 Jan 2024 18:45:52 +0100
Subject: [PATCH 0317/1166] fix: add missing function

---
 stackslib/src/chainstate/stacks/boot/mod.rs | 32 +++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index cdd16e8e85..47ed739a56 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -1790,6 +1790,38 @@ pub mod test {
         make_tx(key, nonce, 0, payload)
     }
 
+    pub fn make_pox_4_delegate_stx(
+        key: &StacksPrivateKey,
+        nonce: u64,
+        amount: u128,
+        delegate_to: PrincipalData,
+        until_burn_ht: Option<u128>,
+        pox_addr: Option<PoxAddress>,
+    ) -> StacksTransaction {
+        let payload = TransactionPayload::new_contract_call(
+            boot_code_test_addr(),
+            POX_4_NAME,
+            "delegate-stx",
+            vec![
+                Value::UInt(amount),
+                Value::Principal(delegate_to.clone()),
+                match until_burn_ht {
+                    Some(burn_ht) => Value::some(Value::UInt(burn_ht)).unwrap(),
+                    None => Value::none(),
+                },
+                match pox_addr {
+                    Some(addr) => {
+                        Value::some(Value::Tuple(addr.as_clarity_tuple().unwrap())).unwrap()
+                    }
+                    None => Value::none(),
+                },
+            ],
+        )
+        .unwrap();
+
+        make_tx(key, nonce, 0, payload)
+    }
+
     pub fn make_pox_4_revoke_delegate_stx(key: &StacksPrivateKey, nonce: u64) -> StacksTransaction {
         let payload = TransactionPayload::new_contract_call(
             boot_code_test_addr(),

From a5110392b5079c8d5fdb196dd6c17b90d1a3681e Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Mon, 18 Dec 2023 16:43:50 -0500
Subject: [PATCH 0318/1166] feat: .miners contract

---
 .../src/chainstate/stacks/boot/miners.clar    | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 stackslib/src/chainstate/stacks/boot/miners.clar

diff --git a/stackslib/src/chainstate/stacks/boot/miners.clar b/stackslib/src/chainstate/stacks/boot/miners.clar
new file mode 100644
index 0000000000..2fd9a9e870
--- /dev/null
+++ b/stackslib/src/chainstate/stacks/boot/miners.clar
@@ -0,0 +1,21 @@
+;; This contract governs a StackerDB instance in which the current and previous
+;; miner can send their blocks to Stackers for an aggregate signature.
+;; This is a placeholder smart contract, which allows the node to advertize
+;; that it replicates the state for this StackerDB while maintaining the power
+;; to generate the config and signer slots directly.
+
+;; StackerDB-required method to get the allocation of slots for signers.
+;; The values here are ignored.
+(define-public (stackerdb-get-signer-slots)
+    (ok (list )))
+
+;; StackerDB-required method to get the DB configuration.
+;; The values here are ignored.
+(define-public (stackerdb-get-config)
+    (ok {
+        chunk-size: u0,
+        write-freq: u0,
+        max-writes: u0,
+        max-neighbors: u0,
+        hint-replicas: (list )
+    }))

From e6148b4571caa061bdf914ab1620f2e3fbe12e2d Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Mon, 18 Dec 2023 16:44:05 -0500
Subject: [PATCH 0319/1166] fix: boost chunk size to 16MB, which is the maximum
 block size

---
 libstackerdb/src/libstackerdb.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/libstackerdb/src/libstackerdb.rs b/libstackerdb/src/libstackerdb.rs
index d4ae0740bc..df74075f64 100644
--- a/libstackerdb/src/libstackerdb.rs
+++ b/libstackerdb/src/libstackerdb.rs
@@ -33,8 +33,8 @@ use stacks_common::types::PrivateKey;
 use stacks_common::util::hash::{hex_bytes, to_hex, Hash160, Sha512Trunc256Sum};
 use stacks_common::util::secp256k1::MessageSignature;
 
-/// maximum chunk size (1 MB)
-pub const STACKERDB_MAX_CHUNK_SIZE: u32 = 1024 * 1024;
+/// maximum chunk size (16 MB; same as MAX_PAYLOAD_SIZE)
+pub const STACKERDB_MAX_CHUNK_SIZE: u32 = 16 * 1024 * 1024;
 
 #[cfg(test)]
 mod tests;

From 5ddeb99b9b5e9fc173c4318f4125abe1d5e35395 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Mon, 18 Dec 2023 16:44:56 -0500
Subject: [PATCH 0320/1166] feat: add method to generate a stackerdb chunk for
 the miner

---
 stackslib/src/chainstate/nakamoto/miner.rs | 51 +++++++++++++++++++++-
 1 file changed, 50 insertions(+), 1 deletion(-)

diff --git a/stackslib/src/chainstate/nakamoto/miner.rs b/stackslib/src/chainstate/nakamoto/miner.rs
index 346b2a1ef8..81df48c5ff 100644
--- a/stackslib/src/chainstate/nakamoto/miner.rs
+++ b/stackslib/src/chainstate/nakamoto/miner.rs
@@ -29,7 +29,9 @@ use clarity::vm::costs::ExecutionCost;
 use clarity::vm::database::BurnStateDB;
 use clarity::vm::errors::Error as InterpreterError;
 use clarity::vm::types::TypeSignature;
+use libstackerdb::StackerDBChunkData;
 use serde::Deserialize;
+use stacks_common::codec::{read_next, write_next, Error as CodecError, StacksMessageCodec};
 use stacks_common::types::chainstate::{
     BlockHeaderHash, BurnchainHeaderHash, ConsensusHash, StacksAddress, StacksBlockId, TrieHash,
 };
@@ -62,7 +64,6 @@ use crate::chainstate::stacks::miner::{
 };
 use crate::chainstate::stacks::{Error, StacksBlockHeader, *};
 use crate::clarity_vm::clarity::{ClarityConnection, ClarityInstance};
-use crate::codec::Error as CodecError;
 use crate::core::mempool::*;
 use crate::core::*;
 use crate::cost_estimates::metrics::CostMetric;
@@ -502,6 +503,54 @@ impl NakamotoBlockBuilder {
     pub fn get_bytes_so_far(&self) -> u64 {
         self.bytes_so_far
     }
+
+    /// Make a StackerDB chunk message containing a proposed block.
+    /// Sign it with the miner's private key.
+    /// Automatically determine which StackerDB slot to use.
+    /// Returns Some(chunk) if the given key corresponds to one of the expected miner slots
+    /// Returns None if not
+    /// Returns an error on signing or DB error
+    pub fn make_stackerdb_block_proposal(
+        sortdb: &SortitionDB,
+        write_count: u32,
+        block: &NakamotoBlock,
+        miner_privkey: &StacksPrivateKey,
+    ) -> Result<Option<StackerDBChunkData>, Error> {
+        let miner_pubkey = StacksPublicKey::from_private(&miner_privkey);
+        let miner_hash160 = Hash160::from_node_public_key(&miner_pubkey);
+        let stackerdb_config = NakamotoChainState::make_miners_stackerdb_config(sortdb)?;
+
+        // find out which slot we're in
+        let Some(slot_id_res) =
+            stackerdb_config
+                .signers
+                .iter()
+                .enumerate()
+                .find_map(|(i, (addr, _))| {
+                    if addr.bytes == miner_hash160 {
+                        Some(u32::try_from(i).map_err(|_| {
+                            CodecError::OverflowError(
+                                "stackerdb config slot ID cannot fit into u32".into(),
+                            )
+                        }))
+                    } else {
+                        None
+                    }
+                })
+        else {
+            // miner key does not match any slot
+            return Ok(None);
+        };
+
+        let slot_id = slot_id_res?;
+        let block_bytes = block.serialize_to_vec();
+        let mut chunk =
+            StackerDBChunkData::new(slot_id, write_count.saturating_add(1), block_bytes);
+        chunk
+            .sign(miner_privkey)
+            .map_err(|_| net_error::SigningError("Failed to sign StackerDB chunk".into()))?;
+        Ok(Some(chunk))
+    }
 }
 
 impl BlockBuilder for NakamotoBlockBuilder {

From 1f021000e9f082637d633e475a31dcb34ebba48d Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Mon, 18 Dec 2023 17:33:39 -0500
Subject: [PATCH 0321/1166] chore: log an error if the miner isn't in the
 .miners stackerdb

---
 stackslib/src/chainstate/nakamoto/miner.rs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/stackslib/src/chainstate/nakamoto/miner.rs b/stackslib/src/chainstate/nakamoto/miner.rs
index 81df48c5ff..a2e8695e52 100644
--- a/stackslib/src/chainstate/nakamoto/miner.rs
+++ b/stackslib/src/chainstate/nakamoto/miner.rs
@@ -539,6 +539,10 @@ impl NakamotoBlockBuilder {
                 })
         else {
             // miner key does not match any slot
+            warn!("Miner is not in the miners StackerDB config";
+                  "miner" => %miner_hash160,
+                  "stackerdb_slots" => format!("{:?}", &stackerdb_config.signers));
+
             return Ok(None);
         };
 

From ce5e13bdae0b783a567c1ad6966ce2aefe0712be Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Mon, 18 Dec 2023 17:34:03 -0500
Subject: [PATCH 0322/1166] feat: synthesize a stackerdb config for the .miners
 contract using the sortition DB

---
 stackslib/src/chainstate/nakamoto/mod.rs | 79 ++++++++++++++++++++++++
 1 file changed, 79 insertions(+)

diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index d3a3e26a0f..aeebdf7e42 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -29,6 +29,7 @@ use rusqlite::{params, Connection, OptionalExtension, ToSql, NO_PARAMS};
 use sha2::{Digest as Sha2Digest, Sha512_256};
 use stacks_common::codec::{
     read_next, write_next, Error as CodecError, StacksMessageCodec, MAX_MESSAGE_LEN,
+    MAX_PAYLOAD_LEN,
 };
 use stacks_common::consts::{
     FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH, MINER_REWARD_MATURITY,
@@ -78,6 +79,7 @@ use crate::clarity_vm::clarity::{ClarityInstance, PreCommitClarityBlock};
 use crate::clarity_vm::database::SortitionDBRef;
 use crate::core::BOOT_BLOCK_HASH;
 use crate::monitoring;
+use crate::net::stackerdb::StackerDBConfig;
 use crate::net::Error as net_error;
 use crate::util_lib::boot::boot_code_id;
 use crate::util_lib::db::{
@@ -3047,6 +3049,83 @@ impl NakamotoChainState {
         Ok((epoch_receipt, clarity_commit))
     }
 
+    /// Create a StackerDB config for the .miners contract.
+    /// It has two slots -- one for the past two sortition winners.
+    pub fn make_miners_stackerdb_config(
+        sortdb: &SortitionDB,
+    ) -> Result<StackerDBConfig, ChainstateError> {
+        let tip = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn())?;
+        let ih = sortdb.index_handle(&tip.sortition_id);
+        let last_winner_snapshot = ih.get_last_snapshot_with_sortition(tip.block_height)?;
+        let parent_winner_snapshot = ih.get_last_snapshot_with_sortition(
+            last_winner_snapshot.block_height.saturating_sub(1),
+        )?;
+
+        let mut miner_key_hash160s = vec![];
+
+        // go get their corresponding leader keys, but preserve the miner's relative position in
+        // the stackerdb signer list -- if a miner was in slot 0, then it should stay in slot 0
+        // after a sortition (and vice versa for 1)
+        let sns = if last_winner_snapshot.num_sortitions % 2 == 0 {
+            [last_winner_snapshot, parent_winner_snapshot]
+        } else {
+            [parent_winner_snapshot, last_winner_snapshot]
+        };
+
+        for sn in sns {
+            // find the commit
+            let Some(block_commit) =
+                ih.get_block_commit_by_txid(&sn.sortition_id, &sn.winning_block_txid)?
+            else {
+                warn!(
+                    "No block commit for {} in sortition for {}",
+                    &sn.winning_block_txid, &sn.consensus_hash
+                );
+                return Err(ChainstateError::InvalidStacksBlock(
+                    "No block-commit in sortition for block's consensus hash".into(),
+                ));
+            };
+
+            // key register of the winning miner
+            let leader_key = ih
+                .get_leader_key_at(
+                    u64::from(block_commit.key_block_ptr),
+                    u32::from(block_commit.key_vtxindex),
+                )?
+                .expect("FATAL: have block commit but no leader key");
+
+            // the leader key should always be valid (i.e. the unwrap_or() should be unreachable),
+            // but be defensive and just use the "null" address
+            miner_key_hash160s.push(
+                leader_key
+                    .interpret_nakamoto_signing_key()
+                    .unwrap_or(Hash160([0x00; 20])),
+            );
+        }
+
+        let signers = miner_key_hash160s
+            .into_iter()
+            .map(|hash160|
+                // each miner gets one slot
+                (
+                    StacksAddress {
+                        version: 1, // NOTE: the version is ignored in stackerdb; we only care about the hashbytes
+                        bytes: hash160
+                    },
+                    1
+                ))
+            .collect();
+
+        Ok(StackerDBConfig {
+            chunk_size: MAX_PAYLOAD_LEN.into(),
+            signers,
+            write_freq: 5,
+            max_writes: u32::MAX,  // no limit on number of writes
+            max_neighbors: 200, // TODO: const -- just has to be equal to or greater than the number of signers
+            hint_replicas: vec![], // TODO: is there a way to get the IP addresses of stackers' preferred nodes?
+        })
+    }
+
     /// Boot code instantiation for the aggregate public key.
     /// TODO: This should be removed once it's possible for stackers to vote on the aggregate
     /// public key

From b8aa7e347812beb49b97872b766e8d1d475c1239 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Mon, 18 Dec 2023 17:34:24 -0500
Subject: [PATCH 0323/1166] feat: unit tests for stackerdb config generation
 and stackerdb chunk generation for .miners

---
 .../src/chainstate/nakamoto/tests/mod.rs      | 282 +++++++++++++++++-
 1 file changed, 279 insertions(+), 3 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/tests/mod.rs b/stackslib/src/chainstate/nakamoto/tests/mod.rs
index a494e0be9d..acb8bae85b 100644
--- a/stackslib/src/chainstate/nakamoto/tests/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/mod.rs
@@ -21,10 +21,12 @@ use clarity::types::chainstate::{PoxId, SortitionId, StacksBlockId};
 use clarity::vm::clarity::ClarityConnection;
 use clarity::vm::costs::ExecutionCost;
 use clarity::vm::types::StacksAddressExtensions;
+use stacks_common::address::AddressHashMode;
+use stacks_common::codec::StacksMessageCodec;
 use stacks_common::consts::{FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH};
 use stacks_common::types::chainstate::{
     BlockHeaderHash, BurnchainHeaderHash, ConsensusHash, StacksAddress, StacksPrivateKey,
-    StacksPublicKey, StacksWorkScore, TrieHash,
+    StacksPublicKey, StacksWorkScore, TrieHash, VRFSeed,
 };
 use stacks_common::types::{Address, PrivateKey, StacksEpoch, StacksEpochId};
 use stacks_common::util::get_epoch_time_secs;
@@ -34,15 +36,20 @@ use stacks_common::util::vrf::{VRFPrivateKey, VRFProof, VRFPublicKey, VRF};
 use stdext::prelude::Integer;
 use stx_genesis::GenesisData;
 
-use crate::burnchains::{PoxConstants, Txid};
+use crate::burnchains::{BurnchainSigner, PoxConstants, Txid};
 use crate::chainstate::burn::db::sortdb::tests::make_fork_run;
 use crate::chainstate::burn::db::sortdb::{SortitionDB, SortitionHandleTx};
+use crate::chainstate::burn::operations::leader_block_commit::BURN_BLOCK_MINED_AT_MODULUS;
+use crate::chainstate::burn::operations::{
+    BlockstackOperationType, LeaderBlockCommitOp, LeaderKeyRegisterOp,
+};
 use crate::chainstate::burn::{BlockSnapshot, OpsHash, SortitionHash};
 use crate::chainstate::coordinator::tests::{
     get_burnchain, get_burnchain_db, get_chainstate, get_rw_sortdb, get_sortition_db, p2pkh_from,
     pox_addr_from, setup_states_with_epochs,
 };
 use crate::chainstate::nakamoto::coordinator::tests::boot_nakamoto;
+use crate::chainstate::nakamoto::miner::NakamotoBlockBuilder;
 use crate::chainstate::nakamoto::tenure::NakamotoTenure;
 use crate::chainstate::nakamoto::tests::node::TestSigners;
 use crate::chainstate::nakamoto::{
@@ -59,7 +66,7 @@ use crate::chainstate::stacks::{
     TransactionAnchorMode, TransactionAuth, TransactionPayload, TransactionVersion,
 };
 use crate::core;
-use crate::core::StacksEpochExtension;
+use crate::core::{StacksEpochExtension, STACKS_EPOCH_3_0_MARKER};
 use crate::net::codec::test::check_codec_and_corruption;
 
 /// Get an address's account
@@ -1636,3 +1643,272 @@ pub fn test_get_highest_nakamoto_tenure() {
     assert_eq!(highest_tenure.tenure_index, 3);
     assert_eq!(highest_tenure.num_blocks_confirmed, 10);
 }
+
+/// Test that we can generate a .miners stackerdb config.
+/// The config must be stable across sortitions -- if a miner is given slot i, then it continues
+/// to have slot i in subsequent sortitions.
+#[test]
+fn test_make_miners_stackerdb_config() {
+    let test_signers = TestSigners::default();
+    let mut peer = boot_nakamoto(
+        function_name!(),
+        vec![],
+        test_signers.aggregate_public_key.clone(),
+    );
+
+    let miner_keys: Vec<_> = (3..13).map(|_| StacksPrivateKey::new()).collect();
+    let miner_hash160s: Vec<_> = miner_keys
+        .iter()
+        .map(|miner_privkey| {
+            let miner_pubkey = StacksPublicKey::from_private(miner_privkey);
+            let miner_hash160 = Hash160::from_node_public_key(&miner_pubkey);
+            miner_hash160
+        })
+        .collect();
+    let miner_addrs: Vec<_> = miner_hash160s
+        .iter()
+        .map(|miner_hash160| StacksAddress {
+            version: 1,
+            bytes: miner_hash160.clone(),
+        })
+        .collect();
+
+    debug!("miners = {:#?}", &miner_hash160s);
+
+    // extract chainstate and sortdb -- we don't need the peer anymore
+    let chainstate = &mut peer.stacks_node.as_mut().unwrap().chainstate;
+    let sort_db = peer.sortdb.as_mut().unwrap();
+    let mut last_snapshot = SortitionDB::get_canonical_burn_chain_tip(sort_db.conn()).unwrap();
+
+    // make two leader keys (miner 1 and miner 2)
+    let mut miners = vec![];
+    for i in 3..13 {
+        let vrf_privkey = VRFPrivateKey::new();
+        let vrf_pubkey = VRFPublicKey::from_private(&vrf_privkey);
+        let miner = LeaderKeyRegisterOp {
+            consensus_hash: last_snapshot.consensus_hash.clone(),
+            public_key: vrf_pubkey,
+            memo: miner_hash160s[i - 3].0.to_vec(),
+            txid: Txid([i as u8; 32]),
+            vtxindex: 1 + (i as u32),
+            block_height: last_snapshot.block_height + 1,
+            burn_header_hash: last_snapshot.burn_header_hash.clone(),
+        };
+        miners.push(miner);
+    }
+
+    let mut stackerdb_configs = vec![];
+    let mut stackerdb_chunks = vec![];
+
+    // synthesize some sortitions and corresponding winning block-commits
+    for i in 3..13 {
+        // no winner every 3rd sortition
+        let sortition = i > 3 && i % 3 != 0;
+        let winning_txid = if sortition {
+            Txid([(i as u8); 32])
+        } else {
+            Txid([0x00; 32])
+        };
+        let winning_block_hash = BlockHeaderHash([(i as u8); 32]);
+        let snapshot = BlockSnapshot {
+            accumulated_coinbase_ustx: 0,
+            pox_valid: true,
+            block_height: last_snapshot.block_height + 1,
+            burn_header_timestamp: get_epoch_time_secs(),
+            burn_header_hash: BurnchainHeaderHash([(i as u8); 32]),
+            sortition_id: SortitionId([(i as u8); 32]),
+            parent_sortition_id: last_snapshot.sortition_id.clone(),
+            parent_burn_header_hash: last_snapshot.burn_header_hash.clone(),
+            consensus_hash: ConsensusHash([(i as u8); 20]),
+            ops_hash: OpsHash([(i as u8); 32]),
+            total_burn: 0,
+            sortition,
+            sortition_hash: SortitionHash([(i as u8); 32]),
+            winning_block_txid: winning_txid.clone(),
+            winning_stacks_block_hash: winning_block_hash.clone(),
+            index_root: TrieHash([0u8; 32]),
+            num_sortitions: last_snapshot.num_sortitions + if sortition { 1 } else { 0 },
+            stacks_block_accepted: false,
+            stacks_block_height: last_snapshot.stacks_block_height,
+            arrival_index: 0,
+            canonical_stacks_tip_height: last_snapshot.canonical_stacks_tip_height + 10,
+            canonical_stacks_tip_hash: BlockHeaderHash([((i + 1) as u8); 32]),
+            canonical_stacks_tip_consensus_hash: ConsensusHash([((i + 1) as u8); 20]),
+            miner_pk_hash: None,
+        };
+        let winning_block_commit = LeaderBlockCommitOp {
+            sunset_burn: 0,
+            block_header_hash: BlockHeaderHash([(i as u8); 32]),
+            new_seed: VRFSeed([(i as u8); 32]),
+            parent_block_ptr: last_snapshot.block_height as u32,
+            parent_vtxindex: 1,
+            // miners take turns winning
+            key_block_ptr: miners[i - 3].block_height as u32,
+            key_vtxindex: miners[i - 3].vtxindex as u16,
+            memo: vec![STACKS_EPOCH_3_0_MARKER],
+            commit_outs: vec![],
+
+            burn_fee: 12345,
+            input: (Txid([0; 32]), 0),
+            apparent_sender: BurnchainSigner::mock_parts(
+                AddressHashMode::SerializeP2PKH,
+                1,
+                vec![StacksPublicKey::from_hex(
+                    "02d8015134d9db8178ac93acbc43170a2f20febba5087a5b0437058765ad5133d0",
+                )
+                .unwrap()],
+            ),
+
+            txid: winning_txid.clone(),
+            vtxindex: 1,
+            block_height: snapshot.block_height,
+            burn_parent_modulus: ((snapshot.block_height - 1) % BURN_BLOCK_MINED_AT_MODULUS) as u8,
+            burn_header_hash: snapshot.burn_header_hash.clone(),
+        };
+
+        let winning_ops = if i == 3 {
+            // first snapshot includes leader keys
+            miners
+                .clone()
+                .into_iter()
+                .map(|miner| BlockstackOperationType::LeaderKeyRegister(miner))
+                .collect()
+        } else {
+            // subsequent ones include block-commits
+            if sortition {
+                vec![BlockstackOperationType::LeaderBlockCommit(
+                    winning_block_commit,
+                )]
+            } else {
+                vec![]
+            }
+        };
+
+        {
+            let mut tx = SortitionHandleTx::begin(sort_db, &last_snapshot.sortition_id).unwrap();
+            let _index_root = tx
+                .append_chain_tip_snapshot(
+                    &last_snapshot,
+                    &snapshot,
+                    &winning_ops,
+                    &vec![],
+                    None,
+                    None,
+                    None,
+                )
+                .unwrap();
+            tx.test_update_canonical_stacks_tip(
+                &snapshot.sortition_id,
+                &snapshot.canonical_stacks_tip_consensus_hash,
+                &snapshot.canonical_stacks_tip_hash,
+                snapshot.canonical_stacks_tip_height,
+            )
+            .unwrap();
+            tx.commit().unwrap();
+        }
+
+        last_snapshot = SortitionDB::get_block_snapshot(sort_db.conn(), &snapshot.sortition_id)
+            .unwrap()
+            .unwrap();
+
+        if i > 3 {
+            // have block-commit
+            // check the stackerdb config as of this chain tip
+            let stackerdb_config =
+                NakamotoChainState::make_miners_stackerdb_config(sort_db).unwrap();
+            eprintln!(
+                "stackerdb_config at i = {} (sorition? {}): {:?}",
+                &i, sortition, &stackerdb_config
+            );
+
+            stackerdb_configs.push(stackerdb_config);
+
+            // make a stackerdb chunk for a hypothetical block
+            let header = NakamotoBlockHeader {
+                version: 1,
+                chain_length: 2,
+                burn_spent: 3,
+                consensus_hash: ConsensusHash([0x04; 20]),
+                parent_block_id: StacksBlockId([0x05; 32]),
+                tx_merkle_root: Sha512Trunc256Sum([0x06; 32]),
+                state_index_root: TrieHash([0x07; 32]),
+                miner_signature: MessageSignature::empty(),
+                signer_signature: ThresholdSignature::mock(),
+            };
+            let block = NakamotoBlock {
+                header,
+                txs: vec![],
+            };
+            if sortition {
+                let chunk = NakamotoBlockBuilder::make_stackerdb_block_proposal(
+                    &sort_db,
+                    i as u32,
+                    &block,
+                    &miner_keys[i - 3],
+                )
+                .unwrap()
+                .unwrap();
+                assert_eq!(chunk.slot_version, (i + 1) as u32);
+                assert_eq!(chunk.data, block.serialize_to_vec());
+                stackerdb_chunks.push(chunk);
+            } else {
+                assert!(NakamotoBlockBuilder::make_stackerdb_block_proposal(
+                    &sort_db,
+                    i as u32,
+                    &block,
+                    &miner_keys[i - 3]
+                )
+                .unwrap()
+                .is_none());
+            }
+        }
+    }
+    // miners are "stable" across snapshots
+    let miner_hashbytes: Vec<_> = stackerdb_configs
+        .iter()
+        .map(|config| {
+            (
+                config.signers[0].0.bytes.clone(),
+                config.signers[1].0.bytes.clone(),
+            )
+        })
+        .collect();
+
+    // active miner alternates slots (part of stability)
+    assert_eq!(stackerdb_chunks[0].slot_id, 0);
+    assert_eq!(stackerdb_chunks[1].slot_id, 1);
+    assert_eq!(stackerdb_chunks[2].slot_id, 0);
+    assert_eq!(stackerdb_chunks[3].slot_id, 1);
+    assert_eq!(stackerdb_chunks[4].slot_id, 0);
+    assert_eq!(stackerdb_chunks[5].slot_id, 1);
+
+    assert!(stackerdb_chunks[0].verify(&miner_addrs[1]).unwrap());
+    assert!(stackerdb_chunks[1].verify(&miner_addrs[2]).unwrap());
+    assert!(stackerdb_chunks[2].verify(&miner_addrs[4]).unwrap());
+    assert!(stackerdb_chunks[3].verify(&miner_addrs[5]).unwrap());
+    assert!(stackerdb_chunks[4].verify(&miner_addrs[7]).unwrap());
+    assert!(stackerdb_chunks[5].verify(&miner_addrs[8]).unwrap());
+
+    assert_eq!(miner_hashbytes[0].0, miner_hash160s[1]);
+    assert_eq!(miner_hashbytes[1].0, miner_hash160s[1]);
+    assert_eq!(miner_hashbytes[2].0, miner_hash160s[1]);
+
+    assert_eq!(miner_hashbytes[1].1, miner_hash160s[2]);
+    assert_eq!(miner_hashbytes[2].1, miner_hash160s[2]);
+    assert_eq!(miner_hashbytes[3].1, miner_hash160s[2]);
+
+    assert_eq!(miner_hashbytes[3].0, miner_hash160s[4]);
+    assert_eq!(miner_hashbytes[4].0, miner_hash160s[4]);
+    assert_eq!(miner_hashbytes[5].0, miner_hash160s[4]);
+
+    assert_eq!(miner_hashbytes[4].1, miner_hash160s[5]);
+    assert_eq!(miner_hashbytes[5].1, miner_hash160s[5]);
+    assert_eq!(miner_hashbytes[6].1, miner_hash160s[5]);
+
+    assert_eq!(miner_hashbytes[6].0, miner_hash160s[7]);
+    assert_eq!(miner_hashbytes[7].0, miner_hash160s[7]);
+    assert_eq!(miner_hashbytes[8].0, miner_hash160s[7]);
+
+    assert_eq!(miner_hashbytes[7].1, miner_hash160s[8]);
+    assert_eq!(miner_hashbytes[8].1, miner_hash160s[8]);
+}

From 7a6868d73fc49bdec2c70972385691d37fc35d00 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Mon, 18 Dec 2023 17:34:46 -0500
Subject: [PATCH 0324/1166] feat: boot code for .miners

---
 stackslib/src/chainstate/stacks/boot/mod.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 146bdd1f38..0b010329b3 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -87,6 +87,9 @@ pub const COSTS_3_NAME: &'static str = "costs-3";
 pub const BOOT_TEST_POX_4_AGG_KEY_CONTRACT: &'static str = "pox-4-agg-test-booter";
 pub const BOOT_TEST_POX_4_AGG_KEY_FNAME: &'static str = "aggregate-key";
 
+pub const MINERS_NAME: &'static str = "miners";
+pub const MINERS_CODE: &'static str = std::include_str!("miners.clar");
+
 pub mod docs;
 
 lazy_static! {

From 84d865b49e17ad0f52746a3998c255d465768b3a Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Mon, 18 Dec 2023 17:34:59 -0500
Subject: [PATCH 0325/1166] chore: instantiate .miners with pox-4, and also,
 clean up and consolidate some redundant code for querying the boot account

---
 stackslib/src/clarity_vm/clarity.rs | 136 ++++++++++++++++++++--------
 1 file changed, 99 insertions(+), 37 deletions(-)

diff --git a/stackslib/src/clarity_vm/clarity.rs b/stackslib/src/clarity_vm/clarity.rs
index 534183ba87..496cde96bc 100644
--- a/stackslib/src/clarity_vm/clarity.rs
+++ b/stackslib/src/clarity_vm/clarity.rs
@@ -47,8 +47,9 @@ use crate::chainstate::stacks::boot::{
     BOOT_CODE_COSTS, BOOT_CODE_COSTS_2, BOOT_CODE_COSTS_2_TESTNET, BOOT_CODE_COSTS_3,
     BOOT_CODE_COST_VOTING_TESTNET as BOOT_CODE_COST_VOTING, BOOT_CODE_POX_TESTNET,
     BOOT_TEST_POX_4_AGG_KEY_CONTRACT, BOOT_TEST_POX_4_AGG_KEY_FNAME, COSTS_2_NAME, COSTS_3_NAME,
-    POX_2_MAINNET_CODE, POX_2_NAME, POX_2_TESTNET_CODE, POX_3_MAINNET_CODE, POX_3_NAME,
-    POX_3_TESTNET_CODE, POX_4_MAINNET_CODE, POX_4_NAME, POX_4_TESTNET_CODE,
+    MINERS_CODE, MINERS_NAME, POX_2_MAINNET_CODE, POX_2_NAME, POX_2_TESTNET_CODE,
+    POX_3_MAINNET_CODE, POX_3_NAME, POX_3_TESTNET_CODE, POX_4_MAINNET_CODE, POX_4_NAME,
+    POX_4_TESTNET_CODE,
 };
 use crate::chainstate::stacks::db::{StacksAccount, StacksChainState};
 use crate::chainstate::stacks::events::{StacksTransactionEvent, StacksTransactionReceipt};
@@ -780,6 +781,16 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
         self.cost_track.unwrap()
     }
 
+    /// Get the boot code account
+    fn get_boot_code_account(&mut self) -> Result<StacksAccount, Error> {
+        let boot_code_address = boot_code_addr(self.mainnet);
+        let boot_code_nonce = self
+            .with_clarity_db_readonly(|db| db.get_account_nonce(&boot_code_address.clone().into()));
+
+        let boot_code_account = boot_code_acc(boot_code_address, boot_code_nonce);
+        Ok(boot_code_account)
+    }
+
     pub fn initialize_epoch_2_05(&mut self) -> Result<StacksTransactionReceipt, Error> {
         // use the `using!` statement to ensure that the old cost_tracker is placed
         //  back in all branches after initialization
@@ -797,12 +808,9 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
                 TransactionVersion::Testnet
             };
 
-            let boot_code_address = boot_code_addr(mainnet);
-            let boot_code_auth = boot_code_tx_auth(boot_code_address);
-            let boot_code_nonce = self.with_clarity_db_readonly(|db| {
-                db.get_account_nonce(&boot_code_address.clone().into())
-            });
-            let boot_code_account = boot_code_acc(boot_code_address, boot_code_nonce);
+            let boot_code_account = self
+                .get_boot_code_account()
+                .expect("FATAL: did not get boot account");
 
             // instantiate costs 2 contract...
             let cost_2_code = if mainnet {
@@ -821,6 +829,19 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
                 None,
             );
 
+            let boot_code_address = boot_code_addr(self.mainnet);
+
+            let boot_code_auth = TransactionAuth::Standard(
+                TransactionSpendingCondition::Singlesig(SinglesigSpendingCondition {
+                    signer: boot_code_address.bytes.clone(),
+                    hash_mode: SinglesigHashMode::P2PKH,
+                    key_encoding: TransactionPublicKeyEncoding::Uncompressed,
+                    nonce: 0,
+                    tx_fee: 0,
+                    signature: MessageSignature::empty(),
+                }),
+            );
+
             let costs_2_contract_tx =
                 StacksTransaction::new(tx_version.clone(), boot_code_auth.clone(), payload);
 
@@ -911,15 +932,9 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
                 }),
             );
 
-            let boot_code_nonce = self.with_clarity_db_readonly(|db| {
-                db.get_account_nonce(&boot_code_address.clone().into())
-            });
-
-            let boot_code_account = StacksAccount {
-                principal: PrincipalData::Standard(boot_code_address.into()),
-                nonce: boot_code_nonce,
-                stx_balance: STXBalance::zero(),
-            };
+            let boot_code_account = self
+                .get_boot_code_account()
+                .expect("FATAL: did not get boot account");
 
             /////////////////// .pox-2 ////////////////////////
             let pox_2_code = if mainnet {
@@ -1175,15 +1190,9 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
                 }),
             );
 
-            let boot_code_nonce = self.with_clarity_db_readonly(|db| {
-                db.get_account_nonce(&boot_code_address.clone().into())
-            });
-
-            let boot_code_account = StacksAccount {
-                principal: PrincipalData::Standard(boot_code_address.into()),
-                nonce: boot_code_nonce,
-                stx_balance: STXBalance::zero(),
-            };
+            let boot_code_account = self
+                .get_boot_code_account()
+                .expect("FATAL: did not get boot account");
 
             let pox_3_code = if mainnet {
                 &*POX_3_MAINNET_CODE
@@ -1277,8 +1286,67 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
                 tx_conn.epoch = StacksEpochId::Epoch25;
             });
 
-            /////////////////// .pox-4 ////////////////////////
+            /////////////////// .miners //////////////////////
             let mainnet = self.mainnet;
+            let tx_version = if mainnet {
+                TransactionVersion::Mainnet
+            } else {
+                TransactionVersion::Testnet
+            };
+            let boot_code_address = boot_code_addr(mainnet);
+
+            let boot_code_auth = TransactionAuth::Standard(
+                TransactionSpendingCondition::Singlesig(SinglesigSpendingCondition {
+                    signer: boot_code_address.bytes.clone(),
+                    hash_mode: SinglesigHashMode::P2PKH,
+                    key_encoding: TransactionPublicKeyEncoding::Uncompressed,
+                    nonce: 0,
+                    tx_fee: 0,
+                    signature: MessageSignature::empty(),
+                }),
+            );
+            let boot_code_account = self
+                .get_boot_code_account()
+                .expect("FATAL: did not get boot account");
+
+            let miners_contract_id = boot_code_id(MINERS_NAME, mainnet);
+
+            let payload = TransactionPayload::SmartContract(
+                TransactionSmartContract {
+                    name: ContractName::try_from(MINERS_NAME)
+                        .expect("FATAL: invalid boot-code contract name"),
+                    code_body: StacksString::from_str(MINERS_CODE)
+                        .expect("FATAL: invalid boot code body"),
+                },
+                Some(ClarityVersion::Clarity2),
+            );
+
+            let miners_contract_tx =
+                StacksTransaction::new(tx_version.clone(), boot_code_auth.clone(), payload);
+
+            let miners_initialization_receipt = self.as_transaction(|tx_conn| {
+                // initialize with a synthetic transaction
+                debug!("Instantiate {} contract", &miners_contract_id);
+                let receipt = StacksChainState::process_transaction_payload(
+                    tx_conn,
+                    &miners_contract_tx,
+                    &boot_code_account,
+                    ASTRules::PrecheckSize,
+                )
+                .expect("FATAL: Failed to process .miners contract initialization");
+                receipt
+            });
+
+            if miners_initialization_receipt.result != Value::okay_true()
+                || miners_initialization_receipt.post_condition_aborted
+            {
+                panic!(
+                    "FATAL: Failure processing .miners contract initialization: {:#?}",
+                    &miners_initialization_receipt
+                );
+            }
+
+            /////////////////// .pox-4 ////////////////////////
             let first_block_height = self.burn_state_db.get_burn_start_height();
             let pox_prepare_length = self.burn_state_db.get_pox_prepare_length();
             let pox_reward_cycle_length = self.burn_state_db.get_pox_reward_cycle_length();
@@ -1312,15 +1380,9 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
                 }),
             );
 
-            let boot_code_nonce = self.with_clarity_db_readonly(|db| {
-                db.get_account_nonce(&boot_code_address.clone().into())
-            });
-
-            let boot_code_account = StacksAccount {
-                principal: PrincipalData::Standard(boot_code_address.into()),
-                nonce: boot_code_nonce,
-                stx_balance: STXBalance::zero(),
-            };
+            let boot_code_account = self
+                .get_boot_code_account()
+                .expect("FATAL: did not get boot account");
 
             let pox_4_code = if mainnet {
                 &*POX_4_MAINNET_CODE
@@ -1378,7 +1440,7 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
                     &boot_code_account,
                     ASTRules::PrecheckSize,
                 )
-                .expect("FATAL: Failed to process PoX 3 contract initialization");
+                .expect("FATAL: Failed to process PoX 4 contract initialization");
 
                 // set burnchain params
                 let consts_setter = PrincipalData::from(pox_4_contract_id.clone());

From 9ceb77f9c1998e4c746673ca6c0ac2edc10d80e9 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Mon, 18 Dec 2023 17:35:25 -0500
Subject: [PATCH 0326/1166] fix: only announce stackerdb DBs when not in IBD

---
 stackslib/src/net/chat.rs | 84 ++++++++++++++++++++++-----------------
 1 file changed, 47 insertions(+), 37 deletions(-)

diff --git a/stackslib/src/net/chat.rs b/stackslib/src/net/chat.rs
index 664ab52c30..79a659e937 100644
--- a/stackslib/src/net/chat.rs
+++ b/stackslib/src/net/chat.rs
@@ -1195,6 +1195,7 @@ impl ConversationP2P {
         network: &mut PeerNetwork,
         message: &mut StacksMessage,
         authenticated: bool,
+        ibd: bool,
     ) -> Result<(Option<StacksMessage>, bool), net_error> {
         if !authenticated && self.connection.options.disable_inbound_handshakes {
             debug!("{:?}: blocking inbound unauthenticated handshake", &self);
@@ -1277,11 +1278,17 @@ impl ConversationP2P {
             if ConversationP2P::supports_stackerdb(network.get_local_peer().services)
                 && ConversationP2P::supports_stackerdb(self.peer_services)
             {
+                // participate in stackerdb protocol, but only announce stackerdbs if we're no
+                // longer in the initial block download.
                 StacksMessageType::StackerDBHandshakeAccept(
                     accept_data,
                     StackerDBHandshakeData {
                         rc_consensus_hash: network.get_chain_view().rc_consensus_hash.clone(),
-                        smart_contracts: network.get_local_peer().stacker_dbs.clone(),
+                        smart_contracts: if ibd {
+                            vec![]
+                        } else {
+                            network.get_local_peer().stacker_dbs.clone()
+                        },
                     },
                 )
             } else {
@@ -2315,6 +2322,7 @@ impl ConversationP2P {
         &mut self,
         network: &mut PeerNetwork,
         msg: &mut StacksMessage,
+        ibd: bool,
     ) -> Result<(Option<StacksMessage>, bool), net_error> {
         let mut consume = false;
 
@@ -2324,7 +2332,7 @@ impl ConversationP2P {
                 monitoring::increment_msg_counter("p2p_authenticated_handshake".to_string());
 
                 debug!("{:?}: Got Handshake", &self);
-                let (handshake_opt, handled) = self.handle_handshake(network, msg, true)?;
+                let (handshake_opt, handled) = self.handle_handshake(network, msg, true, ibd)?;
                 consume = handled;
                 Ok(handshake_opt)
             }
@@ -2390,6 +2398,7 @@ impl ConversationP2P {
         &mut self,
         network: &mut PeerNetwork,
         msg: &mut StacksMessage,
+        ibd: bool,
     ) -> Result<(Option<StacksMessage>, bool), net_error> {
         // only thing we'll take right now is a handshake, as well as handshake
         // accept/rejects, nacks, and NAT holepunches
@@ -2401,7 +2410,7 @@ impl ConversationP2P {
             StacksMessageType::Handshake(_) => {
                 monitoring::increment_msg_counter("p2p_unauthenticated_handshake".to_string());
                 test_debug!("{:?}: Got unauthenticated Handshake", &self);
-                let (reply_opt, handled) = self.handle_handshake(network, msg, false)?;
+                let (reply_opt, handled) = self.handle_handshake(network, msg, false, ibd)?;
                 consume = handled;
                 Ok(reply_opt)
             }
@@ -2567,6 +2576,7 @@ impl ConversationP2P {
         network: &mut PeerNetwork,
         sortdb: &SortitionDB,
         chainstate: &mut StacksChainState,
+        ibd: bool,
     ) -> Result<Vec<StacksMessage>, net_error> {
         let num_inbound = self.connection.inbox_len();
         test_debug!("{:?}: {} messages pending", &self, num_inbound);
@@ -2589,14 +2599,14 @@ impl ConversationP2P {
                 // we already have this remote peer's public key, so the message signature will
                 // have been verified by the underlying ConnectionP2P.
                 update_stats = true;
-                self.handle_authenticated_control_message(network, &mut msg)?
+                self.handle_authenticated_control_message(network, &mut msg, ibd)?
             } else {
                 // the underlying ConnectionP2P does not yet have a public key installed (i.e.
                 // we don't know it yet), so treat this message with a little bit more
                 // suspicion.
                 // Update stats only if we were asking for this message.
                 update_stats = self.connection.is_solicited(&msg);
-                self.handle_unauthenticated_control_message(network, &mut msg)?
+                self.handle_unauthenticated_control_message(network, &mut msg, ibd)?
             };
 
             if let Some(mut reply) = reply_opt.take() {
@@ -3151,14 +3161,14 @@ mod test {
             test_debug!("send handshake");
             convo_send_recv(&mut convo_1, vec![&mut rh_1], &mut convo_2);
             let unhandled_2 = convo_2
-                .chat(&mut net_2, &sortdb_2, &mut chainstate_2)
+                .chat(&mut net_2, &sortdb_2, &mut chainstate_2, false)
                 .unwrap();
 
             // convo_1 has a handshakeaccept
             test_debug!("send handshake-accept");
             convo_send_recv(&mut convo_2, vec![&mut rh_1], &mut convo_1);
             let unhandled_1 = convo_1
-                .chat(&mut net_1, &sortdb_1, &mut chainstate_1)
+                .chat(&mut net_1, &sortdb_1, &mut chainstate_1, false)
                 .unwrap();
 
             let reply_1 = rh_1.recv(0).unwrap();
@@ -3432,14 +3442,14 @@ mod test {
             test_debug!("send handshake");
             convo_send_recv(&mut convo_1, vec![&mut rh_1], &mut convo_2);
             let unhandled_2 = convo_2
-                .chat(&mut net_2, &sortdb_2, &mut chainstate_2)
+                .chat(&mut net_2, &sortdb_2, &mut chainstate_2, false)
                 .unwrap();
 
             // convo_1 has a handshakeaccept
             test_debug!("send handshake-accept");
             convo_send_recv(&mut convo_2, vec![&mut rh_1], &mut convo_1);
             let unhandled_1 = convo_1
-                .chat(&mut net_1, &sortdb_1, &mut chainstate_1)
+                .chat(&mut net_1, &sortdb_1, &mut chainstate_1, false)
                 .unwrap();
 
             let reply_1 = rh_1.recv(0).unwrap();
@@ -3611,13 +3621,13 @@ mod test {
         // convo_2 receives it and automatically rejects it.
         convo_send_recv(&mut convo_1, vec![&mut rh_1], &mut convo_2);
         let unhandled_2 = convo_2
-            .chat(&mut net_2, &sortdb_2, &mut chainstate_2)
+            .chat(&mut net_2, &sortdb_2, &mut chainstate_2, false)
             .unwrap();
 
         // convo_1 has a handshakreject
         convo_send_recv(&mut convo_2, vec![&mut rh_1], &mut convo_1);
         let unhandled_1 = convo_1
-            .chat(&mut net_1, &sortdb_1, &mut chainstate_1)
+            .chat(&mut net_1, &sortdb_1, &mut chainstate_1, false)
             .unwrap();
 
         let reply_1 = rh_1.recv(0).unwrap();
@@ -3759,12 +3769,12 @@ mod test {
 
         // convo_2 receives it and processes it, and barfs
         convo_send_recv(&mut convo_1, vec![&mut rh_1], &mut convo_2);
-        let unhandled_2_err = convo_2.chat(&mut net_2, &sortdb_2, &mut chainstate_2);
+        let unhandled_2_err = convo_2.chat(&mut net_2, &sortdb_2, &mut chainstate_2, false);
 
         // convo_1 gets a nack and consumes it
         convo_send_recv(&mut convo_2, vec![&mut rh_1], &mut convo_1);
         let unhandled_1 = convo_1
-            .chat(&mut net_1, &sortdb_1, &mut chainstate_1)
+            .chat(&mut net_1, &sortdb_1, &mut chainstate_1, false)
             .unwrap();
 
         // the waiting reply aborts on disconnect
@@ -3917,13 +3927,13 @@ mod test {
         // convo_2 receives it and processes it, and rejects it
         convo_send_recv(&mut convo_1, vec![&mut rh_1], &mut convo_2);
         let unhandled_2 = convo_2
-            .chat(&mut net_2, &sortdb_2, &mut chainstate_2)
+            .chat(&mut net_2, &sortdb_2, &mut chainstate_2, false)
             .unwrap();
 
         // convo_1 gets a handshake-reject and consumes it
         convo_send_recv(&mut convo_2, vec![&mut rh_1], &mut convo_1);
         let unhandled_1 = convo_1
-            .chat(&mut net_1, &sortdb_1, &mut chainstate_1)
+            .chat(&mut net_1, &sortdb_1, &mut chainstate_1, false)
             .unwrap();
 
         // the waiting reply aborts on disconnect
@@ -4052,13 +4062,13 @@ mod test {
         // convo_2 receives it
         convo_send_recv(&mut convo_1, vec![&mut rh_1], &mut convo_2);
         let unhandled_2 = convo_2
-            .chat(&mut net_2, &sortdb_2, &mut chainstate_2)
+            .chat(&mut net_2, &sortdb_2, &mut chainstate_2, false)
             .unwrap();
 
         // convo_1 has a handshakaccept
         convo_send_recv(&mut convo_2, vec![&mut rh_1], &mut convo_1);
         let unhandled_1 = convo_1
-            .chat(&mut net_1, &sortdb_1, &mut chainstate_1)
+            .chat(&mut net_1, &sortdb_1, &mut chainstate_1, false)
             .unwrap();
 
         let reply_1 = rh_1.recv(0).unwrap();
@@ -4106,13 +4116,13 @@ mod test {
         // convo_2 receives it
         convo_send_recv(&mut convo_1, vec![&mut rh_1], &mut convo_2);
         let unhandled_2 = convo_2
-            .chat(&mut net_2, &sortdb_2, &mut chainstate_2)
+            .chat(&mut net_2, &sortdb_2, &mut chainstate_2, false)
             .unwrap();
 
         // convo_1 has a handshakaccept
         convo_send_recv(&mut convo_2, vec![&mut rh_1], &mut convo_1);
         let unhandled_1 = convo_1
-            .chat(&mut net_1, &sortdb_1, &mut chainstate_1)
+            .chat(&mut net_1, &sortdb_1, &mut chainstate_1, false)
             .unwrap();
 
         let reply_1 = rh_1.recv(0).unwrap();
@@ -4249,13 +4259,13 @@ mod test {
         // convo_2 receives it and processes it automatically (consuming it), and give back a handshake reject
         convo_send_recv(&mut convo_1, vec![&mut rh_1], &mut convo_2);
         let unhandled_2 = convo_2
-            .chat(&mut net_1, &sortdb_1, &mut chainstate_1)
+            .chat(&mut net_1, &sortdb_1, &mut chainstate_1, false)
             .unwrap();
 
         // convo_1 gets a handshake reject and consumes it
         convo_send_recv(&mut convo_2, vec![&mut rh_1], &mut convo_1);
         let unhandled_1 = convo_1
-            .chat(&mut net_2, &sortdb_2, &mut chainstate_2)
+            .chat(&mut net_2, &sortdb_2, &mut chainstate_2, false)
             .unwrap();
 
         // get back handshake reject
@@ -4410,7 +4420,7 @@ mod test {
             &mut convo_2,
         );
         let unhandled_2 = convo_2
-            .chat(&mut net_2, &sortdb_2, &mut chainstate_2)
+            .chat(&mut net_2, &sortdb_2, &mut chainstate_2, false)
             .unwrap();
 
         // convo_1 has a handshakeaccept
@@ -4422,7 +4432,7 @@ mod test {
             &mut convo_1,
         );
         let unhandled_1 = convo_1
-            .chat(&mut net_1, &sortdb_1, &mut chainstate_1)
+            .chat(&mut net_1, &sortdb_1, &mut chainstate_1, false)
             .unwrap();
 
         let reply_handshake_1 = rh_handshake_1.recv(0).unwrap();
@@ -4583,7 +4593,7 @@ mod test {
                 &mut convo_2,
             );
             let unhandled_2 = convo_2
-                .chat(&mut net_2, &sortdb_2, &mut chainstate_2)
+                .chat(&mut net_2, &sortdb_2, &mut chainstate_2, false)
                 .unwrap();
 
             // convo_1 has a handshakeaccept
@@ -4593,7 +4603,7 @@ mod test {
                 &mut convo_1,
             );
             let unhandled_1 = convo_1
-                .chat(&mut net_1, &sortdb_1, &mut chainstate_1)
+                .chat(&mut net_1, &sortdb_1, &mut chainstate_1, false)
                 .unwrap();
 
             let reply_handshake_1 = rh_handshake_1.recv(0).unwrap();
@@ -4793,13 +4803,13 @@ mod test {
         // convo_2 will reply with a nack since peer_1 hasn't authenticated yet
         convo_send_recv(&mut convo_1, vec![&mut rh_ping_1], &mut convo_2);
         let unhandled_2 = convo_2
-            .chat(&mut net_2, &sortdb_2, &mut chainstate_2)
+            .chat(&mut net_2, &sortdb_2, &mut chainstate_2, false)
             .unwrap();
 
         // convo_1 has a nack
         convo_send_recv(&mut convo_2, vec![&mut rh_ping_1], &mut convo_1);
         let unhandled_1 = convo_1
-            .chat(&mut net_1, &sortdb_1, &mut chainstate_1)
+            .chat(&mut net_1, &sortdb_1, &mut chainstate_1, false)
             .unwrap();
 
         let reply_1 = rh_ping_1.recv(0).unwrap();
@@ -4966,12 +4976,12 @@ mod test {
 
             convo_send_recv(&mut convo_1, vec![&mut rh_1], &mut convo_2);
             let unhandled_2 = convo_2
-                .chat(&mut net_2, &sortdb_2, &mut chainstate_2)
+                .chat(&mut net_2, &sortdb_2, &mut chainstate_2, false)
                 .unwrap();
 
             convo_send_recv(&mut convo_2, vec![&mut rh_1], &mut convo_1);
             let unhandled_1 = convo_1
-                .chat(&mut net_1, &sortdb_1, &mut chainstate_1)
+                .chat(&mut net_1, &sortdb_1, &mut chainstate_1, false)
                 .unwrap();
 
             // connection should break off since nodes ignore unsolicited messages
@@ -5112,14 +5122,14 @@ mod test {
             test_debug!("send handshake");
             convo_send_recv(&mut convo_1, vec![&mut rh_1], &mut convo_2);
             let unhandled_2 = convo_2
-                .chat(&mut net_2, &sortdb_2, &mut chainstate_2)
+                .chat(&mut net_2, &sortdb_2, &mut chainstate_2, false)
                 .unwrap();
 
             // convo_1 has a handshakeaccept
             test_debug!("send handshake-accept");
             convo_send_recv(&mut convo_2, vec![&mut rh_1], &mut convo_1);
             let unhandled_1 = convo_1
-                .chat(&mut net_1, &sortdb_1, &mut chainstate_1)
+                .chat(&mut net_1, &sortdb_1, &mut chainstate_1, false)
                 .unwrap();
 
             let reply_1 = rh_1.recv(0).unwrap();
@@ -5195,14 +5205,14 @@ mod test {
             test_debug!("send getblocksinv");
             convo_send_recv(&mut convo_1, vec![&mut rh_1], &mut convo_2);
             let unhandled_2 = convo_2
-                .chat(&mut net_2, &sortdb_2, &mut chainstate_2)
+                .chat(&mut net_2, &sortdb_2, &mut chainstate_2, false)
                 .unwrap();
 
             // convo_1 gets back a blocksinv message
             test_debug!("send blocksinv");
             convo_send_recv(&mut convo_2, vec![&mut rh_1], &mut convo_1);
             let unhandled_1 = convo_1
-                .chat(&mut net_1, &sortdb_1, &mut chainstate_1)
+                .chat(&mut net_1, &sortdb_1, &mut chainstate_1, false)
                 .unwrap();
 
             let reply_1 = rh_1.recv(0).unwrap();
@@ -5248,14 +5258,14 @@ mod test {
             test_debug!("send getblocksinv (diverged)");
             convo_send_recv(&mut convo_1, vec![&mut rh_1], &mut convo_2);
             let unhandled_2 = convo_2
-                .chat(&mut net_2, &sortdb_2, &mut chainstate_2)
+                .chat(&mut net_2, &sortdb_2, &mut chainstate_2, false)
                 .unwrap();
 
             // convo_1 gets back a nack message
             test_debug!("send nack (diverged)");
             convo_send_recv(&mut convo_2, vec![&mut rh_1], &mut convo_1);
             let unhandled_1 = convo_1
-                .chat(&mut net_1, &sortdb_1, &mut chainstate_1)
+                .chat(&mut net_1, &sortdb_1, &mut chainstate_1, false)
                 .unwrap();
 
             let reply_1 = rh_1.recv(0).unwrap();
@@ -5388,14 +5398,14 @@ mod test {
         test_debug!("send natpunch {:?}", &natpunch_1);
         convo_send_recv(&mut convo_1, vec![&mut rh_natpunch_1], &mut convo_2);
         let unhandled_2 = convo_2
-            .chat(&mut net_2, &sortdb_2, &mut chainstate_2)
+            .chat(&mut net_2, &sortdb_2, &mut chainstate_2, false)
             .unwrap();
 
         // convo_1 gets back a natpunch reply
         test_debug!("reply natpunch-reply");
         convo_send_recv(&mut convo_2, vec![&mut rh_natpunch_1], &mut convo_1);
         let unhandled_1 = convo_1
-            .chat(&mut net_1, &sortdb_1, &mut chainstate_1)
+            .chat(&mut net_1, &sortdb_1, &mut chainstate_1, false)
             .unwrap();
 
         let natpunch_reply_1 = rh_natpunch_1.recv(0).unwrap();

From 61596ac88862d590b309c87ee4a2ef59f5379252 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Mon, 18 Dec 2023 17:35:46 -0500
Subject: [PATCH 0327/1166] feat: synthesize a .miners stackerdb directly every
 Bitcoin block

---
 stackslib/src/net/p2p.rs | 53 +++++++++++++++++++++++++++-------------
 1 file changed, 36 insertions(+), 17 deletions(-)

diff --git a/stackslib/src/net/p2p.rs b/stackslib/src/net/p2p.rs
index 74657ec8ad..ddc07794a4 100644
--- a/stackslib/src/net/p2p.rs
+++ b/stackslib/src/net/p2p.rs
@@ -45,6 +45,7 @@ use crate::chainstate::coordinator::{
     static_get_canonical_affirmation_map, static_get_heaviest_affirmation_map,
     static_get_stacks_tip_affirmation_map,
 };
+use crate::chainstate::stacks::boot::MINERS_NAME;
 use crate::chainstate::stacks::db::StacksChainState;
 use crate::chainstate::stacks::{StacksBlockHeader, MAX_BLOCK_LEN, MAX_TRANSACTION_LEN};
 use crate::core::StacksEpoch;
@@ -65,6 +66,7 @@ use crate::net::relay::{RelayerStats, *, *};
 use crate::net::server::*;
 use crate::net::stackerdb::{StackerDBConfig, StackerDBSync, StackerDBTx, StackerDBs};
 use crate::net::{Error as net_error, Neighbor, NeighborKey, *};
+use crate::util_lib::boot::boot_code_id;
 use crate::util_lib::db::{DBConn, DBTx, Error as db_error};
 
 /// inter-thread request to send a p2p message from another thread in this program.
@@ -1939,6 +1941,7 @@ impl PeerNetwork {
         event_id: usize,
         sortdb: &SortitionDB,
         chainstate: &mut StacksChainState,
+        ibd: bool,
     ) -> Result<(Vec<StacksMessage>, bool), net_error> {
         self.with_p2p_convo(event_id, |network, convo, client_sock| {
             // get incoming bytes and update the state of this conversation.
@@ -1970,7 +1973,7 @@ impl PeerNetwork {
             // react to inbound messages -- do we need to send something out, or fulfill requests
             // to other threads?  Try to chat even if the recv() failed, since we'll want to at
             // least drain the conversation inbox.
-            let unhandled = match convo.chat(network, sortdb, chainstate) {
+            let unhandled = match convo.chat(network, sortdb, chainstate, ibd) {
                 Err(e) => {
                     debug!(
                         "Failed to converse on event {} (socket {:?}): {:?}",
@@ -2027,13 +2030,14 @@ impl PeerNetwork {
         sortdb: &SortitionDB,
         chainstate: &mut StacksChainState,
         poll_state: &mut NetworkPollState,
+        ibd: bool,
     ) -> (Vec<usize>, HashMap<usize, Vec<StacksMessage>>) {
         let mut to_remove = vec![];
         let mut unhandled: HashMap<usize, Vec<StacksMessage>> = HashMap::new();
 
         for event_id in &poll_state.ready {
             let (mut convo_unhandled, alive) =
-                match self.process_p2p_conversation(*event_id, sortdb, chainstate) {
+                match self.process_p2p_conversation(*event_id, sortdb, chainstate, ibd) {
                     Ok((convo_unhandled, alive)) => (convo_unhandled, alive),
                     Err(_e) => {
                         test_debug!(
@@ -5332,20 +5336,35 @@ impl PeerNetwork {
             let mut new_stackerdb_configs = HashMap::new();
             let stacker_db_configs = mem::replace(&mut self.stacker_db_configs, HashMap::new());
             for (stackerdb_contract_id, stackerdb_config) in stacker_db_configs.into_iter() {
-                let new_config = match StackerDBConfig::from_smart_contract(
-                    chainstate,
-                    sortdb,
-                    &stackerdb_contract_id,
-                ) {
-                    Ok(config) => config,
-                    Err(e) => {
-                        warn!(
-                            "Failed to load StackerDB config for {}: {:?}",
-                            &stackerdb_contract_id, &e
-                        );
-                        StackerDBConfig::noop()
-                    }
-                };
+                let new_config =
+                    if stackerdb_contract_id == boot_code_id(MINERS_NAME, chainstate.mainnet) {
+                        // .miners contract -- directly generate the config
+                        let miners_config =
+                            match NakamotoChainState::make_miners_stackerdb_config(sortdb) {
+                                Ok(config) => config,
+                                Err(e) => {
+                                    warn!("Failed to generate .miners config: {:?}", &e);
+                                    continue;
+                                }
+                            };
+                        miners_config
+                    } else {
+                        // normal stackerdb contract
+                        match StackerDBConfig::from_smart_contract(
+                            chainstate,
+                            sortdb,
+                            &stackerdb_contract_id,
+                        ) {
+                            Ok(config) => config,
+                            Err(e) => {
+                                warn!(
+                                    "Failed to load StackerDB config for {}: {:?}",
+                                    &stackerdb_contract_id, &e
+                                );
+                                StackerDBConfig::noop()
+                            }
+                        }
+                    };
                 if new_config != stackerdb_config && new_config.signers.len() > 0 {
                     if let Err(e) =
                         self.create_or_reconfigure_stackerdb(&stackerdb_contract_id, &new_config)
@@ -5426,7 +5445,7 @@ impl PeerNetwork {
 
         // run existing conversations, clear out broken ones, and get back messages forwarded to us
         let (error_events, unsolicited_messages) =
-            self.process_ready_sockets(sortdb, chainstate, &mut poll_state);
+            self.process_ready_sockets(sortdb, chainstate, &mut poll_state, ibd);
         for error_event in error_events {
             debug!(
                 "{:?}: Failed connection on event {}",

From 7c3a62a4fb6f2320915c5832b27eb416167375bd Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Mon, 18 Dec 2023 21:44:07 -0500
Subject: [PATCH 0328/1166] chore: fix failing unit tests

---
 stackslib/src/net/stackerdb/tests/config.rs |  2 +-
 stackslib/src/net/stackerdb/tests/sync.rs   | 10 +++++-----
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/stackslib/src/net/stackerdb/tests/config.rs b/stackslib/src/net/stackerdb/tests/config.rs
index 4cee2fbfdd..9600ed79a8 100644
--- a/stackslib/src/net/stackerdb/tests/config.rs
+++ b/stackslib/src/net/stackerdb/tests/config.rs
@@ -316,7 +316,7 @@ fn test_valid_and_invalid_stackerdb_configs() {
 
             (define-public (stackerdb-get-config)
                 (ok {
-                    chunk-size: u1048577,
+                    chunk-size: (+ (* u16 u1048576) u1),
                     write-freq: u4,
                     max-writes: u56,
                     max-neighbors: u7,
diff --git a/stackslib/src/net/stackerdb/tests/sync.rs b/stackslib/src/net/stackerdb/tests/sync.rs
index 92187820c0..65ef659244 100644
--- a/stackslib/src/net/stackerdb/tests/sync.rs
+++ b/stackslib/src/net/stackerdb/tests/sync.rs
@@ -228,8 +228,8 @@ fn test_stackerdb_replica_2_neighbors_1_chunk() {
         let mut i = 0;
         loop {
             // run peer network state-machines
-            let res_1 = peer_1.step();
-            let res_2 = peer_2.step();
+            let res_1 = peer_1.step_with_ibd(false);
+            let res_2 = peer_2.step_with_ibd(false);
 
             if let Ok(mut res) = res_1 {
                 Relayer::process_stacker_db_chunks(
@@ -347,8 +347,8 @@ fn inner_test_stackerdb_replica_2_neighbors_10_chunks(push_only: bool, base_port
         let mut i = 0;
         loop {
             // run peer network state-machines
-            let res_1 = peer_1.step();
-            let res_2 = peer_2.step();
+            let res_1 = peer_1.step_with_ibd(false);
+            let res_2 = peer_2.step_with_ibd(false);
 
             if let Ok(mut res) = res_1 {
                 Relayer::process_stacker_db_chunks(
@@ -485,7 +485,7 @@ fn inner_test_stackerdb_10_replicas_10_neighbors_line_10_chunks(push_only: bool,
         loop {
             // run peer network state-machines
             for i in 0..num_peers {
-                let res = peers[i].step();
+                let res = peers[i].step_with_ibd(false);
                 if let Ok(mut res) = res {
                     let rc_consensus_hash =
                         peers[i].network.get_chain_view().rc_consensus_hash.clone();

From c9a827d8cbf451700d55fd02ebbd239f5643b778 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Thu, 28 Dec 2023 13:35:05 -0500
Subject: [PATCH 0329/1166] Retrieve slot version and id from stacker db
 directly and propose a block

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 .../chainstate/nakamoto/coordinator/tests.rs  |  6 +-
 stackslib/src/chainstate/nakamoto/miner.rs    | 51 ++++++----------
 stackslib/src/chainstate/nakamoto/mod.rs      | 39 ++++++++++++
 .../src/chainstate/nakamoto/tests/mod.rs      | 16 +++--
 stackslib/src/net/mod.rs                      | 19 ++++++
 stackslib/src/net/stackerdb/db.rs             | 19 ++++++
 .../stacks-node/src/nakamoto_node/miner.rs    | 61 ++++++++++++++++---
 .../src/tests/nakamoto_integrations.rs        |  5 ++
 8 files changed, 169 insertions(+), 47 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index c19b7622ef..d4198dfd2c 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -35,6 +35,7 @@ use crate::chainstate::nakamoto::tests::node::TestSigners;
 use crate::chainstate::nakamoto::{NakamotoBlock, NakamotoChainState};
 use crate::chainstate::stacks::address::PoxAddress;
 use crate::chainstate::stacks::boot::test::{make_pox_4_aggregate_key, make_pox_4_lockup};
+use crate::chainstate::stacks::boot::MINERS_NAME;
 use crate::chainstate::stacks::db::{MinerPaymentTxFees, StacksAccount, StacksChainState};
 use crate::chainstate::stacks::{
     CoinbasePayload, StacksTransaction, StacksTransactionSigner, TenureChangeCause,
@@ -44,7 +45,9 @@ use crate::chainstate::stacks::{
 use crate::clarity::vm::types::StacksAddressExtensions;
 use crate::core::StacksEpochExtension;
 use crate::net::relay::Relayer;
+use crate::net::stackerdb::StackerDBConfig;
 use crate::net::test::{TestPeer, TestPeerConfig};
+use crate::util_lib::boot::boot_code_id;
 
 /// Bring a TestPeer into the Nakamoto Epoch
 fn advance_to_nakamoto(peer: &mut TestPeer) {
@@ -84,8 +87,8 @@ fn advance_to_nakamoto(peer: &mut TestPeer) {
 
         peer.tenure_with_txs(&txs, &mut peer_nonce);
     }
-
     // peer is at the start of cycle 8
+    peer.init_stacker_db_miners();
 }
 
 /// Make a peer and transition it into the Nakamoto epoch.
@@ -117,7 +120,6 @@ pub fn boot_nakamoto(
     peer_config.burnchain.pox_constants.pox_3_activation_height = 26;
     peer_config.burnchain.pox_constants.v3_unlock_height = 27;
     peer_config.burnchain.pox_constants.pox_4_activation_height = 31;
-
     let mut peer = TestPeer::new(peer_config);
     advance_to_nakamoto(&mut peer);
     peer
diff --git a/stackslib/src/chainstate/nakamoto/miner.rs b/stackslib/src/chainstate/nakamoto/miner.rs
index a2e8695e52..5ce0521c60 100644
--- a/stackslib/src/chainstate/nakamoto/miner.rs
+++ b/stackslib/src/chainstate/nakamoto/miner.rs
@@ -28,7 +28,7 @@ use clarity::vm::clarity::TransactionConnection;
 use clarity::vm::costs::ExecutionCost;
 use clarity::vm::database::BurnStateDB;
 use clarity::vm::errors::Error as InterpreterError;
-use clarity::vm::types::TypeSignature;
+use clarity::vm::types::{QualifiedContractIdentifier, TypeSignature};
 use libstackerdb::StackerDBChunkData;
 use serde::Deserialize;
 use stacks_common::codec::{read_next, write_next, Error as CodecError, StacksMessageCodec};
@@ -48,6 +48,7 @@ use crate::chainstate::nakamoto::{
     MaturedMinerRewards, NakamotoBlock, NakamotoBlockHeader, NakamotoChainState, SetupBlockResult,
 };
 use crate::chainstate::stacks::address::StacksAddressExtensions;
+use crate::chainstate::stacks::boot::MINERS_NAME;
 use crate::chainstate::stacks::db::accounts::MinerReward;
 use crate::chainstate::stacks::db::blocks::MemPoolRejection;
 use crate::chainstate::stacks::db::transactions::{
@@ -72,6 +73,9 @@ use crate::monitoring::{
     set_last_mined_block_transaction_count, set_last_mined_execution_cost_observed,
 };
 use crate::net::relay::Relayer;
+use crate::net::stackerdb::StackerDBs;
+use crate::net::Error as net_error;
+use crate::util_lib::boot::boot_code_id;
 use crate::util_lib::db::Error as DBError;
 
 /// Nakamaoto tenure information
@@ -506,50 +510,31 @@ impl NakamotoBlockBuilder {
 
     /// Make a StackerDB chunk message containing a proposed block.
     /// Sign it with the miner's private key.
-    /// Automatically determine which StackerDB slot to use.
+    /// Automatically determine which StackerDB slot and version number to use.
     /// Returns Some(chunk) if the given key corresponds to one of the expected miner slots
     /// Returns None if not
     /// Returns an error on signing or DB error
     pub fn make_stackerdb_block_proposal(
         sortdb: &SortitionDB,
-        write_count: u32,
+        stackerdbs: &StackerDBs,
         block: &NakamotoBlock,
         miner_privkey: &StacksPrivateKey,
+        miners_contract_id: &QualifiedContractIdentifier,
     ) -> Result<Option<StackerDBChunkData>, Error> {
         let miner_pubkey = StacksPublicKey::from_private(&miner_privkey);
-        let miner_hash160 = Hash160::from_node_public_key(&miner_pubkey);
-        let stackerdb_config = NakamotoChainState::make_miners_stackerdb_config(sortdb)?;
-
-        // find out which slot we're in
-        let Some(slot_id_res) =
-            stackerdb_config
-                .signers
-                .iter()
-                .enumerate()
-                .find_map(|(i, (addr, _))| {
-                    if addr.bytes == miner_hash160 {
-                        Some(u32::try_from(i).map_err(|_| {
-                            CodecError::OverflowError(
-                                "stackerdb config slot ID cannot fit into u32".into(),
-                            )
-                        }))
-                    } else {
-                        None
-                    }
-                })
-        else {
-            // miner key does not match any slot
-            warn!("Miner is not in the miners StackerDB config";
-                  "miner" => %miner_hash160,
-                  "stackerdb_slots" => format!("{:?}", &stackerdb_config.signers));
-
+        let Some(slot_id) = NakamotoChainState::get_miner_slot(sortdb, &miner_pubkey)? else {
+            // No slot exists for this miner
             return Ok(None);
         };
-
-        let slot_id = slot_id_res?;
+        // Get the LAST slot version number written to the DB. If not found, use 0.
+        // Add 1 to get the NEXT version number
+        // Note: we already check above for the slot's existence
+        let slot_version = stackerdbs
+            .get_slot_version(&miners_contract_id, slot_id)?
+            .unwrap_or(0)
+            .saturating_add(1);
         let block_bytes = block.serialize_to_vec();
-        let mut chunk =
-            StackerDBChunkData::new(slot_id, write_count.saturating_add(1), block_bytes);
+        let mut chunk = StackerDBChunkData::new(slot_id, slot_version, block_bytes);
         chunk
             .sign(miner_privkey)
             .map_err(|_| net_error::SigningError("Failed to sign StackerDB chunk".into()))?;
diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index aeebdf7e42..ca34c017c1 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -3126,6 +3126,45 @@ impl NakamotoChainState {
         })
     }
 
+    /// Get the slot number for the given miner's public key.
+    /// Returns Some(u32) if the miner is in the StackerDB config.
+    /// Returns None if the miner is not in the StackerDB config.
+    /// Returns an error if the miner is in the StackerDB config but the slot number is invalid.
+    pub fn get_miner_slot(
+        sortdb: &SortitionDB,
+        miner_pubkey: &StacksPublicKey,
+    ) -> Result<Option<u32>, ChainstateError> {
+        let miner_hash160 = Hash160::from_node_public_key(&miner_pubkey);
+        let stackerdb_config = Self::make_miners_stackerdb_config(sortdb)?;
+
+        // find out which slot we're in
+        let Some(slot_id_res) =
+            stackerdb_config
+                .signers
+                .iter()
+                .enumerate()
+                .find_map(|(i, (addr, _))| {
+                    if addr.bytes == miner_hash160 {
+                        Some(u32::try_from(i).map_err(|_| {
+                            CodecError::OverflowError(
+                                "stackerdb config slot ID cannot fit into u32".into(),
+                            )
+                        }))
+                    } else {
+                        None
+                    }
+                })
+        else {
+            // miner key does not match any slot
+            warn!("Miner is not in the miners StackerDB config";
+                  "miner" => %miner_hash160,
+                  "stackerdb_slots" => format!("{:?}", &stackerdb_config.signers));
+
+            return Ok(None);
+        };
+        Ok(Some(slot_id_res?))
+    }
+
     /// Boot code instantiation for the aggregate public key.
     /// TODO: This should be removed once it's possible for stackers to vote on the aggregate
     /// public key
diff --git a/stackslib/src/chainstate/nakamoto/tests/mod.rs b/stackslib/src/chainstate/nakamoto/tests/mod.rs
index acb8bae85b..a2652d2564 100644
--- a/stackslib/src/chainstate/nakamoto/tests/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/mod.rs
@@ -55,6 +55,7 @@ use crate::chainstate::nakamoto::tests::node::TestSigners;
 use crate::chainstate::nakamoto::{
     NakamotoBlock, NakamotoBlockHeader, NakamotoChainState, FIRST_STACKS_BLOCK_ID,
 };
+use crate::chainstate::stacks::boot::MINERS_NAME;
 use crate::chainstate::stacks::db::{
     ChainStateBootData, ChainstateAccountBalance, ChainstateAccountLockup, ChainstateBNSName,
     ChainstateBNSNamespace, StacksAccount, StacksBlockHeaderTypes, StacksChainState,
@@ -68,6 +69,7 @@ use crate::chainstate::stacks::{
 use crate::core;
 use crate::core::{StacksEpochExtension, STACKS_EPOCH_3_0_MARKER};
 use crate::net::codec::test::check_codec_and_corruption;
+use crate::util_lib::boot::boot_code_id;
 
 /// Get an address's account
 pub fn get_account(
@@ -1675,10 +1677,12 @@ fn test_make_miners_stackerdb_config() {
 
     debug!("miners = {:#?}", &miner_hash160s);
 
-    // extract chainstate and sortdb -- we don't need the peer anymore
+    // extract chainstate, sortdb, and stackerdbs -- we don't need the peer anymore
     let chainstate = &mut peer.stacks_node.as_mut().unwrap().chainstate;
     let sort_db = peer.sortdb.as_mut().unwrap();
     let mut last_snapshot = SortitionDB::get_canonical_burn_chain_tip(sort_db.conn()).unwrap();
+    let stackerdbs = peer.network.stackerdbs;
+    let miners_contract_id = boot_code_id(MINERS_NAME, false);
 
     // make two leader keys (miner 1 and miner 2)
     let mut miners = vec![];
@@ -1842,21 +1846,23 @@ fn test_make_miners_stackerdb_config() {
             if sortition {
                 let chunk = NakamotoBlockBuilder::make_stackerdb_block_proposal(
                     &sort_db,
-                    i as u32,
+                    &stackerdbs,
                     &block,
                     &miner_keys[i - 3],
+                    &miners_contract_id,
                 )
                 .unwrap()
                 .unwrap();
-                assert_eq!(chunk.slot_version, (i + 1) as u32);
+                assert_eq!(chunk.slot_version, 1);
                 assert_eq!(chunk.data, block.serialize_to_vec());
                 stackerdb_chunks.push(chunk);
             } else {
                 assert!(NakamotoBlockBuilder::make_stackerdb_block_proposal(
                     &sort_db,
-                    i as u32,
+                    &stackerdbs,
                     &block,
-                    &miner_keys[i - 3]
+                    &miner_keys[i - 3],
+                    &miners_contract_id,
                 )
                 .unwrap()
                 .is_none());
diff --git a/stackslib/src/net/mod.rs b/stackslib/src/net/mod.rs
index d237fb1f89..cbfeb924b9 100644
--- a/stackslib/src/net/mod.rs
+++ b/stackslib/src/net/mod.rs
@@ -2135,6 +2135,25 @@ pub mod test {
             test_path
         }
 
+        /// Initialize the .miners StackerDB instance
+        pub fn init_stacker_db_miners(&mut self) {
+            let miner_contract_id = boot_code_id(MINERS_NAME, false);
+            let miner_stackerdb_config = NakamotoChainState::make_miners_stackerdb_config(
+                self.sortdb.as_mut().expect("No sortition DB found"),
+            )
+            .expect("Could not make {MINERS_NAME} StackerDB config");
+            let tx = self
+                .network
+                .stackerdbs
+                .tx_begin(miner_stackerdb_config.clone())
+                .expect("Could not begin {MINERS_NAME} StackerDB transaction");
+
+            tx.create_stackerdb(&miner_contract_id, &miner_stackerdb_config.signers)
+                .expect("Could not create {MINERS_NAME} StackerDB");
+            tx.commit()
+                .expect("Could not commit {MINERS_NAME} StackerDB transaction");
+        }
+
         fn init_stacker_dbs(
             root_path: &str,
             peerdb: &PeerDB,
diff --git a/stackslib/src/net/stackerdb/db.rs b/stackslib/src/net/stackerdb/db.rs
index 6034f3d059..3adc8845a7 100644
--- a/stackslib/src/net/stackerdb/db.rs
+++ b/stackslib/src/net/stackerdb/db.rs
@@ -567,6 +567,25 @@ impl StackerDBs {
         inner_get_slot_validation(&self.conn, smart_contract, slot_id)
     }
 
+    /// Get the latest version of a given Slot ID from the database.
+    /// Returns Ok(Some(version)) if a chunk exists at the given slot ID.
+    /// Returns Ok(None) if the chunk does not exist at the given slot ID.
+    /// Returns Err(..) if the DB does not exist, or some other DB error occurs
+    pub fn get_slot_version(
+        &self,
+        smart_contract: &QualifiedContractIdentifier,
+        slot_id: u32,
+    ) -> Result<Option<u32>, net_error> {
+        let stackerdb_id = self.get_stackerdb_id(smart_contract)?;
+        let qry = "SELECT version FROM chunks WHERE stackerdb_id = ?1 AND slot_id = ?2";
+        let args: &[&dyn ToSql] = &[&stackerdb_id, &slot_id];
+
+        self.conn
+            .query_row(qry, args, |row| row.get(0))
+            .optional()
+            .map_err(|e| e.into())
+    }
+
     /// Get the list of slot ID versions for a given DB instance at a given reward cycle
     pub fn get_slot_versions(
         &self,
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index c497c0e843..fe76069937 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -18,12 +18,15 @@ use std::thread;
 use std::thread::JoinHandle;
 use std::time::{Duration, Instant};
 
+use clarity::boot_util::boot_code_id;
 use clarity::vm::types::PrincipalData;
+use libsigner::{SignerSession, StackerDBSession};
 use stacks::burnchains::{Burnchain, BurnchainParameters};
 use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::burn::{BlockSnapshot, ConsensusHash};
 use stacks::chainstate::nakamoto::miner::{NakamotoBlockBuilder, NakamotoTenureInfo};
 use stacks::chainstate::nakamoto::{NakamotoBlock, NakamotoChainState};
+use stacks::chainstate::stacks::boot::MINERS_NAME;
 use stacks::chainstate::stacks::db::{StacksChainState, StacksHeaderInfo};
 use stacks::chainstate::stacks::{
     CoinbasePayload, Error as ChainstateError, StacksTransaction, StacksTransactionSigner,
@@ -31,6 +34,7 @@ use stacks::chainstate::stacks::{
     TransactionPayload, TransactionVersion,
 };
 use stacks::core::FIRST_BURNCHAIN_CONSENSUS_HASH;
+use stacks::net::stackerdb::StackerDBs;
 use stacks_common::types::chainstate::{StacksAddress, StacksBlockId};
 use stacks_common::types::{PrivateKey, StacksEpochId};
 use stacks_common::util::hash::Hash160;
@@ -95,6 +99,8 @@ pub struct BlockMinerThread {
     parent_tenure_id: StacksBlockId,
     /// Handle to the node's event dispatcher
     event_dispatcher: EventDispatcher,
+    /// The .miners stacker db session
+    miners_stackerdb: StackerDBSession,
 }
 
 impl BlockMinerThread {
@@ -105,6 +111,14 @@ impl BlockMinerThread {
         burn_block: BlockSnapshot,
         parent_tenure_id: StacksBlockId,
     ) -> BlockMinerThread {
+        let rpc_sock = rt.config.node.rpc_bind.parse().expect(&format!(
+            "Failed to parse socket: {}",
+            &rt.config.node.rpc_bind
+        ));
+
+        let miner_contract_id = boot_code_id(MINERS_NAME, rt.config.is_mainnet());
+
+        let miners_stackerdb = StackerDBSession::new(rpc_sock, miner_contract_id);
         BlockMinerThread {
             config: rt.config.clone(),
             globals: rt.globals.clone(),
@@ -115,6 +129,7 @@ impl BlockMinerThread {
             burn_block,
             event_dispatcher: rt.event_dispatcher.clone(),
             parent_tenure_id,
+            miners_stackerdb,
         }
     }
 
@@ -133,7 +148,9 @@ impl BlockMinerThread {
         if let Some(prior_miner) = prior_miner {
             Self::stop_miner(&self.globals, prior_miner);
         }
-
+        let miners_contract_id = boot_code_id(MINERS_NAME, self.config.is_mainnet());
+        let stackerdbs = StackerDBs::connect(&self.config.get_stacker_db_file_path(), true)
+            .expect("FATAL: failed to connect to stacker DB");
         // now, actually run this tenure
         loop {
             let new_block = loop {
@@ -159,7 +176,43 @@ impl BlockMinerThread {
                 }
             };
 
+            let sort_db = SortitionDB::open(
+                &self.config.get_burn_db_file_path(),
+                true,
+                self.burnchain.pox_constants.clone(),
+            )
+            .expect("FATAL: could not open sortition DB");
             if let Some(new_block) = new_block {
+                let Some(miner_privkey) = self.config.miner.mining_key else {
+                    warn!("No mining key configured, cannot mine");
+                    return;
+                };
+                match NakamotoBlockBuilder::make_stackerdb_block_proposal(
+                    &sort_db,
+                    &stackerdbs,
+                    &new_block,
+                    &miner_privkey,
+                    &miners_contract_id,
+                ) {
+                    Ok(Some(chunk)) => {
+                        // Propose the block to the observing signers through the .miners stackerdb instance
+                        match self.miners_stackerdb.put_chunk(chunk) {
+                            Ok(ack) => {
+                                info!("Proposed block to stackerdb: {ack:?}");
+                            }
+                            Err(e) => {
+                                warn!("Failed to propose block to stackerdb {e:?}");
+                                return;
+                            }
+                        }
+                    }
+                    Ok(None) => {
+                        warn!("Failed to propose block to stackerdb: no slot available");
+                    }
+                    Err(e) => {
+                        warn!("Failed to propose block to stackerdb: {e:?}");
+                    }
+                }
                 if let Some(self_signer) = self.config.self_signing() {
                     if let Err(e) = self.self_sign_and_broadcast(self_signer, new_block.clone()) {
                         warn!("Error self-signing block: {e:?}");
@@ -179,12 +232,6 @@ impl BlockMinerThread {
             }
 
             let wait_start = Instant::now();
-            let sort_db = SortitionDB::open(
-                &self.config.get_burn_db_file_path(),
-                true,
-                self.burnchain.pox_constants.clone(),
-            )
-            .expect("FATAL: could not open sortition DB");
             while wait_start.elapsed() < self.config.miner.wait_on_interim_blocks {
                 thread::sleep(Duration::from_millis(ABORT_TRY_AGAIN_MS));
                 if self.check_burn_tip_changed(&sort_db).is_err() {
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index d72914d047..5a3712001b 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -27,6 +27,7 @@ use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::coordinator::comm::CoordinatorChannels;
 use stacks::chainstate::nakamoto::miner::NakamotoBlockBuilder;
 use stacks::chainstate::nakamoto::NakamotoChainState;
+use stacks::chainstate::stacks::boot::MINERS_NAME;
 use stacks::chainstate::stacks::db::StacksChainState;
 use stacks::chainstate::stacks::miner::{BlockBuilder, BlockLimitFunction, TransactionResult};
 use stacks::chainstate::stacks::{StacksTransaction, ThresholdSignature, TransactionPayload};
@@ -39,6 +40,7 @@ use stacks::core::{
 use stacks::net::api::postblock_proposal::{
     BlockValidateReject, BlockValidateResponse, NakamotoBlockProposal, ValidateRejectCode,
 };
+use stacks::util_lib::boot::boot_code_id;
 use stacks_common::address::AddressHashMode;
 use stacks_common::codec::StacksMessageCodec;
 use stacks_common::consts::STACKS_EPOCH_MAX;
@@ -168,6 +170,9 @@ pub fn naka_neon_integration_conf(seed: Option<&[u8]>) -> (Config, StacksAddress
 
     conf.node.miner = true;
     conf.node.wait_time_for_microblocks = 500;
+    conf.node
+        .stacker_dbs
+        .push(boot_code_id(MINERS_NAME, conf.is_mainnet()));
     conf.burnchain.burn_fee_cap = 20000;
 
     conf.burnchain.username = Some("neon-tester".into());

From f3226a9b20a089ff8275ba4b15823db0110baba7 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Tue, 2 Jan 2024 16:07:12 -0500
Subject: [PATCH 0330/1166] Add naka integration test to check block written to
 stacker db .miners instance

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 .github/workflows/bitcoin-tests.yml           |   1 +
 Cargo.lock                                    |   1 +
 stackslib/Cargo.toml                          |   1 +
 .../src/tests/nakamoto_integrations.rs        | 120 +++++++++++++++++-
 4 files changed, 121 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/bitcoin-tests.yml b/.github/workflows/bitcoin-tests.yml
index 04c66bfae7..aa02b5e6ff 100644
--- a/.github/workflows/bitcoin-tests.yml
+++ b/.github/workflows/bitcoin-tests.yml
@@ -73,6 +73,7 @@ jobs:
           - tests::nakamoto_integrations::simple_neon_integration
           - tests::nakamoto_integrations::mine_multiple_per_tenure_integration
           - tests::nakamoto_integrations::block_proposal_api_endpoint
+          - tests::nakamoto_integrations::miner_writes_proposed_block_to_stackerdb
     steps:
       ## Setup test environment
       - name: Setup Test Environment
diff --git a/Cargo.lock b/Cargo.lock
index 135236c411..a22e40e3f5 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3616,6 +3616,7 @@ dependencies = [
  "integer-sqrt",
  "lazy_static",
  "libc",
+ "libsigner",
  "libstackerdb",
  "mio 0.6.23",
  "nix",
diff --git a/stackslib/Cargo.toml b/stackslib/Cargo.toml
index c505d8429b..748f5b07d3 100644
--- a/stackslib/Cargo.toml
+++ b/stackslib/Cargo.toml
@@ -54,6 +54,7 @@ clarity = { path = "../clarity" }
 stacks-common = { path = "../stacks-common" }
 pox-locking = { path = "../pox-locking" }
 libstackerdb = { path = "../libstackerdb" }
+libsigner = { path = "../libsigner" }
 siphasher = "0.3.7"
 wsts = {workspace = true}
 rand_core = {workspace = true}
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 5a3712001b..4f0a6d8d82 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -22,15 +22,16 @@ use clarity::vm::ast::ASTRules;
 use clarity::vm::costs::ExecutionCost;
 use clarity::vm::types::PrincipalData;
 use lazy_static::lazy_static;
+use libsigner::{SignerSession, StackerDBSession};
 use stacks::burnchains::MagicBytes;
 use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::coordinator::comm::CoordinatorChannels;
 use stacks::chainstate::nakamoto::miner::NakamotoBlockBuilder;
-use stacks::chainstate::nakamoto::NakamotoChainState;
+use stacks::chainstate::nakamoto::{NakamotoBlock, NakamotoChainState};
 use stacks::chainstate::stacks::boot::MINERS_NAME;
 use stacks::chainstate::stacks::db::StacksChainState;
 use stacks::chainstate::stacks::miner::{BlockBuilder, BlockLimitFunction, TransactionResult};
-use stacks::chainstate::stacks::{StacksTransaction, ThresholdSignature, TransactionPayload};
+use stacks::chainstate::stacks::{StacksTransaction, TransactionPayload};
 use stacks::core::{
     StacksEpoch, StacksEpochId, BLOCK_LIMIT_MAINNET_10, HELIUM_BLOCK_LIMIT_20,
     PEER_VERSION_EPOCH_1_0, PEER_VERSION_EPOCH_2_0, PEER_VERSION_EPOCH_2_05,
@@ -1310,3 +1311,118 @@ fn block_proposal_api_endpoint() {
 
     run_loop_thread.join().unwrap();
 }
+
+#[test]
+#[ignore]
+/// This test spins up a nakamoto-neon node and attempts to mine a single Nakamoto block.
+/// It starts in Epoch 2.0, mines with `neon_node` to Epoch 3.0, and then switches
+///  to Nakamoto operation (activating pox-4 by submitting a stack-stx tx). The BootLoop
+///  struct handles the epoch-2/3 tear-down and spin-up.
+/// This test makes the following assertions:
+///  * The proposed Nakamoto block is written to the .miners stackerdb
+fn miner_writes_proposed_block_to_stackerdb() {
+    if env::var("BITCOIND_TEST") != Ok("1".into()) {
+        return;
+    }
+
+    let (mut naka_conf, _miner_account) = naka_neon_integration_conf(None);
+    naka_conf.miner.wait_on_interim_blocks = Duration::from_secs(1000);
+    let sender_sk = Secp256k1PrivateKey::new();
+    // setup sender + recipient for a test stx transfer
+    let sender_addr = tests::to_addr(&sender_sk);
+    let send_amt = 1000;
+    let send_fee = 100;
+    naka_conf.add_initial_balance(
+        PrincipalData::from(sender_addr.clone()).to_string(),
+        send_amt + send_fee,
+    );
+    let stacker_sk = setup_stacker(&mut naka_conf);
+
+    test_observer::spawn();
+    let observer_port = test_observer::EVENT_OBSERVER_PORT;
+    naka_conf.events_observers.insert(EventObserverConfig {
+        endpoint: format!("localhost:{observer_port}"),
+        events_keys: vec![EventKeyType::AnyEvent],
+    });
+
+    let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone());
+    btcd_controller
+        .start_bitcoind()
+        .expect("Failed starting bitcoind");
+    let mut btc_regtest_controller = BitcoinRegtestController::new(naka_conf.clone(), None);
+    btc_regtest_controller.bootstrap_chain(201);
+
+    let mut run_loop = boot_nakamoto::BootRunLoop::new(naka_conf.clone()).unwrap();
+    let run_loop_stopper = run_loop.get_termination_switch();
+    let Counters {
+        blocks_processed,
+        naka_submitted_vrfs: vrfs_submitted,
+        naka_submitted_commits: commits_submitted,
+        ..
+    } = run_loop.counters();
+
+    let coord_channel = run_loop.coordinator_channels();
+
+    let run_loop_thread = thread::spawn(move || run_loop.start(None, 0));
+    wait_for_runloop(&blocks_processed);
+    boot_to_epoch_3(
+        &naka_conf,
+        &blocks_processed,
+        stacker_sk,
+        StacksPublicKey::new(),
+        &mut btc_regtest_controller,
+    );
+    let rpc_sock = naka_conf
+        .node
+        .rpc_bind
+        .clone()
+        .parse()
+        .expect("Failed to parse socket");
+
+    info!("Nakamoto miner started...");
+    // first block wakes up the run loop, wait until a key registration has been submitted.
+    next_block_and(&mut btc_regtest_controller, 60, || {
+        let vrf_count = vrfs_submitted.load(Ordering::SeqCst);
+        Ok(vrf_count >= 1)
+    })
+    .unwrap();
+
+    // second block should confirm the VRF register, wait until a block commit is submitted
+    next_block_and(&mut btc_regtest_controller, 60, || {
+        let commits_count = commits_submitted.load(Ordering::SeqCst);
+        Ok(commits_count >= 1)
+    })
+    .unwrap();
+
+    // Mine 1 nakamoto tenure
+    next_block_and_mine_commit(
+        &mut btc_regtest_controller,
+        60,
+        &coord_channel,
+        &commits_submitted,
+    )
+    .unwrap();
+
+    let chunk = std::thread::spawn(move || {
+        let miner_contract_id = boot_code_id(MINERS_NAME, false);
+        let mut miners_stackerdb = StackerDBSession::new(rpc_sock, miner_contract_id);
+        miners_stackerdb
+            .get_latest_chunk(0)
+            .expect("Failed to get latest chunk from the miner slot ID")
+            .expect("No chunk found")
+    })
+    .join()
+    .expect("Failed to join chunk handle");
+    // We should now successfully deserialize a chunk
+    let _block = NakamotoBlock::consensus_deserialize(&mut &chunk[..])
+        .expect("Failed to deserialize chunk into block");
+
+    coord_channel
+        .lock()
+        .expect("Mutex poisoned")
+        .stop_chains_coordinator();
+
+    run_loop_stopper.store(false, Ordering::SeqCst);
+
+    run_loop_thread.join().unwrap();
+}

From 75c9f99c482be6a983b3d0e5ff6c819393069276 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Tue, 2 Jan 2024 16:07:29 -0500
Subject: [PATCH 0331/1166] CRC: failing to make the stackerdb should fail
 refreshing the burnchain view

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stackslib/src/net/p2p.rs | 46 +++++++++++++++-------------------------
 1 file changed, 17 insertions(+), 29 deletions(-)

diff --git a/stackslib/src/net/p2p.rs b/stackslib/src/net/p2p.rs
index ddc07794a4..d6ed1bca41 100644
--- a/stackslib/src/net/p2p.rs
+++ b/stackslib/src/net/p2p.rs
@@ -5336,35 +5336,23 @@ impl PeerNetwork {
             let mut new_stackerdb_configs = HashMap::new();
             let stacker_db_configs = mem::replace(&mut self.stacker_db_configs, HashMap::new());
             for (stackerdb_contract_id, stackerdb_config) in stacker_db_configs.into_iter() {
-                let new_config =
-                    if stackerdb_contract_id == boot_code_id(MINERS_NAME, chainstate.mainnet) {
-                        // .miners contract -- directly generate the config
-                        let miners_config =
-                            match NakamotoChainState::make_miners_stackerdb_config(sortdb) {
-                                Ok(config) => config,
-                                Err(e) => {
-                                    warn!("Failed to generate .miners config: {:?}", &e);
-                                    continue;
-                                }
-                            };
-                        miners_config
-                    } else {
-                        // normal stackerdb contract
-                        match StackerDBConfig::from_smart_contract(
-                            chainstate,
-                            sortdb,
-                            &stackerdb_contract_id,
-                        ) {
-                            Ok(config) => config,
-                            Err(e) => {
-                                warn!(
-                                    "Failed to load StackerDB config for {}: {:?}",
-                                    &stackerdb_contract_id, &e
-                                );
-                                StackerDBConfig::noop()
-                            }
-                        }
-                    };
+                let new_config = if stackerdb_contract_id
+                    == boot_code_id(MINERS_NAME, chainstate.mainnet)
+                {
+                    // .miners contract -- directly generate the config
+                    NakamotoChainState::make_miners_stackerdb_config(sortdb)?
+                } else {
+                    // normal stackerdb contract
+                    StackerDBConfig::from_smart_contract(chainstate, sortdb, &stackerdb_contract_id)
+                        .unwrap_or_else(|e| {
+                            warn!(
+                                "Failed to load StackerDB config";
+                                "contract" => %stackerdb_contract_id,
+                                "err" => ?e,
+                            );
+                            StackerDBConfig::noop()
+                        })
+                };
                 if new_config != stackerdb_config && new_config.signers.len() > 0 {
                     if let Err(e) =
                         self.create_or_reconfigure_stackerdb(&stackerdb_contract_id, &new_config)

From a62da59059c959eeabe663a45d99957fa56e7130 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 3 Jan 2024 08:23:19 -0500
Subject: [PATCH 0332/1166] CRC: replace dup code with boot_code_tx_auth in
 clarity.rs

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stackslib/src/clarity_vm/clarity.rs | 55 +++--------------------------
 1 file changed, 5 insertions(+), 50 deletions(-)

diff --git a/stackslib/src/clarity_vm/clarity.rs b/stackslib/src/clarity_vm/clarity.rs
index 496cde96bc..9a18decfdb 100644
--- a/stackslib/src/clarity_vm/clarity.rs
+++ b/stackslib/src/clarity_vm/clarity.rs
@@ -831,16 +831,7 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
 
             let boot_code_address = boot_code_addr(self.mainnet);
 
-            let boot_code_auth = TransactionAuth::Standard(
-                TransactionSpendingCondition::Singlesig(SinglesigSpendingCondition {
-                    signer: boot_code_address.bytes.clone(),
-                    hash_mode: SinglesigHashMode::P2PKH,
-                    key_encoding: TransactionPublicKeyEncoding::Uncompressed,
-                    nonce: 0,
-                    tx_fee: 0,
-                    signature: MessageSignature::empty(),
-                }),
-            );
+            let boot_code_auth = boot_code_tx_auth(boot_code_address.clone());
 
             let costs_2_contract_tx =
                 StacksTransaction::new(tx_version.clone(), boot_code_auth.clone(), payload);
@@ -921,16 +912,7 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
 
             let boot_code_address = boot_code_addr(mainnet);
 
-            let boot_code_auth = TransactionAuth::Standard(
-                TransactionSpendingCondition::Singlesig(SinglesigSpendingCondition {
-                    signer: boot_code_address.bytes.clone(),
-                    hash_mode: SinglesigHashMode::P2PKH,
-                    key_encoding: TransactionPublicKeyEncoding::Uncompressed,
-                    nonce: 0,
-                    tx_fee: 0,
-                    signature: MessageSignature::empty(),
-                }),
-            );
+            let boot_code_auth = boot_code_tx_auth(boot_code_address.clone());
 
             let boot_code_account = self
                 .get_boot_code_account()
@@ -1179,16 +1161,7 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
 
             let boot_code_address = boot_code_addr(mainnet);
 
-            let boot_code_auth = TransactionAuth::Standard(
-                TransactionSpendingCondition::Singlesig(SinglesigSpendingCondition {
-                    signer: boot_code_address.bytes.clone(),
-                    hash_mode: SinglesigHashMode::P2PKH,
-                    key_encoding: TransactionPublicKeyEncoding::Uncompressed,
-                    nonce: 0,
-                    tx_fee: 0,
-                    signature: MessageSignature::empty(),
-                }),
-            );
+            let boot_code_auth = boot_code_tx_auth(boot_code_address.clone());
 
             let boot_code_account = self
                 .get_boot_code_account()
@@ -1295,16 +1268,7 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
             };
             let boot_code_address = boot_code_addr(mainnet);
 
-            let boot_code_auth = TransactionAuth::Standard(
-                TransactionSpendingCondition::Singlesig(SinglesigSpendingCondition {
-                    signer: boot_code_address.bytes.clone(),
-                    hash_mode: SinglesigHashMode::P2PKH,
-                    key_encoding: TransactionPublicKeyEncoding::Uncompressed,
-                    nonce: 0,
-                    tx_fee: 0,
-                    signature: MessageSignature::empty(),
-                }),
-            );
+            let boot_code_auth = boot_code_tx_auth(boot_code_address.clone());
             let boot_code_account = self
                 .get_boot_code_account()
                 .expect("FATAL: did not get boot account");
@@ -1369,16 +1333,7 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
 
             let boot_code_address = boot_code_addr(mainnet);
 
-            let boot_code_auth = TransactionAuth::Standard(
-                TransactionSpendingCondition::Singlesig(SinglesigSpendingCondition {
-                    signer: boot_code_address.bytes.clone(),
-                    hash_mode: SinglesigHashMode::P2PKH,
-                    key_encoding: TransactionPublicKeyEncoding::Uncompressed,
-                    nonce: 0,
-                    tx_fee: 0,
-                    signature: MessageSignature::empty(),
-                }),
-            );
+            let boot_code_auth = boot_code_tx_auth(boot_code_address.clone());
 
             let boot_code_account = self
                 .get_boot_code_account()

From c5c151d9a090b8875d079f134bf24cf45ab75b38 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 3 Jan 2024 09:40:43 -0500
Subject: [PATCH 0333/1166] CRC: cleanup make_miners_stackerdb_config indexing

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 .../src/chainstate/nakamoto/tests/mod.rs      | 52 ++++++++++---------
 1 file changed, 27 insertions(+), 25 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/tests/mod.rs b/stackslib/src/chainstate/nakamoto/tests/mod.rs
index a2652d2564..985311ff6b 100644
--- a/stackslib/src/chainstate/nakamoto/tests/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/mod.rs
@@ -1658,7 +1658,7 @@ fn test_make_miners_stackerdb_config() {
         test_signers.aggregate_public_key.clone(),
     );
 
-    let miner_keys: Vec<_> = (3..13).map(|_| StacksPrivateKey::new()).collect();
+    let miner_keys: Vec<_> = (0..10).map(|_| StacksPrivateKey::new()).collect();
     let miner_hash160s: Vec<_> = miner_keys
         .iter()
         .map(|miner_privkey| {
@@ -1684,17 +1684,18 @@ fn test_make_miners_stackerdb_config() {
     let stackerdbs = peer.network.stackerdbs;
     let miners_contract_id = boot_code_id(MINERS_NAME, false);
 
-    // make two leader keys (miner 1 and miner 2)
+    // make leader keys for each miner
     let mut miners = vec![];
-    for i in 3..13 {
+    for (i, miner_hash160) in miner_hash160s.iter().enumerate() {
+        let id = i as u8 + 1; // Add 1 to avoid 0-ed Txid.
         let vrf_privkey = VRFPrivateKey::new();
         let vrf_pubkey = VRFPublicKey::from_private(&vrf_privkey);
         let miner = LeaderKeyRegisterOp {
             consensus_hash: last_snapshot.consensus_hash.clone(),
             public_key: vrf_pubkey,
-            memo: miner_hash160s[i - 3].0.to_vec(),
-            txid: Txid([i as u8; 32]),
-            vtxindex: 1 + (i as u32),
+            memo: miner_hash160.0.to_vec(),
+            txid: Txid([id; 32]),
+            vtxindex: 1 + (id as u32),
             block_height: last_snapshot.block_height + 1,
             burn_header_hash: last_snapshot.burn_header_hash.clone(),
         };
@@ -1705,29 +1706,30 @@ fn test_make_miners_stackerdb_config() {
     let mut stackerdb_chunks = vec![];
 
     // synthesize some sortitions and corresponding winning block-commits
-    for i in 3..13 {
+    for (i, miner) in miners.iter().enumerate() {
         // no winner every 3rd sortition
-        let sortition = i > 3 && i % 3 != 0;
+        let sortition = i % 3 != 0;
+        let id = i as u8 + 1; // Add 1 to avoid 0-ed IDs.
         let winning_txid = if sortition {
-            Txid([(i as u8); 32])
+            Txid([id; 32])
         } else {
             Txid([0x00; 32])
         };
-        let winning_block_hash = BlockHeaderHash([(i as u8); 32]);
+        let winning_block_hash = BlockHeaderHash([id; 32]);
         let snapshot = BlockSnapshot {
             accumulated_coinbase_ustx: 0,
             pox_valid: true,
             block_height: last_snapshot.block_height + 1,
             burn_header_timestamp: get_epoch_time_secs(),
-            burn_header_hash: BurnchainHeaderHash([(i as u8); 32]),
-            sortition_id: SortitionId([(i as u8); 32]),
+            burn_header_hash: BurnchainHeaderHash([id; 32]),
+            sortition_id: SortitionId([id; 32]),
             parent_sortition_id: last_snapshot.sortition_id.clone(),
             parent_burn_header_hash: last_snapshot.burn_header_hash.clone(),
-            consensus_hash: ConsensusHash([(i as u8); 20]),
-            ops_hash: OpsHash([(i as u8); 32]),
+            consensus_hash: ConsensusHash([id; 20]),
+            ops_hash: OpsHash([id; 32]),
             total_burn: 0,
             sortition,
-            sortition_hash: SortitionHash([(i as u8); 32]),
+            sortition_hash: SortitionHash([id; 32]),
             winning_block_txid: winning_txid.clone(),
             winning_stacks_block_hash: winning_block_hash.clone(),
             index_root: TrieHash([0u8; 32]),
@@ -1736,19 +1738,19 @@ fn test_make_miners_stackerdb_config() {
             stacks_block_height: last_snapshot.stacks_block_height,
             arrival_index: 0,
             canonical_stacks_tip_height: last_snapshot.canonical_stacks_tip_height + 10,
-            canonical_stacks_tip_hash: BlockHeaderHash([((i + 1) as u8); 32]),
-            canonical_stacks_tip_consensus_hash: ConsensusHash([((i + 1) as u8); 20]),
+            canonical_stacks_tip_hash: BlockHeaderHash([id; 32]),
+            canonical_stacks_tip_consensus_hash: ConsensusHash([id; 20]),
             miner_pk_hash: None,
         };
         let winning_block_commit = LeaderBlockCommitOp {
             sunset_burn: 0,
-            block_header_hash: BlockHeaderHash([(i as u8); 32]),
-            new_seed: VRFSeed([(i as u8); 32]),
+            block_header_hash: BlockHeaderHash([id; 32]),
+            new_seed: VRFSeed([id; 32]),
             parent_block_ptr: last_snapshot.block_height as u32,
             parent_vtxindex: 1,
             // miners take turns winning
-            key_block_ptr: miners[i - 3].block_height as u32,
-            key_vtxindex: miners[i - 3].vtxindex as u16,
+            key_block_ptr: miner.block_height as u32,
+            key_vtxindex: miner.vtxindex as u16,
             memo: vec![STACKS_EPOCH_3_0_MARKER],
             commit_outs: vec![],
 
@@ -1770,7 +1772,7 @@ fn test_make_miners_stackerdb_config() {
             burn_header_hash: snapshot.burn_header_hash.clone(),
         };
 
-        let winning_ops = if i == 3 {
+        let winning_ops = if i == 0 {
             // first snapshot includes leader keys
             miners
                 .clone()
@@ -1815,7 +1817,7 @@ fn test_make_miners_stackerdb_config() {
             .unwrap()
             .unwrap();
 
-        if i > 3 {
+        if i > 0 {
             // have block-commit
             // check the stackerdb config as of this chain tip
             let stackerdb_config =
@@ -1848,7 +1850,7 @@ fn test_make_miners_stackerdb_config() {
                     &sort_db,
                     &stackerdbs,
                     &block,
-                    &miner_keys[i - 3],
+                    &miner_keys[i],
                     &miners_contract_id,
                 )
                 .unwrap()
@@ -1861,7 +1863,7 @@ fn test_make_miners_stackerdb_config() {
                     &sort_db,
                     &stackerdbs,
                     &block,
-                    &miner_keys[i - 3],
+                    &miner_keys[i],
                     &miners_contract_id,
                 )
                 .unwrap()

From f6a142ac6412677d11fad7f109543802615e2772 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 3 Jan 2024 09:41:54 -0500
Subject: [PATCH 0334/1166] CRC: the first ever miner config should include the
 test peer miner private key

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 .../src/chainstate/nakamoto/tests/mod.rs      | 157 +++++++++---------
 1 file changed, 79 insertions(+), 78 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/tests/mod.rs b/stackslib/src/chainstate/nakamoto/tests/mod.rs
index 985311ff6b..5d6225f5f7 100644
--- a/stackslib/src/chainstate/nakamoto/tests/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/mod.rs
@@ -1658,6 +1658,7 @@ fn test_make_miners_stackerdb_config() {
         test_signers.aggregate_public_key.clone(),
     );
 
+    let naka_miner_hash160 = peer.miner.nakamoto_miner_hash160();
     let miner_keys: Vec<_> = (0..10).map(|_| StacksPrivateKey::new()).collect();
     let miner_hash160s: Vec<_> = miner_keys
         .iter()
@@ -1790,85 +1791,79 @@ fn test_make_miners_stackerdb_config() {
             }
         };
 
-        {
-            let mut tx = SortitionHandleTx::begin(sort_db, &last_snapshot.sortition_id).unwrap();
-            let _index_root = tx
-                .append_chain_tip_snapshot(
-                    &last_snapshot,
-                    &snapshot,
-                    &winning_ops,
-                    &vec![],
-                    None,
-                    None,
-                    None,
-                )
-                .unwrap();
-            tx.test_update_canonical_stacks_tip(
-                &snapshot.sortition_id,
-                &snapshot.canonical_stacks_tip_consensus_hash,
-                &snapshot.canonical_stacks_tip_hash,
-                snapshot.canonical_stacks_tip_height,
+        let mut tx = SortitionHandleTx::begin(sort_db, &last_snapshot.sortition_id).unwrap();
+        let _index_root = tx
+            .append_chain_tip_snapshot(
+                &last_snapshot,
+                &snapshot,
+                &winning_ops,
+                &vec![],
+                None,
+                None,
+                None,
             )
             .unwrap();
-            tx.commit().unwrap();
-        }
+        tx.test_update_canonical_stacks_tip(
+            &snapshot.sortition_id,
+            &snapshot.canonical_stacks_tip_consensus_hash,
+            &snapshot.canonical_stacks_tip_hash,
+            snapshot.canonical_stacks_tip_height,
+        )
+        .unwrap();
+        tx.commit().unwrap();
 
         last_snapshot = SortitionDB::get_block_snapshot(sort_db.conn(), &snapshot.sortition_id)
             .unwrap()
             .unwrap();
 
-        if i > 0 {
-            // have block-commit
-            // check the stackerdb config as of this chain tip
-            let stackerdb_config =
-                NakamotoChainState::make_miners_stackerdb_config(sort_db).unwrap();
-            eprintln!(
-                "stackerdb_config at i = {} (sorition? {}): {:?}",
-                &i, sortition, &stackerdb_config
-            );
-
-            stackerdb_configs.push(stackerdb_config);
-
-            // make a stackerdb chunk for a hypothetical block
-            let header = NakamotoBlockHeader {
-                version: 1,
-                chain_length: 2,
-                burn_spent: 3,
-                consensus_hash: ConsensusHash([0x04; 20]),
-                parent_block_id: StacksBlockId([0x05; 32]),
-                tx_merkle_root: Sha512Trunc256Sum([0x06; 32]),
-                state_index_root: TrieHash([0x07; 32]),
-                miner_signature: MessageSignature::empty(),
-                signer_signature: ThresholdSignature::mock(),
-            };
-            let block = NakamotoBlock {
-                header,
-                txs: vec![],
-            };
-            if sortition {
-                let chunk = NakamotoBlockBuilder::make_stackerdb_block_proposal(
-                    &sort_db,
-                    &stackerdbs,
-                    &block,
-                    &miner_keys[i],
-                    &miners_contract_id,
-                )
-                .unwrap()
-                .unwrap();
-                assert_eq!(chunk.slot_version, 1);
-                assert_eq!(chunk.data, block.serialize_to_vec());
-                stackerdb_chunks.push(chunk);
-            } else {
-                assert!(NakamotoBlockBuilder::make_stackerdb_block_proposal(
-                    &sort_db,
-                    &stackerdbs,
-                    &block,
-                    &miner_keys[i],
-                    &miners_contract_id,
-                )
-                .unwrap()
-                .is_none());
-            }
+        // check the stackerdb config as of this chain tip
+        let stackerdb_config = NakamotoChainState::make_miners_stackerdb_config(sort_db).unwrap();
+        eprintln!(
+            "stackerdb_config at i = {} (sorition? {}): {:?}",
+            &i, sortition, &stackerdb_config
+        );
+
+        stackerdb_configs.push(stackerdb_config);
+
+        // make a stackerdb chunk for a hypothetical block
+        let header = NakamotoBlockHeader {
+            version: 1,
+            chain_length: 2,
+            burn_spent: 3,
+            consensus_hash: ConsensusHash([0x04; 20]),
+            parent_block_id: StacksBlockId([0x05; 32]),
+            tx_merkle_root: Sha512Trunc256Sum([0x06; 32]),
+            state_index_root: TrieHash([0x07; 32]),
+            miner_signature: MessageSignature::empty(),
+            signer_signature: ThresholdSignature::mock(),
+        };
+        let block = NakamotoBlock {
+            header,
+            txs: vec![],
+        };
+        if sortition {
+            let chunk = NakamotoBlockBuilder::make_stackerdb_block_proposal(
+                &sort_db,
+                &stackerdbs,
+                &block,
+                &miner_keys[i],
+                &miners_contract_id,
+            )
+            .unwrap()
+            .unwrap();
+            assert_eq!(chunk.slot_version, 1);
+            assert_eq!(chunk.data, block.serialize_to_vec());
+            stackerdb_chunks.push(chunk);
+        } else {
+            assert!(NakamotoBlockBuilder::make_stackerdb_block_proposal(
+                &sort_db,
+                &stackerdbs,
+                &block,
+                &miner_keys[i],
+                &miners_contract_id,
+            )
+            .unwrap()
+            .is_none());
         }
     }
     // miners are "stable" across snapshots
@@ -1897,26 +1892,32 @@ fn test_make_miners_stackerdb_config() {
     assert!(stackerdb_chunks[4].verify(&miner_addrs[7]).unwrap());
     assert!(stackerdb_chunks[5].verify(&miner_addrs[8]).unwrap());
 
-    assert_eq!(miner_hashbytes[0].0, miner_hash160s[1]);
+    // There is no block commit associated with the first ever sortition.
+    // Both the first and second writers will be the same miner (the default for the test peer)
+    assert_eq!(miner_hashbytes[0].0, naka_miner_hash160);
+    assert_eq!(miner_hashbytes[0].1, naka_miner_hash160);
+    assert_eq!(miner_hashbytes[1].1, naka_miner_hash160);
+
     assert_eq!(miner_hashbytes[1].0, miner_hash160s[1]);
     assert_eq!(miner_hashbytes[2].0, miner_hash160s[1]);
+    assert_eq!(miner_hashbytes[3].0, miner_hash160s[1]);
 
-    assert_eq!(miner_hashbytes[1].1, miner_hash160s[2]);
     assert_eq!(miner_hashbytes[2].1, miner_hash160s[2]);
     assert_eq!(miner_hashbytes[3].1, miner_hash160s[2]);
+    assert_eq!(miner_hashbytes[4].1, miner_hash160s[2]);
 
-    assert_eq!(miner_hashbytes[3].0, miner_hash160s[4]);
     assert_eq!(miner_hashbytes[4].0, miner_hash160s[4]);
     assert_eq!(miner_hashbytes[5].0, miner_hash160s[4]);
+    assert_eq!(miner_hashbytes[6].0, miner_hash160s[4]);
 
-    assert_eq!(miner_hashbytes[4].1, miner_hash160s[5]);
     assert_eq!(miner_hashbytes[5].1, miner_hash160s[5]);
     assert_eq!(miner_hashbytes[6].1, miner_hash160s[5]);
+    assert_eq!(miner_hashbytes[7].1, miner_hash160s[5]);
 
-    assert_eq!(miner_hashbytes[6].0, miner_hash160s[7]);
     assert_eq!(miner_hashbytes[7].0, miner_hash160s[7]);
     assert_eq!(miner_hashbytes[8].0, miner_hash160s[7]);
+    assert_eq!(miner_hashbytes[9].0, miner_hash160s[7]);
 
-    assert_eq!(miner_hashbytes[7].1, miner_hash160s[8]);
     assert_eq!(miner_hashbytes[8].1, miner_hash160s[8]);
+    assert_eq!(miner_hashbytes[9].1, miner_hash160s[8]);
 }

From 767009bd209b2ed27906294f286e89af0c3ca97b Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 5 Jan 2024 11:15:46 -0500
Subject: [PATCH 0335/1166] Always create stacker dbs if they don't exist

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 .../chainstate/nakamoto/coordinator/tests.rs  |   6 +-
 stackslib/src/net/mod.rs                      |  67 ++++------
 stackslib/src/net/p2p.rs                      |  84 ++-----------
 stackslib/src/net/stackerdb/mod.rs            | 115 +++++++++++++++++-
 testnet/stacks-node/src/neon_node.rs          |  83 ++++---------
 5 files changed, 177 insertions(+), 178 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index d4198dfd2c..df115a6fba 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -88,7 +88,6 @@ fn advance_to_nakamoto(peer: &mut TestPeer) {
         peer.tenure_with_txs(&txs, &mut peer_nonce);
     }
     // peer is at the start of cycle 8
-    peer.init_stacker_db_miners();
 }
 
 /// Make a peer and transition it into the Nakamoto epoch.
@@ -99,7 +98,6 @@ 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,
@@ -113,6 +111,10 @@ pub fn boot_nakamoto(
     // first 25 blocks are boot-up
     // reward cycle 6 instantiates pox-3
     // we stack in reward cycle 7 so pox-3 is evaluated to find reward set participation
+    peer_config.aggregate_public_key = Some(aggregate_public_key.clone());
+    peer_config
+        .stacker_dbs
+        .push(boot_code_id(MINERS_NAME, false));
     peer_config.epochs = Some(StacksEpoch::unit_test_3_0_only(37));
     peer_config.initial_balances = vec![(addr.to_account_principal(), 1_000_000_000_000_000_000)];
     peer_config.initial_balances.append(&mut initial_balances);
diff --git a/stackslib/src/net/mod.rs b/stackslib/src/net/mod.rs
index cbfeb924b9..cd5bafbc1b 100644
--- a/stackslib/src/net/mod.rs
+++ b/stackslib/src/net/mod.rs
@@ -2135,46 +2135,16 @@ pub mod test {
             test_path
         }
 
-        /// Initialize the .miners StackerDB instance
-        pub fn init_stacker_db_miners(&mut self) {
-            let miner_contract_id = boot_code_id(MINERS_NAME, false);
-            let miner_stackerdb_config = NakamotoChainState::make_miners_stackerdb_config(
-                self.sortdb.as_mut().expect("No sortition DB found"),
-            )
-            .expect("Could not make {MINERS_NAME} StackerDB config");
-            let tx = self
-                .network
-                .stackerdbs
-                .tx_begin(miner_stackerdb_config.clone())
-                .expect("Could not begin {MINERS_NAME} StackerDB transaction");
-
-            tx.create_stackerdb(&miner_contract_id, &miner_stackerdb_config.signers)
-                .expect("Could not create {MINERS_NAME} StackerDB");
-            tx.commit()
-                .expect("Could not commit {MINERS_NAME} StackerDB transaction");
-        }
-
-        fn init_stacker_dbs(
+        fn init_stackerdb_syncs(
             root_path: &str,
             peerdb: &PeerDB,
-            stacker_dbs: &[QualifiedContractIdentifier],
-            stacker_db_configs: &[Option<StackerDBConfig>],
+            stacker_dbs: &mut HashMap<QualifiedContractIdentifier, StackerDBConfig>,
         ) -> HashMap<QualifiedContractIdentifier, (StackerDBConfig, StackerDBSync<PeerNetworkComms>)>
         {
             let stackerdb_path = format!("{}/stacker_db.sqlite", root_path);
             let mut stacker_db_syncs = HashMap::new();
             let local_peer = PeerDB::get_local_peer(peerdb.conn()).unwrap();
-            for (i, contract_id) in stacker_dbs.iter().enumerate() {
-                let mut db_config = if let Some(config_opt) = stacker_db_configs.get(i) {
-                    if let Some(db_config) = config_opt.as_ref() {
-                        db_config.clone()
-                    } else {
-                        StackerDBConfig::noop()
-                    }
-                } else {
-                    StackerDBConfig::noop()
-                };
-
+            for (i, (contract_id, db_config)) in stacker_dbs.iter_mut().enumerate() {
                 let initial_peers = PeerDB::find_stacker_db_replicas(
                     peerdb.conn(),
                     local_peer.network_id,
@@ -2431,14 +2401,31 @@ pub mod test {
                     .unwrap()
             };
             let stackerdb_path = format!("{}/stacker_db.sqlite", &test_path);
+            let mut stacker_dbs_conn = StackerDBs::connect(&stackerdb_path, true).unwrap();
             let relayer_stacker_dbs = StackerDBs::connect(&stackerdb_path, true).unwrap();
             let p2p_stacker_dbs = StackerDBs::connect(&stackerdb_path, true).unwrap();
-            let stacker_dbs = Self::init_stacker_dbs(
-                &test_path,
-                &peerdb,
-                &config.stacker_dbs,
-                &config.stacker_db_configs,
-            );
+
+            let contracts: Vec<_> = config
+                .stacker_dbs
+                .iter()
+                .enumerate()
+                .map(|(i, stackerdb)| {
+                    (
+                        stackerdb.clone(),
+                        config.stacker_db_configs.get(i).unwrap_or(&None).clone(),
+                    )
+                })
+                .collect();
+            let mut stackerdb_configs = stacker_dbs_conn
+                .create_or_reconfigure_stackerdb(
+                    &mut stacks_node.chainstate,
+                    &sortdb,
+                    contracts.as_slice(),
+                )
+                .expect("Failed to refresh stackerdb configs");
+
+            let stacker_db_syncs =
+                Self::init_stackerdb_syncs(&test_path, &peerdb, &mut stackerdb_configs);
 
             let mut peer_network = PeerNetwork::new(
                 peerdb,
@@ -2449,7 +2436,7 @@ pub mod test {
                 config.burnchain.clone(),
                 burnchain_view,
                 config.connection_opts.clone(),
-                stacker_dbs,
+                stacker_db_syncs,
                 epochs.clone(),
             );
             peer_network.set_stacker_db_configs(config.get_stacker_db_configs());
diff --git a/stackslib/src/net/p2p.rs b/stackslib/src/net/p2p.rs
index d6ed1bca41..0306e92d60 100644
--- a/stackslib/src/net/p2p.rs
+++ b/stackslib/src/net/p2p.rs
@@ -5196,46 +5196,6 @@ impl PeerNetwork {
         &self.stacker_db_configs
     }
 
-    /// Create or reconfigure a StackerDB.
-    /// Fails only if the underlying DB fails
-    fn create_or_reconfigure_stackerdb(
-        &mut self,
-        stackerdb_contract_id: &QualifiedContractIdentifier,
-        new_config: &StackerDBConfig,
-    ) -> Result<(), db_error> {
-        debug!("Reconfiguring StackerDB {}...", stackerdb_contract_id);
-        let tx = self.stackerdbs.tx_begin(new_config.clone())?;
-        match tx.reconfigure_stackerdb(stackerdb_contract_id, &new_config.signers) {
-            Ok(..) => {}
-            Err(net_error::NoSuchStackerDB(..)) => {
-                // need to create it first
-                info!(
-                    "Creating local replica of StackerDB {}",
-                    stackerdb_contract_id
-                );
-                test_debug!(
-                    "Creating local replica of StackerDB {} with config {:?}",
-                    stackerdb_contract_id,
-                    &new_config
-                );
-                if let Err(e) = tx.create_stackerdb(stackerdb_contract_id, &new_config.signers) {
-                    warn!(
-                        "Failed to create StackerDB replica {}: {:?}",
-                        stackerdb_contract_id, &e
-                    );
-                }
-            }
-            Err(e) => {
-                warn!(
-                    "Failed to reconfigure StackerDB replica {}: {:?}",
-                    stackerdb_contract_id, &e
-                );
-            }
-        }
-        tx.commit()?;
-        Ok(())
-    }
-
     /// Refresh view of burnchain, if needed.
     /// If the burnchain view changes, then take the following additional steps:
     /// * hint to the inventory sync state-machine to restart, since we potentially have a new
@@ -5333,40 +5293,16 @@ impl PeerNetwork {
                 .unwrap_or(Txid([0x00; 32]));
 
             // refresh stackerdb configs
-            let mut new_stackerdb_configs = HashMap::new();
-            let stacker_db_configs = mem::replace(&mut self.stacker_db_configs, HashMap::new());
-            for (stackerdb_contract_id, stackerdb_config) in stacker_db_configs.into_iter() {
-                let new_config = if stackerdb_contract_id
-                    == boot_code_id(MINERS_NAME, chainstate.mainnet)
-                {
-                    // .miners contract -- directly generate the config
-                    NakamotoChainState::make_miners_stackerdb_config(sortdb)?
-                } else {
-                    // normal stackerdb contract
-                    StackerDBConfig::from_smart_contract(chainstate, sortdb, &stackerdb_contract_id)
-                        .unwrap_or_else(|e| {
-                            warn!(
-                                "Failed to load StackerDB config";
-                                "contract" => %stackerdb_contract_id,
-                                "err" => ?e,
-                            );
-                            StackerDBConfig::noop()
-                        })
-                };
-                if new_config != stackerdb_config && new_config.signers.len() > 0 {
-                    if let Err(e) =
-                        self.create_or_reconfigure_stackerdb(&stackerdb_contract_id, &new_config)
-                    {
-                        warn!(
-                            "Failed to create or reconfigure StackerDB {}: DB error {:?}",
-                            &stackerdb_contract_id, &e
-                        );
-                    }
-                }
-                new_stackerdb_configs.insert(stackerdb_contract_id.clone(), new_config);
-            }
-
-            self.stacker_db_configs = new_stackerdb_configs;
+            let contracts: Vec<_> = self
+                .stacker_db_configs
+                .iter()
+                .map(|(contract_id, config)| (contract_id.clone(), Some(config.clone())))
+                .collect();
+            self.stacker_db_configs = self.stackerdbs.create_or_reconfigure_stackerdb(
+                chainstate,
+                sortdb,
+                contracts.as_slice(),
+            )?;
         }
 
         if sn.canonical_stacks_tip_hash != self.burnchain_tip.canonical_stacks_tip_hash
diff --git a/stackslib/src/net/stackerdb/mod.rs b/stackslib/src/net/stackerdb/mod.rs
index 8520cec1f0..bdc6082f8b 100644
--- a/stackslib/src/net/stackerdb/mod.rs
+++ b/stackslib/src/net/stackerdb/mod.rs
@@ -127,6 +127,10 @@ use stacks_common::util::get_epoch_time_secs;
 use stacks_common::util::hash::Sha512Trunc256Sum;
 use stacks_common::util::secp256k1::MessageSignature;
 
+use crate::chainstate::burn::db::sortdb::SortitionDB;
+use crate::chainstate::nakamoto::NakamotoChainState;
+use crate::chainstate::stacks::boot::MINERS_NAME;
+use crate::chainstate::stacks::db::StacksChainState;
 use crate::net::neighbors::NeighborComms;
 use crate::net::p2p::PeerNetwork;
 use crate::net::{
@@ -134,7 +138,8 @@ use crate::net::{
     StackerDBChunkData, StackerDBChunkInvData, StackerDBGetChunkData, StackerDBPushChunkData,
     StacksMessage, StacksMessageType,
 };
-use crate::util_lib::db::{DBConn, DBTx};
+use crate::util_lib::boot::boot_code_id;
+use crate::util_lib::db::{DBConn, DBTx, Error as db_error};
 
 /// maximum chunk inventory size
 pub const STACKERDB_INV_MAX: u32 = 4096;
@@ -197,6 +202,114 @@ pub struct StackerDBs {
     path: String,
 }
 
+impl StackerDBs {
+    /// Create a StackerDB.
+    /// Fails only if the underlying DB fails
+    fn create_stackerdb(
+        &mut self,
+        stackerdb_contract_id: &QualifiedContractIdentifier,
+        new_config: &StackerDBConfig,
+    ) -> Result<(), db_error> {
+        info!("Creating local replica of StackerDB {stackerdb_contract_id}");
+        test_debug!(
+            "Creating local replica of StackerDB {stackerdb_contract_id} with config {:?}",
+            &new_config
+        );
+        let tx = self.tx_begin(new_config.clone())?;
+        tx.create_stackerdb(stackerdb_contract_id, &new_config.signers)
+            .unwrap_or_else(|e| {
+                warn!(
+                    "Failed to create StackerDB replica {stackerdb_contract_id}: {:?}",
+                    &e
+                );
+            });
+        tx.commit()?;
+        Ok(())
+    }
+
+    /// Reconfigure a StackerDB.
+    /// Fails only if the underlying DB fails
+    fn reconfigure_stackerdb(
+        &mut self,
+        stackerdb_contract_id: &QualifiedContractIdentifier,
+        new_config: &StackerDBConfig,
+    ) -> Result<(), db_error> {
+        debug!("Reconfiguring StackerDB {stackerdb_contract_id}...");
+        let tx = self.tx_begin(new_config.clone())?;
+        tx.reconfigure_stackerdb(stackerdb_contract_id, &new_config.signers)
+            .unwrap_or_else(|e| {
+                warn!(
+                    "Failed to reconfigure StackerDB replica {}: {:?}",
+                    stackerdb_contract_id, &e
+                );
+            });
+        tx.commit()?;
+        Ok(())
+    }
+
+    /// Create or reconfigure the supplied contracts with the appropriate stacker DB config.
+    /// Returns a map of the stacker DBs and their loaded configs.
+    /// Fails only if the underlying DB fails
+    pub fn create_or_reconfigure_stackerdb(
+        &mut self,
+        chainstate: &mut StacksChainState,
+        sortdb: &SortitionDB,
+        contracts: &[(QualifiedContractIdentifier, Option<StackerDBConfig>)],
+    ) -> Result<HashMap<QualifiedContractIdentifier, StackerDBConfig>, net_error> {
+        let existing_contract_ids = self.get_stackerdb_contract_ids()?;
+        let mut new_stackerdb_configs = HashMap::new();
+        for (contract_id, config) in contracts {
+            // Determine the new config for this StackerDB replica
+            let new_config = if *contract_id == boot_code_id(MINERS_NAME, chainstate.mainnet) {
+                // .miners contract -- directly generate the config
+                NakamotoChainState::make_miners_stackerdb_config(sortdb).unwrap_or_else(|e| {
+                    warn!(
+                        "Failed to generate .miners StackerDB config";
+                        "contract" => %contract_id,
+                        "err" => ?e,
+                    );
+                    StackerDBConfig::noop()
+                })
+            } else {
+                // attempt to load the config from the contract itself
+                config.clone().unwrap_or_else(|| {
+                    StackerDBConfig::from_smart_contract(chainstate, &sortdb, contract_id)
+                        .unwrap_or_else(|e| {
+                            warn!(
+                                "Failed to load StackerDB config";
+                                "contract" => %contract_id,
+                                "err" => ?e,
+                            );
+                            StackerDBConfig::noop()
+                        })
+                })
+            };
+            // Create the StackerDB replica if it does not exist already
+            if !existing_contract_ids.contains(contract_id) {
+                if let Err(e) = self.create_stackerdb(contract_id, &new_config) {
+                    warn!(
+                        "Failed to create or reconfigure StackerDB {contract_id}: DB error {:?}",
+                        &e
+                    );
+                }
+            } else if new_config != config.clone().unwrap_or(StackerDBConfig::noop())
+                && new_config.signers.len() > 0
+            {
+                // only reconfigure if the config has changed
+                if let Err(e) = self.reconfigure_stackerdb(contract_id, &new_config) {
+                    warn!(
+                        "Failed to create or reconfigure StackerDB {contract_id}: DB error {:?}",
+                        &e
+                    );
+                }
+            }
+            // Even if we failed to create or reconfigure the DB, we still want to keep track of them
+            // so that we can attempt to create/reconfigure them again later.
+            new_stackerdb_configs.insert(contract_id.clone(), new_config);
+        }
+        Ok(new_stackerdb_configs)
+    }
+}
 /// A transaction against one or more stacker DBs (really, against StackerDBSet)
 pub struct StackerDBTx<'a> {
     sql_tx: DBTx<'a>,
diff --git a/testnet/stacks-node/src/neon_node.rs b/testnet/stacks-node/src/neon_node.rs
index 284d63a1c3..d23ad967c2 100644
--- a/testnet/stacks-node/src/neon_node.rs
+++ b/testnet/stacks-node/src/neon_node.rs
@@ -184,7 +184,7 @@ use stacks::net::db::{LocalPeer, PeerDB};
 use stacks::net::dns::{DNSClient, DNSResolver};
 use stacks::net::p2p::PeerNetwork;
 use stacks::net::relay::Relayer;
-use stacks::net::stackerdb::{StackerDBConfig, StackerDBSync, StackerDBs};
+use stacks::net::stackerdb::{StackerDBSync, StackerDBs};
 use stacks::net::{
     Error as NetError, NetworkResult, PeerNetworkComms, RPCHandlerArgs, ServiceFlags,
 };
@@ -3801,82 +3801,43 @@ impl StacksNode {
         let atlasdb =
             AtlasDB::connect(atlas_config.clone(), &config.get_atlas_db_file_path(), true).unwrap();
 
-        let stackerdbs = StackerDBs::connect(&config.get_stacker_db_file_path(), true).unwrap();
-
         let mut chainstate =
             open_chainstate_with_faults(config).expect("FATAL: could not open chainstate DB");
 
         let mut stackerdb_machines = HashMap::new();
-        for stackerdb_contract_id in config.node.stacker_dbs.iter() {
-            // attempt to load the config
-            let (instantiate, stacker_db_config) = match StackerDBConfig::from_smart_contract(
-                &mut chainstate,
-                &sortdb,
-                stackerdb_contract_id,
-            ) {
-                Ok(c) => (true, c),
-                Err(e) => {
-                    warn!(
-                        "Failed to load StackerDB config for {}: {:?}",
-                        stackerdb_contract_id, &e
-                    );
-                    (false, StackerDBConfig::noop())
-                }
-            };
-            let mut stackerdbs =
-                StackerDBs::connect(&config.get_stacker_db_file_path(), true).unwrap();
-
-            if instantiate {
-                match stackerdbs.get_stackerdb_id(stackerdb_contract_id) {
-                    Ok(..) => {
-                        // reconfigure
-                        let tx = stackerdbs.tx_begin(stacker_db_config.clone()).unwrap();
-                        tx.reconfigure_stackerdb(stackerdb_contract_id, &stacker_db_config.signers)
-                            .expect(&format!(
-                                "FATAL: failed to reconfigure StackerDB replica {}",
-                                stackerdb_contract_id
-                            ));
-                        tx.commit().unwrap();
-                    }
-                    Err(NetError::NoSuchStackerDB(..)) => {
-                        // instantiate replica
-                        let tx = stackerdbs.tx_begin(stacker_db_config.clone()).unwrap();
-                        tx.create_stackerdb(stackerdb_contract_id, &stacker_db_config.signers)
-                            .expect(&format!(
-                                "FATAL: failed to instantiate StackerDB replica {}",
-                                stackerdb_contract_id
-                            ));
-                        tx.commit().unwrap();
-                    }
-                    Err(e) => {
-                        panic!("FATAL: failed to query StackerDB state: {:?}", &e);
-                    }
-                }
-            }
+        let mut stackerdbs = StackerDBs::connect(&config.get_stacker_db_file_path(), true).unwrap();
+        let contracts: Vec<_> = config
+            .node
+            .stacker_dbs
+            .clone()
+            .into_iter()
+            .map(|contract_id| (contract_id, None))
+            .collect();
+        let stackerdb_configs = stackerdbs
+            .create_or_reconfigure_stackerdb(&mut chainstate, &sortdb, contracts.as_slice())
+            .unwrap();
+
+        let stackerdb_contract_ids: Vec<QualifiedContractIdentifier> =
+            stackerdb_configs.keys().cloned().collect();
+        for (contract_id, stackerdb_config) in stackerdb_configs {
+            let stackerdbs = StackerDBs::connect(&config.get_stacker_db_file_path(), true).unwrap();
             let stacker_db_sync = match StackerDBSync::new(
-                stackerdb_contract_id.clone(),
-                &stacker_db_config,
+                contract_id.clone(),
+                &stackerdb_config,
                 PeerNetworkComms::new(),
                 stackerdbs,
             ) {
                 Ok(s) => s,
                 Err(e) => {
                     warn!(
-                        "Failed to instantiate StackerDB sync machine for {}: {:?}",
-                        stackerdb_contract_id, &e
+                        "Failed to instantiate StackerDB sync machine for {contract_id}: {:?}",
+                        &e
                     );
                     continue;
                 }
             };
-
-            stackerdb_machines.insert(
-                stackerdb_contract_id.clone(),
-                (stacker_db_config, stacker_db_sync),
-            );
+            stackerdb_machines.insert(contract_id, (stackerdb_config, stacker_db_sync));
         }
-
-        let stackerdb_contract_ids: Vec<_> =
-            stackerdb_machines.keys().map(|sc| sc.clone()).collect();
         let peerdb = Self::setup_peer_db(config, &burnchain, &stackerdb_contract_ids);
 
         let local_peer = match PeerDB::get_local_peer(peerdb.conn()) {

From edc495cee05c0fd194b20e5e4e45b451c2a4829b Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 5 Jan 2024 14:51:38 -0500
Subject: [PATCH 0336/1166] CRC: do not store miners_stackerdb in miner

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 .../stacks-node/src/nakamoto_node/miner.rs    | 21 ++++++++-----------
 1 file changed, 9 insertions(+), 12 deletions(-)

diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index fe76069937..aca0e99e02 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -99,8 +99,6 @@ pub struct BlockMinerThread {
     parent_tenure_id: StacksBlockId,
     /// Handle to the node's event dispatcher
     event_dispatcher: EventDispatcher,
-    /// The .miners stacker db session
-    miners_stackerdb: StackerDBSession,
 }
 
 impl BlockMinerThread {
@@ -111,14 +109,6 @@ impl BlockMinerThread {
         burn_block: BlockSnapshot,
         parent_tenure_id: StacksBlockId,
     ) -> BlockMinerThread {
-        let rpc_sock = rt.config.node.rpc_bind.parse().expect(&format!(
-            "Failed to parse socket: {}",
-            &rt.config.node.rpc_bind
-        ));
-
-        let miner_contract_id = boot_code_id(MINERS_NAME, rt.config.is_mainnet());
-
-        let miners_stackerdb = StackerDBSession::new(rpc_sock, miner_contract_id);
         BlockMinerThread {
             config: rt.config.clone(),
             globals: rt.globals.clone(),
@@ -129,7 +119,6 @@ impl BlockMinerThread {
             burn_block,
             event_dispatcher: rt.event_dispatcher.clone(),
             parent_tenure_id,
-            miners_stackerdb,
         }
     }
 
@@ -196,7 +185,15 @@ impl BlockMinerThread {
                 ) {
                     Ok(Some(chunk)) => {
                         // Propose the block to the observing signers through the .miners stackerdb instance
-                        match self.miners_stackerdb.put_chunk(chunk) {
+                        let rpc_sock = self.config.node.rpc_bind.parse().expect(&format!(
+                            "Failed to parse socket: {}",
+                            &self.config.node.rpc_bind
+                        ));
+
+                        let miner_contract_id = boot_code_id(MINERS_NAME, self.config.is_mainnet());
+                        let mut miners_stackerdb =
+                            StackerDBSession::new(rpc_sock, miner_contract_id);
+                        match miners_stackerdb.put_chunk(chunk) {
                             Ok(ack) => {
                                 info!("Proposed block to stackerdb: {ack:?}");
                             }

From 62eb11046ff4fba4ba9713a5317a786934a3ba36 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Mon, 8 Jan 2024 13:10:28 -0500
Subject: [PATCH 0337/1166] CRC: Subscribe to MinedBlocks and zero out the
 signatures to ensure the block hash matches between observed and proposed
 blocks

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stackslib/src/chainstate/nakamoto/miner.rs    |  2 +-
 stackslib/src/chainstate/nakamoto/mod.rs      |  1 +
 .../src/chainstate/stacks/transaction.rs      |  1 +
 .../src/tests/nakamoto_integrations.rs        | 45 ++++++++++++++-----
 .../src/tests/neon_integrations.rs            |  4 ++
 5 files changed, 42 insertions(+), 11 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/miner.rs b/stackslib/src/chainstate/nakamoto/miner.rs
index 5ce0521c60..730882b78a 100644
--- a/stackslib/src/chainstate/nakamoto/miner.rs
+++ b/stackslib/src/chainstate/nakamoto/miner.rs
@@ -364,7 +364,7 @@ impl NakamotoBlockBuilder {
         );
 
         debug!(
-            "Miner: mined Nakamoto block";
+            "Miner: mined Nakamoto block (miner hashes include zeroed signatures)";
             "consensus_hash" => %block.header.consensus_hash,
             "block_hash" => %block.header.block_hash(),
             "block_height" => block.header.chain_length,
diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index ca34c017c1..c9bd8a9e21 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -463,6 +463,7 @@ impl NakamotoBlockHeader {
             tx_merkle_root: Sha512Trunc256Sum([0u8; 32]),
             state_index_root: TrieHash([0u8; 32]),
             miner_signature: MessageSignature::empty(),
+            // TODO: `mock()` should be updated to `empty()` and rustdocs updated
             signer_signature: ThresholdSignature::mock(),
         }
     }
diff --git a/stackslib/src/chainstate/stacks/transaction.rs b/stackslib/src/chainstate/stacks/transaction.rs
index cf46bb7f42..2999bb1c75 100644
--- a/stackslib/src/chainstate/stacks/transaction.rs
+++ b/stackslib/src/chainstate/stacks/transaction.rs
@@ -184,6 +184,7 @@ impl ThresholdSignature {
     }
 
     /// Create mock data for testing. Not valid data
+    // TODO: `mock()` should be updated to `empty()` and rustdocs updated
     pub fn mock() -> Self {
         Self(Secp256k1Signature {
             R: Secp256k1Point::G(),
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 4f0a6d8d82..05ae6da4a5 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -31,7 +31,7 @@ use stacks::chainstate::nakamoto::{NakamotoBlock, NakamotoChainState};
 use stacks::chainstate::stacks::boot::MINERS_NAME;
 use stacks::chainstate::stacks::db::StacksChainState;
 use stacks::chainstate::stacks::miner::{BlockBuilder, BlockLimitFunction, TransactionResult};
-use stacks::chainstate::stacks::{StacksTransaction, TransactionPayload};
+use stacks::chainstate::stacks::{StacksTransaction, ThresholdSignature, TransactionPayload};
 use stacks::core::{
     StacksEpoch, StacksEpochId, BLOCK_LIMIT_MAINNET_10, HELIUM_BLOCK_LIMIT_20,
     PEER_VERSION_EPOCH_1_0, PEER_VERSION_EPOCH_2_0, PEER_VERSION_EPOCH_2_05,
@@ -47,7 +47,7 @@ use stacks_common::codec::StacksMessageCodec;
 use stacks_common::consts::STACKS_EPOCH_MAX;
 use stacks_common::types::chainstate::{StacksAddress, StacksPrivateKey, StacksPublicKey};
 use stacks_common::util::hash::to_hex;
-use stacks_common::util::secp256k1::Secp256k1PrivateKey;
+use stacks_common::util::secp256k1::{MessageSignature, Secp256k1PrivateKey};
 
 use super::bitcoin_regtest::BitcoinCoreController;
 use crate::config::{EventKeyType, EventObserverConfig, InitialBalance};
@@ -1342,7 +1342,7 @@ fn miner_writes_proposed_block_to_stackerdb() {
     let observer_port = test_observer::EVENT_OBSERVER_PORT;
     naka_conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{observer_port}"),
-        events_keys: vec![EventKeyType::AnyEvent],
+        events_keys: vec![EventKeyType::AnyEvent, EventKeyType::MinedBlocks],
     });
 
     let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone());
@@ -1372,12 +1372,6 @@ fn miner_writes_proposed_block_to_stackerdb() {
         StacksPublicKey::new(),
         &mut btc_regtest_controller,
     );
-    let rpc_sock = naka_conf
-        .node
-        .rpc_bind
-        .clone()
-        .parse()
-        .expect("Failed to parse socket");
 
     info!("Nakamoto miner started...");
     // first block wakes up the run loop, wait until a key registration has been submitted.
@@ -1403,6 +1397,12 @@ fn miner_writes_proposed_block_to_stackerdb() {
     )
     .unwrap();
 
+    let rpc_sock = naka_conf
+        .node
+        .rpc_bind
+        .clone()
+        .parse()
+        .expect("Failed to parse socket");
     let chunk = std::thread::spawn(move || {
         let miner_contract_id = boot_code_id(MINERS_NAME, false);
         let mut miners_stackerdb = StackerDBSession::new(rpc_sock, miner_contract_id);
@@ -1414,8 +1414,14 @@ fn miner_writes_proposed_block_to_stackerdb() {
     .join()
     .expect("Failed to join chunk handle");
     // We should now successfully deserialize a chunk
-    let _block = NakamotoBlock::consensus_deserialize(&mut &chunk[..])
+    let proposed_block = NakamotoBlock::consensus_deserialize(&mut &chunk[..])
         .expect("Failed to deserialize chunk into block");
+    let proposed_block_hash = format!("0x{}", proposed_block.header.block_hash());
+
+    let mut proposed_zero_block = proposed_block.clone();
+    proposed_zero_block.header.miner_signature = MessageSignature::empty();
+    proposed_zero_block.header.signer_signature = ThresholdSignature::mock();
+    let proposed_zero_block_hash = format!("0x{}", proposed_zero_block.header.block_hash());
 
     coord_channel
         .lock()
@@ -1425,4 +1431,23 @@ fn miner_writes_proposed_block_to_stackerdb() {
     run_loop_stopper.store(false, Ordering::SeqCst);
 
     run_loop_thread.join().unwrap();
+
+    let observed_blocks = test_observer::get_mined_nakamoto_blocks();
+    assert_eq!(observed_blocks.len(), 1);
+
+    let observed_block = observed_blocks.first().unwrap();
+    info!(
+        "Checking observed and proposed miner block";
+        "observed_block" => ?observed_block,
+        "proposed_block" => ?proposed_block,
+        "observed_block_hash" => format!("0x{}", observed_block.block_hash),
+        "proposed_zero_block_hash" => &proposed_zero_block_hash,
+        "proposed_block_hash" => &proposed_block_hash,
+    );
+
+    assert_eq!(
+        format!("0x{}", observed_block.block_hash),
+        proposed_zero_block_hash,
+        "Observed miner hash should match the proposed block read from StackerDB (after zeroing signatures)"
+    );
 }
diff --git a/testnet/stacks-node/src/tests/neon_integrations.rs b/testnet/stacks-node/src/tests/neon_integrations.rs
index 2bee326418..13c5c10573 100644
--- a/testnet/stacks-node/src/tests/neon_integrations.rs
+++ b/testnet/stacks-node/src/tests/neon_integrations.rs
@@ -403,6 +403,10 @@ pub mod test_observer {
         MINED_MICROBLOCKS.lock().unwrap().clone()
     }
 
+    pub fn get_mined_nakamoto_blocks() -> Vec<MinedNakamotoBlockEvent> {
+        MINED_NAKAMOTO_BLOCKS.lock().unwrap().clone()
+    }
+
     pub fn get_stackerdb_chunks() -> Vec<StackerDBChunksEvent> {
         NEW_STACKERDB_CHUNKS.lock().unwrap().clone()
     }

From d85eda90a2563ca49eef1e2fb20b00f9443be862 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Tue, 9 Jan 2024 10:59:15 -0500
Subject: [PATCH 0338/1166] CRC: add .miners to NodeConfig if is a miner neon
 node

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 testnet/stacks-node/src/config.rs | 945 +++++++++++++++---------------
 1 file changed, 473 insertions(+), 472 deletions(-)

diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index ac6d4e733d..0701219e0e 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -12,6 +12,7 @@ use lazy_static::lazy_static;
 use rand::RngCore;
 use stacks::burnchains::bitcoin::BitcoinNetworkType;
 use stacks::burnchains::{Burnchain, MagicBytes, BLOCKSTACK_MAGIC_MAINNET};
+use stacks::chainstate::stacks::boot::MINERS_NAME;
 use stacks::chainstate::stacks::index::marf::MARFOpenOpts;
 use stacks::chainstate::stacks::index::storage::TrieHashCalculationMode;
 use stacks::chainstate::stacks::miner::{BlockBuilderSettings, MinerStatus};
@@ -29,6 +30,7 @@ use stacks::cost_estimates::{CostEstimator, FeeEstimator, PessimisticEstimator,
 use stacks::net::atlas::AtlasConfig;
 use stacks::net::connection::ConnectionOptions;
 use stacks::net::{Neighbor, NeighborKey};
+use stacks::util_lib::boot::boot_code_id;
 use stacks::util_lib::db::Error as DBError;
 use stacks_common::address::{AddressHashMode, C32_ADDRESS_VERSION_TESTNET_SINGLESIG};
 use stacks_common::types::chainstate::StacksAddress;
@@ -859,317 +861,13 @@ impl Config {
             estimation: default_estimator,
             ..
         } = default;
-        let mut has_require_affirmed_anchor_blocks = false;
-        let (mut node, bootstrap_node, deny_nodes) = match config_file.node {
-            Some(node) => {
-                let rpc_bind = node.rpc_bind.unwrap_or(default_node_config.rpc_bind);
-                let node_config = NodeConfig {
-                    name: node.name.unwrap_or(default_node_config.name),
-                    seed: match node.seed {
-                        Some(seed) => hex_bytes(&seed)
-                            .map_err(|_e| format!("node.seed should be a hex encoded string"))?,
-                        None => default_node_config.seed,
-                    },
-                    working_dir: std::env::var("STACKS_WORKING_DIR")
-                        .unwrap_or(node.working_dir.unwrap_or(default_node_config.working_dir)),
-                    rpc_bind: rpc_bind.clone(),
-                    p2p_bind: node.p2p_bind.unwrap_or(default_node_config.p2p_bind),
-                    p2p_address: node.p2p_address.unwrap_or(rpc_bind.clone()),
-                    bootstrap_node: vec![],
-                    deny_nodes: vec![],
-                    data_url: match node.data_url {
-                        Some(data_url) => data_url,
-                        None => format!("http://{}", rpc_bind),
-                    },
-                    local_peer_seed: match node.local_peer_seed {
-                        Some(seed) => hex_bytes(&seed).map_err(|_e| {
-                            format!("node.local_peer_seed should be a hex encoded string")
-                        })?,
-                        None => default_node_config.local_peer_seed,
-                    },
-                    miner: node.miner.unwrap_or(default_node_config.miner),
-                    mock_mining: node.mock_mining.unwrap_or(default_node_config.mock_mining),
-                    mine_microblocks: node
-                        .mine_microblocks
-                        .unwrap_or(default_node_config.mine_microblocks),
-                    microblock_frequency: node
-                        .microblock_frequency
-                        .unwrap_or(default_node_config.microblock_frequency),
-                    max_microblocks: node
-                        .max_microblocks
-                        .unwrap_or(default_node_config.max_microblocks),
-                    wait_time_for_microblocks: node
-                        .wait_time_for_microblocks
-                        .unwrap_or(default_node_config.wait_time_for_microblocks),
-                    wait_time_for_blocks: node
-                        .wait_time_for_blocks
-                        .unwrap_or(default_node_config.wait_time_for_blocks),
-                    prometheus_bind: node.prometheus_bind,
-                    marf_cache_strategy: node.marf_cache_strategy,
-                    marf_defer_hashing: node
-                        .marf_defer_hashing
-                        .unwrap_or(default_node_config.marf_defer_hashing),
-                    pox_sync_sample_secs: node
-                        .pox_sync_sample_secs
-                        .unwrap_or(default_node_config.pox_sync_sample_secs),
-                    use_test_genesis_chainstate: node.use_test_genesis_chainstate,
-                    always_use_affirmation_maps: node
-                        .always_use_affirmation_maps
-                        .unwrap_or(default_node_config.always_use_affirmation_maps),
-                    // miners should always try to mine, even if they don't have the anchored
-                    // blocks in the canonical affirmation map. Followers, however, can stall.
-                    require_affirmed_anchor_blocks: match node.require_affirmed_anchor_blocks {
-                        Some(x) => {
-                            has_require_affirmed_anchor_blocks = true;
-                            x
-                        }
-                        None => {
-                            has_require_affirmed_anchor_blocks = false;
-                            !node.miner.unwrap_or(!default_node_config.miner)
-                        }
-                    },
-                    // chainstate fault_injection activation for hide_blocks.
-                    // you can't set this in the config file.
-                    fault_injection_hide_blocks: false,
-                    chain_liveness_poll_time_secs: node
-                        .chain_liveness_poll_time_secs
-                        .unwrap_or(default_node_config.chain_liveness_poll_time_secs),
-                    stacker_dbs: node
-                        .stacker_dbs
-                        .unwrap_or(vec![])
-                        .iter()
-                        .filter_map(|contract_id| {
-                            QualifiedContractIdentifier::parse(contract_id).ok()
-                        })
-                        .collect(),
-                    mockamoto_time_ms: node
-                        .mockamoto_time_ms
-                        .unwrap_or(default_node_config.mockamoto_time_ms),
-                };
-                (node_config, node.bootstrap_node, node.deny_nodes)
-            }
-            None => (default_node_config, None, None),
-        };
 
+        // First parse the burnchain config
         let burnchain = match config_file.burnchain {
-            Some(mut burnchain) => {
-                if burnchain.mode.as_deref() == Some("xenon") {
-                    if burnchain.magic_bytes.is_none() {
-                        burnchain.magic_bytes = ConfigFile::xenon().burnchain.unwrap().magic_bytes;
-                    }
-                }
-
-                let burnchain_mode = burnchain.mode.unwrap_or(default_burnchain_config.mode);
-
-                if &burnchain_mode == "mainnet" {
-                    // check magic bytes and set if not defined
-                    let mainnet_magic = ConfigFile::mainnet().burnchain.unwrap().magic_bytes;
-                    if burnchain.magic_bytes.is_none() {
-                        burnchain.magic_bytes = mainnet_magic.clone();
-                    }
-                    if burnchain.magic_bytes != mainnet_magic {
-                        return Err(format!(
-                            "Attempted to run mainnet node with bad magic bytes '{}'",
-                            burnchain.magic_bytes.as_ref().unwrap()
-                        ));
-                    }
-                    if node.use_test_genesis_chainstate == Some(true) {
-                        return Err(format!(
-                            "Attempted to run mainnet node with `use_test_genesis_chainstate`"
-                        ));
-                    }
-                    if let Some(ref balances) = config_file.ustx_balance {
-                        if balances.len() > 0 {
-                            return Err(format!(
-                                "Attempted to run mainnet node with specified `initial_balances`"
-                            ));
-                        }
-                    }
-                } else {
-                    // testnet requires that we use the 2.05 rules for anchor block affirmations,
-                    // because reward cycle 360 (and possibly future ones) has a different anchor
-                    // block choice in 2.05 rules than in 2.1 rules.
-                    if !has_require_affirmed_anchor_blocks {
-                        debug!("Set `require_affirmed_anchor_blocks` to `false` for non-mainnet config");
-                        node.require_affirmed_anchor_blocks = false;
-                    }
-                }
-
-                let mut result = BurnchainConfig {
-                    chain: burnchain.chain.unwrap_or(default_burnchain_config.chain),
-                    chain_id: if &burnchain_mode == "mainnet" {
-                        CHAIN_ID_MAINNET
-                    } else {
-                        CHAIN_ID_TESTNET
-                    },
-                    peer_version: if &burnchain_mode == "mainnet" {
-                        PEER_VERSION_MAINNET
-                    } else {
-                        PEER_VERSION_TESTNET
-                    },
-                    mode: burnchain_mode,
-                    burn_fee_cap: burnchain
-                        .burn_fee_cap
-                        .unwrap_or(default_burnchain_config.burn_fee_cap),
-                    commit_anchor_block_within: burnchain
-                        .commit_anchor_block_within
-                        .unwrap_or(default_burnchain_config.commit_anchor_block_within),
-                    peer_host: match burnchain.peer_host {
-                        Some(peer_host) => {
-                            // Using std::net::LookupHost would be preferable, but it's
-                            // unfortunately unstable at this point.
-                            // https://doc.rust-lang.org/1.6.0/std/net/struct.LookupHost.html
-                            let mut sock_addrs = format!("{}:1", &peer_host)
-                                .to_socket_addrs()
-                                .map_err(|e| format!("Invalid burnchain.peer_host: {}", &e))?;
-                            let sock_addr = match sock_addrs.next() {
-                                Some(addr) => addr,
-                                None => {
-                                    return Err(format!(
-                                        "No IP address could be queried for '{}'",
-                                        &peer_host
-                                    ));
-                                }
-                            };
-                            format!("{}", sock_addr.ip())
-                        }
-                        None => default_burnchain_config.peer_host,
-                    },
-                    peer_port: burnchain
-                        .peer_port
-                        .unwrap_or(default_burnchain_config.peer_port),
-                    rpc_port: burnchain
-                        .rpc_port
-                        .unwrap_or(default_burnchain_config.rpc_port),
-                    rpc_ssl: burnchain
-                        .rpc_ssl
-                        .unwrap_or(default_burnchain_config.rpc_ssl),
-                    username: burnchain.username,
-                    password: burnchain.password,
-                    timeout: burnchain
-                        .timeout
-                        .unwrap_or(default_burnchain_config.timeout),
-                    magic_bytes: burnchain
-                        .magic_bytes
-                        .map(|magic_ascii| {
-                            assert_eq!(magic_ascii.len(), 2, "Magic bytes must be length-2");
-                            assert!(magic_ascii.is_ascii(), "Magic bytes must be ASCII");
-                            MagicBytes::from(magic_ascii.as_bytes())
-                        })
-                        .unwrap_or(default_burnchain_config.magic_bytes),
-                    local_mining_public_key: burnchain.local_mining_public_key,
-                    process_exit_at_block_height: burnchain.process_exit_at_block_height,
-                    poll_time_secs: burnchain
-                        .poll_time_secs
-                        .unwrap_or(default_burnchain_config.poll_time_secs),
-                    satoshis_per_byte: burnchain
-                        .satoshis_per_byte
-                        .unwrap_or(default_burnchain_config.satoshis_per_byte),
-                    max_rbf: burnchain
-                        .max_rbf
-                        .unwrap_or(default_burnchain_config.max_rbf),
-                    leader_key_tx_estimated_size: burnchain
-                        .leader_key_tx_estimated_size
-                        .unwrap_or(default_burnchain_config.leader_key_tx_estimated_size),
-                    block_commit_tx_estimated_size: burnchain
-                        .block_commit_tx_estimated_size
-                        .unwrap_or(default_burnchain_config.block_commit_tx_estimated_size),
-                    rbf_fee_increment: burnchain
-                        .rbf_fee_increment
-                        .unwrap_or(default_burnchain_config.rbf_fee_increment),
-                    // will be overwritten below
-                    epochs: default_burnchain_config.epochs,
-                    ast_precheck_size_height: burnchain.ast_precheck_size_height,
-                    pox_2_activation: burnchain
-                        .pox_2_activation
-                        .or(default_burnchain_config.pox_2_activation),
-                    sunset_start: burnchain
-                        .sunset_start
-                        .or(default_burnchain_config.sunset_start),
-                    sunset_end: burnchain.sunset_end.or(default_burnchain_config.sunset_end),
-                    wallet_name: burnchain
-                        .wallet_name
-                        .unwrap_or(default_burnchain_config.wallet_name.clone()),
-                    pox_reward_length: burnchain
-                        .pox_reward_length
-                        .or(default_burnchain_config.pox_reward_length),
-                    pox_prepare_length: burnchain
-                        .pox_prepare_length
-                        .or(default_burnchain_config.pox_prepare_length),
-                };
-
-                if let BitcoinNetworkType::Mainnet = result.get_bitcoin_network().1 {
-                    // check that pox_2_activation hasn't been set in mainnet
-                    if result.pox_2_activation.is_some()
-                        || result.sunset_start.is_some()
-                        || result.sunset_end.is_some()
-                    {
-                        return Err("PoX-2 parameters are not configurable in mainnet".into());
-                    }
-                }
-
-                if let Some(ref conf_epochs) = burnchain.epochs {
-                    result.epochs = Some(Self::make_epochs(
-                        conf_epochs,
-                        &result.mode,
-                        result.get_bitcoin_network().1,
-                        burnchain.pox_2_activation,
-                    )?);
-                }
-
-                result
-            }
+            Some(burnchain) => burnchain.into_config_default(default_burnchain_config)?,
             None => default_burnchain_config,
         };
 
-        let miner = match config_file.miner {
-            Some(ref miner) => MinerConfig {
-                min_tx_fee: miner.min_tx_fee.unwrap_or(miner_default_config.min_tx_fee),
-                first_attempt_time_ms: miner
-                    .first_attempt_time_ms
-                    .unwrap_or(miner_default_config.first_attempt_time_ms),
-                subsequent_attempt_time_ms: miner
-                    .subsequent_attempt_time_ms
-                    .unwrap_or(miner_default_config.subsequent_attempt_time_ms),
-                microblock_attempt_time_ms: miner
-                    .microblock_attempt_time_ms
-                    .unwrap_or(miner_default_config.microblock_attempt_time_ms),
-                probability_pick_no_estimate_tx: miner
-                    .probability_pick_no_estimate_tx
-                    .unwrap_or(miner_default_config.probability_pick_no_estimate_tx),
-                block_reward_recipient: miner.block_reward_recipient.as_ref().map(|c| {
-                    PrincipalData::parse(&c)
-                        .expect(&format!("FATAL: not a valid principal identifier: {}", c))
-                }),
-                segwit: miner.segwit.unwrap_or(miner_default_config.segwit),
-                wait_for_block_download: miner_default_config.wait_for_block_download,
-                nonce_cache_size: miner
-                    .nonce_cache_size
-                    .unwrap_or(miner_default_config.nonce_cache_size),
-                candidate_retry_cache_size: miner
-                    .candidate_retry_cache_size
-                    .unwrap_or(miner_default_config.candidate_retry_cache_size),
-                unprocessed_block_deadline_secs: miner
-                    .unprocessed_block_deadline_secs
-                    .unwrap_or(miner_default_config.unprocessed_block_deadline_secs),
-                mining_key: miner
-                    .mining_key
-                    .as_ref()
-                    .map(|x| Secp256k1PrivateKey::from_hex(x))
-                    .transpose()?,
-                self_signing_key: miner
-                    .self_signing_seed
-                    .as_ref()
-                    .map(|x| SelfSigner::from_seed(*x))
-                    .or(miner_default_config.self_signing_key),
-                wait_on_interim_blocks: miner
-                    .wait_on_interim_blocks_ms
-                    .map(Duration::from_millis)
-                    .unwrap_or(miner_default_config.wait_on_interim_blocks),
-            },
-            None => miner_default_config,
-        };
-
         let supported_modes = vec![
             "mocknet",
             "helium",
@@ -1193,10 +891,23 @@ impl Config {
             return Err(format!("Config is missing the setting `burnchain.local_mining_public_key` (mandatory for helium)"));
         }
 
+        let is_mainnet = burnchain.mode == "mainnet";
+
+        // Parse the node config
+        let (mut node, bootstrap_node, deny_nodes) = match config_file.node {
+            Some(node) => {
+                let deny_nodes = node.deny_nodes.clone();
+                let bootstrap_node = node.bootstrap_node.clone();
+                let node_config = node.into_config_default(default_node_config)?;
+                (node_config, bootstrap_node, deny_nodes)
+            }
+            None => (default_node_config, None, None),
+        };
+
         if let Some(bootstrap_node) = bootstrap_node {
             node.set_bootstrap_nodes(bootstrap_node, burnchain.chain_id, burnchain.peer_version);
         } else {
-            if burnchain.mode == "mainnet" {
+            if is_mainnet {
                 let bootstrap_node = ConfigFile::mainnet().node.unwrap().bootstrap_node.unwrap();
                 node.set_bootstrap_nodes(
                     bootstrap_node,
@@ -1209,20 +920,56 @@ impl Config {
             node.set_deny_nodes(deny_nodes, burnchain.chain_id, burnchain.peer_version);
         }
 
+        // Validate the node config
+        if is_mainnet {
+            if node.use_test_genesis_chainstate == Some(true) {
+                return Err(format!(
+                    "Attempted to run mainnet node with `use_test_genesis_chainstate`"
+                ));
+            }
+        } else if node.require_affirmed_anchor_blocks {
+            // testnet requires that we use the 2.05 rules for anchor block affirmations,
+            // because reward cycle 360 (and possibly future ones) has a different anchor
+            // block choice in 2.05 rules than in 2.1 rules.
+            debug!("Set `require_affirmed_anchor_blocks` to `false` for non-mainnet config");
+            node.require_affirmed_anchor_blocks = false;
+        }
+
+        let miners_contract_id = boot_code_id(MINERS_NAME, is_mainnet);
+        if node.miner
+            && burnchain.mode == "nakamoto-neon"
+            && !node.stacker_dbs.contains(&miners_contract_id)
+        {
+            debug!("A miner must subscribe to the {miners_contract_id} stacker db contract. Forcibly subscribing...");
+            node.stacker_dbs.push(miners_contract_id);
+        }
+
+        let miner = match config_file.miner {
+            Some(miner) => miner.into_config_default(miner_default_config)?,
+            None => miner_default_config,
+        };
+
         let initial_balances: Vec<InitialBalance> = match config_file.ustx_balance {
-            Some(balances) => balances
-                .iter()
-                .map(|balance| {
-                    let address: PrincipalData =
-                        PrincipalData::parse_standard_principal(&balance.address)
-                            .unwrap()
-                            .into();
-                    InitialBalance {
-                        address,
-                        amount: balance.amount,
-                    }
-                })
-                .collect(),
+            Some(balances) => {
+                if is_mainnet && balances.len() > 0 {
+                    return Err(format!(
+                        "Attempted to run mainnet node with specified `initial_balances`"
+                    ));
+                }
+                balances
+                    .iter()
+                    .map(|balance| {
+                        let address: PrincipalData =
+                            PrincipalData::parse_standard_principal(&balance.address)
+                                .unwrap()
+                                .into();
+                        InitialBalance {
+                            address,
+                            amount: balance.amount,
+                        }
+                    })
+                    .collect()
+            }
             None => vec![],
         };
 
@@ -1261,152 +1008,7 @@ impl Config {
         };
 
         let connection_options = match config_file.connection_options {
-            Some(opts) => {
-                let ip_addr = match opts.public_ip_address {
-                    Some(public_ip_address) => {
-                        let addr = public_ip_address.parse::<SocketAddr>().unwrap();
-                        debug!("addr.parse {:?}", addr);
-                        Some((PeerAddress::from_socketaddr(&addr), addr.port()))
-                    }
-                    None => None,
-                };
-                let mut read_only_call_limit = HELIUM_DEFAULT_CONNECTION_OPTIONS
-                    .read_only_call_limit
-                    .clone();
-                opts.read_only_call_limit_write_length.map(|x| {
-                    read_only_call_limit.write_length = x;
-                });
-                opts.read_only_call_limit_write_count.map(|x| {
-                    read_only_call_limit.write_count = x;
-                });
-                opts.read_only_call_limit_read_length.map(|x| {
-                    read_only_call_limit.read_length = x;
-                });
-                opts.read_only_call_limit_read_count.map(|x| {
-                    read_only_call_limit.read_count = x;
-                });
-                opts.read_only_call_limit_runtime.map(|x| {
-                    read_only_call_limit.runtime = x;
-                });
-                ConnectionOptions {
-                    read_only_call_limit,
-                    inbox_maxlen: opts
-                        .inbox_maxlen
-                        .unwrap_or_else(|| HELIUM_DEFAULT_CONNECTION_OPTIONS.inbox_maxlen.clone()),
-                    outbox_maxlen: opts
-                        .outbox_maxlen
-                        .unwrap_or_else(|| HELIUM_DEFAULT_CONNECTION_OPTIONS.outbox_maxlen.clone()),
-                    timeout: opts
-                        .timeout
-                        .unwrap_or_else(|| HELIUM_DEFAULT_CONNECTION_OPTIONS.timeout.clone()),
-                    idle_timeout: opts
-                        .idle_timeout
-                        .unwrap_or_else(|| HELIUM_DEFAULT_CONNECTION_OPTIONS.idle_timeout.clone()),
-                    heartbeat: opts
-                        .heartbeat
-                        .unwrap_or_else(|| HELIUM_DEFAULT_CONNECTION_OPTIONS.heartbeat.clone()),
-                    private_key_lifetime: opts.private_key_lifetime.unwrap_or_else(|| {
-                        HELIUM_DEFAULT_CONNECTION_OPTIONS
-                            .private_key_lifetime
-                            .clone()
-                    }),
-                    num_neighbors: opts
-                        .num_neighbors
-                        .unwrap_or_else(|| HELIUM_DEFAULT_CONNECTION_OPTIONS.num_neighbors.clone()),
-                    num_clients: opts
-                        .num_clients
-                        .unwrap_or_else(|| HELIUM_DEFAULT_CONNECTION_OPTIONS.num_clients.clone()),
-                    soft_num_neighbors: opts.soft_num_neighbors.unwrap_or_else(|| {
-                        HELIUM_DEFAULT_CONNECTION_OPTIONS.soft_num_neighbors.clone()
-                    }),
-                    soft_num_clients: opts.soft_num_clients.unwrap_or_else(|| {
-                        HELIUM_DEFAULT_CONNECTION_OPTIONS.soft_num_clients.clone()
-                    }),
-                    max_neighbors_per_host: opts.max_neighbors_per_host.unwrap_or_else(|| {
-                        HELIUM_DEFAULT_CONNECTION_OPTIONS
-                            .max_neighbors_per_host
-                            .clone()
-                    }),
-                    max_clients_per_host: opts.max_clients_per_host.unwrap_or_else(|| {
-                        HELIUM_DEFAULT_CONNECTION_OPTIONS
-                            .max_clients_per_host
-                            .clone()
-                    }),
-                    soft_max_neighbors_per_host: opts.soft_max_neighbors_per_host.unwrap_or_else(
-                        || {
-                            HELIUM_DEFAULT_CONNECTION_OPTIONS
-                                .soft_max_neighbors_per_host
-                                .clone()
-                        },
-                    ),
-                    soft_max_neighbors_per_org: opts.soft_max_neighbors_per_org.unwrap_or_else(
-                        || {
-                            HELIUM_DEFAULT_CONNECTION_OPTIONS
-                                .soft_max_neighbors_per_org
-                                .clone()
-                        },
-                    ),
-                    soft_max_clients_per_host: opts.soft_max_clients_per_host.unwrap_or_else(
-                        || {
-                            HELIUM_DEFAULT_CONNECTION_OPTIONS
-                                .soft_max_clients_per_host
-                                .clone()
-                        },
-                    ),
-                    walk_interval: opts
-                        .walk_interval
-                        .unwrap_or_else(|| HELIUM_DEFAULT_CONNECTION_OPTIONS.walk_interval.clone()),
-                    dns_timeout: opts.dns_timeout.unwrap_or_else(|| {
-                        HELIUM_DEFAULT_CONNECTION_OPTIONS.dns_timeout.clone() as u64
-                    }) as u128,
-                    max_inflight_blocks: opts.max_inflight_blocks.unwrap_or_else(|| {
-                        HELIUM_DEFAULT_CONNECTION_OPTIONS
-                            .max_inflight_blocks
-                            .clone()
-                    }),
-                    max_inflight_attachments: opts.max_inflight_attachments.unwrap_or_else(|| {
-                        HELIUM_DEFAULT_CONNECTION_OPTIONS
-                            .max_inflight_attachments
-                            .clone()
-                    }),
-                    maximum_call_argument_size: opts.maximum_call_argument_size.unwrap_or_else(
-                        || {
-                            HELIUM_DEFAULT_CONNECTION_OPTIONS
-                                .maximum_call_argument_size
-                                .clone()
-                        },
-                    ),
-                    download_interval: opts.download_interval.unwrap_or_else(|| {
-                        HELIUM_DEFAULT_CONNECTION_OPTIONS.download_interval.clone()
-                    }),
-                    inv_sync_interval: opts
-                        .inv_sync_interval
-                        .unwrap_or_else(|| HELIUM_DEFAULT_CONNECTION_OPTIONS.inv_sync_interval),
-                    inv_reward_cycles: opts.inv_reward_cycles.unwrap_or_else(|| {
-                        if burnchain.mode == "mainnet" {
-                            HELIUM_DEFAULT_CONNECTION_OPTIONS.inv_reward_cycles
-                        } else {
-                            // testnet reward cycles are a bit smaller (and blocks can go by
-                            // faster), so make our inventory
-                            // reward cycle depth a bit longer to compensate
-                            INV_REWARD_CYCLES_TESTNET
-                        }
-                    }),
-                    public_ip_address: ip_addr,
-                    disable_inbound_walks: opts.disable_inbound_walks.unwrap_or(false),
-                    disable_inbound_handshakes: opts.disable_inbound_handshakes.unwrap_or(false),
-                    disable_block_download: opts.disable_block_download.unwrap_or(false),
-                    force_disconnect_interval: opts.force_disconnect_interval,
-                    max_http_clients: opts.max_http_clients.unwrap_or_else(|| {
-                        HELIUM_DEFAULT_CONNECTION_OPTIONS.max_http_clients.clone()
-                    }),
-                    connect_timeout: opts.connect_timeout.unwrap_or(10),
-                    handshake_timeout: opts.handshake_timeout.unwrap_or(5),
-                    max_sockets: opts.max_sockets.unwrap_or(800) as usize,
-                    antientropy_public: opts.antientropy_public.unwrap_or(true),
-                    ..ConnectionOptions::default()
-                }
-            }
+            Some(opts) => opts.into_config(is_mainnet)?,
             None => HELIUM_DEFAULT_CONNECTION_OPTIONS.clone(),
         };
 
@@ -1415,10 +1017,9 @@ impl Config {
             None => default_estimator,
         };
 
-        let mainnet = burnchain.mode == "mainnet";
         let atlas = match config_file.atlas {
-            Some(f) => f.into_config(mainnet),
-            None => AtlasConfig::new(mainnet),
+            Some(f) => f.into_config(is_mainnet),
+            None => AtlasConfig::new(is_mainnet),
         };
 
         atlas
@@ -1757,7 +1358,147 @@ pub struct BurnchainConfigFile {
     pub ast_precheck_size_height: Option<u64>,
 }
 
-#[derive(Clone, Debug, Default)]
+impl BurnchainConfigFile {
+    fn into_config_default(
+        mut self,
+        default_burnchain_config: BurnchainConfig,
+    ) -> Result<BurnchainConfig, String> {
+        if self.mode.as_deref() == Some("xenon") {
+            if self.magic_bytes.is_none() {
+                self.magic_bytes = ConfigFile::xenon().burnchain.unwrap().magic_bytes;
+            }
+        }
+
+        let mode = self.mode.unwrap_or(default_burnchain_config.mode);
+        let is_mainnet = mode == "mainnet";
+        if is_mainnet {
+            // check magic bytes and set if not defined
+            let mainnet_magic = ConfigFile::mainnet().burnchain.unwrap().magic_bytes;
+            if self.magic_bytes.is_none() {
+                self.magic_bytes = mainnet_magic.clone();
+            }
+            if self.magic_bytes != mainnet_magic {
+                return Err(format!(
+                    "Attempted to run mainnet node with bad magic bytes '{}'",
+                    self.magic_bytes.as_ref().unwrap()
+                ));
+            }
+        }
+
+        let mut config = BurnchainConfig {
+            chain: self.chain.unwrap_or(default_burnchain_config.chain),
+            chain_id: if is_mainnet {
+                CHAIN_ID_MAINNET
+            } else {
+                CHAIN_ID_TESTNET
+            },
+            peer_version: if is_mainnet {
+                PEER_VERSION_MAINNET
+            } else {
+                PEER_VERSION_TESTNET
+            },
+            mode,
+            burn_fee_cap: self
+                .burn_fee_cap
+                .unwrap_or(default_burnchain_config.burn_fee_cap),
+            commit_anchor_block_within: self
+                .commit_anchor_block_within
+                .unwrap_or(default_burnchain_config.commit_anchor_block_within),
+            peer_host: match self.peer_host.as_ref() {
+                Some(peer_host) => {
+                    // Using std::net::LookupHost would be preferable, but it's
+                    // unfortunately unstable at this point.
+                    // https://doc.rust-lang.org/1.6.0/std/net/struct.LookupHost.html
+                    let mut sock_addrs = format!("{}:1", &peer_host)
+                        .to_socket_addrs()
+                        .map_err(|e| format!("Invalid burnchain.peer_host: {}", &e))?;
+                    let sock_addr = match sock_addrs.next() {
+                        Some(addr) => addr,
+                        None => {
+                            return Err(format!(
+                                "No IP address could be queried for '{}'",
+                                &peer_host
+                            ));
+                        }
+                    };
+                    format!("{}", sock_addr.ip())
+                }
+                None => default_burnchain_config.peer_host,
+            },
+            peer_port: self.peer_port.unwrap_or(default_burnchain_config.peer_port),
+            rpc_port: self.rpc_port.unwrap_or(default_burnchain_config.rpc_port),
+            rpc_ssl: self.rpc_ssl.unwrap_or(default_burnchain_config.rpc_ssl),
+            username: self.username,
+            password: self.password,
+            timeout: self.timeout.unwrap_or(default_burnchain_config.timeout),
+            magic_bytes: self
+                .magic_bytes
+                .map(|magic_ascii| {
+                    assert_eq!(magic_ascii.len(), 2, "Magic bytes must be length-2");
+                    assert!(magic_ascii.is_ascii(), "Magic bytes must be ASCII");
+                    MagicBytes::from(magic_ascii.as_bytes())
+                })
+                .unwrap_or(default_burnchain_config.magic_bytes),
+            local_mining_public_key: self.local_mining_public_key,
+            process_exit_at_block_height: self.process_exit_at_block_height,
+            poll_time_secs: self
+                .poll_time_secs
+                .unwrap_or(default_burnchain_config.poll_time_secs),
+            satoshis_per_byte: self
+                .satoshis_per_byte
+                .unwrap_or(default_burnchain_config.satoshis_per_byte),
+            max_rbf: self.max_rbf.unwrap_or(default_burnchain_config.max_rbf),
+            leader_key_tx_estimated_size: self
+                .leader_key_tx_estimated_size
+                .unwrap_or(default_burnchain_config.leader_key_tx_estimated_size),
+            block_commit_tx_estimated_size: self
+                .block_commit_tx_estimated_size
+                .unwrap_or(default_burnchain_config.block_commit_tx_estimated_size),
+            rbf_fee_increment: self
+                .rbf_fee_increment
+                .unwrap_or(default_burnchain_config.rbf_fee_increment),
+            // will be overwritten below
+            epochs: default_burnchain_config.epochs,
+            ast_precheck_size_height: self.ast_precheck_size_height,
+            pox_2_activation: self
+                .pox_2_activation
+                .or(default_burnchain_config.pox_2_activation),
+            sunset_start: self.sunset_start.or(default_burnchain_config.sunset_start),
+            sunset_end: self.sunset_end.or(default_burnchain_config.sunset_end),
+            wallet_name: self
+                .wallet_name
+                .unwrap_or(default_burnchain_config.wallet_name.clone()),
+            pox_reward_length: self
+                .pox_reward_length
+                .or(default_burnchain_config.pox_reward_length),
+            pox_prepare_length: self
+                .pox_prepare_length
+                .or(default_burnchain_config.pox_prepare_length),
+        };
+
+        if let BitcoinNetworkType::Mainnet = config.get_bitcoin_network().1 {
+            // check that pox_2_activation hasn't been set in mainnet
+            if config.pox_2_activation.is_some()
+                || config.sunset_start.is_some()
+                || config.sunset_end.is_some()
+            {
+                return Err("PoX-2 parameters are not configurable in mainnet".into());
+            }
+        }
+
+        if let Some(ref conf_epochs) = self.epochs {
+            config.epochs = Some(Config::make_epochs(
+                conf_epochs,
+                &config.mode,
+                config.get_bitcoin_network().1,
+                self.pox_2_activation,
+            )?);
+        }
+
+        Ok(config)
+    }
+}
+#[derive(Clone, Debug)]
 pub struct NodeConfig {
     pub name: String,
     pub seed: Vec<u8>,
@@ -2026,8 +1767,8 @@ impl FeeEstimationConfig {
     }
 }
 
-impl NodeConfig {
-    fn default() -> NodeConfig {
+impl Default for NodeConfig {
+    fn default() -> Self {
         let mut rng = rand::thread_rng();
         let mut buf = [0u8; 8];
         rng.fill_bytes(&mut buf);
@@ -2076,7 +1817,9 @@ impl NodeConfig {
             mockamoto_time_ms: 3_000,
         }
     }
+}
 
+impl NodeConfig {
     fn default_neighbor(
         addr: SocketAddr,
         pubk: Secp256k1PublicKey,
@@ -2258,6 +2001,131 @@ pub struct ConnectionOptionsFile {
     pub antientropy_public: Option<bool>,
 }
 
+impl ConnectionOptionsFile {
+    fn into_config(self, is_mainnet: bool) -> Result<ConnectionOptions, String> {
+        let ip_addr = self
+            .public_ip_address
+            .map(|public_ip_address| {
+                public_ip_address
+                    .parse::<SocketAddr>()
+                    .map(|addr| (PeerAddress::from_socketaddr(&addr), addr.port()))
+                    .map_err(|e| format!("Invalid connection_option.public_ip_address: {}", e))
+            })
+            .transpose()?;
+        let mut read_only_call_limit = HELIUM_DEFAULT_CONNECTION_OPTIONS
+            .read_only_call_limit
+            .clone();
+        self.read_only_call_limit_write_length.map(|x| {
+            read_only_call_limit.write_length = x;
+        });
+        self.read_only_call_limit_write_count.map(|x| {
+            read_only_call_limit.write_count = x;
+        });
+        self.read_only_call_limit_read_length.map(|x| {
+            read_only_call_limit.read_length = x;
+        });
+        self.read_only_call_limit_read_count.map(|x| {
+            read_only_call_limit.read_count = x;
+        });
+        self.read_only_call_limit_runtime.map(|x| {
+            read_only_call_limit.runtime = x;
+        });
+        Ok(ConnectionOptions {
+            read_only_call_limit,
+            inbox_maxlen: self
+                .inbox_maxlen
+                .unwrap_or_else(|| HELIUM_DEFAULT_CONNECTION_OPTIONS.inbox_maxlen),
+            outbox_maxlen: self
+                .outbox_maxlen
+                .unwrap_or_else(|| HELIUM_DEFAULT_CONNECTION_OPTIONS.outbox_maxlen),
+            timeout: self
+                .timeout
+                .unwrap_or_else(|| HELIUM_DEFAULT_CONNECTION_OPTIONS.timeout),
+            idle_timeout: self
+                .idle_timeout
+                .unwrap_or_else(|| HELIUM_DEFAULT_CONNECTION_OPTIONS.idle_timeout),
+            heartbeat: self
+                .heartbeat
+                .unwrap_or_else(|| HELIUM_DEFAULT_CONNECTION_OPTIONS.heartbeat),
+            private_key_lifetime: self
+                .private_key_lifetime
+                .unwrap_or_else(|| HELIUM_DEFAULT_CONNECTION_OPTIONS.private_key_lifetime),
+            num_neighbors: self
+                .num_neighbors
+                .unwrap_or_else(|| HELIUM_DEFAULT_CONNECTION_OPTIONS.num_neighbors),
+            num_clients: self
+                .num_clients
+                .unwrap_or_else(|| HELIUM_DEFAULT_CONNECTION_OPTIONS.num_clients),
+            soft_num_neighbors: self
+                .soft_num_neighbors
+                .unwrap_or_else(|| HELIUM_DEFAULT_CONNECTION_OPTIONS.soft_num_neighbors),
+            soft_num_clients: self
+                .soft_num_clients
+                .unwrap_or_else(|| HELIUM_DEFAULT_CONNECTION_OPTIONS.soft_num_clients),
+            max_neighbors_per_host: self
+                .max_neighbors_per_host
+                .unwrap_or_else(|| HELIUM_DEFAULT_CONNECTION_OPTIONS.max_neighbors_per_host),
+            max_clients_per_host: self
+                .max_clients_per_host
+                .unwrap_or_else(|| HELIUM_DEFAULT_CONNECTION_OPTIONS.max_clients_per_host),
+            soft_max_neighbors_per_host: self
+                .soft_max_neighbors_per_host
+                .unwrap_or_else(|| HELIUM_DEFAULT_CONNECTION_OPTIONS.soft_max_neighbors_per_host),
+            soft_max_neighbors_per_org: self
+                .soft_max_neighbors_per_org
+                .unwrap_or_else(|| HELIUM_DEFAULT_CONNECTION_OPTIONS.soft_max_neighbors_per_org),
+            soft_max_clients_per_host: self
+                .soft_max_clients_per_host
+                .unwrap_or_else(|| HELIUM_DEFAULT_CONNECTION_OPTIONS.soft_max_clients_per_host),
+            walk_interval: self
+                .walk_interval
+                .unwrap_or_else(|| HELIUM_DEFAULT_CONNECTION_OPTIONS.walk_interval.clone()),
+            dns_timeout: self
+                .dns_timeout
+                .map(|dns_timeout| dns_timeout as u128)
+                .unwrap_or_else(|| HELIUM_DEFAULT_CONNECTION_OPTIONS.dns_timeout),
+            max_inflight_blocks: self
+                .max_inflight_blocks
+                .unwrap_or_else(|| HELIUM_DEFAULT_CONNECTION_OPTIONS.max_inflight_blocks),
+            max_inflight_attachments: self
+                .max_inflight_attachments
+                .unwrap_or_else(|| HELIUM_DEFAULT_CONNECTION_OPTIONS.max_inflight_attachments),
+            maximum_call_argument_size: self
+                .maximum_call_argument_size
+                .unwrap_or_else(|| HELIUM_DEFAULT_CONNECTION_OPTIONS.maximum_call_argument_size),
+            download_interval: self
+                .download_interval
+                .unwrap_or_else(|| HELIUM_DEFAULT_CONNECTION_OPTIONS.download_interval.clone()),
+            inv_sync_interval: self
+                .inv_sync_interval
+                .unwrap_or_else(|| HELIUM_DEFAULT_CONNECTION_OPTIONS.inv_sync_interval),
+            inv_reward_cycles: self.inv_reward_cycles.unwrap_or_else(|| {
+                if is_mainnet {
+                    HELIUM_DEFAULT_CONNECTION_OPTIONS.inv_reward_cycles
+                } else {
+                    // testnet reward cycles are a bit smaller (and blocks can go by
+                    // faster), so make our inventory
+                    // reward cycle depth a bit longer to compensate
+                    INV_REWARD_CYCLES_TESTNET
+                }
+            }),
+            public_ip_address: ip_addr,
+            disable_inbound_walks: self.disable_inbound_walks.unwrap_or(false),
+            disable_inbound_handshakes: self.disable_inbound_handshakes.unwrap_or(false),
+            disable_block_download: self.disable_block_download.unwrap_or(false),
+            force_disconnect_interval: self.force_disconnect_interval,
+            max_http_clients: self
+                .max_http_clients
+                .unwrap_or_else(|| HELIUM_DEFAULT_CONNECTION_OPTIONS.max_http_clients.clone()),
+            connect_timeout: self.connect_timeout.unwrap_or(10),
+            handshake_timeout: self.handshake_timeout.unwrap_or(5),
+            max_sockets: self.max_sockets.unwrap_or(800) as usize,
+            antientropy_public: self.antientropy_public.unwrap_or(true),
+            ..ConnectionOptions::default()
+        })
+    }
+}
+
 #[derive(Clone, Deserialize, Default, Debug)]
 pub struct NodeConfigFile {
     pub name: Option<String>,
@@ -2294,6 +2162,85 @@ pub struct NodeConfigFile {
     pub mockamoto_time_ms: Option<u64>,
 }
 
+impl NodeConfigFile {
+    fn into_config_default(self, default_node_config: NodeConfig) -> Result<NodeConfig, String> {
+        let rpc_bind = self.rpc_bind.unwrap_or(default_node_config.rpc_bind);
+        let miner = self.miner.unwrap_or(default_node_config.miner);
+        let node_config = NodeConfig {
+            name: self.name.unwrap_or(default_node_config.name),
+            seed: match self.seed {
+                Some(seed) => hex_bytes(&seed)
+                    .map_err(|_e| format!("node.seed should be a hex encoded string"))?,
+                None => default_node_config.seed,
+            },
+            working_dir: std::env::var("STACKS_WORKING_DIR")
+                .unwrap_or(self.working_dir.unwrap_or(default_node_config.working_dir)),
+            rpc_bind: rpc_bind.clone(),
+            p2p_bind: self.p2p_bind.unwrap_or(default_node_config.p2p_bind),
+            p2p_address: self.p2p_address.unwrap_or(rpc_bind.clone()),
+            bootstrap_node: vec![],
+            deny_nodes: vec![],
+            data_url: match self.data_url {
+                Some(data_url) => data_url,
+                None => format!("http://{}", rpc_bind),
+            },
+            local_peer_seed: match self.local_peer_seed {
+                Some(seed) => hex_bytes(&seed)
+                    .map_err(|_e| format!("node.local_peer_seed should be a hex encoded string"))?,
+                None => default_node_config.local_peer_seed,
+            },
+            miner,
+            mock_mining: self.mock_mining.unwrap_or(default_node_config.mock_mining),
+            mine_microblocks: self
+                .mine_microblocks
+                .unwrap_or(default_node_config.mine_microblocks),
+            microblock_frequency: self
+                .microblock_frequency
+                .unwrap_or(default_node_config.microblock_frequency),
+            max_microblocks: self
+                .max_microblocks
+                .unwrap_or(default_node_config.max_microblocks),
+            wait_time_for_microblocks: self
+                .wait_time_for_microblocks
+                .unwrap_or(default_node_config.wait_time_for_microblocks),
+            wait_time_for_blocks: self
+                .wait_time_for_blocks
+                .unwrap_or(default_node_config.wait_time_for_blocks),
+            prometheus_bind: self.prometheus_bind,
+            marf_cache_strategy: self.marf_cache_strategy,
+            marf_defer_hashing: self
+                .marf_defer_hashing
+                .unwrap_or(default_node_config.marf_defer_hashing),
+            pox_sync_sample_secs: self
+                .pox_sync_sample_secs
+                .unwrap_or(default_node_config.pox_sync_sample_secs),
+            use_test_genesis_chainstate: self.use_test_genesis_chainstate,
+            always_use_affirmation_maps: self
+                .always_use_affirmation_maps
+                .unwrap_or(default_node_config.always_use_affirmation_maps),
+            // miners should always try to mine, even if they don't have the anchored
+            // blocks in the canonical affirmation map. Followers, however, can stall.
+            require_affirmed_anchor_blocks: self.require_affirmed_anchor_blocks.unwrap_or(!miner),
+            // chainstate fault_injection activation for hide_blocks.
+            // you can't set this in the config file.
+            fault_injection_hide_blocks: false,
+            chain_liveness_poll_time_secs: self
+                .chain_liveness_poll_time_secs
+                .unwrap_or(default_node_config.chain_liveness_poll_time_secs),
+            stacker_dbs: self
+                .stacker_dbs
+                .unwrap_or(vec![])
+                .iter()
+                .filter_map(|contract_id| QualifiedContractIdentifier::parse(contract_id).ok())
+                .collect(),
+            mockamoto_time_ms: self
+                .mockamoto_time_ms
+                .unwrap_or(default_node_config.mockamoto_time_ms),
+        };
+        Ok(node_config)
+    }
+}
+
 #[derive(Clone, Deserialize, Default, Debug)]
 pub struct FeeEstimationConfigFile {
     pub cost_estimator: Option<String>,
@@ -2322,6 +2269,60 @@ pub struct MinerConfigFile {
     pub wait_on_interim_blocks_ms: Option<u64>,
 }
 
+impl MinerConfigFile {
+    fn into_config_default(self, miner_default_config: MinerConfig) -> Result<MinerConfig, String> {
+        Ok(MinerConfig {
+            min_tx_fee: self.min_tx_fee.unwrap_or(miner_default_config.min_tx_fee),
+            first_attempt_time_ms: self
+                .first_attempt_time_ms
+                .unwrap_or(miner_default_config.first_attempt_time_ms),
+            subsequent_attempt_time_ms: self
+                .subsequent_attempt_time_ms
+                .unwrap_or(miner_default_config.subsequent_attempt_time_ms),
+            microblock_attempt_time_ms: self
+                .microblock_attempt_time_ms
+                .unwrap_or(miner_default_config.microblock_attempt_time_ms),
+            probability_pick_no_estimate_tx: self
+                .probability_pick_no_estimate_tx
+                .unwrap_or(miner_default_config.probability_pick_no_estimate_tx),
+            block_reward_recipient: self
+                .block_reward_recipient
+                .map(|c| {
+                    PrincipalData::parse(&c).map_err(|e| {
+                        format!(
+                            "miner.block_reward_recipient is not a valid principal identifier: {e}"
+                        )
+                    })
+                })
+                .transpose()?,
+            segwit: self.segwit.unwrap_or(miner_default_config.segwit),
+            wait_for_block_download: miner_default_config.wait_for_block_download,
+            nonce_cache_size: self
+                .nonce_cache_size
+                .unwrap_or(miner_default_config.nonce_cache_size),
+            candidate_retry_cache_size: self
+                .candidate_retry_cache_size
+                .unwrap_or(miner_default_config.candidate_retry_cache_size),
+            unprocessed_block_deadline_secs: self
+                .unprocessed_block_deadline_secs
+                .unwrap_or(miner_default_config.unprocessed_block_deadline_secs),
+            mining_key: self
+                .mining_key
+                .as_ref()
+                .map(|x| Secp256k1PrivateKey::from_hex(x))
+                .transpose()?,
+            self_signing_key: self
+                .self_signing_seed
+                .as_ref()
+                .map(|x| SelfSigner::from_seed(*x))
+                .or(miner_default_config.self_signing_key),
+            wait_on_interim_blocks: self
+                .wait_on_interim_blocks_ms
+                .map(Duration::from_millis)
+                .unwrap_or(miner_default_config.wait_on_interim_blocks),
+        })
+    }
+}
 #[derive(Clone, Deserialize, Default, Debug)]
 pub struct AtlasConfigFile {
     pub attachments_max_size: Option<u32>,

From a962725a144860401a86bda1a6f2ad498416adaf Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Tue, 9 Jan 2024 12:59:48 -0500
Subject: [PATCH 0339/1166] BUG: fix stacker db refresh logic

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stackslib/src/net/mod.rs             | 26 +++++++--------
 stackslib/src/net/p2p.rs             | 10 ++----
 stackslib/src/net/stackerdb/mod.rs   | 49 ++++++++++++++--------------
 testnet/stacks-node/src/neon_node.rs | 16 ++++-----
 4 files changed, 47 insertions(+), 54 deletions(-)

diff --git a/stackslib/src/net/mod.rs b/stackslib/src/net/mod.rs
index cd5bafbc1b..46f0d67141 100644
--- a/stackslib/src/net/mod.rs
+++ b/stackslib/src/net/mod.rs
@@ -2405,22 +2405,22 @@ pub mod test {
             let relayer_stacker_dbs = StackerDBs::connect(&stackerdb_path, true).unwrap();
             let p2p_stacker_dbs = StackerDBs::connect(&stackerdb_path, true).unwrap();
 
-            let contracts: Vec<_> = config
-                .stacker_dbs
-                .iter()
-                .enumerate()
-                .map(|(i, stackerdb)| {
-                    (
-                        stackerdb.clone(),
-                        config.stacker_db_configs.get(i).unwrap_or(&None).clone(),
-                    )
-                })
-                .collect();
+            let mut old_stackerdb_configs = HashMap::new();
+            for (i, contract) in config.stacker_dbs.iter().enumerate() {
+                old_stackerdb_configs.insert(
+                    contract.clone(),
+                    config
+                        .stacker_db_configs
+                        .get(i)
+                        .map(|config| config.clone().unwrap_or(StackerDBConfig::noop()))
+                        .unwrap_or(StackerDBConfig::noop()),
+                );
+            }
             let mut stackerdb_configs = stacker_dbs_conn
-                .create_or_reconfigure_stackerdb(
+                .create_or_reconfigure_stackerdbs(
                     &mut stacks_node.chainstate,
                     &sortdb,
-                    contracts.as_slice(),
+                    old_stackerdb_configs,
                 )
                 .expect("Failed to refresh stackerdb configs");
 
diff --git a/stackslib/src/net/p2p.rs b/stackslib/src/net/p2p.rs
index 0306e92d60..36f680c269 100644
--- a/stackslib/src/net/p2p.rs
+++ b/stackslib/src/net/p2p.rs
@@ -5293,15 +5293,11 @@ impl PeerNetwork {
                 .unwrap_or(Txid([0x00; 32]));
 
             // refresh stackerdb configs
-            let contracts: Vec<_> = self
-                .stacker_db_configs
-                .iter()
-                .map(|(contract_id, config)| (contract_id.clone(), Some(config.clone())))
-                .collect();
-            self.stacker_db_configs = self.stackerdbs.create_or_reconfigure_stackerdb(
+            let stacker_db_configs = mem::replace(&mut self.stacker_db_configs, HashMap::new());
+            self.stacker_db_configs = self.stackerdbs.create_or_reconfigure_stackerdbs(
                 chainstate,
                 sortdb,
-                contracts.as_slice(),
+                stacker_db_configs,
             )?;
         }
 
diff --git a/stackslib/src/net/stackerdb/mod.rs b/stackslib/src/net/stackerdb/mod.rs
index bdc6082f8b..996042dd50 100644
--- a/stackslib/src/net/stackerdb/mod.rs
+++ b/stackslib/src/net/stackerdb/mod.rs
@@ -250,62 +250,61 @@ impl StackerDBs {
     /// Create or reconfigure the supplied contracts with the appropriate stacker DB config.
     /// Returns a map of the stacker DBs and their loaded configs.
     /// Fails only if the underlying DB fails
-    pub fn create_or_reconfigure_stackerdb(
+    pub fn create_or_reconfigure_stackerdbs(
         &mut self,
         chainstate: &mut StacksChainState,
         sortdb: &SortitionDB,
-        contracts: &[(QualifiedContractIdentifier, Option<StackerDBConfig>)],
+        stacker_db_configs: HashMap<QualifiedContractIdentifier, StackerDBConfig>,
     ) -> Result<HashMap<QualifiedContractIdentifier, StackerDBConfig>, net_error> {
         let existing_contract_ids = self.get_stackerdb_contract_ids()?;
         let mut new_stackerdb_configs = HashMap::new();
-        for (contract_id, config) in contracts {
+
+        for (stackerdb_contract_id, stackerdb_config) in stacker_db_configs.into_iter() {
             // Determine the new config for this StackerDB replica
-            let new_config = if *contract_id == boot_code_id(MINERS_NAME, chainstate.mainnet) {
+            let new_config = if stackerdb_contract_id
+                == boot_code_id(MINERS_NAME, chainstate.mainnet)
+            {
                 // .miners contract -- directly generate the config
                 NakamotoChainState::make_miners_stackerdb_config(sortdb).unwrap_or_else(|e| {
                     warn!(
                         "Failed to generate .miners StackerDB config";
-                        "contract" => %contract_id,
+                        "contract" => %stackerdb_contract_id,
                         "err" => ?e,
                     );
                     StackerDBConfig::noop()
                 })
             } else {
                 // attempt to load the config from the contract itself
-                config.clone().unwrap_or_else(|| {
-                    StackerDBConfig::from_smart_contract(chainstate, &sortdb, contract_id)
-                        .unwrap_or_else(|e| {
-                            warn!(
-                                "Failed to load StackerDB config";
-                                "contract" => %contract_id,
-                                "err" => ?e,
-                            );
-                            StackerDBConfig::noop()
-                        })
-                })
+                StackerDBConfig::from_smart_contract(chainstate, &sortdb, &stackerdb_contract_id)
+                    .unwrap_or_else(|e| {
+                        warn!(
+                            "Failed to load StackerDB config";
+                            "contract" => %stackerdb_contract_id,
+                            "err" => ?e,
+                        );
+                        StackerDBConfig::noop()
+                    })
             };
             // Create the StackerDB replica if it does not exist already
-            if !existing_contract_ids.contains(contract_id) {
-                if let Err(e) = self.create_stackerdb(contract_id, &new_config) {
+            if !existing_contract_ids.contains(&stackerdb_contract_id) {
+                if let Err(e) = self.create_stackerdb(&stackerdb_contract_id, &new_config) {
                     warn!(
-                        "Failed to create or reconfigure StackerDB {contract_id}: DB error {:?}",
+                        "Failed to create or reconfigure StackerDB {stackerdb_contract_id}: DB error {:?}",
                         &e
                     );
                 }
-            } else if new_config != config.clone().unwrap_or(StackerDBConfig::noop())
-                && new_config.signers.len() > 0
-            {
+            } else if new_config != stackerdb_config && new_config.signers.len() > 0 {
                 // only reconfigure if the config has changed
-                if let Err(e) = self.reconfigure_stackerdb(contract_id, &new_config) {
+                if let Err(e) = self.reconfigure_stackerdb(&stackerdb_contract_id, &new_config) {
                     warn!(
-                        "Failed to create or reconfigure StackerDB {contract_id}: DB error {:?}",
+                        "Failed to create or reconfigure StackerDB {stackerdb_contract_id}: DB error {:?}",
                         &e
                     );
                 }
             }
             // Even if we failed to create or reconfigure the DB, we still want to keep track of them
             // so that we can attempt to create/reconfigure them again later.
-            new_stackerdb_configs.insert(contract_id.clone(), new_config);
+            new_stackerdb_configs.insert(stackerdb_contract_id, new_config);
         }
         Ok(new_stackerdb_configs)
     }
diff --git a/testnet/stacks-node/src/neon_node.rs b/testnet/stacks-node/src/neon_node.rs
index d23ad967c2..0305801107 100644
--- a/testnet/stacks-node/src/neon_node.rs
+++ b/testnet/stacks-node/src/neon_node.rs
@@ -184,7 +184,7 @@ use stacks::net::db::{LocalPeer, PeerDB};
 use stacks::net::dns::{DNSClient, DNSResolver};
 use stacks::net::p2p::PeerNetwork;
 use stacks::net::relay::Relayer;
-use stacks::net::stackerdb::{StackerDBSync, StackerDBs};
+use stacks::net::stackerdb::{StackerDBConfig, StackerDBSync, StackerDBs};
 use stacks::net::{
     Error as NetError, NetworkResult, PeerNetworkComms, RPCHandlerArgs, ServiceFlags,
 };
@@ -3806,15 +3806,13 @@ impl StacksNode {
 
         let mut stackerdb_machines = HashMap::new();
         let mut stackerdbs = StackerDBs::connect(&config.get_stacker_db_file_path(), true).unwrap();
-        let contracts: Vec<_> = config
-            .node
-            .stacker_dbs
-            .clone()
-            .into_iter()
-            .map(|contract_id| (contract_id, None))
-            .collect();
+
+        let mut stackerdb_configs = HashMap::new();
+        for contract in config.node.stacker_dbs.iter() {
+            stackerdb_configs.insert(contract.clone(), StackerDBConfig::noop());
+        }
         let stackerdb_configs = stackerdbs
-            .create_or_reconfigure_stackerdb(&mut chainstate, &sortdb, contracts.as_slice())
+            .create_or_reconfigure_stackerdbs(&mut chainstate, &sortdb, stackerdb_configs)
             .unwrap();
 
         let stackerdb_contract_ids: Vec<QualifiedContractIdentifier> =

From ac984f87cde717ac6873d1e6aa9ad0462cc4be30 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Tue, 9 Jan 2024 14:18:12 -0500
Subject: [PATCH 0340/1166] BUG: fix tests setup_stackerdb to reconfigure
 rather than create

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stackslib/src/net/stackerdb/tests/sync.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stackslib/src/net/stackerdb/tests/sync.rs b/stackslib/src/net/stackerdb/tests/sync.rs
index 65ef659244..066b9b469c 100644
--- a/stackslib/src/net/stackerdb/tests/sync.rs
+++ b/stackslib/src/net/stackerdb/tests/sync.rs
@@ -123,7 +123,7 @@ fn setup_stackerdb(peer: &mut TestPeer, idx: usize, fill: bool, num_slots: usize
         .tx_begin(stackerdb_config.clone())
         .unwrap();
 
-    tx.create_stackerdb(contract_id, &slots).unwrap();
+    tx.reconfigure_stackerdb(contract_id, &slots).unwrap();
 
     if fill {
         for i in 0..num_slots {

From 157c80952344ac3613edb040160185558f457aab Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Tue, 9 Jan 2024 15:33:35 -0500
Subject: [PATCH 0341/1166] CRC: move tip calculation to outer loop to minimize
 IO

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stackslib/src/chainstate/nakamoto/miner.rs     | 3 ++-
 stackslib/src/chainstate/nakamoto/mod.rs       | 5 +++--
 stackslib/src/chainstate/nakamoto/tests/mod.rs | 7 ++++++-
 stackslib/src/net/stackerdb/mod.rs             | 3 ++-
 testnet/stacks-node/src/nakamoto_node/miner.rs | 3 +++
 5 files changed, 16 insertions(+), 5 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/miner.rs b/stackslib/src/chainstate/nakamoto/miner.rs
index 730882b78a..b4f44bdd2a 100644
--- a/stackslib/src/chainstate/nakamoto/miner.rs
+++ b/stackslib/src/chainstate/nakamoto/miner.rs
@@ -516,13 +516,14 @@ impl NakamotoBlockBuilder {
     /// Returns an error on signing or DB error
     pub fn make_stackerdb_block_proposal(
         sortdb: &SortitionDB,
+        tip: &BlockSnapshot,
         stackerdbs: &StackerDBs,
         block: &NakamotoBlock,
         miner_privkey: &StacksPrivateKey,
         miners_contract_id: &QualifiedContractIdentifier,
     ) -> Result<Option<StackerDBChunkData>, Error> {
         let miner_pubkey = StacksPublicKey::from_private(&miner_privkey);
-        let Some(slot_id) = NakamotoChainState::get_miner_slot(sortdb, &miner_pubkey)? else {
+        let Some(slot_id) = NakamotoChainState::get_miner_slot(sortdb, tip, &miner_pubkey)? else {
             // No slot exists for this miner
             return Ok(None);
         };
diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index c9bd8a9e21..23662cab50 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -3054,8 +3054,8 @@ impl NakamotoChainState {
     /// It has two slots -- one for the past two sortition winners.
     pub fn make_miners_stackerdb_config(
         sortdb: &SortitionDB,
+        tip: &BlockSnapshot,
     ) -> Result<StackerDBConfig, ChainstateError> {
-        let tip = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn())?;
         let ih = sortdb.index_handle(&tip.sortition_id);
         let last_winner_snapshot = ih.get_last_snapshot_with_sortition(tip.block_height)?;
         let parent_winner_snapshot = ih.get_last_snapshot_with_sortition(
@@ -3133,10 +3133,11 @@ impl NakamotoChainState {
     /// Returns an error if the miner is in the StackerDB config but the slot number is invalid.
     pub fn get_miner_slot(
         sortdb: &SortitionDB,
+        tip: &BlockSnapshot,
         miner_pubkey: &StacksPublicKey,
     ) -> Result<Option<u32>, ChainstateError> {
         let miner_hash160 = Hash160::from_node_public_key(&miner_pubkey);
-        let stackerdb_config = Self::make_miners_stackerdb_config(sortdb)?;
+        let stackerdb_config = Self::make_miners_stackerdb_config(sortdb, &tip)?;
 
         // find out which slot we're in
         let Some(slot_id_res) =
diff --git a/stackslib/src/chainstate/nakamoto/tests/mod.rs b/stackslib/src/chainstate/nakamoto/tests/mod.rs
index 5d6225f5f7..2e89d23bcb 100644
--- a/stackslib/src/chainstate/nakamoto/tests/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/mod.rs
@@ -1816,8 +1816,10 @@ fn test_make_miners_stackerdb_config() {
             .unwrap()
             .unwrap();
 
+        let tip = SortitionDB::get_canonical_burn_chain_tip(sort_db.conn()).unwrap();
         // check the stackerdb config as of this chain tip
-        let stackerdb_config = NakamotoChainState::make_miners_stackerdb_config(sort_db).unwrap();
+        let stackerdb_config =
+            NakamotoChainState::make_miners_stackerdb_config(sort_db, &tip).unwrap();
         eprintln!(
             "stackerdb_config at i = {} (sorition? {}): {:?}",
             &i, sortition, &stackerdb_config
@@ -1841,9 +1843,11 @@ fn test_make_miners_stackerdb_config() {
             header,
             txs: vec![],
         };
+        let tip = SortitionDB::get_canonical_burn_chain_tip(sort_db.conn()).unwrap();
         if sortition {
             let chunk = NakamotoBlockBuilder::make_stackerdb_block_proposal(
                 &sort_db,
+                &tip,
                 &stackerdbs,
                 &block,
                 &miner_keys[i],
@@ -1857,6 +1861,7 @@ fn test_make_miners_stackerdb_config() {
         } else {
             assert!(NakamotoBlockBuilder::make_stackerdb_block_proposal(
                 &sort_db,
+                &tip,
                 &stackerdbs,
                 &block,
                 &miner_keys[i],
diff --git a/stackslib/src/net/stackerdb/mod.rs b/stackslib/src/net/stackerdb/mod.rs
index 996042dd50..243a7324d4 100644
--- a/stackslib/src/net/stackerdb/mod.rs
+++ b/stackslib/src/net/stackerdb/mod.rs
@@ -258,6 +258,7 @@ impl StackerDBs {
     ) -> Result<HashMap<QualifiedContractIdentifier, StackerDBConfig>, net_error> {
         let existing_contract_ids = self.get_stackerdb_contract_ids()?;
         let mut new_stackerdb_configs = HashMap::new();
+        let tip = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn())?;
 
         for (stackerdb_contract_id, stackerdb_config) in stacker_db_configs.into_iter() {
             // Determine the new config for this StackerDB replica
@@ -265,7 +266,7 @@ impl StackerDBs {
                 == boot_code_id(MINERS_NAME, chainstate.mainnet)
             {
                 // .miners contract -- directly generate the config
-                NakamotoChainState::make_miners_stackerdb_config(sortdb).unwrap_or_else(|e| {
+                NakamotoChainState::make_miners_stackerdb_config(sortdb, &tip).unwrap_or_else(|e| {
                     warn!(
                         "Failed to generate .miners StackerDB config";
                         "contract" => %stackerdb_contract_id,
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index aca0e99e02..03e3e29bc2 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -171,6 +171,8 @@ impl BlockMinerThread {
                 self.burnchain.pox_constants.clone(),
             )
             .expect("FATAL: could not open sortition DB");
+            let tip = SortitionDB::get_canonical_burn_chain_tip(sort_db.conn())
+                .expect("FATAL: could not retrieve chain tip");
             if let Some(new_block) = new_block {
                 let Some(miner_privkey) = self.config.miner.mining_key else {
                     warn!("No mining key configured, cannot mine");
@@ -178,6 +180,7 @@ impl BlockMinerThread {
                 };
                 match NakamotoBlockBuilder::make_stackerdb_block_proposal(
                     &sort_db,
+                    &tip,
                     &stackerdbs,
                     &new_block,
                     &miner_privkey,

From 9b28e4825b4e0066456e564e7d078fbf314db829 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Tue, 9 Jan 2024 15:37:50 -0500
Subject: [PATCH 0342/1166] CRC: rip out .miners dummy contract

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 .../src/chainstate/stacks/boot/miners.clar    | 21 -------
 stackslib/src/chainstate/stacks/boot/mod.rs   |  1 -
 stackslib/src/clarity_vm/clarity.rs           | 58 +------------------
 3 files changed, 3 insertions(+), 77 deletions(-)
 delete mode 100644 stackslib/src/chainstate/stacks/boot/miners.clar

diff --git a/stackslib/src/chainstate/stacks/boot/miners.clar b/stackslib/src/chainstate/stacks/boot/miners.clar
deleted file mode 100644
index 2fd9a9e870..0000000000
--- a/stackslib/src/chainstate/stacks/boot/miners.clar
+++ /dev/null
@@ -1,21 +0,0 @@
-;; This contract governs a StackerDB instance in which the current and previous
-;; miner can send their blocks to Stackers for an aggregate signature.
-;; This is a placeholder smart contract, which allows the node to advertize
-;; that it replicates the state for this StackerDB while maintaining the power
-;; to generate the config and signer slots directly.
-
-;; StackerDB-required method to get the allocation of slots for signers.
-;; The values here are ignored.
-(define-public (stackerdb-get-signer-slots)
-    (ok (list )))
-
-;; StackerDB-required method to get the DB configuration.
-;; The values here are ignored.
-(define-public (stackerdb-get-config)
-    (ok {
-        chunk-size: u0,
-        write-freq: u0,
-        max-writes: u0,
-        max-neighbors: u0,
-        hint-replicas: (list )
-    }))
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 0b010329b3..aadab604f4 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -88,7 +88,6 @@ pub const BOOT_TEST_POX_4_AGG_KEY_CONTRACT: &'static str = "pox-4-agg-test-boote
 pub const BOOT_TEST_POX_4_AGG_KEY_FNAME: &'static str = "aggregate-key";
 
 pub const MINERS_NAME: &'static str = "miners";
-pub const MINERS_CODE: &'static str = std::include_str!("miners.clar");
 
 pub mod docs;
 
diff --git a/stackslib/src/clarity_vm/clarity.rs b/stackslib/src/clarity_vm/clarity.rs
index 9a18decfdb..c702d9b084 100644
--- a/stackslib/src/clarity_vm/clarity.rs
+++ b/stackslib/src/clarity_vm/clarity.rs
@@ -47,9 +47,8 @@ use crate::chainstate::stacks::boot::{
     BOOT_CODE_COSTS, BOOT_CODE_COSTS_2, BOOT_CODE_COSTS_2_TESTNET, BOOT_CODE_COSTS_3,
     BOOT_CODE_COST_VOTING_TESTNET as BOOT_CODE_COST_VOTING, BOOT_CODE_POX_TESTNET,
     BOOT_TEST_POX_4_AGG_KEY_CONTRACT, BOOT_TEST_POX_4_AGG_KEY_FNAME, COSTS_2_NAME, COSTS_3_NAME,
-    MINERS_CODE, MINERS_NAME, POX_2_MAINNET_CODE, POX_2_NAME, POX_2_TESTNET_CODE,
-    POX_3_MAINNET_CODE, POX_3_NAME, POX_3_TESTNET_CODE, POX_4_MAINNET_CODE, POX_4_NAME,
-    POX_4_TESTNET_CODE,
+    MINERS_NAME, POX_2_MAINNET_CODE, POX_2_NAME, POX_2_TESTNET_CODE, POX_3_MAINNET_CODE,
+    POX_3_NAME, POX_3_TESTNET_CODE, POX_4_MAINNET_CODE, POX_4_NAME, POX_4_TESTNET_CODE,
 };
 use crate::chainstate::stacks::db::{StacksAccount, StacksChainState};
 use crate::chainstate::stacks::events::{StacksTransactionEvent, StacksTransactionReceipt};
@@ -1259,57 +1258,6 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
                 tx_conn.epoch = StacksEpochId::Epoch25;
             });
 
-            /////////////////// .miners //////////////////////
-            let mainnet = self.mainnet;
-            let tx_version = if mainnet {
-                TransactionVersion::Mainnet
-            } else {
-                TransactionVersion::Testnet
-            };
-            let boot_code_address = boot_code_addr(mainnet);
-
-            let boot_code_auth = boot_code_tx_auth(boot_code_address.clone());
-            let boot_code_account = self
-                .get_boot_code_account()
-                .expect("FATAL: did not get boot account");
-
-            let miners_contract_id = boot_code_id(MINERS_NAME, mainnet);
-
-            let payload = TransactionPayload::SmartContract(
-                TransactionSmartContract {
-                    name: ContractName::try_from(MINERS_NAME)
-                        .expect("FATAL: invalid boot-code contract name"),
-                    code_body: StacksString::from_str(MINERS_CODE)
-                        .expect("FATAL: invalid boot code body"),
-                },
-                Some(ClarityVersion::Clarity2),
-            );
-
-            let miners_contract_tx =
-                StacksTransaction::new(tx_version.clone(), boot_code_auth.clone(), payload);
-
-            let miners_initialization_receipt = self.as_transaction(|tx_conn| {
-                // initialize with a synthetic transaction
-                debug!("Instantiate {} contract", &miners_contract_id);
-                let receipt = StacksChainState::process_transaction_payload(
-                    tx_conn,
-                    &miners_contract_tx,
-                    &boot_code_account,
-                    ASTRules::PrecheckSize,
-                )
-                .expect("FATAL: Failed to process .miners contract initialization");
-                receipt
-            });
-
-            if miners_initialization_receipt.result != Value::okay_true()
-                || miners_initialization_receipt.post_condition_aborted
-            {
-                panic!(
-                    "FATAL: Failure processing .miners contract initialization: {:#?}",
-                    &miners_initialization_receipt
-                );
-            }
-
             /////////////////// .pox-4 ////////////////////////
             let first_block_height = self.burn_state_db.get_burn_start_height();
             let pox_prepare_length = self.burn_state_db.get_pox_prepare_length();
@@ -1323,8 +1271,8 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
             )
             .expect("PANIC: PoX-4 first reward cycle begins *before* first burn block height")
                 + 1;
-
             // get tx_version & boot code account information for pox-3 contract init
+            let mainnet = self.mainnet;
             let tx_version = if mainnet {
                 TransactionVersion::Mainnet
             } else {

From 284a661dc245ba1d5d0b4a247df94f3b961924d6 Mon Sep 17 00:00:00 2001
From: friedger <mail@friedger.de>
Date: Tue, 9 Jan 2024 23:39:47 +0100
Subject: [PATCH 0343/1166] fix: re-add checks for expiry

---
 stackslib/src/chainstate/stacks/boot/pox-4.clar | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index 45f2b6f16d..5fe89998cc 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -29,6 +29,7 @@
 (define-constant ERR_STACKING_NOT_DELEGATED 31)
 (define-constant ERR_INVALID_SIGNER_KEY 32)
 (define-constant ERR_REUSED_SIGNER_KEY 33)
+(define-constant ERR_DELEGATION_ALREADY_REVOKED 34)
 
 ;; Valid values for burnchain address versions.
 ;; These first four correspond to address hash modes in Stacks 2.1,
@@ -600,12 +601,17 @@
           ;; return the lock-up information, so the node can actually carry out the lock.
           (ok { stacker: tx-sender, lock-amount: amount-ustx, signer-key: signer-key, unlock-burn-height: (reward-cycle-to-burn-height (+ first-reward-cycle lock-period)) }))))
 
+;; Revokes the delegation to the current stacking pool.
+;; New in pox-4: Fails if the delegation was already revoked.
+;; Returns the last delegation state.
 (define-public (revoke-delegate-stx)
-  (begin
+  (let ((last-delegation-state (get-check-delegation tx-sender)))
     ;; must be called directly by the tx-sender or by an allowed contract-caller
     (asserts! (check-caller-allowed)
               (err ERR_STACKING_PERMISSION_DENIED))
-    (ok (map-delete delegation-state { stacker: tx-sender }))))
+    (asserts! (is-some last-delegation-state) (err ERR_DELEGATION_ALREADY_REVOKED))
+    (asserts! (map-delete delegation-state { stacker: tx-sender }) (err ERR_DELEGATION_ALREADY_REVOKED))
+    (ok last-delegation-state)))
 
 ;; Delegate to `delegate-to` the ability to stack from a given address.
 ;;  This method _does not_ lock the funds, rather, it allows the delegate

From f2567faae4840e331b4e7c2b7b4c8a7cbd33b995 Mon Sep 17 00:00:00 2001
From: Friedger <mail@friedger.de>
Date: Tue, 9 Jan 2024 23:44:52 +0100
Subject: [PATCH 0344/1166] chore: fix constant names

---
 stackslib/src/clarity_vm/clarity.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stackslib/src/clarity_vm/clarity.rs b/stackslib/src/clarity_vm/clarity.rs
index 56dc3b4f69..d51bb518c4 100644
--- a/stackslib/src/clarity_vm/clarity.rs
+++ b/stackslib/src/clarity_vm/clarity.rs
@@ -48,7 +48,7 @@ use crate::chainstate::stacks::boot::{
     BOOT_CODE_COST_VOTING_TESTNET as BOOT_CODE_COST_VOTING, BOOT_CODE_POX_TESTNET,
     BOOT_TEST_POX_4_AGG_KEY_CONTRACT, BOOT_TEST_POX_4_AGG_KEY_FNAME, COSTS_2_NAME, COSTS_3_NAME,
     MINERS_NAME, POX_2_MAINNET_CODE, POX_2_NAME, POX_2_TESTNET_CODE, POX_3_MAINNET_CODE,
-    POX_3_NAME, POX_4_CODE, POX_4_NAME, POX_4_TESTNET_CODE,
+    POX_3_NAME, POX_3_TESTNET_CODE, POX_4_CODE, POX_4_NAME,
 };
 use crate::chainstate::stacks::db::{StacksAccount, StacksChainState};
 use crate::chainstate::stacks::events::{StacksTransactionEvent, StacksTransactionReceipt};

From 2b812fb2ca3624a6bfeac8a921be113d97fea102 Mon Sep 17 00:00:00 2001
From: "brady.ouren" <tippenein@gmail.com>
Date: Sun, 10 Dec 2023 18:09:02 -0800
Subject: [PATCH 0345/1166] change the wording around the signature description

---
 clarity/src/vm/docs/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/clarity/src/vm/docs/mod.rs b/clarity/src/vm/docs/mod.rs
index df117a7bca..1f7a6c5ced 100644
--- a/clarity/src/vm/docs/mod.rs
+++ b/clarity/src/vm/docs/mod.rs
@@ -2001,7 +2001,7 @@ const DEFINE_TRAIT_API: DefineAPI = DefineAPI {
 can implement a given trait and then have their contract identifier being passed as a function argument in order to be called
 dynamically with `contract-call?`.
 
-Traits are defined with a name, and a list functions, defined with a name, a list of argument types, and return type.
+Traits are defined with a name, a list of functions, and a return type. The list of functions here is defined with a name and the list of argument types.
 
 In Clarity 1, a trait type can be used to specify the type of a function parameter. A parameter with a trait type can
 be used as the target of a dynamic `contract-call?`. A principal literal (e.g. `ST1PQHQKV0RJXZFY1DGX8MNSNYVE3VGZJSRTPGZGM.foo`)

From 9d8044deefb9467329902db0700e1f4702d30e8d Mon Sep 17 00:00:00 2001
From: "brady.ouren" <tippenein@gmail.com>
Date: Tue, 12 Dec 2023 10:32:24 -0800
Subject: [PATCH 0346/1166] use @obycode copy

---
 clarity/src/vm/docs/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/clarity/src/vm/docs/mod.rs b/clarity/src/vm/docs/mod.rs
index 1f7a6c5ced..0199d1c71e 100644
--- a/clarity/src/vm/docs/mod.rs
+++ b/clarity/src/vm/docs/mod.rs
@@ -2001,7 +2001,7 @@ const DEFINE_TRAIT_API: DefineAPI = DefineAPI {
 can implement a given trait and then have their contract identifier being passed as a function argument in order to be called
 dynamically with `contract-call?`.
 
-Traits are defined with a name, a list of functions, and a return type. The list of functions here is defined with a name and the list of argument types.
+Traits are defined with a name, and a list functions, where each function is defined with a name, a list of argument types, and a return type.
 
 In Clarity 1, a trait type can be used to specify the type of a function parameter. A parameter with a trait type can
 be used as the target of a dynamic `contract-call?`. A principal literal (e.g. `ST1PQHQKV0RJXZFY1DGX8MNSNYVE3VGZJSRTPGZGM.foo`)

From 0813280cecf8275cf4640d7d2130a9dfcf739bd4 Mon Sep 17 00:00:00 2001
From: "brady.ouren" <tippenein@gmail.com>
Date: Tue, 12 Dec 2023 11:55:48 -0800
Subject: [PATCH 0347/1166] 'list of functions'

---
 clarity/src/vm/docs/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/clarity/src/vm/docs/mod.rs b/clarity/src/vm/docs/mod.rs
index 0199d1c71e..034616c0f7 100644
--- a/clarity/src/vm/docs/mod.rs
+++ b/clarity/src/vm/docs/mod.rs
@@ -2001,7 +2001,7 @@ const DEFINE_TRAIT_API: DefineAPI = DefineAPI {
 can implement a given trait and then have their contract identifier being passed as a function argument in order to be called
 dynamically with `contract-call?`.
 
-Traits are defined with a name, and a list functions, where each function is defined with a name, a list of argument types, and a return type.
+Traits are defined with a name, and a list of functions, where each function is defined with a name, a list of argument types, and a return type.
 
 In Clarity 1, a trait type can be used to specify the type of a function parameter. A parameter with a trait type can
 be used as the target of a dynamic `contract-call?`. A principal literal (e.g. `ST1PQHQKV0RJXZFY1DGX8MNSNYVE3VGZJSRTPGZGM.foo`)

From a594e8b933a9c9ec9ea8250bf371876da0641e46 Mon Sep 17 00:00:00 2001
From: Arun <arun@arun.blog>
Date: Tue, 26 Dec 2023 22:45:24 -0800
Subject: [PATCH 0348/1166] Use GITHUB_OUTPUT envvar instead of set-output
 command as the latter is deprecated

---
 .github/workflows/docs-pr.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/docs-pr.yml b/.github/workflows/docs-pr.yml
index d3dbeaa45c..29e49a9236 100644
--- a/.github/workflows/docs-pr.yml
+++ b/.github/workflows/docs-pr.yml
@@ -66,12 +66,12 @@ jobs:
           git add src/_data/boot-contracts-reference.json
           if $(git diff --staged --quiet --exit-code); then
             echo "No reference.json changes, stopping"
-            echo "::set-output name=open_pr::0"
+            echo "open_pr=0" >> $GITHUB_OUTPUT
           else
             git remote add robot https://github.com/$ROBOT_OWNER/$ROBOT_REPO
             git commit -m "auto: update Clarity references JSONs from stacks-core@${GITHUB_SHA}"
             git push robot $ROBOT_BRANCH
-            echo "::set-output name=open_pr::1"
+            echo "open_pr=1" >> $GITHUB_OUTPUT
           fi
 
       - name: Open PR

From a2eb39fff043ac9f354656c2fa1177253c233a67 Mon Sep 17 00:00:00 2001
From: friedger <mail@friedger.de>
Date: Wed, 10 Jan 2024 10:59:07 +0100
Subject: [PATCH 0349/1166] fix: use correct error code

---
 stackslib/src/chainstate/stacks/boot/pox_4_tests.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 916d713be8..ac20ffca5f 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -1325,7 +1325,7 @@ fn pox_4_revoke_delegate_stx_events() {
     // second revoke transaction should fail
     assert_eq!(
         &alice_txs[&alice_revoke_2_nonce].result.to_string(),
-        "(err 33)"
+        "(err 34)"
     );
 
     // second delegate transaction should succeed
@@ -1336,7 +1336,7 @@ fn pox_4_revoke_delegate_stx_events() {
     // third revoke transaction should fail
     assert_eq!(
         &alice_txs[&alice_revoke_3_nonce].result.to_string(),
-        "(err 33)"
+        "(err 34)"
     );
 }
 

From a77f6b4b5fb1d3811a58a298058642b0ab7f72dd Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Mon, 18 Dec 2023 14:41:45 -0500
Subject: [PATCH 0350/1166] Process coordinator messages to duplicate state
 between multiple coordinators

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/runloop.rs            | 15 +++---
 testnet/stacks-node/src/tests/signer.rs | 72 +++++++++++++------------
 2 files changed, 44 insertions(+), 43 deletions(-)

diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index f109e2ce02..c6cd3d9b0d 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -170,7 +170,7 @@ impl<C: Coordinator> RunLoop<C> {
         event: &StackerDBChunksEvent,
     ) -> (Vec<Packet>, Vec<OperationResult>) {
         // Determine the current coordinator id and public key for verification
-        let (coordinator_id, coordinator_public_key) =
+        let (_coordinator_id, coordinator_public_key) =
             calculate_coordinator(&self.signing_round.public_keys);
         // Filter out invalid messages
         let inbound_messages: Vec<Packet> = event
@@ -190,14 +190,11 @@ impl<C: Coordinator> RunLoop<C> {
             .signing_round
             .process_inbound_messages(&inbound_messages)
             .unwrap_or_default();
-        // If the signer is the coordinator, then next process the message as the coordinator
-        let (messages, results) = if self.signing_round.signer_id == coordinator_id {
-            self.coordinator
-                .process_inbound_messages(&inbound_messages)
-                .unwrap_or_default()
-        } else {
-            (vec![], vec![])
-        };
+        // Next process the message as the coordinator
+        let (messages, results) = self
+            .coordinator
+            .process_inbound_messages(&inbound_messages)
+            .unwrap_or_default();
         outbound_messages.extend(messages);
         (outbound_messages, results)
     }
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index 9779e84a62..f142fe26ad 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -201,8 +201,8 @@ fn test_stackerdb_dkg() {
         .init();
 
     // Generate Signer Data
-    let num_signers: u32 = 10;
-    let num_keys: u32 = 400;
+    let num_signers: u32 = 3;
+    let num_keys: u32 = 2;
     let publisher_private_key = StacksPrivateKey::new();
     let signer_stacks_private_keys = (0..num_signers)
         .map(|_| StacksPrivateKey::new())
@@ -240,7 +240,7 @@ fn test_stackerdb_dkg() {
     let mut running_signers = vec![];
     // Spawn all the signers first to listen to the coordinator request for dkg
     let mut signer_cmd_senders = Vec::new();
-    let mut signer_res_receivers = Vec::new();
+    let mut res_receivers = Vec::new();
     for i in (1..num_signers).rev() {
         let (cmd_send, cmd_recv) = channel();
         let (res_send, res_recv) = channel();
@@ -248,7 +248,7 @@ fn test_stackerdb_dkg() {
         let running_signer = spawn_signer(&signer_configs[i as usize], cmd_recv, res_send);
         running_signers.push(running_signer);
         signer_cmd_senders.push(cmd_send);
-        signer_res_receivers.push(res_recv);
+        res_receivers.push(res_recv);
     }
     // Spawn coordinator second
     let (coordinator_cmd_send, coordinator_cmd_recv) = channel();
@@ -260,6 +260,8 @@ fn test_stackerdb_dkg() {
         coordinator_res_send,
     );
 
+    res_receivers.push(coordinator_res_recv);
+
     // Let's wrap the node in a lifetime to ensure stopping the signers doesn't cause issues.
     {
         // Setup the nodes and deploy the contract to it
@@ -291,38 +293,40 @@ fn test_stackerdb_dkg() {
                 merkle_root: None,
             })
             .expect("failed to send Sign command");
-
-        let mut aggregate_group_key = None;
-        let mut frost_signature = None;
-        let mut schnorr_proof = None;
-
-        loop {
-            let results = coordinator_res_recv.recv().expect("failed to recv results");
-            for result in results {
-                match result {
-                    OperationResult::Dkg(point) => {
-                        info!("Received aggregate_group_key {point}");
-                        aggregate_group_key = Some(point);
-                    }
-                    OperationResult::Sign(sig) => {
-                        info!("Received Signature ({},{})", &sig.R, &sig.z);
-                        frost_signature = Some(sig);
-                    }
-                    OperationResult::SignTaproot(proof) => {
-                        info!("Received SchnorrProof ({},{})", &proof.r, &proof.s);
-                        schnorr_proof = Some(proof);
-                    }
-                    OperationResult::DkgError(dkg_error) => {
-                        panic!("Received DkgError {}", dkg_error);
-                    }
-                    OperationResult::SignError(sign_error) => {
-                        panic!("Received SignError {}", sign_error);
+        for recv in res_receivers.iter() {
+            let mut aggregate_group_key = None;
+            let mut frost_signature = None;
+            let mut schnorr_proof = None;
+            loop {
+                let results = recv.recv().expect("failed to recv results");
+                for result in results {
+                    match result {
+                        OperationResult::Dkg(point) => {
+                            info!("Received aggregate_group_key {point}");
+                            aggregate_group_key = Some(point);
+                        }
+                        OperationResult::Sign(sig) => {
+                            info!("Received Signature ({},{})", &sig.R, &sig.z);
+                            frost_signature = Some(sig);
+                        }
+                        OperationResult::SignTaproot(proof) => {
+                            info!("Received SchnorrProof ({},{})", &proof.r, &proof.s);
+                            schnorr_proof = Some(proof);
+                        }
+                        OperationResult::DkgError(dkg_error) => {
+                            panic!("Received DkgError {:?}", dkg_error);
+                        }
+                        OperationResult::SignError(sign_error) => {
+                            panic!("Received SignError {}", sign_error);
+                        }
                     }
                 }
-            }
-            if aggregate_group_key.is_some() && frost_signature.is_some() && schnorr_proof.is_some()
-            {
-                break;
+                if aggregate_group_key.is_some()
+                    && frost_signature.is_some()
+                    && schnorr_proof.is_some()
+                {
+                    break;
+                }
             }
         }
         let elapsed = now.elapsed();

From 00221a68d08aae1719982565250b0ea43c234ac5 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Tue, 9 Jan 2024 15:49:23 -0500
Subject: [PATCH 0351/1166] CRC: log the error from process inbound messages

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/runloop.rs | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index c6cd3d9b0d..4aef62a391 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -189,12 +189,18 @@ impl<C: Coordinator> RunLoop<C> {
         let mut outbound_messages = self
             .signing_round
             .process_inbound_messages(&inbound_messages)
-            .unwrap_or_default();
+            .unwrap_or_else(|e| {
+                error!("Failed to process inbound messages as a signer: {e}");
+                vec![]
+            });
         // Next process the message as the coordinator
         let (messages, results) = self
             .coordinator
             .process_inbound_messages(&inbound_messages)
-            .unwrap_or_default();
+            .unwrap_or_else(|e| {
+                error!("Failed to process inbound messages as a coordinator: {e}");
+                (vec![], vec![])
+            });
         outbound_messages.extend(messages);
         (outbound_messages, results)
     }

From d7e9a8088622c06df833c285e5aa07c20fe3aec8 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 10 Jan 2024 10:08:38 -0500
Subject: [PATCH 0352/1166] Remove accidental reduction of signer data
 generation in test_Stackerdb_dkg

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 testnet/stacks-node/src/tests/signer.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index f142fe26ad..bb7f3d6446 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -201,8 +201,8 @@ fn test_stackerdb_dkg() {
         .init();
 
     // Generate Signer Data
-    let num_signers: u32 = 3;
-    let num_keys: u32 = 2;
+    let num_signers: u32 = 10;
+    let num_keys: u32 = 400;
     let publisher_private_key = StacksPrivateKey::new();
     let signer_stacks_private_keys = (0..num_signers)
         .map(|_| StacksPrivateKey::new())

From 298e8e0428da61e8177ff5a16301ea575e841208 Mon Sep 17 00:00:00 2001
From: ASuciuX <asuciu@hiro.so>
Date: Wed, 10 Jan 2024 19:58:13 +0200
Subject: [PATCH 0353/1166] feat: move shell runs from main workflow to
 composite action

---
 .github/workflows/pr-differences-mutants.yml | 251 +------------------
 1 file changed, 4 insertions(+), 247 deletions(-)

diff --git a/.github/workflows/pr-differences-mutants.yml b/.github/workflows/pr-differences-mutants.yml
index d2aed12962..a071f95487 100644
--- a/.github/workflows/pr-differences-mutants.yml
+++ b/.github/workflows/pr-differences-mutants.yml
@@ -29,108 +29,8 @@ jobs:
       small_packages_with_shards: ${{ steps.check_packages_and_shards.outputs.small_packages_with_shards }}
 
     steps:
-      - name: Checkout repo
-        uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-
-      - name: Install cargo-mutants
-        run: cargo install --version 23.12.2 cargo-mutants
-
-      - name: Relative diff
-        run: |
-          git diff origin/${{ github.base_ref }}.. > git.diff
-
-      - name: Update git diff
-        run: |
-          input_file="git.diff"
-          temp_file="temp_diff_file.diff"
-
-          # Check if the commands exist on the host
-          for cmd in tac awk sed; do
-            command -v "${cmd}" > /dev/null 2>&1 || echo "Missing command: ${cmd}"
-          done
-
-          # Reverse the file, remove 4 lines after '+++ /dev/null', then reverse it back (editors can't go backwards - to remove lines above)
-          tac "$input_file" > "$temp_file" && mv "$temp_file" "$input_file"
-          sed '/+++ \/dev\/null/{n;N;N;N;d;}' "$input_file" > "$temp_file" && mv "$temp_file" "$input_file"
-          tac "$input_file" > "$temp_file" && mv "$temp_file" "$input_file"
-
-          # Remove the lines between '+++ /dev/null' (included) and 'diff --git a/'
-          awk '
-            BEGIN { in_block=0 }
-            /\+\+\+ \/dev\/null/ { in_block=1; next }
-            in_block && /diff --git a\// { in_block=0; print; next }
-            !in_block
-          ' "$input_file" > "$temp_file" && mv "$temp_file" "$input_file"
-
-      - name: Split diffs
-        run: |
-          cargo mutants --in-diff git.diff --list > all_mutants.txt
-          mkdir -p mutants_by_packages
-
-          # Check that the file exists before performing actions on it
-          if [ -s all_mutants.txt ]; then
-            echo "The file containing mutants is missing or empty!"
-            exit 1
-          fi
-
-          # Split the differences from git into 2 parts, big packages ('stacks-node' and 'stackslib') and small packages (all others) and put them into separate files
-          while IFS= read -r line; do
-            package=$(echo "$line" | cut -d'/' -f1)
-            if [[ $package == "testnet" || $package == "stackslib" ]]; then
-              echo "$line" >> "mutants_by_packages/big_packages.txt"
-            else
-              echo "$line" >> "mutants_by_packages/small_packages.txt"
-            fi
-          done < all_mutants.txt
-
-      - name: Check packages and shards
-        id: check_packages_and_shards
-        run: |
-          number_of_big_mutants=0
-          number_of_small_mutants=0
-
-          # If big_packages file exists, count how many mutants there are
-          if [[ -s mutants_by_packages/big_packages.txt ]]; then
-            number_of_big_mutants=$(cat mutants_by_packages/big_packages.txt | awk 'END { print NR }' | tr -d '[:space:]')
-          fi
-
-          # If small_packages file exists, count how many mutants there are
-          if [[ -s mutants_by_packages/small_packages.txt ]]; then
-            number_of_small_mutants=$(cat mutants_by_packages/small_packages.txt | awk 'END { print NR }' | tr -d '[:space:]')
-          fi
-
-          # Set the mutants limit for when to run with shards on the small packages
-          if [[ $number_of_big_mutants -gt 15 ]]; then
-            small_packages_shard_limit=119
-          else
-            small_packages_shard_limit=79
-          fi
-
-          # If there are mutants from big packages, check whether to run with or without shards, otherwise there's nothing to run
-          if [[ $number_of_big_mutants -ne 0 ]]; then
-            echo "run_big_packages=true" >> "$GITHUB_OUTPUT"
-            if [[ $number_of_big_mutants -gt 15 ]]; then
-              echo "big_packages_with_shards=true" >> "$GITHUB_OUTPUT"
-            else
-              echo "big_packages_with_shards=false" >> "$GITHUB_OUTPUT"
-            fi
-          else
-            echo "run_big_packages=false" >> "$GITHUB_OUTPUT"
-          fi
-
-          # If there are mutants from small packages, check whether to run with or without shards, otherwise there's nothing to run
-          if [[ $number_of_small_mutants -ne 0 ]]; then
-            echo "run_small_packages=true" >> "$GITHUB_OUTPUT"
-            if [[ $number_of_small_mutants -gt $small_packages_shard_limit ]]; then
-              echo "small_packages_with_shards=true" >> "$GITHUB_OUTPUT"
-            else
-              echo "small_packages_with_shards=false" >> "$GITHUB_OUTPUT"
-            fi
-          else
-            echo "run_small_packages=false" >> "$GITHUB_OUTPUT"
-          fi
+      - id: check_packages_and_shards
+        uses: stacks-network/actions/mutation-testing/check-packages-and-shards@feat/mutation-testing
 
   # Mutation testing - Execute on PR on small packages that have functions modified (normal run, no shards)
   pr-differences-mutants-small-normal:
@@ -230,148 +130,5 @@ jobs:
       ]
 
     steps:
-      - name: Download artifacts
-        uses: actions/download-artifact@v3
-
-      - name: Append output from shards
-        run: |
-          folders=("mutants-shard-big--1" "mutants-shard-big-0" "mutants-shard-big-1" "mutants-shard-big-2" "mutants-shard-big-3" "mutants-shard-big-4" "mutants-shard-big-5" "mutants-shard-big-6" "mutants-shard-big-7" "mutants-shard-small--1" "mutants-shard-small-0" "mutants-shard-small-1" "mutants-shard-small-2" "mutants-shard-small-3")
-          files=("missed.txt" "caught.txt" "timeout.txt" "unviable.txt")
-          mkdir -p mutants-shards
-
-          for file in "${files[@]}"; do
-            for folder in "${folders[@]}"; do
-              if [[ -s "$folder/$file" ]]; then
-                cat "$folder/$file" >> "mutants-shards/$file"
-              fi
-            done
-          done
-
-          for folder in "${folders[@]}"; do
-            if [[ -s "$folder/exit_code.txt" ]]; then
-              exit_code=$(<"${folder}/exit_code.txt")
-              most_relevant_exit_code=0
-
-              case $exit_code in
-              4)
-                most_relevant_exit_code=4
-                ;;
-              1)
-                [ "$most_relevant_exit_code" -eq 0 ] && most_relevant_exit_code=1
-                ;;
-              2)
-                [ "$most_relevant_exit_code" -eq 0 ] && most_relevant_exit_code=2
-                ;;
-              3)
-                [ "$most_relevant_exit_code" -eq 0 ] && most_relevant_exit_code=3
-                ;;
-              0)
-                ;;
-              *)
-                echo "Unknown exit code $exit_code"
-                most_relevant_exit_code=$exit_code
-                ;;
-              esac
-            fi
-          done
-
-          echo "$most_relevant_exit_code" > './mutants-shards/exit_code.txt'
-
-      - name: Print mutants
-        run: |
-          server_url="${{ github.server_url }}"
-          organisation="${{ github.repository_owner }}"
-          repository="${{ github.event.repository.name }}"
-          commit="${{ github.sha }}"
-
-          write_section() {
-            local section_title=$1
-            local file_name=$2
-
-            if [ -s "$file_name" ]; then
-              if [[ "$section_title" != "" ]]; then
-                echo "## $section_title" >> "$GITHUB_STEP_SUMMARY"
-              fi
-
-              if [[ "$section_title" == "Missed:" ]]; then
-                echo "<details>" >> "$GITHUB_STEP_SUMMARY"
-                echo "<summary>What are missed mutants?</summary>" >> "$GITHUB_STEP_SUMMARY"
-                echo "<br>" >> "$GITHUB_STEP_SUMMARY"
-                echo "No test failed with this mutation applied, which seems to indicate a gap in test coverage. Or, it may be that the mutant is undistinguishable from the correct code. You may wish to add a better test, or mark that the function should be skipped." >> "$GITHUB_STEP_SUMMARY"
-                echo "</details>" >> "$GITHUB_STEP_SUMMARY"
-                echo "" >> "$GITHUB_STEP_SUMMARY"
-              elif [[ "$section_title" == "Timeout:" ]]; then
-                echo "<details>" >> "$GITHUB_STEP_SUMMARY"
-                echo "<summary>What are timeout mutants?</summary>" >> "$GITHUB_STEP_SUMMARY"
-                echo "<br>" >> "$GITHUB_STEP_SUMMARY"
-                echo "The mutation caused the test suite to run for a long time, until it was eventually killed. You might want to investigate the cause and potentially mark the function to be skipped." >> "$GITHUB_STEP_SUMMARY"
-                echo "</details>" >> "$GITHUB_STEP_SUMMARY"
-                echo "" >> "$GITHUB_STEP_SUMMARY"
-              elif [[ "$section_title" == "Unviable:" ]]; then
-                echo "<details>" >> "$GITHUB_STEP_SUMMARY"
-                echo "<summary>What are unviable mutants?</summary>" >> "$GITHUB_STEP_SUMMARY"
-                echo "<br>" >> "$GITHUB_STEP_SUMMARY"
-                echo "The attempted mutation doesn't compile. This is inconclusive about test coverage and no action is needed, unless you wish to test the specific function, in which case you may wish to add a 'Default::default()' implementation for the specific return type." >> "$GITHUB_STEP_SUMMARY"
-                echo "</details>" >> "$GITHUB_STEP_SUMMARY"
-                echo "" >> "$GITHUB_STEP_SUMMARY"
-              fi
-
-              if [[ "$section_title" != "" ]]; then
-                awk -F':' '{printf "- [ ] " "[" $0 "]"; file_path=$1; line=$2; $1=""; $2=""; printf "(" "'"$server_url"'/'"$organisation"'/'"$repository"'/blob/'"$commit"'/" file_path "#L" line-1 ")\n\n"}' "$file_name" >> "$GITHUB_STEP_SUMMARY"
-              else
-                awk -F':' '{printf "- [x] " "[" $0 "]"; file_path=$1; line=$2; $1=""; $2=""; printf "(" "'"$server_url"'/'"$organisation"'/'"$repository"'/blob/'"$commit"'/" file_path "#L" line-1 ")\n\n"}' "$file_name" >> "$GITHUB_STEP_SUMMARY"
-              fi
-
-              if [[ "$section_title" == "Missed:" ]]; then
-                echo "### To resolve this issue, consider one of the following options:" >> "$GITHUB_STEP_SUMMARY"
-                echo "- Modify or add tests including this function." >> "$GITHUB_STEP_SUMMARY"
-                echo "- If you are absolutely certain that this function should not undergo mutation testing, add '#[mutants::skip]' or '#[cfg_attr(test, mutants::skip)]' function header to skip it." >> "$GITHUB_STEP_SUMMARY"
-              elif [[ "$section_title" == "Timeout:" ]]; then
-                echo "### To resolve this issue, consider one of the following options:" >> "$GITHUB_STEP_SUMMARY"
-                echo "- Modify the tests that include this funcion." >> "$GITHUB_STEP_SUMMARY"
-                echo "- Add '#[mutants::skip]' or '#[cfg_attr(test, mutants::skip)]' function header to skip it." >> "$GITHUB_STEP_SUMMARY"
-              elif [[ "$section_title" == "Unviable:" ]]; then
-                echo "### To resolve this issue, consider one of the following options:" >> "$GITHUB_STEP_SUMMARY"
-                echo "- Create 'Default::default()' implementation for the specific structure." >> "$GITHUB_STEP_SUMMARY"
-                echo "- Add '#[mutants::skip]' or '#[cfg_attr(test, mutants::skip)]' function header to skip it." >> "$GITHUB_STEP_SUMMARY"
-              fi
-
-              echo >> "$GITHUB_STEP_SUMMARY"
-            fi
-          }
-
-          echo "# Uncaught Mutants" >> "$GITHUB_STEP_SUMMARY"
-          write_section "Missed:" "./mutants-shards/missed.txt"
-          write_section "Timeout:" "./mutants-shards/timeout.txt"
-          write_section "Unviable:" "./mutants-shards/unviable.txt"
-            
-          echo "# Caught Mutants" >> "$GITHUB_STEP_SUMMARY"
-          write_section "" "./mutants-shards/caught.txt"
-
-          exit_code=$(<"mutants-shards/exit_code.txt")
-
-          case $exit_code in
-            0)
-                if [[ -f ./mutants-shards/unviable.txt ]]; then
-                  echo "Found unviable mutants!"
-                  exit 1
-                fi
-              echo "All new and updated functions are caught!"
-              ;;
-            1)
-              echo "Invalid command line arguments!"
-              exit 1
-              ;;
-            2 | 3)
-              echo "Found missed/timeout/unviable mutants!"
-              exit 1
-              ;;
-            4)
-              echo "Building the packages failed without any mutations!"
-              exit 1
-              ;;
-            *)
-              echo "Unknown exit code: $exit_code"
-              exit 1
-            ;;
-          esac
+      - name: Output Mutants
+        uses: stacks-network/actions/mutation-testing/output-pr-mutants@feat/mutation-testing

From 12388b7e75c7bfa277ffdc73998b09c36b02f2b1 Mon Sep 17 00:00:00 2001
From: ASuciuX <asuciu@hiro.so>
Date: Thu, 11 Jan 2024 03:28:17 +0200
Subject: [PATCH 0354/1166] feat: add documentation for mutation testing

---
 docs/ci-release.md | 69 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 69 insertions(+)

diff --git a/docs/ci-release.md b/docs/ci-release.md
index f042b05ed2..d6a3d9bc35 100644
--- a/docs/ci-release.md
+++ b/docs/ci-release.md
@@ -228,4 +228,73 @@ ex: Branch is named `develop` and the PR is numbered `113`
   - `stacks-core:2.1.0.0.0`
   - `stacks-core:latest`
 
+## Mutation Testing
+
+When a new Pull Request (PR) is submitted, this feature evaluates the quality of the tests added or modified in the PR. It checks the new and altered functions through mutation testing. Mutation testing involves making small changes (mutations) to the code to check if the tests can detect these changes. The mutations are run with or without a [Github Actions matrix](https://docs.github.com/en/actions/using-jobs/using-a-matrix-for-your-jobs). The matrix is used when there is a large number of mutations to run.
+
+Since mutation testing is directly correlated to the written tests, there are slower packages (due to the quantity or time it takes to run the tests) like `stackslib` or `stacks-node`. These mutations are run separately from the others, with one or more parallel jobs, depending on the amount of mutations found.
+
+Once all the jobs have finished testing mutants, the last job collects all the tested mutations from the previous jobs, combines them and outputs them to the `Summary` section of the workflow, at the bottom of the page. There, you can find all mutants on categories, with links to the function they tested, and a short description on how to fix the issue. The PR should only be approved/merged after all the mutants tested are in the `Caught` category.
+
+File:
+
+- [PR Differences Mutants](../.github/workflows/pr-differences-mutants.yml)
+
+### Mutant Outcomes
+
+- caught — A test failed with this mutant applied. This is a good sign about test coverage.
+
+- missed — No test failed with this mutation applied, which seems to indicate a gap in test coverage. Or, it may be that the mutant is undistinguishable from the correct code. In any case, you may wish to add a better test.
+
+- unviable — The attempted mutation doesn't compile. This is inconclusive about test coverage, since the function's return structure may not implement `Default::default()` (one of the mutations applied), hence causing the compile to fail. It is recommended to add `Default` implementation for the return structures of these functions, only mark that the function should be skipped as a last resort.
+
+- timeout — The mutation caused the test suite to run for a long time, until it was eventually killed. You might want to investigate the cause and only mark the function to be skipped if necessary.
+
+### Skipping Mutations
+
+Some functions may be inherently hard to cover with tests, for example if:
+
+- Generated mutants cause tests to hang.
+- You've chosen to test the functionality by human inspection or some higher-level integration tests.
+- The function has side effects or performance characteristics that are hard to test.
+- You've decided that the function is not important to test.
+
+To mark functions as skipped, so they are not mutated:
+
+- Add a Cargo dependency of the [mutants](https://crates.io/crates/mutants) crate, version `0.0.3` or later (this must be a regular `dependency`, not a `dev-dependency`, because the annotation will be on non-test code) and mark functions with `#[mutants::skip]`, or
+
+- You can avoid adding the dependency by using the slightly longer `#[cfg_attr(test, mutants::skip)]`.
+
+**Example:**
+
+```rust
+use std::time::{Duration, Instant};
+
+/// Returns true if the program should stop
+#[cfg_attr(test, mutants::skip)] // Returning false would cause a hang
+fn should_stop() -> bool {
+    true
+}
+
+pub fn controlled_loop() {
+    let start = Instant::now();
+    for i in 0.. {
+        println!("{}", i);
+        if should_stop() {
+            break;
+        }
+        if start.elapsed() > Duration::from_secs(60 * 5) {
+            panic!("timed out");
+        }
+    }
+}
+
+mod test {
+    #[test]
+    fn controlled_loop_terminates() {
+        super::controlled_loop()
+    }
+}
+```
+
 ---

From 5a4f9b38d4203f20cbecbdb90ae15785a03f27bd Mon Sep 17 00:00:00 2001
From: ASuciuX <asuciu@hiro.so>
Date: Tue, 16 Jan 2024 18:05:47 +0200
Subject: [PATCH 0355/1166] feat: mutation testing - update composite branch

- add required input fields to the output job
---
 .github/workflows/pr-differences-mutants.yml | 18 ++++++++++++------
 1 file changed, 12 insertions(+), 6 deletions(-)

diff --git a/.github/workflows/pr-differences-mutants.yml b/.github/workflows/pr-differences-mutants.yml
index a071f95487..ebed9fe65e 100644
--- a/.github/workflows/pr-differences-mutants.yml
+++ b/.github/workflows/pr-differences-mutants.yml
@@ -30,7 +30,7 @@ jobs:
 
     steps:
       - id: check_packages_and_shards
-        uses: stacks-network/actions/mutation-testing/check-packages-and-shards@feat/mutation-testing
+        uses: stacks-network/actions/stacks-core/mutation-testing/check-packages-and-shards@main
 
   # Mutation testing - Execute on PR on small packages that have functions modified (normal run, no shards)
   pr-differences-mutants-small-normal:
@@ -44,7 +44,7 @@ jobs:
 
     steps:
       - name: Run mutants on diffs
-        uses: stacks-network/actions/mutation-testing/pr-differences@feat/mutation-testing
+        uses: stacks-network/actions/stacks-core/mutation-testing/pr-differences@main
         with:
           package-dimension: "small"
 
@@ -65,7 +65,7 @@ jobs:
 
     steps:
       - name: Run mutants on diffs
-        uses: stacks-network/actions/mutation-testing/pr-differences@feat/mutation-testing
+        uses: stacks-network/actions/stacks-core/mutation-testing/pr-differences@main
         with:
           shard: ${{ matrix.shard }}
           package-dimension: "small"
@@ -85,7 +85,7 @@ jobs:
         env:
           BITCOIND_TEST: 1
           RUST_BACKTRACE: full
-        uses: stacks-network/actions/mutation-testing/pr-differences@feat/mutation-testing
+        uses: stacks-network/actions/stacks-core/mutation-testing/pr-differences@main
         with:
           package-dimension: "big"
 
@@ -109,7 +109,7 @@ jobs:
         env:
           BITCOIND_TEST: 1
           RUST_BACKTRACE: full
-        uses: stacks-network/actions/mutation-testing/pr-differences@feat/mutation-testing
+        uses: stacks-network/actions/stacks-core/mutation-testing/pr-differences@main
         with:
           shard: ${{ matrix.shard }}
           package-dimension: "big"
@@ -123,6 +123,7 @@ jobs:
     if: always()
     needs:
       [
+        check-big-packages-and-shards,
         pr-differences-mutants-small-normal,
         pr-differences-mutants-small-shards,
         pr-differences-mutants-big-normal,
@@ -131,4 +132,9 @@ jobs:
 
     steps:
       - name: Output Mutants
-        uses: stacks-network/actions/mutation-testing/output-pr-mutants@feat/mutation-testing
+        uses: stacks-network/actions/stacks-core/mutation-testing/output-pr-mutants@main
+        with:
+          big_packages: ${{ needs.check-big-packages-and-shards.outputs.run_big_packages }}
+          shards_for_big_packages: ${{ needs.check-big-packages-and-shards.outputs.big_packages_with_shards }}
+          small_packages: ${{ needs.check-big-packages-and-shards.outputs.run_small_packages }}
+          shards_for_small_packages: ${{ needs.check-big-packages-and-shards.outputs.small_packages_with_shards }}

From fc5b281cb5a4b941cd7e5ae220cfe531417dd1b9 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Tue, 5 Dec 2023 16:40:52 -0500
Subject: [PATCH 0356/1166] Seperate stacks node calls from stacker db specific
 calls

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/mod.rs           |  91 ++++
 stacks-signer/src/client/stackerdb.rs     | 101 ++++
 stacks-signer/src/client/stacks_client.rs | 600 ++++++++++++++++++++++
 stacks-signer/src/lib.rs                  |   4 +-
 stacks-signer/src/runloop.rs              |  14 +-
 stacks-signer/src/utils.rs                |   2 +-
 6 files changed, 804 insertions(+), 8 deletions(-)
 create mode 100644 stacks-signer/src/client/mod.rs
 create mode 100644 stacks-signer/src/client/stackerdb.rs
 create mode 100644 stacks-signer/src/client/stacks_client.rs

diff --git a/stacks-signer/src/client/mod.rs b/stacks-signer/src/client/mod.rs
new file mode 100644
index 0000000000..c90473e64a
--- /dev/null
+++ b/stacks-signer/src/client/mod.rs
@@ -0,0 +1,91 @@
+/// The stacker db module for communicating with the stackerdb contract
+mod stackerdb;
+/// The stacks node client module for communicating with the stacks node
+mod stacks_client;
+
+use std::time::Duration;
+
+use clarity::vm::types::serialization::SerializationError;
+use clarity::vm::Value as ClarityValue;
+use libsigner::RPCError;
+use libstackerdb::Error as StackerDBError;
+use slog::slog_debug;
+pub use stackerdb::*;
+pub use stacks_client::*;
+use stacks_common::debug;
+
+/// Backoff timer initial interval in milliseconds
+const BACKOFF_INITIAL_INTERVAL: u64 = 128;
+/// Backoff timer max interval in milliseconds
+const BACKOFF_MAX_INTERVAL: u64 = 16384;
+
+/// Temporary placeholder for the number of slots allocated to a stacker-db writer. This will be retrieved from the stacker-db instance in the future
+/// See: https://github.com/stacks-network/stacks-blockchain/issues/3921
+/// Is equal to the number of message types
+pub const SIGNER_SLOTS_PER_USER: u32 = 10;
+/// The number of miner slots available per miner
+pub const MINER_SLOTS_PER_USER: u32 = 1;
+
+#[derive(thiserror::Error, Debug)]
+/// Client error type
+pub enum ClientError {
+    /// An error occurred serializing the message
+    #[error("Unable to serialize stacker-db message: {0}")]
+    StackerDBSerializationError(#[from] bincode::Error),
+    /// Failed to sign stacker-db chunk
+    #[error("Failed to sign stacker-db chunk: {0}")]
+    FailToSign(#[from] StackerDBError),
+    /// Failed to write to stacker-db due to RPC error
+    #[error("Failed to write to stacker-db instance: {0}")]
+    PutChunkFailed(#[from] RPCError),
+    /// Stacker-db instance rejected the chunk
+    #[error("Stacker-db rejected the chunk. Reason: {0}")]
+    PutChunkRejected(String),
+    /// Failed to find a given json entry
+    #[error("Invalid JSON entry: {0}")]
+    InvalidJsonEntry(String),
+    /// Failed to call a read only function
+    #[error("Failed to call read only function. {0}")]
+    ReadOnlyFailure(String),
+    /// Reqwest specific error occurred
+    #[error("{0}")]
+    ReqwestError(#[from] reqwest::Error),
+    /// Failed to build and sign a new Stacks transaction.
+    #[error("Failed to generate transaction from a transaction signer: {0}")]
+    TransactionGenerationFailure(String),
+    /// Stacks node client request failed
+    #[error("Stacks node client request failed: {0}")]
+    RequestFailure(reqwest::StatusCode),
+    /// Failed to serialize a Clarity value
+    #[error("Failed to serialize Clarity value: {0}")]
+    ClaritySerializationError(#[from] SerializationError),
+    /// Failed to parse a Clarity value
+    #[error("Recieved a malformed clarity value: {0}")]
+    MalformedClarityValue(ClarityValue),
+    /// Invalid Clarity Name
+    #[error("Invalid Clarity Name: {0}")]
+    InvalidClarityName(String),
+    /// Backoff retry timeout
+    #[error("Backoff retry timeout occurred. Stacks node may be down.")]
+    RetryTimeout,
+}
+
+/// Retry a function F with an exponential backoff and notification on transient failure
+pub fn retry_with_exponential_backoff<F, E, T>(request_fn: F) -> Result<T, ClientError>
+where
+    F: FnMut() -> Result<T, backoff::Error<E>>,
+{
+    let notify = |_err, dur| {
+        debug!(
+            "Failed to connect to stacks-node. Next attempt in {:?}",
+            dur
+        );
+    };
+
+    let backoff_timer = backoff::ExponentialBackoffBuilder::new()
+        .with_initial_interval(Duration::from_millis(BACKOFF_INITIAL_INTERVAL))
+        .with_max_interval(Duration::from_millis(BACKOFF_MAX_INTERVAL))
+        .build();
+
+    backoff::retry_notify(backoff_timer, request_fn, notify).map_err(|_| ClientError::RetryTimeout)
+}
diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
new file mode 100644
index 0000000000..df7e413186
--- /dev/null
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -0,0 +1,101 @@
+use hashbrown::HashMap;
+use libsigner::{SignerSession, StackerDBSession};
+use libstackerdb::{StackerDBChunkAckData, StackerDBChunkData};
+use slog::{slog_debug, slog_warn};
+use stacks_common::types::chainstate::StacksPrivateKey;
+use stacks_common::{debug, warn};
+use wsts::net::{Message, Packet};
+
+use super::ClientError;
+use crate::client::retry_with_exponential_backoff;
+use crate::config::Config;
+
+/// Temporary placeholder for the number of slots allocated to a stacker-db writer. This will be retrieved from the stacker-db instance in the future
+/// See: https://github.com/stacks-network/stacks-blockchain/issues/3921
+/// Is equal to the number of message types
+pub const SLOTS_PER_USER: u32 = 10;
+
+/// The StackerDB client for communicating with both .signers and .miners contracts
+pub struct StackerDB {
+    /// The stacker-db session for the signer StackerDB
+    signers_stackerdb_session: StackerDBSession,
+    /// The private key used in all stacks node communications
+    stacks_private_key: StacksPrivateKey,
+    /// A map of a slot ID to last chunk version
+    slot_versions: HashMap<u32, u32>,
+}
+
+impl From<&Config> for StackerDB {
+    fn from(config: &Config) -> Self {
+        Self {
+            signers_stackerdb_session: StackerDBSession::new(
+                config.node_host,
+                config.stackerdb_contract_id.clone(),
+            ),
+            stacks_private_key: config.stacks_private_key,
+            slot_versions: HashMap::new(),
+        }
+    }
+}
+
+impl StackerDB {
+    /// Sends messages to the stacker-db with an exponential backoff retry
+    pub fn send_message_with_retry(
+        &mut self,
+        id: u32,
+        message: Packet,
+    ) -> Result<StackerDBChunkAckData, ClientError> {
+        let message_bytes = bincode::serialize(&message)?;
+        let slot_id = slot_id(id, &message.msg);
+
+        loop {
+            let slot_version = *self.slot_versions.entry(slot_id).or_insert(0) + 1;
+            let mut chunk = StackerDBChunkData::new(slot_id, slot_version, message_bytes.clone());
+            chunk.sign(&self.stacks_private_key)?;
+            debug!("Sending a chunk to stackerdb!\n{:?}", chunk.clone());
+            let send_request = || {
+                self.signers_stackerdb_session
+                    .put_chunk(chunk.clone())
+                    .map_err(backoff::Error::transient)
+            };
+            let chunk_ack: StackerDBChunkAckData = retry_with_exponential_backoff(send_request)?;
+            self.slot_versions.insert(slot_id, slot_version);
+
+            if chunk_ack.accepted {
+                debug!("Chunk accepted by stackerdb: {:?}", chunk_ack);
+                return Ok(chunk_ack);
+            } else {
+                warn!("Chunk rejected by stackerdb: {:?}", chunk_ack);
+            }
+            if let Some(reason) = chunk_ack.reason {
+                // TODO: fix this jankiness. Update stackerdb to use an error code mapping instead of just a string
+                // See: https://github.com/stacks-network/stacks-blockchain/issues/3917
+                if reason == "Data for this slot and version already exist" {
+                    warn!("Failed to send message to stackerdb due to wrong version number {}. Incrementing and retrying...", slot_version);
+                } else {
+                    warn!("Failed to send message to stackerdb: {}", reason);
+                    return Err(ClientError::PutChunkRejected(reason));
+                }
+            }
+        }
+    }
+}
+
+/// Helper function to determine the slot ID for the provided stacker-db writer id and the message type
+fn slot_id(id: u32, message: &Message) -> u32 {
+    let slot_id = match message {
+        Message::DkgBegin(_) => 0,
+        Message::DkgPrivateBegin(_) => 1,
+        Message::DkgEnd(_) => 2,
+        Message::DkgPublicShares(_) => 4,
+        Message::DkgPrivateShares(_) => 5,
+        Message::NonceRequest(_) => 6,
+        Message::NonceResponse(_) => 7,
+        Message::SignatureShareRequest(_) => 8,
+        Message::SignatureShareResponse(_) => 9,
+    };
+    SLOTS_PER_USER * id + slot_id
+}
+
+#[cfg(test)]
+mod tests {}
diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
new file mode 100644
index 0000000000..e1fbbb61cd
--- /dev/null
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -0,0 +1,600 @@
+use blockstack_lib::burnchains::Txid;
+use blockstack_lib::chainstate::stacks::{
+    StacksTransaction, StacksTransactionSigner, TransactionAnchorMode, TransactionAuth,
+    TransactionContractCall, TransactionPayload, TransactionPostConditionMode,
+    TransactionSpendingCondition, TransactionVersion,
+};
+use clarity::vm::types::{QualifiedContractIdentifier, SequenceData};
+use clarity::vm::{ClarityName, ContractName, Value as ClarityValue};
+use serde_json::json;
+use slog::slog_debug;
+use stacks_common::codec::StacksMessageCodec;
+use stacks_common::debug;
+use stacks_common::types::chainstate::{StacksAddress, StacksPrivateKey, StacksPublicKey};
+use wsts::curve::point::Point;
+use wsts::curve::scalar::Scalar;
+
+use crate::client::{retry_with_exponential_backoff, ClientError};
+use crate::config::Config;
+
+/// The Stacks signer client used to communicate with the stacks node
+pub struct StacksClient {
+    /// The stacks address of the signer
+    stacks_address: StacksAddress,
+    /// The private key used in all stacks node communications
+    stacks_private_key: StacksPrivateKey,
+    /// The stacks node HTTP base endpoint
+    http_origin: String,
+    /// The types of transactions
+    tx_version: TransactionVersion,
+    /// The chain we are interacting with
+    chain_id: u32,
+    /// The Client used to make HTTP connects
+    stacks_node_client: reqwest::blocking::Client,
+    /// The pox contract ID
+    pox_contract_id: Option<QualifiedContractIdentifier>,
+}
+
+impl From<&Config> for StacksClient {
+    fn from(config: &Config) -> Self {
+        Self {
+            stacks_private_key: config.stacks_private_key,
+            stacks_address: config.stacks_address,
+            http_origin: format!("http://{}", config.node_host),
+            tx_version: config.network.to_transaction_version(),
+            chain_id: config.network.to_chain_id(),
+            stacks_node_client: reqwest::blocking::Client::new(),
+            pox_contract_id: config.pox_contract_id.clone(),
+        }
+    }
+}
+
+impl StacksClient {
+    /// Retrieve the current DKG aggregate public key
+    pub fn get_aggregate_public_key(&self) -> Result<Option<Point>, ClientError> {
+        let reward_cycle = self.get_current_reward_cycle()?;
+        let function_name_str = "get-aggregate-public-key"; // FIXME: this may need to be modified to match .pox-4
+        let function_name = ClarityName::try_from(function_name_str)
+            .map_err(|_| ClientError::InvalidClarityName(function_name_str.to_string()))?;
+        let (contract_addr, contract_name) = self.get_pox_contract()?;
+        let function_args = &[ClarityValue::UInt(reward_cycle as u128)];
+        let contract_response_hex = self.read_only_contract_call_with_retry(
+            &contract_addr,
+            &contract_name,
+            &function_name,
+            function_args,
+        )?;
+        self.parse_aggregate_public_key(&contract_response_hex)
+    }
+
+    /// Helper function to retrieve the current reward cycle number from the stacks node
+    fn get_current_reward_cycle(&self) -> Result<u64, ClientError> {
+        let send_request = || {
+            self.stacks_node_client
+                .get(self.pox_path())
+                .send()
+                .map_err(backoff::Error::transient)
+        };
+        let response = retry_with_exponential_backoff(send_request)?;
+        if !response.status().is_success() {
+            return Err(ClientError::RequestFailure(response.status()));
+        }
+        let json_response = response.json::<serde_json::Value>()?;
+        let entry = "current_cycle";
+        json_response
+            .get(entry)
+            .and_then(|cycle: &serde_json::Value| cycle.get("id"))
+            .and_then(|id| id.as_u64())
+            .ok_or_else(|| ClientError::InvalidJsonEntry(format!("{}.id", entry)))
+    }
+
+    /// Helper function to retrieve the next possible nonce for the signer from the stacks node
+    #[allow(dead_code)]
+    fn get_next_possible_nonce(&self) -> Result<u64, ClientError> {
+        //FIXME: use updated RPC call to get mempool nonces. Depends on https://github.com/stacks-network/stacks-blockchain/issues/4000
+        todo!("Get the next possible nonce from the stacks node");
+    }
+
+    /// Helper function to retrieve the pox contract address and name from the stacks node
+    fn get_pox_contract(&self) -> Result<(StacksAddress, ContractName), ClientError> {
+        // Check if we have overwritten the pox contract ID in the config
+        if let Some(pox_contract) = self.pox_contract_id.clone() {
+            return Ok((pox_contract.issuer.into(), pox_contract.name));
+        }
+        // TODO: we may want to cache the pox contract inside the client itself (calling this function once on init)
+        // https://github.com/stacks-network/stacks-blockchain/issues/4005
+        let send_request = || {
+            self.stacks_node_client
+                .get(self.pox_path())
+                .send()
+                .map_err(backoff::Error::transient)
+        };
+        let response = retry_with_exponential_backoff(send_request)?;
+        if !response.status().is_success() {
+            return Err(ClientError::RequestFailure(response.status()));
+        }
+        let json_response = response.json::<serde_json::Value>()?;
+        let entry = "contract_id";
+        let contract_id_string = json_response
+            .get(entry)
+            .and_then(|id: &serde_json::Value| id.as_str())
+            .ok_or_else(|| ClientError::InvalidJsonEntry(entry.to_string()))?;
+        let id = QualifiedContractIdentifier::parse(contract_id_string).unwrap();
+        Ok((id.issuer.into(), id.name))
+    }
+
+    /// Helper function that attempts to deserialize a clarity hex string as the aggregate public key
+    fn parse_aggregate_public_key(&self, hex: &str) -> Result<Option<Point>, ClientError> {
+        let public_key_clarity_value = ClarityValue::try_deserialize_hex_untyped(hex)?;
+        if let ClarityValue::Optional(optional_data) = public_key_clarity_value.clone() {
+            if let Some(ClarityValue::Sequence(SequenceData::Buffer(public_key))) =
+                optional_data.data.map(|boxed| *boxed)
+            {
+                if public_key.data.len() != 32 {
+                    return Err(ClientError::MalformedClarityValue(public_key_clarity_value));
+                }
+                let mut bytes = [0_u8; 32];
+                bytes.copy_from_slice(&public_key.data);
+                Ok(Some(Point::from(Scalar::from(bytes))))
+            } else {
+                Ok(None)
+            }
+        } else {
+            Err(ClientError::MalformedClarityValue(public_key_clarity_value))
+        }
+    }
+
+    /// Sends a transaction to the stacks node for a modifying contract call
+    #[allow(dead_code)]
+    fn transaction_contract_call(
+        &self,
+        contract_addr: &StacksAddress,
+        contract_name: ContractName,
+        function_name: ClarityName,
+        function_args: &[ClarityValue],
+    ) -> Result<Txid, ClientError> {
+        debug!("Making a contract call to {contract_addr}.{contract_name}...");
+        let signed_tx = self.build_signed_transaction(
+            contract_addr,
+            contract_name,
+            function_name,
+            function_args,
+        )?;
+        self.submit_tx(&signed_tx)
+    }
+
+    /// Helper function to create a stacks transaction for a modifying contract call
+    fn build_signed_transaction(
+        &self,
+        contract_addr: &StacksAddress,
+        contract_name: ContractName,
+        function_name: ClarityName,
+        function_args: &[ClarityValue],
+    ) -> Result<StacksTransaction, ClientError> {
+        let tx_payload = TransactionPayload::ContractCall(TransactionContractCall {
+            address: *contract_addr,
+            contract_name,
+            function_name,
+            function_args: function_args.to_vec(),
+        });
+        let public_key = StacksPublicKey::from_private(&self.stacks_private_key);
+        let tx_auth = TransactionAuth::Standard(
+            TransactionSpendingCondition::new_singlesig_p2pkh(public_key).ok_or(
+                ClientError::TransactionGenerationFailure(format!(
+                    "Failed to create spending condition from public key: {}",
+                    public_key.to_hex()
+                )),
+            )?,
+        );
+
+        let mut unsigned_tx = StacksTransaction::new(self.tx_version, tx_auth, tx_payload);
+
+        // FIXME: Because signers are given priority, we can put down a tx fee of 0
+        // https://github.com/stacks-network/stacks-blockchain/issues/4006
+        // Note: if set to 0 now, will cause a failure (MemPoolRejection::FeeTooLow)
+        unsigned_tx.set_tx_fee(10_000);
+        unsigned_tx.set_origin_nonce(self.get_next_possible_nonce()?);
+
+        unsigned_tx.anchor_mode = TransactionAnchorMode::Any;
+        unsigned_tx.post_condition_mode = TransactionPostConditionMode::Allow;
+        unsigned_tx.chain_id = self.chain_id;
+
+        let mut tx_signer = StacksTransactionSigner::new(&unsigned_tx);
+        tx_signer
+            .sign_origin(&self.stacks_private_key)
+            .map_err(|e| ClientError::TransactionGenerationFailure(e.to_string()))?;
+
+        tx_signer
+            .get_tx()
+            .ok_or(ClientError::TransactionGenerationFailure(
+                "Failed to generate transaction from a transaction signer".to_string(),
+            ))
+    }
+
+    /// Helper function to submit a transaction to the Stacks node
+    fn submit_tx(&self, tx: &StacksTransaction) -> Result<Txid, ClientError> {
+        let txid = tx.txid();
+        let tx = tx.serialize_to_vec();
+        let send_request = || {
+            self.stacks_node_client
+                .post(self.transaction_path())
+                .header("Content-Type", "application/octet-stream")
+                .body(tx.clone())
+                .send()
+                .map_err(backoff::Error::transient)
+        };
+        let response = retry_with_exponential_backoff(send_request)?;
+        if !response.status().is_success() {
+            return Err(ClientError::RequestFailure(response.status()));
+        }
+        Ok(txid)
+    }
+
+    /// Makes a read only contract call to a stacks contract
+    pub fn read_only_contract_call_with_retry(
+        &self,
+        contract_addr: &StacksAddress,
+        contract_name: &ContractName,
+        function_name: &ClarityName,
+        function_args: &[ClarityValue],
+    ) -> Result<String, ClientError> {
+        debug!("Calling read-only function {}...", function_name);
+        let args = function_args
+            .iter()
+            .map(|arg| arg.serialize_to_hex())
+            .collect::<Vec<String>>();
+        let body =
+            json!({"sender": self.stacks_address.to_string(), "arguments": args}).to_string();
+        let path = self.read_only_path(contract_addr, contract_name, function_name);
+        let send_request = || {
+            self.stacks_node_client
+                .post(path.clone())
+                .header("Content-Type", "application/json")
+                .body(body.clone())
+                .send()
+                .map_err(backoff::Error::transient)
+        };
+        let response = retry_with_exponential_backoff(send_request)?;
+        if !response.status().is_success() {
+            return Err(ClientError::RequestFailure(response.status()));
+        }
+        let response = response.json::<serde_json::Value>()?;
+        if !response
+            .get("okay")
+            .map(|val| val.as_bool().unwrap_or(false))
+            .unwrap_or(false)
+        {
+            let cause = response
+                .get("cause")
+                .ok_or(ClientError::InvalidJsonEntry("cause".to_string()))?;
+            return Err(ClientError::ReadOnlyFailure(format!(
+                "{}: {}",
+                function_name, cause
+            )));
+        }
+        let result = response
+            .get("result")
+            .ok_or(ClientError::InvalidJsonEntry("result".to_string()))?
+            .as_str()
+            .ok_or_else(|| ClientError::ReadOnlyFailure("Expected string result.".to_string()))?
+            .to_string();
+        Ok(result)
+    }
+
+    fn pox_path(&self) -> String {
+        format!("{}/v2/pox", self.http_origin)
+    }
+
+    fn transaction_path(&self) -> String {
+        format!("{}/v2/transactions", self.http_origin)
+    }
+
+    fn read_only_path(
+        &self,
+        contract_addr: &StacksAddress,
+        contract_name: &ContractName,
+        function_name: &ClarityName,
+    ) -> String {
+        format!(
+            "{}/v2/contracts/call-read/{contract_addr}/{contract_name}/{function_name}",
+            self.http_origin
+        )
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::io::{BufWriter, Read, Write};
+    use std::net::{SocketAddr, TcpListener};
+    use std::thread::spawn;
+
+    use super::*;
+    use crate::client::ClientError;
+
+    struct TestConfig {
+        mock_server: TcpListener,
+        client: StacksClient,
+    }
+
+    impl TestConfig {
+        pub fn new() -> Self {
+            let mut config = Config::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
+
+            let mut mock_server_addr = SocketAddr::from(([127, 0, 0, 1], 0));
+            // Ask the OS to assign a random port to listen on by passing 0
+            let mock_server = TcpListener::bind(mock_server_addr).unwrap();
+
+            // Update the config to use this port
+            mock_server_addr.set_port(mock_server.local_addr().unwrap().port());
+            config.node_host = mock_server_addr;
+
+            let client = StacksClient::from(&config);
+            Self {
+                mock_server,
+                client,
+            }
+        }
+    }
+
+    fn write_response(mock_server: TcpListener, bytes: &[u8]) -> [u8; 1024] {
+        debug!("Writing a response...");
+        let mut request_bytes = [0u8; 1024];
+        {
+            let mut stream = mock_server.accept().unwrap().0;
+            let _ = stream.read(&mut request_bytes).unwrap();
+            stream.write_all(bytes).unwrap();
+        }
+        request_bytes
+    }
+
+    #[test]
+    fn read_only_contract_call_200_success() {
+        let config = TestConfig::new();
+        let h = spawn(move || {
+            config.client.read_only_contract_call_with_retry(
+                &config.client.stacks_address,
+                &ContractName::try_from("contract-name").unwrap(),
+                &ClarityName::try_from("function-name").unwrap(),
+                &[],
+            )
+        });
+        write_response(
+            config.mock_server,
+            b"HTTP/1.1 200 OK\n\n{\"okay\":true,\"result\":\"0x070d0000000473425443\"}",
+        );
+        let result = h.join().unwrap().unwrap();
+        assert_eq!(result, "0x070d0000000473425443");
+    }
+
+    #[test]
+    fn read_only_contract_call_with_function_args_200_success() {
+        let config = TestConfig::new();
+        let h = spawn(move || {
+            config.client.read_only_contract_call_with_retry(
+                &config.client.stacks_address,
+                &ContractName::try_from("contract-name").unwrap(),
+                &ClarityName::try_from("function-name").unwrap(),
+                &[ClarityValue::UInt(10_u128)],
+            )
+        });
+        write_response(
+            config.mock_server,
+            b"HTTP/1.1 200 OK\n\n{\"okay\":true,\"result\":\"0x070d0000000473425443\"}",
+        );
+        let result = h.join().unwrap().unwrap();
+        assert_eq!(result, "0x070d0000000473425443");
+    }
+
+    #[test]
+    fn read_only_contract_call_200_failure() {
+        let config = TestConfig::new();
+        let h = spawn(move || {
+            config.client.read_only_contract_call_with_retry(
+                &config.client.stacks_address,
+                &ContractName::try_from("contract-name").unwrap(),
+                &ClarityName::try_from("function-name").unwrap(),
+                &[],
+            )
+        });
+        write_response(
+            config.mock_server,
+            b"HTTP/1.1 200 OK\n\n{\"okay\":false,\"cause\":\"Some reason\"}",
+        );
+        let result = h.join().unwrap();
+        assert!(matches!(result, Err(ClientError::ReadOnlyFailure(_))));
+    }
+
+    #[test]
+    fn read_only_contract_call_400_failure() {
+        let config = TestConfig::new();
+        // Simulate a 400 Bad Request response
+        let h = spawn(move || {
+            config.client.read_only_contract_call_with_retry(
+                &config.client.stacks_address,
+                &ContractName::try_from("contract-name").unwrap(),
+                &ClarityName::try_from("function-name").unwrap(),
+                &[],
+            )
+        });
+        write_response(config.mock_server, b"HTTP/1.1 400 Bad Request\n\n");
+        let result = h.join().unwrap();
+        assert!(matches!(
+            result,
+            Err(ClientError::RequestFailure(
+                reqwest::StatusCode::BAD_REQUEST
+            ))
+        ));
+    }
+
+    #[test]
+    fn read_only_contract_call_404_failure() {
+        let config = TestConfig::new();
+        // Simulate a 400 Bad Request response
+        let h = spawn(move || {
+            config.client.read_only_contract_call_with_retry(
+                &config.client.stacks_address,
+                &ContractName::try_from("contract-name").unwrap(),
+                &ClarityName::try_from("function-name").unwrap(),
+                &[],
+            )
+        });
+        write_response(config.mock_server, b"HTTP/1.1 404 Not Found\n\n");
+        let result = h.join().unwrap();
+        assert!(matches!(
+            result,
+            Err(ClientError::RequestFailure(reqwest::StatusCode::NOT_FOUND))
+        ));
+    }
+
+    #[test]
+    fn pox_contract_success() {
+        let config = TestConfig::new();
+        let h = spawn(move || config.client.get_pox_contract());
+        write_response(
+            config.mock_server,
+            b"HTTP/1.1 200 Ok\n\n{\"contract_id\":\"ST000000000000000000002AMW42H.pox-3\"}",
+        );
+        let (address, name) = h.join().unwrap().unwrap();
+        assert_eq!(
+            (address.to_string().as_str(), name.to_string().as_str()),
+            ("ST000000000000000000002AMW42H", "pox-3")
+        );
+    }
+
+    #[test]
+    fn valid_reward_cycle_should_succeed() {
+        let config = TestConfig::new();
+        let h = spawn(move || config.client.get_current_reward_cycle());
+        write_response(
+            config.mock_server,
+            b"HTTP/1.1 200 Ok\n\n{\"current_cycle\":{\"id\":506,\"min_threshold_ustx\":5190000000000,\"stacked_ustx\":5690000000000,\"is_pox_active\":false}}",
+        );
+        let current_cycle_id = h.join().unwrap().unwrap();
+        assert_eq!(506, current_cycle_id);
+    }
+
+    #[test]
+    fn invalid_reward_cycle_should_fail() {
+        let config = TestConfig::new();
+        let h = spawn(move || config.client.get_current_reward_cycle());
+        write_response(
+            config.mock_server,
+            b"HTTP/1.1 200 Ok\n\n{\"current_cycle\":{\"id\":\"fake id\", \"is_pox_active\":false}}",
+        );
+        let res = h.join().unwrap();
+        assert!(matches!(res, Err(ClientError::InvalidJsonEntry(_))));
+    }
+
+    #[test]
+    fn missing_reward_cycle_should_fail() {
+        let config = TestConfig::new();
+        let h = spawn(move || config.client.get_current_reward_cycle());
+        write_response(
+            config.mock_server,
+            b"HTTP/1.1 200 Ok\n\n{\"current_cycle\":{\"is_pox_active\":false}}",
+        );
+        let res = h.join().unwrap();
+        assert!(matches!(res, Err(ClientError::InvalidJsonEntry(_))));
+    }
+
+    #[test]
+    fn parse_valid_aggregate_public_key_should_succeed() {
+        let config = TestConfig::new();
+        let clarity_value_hex =
+            "0x0a0200000020b8c8b0652cb2851a52374c7acd47181eb031e8fa5c62883f636e0d4fe695d6ca";
+        let result = config
+            .client
+            .parse_aggregate_public_key(clarity_value_hex)
+            .unwrap();
+        assert_eq!(
+            result.map(|point| point.to_string()),
+            Some("yzwdjwPz36Has1MSkg8JGwo38avvATkiTZvRiH1e5MLd".to_string())
+        );
+
+        let clarity_value_hex = "0x09";
+        let result = config
+            .client
+            .parse_aggregate_public_key(clarity_value_hex)
+            .unwrap();
+        assert!(result.is_none());
+    }
+
+    #[test]
+    fn parse_invalid_aggregate_public_key_should_fail() {
+        let config = TestConfig::new();
+        let clarity_value_hex = "0x00";
+        let result = config.client.parse_aggregate_public_key(clarity_value_hex);
+        assert!(matches!(
+            result,
+            Err(ClientError::ClaritySerializationError(..))
+        ));
+        // TODO: add further tests for malformed clarity values (an optional of any other type for example)
+    }
+
+    #[ignore]
+    #[test]
+    fn transaction_contract_call_should_send_bytes_to_node() {
+        let config = TestConfig::new();
+        let tx = config
+            .client
+            .build_signed_transaction(
+                &config.client.stacks_address,
+                ContractName::try_from("contract-name").unwrap(),
+                ClarityName::try_from("function-name").unwrap(),
+                &[],
+            )
+            .unwrap();
+
+        let mut tx_bytes = [0u8; 1024];
+        {
+            let mut tx_bytes_writer = BufWriter::new(&mut tx_bytes[..]);
+            tx.consensus_serialize(&mut tx_bytes_writer).unwrap();
+            tx_bytes_writer.flush().unwrap();
+        }
+
+        let bytes_len = tx_bytes
+            .iter()
+            .enumerate()
+            .rev()
+            .find(|(_, &x)| x != 0)
+            .unwrap()
+            .0
+            + 1;
+
+        let tx_clone = tx.clone();
+        let h = spawn(move || config.client.submit_tx(&tx_clone));
+
+        let request_bytes = write_response(
+            config.mock_server,
+            format!("HTTP/1.1 200 OK\n\n{}", tx.txid()).as_bytes(),
+        );
+        let returned_txid = h.join().unwrap().unwrap();
+
+        assert_eq!(returned_txid, tx.txid());
+        assert!(
+            request_bytes
+                .windows(bytes_len)
+                .any(|window| window == &tx_bytes[..bytes_len]),
+            "Request bytes did not contain the transaction bytes"
+        );
+    }
+
+    #[ignore]
+    #[test]
+    fn transaction_contract_call_should_succeed() {
+        let config = TestConfig::new();
+        let h = spawn(move || {
+            config.client.transaction_contract_call(
+                &config.client.stacks_address,
+                ContractName::try_from("contract-name").unwrap(),
+                ClarityName::try_from("function-name").unwrap(),
+                &[],
+            )
+        });
+        write_response(
+            config.mock_server,
+            b"HTTP/1.1 200 OK\n\n4e99f99bc4a05437abb8c7d0c306618f45b203196498e2ebe287f10497124958",
+        );
+        assert!(h.join().unwrap().is_ok());
+    }
+}
diff --git a/stacks-signer/src/lib.rs b/stacks-signer/src/lib.rs
index 2a14245b6c..e5b8350f5b 100644
--- a/stacks-signer/src/lib.rs
+++ b/stacks-signer/src/lib.rs
@@ -5,11 +5,11 @@ Usage documentation can be found in the [README](https://github.com/Trust-Machin
 */
 /// The cli module for the signer binary
 pub mod cli;
+/// The signer client for communicating with stackerdb/stacks nodes
+pub mod client;
 /// The configuration module for the signer
 pub mod config;
 /// The primary runloop for the signer
 pub mod runloop;
-/// The signer client for communicating with stackerdb/stacks nodes
-pub mod stacks_client;
 /// Util functions
 pub mod utils;
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 4aef62a391..7337546a07 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -15,8 +15,8 @@ use wsts::state_machine::signer::Signer;
 use wsts::state_machine::{OperationResult, PublicKeys};
 use wsts::v2;
 
+use crate::client::{retry_with_exponential_backoff, ClientError, StackerDB, StacksClient};
 use crate::config::Config;
-use crate::stacks_client::{retry_with_exponential_backoff, ClientError, StacksClient};
 
 /// Which operation to perform
 #[derive(PartialEq, Clone)]
@@ -58,8 +58,10 @@ pub struct RunLoop<C> {
     // TODO: update this to use frost_signer directly instead of the frost signing round
     // See: https://github.com/stacks-network/stacks-blockchain/issues/3913
     pub signing_round: Signer<v2::Signer>,
-    /// The stacks client
+    /// The stacks node client
     pub stacks_client: StacksClient,
+    /// The stacker db client
+    pub stackerdb: StackerDB,
     /// Received Commands that need to be processed
     pub commands: VecDeque<RunLoopCommand>,
     /// The current state
@@ -96,7 +98,7 @@ impl<C: Coordinator> RunLoop<C> {
                 match self.coordinator.start_dkg_round() {
                     Ok(msg) => {
                         let ack = self
-                            .stacks_client
+                            .stackerdb
                             .send_message_with_retry(self.signing_round.signer_id, msg);
                         debug!("ACK: {:?}", ack);
                         self.state = State::Dkg;
@@ -122,7 +124,7 @@ impl<C: Coordinator> RunLoop<C> {
                 {
                     Ok(msg) => {
                         let ack = self
-                            .stacks_client
+                            .stackerdb
                             .send_message_with_retry(self.signing_round.signer_id, msg);
                         debug!("ACK: {:?}", ack);
                         self.state = State::Sign;
@@ -266,11 +268,13 @@ impl From<&Config> for RunLoop<FireCoordinator<v2::Aggregator>> {
             config.signer_ids_public_keys.clone(),
         );
         let stacks_client = StacksClient::from(config);
+        let stackerdb = StackerDB::from(config);
         RunLoop {
             event_timeout: config.event_timeout,
             coordinator,
             signing_round,
             stacks_client,
+            stackerdb,
             commands: VecDeque::new(),
             state: State::Uninitialized,
         }
@@ -313,7 +317,7 @@ impl<C: Coordinator> SignerRunLoop<Vec<OperationResult>, RunLoopCommand> for Run
             );
             for msg in outbound_messages {
                 let ack = self
-                    .stacks_client
+                    .stackerdb
                     .send_message_with_retry(self.signing_round.signer_id, msg);
                 if let Ok(ack) = ack {
                     debug!("ACK: {:?}", ack);
diff --git a/stacks-signer/src/utils.rs b/stacks-signer/src/utils.rs
index 5664fd7076..585ad73ceb 100644
--- a/stacks-signer/src/utils.rs
+++ b/stacks-signer/src/utils.rs
@@ -7,7 +7,7 @@ use stacks_common::types::chainstate::{StacksAddress, StacksPrivateKey};
 use wsts::curve::ecdsa;
 use wsts::curve::scalar::Scalar;
 
-use crate::stacks_client::SLOTS_PER_USER;
+use crate::client::SLOTS_PER_USER;
 
 /// Helper function for building a signer config for each provided signer private key
 pub fn build_signer_config_tomls(

From 2a5ce7fcdfb5f1cbee3a38d4e95ddd7043ecccc0 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Tue, 5 Dec 2023 16:53:20 -0500
Subject: [PATCH 0357/1166] Add miners stackerdb and update cli

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/cli.rs                   | 23 +++++---
 stacks-signer/src/client/mod.rs            |  7 ---
 stacks-signer/src/client/stackerdb.rs      | 14 +++--
 stacks-signer/src/config.rs                | 43 ++++++++++-----
 stacks-signer/src/main.rs                  | 48 +++++++++--------
 stacks-signer/src/tests/conf/signer-0.toml |  3 +-
 stacks-signer/src/tests/conf/signer-1.toml |  3 +-
 stacks-signer/src/tests/conf/signer-2.toml |  3 +-
 stacks-signer/src/tests/conf/signer-3.toml |  3 +-
 stacks-signer/src/tests/conf/signer-4.toml |  3 +-
 stacks-signer/src/utils.rs                 | 15 +++---
 testnet/stacks-node/src/tests/signer.rs    | 62 ++++++++++++++++------
 12 files changed, 147 insertions(+), 80 deletions(-)

diff --git a/stacks-signer/src/cli.rs b/stacks-signer/src/cli.rs
index ab0e6649a3..0e368ac4c8 100644
--- a/stacks-signer/src/cli.rs
+++ b/stacks-signer/src/cli.rs
@@ -125,19 +125,28 @@ pub struct RunDkgArgs {
 #[derive(Parser, Debug, Clone)]
 /// Arguments for the generate-files command
 pub struct GenerateFilesArgs {
-    /// The base arguments
-    #[clap(flatten)]
-    pub db_args: StackerDBArgs,
+    /// The Stacks node to connect to
+    #[arg(long)]
+    pub host: SocketAddr,
+    /// The signers stacker-db contract to use. Must be in the format of "STACKS_ADDRESS.CONTRACT_NAME"
+    #[arg(short, long, value_parser = parse_contract)]
+    pub signers_contract: QualifiedContractIdentifier,
+    /// The miners stacker-db contract to use. Must be in the format of "STACKS_ADDRESS.CONTRACT_NAME"
+    #[arg(short, long, value_parser = parse_contract)]
+    pub miners_contract: QualifiedContractIdentifier,
     #[arg(
         long,
-        required_unless_present = "private_keys",
-        conflicts_with = "private_keys"
+        required_unless_present = "signer_private_keys",
+        conflicts_with = "signer_private_keys"
     )]
     /// The number of signers to generate
     pub num_signers: Option<u32>,
     #[clap(long, value_name = "FILE")]
-    /// A path to a file containing a list of hexadecimal Stacks private keys
-    pub private_keys: Option<PathBuf>,
+    /// A path to a file containing a list of hexadecimal Stacks private keys of the signers
+    pub signer_private_keys: Option<PathBuf>,
+    /// The Stacks private key to use in hexademical format for the miner
+    #[arg(long, value_parser = parse_private_key)]
+    pub miner_private_key: StacksPrivateKey,
     #[arg(long)]
     /// The total number of key ids to distribute among the signers
     pub num_keys: u32,
diff --git a/stacks-signer/src/client/mod.rs b/stacks-signer/src/client/mod.rs
index c90473e64a..440586eb35 100644
--- a/stacks-signer/src/client/mod.rs
+++ b/stacks-signer/src/client/mod.rs
@@ -19,13 +19,6 @@ const BACKOFF_INITIAL_INTERVAL: u64 = 128;
 /// Backoff timer max interval in milliseconds
 const BACKOFF_MAX_INTERVAL: u64 = 16384;
 
-/// Temporary placeholder for the number of slots allocated to a stacker-db writer. This will be retrieved from the stacker-db instance in the future
-/// See: https://github.com/stacks-network/stacks-blockchain/issues/3921
-/// Is equal to the number of message types
-pub const SIGNER_SLOTS_PER_USER: u32 = 10;
-/// The number of miner slots available per miner
-pub const MINER_SLOTS_PER_USER: u32 = 1;
-
 #[derive(thiserror::Error, Debug)]
 /// Client error type
 pub enum ClientError {
diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index df7e413186..776fa8455f 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -13,12 +13,16 @@ use crate::config::Config;
 /// Temporary placeholder for the number of slots allocated to a stacker-db writer. This will be retrieved from the stacker-db instance in the future
 /// See: https://github.com/stacks-network/stacks-blockchain/issues/3921
 /// Is equal to the number of message types
-pub const SLOTS_PER_USER: u32 = 10;
+pub const SIGNER_SLOTS_PER_USER: u32 = 10;
+/// The number of miner slots available per miner
+pub const MINER_SLOTS_PER_USER: u32 = 1;
 
 /// The StackerDB client for communicating with both .signers and .miners contracts
 pub struct StackerDB {
     /// The stacker-db session for the signer StackerDB
     signers_stackerdb_session: StackerDBSession,
+    /// The stacker-db session for the .miners StackerDB
+    _miners_stackerdb_session: StackerDBSession,
     /// The private key used in all stacks node communications
     stacks_private_key: StacksPrivateKey,
     /// A map of a slot ID to last chunk version
@@ -30,7 +34,11 @@ impl From<&Config> for StackerDB {
         Self {
             signers_stackerdb_session: StackerDBSession::new(
                 config.node_host,
-                config.stackerdb_contract_id.clone(),
+                config.signers_stackerdb_contract_id.clone(),
+            ),
+            _miners_stackerdb_session: StackerDBSession::new(
+                config.node_host,
+                config.miners_stackerdb_contract_id.clone(),
             ),
             stacks_private_key: config.stacks_private_key,
             slot_versions: HashMap::new(),
@@ -94,7 +102,7 @@ fn slot_id(id: u32, message: &Message) -> u32 {
         Message::SignatureShareRequest(_) => 8,
         Message::SignatureShareResponse(_) => 9,
     };
-    SLOTS_PER_USER * id + slot_id
+    SIGNER_SLOTS_PER_USER * id + slot_id
 }
 
 #[cfg(test)]
diff --git a/stacks-signer/src/config.rs b/stacks-signer/src/config.rs
index 190a6f82c8..c298ead275 100644
--- a/stacks-signer/src/config.rs
+++ b/stacks-signer/src/config.rs
@@ -99,9 +99,11 @@ pub struct Config {
     pub node_host: SocketAddr,
     /// endpoint to the stackerdb receiver
     pub endpoint: SocketAddr,
-    /// smart contract that controls the target stackerdb
-    pub stackerdb_contract_id: QualifiedContractIdentifier,
-    /// smart contract that controls the target stackerdb
+    /// smart contract that controls the target signers' stackerdb
+    pub signers_stackerdb_contract_id: QualifiedContractIdentifier,
+    /// smart contract that controls the target .miners stackerdb
+    pub miners_stackerdb_contract_id: QualifiedContractIdentifier,
+    /// the pox contract identifier to use
     pub pox_contract_id: Option<QualifiedContractIdentifier>,
     /// The Scalar representation of the private key for signer communication
     pub message_private_key: Scalar,
@@ -144,8 +146,10 @@ struct RawConfigFile {
     /// endpoint to stackerdb receiver
     pub endpoint: String,
     // FIXME: these contract's should go away in non testing scenarios. Make them both optionals.
-    /// Stacker db contract identifier
-    pub stackerdb_contract_id: String,
+    /// Signers' Stacker db contract identifier
+    pub signers_stackerdb_contract_id: String,
+    /// Miners' Stacker db contract identifier
+    pub miners_stackerdb_contract_id: String,
     /// pox contract identifier
     pub pox_contract_id: Option<String>,
     /// the 32 byte ECDSA private key used to sign blocks, chunks, and transactions
@@ -219,13 +223,25 @@ impl TryFrom<RawConfigFile> for Config {
                 raw_data.endpoint.clone(),
             ))?;
 
-        let stackerdb_contract_id =
-            QualifiedContractIdentifier::parse(&raw_data.stackerdb_contract_id).map_err(|_| {
-                ConfigError::BadField(
-                    "stackerdb_contract_id".to_string(),
-                    raw_data.stackerdb_contract_id,
-                )
-            })?;
+        let signers_stackerdb_contract_id = QualifiedContractIdentifier::parse(
+            &raw_data.signers_stackerdb_contract_id,
+        )
+        .map_err(|_| {
+            ConfigError::BadField(
+                "signers_stackerdb_contract_id".to_string(),
+                raw_data.signers_stackerdb_contract_id,
+            )
+        })?;
+
+        let miners_stackerdb_contract_id = QualifiedContractIdentifier::parse(
+            &raw_data.miners_stackerdb_contract_id,
+        )
+        .map_err(|_| {
+            ConfigError::BadField(
+                "miners_stackerdb_contract_id".to_string(),
+                raw_data.miners_stackerdb_contract_id,
+            )
+        })?;
 
         let pox_contract_id = if let Some(id) = raw_data.pox_contract_id.as_ref() {
             Some(QualifiedContractIdentifier::parse(id).map_err(|_| {
@@ -288,7 +304,8 @@ impl TryFrom<RawConfigFile> for Config {
         Ok(Self {
             node_host,
             endpoint,
-            stackerdb_contract_id,
+            signers_stackerdb_contract_id,
+            miners_stackerdb_contract_id,
             pox_contract_id,
             message_private_key,
             stacks_private_key,
diff --git a/stacks-signer/src/main.rs b/stacks-signer/src/main.rs
index 4f6c762c1e..1dc2290b10 100644
--- a/stacks-signer/src/main.rs
+++ b/stacks-signer/src/main.rs
@@ -47,6 +47,7 @@ use stacks_signer::cli::{
     Cli, Command, GenerateFilesArgs, GetChunkArgs, GetLatestChunkArgs, PutChunkArgs, RunDkgArgs,
     SignArgs, StackerDBArgs,
 };
+use stacks_signer::client::{MINER_SLOTS_PER_USER, SIGNER_SLOTS_PER_USER};
 use stacks_signer::config::{Config, Network};
 use stacks_signer::runloop::{RunLoop, RunLoopCommand};
 use stacks_signer::utils::{build_signer_config_tomls, build_stackerdb_contract};
@@ -87,7 +88,7 @@ fn spawn_running_signer(path: &PathBuf) -> SpawnedSigner {
     let config = Config::try_from(path).unwrap();
     let (cmd_send, cmd_recv) = channel();
     let (res_send, res_recv) = channel();
-    let ev = StackerDBEventReceiver::new(vec![config.stackerdb_contract_id.clone()]);
+    let ev = StackerDBEventReceiver::new(vec![config.signers_stackerdb_contract_id.clone()]);
     let runloop: RunLoop<FireCoordinator<v2::Aggregator>> = RunLoop::from(&config);
     let mut signer: Signer<
         RunLoopCommand,
@@ -247,7 +248,7 @@ fn handle_run(args: RunDkgArgs) {
 
 fn handle_generate_files(args: GenerateFilesArgs) {
     debug!("Generating files...");
-    let signer_stacks_private_keys = if let Some(path) = args.private_keys {
+    let signer_stacks_private_keys = if let Some(path) = args.signer_private_keys {
         let file = File::open(&path).unwrap();
         let reader = io::BufReader::new(file);
 
@@ -274,36 +275,37 @@ fn handle_generate_files(args: GenerateFilesArgs) {
         .iter()
         .map(|key| to_addr(key, &args.network))
         .collect::<Vec<StacksAddress>>();
-    // Build the stackerdb contract
-    let stackerdb_contract = build_stackerdb_contract(&signer_stacks_addresses);
+    let miner_stacks_address = to_addr(&args.miner_private_key, &args.network);
+    // Build the signer and miner stackerdb contract
+    let signer_stackerdb_contract =
+        build_stackerdb_contract(&signer_stacks_addresses, SIGNER_SLOTS_PER_USER);
+    let miner_stackerdb_contract =
+        build_stackerdb_contract(&[miner_stacks_address], MINER_SLOTS_PER_USER);
+    write_file(&args.dir, "signers.clar", &signer_stackerdb_contract);
+    write_file(&args.dir, "miners.clar", &miner_stackerdb_contract);
+
     let signer_config_tomls = build_signer_config_tomls(
         &signer_stacks_private_keys,
         args.num_keys,
-        &args.db_args.host.to_string(),
-        &args.db_args.contract.to_string(),
+        &args.host.to_string(),
+        &args.signers_contract.to_string(),
+        &args.miners_contract.to_string(),
         None,
         args.timeout.map(Duration::from_millis),
     );
     debug!("Built {:?} signer config tomls.", signer_config_tomls.len());
     for (i, file_contents) in signer_config_tomls.iter().enumerate() {
-        let signer_conf_path = args.dir.join(format!("signer-{}.toml", i));
-        let signer_conf_filename = signer_conf_path.to_str().unwrap();
-        let mut signer_conf_file = File::create(signer_conf_filename).unwrap();
-        signer_conf_file
-            .write_all(file_contents.as_bytes())
-            .unwrap();
-        println!("Created signer config toml file: {}", signer_conf_filename);
+        write_file(&args.dir, &format!("signer-{}.toml", i), file_contents);
     }
-    let stackerdb_contract_path = args.dir.join("stackerdb.clar");
-    let stackerdb_contract_filename = stackerdb_contract_path.to_str().unwrap();
-    let mut stackerdb_contract_file = File::create(stackerdb_contract_filename).unwrap();
-    stackerdb_contract_file
-        .write_all(stackerdb_contract.as_bytes())
-        .unwrap();
-    println!(
-        "Created stackerdb clarity contract: {}",
-        stackerdb_contract_filename
-    );
+}
+
+/// Helper function for writing the given contents to filename in the given directory
+fn write_file(dir: &PathBuf, filename: &str, contents: &str) {
+    let file_path = dir.join(filename);
+    let filename = file_path.to_str().unwrap();
+    let mut file = File::create(filename).unwrap();
+    file.write_all(contents.as_bytes()).unwrap();
+    println!("Created file: {}", filename);
 }
 
 fn main() {
diff --git a/stacks-signer/src/tests/conf/signer-0.toml b/stacks-signer/src/tests/conf/signer-0.toml
index ee510d563e..226a30eb7b 100644
--- a/stacks-signer/src/tests/conf/signer-0.toml
+++ b/stacks-signer/src/tests/conf/signer-0.toml
@@ -4,7 +4,8 @@ stacks_private_key = "69be0e68947fa7128702761151dc8d9b39ee1401e547781bb2ec3e5b4e
 node_host = "127.0.0.1:20443"
 endpoint = "localhost:30000"
 network = "testnet"
-stackerdb_contract_id = "ST11Z60137Y96MF89K1KKRTA3CR6B25WY1Y931668.signers-stackerdb"
+signers_stackerdb_contract_id = "ST11Z60137Y96MF89K1KKRTA3CR6B25WY1Y931668.signers-stackerdb"
+miners_stackerdb_contract_id = "ST11Z60137Y96MF89K1KKRTA3CR6B25WY1Y931668.miners-stackerdb"
 signer_id = 0
 signers = [
             {public_key = "swBaKxfzs4pQne7spxhrkF6AtB34WEcreAkJ8mPcqx3t", key_ids = [1, 2, 3, 4]}
diff --git a/stacks-signer/src/tests/conf/signer-1.toml b/stacks-signer/src/tests/conf/signer-1.toml
index 73d5cb6a69..e3f6f68cbd 100644
--- a/stacks-signer/src/tests/conf/signer-1.toml
+++ b/stacks-signer/src/tests/conf/signer-1.toml
@@ -4,7 +4,8 @@ stacks_private_key = "fd5a538e8548e9d6a4a4060a43d0142356df022a4b8fd8ed4a7d066382
 node_host = "127.0.0.1:20443"
 endpoint = "localhost:30001"
 network = "testnet"
-stackerdb_contract_id = "ST11Z60137Y96MF89K1KKRTA3CR6B25WY1Y931668.signers-stackerdb"
+signers_stackerdb_contract_id = "ST11Z60137Y96MF89K1KKRTA3CR6B25WY1Y931668.signers-stackerdb"
+miners_stackerdb_contract_id = "ST11Z60137Y96MF89K1KKRTA3CR6B25WY1Y931668.miners-stackerdb"
 signer_id = 1
 signers = [
             {public_key = "swBaKxfzs4pQne7spxhrkF6AtB34WEcreAkJ8mPcqx3t", key_ids = [1, 2, 3, 4]}
diff --git a/stacks-signer/src/tests/conf/signer-2.toml b/stacks-signer/src/tests/conf/signer-2.toml
index 7ff263940d..0140dadad0 100644
--- a/stacks-signer/src/tests/conf/signer-2.toml
+++ b/stacks-signer/src/tests/conf/signer-2.toml
@@ -4,7 +4,8 @@ stacks_private_key = "74e8e8550a5210b89461128c600e4bf611d1553e6809308bc012dbb0fb
 node_host = "127.0.0.1:20443"
 endpoint = "localhost:30002"
 network = "testnet"
-stackerdb_contract_id = "ST11Z60137Y96MF89K1KKRTA3CR6B25WY1Y931668.signers-stackerdb"
+signers_stackerdb_contract_id = "ST11Z60137Y96MF89K1KKRTA3CR6B25WY1Y931668.signers-stackerdb"
+miners_stackerdb_contract_id = "ST11Z60137Y96MF89K1KKRTA3CR6B25WY1Y931668.miners-stackerdb"
 signer_id = 2
 signers = [
             {public_key = "swBaKxfzs4pQne7spxhrkF6AtB34WEcreAkJ8mPcqx3t", key_ids = [1, 2, 3, 4]}
diff --git a/stacks-signer/src/tests/conf/signer-3.toml b/stacks-signer/src/tests/conf/signer-3.toml
index e7ac219a40..8cc8889f52 100644
--- a/stacks-signer/src/tests/conf/signer-3.toml
+++ b/stacks-signer/src/tests/conf/signer-3.toml
@@ -4,7 +4,8 @@ stacks_private_key = "803fa7b9c8a39ed368f160b3dcbfaa8f677fc157ffbccb46ee3e4a32a3
 node_host = "127.0.0.1:20443"
 endpoint = "localhost:30003"
 network = "testnet"
-stackerdb_contract_id = "ST11Z60137Y96MF89K1KKRTA3CR6B25WY1Y931668.signers-stackerdb"
+signers_stackerdb_contract_id = "ST11Z60137Y96MF89K1KKRTA3CR6B25WY1Y931668.signers-stackerdb"
+miners_stackerdb_contract_id = "ST11Z60137Y96MF89K1KKRTA3CR6B25WY1Y931668.miners-stackerdb"
 signer_id = 3
 signers = [
             {public_key = "swBaKxfzs4pQne7spxhrkF6AtB34WEcreAkJ8mPcqx3t", key_ids = [1, 2, 3, 4]}
diff --git a/stacks-signer/src/tests/conf/signer-4.toml b/stacks-signer/src/tests/conf/signer-4.toml
index c2eb3f37d0..999e066a09 100644
--- a/stacks-signer/src/tests/conf/signer-4.toml
+++ b/stacks-signer/src/tests/conf/signer-4.toml
@@ -4,7 +4,8 @@ stacks_private_key = "1bfdf386114aacf355fe018a1ec7ac728fa05ca20a6131a70f686291bb
 node_host = "127.0.0.1:20443"
 endpoint = "localhost:30004"
 network = "testnet"
-stackerdb_contract_id = "ST11Z60137Y96MF89K1KKRTA3CR6B25WY1Y931668.signers-stackerdb"
+signers_stackerdb_contract_id = "ST11Z60137Y96MF89K1KKRTA3CR6B25WY1Y931668.signers-stackerdb"
+miners_stackerdb_contract_id = "ST11Z60137Y96MF89K1KKRTA3CR6B25WY1Y931668.miners-stackerdb"
 signer_id = 4
 signers = [
             {public_key = "swBaKxfzs4pQne7spxhrkF6AtB34WEcreAkJ8mPcqx3t", key_ids = [1, 2, 3, 4]}
diff --git a/stacks-signer/src/utils.rs b/stacks-signer/src/utils.rs
index 585ad73ceb..6011a3a170 100644
--- a/stacks-signer/src/utils.rs
+++ b/stacks-signer/src/utils.rs
@@ -7,14 +7,13 @@ use stacks_common::types::chainstate::{StacksAddress, StacksPrivateKey};
 use wsts::curve::ecdsa;
 use wsts::curve::scalar::Scalar;
 
-use crate::client::SLOTS_PER_USER;
-
 /// Helper function for building a signer config for each provided signer private key
 pub fn build_signer_config_tomls(
     signer_stacks_private_keys: &[StacksPrivateKey],
     num_keys: u32,
     node_host: &str,
-    stackerdb_contract_id: &str,
+    signers_stackerdb_contract_id: &str,
+    miners_stackerdb_contract_id: &str,
     pox_contract_id: Option<&str>,
     timeout: Option<Duration>,
 ) -> Vec<String> {
@@ -74,7 +73,8 @@ stacks_private_key = "{stacks_private_key}"
 node_host = "{node_host}"
 endpoint = "{endpoint}"
 network = "testnet"
-stackerdb_contract_id = "{stackerdb_contract_id}"
+signers_stackerdb_contract_id = "{signers_stackerdb_contract_id}"
+miners_stackerdb_contract_id = "{miners_stackerdb_contract_id}"
 signer_id = {id}
 {signers_array}
 "#
@@ -105,7 +105,10 @@ pox_contract_id = "{pox_contract_id}"
 }
 
 /// Helper function for building a stackerdb contract from the provided signer stacks addresses
-pub fn build_stackerdb_contract(signer_stacks_addresses: &[StacksAddress]) -> String {
+pub fn build_stackerdb_contract(
+    signer_stacks_addresses: &[StacksAddress],
+    slots_per_user: u32,
+) -> String {
     let mut stackerdb_contract = String::new(); // "
     stackerdb_contract += "        ;; stacker DB\n";
     stackerdb_contract += "        (define-read-only (stackerdb-get-signer-slots)\n";
@@ -115,7 +118,7 @@ pub fn build_stackerdb_contract(signer_stacks_addresses: &[StacksAddress]) -> St
         stackerdb_contract +=
             format!("                    signer: '{},\n", signer_stacks_address).as_str();
         stackerdb_contract +=
-            format!("                    num-slots: u{}\n", SLOTS_PER_USER).as_str();
+            format!("                    num-slots: u{}\n", slots_per_user).as_str();
         stackerdb_contract += "                }\n";
     }
     stackerdb_contract += "                )))\n";
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index bb7f3d6446..933e3e0c6f 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -6,6 +6,7 @@ use clarity::vm::types::QualifiedContractIdentifier;
 use libsigner::{RunningSigner, Signer, StackerDBEventReceiver};
 use stacks::chainstate::stacks::StacksPrivateKey;
 use stacks_common::types::chainstate::StacksAddress;
+use stacks_signer::client::{MINER_SLOTS_PER_USER, SIGNER_SLOTS_PER_USER};
 use stacks_signer::config::Config as SignerConfig;
 use stacks_signer::runloop::RunLoopCommand;
 use stacks_signer::utils::{build_signer_config_tomls, build_stackerdb_contract};
@@ -38,7 +39,10 @@ fn spawn_signer(
     sender: Sender<Vec<OperationResult>>,
 ) -> RunningSigner<StackerDBEventReceiver, Vec<OperationResult>> {
     let config = stacks_signer::config::Config::load_from_str(data).unwrap();
-    let ev = StackerDBEventReceiver::new(vec![config.stackerdb_contract_id.clone()]);
+    let ev = StackerDBEventReceiver::new(vec![
+        config.miners_stackerdb_contract_id.clone(),
+        config.signers_stackerdb_contract_id.clone(),
+    ]);
     let runloop: stacks_signer::runloop::RunLoop<FireCoordinator<v2::Aggregator>> =
         stacks_signer::runloop::RunLoop::from(&config);
     let mut signer: Signer<
@@ -61,8 +65,10 @@ fn setup_stx_btc_node(
     num_signers: u32,
     signer_stacks_private_keys: &[StacksPrivateKey],
     publisher_private_key: &StacksPrivateKey,
-    stackerdb_contract: &str,
-    stackerdb_contract_id: &QualifiedContractIdentifier,
+    signers_stackerdb_contract: &str,
+    signers_stackerdb_contract_id: &QualifiedContractIdentifier,
+    miners_stackerdb_contract: &str,
+    miners_stackerdb_contract_id: &QualifiedContractIdentifier,
     pox_contract: &str,
     pox_contract_id: &QualifiedContractIdentifier,
     signer_config_tomls: &Vec<String>,
@@ -91,7 +97,12 @@ fn setup_stx_btc_node(
     }
 
     conf.initial_balances.append(&mut initial_balances);
-    conf.node.stacker_dbs.push(stackerdb_contract_id.clone());
+    conf.node
+        .stacker_dbs
+        .push(signers_stackerdb_contract_id.clone());
+    conf.node
+        .stacker_dbs
+        .push(miners_stackerdb_contract_id.clone());
 
     info!("Make new BitcoinCoreController");
     let mut btcd_controller = BitcoinCoreController::new(conf.clone());
@@ -143,13 +154,23 @@ fn setup_stx_btc_node(
     );
     submit_tx(&http_origin, &tx);
 
-    info!("Send stacker-db contract-publish...");
+    info!("Send signers stacker-db contract-publish...");
     let tx = make_contract_publish(
         publisher_private_key,
         1,
         tx_fee,
-        &stackerdb_contract_id.name,
-        stackerdb_contract,
+        &signers_stackerdb_contract_id.name,
+        signers_stackerdb_contract,
+    );
+    submit_tx(&http_origin, &tx);
+
+    info!("Send miners stacker-db contract-publish...");
+    let tx = make_contract_publish(
+        publisher_private_key,
+        2,
+        tx_fee,
+        &miners_stackerdb_contract_id.name,
+        miners_stackerdb_contract,
     );
     submit_tx(&http_origin, &tx);
 
@@ -211,6 +232,8 @@ fn test_stackerdb_dkg() {
         .iter()
         .map(to_addr)
         .collect::<Vec<StacksAddress>>();
+    let miner_private_key = StacksPrivateKey::new();
+    let miner_stacks_address = to_addr(&miner_private_key);
 
     // Setup the neon node
     let (mut conf, _) = neon_integration_test_conf();
@@ -219,19 +242,24 @@ fn test_stackerdb_dkg() {
     let pox_contract = build_pox_contract(num_signers);
     let pox_contract_id =
         QualifiedContractIdentifier::new(to_addr(&publisher_private_key).into(), "pox-4".into());
-    // Build the stackerdb contract
-    let stackerdb_contract = build_stackerdb_contract(&signer_stacks_addresses);
-    let stacker_db_contract_id = QualifiedContractIdentifier::new(
-        to_addr(&publisher_private_key).into(),
-        "hello-world".into(),
-    );
+    // Build the stackerdb contracts
+    let signers_stackerdb_contract =
+        build_stackerdb_contract(&signer_stacks_addresses, SIGNER_SLOTS_PER_USER);
+    let signers_stacker_db_contract_id =
+        QualifiedContractIdentifier::new(to_addr(&publisher_private_key).into(), "signers".into());
+
+    let miners_stackerdb_contract =
+        build_stackerdb_contract(&[miner_stacks_address], MINER_SLOTS_PER_USER);
+    let miners_stacker_db_contract_id =
+        QualifiedContractIdentifier::new(to_addr(&publisher_private_key).into(), "miners".into());
 
     // Setup the signer and coordinator configurations
     let signer_configs = build_signer_config_tomls(
         &signer_stacks_private_keys,
         num_keys,
         &conf.node.rpc_bind,
-        &stacker_db_contract_id.to_string(),
+        &signers_stacker_db_contract_id.to_string(),
+        &miners_stacker_db_contract_id.to_string(),
         Some(&pox_contract_id.to_string()),
         Some(Duration::from_millis(128)), // Timeout defaults to 5 seconds. Let's override it to 128 milliseconds.
     );
@@ -270,8 +298,10 @@ fn test_stackerdb_dkg() {
             num_signers,
             &signer_stacks_private_keys,
             &publisher_private_key,
-            &stackerdb_contract,
-            &stacker_db_contract_id,
+            &signers_stackerdb_contract,
+            &signers_stacker_db_contract_id,
+            &miners_stackerdb_contract,
+            &miners_stacker_db_contract_id,
             &pox_contract,
             &pox_contract_id,
             &signer_configs,

From eb95f04ccd62e12f8b66fd27c38c3e7b13e46339 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 6 Dec 2023 10:04:28 -0500
Subject: [PATCH 0358/1166] Seperate miner and signer events

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/stackerdb.rs | 15 +++++-
 stacks-signer/src/main.rs             |  4 +-
 stacks-signer/src/runloop.rs          | 74 ++++++++++++++++-----------
 3 files changed, 59 insertions(+), 34 deletions(-)

diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index 776fa8455f..ac3870b0c2 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -1,3 +1,4 @@
+use clarity::vm::types::QualifiedContractIdentifier;
 use hashbrown::HashMap;
 use libsigner::{SignerSession, StackerDBSession};
 use libstackerdb::{StackerDBChunkAckData, StackerDBChunkData};
@@ -22,7 +23,7 @@ pub struct StackerDB {
     /// The stacker-db session for the signer StackerDB
     signers_stackerdb_session: StackerDBSession,
     /// The stacker-db session for the .miners StackerDB
-    _miners_stackerdb_session: StackerDBSession,
+    miners_stackerdb_session: StackerDBSession,
     /// The private key used in all stacks node communications
     stacks_private_key: StacksPrivateKey,
     /// A map of a slot ID to last chunk version
@@ -36,7 +37,7 @@ impl From<&Config> for StackerDB {
                 config.node_host,
                 config.signers_stackerdb_contract_id.clone(),
             ),
-            _miners_stackerdb_session: StackerDBSession::new(
+            miners_stackerdb_session: StackerDBSession::new(
                 config.node_host,
                 config.miners_stackerdb_contract_id.clone(),
             ),
@@ -87,6 +88,16 @@ impl StackerDB {
             }
         }
     }
+
+    /// Retrieve the miner contract id
+    pub fn miners_contract_id(&self) -> &QualifiedContractIdentifier {
+        &self.miners_stackerdb_session.stackerdb_contract_id
+    }
+
+    /// Retrieve the signer contract id
+    pub fn signers_contract_id(&self) -> &QualifiedContractIdentifier {
+        &self.signers_stackerdb_session.stackerdb_contract_id
+    }
 }
 
 /// Helper function to determine the slot ID for the provided stacker-db writer id and the message type
diff --git a/stacks-signer/src/main.rs b/stacks-signer/src/main.rs
index 1dc2290b10..a3270f8fac 100644
--- a/stacks-signer/src/main.rs
+++ b/stacks-signer/src/main.rs
@@ -29,7 +29,7 @@ extern crate toml;
 use std::fs::File;
 use std::io::{self, BufRead, Write};
 use std::net::SocketAddr;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 use std::sync::mpsc::{channel, Receiver, Sender};
 use std::time::Duration;
 
@@ -300,7 +300,7 @@ fn handle_generate_files(args: GenerateFilesArgs) {
 }
 
 /// Helper function for writing the given contents to filename in the given directory
-fn write_file(dir: &PathBuf, filename: &str, contents: &str) {
+fn write_file(dir: &Path, filename: &str, contents: &str) {
     let file_path = dir.join(filename);
     let filename = file_path.to_str().unwrap();
     let mut file = File::create(filename).unwrap();
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 7337546a07..f8c7a0fef7 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -166,11 +166,16 @@ impl<C: Coordinator> RunLoop<C> {
         }
     }
 
-    /// Process the event as both a signer and a coordinator
-    fn process_event(
+    /// Process the event as a miner message from the miner stacker-db
+    fn process_event_miner(
         &mut self,
-        event: &StackerDBChunksEvent,
+        _event: &StackerDBChunksEvent,
     ) -> (Vec<Packet>, Vec<OperationResult>) {
+        todo!("Process miner event")
+    }
+
+    /// Process the event as a signer message from the signer stacker-db
+    fn process_event_signer(&mut self, event: &StackerDBChunksEvent) -> Vec<OperationResult> {
         // Determine the current coordinator id and public key for verification
         let (_coordinator_id, coordinator_public_key) =
             calculate_coordinator(&self.signing_round.public_keys);
@@ -196,15 +201,30 @@ impl<C: Coordinator> RunLoop<C> {
                 vec![]
             });
         // Next process the message as the coordinator
-        let (messages, results) = self
+        let (messages, operation_results) = self
             .coordinator
             .process_inbound_messages(&inbound_messages)
             .unwrap_or_else(|e| {
-                error!("Failed to process inbound messages as a coordinator: {e}");
+                error!("Failed to process inbound messages as a signer: {e}");
                 (vec![], vec![])
             });
+
         outbound_messages.extend(messages);
-        (outbound_messages, results)
+        debug!(
+            "Sending {} messages to other stacker-db instances.",
+            outbound_messages.len()
+        );
+        for msg in outbound_messages {
+            let ack = self
+                .stackerdb
+                .send_message_with_retry(self.signing_round.signer_id, msg);
+            if let Ok(ack) = ack {
+                debug!("ACK: {:?}", ack);
+            } else {
+                warn!("Failed to send message to stacker-db instance: {:?}", ack);
+            }
+        }
+        operation_results
     }
 }
 
@@ -310,32 +330,26 @@ impl<C: Coordinator> SignerRunLoop<Vec<OperationResult>, RunLoopCommand> for Run
         }
         // Process any arrived events
         if let Some(event) = event {
-            let (outbound_messages, operation_results) = self.process_event(&event);
-            debug!(
-                "Sending {} messages to other stacker-db instances.",
-                outbound_messages.len()
-            );
-            for msg in outbound_messages {
-                let ack = self
-                    .stackerdb
-                    .send_message_with_retry(self.signing_round.signer_id, msg);
-                if let Ok(ack) = ack {
-                    debug!("ACK: {:?}", ack);
-                } else {
-                    warn!("Failed to send message to stacker-db instance: {:?}", ack);
-                }
-            }
-
-            let nmb_results = operation_results.len();
-            if nmb_results > 0 {
-                // We finished our command. Update the state
-                self.state = State::Idle;
-                match res.send(operation_results) {
-                    Ok(_) => debug!("Successfully sent {} operation result(s)", nmb_results),
-                    Err(e) => {
-                        warn!("Failed to send operation results: {:?}", e);
+            if event.contract_id == *self.stackerdb.miners_contract_id() {
+                self.process_event_miner(&event);
+            } else if event.contract_id == *self.stackerdb.signers_contract_id() {
+                let operation_results = self.process_event_signer(&event);
+                let nmb_results = operation_results.len();
+                if nmb_results > 0 {
+                    // We finished our command. Update the state
+                    self.state = State::Idle;
+                    match res.send(operation_results) {
+                        Ok(_) => debug!("Successfully sent {} operation result(s)", nmb_results),
+                        Err(e) => {
+                            warn!("Failed to send operation results: {:?}", e);
+                        }
                     }
                 }
+            } else {
+                warn!(
+                    "Received event from unknown contract ID: {}",
+                    event.contract_id
+                );
             }
         }
         // The process the next command

From c3010075766c84ddba59986b51f87c093953a2bb Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 6 Dec 2023 10:39:58 -0500
Subject: [PATCH 0359/1166] Add block specific slot and StackerDBMessage type
 to stackerdb.rs

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/mod.rs       |  3 +-
 stacks-signer/src/client/stackerdb.rs | 80 ++++++++++++++++++++-------
 stacks-signer/src/runloop.rs          |  6 +-
 3 files changed, 66 insertions(+), 23 deletions(-)

diff --git a/stacks-signer/src/client/mod.rs b/stacks-signer/src/client/mod.rs
index 440586eb35..fcc614c6e3 100644
--- a/stacks-signer/src/client/mod.rs
+++ b/stacks-signer/src/client/mod.rs
@@ -12,6 +12,7 @@ use libstackerdb::Error as StackerDBError;
 use slog::slog_debug;
 pub use stackerdb::*;
 pub use stacks_client::*;
+use stacks_common::codec::Error as CodecError;
 use stacks_common::debug;
 
 /// Backoff timer initial interval in milliseconds
@@ -24,7 +25,7 @@ const BACKOFF_MAX_INTERVAL: u64 = 16384;
 pub enum ClientError {
     /// An error occurred serializing the message
     #[error("Unable to serialize stacker-db message: {0}")]
-    StackerDBSerializationError(#[from] bincode::Error),
+    StackerDBSerializationError(#[from] CodecError),
     /// Failed to sign stacker-db chunk
     #[error("Failed to sign stacker-db chunk: {0}")]
     FailToSign(#[from] StackerDBError),
diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index ac3870b0c2..8e776e935f 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -1,8 +1,10 @@
+use blockstack_lib::chainstate::nakamoto::NakamotoBlock;
 use clarity::vm::types::QualifiedContractIdentifier;
 use hashbrown::HashMap;
 use libsigner::{SignerSession, StackerDBSession};
 use libstackerdb::{StackerDBChunkAckData, StackerDBChunkData};
 use slog::{slog_debug, slog_warn};
+use stacks_common::codec::{Error as CodecError, StacksMessageCodec};
 use stacks_common::types::chainstate::StacksPrivateKey;
 use stacks_common::{debug, warn};
 use wsts::net::{Message, Packet};
@@ -18,6 +20,62 @@ pub const SIGNER_SLOTS_PER_USER: u32 = 10;
 /// The number of miner slots available per miner
 pub const MINER_SLOTS_PER_USER: u32 = 1;
 
+// The slot IDS for each message type
+const DKG_BEGIN_SLOT_ID: u32 = 0;
+const DKG_PRIVATE_BEGIN_SLOT_ID: u32 = 1;
+const DKG_END_SLOT_ID: u32 = 2;
+const DKG_PUBLIC_SHARES_SLOT_ID: u32 = 3;
+const DKG_PRIVATE_SHARES_SLOT_ID: u32 = 4;
+const NONCE_REQUEST_SLOT_ID: u32 = 5;
+const NONCE_RESPONSE_SLOT_ID: u32 = 6;
+const SIGNATURE_SHARE_REQUEST_SLOT_ID: u32 = 7;
+const SIGNATURE_SHARE_RESPONSE_SLOT_ID: u32 = 8;
+const BLOCK_SLOT_ID: u32 = 9;
+
+/// The StackerDB messages that can be sent through the .signers contract
+pub enum StackerDBMessage {
+    /// The latest Nakamoto block for miners to observe
+    Block(NakamotoBlock),
+    /// DKG and Signing round data for other signers to observe
+    Packet(Packet),
+}
+
+impl From<Packet> for StackerDBMessage {
+    fn from(packet: Packet) -> Self {
+        Self::Packet(packet)
+    }
+}
+
+impl StacksMessageCodec for StackerDBMessage {
+    fn consensus_serialize<W: std::io::Write>(&self, _fd: &mut W) -> Result<(), CodecError> {
+        todo!()
+    }
+
+    fn consensus_deserialize<R: std::io::Read>(_fd: &mut R) -> Result<Self, CodecError> {
+        todo!()
+    }
+}
+
+impl StackerDBMessage {
+    /// Helper function to determine the slot ID for the provided stacker-db writer id
+    pub fn slot_id(&self, id: u32) -> u32 {
+        let slot_id = match self {
+            StackerDBMessage::Packet(packet) => match packet.msg {
+                Message::DkgBegin(_) => DKG_BEGIN_SLOT_ID,
+                Message::DkgPrivateBegin(_) => DKG_PRIVATE_BEGIN_SLOT_ID,
+                Message::DkgEnd(_) => DKG_END_SLOT_ID,
+                Message::DkgPublicShares(_) => DKG_PUBLIC_SHARES_SLOT_ID,
+                Message::DkgPrivateShares(_) => DKG_PRIVATE_SHARES_SLOT_ID,
+                Message::NonceRequest(_) => NONCE_REQUEST_SLOT_ID,
+                Message::NonceResponse(_) => NONCE_RESPONSE_SLOT_ID,
+                Message::SignatureShareRequest(_) => SIGNATURE_SHARE_REQUEST_SLOT_ID,
+                Message::SignatureShareResponse(_) => SIGNATURE_SHARE_RESPONSE_SLOT_ID,
+            },
+            Self::Block(_block) => BLOCK_SLOT_ID,
+        };
+        SIGNER_SLOTS_PER_USER * id + slot_id
+    }
+}
 /// The StackerDB client for communicating with both .signers and .miners contracts
 pub struct StackerDB {
     /// The stacker-db session for the signer StackerDB
@@ -52,10 +110,10 @@ impl StackerDB {
     pub fn send_message_with_retry(
         &mut self,
         id: u32,
-        message: Packet,
+        message: StackerDBMessage,
     ) -> Result<StackerDBChunkAckData, ClientError> {
-        let message_bytes = bincode::serialize(&message)?;
-        let slot_id = slot_id(id, &message.msg);
+        let message_bytes = message.serialize_to_vec();
+        let slot_id = message.slot_id(id);
 
         loop {
             let slot_version = *self.slot_versions.entry(slot_id).or_insert(0) + 1;
@@ -100,21 +158,5 @@ impl StackerDB {
     }
 }
 
-/// Helper function to determine the slot ID for the provided stacker-db writer id and the message type
-fn slot_id(id: u32, message: &Message) -> u32 {
-    let slot_id = match message {
-        Message::DkgBegin(_) => 0,
-        Message::DkgPrivateBegin(_) => 1,
-        Message::DkgEnd(_) => 2,
-        Message::DkgPublicShares(_) => 4,
-        Message::DkgPrivateShares(_) => 5,
-        Message::NonceRequest(_) => 6,
-        Message::NonceResponse(_) => 7,
-        Message::SignatureShareRequest(_) => 8,
-        Message::SignatureShareResponse(_) => 9,
-    };
-    SIGNER_SLOTS_PER_USER * id + slot_id
-}
-
 #[cfg(test)]
 mod tests {}
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index f8c7a0fef7..7f36cc0955 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -99,7 +99,7 @@ impl<C: Coordinator> RunLoop<C> {
                     Ok(msg) => {
                         let ack = self
                             .stackerdb
-                            .send_message_with_retry(self.signing_round.signer_id, msg);
+                            .send_message_with_retry(self.signing_round.signer_id, msg.into());
                         debug!("ACK: {:?}", ack);
                         self.state = State::Dkg;
                         true
@@ -125,7 +125,7 @@ impl<C: Coordinator> RunLoop<C> {
                     Ok(msg) => {
                         let ack = self
                             .stackerdb
-                            .send_message_with_retry(self.signing_round.signer_id, msg);
+                            .send_message_with_retry(self.signing_round.signer_id, msg.into());
                         debug!("ACK: {:?}", ack);
                         self.state = State::Sign;
                         true
@@ -217,7 +217,7 @@ impl<C: Coordinator> RunLoop<C> {
         for msg in outbound_messages {
             let ack = self
                 .stackerdb
-                .send_message_with_retry(self.signing_round.signer_id, msg);
+                .send_message_with_retry(self.signing_round.signer_id, msg.into());
             if let Ok(ack) = ack {
                 debug!("ACK: {:?}", ack);
             } else {

From cdc16bcd1a95e077ba1064ce130948863ca06eb9 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 6 Dec 2023 14:24:11 -0500
Subject: [PATCH 0360/1166] Delete stale stacks_client.rs

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/stacks_client.rs | 754 -----------------------------
 1 file changed, 754 deletions(-)
 delete mode 100644 stacks-signer/src/stacks_client.rs

diff --git a/stacks-signer/src/stacks_client.rs b/stacks-signer/src/stacks_client.rs
deleted file mode 100644
index cc70a0b8ce..0000000000
--- a/stacks-signer/src/stacks_client.rs
+++ /dev/null
@@ -1,754 +0,0 @@
-use std::time::Duration;
-
-use bincode::Error as BincodeError;
-use blockstack_lib::burnchains::Txid;
-use blockstack_lib::chainstate::stacks::{
-    StacksTransaction, StacksTransactionSigner, TransactionAnchorMode, TransactionAuth,
-    TransactionContractCall, TransactionPayload, TransactionPostConditionMode,
-    TransactionSpendingCondition, TransactionVersion,
-};
-use clarity::vm::types::serialization::SerializationError;
-use clarity::vm::types::{QualifiedContractIdentifier, SequenceData};
-use clarity::vm::{ClarityName, ContractName, Value as ClarityValue};
-use hashbrown::HashMap;
-use libsigner::{RPCError, SignerSession, StackerDBSession};
-use libstackerdb::{Error as StackerDBError, StackerDBChunkAckData, StackerDBChunkData};
-use serde_json::json;
-use slog::{slog_debug, slog_warn};
-use stacks_common::codec::StacksMessageCodec;
-use stacks_common::types::chainstate::{StacksAddress, StacksPrivateKey, StacksPublicKey};
-use stacks_common::{debug, warn};
-use wsts::curve::point::Point;
-use wsts::curve::scalar::Scalar;
-use wsts::net::{Message, Packet};
-
-use crate::config::Config;
-
-/// Backoff timer initial interval in milliseconds
-const BACKOFF_INITIAL_INTERVAL: u64 = 128;
-/// Backoff timer max interval in milliseconds
-const BACKOFF_MAX_INTERVAL: u64 = 16384;
-
-/// Temporary placeholder for the number of slots allocated to a stacker-db writer. This will be retrieved from the stacker-db instance in the future
-/// See: https://github.com/stacks-network/stacks-blockchain/issues/3921
-/// Is equal to the number of message types
-pub const SLOTS_PER_USER: u32 = 10;
-
-#[derive(thiserror::Error, Debug)]
-/// Client error type
-pub enum ClientError {
-    /// An error occurred serializing the message
-    #[error("Unable to serialize stacker-db message: {0}")]
-    StackerDBSerializationError(#[from] BincodeError),
-    /// Failed to sign stacker-db chunk
-    #[error("Failed to sign stacker-db chunk: {0}")]
-    FailToSign(#[from] StackerDBError),
-    /// Failed to write to stacker-db due to RPC error
-    #[error("Failed to write to stacker-db instance: {0}")]
-    PutChunkFailed(#[from] RPCError),
-    /// Stacker-db instance rejected the chunk
-    #[error("Stacker-db rejected the chunk. Reason: {0}")]
-    PutChunkRejected(String),
-    /// Failed to find a given json entry
-    #[error("Invalid JSON entry: {0}")]
-    InvalidJsonEntry(String),
-    /// Failed to call a read only function
-    #[error("Failed to call read only function. {0}")]
-    ReadOnlyFailure(String),
-    /// Reqwest specific error occurred
-    #[error("{0}")]
-    ReqwestError(#[from] reqwest::Error),
-    /// Failed to build and sign a new Stacks transaction.
-    #[error("Failed to generate transaction from a transaction signer: {0}")]
-    TransactionGenerationFailure(String),
-    /// Stacks node client request failed
-    #[error("Stacks node client request failed: {0}")]
-    RequestFailure(reqwest::StatusCode),
-    /// Failed to serialize a Clarity value
-    #[error("Failed to serialize Clarity value: {0}")]
-    ClaritySerializationError(#[from] SerializationError),
-    /// Failed to parse a Clarity value
-    #[error("Recieved a malformed clarity value: {0}")]
-    MalformedClarityValue(ClarityValue),
-    /// Invalid Clarity Name
-    #[error("Invalid Clarity Name: {0}")]
-    InvalidClarityName(String),
-    /// Backoff retry timeout
-    #[error("Backoff retry timeout occurred. Stacks node may be down.")]
-    RetryTimeout,
-}
-
-/// The Stacks signer client used to communicate with the stacker-db instance
-pub struct StacksClient {
-    /// The stacker-db session
-    stackerdb_session: StackerDBSession,
-    /// The stacks address of the signer
-    stacks_address: StacksAddress,
-    /// The private key used in all stacks node communications
-    stacks_private_key: StacksPrivateKey,
-    /// A map of a slot ID to last chunk version
-    slot_versions: HashMap<u32, u32>,
-    /// The stacks node HTTP base endpoint
-    http_origin: String,
-    /// The types of transactions
-    tx_version: TransactionVersion,
-    /// The chain we are interacting with
-    chain_id: u32,
-    /// The Client used to make HTTP connects
-    stacks_node_client: reqwest::blocking::Client,
-    /// The pox contract ID
-    pox_contract_id: Option<QualifiedContractIdentifier>,
-}
-
-impl From<&Config> for StacksClient {
-    fn from(config: &Config) -> Self {
-        Self {
-            stackerdb_session: StackerDBSession::new(
-                config.node_host,
-                config.stackerdb_contract_id.clone(),
-            ),
-            stacks_private_key: config.stacks_private_key,
-            stacks_address: config.stacks_address,
-            slot_versions: HashMap::new(),
-            http_origin: format!("http://{}", config.node_host),
-            tx_version: config.network.to_transaction_version(),
-            chain_id: config.network.to_chain_id(),
-            stacks_node_client: reqwest::blocking::Client::new(),
-            pox_contract_id: config.pox_contract_id.clone(),
-        }
-    }
-}
-
-impl StacksClient {
-    /// Sends messages to the stacker-db with an exponential backoff retry
-    pub fn send_message_with_retry(
-        &mut self,
-        id: u32,
-        message: Packet,
-    ) -> Result<StackerDBChunkAckData, ClientError> {
-        let message_bytes = bincode::serialize(&message)?;
-        let slot_id = slot_id(id, &message.msg);
-
-        loop {
-            let slot_version = *self.slot_versions.entry(slot_id).or_insert(0) + 1;
-            let mut chunk = StackerDBChunkData::new(slot_id, slot_version, message_bytes.clone());
-            chunk.sign(&self.stacks_private_key)?;
-            debug!("Sending a chunk to stackerdb!\n{:?}", chunk.clone());
-            let send_request = || {
-                self.stackerdb_session
-                    .put_chunk(chunk.clone())
-                    .map_err(backoff::Error::transient)
-            };
-            let chunk_ack: StackerDBChunkAckData = retry_with_exponential_backoff(send_request)?;
-            self.slot_versions.insert(slot_id, slot_version);
-
-            if chunk_ack.accepted {
-                debug!("Chunk accepted by stackerdb: {:?}", chunk_ack);
-                return Ok(chunk_ack);
-            } else {
-                warn!("Chunk rejected by stackerdb: {:?}", chunk_ack);
-            }
-            if let Some(reason) = chunk_ack.reason {
-                // TODO: fix this jankiness. Update stackerdb to use an error code mapping instead of just a string
-                // See: https://github.com/stacks-network/stacks-blockchain/issues/3917
-                if reason == "Data for this slot and version already exist" {
-                    warn!("Failed to send message to stackerdb due to wrong version number {}. Incrementing and retrying...", slot_version);
-                } else {
-                    warn!("Failed to send message to stackerdb: {}", reason);
-                    return Err(ClientError::PutChunkRejected(reason));
-                }
-            }
-        }
-    }
-
-    /// Retrieve the current DKG aggregate public key
-    pub fn get_aggregate_public_key(&self) -> Result<Option<Point>, ClientError> {
-        let reward_cycle = self.get_current_reward_cycle()?;
-        let function_name_str = "get-aggregate-public-key"; // FIXME: this may need to be modified to match .pox-4
-        let function_name = ClarityName::try_from(function_name_str)
-            .map_err(|_| ClientError::InvalidClarityName(function_name_str.to_string()))?;
-        let (contract_addr, contract_name) = self.get_pox_contract()?;
-        let function_args = &[ClarityValue::UInt(reward_cycle as u128)];
-        let contract_response_hex = self.read_only_contract_call_with_retry(
-            &contract_addr,
-            &contract_name,
-            &function_name,
-            function_args,
-        )?;
-        self.parse_aggregate_public_key(&contract_response_hex)
-    }
-
-    /// Retrieve the total number of slots allocated to a stacker-db writer
-    #[allow(dead_code)]
-    pub fn slots_per_user(&self) -> u32 {
-        // TODO: retrieve this from the stackerdb instance and make it a function of a given signer public key
-        // See: https://github.com/stacks-network/stacks-blockchain/issues/3921
-        SLOTS_PER_USER
-    }
-
-    /// Helper function to retrieve the current reward cycle number from the stacks node
-    fn get_current_reward_cycle(&self) -> Result<u64, ClientError> {
-        let send_request = || {
-            self.stacks_node_client
-                .get(self.pox_path())
-                .send()
-                .map_err(backoff::Error::transient)
-        };
-        let response = retry_with_exponential_backoff(send_request)?;
-        if !response.status().is_success() {
-            return Err(ClientError::RequestFailure(response.status()));
-        }
-        let json_response = response.json::<serde_json::Value>()?;
-        let entry = "current_cycle";
-        json_response
-            .get(entry)
-            .and_then(|cycle: &serde_json::Value| cycle.get("id"))
-            .and_then(|id| id.as_u64())
-            .ok_or_else(|| ClientError::InvalidJsonEntry(format!("{}.id", entry)))
-    }
-
-    /// Helper function to retrieve the next possible nonce for the signer from the stacks node
-    #[allow(dead_code)]
-    fn get_next_possible_nonce(&self) -> Result<u64, ClientError> {
-        //FIXME: use updated RPC call to get mempool nonces. Depends on https://github.com/stacks-network/stacks-blockchain/issues/4000
-        todo!("Get the next possible nonce from the stacks node");
-    }
-
-    /// Helper function to retrieve the pox contract address and name from the stacks node
-    fn get_pox_contract(&self) -> Result<(StacksAddress, ContractName), ClientError> {
-        // Check if we have overwritten the pox contract ID in the config
-        if let Some(pox_contract) = self.pox_contract_id.clone() {
-            return Ok((pox_contract.issuer.into(), pox_contract.name));
-        }
-        // TODO: we may want to cache the pox contract inside the client itself (calling this function once on init)
-        // https://github.com/stacks-network/stacks-blockchain/issues/4005
-        let send_request = || {
-            self.stacks_node_client
-                .get(self.pox_path())
-                .send()
-                .map_err(backoff::Error::transient)
-        };
-        let response = retry_with_exponential_backoff(send_request)?;
-        if !response.status().is_success() {
-            return Err(ClientError::RequestFailure(response.status()));
-        }
-        let json_response = response.json::<serde_json::Value>()?;
-        let entry = "contract_id";
-        let contract_id_string = json_response
-            .get(entry)
-            .and_then(|id: &serde_json::Value| id.as_str())
-            .ok_or_else(|| ClientError::InvalidJsonEntry(entry.to_string()))?;
-        let id = QualifiedContractIdentifier::parse(contract_id_string).unwrap();
-        Ok((id.issuer.into(), id.name))
-    }
-
-    /// Helper function that attempts to deserialize a clarity hex string as the aggregate public key
-    fn parse_aggregate_public_key(&self, hex: &str) -> Result<Option<Point>, ClientError> {
-        let public_key_clarity_value = ClarityValue::try_deserialize_hex_untyped(hex)?;
-        if let ClarityValue::Optional(optional_data) = public_key_clarity_value.clone() {
-            if let Some(ClarityValue::Sequence(SequenceData::Buffer(public_key))) =
-                optional_data.data.map(|boxed| *boxed)
-            {
-                if public_key.data.len() != 32 {
-                    return Err(ClientError::MalformedClarityValue(public_key_clarity_value));
-                }
-                let mut bytes = [0_u8; 32];
-                bytes.copy_from_slice(&public_key.data);
-                Ok(Some(Point::from(Scalar::from(bytes))))
-            } else {
-                Ok(None)
-            }
-        } else {
-            Err(ClientError::MalformedClarityValue(public_key_clarity_value))
-        }
-    }
-
-    /// Sends a transaction to the stacks node for a modifying contract call
-    #[allow(dead_code)]
-    fn transaction_contract_call(
-        &self,
-        contract_addr: &StacksAddress,
-        contract_name: ContractName,
-        function_name: ClarityName,
-        function_args: &[ClarityValue],
-    ) -> Result<Txid, ClientError> {
-        debug!("Making a contract call to {contract_addr}.{contract_name}...");
-        let signed_tx = self.build_signed_transaction(
-            contract_addr,
-            contract_name,
-            function_name,
-            function_args,
-        )?;
-        self.submit_tx(&signed_tx)
-    }
-
-    /// Helper function to create a stacks transaction for a modifying contract call
-    fn build_signed_transaction(
-        &self,
-        contract_addr: &StacksAddress,
-        contract_name: ContractName,
-        function_name: ClarityName,
-        function_args: &[ClarityValue],
-    ) -> Result<StacksTransaction, ClientError> {
-        let tx_payload = TransactionPayload::ContractCall(TransactionContractCall {
-            address: *contract_addr,
-            contract_name,
-            function_name,
-            function_args: function_args.to_vec(),
-        });
-        let public_key = StacksPublicKey::from_private(&self.stacks_private_key);
-        let tx_auth = TransactionAuth::Standard(
-            TransactionSpendingCondition::new_singlesig_p2pkh(public_key).ok_or(
-                ClientError::TransactionGenerationFailure(format!(
-                    "Failed to create spending condition from public key: {}",
-                    public_key.to_hex()
-                )),
-            )?,
-        );
-
-        let mut unsigned_tx = StacksTransaction::new(self.tx_version, tx_auth, tx_payload);
-
-        // FIXME: Because signers are given priority, we can put down a tx fee of 0
-        // https://github.com/stacks-network/stacks-blockchain/issues/4006
-        // Note: if set to 0 now, will cause a failure (MemPoolRejection::FeeTooLow)
-        unsigned_tx.set_tx_fee(10_000);
-        unsigned_tx.set_origin_nonce(self.get_next_possible_nonce()?);
-
-        unsigned_tx.anchor_mode = TransactionAnchorMode::Any;
-        unsigned_tx.post_condition_mode = TransactionPostConditionMode::Allow;
-        unsigned_tx.chain_id = self.chain_id;
-
-        let mut tx_signer = StacksTransactionSigner::new(&unsigned_tx);
-        tx_signer
-            .sign_origin(&self.stacks_private_key)
-            .map_err(|e| ClientError::TransactionGenerationFailure(e.to_string()))?;
-
-        tx_signer
-            .get_tx()
-            .ok_or(ClientError::TransactionGenerationFailure(
-                "Failed to generate transaction from a transaction signer".to_string(),
-            ))
-    }
-
-    /// Helper function to submit a transaction to the Stacks node
-    fn submit_tx(&self, tx: &StacksTransaction) -> Result<Txid, ClientError> {
-        let txid = tx.txid();
-        let tx = tx.serialize_to_vec();
-        let send_request = || {
-            self.stacks_node_client
-                .post(self.transaction_path())
-                .header("Content-Type", "application/octet-stream")
-                .body(tx.clone())
-                .send()
-                .map_err(backoff::Error::transient)
-        };
-        let response = retry_with_exponential_backoff(send_request)?;
-        if !response.status().is_success() {
-            return Err(ClientError::RequestFailure(response.status()));
-        }
-        Ok(txid)
-    }
-
-    /// Makes a read only contract call to a stacks contract
-    pub fn read_only_contract_call_with_retry(
-        &self,
-        contract_addr: &StacksAddress,
-        contract_name: &ContractName,
-        function_name: &ClarityName,
-        function_args: &[ClarityValue],
-    ) -> Result<String, ClientError> {
-        debug!("Calling read-only function {}...", function_name);
-        let args = function_args
-            .iter()
-            .map(|arg| arg.serialize_to_hex())
-            .collect::<Vec<String>>();
-        let body =
-            json!({"sender": self.stacks_address.to_string(), "arguments": args}).to_string();
-        let path = self.read_only_path(contract_addr, contract_name, function_name);
-        let send_request = || {
-            self.stacks_node_client
-                .post(path.clone())
-                .header("Content-Type", "application/json")
-                .body(body.clone())
-                .send()
-                .map_err(backoff::Error::transient)
-        };
-        let response = retry_with_exponential_backoff(send_request)?;
-        if !response.status().is_success() {
-            return Err(ClientError::RequestFailure(response.status()));
-        }
-        let response = response.json::<serde_json::Value>()?;
-        if !response
-            .get("okay")
-            .map(|val| val.as_bool().unwrap_or(false))
-            .unwrap_or(false)
-        {
-            let cause = response
-                .get("cause")
-                .ok_or(ClientError::InvalidJsonEntry("cause".to_string()))?;
-            return Err(ClientError::ReadOnlyFailure(format!(
-                "{}: {}",
-                function_name, cause
-            )));
-        }
-        let result = response
-            .get("result")
-            .ok_or(ClientError::InvalidJsonEntry("result".to_string()))?
-            .as_str()
-            .ok_or_else(|| ClientError::ReadOnlyFailure("Expected string result.".to_string()))?
-            .to_string();
-        Ok(result)
-    }
-
-    fn pox_path(&self) -> String {
-        format!("{}/v2/pox", self.http_origin)
-    }
-
-    fn transaction_path(&self) -> String {
-        format!("{}/v2/transactions", self.http_origin)
-    }
-
-    fn read_only_path(
-        &self,
-        contract_addr: &StacksAddress,
-        contract_name: &ContractName,
-        function_name: &ClarityName,
-    ) -> String {
-        format!(
-            "{}/v2/contracts/call-read/{contract_addr}/{contract_name}/{function_name}",
-            self.http_origin
-        )
-    }
-}
-
-/// Retry a function F with an exponential backoff and notification on transient failure
-pub fn retry_with_exponential_backoff<F, E, T>(request_fn: F) -> Result<T, ClientError>
-where
-    F: FnMut() -> Result<T, backoff::Error<E>>,
-{
-    let notify = |_err, dur| {
-        debug!(
-            "Failed to connect to stacks-node. Next attempt in {:?}",
-            dur
-        );
-    };
-
-    let backoff_timer = backoff::ExponentialBackoffBuilder::new()
-        .with_initial_interval(Duration::from_millis(BACKOFF_INITIAL_INTERVAL))
-        .with_max_interval(Duration::from_millis(BACKOFF_MAX_INTERVAL))
-        .build();
-
-    backoff::retry_notify(backoff_timer, request_fn, notify).map_err(|_| ClientError::RetryTimeout)
-}
-
-/// Helper function to determine the slot ID for the provided stacker-db writer id and the message type
-fn slot_id(id: u32, message: &Message) -> u32 {
-    let slot_id = match message {
-        Message::DkgBegin(_) => 0,
-        Message::DkgPrivateBegin(_) => 1,
-        Message::DkgEnd(_) => 2,
-        Message::DkgPublicShares(_) => 4,
-        Message::DkgPrivateShares(_) => 5,
-        Message::NonceRequest(_) => 6,
-        Message::NonceResponse(_) => 7,
-        Message::SignatureShareRequest(_) => 8,
-        Message::SignatureShareResponse(_) => 9,
-    };
-    SLOTS_PER_USER * id + slot_id
-}
-
-#[cfg(test)]
-mod tests {
-    use std::io::{BufWriter, Read, Write};
-    use std::net::{SocketAddr, TcpListener};
-    use std::thread::spawn;
-
-    use super::*;
-
-    struct TestConfig {
-        mock_server: TcpListener,
-        client: StacksClient,
-    }
-
-    impl TestConfig {
-        pub fn new() -> Self {
-            let mut config = Config::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
-
-            let mut mock_server_addr = SocketAddr::from(([127, 0, 0, 1], 0));
-            // Ask the OS to assign a random port to listen on by passing 0
-            let mock_server = TcpListener::bind(mock_server_addr).unwrap();
-
-            // Update the config to use this port
-            mock_server_addr.set_port(mock_server.local_addr().unwrap().port());
-            config.node_host = mock_server_addr;
-
-            let client = StacksClient::from(&config);
-            Self {
-                mock_server,
-                client,
-            }
-        }
-    }
-
-    fn write_response(mock_server: TcpListener, bytes: &[u8]) -> [u8; 1024] {
-        debug!("Writing a response...");
-        let mut request_bytes = [0u8; 1024];
-        {
-            let mut stream = mock_server.accept().unwrap().0;
-            let _ = stream.read(&mut request_bytes).unwrap();
-            stream.write_all(bytes).unwrap();
-        }
-        request_bytes
-    }
-
-    #[test]
-    fn read_only_contract_call_200_success() {
-        let config = TestConfig::new();
-        let h = spawn(move || {
-            config.client.read_only_contract_call_with_retry(
-                &config.client.stacks_address,
-                &ContractName::try_from("contract-name").unwrap(),
-                &ClarityName::try_from("function-name").unwrap(),
-                &[],
-            )
-        });
-        write_response(
-            config.mock_server,
-            b"HTTP/1.1 200 OK\n\n{\"okay\":true,\"result\":\"0x070d0000000473425443\"}",
-        );
-        let result = h.join().unwrap().unwrap();
-        assert_eq!(result, "0x070d0000000473425443");
-    }
-
-    #[test]
-    fn read_only_contract_call_with_function_args_200_success() {
-        let config = TestConfig::new();
-        let h = spawn(move || {
-            config.client.read_only_contract_call_with_retry(
-                &config.client.stacks_address,
-                &ContractName::try_from("contract-name").unwrap(),
-                &ClarityName::try_from("function-name").unwrap(),
-                &[ClarityValue::UInt(10_u128)],
-            )
-        });
-        write_response(
-            config.mock_server,
-            b"HTTP/1.1 200 OK\n\n{\"okay\":true,\"result\":\"0x070d0000000473425443\"}",
-        );
-        let result = h.join().unwrap().unwrap();
-        assert_eq!(result, "0x070d0000000473425443");
-    }
-
-    #[test]
-    fn read_only_contract_call_200_failure() {
-        let config = TestConfig::new();
-        let h = spawn(move || {
-            config.client.read_only_contract_call_with_retry(
-                &config.client.stacks_address,
-                &ContractName::try_from("contract-name").unwrap(),
-                &ClarityName::try_from("function-name").unwrap(),
-                &[],
-            )
-        });
-        write_response(
-            config.mock_server,
-            b"HTTP/1.1 200 OK\n\n{\"okay\":false,\"cause\":\"Some reason\"}",
-        );
-        let result = h.join().unwrap();
-        assert!(matches!(result, Err(ClientError::ReadOnlyFailure(_))));
-    }
-
-    #[test]
-    fn read_only_contract_call_400_failure() {
-        let config = TestConfig::new();
-        // Simulate a 400 Bad Request response
-        let h = spawn(move || {
-            config.client.read_only_contract_call_with_retry(
-                &config.client.stacks_address,
-                &ContractName::try_from("contract-name").unwrap(),
-                &ClarityName::try_from("function-name").unwrap(),
-                &[],
-            )
-        });
-        write_response(config.mock_server, b"HTTP/1.1 400 Bad Request\n\n");
-        let result = h.join().unwrap();
-        assert!(matches!(
-            result,
-            Err(ClientError::RequestFailure(
-                reqwest::StatusCode::BAD_REQUEST
-            ))
-        ));
-    }
-
-    #[test]
-    fn read_only_contract_call_404_failure() {
-        let config = TestConfig::new();
-        // Simulate a 400 Bad Request response
-        let h = spawn(move || {
-            config.client.read_only_contract_call_with_retry(
-                &config.client.stacks_address,
-                &ContractName::try_from("contract-name").unwrap(),
-                &ClarityName::try_from("function-name").unwrap(),
-                &[],
-            )
-        });
-        write_response(config.mock_server, b"HTTP/1.1 404 Not Found\n\n");
-        let result = h.join().unwrap();
-        assert!(matches!(
-            result,
-            Err(ClientError::RequestFailure(reqwest::StatusCode::NOT_FOUND))
-        ));
-    }
-
-    #[test]
-    fn pox_contract_success() {
-        let config = TestConfig::new();
-        let h = spawn(move || config.client.get_pox_contract());
-        write_response(
-            config.mock_server,
-            b"HTTP/1.1 200 Ok\n\n{\"contract_id\":\"ST000000000000000000002AMW42H.pox-3\"}",
-        );
-        let (address, name) = h.join().unwrap().unwrap();
-        assert_eq!(
-            (address.to_string().as_str(), name.to_string().as_str()),
-            ("ST000000000000000000002AMW42H", "pox-3")
-        );
-    }
-
-    #[test]
-    fn valid_reward_cycle_should_succeed() {
-        let config = TestConfig::new();
-        let h = spawn(move || config.client.get_current_reward_cycle());
-        write_response(
-            config.mock_server,
-            b"HTTP/1.1 200 Ok\n\n{\"current_cycle\":{\"id\":506,\"min_threshold_ustx\":5190000000000,\"stacked_ustx\":5690000000000,\"is_pox_active\":false}}",
-        );
-        let current_cycle_id = h.join().unwrap().unwrap();
-        assert_eq!(506, current_cycle_id);
-    }
-
-    #[test]
-    fn invalid_reward_cycle_should_fail() {
-        let config = TestConfig::new();
-        let h = spawn(move || config.client.get_current_reward_cycle());
-        write_response(
-            config.mock_server,
-            b"HTTP/1.1 200 Ok\n\n{\"current_cycle\":{\"id\":\"fake id\", \"is_pox_active\":false}}",
-        );
-        let res = h.join().unwrap();
-        assert!(matches!(res, Err(ClientError::InvalidJsonEntry(_))));
-    }
-
-    #[test]
-    fn missing_reward_cycle_should_fail() {
-        let config = TestConfig::new();
-        let h = spawn(move || config.client.get_current_reward_cycle());
-        write_response(
-            config.mock_server,
-            b"HTTP/1.1 200 Ok\n\n{\"current_cycle\":{\"is_pox_active\":false}}",
-        );
-        let res = h.join().unwrap();
-        assert!(matches!(res, Err(ClientError::InvalidJsonEntry(_))));
-    }
-
-    #[test]
-    fn parse_valid_aggregate_public_key_should_succeed() {
-        let config = TestConfig::new();
-        let clarity_value_hex =
-            "0x0a0200000020b8c8b0652cb2851a52374c7acd47181eb031e8fa5c62883f636e0d4fe695d6ca";
-        let result = config
-            .client
-            .parse_aggregate_public_key(clarity_value_hex)
-            .unwrap();
-        assert_eq!(
-            result.map(|point| point.to_string()),
-            Some("yzwdjwPz36Has1MSkg8JGwo38avvATkiTZvRiH1e5MLd".to_string())
-        );
-
-        let clarity_value_hex = "0x09";
-        let result = config
-            .client
-            .parse_aggregate_public_key(clarity_value_hex)
-            .unwrap();
-        assert!(result.is_none());
-    }
-
-    #[test]
-    fn parse_invalid_aggregate_public_key_should_fail() {
-        let config = TestConfig::new();
-        let clarity_value_hex = "0x00";
-        let result = config.client.parse_aggregate_public_key(clarity_value_hex);
-        assert!(matches!(
-            result,
-            Err(ClientError::ClaritySerializationError(..))
-        ));
-        // TODO: add further tests for malformed clarity values (an optional of any other type for example)
-    }
-
-    #[ignore]
-    #[test]
-    fn transaction_contract_call_should_send_bytes_to_node() {
-        let config = TestConfig::new();
-        let tx = config
-            .client
-            .build_signed_transaction(
-                &config.client.stacks_address,
-                ContractName::try_from("contract-name").unwrap(),
-                ClarityName::try_from("function-name").unwrap(),
-                &[],
-            )
-            .unwrap();
-
-        let mut tx_bytes = [0u8; 1024];
-        {
-            let mut tx_bytes_writer = BufWriter::new(&mut tx_bytes[..]);
-            tx.consensus_serialize(&mut tx_bytes_writer).unwrap();
-            tx_bytes_writer.flush().unwrap();
-        }
-
-        let bytes_len = tx_bytes
-            .iter()
-            .enumerate()
-            .rev()
-            .find(|(_, &x)| x != 0)
-            .unwrap()
-            .0
-            + 1;
-
-        let tx_clone = tx.clone();
-        let h = spawn(move || config.client.submit_tx(&tx_clone));
-
-        let request_bytes = write_response(
-            config.mock_server,
-            format!("HTTP/1.1 200 OK\n\n{}", tx.txid()).as_bytes(),
-        );
-        let returned_txid = h.join().unwrap().unwrap();
-
-        assert_eq!(returned_txid, tx.txid());
-        assert!(
-            request_bytes
-                .windows(bytes_len)
-                .any(|window| window == &tx_bytes[..bytes_len]),
-            "Request bytes did not contain the transaction bytes"
-        );
-    }
-
-    #[ignore]
-    #[test]
-    fn transaction_contract_call_should_succeed() {
-        let config = TestConfig::new();
-        let h = spawn(move || {
-            config.client.transaction_contract_call(
-                &config.client.stacks_address,
-                ContractName::try_from("contract-name").unwrap(),
-                ClarityName::try_from("function-name").unwrap(),
-                &[],
-            )
-        });
-        write_response(
-            config.mock_server,
-            b"HTTP/1.1 200 OK\n\n4e99f99bc4a05437abb8c7d0c306618f45b203196498e2ebe287f10497124958",
-        );
-        assert!(h.join().unwrap().is_ok());
-    }
-}

From 927c466de7338504bcbc4f50479d6b0735e7f925 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 6 Dec 2023 14:55:01 -0500
Subject: [PATCH 0361/1166] Filter out message types from the signer and miner
 StackerDBMessages

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/stackerdb.rs |  3 ++
 stacks-signer/src/runloop.rs          | 65 ++++++++++++++++++++++-----
 2 files changed, 57 insertions(+), 11 deletions(-)

diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index 8e776e935f..01bc12d9a9 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -35,6 +35,9 @@ const BLOCK_SLOT_ID: u32 = 9;
 /// The StackerDB messages that can be sent through the .signers contract
 pub enum StackerDBMessage {
     /// The latest Nakamoto block for miners to observe
+    // TODO: update this to use a struct that lists optional error code if the block is invalid
+    // to prove that the signers have considered the block but rejected it. This should include
+    // hints about how to fix the block
     Block(NakamotoBlock),
     /// DKG and Signing round data for other signers to observe
     Packet(Packet),
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 7f36cc0955..786119d73f 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -5,6 +5,7 @@ use std::time::Duration;
 use hashbrown::{HashMap, HashSet};
 use libsigner::{SignerRunLoop, StackerDBChunksEvent};
 use slog::{slog_debug, slog_error, slog_info, slog_warn};
+use stacks_common::codec::{read_next, StacksMessageCodec};
 use stacks_common::{debug, error, info, warn};
 use wsts::common::MerkleRoot;
 use wsts::curve::ecdsa;
@@ -15,7 +16,9 @@ use wsts::state_machine::signer::Signer;
 use wsts::state_machine::{OperationResult, PublicKeys};
 use wsts::v2;
 
-use crate::client::{retry_with_exponential_backoff, ClientError, StackerDB, StacksClient};
+use crate::client::{
+    retry_with_exponential_backoff, ClientError, StackerDB, StackerDBMessage, StacksClient,
+};
 use crate::config::Config;
 
 /// Which operation to perform
@@ -167,11 +170,36 @@ impl<C: Coordinator> RunLoop<C> {
     }
 
     /// Process the event as a miner message from the miner stacker-db
-    fn process_event_miner(
-        &mut self,
-        _event: &StackerDBChunksEvent,
-    ) -> (Vec<Packet>, Vec<OperationResult>) {
-        todo!("Process miner event")
+    fn process_event_miner(&mut self, event: &StackerDBChunksEvent) {
+        // Determine the current coordinator id and public key for verification
+        let (coordinator_id, _coordinator_public_key) =
+            calculate_coordinator(&self.signing_round.public_keys);
+        event.modified_slots.iter().for_each(|chunk| {
+            let mut ptr = &chunk.data[..];
+            let Some(stacker_db_message) = read_next::<StackerDBMessage, _>(&mut ptr).ok() else {
+                warn!("Received an unrecognized message type from .miners stacker-db slot id {}: {:?}", chunk.slot_id, ptr);
+                return;
+            };
+            match stacker_db_message {
+                StackerDBMessage::Packet(_packet) => {
+                    // We should never actually be receiving packets from the miner stacker-db.
+                    warn!(
+                        "Received a packet from the miner stacker-db. This should never happen..."
+                    );
+                }
+                StackerDBMessage::Block(block) => {
+                    // Received a block proposal from the miner.
+                    // If the signer is the coordinator, then trigger a Signing round for the block
+                    if coordinator_id == self.signing_round.signer_id {
+                        self.commands.push_back(RunLoopCommand::Sign {
+                            message: block.serialize_to_vec(),
+                            is_taproot: false,
+                            merkle_root: None,
+                        });
+                    }
+                }
+            }
+        });
     }
 
     /// Process the event as a signer message from the signer stacker-db
@@ -184,11 +212,26 @@ impl<C: Coordinator> RunLoop<C> {
             .modified_slots
             .iter()
             .filter_map(|chunk| {
-                let packet = bincode::deserialize::<Packet>(&chunk.data).ok()?;
-                if packet.verify(&self.signing_round.public_keys, coordinator_public_key) {
-                    Some(packet)
-                } else {
-                    None
+                let mut ptr = &chunk.data[..];
+                let Some(stacker_db_message) = read_next::<StackerDBMessage, _>(&mut ptr).ok() else {
+                    warn!("Received an unrecognized message type from .signers stacker-db slot id {}: {:?}", chunk.slot_id, ptr);
+                    return None;
+                };
+                match stacker_db_message {
+                    StackerDBMessage::Packet(packet) => {
+                        if packet.verify(
+                            &self.signing_round.public_keys,
+                            coordinator_public_key,
+                        ) {
+                            Some(packet)
+                        } else {
+                            None
+                        }
+                    }
+                    StackerDBMessage::Block(_block) => {
+                        // Blocks are meant to be read by observing miners. Ignore them.
+                        None
+                    }
                 }
             })
             .collect();

From 9f9eb274abecc2095a07eb3fda02cfa8175b09d4 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 6 Dec 2023 14:55:33 -0500
Subject: [PATCH 0362/1166] Add serde to StackerDBMessage types

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/stackerdb.rs | 156 +++++++++++++++++++++++++-
 1 file changed, 151 insertions(+), 5 deletions(-)

diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index 01bc12d9a9..62d2e80ed4 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -32,6 +32,33 @@ const SIGNATURE_SHARE_REQUEST_SLOT_ID: u32 = 7;
 const SIGNATURE_SHARE_RESPONSE_SLOT_ID: u32 = 8;
 const BLOCK_SLOT_ID: u32 = 9;
 
+/// This is required for easy serialization of the various StackerDBMessage types
+#[repr(u8)]
+enum TypePrefix {
+    Block,
+    Packet,
+}
+
+impl TypePrefix {
+    /// Convert a u8 to a TypePrefix
+    fn from_u8(value: u8) -> Option<Self> {
+        match value {
+            0 => Some(Self::Block),
+            1 => Some(Self::Packet),
+            _ => None,
+        }
+    }
+}
+
+impl From<&StackerDBMessage> for TypePrefix {
+    fn from(message: &StackerDBMessage) -> TypePrefix {
+        match message {
+            StackerDBMessage::Block(_) => TypePrefix::Block,
+            StackerDBMessage::Packet(_) => TypePrefix::Packet,
+        }
+    }
+}
+
 /// The StackerDB messages that can be sent through the .signers contract
 pub enum StackerDBMessage {
     /// The latest Nakamoto block for miners to observe
@@ -50,12 +77,39 @@ impl From<Packet> for StackerDBMessage {
 }
 
 impl StacksMessageCodec for StackerDBMessage {
-    fn consensus_serialize<W: std::io::Write>(&self, _fd: &mut W) -> Result<(), CodecError> {
-        todo!()
+    fn consensus_serialize<W: std::io::Write>(&self, fd: &mut W) -> Result<(), CodecError> {
+        fd.write_all(&[TypePrefix::from(self) as u8])
+            .map_err(CodecError::WriteError)?;
+        match self {
+            StackerDBMessage::Packet(packet) => {
+                let message_bytes = bincode::serialize(&packet)
+                    .map_err(|e| CodecError::SerializeError(e.to_string()))?;
+                message_bytes.consensus_serialize(fd)
+            }
+            StackerDBMessage::Block(block) => block.consensus_serialize(fd),
+        }
     }
 
-    fn consensus_deserialize<R: std::io::Read>(_fd: &mut R) -> Result<Self, CodecError> {
-        todo!()
+    fn consensus_deserialize<R: std::io::Read>(fd: &mut R) -> Result<Self, CodecError> {
+        let mut prefix = [0];
+        fd.read_exact(&mut prefix)
+            .map_err(|e| CodecError::DeserializeError(e.to_string()))?;
+        let prefix = TypePrefix::from_u8(prefix[0]).ok_or(CodecError::DeserializeError(
+            "Bad StackerDBMessage prefix".into(),
+        ))?;
+
+        match prefix {
+            TypePrefix::Packet => {
+                let message_bytes = Vec::<u8>::consensus_deserialize(fd)?;
+                let packet = bincode::deserialize(&message_bytes)
+                    .map_err(|e| CodecError::DeserializeError(e.to_string()))?;
+                Ok(Self::Packet(packet))
+            }
+            TypePrefix::Block => {
+                let block = NakamotoBlock::consensus_deserialize(fd)?;
+                Ok(StackerDBMessage::Block(block))
+            }
+        }
     }
 }
 
@@ -162,4 +216,96 @@ impl StackerDB {
 }
 
 #[cfg(test)]
-mod tests {}
+mod tests {
+    use blockstack_lib::chainstate::nakamoto::{NakamotoBlock, NakamotoBlockHeader};
+    use blockstack_lib::chainstate::stacks::StacksTransaction;
+    use rand_core::OsRng;
+    use stacks_common::codec::StacksMessageCodec;
+    use stacks_common::types::chainstate::{ConsensusHash, StacksBlockId, TrieHash};
+    use stacks_common::util::hash::{MerkleTree, Sha512Trunc256Sum};
+    use stacks_common::util::secp256k1::{MessageSignature, SchnorrSignature};
+    use wsts::curve::scalar::Scalar;
+    use wsts::net::{Message, Packet, Signable, SignatureShareRequest};
+
+    use super::StackerDBMessage;
+
+    #[test]
+    fn serde_stackerdb_message_block() {
+        let txs: Vec<StacksTransaction> = vec![];
+        let mut header = NakamotoBlockHeader {
+            version: 1,
+            chain_length: 2,
+            burn_spent: 3,
+            consensus_hash: ConsensusHash([0x04; 20]),
+            parent_block_id: StacksBlockId([0x05; 32]),
+            tx_merkle_root: Sha512Trunc256Sum([0x06; 32]),
+            state_index_root: TrieHash([0x07; 32]),
+            miner_signature: MessageSignature::empty(),
+            signer_signature: SchnorrSignature::default(),
+        };
+        let txid_vecs = txs.iter().map(|tx| tx.txid().as_bytes().to_vec()).collect();
+
+        let merkle_tree = MerkleTree::<Sha512Trunc256Sum>::new(&txid_vecs);
+        let tx_merkle_root = merkle_tree.root();
+
+        header.tx_merkle_root = tx_merkle_root;
+
+        let block = NakamotoBlock { header, txs };
+
+        let msg = StackerDBMessage::Block(block.clone());
+        let serialized_bytes = msg.serialize_to_vec();
+        let deserialized_msg =
+            StackerDBMessage::consensus_deserialize(&mut &serialized_bytes[..]).unwrap();
+        match deserialized_msg {
+            StackerDBMessage::Block(deserialized_block) => {
+                assert_eq!(deserialized_block, block);
+            }
+            _ => panic!("Wrong message type. Expected StackerDBMessage::Block"),
+        }
+    }
+
+    #[test]
+    fn serde_stackerdb_message_packet() {
+        let mut rng = OsRng;
+        let private_key = Scalar::random(&mut rng);
+        let to_sign = "One, two, three, four, five? That's amazing. I've got the same combination on my luggage.".as_bytes();
+        let sig_share_request = SignatureShareRequest {
+            dkg_id: 1,
+            sign_id: 5,
+            sign_iter_id: 4,
+            nonce_responses: vec![],
+            message: to_sign.to_vec(),
+            is_taproot: false,
+            merkle_root: None,
+        };
+        let packet = Packet {
+            sig: sig_share_request
+                .sign(&private_key)
+                .expect("Failed to sign SignatureShareRequest"),
+            msg: Message::SignatureShareRequest(sig_share_request),
+        };
+
+        let msg = StackerDBMessage::Packet(packet.clone());
+        let serialized_bytes = msg.serialize_to_vec();
+        let deserialized_msg =
+            StackerDBMessage::consensus_deserialize(&mut &serialized_bytes[..]).unwrap();
+        match deserialized_msg {
+            StackerDBMessage::Packet(deserialized_packet) => {
+                assert_eq!(deserialized_packet.sig, packet.sig);
+                match deserialized_packet.msg {
+                    Message::SignatureShareRequest(deserialized_message) => {
+                        assert_eq!(deserialized_message.dkg_id, 1);
+                        assert_eq!(deserialized_message.sign_id, 5);
+                        assert_eq!(deserialized_message.sign_iter_id, 4);
+                        assert!(deserialized_message.nonce_responses.is_empty());
+                        assert_eq!(deserialized_message.message.as_slice(), to_sign);
+                        assert!(!deserialized_message.is_taproot);
+                        assert!(deserialized_message.merkle_root.is_none());
+                    }
+                    _ => panic!("Wrong message type. Expected Message::SignatureShareRequest"),
+                }
+            }
+            _ => panic!("Wrong message type. Expected StackerDBMessage::Packet."),
+        }
+    }
+}

From f9c887d2f57e449bf7de55f40c9fb01b5ff87faa Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 6 Dec 2023 15:48:56 -0500
Subject: [PATCH 0363/1166] Add TODO for miner public key verification

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/stackerdb.rs     |  1 +
 stacks-signer/src/client/stacks_client.rs | 27 +++++++++++++++++++++++
 stacks-signer/src/runloop.rs              | 22 ++++++++++++++++++
 3 files changed, 50 insertions(+)

diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index 62d2e80ed4..ed97adcc50 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -65,6 +65,7 @@ pub enum StackerDBMessage {
     // TODO: update this to use a struct that lists optional error code if the block is invalid
     // to prove that the signers have considered the block but rejected it. This should include
     // hints about how to fix the block
+    // Update to use NakamotoBlockProposal. Depends on https://github.com/stacks-network/stacks-core/pull/4084
     Block(NakamotoBlock),
     /// DKG and Signing round data for other signers to observe
     Packet(Packet),
diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index e1fbbb61cd..d3fb3c570f 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -1,4 +1,5 @@
 use blockstack_lib::burnchains::Txid;
+use blockstack_lib::chainstate::nakamoto::NakamotoBlock;
 use blockstack_lib::chainstate::stacks::{
     StacksTransaction, StacksTransactionSigner, TransactionAnchorMode, TransactionAuth,
     TransactionContractCall, TransactionPayload, TransactionPostConditionMode,
@@ -50,6 +51,28 @@ impl From<&Config> for StacksClient {
 }
 
 impl StacksClient {
+    /// Retrieve the current miner public key
+    pub fn get_miner_public_key(&self) -> Result<StacksPublicKey, ClientError> {
+        // TODO: Depends on https://github.com/stacks-network/stacks-core/issues/4018
+        todo!("Get the miner public key from the stacks node to verify the miner blocks were signed by the correct miner");
+    }
+
+    /// Check if the proposed Nakamoto block is a valid block
+    pub fn is_valid_nakamoto_block(&self, _block: &NakamotoBlock) -> Result<bool, ClientError> {
+        // TODO: Depends on https://github.com/stacks-network/stacks-core/issues/3866 
+        let send_request = || {
+            self.stacks_node_client
+                .get(self.block_proposal_path())
+                .send()
+                .map_err(backoff::Error::transient)
+        };
+        let response = retry_with_exponential_backoff(send_request)?;
+        if !response.status().is_success() {
+            return Err(ClientError::RequestFailure(response.status()));
+        }
+        todo!("Call the appropriate RPC endpoint to check if the proposed Nakamoto block is valid");
+    }
+
     /// Retrieve the current DKG aggregate public key
     pub fn get_aggregate_public_key(&self) -> Result<Option<Point>, ClientError> {
         let reward_cycle = self.get_current_reward_cycle()?;
@@ -300,6 +323,10 @@ impl StacksClient {
             self.http_origin
         )
     }
+
+    fn block_proposal_path(&self) -> String {
+        format!("{}/v2/block-proposal", self.http_origin)
+    }
 }
 
 #[cfg(test)]
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 786119d73f..f3df4bac03 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -191,6 +191,27 @@ impl<C: Coordinator> RunLoop<C> {
                     // Received a block proposal from the miner.
                     // If the signer is the coordinator, then trigger a Signing round for the block
                     if coordinator_id == self.signing_round.signer_id {
+                        // Don't bother triggering a signing round for the block if it is invalid
+                        if !self.stacks_client.is_valid_nakamoto_block(&block).unwrap_or_else(|e| {
+                            warn!("Failed to validate block: {:?}", e);
+                            false
+                        }) {
+                            warn!("Received an invalid block proposal from the miner. Ignoring block proposal: {:?}", block);
+                            return;
+                        }
+
+                        // TODO: dependent on https://github.com/stacks-network/stacks-core/issues/4018
+                        // let miner_public_key = self.stacks_client.get_miner_public_key().expect("Failed to get miner public key. Cannot verify blocks.");
+                        // let Some(block_miner_public_key) = block.header.recover_miner_pk() else {
+                        //     warn!("Failed to recover miner public key from block. Ignoring block proposal: {:?}", block);
+                        //     return;
+                        // };
+                        // if block_miner_public_key != miner_public_key {
+                        //     warn!("Received a block proposal signed with an invalid miner public key. Ignoring block proposal: {:?}.", block);
+                        //     return;
+                        // }
+                        
+                        // This is a block proposal from the miner. Trigger a signing round for it.
                         self.commands.push_back(RunLoopCommand::Sign {
                             message: block.serialize_to_vec(),
                             is_taproot: false,
@@ -236,6 +257,7 @@ impl<C: Coordinator> RunLoop<C> {
             })
             .collect();
         // First process all messages as a signer
+        // TODO: deserialize the packet into a block and verify its contents
         let mut outbound_messages = self
             .signing_round
             .process_inbound_messages(&inbound_messages)

From 4d38d172e5c8287bcee3828dc9e3ba5ea2bd03d2 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Mon, 11 Dec 2023 08:53:13 -0500
Subject: [PATCH 0364/1166] Add copyright to lib.rs and mod.rs files

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/mod.rs           | 16 ++++++++++++++++
 stacks-signer/src/client/stacks_client.rs |  2 +-
 stacks-signer/src/lib.rs                  | 17 +++++++++++++++++
 stacks-signer/src/runloop.rs              |  2 +-
 4 files changed, 35 insertions(+), 2 deletions(-)

diff --git a/stacks-signer/src/client/mod.rs b/stacks-signer/src/client/mod.rs
index fcc614c6e3..72dc9cae91 100644
--- a/stacks-signer/src/client/mod.rs
+++ b/stacks-signer/src/client/mod.rs
@@ -1,3 +1,19 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020-2023 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
 /// The stacker db module for communicating with the stackerdb contract
 mod stackerdb;
 /// The stacks node client module for communicating with the stacks node
diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index d3fb3c570f..6c317881da 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -59,7 +59,7 @@ impl StacksClient {
 
     /// Check if the proposed Nakamoto block is a valid block
     pub fn is_valid_nakamoto_block(&self, _block: &NakamotoBlock) -> Result<bool, ClientError> {
-        // TODO: Depends on https://github.com/stacks-network/stacks-core/issues/3866 
+        // TODO: Depends on https://github.com/stacks-network/stacks-core/issues/3866
         let send_request = || {
             self.stacks_node_client
                 .get(self.block_proposal_path())
diff --git a/stacks-signer/src/lib.rs b/stacks-signer/src/lib.rs
index e5b8350f5b..c0a8a11f7c 100644
--- a/stacks-signer/src/lib.rs
+++ b/stacks-signer/src/lib.rs
@@ -3,6 +3,23 @@
 # stacks-signer: a libary for creating a Stacks compliant signer. A default implementation binary is also provided.
 Usage documentation can be found in the [README](https://github.com/Trust-Machines/core-eng/stacks-signer-api/README.md).
 */
+
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020-2023 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
 /// The cli module for the signer binary
 pub mod cli;
 /// The signer client for communicating with stackerdb/stacks nodes
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index f3df4bac03..3fa6e19d65 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -210,7 +210,7 @@ impl<C: Coordinator> RunLoop<C> {
                         //     warn!("Received a block proposal signed with an invalid miner public key. Ignoring block proposal: {:?}.", block);
                         //     return;
                         // }
-                        
+
                         // This is a block proposal from the miner. Trigger a signing round for it.
                         self.commands.push_back(RunLoopCommand::Sign {
                             message: block.serialize_to_vec(),

From 0fcb1f0cc012f042122e32192326a42b909a8c7f Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Mon, 11 Dec 2023 09:00:40 -0500
Subject: [PATCH 0365/1166] Update put_chunk to take a ref and cleanup clippy

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 libsigner/src/session.rs              | 6 +++---
 stacks-signer/src/client/stackerdb.rs | 4 ++--
 stacks-signer/src/main.rs             | 2 +-
 stacks-signer/src/runloop.rs          | 7 ++++---
 4 files changed, 10 insertions(+), 9 deletions(-)

diff --git a/libsigner/src/session.rs b/libsigner/src/session.rs
index b65e43467c..e5dbd67f35 100644
--- a/libsigner/src/session.rs
+++ b/libsigner/src/session.rs
@@ -44,7 +44,7 @@ pub trait SignerSession {
     /// query the replica for zero or more latest chunks
     fn get_latest_chunks(&mut self, slot_ids: &[u32]) -> Result<Vec<Option<Vec<u8>>>, RPCError>;
     /// Upload a chunk to the stacker DB instance
-    fn put_chunk(&mut self, chunk: StackerDBChunkData) -> Result<StackerDBChunkAckData, RPCError>;
+    fn put_chunk(&mut self, chunk: &StackerDBChunkData) -> Result<StackerDBChunkAckData, RPCError>;
 
     /// Get a single chunk with the given version
     /// Returns Ok(Some(..)) if the chunk exists
@@ -207,9 +207,9 @@ impl SignerSession for StackerDBSession {
     }
 
     /// upload a chunk
-    fn put_chunk(&mut self, chunk: StackerDBChunkData) -> Result<StackerDBChunkAckData, RPCError> {
+    fn put_chunk(&mut self, chunk: &StackerDBChunkData) -> Result<StackerDBChunkAckData, RPCError> {
         let body =
-            serde_json::to_vec(&chunk).map_err(|e| RPCError::Deserialize(format!("{:?}", &e)))?;
+            serde_json::to_vec(chunk).map_err(|e| RPCError::Deserialize(format!("{:?}", &e)))?;
         let path = stackerdb_post_chunk_path(self.stackerdb_contract_id.clone());
         let resp_bytes = self.rpc_request("POST", &path, Some("application/json"), &body)?;
         let ack: StackerDBChunkAckData = serde_json::from_slice(&resp_bytes)
diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index ed97adcc50..6ea13040b4 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -177,10 +177,10 @@ impl StackerDB {
             let slot_version = *self.slot_versions.entry(slot_id).or_insert(0) + 1;
             let mut chunk = StackerDBChunkData::new(slot_id, slot_version, message_bytes.clone());
             chunk.sign(&self.stacks_private_key)?;
-            debug!("Sending a chunk to stackerdb!\n{:?}", chunk.clone());
+            debug!("Sending a chunk to stackerdb!\n{:?}", &chunk);
             let send_request = || {
                 self.signers_stackerdb_session
-                    .put_chunk(chunk.clone())
+                    .put_chunk(&chunk)
                     .map_err(backoff::Error::transient)
             };
             let chunk_ack: StackerDBChunkAckData = retry_with_exponential_backoff(send_request)?;
diff --git a/stacks-signer/src/main.rs b/stacks-signer/src/main.rs
index a3270f8fac..18ef2ca6f7 100644
--- a/stacks-signer/src/main.rs
+++ b/stacks-signer/src/main.rs
@@ -189,7 +189,7 @@ fn handle_put_chunk(args: PutChunkArgs) {
     let mut session = stackerdb_session(args.db_args.host, args.db_args.contract);
     let mut chunk = StackerDBChunkData::new(args.slot_id, args.slot_version, args.data);
     chunk.sign(&args.private_key).unwrap();
-    let chunk_ack = session.put_chunk(chunk).unwrap();
+    let chunk_ack = session.put_chunk(&chunk).unwrap();
     println!("{}", serde_json::to_string(&chunk_ack).unwrap());
 }
 
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 3fa6e19d65..d119cc1cc0 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -191,11 +191,12 @@ impl<C: Coordinator> RunLoop<C> {
                     // Received a block proposal from the miner.
                     // If the signer is the coordinator, then trigger a Signing round for the block
                     if coordinator_id == self.signing_round.signer_id {
-                        // Don't bother triggering a signing round for the block if it is invalid
-                        if !self.stacks_client.is_valid_nakamoto_block(&block).unwrap_or_else(|e| {
+                        let is_valid_block =  self.stacks_client.is_valid_nakamoto_block(&block).unwrap_or_else(|e| {
                             warn!("Failed to validate block: {:?}", e);
                             false
-                        }) {
+                        });
+                        // Don't bother triggering a signing round for the block if it is invalid
+                        if !is_valid_block {
                             warn!("Received an invalid block proposal from the miner. Ignoring block proposal: {:?}", block);
                             return;
                         }

From 41072f1578ca40c3f1e6aabcc872902c1f125f1f Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 10 Jan 2024 10:43:16 -0500
Subject: [PATCH 0366/1166] Cleanup stacks client to deserialize specific
 response types isntead of generic json blobs

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/mod.rs           |  3 -
 stacks-signer/src/client/stackerdb.rs     | 12 +--
 stacks-signer/src/client/stacks_client.rs | 95 ++++++++++-------------
 3 files changed, 45 insertions(+), 65 deletions(-)

diff --git a/stacks-signer/src/client/mod.rs b/stacks-signer/src/client/mod.rs
index 72dc9cae91..73e6d756f3 100644
--- a/stacks-signer/src/client/mod.rs
+++ b/stacks-signer/src/client/mod.rs
@@ -51,9 +51,6 @@ pub enum ClientError {
     /// Stacker-db instance rejected the chunk
     #[error("Stacker-db rejected the chunk. Reason: {0}")]
     PutChunkRejected(String),
-    /// Failed to find a given json entry
-    #[error("Invalid JSON entry: {0}")]
-    InvalidJsonEntry(String),
     /// Failed to call a read only function
     #[error("Failed to call read only function. {0}")]
     ReadOnlyFailure(String),
diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index 6ea13040b4..b53467b5e7 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -59,13 +59,9 @@ impl From<&StackerDBMessage> for TypePrefix {
     }
 }
 
-/// The StackerDB messages that can be sent through the .signers contract
+/// The StackerDB messages that can be sent through the observed contracts
 pub enum StackerDBMessage {
     /// The latest Nakamoto block for miners to observe
-    // TODO: update this to use a struct that lists optional error code if the block is invalid
-    // to prove that the signers have considered the block but rejected it. This should include
-    // hints about how to fix the block
-    // Update to use NakamotoBlockProposal. Depends on https://github.com/stacks-network/stacks-core/pull/4084
     Block(NakamotoBlock),
     /// DKG and Signing round data for other signers to observe
     Packet(Packet),
@@ -219,12 +215,12 @@ impl StackerDB {
 #[cfg(test)]
 mod tests {
     use blockstack_lib::chainstate::nakamoto::{NakamotoBlock, NakamotoBlockHeader};
-    use blockstack_lib::chainstate::stacks::StacksTransaction;
+    use blockstack_lib::chainstate::stacks::{StacksTransaction, ThresholdSignature};
     use rand_core::OsRng;
     use stacks_common::codec::StacksMessageCodec;
     use stacks_common::types::chainstate::{ConsensusHash, StacksBlockId, TrieHash};
     use stacks_common::util::hash::{MerkleTree, Sha512Trunc256Sum};
-    use stacks_common::util::secp256k1::{MessageSignature, SchnorrSignature};
+    use stacks_common::util::secp256k1::MessageSignature;
     use wsts::curve::scalar::Scalar;
     use wsts::net::{Message, Packet, Signable, SignatureShareRequest};
 
@@ -242,7 +238,7 @@ mod tests {
             tx_merkle_root: Sha512Trunc256Sum([0x06; 32]),
             state_index_root: TrieHash([0x07; 32]),
             miner_signature: MessageSignature::empty(),
-            signer_signature: SchnorrSignature::default(),
+            signer_signature: ThresholdSignature::mock(),
         };
         let txid_vecs = txs.iter().map(|tx| tx.txid().as_bytes().to_vec()).collect();
 
diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index 6c317881da..f6aed8b137 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -5,6 +5,9 @@ use blockstack_lib::chainstate::stacks::{
     TransactionContractCall, TransactionPayload, TransactionPostConditionMode,
     TransactionSpendingCondition, TransactionVersion,
 };
+use blockstack_lib::net::api::callreadonly::CallReadOnlyResponse;
+use blockstack_lib::net::api::getpoxinfo::RPCPoxInfoData;
+use blockstack_lib::net::api::postblock_proposal::BlockValidateResponse;
 use clarity::vm::types::{QualifiedContractIdentifier, SequenceData};
 use clarity::vm::{ClarityName, ContractName, Value as ClarityValue};
 use serde_json::json;
@@ -59,7 +62,6 @@ impl StacksClient {
 
     /// Check if the proposed Nakamoto block is a valid block
     pub fn is_valid_nakamoto_block(&self, _block: &NakamotoBlock) -> Result<bool, ClientError> {
-        // TODO: Depends on https://github.com/stacks-network/stacks-core/issues/3866
         let send_request = || {
             self.stacks_node_client
                 .get(self.block_proposal_path())
@@ -70,7 +72,17 @@ impl StacksClient {
         if !response.status().is_success() {
             return Err(ClientError::RequestFailure(response.status()));
         }
-        todo!("Call the appropriate RPC endpoint to check if the proposed Nakamoto block is valid");
+        let validate_block_response = response.json::<BlockValidateResponse>()?;
+        match validate_block_response {
+            BlockValidateResponse::Ok(validate_block_ok) => {
+                debug!("Block validation succeeded: {:?}", validate_block_ok);
+                Ok(true)
+            }
+            BlockValidateResponse::Reject(validate_block_reject) => {
+                debug!("Block validation failed: {:?}", validate_block_reject);
+                Ok(false)
+            }
+        }
     }
 
     /// Retrieve the current DKG aggregate public key
@@ -90,8 +102,8 @@ impl StacksClient {
         self.parse_aggregate_public_key(&contract_response_hex)
     }
 
-    /// Helper function to retrieve the current reward cycle number from the stacks node
-    fn get_current_reward_cycle(&self) -> Result<u64, ClientError> {
+    // Helper function to retrieve the pox data from the stacks node
+    fn get_pox_data(&self) -> Result<RPCPoxInfoData, ClientError> {
         let send_request = || {
             self.stacks_node_client
                 .get(self.pox_path())
@@ -102,13 +114,14 @@ impl StacksClient {
         if !response.status().is_success() {
             return Err(ClientError::RequestFailure(response.status()));
         }
-        let json_response = response.json::<serde_json::Value>()?;
-        let entry = "current_cycle";
-        json_response
-            .get(entry)
-            .and_then(|cycle: &serde_json::Value| cycle.get("id"))
-            .and_then(|id| id.as_u64())
-            .ok_or_else(|| ClientError::InvalidJsonEntry(format!("{}.id", entry)))
+        let pox_info_data = response.json::<RPCPoxInfoData>()?;
+        Ok(pox_info_data)
+    }
+
+    /// Helper function to retrieve the current reward cycle number from the stacks node
+    fn get_current_reward_cycle(&self) -> Result<u64, ClientError> {
+        let pox_data = self.get_pox_data()?;
+        Ok(pox_data.reward_cycle_id)
     }
 
     /// Helper function to retrieve the next possible nonce for the signer from the stacks node
@@ -124,25 +137,10 @@ impl StacksClient {
         if let Some(pox_contract) = self.pox_contract_id.clone() {
             return Ok((pox_contract.issuer.into(), pox_contract.name));
         }
-        // TODO: we may want to cache the pox contract inside the client itself (calling this function once on init)
-        // https://github.com/stacks-network/stacks-blockchain/issues/4005
-        let send_request = || {
-            self.stacks_node_client
-                .get(self.pox_path())
-                .send()
-                .map_err(backoff::Error::transient)
-        };
-        let response = retry_with_exponential_backoff(send_request)?;
-        if !response.status().is_success() {
-            return Err(ClientError::RequestFailure(response.status()));
-        }
-        let json_response = response.json::<serde_json::Value>()?;
-        let entry = "contract_id";
-        let contract_id_string = json_response
-            .get(entry)
-            .and_then(|id: &serde_json::Value| id.as_str())
-            .ok_or_else(|| ClientError::InvalidJsonEntry(entry.to_string()))?;
-        let id = QualifiedContractIdentifier::parse(contract_id_string).unwrap();
+        let pox_data = self.get_pox_data()?;
+        let contract_id = pox_data.contract_id.as_str();
+        let err_msg = format!("Stacks node returned an invalid pox contract id: {contract_id}");
+        let id = QualifiedContractIdentifier::parse(contract_id).expect(&err_msg);
         Ok((id.issuer.into(), id.name))
     }
 
@@ -281,27 +279,16 @@ impl StacksClient {
         if !response.status().is_success() {
             return Err(ClientError::RequestFailure(response.status()));
         }
-        let response = response.json::<serde_json::Value>()?;
-        if !response
-            .get("okay")
-            .map(|val| val.as_bool().unwrap_or(false))
-            .unwrap_or(false)
-        {
-            let cause = response
-                .get("cause")
-                .ok_or(ClientError::InvalidJsonEntry("cause".to_string()))?;
+        let call_read_only_response = response.json::<CallReadOnlyResponse>()?;
+        if !call_read_only_response.okay {
             return Err(ClientError::ReadOnlyFailure(format!(
-                "{}: {}",
-                function_name, cause
+                "{function_name}: {}",
+                call_read_only_response
+                    .cause
+                    .unwrap_or("unknown".to_string())
             )));
         }
-        let result = response
-            .get("result")
-            .ok_or(ClientError::InvalidJsonEntry("result".to_string()))?
-            .as_str()
-            .ok_or_else(|| ClientError::ReadOnlyFailure("Expected string result.".to_string()))?
-            .to_string();
-        Ok(result)
+        Ok(call_read_only_response.result.unwrap_or_default())
     }
 
     fn pox_path(&self) -> String {
@@ -325,7 +312,7 @@ impl StacksClient {
     }
 
     fn block_proposal_path(&self) -> String {
-        format!("{}/v2/block-proposal", self.http_origin)
+        format!("{}/v2/block_proposal", self.http_origin)
     }
 }
 
@@ -479,7 +466,7 @@ mod tests {
         let h = spawn(move || config.client.get_pox_contract());
         write_response(
             config.mock_server,
-            b"HTTP/1.1 200 Ok\n\n{\"contract_id\":\"ST000000000000000000002AMW42H.pox-3\"}",
+            b"HTTP/1.1 200 Ok\n\n{\"contract_id\":\"ST000000000000000000002AMW42H.pox-3\",\"pox_activation_threshold_ustx\":829371801288885,\"first_burnchain_block_height\":2000000,\"current_burnchain_block_height\":2572192,\"prepare_phase_block_length\":50,\"reward_phase_block_length\":1000,\"reward_slots\":2000,\"rejection_fraction\":12,\"total_liquid_supply_ustx\":41468590064444294,\"current_cycle\":{\"id\":544,\"min_threshold_ustx\":5190000000000,\"stacked_ustx\":853258144644000,\"is_pox_active\":true},\"next_cycle\":{\"id\":545,\"min_threshold_ustx\":5190000000000,\"min_increment_ustx\":5183573758055,\"stacked_ustx\":847278759574000,\"prepare_phase_start_block_height\":2572200,\"blocks_until_prepare_phase\":8,\"reward_phase_start_block_height\":2572250,\"blocks_until_reward_phase\":58,\"ustx_until_pox_rejection\":4976230807733304},\"min_amount_ustx\":5190000000000,\"prepare_cycle_length\":50,\"reward_cycle_id\":544,\"reward_cycle_length\":1050,\"rejection_votes_left_required\":4976230807733304,\"next_reward_cycle_in\":58,\"contract_versions\":[{\"contract_id\":\"ST000000000000000000002AMW42H.pox\",\"activation_burnchain_block_height\":2000000,\"first_reward_cycle_id\":0},{\"contract_id\":\"ST000000000000000000002AMW42H.pox-2\",\"activation_burnchain_block_height\":2422102,\"first_reward_cycle_id\":403},{\"contract_id\":\"ST000000000000000000002AMW42H.pox-3\",\"activation_burnchain_block_height\":2432545,\"first_reward_cycle_id\":412}]}",
         );
         let (address, name) = h.join().unwrap().unwrap();
         assert_eq!(
@@ -494,10 +481,10 @@ mod tests {
         let h = spawn(move || config.client.get_current_reward_cycle());
         write_response(
             config.mock_server,
-            b"HTTP/1.1 200 Ok\n\n{\"current_cycle\":{\"id\":506,\"min_threshold_ustx\":5190000000000,\"stacked_ustx\":5690000000000,\"is_pox_active\":false}}",
+            b"HTTP/1.1 200 Ok\n\n{\"contract_id\":\"ST000000000000000000002AMW42H.pox-3\",\"pox_activation_threshold_ustx\":829371801288885,\"first_burnchain_block_height\":2000000,\"current_burnchain_block_height\":2572192,\"prepare_phase_block_length\":50,\"reward_phase_block_length\":1000,\"reward_slots\":2000,\"rejection_fraction\":12,\"total_liquid_supply_ustx\":41468590064444294,\"current_cycle\":{\"id\":544,\"min_threshold_ustx\":5190000000000,\"stacked_ustx\":853258144644000,\"is_pox_active\":true},\"next_cycle\":{\"id\":545,\"min_threshold_ustx\":5190000000000,\"min_increment_ustx\":5183573758055,\"stacked_ustx\":847278759574000,\"prepare_phase_start_block_height\":2572200,\"blocks_until_prepare_phase\":8,\"reward_phase_start_block_height\":2572250,\"blocks_until_reward_phase\":58,\"ustx_until_pox_rejection\":4976230807733304},\"min_amount_ustx\":5190000000000,\"prepare_cycle_length\":50,\"reward_cycle_id\":544,\"reward_cycle_length\":1050,\"rejection_votes_left_required\":4976230807733304,\"next_reward_cycle_in\":58,\"contract_versions\":[{\"contract_id\":\"ST000000000000000000002AMW42H.pox\",\"activation_burnchain_block_height\":2000000,\"first_reward_cycle_id\":0},{\"contract_id\":\"ST000000000000000000002AMW42H.pox-2\",\"activation_burnchain_block_height\":2422102,\"first_reward_cycle_id\":403},{\"contract_id\":\"ST000000000000000000002AMW42H.pox-3\",\"activation_burnchain_block_height\":2432545,\"first_reward_cycle_id\":412}]}",
         );
         let current_cycle_id = h.join().unwrap().unwrap();
-        assert_eq!(506, current_cycle_id);
+        assert_eq!(544, current_cycle_id);
     }
 
     #[test]
@@ -509,7 +496,7 @@ mod tests {
             b"HTTP/1.1 200 Ok\n\n{\"current_cycle\":{\"id\":\"fake id\", \"is_pox_active\":false}}",
         );
         let res = h.join().unwrap();
-        assert!(matches!(res, Err(ClientError::InvalidJsonEntry(_))));
+        assert!(matches!(res, Err(ClientError::ReqwestError(_))));
     }
 
     #[test]
@@ -521,7 +508,7 @@ mod tests {
             b"HTTP/1.1 200 Ok\n\n{\"current_cycle\":{\"is_pox_active\":false}}",
         );
         let res = h.join().unwrap();
-        assert!(matches!(res, Err(ClientError::InvalidJsonEntry(_))));
+        assert!(matches!(res, Err(ClientError::ReqwestError(_))));
     }
 
     #[test]

From f033d9d52976b455c91c6ac06cd12257b931ec62 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 10 Jan 2024 11:35:29 -0500
Subject: [PATCH 0367/1166] is_valid_nakamoto_block should be making a post not
 a get request

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/stacks_client.rs | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index f6aed8b137..28a60c59f5 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -7,7 +7,7 @@ use blockstack_lib::chainstate::stacks::{
 };
 use blockstack_lib::net::api::callreadonly::CallReadOnlyResponse;
 use blockstack_lib::net::api::getpoxinfo::RPCPoxInfoData;
-use blockstack_lib::net::api::postblock_proposal::BlockValidateResponse;
+use blockstack_lib::net::api::postblock_proposal::{BlockValidateResponse, NakamotoBlockProposal};
 use clarity::vm::types::{QualifiedContractIdentifier, SequenceData};
 use clarity::vm::{ClarityName, ContractName, Value as ClarityValue};
 use serde_json::json;
@@ -61,17 +61,25 @@ impl StacksClient {
     }
 
     /// Check if the proposed Nakamoto block is a valid block
-    pub fn is_valid_nakamoto_block(&self, _block: &NakamotoBlock) -> Result<bool, ClientError> {
+    pub fn is_valid_nakamoto_block(&self, block: NakamotoBlock) -> Result<bool, ClientError> {
+        let block_proposal = NakamotoBlockProposal {
+            block,
+            chain_id: self.chain_id,
+        };
         let send_request = || {
             self.stacks_node_client
-                .get(self.block_proposal_path())
+                .post(&self.block_proposal_path())
+                .header("Content-Type", "application/json")
+                .json(&block_proposal)
                 .send()
                 .map_err(backoff::Error::transient)
         };
+
         let response = retry_with_exponential_backoff(send_request)?;
         if !response.status().is_success() {
             return Err(ClientError::RequestFailure(response.status()));
         }
+        // TODO: this is actually an aysnc call. It will not return the JSON response as below. It uses the event dispatcher instead
         let validate_block_response = response.json::<BlockValidateResponse>()?;
         match validate_block_response {
             BlockValidateResponse::Ok(validate_block_ok) => {

From f46454c551dfa7d15e072fa23de18731687a98c9 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 10 Jan 2024 18:27:55 -0500
Subject: [PATCH 0368/1166] WIP: add block events to libsigner

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 Cargo.lock                                    |   6 +-
 Cargo.toml                                    |   2 +-
 libsigner/Cargo.toml                          |   3 +
 libsigner/src/events.rs                       | 111 +++++++++++-------
 libsigner/src/libsigner.rs                    |   3 +-
 libsigner/src/runloop.rs                      |   8 +-
 libsigner/src/tests/mod.rs                    |  51 ++++----
 stacks-signer/src/client/stacks_client.rs     |  31 ++---
 stacks-signer/src/config.rs                   |   4 +-
 stacks-signer/src/main.rs                     |  11 +-
 stackslib/Cargo.toml                          |   1 -
 stackslib/src/net/api/poststackerdbchunk.rs   |   9 ++
 testnet/stacks-node/src/event_dispatcher.rs   |   2 +-
 .../stacks-node/src/nakamoto_node/miner.rs    |   2 +-
 .../src/tests/neon_integrations.rs            |   5 +-
 testnet/stacks-node/src/tests/signer.rs       |  10 +-
 16 files changed, 151 insertions(+), 108 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index a22e40e3f5..5d5061bb7f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1971,6 +1971,7 @@ dependencies = [
 name = "libsigner"
 version = "0.0.1"
 dependencies = [
+ "bincode",
  "clarity",
  "libc",
  "libstackerdb",
@@ -1984,8 +1985,10 @@ dependencies = [
  "slog-json",
  "slog-term",
  "stacks-common",
+ "stackslib",
  "thiserror",
  "tiny_http",
+ "wsts",
 ]
 
 [[package]]
@@ -3616,7 +3619,6 @@ dependencies = [
  "integer-sqrt",
  "lazy_static",
  "libc",
- "libsigner",
  "libstackerdb",
  "mio 0.6.23",
  "nix",
@@ -4714,8 +4716,6 @@ dependencies = [
 [[package]]
 name = "wsts"
 version = "6.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b2cb1ef1b26d526daae40c1ee657c83bbedaeefd7196f827b40ca79d13f0f34"
 dependencies = [
  "aes-gcm 0.10.2",
  "bs58 0.5.0",
diff --git a/Cargo.toml b/Cargo.toml
index e409b94158..ebc7261cf9 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -14,7 +14,7 @@ members = [
 
 # Dependencies we want to keep the same between workspace members
 [workspace.dependencies]  
-wsts = "6.0"
+wsts = { path = "../wsts" }
 rand_core = "0.6"
 rand = "0.8"
 
diff --git a/libsigner/Cargo.toml b/libsigner/Cargo.toml
index 8500ef55fa..73fad53a8b 100644
--- a/libsigner/Cargo.toml
+++ b/libsigner/Cargo.toml
@@ -17,6 +17,7 @@ path = "./src/libsigner.rs"
 
 [dependencies]
 clarity = { path = "../clarity" }
+bincode = "1.3.3"
 libc = "0.2"
 libstackerdb = { path = "../libstackerdb" }
 serde = "1"
@@ -26,8 +27,10 @@ slog = { version = "2.5.2", features = [ "max_level_trace" ] }
 slog-term = "2.6.0"
 slog-json = { version = "2.3.0", optional = true }
 stacks-common = { path = "../stacks-common" }
+stackslib = { path = "../stackslib"}
 thiserror = "1.0"
 tiny_http = "0.12"
+wsts = { workspace = true }
 
 [dependencies.serde_json]
 version = "1.0"
diff --git a/libsigner/src/events.rs b/libsigner/src/events.rs
index 23f5d0e4bf..a86d47df59 100644
--- a/libsigner/src/events.rs
+++ b/libsigner/src/events.rs
@@ -20,23 +20,31 @@ use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::mpsc::Sender;
 use std::sync::Arc;
 
+use blockstack_lib::chainstate::nakamoto::NakamotoBlock;
+use blockstack_lib::chainstate::stacks::boot::MINERS_NAME;
+use blockstack_lib::net::api::postblock_proposal::BlockValidateResponse;
+use blockstack_lib::net::api::poststackerdbchunk::StackerDBChunksEvent;
+use blockstack_lib::util_lib::boot::boot_code_id;
 use clarity::vm::types::QualifiedContractIdentifier;
-use libstackerdb::StackerDBChunkData;
 use serde::{Deserialize, Serialize};
+use stacks_common::codec::{
+    read_next, read_next_at_most, write_next, Error as CodecError, StacksMessageCodec,
+};
 use tiny_http::{
     Method as HttpMethod, Request as HttpRequest, Response as HttpResponse, Server as HttpServer,
 };
+use wsts::net::{Message, Packet};
 
 use crate::http::{decode_http_body, decode_http_request};
 use crate::EventError;
 
-/// Event structure for newly-arrived StackerDB data
+/// Event enum for newly-arrived signer subscribed events
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct StackerDBChunksEvent {
-    /// The contract ID for the StackerDB instance
-    pub contract_id: QualifiedContractIdentifier,
-    /// The chunk data for newly-modified slots
-    pub modified_slots: Vec<StackerDBChunkData>,
+pub enum SignerEvent {
+    /// A new stackerDB chunk was received
+    StackerDB(StackerDBChunksEvent),
+    /// A new block proposal was received
+    BlockProposal(BlockValidateResponse),
 }
 
 /// Trait to implement a stop-signaler for the event receiver thread.
@@ -47,7 +55,7 @@ pub trait EventStopSignaler {
     fn send(&mut self);
 }
 
-/// Trait to implement to handle StackerDB events sent by the Stacks node
+/// Trait to implement to handle StackerDB and BlockProposal events sent by the Stacks node
 pub trait EventReceiver {
     /// The implementation of ST will ensure that a call to ST::send() will cause
     /// the call to `is_stopped()` below to return true.
@@ -56,11 +64,11 @@ pub trait EventReceiver {
     /// Open a server socket to the given socket address.
     fn bind(&mut self, listener: SocketAddr) -> Result<SocketAddr, EventError>;
     /// Return the next event
-    fn next_event(&mut self) -> Result<StackerDBChunksEvent, EventError>;
+    fn next_event(&mut self) -> Result<SignerEvent, EventError>;
     /// Add a downstream event consumer
-    fn add_consumer(&mut self, event_out: Sender<StackerDBChunksEvent>);
+    fn add_consumer(&mut self, event_out: Sender<SignerEvent>);
     /// Forward the event to downstream consumers
-    fn forward_event(&mut self, ev: StackerDBChunksEvent) -> bool;
+    fn forward_event(&mut self, ev: SignerEvent) -> bool;
     /// Determine if the receiver should hang up
     fn is_stopped(&self) -> bool;
     /// Get a stop signal instance that, when sent, will cause this receiver to stop accepting new
@@ -100,25 +108,25 @@ pub trait EventReceiver {
     }
 }
 
-/// Event receiver for StackerDB events
-pub struct StackerDBEventReceiver {
-    /// contracts we're listening for
+/// Event receiver for Signer events
+pub struct SignerEventReceiver {
+    /// stacker db contracts we're listening for
     pub stackerdb_contract_ids: Vec<QualifiedContractIdentifier>,
     /// Address we bind to
     local_addr: Option<SocketAddr>,
     /// server socket that listens for HTTP POSTs from the node
     http_server: Option<HttpServer>,
     /// channel into which to write newly-discovered data
-    out_channels: Vec<Sender<StackerDBChunksEvent>>,
+    out_channels: Vec<Sender<SignerEvent>>,
     /// inter-thread stop variable -- if set to true, then the `main_loop` will exit
     stop_signal: Arc<AtomicBool>,
 }
 
-impl StackerDBEventReceiver {
-    /// Make a new StackerDB event receiver, and return both the receiver and the read end of a
+impl SignerEventReceiver {
+    /// Make a new Signer event receiver, and return both the receiver and the read end of a
     /// channel into which node-received data can be obtained.
-    pub fn new(contract_ids: Vec<QualifiedContractIdentifier>) -> StackerDBEventReceiver {
-        StackerDBEventReceiver {
+    pub fn new(contract_ids: Vec<QualifiedContractIdentifier>) -> SignerEventReceiver {
+        SignerEventReceiver {
             stackerdb_contract_ids: contract_ids,
             http_server: None,
             local_addr: None,
@@ -130,7 +138,7 @@ impl StackerDBEventReceiver {
     /// Do something with the socket
     pub fn with_server<F, R>(&mut self, todo: F) -> Result<R, EventError>
     where
-        F: FnOnce(&mut StackerDBEventReceiver, &mut HttpServer) -> R,
+        F: FnOnce(&mut SignerEventReceiver, &mut HttpServer) -> R,
     {
         let mut server = if let Some(s) = self.http_server.take() {
             s
@@ -146,22 +154,22 @@ impl StackerDBEventReceiver {
 }
 
 /// Stop signaler implementation
-pub struct StackerDBStopSignaler {
+pub struct SignerStopSignaler {
     stop_signal: Arc<AtomicBool>,
     local_addr: SocketAddr,
 }
 
-impl StackerDBStopSignaler {
+impl SignerStopSignaler {
     /// Make a new stop signaler
-    pub fn new(sig: Arc<AtomicBool>, local_addr: SocketAddr) -> StackerDBStopSignaler {
-        StackerDBStopSignaler {
+    pub fn new(sig: Arc<AtomicBool>, local_addr: SocketAddr) -> SignerStopSignaler {
+        SignerStopSignaler {
             stop_signal: sig,
             local_addr,
         }
     }
 }
 
-impl EventStopSignaler for StackerDBStopSignaler {
+impl EventStopSignaler for SignerStopSignaler {
     fn send(&mut self) {
         self.stop_signal.store(true, Ordering::SeqCst);
         // wake up the thread so the atomicbool can be checked
@@ -179,8 +187,8 @@ impl EventStopSignaler for StackerDBStopSignaler {
     }
 }
 
-impl EventReceiver for StackerDBEventReceiver {
-    type ST = StackerDBStopSignaler;
+impl EventReceiver for SignerEventReceiver {
+    type ST = SignerStopSignaler;
 
     /// Start listening on the given socket address.
     /// Returns the address that was bound.
@@ -194,7 +202,7 @@ impl EventReceiver for StackerDBEventReceiver {
     /// Wait for the node to post something, and then return it.
     /// Errors are recoverable -- the caller should call this method again even if it returns an
     /// error.
-    fn next_event(&mut self) -> Result<StackerDBChunksEvent, EventError> {
+    fn next_event(&mut self) -> Result<SignerEvent, EventError> {
         self.with_server(|event_receiver, http_server| {
             let mut request = http_server.recv()?;
 
@@ -209,27 +217,31 @@ impl EventReceiver for StackerDBEventReceiver {
                     &request.method(),
                 )));
             }
-            if request.url() != "/stackerdb_chunks" {
-                let url = request.url().to_string();
+            if request.url() == "/stackerdb_chunks" {
+                let mut body = String::new();
+                request
+                    .as_reader()
+                    .read_to_string(&mut body)
+                    .expect("failed to read body");
 
-                info!(
-                    "[{:?}] next_event got request with unexpected url {}, return OK so other side doesn't keep sending this",
-                    event_receiver.local_addr,
-                    request.url()
-                );
+                let event: StackerDBChunksEvent =
+                    serde_json::from_slice(body.as_bytes()).map_err(|e| {
+                        EventError::Deserialize(format!("Could not decode body to JSON: {:?}", &e))
+                    })?;
 
                 request
                     .respond(HttpResponse::empty(200u16))
                     .expect("response failed");
-                Err(EventError::UnrecognizedEvent(url))
-            } else {
+
+                Ok(SignerEvent::StackerDB(event))
+            } else if request.url() == "/proposal_response" {
                 let mut body = String::new();
                 request
                     .as_reader()
                     .read_to_string(&mut body)
                     .expect("failed to read body");
 
-                let event: StackerDBChunksEvent =
+                let event: BlockValidateResponse =
                     serde_json::from_slice(body.as_bytes()).map_err(|e| {
                         EventError::Deserialize(format!("Could not decode body to JSON: {:?}", &e))
                     })?;
@@ -238,7 +250,20 @@ impl EventReceiver for StackerDBEventReceiver {
                     .respond(HttpResponse::empty(200u16))
                     .expect("response failed");
 
-                Ok(event)
+                Ok(SignerEvent::BlockProposal(event))
+            } else {
+                let url = request.url().to_string();
+
+                info!(
+                    "[{:?}] next_event got request with unexpected url {}, return OK so other side doesn't keep sending this",
+                    event_receiver.local_addr,
+                    request.url()
+                );
+
+                request
+                    .respond(HttpResponse::empty(200u16))
+                    .expect("response failed");
+                Err(EventError::UnrecognizedEvent(url))
             }
         })?
     }
@@ -251,7 +276,7 @@ impl EventReceiver for StackerDBEventReceiver {
     /// Forward an event
     /// Return true on success; false on error.
     /// Returning false terminates the event receiver.
-    fn forward_event(&mut self, ev: StackerDBChunksEvent) -> bool {
+    fn forward_event(&mut self, ev: SignerEvent) -> bool {
         if self.out_channels.is_empty() {
             // nothing to do
             error!("No channels connected to event receiver");
@@ -275,15 +300,15 @@ impl EventReceiver for StackerDBEventReceiver {
     }
 
     /// Add an event consumer.  A received event will be forwarded to this Sender.
-    fn add_consumer(&mut self, out_channel: Sender<StackerDBChunksEvent>) {
+    fn add_consumer(&mut self, out_channel: Sender<SignerEvent>) {
         self.out_channels.push(out_channel);
     }
 
     /// Get a stopped signaler.  The caller can then use it to terminate the event receiver loop,
     /// even if it's in a different thread.
-    fn get_stop_signaler(&mut self) -> Result<StackerDBStopSignaler, EventError> {
+    fn get_stop_signaler(&mut self) -> Result<SignerStopSignaler, EventError> {
         if let Some(local_addr) = self.local_addr {
-            Ok(StackerDBStopSignaler::new(
+            Ok(SignerStopSignaler::new(
                 self.stop_signal.clone(),
                 local_addr,
             ))
diff --git a/libsigner/src/libsigner.rs b/libsigner/src/libsigner.rs
index 3ab25f46e9..b7f983f8c3 100644
--- a/libsigner/src/libsigner.rs
+++ b/libsigner/src/libsigner.rs
@@ -44,8 +44,7 @@ mod session;
 
 pub use crate::error::{EventError, RPCError};
 pub use crate::events::{
-    EventReceiver, EventStopSignaler, StackerDBChunksEvent, StackerDBEventReceiver,
-    StackerDBStopSignaler,
+    EventReceiver, EventStopSignaler, SignerEvent, SignerEventReceiver, SignerStopSignaler,
 };
 pub use crate::runloop::{RunningSigner, Signer, SignerRunLoop};
 pub use crate::session::{SignerSession, StackerDBSession};
diff --git a/libsigner/src/runloop.rs b/libsigner/src/runloop.rs
index 2f4bbcf46b..d1a2474a33 100644
--- a/libsigner/src/runloop.rs
+++ b/libsigner/src/runloop.rs
@@ -28,7 +28,7 @@ use stacks_common::deps_common::ctrlc as termination;
 use stacks_common::deps_common::ctrlc::SignalId;
 
 use crate::error::EventError;
-use crate::events::{EventReceiver, EventStopSignaler, StackerDBChunksEvent};
+use crate::events::{EventReceiver, EventStopSignaler, SignerEvent};
 
 /// Some libcs, like musl, have a very small stack size.
 /// Make sure it's big enough.
@@ -45,12 +45,12 @@ pub trait SignerRunLoop<R: Send, CMD: Send> {
     fn set_event_timeout(&mut self, timeout: Duration);
     /// Getter for the event poll timeout
     fn get_event_timeout(&self) -> Duration;
-    /// Run one pass of the event loop, given new StackerDB events discovered since the last pass.
+    /// Run one pass of the event loop, given new Signer events discovered since the last pass.
     /// Returns Some(R) if this is the final pass -- the runloop evaluated to R
     /// Returns None to keep running.
     fn run_one_pass(
         &mut self,
-        event: Option<StackerDBChunksEvent>,
+        event: Option<SignerEvent>,
         cmd: Option<CMD>,
         res: Sender<R>,
     ) -> Option<R>;
@@ -64,7 +64,7 @@ pub trait SignerRunLoop<R: Send, CMD: Send> {
     /// This would run in a separate thread from the event receiver.
     fn main_loop<EVST: EventStopSignaler>(
         &mut self,
-        event_recv: Receiver<StackerDBChunksEvent>,
+        event_recv: Receiver<SignerEvent>,
         command_recv: Receiver<CMD>,
         result_send: Sender<R>,
         mut event_stop_signaler: EVST,
diff --git a/libsigner/src/tests/mod.rs b/libsigner/src/tests/mod.rs
index ffe8d4d9ee..3e16bf4729 100644
--- a/libsigner/src/tests/mod.rs
+++ b/libsigner/src/tests/mod.rs
@@ -22,18 +22,20 @@ use std::sync::mpsc::{channel, Receiver, Sender};
 use std::time::Duration;
 use std::{mem, thread};
 
+use blockstack_lib::net::api::poststackerdbchunk::StackerDBChunksEvent;
 use clarity::vm::types::QualifiedContractIdentifier;
 use libstackerdb::StackerDBChunkData;
 use stacks_common::util::secp256k1::Secp256k1PrivateKey;
 use stacks_common::util::sleep_ms;
 
-use crate::{Signer, SignerRunLoop, StackerDBChunksEvent, StackerDBEventReceiver};
+use crate::events::SignerEvent;
+use crate::{Signer, SignerEventReceiver, SignerRunLoop};
 
 /// Simple runloop implementation.  It receives `max_events` events and returns `events` from the
 /// last call to `run_one_pass` as its final state.
 struct SimpleRunLoop {
     poll_timeout: Duration,
-    events: Vec<StackerDBChunksEvent>,
+    events: Vec<SignerEvent>,
     max_events: usize,
 }
 
@@ -51,7 +53,7 @@ enum Command {
     Empty,
 }
 
-impl SignerRunLoop<Vec<StackerDBChunksEvent>, Command> for SimpleRunLoop {
+impl SignerRunLoop<Vec<SignerEvent>, Command> for SimpleRunLoop {
     fn set_event_timeout(&mut self, timeout: Duration) {
         self.poll_timeout = timeout;
     }
@@ -62,10 +64,10 @@ impl SignerRunLoop<Vec<StackerDBChunksEvent>, Command> for SimpleRunLoop {
 
     fn run_one_pass(
         &mut self,
-        event: Option<StackerDBChunksEvent>,
+        event: Option<SignerEvent>,
         _cmd: Option<Command>,
-        _res: Sender<Vec<StackerDBChunksEvent>>,
-    ) -> Option<Vec<StackerDBChunksEvent>> {
+        _res: Sender<Vec<SignerEvent>>,
+    ) -> Option<Vec<SignerEvent>> {
         debug!("Got event: {:?}", &event);
         if let Some(event) = event {
             self.events.push(event);
@@ -85,7 +87,7 @@ impl SignerRunLoop<Vec<StackerDBChunksEvent>, Command> for SimpleRunLoop {
 /// and the signer runloop.
 #[test]
 fn test_simple_signer() {
-    let ev = StackerDBEventReceiver::new(vec![QualifiedContractIdentifier::parse(
+    let ev = SignerEventReceiver::new(vec![QualifiedContractIdentifier::parse(
         "ST2DS4MSWSGJ3W9FBC6BVT0Y92S345HY8N3T6AV7R.hello-world",
     )
     .unwrap()]);
@@ -100,13 +102,13 @@ fn test_simple_signer() {
         let mut chunk = StackerDBChunkData::new(i as u32, 1, "hello world".as_bytes().to_vec());
         chunk.sign(&privk).unwrap();
 
-        let chunk_event = StackerDBChunksEvent {
+        let chunk_event = SignerEvent::StackerDB(StackerDBChunksEvent {
             contract_id: QualifiedContractIdentifier::parse(
                 "ST2DS4MSWSGJ3W9FBC6BVT0Y92S345HY8N3T6AV7R.hello-world",
             )
             .unwrap(),
             modified_slots: vec![chunk],
-        };
+        });
         chunks.push(chunk_event);
     }
 
@@ -124,14 +126,19 @@ fn test_simple_signer() {
                 }
             };
 
-            let body = serde_json::to_string(&thread_chunks[num_sent]).unwrap();
-            let req = format!("POST /stackerdb_chunks HTTP/1.0\r\nConnection: close\r\nContent-Length: {}\r\n\r\n{}", &body.len(), body);
-            debug!("Send:\n{}", &req);
+            match &thread_chunks[num_sent] {
+                SignerEvent::StackerDB(ev) => {
+                    let body = serde_json::to_string(ev).unwrap();
+                    let req = format!("POST /stackerdb_chunks HTTP/1.0\r\nConnection: close\r\nContent-Length: {}\r\n\r\n{}", &body.len(), body);
+                    debug!("Send:\n{}", &req);
 
-            sock.write_all(req.as_bytes()).unwrap();
-            sock.flush().unwrap();
+                    sock.write_all(req.as_bytes()).unwrap();
+                    sock.flush().unwrap();
 
-            num_sent += 1;
+                    num_sent += 1;
+                }
+                _ => panic!("Unexpected event type"),
+            }
         }
     });
 
@@ -139,17 +146,19 @@ fn test_simple_signer() {
     sleep_ms(5000);
     let mut accepted_events = running_signer.stop().unwrap();
 
-    chunks.sort_by(|ev1, ev2| {
-        ev1.modified_slots[0]
+    chunks.sort_by(|ev1, ev2| match (ev1, ev2) {
+        (SignerEvent::StackerDB(ev1), SignerEvent::StackerDB(ev2)) => ev1.modified_slots[0]
             .slot_id
             .partial_cmp(&ev2.modified_slots[0].slot_id)
-            .unwrap()
+            .unwrap(),
+        _ => panic!("Unexpected event type"),
     });
-    accepted_events.sort_by(|ev1, ev2| {
-        ev1.modified_slots[0]
+    accepted_events.sort_by(|ev1, ev2| match (ev1, ev2) {
+        (SignerEvent::StackerDB(ev1), SignerEvent::StackerDB(ev2)) => ev1.modified_slots[0]
             .slot_id
             .partial_cmp(&ev2.modified_slots[0].slot_id)
-            .unwrap()
+            .unwrap(),
+        _ => panic!("Unexpected event type"),
     });
 
     // runloop got the event that the mocked stacks node sent
diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index 28a60c59f5..d80bbe9269 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -7,7 +7,7 @@ use blockstack_lib::chainstate::stacks::{
 };
 use blockstack_lib::net::api::callreadonly::CallReadOnlyResponse;
 use blockstack_lib::net::api::getpoxinfo::RPCPoxInfoData;
-use blockstack_lib::net::api::postblock_proposal::{BlockValidateResponse, NakamotoBlockProposal};
+use blockstack_lib::net::api::postblock_proposal::NakamotoBlockProposal;
 use clarity::vm::types::{QualifiedContractIdentifier, SequenceData};
 use clarity::vm::{ClarityName, ContractName, Value as ClarityValue};
 use serde_json::json;
@@ -60,15 +60,15 @@ impl StacksClient {
         todo!("Get the miner public key from the stacks node to verify the miner blocks were signed by the correct miner");
     }
 
-    /// Check if the proposed Nakamoto block is a valid block
-    pub fn is_valid_nakamoto_block(&self, block: NakamotoBlock) -> Result<bool, ClientError> {
+    /// Submit the block proposal to the stacks node. The block will be validated and returned via the HTTP endpoint for Block events.
+    pub fn submit_block_for_validation(&self, block: NakamotoBlock) -> Result<(), ClientError> {
         let block_proposal = NakamotoBlockProposal {
             block,
             chain_id: self.chain_id,
         };
         let send_request = || {
             self.stacks_node_client
-                .post(&self.block_proposal_path())
+                .post(self.block_proposal_path())
                 .header("Content-Type", "application/json")
                 .json(&block_proposal)
                 .send()
@@ -80,17 +80,18 @@ impl StacksClient {
             return Err(ClientError::RequestFailure(response.status()));
         }
         // TODO: this is actually an aysnc call. It will not return the JSON response as below. It uses the event dispatcher instead
-        let validate_block_response = response.json::<BlockValidateResponse>()?;
-        match validate_block_response {
-            BlockValidateResponse::Ok(validate_block_ok) => {
-                debug!("Block validation succeeded: {:?}", validate_block_ok);
-                Ok(true)
-            }
-            BlockValidateResponse::Reject(validate_block_reject) => {
-                debug!("Block validation failed: {:?}", validate_block_reject);
-                Ok(false)
-            }
-        }
+        // let validate_block_response = response.json::<BlockValidateResponse>()?;
+        // match validate_block_response {
+        //     BlockValidateResponse::Ok(validate_block_ok) => {
+        //         debug!("Block validation succeeded: {:?}", validate_block_ok);
+        //         Ok(true)
+        //     }
+        //     BlockValidateResponse::Reject(validate_block_reject) => {
+        //         debug!("Block validation failed: {:?}", validate_block_reject);
+        //         Ok(false)
+        //     }
+        // }
+        Ok(())
     }
 
     /// Retrieve the current DKG aggregate public key
diff --git a/stacks-signer/src/config.rs b/stacks-signer/src/config.rs
index c298ead275..4e1a53dffe 100644
--- a/stacks-signer/src/config.rs
+++ b/stacks-signer/src/config.rs
@@ -97,7 +97,7 @@ impl Network {
 pub struct Config {
     /// endpoint to the stacks node
     pub node_host: SocketAddr,
-    /// endpoint to the stackerdb receiver
+    /// endpoint to the event receiver
     pub endpoint: SocketAddr,
     /// smart contract that controls the target signers' stackerdb
     pub signers_stackerdb_contract_id: QualifiedContractIdentifier,
@@ -143,7 +143,7 @@ struct RawSigners {
 struct RawConfigFile {
     /// endpoint to stacks node
     pub node_host: String,
-    /// endpoint to stackerdb receiver
+    /// endpoint to event receiver
     pub endpoint: String,
     // FIXME: these contract's should go away in non testing scenarios. Make them both optionals.
     /// Signers' Stacker db contract identifier
diff --git a/stacks-signer/src/main.rs b/stacks-signer/src/main.rs
index 18ef2ca6f7..5187f9a522 100644
--- a/stacks-signer/src/main.rs
+++ b/stacks-signer/src/main.rs
@@ -35,7 +35,7 @@ use std::time::Duration;
 
 use clap::Parser;
 use clarity::vm::types::QualifiedContractIdentifier;
-use libsigner::{RunningSigner, Signer, SignerSession, StackerDBEventReceiver, StackerDBSession};
+use libsigner::{RunningSigner, Signer, SignerEventReceiver, SignerSession, StackerDBSession};
 use libstackerdb::StackerDBChunkData;
 use slog::slog_debug;
 use stacks_common::address::{
@@ -58,7 +58,7 @@ use wsts::state_machine::OperationResult;
 use wsts::v2;
 
 struct SpawnedSigner {
-    running_signer: RunningSigner<StackerDBEventReceiver, Vec<OperationResult>>,
+    running_signer: RunningSigner<SignerEventReceiver, Vec<OperationResult>>,
     cmd_send: Sender<RunLoopCommand>,
     res_recv: Receiver<Vec<OperationResult>>,
 }
@@ -88,16 +88,15 @@ fn spawn_running_signer(path: &PathBuf) -> SpawnedSigner {
     let config = Config::try_from(path).unwrap();
     let (cmd_send, cmd_recv) = channel();
     let (res_send, res_recv) = channel();
-    let ev = StackerDBEventReceiver::new(vec![config.signers_stackerdb_contract_id.clone()]);
+    let ev = SignerEventReceiver::new(vec![config.signers_stackerdb_contract_id.clone()]);
     let runloop: RunLoop<FireCoordinator<v2::Aggregator>> = RunLoop::from(&config);
     let mut signer: Signer<
         RunLoopCommand,
         Vec<OperationResult>,
         RunLoop<FireCoordinator<v2::Aggregator>>,
-        StackerDBEventReceiver,
+        SignerEventReceiver,
     > = Signer::new(runloop, ev, cmd_recv, res_send);
-    let endpoint = config.endpoint;
-    let running_signer = signer.spawn(endpoint).unwrap();
+    let running_signer = signer.spawn(config.endpoint).unwrap();
     SpawnedSigner {
         running_signer,
         cmd_send,
diff --git a/stackslib/Cargo.toml b/stackslib/Cargo.toml
index 748f5b07d3..c505d8429b 100644
--- a/stackslib/Cargo.toml
+++ b/stackslib/Cargo.toml
@@ -54,7 +54,6 @@ clarity = { path = "../clarity" }
 stacks-common = { path = "../stacks-common" }
 pox-locking = { path = "../pox-locking" }
 libstackerdb = { path = "../libstackerdb" }
-libsigner = { path = "../libsigner" }
 siphasher = "0.3.7"
 wsts = {workspace = true}
 rand_core = {workspace = true}
diff --git a/stackslib/src/net/api/poststackerdbchunk.rs b/stackslib/src/net/api/poststackerdbchunk.rs
index 3ca82b4141..a006cf386b 100644
--- a/stackslib/src/net/api/poststackerdbchunk.rs
+++ b/stackslib/src/net/api/poststackerdbchunk.rs
@@ -54,6 +54,15 @@ use crate::net::{
 };
 use crate::util_lib::db::{DBConn, Error as DBError};
 
+/// Event structure for newly-arrived StackerDB data
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StackerDBChunksEvent {
+    /// The contract ID for the StackerDB instance
+    pub contract_id: QualifiedContractIdentifier,
+    /// The chunk data for newly-modified slots
+    pub modified_slots: Vec<StackerDBChunkData>,
+}
+
 #[derive(Clone)]
 pub struct RPCPostStackerDBChunkRequestHandler {
     pub contract_identifier: Option<QualifiedContractIdentifier>,
diff --git a/testnet/stacks-node/src/event_dispatcher.rs b/testnet/stacks-node/src/event_dispatcher.rs
index 3619970fc0..98c08ba4a0 100644
--- a/testnet/stacks-node/src/event_dispatcher.rs
+++ b/testnet/stacks-node/src/event_dispatcher.rs
@@ -10,7 +10,6 @@ use clarity::vm::costs::ExecutionCost;
 use clarity::vm::events::{FTEventType, NFTEventType, STXEventType};
 use clarity::vm::types::{AssetIdentifier, QualifiedContractIdentifier, Value};
 use http_types::{Method, Request, Url};
-pub use libsigner::StackerDBChunksEvent;
 use serde_json::json;
 use stacks::burnchains::{PoxConstants, Txid};
 use stacks::chainstate::burn::operations::BlockstackOperationType;
@@ -33,6 +32,7 @@ use stacks::libstackerdb::StackerDBChunkData;
 use stacks::net::api::postblock_proposal::{
     BlockValidateOk, BlockValidateReject, BlockValidateResponse,
 };
+use stacks::net::api::poststackerdbchunk::StackerDBChunksEvent;
 use stacks::net::atlas::{Attachment, AttachmentInstance};
 use stacks::net::stackerdb::StackerDBEventDispatcher;
 use stacks_common::codec::StacksMessageCodec;
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index 03e3e29bc2..cc9b25c61b 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -196,7 +196,7 @@ impl BlockMinerThread {
                         let miner_contract_id = boot_code_id(MINERS_NAME, self.config.is_mainnet());
                         let mut miners_stackerdb =
                             StackerDBSession::new(rpc_sock, miner_contract_id);
-                        match miners_stackerdb.put_chunk(chunk) {
+                        match miners_stackerdb.put_chunk(&chunk) {
                             Ok(ack) => {
                                 info!("Proposed block to stackerdb: {ack:?}");
                             }
diff --git a/testnet/stacks-node/src/tests/neon_integrations.rs b/testnet/stacks-node/src/tests/neon_integrations.rs
index 13c5c10573..c9d529bf21 100644
--- a/testnet/stacks-node/src/tests/neon_integrations.rs
+++ b/testnet/stacks-node/src/tests/neon_integrations.rs
@@ -178,12 +178,11 @@ pub mod test_observer {
     use std::thread;
 
     use stacks::net::api::postblock_proposal::BlockValidateResponse;
+    use stacks::net::api::poststackerdbchunk::StackerDBChunksEvent;
     use warp::Filter;
     use {tokio, warp};
 
-    use crate::event_dispatcher::{
-        MinedBlockEvent, MinedMicroblockEvent, MinedNakamotoBlockEvent, StackerDBChunksEvent,
-    };
+    use crate::event_dispatcher::{MinedBlockEvent, MinedMicroblockEvent, MinedNakamotoBlockEvent};
 
     pub const EVENT_OBSERVER_PORT: u16 = 50303;
 
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index 933e3e0c6f..4a4e6e55c9 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -3,7 +3,7 @@ use std::time::Duration;
 use std::{env, thread};
 
 use clarity::vm::types::QualifiedContractIdentifier;
-use libsigner::{RunningSigner, Signer, StackerDBEventReceiver};
+use libsigner::{RunningSigner, Signer, SignerEventReceiver};
 use stacks::chainstate::stacks::StacksPrivateKey;
 use stacks_common::types::chainstate::StacksAddress;
 use stacks_signer::client::{MINER_SLOTS_PER_USER, SIGNER_SLOTS_PER_USER};
@@ -37,9 +37,9 @@ fn spawn_signer(
     data: &str,
     receiver: Receiver<RunLoopCommand>,
     sender: Sender<Vec<OperationResult>>,
-) -> RunningSigner<StackerDBEventReceiver, Vec<OperationResult>> {
+) -> RunningSigner<SignerEventReceiver, Vec<OperationResult>> {
     let config = stacks_signer::config::Config::load_from_str(data).unwrap();
-    let ev = StackerDBEventReceiver::new(vec![
+    let ev = SignerEventReceiver::new(vec![
         config.miners_stackerdb_contract_id.clone(),
         config.signers_stackerdb_contract_id.clone(),
     ]);
@@ -49,7 +49,7 @@ fn spawn_signer(
         RunLoopCommand,
         Vec<OperationResult>,
         stacks_signer::runloop::RunLoop<FireCoordinator<v2::Aggregator>>,
-        StackerDBEventReceiver,
+        SignerEventReceiver,
     > = Signer::new(runloop, ev, receiver, sender);
     let endpoint = config.endpoint;
     info!(
@@ -78,7 +78,7 @@ fn setup_stx_btc_node(
 
         conf.events_observers.insert(EventObserverConfig {
             endpoint: format!("{}", signer_config.endpoint),
-            events_keys: vec![EventKeyType::StackerDBChunks],
+            events_keys: vec![EventKeyType::StackerDBChunks, EventKeyType::BlockProposal],
         });
     }
 

From 906caaa1912a34c4d08de1d40971924843002010 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 10 Jan 2024 18:43:48 -0500
Subject: [PATCH 0369/1166] Add block events to libsigner

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/runloop.rs | 79 ++++++++++++++++++++++--------------
 1 file changed, 48 insertions(+), 31 deletions(-)

diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index d119cc1cc0..9ffcd649f7 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -2,8 +2,10 @@ use std::collections::VecDeque;
 use std::sync::mpsc::Sender;
 use std::time::Duration;
 
+use blockstack_lib::net::api::postblock_proposal::BlockValidateResponse;
+use blockstack_lib::net::api::poststackerdbchunk::StackerDBChunksEvent;
 use hashbrown::{HashMap, HashSet};
-use libsigner::{SignerRunLoop, StackerDBChunksEvent};
+use libsigner::{SignerEvent, SignerRunLoop};
 use slog::{slog_debug, slog_error, slog_info, slog_warn};
 use stacks_common::codec::{read_next, StacksMessageCodec};
 use stacks_common::{debug, error, info, warn};
@@ -169,11 +171,26 @@ impl<C: Coordinator> RunLoop<C> {
         }
     }
 
+    /// Handle block proposal from the miners stacker-db contract
+    fn handle_block_validate_response(&mut self, block_validate_response: BlockValidateResponse) {
+        match block_validate_response {
+            BlockValidateResponse::Ok(block_validate_ok) => {
+                // This is a valid block proposal from the miner. Trigger a signing round for it.
+                self.commands.push_back(RunLoopCommand::Sign {
+                    message: block_validate_ok.block.serialize_to_vec(),
+                    is_taproot: false,
+                    merkle_root: None,
+                });
+            }
+            BlockValidateResponse::Reject(_block_validate_reject) => {
+                // TODO: send a message to the miner to let them know their block was rejected
+                todo!("Send a message to the miner to let them know their block was rejected");
+            }
+        }
+    }
+
     /// Process the event as a miner message from the miner stacker-db
     fn process_event_miner(&mut self, event: &StackerDBChunksEvent) {
-        // Determine the current coordinator id and public key for verification
-        let (coordinator_id, _coordinator_public_key) =
-            calculate_coordinator(&self.signing_round.public_keys);
         event.modified_slots.iter().for_each(|chunk| {
             let mut ptr = &chunk.data[..];
             let Some(stacker_db_message) = read_next::<StackerDBMessage, _>(&mut ptr).ok() else {
@@ -189,17 +206,10 @@ impl<C: Coordinator> RunLoop<C> {
                 }
                 StackerDBMessage::Block(block) => {
                     // Received a block proposal from the miner.
-                    // If the signer is the coordinator, then trigger a Signing round for the block
-                    if coordinator_id == self.signing_round.signer_id {
-                        let is_valid_block =  self.stacks_client.is_valid_nakamoto_block(&block).unwrap_or_else(|e| {
+                    // Submit it to the stacks node to validate it before triggering a signing round.
+                        self.stacks_client.submit_block_for_validation(block).unwrap_or_else(|e| {
                             warn!("Failed to validate block: {:?}", e);
-                            false
                         });
-                        // Don't bother triggering a signing round for the block if it is invalid
-                        if !is_valid_block {
-                            warn!("Received an invalid block proposal from the miner. Ignoring block proposal: {:?}", block);
-                            return;
-                        }
 
                         // TODO: dependent on https://github.com/stacks-network/stacks-core/issues/4018
                         // let miner_public_key = self.stacks_client.get_miner_public_key().expect("Failed to get miner public key. Cannot verify blocks.");
@@ -212,19 +222,28 @@ impl<C: Coordinator> RunLoop<C> {
                         //     return;
                         // }
 
-                        // This is a block proposal from the miner. Trigger a signing round for it.
-                        self.commands.push_back(RunLoopCommand::Sign {
-                            message: block.serialize_to_vec(),
-                            is_taproot: false,
-                            merkle_root: None,
-                        });
-                    }
                 }
             }
         });
     }
 
     /// Process the event as a signer message from the signer stacker-db
+    fn handle_stackerdb_event(&mut self, event: &StackerDBChunksEvent) -> Vec<OperationResult> {
+        if event.contract_id == *self.stackerdb.miners_contract_id() {
+            self.process_event_miner(event);
+            vec![]
+        } else if event.contract_id == *self.stackerdb.signers_contract_id() {
+            self.process_event_signer(event)
+        } else {
+            warn!(
+                "Received an event from an unrecognized contract ID: {:?}",
+                event.contract_id
+            );
+            vec![]
+        }
+    }
+
+    // Process the event as a signer message from the signer stacker-db
     fn process_event_signer(&mut self, event: &StackerDBChunksEvent) -> Vec<OperationResult> {
         // Determine the current coordinator id and public key for verification
         let (_coordinator_id, coordinator_public_key) =
@@ -378,7 +397,7 @@ impl<C: Coordinator> SignerRunLoop<Vec<OperationResult>, RunLoopCommand> for Run
 
     fn run_one_pass(
         &mut self,
-        event: Option<StackerDBChunksEvent>,
+        event: Option<SignerEvent>,
         cmd: Option<RunLoopCommand>,
         res: Sender<Vec<OperationResult>>,
     ) -> Option<Vec<OperationResult>> {
@@ -395,11 +414,13 @@ impl<C: Coordinator> SignerRunLoop<Vec<OperationResult>, RunLoopCommand> for Run
                 .expect("Failed to connect to initialize due to timeout. Stacks node may be down.");
         }
         // Process any arrived events
-        if let Some(event) = event {
-            if event.contract_id == *self.stackerdb.miners_contract_id() {
-                self.process_event_miner(&event);
-            } else if event.contract_id == *self.stackerdb.signers_contract_id() {
-                let operation_results = self.process_event_signer(&event);
+        match event {
+            Some(SignerEvent::BlockProposal(block_validate_response)) => {
+                self.handle_block_validate_response(block_validate_response)
+            }
+            Some(SignerEvent::StackerDB(event)) => {
+                let operation_results = self.handle_stackerdb_event(&event);
+
                 let nmb_results = operation_results.len();
                 if nmb_results > 0 {
                     // We finished our command. Update the state
@@ -411,12 +432,8 @@ impl<C: Coordinator> SignerRunLoop<Vec<OperationResult>, RunLoopCommand> for Run
                         }
                     }
                 }
-            } else {
-                warn!(
-                    "Received event from unknown contract ID: {}",
-                    event.contract_id
-                );
             }
+            None => debug!("No event received"),
         }
         // The process the next command
         // Must be called AFTER processing the event as the state may update to IDLE due to said event.

From da39a87a71fb7e8198a6c0bee95ebb171ffe3a96 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 10 Jan 2024 18:48:42 -0500
Subject: [PATCH 0370/1166] Add block to BlockValidateReject

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stackslib/src/net/api/postblock_proposal.rs | 72 +++++++++++++++------
 1 file changed, 51 insertions(+), 21 deletions(-)

diff --git a/stackslib/src/net/api/postblock_proposal.rs b/stackslib/src/net/api/postblock_proposal.rs
index b2416d7a6e..1c6613f8d7 100644
--- a/stackslib/src/net/api/postblock_proposal.rs
+++ b/stackslib/src/net/api/postblock_proposal.rs
@@ -90,6 +90,8 @@ fn hex_deser_block<'de, D: serde::Deserializer<'de>>(d: D) -> Result<NakamotoBlo
 ///  that the stacks-node thinks should be rejected.
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct BlockValidateReject {
+    #[serde(serialize_with = "hex_ser_block", deserialize_with = "hex_deser_block")]
+    pub block: NakamotoBlock,
     pub reason: String,
     pub reason_code: ValidateRejectCode,
 }
@@ -122,19 +124,6 @@ impl From<Result<BlockValidateOk, BlockValidateReject>> for BlockValidateRespons
     }
 }
 
-impl<T> From<T> for BlockValidateReject
-where
-    T: Into<ChainError>,
-{
-    fn from(value: T) -> Self {
-        let ce: ChainError = value.into();
-        BlockValidateReject {
-            reason: format!("Chainstate Error: {ce}"),
-            reason_code: ValidateRejectCode::ChainstateError,
-        }
-    }
-}
-
 /// Represents a block proposed to the `v2/block_proposal` endpoint for validation
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct NakamotoBlockProposal {
@@ -182,16 +171,28 @@ impl NakamotoBlockProposal {
         let mainnet = self.chain_id == CHAIN_ID_MAINNET;
         if self.chain_id != chainstate.chain_id || mainnet != chainstate.mainnet {
             return Err(BlockValidateReject {
+                block: self.block.clone(),
                 reason_code: ValidateRejectCode::InvalidBlock,
                 reason: "Wrong network/chain_id".into(),
             });
         }
 
         let burn_dbconn = sortdb.index_conn();
-        let sort_tip = SortitionDB::get_canonical_sortition_tip(sortdb.conn())?;
+        let sort_tip = SortitionDB::get_canonical_sortition_tip(sortdb.conn()).map_err(|ce| {
+            BlockValidateReject {
+                block: self.block.clone(),
+                reason: format!("Chainstate Error: {ce}"),
+                reason_code: ValidateRejectCode::ChainstateError,
+            }
+        })?;
         let mut db_handle = sortdb.index_handle(&sort_tip);
         let expected_burn =
-            NakamotoChainState::get_expected_burns(&mut db_handle, chainstate.db(), &self.block)?;
+            NakamotoChainState::get_expected_burns(&mut db_handle, chainstate.db(), &self.block)
+                .map_err(|ce| BlockValidateReject {
+                    block: self.block.clone(),
+                    reason: format!("Chainstate Error: {ce}"),
+                    reason_code: ValidateRejectCode::ChainstateError,
+                })?;
 
         // Static validation checks
         NakamotoChainState::validate_nakamoto_block_burnchain(
@@ -200,14 +201,25 @@ impl NakamotoBlockProposal {
             &self.block,
             mainnet,
             self.chain_id,
-        )?;
+        )
+        .map_err(|ce| BlockValidateReject {
+            block: self.block.clone(),
+            reason: format!("Chainstate Error: {ce}"),
+            reason_code: ValidateRejectCode::ChainstateError,
+        })?;
 
         // Validate txs against chainstate
         let parent_stacks_header = NakamotoChainState::get_block_header(
             chainstate.db(),
             &self.block.header.parent_block_id,
-        )?
+        )
+        .map_err(|ce| BlockValidateReject {
+            block: self.block.clone(),
+            reason: format!("Chainstate Error: {ce}"),
+            reason_code: ValidateRejectCode::ChainstateError,
+        })?
         .ok_or_else(|| BlockValidateReject {
+            block: self.block.clone(),
             reason_code: ValidateRejectCode::InvalidBlock,
             reason: "Invalid parent block".into(),
         })?;
@@ -232,11 +244,27 @@ impl NakamotoBlockProposal {
             self.block.header.burn_spent,
             tenure_change,
             coinbase,
-        )?;
+        )
+        .map_err(|ce| BlockValidateReject {
+            block: self.block.clone(),
+            reason: format!("Chainstate Error: {ce}"),
+            reason_code: ValidateRejectCode::ChainstateError,
+        })?;
 
-        let mut miner_tenure_info =
-            builder.load_tenure_info(chainstate, &burn_dbconn, tenure_cause)?;
-        let mut tenure_tx = builder.tenure_begin(&burn_dbconn, &mut miner_tenure_info)?;
+        let mut miner_tenure_info = builder
+            .load_tenure_info(chainstate, &burn_dbconn, tenure_cause)
+            .map_err(|ce| BlockValidateReject {
+                block: self.block.clone(),
+                reason: format!("Chainstate Error: {ce}"),
+                reason_code: ValidateRejectCode::ChainstateError,
+            })?;
+        let mut tenure_tx = builder
+            .tenure_begin(&burn_dbconn, &mut miner_tenure_info)
+            .map_err(|ce| BlockValidateReject {
+                block: self.block.clone(),
+                reason: format!("Chainstate Error: {ce}"),
+                reason_code: ValidateRejectCode::ChainstateError,
+            })?;
 
         for (i, tx) in self.block.txs.iter().enumerate() {
             let tx_len = tx.tx_len();
@@ -264,6 +292,7 @@ impl NakamotoBlockProposal {
                     "tx" => ?tx,
                 );
                 return Err(BlockValidateReject {
+                    block: self.block.clone(),
                     reason,
                     reason_code: ValidateRejectCode::BadTransaction,
                 });
@@ -293,6 +322,7 @@ impl NakamotoBlockProposal {
                 //"computed_block" => %serde_json::to_string(&serde_json::to_value(&block).unwrap()).unwrap(),
             );
             return Err(BlockValidateReject {
+                block: self.block.clone(),
                 reason: "Block hash is not as expected".into(),
                 reason_code: ValidateRejectCode::BadBlockHash,
             });

From afd45fe7cd65ca523d4957cf4f75b1b528dcf763 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Thu, 11 Jan 2024 14:15:35 -0500
Subject: [PATCH 0371/1166] Remove use of pox contract and miners contract
 configs and update test

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 Cargo.lock                                    |   1 -
 libsigner/Cargo.toml                          |   1 -
 libsigner/src/events.rs                       |  31 ++
 stacks-signer/src/cli.rs                      |   6 -
 stacks-signer/src/client/stackerdb.rs         | 225 +++----------
 stacks-signer/src/client/stacks_client.rs     | 102 ++----
 stacks-signer/src/config.rs                   |  35 +--
 stacks-signer/src/main.rs                     |   8 +-
 stacks-signer/src/runloop.rs                  | 245 ++++++++-------
 stacks-signer/src/tests/conf/signer-0.toml    |   1 -
 stacks-signer/src/tests/conf/signer-1.toml    |   1 -
 stacks-signer/src/tests/conf/signer-2.toml    |   1 -
 stacks-signer/src/tests/conf/signer-3.toml    |   1 -
 stacks-signer/src/tests/conf/signer-4.toml    |   1 -
 stacks-signer/src/utils.rs                    |  11 -
 .../src/tests/nakamoto_integrations.rs        |   8 +-
 testnet/stacks-node/src/tests/signer.rs       | 296 ++++++++----------
 17 files changed, 394 insertions(+), 580 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 5d5061bb7f..03febb2e39 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1971,7 +1971,6 @@ dependencies = [
 name = "libsigner"
 version = "0.0.1"
 dependencies = [
- "bincode",
  "clarity",
  "libc",
  "libstackerdb",
diff --git a/libsigner/Cargo.toml b/libsigner/Cargo.toml
index 73fad53a8b..ee7338ea17 100644
--- a/libsigner/Cargo.toml
+++ b/libsigner/Cargo.toml
@@ -17,7 +17,6 @@ path = "./src/libsigner.rs"
 
 [dependencies]
 clarity = { path = "../clarity" }
-bincode = "1.3.3"
 libc = "0.2"
 libstackerdb = { path = "../libstackerdb" }
 serde = "1"
diff --git a/libsigner/src/events.rs b/libsigner/src/events.rs
index a86d47df59..a8ab01563f 100644
--- a/libsigner/src/events.rs
+++ b/libsigner/src/events.rs
@@ -38,6 +38,35 @@ use wsts::net::{Message, Packet};
 use crate::http::{decode_http_body, decode_http_request};
 use crate::EventError;
 
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[repr(u8)]
+enum EventPrefix {
+    /// A StackerDB event
+    StackerDB,
+    /// A block proposal event
+    BlockProposal,
+}
+
+impl From<&SignerEvent> for EventPrefix {
+    fn from(event: &SignerEvent) -> Self {
+        match event {
+            SignerEvent::StackerDB(_) => EventPrefix::StackerDB,
+            SignerEvent::BlockProposal(_) => EventPrefix::BlockProposal,
+        }
+    }
+}
+impl TryFrom<u8> for EventPrefix {
+    type Error = ();
+
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        match value {
+            0 => Ok(EventPrefix::StackerDB),
+            1 => Ok(EventPrefix::BlockProposal),
+            _ => Err(()),
+        }
+    }
+}
+
 /// Event enum for newly-arrived signer subscribed events
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub enum SignerEvent {
@@ -218,6 +247,7 @@ impl EventReceiver for SignerEventReceiver {
                 )));
             }
             if request.url() == "/stackerdb_chunks" {
+                debug!("Got stackerdb_chunks event");
                 let mut body = String::new();
                 request
                     .as_reader()
@@ -235,6 +265,7 @@ impl EventReceiver for SignerEventReceiver {
 
                 Ok(SignerEvent::StackerDB(event))
             } else if request.url() == "/proposal_response" {
+                debug!("Got proposal_response event");
                 let mut body = String::new();
                 request
                     .as_reader()
diff --git a/stacks-signer/src/cli.rs b/stacks-signer/src/cli.rs
index 0e368ac4c8..65aa8ccafc 100644
--- a/stacks-signer/src/cli.rs
+++ b/stacks-signer/src/cli.rs
@@ -131,9 +131,6 @@ pub struct GenerateFilesArgs {
     /// The signers stacker-db contract to use. Must be in the format of "STACKS_ADDRESS.CONTRACT_NAME"
     #[arg(short, long, value_parser = parse_contract)]
     pub signers_contract: QualifiedContractIdentifier,
-    /// The miners stacker-db contract to use. Must be in the format of "STACKS_ADDRESS.CONTRACT_NAME"
-    #[arg(short, long, value_parser = parse_contract)]
-    pub miners_contract: QualifiedContractIdentifier,
     #[arg(
         long,
         required_unless_present = "signer_private_keys",
@@ -144,9 +141,6 @@ pub struct GenerateFilesArgs {
     #[clap(long, value_name = "FILE")]
     /// A path to a file containing a list of hexadecimal Stacks private keys of the signers
     pub signer_private_keys: Option<PathBuf>,
-    /// The Stacks private key to use in hexademical format for the miner
-    #[arg(long, value_parser = parse_private_key)]
-    pub miner_private_key: StacksPrivateKey,
     #[arg(long)]
     /// The total number of key ids to distribute among the signers
     pub num_keys: u32,
diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index b53467b5e7..7032bcdcb2 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -1,10 +1,12 @@
+use blockstack_lib::burnchains::Txid;
 use blockstack_lib::chainstate::nakamoto::NakamotoBlock;
+use blockstack_lib::net::api::postblock_proposal::ValidateRejectCode;
 use clarity::vm::types::QualifiedContractIdentifier;
 use hashbrown::HashMap;
 use libsigner::{SignerSession, StackerDBSession};
 use libstackerdb::{StackerDBChunkAckData, StackerDBChunkData};
+use serde_derive::{Deserialize, Serialize};
 use slog::{slog_debug, slog_warn};
-use stacks_common::codec::{Error as CodecError, StacksMessageCodec};
 use stacks_common::types::chainstate::StacksPrivateKey;
 use stacks_common::{debug, warn};
 use wsts::net::{Message, Packet};
@@ -17,8 +19,6 @@ use crate::config::Config;
 /// See: https://github.com/stacks-network/stacks-blockchain/issues/3921
 /// Is equal to the number of message types
 pub const SIGNER_SLOTS_PER_USER: u32 = 10;
-/// The number of miner slots available per miner
-pub const MINER_SLOTS_PER_USER: u32 = 1;
 
 // The slot IDS for each message type
 const DKG_BEGIN_SLOT_ID: u32 = 0;
@@ -32,89 +32,63 @@ const SIGNATURE_SHARE_REQUEST_SLOT_ID: u32 = 7;
 const SIGNATURE_SHARE_RESPONSE_SLOT_ID: u32 = 8;
 const BLOCK_SLOT_ID: u32 = 9;
 
-/// This is required for easy serialization of the various StackerDBMessage types
-#[repr(u8)]
-enum TypePrefix {
-    Block,
-    Packet,
+/// The messages being sent through the stacker db contracts
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum SignerMessage {
+    /// The signed/validated Nakamoto block for miners to observe
+    BlockResponse(BlockResponse),
+    /// DKG and Signing round data for other signers to observe
+    Packet(Packet),
 }
 
-impl TypePrefix {
-    /// Convert a u8 to a TypePrefix
-    fn from_u8(value: u8) -> Option<Self> {
-        match value {
-            0 => Some(Self::Block),
-            1 => Some(Self::Packet),
-            _ => None,
-        }
-    }
+/// The response that a signer sends back to observing miners
+/// either accepting or rejecting a Nakamoto block with the corresponding reason
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum BlockResponse {
+    /// The Nakamoto block was accepted and therefore signed
+    Accepted(NakamotoBlock),
+    /// The Nakamoto block was rejected and therefore not signed
+    Rejected(BlockRejection),
 }
 
-impl From<&StackerDBMessage> for TypePrefix {
-    fn from(message: &StackerDBMessage) -> TypePrefix {
-        match message {
-            StackerDBMessage::Block(_) => TypePrefix::Block,
-            StackerDBMessage::Packet(_) => TypePrefix::Packet,
-        }
-    }
+/// A rejection response from a signer for a proposed block
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BlockRejection {
+    /// The reason for the rejection
+    pub reason: String,
+    /// The reason code for the rejection
+    pub reason_code: RejectCode,
+    /// The block that was rejected
+    pub block: NakamotoBlock,
 }
 
-/// The StackerDB messages that can be sent through the observed contracts
-pub enum StackerDBMessage {
-    /// The latest Nakamoto block for miners to observe
-    Block(NakamotoBlock),
-    /// DKG and Signing round data for other signers to observe
-    Packet(Packet),
+/// This enum is used to supply a `reason_code` for block rejections
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[repr(u8)]
+pub enum RejectCode {
+    /// RPC endpoint Validation failed
+    ValidationFailed(ValidateRejectCode),
+    /// Missing expected transactions
+    MissingTransactions(Vec<Txid>),
 }
 
-impl From<Packet> for StackerDBMessage {
+impl From<Packet> for SignerMessage {
     fn from(packet: Packet) -> Self {
         Self::Packet(packet)
     }
 }
 
-impl StacksMessageCodec for StackerDBMessage {
-    fn consensus_serialize<W: std::io::Write>(&self, fd: &mut W) -> Result<(), CodecError> {
-        fd.write_all(&[TypePrefix::from(self) as u8])
-            .map_err(CodecError::WriteError)?;
-        match self {
-            StackerDBMessage::Packet(packet) => {
-                let message_bytes = bincode::serialize(&packet)
-                    .map_err(|e| CodecError::SerializeError(e.to_string()))?;
-                message_bytes.consensus_serialize(fd)
-            }
-            StackerDBMessage::Block(block) => block.consensus_serialize(fd),
-        }
-    }
-
-    fn consensus_deserialize<R: std::io::Read>(fd: &mut R) -> Result<Self, CodecError> {
-        let mut prefix = [0];
-        fd.read_exact(&mut prefix)
-            .map_err(|e| CodecError::DeserializeError(e.to_string()))?;
-        let prefix = TypePrefix::from_u8(prefix[0]).ok_or(CodecError::DeserializeError(
-            "Bad StackerDBMessage prefix".into(),
-        ))?;
-
-        match prefix {
-            TypePrefix::Packet => {
-                let message_bytes = Vec::<u8>::consensus_deserialize(fd)?;
-                let packet = bincode::deserialize(&message_bytes)
-                    .map_err(|e| CodecError::DeserializeError(e.to_string()))?;
-                Ok(Self::Packet(packet))
-            }
-            TypePrefix::Block => {
-                let block = NakamotoBlock::consensus_deserialize(fd)?;
-                Ok(StackerDBMessage::Block(block))
-            }
-        }
+impl From<BlockResponse> for SignerMessage {
+    fn from(block_response: BlockResponse) -> Self {
+        Self::BlockResponse(block_response)
     }
 }
 
-impl StackerDBMessage {
+impl SignerMessage {
     /// Helper function to determine the slot ID for the provided stacker-db writer id
     pub fn slot_id(&self, id: u32) -> u32 {
         let slot_id = match self {
-            StackerDBMessage::Packet(packet) => match packet.msg {
+            Self::Packet(packet) => match packet.msg {
                 Message::DkgBegin(_) => DKG_BEGIN_SLOT_ID,
                 Message::DkgPrivateBegin(_) => DKG_PRIVATE_BEGIN_SLOT_ID,
                 Message::DkgEnd(_) => DKG_END_SLOT_ID,
@@ -125,17 +99,16 @@ impl StackerDBMessage {
                 Message::SignatureShareRequest(_) => SIGNATURE_SHARE_REQUEST_SLOT_ID,
                 Message::SignatureShareResponse(_) => SIGNATURE_SHARE_RESPONSE_SLOT_ID,
             },
-            Self::Block(_block) => BLOCK_SLOT_ID,
+            Self::BlockResponse(_) => BLOCK_SLOT_ID,
         };
         SIGNER_SLOTS_PER_USER * id + slot_id
     }
 }
-/// The StackerDB client for communicating with both .signers and .miners contracts
+
+/// The StackerDB client for communicating with the .signers contract
 pub struct StackerDB {
     /// The stacker-db session for the signer StackerDB
     signers_stackerdb_session: StackerDBSession,
-    /// The stacker-db session for the .miners StackerDB
-    miners_stackerdb_session: StackerDBSession,
     /// The private key used in all stacks node communications
     stacks_private_key: StacksPrivateKey,
     /// A map of a slot ID to last chunk version
@@ -149,10 +122,6 @@ impl From<&Config> for StackerDB {
                 config.node_host,
                 config.signers_stackerdb_contract_id.clone(),
             ),
-            miners_stackerdb_session: StackerDBSession::new(
-                config.node_host,
-                config.miners_stackerdb_contract_id.clone(),
-            ),
             stacks_private_key: config.stacks_private_key,
             slot_versions: HashMap::new(),
         }
@@ -160,13 +129,13 @@ impl From<&Config> for StackerDB {
 }
 
 impl StackerDB {
-    /// Sends messages to the stacker-db with an exponential backoff retry
+    /// Sends messages to the .signers stacker-db with an exponential backoff retry
     pub fn send_message_with_retry(
         &mut self,
         id: u32,
-        message: StackerDBMessage,
+        message: SignerMessage,
     ) -> Result<StackerDBChunkAckData, ClientError> {
-        let message_bytes = message.serialize_to_vec();
+        let message_bytes = bincode::serialize(&message).unwrap();
         let slot_id = message.slot_id(id);
 
         loop {
@@ -201,108 +170,8 @@ impl StackerDB {
         }
     }
 
-    /// Retrieve the miner contract id
-    pub fn miners_contract_id(&self) -> &QualifiedContractIdentifier {
-        &self.miners_stackerdb_session.stackerdb_contract_id
-    }
-
     /// Retrieve the signer contract id
     pub fn signers_contract_id(&self) -> &QualifiedContractIdentifier {
         &self.signers_stackerdb_session.stackerdb_contract_id
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use blockstack_lib::chainstate::nakamoto::{NakamotoBlock, NakamotoBlockHeader};
-    use blockstack_lib::chainstate::stacks::{StacksTransaction, ThresholdSignature};
-    use rand_core::OsRng;
-    use stacks_common::codec::StacksMessageCodec;
-    use stacks_common::types::chainstate::{ConsensusHash, StacksBlockId, TrieHash};
-    use stacks_common::util::hash::{MerkleTree, Sha512Trunc256Sum};
-    use stacks_common::util::secp256k1::MessageSignature;
-    use wsts::curve::scalar::Scalar;
-    use wsts::net::{Message, Packet, Signable, SignatureShareRequest};
-
-    use super::StackerDBMessage;
-
-    #[test]
-    fn serde_stackerdb_message_block() {
-        let txs: Vec<StacksTransaction> = vec![];
-        let mut header = NakamotoBlockHeader {
-            version: 1,
-            chain_length: 2,
-            burn_spent: 3,
-            consensus_hash: ConsensusHash([0x04; 20]),
-            parent_block_id: StacksBlockId([0x05; 32]),
-            tx_merkle_root: Sha512Trunc256Sum([0x06; 32]),
-            state_index_root: TrieHash([0x07; 32]),
-            miner_signature: MessageSignature::empty(),
-            signer_signature: ThresholdSignature::mock(),
-        };
-        let txid_vecs = txs.iter().map(|tx| tx.txid().as_bytes().to_vec()).collect();
-
-        let merkle_tree = MerkleTree::<Sha512Trunc256Sum>::new(&txid_vecs);
-        let tx_merkle_root = merkle_tree.root();
-
-        header.tx_merkle_root = tx_merkle_root;
-
-        let block = NakamotoBlock { header, txs };
-
-        let msg = StackerDBMessage::Block(block.clone());
-        let serialized_bytes = msg.serialize_to_vec();
-        let deserialized_msg =
-            StackerDBMessage::consensus_deserialize(&mut &serialized_bytes[..]).unwrap();
-        match deserialized_msg {
-            StackerDBMessage::Block(deserialized_block) => {
-                assert_eq!(deserialized_block, block);
-            }
-            _ => panic!("Wrong message type. Expected StackerDBMessage::Block"),
-        }
-    }
-
-    #[test]
-    fn serde_stackerdb_message_packet() {
-        let mut rng = OsRng;
-        let private_key = Scalar::random(&mut rng);
-        let to_sign = "One, two, three, four, five? That's amazing. I've got the same combination on my luggage.".as_bytes();
-        let sig_share_request = SignatureShareRequest {
-            dkg_id: 1,
-            sign_id: 5,
-            sign_iter_id: 4,
-            nonce_responses: vec![],
-            message: to_sign.to_vec(),
-            is_taproot: false,
-            merkle_root: None,
-        };
-        let packet = Packet {
-            sig: sig_share_request
-                .sign(&private_key)
-                .expect("Failed to sign SignatureShareRequest"),
-            msg: Message::SignatureShareRequest(sig_share_request),
-        };
-
-        let msg = StackerDBMessage::Packet(packet.clone());
-        let serialized_bytes = msg.serialize_to_vec();
-        let deserialized_msg =
-            StackerDBMessage::consensus_deserialize(&mut &serialized_bytes[..]).unwrap();
-        match deserialized_msg {
-            StackerDBMessage::Packet(deserialized_packet) => {
-                assert_eq!(deserialized_packet.sig, packet.sig);
-                match deserialized_packet.msg {
-                    Message::SignatureShareRequest(deserialized_message) => {
-                        assert_eq!(deserialized_message.dkg_id, 1);
-                        assert_eq!(deserialized_message.sign_id, 5);
-                        assert_eq!(deserialized_message.sign_iter_id, 4);
-                        assert!(deserialized_message.nonce_responses.is_empty());
-                        assert_eq!(deserialized_message.message.as_slice(), to_sign);
-                        assert!(!deserialized_message.is_taproot);
-                        assert!(deserialized_message.merkle_root.is_none());
-                    }
-                    _ => panic!("Wrong message type. Expected Message::SignatureShareRequest"),
-                }
-            }
-            _ => panic!("Wrong message type. Expected StackerDBMessage::Packet."),
-        }
-    }
-}
diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index d80bbe9269..677f722420 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -1,5 +1,6 @@
 use blockstack_lib::burnchains::Txid;
 use blockstack_lib::chainstate::nakamoto::NakamotoBlock;
+use blockstack_lib::chainstate::stacks::boot::POX_4_NAME;
 use blockstack_lib::chainstate::stacks::{
     StacksTransaction, StacksTransactionSigner, TransactionAnchorMode, TransactionAuth,
     TransactionContractCall, TransactionPayload, TransactionPostConditionMode,
@@ -8,15 +9,15 @@ use blockstack_lib::chainstate::stacks::{
 use blockstack_lib::net::api::callreadonly::CallReadOnlyResponse;
 use blockstack_lib::net::api::getpoxinfo::RPCPoxInfoData;
 use blockstack_lib::net::api::postblock_proposal::NakamotoBlockProposal;
-use clarity::vm::types::{QualifiedContractIdentifier, SequenceData};
+use blockstack_lib::util_lib::boot::boot_code_id;
 use clarity::vm::{ClarityName, ContractName, Value as ClarityValue};
 use serde_json::json;
 use slog::slog_debug;
 use stacks_common::codec::StacksMessageCodec;
+use stacks_common::consts::CHAIN_ID_MAINNET;
 use stacks_common::debug;
 use stacks_common::types::chainstate::{StacksAddress, StacksPrivateKey, StacksPublicKey};
-use wsts::curve::point::Point;
-use wsts::curve::scalar::Scalar;
+use wsts::curve::point::{Compressed, Point};
 
 use crate::client::{retry_with_exponential_backoff, ClientError};
 use crate::config::Config;
@@ -35,8 +36,6 @@ pub struct StacksClient {
     chain_id: u32,
     /// The Client used to make HTTP connects
     stacks_node_client: reqwest::blocking::Client,
-    /// The pox contract ID
-    pox_contract_id: Option<QualifiedContractIdentifier>,
 }
 
 impl From<&Config> for StacksClient {
@@ -48,7 +47,6 @@ impl From<&Config> for StacksClient {
             tx_version: config.network.to_transaction_version(),
             chain_id: config.network.to_chain_id(),
             stacks_node_client: reqwest::blocking::Client::new(),
-            pox_contract_id: config.pox_contract_id.clone(),
         }
     }
 }
@@ -79,32 +77,20 @@ impl StacksClient {
         if !response.status().is_success() {
             return Err(ClientError::RequestFailure(response.status()));
         }
-        // TODO: this is actually an aysnc call. It will not return the JSON response as below. It uses the event dispatcher instead
-        // let validate_block_response = response.json::<BlockValidateResponse>()?;
-        // match validate_block_response {
-        //     BlockValidateResponse::Ok(validate_block_ok) => {
-        //         debug!("Block validation succeeded: {:?}", validate_block_ok);
-        //         Ok(true)
-        //     }
-        //     BlockValidateResponse::Reject(validate_block_reject) => {
-        //         debug!("Block validation failed: {:?}", validate_block_reject);
-        //         Ok(false)
-        //     }
-        // }
         Ok(())
     }
 
     /// Retrieve the current DKG aggregate public key
     pub fn get_aggregate_public_key(&self) -> Result<Option<Point>, ClientError> {
         let reward_cycle = self.get_current_reward_cycle()?;
-        let function_name_str = "get-aggregate-public-key"; // FIXME: this may need to be modified to match .pox-4
+        let function_name_str = "get-aggregate-public-key";
         let function_name = ClarityName::try_from(function_name_str)
             .map_err(|_| ClientError::InvalidClarityName(function_name_str.to_string()))?;
-        let (contract_addr, contract_name) = self.get_pox_contract()?;
+        let pox_contract_id = boot_code_id(POX_4_NAME, self.chain_id == CHAIN_ID_MAINNET);
         let function_args = &[ClarityValue::UInt(reward_cycle as u128)];
         let contract_response_hex = self.read_only_contract_call_with_retry(
-            &contract_addr,
-            &contract_name,
+            &pox_contract_id.issuer.into(),
+            &pox_contract_id.name,
             &function_name,
             function_args,
         )?;
@@ -113,6 +99,7 @@ impl StacksClient {
 
     // Helper function to retrieve the pox data from the stacks node
     fn get_pox_data(&self) -> Result<RPCPoxInfoData, ClientError> {
+        debug!("Getting pox data...");
         let send_request = || {
             self.stacks_node_client
                 .get(self.pox_path())
@@ -140,38 +127,25 @@ impl StacksClient {
         todo!("Get the next possible nonce from the stacks node");
     }
 
-    /// Helper function to retrieve the pox contract address and name from the stacks node
-    fn get_pox_contract(&self) -> Result<(StacksAddress, ContractName), ClientError> {
-        // Check if we have overwritten the pox contract ID in the config
-        if let Some(pox_contract) = self.pox_contract_id.clone() {
-            return Ok((pox_contract.issuer.into(), pox_contract.name));
-        }
-        let pox_data = self.get_pox_data()?;
-        let contract_id = pox_data.contract_id.as_str();
-        let err_msg = format!("Stacks node returned an invalid pox contract id: {contract_id}");
-        let id = QualifiedContractIdentifier::parse(contract_id).expect(&err_msg);
-        Ok((id.issuer.into(), id.name))
-    }
-
     /// Helper function that attempts to deserialize a clarity hex string as the aggregate public key
     fn parse_aggregate_public_key(&self, hex: &str) -> Result<Option<Point>, ClientError> {
-        let public_key_clarity_value = ClarityValue::try_deserialize_hex_untyped(hex)?;
-        if let ClarityValue::Optional(optional_data) = public_key_clarity_value.clone() {
-            if let Some(ClarityValue::Sequence(SequenceData::Buffer(public_key))) =
-                optional_data.data.map(|boxed| *boxed)
-            {
-                if public_key.data.len() != 32 {
-                    return Err(ClientError::MalformedClarityValue(public_key_clarity_value));
-                }
-                let mut bytes = [0_u8; 32];
-                bytes.copy_from_slice(&public_key.data);
-                Ok(Some(Point::from(Scalar::from(bytes))))
-            } else {
-                Ok(None)
-            }
-        } else {
-            Err(ClientError::MalformedClarityValue(public_key_clarity_value))
-        }
+        debug!("Parsing aggregate public key: {hex}...");
+        // Due to pox 4 definition, the aggregate public key is always an optional clarity value hence the use of expect
+        // If this fails, we have bigger problems than the signer crashing...
+        let value_opt = ClarityValue::try_deserialize_hex_untyped(hex)?.expect_optional();
+        let Some(value) = value_opt else {
+            return Ok(None);
+        };
+        // A point should have 33 bytes exactly due to the pox 4 definition hence the use of expect
+        // If this fails, we have bigger problems than the signer crashing...
+        let data = value.clone().expect_buff(33);
+        // It is possible that the point was invalid though when voted upon and this cannot be prevented by pox 4 definitions...
+        // Pass up this error if the conversions fail.
+        let compressed_data = Compressed::try_from(data.as_slice())
+            .map_err(|_e| ClientError::MalformedClarityValue(value.clone()))?;
+        let point = Point::try_from(&compressed_data)
+            .map_err(|_e| ClientError::MalformedClarityValue(value))?;
+        Ok(Some(point))
     }
 
     /// Sends a transaction to the stacks node for a modifying contract call
@@ -268,7 +242,10 @@ impl StacksClient {
         function_name: &ClarityName,
         function_args: &[ClarityValue],
     ) -> Result<String, ClientError> {
-        debug!("Calling read-only function {}...", function_name);
+        debug!(
+            "Calling read-only function {function_name} with args {:?}...",
+            function_args
+        );
         let args = function_args
             .iter()
             .map(|arg| arg.serialize_to_hex())
@@ -469,21 +446,6 @@ mod tests {
         ));
     }
 
-    #[test]
-    fn pox_contract_success() {
-        let config = TestConfig::new();
-        let h = spawn(move || config.client.get_pox_contract());
-        write_response(
-            config.mock_server,
-            b"HTTP/1.1 200 Ok\n\n{\"contract_id\":\"ST000000000000000000002AMW42H.pox-3\",\"pox_activation_threshold_ustx\":829371801288885,\"first_burnchain_block_height\":2000000,\"current_burnchain_block_height\":2572192,\"prepare_phase_block_length\":50,\"reward_phase_block_length\":1000,\"reward_slots\":2000,\"rejection_fraction\":12,\"total_liquid_supply_ustx\":41468590064444294,\"current_cycle\":{\"id\":544,\"min_threshold_ustx\":5190000000000,\"stacked_ustx\":853258144644000,\"is_pox_active\":true},\"next_cycle\":{\"id\":545,\"min_threshold_ustx\":5190000000000,\"min_increment_ustx\":5183573758055,\"stacked_ustx\":847278759574000,\"prepare_phase_start_block_height\":2572200,\"blocks_until_prepare_phase\":8,\"reward_phase_start_block_height\":2572250,\"blocks_until_reward_phase\":58,\"ustx_until_pox_rejection\":4976230807733304},\"min_amount_ustx\":5190000000000,\"prepare_cycle_length\":50,\"reward_cycle_id\":544,\"reward_cycle_length\":1050,\"rejection_votes_left_required\":4976230807733304,\"next_reward_cycle_in\":58,\"contract_versions\":[{\"contract_id\":\"ST000000000000000000002AMW42H.pox\",\"activation_burnchain_block_height\":2000000,\"first_reward_cycle_id\":0},{\"contract_id\":\"ST000000000000000000002AMW42H.pox-2\",\"activation_burnchain_block_height\":2422102,\"first_reward_cycle_id\":403},{\"contract_id\":\"ST000000000000000000002AMW42H.pox-3\",\"activation_burnchain_block_height\":2432545,\"first_reward_cycle_id\":412}]}",
-        );
-        let (address, name) = h.join().unwrap().unwrap();
-        assert_eq!(
-            (address.to_string().as_str(), name.to_string().as_str()),
-            ("ST000000000000000000002AMW42H", "pox-3")
-        );
-    }
-
     #[test]
     fn valid_reward_cycle_should_succeed() {
         let config = TestConfig::new();
@@ -524,14 +486,14 @@ mod tests {
     fn parse_valid_aggregate_public_key_should_succeed() {
         let config = TestConfig::new();
         let clarity_value_hex =
-            "0x0a0200000020b8c8b0652cb2851a52374c7acd47181eb031e8fa5c62883f636e0d4fe695d6ca";
+            "0x0a020000002103beca18a0e51ea31d8e66f58a245d54791b277ad08e1e9826bf5f814334ac77e0";
         let result = config
             .client
             .parse_aggregate_public_key(clarity_value_hex)
             .unwrap();
         assert_eq!(
             result.map(|point| point.to_string()),
-            Some("yzwdjwPz36Has1MSkg8JGwo38avvATkiTZvRiH1e5MLd".to_string())
+            Some("27XiJwhYDWdUrYAFNejKDhmY22jU1hmwyQ5nVDUJZPmbm".to_string())
         );
 
         let clarity_value_hex = "0x09";
diff --git a/stacks-signer/src/config.rs b/stacks-signer/src/config.rs
index 4e1a53dffe..61ca95fa3a 100644
--- a/stacks-signer/src/config.rs
+++ b/stacks-signer/src/config.rs
@@ -55,7 +55,7 @@ pub enum ConfigError {
     UnsupportedAddressVersion,
 }
 
-#[derive(serde::Deserialize, Debug, Clone)]
+#[derive(serde::Deserialize, Debug, Clone, PartialEq)]
 #[serde(rename_all = "lowercase")]
 /// The Stacks network to use.
 pub enum Network {
@@ -101,10 +101,6 @@ pub struct Config {
     pub endpoint: SocketAddr,
     /// smart contract that controls the target signers' stackerdb
     pub signers_stackerdb_contract_id: QualifiedContractIdentifier,
-    /// smart contract that controls the target .miners stackerdb
-    pub miners_stackerdb_contract_id: QualifiedContractIdentifier,
-    /// the pox contract identifier to use
-    pub pox_contract_id: Option<QualifiedContractIdentifier>,
     /// The Scalar representation of the private key for signer communication
     pub message_private_key: Scalar,
     /// The signer's Stacks private key
@@ -145,13 +141,9 @@ struct RawConfigFile {
     pub node_host: String,
     /// endpoint to event receiver
     pub endpoint: String,
-    // FIXME: these contract's should go away in non testing scenarios. Make them both optionals.
+    // FIXME: this should go away once .signers contract exists
     /// Signers' Stacker db contract identifier
     pub signers_stackerdb_contract_id: String,
-    /// Miners' Stacker db contract identifier
-    pub miners_stackerdb_contract_id: String,
-    /// pox contract identifier
-    pub pox_contract_id: Option<String>,
     /// the 32 byte ECDSA private key used to sign blocks, chunks, and transactions
     pub message_private_key: String,
     /// The hex representation of the signer's Stacks private key used for communicating
@@ -233,27 +225,6 @@ impl TryFrom<RawConfigFile> for Config {
             )
         })?;
 
-        let miners_stackerdb_contract_id = QualifiedContractIdentifier::parse(
-            &raw_data.miners_stackerdb_contract_id,
-        )
-        .map_err(|_| {
-            ConfigError::BadField(
-                "miners_stackerdb_contract_id".to_string(),
-                raw_data.miners_stackerdb_contract_id,
-            )
-        })?;
-
-        let pox_contract_id = if let Some(id) = raw_data.pox_contract_id.as_ref() {
-            Some(QualifiedContractIdentifier::parse(id).map_err(|_| {
-                ConfigError::BadField(
-                    "pox_contract_id".to_string(),
-                    raw_data.pox_contract_id.unwrap_or("".to_string()),
-                )
-            })?)
-        } else {
-            None
-        };
-
         let message_private_key =
             Scalar::try_from(raw_data.message_private_key.as_str()).map_err(|_| {
                 ConfigError::BadField(
@@ -305,8 +276,6 @@ impl TryFrom<RawConfigFile> for Config {
             node_host,
             endpoint,
             signers_stackerdb_contract_id,
-            miners_stackerdb_contract_id,
-            pox_contract_id,
             message_private_key,
             stacks_private_key,
             stacks_address,
diff --git a/stacks-signer/src/main.rs b/stacks-signer/src/main.rs
index 5187f9a522..1a41918712 100644
--- a/stacks-signer/src/main.rs
+++ b/stacks-signer/src/main.rs
@@ -47,7 +47,7 @@ use stacks_signer::cli::{
     Cli, Command, GenerateFilesArgs, GetChunkArgs, GetLatestChunkArgs, PutChunkArgs, RunDkgArgs,
     SignArgs, StackerDBArgs,
 };
-use stacks_signer::client::{MINER_SLOTS_PER_USER, SIGNER_SLOTS_PER_USER};
+use stacks_signer::client::SIGNER_SLOTS_PER_USER;
 use stacks_signer::config::{Config, Network};
 use stacks_signer::runloop::{RunLoop, RunLoopCommand};
 use stacks_signer::utils::{build_signer_config_tomls, build_stackerdb_contract};
@@ -274,22 +274,16 @@ fn handle_generate_files(args: GenerateFilesArgs) {
         .iter()
         .map(|key| to_addr(key, &args.network))
         .collect::<Vec<StacksAddress>>();
-    let miner_stacks_address = to_addr(&args.miner_private_key, &args.network);
     // Build the signer and miner stackerdb contract
     let signer_stackerdb_contract =
         build_stackerdb_contract(&signer_stacks_addresses, SIGNER_SLOTS_PER_USER);
-    let miner_stackerdb_contract =
-        build_stackerdb_contract(&[miner_stacks_address], MINER_SLOTS_PER_USER);
     write_file(&args.dir, "signers.clar", &signer_stackerdb_contract);
-    write_file(&args.dir, "miners.clar", &miner_stackerdb_contract);
 
     let signer_config_tomls = build_signer_config_tomls(
         &signer_stacks_private_keys,
         args.num_keys,
         &args.host.to_string(),
         &args.signers_contract.to_string(),
-        &args.miners_contract.to_string(),
-        None,
         args.timeout.map(Duration::from_millis),
     );
     debug!("Built {:?} signer config tomls.", signer_config_tomls.len());
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 9ffcd649f7..068cdfaee8 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -2,8 +2,11 @@ use std::collections::VecDeque;
 use std::sync::mpsc::Sender;
 use std::time::Duration;
 
+use blockstack_lib::chainstate::nakamoto::NakamotoBlock;
+use blockstack_lib::chainstate::stacks::boot::MINERS_NAME;
 use blockstack_lib::net::api::postblock_proposal::BlockValidateResponse;
 use blockstack_lib::net::api::poststackerdbchunk::StackerDBChunksEvent;
+use blockstack_lib::util_lib::boot::boot_code_id;
 use hashbrown::{HashMap, HashSet};
 use libsigner::{SignerEvent, SignerRunLoop};
 use slog::{slog_debug, slog_error, slog_info, slog_warn};
@@ -19,9 +22,10 @@ use wsts::state_machine::{OperationResult, PublicKeys};
 use wsts::v2;
 
 use crate::client::{
-    retry_with_exponential_backoff, ClientError, StackerDB, StackerDBMessage, StacksClient,
+    retry_with_exponential_backoff, BlockRejection, BlockResponse, ClientError, RejectCode,
+    SignerMessage, StackerDB, StacksClient,
 };
-use crate::config::Config;
+use crate::config::{Config, Network};
 
 /// Which operation to perform
 #[derive(PartialEq, Clone)]
@@ -71,6 +75,8 @@ pub struct RunLoop<C> {
     pub commands: VecDeque<RunLoopCommand>,
     /// The current state
     pub state: State,
+    /// Wether mainnet or not
+    pub mainnet: bool,
 }
 
 impl<C: Coordinator> RunLoop<C> {
@@ -82,6 +88,7 @@ impl<C: Coordinator> RunLoop<C> {
             debug!("Aggregate public key is set: {:?}", key);
             self.coordinator.set_aggregate_public_key(Some(key));
         } else {
+            debug!("Aggregate public key is not set. Coordinator must trigger DKG...");
             // Update the state to IDLE so we don't needlessy requeue the DKG command.
             let (coordinator_id, _) = calculate_coordinator(&self.signing_round.public_keys);
             if coordinator_id == self.signing_round.signer_id
@@ -171,130 +178,144 @@ impl<C: Coordinator> RunLoop<C> {
         }
     }
 
-    /// Handle block proposal from the miners stacker-db contract
+    /// Handle the block validate response returned from our prior calls to submit a block for validation
     fn handle_block_validate_response(&mut self, block_validate_response: BlockValidateResponse) {
         match block_validate_response {
             BlockValidateResponse::Ok(block_validate_ok) => {
                 // This is a valid block proposal from the miner. Trigger a signing round for it.
-                self.commands.push_back(RunLoopCommand::Sign {
-                    message: block_validate_ok.block.serialize_to_vec(),
-                    is_taproot: false,
-                    merkle_root: None,
-                });
-            }
-            BlockValidateResponse::Reject(_block_validate_reject) => {
-                // TODO: send a message to the miner to let them know their block was rejected
-                todo!("Send a message to the miner to let them know their block was rejected");
+                let (coordinator_id, _) = calculate_coordinator(&self.signing_round.public_keys);
+                if coordinator_id == self.signing_round.signer_id {
+                    // We are the coordinator. Trigger a signing round for this block
+                    self.commands.push_back(RunLoopCommand::Sign {
+                        message: block_validate_ok.block.serialize_to_vec(),
+                        is_taproot: false,
+                        merkle_root: None,
+                    });
+                }
             }
-        }
-    }
-
-    /// Process the event as a miner message from the miner stacker-db
-    fn process_event_miner(&mut self, event: &StackerDBChunksEvent) {
-        event.modified_slots.iter().for_each(|chunk| {
-            let mut ptr = &chunk.data[..];
-            let Some(stacker_db_message) = read_next::<StackerDBMessage, _>(&mut ptr).ok() else {
-                warn!("Received an unrecognized message type from .miners stacker-db slot id {}: {:?}", chunk.slot_id, ptr);
-                return;
-            };
-            match stacker_db_message {
-                StackerDBMessage::Packet(_packet) => {
-                    // We should never actually be receiving packets from the miner stacker-db.
+            BlockValidateResponse::Reject(block_validate_reject) => {
+                warn!(
+                    "Received a block proposal that was rejected by the stacks node: {:?}",
+                    block_validate_reject
+                );
+                // TODO: submit a rejection response to the .signers contract for miners
+                // to observe so they know to ignore it and to prove signers are doing work
+                let block_rejection = BlockRejection {
+                    block: block_validate_reject.block,
+                    reason: block_validate_reject.reason,
+                    reason_code: RejectCode::ValidationFailed(block_validate_reject.reason_code),
+                };
+                let message =
+                    SignerMessage::BlockResponse(BlockResponse::Rejected(block_rejection));
+                if let Err(e) = self
+                    .stackerdb
+                    .send_message_with_retry(self.signing_round.signer_id, message)
+                {
                     warn!(
-                        "Received a packet from the miner stacker-db. This should never happen..."
+                        "Failed to send block rejection response to stacker-db: {:?}",
+                        e
                     );
                 }
-                StackerDBMessage::Block(block) => {
-                    // Received a block proposal from the miner.
-                    // Submit it to the stacks node to validate it before triggering a signing round.
-                        self.stacks_client.submit_block_for_validation(block).unwrap_or_else(|e| {
-                            warn!("Failed to validate block: {:?}", e);
-                        });
-
-                        // TODO: dependent on https://github.com/stacks-network/stacks-core/issues/4018
-                        // let miner_public_key = self.stacks_client.get_miner_public_key().expect("Failed to get miner public key. Cannot verify blocks.");
-                        // let Some(block_miner_public_key) = block.header.recover_miner_pk() else {
-                        //     warn!("Failed to recover miner public key from block. Ignoring block proposal: {:?}", block);
-                        //     return;
-                        // };
-                        // if block_miner_public_key != miner_public_key {
-                        //     warn!("Received a block proposal signed with an invalid miner public key. Ignoring block proposal: {:?}.", block);
-                        //     return;
-                        // }
-
-                }
             }
-        });
-    }
-
-    /// Process the event as a signer message from the signer stacker-db
-    fn handle_stackerdb_event(&mut self, event: &StackerDBChunksEvent) -> Vec<OperationResult> {
-        if event.contract_id == *self.stackerdb.miners_contract_id() {
-            self.process_event_miner(event);
-            vec![]
-        } else if event.contract_id == *self.stackerdb.signers_contract_id() {
-            self.process_event_signer(event)
-        } else {
-            warn!(
-                "Received an event from an unrecognized contract ID: {:?}",
-                event.contract_id
-            );
-            vec![]
         }
     }
 
-    // Process the event as a signer message from the signer stacker-db
-    fn process_event_signer(&mut self, event: &StackerDBChunksEvent) -> Vec<OperationResult> {
-        // Determine the current coordinator id and public key for verification
+    // Handle the stackerdb chunk event as a signer message
+    fn handle_stackerdb_chunk_event_signers(
+        &mut self,
+        stackerdb_chunk_event: StackerDBChunksEvent,
+        res: Sender<Vec<OperationResult>>,
+    ) {
         let (_coordinator_id, coordinator_public_key) =
             calculate_coordinator(&self.signing_round.public_keys);
-        // Filter out invalid messages
-        let inbound_messages: Vec<Packet> = event
+
+        let inbound_messages: Vec<Packet> = stackerdb_chunk_event
             .modified_slots
             .iter()
             .filter_map(|chunk| {
-                let mut ptr = &chunk.data[..];
-                let Some(stacker_db_message) = read_next::<StackerDBMessage, _>(&mut ptr).ok() else {
-                    warn!("Received an unrecognized message type from .signers stacker-db slot id {}: {:?}", chunk.slot_id, ptr);
-                    return None;
+                // We only care about verified wsts packets. Ignore anything else
+                let signer_message = bincode::deserialize::<SignerMessage>(&chunk.data).ok()?;
+                let packet = match signer_message {
+                    SignerMessage::Packet(packet) => packet,
+                    _ => return None, // This is a message for miners to observe. Ignore it.
                 };
-                match stacker_db_message {
-                    StackerDBMessage::Packet(packet) => {
-                        if packet.verify(
-                            &self.signing_round.public_keys,
-                            coordinator_public_key,
-                        ) {
-                            Some(packet)
-                        } else {
-                            None
-                        }
-                    }
-                    StackerDBMessage::Block(_block) => {
-                        // Blocks are meant to be read by observing miners. Ignore them.
-                        None
-                    }
+                if packet.verify(&self.signing_round.public_keys, &coordinator_public_key) {
+                    debug!("Verified wsts packet: {:?}", &packet);
+                    Some(packet)
+                } else {
+                    None
                 }
             })
             .collect();
+
         // First process all messages as a signer
         // TODO: deserialize the packet into a block and verify its contents
-        let mut outbound_messages = self
+        // TODO: we need to be able to sign yes or no on a block...this needs to propogate
+        // to the singning round/coordinator that we are signing yes or no on a block
+        // self.verify_block_transactions(&block);
+        let signer_outbound_messages = self
             .signing_round
             .process_inbound_messages(&inbound_messages)
             .unwrap_or_else(|e| {
                 error!("Failed to process inbound messages as a signer: {e}");
                 vec![]
             });
+
         // Next process the message as the coordinator
-        let (messages, operation_results) = self
+        let (coordinator_outbound_messages, operation_results) = self
             .coordinator
             .process_inbound_messages(&inbound_messages)
             .unwrap_or_else(|e| {
-                error!("Failed to process inbound messages as a signer: {e}");
+                error!("Failed to process inbound messages as a coordinator: {e}");
                 (vec![], vec![])
             });
 
-        outbound_messages.extend(messages);
+        self.send_outbound_messages(signer_outbound_messages);
+        self.send_outbound_messages(coordinator_outbound_messages);
+        self.send_operation_results(res, operation_results);
+    }
+
+    // Handle the stackerdb chunk event as a miner message
+    fn handle_stackerdb_chunk_event_miners(&mut self, stackerdb_chunk_event: StackerDBChunksEvent) {
+        for chunk in &stackerdb_chunk_event.modified_slots {
+            let mut ptr = &chunk.data[..];
+            let Some(block) = read_next::<NakamotoBlock, _>(&mut ptr).ok() else {
+                warn!("Received an unrecognized message type from .miners stacker-db slot id {}: {:?}", chunk.slot_id, ptr);
+                continue;
+            };
+
+            // Received a block proposal from the miner. Submit it for verification.
+            self.stacks_client
+                .submit_block_for_validation(block)
+                .unwrap_or_else(|e| {
+                    warn!("Failed to submit block for validation: {:?}", e);
+                });
+        }
+    }
+
+    /// Helper function to send operation results across the provided channel
+    fn send_operation_results(
+        &mut self,
+        res: Sender<Vec<OperationResult>>,
+        operation_results: Vec<OperationResult>,
+    ) {
+        let nmb_results = operation_results.len();
+        if nmb_results > 0 {
+            // We finished our command. Update the state
+            self.state = State::Idle;
+            match res.send(operation_results) {
+                Ok(_) => {
+                    debug!("Successfully sent {} operation result(s)", nmb_results)
+                }
+                Err(e) => {
+                    warn!("Failed to send operation results: {:?}", e);
+                }
+            }
+        }
+    }
+
+    // Helper function for sending packets through stackerdb
+    fn send_outbound_messages(&mut self, outbound_messages: Vec<Packet>) {
         debug!(
             "Sending {} messages to other stacker-db instances.",
             outbound_messages.len()
@@ -309,7 +330,6 @@ impl<C: Coordinator> RunLoop<C> {
                 warn!("Failed to send message to stacker-db instance: {:?}", ack);
             }
         }
-        operation_results
     }
 }
 
@@ -382,6 +402,7 @@ impl From<&Config> for RunLoop<FireCoordinator<v2::Aggregator>> {
             stackerdb,
             commands: VecDeque::new(),
             state: State::Uninitialized,
+            mainnet: config.network == Network::Mainnet,
         }
     }
 }
@@ -408,33 +429,43 @@ impl<C: Coordinator> SignerRunLoop<Vec<OperationResult>, RunLoopCommand> for Run
         if let Some(command) = cmd {
             self.commands.push_back(command);
         }
+        // TODO: This should be called every time as DKG can change at any time...but until we have the node
+        // set up to receive cast votes...just do on initialization.
         if self.state == State::Uninitialized {
             let request_fn = || self.initialize().map_err(backoff::Error::transient);
             retry_with_exponential_backoff(request_fn)
                 .expect("Failed to connect to initialize due to timeout. Stacks node may be down.");
         }
         // Process any arrived events
+        debug!("Processing event: {:?}", event);
         match event {
             Some(SignerEvent::BlockProposal(block_validate_response)) => {
+                debug!("Received a block proposal result from the stacks node...");
                 self.handle_block_validate_response(block_validate_response)
             }
-            Some(SignerEvent::StackerDB(event)) => {
-                let operation_results = self.handle_stackerdb_event(&event);
-
-                let nmb_results = operation_results.len();
-                if nmb_results > 0 {
-                    // We finished our command. Update the state
-                    self.state = State::Idle;
-                    match res.send(operation_results) {
-                        Ok(_) => debug!("Successfully sent {} operation result(s)", nmb_results),
-                        Err(e) => {
-                            warn!("Failed to send operation results: {:?}", e);
-                        }
-                    }
+            Some(SignerEvent::StackerDB(stackerdb_chunk_event)) => {
+                if stackerdb_chunk_event.contract_id == *self.stackerdb.signers_contract_id() {
+                    debug!("Received a StackerDB event for the .signers contract...");
+                    self.handle_stackerdb_chunk_event_signers(stackerdb_chunk_event, res);
+                } else if stackerdb_chunk_event.contract_id
+                    == boot_code_id(MINERS_NAME, self.mainnet)
+                {
+                    debug!("Received a StackerDB event for the .miners contract...");
+                    self.handle_stackerdb_chunk_event_miners(stackerdb_chunk_event);
+                } else {
+                    // Ignore non miner or signer messages
+                    debug!(
+                        "Received a StackerDB event for an unrecognized contract id: {:?}. Ignoring...",
+                        stackerdb_chunk_event.contract_id
+                    );
                 }
             }
-            None => debug!("No event received"),
+            None => {
+                // No event. Do nothing.
+                debug!("No event received")
+            }
         }
+
         // The process the next command
         // Must be called AFTER processing the event as the state may update to IDLE due to said event.
         self.process_next_command();
@@ -443,9 +474,9 @@ impl<C: Coordinator> SignerRunLoop<Vec<OperationResult>, RunLoopCommand> for Run
 }
 
 /// Helper function for determining the coordinator public key given the the public keys
-fn calculate_coordinator(public_keys: &PublicKeys) -> (u32, &ecdsa::PublicKey) {
+fn calculate_coordinator(public_keys: &PublicKeys) -> (u32, ecdsa::PublicKey) {
     // TODO: do some sort of VRF here to calculate the public key
     // See: https://github.com/stacks-network/stacks-blockchain/issues/3915
     // Mockamato just uses the first signer_id as the coordinator for now
-    (0, public_keys.signers.get(&0).unwrap())
+    (0, public_keys.signers.get(&0).cloned().unwrap())
 }
diff --git a/stacks-signer/src/tests/conf/signer-0.toml b/stacks-signer/src/tests/conf/signer-0.toml
index 226a30eb7b..dc9bbf61c2 100644
--- a/stacks-signer/src/tests/conf/signer-0.toml
+++ b/stacks-signer/src/tests/conf/signer-0.toml
@@ -5,7 +5,6 @@ node_host = "127.0.0.1:20443"
 endpoint = "localhost:30000"
 network = "testnet"
 signers_stackerdb_contract_id = "ST11Z60137Y96MF89K1KKRTA3CR6B25WY1Y931668.signers-stackerdb"
-miners_stackerdb_contract_id = "ST11Z60137Y96MF89K1KKRTA3CR6B25WY1Y931668.miners-stackerdb"
 signer_id = 0
 signers = [
             {public_key = "swBaKxfzs4pQne7spxhrkF6AtB34WEcreAkJ8mPcqx3t", key_ids = [1, 2, 3, 4]}
diff --git a/stacks-signer/src/tests/conf/signer-1.toml b/stacks-signer/src/tests/conf/signer-1.toml
index e3f6f68cbd..c0988c9c8d 100644
--- a/stacks-signer/src/tests/conf/signer-1.toml
+++ b/stacks-signer/src/tests/conf/signer-1.toml
@@ -5,7 +5,6 @@ node_host = "127.0.0.1:20443"
 endpoint = "localhost:30001"
 network = "testnet"
 signers_stackerdb_contract_id = "ST11Z60137Y96MF89K1KKRTA3CR6B25WY1Y931668.signers-stackerdb"
-miners_stackerdb_contract_id = "ST11Z60137Y96MF89K1KKRTA3CR6B25WY1Y931668.miners-stackerdb"
 signer_id = 1
 signers = [
             {public_key = "swBaKxfzs4pQne7spxhrkF6AtB34WEcreAkJ8mPcqx3t", key_ids = [1, 2, 3, 4]}
diff --git a/stacks-signer/src/tests/conf/signer-2.toml b/stacks-signer/src/tests/conf/signer-2.toml
index 0140dadad0..b6987b71b6 100644
--- a/stacks-signer/src/tests/conf/signer-2.toml
+++ b/stacks-signer/src/tests/conf/signer-2.toml
@@ -5,7 +5,6 @@ node_host = "127.0.0.1:20443"
 endpoint = "localhost:30002"
 network = "testnet"
 signers_stackerdb_contract_id = "ST11Z60137Y96MF89K1KKRTA3CR6B25WY1Y931668.signers-stackerdb"
-miners_stackerdb_contract_id = "ST11Z60137Y96MF89K1KKRTA3CR6B25WY1Y931668.miners-stackerdb"
 signer_id = 2
 signers = [
             {public_key = "swBaKxfzs4pQne7spxhrkF6AtB34WEcreAkJ8mPcqx3t", key_ids = [1, 2, 3, 4]}
diff --git a/stacks-signer/src/tests/conf/signer-3.toml b/stacks-signer/src/tests/conf/signer-3.toml
index 8cc8889f52..114ea38218 100644
--- a/stacks-signer/src/tests/conf/signer-3.toml
+++ b/stacks-signer/src/tests/conf/signer-3.toml
@@ -5,7 +5,6 @@ node_host = "127.0.0.1:20443"
 endpoint = "localhost:30003"
 network = "testnet"
 signers_stackerdb_contract_id = "ST11Z60137Y96MF89K1KKRTA3CR6B25WY1Y931668.signers-stackerdb"
-miners_stackerdb_contract_id = "ST11Z60137Y96MF89K1KKRTA3CR6B25WY1Y931668.miners-stackerdb"
 signer_id = 3
 signers = [
             {public_key = "swBaKxfzs4pQne7spxhrkF6AtB34WEcreAkJ8mPcqx3t", key_ids = [1, 2, 3, 4]}
diff --git a/stacks-signer/src/tests/conf/signer-4.toml b/stacks-signer/src/tests/conf/signer-4.toml
index 999e066a09..37a68f1035 100644
--- a/stacks-signer/src/tests/conf/signer-4.toml
+++ b/stacks-signer/src/tests/conf/signer-4.toml
@@ -5,7 +5,6 @@ node_host = "127.0.0.1:20443"
 endpoint = "localhost:30004"
 network = "testnet"
 signers_stackerdb_contract_id = "ST11Z60137Y96MF89K1KKRTA3CR6B25WY1Y931668.signers-stackerdb"
-miners_stackerdb_contract_id = "ST11Z60137Y96MF89K1KKRTA3CR6B25WY1Y931668.miners-stackerdb"
 signer_id = 4
 signers = [
             {public_key = "swBaKxfzs4pQne7spxhrkF6AtB34WEcreAkJ8mPcqx3t", key_ids = [1, 2, 3, 4]}
diff --git a/stacks-signer/src/utils.rs b/stacks-signer/src/utils.rs
index 6011a3a170..b99087bfe0 100644
--- a/stacks-signer/src/utils.rs
+++ b/stacks-signer/src/utils.rs
@@ -13,8 +13,6 @@ pub fn build_signer_config_tomls(
     num_keys: u32,
     node_host: &str,
     signers_stackerdb_contract_id: &str,
-    miners_stackerdb_contract_id: &str,
-    pox_contract_id: Option<&str>,
     timeout: Option<Duration>,
 ) -> Vec<String> {
     let num_signers = signer_stacks_private_keys.len() as u32;
@@ -74,7 +72,6 @@ node_host = "{node_host}"
 endpoint = "{endpoint}"
 network = "testnet"
 signers_stackerdb_contract_id = "{signers_stackerdb_contract_id}"
-miners_stackerdb_contract_id = "{miners_stackerdb_contract_id}"
 signer_id = {id}
 {signers_array}
 "#
@@ -89,14 +86,6 @@ event_timeout = {event_timeout_ms}
 "#
             )
         }
-        if let Some(pox_contract_id) = pox_contract_id {
-            signer_config_toml = format!(
-                r#"
-{signer_config_toml}
-pox_contract_id = "{pox_contract_id}"
-"#
-            );
-        }
 
         signer_config_tomls.push(signer_config_toml);
     }
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 05ae6da4a5..0bbd826ca2 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -238,7 +238,7 @@ where
 
 /// Mine a bitcoin block, and wait until:
 ///  (1) a new block has been processed by the coordinator
-fn next_block_and_process_new_stacks_block(
+pub fn next_block_and_process_new_stacks_block(
     btc_controller: &mut BitcoinRegtestController,
     timeout_secs: u64,
     coord_channels: &Arc<Mutex<CoordinatorChannels>>,
@@ -263,7 +263,7 @@ fn next_block_and_process_new_stacks_block(
 ///  (1) a new block has been processed by the coordinator
 ///  (2) 2 block commits have been issued ** or ** more than 10 seconds have
 ///      passed since (1) occurred
-fn next_block_and_mine_commit(
+pub fn next_block_and_mine_commit(
     btc_controller: &mut BitcoinRegtestController,
     timeout_secs: u64,
     coord_channels: &Arc<Mutex<CoordinatorChannels>>,
@@ -320,7 +320,7 @@ fn next_block_and_mine_commit(
     })
 }
 
-fn setup_stacker(naka_conf: &mut Config) -> Secp256k1PrivateKey {
+pub fn setup_stacker(naka_conf: &mut Config) -> Secp256k1PrivateKey {
     let stacker_sk = Secp256k1PrivateKey::new();
     let stacker_address = tests::to_addr(&stacker_sk);
     naka_conf.add_initial_balance(
@@ -333,7 +333,7 @@ fn setup_stacker(naka_conf: &mut Config) -> Secp256k1PrivateKey {
 ///
 /// * `stacker_sk` - must be a private key for sending a large `stack-stx` transaction in order
 ///   for pox-4 to activate
-fn boot_to_epoch_3(
+pub fn boot_to_epoch_3(
     naka_conf: &Config,
     blocks_processed: &RunLoopCounter,
     stacker_sk: Secp256k1PrivateKey,
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index 4a4e6e55c9..b561fe1460 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -1,13 +1,18 @@
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::mpsc::{channel, Receiver, Sender};
+use std::sync::{Arc, Mutex};
 use std::time::Duration;
 use std::{env, thread};
 
 use clarity::vm::types::QualifiedContractIdentifier;
 use libsigner::{RunningSigner, Signer, SignerEventReceiver};
+use stacks::chainstate::coordinator::comm::CoordinatorChannels;
+use stacks::chainstate::stacks::boot::MINERS_NAME;
 use stacks::chainstate::stacks::StacksPrivateKey;
-use stacks_common::types::chainstate::StacksAddress;
-use stacks_signer::client::{MINER_SLOTS_PER_USER, SIGNER_SLOTS_PER_USER};
-use stacks_signer::config::Config as SignerConfig;
+use stacks::util_lib::boot::boot_code_id;
+use stacks_common::types::chainstate::{StacksAddress, StacksPublicKey};
+use stacks_signer::client::SIGNER_SLOTS_PER_USER;
+use stacks_signer::config::{Config as SignerConfig, Network};
 use stacks_signer::runloop::RunLoopCommand;
 use stacks_signer::utils::{build_signer_config_tomls, build_stackerdb_contract};
 use tracing_subscriber::prelude::*;
@@ -17,19 +22,26 @@ use wsts::state_machine::OperationResult;
 use wsts::v2;
 
 use crate::config::{Config as NeonConfig, EventKeyType, EventObserverConfig, InitialBalance};
+use crate::neon::Counters;
+use crate::run_loop::boot_nakamoto;
 use crate::tests::bitcoin_regtest::BitcoinCoreController;
+use crate::tests::nakamoto_integrations::{
+    boot_to_epoch_3, naka_neon_integration_conf, setup_stacker,
+};
 use crate::tests::neon_integrations::{
-    neon_integration_test_conf, next_block_and_wait, submit_tx, wait_for_runloop,
+    next_block_and_wait, submit_tx, test_observer, wait_for_runloop,
 };
 use crate::tests::{make_contract_publish, to_addr};
-use crate::{neon, BitcoinRegtestController, BurnchainController};
+use crate::{BitcoinRegtestController, BurnchainController};
 
 // Helper struct for holding the btc and stx neon nodes
 #[allow(dead_code)]
 struct RunningNodes {
     pub btc_regtest_controller: BitcoinRegtestController,
     pub btcd_controller: BitcoinCoreController,
-    pub join_handle: thread::JoinHandle<()>,
+    pub run_loop_thread: thread::JoinHandle<()>,
+    pub run_loop_stopper: Arc<AtomicBool>,
+    pub coord_channel: Arc<Mutex<CoordinatorChannels>>,
     pub conf: NeonConfig,
 }
 
@@ -40,7 +52,7 @@ fn spawn_signer(
 ) -> RunningSigner<SignerEventReceiver, Vec<OperationResult>> {
     let config = stacks_signer::config::Config::load_from_str(data).unwrap();
     let ev = SignerEventReceiver::new(vec![
-        config.miners_stackerdb_contract_id.clone(),
+        boot_code_id(MINERS_NAME, config.network == Network::Mainnet),
         config.signers_stackerdb_contract_id.clone(),
     ]);
     let runloop: stacks_signer::runloop::RunLoop<FireCoordinator<v2::Aggregator>> =
@@ -61,27 +73,33 @@ fn spawn_signer(
 
 #[allow(clippy::too_many_arguments)]
 fn setup_stx_btc_node(
-    conf: &mut NeonConfig,
+    mut naka_conf: NeonConfig,
     num_signers: u32,
     signer_stacks_private_keys: &[StacksPrivateKey],
     publisher_private_key: &StacksPrivateKey,
     signers_stackerdb_contract: &str,
     signers_stackerdb_contract_id: &QualifiedContractIdentifier,
-    miners_stackerdb_contract: &str,
-    miners_stackerdb_contract_id: &QualifiedContractIdentifier,
-    pox_contract: &str,
-    pox_contract_id: &QualifiedContractIdentifier,
     signer_config_tomls: &Vec<String>,
 ) -> RunningNodes {
+    // Spawn the endpoints for observing signers
     for toml in signer_config_tomls {
         let signer_config = SignerConfig::load_from_str(toml).unwrap();
 
-        conf.events_observers.insert(EventObserverConfig {
+        naka_conf.events_observers.insert(EventObserverConfig {
             endpoint: format!("{}", signer_config.endpoint),
             events_keys: vec![EventKeyType::StackerDBChunks, EventKeyType::BlockProposal],
         });
     }
 
+    // Spawn a test observer for verification purposes
+    test_observer::spawn();
+    let observer_port = test_observer::EVENT_OBSERVER_PORT;
+    naka_conf.events_observers.insert(EventObserverConfig {
+        endpoint: format!("localhost:{observer_port}"),
+        events_keys: vec![EventKeyType::StackerDBChunks, EventKeyType::BlockProposal],
+    });
+
+    // The signers need some initial balances in order to pay for epoch 2.5 transaction votes
     let mut initial_balances = Vec::new();
 
     initial_balances.push(InitialBalance {
@@ -95,34 +113,38 @@ fn setup_stx_btc_node(
             amount: 10_000_000_000_000,
         });
     }
-
-    conf.initial_balances.append(&mut initial_balances);
-    conf.node
+    naka_conf.initial_balances.append(&mut initial_balances);
+    naka_conf
+        .node
         .stacker_dbs
         .push(signers_stackerdb_contract_id.clone());
-    conf.node
-        .stacker_dbs
-        .push(miners_stackerdb_contract_id.clone());
+    naka_conf.miner.wait_on_interim_blocks = Duration::from_secs(1000);
+
+    let stacker_sk = setup_stacker(&mut naka_conf);
 
     info!("Make new BitcoinCoreController");
-    let mut btcd_controller = BitcoinCoreController::new(conf.clone());
+    let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone());
     btcd_controller
         .start_bitcoind()
         .map_err(|_e| ())
         .expect("Failed starting bitcoind");
 
     info!("Make new BitcoinRegtestController");
-    let mut btc_regtest_controller = BitcoinRegtestController::new(conf.clone(), None);
+    let mut btc_regtest_controller = BitcoinRegtestController::new(naka_conf.clone(), None);
 
     info!("Bootstraping...");
     btc_regtest_controller.bootstrap_chain(201);
 
     info!("Chain bootstrapped...");
 
-    let mut run_loop = neon::RunLoop::new(conf.clone());
-    let blocks_processed = run_loop.get_blocks_processed_arc();
+    let mut run_loop = boot_nakamoto::BootRunLoop::new(naka_conf.clone()).unwrap();
+    let run_loop_stopper = run_loop.get_termination_switch();
+    let Counters {
+        blocks_processed, ..
+    } = run_loop.counters();
 
-    let join_handle = thread::spawn(move || run_loop.start(None, 0));
+    let coord_channel = run_loop.coordinator_channels();
+    let run_loop_thread = thread::spawn(move || run_loop.start(None, 0));
 
     // Give the run loop some time to start up!
     info!("Wait for runloop...");
@@ -140,75 +162,43 @@ fn setup_stx_btc_node(
     info!("Mine third block...");
     next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
 
-    let http_origin = format!("http://{}", &conf.node.rpc_bind);
-
-    info!("Send pox contract-publish...");
+    info!("Send signers stacker-db contract-publish...");
+    let http_origin = format!("http://{}", &naka_conf.node.rpc_bind);
 
     let tx_fee = 100_000;
     let tx = make_contract_publish(
         publisher_private_key,
         0,
         tx_fee,
-        &pox_contract_id.name,
-        pox_contract,
-    );
-    submit_tx(&http_origin, &tx);
-
-    info!("Send signers stacker-db contract-publish...");
-    let tx = make_contract_publish(
-        publisher_private_key,
-        1,
-        tx_fee,
         &signers_stackerdb_contract_id.name,
         signers_stackerdb_contract,
     );
     submit_tx(&http_origin, &tx);
-
-    info!("Send miners stacker-db contract-publish...");
-    let tx = make_contract_publish(
-        publisher_private_key,
-        2,
-        tx_fee,
-        &miners_stackerdb_contract_id.name,
-        miners_stackerdb_contract,
-    );
-    submit_tx(&http_origin, &tx);
-
     // mine it
-    info!("Mining the pox and stackerdb contract...");
+    info!("Mining the stackerdb contract: {signers_stackerdb_contract_id}");
     next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
     next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
 
+    info!("Boot to epoch 3.0 to activate pox-4...");
+    boot_to_epoch_3(
+        &naka_conf,
+        &blocks_processed,
+        stacker_sk,
+        StacksPublicKey::new(),
+        &mut btc_regtest_controller,
+    );
+
+    info!("Pox 4 activated and ready for signers to perform DKG and sign!");
     RunningNodes {
         btcd_controller,
         btc_regtest_controller,
-        join_handle,
-        conf: conf.clone(),
+        run_loop_thread,
+        run_loop_stopper,
+        coord_channel,
+        conf: naka_conf,
     }
 }
 
-/// Helper function for building our fake pox contract
-pub fn build_pox_contract(num_signers: u32) -> String {
-    let mut pox_contract = String::new(); // "
-    pox_contract += r#"
-;; data vars
-;;
-(define-data-var aggregate-public-key (optional (buff 33)) none)
-"#;
-    pox_contract += &format!("(define-data-var num-signers uint u{num_signers})\n");
-    pox_contract += r#"
-
-;; read only functions
-;;
-
-(define-read-only (get-aggregate-public-key (reward-cycle uint))
-    (var-get aggregate-public-key)
-)
-
-"#;
-    pox_contract
-}
-
 #[test]
 #[ignore]
 fn test_stackerdb_dkg() {
@@ -221,6 +211,7 @@ fn test_stackerdb_dkg() {
         .with(EnvFilter::from_default_env())
         .init();
 
+    info!("------------------------- Test Setup -------------------------");
     // Generate Signer Data
     let num_signers: u32 = 10;
     let num_keys: u32 = 400;
@@ -232,35 +223,22 @@ fn test_stackerdb_dkg() {
         .iter()
         .map(to_addr)
         .collect::<Vec<StacksAddress>>();
-    let miner_private_key = StacksPrivateKey::new();
-    let miner_stacks_address = to_addr(&miner_private_key);
-
-    // Setup the neon node
-    let (mut conf, _) = neon_integration_test_conf();
 
-    // Build our simulated pox-4 stacks contract TODO: replace this with the real deal?
-    let pox_contract = build_pox_contract(num_signers);
-    let pox_contract_id =
-        QualifiedContractIdentifier::new(to_addr(&publisher_private_key).into(), "pox-4".into());
-    // Build the stackerdb contracts
+    // Build the stackerdb signers contract
+    // TODO: Remove this once it is a boot contract
     let signers_stackerdb_contract =
         build_stackerdb_contract(&signer_stacks_addresses, SIGNER_SLOTS_PER_USER);
     let signers_stacker_db_contract_id =
         QualifiedContractIdentifier::new(to_addr(&publisher_private_key).into(), "signers".into());
 
-    let miners_stackerdb_contract =
-        build_stackerdb_contract(&[miner_stacks_address], MINER_SLOTS_PER_USER);
-    let miners_stacker_db_contract_id =
-        QualifiedContractIdentifier::new(to_addr(&publisher_private_key).into(), "miners".into());
+    let (naka_conf, _miner_account) = naka_neon_integration_conf(None);
 
     // Setup the signer and coordinator configurations
     let signer_configs = build_signer_config_tomls(
         &signer_stacks_private_keys,
         num_keys,
-        &conf.node.rpc_bind,
+        &naka_conf.node.rpc_bind,
         &signers_stacker_db_contract_id.to_string(),
-        &miners_stacker_db_contract_id.to_string(),
-        Some(&pox_contract_id.to_string()),
         Some(Duration::from_millis(128)), // Timeout defaults to 5 seconds. Let's override it to 128 milliseconds.
     );
 
@@ -290,78 +268,82 @@ fn test_stackerdb_dkg() {
 
     res_receivers.push(coordinator_res_recv);
 
-    // Let's wrap the node in a lifetime to ensure stopping the signers doesn't cause issues.
-    {
-        // Setup the nodes and deploy the contract to it
-        let _node = setup_stx_btc_node(
-            &mut conf,
-            num_signers,
-            &signer_stacks_private_keys,
-            &publisher_private_key,
-            &signers_stackerdb_contract,
-            &signers_stacker_db_contract_id,
-            &miners_stackerdb_contract,
-            &miners_stacker_db_contract_id,
-            &pox_contract,
-            &pox_contract_id,
-            &signer_configs,
-        );
-
-        let now = std::time::Instant::now();
-        info!("signer_runloop: spawn send commands to do dkg and then sign");
-        coordinator_cmd_send
-            .send(RunLoopCommand::Sign {
-                message: vec![1, 2, 3, 4, 5],
-                is_taproot: false,
-                merkle_root: None,
-            })
-            .expect("failed to send Sign command");
-        coordinator_cmd_send
-            .send(RunLoopCommand::Sign {
-                message: vec![1, 2, 3, 4, 5],
-                is_taproot: true,
-                merkle_root: None,
-            })
-            .expect("failed to send Sign command");
-        for recv in res_receivers.iter() {
-            let mut aggregate_group_key = None;
-            let mut frost_signature = None;
-            let mut schnorr_proof = None;
-            loop {
-                let results = recv.recv().expect("failed to recv results");
-                for result in results {
-                    match result {
-                        OperationResult::Dkg(point) => {
-                            info!("Received aggregate_group_key {point}");
-                            aggregate_group_key = Some(point);
-                        }
-                        OperationResult::Sign(sig) => {
-                            info!("Received Signature ({},{})", &sig.R, &sig.z);
-                            frost_signature = Some(sig);
-                        }
-                        OperationResult::SignTaproot(proof) => {
-                            info!("Received SchnorrProof ({},{})", &proof.r, &proof.s);
-                            schnorr_proof = Some(proof);
-                        }
-                        OperationResult::DkgError(dkg_error) => {
-                            panic!("Received DkgError {:?}", dkg_error);
-                        }
-                        OperationResult::SignError(sign_error) => {
-                            panic!("Received SignError {}", sign_error);
-                        }
+    // Setup the nodes and deploy the contract to it
+    let node = setup_stx_btc_node(
+        naka_conf,
+        num_signers,
+        &signer_stacks_private_keys,
+        &publisher_private_key,
+        &signers_stackerdb_contract,
+        &signers_stacker_db_contract_id,
+        &signer_configs,
+    );
+
+    info!("------------------------- Test DKG and Sign -------------------------");
+    let now = std::time::Instant::now();
+    info!("signer_runloop: spawn send commands to do dkg and then sign");
+    coordinator_cmd_send
+        .send(RunLoopCommand::Dkg)
+        .expect("failed to send Dkg command");
+    coordinator_cmd_send
+        .send(RunLoopCommand::Sign {
+            message: vec![1, 2, 3, 4, 5],
+            is_taproot: false,
+            merkle_root: None,
+        })
+        .expect("failed to send non taproot Sign command");
+    coordinator_cmd_send
+        .send(RunLoopCommand::Sign {
+            message: vec![1, 2, 3, 4, 5],
+            is_taproot: true,
+            merkle_root: None,
+        })
+        .expect("failed to send taproot Sign command");
+    for recv in res_receivers.iter() {
+        let mut aggregate_group_key = None;
+        let mut frost_signature = None;
+        let mut schnorr_proof = None;
+        loop {
+            let results = recv.recv().expect("failed to recv results");
+            for result in results {
+                match result {
+                    OperationResult::Dkg(point) => {
+                        info!("Received aggregate_group_key {point}");
+                        aggregate_group_key = Some(point);
+                    }
+                    OperationResult::Sign(sig) => {
+                        info!("Received Signature ({},{})", &sig.R, &sig.z);
+                        frost_signature = Some(sig);
+                    }
+                    OperationResult::SignTaproot(proof) => {
+                        info!("Received SchnorrProof ({},{})", &proof.r, &proof.s);
+                        schnorr_proof = Some(proof);
+                    }
+                    OperationResult::DkgError(dkg_error) => {
+                        panic!("Received DkgError {:?}", dkg_error);
+                    }
+                    OperationResult::SignError(sign_error) => {
+                        panic!("Received SignError {}", sign_error);
                     }
-                }
-                if aggregate_group_key.is_some()
-                    && frost_signature.is_some()
-                    && schnorr_proof.is_some()
-                {
-                    break;
                 }
             }
+            if aggregate_group_key.is_some() && frost_signature.is_some() && schnorr_proof.is_some()
+            {
+                break;
+            }
         }
-        let elapsed = now.elapsed();
-        info!("DKG and Sign Time Elapsed: {:.2?}", elapsed);
     }
+    let elapsed = now.elapsed();
+    info!("DKG and Sign Time Elapsed: {:.2?}", elapsed);
+
+    node.coord_channel
+        .lock()
+        .expect("Mutex poisoned")
+        .stop_chains_coordinator();
+
+    node.run_loop_stopper.store(false, Ordering::SeqCst);
+
+    node.run_loop_thread.join().unwrap();
     // Stop the signers
     for signer in running_signers {
         assert!(signer.stop().is_none());

From 81dcf1bc68e25d317d5b3310c15326ccec180f20 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Thu, 11 Jan 2024 14:40:55 -0500
Subject: [PATCH 0372/1166] Cleanup signer test to easily add another

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 testnet/stacks-node/src/tests/signer.rs | 211 ++++++++++++++----------
 1 file changed, 123 insertions(+), 88 deletions(-)

diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index b561fe1460..52f316dc17 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -45,6 +45,120 @@ struct RunningNodes {
     pub conf: NeonConfig,
 }
 
+struct SignerTest {
+    // The stx and bitcoin nodes and their run loops
+    pub running_nodes: RunningNodes,
+    // The channel for sending commands to the coordinator
+    pub coordinator_cmd_sender: Sender<RunLoopCommand>,
+    // The channels for sending commands to the signers
+    pub _signer_cmd_senders: Vec<Sender<RunLoopCommand>>,
+    // The channels for receiving results from both the coordinator and the signers
+    pub result_receivers: Vec<Receiver<Vec<OperationResult>>>,
+    // The running coordinator and its threads
+    pub running_coordinator: RunningSigner<SignerEventReceiver, Vec<OperationResult>>,
+    // The running signer and its threads
+    pub running_signers: Vec<RunningSigner<SignerEventReceiver, Vec<OperationResult>>>,
+}
+
+impl SignerTest {
+    fn new(num_signers: u32, num_keys: u32) -> Self {
+        // Generate Signer Data
+        let publisher_private_key = StacksPrivateKey::new();
+        let signer_stacks_private_keys = (0..num_signers)
+            .map(|_| StacksPrivateKey::new())
+            .collect::<Vec<StacksPrivateKey>>();
+        let signer_stacks_addresses = signer_stacks_private_keys
+            .iter()
+            .map(to_addr)
+            .collect::<Vec<StacksAddress>>();
+
+        // Build the stackerdb signers contract
+        // TODO: Remove this once it is a boot contract
+        let signers_stackerdb_contract =
+            build_stackerdb_contract(&signer_stacks_addresses, SIGNER_SLOTS_PER_USER);
+        let signers_stacker_db_contract_id = QualifiedContractIdentifier::new(
+            to_addr(&publisher_private_key).into(),
+            "signers".into(),
+        );
+
+        let (naka_conf, _miner_account) = naka_neon_integration_conf(None);
+
+        // Setup the signer and coordinator configurations
+        let signer_configs = build_signer_config_tomls(
+            &signer_stacks_private_keys,
+            num_keys,
+            &naka_conf.node.rpc_bind,
+            &signers_stacker_db_contract_id.to_string(),
+            Some(Duration::from_millis(128)), // Timeout defaults to 5 seconds. Let's override it to 128 milliseconds.
+        );
+
+        let mut running_signers = vec![];
+        let mut _signer_cmd_senders = vec![];
+        // Spawn all the signers first to listen to the coordinator request for dkg
+        let mut result_receivers = Vec::new();
+        for i in (1..num_signers).rev() {
+            let (cmd_send, cmd_recv) = channel();
+            let (res_send, res_recv) = channel();
+            info!("spawn signer");
+            let running_signer = spawn_signer(&signer_configs[i as usize], cmd_recv, res_send);
+            running_signers.push(running_signer);
+            _signer_cmd_senders.push(cmd_send);
+            result_receivers.push(res_recv);
+        }
+        // Spawn coordinator second
+        let (coordinator_cmd_sender, coordinator_cmd_recv) = channel();
+        let (coordinator_res_send, coordinator_res_receiver) = channel();
+        info!("spawn coordinator");
+        let running_coordinator = spawn_signer(
+            &signer_configs[0],
+            coordinator_cmd_recv,
+            coordinator_res_send,
+        );
+
+        result_receivers.push(coordinator_res_receiver);
+
+        // Setup the nodes and deploy the contract to it
+        let node = setup_stx_btc_node(
+            naka_conf,
+            num_signers,
+            &signer_stacks_private_keys,
+            &publisher_private_key,
+            &signers_stackerdb_contract,
+            &signers_stacker_db_contract_id,
+            &signer_configs,
+        );
+
+        Self {
+            running_nodes: node,
+            result_receivers,
+            _signer_cmd_senders,
+            coordinator_cmd_sender,
+            running_coordinator,
+            running_signers,
+        }
+    }
+
+    fn shutdown(self) {
+        self.running_nodes
+            .coord_channel
+            .lock()
+            .expect("Mutex poisoned")
+            .stop_chains_coordinator();
+
+        self.running_nodes
+            .run_loop_stopper
+            .store(false, Ordering::SeqCst);
+
+        self.running_nodes.run_loop_thread.join().unwrap();
+        // Stop the signers
+        for signer in self.running_signers {
+            assert!(signer.stop().is_none());
+        }
+        // Stop the coordinator
+        assert!(self.running_coordinator.stop().is_none());
+    }
+}
+
 fn spawn_signer(
     data: &str,
     receiver: Receiver<RunLoopCommand>,
@@ -71,7 +185,6 @@ fn spawn_signer(
     signer.spawn(endpoint).unwrap()
 }
 
-#[allow(clippy::too_many_arguments)]
 fn setup_stx_btc_node(
     mut naka_conf: NeonConfig,
     num_signers: u32,
@@ -198,7 +311,6 @@ fn setup_stx_btc_node(
         conf: naka_conf,
     }
 }
-
 #[test]
 #[ignore]
 fn test_stackerdb_dkg() {
@@ -212,94 +324,31 @@ fn test_stackerdb_dkg() {
         .init();
 
     info!("------------------------- Test Setup -------------------------");
-    // Generate Signer Data
-    let num_signers: u32 = 10;
-    let num_keys: u32 = 400;
-    let publisher_private_key = StacksPrivateKey::new();
-    let signer_stacks_private_keys = (0..num_signers)
-        .map(|_| StacksPrivateKey::new())
-        .collect::<Vec<StacksPrivateKey>>();
-    let signer_stacks_addresses = signer_stacks_private_keys
-        .iter()
-        .map(to_addr)
-        .collect::<Vec<StacksAddress>>();
-
-    // Build the stackerdb signers contract
-    // TODO: Remove this once it is a boot contract
-    let signers_stackerdb_contract =
-        build_stackerdb_contract(&signer_stacks_addresses, SIGNER_SLOTS_PER_USER);
-    let signers_stacker_db_contract_id =
-        QualifiedContractIdentifier::new(to_addr(&publisher_private_key).into(), "signers".into());
-
-    let (naka_conf, _miner_account) = naka_neon_integration_conf(None);
-
-    // Setup the signer and coordinator configurations
-    let signer_configs = build_signer_config_tomls(
-        &signer_stacks_private_keys,
-        num_keys,
-        &naka_conf.node.rpc_bind,
-        &signers_stacker_db_contract_id.to_string(),
-        Some(Duration::from_millis(128)), // Timeout defaults to 5 seconds. Let's override it to 128 milliseconds.
-    );
-
-    // The test starts here
-    let mut running_signers = vec![];
-    // Spawn all the signers first to listen to the coordinator request for dkg
-    let mut signer_cmd_senders = Vec::new();
-    let mut res_receivers = Vec::new();
-    for i in (1..num_signers).rev() {
-        let (cmd_send, cmd_recv) = channel();
-        let (res_send, res_recv) = channel();
-        info!("spawn signer");
-        let running_signer = spawn_signer(&signer_configs[i as usize], cmd_recv, res_send);
-        running_signers.push(running_signer);
-        signer_cmd_senders.push(cmd_send);
-        res_receivers.push(res_recv);
-    }
-    // Spawn coordinator second
-    let (coordinator_cmd_send, coordinator_cmd_recv) = channel();
-    let (coordinator_res_send, coordinator_res_recv) = channel();
-    info!("spawn coordinator");
-    let running_coordinator = spawn_signer(
-        &signer_configs[0],
-        coordinator_cmd_recv,
-        coordinator_res_send,
-    );
-
-    res_receivers.push(coordinator_res_recv);
-
-    // Setup the nodes and deploy the contract to it
-    let node = setup_stx_btc_node(
-        naka_conf,
-        num_signers,
-        &signer_stacks_private_keys,
-        &publisher_private_key,
-        &signers_stackerdb_contract,
-        &signers_stacker_db_contract_id,
-        &signer_configs,
-    );
-
+    let signer_test = SignerTest::new(10, 400);
     info!("------------------------- Test DKG and Sign -------------------------");
     let now = std::time::Instant::now();
     info!("signer_runloop: spawn send commands to do dkg and then sign");
-    coordinator_cmd_send
+    signer_test
+        .coordinator_cmd_sender
         .send(RunLoopCommand::Dkg)
         .expect("failed to send Dkg command");
-    coordinator_cmd_send
+    signer_test
+        .coordinator_cmd_sender
         .send(RunLoopCommand::Sign {
             message: vec![1, 2, 3, 4, 5],
             is_taproot: false,
             merkle_root: None,
         })
         .expect("failed to send non taproot Sign command");
-    coordinator_cmd_send
+    signer_test
+        .coordinator_cmd_sender
         .send(RunLoopCommand::Sign {
             message: vec![1, 2, 3, 4, 5],
             is_taproot: true,
             merkle_root: None,
         })
         .expect("failed to send taproot Sign command");
-    for recv in res_receivers.iter() {
+    for recv in signer_test.result_receivers.iter() {
         let mut aggregate_group_key = None;
         let mut frost_signature = None;
         let mut schnorr_proof = None;
@@ -335,19 +384,5 @@ fn test_stackerdb_dkg() {
     }
     let elapsed = now.elapsed();
     info!("DKG and Sign Time Elapsed: {:.2?}", elapsed);
-
-    node.coord_channel
-        .lock()
-        .expect("Mutex poisoned")
-        .stop_chains_coordinator();
-
-    node.run_loop_stopper.store(false, Ordering::SeqCst);
-
-    node.run_loop_thread.join().unwrap();
-    // Stop the signers
-    for signer in running_signers {
-        assert!(signer.stop().is_none());
-    }
-    // Stop the coordinator
-    assert!(running_coordinator.stop().is_none());
+    signer_test.shutdown();
 }

From 059d53d4504eec9a2031e56752d1f25f230fa566 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Thu, 11 Jan 2024 15:42:25 -0500
Subject: [PATCH 0373/1166] Add test to handle block written to miners stacker
 db and fix signature to be across signature hash

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 .github/workflows/bitcoin-tests.yml     |   1 +
 stacks-signer/src/runloop.rs            |   5 +-
 testnet/stacks-node/src/tests/signer.rs | 137 +++++++++++++++++++++++-
 3 files changed, 137 insertions(+), 6 deletions(-)

diff --git a/.github/workflows/bitcoin-tests.yml b/.github/workflows/bitcoin-tests.yml
index aa02b5e6ff..417d68e2b1 100644
--- a/.github/workflows/bitcoin-tests.yml
+++ b/.github/workflows/bitcoin-tests.yml
@@ -74,6 +74,7 @@ jobs:
           - tests::nakamoto_integrations::mine_multiple_per_tenure_integration
           - tests::nakamoto_integrations::block_proposal_api_endpoint
           - tests::nakamoto_integrations::miner_writes_proposed_block_to_stackerdb
+          - tests::signer::stackerdb_block_proposal
     steps:
       ## Setup test environment
       - name: Setup Test Environment
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 068cdfaee8..197d2e1d3d 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -10,7 +10,7 @@ use blockstack_lib::util_lib::boot::boot_code_id;
 use hashbrown::{HashMap, HashSet};
 use libsigner::{SignerEvent, SignerRunLoop};
 use slog::{slog_debug, slog_error, slog_info, slog_warn};
-use stacks_common::codec::{read_next, StacksMessageCodec};
+use stacks_common::codec::read_next;
 use stacks_common::{debug, error, info, warn};
 use wsts::common::MerkleRoot;
 use wsts::curve::ecdsa;
@@ -186,8 +186,9 @@ impl<C: Coordinator> RunLoop<C> {
                 let (coordinator_id, _) = calculate_coordinator(&self.signing_round.public_keys);
                 if coordinator_id == self.signing_round.signer_id {
                     // We are the coordinator. Trigger a signing round for this block
+                    let signature_hash = block_validate_ok.block.header.signature_hash().expect("BUG: Stacks node should never return a validated block with an invalid signature hash");
                     self.commands.push_back(RunLoopCommand::Sign {
-                        message: block_validate_ok.block.serialize_to_vec(),
+                        message: signature_hash.0.to_vec(),
                         is_taproot: false,
                         merkle_root: None,
                     });
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index 52f316dc17..59c181fee2 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -1,4 +1,4 @@
-use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
 use std::sync::mpsc::{channel, Receiver, Sender};
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
@@ -9,6 +9,7 @@ use libsigner::{RunningSigner, Signer, SignerEventReceiver};
 use stacks::chainstate::coordinator::comm::CoordinatorChannels;
 use stacks::chainstate::stacks::boot::MINERS_NAME;
 use stacks::chainstate::stacks::StacksPrivateKey;
+use stacks::net::api::postblock_proposal::BlockValidateResponse;
 use stacks::util_lib::boot::boot_code_id;
 use stacks_common::types::chainstate::{StacksAddress, StacksPublicKey};
 use stacks_signer::client::SIGNER_SLOTS_PER_USER;
@@ -26,7 +27,8 @@ use crate::neon::Counters;
 use crate::run_loop::boot_nakamoto;
 use crate::tests::bitcoin_regtest::BitcoinCoreController;
 use crate::tests::nakamoto_integrations::{
-    boot_to_epoch_3, naka_neon_integration_conf, setup_stacker,
+    boot_to_epoch_3, naka_neon_integration_conf, next_block_and, next_block_and_mine_commit,
+    setup_stacker,
 };
 use crate::tests::neon_integrations::{
     next_block_and_wait, submit_tx, test_observer, wait_for_runloop,
@@ -41,6 +43,9 @@ struct RunningNodes {
     pub btcd_controller: BitcoinCoreController,
     pub run_loop_thread: thread::JoinHandle<()>,
     pub run_loop_stopper: Arc<AtomicBool>,
+    pub vrfs_submitted: Arc<AtomicU64>,
+    pub commits_submitted: Arc<AtomicU64>,
+    pub blocks_processed: Arc<AtomicU64>,
     pub coord_channel: Arc<Mutex<CoordinatorChannels>>,
     pub conf: NeonConfig,
 }
@@ -253,7 +258,10 @@ fn setup_stx_btc_node(
     let mut run_loop = boot_nakamoto::BootRunLoop::new(naka_conf.clone()).unwrap();
     let run_loop_stopper = run_loop.get_termination_switch();
     let Counters {
-        blocks_processed, ..
+        blocks_processed,
+        naka_submitted_vrfs: vrfs_submitted,
+        naka_submitted_commits: commits_submitted,
+        ..
     } = run_loop.counters();
 
     let coord_channel = run_loop.coordinator_channels();
@@ -307,13 +315,17 @@ fn setup_stx_btc_node(
         btc_regtest_controller,
         run_loop_thread,
         run_loop_stopper,
+        vrfs_submitted,
+        commits_submitted,
+        blocks_processed,
         coord_channel,
         conf: naka_conf,
     }
 }
+
 #[test]
 #[ignore]
-fn test_stackerdb_dkg() {
+fn stackerdb_dkg_sign() {
     if env::var("BITCOIND_TEST") != Ok("1".into()) {
         return;
     }
@@ -386,3 +398,120 @@ fn test_stackerdb_dkg() {
     info!("DKG and Sign Time Elapsed: {:.2?}", elapsed);
     signer_test.shutdown();
 }
+
+#[test]
+#[ignore]
+fn stackerdb_block_proposal() {
+    if env::var("BITCOIND_TEST") != Ok("1".into()) {
+        return;
+    }
+
+    tracing_subscriber::registry()
+        .with(fmt::layer())
+        .with(EnvFilter::from_default_env())
+        .init();
+
+    info!("------------------------- Test Setup -------------------------");
+    let mut signer_test = SignerTest::new(5, 5);
+
+    // First run DKG in order to sign the block that arrives from the miners following a nakamoto block production
+    // TODO: remove this forcibly running DKG once we have casting of the vote automagically happening during epoch 2.5
+    info!("signer_runloop: spawn send commands to do dkg");
+    signer_test
+        .coordinator_cmd_sender
+        .send(RunLoopCommand::Dkg)
+        .expect("failed to send Dkg command");
+    let mut aggregate_public_key = None;
+    let recv = signer_test
+        .result_receivers
+        .last()
+        .expect("Failed to get coordinator recv");
+    let results = recv.recv().expect("failed to recv results");
+    for result in results {
+        match result {
+            OperationResult::Dkg(point) => {
+                info!("Received aggregate_group_key {point}");
+                aggregate_public_key = Some(point);
+                break;
+            }
+            _ => {
+                panic!("Received Unexpected result");
+            }
+        }
+    }
+    let aggregate_public_key = aggregate_public_key.expect("Failed to get aggregate public key");
+
+    let (vrfs_submitted, commits_submitted) = (
+        signer_test.running_nodes.vrfs_submitted.clone(),
+        signer_test.running_nodes.commits_submitted.clone(),
+    );
+
+    info!("Mining a Nakamoto tenure...");
+
+    // first block wakes up the run loop, wait until a key registration has been submitted.
+    next_block_and(
+        &mut signer_test.running_nodes.btc_regtest_controller,
+        60,
+        || {
+            let vrf_count = vrfs_submitted.load(Ordering::SeqCst);
+            Ok(vrf_count >= 1)
+        },
+    )
+    .unwrap();
+
+    // second block should confirm the VRF register, wait until a block commit is submitted
+    next_block_and(
+        &mut signer_test.running_nodes.btc_regtest_controller,
+        60,
+        || {
+            let commits_count = commits_submitted.load(Ordering::SeqCst);
+            Ok(commits_count >= 1)
+        },
+    )
+    .unwrap();
+
+    // Mine 1 nakamoto tenure
+    next_block_and_mine_commit(
+        &mut signer_test.running_nodes.btc_regtest_controller,
+        60,
+        &signer_test.running_nodes.coord_channel,
+        &commits_submitted,
+    )
+    .unwrap();
+
+    info!("------------------------- Test Block Processed -------------------------");
+    //Wait for the block to show up in the test observer
+    let validate_responses = test_observer::get_proposal_responses();
+    let proposed_block = match validate_responses.first().expect("No block proposal") {
+        BlockValidateResponse::Ok(block_validated) => block_validated.block.clone(),
+        _ => panic!("Unexpected response"),
+    };
+    let recv = signer_test
+        .result_receivers
+        .last()
+        .expect("Failed to retreive coordinator recv");
+    let results = recv.recv().expect("failed to recv results");
+    let mut signature = None;
+    for result in results {
+        match result {
+            OperationResult::Sign(sig) => {
+                info!("Received Signature ({},{})", &sig.R, &sig.z);
+                signature = Some(sig);
+                break;
+            }
+            _ => {
+                panic!("Unexpected operation result");
+            }
+        }
+    }
+    let signature = signature.expect("Failed to get signature");
+    let signature_hash = proposed_block
+        .header
+        .signature_hash()
+        .expect("Unable to retrieve signature hash from proposed block");
+    assert!(
+        signature.verify(&aggregate_public_key, signature_hash.0.as_slice()),
+        "Signature verification failed"
+    );
+    signer_test.shutdown();
+}

From a7e9ff9f914d2375e22588297e053a6ac275490b Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 12 Jan 2024 08:37:13 -0500
Subject: [PATCH 0374/1166] Add braindumped psuedo code function for extracting
 block responses from signature

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/stackerdb.rs     | 22 +++++-
 stacks-signer/src/client/stacks_client.rs |  6 --
 stacks-signer/src/runloop.rs              | 83 ++++++++++++++++++-----
 3 files changed, 87 insertions(+), 24 deletions(-)

diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index 7032bcdcb2..5cd103f5fc 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -1,6 +1,6 @@
 use blockstack_lib::burnchains::Txid;
 use blockstack_lib::chainstate::nakamoto::NakamotoBlock;
-use blockstack_lib::net::api::postblock_proposal::ValidateRejectCode;
+use blockstack_lib::net::api::postblock_proposal::{BlockValidateReject, ValidateRejectCode};
 use clarity::vm::types::QualifiedContractIdentifier;
 use hashbrown::HashMap;
 use libsigner::{SignerSession, StackerDBSession};
@@ -62,6 +62,16 @@ pub struct BlockRejection {
     pub block: NakamotoBlock,
 }
 
+impl From<BlockValidateReject> for BlockRejection {
+    fn from(reject: BlockValidateReject) -> Self {
+        Self {
+            reason: reject.reason,
+            reason_code: RejectCode::ValidationFailed(reject.reason_code),
+            block: reject.block,
+        }
+    }
+}
+
 /// This enum is used to supply a `reason_code` for block rejections
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 #[repr(u8)]
@@ -70,6 +80,10 @@ pub enum RejectCode {
     ValidationFailed(ValidateRejectCode),
     /// Missing expected transactions
     MissingTransactions(Vec<Txid>),
+    // No Consensus Reached
+    //NoConsensusReached,
+    // Consensus No Reached
+    //ConsensusNo(Signature),
 }
 
 impl From<Packet> for SignerMessage {
@@ -84,6 +98,12 @@ impl From<BlockResponse> for SignerMessage {
     }
 }
 
+impl From<BlockRejection> for SignerMessage {
+    fn from(block_rejection: BlockRejection) -> Self {
+        Self::BlockResponse(BlockResponse::Rejected(block_rejection))
+    }
+}
+
 impl SignerMessage {
     /// Helper function to determine the slot ID for the provided stacker-db writer id
     pub fn slot_id(&self, id: u32) -> u32 {
diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index 677f722420..9a690f79b7 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -52,12 +52,6 @@ impl From<&Config> for StacksClient {
 }
 
 impl StacksClient {
-    /// Retrieve the current miner public key
-    pub fn get_miner_public_key(&self) -> Result<StacksPublicKey, ClientError> {
-        // TODO: Depends on https://github.com/stacks-network/stacks-core/issues/4018
-        todo!("Get the miner public key from the stacks node to verify the miner blocks were signed by the correct miner");
-    }
-
     /// Submit the block proposal to the stacks node. The block will be validated and returned via the HTTP endpoint for Block events.
     pub fn submit_block_for_validation(&self, block: NakamotoBlock) -> Result<(), ClientError> {
         let block_proposal = NakamotoBlockProposal {
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 197d2e1d3d..140d8af562 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -22,8 +22,8 @@ use wsts::state_machine::{OperationResult, PublicKeys};
 use wsts::v2;
 
 use crate::client::{
-    retry_with_exponential_backoff, BlockRejection, BlockResponse, ClientError, RejectCode,
-    SignerMessage, StackerDB, StacksClient,
+    retry_with_exponential_backoff, BlockRejection, ClientError, SignerMessage, StackerDB,
+    StacksClient,
 };
 use crate::config::{Config, Network};
 
@@ -64,8 +64,6 @@ pub struct RunLoop<C> {
     /// The coordinator for inbound messages
     pub coordinator: C,
     /// The signing round used to sign messages
-    // TODO: update this to use frost_signer directly instead of the frost signing round
-    // See: https://github.com/stacks-network/stacks-blockchain/issues/3913
     pub signing_round: Signer<v2::Signer>,
     /// The stacks node client
     pub stacks_client: StacksClient,
@@ -199,23 +197,14 @@ impl<C: Coordinator> RunLoop<C> {
                     "Received a block proposal that was rejected by the stacks node: {:?}",
                     block_validate_reject
                 );
-                // TODO: submit a rejection response to the .signers contract for miners
+                // Submit a rejection response to the .signers contract for miners
                 // to observe so they know to ignore it and to prove signers are doing work
-                let block_rejection = BlockRejection {
-                    block: block_validate_reject.block,
-                    reason: block_validate_reject.reason,
-                    reason_code: RejectCode::ValidationFailed(block_validate_reject.reason_code),
-                };
-                let message =
-                    SignerMessage::BlockResponse(BlockResponse::Rejected(block_rejection));
+                let block_rejection = BlockRejection::from(block_validate_reject);
                 if let Err(e) = self
                     .stackerdb
-                    .send_message_with_retry(self.signing_round.signer_id, message)
+                    .send_message_with_retry(self.signing_round.signer_id, block_rejection.into())
                 {
-                    warn!(
-                        "Failed to send block rejection response to stacker-db: {:?}",
-                        e
-                    );
+                    warn!("Failed to send block rejection to stacker-db: {:?}", e);
                 }
             }
         }
@@ -273,6 +262,7 @@ impl<C: Coordinator> RunLoop<C> {
 
         self.send_outbound_messages(signer_outbound_messages);
         self.send_outbound_messages(coordinator_outbound_messages);
+        self.send_block_response_messages(&operation_results);
         self.send_operation_results(res, operation_results);
     }
 
@@ -294,6 +284,65 @@ impl<C: Coordinator> RunLoop<C> {
         }
     }
 
+    /// Helper function to extract block proposals from signature results and braodcast them to the stackerdb slot
+    fn send_block_response_messages(&mut self, _operation_results: &[OperationResult]) {
+        //TODO: Deserialize the signature result and broadcast an appropriate Reject or Approval message to stackerdb
+        // https://github.com/stacks-network/stacks-core/issues/3930
+        // for result in operation_results {
+        //     match result {
+        //         OperationResult::Sign(signature) => {
+        //             debug!("Successfully signed message: {:?}", signature);
+        //             if signature.verify(
+        //                 &self
+        //                     .coordinator
+        //                     .get_aggregate_public_key()
+        //                     .expect("How could we have signed with no DKG?"),
+        //                 &block.unwrap().header.signature_hash().0,
+        //             ) {
+        //                 block.header.signer_signature = Some(signature);
+        //                 let message = SignerMessage::BlockResponse(BlockResponse::Accepted(block));
+        //                 // Submit the accepted signature to the stacks node
+        //                 if let Err(e) = self.stackerdb.send_message_with_retry(
+        //                     self.signing_round.signer_id,
+        //                     message,
+        //                 ) {
+        //                     warn!("Failed to send block rejection to stacker-db: {:?}", e);
+        //                 }
+        //             } else if false // match against the hash of the block + "no"
+        //             {
+        //                 warn!("Failed to verify signature: {:?}", signature);
+        //                 let block_rejection = BlockRejection {
+        //                     block,
+        //                     reject_code: RejectCode::ConsensusNo(signature),
+        //                     reason: "Consensus no vote".to_string()
+        //                 };
+        //                 if let Err(e) = self
+        //                 .stackerdb
+        //                 .send_message_with_retry(self.signing_round.signer_id, block_rejection.into())
+        //             {
+        //                 warn!(
+        //                     "Failed to send block rejection to stacker-db: {:?}",
+        //                     e
+        //                 );
+        //             }
+        //             } else { // No consensus reached
+        //                 if let Err(e) = self
+        //                 .stackerdb
+        //                 .send_message_with_retry(self.signing_round.signer_id, block_rejection.into())
+        //             {
+        //                 warn!(
+        //                     "Failed to send block rejection to stacker-db: {:?}",
+        //                     e
+        //                 );
+        //             }
+        //             }
+        //         },
+        //         _ => {
+        //             // Nothing to do
+        //         }
+        //     }
+    }
+
     /// Helper function to send operation results across the provided channel
     fn send_operation_results(
         &mut self,

From 46acc94692badb60fd458770d4813da706b70847 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 12 Jan 2024 08:39:47 -0500
Subject: [PATCH 0375/1166] Add braindumped psuedo code function for extracting
 block responses from signature

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/runloop.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 140d8af562..c4ae8eb574 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -274,7 +274,8 @@ impl<C: Coordinator> RunLoop<C> {
                 warn!("Received an unrecognized message type from .miners stacker-db slot id {}: {:?}", chunk.slot_id, ptr);
                 continue;
             };
-
+            //TODO: trigger the signing round here instead. Then deserialize the block and call the validation as you validate its contents
+            // https://github.com/stacks-network/stacks-core/issues/3930
             // Received a block proposal from the miner. Submit it for verification.
             self.stacks_client
                 .submit_block_for_validation(block)

From 8216918288cf34ea5eb6793a1049f5321df8a58c Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 12 Jan 2024 08:48:59 -0500
Subject: [PATCH 0376/1166] CRC: remove unused EventPrefix and fix copyright
 year from 2023 to 2024 in stacks-signer code

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 libsigner/src/events.rs         | 29 -----------------------------
 stacks-signer/src/client/mod.rs |  2 +-
 stacks-signer/src/lib.rs        |  2 +-
 3 files changed, 2 insertions(+), 31 deletions(-)

diff --git a/libsigner/src/events.rs b/libsigner/src/events.rs
index a8ab01563f..7e50226ef6 100644
--- a/libsigner/src/events.rs
+++ b/libsigner/src/events.rs
@@ -38,35 +38,6 @@ use wsts::net::{Message, Packet};
 use crate::http::{decode_http_body, decode_http_request};
 use crate::EventError;
 
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-#[repr(u8)]
-enum EventPrefix {
-    /// A StackerDB event
-    StackerDB,
-    /// A block proposal event
-    BlockProposal,
-}
-
-impl From<&SignerEvent> for EventPrefix {
-    fn from(event: &SignerEvent) -> Self {
-        match event {
-            SignerEvent::StackerDB(_) => EventPrefix::StackerDB,
-            SignerEvent::BlockProposal(_) => EventPrefix::BlockProposal,
-        }
-    }
-}
-impl TryFrom<u8> for EventPrefix {
-    type Error = ();
-
-    fn try_from(value: u8) -> Result<Self, Self::Error> {
-        match value {
-            0 => Ok(EventPrefix::StackerDB),
-            1 => Ok(EventPrefix::BlockProposal),
-            _ => Err(()),
-        }
-    }
-}
-
 /// Event enum for newly-arrived signer subscribed events
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub enum SignerEvent {
diff --git a/stacks-signer/src/client/mod.rs b/stacks-signer/src/client/mod.rs
index 73e6d756f3..ec7e8e8235 100644
--- a/stacks-signer/src/client/mod.rs
+++ b/stacks-signer/src/client/mod.rs
@@ -1,5 +1,5 @@
 // Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
-// Copyright (C) 2020-2023 Stacks Open Internet Foundation
+// Copyright (C) 2020-2024 Stacks Open Internet Foundation
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
diff --git a/stacks-signer/src/lib.rs b/stacks-signer/src/lib.rs
index c0a8a11f7c..cadb72c8a4 100644
--- a/stacks-signer/src/lib.rs
+++ b/stacks-signer/src/lib.rs
@@ -5,7 +5,7 @@ Usage documentation can be found in the [README](https://github.com/Trust-Machin
 */
 
 // Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
-// Copyright (C) 2020-2023 Stacks Open Internet Foundation
+// Copyright (C) 2020-2024 Stacks Open Internet Foundation
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by

From 186fa2e35edb290c3f4a402e12de241de4700c20 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 12 Jan 2024 09:18:46 -0500
Subject: [PATCH 0377/1166] Filter out unknown contract ids from libsigner
 events

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 libsigner/src/error.rs  |  5 +++++
 libsigner/src/events.rs | 18 +++++++++++++++---
 2 files changed, 20 insertions(+), 3 deletions(-)

diff --git a/libsigner/src/error.rs b/libsigner/src/error.rs
index fec6a1e8f1..101a1b35e9 100644
--- a/libsigner/src/error.rs
+++ b/libsigner/src/error.rs
@@ -16,6 +16,8 @@
 
 use std::io;
 
+use clarity::vm::types::QualifiedContractIdentifier;
+
 /// Errors originating from doing an RPC request to the Stacks node
 #[derive(thiserror::Error, Debug)]
 pub enum RPCError {
@@ -66,4 +68,7 @@ pub enum EventError {
     /// Unrecognized event error
     #[error("Unrecognized event: {0}")]
     UnrecognizedEvent(String),
+    /// Unrecognized stacker DB contract error
+    #[error("Unrecognized StackerDB contract: {0}")]
+    UnrecognizedStackerDBContract(QualifiedContractIdentifier),
 }
diff --git a/libsigner/src/events.rs b/libsigner/src/events.rs
index 7e50226ef6..cc05d5db0d 100644
--- a/libsigner/src/events.rs
+++ b/libsigner/src/events.rs
@@ -138,7 +138,7 @@ impl SignerEventReceiver {
     /// Do something with the socket
     pub fn with_server<F, R>(&mut self, todo: F) -> Result<R, EventError>
     where
-        F: FnOnce(&mut SignerEventReceiver, &mut HttpServer) -> R,
+        F: FnOnce(&SignerEventReceiver, &mut HttpServer, &[QualifiedContractIdentifier]) -> R,
     {
         let mut server = if let Some(s) = self.http_server.take() {
             s
@@ -146,7 +146,7 @@ impl SignerEventReceiver {
             return Err(EventError::NotBound);
         };
 
-        let res = todo(self, &mut server);
+        let res = todo(self, &mut server, &self.stackerdb_contract_ids);
 
         self.http_server = Some(server);
         Ok(res)
@@ -203,7 +203,7 @@ impl EventReceiver for SignerEventReceiver {
     /// Errors are recoverable -- the caller should call this method again even if it returns an
     /// error.
     fn next_event(&mut self) -> Result<SignerEvent, EventError> {
-        self.with_server(|event_receiver, http_server| {
+        self.with_server(|event_receiver, http_server, contract_ids| {
             let mut request = http_server.recv()?;
 
             // were we asked to terminate?
@@ -230,6 +230,18 @@ impl EventReceiver for SignerEventReceiver {
                         EventError::Deserialize(format!("Could not decode body to JSON: {:?}", &e))
                     })?;
 
+                if !contract_ids.contains(&event.contract_id) {
+                    info!(
+                        "[{:?}] next_event got event from an unexpected contract id {}, return OK so other side doesn't keep sending this",
+                        event_receiver.local_addr,
+                        event.contract_id
+                    );
+                    request
+                        .respond(HttpResponse::empty(200u16))
+                        .expect("response failed");
+                    return Err(EventError::UnrecognizedStackerDBContract(event.contract_id));
+                }
+
                 request
                     .respond(HttpResponse::empty(200u16))
                     .expect("response failed");

From b254b723913c9901bd2ec665cdcab1d158575927 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 12 Jan 2024 10:24:16 -0500
Subject: [PATCH 0378/1166] Update wsts version to 6.1 to use PartialEq change
 in Packet

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Cargo.toml b/Cargo.toml
index ebc7261cf9..33f1720b77 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -14,7 +14,7 @@ members = [
 
 # Dependencies we want to keep the same between workspace members
 [workspace.dependencies]  
-wsts = { path = "../wsts" }
+wsts = "6.1"
 rand_core = "0.6"
 rand = "0.8"
 

From 13ae8cdb812cd5910afd85d47fda9a6f2dcf5f18 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 12 Jan 2024 12:34:50 -0500
Subject: [PATCH 0379/1166] Add stackerdb_dkg_sign test to CI

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 .github/workflows/bitcoin-tests.yml | 1 +
 Cargo.lock                          | 4 +++-
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/bitcoin-tests.yml b/.github/workflows/bitcoin-tests.yml
index 417d68e2b1..0cf9efa761 100644
--- a/.github/workflows/bitcoin-tests.yml
+++ b/.github/workflows/bitcoin-tests.yml
@@ -74,6 +74,7 @@ jobs:
           - tests::nakamoto_integrations::mine_multiple_per_tenure_integration
           - tests::nakamoto_integrations::block_proposal_api_endpoint
           - tests::nakamoto_integrations::miner_writes_proposed_block_to_stackerdb
+          - tests::signer::stackerdb_dkg_sign
           - tests::signer::stackerdb_block_proposal
     steps:
       ## Setup test environment
diff --git a/Cargo.lock b/Cargo.lock
index 03febb2e39..1eaf731f65 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4714,7 +4714,9 @@ dependencies = [
 
 [[package]]
 name = "wsts"
-version = "6.0.0"
+version = "6.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c7db3d3fe28c359e0cdb7f7ad83e3316bda0ba982b8cd1bf0fbe73ae4127e4b"
 dependencies = [
  "aes-gcm 0.10.2",
  "bs58 0.5.0",

From ea82c27e852e1e68f005c38d4d4ad63f29208160 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 12 Jan 2024 15:55:09 -0500
Subject: [PATCH 0380/1166] CRC: add rustdocs to test, cleanup error handling
 in event.rs, and revert postblock_proposal api changes

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 libsigner/src/events.rs                     | 30 +++++--
 stackslib/src/net/api/postblock_proposal.rs | 94 +++++++++------------
 testnet/stacks-node/src/tests/signer.rs     | 37 ++++++--
 3 files changed, 94 insertions(+), 67 deletions(-)

diff --git a/libsigner/src/events.rs b/libsigner/src/events.rs
index cc05d5db0d..aa770820b9 100644
--- a/libsigner/src/events.rs
+++ b/libsigner/src/events.rs
@@ -220,10 +220,19 @@ impl EventReceiver for SignerEventReceiver {
             if request.url() == "/stackerdb_chunks" {
                 debug!("Got stackerdb_chunks event");
                 let mut body = String::new();
-                request
+                if let Err(e) = request
                     .as_reader()
-                    .read_to_string(&mut body)
-                    .expect("failed to read body");
+                    .read_to_string(&mut body) {
+                    error!("Failed to read body: {:?}", &e);
+
+                    request
+                        .respond(HttpResponse::empty(200u16))
+                        .expect("response failed");
+                    return Err(EventError::MalformedRequest(format!(
+                        "Failed to read body: {:?}",
+                        &e
+                    )));
+                    }
 
                 let event: StackerDBChunksEvent =
                     serde_json::from_slice(body.as_bytes()).map_err(|e| {
@@ -250,10 +259,19 @@ impl EventReceiver for SignerEventReceiver {
             } else if request.url() == "/proposal_response" {
                 debug!("Got proposal_response event");
                 let mut body = String::new();
-                request
+                if let Err(e) = request
                     .as_reader()
-                    .read_to_string(&mut body)
-                    .expect("failed to read body");
+                    .read_to_string(&mut body) {
+                    error!("Failed to read body: {:?}", &e);
+
+                    request
+                        .respond(HttpResponse::empty(200u16))
+                        .expect("response failed");
+                    return Err(EventError::MalformedRequest(format!(
+                        "Failed to read body: {:?}",
+                        &e
+                    )));
+                    }
 
                 let event: BlockValidateResponse =
                     serde_json::from_slice(body.as_bytes()).map_err(|e| {
diff --git a/stackslib/src/net/api/postblock_proposal.rs b/stackslib/src/net/api/postblock_proposal.rs
index 1c6613f8d7..4091aabb5a 100644
--- a/stackslib/src/net/api/postblock_proposal.rs
+++ b/stackslib/src/net/api/postblock_proposal.rs
@@ -96,6 +96,25 @@ pub struct BlockValidateReject {
     pub reason_code: ValidateRejectCode,
 }
 
+#[derive(Debug, Clone, PartialEq)]
+pub struct BlockValidateRejectReason {
+    pub reason: String,
+    pub reason_code: ValidateRejectCode,
+}
+
+impl<T> From<T> for BlockValidateRejectReason
+where
+    T: Into<ChainError>,
+{
+    fn from(value: T) -> Self {
+        let ce: ChainError = value.into();
+        Self {
+            reason: format!("Chainstate Error: {ce}"),
+            reason_code: ValidateRejectCode::ChainstateError,
+        }
+    }
+}
+
 /// A response for block proposal validation
 ///  that the stacks-node thinks is acceptable.
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
@@ -144,7 +163,13 @@ impl NakamotoBlockProposal {
         thread::Builder::new()
             .name("block-proposal".into())
             .spawn(move || {
-                let result = self.validate(&sortdb, &mut chainstate);
+                let result =
+                    self.validate(&sortdb, &mut chainstate)
+                        .map_err(|reason| BlockValidateReject {
+                            block: self.block.clone(),
+                            reason_code: reason.reason_code,
+                            reason: reason.reason,
+                        });
                 receiver.notify_proposal_result(result);
             })
     }
@@ -163,36 +188,24 @@ impl NakamotoBlockProposal {
         &self,
         sortdb: &SortitionDB,
         chainstate: &mut StacksChainState, // not directly used; used as a handle to open other chainstates
-    ) -> Result<BlockValidateOk, BlockValidateReject> {
+    ) -> Result<BlockValidateOk, BlockValidateRejectReason> {
         let ts_start = get_epoch_time_ms();
         // Measure time from start of function
         let time_elapsed = || get_epoch_time_ms().saturating_sub(ts_start);
 
         let mainnet = self.chain_id == CHAIN_ID_MAINNET;
         if self.chain_id != chainstate.chain_id || mainnet != chainstate.mainnet {
-            return Err(BlockValidateReject {
-                block: self.block.clone(),
+            return Err(BlockValidateRejectReason {
                 reason_code: ValidateRejectCode::InvalidBlock,
                 reason: "Wrong network/chain_id".into(),
             });
         }
 
         let burn_dbconn = sortdb.index_conn();
-        let sort_tip = SortitionDB::get_canonical_sortition_tip(sortdb.conn()).map_err(|ce| {
-            BlockValidateReject {
-                block: self.block.clone(),
-                reason: format!("Chainstate Error: {ce}"),
-                reason_code: ValidateRejectCode::ChainstateError,
-            }
-        })?;
+        let sort_tip = SortitionDB::get_canonical_sortition_tip(sortdb.conn())?;
         let mut db_handle = sortdb.index_handle(&sort_tip);
         let expected_burn =
-            NakamotoChainState::get_expected_burns(&mut db_handle, chainstate.db(), &self.block)
-                .map_err(|ce| BlockValidateReject {
-                    block: self.block.clone(),
-                    reason: format!("Chainstate Error: {ce}"),
-                    reason_code: ValidateRejectCode::ChainstateError,
-                })?;
+            NakamotoChainState::get_expected_burns(&mut db_handle, chainstate.db(), &self.block)?;
 
         // Static validation checks
         NakamotoChainState::validate_nakamoto_block_burnchain(
@@ -201,25 +214,14 @@ impl NakamotoBlockProposal {
             &self.block,
             mainnet,
             self.chain_id,
-        )
-        .map_err(|ce| BlockValidateReject {
-            block: self.block.clone(),
-            reason: format!("Chainstate Error: {ce}"),
-            reason_code: ValidateRejectCode::ChainstateError,
-        })?;
+        )?;
 
         // Validate txs against chainstate
         let parent_stacks_header = NakamotoChainState::get_block_header(
             chainstate.db(),
             &self.block.header.parent_block_id,
-        )
-        .map_err(|ce| BlockValidateReject {
-            block: self.block.clone(),
-            reason: format!("Chainstate Error: {ce}"),
-            reason_code: ValidateRejectCode::ChainstateError,
-        })?
-        .ok_or_else(|| BlockValidateReject {
-            block: self.block.clone(),
+        )?
+        .ok_or_else(|| BlockValidateRejectReason {
             reason_code: ValidateRejectCode::InvalidBlock,
             reason: "Invalid parent block".into(),
         })?;
@@ -244,27 +246,11 @@ impl NakamotoBlockProposal {
             self.block.header.burn_spent,
             tenure_change,
             coinbase,
-        )
-        .map_err(|ce| BlockValidateReject {
-            block: self.block.clone(),
-            reason: format!("Chainstate Error: {ce}"),
-            reason_code: ValidateRejectCode::ChainstateError,
-        })?;
+        )?;
 
-        let mut miner_tenure_info = builder
-            .load_tenure_info(chainstate, &burn_dbconn, tenure_cause)
-            .map_err(|ce| BlockValidateReject {
-                block: self.block.clone(),
-                reason: format!("Chainstate Error: {ce}"),
-                reason_code: ValidateRejectCode::ChainstateError,
-            })?;
-        let mut tenure_tx = builder
-            .tenure_begin(&burn_dbconn, &mut miner_tenure_info)
-            .map_err(|ce| BlockValidateReject {
-                block: self.block.clone(),
-                reason: format!("Chainstate Error: {ce}"),
-                reason_code: ValidateRejectCode::ChainstateError,
-            })?;
+        let mut miner_tenure_info =
+            builder.load_tenure_info(chainstate, &burn_dbconn, tenure_cause)?;
+        let mut tenure_tx = builder.tenure_begin(&burn_dbconn, &mut miner_tenure_info)?;
 
         for (i, tx) in self.block.txs.iter().enumerate() {
             let tx_len = tx.tx_len();
@@ -291,8 +277,7 @@ impl NakamotoBlockProposal {
                     "reason" => %reason,
                     "tx" => ?tx,
                 );
-                return Err(BlockValidateReject {
-                    block: self.block.clone(),
+                return Err(BlockValidateRejectReason {
                     reason,
                     reason_code: ValidateRejectCode::BadTransaction,
                 });
@@ -321,8 +306,7 @@ impl NakamotoBlockProposal {
                 //"expected_block" => %serde_json::to_string(&serde_json::to_value(&self.block).unwrap()).unwrap(),
                 //"computed_block" => %serde_json::to_string(&serde_json::to_value(&block).unwrap()).unwrap(),
             );
-            return Err(BlockValidateReject {
-                block: self.block.clone(),
+            return Err(BlockValidateRejectReason {
                 reason: "Block hash is not as expected".into(),
                 reason_code: ValidateRejectCode::BadBlockHash,
             });
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index 59c181fee2..160f83bdb1 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -401,6 +401,22 @@ fn stackerdb_dkg_sign() {
 
 #[test]
 #[ignore]
+/// Test that a signer can respond to a miners request for a signature on a block proposal
+///
+/// Test Setup:
+/// The test spins up five stacks signers, one miner Nakamoto node, and a corresponding bitcoind.
+/// The stacks node is advanced to epoch 3.0. and signers perform a DKG round (this should be removed
+/// once we have proper casting of the vote during epoch 2.5).
+///
+/// Test Execution:
+/// The node attempts to mine a Nakamoto tenure, sending a block to the observing signers via the
+/// .miners stacker db instance. The signers submit the block to the stacks node for verification.
+/// Upon receiving a Block Validation response approving the block, the signers perform a signing
+/// round across its signature hash.
+///
+/// Test Assertion:
+/// Signers return an operation result containing a valid signature across the miner's Nakamoto block's signature hash.
+/// TODO: update this test to assert that the signers broadcast a Nakamoto block response back to the miners
 fn stackerdb_block_proposal() {
     if env::var("BITCOIND_TEST") != Ok("1".into()) {
         return;
@@ -480,12 +496,6 @@ fn stackerdb_block_proposal() {
     .unwrap();
 
     info!("------------------------- Test Block Processed -------------------------");
-    //Wait for the block to show up in the test observer
-    let validate_responses = test_observer::get_proposal_responses();
-    let proposed_block = match validate_responses.first().expect("No block proposal") {
-        BlockValidateResponse::Ok(block_validated) => block_validated.block.clone(),
-        _ => panic!("Unexpected response"),
-    };
     let recv = signer_test
         .result_receivers
         .last()
@@ -505,6 +515,21 @@ fn stackerdb_block_proposal() {
         }
     }
     let signature = signature.expect("Failed to get signature");
+    // Wait for the block to show up in the test observer (Don't have to wait long as if we have received a signature,
+    // we know that the signers have already received their block proposal events via their event observers)
+    let t_start = std::time::Instant::now();
+    while test_observer::get_proposal_responses().is_empty() {
+        assert!(
+            t_start.elapsed() < Duration::from_secs(30),
+            "Timed out while waiting for block proposal event"
+        );
+        thread::sleep(Duration::from_secs(1));
+    }
+    let validate_responses = test_observer::get_proposal_responses();
+    let proposed_block = match validate_responses.first().expect("No block proposal") {
+        BlockValidateResponse::Ok(block_validated) => block_validated.block.clone(),
+        _ => panic!("Unexpected response"),
+    };
     let signature_hash = proposed_block
         .header
         .signature_hash()

From 01839ee943577c7c6f343f206f83f8da7f92c3df Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Tue, 16 Jan 2024 09:13:55 -0500
Subject: [PATCH 0381/1166] Remove unnecessary changes to cli and configs

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/cli.rs                   |  6 +++---
 stacks-signer/src/client/stackerdb.rs      |  2 +-
 stacks-signer/src/config.rs                | 24 ++++++++++------------
 stacks-signer/src/main.rs                  |  4 ++--
 stacks-signer/src/tests/conf/signer-0.toml |  2 +-
 stacks-signer/src/tests/conf/signer-1.toml |  2 +-
 stacks-signer/src/tests/conf/signer-2.toml |  2 +-
 stacks-signer/src/tests/conf/signer-3.toml |  2 +-
 stacks-signer/src/tests/conf/signer-4.toml |  2 +-
 stacks-signer/src/utils.rs                 |  4 ++--
 testnet/stacks-node/src/tests/signer.rs    | 14 ++++++-------
 11 files changed, 31 insertions(+), 33 deletions(-)

diff --git a/stacks-signer/src/cli.rs b/stacks-signer/src/cli.rs
index 65aa8ccafc..ad7b40e067 100644
--- a/stacks-signer/src/cli.rs
+++ b/stacks-signer/src/cli.rs
@@ -133,14 +133,14 @@ pub struct GenerateFilesArgs {
     pub signers_contract: QualifiedContractIdentifier,
     #[arg(
         long,
-        required_unless_present = "signer_private_keys",
-        conflicts_with = "signer_private_keys"
+        required_unless_present = "private_keys",
+        conflicts_with = "private_keys"
     )]
     /// The number of signers to generate
     pub num_signers: Option<u32>,
     #[clap(long, value_name = "FILE")]
     /// A path to a file containing a list of hexadecimal Stacks private keys of the signers
-    pub signer_private_keys: Option<PathBuf>,
+    pub private_keys: Option<PathBuf>,
     #[arg(long)]
     /// The total number of key ids to distribute among the signers
     pub num_keys: u32,
diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index 5cd103f5fc..4b1c5e5e53 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -140,7 +140,7 @@ impl From<&Config> for StackerDB {
         Self {
             signers_stackerdb_session: StackerDBSession::new(
                 config.node_host,
-                config.signers_stackerdb_contract_id.clone(),
+                config.stackerdb_contract_id.clone(),
             ),
             stacks_private_key: config.stacks_private_key,
             slot_versions: HashMap::new(),
diff --git a/stacks-signer/src/config.rs b/stacks-signer/src/config.rs
index 61ca95fa3a..aa031e7eb1 100644
--- a/stacks-signer/src/config.rs
+++ b/stacks-signer/src/config.rs
@@ -100,7 +100,7 @@ pub struct Config {
     /// endpoint to the event receiver
     pub endpoint: SocketAddr,
     /// smart contract that controls the target signers' stackerdb
-    pub signers_stackerdb_contract_id: QualifiedContractIdentifier,
+    pub stackerdb_contract_id: QualifiedContractIdentifier,
     /// The Scalar representation of the private key for signer communication
     pub message_private_key: Scalar,
     /// The signer's Stacks private key
@@ -141,9 +141,9 @@ struct RawConfigFile {
     pub node_host: String,
     /// endpoint to event receiver
     pub endpoint: String,
-    // FIXME: this should go away once .signers contract exists
+    // FIXME: this should go away once .signers contract exists at pox-4 instantiation
     /// Signers' Stacker db contract identifier
-    pub signers_stackerdb_contract_id: String,
+    pub stackerdb_contract_id: String,
     /// the 32 byte ECDSA private key used to sign blocks, chunks, and transactions
     pub message_private_key: String,
     /// The hex representation of the signer's Stacks private key used for communicating
@@ -215,15 +215,13 @@ impl TryFrom<RawConfigFile> for Config {
                 raw_data.endpoint.clone(),
             ))?;
 
-        let signers_stackerdb_contract_id = QualifiedContractIdentifier::parse(
-            &raw_data.signers_stackerdb_contract_id,
-        )
-        .map_err(|_| {
-            ConfigError::BadField(
-                "signers_stackerdb_contract_id".to_string(),
-                raw_data.signers_stackerdb_contract_id,
-            )
-        })?;
+        let stackerdb_contract_id =
+            QualifiedContractIdentifier::parse(&raw_data.stackerdb_contract_id).map_err(|_| {
+                ConfigError::BadField(
+                    "stackerdb_contract_id".to_string(),
+                    raw_data.stackerdb_contract_id,
+                )
+            })?;
 
         let message_private_key =
             Scalar::try_from(raw_data.message_private_key.as_str()).map_err(|_| {
@@ -275,7 +273,7 @@ impl TryFrom<RawConfigFile> for Config {
         Ok(Self {
             node_host,
             endpoint,
-            signers_stackerdb_contract_id,
+            stackerdb_contract_id,
             message_private_key,
             stacks_private_key,
             stacks_address,
diff --git a/stacks-signer/src/main.rs b/stacks-signer/src/main.rs
index 1a41918712..a04d6a24f6 100644
--- a/stacks-signer/src/main.rs
+++ b/stacks-signer/src/main.rs
@@ -88,7 +88,7 @@ fn spawn_running_signer(path: &PathBuf) -> SpawnedSigner {
     let config = Config::try_from(path).unwrap();
     let (cmd_send, cmd_recv) = channel();
     let (res_send, res_recv) = channel();
-    let ev = SignerEventReceiver::new(vec![config.signers_stackerdb_contract_id.clone()]);
+    let ev = SignerEventReceiver::new(vec![config.stackerdb_contract_id.clone()]);
     let runloop: RunLoop<FireCoordinator<v2::Aggregator>> = RunLoop::from(&config);
     let mut signer: Signer<
         RunLoopCommand,
@@ -247,7 +247,7 @@ fn handle_run(args: RunDkgArgs) {
 
 fn handle_generate_files(args: GenerateFilesArgs) {
     debug!("Generating files...");
-    let signer_stacks_private_keys = if let Some(path) = args.signer_private_keys {
+    let signer_stacks_private_keys = if let Some(path) = args.private_keys {
         let file = File::open(&path).unwrap();
         let reader = io::BufReader::new(file);
 
diff --git a/stacks-signer/src/tests/conf/signer-0.toml b/stacks-signer/src/tests/conf/signer-0.toml
index dc9bbf61c2..ee510d563e 100644
--- a/stacks-signer/src/tests/conf/signer-0.toml
+++ b/stacks-signer/src/tests/conf/signer-0.toml
@@ -4,7 +4,7 @@ stacks_private_key = "69be0e68947fa7128702761151dc8d9b39ee1401e547781bb2ec3e5b4e
 node_host = "127.0.0.1:20443"
 endpoint = "localhost:30000"
 network = "testnet"
-signers_stackerdb_contract_id = "ST11Z60137Y96MF89K1KKRTA3CR6B25WY1Y931668.signers-stackerdb"
+stackerdb_contract_id = "ST11Z60137Y96MF89K1KKRTA3CR6B25WY1Y931668.signers-stackerdb"
 signer_id = 0
 signers = [
             {public_key = "swBaKxfzs4pQne7spxhrkF6AtB34WEcreAkJ8mPcqx3t", key_ids = [1, 2, 3, 4]}
diff --git a/stacks-signer/src/tests/conf/signer-1.toml b/stacks-signer/src/tests/conf/signer-1.toml
index c0988c9c8d..73d5cb6a69 100644
--- a/stacks-signer/src/tests/conf/signer-1.toml
+++ b/stacks-signer/src/tests/conf/signer-1.toml
@@ -4,7 +4,7 @@ stacks_private_key = "fd5a538e8548e9d6a4a4060a43d0142356df022a4b8fd8ed4a7d066382
 node_host = "127.0.0.1:20443"
 endpoint = "localhost:30001"
 network = "testnet"
-signers_stackerdb_contract_id = "ST11Z60137Y96MF89K1KKRTA3CR6B25WY1Y931668.signers-stackerdb"
+stackerdb_contract_id = "ST11Z60137Y96MF89K1KKRTA3CR6B25WY1Y931668.signers-stackerdb"
 signer_id = 1
 signers = [
             {public_key = "swBaKxfzs4pQne7spxhrkF6AtB34WEcreAkJ8mPcqx3t", key_ids = [1, 2, 3, 4]}
diff --git a/stacks-signer/src/tests/conf/signer-2.toml b/stacks-signer/src/tests/conf/signer-2.toml
index b6987b71b6..7ff263940d 100644
--- a/stacks-signer/src/tests/conf/signer-2.toml
+++ b/stacks-signer/src/tests/conf/signer-2.toml
@@ -4,7 +4,7 @@ stacks_private_key = "74e8e8550a5210b89461128c600e4bf611d1553e6809308bc012dbb0fb
 node_host = "127.0.0.1:20443"
 endpoint = "localhost:30002"
 network = "testnet"
-signers_stackerdb_contract_id = "ST11Z60137Y96MF89K1KKRTA3CR6B25WY1Y931668.signers-stackerdb"
+stackerdb_contract_id = "ST11Z60137Y96MF89K1KKRTA3CR6B25WY1Y931668.signers-stackerdb"
 signer_id = 2
 signers = [
             {public_key = "swBaKxfzs4pQne7spxhrkF6AtB34WEcreAkJ8mPcqx3t", key_ids = [1, 2, 3, 4]}
diff --git a/stacks-signer/src/tests/conf/signer-3.toml b/stacks-signer/src/tests/conf/signer-3.toml
index 114ea38218..e7ac219a40 100644
--- a/stacks-signer/src/tests/conf/signer-3.toml
+++ b/stacks-signer/src/tests/conf/signer-3.toml
@@ -4,7 +4,7 @@ stacks_private_key = "803fa7b9c8a39ed368f160b3dcbfaa8f677fc157ffbccb46ee3e4a32a3
 node_host = "127.0.0.1:20443"
 endpoint = "localhost:30003"
 network = "testnet"
-signers_stackerdb_contract_id = "ST11Z60137Y96MF89K1KKRTA3CR6B25WY1Y931668.signers-stackerdb"
+stackerdb_contract_id = "ST11Z60137Y96MF89K1KKRTA3CR6B25WY1Y931668.signers-stackerdb"
 signer_id = 3
 signers = [
             {public_key = "swBaKxfzs4pQne7spxhrkF6AtB34WEcreAkJ8mPcqx3t", key_ids = [1, 2, 3, 4]}
diff --git a/stacks-signer/src/tests/conf/signer-4.toml b/stacks-signer/src/tests/conf/signer-4.toml
index 37a68f1035..c2eb3f37d0 100644
--- a/stacks-signer/src/tests/conf/signer-4.toml
+++ b/stacks-signer/src/tests/conf/signer-4.toml
@@ -4,7 +4,7 @@ stacks_private_key = "1bfdf386114aacf355fe018a1ec7ac728fa05ca20a6131a70f686291bb
 node_host = "127.0.0.1:20443"
 endpoint = "localhost:30004"
 network = "testnet"
-signers_stackerdb_contract_id = "ST11Z60137Y96MF89K1KKRTA3CR6B25WY1Y931668.signers-stackerdb"
+stackerdb_contract_id = "ST11Z60137Y96MF89K1KKRTA3CR6B25WY1Y931668.signers-stackerdb"
 signer_id = 4
 signers = [
             {public_key = "swBaKxfzs4pQne7spxhrkF6AtB34WEcreAkJ8mPcqx3t", key_ids = [1, 2, 3, 4]}
diff --git a/stacks-signer/src/utils.rs b/stacks-signer/src/utils.rs
index b99087bfe0..5d882e74cc 100644
--- a/stacks-signer/src/utils.rs
+++ b/stacks-signer/src/utils.rs
@@ -12,7 +12,7 @@ pub fn build_signer_config_tomls(
     signer_stacks_private_keys: &[StacksPrivateKey],
     num_keys: u32,
     node_host: &str,
-    signers_stackerdb_contract_id: &str,
+    stackerdb_contract_id: &str,
     timeout: Option<Duration>,
 ) -> Vec<String> {
     let num_signers = signer_stacks_private_keys.len() as u32;
@@ -71,7 +71,7 @@ stacks_private_key = "{stacks_private_key}"
 node_host = "{node_host}"
 endpoint = "{endpoint}"
 network = "testnet"
-signers_stackerdb_contract_id = "{signers_stackerdb_contract_id}"
+stackerdb_contract_id = "{stackerdb_contract_id}"
 signer_id = {id}
 {signers_array}
 "#
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index 160f83bdb1..08a928d092 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -172,7 +172,7 @@ fn spawn_signer(
     let config = stacks_signer::config::Config::load_from_str(data).unwrap();
     let ev = SignerEventReceiver::new(vec![
         boot_code_id(MINERS_NAME, config.network == Network::Mainnet),
-        config.signers_stackerdb_contract_id.clone(),
+        config.stackerdb_contract_id.clone(),
     ]);
     let runloop: stacks_signer::runloop::RunLoop<FireCoordinator<v2::Aggregator>> =
         stacks_signer::runloop::RunLoop::from(&config);
@@ -195,8 +195,8 @@ fn setup_stx_btc_node(
     num_signers: u32,
     signer_stacks_private_keys: &[StacksPrivateKey],
     publisher_private_key: &StacksPrivateKey,
-    signers_stackerdb_contract: &str,
-    signers_stackerdb_contract_id: &QualifiedContractIdentifier,
+    stackerdb_contract: &str,
+    stackerdb_contract_id: &QualifiedContractIdentifier,
     signer_config_tomls: &Vec<String>,
 ) -> RunningNodes {
     // Spawn the endpoints for observing signers
@@ -235,7 +235,7 @@ fn setup_stx_btc_node(
     naka_conf
         .node
         .stacker_dbs
-        .push(signers_stackerdb_contract_id.clone());
+        .push(stackerdb_contract_id.clone());
     naka_conf.miner.wait_on_interim_blocks = Duration::from_secs(1000);
 
     let stacker_sk = setup_stacker(&mut naka_conf);
@@ -291,12 +291,12 @@ fn setup_stx_btc_node(
         publisher_private_key,
         0,
         tx_fee,
-        &signers_stackerdb_contract_id.name,
-        signers_stackerdb_contract,
+        &stackerdb_contract_id.name,
+        stackerdb_contract,
     );
     submit_tx(&http_origin, &tx);
     // mine it
-    info!("Mining the stackerdb contract: {signers_stackerdb_contract_id}");
+    info!("Mining the signers stackerdb contract: {stackerdb_contract_id}");
     next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
     next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
 

From f394a3b1d11954117bd66bbbcdf4f42894f255e3 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Tue, 16 Jan 2024 16:52:05 -0500
Subject: [PATCH 0382/1166] CRC: add copyright to all files, remove commented
 out code, and move StackerDBChunksEvent to event.rs

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 libsigner/src/events.rs                       |  2 +-
 libsigner/src/tests/mod.rs                    |  2 +-
 stacks-signer/src/cli.rs                      | 15 ++++
 stacks-signer/src/client/stackerdb.rs         | 19 +++--
 stacks-signer/src/client/stacks_client.rs     | 15 ++++
 stacks-signer/src/runloop.rs                  | 70 +++++--------------
 stacks-signer/src/utils.rs                    | 15 ++++
 stackslib/src/chainstate/stacks/events.rs     | 10 +++
 stackslib/src/net/api/poststackerdbchunk.rs   |  9 ---
 testnet/stacks-node/src/event_dispatcher.rs   |  4 +-
 .../src/tests/neon_integrations.rs            |  2 +-
 11 files changed, 91 insertions(+), 72 deletions(-)

diff --git a/libsigner/src/events.rs b/libsigner/src/events.rs
index aa770820b9..dde39a3f83 100644
--- a/libsigner/src/events.rs
+++ b/libsigner/src/events.rs
@@ -22,8 +22,8 @@ use std::sync::Arc;
 
 use blockstack_lib::chainstate::nakamoto::NakamotoBlock;
 use blockstack_lib::chainstate::stacks::boot::MINERS_NAME;
+use blockstack_lib::chainstate::stacks::events::StackerDBChunksEvent;
 use blockstack_lib::net::api::postblock_proposal::BlockValidateResponse;
-use blockstack_lib::net::api::poststackerdbchunk::StackerDBChunksEvent;
 use blockstack_lib::util_lib::boot::boot_code_id;
 use clarity::vm::types::QualifiedContractIdentifier;
 use serde::{Deserialize, Serialize};
diff --git a/libsigner/src/tests/mod.rs b/libsigner/src/tests/mod.rs
index 3e16bf4729..0048b7435c 100644
--- a/libsigner/src/tests/mod.rs
+++ b/libsigner/src/tests/mod.rs
@@ -22,7 +22,7 @@ use std::sync::mpsc::{channel, Receiver, Sender};
 use std::time::Duration;
 use std::{mem, thread};
 
-use blockstack_lib::net::api::poststackerdbchunk::StackerDBChunksEvent;
+use blockstack_lib::chainstate::stacks::events::StackerDBChunksEvent;
 use clarity::vm::types::QualifiedContractIdentifier;
 use libstackerdb::StackerDBChunkData;
 use stacks_common::util::secp256k1::Secp256k1PrivateKey;
diff --git a/stacks-signer/src/cli.rs b/stacks-signer/src/cli.rs
index ad7b40e067..d5b549fd1a 100644
--- a/stacks-signer/src/cli.rs
+++ b/stacks-signer/src/cli.rs
@@ -1,3 +1,18 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020-2024 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
 use std::io::{self, Read};
 use std::net::SocketAddr;
 use std::path::PathBuf;
diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index 4b1c5e5e53..4631ecbd4d 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -1,3 +1,18 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020-2024 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
 use blockstack_lib::burnchains::Txid;
 use blockstack_lib::chainstate::nakamoto::NakamotoBlock;
 use blockstack_lib::net::api::postblock_proposal::{BlockValidateReject, ValidateRejectCode};
@@ -80,10 +95,6 @@ pub enum RejectCode {
     ValidationFailed(ValidateRejectCode),
     /// Missing expected transactions
     MissingTransactions(Vec<Txid>),
-    // No Consensus Reached
-    //NoConsensusReached,
-    // Consensus No Reached
-    //ConsensusNo(Signature),
 }
 
 impl From<Packet> for SignerMessage {
diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index 9a690f79b7..e8a39b82cf 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -1,3 +1,18 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020-2024 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
 use blockstack_lib::burnchains::Txid;
 use blockstack_lib::chainstate::nakamoto::NakamotoBlock;
 use blockstack_lib::chainstate::stacks::boot::POX_4_NAME;
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index c4ae8eb574..5f68359a1c 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -1,11 +1,26 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020-2024 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
 use std::collections::VecDeque;
 use std::sync::mpsc::Sender;
 use std::time::Duration;
 
 use blockstack_lib::chainstate::nakamoto::NakamotoBlock;
 use blockstack_lib::chainstate::stacks::boot::MINERS_NAME;
+use blockstack_lib::chainstate::stacks::events::StackerDBChunksEvent;
 use blockstack_lib::net::api::postblock_proposal::BlockValidateResponse;
-use blockstack_lib::net::api::poststackerdbchunk::StackerDBChunksEvent;
 use blockstack_lib::util_lib::boot::boot_code_id;
 use hashbrown::{HashMap, HashSet};
 use libsigner::{SignerEvent, SignerRunLoop};
@@ -289,59 +304,6 @@ impl<C: Coordinator> RunLoop<C> {
     fn send_block_response_messages(&mut self, _operation_results: &[OperationResult]) {
         //TODO: Deserialize the signature result and broadcast an appropriate Reject or Approval message to stackerdb
         // https://github.com/stacks-network/stacks-core/issues/3930
-        // for result in operation_results {
-        //     match result {
-        //         OperationResult::Sign(signature) => {
-        //             debug!("Successfully signed message: {:?}", signature);
-        //             if signature.verify(
-        //                 &self
-        //                     .coordinator
-        //                     .get_aggregate_public_key()
-        //                     .expect("How could we have signed with no DKG?"),
-        //                 &block.unwrap().header.signature_hash().0,
-        //             ) {
-        //                 block.header.signer_signature = Some(signature);
-        //                 let message = SignerMessage::BlockResponse(BlockResponse::Accepted(block));
-        //                 // Submit the accepted signature to the stacks node
-        //                 if let Err(e) = self.stackerdb.send_message_with_retry(
-        //                     self.signing_round.signer_id,
-        //                     message,
-        //                 ) {
-        //                     warn!("Failed to send block rejection to stacker-db: {:?}", e);
-        //                 }
-        //             } else if false // match against the hash of the block + "no"
-        //             {
-        //                 warn!("Failed to verify signature: {:?}", signature);
-        //                 let block_rejection = BlockRejection {
-        //                     block,
-        //                     reject_code: RejectCode::ConsensusNo(signature),
-        //                     reason: "Consensus no vote".to_string()
-        //                 };
-        //                 if let Err(e) = self
-        //                 .stackerdb
-        //                 .send_message_with_retry(self.signing_round.signer_id, block_rejection.into())
-        //             {
-        //                 warn!(
-        //                     "Failed to send block rejection to stacker-db: {:?}",
-        //                     e
-        //                 );
-        //             }
-        //             } else { // No consensus reached
-        //                 if let Err(e) = self
-        //                 .stackerdb
-        //                 .send_message_with_retry(self.signing_round.signer_id, block_rejection.into())
-        //             {
-        //                 warn!(
-        //                     "Failed to send block rejection to stacker-db: {:?}",
-        //                     e
-        //                 );
-        //             }
-        //             }
-        //         },
-        //         _ => {
-        //             // Nothing to do
-        //         }
-        //     }
     }
 
     /// Helper function to send operation results across the provided channel
diff --git a/stacks-signer/src/utils.rs b/stacks-signer/src/utils.rs
index 5d882e74cc..5e7af9a4e0 100644
--- a/stacks-signer/src/utils.rs
+++ b/stacks-signer/src/utils.rs
@@ -1,3 +1,18 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020-2024 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
 use std::time::Duration;
 
 use rand_core::OsRng;
diff --git a/stackslib/src/chainstate/stacks/events.rs b/stackslib/src/chainstate/stacks/events.rs
index 625b3002c0..a744d126b4 100644
--- a/stackslib/src/chainstate/stacks/events.rs
+++ b/stackslib/src/chainstate/stacks/events.rs
@@ -4,6 +4,7 @@ pub use clarity::vm::events::StacksTransactionEvent;
 use clarity::vm::types::{
     AssetIdentifier, PrincipalData, QualifiedContractIdentifier, StandardPrincipalData, Value,
 };
+use libstackerdb::StackerDBChunkData;
 use stacks_common::codec::StacksMessageCodec;
 use stacks_common::types::chainstate::{BlockHeaderHash, StacksAddress};
 use stacks_common::util::hash::to_hex;
@@ -86,3 +87,12 @@ impl From<(NakamotoBlock, BlockHeaderHash)> for StacksBlockEventData {
         }
     }
 }
+
+/// Event structure for newly-arrived StackerDB data
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct StackerDBChunksEvent {
+    /// The contract ID for the StackerDB instance
+    pub contract_id: QualifiedContractIdentifier,
+    /// The chunk data for newly-modified slots
+    pub modified_slots: Vec<StackerDBChunkData>,
+}
diff --git a/stackslib/src/net/api/poststackerdbchunk.rs b/stackslib/src/net/api/poststackerdbchunk.rs
index a006cf386b..3ca82b4141 100644
--- a/stackslib/src/net/api/poststackerdbchunk.rs
+++ b/stackslib/src/net/api/poststackerdbchunk.rs
@@ -54,15 +54,6 @@ use crate::net::{
 };
 use crate::util_lib::db::{DBConn, Error as DBError};
 
-/// Event structure for newly-arrived StackerDB data
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct StackerDBChunksEvent {
-    /// The contract ID for the StackerDB instance
-    pub contract_id: QualifiedContractIdentifier,
-    /// The chunk data for newly-modified slots
-    pub modified_slots: Vec<StackerDBChunkData>,
-}
-
 #[derive(Clone)]
 pub struct RPCPostStackerDBChunkRequestHandler {
     pub contract_identifier: Option<QualifiedContractIdentifier>,
diff --git a/testnet/stacks-node/src/event_dispatcher.rs b/testnet/stacks-node/src/event_dispatcher.rs
index 98c08ba4a0..6c48ae9214 100644
--- a/testnet/stacks-node/src/event_dispatcher.rs
+++ b/testnet/stacks-node/src/event_dispatcher.rs
@@ -21,7 +21,8 @@ use stacks::chainstate::stacks::db::accounts::MinerReward;
 use stacks::chainstate::stacks::db::unconfirmed::ProcessedUnconfirmedState;
 use stacks::chainstate::stacks::db::{MinerRewardInfo, StacksHeaderInfo};
 use stacks::chainstate::stacks::events::{
-    StacksBlockEventData, StacksTransactionEvent, StacksTransactionReceipt, TransactionOrigin,
+    StackerDBChunksEvent, StacksBlockEventData, StacksTransactionEvent, StacksTransactionReceipt,
+    TransactionOrigin,
 };
 use stacks::chainstate::stacks::miner::TransactionEvent;
 use stacks::chainstate::stacks::{
@@ -32,7 +33,6 @@ use stacks::libstackerdb::StackerDBChunkData;
 use stacks::net::api::postblock_proposal::{
     BlockValidateOk, BlockValidateReject, BlockValidateResponse,
 };
-use stacks::net::api::poststackerdbchunk::StackerDBChunksEvent;
 use stacks::net::atlas::{Attachment, AttachmentInstance};
 use stacks::net::stackerdb::StackerDBEventDispatcher;
 use stacks_common::codec::StacksMessageCodec;
diff --git a/testnet/stacks-node/src/tests/neon_integrations.rs b/testnet/stacks-node/src/tests/neon_integrations.rs
index c9d529bf21..9cb4d1a33a 100644
--- a/testnet/stacks-node/src/tests/neon_integrations.rs
+++ b/testnet/stacks-node/src/tests/neon_integrations.rs
@@ -177,8 +177,8 @@ pub mod test_observer {
     use std::sync::Mutex;
     use std::thread;
 
+    use stacks::chainstate::stacks::events::StackerDBChunksEvent;
     use stacks::net::api::postblock_proposal::BlockValidateResponse;
-    use stacks::net::api::poststackerdbchunk::StackerDBChunksEvent;
     use warp::Filter;
     use {tokio, warp};
 

From 16b7bffd9f045ac56beade5b48eac1aba037b2e5 Mon Sep 17 00:00:00 2001
From: ASuciuX <asuciu@hiro.so>
Date: Wed, 17 Jan 2024 02:29:00 +0200
Subject: [PATCH 0383/1166] feat: renamed back the lib files as cargo-mutants
 supports them now

---
 clarity/Cargo.toml                         | 2 +-
 clarity/src/{lib.rs => libclarity.rs}      | 0
 libsigner/Cargo.toml                       | 2 +-
 libsigner/src/{lib.rs => libsigner.rs}     | 0
 stacks-common/Cargo.toml                   | 2 +-
 stacks-common/src/{lib.rs => libcommon.rs} | 0
 6 files changed, 3 insertions(+), 3 deletions(-)
 rename clarity/src/{lib.rs => libclarity.rs} (100%)
 rename libsigner/src/{lib.rs => libsigner.rs} (100%)
 rename stacks-common/src/{lib.rs => libcommon.rs} (100%)

diff --git a/clarity/Cargo.toml b/clarity/Cargo.toml
index e83c77f823..86089991dc 100644
--- a/clarity/Cargo.toml
+++ b/clarity/Cargo.toml
@@ -15,7 +15,7 @@ resolver = "2"
 
 [lib]
 name = "clarity"
-path = "./src/lib.rs"
+path = "./src/libclarity.rs"
 
 [dependencies]
 rand = "0.7.3"
diff --git a/clarity/src/lib.rs b/clarity/src/libclarity.rs
similarity index 100%
rename from clarity/src/lib.rs
rename to clarity/src/libclarity.rs
diff --git a/libsigner/Cargo.toml b/libsigner/Cargo.toml
index 35aaca69f7..8500ef55fa 100644
--- a/libsigner/Cargo.toml
+++ b/libsigner/Cargo.toml
@@ -13,7 +13,7 @@ edition = "2021"
 
 [lib]
 name = "libsigner"
-path = "./src/lib.rs"
+path = "./src/libsigner.rs"
 
 [dependencies]
 clarity = { path = "../clarity" }
diff --git a/libsigner/src/lib.rs b/libsigner/src/libsigner.rs
similarity index 100%
rename from libsigner/src/lib.rs
rename to libsigner/src/libsigner.rs
diff --git a/stacks-common/Cargo.toml b/stacks-common/Cargo.toml
index 650446ea25..863a82d53c 100644
--- a/stacks-common/Cargo.toml
+++ b/stacks-common/Cargo.toml
@@ -15,7 +15,7 @@ edition = "2021"
 
 [lib]
 name = "stacks_common"
-path = "./src/lib.rs"
+path = "./src/libcommon.rs"
 
 [dependencies]
 rand = "0.7.3"
diff --git a/stacks-common/src/lib.rs b/stacks-common/src/libcommon.rs
similarity index 100%
rename from stacks-common/src/lib.rs
rename to stacks-common/src/libcommon.rs

From 40207d3d352944792b963e1072d4e12b71026e34 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 16 Jan 2024 22:43:15 -0500
Subject: [PATCH 0384/1166] feat: miner behavior improvements (squashed; see
 CHANGELOG)

---
 .cargo/config                                 |    1 +
 .../bitcoin-int-tests/Dockerfile.rustfmt      |    3 +-
 .github/workflows/bitcoin-tests.yml           |    1 +
 CHANGELOG.md                                  |   21 +
 CONTRIBUTING.md                               |   27 +-
 Cargo.lock                                    |    8 +-
 README.md                                     |    2 +-
 .../get_unconfirmed_block_commmits.py         |  134 ++
 src/burnchains/burnchain.rs                   |    4 +-
 src/chainstate/stacks/db/blocks.rs            |   22 +
 src/chainstate/stacks/miner.rs                |    1 +
 src/chainstate/stacks/mod.rs                  |    2 +-
 .../stacks/tests/block_construction.rs        |    1 -
 src/core/mempool.rs                           |  117 +-
 src/core/tests/mod.rs                         |  173 ++-
 src/cost_estimates/fee_scalar.rs              |   23 +-
 src/main.rs                                   |    1 -
 testnet/stacks-node/Cargo.toml                |    4 +-
 .../burnchains/bitcoin_regtest_controller.rs  |   66 +-
 testnet/stacks-node/src/chain_data.rs         | 1105 ++++++++++++++++
 testnet/stacks-node/src/config.rs             |  213 +++-
 testnet/stacks-node/src/main.rs               |  258 +++-
 testnet/stacks-node/src/neon_node.rs          | 1121 +++++++++++++++--
 testnet/stacks-node/src/run_loop/mod.rs       |    2 +-
 testnet/stacks-node/src/run_loop/neon.rs      |   19 +-
 .../stacks-node/src/tests/bitcoin_regtest.rs  |    1 -
 testnet/stacks-node/src/tests/epoch_205.rs    |    1 -
 testnet/stacks-node/src/tests/epoch_21.rs     |    2 -
 testnet/stacks-node/src/tests/epoch_22.rs     |    2 -
 testnet/stacks-node/src/tests/epoch_23.rs     |    1 -
 testnet/stacks-node/src/tests/epoch_24.rs     |   11 +-
 testnet/stacks-node/src/tests/integrations.rs |    1 -
 testnet/stacks-node/src/tests/mod.rs          |  351 +++++-
 .../src/tests/neon_integrations.rs            |  468 +++++--
 34 files changed, 3820 insertions(+), 347 deletions(-)
 create mode 100755 contrib/miner-queries/get_unconfirmed_block_commmits.py
 create mode 100644 testnet/stacks-node/src/chain_data.rs

diff --git a/.cargo/config b/.cargo/config
index 3c72bd0ea1..f208bb1d2d 100644
--- a/.cargo/config
+++ b/.cargo/config
@@ -1,5 +1,6 @@
 [alias]
 stacks-node = "run --package stacks-node --"
+fmt-stacks = "fmt -- --config group_imports=StdExternalCrate,imports_granularity=Module"
 
 # Needed by perf to generate flamegraphs.
 #[target.x86_64-unknown-linux-gnu]
diff --git a/.github/actions/bitcoin-int-tests/Dockerfile.rustfmt b/.github/actions/bitcoin-int-tests/Dockerfile.rustfmt
index 793d8e4668..5d6455e2e6 100644
--- a/.github/actions/bitcoin-int-tests/Dockerfile.rustfmt
+++ b/.github/actions/bitcoin-int-tests/Dockerfile.rustfmt
@@ -4,9 +4,10 @@ WORKDIR /src
 
 COPY ./rust-toolchain .
 COPY ./Cargo.toml .
+COPY ./.cargo .
 
 RUN rustup component add rustfmt
 
 COPY . .
 
-RUN cargo fmt --all -- --check
+RUN cargo fmt-stacks --check
diff --git a/.github/workflows/bitcoin-tests.yml b/.github/workflows/bitcoin-tests.yml
index de1b16c26f..59df529a74 100644
--- a/.github/workflows/bitcoin-tests.yml
+++ b/.github/workflows/bitcoin-tests.yml
@@ -68,6 +68,7 @@ jobs:
           - tests::neon_integrations::test_problematic_microblocks_are_not_relayed_or_stored
           - tests::neon_integrations::test_problematic_txs_are_not_stored
           - tests::neon_integrations::use_latest_tip_integration_test
+          - tests::neon_integrations::min_txs
           - tests::should_succeed_handling_malformed_and_valid_txs
     steps:
       ## Setup test environment
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 812eb18c5e..0c270ad5f3 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,27 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to the versioning scheme outlined in the [README.md](README.md).
 
+## [2.4.0.0.5]
+
+This introduces a set of improvements to the Stacks miner behavior.  In
+particular:
+* The VRF public key can be re-used across node restarts.
+* Settings that affect mining are hot-reloaded from the config file.  They take
+  effect once the file is updated; there is no longer a need to restart the
+node.
+* The act of changing the miner settings in the config file automatically
+  triggers a subsequent block-build attempt, allowing the operator to force the
+miner to re-try building blocks.
+* This adds a new tip-selection algorithm that minimizes block orphans within a
+  configurable window of time.
+* When configured, the node will automatically stop mining if it is not achieving a
+  targeted win rate over a configurable window of blocks.
+* When configured, the node will selectively mine transactions from only certain
+  addresses, or only of certain types (STX-transfers, contract-publishes,
+contract-calls).
+* When configured, the node will optionally only RBF block-commits if it can
+  produce a block with strictly more transactions.
+
 ## [2.4.0.0.4]
 
 This is a high-priority hotfix that addresses a bug in transaction processing which
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 9c121b9dbf..0101858b62 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -91,6 +91,24 @@ should reference the issue in the commit message. For example:
 fix: incorporate unlocks in mempool admitter, #3623
 ```
 
+## Recommended developer setup
+### Recommended githooks
+
+It is helpful to set up the pre-commit git hook set up, so that Rust formatting issues are caught before
+you push your code. Follow these instruction to set it up:
+
+1. Rename `.git/hooks/pre-commit.sample` to `.git/hooks/pre-commit`
+2. Change the content of `.git/hooks/pre-commit` to be the following
+```sh
+#!/bin/sh
+git diff --name-only --staged | grep '\.rs$' | xargs -P 8 -I {} rustfmt {} --edition 2021 --check --config group_imports=StdExternalCrate,imports_granularity=Module || (
+  echo 'rustfmt failed: run "cargo fmt-stacks"';
+  exit 1
+)
+```
+3. Make it executable by running `chmod +x .git/hooks/pre-commit`
+   That's it! Now your pre-commit hook should be configured on your local machine.
+
 # Creating and Reviewing PRs
 
 This section describes some best practices on how to create and review PRs in this context.  The target audience is people who have commit access to this repository (reviewers), and people who open PRs (submitters).  This is a living document -- developers can and should document their own additional guidelines here.
@@ -366,19 +384,20 @@ A test should be marked `#[ignore]` if:
 
 ## Formatting
 
-This repository uses the default rustfmt formatting style. PRs will be checked against `rustfmt` and will _fail_ if not
-properly formatted.
+PRs will be checked against `rustfmt` and will _fail_ if not properly formatted.
+Unfortunately, some config options that we require cannot currently be set in `.rustfmt` files, so arguments must be passed via the command line.
+Therefore, we handle `rustfmt` configuration using a Cargo alias: `cargo fmt-stacks`
 
 You can check the formatting locally via:
 
 ```bash
-cargo fmt --all -- --check --config group_imports=StdExternalCrate
+cargo fmt-stacks --check
 ```
 
 You can automatically reformat your commit via:
 
 ```bash
-cargo fmt --all -- --config group_imports=StdExternalCrate
+cargo fmt-stacks
 ```
 
 ## Comments
diff --git a/Cargo.lock b/Cargo.lock
index 841302aee0..f952164fc8 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1531,9 +1531,9 @@ checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
 
 [[package]]
 name = "libc"
-version = "0.2.140"
+version = "0.2.151"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "99227334921fae1a979cf0bfdfcc6b3e5ce376ef57e16fb6fb3ea2ed6095f80c"
+checksum = "302d7ab3130588088d277783b1e2d2e10c9e9e4a16dd9050e6ec93fb3e7048f4"
 
 [[package]]
 name = "libflate"
@@ -1820,9 +1820,9 @@ dependencies = [
 
 [[package]]
 name = "pico-args"
-version = "0.3.4"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28b9b4df73455c861d7cbf8be42f01d3b373ed7f02e378d55fa84eafc6f638b1"
+checksum = "5be167a7af36ee22fe3115051bc51f6e6c7054c9348e28deb4f49bd6f705a315"
 
 [[package]]
 name = "pin-project"
diff --git a/README.md b/README.md
index 2f1be08873..e61829ff30 100644
--- a/README.md
+++ b/README.md
@@ -67,7 +67,7 @@ You can observe the state machine in action locally by running:
 
 ```bash
 $ cd testnet/stacks-node
-$ cargo run --bin stacks-node -- start --config=./conf/testnet-follower-conf.toml
+$ cargo run --bin stacks-node -- start --config ./conf/testnet-follower-conf.toml
 ```
 
 _On Windows, many tests will fail if the line endings aren't `LF`. Please ensure that you are have git's `core.autocrlf` set to `input` when you clone the repository to avoid any potential issues. This is due to the Clarity language currently being sensitive to line endings._
diff --git a/contrib/miner-queries/get_unconfirmed_block_commmits.py b/contrib/miner-queries/get_unconfirmed_block_commmits.py
new file mode 100755
index 0000000000..c5cee38123
--- /dev/null
+++ b/contrib/miner-queries/get_unconfirmed_block_commmits.py
@@ -0,0 +1,134 @@
+#!/usr/bin/env python3
+"""
+Usage:
+This script is designed to be run from the command line. It takes one or more Bitcoin addresses
+and outputs the extracted block commit data for these addresses.
+
+Example command line usage:
+python3 get_unconfirmed_block_commits.py [btcAddress1] [btcAddress2] ...
+"""
+
+import requests
+import json
+import sys
+
+def read_api_endpoint(url):
+    """
+    Reads data from the specified API endpoint and returns the response.
+
+    Args:
+        url (str): The API endpoint URL.
+
+    Returns:
+        dict: JSON response from the API if successful, otherwise None.
+    """
+    try:
+        response = requests.get(url)
+        response.raise_for_status()  # Raise an exception for non-200 status codes
+        return response.json()  # Assuming a JSON response
+    except requests.exceptions.RequestException as e:
+        return None
+
+def is_block_commit(txn):
+    """
+    Determines whether a given transaction is a block commit.
+
+    Args:
+        txn (dict): The transaction data.
+
+    Returns:
+        bool: True if the transaction is a block commit, otherwise False.
+    """
+    try:
+        vout = txn['vout']
+
+        # Verify the number of recipients.
+        assert(3 <= len(vout) <= 4)
+        block_commit_txn = vout[0]
+        to_stacker_txns = vout[1::2]
+
+        # Verify block commit.
+        # TODO: Add more verification steps if necessary.
+        assert(block_commit_txn['scriptpubkey_type'] == "op_return")
+
+        # Verify PoX Payouts.
+        for to_stacker_txn in to_stacker_txns:
+            # TODO: Add more verification steps if necessary.
+            assert(to_stacker_txn['scriptpubkey_type'] != "op_return")
+
+    except (Exception, AssertionError):
+        return False
+    return True
+
+MEMPOOL_TXN_API = "https://mempool.space/api/address/{btcAddress}/txs/mempool"
+def unconfirmed_block_commit_from_address(btcAddress):
+    """
+    Fetches the first unconfirmed block commit for a given Bitcoin address.
+
+    Args:
+        btcAddress (str): Bitcoin address.
+
+    Returns:
+        dict: The first transaction that is a block commit.
+    """
+    url = MEMPOOL_TXN_API.format(btcAddress=btcAddress)
+    txns = read_api_endpoint(url)
+
+    # Return only the first block commit transaction. This is good enough for now.
+    for txn in txns:
+        if is_block_commit(txn):
+            return txn
+
+def extracted_block_commit_data(txn):
+    """
+    Extracts data from a block commit transaction.
+
+    Args:
+        txn (dict): Block commit transaction.
+
+    Returns:
+        dict: Extracted data from the transaction, or None if extraction fails.
+    """
+    try:
+        vout_start = 1
+        vout_end = len(txn['vout']) - 1
+        spent_utxo = txn['vin'][0]
+        return {
+            'txid': txn['txid'],
+            'burn': sum(pox_payout['value'] for pox_payout in txn['vout'][vout_start:vout_end]),
+            'address': spent_utxo['prevout']['scriptpubkey_address'],
+            'pox_addrs': [txn['vout'][i]['scriptpubkey'] for i in range(vout_start,vout_end)],
+            'input_txid': spent_utxo['txid'],
+            'input_index': spent_utxo['vout'],
+        }
+    except Exception as e:
+        return None
+
+def block_commit_data(btcAddresses):
+    """
+    Fetches and extracts block commit data for a list of Bitcoin addresses.
+
+    Args:
+        btcAddresses (list): List of Bitcoin addresses.
+
+    Returns:
+        list: Extracted block commit data for each address.
+    """
+    return [extracted_block_commit_data(unconfirmed_block_commit_from_address(btcAddress)) \
+            for btcAddress in btcAddresses]
+
+def main():
+    """
+    Main function to run the script. Takes command line arguments as Bitcoin addresses.
+    """
+    btc_addresses = sys.argv[1:]
+    if not btc_addresses:
+        print("No Bitcoin addresses provided. Please provide at least one address.")
+        return
+
+    # Return the data by printing it to stdout.
+    data = block_commit_data(btc_addresses)
+    print(json.dumps([datum for datum in data if datum is not None], indent=1))
+
+if __name__ == "__main__":
+    main()
diff --git a/src/burnchains/burnchain.rs b/src/burnchains/burnchain.rs
index dc0b75de61..f90e05e4ee 100644
--- a/src/burnchains/burnchain.rs
+++ b/src/burnchains/burnchain.rs
@@ -316,7 +316,7 @@ impl BurnchainStateTransition {
 }
 
 impl BurnchainSigner {
-    #[cfg(test)]
+    #[cfg(any(test, feature = "testing"))]
     pub fn mock_parts(
         hash_mode: AddressHashMode,
         num_sigs: usize,
@@ -330,7 +330,7 @@ impl BurnchainSigner {
         BurnchainSigner(repr)
     }
 
-    #[cfg(test)]
+    #[cfg(any(test, feature = "testing"))]
     pub fn new_p2pkh(pubk: &StacksPublicKey) -> BurnchainSigner {
         BurnchainSigner::mock_parts(AddressHashMode::SerializeP2PKH, 1, vec![pubk.clone()])
     }
diff --git a/src/chainstate/stacks/db/blocks.rs b/src/chainstate/stacks/db/blocks.rs
index cc52346682..e16468ad32 100644
--- a/src/chainstate/stacks/db/blocks.rs
+++ b/src/chainstate/stacks/db/blocks.rs
@@ -7042,6 +7042,28 @@ impl StacksChainState {
         query_row(&self.db(), sql, args).map_err(Error::DBError)
     }
 
+    /// Get all possible canonical chain tips
+    pub fn get_stacks_chain_tips(&self, sortdb: &SortitionDB) -> Result<Vec<StagingBlock>, Error> {
+        let (consensus_hash, block_bhh) =
+            SortitionDB::get_canonical_stacks_chain_tip_hash(sortdb.conn())?;
+        let sql = "SELECT * FROM staging_blocks WHERE processed = 1 AND orphaned = 0 AND consensus_hash = ?1 AND anchored_block_hash = ?2";
+        let args: &[&dyn ToSql] = &[&consensus_hash, &block_bhh];
+        let Some(staging_block): Option<StagingBlock> =
+            query_row(&self.db(), sql, args).map_err(Error::DBError)?
+        else {
+            return Ok(vec![]);
+        };
+        self.get_stacks_chain_tips_at_height(staging_block.height)
+    }
+
+    /// Get all Stacks blocks at a given height
+    pub fn get_stacks_chain_tips_at_height(&self, height: u64) -> Result<Vec<StagingBlock>, Error> {
+        let sql =
+            "SELECT * FROM staging_blocks WHERE processed = 1 AND orphaned = 0 AND height = ?1";
+        let args: &[&dyn ToSql] = &[&u64_to_sql(height)?];
+        query_rows(&self.db(), sql, args).map_err(Error::DBError)
+    }
+
     /// Get the parent block of `staging_block`.
     pub fn get_stacks_block_parent(
         &self,
diff --git a/src/chainstate/stacks/miner.rs b/src/chainstate/stacks/miner.rs
index a65eeab78e..71881e304d 100644
--- a/src/chainstate/stacks/miner.rs
+++ b/src/chainstate/stacks/miner.rs
@@ -114,6 +114,7 @@ impl MinerStatus {
     pub fn get_spend_amount(&self) -> u64 {
         return self.spend_amount;
     }
+
     pub fn set_spend_amount(&mut self, amt: u64) {
         self.spend_amount = amt;
     }
diff --git a/src/chainstate/stacks/mod.rs b/src/chainstate/stacks/mod.rs
index 4ed4169d4a..74979b1ece 100644
--- a/src/chainstate/stacks/mod.rs
+++ b/src/chainstate/stacks/mod.rs
@@ -84,7 +84,7 @@ pub use stacks_common::address::{
     C32_ADDRESS_VERSION_TESTNET_MULTISIG, C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
 };
 
-pub const STACKS_BLOCK_VERSION: u8 = 6;
+pub const STACKS_BLOCK_VERSION: u8 = 7;
 pub const STACKS_BLOCK_VERSION_AST_PRECHECK_SIZE: u8 = 1;
 
 pub const MAX_BLOCK_LEN: u32 = 2 * 1024 * 1024;
diff --git a/src/chainstate/stacks/tests/block_construction.rs b/src/chainstate/stacks/tests/block_construction.rs
index 8596ca892e..e1918fb74a 100644
--- a/src/chainstate/stacks/tests/block_construction.rs
+++ b/src/chainstate/stacks/tests/block_construction.rs
@@ -4708,7 +4708,6 @@ fn paramaterized_mempool_walk_test(
     let b_2 = make_block(&mut chainstate, ConsensusHash([0x2; 20]), &b_1, 2, 2);
 
     let mut mempool_settings = MemPoolWalkSettings::default();
-    mempool_settings.min_tx_fee = 10;
     let mut tx_events = Vec::new();
 
     let txs = codec_all_transactions(
diff --git a/src/core/mempool.rs b/src/core/mempool.rs
index 5efb762815..9287fcd519 100644
--- a/src/core/mempool.rs
+++ b/src/core/mempool.rs
@@ -22,6 +22,7 @@ use std::io::{Read, Write};
 use std::ops::Deref;
 use std::ops::DerefMut;
 use std::path::{Path, PathBuf};
+use std::str::FromStr;
 
 use rand::distributions::Uniform;
 use rand::prelude::Distribution;
@@ -292,10 +293,51 @@ impl MemPoolTxMetadata {
     }
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum MemPoolWalkTxTypes {
+    TokenTransfer,
+    SmartContract,
+    ContractCall,
+}
+
+impl FromStr for MemPoolWalkTxTypes {
+    type Err = &'static str;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "TokenTransfer" => {
+                return Ok(Self::TokenTransfer);
+            }
+            "SmartContract" => {
+                return Ok(Self::SmartContract);
+            }
+            "ContractCall" => {
+                return Ok(Self::ContractCall);
+            }
+            _ => {
+                return Err("Unknown mempool tx walk type");
+            }
+        }
+    }
+}
+
+impl MemPoolWalkTxTypes {
+    pub fn all() -> HashSet<MemPoolWalkTxTypes> {
+        [
+            MemPoolWalkTxTypes::TokenTransfer,
+            MemPoolWalkTxTypes::SmartContract,
+            MemPoolWalkTxTypes::ContractCall,
+        ]
+        .into_iter()
+        .collect()
+    }
+
+    pub fn only(selected: &[MemPoolWalkTxTypes]) -> HashSet<MemPoolWalkTxTypes> {
+        selected.iter().map(|x| x.clone()).collect()
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct MemPoolWalkSettings {
-    /// Minimum transaction fee that will be considered
-    pub min_tx_fee: u64,
     /// Maximum amount of time a miner will spend walking through mempool transactions, in
     /// milliseconds.  This is a soft deadline.
     pub max_walk_time_ms: u64,
@@ -308,25 +350,43 @@ pub struct MemPoolWalkSettings {
     /// Size of the candidate cache. These are the candidates that will be retried after each
     /// transaction is mined.
     pub candidate_retry_cache_size: u64,
+    /// Types of transactions we'll consider
+    pub txs_to_consider: HashSet<MemPoolWalkTxTypes>,
+    /// Origins for transactions that we'll consider
+    pub filter_origins: HashSet<StacksAddress>,
 }
 
 impl MemPoolWalkSettings {
     pub fn default() -> MemPoolWalkSettings {
         MemPoolWalkSettings {
-            min_tx_fee: 1,
             max_walk_time_ms: u64::max_value(),
             consider_no_estimate_tx_prob: 5,
             nonce_cache_size: 1024 * 1024,
             candidate_retry_cache_size: 64 * 1024,
+            txs_to_consider: [
+                MemPoolWalkTxTypes::TokenTransfer,
+                MemPoolWalkTxTypes::SmartContract,
+                MemPoolWalkTxTypes::ContractCall,
+            ]
+            .into_iter()
+            .collect(),
+            filter_origins: HashSet::new(),
         }
     }
     pub fn zero() -> MemPoolWalkSettings {
         MemPoolWalkSettings {
-            min_tx_fee: 0,
             max_walk_time_ms: u64::max_value(),
-            consider_no_estimate_tx_prob: 5,
+            consider_no_estimate_tx_prob: 25,
             nonce_cache_size: 1024 * 1024,
             candidate_retry_cache_size: 64 * 1024,
+            txs_to_consider: [
+                MemPoolWalkTxTypes::TokenTransfer,
+                MemPoolWalkTxTypes::SmartContract,
+                MemPoolWalkTxTypes::ContractCall,
+            ]
+            .into_iter()
+            .collect(),
+            filter_origins: HashSet::new(),
         }
     }
 }
@@ -698,8 +758,8 @@ impl<'a> MemPoolTx<'a> {
             let evict_txid = {
                 let num_recents = MemPoolDB::get_num_recent_txs(&dbtx)?;
                 if num_recents >= MAX_BLOOM_COUNTER_TXS.into() {
-                    // for now, remove lowest-fee tx in the recent tx set.
-                    // TODO: In the future, do it by lowest fee rate
+                    // remove lowest-fee tx (they're paying the least, so replication is
+                    // deprioritized)
                     let sql = "SELECT a.txid FROM mempool AS a LEFT OUTER JOIN removed_txids AS b ON a.txid = b.txid WHERE b.txid IS NULL AND a.height > ?1 ORDER BY a.tx_fee ASC LIMIT 1";
                     let args: &[&dyn ToSql] = &[&u64_to_sql(
                         height.saturating_sub(BLOOM_COUNTER_DEPTH as u64),
@@ -1539,6 +1599,49 @@ impl MemPoolDB {
                 }
             };
 
+            let (tx_type, do_consider) = match &tx_info.tx.payload {
+                TransactionPayload::TokenTransfer(..) => (
+                    "TokenTransfer".to_string(),
+                    settings
+                        .txs_to_consider
+                        .contains(&MemPoolWalkTxTypes::TokenTransfer),
+                ),
+                TransactionPayload::SmartContract(..) => (
+                    "SmartContract".to_string(),
+                    settings
+                        .txs_to_consider
+                        .contains(&MemPoolWalkTxTypes::SmartContract),
+                ),
+                TransactionPayload::ContractCall(..) => (
+                    "ContractCall".to_string(),
+                    settings
+                        .txs_to_consider
+                        .contains(&MemPoolWalkTxTypes::ContractCall),
+                ),
+                _ => ("".to_string(), true),
+            };
+            if !do_consider {
+                debug!("Will skip mempool tx, since it does not have an acceptable type";
+                       "txid" => %tx_info.tx.txid(),
+                       "type" => %tx_type);
+                continue;
+            }
+
+            let do_consider = if settings.filter_origins.len() > 0 {
+                settings
+                    .filter_origins
+                    .contains(&tx_info.metadata.origin_address)
+            } else {
+                true
+            };
+
+            if !do_consider {
+                debug!("Will skip mempool tx, since it does not have an allowed origin";
+                       "txid" => %tx_info.tx.txid(),
+                       "origin" => %tx_info.metadata.origin_address);
+                continue;
+            }
+
             let consider = ConsiderTransaction {
                 tx: tx_info,
                 update_estimate,
diff --git a/src/core/tests/mod.rs b/src/core/tests/mod.rs
index 3533ce2ad8..1ad95d781f 100644
--- a/src/core/tests/mod.rs
+++ b/src/core/tests/mod.rs
@@ -42,6 +42,7 @@ use crate::chainstate::stacks::{
 };
 use crate::core::mempool::db_get_all_nonces;
 use crate::core::mempool::MemPoolWalkSettings;
+use crate::core::mempool::MemPoolWalkTxTypes;
 use crate::core::mempool::TxTag;
 use crate::core::mempool::{BLOOM_COUNTER_DEPTH, BLOOM_COUNTER_ERROR_RATE, MAX_BLOOM_COUNTER_TXS};
 use crate::core::FIRST_BURNCHAIN_CONSENSUS_HASH;
@@ -278,8 +279,7 @@ fn mempool_walk_over_fork() {
     //   try to walk at b_4, we should be able to find
     //   the transaction at b_1
 
-    let mut mempool_settings = MemPoolWalkSettings::default();
-    mempool_settings.min_tx_fee = 10;
+    let mempool_settings = MemPoolWalkSettings::default();
     let mut tx_events = Vec::new();
     chainstate.with_read_only_clarity_tx(
         &TEST_BURN_STATE_DB,
@@ -614,7 +614,6 @@ fn test_iterate_candidates_consider_no_estimate_tx_prob() {
     let b_2 = make_block(&mut chainstate, ConsensusHash([0x2; 20]), &b_1, 2, 2);
 
     let mut mempool_settings = MemPoolWalkSettings::default();
-    mempool_settings.min_tx_fee = 10;
     let mut tx_events = Vec::new();
 
     let mut txs = codec_all_transactions(
@@ -809,8 +808,7 @@ fn test_iterate_candidates_skipped_transaction() {
     );
     let b_2 = make_block(&mut chainstate, ConsensusHash([0x2; 20]), &b_1, 2, 2);
 
-    let mut mempool_settings = MemPoolWalkSettings::default();
-    mempool_settings.min_tx_fee = 10;
+    let mempool_settings = MemPoolWalkSettings::default();
     let mut tx_events = Vec::new();
 
     let mut txs = codec_all_transactions(
@@ -922,8 +920,7 @@ fn test_iterate_candidates_processing_error_transaction() {
     );
     let b_2 = make_block(&mut chainstate, ConsensusHash([0x2; 20]), &b_1, 2, 2);
 
-    let mut mempool_settings = MemPoolWalkSettings::default();
-    mempool_settings.min_tx_fee = 10;
+    let mempool_settings = MemPoolWalkSettings::default();
     let mut tx_events = Vec::new();
 
     let mut txs = codec_all_transactions(
@@ -1037,8 +1034,7 @@ fn test_iterate_candidates_problematic_transaction() {
     );
     let b_2 = make_block(&mut chainstate, ConsensusHash([0x2; 20]), &b_1, 2, 2);
 
-    let mut mempool_settings = MemPoolWalkSettings::default();
-    mempool_settings.min_tx_fee = 10;
+    let mempool_settings = MemPoolWalkSettings::default();
     let mut tx_events = Vec::new();
 
     let mut txs = codec_all_transactions(
@@ -1153,7 +1149,6 @@ fn test_iterate_candidates_concurrent_write_lock() {
     let b_2 = make_block(&mut chainstate, ConsensusHash([0x2; 20]), &b_1, 2, 2);
 
     let mut mempool_settings = MemPoolWalkSettings::default();
-    mempool_settings.min_tx_fee = 10;
     let mut tx_events = Vec::new();
 
     let mut txs = codec_all_transactions(
@@ -3013,3 +3008,161 @@ fn test_drop_and_blacklist_txs_by_size() {
 
     assert_eq!(num_blacklisted, 5);
 }
+
+#[test]
+fn test_filter_txs_by_type() {
+    let mut chainstate = instantiate_chainstate(false, 0x80000000, function_name!());
+    let chainstate_path = chainstate_path(function_name!());
+    let mut mempool = MemPoolDB::open_test(false, 0x80000000, &chainstate_path).unwrap();
+
+    let addr = StacksAddress {
+        version: 1,
+        bytes: Hash160([0xff; 20]),
+    };
+    let mut txs = vec![];
+    let block_height = 10;
+    let mut total_len = 0;
+
+    let b_1 = make_block(
+        &mut chainstate,
+        ConsensusHash([0x1; 20]),
+        &(
+            FIRST_BURNCHAIN_CONSENSUS_HASH.clone(),
+            FIRST_STACKS_BLOCK_HASH.clone(),
+        ),
+        1,
+        1,
+    );
+    let b_2 = make_block(&mut chainstate, ConsensusHash([0x2; 20]), &b_1, 2, 2);
+
+    let mut mempool_tx = mempool.tx_begin().unwrap();
+    for i in 0..10 {
+        let pk = StacksPrivateKey::new();
+        let mut tx = StacksTransaction {
+            version: TransactionVersion::Testnet,
+            chain_id: 0x80000000,
+            auth: TransactionAuth::from_p2pkh(&pk).unwrap(),
+            anchor_mode: TransactionAnchorMode::Any,
+            post_condition_mode: TransactionPostConditionMode::Allow,
+            post_conditions: vec![],
+            payload: TransactionPayload::TokenTransfer(
+                addr.to_account_principal(),
+                123,
+                TokenTransferMemo([0u8; 34]),
+            ),
+        };
+        tx.set_tx_fee(1000);
+        tx.set_origin_nonce(0);
+
+        let txid = tx.txid();
+        let tx_bytes = tx.serialize_to_vec();
+        let origin_addr = tx.origin_address();
+        let origin_nonce = tx.get_origin_nonce();
+        let sponsor_addr = tx.sponsor_address().unwrap_or(origin_addr.clone());
+        let sponsor_nonce = tx.get_sponsor_nonce().unwrap_or(origin_nonce);
+        let tx_fee = tx.get_tx_fee();
+
+        total_len += tx_bytes.len();
+
+        // should succeed
+        MemPoolDB::try_add_tx(
+            &mut mempool_tx,
+            &mut chainstate,
+            &b_2.0,
+            &b_2.1,
+            txid.clone(),
+            tx_bytes,
+            tx_fee,
+            block_height as u64,
+            &origin_addr,
+            origin_nonce,
+            &sponsor_addr,
+            sponsor_nonce,
+            None,
+        )
+        .unwrap();
+
+        eprintln!("Added {} {}", i, &txid);
+        txs.push(tx);
+    }
+    mempool_tx.commit().unwrap();
+
+    let mut mempool_settings = MemPoolWalkSettings::default();
+    let mut tx_events = Vec::new();
+    mempool_settings.txs_to_consider = [
+        MemPoolWalkTxTypes::SmartContract,
+        MemPoolWalkTxTypes::ContractCall,
+    ]
+    .into_iter()
+    .collect();
+
+    chainstate.with_read_only_clarity_tx(
+        &TEST_BURN_STATE_DB,
+        &StacksBlockHeader::make_index_block_hash(&b_2.0, &b_2.1),
+        |clarity_conn| {
+            let mut count_txs = 0;
+            mempool
+                .iterate_candidates::<_, ChainstateError, _>(
+                    clarity_conn,
+                    &mut tx_events,
+                    2,
+                    mempool_settings.clone(),
+                    |_, available_tx, _| {
+                        count_txs += 1;
+                        Ok(Some(
+                            // Generate any success result
+                            TransactionResult::success(
+                                &available_tx.tx.tx,
+                                available_tx.tx.metadata.tx_fee,
+                                StacksTransactionReceipt::from_stx_transfer(
+                                    available_tx.tx.tx.clone(),
+                                    vec![],
+                                    Value::okay(Value::Bool(true)).unwrap(),
+                                    ExecutionCost::zero(),
+                                ),
+                            )
+                            .convert_to_event(),
+                        ))
+                    },
+                )
+                .unwrap();
+            assert_eq!(count_txs, 0);
+        },
+    );
+
+    mempool_settings.txs_to_consider = [MemPoolWalkTxTypes::TokenTransfer].into_iter().collect();
+
+    chainstate.with_read_only_clarity_tx(
+        &TEST_BURN_STATE_DB,
+        &StacksBlockHeader::make_index_block_hash(&b_2.0, &b_2.1),
+        |clarity_conn| {
+            let mut count_txs = 0;
+            mempool
+                .iterate_candidates::<_, ChainstateError, _>(
+                    clarity_conn,
+                    &mut tx_events,
+                    2,
+                    mempool_settings.clone(),
+                    |_, available_tx, _| {
+                        count_txs += 1;
+                        Ok(Some(
+                            // Generate any success result
+                            TransactionResult::success(
+                                &available_tx.tx.tx,
+                                available_tx.tx.metadata.tx_fee,
+                                StacksTransactionReceipt::from_stx_transfer(
+                                    available_tx.tx.tx.clone(),
+                                    vec![],
+                                    Value::okay(Value::Bool(true)).unwrap(),
+                                    ExecutionCost::zero(),
+                                ),
+                            )
+                            .convert_to_event(),
+                        ))
+                    },
+                )
+                .unwrap();
+            assert_eq!(count_txs, 10);
+        },
+    );
+}
diff --git a/src/cost_estimates/fee_scalar.rs b/src/cost_estimates/fee_scalar.rs
index ca252940cb..0e19b7a66b 100644
--- a/src/cost_estimates/fee_scalar.rs
+++ b/src/cost_estimates/fee_scalar.rs
@@ -16,6 +16,9 @@ use crate::util_lib::db::u64_to_sql;
 
 use clarity::vm::costs::ExecutionCost;
 
+use clarity::vm::database::ClaritySerializable;
+use clarity::vm::database::STXBalance;
+
 use crate::chainstate::stacks::db::StacksEpochReceipt;
 use crate::chainstate::stacks::events::TransactionOrigin;
 
@@ -170,7 +173,25 @@ impl<M: CostMetric> FeeEstimator for ScalarFeeRateEstimator<M> {
                 let scalar_cost = match payload {
                     TransactionPayload::TokenTransfer(_, _, _) => {
                         // TokenTransfers *only* contribute tx_len, and just have an empty ExecutionCost.
-                        self.metric.from_len(tx_size)
+                        let stx_balance_len = STXBalance::LockedPoxThree {
+                            amount_unlocked: 1,
+                            amount_locked: 1,
+                            unlock_height: 1,
+                        }
+                        .serialize()
+                        .as_bytes()
+                        .len() as u64;
+                        self.metric.from_cost_and_len(
+                            &ExecutionCost {
+                                write_length: stx_balance_len,
+                                write_count: 1,
+                                read_length: 2 * stx_balance_len,
+                                read_count: 2,
+                                runtime: 4640, // taken from .costs-3
+                            },
+                            &block_limit,
+                            tx_size,
+                        )
                     }
                     TransactionPayload::Coinbase(..) => {
                         // Coinbase txs are "free", so they don't factor into the fee market.
diff --git a/src/main.rs b/src/main.rs
index 10ea712cbe..6e92a7296c 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -770,7 +770,6 @@ simulating a miner.
 
         let mut settings = BlockBuilderSettings::limited();
         settings.max_miner_time_ms = max_time;
-        settings.mempool_settings.min_tx_fee = min_fee;
 
         let result = StacksBlockBuilder::build_anchored_block(
             &chain_state,
diff --git a/testnet/stacks-node/Cargo.toml b/testnet/stacks-node/Cargo.toml
index c36a27fb93..043d929c84 100644
--- a/testnet/stacks-node/Cargo.toml
+++ b/testnet/stacks-node/Cargo.toml
@@ -8,7 +8,7 @@ rust-version = "1.61"
 
 [dependencies]
 lazy_static = "1.4.0"
-pico-args = "0.3.1"
+pico-args = "0.5.0"
 rand = "0.7.3"
 serde = "1"
 serde_derive = "1"
@@ -21,7 +21,7 @@ async-std = { version = "1.6", features = ["attributes"] }
 http-types = "2.12"
 base64 = "0.12.0"
 backtrace = "0.3.50"
-libc = "0.2"
+libc = "0.2.151"
 slog = { version = "2.5.2", features = [ "max_level_trace" ] }
 clarity = { package = "clarity", path = "../../clarity/." }
 stacks_common = { package = "stacks-common", path = "../../stacks-common/." }
diff --git a/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs b/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
index 8b23d48c1f..86521e9ced 100644
--- a/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
+++ b/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
@@ -162,6 +162,18 @@ pub fn make_bitcoin_indexer(config: &Config) -> BitcoinIndexer {
     burnchain_indexer
 }
 
+pub fn get_satoshis_per_byte(config: &Config) -> u64 {
+    config.get_burnchain_config().satoshis_per_byte
+}
+
+pub fn get_rbf_fee_increment(config: &Config) -> u64 {
+    config.get_burnchain_config().rbf_fee_increment
+}
+
+pub fn get_max_rbf(config: &Config) -> u64 {
+    config.get_burnchain_config().max_rbf
+}
+
 impl LeaderBlockCommitFees {
     pub fn fees_from_previous_tx(
         &self,
@@ -171,7 +183,7 @@ impl LeaderBlockCommitFees {
         let mut fees = LeaderBlockCommitFees::estimated_fees_from_payload(payload, config);
         fees.spent_in_attempts = cmp::max(1, self.spent_in_attempts);
         fees.final_size = self.final_size;
-        fees.fee_rate = self.fee_rate + config.burnchain.rbf_fee_increment;
+        fees.fee_rate = self.fee_rate + get_rbf_fee_increment(&config);
         fees.is_rbf_enabled = true;
         fees
     }
@@ -190,7 +202,7 @@ impl LeaderBlockCommitFees {
         let value_per_transfer = payload.burn_fee / number_of_transfers;
         let sortition_fee = value_per_transfer * number_of_transfers;
         let spent_in_attempts = 0;
-        let fee_rate = config.burnchain.satoshis_per_byte;
+        let fee_rate = get_satoshis_per_byte(&config);
         let default_tx_size = config.burnchain.block_commit_tx_estimated_size;
 
         LeaderBlockCommitFees {
@@ -802,8 +814,9 @@ impl BitcoinRegtestController {
     ) -> Option<Transaction> {
         let public_key = signer.get_public_key();
 
+        // reload the config to find satoshis_per_byte changes
         let btc_miner_fee = self.config.burnchain.leader_key_tx_estimated_size
-            * self.config.burnchain.satoshis_per_byte;
+            * get_satoshis_per_byte(&self.config);
         let budget_for_outputs = DUST_UTXO_LIMIT;
         let total_required = btc_miner_fee + budget_for_outputs;
 
@@ -831,7 +844,7 @@ impl BitcoinRegtestController {
 
         tx.output = vec![consensus_output];
 
-        let fee_rate = self.config.burnchain.satoshis_per_byte;
+        let fee_rate = get_satoshis_per_byte(&self.config);
 
         self.finalize_tx(
             epoch_id,
@@ -925,7 +938,6 @@ impl BitcoinRegtestController {
     ) -> Option<Transaction> {
         let public_key = signer.get_public_key();
         let max_tx_size = 230;
-
         let (mut tx, mut utxos) = if let Some(utxo) = utxo_to_use {
             (
                 Transaction {
@@ -943,7 +955,7 @@ impl BitcoinRegtestController {
             self.prepare_tx(
                 epoch_id,
                 &public_key,
-                DUST_UTXO_LIMIT + max_tx_size * self.config.burnchain.satoshis_per_byte,
+                DUST_UTXO_LIMIT + max_tx_size * get_satoshis_per_byte(&self.config),
                 None,
                 None,
                 0,
@@ -977,7 +989,7 @@ impl BitcoinRegtestController {
             DUST_UTXO_LIMIT,
             0,
             max_tx_size,
-            self.config.burnchain.satoshis_per_byte,
+            get_satoshis_per_byte(&self.config),
             &mut utxos,
             signer,
         )?;
@@ -1026,7 +1038,7 @@ impl BitcoinRegtestController {
             self.prepare_tx(
                 epoch_id,
                 &public_key,
-                DUST_UTXO_LIMIT + max_tx_size * self.config.burnchain.satoshis_per_byte,
+                DUST_UTXO_LIMIT + max_tx_size * get_satoshis_per_byte(&self.config),
                 None,
                 None,
                 0,
@@ -1060,7 +1072,7 @@ impl BitcoinRegtestController {
             DUST_UTXO_LIMIT,
             0,
             max_tx_size,
-            self.config.burnchain.satoshis_per_byte,
+            get_satoshis_per_byte(&self.config),
             &mut utxos,
             signer,
         )?;
@@ -1095,7 +1107,7 @@ impl BitcoinRegtestController {
         let public_key = signer.get_public_key();
         let max_tx_size = 280;
 
-        let output_amt = DUST_UTXO_LIMIT + max_tx_size * self.config.burnchain.satoshis_per_byte;
+        let output_amt = DUST_UTXO_LIMIT + max_tx_size * get_satoshis_per_byte(&self.config);
         let (mut tx, mut utxos) =
             self.prepare_tx(epoch_id, &public_key, output_amt, None, None, 0)?;
 
@@ -1124,7 +1136,7 @@ impl BitcoinRegtestController {
             output_amt,
             0,
             max_tx_size,
-            self.config.burnchain.satoshis_per_byte,
+            get_satoshis_per_byte(&self.config),
             &mut utxos,
             signer,
         )?;
@@ -1322,11 +1334,11 @@ impl BitcoinRegtestController {
 
         // Stop as soon as the fee_rate is ${self.config.burnchain.max_rbf} percent higher, stop RBF
         if ongoing_op.fees.fee_rate
-            > (self.config.burnchain.satoshis_per_byte * self.config.burnchain.max_rbf / 100)
+            > (get_satoshis_per_byte(&self.config) * get_max_rbf(&self.config) / 100)
         {
             warn!(
                 "RBF'd block commits reached {}% satoshi per byte fee rate, not resubmitting",
-                self.config.burnchain.max_rbf
+                get_max_rbf(&self.config)
             );
             self.ongoing_block_commit = Some(ongoing_op);
             return None;
@@ -2489,3 +2501,31 @@ impl BitcoinRPCRequest {
         Ok(payload)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::config::DEFAULT_SATS_PER_VB;
+
+    use super::*;
+    use std::env::temp_dir;
+    use std::fs::File;
+    use std::io::Write;
+
+    #[test]
+    fn test_get_satoshis_per_byte() {
+        let dir = temp_dir();
+        let file_path = dir.as_path().join("config.toml");
+
+        let mut config = Config::default();
+
+        let satoshis_per_byte = get_satoshis_per_byte(&config);
+        assert_eq!(satoshis_per_byte, DEFAULT_SATS_PER_VB);
+
+        let mut file = File::create(&file_path).unwrap();
+        writeln!(file, "[burnchain]").unwrap();
+        writeln!(file, "satoshis_per_byte = 51").unwrap();
+        config.config_path = Some(file_path.to_str().unwrap().to_string());
+
+        assert_eq!(get_satoshis_per_byte(&config), 51);
+    }
+}
diff --git a/testnet/stacks-node/src/chain_data.rs b/testnet/stacks-node/src/chain_data.rs
new file mode 100644
index 0000000000..92b22a5a6c
--- /dev/null
+++ b/testnet/stacks-node/src/chain_data.rs
@@ -0,0 +1,1105 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020-2023 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+use std::collections::HashMap;
+use std::process::Command;
+use std::process::Stdio;
+
+use stacks::chainstate::burn::db::sortdb::SortitionDB;
+use stacks::chainstate::burn::db::sortdb::SortitionHandle;
+use stacks::chainstate::burn::distribution::BurnSamplePoint;
+use stacks::chainstate::burn::operations::leader_block_commit::{
+    MissedBlockCommit, BURN_BLOCK_MINED_AT_MODULUS,
+};
+use stacks::chainstate::burn::operations::LeaderBlockCommitOp;
+use stacks::chainstate::stacks::address::PoxAddress;
+
+use stacks::burnchains::bitcoin::address::BitcoinAddress;
+use stacks::burnchains::bitcoin::BitcoinNetworkType;
+use stacks::burnchains::bitcoin::BitcoinTxOutput;
+use stacks::burnchains::Burnchain;
+use stacks::burnchains::BurnchainSigner;
+use stacks::burnchains::Txid;
+use stacks_common::types::chainstate::BlockHeaderHash;
+use stacks_common::types::chainstate::BurnchainHeaderHash;
+use stacks_common::types::chainstate::VRFSeed;
+use stacks_common::util::hash::hex_bytes;
+
+use stacks::core::MINING_COMMITMENT_WINDOW;
+
+use stacks::util_lib::db::Error as DBError;
+
+use stacks::burnchains::Error as BurnchainError;
+
+pub struct MinerStats {
+    pub unconfirmed_commits_helper: String,
+}
+
+/// Unconfirmed block-commit transaction as emitted by our helper
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+struct UnconfirmedBlockCommit {
+    /// burnchain signer
+    address: String,
+    /// PoX payouts
+    pox_addrs: Vec<String>,
+    /// UTXO spent to create this block-commit
+    input_vout: u32,
+    input_txid: String,
+    /// transaction ID
+    txid: String,
+    /// amount spent
+    burn: u64,
+}
+
+const DEADBEEF: [u8; 32] = [
+    0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef,
+    0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef,
+];
+
+impl MinerStats {
+    /// Find the burn distribution for a single sortition's block-commits and missed-commits
+    fn get_burn_distribution<SH: SortitionHandle>(
+        sort_handle: &mut SH,
+        burnchain: &Burnchain,
+        burn_block_height: u64,
+        block_commits: Vec<LeaderBlockCommitOp>,
+        missed_commits: Vec<MissedBlockCommit>,
+    ) -> Result<Vec<BurnSamplePoint>, BurnchainError> {
+        // assemble the commit windows
+        let mut windowed_block_commits = vec![block_commits];
+        let mut windowed_missed_commits = vec![];
+
+        if !burnchain.is_in_prepare_phase(burn_block_height) {
+            // PoX reward-phase is active!
+            // build a map of intended sortition -> missed commit for the missed commits
+            //   discovered in this block.
+            let mut missed_commits_map: HashMap<_, Vec<_>> = HashMap::new();
+            for missed in missed_commits.iter() {
+                if let Some(commits_at_sortition) =
+                    missed_commits_map.get_mut(&missed.intended_sortition)
+                {
+                    commits_at_sortition.push(missed);
+                } else {
+                    missed_commits_map.insert(missed.intended_sortition.clone(), vec![missed]);
+                }
+            }
+
+            for blocks_back in 0..(MINING_COMMITMENT_WINDOW - 1) {
+                if burn_block_height.saturating_sub(1) < (blocks_back as u64) {
+                    debug!("Mining commitment window shortened because block height is less than window size";
+                           "block_height" => %burn_block_height.saturating_sub(1),
+                           "window_size" => %MINING_COMMITMENT_WINDOW);
+                    break;
+                }
+                let block_height = (burn_block_height.saturating_sub(1)) - (blocks_back as u64);
+                let sortition_id = match sort_handle.get_block_snapshot_by_height(block_height)? {
+                    Some(sn) => sn.sortition_id,
+                    None => break,
+                };
+                windowed_block_commits.push(SortitionDB::get_block_commits_by_block(
+                    sort_handle.sqlite(),
+                    &sortition_id,
+                )?);
+                let mut missed_commits_at_height = SortitionDB::get_missed_commits_by_intended(
+                    sort_handle.sqlite(),
+                    &sortition_id,
+                )?;
+                if let Some(missed_commit_in_block) = missed_commits_map.remove(&sortition_id) {
+                    missed_commits_at_height
+                        .extend(missed_commit_in_block.into_iter().map(|x| x.clone()));
+                }
+
+                windowed_missed_commits.push(missed_commits_at_height);
+            }
+        } else {
+            // PoX reward-phase is not active
+            debug!(
+                "Block {} is in a prepare phase or post-PoX sunset, so no windowing will take place",
+                burn_block_height;
+            );
+
+            assert_eq!(windowed_block_commits.len(), 1);
+            assert_eq!(windowed_missed_commits.len(), 0);
+        }
+
+        // reverse vecs so that windows are in ascending block height order
+        windowed_block_commits.reverse();
+        windowed_missed_commits.reverse();
+
+        // figure out if the PoX sunset finished during the window,
+        // and/or which sortitions must be PoB due to them falling in a prepare phase.
+        let window_end_height = burn_block_height;
+        let window_start_height = window_end_height + 1 - (windowed_block_commits.len() as u64);
+        let mut burn_blocks = vec![false; windowed_block_commits.len()];
+
+        // set burn_blocks flags to accomodate prepare phases and PoX sunset
+        for (i, b) in burn_blocks.iter_mut().enumerate() {
+            if burnchain.is_in_prepare_phase(window_start_height + (i as u64)) {
+                // must burn
+                *b = true;
+            } else {
+                // must not burn
+                *b = false;
+            }
+        }
+
+        // not all commits in windowed_block_commits have been confirmed, so make sure that they
+        // are in the right order
+        let mut block_height_at_index = None;
+        for (index, commits) in windowed_block_commits.iter_mut().enumerate() {
+            let index = index as u64;
+            for commit in commits.iter_mut() {
+                if let Some((first_block_height, first_index)) = block_height_at_index {
+                    if commit.block_height != first_block_height + (index - first_index) {
+                        commit.block_height = first_block_height + (index - first_index);
+                    }
+                } else {
+                    block_height_at_index = Some((commit.block_height, index));
+                }
+            }
+        }
+
+        // calculate the burn distribution from these operations.
+        // The resulting distribution will contain the user burns that match block commits
+        let burn_dist = BurnSamplePoint::make_min_median_distribution(
+            windowed_block_commits,
+            windowed_missed_commits,
+            burn_blocks,
+        );
+
+        Ok(burn_dist)
+    }
+
+    fn fmt_bin_args(bin: &str, args: &[&str]) -> String {
+        let mut all = Vec::with_capacity(1 + args.len());
+        all.push(bin);
+        for arg in args {
+            all.push(arg);
+        }
+        all.join(" ")
+    }
+
+    /// Returns (exit code, stdout, stderr)
+    fn run_subprocess(
+        bin_fullpath: &str,
+        args: &[&str],
+    ) -> Result<(i32, Vec<u8>, Vec<u8>), String> {
+        let full_args = Self::fmt_bin_args(bin_fullpath, args);
+        let mut cmd = Command::new(bin_fullpath);
+        cmd.stdin(Stdio::piped())
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped())
+            .args(args);
+
+        debug!("Run: `{:?}`", &cmd);
+
+        let output = cmd
+            .spawn()
+            .map_err(|e| format!("Failed to run `{}`: {:?}", &full_args, &e))?
+            .wait_with_output()
+            .map_err(|ioe| format!("Failed to run `{}`: {:?}", &full_args, &ioe))?;
+
+        let exit_code = match output.status.code() {
+            Some(code) => code,
+            None => {
+                // failed due to signal
+                return Err(format!("Failed to run `{}`: killed by signal", &full_args));
+            }
+        };
+
+        Ok((exit_code, output.stdout, output.stderr))
+    }
+
+    /// Get the list of all unconfirmed block-commits.
+    pub fn get_unconfirmed_commits(
+        &self,
+        next_block_height: u64,
+        all_miners: &[&str],
+    ) -> Result<Vec<LeaderBlockCommitOp>, String> {
+        let (exit_code, stdout, _stderr) =
+            Self::run_subprocess(&self.unconfirmed_commits_helper, &all_miners)?;
+        if exit_code != 0 {
+            return Err(format!(
+                "Failed to run `{}`: exit code {}",
+                &self.unconfirmed_commits_helper, exit_code
+            ));
+        }
+
+        // decode stdout to JSON
+        let unconfirmed_commits: Vec<UnconfirmedBlockCommit> = serde_json::from_slice(&stdout)
+            .map_err(|e| {
+                format!(
+                    "Failed to decode output from `{}`: {:?}. Output was `{}`",
+                    &self.unconfirmed_commits_helper,
+                    &e,
+                    String::from_utf8_lossy(&stdout)
+                )
+            })?;
+
+        let mut unconfirmed_spends = vec![];
+        for unconfirmed_commit in unconfirmed_commits.into_iter() {
+            let Ok(txid) = Txid::from_hex(&unconfirmed_commit.txid) else {
+                return Err(format!("Not a valid txid: `{}`", &unconfirmed_commit.txid));
+            };
+            let Ok(input_txid) = Txid::from_hex(&unconfirmed_commit.input_txid) else {
+                return Err(format!(
+                    "Not a valid txid: `{}`",
+                    &unconfirmed_commit.input_txid
+                ));
+            };
+            let mut decoded_pox_addrs = vec![];
+            for pox_addr_hex in unconfirmed_commit.pox_addrs.iter() {
+                let Ok(pox_addr_bytes) = hex_bytes(&pox_addr_hex) else {
+                    return Err(format!("Not a hex string: `{}`", &pox_addr_hex));
+                };
+                let Some(bitcoin_addr) =
+                    BitcoinAddress::from_scriptpubkey(BitcoinNetworkType::Mainnet, &pox_addr_bytes)
+                else {
+                    return Err(format!(
+                        "Not a recognized Bitcoin scriptpubkey: {}",
+                        &pox_addr_hex
+                    ));
+                };
+                let Some(pox_addr) = PoxAddress::try_from_bitcoin_output(&BitcoinTxOutput {
+                    address: bitcoin_addr.clone(),
+                    units: 1,
+                }) else {
+                    return Err(format!("Not a recognized PoX address: {}", &bitcoin_addr));
+                };
+                decoded_pox_addrs.push(pox_addr);
+            }
+
+            // mocked commit
+            let mocked_commit = LeaderBlockCommitOp {
+                sunset_burn: 0,
+                block_header_hash: BlockHeaderHash(DEADBEEF.clone()),
+                new_seed: VRFSeed(DEADBEEF.clone()),
+                parent_block_ptr: 1,
+                parent_vtxindex: 1,
+                key_block_ptr: 1,
+                key_vtxindex: 1,
+                memo: vec![],
+                commit_outs: decoded_pox_addrs,
+                burn_fee: unconfirmed_commit.burn,
+                input: (input_txid, unconfirmed_commit.input_vout),
+                apparent_sender: BurnchainSigner(unconfirmed_commit.address),
+                txid,
+                vtxindex: 1,
+                block_height: next_block_height,
+                burn_parent_modulus: ((next_block_height.saturating_sub(1))
+                    % BURN_BLOCK_MINED_AT_MODULUS) as u8,
+                burn_header_hash: BurnchainHeaderHash(DEADBEEF.clone()),
+            };
+
+            unconfirmed_spends.push(mocked_commit);
+        }
+        Ok(unconfirmed_spends)
+    }
+
+    /// Convert a list of burn sample points into a probability distribution by candidate's
+    /// apparent sender (e.g. miner address).
+    pub fn burn_dist_to_prob_dist(burn_dist: &[BurnSamplePoint]) -> HashMap<String, f64> {
+        if burn_dist.len() == 0 {
+            return HashMap::new();
+        }
+        if burn_dist.len() == 1 {
+            let mut ret = HashMap::new();
+            ret.insert(burn_dist[0].candidate.apparent_sender.to_string(), 1.0);
+            return ret;
+        }
+
+        let mut ret = HashMap::new();
+        for pt in burn_dist.iter() {
+            // take the upper 32 bits
+            let range_lower_64 = (pt.range_end - pt.range_start) >> 192;
+            let int_prob = (range_lower_64.low_u64() >> 32) as u32;
+
+            ret.insert(
+                pt.candidate.apparent_sender.to_string(),
+                (int_prob as f64) / (u32::MAX as f64),
+            );
+        }
+
+        ret
+    }
+
+    /// Get the spend distribution and total spend.
+    /// If the miner has both a confirmed and unconfirmed spend, then take the latter.
+    pub fn get_spend_distribution(
+        active_miners_and_commits: &[(String, LeaderBlockCommitOp)],
+        unconfirmed_block_commits: &[LeaderBlockCommitOp],
+        expected_pox_addrs: &[PoxAddress],
+    ) -> (HashMap<String, u64>, u64) {
+        let unconfirmed_block_commits: Vec<_> = unconfirmed_block_commits
+            .iter()
+            .filter(|commit| {
+                if commit.commit_outs.len() != expected_pox_addrs.len() {
+                    return false;
+                }
+                for i in 0..commit.commit_outs.len() {
+                    if commit.commit_outs[i].to_burnchain_repr()
+                        != expected_pox_addrs[i].to_burnchain_repr()
+                    {
+                        info!(
+                            "Skipping invalid unconfirmed block-commit: {:?} != {:?}",
+                            &commit.commit_outs[i].to_burnchain_repr(),
+                            expected_pox_addrs[i].to_burnchain_repr()
+                        );
+                        return false;
+                    }
+                }
+                true
+            })
+            .collect();
+
+        let mut total_spend = 0;
+        let mut dist = HashMap::new();
+        for commit in unconfirmed_block_commits {
+            let addr = commit.apparent_sender.to_string();
+            dist.insert(addr, commit.burn_fee);
+        }
+
+        for (_, commit) in active_miners_and_commits.iter() {
+            let addr = commit.apparent_sender.to_string();
+            if dist.contains_key(&addr) {
+                continue;
+            }
+            dist.insert(addr, commit.burn_fee);
+        }
+
+        for (_, spend) in dist.iter() {
+            total_spend += *spend;
+        }
+
+        (dist, total_spend)
+    }
+
+    /// Get the probability distribution for the Bitcoin block 6+ blocks in the future, assuming
+    /// all block-commit spends remain the same.
+    pub fn get_future_win_distribution(
+        active_miners_and_commits: &[(String, LeaderBlockCommitOp)],
+        unconfirmed_block_commits: &[LeaderBlockCommitOp],
+        expected_pox_addrs: &[PoxAddress],
+    ) -> HashMap<String, f64> {
+        let (dist, total_spend) = Self::get_spend_distribution(
+            active_miners_and_commits,
+            unconfirmed_block_commits,
+            &expected_pox_addrs,
+        );
+
+        let mut probs = HashMap::new();
+        for (addr, spend) in dist.into_iter() {
+            if total_spend == 0 {
+                probs.insert(addr, 0.0);
+            } else {
+                probs.insert(addr, (spend as f64) / (total_spend as f64));
+            }
+        }
+        probs
+    }
+
+    /// Get the burn distribution for the _next_ Bitcoin block, assuming that the given list of
+    /// block-commit data will get mined.  For miners that are known to the system but who do not
+    /// have unconfirmed block-commits, infer that they'll just mine the same block-commit value
+    /// again.
+    pub fn get_unconfirmed_burn_distribution(
+        &self,
+        burnchain: &Burnchain,
+        sortdb: &SortitionDB,
+        active_miners_and_commits: &[(String, LeaderBlockCommitOp)],
+        unconfirmed_block_commits: Vec<LeaderBlockCommitOp>,
+        expected_pox_addrs: &[PoxAddress],
+        at_block: Option<u64>,
+    ) -> Result<Vec<BurnSamplePoint>, BurnchainError> {
+        let mut commit_table = HashMap::new();
+        for commit in unconfirmed_block_commits.iter() {
+            commit_table.insert(commit.apparent_sender.to_string(), commit.clone());
+        }
+
+        let tip = if let Some(at_block) = at_block {
+            let tip = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn())?;
+            let ih = sortdb.index_handle(&tip.sortition_id);
+            ih.get_block_snapshot_by_height(at_block)?
+                .ok_or(BurnchainError::MissingParentBlock)?
+        } else {
+            SortitionDB::get_canonical_burn_chain_tip(sortdb.conn())?
+        };
+
+        let next_block_height = tip.block_height + 1;
+        let expected_input_index = if burnchain.is_in_prepare_phase(tip.block_height) {
+            LeaderBlockCommitOp::expected_chained_utxo(true)
+        } else {
+            LeaderBlockCommitOp::expected_chained_utxo(false)
+        };
+
+        for (miner, last_commit) in active_miners_and_commits.iter() {
+            if !commit_table.contains_key(miner) {
+                let mocked_commit = LeaderBlockCommitOp {
+                    sunset_burn: 0,
+                    block_header_hash: BlockHeaderHash(DEADBEEF.clone()),
+                    new_seed: VRFSeed(DEADBEEF.clone()),
+                    parent_block_ptr: 2,
+                    parent_vtxindex: 2,
+                    key_block_ptr: 2,
+                    key_vtxindex: 2,
+                    memo: vec![],
+                    commit_outs: expected_pox_addrs.to_vec(),
+                    burn_fee: last_commit.burn_fee,
+                    input: (last_commit.txid, expected_input_index),
+                    apparent_sender: last_commit.apparent_sender.clone(),
+                    txid: Txid(DEADBEEF.clone()),
+                    vtxindex: 1,
+                    block_height: next_block_height,
+                    burn_parent_modulus: ((next_block_height.saturating_sub(1))
+                        % BURN_BLOCK_MINED_AT_MODULUS)
+                        as u8,
+                    burn_header_hash: BurnchainHeaderHash(DEADBEEF.clone()),
+                };
+                commit_table.insert(miner.to_string(), mocked_commit);
+            }
+        }
+
+        let unconfirmed_block_commits: Vec<_> = commit_table
+            .into_values()
+            .filter(|commit| {
+                if commit.commit_outs.len() != expected_pox_addrs.len() {
+                    return false;
+                }
+                for i in 0..commit.commit_outs.len() {
+                    if commit.commit_outs[i].to_burnchain_repr()
+                        != expected_pox_addrs[i].to_burnchain_repr()
+                    {
+                        info!(
+                            "Skipping invalid unconfirmed block-commit: {:?} != {:?}",
+                            &commit.commit_outs[i].to_burnchain_repr(),
+                            expected_pox_addrs[i].to_burnchain_repr()
+                        );
+                        return false;
+                    }
+                }
+                true
+            })
+            .collect();
+
+        let mut handle = sortdb.index_handle(&tip.sortition_id);
+        Self::get_burn_distribution(
+            &mut handle,
+            burnchain,
+            tip.block_height + 1,
+            unconfirmed_block_commits,
+            vec![],
+        )
+    }
+
+    /// Given the sortition DB, get the list of all miners in the past MINING_COMMITMENT_WINDOW
+    /// blocks, as well as their last block-commits
+    pub fn get_active_miners(
+        sortdb: &SortitionDB,
+        at_burn_block: Option<u64>,
+    ) -> Result<Vec<(String, LeaderBlockCommitOp)>, DBError> {
+        let mut tip = if let Some(at_burn_block) = at_burn_block {
+            let tip = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn())?;
+            let ih = sortdb.index_handle(&tip.sortition_id);
+            ih.get_block_snapshot_by_height(at_burn_block)?
+                .ok_or(DBError::NotFoundError)?
+        } else {
+            SortitionDB::get_canonical_burn_chain_tip(sortdb.conn())?
+        };
+
+        let mut miners = HashMap::new();
+        for _i in 0..MINING_COMMITMENT_WINDOW {
+            let commits =
+                SortitionDB::get_block_commits_by_block(sortdb.conn(), &tip.sortition_id)?;
+            for commit in commits.into_iter() {
+                let miner = commit.apparent_sender.to_string();
+                if miners.get(&miner).is_none() {
+                    miners.insert(miner, commit);
+                }
+            }
+            tip = SortitionDB::get_block_snapshot(sortdb.conn(), &tip.parent_sortition_id)?
+                .ok_or(DBError::NotFoundError)?;
+        }
+        Ok(miners.into_iter().collect())
+    }
+}
+
+#[cfg(test)]
+pub mod tests {
+    use super::MinerStats;
+    use stacks::burnchains::BurnchainSigner;
+    use stacks::burnchains::Txid;
+    use stacks::chainstate::burn::distribution::BurnSamplePoint;
+    use stacks::chainstate::burn::operations::leader_block_commit::BURN_BLOCK_MINED_AT_MODULUS;
+    use stacks::chainstate::burn::operations::LeaderBlockCommitOp;
+    use stacks::chainstate::stacks::address::PoxAddress;
+    use stacks::chainstate::stacks::address::PoxAddressType20;
+    use stacks_common::types::chainstate::BlockHeaderHash;
+    use stacks_common::types::chainstate::BurnchainHeaderHash;
+    use stacks_common::types::chainstate::StacksAddress;
+    use stacks_common::types::chainstate::StacksPublicKey;
+    use stacks_common::types::chainstate::VRFSeed;
+    use stacks_common::util::hash::hex_bytes;
+    use stacks_common::util::hash::Hash160;
+    use stacks_common::util::uint::BitArray;
+    use stacks_common::util::uint::Uint256;
+
+    use std::fs;
+    use std::io::Write;
+
+    #[test]
+    fn test_burn_dist_to_prob_dist() {
+        let block_commit_1 = LeaderBlockCommitOp {
+            sunset_burn: 0,
+            block_header_hash: BlockHeaderHash([0x22; 32]),
+            new_seed: VRFSeed([0x33; 32]),
+            parent_block_ptr: 111,
+            parent_vtxindex: 456,
+            key_block_ptr: 123,
+            key_vtxindex: 456,
+            memo: vec![0x80],
+
+            burn_fee: 12345,
+            input: (Txid([0; 32]), 0),
+            apparent_sender: BurnchainSigner::new_p2pkh(
+                &StacksPublicKey::from_hex(
+                    "02d8015134d9db8178ac93acbc43170a2f20febba5087a5b0437058765ad5133d0",
+                )
+                .unwrap(),
+            ),
+
+            commit_outs: vec![],
+
+            txid: Txid::from_bytes_be(
+                &hex_bytes("3c07a0a93360bc85047bbaadd49e30c8af770f73a37e10fec400174d2e5f27cf")
+                    .unwrap(),
+            )
+            .unwrap(),
+            vtxindex: 443,
+            block_height: 124,
+            burn_parent_modulus: (123 % BURN_BLOCK_MINED_AT_MODULUS) as u8,
+            burn_header_hash: BurnchainHeaderHash([0x00; 32]),
+        };
+
+        let block_commit_2 = LeaderBlockCommitOp {
+            sunset_burn: 0,
+            block_header_hash: BlockHeaderHash([0x22; 32]),
+            new_seed: VRFSeed([0x33; 32]),
+            parent_block_ptr: 112,
+            parent_vtxindex: 111,
+            key_block_ptr: 122,
+            key_vtxindex: 457,
+            memo: vec![0x80],
+
+            burn_fee: 12345,
+            input: (Txid([0; 32]), 0),
+            apparent_sender: BurnchainSigner::new_p2pkh(
+                &StacksPublicKey::from_hex(
+                    "023616a344700c9455bf0b55cc65e404c7b8f82e815da885398a44f6dc70e64045",
+                )
+                .unwrap(),
+            ),
+
+            commit_outs: vec![],
+
+            txid: Txid::from_bytes_be(
+                &hex_bytes("3c07a0a93360bc85047bbaadd49e30c8af770f73a37e10fec400174d2e5f27d0")
+                    .unwrap(),
+            )
+            .unwrap(),
+            vtxindex: 444,
+            block_height: 124,
+            burn_parent_modulus: (123 % BURN_BLOCK_MINED_AT_MODULUS) as u8,
+            burn_header_hash: BurnchainHeaderHash::from_hex(
+                "0000000000000000000000000000000000000000000000000000000000000004",
+            )
+            .unwrap(),
+        };
+
+        let block_commit_3 = LeaderBlockCommitOp {
+            sunset_burn: 0,
+            block_header_hash: BlockHeaderHash([0x22; 32]),
+            new_seed: VRFSeed([0x33; 32]),
+            parent_block_ptr: 113,
+            parent_vtxindex: 111,
+            key_block_ptr: 121,
+            key_vtxindex: 10,
+            memo: vec![0x80],
+
+            burn_fee: 23456,
+            input: (Txid([0; 32]), 0),
+            apparent_sender: BurnchainSigner::new_p2pkh(
+                &StacksPublicKey::from_hex(
+                    "020a9b0a938a2226694fe4f867193cf0b78cd6264e4277fd686468a00a9afdc36d",
+                )
+                .unwrap(),
+            ),
+
+            commit_outs: vec![],
+
+            txid: Txid::from_bytes_be(
+                &hex_bytes("301dc687a9f06a1ae87a013f27133e9cec0843c2983567be73e185827c7c13de")
+                    .unwrap(),
+            )
+            .unwrap(),
+            vtxindex: 445,
+            block_height: 124,
+            burn_parent_modulus: (123 % BURN_BLOCK_MINED_AT_MODULUS) as u8,
+            burn_header_hash: BurnchainHeaderHash::from_hex(
+                "0000000000000000000000000000000000000000000000000000000000000004",
+            )
+            .unwrap(),
+        };
+        let burn_dist = vec![
+            BurnSamplePoint {
+                burns: block_commit_1.burn_fee.into(),
+                median_burn: block_commit_2.burn_fee.into(),
+                range_start: Uint256::zero(),
+                range_end: Uint256([
+                    0x3ed94d3cb0a84709,
+                    0x0963dded799a7c1a,
+                    0x70989faf596c8b65,
+                    0x41a3ed94d3cb0a84,
+                ]),
+                candidate: block_commit_1.clone(),
+                user_burns: vec![],
+            },
+            BurnSamplePoint {
+                burns: block_commit_2.burn_fee.into(),
+                median_burn: block_commit_2.burn_fee.into(),
+                range_start: Uint256([
+                    0x3ed94d3cb0a84709,
+                    0x0963dded799a7c1a,
+                    0x70989faf596c8b65,
+                    0x41a3ed94d3cb0a84,
+                ]),
+                range_end: Uint256([
+                    0x7db29a7961508e12,
+                    0x12c7bbdaf334f834,
+                    0xe1313f5eb2d916ca,
+                    0x8347db29a7961508,
+                ]),
+                candidate: block_commit_2.clone(),
+                user_burns: vec![],
+            },
+            BurnSamplePoint {
+                burns: (block_commit_3.burn_fee).into(),
+                median_burn: block_commit_3.burn_fee.into(),
+                range_start: Uint256([
+                    0x7db29a7961508e12,
+                    0x12c7bbdaf334f834,
+                    0xe1313f5eb2d916ca,
+                    0x8347db29a7961508,
+                ]),
+                range_end: Uint256::max(),
+                candidate: block_commit_3.clone(),
+                user_burns: vec![],
+            },
+        ];
+
+        let prob_dist = MinerStats::burn_dist_to_prob_dist(&burn_dist);
+        assert_eq!(prob_dist.len(), 3);
+        assert!(
+            (prob_dist
+                .get(&format!("{}", &block_commit_1.apparent_sender))
+                .unwrap()
+                - 0.25641)
+                .abs()
+                < 0.001
+        );
+        assert!(
+            (prob_dist
+                .get(&format!("{}", &block_commit_2.apparent_sender))
+                .unwrap()
+                - 0.25641)
+                .abs()
+                < 0.001
+        );
+        assert!(
+            (prob_dist
+                .get(&format!("{}", &block_commit_3.apparent_sender))
+                .unwrap()
+                - 0.48718)
+                .abs()
+                < 0.001
+        );
+    }
+
+    #[test]
+    fn test_get_unconfirmed_commits() {
+        use std::os::unix::fs::PermissionsExt;
+        let shell_code = r#"#!/bin/bash
+echo <<EOF '[
+ {
+  "txid": "73c318be8cd272a73200b9630089d77a44342d84b2c0d81c937da714152cf402",
+  "burn": 555000,
+  "address": "1FCcoFSKWvNyhjazNvVdLLw8mGkGdcRMux",
+  "input_txid": "ef0dbf0fc4755de5e94843a4da7c1d943571299afb15f32b76bac5d18d8668ce",
+  "input_index": 3,
+  "pox_addrs": [
+      "0014db14133a9dbb1d0e16b60513453e48b6ff2847a9",
+      "a91418c42080a1e87fd02dd3fca94c4513f9ecfe741487"
+  ]
+ }
+]'
+EOF
+"#;
+        let path = "/tmp/test-get-unconfirmed-commits.sh";
+        if fs::metadata(&path).is_ok() {
+            fs::remove_file(&path).unwrap();
+        }
+        {
+            let mut f = fs::File::create(&path).unwrap();
+            f.write_all(shell_code.as_bytes()).unwrap();
+
+            let md = f.metadata().unwrap();
+            let mut permissions = md.permissions();
+            permissions.set_mode(0o744);
+
+            fs::set_permissions(path, permissions).unwrap();
+            f.sync_all().unwrap();
+        }
+
+        let ms = MinerStats {
+            unconfirmed_commits_helper: path.to_string(),
+        };
+
+        let mut commits = ms.get_unconfirmed_commits(123, &[]).unwrap();
+        assert_eq!(commits.len(), 1);
+        let commit = commits.pop().unwrap();
+
+        assert_eq!(
+            commit.txid,
+            Txid::from_hex("73c318be8cd272a73200b9630089d77a44342d84b2c0d81c937da714152cf402")
+                .unwrap()
+        );
+        assert_eq!(commit.burn_fee, 555000);
+        assert_eq!(
+            commit.apparent_sender.0,
+            "1FCcoFSKWvNyhjazNvVdLLw8mGkGdcRMux".to_string()
+        );
+        assert_eq!(
+            commit.input.0,
+            Txid::from_hex("ef0dbf0fc4755de5e94843a4da7c1d943571299afb15f32b76bac5d18d8668ce")
+                .unwrap()
+        );
+        assert_eq!(commit.input.1, 3);
+        assert_eq!(commit.block_height, 123);
+
+        assert_eq!(
+            commit.commit_outs,
+            vec![
+                PoxAddress::Addr20(
+                    true,
+                    PoxAddressType20::P2WPKH,
+                    [
+                        219, 20, 19, 58, 157, 187, 29, 14, 22, 182, 5, 19, 69, 62, 72, 182, 255,
+                        40, 71, 169
+                    ]
+                ),
+                PoxAddress::Standard(
+                    StacksAddress {
+                        version: 20,
+                        bytes: Hash160([
+                            0x18, 0xc4, 0x20, 0x80, 0xa1, 0xe8, 0x7f, 0xd0, 0x2d, 0xd3, 0xfc, 0xa9,
+                            0x4c, 0x45, 0x13, 0xf9, 0xec, 0xfe, 0x74, 0x14
+                        ])
+                    },
+                    None
+                )
+            ]
+        );
+    }
+
+    #[test]
+    fn test_get_spend_and_win_distribution() {
+        let active_miners_and_commits = vec![
+            (
+                "miner-1".to_string(),
+                LeaderBlockCommitOp {
+                    sunset_burn: 0,
+                    block_header_hash: BlockHeaderHash([0x22; 32]),
+                    new_seed: VRFSeed([0x33; 32]),
+                    parent_block_ptr: 111,
+                    parent_vtxindex: 456,
+                    key_block_ptr: 123,
+                    key_vtxindex: 456,
+                    memo: vec![0x80],
+
+                    burn_fee: 2,
+                    input: (Txid([0; 32]), 0),
+                    apparent_sender: BurnchainSigner("miner-1".into()),
+
+                    commit_outs: vec![],
+
+                    txid: Txid::from_bytes_be(
+                        &hex_bytes(
+                            "3c07a0a93360bc85047bbaadd49e30c8af770f73a37e10fec400174d2e5f27cf",
+                        )
+                        .unwrap(),
+                    )
+                    .unwrap(),
+                    vtxindex: 443,
+                    block_height: 124,
+                    burn_parent_modulus: (123 % BURN_BLOCK_MINED_AT_MODULUS) as u8,
+                    burn_header_hash: BurnchainHeaderHash([0x00; 32]),
+                },
+            ),
+            (
+                "miner-2".to_string(),
+                LeaderBlockCommitOp {
+                    sunset_burn: 0,
+                    block_header_hash: BlockHeaderHash([0x22; 32]),
+                    new_seed: VRFSeed([0x33; 32]),
+                    parent_block_ptr: 112,
+                    parent_vtxindex: 111,
+                    key_block_ptr: 122,
+                    key_vtxindex: 457,
+                    memo: vec![0x80],
+
+                    burn_fee: 3,
+                    input: (Txid([0; 32]), 0),
+                    apparent_sender: BurnchainSigner("miner-2".into()),
+
+                    commit_outs: vec![],
+
+                    txid: Txid::from_bytes_be(
+                        &hex_bytes(
+                            "3c07a0a93360bc85047bbaadd49e30c8af770f73a37e10fec400174d2e5f27d0",
+                        )
+                        .unwrap(),
+                    )
+                    .unwrap(),
+                    vtxindex: 444,
+                    block_height: 124,
+                    burn_parent_modulus: (123 % BURN_BLOCK_MINED_AT_MODULUS) as u8,
+                    burn_header_hash: BurnchainHeaderHash::from_hex(
+                        "0000000000000000000000000000000000000000000000000000000000000004",
+                    )
+                    .unwrap(),
+                },
+            ),
+            (
+                "miner-3".to_string(),
+                LeaderBlockCommitOp {
+                    sunset_burn: 0,
+                    block_header_hash: BlockHeaderHash([0x22; 32]),
+                    new_seed: VRFSeed([0x33; 32]),
+                    parent_block_ptr: 113,
+                    parent_vtxindex: 111,
+                    key_block_ptr: 121,
+                    key_vtxindex: 10,
+                    memo: vec![0x80],
+
+                    burn_fee: 5,
+                    input: (Txid([0; 32]), 0),
+                    apparent_sender: BurnchainSigner("miner-3".into()),
+                    commit_outs: vec![],
+
+                    txid: Txid::from_bytes_be(
+                        &hex_bytes(
+                            "301dc687a9f06a1ae87a013f27133e9cec0843c2983567be73e185827c7c13de",
+                        )
+                        .unwrap(),
+                    )
+                    .unwrap(),
+                    vtxindex: 445,
+                    block_height: 124,
+                    burn_parent_modulus: (123 % BURN_BLOCK_MINED_AT_MODULUS) as u8,
+                    burn_header_hash: BurnchainHeaderHash::from_hex(
+                        "0000000000000000000000000000000000000000000000000000000000000004",
+                    )
+                    .unwrap(),
+                },
+            ),
+        ];
+
+        let unconfirmed_block_commits = vec![
+            LeaderBlockCommitOp {
+                sunset_burn: 0,
+                block_header_hash: BlockHeaderHash([0x22; 32]),
+                new_seed: VRFSeed([0x33; 32]),
+                parent_block_ptr: 124,
+                parent_vtxindex: 456,
+                key_block_ptr: 123,
+                key_vtxindex: 456,
+                memo: vec![0x80],
+
+                burn_fee: 2,
+                input: (Txid([0; 32]), 0),
+                apparent_sender: BurnchainSigner("miner-1".into()),
+
+                commit_outs: vec![],
+
+                txid: Txid::from_bytes_be(
+                    &hex_bytes("3c07a0a93360bc85047bbaadd49e30c8af770f73a37e10fec400174d2e5f27cf")
+                        .unwrap(),
+                )
+                .unwrap(),
+                vtxindex: 443,
+                block_height: 125,
+                burn_parent_modulus: (124 % BURN_BLOCK_MINED_AT_MODULUS) as u8,
+                burn_header_hash: BurnchainHeaderHash([0x01; 32]),
+            },
+            LeaderBlockCommitOp {
+                sunset_burn: 0,
+                block_header_hash: BlockHeaderHash([0x22; 32]),
+                new_seed: VRFSeed([0x33; 32]),
+                parent_block_ptr: 124,
+                parent_vtxindex: 444,
+                key_block_ptr: 123,
+                key_vtxindex: 456,
+                memo: vec![0x80],
+
+                burn_fee: 3,
+                input: (Txid([0; 32]), 0),
+                apparent_sender: BurnchainSigner("miner-2".into()),
+
+                commit_outs: vec![],
+
+                txid: Txid::from_bytes_be(
+                    &hex_bytes("3c07a0a93360bc85047bbaadd49e30c8af770f73a37e10fec400174d2e5f27cf")
+                        .unwrap(),
+                )
+                .unwrap(),
+                vtxindex: 444,
+                block_height: 125,
+                burn_parent_modulus: (124 % BURN_BLOCK_MINED_AT_MODULUS) as u8,
+                burn_header_hash: BurnchainHeaderHash([0x01; 32]),
+            },
+            LeaderBlockCommitOp {
+                sunset_burn: 0,
+                block_header_hash: BlockHeaderHash([0x22; 32]),
+                new_seed: VRFSeed([0x33; 32]),
+                parent_block_ptr: 124,
+                parent_vtxindex: 445,
+                key_block_ptr: 123,
+                key_vtxindex: 456,
+                memo: vec![0x80],
+
+                burn_fee: 10,
+                input: (Txid([0; 32]), 0),
+                apparent_sender: BurnchainSigner("miner-3".into()),
+
+                commit_outs: vec![],
+
+                txid: Txid::from_bytes_be(
+                    &hex_bytes("3c07a0a93360bc85047bbaadd49e30c8af770f73a37e10fec400174d2e5f27cf")
+                        .unwrap(),
+                )
+                .unwrap(),
+                vtxindex: 445,
+                block_height: 125,
+                burn_parent_modulus: (124 % BURN_BLOCK_MINED_AT_MODULUS) as u8,
+                burn_header_hash: BurnchainHeaderHash([0x01; 32]),
+            },
+            LeaderBlockCommitOp {
+                sunset_burn: 0,
+                block_header_hash: BlockHeaderHash([0x22; 32]),
+                new_seed: VRFSeed([0x33; 32]),
+                parent_block_ptr: 124,
+                parent_vtxindex: 445,
+                key_block_ptr: 123,
+                key_vtxindex: 456,
+                memo: vec![0x80],
+
+                burn_fee: 10,
+                input: (Txid([0; 32]), 0),
+                apparent_sender: BurnchainSigner("miner-4".into()),
+
+                commit_outs: vec![],
+
+                txid: Txid::from_bytes_be(
+                    &hex_bytes("3c07a0a93360bc85047bbaadd49e30c8af770f73a37e10fec400174d2e5f27cf")
+                        .unwrap(),
+                )
+                .unwrap(),
+                vtxindex: 446,
+                block_height: 125,
+                burn_parent_modulus: (124 % BURN_BLOCK_MINED_AT_MODULUS) as u8,
+                burn_header_hash: BurnchainHeaderHash([0x01; 32]),
+            },
+        ];
+
+        let (spend_dist, total_spend) = MinerStats::get_spend_distribution(
+            &active_miners_and_commits,
+            &unconfirmed_block_commits,
+            &[],
+        );
+        assert_eq!(total_spend, 2 + 3 + 10 + 10);
+
+        assert_eq!(spend_dist.len(), 4);
+        for miner in &[
+            "miner-1".to_string(),
+            "miner-2".to_string(),
+            "miner-3".to_string(),
+            "miner-4".to_string(),
+        ] {
+            let spend = *spend_dist
+                .get(miner)
+                .expect(&format!("no spend for {}", &miner));
+            match miner.as_str() {
+                "miner-1" => {
+                    assert_eq!(spend, 2);
+                }
+                "miner-2" => {
+                    assert_eq!(spend, 3);
+                }
+                "miner-3" => {
+                    assert_eq!(spend, 10);
+                }
+                "miner-4" => {
+                    assert_eq!(spend, 10);
+                }
+                _ => {
+                    panic!("unknown miner {}", &miner);
+                }
+            }
+        }
+
+        let win_probs = MinerStats::get_future_win_distribution(
+            &active_miners_and_commits,
+            &unconfirmed_block_commits,
+            &[],
+        );
+        for miner in &[
+            "miner-1".to_string(),
+            "miner-2".to_string(),
+            "miner-3".to_string(),
+            "miner-4".to_string(),
+        ] {
+            let prob = *win_probs
+                .get(miner)
+                .expect(&format!("no probability for {}", &miner));
+            match miner.as_str() {
+                "miner-1" => {
+                    assert!((prob - (2.0 / 25.0)).abs() < 0.00001);
+                }
+                "miner-2" => {
+                    assert!((prob - (3.0 / 25.0)).abs() < 0.00001);
+                }
+                "miner-3" => {
+                    assert!((prob - (10.0 / 25.0)).abs() < 0.00001);
+                }
+                "miner-4" => {
+                    assert!((prob - (10.0 / 25.0)).abs() < 0.00001);
+                }
+                _ => {
+                    panic!("unknown miner {}", &miner);
+                }
+            }
+        }
+    }
+}
diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index d2c152478e..5f02936109 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -1,45 +1,42 @@
+use std::collections::HashSet;
 use std::convert::TryInto;
 use std::fs;
 use std::net::{SocketAddr, ToSocketAddrs};
 use std::path::PathBuf;
-use std::sync::Arc;
-use std::sync::Mutex;
+use std::sync::{Arc, Mutex};
 
 use rand::RngCore;
-
 use stacks::burnchains::bitcoin::BitcoinNetworkType;
-use stacks::burnchains::Burnchain;
-use stacks::burnchains::{MagicBytes, BLOCKSTACK_MAGIC_MAINNET};
+use stacks::burnchains::{Burnchain, MagicBytes, BLOCKSTACK_MAGIC_MAINNET};
 use stacks::chainstate::stacks::index::marf::MARFOpenOpts;
 use stacks::chainstate::stacks::index::storage::TrieHashCalculationMode;
-use stacks::chainstate::stacks::miner::BlockBuilderSettings;
-use stacks::chainstate::stacks::miner::MinerStatus;
+use stacks::chainstate::stacks::miner::{BlockBuilderSettings, MinerStatus};
 use stacks::chainstate::stacks::MAX_BLOCK_LEN;
 use stacks::core::mempool::MemPoolWalkSettings;
-use stacks::core::StacksEpoch;
-use stacks::core::StacksEpochExtension;
-use stacks::core::StacksEpochId;
+use stacks::core::mempool::MemPoolWalkTxTypes;
 use stacks::core::{
-    CHAIN_ID_MAINNET, CHAIN_ID_TESTNET, PEER_VERSION_MAINNET, PEER_VERSION_TESTNET,
+    StacksEpoch, StacksEpochExtension, StacksEpochId, CHAIN_ID_MAINNET, CHAIN_ID_TESTNET,
+    PEER_VERSION_MAINNET, PEER_VERSION_TESTNET,
 };
 use stacks::cost_estimates::fee_medians::WeightedMedianFeeRateEstimator;
 use stacks::cost_estimates::fee_rate_fuzzer::FeeRateFuzzer;
 use stacks::cost_estimates::fee_scalar::ScalarFeeRateEstimator;
-use stacks::cost_estimates::metrics::CostMetric;
-use stacks::cost_estimates::metrics::ProportionalDotProduct;
-use stacks::cost_estimates::CostEstimator;
-use stacks::cost_estimates::FeeEstimator;
-use stacks::cost_estimates::PessimisticEstimator;
+use stacks::cost_estimates::metrics::{CostMetric, ProportionalDotProduct};
+use stacks::cost_estimates::{CostEstimator, FeeEstimator, PessimisticEstimator};
 use stacks::net::connection::ConnectionOptions;
 use stacks::net::{Neighbor, NeighborKey, PeerAddress};
 use stacks::util::get_epoch_time_ms;
 use stacks::util::hash::hex_bytes;
-use stacks::util::secp256k1::Secp256k1PrivateKey;
-use stacks::util::secp256k1::Secp256k1PublicKey;
+use stacks::util::secp256k1::{Secp256k1PrivateKey, Secp256k1PublicKey};
 use stacks::vm::costs::ExecutionCost;
 use stacks::vm::types::{AssetIdentifier, PrincipalData, QualifiedContractIdentifier};
 
-const DEFAULT_SATS_PER_VB: u64 = 50;
+use stacks_common::types::chainstate::StacksAddress;
+use stacks_common::types::Address;
+
+use crate::chain_data::MinerStats;
+
+pub const DEFAULT_SATS_PER_VB: u64 = 50;
 const DEFAULT_MAX_RBF_RATE: u64 = 150; // 1.5x
 const DEFAULT_RBF_FEE_RATE_INCREMENT: u64 = 5;
 const LEADER_KEY_TX_ESTIM_SIZE: u64 = 290;
@@ -48,6 +45,7 @@ const INV_REWARD_CYCLES_TESTNET: u64 = 6;
 
 #[derive(Clone, Deserialize, Default, Debug)]
 pub struct ConfigFile {
+    pub __path: Option<String>, // Only used for config file reloads
     pub burnchain: Option<BurnchainConfigFile>,
     pub node: Option<NodeConfigFile>,
     pub ustx_balance: Option<Vec<InitialBalanceFile>>,
@@ -178,7 +176,9 @@ mod tests {
 impl ConfigFile {
     pub fn from_path(path: &str) -> Result<ConfigFile, String> {
         let content = fs::read_to_string(path).map_err(|e| format!("Invalid path: {}", &e))?;
-        Self::from_str(&content)
+        let mut f = Self::from_str(&content)?;
+        f.__path = Some(path.to_string());
+        Ok(f)
     }
 
     pub fn from_str(content: &str) -> Result<ConfigFile, String> {
@@ -353,6 +353,7 @@ impl ConfigFile {
 
 #[derive(Clone, Debug)]
 pub struct Config {
+    pub config_path: Option<String>,
     pub burnchain: BurnchainConfig,
     pub node: NodeConfig,
     pub initial_balances: Vec<InitialBalance>,
@@ -394,6 +395,36 @@ lazy_static! {
 }
 
 impl Config {
+    /// get the up-to-date burnchain options from the config.
+    /// If the config file can't be loaded, then return the existing config
+    pub fn get_burnchain_config(&self) -> BurnchainConfig {
+        let Some(path) = &self.config_path else {
+            return self.burnchain.clone();
+        };
+        let Ok(config_file) = ConfigFile::from_path(path.as_str()) else {
+            return self.burnchain.clone();
+        };
+        let Ok(config) = Config::from_config_file(config_file) else {
+            return self.burnchain.clone();
+        };
+        config.burnchain
+    }
+
+    /// get the up-to-date miner options from the config
+    /// If the config can't be loaded for some reason, then return the existing config
+    pub fn get_miner_config(&self) -> MinerConfig {
+        let Some(path) = &self.config_path else {
+            return self.miner.clone();
+        };
+        let Ok(config_file) = ConfigFile::from_path(path.as_str()) else {
+            return self.miner.clone();
+        };
+        let Ok(config) = Config::from_config_file(config_file) else {
+            return self.miner.clone();
+        };
+        return config.miner;
+    }
+
     /// Apply any test settings to this burnchain config struct
     fn apply_test_settings(&self, burnchain: &mut Burnchain) {
         if self.burnchain.get_bitcoin_network().1 == BitcoinNetworkType::Mainnet {
@@ -881,7 +912,6 @@ impl Config {
         let miner_default_config = MinerConfig::default();
         let miner = match config_file.miner {
             Some(ref miner) => MinerConfig {
-                min_tx_fee: miner.min_tx_fee.unwrap_or(miner_default_config.min_tx_fee),
                 first_attempt_time_ms: miner
                     .first_attempt_time_ms
                     .unwrap_or(miner_default_config.first_attempt_time_ms),
@@ -909,6 +939,52 @@ impl Config {
                 unprocessed_block_deadline_secs: miner
                     .unprocessed_block_deadline_secs
                     .unwrap_or(miner_default_config.unprocessed_block_deadline_secs),
+                min_tx_count: miner.min_tx_count.unwrap_or(0),
+                only_increase_tx_count: miner.only_increase_tx_count.unwrap_or(false),
+                unconfirmed_commits_helper: miner.unconfirmed_commits_helper.clone(),
+                target_win_probability: miner.target_win_probability.unwrap_or(0.0),
+                activated_vrf_key_path: miner.activated_vrf_key_path.clone(),
+                fast_rampup: miner.fast_rampup.unwrap_or(true),
+                underperform_stop_threshold: miner.underperform_stop_threshold,
+                txs_to_consider: {
+                    if let Some(txs_to_consider) = &miner.txs_to_consider {
+                        txs_to_consider
+                            .split(",")
+                            .map(
+                                |txs_to_consider_str| match str::parse(txs_to_consider_str) {
+                                    Ok(txtype) => txtype,
+                                    Err(e) => {
+                                        panic!(
+                                            "could not parse '{}': {}",
+                                            &txs_to_consider_str, &e
+                                        );
+                                    }
+                                },
+                            )
+                            .collect()
+                    } else {
+                        MemPoolWalkTxTypes::all()
+                    }
+                },
+                filter_origins: {
+                    if let Some(filter_origins) = &miner.filter_origins {
+                        filter_origins
+                            .split(",")
+                            .map(|origin_str| match StacksAddress::from_string(origin_str) {
+                                Some(addr) => addr,
+                                None => {
+                                    panic!(
+                                        "could not parse '{}' into a Stacks address",
+                                        origin_str
+                                    );
+                                }
+                            })
+                            .collect()
+                    } else {
+                        HashSet::new()
+                    }
+                },
+                max_reorg_depth: miner.max_reorg_depth.unwrap_or(3),
             },
             None => miner_default_config,
         };
@@ -1148,6 +1224,7 @@ impl Config {
         };
 
         Ok(Config {
+            config_path: config_file.__path,
             node,
             burnchain,
             initial_balances,
@@ -1263,34 +1340,47 @@ impl Config {
         microblocks: bool,
         miner_status: Arc<Mutex<MinerStatus>>,
     ) -> BlockBuilderSettings {
+        let miner_config = self.get_miner_config();
         BlockBuilderSettings {
             max_miner_time_ms: if microblocks {
-                self.miner.microblock_attempt_time_ms
+                miner_config.microblock_attempt_time_ms
             } else if attempt <= 1 {
                 // first attempt to mine a block -- do so right away
-                self.miner.first_attempt_time_ms
+                miner_config.first_attempt_time_ms
             } else {
                 // second or later attempt to mine a block -- give it some time
-                self.miner.subsequent_attempt_time_ms
+                miner_config.subsequent_attempt_time_ms
             },
             mempool_settings: MemPoolWalkSettings {
-                min_tx_fee: self.miner.min_tx_fee,
                 max_walk_time_ms: if microblocks {
-                    self.miner.microblock_attempt_time_ms
+                    miner_config.microblock_attempt_time_ms
                 } else if attempt <= 1 {
                     // first attempt to mine a block -- do so right away
-                    self.miner.first_attempt_time_ms
+                    miner_config.first_attempt_time_ms
                 } else {
                     // second or later attempt to mine a block -- give it some time
-                    self.miner.subsequent_attempt_time_ms
+                    miner_config.subsequent_attempt_time_ms
                 },
-                consider_no_estimate_tx_prob: self.miner.probability_pick_no_estimate_tx,
-                nonce_cache_size: self.miner.nonce_cache_size,
-                candidate_retry_cache_size: self.miner.candidate_retry_cache_size,
+                consider_no_estimate_tx_prob: miner_config.probability_pick_no_estimate_tx,
+                nonce_cache_size: miner_config.nonce_cache_size,
+                candidate_retry_cache_size: miner_config.candidate_retry_cache_size,
+                txs_to_consider: miner_config.txs_to_consider,
+                filter_origins: miner_config.filter_origins,
             },
             miner_status,
         }
     }
+
+    pub fn get_miner_stats(&self) -> Option<MinerStats> {
+        let miner_config = self.get_miner_config();
+        if let Some(unconfirmed_commits_helper) = miner_config.unconfirmed_commits_helper.as_ref() {
+            let miner_stats = MinerStats {
+                unconfirmed_commits_helper: unconfirmed_commits_helper.clone(),
+            };
+            return Some(miner_stats);
+        }
+        None
+    }
 }
 
 impl std::default::Default for Config {
@@ -1308,6 +1398,7 @@ impl std::default::Default for Config {
         let estimation = FeeEstimationConfig::default();
 
         Config {
+            config_path: None,
             burnchain,
             node,
             initial_balances: vec![],
@@ -1874,9 +1965,8 @@ impl NodeConfig {
     }
 }
 
-#[derive(Clone, Debug, Default)]
+#[derive(Clone, Debug, Default, PartialEq)]
 pub struct MinerConfig {
-    pub min_tx_fee: u64,
     pub first_attempt_time_ms: u64,
     pub subsequent_attempt_time_ms: u64,
     pub microblock_attempt_time_ms: u64,
@@ -1890,22 +1980,58 @@ pub struct MinerConfig {
     pub nonce_cache_size: u64,
     pub candidate_retry_cache_size: u64,
     pub unprocessed_block_deadline_secs: u64,
+    /// minimum number of transactions that must be in a block if we're going to replace a pending
+    /// block-commit with a new block-commit
+    pub min_tx_count: u64,
+    /// Only allow a block's tx count to increase across RBFs.
+    pub only_increase_tx_count: bool,
+    /// Path to a script that prints out all unconfirmed block-commits for a list of addresses
+    pub unconfirmed_commits_helper: Option<String>,
+    /// Targeted win probability for this miner.  Used to deduce when to stop trying to mine.
+    pub target_win_probability: f64,
+    /// Path to a serialized RegisteredKey struct, which points to an already-registered VRF key
+    /// (so we don't have to go make a new one)
+    pub activated_vrf_key_path: Option<String>,
+    /// When estimating win probability, whether or not to use the assumed win rate 6+ blocks from
+    /// now (true), or the current win rate (false)
+    pub fast_rampup: bool,
+    /// Number of Bitcoin blocks which must pass where the boostes+neutrals are a minority, at which
+    /// point the miner will stop trying.
+    pub underperform_stop_threshold: Option<u64>,
+    /// Kinds of transactions to consider from the mempool.  This is used by boosted and neutral
+    /// miners to push past averse fee estimations.
+    pub txs_to_consider: HashSet<MemPoolWalkTxTypes>,
+    /// Origin addresses to whitelist when doing a mempool walk.  This is used by boosted and
+    /// neutral miners to push transactions through that are important to them.
+    pub filter_origins: HashSet<StacksAddress>,
+    /// When selecting the "nicest" tip, do not consider tips that are more than this many blocks
+    /// behind the highest tip.
+    pub max_reorg_depth: u64,
 }
 
 impl MinerConfig {
     pub fn default() -> MinerConfig {
         MinerConfig {
-            min_tx_fee: 1,
-            first_attempt_time_ms: 5_000,
-            subsequent_attempt_time_ms: 30_000,
+            first_attempt_time_ms: 10,
+            subsequent_attempt_time_ms: 120_000,
             microblock_attempt_time_ms: 30_000,
             probability_pick_no_estimate_tx: 5,
             block_reward_recipient: None,
             segwit: false,
             wait_for_block_download: true,
-            nonce_cache_size: 10_000,
-            candidate_retry_cache_size: 10_000,
+            nonce_cache_size: 1024 * 1024,
+            candidate_retry_cache_size: 1024 * 1024,
             unprocessed_block_deadline_secs: 30,
+            min_tx_count: 0,
+            only_increase_tx_count: false,
+            unconfirmed_commits_helper: None,
+            target_win_probability: 0.0,
+            activated_vrf_key_path: None,
+            fast_rampup: false,
+            underperform_stop_threshold: None,
+            txs_to_consider: MemPoolWalkTxTypes::all(),
+            filter_origins: HashSet::new(),
+            max_reorg_depth: 3,
         }
     }
 }
@@ -2012,7 +2138,6 @@ impl Default for FeeEstimationConfigFile {
 
 #[derive(Clone, Deserialize, Default, Debug)]
 pub struct MinerConfigFile {
-    pub min_tx_fee: Option<u64>,
     pub first_attempt_time_ms: Option<u64>,
     pub subsequent_attempt_time_ms: Option<u64>,
     pub microblock_attempt_time_ms: Option<u64>,
@@ -2022,6 +2147,16 @@ pub struct MinerConfigFile {
     pub nonce_cache_size: Option<u64>,
     pub candidate_retry_cache_size: Option<u64>,
     pub unprocessed_block_deadline_secs: Option<u64>,
+    pub min_tx_count: Option<u64>,
+    pub only_increase_tx_count: Option<bool>,
+    pub unconfirmed_commits_helper: Option<String>,
+    pub target_win_probability: Option<f64>,
+    pub activated_vrf_key_path: Option<String>,
+    pub fast_rampup: Option<bool>,
+    pub underperform_stop_threshold: Option<u64>,
+    pub txs_to_consider: Option<String>,
+    pub filter_origins: Option<String>,
+    pub max_reorg_depth: Option<u64>,
 }
 
 #[derive(Clone, Deserialize, Default, Debug)]
diff --git a/testnet/stacks-node/src/main.rs b/testnet/stacks-node/src/main.rs
index 3d904a2116..0c8b8ca9dd 100644
--- a/testnet/stacks-node/src/main.rs
+++ b/testnet/stacks-node/src/main.rs
@@ -23,6 +23,7 @@ use stacks::util::hash::hex_bytes;
 pub mod monitoring;
 
 pub mod burnchains;
+pub mod chain_data;
 pub mod config;
 pub mod event_dispatcher;
 pub mod genesis_data;
@@ -34,6 +35,8 @@ pub mod run_loop;
 pub mod syncctl;
 pub mod tenure;
 
+use std::collections::HashMap;
+
 pub use self::burnchains::{
     BitcoinRegtestController, BurnchainController, BurnchainTip, MocknetController,
 };
@@ -44,6 +47,18 @@ pub use self::node::{ChainTip, Node};
 pub use self::run_loop::{helium, neon};
 pub use self::tenure::Tenure;
 
+use crate::neon_node::BlockMinerThread;
+
+use stacks::chainstate::burn::db::sortdb::SortitionDB;
+use stacks::chainstate::burn::operations::leader_block_commit::RewardSetInfo;
+use stacks::chainstate::coordinator::get_next_recipients;
+use stacks::chainstate::coordinator::OnChainRewardSetProvider;
+use stacks::chainstate::stacks::address::PoxAddress;
+use stacks::chainstate::stacks::db::StacksChainState;
+
+use crate::chain_data::MinerStats;
+use crate::neon_node::TipCandidate;
+
 use pico_args::Arguments;
 use std::env;
 
@@ -53,6 +68,210 @@ use std::process;
 
 use backtrace::Backtrace;
 
+/// Implmentation of `pick_best_tip` CLI option
+fn cli_pick_best_tip(config_path: &str, at_stacks_height: Option<u64>) -> TipCandidate {
+    info!("Loading config at path {}", config_path);
+    let config = match ConfigFile::from_path(config_path) {
+        Ok(config_file) => Config::from_config_file(config_file).unwrap(),
+        Err(e) => {
+            warn!("Invalid config file: {}", e);
+            process::exit(1);
+        }
+    };
+    let burn_db_path = config.get_burn_db_file_path();
+    let stacks_chainstate_path = config.get_chainstate_path_str();
+    let burnchain = config.get_burnchain();
+    let (mut chainstate, _) = StacksChainState::open(
+        config.is_mainnet(),
+        config.burnchain.chain_id,
+        &stacks_chainstate_path,
+        Some(config.node.get_marf_opts()),
+    )
+    .unwrap();
+    let mut sortdb =
+        SortitionDB::open(&burn_db_path, false, burnchain.pox_constants.clone()).unwrap();
+
+    let max_depth = config.miner.max_reorg_depth;
+
+    // There could be more than one possible chain tip. Go find them.
+    let stacks_tips = BlockMinerThread::load_candidate_tips(
+        &mut sortdb,
+        &mut chainstate,
+        max_depth,
+        at_stacks_height,
+    );
+
+    let best_tip = BlockMinerThread::inner_pick_best_tip(stacks_tips, HashMap::new()).unwrap();
+    best_tip
+}
+
+/// Implementation of `get_miner_spend` CLI option
+fn cli_get_miner_spend(
+    config_path: &str,
+    mine_start: Option<u64>,
+    at_burnchain_height: Option<u64>,
+) -> u64 {
+    info!("Loading config at path {}", config_path);
+    let config = match ConfigFile::from_path(&config_path) {
+        Ok(config_file) => Config::from_config_file(config_file).unwrap(),
+        Err(e) => {
+            warn!("Invalid config file: {}", e);
+            process::exit(1);
+        }
+    };
+    let keychain = Keychain::default(config.node.seed.clone());
+    let burn_db_path = config.get_burn_db_file_path();
+    let stacks_chainstate_path = config.get_chainstate_path_str();
+    let burnchain = config.get_burnchain();
+    let (mut chainstate, _) = StacksChainState::open(
+        config.is_mainnet(),
+        config.burnchain.chain_id,
+        &stacks_chainstate_path,
+        Some(config.node.get_marf_opts()),
+    )
+    .unwrap();
+    let mut sortdb =
+        SortitionDB::open(&burn_db_path, true, burnchain.pox_constants.clone()).unwrap();
+    let tip = if let Some(at_burnchain_height) = at_burnchain_height {
+        let tip = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn()).unwrap();
+        let ih = sortdb.index_handle(&tip.sortition_id);
+        ih.get_block_snapshot_by_height(at_burnchain_height)
+            .unwrap()
+            .unwrap()
+    } else {
+        SortitionDB::get_canonical_burn_chain_tip(sortdb.conn()).unwrap()
+    };
+
+    let recipients = get_next_recipients(
+        &tip,
+        &mut chainstate,
+        &mut sortdb,
+        &burnchain,
+        &OnChainRewardSetProvider(),
+        config.node.always_use_affirmation_maps,
+    )
+    .unwrap();
+
+    let commit_outs = if !burnchain.is_in_prepare_phase(tip.block_height + 1) {
+        RewardSetInfo::into_commit_outs(recipients, config.is_mainnet())
+    } else {
+        vec![PoxAddress::standard_burn_address(config.is_mainnet())]
+    };
+
+    let spend_amount = BlockMinerThread::get_mining_spend_amount(
+        &config,
+        &keychain,
+        &burnchain,
+        &mut sortdb,
+        &commit_outs,
+        mine_start.unwrap_or(tip.block_height),
+        at_burnchain_height,
+        |burn_block_height| {
+            let sortdb =
+                SortitionDB::open(&burn_db_path, true, burnchain.pox_constants.clone()).unwrap();
+            let Some(miner_stats) = config.get_miner_stats() else {
+                return 0.0;
+            };
+            let Ok(active_miners_and_commits) =
+                MinerStats::get_active_miners(&sortdb, Some(burn_block_height)).map_err(|e| {
+                    warn!("Failed to get active miners: {:?}", &e);
+                    e
+                })
+            else {
+                return 0.0;
+            };
+            if active_miners_and_commits.len() == 0 {
+                warn!("No active miners detected; using config file burn_fee_cap");
+                return 0.0;
+            }
+
+            let active_miners: Vec<_> = active_miners_and_commits
+                .iter()
+                .map(|(miner, _cmt)| miner.as_str())
+                .collect();
+
+            info!("Active miners: {:?}", &active_miners);
+
+            let Ok(unconfirmed_block_commits) = miner_stats
+                .get_unconfirmed_commits(burn_block_height + 1, &active_miners)
+                .map_err(|e| {
+                    warn!("Failed to find unconfirmed block-commits: {}", &e);
+                    e
+                })
+            else {
+                return 0.0;
+            };
+
+            let unconfirmed_miners_and_amounts: Vec<(String, u64)> = unconfirmed_block_commits
+                .iter()
+                .map(|cmt| (format!("{}", &cmt.apparent_sender), cmt.burn_fee))
+                .collect();
+
+            info!(
+                "Found unconfirmed block-commits: {:?}",
+                &unconfirmed_miners_and_amounts
+            );
+
+            let (spend_dist, _total_spend) = MinerStats::get_spend_distribution(
+                &active_miners_and_commits,
+                &unconfirmed_block_commits,
+                &commit_outs,
+            );
+            let win_probs = if config.miner.fast_rampup {
+                // look at spends 6+ blocks in the future
+                let win_probs = MinerStats::get_future_win_distribution(
+                    &active_miners_and_commits,
+                    &unconfirmed_block_commits,
+                    &commit_outs,
+                );
+                win_probs
+            } else {
+                // look at the current spends
+                let Ok(unconfirmed_burn_dist) = miner_stats
+                    .get_unconfirmed_burn_distribution(
+                        &burnchain,
+                        &sortdb,
+                        &active_miners_and_commits,
+                        unconfirmed_block_commits,
+                        &commit_outs,
+                        at_burnchain_height,
+                    )
+                    .map_err(|e| {
+                        warn!("Failed to get unconfirmed burn distribution: {:?}", &e);
+                        e
+                    })
+                else {
+                    return 0.0;
+                };
+
+                let win_probs = MinerStats::burn_dist_to_prob_dist(&unconfirmed_burn_dist);
+                win_probs
+            };
+
+            info!("Unconfirmed spend distribution: {:?}", &spend_dist);
+            info!(
+                "Unconfirmed win probabilities (fast_rampup={}): {:?}",
+                config.miner.fast_rampup, &win_probs
+            );
+
+            let miner_addrs = BlockMinerThread::get_miner_addrs(&config, &keychain);
+            let win_prob = miner_addrs
+                .iter()
+                .find_map(|x| win_probs.get(x))
+                .copied()
+                .unwrap_or(0.0);
+
+            info!(
+                "This miner's win probability at {} is {}",
+                tip.block_height, &win_prob
+            );
+            win_prob
+        },
+        |_burn_block_height, _win_prob| {},
+    );
+    spend_amount
+}
+
 fn main() {
     panic::set_hook(Box::new(|panic_info| {
         error!("Process abort due to thread panic: {}", panic_info);
@@ -94,24 +313,24 @@ fn main() {
 
     let config_file = match subcommand.as_str() {
         "mocknet" => {
-            args.finish().unwrap();
+            args.finish();
             ConfigFile::mocknet()
         }
         "helium" => {
-            args.finish().unwrap();
+            args.finish();
             ConfigFile::helium()
         }
         "testnet" => {
-            args.finish().unwrap();
+            args.finish();
             ConfigFile::xenon()
         }
         "mainnet" => {
-            args.finish().unwrap();
+            args.finish();
             ConfigFile::mainnet()
         }
         "check-config" => {
             let config_path: String = args.value_from_str("--config").unwrap();
-            args.finish().unwrap();
+            args.finish();
             info!("Loading config at path {}", config_path);
             let config_file = match ConfigFile::from_path(&config_path) {
                 Ok(config_file) => {
@@ -136,7 +355,7 @@ fn main() {
         }
         "start" => {
             let config_path: String = args.value_from_str("--config").unwrap();
-            args.finish().unwrap();
+            args.finish();
             info!("Loading config at path {}", config_path);
             match ConfigFile::from_path(&config_path) {
                 Ok(config_file) => config_file,
@@ -157,14 +376,15 @@ fn main() {
                     let conf =
                         Config::from_config_file(ConfigFile::from_path(&config_path).unwrap())
                             .unwrap();
-                    args.finish().unwrap();
+                    args.finish();
                     conf.node.seed
                 } else {
-                    let free_args = args.free().unwrap();
+                    let free_args = args.finish();
                     let seed_hex = free_args
                         .first()
                         .expect("`wif-for-seed` must be passed either a config file via the `--config` flag or a hex seed string");
-                    hex_bytes(seed_hex).expect("Seed should be a hex encoded string")
+                    hex_bytes(seed_hex.to_str().unwrap())
+                        .expect("Seed should be a hex encoded string")
                 }
             };
             let keychain = Keychain::default(seed);
@@ -178,6 +398,26 @@ fn main() {
             );
             return;
         }
+        "pick-best-tip" => {
+            let config_path: String = args.value_from_str("--config").unwrap();
+            let at_stacks_height: Option<u64> =
+                args.opt_value_from_str("--at-stacks-height").unwrap();
+            args.finish();
+
+            let best_tip = cli_pick_best_tip(&config_path, at_stacks_height);
+            println!("Best tip is {:?}", &best_tip);
+            process::exit(0);
+        }
+        "get-spend-amount" => {
+            let config_path: String = args.value_from_str("--config").unwrap();
+            let at_burnchain_height: Option<u64> =
+                args.opt_value_from_str("--at-bitcoin-height").unwrap();
+            args.finish();
+
+            let spend_amount = cli_get_miner_spend(&config_path, mine_start, at_burnchain_height);
+            println!("Will spend {}", spend_amount);
+            process::exit(0);
+        }
         _ => {
             print_help();
             return;
diff --git a/testnet/stacks-node/src/neon_node.rs b/testnet/stacks-node/src/neon_node.rs
index 17eebf2c97..865f5e2a9a 100644
--- a/testnet/stacks-node/src/neon_node.rs
+++ b/testnet/stacks-node/src/neon_node.rs
@@ -1,5 +1,5 @@
 // Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
-// Copyright (C) 2020 Stacks Open Internet Foundation
+// Copyright (C) 2020-2024 Stacks Open Internet Foundation
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -138,91 +138,90 @@
 ///
 /// This file may be refactored in the future into a full-fledged module.
 use std::cmp;
-use std::collections::HashMap;
-use std::collections::{HashSet, VecDeque};
+use std::cmp::Ordering as CmpOrdering;
+use std::collections::{BTreeMap, HashMap, HashSet, VecDeque};
 use std::convert::{TryFrom, TryInto};
 use std::default::Default;
-use std::mem;
+use std::fs;
+use std::io::{Read, Write};
 use std::net::SocketAddr;
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::mpsc::{Receiver, SyncSender, TrySendError};
-use std::sync::{atomic::AtomicBool, atomic::Ordering, Arc, Mutex};
+use std::sync::{Arc, Mutex};
+use std::thread::JoinHandle;
 use std::time::Duration;
-use std::{thread, thread::JoinHandle};
+use std::{mem, thread};
+
+use clarity::vm::ast::ASTRules;
+use clarity::vm::types::PrincipalData;
+use stacks::burnchains::bitcoin::address::BitcoinAddress;
+use stacks::burnchains::bitcoin::address::LegacyBitcoinAddressType;
+use stacks::burnchains::db::BurnchainHeaderReader;
+use stacks::burnchains::{Burnchain, BurnchainParameters, Txid};
 
-use stacks::burnchains::{db::BurnchainHeaderReader, Burnchain, BurnchainParameters, Txid};
 use stacks::chainstate::burn::db::sortdb::SortitionDB;
+use stacks::chainstate::burn::operations::leader_block_commit::{
+    RewardSetInfo, BURN_BLOCK_MINED_AT_MODULUS,
+};
 use stacks::chainstate::burn::operations::{
-    leader_block_commit::{RewardSetInfo, BURN_BLOCK_MINED_AT_MODULUS},
     BlockstackOperationType, LeaderBlockCommitOp, LeaderKeyRegisterOp,
 };
-use stacks::chainstate::burn::BlockSnapshot;
-use stacks::chainstate::burn::ConsensusHash;
+use stacks::chainstate::burn::{BlockSnapshot, ConsensusHash};
 use stacks::chainstate::coordinator::comm::CoordinatorChannels;
 use stacks::chainstate::coordinator::{get_next_recipients, OnChainRewardSetProvider};
 use stacks::chainstate::stacks::address::PoxAddress;
 use stacks::chainstate::stacks::db::unconfirmed::UnconfirmedTxMap;
-use stacks::chainstate::stacks::db::StacksHeaderInfo;
-use stacks::chainstate::stacks::db::{StacksChainState, MINER_REWARD_MATURITY};
-use stacks::chainstate::stacks::Error as ChainstateError;
-use stacks::chainstate::stacks::StacksPublicKey;
-use stacks::chainstate::stacks::{
-    miner::get_mining_spend_amount, miner::signal_mining_blocked, miner::signal_mining_ready,
-    miner::BlockBuilderSettings, miner::MinerStatus, miner::StacksMicroblockBuilder,
-    StacksBlockBuilder, StacksBlockHeader,
+use stacks::chainstate::stacks::db::{
+    blocks::StagingBlock, StacksChainState, StacksHeaderInfo, MINER_REWARD_MATURITY,
+};
+use stacks::chainstate::stacks::miner::{
+    signal_mining_blocked, signal_mining_ready, BlockBuilderSettings, MinerStatus,
+    StacksMicroblockBuilder,
 };
 use stacks::chainstate::stacks::{
-    CoinbasePayload, StacksBlock, StacksMicroblock, StacksTransaction, StacksTransactionSigner,
+    CoinbasePayload, Error as ChainstateError, StacksBlock, StacksBlockBuilder, StacksBlockHeader,
+    StacksMicroblock, StacksPublicKey, StacksTransaction, StacksTransactionSigner,
     TransactionAnchorMode, TransactionPayload, TransactionVersion,
 };
 use stacks::codec::StacksMessageCodec;
 use stacks::core::mempool::MemPoolDB;
-use stacks::core::FIRST_BURNCHAIN_CONSENSUS_HASH;
-use stacks::core::STACKS_EPOCH_2_4_MARKER;
-use stacks::cost_estimates::metrics::CostMetric;
-use stacks::cost_estimates::metrics::UnitMetric;
-use stacks::cost_estimates::UnitEstimator;
-use stacks::cost_estimates::{CostEstimator, FeeEstimator};
+use stacks::core::{FIRST_BURNCHAIN_CONSENSUS_HASH, STACKS_EPOCH_2_4_MARKER};
+use stacks::cost_estimates::metrics::{CostMetric, UnitMetric};
+use stacks::cost_estimates::{CostEstimator, FeeEstimator, UnitEstimator};
+use stacks::monitoring;
 use stacks::monitoring::{increment_stx_blocks_mined_counter, update_active_miners_count_gauge};
-use stacks::net::{
-    atlas::{AtlasConfig, AtlasDB, AttachmentInstance},
-    db::{LocalPeer, PeerDB},
-    dns::DNSClient,
-    dns::DNSResolver,
-    p2p::PeerNetwork,
-    relay::Relayer,
-    rpc::RPCHandlerArgs,
-    Error as NetError, NetworkResult, PeerAddress, ServiceFlags,
-};
+use stacks::net::atlas::{AtlasConfig, AtlasDB, AttachmentInstance};
+use stacks::net::db::{LocalPeer, PeerDB};
+use stacks::net::dns::{DNSClient, DNSResolver};
+use stacks::net::p2p::PeerNetwork;
+use stacks::net::relay::Relayer;
+use stacks::net::rpc::RPCHandlerArgs;
+use stacks::net::{Error as NetError, NetworkResult, PeerAddress, ServiceFlags};
 use stacks::types::chainstate::{
     BlockHeaderHash, BurnchainHeaderHash, SortitionId, StacksAddress, VRFSeed,
 };
 use stacks::types::StacksEpochId;
-use stacks::util::get_epoch_time_ms;
-use stacks::util::get_epoch_time_secs;
 use stacks::util::hash::{to_hex, Hash160, Sha256Sum};
 use stacks::util::secp256k1::Secp256k1PrivateKey;
 use stacks::util::vrf::VRFPublicKey;
+use stacks::util::{get_epoch_time_ms, get_epoch_time_secs};
 use stacks::util_lib::strings::{UrlString, VecDisplay};
 use stacks::vm::costs::ExecutionCost;
 
-use crate::burnchains::bitcoin_regtest_controller::BitcoinRegtestController;
-use crate::burnchains::bitcoin_regtest_controller::OngoingBlockCommit;
-use crate::burnchains::make_bitcoin_indexer;
-use crate::run_loop::neon::Counters;
-use crate::run_loop::neon::RunLoop;
-use crate::run_loop::RegisteredKey;
-use crate::ChainTip;
-
 use super::{BurnchainController, Config, EventDispatcher, Keychain};
-use crate::syncctl::PoxSyncWatchdogComms;
-use stacks::monitoring;
 
-use stacks_common::types::chainstate::StacksBlockId;
-use stacks_common::types::chainstate::StacksPrivateKey;
+use stacks_common::types::chainstate::{StacksBlockId, StacksPrivateKey};
+use stacks_common::types::PublicKey;
 use stacks_common::util::vrf::VRFProof;
 
-use clarity::vm::ast::ASTRules;
-use clarity::vm::types::PrincipalData;
+use crate::burnchains::bitcoin_regtest_controller::{BitcoinRegtestController, OngoingBlockCommit};
+use crate::burnchains::make_bitcoin_indexer;
+use crate::chain_data::MinerStats;
+use crate::config::MinerConfig;
+use crate::run_loop::neon::{Counters, RunLoop};
+use crate::run_loop::RegisteredKey;
+use crate::syncctl::PoxSyncWatchdogComms;
+use crate::ChainTip;
 
 pub const RELAYER_MAX_BUFFER: usize = 100;
 const VRF_MOCK_MINER_KEY: u64 = 1;
@@ -232,7 +231,7 @@ pub const BLOCK_PROCESSOR_STACK_SIZE: usize = 32 * 1024 * 1024; // 32 MB
 type MinedBlocks = HashMap<BlockHeaderHash, (AssembledAnchorBlock, Secp256k1PrivateKey)>;
 
 /// Result of running the miner thread.  It could produce a Stacks block or a microblock.
-enum MinerThreadResult {
+pub(crate) enum MinerThreadResult {
     Block(
         AssembledAnchorBlock,
         Secp256k1PrivateKey,
@@ -248,7 +247,7 @@ enum MinerThreadResult {
 /// linked to the burnchain and what view(s) the miner had of the burnchain before and after
 /// completing the block.
 #[derive(Clone)]
-struct AssembledAnchorBlock {
+pub struct AssembledAnchorBlock {
     /// Consensus hash of the parent Stacks block
     parent_consensus_hash: ConsensusHash,
     /// Burnchain tip's block hash when we finished mining
@@ -301,6 +300,15 @@ pub struct Globals {
     pub should_keep_running: Arc<AtomicBool>,
     /// Status of our VRF key registration state (shared between the main thread and the relayer)
     leader_key_registration_state: Arc<Mutex<LeaderKeyRegistrationState>>,
+    /// Last miner config loaded
+    last_miner_config: Arc<Mutex<Option<MinerConfig>>>,
+    /// burnchain height at which we start mining
+    start_mining_height: Arc<Mutex<u64>>,
+    /// estimated winning probability at given bitcoin block heights
+    estimated_winning_probs: Arc<Mutex<HashMap<u64, f64>>>,
+    /// previously-selected best tips
+    /// maps stacks height to tip candidate
+    previous_best_tips: Arc<Mutex<BTreeMap<u64, TipCandidate>>>,
 }
 
 /// Miner chain tip, on top of which to build microblocks
@@ -344,6 +352,7 @@ impl Globals {
         counters: Counters,
         sync_comms: PoxSyncWatchdogComms,
         should_keep_running: Arc<AtomicBool>,
+        start_mining_height: u64,
     ) -> Globals {
         Globals {
             last_sortition: Arc::new(Mutex::new(None)),
@@ -357,6 +366,10 @@ impl Globals {
             leader_key_registration_state: Arc::new(Mutex::new(
                 LeaderKeyRegistrationState::Inactive,
             )),
+            last_miner_config: Arc::new(Mutex::new(None)),
+            start_mining_height: Arc::new(Mutex::new(start_mining_height)),
+            estimated_winning_probs: Arc::new(Mutex::new(HashMap::new())),
+            previous_best_tips: Arc::new(Mutex::new(BTreeMap::new())),
         }
     }
 
@@ -496,8 +509,8 @@ impl Globals {
         &self,
         burn_block_height: u64,
         key_registers: Vec<LeaderKeyRegisterOp>,
-    ) -> bool {
-        let mut activated = false;
+    ) -> Option<RegisteredKey> {
+        let mut activated_key = None;
         match self.leader_key_registration_state.lock() {
             Ok(ref mut leader_key_registration_state) => {
                 for op in key_registers.into_iter() {
@@ -509,14 +522,17 @@ impl Globals {
                             burn_block_height, txid
                         );
                         if txid == op.txid {
+                            let active_key = RegisteredKey {
+                                target_block_height,
+                                vrf_public_key: op.public_key,
+                                block_height: op.block_height as u64,
+                                op_vtxindex: op.vtxindex as u32,
+                            };
+
                             **leader_key_registration_state =
-                                LeaderKeyRegistrationState::Active(RegisteredKey {
-                                    target_block_height,
-                                    vrf_public_key: op.public_key,
-                                    block_height: op.block_height as u64,
-                                    op_vtxindex: op.vtxindex as u32,
-                                });
-                            activated = true;
+                                LeaderKeyRegistrationState::Active(active_key.clone());
+
+                            activated_key = Some(active_key);
                         } else {
                             debug!(
                                 "key_register_op {} does not match our pending op {}",
@@ -531,7 +547,126 @@ impl Globals {
                 panic!();
             }
         }
-        activated
+        activated_key
+    }
+
+    /// Directly set the leader key activation state from a saved key
+    pub fn resume_leader_key(&self, registered_key: RegisteredKey) {
+        match self.leader_key_registration_state.lock() {
+            Ok(ref mut leader_key_registration_state) => {
+                **leader_key_registration_state = LeaderKeyRegistrationState::Active(registered_key)
+            }
+            Err(_e) => {
+                error!("FATAL: failed to lock leader key registration state mutex");
+                panic!();
+            }
+        }
+    }
+
+    /// Get the last miner config loaded
+    pub fn get_last_miner_config(&self) -> Option<MinerConfig> {
+        match self.last_miner_config.lock() {
+            Ok(last_miner_config) => (*last_miner_config).clone(),
+            Err(_e) => {
+                error!("FATAL; failed to lock last miner config");
+                panic!();
+            }
+        }
+    }
+
+    /// Set the last miner config loaded
+    pub fn set_last_miner_config(&self, miner_config: MinerConfig) {
+        match self.last_miner_config.lock() {
+            Ok(ref mut last_miner_config) => **last_miner_config = Some(miner_config),
+            Err(_e) => {
+                error!("FATAL; failed to lock last miner config");
+                panic!();
+            }
+        }
+    }
+
+    /// Get the height at which we should start mining
+    pub fn get_start_mining_height(&self) -> u64 {
+        match self.start_mining_height.lock() {
+            Ok(ht) => *ht,
+            Err(_e) => {
+                error!("FATAL: failed to lock start_mining_height");
+                panic!();
+            }
+        }
+    }
+
+    /// Set the height at which we started mining.
+    /// Only takes effect if the current start mining height is 0.
+    pub fn set_start_mining_height_if_zero(&self, value: u64) {
+        match self.start_mining_height.lock() {
+            Ok(ref mut ht) => {
+                if **ht == 0 {
+                    **ht = value;
+                }
+            }
+            Err(_e) => {
+                error!("FATAL: failed to lock start_mining_height");
+                panic!();
+            }
+        }
+    }
+
+    /// Record an estimated winning probability
+    pub fn add_estimated_win_prob(&self, burn_height: u64, win_prob: f64) {
+        match self.estimated_winning_probs.lock() {
+            Ok(mut probs) => {
+                probs.insert(burn_height, win_prob);
+            }
+            Err(_e) => {
+                error!("FATAL: failed to lock estimated_winning_probs");
+                panic!();
+            }
+        }
+    }
+
+    /// Get the estimated winning probability, if we have one
+    pub fn get_estimated_win_prob(&self, burn_height: u64) -> Option<f64> {
+        match self.estimated_winning_probs.lock() {
+            Ok(probs) => probs.get(&burn_height).cloned(),
+            Err(_e) => {
+                error!("FATAL: failed to lock estimated_winning_probs");
+                panic!();
+            }
+        }
+    }
+
+    /// Record a best-tip
+    pub fn add_best_tip(&self, stacks_height: u64, tip_candidate: TipCandidate, max_depth: u64) {
+        match self.previous_best_tips.lock() {
+            Ok(mut tips) => {
+                tips.insert(stacks_height, tip_candidate);
+                let mut stale = vec![];
+                for (prev_height, _) in tips.iter() {
+                    if *prev_height + max_depth < stacks_height {
+                        stale.push(*prev_height);
+                    }
+                }
+                for height in stale.into_iter() {
+                    tips.remove(&height);
+                }
+            }
+            Err(_e) => {
+                error!("FATAL: failed to lock previous_best_tips");
+                panic!();
+            }
+        }
+    }
+
+    /// Get a best-tip at a previous height
+    pub fn get_best_tip(&self, stacks_height: u64) -> Option<TipCandidate> {
+        match self.previous_best_tips.lock() {
+            Ok(tips) => tips.get(&stacks_height).cloned(),
+            Err(_e) => {
+                error!("FATAL: failed to lock previous_best_tips");
+                panic!();
+            }
+        }
     }
 }
 
@@ -745,7 +880,7 @@ pub struct RelayerThread {
     mined_stacks_block: bool,
 }
 
-struct BlockMinerThread {
+pub(crate) struct BlockMinerThread {
     /// node config struct
     config: Config,
     /// handle to global state
@@ -1063,8 +1198,6 @@ impl MicroblockMinerThread {
 
             #[cfg(any(test, feature = "testing"))]
             {
-                use std::fs;
-                use std::io::Write;
                 use std::path::Path;
                 if let Ok(path) = std::env::var("STACKS_BAD_BLOCKS_DIR") {
                     // record this microblock somewhere
@@ -1216,6 +1349,46 @@ impl MicroblockMinerThread {
     }
 }
 
+/// Candidate chain tip
+#[derive(Debug, Clone, PartialEq)]
+pub struct TipCandidate {
+    pub stacks_height: u64,
+    pub consensus_hash: ConsensusHash,
+    pub anchored_block_hash: BlockHeaderHash,
+    pub parent_consensus_hash: ConsensusHash,
+    pub parent_anchored_block_hash: BlockHeaderHash,
+    /// the block's sortition's burnchain height
+    pub burn_height: u64,
+    /// the number of Stacks blocks *at the same height* as this one, but from earlier sortitions
+    /// than `burn_height`
+    pub num_earlier_siblings: u64,
+}
+
+impl TipCandidate {
+    pub fn id(&self) -> StacksBlockId {
+        StacksBlockId::new(&self.consensus_hash, &self.anchored_block_hash)
+    }
+
+    pub fn parent_id(&self) -> StacksBlockId {
+        StacksBlockId::new(
+            &self.parent_consensus_hash,
+            &self.parent_anchored_block_hash,
+        )
+    }
+
+    pub fn new(tip: StagingBlock, burn_height: u64) -> Self {
+        Self {
+            stacks_height: tip.height,
+            consensus_hash: tip.consensus_hash,
+            anchored_block_hash: tip.anchored_block_hash,
+            parent_consensus_hash: tip.parent_consensus_hash,
+            parent_anchored_block_hash: tip.parent_anchored_block_hash,
+            burn_height,
+            num_earlier_siblings: 0,
+        }
+    }
+}
+
 impl BlockMinerThread {
     /// Instantiate the miner thread from its parent RelayerThread
     pub fn from_relayer_thread(
@@ -1238,11 +1411,12 @@ impl BlockMinerThread {
 
     /// Get the coinbase recipient address, if set in the config and if allowed in this epoch
     fn get_coinbase_recipient(&self, epoch_id: StacksEpochId) -> Option<PrincipalData> {
-        if epoch_id < StacksEpochId::Epoch21 && self.config.miner.block_reward_recipient.is_some() {
+        let miner_config = self.config.get_miner_config();
+        if epoch_id < StacksEpochId::Epoch21 && miner_config.block_reward_recipient.is_some() {
             warn!("Coinbase pay-to-contract is not supported in the current epoch");
             None
         } else {
-            self.config.miner.block_reward_recipient.clone()
+            miner_config.block_reward_recipient.clone()
         }
     }
 
@@ -1353,6 +1527,320 @@ impl BlockMinerThread {
         ret
     }
 
+    /// Load all candidate tips upon which to build.  This is all Stacks blocks whose heights are
+    /// less than or equal to at `at_stacks_height` (or the canonical chain tip height, if not given),
+    /// but greater than or equal to this end height minus `max_depth`.
+    /// Returns the list of all Stacks blocks up to max_depth blocks beneath it.
+    /// The blocks will be sorted first by stacks height, and then by burnchain height
+    pub(crate) fn load_candidate_tips(
+        burn_db: &mut SortitionDB,
+        chain_state: &mut StacksChainState,
+        max_depth: u64,
+        at_stacks_height: Option<u64>,
+    ) -> Vec<TipCandidate> {
+        let stacks_tips = if let Some(start_height) = at_stacks_height {
+            chain_state
+                .get_stacks_chain_tips_at_height(start_height)
+                .expect("FATAL: could not query chain tips at start height")
+        } else {
+            chain_state
+                .get_stacks_chain_tips(burn_db)
+                .expect("FATAL: could not query chain tips")
+        };
+
+        if stacks_tips.len() == 0 {
+            return vec![];
+        }
+
+        let mut considered = HashSet::new();
+        let mut candidates = vec![];
+        let end_height = stacks_tips[0].height;
+
+        for cur_height in end_height.saturating_sub(max_depth)..=end_height {
+            let stacks_tips = chain_state
+                .get_stacks_chain_tips_at_height(cur_height)
+                .expect("FATAL: could not query chain tips at height");
+
+            for tip in stacks_tips {
+                let index_block_hash =
+                    StacksBlockId::new(&tip.consensus_hash, &tip.anchored_block_hash);
+
+                if !considered.contains(&index_block_hash) {
+                    let burn_height = burn_db
+                        .get_consensus_hash_height(&tip.consensus_hash)
+                        .expect("FATAL: could not query burnchain block height")
+                        .expect("FATAL: no burnchain block height for Stacks tip");
+                    let candidate = TipCandidate::new(tip, burn_height);
+                    candidates.push(candidate);
+                    considered.insert(index_block_hash);
+                }
+            }
+        }
+        Self::sort_and_populate_candidates(candidates)
+    }
+
+    /// Put all tip candidates in order by stacks height, breaking ties with burnchain height.
+    /// Also, count up the number of earliersiblings each tip has -- i.e. the number of stacks
+    /// blocks that have the same height, but a later burnchain sortition.
+    pub(crate) fn sort_and_populate_candidates(
+        mut candidates: Vec<TipCandidate>,
+    ) -> Vec<TipCandidate> {
+        if candidates.len() == 0 {
+            return candidates;
+        }
+        candidates.sort_by(|tip1, tip2| {
+            // stacks block height, then burnchain block height
+            let ord = tip1.stacks_height.cmp(&tip2.stacks_height);
+            if ord == CmpOrdering::Equal {
+                return tip1.burn_height.cmp(&tip2.burn_height);
+            }
+            ord
+        });
+
+        // calculate the number of earlier siblings for each block.
+        // this is the number of stacks blocks at the same height, but later burnchain heights.
+        let mut idx = 0;
+        let mut cur_stacks_height = candidates[idx].stacks_height;
+        let mut num_siblings = 0;
+        loop {
+            idx += 1;
+            if idx >= candidates.len() {
+                break;
+            }
+            if cur_stacks_height == candidates[idx].stacks_height {
+                // same stacks height, so this block has one more earlier sibling than the last
+                num_siblings += 1;
+                candidates[idx].num_earlier_siblings = num_siblings;
+            } else {
+                // new stacks height, so no earlier siblings
+                num_siblings = 0;
+                cur_stacks_height = candidates[idx].stacks_height;
+                candidates[idx].num_earlier_siblings = 0;
+            }
+        }
+
+        candidates
+    }
+
+    /// Select the best tip to mine the next block on. Potential tips are all
+    /// leaf nodes where the Stacks block height is <= the max height -
+    /// max_reorg_depth. Each potential tip is then scored based on the amount
+    /// of orphans that its chain has caused -- that is, the number of orphans
+    /// that the tip _and all of its ancestors_ (up to `max_depth`) created.
+    /// The tip with the lowest score is composed of blocks that collectively made the fewest
+    /// orphans, and is thus the "nicest" chain with the least orphaning.  This is the tip that is
+    /// selected.
+    pub fn pick_best_tip(
+        globals: &Globals,
+        config: &Config,
+        burn_db: &mut SortitionDB,
+        chain_state: &mut StacksChainState,
+        at_stacks_height: Option<u64>,
+    ) -> Option<TipCandidate> {
+        info!("Picking best Stacks tip");
+        let miner_config = config.get_miner_config();
+        let max_depth = miner_config.max_reorg_depth;
+
+        // There could be more than one possible chain tip. Go find them.
+        let stacks_tips =
+            Self::load_candidate_tips(burn_db, chain_state, max_depth, at_stacks_height);
+
+        let mut previous_best_tips = HashMap::new();
+        for tip in stacks_tips.iter() {
+            let Some(prev_best_tip) = globals.get_best_tip(tip.stacks_height) else {
+                continue;
+            };
+            previous_best_tips.insert(tip.stacks_height, prev_best_tip);
+        }
+
+        let best_tip_opt = Self::inner_pick_best_tip(stacks_tips, previous_best_tips);
+        if let Some(best_tip) = best_tip_opt.as_ref() {
+            globals.add_best_tip(best_tip.stacks_height, best_tip.clone(), max_depth);
+        } else {
+            // no best-tip found; revert to old tie-breaker logic
+            info!("No best-tips found; using old tie-breaking logic");
+            return chain_state
+                .get_stacks_chain_tip(burn_db)
+                .expect("FATAL: could not load chain tip")
+                .map(|staging_block| {
+                    let burn_height = burn_db
+                        .get_consensus_hash_height(&staging_block.consensus_hash)
+                        .expect("FATAL: could not query burnchain block height")
+                        .expect("FATAL: no burnchain block height for Stacks tip");
+                    TipCandidate::new(staging_block, burn_height)
+                });
+        }
+        best_tip_opt
+    }
+
+    /// Given a list of sorted candidate tips, pick the best one.  See `Self::pick_best_tip()`.
+    /// Takes the list of stacks tips that are eligible to be built on, and a map of
+    /// previously-chosen best tips (so if we chose a tip in the past, we keep confirming it, even
+    /// if subsequent stacks blocks show up).  The previous best tips should be from recent Stacks
+    /// heights; it's important that older best-tips are forgotten in order to ensure that miners
+    /// will eventually (e.g. after `max_reorg_depth` Stacks blocks pass) stop trying to confirm a
+    /// now-orphaned previously-chosen best-tip.  If there are multiple best-tips that conflict in
+    /// `previosu_best_tips`, then only the highest one which the leaf could confirm will be
+    /// considered (since the node updates its understanding of the best-tip on each RunTenure).
+    pub(crate) fn inner_pick_best_tip(
+        stacks_tips: Vec<TipCandidate>,
+        previous_best_tips: HashMap<u64, TipCandidate>,
+    ) -> Option<TipCandidate> {
+        // identify leaf tips -- i.e. blocks with no children
+        let parent_consensus_hashes: HashSet<_> = stacks_tips
+            .iter()
+            .map(|x| x.parent_consensus_hash.clone())
+            .collect();
+
+        let mut leaf_tips: Vec<_> = stacks_tips
+            .iter()
+            .filter(|x| !parent_consensus_hashes.contains(&x.consensus_hash))
+            .collect();
+
+        if leaf_tips.len() == 0 {
+            return None;
+        }
+
+        // Make scoring deterministic in the case of a tie.
+        // Prefer leafs that were mined earlier on the burnchain,
+        // but which pass through previously-determined best tips.
+        leaf_tips.sort_by(|tip1, tip2| {
+            // stacks block height, then burnchain block height
+            let ord = tip1.stacks_height.cmp(&tip2.stacks_height);
+            if ord == CmpOrdering::Equal {
+                return tip1.burn_height.cmp(&tip2.burn_height);
+            }
+            ord
+        });
+
+        let mut scores = BTreeMap::new();
+        for (i, leaf_tip) in leaf_tips.iter().enumerate() {
+            let leaf_id = leaf_tip.id();
+            // Score each leaf tip as the number of preceding Stacks blocks that are _not_ an
+            // ancestor.  Because stacks_tips are in order by stacks height, a linear scan of this
+            // list will allow us to match all ancestors in the last max_depth Stacks blocks.
+            // `ancestor_ptr` tracks the next expected ancestor.
+            let mut ancestor_ptr = leaf_tip.parent_id();
+            let mut score: u64 = 0;
+            let mut score_summaries = vec![];
+
+            // find the highest stacks_tip we must confirm
+            let mut must_confirm = None;
+            for tip in stacks_tips.iter().rev() {
+                if let Some(prev_best_tip) = previous_best_tips.get(&tip.stacks_height) {
+                    if leaf_id != prev_best_tip.id() {
+                        // the `ancestor_ptr` must pass through this prior best-tip
+                        must_confirm = Some(prev_best_tip.clone());
+                        break;
+                    }
+                }
+            }
+
+            for tip in stacks_tips.iter().rev() {
+                if let Some(required_ancestor) = must_confirm.as_ref() {
+                    if tip.stacks_height < required_ancestor.stacks_height
+                        && leaf_tip.stacks_height >= required_ancestor.stacks_height
+                    {
+                        // This leaf does not confirm a previous-best-tip, so assign it the
+                        // worst-possible score.
+                        info!("Tip #{} {}/{} at {}:{} conflicts with a previous best-tip {}/{} at {}:{}",
+                              i,
+                              &leaf_tip.consensus_hash,
+                              &leaf_tip.anchored_block_hash,
+                              leaf_tip.burn_height,
+                              leaf_tip.stacks_height,
+                              &required_ancestor.consensus_hash,
+                              &required_ancestor.anchored_block_hash,
+                              required_ancestor.burn_height,
+                              required_ancestor.stacks_height
+                        );
+                        score = u64::MAX;
+                        score_summaries.push(format!("{} (best-tip reorged)", u64::MAX));
+                        break;
+                    }
+                }
+                if tip.id() == leaf_id {
+                    // we can't orphan ourselves
+                    continue;
+                }
+                if leaf_tip.stacks_height < tip.stacks_height {
+                    // this tip is further along than leaf_tip, so canonicalizing leaf_tip would
+                    // orphan `tip.stacks_height - leaf_tip.stacks_height` blocks.
+                    score = score.saturating_add(tip.stacks_height - leaf_tip.stacks_height);
+                    score_summaries.push(format!(
+                        "{} (stx height diff)",
+                        tip.stacks_height - leaf_tip.stacks_height
+                    ));
+                } else if leaf_tip.stacks_height == tip.stacks_height
+                    && leaf_tip.burn_height > tip.burn_height
+                {
+                    // this tip has the same stacks height as the leaf, but its sortition happened
+                    // earlier. This means that the leaf is trying to orphan this block and all
+                    // blocks sortition'ed up to this leaf.  The miner should have instead tried to
+                    // confirm this existing tip, instead of mine a sibling.
+                    score = score.saturating_add(tip.num_earlier_siblings + 1);
+                    score_summaries.push(format!("{} (uncles)", tip.num_earlier_siblings + 1));
+                }
+                if tip.id() == ancestor_ptr {
+                    // did we confirm a previous best-tip? If so, then clear this
+                    if let Some(required_ancestor) = must_confirm.take() {
+                        if required_ancestor.id() != tip.id() {
+                            // did not confirm, so restoroe
+                            must_confirm = Some(required_ancestor);
+                        }
+                    }
+
+                    // this stacks tip is the next ancestor.  However, that ancestor may have
+                    // earlier-sortition'ed siblings that confirming this tip would orphan, so count those.
+                    ancestor_ptr = tip.parent_id();
+                    score = score.saturating_add(tip.num_earlier_siblings);
+                    score_summaries.push(format!("{} (earlier sibs)", tip.num_earlier_siblings));
+                } else {
+                    // this stacks tip is not an ancestor, and would be orphaned if leaf_tip is
+                    // canonical.
+                    score = score.saturating_add(1);
+                    score_summaries.push(format!("{} (non-ancestor)", 1));
+                }
+            }
+
+            info!(
+                "Tip #{} {}/{} at {}:{} has score {} ({})",
+                i,
+                &leaf_tip.consensus_hash,
+                &leaf_tip.anchored_block_hash,
+                leaf_tip.burn_height,
+                leaf_tip.stacks_height,
+                score,
+                score_summaries.join(" + ").to_string()
+            );
+            if score < u64::MAX {
+                scores.insert(i, score);
+            }
+        }
+
+        if scores.len() == 0 {
+            // revert to prior tie-breaking scheme
+            return None;
+        }
+
+        // The lowest score is the "nicest" tip (least amount of orphaning)
+        let best_tip_idx = scores
+            .iter()
+            .min_by_key(|(_, score)| *score)
+            .expect("FATAL: candidates should not be empty here")
+            .0;
+
+        let best_tip = leaf_tips
+            .get(*best_tip_idx)
+            .expect("FATAL: candidates should not be empty");
+
+        info!(
+            "Best tip is #{} {}/{}",
+            best_tip_idx, &best_tip.consensus_hash, &best_tip.anchored_block_hash
+        );
+        Some((*best_tip).clone())
+    }
+
     /// Load up the parent block info for mining.
     /// If there's no parent because this is the first block, then return the genesis block's info.
     /// If we can't find the parent in the DB but we expect one, return None.
@@ -1360,22 +1848,25 @@ impl BlockMinerThread {
         &self,
         burn_db: &mut SortitionDB,
         chain_state: &mut StacksChainState,
-    ) -> Option<ParentStacksBlockInfo> {
+    ) -> (Option<ParentStacksBlockInfo>, bool) {
         if let Some(stacks_tip) = chain_state
             .get_stacks_chain_tip(burn_db)
             .expect("FATAL: could not query chain tip")
         {
+            let best_stacks_tip =
+                Self::pick_best_tip(&self.globals, &self.config, burn_db, chain_state, None)
+                    .expect("FATAL: no best chain tip");
             let miner_address = self
                 .keychain
                 .origin_address(self.config.is_mainnet())
                 .unwrap();
-            match ParentStacksBlockInfo::lookup(
+            let parent_info = match ParentStacksBlockInfo::lookup(
                 chain_state,
                 burn_db,
                 &self.burn_block,
                 miner_address,
-                &stacks_tip.consensus_hash,
-                &stacks_tip.anchored_block_hash,
+                &best_stacks_tip.consensus_hash,
+                &best_stacks_tip.anchored_block_hash,
             ) {
                 Ok(parent_info) => Some(parent_info),
                 Err(Error::BurnchainTipChanged) => {
@@ -1383,7 +1874,16 @@ impl BlockMinerThread {
                     None
                 }
                 Err(..) => None,
+            };
+            if parent_info.is_none() {
+                warn!(
+                    "No parent for best-tip {}/{}",
+                    &best_stacks_tip.consensus_hash, &best_stacks_tip.anchored_block_hash
+                );
             }
+            let canonical = best_stacks_tip.consensus_hash == stacks_tip.consensus_hash
+                && best_stacks_tip.anchored_block_hash == stacks_tip.anchored_block_hash;
+            (parent_info, canonical)
         } else {
             debug!("No Stacks chain tip known, will return a genesis block");
             let (network, _) = self.config.burnchain.get_bitcoin_network();
@@ -1397,26 +1897,30 @@ impl BlockMinerThread {
                 burnchain_params.first_block_timestamp.into(),
             );
 
-            Some(ParentStacksBlockInfo {
-                stacks_parent_header: chain_tip.metadata,
-                parent_consensus_hash: FIRST_BURNCHAIN_CONSENSUS_HASH.clone(),
-                parent_block_burn_height: 0,
-                parent_block_total_burn: 0,
-                parent_winning_vtxindex: 0,
-                coinbase_nonce: 0,
-            })
+            (
+                Some(ParentStacksBlockInfo {
+                    stacks_parent_header: chain_tip.metadata,
+                    parent_consensus_hash: FIRST_BURNCHAIN_CONSENSUS_HASH.clone(),
+                    parent_block_burn_height: 0,
+                    parent_block_total_burn: 0,
+                    parent_winning_vtxindex: 0,
+                    coinbase_nonce: 0,
+                }),
+                true,
+            )
         }
     }
 
     /// Determine which attempt this will be when mining a block, and whether or not an attempt
     /// should even be made.
-    /// Returns Some(attempt) if we should attempt to mine (and what attempt it will be)
+    /// Returns Some(attempt, max-txs) if we should attempt to mine (and what attempt it will be)
     /// Returns None if we should not mine.
     fn get_mine_attempt(
         &self,
         chain_state: &StacksChainState,
         parent_block_info: &ParentStacksBlockInfo,
-    ) -> Option<u64> {
+        force: bool,
+    ) -> Option<(u64, u64)> {
         let parent_consensus_hash = &parent_block_info.parent_consensus_hash;
         let stacks_parent_header = &parent_block_info.stacks_parent_header;
         let parent_block_burn_height = parent_block_info.parent_block_burn_height;
@@ -1425,22 +1929,28 @@ impl BlockMinerThread {
             Self::find_inflight_mined_blocks(self.burn_block.block_height, &self.last_mined_blocks);
 
         // has the tip changed from our previously-mined block for this epoch?
-        let attempt = if last_mined_blocks.len() <= 1 {
+        let (attempt, max_txs) = if last_mined_blocks.len() <= 1 {
             // always mine if we've not mined a block for this epoch yet, or
             // if we've mined just one attempt, unconditionally try again (so we
             // can use `subsequent_miner_time_ms` in this attempt)
             if last_mined_blocks.len() == 1 {
-                debug!("Have only attempted one block; unconditionally trying again");
+                info!("Have only attempted one block; unconditionally trying again");
+            }
+            let attempt = last_mined_blocks.len() as u64 + 1;
+            let mut max_txs = 0;
+            for last_mined_block in last_mined_blocks.iter() {
+                max_txs = cmp::max(max_txs, last_mined_block.anchored_block.txs.len());
             }
-            last_mined_blocks.len() as u64 + 1
+            (attempt, max_txs)
         } else {
             let mut best_attempt = 0;
-            debug!(
+            let mut max_txs = 0;
+            info!(
                 "Consider {} in-flight Stacks tip(s)",
                 &last_mined_blocks.len()
             );
             for prev_block in last_mined_blocks.iter() {
-                debug!(
+                info!(
                     "Consider in-flight block {} on Stacks tip {}/{} in {} with {} txs",
                     &prev_block.anchored_block.block_hash(),
                     &prev_block.parent_consensus_hash,
@@ -1448,6 +1958,7 @@ impl BlockMinerThread {
                     &prev_block.my_burn_hash,
                     &prev_block.anchored_block.txs.len()
                 );
+                max_txs = cmp::max(max_txs, prev_block.anchored_block.txs.len());
 
                 if prev_block.anchored_block.txs.len() == 1 && prev_block.attempt == 1 {
                     // Don't let the fact that we've built an empty block during this sortition
@@ -1483,47 +1994,51 @@ impl BlockMinerThread {
                                         as usize)
                                         + 1)
                         {
-                            // the chain tip hasn't changed since we attempted to build a block.  Use what we
-                            // already have.
-                            debug!("Relayer: Stacks tip is unchanged since we last tried to mine a block off of {}/{} at height {} with {} txs, in {} at burn height {}, and no new microblocks ({} <= {} + 1)",
-                                   &prev_block.parent_consensus_hash, &prev_block.anchored_block.header.parent_block, prev_block.anchored_block.header.total_work.work,
-                                   prev_block.anchored_block.txs.len(), prev_block.my_burn_hash, parent_block_burn_height, stream.len(), prev_block.anchored_block.header.parent_microblock_sequence);
-
-                            return None;
+                            if !force {
+                                // the chain tip hasn't changed since we attempted to build a block.  Use what we
+                                // already have.
+                                info!("Relayer: Stacks tip is unchanged since we last tried to mine a block off of {}/{} at height {} with {} txs, in {} at burn height {}, and no new microblocks ({} <= {} + 1)",
+                                       &prev_block.parent_consensus_hash, &prev_block.anchored_block.header.parent_block, prev_block.anchored_block.header.total_work.work,
+                                       prev_block.anchored_block.txs.len(), prev_block.my_burn_hash, parent_block_burn_height, stream.len(), prev_block.anchored_block.header.parent_microblock_sequence);
+
+                                return None;
+                            }
                         } else {
                             // there are new microblocks!
                             // TODO: only consider rebuilding our anchored block if we (a) have
                             // time, and (b) the new microblocks are worth more than the new BTC
                             // fee minus the old BTC fee
-                            debug!("Relayer: Stacks tip is unchanged since we last tried to mine a block off of {}/{} at height {} with {} txs, in {} at burn height {}, but there are new microblocks ({} > {} + 1)",
+                            info!("Relayer: Stacks tip is unchanged since we last tried to mine a block off of {}/{} at height {} with {} txs, in {} at burn height {}, but there are new microblocks ({} > {} + 1)",
                                    &prev_block.parent_consensus_hash, &prev_block.anchored_block.header.parent_block, prev_block.anchored_block.header.total_work.work,
                                    prev_block.anchored_block.txs.len(), prev_block.my_burn_hash, parent_block_burn_height, stream.len(), prev_block.anchored_block.header.parent_microblock_sequence);
 
                             best_attempt = cmp::max(best_attempt, prev_block.attempt);
                         }
                     } else {
-                        // no microblock stream to confirm, and the stacks tip hasn't changed
-                        debug!("Relayer: Stacks tip is unchanged since we last tried to mine a block off of {}/{} at height {} with {} txs, in {} at burn height {}, and no microblocks present",
-                               &prev_block.parent_consensus_hash, &prev_block.anchored_block.header.parent_block, prev_block.anchored_block.header.total_work.work,
-                               prev_block.anchored_block.txs.len(), prev_block.my_burn_hash, parent_block_burn_height);
+                        if !force {
+                            // no microblock stream to confirm, and the stacks tip hasn't changed
+                            info!("Relayer: Stacks tip is unchanged since we last tried to mine a block off of {}/{} at height {} with {} txs, in {} at burn height {}, and no microblocks present",
+                                   &prev_block.parent_consensus_hash, &prev_block.anchored_block.header.parent_block, prev_block.anchored_block.header.total_work.work,
+                                   prev_block.anchored_block.txs.len(), prev_block.my_burn_hash, parent_block_burn_height);
 
-                        return None;
+                            return None;
+                        }
                     }
                 } else {
                     if self.burn_block.burn_header_hash == prev_block.my_burn_hash {
                         // only try and re-mine if there was no sortition since the last chain tip
-                        debug!("Relayer: Stacks tip has changed to {}/{} since we last tried to mine a block in {} at burn height {}; attempt was {} (for Stacks tip {}/{})",
+                        info!("Relayer: Stacks tip has changed to {}/{} since we last tried to mine a block in {} at burn height {}; attempt was {} (for Stacks tip {}/{})",
                                parent_consensus_hash, stacks_parent_header.anchored_header.block_hash(), prev_block.my_burn_hash, parent_block_burn_height, prev_block.attempt, &prev_block.parent_consensus_hash, &prev_block.anchored_block.header.parent_block);
                         best_attempt = cmp::max(best_attempt, prev_block.attempt);
                     } else {
-                        debug!("Relayer: Burn tip has changed to {} ({}) since we last tried to mine a block in {}",
+                        info!("Relayer: Burn tip has changed to {} ({}) since we last tried to mine a block in {}",
                                &self.burn_block.burn_header_hash, self.burn_block.block_height, &prev_block.my_burn_hash);
                     }
                 }
             }
-            best_attempt + 1
+            (best_attempt + 1, max_txs)
         };
-        Some(attempt)
+        Some((attempt, u64::try_from(max_txs).expect("too many txs")))
     }
 
     /// Generate the VRF proof for the block we're going to build.
@@ -1687,6 +2202,214 @@ impl BlockMinerThread {
         microblock_info_opt.map(|(stream, _)| stream)
     }
 
+    /// Get the list of possible burn addresses this miner is using
+    pub fn get_miner_addrs(config: &Config, keychain: &Keychain) -> Vec<String> {
+        let mut op_signer = keychain.generate_op_signer();
+        let mut btc_addrs = vec![
+            // legacy
+            BitcoinAddress::from_bytes_legacy(
+                config.burnchain.get_bitcoin_network().1,
+                LegacyBitcoinAddressType::PublicKeyHash,
+                &Hash160::from_data(&op_signer.get_public_key().to_bytes()).0,
+            )
+            .expect("FATAL: failed to construct legacy bitcoin address"),
+        ];
+        if config.miner.segwit {
+            btc_addrs.push(
+                // segwit p2wpkh
+                BitcoinAddress::from_bytes_segwit_p2wpkh(
+                    config.burnchain.get_bitcoin_network().1,
+                    &Hash160::from_data(&op_signer.get_public_key().to_bytes_compressed()).0,
+                )
+                .expect("FATAL: failed to construct segwit p2wpkh address"),
+            );
+        }
+        btc_addrs
+            .into_iter()
+            .map(|addr| format!("{}", &addr))
+            .collect()
+    }
+
+    /// Obtain the target burn fee cap, when considering how well this miner is performing.
+    pub fn get_mining_spend_amount<F, G>(
+        config: &Config,
+        keychain: &Keychain,
+        burnchain: &Burnchain,
+        sortdb: &SortitionDB,
+        recipients: &[PoxAddress],
+        start_mine_height: u64,
+        at_burn_block: Option<u64>,
+        mut get_prior_winning_prob: F,
+        mut set_prior_winning_prob: G,
+    ) -> u64
+    where
+        F: FnMut(u64) -> f64,
+        G: FnMut(u64, f64),
+    {
+        let config_file_burn_fee_cap = config.get_burnchain_config().burn_fee_cap;
+        let miner_config = config.get_miner_config();
+
+        if miner_config.target_win_probability < 0.00001 {
+            // this field is effectively zero
+            return config_file_burn_fee_cap;
+        }
+        let Some(miner_stats) = config.get_miner_stats() else {
+            return config_file_burn_fee_cap;
+        };
+
+        let Ok(tip) = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn()).map_err(|e| {
+            warn!("Failed to load canonical burn chain tip: {:?}", &e);
+            e
+        }) else {
+            return config_file_burn_fee_cap;
+        };
+        let tip = if let Some(at_burn_block) = at_burn_block.as_ref() {
+            let ih = sortdb.index_handle(&tip.sortition_id);
+            let Ok(Some(ancestor_tip)) = ih.get_block_snapshot_by_height(*at_burn_block) else {
+                warn!(
+                    "Failed to load ancestor tip at burn height {}",
+                    at_burn_block
+                );
+                return config_file_burn_fee_cap;
+            };
+            ancestor_tip
+        } else {
+            tip
+        };
+
+        let Ok(active_miners_and_commits) = MinerStats::get_active_miners(sortdb, at_burn_block)
+            .map_err(|e| {
+                warn!("Failed to get active miners: {:?}", &e);
+                e
+            })
+        else {
+            return config_file_burn_fee_cap;
+        };
+        if active_miners_and_commits.len() == 0 {
+            warn!("No active miners detected; using config file burn_fee_cap");
+            return config_file_burn_fee_cap;
+        }
+
+        let active_miners: Vec<_> = active_miners_and_commits
+            .iter()
+            .map(|(miner, _cmt)| miner.as_str())
+            .collect();
+
+        info!("Active miners: {:?}", &active_miners);
+
+        let Ok(unconfirmed_block_commits) = miner_stats
+            .get_unconfirmed_commits(tip.block_height + 1, &active_miners)
+            .map_err(|e| {
+                warn!("Failed to find unconfirmed block-commits: {}", &e);
+                e
+            })
+        else {
+            return config_file_burn_fee_cap;
+        };
+
+        let unconfirmed_miners_and_amounts: Vec<(String, u64)> = unconfirmed_block_commits
+            .iter()
+            .map(|cmt| (cmt.apparent_sender.to_string(), cmt.burn_fee))
+            .collect();
+
+        info!(
+            "Found unconfirmed block-commits: {:?}",
+            &unconfirmed_miners_and_amounts
+        );
+
+        let (spend_dist, _total_spend) = MinerStats::get_spend_distribution(
+            &active_miners_and_commits,
+            &unconfirmed_block_commits,
+            &recipients,
+        );
+        let win_probs = if miner_config.fast_rampup {
+            // look at spends 6+ blocks in the future
+            let win_probs = MinerStats::get_future_win_distribution(
+                &active_miners_and_commits,
+                &unconfirmed_block_commits,
+                &recipients,
+            );
+            win_probs
+        } else {
+            // look at the current spends
+            let Ok(unconfirmed_burn_dist) = miner_stats
+                .get_unconfirmed_burn_distribution(
+                    burnchain,
+                    sortdb,
+                    &active_miners_and_commits,
+                    unconfirmed_block_commits,
+                    recipients,
+                    at_burn_block,
+                )
+                .map_err(|e| {
+                    warn!("Failed to get unconfirmed burn distribution: {:?}", &e);
+                    e
+                })
+            else {
+                return config_file_burn_fee_cap;
+            };
+
+            let win_probs = MinerStats::burn_dist_to_prob_dist(&unconfirmed_burn_dist);
+            win_probs
+        };
+
+        info!("Unconfirmed spend distribution: {:?}", &spend_dist);
+        info!(
+            "Unconfirmed win probabilities (fast_rampup={}): {:?}",
+            miner_config.fast_rampup, &win_probs
+        );
+
+        let miner_addrs = Self::get_miner_addrs(config, keychain);
+        let win_prob = miner_addrs
+            .iter()
+            .find_map(|x| win_probs.get(x))
+            .copied()
+            .unwrap_or(0.0);
+
+        info!(
+            "This miner's win probability at {} is {}",
+            tip.block_height, &win_prob
+        );
+        set_prior_winning_prob(tip.block_height, win_prob);
+
+        if win_prob < config.miner.target_win_probability {
+            // no mining strategy is viable, so just quit.
+            // Unless we're spinning up, that is.
+            if start_mine_height + 6 < tip.block_height
+                && config.miner.underperform_stop_threshold.is_some()
+            {
+                let underperform_stop_threshold =
+                    config.miner.underperform_stop_threshold.unwrap_or(0);
+                info!(
+                    "Miner is spun up, but is not meeting target win probability as of {}",
+                    tip.block_height
+                );
+                // we've spun up and we're underperforming. How long do we tolerate this?
+                let mut underperformed_count = 0;
+                for depth in 0..underperform_stop_threshold {
+                    let prior_burn_height = tip.block_height.saturating_sub(depth);
+                    let prior_win_prob = get_prior_winning_prob(prior_burn_height);
+                    if prior_win_prob < config.miner.target_win_probability {
+                        info!(
+                            "Miner underperformed in block {} ({}/{})",
+                            prior_burn_height, underperformed_count, underperform_stop_threshold
+                        );
+                        underperformed_count += 1;
+                    }
+                }
+                if underperformed_count == underperform_stop_threshold {
+                    warn!(
+                        "Miner underperformed since burn height {}; spinning down",
+                        start_mine_height + 6 + underperform_stop_threshold
+                    );
+                    return 0;
+                }
+            }
+        }
+
+        config_file_burn_fee_cap
+    }
+
     /// Produce the block-commit for this anchored block, if we can.
     /// Returns the op on success
     /// Returns None if we fail somehow.
@@ -1716,15 +2439,6 @@ impl BlockMinerThread {
             }
         };
 
-        // let burn_fee_cap = self.config.burnchain.burn_fee_cap;
-        let burn_fee_cap = get_mining_spend_amount(self.globals.get_miner_status());
-        let sunset_burn = self.burnchain.expected_sunset_burn(
-            self.burn_block.block_height + 1,
-            burn_fee_cap,
-            target_epoch_id,
-        );
-        let rest_commit = burn_fee_cap - sunset_burn;
-
         let commit_outs = if !self
             .burnchain
             .pox_constants
@@ -1738,6 +2452,32 @@ impl BlockMinerThread {
             vec![PoxAddress::standard_burn_address(self.config.is_mainnet())]
         };
 
+        let burn_fee_cap = Self::get_mining_spend_amount(
+            &self.config,
+            &self.keychain,
+            &self.burnchain,
+            burn_db,
+            &commit_outs,
+            self.globals.get_start_mining_height(),
+            None,
+            |block_height| {
+                self.globals
+                    .get_estimated_win_prob(block_height)
+                    .unwrap_or(0.0)
+            },
+            |block_height, win_prob| self.globals.add_estimated_win_prob(block_height, win_prob),
+        );
+        if burn_fee_cap == 0 {
+            warn!("Calculated burn_fee_cap is 0; will not mine");
+            return None;
+        }
+        let sunset_burn = self.burnchain.expected_sunset_burn(
+            self.burn_block.block_height + 1,
+            burn_fee_cap,
+            target_epoch_id,
+        );
+        let rest_commit = burn_fee_cap - sunset_burn;
+
         // let's commit, but target the current burnchain tip with our modulus
         let op = self.inner_generate_block_commit_op(
             block_hash,
@@ -1840,6 +2580,19 @@ impl BlockMinerThread {
             self.ongoing_commit.clone(),
         );
 
+        let miner_config = self.config.get_miner_config();
+        let last_miner_config_opt = self.globals.get_last_miner_config();
+        let force_remine = if let Some(last_miner_config) = last_miner_config_opt {
+            last_miner_config != miner_config
+        } else {
+            false
+        };
+        if force_remine {
+            info!("Miner config changed; forcing a re-mine attempt");
+        }
+
+        self.globals.set_last_miner_config(miner_config);
+
         // NOTE: read-write access is needed in order to be able to query the recipient set.
         // This is an artifact of the way the MARF is built (see #1449)
         let mut burn_db =
@@ -1865,8 +2618,14 @@ impl BlockMinerThread {
                 .ok()?
                 .expect("FATAL: no epoch defined")
                 .epoch_id;
-        let mut parent_block_info = self.load_block_parent_info(&mut burn_db, &mut chain_state)?;
-        let attempt = self.get_mine_attempt(&chain_state, &parent_block_info)?;
+
+        let (Some(mut parent_block_info), _) =
+            self.load_block_parent_info(&mut burn_db, &mut chain_state)
+        else {
+            return None;
+        };
+        let (attempt, max_txs) =
+            self.get_mine_attempt(&chain_state, &parent_block_info, force_remine)?;
         let vrf_proof = self.make_vrf_proof()?;
 
         // Generates a new secret key for signing the trail of microblocks
@@ -1979,6 +2738,24 @@ impl BlockMinerThread {
             }
         };
 
+        let miner_config = self.config.get_miner_config();
+
+        if attempt > 1
+            && miner_config.min_tx_count > 0
+            && u64::try_from(anchored_block.txs.len()).expect("too many txs")
+                < miner_config.min_tx_count
+        {
+            info!("Relayer: Succeeded assembling subsequent block with {} txs, but expected at least {}", anchored_block.txs.len(), miner_config.min_tx_count);
+            return None;
+        }
+
+        if miner_config.only_increase_tx_count
+            && max_txs > u64::try_from(anchored_block.txs.len()).expect("too many txs")
+        {
+            info!("Relayer: Succeeded assembling subsequent block with {} txs, but had previously produced a block with {} txs", anchored_block.txs.len(), max_txs);
+            return None;
+        }
+
         info!(
             "Relayer: Succeeded assembling {} block #{}: {}, with {} txs, attempt {}",
             if parent_block_info.parent_block_total_burn == 0 {
@@ -2002,6 +2779,11 @@ impl BlockMinerThread {
             &vrf_proof,
             target_epoch_id,
         )?;
+        let burn_fee = if let BlockstackOperationType::LeaderBlockCommit(ref op) = &op {
+            op.burn_fee
+        } else {
+            0
+        };
 
         // last chance -- confirm that the stacks tip is unchanged (since it could have taken long
         // enough to build this block that another block could have arrived), and confirm that all
@@ -2009,10 +2791,13 @@ impl BlockMinerThread {
         let cur_burn_chain_tip = SortitionDB::get_canonical_burn_chain_tip(burn_db.conn())
             .expect("FATAL: failed to query sortition DB for canonical burn chain tip");
 
-        if let Some(stacks_tip) = chain_state
-            .get_stacks_chain_tip(&burn_db)
-            .expect("FATAL: could not query chain tip")
-        {
+        if let Some(stacks_tip) = Self::pick_best_tip(
+            &self.globals,
+            &self.config,
+            &mut burn_db,
+            &mut chain_state,
+            None,
+        ) {
             let is_miner_blocked = self
                 .globals
                 .get_miner_status()
@@ -2024,7 +2809,7 @@ impl BlockMinerThread {
                 &self.burnchain,
                 &burn_db,
                 &chain_state,
-                self.config.miner.unprocessed_block_deadline_secs,
+                miner_config.unprocessed_block_deadline_secs,
             );
             if stacks_tip.anchored_block_hash != anchored_block.header.parent_block
                 || parent_block_info.parent_consensus_hash != stacks_tip.consensus_hash
@@ -2032,7 +2817,7 @@ impl BlockMinerThread {
                 || is_miner_blocked
                 || has_unprocessed
             {
-                debug!(
+                info!(
                     "Relayer: Cancel block-commit; chain tip(s) have changed or cancelled";
                     "block_hash" => %anchored_block.block_hash(),
                     "tx_count" => anchored_block.txs.len(),
@@ -2059,8 +2844,9 @@ impl BlockMinerThread {
         }
 
         let mut op_signer = self.keychain.generate_op_signer();
-        debug!(
+        info!(
             "Relayer: Submit block-commit";
+            "burn_fee" => burn_fee,
             "block_hash" => %anchored_block.block_hash(),
             "tx_count" => anchored_block.txs.len(),
             "target_height" => anchored_block.header.total_work.work,
@@ -2379,8 +3165,6 @@ impl RelayerThread {
             );
             #[cfg(any(test, feature = "testing"))]
             {
-                use std::fs;
-                use std::io::Write;
                 use std::path::Path;
                 if let Ok(path) = std::env::var("STACKS_BAD_BLOCKS_DIR") {
                     // record this block somewhere
@@ -2986,11 +3770,13 @@ impl RelayerThread {
             return None;
         }
 
+        let miner_config = self.config.get_miner_config();
+
         let has_unprocessed = BlockMinerThread::unprocessed_blocks_prevent_mining(
             &self.burnchain,
             self.sortdb_ref(),
             self.chainstate_ref(),
-            self.config.miner.unprocessed_block_deadline_secs,
+            miner_config.unprocessed_block_deadline_secs,
         );
         if has_unprocessed {
             debug!(
@@ -3381,6 +4167,36 @@ impl RelayerThread {
         self.miner_thread.is_none()
     }
 
+    /// Try loading up a saved VRF key
+    pub(crate) fn load_saved_vrf_key(path: &str) -> Option<RegisteredKey> {
+        let mut f = match fs::File::open(path) {
+            Ok(f) => f,
+            Err(e) => {
+                warn!("Could not open {}: {:?}", &path, &e);
+                return None;
+            }
+        };
+        let mut registered_key_bytes = vec![];
+        if let Err(e) = f.read_to_end(&mut registered_key_bytes) {
+            warn!(
+                "Failed to read registered key bytes from {}: {:?}",
+                path, &e
+            );
+            return None;
+        }
+
+        let Ok(registered_key) = serde_json::from_slice(&registered_key_bytes) else {
+            warn!(
+                "Did not load registered key from {}: could not decode JSON",
+                &path
+            );
+            return None;
+        };
+
+        info!("Loaded registered key from {}", &path);
+        Some(registered_key)
+    }
+
     /// Top-level dispatcher
     pub fn handle_directive(&mut self, directive: RelayerDirective) -> bool {
         debug!("Relayer: received next directive");
@@ -3392,10 +4208,18 @@ impl RelayerThread {
                 true
             }
             RelayerDirective::RegisterKey(last_burn_block) => {
-                debug!("Relayer: directive Register VRF key");
-                self.rotate_vrf_and_register(&last_burn_block);
+                let mut saved_key_opt = None;
+                if let Some(path) = self.config.miner.activated_vrf_key_path.as_ref() {
+                    saved_key_opt = Self::load_saved_vrf_key(&path);
+                }
+                if let Some(saved_key) = saved_key_opt {
+                    self.globals.resume_leader_key(saved_key);
+                } else {
+                    debug!("Relayer: directive Register VRF key");
+                    self.rotate_vrf_and_register(&last_burn_block);
+                    debug!("Relayer: directive Registered VRF key");
+                }
                 self.globals.counters.bump_blocks_processed();
-                debug!("Relayer: directive Registered VRF key");
                 true
             }
             RelayerDirective::ProcessTenure(consensus_hash, burn_hash, block_header_hash) => {
@@ -4334,6 +5158,7 @@ impl StacksNode {
     /// Called from the main thread.
     pub fn process_burnchain_state(
         &mut self,
+        config: &Config,
         sortdb: &SortitionDB,
         sort_id: &SortitionId,
         ibd: bool,
@@ -4376,18 +5201,46 @@ impl StacksNode {
             SortitionDB::get_leader_keys_by_block(&ic, &block_snapshot.sortition_id)
                 .expect("Unexpected SortitionDB error fetching key registers");
 
-        let num_key_registers = key_registers.len();
-
-        self.globals
-            .try_activate_leader_key_registration(block_height, key_registers);
+        self.globals.set_last_sortition(block_snapshot);
+        let ret = last_sortitioned_block.map(|x| x.0);
 
+        let num_key_registers = key_registers.len();
         debug!(
             "Processed burnchain state at height {}: {} leader keys, {} block-commits (ibd = {})",
             block_height, num_key_registers, num_block_commits, ibd
         );
 
-        self.globals.set_last_sortition(block_snapshot);
-        last_sortitioned_block.map(|x| x.0)
+        // save the registered VRF key
+        let activated_key_opt = self
+            .globals
+            .try_activate_leader_key_registration(block_height, key_registers);
+
+        let Some(activated_key) = activated_key_opt else {
+            return ret;
+        };
+        let Some(path) = config.miner.activated_vrf_key_path.as_ref() else {
+            return ret;
+        };
+        info!("Activated VRF key; saving to {}", &path);
+        let Ok(key_json) = serde_json::to_string(&activated_key) else {
+            warn!("Failed to serialize VRF key");
+            return ret;
+        };
+        let mut f = match fs::File::create(&path) {
+            Ok(f) => f,
+            Err(e) => {
+                warn!("Failed to create {}: {:?}", &path, &e);
+                return ret;
+            }
+        };
+
+        if let Err(e) = f.write_all(key_json.as_str().as_bytes()) {
+            warn!("Failed to write activated VRF key to {}: {:?}", &path, &e);
+            return ret;
+        }
+
+        info!("Saved activated VRF key to {}", &path);
+        return ret;
     }
 
     /// Join all inner threads
diff --git a/testnet/stacks-node/src/run_loop/mod.rs b/testnet/stacks-node/src/run_loop/mod.rs
index bbee55f1e6..37d8ce1fa9 100644
--- a/testnet/stacks-node/src/run_loop/mod.rs
+++ b/testnet/stacks-node/src/run_loop/mod.rs
@@ -151,7 +151,7 @@ impl RunLoopCallbacks {
     }
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct RegisteredKey {
     /// burn block height we intended this VRF key register to land in
     pub target_block_height: u64,
diff --git a/testnet/stacks-node/src/run_loop/neon.rs b/testnet/stacks-node/src/run_loop/neon.rs
index 47b5df31ce..983fee7a27 100644
--- a/testnet/stacks-node/src/run_loop/neon.rs
+++ b/testnet/stacks-node/src/run_loop/neon.rs
@@ -628,11 +628,12 @@ impl RunLoop {
         sortdb: &SortitionDB,
         last_stacks_pox_reorg_recover_time: &mut u128,
     ) {
+        let miner_config = config.get_miner_config();
         let delay = cmp::max(
             config.node.chain_liveness_poll_time_secs,
             cmp::max(
-                config.miner.first_attempt_time_ms,
-                config.miner.subsequent_attempt_time_ms,
+                miner_config.first_attempt_time_ms,
+                miner_config.subsequent_attempt_time_ms,
             ) / 1000,
         );
 
@@ -748,11 +749,12 @@ impl RunLoop {
         last_burn_pox_reorg_recover_time: &mut u128,
         last_announce_time: &mut u128,
     ) {
+        let miner_config = config.get_miner_config();
         let delay = cmp::max(
             config.node.chain_liveness_poll_time_secs,
             cmp::max(
-                config.miner.first_attempt_time_ms,
-                config.miner.subsequent_attempt_time_ms,
+                miner_config.first_attempt_time_ms,
+                miner_config.subsequent_attempt_time_ms,
             ) / 1000,
         );
 
@@ -977,6 +979,7 @@ impl RunLoop {
             self.counters.clone(),
             self.pox_watchdog_comms.clone(),
             self.should_keep_running.clone(),
+            mine_start,
         );
         self.set_globals(globals.clone());
 
@@ -1165,7 +1168,12 @@ impl RunLoop {
                         let sortition_id = &block.sortition_id;
 
                         // Have the node process the new block, that can include, or not, a sortition.
-                        node.process_burnchain_state(burnchain.sortdb_mut(), sortition_id, ibd);
+                        node.process_burnchain_state(
+                            self.config(),
+                            burnchain.sortdb_mut(),
+                            sortition_id,
+                            ibd,
+                        );
 
                         // Now, tell the relayer to check if it won a sortition during this block,
                         // and, if so, to process and advertize the block.  This is basically a
@@ -1235,6 +1243,7 @@ impl RunLoop {
                     // once we've synced to the chain tip once, don't apply this check again.
                     //  this prevents a possible corner case in the event of a PoX fork.
                     mine_start = 0;
+                    globals.set_start_mining_height_if_zero(sortition_db_height);
 
                     // at tip, and not downloading. proceed to mine.
                     if last_tenure_sortition_height != sortition_db_height {
diff --git a/testnet/stacks-node/src/tests/bitcoin_regtest.rs b/testnet/stacks-node/src/tests/bitcoin_regtest.rs
index 2479a403cd..3814f7b880 100644
--- a/testnet/stacks-node/src/tests/bitcoin_regtest.rs
+++ b/testnet/stacks-node/src/tests/bitcoin_regtest.rs
@@ -142,7 +142,6 @@ fn bitcoind_integration(segwit_flag: bool) {
     conf.burnchain.password = Some("secret".to_string());
     conf.burnchain.local_mining_public_key = Some("04ee0b1602eb18fef7986887a7e8769a30c9df981d33c8380d255edef003abdcd243a0eb74afdf6740e6c423e62aec631519a24cf5b1d62bf8a3e06ddc695dcb77".to_string());
 
-    conf.miner.min_tx_fee = 0;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
     conf.miner.segwit = segwit_flag;
diff --git a/testnet/stacks-node/src/tests/epoch_205.rs b/testnet/stacks-node/src/tests/epoch_205.rs
index 7d8543bd58..b95ad46527 100644
--- a/testnet/stacks-node/src/tests/epoch_205.rs
+++ b/testnet/stacks-node/src/tests/epoch_205.rs
@@ -996,7 +996,6 @@ fn bigger_microblock_streams_in_2_05() {
     conf.node.max_microblocks = 65536;
     conf.burnchain.max_rbf = 1000000;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
diff --git a/testnet/stacks-node/src/tests/epoch_21.rs b/testnet/stacks-node/src/tests/epoch_21.rs
index 50b4fc2920..1b9b7d02f6 100644
--- a/testnet/stacks-node/src/tests/epoch_21.rs
+++ b/testnet/stacks-node/src/tests/epoch_21.rs
@@ -4987,7 +4987,6 @@ fn test_v1_unlock_height_with_current_stackers() {
     conf.node.wait_time_for_blocks = 1_000;
     conf.miner.wait_for_block_download = false;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -5249,7 +5248,6 @@ fn test_v1_unlock_height_with_delay_and_current_stackers() {
     conf.node.wait_time_for_blocks = 1_000;
     conf.miner.wait_for_block_download = false;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
diff --git a/testnet/stacks-node/src/tests/epoch_22.rs b/testnet/stacks-node/src/tests/epoch_22.rs
index 2a42c7f083..01e4e0f689 100644
--- a/testnet/stacks-node/src/tests/epoch_22.rs
+++ b/testnet/stacks-node/src/tests/epoch_22.rs
@@ -144,7 +144,6 @@ fn disable_pox() {
     conf.node.wait_time_for_blocks = 1_000;
     conf.miner.wait_for_block_download = false;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -674,7 +673,6 @@ fn pox_2_unlock_all() {
     conf.node.wait_time_for_blocks = 1_000;
     conf.miner.wait_for_block_download = false;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
diff --git a/testnet/stacks-node/src/tests/epoch_23.rs b/testnet/stacks-node/src/tests/epoch_23.rs
index 58313947d8..59bce72857 100644
--- a/testnet/stacks-node/src/tests/epoch_23.rs
+++ b/testnet/stacks-node/src/tests/epoch_23.rs
@@ -104,7 +104,6 @@ fn trait_invocation_behavior() {
     conf.node.wait_time_for_blocks = 1_000;
     conf.miner.wait_for_block_download = false;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
diff --git a/testnet/stacks-node/src/tests/epoch_24.rs b/testnet/stacks-node/src/tests/epoch_24.rs
index 854031eebc..3019047a37 100644
--- a/testnet/stacks-node/src/tests/epoch_24.rs
+++ b/testnet/stacks-node/src/tests/epoch_24.rs
@@ -38,13 +38,10 @@ use crate::tests::bitcoin_regtest::BitcoinCoreController;
 use crate::{neon, BitcoinRegtestController, BurnchainController};
 use stacks::clarity_cli::vm_execute as execute;
 use stacks::core;
-use stacks::core::{
-    StacksEpoch, PEER_VERSION_EPOCH_2_2, PEER_VERSION_EPOCH_2_3, PEER_VERSION_EPOCH_2_4,
-};
 use stacks_common::address::{AddressHashMode, C32_ADDRESS_VERSION_TESTNET_SINGLESIG};
 use stacks_common::codec::StacksMessageCodec;
 use stacks_common::consts::STACKS_EPOCH_MAX;
-use stacks_common::types::{Address, StacksEpochId};
+use stacks_common::types::Address;
 use stacks_common::util::sleep_ms;
 
 #[cfg(test)]
@@ -150,7 +147,6 @@ fn fix_to_pox_contract() {
     conf.node.wait_time_for_blocks = 1_000;
     conf.miner.wait_for_block_download = false;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -786,7 +782,6 @@ fn verify_auto_unlock_behavior() {
     conf.node.wait_time_for_blocks = 1_000;
     conf.miner.wait_for_block_download = false;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -1085,7 +1080,7 @@ fn verify_auto_unlock_behavior() {
 
     // Check that the "raw" reward sets for all cycles just contains entries for both addrs
     //  for the next few cycles.
-    for cycle_number in first_v3_cycle..(first_v3_cycle + 6) {
+    for _cycle_number in first_v3_cycle..(first_v3_cycle + 6) {
         let (mut chainstate, _) = StacksChainState::open(
             false,
             conf.burnchain.chain_id,
@@ -1171,7 +1166,7 @@ fn verify_auto_unlock_behavior() {
 
     // Check that the "raw" reward sets for all cycles just contains entries for the first
     //  address at the cycle start, since addr 2 was auto-unlocked.
-    for cycle_number in first_v3_cycle..(first_v3_cycle + 6) {
+    for _cycle_number in first_v3_cycle..(first_v3_cycle + 6) {
         let tip_info = get_chain_info(&conf);
         let tip_block_id =
             StacksBlockId::new(&tip_info.stacks_tip_consensus_hash, &tip_info.stacks_tip);
diff --git a/testnet/stacks-node/src/tests/integrations.rs b/testnet/stacks-node/src/tests/integrations.rs
index 5fe4efd252..734422e3df 100644
--- a/testnet/stacks-node/src/tests/integrations.rs
+++ b/testnet/stacks-node/src/tests/integrations.rs
@@ -186,7 +186,6 @@ fn integration_test_get_info() {
     });
 
     conf.burnchain.commit_anchor_block_within = 5000;
-    conf.miner.min_tx_fee = 0;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
diff --git a/testnet/stacks-node/src/tests/mod.rs b/testnet/stacks-node/src/tests/mod.rs
index 94d6401c52..d2af21db8a 100644
--- a/testnet/stacks-node/src/tests/mod.rs
+++ b/testnet/stacks-node/src/tests/mod.rs
@@ -1,3 +1,19 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020-2024 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+use std::collections::HashMap;
 use std::convert::TryInto;
 use std::sync::atomic::AtomicU64;
 use std::sync::Arc;
@@ -36,8 +52,12 @@ use stacks::core::StacksEpochExtension;
 use stacks::core::StacksEpochId;
 
 use super::burnchains::bitcoin_regtest_controller::ParsedUTXO;
+use super::neon_node::BlockMinerThread;
+use super::neon_node::TipCandidate;
 use super::Config;
 
+use stacks_common::types::chainstate::BlockHeaderHash;
+
 mod atlas;
 mod bitcoin_regtest;
 mod epoch_205;
@@ -521,8 +541,6 @@ fn should_succeed_mining_valid_txs() {
         100000,
     );
 
-    conf.miner.min_tx_fee = 0;
-
     let num_rounds = 6;
     let mut run_loop = RunLoop::new(conf.clone());
 
@@ -996,3 +1014,332 @@ fn test_btc_to_sat_errors() {
     assert!(ParsedUTXO::serialized_btc_to_sat("7.4e-7").is_none());
     assert!(ParsedUTXO::serialized_btc_to_sat("5.96e-6").is_none());
 }
+
+#[test]
+fn test_sort_and_populate_candidates() {
+    let empty: Vec<TipCandidate> = vec![];
+    assert_eq!(
+        empty,
+        BlockMinerThread::sort_and_populate_candidates(vec![])
+    );
+    let candidates = vec![
+        TipCandidate {
+            stacks_height: 1,
+            consensus_hash: ConsensusHash([0x01; 20]),
+            anchored_block_hash: BlockHeaderHash([0x01; 32]),
+            parent_consensus_hash: ConsensusHash([0x00; 20]),
+            parent_anchored_block_hash: BlockHeaderHash([0x00; 32]),
+            burn_height: 100,
+            num_earlier_siblings: 0,
+        },
+        TipCandidate {
+            stacks_height: 2,
+            consensus_hash: ConsensusHash([0x02; 20]),
+            anchored_block_hash: BlockHeaderHash([0x02; 32]),
+            parent_consensus_hash: ConsensusHash([0x01; 20]),
+            parent_anchored_block_hash: BlockHeaderHash([0x01; 32]),
+            burn_height: 102,
+            num_earlier_siblings: 0,
+        },
+        TipCandidate {
+            stacks_height: 2,
+            consensus_hash: ConsensusHash([0x12; 20]),
+            anchored_block_hash: BlockHeaderHash([0x12; 32]),
+            parent_consensus_hash: ConsensusHash([0x01; 20]),
+            parent_anchored_block_hash: BlockHeaderHash([0x01; 32]),
+            burn_height: 101,
+            num_earlier_siblings: 0,
+        },
+        TipCandidate {
+            stacks_height: 2,
+            consensus_hash: ConsensusHash([0x22; 20]),
+            anchored_block_hash: BlockHeaderHash([0x22; 32]),
+            parent_consensus_hash: ConsensusHash([0x01; 20]),
+            parent_anchored_block_hash: BlockHeaderHash([0x01; 32]),
+            burn_height: 104,
+            num_earlier_siblings: 0,
+        },
+        TipCandidate {
+            stacks_height: 4,
+            consensus_hash: ConsensusHash([0x04; 20]),
+            anchored_block_hash: BlockHeaderHash([0x04; 32]),
+            parent_consensus_hash: ConsensusHash([0x03; 20]),
+            parent_anchored_block_hash: BlockHeaderHash([0x03; 32]),
+            burn_height: 105,
+            num_earlier_siblings: 0,
+        },
+        TipCandidate {
+            stacks_height: 3,
+            consensus_hash: ConsensusHash([0x03; 20]),
+            anchored_block_hash: BlockHeaderHash([0x03; 32]),
+            parent_consensus_hash: ConsensusHash([0x02; 20]),
+            parent_anchored_block_hash: BlockHeaderHash([0x02; 32]),
+            burn_height: 105,
+            num_earlier_siblings: 0,
+        },
+    ];
+    let sorted_candidates = BlockMinerThread::sort_and_populate_candidates(candidates);
+    assert_eq!(
+        sorted_candidates,
+        vec![
+            TipCandidate {
+                stacks_height: 1,
+                consensus_hash: ConsensusHash([0x01; 20]),
+                anchored_block_hash: BlockHeaderHash([0x01; 32]),
+                parent_consensus_hash: ConsensusHash([0x00; 20]),
+                parent_anchored_block_hash: BlockHeaderHash([0x00; 32]),
+                burn_height: 100,
+                num_earlier_siblings: 0
+            },
+            TipCandidate {
+                stacks_height: 2,
+                consensus_hash: ConsensusHash([0x12; 20]),
+                anchored_block_hash: BlockHeaderHash([0x12; 32]),
+                parent_consensus_hash: ConsensusHash([0x01; 20]),
+                parent_anchored_block_hash: BlockHeaderHash([0x01; 32]),
+                burn_height: 101,
+                num_earlier_siblings: 0
+            },
+            TipCandidate {
+                stacks_height: 2,
+                consensus_hash: ConsensusHash([0x02; 20]),
+                anchored_block_hash: BlockHeaderHash([0x02; 32]),
+                parent_consensus_hash: ConsensusHash([0x01; 20]),
+                parent_anchored_block_hash: BlockHeaderHash([0x01; 32]),
+                burn_height: 102,
+                num_earlier_siblings: 1
+            },
+            TipCandidate {
+                stacks_height: 2,
+                consensus_hash: ConsensusHash([0x22; 20]),
+                anchored_block_hash: BlockHeaderHash([0x22; 32]),
+                parent_consensus_hash: ConsensusHash([0x01; 20]),
+                parent_anchored_block_hash: BlockHeaderHash([0x01; 32]),
+                burn_height: 104,
+                num_earlier_siblings: 2
+            },
+            TipCandidate {
+                stacks_height: 3,
+                consensus_hash: ConsensusHash([0x03; 20]),
+                anchored_block_hash: BlockHeaderHash([0x03; 32]),
+                parent_consensus_hash: ConsensusHash([0x02; 20]),
+                parent_anchored_block_hash: BlockHeaderHash([0x02; 32]),
+                burn_height: 105,
+                num_earlier_siblings: 0
+            },
+            TipCandidate {
+                stacks_height: 4,
+                consensus_hash: ConsensusHash([0x04; 20]),
+                anchored_block_hash: BlockHeaderHash([0x04; 32]),
+                parent_consensus_hash: ConsensusHash([0x03; 20]),
+                parent_anchored_block_hash: BlockHeaderHash([0x03; 32]),
+                burn_height: 105,
+                num_earlier_siblings: 0
+            }
+        ]
+    );
+}
+
+#[test]
+fn test_inner_pick_best_tip() {
+    // chain structure as folows:
+    //
+    // Bitcoin chain
+    // 100  101  102  103  104  105  106
+    //  |    |    |         |    |    |
+    // Stacks chain         |    |    |
+    //  1 <- 2    |         |.-- 3 <- 4
+    //    \       |         /
+    //     *----- 2 <------*|
+    //      \               |
+    //       *--------------2
+    //
+    // If there are no previous best-tips, then:
+    // At Bitcoin height 105, the best tip is (4,105)
+    // At Bitcoin height 104, the best tip is (3,104)
+    // At Bitcoin height 103, the best tip is (2,101)
+    // At Bitcoin height 102, the best tip is (2,101)
+    // At Bitcoin height 101, the best tip is (2,101)
+    // At Bitcoin height 100, the best tip is (1,100)
+    //
+    let candidates = vec![
+        TipCandidate {
+            stacks_height: 1,
+            consensus_hash: ConsensusHash([0x01; 20]),
+            anchored_block_hash: BlockHeaderHash([0x01; 32]),
+            parent_consensus_hash: ConsensusHash([0x00; 20]),
+            parent_anchored_block_hash: BlockHeaderHash([0x00; 32]),
+            burn_height: 100,
+            num_earlier_siblings: 0,
+        },
+        TipCandidate {
+            stacks_height: 2,
+            consensus_hash: ConsensusHash([0x02; 20]),
+            anchored_block_hash: BlockHeaderHash([0x02; 32]),
+            parent_consensus_hash: ConsensusHash([0x01; 20]),
+            parent_anchored_block_hash: BlockHeaderHash([0x01; 32]),
+            burn_height: 102,
+            num_earlier_siblings: 0,
+        },
+        TipCandidate {
+            stacks_height: 2,
+            consensus_hash: ConsensusHash([0x12; 20]),
+            anchored_block_hash: BlockHeaderHash([0x12; 32]),
+            parent_consensus_hash: ConsensusHash([0x01; 20]),
+            parent_anchored_block_hash: BlockHeaderHash([0x01; 32]),
+            burn_height: 101,
+            num_earlier_siblings: 0,
+        },
+        TipCandidate {
+            stacks_height: 2,
+            consensus_hash: ConsensusHash([0x22; 20]),
+            anchored_block_hash: BlockHeaderHash([0x22; 32]),
+            parent_consensus_hash: ConsensusHash([0x01; 20]),
+            parent_anchored_block_hash: BlockHeaderHash([0x01; 32]),
+            burn_height: 104,
+            num_earlier_siblings: 0,
+        },
+        TipCandidate {
+            stacks_height: 4,
+            consensus_hash: ConsensusHash([0x04; 20]),
+            anchored_block_hash: BlockHeaderHash([0x04; 32]),
+            parent_consensus_hash: ConsensusHash([0x03; 20]),
+            parent_anchored_block_hash: BlockHeaderHash([0x03; 32]),
+            burn_height: 106,
+            num_earlier_siblings: 0,
+        },
+        TipCandidate {
+            stacks_height: 3,
+            consensus_hash: ConsensusHash([0x03; 20]),
+            anchored_block_hash: BlockHeaderHash([0x03; 32]),
+            parent_consensus_hash: ConsensusHash([0x02; 20]),
+            parent_anchored_block_hash: BlockHeaderHash([0x02; 32]),
+            burn_height: 105,
+            num_earlier_siblings: 0,
+        },
+    ];
+
+    let sorted_candidates = BlockMinerThread::sort_and_populate_candidates(candidates.clone());
+    assert_eq!(
+        None,
+        BlockMinerThread::inner_pick_best_tip(vec![], HashMap::new())
+    );
+    assert_eq!(
+        Some(sorted_candidates[5].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates.clone(), HashMap::new())
+    );
+    assert_eq!(
+        Some(sorted_candidates[0].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..1].to_vec(), HashMap::new())
+    );
+    assert_eq!(
+        Some(sorted_candidates[1].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..2].to_vec(), HashMap::new())
+    );
+    assert_eq!(
+        Some(sorted_candidates[1].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..3].to_vec(), HashMap::new())
+    );
+    assert_eq!(
+        Some(sorted_candidates[1].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..4].to_vec(), HashMap::new())
+    );
+    assert_eq!(
+        Some(sorted_candidates[4].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..5].to_vec(), HashMap::new())
+    );
+
+    // suppose now that we previously picked (2,104) as the best-tip.
+    // No other tips at Stacks height 2 will be accepted, nor will those at heights 3 and 4 (since
+    // they descend from the wrong height-2 block).
+    let mut best_tips = HashMap::new();
+    best_tips.insert(2, sorted_candidates[3].clone());
+
+    assert_eq!(
+        Some(sorted_candidates[3].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates.clone(), best_tips.clone())
+    );
+    assert_eq!(
+        Some(sorted_candidates[0].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..1].to_vec(), best_tips.clone())
+    );
+    assert_eq!(
+        None,
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..2].to_vec(), best_tips.clone())
+    );
+    assert_eq!(
+        None,
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..3].to_vec(), best_tips.clone())
+    );
+    assert_eq!(
+        Some(sorted_candidates[3].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..4].to_vec(), best_tips.clone())
+    );
+    assert_eq!(
+        Some(sorted_candidates[3].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..5].to_vec(), best_tips.clone())
+    );
+
+    // now suppose that we previously picked (2,102) as the best-tip.
+    // Conflicting blocks are (2,101) and (2,104)
+    let mut best_tips = HashMap::new();
+    best_tips.insert(2, sorted_candidates[2].clone());
+
+    assert_eq!(
+        Some(sorted_candidates[5].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates.clone(), best_tips.clone())
+    );
+    assert_eq!(
+        Some(sorted_candidates[0].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..1].to_vec(), best_tips.clone())
+    );
+    assert_eq!(
+        None,
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..2].to_vec(), best_tips.clone())
+    );
+    assert_eq!(
+        Some(sorted_candidates[2].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..3].to_vec(), best_tips.clone())
+    );
+    assert_eq!(
+        Some(sorted_candidates[2].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..4].to_vec(), best_tips.clone())
+    );
+    assert_eq!(
+        Some(sorted_candidates[4].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..5].to_vec(), best_tips.clone())
+    );
+
+    // now suppose that we previously picked both (2,101) and (3,105) as the best-tips.
+    // these best-tips are in conflict, but that shouldn't prohibit us from choosing (4,106) as the
+    // best tip even though it doesn't confirm (2,101).  However, it would mean that (2,102) and
+    // (2,104) are in conflict.
+    let mut best_tips = HashMap::new();
+    best_tips.insert(2, sorted_candidates[1].clone());
+    best_tips.insert(3, sorted_candidates[4].clone());
+
+    assert_eq!(
+        Some(sorted_candidates[5].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates.clone(), best_tips.clone())
+    );
+    assert_eq!(
+        Some(sorted_candidates[0].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..1].to_vec(), best_tips.clone())
+    );
+    assert_eq!(
+        Some(sorted_candidates[1].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..2].to_vec(), best_tips.clone())
+    );
+    assert_eq!(
+        Some(sorted_candidates[1].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..3].to_vec(), best_tips.clone())
+    );
+    assert_eq!(
+        Some(sorted_candidates[1].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..4].to_vec(), best_tips.clone())
+    );
+    assert_eq!(
+        Some(sorted_candidates[1].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..5].to_vec(), best_tips.clone())
+    );
+}
diff --git a/testnet/stacks-node/src/tests/neon_integrations.rs b/testnet/stacks-node/src/tests/neon_integrations.rs
index a197523af6..312e1bf622 100644
--- a/testnet/stacks-node/src/tests/neon_integrations.rs
+++ b/testnet/stacks-node/src/tests/neon_integrations.rs
@@ -1,83 +1,61 @@
-use std::cmp;
-use std::fs;
+use std::collections::{HashMap, HashSet};
+use std::convert::TryFrom;
 use std::path::Path;
-use std::sync::mpsc;
-use std::sync::Arc;
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::{mpsc, Arc};
 use std::time::{Duration, Instant};
-use std::{
-    collections::HashMap,
-    collections::HashSet,
-    sync::atomic::{AtomicU64, Ordering},
-};
-use std::{env, thread};
+use std::{cmp, env, fs, thread};
 
+use clarity::vm::ast::stack_depth_checker::AST_CALL_STACK_DEPTH_BUFFER;
+use clarity::vm::ast::ASTRules;
+use clarity::vm::MAX_CALL_STACK_DEPTH;
+use rand::Rng;
 use rusqlite::types::ToSql;
-
 use stacks::burnchains::bitcoin::address::{BitcoinAddress, LegacyBitcoinAddressType};
 use stacks::burnchains::bitcoin::BitcoinNetworkType;
-use stacks::burnchains::Txid;
+use stacks::burnchains::db::BurnchainDB;
+use stacks::burnchains::{Address, Burnchain, PoxConstants, Txid};
+use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::burn::operations::{
     BlockstackOperationType, DelegateStxOp, PreStxOp, TransferStxOp,
 };
+use stacks::chainstate::burn::ConsensusHash;
 use stacks::chainstate::coordinator::comm::CoordinatorChannels;
+use stacks::chainstate::stacks::db::StacksChainState;
+use stacks::chainstate::stacks::miner::{
+    signal_mining_blocked, signal_mining_ready, TransactionErrorEvent, TransactionEvent,
+    TransactionSuccessEvent,
+};
+use stacks::chainstate::stacks::{
+    StacksBlock, StacksBlockHeader, StacksMicroblock, StacksMicroblockHeader, StacksPrivateKey,
+    StacksPublicKey, StacksTransaction, TransactionContractCall, TransactionPayload,
+};
 use stacks::clarity_cli::vm_execute as execute;
 use stacks::codec::StacksMessageCodec;
 use stacks::core;
 use stacks::core::{
-    StacksEpoch, StacksEpochId, BLOCK_LIMIT_MAINNET_20, BLOCK_LIMIT_MAINNET_205,
-    BLOCK_LIMIT_MAINNET_21, CHAIN_ID_TESTNET, HELIUM_BLOCK_LIMIT_20, PEER_VERSION_EPOCH_1_0,
-    PEER_VERSION_EPOCH_2_0, PEER_VERSION_EPOCH_2_05, PEER_VERSION_EPOCH_2_1,
+    mempool::MemPoolWalkTxTypes, StacksEpoch, StacksEpochId, BLOCK_LIMIT_MAINNET_20,
+    BLOCK_LIMIT_MAINNET_205, BLOCK_LIMIT_MAINNET_21, CHAIN_ID_TESTNET, HELIUM_BLOCK_LIMIT_20,
+    PEER_VERSION_EPOCH_1_0, PEER_VERSION_EPOCH_2_0, PEER_VERSION_EPOCH_2_05,
+    PEER_VERSION_EPOCH_2_1,
 };
 use stacks::net::atlas::{AtlasConfig, AtlasDB, MAX_ATTACHMENT_INV_PAGES_PER_REQUEST};
 use stacks::net::{
     AccountEntryResponse, ContractSrcResponse, GetAttachmentResponse, GetAttachmentsInvResponse,
-    PostTransactionRequestBody, RPCPeerInfoData, StacksBlockAcceptedData,
-    UnconfirmedTransactionResponse,
+    PostTransactionRequestBody, RPCFeeEstimateResponse, RPCPeerInfoData, RPCPoxInfoData,
+    StacksBlockAcceptedData, UnconfirmedTransactionResponse,
 };
 use stacks::types::chainstate::{
     BlockHeaderHash, BurnchainHeaderHash, StacksAddress, StacksBlockId,
 };
-use stacks::util::hash::Hash160;
-use stacks::util::hash::{bytes_to_hex, hex_bytes, to_hex};
+use stacks::util::hash::{bytes_to_hex, hex_bytes, to_hex, Hash160};
 use stacks::util::secp256k1::Secp256k1PublicKey;
 use stacks::util::{get_epoch_time_ms, get_epoch_time_secs, sleep_ms};
 use stacks::util_lib::boot::boot_code_id;
+use stacks::util_lib::db::{query_row_columns, query_rows, u64_to_sql};
+use stacks::vm::costs::ExecutionCost;
 use stacks::vm::types::PrincipalData;
-use stacks::vm::ClarityVersion;
-use stacks::vm::Value;
-use stacks::{
-    burnchains::db::BurnchainDB,
-    chainstate::{burn::ConsensusHash, stacks::StacksMicroblock},
-};
-use stacks::{
-    burnchains::{Address, Burnchain, PoxConstants},
-    vm::costs::ExecutionCost,
-};
-use stacks::{
-    chainstate::stacks::{
-        db::StacksChainState, StacksBlock, StacksBlockHeader, StacksMicroblockHeader,
-        StacksPrivateKey, StacksPublicKey, StacksTransaction, TransactionContractCall,
-        TransactionPayload,
-    },
-    net::RPCPoxInfoData,
-    util_lib::db::query_row_columns,
-    util_lib::db::query_rows,
-    util_lib::db::u64_to_sql,
-};
-
-use crate::{
-    burnchains::bitcoin_regtest_controller::UTXO, config::EventKeyType,
-    config::EventObserverConfig, config::InitialBalance, neon, operations::BurnchainOpSigner,
-    syncctl::PoxSyncWatchdogComms, BitcoinRegtestController, BurnchainController, Config,
-    ConfigFile, Keychain,
-};
-
-use crate::util::hash::{MerkleTree, Sha512Trunc256Sum};
-use crate::util::secp256k1::MessageSignature;
-
-use crate::neon_node::StacksNode;
-
-use rand::Rng;
+use stacks::vm::{ClarityName, ClarityVersion, ContractName, Value};
 
 use super::bitcoin_regtest::BitcoinCoreController;
 use super::{
@@ -85,23 +63,16 @@ use super::{
     make_microblock, make_stacks_transfer, make_stacks_transfer_mblock_only, to_addr, ADDR_4, SK_1,
     SK_2,
 };
-
-use crate::config::FeeEstimatorName;
-use crate::tests::SK_3;
-use clarity::vm::ast::stack_depth_checker::AST_CALL_STACK_DEPTH_BUFFER;
-use clarity::vm::ast::ASTRules;
-use clarity::vm::MAX_CALL_STACK_DEPTH;
-use stacks::chainstate::burn::db::sortdb::SortitionDB;
-use stacks::chainstate::stacks::miner::{
-    signal_mining_blocked, signal_mining_ready, TransactionErrorEvent, TransactionEvent,
-    TransactionSuccessEvent,
-};
-use stacks::net::RPCFeeEstimateResponse;
-use stacks::vm::ClarityName;
-use stacks::vm::ContractName;
-use std::convert::TryFrom;
-
+use crate::burnchains::bitcoin_regtest_controller::UTXO;
+use crate::config::{EventKeyType, EventObserverConfig, FeeEstimatorName, InitialBalance};
+use crate::neon_node::{RelayerThread, StacksNode};
+use crate::operations::BurnchainOpSigner;
 use crate::stacks_common::types::PrivateKey;
+use crate::syncctl::PoxSyncWatchdogComms;
+use crate::tests::SK_3;
+use crate::util::hash::{MerkleTree, Sha512Trunc256Sum};
+use crate::util::secp256k1::MessageSignature;
+use crate::{neon, BitcoinRegtestController, BurnchainController, Config, ConfigFile, Keychain};
 
 fn inner_neon_integration_test_conf(seed: Option<Vec<u8>>) -> (Config, StacksAddress) {
     let mut conf = super::new_test_conf();
@@ -170,7 +141,6 @@ fn inner_neon_integration_test_conf(seed: Option<Vec<u8>>) -> (Config, StacksAdd
     conf.burnchain.poll_time_secs = 1;
     conf.node.pox_sync_sample_secs = 0;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -201,9 +171,8 @@ pub mod test_observer {
     use std::sync::Mutex;
     use std::thread;
 
-    use tokio;
-    use warp;
     use warp::Filter;
+    use {tokio, warp};
 
     use crate::event_dispatcher::{MinedBlockEvent, MinedMicroblockEvent};
 
@@ -2339,7 +2308,6 @@ fn microblock_fork_poison_integration_test() {
     conf.miner.subsequent_attempt_time_ms = 5_000;
     conf.node.wait_time_for_blocks = 1_000;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -3087,9 +3055,6 @@ fn filter_low_fee_tx_integration_test() {
         });
     }
 
-    // exclude the first 5 transactions from miner consideration
-    conf.miner.min_tx_fee = 1500;
-
     let mut btcd_controller = BitcoinCoreController::new(conf.clone());
     btcd_controller
         .start_bitcoind()
@@ -3177,9 +3142,6 @@ fn filter_long_runtime_tx_integration_test() {
         });
     }
 
-    // all transactions have high-enough fees...
-    conf.miner.min_tx_fee = 1;
-
     // ...but none of them will be mined since we allot zero ms to do so
     conf.miner.first_attempt_time_ms = 0;
     conf.miner.subsequent_attempt_time_ms = 0;
@@ -3258,8 +3220,6 @@ fn miner_submit_twice() {
         amount: 1049230,
     });
 
-    // all transactions have high-enough fees...
-    conf.miner.min_tx_fee = 1;
     conf.node.mine_microblocks = false;
     // one should be mined in first attempt, and two should be in second attempt
     conf.miner.first_attempt_time_ms = 20;
@@ -3379,7 +3339,6 @@ fn size_check_integration_test() {
     conf.node.microblock_frequency = 5000;
     conf.miner.microblock_attempt_time_ms = 120_000;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -3556,7 +3515,6 @@ fn size_overflow_unconfirmed_microblocks_integration_test() {
     conf.node.microblock_frequency = 5_000;
     conf.miner.microblock_attempt_time_ms = 120_000;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -3753,7 +3711,6 @@ fn size_overflow_unconfirmed_stream_microblocks_integration_test() {
     conf.node.max_microblocks = 65536;
     conf.burnchain.max_rbf = 1000000;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -3948,7 +3905,6 @@ fn size_overflow_unconfirmed_invalid_stream_microblocks_integration_test() {
     epochs[1].block_limit = core::BLOCK_LIMIT_MAINNET_20;
     conf.burnchain.epochs = Some(epochs);
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -4211,7 +4167,6 @@ fn runtime_overflow_unconfirmed_microblocks_integration_test() {
     conf.node.microblock_frequency = 15000;
     conf.miner.microblock_attempt_time_ms = 120_000;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -4387,7 +4342,6 @@ fn block_replay_integration_test() {
     conf.node.wait_time_for_microblocks = 30000;
     conf.node.microblock_frequency = 5_000;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -4838,7 +4792,6 @@ fn mining_events_integration_test() {
     conf.node.wait_time_for_microblocks = 1000;
     conf.node.microblock_frequency = 1000;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -5086,7 +5039,6 @@ fn block_limit_hit_integration_test() {
     conf.node.wait_time_for_microblocks = 30000;
     conf.node.microblock_frequency = 1000;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -5304,7 +5256,6 @@ fn microblock_limit_hit_integration_test() {
     conf.burnchain.max_rbf = 10_000_000;
     conf.node.wait_time_for_blocks = 1_000;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -5516,7 +5467,6 @@ fn block_large_tx_integration_test() {
     conf.burnchain.max_rbf = 10_000_000;
     conf.node.wait_time_for_blocks = 1_000;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -5651,7 +5601,6 @@ fn microblock_large_tx_integration_test_FLAKY() {
     conf.node.wait_time_for_microblocks = 30000;
     conf.node.microblock_frequency = 1000;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -10730,3 +10679,336 @@ fn microblock_miner_multiple_attempts() {
 
     channel.stop_chains_coordinator();
 }
+
+#[test]
+#[ignore]
+fn min_txs() {
+    if env::var("BITCOIND_TEST") != Ok("1".into()) {
+        return;
+    }
+
+    let spender_sk = StacksPrivateKey::new();
+    let spender_addr = to_addr(&spender_sk);
+    let spender_princ: PrincipalData = spender_addr.into();
+
+    let (mut conf, _miner_account) = neon_integration_test_conf();
+
+    test_observer::spawn();
+
+    conf.events_observers.push(EventObserverConfig {
+        endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
+        events_keys: vec![EventKeyType::AnyEvent],
+    });
+
+    conf.miner.min_tx_count = 4;
+    conf.miner.first_attempt_time_ms = 0;
+    conf.miner.activated_vrf_key_path = Some("/tmp/activate_vrf_key.min_txs.json".to_string());
+
+    if fs::metadata("/tmp/activate_vrf_key.min_txs.json").is_ok() {
+        fs::remove_file("/tmp/activate_vrf_key.min_txs.json").unwrap();
+    }
+
+    let spender_bal = 10_000_000_000 * (core::MICROSTACKS_PER_STACKS as u64);
+
+    conf.initial_balances.push(InitialBalance {
+        address: spender_princ.clone(),
+        amount: spender_bal,
+    });
+
+    let mut btcd_controller = BitcoinCoreController::new(conf.clone());
+    btcd_controller
+        .start_bitcoind()
+        .map_err(|_e| ())
+        .expect("Failed starting bitcoind");
+
+    let burnchain_config = Burnchain::regtest(&conf.get_burn_db_path());
+
+    let mut btc_regtest_controller = BitcoinRegtestController::with_burnchain(
+        conf.clone(),
+        None,
+        Some(burnchain_config.clone()),
+        None,
+    );
+    let http_origin = format!("http://{}", &conf.node.rpc_bind);
+
+    btc_regtest_controller.bootstrap_chain(201);
+
+    eprintln!("Chain bootstrapped...");
+
+    let mut run_loop = neon::RunLoop::new(conf.clone());
+    let blocks_processed = run_loop.get_blocks_processed_arc();
+    let _client = reqwest::blocking::Client::new();
+    let channel = run_loop.get_coordinator_channel().unwrap();
+
+    thread::spawn(move || run_loop.start(Some(burnchain_config), 0));
+
+    // give the run loop some time to start up!
+    wait_for_runloop(&blocks_processed);
+
+    // first block wakes up the run loop
+    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+
+    // first block will hold our VRF registration
+    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+
+    // second block will be the first mined Stacks block
+    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+
+    let _sort_height = channel.get_sortitions_processed();
+
+    for i in 0..2 {
+        let code = format!("(print \"hello world {}\")", i);
+        let publish = make_contract_publish(
+            &spender_sk,
+            i as u64,
+            1000,
+            &format!("test-publish-{}", &i),
+            &code,
+        );
+        submit_tx(&http_origin, &publish);
+
+        debug!("Try to build too-small a block {}", &i);
+        next_block_and_wait_with_timeout(&mut btc_regtest_controller, &blocks_processed, 15);
+    }
+
+    let blocks = test_observer::get_blocks();
+    for block in blocks {
+        let transactions = block.get("transactions").unwrap().as_array().unwrap();
+        if transactions.len() > 1 {
+            debug!("Got block: {:?}", &block);
+            assert!(transactions.len() >= 4);
+        }
+    }
+
+    let saved_vrf_key = RelayerThread::load_saved_vrf_key("/tmp/activate_vrf_key.min_txs.json");
+    assert!(saved_vrf_key.is_some());
+
+    test_observer::clear();
+}
+
+#[test]
+#[ignore]
+fn filter_txs_by_type() {
+    if env::var("BITCOIND_TEST") != Ok("1".into()) {
+        return;
+    }
+
+    let spender_sk = StacksPrivateKey::new();
+    let spender_addr = to_addr(&spender_sk);
+    let spender_princ: PrincipalData = spender_addr.into();
+
+    let (mut conf, _miner_account) = neon_integration_test_conf();
+
+    test_observer::spawn();
+
+    conf.events_observers.push(EventObserverConfig {
+        endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
+        events_keys: vec![EventKeyType::AnyEvent],
+    });
+
+    conf.miner.min_tx_count = 4;
+    conf.miner.first_attempt_time_ms = 0;
+    conf.miner.activated_vrf_key_path = Some("/tmp/activate_vrf_key.filter_txs.json".to_string());
+    conf.miner.txs_to_consider = [MemPoolWalkTxTypes::TokenTransfer].into_iter().collect();
+
+    if fs::metadata("/tmp/activate_vrf_key.filter_txs.json").is_ok() {
+        fs::remove_file("/tmp/activate_vrf_key.filter_txs.json").unwrap();
+    }
+
+    let spender_bal = 10_000_000_000 * (core::MICROSTACKS_PER_STACKS as u64);
+
+    conf.initial_balances.push(InitialBalance {
+        address: spender_princ.clone(),
+        amount: spender_bal,
+    });
+
+    let mut btcd_controller = BitcoinCoreController::new(conf.clone());
+    btcd_controller
+        .start_bitcoind()
+        .map_err(|_e| ())
+        .expect("Failed starting bitcoind");
+
+    let burnchain_config = Burnchain::regtest(&conf.get_burn_db_path());
+
+    let mut btc_regtest_controller = BitcoinRegtestController::with_burnchain(
+        conf.clone(),
+        None,
+        Some(burnchain_config.clone()),
+        None,
+    );
+    let http_origin = format!("http://{}", &conf.node.rpc_bind);
+
+    btc_regtest_controller.bootstrap_chain(201);
+
+    eprintln!("Chain bootstrapped...");
+
+    let mut run_loop = neon::RunLoop::new(conf.clone());
+    let blocks_processed = run_loop.get_blocks_processed_arc();
+    let _client = reqwest::blocking::Client::new();
+    let channel = run_loop.get_coordinator_channel().unwrap();
+
+    thread::spawn(move || run_loop.start(Some(burnchain_config), 0));
+
+    // give the run loop some time to start up!
+    wait_for_runloop(&blocks_processed);
+
+    // first block wakes up the run loop
+    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+
+    // first block will hold our VRF registration
+    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+
+    // second block will be the first mined Stacks block
+    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+
+    let _sort_height = channel.get_sortitions_processed();
+    let mut sent_txids = HashSet::new();
+    for i in 0..2 {
+        let code = format!("(print \"hello world {}\")", i);
+        let publish = make_contract_publish(
+            &spender_sk,
+            i as u64,
+            1000,
+            &format!("test-publish-{}", &i),
+            &code,
+        );
+        let parsed = StacksTransaction::consensus_deserialize(&mut &publish[..]).unwrap();
+        sent_txids.insert(parsed.txid());
+
+        submit_tx(&http_origin, &publish);
+        next_block_and_wait_with_timeout(&mut btc_regtest_controller, &blocks_processed, 15);
+    }
+
+    let blocks = test_observer::get_blocks();
+    for block in blocks {
+        info!("block: {:?}", &block);
+        let transactions = block.get("transactions").unwrap().as_array().unwrap();
+        for tx in transactions {
+            let raw_tx = tx.get("raw_tx").unwrap().as_str().unwrap();
+            if raw_tx == "0x00" {
+                continue;
+            }
+            let tx_bytes = hex_bytes(&raw_tx[2..]).unwrap();
+            let parsed = StacksTransaction::consensus_deserialize(&mut &tx_bytes[..]).unwrap();
+            if sent_txids.contains(&parsed.txid()) {
+                panic!("Included a smart contract");
+            }
+        }
+    }
+
+    let saved_vrf_key = RelayerThread::load_saved_vrf_key("/tmp/activate_vrf_key.filter_txs.json");
+    assert!(saved_vrf_key.is_some());
+
+    test_observer::clear();
+}
+
+#[test]
+#[ignore]
+fn filter_txs_by_origin() {
+    if env::var("BITCOIND_TEST") != Ok("1".into()) {
+        return;
+    }
+
+    let spender_sk = StacksPrivateKey::new();
+    let spender_addr = to_addr(&spender_sk);
+    let spender_princ: PrincipalData = spender_addr.into();
+
+    let (mut conf, _miner_account) = neon_integration_test_conf();
+
+    test_observer::spawn();
+
+    conf.events_observers.push(EventObserverConfig {
+        endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
+        events_keys: vec![EventKeyType::AnyEvent],
+    });
+
+    conf.miner.min_tx_count = 4;
+    conf.miner.first_attempt_time_ms = 0;
+    conf.miner.filter_origins =
+        [StacksAddress::from_string("STA2MZWV9N67TBYVWTE0PSSKMJ2F6YXW7DX96QAM").unwrap()]
+            .into_iter()
+            .collect();
+
+    let spender_bal = 10_000_000_000 * (core::MICROSTACKS_PER_STACKS as u64);
+
+    conf.initial_balances.push(InitialBalance {
+        address: spender_princ.clone(),
+        amount: spender_bal,
+    });
+
+    let mut btcd_controller = BitcoinCoreController::new(conf.clone());
+    btcd_controller
+        .start_bitcoind()
+        .map_err(|_e| ())
+        .expect("Failed starting bitcoind");
+
+    let burnchain_config = Burnchain::regtest(&conf.get_burn_db_path());
+
+    let mut btc_regtest_controller = BitcoinRegtestController::with_burnchain(
+        conf.clone(),
+        None,
+        Some(burnchain_config.clone()),
+        None,
+    );
+    let http_origin = format!("http://{}", &conf.node.rpc_bind);
+
+    btc_regtest_controller.bootstrap_chain(201);
+
+    eprintln!("Chain bootstrapped...");
+
+    let mut run_loop = neon::RunLoop::new(conf.clone());
+    let blocks_processed = run_loop.get_blocks_processed_arc();
+    let _client = reqwest::blocking::Client::new();
+    let channel = run_loop.get_coordinator_channel().unwrap();
+
+    thread::spawn(move || run_loop.start(Some(burnchain_config), 0));
+
+    // give the run loop some time to start up!
+    wait_for_runloop(&blocks_processed);
+
+    // first block wakes up the run loop
+    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+
+    // first block will hold our VRF registration
+    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+
+    // second block will be the first mined Stacks block
+    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+
+    let _sort_height = channel.get_sortitions_processed();
+    let mut sent_txids = HashSet::new();
+    for i in 0..2 {
+        let code = format!("(print \"hello world {}\")", i);
+        let publish = make_contract_publish(
+            &spender_sk,
+            i as u64,
+            1000,
+            &format!("test-publish-{}", &i),
+            &code,
+        );
+        let parsed = StacksTransaction::consensus_deserialize(&mut &publish[..]).unwrap();
+        sent_txids.insert(parsed.txid());
+
+        submit_tx(&http_origin, &publish);
+        next_block_and_wait_with_timeout(&mut btc_regtest_controller, &blocks_processed, 15);
+    }
+
+    let blocks = test_observer::get_blocks();
+    for block in blocks {
+        info!("block: {:?}", &block);
+        let transactions = block.get("transactions").unwrap().as_array().unwrap();
+        for tx in transactions {
+            let raw_tx = tx.get("raw_tx").unwrap().as_str().unwrap();
+            if raw_tx == "0x00" {
+                continue;
+            }
+            let tx_bytes = hex_bytes(&raw_tx[2..]).unwrap();
+            let parsed = StacksTransaction::consensus_deserialize(&mut &tx_bytes[..]).unwrap();
+            if sent_txids.contains(&parsed.txid()) {
+                panic!("Included a smart contract");
+            }
+        }
+    }
+
+    test_observer::clear();
+}

From 924ac90b80ea62ba8226d1d9da0e1f70fb2f1ead Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 16 Jan 2024 22:49:08 -0500
Subject: [PATCH 0385/1166] fix: input_index, not input_vout

---
 testnet/stacks-node/src/chain_data.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/testnet/stacks-node/src/chain_data.rs b/testnet/stacks-node/src/chain_data.rs
index 92b22a5a6c..bd9e9e6173 100644
--- a/testnet/stacks-node/src/chain_data.rs
+++ b/testnet/stacks-node/src/chain_data.rs
@@ -56,7 +56,7 @@ struct UnconfirmedBlockCommit {
     /// PoX payouts
     pox_addrs: Vec<String>,
     /// UTXO spent to create this block-commit
-    input_vout: u32,
+    input_index: u32,
     input_txid: String,
     /// transaction ID
     txid: String,
@@ -294,7 +294,7 @@ impl MinerStats {
                 memo: vec![],
                 commit_outs: decoded_pox_addrs,
                 burn_fee: unconfirmed_commit.burn,
-                input: (input_txid, unconfirmed_commit.input_vout),
+                input: (input_txid, unconfirmed_commit.input_index),
                 apparent_sender: BurnchainSigner(unconfirmed_commit.address),
                 txid,
                 vtxindex: 1,

From 8c70e985c6b1ba05e48aa0d4a309296ab17a21ec Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Wed, 17 Jan 2024 07:38:06 -0500
Subject: [PATCH 0386/1166] fix: reset `consider_no_estimate_tx_prob` to 5 in
 `zero`

---
 src/core/mempool.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/core/mempool.rs b/src/core/mempool.rs
index 9287fcd519..aba585044f 100644
--- a/src/core/mempool.rs
+++ b/src/core/mempool.rs
@@ -376,7 +376,7 @@ impl MemPoolWalkSettings {
     pub fn zero() -> MemPoolWalkSettings {
         MemPoolWalkSettings {
             max_walk_time_ms: u64::max_value(),
-            consider_no_estimate_tx_prob: 25,
+            consider_no_estimate_tx_prob: 5,
             nonce_cache_size: 1024 * 1024,
             candidate_retry_cache_size: 64 * 1024,
             txs_to_consider: [

From 58019925e47fb3434f5baf9650563e113bd981ce Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Wed, 17 Jan 2024 16:16:42 -0500
Subject: [PATCH 0387/1166] Merge master to develop

---
 .github/workflows/bitcoin-tests.yml           |    1 +
 CHANGELOG.md                                  |   21 +
 CODE_OF_CONDUCT.md                            |    3 +
 Cargo.lock                                    |    8 +-
 README.md                                     |    2 +-
 clarity/src/vm/docs/mod.rs                    |    2 +-
 .../get_unconfirmed_block_commmits.py         |  134 ++
 stackslib/src/burnchains/burnchain.rs         |    4 +-
 stackslib/src/chainstate/stacks/db/blocks.rs  |   22 +
 stackslib/src/chainstate/stacks/miner.rs      |    1 +
 stackslib/src/chainstate/stacks/mod.rs        |    2 +-
 .../stacks/tests/block_construction.rs        |    1 -
 stackslib/src/core/mempool.rs                 |  115 +-
 stackslib/src/core/tests/mod.rs               |  174 ++-
 stackslib/src/cost_estimates/fee_scalar.rs    |   24 +-
 stackslib/src/main.rs                         |    1 -
 stackslib/src/net/httpcore.rs                 |   19 +-
 stackslib/src/net/rpc.rs                      |   14 +-
 testnet/stacks-node/Cargo.toml                |    4 +-
 .../burnchains/bitcoin_regtest_controller.rs  |   84 +-
 testnet/stacks-node/src/chain_data.rs         | 1088 +++++++++++++++++
 testnet/stacks-node/src/config.rs             |  184 ++-
 testnet/stacks-node/src/main.rs               |  252 +++-
 testnet/stacks-node/src/neon_node.rs          | 1038 ++++++++++++++--
 testnet/stacks-node/src/run_loop/mod.rs       |    2 +-
 testnet/stacks-node/src/run_loop/neon.rs      |   19 +-
 .../stacks-node/src/tests/bitcoin_regtest.rs  |    1 -
 testnet/stacks-node/src/tests/epoch_205.rs    |    1 -
 testnet/stacks-node/src/tests/epoch_21.rs     |    2 -
 testnet/stacks-node/src/tests/epoch_22.rs     |    2 -
 testnet/stacks-node/src/tests/epoch_23.rs     |    1 -
 testnet/stacks-node/src/tests/epoch_24.rs     |    2 -
 testnet/stacks-node/src/tests/integrations.rs |    1 -
 testnet/stacks-node/src/tests/mod.rs          |  350 +++++-
 .../src/tests/neon_integrations.rs            |  356 +++++-
 35 files changed, 3689 insertions(+), 246 deletions(-)
 create mode 100755 contrib/miner-queries/get_unconfirmed_block_commmits.py
 create mode 100644 testnet/stacks-node/src/chain_data.rs

diff --git a/.github/workflows/bitcoin-tests.yml b/.github/workflows/bitcoin-tests.yml
index 4acac1c8a0..babcbfda46 100644
--- a/.github/workflows/bitcoin-tests.yml
+++ b/.github/workflows/bitcoin-tests.yml
@@ -68,6 +68,7 @@ jobs:
           - tests::neon_integrations::test_problematic_microblocks_are_not_relayed_or_stored
           - tests::neon_integrations::test_problematic_txs_are_not_stored
           - tests::neon_integrations::use_latest_tip_integration_test
+          - tests::neon_integrations::min_txs
           - tests::should_succeed_handling_malformed_and_valid_txs
     steps:
       ## Setup test environment
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5ceb41364a..fc21d8eac5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,27 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to the versioning scheme outlined in the [README.md](README.md).
 
+## [2.4.0.0.5]
+
+This introduces a set of improvements to the Stacks miner behavior.  In
+particular:
+* The VRF public key can be re-used across node restarts.
+* Settings that affect mining are hot-reloaded from the config file.  They take
+  effect once the file is updated; there is no longer a need to restart the
+node.
+* The act of changing the miner settings in the config file automatically
+  triggers a subsequent block-build attempt, allowing the operator to force the
+miner to re-try building blocks.
+* This adds a new tip-selection algorithm that minimizes block orphans within a
+  configurable window of time.
+* When configured, the node will automatically stop mining if it is not achieving a
+  targeted win rate over a configurable window of blocks.
+* When configured, the node will selectively mine transactions from only certain
+  addresses, or only of certain types (STX-transfers, contract-publishes,
+contract-calls).
+* When configured, the node will optionally only RBF block-commits if it can
+  produce a block with strictly more transactions.
+
 ## [2.4.0.0.4]
 
 This is a high-priority hotfix that addresses a bug in transaction processing which
diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md
index 6d6e5053dd..81f2ed3cc0 100644
--- a/CODE_OF_CONDUCT.md
+++ b/CODE_OF_CONDUCT.md
@@ -71,6 +71,9 @@ Community leaders will follow these Community Impact Guidelines in determining t
 
 **Consequence**: A permanent ban from any sort of public interaction within the community.
 
+### Secret Code: 
+The code to the contest is: BITCOINL2
+
 ## Attribution
 
 This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 2.0,
diff --git a/Cargo.lock b/Cargo.lock
index 58da7992d4..f7e17419fe 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1933,9 +1933,9 @@ checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
 
 [[package]]
 name = "libc"
-version = "0.2.149"
+version = "0.2.151"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a08173bc88b7955d1b3145aa561539096c421ac8debde8cbc3612ec635fee29b"
+checksum = "302d7ab3130588088d277783b1e2d2e10c9e9e4a16dd9050e6ec93fb3e7048f4"
 
 [[package]]
 name = "libflate"
@@ -2430,9 +2430,9 @@ dependencies = [
 
 [[package]]
 name = "pico-args"
-version = "0.3.4"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28b9b4df73455c861d7cbf8be42f01d3b373ed7f02e378d55fa84eafc6f638b1"
+checksum = "5be167a7af36ee22fe3115051bc51f6e6c7054c9348e28deb4f49bd6f705a315"
 
 [[package]]
 name = "pin-project"
diff --git a/README.md b/README.md
index 2f1be08873..e61829ff30 100644
--- a/README.md
+++ b/README.md
@@ -67,7 +67,7 @@ You can observe the state machine in action locally by running:
 
 ```bash
 $ cd testnet/stacks-node
-$ cargo run --bin stacks-node -- start --config=./conf/testnet-follower-conf.toml
+$ cargo run --bin stacks-node -- start --config ./conf/testnet-follower-conf.toml
 ```
 
 _On Windows, many tests will fail if the line endings aren't `LF`. Please ensure that you are have git's `core.autocrlf` set to `input` when you clone the repository to avoid any potential issues. This is due to the Clarity language currently being sensitive to line endings._
diff --git a/clarity/src/vm/docs/mod.rs b/clarity/src/vm/docs/mod.rs
index df117a7bca..034616c0f7 100644
--- a/clarity/src/vm/docs/mod.rs
+++ b/clarity/src/vm/docs/mod.rs
@@ -2001,7 +2001,7 @@ const DEFINE_TRAIT_API: DefineAPI = DefineAPI {
 can implement a given trait and then have their contract identifier being passed as a function argument in order to be called
 dynamically with `contract-call?`.
 
-Traits are defined with a name, and a list functions, defined with a name, a list of argument types, and return type.
+Traits are defined with a name, and a list of functions, where each function is defined with a name, a list of argument types, and a return type.
 
 In Clarity 1, a trait type can be used to specify the type of a function parameter. A parameter with a trait type can
 be used as the target of a dynamic `contract-call?`. A principal literal (e.g. `ST1PQHQKV0RJXZFY1DGX8MNSNYVE3VGZJSRTPGZGM.foo`)
diff --git a/contrib/miner-queries/get_unconfirmed_block_commmits.py b/contrib/miner-queries/get_unconfirmed_block_commmits.py
new file mode 100755
index 0000000000..c5cee38123
--- /dev/null
+++ b/contrib/miner-queries/get_unconfirmed_block_commmits.py
@@ -0,0 +1,134 @@
+#!/usr/bin/env python3
+"""
+Usage:
+This script is designed to be run from the command line. It takes one or more Bitcoin addresses
+and outputs the extracted block commit data for these addresses.
+
+Example command line usage:
+python3 get_unconfirmed_block_commits.py [btcAddress1] [btcAddress2] ...
+"""
+
+import requests
+import json
+import sys
+
+def read_api_endpoint(url):
+    """
+    Reads data from the specified API endpoint and returns the response.
+
+    Args:
+        url (str): The API endpoint URL.
+
+    Returns:
+        dict: JSON response from the API if successful, otherwise None.
+    """
+    try:
+        response = requests.get(url)
+        response.raise_for_status()  # Raise an exception for non-200 status codes
+        return response.json()  # Assuming a JSON response
+    except requests.exceptions.RequestException as e:
+        return None
+
+def is_block_commit(txn):
+    """
+    Determines whether a given transaction is a block commit.
+
+    Args:
+        txn (dict): The transaction data.
+
+    Returns:
+        bool: True if the transaction is a block commit, otherwise False.
+    """
+    try:
+        vout = txn['vout']
+
+        # Verify the number of recipients.
+        assert(3 <= len(vout) <= 4)
+        block_commit_txn = vout[0]
+        to_stacker_txns = vout[1::2]
+
+        # Verify block commit.
+        # TODO: Add more verification steps if necessary.
+        assert(block_commit_txn['scriptpubkey_type'] == "op_return")
+
+        # Verify PoX Payouts.
+        for to_stacker_txn in to_stacker_txns:
+            # TODO: Add more verification steps if necessary.
+            assert(to_stacker_txn['scriptpubkey_type'] != "op_return")
+
+    except (Exception, AssertionError):
+        return False
+    return True
+
+MEMPOOL_TXN_API = "https://mempool.space/api/address/{btcAddress}/txs/mempool"
+def unconfirmed_block_commit_from_address(btcAddress):
+    """
+    Fetches the first unconfirmed block commit for a given Bitcoin address.
+
+    Args:
+        btcAddress (str): Bitcoin address.
+
+    Returns:
+        dict: The first transaction that is a block commit.
+    """
+    url = MEMPOOL_TXN_API.format(btcAddress=btcAddress)
+    txns = read_api_endpoint(url)
+
+    # Return only the first block commit transaction. This is good enough for now.
+    for txn in txns:
+        if is_block_commit(txn):
+            return txn
+
+def extracted_block_commit_data(txn):
+    """
+    Extracts data from a block commit transaction.
+
+    Args:
+        txn (dict): Block commit transaction.
+
+    Returns:
+        dict: Extracted data from the transaction, or None if extraction fails.
+    """
+    try:
+        vout_start = 1
+        vout_end = len(txn['vout']) - 1
+        spent_utxo = txn['vin'][0]
+        return {
+            'txid': txn['txid'],
+            'burn': sum(pox_payout['value'] for pox_payout in txn['vout'][vout_start:vout_end]),
+            'address': spent_utxo['prevout']['scriptpubkey_address'],
+            'pox_addrs': [txn['vout'][i]['scriptpubkey'] for i in range(vout_start,vout_end)],
+            'input_txid': spent_utxo['txid'],
+            'input_index': spent_utxo['vout'],
+        }
+    except Exception as e:
+        return None
+
+def block_commit_data(btcAddresses):
+    """
+    Fetches and extracts block commit data for a list of Bitcoin addresses.
+
+    Args:
+        btcAddresses (list): List of Bitcoin addresses.
+
+    Returns:
+        list: Extracted block commit data for each address.
+    """
+    return [extracted_block_commit_data(unconfirmed_block_commit_from_address(btcAddress)) \
+            for btcAddress in btcAddresses]
+
+def main():
+    """
+    Main function to run the script. Takes command line arguments as Bitcoin addresses.
+    """
+    btc_addresses = sys.argv[1:]
+    if not btc_addresses:
+        print("No Bitcoin addresses provided. Please provide at least one address.")
+        return
+
+    # Return the data by printing it to stdout.
+    data = block_commit_data(btc_addresses)
+    print(json.dumps([datum for datum in data if datum is not None], indent=1))
+
+if __name__ == "__main__":
+    main()
diff --git a/stackslib/src/burnchains/burnchain.rs b/stackslib/src/burnchains/burnchain.rs
index 4ba47f804e..babc3da537 100644
--- a/stackslib/src/burnchains/burnchain.rs
+++ b/stackslib/src/burnchains/burnchain.rs
@@ -297,7 +297,7 @@ impl BurnchainStateTransition {
 }
 
 impl BurnchainSigner {
-    #[cfg(test)]
+    #[cfg(any(test, feature = "testing"))]
     pub fn mock_parts(
         hash_mode: AddressHashMode,
         num_sigs: usize,
@@ -311,7 +311,7 @@ impl BurnchainSigner {
         BurnchainSigner(repr)
     }
 
-    #[cfg(test)]
+    #[cfg(any(test, feature = "testing"))]
     pub fn new_p2pkh(pubk: &StacksPublicKey) -> BurnchainSigner {
         BurnchainSigner::mock_parts(AddressHashMode::SerializeP2PKH, 1, vec![pubk.clone()])
     }
diff --git a/stackslib/src/chainstate/stacks/db/blocks.rs b/stackslib/src/chainstate/stacks/db/blocks.rs
index 25dcdc9f33..1bd8188815 100644
--- a/stackslib/src/chainstate/stacks/db/blocks.rs
+++ b/stackslib/src/chainstate/stacks/db/blocks.rs
@@ -6307,6 +6307,28 @@ impl StacksChainState {
         query_row(&self.db(), sql, args).map_err(Error::DBError)
     }
 
+    /// Get all possible canonical chain tips
+    pub fn get_stacks_chain_tips(&self, sortdb: &SortitionDB) -> Result<Vec<StagingBlock>, Error> {
+        let (consensus_hash, block_bhh) =
+            SortitionDB::get_canonical_stacks_chain_tip_hash(sortdb.conn())?;
+        let sql = "SELECT * FROM staging_blocks WHERE processed = 1 AND orphaned = 0 AND consensus_hash = ?1 AND anchored_block_hash = ?2";
+        let args: &[&dyn ToSql] = &[&consensus_hash, &block_bhh];
+        let Some(staging_block): Option<StagingBlock> =
+            query_row(&self.db(), sql, args).map_err(Error::DBError)?
+        else {
+            return Ok(vec![]);
+        };
+        self.get_stacks_chain_tips_at_height(staging_block.height)
+    }
+
+    /// Get all Stacks blocks at a given height
+    pub fn get_stacks_chain_tips_at_height(&self, height: u64) -> Result<Vec<StagingBlock>, Error> {
+        let sql =
+            "SELECT * FROM staging_blocks WHERE processed = 1 AND orphaned = 0 AND height = ?1";
+        let args: &[&dyn ToSql] = &[&u64_to_sql(height)?];
+        query_rows(&self.db(), sql, args).map_err(Error::DBError)
+    }
+
     /// Get the parent block of `staging_block`.
     pub fn get_stacks_block_parent(
         &self,
diff --git a/stackslib/src/chainstate/stacks/miner.rs b/stackslib/src/chainstate/stacks/miner.rs
index de58760ce6..534f81f725 100644
--- a/stackslib/src/chainstate/stacks/miner.rs
+++ b/stackslib/src/chainstate/stacks/miner.rs
@@ -105,6 +105,7 @@ impl MinerStatus {
     pub fn get_spend_amount(&self) -> u64 {
         return self.spend_amount;
     }
+
     pub fn set_spend_amount(&mut self, amt: u64) {
         self.spend_amount = amt;
     }
diff --git a/stackslib/src/chainstate/stacks/mod.rs b/stackslib/src/chainstate/stacks/mod.rs
index f7f1243d9c..d0e18721b5 100644
--- a/stackslib/src/chainstate/stacks/mod.rs
+++ b/stackslib/src/chainstate/stacks/mod.rs
@@ -74,7 +74,7 @@ pub use stacks_common::address::{
 };
 pub use stacks_common::types::chainstate::{StacksPrivateKey, StacksPublicKey};
 
-pub const STACKS_BLOCK_VERSION: u8 = 6;
+pub const STACKS_BLOCK_VERSION: u8 = 7;
 pub const STACKS_BLOCK_VERSION_AST_PRECHECK_SIZE: u8 = 1;
 
 pub const MAX_BLOCK_LEN: u32 = 2 * 1024 * 1024;
diff --git a/stackslib/src/chainstate/stacks/tests/block_construction.rs b/stackslib/src/chainstate/stacks/tests/block_construction.rs
index 24de63a676..c81a57b098 100644
--- a/stackslib/src/chainstate/stacks/tests/block_construction.rs
+++ b/stackslib/src/chainstate/stacks/tests/block_construction.rs
@@ -4697,7 +4697,6 @@ fn paramaterized_mempool_walk_test(
     let b_2 = make_block(&mut chainstate, ConsensusHash([0x2; 20]), &b_1, 2, 2);
 
     let mut mempool_settings = MemPoolWalkSettings::default();
-    mempool_settings.min_tx_fee = 10;
     let mut tx_events = Vec::new();
 
     let txs = codec_all_transactions(
diff --git a/stackslib/src/core/mempool.rs b/stackslib/src/core/mempool.rs
index 24ef7e5485..0146065e63 100644
--- a/stackslib/src/core/mempool.rs
+++ b/stackslib/src/core/mempool.rs
@@ -22,6 +22,7 @@ use std::ops::{Deref, DerefMut};
 use std::path::{Path, PathBuf};
 use std::time::Instant;
 use std::{fs, io};
+use std::str::FromStr;
 
 use clarity::vm::types::PrincipalData;
 use rand::distributions::Uniform;
@@ -431,10 +432,51 @@ impl MemPoolTxMetadata {
     }
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum MemPoolWalkTxTypes {
+    TokenTransfer,
+    SmartContract,
+    ContractCall,
+}
+
+impl FromStr for MemPoolWalkTxTypes {
+    type Err = &'static str;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "TokenTransfer" => {
+                return Ok(Self::TokenTransfer);
+            }
+            "SmartContract" => {
+                return Ok(Self::SmartContract);
+            }
+            "ContractCall" => {
+                return Ok(Self::ContractCall);
+            }
+            _ => {
+                return Err("Unknown mempool tx walk type");
+            }
+        }
+    }
+}
+
+impl MemPoolWalkTxTypes {
+    pub fn all() -> HashSet<MemPoolWalkTxTypes> {
+        [
+            MemPoolWalkTxTypes::TokenTransfer,
+            MemPoolWalkTxTypes::SmartContract,
+            MemPoolWalkTxTypes::ContractCall,
+        ]
+        .into_iter()
+        .collect()
+    }
+
+    pub fn only(selected: &[MemPoolWalkTxTypes]) -> HashSet<MemPoolWalkTxTypes> {
+        selected.iter().map(|x| x.clone()).collect()
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct MemPoolWalkSettings {
-    /// Minimum transaction fee that will be considered
-    pub min_tx_fee: u64,
     /// Maximum amount of time a miner will spend walking through mempool transactions, in
     /// milliseconds.  This is a soft deadline.
     pub max_walk_time_ms: u64,
@@ -447,25 +489,43 @@ pub struct MemPoolWalkSettings {
     /// Size of the candidate cache. These are the candidates that will be retried after each
     /// transaction is mined.
     pub candidate_retry_cache_size: u64,
+    /// Types of transactions we'll consider
+    pub txs_to_consider: HashSet<MemPoolWalkTxTypes>,
+    /// Origins for transactions that we'll consider
+    pub filter_origins: HashSet<StacksAddress>,
 }
 
 impl MemPoolWalkSettings {
     pub fn default() -> MemPoolWalkSettings {
         MemPoolWalkSettings {
-            min_tx_fee: 1,
             max_walk_time_ms: u64::MAX,
             consider_no_estimate_tx_prob: 5,
             nonce_cache_size: 1024 * 1024,
             candidate_retry_cache_size: 64 * 1024,
+            txs_to_consider: [
+                MemPoolWalkTxTypes::TokenTransfer,
+                MemPoolWalkTxTypes::SmartContract,
+                MemPoolWalkTxTypes::ContractCall,
+            ]
+            .into_iter()
+            .collect(),
+            filter_origins: HashSet::new(),
         }
     }
     pub fn zero() -> MemPoolWalkSettings {
         MemPoolWalkSettings {
-            min_tx_fee: 0,
             max_walk_time_ms: u64::MAX,
             consider_no_estimate_tx_prob: 5,
             nonce_cache_size: 1024 * 1024,
             candidate_retry_cache_size: 64 * 1024,
+            txs_to_consider: [
+                MemPoolWalkTxTypes::TokenTransfer,
+                MemPoolWalkTxTypes::SmartContract,
+                MemPoolWalkTxTypes::ContractCall,
+            ]
+            .into_iter()
+            .collect(),
+            filter_origins: HashSet::new(),
         }
     }
 }
@@ -837,8 +897,8 @@ impl<'a> MemPoolTx<'a> {
             let evict_txid = {
                 let num_recents = MemPoolDB::get_num_recent_txs(&dbtx)?;
                 if num_recents >= MAX_BLOOM_COUNTER_TXS.into() {
-                    // for now, remove lowest-fee tx in the recent tx set.
-                    // TODO: In the future, do it by lowest fee rate
+                    // remove lowest-fee tx (they're paying the least, so replication is
+                    // deprioritized)
                     let sql = "SELECT a.txid FROM mempool AS a LEFT OUTER JOIN removed_txids AS b ON a.txid = b.txid WHERE b.txid IS NULL AND a.height > ?1 ORDER BY a.tx_fee ASC LIMIT 1";
                     let args: &[&dyn ToSql] = &[&u64_to_sql(
                         height.saturating_sub(BLOOM_COUNTER_DEPTH as u64),
@@ -1693,6 +1753,49 @@ impl MemPoolDB {
                 }
             };
 
+            let (tx_type, do_consider) = match &tx_info.tx.payload {
+                TransactionPayload::TokenTransfer(..) => (
+                    "TokenTransfer".to_string(),
+                    settings
+                        .txs_to_consider
+                        .contains(&MemPoolWalkTxTypes::TokenTransfer),
+                ),
+                TransactionPayload::SmartContract(..) => (
+                    "SmartContract".to_string(),
+                    settings
+                        .txs_to_consider
+                        .contains(&MemPoolWalkTxTypes::SmartContract),
+                ),
+                TransactionPayload::ContractCall(..) => (
+                    "ContractCall".to_string(),
+                    settings
+                        .txs_to_consider
+                        .contains(&MemPoolWalkTxTypes::ContractCall),
+                ),
+                _ => ("".to_string(), true),
+            };
+            if !do_consider {
+                debug!("Will skip mempool tx, since it does not have an acceptable type";
+                       "txid" => %tx_info.tx.txid(),
+                       "type" => %tx_type);
+                continue;
+            }
+
+            let do_consider = if settings.filter_origins.len() > 0 {
+                settings
+                    .filter_origins
+                    .contains(&tx_info.metadata.origin_address)
+            } else {
+                true
+            };
+
+            if !do_consider {
+                debug!("Will skip mempool tx, since it does not have an allowed origin";
+                       "txid" => %tx_info.tx.txid(),
+                       "origin" => %tx_info.metadata.origin_address);
+                continue;
+            }
+
             let consider = ConsiderTransaction {
                 tx: tx_info,
                 update_estimate,
diff --git a/stackslib/src/core/tests/mod.rs b/stackslib/src/core/tests/mod.rs
index 8902ff4cb8..cfa950f1f5 100644
--- a/stackslib/src/core/tests/mod.rs
+++ b/stackslib/src/core/tests/mod.rs
@@ -58,7 +58,7 @@ use crate::chainstate::stacks::{
     C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
 };
 use crate::core::mempool::{
-    db_get_all_nonces, MemPoolSyncData, MemPoolWalkSettings, TxTag, BLOOM_COUNTER_DEPTH,
+    db_get_all_nonces, MemPoolSyncData, MemPoolWalkSettings, MemPoolWalkTxTypes, TxTag, BLOOM_COUNTER_DEPTH,
     BLOOM_COUNTER_ERROR_RATE, MAX_BLOOM_COUNTER_TXS,
 };
 use crate::core::{FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH};
@@ -259,8 +259,7 @@ fn mempool_walk_over_fork() {
     //   try to walk at b_4, we should be able to find
     //   the transaction at b_1
 
-    let mut mempool_settings = MemPoolWalkSettings::default();
-    mempool_settings.min_tx_fee = 10;
+    let mempool_settings = MemPoolWalkSettings::default();
     let mut tx_events = Vec::new();
     chainstate.with_read_only_clarity_tx(
         &TEST_BURN_STATE_DB,
@@ -595,7 +594,6 @@ fn test_iterate_candidates_consider_no_estimate_tx_prob() {
     let b_2 = make_block(&mut chainstate, ConsensusHash([0x2; 20]), &b_1, 2, 2);
 
     let mut mempool_settings = MemPoolWalkSettings::default();
-    mempool_settings.min_tx_fee = 10;
     let mut tx_events = Vec::new();
 
     let mut txs = codec_all_transactions(
@@ -790,8 +788,7 @@ fn test_iterate_candidates_skipped_transaction() {
     );
     let b_2 = make_block(&mut chainstate, ConsensusHash([0x2; 20]), &b_1, 2, 2);
 
-    let mut mempool_settings = MemPoolWalkSettings::default();
-    mempool_settings.min_tx_fee = 10;
+    let mempool_settings = MemPoolWalkSettings::default();
     let mut tx_events = Vec::new();
 
     let mut txs = codec_all_transactions(
@@ -903,8 +900,7 @@ fn test_iterate_candidates_processing_error_transaction() {
     );
     let b_2 = make_block(&mut chainstate, ConsensusHash([0x2; 20]), &b_1, 2, 2);
 
-    let mut mempool_settings = MemPoolWalkSettings::default();
-    mempool_settings.min_tx_fee = 10;
+    let mempool_settings = MemPoolWalkSettings::default();
     let mut tx_events = Vec::new();
 
     let mut txs = codec_all_transactions(
@@ -1018,8 +1014,7 @@ fn test_iterate_candidates_problematic_transaction() {
     );
     let b_2 = make_block(&mut chainstate, ConsensusHash([0x2; 20]), &b_1, 2, 2);
 
-    let mut mempool_settings = MemPoolWalkSettings::default();
-    mempool_settings.min_tx_fee = 10;
+    let mempool_settings = MemPoolWalkSettings::default();
     let mut tx_events = Vec::new();
 
     let mut txs = codec_all_transactions(
@@ -1134,7 +1129,6 @@ fn test_iterate_candidates_concurrent_write_lock() {
     let b_2 = make_block(&mut chainstate, ConsensusHash([0x2; 20]), &b_1, 2, 2);
 
     let mut mempool_settings = MemPoolWalkSettings::default();
-    mempool_settings.min_tx_fee = 10;
     let mut tx_events = Vec::new();
 
     let mut txs = codec_all_transactions(
@@ -2648,3 +2642,161 @@ fn test_drop_and_blacklist_txs_by_size() {
 
     assert_eq!(num_blacklisted, 5);
 }
+
+#[test]
+fn test_filter_txs_by_type() {
+    let mut chainstate = instantiate_chainstate(false, 0x80000000, function_name!());
+    let chainstate_path = chainstate_path(function_name!());
+    let mut mempool = MemPoolDB::open_test(false, 0x80000000, &chainstate_path).unwrap();
+
+    let addr = StacksAddress {
+        version: 1,
+        bytes: Hash160([0xff; 20]),
+    };
+    let mut txs = vec![];
+    let block_height = 10;
+    let mut total_len = 0;
+
+    let b_1 = make_block(
+        &mut chainstate,
+        ConsensusHash([0x1; 20]),
+        &(
+            FIRST_BURNCHAIN_CONSENSUS_HASH.clone(),
+            FIRST_STACKS_BLOCK_HASH.clone(),
+        ),
+        1,
+        1,
+    );
+    let b_2 = make_block(&mut chainstate, ConsensusHash([0x2; 20]), &b_1, 2, 2);
+
+    let mut mempool_tx = mempool.tx_begin().unwrap();
+    for i in 0..10 {
+        let pk = StacksPrivateKey::new();
+        let mut tx = StacksTransaction {
+            version: TransactionVersion::Testnet,
+            chain_id: 0x80000000,
+            auth: TransactionAuth::from_p2pkh(&pk).unwrap(),
+            anchor_mode: TransactionAnchorMode::Any,
+            post_condition_mode: TransactionPostConditionMode::Allow,
+            post_conditions: vec![],
+            payload: TransactionPayload::TokenTransfer(
+                addr.to_account_principal(),
+                123,
+                TokenTransferMemo([0u8; 34]),
+            ),
+        };
+        tx.set_tx_fee(1000);
+        tx.set_origin_nonce(0);
+
+        let txid = tx.txid();
+        let tx_bytes = tx.serialize_to_vec();
+        let origin_addr = tx.origin_address();
+        let origin_nonce = tx.get_origin_nonce();
+        let sponsor_addr = tx.sponsor_address().unwrap_or(origin_addr.clone());
+        let sponsor_nonce = tx.get_sponsor_nonce().unwrap_or(origin_nonce);
+        let tx_fee = tx.get_tx_fee();
+
+        total_len += tx_bytes.len();
+
+        // should succeed
+        MemPoolDB::try_add_tx(
+            &mut mempool_tx,
+            &mut chainstate,
+            &b_2.0,
+            &b_2.1,
+            txid.clone(),
+            tx_bytes,
+            tx_fee,
+            block_height as u64,
+            &origin_addr,
+            origin_nonce,
+            &sponsor_addr,
+            sponsor_nonce,
+            None,
+        )
+        .unwrap();
+
+        eprintln!("Added {} {}", i, &txid);
+        txs.push(tx);
+    }
+    mempool_tx.commit().unwrap();
+
+    let mut mempool_settings = MemPoolWalkSettings::default();
+    let mut tx_events = Vec::new();
+    mempool_settings.txs_to_consider = [
+        MemPoolWalkTxTypes::SmartContract,
+        MemPoolWalkTxTypes::ContractCall,
+    ]
+    .into_iter()
+    .collect();
+
+    chainstate.with_read_only_clarity_tx(
+        &TEST_BURN_STATE_DB,
+        &StacksBlockHeader::make_index_block_hash(&b_2.0, &b_2.1),
+        |clarity_conn| {
+            let mut count_txs = 0;
+            mempool
+                .iterate_candidates::<_, ChainstateError, _>(
+                    clarity_conn,
+                    &mut tx_events,
+                    2,
+                    mempool_settings.clone(),
+                    |_, available_tx, _| {
+                        count_txs += 1;
+                        Ok(Some(
+                            // Generate any success result
+                            TransactionResult::success(
+                                &available_tx.tx.tx,
+                                available_tx.tx.metadata.tx_fee,
+                                StacksTransactionReceipt::from_stx_transfer(
+                                    available_tx.tx.tx.clone(),
+                                    vec![],
+                                    Value::okay(Value::Bool(true)).unwrap(),
+                                    ExecutionCost::zero(),
+                                ),
+                            )
+                            .convert_to_event(),
+                        ))
+                    },
+                )
+                .unwrap();
+            assert_eq!(count_txs, 0);
+        },
+    );
+
+    mempool_settings.txs_to_consider = [MemPoolWalkTxTypes::TokenTransfer].into_iter().collect();
+
+    chainstate.with_read_only_clarity_tx(
+        &TEST_BURN_STATE_DB,
+        &StacksBlockHeader::make_index_block_hash(&b_2.0, &b_2.1),
+        |clarity_conn| {
+            let mut count_txs = 0;
+            mempool
+                .iterate_candidates::<_, ChainstateError, _>(
+                    clarity_conn,
+                    &mut tx_events,
+                    2,
+                    mempool_settings.clone(),
+                    |_, available_tx, _| {
+                        count_txs += 1;
+                        Ok(Some(
+                            // Generate any success result
+                            TransactionResult::success(
+                                &available_tx.tx.tx,
+                                available_tx.tx.metadata.tx_fee,
+                                StacksTransactionReceipt::from_stx_transfer(
+                                    available_tx.tx.tx.clone(),
+                                    vec![],
+                                    Value::okay(Value::Bool(true)).unwrap(),
+                                    ExecutionCost::zero(),
+                                ),
+                            )
+                            .convert_to_event(),
+                        ))
+                    },
+                )
+                .unwrap();
+            assert_eq!(count_txs, 10);
+        },
+    );
+}
diff --git a/stackslib/src/cost_estimates/fee_scalar.rs b/stackslib/src/cost_estimates/fee_scalar.rs
index 14c4471458..b7fc814ff3 100644
--- a/stackslib/src/cost_estimates/fee_scalar.rs
+++ b/stackslib/src/cost_estimates/fee_scalar.rs
@@ -12,6 +12,10 @@ use serde_json::Value as JsonValue;
 
 use super::metrics::CostMetric;
 use super::{EstimatorError, FeeEstimator, FeeRateEstimate};
+
+use clarity::vm::database::ClaritySerializable;
+use clarity::vm::database::STXBalance;
+
 use crate::chainstate::stacks::db::StacksEpochReceipt;
 use crate::chainstate::stacks::events::TransactionOrigin;
 use crate::chainstate::stacks::TransactionPayload;
@@ -163,7 +167,25 @@ impl<M: CostMetric> FeeEstimator for ScalarFeeRateEstimator<M> {
                 let scalar_cost = match payload {
                     TransactionPayload::TokenTransfer(_, _, _) => {
                         // TokenTransfers *only* contribute tx_len, and just have an empty ExecutionCost.
-                        self.metric.from_len(tx_size)
+                        let stx_balance_len = STXBalance::LockedPoxThree {
+                            amount_unlocked: 1,
+                            amount_locked: 1,
+                            unlock_height: 1,
+                        }
+                        .serialize()
+                        .as_bytes()
+                        .len() as u64;
+                        self.metric.from_cost_and_len(
+                            &ExecutionCost {
+                                write_length: stx_balance_len,
+                                write_count: 1,
+                                read_length: 2 * stx_balance_len,
+                                read_count: 2,
+                                runtime: 4640, // taken from .costs-3
+                            },
+                            &block_limit,
+                            tx_size,
+                        )
                     }
                     TransactionPayload::Coinbase(..) => {
                         // Coinbase txs are "free", so they don't factor into the fee market.
diff --git a/stackslib/src/main.rs b/stackslib/src/main.rs
index c70e5c2e7a..03d2d2edfa 100644
--- a/stackslib/src/main.rs
+++ b/stackslib/src/main.rs
@@ -771,7 +771,6 @@ simulating a miner.
 
         let mut settings = BlockBuilderSettings::limited();
         settings.max_miner_time_ms = max_time;
-        settings.mempool_settings.min_tx_fee = min_fee;
 
         let result = StacksBlockBuilder::build_anchored_block(
             &chain_state,
diff --git a/stackslib/src/net/httpcore.rs b/stackslib/src/net/httpcore.rs
index 8b4c11bb07..017a151af6 100644
--- a/stackslib/src/net/httpcore.rs
+++ b/stackslib/src/net/httpcore.rs
@@ -33,6 +33,7 @@ use stacks_common::types::net::PeerHost;
 use stacks_common::types::Address;
 use stacks_common::util::chunked_encoding::*;
 use stacks_common::util::retry::{BoundReader, RetryReader};
+use stacks_common::util::get_epoch_time_ms;
 use url::Url;
 
 use crate::burnchains::Txid;
@@ -435,11 +436,12 @@ pub trait RPCRequestHandler: HttpRequest + HttpResponse + RPCRequestHandlerClone
 pub struct StacksHttpRequest {
     preamble: HttpRequestPreamble,
     contents: HttpRequestContents,
+    start_time: u128
 }
 
 impl StacksHttpRequest {
     pub fn new(preamble: HttpRequestPreamble, contents: HttpRequestContents) -> Self {
-        Self { preamble, contents }
+        Self { preamble, contents, start_time: get_epoch_time_ms() }
     }
 
     /// Instantiate a request to a remote Stacks peer
@@ -470,7 +472,7 @@ impl StacksHttpRequest {
             preamble.path_and_query_str = decoded_path;
         }
 
-        Ok(Self { preamble, contents })
+        Ok(Self { preamble, contents, start_time: get_epoch_time_ms() })
     }
 
     /// Get a reference to the request premable metadata
@@ -493,6 +495,17 @@ impl StacksHttpRequest {
         &self.preamble.path_and_query_str
     }
 
+    /// Get the HTTP verb for this request
+    pub fn verb(&self) -> &str {
+        &self.preamble.verb
+    }
+
+    /// Get the number of milliseconds elapsed since this request was created
+    pub fn duration_ms(&self) -> u128 {
+        let now = get_epoch_time_ms();
+        now.saturating_sub(self.start_time)
+    }
+
     /// Write out this message to a Write.
     /// NOTE: In practice, the Write will be a reply handle endpoint, so writing to it won't block.
     pub fn send<W: Write>(&self, fd: &mut W) -> Result<(), NetError> {
@@ -982,7 +995,7 @@ impl StacksHttp {
                 }
             };
 
-            info!("Handle StacksHttpRequest"; "verb" => %verb, "peer_addr" => %self.peer_addr, "path" => %decoded_path, "query" => %query);
+            debug!("Handle StacksHttpRequest"; "verb" => %verb, "peer_addr" => %self.peer_addr, "path" => %decoded_path, "query" => %query);
             let request = StacksHttpRequest::new(preamble.clone(), payload);
             return Ok(request);
         }
diff --git a/stackslib/src/net/rpc.rs b/stackslib/src/net/rpc.rs
index f66e26a71a..49f0aa2479 100644
--- a/stackslib/src/net/rpc.rs
+++ b/stackslib/src/net/rpc.rs
@@ -546,13 +546,21 @@ impl ConversationHttp {
                     // new request that we can handle
                     self.total_request_count += 1;
                     self.last_request_timestamp = get_epoch_time_secs();
+                    let latency = req.duration_ms();
                     let start_time = Instant::now();
-                    let path = req.request_path().to_string();
+                    let verb = req.verb().to_string();
+                    let request_path = req.request_path().to_string();
                     let msg_opt = monitoring::instrument_http_request_handler(req, |req| {
                         self.handle_request(req, node)
                     })?;
 
-                    debug!("Processed HTTPRequest"; "path" => %path, "processing_time_ms" => start_time.elapsed().as_millis(), "conn_id" => self.conn_id, "peer_addr" => &self.peer_addr);
+                    info!("Handled StacksHTTPRequest";
+                           "verb" => %verb,
+                           "path" => %request_path,
+                           "processing_time_ms" => start_time.elapsed().as_millis(),
+                           "latency_ms" => latency,
+                           "conn_id" => self.conn_id,
+                           "peer_addr" => &self.peer_addr);
 
                     if let Some(msg) = msg_opt {
                         ret.push(msg);
@@ -565,7 +573,7 @@ impl ConversationHttp {
                     let start_time = Instant::now();
                     self.reply_error(resp)?;
 
-                    debug!("Processed HTTPRequest Error"; "path" => %path, "processing_time_ms" => start_time.elapsed().as_millis(), "conn_id" => self.conn_id, "peer_addr" => &self.peer_addr);
+                    info!("Handled StacksHTTPRequest Error"; "path" => %path, "processing_time_ms" => start_time.elapsed().as_millis(), "conn_id" => self.conn_id, "peer_addr" => &self.peer_addr);
                 }
                 StacksHttpMessage::Response(resp) => {
                     // Is there someone else waiting for this message?  If so, pass it along.
diff --git a/testnet/stacks-node/Cargo.toml b/testnet/stacks-node/Cargo.toml
index 82ed994ee4..b50198954b 100644
--- a/testnet/stacks-node/Cargo.toml
+++ b/testnet/stacks-node/Cargo.toml
@@ -8,7 +8,7 @@ rust-version = "1.61"
 
 [dependencies]
 lazy_static = "1.4.0"
-pico-args = "0.3.1"
+pico-args = "0.5.0"
 rand = "0.7.3"
 serde = "1"
 serde_derive = "1"
@@ -21,7 +21,7 @@ async-std = { version = "1.6", features = ["attributes"] }
 http-types = "2.12"
 base64 = "0.12.0"
 backtrace = "0.3.50"
-libc = "0.2"
+libc = "0.2.151"
 slog = { version = "2.5.2", features = [ "max_level_trace" ] }
 clarity = { path = "../../clarity" }
 stacks-common = { path = "../../stacks-common" }
diff --git a/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs b/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
index 30967f5556..d511603ed5 100644
--- a/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
+++ b/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
@@ -155,41 +155,15 @@ pub fn make_bitcoin_indexer(
 }
 
 pub fn get_satoshis_per_byte(config: &Config) -> u64 {
-    match config.get_burnchain_config() {
-        Ok(s) => s.satoshis_per_byte,
-        Err(_) => {
-            info!("No config found. Using previous configuration.");
-            config.burnchain.satoshis_per_byte
-        }
-    }
+    config.get_burnchain_config().satoshis_per_byte
 }
 
-#[cfg(test)]
-mod tests {
-    use std::env::temp_dir;
-    use std::fs::File;
-    use std::io::Write;
-
-    use super::*;
-    use crate::config::DEFAULT_SATS_PER_VB;
-
-    #[test]
-    fn test_get_satoshis_per_byte() {
-        let dir = temp_dir();
-        let file_path = dir.as_path().join("config.toml");
-
-        let mut config = Config::default();
-
-        let satoshis_per_byte = get_satoshis_per_byte(&config);
-        assert_eq!(satoshis_per_byte, DEFAULT_SATS_PER_VB);
-
-        let mut file = File::create(&file_path).unwrap();
-        writeln!(file, "[burnchain]").unwrap();
-        writeln!(file, "satoshis_per_byte = 51").unwrap();
-        config.config_path = Some(file_path.to_str().unwrap().to_string());
+pub fn get_rbf_fee_increment(config: &Config) -> u64 {
+    config.get_burnchain_config().rbf_fee_increment
+}
 
-        assert_eq!(get_satoshis_per_byte(&config), 51);
-    }
+pub fn get_max_rbf(config: &Config) -> u64 {
+    config.get_burnchain_config().max_rbf
 }
 
 impl LeaderBlockCommitFees {
@@ -201,7 +175,7 @@ impl LeaderBlockCommitFees {
         let mut fees = LeaderBlockCommitFees::estimated_fees_from_payload(payload, config);
         fees.spent_in_attempts = cmp::max(1, self.spent_in_attempts);
         fees.final_size = self.final_size;
-        fees.fee_rate = self.fee_rate + config.burnchain.rbf_fee_increment;
+        fees.fee_rate = self.fee_rate + get_rbf_fee_increment(&config);
         fees.is_rbf_enabled = true;
         fees
     }
@@ -835,8 +809,8 @@ impl BitcoinRegtestController {
         let public_key = signer.get_public_key();
 
         // reload the config to find satoshis_per_byte changes
-        let satoshis_per_byte = get_satoshis_per_byte(&self.config);
-        let btc_miner_fee = self.config.burnchain.leader_key_tx_estimated_size * satoshis_per_byte;
+        let btc_miner_fee = self.config.burnchain.leader_key_tx_estimated_size
+            * get_satoshis_per_byte(&self.config);
         let budget_for_outputs = DUST_UTXO_LIMIT;
         let total_required = btc_miner_fee + budget_for_outputs;
 
@@ -864,7 +838,7 @@ impl BitcoinRegtestController {
 
         tx.output = vec![consensus_output];
 
-        let fee_rate = satoshis_per_byte;
+        let fee_rate = get_satoshis_per_byte(&self.config);
 
         self.finalize_tx(
             epoch_id,
@@ -958,7 +932,6 @@ impl BitcoinRegtestController {
     ) -> Option<Transaction> {
         let public_key = signer.get_public_key();
         let max_tx_size = 230;
-        let satoshis_per_byte = get_satoshis_per_byte(&self.config);
         let (mut tx, mut utxos) = if let Some(utxo) = utxo_to_use {
             (
                 Transaction {
@@ -976,7 +949,7 @@ impl BitcoinRegtestController {
             self.prepare_tx(
                 epoch_id,
                 &public_key,
-                DUST_UTXO_LIMIT + max_tx_size * satoshis_per_byte,
+                DUST_UTXO_LIMIT + max_tx_size * get_satoshis_per_byte(&self.config),
                 None,
                 None,
                 0,
@@ -1004,14 +977,13 @@ impl BitcoinRegtestController {
                 .to_bitcoin_tx_out(DUST_UTXO_LIMIT),
         );
 
-        let satoshis_per_byte = get_satoshis_per_byte(&self.config);
         self.finalize_tx(
             epoch_id,
             &mut tx,
             DUST_UTXO_LIMIT,
             0,
             max_tx_size,
-            satoshis_per_byte,
+            get_satoshis_per_byte(&self.config),
             &mut utxos,
             signer,
         )?;
@@ -1359,11 +1331,11 @@ impl BitcoinRegtestController {
 
         // Stop as soon as the fee_rate is ${self.config.burnchain.max_rbf} percent higher, stop RBF
         if ongoing_op.fees.fee_rate
-            > (get_satoshis_per_byte(&self.config) * self.config.burnchain.max_rbf / 100)
+            > (get_satoshis_per_byte(&self.config) * get_max_rbf(&self.config) / 100)
         {
             warn!(
                 "RBF'd block commits reached {}% satoshi per byte fee rate, not resubmitting",
-                self.config.burnchain.max_rbf
+                get_max_rbf(&self.config)
             );
             self.ongoing_block_commit = Some(ongoing_op);
             return None;
@@ -2546,3 +2518,31 @@ impl BitcoinRPCRequest {
         Ok(payload)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use std::env::temp_dir;
+    use std::fs::File;
+    use std::io::Write;
+
+    use super::*;
+    use crate::config::DEFAULT_SATS_PER_VB;
+
+    #[test]
+    fn test_get_satoshis_per_byte() {
+        let dir = temp_dir();
+        let file_path = dir.as_path().join("config.toml");
+
+        let mut config = Config::default();
+
+        let satoshis_per_byte = get_satoshis_per_byte(&config);
+        assert_eq!(satoshis_per_byte, DEFAULT_SATS_PER_VB);
+
+        let mut file = File::create(&file_path).unwrap();
+        writeln!(file, "[burnchain]").unwrap();
+        writeln!(file, "satoshis_per_byte = 51").unwrap();
+        config.config_path = Some(file_path.to_str().unwrap().to_string());
+
+        assert_eq!(get_satoshis_per_byte(&config), 51);
+    }
+}
diff --git a/testnet/stacks-node/src/chain_data.rs b/testnet/stacks-node/src/chain_data.rs
new file mode 100644
index 0000000000..587fece9bc
--- /dev/null
+++ b/testnet/stacks-node/src/chain_data.rs
@@ -0,0 +1,1088 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020-2023 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+use std::collections::HashMap;
+use std::process::{Command, Stdio};
+
+use stacks::burnchains::bitcoin::address::BitcoinAddress;
+use stacks::burnchains::bitcoin::{BitcoinNetworkType, BitcoinTxOutput};
+use stacks::burnchains::{Burnchain, BurnchainSigner, Error as BurnchainError, Txid};
+use stacks::chainstate::burn::db::sortdb::{SortitionDB, SortitionHandle};
+use stacks::chainstate::burn::distribution::BurnSamplePoint;
+use stacks::chainstate::burn::operations::leader_block_commit::{
+    MissedBlockCommit, BURN_BLOCK_MINED_AT_MODULUS,
+};
+use stacks::chainstate::burn::operations::LeaderBlockCommitOp;
+use stacks::chainstate::stacks::address::PoxAddress;
+use stacks::core::MINING_COMMITMENT_WINDOW;
+use stacks::util_lib::db::Error as DBError;
+use stacks_common::types::chainstate::{BlockHeaderHash, BurnchainHeaderHash, VRFSeed};
+use stacks_common::util::hash::hex_bytes;
+
+pub struct MinerStats {
+    pub unconfirmed_commits_helper: String,
+}
+
+/// Unconfirmed block-commit transaction as emitted by our helper
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+struct UnconfirmedBlockCommit {
+    /// burnchain signer
+    address: String,
+    /// PoX payouts
+    pox_addrs: Vec<String>,
+    /// UTXO spent to create this block-commit
+    input_index: u32,
+    input_txid: String,
+    /// transaction ID
+    txid: String,
+    /// amount spent
+    burn: u64,
+}
+
+const DEADBEEF: [u8; 32] = [
+    0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef,
+    0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef,
+];
+
+impl MinerStats {
+    /// Find the burn distribution for a single sortition's block-commits and missed-commits
+    fn get_burn_distribution<SH: SortitionHandle>(
+        sort_handle: &mut SH,
+        burnchain: &Burnchain,
+        burn_block_height: u64,
+        block_commits: Vec<LeaderBlockCommitOp>,
+        missed_commits: Vec<MissedBlockCommit>,
+    ) -> Result<Vec<BurnSamplePoint>, BurnchainError> {
+        // assemble the commit windows
+        let mut windowed_block_commits = vec![block_commits];
+        let mut windowed_missed_commits = vec![];
+
+        if !burnchain.is_in_prepare_phase(burn_block_height) {
+            // PoX reward-phase is active!
+            // build a map of intended sortition -> missed commit for the missed commits
+            //   discovered in this block.
+            let mut missed_commits_map: HashMap<_, Vec<_>> = HashMap::new();
+            for missed in missed_commits.iter() {
+                if let Some(commits_at_sortition) =
+                    missed_commits_map.get_mut(&missed.intended_sortition)
+                {
+                    commits_at_sortition.push(missed);
+                } else {
+                    missed_commits_map.insert(missed.intended_sortition.clone(), vec![missed]);
+                }
+            }
+
+            for blocks_back in 0..(MINING_COMMITMENT_WINDOW - 1) {
+                if burn_block_height.saturating_sub(1) < (blocks_back as u64) {
+                    debug!("Mining commitment window shortened because block height is less than window size";
+                           "block_height" => %burn_block_height.saturating_sub(1),
+                           "window_size" => %MINING_COMMITMENT_WINDOW);
+                    break;
+                }
+                let block_height = (burn_block_height.saturating_sub(1)) - (blocks_back as u64);
+                let sortition_id = match sort_handle.get_block_snapshot_by_height(block_height)? {
+                    Some(sn) => sn.sortition_id,
+                    None => break,
+                };
+                windowed_block_commits.push(SortitionDB::get_block_commits_by_block(
+                    sort_handle.sqlite(),
+                    &sortition_id,
+                )?);
+                let mut missed_commits_at_height = SortitionDB::get_missed_commits_by_intended(
+                    sort_handle.sqlite(),
+                    &sortition_id,
+                )?;
+                if let Some(missed_commit_in_block) = missed_commits_map.remove(&sortition_id) {
+                    missed_commits_at_height
+                        .extend(missed_commit_in_block.into_iter().map(|x| x.clone()));
+                }
+
+                windowed_missed_commits.push(missed_commits_at_height);
+            }
+        } else {
+            // PoX reward-phase is not active
+            debug!(
+                "Block {} is in a prepare phase or post-PoX sunset, so no windowing will take place",
+                burn_block_height;
+            );
+
+            assert_eq!(windowed_block_commits.len(), 1);
+            assert_eq!(windowed_missed_commits.len(), 0);
+        }
+
+        // reverse vecs so that windows are in ascending block height order
+        windowed_block_commits.reverse();
+        windowed_missed_commits.reverse();
+
+        // figure out if the PoX sunset finished during the window,
+        // and/or which sortitions must be PoB due to them falling in a prepare phase.
+        let window_end_height = burn_block_height;
+        let window_start_height = window_end_height + 1 - (windowed_block_commits.len() as u64);
+        let mut burn_blocks = vec![false; windowed_block_commits.len()];
+
+        // set burn_blocks flags to accomodate prepare phases and PoX sunset
+        for (i, b) in burn_blocks.iter_mut().enumerate() {
+            if burnchain.is_in_prepare_phase(window_start_height + (i as u64)) {
+                // must burn
+                *b = true;
+            } else {
+                // must not burn
+                *b = false;
+            }
+        }
+
+        // not all commits in windowed_block_commits have been confirmed, so make sure that they
+        // are in the right order
+        let mut block_height_at_index = None;
+        for (index, commits) in windowed_block_commits.iter_mut().enumerate() {
+            let index = index as u64;
+            for commit in commits.iter_mut() {
+                if let Some((first_block_height, first_index)) = block_height_at_index {
+                    if commit.block_height != first_block_height + (index - first_index) {
+                        commit.block_height = first_block_height + (index - first_index);
+                    }
+                } else {
+                    block_height_at_index = Some((commit.block_height, index));
+                }
+            }
+        }
+
+        // calculate the burn distribution from these operations.
+        // The resulting distribution will contain the user burns that match block commits
+        let burn_dist = BurnSamplePoint::make_min_median_distribution(
+            windowed_block_commits,
+            windowed_missed_commits,
+            burn_blocks,
+        );
+
+        Ok(burn_dist)
+    }
+
+    fn fmt_bin_args(bin: &str, args: &[&str]) -> String {
+        let mut all = Vec::with_capacity(1 + args.len());
+        all.push(bin);
+        for arg in args {
+            all.push(arg);
+        }
+        all.join(" ")
+    }
+
+    /// Returns (exit code, stdout, stderr)
+    fn run_subprocess(
+        bin_fullpath: &str,
+        args: &[&str],
+    ) -> Result<(i32, Vec<u8>, Vec<u8>), String> {
+        let full_args = Self::fmt_bin_args(bin_fullpath, args);
+        let mut cmd = Command::new(bin_fullpath);
+        cmd.stdin(Stdio::piped())
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped())
+            .args(args);
+
+        debug!("Run: `{:?}`", &cmd);
+
+        let output = cmd
+            .spawn()
+            .map_err(|e| format!("Failed to run `{}`: {:?}", &full_args, &e))?
+            .wait_with_output()
+            .map_err(|ioe| format!("Failed to run `{}`: {:?}", &full_args, &ioe))?;
+
+        let exit_code = match output.status.code() {
+            Some(code) => code,
+            None => {
+                // failed due to signal
+                return Err(format!("Failed to run `{}`: killed by signal", &full_args));
+            }
+        };
+
+        Ok((exit_code, output.stdout, output.stderr))
+    }
+
+    /// Get the list of all unconfirmed block-commits.
+    pub fn get_unconfirmed_commits(
+        &self,
+        next_block_height: u64,
+        all_miners: &[&str],
+    ) -> Result<Vec<LeaderBlockCommitOp>, String> {
+        let (exit_code, stdout, _stderr) =
+            Self::run_subprocess(&self.unconfirmed_commits_helper, &all_miners)?;
+        if exit_code != 0 {
+            return Err(format!(
+                "Failed to run `{}`: exit code {}",
+                &self.unconfirmed_commits_helper, exit_code
+            ));
+        }
+
+        // decode stdout to JSON
+        let unconfirmed_commits: Vec<UnconfirmedBlockCommit> = serde_json::from_slice(&stdout)
+            .map_err(|e| {
+                format!(
+                    "Failed to decode output from `{}`: {:?}. Output was `{}`",
+                    &self.unconfirmed_commits_helper,
+                    &e,
+                    String::from_utf8_lossy(&stdout)
+                )
+            })?;
+
+        let mut unconfirmed_spends = vec![];
+        for unconfirmed_commit in unconfirmed_commits.into_iter() {
+            let Ok(txid) = Txid::from_hex(&unconfirmed_commit.txid) else {
+                return Err(format!("Not a valid txid: `{}`", &unconfirmed_commit.txid));
+            };
+            let Ok(input_txid) = Txid::from_hex(&unconfirmed_commit.input_txid) else {
+                return Err(format!(
+                    "Not a valid txid: `{}`",
+                    &unconfirmed_commit.input_txid
+                ));
+            };
+            let mut decoded_pox_addrs = vec![];
+            for pox_addr_hex in unconfirmed_commit.pox_addrs.iter() {
+                let Ok(pox_addr_bytes) = hex_bytes(&pox_addr_hex) else {
+                    return Err(format!("Not a hex string: `{}`", &pox_addr_hex));
+                };
+                let Some(bitcoin_addr) =
+                    BitcoinAddress::from_scriptpubkey(BitcoinNetworkType::Mainnet, &pox_addr_bytes)
+                else {
+                    return Err(format!(
+                        "Not a recognized Bitcoin scriptpubkey: {}",
+                        &pox_addr_hex
+                    ));
+                };
+                let Some(pox_addr) = PoxAddress::try_from_bitcoin_output(&BitcoinTxOutput {
+                    address: bitcoin_addr.clone(),
+                    units: 1,
+                }) else {
+                    return Err(format!("Not a recognized PoX address: {}", &bitcoin_addr));
+                };
+                decoded_pox_addrs.push(pox_addr);
+            }
+
+            // mocked commit
+            let mocked_commit = LeaderBlockCommitOp {
+                sunset_burn: 0,
+                block_header_hash: BlockHeaderHash(DEADBEEF.clone()),
+                new_seed: VRFSeed(DEADBEEF.clone()),
+                parent_block_ptr: 1,
+                parent_vtxindex: 1,
+                key_block_ptr: 1,
+                key_vtxindex: 1,
+                memo: vec![],
+                commit_outs: decoded_pox_addrs,
+                burn_fee: unconfirmed_commit.burn,
+                input: (input_txid, unconfirmed_commit.input_index),
+                apparent_sender: BurnchainSigner(unconfirmed_commit.address),
+                txid,
+                vtxindex: 1,
+                block_height: next_block_height,
+                burn_parent_modulus: ((next_block_height.saturating_sub(1))
+                    % BURN_BLOCK_MINED_AT_MODULUS) as u8,
+                burn_header_hash: BurnchainHeaderHash(DEADBEEF.clone()),
+            };
+
+            unconfirmed_spends.push(mocked_commit);
+        }
+        Ok(unconfirmed_spends)
+    }
+
+    /// Convert a list of burn sample points into a probability distribution by candidate's
+    /// apparent sender (e.g. miner address).
+    pub fn burn_dist_to_prob_dist(burn_dist: &[BurnSamplePoint]) -> HashMap<String, f64> {
+        if burn_dist.len() == 0 {
+            return HashMap::new();
+        }
+        if burn_dist.len() == 1 {
+            let mut ret = HashMap::new();
+            ret.insert(burn_dist[0].candidate.apparent_sender.to_string(), 1.0);
+            return ret;
+        }
+
+        let mut ret = HashMap::new();
+        for pt in burn_dist.iter() {
+            // take the upper 32 bits
+            let range_lower_64 = (pt.range_end - pt.range_start) >> 192;
+            let int_prob = (range_lower_64.low_u64() >> 32) as u32;
+
+            ret.insert(
+                pt.candidate.apparent_sender.to_string(),
+                (int_prob as f64) / (u32::MAX as f64),
+            );
+        }
+
+        ret
+    }
+
+    /// Get the spend distribution and total spend.
+    /// If the miner has both a confirmed and unconfirmed spend, then take the latter.
+    pub fn get_spend_distribution(
+        active_miners_and_commits: &[(String, LeaderBlockCommitOp)],
+        unconfirmed_block_commits: &[LeaderBlockCommitOp],
+        expected_pox_addrs: &[PoxAddress],
+    ) -> (HashMap<String, u64>, u64) {
+        let unconfirmed_block_commits: Vec<_> = unconfirmed_block_commits
+            .iter()
+            .filter(|commit| {
+                if commit.commit_outs.len() != expected_pox_addrs.len() {
+                    return false;
+                }
+                for i in 0..commit.commit_outs.len() {
+                    if commit.commit_outs[i].to_burnchain_repr()
+                        != expected_pox_addrs[i].to_burnchain_repr()
+                    {
+                        info!(
+                            "Skipping invalid unconfirmed block-commit: {:?} != {:?}",
+                            &commit.commit_outs[i].to_burnchain_repr(),
+                            expected_pox_addrs[i].to_burnchain_repr()
+                        );
+                        return false;
+                    }
+                }
+                true
+            })
+            .collect();
+
+        let mut total_spend = 0;
+        let mut dist = HashMap::new();
+        for commit in unconfirmed_block_commits {
+            let addr = commit.apparent_sender.to_string();
+            dist.insert(addr, commit.burn_fee);
+        }
+
+        for (_, commit) in active_miners_and_commits.iter() {
+            let addr = commit.apparent_sender.to_string();
+            if dist.contains_key(&addr) {
+                continue;
+            }
+            dist.insert(addr, commit.burn_fee);
+        }
+
+        for (_, spend) in dist.iter() {
+            total_spend += *spend;
+        }
+
+        (dist, total_spend)
+    }
+
+    /// Get the probability distribution for the Bitcoin block 6+ blocks in the future, assuming
+    /// all block-commit spends remain the same.
+    pub fn get_future_win_distribution(
+        active_miners_and_commits: &[(String, LeaderBlockCommitOp)],
+        unconfirmed_block_commits: &[LeaderBlockCommitOp],
+        expected_pox_addrs: &[PoxAddress],
+    ) -> HashMap<String, f64> {
+        let (dist, total_spend) = Self::get_spend_distribution(
+            active_miners_and_commits,
+            unconfirmed_block_commits,
+            &expected_pox_addrs,
+        );
+
+        let mut probs = HashMap::new();
+        for (addr, spend) in dist.into_iter() {
+            if total_spend == 0 {
+                probs.insert(addr, 0.0);
+            } else {
+                probs.insert(addr, (spend as f64) / (total_spend as f64));
+            }
+        }
+        probs
+    }
+
+    /// Get the burn distribution for the _next_ Bitcoin block, assuming that the given list of
+    /// block-commit data will get mined.  For miners that are known to the system but who do not
+    /// have unconfirmed block-commits, infer that they'll just mine the same block-commit value
+    /// again.
+    pub fn get_unconfirmed_burn_distribution(
+        &self,
+        burnchain: &Burnchain,
+        sortdb: &SortitionDB,
+        active_miners_and_commits: &[(String, LeaderBlockCommitOp)],
+        unconfirmed_block_commits: Vec<LeaderBlockCommitOp>,
+        expected_pox_addrs: &[PoxAddress],
+        at_block: Option<u64>,
+    ) -> Result<Vec<BurnSamplePoint>, BurnchainError> {
+        let mut commit_table = HashMap::new();
+        for commit in unconfirmed_block_commits.iter() {
+            commit_table.insert(commit.apparent_sender.to_string(), commit.clone());
+        }
+
+        let tip = if let Some(at_block) = at_block {
+            let tip = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn())?;
+            let ih = sortdb.index_handle(&tip.sortition_id);
+            ih.get_block_snapshot_by_height(at_block)?
+                .ok_or(BurnchainError::MissingParentBlock)?
+        } else {
+            SortitionDB::get_canonical_burn_chain_tip(sortdb.conn())?
+        };
+
+        let next_block_height = tip.block_height + 1;
+        let expected_input_index = if burnchain.is_in_prepare_phase(tip.block_height) {
+            LeaderBlockCommitOp::expected_chained_utxo(true)
+        } else {
+            LeaderBlockCommitOp::expected_chained_utxo(false)
+        };
+
+        for (miner, last_commit) in active_miners_and_commits.iter() {
+            if !commit_table.contains_key(miner) {
+                let mocked_commit = LeaderBlockCommitOp {
+                    sunset_burn: 0,
+                    block_header_hash: BlockHeaderHash(DEADBEEF.clone()),
+                    new_seed: VRFSeed(DEADBEEF.clone()),
+                    parent_block_ptr: 2,
+                    parent_vtxindex: 2,
+                    key_block_ptr: 2,
+                    key_vtxindex: 2,
+                    memo: vec![],
+                    commit_outs: expected_pox_addrs.to_vec(),
+                    burn_fee: last_commit.burn_fee,
+                    input: (last_commit.txid, expected_input_index),
+                    apparent_sender: last_commit.apparent_sender.clone(),
+                    txid: Txid(DEADBEEF.clone()),
+                    vtxindex: 1,
+                    block_height: next_block_height,
+                    burn_parent_modulus: ((next_block_height.saturating_sub(1))
+                        % BURN_BLOCK_MINED_AT_MODULUS)
+                        as u8,
+                    burn_header_hash: BurnchainHeaderHash(DEADBEEF.clone()),
+                };
+                commit_table.insert(miner.to_string(), mocked_commit);
+            }
+        }
+
+        let unconfirmed_block_commits: Vec<_> = commit_table
+            .into_values()
+            .filter(|commit| {
+                if commit.commit_outs.len() != expected_pox_addrs.len() {
+                    return false;
+                }
+                for i in 0..commit.commit_outs.len() {
+                    if commit.commit_outs[i].to_burnchain_repr()
+                        != expected_pox_addrs[i].to_burnchain_repr()
+                    {
+                        info!(
+                            "Skipping invalid unconfirmed block-commit: {:?} != {:?}",
+                            &commit.commit_outs[i].to_burnchain_repr(),
+                            expected_pox_addrs[i].to_burnchain_repr()
+                        );
+                        return false;
+                    }
+                }
+                true
+            })
+            .collect();
+
+        let mut handle = sortdb.index_handle(&tip.sortition_id);
+        Self::get_burn_distribution(
+            &mut handle,
+            burnchain,
+            tip.block_height + 1,
+            unconfirmed_block_commits,
+            vec![],
+        )
+    }
+
+    /// Given the sortition DB, get the list of all miners in the past MINING_COMMITMENT_WINDOW
+    /// blocks, as well as their last block-commits
+    pub fn get_active_miners(
+        sortdb: &SortitionDB,
+        at_burn_block: Option<u64>,
+    ) -> Result<Vec<(String, LeaderBlockCommitOp)>, DBError> {
+        let mut tip = if let Some(at_burn_block) = at_burn_block {
+            let tip = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn())?;
+            let ih = sortdb.index_handle(&tip.sortition_id);
+            ih.get_block_snapshot_by_height(at_burn_block)?
+                .ok_or(DBError::NotFoundError)?
+        } else {
+            SortitionDB::get_canonical_burn_chain_tip(sortdb.conn())?
+        };
+
+        let mut miners = HashMap::new();
+        for _i in 0..MINING_COMMITMENT_WINDOW {
+            let commits =
+                SortitionDB::get_block_commits_by_block(sortdb.conn(), &tip.sortition_id)?;
+            for commit in commits.into_iter() {
+                let miner = commit.apparent_sender.to_string();
+                if miners.get(&miner).is_none() {
+                    miners.insert(miner, commit);
+                }
+            }
+            tip = SortitionDB::get_block_snapshot(sortdb.conn(), &tip.parent_sortition_id)?
+                .ok_or(DBError::NotFoundError)?;
+        }
+        Ok(miners.into_iter().collect())
+    }
+}
+
+#[cfg(test)]
+pub mod tests {
+    use std::fs;
+    use std::io::Write;
+
+    use stacks::burnchains::{BurnchainSigner, Txid};
+    use stacks::chainstate::burn::distribution::BurnSamplePoint;
+    use stacks::chainstate::burn::operations::leader_block_commit::BURN_BLOCK_MINED_AT_MODULUS;
+    use stacks::chainstate::burn::operations::LeaderBlockCommitOp;
+    use stacks::chainstate::stacks::address::{PoxAddress, PoxAddressType20};
+    use stacks_common::types::chainstate::{
+        BlockHeaderHash, BurnchainHeaderHash, StacksAddress, StacksPublicKey, VRFSeed,
+    };
+    use stacks_common::util::hash::{hex_bytes, Hash160};
+    use stacks_common::util::uint::{BitArray, Uint256};
+
+    use super::MinerStats;
+
+    #[test]
+    fn test_burn_dist_to_prob_dist() {
+        let block_commit_1 = LeaderBlockCommitOp {
+            sunset_burn: 0,
+            block_header_hash: BlockHeaderHash([0x22; 32]),
+            new_seed: VRFSeed([0x33; 32]),
+            parent_block_ptr: 111,
+            parent_vtxindex: 456,
+            key_block_ptr: 123,
+            key_vtxindex: 456,
+            memo: vec![0x80],
+
+            burn_fee: 12345,
+            input: (Txid([0; 32]), 0),
+            apparent_sender: BurnchainSigner::new_p2pkh(
+                &StacksPublicKey::from_hex(
+                    "02d8015134d9db8178ac93acbc43170a2f20febba5087a5b0437058765ad5133d0",
+                )
+                .unwrap(),
+            ),
+
+            commit_outs: vec![],
+
+            txid: Txid::from_bytes_be(
+                &hex_bytes("3c07a0a93360bc85047bbaadd49e30c8af770f73a37e10fec400174d2e5f27cf")
+                    .unwrap(),
+            )
+            .unwrap(),
+            vtxindex: 443,
+            block_height: 124,
+            burn_parent_modulus: (123 % BURN_BLOCK_MINED_AT_MODULUS) as u8,
+            burn_header_hash: BurnchainHeaderHash([0x00; 32]),
+        };
+
+        let block_commit_2 = LeaderBlockCommitOp {
+            sunset_burn: 0,
+            block_header_hash: BlockHeaderHash([0x22; 32]),
+            new_seed: VRFSeed([0x33; 32]),
+            parent_block_ptr: 112,
+            parent_vtxindex: 111,
+            key_block_ptr: 122,
+            key_vtxindex: 457,
+            memo: vec![0x80],
+
+            burn_fee: 12345,
+            input: (Txid([0; 32]), 0),
+            apparent_sender: BurnchainSigner::new_p2pkh(
+                &StacksPublicKey::from_hex(
+                    "023616a344700c9455bf0b55cc65e404c7b8f82e815da885398a44f6dc70e64045",
+                )
+                .unwrap(),
+            ),
+
+            commit_outs: vec![],
+
+            txid: Txid::from_bytes_be(
+                &hex_bytes("3c07a0a93360bc85047bbaadd49e30c8af770f73a37e10fec400174d2e5f27d0")
+                    .unwrap(),
+            )
+            .unwrap(),
+            vtxindex: 444,
+            block_height: 124,
+            burn_parent_modulus: (123 % BURN_BLOCK_MINED_AT_MODULUS) as u8,
+            burn_header_hash: BurnchainHeaderHash::from_hex(
+                "0000000000000000000000000000000000000000000000000000000000000004",
+            )
+            .unwrap(),
+        };
+
+        let block_commit_3 = LeaderBlockCommitOp {
+            sunset_burn: 0,
+            block_header_hash: BlockHeaderHash([0x22; 32]),
+            new_seed: VRFSeed([0x33; 32]),
+            parent_block_ptr: 113,
+            parent_vtxindex: 111,
+            key_block_ptr: 121,
+            key_vtxindex: 10,
+            memo: vec![0x80],
+
+            burn_fee: 23456,
+            input: (Txid([0; 32]), 0),
+            apparent_sender: BurnchainSigner::new_p2pkh(
+                &StacksPublicKey::from_hex(
+                    "020a9b0a938a2226694fe4f867193cf0b78cd6264e4277fd686468a00a9afdc36d",
+                )
+                .unwrap(),
+            ),
+
+            commit_outs: vec![],
+
+            txid: Txid::from_bytes_be(
+                &hex_bytes("301dc687a9f06a1ae87a013f27133e9cec0843c2983567be73e185827c7c13de")
+                    .unwrap(),
+            )
+            .unwrap(),
+            vtxindex: 445,
+            block_height: 124,
+            burn_parent_modulus: (123 % BURN_BLOCK_MINED_AT_MODULUS) as u8,
+            burn_header_hash: BurnchainHeaderHash::from_hex(
+                "0000000000000000000000000000000000000000000000000000000000000004",
+            )
+            .unwrap(),
+        };
+        let burn_dist = vec![
+            BurnSamplePoint {
+                burns: block_commit_1.burn_fee.into(),
+                median_burn: block_commit_2.burn_fee.into(),
+                range_start: Uint256::zero(),
+                range_end: Uint256([
+                    0x3ed94d3cb0a84709,
+                    0x0963dded799a7c1a,
+                    0x70989faf596c8b65,
+                    0x41a3ed94d3cb0a84,
+                ]),
+                candidate: block_commit_1.clone(),
+                user_burns: vec![],
+            },
+            BurnSamplePoint {
+                burns: block_commit_2.burn_fee.into(),
+                median_burn: block_commit_2.burn_fee.into(),
+                range_start: Uint256([
+                    0x3ed94d3cb0a84709,
+                    0x0963dded799a7c1a,
+                    0x70989faf596c8b65,
+                    0x41a3ed94d3cb0a84,
+                ]),
+                range_end: Uint256([
+                    0x7db29a7961508e12,
+                    0x12c7bbdaf334f834,
+                    0xe1313f5eb2d916ca,
+                    0x8347db29a7961508,
+                ]),
+                candidate: block_commit_2.clone(),
+                user_burns: vec![],
+            },
+            BurnSamplePoint {
+                burns: (block_commit_3.burn_fee).into(),
+                median_burn: block_commit_3.burn_fee.into(),
+                range_start: Uint256([
+                    0x7db29a7961508e12,
+                    0x12c7bbdaf334f834,
+                    0xe1313f5eb2d916ca,
+                    0x8347db29a7961508,
+                ]),
+                range_end: Uint256::max(),
+                candidate: block_commit_3.clone(),
+                user_burns: vec![],
+            },
+        ];
+
+        let prob_dist = MinerStats::burn_dist_to_prob_dist(&burn_dist);
+        assert_eq!(prob_dist.len(), 3);
+        assert!(
+            (prob_dist
+                .get(&format!("{}", &block_commit_1.apparent_sender))
+                .unwrap()
+                - 0.25641)
+                .abs()
+                < 0.001
+        );
+        assert!(
+            (prob_dist
+                .get(&format!("{}", &block_commit_2.apparent_sender))
+                .unwrap()
+                - 0.25641)
+                .abs()
+                < 0.001
+        );
+        assert!(
+            (prob_dist
+                .get(&format!("{}", &block_commit_3.apparent_sender))
+                .unwrap()
+                - 0.48718)
+                .abs()
+                < 0.001
+        );
+    }
+
+    #[test]
+    fn test_get_unconfirmed_commits() {
+        use std::os::unix::fs::PermissionsExt;
+        let shell_code = r#"#!/bin/bash
+echo <<EOF '[
+ {
+  "txid": "73c318be8cd272a73200b9630089d77a44342d84b2c0d81c937da714152cf402",
+  "burn": 555000,
+  "address": "1FCcoFSKWvNyhjazNvVdLLw8mGkGdcRMux",
+  "input_txid": "ef0dbf0fc4755de5e94843a4da7c1d943571299afb15f32b76bac5d18d8668ce",
+  "input_index": 3,
+  "pox_addrs": [
+      "0014db14133a9dbb1d0e16b60513453e48b6ff2847a9",
+      "a91418c42080a1e87fd02dd3fca94c4513f9ecfe741487"
+  ]
+ }
+]'
+EOF
+"#;
+        let path = "/tmp/test-get-unconfirmed-commits.sh";
+        if fs::metadata(&path).is_ok() {
+            fs::remove_file(&path).unwrap();
+        }
+        {
+            let mut f = fs::File::create(&path).unwrap();
+            f.write_all(shell_code.as_bytes()).unwrap();
+
+            let md = f.metadata().unwrap();
+            let mut permissions = md.permissions();
+            permissions.set_mode(0o744);
+
+            fs::set_permissions(path, permissions).unwrap();
+            f.sync_all().unwrap();
+        }
+
+        let ms = MinerStats {
+            unconfirmed_commits_helper: path.to_string(),
+        };
+
+        let mut commits = ms.get_unconfirmed_commits(123, &[]).unwrap();
+        assert_eq!(commits.len(), 1);
+        let commit = commits.pop().unwrap();
+
+        assert_eq!(
+            commit.txid,
+            Txid::from_hex("73c318be8cd272a73200b9630089d77a44342d84b2c0d81c937da714152cf402")
+                .unwrap()
+        );
+        assert_eq!(commit.burn_fee, 555000);
+        assert_eq!(
+            commit.apparent_sender.0,
+            "1FCcoFSKWvNyhjazNvVdLLw8mGkGdcRMux".to_string()
+        );
+        assert_eq!(
+            commit.input.0,
+            Txid::from_hex("ef0dbf0fc4755de5e94843a4da7c1d943571299afb15f32b76bac5d18d8668ce")
+                .unwrap()
+        );
+        assert_eq!(commit.input.1, 3);
+        assert_eq!(commit.block_height, 123);
+
+        assert_eq!(
+            commit.commit_outs,
+            vec![
+                PoxAddress::Addr20(
+                    true,
+                    PoxAddressType20::P2WPKH,
+                    [
+                        219, 20, 19, 58, 157, 187, 29, 14, 22, 182, 5, 19, 69, 62, 72, 182, 255,
+                        40, 71, 169
+                    ]
+                ),
+                PoxAddress::Standard(
+                    StacksAddress {
+                        version: 20,
+                        bytes: Hash160([
+                            0x18, 0xc4, 0x20, 0x80, 0xa1, 0xe8, 0x7f, 0xd0, 0x2d, 0xd3, 0xfc, 0xa9,
+                            0x4c, 0x45, 0x13, 0xf9, 0xec, 0xfe, 0x74, 0x14
+                        ])
+                    },
+                    None
+                )
+            ]
+        );
+    }
+
+    #[test]
+    fn test_get_spend_and_win_distribution() {
+        let active_miners_and_commits = vec![
+            (
+                "miner-1".to_string(),
+                LeaderBlockCommitOp {
+                    sunset_burn: 0,
+                    block_header_hash: BlockHeaderHash([0x22; 32]),
+                    new_seed: VRFSeed([0x33; 32]),
+                    parent_block_ptr: 111,
+                    parent_vtxindex: 456,
+                    key_block_ptr: 123,
+                    key_vtxindex: 456,
+                    memo: vec![0x80],
+
+                    burn_fee: 2,
+                    input: (Txid([0; 32]), 0),
+                    apparent_sender: BurnchainSigner("miner-1".into()),
+
+                    commit_outs: vec![],
+
+                    txid: Txid::from_bytes_be(
+                        &hex_bytes(
+                            "3c07a0a93360bc85047bbaadd49e30c8af770f73a37e10fec400174d2e5f27cf",
+                        )
+                        .unwrap(),
+                    )
+                    .unwrap(),
+                    vtxindex: 443,
+                    block_height: 124,
+                    burn_parent_modulus: (123 % BURN_BLOCK_MINED_AT_MODULUS) as u8,
+                    burn_header_hash: BurnchainHeaderHash([0x00; 32]),
+                },
+            ),
+            (
+                "miner-2".to_string(),
+                LeaderBlockCommitOp {
+                    sunset_burn: 0,
+                    block_header_hash: BlockHeaderHash([0x22; 32]),
+                    new_seed: VRFSeed([0x33; 32]),
+                    parent_block_ptr: 112,
+                    parent_vtxindex: 111,
+                    key_block_ptr: 122,
+                    key_vtxindex: 457,
+                    memo: vec![0x80],
+
+                    burn_fee: 3,
+                    input: (Txid([0; 32]), 0),
+                    apparent_sender: BurnchainSigner("miner-2".into()),
+
+                    commit_outs: vec![],
+
+                    txid: Txid::from_bytes_be(
+                        &hex_bytes(
+                            "3c07a0a93360bc85047bbaadd49e30c8af770f73a37e10fec400174d2e5f27d0",
+                        )
+                        .unwrap(),
+                    )
+                    .unwrap(),
+                    vtxindex: 444,
+                    block_height: 124,
+                    burn_parent_modulus: (123 % BURN_BLOCK_MINED_AT_MODULUS) as u8,
+                    burn_header_hash: BurnchainHeaderHash::from_hex(
+                        "0000000000000000000000000000000000000000000000000000000000000004",
+                    )
+                    .unwrap(),
+                },
+            ),
+            (
+                "miner-3".to_string(),
+                LeaderBlockCommitOp {
+                    sunset_burn: 0,
+                    block_header_hash: BlockHeaderHash([0x22; 32]),
+                    new_seed: VRFSeed([0x33; 32]),
+                    parent_block_ptr: 113,
+                    parent_vtxindex: 111,
+                    key_block_ptr: 121,
+                    key_vtxindex: 10,
+                    memo: vec![0x80],
+
+                    burn_fee: 5,
+                    input: (Txid([0; 32]), 0),
+                    apparent_sender: BurnchainSigner("miner-3".into()),
+                    commit_outs: vec![],
+
+                    txid: Txid::from_bytes_be(
+                        &hex_bytes(
+                            "301dc687a9f06a1ae87a013f27133e9cec0843c2983567be73e185827c7c13de",
+                        )
+                        .unwrap(),
+                    )
+                    .unwrap(),
+                    vtxindex: 445,
+                    block_height: 124,
+                    burn_parent_modulus: (123 % BURN_BLOCK_MINED_AT_MODULUS) as u8,
+                    burn_header_hash: BurnchainHeaderHash::from_hex(
+                        "0000000000000000000000000000000000000000000000000000000000000004",
+                    )
+                    .unwrap(),
+                },
+            ),
+        ];
+
+        let unconfirmed_block_commits = vec![
+            LeaderBlockCommitOp {
+                sunset_burn: 0,
+                block_header_hash: BlockHeaderHash([0x22; 32]),
+                new_seed: VRFSeed([0x33; 32]),
+                parent_block_ptr: 124,
+                parent_vtxindex: 456,
+                key_block_ptr: 123,
+                key_vtxindex: 456,
+                memo: vec![0x80],
+
+                burn_fee: 2,
+                input: (Txid([0; 32]), 0),
+                apparent_sender: BurnchainSigner("miner-1".into()),
+
+                commit_outs: vec![],
+
+                txid: Txid::from_bytes_be(
+                    &hex_bytes("3c07a0a93360bc85047bbaadd49e30c8af770f73a37e10fec400174d2e5f27cf")
+                        .unwrap(),
+                )
+                .unwrap(),
+                vtxindex: 443,
+                block_height: 125,
+                burn_parent_modulus: (124 % BURN_BLOCK_MINED_AT_MODULUS) as u8,
+                burn_header_hash: BurnchainHeaderHash([0x01; 32]),
+            },
+            LeaderBlockCommitOp {
+                sunset_burn: 0,
+                block_header_hash: BlockHeaderHash([0x22; 32]),
+                new_seed: VRFSeed([0x33; 32]),
+                parent_block_ptr: 124,
+                parent_vtxindex: 444,
+                key_block_ptr: 123,
+                key_vtxindex: 456,
+                memo: vec![0x80],
+
+                burn_fee: 3,
+                input: (Txid([0; 32]), 0),
+                apparent_sender: BurnchainSigner("miner-2".into()),
+
+                commit_outs: vec![],
+
+                txid: Txid::from_bytes_be(
+                    &hex_bytes("3c07a0a93360bc85047bbaadd49e30c8af770f73a37e10fec400174d2e5f27cf")
+                        .unwrap(),
+                )
+                .unwrap(),
+                vtxindex: 444,
+                block_height: 125,
+                burn_parent_modulus: (124 % BURN_BLOCK_MINED_AT_MODULUS) as u8,
+                burn_header_hash: BurnchainHeaderHash([0x01; 32]),
+            },
+            LeaderBlockCommitOp {
+                sunset_burn: 0,
+                block_header_hash: BlockHeaderHash([0x22; 32]),
+                new_seed: VRFSeed([0x33; 32]),
+                parent_block_ptr: 124,
+                parent_vtxindex: 445,
+                key_block_ptr: 123,
+                key_vtxindex: 456,
+                memo: vec![0x80],
+
+                burn_fee: 10,
+                input: (Txid([0; 32]), 0),
+                apparent_sender: BurnchainSigner("miner-3".into()),
+
+                commit_outs: vec![],
+
+                txid: Txid::from_bytes_be(
+                    &hex_bytes("3c07a0a93360bc85047bbaadd49e30c8af770f73a37e10fec400174d2e5f27cf")
+                        .unwrap(),
+                )
+                .unwrap(),
+                vtxindex: 445,
+                block_height: 125,
+                burn_parent_modulus: (124 % BURN_BLOCK_MINED_AT_MODULUS) as u8,
+                burn_header_hash: BurnchainHeaderHash([0x01; 32]),
+            },
+            LeaderBlockCommitOp {
+                sunset_burn: 0,
+                block_header_hash: BlockHeaderHash([0x22; 32]),
+                new_seed: VRFSeed([0x33; 32]),
+                parent_block_ptr: 124,
+                parent_vtxindex: 445,
+                key_block_ptr: 123,
+                key_vtxindex: 456,
+                memo: vec![0x80],
+
+                burn_fee: 10,
+                input: (Txid([0; 32]), 0),
+                apparent_sender: BurnchainSigner("miner-4".into()),
+
+                commit_outs: vec![],
+
+                txid: Txid::from_bytes_be(
+                    &hex_bytes("3c07a0a93360bc85047bbaadd49e30c8af770f73a37e10fec400174d2e5f27cf")
+                        .unwrap(),
+                )
+                .unwrap(),
+                vtxindex: 446,
+                block_height: 125,
+                burn_parent_modulus: (124 % BURN_BLOCK_MINED_AT_MODULUS) as u8,
+                burn_header_hash: BurnchainHeaderHash([0x01; 32]),
+            },
+        ];
+
+        let (spend_dist, total_spend) = MinerStats::get_spend_distribution(
+            &active_miners_and_commits,
+            &unconfirmed_block_commits,
+            &[],
+        );
+        assert_eq!(total_spend, 2 + 3 + 10 + 10);
+
+        assert_eq!(spend_dist.len(), 4);
+        for miner in &[
+            "miner-1".to_string(),
+            "miner-2".to_string(),
+            "miner-3".to_string(),
+            "miner-4".to_string(),
+        ] {
+            let spend = *spend_dist
+                .get(miner)
+                .expect(&format!("no spend for {}", &miner));
+            match miner.as_str() {
+                "miner-1" => {
+                    assert_eq!(spend, 2);
+                }
+                "miner-2" => {
+                    assert_eq!(spend, 3);
+                }
+                "miner-3" => {
+                    assert_eq!(spend, 10);
+                }
+                "miner-4" => {
+                    assert_eq!(spend, 10);
+                }
+                _ => {
+                    panic!("unknown miner {}", &miner);
+                }
+            }
+        }
+
+        let win_probs = MinerStats::get_future_win_distribution(
+            &active_miners_and_commits,
+            &unconfirmed_block_commits,
+            &[],
+        );
+        for miner in &[
+            "miner-1".to_string(),
+            "miner-2".to_string(),
+            "miner-3".to_string(),
+            "miner-4".to_string(),
+        ] {
+            let prob = *win_probs
+                .get(miner)
+                .expect(&format!("no probability for {}", &miner));
+            match miner.as_str() {
+                "miner-1" => {
+                    assert!((prob - (2.0 / 25.0)).abs() < 0.00001);
+                }
+                "miner-2" => {
+                    assert!((prob - (3.0 / 25.0)).abs() < 0.00001);
+                }
+                "miner-3" => {
+                    assert!((prob - (10.0 / 25.0)).abs() < 0.00001);
+                }
+                "miner-4" => {
+                    assert!((prob - (10.0 / 25.0)).abs() < 0.00001);
+                }
+                _ => {
+                    panic!("unknown miner {}", &miner);
+                }
+            }
+        }
+    }
+}
diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index bb1c4e91d1..fb4d6d91b0 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -14,7 +14,7 @@ use stacks::chainstate::stacks::index::marf::MARFOpenOpts;
 use stacks::chainstate::stacks::index::storage::TrieHashCalculationMode;
 use stacks::chainstate::stacks::miner::{BlockBuilderSettings, MinerStatus};
 use stacks::chainstate::stacks::MAX_BLOCK_LEN;
-use stacks::core::mempool::MemPoolWalkSettings;
+use stacks::core::mempool::{MemPoolWalkSettings, MemPoolWalkTxTypes};
 use stacks::core::{
     StacksEpoch, StacksEpochExtension, StacksEpochId, CHAIN_ID_MAINNET, CHAIN_ID_TESTNET,
     PEER_VERSION_MAINNET, PEER_VERSION_TESTNET,
@@ -27,11 +27,15 @@ use stacks::cost_estimates::{CostEstimator, FeeEstimator, PessimisticEstimator};
 use stacks::net::atlas::AtlasConfig;
 use stacks::net::connection::ConnectionOptions;
 use stacks::net::{Neighbor, NeighborKey};
+use stacks_common::types::chainstate::StacksAddress;
 use stacks_common::types::net::PeerAddress;
+use stacks_common::types::Address;
 use stacks_common::util::get_epoch_time_ms;
 use stacks_common::util::hash::hex_bytes;
 use stacks_common::util::secp256k1::{Secp256k1PrivateKey, Secp256k1PublicKey};
 
+use crate::chain_data::MinerStats;
+
 pub const DEFAULT_SATS_PER_VB: u64 = 50;
 const DEFAULT_MAX_RBF_RATE: u64 = 150; // 1.5x
 const DEFAULT_RBF_FEE_RATE_INCREMENT: u64 = 5;
@@ -393,16 +397,36 @@ lazy_static! {
 }
 
 impl Config {
-    /// get the up-to-date burnchain from the config
-    pub fn get_burnchain_config(&self) -> Result<BurnchainConfig, String> {
-        if let Some(path) = &self.config_path {
-            let config_file = ConfigFile::from_path(path.as_str())?;
-            let config = Config::from_config_file(config_file)?;
-            Ok(config.burnchain)
-        } else {
-            Ok(self.burnchain.clone())
-        }
+    /// get the up-to-date burnchain options from the config.
+    /// If the config file can't be loaded, then return the existing config
+    pub fn get_burnchain_config(&self) -> BurnchainConfig {
+        let Some(path) = &self.config_path else {
+            return self.burnchain.clone();
+        };
+        let Ok(config_file) = ConfigFile::from_path(path.as_str()) else {
+            return self.burnchain.clone();
+        };
+        let Ok(config) = Config::from_config_file(config_file) else {
+            return self.burnchain.clone();
+        };
+        config.burnchain
     }
+
+    /// get the up-to-date miner options from the config
+    /// If the config can't be loaded for some reason, then return the existing config
+    pub fn get_miner_config(&self) -> MinerConfig {
+        let Some(path) = &self.config_path else {
+            return self.miner.clone();
+        };
+        let Ok(config_file) = ConfigFile::from_path(path.as_str()) else {
+            return self.miner.clone();
+        };
+        let Ok(config) = Config::from_config_file(config_file) else {
+            return self.miner.clone();
+        };
+        return config.miner;
+    }
+
     /// Apply any test settings to this burnchain config struct
     fn apply_test_settings(&self, burnchain: &mut Burnchain) {
         if self.burnchain.get_bitcoin_network().1 == BitcoinNetworkType::Mainnet {
@@ -898,7 +922,6 @@ impl Config {
         let miner_default_config = MinerConfig::default();
         let miner = match config_file.miner {
             Some(ref miner) => MinerConfig {
-                min_tx_fee: miner.min_tx_fee.unwrap_or(miner_default_config.min_tx_fee),
                 first_attempt_time_ms: miner
                     .first_attempt_time_ms
                     .unwrap_or(miner_default_config.first_attempt_time_ms),
@@ -926,6 +949,52 @@ impl Config {
                 unprocessed_block_deadline_secs: miner
                     .unprocessed_block_deadline_secs
                     .unwrap_or(miner_default_config.unprocessed_block_deadline_secs),
+                min_tx_count: miner.min_tx_count.unwrap_or(0),
+                only_increase_tx_count: miner.only_increase_tx_count.unwrap_or(false),
+                unconfirmed_commits_helper: miner.unconfirmed_commits_helper.clone(),
+                target_win_probability: miner.target_win_probability.unwrap_or(0.0),
+                activated_vrf_key_path: miner.activated_vrf_key_path.clone(),
+                fast_rampup: miner.fast_rampup.unwrap_or(true),
+                underperform_stop_threshold: miner.underperform_stop_threshold,
+                txs_to_consider: {
+                    if let Some(txs_to_consider) = &miner.txs_to_consider {
+                        txs_to_consider
+                            .split(",")
+                            .map(
+                                |txs_to_consider_str| match str::parse(txs_to_consider_str) {
+                                    Ok(txtype) => txtype,
+                                    Err(e) => {
+                                        panic!(
+                                            "could not parse '{}': {}",
+                                            &txs_to_consider_str, &e
+                                        );
+                                    }
+                                },
+                            )
+                            .collect()
+                    } else {
+                        MemPoolWalkTxTypes::all()
+                    }
+                },
+                filter_origins: {
+                    if let Some(filter_origins) = &miner.filter_origins {
+                        filter_origins
+                            .split(",")
+                            .map(|origin_str| match StacksAddress::from_string(origin_str) {
+                                Some(addr) => addr,
+                                None => {
+                                    panic!(
+                                        "could not parse '{}' into a Stacks address",
+                                        origin_str
+                                    );
+                                }
+                            })
+                            .collect()
+                    } else {
+                        HashSet::new()
+                    }
+                },
+                max_reorg_depth: miner.max_reorg_depth.unwrap_or(3),
             },
             None => miner_default_config,
         };
@@ -1301,34 +1370,47 @@ impl Config {
         microblocks: bool,
         miner_status: Arc<Mutex<MinerStatus>>,
     ) -> BlockBuilderSettings {
+        let miner_config = self.get_miner_config();
         BlockBuilderSettings {
             max_miner_time_ms: if microblocks {
-                self.miner.microblock_attempt_time_ms
+                miner_config.microblock_attempt_time_ms
             } else if attempt <= 1 {
                 // first attempt to mine a block -- do so right away
-                self.miner.first_attempt_time_ms
+                miner_config.first_attempt_time_ms
             } else {
                 // second or later attempt to mine a block -- give it some time
-                self.miner.subsequent_attempt_time_ms
+                miner_config.subsequent_attempt_time_ms
             },
             mempool_settings: MemPoolWalkSettings {
-                min_tx_fee: self.miner.min_tx_fee,
                 max_walk_time_ms: if microblocks {
-                    self.miner.microblock_attempt_time_ms
+                    miner_config.microblock_attempt_time_ms
                 } else if attempt <= 1 {
                     // first attempt to mine a block -- do so right away
-                    self.miner.first_attempt_time_ms
+                    miner_config.first_attempt_time_ms
                 } else {
                     // second or later attempt to mine a block -- give it some time
-                    self.miner.subsequent_attempt_time_ms
+                    miner_config.subsequent_attempt_time_ms
                 },
-                consider_no_estimate_tx_prob: self.miner.probability_pick_no_estimate_tx,
-                nonce_cache_size: self.miner.nonce_cache_size,
-                candidate_retry_cache_size: self.miner.candidate_retry_cache_size,
+                consider_no_estimate_tx_prob: miner_config.probability_pick_no_estimate_tx,
+                nonce_cache_size: miner_config.nonce_cache_size,
+                candidate_retry_cache_size: miner_config.candidate_retry_cache_size,
+                txs_to_consider: miner_config.txs_to_consider,
+                filter_origins: miner_config.filter_origins,
             },
             miner_status,
         }
     }
+
+    pub fn get_miner_stats(&self) -> Option<MinerStats> {
+        let miner_config = self.get_miner_config();
+        if let Some(unconfirmed_commits_helper) = miner_config.unconfirmed_commits_helper.as_ref() {
+            let miner_stats = MinerStats {
+                unconfirmed_commits_helper: unconfirmed_commits_helper.clone(),
+            };
+            return Some(miner_stats);
+        }
+        None
+    }
 }
 
 impl std::default::Default for Config {
@@ -1917,9 +1999,8 @@ impl NodeConfig {
     }
 }
 
-#[derive(Clone, Debug, Default)]
+#[derive(Clone, Debug, Default, PartialEq)]
 pub struct MinerConfig {
-    pub min_tx_fee: u64,
     pub first_attempt_time_ms: u64,
     pub subsequent_attempt_time_ms: u64,
     pub microblock_attempt_time_ms: u64,
@@ -1933,22 +2014,58 @@ pub struct MinerConfig {
     pub nonce_cache_size: u64,
     pub candidate_retry_cache_size: u64,
     pub unprocessed_block_deadline_secs: u64,
+    /// minimum number of transactions that must be in a block if we're going to replace a pending
+    /// block-commit with a new block-commit
+    pub min_tx_count: u64,
+    /// Only allow a block's tx count to increase across RBFs.
+    pub only_increase_tx_count: bool,
+    /// Path to a script that prints out all unconfirmed block-commits for a list of addresses
+    pub unconfirmed_commits_helper: Option<String>,
+    /// Targeted win probability for this miner.  Used to deduce when to stop trying to mine.
+    pub target_win_probability: f64,
+    /// Path to a serialized RegisteredKey struct, which points to an already-registered VRF key
+    /// (so we don't have to go make a new one)
+    pub activated_vrf_key_path: Option<String>,
+    /// When estimating win probability, whether or not to use the assumed win rate 6+ blocks from
+    /// now (true), or the current win rate (false)
+    pub fast_rampup: bool,
+    /// Number of Bitcoin blocks which must pass where the boostes+neutrals are a minority, at which
+    /// point the miner will stop trying.
+    pub underperform_stop_threshold: Option<u64>,
+    /// Kinds of transactions to consider from the mempool.  This is used by boosted and neutral
+    /// miners to push past averse fee estimations.
+    pub txs_to_consider: HashSet<MemPoolWalkTxTypes>,
+    /// Origin addresses to whitelist when doing a mempool walk.  This is used by boosted and
+    /// neutral miners to push transactions through that are important to them.
+    pub filter_origins: HashSet<StacksAddress>,
+    /// When selecting the "nicest" tip, do not consider tips that are more than this many blocks
+    /// behind the highest tip.
+    pub max_reorg_depth: u64,
 }
 
 impl MinerConfig {
     pub fn default() -> MinerConfig {
         MinerConfig {
-            min_tx_fee: 1,
-            first_attempt_time_ms: 5_000,
-            subsequent_attempt_time_ms: 30_000,
+            first_attempt_time_ms: 10,
+            subsequent_attempt_time_ms: 120_000,
             microblock_attempt_time_ms: 30_000,
             probability_pick_no_estimate_tx: 5,
             block_reward_recipient: None,
             segwit: false,
             wait_for_block_download: true,
-            nonce_cache_size: 10_000,
-            candidate_retry_cache_size: 10_000,
+            nonce_cache_size: 1024 * 1024,
+            candidate_retry_cache_size: 1024 * 1024,
             unprocessed_block_deadline_secs: 30,
+            min_tx_count: 0,
+            only_increase_tx_count: false,
+            unconfirmed_commits_helper: None,
+            target_win_probability: 0.0,
+            activated_vrf_key_path: None,
+            fast_rampup: false,
+            underperform_stop_threshold: None,
+            txs_to_consider: MemPoolWalkTxTypes::all(),
+            filter_origins: HashSet::new(),
+            max_reorg_depth: 3,
         }
     }
 }
@@ -2043,7 +2160,6 @@ pub struct FeeEstimationConfigFile {
 
 #[derive(Clone, Deserialize, Default, Debug)]
 pub struct MinerConfigFile {
-    pub min_tx_fee: Option<u64>,
     pub first_attempt_time_ms: Option<u64>,
     pub subsequent_attempt_time_ms: Option<u64>,
     pub microblock_attempt_time_ms: Option<u64>,
@@ -2053,6 +2169,16 @@ pub struct MinerConfigFile {
     pub nonce_cache_size: Option<u64>,
     pub candidate_retry_cache_size: Option<u64>,
     pub unprocessed_block_deadline_secs: Option<u64>,
+    pub min_tx_count: Option<u64>,
+    pub only_increase_tx_count: Option<bool>,
+    pub unconfirmed_commits_helper: Option<String>,
+    pub target_win_probability: Option<f64>,
+    pub activated_vrf_key_path: Option<String>,
+    pub fast_rampup: Option<bool>,
+    pub underperform_stop_threshold: Option<u64>,
+    pub txs_to_consider: Option<String>,
+    pub filter_origins: Option<String>,
+    pub max_reorg_depth: Option<u64>,
 }
 
 #[derive(Clone, Deserialize, Default, Debug)]
diff --git a/testnet/stacks-node/src/main.rs b/testnet/stacks-node/src/main.rs
index 33f1214dc9..6495beab74 100644
--- a/testnet/stacks-node/src/main.rs
+++ b/testnet/stacks-node/src/main.rs
@@ -24,6 +24,7 @@ use stacks_common::util::hash::hex_bytes;
 pub mod monitoring;
 
 pub mod burnchains;
+pub mod chain_data;
 pub mod config;
 pub mod event_dispatcher;
 pub mod genesis_data;
@@ -35,11 +36,17 @@ pub mod run_loop;
 pub mod syncctl;
 pub mod tenure;
 
+use std::collections::HashMap;
 use std::convert::TryInto;
 use std::{env, panic, process};
 
 use backtrace::Backtrace;
 use pico_args::Arguments;
+use stacks::chainstate::burn::db::sortdb::SortitionDB;
+use stacks::chainstate::burn::operations::leader_block_commit::RewardSetInfo;
+use stacks::chainstate::coordinator::{get_next_recipients, OnChainRewardSetProvider};
+use stacks::chainstate::stacks::address::PoxAddress;
+use stacks::chainstate::stacks::db::StacksChainState;
 
 pub use self::burnchains::{
     BitcoinRegtestController, BurnchainController, BurnchainTip, MocknetController,
@@ -50,6 +57,212 @@ pub use self::keychain::Keychain;
 pub use self::node::{ChainTip, Node};
 pub use self::run_loop::{helium, neon};
 pub use self::tenure::Tenure;
+use crate::chain_data::MinerStats;
+use crate::neon_node::{BlockMinerThread, TipCandidate};
+
+/// Implmentation of `pick_best_tip` CLI option
+fn cli_pick_best_tip(config_path: &str, at_stacks_height: Option<u64>) -> TipCandidate {
+    info!("Loading config at path {}", config_path);
+    let config = match ConfigFile::from_path(config_path) {
+        Ok(config_file) => Config::from_config_file(config_file).unwrap(),
+        Err(e) => {
+            warn!("Invalid config file: {}", e);
+            process::exit(1);
+        }
+    };
+    let burn_db_path = config.get_burn_db_file_path();
+    let stacks_chainstate_path = config.get_chainstate_path_str();
+    let burnchain = config.get_burnchain();
+    let (mut chainstate, _) = StacksChainState::open(
+        config.is_mainnet(),
+        config.burnchain.chain_id,
+        &stacks_chainstate_path,
+        Some(config.node.get_marf_opts()),
+    )
+    .unwrap();
+    let mut sortdb =
+        SortitionDB::open(&burn_db_path, false, burnchain.pox_constants.clone()).unwrap();
+
+    let max_depth = config.miner.max_reorg_depth;
+
+    // There could be more than one possible chain tip. Go find them.
+    let stacks_tips = BlockMinerThread::load_candidate_tips(
+        &mut sortdb,
+        &mut chainstate,
+        max_depth,
+        at_stacks_height,
+    );
+
+    let best_tip = BlockMinerThread::inner_pick_best_tip(stacks_tips, HashMap::new()).unwrap();
+    best_tip
+}
+
+/// Implementation of `get_miner_spend` CLI option
+fn cli_get_miner_spend(
+    config_path: &str,
+    mine_start: Option<u64>,
+    at_burnchain_height: Option<u64>,
+) -> u64 {
+    info!("Loading config at path {}", config_path);
+    let config = match ConfigFile::from_path(&config_path) {
+        Ok(config_file) => Config::from_config_file(config_file).unwrap(),
+        Err(e) => {
+            warn!("Invalid config file: {}", e);
+            process::exit(1);
+        }
+    };
+    let keychain = Keychain::default(config.node.seed.clone());
+    let burn_db_path = config.get_burn_db_file_path();
+    let stacks_chainstate_path = config.get_chainstate_path_str();
+    let burnchain = config.get_burnchain();
+    let (mut chainstate, _) = StacksChainState::open(
+        config.is_mainnet(),
+        config.burnchain.chain_id,
+        &stacks_chainstate_path,
+        Some(config.node.get_marf_opts()),
+    )
+    .unwrap();
+    let mut sortdb =
+        SortitionDB::open(&burn_db_path, true, burnchain.pox_constants.clone()).unwrap();
+    let tip = if let Some(at_burnchain_height) = at_burnchain_height {
+        let tip = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn()).unwrap();
+        let ih = sortdb.index_handle(&tip.sortition_id);
+        ih.get_block_snapshot_by_height(at_burnchain_height)
+            .unwrap()
+            .unwrap()
+    } else {
+        SortitionDB::get_canonical_burn_chain_tip(sortdb.conn()).unwrap()
+    };
+
+    let recipients = get_next_recipients(
+        &tip,
+        &mut chainstate,
+        &mut sortdb,
+        &burnchain,
+        &OnChainRewardSetProvider(),
+        config.node.always_use_affirmation_maps,
+    )
+    .unwrap();
+
+    let commit_outs = if !burnchain.is_in_prepare_phase(tip.block_height + 1) {
+        RewardSetInfo::into_commit_outs(recipients, config.is_mainnet())
+    } else {
+        vec![PoxAddress::standard_burn_address(config.is_mainnet())]
+    };
+
+    let spend_amount = BlockMinerThread::get_mining_spend_amount(
+        &config,
+        &keychain,
+        &burnchain,
+        &mut sortdb,
+        &commit_outs,
+        mine_start.unwrap_or(tip.block_height),
+        at_burnchain_height,
+        |burn_block_height| {
+            let sortdb =
+                SortitionDB::open(&burn_db_path, true, burnchain.pox_constants.clone()).unwrap();
+            let Some(miner_stats) = config.get_miner_stats() else {
+                return 0.0;
+            };
+            let Ok(active_miners_and_commits) =
+                MinerStats::get_active_miners(&sortdb, Some(burn_block_height)).map_err(|e| {
+                    warn!("Failed to get active miners: {:?}", &e);
+                    e
+                })
+            else {
+                return 0.0;
+            };
+            if active_miners_and_commits.len() == 0 {
+                warn!("No active miners detected; using config file burn_fee_cap");
+                return 0.0;
+            }
+
+            let active_miners: Vec<_> = active_miners_and_commits
+                .iter()
+                .map(|(miner, _cmt)| miner.as_str())
+                .collect();
+
+            info!("Active miners: {:?}", &active_miners);
+
+            let Ok(unconfirmed_block_commits) = miner_stats
+                .get_unconfirmed_commits(burn_block_height + 1, &active_miners)
+                .map_err(|e| {
+                    warn!("Failed to find unconfirmed block-commits: {}", &e);
+                    e
+                })
+            else {
+                return 0.0;
+            };
+
+            let unconfirmed_miners_and_amounts: Vec<(String, u64)> = unconfirmed_block_commits
+                .iter()
+                .map(|cmt| (format!("{}", &cmt.apparent_sender), cmt.burn_fee))
+                .collect();
+
+            info!(
+                "Found unconfirmed block-commits: {:?}",
+                &unconfirmed_miners_and_amounts
+            );
+
+            let (spend_dist, _total_spend) = MinerStats::get_spend_distribution(
+                &active_miners_and_commits,
+                &unconfirmed_block_commits,
+                &commit_outs,
+            );
+            let win_probs = if config.miner.fast_rampup {
+                // look at spends 6+ blocks in the future
+                let win_probs = MinerStats::get_future_win_distribution(
+                    &active_miners_and_commits,
+                    &unconfirmed_block_commits,
+                    &commit_outs,
+                );
+                win_probs
+            } else {
+                // look at the current spends
+                let Ok(unconfirmed_burn_dist) = miner_stats
+                    .get_unconfirmed_burn_distribution(
+                        &burnchain,
+                        &sortdb,
+                        &active_miners_and_commits,
+                        unconfirmed_block_commits,
+                        &commit_outs,
+                        at_burnchain_height,
+                    )
+                    .map_err(|e| {
+                        warn!("Failed to get unconfirmed burn distribution: {:?}", &e);
+                        e
+                    })
+                else {
+                    return 0.0;
+                };
+
+                let win_probs = MinerStats::burn_dist_to_prob_dist(&unconfirmed_burn_dist);
+                win_probs
+            };
+
+            info!("Unconfirmed spend distribution: {:?}", &spend_dist);
+            info!(
+                "Unconfirmed win probabilities (fast_rampup={}): {:?}",
+                config.miner.fast_rampup, &win_probs
+            );
+
+            let miner_addrs = BlockMinerThread::get_miner_addrs(&config, &keychain);
+            let win_prob = miner_addrs
+                .iter()
+                .find_map(|x| win_probs.get(x))
+                .copied()
+                .unwrap_or(0.0);
+
+            info!(
+                "This miner's win probability at {} is {}",
+                tip.block_height, &win_prob
+            );
+            win_prob
+        },
+        |_burn_block_height, _win_prob| {},
+    );
+    spend_amount
+}
 
 fn main() {
     panic::set_hook(Box::new(|panic_info| {
@@ -91,24 +304,24 @@ fn main() {
 
     let config_file = match subcommand.as_str() {
         "mocknet" => {
-            args.finish().unwrap();
+            args.finish();
             ConfigFile::mocknet()
         }
         "helium" => {
-            args.finish().unwrap();
+            args.finish();
             ConfigFile::helium()
         }
         "testnet" => {
-            args.finish().unwrap();
+            args.finish();
             ConfigFile::xenon()
         }
         "mainnet" => {
-            args.finish().unwrap();
+            args.finish();
             ConfigFile::mainnet()
         }
         "check-config" => {
             let config_path: String = args.value_from_str("--config").unwrap();
-            args.finish().unwrap();
+            args.finish();
             info!("Loading config at path {}", config_path);
             let config_file = match ConfigFile::from_path(&config_path) {
                 Ok(config_file) => {
@@ -133,7 +346,7 @@ fn main() {
         }
         "start" => {
             let config_path: String = args.value_from_str("--config").unwrap();
-            args.finish().unwrap();
+            args.finish();
             info!("Loading config at path {}", config_path);
             match ConfigFile::from_path(&config_path) {
                 Ok(config_file) => config_file,
@@ -154,14 +367,15 @@ fn main() {
                     let conf =
                         Config::from_config_file(ConfigFile::from_path(&config_path).unwrap())
                             .unwrap();
-                    args.finish().unwrap();
+                    args.finish();
                     conf.node.seed
                 } else {
-                    let free_args = args.free().unwrap();
+                    let free_args = args.finish();
                     let seed_hex = free_args
                         .first()
                         .expect("`wif-for-seed` must be passed either a config file via the `--config` flag or a hex seed string");
-                    hex_bytes(seed_hex).expect("Seed should be a hex encoded string")
+                    hex_bytes(seed_hex.to_str().unwrap())
+                        .expect("Seed should be a hex encoded string")
                 }
             };
             let keychain = Keychain::default(seed);
@@ -175,6 +389,26 @@ fn main() {
             );
             return;
         }
+        "pick-best-tip" => {
+            let config_path: String = args.value_from_str("--config").unwrap();
+            let at_stacks_height: Option<u64> =
+                args.opt_value_from_str("--at-stacks-height").unwrap();
+            args.finish();
+
+            let best_tip = cli_pick_best_tip(&config_path, at_stacks_height);
+            println!("Best tip is {:?}", &best_tip);
+            process::exit(0);
+        }
+        "get-spend-amount" => {
+            let config_path: String = args.value_from_str("--config").unwrap();
+            let at_burnchain_height: Option<u64> =
+                args.opt_value_from_str("--at-bitcoin-height").unwrap();
+            args.finish();
+
+            let spend_amount = cli_get_miner_spend(&config_path, mine_start, at_burnchain_height);
+            println!("Will spend {}", spend_amount);
+            process::exit(0);
+        }
         _ => {
             print_help();
             return;
diff --git a/testnet/stacks-node/src/neon_node.rs b/testnet/stacks-node/src/neon_node.rs
index 517f080cb6..56f777076e 100644
--- a/testnet/stacks-node/src/neon_node.rs
+++ b/testnet/stacks-node/src/neon_node.rs
@@ -1,5 +1,5 @@
 // Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
-// Copyright (C) 2020 Stacks Open Internet Foundation
+// Copyright (C) 2020-2024 Stacks Open Internet Foundation
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -138,20 +138,23 @@
 ///
 /// This file may be refactored in the future into a full-fledged module.
 use std::cmp;
-use std::collections::{HashMap, VecDeque};
+use std::cmp::Ordering as CmpOrdering;
+use std::collections::{BTreeMap, HashMap, HashSet, VecDeque};
 use std::convert::{TryFrom, TryInto};
 use std::default::Default;
+use std::io::{Read, Write};
 use std::net::SocketAddr;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::mpsc::{Receiver, SyncSender, TrySendError};
 use std::sync::{Arc, Mutex};
 use std::thread::JoinHandle;
 use std::time::Duration;
-use std::{mem, thread};
+use std::{fs, mem, thread};
 
 use clarity::vm::ast::ASTRules;
 use clarity::vm::costs::ExecutionCost;
 use clarity::vm::types::{PrincipalData, QualifiedContractIdentifier};
+use stacks::burnchains::bitcoin::address::{BitcoinAddress, LegacyBitcoinAddressType};
 use stacks::burnchains::db::BurnchainHeaderReader;
 use stacks::burnchains::{Burnchain, BurnchainParameters, BurnchainSigner, Txid};
 use stacks::chainstate::burn::db::sortdb::SortitionDB;
@@ -165,11 +168,12 @@ use stacks::chainstate::burn::{BlockSnapshot, ConsensusHash};
 use stacks::chainstate::coordinator::comm::CoordinatorChannels;
 use stacks::chainstate::coordinator::{get_next_recipients, OnChainRewardSetProvider};
 use stacks::chainstate::stacks::address::PoxAddress;
+use stacks::chainstate::stacks::db::blocks::StagingBlock;
 use stacks::chainstate::stacks::db::unconfirmed::UnconfirmedTxMap;
 use stacks::chainstate::stacks::db::{StacksChainState, StacksHeaderInfo, MINER_REWARD_MATURITY};
 use stacks::chainstate::stacks::miner::{
-    get_mining_spend_amount, signal_mining_blocked, signal_mining_ready, BlockBuilderSettings,
-    MinerStatus, StacksMicroblockBuilder,
+    signal_mining_blocked, signal_mining_ready, BlockBuilderSettings, MinerStatus,
+    StacksMicroblockBuilder,
 };
 use stacks::chainstate::stacks::{
     CoinbasePayload, Error as ChainstateError, StacksBlock, StacksBlockBuilder, StacksBlockHeader,
@@ -198,7 +202,7 @@ use stacks_common::types::chainstate::{
     StacksPrivateKey, VRFSeed,
 };
 use stacks_common::types::net::PeerAddress;
-use stacks_common::types::StacksEpochId;
+use stacks_common::types::{PublicKey, StacksEpochId};
 use stacks_common::util::hash::{to_hex, Hash160, Sha256Sum};
 use stacks_common::util::secp256k1::Secp256k1PrivateKey;
 use stacks_common::util::vrf::{VRFProof, VRFPublicKey};
@@ -209,6 +213,8 @@ use crate::burnchains::bitcoin_regtest_controller::{
     addr2str, BitcoinRegtestController, OngoingBlockCommit,
 };
 use crate::burnchains::make_bitcoin_indexer;
+use crate::chain_data::MinerStats;
+use crate::config::MinerConfig;
 use crate::run_loop::neon::{Counters, RunLoop};
 use crate::run_loop::RegisteredKey;
 use crate::syncctl::PoxSyncWatchdogComms;
@@ -222,7 +228,7 @@ pub const BLOCK_PROCESSOR_STACK_SIZE: usize = 32 * 1024 * 1024; // 32 MB
 type MinedBlocks = HashMap<BlockHeaderHash, (AssembledAnchorBlock, Secp256k1PrivateKey)>;
 
 /// Result of running the miner thread.  It could produce a Stacks block or a microblock.
-enum MinerThreadResult {
+pub(crate) enum MinerThreadResult {
     Block(
         AssembledAnchorBlock,
         Secp256k1PrivateKey,
@@ -238,7 +244,7 @@ enum MinerThreadResult {
 /// linked to the burnchain and what view(s) the miner had of the burnchain before and after
 /// completing the block.
 #[derive(Clone)]
-struct AssembledAnchorBlock {
+pub struct AssembledAnchorBlock {
     /// Consensus hash of the parent Stacks block
     parent_consensus_hash: ConsensusHash,
     /// Burnchain tip's block hash when we finished mining
@@ -291,6 +297,15 @@ pub struct Globals {
     pub should_keep_running: Arc<AtomicBool>,
     /// Status of our VRF key registration state (shared between the main thread and the relayer)
     leader_key_registration_state: Arc<Mutex<LeaderKeyRegistrationState>>,
+    /// Last miner config loaded
+    last_miner_config: Arc<Mutex<Option<MinerConfig>>>,
+    /// burnchain height at which we start mining
+    start_mining_height: Arc<Mutex<u64>>,
+    /// estimated winning probability at given bitcoin block heights
+    estimated_winning_probs: Arc<Mutex<HashMap<u64, f64>>>,
+    /// previously-selected best tips
+    /// maps stacks height to tip candidate
+    previous_best_tips: Arc<Mutex<BTreeMap<u64, TipCandidate>>>,
 }
 
 /// Miner chain tip, on top of which to build microblocks
@@ -334,6 +349,7 @@ impl Globals {
         counters: Counters,
         sync_comms: PoxSyncWatchdogComms,
         should_keep_running: Arc<AtomicBool>,
+        start_mining_height: u64,
     ) -> Globals {
         Globals {
             last_sortition: Arc::new(Mutex::new(None)),
@@ -347,6 +363,10 @@ impl Globals {
             leader_key_registration_state: Arc::new(Mutex::new(
                 LeaderKeyRegistrationState::Inactive,
             )),
+            last_miner_config: Arc::new(Mutex::new(None)),
+            start_mining_height: Arc::new(Mutex::new(start_mining_height)),
+            estimated_winning_probs: Arc::new(Mutex::new(HashMap::new())),
+            previous_best_tips: Arc::new(Mutex::new(BTreeMap::new())),
         }
     }
 
@@ -486,8 +506,8 @@ impl Globals {
         &self,
         burn_block_height: u64,
         key_registers: Vec<LeaderKeyRegisterOp>,
-    ) -> bool {
-        let mut activated = false;
+    ) -> Option<RegisteredKey> {
+        let mut activated_key = None;
         match self.leader_key_registration_state.lock() {
             Ok(ref mut leader_key_registration_state) => {
                 for op in key_registers.into_iter() {
@@ -499,14 +519,17 @@ impl Globals {
                             burn_block_height, txid
                         );
                         if txid == op.txid {
+                            let active_key = RegisteredKey {
+                                target_block_height,
+                                vrf_public_key: op.public_key,
+                                block_height: op.block_height as u64,
+                                op_vtxindex: op.vtxindex as u32,
+                            };
+
                             **leader_key_registration_state =
-                                LeaderKeyRegistrationState::Active(RegisteredKey {
-                                    target_block_height,
-                                    vrf_public_key: op.public_key,
-                                    block_height: op.block_height as u64,
-                                    op_vtxindex: op.vtxindex as u32,
-                                });
-                            activated = true;
+                                LeaderKeyRegistrationState::Active(active_key.clone());
+
+                            activated_key = Some(active_key);
                         } else {
                             debug!(
                                 "key_register_op {} does not match our pending op {}",
@@ -521,7 +544,126 @@ impl Globals {
                 panic!();
             }
         }
-        activated
+        activated_key
+    }
+
+    /// Directly set the leader key activation state from a saved key
+    pub fn resume_leader_key(&self, registered_key: RegisteredKey) {
+        match self.leader_key_registration_state.lock() {
+            Ok(ref mut leader_key_registration_state) => {
+                **leader_key_registration_state = LeaderKeyRegistrationState::Active(registered_key)
+            }
+            Err(_e) => {
+                error!("FATAL: failed to lock leader key registration state mutex");
+                panic!();
+            }
+        }
+    }
+
+    /// Get the last miner config loaded
+    pub fn get_last_miner_config(&self) -> Option<MinerConfig> {
+        match self.last_miner_config.lock() {
+            Ok(last_miner_config) => (*last_miner_config).clone(),
+            Err(_e) => {
+                error!("FATAL; failed to lock last miner config");
+                panic!();
+            }
+        }
+    }
+
+    /// Set the last miner config loaded
+    pub fn set_last_miner_config(&self, miner_config: MinerConfig) {
+        match self.last_miner_config.lock() {
+            Ok(ref mut last_miner_config) => **last_miner_config = Some(miner_config),
+            Err(_e) => {
+                error!("FATAL; failed to lock last miner config");
+                panic!();
+            }
+        }
+    }
+
+    /// Get the height at which we should start mining
+    pub fn get_start_mining_height(&self) -> u64 {
+        match self.start_mining_height.lock() {
+            Ok(ht) => *ht,
+            Err(_e) => {
+                error!("FATAL: failed to lock start_mining_height");
+                panic!();
+            }
+        }
+    }
+
+    /// Set the height at which we started mining.
+    /// Only takes effect if the current start mining height is 0.
+    pub fn set_start_mining_height_if_zero(&self, value: u64) {
+        match self.start_mining_height.lock() {
+            Ok(ref mut ht) => {
+                if **ht == 0 {
+                    **ht = value;
+                }
+            }
+            Err(_e) => {
+                error!("FATAL: failed to lock start_mining_height");
+                panic!();
+            }
+        }
+    }
+
+    /// Record an estimated winning probability
+    pub fn add_estimated_win_prob(&self, burn_height: u64, win_prob: f64) {
+        match self.estimated_winning_probs.lock() {
+            Ok(mut probs) => {
+                probs.insert(burn_height, win_prob);
+            }
+            Err(_e) => {
+                error!("FATAL: failed to lock estimated_winning_probs");
+                panic!();
+            }
+        }
+    }
+
+    /// Get the estimated winning probability, if we have one
+    pub fn get_estimated_win_prob(&self, burn_height: u64) -> Option<f64> {
+        match self.estimated_winning_probs.lock() {
+            Ok(probs) => probs.get(&burn_height).cloned(),
+            Err(_e) => {
+                error!("FATAL: failed to lock estimated_winning_probs");
+                panic!();
+            }
+        }
+    }
+
+    /// Record a best-tip
+    pub fn add_best_tip(&self, stacks_height: u64, tip_candidate: TipCandidate, max_depth: u64) {
+        match self.previous_best_tips.lock() {
+            Ok(mut tips) => {
+                tips.insert(stacks_height, tip_candidate);
+                let mut stale = vec![];
+                for (prev_height, _) in tips.iter() {
+                    if *prev_height + max_depth < stacks_height {
+                        stale.push(*prev_height);
+                    }
+                }
+                for height in stale.into_iter() {
+                    tips.remove(&height);
+                }
+            }
+            Err(_e) => {
+                error!("FATAL: failed to lock previous_best_tips");
+                panic!();
+            }
+        }
+    }
+
+    /// Get a best-tip at a previous height
+    pub fn get_best_tip(&self, stacks_height: u64) -> Option<TipCandidate> {
+        match self.previous_best_tips.lock() {
+            Ok(tips) => tips.get(&stacks_height).cloned(),
+            Err(_e) => {
+                error!("FATAL: failed to lock previous_best_tips");
+                panic!();
+            }
+        }
     }
 }
 
@@ -735,7 +877,7 @@ pub struct RelayerThread {
     mined_stacks_block: bool,
 }
 
-struct BlockMinerThread {
+pub(crate) struct BlockMinerThread {
     /// node config struct
     config: Config,
     /// handle to global state
@@ -1053,8 +1195,6 @@ impl MicroblockMinerThread {
 
             #[cfg(any(test, feature = "testing"))]
             {
-                use std::fs;
-                use std::io::Write;
                 use std::path::Path;
                 if let Ok(path) = std::env::var("STACKS_BAD_BLOCKS_DIR") {
                     // record this microblock somewhere
@@ -1206,6 +1346,46 @@ impl MicroblockMinerThread {
     }
 }
 
+/// Candidate chain tip
+#[derive(Debug, Clone, PartialEq)]
+pub struct TipCandidate {
+    pub stacks_height: u64,
+    pub consensus_hash: ConsensusHash,
+    pub anchored_block_hash: BlockHeaderHash,
+    pub parent_consensus_hash: ConsensusHash,
+    pub parent_anchored_block_hash: BlockHeaderHash,
+    /// the block's sortition's burnchain height
+    pub burn_height: u64,
+    /// the number of Stacks blocks *at the same height* as this one, but from earlier sortitions
+    /// than `burn_height`
+    pub num_earlier_siblings: u64,
+}
+
+impl TipCandidate {
+    pub fn id(&self) -> StacksBlockId {
+        StacksBlockId::new(&self.consensus_hash, &self.anchored_block_hash)
+    }
+
+    pub fn parent_id(&self) -> StacksBlockId {
+        StacksBlockId::new(
+            &self.parent_consensus_hash,
+            &self.parent_anchored_block_hash,
+        )
+    }
+
+    pub fn new(tip: StagingBlock, burn_height: u64) -> Self {
+        Self {
+            stacks_height: tip.height,
+            consensus_hash: tip.consensus_hash,
+            anchored_block_hash: tip.anchored_block_hash,
+            parent_consensus_hash: tip.parent_consensus_hash,
+            parent_anchored_block_hash: tip.parent_anchored_block_hash,
+            burn_height,
+            num_earlier_siblings: 0,
+        }
+    }
+}
+
 impl BlockMinerThread {
     /// Instantiate the miner thread from its parent RelayerThread
     pub fn from_relayer_thread(
@@ -1228,11 +1408,12 @@ impl BlockMinerThread {
 
     /// Get the coinbase recipient address, if set in the config and if allowed in this epoch
     fn get_coinbase_recipient(&self, epoch_id: StacksEpochId) -> Option<PrincipalData> {
-        if epoch_id < StacksEpochId::Epoch21 && self.config.miner.block_reward_recipient.is_some() {
+        let miner_config = self.config.get_miner_config();
+        if epoch_id < StacksEpochId::Epoch21 && miner_config.block_reward_recipient.is_some() {
             warn!("Coinbase pay-to-contract is not supported in the current epoch");
             None
         } else {
-            self.config.miner.block_reward_recipient.clone()
+            miner_config.block_reward_recipient.clone()
         }
     }
 
@@ -1343,6 +1524,320 @@ impl BlockMinerThread {
         ret
     }
 
+    /// Load all candidate tips upon which to build.  This is all Stacks blocks whose heights are
+    /// less than or equal to at `at_stacks_height` (or the canonical chain tip height, if not given),
+    /// but greater than or equal to this end height minus `max_depth`.
+    /// Returns the list of all Stacks blocks up to max_depth blocks beneath it.
+    /// The blocks will be sorted first by stacks height, and then by burnchain height
+    pub(crate) fn load_candidate_tips(
+        burn_db: &mut SortitionDB,
+        chain_state: &mut StacksChainState,
+        max_depth: u64,
+        at_stacks_height: Option<u64>,
+    ) -> Vec<TipCandidate> {
+        let stacks_tips = if let Some(start_height) = at_stacks_height {
+            chain_state
+                .get_stacks_chain_tips_at_height(start_height)
+                .expect("FATAL: could not query chain tips at start height")
+        } else {
+            chain_state
+                .get_stacks_chain_tips(burn_db)
+                .expect("FATAL: could not query chain tips")
+        };
+
+        if stacks_tips.len() == 0 {
+            return vec![];
+        }
+
+        let mut considered = HashSet::new();
+        let mut candidates = vec![];
+        let end_height = stacks_tips[0].height;
+
+        for cur_height in end_height.saturating_sub(max_depth)..=end_height {
+            let stacks_tips = chain_state
+                .get_stacks_chain_tips_at_height(cur_height)
+                .expect("FATAL: could not query chain tips at height");
+
+            for tip in stacks_tips {
+                let index_block_hash =
+                    StacksBlockId::new(&tip.consensus_hash, &tip.anchored_block_hash);
+
+                if !considered.contains(&index_block_hash) {
+                    let burn_height = burn_db
+                        .get_consensus_hash_height(&tip.consensus_hash)
+                        .expect("FATAL: could not query burnchain block height")
+                        .expect("FATAL: no burnchain block height for Stacks tip");
+                    let candidate = TipCandidate::new(tip, burn_height);
+                    candidates.push(candidate);
+                    considered.insert(index_block_hash);
+                }
+            }
+        }
+        Self::sort_and_populate_candidates(candidates)
+    }
+
+    /// Put all tip candidates in order by stacks height, breaking ties with burnchain height.
+    /// Also, count up the number of earliersiblings each tip has -- i.e. the number of stacks
+    /// blocks that have the same height, but a later burnchain sortition.
+    pub(crate) fn sort_and_populate_candidates(
+        mut candidates: Vec<TipCandidate>,
+    ) -> Vec<TipCandidate> {
+        if candidates.len() == 0 {
+            return candidates;
+        }
+        candidates.sort_by(|tip1, tip2| {
+            // stacks block height, then burnchain block height
+            let ord = tip1.stacks_height.cmp(&tip2.stacks_height);
+            if ord == CmpOrdering::Equal {
+                return tip1.burn_height.cmp(&tip2.burn_height);
+            }
+            ord
+        });
+
+        // calculate the number of earlier siblings for each block.
+        // this is the number of stacks blocks at the same height, but later burnchain heights.
+        let mut idx = 0;
+        let mut cur_stacks_height = candidates[idx].stacks_height;
+        let mut num_siblings = 0;
+        loop {
+            idx += 1;
+            if idx >= candidates.len() {
+                break;
+            }
+            if cur_stacks_height == candidates[idx].stacks_height {
+                // same stacks height, so this block has one more earlier sibling than the last
+                num_siblings += 1;
+                candidates[idx].num_earlier_siblings = num_siblings;
+            } else {
+                // new stacks height, so no earlier siblings
+                num_siblings = 0;
+                cur_stacks_height = candidates[idx].stacks_height;
+                candidates[idx].num_earlier_siblings = 0;
+            }
+        }
+
+        candidates
+    }
+
+    /// Select the best tip to mine the next block on. Potential tips are all
+    /// leaf nodes where the Stacks block height is <= the max height -
+    /// max_reorg_depth. Each potential tip is then scored based on the amount
+    /// of orphans that its chain has caused -- that is, the number of orphans
+    /// that the tip _and all of its ancestors_ (up to `max_depth`) created.
+    /// The tip with the lowest score is composed of blocks that collectively made the fewest
+    /// orphans, and is thus the "nicest" chain with the least orphaning.  This is the tip that is
+    /// selected.
+    pub fn pick_best_tip(
+        globals: &Globals,
+        config: &Config,
+        burn_db: &mut SortitionDB,
+        chain_state: &mut StacksChainState,
+        at_stacks_height: Option<u64>,
+    ) -> Option<TipCandidate> {
+        info!("Picking best Stacks tip");
+        let miner_config = config.get_miner_config();
+        let max_depth = miner_config.max_reorg_depth;
+
+        // There could be more than one possible chain tip. Go find them.
+        let stacks_tips =
+            Self::load_candidate_tips(burn_db, chain_state, max_depth, at_stacks_height);
+
+        let mut previous_best_tips = HashMap::new();
+        for tip in stacks_tips.iter() {
+            let Some(prev_best_tip) = globals.get_best_tip(tip.stacks_height) else {
+                continue;
+            };
+            previous_best_tips.insert(tip.stacks_height, prev_best_tip);
+        }
+
+        let best_tip_opt = Self::inner_pick_best_tip(stacks_tips, previous_best_tips);
+        if let Some(best_tip) = best_tip_opt.as_ref() {
+            globals.add_best_tip(best_tip.stacks_height, best_tip.clone(), max_depth);
+        } else {
+            // no best-tip found; revert to old tie-breaker logic
+            info!("No best-tips found; using old tie-breaking logic");
+            return chain_state
+                .get_stacks_chain_tip(burn_db)
+                .expect("FATAL: could not load chain tip")
+                .map(|staging_block| {
+                    let burn_height = burn_db
+                        .get_consensus_hash_height(&staging_block.consensus_hash)
+                        .expect("FATAL: could not query burnchain block height")
+                        .expect("FATAL: no burnchain block height for Stacks tip");
+                    TipCandidate::new(staging_block, burn_height)
+                });
+        }
+        best_tip_opt
+    }
+
+    /// Given a list of sorted candidate tips, pick the best one.  See `Self::pick_best_tip()`.
+    /// Takes the list of stacks tips that are eligible to be built on, and a map of
+    /// previously-chosen best tips (so if we chose a tip in the past, we keep confirming it, even
+    /// if subsequent stacks blocks show up).  The previous best tips should be from recent Stacks
+    /// heights; it's important that older best-tips are forgotten in order to ensure that miners
+    /// will eventually (e.g. after `max_reorg_depth` Stacks blocks pass) stop trying to confirm a
+    /// now-orphaned previously-chosen best-tip.  If there are multiple best-tips that conflict in
+    /// `previosu_best_tips`, then only the highest one which the leaf could confirm will be
+    /// considered (since the node updates its understanding of the best-tip on each RunTenure).
+    pub(crate) fn inner_pick_best_tip(
+        stacks_tips: Vec<TipCandidate>,
+        previous_best_tips: HashMap<u64, TipCandidate>,
+    ) -> Option<TipCandidate> {
+        // identify leaf tips -- i.e. blocks with no children
+        let parent_consensus_hashes: HashSet<_> = stacks_tips
+            .iter()
+            .map(|x| x.parent_consensus_hash.clone())
+            .collect();
+
+        let mut leaf_tips: Vec<_> = stacks_tips
+            .iter()
+            .filter(|x| !parent_consensus_hashes.contains(&x.consensus_hash))
+            .collect();
+
+        if leaf_tips.len() == 0 {
+            return None;
+        }
+
+        // Make scoring deterministic in the case of a tie.
+        // Prefer leafs that were mined earlier on the burnchain,
+        // but which pass through previously-determined best tips.
+        leaf_tips.sort_by(|tip1, tip2| {
+            // stacks block height, then burnchain block height
+            let ord = tip1.stacks_height.cmp(&tip2.stacks_height);
+            if ord == CmpOrdering::Equal {
+                return tip1.burn_height.cmp(&tip2.burn_height);
+            }
+            ord
+        });
+
+        let mut scores = BTreeMap::new();
+        for (i, leaf_tip) in leaf_tips.iter().enumerate() {
+            let leaf_id = leaf_tip.id();
+            // Score each leaf tip as the number of preceding Stacks blocks that are _not_ an
+            // ancestor.  Because stacks_tips are in order by stacks height, a linear scan of this
+            // list will allow us to match all ancestors in the last max_depth Stacks blocks.
+            // `ancestor_ptr` tracks the next expected ancestor.
+            let mut ancestor_ptr = leaf_tip.parent_id();
+            let mut score: u64 = 0;
+            let mut score_summaries = vec![];
+
+            // find the highest stacks_tip we must confirm
+            let mut must_confirm = None;
+            for tip in stacks_tips.iter().rev() {
+                if let Some(prev_best_tip) = previous_best_tips.get(&tip.stacks_height) {
+                    if leaf_id != prev_best_tip.id() {
+                        // the `ancestor_ptr` must pass through this prior best-tip
+                        must_confirm = Some(prev_best_tip.clone());
+                        break;
+                    }
+                }
+            }
+
+            for tip in stacks_tips.iter().rev() {
+                if let Some(required_ancestor) = must_confirm.as_ref() {
+                    if tip.stacks_height < required_ancestor.stacks_height
+                        && leaf_tip.stacks_height >= required_ancestor.stacks_height
+                    {
+                        // This leaf does not confirm a previous-best-tip, so assign it the
+                        // worst-possible score.
+                        info!("Tip #{} {}/{} at {}:{} conflicts with a previous best-tip {}/{} at {}:{}",
+                              i,
+                              &leaf_tip.consensus_hash,
+                              &leaf_tip.anchored_block_hash,
+                              leaf_tip.burn_height,
+                              leaf_tip.stacks_height,
+                              &required_ancestor.consensus_hash,
+                              &required_ancestor.anchored_block_hash,
+                              required_ancestor.burn_height,
+                              required_ancestor.stacks_height
+                        );
+                        score = u64::MAX;
+                        score_summaries.push(format!("{} (best-tip reorged)", u64::MAX));
+                        break;
+                    }
+                }
+                if tip.id() == leaf_id {
+                    // we can't orphan ourselves
+                    continue;
+                }
+                if leaf_tip.stacks_height < tip.stacks_height {
+                    // this tip is further along than leaf_tip, so canonicalizing leaf_tip would
+                    // orphan `tip.stacks_height - leaf_tip.stacks_height` blocks.
+                    score = score.saturating_add(tip.stacks_height - leaf_tip.stacks_height);
+                    score_summaries.push(format!(
+                        "{} (stx height diff)",
+                        tip.stacks_height - leaf_tip.stacks_height
+                    ));
+                } else if leaf_tip.stacks_height == tip.stacks_height
+                    && leaf_tip.burn_height > tip.burn_height
+                {
+                    // this tip has the same stacks height as the leaf, but its sortition happened
+                    // earlier. This means that the leaf is trying to orphan this block and all
+                    // blocks sortition'ed up to this leaf.  The miner should have instead tried to
+                    // confirm this existing tip, instead of mine a sibling.
+                    score = score.saturating_add(tip.num_earlier_siblings + 1);
+                    score_summaries.push(format!("{} (uncles)", tip.num_earlier_siblings + 1));
+                }
+                if tip.id() == ancestor_ptr {
+                    // did we confirm a previous best-tip? If so, then clear this
+                    if let Some(required_ancestor) = must_confirm.take() {
+                        if required_ancestor.id() != tip.id() {
+                            // did not confirm, so restoroe
+                            must_confirm = Some(required_ancestor);
+                        }
+                    }
+
+                    // this stacks tip is the next ancestor.  However, that ancestor may have
+                    // earlier-sortition'ed siblings that confirming this tip would orphan, so count those.
+                    ancestor_ptr = tip.parent_id();
+                    score = score.saturating_add(tip.num_earlier_siblings);
+                    score_summaries.push(format!("{} (earlier sibs)", tip.num_earlier_siblings));
+                } else {
+                    // this stacks tip is not an ancestor, and would be orphaned if leaf_tip is
+                    // canonical.
+                    score = score.saturating_add(1);
+                    score_summaries.push(format!("{} (non-ancestor)", 1));
+                }
+            }
+
+            info!(
+                "Tip #{} {}/{} at {}:{} has score {} ({})",
+                i,
+                &leaf_tip.consensus_hash,
+                &leaf_tip.anchored_block_hash,
+                leaf_tip.burn_height,
+                leaf_tip.stacks_height,
+                score,
+                score_summaries.join(" + ").to_string()
+            );
+            if score < u64::MAX {
+                scores.insert(i, score);
+            }
+        }
+
+        if scores.len() == 0 {
+            // revert to prior tie-breaking scheme
+            return None;
+        }
+
+        // The lowest score is the "nicest" tip (least amount of orphaning)
+        let best_tip_idx = scores
+            .iter()
+            .min_by_key(|(_, score)| *score)
+            .expect("FATAL: candidates should not be empty here")
+            .0;
+
+        let best_tip = leaf_tips
+            .get(*best_tip_idx)
+            .expect("FATAL: candidates should not be empty");
+
+        info!(
+            "Best tip is #{} {}/{}",
+            best_tip_idx, &best_tip.consensus_hash, &best_tip.anchored_block_hash
+        );
+        Some((*best_tip).clone())
+    }
+
     /// Load up the parent block info for mining.
     /// If there's no parent because this is the first block, then return the genesis block's info.
     /// If we can't find the parent in the DB but we expect one, return None.
@@ -1350,22 +1845,25 @@ impl BlockMinerThread {
         &self,
         burn_db: &mut SortitionDB,
         chain_state: &mut StacksChainState,
-    ) -> Option<ParentStacksBlockInfo> {
+    ) -> (Option<ParentStacksBlockInfo>, bool) {
         if let Some(stacks_tip) = chain_state
             .get_stacks_chain_tip(burn_db)
             .expect("FATAL: could not query chain tip")
         {
+            let best_stacks_tip =
+                Self::pick_best_tip(&self.globals, &self.config, burn_db, chain_state, None)
+                    .expect("FATAL: no best chain tip");
             let miner_address = self
                 .keychain
                 .origin_address(self.config.is_mainnet())
                 .unwrap();
-            match ParentStacksBlockInfo::lookup(
+            let parent_info = match ParentStacksBlockInfo::lookup(
                 chain_state,
                 burn_db,
                 &self.burn_block,
                 miner_address,
-                &stacks_tip.consensus_hash,
-                &stacks_tip.anchored_block_hash,
+                &best_stacks_tip.consensus_hash,
+                &best_stacks_tip.anchored_block_hash,
             ) {
                 Ok(parent_info) => Some(parent_info),
                 Err(Error::BurnchainTipChanged) => {
@@ -1373,7 +1871,16 @@ impl BlockMinerThread {
                     None
                 }
                 Err(..) => None,
+            };
+            if parent_info.is_none() {
+                warn!(
+                    "No parent for best-tip {}/{}",
+                    &best_stacks_tip.consensus_hash, &best_stacks_tip.anchored_block_hash
+                );
             }
+            let canonical = best_stacks_tip.consensus_hash == stacks_tip.consensus_hash
+                && best_stacks_tip.anchored_block_hash == stacks_tip.anchored_block_hash;
+            (parent_info, canonical)
         } else {
             debug!("No Stacks chain tip known, will return a genesis block");
             let (network, _) = self.config.burnchain.get_bitcoin_network();
@@ -1387,26 +1894,30 @@ impl BlockMinerThread {
                 burnchain_params.first_block_timestamp.into(),
             );
 
-            Some(ParentStacksBlockInfo {
-                stacks_parent_header: chain_tip.metadata,
-                parent_consensus_hash: FIRST_BURNCHAIN_CONSENSUS_HASH.clone(),
-                parent_block_burn_height: 0,
-                parent_block_total_burn: 0,
-                parent_winning_vtxindex: 0,
-                coinbase_nonce: 0,
-            })
+            (
+                Some(ParentStacksBlockInfo {
+                    stacks_parent_header: chain_tip.metadata,
+                    parent_consensus_hash: FIRST_BURNCHAIN_CONSENSUS_HASH.clone(),
+                    parent_block_burn_height: 0,
+                    parent_block_total_burn: 0,
+                    parent_winning_vtxindex: 0,
+                    coinbase_nonce: 0,
+                }),
+                true,
+            )
         }
     }
 
     /// Determine which attempt this will be when mining a block, and whether or not an attempt
     /// should even be made.
-    /// Returns Some(attempt) if we should attempt to mine (and what attempt it will be)
+    /// Returns Some(attempt, max-txs) if we should attempt to mine (and what attempt it will be)
     /// Returns None if we should not mine.
     fn get_mine_attempt(
         &self,
         chain_state: &StacksChainState,
         parent_block_info: &ParentStacksBlockInfo,
-    ) -> Option<u64> {
+        force: bool,
+    ) -> Option<(u64, u64)> {
         let parent_consensus_hash = &parent_block_info.parent_consensus_hash;
         let stacks_parent_header = &parent_block_info.stacks_parent_header;
         let parent_block_burn_height = parent_block_info.parent_block_burn_height;
@@ -1415,22 +1926,28 @@ impl BlockMinerThread {
             Self::find_inflight_mined_blocks(self.burn_block.block_height, &self.last_mined_blocks);
 
         // has the tip changed from our previously-mined block for this epoch?
-        let attempt = if last_mined_blocks.len() <= 1 {
+        let (attempt, max_txs) = if last_mined_blocks.len() <= 1 {
             // always mine if we've not mined a block for this epoch yet, or
             // if we've mined just one attempt, unconditionally try again (so we
             // can use `subsequent_miner_time_ms` in this attempt)
             if last_mined_blocks.len() == 1 {
-                debug!("Have only attempted one block; unconditionally trying again");
+                info!("Have only attempted one block; unconditionally trying again");
+            }
+            let attempt = last_mined_blocks.len() as u64 + 1;
+            let mut max_txs = 0;
+            for last_mined_block in last_mined_blocks.iter() {
+                max_txs = cmp::max(max_txs, last_mined_block.anchored_block.txs.len());
             }
-            last_mined_blocks.len() as u64 + 1
+            (attempt, max_txs)
         } else {
             let mut best_attempt = 0;
-            debug!(
+            let mut max_txs = 0;
+            info!(
                 "Consider {} in-flight Stacks tip(s)",
                 &last_mined_blocks.len()
             );
             for prev_block in last_mined_blocks.iter() {
-                debug!(
+                info!(
                     "Consider in-flight block {} on Stacks tip {}/{} in {} with {} txs",
                     &prev_block.anchored_block.block_hash(),
                     &prev_block.parent_consensus_hash,
@@ -1438,6 +1955,7 @@ impl BlockMinerThread {
                     &prev_block.my_burn_hash,
                     &prev_block.anchored_block.txs.len()
                 );
+                max_txs = cmp::max(max_txs, prev_block.anchored_block.txs.len());
 
                 if prev_block.anchored_block.txs.len() == 1 && prev_block.attempt == 1 {
                     // Don't let the fact that we've built an empty block during this sortition
@@ -1473,47 +1991,51 @@ impl BlockMinerThread {
                                         as usize)
                                         + 1)
                         {
-                            // the chain tip hasn't changed since we attempted to build a block.  Use what we
-                            // already have.
-                            debug!("Relayer: Stacks tip is unchanged since we last tried to mine a block off of {}/{} at height {} with {} txs, in {} at burn height {}, and no new microblocks ({} <= {} + 1)",
-                                   &prev_block.parent_consensus_hash, &prev_block.anchored_block.header.parent_block, prev_block.anchored_block.header.total_work.work,
-                                   prev_block.anchored_block.txs.len(), prev_block.my_burn_hash, parent_block_burn_height, stream.len(), prev_block.anchored_block.header.parent_microblock_sequence);
-
-                            return None;
+                            if !force {
+                                // the chain tip hasn't changed since we attempted to build a block.  Use what we
+                                // already have.
+                                info!("Relayer: Stacks tip is unchanged since we last tried to mine a block off of {}/{} at height {} with {} txs, in {} at burn height {}, and no new microblocks ({} <= {} + 1)",
+                                       &prev_block.parent_consensus_hash, &prev_block.anchored_block.header.parent_block, prev_block.anchored_block.header.total_work.work,
+                                       prev_block.anchored_block.txs.len(), prev_block.my_burn_hash, parent_block_burn_height, stream.len(), prev_block.anchored_block.header.parent_microblock_sequence);
+
+                                return None;
+                            }
                         } else {
                             // there are new microblocks!
                             // TODO: only consider rebuilding our anchored block if we (a) have
                             // time, and (b) the new microblocks are worth more than the new BTC
                             // fee minus the old BTC fee
-                            debug!("Relayer: Stacks tip is unchanged since we last tried to mine a block off of {}/{} at height {} with {} txs, in {} at burn height {}, but there are new microblocks ({} > {} + 1)",
+                            info!("Relayer: Stacks tip is unchanged since we last tried to mine a block off of {}/{} at height {} with {} txs, in {} at burn height {}, but there are new microblocks ({} > {} + 1)",
                                    &prev_block.parent_consensus_hash, &prev_block.anchored_block.header.parent_block, prev_block.anchored_block.header.total_work.work,
                                    prev_block.anchored_block.txs.len(), prev_block.my_burn_hash, parent_block_burn_height, stream.len(), prev_block.anchored_block.header.parent_microblock_sequence);
 
                             best_attempt = cmp::max(best_attempt, prev_block.attempt);
                         }
                     } else {
-                        // no microblock stream to confirm, and the stacks tip hasn't changed
-                        debug!("Relayer: Stacks tip is unchanged since we last tried to mine a block off of {}/{} at height {} with {} txs, in {} at burn height {}, and no microblocks present",
-                               &prev_block.parent_consensus_hash, &prev_block.anchored_block.header.parent_block, prev_block.anchored_block.header.total_work.work,
-                               prev_block.anchored_block.txs.len(), prev_block.my_burn_hash, parent_block_burn_height);
+                        if !force {
+                            // no microblock stream to confirm, and the stacks tip hasn't changed
+                            info!("Relayer: Stacks tip is unchanged since we last tried to mine a block off of {}/{} at height {} with {} txs, in {} at burn height {}, and no microblocks present",
+                                   &prev_block.parent_consensus_hash, &prev_block.anchored_block.header.parent_block, prev_block.anchored_block.header.total_work.work,
+                                   prev_block.anchored_block.txs.len(), prev_block.my_burn_hash, parent_block_burn_height);
 
-                        return None;
+                            return None;
+                        }
                     }
                 } else {
                     if self.burn_block.burn_header_hash == prev_block.my_burn_hash {
                         // only try and re-mine if there was no sortition since the last chain tip
-                        debug!("Relayer: Stacks tip has changed to {}/{} since we last tried to mine a block in {} at burn height {}; attempt was {} (for Stacks tip {}/{})",
+                        info!("Relayer: Stacks tip has changed to {}/{} since we last tried to mine a block in {} at burn height {}; attempt was {} (for Stacks tip {}/{})",
                                parent_consensus_hash, stacks_parent_header.anchored_header.block_hash(), prev_block.my_burn_hash, parent_block_burn_height, prev_block.attempt, &prev_block.parent_consensus_hash, &prev_block.anchored_block.header.parent_block);
                         best_attempt = cmp::max(best_attempt, prev_block.attempt);
                     } else {
-                        debug!("Relayer: Burn tip has changed to {} ({}) since we last tried to mine a block in {}",
+                        info!("Relayer: Burn tip has changed to {} ({}) since we last tried to mine a block in {}",
                                &self.burn_block.burn_header_hash, self.burn_block.block_height, &prev_block.my_burn_hash);
                     }
                 }
             }
-            best_attempt + 1
+            (best_attempt + 1, max_txs)
         };
-        Some(attempt)
+        Some((attempt, u64::try_from(max_txs).expect("too many txs")))
     }
 
     /// Generate the VRF proof for the block we're going to build.
@@ -1677,6 +2199,214 @@ impl BlockMinerThread {
         microblock_info_opt.map(|(stream, _)| stream)
     }
 
+    /// Get the list of possible burn addresses this miner is using
+    pub fn get_miner_addrs(config: &Config, keychain: &Keychain) -> Vec<String> {
+        let mut op_signer = keychain.generate_op_signer();
+        let mut btc_addrs = vec![
+            // legacy
+            BitcoinAddress::from_bytes_legacy(
+                config.burnchain.get_bitcoin_network().1,
+                LegacyBitcoinAddressType::PublicKeyHash,
+                &Hash160::from_data(&op_signer.get_public_key().to_bytes()).0,
+            )
+            .expect("FATAL: failed to construct legacy bitcoin address"),
+        ];
+        if config.miner.segwit {
+            btc_addrs.push(
+                // segwit p2wpkh
+                BitcoinAddress::from_bytes_segwit_p2wpkh(
+                    config.burnchain.get_bitcoin_network().1,
+                    &Hash160::from_data(&op_signer.get_public_key().to_bytes_compressed()).0,
+                )
+                .expect("FATAL: failed to construct segwit p2wpkh address"),
+            );
+        }
+        btc_addrs
+            .into_iter()
+            .map(|addr| format!("{}", &addr))
+            .collect()
+    }
+
+    /// Obtain the target burn fee cap, when considering how well this miner is performing.
+    pub fn get_mining_spend_amount<F, G>(
+        config: &Config,
+        keychain: &Keychain,
+        burnchain: &Burnchain,
+        sortdb: &SortitionDB,
+        recipients: &[PoxAddress],
+        start_mine_height: u64,
+        at_burn_block: Option<u64>,
+        mut get_prior_winning_prob: F,
+        mut set_prior_winning_prob: G,
+    ) -> u64
+    where
+        F: FnMut(u64) -> f64,
+        G: FnMut(u64, f64),
+    {
+        let config_file_burn_fee_cap = config.get_burnchain_config().burn_fee_cap;
+        let miner_config = config.get_miner_config();
+
+        if miner_config.target_win_probability < 0.00001 {
+            // this field is effectively zero
+            return config_file_burn_fee_cap;
+        }
+        let Some(miner_stats) = config.get_miner_stats() else {
+            return config_file_burn_fee_cap;
+        };
+
+        let Ok(tip) = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn()).map_err(|e| {
+            warn!("Failed to load canonical burn chain tip: {:?}", &e);
+            e
+        }) else {
+            return config_file_burn_fee_cap;
+        };
+        let tip = if let Some(at_burn_block) = at_burn_block.as_ref() {
+            let ih = sortdb.index_handle(&tip.sortition_id);
+            let Ok(Some(ancestor_tip)) = ih.get_block_snapshot_by_height(*at_burn_block) else {
+                warn!(
+                    "Failed to load ancestor tip at burn height {}",
+                    at_burn_block
+                );
+                return config_file_burn_fee_cap;
+            };
+            ancestor_tip
+        } else {
+            tip
+        };
+
+        let Ok(active_miners_and_commits) = MinerStats::get_active_miners(sortdb, at_burn_block)
+            .map_err(|e| {
+                warn!("Failed to get active miners: {:?}", &e);
+                e
+            })
+        else {
+            return config_file_burn_fee_cap;
+        };
+        if active_miners_and_commits.len() == 0 {
+            warn!("No active miners detected; using config file burn_fee_cap");
+            return config_file_burn_fee_cap;
+        }
+
+        let active_miners: Vec<_> = active_miners_and_commits
+            .iter()
+            .map(|(miner, _cmt)| miner.as_str())
+            .collect();
+
+        info!("Active miners: {:?}", &active_miners);
+
+        let Ok(unconfirmed_block_commits) = miner_stats
+            .get_unconfirmed_commits(tip.block_height + 1, &active_miners)
+            .map_err(|e| {
+                warn!("Failed to find unconfirmed block-commits: {}", &e);
+                e
+            })
+        else {
+            return config_file_burn_fee_cap;
+        };
+
+        let unconfirmed_miners_and_amounts: Vec<(String, u64)> = unconfirmed_block_commits
+            .iter()
+            .map(|cmt| (cmt.apparent_sender.to_string(), cmt.burn_fee))
+            .collect();
+
+        info!(
+            "Found unconfirmed block-commits: {:?}",
+            &unconfirmed_miners_and_amounts
+        );
+
+        let (spend_dist, _total_spend) = MinerStats::get_spend_distribution(
+            &active_miners_and_commits,
+            &unconfirmed_block_commits,
+            &recipients,
+        );
+        let win_probs = if miner_config.fast_rampup {
+            // look at spends 6+ blocks in the future
+            let win_probs = MinerStats::get_future_win_distribution(
+                &active_miners_and_commits,
+                &unconfirmed_block_commits,
+                &recipients,
+            );
+            win_probs
+        } else {
+            // look at the current spends
+            let Ok(unconfirmed_burn_dist) = miner_stats
+                .get_unconfirmed_burn_distribution(
+                    burnchain,
+                    sortdb,
+                    &active_miners_and_commits,
+                    unconfirmed_block_commits,
+                    recipients,
+                    at_burn_block,
+                )
+                .map_err(|e| {
+                    warn!("Failed to get unconfirmed burn distribution: {:?}", &e);
+                    e
+                })
+            else {
+                return config_file_burn_fee_cap;
+            };
+
+            let win_probs = MinerStats::burn_dist_to_prob_dist(&unconfirmed_burn_dist);
+            win_probs
+        };
+
+        info!("Unconfirmed spend distribution: {:?}", &spend_dist);
+        info!(
+            "Unconfirmed win probabilities (fast_rampup={}): {:?}",
+            miner_config.fast_rampup, &win_probs
+        );
+
+        let miner_addrs = Self::get_miner_addrs(config, keychain);
+        let win_prob = miner_addrs
+            .iter()
+            .find_map(|x| win_probs.get(x))
+            .copied()
+            .unwrap_or(0.0);
+
+        info!(
+            "This miner's win probability at {} is {}",
+            tip.block_height, &win_prob
+        );
+        set_prior_winning_prob(tip.block_height, win_prob);
+
+        if win_prob < config.miner.target_win_probability {
+            // no mining strategy is viable, so just quit.
+            // Unless we're spinning up, that is.
+            if start_mine_height + 6 < tip.block_height
+                && config.miner.underperform_stop_threshold.is_some()
+            {
+                let underperform_stop_threshold =
+                    config.miner.underperform_stop_threshold.unwrap_or(0);
+                info!(
+                    "Miner is spun up, but is not meeting target win probability as of {}",
+                    tip.block_height
+                );
+                // we've spun up and we're underperforming. How long do we tolerate this?
+                let mut underperformed_count = 0;
+                for depth in 0..underperform_stop_threshold {
+                    let prior_burn_height = tip.block_height.saturating_sub(depth);
+                    let prior_win_prob = get_prior_winning_prob(prior_burn_height);
+                    if prior_win_prob < config.miner.target_win_probability {
+                        info!(
+                            "Miner underperformed in block {} ({}/{})",
+                            prior_burn_height, underperformed_count, underperform_stop_threshold
+                        );
+                        underperformed_count += 1;
+                    }
+                }
+                if underperformed_count == underperform_stop_threshold {
+                    warn!(
+                        "Miner underperformed since burn height {}; spinning down",
+                        start_mine_height + 6 + underperform_stop_threshold
+                    );
+                    return 0;
+                }
+            }
+        }
+
+        config_file_burn_fee_cap
+    }
+
     /// Produce the block-commit for this anchored block, if we can.
     /// Returns the op on success
     /// Returns None if we fail somehow.
@@ -1706,15 +2436,6 @@ impl BlockMinerThread {
             }
         };
 
-        // let burn_fee_cap = self.config.burnchain.burn_fee_cap;
-        let burn_fee_cap = get_mining_spend_amount(self.globals.get_miner_status());
-        let sunset_burn = self.burnchain.expected_sunset_burn(
-            self.burn_block.block_height + 1,
-            burn_fee_cap,
-            target_epoch_id,
-        );
-        let rest_commit = burn_fee_cap - sunset_burn;
-
         let commit_outs = if !self
             .burnchain
             .pox_constants
@@ -1728,6 +2449,32 @@ impl BlockMinerThread {
             vec![PoxAddress::standard_burn_address(self.config.is_mainnet())]
         };
 
+        let burn_fee_cap = Self::get_mining_spend_amount(
+            &self.config,
+            &self.keychain,
+            &self.burnchain,
+            burn_db,
+            &commit_outs,
+            self.globals.get_start_mining_height(),
+            None,
+            |block_height| {
+                self.globals
+                    .get_estimated_win_prob(block_height)
+                    .unwrap_or(0.0)
+            },
+            |block_height, win_prob| self.globals.add_estimated_win_prob(block_height, win_prob),
+        );
+        if burn_fee_cap == 0 {
+            warn!("Calculated burn_fee_cap is 0; will not mine");
+            return None;
+        }
+        let sunset_burn = self.burnchain.expected_sunset_burn(
+            self.burn_block.block_height + 1,
+            burn_fee_cap,
+            target_epoch_id,
+        );
+        let rest_commit = burn_fee_cap - sunset_burn;
+
         // let's commit, but target the current burnchain tip with our modulus
         let op = self.inner_generate_block_commit_op(
             block_hash,
@@ -1830,6 +2577,19 @@ impl BlockMinerThread {
             self.ongoing_commit.clone(),
         );
 
+        let miner_config = self.config.get_miner_config();
+        let last_miner_config_opt = self.globals.get_last_miner_config();
+        let force_remine = if let Some(last_miner_config) = last_miner_config_opt {
+            last_miner_config != miner_config
+        } else {
+            false
+        };
+        if force_remine {
+            info!("Miner config changed; forcing a re-mine attempt");
+        }
+
+        self.globals.set_last_miner_config(miner_config);
+
         // NOTE: read-write access is needed in order to be able to query the recipient set.
         // This is an artifact of the way the MARF is built (see #1449)
         let mut burn_db =
@@ -1855,8 +2615,14 @@ impl BlockMinerThread {
                 .ok()?
                 .expect("FATAL: no epoch defined")
                 .epoch_id;
-        let mut parent_block_info = self.load_block_parent_info(&mut burn_db, &mut chain_state)?;
-        let attempt = self.get_mine_attempt(&chain_state, &parent_block_info)?;
+
+        let (Some(mut parent_block_info), _) =
+            self.load_block_parent_info(&mut burn_db, &mut chain_state)
+        else {
+            return None;
+        };
+        let (attempt, max_txs) =
+            self.get_mine_attempt(&chain_state, &parent_block_info, force_remine)?;
         let vrf_proof = self.make_vrf_proof()?;
 
         // Generates a new secret key for signing the trail of microblocks
@@ -1969,6 +2735,24 @@ impl BlockMinerThread {
             }
         };
 
+        let miner_config = self.config.get_miner_config();
+
+        if attempt > 1
+            && miner_config.min_tx_count > 0
+            && u64::try_from(anchored_block.txs.len()).expect("too many txs")
+                < miner_config.min_tx_count
+        {
+            info!("Relayer: Succeeded assembling subsequent block with {} txs, but expected at least {}", anchored_block.txs.len(), miner_config.min_tx_count);
+            return None;
+        }
+
+        if miner_config.only_increase_tx_count
+            && max_txs > u64::try_from(anchored_block.txs.len()).expect("too many txs")
+        {
+            info!("Relayer: Succeeded assembling subsequent block with {} txs, but had previously produced a block with {} txs", anchored_block.txs.len(), max_txs);
+            return None;
+        }
+
         info!(
             "Relayer: Succeeded assembling {} block #{}: {}, with {} txs, attempt {}",
             if parent_block_info.parent_block_total_burn == 0 {
@@ -1992,6 +2776,11 @@ impl BlockMinerThread {
             &vrf_proof,
             target_epoch_id,
         )?;
+        let burn_fee = if let BlockstackOperationType::LeaderBlockCommit(ref op) = &op {
+            op.burn_fee
+        } else {
+            0
+        };
 
         // last chance -- confirm that the stacks tip is unchanged (since it could have taken long
         // enough to build this block that another block could have arrived), and confirm that all
@@ -1999,10 +2788,13 @@ impl BlockMinerThread {
         let cur_burn_chain_tip = SortitionDB::get_canonical_burn_chain_tip(burn_db.conn())
             .expect("FATAL: failed to query sortition DB for canonical burn chain tip");
 
-        if let Some(stacks_tip) = chain_state
-            .get_stacks_chain_tip(&burn_db)
-            .expect("FATAL: could not query chain tip")
-        {
+        if let Some(stacks_tip) = Self::pick_best_tip(
+            &self.globals,
+            &self.config,
+            &mut burn_db,
+            &mut chain_state,
+            None,
+        ) {
             let is_miner_blocked = self
                 .globals
                 .get_miner_status()
@@ -2014,7 +2806,7 @@ impl BlockMinerThread {
                 &self.burnchain,
                 &burn_db,
                 &chain_state,
-                self.config.miner.unprocessed_block_deadline_secs,
+                miner_config.unprocessed_block_deadline_secs,
             );
             if stacks_tip.anchored_block_hash != anchored_block.header.parent_block
                 || parent_block_info.parent_consensus_hash != stacks_tip.consensus_hash
@@ -2022,7 +2814,7 @@ impl BlockMinerThread {
                 || is_miner_blocked
                 || has_unprocessed
             {
-                debug!(
+                info!(
                     "Relayer: Cancel block-commit; chain tip(s) have changed or cancelled";
                     "block_hash" => %anchored_block.block_hash(),
                     "tx_count" => anchored_block.txs.len(),
@@ -2049,8 +2841,9 @@ impl BlockMinerThread {
         }
 
         let mut op_signer = self.keychain.generate_op_signer();
-        debug!(
+        info!(
             "Relayer: Submit block-commit";
+            "burn_fee" => burn_fee,
             "block_hash" => %anchored_block.block_hash(),
             "tx_count" => anchored_block.txs.len(),
             "target_height" => anchored_block.header.total_work.work,
@@ -2369,8 +3162,6 @@ impl RelayerThread {
             );
             #[cfg(any(test, feature = "testing"))]
             {
-                use std::fs;
-                use std::io::Write;
                 use std::path::Path;
                 if let Ok(path) = std::env::var("STACKS_BAD_BLOCKS_DIR") {
                     // record this block somewhere
@@ -2976,11 +3767,13 @@ impl RelayerThread {
             return None;
         }
 
+        let miner_config = self.config.get_miner_config();
+
         let has_unprocessed = BlockMinerThread::unprocessed_blocks_prevent_mining(
             &self.burnchain,
             self.sortdb_ref(),
             self.chainstate_ref(),
-            self.config.miner.unprocessed_block_deadline_secs,
+            miner_config.unprocessed_block_deadline_secs,
         );
         if has_unprocessed {
             debug!(
@@ -3371,6 +4164,36 @@ impl RelayerThread {
         self.miner_thread.is_none()
     }
 
+    /// Try loading up a saved VRF key
+    pub(crate) fn load_saved_vrf_key(path: &str) -> Option<RegisteredKey> {
+        let mut f = match fs::File::open(path) {
+            Ok(f) => f,
+            Err(e) => {
+                warn!("Could not open {}: {:?}", &path, &e);
+                return None;
+            }
+        };
+        let mut registered_key_bytes = vec![];
+        if let Err(e) = f.read_to_end(&mut registered_key_bytes) {
+            warn!(
+                "Failed to read registered key bytes from {}: {:?}",
+                path, &e
+            );
+            return None;
+        }
+
+        let Ok(registered_key) = serde_json::from_slice(&registered_key_bytes) else {
+            warn!(
+                "Did not load registered key from {}: could not decode JSON",
+                &path
+            );
+            return None;
+        };
+
+        info!("Loaded registered key from {}", &path);
+        Some(registered_key)
+    }
+
     /// Top-level dispatcher
     pub fn handle_directive(&mut self, directive: RelayerDirective) -> bool {
         debug!("Relayer: received next directive");
@@ -3382,10 +4205,18 @@ impl RelayerThread {
                 true
             }
             RelayerDirective::RegisterKey(last_burn_block) => {
-                debug!("Relayer: directive Register VRF key");
-                self.rotate_vrf_and_register(&last_burn_block);
+                let mut saved_key_opt = None;
+                if let Some(path) = self.config.miner.activated_vrf_key_path.as_ref() {
+                    saved_key_opt = Self::load_saved_vrf_key(&path);
+                }
+                if let Some(saved_key) = saved_key_opt {
+                    self.globals.resume_leader_key(saved_key);
+                } else {
+                    debug!("Relayer: directive Register VRF key");
+                    self.rotate_vrf_and_register(&last_burn_block);
+                    debug!("Relayer: directive Registered VRF key");
+                }
                 self.globals.counters.bump_blocks_processed();
-                debug!("Relayer: directive Registered VRF key");
                 true
             }
             RelayerDirective::ProcessTenure(consensus_hash, burn_hash, block_header_hash) => {
@@ -4411,6 +5242,7 @@ impl StacksNode {
     /// Called from the main thread.
     pub fn process_burnchain_state(
         &mut self,
+        config: &Config,
         sortdb: &SortitionDB,
         sort_id: &SortitionId,
         ibd: bool,
@@ -4453,18 +5285,46 @@ impl StacksNode {
             SortitionDB::get_leader_keys_by_block(&ic, &block_snapshot.sortition_id)
                 .expect("Unexpected SortitionDB error fetching key registers");
 
-        let num_key_registers = key_registers.len();
-
-        self.globals
-            .try_activate_leader_key_registration(block_height, key_registers);
+        self.globals.set_last_sortition(block_snapshot);
+        let ret = last_sortitioned_block.map(|x| x.0);
 
+        let num_key_registers = key_registers.len();
         debug!(
             "Processed burnchain state at height {}: {} leader keys, {} block-commits (ibd = {})",
             block_height, num_key_registers, num_block_commits, ibd
         );
 
-        self.globals.set_last_sortition(block_snapshot);
-        last_sortitioned_block.map(|x| x.0)
+        // save the registered VRF key
+        let activated_key_opt = self
+            .globals
+            .try_activate_leader_key_registration(block_height, key_registers);
+
+        let Some(activated_key) = activated_key_opt else {
+            return ret;
+        };
+        let Some(path) = config.miner.activated_vrf_key_path.as_ref() else {
+            return ret;
+        };
+        info!("Activated VRF key; saving to {}", &path);
+        let Ok(key_json) = serde_json::to_string(&activated_key) else {
+            warn!("Failed to serialize VRF key");
+            return ret;
+        };
+        let mut f = match fs::File::create(&path) {
+            Ok(f) => f,
+            Err(e) => {
+                warn!("Failed to create {}: {:?}", &path, &e);
+                return ret;
+            }
+        };
+
+        if let Err(e) = f.write_all(key_json.as_str().as_bytes()) {
+            warn!("Failed to write activated VRF key to {}: {:?}", &path, &e);
+            return ret;
+        }
+
+        info!("Saved activated VRF key to {}", &path);
+        return ret;
     }
 
     /// Join all inner threads
diff --git a/testnet/stacks-node/src/run_loop/mod.rs b/testnet/stacks-node/src/run_loop/mod.rs
index bc76a128ca..8b264365b0 100644
--- a/testnet/stacks-node/src/run_loop/mod.rs
+++ b/testnet/stacks-node/src/run_loop/mod.rs
@@ -146,7 +146,7 @@ impl RunLoopCallbacks {
     }
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct RegisteredKey {
     /// burn block height we intended this VRF key register to land in
     pub target_block_height: u64,
diff --git a/testnet/stacks-node/src/run_loop/neon.rs b/testnet/stacks-node/src/run_loop/neon.rs
index 3688acb153..45055097d1 100644
--- a/testnet/stacks-node/src/run_loop/neon.rs
+++ b/testnet/stacks-node/src/run_loop/neon.rs
@@ -623,11 +623,12 @@ impl RunLoop {
         sortdb: &SortitionDB,
         last_stacks_pox_reorg_recover_time: &mut u128,
     ) {
+        let miner_config = config.get_miner_config();
         let delay = cmp::max(
             config.node.chain_liveness_poll_time_secs,
             cmp::max(
-                config.miner.first_attempt_time_ms,
-                config.miner.subsequent_attempt_time_ms,
+                miner_config.first_attempt_time_ms,
+                miner_config.subsequent_attempt_time_ms,
             ) / 1000,
         );
 
@@ -743,11 +744,12 @@ impl RunLoop {
         last_burn_pox_reorg_recover_time: &mut u128,
         last_announce_time: &mut u128,
     ) {
+        let miner_config = config.get_miner_config();
         let delay = cmp::max(
             config.node.chain_liveness_poll_time_secs,
             cmp::max(
-                config.miner.first_attempt_time_ms,
-                config.miner.subsequent_attempt_time_ms,
+                miner_config.first_attempt_time_ms,
+                miner_config.subsequent_attempt_time_ms,
             ) / 1000,
         );
 
@@ -972,6 +974,7 @@ impl RunLoop {
             self.counters.clone(),
             self.pox_watchdog_comms.clone(),
             self.should_keep_running.clone(),
+            mine_start,
         );
         self.set_globals(globals.clone());
 
@@ -1170,7 +1173,12 @@ impl RunLoop {
                         let sortition_id = &block.sortition_id;
 
                         // Have the node process the new block, that can include, or not, a sortition.
-                        node.process_burnchain_state(burnchain.sortdb_mut(), sortition_id, ibd);
+                        node.process_burnchain_state(
+                            self.config(),
+                            burnchain.sortdb_mut(),
+                            sortition_id,
+                            ibd,
+                        );
 
                         // Now, tell the relayer to check if it won a sortition during this block,
                         // and, if so, to process and advertize the block.  This is basically a
@@ -1240,6 +1248,7 @@ impl RunLoop {
                     // once we've synced to the chain tip once, don't apply this check again.
                     //  this prevents a possible corner case in the event of a PoX fork.
                     mine_start = 0;
+                    globals.set_start_mining_height_if_zero(sortition_db_height);
 
                     // at tip, and not downloading. proceed to mine.
                     if last_tenure_sortition_height != sortition_db_height {
diff --git a/testnet/stacks-node/src/tests/bitcoin_regtest.rs b/testnet/stacks-node/src/tests/bitcoin_regtest.rs
index fdb09dd22c..75c6ec3666 100644
--- a/testnet/stacks-node/src/tests/bitcoin_regtest.rs
+++ b/testnet/stacks-node/src/tests/bitcoin_regtest.rs
@@ -141,7 +141,6 @@ fn bitcoind_integration(segwit_flag: bool) {
     conf.burnchain.password = Some("secret".to_string());
     conf.burnchain.local_mining_public_key = Some("04ee0b1602eb18fef7986887a7e8769a30c9df981d33c8380d255edef003abdcd243a0eb74afdf6740e6c423e62aec631519a24cf5b1d62bf8a3e06ddc695dcb77".to_string());
 
-    conf.miner.min_tx_fee = 0;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
     conf.miner.segwit = segwit_flag;
diff --git a/testnet/stacks-node/src/tests/epoch_205.rs b/testnet/stacks-node/src/tests/epoch_205.rs
index 568912feec..844a314bc6 100644
--- a/testnet/stacks-node/src/tests/epoch_205.rs
+++ b/testnet/stacks-node/src/tests/epoch_205.rs
@@ -982,7 +982,6 @@ fn bigger_microblock_streams_in_2_05() {
     conf.node.max_microblocks = 65536;
     conf.burnchain.max_rbf = 1000000;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
diff --git a/testnet/stacks-node/src/tests/epoch_21.rs b/testnet/stacks-node/src/tests/epoch_21.rs
index 34ac467bc0..8be3edad0f 100644
--- a/testnet/stacks-node/src/tests/epoch_21.rs
+++ b/testnet/stacks-node/src/tests/epoch_21.rs
@@ -4956,7 +4956,6 @@ fn test_v1_unlock_height_with_current_stackers() {
     conf.node.wait_time_for_blocks = 1_000;
     conf.miner.wait_for_block_download = false;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -5218,7 +5217,6 @@ fn test_v1_unlock_height_with_delay_and_current_stackers() {
     conf.node.wait_time_for_blocks = 1_000;
     conf.miner.wait_for_block_download = false;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
diff --git a/testnet/stacks-node/src/tests/epoch_22.rs b/testnet/stacks-node/src/tests/epoch_22.rs
index eab6ea5685..99863c95e0 100644
--- a/testnet/stacks-node/src/tests/epoch_22.rs
+++ b/testnet/stacks-node/src/tests/epoch_22.rs
@@ -130,7 +130,6 @@ fn disable_pox() {
     conf.node.wait_time_for_blocks = 1_000;
     conf.miner.wait_for_block_download = false;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -660,7 +659,6 @@ fn pox_2_unlock_all() {
     conf.node.wait_time_for_blocks = 1_000;
     conf.miner.wait_for_block_download = false;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
diff --git a/testnet/stacks-node/src/tests/epoch_23.rs b/testnet/stacks-node/src/tests/epoch_23.rs
index 9e13e597dd..40a4dddb47 100644
--- a/testnet/stacks-node/src/tests/epoch_23.rs
+++ b/testnet/stacks-node/src/tests/epoch_23.rs
@@ -96,7 +96,6 @@ fn trait_invocation_behavior() {
     conf.node.wait_time_for_blocks = 1_000;
     conf.miner.wait_for_block_download = false;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
diff --git a/testnet/stacks-node/src/tests/epoch_24.rs b/testnet/stacks-node/src/tests/epoch_24.rs
index 9b002f6253..4376da2d41 100644
--- a/testnet/stacks-node/src/tests/epoch_24.rs
+++ b/testnet/stacks-node/src/tests/epoch_24.rs
@@ -148,7 +148,6 @@ fn fix_to_pox_contract() {
     conf.node.wait_time_for_blocks = 1_000;
     conf.miner.wait_for_block_download = false;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -784,7 +783,6 @@ fn verify_auto_unlock_behavior() {
     conf.node.wait_time_for_blocks = 1_000;
     conf.miner.wait_for_block_download = false;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
diff --git a/testnet/stacks-node/src/tests/integrations.rs b/testnet/stacks-node/src/tests/integrations.rs
index c2057d6430..ffc7873dfc 100644
--- a/testnet/stacks-node/src/tests/integrations.rs
+++ b/testnet/stacks-node/src/tests/integrations.rs
@@ -181,7 +181,6 @@ fn integration_test_get_info() {
     });
 
     conf.burnchain.commit_anchor_block_within = 5000;
-    conf.miner.min_tx_fee = 0;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
diff --git a/testnet/stacks-node/src/tests/mod.rs b/testnet/stacks-node/src/tests/mod.rs
index 03f61b5e4c..0630e71387 100644
--- a/testnet/stacks-node/src/tests/mod.rs
+++ b/testnet/stacks-node/src/tests/mod.rs
@@ -1,3 +1,19 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020-2024 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+use std::collections::HashMap;
 use std::convert::TryInto;
 use std::sync::atomic::AtomicU64;
 use std::sync::Arc;
@@ -23,11 +39,12 @@ use stacks::core::{StacksEpoch, StacksEpochExtension, StacksEpochId, CHAIN_ID_TE
 use stacks::util_lib::strings::StacksString;
 use stacks_common::address::AddressHashMode;
 use stacks_common::codec::StacksMessageCodec;
-use stacks_common::types::chainstate::StacksAddress;
+use stacks_common::types::chainstate::{BlockHeaderHash, StacksAddress};
 use stacks_common::util::get_epoch_time_secs;
 use stacks_common::util::hash::{hex_bytes, to_hex};
 
 use super::burnchains::bitcoin_regtest_controller::ParsedUTXO;
+use super::neon_node::{BlockMinerThread, TipCandidate};
 use super::Config;
 use crate::helium::RunLoop;
 use crate::tests::neon_integrations::{get_chain_info, next_block_and_wait};
@@ -518,8 +535,6 @@ fn should_succeed_mining_valid_txs() {
         100000,
     );
 
-    conf.miner.min_tx_fee = 0;
-
     let num_rounds = 6;
     let mut run_loop = RunLoop::new(conf.clone());
 
@@ -993,3 +1008,332 @@ fn test_btc_to_sat_errors() {
     assert!(ParsedUTXO::serialized_btc_to_sat("7.4e-7").is_none());
     assert!(ParsedUTXO::serialized_btc_to_sat("5.96e-6").is_none());
 }
+
+#[test]
+fn test_sort_and_populate_candidates() {
+    let empty: Vec<TipCandidate> = vec![];
+    assert_eq!(
+        empty,
+        BlockMinerThread::sort_and_populate_candidates(vec![])
+    );
+    let candidates = vec![
+        TipCandidate {
+            stacks_height: 1,
+            consensus_hash: ConsensusHash([0x01; 20]),
+            anchored_block_hash: BlockHeaderHash([0x01; 32]),
+            parent_consensus_hash: ConsensusHash([0x00; 20]),
+            parent_anchored_block_hash: BlockHeaderHash([0x00; 32]),
+            burn_height: 100,
+            num_earlier_siblings: 0,
+        },
+        TipCandidate {
+            stacks_height: 2,
+            consensus_hash: ConsensusHash([0x02; 20]),
+            anchored_block_hash: BlockHeaderHash([0x02; 32]),
+            parent_consensus_hash: ConsensusHash([0x01; 20]),
+            parent_anchored_block_hash: BlockHeaderHash([0x01; 32]),
+            burn_height: 102,
+            num_earlier_siblings: 0,
+        },
+        TipCandidate {
+            stacks_height: 2,
+            consensus_hash: ConsensusHash([0x12; 20]),
+            anchored_block_hash: BlockHeaderHash([0x12; 32]),
+            parent_consensus_hash: ConsensusHash([0x01; 20]),
+            parent_anchored_block_hash: BlockHeaderHash([0x01; 32]),
+            burn_height: 101,
+            num_earlier_siblings: 0,
+        },
+        TipCandidate {
+            stacks_height: 2,
+            consensus_hash: ConsensusHash([0x22; 20]),
+            anchored_block_hash: BlockHeaderHash([0x22; 32]),
+            parent_consensus_hash: ConsensusHash([0x01; 20]),
+            parent_anchored_block_hash: BlockHeaderHash([0x01; 32]),
+            burn_height: 104,
+            num_earlier_siblings: 0,
+        },
+        TipCandidate {
+            stacks_height: 4,
+            consensus_hash: ConsensusHash([0x04; 20]),
+            anchored_block_hash: BlockHeaderHash([0x04; 32]),
+            parent_consensus_hash: ConsensusHash([0x03; 20]),
+            parent_anchored_block_hash: BlockHeaderHash([0x03; 32]),
+            burn_height: 105,
+            num_earlier_siblings: 0,
+        },
+        TipCandidate {
+            stacks_height: 3,
+            consensus_hash: ConsensusHash([0x03; 20]),
+            anchored_block_hash: BlockHeaderHash([0x03; 32]),
+            parent_consensus_hash: ConsensusHash([0x02; 20]),
+            parent_anchored_block_hash: BlockHeaderHash([0x02; 32]),
+            burn_height: 105,
+            num_earlier_siblings: 0,
+        },
+    ];
+    let sorted_candidates = BlockMinerThread::sort_and_populate_candidates(candidates);
+    assert_eq!(
+        sorted_candidates,
+        vec![
+            TipCandidate {
+                stacks_height: 1,
+                consensus_hash: ConsensusHash([0x01; 20]),
+                anchored_block_hash: BlockHeaderHash([0x01; 32]),
+                parent_consensus_hash: ConsensusHash([0x00; 20]),
+                parent_anchored_block_hash: BlockHeaderHash([0x00; 32]),
+                burn_height: 100,
+                num_earlier_siblings: 0
+            },
+            TipCandidate {
+                stacks_height: 2,
+                consensus_hash: ConsensusHash([0x12; 20]),
+                anchored_block_hash: BlockHeaderHash([0x12; 32]),
+                parent_consensus_hash: ConsensusHash([0x01; 20]),
+                parent_anchored_block_hash: BlockHeaderHash([0x01; 32]),
+                burn_height: 101,
+                num_earlier_siblings: 0
+            },
+            TipCandidate {
+                stacks_height: 2,
+                consensus_hash: ConsensusHash([0x02; 20]),
+                anchored_block_hash: BlockHeaderHash([0x02; 32]),
+                parent_consensus_hash: ConsensusHash([0x01; 20]),
+                parent_anchored_block_hash: BlockHeaderHash([0x01; 32]),
+                burn_height: 102,
+                num_earlier_siblings: 1
+            },
+            TipCandidate {
+                stacks_height: 2,
+                consensus_hash: ConsensusHash([0x22; 20]),
+                anchored_block_hash: BlockHeaderHash([0x22; 32]),
+                parent_consensus_hash: ConsensusHash([0x01; 20]),
+                parent_anchored_block_hash: BlockHeaderHash([0x01; 32]),
+                burn_height: 104,
+                num_earlier_siblings: 2
+            },
+            TipCandidate {
+                stacks_height: 3,
+                consensus_hash: ConsensusHash([0x03; 20]),
+                anchored_block_hash: BlockHeaderHash([0x03; 32]),
+                parent_consensus_hash: ConsensusHash([0x02; 20]),
+                parent_anchored_block_hash: BlockHeaderHash([0x02; 32]),
+                burn_height: 105,
+                num_earlier_siblings: 0
+            },
+            TipCandidate {
+                stacks_height: 4,
+                consensus_hash: ConsensusHash([0x04; 20]),
+                anchored_block_hash: BlockHeaderHash([0x04; 32]),
+                parent_consensus_hash: ConsensusHash([0x03; 20]),
+                parent_anchored_block_hash: BlockHeaderHash([0x03; 32]),
+                burn_height: 105,
+                num_earlier_siblings: 0
+            }
+        ]
+    );
+}
+
+#[test]
+fn test_inner_pick_best_tip() {
+    // chain structure as folows:
+    //
+    // Bitcoin chain
+    // 100  101  102  103  104  105  106
+    //  |    |    |         |    |    |
+    // Stacks chain         |    |    |
+    //  1 <- 2    |         |.-- 3 <- 4
+    //    \       |         /
+    //     *----- 2 <------*|
+    //      \               |
+    //       *--------------2
+    //
+    // If there are no previous best-tips, then:
+    // At Bitcoin height 105, the best tip is (4,105)
+    // At Bitcoin height 104, the best tip is (3,104)
+    // At Bitcoin height 103, the best tip is (2,101)
+    // At Bitcoin height 102, the best tip is (2,101)
+    // At Bitcoin height 101, the best tip is (2,101)
+    // At Bitcoin height 100, the best tip is (1,100)
+    //
+    let candidates = vec![
+        TipCandidate {
+            stacks_height: 1,
+            consensus_hash: ConsensusHash([0x01; 20]),
+            anchored_block_hash: BlockHeaderHash([0x01; 32]),
+            parent_consensus_hash: ConsensusHash([0x00; 20]),
+            parent_anchored_block_hash: BlockHeaderHash([0x00; 32]),
+            burn_height: 100,
+            num_earlier_siblings: 0,
+        },
+        TipCandidate {
+            stacks_height: 2,
+            consensus_hash: ConsensusHash([0x02; 20]),
+            anchored_block_hash: BlockHeaderHash([0x02; 32]),
+            parent_consensus_hash: ConsensusHash([0x01; 20]),
+            parent_anchored_block_hash: BlockHeaderHash([0x01; 32]),
+            burn_height: 102,
+            num_earlier_siblings: 0,
+        },
+        TipCandidate {
+            stacks_height: 2,
+            consensus_hash: ConsensusHash([0x12; 20]),
+            anchored_block_hash: BlockHeaderHash([0x12; 32]),
+            parent_consensus_hash: ConsensusHash([0x01; 20]),
+            parent_anchored_block_hash: BlockHeaderHash([0x01; 32]),
+            burn_height: 101,
+            num_earlier_siblings: 0,
+        },
+        TipCandidate {
+            stacks_height: 2,
+            consensus_hash: ConsensusHash([0x22; 20]),
+            anchored_block_hash: BlockHeaderHash([0x22; 32]),
+            parent_consensus_hash: ConsensusHash([0x01; 20]),
+            parent_anchored_block_hash: BlockHeaderHash([0x01; 32]),
+            burn_height: 104,
+            num_earlier_siblings: 0,
+        },
+        TipCandidate {
+            stacks_height: 4,
+            consensus_hash: ConsensusHash([0x04; 20]),
+            anchored_block_hash: BlockHeaderHash([0x04; 32]),
+            parent_consensus_hash: ConsensusHash([0x03; 20]),
+            parent_anchored_block_hash: BlockHeaderHash([0x03; 32]),
+            burn_height: 106,
+            num_earlier_siblings: 0,
+        },
+        TipCandidate {
+            stacks_height: 3,
+            consensus_hash: ConsensusHash([0x03; 20]),
+            anchored_block_hash: BlockHeaderHash([0x03; 32]),
+            parent_consensus_hash: ConsensusHash([0x02; 20]),
+            parent_anchored_block_hash: BlockHeaderHash([0x02; 32]),
+            burn_height: 105,
+            num_earlier_siblings: 0,
+        },
+    ];
+
+    let sorted_candidates = BlockMinerThread::sort_and_populate_candidates(candidates.clone());
+    assert_eq!(
+        None,
+        BlockMinerThread::inner_pick_best_tip(vec![], HashMap::new())
+    );
+    assert_eq!(
+        Some(sorted_candidates[5].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates.clone(), HashMap::new())
+    );
+    assert_eq!(
+        Some(sorted_candidates[0].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..1].to_vec(), HashMap::new())
+    );
+    assert_eq!(
+        Some(sorted_candidates[1].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..2].to_vec(), HashMap::new())
+    );
+    assert_eq!(
+        Some(sorted_candidates[1].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..3].to_vec(), HashMap::new())
+    );
+    assert_eq!(
+        Some(sorted_candidates[1].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..4].to_vec(), HashMap::new())
+    );
+    assert_eq!(
+        Some(sorted_candidates[4].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..5].to_vec(), HashMap::new())
+    );
+
+    // suppose now that we previously picked (2,104) as the best-tip.
+    // No other tips at Stacks height 2 will be accepted, nor will those at heights 3 and 4 (since
+    // they descend from the wrong height-2 block).
+    let mut best_tips = HashMap::new();
+    best_tips.insert(2, sorted_candidates[3].clone());
+
+    assert_eq!(
+        Some(sorted_candidates[3].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates.clone(), best_tips.clone())
+    );
+    assert_eq!(
+        Some(sorted_candidates[0].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..1].to_vec(), best_tips.clone())
+    );
+    assert_eq!(
+        None,
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..2].to_vec(), best_tips.clone())
+    );
+    assert_eq!(
+        None,
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..3].to_vec(), best_tips.clone())
+    );
+    assert_eq!(
+        Some(sorted_candidates[3].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..4].to_vec(), best_tips.clone())
+    );
+    assert_eq!(
+        Some(sorted_candidates[3].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..5].to_vec(), best_tips.clone())
+    );
+
+    // now suppose that we previously picked (2,102) as the best-tip.
+    // Conflicting blocks are (2,101) and (2,104)
+    let mut best_tips = HashMap::new();
+    best_tips.insert(2, sorted_candidates[2].clone());
+
+    assert_eq!(
+        Some(sorted_candidates[5].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates.clone(), best_tips.clone())
+    );
+    assert_eq!(
+        Some(sorted_candidates[0].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..1].to_vec(), best_tips.clone())
+    );
+    assert_eq!(
+        None,
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..2].to_vec(), best_tips.clone())
+    );
+    assert_eq!(
+        Some(sorted_candidates[2].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..3].to_vec(), best_tips.clone())
+    );
+    assert_eq!(
+        Some(sorted_candidates[2].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..4].to_vec(), best_tips.clone())
+    );
+    assert_eq!(
+        Some(sorted_candidates[4].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..5].to_vec(), best_tips.clone())
+    );
+
+    // now suppose that we previously picked both (2,101) and (3,105) as the best-tips.
+    // these best-tips are in conflict, but that shouldn't prohibit us from choosing (4,106) as the
+    // best tip even though it doesn't confirm (2,101).  However, it would mean that (2,102) and
+    // (2,104) are in conflict.
+    let mut best_tips = HashMap::new();
+    best_tips.insert(2, sorted_candidates[1].clone());
+    best_tips.insert(3, sorted_candidates[4].clone());
+
+    assert_eq!(
+        Some(sorted_candidates[5].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates.clone(), best_tips.clone())
+    );
+    assert_eq!(
+        Some(sorted_candidates[0].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..1].to_vec(), best_tips.clone())
+    );
+    assert_eq!(
+        Some(sorted_candidates[1].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..2].to_vec(), best_tips.clone())
+    );
+    assert_eq!(
+        Some(sorted_candidates[1].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..3].to_vec(), best_tips.clone())
+    );
+    assert_eq!(
+        Some(sorted_candidates[1].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..4].to_vec(), best_tips.clone())
+    );
+    assert_eq!(
+        Some(sorted_candidates[1].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..5].to_vec(), best_tips.clone())
+    );
+}
diff --git a/testnet/stacks-node/src/tests/neon_integrations.rs b/testnet/stacks-node/src/tests/neon_integrations.rs
index 02461ce840..52a03b60ed 100644
--- a/testnet/stacks-node/src/tests/neon_integrations.rs
+++ b/testnet/stacks-node/src/tests/neon_integrations.rs
@@ -34,6 +34,7 @@ use stacks::chainstate::stacks::{
 };
 use stacks::clarity_cli::vm_execute as execute;
 use stacks::core;
+use stacks::core::mempool::MemPoolWalkTxTypes;
 use stacks::core::{
     StacksEpoch, StacksEpochId, BLOCK_LIMIT_MAINNET_20, BLOCK_LIMIT_MAINNET_205,
     BLOCK_LIMIT_MAINNET_21, CHAIN_ID_TESTNET, HELIUM_BLOCK_LIMIT_20, PEER_VERSION_EPOCH_1_0,
@@ -69,6 +70,7 @@ use super::{
 };
 use crate::burnchains::bitcoin_regtest_controller::{BitcoinRPCRequest, UTXO};
 use crate::config::{EventKeyType, EventObserverConfig, FeeEstimatorName, InitialBalance};
+use crate::neon_node::RelayerThread;
 use crate::operations::BurnchainOpSigner;
 use crate::stacks_common::types::PrivateKey;
 use crate::syncctl::PoxSyncWatchdogComms;
@@ -146,7 +148,6 @@ fn inner_neon_integration_test_conf(seed: Option<Vec<u8>>) -> (Config, StacksAdd
     conf.burnchain.poll_time_secs = 1;
     conf.node.pox_sync_sample_secs = 0;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -2375,7 +2376,6 @@ fn microblock_fork_poison_integration_test() {
     conf.miner.subsequent_attempt_time_ms = 5_000;
     conf.node.wait_time_for_blocks = 1_000;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -3123,9 +3123,6 @@ fn filter_low_fee_tx_integration_test() {
         });
     }
 
-    // exclude the first 5 transactions from miner consideration
-    conf.miner.min_tx_fee = 1500;
-
     let mut btcd_controller = BitcoinCoreController::new(conf.clone());
     btcd_controller
         .start_bitcoind()
@@ -3213,9 +3210,6 @@ fn filter_long_runtime_tx_integration_test() {
         });
     }
 
-    // all transactions have high-enough fees...
-    conf.miner.min_tx_fee = 1;
-
     // ...but none of them will be mined since we allot zero ms to do so
     conf.miner.first_attempt_time_ms = 0;
     conf.miner.subsequent_attempt_time_ms = 0;
@@ -3294,8 +3288,6 @@ fn miner_submit_twice() {
         amount: 1049230,
     });
 
-    // all transactions have high-enough fees...
-    conf.miner.min_tx_fee = 1;
     conf.node.mine_microblocks = false;
     // one should be mined in first attempt, and two should be in second attempt
     conf.miner.first_attempt_time_ms = 20;
@@ -3415,7 +3407,6 @@ fn size_check_integration_test() {
     conf.node.microblock_frequency = 5000;
     conf.miner.microblock_attempt_time_ms = 120_000;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -3592,7 +3583,6 @@ fn size_overflow_unconfirmed_microblocks_integration_test() {
     conf.node.microblock_frequency = 5_000;
     conf.miner.microblock_attempt_time_ms = 120_000;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -3789,7 +3779,6 @@ fn size_overflow_unconfirmed_stream_microblocks_integration_test() {
     conf.node.max_microblocks = 65536;
     conf.burnchain.max_rbf = 1000000;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -3984,7 +3973,6 @@ fn size_overflow_unconfirmed_invalid_stream_microblocks_integration_test() {
     epochs[1].block_limit = core::BLOCK_LIMIT_MAINNET_20;
     conf.burnchain.epochs = Some(epochs);
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -4247,7 +4235,6 @@ fn runtime_overflow_unconfirmed_microblocks_integration_test() {
     conf.node.microblock_frequency = 15000;
     conf.miner.microblock_attempt_time_ms = 120_000;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -4423,7 +4410,6 @@ fn block_replay_integration_test() {
     conf.node.wait_time_for_microblocks = 30000;
     conf.node.microblock_frequency = 5_000;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -4874,7 +4860,6 @@ fn mining_events_integration_test() {
     conf.node.wait_time_for_microblocks = 1000;
     conf.node.microblock_frequency = 1000;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -5122,7 +5107,6 @@ fn block_limit_hit_integration_test() {
     conf.node.wait_time_for_microblocks = 30000;
     conf.node.microblock_frequency = 1000;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -5340,7 +5324,6 @@ fn microblock_limit_hit_integration_test() {
     conf.burnchain.max_rbf = 10_000_000;
     conf.node.wait_time_for_blocks = 1_000;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -5552,7 +5535,6 @@ fn block_large_tx_integration_test() {
     conf.burnchain.max_rbf = 10_000_000;
     conf.node.wait_time_for_blocks = 1_000;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -5687,7 +5669,6 @@ fn microblock_large_tx_integration_test_FLAKY() {
     conf.node.wait_time_for_microblocks = 30000;
     conf.node.microblock_frequency = 1000;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -10836,3 +10817,336 @@ fn microblock_miner_multiple_attempts() {
 
     channel.stop_chains_coordinator();
 }
+
+#[test]
+#[ignore]
+fn min_txs() {
+    if env::var("BITCOIND_TEST") != Ok("1".into()) {
+        return;
+    }
+
+    let spender_sk = StacksPrivateKey::new();
+    let spender_addr = to_addr(&spender_sk);
+    let spender_princ: PrincipalData = spender_addr.into();
+
+    let (mut conf, _miner_account) = neon_integration_test_conf();
+
+    test_observer::spawn();
+
+    conf.events_observers.insert(EventObserverConfig {
+        endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
+        events_keys: vec![EventKeyType::AnyEvent],
+    });
+
+    conf.miner.min_tx_count = 4;
+    conf.miner.first_attempt_time_ms = 0;
+    conf.miner.activated_vrf_key_path = Some("/tmp/activate_vrf_key.min_txs.json".to_string());
+
+    if fs::metadata("/tmp/activate_vrf_key.min_txs.json").is_ok() {
+        fs::remove_file("/tmp/activate_vrf_key.min_txs.json").unwrap();
+    }
+
+    let spender_bal = 10_000_000_000 * (core::MICROSTACKS_PER_STACKS as u64);
+
+    conf.initial_balances.push(InitialBalance {
+        address: spender_princ.clone(),
+        amount: spender_bal,
+    });
+
+    let mut btcd_controller = BitcoinCoreController::new(conf.clone());
+    btcd_controller
+        .start_bitcoind()
+        .map_err(|_e| ())
+        .expect("Failed starting bitcoind");
+
+    let burnchain_config = Burnchain::regtest(&conf.get_burn_db_path());
+
+    let mut btc_regtest_controller = BitcoinRegtestController::with_burnchain(
+        conf.clone(),
+        None,
+        Some(burnchain_config.clone()),
+        None,
+    );
+    let http_origin = format!("http://{}", &conf.node.rpc_bind);
+
+    btc_regtest_controller.bootstrap_chain(201);
+
+    eprintln!("Chain bootstrapped...");
+
+    let mut run_loop = neon::RunLoop::new(conf.clone());
+    let blocks_processed = run_loop.get_blocks_processed_arc();
+    let _client = reqwest::blocking::Client::new();
+    let channel = run_loop.get_coordinator_channel().unwrap();
+
+    thread::spawn(move || run_loop.start(Some(burnchain_config), 0));
+
+    // give the run loop some time to start up!
+    wait_for_runloop(&blocks_processed);
+
+    // first block wakes up the run loop
+    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+
+    // first block will hold our VRF registration
+    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+
+    // second block will be the first mined Stacks block
+    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+
+    let _sort_height = channel.get_sortitions_processed();
+
+    for i in 0..2 {
+        let code = format!("(print \"hello world {}\")", i);
+        let publish = make_contract_publish(
+            &spender_sk,
+            i as u64,
+            1000,
+            &format!("test-publish-{}", &i),
+            &code,
+        );
+        submit_tx(&http_origin, &publish);
+
+        debug!("Try to build too-small a block {}", &i);
+        next_block_and_wait_with_timeout(&mut btc_regtest_controller, &blocks_processed, 15);
+    }
+
+    let blocks = test_observer::get_blocks();
+    for block in blocks {
+        let transactions = block.get("transactions").unwrap().as_array().unwrap();
+        if transactions.len() > 1 {
+            debug!("Got block: {:?}", &block);
+            assert!(transactions.len() >= 4);
+        }
+    }
+
+    let saved_vrf_key = RelayerThread::load_saved_vrf_key("/tmp/activate_vrf_key.min_txs.json");
+    assert!(saved_vrf_key.is_some());
+
+    test_observer::clear();
+}
+
+#[test]
+#[ignore]
+fn filter_txs_by_type() {
+    if env::var("BITCOIND_TEST") != Ok("1".into()) {
+        return;
+    }
+
+    let spender_sk = StacksPrivateKey::new();
+    let spender_addr = to_addr(&spender_sk);
+    let spender_princ: PrincipalData = spender_addr.into();
+
+    let (mut conf, _miner_account) = neon_integration_test_conf();
+
+    test_observer::spawn();
+
+    conf.events_observers.insert(EventObserverConfig {
+        endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
+        events_keys: vec![EventKeyType::AnyEvent],
+    });
+
+    conf.miner.min_tx_count = 4;
+    conf.miner.first_attempt_time_ms = 0;
+    conf.miner.activated_vrf_key_path = Some("/tmp/activate_vrf_key.filter_txs.json".to_string());
+    conf.miner.txs_to_consider = [MemPoolWalkTxTypes::TokenTransfer].into_iter().collect();
+
+    if fs::metadata("/tmp/activate_vrf_key.filter_txs.json").is_ok() {
+        fs::remove_file("/tmp/activate_vrf_key.filter_txs.json").unwrap();
+    }
+
+    let spender_bal = 10_000_000_000 * (core::MICROSTACKS_PER_STACKS as u64);
+
+    conf.initial_balances.push(InitialBalance {
+        address: spender_princ.clone(),
+        amount: spender_bal,
+    });
+
+    let mut btcd_controller = BitcoinCoreController::new(conf.clone());
+    btcd_controller
+        .start_bitcoind()
+        .map_err(|_e| ())
+        .expect("Failed starting bitcoind");
+
+    let burnchain_config = Burnchain::regtest(&conf.get_burn_db_path());
+
+    let mut btc_regtest_controller = BitcoinRegtestController::with_burnchain(
+        conf.clone(),
+        None,
+        Some(burnchain_config.clone()),
+        None,
+    );
+    let http_origin = format!("http://{}", &conf.node.rpc_bind);
+
+    btc_regtest_controller.bootstrap_chain(201);
+
+    eprintln!("Chain bootstrapped...");
+
+    let mut run_loop = neon::RunLoop::new(conf.clone());
+    let blocks_processed = run_loop.get_blocks_processed_arc();
+    let _client = reqwest::blocking::Client::new();
+    let channel = run_loop.get_coordinator_channel().unwrap();
+
+    thread::spawn(move || run_loop.start(Some(burnchain_config), 0));
+
+    // give the run loop some time to start up!
+    wait_for_runloop(&blocks_processed);
+
+    // first block wakes up the run loop
+    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+
+    // first block will hold our VRF registration
+    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+
+    // second block will be the first mined Stacks block
+    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+
+    let _sort_height = channel.get_sortitions_processed();
+    let mut sent_txids = HashSet::new();
+    for i in 0..2 {
+        let code = format!("(print \"hello world {}\")", i);
+        let publish = make_contract_publish(
+            &spender_sk,
+            i as u64,
+            1000,
+            &format!("test-publish-{}", &i),
+            &code,
+        );
+        let parsed = StacksTransaction::consensus_deserialize(&mut &publish[..]).unwrap();
+        sent_txids.insert(parsed.txid());
+
+        submit_tx(&http_origin, &publish);
+        next_block_and_wait_with_timeout(&mut btc_regtest_controller, &blocks_processed, 15);
+    }
+
+    let blocks = test_observer::get_blocks();
+    for block in blocks {
+        info!("block: {:?}", &block);
+        let transactions = block.get("transactions").unwrap().as_array().unwrap();
+        for tx in transactions {
+            let raw_tx = tx.get("raw_tx").unwrap().as_str().unwrap();
+            if raw_tx == "0x00" {
+                continue;
+            }
+            let tx_bytes = hex_bytes(&raw_tx[2..]).unwrap();
+            let parsed = StacksTransaction::consensus_deserialize(&mut &tx_bytes[..]).unwrap();
+            if sent_txids.contains(&parsed.txid()) {
+                panic!("Included a smart contract");
+            }
+        }
+    }
+
+    let saved_vrf_key = RelayerThread::load_saved_vrf_key("/tmp/activate_vrf_key.filter_txs.json");
+    assert!(saved_vrf_key.is_some());
+
+    test_observer::clear();
+}
+
+#[test]
+#[ignore]
+fn filter_txs_by_origin() {
+    if env::var("BITCOIND_TEST") != Ok("1".into()) {
+        return;
+    }
+
+    let spender_sk = StacksPrivateKey::new();
+    let spender_addr = to_addr(&spender_sk);
+    let spender_princ: PrincipalData = spender_addr.into();
+
+    let (mut conf, _miner_account) = neon_integration_test_conf();
+
+    test_observer::spawn();
+
+    conf.events_observers.insert(EventObserverConfig {
+        endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
+        events_keys: vec![EventKeyType::AnyEvent],
+    });
+
+    conf.miner.min_tx_count = 4;
+    conf.miner.first_attempt_time_ms = 0;
+    conf.miner.filter_origins =
+        [StacksAddress::from_string("STA2MZWV9N67TBYVWTE0PSSKMJ2F6YXW7DX96QAM").unwrap()]
+            .into_iter()
+            .collect();
+
+    let spender_bal = 10_000_000_000 * (core::MICROSTACKS_PER_STACKS as u64);
+
+    conf.initial_balances.push(InitialBalance {
+        address: spender_princ.clone(),
+        amount: spender_bal,
+    });
+
+    let mut btcd_controller = BitcoinCoreController::new(conf.clone());
+    btcd_controller
+        .start_bitcoind()
+        .map_err(|_e| ())
+        .expect("Failed starting bitcoind");
+
+    let burnchain_config = Burnchain::regtest(&conf.get_burn_db_path());
+
+    let mut btc_regtest_controller = BitcoinRegtestController::with_burnchain(
+        conf.clone(),
+        None,
+        Some(burnchain_config.clone()),
+        None,
+    );
+    let http_origin = format!("http://{}", &conf.node.rpc_bind);
+
+    btc_regtest_controller.bootstrap_chain(201);
+
+    eprintln!("Chain bootstrapped...");
+
+    let mut run_loop = neon::RunLoop::new(conf.clone());
+    let blocks_processed = run_loop.get_blocks_processed_arc();
+    let _client = reqwest::blocking::Client::new();
+    let channel = run_loop.get_coordinator_channel().unwrap();
+
+    thread::spawn(move || run_loop.start(Some(burnchain_config), 0));
+
+    // give the run loop some time to start up!
+    wait_for_runloop(&blocks_processed);
+
+    // first block wakes up the run loop
+    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+
+    // first block will hold our VRF registration
+    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+
+    // second block will be the first mined Stacks block
+    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+
+    let _sort_height = channel.get_sortitions_processed();
+    let mut sent_txids = HashSet::new();
+    for i in 0..2 {
+        let code = format!("(print \"hello world {}\")", i);
+        let publish = make_contract_publish(
+            &spender_sk,
+            i as u64,
+            1000,
+            &format!("test-publish-{}", &i),
+            &code,
+        );
+        let parsed = StacksTransaction::consensus_deserialize(&mut &publish[..]).unwrap();
+        sent_txids.insert(parsed.txid());
+
+        submit_tx(&http_origin, &publish);
+        next_block_and_wait_with_timeout(&mut btc_regtest_controller, &blocks_processed, 15);
+    }
+
+    let blocks = test_observer::get_blocks();
+    for block in blocks {
+        info!("block: {:?}", &block);
+        let transactions = block.get("transactions").unwrap().as_array().unwrap();
+        for tx in transactions {
+            let raw_tx = tx.get("raw_tx").unwrap().as_str().unwrap();
+            if raw_tx == "0x00" {
+                continue;
+            }
+            let tx_bytes = hex_bytes(&raw_tx[2..]).unwrap();
+            let parsed = StacksTransaction::consensus_deserialize(&mut &tx_bytes[..]).unwrap();
+            if sent_txids.contains(&parsed.txid()) {
+                panic!("Included a smart contract");
+            }
+        }
+    }
+
+    test_observer::clear();
+}

From 9012cf768a58d97654d6d89bda5a21b5e950224b Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Wed, 17 Jan 2024 16:26:03 -0500
Subject: [PATCH 0388/1166] chore: cargo fmt-stacks

---
 stackslib/src/core/mempool.rs              |  2 +-
 stackslib/src/core/tests/mod.rs            |  4 ++--
 stackslib/src/cost_estimates/fee_scalar.rs |  5 +----
 stackslib/src/net/httpcore.rs              | 16 ++++++++++++----
 4 files changed, 16 insertions(+), 11 deletions(-)

diff --git a/stackslib/src/core/mempool.rs b/stackslib/src/core/mempool.rs
index 0146065e63..36c52fa008 100644
--- a/stackslib/src/core/mempool.rs
+++ b/stackslib/src/core/mempool.rs
@@ -20,9 +20,9 @@ use std::hash::Hasher;
 use std::io::{Read, Write};
 use std::ops::{Deref, DerefMut};
 use std::path::{Path, PathBuf};
+use std::str::FromStr;
 use std::time::Instant;
 use std::{fs, io};
-use std::str::FromStr;
 
 use clarity::vm::types::PrincipalData;
 use rand::distributions::Uniform;
diff --git a/stackslib/src/core/tests/mod.rs b/stackslib/src/core/tests/mod.rs
index cfa950f1f5..35a933045a 100644
--- a/stackslib/src/core/tests/mod.rs
+++ b/stackslib/src/core/tests/mod.rs
@@ -58,8 +58,8 @@ use crate::chainstate::stacks::{
     C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
 };
 use crate::core::mempool::{
-    db_get_all_nonces, MemPoolSyncData, MemPoolWalkSettings, MemPoolWalkTxTypes, TxTag, BLOOM_COUNTER_DEPTH,
-    BLOOM_COUNTER_ERROR_RATE, MAX_BLOOM_COUNTER_TXS,
+    db_get_all_nonces, MemPoolSyncData, MemPoolWalkSettings, MemPoolWalkTxTypes, TxTag,
+    BLOOM_COUNTER_DEPTH, BLOOM_COUNTER_ERROR_RATE, MAX_BLOOM_COUNTER_TXS,
 };
 use crate::core::{FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH};
 use crate::net::Error as NetError;
diff --git a/stackslib/src/cost_estimates/fee_scalar.rs b/stackslib/src/cost_estimates/fee_scalar.rs
index b7fc814ff3..2ac4e592ac 100644
--- a/stackslib/src/cost_estimates/fee_scalar.rs
+++ b/stackslib/src/cost_estimates/fee_scalar.rs
@@ -4,6 +4,7 @@ use std::iter::FromIterator;
 use std::path::Path;
 
 use clarity::vm::costs::ExecutionCost;
+use clarity::vm::database::{ClaritySerializable, STXBalance};
 use rusqlite::types::{FromSql, FromSqlError};
 use rusqlite::{
     Connection, Error as SqliteError, OptionalExtension, ToSql, Transaction as SqlTransaction,
@@ -12,10 +13,6 @@ use serde_json::Value as JsonValue;
 
 use super::metrics::CostMetric;
 use super::{EstimatorError, FeeEstimator, FeeRateEstimate};
-
-use clarity::vm::database::ClaritySerializable;
-use clarity::vm::database::STXBalance;
-
 use crate::chainstate::stacks::db::StacksEpochReceipt;
 use crate::chainstate::stacks::events::TransactionOrigin;
 use crate::chainstate::stacks::TransactionPayload;
diff --git a/stackslib/src/net/httpcore.rs b/stackslib/src/net/httpcore.rs
index 017a151af6..169677eb8c 100644
--- a/stackslib/src/net/httpcore.rs
+++ b/stackslib/src/net/httpcore.rs
@@ -32,8 +32,8 @@ use stacks_common::types::chainstate::{
 use stacks_common::types::net::PeerHost;
 use stacks_common::types::Address;
 use stacks_common::util::chunked_encoding::*;
-use stacks_common::util::retry::{BoundReader, RetryReader};
 use stacks_common::util::get_epoch_time_ms;
+use stacks_common::util::retry::{BoundReader, RetryReader};
 use url::Url;
 
 use crate::burnchains::Txid;
@@ -436,12 +436,16 @@ pub trait RPCRequestHandler: HttpRequest + HttpResponse + RPCRequestHandlerClone
 pub struct StacksHttpRequest {
     preamble: HttpRequestPreamble,
     contents: HttpRequestContents,
-    start_time: u128
+    start_time: u128,
 }
 
 impl StacksHttpRequest {
     pub fn new(preamble: HttpRequestPreamble, contents: HttpRequestContents) -> Self {
-        Self { preamble, contents, start_time: get_epoch_time_ms() }
+        Self {
+            preamble,
+            contents,
+            start_time: get_epoch_time_ms(),
+        }
     }
 
     /// Instantiate a request to a remote Stacks peer
@@ -472,7 +476,11 @@ impl StacksHttpRequest {
             preamble.path_and_query_str = decoded_path;
         }
 
-        Ok(Self { preamble, contents, start_time: get_epoch_time_ms() })
+        Ok(Self {
+            preamble,
+            contents,
+            start_time: get_epoch_time_ms(),
+        })
     }
 
     /// Get a reference to the request premable metadata

From 12f5d9c6c3338a7ef74c3133e30d0d958273b723 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Thu, 18 Jan 2024 10:39:51 -0600
Subject: [PATCH 0389/1166] feat: remove stacker signature fields from tenure
 change payload

---
 stackslib/src/chainstate/nakamoto/tests/mod.rs  | 16 ----------------
 stackslib/src/chainstate/nakamoto/tests/node.rs |  2 --
 stackslib/src/chainstate/stacks/block.rs        |  2 --
 stackslib/src/chainstate/stacks/mod.rs          |  8 --------
 stackslib/src/chainstate/stacks/transaction.rs  |  8 +-------
 testnet/stacks-node/src/mockamoto.rs            |  2 --
 testnet/stacks-node/src/nakamoto_node/miner.rs  | 11 ++---------
 7 files changed, 3 insertions(+), 46 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/tests/mod.rs b/stackslib/src/chainstate/nakamoto/tests/mod.rs
index 2e89d23bcb..64f8fa3d13 100644
--- a/stackslib/src/chainstate/nakamoto/tests/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/mod.rs
@@ -174,8 +174,6 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
         previous_tenure_blocks: 1,
         cause: TenureChangeCause::BlockFound,
         pubkey_hash: Hash160([0x02; 20]),
-        signature: ThresholdSignature::mock(),
-        signers: vec![],
     };
 
     // non-sortition-inducing tenure change
@@ -187,8 +185,6 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
         previous_tenure_blocks: 1,
         cause: TenureChangeCause::Extended,
         pubkey_hash: Hash160([0x02; 20]),
-        signature: ThresholdSignature::mock(),
-        signers: vec![],
     };
 
     let invalid_tenure_change_payload = TenureChangePayload {
@@ -200,8 +196,6 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
         previous_tenure_blocks: 1,
         cause: TenureChangeCause::BlockFound,
         pubkey_hash: Hash160([0x02; 20]),
-        signature: ThresholdSignature::mock(),
-        signers: vec![],
     };
 
     let proof_bytes = hex_bytes("9275df67a68c8745c0ff97b48201ee6db447f7c93b23ae24cdc2400f52fdb08a1a6ac7ec71bf9c9c76e96ee4675ebff60625af28718501047bfd87b810c2d2139b73c23bd69de66360953a642c2a330a").unwrap();
@@ -615,8 +609,6 @@ pub fn test_load_store_update_nakamoto_blocks() {
         previous_tenure_blocks: 1,
         cause: TenureChangeCause::BlockFound,
         pubkey_hash: Hash160([0x02; 20]),
-        signature: ThresholdSignature::mock(),
-        signers: vec![],
     };
 
     let tenure_change_tx_payload = TransactionPayload::TenureChange(tenure_change_payload.clone());
@@ -1255,8 +1247,6 @@ fn test_nakamoto_block_static_verification() {
         previous_tenure_blocks: 1,
         cause: TenureChangeCause::BlockFound,
         pubkey_hash: Hash160::from_node_public_key(&StacksPublicKey::from_private(&private_key)),
-        signature: ThresholdSignature::mock(),
-        signers: vec![],
     };
 
     let tenure_change_payload_bad_ch = TenureChangePayload {
@@ -1267,8 +1257,6 @@ fn test_nakamoto_block_static_verification() {
         previous_tenure_blocks: 1,
         cause: TenureChangeCause::BlockFound,
         pubkey_hash: Hash160::from_node_public_key(&StacksPublicKey::from_private(&private_key)),
-        signature: ThresholdSignature::mock(),
-        signers: vec![],
     };
 
     let tenure_change_payload_bad_miner_sig = TenureChangePayload {
@@ -1279,8 +1267,6 @@ fn test_nakamoto_block_static_verification() {
         previous_tenure_blocks: 1,
         cause: TenureChangeCause::BlockFound,
         pubkey_hash: Hash160([0x02; 20]), // wrong
-        signature: ThresholdSignature::mock(),
-        signers: vec![],
     };
 
     let tenure_change_tx_payload = TransactionPayload::TenureChange(tenure_change_payload.clone());
@@ -1551,8 +1537,6 @@ pub fn test_get_highest_nakamoto_tenure() {
             previous_tenure_blocks: 10,
             cause: TenureChangeCause::BlockFound,
             pubkey_hash: Hash160([0x00; 20]),
-            signature: ThresholdSignature::mock(),
-            signers: vec![],
         };
 
         let tx = chainstate.db_tx_begin().unwrap();
diff --git a/stackslib/src/chainstate/nakamoto/tests/node.rs b/stackslib/src/chainstate/nakamoto/tests/node.rs
index e1a12230f8..9c96ca1e6c 100644
--- a/stackslib/src/chainstate/nakamoto/tests/node.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/node.rs
@@ -476,8 +476,6 @@ impl TestStacksNode {
             previous_tenure_blocks,
             cause: tenure_change_cause,
             pubkey_hash: miner.nakamoto_miner_hash160(),
-            signature: ThresholdSignature::mock(),
-            signers: vec![],
         };
 
         let block_commit_op = self.make_nakamoto_tenure_commitment(
diff --git a/stackslib/src/chainstate/stacks/block.rs b/stackslib/src/chainstate/stacks/block.rs
index 8de0eb75e4..011ff9baa8 100644
--- a/stackslib/src/chainstate/stacks/block.rs
+++ b/stackslib/src/chainstate/stacks/block.rs
@@ -1789,8 +1789,6 @@ mod test {
             previous_tenure_blocks: 0,
             cause: TenureChangeCause::BlockFound,
             pubkey_hash: Hash160([0x00; 20]),
-            signature: ThresholdSignature::mock(),
-            signers: vec![],
         };
         let tx_tenure_change = StacksTransaction::new(
             TransactionVersion::Testnet,
diff --git a/stackslib/src/chainstate/stacks/mod.rs b/stackslib/src/chainstate/stacks/mod.rs
index e1f07efc92..81523ecfec 100644
--- a/stackslib/src/chainstate/stacks/mod.rs
+++ b/stackslib/src/chainstate/stacks/mod.rs
@@ -731,10 +731,6 @@ pub struct TenureChangePayload {
     pub cause: TenureChangeCause,
     /// The ECDSA public key hash of the current tenure
     pub pubkey_hash: Hash160,
-    /// The Stacker signature
-    pub signature: ThresholdSignature,
-    /// A bitmap of which Stackers signed
-    pub signers: Vec<u8>,
 }
 
 impl TenureChangePayload {
@@ -752,8 +748,6 @@ impl TenureChangePayload {
             previous_tenure_blocks: num_blocks_so_far,
             cause: TenureChangeCause::Extended,
             pubkey_hash: self.pubkey_hash.clone(),
-            signature: ThresholdSignature::mock(),
-            signers: vec![],
         }
     }
 }
@@ -1400,8 +1394,6 @@ pub mod test {
                 previous_tenure_blocks: 0,
                 cause: TenureChangeCause::BlockFound,
                 pubkey_hash: Hash160([0x00; 20]),
-                signature: ThresholdSignature::mock(),
-                signers: vec![],
             }),
         ];
 
diff --git a/stackslib/src/chainstate/stacks/transaction.rs b/stackslib/src/chainstate/stacks/transaction.rs
index 2999bb1c75..248ab2180e 100644
--- a/stackslib/src/chainstate/stacks/transaction.rs
+++ b/stackslib/src/chainstate/stacks/transaction.rs
@@ -201,9 +201,7 @@ impl StacksMessageCodec for TenureChangePayload {
         write_next(fd, &self.previous_tenure_end)?;
         write_next(fd, &self.previous_tenure_blocks)?;
         write_next(fd, &self.cause)?;
-        write_next(fd, &self.pubkey_hash)?;
-        write_next(fd, &self.signature)?;
-        write_next(fd, &self.signers)
+        write_next(fd, &self.pubkey_hash)
     }
 
     fn consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, codec_error> {
@@ -215,8 +213,6 @@ impl StacksMessageCodec for TenureChangePayload {
             previous_tenure_blocks: read_next(fd)?,
             cause: read_next(fd)?,
             pubkey_hash: read_next(fd)?,
-            signature: read_next(fd)?,
-            signers: read_next(fd)?,
         })
     }
 }
@@ -3782,8 +3778,6 @@ mod test {
                 previous_tenure_blocks: 0,
                 cause: TenureChangeCause::BlockFound,
                 pubkey_hash: Hash160([0x00; 20]),
-                signature: ThresholdSignature::mock(),
-                signers: vec![],
             }),
         );
 
diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index d924b4a712..3227b50ec0 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -813,8 +813,6 @@ impl MockamotoNode {
             previous_tenure_blocks: 1,
             cause: TenureChangeCause::BlockFound,
             pubkey_hash: miner_pk_hash,
-            signature: ThresholdSignature::mock(),
-            signers: vec![],
         });
         let mut tenure_tx = StacksTransaction::new(
             TransactionVersion::Testnet,
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index cc9b25c61b..7aec8ce6bb 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -30,8 +30,8 @@ use stacks::chainstate::stacks::boot::MINERS_NAME;
 use stacks::chainstate::stacks::db::{StacksChainState, StacksHeaderInfo};
 use stacks::chainstate::stacks::{
     CoinbasePayload, Error as ChainstateError, StacksTransaction, StacksTransactionSigner,
-    TenureChangeCause, TenureChangePayload, ThresholdSignature, TransactionAnchorMode,
-    TransactionPayload, TransactionVersion,
+    TenureChangeCause, TenureChangePayload, TransactionAnchorMode, TransactionPayload,
+    TransactionVersion,
 };
 use stacks::core::FIRST_BURNCHAIN_CONSENSUS_HASH;
 use stacks::net::stackerdb::StackerDBs;
@@ -299,11 +299,6 @@ impl BlockMinerThread {
         parent_tenure_blocks: u64,
         miner_pkh: Hash160,
     ) -> Result<StacksTransaction, NakamotoNodeError> {
-        if self.config.self_signing().is_none() {
-            // if we're not self-signing, then we can't generate a tenure change tx: it has to come from the signers.
-            warn!("Tried to generate a tenure change transaction, but we aren't self-signing");
-            return Err(NakamotoNodeError::CannotSelfSign);
-        }
         let is_mainnet = self.config.is_mainnet();
         let chain_id = self.config.burnchain.chain_id;
         let tenure_change_tx_payload = TransactionPayload::TenureChange(TenureChangePayload {
@@ -315,8 +310,6 @@ impl BlockMinerThread {
                 .expect("FATAL: more than u32 blocks in a tenure"),
             cause: TenureChangeCause::BlockFound,
             pubkey_hash: miner_pkh,
-            signers: vec![],
-            signature: ThresholdSignature::mock(),
         });
 
         let mut tx_auth = self.keychain.get_transaction_auth().unwrap();

From 43894995cee527f66ef30a28b9b70b91ae0b111d Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Thu, 18 Jan 2024 12:53:28 -0500
Subject: [PATCH 0390/1166] chore: cargo fmt

---
 Cargo.lock                                    |    4 +-
 clarity/src/libclarity.rs                     |    4 +-
 clarity/src/vm/analysis/analysis_db.rs        |   63 +-
 .../contract_interface_builder/mod.rs         |   74 +-
 clarity/src/vm/analysis/errors.rs             |   19 +
 clarity/src/vm/analysis/mod.rs                |   19 +-
 clarity/src/vm/analysis/trait_checker/mod.rs  |    2 +-
 clarity/src/vm/analysis/type_checker/mod.rs   |    8 +-
 .../src/vm/analysis/type_checker/v2_05/mod.rs |   55 +-
 .../type_checker/v2_05/natives/mod.rs         |  106 +-
 .../type_checker/v2_05/natives/sequences.rs   |   20 +-
 .../type_checker/v2_05/tests/contracts.rs     |    5 +-
 .../analysis/type_checker/v2_05/tests/mod.rs  |   12 +-
 .../src/vm/analysis/type_checker/v2_1/mod.rs  |   64 +-
 .../type_checker/v2_1/natives/assets.rs       |    3 +-
 .../type_checker/v2_1/natives/conversions.rs  |    2 +-
 .../analysis/type_checker/v2_1/natives/mod.rs |  163 ++-
 .../type_checker/v2_1/natives/sequences.rs    |   22 +-
 .../type_checker/v2_1/tests/contracts.rs      |   12 +-
 .../analysis/type_checker/v2_1/tests/mod.rs   |   54 +-
 clarity/src/vm/analysis/types.rs              |    1 +
 clarity/src/vm/ast/definition_sorter/mod.rs   |   16 +-
 clarity/src/vm/ast/errors.rs                  |   13 +
 clarity/src/vm/ast/mod.rs                     |    5 +-
 clarity/src/vm/ast/parser/v1.rs               |    5 +-
 clarity/src/vm/ast/parser/v2/mod.rs           |   11 +-
 clarity/src/vm/ast/sugar_expander/mod.rs      |    7 +-
 clarity/src/vm/callables.rs                   |   69 +-
 clarity/src/vm/clarity.rs                     |   30 +-
 clarity/src/vm/contexts.rs                    |  189 ++-
 clarity/src/vm/costs/mod.rs                   |  194 ++-
 clarity/src/vm/database/clarity_db.rs         |  659 ++++++----
 clarity/src/vm/database/clarity_store.rs      |   85 +-
 clarity/src/vm/database/key_value_wrapper.rs  |  205 +--
 clarity/src/vm/database/sqlite.rs             |   49 +-
 clarity/src/vm/database/structures.rs         |  400 +++---
 clarity/src/vm/docs/contracts.rs              |    6 +-
 clarity/src/vm/docs/mod.rs                    |   10 +-
 clarity/src/vm/errors.rs                      |   30 +-
 clarity/src/vm/events.rs                      |   49 +-
 clarity/src/vm/functions/arithmetic.rs        |   40 +-
 clarity/src/vm/functions/assets.rs            |  131 +-
 clarity/src/vm/functions/conversions.rs       |   35 +-
 clarity/src/vm/functions/crypto.rs            |   27 +-
 clarity/src/vm/functions/database.rs          |   88 +-
 clarity/src/vm/functions/mod.rs               |   17 +-
 clarity/src/vm/functions/options.rs           |   17 +-
 clarity/src/vm/functions/principals.rs        |   72 +-
 clarity/src/vm/functions/sequences.rs         |   69 +-
 clarity/src/vm/functions/tuples.rs            |   18 +-
 clarity/src/vm/mod.rs                         |   48 +-
 clarity/src/vm/representations.rs             |   14 +-
 clarity/src/vm/tests/contracts.rs             |   20 +-
 clarity/src/vm/tests/principals.rs            |    2 +-
 clarity/src/vm/tests/sequences.rs             |   12 +-
 clarity/src/vm/tests/simple_apply_eval.rs     |   43 +-
 clarity/src/vm/tests/traits.rs                |   66 +-
 clarity/src/vm/types/mod.rs                   |  310 +++--
 clarity/src/vm/types/serialization.rs         |  159 ++-
 clarity/src/vm/types/signatures.rs            |  412 +++---
 clarity/src/vm/variables.rs                   |   15 +-
 src/burnchains/burnchain.rs                   |    4 +-
 src/chainstate/coordinator/tests.rs           |   93 +-
 src/chainstate/stacks/address.rs              |   56 +-
 src/chainstate/stacks/boot/contract_tests.rs  |   10 +-
 src/chainstate/stacks/boot/mod.rs             |  151 ++-
 src/chainstate/stacks/boot/pox_2_tests.rs     |  181 ++-
 src/chainstate/stacks/boot/pox_3_tests.rs     |   79 +-
 src/chainstate/stacks/db/accounts.rs          |  130 +-
 src/chainstate/stacks/db/blocks.rs            |  119 +-
 src/chainstate/stacks/db/mod.rs               |   11 +-
 src/chainstate/stacks/db/transactions.rs      |  160 ++-
 src/chainstate/stacks/db/unconfirmed.rs       |   23 +-
 src/chainstate/stacks/miner.rs                |   11 +-
 src/chainstate/stacks/mod.rs                  |    2 +-
 src/chainstate/stacks/tests/accounting.rs     |   38 +-
 .../stacks/tests/block_construction.rs        |   21 +-
 .../stacks/tests/chain_histories.rs           |   32 +-
 src/chainstate/stacks/tests/mod.rs            |    2 +
 src/clarity_cli.rs                            |   32 +-
 src/clarity_vm/clarity.rs                     |  109 +-
 src/clarity_vm/database/marf.rs               |   99 +-
 src/clarity_vm/database/mod.rs                |   11 +-
 src/clarity_vm/special.rs                     |   78 +-
 src/clarity_vm/tests/analysis_costs.rs        |    2 +-
 src/clarity_vm/tests/costs.rs                 |   12 +-
 src/clarity_vm/tests/events.rs                |    4 +-
 src/clarity_vm/tests/forking.rs               |    4 +-
 src/clarity_vm/tests/large_contract.rs        |   12 +-
 src/core/mempool.rs                           |  115 +-
 src/core/tests/mod.rs                         |  173 +--
 src/cost_estimates/fee_scalar.rs              |   23 +-
 src/main.rs                                   |    1 +
 src/net/download.rs                           |    1 +
 src/net/http.rs                               |    4 +-
 src/net/mod.rs                                |    2 +-
 src/net/relay.rs                              |    8 +-
 src/net/rpc.rs                                |  213 ++--
 testnet/stacks-node/Cargo.toml                |    4 +-
 .../conf/testnet-follower-conf.toml           |    2 +-
 .../stacks-node/conf/testnet-miner-conf.toml  |    2 +-
 .../burnchains/bitcoin_regtest_controller.rs  |   66 +-
 testnet/stacks-node/src/chain_data.rs         | 1105 ----------------
 testnet/stacks-node/src/config.rs             |  215 +---
 testnet/stacks-node/src/event_dispatcher.rs   |   16 +-
 testnet/stacks-node/src/main.rs               |  258 +---
 testnet/stacks-node/src/neon_node.rs          | 1121 ++---------------
 testnet/stacks-node/src/run_loop/mod.rs       |    2 +-
 testnet/stacks-node/src/run_loop/neon.rs      |   19 +-
 .../stacks-node/src/tests/bitcoin_regtest.rs  |    1 +
 testnet/stacks-node/src/tests/epoch_205.rs    |    1 +
 testnet/stacks-node/src/tests/epoch_21.rs     |   73 +-
 testnet/stacks-node/src/tests/epoch_22.rs     |   12 +-
 testnet/stacks-node/src/tests/epoch_23.rs     |    1 +
 testnet/stacks-node/src/tests/epoch_24.rs     |   21 +-
 testnet/stacks-node/src/tests/integrations.rs |   38 +-
 testnet/stacks-node/src/tests/mod.rs          |  351 +-----
 .../src/tests/neon_integrations.rs            |  500 ++------
 118 files changed, 4174 insertions(+), 6019 deletions(-)
 delete mode 100644 testnet/stacks-node/src/chain_data.rs

diff --git a/Cargo.lock b/Cargo.lock
index f952164fc8..d4ea00d0b6 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1820,9 +1820,9 @@ dependencies = [
 
 [[package]]
 name = "pico-args"
-version = "0.5.0"
+version = "0.3.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5be167a7af36ee22fe3115051bc51f6e6c7054c9348e28deb4f49bd6f705a315"
+checksum = "28b9b4df73455c861d7cbf8be42f01d3b373ed7f02e378d55fa84eafc6f638b1"
 
 [[package]]
 name = "pin-project"
diff --git a/clarity/src/libclarity.rs b/clarity/src/libclarity.rs
index f2ac8ebb2b..b91a622ba5 100644
--- a/clarity/src/libclarity.rs
+++ b/clarity/src/libclarity.rs
@@ -82,11 +82,13 @@ pub mod boot_util {
     use stacks_common::types::chainstate::StacksAddress;
     use std::convert::TryFrom;
 
+    #[allow(clippy::expect_used)]
     pub fn boot_code_id(name: &str, mainnet: bool) -> QualifiedContractIdentifier {
         let addr = boot_code_addr(mainnet);
         QualifiedContractIdentifier::new(
             addr.into(),
-            ContractName::try_from(name.to_string()).unwrap(),
+            ContractName::try_from(name.to_string())
+                .expect("FATAL: boot contract name is not a legal ContractName"),
         )
     }
 
diff --git a/clarity/src/vm/analysis/analysis_db.rs b/clarity/src/vm/analysis/analysis_db.rs
index bb330b18d5..ab669f8fc8 100644
--- a/clarity/src/vm/analysis/analysis_db.rs
+++ b/clarity/src/vm/analysis/analysis_db.rs
@@ -46,13 +46,16 @@ impl<'a> AnalysisDatabase<'a> {
     pub fn execute<F, T, E>(&mut self, f: F) -> Result<T, E>
     where
         F: FnOnce(&mut Self) -> Result<T, E>,
+        E: From<CheckErrors>,
     {
         self.begin();
         let result = f(self).or_else(|e| {
-            self.roll_back();
+            self.roll_back()
+                .map_err(|e| CheckErrors::Expects(format!("{e:?}")).into())?;
             Err(e)
         })?;
-        self.commit();
+        self.commit()
+            .map_err(|e| CheckErrors::Expects(format!("{e:?}")).into())?;
         Ok(result)
     }
 
@@ -60,12 +63,16 @@ impl<'a> AnalysisDatabase<'a> {
         self.store.nest();
     }
 
-    pub fn commit(&mut self) {
-        self.store.commit();
+    pub fn commit(&mut self) -> CheckResult<()> {
+        self.store
+            .commit()
+            .map_err(|e| CheckErrors::Expects(format!("{e:?}")).into())
     }
 
-    pub fn roll_back(&mut self) {
-        self.store.rollback();
+    pub fn roll_back(&mut self) -> CheckResult<()> {
+        self.store
+            .rollback()
+            .map_err(|e| CheckErrors::Expects(format!("{e:?}")).into())
     }
 
     pub fn storage_key() -> &'static str {
@@ -79,7 +86,8 @@ impl<'a> AnalysisDatabase<'a> {
     pub fn test_insert_contract_hash(&mut self, contract_identifier: &QualifiedContractIdentifier) {
         use stacks_common::util::hash::Sha512Trunc256Sum;
         self.store
-            .prepare_for_contract_metadata(contract_identifier, Sha512Trunc256Sum([0; 32]));
+            .prepare_for_contract_metadata(contract_identifier, Sha512Trunc256Sum([0; 32]))
+            .unwrap();
     }
 
     pub fn has_contract(&mut self, contract_identifier: &QualifiedContractIdentifier) -> bool {
@@ -91,30 +99,42 @@ impl<'a> AnalysisDatabase<'a> {
     pub fn load_contract_non_canonical(
         &mut self,
         contract_identifier: &QualifiedContractIdentifier,
-    ) -> Option<ContractAnalysis> {
+    ) -> CheckResult<Option<ContractAnalysis>> {
         self.store
             .get_metadata(contract_identifier, AnalysisDatabase::storage_key())
             // treat NoSuchContract error thrown by get_metadata as an Option::None --
             //    the analysis will propagate that as a CheckError anyways.
-            .ok()?
-            .map(|x| ContractAnalysis::deserialize(&x))
+            .ok()
+            .flatten()
+            .map(|x| {
+                ContractAnalysis::deserialize(&x).map_err(|_| {
+                    CheckErrors::Expects("Bad data deserialized from DB".into()).into()
+                })
+            })
+            .transpose()
     }
 
     pub fn load_contract(
         &mut self,
         contract_identifier: &QualifiedContractIdentifier,
         epoch: &StacksEpochId,
-    ) -> Option<ContractAnalysis> {
-        self.store
+    ) -> CheckResult<Option<ContractAnalysis>> {
+        Ok(self
+            .store
             .get_metadata(contract_identifier, AnalysisDatabase::storage_key())
             // treat NoSuchContract error thrown by get_metadata as an Option::None --
             //    the analysis will propagate that as a CheckError anyways.
-            .ok()?
-            .map(|x| ContractAnalysis::deserialize(&x))
+            .ok()
+            .flatten()
+            .map(|x| {
+                ContractAnalysis::deserialize(&x)
+                    .map_err(|_| CheckErrors::Expects("Bad data deserialized from DB".into()))
+            })
+            .transpose()?
             .and_then(|mut x| {
                 x.canonicalize_types(epoch);
                 Some(x)
-            })
+            }))
     }
 
     pub fn insert_contract(
@@ -128,7 +148,8 @@ impl<'a> AnalysisDatabase<'a> {
         }
 
         self.store
-            .insert_metadata(contract_identifier, key, &contract.serialize());
+            .insert_metadata(contract_identifier, key, &contract.serialize())
+            .map_err(|e| CheckErrors::Expects(format!("{e:?}")))?;
         Ok(())
     }
 
@@ -141,7 +162,7 @@ impl<'a> AnalysisDatabase<'a> {
         //         stored as its own entry. the analysis cost tracking currently only
         //         charges based on the function type size.
         let contract = self
-            .load_contract_non_canonical(contract_identifier)
+            .load_contract_non_canonical(contract_identifier)?
             .ok_or(CheckErrors::NoSuchContract(contract_identifier.to_string()))?;
         Ok(contract.clarity_version)
     }
@@ -157,7 +178,7 @@ impl<'a> AnalysisDatabase<'a> {
         //         stored as its own entry. the analysis cost tracking currently only
         //         charges based on the function type size.
         let contract = self
-            .load_contract_non_canonical(contract_identifier)
+            .load_contract_non_canonical(contract_identifier)?
             .ok_or(CheckErrors::NoSuchContract(contract_identifier.to_string()))?;
         Ok(contract
             .get_public_function_type(function_name)
@@ -175,7 +196,7 @@ impl<'a> AnalysisDatabase<'a> {
         //         stored as its own entry. the analysis cost tracking currently only
         //         charges based on the function type size.
         let contract = self
-            .load_contract_non_canonical(contract_identifier)
+            .load_contract_non_canonical(contract_identifier)?
             .ok_or(CheckErrors::NoSuchContract(contract_identifier.to_string()))?;
         Ok(contract
             .get_read_only_function_type(function_name)
@@ -193,7 +214,7 @@ impl<'a> AnalysisDatabase<'a> {
         //         stored as its own entry. the analysis cost tracking currently only
         //         charges based on the function type size.
         let contract = self
-            .load_contract_non_canonical(contract_identifier)
+            .load_contract_non_canonical(contract_identifier)?
             .ok_or(CheckErrors::NoSuchContract(contract_identifier.to_string()))?;
         Ok(contract
             .get_defined_trait(trait_name)
@@ -212,7 +233,7 @@ impl<'a> AnalysisDatabase<'a> {
         contract_identifier: &QualifiedContractIdentifier,
     ) -> CheckResult<BTreeSet<TraitIdentifier>> {
         let contract = self
-            .load_contract_non_canonical(contract_identifier)
+            .load_contract_non_canonical(contract_identifier)?
             .ok_or(CheckErrors::NoSuchContract(contract_identifier.to_string()))?;
         Ok(contract.implemented_traits)
     }
diff --git a/clarity/src/vm/analysis/contract_interface_builder/mod.rs b/clarity/src/vm/analysis/contract_interface_builder/mod.rs
index 61327605d0..9feb66bcf6 100644
--- a/clarity/src/vm/analysis/contract_interface_builder/mod.rs
+++ b/clarity/src/vm/analysis/contract_interface_builder/mod.rs
@@ -26,7 +26,11 @@ use std::collections::{BTreeMap, BTreeSet};
 
 use crate::vm::ClarityVersion;
 
-pub fn build_contract_interface(contract_analysis: &ContractAnalysis) -> ContractInterface {
+use super::{CheckErrors, CheckResult};
+
+pub fn build_contract_interface(
+    contract_analysis: &ContractAnalysis,
+) -> CheckResult<ContractInterface> {
     let mut contract_interface = ContractInterface::new(
         contract_analysis.epoch.clone(),
         contract_analysis.clarity_version.clone(),
@@ -58,21 +62,21 @@ pub fn build_contract_interface(contract_analysis: &ContractAnalysis) -> Contrac
         .append(&mut ContractInterfaceFunction::from_map(
             private_function_types,
             ContractInterfaceFunctionAccess::private,
-        ));
+        )?);
 
     contract_interface
         .functions
         .append(&mut ContractInterfaceFunction::from_map(
             public_function_types,
             ContractInterfaceFunctionAccess::public,
-        ));
+        )?);
 
     contract_interface
         .functions
         .append(&mut ContractInterfaceFunction::from_map(
             read_only_function_types,
             ContractInterfaceFunctionAccess::read_only,
-        ));
+        )?);
 
     contract_interface
         .variables
@@ -102,7 +106,7 @@ pub fn build_contract_interface(contract_analysis: &ContractAnalysis) -> Contrac
             fungible_tokens,
         ));
 
-    contract_interface
+    Ok(contract_interface)
 }
 
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
@@ -262,30 +266,40 @@ pub struct ContractInterfaceFunction {
 }
 
 impl ContractInterfaceFunction {
-    pub fn from_map(
+    fn from_map(
         map: &BTreeMap<ClarityName, FunctionType>,
         access: ContractInterfaceFunctionAccess,
-    ) -> Vec<ContractInterfaceFunction> {
+    ) -> CheckResult<Vec<ContractInterfaceFunction>> {
         map.iter()
-            .map(|(name, function_type)| ContractInterfaceFunction {
-                name: name.clone().into(),
-                access: access.to_owned(),
-                outputs: ContractInterfaceFunctionOutput {
-                    type_f: match function_type {
-                        FunctionType::Fixed(FixedFunction { returns, .. }) => {
-                            ContractInterfaceAtomType::from_type_signature(&returns)
+            .map(|(name, function_type)| {
+                Ok(ContractInterfaceFunction {
+                    name: name.clone().into(),
+                    access: access.to_owned(),
+                    outputs: ContractInterfaceFunctionOutput {
+                        type_f: match function_type {
+                            FunctionType::Fixed(FixedFunction { returns, .. }) => {
+                                ContractInterfaceAtomType::from_type_signature(&returns)
+                            }
+                            _ => return Err(CheckErrors::Expects(
+                                "Contract functions should only have fixed function return types!"
+                                    .into(),
+                            )
+                            .into()),
+                        },
+                    },
+                    args: match function_type {
+                        FunctionType::Fixed(FixedFunction { args, .. }) => {
+                            ContractInterfaceFunctionArg::from_function_args(&args)
+                        }
+                        _ => {
+                            return Err(CheckErrors::Expects(
+                                "Contract functions should only have fixed function arguments!"
+                                    .into(),
+                            )
+                            .into())
                         }
-                        _ => panic!(
-                            "Contract functions should only have fixed function return types!"
-                        ),
                     },
-                },
-                args: match function_type {
-                    FunctionType::Fixed(FixedFunction { args, .. }) => {
-                        ContractInterfaceFunctionArg::from_function_args(&args)
-                    }
-                    _ => panic!("Contract functions should only have fixed function arguments!"),
-                },
+                })
             })
             .collect()
     }
@@ -317,7 +331,7 @@ impl ContractInterfaceFungibleTokens {
 }
 
 impl ContractInterfaceNonFungibleTokens {
-    pub fn from_map(assets: &BTreeMap<ClarityName, TypeSignature>) -> Vec<Self> {
+    fn from_map(assets: &BTreeMap<ClarityName, TypeSignature>) -> Vec<Self> {
         assets
             .iter()
             .map(|(name, type_sig)| Self {
@@ -329,7 +343,7 @@ impl ContractInterfaceNonFungibleTokens {
 }
 
 impl ContractInterfaceVariable {
-    pub fn from_map(
+    fn from_map(
         map: &BTreeMap<ClarityName, TypeSignature>,
         access: ContractInterfaceVariableAccess,
     ) -> Vec<ContractInterfaceVariable> {
@@ -351,7 +365,7 @@ pub struct ContractInterfaceMap {
 }
 
 impl ContractInterfaceMap {
-    pub fn from_map(
+    fn from_map(
         map: &BTreeMap<ClarityName, (TypeSignature, TypeSignature)>,
     ) -> Vec<ContractInterfaceMap> {
         map.iter()
@@ -388,8 +402,10 @@ impl ContractInterface {
         }
     }
 
-    pub fn serialize(&self) -> String {
-        serde_json::to_string(self).expect("Failed to serialize contract interface")
+    pub fn serialize(&self) -> CheckResult<String> {
+        serde_json::to_string(self).map_err(|_| {
+            CheckErrors::Expects("Failed to serialize contract interface".into()).into()
+        })
     }
 }
 
diff --git a/clarity/src/vm/analysis/errors.rs b/clarity/src/vm/analysis/errors.rs
index 76895c1325..db36b656e9 100644
--- a/clarity/src/vm/analysis/errors.rs
+++ b/clarity/src/vm/analysis/errors.rs
@@ -37,6 +37,9 @@ pub enum CheckErrors {
     ExpectedName,
     SupertypeTooLarge,
 
+    // unexpected interpreter behavior
+    Expects(String),
+
     // match errors
     BadMatchOptionSyntax(Box<CheckErrors>),
     BadMatchResponseSyntax(Box<CheckErrors>),
@@ -195,6 +198,17 @@ pub struct CheckError {
     pub diagnostic: Diagnostic,
 }
 
+impl CheckErrors {
+    /// Does this check error indicate that the transaction should be
+    /// rejected?
+    pub fn rejectable(&self) -> bool {
+        match &self {
+            CheckErrors::SupertypeTooLarge | CheckErrors::Expects(_) => true,
+            _ => false,
+        }
+    }
+}
+
 impl CheckError {
     pub fn new(err: CheckErrors) -> CheckError {
         let diagnostic = Diagnostic::err(&err);
@@ -256,6 +270,10 @@ impl From<CostErrors> for CheckErrors {
             CostErrors::CostContractLoadFailure => {
                 CheckErrors::CostComputationFailed("Failed to load cost contract".into())
             }
+            CostErrors::InterpreterFailure => {
+                CheckErrors::Expects("Unexpected interpreter failure in cost computation".into())
+            }
+            CostErrors::Expect(s) => CheckErrors::Expects(s),
         }
     }
 }
@@ -322,6 +340,7 @@ impl DiagnosableError for CheckErrors {
         match &self {
             CheckErrors::ExpectedLiteral => "expected a literal argument".into(),
             CheckErrors::SupertypeTooLarge => "supertype of two types is too large".into(),
+            CheckErrors::Expects(s) => format!("unexpected interpreter behavior: {s}"),
             CheckErrors::BadMatchOptionSyntax(source) =>
                 format!("match on a optional type uses the following syntax: (match input some-name if-some-expression if-none-expression). Caused by: {}",
                         source.message()),
diff --git a/clarity/src/vm/analysis/mod.rs b/clarity/src/vm/analysis/mod.rs
index 640807d42c..abf7d29b93 100644
--- a/clarity/src/vm/analysis/mod.rs
+++ b/clarity/src/vm/analysis/mod.rs
@@ -61,7 +61,7 @@ pub fn mem_type_check(
         epoch,
         ASTRules::PrecheckSize,
     )
-    .unwrap()
+    .map_err(|_| CheckErrors::Expects("Failed to build AST".into()))?
     .expressions;
 
     let mut marf = MemoryBackingStore::new();
@@ -81,8 +81,12 @@ pub fn mem_type_check(
             let first_type = x
                 .type_map
                 .as_ref()
-                .unwrap()
-                .get_type(&x.expressions.last().unwrap())
+                .ok_or_else(|| CheckErrors::Expects("Should be non-empty".into()))?
+                .get_type(
+                    x.expressions
+                        .last()
+                        .ok_or_else(|| CheckErrors::Expects("Should be non-empty".into()))?,
+                )
                 .cloned();
             Ok((first_type, x))
         }
@@ -143,13 +147,18 @@ pub fn run_analysis(
             | StacksEpochId::Epoch24 => {
                 TypeChecker2_1::run_pass(&epoch, &mut contract_analysis, db)
             }
-            StacksEpochId::Epoch10 => unreachable!("Epoch 1.0 is not a valid epoch for analysis"),
+            StacksEpochId::Epoch10 => {
+                return Err(CheckErrors::Expects(
+                    "Epoch 1.0 is not a valid epoch for analysis".into(),
+                )
+                .into())
+            }
         }?;
         TraitChecker::run_pass(&epoch, &mut contract_analysis, db)?;
         ArithmeticOnlyChecker::check_contract_cost_eligible(&mut contract_analysis);
 
         if STORE_CONTRACT_SRC_INTERFACE {
-            let interface = build_contract_interface(&contract_analysis);
+            let interface = build_contract_interface(&contract_analysis)?;
             contract_analysis.contract_interface = Some(interface);
         }
         if save_contract {
diff --git a/clarity/src/vm/analysis/trait_checker/mod.rs b/clarity/src/vm/analysis/trait_checker/mod.rs
index 7938ca2a40..20339b6cd8 100644
--- a/clarity/src/vm/analysis/trait_checker/mod.rs
+++ b/clarity/src/vm/analysis/trait_checker/mod.rs
@@ -58,7 +58,7 @@ impl TraitChecker {
         for trait_identifier in &contract_analysis.implemented_traits {
             let trait_name = trait_identifier.name.to_string();
             let contract_defining_trait = analysis_db
-                .load_contract(&trait_identifier.contract_identifier, &self.epoch)
+                .load_contract(&trait_identifier.contract_identifier, &self.epoch)?
                 .ok_or(CheckErrors::TraitReferenceUnknown(
                     trait_identifier.name.to_string(),
                 ))?;
diff --git a/clarity/src/vm/analysis/type_checker/mod.rs b/clarity/src/vm/analysis/type_checker/mod.rs
index 70ed9e1759..2e78e43ccd 100644
--- a/clarity/src/vm/analysis/type_checker/mod.rs
+++ b/clarity/src/vm/analysis/type_checker/mod.rs
@@ -54,7 +54,9 @@ impl FunctionType {
             | StacksEpochId::Epoch22
             | StacksEpochId::Epoch23
             | StacksEpochId::Epoch24 => self.check_args_2_1(accounting, args, clarity_version),
-            StacksEpochId::Epoch10 => unreachable!("Epoch10 is not supported"),
+            StacksEpochId::Epoch10 => {
+                return Err(CheckErrors::Expects("Epoch10 is not supported".into()).into())
+            }
         }
     }
 
@@ -75,7 +77,9 @@ impl FunctionType {
             | StacksEpochId::Epoch24 => {
                 self.check_args_by_allowing_trait_cast_2_1(db, clarity_version, func_args)
             }
-            StacksEpochId::Epoch10 => unreachable!("Epoch10 is not supported"),
+            StacksEpochId::Epoch10 => {
+                return Err(CheckErrors::Expects("Epoch10 is not supported".into()).into())
+            }
         }
     }
 }
diff --git a/clarity/src/vm/analysis/type_checker/v2_05/mod.rs b/clarity/src/vm/analysis/type_checker/v2_05/mod.rs
index 09f89993e2..274a9dbd04 100644
--- a/clarity/src/vm/analysis/type_checker/v2_05/mod.rs
+++ b/clarity/src/vm/analysis/type_checker/v2_05/mod.rs
@@ -24,6 +24,7 @@ use crate::vm::costs::{
     analysis_typecheck_cost, cost_functions, runtime_cost, ClarityCostFunctionReference,
     CostErrors, CostOverflowingMath, CostTracker, ExecutionCost, LimitedCostTracker,
 };
+use crate::vm::errors::InterpreterError;
 use crate::vm::functions::define::DefineFunctionsParsed;
 use crate::vm::functions::NativeFunctions;
 use crate::vm::representations::SymbolicExpressionType::{
@@ -96,7 +97,7 @@ impl CostTracker for TypeChecker<'_, '_> {
     fn add_memory(&mut self, memory: u64) -> std::result::Result<(), CostErrors> {
         self.cost_track.add_memory(memory)
     }
-    fn drop_memory(&mut self, memory: u64) {
+    fn drop_memory(&mut self, memory: u64) -> std::result::Result<(), CostErrors> {
         self.cost_track.drop_memory(memory)
     }
     fn reset_memory(&mut self) {
@@ -239,7 +240,12 @@ impl FunctionType {
 
                 Ok(TypeSignature::BoolType)
             }
-            FunctionType::Binary(_, _, _) => unreachable!("Binary type should be reached in 2.05"),
+            FunctionType::Binary(_, _, _) => {
+                return Err(CheckErrors::Expects(
+                    "Binary type should not be reached in 2.05".into(),
+                )
+                .into())
+            }
         }
     }
 
@@ -250,7 +256,7 @@ impl FunctionType {
     ) -> CheckResult<TypeSignature> {
         let (expected_args, returns) = match self {
             FunctionType::Fixed(FixedFunction { args, returns }) => (args, returns),
-            _ => panic!("Unexpected function type"),
+            _ => return Err(CheckErrors::Expects("Unexpected function type".into()).into()),
         };
         check_argument_count(expected_args.len(), func_args)?;
 
@@ -261,10 +267,8 @@ impl FunctionType {
                     Value::Principal(PrincipalData::Contract(contract)),
                 ) => {
                     let contract_to_check = db
-                        .load_contract(contract, &StacksEpochId::Epoch2_05)
-                        .ok_or_else(|| {
-                        CheckErrors::NoSuchContract(contract.name.to_string())
-                    })?;
+                        .load_contract(contract, &StacksEpochId::Epoch2_05)?
+                        .ok_or_else(|| CheckErrors::NoSuchContract(contract.name.to_string()))?;
                     let trait_definition = db
                         .get_defined_trait(
                             &trait_id.contract_identifier,
@@ -285,7 +289,7 @@ impl FunctionType {
                 }
                 (expected_type, value) => {
                     if !expected_type.admits(&StacksEpochId::Epoch2_05, &value)? {
-                        let actual_type = TypeSignature::type_of(&value);
+                        let actual_type = TypeSignature::type_of(&value)?;
                         return Err(
                             CheckErrors::TypeError(expected_type.clone(), actual_type).into()
                         );
@@ -305,7 +309,7 @@ fn trait_type_size(trait_sig: &BTreeMap<ClarityName, FunctionSignature>) -> Chec
     Ok(total_size)
 }
 
-fn type_reserved_variable(variable_name: &str) -> Option<TypeSignature> {
+fn type_reserved_variable(variable_name: &str) -> CheckResult<Option<TypeSignature>> {
     if let Some(variable) =
         NativeVariables::lookup_by_name_at_version(variable_name, &ClarityVersion::Clarity1)
     {
@@ -315,18 +319,22 @@ fn type_reserved_variable(variable_name: &str) -> Option<TypeSignature> {
             ContractCaller => TypeSignature::PrincipalType,
             BlockHeight => TypeSignature::UIntType,
             BurnBlockHeight => TypeSignature::UIntType,
-            NativeNone => TypeSignature::new_option(no_type()).unwrap(),
+            NativeNone => TypeSignature::new_option(no_type())
+                .map_err(|_| CheckErrors::Expects("Bad constructor".into()))?,
             NativeTrue => TypeSignature::BoolType,
             NativeFalse => TypeSignature::BoolType,
             TotalLiquidMicroSTX => TypeSignature::UIntType,
             Regtest => TypeSignature::BoolType,
             TxSponsor | Mainnet | ChainId => {
-                unreachable!("tx-sponsor, mainnet, and chain-id should not reach here in 2.05")
+                return Err(CheckErrors::Expects(
+                    "tx-sponsor, mainnet, and chain-id should not reach here in 2.05".into(),
+                )
+                .into())
             }
         };
-        Some(var_type)
+        Ok(Some(var_type))
     } else {
-        None
+        Ok(None)
     }
 }
 
@@ -399,7 +407,8 @@ impl<'a, 'b> TypeChecker<'a, 'b> {
                     Ok(())
                 }
                 Err(e) => Err(e),
-            })?;
+            })?
+            .ok_or_else(|| CheckErrors::Expects("Expected a depth result".into()))?;
         }
 
         runtime_cost(ClarityCostFunction::AnalysisStorage, self, size)?;
@@ -437,7 +446,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> {
             ) => {
                 let contract_to_check = self
                     .db
-                    .load_contract(&contract_identifier, &StacksEpochId::Epoch2_05)
+                    .load_contract(&contract_identifier, &StacksEpochId::Epoch2_05)?
                     .ok_or(CheckErrors::NoSuchContract(contract_identifier.to_string()))?;
 
                 let contract_defining_trait = self
@@ -445,7 +454,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> {
                     .load_contract(
                         &trait_identifier.contract_identifier,
                         &StacksEpochId::Epoch2_05,
-                    )
+                    )?
                     .ok_or(CheckErrors::NoSuchContract(
                         trait_identifier.contract_identifier.to_string(),
                     ))?;
@@ -559,7 +568,10 @@ impl<'a, 'b> TypeChecker<'a, 'b> {
             .map_err(|_| CheckErrors::BadSyntaxBinding)?;
 
         if self.function_return_tracker.is_some() {
-            panic!("Interpreter error: Previous function define left dirty typecheck state.");
+            return Err(CheckErrors::Expects(
+                "Interpreter error: Previous function define left dirty typecheck state.".into(),
+            )
+            .into());
         }
 
         let mut function_context = context.extend()?;
@@ -652,7 +664,10 @@ impl<'a, 'b> TypeChecker<'a, 'b> {
         if let Some(ref native_function) =
             NativeFunctions::lookup_by_name_at_version(function, &ClarityVersion::Clarity1)
         {
-            let typed_function = TypedNativeFunction::type_native_function(native_function);
+            let typed_function = match TypedNativeFunction::type_native_function(native_function) {
+                Ok(f) => f,
+                Err(e) => return Some(Err(e.into())),
+            };
             Some(typed_function.type_check_application(self, args, context))
         } else {
             None
@@ -693,7 +708,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> {
     fn lookup_variable(&mut self, name: &str, context: &TypingContext) -> TypeResult {
         runtime_cost(ClarityCostFunction::AnalysisLookupVariableConst, self, 0)?;
 
-        if let Some(type_result) = type_reserved_variable(name) {
+        if let Some(type_result) = type_reserved_variable(name)? {
             Ok(type_result)
         } else if let Some(type_result) = self.contract_context.get_variable_type(name) {
             Ok(type_result.clone())
@@ -720,7 +735,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> {
         context: &TypingContext,
     ) -> TypeResult {
         let type_sig = match expr.expr {
-            AtomValue(ref value) | LiteralValue(ref value) => TypeSignature::type_of(value),
+            AtomValue(ref value) | LiteralValue(ref value) => TypeSignature::type_of(value)?,
             Atom(ref name) => self.lookup_variable(name, context)?,
             List(ref expression) => self.type_check_function_application(expression, context)?,
             TraitReference(_, _) | Field(_) => {
diff --git a/clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs b/clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs
index 0ac1cc541d..ac0a8759d9 100644
--- a/clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs
+++ b/clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs
@@ -20,7 +20,7 @@ use super::{
     check_argument_count, check_arguments_at_least, no_type, TypeChecker, TypeResult, TypingContext,
 };
 use crate::vm::analysis::errors::{CheckError, CheckErrors, CheckResult};
-use crate::vm::errors::{Error as InterpError, RuntimeErrorType};
+use crate::vm::errors::{Error as InterpError, InterpreterError, RuntimeErrorType};
 use crate::vm::functions::{handle_binding_list, NativeFunctions};
 use crate::vm::types::{
     BlockInfoProperty, FixedFunction, FunctionArg, FunctionSignature, FunctionType, PrincipalData,
@@ -479,7 +479,10 @@ fn check_principal_of(
 ) -> TypeResult {
     check_argument_count(1, args)?;
     checker.type_check_expects(&args[0], context, &BUFF_33)?;
-    Ok(TypeSignature::new_response(TypeSignature::PrincipalType, TypeSignature::UIntType).unwrap())
+    Ok(
+        TypeSignature::new_response(TypeSignature::PrincipalType, TypeSignature::UIntType)
+            .map_err(|_| CheckErrors::Expects("Bad constructor".into()))?,
+    )
 }
 
 fn check_secp256k1_recover(
@@ -490,7 +493,10 @@ fn check_secp256k1_recover(
     check_argument_count(2, args)?;
     checker.type_check_expects(&args[0], context, &BUFF_32)?;
     checker.type_check_expects(&args[1], context, &BUFF_65)?;
-    Ok(TypeSignature::new_response(BUFF_33.clone(), TypeSignature::UIntType).unwrap())
+    Ok(
+        TypeSignature::new_response(BUFF_33.clone(), TypeSignature::UIntType)
+            .map_err(|_| CheckErrors::Expects("Bad constructor".into()))?,
+    )
 }
 
 fn check_secp256k1_verify(
@@ -545,10 +551,12 @@ impl TypedNativeFunction {
         }
     }
 
-    pub fn type_native_function(function: &NativeFunctions) -> TypedNativeFunction {
+    pub fn type_native_function(
+        function: &NativeFunctions,
+    ) -> Result<TypedNativeFunction, CheckErrors> {
         use self::TypedNativeFunction::{Simple, Special};
         use crate::vm::functions::NativeFunctions::*;
-        match function {
+        let out = match function {
             Add | Subtract | Divide | Multiply => {
                 Simple(SimpleNativeFunction(FunctionType::ArithmeticVariadic))
             }
@@ -566,30 +574,39 @@ impl TypedNativeFunction {
             ToUInt => Simple(SimpleNativeFunction(FunctionType::Fixed(FixedFunction {
                 args: vec![FunctionArg::new(
                     TypeSignature::IntType,
-                    ClarityName::try_from("value".to_owned())
-                        .expect("FAIL: ClarityName failed to accept default arg name"),
+                    ClarityName::try_from("value".to_owned()).map_err(|_| {
+                        CheckErrors::Expects(
+                            "FAIL: ClarityName failed to accept default arg name".into(),
+                        )
+                    })?,
                 )],
                 returns: TypeSignature::UIntType,
             }))),
             ToInt => Simple(SimpleNativeFunction(FunctionType::Fixed(FixedFunction {
                 args: vec![FunctionArg::new(
                     TypeSignature::UIntType,
-                    ClarityName::try_from("value".to_owned())
-                        .expect("FAIL: ClarityName failed to accept default arg name"),
+                    ClarityName::try_from("value".to_owned()).map_err(|_| {
+                        CheckErrors::Expects(
+                            "FAIL: ClarityName failed to accept default arg name".into(),
+                        )
+                    })?,
                 )],
                 returns: TypeSignature::IntType,
             }))),
             Not => Simple(SimpleNativeFunction(FunctionType::Fixed(FixedFunction {
                 args: vec![FunctionArg::new(
                     TypeSignature::BoolType,
-                    ClarityName::try_from("value".to_owned())
-                        .expect("FAIL: ClarityName failed to accept default arg name"),
+                    ClarityName::try_from("value".to_owned()).map_err(|_| {
+                        CheckErrors::Expects(
+                            "FAIL: ClarityName failed to accept default arg name".into(),
+                        )
+                    })?,
                 )],
                 returns: TypeSignature::BoolType,
             }))),
             Hash160 => Simple(SimpleNativeFunction(FunctionType::UnionArgs(
                 vec![
-                    TypeSignature::max_buffer(),
+                    TypeSignature::max_buffer()?,
                     TypeSignature::UIntType,
                     TypeSignature::IntType,
                 ],
@@ -597,7 +614,7 @@ impl TypedNativeFunction {
             ))),
             Sha256 => Simple(SimpleNativeFunction(FunctionType::UnionArgs(
                 vec![
-                    TypeSignature::max_buffer(),
+                    TypeSignature::max_buffer()?,
                     TypeSignature::UIntType,
                     TypeSignature::IntType,
                 ],
@@ -605,7 +622,7 @@ impl TypedNativeFunction {
             ))),
             Sha512Trunc256 => Simple(SimpleNativeFunction(FunctionType::UnionArgs(
                 vec![
-                    TypeSignature::max_buffer(),
+                    TypeSignature::max_buffer()?,
                     TypeSignature::UIntType,
                     TypeSignature::IntType,
                 ],
@@ -613,7 +630,7 @@ impl TypedNativeFunction {
             ))),
             Sha512 => Simple(SimpleNativeFunction(FunctionType::UnionArgs(
                 vec![
-                    TypeSignature::max_buffer(),
+                    TypeSignature::max_buffer()?,
                     TypeSignature::UIntType,
                     TypeSignature::IntType,
                 ],
@@ -621,7 +638,7 @@ impl TypedNativeFunction {
             ))),
             Keccak256 => Simple(SimpleNativeFunction(FunctionType::UnionArgs(
                 vec![
-                    TypeSignature::max_buffer(),
+                    TypeSignature::max_buffer()?,
                     TypeSignature::UIntType,
                     TypeSignature::IntType,
                 ],
@@ -632,8 +649,11 @@ impl TypedNativeFunction {
             GetStxBalance => Simple(SimpleNativeFunction(FunctionType::Fixed(FixedFunction {
                 args: vec![FunctionArg::new(
                     TypeSignature::PrincipalType,
-                    ClarityName::try_from("owner".to_owned())
-                        .expect("FAIL: ClarityName failed to accept default arg name"),
+                    ClarityName::try_from("owner".to_owned()).map_err(|_| {
+                        CheckErrors::Expects(
+                            "FAIL: ClarityName failed to accept default arg name".into(),
+                        )
+                    })?,
                 )],
                 returns: TypeSignature::UIntType,
             }))),
@@ -641,44 +661,59 @@ impl TypedNativeFunction {
                 args: vec![
                     FunctionArg::new(
                         TypeSignature::UIntType,
-                        ClarityName::try_from("amount".to_owned())
-                            .expect("FAIL: ClarityName failed to accept default arg name"),
+                        ClarityName::try_from("amount".to_owned()).map_err(|_| {
+                            CheckErrors::Expects(
+                                "FAIL: ClarityName failed to accept default arg name".into(),
+                            )
+                        })?,
                     ),
                     FunctionArg::new(
                         TypeSignature::PrincipalType,
-                        ClarityName::try_from("sender".to_owned())
-                            .expect("FAIL: ClarityName failed to accept default arg name"),
+                        ClarityName::try_from("sender".to_owned()).map_err(|_| {
+                            CheckErrors::Expects(
+                                "FAIL: ClarityName failed to accept default arg name".into(),
+                            )
+                        })?,
                     ),
                     FunctionArg::new(
                         TypeSignature::PrincipalType,
-                        ClarityName::try_from("recipient".to_owned())
-                            .expect("FAIL: ClarityName failed to accept default arg name"),
+                        ClarityName::try_from("recipient".to_owned()).map_err(|_| {
+                            CheckErrors::Expects(
+                                "FAIL: ClarityName failed to accept default arg name".into(),
+                            )
+                        })?,
                     ),
                 ],
                 returns: TypeSignature::new_response(
                     TypeSignature::BoolType,
                     TypeSignature::UIntType,
                 )
-                .unwrap(),
+                .map_err(|_| CheckErrors::Expects("Bad constructor".into()))?,
             }))),
             StxBurn => Simple(SimpleNativeFunction(FunctionType::Fixed(FixedFunction {
                 args: vec![
                     FunctionArg::new(
                         TypeSignature::UIntType,
-                        ClarityName::try_from("amount".to_owned())
-                            .expect("FAIL: ClarityName failed to accept default arg name"),
+                        ClarityName::try_from("amount".to_owned()).map_err(|_| {
+                            CheckErrors::Expects(
+                                "FAIL: ClarityName failed to accept default arg name".into(),
+                            )
+                        })?,
                     ),
                     FunctionArg::new(
                         TypeSignature::PrincipalType,
-                        ClarityName::try_from("sender".to_owned())
-                            .expect("FAIL: ClarityName failed to accept default arg name"),
+                        ClarityName::try_from("sender".to_owned()).map_err(|_| {
+                            CheckErrors::Expects(
+                                "FAIL: ClarityName failed to accept default arg name".into(),
+                            )
+                        })?,
                     ),
                 ],
                 returns: TypeSignature::new_response(
                     TypeSignature::BoolType,
                     TypeSignature::UIntType,
                 )
-                .unwrap(),
+                .map_err(|_| CheckErrors::Expects("Bad constructor".into()))?,
             }))),
             GetTokenBalance => Special(SpecialNativeFunction(&assets::check_special_get_balance)),
             GetAssetOwner => Special(SpecialNativeFunction(&assets::check_special_get_owner)),
@@ -743,7 +778,14 @@ impl TypedNativeFunction {
             | StringToUInt | IntToAscii | IntToUtf8 | GetBurnBlockInfo | StxTransferMemo
             | StxGetAccount | BitwiseAnd | BitwiseOr | BitwiseNot | BitwiseLShift
             | BitwiseRShift | BitwiseXor2 | Slice | ToConsensusBuff | FromConsensusBuff
-            | ReplaceAt => unreachable!("Clarity 2 keywords should not show up in 2.05"),
-        }
+            | ReplaceAt => {
+                return Err(CheckErrors::Expects(
+                    "Clarity 2 keywords should not show up in 2.05".into(),
+                )
+                .into())
+            }
+        };
+
+        Ok(out)
     }
 }
diff --git a/clarity/src/vm/analysis/type_checker/v2_05/natives/sequences.rs b/clarity/src/vm/analysis/type_checker/v2_05/natives/sequences.rs
index 605b5e3ef7..eed1eacbab 100644
--- a/clarity/src/vm/analysis/type_checker/v2_05/natives/sequences.rs
+++ b/clarity/src/vm/analysis/type_checker/v2_05/natives/sequences.rs
@@ -44,7 +44,7 @@ fn get_simple_native_or_user_define(
         NativeFunctions::lookup_by_name_at_version(function_name, &ClarityVersion::Clarity1)
     {
         if let TypedNativeFunction::Simple(SimpleNativeFunction(function_type)) =
-            TypedNativeFunction::type_native_function(native_function)
+            TypedNativeFunction::type_native_function(native_function)?
         {
             Ok(function_type)
         } else {
@@ -84,12 +84,12 @@ pub fn check_special_map(
             TypeSignature::SequenceType(sequence) => {
                 let (entry_type, len) = match sequence {
                     ListType(list_data) => list_data.destruct(),
-                    BufferType(buffer_data) => (TypeSignature::min_buffer(), buffer_data.into()),
+                    BufferType(buffer_data) => (TypeSignature::min_buffer()?, buffer_data.into()),
                     StringType(ASCII(ascii_data)) => {
-                        (TypeSignature::min_string_ascii(), ascii_data.into())
+                        (TypeSignature::min_string_ascii()?, ascii_data.into())
                     }
                     StringType(UTF8(utf8_data)) => {
-                        (TypeSignature::min_string_utf8(), utf8_data.into())
+                        (TypeSignature::min_string_utf8()?, utf8_data.into())
                     }
                 };
                 min_args = min_args.min(len);
@@ -132,7 +132,7 @@ pub fn check_special_filter(
 
     {
         let input_type = match argument_type {
-            TypeSignature::SequenceType(ref sequence_type) => Ok(sequence_type.unit_type()),
+            TypeSignature::SequenceType(ref sequence_type) => Ok(sequence_type.unit_type()?),
             _ => Err(CheckErrors::ExpectedSequence(argument_type.clone())),
         }?;
 
@@ -169,7 +169,7 @@ pub fn check_special_fold(
     let argument_type = checker.type_check(&args[1], context)?;
 
     let input_type = match argument_type {
-        TypeSignature::SequenceType(sequence_type) => Ok(sequence_type.unit_type()),
+        TypeSignature::SequenceType(sequence_type) => Ok(sequence_type.unit_type()?),
         _ => Err(CheckErrors::ExpectedSequence(argument_type)),
     }?;
 
@@ -385,12 +385,14 @@ pub fn check_special_element_at(
         }
         TypeSignature::SequenceType(StringType(ASCII(_))) => Ok(TypeSignature::OptionalType(
             Box::new(TypeSignature::SequenceType(StringType(ASCII(
-                BufferLength::try_from(1u32).unwrap(),
+                BufferLength::try_from(1u32)
+                    .map_err(|_| CheckErrors::Expects("Bad constructor".into()))?,
             )))),
         )),
         TypeSignature::SequenceType(StringType(UTF8(_))) => Ok(TypeSignature::OptionalType(
             Box::new(TypeSignature::SequenceType(StringType(UTF8(
-                StringUTF8Length::try_from(1u32).unwrap(),
+                StringUTF8Length::try_from(1u32)
+                    .map_err(|_| CheckErrors::Expects("Bad constructor".into()))?,
             )))),
         )),
         _ => Err(CheckErrors::ExpectedSequence(collection_type).into()),
@@ -408,7 +410,7 @@ pub fn check_special_index_of(
     let list_type = checker.type_check(&args[0], context)?;
 
     let expected_input_type = match list_type {
-        TypeSignature::SequenceType(ref sequence_type) => Ok(sequence_type.unit_type()),
+        TypeSignature::SequenceType(ref sequence_type) => Ok(sequence_type.unit_type()?),
         _ => Err(CheckErrors::ExpectedSequence(list_type)),
     }?;
 
diff --git a/clarity/src/vm/analysis/type_checker/v2_05/tests/contracts.rs b/clarity/src/vm/analysis/type_checker/v2_05/tests/contracts.rs
index 2274bbcad5..c43e8460a5 100644
--- a/clarity/src/vm/analysis/type_checker/v2_05/tests/contracts.rs
+++ b/clarity/src/vm/analysis/type_checker/v2_05/tests/contracts.rs
@@ -166,7 +166,10 @@ fn test_names_tokens_contracts_interface() {
     )
     .unwrap()
     .1;
-    let test_contract_json_str = build_contract_interface(&contract_analysis).serialize();
+    let test_contract_json_str = build_contract_interface(&contract_analysis)
+        .unwrap()
+        .serialize()
+        .unwrap();
     let test_contract_json: serde_json::Value =
         serde_json::from_str(&test_contract_json_str).unwrap();
 
diff --git a/clarity/src/vm/analysis/type_checker/v2_05/tests/mod.rs b/clarity/src/vm/analysis/type_checker/v2_05/tests/mod.rs
index 2023b2f700..f976ae8ac0 100644
--- a/clarity/src/vm/analysis/type_checker/v2_05/tests/mod.rs
+++ b/clarity/src/vm/analysis/type_checker/v2_05/tests/mod.rs
@@ -717,16 +717,16 @@ fn test_index_of() {
         CheckErrors::ExpectedSequence(TypeSignature::IntType),
         CheckErrors::TypeError(TypeSignature::IntType, TypeSignature::UIntType),
         CheckErrors::TypeError(
-            TypeSignature::min_buffer(),
-            TypeSignature::min_string_ascii(),
+            TypeSignature::min_buffer().unwrap(),
+            TypeSignature::min_string_ascii().unwrap(),
         ),
         CheckErrors::TypeError(
-            TypeSignature::min_string_utf8(),
-            TypeSignature::min_string_ascii(),
+            TypeSignature::min_string_utf8().unwrap(),
+            TypeSignature::min_string_ascii().unwrap(),
         ),
         CheckErrors::TypeError(
-            TypeSignature::min_string_ascii(),
-            TypeSignature::min_string_utf8(),
+            TypeSignature::min_string_ascii().unwrap(),
+            TypeSignature::min_string_utf8().unwrap(),
         ),
         CheckErrors::CouldNotDetermineType,
         CheckErrors::CouldNotDetermineType,
diff --git a/clarity/src/vm/analysis/type_checker/v2_1/mod.rs b/clarity/src/vm/analysis/type_checker/v2_1/mod.rs
index c9bcd88eab..4f7e3d0caa 100644
--- a/clarity/src/vm/analysis/type_checker/v2_1/mod.rs
+++ b/clarity/src/vm/analysis/type_checker/v2_1/mod.rs
@@ -101,7 +101,7 @@ impl CostTracker for TypeChecker<'_, '_> {
     fn add_memory(&mut self, memory: u64) -> std::result::Result<(), CostErrors> {
         self.cost_track.add_memory(memory)
     }
-    fn drop_memory(&mut self, memory: u64) {
+    fn drop_memory(&mut self, memory: u64) -> std::result::Result<(), CostErrors> {
         self.cost_track.drop_memory(memory)
     }
     fn reset_memory(&mut self) {
@@ -273,9 +273,9 @@ impl FunctionType {
                         vec![
                             TypeSignature::IntType,
                             TypeSignature::UIntType,
-                            TypeSignature::max_string_ascii(),
-                            TypeSignature::max_string_utf8(),
-                            TypeSignature::max_buffer(),
+                            TypeSignature::max_string_ascii()?,
+                            TypeSignature::max_string_utf8()?,
+                            TypeSignature::max_buffer()?,
                         ],
                         first.clone(),
                     )
@@ -340,7 +340,7 @@ impl FunctionType {
                         contract_identifier.clone(),
                     ))
                 }
-                _ => TypeSignature::type_of(value),
+                _ => TypeSignature::type_of(value)?,
             })
         }
     }
@@ -401,7 +401,7 @@ impl FunctionType {
                 }
                 TypeSignature::TupleType(TupleTypeSignature::try_from(type_map)?)
             }
-            _ => TypeSignature::type_of(value),
+            _ => TypeSignature::type_of(value)?,
         })
     }
 
@@ -417,7 +417,7 @@ impl FunctionType {
     ) -> CheckResult<TypeSignature> {
         let (expected_args, returns) = match self {
             FunctionType::Fixed(FixedFunction { args, returns }) => (args, returns),
-            _ => panic!("Unexpected function type"),
+            _ => return Err(CheckErrors::Expects("Unexpected function type".into()).into()),
         };
         check_argument_count(expected_args.len(), func_args)?;
 
@@ -429,7 +429,7 @@ impl FunctionType {
                         Value::Principal(PrincipalData::Contract(contract)),
                     ) => {
                         let contract_to_check = db
-                            .load_contract(contract, &StacksEpochId::Epoch21)
+                            .load_contract(contract, &StacksEpochId::Epoch21)?
                             .ok_or_else(|| {
                                 CheckErrors::NoSuchContract(contract.name.to_string())
                             })?;
@@ -439,7 +439,7 @@ impl FunctionType {
                                 &trait_id.name,
                                 &StacksEpochId::Epoch21,
                             )
-                            .unwrap()
+                            .map_err(|_| CheckErrors::Expects("Failed to get trait".into()))?
                             .ok_or(CheckErrors::NoSuchContract(
                                 trait_id.contract_identifier.to_string(),
                             ))?;
@@ -451,7 +451,7 @@ impl FunctionType {
                     }
                     (expected_type, value) => {
                         if !expected_type.admits(&StacksEpochId::Epoch21, &value)? {
-                            let actual_type = TypeSignature::type_of(&value);
+                            let actual_type = TypeSignature::type_of(&value)?;
                             return Err(
                                 CheckErrors::TypeError(expected_type.clone(), actual_type).into()
                             );
@@ -728,7 +728,7 @@ fn clarity2_inner_type_check_type<T: CostTracker>(
             TypeSignature::CallableType(CallableSubtype::Trait(expected_trait_id)),
         ) => {
             let contract_to_check = match db
-                .load_contract(&contract_identifier, &StacksEpochId::Epoch21)
+                .load_contract(&contract_identifier, &StacksEpochId::Epoch21)?
             {
                 Some(contract) => {
                     runtime_cost(
@@ -844,16 +844,21 @@ fn contract_analysis_size(contract: &ContractAnalysis) -> CheckResult<u64> {
     Ok(total_size)
 }
 
-fn type_reserved_variable(variable_name: &str, version: &ClarityVersion) -> Option<TypeSignature> {
+fn type_reserved_variable(
+    variable_name: &str,
+    version: &ClarityVersion,
+) -> CheckResult<Option<TypeSignature>> {
     if let Some(variable) = NativeVariables::lookup_by_name_at_version(variable_name, version) {
         use crate::vm::variables::NativeVariables::*;
         let var_type = match variable {
             TxSender => TypeSignature::PrincipalType,
-            TxSponsor => TypeSignature::new_option(TypeSignature::PrincipalType).unwrap(),
+            TxSponsor => TypeSignature::new_option(TypeSignature::PrincipalType)
+                .map_err(|_| CheckErrors::Expects("Bad construction".into()))?,
             ContractCaller => TypeSignature::PrincipalType,
             BlockHeight => TypeSignature::UIntType,
             BurnBlockHeight => TypeSignature::UIntType,
-            NativeNone => TypeSignature::new_option(no_type()).unwrap(),
+            NativeNone => TypeSignature::new_option(no_type())
+                .map_err(|_| CheckErrors::Expects("Bad construction".into()))?,
             NativeTrue => TypeSignature::BoolType,
             NativeFalse => TypeSignature::BoolType,
             TotalLiquidMicroSTX => TypeSignature::UIntType,
@@ -861,9 +866,9 @@ fn type_reserved_variable(variable_name: &str, version: &ClarityVersion) -> Opti
             Mainnet => TypeSignature::BoolType,
             ChainId => TypeSignature::UIntType,
         };
-        Some(var_type)
+        Ok(Some(var_type))
     } else {
-        None
+        Ok(None)
     }
 }
 
@@ -942,7 +947,8 @@ impl<'a, 'b> TypeChecker<'a, 'b> {
                     Ok(())
                 }
                 Err(e) => Err(e),
-            })?;
+            })?
+            .ok_or_else(|| CheckErrors::Expects("Expected a depth result".into()))?;
         }
 
         runtime_cost(ClarityCostFunction::AnalysisStorage, self, size)?;
@@ -1068,7 +1074,10 @@ impl<'a, 'b> TypeChecker<'a, 'b> {
             .map_err(|_| CheckErrors::BadSyntaxBinding)?;
 
         if self.function_return_tracker.is_some() {
-            panic!("Interpreter error: Previous function define left dirty typecheck state.");
+            return Err(CheckErrors::Expects(
+                "Interpreter error: Previous function define left dirty typecheck state.".into(),
+            )
+            .into());
         }
 
         let mut function_context = context.extend()?;
@@ -1162,7 +1171,10 @@ impl<'a, 'b> TypeChecker<'a, 'b> {
         if let Some(ref native_function) =
             NativeFunctions::lookup_by_name_at_version(function, &self.clarity_version)
         {
-            let typed_function = TypedNativeFunction::type_native_function(native_function);
+            let typed_function = match TypedNativeFunction::type_native_function(native_function) {
+                Ok(f) => f,
+                Err(e) => return Some(Err(e.into())),
+            };
             Some(typed_function.type_check_application(self, args, context))
         } else {
             None
@@ -1203,7 +1215,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> {
     fn lookup_variable(&mut self, name: &str, context: &TypingContext) -> TypeResult {
         runtime_cost(ClarityCostFunction::AnalysisLookupVariableConst, self, 0)?;
 
-        if let Some(type_result) = type_reserved_variable(name, &self.clarity_version) {
+        if let Some(type_result) = type_reserved_variable(name, &self.clarity_version)? {
             Ok(type_result)
         } else if let Some(type_result) = self.contract_context.get_variable_type(name) {
             Ok(type_result.clone())
@@ -1239,7 +1251,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> {
             ) => {
                 let contract_to_check = self
                     .db
-                    .load_contract(&contract_identifier, &StacksEpochId::Epoch21)
+                    .load_contract(&contract_identifier, &StacksEpochId::Epoch21)?
                     .ok_or(CheckErrors::NoSuchContract(contract_identifier.to_string()))?;
 
                 let contract_defining_trait = self
@@ -1247,7 +1259,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> {
                     .load_contract(
                         &trait_identifier.contract_identifier,
                         &StacksEpochId::Epoch21,
-                    )
+                    )?
                     .ok_or(CheckErrors::NoSuchContract(
                         trait_identifier.contract_identifier.to_string(),
                     ))?;
@@ -1289,8 +1301,8 @@ impl<'a, 'b> TypeChecker<'a, 'b> {
         expected_type: &TypeSignature,
     ) -> TypeResult {
         let mut expr_type = match expr.expr {
-            AtomValue(ref value) => TypeSignature::type_of(value),
-            LiteralValue(ref value) => TypeSignature::literal_type_of(value),
+            AtomValue(ref value) => TypeSignature::type_of(value)?,
+            LiteralValue(ref value) => TypeSignature::literal_type_of(value)?,
             Atom(ref name) => self.lookup_variable(name, context)?,
             List(ref expression) => self.type_check_function_application(expression, context)?,
             TraitReference(_, _) | Field(_) => {
@@ -1327,8 +1339,8 @@ impl<'a, 'b> TypeChecker<'a, 'b> {
         context: &TypingContext,
     ) -> TypeResult {
         let expr_type = match expr.expr {
-            AtomValue(ref value) => TypeSignature::type_of(value),
-            LiteralValue(ref value) => TypeSignature::literal_type_of(value),
+            AtomValue(ref value) => TypeSignature::type_of(value)?,
+            LiteralValue(ref value) => TypeSignature::literal_type_of(value)?,
             Atom(ref name) => self.lookup_variable(name, context)?,
             List(ref expression) => self.type_check_function_application(expression, context)?,
             TraitReference(_, _) | Field(_) => {
diff --git a/clarity/src/vm/analysis/type_checker/v2_1/natives/assets.rs b/clarity/src/vm/analysis/type_checker/v2_1/natives/assets.rs
index 3537dfe01c..ffea65650a 100644
--- a/clarity/src/vm/analysis/type_checker/v2_1/natives/assets.rs
+++ b/clarity/src/vm/analysis/type_checker/v2_1/natives/assets.rs
@@ -225,7 +225,8 @@ pub fn check_special_stx_transfer_memo(
     let from_type: TypeSignature = TypeSignature::PrincipalType;
     let to_type: TypeSignature = TypeSignature::PrincipalType;
     let memo_type: TypeSignature = TypeSignature::SequenceType(SequenceSubtype::BufferType(
-        BufferLength::try_from(TOKEN_TRANSFER_MEMO_LENGTH as u32).unwrap(),
+        BufferLength::try_from(TOKEN_TRANSFER_MEMO_LENGTH as u32)
+            .map_err(|_| CheckErrors::Expects("Bad constructor".into()))?,
     ));
 
     runtime_cost(ClarityCostFunction::AnalysisTypeLookup, checker, 0)?;
diff --git a/clarity/src/vm/analysis/type_checker/v2_1/natives/conversions.rs b/clarity/src/vm/analysis/type_checker/v2_1/natives/conversions.rs
index c0dbd8307e..9876062241 100644
--- a/clarity/src/vm/analysis/type_checker/v2_1/natives/conversions.rs
+++ b/clarity/src/vm/analysis/type_checker/v2_1/natives/conversions.rs
@@ -36,6 +36,6 @@ pub fn check_special_from_consensus_buff(
 ) -> TypeResult {
     check_argument_count(2, args)?;
     let result_type = TypeSignature::parse_type_repr(StacksEpochId::Epoch21, &args[0], checker)?;
-    checker.type_check_expects(&args[1], context, &TypeSignature::max_buffer())?;
+    checker.type_check_expects(&args[1], context, &TypeSignature::max_buffer()?)?;
     TypeSignature::new_option(result_type).map_err(CheckError::from)
 }
diff --git a/clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs b/clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs
index b58795b8d2..47ad7469aa 100644
--- a/clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs
+++ b/clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs
@@ -567,7 +567,10 @@ fn check_principal_of(
 ) -> TypeResult {
     check_argument_count(1, args)?;
     checker.type_check_expects(&args[0], context, &BUFF_33)?;
-    Ok(TypeSignature::new_response(TypeSignature::PrincipalType, TypeSignature::UIntType).unwrap())
+    Ok(
+        TypeSignature::new_response(TypeSignature::PrincipalType, TypeSignature::UIntType)
+            .map_err(|_| CheckErrors::Expects("Bad constructor".into()))?,
+    )
 }
 
 /// Forms:
@@ -589,7 +592,7 @@ fn check_principal_construct(
         checker.type_check_expects(
             &args[2],
             context,
-            &TypeSignature::contract_name_string_ascii_type(),
+            &TypeSignature::contract_name_string_ascii_type()?,
         )?;
     }
     Ok(TypeSignature::new_response(
@@ -598,13 +601,13 @@ fn check_principal_construct(
                 ("error_code".into(), TypeSignature::UIntType),
                 (
                     "value".into(),
-                    TypeSignature::new_option(TypeSignature::PrincipalType).expect("FATAL: failed to create (optional principal) type signature"),
+                    TypeSignature::new_option(TypeSignature::PrincipalType).map_err(|_| CheckErrors::Expects("FATAL: failed to create (optional principal) type signature".into()))?,
                 ),
             ])
-            .expect("FAIL: PrincipalConstruct failed to initialize type signature")
+            .map_err(|_| CheckErrors::Expects("FAIL: PrincipalConstruct failed to initialize type signature".into()))?
             .into()
         )
-        .expect("FATAL: failed to create `(response principal { error_code: uint, principal: (optional principal) })` type signature")
+        .map_err(|_| CheckErrors::Expects("FATAL: failed to create `(response principal { error_code: uint, principal: (optional principal) })` type signature".into()))?
     )
 }
 
@@ -616,7 +619,10 @@ fn check_secp256k1_recover(
     check_argument_count(2, args)?;
     checker.type_check_expects(&args[0], context, &BUFF_32)?;
     checker.type_check_expects(&args[1], context, &BUFF_65)?;
-    Ok(TypeSignature::new_response(BUFF_33.clone(), TypeSignature::UIntType).unwrap())
+    Ok(
+        TypeSignature::new_response(BUFF_33.clone(), TypeSignature::UIntType)
+            .map_err(|_| CheckErrors::Expects("Bad constructor".into()))?,
+    )
 }
 
 fn check_secp256k1_verify(
@@ -674,7 +680,11 @@ fn check_get_burn_block_info(
 
     checker.type_check_expects(&args[1], &context, &TypeSignature::UIntType)?;
 
-    Ok(TypeSignature::new_option(block_info_prop.type_result())?)
+    Ok(TypeSignature::new_option(
+        block_info_prop
+            .type_result()
+            .map_err(|_| CheckErrors::Expects("FAILED to type valid burn info property".into()))?,
+    )?)
 }
 
 impl TypedNativeFunction {
@@ -697,10 +707,12 @@ impl TypedNativeFunction {
         }
     }
 
-    pub fn type_native_function(function: &NativeFunctions) -> TypedNativeFunction {
+    pub fn type_native_function(
+        function: &NativeFunctions,
+    ) -> Result<TypedNativeFunction, CheckErrors> {
         use self::TypedNativeFunction::{Simple, Special};
         use crate::vm::functions::NativeFunctions::*;
-        match function {
+        let out = match function {
             Add | Subtract | Divide | Multiply | BitwiseOr | BitwiseAnd | BitwiseXor2 => {
                 Simple(SimpleNativeFunction(FunctionType::ArithmeticVariadic))
             }
@@ -725,24 +737,33 @@ impl TypedNativeFunction {
             ToUInt => Simple(SimpleNativeFunction(FunctionType::Fixed(FixedFunction {
                 args: vec![FunctionArg::new(
                     TypeSignature::IntType,
-                    ClarityName::try_from("value".to_owned())
-                        .expect("FAIL: ClarityName failed to accept default arg name"),
+                    ClarityName::try_from("value".to_owned()).map_err(|_| {
+                        CheckErrors::Expects(
+                            "FAIL: ClarityName failed to accept default arg name".into(),
+                        )
+                    })?,
                 )],
                 returns: TypeSignature::UIntType,
             }))),
             ToInt => Simple(SimpleNativeFunction(FunctionType::Fixed(FixedFunction {
                 args: vec![FunctionArg::new(
                     TypeSignature::UIntType,
-                    ClarityName::try_from("value".to_owned())
-                        .expect("FAIL: ClarityName failed to accept default arg name"),
+                    ClarityName::try_from("value".to_owned()).map_err(|_| {
+                        CheckErrors::Expects(
+                            "FAIL: ClarityName failed to accept default arg name".into(),
+                        )
+                    })?,
                 )],
                 returns: TypeSignature::IntType,
             }))),
             IsStandard => Simple(SimpleNativeFunction(FunctionType::Fixed(FixedFunction {
                 args: vec![FunctionArg::new(
                     TypeSignature::PrincipalType,
-                    ClarityName::try_from("value".to_owned())
-                        .expect("FAIL: ClarityName failed to accept default arg name"),
+                    ClarityName::try_from("value".to_owned()).map_err(|_| {
+                        CheckErrors::Expects(
+                            "FAIL: ClarityName failed to accept default arg name".into(),
+                        )
+                    })?,
                 )],
                 returns: TypeSignature::BoolType,
             }))),
@@ -750,10 +771,14 @@ impl TypedNativeFunction {
                 Simple(SimpleNativeFunction(FunctionType::Fixed(FixedFunction {
                     args: vec![FunctionArg::new(
                         TypeSignature::SequenceType(SequenceSubtype::BufferType(
-                            BufferLength::try_from(16_u32).unwrap(),
+                            BufferLength::try_from(16_u32)
+                                .map_err(|_| CheckErrors::Expects("Bad constructor".into()))?,
                         )),
-                        ClarityName::try_from("value".to_owned())
-                            .expect("FAIL: ClarityName failed to accept default arg name"),
+                        ClarityName::try_from("value".to_owned()).map_err(|_| {
+                            CheckErrors::Expects(
+                                "FAIL: ClarityName failed to accept default arg name".into(),
+                            )
+                        })?,
                     )],
                     returns: TypeSignature::IntType,
                 })))
@@ -762,25 +787,29 @@ impl TypedNativeFunction {
                 Simple(SimpleNativeFunction(FunctionType::Fixed(FixedFunction {
                     args: vec![FunctionArg::new(
                         TypeSignature::SequenceType(SequenceSubtype::BufferType(
-                            BufferLength::try_from(16_u32).unwrap(),
+                            BufferLength::try_from(16_u32)
+                                .map_err(|_| CheckErrors::Expects("Bad constructor".into()))?,
                         )),
-                        ClarityName::try_from("value".to_owned())
-                            .expect("FAIL: ClarityName failed to accept default arg name"),
+                        ClarityName::try_from("value".to_owned()).map_err(|_| {
+                            CheckErrors::Expects(
+                                "FAIL: ClarityName failed to accept default arg name".into(),
+                            )
+                        })?,
                     )],
                     returns: TypeSignature::UIntType,
                 })))
             }
             StringToInt => Simple(SimpleNativeFunction(FunctionType::UnionArgs(
                 vec![
-                    TypeSignature::max_string_ascii(),
-                    TypeSignature::max_string_utf8(),
+                    TypeSignature::max_string_ascii()?,
+                    TypeSignature::max_string_utf8()?,
                 ],
                 TypeSignature::OptionalType(Box::new(TypeSignature::IntType)),
             ))),
             StringToUInt => Simple(SimpleNativeFunction(FunctionType::UnionArgs(
                 vec![
-                    TypeSignature::max_string_ascii(),
-                    TypeSignature::max_string_utf8(),
+                    TypeSignature::max_string_ascii()?,
+                    TypeSignature::max_string_utf8()?,
                 ],
                 TypeSignature::OptionalType(Box::new(TypeSignature::UIntType)),
             ))),
@@ -797,14 +826,17 @@ impl TypedNativeFunction {
             Not => Simple(SimpleNativeFunction(FunctionType::Fixed(FixedFunction {
                 args: vec![FunctionArg::new(
                     TypeSignature::BoolType,
-                    ClarityName::try_from("value".to_owned())
-                        .expect("FAIL: ClarityName failed to accept default arg name"),
+                    ClarityName::try_from("value".to_owned()).map_err(|_| {
+                        CheckErrors::Expects(
+                            "FAIL: ClarityName failed to accept default arg name".into(),
+                        )
+                    })?,
                 )],
                 returns: TypeSignature::BoolType,
             }))),
             Hash160 => Simple(SimpleNativeFunction(FunctionType::UnionArgs(
                 vec![
-                    TypeSignature::max_buffer(),
+                    TypeSignature::max_buffer()?,
                     TypeSignature::UIntType,
                     TypeSignature::IntType,
                 ],
@@ -812,7 +844,7 @@ impl TypedNativeFunction {
             ))),
             Sha256 => Simple(SimpleNativeFunction(FunctionType::UnionArgs(
                 vec![
-                    TypeSignature::max_buffer(),
+                    TypeSignature::max_buffer()?,
                     TypeSignature::UIntType,
                     TypeSignature::IntType,
                 ],
@@ -820,7 +852,7 @@ impl TypedNativeFunction {
             ))),
             Sha512Trunc256 => Simple(SimpleNativeFunction(FunctionType::UnionArgs(
                 vec![
-                    TypeSignature::max_buffer(),
+                    TypeSignature::max_buffer()?,
                     TypeSignature::UIntType,
                     TypeSignature::IntType,
                 ],
@@ -828,7 +860,7 @@ impl TypedNativeFunction {
             ))),
             Sha512 => Simple(SimpleNativeFunction(FunctionType::UnionArgs(
                 vec![
-                    TypeSignature::max_buffer(),
+                    TypeSignature::max_buffer()?,
                     TypeSignature::UIntType,
                     TypeSignature::IntType,
                 ],
@@ -836,7 +868,7 @@ impl TypedNativeFunction {
             ))),
             Keccak256 => Simple(SimpleNativeFunction(FunctionType::UnionArgs(
                 vec![
-                    TypeSignature::max_buffer(),
+                    TypeSignature::max_buffer()?,
                     TypeSignature::UIntType,
                     TypeSignature::IntType,
                 ],
@@ -847,8 +879,11 @@ impl TypedNativeFunction {
             GetStxBalance => Simple(SimpleNativeFunction(FunctionType::Fixed(FixedFunction {
                 args: vec![FunctionArg::new(
                     TypeSignature::PrincipalType,
-                    ClarityName::try_from("owner".to_owned())
-                        .expect("FAIL: ClarityName failed to accept default arg name"),
+                    ClarityName::try_from("owner".to_owned()).map_err(|_| {
+                        CheckErrors::Expects(
+                            "FAIL: ClarityName failed to accept default arg name".into(),
+                        )
+                    })?,
                 )],
                 returns: TypeSignature::UIntType,
             }))),
@@ -856,65 +891,85 @@ impl TypedNativeFunction {
             PrincipalDestruct => Simple(SimpleNativeFunction(FunctionType::Fixed(FixedFunction {
                 args: vec![FunctionArg::new(
                     TypeSignature::PrincipalType,
-                    ClarityName::try_from("principal".to_owned())
-                        .expect("FAIL: ClarityName failed to accept default arg name"),
+                    ClarityName::try_from("principal".to_owned()).map_err(|_| {
+                        CheckErrors::Expects(
+                            "FAIL: ClarityName failed to accept default arg name".into(),
+                        )
+                    })?,
                 )],
                 returns: {
                     /// The return type of `principal-destruct` is a Response, in which the success
                     /// and error types are the same.
-                    fn parse_principal_basic_type() -> TypeSignature {
-                        TupleTypeSignature::try_from(vec![
+                    fn parse_principal_basic_type() -> Result<TupleTypeSignature, CheckErrors> {
+                        Ok(TupleTypeSignature::try_from(vec![
                             ("version".into(), BUFF_1.clone()),
                             ("hash-bytes".into(), BUFF_20.clone()),
                             (
                                 "name".into(),
                                 TypeSignature::new_option(
-                                    TypeSignature::contract_name_string_ascii_type(),
+                                    TypeSignature::contract_name_string_ascii_type()?,
                                 )
-                                .unwrap(),
+                                .map_err(|_| CheckErrors::Expects("Bad constructor".into()))?,
                             ),
                         ])
-                        .expect("FAIL: PrincipalDestruct failed to initialize type signature")
-                        .into()
+                        .map_err(|_| {
+                            CheckErrors::Expects(
+                                "FAIL: PrincipalDestruct failed to initialize type signature"
+                                    .into(),
+                            )
+                        })?)
                     }
                     TypeSignature::ResponseType(Box::new((
-                        parse_principal_basic_type(),
-                        parse_principal_basic_type(),
+                        parse_principal_basic_type()?.into(),
+                        parse_principal_basic_type()?.into(),
                     )))
                 },
             }))),
             StxGetAccount => Simple(SimpleNativeFunction(FunctionType::Fixed(FixedFunction {
                 args: vec![FunctionArg::new(
                     TypeSignature::PrincipalType,
-                    ClarityName::try_from("owner".to_owned())
-                        .expect("FAIL: ClarityName failed to accept default arg name"),
+                    ClarityName::try_from("owner".to_owned()).map_err(|_| {
+                        CheckErrors::Expects(
+                            "FAIL: ClarityName failed to accept default arg name".into(),
+                        )
+                    })?,
                 )],
                 returns: TupleTypeSignature::try_from(vec![
                     ("unlocked".into(), TypeSignature::UIntType),
                     ("locked".into(), TypeSignature::UIntType),
                     ("unlock-height".into(), TypeSignature::UIntType),
                 ])
-                .expect("FAIL: StxGetAccount failed to initialize type signature")
+                .map_err(|_| {
+                    CheckErrors::Expects(
+                        "FAIL: StxGetAccount failed to initialize type signature".into(),
+                    )
+                })?
                 .into(),
             }))),
             StxBurn => Simple(SimpleNativeFunction(FunctionType::Fixed(FixedFunction {
                 args: vec![
                     FunctionArg::new(
                         TypeSignature::UIntType,
-                        ClarityName::try_from("amount".to_owned())
-                            .expect("FAIL: ClarityName failed to accept default arg name"),
+                        ClarityName::try_from("amount".to_owned()).map_err(|_| {
+                            CheckErrors::Expects(
+                                "FAIL: ClarityName failed to accept default arg name".into(),
+                            )
+                        })?,
                     ),
                     FunctionArg::new(
                         TypeSignature::PrincipalType,
-                        ClarityName::try_from("sender".to_owned())
-                            .expect("FAIL: ClarityName failed to accept default arg name"),
+                        ClarityName::try_from("sender".to_owned()).map_err(|_| {
+                            CheckErrors::Expects(
+                                "FAIL: ClarityName failed to accept default arg name".into(),
+                            )
+                        })?,
                     ),
                 ],
                 returns: TypeSignature::new_response(
                     TypeSignature::BoolType,
                     TypeSignature::UIntType,
                 )
-                .unwrap(),
+                .map_err(|_| CheckErrors::Expects("Bad constructor".into()))?,
             }))),
             StxTransfer => Special(SpecialNativeFunction(&assets::check_special_stx_transfer)),
             StxTransferMemo => Special(SpecialNativeFunction(
@@ -991,6 +1046,8 @@ impl TypedNativeFunction {
             FromConsensusBuff => Special(SpecialNativeFunction(
                 &conversions::check_special_from_consensus_buff,
             )),
-        }
+        };
+
+        Ok(out)
     }
 }
diff --git a/clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs b/clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs
index 78b5f5eaef..0b32db4b5a 100644
--- a/clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs
+++ b/clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs
@@ -44,7 +44,7 @@ fn get_simple_native_or_user_define(
         NativeFunctions::lookup_by_name_at_version(function_name, &checker.clarity_version)
     {
         if let TypedNativeFunction::Simple(SimpleNativeFunction(function_type)) =
-            TypedNativeFunction::type_native_function(native_function)
+            TypedNativeFunction::type_native_function(native_function)?
         {
             Ok(function_type)
         } else {
@@ -84,12 +84,12 @@ pub fn check_special_map(
             TypeSignature::SequenceType(sequence) => {
                 let (entry_type, len) = match sequence {
                     ListType(list_data) => list_data.destruct(),
-                    BufferType(buffer_data) => (TypeSignature::min_buffer(), buffer_data.into()),
+                    BufferType(buffer_data) => (TypeSignature::min_buffer()?, buffer_data.into()),
                     StringType(ASCII(ascii_data)) => {
-                        (TypeSignature::min_string_ascii(), ascii_data.into())
+                        (TypeSignature::min_string_ascii()?, ascii_data.into())
                     }
                     StringType(UTF8(utf8_data)) => {
-                        (TypeSignature::min_string_utf8(), utf8_data.into())
+                        (TypeSignature::min_string_utf8()?, utf8_data.into())
                     }
                 };
                 min_args = min_args.min(len);
@@ -132,7 +132,7 @@ pub fn check_special_filter(
 
     {
         let input_type = match argument_type {
-            TypeSignature::SequenceType(ref sequence_type) => Ok(sequence_type.unit_type()),
+            TypeSignature::SequenceType(ref sequence_type) => Ok(sequence_type.unit_type()?),
             _ => Err(CheckErrors::ExpectedSequence(argument_type.clone())),
         }?;
 
@@ -169,7 +169,7 @@ pub fn check_special_fold(
     let argument_type = checker.type_check(&args[1], context)?;
 
     let input_type = match argument_type {
-        TypeSignature::SequenceType(sequence_type) => Ok(sequence_type.unit_type()),
+        TypeSignature::SequenceType(sequence_type) => Ok(sequence_type.unit_type()?),
         _ => Err(CheckErrors::ExpectedSequence(argument_type)),
     }?;
 
@@ -385,12 +385,14 @@ pub fn check_special_element_at(
         }
         TypeSignature::SequenceType(StringType(ASCII(_))) => Ok(TypeSignature::OptionalType(
             Box::new(TypeSignature::SequenceType(StringType(ASCII(
-                BufferLength::try_from(1u32).unwrap(),
+                BufferLength::try_from(1u32)
+                    .map_err(|_| CheckErrors::Expects("Bad constructor".into()))?,
             )))),
         )),
         TypeSignature::SequenceType(StringType(UTF8(_))) => Ok(TypeSignature::OptionalType(
             Box::new(TypeSignature::SequenceType(StringType(UTF8(
-                StringUTF8Length::try_from(1u32).unwrap(),
+                StringUTF8Length::try_from(1u32)
+                    .map_err(|_| CheckErrors::Expects("Bad constructor".into()))?,
             )))),
         )),
         _ => Err(CheckErrors::ExpectedSequence(collection_type).into()),
@@ -408,7 +410,7 @@ pub fn check_special_index_of(
     let list_type = checker.type_check(&args[0], context)?;
 
     let expected_input_type = match list_type {
-        TypeSignature::SequenceType(ref sequence_type) => Ok(sequence_type.unit_type()),
+        TypeSignature::SequenceType(ref sequence_type) => Ok(sequence_type.unit_type()?),
         _ => Err(CheckErrors::ExpectedSequence(list_type)),
     }?;
 
@@ -458,7 +460,7 @@ pub fn check_special_replace_at(
         TypeSignature::SequenceType(seq) => seq,
         _ => return Err(CheckErrors::ExpectedSequence(input_type).into()),
     };
-    let unit_seq = seq_type.unit_type();
+    let unit_seq = seq_type.unit_type()?;
     // Check index argument
     checker.type_check_expects(&args[1], context, &TypeSignature::UIntType)?;
     // Check element argument
diff --git a/clarity/src/vm/analysis/type_checker/v2_1/tests/contracts.rs b/clarity/src/vm/analysis/type_checker/v2_1/tests/contracts.rs
index c4578db59b..d737a134ec 100644
--- a/clarity/src/vm/analysis/type_checker/v2_1/tests/contracts.rs
+++ b/clarity/src/vm/analysis/type_checker/v2_1/tests/contracts.rs
@@ -215,7 +215,10 @@ fn test_names_tokens_contracts_interface() {
     ";
 
     let contract_analysis = mem_type_check(INTERFACE_TEST_CONTRACT).unwrap().1;
-    let test_contract_json_str = build_contract_interface(&contract_analysis).serialize();
+    let test_contract_json_str = build_contract_interface(&contract_analysis)
+        .unwrap()
+        .serialize()
+        .unwrap();
     let test_contract_json: serde_json::Value =
         serde_json::from_str(&test_contract_json_str).unwrap();
 
@@ -3500,6 +3503,13 @@ fn clarity_trait_experiments_double_trait_method2_v1_v2(
     };
 }
 
+#[cfg(test)]
+impl From<CheckErrors> for String {
+    fn from(o: CheckErrors) -> Self {
+        o.to_string()
+    }
+}
+
 #[apply(test_clarity_versions)]
 fn clarity_trait_experiments_cross_epochs(
     #[case] version: ClarityVersion,
diff --git a/clarity/src/vm/analysis/type_checker/v2_1/tests/mod.rs b/clarity/src/vm/analysis/type_checker/v2_1/tests/mod.rs
index e2c3af5cea..8cde67a5b4 100644
--- a/clarity/src/vm/analysis/type_checker/v2_1/tests/mod.rs
+++ b/clarity/src/vm/analysis/type_checker/v2_1/tests/mod.rs
@@ -106,7 +106,10 @@ fn test_from_consensus_buff() {
         ),
         (
             "(from-consensus-buff? int u6)",
-            CheckErrors::TypeError(TypeSignature::max_buffer(), TypeSignature::UIntType),
+            CheckErrors::TypeError(
+                TypeSignature::max_buffer().unwrap(),
+                TypeSignature::UIntType,
+            ),
         ),
         (
             "(from-consensus-buff? (buff 1048576) 0x00)",
@@ -1048,16 +1051,16 @@ fn test_index_of() {
         CheckErrors::ExpectedSequence(TypeSignature::IntType),
         CheckErrors::TypeError(TypeSignature::IntType, TypeSignature::UIntType),
         CheckErrors::TypeError(
-            TypeSignature::min_buffer(),
-            TypeSignature::min_string_ascii(),
+            TypeSignature::min_buffer().unwrap(),
+            TypeSignature::min_string_ascii().unwrap(),
         ),
         CheckErrors::TypeError(
-            TypeSignature::min_string_utf8(),
-            TypeSignature::min_string_ascii(),
+            TypeSignature::min_string_utf8().unwrap(),
+            TypeSignature::min_string_ascii().unwrap(),
         ),
         CheckErrors::TypeError(
-            TypeSignature::min_string_ascii(),
-            TypeSignature::min_string_utf8(),
+            TypeSignature::min_string_ascii().unwrap(),
+            TypeSignature::min_string_utf8().unwrap(),
         ),
         CheckErrors::TypeError(
             TypeSignature::list_of(TypeSignature::IntType, 1).unwrap(),
@@ -1066,16 +1069,16 @@ fn test_index_of() {
         CheckErrors::ExpectedSequence(TypeSignature::IntType),
         CheckErrors::TypeError(TypeSignature::IntType, TypeSignature::UIntType),
         CheckErrors::TypeError(
-            TypeSignature::min_buffer(),
-            TypeSignature::min_string_ascii(),
+            TypeSignature::min_buffer().unwrap(),
+            TypeSignature::min_string_ascii().unwrap(),
         ),
         CheckErrors::TypeError(
-            TypeSignature::min_string_utf8(),
-            TypeSignature::min_string_ascii(),
+            TypeSignature::min_string_utf8().unwrap(),
+            TypeSignature::min_string_ascii().unwrap(),
         ),
         CheckErrors::TypeError(
-            TypeSignature::min_string_ascii(),
-            TypeSignature::min_string_utf8(),
+            TypeSignature::min_string_ascii().unwrap(),
+            TypeSignature::min_string_utf8().unwrap(),
         ),
         CheckErrors::CouldNotDetermineType,
         CheckErrors::CouldNotDetermineType,
@@ -2146,15 +2149,15 @@ fn test_string_to_ints() {
         CheckErrors::IncorrectArgumentCount(1, 0),
         CheckErrors::UnionTypeError(
             vec![
-                TypeSignature::max_string_ascii(),
-                TypeSignature::max_string_utf8(),
+                TypeSignature::max_string_ascii().unwrap(),
+                TypeSignature::max_string_utf8().unwrap(),
             ],
             SequenceType(BufferType(BufferLength::try_from(17_u32).unwrap())),
         ),
         CheckErrors::UnionTypeError(
             vec![
-                TypeSignature::max_string_ascii(),
-                TypeSignature::max_string_utf8(),
+                TypeSignature::max_string_ascii().unwrap(),
+                TypeSignature::max_string_utf8().unwrap(),
             ],
             IntType,
         ),
@@ -2162,15 +2165,15 @@ fn test_string_to_ints() {
         CheckErrors::IncorrectArgumentCount(1, 0),
         CheckErrors::UnionTypeError(
             vec![
-                TypeSignature::max_string_ascii(),
-                TypeSignature::max_string_utf8(),
+                TypeSignature::max_string_ascii().unwrap(),
+                TypeSignature::max_string_utf8().unwrap(),
             ],
             SequenceType(BufferType(BufferLength::try_from(17_u32).unwrap())),
         ),
         CheckErrors::UnionTypeError(
             vec![
-                TypeSignature::max_string_ascii(),
-                TypeSignature::max_string_utf8(),
+                TypeSignature::max_string_ascii().unwrap(),
+                TypeSignature::max_string_utf8().unwrap(),
             ],
             IntType,
         ),
@@ -3391,14 +3394,17 @@ fn test_principal_construct() {
         (
             r#"(principal-construct? 0x22 0xfa6bf38ed557fe417333710d6033e9419391a320 "foooooooooooooooooooooooooooooooooooooooo")"#,
             CheckErrors::TypeError(
-                TypeSignature::contract_name_string_ascii_type(),
-                TypeSignature::bound_string_ascii_type(41),
+                TypeSignature::contract_name_string_ascii_type().unwrap(),
+                TypeSignature::bound_string_ascii_type(41).unwrap(),
             ),
         ),
         // bad argument type for `name`
         (
             r#"(principal-construct? 0x22 0xfa6bf38ed557fe417333710d6033e9419391a320 u123)"#,
-            CheckErrors::TypeError(TypeSignature::contract_name_string_ascii_type(), UIntType),
+            CheckErrors::TypeError(
+                TypeSignature::contract_name_string_ascii_type().unwrap(),
+                UIntType,
+            ),
         ),
         // too many arguments
         (
diff --git a/clarity/src/vm/analysis/types.rs b/clarity/src/vm/analysis/types.rs
index 6771c5c514..1abdbff8fb 100644
--- a/clarity/src/vm/analysis/types.rs
+++ b/clarity/src/vm/analysis/types.rs
@@ -94,6 +94,7 @@ impl ContractAnalysis {
         }
     }
 
+    #[allow(clippy::expect_used)]
     pub fn take_contract_cost_tracker(&mut self) -> LimitedCostTracker {
         self.cost_track
             .take()
diff --git a/clarity/src/vm/ast/definition_sorter/mod.rs b/clarity/src/vm/ast/definition_sorter/mod.rs
index 235fb77019..cbbc4b19eb 100644
--- a/clarity/src/vm/ast/definition_sorter/mod.rs
+++ b/clarity/src/vm/ast/definition_sorter/mod.rs
@@ -120,7 +120,7 @@ impl<'a> DefinitionSorter {
             Atom(ref name) => {
                 if let Some(dep) = self.top_level_expressions_map.get(name) {
                     if dep.atom_index != expr.id {
-                        self.graph.add_directed_edge(tle_index, dep.expr_index);
+                        self.graph.add_directed_edge(tle_index, dep.expr_index)?;
                     }
                 }
                 Ok(())
@@ -128,7 +128,7 @@ impl<'a> DefinitionSorter {
             TraitReference(ref name) => {
                 if let Some(dep) = self.top_level_expressions_map.get(name) {
                     if dep.atom_index != expr.id {
-                        self.graph.add_directed_edge(tle_index, dep.expr_index);
+                        self.graph.add_directed_edge(tle_index, dep.expr_index)?;
                     }
                 }
                 Ok(())
@@ -420,9 +420,17 @@ impl Graph {
         self.adjacency_list.push(vec![]);
     }
 
-    fn add_directed_edge(&mut self, src_expr_index: usize, dst_expr_index: usize) {
-        let list = self.adjacency_list.get_mut(src_expr_index).unwrap();
+    fn add_directed_edge(
+        &mut self,
+        src_expr_index: usize,
+        dst_expr_index: usize,
+    ) -> ParseResult<()> {
+        let list = self
+            .adjacency_list
+            .get_mut(src_expr_index)
+            .ok_or_else(|| ParseErrors::InterpreterFailure)?;
         list.push(dst_expr_index);
+        Ok(())
     }
 
     fn get_node_descendants(&self, expr_index: usize) -> Vec<usize> {
diff --git a/clarity/src/vm/ast/errors.rs b/clarity/src/vm/ast/errors.rs
index 8903e6ae73..db6c154153 100644
--- a/clarity/src/vm/ast/errors.rs
+++ b/clarity/src/vm/ast/errors.rs
@@ -91,6 +91,8 @@ pub enum ParseErrors {
 
     /// Should be an unreachable error
     UnexpectedParserFailure,
+    /// Should be an unreachable failure which invalidates the transaction
+    InterpreterFailure,
 }
 
 #[derive(Debug, PartialEq)]
@@ -110,6 +112,13 @@ impl ParseError {
         }
     }
 
+    pub fn rejectable(&self) -> bool {
+        match self.err {
+            ParseErrors::InterpreterFailure => true,
+            _ => false,
+        }
+    }
+
     pub fn has_pre_expression(&self) -> bool {
         self.pre_expressions.is_some()
     }
@@ -169,6 +178,9 @@ impl From<CostErrors> for ParseError {
             CostErrors::CostContractLoadFailure => ParseError::new(
                 ParseErrors::CostComputationFailed("Failed to load cost contract".into()),
             ),
+            CostErrors::InterpreterFailure | CostErrors::Expect(_) => {
+                ParseError::new(ParseErrors::InterpreterFailure)
+            }
         }
     }
 }
@@ -298,6 +310,7 @@ impl DiagnosableError for ParseErrors {
             ParseErrors::ExpectedWhitespace => "expected whitespace before expression".to_string(),
             ParseErrors::NoteToMatchThis(token) => format!("to match this '{}'", token),
             ParseErrors::UnexpectedParserFailure => "unexpected failure while parsing".to_string(),
+            ParseErrors::InterpreterFailure => "unexpected failure while parsing".to_string(),
         }
     }
 
diff --git a/clarity/src/vm/ast/mod.rs b/clarity/src/vm/ast/mod.rs
index 9dfcbc1ee9..cdaeb88261 100644
--- a/clarity/src/vm/ast/mod.rs
+++ b/clarity/src/vm/ast/mod.rs
@@ -150,6 +150,7 @@ fn build_ast_typical<T: CostTracker>(
 /// placeholders into the AST. Collects as many diagnostics as possible.
 /// Always returns a ContractAST, a vector of diagnostics, and a boolean
 /// that indicates if the build was successful.
+#[allow(clippy::unwrap_used)]
 pub fn build_ast_with_diagnostics<T: CostTracker>(
     contract_identifier: &QualifiedContractIdentifier,
     source_code: &str,
@@ -370,7 +371,9 @@ mod test {
         fn add_memory(&mut self, _memory: u64) -> std::result::Result<(), CostErrors> {
             Ok(())
         }
-        fn drop_memory(&mut self, _memory: u64) {}
+        fn drop_memory(&mut self, _memory: u64) -> std::result::Result<(), CostErrors> {
+            Ok(())
+        }
         fn reset_memory(&mut self) {}
         fn short_circuit_contract_call(
             &mut self,
diff --git a/clarity/src/vm/ast/parser/v1.rs b/clarity/src/vm/ast/parser/v1.rs
index f62d3e5938..cc8e2dfcbc 100644
--- a/clarity/src/vm/ast/parser/v1.rs
+++ b/clarity/src/vm/ast/parser/v1.rs
@@ -89,6 +89,7 @@ enum ParseContext {
 
 impl LexMatcher {
     fn new(regex_str: &str, handles: TokenType) -> LexMatcher {
+        #[allow(clippy::unwrap_used)]
         LexMatcher {
             matcher: Regex::new(&format!("^{}", regex_str)).unwrap(),
             handler: handles,
@@ -216,7 +217,9 @@ fn inner_lex(input: &str, max_nesting: u64) -> ParseResult<Vec<(LexItem, u32, u3
         let current_slice = &input[munch_index..];
         for matcher in lex_matchers.iter() {
             if let Some(captures) = matcher.matcher.captures(current_slice) {
-                let whole_match = captures.get(0).unwrap();
+                let whole_match = captures
+                    .get(0)
+                    .ok_or_else(|| ParseErrors::InterpreterFailure)?;
                 assert_eq!(whole_match.start(), 0);
                 munch_index += whole_match.end();
 
diff --git a/clarity/src/vm/ast/parser/v2/mod.rs b/clarity/src/vm/ast/parser/v2/mod.rs
index 3114a697e6..371f9d6f66 100644
--- a/clarity/src/vm/ast/parser/v2/mod.rs
+++ b/clarity/src/vm/ast/parser/v2/mod.rs
@@ -537,6 +537,7 @@ impl<'a> Parser<'a> {
 
         // Peek ahead for a '.', indicating a contract identifier
         if self.peek_next_token().token == Token::Dot {
+            #[allow(clippy::unwrap_used)]
             let dot = self.next_token().unwrap(); // skip over the dot
             let (name, contract_span) = match self.next_token() {
                 Some(PlacedToken {
@@ -601,6 +602,7 @@ impl<'a> Parser<'a> {
 
             // Peek ahead for a '.', indicating a trait identifier
             if self.peek_next_token().token == Token::Dot {
+                #[allow(clippy::unwrap_used)]
                 let dot = self.next_token().unwrap(); // skip over the dot
                 let (name, trait_span) = match self.next_token() {
                     Some(PlacedToken {
@@ -742,6 +744,7 @@ impl<'a> Parser<'a> {
 
         // Peek ahead for a '.', indicating a trait identifier
         if self.peek_next_token().token == Token::Dot {
+            #[allow(clippy::unwrap_used)]
             let dot = self.next_token().unwrap(); // skip over the dot
             let (name, trait_span) = match self.next_token() {
                 Some(PlacedToken {
@@ -1008,7 +1011,8 @@ impl<'a> Parser<'a> {
                         | Token::LessEqual
                         | Token::Greater
                         | Token::GreaterEqual => {
-                            let name = ClarityName::try_from(token.token.to_string()).unwrap();
+                            let name = ClarityName::try_from(token.token.to_string())
+                                .map_err(|_| ParseErrors::InterpreterFailure)?;
                             let mut e = PreSymbolicExpression::atom(name);
                             e.span = token.span;
                             Some(e)
@@ -1115,6 +1119,7 @@ pub fn parse(input: &str) -> ParseResult<Vec<PreSymbolicExpression>> {
     }
 }
 
+#[allow(clippy::unwrap_used)]
 pub fn parse_collect_diagnostics(
     input: &str,
 ) -> (Vec<PreSymbolicExpression>, Vec<Diagnostic>, bool) {
@@ -1382,7 +1387,7 @@ mod tests {
         assert_eq!(stmts.len(), 1);
         assert_eq!(diagnostics.len(), 0);
         if let Some(v) = stmts[0].match_atom_value() {
-            assert_eq!(v.clone().expect_ascii(), "new\nline");
+            assert_eq!(v.clone().expect_ascii().unwrap(), "new\nline");
         } else {
             panic!("failed to parse ascii string");
         }
@@ -3405,7 +3410,7 @@ mod tests {
             }
         );
         let val = stmts[0].match_atom_value().unwrap().clone();
-        assert_eq!(val.expect_buff(2), vec![0x12, 0x34]);
+        assert_eq!(val.expect_buff(2).unwrap(), vec![0x12, 0x34]);
     }
 
     #[test]
diff --git a/clarity/src/vm/ast/sugar_expander/mod.rs b/clarity/src/vm/ast/sugar_expander/mod.rs
index 1d5200ad5d..3a3afbe9c0 100644
--- a/clarity/src/vm/ast/sugar_expander/mod.rs
+++ b/clarity/src/vm/ast/sugar_expander/mod.rs
@@ -87,7 +87,12 @@ impl SugarExpander {
                         .collect::<Vec<_>>();
                     pairs.insert(
                         0,
-                        SymbolicExpression::atom("tuple".to_string().try_into().unwrap()),
+                        SymbolicExpression::atom(
+                            "tuple"
+                                .to_string()
+                                .try_into()
+                                .map_err(|_| ParseErrors::InterpreterFailure)?,
+                        ),
                     );
                     SymbolicExpression::list(pairs.into_boxed_slice())
                 }
diff --git a/clarity/src/vm/callables.rs b/clarity/src/vm/callables.rs
index b5f26264cb..5c8e40f78e 100644
--- a/clarity/src/vm/callables.rs
+++ b/clarity/src/vm/callables.rs
@@ -36,7 +36,8 @@ use crate::vm::types::{
 };
 use crate::vm::{eval, Environment, LocalContext, Value};
 
-use super::costs::CostOverflowingMath;
+use super::costs::{CostErrors, CostOverflowingMath};
+use super::errors::InterpreterError;
 use super::types::signatures::CallableSubtype;
 use super::ClarityVersion;
 
@@ -90,12 +91,19 @@ impl NativeHandle {
         match self {
             Self::SingleArg(function) => {
                 check_argument_count(1, &args)?;
-                function(args.pop().unwrap())
+                function(
+                    args.pop()
+                        .ok_or_else(|| InterpreterError::Expect("Unexpected list length".into()))?,
+                )
             }
             Self::DoubleArg(function) => {
                 check_argument_count(2, &args)?;
-                let second = args.pop().unwrap();
-                let first = args.pop().unwrap();
+                let second = args
+                    .pop()
+                    .ok_or_else(|| InterpreterError::Expect("Unexpected list length".into()))?;
+                let first = args
+                    .pop()
+                    .ok_or_else(|| InterpreterError::Expect("Unexpected list length".into()))?;
                 function(first, second)
             }
             Self::MoreArg(function) => function(args),
@@ -107,7 +115,10 @@ impl NativeHandle {
 pub fn cost_input_sized_vararg(args: &[Value]) -> Result<u64> {
     args.iter()
         .try_fold(0, |sum, value| {
-            (value.serialized_size() as u64).cost_overflow_add(sum)
+            (value
+                .serialized_size()
+                .map_err(|e| CostErrors::Expect(format!("{e:?}")))? as u64)
+                .cost_overflow_add(sum)
         })
         .map_err(Error::from)
 }
@@ -154,7 +165,7 @@ impl DefinedFunction {
             runtime_cost(
                 ClarityCostFunction::InnerTypeCheckCost,
                 env,
-                arg_type.size(),
+                arg_type.size()?,
             )?;
         }
 
@@ -533,7 +544,7 @@ mod test {
             trait_identifier: None,
         });
         let cast_contract = clarity2_implicit_cast(&trait_ty, &contract).unwrap();
-        let cast_trait = cast_contract.expect_callable();
+        let cast_trait = cast_contract.expect_callable().unwrap();
         assert_eq!(&cast_trait.contract_identifier, &contract_identifier);
         assert_eq!(&cast_trait.trait_identifier.unwrap(), &trait_identifier);
 
@@ -541,7 +552,7 @@ mod test {
         let optional_ty = TypeSignature::new_option(trait_ty.clone()).unwrap();
         let optional_contract = Value::some(contract.clone()).unwrap();
         let cast_optional = clarity2_implicit_cast(&optional_ty, &optional_contract).unwrap();
-        match &cast_optional.expect_optional().unwrap() {
+        match &cast_optional.expect_optional().unwrap().unwrap() {
             Value::CallableContract(CallableData {
                 contract_identifier: contract_id,
                 trait_identifier: trait_id,
@@ -557,7 +568,11 @@ mod test {
             TypeSignature::new_response(trait_ty.clone(), TypeSignature::UIntType).unwrap();
         let response_contract = Value::okay(contract.clone()).unwrap();
         let cast_response = clarity2_implicit_cast(&response_ok_ty, &response_contract).unwrap();
-        let cast_trait = cast_response.expect_result_ok().expect_callable();
+        let cast_trait = cast_response
+            .expect_result_ok()
+            .unwrap()
+            .expect_callable()
+            .unwrap();
         assert_eq!(&cast_trait.contract_identifier, &contract_identifier);
         assert_eq!(&cast_trait.trait_identifier.unwrap(), &trait_identifier);
 
@@ -566,7 +581,11 @@ mod test {
             TypeSignature::new_response(TypeSignature::UIntType, trait_ty.clone()).unwrap();
         let response_contract = Value::error(contract.clone()).unwrap();
         let cast_response = clarity2_implicit_cast(&response_err_ty, &response_contract).unwrap();
-        let cast_trait = cast_response.expect_result_err().expect_callable();
+        let cast_trait = cast_response
+            .expect_result_err()
+            .unwrap()
+            .expect_callable()
+            .unwrap();
         assert_eq!(&cast_trait.contract_identifier, &contract_identifier);
         assert_eq!(&cast_trait.trait_identifier.unwrap(), &trait_identifier);
 
@@ -574,9 +593,9 @@ mod test {
         let list_ty = TypeSignature::list_of(trait_ty.clone(), 4).unwrap();
         let list_contract = Value::list_from(vec![contract.clone(), contract2.clone()]).unwrap();
         let cast_list = clarity2_implicit_cast(&list_ty, &list_contract).unwrap();
-        let items = cast_list.expect_list();
+        let items = cast_list.expect_list().unwrap();
         for item in items {
-            let cast_trait = item.expect_callable();
+            let cast_trait = item.expect_callable().unwrap();
             assert_eq!(&cast_trait.trait_identifier.unwrap(), &trait_identifier);
         }
 
@@ -602,10 +621,12 @@ mod test {
         let cast_tuple = clarity2_implicit_cast(&tuple_ty, &tuple_contract).unwrap();
         let cast_trait = cast_tuple
             .expect_tuple()
+            .unwrap()
             .get(&a_name)
             .unwrap()
             .clone()
-            .expect_callable();
+            .expect_callable()
+            .unwrap();
         assert_eq!(&cast_trait.contract_identifier, &contract_identifier);
         assert_eq!(&cast_trait.trait_identifier.unwrap(), &trait_identifier);
 
@@ -618,11 +639,11 @@ mod test {
         ])
         .unwrap();
         let cast_list = clarity2_implicit_cast(&list_opt_ty, &list_opt_contract).unwrap();
-        let items = cast_list.expect_list();
+        let items = cast_list.expect_list().unwrap();
         for item in items {
-            match item.expect_optional() {
+            match item.expect_optional().unwrap() {
                 Some(cast_opt) => {
-                    let cast_trait = cast_opt.expect_callable();
+                    let cast_trait = cast_opt.expect_callable().unwrap();
                     assert_eq!(&cast_trait.trait_identifier.unwrap(), &trait_identifier);
                 }
                 None => (),
@@ -638,9 +659,9 @@ mod test {
         ])
         .unwrap();
         let cast_list = clarity2_implicit_cast(&list_res_ty, &list_res_contract).unwrap();
-        let items = cast_list.expect_list();
+        let items = cast_list.expect_list().unwrap();
         for item in items {
-            let cast_trait = item.expect_result_ok().expect_callable();
+            let cast_trait = item.expect_result_ok().unwrap().expect_callable().unwrap();
             assert_eq!(&cast_trait.trait_identifier.unwrap(), &trait_identifier);
         }
 
@@ -653,9 +674,9 @@ mod test {
         ])
         .unwrap();
         let cast_list = clarity2_implicit_cast(&list_res_ty, &list_res_contract).unwrap();
-        let items = cast_list.expect_list();
+        let items = cast_list.expect_list().unwrap();
         for item in items {
-            let cast_trait = item.expect_result_err().expect_callable();
+            let cast_trait = item.expect_result_err().unwrap().expect_callable().unwrap();
             assert_eq!(&cast_trait.trait_identifier.unwrap(), &trait_identifier);
         }
 
@@ -670,10 +691,10 @@ mod test {
         .unwrap();
         let opt_list_res_contract = Value::some(list_res_contract).unwrap();
         let cast_opt = clarity2_implicit_cast(&opt_list_res_ty, &opt_list_res_contract).unwrap();
-        let inner = cast_opt.expect_optional().unwrap();
-        let items = inner.expect_list();
+        let inner = cast_opt.expect_optional().unwrap().unwrap();
+        let items = inner.expect_list().unwrap();
         for item in items {
-            let cast_trait = item.expect_result_err().expect_callable();
+            let cast_trait = item.expect_result_err().unwrap().expect_callable().unwrap();
             assert_eq!(&cast_trait.trait_identifier.unwrap(), &trait_identifier);
         }
 
@@ -687,8 +708,10 @@ mod test {
         match &cast_optional
             .expect_optional()
             .unwrap()
+            .unwrap()
             .expect_optional()
             .unwrap()
+            .unwrap()
         {
             Value::CallableContract(CallableData {
                 contract_identifier: contract_id,
diff --git a/clarity/src/vm/clarity.rs b/clarity/src/vm/clarity.rs
index 18b11b185e..b98c246713 100644
--- a/clarity/src/vm/clarity.rs
+++ b/clarity/src/vm/clarity.rs
@@ -141,9 +141,14 @@ pub trait ClarityConnection {
             let result = vm_env
                 .execute_in_env(sender, sponsor, Some(initial_context), to_do)
                 .map(|(result, _, _)| result);
-            let (db, _) = vm_env
-                .destruct()
-                .expect("Failed to recover database reference after executing transaction");
+            // this expect is allowed, if the database has escaped this context, then it is no longer sane
+            //  and we must crash
+            #[allow(clippy::expect_used)]
+            let (db, _) = {
+                vm_env
+                    .destruct()
+                    .expect("Failed to recover database reference after executing transaction")
+            };
             (result, db)
         })
     }
@@ -165,7 +170,8 @@ pub trait TransactionConnection: ClarityConnection {
     ) -> Result<(R, AssetMap, Vec<StacksTransactionEvent>, bool), E>
     where
         A: FnOnce(&AssetMap, &mut ClarityDatabase) -> bool,
-        F: FnOnce(&mut OwnedEnvironment) -> Result<(R, AssetMap, Vec<StacksTransactionEvent>), E>;
+        F: FnOnce(&mut OwnedEnvironment) -> Result<(R, AssetMap, Vec<StacksTransactionEvent>), E>,
+        E: From<InterpreterError>;
 
     /// Do something with the analysis database and cost tracker
     ///  instance of this transaction connection. This is a low-level
@@ -234,12 +240,20 @@ pub trait TransactionConnection: ClarityConnection {
             let result = db.insert_contract(identifier, contract_analysis);
             match result {
                 Ok(_) => {
-                    db.commit();
-                    (cost_tracker, Ok(()))
+                    let result = db
+                        .commit()
+                        .map_err(|e| CheckErrors::Expects(format!("{e:?}")).into());
+                    (cost_tracker, result)
                 }
                 Err(e) => {
-                    db.roll_back();
-                    (cost_tracker, Err(e))
+                    let result = db
+                        .roll_back()
+                        .map_err(|e| CheckErrors::Expects(format!("{e:?}")).into());
+                    if result.is_err() {
+                        (cost_tracker, result)
+                    } else {
+                        (cost_tracker, Err(e))
+                    }
                 }
             }
         })
diff --git a/clarity/src/vm/contexts.rs b/clarity/src/vm/contexts.rs
index f577690ae3..ca9b844d1f 100644
--- a/clarity/src/vm/contexts.rs
+++ b/clarity/src/vm/contexts.rs
@@ -310,14 +310,13 @@ impl AssetMap {
         asset: AssetIdentifier,
         transfered: Value,
     ) {
-        if !self.asset_map.contains_key(principal) {
-            self.asset_map.insert(principal.clone(), HashMap::new());
-        }
-
-        let principal_map = self.asset_map.get_mut(principal).unwrap(); // should always exist, because of checked insert above.
+        let principal_map = self
+            .asset_map
+            .entry(principal.clone())
+            .or_insert_with(|| HashMap::new());
 
-        if principal_map.contains_key(&asset) {
-            principal_map.get_mut(&asset).unwrap().push(transfered);
+        if let Some(map_entry) = principal_map.get_mut(&asset) {
+            map_entry.push(transfered);
         } else {
             principal_map.insert(asset, vec![transfered]);
         }
@@ -331,12 +330,10 @@ impl AssetMap {
     ) -> Result<()> {
         let next_amount = self.get_next_amount(principal, &asset, amount)?;
 
-        if !self.token_map.contains_key(principal) {
-            self.token_map.insert(principal.clone(), HashMap::new());
-        }
-
-        let principal_map = self.token_map.get_mut(principal).unwrap(); // should always exist, because of checked insert above.
-
+        let principal_map = self
+            .token_map
+            .entry(principal.clone())
+            .or_insert_with(|| HashMap::new());
         principal_map.insert(asset, next_amount);
 
         Ok(())
@@ -369,13 +366,11 @@ impl AssetMap {
         // After this point, this function will not fail.
         for (principal, mut principal_map) in other.asset_map.drain() {
             for (asset, mut transfers) in principal_map.drain() {
-                if !self.asset_map.contains_key(&principal) {
-                    self.asset_map.insert(principal.clone(), HashMap::new());
-                }
-
-                let landing_map = self.asset_map.get_mut(&principal).unwrap(); // should always exist, because of checked insert above.
-                if landing_map.contains_key(&asset) {
-                    let landing_vec = landing_map.get_mut(&asset).unwrap();
+                let landing_map = self
+                    .asset_map
+                    .entry(principal.clone())
+                    .or_insert_with(|| HashMap::new());
+                if let Some(landing_vec) = landing_map.get_mut(&asset) {
                     landing_vec.append(&mut transfers);
                 } else {
                     landing_map.insert(asset, transfers);
@@ -392,11 +387,10 @@ impl AssetMap {
         }
 
         for (principal, asset, amount) in to_add.drain(..) {
-            if !self.token_map.contains_key(&principal) {
-                self.token_map.insert(principal.clone(), HashMap::new());
-            }
-
-            let principal_map = self.token_map.get_mut(&principal).unwrap(); // should always exist, because of checked insert above.
+            let principal_map = self
+                .token_map
+                .entry(principal)
+                .or_insert_with(|| HashMap::new());
             principal_map.insert(asset, amount);
         }
 
@@ -414,12 +408,9 @@ impl AssetMap {
         }
 
         for (principal, stx_amount) in self.stx_map.drain() {
-            let output_map = if map.contains_key(&principal) {
-                map.get_mut(&principal).unwrap()
-            } else {
-                map.insert(principal.clone(), HashMap::new());
-                map.get_mut(&principal).unwrap()
-            };
+            let output_map = map
+                .entry(principal.clone())
+                .or_insert_with(|| HashMap::new());
             output_map.insert(
                 AssetIdentifier::STX(),
                 AssetMapEntry::STX(stx_amount as u128),
@@ -427,12 +418,9 @@ impl AssetMap {
         }
 
         for (principal, stx_burned_amount) in self.burn_map.drain() {
-            let output_map = if map.contains_key(&principal) {
-                map.get_mut(&principal).unwrap()
-            } else {
-                map.insert(principal.clone(), HashMap::new());
-                map.get_mut(&principal).unwrap()
-            };
+            let output_map = map
+                .entry(principal.clone())
+                .or_insert_with(|| HashMap::new());
             output_map.insert(
                 AssetIdentifier::STX_burned(),
                 AssetMapEntry::Burn(stx_burned_amount as u128),
@@ -440,13 +428,9 @@ impl AssetMap {
         }
 
         for (principal, mut principal_map) in self.asset_map.drain() {
-            let output_map = if map.contains_key(&principal) {
-                map.get_mut(&principal).unwrap()
-            } else {
-                map.insert(principal.clone(), HashMap::new());
-                map.get_mut(&principal).unwrap()
-            };
-
+            let output_map = map
+                .entry(principal.clone())
+                .or_insert_with(|| HashMap::new());
             for (asset, transfers) in principal_map.drain() {
                 output_map.insert(asset, AssetMapEntry::Asset(transfers));
             }
@@ -469,14 +453,14 @@ impl AssetMap {
         }
     }
 
-    pub fn get_stx_burned_total(&self) -> u128 {
+    pub fn get_stx_burned_total(&self) -> Result<u128> {
         let mut total: u128 = 0;
         for principal in self.burn_map.keys() {
             total = total
                 .checked_add(*self.burn_map.get(principal).unwrap_or(&0u128))
-                .expect("BURN OVERFLOW");
+                .ok_or_else(|| InterpreterError::Expect("BURN OVERFLOW".into()))?;
         }
-        total
+        Ok(total)
     }
 
     pub fn get_fungible_tokens(
@@ -559,9 +543,9 @@ impl<'a, 'hooks> OwnedEnvironment<'a, 'hooks> {
     #[cfg(any(test, feature = "testing"))]
     pub fn new_toplevel(mut database: ClarityDatabase<'a>) -> OwnedEnvironment<'a, '_> {
         database.begin();
-        let epoch = database.get_clarity_epoch_version();
+        let epoch = database.get_clarity_epoch_version().unwrap();
         let version = ClarityVersion::default_for_epoch(epoch);
-        database.roll_back();
+        database.roll_back().unwrap();
 
         debug!(
             "Begin OwnedEnvironment(epoch = {}, version = {})",
@@ -673,7 +657,7 @@ impl<'a, 'hooks> OwnedEnvironment<'a, 'hooks> {
                 Ok((return_value, asset_map, event_batch.events))
             }
             Err(e) => {
-                self.context.roll_back();
+                self.context.roll_back()?;
                 Err(e)
             }
         }
@@ -781,10 +765,11 @@ impl<'a, 'hooks> OwnedEnvironment<'a, 'hooks> {
                 let mut snapshot = env
                     .global_context
                     .database
-                    .get_stx_balance_snapshot(&recipient);
+                    .get_stx_balance_snapshot(&recipient)
+                    .unwrap();
 
-                snapshot.credit(amount);
-                snapshot.save();
+                snapshot.credit(amount).unwrap();
+                snapshot.save().unwrap();
 
                 env.global_context
                     .database
@@ -883,7 +868,7 @@ impl CostTracker for Environment<'_, '_, '_> {
     fn add_memory(&mut self, memory: u64) -> std::result::Result<(), CostErrors> {
         self.global_context.cost_track.add_memory(memory)
     }
-    fn drop_memory(&mut self, memory: u64) {
+    fn drop_memory(&mut self, memory: u64) -> std::result::Result<(), CostErrors> {
         self.global_context.cost_track.drop_memory(memory)
     }
     fn reset_memory(&mut self) {
@@ -916,7 +901,7 @@ impl CostTracker for GlobalContext<'_, '_> {
     fn add_memory(&mut self, memory: u64) -> std::result::Result<(), CostErrors> {
         self.cost_track.add_memory(memory)
     }
-    fn drop_memory(&mut self, memory: u64) {
+    fn drop_memory(&mut self, memory: u64) -> std::result::Result<(), CostErrors> {
         self.cost_track.drop_memory(memory)
     }
     fn reset_memory(&mut self) {
@@ -1031,7 +1016,7 @@ impl<'a, 'b, 'hooks> Environment<'a, 'b, 'hooks> {
             eval(&parsed[0], &mut nested_env, &local_context)
         };
 
-        self.global_context.roll_back();
+        self.global_context.roll_back()?;
 
         result
     }
@@ -1164,7 +1149,7 @@ impl<'a, 'b, 'hooks> Environment<'a, 'b, 'hooks> {
                                                                                   tx_name)))?;
                     // sanitize contract-call inputs in epochs >= 2.4
                     // testing todo: ensure sanitize_value() preserves trait callability!
-                    let expected_type = TypeSignature::type_of(value);
+                    let expected_type = TypeSignature::type_of(value)?;
                     let (sanitized_value, _) = Value::sanitize_value(
                         self.epoch(),
                         &expected_type,
@@ -1236,7 +1221,7 @@ impl<'a, 'b, 'hooks> Environment<'a, 'b, 'hooks> {
         };
 
         if make_read_only {
-            self.global_context.roll_back();
+            self.global_context.roll_back()?;
             result
         } else {
             self.global_context.handle_tx_result(result)
@@ -1260,13 +1245,15 @@ impl<'a, 'b, 'hooks> Environment<'a, 'b, 'hooks> {
                 self.global_context
                     .database
                     .set_block_hash(prior_bhh, true)
-                    .expect(
-                    "ERROR: Failed to restore prior active block after time-shifted evaluation.",
-                );
+                    .map_err(|_| {
+                        InterpreterError::Expect(
+                        "ERROR: Failed to restore prior active block after time-shifted evaluation."
+                            .into())
+                    })?;
                 result
             });
 
-        self.global_context.roll_back();
+        self.global_context.roll_back()?;
 
         result
     }
@@ -1339,7 +1326,7 @@ impl<'a, 'b, 'hooks> Environment<'a, 'b, 'hooks> {
                 &mut self.global_context,
                 contract_version,
             );
-            self.drop_memory(memory_use);
+            self.drop_memory(memory_use)?;
             result
         })();
 
@@ -1348,7 +1335,7 @@ impl<'a, 'b, 'hooks> Environment<'a, 'b, 'hooks> {
                 let data_size = contract.contract_context.data_size;
                 self.global_context
                     .database
-                    .insert_contract(&contract_identifier, contract);
+                    .insert_contract(&contract_identifier, contract)?;
                 self.global_context
                     .database
                     .set_contract_data_size(&contract_identifier, data_size)?;
@@ -1357,7 +1344,7 @@ impl<'a, 'b, 'hooks> Environment<'a, 'b, 'hooks> {
                 Ok(())
             }
             Err(e) => {
-                self.global_context.roll_back();
+                self.global_context.roll_back()?;
                 Err(e)
             }
         }
@@ -1383,12 +1370,12 @@ impl<'a, 'b, 'hooks> Environment<'a, 'b, 'hooks> {
                     Ok(value)
                 }
                 Err(_) => {
-                    self.global_context.roll_back();
+                    self.global_context.roll_back()?;
                     Err(InterpreterError::InsufficientBalance.into())
                 }
             },
             Err(e) => {
-                self.global_context.roll_back();
+                self.global_context.roll_back()?;
                 Err(e)
             }
         }
@@ -1407,7 +1394,7 @@ impl<'a, 'b, 'hooks> Environment<'a, 'b, 'hooks> {
                 Ok(ret)
             }
             Err(e) => {
-                self.global_context.roll_back();
+                self.global_context.roll_back()?;
                 Err(e)
             }
         }
@@ -1601,10 +1588,10 @@ impl<'a, 'hooks> GlobalContext<'a, 'hooks> {
         self.asset_maps.len() == 0
     }
 
-    fn get_asset_map(&mut self) -> &mut AssetMap {
+    fn get_asset_map(&mut self) -> Result<&mut AssetMap> {
         self.asset_maps
             .last_mut()
-            .expect("Failed to obtain asset map")
+            .ok_or_else(|| InterpreterError::Expect("Failed to obtain asset map".into()).into())
     }
 
     pub fn log_asset_transfer(
@@ -1613,13 +1600,14 @@ impl<'a, 'hooks> GlobalContext<'a, 'hooks> {
         contract_identifier: &QualifiedContractIdentifier,
         asset_name: &ClarityName,
         transfered: Value,
-    ) {
+    ) -> Result<()> {
         let asset_identifier = AssetIdentifier {
             contract_identifier: contract_identifier.clone(),
             asset_name: asset_name.clone(),
         };
-        self.get_asset_map()
-            .add_asset_transfer(sender, asset_identifier, transfered)
+        self.get_asset_map()?
+            .add_asset_transfer(sender, asset_identifier, transfered);
+        Ok(())
     }
 
     pub fn log_token_transfer(
@@ -1633,16 +1621,16 @@ impl<'a, 'hooks> GlobalContext<'a, 'hooks> {
             contract_identifier: contract_identifier.clone(),
             asset_name: asset_name.clone(),
         };
-        self.get_asset_map()
+        self.get_asset_map()?
             .add_token_transfer(sender, asset_identifier, transfered)
     }
 
     pub fn log_stx_transfer(&mut self, sender: &PrincipalData, transfered: u128) -> Result<()> {
-        self.get_asset_map().add_stx_transfer(sender, transfered)
+        self.get_asset_map()?.add_stx_transfer(sender, transfered)
     }
 
     pub fn log_stx_burn(&mut self, sender: &PrincipalData, transfered: u128) -> Result<()> {
-        self.get_asset_map().add_stx_burn(sender, transfered)
+        self.get_asset_map()?.add_stx_burn(sender, transfered)
     }
 
     pub fn execute<F, T>(&mut self, f: F) -> Result<T>
@@ -1651,7 +1639,7 @@ impl<'a, 'hooks> GlobalContext<'a, 'hooks> {
     {
         self.begin();
         let result = f(self).or_else(|e| {
-            self.roll_back();
+            self.roll_back()?;
             Err(e)
         })?;
         self.commit()?;
@@ -1688,7 +1676,7 @@ impl<'a, 'hooks> GlobalContext<'a, 'hooks> {
             );
             f(&mut exec_env)
         };
-        self.roll_back();
+        self.roll_back().map_err(crate::vm::errors::Error::from)?;
 
         match result {
             Ok(return_value) => Ok(return_value),
@@ -1719,19 +1707,17 @@ impl<'a, 'hooks> GlobalContext<'a, 'hooks> {
     pub fn commit(&mut self) -> Result<(Option<AssetMap>, Option<EventBatch>)> {
         trace!("Calling commit");
         self.read_only.pop();
-        let asset_map = self
-            .asset_maps
-            .pop()
-            .expect("ERROR: Committed non-nested context.");
-        let mut event_batch = self
-            .event_batches
-            .pop()
-            .expect("ERROR: Committed non-nested context.");
+        let asset_map = self.asset_maps.pop().ok_or_else(|| {
+            InterpreterError::Expect("ERROR: Committed non-nested context.".into())
+        })?;
+        let mut event_batch = self.event_batches.pop().ok_or_else(|| {
+            InterpreterError::Expect("ERROR: Committed non-nested context.".into())
+        })?;
 
         let out_map = match self.asset_maps.last_mut() {
             Some(tail_back) => {
                 if let Err(e) = tail_back.commit_other(asset_map) {
-                    self.database.roll_back();
+                    self.database.roll_back()?;
                     return Err(e);
                 }
                 None
@@ -1747,19 +1733,25 @@ impl<'a, 'hooks> GlobalContext<'a, 'hooks> {
             None => Some(event_batch),
         };
 
-        self.database.commit();
+        self.database.commit()?;
         Ok((out_map, out_batch))
     }
 
-    pub fn roll_back(&mut self) {
+    pub fn roll_back(&mut self) -> Result<()> {
         let popped = self.asset_maps.pop();
-        assert!(popped.is_some());
+        if popped.is_none() {
+            return Err(InterpreterError::Expect("Expected entry to rollback".into()).into());
+        }
         let popped = self.read_only.pop();
-        assert!(popped.is_some());
+        if popped.is_none() {
+            return Err(InterpreterError::Expect("Expected entry to rollback".into()).into());
+        }
         let popped = self.event_batches.pop();
-        assert!(popped.is_some());
+        if popped.is_none() {
+            return Err(InterpreterError::Expect("Expected entry to rollback".into()).into());
+        }
 
-        self.database.roll_back();
+        self.database.roll_back()
     }
 
     pub fn handle_tx_result(&mut self, result: Result<Value>) -> Result<Value> {
@@ -1768,17 +1760,17 @@ impl<'a, 'hooks> GlobalContext<'a, 'hooks> {
                 if data.committed {
                     self.commit()?;
                 } else {
-                    self.roll_back();
+                    self.roll_back()?;
                 }
                 Ok(Value::Response(data))
             } else {
                 Err(
-                    CheckErrors::PublicFunctionMustReturnResponse(TypeSignature::type_of(&result))
+                    CheckErrors::PublicFunctionMustReturnResponse(TypeSignature::type_of(&result)?)
                         .into(),
                 )
             }
         } else {
-            self.roll_back();
+            self.roll_back()?;
             result
         }
     }
@@ -1961,7 +1953,10 @@ impl CallStack {
                 .into());
             }
             if tracked && !self.set.remove(&function) {
-                panic!("Tried to remove tracked function from call stack, but could not find in current context.")
+                return Err(InterpreterError::InterpreterError(
+                    "Tried to remove tracked function from call stack, but could not find in current context.".into()
+                )
+                .into());
             }
             Ok(())
         } else {
diff --git a/clarity/src/vm/costs/mod.rs b/clarity/src/vm/costs/mod.rs
index c70ab9600a..9d2b086734 100644
--- a/clarity/src/vm/costs/mod.rs
+++ b/clarity/src/vm/costs/mod.rs
@@ -50,16 +50,19 @@ pub const COSTS_2_NAME: &'static str = "costs-2";
 pub const COSTS_3_NAME: &'static str = "costs-3";
 
 lazy_static! {
-    static ref COST_TUPLE_TYPE_SIGNATURE: TypeSignature = TypeSignature::TupleType(
-        TupleTypeSignature::try_from(vec![
-            ("runtime".into(), TypeSignature::UIntType),
-            ("write_length".into(), TypeSignature::UIntType),
-            ("write_count".into(), TypeSignature::UIntType),
-            ("read_count".into(), TypeSignature::UIntType),
-            ("read_length".into(), TypeSignature::UIntType),
-        ])
-        .expect("BUG: failed to construct type signature for cost tuple")
-    );
+    static ref COST_TUPLE_TYPE_SIGNATURE: TypeSignature = {
+        #[allow(clippy::expect_used)]
+        TypeSignature::TupleType(
+            TupleTypeSignature::try_from(vec![
+                ("runtime".into(), TypeSignature::UIntType),
+                ("write_length".into(), TypeSignature::UIntType),
+                ("write_count".into(), TypeSignature::UIntType),
+                ("read_count".into(), TypeSignature::UIntType),
+                ("read_length".into(), TypeSignature::UIntType),
+            ])
+            .expect("BUG: failed to construct type signature for cost tuple"),
+        )
+    };
 }
 
 pub fn runtime_cost<T: TryInto<u64>, C: CostTracker>(
@@ -76,7 +79,7 @@ pub fn runtime_cost<T: TryInto<u64>, C: CostTracker>(
 macro_rules! finally_drop_memory {
     ( $env: expr, $used_mem:expr; $exec:expr ) => {{
         let result = (|| $exec)();
-        $env.drop_memory($used_mem);
+        $env.drop_memory($used_mem)?;
         result
     }};
 }
@@ -96,12 +99,15 @@ pub fn analysis_typecheck_cost<T: CostTracker>(
 }
 
 pub trait MemoryConsumer {
-    fn get_memory_use(&self) -> u64;
+    fn get_memory_use(&self) -> Result<u64>;
 }
 
 impl MemoryConsumer for Value {
-    fn get_memory_use(&self) -> u64 {
-        self.size().into()
+    fn get_memory_use(&self) -> Result<u64> {
+        Ok(self
+            .size()
+            .map_err(|_| CostErrors::InterpreterFailure)?
+            .into())
     }
 }
 
@@ -113,7 +119,7 @@ pub trait CostTracker {
     ) -> Result<ExecutionCost>;
     fn add_cost(&mut self, cost: ExecutionCost) -> Result<()>;
     fn add_memory(&mut self, memory: u64) -> Result<()>;
-    fn drop_memory(&mut self, memory: u64);
+    fn drop_memory(&mut self, memory: u64) -> Result<()>;
     fn reset_memory(&mut self);
     /// Check if the given contract-call should be short-circuited.
     ///  If so: this charges the cost to the CostTracker, and return true
@@ -141,7 +147,9 @@ impl CostTracker for () {
     fn add_memory(&mut self, _memory: u64) -> std::result::Result<(), CostErrors> {
         Ok(())
     }
-    fn drop_memory(&mut self, _memory: u64) {}
+    fn drop_memory(&mut self, _memory: u64) -> Result<()> {
+        Ok(())
+    }
     fn reset_memory(&mut self) {}
     fn short_circuit_contract_call(
         &mut self,
@@ -319,18 +327,37 @@ pub enum CostErrors {
     CostBalanceExceeded(ExecutionCost, ExecutionCost),
     MemoryBalanceExceeded(u64, u64),
     CostContractLoadFailure,
+    InterpreterFailure,
+    Expect(String),
+}
+
+impl CostErrors {
+    fn rejectable(&self) -> bool {
+        match self {
+            CostErrors::InterpreterFailure => true,
+            CostErrors::Expect(_) => true,
+            _ => false,
+        }
+    }
 }
 
 fn load_state_summary(mainnet: bool, clarity_db: &mut ClarityDatabase) -> Result<CostStateSummary> {
     let cost_voting_contract = boot_code_id("cost-voting", mainnet);
 
-    let clarity_epoch = clarity_db.get_clarity_epoch_version();
+    let clarity_epoch = clarity_db
+        .get_clarity_epoch_version()
+        .map_err(|e| CostErrors::CostComputationFailed(e.to_string()))?;
     let last_processed_at = match clarity_db.get_value(
         "vm-costs::last-processed-at-height",
         &TypeSignature::UIntType,
         &clarity_epoch,
     ) {
-        Ok(Some(v)) => u32::try_from(v.value.expect_u128()).expect("Block height overflowed u32"),
+        Ok(Some(v)) => u32::try_from(
+            v.value
+                .expect_u128()
+                .map_err(|_| CostErrors::InterpreterFailure)?,
+        )
+        .map_err(|_| CostErrors::InterpreterFailure)?,
         Ok(None) => return Ok(CostStateSummary::empty()),
         Err(e) => return Err(CostErrors::CostComputationFailed(e.to_string())),
     };
@@ -343,7 +370,9 @@ fn load_state_summary(mainnet: bool, clarity_db: &mut ClarityDatabase) -> Result
         )
         .map_err(|e| CostErrors::CostComputationFailed(e.to_string()))?;
     let serialized: SerializedCostStateSummary = match metadata_result {
-        Some(serialized) => serde_json::from_str(&serialized).unwrap(),
+        Some(serialized) => {
+            serde_json::from_str(&serialized).map_err(|_| CostErrors::InterpreterFailure)?
+        }
         None => return Ok(CostStateSummary::empty()),
     };
     Ok(CostStateSummary::from(serialized))
@@ -356,7 +385,9 @@ fn store_state_summary(
 ) -> Result<()> {
     let block_height = clarity_db.get_current_block_height();
     let cost_voting_contract = boot_code_id("cost-voting", mainnet);
-    let epoch = clarity_db.get_clarity_epoch_version();
+    let epoch = clarity_db
+        .get_clarity_epoch_version()
+        .map_err(|e| CostErrors::CostComputationFailed(e.to_string()))?;
     clarity_db
         .put_value(
             "vm-costs::last-processed-at-height",
@@ -366,12 +397,14 @@ fn store_state_summary(
         .map_err(|_e| CostErrors::CostContractLoadFailure)?;
     let serialized_summary =
         serde_json::to_string(&SerializedCostStateSummary::from(to_store.clone()))
-            .expect("BUG: failure to serialize cost state summary struct");
-    clarity_db.set_metadata(
-        &cost_voting_contract,
-        "::state_summary",
-        &serialized_summary,
-    );
+            .map_err(|_| CostErrors::InterpreterFailure)?;
+    clarity_db
+        .set_metadata(
+            &cost_voting_contract,
+            "::state_summary",
+            &serialized_summary,
+        )
+        .map_err(|e| CostErrors::Expect(e.to_string()))?;
 
     Ok(())
 }
@@ -391,7 +424,9 @@ fn load_cost_functions(
     clarity_db: &mut ClarityDatabase,
     apply_updates: bool,
 ) -> Result<CostStateSummary> {
-    let clarity_epoch = clarity_db.get_clarity_epoch_version();
+    let clarity_epoch = clarity_db
+        .get_clarity_epoch_version()
+        .map_err(|e| CostErrors::CostComputationFailed(e.to_string()))?;
     let last_processed_count = clarity_db
         .get_value(
             "vm-costs::last_processed_count",
@@ -401,7 +436,8 @@ fn load_cost_functions(
         .map_err(|_e| CostErrors::CostContractLoadFailure)?
         .map(|result| result.value)
         .unwrap_or(Value::UInt(0))
-        .expect_u128();
+        .expect_u128()
+        .map_err(|_| CostErrors::InterpreterFailure)?;
     let cost_voting_contract = boot_code_id("cost-voting", mainnet);
     let confirmed_proposals_count = clarity_db
         .lookup_variable_unknown_descriptor(
@@ -410,7 +446,8 @@ fn load_cost_functions(
             &clarity_epoch,
         )
         .map_err(|e| CostErrors::CostComputationFailed(e.to_string()))?
-        .expect_u128();
+        .expect_u128()
+        .map_err(|_| CostErrors::InterpreterFailure)?;
     debug!("Check cost voting contract";
            "confirmed_proposal_count" => confirmed_proposals_count,
            "last_processed_count" => last_processed_count);
@@ -433,19 +470,26 @@ fn load_cost_functions(
                         "confirmed-id".into(),
                         Value::UInt(confirmed_proposal),
                     )])
-                    .expect("BUG: failed to construct simple tuple"),
+                    .map_err(|_| {
+                        CostErrors::Expect("BUG: failed to construct simple tuple".into())
+                    })?,
                 ),
                 &clarity_epoch,
             )
-            .expect("BUG: Failed querying confirmed-proposals")
+            .map_err(|_| CostErrors::Expect("BUG: Failed querying confirmed-proposals".into()))?
             .expect_optional()
-            .expect("BUG: confirmed-proposal-count exceeds stored proposals")
-            .expect_tuple();
+            .map_err(|_| CostErrors::InterpreterFailure)?
+            .ok_or_else(|| {
+                CostErrors::Expect("BUG: confirmed-proposal-count exceeds stored proposals".into())
+            })?
+            .expect_tuple()
+            .map_err(|_| CostErrors::InterpreterFailure)?;
         let target_contract = match entry
             .get("function-contract")
-            .expect("BUG: malformed cost proposal tuple")
+            .map_err(|_| CostErrors::Expect("BUG: malformed cost proposal tuple".into()))?
             .clone()
             .expect_principal()
+            .map_err(|_| CostErrors::InterpreterFailure)?
         {
             PrincipalData::Contract(contract_id) => contract_id,
             _ => {
@@ -457,9 +501,10 @@ fn load_cost_functions(
         let target_function = match ClarityName::try_from(
             entry
                 .get("function-name")
-                .expect("BUG: malformed cost proposal tuple")
+                .map_err(|_| CostErrors::Expect("BUG: malformed cost proposal tuple".into()))?
                 .clone()
-                .expect_ascii(),
+                .expect_ascii()
+                .map_err(|_| CostErrors::InterpreterFailure)?,
         ) {
             Ok(x) => x,
             Err(_) => {
@@ -470,9 +515,10 @@ fn load_cost_functions(
         };
         let cost_contract = match entry
             .get("cost-function-contract")
-            .expect("BUG: malformed cost proposal tuple")
+            .map_err(|_| CostErrors::Expect("BUG: malformed cost proposal tuple".into()))?
             .clone()
             .expect_principal()
+            .map_err(|_| CostErrors::InterpreterFailure)?
         {
             PrincipalData::Contract(contract_id) => contract_id,
             _ => {
@@ -485,8 +531,9 @@ fn load_cost_functions(
         let cost_function = match ClarityName::try_from(
             entry
                 .get_owned("cost-function-name")
-                .expect("BUG: malformed cost proposal tuple")
-                .expect_ascii(),
+                .map_err(|_| CostErrors::Expect("BUG: malformed cost proposal tuple".into()))?
+                .expect_ascii()
+                .map_err(|_| CostErrors::InterpreterFailure)?,
         ) {
             Ok(x) => x,
             Err(_) => {
@@ -505,6 +552,7 @@ fn load_cost_functions(
         //  arithmetic-checking analysis pass
         let (cost_func_ref, cost_func_type) = match clarity_db
             .load_contract_analysis(&cost_contract)
+            .map_err(|e| CostErrors::CostComputationFailed(e.to_string()))?
         {
             Some(c) => {
                 if !c.is_cost_contract_eligible {
@@ -586,7 +634,10 @@ fn load_cost_functions(
                 .insert(target, cost_func_ref);
         } else {
             // referring to a user-defined function
-            match clarity_db.load_contract_analysis(&target_contract) {
+            match clarity_db
+                .load_contract_analysis(&target_contract)
+                .map_err(|e| CostErrors::CostComputationFailed(e.to_string()))?
+            {
                 Some(c) => {
                     if let Some(Fixed(tf)) = c.read_only_function_types.get(&target_function) {
                         if cost_func_type.args.len() != tf.args.len() {
@@ -711,10 +762,10 @@ impl LimitedCostTracker {
         Self::Free
     }
 
-    fn default_cost_contract_for_epoch(epoch_id: StacksEpochId) -> String {
-        match epoch_id {
+    fn default_cost_contract_for_epoch(epoch_id: StacksEpochId) -> Result<String> {
+        let result = match epoch_id {
             StacksEpochId::Epoch10 => {
-                panic!("Attempted to get default cost functions for Epoch 1.0 where Clarity does not exist");
+                return Err(CostErrors::Expect("Attempted to get default cost functions for Epoch 1.0 where Clarity does not exist".into()));
             }
             StacksEpochId::Epoch20 => COSTS_1_NAME.to_string(),
             StacksEpochId::Epoch2_05 => COSTS_2_NAME.to_string(),
@@ -722,7 +773,8 @@ impl LimitedCostTracker {
             | StacksEpochId::Epoch22
             | StacksEpochId::Epoch23
             | StacksEpochId::Epoch24 => COSTS_3_NAME.to_string(),
-        }
+        };
+        Ok(result)
     }
 }
 
@@ -732,9 +784,11 @@ impl TrackerData {
     ///   fork.
     fn load_costs(&mut self, clarity_db: &mut ClarityDatabase, apply_updates: bool) -> Result<()> {
         clarity_db.begin();
-        let epoch_id = clarity_db.get_clarity_epoch_version();
+        let epoch_id = clarity_db
+            .get_clarity_epoch_version()
+            .map_err(|e| CostErrors::CostComputationFailed(e.to_string()))?;
         let boot_costs_id = boot_code_id(
-            &LimitedCostTracker::default_cost_contract_for_epoch(epoch_id),
+            &LimitedCostTracker::default_cost_contract_for_epoch(epoch_id)?,
             self.mainnet,
         );
 
@@ -742,8 +796,13 @@ impl TrackerData {
             contract_call_circuits,
             mut cost_function_references,
         } = load_cost_functions(self.mainnet, clarity_db, apply_updates).map_err(|e| {
-            clarity_db.roll_back();
-            e
+            let result = clarity_db
+                .roll_back()
+                .map_err(|e| CostErrors::Expect(e.to_string()));
+            match result {
+                Ok(_) => e,
+                Err(rollback_err) => rollback_err,
+            }
         })?;
 
         self.contract_call_circuits = contract_call_circuits;
@@ -762,7 +821,9 @@ impl TrackerData {
                         error!("Failed to load intended Clarity cost contract";
                                "contract" => %cost_function_ref.contract_id,
                                "error" => ?e);
-                        clarity_db.roll_back();
+                        clarity_db
+                            .roll_back()
+                            .map_err(|e| CostErrors::Expect(e.to_string()))?;
                         return Err(CostErrors::CostContractLoadFailure);
                     }
                 };
@@ -780,7 +841,9 @@ impl TrackerData {
                         error!("Failed to load intended Clarity cost contract";
                                "contract" => %boot_costs_id.to_string(),
                                "error" => %format!("{:?}", e));
-                        clarity_db.roll_back();
+                        clarity_db
+                            .roll_back()
+                            .map_err(|e| CostErrors::Expect(e.to_string()))?;
                         return Err(CostErrors::CostContractLoadFailure);
                     }
                 };
@@ -792,9 +855,13 @@ impl TrackerData {
         self.cost_contracts = cost_contracts;
 
         if apply_updates {
-            clarity_db.commit();
+            clarity_db
+                .commit()
+                .map_err(|e| CostErrors::Expect(e.to_string()))?;
         } else {
-            clarity_db.roll_back();
+            clarity_db
+                .roll_back()
+                .map_err(|e| CostErrors::Expect(e.to_string()))?;
         }
 
         return Ok(());
@@ -808,6 +875,7 @@ impl LimitedCostTracker {
             Self::Free => ExecutionCost::zero(),
         }
     }
+    #[allow(clippy::panic)]
     pub fn set_total(&mut self, total: ExecutionCost) -> () {
         // used by the miner to "undo" the cost of a transaction when trying to pack a block.
         match self {
@@ -954,11 +1022,12 @@ fn add_memory(s: &mut TrackerData, memory: u64) -> std::result::Result<(), CostE
     }
 }
 
-fn drop_memory(s: &mut TrackerData, memory: u64) {
+fn drop_memory(s: &mut TrackerData, memory: u64) -> Result<()> {
     s.memory = s
         .memory
         .checked_sub(memory)
-        .expect("Underflowed dropped memory");
+        .ok_or_else(|| CostErrors::Expect("Underflowed dropped memory".into()))?;
+    Ok(())
 }
 
 impl CostTracker for LimitedCostTracker {
@@ -974,7 +1043,9 @@ impl CostTracker for LimitedCostTracker {
             }
             Self::Limited(ref mut data) => {
                 if cost_function == ClarityCostFunction::Unimplemented {
-                    panic!("Used unimplemented cost function");
+                    return Err(CostErrors::Expect(
+                        "Used unimplemented cost function".into(),
+                    ));
                 }
                 let cost_function_ref = data
                     .cost_function_references
@@ -1001,9 +1072,9 @@ impl CostTracker for LimitedCostTracker {
             Self::Limited(ref mut data) => add_memory(data, memory),
         }
     }
-    fn drop_memory(&mut self, memory: u64) {
+    fn drop_memory(&mut self, memory: u64) -> Result<()> {
         match self {
-            Self::Free => {}
+            Self::Free => Ok(()),
             Self::Limited(ref mut data) => drop_memory(data, memory),
         }
     }
@@ -1054,7 +1125,7 @@ impl CostTracker for &mut LimitedCostTracker {
     fn add_memory(&mut self, memory: u64) -> std::result::Result<(), CostErrors> {
         LimitedCostTracker::add_memory(self, memory)
     }
-    fn drop_memory(&mut self, memory: u64) {
+    fn drop_memory(&mut self, memory: u64) -> std::result::Result<(), CostErrors> {
         LimitedCostTracker::drop_memory(self, memory)
     }
     fn reset_memory(&mut self) {
@@ -1088,7 +1159,8 @@ impl fmt::Display for ExecutionCost {
 
 impl ToSql for ExecutionCost {
     fn to_sql(&self) -> rusqlite::Result<ToSqlOutput> {
-        let val = serde_json::to_string(self).expect("FAIL: could not serialize ExecutionCost");
+        let val = serde_json::to_string(self)
+            .map_err(|e| rusqlite::Error::ToSqlConversionFailure(Box::new(e)))?;
         Ok(ToSqlOutput::from(val))
     }
 }
@@ -1097,7 +1169,7 @@ impl FromSql for ExecutionCost {
     fn column_result(value: ValueRef) -> FromSqlResult<ExecutionCost> {
         let str_val = String::column_result(value)?;
         let parsed = serde_json::from_str(&str_val)
-            .expect("CORRUPTION: failed to parse ExecutionCost from DB");
+            .map_err(|e| rusqlite::types::FromSqlError::Other(Box::new(e)))?;
         Ok(parsed)
     }
 }
@@ -1136,6 +1208,8 @@ impl ExecutionCost {
 
     /// Returns the percentage of self consumed in `numerator`'s largest proportion dimension.
     pub fn proportion_largest_dimension(&self, numerator: &ExecutionCost) -> u64 {
+        // max() should always return because there are > 0 elements
+        #[allow(clippy::expect_used)]
         [
             numerator.runtime / cmp::max(1, self.runtime / 100),
             numerator.write_length / cmp::max(1, self.write_length / 100),
diff --git a/clarity/src/vm/database/clarity_db.rs b/clarity/src/vm/database/clarity_db.rs
index 1218da1a13..d7383c7eb3 100644
--- a/clarity/src/vm/database/clarity_db.rs
+++ b/clarity/src/vm/database/clarity_db.rs
@@ -280,6 +280,7 @@ impl HeadersDB for NullHeadersDB {
     ) -> Option<BurnchainHeaderHash> {
         if *id_bhh == StacksBlockId::new(&FIRST_BURNCHAIN_CONSENSUS_HASH, &FIRST_STACKS_BLOCK_HASH)
         {
+            #[allow(clippy::unwrap_used)]
             let first_block_hash =
                 BurnchainHeaderHash::from_hex(BITCOIN_REGTEST_FIRST_BLOCK_HASH).unwrap();
             Some(first_block_hash)
@@ -337,6 +338,7 @@ impl HeadersDB for NullHeadersDB {
     }
 }
 
+#[allow(clippy::panic)]
 impl BurnStateDB for NullBurnStateDB {
     fn get_burn_block_height(&self, _sortition_id: &SortitionId) -> Option<u32> {
         None
@@ -447,13 +449,13 @@ impl<'a> ClarityDatabase<'a> {
     }
 
     /// Commit current key-value wrapper layer
-    pub fn commit(&mut self) {
-        self.store.commit();
+    pub fn commit(&mut self) -> Result<()> {
+        self.store.commit().map_err(|e| e.into())
     }
 
     /// Drop current key-value wrapper layer
-    pub fn roll_back(&mut self) {
-        self.store.rollback();
+    pub fn roll_back(&mut self) -> Result<()> {
+        self.store.rollback().map_err(|e| e.into())
     }
 
     pub fn set_block_hash(
@@ -464,18 +466,18 @@ impl<'a> ClarityDatabase<'a> {
         self.store.set_block_hash(bhh, query_pending_data)
     }
 
-    pub fn put<T: ClaritySerializable>(&mut self, key: &str, value: &T) {
-        self.store.put(&key, &value.serialize());
+    pub fn put<T: ClaritySerializable>(&mut self, key: &str, value: &T) -> Result<()> {
+        self.store.put(&key, &value.serialize())
     }
 
     /// Like `put()`, but returns the serialized byte size of the stored value
-    pub fn put_with_size<T: ClaritySerializable>(&mut self, key: &str, value: &T) -> u64 {
+    pub fn put_with_size<T: ClaritySerializable>(&mut self, key: &str, value: &T) -> Result<u64> {
         let serialized = value.serialize();
-        self.store.put(&key, &serialized);
-        byte_len_of_serialization(&serialized)
+        self.store.put(&key, &serialized)?;
+        Ok(byte_len_of_serialization(&serialized))
     }
 
-    pub fn get<T>(&mut self, key: &str) -> Option<T>
+    pub fn get<T>(&mut self, key: &str) -> Result<Option<T>>
     where
         T: ClarityDeserializable<T>,
     {
@@ -497,22 +499,26 @@ impl<'a> ClarityDatabase<'a> {
         let mut pre_sanitized_size = None;
 
         let serialized = if sanitize {
-            let value_size = value.serialized_size() as u64;
+            let value_size = value
+                .serialized_size()
+                .map_err(|e| InterpreterError::Expect(e.to_string()))?
+                as u64;
+
             let (sanitized_value, did_sanitize) =
-                Value::sanitize_value(epoch, &TypeSignature::type_of(&value), value)
+                Value::sanitize_value(epoch, &TypeSignature::type_of(&value)?, value)
                     .ok_or_else(|| CheckErrors::CouldNotDetermineType)?;
             // if data needed to be sanitized *charge* for the unsanitized cost
             if did_sanitize {
                 pre_sanitized_size = Some(value_size);
             }
-            sanitized_value.serialize_to_vec()
+            sanitized_value.serialize_to_vec()?
         } else {
-            value.serialize_to_vec()
+            value.serialize_to_vec()?
         };
 
         let size = serialized.len() as u64;
         let hex_serialized = to_hex(serialized.as_slice());
-        self.store.put(&key, &hex_serialized);
+        self.store.put(&key, &hex_serialized)?;
 
         Ok(pre_sanitized_size.unwrap_or(size))
     }
@@ -528,7 +534,7 @@ impl<'a> ClarityDatabase<'a> {
             .map_err(|e| InterpreterError::DBError(e.to_string()).into())
     }
 
-    pub fn get_with_proof<T>(&mut self, key: &str) -> Option<(T, Vec<u8>)>
+    pub fn get_with_proof<T>(&mut self, key: &str) -> Result<Option<(T, Vec<u8>)>>
     where
         T: ClarityDeserializable<T>,
     {
@@ -570,15 +576,15 @@ impl<'a> ClarityDatabase<'a> {
     ) -> Result<()> {
         let hash = Sha512Trunc256Sum::from_data(contract_content.as_bytes());
         self.store
-            .prepare_for_contract_metadata(contract_identifier, hash);
+            .prepare_for_contract_metadata(contract_identifier, hash)?;
         // insert contract-size
         let key = ClarityDatabase::make_metadata_key(StoreType::Contract, "contract-size");
-        self.insert_metadata(contract_identifier, &key, &(contract_content.len() as u64));
+        self.insert_metadata(contract_identifier, &key, &(contract_content.len() as u64))?;
 
         // insert contract-src
         if STORE_CONTRACT_SRC_INTERFACE {
             let key = ClarityDatabase::make_metadata_key(StoreType::Contract, "contract-src");
-            self.insert_metadata(contract_identifier, &key, &contract_content.to_string());
+            self.insert_metadata(contract_identifier, &key, &contract_content.to_string())?;
         }
         Ok(())
     }
@@ -598,8 +604,10 @@ impl<'a> ClarityDatabase<'a> {
         contract_identifier: &QualifiedContractIdentifier,
         key: &str,
         data: &str,
-    ) {
-        self.store.insert_metadata(contract_identifier, key, data);
+    ) -> Result<()> {
+        self.store
+            .insert_metadata(contract_identifier, key, data)
+            .map_err(|e| e.into())
     }
 
     fn insert_metadata<T: ClaritySerializable>(
@@ -607,15 +615,17 @@ impl<'a> ClarityDatabase<'a> {
         contract_identifier: &QualifiedContractIdentifier,
         key: &str,
         data: &T,
-    ) {
+    ) -> Result<()> {
         if self.store.has_metadata_entry(contract_identifier, key) {
-            panic!(
+            Err(InterpreterError::Expect(format!(
                 "Metadata entry '{}' already exists for contract: {}",
                 key, contract_identifier
-            );
+            ))
+            .into())
         } else {
             self.store
-                .insert_metadata(contract_identifier, key, &data.serialize());
+                .insert_metadata(contract_identifier, key, &data.serialize())
+                .map_err(|e| e.into())
         }
     }
 
@@ -627,9 +637,11 @@ impl<'a> ClarityDatabase<'a> {
     where
         T: ClarityDeserializable<T>,
     {
-        self.store
-            .get_metadata(contract_identifier, key)
-            .map(|x_opt| x_opt.map(|x| T::deserialize(&x)))
+        let x_opt = self.store.get_metadata(contract_identifier, key)?;
+        match x_opt {
+            None => Ok(None),
+            Some(x) => T::deserialize(&x).map(|out| Some(out)),
+        }
     }
 
     pub fn fetch_metadata_manual<T>(
@@ -641,9 +653,13 @@ impl<'a> ClarityDatabase<'a> {
     where
         T: ClarityDeserializable<T>,
     {
-        self.store
-            .get_metadata_manual(at_height, contract_identifier, key)
-            .map(|x_opt| x_opt.map(|x| T::deserialize(&x)))
+        let x_opt = self
+            .store
+            .get_metadata_manual(at_height, contract_identifier, key)?;
+        match x_opt {
+            None => Ok(None),
+            Some(x) => T::deserialize(&x).map(|out| Some(out)),
+        }
     }
 
     // load contract analysis stored by an analysis_db instance.
@@ -653,13 +669,17 @@ impl<'a> ClarityDatabase<'a> {
     pub fn load_contract_analysis(
         &mut self,
         contract_identifier: &QualifiedContractIdentifier,
-    ) -> Option<ContractAnalysis> {
-        self.store
+    ) -> Result<Option<ContractAnalysis>> {
+        let x_opt = self
+            .store
             .get_metadata(contract_identifier, AnalysisDatabase::storage_key())
             // treat NoSuchContract error thrown by get_metadata as an Option::None --
             //    the analysis will propagate that as a CheckError anyways.
-            .ok()?
-            .map(|x| ContractAnalysis::deserialize(&x))
+            .ok();
+        match x_opt.flatten() {
+            None => Ok(None),
+            Some(x) => ContractAnalysis::deserialize(&x).map(|out| Some(out)),
+        }
     }
 
     pub fn get_contract_size(
@@ -667,13 +687,21 @@ impl<'a> ClarityDatabase<'a> {
         contract_identifier: &QualifiedContractIdentifier,
     ) -> Result<u64> {
         let key = ClarityDatabase::make_metadata_key(StoreType::Contract, "contract-size");
-        let contract_size: u64 = self.fetch_metadata(contract_identifier, &key)?.expect(
-            "Failed to read non-consensus contract metadata, even though contract exists in MARF.",
-        );
+        let contract_size: u64 =
+            self.fetch_metadata(contract_identifier, &key)?
+                .ok_or_else(|| {
+                    InterpreterError::Expect(
+            "Failed to read non-consensus contract metadata, even though contract exists in MARF."
+        .into())
+                })?;
         let key = ClarityDatabase::make_metadata_key(StoreType::Contract, "contract-data-size");
-        let data_size: u64 = self.fetch_metadata(contract_identifier, &key)?.expect(
-            "Failed to read non-consensus contract metadata, even though contract exists in MARF.",
-        );
+        let data_size: u64 = self
+            .fetch_metadata(contract_identifier, &key)?
+            .ok_or_else(|| {
+                InterpreterError::Expect(
+            "Failed to read non-consensus contract metadata, even though contract exists in MARF."
+        .into())
+            })?;
 
         // u64 overflow is _checked_ on insert into contract-data-size
         Ok(data_size + contract_size)
@@ -686,13 +714,17 @@ impl<'a> ClarityDatabase<'a> {
         data_size: u64,
     ) -> Result<()> {
         let key = ClarityDatabase::make_metadata_key(StoreType::Contract, "contract-size");
-        let contract_size: u64 = self.fetch_metadata(contract_identifier, &key)?.expect(
-            "Failed to read non-consensus contract metadata, even though contract exists in MARF.",
-        );
+        let contract_size: u64 =
+            self.fetch_metadata(contract_identifier, &key)?
+                .ok_or_else(|| {
+                    InterpreterError::Expect(
+            "Failed to read non-consensus contract metadata, even though contract exists in MARF."
+        .into())
+                })?;
         contract_size.cost_overflow_add(data_size)?;
 
         let key = ClarityDatabase::make_metadata_key(StoreType::Contract, "contract-data-size");
-        self.insert_metadata(contract_identifier, &key, &data_size);
+        self.insert_metadata(contract_identifier, &key, &data_size)?;
         Ok(())
     }
 
@@ -700,9 +732,10 @@ impl<'a> ClarityDatabase<'a> {
         &mut self,
         contract_identifier: &QualifiedContractIdentifier,
         contract: Contract,
-    ) {
+    ) -> Result<()> {
         let key = ClarityDatabase::make_metadata_key(StoreType::Contract, "contract");
-        self.insert_metadata(contract_identifier, &key, &contract);
+        self.insert_metadata(contract_identifier, &key, &contract)?;
+        Ok(())
     }
 
     pub fn has_contract(&mut self, contract_identifier: &QualifiedContractIdentifier) -> bool {
@@ -715,10 +748,11 @@ impl<'a> ClarityDatabase<'a> {
         contract_identifier: &QualifiedContractIdentifier,
     ) -> Result<Contract> {
         let key = ClarityDatabase::make_metadata_key(StoreType::Contract, "contract");
-        let mut data: Contract = self.fetch_metadata(contract_identifier, &key)?.expect(
-            "Failed to read non-consensus contract metadata, even though contract exists in MARF.",
-        );
-        data.canonicalize_types(&self.get_clarity_epoch_version());
+        let mut data: Contract = self.fetch_metadata(contract_identifier, &key)?
+            .ok_or_else(|| InterpreterError::Expect(
+                "Failed to read non-consensus contract metadata, even though contract exists in MARF."
+                .into()))?;
+        data.canonicalize_types(&self.get_clarity_epoch_version()?);
         Ok(data)
     }
 
@@ -730,57 +764,68 @@ impl<'a> ClarityDatabase<'a> {
     /// Since Clarity did not exist in stacks 1.0, the lowest valid epoch ID is stacks 2.0.
     /// The instantiation of subsequent epochs may bump up the epoch version in the clarity DB if
     /// Clarity is updated in that epoch.
-    pub fn get_clarity_epoch_version(&mut self) -> StacksEpochId {
-        match self.get(Self::clarity_state_epoch_key()) {
-            Some(x) => u32::try_into(x).expect("Bad Clarity epoch version in stored Clarity state"),
+    pub fn get_clarity_epoch_version(&mut self) -> Result<StacksEpochId> {
+        let out = match self.get(Self::clarity_state_epoch_key())? {
+            Some(x) => u32::try_into(x).map_err(|_| {
+                InterpreterError::Expect("Bad Clarity epoch version in stored Clarity state".into())
+            })?,
             None => StacksEpochId::Epoch20,
-        }
+        };
+        Ok(out)
     }
 
     /// Should be called _after_ all of the epoch's initialization has been invoked
-    pub fn set_clarity_epoch_version(&mut self, epoch: StacksEpochId) {
+    pub fn set_clarity_epoch_version(&mut self, epoch: StacksEpochId) -> Result<()> {
         self.put(Self::clarity_state_epoch_key(), &(epoch as u32))
     }
 
     /// Returns the _current_ total liquid ustx
-    pub fn get_total_liquid_ustx(&mut self) -> u128 {
-        self.get_value(
-            ClarityDatabase::ustx_liquid_supply_key(),
-            &TypeSignature::UIntType,
-            &StacksEpochId::latest(),
-        )
-        .expect("FATAL: failed to load ustx_liquid_supply Clarity key")
-        .map(|v| v.value.expect_u128())
-        .unwrap_or(0)
+    pub fn get_total_liquid_ustx(&mut self) -> Result<u128> {
+        Ok(self
+            .get_value(
+                ClarityDatabase::ustx_liquid_supply_key(),
+                &TypeSignature::UIntType,
+                &StacksEpochId::latest(),
+            )
+            .map_err(|_| {
+                InterpreterError::Expect(
+                    "FATAL: failed to load ustx_liquid_supply Clarity key".into(),
+                )
+            })?
+            .map(|v| v.value.expect_u128())
+            .transpose()?
+            .unwrap_or(0))
     }
 
-    fn set_ustx_liquid_supply(&mut self, set_to: u128) {
+    fn set_ustx_liquid_supply(&mut self, set_to: u128) -> Result<()> {
         self.put_value(
             ClarityDatabase::ustx_liquid_supply_key(),
             Value::UInt(set_to),
             // okay to pin epoch, because ustx_liquid_supply does not need to sanitize
             &StacksEpochId::Epoch21,
         )
-        .expect("FATAL: Failed to store STX liquid supply");
+        .map_err(|_| {
+            InterpreterError::Expect("FATAL: Failed to store STX liquid supply".into()).into()
+        })
     }
 
     pub fn increment_ustx_liquid_supply(&mut self, incr_by: u128) -> Result<()> {
-        let current = self.get_total_liquid_ustx();
+        let current = self.get_total_liquid_ustx()?;
         let next = current.checked_add(incr_by).ok_or_else(|| {
             error!("Overflowed `ustx-liquid-supply`");
             RuntimeErrorType::ArithmeticOverflow
         })?;
-        self.set_ustx_liquid_supply(next);
+        self.set_ustx_liquid_supply(next)?;
         Ok(())
     }
 
     pub fn decrement_ustx_liquid_supply(&mut self, decr_by: u128) -> Result<()> {
-        let current = self.get_total_liquid_ustx();
+        let current = self.get_total_liquid_ustx()?;
         let next = current.checked_sub(decr_by).ok_or_else(|| {
             error!("`stx-burn?` accepted that reduces `ustx-liquid-supply` below 0");
             RuntimeErrorType::ArithmeticUnderflow
         })?;
-        self.set_ustx_liquid_supply(next);
+        self.set_ustx_liquid_supply(next)?;
         Ok(())
     }
 
@@ -799,12 +844,17 @@ impl<'a> ClarityDatabase<'a> {
     /// Returns the ID of a *Stacks* block, by a *Stacks* block height.
     ///
     /// Fails if `block_height` >= the "currently" under construction Stacks block height.
-    pub fn get_index_block_header_hash(&mut self, block_height: u32) -> StacksBlockId {
+    pub fn get_index_block_header_hash(&mut self, block_height: u32) -> Result<StacksBlockId> {
         self.store
             .get_block_header_hash(block_height)
             // the caller is responsible for ensuring that the block_height given
             //  is < current_block_height, so this should _always_ return a value.
-            .expect("Block header hash must return for provided block height")
+            .ok_or_else(|| {
+                InterpreterError::Expect(
+                    "Block header hash must return for provided block height".into(),
+                )
+                .into()
+            })
     }
 
     /// This is the height we are currently constructing. It comes from the MARF.
@@ -825,11 +875,11 @@ impl<'a> ClarityDatabase<'a> {
 
     /// Return the height for PoX v2 -> v3 auto unlocks
     ///   from the burn state db
-    pub fn get_v2_unlock_height(&mut self) -> u32 {
-        if self.get_clarity_epoch_version() >= StacksEpochId::Epoch22 {
-            self.burn_state_db.get_v2_unlock_height()
+    pub fn get_v2_unlock_height(&mut self) -> Result<u32> {
+        if self.get_clarity_epoch_version()? >= StacksEpochId::Epoch22 {
+            Ok(self.burn_state_db.get_v2_unlock_height())
         } else {
-            u32::MAX
+            Ok(u32::MAX)
         }
     }
 
@@ -838,44 +888,52 @@ impl<'a> ClarityDatabase<'a> {
     /// This is the burnchain block height of the parent of the Stacks block at the current Stacks
     /// block height (i.e. that returned by `get_index_block_header_hash` for
     /// `get_current_block_height`).
-    pub fn get_current_burnchain_block_height(&mut self) -> u32 {
+    pub fn get_current_burnchain_block_height(&mut self) -> Result<u32> {
         let cur_stacks_height = self.store.get_current_block_height();
         let last_mined_bhh = if cur_stacks_height == 0 {
-            return self.burn_state_db.get_burn_start_height();
+            return Ok(self.burn_state_db.get_burn_start_height());
         } else {
-            self.get_index_block_header_hash(
-                cur_stacks_height
-                    .checked_sub(1)
-                    .expect("BUG: cannot eval burn-block-height in boot code"),
-            )
+            self.get_index_block_header_hash(cur_stacks_height.checked_sub(1).ok_or_else(
+                || {
+                    InterpreterError::Expect(
+                        "BUG: cannot eval burn-block-height in boot code".into(),
+                    )
+                },
+            )?)?
         };
 
         self.get_burnchain_block_height(&last_mined_bhh)
-            .expect(&format!(
-                "Block header hash '{}' must return for provided stacks block height {}",
-                &last_mined_bhh, cur_stacks_height
-            ))
+            .ok_or_else(|| {
+                InterpreterError::Expect(format!(
+                    "Block header hash '{}' must return for provided stacks block height {}",
+                    &last_mined_bhh, cur_stacks_height
+                ))
+                .into()
+            })
     }
 
-    pub fn get_block_header_hash(&mut self, block_height: u32) -> BlockHeaderHash {
-        let id_bhh = self.get_index_block_header_hash(block_height);
+    pub fn get_block_header_hash(&mut self, block_height: u32) -> Result<BlockHeaderHash> {
+        let id_bhh = self.get_index_block_header_hash(block_height)?;
         self.headers_db
             .get_stacks_block_header_hash_for_block(&id_bhh)
-            .expect("Failed to get block data.")
+            .ok_or_else(|| InterpreterError::Expect("Failed to get block data.".into()).into())
     }
 
-    pub fn get_block_time(&mut self, block_height: u32) -> u64 {
-        let id_bhh = self.get_index_block_header_hash(block_height);
+    pub fn get_block_time(&mut self, block_height: u32) -> Result<u64> {
+        let id_bhh = self.get_index_block_header_hash(block_height)?;
         self.headers_db
             .get_burn_block_time_for_block(&id_bhh)
-            .expect("Failed to get block data.")
+            .ok_or_else(|| InterpreterError::Expect("Failed to get block data.".into()).into())
     }
 
-    pub fn get_burnchain_block_header_hash(&mut self, block_height: u32) -> BurnchainHeaderHash {
-        let id_bhh = self.get_index_block_header_hash(block_height);
+    pub fn get_burnchain_block_header_hash(
+        &mut self,
+        block_height: u32,
+    ) -> Result<BurnchainHeaderHash> {
+        let id_bhh = self.get_index_block_header_hash(block_height)?;
         self.headers_db
             .get_burn_header_hash_for_block(&id_bhh)
-            .expect("Failed to get block data.")
+            .ok_or_else(|| InterpreterError::Expect("Failed to get block data.".into()).into())
     }
 
     /// 1. Get the current Stacks tip height (which is in the process of being evaluated)
@@ -883,37 +941,41 @@ impl<'a> ClarityDatabase<'a> {
     ///    This is the highest Stacks block in this fork whose consensus hash is known.
     /// 3. Resolve the parent StacksBlockId to its consensus hash
     /// 4. Resolve the consensus hash to the associated SortitionId
-    fn get_sortition_id_for_stacks_tip(&mut self) -> Option<SortitionId> {
+    fn get_sortition_id_for_stacks_tip(&mut self) -> Result<Option<SortitionId>> {
         let current_stacks_height = self.get_current_block_height();
 
         if current_stacks_height < 1 {
             // we are in the Stacks genesis block
-            return None;
+            return Ok(None);
         }
 
         // this is the StacksBlockId of the last block evaluated in this fork
-        let parent_id_bhh = self.get_index_block_header_hash(current_stacks_height - 1);
+        let parent_id_bhh = self.get_index_block_header_hash(current_stacks_height - 1)?;
 
         // infallible, since we always store the consensus hash with the StacksBlockId in the
         // headers DB
         let consensus_hash = self
             .headers_db
             .get_consensus_hash_for_block(&parent_id_bhh)
-            .expect(&format!(
-                "FATAL: no consensus hash found for StacksBlockId {}",
-                &parent_id_bhh
-            ));
+            .ok_or_else(|| {
+                InterpreterError::Expect(format!(
+                    "FATAL: no consensus hash found for StacksBlockId {}",
+                    &parent_id_bhh
+                ))
+            })?;
 
         // infallible, since every sortition has a consensus hash
         let sortition_id = self
             .burn_state_db
             .get_sortition_id_from_consensus_hash(&consensus_hash)
-            .expect(&format!(
-                "FATAL: no SortitionID found for consensus hash {}",
-                &consensus_hash
-            ));
+            .ok_or_else(|| {
+                InterpreterError::Expect(format!(
+                    "FATAL: no SortitionID found for consensus hash {}",
+                    &consensus_hash
+                ))
+            })?;
 
-        Some(sortition_id)
+        Ok(Some(sortition_id))
     }
 
     /// Fetch the burnchain block header hash for a given burnchain height.
@@ -926,10 +988,14 @@ impl<'a> ClarityDatabase<'a> {
     pub fn get_burnchain_block_header_hash_for_burnchain_height(
         &mut self,
         burnchain_block_height: u32,
-    ) -> Option<BurnchainHeaderHash> {
-        let sortition_id = self.get_sortition_id_for_stacks_tip()?;
-        self.burn_state_db
-            .get_burn_header_hash(burnchain_block_height, &sortition_id)
+    ) -> Result<Option<BurnchainHeaderHash>> {
+        let sortition_id = match self.get_sortition_id_for_stacks_tip()? {
+            Some(x) => x,
+            None => return Ok(None),
+        };
+        Ok(self
+            .burn_state_db
+            .get_burn_header_hash(burnchain_block_height, &sortition_id))
     }
 
     /// Get the PoX reward addresses and per-address payout for a given burnchain height.  Because the burnchain can fork,
@@ -937,58 +1003,73 @@ impl<'a> ClarityDatabase<'a> {
     pub fn get_pox_payout_addrs_for_burnchain_height(
         &mut self,
         burnchain_block_height: u32,
-    ) -> Option<(Vec<TupleData>, u128)> {
-        let sortition_id = self.get_sortition_id_for_stacks_tip()?;
-        self.burn_state_db
-            .get_pox_payout_addrs(burnchain_block_height, &sortition_id)
+    ) -> Result<Option<(Vec<TupleData>, u128)>> {
+        let sortition_id = match self.get_sortition_id_for_stacks_tip()? {
+            Some(x) => x,
+            None => return Ok(None),
+        };
+        Ok(self
+            .burn_state_db
+            .get_pox_payout_addrs(burnchain_block_height, &sortition_id))
     }
 
     pub fn get_burnchain_block_height(&mut self, id_bhh: &StacksBlockId) -> Option<u32> {
         self.headers_db.get_burn_block_height_for_block(id_bhh)
     }
 
-    pub fn get_block_vrf_seed(&mut self, block_height: u32) -> VRFSeed {
-        let id_bhh = self.get_index_block_header_hash(block_height);
+    pub fn get_block_vrf_seed(&mut self, block_height: u32) -> Result<VRFSeed> {
+        let id_bhh = self.get_index_block_header_hash(block_height)?;
         self.headers_db
             .get_vrf_seed_for_block(&id_bhh)
-            .expect("Failed to get block data.")
+            .ok_or_else(|| InterpreterError::Expect("Failed to get block data.".into()).into())
     }
 
-    pub fn get_miner_address(&mut self, block_height: u32) -> StandardPrincipalData {
-        let id_bhh = self.get_index_block_header_hash(block_height);
-        self.headers_db
+    pub fn get_miner_address(&mut self, block_height: u32) -> Result<StandardPrincipalData> {
+        let id_bhh = self.get_index_block_header_hash(block_height)?;
+        Ok(self
+            .headers_db
             .get_miner_address(&id_bhh)
-            .expect("Failed to get block data.")
-            .into()
+            .ok_or_else(|| InterpreterError::Expect("Failed to get block data.".into()))?
+            .into())
     }
 
-    pub fn get_miner_spend_winner(&mut self, block_height: u32) -> u128 {
+    pub fn get_miner_spend_winner(&mut self, block_height: u32) -> Result<u128> {
         if block_height == 0 {
-            return 0;
+            return Ok(0);
         }
 
-        let id_bhh = self.get_index_block_header_hash(block_height);
-        self.headers_db
+        let id_bhh = self.get_index_block_header_hash(block_height)?;
+        Ok(self
+            .headers_db
             .get_burnchain_tokens_spent_for_winning_block(&id_bhh)
-            .expect("FATAL: no winning burnchain token spend record for block")
-            .into()
+            .ok_or_else(|| {
+                InterpreterError::Expect(
+                    "FATAL: no winning burnchain token spend record for block".into(),
+                )
+            })?
+            .into())
     }
 
-    pub fn get_miner_spend_total(&mut self, block_height: u32) -> u128 {
+    pub fn get_miner_spend_total(&mut self, block_height: u32) -> Result<u128> {
         if block_height == 0 {
-            return 0;
+            return Ok(0);
         }
 
-        let id_bhh = self.get_index_block_header_hash(block_height);
-        self.headers_db
+        let id_bhh = self.get_index_block_header_hash(block_height)?;
+        Ok(self
+            .headers_db
             .get_burnchain_tokens_spent_for_block(&id_bhh)
-            .expect("FATAL: no total burnchain token spend record for block")
-            .into()
+            .ok_or_else(|| {
+                InterpreterError::Expect(
+                    "FATAL: no total burnchain token spend record for block".into(),
+                )
+            })?
+            .into())
     }
 
-    pub fn get_block_reward(&mut self, block_height: u32) -> Option<u128> {
+    pub fn get_block_reward(&mut self, block_height: u32) -> Result<Option<u128>> {
         if block_height == 0 {
-            return None;
+            return Ok(None);
         }
 
         let cur_height: u64 = self.get_current_block_height().into();
@@ -996,26 +1077,29 @@ impl<'a> ClarityDatabase<'a> {
         // reward for the *child* of this block must have matured, since that determines the
         // streamed tx fee reward portion
         if ((block_height + 1) as u64) + MINER_REWARD_MATURITY >= cur_height {
-            return None;
+            return Ok(None);
         }
 
-        let id_bhh = self.get_index_block_header_hash(block_height);
+        let id_bhh = self.get_index_block_header_hash(block_height)?;
         let reward: u128 = self
             .headers_db
             .get_tokens_earned_for_block(&id_bhh)
             .map(|x| x.into())
-            .expect("FATAL: matured block has no recorded reward");
+            .ok_or_else(|| {
+                InterpreterError::Expect("FATAL: matured block has no recorded reward".into())
+            })?;
 
-        Some(reward)
+        Ok(Some(reward))
     }
 
-    pub fn get_stx_btc_ops_processed(&mut self) -> u64 {
-        self.get("vm_pox::stx_btc_ops::processed_blocks")
-            .unwrap_or(0)
+    pub fn get_stx_btc_ops_processed(&mut self) -> Result<u64> {
+        Ok(self
+            .get("vm_pox::stx_btc_ops::processed_blocks")?
+            .unwrap_or(0))
     }
 
-    pub fn set_stx_btc_ops_processed(&mut self, processed: u64) {
-        self.put("vm_pox::stx_btc_ops::processed_blocks", &processed);
+    pub fn set_stx_btc_ops_processed(&mut self, processed: u64) -> Result<()> {
+        self.put("vm_pox::stx_btc_ops::processed_blocks", &processed)
     }
 }
 
@@ -1037,8 +1121,7 @@ impl<'a> ClarityDatabase<'a> {
     ) -> Result<()> {
         let key = ClarityDatabase::make_microblock_pubkey_height_key(pubkey_hash);
         let value = format!("{}", &height);
-        self.put(&key, &value);
-        Ok(())
+        self.put(&key, &value)
     }
 
     pub fn get_cc_special_cases_handler(&self) -> Option<SpecialCaseHandler> {
@@ -1055,64 +1138,95 @@ impl<'a> ClarityDatabase<'a> {
         let value = Value::Tuple(
             TupleData::from_data(vec![
                 (
-                    ClarityName::try_from("reporter").expect("BUG: valid string representation"),
+                    ClarityName::try_from("reporter").map_err(|_| {
+                        InterpreterError::Expect("BUG: valid string representation".into())
+                    })?,
                     Value::Principal(PrincipalData::Standard(reporter.clone())),
                 ),
                 (
-                    ClarityName::try_from("sequence").expect("BUG: valid string representation"),
+                    ClarityName::try_from("sequence").map_err(|_| {
+                        InterpreterError::Expect("BUG: valid string representation".into())
+                    })?,
                     Value::UInt(seq as u128),
                 ),
             ])
-            .expect("BUG: valid tuple representation"),
+            .map_err(|_| InterpreterError::Expect("BUG: valid tuple representation".into()))?,
         );
         let mut value_bytes = vec![];
-        value
-            .serialize_write(&mut value_bytes)
-            .expect("BUG: valid tuple representation did not serialize");
+        value.serialize_write(&mut value_bytes).map_err(|_| {
+            InterpreterError::Expect("BUG: valid tuple representation did not serialize".into())
+        })?;
 
         let value_str = to_hex(&value_bytes);
-        self.put(&key, &value_str);
-        Ok(())
+        self.put(&key, &value_str)
     }
 
-    pub fn get_microblock_pubkey_hash_height(&mut self, pubkey_hash: &Hash160) -> Option<u32> {
+    pub fn get_microblock_pubkey_hash_height(
+        &mut self,
+        pubkey_hash: &Hash160,
+    ) -> Result<Option<u32>> {
         let key = ClarityDatabase::make_microblock_pubkey_height_key(pubkey_hash);
-        self.get(&key).map(|height_str: String| {
-            height_str
-                .parse::<u32>()
-                .expect("BUG: inserted non-u32 as height of microblock pubkey hash")
-        })
+        self.get(&key)?
+            .map(|height_str: String| {
+                height_str.parse::<u32>().map_err(|_| {
+                    InterpreterError::Expect(
+                        "BUG: inserted non-u32 as height of microblock pubkey hash".into(),
+                    )
+                    .into()
+                })
+            })
+            .transpose()
     }
 
     /// Returns (who-reported-the-poison-microblock, sequence-of-microblock-fork)
     pub fn get_microblock_poison_report(
         &mut self,
         height: u32,
-    ) -> Option<(StandardPrincipalData, u16)> {
+    ) -> Result<Option<(StandardPrincipalData, u16)>> {
         let key = ClarityDatabase::make_microblock_poison_key(height);
-        self.get(&key).map(|reporter_hex_str: String| {
-            let reporter_value = Value::try_deserialize_hex_untyped(&reporter_hex_str)
-                .expect("BUG: failed to decode serialized poison-microblock reporter");
-            let tuple_data = reporter_value.expect_tuple();
-            let reporter_value = tuple_data
-                .get("reporter")
-                .expect("BUG: poison-microblock report has no 'reporter'")
-                .to_owned();
-            let seq_value = tuple_data
-                .get("sequence")
-                .expect("BUG: poison-microblock report has no 'sequence'")
-                .to_owned();
-
-            let reporter_principal = reporter_value.expect_principal();
-            let seq_u128 = seq_value.expect_u128();
-
-            let seq: u16 = seq_u128.try_into().expect("BUG: seq exceeds u16 max");
-            if let PrincipalData::Standard(principal_data) = reporter_principal {
-                (principal_data, seq)
-            } else {
-                panic!("BUG: poison-microblock report principal is not a standard principal");
-            }
-        })
+        self.get(&key)?
+            .map(|reporter_hex_str: String| {
+                let reporter_value = Value::try_deserialize_hex_untyped(&reporter_hex_str)
+                    .map_err(|_| {
+                        InterpreterError::Expect(
+                            "BUG: failed to decode serialized poison-microblock reporter".into(),
+                        )
+                    })?;
+                let tuple_data = reporter_value.expect_tuple()?;
+                let reporter_value = tuple_data
+                    .get("reporter")
+                    .map_err(|_| {
+                        InterpreterError::Expect(
+                            "BUG: poison-microblock report has no 'reporter'".into(),
+                        )
+                    })?
+                    .to_owned();
+                let seq_value = tuple_data
+                    .get("sequence")
+                    .map_err(|_| {
+                        InterpreterError::Expect(
+                            "BUG: poison-microblock report has no 'sequence'".into(),
+                        )
+                    })?
+                    .to_owned();
+
+                let reporter_principal = reporter_value.expect_principal()?;
+                let seq_u128 = seq_value.expect_u128()?;
+
+                let seq: u16 = seq_u128
+                    .try_into()
+                    .map_err(|_| InterpreterError::Expect("BUG: seq exceeds u16 max".into()))?;
+                if let PrincipalData::Standard(principal_data) = reporter_principal {
+                    Ok((principal_data, seq))
+                } else {
+                    return Err(InterpreterError::Expect(
+                        "BUG: poison-microblock report principal is not a standard principal"
+                            .into(),
+                    )
+                    .into());
+                }
+            })
+            .transpose()
     }
 }
 
@@ -1132,12 +1246,12 @@ impl<'a> ClarityDatabase<'a> {
         contract_identifier: &QualifiedContractIdentifier,
         variable_name: &str,
         value_type: TypeSignature,
-    ) -> DataVariableMetadata {
+    ) -> Result<DataVariableMetadata> {
         let variable_data = DataVariableMetadata { value_type };
         let key = ClarityDatabase::make_metadata_key(StoreType::VariableMeta, variable_name);
 
-        self.insert_metadata(contract_identifier, &key, &variable_data);
-        variable_data
+        self.insert_metadata(contract_identifier, &key, &variable_data)?;
+        Ok(variable_data)
     }
 
     pub fn load_variable(
@@ -1179,7 +1293,7 @@ impl<'a> ClarityDatabase<'a> {
     ) -> Result<ValueResult> {
         if !variable_descriptor
             .value_type
-            .admits(&self.get_clarity_epoch_version(), &value)?
+            .admits(&self.get_clarity_epoch_version()?, &value)?
         {
             return Err(
                 CheckErrors::TypeValueError(variable_descriptor.value_type.clone(), value).into(),
@@ -1266,16 +1380,16 @@ impl<'a> ClarityDatabase<'a> {
         map_name: &str,
         key_type: TypeSignature,
         value_type: TypeSignature,
-    ) -> DataMapMetadata {
+    ) -> Result<DataMapMetadata> {
         let data = DataMapMetadata {
             key_type,
             value_type,
         };
 
         let key = ClarityDatabase::make_metadata_key(StoreType::DataMapMeta, map_name);
-        self.insert_metadata(contract_identifier, &key, &data);
+        self.insert_metadata(contract_identifier, &key, &data)?;
 
-        data
+        Ok(data)
     }
 
     pub fn load_map(
@@ -1293,12 +1407,12 @@ impl<'a> ClarityDatabase<'a> {
         contract_identifier: &QualifiedContractIdentifier,
         map_name: &str,
         key_value: &Value,
-    ) -> String {
-        ClarityDatabase::make_key_for_data_map_entry_serialized(
+    ) -> Result<String> {
+        Ok(ClarityDatabase::make_key_for_data_map_entry_serialized(
             contract_identifier,
             map_name,
-            &key_value.serialize_to_hex(),
-        )
+            &key_value.serialize_to_hex()?,
+        ))
     }
 
     fn make_key_for_data_map_entry_serialized(
@@ -1336,7 +1450,7 @@ impl<'a> ClarityDatabase<'a> {
     ) -> Result<Value> {
         if !map_descriptor
             .key_type
-            .admits(&self.get_clarity_epoch_version(), key_value)?
+            .admits(&self.get_clarity_epoch_version()?, key_value)?
         {
             return Err(CheckErrors::TypeValueError(
                 map_descriptor.key_type.clone(),
@@ -1346,7 +1460,7 @@ impl<'a> ClarityDatabase<'a> {
         }
 
         let key =
-            ClarityDatabase::make_key_for_data_map_entry(contract_identifier, map_name, key_value);
+            ClarityDatabase::make_key_for_data_map_entry(contract_identifier, map_name, key_value)?;
 
         let stored_type = TypeSignature::new_option(map_descriptor.value_type.clone())?;
         let result = self.get_value(&key, &stored_type, epoch)?;
@@ -1367,7 +1481,7 @@ impl<'a> ClarityDatabase<'a> {
     ) -> Result<ValueResult> {
         if !map_descriptor
             .key_type
-            .admits(&self.get_clarity_epoch_version(), key_value)?
+            .admits(&self.get_clarity_epoch_version()?, key_value)?
         {
             return Err(CheckErrors::TypeValueError(
                 map_descriptor.key_type.clone(),
@@ -1376,7 +1490,7 @@ impl<'a> ClarityDatabase<'a> {
             .into());
         }
 
-        let key_serialized = key_value.serialize_to_hex();
+        let key_serialized = key_value.serialize_to_hex()?;
         let key = ClarityDatabase::make_key_for_data_map_entry_serialized(
             contract_identifier,
             map_name,
@@ -1398,7 +1512,9 @@ impl<'a> ClarityDatabase<'a> {
                 value,
                 serialized_byte_len: serialized_byte_len
                     .checked_add(byte_len_of_serialization(&key_serialized))
-                    .expect("Overflowed Clarity key/value size"),
+                    .ok_or_else(|| {
+                        InterpreterError::Expect("Overflowed Clarity key/value size".into())
+                    })?,
             }),
         }
     }
@@ -1507,7 +1623,7 @@ impl<'a> ClarityDatabase<'a> {
     ) -> Result<ValueResult> {
         if !map_descriptor
             .key_type
-            .admits(&self.get_clarity_epoch_version(), &key_value)?
+            .admits(&self.get_clarity_epoch_version()?, &key_value)?
         {
             return Err(
                 CheckErrors::TypeValueError(map_descriptor.key_type.clone(), key_value).into(),
@@ -1515,14 +1631,14 @@ impl<'a> ClarityDatabase<'a> {
         }
         if !map_descriptor
             .value_type
-            .admits(&self.get_clarity_epoch_version(), &value)?
+            .admits(&self.get_clarity_epoch_version()?, &value)?
         {
             return Err(
                 CheckErrors::TypeValueError(map_descriptor.value_type.clone(), value).into(),
             );
         }
 
-        let key_serialized = key_value.serialize_to_hex();
+        let key_serialized = key_value.serialize_to_hex()?;
         let key_serialized_byte_len = byte_len_of_serialization(&key_serialized);
         let key = ClarityDatabase::make_key_for_quad(
             contract_identifier,
@@ -1546,7 +1662,9 @@ impl<'a> ClarityDatabase<'a> {
             value: Value::Bool(true),
             serialized_byte_len: key_serialized_byte_len
                 .checked_add(placed_size)
-                .expect("Overflowed Clarity key/value size"),
+                .ok_or_else(|| {
+                    InterpreterError::Expect("Overflowed Clarity key/value size".into())
+                })?,
         })
     }
 
@@ -1560,7 +1678,7 @@ impl<'a> ClarityDatabase<'a> {
     ) -> Result<ValueResult> {
         if !map_descriptor
             .key_type
-            .admits(&self.get_clarity_epoch_version(), key_value)?
+            .admits(&self.get_clarity_epoch_version()?, key_value)?
         {
             return Err(CheckErrors::TypeValueError(
                 map_descriptor.key_type.clone(),
@@ -1569,7 +1687,7 @@ impl<'a> ClarityDatabase<'a> {
             .into());
         }
 
-        let key_serialized = key_value.serialize_to_hex();
+        let key_serialized = key_value.serialize_to_hex()?;
         let key_serialized_byte_len = byte_len_of_serialization(&key_serialized);
         let key = ClarityDatabase::make_key_for_quad(
             contract_identifier,
@@ -1591,7 +1709,9 @@ impl<'a> ClarityDatabase<'a> {
             value: Value::Bool(true),
             serialized_byte_len: key_serialized_byte_len
                 .checked_add(*NONE_SERIALIZATION_LEN)
-                .expect("Overflowed Clarity key/value size"),
+                .ok_or_else(|| {
+                    InterpreterError::Expect("Overflowed Clarity key/value size".into())
+                })?,
         })
     }
 }
@@ -1604,13 +1724,13 @@ impl<'a> ClarityDatabase<'a> {
         contract_identifier: &QualifiedContractIdentifier,
         token_name: &str,
         total_supply: &Option<u128>,
-    ) -> FungibleTokenMetadata {
+    ) -> Result<FungibleTokenMetadata> {
         let data = FungibleTokenMetadata {
             total_supply: total_supply.clone(),
         };
 
         let key = ClarityDatabase::make_metadata_key(StoreType::FungibleTokenMeta, token_name);
-        self.insert_metadata(contract_identifier, &key, &data);
+        self.insert_metadata(contract_identifier, &key, &data)?;
 
         // total supply _is_ included in the consensus hash
         let supply_key = ClarityDatabase::make_key_for_trip(
@@ -1618,9 +1738,9 @@ impl<'a> ClarityDatabase<'a> {
             StoreType::CirculatingSupply,
             token_name,
         );
-        self.put(&supply_key, &(0 as u128));
+        self.put(&supply_key, &(0 as u128))?;
 
-        data
+        Ok(data)
     }
 
     pub fn load_ft(
@@ -1639,14 +1759,14 @@ impl<'a> ClarityDatabase<'a> {
         contract_identifier: &QualifiedContractIdentifier,
         token_name: &str,
         key_type: &TypeSignature,
-    ) -> NonFungibleTokenMetadata {
+    ) -> Result<NonFungibleTokenMetadata> {
         let data = NonFungibleTokenMetadata {
             key_type: key_type.clone(),
         };
         let key = ClarityDatabase::make_metadata_key(StoreType::NonFungibleTokenMeta, token_name);
-        self.insert_metadata(contract_identifier, &key, &data);
+        self.insert_metadata(contract_identifier, &key, &data)?;
 
-        data
+        Ok(data)
     }
 
     fn load_nft(
@@ -1672,9 +1792,9 @@ impl<'a> ClarityDatabase<'a> {
             StoreType::CirculatingSupply,
             token_name,
         );
-        let current_supply: u128 = self
-            .get(&key)
-            .expect("ERROR: Clarity VM failed to track token supply.");
+        let current_supply: u128 = self.get(&key)?.ok_or_else(|| {
+            InterpreterError::Expect("ERROR: Clarity VM failed to track token supply.".into())
+        })?;
 
         let new_supply = current_supply
             .checked_add(amount)
@@ -1686,8 +1806,7 @@ impl<'a> ClarityDatabase<'a> {
             }
         }
 
-        self.put(&key, &new_supply);
-        Ok(())
+        self.put(&key, &new_supply)
     }
 
     pub fn checked_decrease_token_supply(
@@ -1701,9 +1820,9 @@ impl<'a> ClarityDatabase<'a> {
             StoreType::CirculatingSupply,
             token_name,
         );
-        let current_supply: u128 = self
-            .get(&key)
-            .expect("ERROR: Clarity VM failed to track token supply.");
+        let current_supply: u128 = self.get(&key)?.ok_or_else(|| {
+            InterpreterError::Expect("ERROR: Clarity VM failed to track token supply.".into())
+        })?;
 
         if amount > current_supply {
             return Err(RuntimeErrorType::SupplyUnderflow(current_supply, amount).into());
@@ -1711,8 +1830,7 @@ impl<'a> ClarityDatabase<'a> {
 
         let new_supply = current_supply - amount;
 
-        self.put(&key, &new_supply);
-        Ok(())
+        self.put(&key, &new_supply)
     }
 
     pub fn get_ft_balance(
@@ -1733,7 +1851,7 @@ impl<'a> ClarityDatabase<'a> {
             &principal.serialize(),
         );
 
-        let result = self.get(&key);
+        let result = self.get(&key)?;
         match result {
             None => Ok(0),
             Some(balance) => Ok(balance),
@@ -1753,9 +1871,7 @@ impl<'a> ClarityDatabase<'a> {
             token_name,
             &principal.serialize(),
         );
-        self.put(&key, &balance);
-
-        Ok(())
+        self.put(&key, &balance)
     }
 
     pub fn get_ft_supply(
@@ -1768,9 +1884,9 @@ impl<'a> ClarityDatabase<'a> {
             StoreType::CirculatingSupply,
             token_name,
         );
-        let supply = self
-            .get(&key)
-            .expect("ERROR: Clarity VM failed to track token supply.");
+        let supply = self.get(&key)?.ok_or_else(|| {
+            InterpreterError::Expect("ERROR: Clarity VM failed to track token supply.".into())
+        })?;
         Ok(supply)
     }
 
@@ -1781,7 +1897,7 @@ impl<'a> ClarityDatabase<'a> {
         asset: &Value,
         key_type: &TypeSignature,
     ) -> Result<PrincipalData> {
-        if !key_type.admits(&self.get_clarity_epoch_version(), asset)? {
+        if !key_type.admits(&self.get_clarity_epoch_version()?, asset)? {
             return Err(CheckErrors::TypeValueError(key_type.clone(), (*asset).clone()).into());
         }
 
@@ -1789,22 +1905,23 @@ impl<'a> ClarityDatabase<'a> {
             contract_identifier,
             StoreType::NonFungibleToken,
             asset_name,
-            &asset.serialize_to_hex(),
+            &asset.serialize_to_hex()?,
         );
 
-        let epoch = self.get_clarity_epoch_version();
+        let epoch = self.get_clarity_epoch_version()?;
         let value: Option<ValueResult> = self.get_value(
             &key,
-            &TypeSignature::new_option(TypeSignature::PrincipalType).unwrap(),
+            &TypeSignature::new_option(TypeSignature::PrincipalType)
+                .map_err(|_| InterpreterError::Expect("Unexpected type failure".into()))?,
             &epoch,
         )?;
         let owner = match value {
-            Some(owner) => owner.value.expect_optional(),
+            Some(owner) => owner.value.expect_optional()?,
             None => return Err(RuntimeErrorType::NoSuchToken.into()),
         };
 
         let principal = match owner {
-            Some(value) => value.expect_principal(),
+            Some(value) => value.expect_principal()?,
             None => return Err(RuntimeErrorType::NoSuchToken.into()),
         };
 
@@ -1829,7 +1946,7 @@ impl<'a> ClarityDatabase<'a> {
         key_type: &TypeSignature,
         epoch: &StacksEpochId,
     ) -> Result<()> {
-        if !key_type.admits(&self.get_clarity_epoch_version(), asset)? {
+        if !key_type.admits(&self.get_clarity_epoch_version()?, asset)? {
             return Err(CheckErrors::TypeValueError(key_type.clone(), (*asset).clone()).into());
         }
 
@@ -1837,7 +1954,7 @@ impl<'a> ClarityDatabase<'a> {
             contract_identifier,
             StoreType::NonFungibleToken,
             asset_name,
-            &asset.serialize_to_hex(),
+            &asset.serialize_to_hex()?,
         );
 
         let value = Value::some(Value::Principal(principal.clone()))?;
@@ -1854,7 +1971,7 @@ impl<'a> ClarityDatabase<'a> {
         key_type: &TypeSignature,
         epoch: &StacksEpochId,
     ) -> Result<()> {
-        if !key_type.admits(&self.get_clarity_epoch_version(), asset)? {
+        if !key_type.admits(&self.get_clarity_epoch_version()?, asset)? {
             return Err(CheckErrors::TypeValueError(key_type.clone(), (*asset).clone()).into());
         }
 
@@ -1862,7 +1979,7 @@ impl<'a> ClarityDatabase<'a> {
             contract_identifier,
             StoreType::NonFungibleToken,
             asset_name,
-            &asset.serialize_to_hex(),
+            &asset.serialize_to_hex()?,
         );
 
         self.put_value(&key, Value::none(), epoch)?;
@@ -1895,9 +2012,9 @@ impl<'a> ClarityDatabase<'a> {
     pub fn get_stx_balance_snapshot<'conn>(
         &'conn mut self,
         principal: &PrincipalData,
-    ) -> STXBalanceSnapshot<'a, 'conn> {
-        let stx_balance = self.get_account_stx_balance(principal);
-        let cur_burn_height = self.get_current_burnchain_block_height() as u64;
+    ) -> Result<STXBalanceSnapshot<'a, 'conn>> {
+        let stx_balance = self.get_account_stx_balance(principal)?;
+        let cur_burn_height = u64::from(self.get_current_burnchain_block_height()?);
 
         test_debug!("Balance of {} (raw={},locked={},unlock-height={},current-height={}) is {} (has_unlockable_tokens_at_burn_block={})",
             principal,
@@ -1905,17 +2022,22 @@ impl<'a> ClarityDatabase<'a> {
             stx_balance.amount_locked(),
             stx_balance.unlock_height(),
             cur_burn_height,
-            stx_balance.get_available_balance_at_burn_block(cur_burn_height, self.get_v1_unlock_height(), self.get_v2_unlock_height()),
-            stx_balance.has_unlockable_tokens_at_burn_block(cur_burn_height, self.get_v1_unlock_height(), self.get_v2_unlock_height()));
+            stx_balance.get_available_balance_at_burn_block(cur_burn_height, self.get_v1_unlock_height(), self.get_v2_unlock_height()?)?,
+            stx_balance.has_unlockable_tokens_at_burn_block(cur_burn_height, self.get_v1_unlock_height(), self.get_v2_unlock_height()?));
 
-        STXBalanceSnapshot::new(principal, stx_balance, cur_burn_height, self)
+        Ok(STXBalanceSnapshot::new(
+            principal,
+            stx_balance,
+            cur_burn_height,
+            self,
+        ))
     }
 
     pub fn get_stx_balance_snapshot_genesis<'conn>(
         &'conn mut self,
         principal: &PrincipalData,
-    ) -> STXBalanceSnapshot<'a, 'conn> {
-        let stx_balance = self.get_account_stx_balance(principal);
+    ) -> Result<STXBalanceSnapshot<'a, 'conn>> {
+        let stx_balance = self.get_account_stx_balance(principal)?;
         let cur_burn_height = 0;
 
         test_debug!("Balance of {} (raw={},locked={},unlock-height={},current-height={}) is {} (has_unlockable_tokens_at_burn_block={})",
@@ -1924,34 +2046,39 @@ impl<'a> ClarityDatabase<'a> {
             stx_balance.amount_locked(),
             stx_balance.unlock_height(),
             cur_burn_height,
-            stx_balance.get_available_balance_at_burn_block(cur_burn_height, self.get_v1_unlock_height(), self.get_v2_unlock_height()),
-            stx_balance.has_unlockable_tokens_at_burn_block(cur_burn_height, self.get_v1_unlock_height(), self.get_v2_unlock_height()));
+            stx_balance.get_available_balance_at_burn_block(cur_burn_height, self.get_v1_unlock_height(), self.get_v2_unlock_height()?)?,
+            stx_balance.has_unlockable_tokens_at_burn_block(cur_burn_height, self.get_v1_unlock_height(), self.get_v2_unlock_height()?));
 
-        STXBalanceSnapshot::new(principal, stx_balance, cur_burn_height, self)
+        Ok(STXBalanceSnapshot::new(
+            principal,
+            stx_balance,
+            cur_burn_height,
+            self,
+        ))
     }
 
-    pub fn get_account_stx_balance(&mut self, principal: &PrincipalData) -> STXBalance {
+    pub fn get_account_stx_balance(&mut self, principal: &PrincipalData) -> Result<STXBalance> {
         let key = ClarityDatabase::make_key_for_account_balance(principal);
         debug!("Fetching account balance"; "principal" => %principal.to_string());
-        let result = self.get(&key);
-        match result {
+        let result = self.get(&key)?;
+        Ok(match result {
             None => STXBalance::zero(),
             Some(balance) => balance,
-        }
+        })
     }
 
-    pub fn get_account_nonce(&mut self, principal: &PrincipalData) -> u64 {
+    pub fn get_account_nonce(&mut self, principal: &PrincipalData) -> Result<u64> {
         let key = ClarityDatabase::make_key_for_account_nonce(principal);
-        let result = self.get(&key);
-        match result {
+        let result = self.get(&key)?;
+        Ok(match result {
             None => 0,
             Some(nonce) => nonce,
-        }
+        })
     }
 
-    pub fn set_account_nonce(&mut self, principal: &PrincipalData, nonce: u64) {
+    pub fn set_account_nonce(&mut self, principal: &PrincipalData, nonce: u64) -> Result<()> {
         let key = ClarityDatabase::make_key_for_account_nonce(principal);
-        self.put(&key, &nonce);
+        self.put(&key, &nonce)
     }
 }
 
diff --git a/clarity/src/vm/database/clarity_store.rs b/clarity/src/vm/database/clarity_store.rs
index a6bf017ccc..3cf9bedf8a 100644
--- a/clarity/src/vm/database/clarity_store.rs
+++ b/clarity/src/vm/database/clarity_store.rs
@@ -61,14 +61,14 @@ pub type SpecialCaseHandler = &'static dyn Fn(
 //    attempt to continue processing in the event of an unexpected storage error.
 pub trait ClarityBackingStore {
     /// put K-V data into the committed datastore
-    fn put_all(&mut self, items: Vec<(String, String)>);
+    fn put_all(&mut self, items: Vec<(String, String)>) -> Result<()>;
     /// fetch K-V out of the committed datastore
-    fn get(&mut self, key: &str) -> Option<String>;
+    fn get(&mut self, key: &str) -> Result<Option<String>>;
     /// fetch K-V out of the committed datastore, along with the byte representation
     ///  of the Merkle proof for that key-value pair
-    fn get_with_proof(&mut self, key: &str) -> Option<(String, Vec<u8>)>;
-    fn has_entry(&mut self, key: &str) -> bool {
-        self.get(key).is_some()
+    fn get_with_proof(&mut self, key: &str) -> Result<Option<(String, Vec<u8>)>>;
+    fn has_entry(&mut self, key: &str) -> Result<bool> {
+        Ok(self.get(key)?.is_some())
     }
 
     /// change the current MARF context to service reads from a different chain_tip
@@ -112,19 +112,24 @@ pub trait ClarityBackingStore {
     ) -> Result<(StacksBlockId, Sha512Trunc256Sum)> {
         let key = make_contract_hash_key(contract);
         let contract_commitment = self
-            .get(&key)
+            .get(&key)?
             .map(|x| ContractCommitment::deserialize(&x))
             .ok_or_else(|| CheckErrors::NoSuchContract(contract.to_string()))?;
         let ContractCommitment {
             block_height,
             hash: contract_hash,
-        } = contract_commitment;
+        } = contract_commitment?;
         let bhh = self.get_block_at_height(block_height)
-            .expect("Should always be able to map from height to block hash when looking up contract information.");
+            .ok_or_else(|| InterpreterError::Expect("Should always be able to map from height to block hash when looking up contract information.".into()))?;
         Ok((bhh, contract_hash))
     }
 
-    fn insert_metadata(&mut self, contract: &QualifiedContractIdentifier, key: &str, value: &str) {
+    fn insert_metadata(
+        &mut self,
+        contract: &QualifiedContractIdentifier,
+        key: &str,
+        value: &str,
+    ) -> Result<()> {
         let bhh = self.get_open_chain_tip();
         SqliteConnection::insert_metadata(
             self.get_side_store(),
@@ -141,12 +146,7 @@ pub trait ClarityBackingStore {
         key: &str,
     ) -> Result<Option<String>> {
         let (bhh, _) = self.get_contract_hash(contract)?;
-        Ok(SqliteConnection::get_metadata(
-            self.get_side_store(),
-            &bhh,
-            &contract.to_string(),
-            key,
-        ))
+        SqliteConnection::get_metadata(self.get_side_store(), &bhh, &contract.to_string(), key)
     }
 
     fn get_metadata_manual(
@@ -160,18 +160,17 @@ pub trait ClarityBackingStore {
                 warn!("Unknown block height when manually querying metadata"; "block_height" => at_height);
                 RuntimeErrorType::BadBlockHeight(at_height.to_string())
             })?;
-        Ok(SqliteConnection::get_metadata(
-            self.get_side_store(),
-            &bhh,
-            &contract.to_string(),
-            key,
-        ))
+        SqliteConnection::get_metadata(self.get_side_store(), &bhh, &contract.to_string(), key)
     }
 
-    fn put_all_metadata(&mut self, items: Vec<((QualifiedContractIdentifier, String), String)>) {
+    fn put_all_metadata(
+        &mut self,
+        items: Vec<((QualifiedContractIdentifier, String), String)>,
+    ) -> Result<()> {
         for ((contract, key), value) in items.into_iter() {
-            self.insert_metadata(&contract, &key, &value);
+            self.insert_metadata(&contract, &key, &value)?;
         }
+        Ok(())
     }
 }
 
@@ -192,12 +191,21 @@ impl ClaritySerializable for ContractCommitment {
 }
 
 impl ClarityDeserializable<ContractCommitment> for ContractCommitment {
-    fn deserialize(input: &str) -> ContractCommitment {
-        assert_eq!(input.len(), 72);
-        let hash = Sha512Trunc256Sum::from_hex(&input[0..64]).expect("Hex decode fail.");
-        let height_bytes = hex_bytes(&input[64..72]).expect("Hex decode fail.");
-        let block_height = u32::from_be_bytes(height_bytes.as_slice().try_into().unwrap());
-        ContractCommitment { hash, block_height }
+    fn deserialize(input: &str) -> Result<ContractCommitment> {
+        if input.len() != 72 {
+            return Err(InterpreterError::Expect("Unexpected input length".into()).into());
+        }
+        let hash = Sha512Trunc256Sum::from_hex(&input[0..64])
+            .map_err(|_| InterpreterError::Expect("Hex decode fail.".into()))?;
+        let height_bytes = hex_bytes(&input[64..72])
+            .map_err(|_| InterpreterError::Expect("Hex decode fail.".into()))?;
+        let block_height = u32::from_be_bytes(
+            height_bytes
+                .as_slice()
+                .try_into()
+                .map_err(|_| InterpreterError::Expect("Block height decode fail.".into()))?,
+        );
+        Ok(ContractCommitment { hash, block_height })
     }
 }
 
@@ -215,16 +223,17 @@ impl NullBackingStore {
     }
 }
 
+#[allow(clippy::panic)]
 impl ClarityBackingStore for NullBackingStore {
     fn set_block_hash(&mut self, _bhh: StacksBlockId) -> Result<StacksBlockId> {
         panic!("NullBackingStore can't set block hash")
     }
 
-    fn get(&mut self, _key: &str) -> Option<String> {
+    fn get(&mut self, _key: &str) -> Result<Option<String>> {
         panic!("NullBackingStore can't retrieve data")
     }
 
-    fn get_with_proof(&mut self, _key: &str) -> Option<(String, Vec<u8>)> {
+    fn get_with_proof(&mut self, _key: &str) -> Result<Option<(String, Vec<u8>)>> {
         panic!("NullBackingStore can't retrieve data")
     }
 
@@ -248,7 +257,7 @@ impl ClarityBackingStore for NullBackingStore {
         panic!("NullBackingStore can't get current block height")
     }
 
-    fn put_all(&mut self, mut _items: Vec<(String, String)>) {
+    fn put_all(&mut self, mut _items: Vec<(String, String)>) -> Result<()> {
         panic!("NullBackingStore cannot put")
     }
 }
@@ -258,6 +267,7 @@ pub struct MemoryBackingStore {
 }
 
 impl MemoryBackingStore {
+    #[allow(clippy::unwrap_used)]
     pub fn new() -> MemoryBackingStore {
         let side_store = SqliteConnection::memory().unwrap();
 
@@ -282,12 +292,12 @@ impl ClarityBackingStore for MemoryBackingStore {
         Err(RuntimeErrorType::UnknownBlockHeaderHash(BlockHeaderHash(bhh.0)).into())
     }
 
-    fn get(&mut self, key: &str) -> Option<String> {
+    fn get(&mut self, key: &str) -> Result<Option<String>> {
         SqliteConnection::get(self.get_side_store(), key)
     }
 
-    fn get_with_proof(&mut self, key: &str) -> Option<(String, Vec<u8>)> {
-        SqliteConnection::get(self.get_side_store(), key).map(|x| (x, vec![]))
+    fn get_with_proof(&mut self, key: &str) -> Result<Option<(String, Vec<u8>)>> {
+        Ok(SqliteConnection::get(self.get_side_store(), key)?.map(|x| (x, vec![])))
     }
 
     fn get_side_store(&mut self) -> &Connection {
@@ -318,9 +328,10 @@ impl ClarityBackingStore for MemoryBackingStore {
         None
     }
 
-    fn put_all(&mut self, items: Vec<(String, String)>) {
+    fn put_all(&mut self, items: Vec<(String, String)>) -> Result<()> {
         for (key, value) in items.into_iter() {
-            SqliteConnection::put(self.get_side_store(), &key, &value);
+            SqliteConnection::put(self.get_side_store(), &key, &value)?;
         }
+        Ok(())
     }
 }
diff --git a/clarity/src/vm/database/key_value_wrapper.rs b/clarity/src/vm/database/key_value_wrapper.rs
index 0b45c54089..89a534003f 100644
--- a/clarity/src/vm/database/key_value_wrapper.rs
+++ b/clarity/src/vm/database/key_value_wrapper.rs
@@ -18,7 +18,7 @@ use std::collections::HashMap;
 use std::{clone::Clone, cmp::Eq, hash::Hash};
 
 use crate::vm::database::clarity_store::make_contract_hash_key;
-use crate::vm::errors::InterpreterResult;
+use crate::vm::errors::{InterpreterError, InterpreterResult};
 use crate::vm::types::serialization::SerializationError;
 use crate::vm::types::{
     QualifiedContractIdentifier, SequenceData, SequenceSubtype, TupleData, TypeSignature,
@@ -52,7 +52,7 @@ fn rollback_edits_push<T>(edits: &mut Vec<(T, RollbackValueCheck)>, key: T, _val
 fn rollback_check_pre_bottom_commit<T>(
     edits: Vec<(T, RollbackValueCheck)>,
     lookup_map: &mut HashMap<T, Vec<String>>,
-) -> Vec<(T, String)>
+) -> Result<Vec<(T, String)>, InterpreterError>
 where
     T: Eq + Hash + Clone,
 {
@@ -63,8 +63,8 @@ where
     let output = edits
         .into_iter()
         .map(|(key, _)| {
-            let value = rollback_lookup_map(&key, &(), lookup_map);
-            (key, value)
+            let value = rollback_lookup_map(&key, &(), lookup_map)?;
+            Ok((key, value))
         })
         .collect();
 
@@ -176,23 +176,27 @@ fn rollback_lookup_map<T>(
     key: &T,
     value: &RollbackValueCheck,
     lookup_map: &mut HashMap<T, Vec<String>>,
-) -> String
+) -> Result<String, InterpreterError>
 where
     T: Eq + Hash + Clone,
 {
     let popped_value;
     let remove_edit_deque = {
-        let key_edit_history = lookup_map
-            .get_mut(key)
-            .expect("ERROR: Clarity VM had edit log entry, but not lookup_map entry");
-        popped_value = key_edit_history.pop().unwrap();
+        let key_edit_history = lookup_map.get_mut(key).ok_or_else(|| {
+            InterpreterError::Expect(
+                "ERROR: Clarity VM had edit log entry, but not lookup_map entry".into(),
+            )
+        })?;
+        popped_value = key_edit_history.pop().ok_or_else(|| {
+            InterpreterError::Expect("ERROR: expected value in edit history".into())
+        })?;
         rollback_value_check(&popped_value, value);
         key_edit_history.len() == 0
     };
     if remove_edit_deque {
         lookup_map.remove(key);
     }
-    popped_value
+    Ok(popped_value)
 }
 
 impl<'a> RollbackWrapper<'a> {
@@ -233,58 +237,69 @@ impl<'a> RollbackWrapper<'a> {
     // Rollback the child's edits.
     //   this clears all edits from the child's edit queue,
     //     and removes any of those edits from the lookup map.
-    pub fn rollback(&mut self) {
-        let mut last_item = self
-            .stack
-            .pop()
-            .expect("ERROR: Clarity VM attempted to commit past the stack.");
+    pub fn rollback(&mut self) -> Result<(), InterpreterError> {
+        let mut last_item = self.stack.pop().ok_or_else(|| {
+            InterpreterError::Expect("ERROR: Clarity VM attempted to commit past the stack.".into())
+        })?;
 
         last_item.edits.reverse();
         last_item.metadata_edits.reverse();
 
         for (key, value) in last_item.edits.drain(..) {
-            rollback_lookup_map(&key, &value, &mut self.lookup_map);
+            rollback_lookup_map(&key, &value, &mut self.lookup_map)?;
         }
 
         for (key, value) in last_item.metadata_edits.drain(..) {
-            rollback_lookup_map(&key, &value, &mut self.metadata_lookup_map);
+            rollback_lookup_map(&key, &value, &mut self.metadata_lookup_map)?;
         }
+
+        Ok(())
     }
 
     pub fn depth(&self) -> usize {
         self.stack.len()
     }
 
-    pub fn commit(&mut self) {
-        let mut last_item = self
-            .stack
-            .pop()
-            .expect("ERROR: Clarity VM attempted to commit past the stack.");
+    pub fn commit(&mut self) -> Result<(), InterpreterError> {
+        let mut last_item = self.stack.pop().ok_or_else(|| {
+            InterpreterError::Expect("ERROR: Clarity VM attempted to commit past the stack.".into())
+        })?;
 
-        if self.stack.len() == 0 {
-            // committing to the backing store
-            let all_edits = rollback_check_pre_bottom_commit(last_item.edits, &mut self.lookup_map);
+        if let Some(next_up) = self.stack.last_mut() {
+            // bubble up to the next item in the stack
+            // last_mut() must exist because of the if-statement
+            for (key, value) in last_item.edits.drain(..) {
+                next_up.edits.push((key, value));
+            }
+            for (key, value) in last_item.metadata_edits.drain(..) {
+                next_up.metadata_edits.push((key, value));
+            }
+        } else {
+            // stack is empty, committing to the backing store
+            let all_edits =
+                rollback_check_pre_bottom_commit(last_item.edits, &mut self.lookup_map)?;
             if all_edits.len() > 0 {
-                self.store.put_all(all_edits);
+                self.store.put_all(all_edits).map_err(|e| {
+                    InterpreterError::Expect(format!(
+                        "ERROR: Failed to commit data to sql store: {e:?}"
+                    ))
+                })?;
             }
 
             let metadata_edits = rollback_check_pre_bottom_commit(
                 last_item.metadata_edits,
                 &mut self.metadata_lookup_map,
-            );
+            )?;
             if metadata_edits.len() > 0 {
-                self.store.put_all_metadata(metadata_edits);
-            }
-        } else {
-            // bubble up to the next item in the stack
-            let next_up = self.stack.last_mut().unwrap();
-            for (key, value) in last_item.edits.drain(..) {
-                next_up.edits.push((key, value));
-            }
-            for (key, value) in last_item.metadata_edits.drain(..) {
-                next_up.metadata_edits.push((key, value));
+                self.store.put_all_metadata(metadata_edits).map_err(|e| {
+                    InterpreterError::Expect(format!(
+                        "ERROR: Failed to commit data to sql store: {e:?}"
+                    ))
+                })?;
             }
         }
+
+        Ok(())
     }
 }
 
@@ -296,27 +311,25 @@ fn inner_put<T>(
 ) where
     T: Eq + Hash + Clone,
 {
-    if !lookup_map.contains_key(&key) {
-        lookup_map.insert(key.clone(), Vec::new());
-    }
-    let key_edit_deque = lookup_map.get_mut(&key).unwrap();
+    let key_edit_deque = lookup_map.entry(key.clone()).or_insert_with(|| Vec::new());
     rollback_edits_push(edits, key, &value);
     key_edit_deque.push(value);
 }
 
 impl<'a> RollbackWrapper<'a> {
-    pub fn put(&mut self, key: &str, value: &str) {
-        let current = self
-            .stack
-            .last_mut()
-            .expect("ERROR: Clarity VM attempted PUT on non-nested context.");
-
-        inner_put(
+    pub fn put(&mut self, key: &str, value: &str) -> InterpreterResult<()> {
+        let current = self.stack.last_mut().ok_or_else(|| {
+            InterpreterError::Expect(
+                "ERROR: Clarity VM attempted PUT on non-nested context.".into(),
+            )
+        })?;
+
+        Ok(inner_put(
             &mut self.lookup_map,
             &mut current.edits,
             key.to_string(),
             value.to_string(),
-        )
+        ))
     }
 
     ///
@@ -341,33 +354,34 @@ impl<'a> RollbackWrapper<'a> {
 
     /// this function will only return commitment proofs for values _already_ materialized
     ///  in the underlying store. otherwise it returns None.
-    pub fn get_with_proof<T>(&mut self, key: &str) -> Option<(T, Vec<u8>)>
+    pub fn get_with_proof<T>(&mut self, key: &str) -> InterpreterResult<Option<(T, Vec<u8>)>>
     where
         T: ClarityDeserializable<T>,
     {
         self.store
-            .get_with_proof(key)
-            .map(|(value, proof)| (T::deserialize(&value), proof))
+            .get_with_proof(key)?
+            .map(|(value, proof)| Ok((T::deserialize(&value)?, proof)))
+            .transpose()
     }
 
-    pub fn get<T>(&mut self, key: &str) -> Option<T>
+    pub fn get<T>(&mut self, key: &str) -> InterpreterResult<Option<T>>
     where
         T: ClarityDeserializable<T>,
     {
-        self.stack
-            .last()
-            .expect("ERROR: Clarity VM attempted GET on non-nested context.");
+        self.stack.last().ok_or_else(|| {
+            InterpreterError::Expect(
+                "ERROR: Clarity VM attempted GET on non-nested context.".into(),
+            )
+        })?;
 
-        let lookup_result = if self.query_pending_data {
-            self.lookup_map
-                .get(key)
-                .and_then(|x| x.last())
-                .map(|x| T::deserialize(x))
-        } else {
-            None
-        };
-
-        lookup_result.or_else(|| self.store.get(key).map(|x| T::deserialize(&x)))
+        if self.query_pending_data {
+            if let Some(pending_value) = self.lookup_map.get(key).and_then(|x| x.last()) {
+                // if there's pending data and we're querying pending data, return here
+                return Some(T::deserialize(pending_value)).transpose();
+            }
+        }
+        // otherwise, lookup from store
+        self.store.get(key)?.map(|x| T::deserialize(&x)).transpose()
     }
 
     pub fn deserialize_value(
@@ -393,17 +407,21 @@ impl<'a> RollbackWrapper<'a> {
         expected: &TypeSignature,
         epoch: &StacksEpochId,
     ) -> Result<Option<ValueResult>, SerializationError> {
-        self.stack
-            .last()
-            .expect("ERROR: Clarity VM attempted GET on non-nested context.");
+        self.stack.last().ok_or_else(|| {
+            SerializationError::DeserializationError(
+                "ERROR: Clarity VM attempted GET on non-nested context.".into(),
+            )
+        })?;
 
         if self.query_pending_data {
             if let Some(x) = self.lookup_map.get(key).and_then(|x| x.last()) {
                 return Ok(Some(Self::deserialize_value(x, expected, epoch)?));
             }
         }
-
-        match self.store.get(key) {
+        let stored_data = self.store.get(key).map_err(|_| {
+            SerializationError::DeserializationError("ERROR: Clarity backing store failure".into())
+        })?;
+        match stored_data {
             Some(x) => Ok(Some(Self::deserialize_value(&x, expected, epoch)?)),
             None => Ok(None),
         }
@@ -423,7 +441,7 @@ impl<'a> RollbackWrapper<'a> {
         &mut self,
         contract: &QualifiedContractIdentifier,
         content_hash: Sha512Trunc256Sum,
-    ) {
+    ) -> InterpreterResult<()> {
         let key = make_contract_hash_key(contract);
         let value = self.store.make_contract_commitment(content_hash);
         self.put(&key, &value)
@@ -434,20 +452,21 @@ impl<'a> RollbackWrapper<'a> {
         contract: &QualifiedContractIdentifier,
         key: &str,
         value: &str,
-    ) {
-        let current = self
-            .stack
-            .last_mut()
-            .expect("ERROR: Clarity VM attempted PUT on non-nested context.");
+    ) -> Result<(), InterpreterError> {
+        let current = self.stack.last_mut().ok_or_else(|| {
+            InterpreterError::Expect(
+                "ERROR: Clarity VM attempted PUT on non-nested context.".into(),
+            )
+        })?;
 
         let metadata_key = (contract.clone(), key.to_string());
 
-        inner_put(
+        Ok(inner_put(
             &mut self.metadata_lookup_map,
             &mut current.metadata_edits,
             metadata_key,
             value.to_string(),
-        )
+        ))
     }
 
     // Throws a NoSuchContract error if contract doesn't exist,
@@ -457,9 +476,11 @@ impl<'a> RollbackWrapper<'a> {
         contract: &QualifiedContractIdentifier,
         key: &str,
     ) -> InterpreterResult<Option<String>> {
-        self.stack
-            .last()
-            .expect("ERROR: Clarity VM attempted GET on non-nested context.");
+        self.stack.last().ok_or_else(|| {
+            InterpreterError::Expect(
+                "ERROR: Clarity VM attempted GET on non-nested context.".into(),
+            )
+        })?;
 
         // This is THEORETICALLY a spurious clone, but it's hard to turn something like
         //  (&A, &B) into &(A, B).
@@ -486,9 +507,11 @@ impl<'a> RollbackWrapper<'a> {
         contract: &QualifiedContractIdentifier,
         key: &str,
     ) -> InterpreterResult<Option<String>> {
-        self.stack
-            .last()
-            .expect("ERROR: Clarity VM attempted GET on non-nested context.");
+        self.stack.last().ok_or_else(|| {
+            InterpreterError::Expect(
+                "ERROR: Clarity VM attempted GET on non-nested context.".into(),
+            )
+        })?;
 
         // This is THEORETICALLY a spurious clone, but it's hard to turn something like
         //  (&A, &B) into &(A, B).
@@ -507,12 +530,14 @@ impl<'a> RollbackWrapper<'a> {
         }
     }
 
-    pub fn has_entry(&mut self, key: &str) -> bool {
-        self.stack
-            .last()
-            .expect("ERROR: Clarity VM attempted GET on non-nested context.");
+    pub fn has_entry(&mut self, key: &str) -> InterpreterResult<bool> {
+        self.stack.last().ok_or_else(|| {
+            InterpreterError::Expect(
+                "ERROR: Clarity VM attempted GET on non-nested context.".into(),
+            )
+        })?;
         if self.query_pending_data && self.lookup_map.contains_key(key) {
-            true
+            Ok(true)
         } else {
             self.store.has_entry(key)
         }
diff --git a/clarity/src/vm/database/sqlite.rs b/clarity/src/vm/database/sqlite.rs
index 433d93cf07..a1893fd33a 100644
--- a/clarity/src/vm/database/sqlite.rs
+++ b/clarity/src/vm/database/sqlite.rs
@@ -35,21 +35,21 @@ pub struct SqliteConnection {
     conn: Connection,
 }
 
-fn sqlite_put(conn: &Connection, key: &str, value: &str) {
+fn sqlite_put(conn: &Connection, key: &str, value: &str) -> Result<()> {
     let params: [&dyn ToSql; 2] = [&key, &value];
     match conn.execute(
         "REPLACE INTO data_table (key, value) VALUES (?, ?)",
         &params,
     ) {
-        Ok(_) => {}
+        Ok(_) => Ok(()),
         Err(e) => {
             error!("Failed to insert/replace ({},{}): {:?}", key, value, &e);
-            panic!("{}", SQL_FAIL_MESSAGE);
+            Err(InterpreterError::DBError(SQL_FAIL_MESSAGE.into()).into())
         }
-    };
+    }
 }
 
-fn sqlite_get(conn: &Connection, key: &str) -> Option<String> {
+fn sqlite_get(conn: &Connection, key: &str) -> Result<Option<String>> {
     trace!("sqlite_get {}", key);
     let params: [&dyn ToSql; 1] = [&key];
     let res = match conn
@@ -60,10 +60,10 @@ fn sqlite_get(conn: &Connection, key: &str) -> Option<String> {
         )
         .optional()
     {
-        Ok(x) => x,
+        Ok(x) => Ok(x),
         Err(e) => {
             error!("Failed to query '{}': {:?}", key, &e);
-            panic!("{}", SQL_FAIL_MESSAGE);
+            Err(InterpreterError::DBError(SQL_FAIL_MESSAGE.into()).into())
         }
     };
 
@@ -71,16 +71,16 @@ fn sqlite_get(conn: &Connection, key: &str) -> Option<String> {
     res
 }
 
-fn sqlite_has_entry(conn: &Connection, key: &str) -> bool {
-    sqlite_get(conn, key).is_some()
+fn sqlite_has_entry(conn: &Connection, key: &str) -> Result<bool> {
+    Ok(sqlite_get(conn, key)?.is_some())
 }
 
 impl SqliteConnection {
-    pub fn put(conn: &Connection, key: &str, value: &str) {
+    pub fn put(conn: &Connection, key: &str, value: &str) -> Result<()> {
         sqlite_put(conn, key, value)
     }
 
-    pub fn get(conn: &Connection, key: &str) -> Option<String> {
+    pub fn get(conn: &Connection, key: &str) -> Result<Option<String>> {
         sqlite_get(conn, key)
     }
 
@@ -90,7 +90,7 @@ impl SqliteConnection {
         contract_hash: &str,
         key: &str,
         value: &str,
-    ) {
+    ) -> Result<()> {
         let key = format!("clr-meta::{}::{}", contract_hash, key);
         let params: [&dyn ToSql; 3] = [&bhh, &key, &value];
 
@@ -105,26 +105,33 @@ impl SqliteConnection {
                 &value.to_string(),
                 &e
             );
-            panic!("{}", SQL_FAIL_MESSAGE);
+            return Err(InterpreterError::DBError(SQL_FAIL_MESSAGE.into()).into());
         }
+        Ok(())
     }
 
-    pub fn commit_metadata_to(conn: &Connection, from: &StacksBlockId, to: &StacksBlockId) {
+    pub fn commit_metadata_to(
+        conn: &Connection,
+        from: &StacksBlockId,
+        to: &StacksBlockId,
+    ) -> Result<()> {
         let params = [to, from];
         if let Err(e) = conn.execute(
             "UPDATE metadata_table SET blockhash = ? WHERE blockhash = ?",
             &params,
         ) {
             error!("Failed to update {} to {}: {:?}", &from, &to, &e);
-            panic!("{}", SQL_FAIL_MESSAGE);
+            return Err(InterpreterError::DBError(SQL_FAIL_MESSAGE.into()).into());
         }
+        Ok(())
     }
 
-    pub fn drop_metadata(conn: &Connection, from: &StacksBlockId) {
+    pub fn drop_metadata(conn: &Connection, from: &StacksBlockId) -> Result<()> {
         if let Err(e) = conn.execute("DELETE FROM metadata_table WHERE blockhash = ?", &[from]) {
             error!("Failed to drop metadata from {}: {:?}", &from, &e);
-            panic!("{}", SQL_FAIL_MESSAGE);
+            return Err(InterpreterError::DBError(SQL_FAIL_MESSAGE.into()).into());
         }
+        Ok(())
     }
 
     pub fn get_metadata(
@@ -132,7 +139,7 @@ impl SqliteConnection {
         bhh: &StacksBlockId,
         contract_hash: &str,
         key: &str,
-    ) -> Option<String> {
+    ) -> Result<Option<String>> {
         let key = format!("clr-meta::{}::{}", contract_hash, key);
         let params: [&dyn ToSql; 2] = [&bhh, &key];
 
@@ -144,15 +151,15 @@ impl SqliteConnection {
             )
             .optional()
         {
-            Ok(x) => x,
+            Ok(x) => Ok(x),
             Err(e) => {
                 error!("Failed to query ({},{}): {:?}", &bhh, &key, &e);
-                panic!("{}", SQL_FAIL_MESSAGE);
+                Err(InterpreterError::DBError(SQL_FAIL_MESSAGE.into()).into())
             }
         }
     }
 
-    pub fn has_entry(conn: &Connection, key: &str) -> bool {
+    pub fn has_entry(conn: &Connection, key: &str) -> Result<bool> {
         sqlite_has_entry(conn, key)
     }
 }
diff --git a/clarity/src/vm/database/structures.rs b/clarity/src/vm/database/structures.rs
index 9216a49681..238574a1fc 100644
--- a/clarity/src/vm/database/structures.rs
+++ b/clarity/src/vm/database/structures.rs
@@ -33,7 +33,7 @@ pub trait ClaritySerializable {
 }
 
 pub trait ClarityDeserializable<T> {
-    fn deserialize(json: &str) -> T;
+    fn deserialize(json: &str) -> Result<T>;
 }
 
 impl ClaritySerializable for String {
@@ -43,8 +43,8 @@ impl ClaritySerializable for String {
 }
 
 impl ClarityDeserializable<String> for String {
-    fn deserialize(serialized: &str) -> String {
-        serialized.into()
+    fn deserialize(serialized: &str) -> Result<String> {
+        Ok(serialized.into())
     }
 }
 
@@ -56,7 +56,7 @@ macro_rules! clarity_serializable {
             }
         }
         impl ClarityDeserializable<$Name> for $Name {
-            fn deserialize(json: &str) -> Self {
+            fn deserialize(json: &str) -> Result<Self> {
                 let mut deserializer = serde_json::Deserializer::from_str(&json);
                 // serde's default 128 depth limit can be exhausted
                 //  by a 64-stack-depth AST, so disable the recursion limit
@@ -64,7 +64,9 @@ macro_rules! clarity_serializable {
                 // use stacker to prevent the deserializer from overflowing.
                 //  this will instead spill to the heap
                 let deserializer = serde_stacker::Deserializer::new(&mut deserializer);
-                Deserialize::deserialize(deserializer).expect("Failed to deserialize vm.Value")
+                Deserialize::deserialize(deserializer).map_err(|_| {
+                    InterpreterError::Expect("Failed to deserialize vm.Value".into()).into()
+                })
             }
         }
     };
@@ -158,6 +160,7 @@ pub struct STXBalanceSnapshot<'db, 'conn> {
 type Result<T> = std::result::Result<T, Error>;
 
 impl ClaritySerializable for STXBalance {
+    #[allow(clippy::expect_used)]
     fn serialize(&self) -> String {
         let mut buffer = Vec::new();
         match self {
@@ -229,24 +232,26 @@ impl ClaritySerializable for STXBalance {
 }
 
 impl ClarityDeserializable<STXBalance> for STXBalance {
-    fn deserialize(input: &str) -> Self {
-        let bytes = hex_bytes(&input).expect("STXBalance deserialization: failed decoding bytes.");
-        if bytes.len() == STXBalance::unlocked_and_v1_size {
-            let amount_unlocked = u128::from_be_bytes(
-                bytes[0..16]
-                    .try_into()
-                    .expect("STXBalance deserialization: failed reading amount_unlocked."),
-            );
-            let amount_locked = u128::from_be_bytes(
-                bytes[16..32]
-                    .try_into()
-                    .expect("STXBalance deserialization: failed reading amount_locked."),
-            );
-            let unlock_height = u64::from_be_bytes(
-                bytes[32..40]
-                    .try_into()
-                    .expect("STXBalance deserialization: failed reading unlock_height."),
-            );
+    fn deserialize(input: &str) -> Result<Self> {
+        let bytes = hex_bytes(&input).map_err(|_| {
+            InterpreterError::Expect("STXBalance deserialization: failed decoding bytes.".into())
+        })?;
+        let result = if bytes.len() == STXBalance::unlocked_and_v1_size {
+            let amount_unlocked = u128::from_be_bytes(bytes[0..16].try_into().map_err(|_| {
+                InterpreterError::Expect(
+                    "STXBalance deserialization: failed reading amount_unlocked.".into(),
+                )
+            })?);
+            let amount_locked = u128::from_be_bytes(bytes[16..32].try_into().map_err(|_| {
+                InterpreterError::Expect(
+                    "STXBalance deserialization: failed reading amount_locked.".into(),
+                )
+            })?);
+            let unlock_height = u64::from_be_bytes(bytes[32..40].try_into().map_err(|_| {
+                InterpreterError::Expect(
+                    "STXBalance deserialization: failed reading unlock_height.".into(),
+                )
+            })?);
 
             if amount_locked == 0 {
                 STXBalance::Unlocked {
@@ -262,26 +267,26 @@ impl ClarityDeserializable<STXBalance> for STXBalance {
         } else if bytes.len() == STXBalance::v2_and_v3_size {
             let version = &bytes[0];
             if version != &STXBalance::pox_2_version && version != &STXBalance::pox_3_version {
-                panic!(
-                    "Bad version byte in STX Balance serialization = {}",
-                    version
-                );
+                return Err(InterpreterError::Expect(format!(
+                    "Bad version byte in STX Balance serialization = {version}"
+                ))
+                .into());
             }
-            let amount_unlocked = u128::from_be_bytes(
-                bytes[1..17]
-                    .try_into()
-                    .expect("STXBalance deserialization: failed reading amount_unlocked."),
-            );
-            let amount_locked = u128::from_be_bytes(
-                bytes[17..33]
-                    .try_into()
-                    .expect("STXBalance deserialization: failed reading amount_locked."),
-            );
-            let unlock_height = u64::from_be_bytes(
-                bytes[33..41]
-                    .try_into()
-                    .expect("STXBalance deserialization: failed reading unlock_height."),
-            );
+            let amount_unlocked = u128::from_be_bytes(bytes[1..17].try_into().map_err(|_| {
+                InterpreterError::Expect(
+                    "STXBalance deserialization: failed reading amount_unlocked.".into(),
+                )
+            })?);
+            let amount_locked = u128::from_be_bytes(bytes[17..33].try_into().map_err(|_| {
+                InterpreterError::Expect(
+                    "STXBalance deserialization: failed reading amount_locked.".into(),
+                )
+            })?);
+            let unlock_height = u64::from_be_bytes(bytes[33..41].try_into().map_err(|_| {
+                InterpreterError::Expect(
+                    "STXBalance deserialization: failed reading unlock_height.".into(),
+                )
+            })?);
 
             if amount_locked == 0 {
                 STXBalance::Unlocked {
@@ -300,11 +305,19 @@ impl ClarityDeserializable<STXBalance> for STXBalance {
                     unlock_height,
                 }
             } else {
-                unreachable!("Version is checked for pox_3 or pox_2 version compliance above");
+                return Err(InterpreterError::Expect(
+                    "Version is checked for pox_3 or pox_2 version compliance above".into(),
+                )
+                .into());
             }
         } else {
-            panic!("Bad STX Balance serialization size = {}", bytes.len());
-        }
+            return Err(InterpreterError::Expect(format!(
+                "Bad STX Balance serialization size = {}",
+                bytes.len()
+            ))
+            .into());
+        };
+        Ok(result)
     }
 }
 
@@ -327,35 +340,35 @@ impl<'db, 'conn> STXBalanceSnapshot<'db, 'conn> {
         &self.balance
     }
 
-    pub fn save(self) -> () {
+    pub fn save(self) -> Result<()> {
         let key = ClarityDatabase::make_key_for_account_balance(&self.principal);
         self.db_ref.put(&key, &self.balance)
     }
 
     pub fn transfer_to(mut self, recipient: &PrincipalData, amount: u128) -> Result<()> {
-        if !self.can_transfer(amount) {
+        if !self.can_transfer(amount)? {
             return Err(InterpreterError::InsufficientBalance.into());
         }
 
         let recipient_key = ClarityDatabase::make_key_for_account_balance(recipient);
         let mut recipient_balance = self
             .db_ref
-            .get(&recipient_key)
+            .get(&recipient_key)?
             .unwrap_or(STXBalance::zero());
 
         recipient_balance
             .checked_add_unlocked_amount(amount)
             .ok_or(Error::Runtime(RuntimeErrorType::ArithmeticOverflow, None))?;
 
-        self.debit(amount);
-        self.db_ref.put(&recipient_key, &recipient_balance);
-        self.save();
+        self.debit(amount)?;
+        self.db_ref.put(&recipient_key, &recipient_balance)?;
+        self.save()?;
         Ok(())
     }
 
-    pub fn get_available_balance(&mut self) -> u128 {
+    pub fn get_available_balance(&mut self) -> Result<u128> {
         let v1_unlock_height = self.db_ref.get_v1_unlock_height();
-        let v2_unlock_height = self.db_ref.get_v2_unlock_height();
+        let v2_unlock_height = self.db_ref.get_v2_unlock_height()?;
         self.balance.get_available_balance_at_burn_block(
             self.burn_block_height,
             v1_unlock_height,
@@ -363,40 +376,41 @@ impl<'db, 'conn> STXBalanceSnapshot<'db, 'conn> {
         )
     }
 
-    pub fn canonical_balance_repr(&mut self) -> STXBalance {
+    pub fn canonical_balance_repr(&mut self) -> Result<STXBalance> {
         let v1_unlock_height = self.db_ref.get_v1_unlock_height();
-        let v2_unlock_height = self.db_ref.get_v2_unlock_height();
-        self.balance
-            .canonical_repr_at_block(self.burn_block_height, v1_unlock_height, v2_unlock_height)
-            .0
+        let v2_unlock_height = self.db_ref.get_v2_unlock_height()?;
+        Ok(self
+            .balance
+            .canonical_repr_at_block(self.burn_block_height, v1_unlock_height, v2_unlock_height)?
+            .0)
     }
 
-    pub fn has_locked_tokens(&mut self) -> bool {
+    pub fn has_locked_tokens(&mut self) -> Result<bool> {
         let v1_unlock_height = self.db_ref.get_v1_unlock_height();
-        let v2_unlock_height = self.db_ref.get_v2_unlock_height();
-        self.balance.has_locked_tokens_at_burn_block(
+        let v2_unlock_height = self.db_ref.get_v2_unlock_height()?;
+        Ok(self.balance.has_locked_tokens_at_burn_block(
             self.burn_block_height,
             v1_unlock_height,
             v2_unlock_height,
-        )
+        ))
     }
 
-    pub fn has_unlockable_tokens(&mut self) -> bool {
+    pub fn has_unlockable_tokens(&mut self) -> Result<bool> {
         let v1_unlock_height = self.db_ref.get_v1_unlock_height();
-        let v2_unlock_height = self.db_ref.get_v2_unlock_height();
-        self.balance.has_unlockable_tokens_at_burn_block(
+        let v2_unlock_height = self.db_ref.get_v2_unlock_height()?;
+        Ok(self.balance.has_unlockable_tokens_at_burn_block(
             self.burn_block_height,
             v1_unlock_height,
             v2_unlock_height,
-        )
+        ))
     }
 
-    pub fn can_transfer(&mut self, amount: u128) -> bool {
-        self.get_available_balance() >= amount
+    pub fn can_transfer(&mut self, amount: u128) -> Result<bool> {
+        Ok(self.get_available_balance()? >= amount)
     }
 
-    pub fn debit(&mut self, amount: u128) {
-        let unlocked = self.unlock_available_tokens_if_any();
+    pub fn debit(&mut self, amount: u128) -> Result<()> {
+        let unlocked = self.unlock_available_tokens_if_any()?;
         if unlocked > 0 {
             debug!("Consolidated after account-debit");
         }
@@ -404,23 +418,24 @@ impl<'db, 'conn> STXBalanceSnapshot<'db, 'conn> {
         self.balance.debit_unlocked_amount(amount)
     }
 
-    pub fn credit(&mut self, amount: u128) {
-        let unlocked = self.unlock_available_tokens_if_any();
+    pub fn credit(&mut self, amount: u128) -> Result<()> {
+        let unlocked = self.unlock_available_tokens_if_any()?;
         if unlocked > 0 {
             debug!("Consolidated after account-credit");
         }
 
         self.balance
             .checked_add_unlocked_amount(amount)
-            .expect("STX balance overflow");
+            .ok_or_else(|| InterpreterError::Expect("STX balance overflow".into()))?;
+        Ok(())
     }
 
     pub fn set_balance(&mut self, balance: STXBalance) {
         self.balance = balance;
     }
 
-    pub fn lock_tokens_v1(&mut self, amount_to_lock: u128, unlock_burn_height: u64) {
-        let unlocked = self.unlock_available_tokens_if_any();
+    pub fn lock_tokens_v1(&mut self, amount_to_lock: u128, unlock_burn_height: u64) -> Result<()> {
+        let unlocked = self.unlock_available_tokens_if_any()?;
         if unlocked > 0 {
             debug!("Consolidated after account-token-lock");
         }
@@ -430,12 +445,18 @@ impl<'db, 'conn> STXBalanceSnapshot<'db, 'conn> {
 
         if unlock_burn_height <= self.burn_block_height {
             // caller needs to have checked this
-            panic!("FATAL: cannot set a lock with expired unlock burn height");
+            return Err(InterpreterError::Expect(
+                "FATAL: cannot set a lock with expired unlock burn height".into(),
+            )
+            .into());
         }
 
-        if self.has_locked_tokens() {
+        if self.has_locked_tokens()? {
             // caller needs to have checked this
-            panic!("FATAL: account already has locked tokens");
+            return Err(InterpreterError::Expect(
+                "FATAL: account already has locked tokens".into(),
+            )
+            .into());
         }
 
         // from `unlock_available_tokens_if_any` call above, `self.balance` should
@@ -443,84 +464,100 @@ impl<'db, 'conn> STXBalanceSnapshot<'db, 'conn> {
 
         let new_amount_unlocked = self
             .balance
-            .get_total_balance()
+            .get_total_balance()?
             .checked_sub(amount_to_lock)
-            .expect("STX underflow");
+            .ok_or_else(|| InterpreterError::Expect("STX underflow".into()))?;
 
         self.balance = STXBalance::LockedPoxOne {
             amount_unlocked: new_amount_unlocked,
             amount_locked: amount_to_lock,
             unlock_height: unlock_burn_height,
         };
+        Ok(())
     }
 
     ////////////// Pox-2 /////////////////
 
     /// Return true iff `self` represents a snapshot that has a lock
     ///  created by PoX v2.
-    pub fn is_v2_locked(&mut self) -> bool {
-        match self.canonical_balance_repr() {
-            STXBalance::LockedPoxTwo { .. } => true,
-            _ => false,
+    pub fn is_v2_locked(&mut self) -> Result<bool> {
+        match self.canonical_balance_repr()? {
+            STXBalance::LockedPoxTwo { .. } => Ok(true),
+            _ => Ok(false),
         }
     }
 
     /// Increase the account's current lock to `new_total_locked`.
     /// Panics if `self` was not locked by V2 PoX.
-    pub fn increase_lock_v2(&mut self, new_total_locked: u128) {
-        let unlocked = self.unlock_available_tokens_if_any();
+    pub fn increase_lock_v2(&mut self, new_total_locked: u128) -> Result<()> {
+        let unlocked = self.unlock_available_tokens_if_any()?;
         if unlocked > 0 {
             debug!("Consolidated after extend-token-lock");
         }
 
-        if !self.has_locked_tokens() {
+        if !self.has_locked_tokens()? {
             // caller needs to have checked this
-            panic!("FATAL: account does not have locked tokens");
+            return Err(InterpreterError::Expect(
+                "FATAL: account does not have locked tokens".into(),
+            )
+            .into());
         }
 
-        if !self.is_v2_locked() {
+        if !self.is_v2_locked()? {
             // caller needs to have checked this
-            panic!("FATAL: account must be locked by pox-2");
+            return Err(
+                InterpreterError::Expect("FATAL: account must be locked by pox-2".into()).into(),
+            );
         }
 
-        assert!(
-            self.balance.amount_locked() <= new_total_locked,
-            "FATAL: account must lock more after `increase_lock_v2`"
-        );
+        if !(self.balance.amount_locked() <= new_total_locked) {
+            return Err(InterpreterError::Expect(
+                "FATAL: account must lock more after `increase_lock_v2`".into(),
+            )
+            .into());
+        }
 
         let total_amount = self
             .balance
             .amount_unlocked()
             .checked_add(self.balance.amount_locked())
-            .expect("STX balance overflowed u128");
-        let amount_unlocked = total_amount
-            .checked_sub(new_total_locked)
-            .expect("STX underflow: more is locked than total balance");
+            .ok_or_else(|| InterpreterError::Expect("STX balance overflowed u128".into()))?;
+        let amount_unlocked = total_amount.checked_sub(new_total_locked).ok_or_else(|| {
+            InterpreterError::Expect("STX underflow: more is locked than total balance".into())
+        })?;
 
         self.balance = STXBalance::LockedPoxTwo {
             amount_unlocked,
             amount_locked: new_total_locked,
             unlock_height: self.balance.unlock_height(),
         };
+
+        Ok(())
     }
 
     /// Extend this account's current lock to `unlock_burn_height`.
     /// After calling, this method will set the balance to a "LockedPoxTwo" balance,
     ///  because this method is only invoked as a result of PoX2 interactions
-    pub fn extend_lock_v2(&mut self, unlock_burn_height: u64) {
-        let unlocked = self.unlock_available_tokens_if_any();
+    pub fn extend_lock_v2(&mut self, unlock_burn_height: u64) -> Result<()> {
+        let unlocked = self.unlock_available_tokens_if_any()?;
         if unlocked > 0 {
             debug!("Consolidated after extend-token-lock");
         }
 
-        if !self.has_locked_tokens() {
+        if !self.has_locked_tokens()? {
             // caller needs to have checked this
-            panic!("FATAL: account does not have locked tokens");
+            return Err(InterpreterError::Expect(
+                "FATAL: account does not have locked tokens".into(),
+            )
+            .into());
         }
 
         if unlock_burn_height <= self.burn_block_height {
             // caller needs to have checked this
-            panic!("FATAL: cannot set a lock with expired unlock burn height");
+            return Err(InterpreterError::Expect(
+                "FATAL: cannot set a lock with expired unlock burn height".into(),
+            )
+            .into());
         }
 
         self.balance = STXBalance::LockedPoxTwo {
@@ -528,28 +565,37 @@ impl<'db, 'conn> STXBalanceSnapshot<'db, 'conn> {
             amount_locked: self.balance.amount_locked(),
             unlock_height: unlock_burn_height,
         };
+        Ok(())
     }
 
     /// Lock `amount_to_lock` tokens on this account until `unlock_burn_height`.
     /// After calling, this method will set the balance to a "LockedPoxTwo" balance,
     ///  because this method is only invoked as a result of PoX2 interactions
-    pub fn lock_tokens_v2(&mut self, amount_to_lock: u128, unlock_burn_height: u64) {
-        let unlocked = self.unlock_available_tokens_if_any();
+    pub fn lock_tokens_v2(&mut self, amount_to_lock: u128, unlock_burn_height: u64) -> Result<()> {
+        let unlocked = self.unlock_available_tokens_if_any()?;
         if unlocked > 0 {
             debug!("Consolidated after account-token-lock");
         }
 
         // caller needs to have checked this
-        assert!(amount_to_lock > 0, "BUG: cannot lock 0 tokens");
+        if !(amount_to_lock > 0) {
+            return Err(InterpreterError::Expect("BUG: cannot lock 0 tokens".into()).into());
+        }
 
         if unlock_burn_height <= self.burn_block_height {
             // caller needs to have checked this
-            panic!("FATAL: cannot set a lock with expired unlock burn height");
+            return Err(InterpreterError::Expect(
+                "FATAL: cannot set a lock with expired unlock burn height".into(),
+            )
+            .into());
         }
 
-        if self.has_locked_tokens() {
+        if self.has_locked_tokens()? {
             // caller needs to have checked this
-            panic!("FATAL: account already has locked tokens");
+            return Err(InterpreterError::Expect(
+                "FATAL: account already has locked tokens".into(),
+            )
+            .into());
         }
 
         // from `unlock_available_tokens_if_any` call above, `self.balance` should
@@ -557,15 +603,16 @@ impl<'db, 'conn> STXBalanceSnapshot<'db, 'conn> {
 
         let new_amount_unlocked = self
             .balance
-            .get_total_balance()
+            .get_total_balance()?
             .checked_sub(amount_to_lock)
-            .expect("STX underflow");
+            .ok_or_else(|| InterpreterError::Expect("STX underflow".into()))?;
 
         self.balance = STXBalance::LockedPoxTwo {
             amount_unlocked: new_amount_unlocked,
             amount_locked: amount_to_lock,
             unlock_height: unlock_burn_height,
         };
+        Ok(())
     }
 
     //////////////// Pox-3 //////////////////
@@ -573,8 +620,8 @@ impl<'db, 'conn> STXBalanceSnapshot<'db, 'conn> {
     /// Lock `amount_to_lock` tokens on this account until `unlock_burn_height`.
     /// After calling, this method will set the balance to a "LockedPoxThree" balance,
     ///  because this method is only invoked as a result of PoX3 interactions
-    pub fn lock_tokens_v3(&mut self, amount_to_lock: u128, unlock_burn_height: u64) {
-        let unlocked = self.unlock_available_tokens_if_any();
+    pub fn lock_tokens_v3(&mut self, amount_to_lock: u128, unlock_burn_height: u64) -> Result<()> {
+        let unlocked = self.unlock_available_tokens_if_any()?;
         if unlocked > 0 {
             debug!("Consolidated after account-token-lock");
         }
@@ -584,12 +631,18 @@ impl<'db, 'conn> STXBalanceSnapshot<'db, 'conn> {
 
         if unlock_burn_height <= self.burn_block_height {
             // caller needs to have checked this
-            panic!("FATAL: cannot set a lock with expired unlock burn height");
+            return Err(InterpreterError::Expect(
+                "FATAL: cannot set a lock with expired unlock burn height".into(),
+            )
+            .into());
         }
 
-        if self.has_locked_tokens() {
+        if self.has_locked_tokens()? {
             // caller needs to have checked this
-            panic!("FATAL: account already has locked tokens");
+            return Err(InterpreterError::Expect(
+                "FATAL: account already has locked tokens".into(),
+            )
+            .into());
         }
 
         // from `unlock_available_tokens_if_any` call above, `self.balance` should
@@ -597,34 +650,46 @@ impl<'db, 'conn> STXBalanceSnapshot<'db, 'conn> {
 
         let new_amount_unlocked = self
             .balance
-            .get_total_balance()
+            .get_total_balance()?
             .checked_sub(amount_to_lock)
-            .expect("FATAL: account locks more STX than balance possessed");
+            .ok_or_else(|| {
+                InterpreterError::Expect(
+                    "FATAL: account locks more STX than balance possessed".into(),
+                )
+            })?;
 
         self.balance = STXBalance::LockedPoxThree {
             amount_unlocked: new_amount_unlocked,
             amount_locked: amount_to_lock,
             unlock_height: unlock_burn_height,
         };
+
+        Ok(())
     }
 
     /// Extend this account's current lock to `unlock_burn_height`.
     /// After calling, this method will set the balance to a "LockedPoxThree" balance,
     ///  because this method is only invoked as a result of PoX3 interactions
-    pub fn extend_lock_v3(&mut self, unlock_burn_height: u64) {
-        let unlocked = self.unlock_available_tokens_if_any();
+    pub fn extend_lock_v3(&mut self, unlock_burn_height: u64) -> Result<()> {
+        let unlocked = self.unlock_available_tokens_if_any()?;
         if unlocked > 0 {
             debug!("Consolidated after extend-token-lock");
         }
 
-        if !self.has_locked_tokens() {
+        if !self.has_locked_tokens()? {
             // caller needs to have checked this
-            panic!("FATAL: account does not have locked tokens");
+            return Err(InterpreterError::Expect(
+                "FATAL: account does not have locked tokens".into(),
+            )
+            .into());
         }
 
         if unlock_burn_height <= self.burn_block_height {
             // caller needs to have checked this
-            panic!("FATAL: cannot set a lock with expired unlock burn height");
+            return Err(InterpreterError::Expect(
+                "FATAL: cannot set a lock with expired unlock burn height".into(),
+            )
+            .into());
         }
 
         self.balance = STXBalance::LockedPoxThree {
@@ -632,24 +697,30 @@ impl<'db, 'conn> STXBalanceSnapshot<'db, 'conn> {
             amount_locked: self.balance.amount_locked(),
             unlock_height: unlock_burn_height,
         };
+        Ok(())
     }
 
     /// Increase the account's current lock to `new_total_locked`.
     /// Panics if `self` was not locked by V3 PoX.
-    pub fn increase_lock_v3(&mut self, new_total_locked: u128) {
-        let unlocked = self.unlock_available_tokens_if_any();
+    pub fn increase_lock_v3(&mut self, new_total_locked: u128) -> Result<()> {
+        let unlocked = self.unlock_available_tokens_if_any()?;
         if unlocked > 0 {
             debug!("Consolidated after extend-token-lock");
         }
 
-        if !self.has_locked_tokens() {
+        if !self.has_locked_tokens()? {
             // caller needs to have checked this
-            panic!("FATAL: account does not have locked tokens");
+            return Err(InterpreterError::Expect(
+                "FATAL: account does not have locked tokens".into(),
+            )
+            .into());
         }
 
-        if !self.is_v3_locked() {
+        if !self.is_v3_locked()? {
             // caller needs to have checked this
-            panic!("FATAL: account must be locked by pox-3");
+            return Err(
+                InterpreterError::Expect("FATAL: account must be locked by pox-3".into()).into(),
+            );
         }
 
         assert!(
@@ -661,24 +732,25 @@ impl<'db, 'conn> STXBalanceSnapshot<'db, 'conn> {
             .balance
             .amount_unlocked()
             .checked_add(self.balance.amount_locked())
-            .expect("STX balance overflowed u128");
-        let amount_unlocked = total_amount
-            .checked_sub(new_total_locked)
-            .expect("STX underflow: more is locked than total balance");
+            .ok_or_else(|| InterpreterError::Expect("STX balance overflowed u128".into()))?;
+        let amount_unlocked = total_amount.checked_sub(new_total_locked).ok_or_else(|| {
+            InterpreterError::Expect("STX underflow: more is locked than total balance".into())
+        })?;
 
         self.balance = STXBalance::LockedPoxThree {
             amount_unlocked,
             amount_locked: new_total_locked,
             unlock_height: self.balance.unlock_height(),
         };
+        Ok(())
     }
 
     /// Return true iff `self` represents a snapshot that has a lock
     ///  created by PoX v3.
-    pub fn is_v3_locked(&mut self) -> bool {
-        match self.canonical_balance_repr() {
-            STXBalance::LockedPoxThree { .. } => true,
-            _ => false,
+    pub fn is_v3_locked(&mut self) -> Result<bool> {
+        match self.canonical_balance_repr()? {
+            STXBalance::LockedPoxThree { .. } => Ok(true),
+            _ => Ok(false),
         }
     }
 
@@ -686,8 +758,8 @@ impl<'db, 'conn> STXBalanceSnapshot<'db, 'conn> {
 
     /// If this snapshot is locked, then alter the lock height to be
     /// the next burn block (i.e., `self.burn_block_height + 1`)
-    pub fn accelerate_unlock(&mut self) {
-        let unlocked = self.unlock_available_tokens_if_any();
+    pub fn accelerate_unlock(&mut self) -> Result<()> {
+        let unlocked = self.unlock_available_tokens_if_any()?;
         if unlocked > 0 {
             debug!("Consolidated after account-token-lock");
         }
@@ -696,7 +768,10 @@ impl<'db, 'conn> STXBalanceSnapshot<'db, 'conn> {
         self.balance = match self.balance {
             STXBalance::Unlocked { amount } => STXBalance::Unlocked { amount },
             STXBalance::LockedPoxOne { .. } => {
-                unreachable!("Attempted to accelerate the unlock of a lockup created by PoX-1")
+                return Err(InterpreterError::Expect(
+                    "Attempted to accelerate the unlock of a lockup created by PoX-1".into(),
+                )
+                .into())
             }
             STXBalance::LockedPoxTwo {
                 amount_unlocked,
@@ -717,18 +792,19 @@ impl<'db, 'conn> STXBalanceSnapshot<'db, 'conn> {
                 unlock_height: new_unlock_height,
             },
         };
+        Ok(())
     }
 
     /// Unlock any tokens that are unlockable at the current
     ///  burn block height, and return the amount newly unlocked
-    fn unlock_available_tokens_if_any(&mut self) -> u128 {
+    fn unlock_available_tokens_if_any(&mut self) -> Result<u128> {
         let (new_balance, unlocked) = self.balance.canonical_repr_at_block(
             self.burn_block_height,
             self.db_ref.get_v1_unlock_height(),
-            self.db_ref.get_v2_unlock_height(),
-        );
+            self.db_ref.get_v2_unlock_height()?,
+        )?;
         self.balance = new_balance;
-        unlocked
+        Ok(unlocked)
     }
 }
 
@@ -813,7 +889,7 @@ impl STXBalance {
         }
     }
 
-    fn debit_unlocked_amount(&mut self, delta: u128) {
+    fn debit_unlocked_amount(&mut self, delta: u128) -> Result<()> {
         match self {
             STXBalance::Unlocked {
                 amount: amount_unlocked,
@@ -827,7 +903,10 @@ impl STXBalance {
             | STXBalance::LockedPoxThree {
                 amount_unlocked, ..
             } => {
-                *amount_unlocked = amount_unlocked.checked_sub(delta).expect("STX underflow");
+                *amount_unlocked = amount_unlocked
+                    .checked_sub(delta)
+                    .ok_or_else(|| InterpreterError::Expect("STX underflow".into()))?;
+                Ok(())
             }
         }
     }
@@ -865,20 +944,20 @@ impl STXBalance {
         burn_block_height: u64,
         v1_unlock_height: u32,
         v2_unlock_height: u32,
-    ) -> (STXBalance, u128) {
+    ) -> Result<(STXBalance, u128)> {
         if self.has_unlockable_tokens_at_burn_block(
             burn_block_height,
             v1_unlock_height,
             v2_unlock_height,
         ) {
-            (
+            Ok((
                 STXBalance::Unlocked {
-                    amount: self.get_total_balance(),
+                    amount: self.get_total_balance()?,
                 },
                 self.amount_locked(),
-            )
+            ))
         } else {
-            (self.clone(), 0)
+            Ok((self.clone(), 0))
         }
     }
 
@@ -887,7 +966,7 @@ impl STXBalance {
         burn_block_height: u64,
         v1_unlock_height: u32,
         v2_unlock_height: u32,
-    ) -> u128 {
+    ) -> Result<u128> {
         if self.has_unlockable_tokens_at_burn_block(
             burn_block_height,
             v1_unlock_height,
@@ -895,7 +974,7 @@ impl STXBalance {
         ) {
             self.get_total_balance()
         } else {
-            match self {
+            let out = match self {
                 STXBalance::Unlocked { amount } => *amount,
                 STXBalance::LockedPoxOne {
                     amount_unlocked, ..
@@ -906,7 +985,8 @@ impl STXBalance {
                 STXBalance::LockedPoxThree {
                     amount_unlocked, ..
                 } => *amount_unlocked,
-            }
+            };
+            Ok(out)
         }
     }
 
@@ -944,7 +1024,7 @@ impl STXBalance {
         }
     }
 
-    pub fn get_total_balance(&self) -> u128 {
+    pub fn get_total_balance(&self) -> Result<u128> {
         let (unlocked, locked) = match self {
             STXBalance::Unlocked { amount } => (*amount, 0),
             STXBalance::LockedPoxOne {
@@ -963,7 +1043,9 @@ impl STXBalance {
                 ..
             } => (*amount_unlocked, *amount_locked),
         };
-        unlocked.checked_add(locked).expect("STX overflow")
+        unlocked
+            .checked_add(locked)
+            .ok_or_else(|| InterpreterError::Expect("STX overflow".into()).into())
     }
 
     pub fn was_locked_by_v1(&self) -> bool {
@@ -1116,11 +1198,11 @@ impl STXBalance {
         burn_block_height: u64,
         v1_unlock_height: u32,
         v2_unlock_height: u32,
-    ) -> bool {
-        self.get_available_balance_at_burn_block(
+    ) -> Result<bool> {
+        Ok(self.get_available_balance_at_burn_block(
             burn_block_height,
             v1_unlock_height,
             v2_unlock_height,
-        ) >= amount
+        )? >= amount)
     }
 }
diff --git a/clarity/src/vm/docs/contracts.rs b/clarity/src/vm/docs/contracts.rs
index 23cd25f650..12afe90886 100644
--- a/clarity/src/vm/docs/contracts.rs
+++ b/clarity/src/vm/docs/contracts.rs
@@ -47,6 +47,7 @@ pub struct ContractSupportDocs {
     pub skip_func_display: HashSet<&'static str>,
 }
 
+#[allow(clippy::expect_used)]
 fn make_func_ref(func_name: &str, func_type: &FunctionType, description: &str) -> FunctionRef {
     let input_type = get_input_type_string(func_type);
     let output_type = get_output_type_string(func_type);
@@ -61,6 +62,7 @@ fn make_func_ref(func_name: &str, func_type: &FunctionType, description: &str) -
     }
 }
 
+#[allow(clippy::expect_used)]
 fn get_constant_value(var_name: &str, contract_content: &str) -> Value {
     let to_eval = format!("{}\n{}", contract_content, var_name);
     doc_execute(&to_eval)
@@ -94,6 +96,7 @@ fn doc_execute(program: &str) -> Result<Option<Value>, vm::Error> {
     })
 }
 
+#[allow(clippy::expect_used)]
 pub fn make_docs(content: &str, support_docs: &ContractSupportDocs) -> ContractRef {
     let (_, contract_analysis) =
         mem_type_check(content, ClarityVersion::latest(), StacksEpochId::latest())
@@ -144,7 +147,8 @@ pub fn make_docs(content: &str, support_docs: &ContractSupportDocs) -> ContractR
     let ecode_result = doc_execute(&ecode_to_eval)
         .expect("BUG: failed to evaluate contract for constant value")
         .expect("BUG: failed to return constant value")
-        .expect_tuple();
+        .expect_tuple()
+        .expect("BUG: failed to build tuple");
 
     let error_codes = variable_types
         .iter()
diff --git a/clarity/src/vm/docs/mod.rs b/clarity/src/vm/docs/mod.rs
index 90497c3dab..474aaca1d2 100644
--- a/clarity/src/vm/docs/mod.rs
+++ b/clarity/src/vm/docs/mod.rs
@@ -777,6 +777,7 @@ pub fn get_input_type_string(function_type: &FunctionType) -> String {
     }
 }
 
+#[allow(clippy::panic)]
 pub fn get_output_type_string(function_type: &FunctionType) -> String {
     match function_type {
         FunctionType::Variadic(_, ref out_type) => format!("{}", out_type),
@@ -826,6 +827,8 @@ pub fn get_signature(function_name: &str, function_type: &FunctionType) -> Optio
     }
 }
 
+#[allow(clippy::expect_used)]
+#[allow(clippy::panic)]
 fn make_for_simple_native(
     api: &SimpleFunctionAPI,
     function: &NativeFunctions,
@@ -834,6 +837,7 @@ fn make_for_simple_native(
     let (input_type, output_type) = {
         if let TypedNativeFunction::Simple(SimpleNativeFunction(function_type)) =
             TypedNativeFunction::type_native_function(&function)
+                .expect("Failed to type a native function")
         {
             let input_type = get_input_type_string(&function_type);
             let output_type = get_output_type_string(&function_type);
@@ -2619,6 +2623,7 @@ fn make_all_api_reference() -> ReferenceAPIs {
     }
 }
 
+#[allow(clippy::expect_used)]
 pub fn make_json_api_reference() -> String {
     let api_out = make_all_api_reference();
     format!(
@@ -3054,9 +3059,10 @@ mod test {
                         let mut snapshot = e
                             .global_context
                             .database
-                            .get_stx_balance_snapshot_genesis(&docs_principal_id);
+                            .get_stx_balance_snapshot_genesis(&docs_principal_id)
+                            .unwrap();
                         snapshot.set_balance(balance);
-                        snapshot.save();
+                        snapshot.save().unwrap();
                         e.global_context
                             .database
                             .increment_ustx_liquid_supply(100000)
diff --git a/clarity/src/vm/errors.rs b/clarity/src/vm/errors.rs
index 9b9e2e2513..b9ef6643b1 100644
--- a/clarity/src/vm/errors.rs
+++ b/clarity/src/vm/errors.rs
@@ -29,6 +29,8 @@ use std::error;
 use std::error::Error as ErrorTrait;
 use std::fmt;
 
+use super::ast::errors::ParseErrors;
+
 #[derive(Debug)]
 pub struct IncomparableError<T> {
     pub err: T,
@@ -64,6 +66,7 @@ pub enum InterpreterError {
     InsufficientBalance,
     CostContractLoadFailure,
     DBError(String),
+    Expect(String),
 }
 
 /// RuntimeErrors are errors that smart contracts are expected
@@ -167,21 +170,28 @@ impl error::Error for RuntimeErrorType {
     }
 }
 
-impl From<CostErrors> for Error {
-    fn from(err: CostErrors) -> Self {
-        Error::from(CheckErrors::from(err))
-    }
-}
-
 impl From<ParseError> for Error {
     fn from(err: ParseError) -> Self {
-        Error::from(RuntimeErrorType::ASTError(err))
+        match &err.err {
+            ParseErrors::InterpreterFailure => Error::from(InterpreterError::Expect(
+                "Unexpected interpreter failure during parsing".into(),
+            )),
+            _ => Error::from(RuntimeErrorType::ASTError(err)),
+        }
     }
 }
 
-impl From<SerdeJSONErr> for Error {
-    fn from(err: SerdeJSONErr) -> Self {
-        Error::from(RuntimeErrorType::JSONParseError(IncomparableError { err }))
+impl From<CostErrors> for Error {
+    fn from(err: CostErrors) -> Self {
+        match err {
+            CostErrors::InterpreterFailure => Error::from(InterpreterError::Expect(
+                "Interpreter failure during cost calculation".into(),
+            )),
+            CostErrors::Expect(s) => Error::from(InterpreterError::Expect(format!(
+                "Interpreter failure during cost calculation: {s}"
+            ))),
+            other_err => Error::from(CheckErrors::from(other_err)),
+        }
     }
 }
 
diff --git a/clarity/src/vm/events.rs b/clarity/src/vm/events.rs
index 3973e60680..b363fd82a8 100644
--- a/clarity/src/vm/events.rs
+++ b/clarity/src/vm/events.rs
@@ -23,6 +23,8 @@ use crate::vm::types::{
     Value,
 };
 
+use super::types::serialization::SerializationError;
+
 #[derive(Debug, Clone, PartialEq)]
 pub enum StacksTransactionEvent {
     SmartContractEvent(SmartContractEventData),
@@ -37,14 +39,14 @@ impl StacksTransactionEvent {
         event_index: usize,
         txid: &dyn std::fmt::Debug,
         committed: bool,
-    ) -> serde_json::Value {
-        match self {
+    ) -> Result<serde_json::Value, SerializationError> {
+        let out = match self {
             StacksTransactionEvent::SmartContractEvent(event_data) => json!({
                 "txid": format!("0x{:?}", txid),
                 "event_index": event_index,
                 "committed": committed,
                 "type": "contract_event",
-                "contract_event": event_data.json_serialize()
+                "contract_event": event_data.json_serialize()?
             }),
             StacksTransactionEvent::STXEvent(STXEventType::STXTransferEvent(event_data)) => json!({
                 "txid": format!("0x{:?}", txid),
@@ -79,21 +81,21 @@ impl StacksTransactionEvent {
                 "event_index": event_index,
                 "committed": committed,
                 "type": "nft_transfer_event",
-                "nft_transfer_event": event_data.json_serialize()
+                "nft_transfer_event": event_data.json_serialize()?
             }),
             StacksTransactionEvent::NFTEvent(NFTEventType::NFTMintEvent(event_data)) => json!({
                 "txid": format!("0x{:?}", txid),
                 "event_index": event_index,
                 "committed": committed,
                 "type": "nft_mint_event",
-                "nft_mint_event": event_data.json_serialize()
+                "nft_mint_event": event_data.json_serialize()?
             }),
             StacksTransactionEvent::NFTEvent(NFTEventType::NFTBurnEvent(event_data)) => json!({
                 "txid": format!("0x{:?}", txid),
                 "event_index": event_index,
                 "committed": committed,
                 "type": "nft_burn_event",
-                "nft_burn_event": event_data.json_serialize()
+                "nft_burn_event": event_data.json_serialize()?
             }),
             StacksTransactionEvent::FTEvent(FTEventType::FTTransferEvent(event_data)) => json!({
                 "txid": format!("0x{:?}", txid),
@@ -116,7 +118,8 @@ impl StacksTransactionEvent {
                 "type": "ft_burn_event",
                 "ft_burn_event": event_data.json_serialize()
             }),
-        }
+        };
+        Ok(out)
     }
 }
 
@@ -219,20 +222,20 @@ pub struct NFTTransferEventData {
 }
 
 impl NFTTransferEventData {
-    pub fn json_serialize(&self) -> serde_json::Value {
+    pub fn json_serialize(&self) -> Result<serde_json::Value, SerializationError> {
         let raw_value = {
             let mut bytes = vec![];
-            self.value.serialize_write(&mut bytes).unwrap();
+            self.value.serialize_write(&mut bytes)?;
             let formatted_bytes: Vec<String> = bytes.iter().map(|b| format!("{:02x}", b)).collect();
             formatted_bytes
         };
-        json!({
+        Ok(json!({
             "asset_identifier": format!("{}", self.asset_identifier),
             "sender": format!("{}",self.sender),
             "recipient": format!("{}",self.recipient),
             "value": self.value,
             "raw_value": format!("0x{}", raw_value.join("")),
-        })
+        }))
     }
 }
 
@@ -244,19 +247,19 @@ pub struct NFTMintEventData {
 }
 
 impl NFTMintEventData {
-    pub fn json_serialize(&self) -> serde_json::Value {
+    pub fn json_serialize(&self) -> Result<serde_json::Value, SerializationError> {
         let raw_value = {
             let mut bytes = vec![];
-            self.value.serialize_write(&mut bytes).unwrap();
+            self.value.serialize_write(&mut bytes)?;
             let formatted_bytes: Vec<String> = bytes.iter().map(|b| format!("{:02x}", b)).collect();
             formatted_bytes
         };
-        json!({
+        Ok(json!({
             "asset_identifier": format!("{}", self.asset_identifier),
             "recipient": format!("{}",self.recipient),
             "value": self.value,
             "raw_value": format!("0x{}", raw_value.join("")),
-        })
+        }))
     }
 }
 
@@ -268,19 +271,19 @@ pub struct NFTBurnEventData {
 }
 
 impl NFTBurnEventData {
-    pub fn json_serialize(&self) -> serde_json::Value {
+    pub fn json_serialize(&self) -> Result<serde_json::Value, SerializationError> {
         let raw_value = {
             let mut bytes = vec![];
-            self.value.serialize_write(&mut bytes).unwrap();
+            self.value.serialize_write(&mut bytes)?;
             let formatted_bytes: Vec<String> = bytes.iter().map(|b| format!("{:02x}", b)).collect();
             formatted_bytes
         };
-        json!({
+        Ok(json!({
             "asset_identifier": format!("{}", self.asset_identifier),
             "sender": format!("{}",self.sender),
             "value": self.value,
             "raw_value": format!("0x{}", raw_value.join("")),
-        })
+        }))
     }
 }
 
@@ -344,18 +347,18 @@ pub struct SmartContractEventData {
 }
 
 impl SmartContractEventData {
-    pub fn json_serialize(&self) -> serde_json::Value {
+    pub fn json_serialize(&self) -> Result<serde_json::Value, SerializationError> {
         let raw_value = {
             let mut bytes = vec![];
-            self.value.serialize_write(&mut bytes).unwrap();
+            self.value.serialize_write(&mut bytes)?;
             let formatted_bytes: Vec<String> = bytes.iter().map(|b| format!("{:02x}", b)).collect();
             formatted_bytes
         };
-        json!({
+        Ok(json!({
             "contract_identifier": self.key.0.to_string(),
             "topic": self.key.1,
             "value": self.value,
             "raw_value": format!("0x{}", raw_value.join("")),
-        })
+        }))
     }
 }
diff --git a/clarity/src/vm/functions/arithmetic.rs b/clarity/src/vm/functions/arithmetic.rs
index ec493d9dee..4f9c2573c4 100644
--- a/clarity/src/vm/functions/arithmetic.rs
+++ b/clarity/src/vm/functions/arithmetic.rs
@@ -15,7 +15,9 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 use crate::vm::costs::cost_functions::ClarityCostFunction;
-use crate::vm::errors::{check_argument_count, CheckErrors, InterpreterResult, RuntimeErrorType};
+use crate::vm::errors::{
+    check_argument_count, CheckErrors, InterpreterError, InterpreterResult, RuntimeErrorType,
+};
 use crate::vm::types::{
     ASCIIData, BuffData, CharType, SequenceData, TypeSignature, UTF8Data, Value,
 };
@@ -123,9 +125,9 @@ macro_rules! type_force_binary_comparison_v2 {
                 vec![
                     TypeSignature::IntType,
                     TypeSignature::UIntType,
-                    TypeSignature::max_string_ascii(),
-                    TypeSignature::max_string_utf8(),
-                    TypeSignature::max_buffer(),
+                    TypeSignature::max_string_ascii()?,
+                    TypeSignature::max_string_utf8()?,
+                    TypeSignature::max_buffer()?,
                 ],
                 x,
             )
@@ -405,7 +407,11 @@ fn special_geq_v2(
     check_argument_count(2, args)?;
     let a = eval(&args[0], env, context)?;
     let b = eval(&args[1], env, context)?;
-    runtime_cost(ClarityCostFunction::Geq, env, cmp::min(a.size(), b.size()))?;
+    runtime_cost(
+        ClarityCostFunction::Geq,
+        env,
+        cmp::min(a.size()?, b.size()?),
+    )?;
     type_force_binary_comparison_v2!(geq, a, b)
 }
 
@@ -448,7 +454,11 @@ fn special_leq_v2(
     check_argument_count(2, args)?;
     let a = eval(&args[0], env, context)?;
     let b = eval(&args[1], env, context)?;
-    runtime_cost(ClarityCostFunction::Leq, env, cmp::min(a.size(), b.size()))?;
+    runtime_cost(
+        ClarityCostFunction::Leq,
+        env,
+        cmp::min(a.size()?, b.size()?),
+    )?;
     type_force_binary_comparison_v2!(leq, a, b)
 }
 
@@ -490,7 +500,7 @@ fn special_greater_v2(
     check_argument_count(2, args)?;
     let a = eval(&args[0], env, context)?;
     let b = eval(&args[1], env, context)?;
-    runtime_cost(ClarityCostFunction::Ge, env, cmp::min(a.size(), b.size()))?;
+    runtime_cost(ClarityCostFunction::Ge, env, cmp::min(a.size()?, b.size()?))?;
     type_force_binary_comparison_v2!(greater, a, b)
 }
 
@@ -532,7 +542,7 @@ fn special_less_v2(
     check_argument_count(2, args)?;
     let a = eval(&args[0], env, context)?;
     let b = eval(&args[1], env, context)?;
-    runtime_cost(ClarityCostFunction::Le, env, cmp::min(a.size(), b.size()))?;
+    runtime_cost(ClarityCostFunction::Le, env, cmp::min(a.size()?, b.size()?))?;
     type_force_binary_comparison_v2!(less, a, b)
 }
 
@@ -577,8 +587,9 @@ pub fn native_mod(a: Value, b: Value) -> InterpreterResult<Value> {
 
 pub fn native_bitwise_left_shift(input: Value, pos: Value) -> InterpreterResult<Value> {
     if let Value::UInt(u128_val) = pos {
-        let shamt =
-            u32::try_from(u128_val & 0x7f).expect("FATAL: lower 32 bits did not convert to u32");
+        let shamt = u32::try_from(u128_val & 0x7f).map_err(|_| {
+            InterpreterError::Expect("FATAL: lower 32 bits did not convert to u32".into())
+        })?;
 
         match input {
             Value::Int(input) => {
@@ -591,7 +602,7 @@ pub fn native_bitwise_left_shift(input: Value, pos: Value) -> InterpreterResult<
             }
             _ => Err(CheckErrors::UnionTypeError(
                 vec![TypeSignature::IntType, TypeSignature::UIntType],
-                TypeSignature::type_of(&input),
+                TypeSignature::type_of(&input)?,
             )
             .into()),
         }
@@ -602,8 +613,9 @@ pub fn native_bitwise_left_shift(input: Value, pos: Value) -> InterpreterResult<
 
 pub fn native_bitwise_right_shift(input: Value, pos: Value) -> InterpreterResult<Value> {
     if let Value::UInt(u128_val) = pos {
-        let shamt =
-            u32::try_from(u128_val & 0x7f).expect("FATAL: lower 32 bits did not convert to u32");
+        let shamt = u32::try_from(u128_val & 0x7f).map_err(|_| {
+            InterpreterError::Expect("FATAL: lower 32 bits did not convert to u32".into())
+        })?;
 
         match input {
             Value::Int(input) => {
@@ -616,7 +628,7 @@ pub fn native_bitwise_right_shift(input: Value, pos: Value) -> InterpreterResult
             }
             _ => Err(CheckErrors::UnionTypeError(
                 vec![TypeSignature::IntType, TypeSignature::UIntType],
-                TypeSignature::type_of(&input),
+                TypeSignature::type_of(&input)?,
             )
             .into()),
         }
diff --git a/clarity/src/vm/functions/assets.rs b/clarity/src/vm/functions/assets.rs
index d5b21c59aa..8b6643d36c 100644
--- a/clarity/src/vm/functions/assets.rs
+++ b/clarity/src/vm/functions/assets.rs
@@ -109,8 +109,8 @@ pub fn special_stx_balance(
             let mut snapshot = env
                 .global_context
                 .database
-                .get_stx_balance_snapshot(principal);
-            snapshot.get_available_balance()
+                .get_stx_balance_snapshot(principal)?;
+            snapshot.get_available_balance()?
         };
         Ok(Value::UInt(balance))
     } else {
@@ -141,16 +141,16 @@ pub fn stx_transfer_consolidated(
     }
 
     // loading from/to principals and balances
-    env.add_memory(TypeSignature::PrincipalType.size() as u64)?;
-    env.add_memory(TypeSignature::PrincipalType.size() as u64)?;
+    env.add_memory(TypeSignature::PrincipalType.size()? as u64)?;
+    env.add_memory(TypeSignature::PrincipalType.size()? as u64)?;
     // loading from's locked amount and height
     // TODO: this does not count the inner stacks block header load, but arguably,
     // this could be optimized away, so it shouldn't penalize the caller.
     env.add_memory(STXBalance::unlocked_and_v1_size as u64)?;
     env.add_memory(STXBalance::unlocked_and_v1_size as u64)?;
 
-    let mut sender_snapshot = env.global_context.database.get_stx_balance_snapshot(from);
-    if !sender_snapshot.can_transfer(amount) {
+    let mut sender_snapshot = env.global_context.database.get_stx_balance_snapshot(from)?;
+    if !sender_snapshot.can_transfer(amount)? {
         return clarity_ecode!(StxErrorCodes::NOT_ENOUGH_BALANCE);
     }
 
@@ -233,23 +233,31 @@ pub fn special_stx_account(
     let stx_balance = env
         .global_context
         .database
-        .get_stx_balance_snapshot(&principal)
-        .canonical_balance_repr();
+        .get_stx_balance_snapshot(&principal)?
+        .canonical_balance_repr()?;
     let v1_unlock_ht = env.global_context.database.get_v1_unlock_height();
-    let v2_unlock_ht = env.global_context.database.get_v2_unlock_height();
+    let v2_unlock_ht = env.global_context.database.get_v2_unlock_height()?;
 
     TupleData::from_data(vec![
         (
-            "unlocked".try_into().unwrap(),
+            "unlocked"
+                .try_into()
+                .map_err(|_| InterpreterError::Expect("Bad special tuple name".into()))?,
             Value::UInt(stx_balance.amount_unlocked()),
         ),
         (
-            "locked".try_into().unwrap(),
+            "locked"
+                .try_into()
+                .map_err(|_| InterpreterError::Expect("Bad special tuple name".into()))?,
             Value::UInt(stx_balance.amount_locked()),
         ),
         (
-            "unlock-height".try_into().unwrap(),
-            Value::UInt(stx_balance.effective_unlock_height(v1_unlock_ht, v2_unlock_ht) as u128),
+            "unlock-height"
+                .try_into()
+                .map_err(|_| InterpreterError::Expect("Bad special tuple name".into()))?,
+            Value::UInt(u128::from(
+                stx_balance.effective_unlock_height(v1_unlock_ht, v2_unlock_ht),
+            )),
         ),
     ])
     .map(|t| Value::Tuple(t))
@@ -276,16 +284,19 @@ pub fn special_stx_burn(
             return clarity_ecode!(StxErrorCodes::SENDER_IS_NOT_TX_SENDER);
         }
 
-        env.add_memory(TypeSignature::PrincipalType.size() as u64)?;
+        env.add_memory(TypeSignature::PrincipalType.size()? as u64)?;
         env.add_memory(STXBalance::unlocked_and_v1_size as u64)?;
 
-        let mut burner_snapshot = env.global_context.database.get_stx_balance_snapshot(&from);
-        if !burner_snapshot.can_transfer(amount) {
+        let mut burner_snapshot = env
+            .global_context
+            .database
+            .get_stx_balance_snapshot(&from)?;
+        if !burner_snapshot.can_transfer(amount)? {
             return clarity_ecode!(StxErrorCodes::NOT_ENOUGH_BALANCE);
         }
 
-        burner_snapshot.debit(amount);
-        burner_snapshot.save();
+        burner_snapshot.debit(amount)?;
+        burner_snapshot.save()?;
 
         env.global_context
             .database
@@ -339,10 +350,12 @@ pub fn special_mint_token(
             Some(ft_info),
         )?;
 
-        let final_to_bal = to_bal.checked_add(amount).expect("STX overflow");
+        let final_to_bal = to_bal
+            .checked_add(amount)
+            .ok_or_else(|| InterpreterError::Expect("STX overflow".into()))?;
 
-        env.add_memory(TypeSignature::PrincipalType.size() as u64)?;
-        env.add_memory(TypeSignature::UIntType.size() as u64)?;
+        env.add_memory(TypeSignature::PrincipalType.size()? as u64)?;
+        env.add_memory(TypeSignature::UIntType.size()? as u64)?;
 
         env.global_context.database.set_ft_balance(
             &env.contract_context.contract_identifier,
@@ -385,7 +398,7 @@ pub fn special_mint_asset_v200(
     runtime_cost(
         ClarityCostFunction::NftMint,
         env,
-        expected_asset_type.size(),
+        expected_asset_type.size()?,
     )?;
 
     if !expected_asset_type.admits(env.epoch(), &asset)? {
@@ -404,8 +417,8 @@ pub fn special_mint_asset_v200(
             Err(e) => Err(e),
         }?;
 
-        env.add_memory(TypeSignature::PrincipalType.size() as u64)?;
-        env.add_memory(expected_asset_type.size() as u64)?;
+        env.add_memory(TypeSignature::PrincipalType.size()? as u64)?;
+        env.add_memory(expected_asset_type.size()? as u64)?;
 
         let epoch = env.epoch().clone();
         env.global_context.database.set_nft_owner(
@@ -450,7 +463,9 @@ pub fn special_mint_asset_v205(
         .ok_or(CheckErrors::NoSuchNFT(asset_name.to_string()))?;
     let expected_asset_type = &nft_metadata.key_type;
 
-    let asset_size = asset.serialized_size() as u64;
+    let asset_size = asset
+        .serialized_size()
+        .map_err(|e| InterpreterError::Expect(e.to_string()))? as u64;
     runtime_cost(ClarityCostFunction::NftMint, env, asset_size)?;
 
     if !expected_asset_type.admits(env.epoch(), &asset)? {
@@ -469,7 +484,7 @@ pub fn special_mint_asset_v205(
             Err(e) => Err(e),
         }?;
 
-        env.add_memory(TypeSignature::PrincipalType.size() as u64)?;
+        env.add_memory(TypeSignature::PrincipalType.size()? as u64)?;
         env.add_memory(asset_size)?;
 
         let epoch = env.epoch().clone();
@@ -517,7 +532,7 @@ pub fn special_transfer_asset_v200(
     runtime_cost(
         ClarityCostFunction::NftTransfer,
         env,
-        expected_asset_type.size(),
+        expected_asset_type.size()?,
     )?;
 
     if !expected_asset_type.admits(env.epoch(), &asset)? {
@@ -546,8 +561,8 @@ pub fn special_transfer_asset_v200(
             return clarity_ecode!(TransferAssetErrorCodes::NOT_OWNED_BY);
         }
 
-        env.add_memory(TypeSignature::PrincipalType.size() as u64)?;
-        env.add_memory(expected_asset_type.size() as u64)?;
+        env.add_memory(TypeSignature::PrincipalType.size()? as u64)?;
+        env.add_memory(expected_asset_type.size()? as u64)?;
 
         let epoch = env.epoch().clone();
         env.global_context.database.set_nft_owner(
@@ -564,7 +579,7 @@ pub fn special_transfer_asset_v200(
             &env.contract_context.contract_identifier,
             asset_name,
             asset.clone(),
-        );
+        )?;
 
         let asset_identifier = AssetIdentifier {
             contract_identifier: env.contract_context.contract_identifier.clone(),
@@ -605,7 +620,9 @@ pub fn special_transfer_asset_v205(
         .ok_or(CheckErrors::NoSuchNFT(asset_name.to_string()))?;
     let expected_asset_type = &nft_metadata.key_type;
 
-    let asset_size = asset.serialized_size() as u64;
+    let asset_size = asset
+        .serialized_size()
+        .map_err(|e| InterpreterError::Expect(e.to_string()))? as u64;
     runtime_cost(ClarityCostFunction::NftTransfer, env, asset_size)?;
 
     if !expected_asset_type.admits(env.epoch(), &asset)? {
@@ -634,7 +651,7 @@ pub fn special_transfer_asset_v205(
             return clarity_ecode!(TransferAssetErrorCodes::NOT_OWNED_BY);
         }
 
-        env.add_memory(TypeSignature::PrincipalType.size() as u64)?;
+        env.add_memory(TypeSignature::PrincipalType.size()? as u64)?;
         env.add_memory(asset_size)?;
 
         let epoch = env.epoch().clone();
@@ -652,7 +669,7 @@ pub fn special_transfer_asset_v205(
             &env.contract_context.contract_identifier,
             asset_name,
             asset.clone(),
-        );
+        )?;
 
         let asset_identifier = AssetIdentifier {
             contract_identifier: env.contract_context.contract_identifier.clone(),
@@ -730,10 +747,10 @@ pub fn special_transfer_token(
             .checked_add(amount)
             .ok_or(RuntimeErrorType::ArithmeticOverflow)?;
 
-        env.add_memory(TypeSignature::PrincipalType.size() as u64)?;
-        env.add_memory(TypeSignature::PrincipalType.size() as u64)?;
-        env.add_memory(TypeSignature::UIntType.size() as u64)?;
-        env.add_memory(TypeSignature::UIntType.size() as u64)?;
+        env.add_memory(TypeSignature::PrincipalType.size()? as u64)?;
+        env.add_memory(TypeSignature::PrincipalType.size()? as u64)?;
+        env.add_memory(TypeSignature::UIntType.size()? as u64)?;
+        env.add_memory(TypeSignature::UIntType.size()? as u64)?;
 
         env.global_context.database.set_ft_balance(
             &env.contract_context.contract_identifier,
@@ -825,7 +842,7 @@ pub fn special_get_owner_v200(
     runtime_cost(
         ClarityCostFunction::NftOwner,
         env,
-        expected_asset_type.size(),
+        expected_asset_type.size()?,
     )?;
 
     if !expected_asset_type.admits(env.epoch(), &asset)? {
@@ -838,10 +855,9 @@ pub fn special_get_owner_v200(
         &asset,
         expected_asset_type,
     ) {
-        Ok(owner) => {
-            Ok(Value::some(Value::Principal(owner))
-                .expect("Principal should always fit in optional."))
-        }
+        Ok(owner) => Ok(Value::some(Value::Principal(owner)).map_err(|_| {
+            InterpreterError::Expect("Principal should always fit in optional.".into())
+        })?),
         Err(Error::Runtime(RuntimeErrorType::NoSuchToken, _)) => Ok(Value::none()),
         Err(e) => Err(e),
     }
@@ -867,7 +883,9 @@ pub fn special_get_owner_v205(
         .ok_or(CheckErrors::NoSuchNFT(asset_name.to_string()))?;
     let expected_asset_type = &nft_metadata.key_type;
 
-    let asset_size = asset.serialized_size() as u64;
+    let asset_size = asset
+        .serialized_size()
+        .map_err(|e| InterpreterError::Expect(e.to_string()))? as u64;
     runtime_cost(ClarityCostFunction::NftOwner, env, asset_size)?;
 
     if !expected_asset_type.admits(env.epoch(), &asset)? {
@@ -880,10 +898,9 @@ pub fn special_get_owner_v205(
         &asset,
         expected_asset_type,
     ) {
-        Ok(owner) => {
-            Ok(Value::some(Value::Principal(owner))
-                .expect("Principal should always fit in optional."))
-        }
+        Ok(owner) => Ok(Value::some(Value::Principal(owner)).map_err(|_| {
+            InterpreterError::Expect("Principal should always fit in optional.".into())
+        })?),
         Err(Error::Runtime(RuntimeErrorType::NoSuchToken, _)) => Ok(Value::none()),
         Err(e) => Err(e),
     }
@@ -958,8 +975,8 @@ pub fn special_burn_token(
         };
         env.register_ft_burn_event(burner.clone(), amount, asset_identifier)?;
 
-        env.add_memory(TypeSignature::PrincipalType.size() as u64)?;
-        env.add_memory(TypeSignature::UIntType.size() as u64)?;
+        env.add_memory(TypeSignature::PrincipalType.size()? as u64)?;
+        env.add_memory(TypeSignature::UIntType.size()? as u64)?;
 
         env.global_context.log_token_transfer(
             burner,
@@ -998,7 +1015,7 @@ pub fn special_burn_asset_v200(
     runtime_cost(
         ClarityCostFunction::NftBurn,
         env,
-        expected_asset_type.size(),
+        expected_asset_type.size()?,
     )?;
 
     if !expected_asset_type.admits(env.epoch(), &asset)? {
@@ -1023,8 +1040,8 @@ pub fn special_burn_asset_v200(
             return clarity_ecode!(BurnAssetErrorCodes::NOT_OWNED_BY);
         }
 
-        env.add_memory(TypeSignature::PrincipalType.size() as u64)?;
-        env.add_memory(expected_asset_type.size() as u64)?;
+        env.add_memory(TypeSignature::PrincipalType.size()? as u64)?;
+        env.add_memory(expected_asset_type.size()? as u64)?;
 
         let epoch = env.epoch().clone();
         env.global_context.database.burn_nft(
@@ -1040,7 +1057,7 @@ pub fn special_burn_asset_v200(
             &env.contract_context.contract_identifier,
             asset_name,
             asset.clone(),
-        );
+        )?;
 
         let asset_identifier = AssetIdentifier {
             contract_identifier: env.contract_context.contract_identifier.clone(),
@@ -1077,7 +1094,9 @@ pub fn special_burn_asset_v205(
         .ok_or(CheckErrors::NoSuchNFT(asset_name.to_string()))?;
     let expected_asset_type = &nft_metadata.key_type;
 
-    let asset_size = asset.serialized_size() as u64;
+    let asset_size = asset
+        .serialized_size()
+        .map_err(|e| InterpreterError::Expect(e.to_string()))? as u64;
     runtime_cost(ClarityCostFunction::NftBurn, env, asset_size)?;
 
     if !expected_asset_type.admits(env.epoch(), &asset)? {
@@ -1102,7 +1121,7 @@ pub fn special_burn_asset_v205(
             return clarity_ecode!(BurnAssetErrorCodes::NOT_OWNED_BY);
         }
 
-        env.add_memory(TypeSignature::PrincipalType.size() as u64)?;
+        env.add_memory(TypeSignature::PrincipalType.size()? as u64)?;
         env.add_memory(asset_size)?;
 
         let epoch = env.epoch().clone();
@@ -1119,7 +1138,7 @@ pub fn special_burn_asset_v205(
             &env.contract_context.contract_identifier,
             asset_name,
             asset.clone(),
-        );
+        )?;
 
         let asset_identifier = AssetIdentifier {
             contract_identifier: env.contract_context.contract_identifier.clone(),
diff --git a/clarity/src/vm/functions/conversions.rs b/clarity/src/vm/functions/conversions.rs
index 594c8f6ec8..8d913be767 100644
--- a/clarity/src/vm/functions/conversions.rs
+++ b/clarity/src/vm/functions/conversions.rs
@@ -19,7 +19,9 @@ use stacks_common::types::StacksEpochId;
 
 use crate::vm::costs::cost_functions::ClarityCostFunction;
 use crate::vm::costs::runtime_cost;
-use crate::vm::errors::{check_argument_count, CheckErrors, InterpreterResult as Result};
+use crate::vm::errors::{
+    check_argument_count, CheckErrors, InterpreterError, InterpreterResult as Result,
+};
 use crate::vm::representations::SymbolicExpression;
 use crate::vm::types::SequenceSubtype::{BufferType, StringType};
 use crate::vm::types::StringSubtype::ASCII;
@@ -52,9 +54,14 @@ pub fn buff_to_int_generic(
 ) -> Result<Value> {
     match value {
         Value::Sequence(SequenceData::Buffer(ref sequence_data)) => {
-            if sequence_data.len() > BufferLength::try_from(16_u32).unwrap() {
+            if sequence_data.len()?
+                > BufferLength::try_from(16_u32)
+                    .map_err(|_| InterpreterError::Expect("Failed to construct".into()))?
+            {
                 return Err(CheckErrors::TypeValueError(
-                    SequenceType(BufferType(BufferLength::try_from(16_u32).unwrap())),
+                    SequenceType(BufferType(BufferLength::try_from(16_u32).map_err(
+                        |_| InterpreterError::Expect("Failed to construct".into()),
+                    )?)),
                     value,
                 )
                 .into());
@@ -78,7 +85,9 @@ pub fn buff_to_int_generic(
         }
         _ => {
             return Err(CheckErrors::TypeValueError(
-                SequenceType(BufferType(BufferLength::try_from(16_u32).unwrap())),
+                SequenceType(BufferType(BufferLength::try_from(16_u32).map_err(
+                    |_| InterpreterError::Expect("Failed to construct".into()),
+                )?)),
                 value,
             )
             .into())
@@ -143,8 +152,8 @@ pub fn native_string_to_int_generic(
         }
         _ => Err(CheckErrors::UnionTypeValueError(
             vec![
-                TypeSignature::max_string_ascii(),
-                TypeSignature::max_string_utf8(),
+                TypeSignature::max_string_ascii()?,
+                TypeSignature::max_string_utf8()?,
             ],
             value,
         )
@@ -187,13 +196,15 @@ pub fn native_int_to_string_generic(
     match value {
         Value::Int(ref int_value) => {
             let as_string = int_value.to_string();
-            Ok(bytes_to_value_fn(as_string.into())
-                .expect("Unexpected error converting Int to string."))
+            Ok(bytes_to_value_fn(as_string.into()).map_err(|_| {
+                InterpreterError::Expect("Unexpected error converting Int to string.".into())
+            })?)
         }
         Value::UInt(ref uint_value) => {
             let as_string = uint_value.to_string();
-            Ok(bytes_to_value_fn(as_string.into())
-                .expect("Unexpected error converting UInt to string."))
+            Ok(bytes_to_value_fn(as_string.into()).map_err(|_| {
+                InterpreterError::Expect("Unexpected error converting UInt to string.".into())
+            })?)
         }
         _ => Err(CheckErrors::UnionTypeValueError(
             vec![TypeSignature::IntType, TypeSignature::UIntType],
@@ -220,7 +231,7 @@ pub fn to_consensus_buff(value: Value) -> Result<Value> {
     let mut clar_buff_serialized = vec![];
     value
         .serialize_write(&mut clar_buff_serialized)
-        .expect("FATAL: failed to serialize to vec");
+        .map_err(|_| InterpreterError::Expect("FATAL: failed to serialize to vec".into()))?;
 
     let clar_buff_serialized = match Value::buff_from(clar_buff_serialized) {
         Ok(x) => x,
@@ -252,7 +263,7 @@ pub fn from_consensus_buff(
         Ok(buff_data.data)
     } else {
         Err(CheckErrors::TypeValueError(
-            TypeSignature::max_buffer(),
+            TypeSignature::max_buffer()?,
             value,
         ))
     }?;
diff --git a/clarity/src/vm/functions/crypto.rs b/clarity/src/vm/functions/crypto.rs
index a468df5157..c823313939 100644
--- a/clarity/src/vm/functions/crypto.rs
+++ b/clarity/src/vm/functions/crypto.rs
@@ -20,7 +20,7 @@ use crate::vm::costs::{
     constants as cost_constants, cost_functions, runtime_cost, CostTracker, MemoryConsumer,
 };
 use crate::vm::errors::{
-    check_argument_count, check_arguments_at_least, CheckErrors, Error,
+    check_argument_count, check_arguments_at_least, CheckErrors, Error, InterpreterError,
     InterpreterResult as Result, RuntimeErrorType, ShortReturnType,
 };
 use crate::vm::representations::SymbolicExpressionType::{Atom, List};
@@ -51,7 +51,7 @@ macro_rules! native_hash_func {
                     vec![
                         TypeSignature::IntType,
                         TypeSignature::UIntType,
-                        TypeSignature::max_buffer(),
+                        TypeSignature::max_buffer()?,
                     ],
                     input,
                 )),
@@ -70,19 +70,19 @@ native_hash_func!(native_keccak256, hash::Keccak256Hash);
 
 // Note: Clarity1 had a bug in how the address is computed (issues/2619).
 // This method preserves the old, incorrect behavior for those running Clarity1.
-fn pubkey_to_address_v1(pub_key: Secp256k1PublicKey) -> StacksAddress {
+fn pubkey_to_address_v1(pub_key: Secp256k1PublicKey) -> Result<StacksAddress> {
     StacksAddress::from_public_keys(
         C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
         &AddressHashMode::SerializeP2PKH,
         1,
         &vec![pub_key],
     )
-    .unwrap()
+    .ok_or_else(|| InterpreterError::Expect("Failed to create address from pubkey".into()).into())
 }
 
 // Note: Clarity1 had a bug in how the address is computed (issues/2619).
 // This version contains the code for Clarity2 and going forward.
-fn pubkey_to_address_v2(pub_key: Secp256k1PublicKey, is_mainnet: bool) -> StacksAddress {
+fn pubkey_to_address_v2(pub_key: Secp256k1PublicKey, is_mainnet: bool) -> Result<StacksAddress> {
     let network_byte = if is_mainnet {
         C32_ADDRESS_VERSION_MAINNET_SINGLESIG
     } else {
@@ -94,7 +94,7 @@ fn pubkey_to_address_v2(pub_key: Secp256k1PublicKey, is_mainnet: bool) -> Stacks
         1,
         &vec![pub_key],
     )
-    .unwrap()
+    .ok_or_else(|| InterpreterError::Expect("Failed to create address from pubkey".into()).into())
 }
 
 pub fn special_principal_of(
@@ -123,12 +123,13 @@ pub fn special_principal_of(
         // Note: Clarity1 had a bug in how the address is computed (issues/2619).
         // We want to preserve the old behavior unless the version is greater.
         let addr = if *env.contract_context.get_clarity_version() > ClarityVersion::Clarity1 {
-            pubkey_to_address_v2(pub_key, env.global_context.mainnet)
+            pubkey_to_address_v2(pub_key, env.global_context.mainnet)?
         } else {
-            pubkey_to_address_v1(pub_key)
+            pubkey_to_address_v1(pub_key)?
         };
         let principal = addr.to_account_principal();
-        return Ok(Value::okay(Value::Principal(principal)).unwrap());
+        return Ok(Value::okay(Value::Principal(principal))
+            .map_err(|_| InterpreterError::Expect("Failed to construct ok".into()))?);
     } else {
         return Ok(Value::err_uint(1));
     }
@@ -172,7 +173,13 @@ pub fn special_secp256k1_recover(
 
     match secp256k1_recover(&message, &signature).map_err(|_| CheckErrors::InvalidSecp65k1Signature)
     {
-        Ok(pubkey) => return Ok(Value::okay(Value::buff_from(pubkey.to_vec()).unwrap()).unwrap()),
+        Ok(pubkey) => {
+            return Ok(Value::okay(
+                Value::buff_from(pubkey.to_vec())
+                    .map_err(|_| InterpreterError::Expect("Failed to construct buff".into()))?,
+            )
+            .map_err(|_| InterpreterError::Expect("Failed to construct ok".into()))?)
+        }
         _ => return Ok(Value::err_uint(1)),
     };
 }
diff --git a/clarity/src/vm/functions/database.rs b/clarity/src/vm/functions/database.rs
index d4f6080c5a..5be892cf5f 100644
--- a/clarity/src/vm/functions/database.rs
+++ b/clarity/src/vm/functions/database.rs
@@ -80,7 +80,7 @@ pub fn special_contract_call(
     let mut rest_args_sizes = vec![];
     for arg in args[2..].iter() {
         let evaluated_arg = eval(arg, env, context)?;
-        rest_args_sizes.push(evaluated_arg.size() as u64);
+        rest_args_sizes.push(evaluated_arg.size()? as u64);
         rest_args.push(SymbolicExpression::atom_value(evaluated_arg));
     }
 
@@ -205,14 +205,14 @@ pub fn special_contract_call(
     }?;
 
     // sanitize contract-call outputs in epochs >= 2.4
-    let result_type = TypeSignature::type_of(&result);
+    let result_type = TypeSignature::type_of(&result)?;
     let (result, _) = Value::sanitize_value(env.epoch(), &result_type, result)
         .ok_or_else(|| CheckErrors::CouldNotDetermineType)?;
 
     // Ensure that the expected type from the trait spec admits
     // the type of the value returned by the dynamic dispatch.
     if let Some(returns_type_signature) = type_returns_constraint {
-        let actual_returns = TypeSignature::type_of(&result);
+        let actual_returns = TypeSignature::type_of(&result)?;
         if !returns_type_signature.admits_type(env.epoch(), &actual_returns)? {
             return Err(
                 CheckErrors::ReturnTypesMustMatch(returns_type_signature, actual_returns).into(),
@@ -243,7 +243,7 @@ pub fn special_fetch_variable_v200(
     runtime_cost(
         ClarityCostFunction::FetchVar,
         env,
-        data_types.value_type.size(),
+        data_types.value_type.size()?,
     )?;
 
     let epoch = env.epoch().clone();
@@ -279,7 +279,7 @@ pub fn special_fetch_variable_v205(
 
     let result_size = match &result {
         Ok(data) => data.serialized_byte_len,
-        Err(_e) => data_types.value_type.size() as u64,
+        Err(_e) => data_types.value_type.size()? as u64,
     };
 
     runtime_cost(ClarityCostFunction::FetchVar, env, result_size)?;
@@ -313,10 +313,10 @@ pub fn special_set_variable_v200(
     runtime_cost(
         ClarityCostFunction::SetVar,
         env,
-        data_types.value_type.size(),
+        data_types.value_type.size()?,
     )?;
 
-    env.add_memory(value.get_memory_use())?;
+    env.add_memory(value.get_memory_use()?)?;
 
     let epoch = env.epoch().clone();
     env.global_context
@@ -358,7 +358,7 @@ pub fn special_set_variable_v205(
 
     let result_size = match &result {
         Ok(data) => data.serialized_byte_len,
-        Err(_e) => data_types.value_type.size() as u64,
+        Err(_e) => data_types.value_type.size()? as u64,
     };
 
     runtime_cost(ClarityCostFunction::SetVar, env, result_size)?;
@@ -390,7 +390,7 @@ pub fn special_fetch_entry_v200(
     runtime_cost(
         ClarityCostFunction::FetchEntry,
         env,
-        data_types.value_type.size() + data_types.key_type.size(),
+        data_types.value_type.size()? + data_types.key_type.size()?,
     )?;
 
     let epoch = env.epoch().clone();
@@ -428,7 +428,7 @@ pub fn special_fetch_entry_v205(
 
     let result_size = match &result {
         Ok(data) => data.serialized_byte_len,
-        Err(_e) => (data_types.value_type.size() + data_types.key_type.size()) as u64,
+        Err(_e) => (data_types.value_type.size()? + data_types.key_type.size()?) as u64,
     };
 
     runtime_cost(ClarityCostFunction::FetchEntry, env, result_size)?;
@@ -458,7 +458,7 @@ pub fn special_at_block(
 
     env.add_memory(cost_constants::AT_BLOCK_MEMORY)?;
     let result = env.evaluate_at_block(bhh, &args[1], context);
-    env.drop_memory(cost_constants::AT_BLOCK_MEMORY);
+    env.drop_memory(cost_constants::AT_BLOCK_MEMORY)?;
 
     result
 }
@@ -491,11 +491,11 @@ pub fn special_set_entry_v200(
     runtime_cost(
         ClarityCostFunction::SetEntry,
         env,
-        data_types.value_type.size() + data_types.key_type.size(),
+        data_types.value_type.size()? + data_types.key_type.size()?,
     )?;
 
-    env.add_memory(key.get_memory_use())?;
-    env.add_memory(value.get_memory_use())?;
+    env.add_memory(key.get_memory_use()?)?;
+    env.add_memory(value.get_memory_use()?)?;
 
     let epoch = env.epoch().clone();
     env.global_context
@@ -539,7 +539,7 @@ pub fn special_set_entry_v205(
 
     let result_size = match &result {
         Ok(data) => data.serialized_byte_len,
-        Err(_e) => (data_types.value_type.size() + data_types.key_type.size()) as u64,
+        Err(_e) => (data_types.value_type.size()? + data_types.key_type.size()?) as u64,
     };
 
     runtime_cost(ClarityCostFunction::SetEntry, env, result_size)?;
@@ -577,11 +577,11 @@ pub fn special_insert_entry_v200(
     runtime_cost(
         ClarityCostFunction::SetEntry,
         env,
-        data_types.value_type.size() + data_types.key_type.size(),
+        data_types.value_type.size()? + data_types.key_type.size()?,
     )?;
 
-    env.add_memory(key.get_memory_use())?;
-    env.add_memory(value.get_memory_use())?;
+    env.add_memory(key.get_memory_use()?)?;
+    env.add_memory(value.get_memory_use()?)?;
 
     let epoch = env.epoch().clone();
 
@@ -626,7 +626,7 @@ pub fn special_insert_entry_v205(
 
     let result_size = match &result {
         Ok(data) => data.serialized_byte_len,
-        Err(_e) => (data_types.value_type.size() + data_types.key_type.size()) as u64,
+        Err(_e) => (data_types.value_type.size()? + data_types.key_type.size()?) as u64,
     };
 
     runtime_cost(ClarityCostFunction::SetEntry, env, result_size)?;
@@ -662,10 +662,10 @@ pub fn special_delete_entry_v200(
     runtime_cost(
         ClarityCostFunction::SetEntry,
         env,
-        data_types.key_type.size(),
+        data_types.key_type.size()?,
     )?;
 
-    env.add_memory(key.get_memory_use())?;
+    env.add_memory(key.get_memory_use()?)?;
 
     let epoch = env.epoch().clone();
     env.global_context
@@ -707,7 +707,7 @@ pub fn special_delete_entry_v205(
 
     let result_size = match &result {
         Ok(data) => data.serialized_byte_len,
-        Err(_e) => data_types.key_type.size() as u64,
+        Err(_e) => data_types.key_type.size()? as u64,
     };
 
     runtime_cost(ClarityCostFunction::SetEntry, env, result_size)?;
@@ -757,11 +757,14 @@ pub fn special_get_block_info(
 
     let result = match block_info_prop {
         BlockInfoProperty::Time => {
-            let block_time = env.global_context.database.get_block_time(height_value);
-            Value::UInt(block_time as u128)
+            let block_time = env.global_context.database.get_block_time(height_value)?;
+            Value::UInt(u128::from(block_time))
         }
         BlockInfoProperty::VrfSeed => {
-            let vrf_seed = env.global_context.database.get_block_vrf_seed(height_value);
+            let vrf_seed = env
+                .global_context
+                .database
+                .get_block_vrf_seed(height_value)?;
             Value::Sequence(SequenceData::Buffer(BuffData {
                 data: vrf_seed.as_bytes().to_vec(),
             }))
@@ -770,7 +773,7 @@ pub fn special_get_block_info(
             let header_hash = env
                 .global_context
                 .database
-                .get_block_header_hash(height_value);
+                .get_block_header_hash(height_value)?;
             Value::Sequence(SequenceData::Buffer(BuffData {
                 data: header_hash.as_bytes().to_vec(),
             }))
@@ -779,7 +782,7 @@ pub fn special_get_block_info(
             let burnchain_header_hash = env
                 .global_context
                 .database
-                .get_burnchain_block_header_hash(height_value);
+                .get_burnchain_block_header_hash(height_value)?;
             Value::Sequence(SequenceData::Buffer(BuffData {
                 data: burnchain_header_hash.as_bytes().to_vec(),
             }))
@@ -788,32 +791,35 @@ pub fn special_get_block_info(
             let id_header_hash = env
                 .global_context
                 .database
-                .get_index_block_header_hash(height_value);
+                .get_index_block_header_hash(height_value)?;
             Value::Sequence(SequenceData::Buffer(BuffData {
                 data: id_header_hash.as_bytes().to_vec(),
             }))
         }
         BlockInfoProperty::MinerAddress => {
-            let miner_address = env.global_context.database.get_miner_address(height_value);
+            let miner_address = env
+                .global_context
+                .database
+                .get_miner_address(height_value)?;
             Value::from(miner_address)
         }
         BlockInfoProperty::MinerSpendWinner => {
             let winner_spend = env
                 .global_context
                 .database
-                .get_miner_spend_winner(height_value);
+                .get_miner_spend_winner(height_value)?;
             Value::UInt(winner_spend)
         }
         BlockInfoProperty::MinerSpendTotal => {
             let total_spend = env
                 .global_context
                 .database
-                .get_miner_spend_total(height_value);
+                .get_miner_spend_total(height_value)?;
             Value::UInt(total_spend)
         }
         BlockInfoProperty::BlockReward => {
             // this is already an optional
-            let block_reward_opt = env.global_context.database.get_block_reward(height_value);
+            let block_reward_opt = env.global_context.database.get_block_reward(height_value)?;
             return Ok(match block_reward_opt {
                 Some(x) => Value::some(Value::UInt(x))?,
                 None => Value::none(),
@@ -872,7 +878,7 @@ pub fn special_get_burn_block_info(
             let burnchain_header_hash_opt = env
                 .global_context
                 .database
-                .get_burnchain_block_header_hash_for_burnchain_height(height_value);
+                .get_burnchain_block_header_hash_for_burnchain_height(height_value)?;
 
             match burnchain_header_hash_opt {
                 Some(burnchain_header_hash) => {
@@ -887,7 +893,7 @@ pub fn special_get_burn_block_info(
             let pox_addrs_and_payout = env
                 .global_context
                 .database
-                .get_pox_payout_addrs_for_burnchain_height(height_value);
+                .get_pox_payout_addrs_for_burnchain_height(height_value)?;
 
             match pox_addrs_and_payout {
                 Some((addrs, payout)) => Ok(Value::some(Value::Tuple(
@@ -901,13 +907,21 @@ pub fn special_get_burn_block_info(
                                     .collect(),
                                 env.epoch(),
                             )
-                            .expect("FATAL: could not convert address list to Value"),
+                            .map_err(|_| {
+                                InterpreterError::Expect(
+                                    "FATAL: could not convert address list to Value".into(),
+                                )
+                            })?,
                         ),
                         ("payout".into(), Value::UInt(payout)),
                     ])
-                    .expect("FATAL: failed to build pox addrs and payout tuple"),
+                    .map_err(|_| {
+                        InterpreterError::Expect(
+                            "FATAL: failed to build pox addrs and payout tuple".into(),
+                        )
+                    })?,
                 ))
-                .expect("FATAL: could not build Some(..)")),
+                .map_err(|_| InterpreterError::Expect("FATAL: could not build Some(..)".into()))?),
                 None => Ok(Value::none()),
             }
         }
diff --git a/clarity/src/vm/functions/mod.rs b/clarity/src/vm/functions/mod.rs
index da8cbde4d1..4708624f93 100644
--- a/clarity/src/vm/functions/mod.rs
+++ b/clarity/src/vm/functions/mod.rs
@@ -584,10 +584,13 @@ fn native_eq(args: Vec<Value>, env: &mut Environment) -> Result<Value> {
     } else {
         let first = &args[0];
         // check types:
-        let mut arg_type = TypeSignature::type_of(first);
+        let mut arg_type = TypeSignature::type_of(first)?;
         for x in args.iter() {
-            arg_type =
-                TypeSignature::least_supertype(env.epoch(), &TypeSignature::type_of(x), &arg_type)?;
+            arg_type = TypeSignature::least_supertype(
+                env.epoch(),
+                &TypeSignature::type_of(x)?,
+                &arg_type,
+            )?;
             if x != first {
                 return Ok(Value::Bool(false));
             }
@@ -613,7 +616,7 @@ fn special_print(
     })?;
     let input = eval(arg, env, context)?;
 
-    runtime_cost(ClarityCostFunction::Print, env, input.size())?;
+    runtime_cost(ClarityCostFunction::Print, env, input.size()?)?;
 
     if cfg!(feature = "developer-mode") {
         debug!("{}", &input);
@@ -738,7 +741,7 @@ fn special_let(
 
             let binding_value = eval(var_sexp, env, &inner_context)?;
 
-            let bind_mem_use = binding_value.get_memory_use();
+            let bind_mem_use = binding_value.get_memory_use()?;
             env.add_memory(bind_mem_use)?;
             memory_use += bind_mem_use; // no check needed, b/c it's done in add_memory.
             if *env.contract_context.get_clarity_version() >= ClarityVersion::Clarity2 {
@@ -757,7 +760,7 @@ fn special_let(
             last_result.replace(body_result);
         }
         // last_result should always be Some(...), because of the arg len check above.
-        Ok(last_result.unwrap())
+        last_result.ok_or_else(|| InterpreterError::Expect("Failed to get let result".into()).into())
     })
 }
 
@@ -783,7 +786,7 @@ fn special_as_contract(
 
     let result = eval(&args[0], &mut nested_env, context);
 
-    env.drop_memory(cost_constants::AS_CONTRACT_MEMORY);
+    env.drop_memory(cost_constants::AS_CONTRACT_MEMORY)?;
 
     result
 }
diff --git a/clarity/src/vm/functions/options.rs b/clarity/src/vm/functions/options.rs
index 79f7784b8d..84145cf313 100644
--- a/clarity/src/vm/functions/options.rs
+++ b/clarity/src/vm/functions/options.rs
@@ -18,8 +18,8 @@ use crate::vm::contexts::{Environment, LocalContext};
 use crate::vm::costs::cost_functions::ClarityCostFunction;
 use crate::vm::costs::{cost_functions, runtime_cost, CostTracker, MemoryConsumer};
 use crate::vm::errors::{
-    check_argument_count, check_arguments_at_least, CheckErrors, InterpreterResult as Result,
-    RuntimeErrorType, ShortReturnType,
+    check_argument_count, check_arguments_at_least, CheckErrors, InterpreterError,
+    InterpreterResult as Result, RuntimeErrorType, ShortReturnType,
 };
 use crate::vm::types::{CallableData, OptionalData, ResponseData, TypeSignature, Value};
 use crate::vm::Value::CallableContract;
@@ -98,8 +98,11 @@ pub fn native_try_ret(input: Value) -> Result<Value> {
             if data.committed {
                 Ok(*data.data)
             } else {
-                let short_return_val = Value::error(*data.data)
-                    .expect("BUG: Failed to construct new response type from old response type");
+                let short_return_val = Value::error(*data.data).map_err(|_| {
+                    InterpreterError::Expect(
+                        "BUG: Failed to construct new response type from old response type".into(),
+                    )
+                })?;
                 Err(ShortReturnType::ExpectedValue(short_return_val).into())
             }
         }
@@ -122,7 +125,7 @@ fn eval_with_new_binding(
         return Err(CheckErrors::NameAlreadyUsed(bind_name.into()).into());
     }
 
-    let memory_use = bind_value.get_memory_use();
+    let memory_use = bind_value.get_memory_use()?;
     env.add_memory(memory_use)?;
 
     if *env.contract_context.get_clarity_version() >= ClarityVersion::Clarity2 {
@@ -139,7 +142,7 @@ fn eval_with_new_binding(
     inner_context.variables.insert(bind_name, bind_value);
     let result = vm::eval(body, env, &inner_context);
 
-    env.drop_memory(memory_use);
+    env.drop_memory(memory_use)?;
 
     result
 }
@@ -213,7 +216,7 @@ pub fn special_match(
     match input {
         Value::Response(data) => special_match_resp(data, &args[1..], env, context),
         Value::Optional(data) => special_match_opt(data, &args[1..], env, context),
-        _ => return Err(CheckErrors::BadMatchInput(TypeSignature::type_of(&input)).into()),
+        _ => return Err(CheckErrors::BadMatchInput(TypeSignature::type_of(&input)?).into()),
     }
 }
 
diff --git a/clarity/src/vm/functions/principals.rs b/clarity/src/vm/functions/principals.rs
index 4f89e0fc46..c22df6208a 100644
--- a/clarity/src/vm/functions/principals.rs
+++ b/clarity/src/vm/functions/principals.rs
@@ -84,8 +84,8 @@ fn create_principal_destruct_tuple(
     version: u8,
     hash_bytes: &[u8; 20],
     name_opt: Option<ContractName>,
-) -> Value {
-    Value::Tuple(
+) -> Result<Value> {
+    Ok(Value::Tuple(
         TupleData::from_data(vec![
             (
                 "version".into(),
@@ -106,23 +106,25 @@ fn create_principal_destruct_tuple(
                 }),
             ),
         ])
-        .expect("FAIL: Failed to initialize tuple."),
-    )
+        .map_err(|_| InterpreterError::Expect("FAIL: Failed to initialize tuple.".into()))?,
+    ))
 }
 
 /// Creates Response return type, to wrap an *actual error* result of a `principal-construct`.
 ///
 /// The response is an error Response, where the `err` value is a tuple `{error_code, parse_tuple}`.
 /// `error_int` is of type `UInt`, `parse_tuple` is None.
-fn create_principal_true_error_response(error_int: PrincipalConstructErrorCode) -> Value {
+fn create_principal_true_error_response(error_int: PrincipalConstructErrorCode) -> Result<Value> {
     Value::error(Value::Tuple(
         TupleData::from_data(vec![
             ("error_code".into(), Value::UInt(error_int as u128)),
             ("value".into(), Value::none()),
         ])
-        .expect("FAIL: Failed to initialize tuple."),
+        .map_err(|_| InterpreterError::Expect("FAIL: Failed to initialize tuple.".into()))?,
     ))
-    .expect("FAIL: Failed to initialize (err ..) response")
+    .map_err(|_| {
+        InterpreterError::Expect("FAIL: Failed to initialize (err ..) response".into()).into()
+    })
 }
 
 /// Creates Response return type, to wrap a *return value returned as an error* result of a
@@ -133,18 +135,22 @@ fn create_principal_true_error_response(error_int: PrincipalConstructErrorCode)
 fn create_principal_value_error_response(
     error_int: PrincipalConstructErrorCode,
     value: Value,
-) -> Value {
+) -> Result<Value> {
     Value::error(Value::Tuple(
         TupleData::from_data(vec![
             ("error_code".into(), Value::UInt(error_int as u128)),
             (
                 "value".into(),
-                Value::some(value).expect("Unexpected problem creating Value."),
+                Value::some(value).map_err(|_| {
+                    InterpreterError::Expect("Unexpected problem creating Value.".into())
+                })?,
             ),
         ])
-        .expect("FAIL: Failed to initialize tuple."),
+        .map_err(|_| InterpreterError::Expect("FAIL: Failed to initialize tuple.".into()))?,
     ))
-    .expect("FAIL: Failed to initialize (err ..) response")
+    .map_err(|_| {
+        InterpreterError::Expect("FAIL: Failed to initialize (err ..) response".into()).into()
+    })
 }
 
 pub fn special_principal_destruct(
@@ -173,7 +179,7 @@ pub fn special_principal_destruct(
     // channel or the error channel.
     let version_byte_is_valid = version_matches_current_network(version_byte, env.global_context);
 
-    let tuple = create_principal_destruct_tuple(version_byte, &hash_bytes, name_opt);
+    let tuple = create_principal_destruct_tuple(version_byte, &hash_bytes, name_opt)?;
     Ok(Value::Response(ResponseData {
         committed: version_byte_is_valid,
         data: Box::new(tuple),
@@ -214,9 +220,7 @@ pub fn special_principal_construct(
     } else if verified_version.len() == 0 {
         // the type checker does not check the actual length of the buffer, but a 0-length buffer
         // will type-check to (buff 1)
-        return Ok(create_principal_true_error_response(
-            PrincipalConstructErrorCode::BUFFER_LENGTH,
-        ));
+        return create_principal_true_error_response(PrincipalConstructErrorCode::BUFFER_LENGTH);
     } else {
         (*verified_version)[0]
     };
@@ -224,9 +228,7 @@ pub fn special_principal_construct(
     // If the version byte is >= 32, this is a runtime error, because it wasn't the job of the
     // type system.  This is a requirement for c32check encoding.
     if version_byte >= 32 {
-        return Ok(create_principal_true_error_response(
-            PrincipalConstructErrorCode::BUFFER_LENGTH,
-        ));
+        return create_principal_true_error_response(PrincipalConstructErrorCode::BUFFER_LENGTH);
     }
 
     // `version_byte_is_valid` determines whether the returned `Response` is through the success
@@ -249,9 +251,7 @@ pub fn special_principal_construct(
     // If the hash-bytes buffer has less than 20 bytes, this is a runtime error, because it
     // wasn't the job of the type system (i.e. (buff X) for all X < 20 are all also (buff 20))
     if verified_hash_bytes.len() < 20 {
-        return Ok(create_principal_true_error_response(
-            PrincipalConstructErrorCode::BUFFER_LENGTH,
-        ));
+        return create_principal_true_error_response(PrincipalConstructErrorCode::BUFFER_LENGTH);
     }
 
     // Construct the principal.
@@ -266,7 +266,7 @@ pub fn special_principal_construct(
             Value::Sequence(SequenceData::String(CharType::ASCII(ascii_data))) => ascii_data,
             _ => {
                 return Err(CheckErrors::TypeValueError(
-                    TypeSignature::contract_name_string_ascii_type(),
+                    TypeSignature::contract_name_string_ascii_type()?,
                     name,
                 )
                 .into())
@@ -275,15 +275,15 @@ pub fn special_principal_construct(
 
         // If it's not long enough, then it's a runtime error that warrants an (err ..) response.
         if name_bytes.data.len() < CONTRACT_MIN_NAME_LENGTH {
-            return Ok(create_principal_true_error_response(
+            return create_principal_true_error_response(
                 PrincipalConstructErrorCode::CONTRACT_NAME,
-            ));
+            );
         }
 
         // if it's too long, then this should have been caught by the type-checker
         if name_bytes.data.len() > CONTRACT_MAX_NAME_LENGTH {
             return Err(CheckErrors::TypeValueError(
-                TypeSignature::contract_name_string_ascii_type(),
+                TypeSignature::contract_name_string_ascii_type()?,
                 Value::from(name_bytes),
             )
             .into());
@@ -292,17 +292,20 @@ pub fn special_principal_construct(
         // The type-checker can't verify that the name is a valid ContractName, so we'll need to do
         // it here at runtime.  If it's not valid, then it warrants this function evaluating to
         // (err ..).
-        let name_string = String::from_utf8(name_bytes.data).expect(
-            "FAIL: could not convert bytes of type (string-ascii 40) back to a UTF-8 string",
-        );
+        let name_string = String::from_utf8(name_bytes.data).map_err(|_| {
+            InterpreterError::Expect(
+                "FAIL: could not convert bytes of type (string-ascii 40) back to a UTF-8 string"
+                    .into(),
+            )
+        })?;
 
         let contract_name = match ContractName::try_from(name_string) {
             Ok(cn) => cn,
             Err(_) => {
                 // not a valid contract name
-                return Ok(create_principal_true_error_response(
+                return create_principal_true_error_response(
                     PrincipalConstructErrorCode::CONTRACT_NAME,
-                ));
+                );
             }
         };
 
@@ -316,11 +319,10 @@ pub fn special_principal_construct(
     };
 
     if version_byte_is_valid {
-        Ok(Value::okay(principal).expect("FAIL: failed to build an (ok ..) response"))
+        Ok(Value::okay(principal).map_err(|_| {
+            InterpreterError::Expect("FAIL: failed to build an (ok ..) response".into())
+        })?)
     } else {
-        Ok(create_principal_value_error_response(
-            PrincipalConstructErrorCode::VERSION_BYTE,
-            principal,
-        ))
+        create_principal_value_error_response(PrincipalConstructErrorCode::VERSION_BYTE, principal)
     }
 }
diff --git a/clarity/src/vm/functions/sequences.rs b/clarity/src/vm/functions/sequences.rs
index 801498f60c..656c5661af 100644
--- a/clarity/src/vm/functions/sequences.rs
+++ b/clarity/src/vm/functions/sequences.rs
@@ -40,7 +40,7 @@ pub fn list_cons(
 
     let mut arg_size = 0;
     for a in args.iter() {
-        arg_size = arg_size.cost_overflow_add(a.size().into())?;
+        arg_size = arg_size.cost_overflow_add(a.size()?.into())?;
     }
 
     runtime_cost(ClarityCostFunction::ListCons, env, arg_size)?;
@@ -74,7 +74,7 @@ pub fn special_filter(
                 }
             })?;
         }
-        _ => return Err(CheckErrors::ExpectedSequence(TypeSignature::type_of(&sequence)).into()),
+        _ => return Err(CheckErrors::ExpectedSequence(TypeSignature::type_of(&sequence)?).into()),
     };
     Ok(sequence)
 }
@@ -95,20 +95,18 @@ pub fn special_fold(
     let initial = eval(&args[2], env, context)?;
 
     match sequence {
-        Value::Sequence(ref mut sequence_data) => {
-            sequence_data
-                .atom_values()
-                .into_iter()
-                .try_fold(initial, |acc, x| {
-                    apply(
-                        &function,
-                        &[x, SymbolicExpression::atom_value(acc)],
-                        env,
-                        context,
-                    )
-                })
-        }
-        _ => Err(CheckErrors::ExpectedSequence(TypeSignature::type_of(&sequence)).into()),
+        Value::Sequence(ref mut sequence_data) => sequence_data
+            .atom_values()?
+            .into_iter()
+            .try_fold(initial, |acc, x| {
+                apply(
+                    &function,
+                    &[x, SymbolicExpression::atom_value(acc)],
+                    env,
+                    context,
+                )
+            }),
+        _ => Err(CheckErrors::ExpectedSequence(TypeSignature::type_of(&sequence)?).into()),
     }
 }
 
@@ -134,7 +132,7 @@ pub fn special_map(
         match sequence {
             Value::Sequence(ref mut sequence_data) => {
                 min_args_len = min_args_len.min(sequence_data.len());
-                for (apply_index, value) in sequence_data.atom_values().into_iter().enumerate() {
+                for (apply_index, value) in sequence_data.atom_values()?.into_iter().enumerate() {
                     if apply_index > min_args_len {
                         break;
                     }
@@ -146,7 +144,9 @@ pub fn special_map(
                 }
             }
             _ => {
-                return Err(CheckErrors::ExpectedSequence(TypeSignature::type_of(&sequence)).into())
+                return Err(
+                    CheckErrors::ExpectedSequence(TypeSignature::type_of(&sequence)?).into(),
+                )
             }
         }
     }
@@ -186,11 +186,11 @@ pub fn special_append(
                 type_signature,
             } = list;
             let (entry_type, size) = type_signature.destruct();
-            let element_type = TypeSignature::type_of(&element);
+            let element_type = TypeSignature::type_of(&element)?;
             runtime_cost(
                 ClarityCostFunction::Append,
                 env,
-                u64::from(cmp::max(entry_type.size(), element_type.size())),
+                u64::from(cmp::max(entry_type.size()?, element_type.size()?)),
             )?;
             if entry_type.is_no_type() {
                 assert_eq!(size, 0);
@@ -231,7 +231,7 @@ pub fn special_concat_v200(
     runtime_cost(
         ClarityCostFunction::Concat,
         env,
-        u64::from(wrapped_seq.size()).cost_overflow_add(u64::from(other_wrapped_seq.size()))?,
+        u64::from(wrapped_seq.size()?).cost_overflow_add(u64::from(other_wrapped_seq.size()?))?,
     )?;
 
     match (&mut wrapped_seq, other_wrapped_seq) {
@@ -288,7 +288,9 @@ pub fn special_as_max_len(
         let sequence_len = match sequence {
             Value::Sequence(ref sequence_data) => sequence_data.len() as u128,
             _ => {
-                return Err(CheckErrors::ExpectedSequence(TypeSignature::type_of(&sequence)).into())
+                return Err(
+                    CheckErrors::ExpectedSequence(TypeSignature::type_of(&sequence)?).into(),
+                )
             }
         };
         if sequence_len > *expected_len {
@@ -301,17 +303,18 @@ pub fn special_as_max_len(
         }
     } else {
         let actual_len = eval(&args[1], env, context)?;
-        Err(
-            CheckErrors::TypeError(TypeSignature::UIntType, TypeSignature::type_of(&actual_len))
-                .into(),
+        Err(CheckErrors::TypeError(
+            TypeSignature::UIntType,
+            TypeSignature::type_of(&actual_len)?,
         )
+        .into())
     }
 }
 
 pub fn native_len(sequence: Value) -> Result<Value> {
     match sequence {
         Value::Sequence(sequence_data) => Ok(Value::UInt(sequence_data.len() as u128)),
-        _ => Err(CheckErrors::ExpectedSequence(TypeSignature::type_of(&sequence)).into()),
+        _ => Err(CheckErrors::ExpectedSequence(TypeSignature::type_of(&sequence)?).into()),
     }
 }
 
@@ -322,7 +325,7 @@ pub fn native_index_of(sequence: Value, to_find: Value) -> Result<Value> {
             None => Ok(Value::none()),
         }
     } else {
-        Err(CheckErrors::ExpectedSequence(TypeSignature::type_of(&sequence)).into())
+        Err(CheckErrors::ExpectedSequence(TypeSignature::type_of(&sequence)?).into())
     }
 }
 
@@ -330,7 +333,7 @@ pub fn native_element_at(sequence: Value, index: Value) -> Result<Value> {
     let sequence_data = if let Value::Sequence(sequence_data) = sequence {
         sequence_data
     } else {
-        return Err(CheckErrors::ExpectedSequence(TypeSignature::type_of(&sequence)).into());
+        return Err(CheckErrors::ExpectedSequence(TypeSignature::type_of(&sequence)?).into());
     };
 
     let index = if let Value::UInt(index_u128) = index {
@@ -343,7 +346,7 @@ pub fn native_element_at(sequence: Value, index: Value) -> Result<Value> {
         return Err(CheckErrors::TypeValueError(TypeSignature::UIntType, index).into());
     };
 
-    if let Some(result) = sequence_data.element_at(index) {
+    if let Some(result) = sequence_data.element_at(index)? {
         Value::some(result)
     } else {
         Ok(Value::none())
@@ -382,7 +385,7 @@ pub fn special_slice(
                 runtime_cost(
                     ClarityCostFunction::Slice,
                     env,
-                    (right_position - left_position) * seq.element_size(),
+                    (right_position - left_position) * seq.element_size()?,
                 )?;
                 let seq_value =
                     seq.slice(env.epoch(), left_position as usize, right_position as usize)?;
@@ -409,13 +412,13 @@ pub fn special_replace_at(
     check_argument_count(3, args)?;
 
     let seq = eval(&args[0], env, context)?;
-    let seq_type = TypeSignature::type_of(&seq);
+    let seq_type = TypeSignature::type_of(&seq)?;
 
     // runtime is the cost to copy over one element into its place
-    runtime_cost(ClarityCostFunction::ReplaceAt, env, seq_type.size())?;
+    runtime_cost(ClarityCostFunction::ReplaceAt, env, seq_type.size()?)?;
 
     let expected_elem_type = if let TypeSignature::SequenceType(seq_subtype) = &seq_type {
-        seq_subtype.unit_type()
+        seq_subtype.unit_type()?
     } else {
         return Err(CheckErrors::ExpectedSequence(seq_type).into());
     };
diff --git a/clarity/src/vm/functions/tuples.rs b/clarity/src/vm/functions/tuples.rs
index 266ccffbf7..9a509ccfbe 100644
--- a/clarity/src/vm/functions/tuples.rs
+++ b/clarity/src/vm/functions/tuples.rs
@@ -16,7 +16,8 @@
 use crate::vm::costs::cost_functions::ClarityCostFunction;
 use crate::vm::costs::{cost_functions, runtime_cost};
 use crate::vm::errors::{
-    check_argument_count, check_arguments_at_least, CheckErrors, InterpreterResult as Result,
+    check_argument_count, check_arguments_at_least, CheckErrors, InterpreterError,
+    InterpreterResult as Result,
 };
 use crate::vm::representations::SymbolicExpressionType::List;
 use crate::vm::representations::{SymbolicExpression, SymbolicExpressionType};
@@ -59,10 +60,13 @@ pub fn tuple_get(
                 Some(data) => {
                     if let Value::Tuple(tuple_data) = *data {
                         runtime_cost(ClarityCostFunction::TupleGet, env, tuple_data.len())?;
-                        Ok(Value::some(tuple_data.get_owned(arg_name)?)
-                            .expect("Tuple contents should *always* fit in a some wrapper"))
+                        Ok(Value::some(tuple_data.get_owned(arg_name)?).map_err(|_| {
+                            InterpreterError::Expect(
+                                "Tuple contents should *always* fit in a some wrapper".into(),
+                            )
+                        })?)
                     } else {
-                        Err(CheckErrors::ExpectedTuple(TypeSignature::type_of(&data)).into())
+                        Err(CheckErrors::ExpectedTuple(TypeSignature::type_of(&data)?).into())
                     }
                 }
                 None => Ok(Value::none()), // just pass through none-types.
@@ -72,19 +76,19 @@ pub fn tuple_get(
             runtime_cost(ClarityCostFunction::TupleGet, env, tuple_data.len())?;
             tuple_data.get_owned(arg_name)
         }
-        _ => Err(CheckErrors::ExpectedTuple(TypeSignature::type_of(&value)).into()),
+        _ => Err(CheckErrors::ExpectedTuple(TypeSignature::type_of(&value)?).into()),
     }
 }
 
 pub fn tuple_merge(base: Value, update: Value) -> Result<Value> {
     let initial_values = match base {
         Value::Tuple(initial_values) => Ok(initial_values),
-        _ => Err(CheckErrors::ExpectedTuple(TypeSignature::type_of(&base))),
+        _ => Err(CheckErrors::ExpectedTuple(TypeSignature::type_of(&base)?)),
     }?;
 
     let new_values = match update {
         Value::Tuple(new_values) => Ok(new_values),
-        _ => Err(CheckErrors::ExpectedTuple(TypeSignature::type_of(&update))),
+        _ => Err(CheckErrors::ExpectedTuple(TypeSignature::type_of(&update)?)),
     }?;
 
     let combined = TupleData::shallow_merge(initial_values, new_values)?;
diff --git a/clarity/src/vm/mod.rs b/clarity/src/vm/mod.rs
index 9943f0038d..74204ef6c0 100644
--- a/clarity/src/vm/mod.rs
+++ b/clarity/src/vm/mod.rs
@@ -185,12 +185,12 @@ fn lookup_variable(name: &str, context: &LocalContext, env: &mut Environment) ->
                 context.depth(),
             )?;
             if let Some(value) = context.lookup_variable(name) {
-                runtime_cost(ClarityCostFunction::LookupVariableSize, env, value.size())?;
+                runtime_cost(ClarityCostFunction::LookupVariableSize, env, value.size()?)?;
                 Ok(value.clone())
             } else if let Some(value) = env.contract_context.lookup_variable(name).cloned() {
-                runtime_cost(ClarityCostFunction::LookupVariableSize, env, value.size())?;
+                runtime_cost(ClarityCostFunction::LookupVariableSize, env, value.size()?)?;
                 let (value, _) =
-                    Value::sanitize_value(env.epoch(), &TypeSignature::type_of(&value), value)
+                    Value::sanitize_value(env.epoch(), &TypeSignature::type_of(&value)?, value)
                         .ok_or_else(|| CheckErrors::CouldNotDetermineType)?;
                 Ok(value)
             } else if let Some(callable_data) = context.lookup_callable_contract(name) {
@@ -268,21 +268,21 @@ pub fn apply(
             let arg_value = match eval(arg_x, env, context) {
                 Ok(x) => x,
                 Err(e) => {
-                    env.drop_memory(used_memory);
+                    env.drop_memory(used_memory)?;
                     env.call_stack.decr_apply_depth();
                     return Err(e);
                 }
             };
-            let arg_use = arg_value.get_memory_use();
+            let arg_use = arg_value.get_memory_use()?;
             match env.add_memory(arg_use) {
                 Ok(_x) => {}
                 Err(e) => {
-                    env.drop_memory(used_memory);
+                    env.drop_memory(used_memory)?;
                     env.call_stack.decr_apply_depth();
                     return Err(Error::from(e));
                 }
             };
-            used_memory += arg_value.get_memory_use();
+            used_memory += arg_value.get_memory_use()?;
             evaluated_args.push(arg_value);
         }
         env.call_stack.decr_apply_depth();
@@ -305,10 +305,10 @@ pub fn apply(
                     .and_then(|_| function.apply(evaluated_args, env))
             }
             CallableType::UserFunction(function) => function.apply(&evaluated_args, env),
-            _ => panic!("Should be unreachable."),
+            _ => return Err(InterpreterError::Expect("Should be unreachable.".into()).into()),
         };
         add_stack_trace(&mut resp, env);
-        env.drop_memory(used_memory);
+        env.drop_memory(used_memory)?;
         env.call_stack.remove(&identifier, track_recursion)?;
         resp
     }
@@ -398,7 +398,7 @@ pub fn eval_all(
             match try_define {
                 DefineResult::Variable(name, value) => {
                     runtime_cost(ClarityCostFunction::BindName, global_context, 0)?;
-                    let value_memory_use = value.get_memory_use();
+                    let value_memory_use = value.get_memory_use()?;
                     global_context.add_memory(value_memory_use)?;
                     total_memory_use += value_memory_use;
 
@@ -410,31 +410,31 @@ pub fn eval_all(
                     contract_context.functions.insert(name, value);
                 },
                 DefineResult::PersistedVariable(name, value_type, value) => {
-                    runtime_cost(ClarityCostFunction::CreateVar, global_context, value_type.size())?;
+                    runtime_cost(ClarityCostFunction::CreateVar, global_context, value_type.size()?)?;
                     contract_context.persisted_names.insert(name.clone());
 
                     global_context.add_memory(value_type.type_size()
-                                              .expect("type size should be realizable") as u64)?;
+                                              .map_err(|_| InterpreterError::Expect("Type size should be realizable".into()))? as u64)?;
 
-                    global_context.add_memory(value.size() as u64)?;
+                    global_context.add_memory(value.size()? as u64)?;
 
-                    let data_type = global_context.database.create_variable(&contract_context.contract_identifier, &name, value_type);
+                    let data_type = global_context.database.create_variable(&contract_context.contract_identifier, &name, value_type)?;
                     global_context.database.set_variable(&contract_context.contract_identifier, &name, value, &data_type, &global_context.epoch_id)?;
 
                     contract_context.meta_data_var.insert(name, data_type);
                 },
                 DefineResult::Map(name, key_type, value_type) => {
                     runtime_cost(ClarityCostFunction::CreateMap, global_context,
-                                  u64::from(key_type.size()).cost_overflow_add(
-                                      u64::from(value_type.size()))?)?;
+                                  u64::from(key_type.size()?).cost_overflow_add(
+                                      u64::from(value_type.size()?))?)?;
                     contract_context.persisted_names.insert(name.clone());
 
                     global_context.add_memory(key_type.type_size()
-                                              .expect("type size should be realizable") as u64)?;
+                                              .map_err(|_| InterpreterError::Expect("Type size should be realizable".into()))? as u64)?;
                     global_context.add_memory(value_type.type_size()
-                                              .expect("type size should be realizable") as u64)?;
+                                              .map_err(|_| InterpreterError::Expect("Type size should be realizable".into()))? as u64)?;
 
-                    let data_type = global_context.database.create_map(&contract_context.contract_identifier, &name, key_type, value_type);
+                    let data_type = global_context.database.create_map(&contract_context.contract_identifier, &name, key_type, value_type)?;
 
                     contract_context.meta_data_map.insert(name, data_type);
                 },
@@ -443,20 +443,20 @@ pub fn eval_all(
                     contract_context.persisted_names.insert(name.clone());
 
                     global_context.add_memory(TypeSignature::UIntType.type_size()
-                                              .expect("type size should be realizable") as u64)?;
+                                              .map_err(|_| InterpreterError::Expect("Type size should be realizable".into()))? as u64)?;
 
-                    let data_type = global_context.database.create_fungible_token(&contract_context.contract_identifier, &name, &total_supply);
+                    let data_type = global_context.database.create_fungible_token(&contract_context.contract_identifier, &name, &total_supply)?;
 
                     contract_context.meta_ft.insert(name, data_type);
                 },
                 DefineResult::NonFungibleAsset(name, asset_type) => {
-                    runtime_cost(ClarityCostFunction::CreateNft, global_context, asset_type.size())?;
+                    runtime_cost(ClarityCostFunction::CreateNft, global_context, asset_type.size()?)?;
                     contract_context.persisted_names.insert(name.clone());
 
                     global_context.add_memory(asset_type.type_size()
-                                              .expect("type size should be realizable") as u64)?;
+                                              .map_err(|_| InterpreterError::Expect("Type size should be realizable".into()))? as u64)?;
 
-                    let data_type = global_context.database.create_non_fungible_token(&contract_context.contract_identifier, &name, &asset_type);
+                    let data_type = global_context.database.create_non_fungible_token(&contract_context.contract_identifier, &name, &asset_type)?;
 
                     contract_context.meta_nft.insert(name, data_type);
                 },
diff --git a/clarity/src/vm/representations.rs b/clarity/src/vm/representations.rs
index bef9fe2e00..61e4cb37e2 100644
--- a/clarity/src/vm/representations.rs
+++ b/clarity/src/vm/representations.rs
@@ -51,10 +51,16 @@ lazy_static! {
     pub static ref CLARITY_NAME_REGEX_STRING: String =
         "^[a-zA-Z]([a-zA-Z0-9]|[-_!?+<>=/*])*$|^[-+=/*]$|^[<>]=?$".into();
     pub static ref CLARITY_NAME_REGEX: Regex =
-        Regex::new(CLARITY_NAME_REGEX_STRING.as_str()).unwrap();
+    {
+        #[allow(clippy::unwrap_used)]
+        Regex::new(CLARITY_NAME_REGEX_STRING.as_str()).unwrap()
+    };
     pub static ref CONTRACT_NAME_REGEX: Regex =
+    {
+        #[allow(clippy::unwrap_used)]
         Regex::new(format!("^{}$|^__transient$", CONTRACT_NAME_REGEX_STRING.as_str()).as_str())
-            .unwrap();
+            .unwrap()
+    };
 }
 
 guarded_string!(
@@ -395,7 +401,7 @@ pub enum TraitDefinition {
     Imported(TraitIdentifier),
 }
 
-pub fn depth_traverse<F, T, E>(expr: &SymbolicExpression, mut visit: F) -> Result<T, E>
+pub fn depth_traverse<F, T, E>(expr: &SymbolicExpression, mut visit: F) -> Result<Option<T>, E>
 where
     F: FnMut(&SymbolicExpression) -> Result<T, E>,
 {
@@ -411,7 +417,7 @@ where
         }
     }
 
-    Ok(last.unwrap())
+    Ok(last)
 }
 
 #[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq)]
diff --git a/clarity/src/vm/tests/contracts.rs b/clarity/src/vm/tests/contracts.rs
index b313285064..673a6905b3 100644
--- a/clarity/src/vm/tests/contracts.rs
+++ b/clarity/src/vm/tests/contracts.rs
@@ -203,7 +203,7 @@ fn test_contract_caller(epoch: StacksEpochId, mut env_factory: MemoryEnvironment
             QualifiedContractIdentifier::local("contract-b").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal()),
+            Some(p1.clone().expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -313,7 +313,9 @@ fn test_tx_sponsor(epoch: StacksEpochId, mut env_factory: MemoryEnvironmentGener
          (define-read-only (as-contract-cc-get-sponsor)
            (as-contract (contract-call? .contract-a get-sponsor)))";
 
-    let p1 = execute("'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR").expect_principal();
+    let p1 = execute("'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR")
+        .expect_principal()
+        .unwrap();
     let p2 = execute("'SM2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQVX8X0G");
     let mut placeholder_context = ContractContext::new(
         QualifiedContractIdentifier::transient(),
@@ -413,7 +415,7 @@ fn test_fully_qualified_contract_call(
             QualifiedContractIdentifier::local("contract-b").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal()),
+            Some(p1.clone().expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -545,7 +547,7 @@ fn test_simple_naming_system(epoch: StacksEpochId, mut env_factory: MemoryEnviro
 
     {
         let mut env = owned_env.get_exec_environment(
-            Some(p2.clone().expect_principal()),
+            Some(p2.clone().expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -564,7 +566,7 @@ fn test_simple_naming_system(epoch: StacksEpochId, mut env_factory: MemoryEnviro
 
     {
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal()),
+            Some(p1.clone().expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -592,7 +594,7 @@ fn test_simple_naming_system(epoch: StacksEpochId, mut env_factory: MemoryEnviro
     {
         // shouldn't be able to register a name you didn't preorder!
         let mut env = owned_env.get_exec_environment(
-            Some(p2.clone().expect_principal()),
+            Some(p2.clone().expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -611,7 +613,7 @@ fn test_simple_naming_system(epoch: StacksEpochId, mut env_factory: MemoryEnviro
     {
         // should work!
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal()),
+            Some(p1.clone().expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -629,7 +631,7 @@ fn test_simple_naming_system(epoch: StacksEpochId, mut env_factory: MemoryEnviro
     {
         // try to underpay!
         let mut env = owned_env.get_exec_environment(
-            Some(p2.clone().expect_principal()),
+            Some(p2.clone().expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -702,7 +704,7 @@ fn test_simple_contract_call(epoch: StacksEpochId, mut env_factory: MemoryEnviro
     );
 
     let mut env = owned_env.get_exec_environment(
-        Some(get_principal().expect_principal()),
+        Some(get_principal().expect_principal().unwrap()),
         None,
         &mut placeholder_context,
     );
diff --git a/clarity/src/vm/tests/principals.rs b/clarity/src/vm/tests/principals.rs
index 684347406c..c22d04a5c5 100644
--- a/clarity/src/vm/tests/principals.rs
+++ b/clarity/src/vm/tests/principals.rs
@@ -1007,7 +1007,7 @@ fn test_principal_construct_check_errors() {
     let input = r#"(principal-construct? 0x16 0x0102030405060708091011121314151617181920 "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")"#;
     assert_eq!(
         Err(CheckErrors::TypeValueError(
-            TypeSignature::contract_name_string_ascii_type(),
+            TypeSignature::contract_name_string_ascii_type().unwrap(),
             Value::Sequence(SequenceData::String(CharType::ASCII(ASCIIData {
                 data: "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
                     .as_bytes()
diff --git a/clarity/src/vm/tests/sequences.rs b/clarity/src/vm/tests/sequences.rs
index 30af202163..1b9dd493e3 100644
--- a/clarity/src/vm/tests/sequences.rs
+++ b/clarity/src/vm/tests/sequences.rs
@@ -107,15 +107,15 @@ fn test_index_of() {
     let bad_expected = [
         CheckErrors::ExpectedSequence(TypeSignature::IntType),
         CheckErrors::TypeValueError(
-            TypeSignature::min_buffer(),
+            TypeSignature::min_buffer().unwrap(),
             execute("\"a\"").unwrap().unwrap(),
         ),
         CheckErrors::TypeValueError(
-            TypeSignature::min_string_utf8(),
+            TypeSignature::min_string_utf8().unwrap(),
             execute("\"a\"").unwrap().unwrap(),
         ),
         CheckErrors::TypeValueError(
-            TypeSignature::min_string_ascii(),
+            TypeSignature::min_string_ascii().unwrap(),
             execute("u\"a\"").unwrap().unwrap(),
         ),
     ];
@@ -1094,10 +1094,10 @@ fn test_list_tuple_admission() {
                (tuple (value 0x3031))
                (tuple (value 0x3032)))";
 
-    let result_type = TypeSignature::type_of(&execute(test).unwrap().unwrap());
-    let expected_type = TypeSignature::type_of(&execute(expected_type).unwrap().unwrap());
+    let result_type = TypeSignature::type_of(&execute(test).unwrap().unwrap()).unwrap();
+    let expected_type = TypeSignature::type_of(&execute(expected_type).unwrap().unwrap()).unwrap();
     let testing_value = &execute(not_expected_type).unwrap().unwrap();
-    let not_expected_type = TypeSignature::type_of(testing_value);
+    let not_expected_type = TypeSignature::type_of(testing_value).unwrap();
 
     assert_eq!(expected_type, result_type);
     assert!(not_expected_type != result_type);
diff --git a/clarity/src/vm/tests/simple_apply_eval.rs b/clarity/src/vm/tests/simple_apply_eval.rs
index df2607b8d9..6f35c16445 100644
--- a/clarity/src/vm/tests/simple_apply_eval.rs
+++ b/clarity/src/vm/tests/simple_apply_eval.rs
@@ -274,7 +274,7 @@ fn test_to_consensus_buff_too_big() {
         .expect("Should execute")
         .expect("Should have return value");
 
-    assert!(result.expect_optional().is_none());
+    assert!(result.expect_optional().unwrap().is_none());
 
     // this program prints the length of the
     // constructed 1048567 buffer and then executes
@@ -295,7 +295,7 @@ fn test_to_consensus_buff_too_big() {
         .expect("Should execute")
         .expect("Should have return value");
 
-    assert!(result.expect_optional().is_none());
+    assert!(result.expect_optional().unwrap().is_none());
 }
 
 #[test]
@@ -350,7 +350,8 @@ fn test_from_consensus_buff_missed_expectations() {
         let result_val = vm_execute_v2(&program)
             .expect("from-consensus-buff? should succeed")
             .expect("from-consensus-buff? should return")
-            .expect_optional();
+            .expect_optional()
+            .unwrap();
         assert!(
             result_val.is_none(),
             "from-consensus-buff? should return none"
@@ -386,6 +387,7 @@ fn test_to_from_consensus_buff_vectors() {
             .expect("from-consensus-buff? should succeed")
             .expect("from-consensus-buff? should return")
             .expect_optional()
+            .unwrap()
             .expect("from-consensus-buff? should return (some value)");
         let expected_val = execute(&value_repr);
         assert_eq!(result_val, expected_val);
@@ -398,6 +400,7 @@ fn test_to_from_consensus_buff_vectors() {
             .expect("to-consensus-buff? should succeed")
             .expect("to-consensus-buff? should return")
             .expect_optional()
+            .unwrap()
             .expect("to-consensus-buff? should return (some buff)");
         let expected_buff = execute(&buff_repr);
         assert_eq!(result_buffer, expected_buff);
@@ -1008,9 +1011,9 @@ fn test_sequence_comparisons_mismatched_types() {
             vec![
                 TypeSignature::IntType,
                 TypeSignature::UIntType,
-                TypeSignature::max_string_ascii(),
-                TypeSignature::max_string_utf8(),
-                TypeSignature::max_buffer(),
+                TypeSignature::max_string_ascii().unwrap(),
+                TypeSignature::max_string_utf8().unwrap(),
+                TypeSignature::max_buffer().unwrap(),
             ],
             Value::Int(0),
         )
@@ -1019,9 +1022,9 @@ fn test_sequence_comparisons_mismatched_types() {
             vec![
                 TypeSignature::IntType,
                 TypeSignature::UIntType,
-                TypeSignature::max_string_ascii(),
-                TypeSignature::max_string_utf8(),
-                TypeSignature::max_buffer(),
+                TypeSignature::max_string_ascii().unwrap(),
+                TypeSignature::max_string_utf8().unwrap(),
+                TypeSignature::max_buffer().unwrap(),
             ],
             Value::Int(0),
         )
@@ -1042,9 +1045,9 @@ fn test_sequence_comparisons_mismatched_types() {
             vec![
                 TypeSignature::IntType,
                 TypeSignature::UIntType,
-                TypeSignature::max_string_ascii(),
-                TypeSignature::max_string_utf8(),
-                TypeSignature::max_buffer(),
+                TypeSignature::max_string_ascii().unwrap(),
+                TypeSignature::max_string_utf8().unwrap(),
+                TypeSignature::max_buffer().unwrap(),
             ],
             Value::Sequence(SequenceData::String(CharType::ASCII(ASCIIData {
                 data: "baa".as_bytes().to_vec(),
@@ -1055,9 +1058,9 @@ fn test_sequence_comparisons_mismatched_types() {
             vec![
                 TypeSignature::IntType,
                 TypeSignature::UIntType,
-                TypeSignature::max_string_ascii(),
-                TypeSignature::max_string_utf8(),
-                TypeSignature::max_buffer(),
+                TypeSignature::max_string_ascii().unwrap(),
+                TypeSignature::max_string_utf8().unwrap(),
+                TypeSignature::max_buffer().unwrap(),
             ],
             Value::Sequence(SequenceData::String(CharType::ASCII(ASCIIData {
                 data: "baa".as_bytes().to_vec(),
@@ -1462,7 +1465,7 @@ fn test_hash_errors() {
             vec![
                 TypeSignature::IntType,
                 TypeSignature::UIntType,
-                TypeSignature::max_buffer(),
+                TypeSignature::max_buffer().unwrap(),
             ],
             Value::Bool(true),
         )
@@ -1471,7 +1474,7 @@ fn test_hash_errors() {
             vec![
                 TypeSignature::IntType,
                 TypeSignature::UIntType,
-                TypeSignature::max_buffer(),
+                TypeSignature::max_buffer().unwrap(),
             ],
             Value::Bool(true),
         )
@@ -1480,7 +1483,7 @@ fn test_hash_errors() {
             vec![
                 TypeSignature::IntType,
                 TypeSignature::UIntType,
-                TypeSignature::max_buffer(),
+                TypeSignature::max_buffer().unwrap(),
             ],
             Value::Bool(true),
         )
@@ -1489,7 +1492,7 @@ fn test_hash_errors() {
             vec![
                 TypeSignature::IntType,
                 TypeSignature::UIntType,
-                TypeSignature::max_buffer(),
+                TypeSignature::max_buffer().unwrap(),
             ],
             Value::Bool(true),
         )
@@ -1499,7 +1502,7 @@ fn test_hash_errors() {
             vec![
                 TypeSignature::IntType,
                 TypeSignature::UIntType,
-                TypeSignature::max_buffer(),
+                TypeSignature::max_buffer().unwrap(),
             ],
             Value::Bool(true),
         )
diff --git a/clarity/src/vm/tests/traits.rs b/clarity/src/vm/tests/traits.rs
index 6d231f55dd..893cefa068 100644
--- a/clarity/src/vm/tests/traits.rs
+++ b/clarity/src/vm/tests/traits.rs
@@ -67,7 +67,7 @@ fn test_dynamic_dispatch_by_defining_trait(
             QualifiedContractIdentifier::local("target-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal()),
+            Some(p1.clone().expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -125,7 +125,7 @@ fn test_dynamic_dispatch_pass_trait_nested_in_let(
             QualifiedContractIdentifier::local("target-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal()),
+            Some(p1.clone().expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -182,7 +182,7 @@ fn test_dynamic_dispatch_pass_trait(
             QualifiedContractIdentifier::local("target-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal()),
+            Some(p1.clone().expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -238,7 +238,7 @@ fn test_dynamic_dispatch_intra_contract_call(
             QualifiedContractIdentifier::local("dispatching-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal()),
+            Some(p1.clone().expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -303,7 +303,7 @@ fn test_dynamic_dispatch_by_implementing_imported_trait(
             QualifiedContractIdentifier::local("target-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal()),
+            Some(p1.clone().expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -368,7 +368,7 @@ fn test_dynamic_dispatch_by_implementing_imported_trait_mul_funcs(
             QualifiedContractIdentifier::local("target-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal()),
+            Some(p1.clone().expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -430,7 +430,7 @@ fn test_dynamic_dispatch_by_importing_trait(
             QualifiedContractIdentifier::local("target-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal()),
+            Some(p1.clone().expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -514,7 +514,7 @@ fn test_dynamic_dispatch_including_nested_trait(
             QualifiedContractIdentifier::local("target-nested-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal()),
+            Some(p1.clone().expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -569,7 +569,7 @@ fn test_dynamic_dispatch_mismatched_args(
             QualifiedContractIdentifier::local("target-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal()),
+            Some(p1.clone().expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -626,7 +626,7 @@ fn test_dynamic_dispatch_mismatched_returned(
             QualifiedContractIdentifier::local("target-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal()),
+            Some(p1.clone().expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -686,7 +686,7 @@ fn test_reentrant_dynamic_dispatch(
             QualifiedContractIdentifier::local("target-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal()),
+            Some(p1.clone().expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -743,7 +743,7 @@ fn test_readwrite_dynamic_dispatch(
             QualifiedContractIdentifier::local("target-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal()),
+            Some(p1.clone().expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -800,7 +800,7 @@ fn test_readwrite_violation_dynamic_dispatch(
             QualifiedContractIdentifier::local("target-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal()),
+            Some(p1.clone().expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -873,7 +873,7 @@ fn test_bad_call_with_trait(
 
     {
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal()),
+            Some(p1.clone().expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -941,7 +941,7 @@ fn test_good_call_with_trait(
 
     {
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal()),
+            Some(p1.clone().expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -1013,7 +1013,7 @@ fn test_good_call_2_with_trait(
             QualifiedContractIdentifier::local("implem").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal()),
+            Some(p1.clone().expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -1078,7 +1078,7 @@ fn test_dynamic_dispatch_pass_literal_principal_as_trait_in_user_defined_functio
             QualifiedContractIdentifier::local("target-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal()),
+            Some(p1.clone().expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -1142,7 +1142,7 @@ fn test_contract_of_value(
         ));
         let result_contract = target_contract.clone();
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal()),
+            Some(p1.clone().expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -1209,7 +1209,7 @@ fn test_contract_of_no_impl(
         ));
         let result_contract = target_contract.clone();
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal()),
+            Some(p1.clone().expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -1267,7 +1267,7 @@ fn test_return_trait_with_contract_of_wrapped_in_begin(
             QualifiedContractIdentifier::local("target-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal()),
+            Some(p1.clone().expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -1324,7 +1324,7 @@ fn test_return_trait_with_contract_of_wrapped_in_let(
             QualifiedContractIdentifier::local("target-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal()),
+            Some(p1.clone().expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -1379,7 +1379,7 @@ fn test_return_trait_with_contract_of(
             QualifiedContractIdentifier::local("target-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal()),
+            Some(p1.clone().expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -1444,7 +1444,7 @@ fn test_pass_trait_to_subtrait(epoch: StacksEpochId, mut env_factory: MemoryEnvi
             QualifiedContractIdentifier::local("target-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal()),
+            Some(p1.clone().expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -1507,7 +1507,7 @@ fn test_embedded_trait(epoch: StacksEpochId, mut env_factory: MemoryEnvironmentG
         ));
         let opt_target = Value::some(target_contract).unwrap();
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal()),
+            Some(p1.clone().expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -1579,7 +1579,7 @@ fn test_pass_embedded_trait_to_subtrait_optional(
             QualifiedContractIdentifier::local("target-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal()),
+            Some(p1.clone().expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -1651,7 +1651,7 @@ fn test_pass_embedded_trait_to_subtrait_ok(
             QualifiedContractIdentifier::local("target-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal()),
+            Some(p1.clone().expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -1723,7 +1723,7 @@ fn test_pass_embedded_trait_to_subtrait_err(
             QualifiedContractIdentifier::local("target-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal()),
+            Some(p1.clone().expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -1795,7 +1795,7 @@ fn test_pass_embedded_trait_to_subtrait_list(
             QualifiedContractIdentifier::local("target-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal()),
+            Some(p1.clone().expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -1870,7 +1870,7 @@ fn test_pass_embedded_trait_to_subtrait_list_option(
             QualifiedContractIdentifier::local("target-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal()),
+            Some(p1.clone().expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -1945,7 +1945,7 @@ fn test_pass_embedded_trait_to_subtrait_option_list(
             QualifiedContractIdentifier::local("target-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal()),
+            Some(p1.clone().expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -2006,7 +2006,7 @@ fn test_let_trait(epoch: StacksEpochId, mut env_factory: MemoryEnvironmentGenera
             QualifiedContractIdentifier::local("target-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal()),
+            Some(p1.clone().expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -2071,7 +2071,7 @@ fn test_let3_trait(epoch: StacksEpochId, mut env_factory: MemoryEnvironmentGener
             QualifiedContractIdentifier::local("target-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal()),
+            Some(p1.clone().expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -2132,7 +2132,7 @@ fn test_pass_principal_literal_to_trait(
             QualifiedContractIdentifier::local("target-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal()),
+            Some(p1.clone().expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
diff --git a/clarity/src/vm/types/mod.rs b/clarity/src/vm/types/mod.rs
index e51bbe9f45..d46bf65ca8 100644
--- a/clarity/src/vm/types/mod.rs
+++ b/clarity/src/vm/types/mod.rs
@@ -101,6 +101,7 @@ impl QualifiedContractIdentifier {
         Ok(Self::new(StandardPrincipalData::transient(), name))
     }
 
+    #[allow(clippy::unwrap_used)]
     pub fn transient() -> QualifiedContractIdentifier {
         let name = String::from("__transient").try_into().unwrap();
         Self {
@@ -254,7 +255,7 @@ pub enum SequenceData {
 }
 
 impl SequenceData {
-    pub fn atom_values(&mut self) -> Vec<SymbolicExpression> {
+    pub fn atom_values(&mut self) -> Result<Vec<SymbolicExpression>> {
         match self {
             SequenceData::Buffer(ref mut data) => data.atom_values(),
             SequenceData::List(ref mut data) => data.atom_values(),
@@ -263,13 +264,14 @@ impl SequenceData {
         }
     }
 
-    pub fn element_size(&self) -> u32 {
-        match self {
-            SequenceData::Buffer(..) => TypeSignature::min_buffer().size(),
+    pub fn element_size(&self) -> Result<u32> {
+        let out = match self {
+            SequenceData::Buffer(..) => TypeSignature::min_buffer()?.size(),
             SequenceData::List(ref data) => data.type_signature.get_list_item_type().size(),
-            SequenceData::String(CharType::ASCII(..)) => TypeSignature::min_string_ascii().size(),
-            SequenceData::String(CharType::UTF8(..)) => TypeSignature::min_string_utf8().size(),
-        }
+            SequenceData::String(CharType::ASCII(..)) => TypeSignature::min_string_ascii()?.size(),
+            SequenceData::String(CharType::UTF8(..)) => TypeSignature::min_string_utf8()?.size(),
+        }?;
+        Ok(out)
     }
 
     pub fn len(&self) -> usize {
@@ -281,16 +283,19 @@ impl SequenceData {
         }
     }
 
-    pub fn element_at(self, index: usize) -> Option<Value> {
+    pub fn element_at(self, index: usize) -> Result<Option<Value>> {
         if self.len() <= index {
-            return None;
+            return Ok(None);
         }
         let result = match self {
             SequenceData::Buffer(data) => Value::buff_from_byte(data.data[index]),
             SequenceData::List(mut data) => data.data.remove(index),
             SequenceData::String(CharType::ASCII(data)) => {
-                Value::string_ascii_from_bytes(vec![data.data[index]])
-                    .expect("BUG: failed to initialize single-byte ASCII buffer")
+                Value::string_ascii_from_bytes(vec![data.data[index]]).map_err(|_| {
+                    InterpreterError::Expect(
+                        "BUG: failed to initialize single-byte ASCII buffer".into(),
+                    )
+                })?
             }
             SequenceData::String(CharType::UTF8(mut data)) => {
                 Value::Sequence(SequenceData::String(CharType::UTF8(UTF8Data {
@@ -299,7 +304,7 @@ impl SequenceData {
             }
         };
 
-        Some(result)
+        Ok(Some(result))
     }
 
     pub fn replace_at(self, epoch: &StacksEpochId, index: usize, element: Value) -> Result<Value> {
@@ -369,7 +374,7 @@ impl SequenceData {
                         Ok(None)
                     }
                 } else {
-                    Err(CheckErrors::TypeValueError(TypeSignature::min_buffer(), to_find).into())
+                    Err(CheckErrors::TypeValueError(TypeSignature::min_buffer()?, to_find).into())
                 }
             }
             SequenceData::List(ref data) => {
@@ -395,7 +400,7 @@ impl SequenceData {
                     }
                 } else {
                     Err(
-                        CheckErrors::TypeValueError(TypeSignature::min_string_ascii(), to_find)
+                        CheckErrors::TypeValueError(TypeSignature::min_string_ascii()?, to_find)
                             .into(),
                     )
                 }
@@ -415,7 +420,7 @@ impl SequenceData {
                     }
                 } else {
                     Err(
-                        CheckErrors::TypeValueError(TypeSignature::min_string_utf8(), to_find)
+                        CheckErrors::TypeValueError(TypeSignature::min_string_utf8()?, to_find)
                             .into(),
                     )
                 }
@@ -435,7 +440,7 @@ impl SequenceData {
                 let mut i = 0;
                 while i != $data.data.len() {
                     let atom_value =
-                        SymbolicExpression::atom_value($seq_type::to_value(&$data.data[i]));
+                        SymbolicExpression::atom_value($seq_type::to_value(&$data.data[i])?);
                     match filter(atom_value) {
                         Ok(res) if res == false => {
                             $data.data.remove(i);
@@ -605,18 +610,18 @@ impl fmt::Display for UTF8Data {
 }
 
 pub trait SequencedValue<T> {
-    fn type_signature(&self) -> TypeSignature;
+    fn type_signature(&self) -> std::result::Result<TypeSignature, CheckErrors>;
 
     fn items(&self) -> &Vec<T>;
 
     fn drained_items(&mut self) -> Vec<T>;
 
-    fn to_value(v: &T) -> Value;
+    fn to_value(v: &T) -> Result<Value>;
 
-    fn atom_values(&mut self) -> Vec<SymbolicExpression> {
+    fn atom_values(&mut self) -> Result<Vec<SymbolicExpression>> {
         self.drained_items()
             .iter()
-            .map(|item| SymbolicExpression::atom_value(Self::to_value(&item)))
+            .map(|item| Ok(SymbolicExpression::atom_value(Self::to_value(&item)?)))
             .collect()
     }
 }
@@ -630,12 +635,14 @@ impl SequencedValue<Value> for ListData {
         self.data.drain(..).collect()
     }
 
-    fn type_signature(&self) -> TypeSignature {
-        TypeSignature::SequenceType(SequenceSubtype::ListType(self.type_signature.clone()))
+    fn type_signature(&self) -> std::result::Result<TypeSignature, CheckErrors> {
+        Ok(TypeSignature::SequenceType(SequenceSubtype::ListType(
+            self.type_signature.clone(),
+        )))
     }
 
-    fn to_value(v: &Value) -> Value {
-        v.clone()
+    fn to_value(v: &Value) -> Result<Value> {
+        Ok(v.clone())
     }
 }
 
@@ -648,14 +655,17 @@ impl SequencedValue<u8> for BuffData {
         self.data.drain(..).collect()
     }
 
-    fn type_signature(&self) -> TypeSignature {
-        let buff_length = BufferLength::try_from(self.data.len())
-            .expect("ERROR: Too large of a buffer successfully constructed.");
-        TypeSignature::SequenceType(SequenceSubtype::BufferType(buff_length))
+    fn type_signature(&self) -> std::result::Result<TypeSignature, CheckErrors> {
+        let buff_length = BufferLength::try_from(self.data.len()).map_err(|_| {
+            CheckErrors::Expects("ERROR: Too large of a buffer successfully constructed.".into())
+        })?;
+        Ok(TypeSignature::SequenceType(SequenceSubtype::BufferType(
+            buff_length,
+        )))
     }
 
-    fn to_value(v: &u8) -> Value {
-        Value::buff_from_byte(*v)
+    fn to_value(v: &u8) -> Result<Value> {
+        Ok(Value::buff_from_byte(*v))
     }
 }
 
@@ -668,17 +678,20 @@ impl SequencedValue<u8> for ASCIIData {
         self.data.drain(..).collect()
     }
 
-    fn type_signature(&self) -> TypeSignature {
-        let buff_length = BufferLength::try_from(self.data.len())
-            .expect("ERROR: Too large of a buffer successfully constructed.");
-        TypeSignature::SequenceType(SequenceSubtype::StringType(StringSubtype::ASCII(
-            buff_length,
+    fn type_signature(&self) -> std::result::Result<TypeSignature, CheckErrors> {
+        let buff_length = BufferLength::try_from(self.data.len()).map_err(|_| {
+            CheckErrors::Expects("ERROR: Too large of a buffer successfully constructed.".into())
+        })?;
+        Ok(TypeSignature::SequenceType(SequenceSubtype::StringType(
+            StringSubtype::ASCII(buff_length),
         )))
     }
 
-    fn to_value(v: &u8) -> Value {
-        Value::string_ascii_from_bytes(vec![*v])
-            .expect("ERROR: Invalid ASCII string successfully constructed")
+    fn to_value(v: &u8) -> Result<Value> {
+        Value::string_ascii_from_bytes(vec![*v]).map_err(|_| {
+            InterpreterError::Expect("ERROR: Invalid ASCII string successfully constructed".into())
+                .into()
+        })
     }
 }
 
@@ -691,15 +704,20 @@ impl SequencedValue<Vec<u8>> for UTF8Data {
         self.data.drain(..).collect()
     }
 
-    fn type_signature(&self) -> TypeSignature {
-        let str_len = StringUTF8Length::try_from(self.data.len())
-            .expect("ERROR: Too large of a buffer successfully constructed.");
-        TypeSignature::SequenceType(SequenceSubtype::StringType(StringSubtype::UTF8(str_len)))
+    fn type_signature(&self) -> std::result::Result<TypeSignature, CheckErrors> {
+        let str_len = StringUTF8Length::try_from(self.data.len()).map_err(|_| {
+            CheckErrors::Expects("ERROR: Too large of a buffer successfully constructed.".into())
+        })?;
+        Ok(TypeSignature::SequenceType(SequenceSubtype::StringType(
+            StringSubtype::UTF8(str_len),
+        )))
     }
 
-    fn to_value(v: &Vec<u8>) -> Value {
-        Value::string_utf8_from_bytes(v.clone())
-            .expect("ERROR: Invalid UTF8 string successfully constructed")
+    fn to_value(v: &Vec<u8>) -> Result<Value> {
+        Value::string_utf8_from_bytes(v.clone()).map_err(|_| {
+            InterpreterError::Expect("ERROR: Invalid UTF8 string successfully constructed".into())
+                .into()
+        })
     }
 }
 
@@ -723,28 +741,32 @@ define_named_enum!(BurnBlockInfoProperty {
 });
 
 impl OptionalData {
-    pub fn type_signature(&self) -> TypeSignature {
+    pub fn type_signature(&self) -> std::result::Result<TypeSignature, CheckErrors> {
         let type_result = match self.data {
-            Some(ref v) => TypeSignature::new_option(TypeSignature::type_of(&v)),
+            Some(ref v) => TypeSignature::new_option(TypeSignature::type_of(&v)?),
             None => TypeSignature::new_option(TypeSignature::NoType),
         };
-        type_result.expect("Should not have constructed too large of a type.")
+        type_result.map_err(|_| {
+            CheckErrors::Expects("Should not have constructed too large of a type.".into()).into()
+        })
     }
 }
 
 impl ResponseData {
-    pub fn type_signature(&self) -> TypeSignature {
+    pub fn type_signature(&self) -> std::result::Result<TypeSignature, CheckErrors> {
         let type_result = match self.committed {
             true => TypeSignature::new_response(
-                TypeSignature::type_of(&self.data),
+                TypeSignature::type_of(&self.data)?,
                 TypeSignature::NoType,
             ),
             false => TypeSignature::new_response(
                 TypeSignature::NoType,
-                TypeSignature::type_of(&self.data),
+                TypeSignature::type_of(&self.data)?,
             ),
         };
-        type_result.expect("Should not have constructed too large of a type.")
+        type_result.map_err(|_| {
+            CheckErrors::Expects("Should not have constructed too large of a type.".into()).into()
+        })
     }
 }
 
@@ -773,9 +795,9 @@ impl BlockInfoProperty {
 }
 
 impl BurnBlockInfoProperty {
-    pub fn type_result(&self) -> TypeSignature {
+    pub fn type_result(&self) -> std::result::Result<TypeSignature, CheckErrors> {
         use self::BurnBlockInfoProperty::*;
-        match self {
+        let result = match self {
             HeaderHash => BUFF_32.clone(),
             PoxAddrs => TupleTypeSignature::try_from(vec![
                 (
@@ -786,17 +808,22 @@ impl BurnBlockInfoProperty {
                                 ("version".into(), BUFF_1.clone()),
                                 ("hashbytes".into(), BUFF_32.clone()),
                             ])
-                            .expect("FATAL: bad type signature for pox addr"),
+                            .map_err(|_| {
+                                CheckErrors::Expects(
+                                    "FATAL: bad type signature for pox addr".into(),
+                                )
+                            })?,
                         ),
                         2,
                     )
-                    .expect("FATAL: bad list type signature"),
+                    .map_err(|_| CheckErrors::Expects("FATAL: bad list type signature".into()))?,
                 ),
                 ("payout".into(), TypeSignature::UIntType),
             ])
-            .expect("FATAL: bad type signature for pox addr")
+            .map_err(|_| CheckErrors::Expects("FATAL: bad type signature for pox addr".into()))?
             .into(),
-        }
+        };
+        Ok(result)
     }
 }
 
@@ -816,9 +843,9 @@ pub const NONE: Value = Value::Optional(OptionalData { data: None });
 
 impl Value {
     pub fn some(data: Value) -> Result<Value> {
-        if data.size() + WRAPPER_VALUE_SIZE > MAX_VALUE_SIZE {
+        if data.size()? + WRAPPER_VALUE_SIZE > MAX_VALUE_SIZE {
             Err(CheckErrors::ValueTooLarge.into())
-        } else if data.depth() + 1 > MAX_TYPE_DEPTH {
+        } else if data.depth()? + 1 > MAX_TYPE_DEPTH {
             Err(CheckErrors::TypeSignatureTooDeep.into())
         } else {
             Ok(Value::Optional(OptionalData {
@@ -853,9 +880,9 @@ impl Value {
     }
 
     pub fn okay(data: Value) -> Result<Value> {
-        if data.size() + WRAPPER_VALUE_SIZE > MAX_VALUE_SIZE {
+        if data.size()? + WRAPPER_VALUE_SIZE > MAX_VALUE_SIZE {
             Err(CheckErrors::ValueTooLarge.into())
-        } else if data.depth() + 1 > MAX_TYPE_DEPTH {
+        } else if data.depth()? + 1 > MAX_TYPE_DEPTH {
             Err(CheckErrors::TypeSignatureTooDeep.into())
         } else {
             Ok(Value::Response(ResponseData {
@@ -866,9 +893,9 @@ impl Value {
     }
 
     pub fn error(data: Value) -> Result<Value> {
-        if data.size() + WRAPPER_VALUE_SIZE > MAX_VALUE_SIZE {
+        if data.size()? + WRAPPER_VALUE_SIZE > MAX_VALUE_SIZE {
             Err(CheckErrors::ValueTooLarge.into())
-        } else if data.depth() + 1 > MAX_TYPE_DEPTH {
+        } else if data.depth()? + 1 > MAX_TYPE_DEPTH {
             Err(CheckErrors::TypeSignatureTooDeep.into())
         } else {
             Ok(Value::Response(ResponseData {
@@ -878,12 +905,12 @@ impl Value {
         }
     }
 
-    pub fn size(&self) -> u32 {
-        TypeSignature::type_of(self).size()
+    pub fn size(&self) -> Result<u32> {
+        Ok(TypeSignature::type_of(self)?.size()?)
     }
 
-    pub fn depth(&self) -> u8 {
-        TypeSignature::type_of(self).depth()
+    pub fn depth(&self) -> Result<u8> {
+        Ok(TypeSignature::type_of(self)?.depth())
     }
 
     /// Invariant: the supplied Values have already been "checked", i.e., it's a valid Value object
@@ -978,14 +1005,16 @@ impl Value {
     }
 
     pub fn string_utf8_from_string_utf8_literal(tokenized_str: String) -> Result<Value> {
-        let wrapped_codepoints_matcher =
-            Regex::new("^\\\\u\\{(?P<value>[[:xdigit:]]+)\\}").unwrap();
+        let wrapped_codepoints_matcher = Regex::new("^\\\\u\\{(?P<value>[[:xdigit:]]+)\\}")
+            .map_err(|_| InterpreterError::Expect("Bad regex".into()))?;
         let mut window = tokenized_str.as_str();
         let mut cursor = 0;
         let mut data: Vec<Vec<u8>> = vec![];
         while !window.is_empty() {
             if let Some(captures) = wrapped_codepoints_matcher.captures(window) {
-                let matched = captures.name("value").unwrap();
+                let matched = captures
+                    .name("value")
+                    .ok_or_else(|| InterpreterError::Expect("Expected capture".into()))?;
                 let scalar_value = window[matched.start()..matched.end()].to_string();
                 let unicode_char = {
                     let u = u32::from_str_radix(&scalar_value, 16)
@@ -1033,163 +1062,167 @@ impl Value {
         ))))
     }
 
-    pub fn expect_ascii(self) -> String {
+    pub fn expect_ascii(self) -> Result<String> {
         if let Value::Sequence(SequenceData::String(CharType::ASCII(ASCIIData { data }))) = self {
-            String::from_utf8(data).unwrap()
+            Ok(String::from_utf8(data)
+                .map_err(|_| InterpreterError::Expect("Non UTF-8 data in string".into()))?)
         } else {
             error!("Value '{:?}' is not an ASCII string", &self);
-            panic!();
+            Err(InterpreterError::Expect("Expected ASCII string".into()).into())
         }
     }
 
-    pub fn expect_u128(self) -> u128 {
+    pub fn expect_u128(self) -> Result<u128> {
         if let Value::UInt(inner) = self {
-            inner
+            Ok(inner)
         } else {
             error!("Value '{:?}' is not a u128", &self);
-            panic!();
+            Err(InterpreterError::Expect("Expected u128".into()).into())
         }
     }
 
-    pub fn expect_i128(self) -> i128 {
+    pub fn expect_i128(self) -> Result<i128> {
         if let Value::Int(inner) = self {
-            inner
+            Ok(inner)
         } else {
             error!("Value '{:?}' is not an i128", &self);
-            panic!();
+            Err(InterpreterError::Expect("Expected i128".into()).into())
         }
     }
 
-    pub fn expect_buff(self, sz: usize) -> Vec<u8> {
+    pub fn expect_buff(self, sz: usize) -> Result<Vec<u8>> {
         if let Value::Sequence(SequenceData::Buffer(buffdata)) = self {
             if buffdata.data.len() <= sz {
-                buffdata.data
+                Ok(buffdata.data)
             } else {
                 error!(
                     "Value buffer has len {}, expected {}",
                     buffdata.data.len(),
                     sz
                 );
-                panic!();
+                Err(InterpreterError::Expect("Unexpected buff length".into()).into())
             }
         } else {
             error!("Value '{:?}' is not a buff", &self);
-            panic!();
+            Err(InterpreterError::Expect("Expected buff".into()).into())
         }
     }
 
-    pub fn expect_list(self) -> Vec<Value> {
+    pub fn expect_list(self) -> Result<Vec<Value>> {
         if let Value::Sequence(SequenceData::List(listdata)) = self {
-            listdata.data
+            Ok(listdata.data)
         } else {
             error!("Value '{:?}' is not a list", &self);
-            panic!();
+            Err(InterpreterError::Expect("Expected list".into()).into())
         }
     }
 
-    pub fn expect_buff_padded(self, sz: usize, pad: u8) -> Vec<u8> {
-        let mut data = self.expect_buff(sz);
+    pub fn expect_buff_padded(self, sz: usize, pad: u8) -> Result<Vec<u8>> {
+        let mut data = self.expect_buff(sz)?;
         if sz > data.len() {
             for _ in data.len()..sz {
                 data.push(pad)
             }
         }
-        data
+        Ok(data)
     }
 
-    pub fn expect_bool(self) -> bool {
+    pub fn expect_bool(self) -> Result<bool> {
         if let Value::Bool(b) = self {
-            b
+            Ok(b)
         } else {
             error!("Value '{:?}' is not a bool", &self);
-            panic!();
+            Err(InterpreterError::Expect("Expected bool".into()).into())
         }
     }
 
-    pub fn expect_tuple(self) -> TupleData {
+    pub fn expect_tuple(self) -> Result<TupleData> {
         if let Value::Tuple(data) = self {
-            data
+            Ok(data)
         } else {
             error!("Value '{:?}' is not a tuple", &self);
-            panic!();
+            Err(InterpreterError::Expect("Expected tuple".into()).into())
         }
     }
 
-    pub fn expect_optional(self) -> Option<Value> {
+    pub fn expect_optional(self) -> Result<Option<Value>> {
         if let Value::Optional(opt) = self {
             match opt.data {
-                Some(boxed_value) => Some(*boxed_value),
-                None => None,
+                Some(boxed_value) => Ok(Some(*boxed_value)),
+                None => Ok(None),
             }
         } else {
             error!("Value '{:?}' is not an optional", &self);
-            panic!();
+            Err(InterpreterError::Expect("Expected optional".into()).into())
         }
     }
 
-    pub fn expect_principal(self) -> PrincipalData {
+    pub fn expect_principal(self) -> Result<PrincipalData> {
         if let Value::Principal(p) = self {
-            p
+            Ok(p)
         } else {
             error!("Value '{:?}' is not a principal", &self);
-            panic!();
+            Err(InterpreterError::Expect("Expected principal".into()).into())
         }
     }
 
-    pub fn expect_callable(self) -> CallableData {
+    pub fn expect_callable(self) -> Result<CallableData> {
         if let Value::CallableContract(t) = self {
-            t
+            Ok(t)
         } else {
             error!("Value '{:?}' is not a callable contract", &self);
-            panic!();
+            Err(InterpreterError::Expect("Expected callable".into()).into())
         }
     }
 
-    pub fn expect_result(self) -> std::result::Result<Value, Value> {
+    pub fn expect_result(self) -> Result<std::result::Result<Value, Value>> {
         if let Value::Response(res_data) = self {
             if res_data.committed {
-                Ok(*res_data.data)
+                Ok(Ok(*res_data.data))
             } else {
-                Err(*res_data.data)
+                Ok(Err(*res_data.data))
             }
         } else {
             error!("Value '{:?}' is not a response", &self);
-            panic!();
+            Err(InterpreterError::Expect("Expected response".into()).into())
         }
     }
 
-    pub fn expect_result_ok(self) -> Value {
+    pub fn expect_result_ok(self) -> Result<Value> {
         if let Value::Response(res_data) = self {
             if res_data.committed {
-                *res_data.data
+                Ok(*res_data.data)
             } else {
                 error!("Value is not a (ok ..)");
-                panic!();
+                Err(InterpreterError::Expect("Expected ok response".into()).into())
             }
         } else {
             error!("Value '{:?}' is not a response", &self);
-            panic!();
+            Err(InterpreterError::Expect("Expected response".into()).into())
         }
     }
 
-    pub fn expect_result_err(self) -> Value {
+    pub fn expect_result_err(self) -> Result<Value> {
         if let Value::Response(res_data) = self {
             if !res_data.committed {
-                *res_data.data
+                Ok(*res_data.data)
             } else {
                 error!("Value is not a (err ..)");
-                panic!();
+                Err(InterpreterError::Expect("Expected err response".into()).into())
             }
         } else {
             error!("Value '{:?}' is not a response", &self);
-            panic!();
+            Err(InterpreterError::Expect("Expected response".into()).into())
         }
     }
 }
 
 impl BuffData {
-    pub fn len(&self) -> BufferLength {
-        self.data.len().try_into().unwrap()
+    pub fn len(&self) -> Result<BufferLength> {
+        self.data
+            .len()
+            .try_into()
+            .map_err(|_| InterpreterError::Expect("Data length should be valid".into()).into())
     }
 
     pub fn as_slice(&self) -> &[u8] {
@@ -1207,8 +1240,11 @@ impl BuffData {
 }
 
 impl ListData {
-    pub fn len(&self) -> u32 {
-        self.data.len().try_into().unwrap()
+    pub fn len(&self) -> Result<u32> {
+        self.data
+            .len()
+            .try_into()
+            .map_err(|_| InterpreterError::Expect("Data length should be valid".into()).into())
     }
 
     fn append(&mut self, epoch: &StacksEpochId, other_seq: ListData) -> Result<()> {
@@ -1233,8 +1269,11 @@ impl ASCIIData {
         Ok(())
     }
 
-    pub fn len(&self) -> BufferLength {
-        self.data.len().try_into().unwrap()
+    pub fn len(&self) -> Result<BufferLength> {
+        self.data
+            .len()
+            .try_into()
+            .map_err(|_| InterpreterError::Expect("Data length should be valid".into()).into())
     }
 }
 
@@ -1244,8 +1283,11 @@ impl UTF8Data {
         Ok(())
     }
 
-    pub fn len(&self) -> BufferLength {
-        self.data.len().try_into().unwrap()
+    pub fn len(&self) -> Result<BufferLength> {
+        self.data
+            .len()
+            .try_into()
+            .map_err(|_| InterpreterError::Expect("Data length should be valid".into()).into())
     }
 }
 
@@ -1497,7 +1539,7 @@ impl TupleData {
         let mut type_map = BTreeMap::new();
         let mut data_map = BTreeMap::new();
         for (name, value) in data.drain(..) {
-            let type_info = TypeSignature::type_of(&value);
+            let type_info = TypeSignature::type_of(&value)?;
             if type_map.contains_key(&name) {
                 return Err(CheckErrors::NameAlreadyUsed(name.into()).into());
             } else {
@@ -1668,7 +1710,7 @@ mod test {
 
     #[test]
     fn simple_size_test() {
-        assert_eq!(Value::Int(10).size(), 16);
+        assert_eq!(Value::Int(10).size().unwrap(), 16);
     }
 
     #[test]
@@ -1728,15 +1770,15 @@ mod test {
         let buff = Value::Sequence(SequenceData::Buffer(BuffData {
             data: vec![1, 2, 3, 4, 5],
         }));
-        assert_eq!(buff.clone().expect_buff(5), vec![1, 2, 3, 4, 5]);
-        assert_eq!(buff.clone().expect_buff(6), vec![1, 2, 3, 4, 5]);
+        assert_eq!(buff.clone().expect_buff(5).unwrap(), vec![1, 2, 3, 4, 5]);
+        assert_eq!(buff.clone().expect_buff(6).unwrap(), vec![1, 2, 3, 4, 5]);
         assert_eq!(
-            buff.clone().expect_buff_padded(6, 0),
+            buff.clone().expect_buff_padded(6, 0).unwrap(),
             vec![1, 2, 3, 4, 5, 0]
         );
-        assert_eq!(buff.clone().expect_buff(10), vec![1, 2, 3, 4, 5]);
+        assert_eq!(buff.clone().expect_buff(10).unwrap(), vec![1, 2, 3, 4, 5]);
         assert_eq!(
-            buff.clone().expect_buff_padded(10, 1),
+            buff.clone().expect_buff_padded(10, 1).unwrap(),
             vec![1, 2, 3, 4, 5, 1, 1, 1, 1, 1]
         );
     }
@@ -1747,6 +1789,6 @@ mod test {
         let buff = Value::Sequence(SequenceData::Buffer(BuffData {
             data: vec![1, 2, 3, 4, 5],
         }));
-        let _ = buff.expect_buff(4);
+        let _ = buff.expect_buff(4).unwrap();
     }
 }
diff --git a/clarity/src/vm/types/serialization.rs b/clarity/src/vm/types/serialization.rs
index 3d2b71c2e4..5a27fc7a13 100644
--- a/clarity/src/vm/types/serialization.rs
+++ b/clarity/src/vm/types/serialization.rs
@@ -57,10 +57,14 @@ pub enum SerializationError {
     DeserializationError(String),
     DeserializeExpected(TypeSignature),
     LeftoverBytesInDeserialization,
+    SerializationError(String),
 }
 
 lazy_static! {
-    pub static ref NONE_SERIALIZATION_LEN: u64 = Value::none().serialize_to_vec().len() as u64;
+    pub static ref NONE_SERIALIZATION_LEN: u64 = {
+        #[allow(clippy::unwrap_used)]
+        u64::try_from(Value::none().serialize_to_vec().unwrap().len()).unwrap()
+    };
 }
 
 /// Deserialization uses a specific epoch for passing to the type signature checks
@@ -89,6 +93,9 @@ impl std::fmt::Display for SerializationError {
             SerializationError::DeserializationError(e) => {
                 write!(f, "Deserialization error: {}", e)
             }
+            SerializationError::SerializationError(e) => {
+                write!(f, "Serialization error: {}", e)
+            }
             SerializationError::DeserializeExpected(e) => write!(
                 f,
                 "Deserialization expected the type of the input to be: {}",
@@ -592,6 +599,7 @@ impl Value {
                 return Err(CheckErrors::TypeSignatureTooDeep.into());
             }
 
+            #[allow(clippy::expect_used)]
             let expected_type = stack
                 .last()
                 .expect("FATAL: stack.last() should always be some() because of loop condition")
@@ -719,6 +727,8 @@ impl Value {
                         None => (None, None),
                         Some(TypeSignature::SequenceType(SequenceSubtype::ListType(list_type))) => {
                             if len > list_type.get_max_len() {
+                                // unwrap is safe because of the match condition
+                                #[allow(clippy::unwrap_used)]
                                 return Err(SerializationError::DeserializeExpected(
                                     expected_type.unwrap().clone(),
                                 ));
@@ -770,12 +780,16 @@ impl Value {
                         Some(TypeSignature::TupleType(tuple_type)) => {
                             if sanitize {
                                 if u64::from(len) < tuple_type.len() {
+                                    // unwrap is safe because of the match condition
+                                    #[allow(clippy::unwrap_used)]
                                     return Err(SerializationError::DeserializeExpected(
                                         expected_type.unwrap().clone(),
                                     ));
                                 }
                             } else {
                                 if len as u64 != tuple_type.len() {
+                                    // unwrap is safe because of the match condition
+                                    #[allow(clippy::unwrap_used)]
                                     return Err(SerializationError::DeserializeExpected(
                                         expected_type.unwrap().clone(),
                                     ));
@@ -1019,7 +1033,7 @@ impl Value {
         ))
     }
 
-    pub fn serialize_write<W: Write>(&self, w: &mut W) -> std::io::Result<()> {
+    pub fn serialize_write<W: Write>(&self, w: &mut W) -> Result<(), SerializationError> {
         use super::CharType::*;
         use super::PrincipalData::*;
         use super::SequenceData::{self, *};
@@ -1047,13 +1061,23 @@ impl Value {
                 value.serialize_write(w)?;
             }
             Sequence(List(data)) => {
-                w.write_all(&data.len().to_be_bytes())?;
+                let len_bytes = data
+                    .len()
+                    .map_err(|e| SerializationError::SerializationError(e.to_string()))?
+                    .to_be_bytes();
+                w.write_all(&len_bytes)?;
                 for item in data.data.iter() {
                     item.serialize_write(w)?;
                 }
             }
             Sequence(Buffer(value)) => {
-                w.write_all(&(u32::from(value.len()).to_be_bytes()))?;
+                let len_bytes = u32::from(
+                    value
+                        .len()
+                        .map_err(|e| SerializationError::SerializationError(e.to_string()))?,
+                )
+                .to_be_bytes();
+                w.write_all(&len_bytes)?;
                 w.write_all(&value.data)?
             }
             Sequence(SequenceData::String(UTF8(value))) => {
@@ -1064,11 +1088,20 @@ impl Value {
                 }
             }
             Sequence(SequenceData::String(ASCII(value))) => {
-                w.write_all(&(u32::from(value.len()).to_be_bytes()))?;
+                let len_bytes = u32::from(
+                    value
+                        .len()
+                        .map_err(|e| SerializationError::SerializationError(e.to_string()))?,
+                )
+                .to_be_bytes();
+                w.write_all(&len_bytes)?;
                 w.write_all(&value.data)?
             }
             Tuple(data) => {
-                w.write_all(&u32::try_from(data.data_map.len()).unwrap().to_be_bytes())?;
+                let len_bytes = u32::try_from(data.data_map.len())
+                    .map_err(|e| SerializationError::SerializationError(e.to_string()))?
+                    .to_be_bytes();
+                w.write_all(&len_bytes)?;
                 for (key, value) in data.data_map.iter() {
                     key.serialize_write(w)?;
                     value.serialize_write(w)?;
@@ -1145,11 +1178,14 @@ impl Value {
         Value::try_deserialize_bytes_untyped(&mut data)
     }
 
-    pub fn serialized_size(&self) -> u32 {
+    pub fn serialized_size(&self) -> Result<u32, SerializationError> {
         let mut counter = WriteCounter { count: 0 };
-        self.serialize_write(&mut counter)
-            .expect("Error: Failed to count serialization length of Clarity value");
-        counter.count
+        self.serialize_write(&mut counter).map_err(|_| {
+            SerializationError::DeserializationError(
+                "Error: Failed to count serialization length of Clarity value".into(),
+            )
+        })?;
+        Ok(counter.count)
     }
 }
 
@@ -1181,17 +1217,17 @@ impl Write for WriteCounter {
 }
 
 impl Value {
-    pub fn serialize_to_vec(&self) -> Vec<u8> {
+    pub fn serialize_to_vec(&self) -> Result<Vec<u8>, InterpreterError> {
         let mut byte_serialization = Vec::new();
         self.serialize_write(&mut byte_serialization)
-            .expect("IOError filling byte buffer.");
-        byte_serialization
+            .map_err(|_| InterpreterError::Expect("IOError filling byte buffer.".into()))?;
+        Ok(byte_serialization)
     }
 
     /// This does *not* perform any data sanitization
-    pub fn serialize_to_hex(&self) -> String {
-        let byte_serialization = self.serialize_to_vec();
-        to_hex(byte_serialization.as_slice())
+    pub fn serialize_to_hex(&self) -> Result<String, InterpreterError> {
+        let byte_serialization = self.serialize_to_vec()?;
+        Ok(to_hex(byte_serialization.as_slice()))
     }
 
     /// Sanitize `value` against pre-2.4 serialization
@@ -1215,7 +1251,8 @@ impl Value {
                     TypeSignature::SequenceType(SequenceSubtype::ListType(lt)) => lt,
                     _ => return None,
                 };
-                if l.len() > lt.get_max_len() {
+                // if cannot compute l.len(), sanitization fails, so use ? operator can short return
+                if l.len().ok()? > lt.get_max_len() {
                     return None;
                 }
                 let mut sanitized_items = vec![];
@@ -1308,23 +1345,19 @@ impl Value {
 
 impl ClaritySerializable for u32 {
     fn serialize(&self) -> String {
-        let mut buffer = Vec::new();
-        buffer
-            .write_all(&self.to_be_bytes())
-            .expect("u32 serialization: failed writing.");
-        to_hex(buffer.as_slice())
+        to_hex(&self.to_be_bytes())
     }
 }
 
 impl ClarityDeserializable<u32> for u32 {
-    fn deserialize(input: &str) -> Self {
-        let bytes = hex_bytes(&input).expect("u32 deserialization: failed decoding bytes.");
+    fn deserialize(input: &str) -> Result<Self, ClarityError> {
+        let bytes = hex_bytes(&input).map_err(|_| {
+            InterpreterError::Expect("u32 deserialization: failed decoding bytes.".into())
+        })?;
         assert_eq!(bytes.len(), 4);
-        u32::from_be_bytes(
-            bytes[0..4]
-                .try_into()
-                .expect("u32 deserialization: failed reading."),
-        )
+        Ok(u32::from_be_bytes(bytes[0..4].try_into().map_err(
+            |_| InterpreterError::Expect("u32 deserialization: failed reading.".into()),
+        )?))
     }
 }
 
@@ -1332,7 +1365,10 @@ impl ClarityDeserializable<u32> for u32 {
 ///       sanitize its serialization or deserialization.
 impl StacksMessageCodec for Value {
     fn consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), codec_error> {
-        self.serialize_write(fd).map_err(codec_error::WriteError)
+        self.serialize_write(fd).map_err(|e| match e {
+            SerializationError::IOError(io_e) => codec_error::WriteError(io_e.err),
+            other => codec_error::SerializeError(other.to_string()),
+        })
     }
 
     fn consensus_deserialize<R: Read>(fd: &mut R) -> Result<Value, codec_error> {
@@ -1343,15 +1379,6 @@ impl StacksMessageCodec for Value {
     }
 }
 
-impl std::hash::Hash for Value {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        let mut s = vec![];
-        self.serialize_write(&mut s)
-            .expect("FATAL: failed to serialize to vec");
-        s.hash(state);
-    }
-}
-
 #[cfg(test)]
 pub mod tests {
     use rstest::rstest;
@@ -1376,28 +1403,33 @@ pub mod tests {
     fn test_deser_ser(v: Value) {
         assert_eq!(
             &v,
-            &Value::try_deserialize_hex(&v.serialize_to_hex(), &TypeSignature::type_of(&v), false)
-                .unwrap()
+            &Value::try_deserialize_hex(
+                &v.serialize_to_hex().unwrap(),
+                &TypeSignature::type_of(&v).unwrap(),
+                false
+            )
+            .unwrap()
         );
         assert_eq!(
             &v,
-            &Value::try_deserialize_hex_untyped(&v.serialize_to_hex()).unwrap()
+            &Value::try_deserialize_hex_untyped(&v.serialize_to_hex().unwrap()).unwrap()
         );
         // test the serialized_size implementation
         assert_eq!(
-            v.serialized_size(),
-            v.serialize_to_hex().len() as u32 / 2,
+            v.serialized_size().unwrap(),
+            v.serialize_to_hex().unwrap().len() as u32 / 2,
             "serialized_size() should return the byte length of the serialization (half the length of the hex encoding)",
         );
     }
 
     fn test_deser_u32_helper(num: u32) {
-        assert_eq!(num, u32::deserialize(&num.serialize()));
+        assert_eq!(num, u32::deserialize(&num.serialize()).unwrap());
     }
 
     fn test_bad_expectation(v: Value, e: TypeSignature) {
         assert!(
-            match Value::try_deserialize_hex(&v.serialize_to_hex(), &e, false).unwrap_err() {
+            match Value::try_deserialize_hex(&v.serialize_to_hex().unwrap(), &e, false).unwrap_err()
+            {
                 SerializationError::DeserializeExpected(_) => true,
                 _ => false,
             }
@@ -1427,19 +1459,22 @@ pub mod tests {
 
         // Should be legal!
         Value::try_deserialize_hex(
-            &Value::list_from(vec![]).unwrap().serialize_to_hex(),
+            &Value::list_from(vec![])
+                .unwrap()
+                .serialize_to_hex()
+                .unwrap(),
             &TypeSignature::from_string("(list 2 (list 3 int))", version, epoch),
             false,
         )
         .unwrap();
         Value::try_deserialize_hex(
-            &list_list_int.serialize_to_hex(),
+            &list_list_int.serialize_to_hex().unwrap(),
             &TypeSignature::from_string("(list 2 (list 3 int))", version, epoch),
             false,
         )
         .unwrap();
         Value::try_deserialize_hex(
-            &list_list_int.serialize_to_hex(),
+            &list_list_int.serialize_to_hex().unwrap(),
             &TypeSignature::from_string("(list 1 (list 4 int))", version, epoch),
             false,
         )
@@ -1663,14 +1698,14 @@ pub mod tests {
         // t_0 and t_1 are actually the same
         assert_eq!(
             Value::try_deserialize_hex(
-                &t_1.serialize_to_hex(),
-                &TypeSignature::type_of(&t_0),
+                &t_1.serialize_to_hex().unwrap(),
+                &TypeSignature::type_of(&t_0).unwrap(),
                 false
             )
             .unwrap(),
             Value::try_deserialize_hex(
-                &t_0.serialize_to_hex(),
-                &TypeSignature::type_of(&t_0),
+                &t_0.serialize_to_hex().unwrap(),
+                &TypeSignature::type_of(&t_0).unwrap(),
                 false
             )
             .unwrap()
@@ -1678,8 +1713,8 @@ pub mod tests {
 
         // field number not equal to expectations
         assert!(match Value::try_deserialize_hex(
-            &t_3.serialize_to_hex(),
-            &TypeSignature::type_of(&t_1),
+            &t_3.serialize_to_hex().unwrap(),
+            &TypeSignature::type_of(&t_1).unwrap(),
             false
         )
         .unwrap_err()
@@ -1690,8 +1725,8 @@ pub mod tests {
 
         // field type mismatch
         assert!(match Value::try_deserialize_hex(
-            &t_2.serialize_to_hex(),
-            &TypeSignature::type_of(&t_1),
+            &t_2.serialize_to_hex().unwrap(),
+            &TypeSignature::type_of(&t_1).unwrap(),
             false
         )
         .unwrap_err()
@@ -1702,8 +1737,8 @@ pub mod tests {
 
         // field not-present in expected
         assert!(match Value::try_deserialize_hex(
-            &t_1.serialize_to_hex(),
-            &TypeSignature::type_of(&t_4),
+            &t_1.serialize_to_hex().unwrap(),
+            &TypeSignature::type_of(&t_4).unwrap(),
             false
         )
         .unwrap_err()
@@ -2044,7 +2079,7 @@ pub mod tests {
                 "Testing {}. Expected sanitization = {}",
                 input_val, expected_out
             );
-            let serialized = input_val.serialize_to_hex();
+            let serialized = input_val.serialize_to_hex().unwrap();
 
             let result =
                 RollbackWrapper::deserialize_value(&serialized, good_type, &epoch).map(|x| x.value);
@@ -2132,7 +2167,7 @@ pub mod tests {
 
         for (test, expected) in tests.iter() {
             if let Ok(x) = expected {
-                assert_eq!(test, &x.serialize_to_hex());
+                assert_eq!(test, &x.serialize_to_hex().unwrap());
             }
             assert_eq!(expected, &Value::try_deserialize_hex_untyped(test));
             assert_eq!(
@@ -2145,7 +2180,7 @@ pub mod tests {
         for (test, expected) in tests.iter() {
             if let Ok(value) = expected {
                 assert_eq!(
-                    value.serialized_size(),
+                    value.serialized_size().unwrap(),
                     test.len() as u32 / 2,
                     "serialized_size() should return the byte length of the serialization (half the length of the hex encoding)",
                 );
diff --git a/clarity/src/vm/types/signatures.rs b/clarity/src/vm/types/signatures.rs
index a8052ab305..5c8a54402a 100644
--- a/clarity/src/vm/types/signatures.rs
+++ b/clarity/src/vm/types/signatures.rs
@@ -44,6 +44,7 @@ pub struct AssetIdentifier {
 }
 
 impl AssetIdentifier {
+    #[allow(clippy::unwrap_used)]
     pub fn STX() -> AssetIdentifier {
         AssetIdentifier {
             contract_identifier: QualifiedContractIdentifier::new(
@@ -54,6 +55,7 @@ impl AssetIdentifier {
         }
     }
 
+    #[allow(clippy::unwrap_used)]
     pub fn STX_burned() -> AssetIdentifier {
         AssetIdentifier {
             contract_identifier: QualifiedContractIdentifier::new(
@@ -123,9 +125,9 @@ pub enum SequenceSubtype {
 }
 
 impl SequenceSubtype {
-    pub fn unit_type(&self) -> TypeSignature {
+    pub fn unit_type(&self) -> Result<TypeSignature> {
         match &self {
-            SequenceSubtype::ListType(ref list_data) => list_data.clone().destruct().0,
+            SequenceSubtype::ListType(ref list_data) => Ok(list_data.clone().destruct().0),
             SequenceSubtype::BufferType(_) => TypeSignature::min_buffer(),
             SequenceSubtype::StringType(StringSubtype::ASCII(_)) => {
                 TypeSignature::min_string_ascii()
@@ -160,30 +162,54 @@ use self::TypeSignature::{
 };
 
 lazy_static! {
-    pub static ref BUFF_64: TypeSignature = SequenceType(SequenceSubtype::BufferType(
-        BufferLength::try_from(64u32).expect("BUG: Legal Clarity buffer length marked invalid")
-    ));
-    pub static ref BUFF_65: TypeSignature = SequenceType(SequenceSubtype::BufferType(
-        BufferLength::try_from(65u32).expect("BUG: Legal Clarity buffer length marked invalid")
-    ));
-    pub static ref BUFF_32: TypeSignature = SequenceType(SequenceSubtype::BufferType(
-        BufferLength::try_from(32u32).expect("BUG: Legal Clarity buffer length marked invalid")
-    ));
-    pub static ref BUFF_33: TypeSignature = SequenceType(SequenceSubtype::BufferType(
-        BufferLength::try_from(33u32).expect("BUG: Legal Clarity buffer length marked invalid")
-    ));
-    pub static ref BUFF_20: TypeSignature = SequenceType(SequenceSubtype::BufferType(
-        BufferLength::try_from(20u32).expect("BUG: Legal Clarity buffer length marked invalid")
-    ));
-    pub static ref BUFF_21: TypeSignature = SequenceType(SequenceSubtype::BufferType(
-        BufferLength::try_from(21u32).expect("BUG: Legal Clarity buffer length marked invalid")
-    ));
-    pub static ref BUFF_1: TypeSignature = SequenceType(SequenceSubtype::BufferType(
-        BufferLength::try_from(1u32).expect("BUG: Legal Clarity buffer length marked invalid")
-    ));
-    pub static ref BUFF_16: TypeSignature = SequenceType(SequenceSubtype::BufferType(
-        BufferLength::try_from(16u32).expect("BUG: Legal Clarity buffer length marked invalid")
-    ));
+    pub static ref BUFF_64: TypeSignature = {
+        #[allow(clippy::expect_used)]
+        SequenceType(SequenceSubtype::BufferType(
+            BufferLength::try_from(64u32).expect("BUG: Legal Clarity buffer length marked invalid"),
+        ))
+    };
+    pub static ref BUFF_65: TypeSignature = {
+        #[allow(clippy::expect_used)]
+        SequenceType(SequenceSubtype::BufferType(
+            BufferLength::try_from(65u32).expect("BUG: Legal Clarity buffer length marked invalid"),
+        ))
+    };
+    pub static ref BUFF_32: TypeSignature = {
+        #[allow(clippy::expect_used)]
+        SequenceType(SequenceSubtype::BufferType(
+            BufferLength::try_from(32u32).expect("BUG: Legal Clarity buffer length marked invalid"),
+        ))
+    };
+    pub static ref BUFF_33: TypeSignature = {
+        #[allow(clippy::expect_used)]
+        SequenceType(SequenceSubtype::BufferType(
+            BufferLength::try_from(33u32).expect("BUG: Legal Clarity buffer length marked invalid"),
+        ))
+    };
+    pub static ref BUFF_20: TypeSignature = {
+        #[allow(clippy::expect_used)]
+        SequenceType(SequenceSubtype::BufferType(
+            BufferLength::try_from(20u32).expect("BUG: Legal Clarity buffer length marked invalid"),
+        ))
+    };
+    pub static ref BUFF_21: TypeSignature = {
+        #[allow(clippy::expect_used)]
+        SequenceType(SequenceSubtype::BufferType(
+            BufferLength::try_from(21u32).expect("BUG: Legal Clarity buffer length marked invalid"),
+        ))
+    };
+    pub static ref BUFF_1: TypeSignature = {
+        #[allow(clippy::expect_used)]
+        SequenceType(SequenceSubtype::BufferType(
+            BufferLength::try_from(1u32).expect("BUG: Legal Clarity buffer length marked invalid"),
+        ))
+    };
+    pub static ref BUFF_16: TypeSignature = {
+        #[allow(clippy::expect_used)]
+        SequenceType(SequenceSubtype::BufferType(
+            BufferLength::try_from(16u32).expect("BUG: Legal Clarity buffer length marked invalid"),
+        ))
+    };
 }
 
 pub const ASCII_40: TypeSignature = SequenceType(SequenceSubtype::StringType(
@@ -453,7 +479,7 @@ impl ListTypeData {
             max_len: max_len as u32,
         };
         let would_be_size = list_data
-            .inner_size()
+            .inner_size()?
             .ok_or_else(|| CheckErrors::ValueTooLarge)?;
         if would_be_size > MAX_VALUE_SIZE {
             Err(CheckErrors::ValueTooLarge)
@@ -485,7 +511,7 @@ impl ListTypeData {
 
 impl TypeSignature {
     pub fn new_option(inner_type: TypeSignature) -> Result<TypeSignature> {
-        let new_size = WRAPPER_VALUE_SIZE + inner_type.size();
+        let new_size = WRAPPER_VALUE_SIZE + inner_type.size()?;
         let new_depth = 1 + inner_type.depth();
         if new_size > MAX_VALUE_SIZE {
             Err(CheckErrors::ValueTooLarge)
@@ -497,7 +523,7 @@ impl TypeSignature {
     }
 
     pub fn new_response(ok_type: TypeSignature, err_type: TypeSignature) -> Result<TypeSignature> {
-        let new_size = WRAPPER_VALUE_SIZE + cmp::max(ok_type.size(), err_type.size());
+        let new_size = WRAPPER_VALUE_SIZE + cmp::max(ok_type.size()?, err_type.size()?);
         let new_depth = 1 + cmp::max(ok_type.depth(), err_type.depth());
 
         if new_size > MAX_VALUE_SIZE {
@@ -522,7 +548,7 @@ impl TypeSignature {
     }
 
     pub fn admits(&self, epoch: &StacksEpochId, x: &Value) -> Result<bool> {
-        let x_type = TypeSignature::type_of(x);
+        let x_type = TypeSignature::type_of(x)?;
         self.admits_type(epoch, &x_type)
     }
 
@@ -533,7 +559,9 @@ impl TypeSignature {
             | StacksEpochId::Epoch22
             | StacksEpochId::Epoch23
             | StacksEpochId::Epoch24 => self.admits_type_v2_1(other),
-            StacksEpochId::Epoch10 => unreachable!("epoch 1.0 not supported"),
+            StacksEpochId::Epoch10 => {
+                return Err(CheckErrors::Expects("epoch 1.0 not supported".into()))
+            }
         }
     }
 
@@ -620,8 +648,16 @@ impl TypeSignature {
                 }
             }
             NoType => Err(CheckErrors::CouldNotDetermineType),
-            CallableType(_) => unreachable!("CallableType should not be used in epoch v2.0"),
-            ListUnionType(_) => unreachable!("ListUnionType should not be used in epoch v2.0"),
+            CallableType(_) => {
+                return Err(CheckErrors::Expects(
+                    "CallableType should not be used in epoch v2.0".into(),
+                ))
+            }
+            ListUnionType(_) => {
+                return Err(CheckErrors::Expects(
+                    "ListUnionType should not be used in epoch v2.0".into(),
+                ))
+            }
             _ => Ok(other == self),
         }
     }
@@ -838,7 +874,7 @@ impl TryFrom<BTreeMap<ClarityName, TypeSignature>> for TupleTypeSignature {
         }
         let result = TupleTypeSignature { type_map };
         let would_be_size = result
-            .inner_size()
+            .inner_size()?
             .ok_or_else(|| CheckErrors::ValueTooLarge)?;
         if would_be_size > MAX_VALUE_SIZE {
             Err(CheckErrors::ValueTooLarge)
@@ -955,59 +991,81 @@ impl FunctionArg {
 }
 
 impl TypeSignature {
-    pub fn empty_buffer() -> TypeSignature {
-        SequenceType(SequenceSubtype::BufferType(0_u32.try_into().unwrap()))
+    pub fn empty_buffer() -> Result<TypeSignature> {
+        Ok(SequenceType(SequenceSubtype::BufferType(
+            0_u32.try_into().map_err(|_| {
+                CheckErrors::Expects("FAIL: Empty clarity value size is not realizable".into())
+            })?,
+        )))
     }
 
-    pub fn min_buffer() -> TypeSignature {
-        SequenceType(SequenceSubtype::BufferType(1_u32.try_into().unwrap()))
+    pub fn min_buffer() -> Result<TypeSignature> {
+        Ok(SequenceType(SequenceSubtype::BufferType(
+            1_u32.try_into().map_err(|_| {
+                CheckErrors::Expects("FAIL: Min clarity value size is not realizable".into())
+            })?,
+        )))
     }
 
-    pub fn min_string_ascii() -> TypeSignature {
-        SequenceType(SequenceSubtype::StringType(StringSubtype::ASCII(
-            1_u32.try_into().unwrap(),
+    pub fn min_string_ascii() -> Result<TypeSignature> {
+        Ok(SequenceType(SequenceSubtype::StringType(
+            StringSubtype::ASCII(1_u32.try_into().map_err(|_| {
+                CheckErrors::Expects("FAIL: Min clarity value size is not realizable".into())
+            })?),
         )))
     }
 
-    pub fn min_string_utf8() -> TypeSignature {
-        SequenceType(SequenceSubtype::StringType(StringSubtype::UTF8(
-            1_u32.try_into().unwrap(),
+    pub fn min_string_utf8() -> Result<TypeSignature> {
+        Ok(SequenceType(SequenceSubtype::StringType(
+            StringSubtype::UTF8(1_u32.try_into().map_err(|_| {
+                CheckErrors::Expects("FAIL: Min clarity value size is not realizable".into())
+            })?),
         )))
     }
 
-    pub fn max_string_ascii() -> TypeSignature {
-        SequenceType(SequenceSubtype::StringType(StringSubtype::ASCII(
-            BufferLength::try_from(MAX_VALUE_SIZE)
-                .expect("FAIL: Max Clarity Value Size is no longer realizable in ASCII Type"),
+    pub fn max_string_ascii() -> Result<TypeSignature> {
+        Ok(SequenceType(SequenceSubtype::StringType(
+            StringSubtype::ASCII(BufferLength::try_from(MAX_VALUE_SIZE).map_err(|_| {
+                CheckErrors::Expects(
+                    "FAIL: Max Clarity Value Size is no longer realizable in ASCII Type".into(),
+                )
+            })?),
         )))
     }
 
-    pub fn max_string_utf8() -> TypeSignature {
-        SequenceType(SequenceSubtype::StringType(StringSubtype::UTF8(
-            StringUTF8Length::try_from(MAX_VALUE_SIZE / 4)
-                .expect("FAIL: Max Clarity Value Size is no longer realizable in UTF8 Type"),
+    pub fn max_string_utf8() -> Result<TypeSignature> {
+        Ok(SequenceType(SequenceSubtype::StringType(
+            StringSubtype::UTF8(StringUTF8Length::try_from(MAX_VALUE_SIZE / 4).map_err(|_| {
+                CheckErrors::Expects(
+                    "FAIL: Max Clarity Value Size is no longer realizable in UTF8 Type".into(),
+                )
+            })?),
         )))
     }
 
-    pub fn max_buffer() -> TypeSignature {
-        SequenceType(SequenceSubtype::BufferType(
-            BufferLength::try_from(MAX_VALUE_SIZE)
-                .expect("FAIL: Max Clarity Value Size is no longer realizable in Buffer Type"),
-        ))
+    pub fn max_buffer() -> Result<TypeSignature> {
+        Ok(SequenceType(SequenceSubtype::BufferType(
+            BufferLength::try_from(MAX_VALUE_SIZE).map_err(|_| {
+                CheckErrors::Expects(
+                    "FAIL: Max Clarity Value Size is no longer realizable in Buffer Type".into(),
+                )
+            })?,
+        )))
     }
 
-    pub fn contract_name_string_ascii_type() -> TypeSignature {
-        TypeSignature::bound_string_ascii_type(
-            CONTRACT_MAX_NAME_LENGTH
-                .try_into()
-                .expect("FAIL: contract name max length exceeds u32 space"),
-        )
+    pub fn contract_name_string_ascii_type() -> Result<TypeSignature> {
+        TypeSignature::bound_string_ascii_type(CONTRACT_MAX_NAME_LENGTH.try_into().map_err(
+            |_| CheckErrors::Expects("FAIL: contract name max length exceeds u32 space".into()),
+        )?)
     }
 
-    pub fn bound_string_ascii_type(max_len: u32) -> TypeSignature {
-        SequenceType(SequenceSubtype::StringType(StringSubtype::ASCII(
-            BufferLength::try_from(max_len)
-                .expect("FAIL: Max Clarity Value Size is no longer realizable in ASCII Type"),
+    pub fn bound_string_ascii_type(max_len: u32) -> Result<TypeSignature> {
+        Ok(SequenceType(SequenceSubtype::StringType(
+            StringSubtype::ASCII(BufferLength::try_from(max_len).map_err(|_| {
+                CheckErrors::Expects(
+                    "FAIL: Max Clarity Value Size is no longer realizable in ASCII Type".into(),
+                )
+            })?),
         )))
     }
 
@@ -1058,7 +1116,9 @@ impl TypeSignature {
             | StacksEpochId::Epoch22
             | StacksEpochId::Epoch23
             | StacksEpochId::Epoch24 => Self::least_supertype_v2_1(a, b),
-            StacksEpochId::Epoch10 => unreachable!("Clarity 1.0 is not supported"),
+            StacksEpochId::Epoch10 => {
+                return Err(CheckErrors::Expects("epoch 1.0 not supported".into()))
+            }
         }
     }
 
@@ -1309,23 +1369,23 @@ impl TypeSignature {
         }
     }
 
-    pub fn type_of(x: &Value) -> TypeSignature {
-        match x {
+    pub fn type_of(x: &Value) -> Result<TypeSignature> {
+        let out = match x {
             Value::Principal(_) => PrincipalType,
             Value::Int(_v) => IntType,
             Value::UInt(_v) => UIntType,
             Value::Bool(_v) => BoolType,
             Value::Tuple(v) => TupleType(v.type_signature.clone()),
-            Value::Sequence(SequenceData::List(list_data)) => list_data.type_signature(),
-            Value::Sequence(SequenceData::Buffer(buff_data)) => buff_data.type_signature(),
+            Value::Sequence(SequenceData::List(list_data)) => list_data.type_signature()?,
+            Value::Sequence(SequenceData::Buffer(buff_data)) => buff_data.type_signature()?,
             Value::Sequence(SequenceData::String(CharType::ASCII(ascii_data))) => {
-                ascii_data.type_signature()
+                ascii_data.type_signature()?
             }
             Value::Sequence(SequenceData::String(CharType::UTF8(utf8_data))) => {
-                utf8_data.type_signature()
+                utf8_data.type_signature()?
             }
-            Value::Optional(v) => v.type_signature(),
-            Value::Response(v) => v.type_signature(),
+            Value::Optional(v) => v.type_signature()?,
+            Value::Response(v) => v.type_signature()?,
             Value::CallableContract(v) => {
                 if let Some(trait_identifier) = &v.trait_identifier {
                     CallableType(CallableSubtype::Trait(trait_identifier.clone()))
@@ -1333,22 +1393,25 @@ impl TypeSignature {
                     CallableType(CallableSubtype::Principal(v.contract_identifier.clone()))
                 }
             }
-        }
+        };
+
+        Ok(out)
     }
 
-    pub fn literal_type_of(x: &Value) -> TypeSignature {
+    pub fn literal_type_of(x: &Value) -> Result<TypeSignature> {
         match x {
-            Value::Principal(PrincipalData::Contract(contract_id)) => {
-                CallableType(CallableSubtype::Principal(contract_id.clone()))
-            }
+            Value::Principal(PrincipalData::Contract(contract_id)) => Ok(CallableType(
+                CallableSubtype::Principal(contract_id.clone()),
+            )),
             _ => Self::type_of(x),
         }
     }
 
     // Checks if resulting type signature is of valid size.
     pub fn construct_parent_list_type(args: &[Value]) -> Result<ListTypeData> {
-        let children_types: Vec<_> = args.iter().map(|x| TypeSignature::type_of(x)).collect();
-        TypeSignature::parent_list_type(&children_types)
+        let children_types: Result<Vec<_>> =
+            args.iter().map(|x| TypeSignature::type_of(x)).collect();
+        TypeSignature::parent_list_type(&children_types?)
     }
 
     pub fn parent_list_type(
@@ -1649,14 +1712,18 @@ impl TypeSignature {
         }
     }
 
-    pub fn size(&self) -> u32 {
-        self.inner_size().expect(
-            "FAIL: .size() overflowed on too large of a type. construction should have failed!",
-        )
+    pub fn size(&self) -> Result<u32> {
+        self.inner_size()?.ok_or_else(|| {
+            CheckErrors::Expects(
+                "FAIL: .size() overflowed on too large of a type. construction should have failed!"
+                    .into(),
+            )
+            .into()
+        })
     }
 
-    fn inner_size(&self) -> Option<u32> {
-        match self {
+    fn inner_size(&self) -> Result<Option<u32>> {
+        let out = match self {
             // NoType's may be asked for their size at runtime --
             //  legal constructions like `(ok 1)` have NoType parts (if they have unknown error variant types).
             NoType => Some(1),
@@ -1664,27 +1731,28 @@ impl TypeSignature {
             UIntType => Some(16),
             BoolType => Some(1),
             PrincipalType => Some(148), // 20+128
-            TupleType(tuple_sig) => tuple_sig.inner_size(),
+            TupleType(tuple_sig) => tuple_sig.inner_size()?,
             SequenceType(SequenceSubtype::BufferType(len))
             | SequenceType(SequenceSubtype::StringType(StringSubtype::ASCII(len))) => {
                 Some(4 + u32::from(len))
             }
-            SequenceType(SequenceSubtype::ListType(list_type)) => list_type.inner_size(),
+            SequenceType(SequenceSubtype::ListType(list_type)) => list_type.inner_size()?,
             SequenceType(SequenceSubtype::StringType(StringSubtype::UTF8(len))) => {
                 Some(4 + 4 * u32::from(len))
             }
-            OptionalType(t) => t.size().checked_add(WRAPPER_VALUE_SIZE),
+            OptionalType(t) => t.size()?.checked_add(WRAPPER_VALUE_SIZE),
             ResponseType(v) => {
                 // ResponseTypes are 1 byte for the committed bool,
                 //   plus max(err_type, ok_type)
                 let (t, s) = (&v.0, &v.1);
-                let t_size = t.size();
-                let s_size = s.size();
+                let t_size = t.size()?;
+                let s_size = s.size()?;
                 cmp::max(t_size, s_size).checked_add(WRAPPER_VALUE_SIZE)
             }
             CallableType(CallableSubtype::Principal(_)) | ListUnionType(_) => Some(148), // 20+128
             CallableType(CallableSubtype::Trait(_)) | TraitReferenceType(_) => Some(276), // 20+128+128
-        }
+        };
+        Ok(out)
     }
 
     pub fn type_size(&self) -> Result<u32> {
@@ -1719,16 +1787,21 @@ impl TypeSignature {
 
 impl ListTypeData {
     /// List Size: type_signature_size + max_len * entry_type.size()
-    fn inner_size(&self) -> Option<u32> {
+    fn inner_size(&self) -> Result<Option<u32>> {
         let total_size = self
             .entry_type
-            .size()
-            .checked_mul(self.max_len)?
-            .checked_add(self.type_size()?)?;
-        if total_size > MAX_VALUE_SIZE {
-            None
-        } else {
-            Some(total_size)
+            .size()?
+            .checked_mul(self.max_len)
+            .and_then(|x| x.checked_add(self.type_size()?));
+        match total_size {
+            Some(total_size) => {
+                if total_size > MAX_VALUE_SIZE {
+                    Ok(None)
+                } else {
+                    Ok(Some(total_size))
+                }
+            }
+            None => Ok(None),
         }
     }
 
@@ -1763,9 +1836,10 @@ impl TupleTypeSignature {
         }
     }
 
-    pub fn size(&self) -> u32 {
-        self.inner_size()
-            .expect("size() overflowed on a constructed type.")
+    pub fn size(&self) -> Result<u32> {
+        self.inner_size()?.ok_or_else(|| {
+            CheckErrors::Expects("size() overflowed on a constructed type.".into()).into()
+        })
     }
 
     fn max_depth(&self) -> u8 {
@@ -1779,24 +1853,33 @@ impl TupleTypeSignature {
     /// Tuple Size:
     ///    size( btreemap<name, value> ) + type_size
     ///    size( btreemap<name, value> ) = 2*map.len() + sum(names) + sum(values)
-    fn inner_size(&self) -> Option<u32> {
-        let mut total_size = u32::try_from(self.type_map.len())
-            .ok()?
-            .checked_mul(2)?
-            .checked_add(self.type_size()?)?;
+    fn inner_size(&self) -> Result<Option<u32>> {
+        let Some(mut total_size) = u32::try_from(self.type_map.len())
+            .ok()
+            .and_then(|x| x.checked_mul(2))
+            .and_then(|x| x.checked_add(self.type_size()?))
+        else {
+            return Ok(None);
+        };
 
         for (name, type_signature) in self.type_map.iter() {
             // we only accept ascii names, so 1 char = 1 byte.
-            total_size = total_size
-                .checked_add(type_signature.size())?
-                // name.len() is bound to MAX_STRING_LEN (128), so `as u32` won't ever truncate
-                .checked_add(name.len() as u32)?;
+            total_size = if let Some(new_size) = total_size.checked_add(type_signature.size()?) {
+                new_size
+            } else {
+                return Ok(None);
+            };
+            total_size = if let Some(new_size) = total_size.checked_add(name.len() as u32) {
+                new_size
+            } else {
+                return Ok(None);
+            };
         }
 
         if total_size > MAX_VALUE_SIZE {
-            None
+            Ok(None)
         } else {
-            Some(total_size)
+            Ok(Some(total_size))
         }
     }
 }
@@ -1959,7 +2042,7 @@ mod test {
     fn type_of_list_of_buffs(#[case] version: ClarityVersion, #[case] epoch: StacksEpochId) {
         let value = execute("(list \"abc\" \"abcde\")").unwrap().unwrap();
         let type_descr = TypeSignature::from_string("(list 2 (string-ascii 5))", version, epoch);
-        assert_eq!(TypeSignature::type_of(&value), type_descr);
+        assert_eq!(TypeSignature::type_of(&value).unwrap(), type_descr);
     }
 
     #[apply(test_clarity_versions)]
@@ -2075,8 +2158,8 @@ mod test {
                 TypeSignature::BoolType,
             ),
             (
-                (TypeSignature::NoType, TypeSignature::min_buffer()),
-                TypeSignature::min_buffer(),
+                (TypeSignature::NoType, TypeSignature::min_buffer().unwrap()),
+                TypeSignature::min_buffer().unwrap(),
             ),
             (
                 (
@@ -2088,13 +2171,16 @@ mod test {
             (
                 (
                     TypeSignature::NoType,
-                    TypeSignature::bound_string_ascii_type(17),
+                    TypeSignature::bound_string_ascii_type(17).unwrap(),
                 ),
-                TypeSignature::bound_string_ascii_type(17),
+                TypeSignature::bound_string_ascii_type(17).unwrap(),
             ),
             (
-                (TypeSignature::NoType, TypeSignature::max_string_utf8()),
-                TypeSignature::max_string_utf8(),
+                (
+                    TypeSignature::NoType,
+                    TypeSignature::max_string_utf8().unwrap(),
+                ),
+                TypeSignature::max_string_utf8().unwrap(),
             ),
             (
                 (TypeSignature::NoType, TypeSignature::PrincipalType),
@@ -2175,8 +2261,11 @@ mod test {
             ((UIntType, UIntType), UIntType),
             ((BoolType, BoolType), BoolType),
             (
-                (TypeSignature::max_buffer(), TypeSignature::max_buffer()),
-                TypeSignature::max_buffer(),
+                (
+                    TypeSignature::max_buffer().unwrap(),
+                    TypeSignature::max_buffer().unwrap(),
+                ),
+                TypeSignature::max_buffer().unwrap(),
             ),
             (
                 (
@@ -2187,17 +2276,17 @@ mod test {
             ),
             (
                 (
-                    TypeSignature::bound_string_ascii_type(17),
-                    TypeSignature::bound_string_ascii_type(17),
+                    TypeSignature::bound_string_ascii_type(17).unwrap(),
+                    TypeSignature::bound_string_ascii_type(17).unwrap(),
                 ),
-                TypeSignature::bound_string_ascii_type(17),
+                TypeSignature::bound_string_ascii_type(17).unwrap(),
             ),
             (
                 (
-                    TypeSignature::max_string_utf8(),
-                    TypeSignature::max_string_utf8(),
+                    TypeSignature::max_string_utf8().unwrap(),
+                    TypeSignature::max_string_utf8().unwrap(),
                 ),
-                TypeSignature::max_string_utf8(),
+                TypeSignature::max_string_utf8().unwrap(),
             ),
             (
                 (TypeSignature::PrincipalType, TypeSignature::PrincipalType),
@@ -2281,8 +2370,11 @@ mod test {
 
         let matched_pairs = [
             (
-                (TypeSignature::max_buffer(), TypeSignature::min_buffer()),
-                TypeSignature::max_buffer(),
+                (
+                    TypeSignature::max_buffer().unwrap(),
+                    TypeSignature::min_buffer().unwrap(),
+                ),
+                TypeSignature::max_buffer().unwrap(),
             ),
             (
                 (
@@ -2293,17 +2385,17 @@ mod test {
             ),
             (
                 (
-                    TypeSignature::min_string_ascii(),
-                    TypeSignature::bound_string_ascii_type(17),
+                    TypeSignature::min_string_ascii().unwrap(),
+                    TypeSignature::bound_string_ascii_type(17).unwrap(),
                 ),
-                TypeSignature::bound_string_ascii_type(17),
+                TypeSignature::bound_string_ascii_type(17).unwrap(),
             ),
             (
                 (
-                    TypeSignature::min_string_utf8(),
-                    TypeSignature::max_string_utf8(),
+                    TypeSignature::min_string_utf8().unwrap(),
+                    TypeSignature::max_string_utf8().unwrap(),
                 ),
-                TypeSignature::max_string_utf8(),
+                TypeSignature::max_string_utf8().unwrap(),
             ),
             (
                 (
@@ -2356,7 +2448,7 @@ mod test {
                         5,
                     )
                     .unwrap(),
-                    TypeSignature::list_of(TypeSignature::min_buffer(), 3).unwrap(),
+                    TypeSignature::list_of(TypeSignature::min_buffer().unwrap(), 3).unwrap(),
                 ),
                 TypeSignature::list_of(
                     TypeSignature::SequenceType(SequenceSubtype::BufferType(
@@ -2371,14 +2463,14 @@ mod test {
                     TypeSignature::TupleType(
                         TupleTypeSignature::try_from(vec![(
                             "b".into(),
-                            TypeSignature::min_string_ascii(),
+                            TypeSignature::min_string_ascii().unwrap(),
                         )])
                         .unwrap(),
                     ),
                     TypeSignature::TupleType(
                         TupleTypeSignature::try_from(vec![(
                             "b".into(),
-                            TypeSignature::bound_string_ascii_type(17),
+                            TypeSignature::bound_string_ascii_type(17).unwrap(),
                         )])
                         .unwrap(),
                     ),
@@ -2386,17 +2478,19 @@ mod test {
                 TypeSignature::TupleType(
                     TupleTypeSignature::try_from(vec![(
                         "b".into(),
-                        TypeSignature::bound_string_ascii_type(17),
+                        TypeSignature::bound_string_ascii_type(17).unwrap(),
                     )])
                     .unwrap(),
                 ),
             ),
             (
                 (
-                    TypeSignature::new_option(TypeSignature::min_string_ascii()).unwrap(),
-                    TypeSignature::new_option(TypeSignature::bound_string_ascii_type(17)).unwrap(),
+                    TypeSignature::new_option(TypeSignature::min_string_ascii().unwrap()).unwrap(),
+                    TypeSignature::new_option(TypeSignature::bound_string_ascii_type(17).unwrap())
+                        .unwrap(),
                 ),
-                TypeSignature::new_option(TypeSignature::bound_string_ascii_type(17)).unwrap(),
+                TypeSignature::new_option(TypeSignature::bound_string_ascii_type(17).unwrap())
+                    .unwrap(),
             ),
             (
                 (
@@ -2433,20 +2527,20 @@ mod test {
             (IntType, UIntType),
             (BoolType, IntType),
             (
-                TypeSignature::max_buffer(),
-                TypeSignature::max_string_ascii(),
+                TypeSignature::max_buffer().unwrap(),
+                TypeSignature::max_string_ascii().unwrap(),
             ),
             (
                 TypeSignature::list_of(TypeSignature::UIntType, 42).unwrap(),
                 TypeSignature::list_of(TypeSignature::IntType, 42).unwrap(),
             ),
             (
-                TypeSignature::min_string_utf8(),
-                TypeSignature::bound_string_ascii_type(17),
+                TypeSignature::min_string_utf8().unwrap(),
+                TypeSignature::bound_string_ascii_type(17).unwrap(),
             ),
             (
-                TypeSignature::min_string_utf8(),
-                TypeSignature::min_buffer(),
+                TypeSignature::min_string_utf8().unwrap(),
+                TypeSignature::min_buffer().unwrap(),
             ),
             (
                 TypeSignature::TupleType(
@@ -2460,7 +2554,7 @@ mod test {
             ),
             (
                 TypeSignature::new_option(TypeSignature::IntType).unwrap(),
-                TypeSignature::new_option(TypeSignature::min_string_utf8()).unwrap(),
+                TypeSignature::new_option(TypeSignature::min_string_utf8().unwrap()).unwrap(),
             ),
             (
                 TypeSignature::new_response(TypeSignature::IntType, TypeSignature::BoolType)
@@ -2483,7 +2577,7 @@ mod test {
             ),
             (list_union.clone(), TypeSignature::PrincipalType),
             (
-                TypeSignature::min_string_ascii(),
+                TypeSignature::min_string_ascii().unwrap(),
                 list_union_principals.clone(),
             ),
             (
@@ -2494,13 +2588,13 @@ mod test {
                     5,
                 )
                 .unwrap(),
-                TypeSignature::list_of(TypeSignature::min_string_ascii(), 3).unwrap(),
+                TypeSignature::list_of(TypeSignature::min_string_ascii().unwrap(), 3).unwrap(),
             ),
             (
                 TypeSignature::TupleType(
                     TupleTypeSignature::try_from(vec![(
                         "b".into(),
-                        TypeSignature::min_string_ascii(),
+                        TypeSignature::min_string_ascii().unwrap(),
                     )])
                     .unwrap(),
                 ),
@@ -2510,8 +2604,8 @@ mod test {
                 ),
             ),
             (
-                TypeSignature::new_option(TypeSignature::min_string_ascii()).unwrap(),
-                TypeSignature::new_option(TypeSignature::min_string_utf8()).unwrap(),
+                TypeSignature::new_option(TypeSignature::min_string_ascii().unwrap()).unwrap(),
+                TypeSignature::new_option(TypeSignature::min_string_utf8().unwrap()).unwrap(),
             ),
             (
                 TypeSignature::new_response(TypeSignature::PrincipalType, list_union.clone())
diff --git a/clarity/src/vm/variables.rs b/clarity/src/vm/variables.rs
index ca5154b81b..baca2799de 100644
--- a/clarity/src/vm/variables.rs
+++ b/clarity/src/vm/variables.rs
@@ -24,6 +24,8 @@ use crate::vm::ClarityVersion;
 use crate::vm::costs::cost_functions::ClarityCostFunction;
 use crate::vm::costs::runtime_cost;
 
+use super::errors::InterpreterError;
+
 define_versioned_named_enum!(NativeVariables(ClarityVersion) {
     ContractCaller("contract-caller", ClarityVersion::Clarity1),
     TxSender("tx-sender", ClarityVersion::Clarity1),
@@ -84,8 +86,11 @@ pub fn lookup_reserved_variable(
             NativeVariables::TxSponsor => {
                 let sponsor = match env.sponsor.clone() {
                     None => Value::none(),
-                    Some(p) => Value::some(Value::Principal(p))
-                        .expect("ERROR: principal should be a valid Clarity object"),
+                    Some(p) => Value::some(Value::Principal(p)).map_err(|_| {
+                        InterpreterError::Expect(
+                            "ERROR: principal should be a valid Clarity object".into(),
+                        )
+                    })?,
                 };
                 Ok(Some(sponsor))
             }
@@ -99,15 +104,15 @@ pub fn lookup_reserved_variable(
                 let burn_block_height = env
                     .global_context
                     .database
-                    .get_current_burnchain_block_height();
-                Ok(Some(Value::UInt(burn_block_height as u128)))
+                    .get_current_burnchain_block_height()?;
+                Ok(Some(Value::UInt(u128::from(burn_block_height))))
             }
             NativeVariables::NativeNone => Ok(Some(Value::none())),
             NativeVariables::NativeTrue => Ok(Some(Value::Bool(true))),
             NativeVariables::NativeFalse => Ok(Some(Value::Bool(false))),
             NativeVariables::TotalLiquidMicroSTX => {
                 runtime_cost(ClarityCostFunction::FetchVar, env, 1)?;
-                let liq = env.global_context.database.get_total_liquid_ustx();
+                let liq = env.global_context.database.get_total_liquid_ustx()?;
                 Ok(Some(Value::UInt(liq)))
             }
             NativeVariables::Regtest => {
diff --git a/src/burnchains/burnchain.rs b/src/burnchains/burnchain.rs
index f90e05e4ee..dc0b75de61 100644
--- a/src/burnchains/burnchain.rs
+++ b/src/burnchains/burnchain.rs
@@ -316,7 +316,7 @@ impl BurnchainStateTransition {
 }
 
 impl BurnchainSigner {
-    #[cfg(any(test, feature = "testing"))]
+    #[cfg(test)]
     pub fn mock_parts(
         hash_mode: AddressHashMode,
         num_sigs: usize,
@@ -330,7 +330,7 @@ impl BurnchainSigner {
         BurnchainSigner(repr)
     }
 
-    #[cfg(any(test, feature = "testing"))]
+    #[cfg(test)]
     pub fn new_p2pkh(pubk: &StacksPublicKey) -> BurnchainSigner {
         BurnchainSigner::mock_parts(AddressHashMode::SerializeP2PKH, 1, vec![pubk.clone()])
     }
diff --git a/src/chainstate/coordinator/tests.rs b/src/chainstate/coordinator/tests.rs
index 4b59d9b347..d77b6af1df 100644
--- a/src/chainstate/coordinator/tests.rs
+++ b/src/chainstate/coordinator/tests.rs
@@ -632,7 +632,7 @@ fn make_genesis_block_with_recipients(
         .unwrap();
 
     let block = builder.mine_anchored_block(&mut epoch_tx);
-    builder.epoch_finish(epoch_tx);
+    builder.epoch_finish(epoch_tx).unwrap();
 
     let commit_outs = if let Some(recipients) = recipients {
         let mut commit_outs = recipients
@@ -891,7 +891,7 @@ fn make_stacks_block_with_input(
         .unwrap();
 
     let block = builder.mine_anchored_block(&mut epoch_tx);
-    builder.epoch_finish(epoch_tx);
+    builder.epoch_finish(epoch_tx).unwrap();
 
     let commit_outs = if let Some(recipients) = recipients {
         let mut commit_outs = recipients
@@ -2843,7 +2843,7 @@ fn test_pox_btc_ops() {
                     |conn| {
                         conn.with_clarity_db_readonly(|db| {
                             (
-                                db.get_account_stx_balance(&stacker.clone().into()),
+                                db.get_account_stx_balance(&stacker.clone().into()).unwrap(),
                                 db.get_current_block_height(),
                             )
                         })
@@ -2860,11 +2860,13 @@ fn test_pox_btc_ops() {
                 assert_eq!(stacker_balance.amount_locked(), stacked_amt);
             } else {
                 assert_eq!(
-                    stacker_balance.get_available_balance_at_burn_block(
-                        burn_height as u64,
-                        pox_v1_unlock_ht,
-                        pox_v2_unlock_ht
-                    ),
+                    stacker_balance
+                        .get_available_balance_at_burn_block(
+                            burn_height as u64,
+                            pox_v1_unlock_ht,
+                            pox_v2_unlock_ht
+                        )
+                        .unwrap(),
                     balance as u128,
                     "No lock should be active"
                 );
@@ -3140,7 +3142,7 @@ fn test_stx_transfer_btc_ops() {
                     |conn| {
                         conn.with_clarity_db_readonly(|db| {
                             (
-                                db.get_account_stx_balance(&stacker.clone().into()),
+                                db.get_account_stx_balance(&stacker.clone().into()).unwrap(),
                                 db.get_current_block_height(),
                             )
                         })
@@ -3155,7 +3157,8 @@ fn test_stx_transfer_btc_ops() {
                     |conn| {
                         conn.with_clarity_db_readonly(|db| {
                             (
-                                db.get_account_stx_balance(&recipient.clone().into()),
+                                db.get_account_stx_balance(&recipient.clone().into())
+                                    .unwrap(),
                                 db.get_current_block_height(),
                             )
                         })
@@ -3165,38 +3168,46 @@ fn test_stx_transfer_btc_ops() {
 
             if ix > 2 {
                 assert_eq!(
-                    sender_balance.get_available_balance_at_burn_block(
-                        burn_height as u64,
-                        pox_v1_unlock_ht,
-                        pox_v2_unlock_ht
-                    ),
+                    sender_balance
+                        .get_available_balance_at_burn_block(
+                            burn_height as u64,
+                            pox_v1_unlock_ht,
+                            pox_v2_unlock_ht
+                        )
+                        .unwrap(),
                     (balance as u128) - transfer_amt,
                     "Transfer should have decremented balance"
                 );
                 assert_eq!(
-                    recipient_balance.get_available_balance_at_burn_block(
-                        burn_height as u64,
-                        pox_v1_unlock_ht,
-                        pox_v2_unlock_ht
-                    ),
+                    recipient_balance
+                        .get_available_balance_at_burn_block(
+                            burn_height as u64,
+                            pox_v1_unlock_ht,
+                            pox_v2_unlock_ht
+                        )
+                        .unwrap(),
                     transfer_amt,
                     "Recipient should have incremented balance"
                 );
             } else {
                 assert_eq!(
-                    sender_balance.get_available_balance_at_burn_block(
-                        burn_height as u64,
-                        pox_v1_unlock_ht,
-                        pox_v2_unlock_ht
-                    ),
+                    sender_balance
+                        .get_available_balance_at_burn_block(
+                            burn_height as u64,
+                            pox_v1_unlock_ht,
+                            pox_v2_unlock_ht
+                        )
+                        .unwrap(),
                     balance as u128,
                 );
                 assert_eq!(
-                    recipient_balance.get_available_balance_at_burn_block(
-                        burn_height as u64,
-                        pox_v1_unlock_ht,
-                        pox_v2_unlock_ht
-                    ),
+                    recipient_balance
+                        .get_available_balance_at_burn_block(
+                            burn_height as u64,
+                            pox_v1_unlock_ht,
+                            pox_v2_unlock_ht
+                        )
+                        .unwrap(),
                     0,
                 );
             }
@@ -3311,14 +3322,24 @@ fn get_delegation_info_pox_2(
             .unwrap()
         })
         .unwrap()
-        .expect_optional();
+        .expect_optional()
+        .unwrap();
     match result {
         None => None,
         Some(tuple) => {
-            let data = tuple.expect_tuple().data_map;
-            let delegated_amt = data.get("amount-ustx").cloned().unwrap().expect_u128();
-            let reward_addr_opt = if let Some(reward_addr) =
-                data.get("pox-addr").cloned().unwrap().expect_optional()
+            let data = tuple.expect_tuple().unwrap().data_map;
+            let delegated_amt = data
+                .get("amount-ustx")
+                .cloned()
+                .unwrap()
+                .expect_u128()
+                .unwrap();
+            let reward_addr_opt = if let Some(reward_addr) = data
+                .get("pox-addr")
+                .cloned()
+                .unwrap()
+                .expect_optional()
+                .unwrap()
             {
                 Some(PoxAddress::try_from_pox_tuple(false, &reward_addr).unwrap())
             } else {
@@ -4522,7 +4543,7 @@ fn get_total_stacked_info(
                         reward_cycle
                     );
 
-                    let result = env.eval_raw(&eval_str).map(|v| v.expect_u128());
+                    let result = env.eval_raw(&eval_str).map(|v| v.expect_u128().unwrap());
                     Ok(result)
                 },
             )
diff --git a/src/chainstate/stacks/address.rs b/src/chainstate/stacks/address.rs
index 9f06783cb2..4ed4a1f88a 100644
--- a/src/chainstate/stacks/address.rs
+++ b/src/chainstate/stacks/address.rs
@@ -933,7 +933,9 @@ mod test {
             )
             .as_clarity_tuple()
             .unwrap(),
-            make_pox_addr_raw(0x00, vec![0x01; 20]).expect_tuple()
+            make_pox_addr_raw(0x00, vec![0x01; 20])
+                .expect_tuple()
+                .unwrap()
         );
         assert_eq!(
             PoxAddress::Standard(
@@ -945,7 +947,9 @@ mod test {
             )
             .as_clarity_tuple()
             .unwrap(),
-            make_pox_addr_raw(0x00, vec![0x02; 20]).expect_tuple()
+            make_pox_addr_raw(0x00, vec![0x02; 20])
+                .expect_tuple()
+                .unwrap()
         );
         assert!(PoxAddress::Standard(
             StacksAddress {
@@ -976,7 +980,9 @@ mod test {
             )
             .as_clarity_tuple()
             .unwrap(),
-            make_pox_addr_raw(0x01, vec![0x01; 20]).expect_tuple()
+            make_pox_addr_raw(0x01, vec![0x01; 20])
+                .expect_tuple()
+                .unwrap()
         );
         assert_eq!(
             PoxAddress::Standard(
@@ -988,7 +994,9 @@ mod test {
             )
             .as_clarity_tuple()
             .unwrap(),
-            make_pox_addr_raw(0x01, vec![0x02; 20]).expect_tuple()
+            make_pox_addr_raw(0x01, vec![0x02; 20])
+                .expect_tuple()
+                .unwrap()
         );
         assert!(PoxAddress::Standard(
             StacksAddress {
@@ -1019,7 +1027,9 @@ mod test {
             )
             .as_clarity_tuple()
             .unwrap(),
-            make_pox_addr_raw(0x02, vec![0x01; 20]).expect_tuple()
+            make_pox_addr_raw(0x02, vec![0x01; 20])
+                .expect_tuple()
+                .unwrap()
         );
         assert_eq!(
             PoxAddress::Standard(
@@ -1031,7 +1041,9 @@ mod test {
             )
             .as_clarity_tuple()
             .unwrap(),
-            make_pox_addr_raw(0x02, vec![0x02; 20]).expect_tuple()
+            make_pox_addr_raw(0x02, vec![0x02; 20])
+                .expect_tuple()
+                .unwrap()
         );
         assert!(PoxAddress::Standard(
             StacksAddress {
@@ -1062,7 +1074,9 @@ mod test {
             )
             .as_clarity_tuple()
             .unwrap(),
-            make_pox_addr_raw(0x03, vec![0x01; 20]).expect_tuple()
+            make_pox_addr_raw(0x03, vec![0x01; 20])
+                .expect_tuple()
+                .unwrap()
         );
         assert_eq!(
             PoxAddress::Standard(
@@ -1074,7 +1088,9 @@ mod test {
             )
             .as_clarity_tuple()
             .unwrap(),
-            make_pox_addr_raw(0x03, vec![0x02; 20]).expect_tuple()
+            make_pox_addr_raw(0x03, vec![0x02; 20])
+                .expect_tuple()
+                .unwrap()
         );
         assert!(PoxAddress::Standard(
             StacksAddress {
@@ -1099,39 +1115,51 @@ mod test {
             PoxAddress::Addr20(true, PoxAddressType20::P2WPKH, [0x09; 20])
                 .as_clarity_tuple()
                 .unwrap(),
-            make_pox_addr_raw(0x04, vec![0x09; 20]).expect_tuple()
+            make_pox_addr_raw(0x04, vec![0x09; 20])
+                .expect_tuple()
+                .unwrap()
         );
         assert_eq!(
             PoxAddress::Addr20(false, PoxAddressType20::P2WPKH, [0x09; 20])
                 .as_clarity_tuple()
                 .unwrap(),
-            make_pox_addr_raw(0x04, vec![0x09; 20]).expect_tuple()
+            make_pox_addr_raw(0x04, vec![0x09; 20])
+                .expect_tuple()
+                .unwrap()
         );
 
         assert_eq!(
             PoxAddress::Addr32(true, PoxAddressType32::P2WSH, [0x09; 32])
                 .as_clarity_tuple()
                 .unwrap(),
-            make_pox_addr_raw(0x05, vec![0x09; 32]).expect_tuple()
+            make_pox_addr_raw(0x05, vec![0x09; 32])
+                .expect_tuple()
+                .unwrap()
         );
         assert_eq!(
             PoxAddress::Addr32(false, PoxAddressType32::P2WSH, [0x09; 32])
                 .as_clarity_tuple()
                 .unwrap(),
-            make_pox_addr_raw(0x05, vec![0x09; 32]).expect_tuple()
+            make_pox_addr_raw(0x05, vec![0x09; 32])
+                .expect_tuple()
+                .unwrap()
         );
 
         assert_eq!(
             PoxAddress::Addr32(true, PoxAddressType32::P2TR, [0x09; 32])
                 .as_clarity_tuple()
                 .unwrap(),
-            make_pox_addr_raw(0x06, vec![0x09; 32]).expect_tuple()
+            make_pox_addr_raw(0x06, vec![0x09; 32])
+                .expect_tuple()
+                .unwrap()
         );
         assert_eq!(
             PoxAddress::Addr32(false, PoxAddressType32::P2TR, [0x09; 32])
                 .as_clarity_tuple()
                 .unwrap(),
-            make_pox_addr_raw(0x06, vec![0x09; 32]).expect_tuple()
+            make_pox_addr_raw(0x06, vec![0x09; 32])
+                .expect_tuple()
+                .unwrap()
         );
     }
 
diff --git a/src/chainstate/stacks/boot/contract_tests.rs b/src/chainstate/stacks/boot/contract_tests.rs
index 7a538ed14d..ce4024419d 100644
--- a/src/chainstate/stacks/boot/contract_tests.rs
+++ b/src/chainstate/stacks/boot/contract_tests.rs
@@ -226,7 +226,7 @@ impl ClarityTestSim {
     ) -> StacksEpochId {
         let mut clarity_db = store.as_clarity_db(headers_db, burn_db);
         clarity_db.begin();
-        let parent_epoch = clarity_db.get_clarity_epoch_version();
+        let parent_epoch = clarity_db.get_clarity_epoch_version().unwrap();
         let sortition_epoch = clarity_db
             .get_stacks_epoch(headers_db.height as u32)
             .unwrap()
@@ -234,10 +234,12 @@ impl ClarityTestSim {
 
         if parent_epoch != sortition_epoch {
             debug!("Set epoch to {}", &sortition_epoch);
-            clarity_db.set_clarity_epoch_version(sortition_epoch);
+            clarity_db
+                .set_clarity_epoch_version(sortition_epoch)
+                .unwrap();
         }
 
-        clarity_db.commit();
+        clarity_db.commit().unwrap();
         sortition_epoch
     }
 
@@ -722,7 +724,7 @@ fn pox_2_contract_caller_units() {
             "After revocation, stack-through still shouldn't be an allowed caller for User 1 in the PoX2 contract",
         );
 
-        let until_height = Value::UInt(burn_height.clone().expect_u128() + 1);
+        let until_height = Value::UInt(burn_height.clone().expect_u128().unwrap() + 1);
 
         assert_eq!(
             env.execute_transaction(
diff --git a/src/chainstate/stacks/boot/mod.rs b/src/chainstate/stacks/boot/mod.rs
index 8c195a5213..1063a01031 100644
--- a/src/chainstate/stacks/boot/mod.rs
+++ b/src/chainstate/stacks/boot/mod.rs
@@ -211,15 +211,22 @@ impl StacksChainState {
     ///  Stacks fork in the opened `clarity_db`.
     pub fn handled_pox_cycle_start(clarity_db: &mut ClarityDatabase, cycle_number: u64) -> bool {
         let db_key = Self::handled_pox_cycle_start_key(cycle_number);
-        match clarity_db.get::<String>(&db_key) {
+        match clarity_db
+            .get::<String>(&db_key)
+            .expect("FATAL: DB error when checking PoX cycle start")
+        {
             Some(x) => x == POX_CYCLE_START_HANDLED_VALUE,
             None => false,
         }
     }
 
-    fn mark_pox_cycle_handled(db: &mut ClarityDatabase, cycle_number: u64) {
+    fn mark_pox_cycle_handled(
+        db: &mut ClarityDatabase,
+        cycle_number: u64,
+    ) -> Result<(), clarity::vm::errors::Error> {
         let db_key = Self::handled_pox_cycle_start_key(cycle_number);
-        db.put(&db_key, &POX_CYCLE_START_HANDLED_VALUE.to_string());
+        db.put(&db_key, &POX_CYCLE_START_HANDLED_VALUE.to_string())?;
+        Ok(())
     }
 
     /// Get the stacking state for a user, before deleting it as part of an unlock
@@ -254,7 +261,9 @@ impl StacksChainState {
                 })
                 .expect("FATAL: failed to query unlocked principal");
 
-        user_stacking_state.expect_tuple()
+        user_stacking_state
+            .expect_tuple()
+            .expect("FATAL: unexpected PoX structure")
     }
 
     /// Synthesize the handle-unlock print event.  This is done here, instead of pox-2, so we can
@@ -360,7 +369,7 @@ impl StacksChainState {
         cycle_info: Option<PoxStartCycleInfo>,
         pox_contract_name: &str,
     ) -> Result<Vec<StacksTransactionEvent>, Error> {
-        clarity.with_clarity_db(|db| Ok(Self::mark_pox_cycle_handled(db, cycle_number)))?;
+        clarity.with_clarity_db(|db| Ok(Self::mark_pox_cycle_handled(db, cycle_number)))??;
 
         debug!(
             "Handling PoX reward cycle start";
@@ -389,13 +398,14 @@ impl StacksChainState {
             // 4. delete the user's stacking-state entry.
             clarity.with_clarity_db(|db| {
                 // lookup the Stacks account and alter their unlock height to next block
-                let mut balance = db.get_stx_balance_snapshot(&principal);
-                if balance.canonical_balance_repr().amount_locked() < *amount_locked {
-                    panic!("Principal missed reward slots, but did not have as many locked tokens as expected. Actual: {}, Expected: {}", balance.canonical_balance_repr().amount_locked(), *amount_locked);
+                let mut balance = db.get_stx_balance_snapshot(&principal)?;
+                let canonical_locked = balance.canonical_balance_repr()?.amount_locked();
+                if canonical_locked < *amount_locked {
+                    panic!("Principal missed reward slots, but did not have as many locked tokens as expected. Actual: {}, Expected: {}", canonical_locked, *amount_locked);
                 }
 
-                balance.accelerate_unlock();
-                balance.save();
+                balance.accelerate_unlock()?;
+                balance.save()?;
                 Ok(())
             }).expect("FATAL: failed to accelerate PoX unlock");
 
@@ -426,7 +436,9 @@ impl StacksChainState {
                 .expect("FATAL: failed to handle PoX unlock");
 
             // this must be infallible
-            result.expect_result_ok();
+            result
+                .expect_result_ok()
+                .expect("FATAL: unexpected PoX structure");
 
             // extract metadata about the unlock
             let event_info =
@@ -469,9 +481,11 @@ impl StacksChainState {
             &NULL_HEADER_DB,
             &NULL_BURN_STATE_DB,
         );
-        connection.with_clarity_db_readonly_owned(|mut clarity_db| {
-            (clarity_db.get_total_liquid_ustx(), clarity_db)
-        })
+        connection
+            .with_clarity_db_readonly_owned(|mut clarity_db| {
+                (clarity_db.get_total_liquid_ustx(), clarity_db)
+            })
+            .expect("FATAL: failed to get total liquid ustx")
     }
 
     /// Determine the minimum amount of STX per reward address required to stack in the _next_
@@ -488,7 +502,11 @@ impl StacksChainState {
             "pox",
             &format!("(get-stacking-minimum)"),
         )
-        .map(|value| value.expect_u128())
+        .map(|value| {
+            value
+                .expect_u128()
+                .expect("FATAL: unexpected PoX structure")
+        })
     }
 
     pub fn get_total_ustx_stacked(
@@ -524,7 +542,8 @@ impl StacksChainState {
                 )
             })?
             .ok_or_else(|| Error::NoSuchBlockError)??
-            .expect_u128();
+            .expect_u128()
+            .expect("FATAL: unexpected PoX structure");
         Ok(result)
     }
 
@@ -542,7 +561,11 @@ impl StacksChainState {
             "pox",
             &format!("(get-total-ustx-stacked u{})", reward_cycle),
         )
-        .map(|value| value.expect_u128())
+        .map(|value| {
+            value
+                .expect_u128()
+                .expect("FATAL: unexpected PoX structure")
+        })
     }
 
     /// Is PoX active in the given reward cycle?
@@ -559,7 +582,11 @@ impl StacksChainState {
             pox_contract,
             &format!("(is-pox-active u{})", reward_cycle),
         )
-        .map(|value| value.expect_bool())
+        .map(|value| {
+            value
+                .expect_bool()
+                .expect("FATAL: unexpected PoX structure")
+        })
     }
 
     /// Given a threshold and set of registered addresses, return a reward set where
@@ -736,7 +763,8 @@ impl StacksChainState {
                 POX_1_NAME,
                 &format!("(get-reward-set-size u{})", reward_cycle),
             )?
-            .expect_u128();
+            .expect_u128()
+            .expect("FATAL: unexpected PoX structure");
 
         debug!(
             "At block {:?} (reward cycle {}): {} PoX reward addresses",
@@ -755,11 +783,13 @@ impl StacksChainState {
                     &format!("(get-reward-set-pox-address u{} u{})", reward_cycle, i),
                 )?
                 .expect_optional()
+                .expect("FATAL: unexpected PoX structure")
                 .expect(&format!(
                     "FATAL: missing PoX address in slot {} out of {} in reward cycle {}",
                     i, num_addrs, reward_cycle
                 ))
-                .expect_tuple();
+                .expect_tuple()
+                .expect("FATAL: unexpected PoX structure");
 
             let pox_addr_tuple = tuple_data
                 .get("pox-addr")
@@ -776,7 +806,8 @@ impl StacksChainState {
                 .get("total-ustx")
                 .expect(&format!("FATAL: no 'total-ustx' in return value from (get-reward-set-pox-address u{} u{})", reward_cycle, i))
                 .to_owned()
-                .expect_u128();
+                .expect_u128()                .expect("FATAL: unexpected PoX structure")
+;
 
             debug!(
                 "PoX reward address (for {} ustx): {}",
@@ -814,7 +845,8 @@ impl StacksChainState {
                 POX_2_NAME,
                 &format!("(get-reward-set-size u{})", reward_cycle),
             )?
-            .expect_u128();
+            .expect_u128()
+            .expect("FATAL: unexpected PoX structure");
 
         debug!(
             "At block {:?} (reward cycle {}): {} PoX reward addresses",
@@ -832,11 +864,13 @@ impl StacksChainState {
                     &format!("(get-reward-set-pox-address u{} u{})", reward_cycle, i),
                 )?
                 .expect_optional()
+                .expect("FATAL: unexpected PoX structure")
                 .expect(&format!(
                     "FATAL: missing PoX address in slot {} out of {} in reward cycle {}",
                     i, num_addrs, reward_cycle
                 ))
-                .expect_tuple();
+                .expect_tuple()
+                .expect("FATAL: unexpected PoX structure");
 
             let pox_addr_tuple = tuple
                 .get("pox-addr")
@@ -853,7 +887,8 @@ impl StacksChainState {
                 .get("total-ustx")
                 .expect(&format!("FATAL: no 'total-ustx' in return value from (get-reward-set-pox-address u{} u{})", reward_cycle, i))
                 .to_owned()
-                .expect_u128();
+                .expect_u128()                .expect("FATAL: unexpected PoX structure")
+;
 
             let stacker = tuple
                 .get("stacker")
@@ -863,7 +898,12 @@ impl StacksChainState {
                 ))
                 .to_owned()
                 .expect_optional()
-                .map(|value| value.expect_principal());
+                .expect("FATAL: unexpected PoX structure")
+                .map(|value| {
+                    value
+                        .expect_principal()
+                        .expect("FATAL: unexpected PoX structure")
+                });
 
             debug!(
                 "Parsed PoX reward address";
@@ -903,7 +943,8 @@ impl StacksChainState {
                 POX_3_NAME,
                 &format!("(get-reward-set-size u{})", reward_cycle),
             )?
-            .expect_u128();
+            .expect_u128()
+            .expect("FATAL: unexpected PoX structure");
 
         debug!(
             "At block {:?} (reward cycle {}): {} PoX reward addresses",
@@ -921,11 +962,13 @@ impl StacksChainState {
                     &format!("(get-reward-set-pox-address u{} u{})", reward_cycle, i),
                 )?
                 .expect_optional()
+                .expect("FATAL: unexpected PoX structure")
                 .expect(&format!(
                     "FATAL: missing PoX address in slot {} out of {} in reward cycle {}",
                     i, num_addrs, reward_cycle
                 ))
-                .expect_tuple();
+                .expect_tuple()
+                .expect("FATAL: unexpected PoX structure");
 
             let pox_addr_tuple = tuple
                 .get("pox-addr")
@@ -942,7 +985,8 @@ impl StacksChainState {
                 .get("total-ustx")
                 .expect(&format!("FATAL: no 'total-ustx' in return value from (get-reward-set-pox-address u{} u{})", reward_cycle, i))
                 .to_owned()
-                .expect_u128();
+                .expect_u128()
+                .expect("FATAL: unexpected PoX structure");
 
             let stacker = tuple
                 .get("stacker")
@@ -952,7 +996,12 @@ impl StacksChainState {
                 ))
                 .to_owned()
                 .expect_optional()
-                .map(|value| value.expect_principal());
+                .expect("FATAL: unexpected PoX structure")
+                .map(|value| {
+                    value
+                        .expect_principal()
+                        .expect("FATAL: unexpected PoX structure")
+                });
 
             debug!(
                 "Parsed PoX reward address";
@@ -1375,22 +1424,39 @@ pub mod test {
             "pox",
             &format!("(get-stacker-info '{})", addr.to_string()),
         );
-        let data = if let Some(d) = value_opt.expect_optional() {
+        let data = if let Some(d) = value_opt.expect_optional().unwrap() {
             d
         } else {
             return None;
         };
 
-        let data = data.expect_tuple();
+        let data = data.expect_tuple().unwrap();
 
-        let amount_ustx = data.get("amount-ustx").unwrap().to_owned().expect_u128();
-        let pox_addr = tuple_to_pox_addr(data.get("pox-addr").unwrap().to_owned().expect_tuple());
-        let lock_period = data.get("lock-period").unwrap().to_owned().expect_u128();
+        let amount_ustx = data
+            .get("amount-ustx")
+            .unwrap()
+            .to_owned()
+            .expect_u128()
+            .unwrap();
+        let pox_addr = tuple_to_pox_addr(
+            data.get("pox-addr")
+                .unwrap()
+                .to_owned()
+                .expect_tuple()
+                .unwrap(),
+        );
+        let lock_period = data
+            .get("lock-period")
+            .unwrap()
+            .to_owned()
+            .expect_u128()
+            .unwrap();
         let first_reward_cycle = data
             .get("first-reward-cycle")
             .unwrap()
             .to_owned()
-            .expect_u128();
+            .expect_u128()
+            .unwrap();
         Some((amount_ustx, pox_addr, lock_period, first_reward_cycle))
     }
 
@@ -3420,9 +3486,9 @@ pub mod test {
                     "(var-get test-run)",
                 );
 
-                assert!(alice_test_result.expect_bool());
-                assert!(bob_test_result.expect_bool());
-                assert!(charlie_test_result.expect_bool());
+                assert!(alice_test_result.expect_bool().unwrap());
+                assert!(bob_test_result.expect_bool().unwrap());
+                assert!(charlie_test_result.expect_bool().unwrap());
 
                 let alice_test_result = eval_contract_at_tip(
                     &mut peer,
@@ -4854,7 +4920,8 @@ pub mod test {
                         "charlie-try-stack",
                         "(var-get test-passed)",
                     )
-                    .expect_bool();
+                    .expect_bool()
+                    .unwrap();
                     assert!(result, "charlie-try-stack test should be `true`");
                     let result = eval_contract_at_tip(
                         &mut peer,
@@ -4862,7 +4929,8 @@ pub mod test {
                         "charlie-try-reject",
                         "(var-get test-passed)",
                     )
-                    .expect_bool();
+                    .expect_bool()
+                    .unwrap();
                     assert!(result, "charlie-try-reject test should be `true`");
                     let result = eval_contract_at_tip(
                         &mut peer,
@@ -4870,7 +4938,8 @@ pub mod test {
                         "alice-try-reject",
                         "(var-get test-passed)",
                     )
-                    .expect_bool();
+                    .expect_bool()
+                    .unwrap();
                     assert!(result, "alice-try-reject test should be `true`");
                 }
 
diff --git a/src/chainstate/stacks/boot/pox_2_tests.rs b/src/chainstate/stacks/boot/pox_2_tests.rs
index 61f8467309..f96210be81 100644
--- a/src/chainstate/stacks/boot/pox_2_tests.rs
+++ b/src/chainstate/stacks/boot/pox_2_tests.rs
@@ -106,7 +106,9 @@ pub fn get_stx_account_at(
 ) -> STXBalance {
     with_clarity_db_ro(peer, tip, |db| {
         db.get_stx_balance_snapshot(account)
+            .unwrap()
             .canonical_balance_repr()
+            .unwrap()
     })
 }
 
@@ -121,7 +123,7 @@ pub fn get_stacking_state_pox(
         let lookup_tuple = Value::Tuple(
             TupleData::from_data(vec![("stacker".into(), account.clone().into())]).unwrap(),
         );
-        let epoch = db.get_clarity_epoch_version();
+        let epoch = db.get_clarity_epoch_version().unwrap();
         db.fetch_entry_unknown_descriptor(
             &boot_code_id(pox_contract, false),
             "stacking-state",
@@ -130,6 +132,7 @@ pub fn get_stacking_state_pox(
         )
         .unwrap()
         .expect_optional()
+        .unwrap()
     })
 }
 
@@ -150,7 +153,7 @@ pub fn check_all_stacker_link_invariants(
     max_cycle_number: u64,
 ) {
     // if PoX-2 hasn't published yet, just return.
-    let epoch = with_clarity_db_ro(peer, tip, |db| db.get_clarity_epoch_version());
+    let epoch = with_clarity_db_ro(peer, tip, |db| db.get_clarity_epoch_version()).unwrap();
     if epoch < StacksEpochId::Epoch21 {
         eprintln!("Skipping invariant checks when PoX-2 has not published yet");
         return;
@@ -214,7 +217,14 @@ pub fn check_pox_print_event(
             data
         );
         assert_eq!(data.key.1, "print");
-        let outer_tuple = data.value.clone().expect_result().unwrap().expect_tuple();
+        let outer_tuple = data
+            .value
+            .clone()
+            .expect_result()
+            .unwrap()
+            .unwrap()
+            .expect_tuple()
+            .unwrap();
         test_debug!(
             "Check name: {:?} =?= {:?}",
             &outer_tuple
@@ -222,7 +232,8 @@ pub fn check_pox_print_event(
                 .get("name")
                 .unwrap()
                 .clone()
-                .expect_ascii(),
+                .expect_ascii()
+                .unwrap(),
             common_data.op_name
         );
         assert_eq!(
@@ -231,7 +242,8 @@ pub fn check_pox_print_event(
                 .get("name")
                 .unwrap()
                 .clone()
-                .expect_ascii(),
+                .expect_ascii()
+                .unwrap(),
             common_data.op_name
         );
         assert_eq!(
@@ -255,7 +267,7 @@ pub fn check_pox_print_event(
             .data_map
             .get("data")
             .expect("The event tuple should have a field named `data`");
-        let inner_tuple = args.clone().expect_tuple();
+        let inner_tuple = args.clone().expect_tuple().unwrap();
 
         test_debug!("Check for ops {:?}", &op_data);
         test_debug!("Inner tuple is {:?}", &inner_tuple);
@@ -308,7 +320,9 @@ pub fn check_stacking_state_invariants(
 ) -> StackingStateCheckData {
     let account_state = with_clarity_db_ro(peer, tip, |db| {
         db.get_stx_balance_snapshot(stacker)
+            .unwrap()
             .canonical_balance_repr()
+            .unwrap()
     });
 
     let tip_burn_height = StacksChainState::get_stacks_block_header_info_by_index_block_hash(
@@ -324,17 +338,19 @@ pub fn check_stacking_state_invariants(
             "Invariant violated: reward-cycle entry has stacker field set, but not present in stacker-state (pox_contract = {})",
             active_pox_contract,
         ))
-        .expect_tuple();
+        .expect_tuple().unwrap();
     let first_cycle = stacking_state_entry
         .get("first-reward-cycle")
         .unwrap()
         .clone()
-        .expect_u128();
+        .expect_u128()
+        .unwrap();
     let lock_period = stacking_state_entry
         .get("lock-period")
         .unwrap()
         .clone()
-        .expect_u128();
+        .expect_u128()
+        .unwrap();
     let pox_addr = stacking_state_entry.get("pox-addr").unwrap();
     let pox_addr = PoxAddress::try_from_pox_tuple(false, pox_addr).unwrap();
 
@@ -342,8 +358,9 @@ pub fn check_stacking_state_invariants(
         .get_owned("reward-set-indexes")
         .unwrap()
         .expect_list()
+        .unwrap()
         .into_iter()
-        .map(|x| x.expect_u128())
+        .map(|x| x.expect_u128().unwrap())
         .collect();
 
     let stacking_state_unlock_ht = peer
@@ -380,7 +397,7 @@ pub fn check_stacking_state_invariants(
                 .unwrap(),
             );
             let entry_value = with_clarity_db_ro(peer, tip, |db| {
-                let epoch = db.get_clarity_epoch_version();
+                let epoch = db.get_clarity_epoch_version().unwrap();
                 db.fetch_entry_unknown_descriptor(
                     &boot_code_id(active_pox_contract, false),
                     "reward-cycle-pox-address-list",
@@ -388,17 +405,17 @@ pub fn check_stacking_state_invariants(
                     &epoch,
                 )
                     .unwrap()
-                    .expect_optional()
+                    .expect_optional().unwrap()
                     .expect("Invariant violated: stacking-state.reward-set-indexes pointed at a non-existent entry")
-                    .expect_tuple()
+                    .expect_tuple().unwrap()
             });
 
             let entry_stacker = entry_value.get("stacker")
                 .unwrap()
                 .clone()
-                .expect_optional()
+                .expect_optional().unwrap()
                 .expect("Invariant violated: stacking-state.reward-set-indexes pointed at an entry without a stacker set")
-                .expect_principal();
+                .expect_principal().unwrap();
 
             assert_eq!(
                 &entry_stacker, stacker,
@@ -564,7 +581,7 @@ pub fn get_reward_cycle_total(peer: &mut TestPeer, tip: &StacksBlockId, cycle_nu
         )])
         .unwrap()
         .into();
-        let epoch = db.get_clarity_epoch_version();
+        let epoch = db.get_clarity_epoch_version().unwrap();
         db.fetch_entry_unknown_descriptor(
             &boot_code_id(active_pox_contract, false),
             "reward-cycle-total-stacked",
@@ -573,11 +590,14 @@ pub fn get_reward_cycle_total(peer: &mut TestPeer, tip: &StacksBlockId, cycle_nu
         )
         .map(|v| {
             v.expect_optional()
+                .unwrap()
                 .map(|v| {
                     v.expect_tuple()
+                        .unwrap()
                         .get_owned("total-ustx")
                         .expect("Malformed tuple returned by PoX contract")
                         .expect_u128()
+                        .unwrap()
                 })
                 // if no entry yet, return 0
                 .unwrap_or(0)
@@ -604,7 +624,7 @@ pub fn get_partial_stacked(
         ])
         .unwrap()
         .into();
-        let epoch = db.get_clarity_epoch_version();
+        let epoch = db.get_clarity_epoch_version().unwrap();
         db.fetch_entry_unknown_descriptor(
             &boot_code_id(pox_contract, false),
             "partial-stacked-by-cycle",
@@ -613,13 +633,16 @@ pub fn get_partial_stacked(
         )
         .map(|v| {
             v.expect_optional()
+                .unwrap()
                 .expect("Expected fetch_entry to return a value")
         })
         .unwrap()
         .expect_tuple()
+        .unwrap()
         .get_owned("stacked-amount")
         .expect("Malformed tuple returned by PoX contract")
         .expect_u128()
+        .unwrap()
     })
 }
 
@@ -1237,7 +1260,8 @@ fn test_simple_pox_2_auto_unlock(alice_first: bool) {
         height_target + 1,
         burnchain.pox_constants.v1_unlock_height,
         burnchain.pox_constants.v2_unlock_height,
-    );
+    )
+    .unwrap();
     assert_eq!(bob_bal.amount_locked(), POX_THRESHOLD_STEPS_USTX);
 
     while get_tip(peer.sortdb.as_ref()).block_height < height_target {
@@ -1266,7 +1290,8 @@ fn test_simple_pox_2_auto_unlock(alice_first: bool) {
         height_target + 1,
         burnchain.pox_constants.v1_unlock_height,
         burnchain.pox_constants.v2_unlock_height,
-    );
+    )
+    .unwrap();
     assert_eq!(bob_bal.amount_locked(), 0);
 
     // but bob's still locked at (height_target): the unlock is accelerated to the "next" burn block
@@ -1279,7 +1304,8 @@ fn test_simple_pox_2_auto_unlock(alice_first: bool) {
         height_target + 1,
         burnchain.pox_constants.v1_unlock_height,
         burnchain.pox_constants.v2_unlock_height,
-    );
+    )
+    .unwrap();
     assert_eq!(bob_bal.amount_locked(), 0);
 
     // check that the total reward cycle amounts have decremented correctly
@@ -1307,7 +1333,8 @@ fn test_simple_pox_2_auto_unlock(alice_first: bool) {
         &key_to_stacks_addr(&alice).to_account_principal(),
     )
     .expect("Alice should have stacking-state entry")
-    .expect_tuple();
+    .expect_tuple()
+    .unwrap();
     let reward_indexes_str = format!("{}", alice_state.get("reward-set-indexes").unwrap());
     assert_eq!(reward_indexes_str, "(u0 u0 u0 u0 u0 u0)");
 
@@ -1849,7 +1876,9 @@ fn stack_increase() {
     );
 
     assert_eq!(
-        get_stx_account_at(&mut peer, &latest_block, &alice_principal).get_total_balance(),
+        get_stx_account_at(&mut peer, &latest_block, &alice_principal)
+            .get_total_balance()
+            .unwrap(),
         total_balance,
     );
 
@@ -1908,7 +1937,9 @@ fn stack_increase() {
     );
 
     assert_eq!(
-        get_stx_account_at(&mut peer, &latest_block, &alice_principal).get_total_balance(),
+        get_stx_account_at(&mut peer, &latest_block, &alice_principal)
+            .get_total_balance()
+            .unwrap(),
         total_balance,
     );
 
@@ -3552,13 +3583,14 @@ fn test_pox_2_getters() {
     ));
 
     eprintln!("{}", &result);
-    let data = result.expect_tuple().data_map;
+    let data = result.expect_tuple().unwrap().data_map;
 
     let alice_delegation_info = data
         .get("get-delegation-info-alice")
         .cloned()
         .unwrap()
-        .expect_optional();
+        .expect_optional()
+        .unwrap();
     assert!(alice_delegation_info.is_none());
 
     let bob_delegation_info = data
@@ -3567,23 +3599,28 @@ fn test_pox_2_getters() {
         .unwrap()
         .expect_optional()
         .unwrap()
+        .unwrap()
         .expect_tuple()
+        .unwrap()
         .data_map;
     let bob_delegation_addr = bob_delegation_info
         .get("delegated-to")
         .cloned()
         .unwrap()
-        .expect_principal();
+        .expect_principal()
+        .unwrap();
     let bob_delegation_amt = bob_delegation_info
         .get("amount-ustx")
         .cloned()
         .unwrap()
-        .expect_u128();
+        .expect_u128()
+        .unwrap();
     let bob_pox_addr_opt = bob_delegation_info
         .get("pox-addr")
         .cloned()
         .unwrap()
-        .expect_optional();
+        .expect_optional()
+        .unwrap();
     assert_eq!(bob_delegation_addr, charlie_address.to_account_principal());
     assert_eq!(bob_delegation_amt, LOCKUP_AMT as u128);
     assert!(bob_pox_addr_opt.is_none());
@@ -3592,27 +3629,30 @@ fn test_pox_2_getters() {
         .get("get-allowance-contract-callers")
         .cloned()
         .unwrap()
-        .expect_optional();
+        .expect_optional()
+        .unwrap();
     assert!(allowance.is_none());
 
     let current_num_reward_addrs = data
         .get("get-num-reward-set-pox-addresses-current")
         .cloned()
         .unwrap()
-        .expect_u128();
+        .expect_u128()
+        .unwrap();
     assert_eq!(current_num_reward_addrs, 2);
 
     let future_num_reward_addrs = data
         .get("get-num-reward-set-pox-addresses-future")
         .cloned()
         .unwrap()
-        .expect_u128();
+        .expect_u128()
+        .unwrap();
     assert_eq!(future_num_reward_addrs, 0);
 
     for i in 0..3 {
         let key =
             ClarityName::try_from(format!("get-partial-stacked-by-cycle-bob-{}", &i)).unwrap();
-        let partial_stacked = data.get(&key).cloned().unwrap().expect_optional();
+        let partial_stacked = data.get(&key).cloned().unwrap().expect_optional().unwrap();
         assert!(partial_stacked.is_none());
     }
     let partial_stacked = data
@@ -3621,33 +3661,39 @@ fn test_pox_2_getters() {
         .unwrap()
         .expect_optional()
         .unwrap()
+        .unwrap()
         .expect_tuple()
+        .unwrap()
         .data_map
         .get("stacked-amount")
         .cloned()
         .unwrap()
-        .expect_u128();
+        .expect_u128()
+        .unwrap();
     assert_eq!(partial_stacked, LOCKUP_AMT as u128);
 
     let rejected = data
         .get("get-total-pox-rejection-now")
         .cloned()
         .unwrap()
-        .expect_u128();
+        .expect_u128()
+        .unwrap();
     assert_eq!(rejected, 0);
 
     let rejected = data
         .get("get-total-pox-rejection-next")
         .cloned()
         .unwrap()
-        .expect_u128();
+        .expect_u128()
+        .unwrap();
     assert_eq!(rejected, LOCKUP_AMT as u128);
 
     let rejected = data
         .get("get-total-pox-rejection-future")
         .cloned()
         .unwrap()
-        .expect_u128();
+        .expect_u128()
+        .unwrap();
     assert_eq!(rejected, 0);
 }
 
@@ -3870,8 +3916,10 @@ fn test_get_pox_addrs() {
             })
             .unwrap()
             .expect_optional()
+            .unwrap()
             .expect("FATAL: expected list")
-            .expect_tuple();
+            .expect_tuple()
+            .unwrap();
 
             eprintln!(
                 "At block height {}: {:?}",
@@ -3883,13 +3931,15 @@ fn test_get_pox_addrs() {
                 .get("addrs")
                 .unwrap()
                 .to_owned()
-                .expect_list();
+                .expect_list()
+                .unwrap();
 
             let payout = addrs_and_payout
                 .get("payout")
                 .unwrap()
                 .to_owned()
-                .expect_u128();
+                .expect_u128()
+                .unwrap();
 
             // there's always some burnchain tokens spent.
             assert!(payout > 0);
@@ -4163,8 +4213,10 @@ fn test_stack_with_segwit() {
             })
             .unwrap()
             .expect_optional()
+            .unwrap()
             .expect("FATAL: expected list")
-            .expect_tuple();
+            .expect_tuple()
+            .unwrap();
 
             eprintln!(
                 "At block height {}: {:?}",
@@ -4176,13 +4228,15 @@ fn test_stack_with_segwit() {
                 .get("addrs")
                 .unwrap()
                 .to_owned()
-                .expect_list();
+                .expect_list()
+                .unwrap();
 
             let payout = addrs_and_payout
                 .get("payout")
                 .unwrap()
                 .to_owned()
-                .expect_u128();
+                .expect_u128()
+                .unwrap();
 
             // there's always some burnchain tokens spent.
             assert!(payout > 0);
@@ -4354,14 +4408,15 @@ fn test_pox_2_delegate_stx_addr_validation() {
     );
 
     eprintln!("{}", &result);
-    let data = result.expect_tuple().data_map;
+    let data = result.expect_tuple().unwrap().data_map;
 
     // bob had an invalid PoX address
     let bob_delegation_info = data
         .get("get-delegation-info-bob")
         .cloned()
         .unwrap()
-        .expect_optional();
+        .expect_optional()
+        .unwrap();
     assert!(bob_delegation_info.is_none());
 
     // alice was valid
@@ -4371,23 +4426,28 @@ fn test_pox_2_delegate_stx_addr_validation() {
         .unwrap()
         .expect_optional()
         .unwrap()
+        .unwrap()
         .expect_tuple()
+        .unwrap()
         .data_map;
     let alice_delegation_addr = alice_delegation_info
         .get("delegated-to")
         .cloned()
         .unwrap()
-        .expect_principal();
+        .expect_principal()
+        .unwrap();
     let alice_delegation_amt = alice_delegation_info
         .get("amount-ustx")
         .cloned()
         .unwrap()
-        .expect_u128();
+        .expect_u128()
+        .unwrap();
     let alice_pox_addr_opt = alice_delegation_info
         .get("pox-addr")
         .cloned()
         .unwrap()
-        .expect_optional();
+        .expect_optional()
+        .unwrap();
     assert_eq!(
         alice_delegation_addr,
         charlie_address.to_account_principal()
@@ -5004,14 +5064,33 @@ fn stack_in_both_pox1_and_pox2() {
     }
 
     // alice's and bob's second transactions both failed with runtime errors
-    alice_txs.get(&0).unwrap().result.clone().expect_result_ok();
+    alice_txs
+        .get(&0)
+        .unwrap()
+        .result
+        .clone()
+        .expect_result_ok()
+        .unwrap();
     alice_txs
         .get(&1)
         .unwrap()
         .result
         .clone()
-        .expect_result_err();
+        .expect_result_err()
+        .unwrap();
 
-    bob_txs.get(&0).unwrap().result.clone().expect_result_ok();
-    bob_txs.get(&1).unwrap().result.clone().expect_result_err();
+    bob_txs
+        .get(&0)
+        .unwrap()
+        .result
+        .clone()
+        .expect_result_ok()
+        .unwrap();
+    bob_txs
+        .get(&1)
+        .unwrap()
+        .result
+        .clone()
+        .expect_result_err()
+        .unwrap();
 }
diff --git a/src/chainstate/stacks/boot/pox_3_tests.rs b/src/chainstate/stacks/boot/pox_3_tests.rs
index adefc7ee01..8e04b3f80a 100644
--- a/src/chainstate/stacks/boot/pox_3_tests.rs
+++ b/src/chainstate/stacks/boot/pox_3_tests.rs
@@ -751,7 +751,8 @@ fn pox_auto_unlock(alice_first: bool) {
         &key_to_stacks_addr(&alice).to_account_principal(),
     )
     .expect("Alice should have stacking-state entry")
-    .expect_tuple();
+    .expect_tuple()
+    .unwrap();
     let reward_indexes_str = format!("{}", alice_state.get("reward-set-indexes").unwrap());
     assert_eq!(reward_indexes_str, "(u0 u0 u0 u0 u0 u0)");
 
@@ -890,7 +891,8 @@ fn pox_auto_unlock(alice_first: bool) {
         POX_3_NAME,
     )
     .expect("Alice should have stacking-state entry")
-    .expect_tuple();
+    .expect_tuple()
+    .unwrap();
     let reward_indexes_str = format!("{}", alice_state.get("reward-set-indexes").unwrap());
     assert_eq!(reward_indexes_str, "(u0 u0 u0 u0 u0 u0)");
 
@@ -1696,7 +1698,7 @@ fn stack_increase() {
     let alice_bal = get_stx_account_at(&mut peer, &latest_block, &alice_principal);
     assert_eq!(alice_bal.amount_locked(), first_lockup_amt);
     assert_eq!(alice_bal.unlock_height(), expected_pox_2_unlock_ht);
-    assert_eq!(alice_bal.get_total_balance(), total_balance,);
+    assert_eq!(alice_bal.get_total_balance().unwrap(), total_balance,);
 
     // check that the "raw" reward set will contain entries for alice at the cycle start
     for cycle_number in EXPECTED_FIRST_V2_CYCLE..first_v3_cycle {
@@ -1750,7 +1752,7 @@ fn stack_increase() {
     let alice_bal = get_stx_account_at(&mut peer, &latest_block, &alice_principal);
     assert_eq!(alice_bal.amount_locked(), first_lockup_amt + increase_amt,);
     assert_eq!(alice_bal.unlock_height(), expected_pox_2_unlock_ht);
-    assert_eq!(alice_bal.get_total_balance(), total_balance,);
+    assert_eq!(alice_bal.get_total_balance().unwrap(), total_balance,);
 
     // check that the total reward cycle amounts have incremented correctly
     for cycle_number in first_v2_cycle..(first_v2_cycle + 2) {
@@ -1862,7 +1864,7 @@ fn stack_increase() {
     let alice_bal = get_stx_account_at(&mut peer, &latest_block, &alice_principal);
     assert_eq!(alice_bal.amount_locked(), first_lockup_amt);
     assert_eq!(alice_bal.unlock_height(), expected_pox_3_unlock_ht);
-    assert_eq!(alice_bal.get_total_balance(), total_balance,);
+    assert_eq!(alice_bal.get_total_balance().unwrap(), total_balance,);
 
     // check that the "raw" reward set will contain entries for alice at the cycle start
     for cycle_number in first_v3_cycle..(first_v3_cycle + 6) {
@@ -1926,7 +1928,7 @@ fn stack_increase() {
     let alice_bal = get_stx_account_at(&mut peer, &latest_block, &alice_principal);
     assert_eq!(alice_bal.amount_locked(), first_lockup_amt + increase_amt,);
     assert_eq!(alice_bal.unlock_height(), expected_pox_3_unlock_ht);
-    assert_eq!(alice_bal.get_total_balance(), total_balance,);
+    assert_eq!(alice_bal.get_total_balance().unwrap(), total_balance,);
 
     // check that the total reward cycle amounts have incremented correctly
     for cycle_number in first_v3_cycle..(first_v3_cycle + 4) {
@@ -3228,13 +3230,14 @@ fn pox_3_getters() {
     ));
 
     eprintln!("{}", &result);
-    let data = result.expect_tuple().data_map;
+    let data = result.expect_tuple().unwrap().data_map;
 
     let alice_delegation_info = data
         .get("get-delegation-info-alice")
         .cloned()
         .unwrap()
-        .expect_optional();
+        .expect_optional()
+        .unwrap();
     assert!(alice_delegation_info.is_none());
 
     let bob_delegation_info = data
@@ -3243,23 +3246,28 @@ fn pox_3_getters() {
         .unwrap()
         .expect_optional()
         .unwrap()
+        .unwrap()
         .expect_tuple()
+        .unwrap()
         .data_map;
     let bob_delegation_addr = bob_delegation_info
         .get("delegated-to")
         .cloned()
         .unwrap()
-        .expect_principal();
+        .expect_principal()
+        .unwrap();
     let bob_delegation_amt = bob_delegation_info
         .get("amount-ustx")
         .cloned()
         .unwrap()
-        .expect_u128();
+        .expect_u128()
+        .unwrap();
     let bob_pox_addr_opt = bob_delegation_info
         .get("pox-addr")
         .cloned()
         .unwrap()
-        .expect_optional();
+        .expect_optional()
+        .unwrap();
     assert_eq!(bob_delegation_addr, charlie_address.to_account_principal());
     assert_eq!(bob_delegation_amt, LOCKUP_AMT as u128);
     assert!(bob_pox_addr_opt.is_none());
@@ -3268,27 +3276,30 @@ fn pox_3_getters() {
         .get("get-allowance-contract-callers")
         .cloned()
         .unwrap()
-        .expect_optional();
+        .expect_optional()
+        .unwrap();
     assert!(allowance.is_none());
 
     let current_num_reward_addrs = data
         .get("get-num-reward-set-pox-addresses-current")
         .cloned()
         .unwrap()
-        .expect_u128();
+        .expect_u128()
+        .unwrap();
     assert_eq!(current_num_reward_addrs, 2);
 
     let future_num_reward_addrs = data
         .get("get-num-reward-set-pox-addresses-future")
         .cloned()
         .unwrap()
-        .expect_u128();
+        .expect_u128()
+        .unwrap();
     assert_eq!(future_num_reward_addrs, 0);
 
     for i in 0..3 {
         let key =
             ClarityName::try_from(format!("get-partial-stacked-by-cycle-bob-{}", &i)).unwrap();
-        let partial_stacked = data.get(&key).cloned().unwrap().expect_optional();
+        let partial_stacked = data.get(&key).cloned().unwrap().expect_optional().unwrap();
         assert!(partial_stacked.is_none());
     }
     let partial_stacked = data
@@ -3297,33 +3308,39 @@ fn pox_3_getters() {
         .unwrap()
         .expect_optional()
         .unwrap()
+        .unwrap()
         .expect_tuple()
+        .unwrap()
         .data_map
         .get("stacked-amount")
         .cloned()
         .unwrap()
-        .expect_u128();
+        .expect_u128()
+        .unwrap();
     assert_eq!(partial_stacked, LOCKUP_AMT as u128);
 
     let rejected = data
         .get("get-total-pox-rejection-now")
         .cloned()
         .unwrap()
-        .expect_u128();
+        .expect_u128()
+        .unwrap();
     assert_eq!(rejected, LOCKUP_AMT as u128);
 
     let rejected = data
         .get("get-total-pox-rejection-next")
         .cloned()
         .unwrap()
-        .expect_u128();
+        .expect_u128()
+        .unwrap();
     assert_eq!(rejected, 0);
 
     let rejected = data
         .get("get-total-pox-rejection-future")
         .cloned()
         .unwrap()
-        .expect_u128();
+        .expect_u128()
+        .unwrap();
     assert_eq!(rejected, 0);
 }
 
@@ -3356,14 +3373,17 @@ fn get_burn_pox_addr_info(peer: &mut TestPeer) -> (Vec<PoxAddress>, u128) {
     })
     .unwrap()
     .expect_optional()
+    .unwrap()
     .expect("FATAL: expected list")
-    .expect_tuple();
+    .expect_tuple()
+    .unwrap();
 
     let addrs = addrs_and_payout
         .get("addrs")
         .unwrap()
         .to_owned()
         .expect_list()
+        .unwrap()
         .into_iter()
         .map(|tuple| PoxAddress::try_from_pox_tuple(false, &tuple).unwrap())
         .collect();
@@ -3372,7 +3392,8 @@ fn get_burn_pox_addr_info(peer: &mut TestPeer) -> (Vec<PoxAddress>, u128) {
         .get("payout")
         .unwrap()
         .to_owned()
-        .expect_u128();
+        .expect_u128()
+        .unwrap();
     (addrs, payout)
 }
 
@@ -4362,14 +4383,15 @@ fn pox_3_delegate_stx_addr_validation() {
     );
 
     eprintln!("{}", &result);
-    let data = result.expect_tuple().data_map;
+    let data = result.expect_tuple().unwrap().data_map;
 
     // bob had an invalid PoX address
     let bob_delegation_info = data
         .get("get-delegation-info-bob")
         .cloned()
         .unwrap()
-        .expect_optional();
+        .expect_optional()
+        .unwrap();
     assert!(bob_delegation_info.is_none());
 
     // alice was valid
@@ -4379,23 +4401,28 @@ fn pox_3_delegate_stx_addr_validation() {
         .unwrap()
         .expect_optional()
         .unwrap()
+        .unwrap()
         .expect_tuple()
+        .unwrap()
         .data_map;
     let alice_delegation_addr = alice_delegation_info
         .get("delegated-to")
         .cloned()
         .unwrap()
-        .expect_principal();
+        .expect_principal()
+        .unwrap();
     let alice_delegation_amt = alice_delegation_info
         .get("amount-ustx")
         .cloned()
         .unwrap()
-        .expect_u128();
+        .expect_u128()
+        .unwrap();
     let alice_pox_addr_opt = alice_delegation_info
         .get("pox-addr")
         .cloned()
         .unwrap()
-        .expect_optional();
+        .expect_optional()
+        .unwrap();
     assert_eq!(
         alice_delegation_addr,
         charlie_address.to_account_principal()
diff --git a/src/chainstate/stacks/db/accounts.rs b/src/chainstate/stacks/db/accounts.rs
index cf65dcf705..f8fae36c3e 100644
--- a/src/chainstate/stacks/db/accounts.rs
+++ b/src/chainstate/stacks/db/accounts.rs
@@ -262,19 +262,25 @@ impl StacksChainState {
         clarity_tx: &mut T,
         principal: &PrincipalData,
     ) -> StacksAccount {
-        clarity_tx.with_clarity_db_readonly(|ref mut db| {
-            let stx_balance = db.get_account_stx_balance(principal);
-            let nonce = db.get_account_nonce(principal);
-            StacksAccount {
-                principal: principal.clone(),
-                stx_balance,
-                nonce,
-            }
-        })
+        clarity_tx
+            .with_clarity_db_readonly(|ref mut db| {
+                let stx_balance = db.get_account_stx_balance(principal)?;
+                let nonce = db.get_account_nonce(principal)?;
+                Ok(StacksAccount {
+                    principal: principal.clone(),
+                    stx_balance,
+                    nonce,
+                })
+            })
+            .map_err(Error::ClarityError)
+            .unwrap()
     }
 
     pub fn get_nonce<T: ClarityConnection>(clarity_tx: &mut T, principal: &PrincipalData) -> u64 {
-        clarity_tx.with_clarity_db_readonly(|ref mut db| db.get_account_nonce(principal))
+        clarity_tx
+            .with_clarity_db_readonly(|ref mut db| db.get_account_nonce(principal))
+            .map_err(|x| Error::ClarityError(x.into()))
+            .unwrap()
     }
 
     pub fn get_account_ft(
@@ -320,21 +326,21 @@ impl StacksChainState {
     ) {
         clarity_tx
             .with_clarity_db(|ref mut db| {
-                let mut snapshot = db.get_stx_balance_snapshot(principal);
+                let mut snapshot = db.get_stx_balance_snapshot(principal)?;
 
                 // last line of defense: if we don't have sufficient funds, panic.
                 // This should be checked by the block validation logic.
-                if !snapshot.can_transfer(amount as u128) {
+                if !snapshot.can_transfer(amount as u128)? {
                     panic!(
                         "Tried to debit {} from account {} (which only has {})",
                         amount,
                         principal,
-                        snapshot.get_available_balance()
+                        snapshot.get_available_balance()?
                     );
                 }
 
-                snapshot.debit(amount as u128);
-                snapshot.save();
+                snapshot.debit(amount as u128)?;
+                snapshot.save()?;
                 Ok(())
             })
             .expect("FATAL: failed to debit account")
@@ -349,11 +355,11 @@ impl StacksChainState {
     ) {
         clarity_tx
             .with_clarity_db(|ref mut db| {
-                let mut snapshot = db.get_stx_balance_snapshot(principal);
-                snapshot.credit(amount as u128);
+                let mut snapshot = db.get_stx_balance_snapshot(principal)?;
+                snapshot.credit(amount as u128)?;
 
-                let new_balance = snapshot.get_available_balance();
-                snapshot.save();
+                let new_balance = snapshot.get_available_balance()?;
+                snapshot.save()?;
 
                 info!("{} credited: {} uSTX", principal, new_balance);
                 Ok(())
@@ -369,9 +375,9 @@ impl StacksChainState {
     ) {
         clarity_tx
             .with_clarity_db(|ref mut db| {
-                let mut snapshot = db.get_stx_balance_snapshot_genesis(principal);
-                snapshot.credit(amount);
-                snapshot.save();
+                let mut snapshot = db.get_stx_balance_snapshot_genesis(principal)?;
+                snapshot.credit(amount)?;
+                snapshot.save()?;
                 Ok(())
             })
             .expect("FATAL: failed to credit account")
@@ -386,7 +392,7 @@ impl StacksChainState {
         clarity_tx
             .with_clarity_db(|ref mut db| {
                 let next_nonce = cur_nonce.checked_add(1).expect("OUT OF NONCES");
-                db.set_account_nonce(&principal, next_nonce);
+                db.set_account_nonce(&principal, next_nonce)?;
                 Ok(())
             })
             .expect("FATAL: failed to set account nonce")
@@ -404,15 +410,15 @@ impl StacksChainState {
         assert!(unlock_burn_height > 0);
         assert!(lock_amount > 0);
 
-        let mut snapshot = db.get_stx_balance_snapshot(principal);
+        let mut snapshot = db.get_stx_balance_snapshot(principal)?;
 
-        if snapshot.has_locked_tokens() {
+        if snapshot.has_locked_tokens()? {
             return Err(Error::PoxAlreadyLocked);
         }
-        if !snapshot.can_transfer(lock_amount) {
+        if !snapshot.can_transfer(lock_amount)? {
             return Err(Error::PoxInsufficientBalance);
         }
-        snapshot.lock_tokens_v3(lock_amount, unlock_burn_height);
+        snapshot.lock_tokens_v3(lock_amount, unlock_burn_height)?;
 
         debug!(
             "PoX v3 lock applied";
@@ -422,7 +428,7 @@ impl StacksChainState {
             "account" => %principal,
         );
 
-        snapshot.save();
+        snapshot.save()?;
         Ok(())
     }
 
@@ -440,13 +446,13 @@ impl StacksChainState {
     ) -> Result<u128, Error> {
         assert!(unlock_burn_height > 0);
 
-        let mut snapshot = db.get_stx_balance_snapshot(principal);
+        let mut snapshot = db.get_stx_balance_snapshot(principal)?;
 
-        if !snapshot.has_locked_tokens() {
+        if !snapshot.has_locked_tokens()? {
             return Err(Error::PoxExtendNotLocked);
         }
 
-        snapshot.extend_lock_v3(unlock_burn_height);
+        snapshot.extend_lock_v3(unlock_burn_height)?;
 
         let amount_locked = snapshot.balance().amount_locked();
 
@@ -458,7 +464,7 @@ impl StacksChainState {
             "account" => %principal,
         );
 
-        snapshot.save();
+        snapshot.save()?;
         Ok(amount_locked)
     }
 
@@ -476,13 +482,13 @@ impl StacksChainState {
     ) -> Result<STXBalance, Error> {
         assert!(new_total_locked > 0);
 
-        let mut snapshot = db.get_stx_balance_snapshot(principal);
+        let mut snapshot = db.get_stx_balance_snapshot(principal)?;
 
-        if !snapshot.has_locked_tokens() {
+        if !snapshot.has_locked_tokens()? {
             return Err(Error::PoxExtendNotLocked);
         }
 
-        let bal = snapshot.canonical_balance_repr();
+        let bal = snapshot.canonical_balance_repr()?;
         let total_amount = bal
             .amount_unlocked()
             .checked_add(bal.amount_locked())
@@ -495,9 +501,9 @@ impl StacksChainState {
             return Err(Error::PoxInvalidIncrease);
         }
 
-        snapshot.increase_lock_v3(new_total_locked);
+        snapshot.increase_lock_v3(new_total_locked)?;
 
-        let out_balance = snapshot.canonical_balance_repr();
+        let out_balance = snapshot.canonical_balance_repr()?;
 
         debug!(
             "PoX v3 lock increased";
@@ -507,7 +513,7 @@ impl StacksChainState {
             "account" => %principal,
         );
 
-        snapshot.save();
+        snapshot.save()?;
         Ok(out_balance)
     }
 
@@ -527,17 +533,17 @@ impl StacksChainState {
     ) -> Result<STXBalance, Error> {
         assert!(new_total_locked > 0);
 
-        let mut snapshot = db.get_stx_balance_snapshot(principal);
+        let mut snapshot = db.get_stx_balance_snapshot(principal)?;
 
-        if !snapshot.has_locked_tokens() {
+        if !snapshot.has_locked_tokens()? {
             return Err(Error::PoxExtendNotLocked);
         }
 
-        if !snapshot.is_v2_locked() {
+        if !snapshot.is_v2_locked()? {
             return Err(Error::PoxIncreaseOnV1);
         }
 
-        let bal = snapshot.canonical_balance_repr();
+        let bal = snapshot.canonical_balance_repr()?;
         let total_amount = bal
             .amount_unlocked()
             .checked_add(bal.amount_locked())
@@ -550,9 +556,9 @@ impl StacksChainState {
             return Err(Error::PoxInvalidIncrease);
         }
 
-        snapshot.increase_lock_v2(new_total_locked);
+        snapshot.increase_lock_v2(new_total_locked)?;
 
-        let out_balance = snapshot.canonical_balance_repr();
+        let out_balance = snapshot.canonical_balance_repr()?;
 
         debug!(
             "PoX v2 lock increased";
@@ -562,7 +568,7 @@ impl StacksChainState {
             "account" => %principal,
         );
 
-        snapshot.save();
+        snapshot.save()?;
         Ok(out_balance)
     }
 
@@ -580,13 +586,13 @@ impl StacksChainState {
     ) -> Result<u128, Error> {
         assert!(unlock_burn_height > 0);
 
-        let mut snapshot = db.get_stx_balance_snapshot(principal);
+        let mut snapshot = db.get_stx_balance_snapshot(principal)?;
 
-        if !snapshot.has_locked_tokens() {
+        if !snapshot.has_locked_tokens()? {
             return Err(Error::PoxExtendNotLocked);
         }
 
-        snapshot.extend_lock_v2(unlock_burn_height);
+        snapshot.extend_lock_v2(unlock_burn_height)?;
 
         let amount_locked = snapshot.balance().amount_locked();
 
@@ -598,7 +604,7 @@ impl StacksChainState {
             "account" => %principal,
         );
 
-        snapshot.save();
+        snapshot.save()?;
         Ok(amount_locked)
     }
 
@@ -612,15 +618,15 @@ impl StacksChainState {
         assert!(unlock_burn_height > 0);
         assert!(lock_amount > 0);
 
-        let mut snapshot = db.get_stx_balance_snapshot(principal);
+        let mut snapshot = db.get_stx_balance_snapshot(principal)?;
 
-        if snapshot.has_locked_tokens() {
+        if snapshot.has_locked_tokens()? {
             return Err(Error::PoxAlreadyLocked);
         }
-        if !snapshot.can_transfer(lock_amount) {
+        if !snapshot.can_transfer(lock_amount)? {
             return Err(Error::PoxInsufficientBalance);
         }
-        snapshot.lock_tokens_v2(lock_amount, unlock_burn_height);
+        snapshot.lock_tokens_v2(lock_amount, unlock_burn_height)?;
 
         debug!(
             "PoX v2 lock applied";
@@ -630,7 +636,7 @@ impl StacksChainState {
             "account" => %principal,
         );
 
-        snapshot.save();
+        snapshot.save()?;
         Ok(())
     }
 
@@ -646,20 +652,20 @@ impl StacksChainState {
         assert!(unlock_burn_height > 0);
         assert!(lock_amount > 0);
 
-        let mut snapshot = db.get_stx_balance_snapshot(principal);
+        let mut snapshot = db.get_stx_balance_snapshot(principal)?;
 
         if snapshot.balance().was_locked_by_v2() {
             debug!("PoX Lock attempted on an account locked by v2");
             return Err(Error::DefunctPoxContract);
         }
 
-        if snapshot.has_locked_tokens() {
+        if snapshot.has_locked_tokens()? {
             return Err(Error::PoxAlreadyLocked);
         }
-        if !snapshot.can_transfer(lock_amount) {
+        if !snapshot.can_transfer(lock_amount)? {
             return Err(Error::PoxInsufficientBalance);
         }
-        snapshot.lock_tokens_v1(lock_amount, unlock_burn_height);
+        snapshot.lock_tokens_v1(lock_amount, unlock_burn_height)?;
 
         debug!(
             "PoX v1 lock applied";
@@ -669,7 +675,7 @@ impl StacksChainState {
             "account" => %principal,
         );
 
-        snapshot.save();
+        snapshot.save()?;
         Ok(())
     }
 
@@ -979,10 +985,8 @@ impl StacksChainState {
         height: u64,
     ) -> Result<Option<(StacksAddress, u16)>, Error> {
         let principal_seq_opt = clarity_tx
-            .with_clarity_db_readonly(|ref mut db| {
-                Ok(db.get_microblock_poison_report(height as u32))
-            })
-            .map_err(Error::ClarityError)?;
+            .with_clarity_db_readonly(|ref mut db| db.get_microblock_poison_report(height as u32))
+            .map_err(|e| Error::ClarityError(e.into()))?;
 
         Ok(principal_seq_opt.map(|(principal, seq)| (principal.into(), seq)))
     }
diff --git a/src/chainstate/stacks/db/blocks.rs b/src/chainstate/stacks/db/blocks.rs
index e16468ad32..86388349ae 100644
--- a/src/chainstate/stacks/db/blocks.rs
+++ b/src/chainstate/stacks/db/blocks.rs
@@ -335,6 +335,12 @@ impl From<db_error> for MemPoolRejection {
     }
 }
 
+impl From<clarity::vm::errors::Error> for MemPoolRejection {
+    fn from(e: clarity::vm::errors::Error) -> MemPoolRejection {
+        MemPoolRejection::Other(e.to_string())
+    }
+}
+
 // These constants are mempool acceptance heuristics, but
 //  not part of the protocol consensus (i.e., a block
 //  that includes a transaction that violates these won't
@@ -4854,12 +4860,13 @@ impl StacksChainState {
         chain_tip_burn_header_height: u32,
     ) -> Result<(bool, Vec<StacksTransactionReceipt>), Error> {
         // is this stacks block the first of a new epoch?
-        let (stacks_parent_epoch, sortition_epoch) = clarity_tx.with_clarity_db_readonly(|db| {
-            (
-                db.get_clarity_epoch_version(),
-                db.get_stacks_epoch(chain_tip_burn_header_height),
-            )
-        });
+        let (stacks_parent_epoch, sortition_epoch) = clarity_tx
+            .with_clarity_db_readonly::<_, Result<_, clarity::vm::errors::Error>>(|db| {
+                Ok((
+                    db.get_clarity_epoch_version()?,
+                    db.get_stacks_epoch(chain_tip_burn_header_height),
+                ))
+            })?;
 
         let mut receipts = vec![];
         let mut applied = false;
@@ -5306,16 +5313,16 @@ impl StacksChainState {
                             ))
                         };
 
-                    let mut snapshot = db.get_stx_balance_snapshot(&recipient_principal);
-                    snapshot.credit(miner_reward_total);
+                    let mut snapshot = db.get_stx_balance_snapshot(&recipient_principal)?;
+                    snapshot.credit(miner_reward_total)?;
 
                     debug!(
                         "Balance available for {} is {} uSTX (earned {} uSTX)",
                         &recipient_principal,
-                        snapshot.get_available_balance(),
+                        snapshot.get_available_balance()?,
                         miner_reward_total
                     );
-                    snapshot.save();
+                    snapshot.save()?;
 
                     Ok(())
                 })
@@ -5368,7 +5375,7 @@ impl StacksChainState {
                 })?;
 
                 let entries = match result {
-                    Value::Optional(_) => match result.expect_optional() {
+                    Value::Optional(_) => match result.expect_optional()? {
                         Some(Value::Sequence(SequenceData::List(entries))) => entries.data,
                         _ => return Ok((0, vec![])),
                     },
@@ -5378,17 +5385,17 @@ impl StacksChainState {
                 let mut total_minted = 0;
                 let mut events = vec![];
                 for entry in entries.into_iter() {
-                    let schedule: TupleData = entry.expect_tuple();
+                    let schedule: TupleData = entry.expect_tuple()?;
                     let amount = schedule
                         .get("amount")
                         .expect("Lockup malformed")
                         .to_owned()
-                        .expect_u128();
+                        .expect_u128()?;
                     let recipient = schedule
                         .get("recipient")
                         .expect("Lockup malformed")
                         .to_owned()
-                        .expect_principal();
+                        .expect_principal()?;
                     total_minted += amount;
                     StacksChainState::account_credit(tx_connection, &recipient, amount as u64);
                     let event = STXEventType::STXMintEvent(STXMintEventData { recipient, amount });
@@ -7042,28 +7049,6 @@ impl StacksChainState {
         query_row(&self.db(), sql, args).map_err(Error::DBError)
     }
 
-    /// Get all possible canonical chain tips
-    pub fn get_stacks_chain_tips(&self, sortdb: &SortitionDB) -> Result<Vec<StagingBlock>, Error> {
-        let (consensus_hash, block_bhh) =
-            SortitionDB::get_canonical_stacks_chain_tip_hash(sortdb.conn())?;
-        let sql = "SELECT * FROM staging_blocks WHERE processed = 1 AND orphaned = 0 AND consensus_hash = ?1 AND anchored_block_hash = ?2";
-        let args: &[&dyn ToSql] = &[&consensus_hash, &block_bhh];
-        let Some(staging_block): Option<StagingBlock> =
-            query_row(&self.db(), sql, args).map_err(Error::DBError)?
-        else {
-            return Ok(vec![]);
-        };
-        self.get_stacks_chain_tips_at_height(staging_block.height)
-    }
-
-    /// Get all Stacks blocks at a given height
-    pub fn get_stacks_chain_tips_at_height(&self, height: u64) -> Result<Vec<StagingBlock>, Error> {
-        let sql =
-            "SELECT * FROM staging_blocks WHERE processed = 1 AND orphaned = 0 AND height = ?1";
-        let args: &[&dyn ToSql] = &[&u64_to_sql(height)?];
-        query_rows(&self.db(), sql, args).map_err(Error::DBError)
-    }
-
     /// Get the parent block of `staging_block`.
     pub fn get_stacks_block_parent(
         &self,
@@ -7285,13 +7270,15 @@ impl StacksChainState {
         }
 
         let (block_height, v1_unlock_height, v2_unlock_height) = clarity_connection
-            .with_clarity_db_readonly(|ref mut db| {
-                (
-                    db.get_current_burnchain_block_height() as u64,
-                    db.get_v1_unlock_height(),
-                    db.get_v2_unlock_height(),
-                )
-            });
+            .with_clarity_db_readonly::<_, Result<_, clarity::vm::errors::Error>>(
+                |ref mut db| {
+                    Ok((
+                        db.get_current_burnchain_block_height()? as u64,
+                        db.get_v1_unlock_height(),
+                        db.get_v2_unlock_height()?,
+                    ))
+                },
+            )?;
 
         // 5: the paying account must have enough funds
         if !payer.stx_balance.can_transfer_at_burn_block(
@@ -7299,7 +7286,7 @@ impl StacksChainState {
             block_height,
             v1_unlock_height,
             v2_unlock_height,
-        ) {
+        )? {
             match &tx.payload {
                 TransactionPayload::TokenTransfer(..) => {
                     // pass: we'll return a total_spent failure below.
@@ -7311,7 +7298,7 @@ impl StacksChainState {
                             block_height,
                             v1_unlock_height,
                             v2_unlock_height,
-                        ),
+                        )?,
                     ));
                 }
             }
@@ -7335,14 +7322,14 @@ impl StacksChainState {
                     block_height,
                     v1_unlock_height,
                     v2_unlock_height,
-                ) {
+                )? {
                     return Err(MemPoolRejection::NotEnoughFunds(
                         total_spent,
                         origin.stx_balance.get_available_balance_at_burn_block(
                             block_height,
                             v1_unlock_height,
                             v2_unlock_height,
-                        ),
+                        )?,
                     ));
                 }
 
@@ -7353,14 +7340,14 @@ impl StacksChainState {
                         block_height,
                         v1_unlock_height,
                         v2_unlock_height,
-                    ) {
+                    )? {
                         return Err(MemPoolRejection::NotEnoughFunds(
                             fee as u128,
                             payer.stx_balance.get_available_balance_at_burn_block(
                                 block_height,
                                 v1_unlock_height,
                                 v2_unlock_height,
-                            ),
+                            )?,
                         ));
                     }
                 }
@@ -12489,7 +12476,7 @@ pub mod test {
         peer.sortdb.replace(sortdb);
 
         assert_eq!(
-            account.stx_balance.get_total_balance(),
+            account.stx_balance.get_total_balance().unwrap(),
             1000000000 - (1000 + 2000 + 3000 + 4000 + 5000 + 6000 + 7000 + 8000 + 9000)
         );
 
@@ -12501,8 +12488,19 @@ pub mod test {
                 &format!("(get-delegation-info '{})", &del_addr),
             );
 
-            let data = result.expect_optional().unwrap().expect_tuple().data_map;
-            let delegation_amt = data.get("amount-ustx").cloned().unwrap().expect_u128();
+            let data = result
+                .expect_optional()
+                .unwrap()
+                .unwrap()
+                .expect_tuple()
+                .unwrap()
+                .data_map;
+            let delegation_amt = data
+                .get("amount-ustx")
+                .cloned()
+                .unwrap()
+                .expect_u128()
+                .unwrap();
 
             assert_eq!(delegation_amt, 1000 * (i as u128 + 1));
         }
@@ -13161,7 +13159,7 @@ pub mod test {
 
         // skipped tenure 6's TransferSTX
         assert_eq!(
-            account.stx_balance.get_total_balance(),
+            account.stx_balance.get_total_balance().unwrap(),
             1000000000
                 - (1000
                     + 2000
@@ -13199,8 +13197,19 @@ pub mod test {
                 ),
             );
 
-            let data = result.expect_optional().unwrap().expect_tuple().data_map;
-            let delegation_amt = data.get("amount-ustx").cloned().unwrap().expect_u128();
+            let data = result
+                .expect_optional()
+                .unwrap()
+                .unwrap()
+                .expect_tuple()
+                .unwrap()
+                .data_map;
+            let delegation_amt = data
+                .get("amount-ustx")
+                .cloned()
+                .unwrap()
+                .expect_u128()
+                .unwrap();
 
             assert_eq!(delegation_amt, 1000 * (i as u128 + 1));
         }
diff --git a/src/chainstate/stacks/db/mod.rs b/src/chainstate/stacks/db/mod.rs
index abcb84bb91..6fb50128d8 100644
--- a/src/chainstate/stacks/db/mod.rs
+++ b/src/chainstate/stacks/db/mod.rs
@@ -396,8 +396,11 @@ impl<'a, 'b> ClarityTx<'a, 'b> {
         self.block.commit_block();
     }
 
-    pub fn commit_mined_block(self, block_hash: &StacksBlockId) -> ExecutionCost {
-        self.block.commit_mined_block(block_hash).get_total()
+    pub fn commit_mined_block(
+        self,
+        block_hash: &StacksBlockId,
+    ) -> Result<ExecutionCost, clarity_error> {
+        Ok(self.block.commit_mined_block(block_hash)?.get_total())
     }
 
     pub fn commit_to_block(
@@ -2294,7 +2297,9 @@ impl StacksChainState {
         let height_opt = clarity_tx
             .connection()
             .with_clarity_db_readonly::<_, Result<_, ()>>(|ref mut db| {
-                let height_opt = db.get_microblock_pubkey_hash_height(mblock_pubkey_hash);
+                let height_opt = db
+                    .get_microblock_pubkey_hash_height(mblock_pubkey_hash)
+                    .expect("FATAL: failed to query microblock public key hash");
                 Ok(height_opt)
             })
             .expect("FATAL: failed to query microblock public key hash");
diff --git a/src/chainstate/stacks/db/transactions.rs b/src/chainstate/stacks/db/transactions.rs
index 78e64bece4..ac7acb3f06 100644
--- a/src/chainstate/stacks/db/transactions.rs
+++ b/src/chainstate/stacks/db/transactions.rs
@@ -40,6 +40,7 @@ use crate::chainstate::stacks::StacksMicroblockHeader;
 use crate::util_lib::strings::{StacksString, VecDisplay};
 use clarity::vm::analysis::run_analysis;
 use clarity::vm::analysis::types::ContractAnalysis;
+use clarity::vm::ast::errors::ParseErrors;
 use clarity::vm::clarity::TransactionConnection;
 use clarity::vm::contexts::{AssetMap, AssetMapEntry, Environment};
 use clarity::vm::contracts::Contract;
@@ -52,13 +53,41 @@ use clarity::vm::database::ClarityDatabase;
 use clarity::vm::errors::Error as InterpreterError;
 use clarity::vm::representations::ClarityName;
 use clarity::vm::representations::ContractName;
+use clarity::vm::types::serialization::SerializationError as ClaritySerializationError;
 use clarity::vm::types::StacksAddressExtensions as ClarityStacksAddressExt;
 use clarity::vm::types::{
     AssetIdentifier, BuffData, PrincipalData, QualifiedContractIdentifier, SequenceData,
     StandardPrincipalData, TupleData, TypeSignature, Value,
 };
+use std::convert::TryFrom;
+use std::convert::TryInto;
+
+/// This is a safe-to-hash Clarity value
+#[derive(PartialEq, Eq)]
+struct HashableClarityValue(Value);
+
+impl TryFrom<Value> for HashableClarityValue {
+    type Error = InterpreterError;
+
+    fn try_from(value: Value) -> Result<Self, Self::Error> {
+        // check that serialization _will_ be successful when hashed
+        let _bytes = value.serialize_to_vec().map_err(|_| {
+            InterpreterError::Interpreter(clarity::vm::errors::InterpreterError::Expect(
+                "Failed to serialize asset in NFT during post-condition checks".into(),
+            ))
+        })?;
+        Ok(Self(value))
+    }
+}
 
-use clarity::vm::ast::errors::ParseErrors;
+impl std::hash::Hash for HashableClarityValue {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        #[allow(clippy::unwrap_used)]
+        // this unwrap is safe _as long as_ TryFrom<Value> was used as a constructor
+        let bytes = self.0.serialize_to_vec().unwrap();
+        bytes.hash(state);
+    }
+}
 
 impl StacksTransactionReceipt {
     pub fn from_stx_transfer(
@@ -329,11 +358,14 @@ pub fn handle_clarity_runtime_error(error: clarity_error) -> ClarityRuntimeTxErr
                 err_type: "short return/panic",
             }
         }
-        clarity_error::Interpreter(InterpreterError::Unchecked(CheckErrors::SupertypeTooLarge)) => {
-            ClarityRuntimeTxError::Rejectable(error)
-        }
         clarity_error::Interpreter(InterpreterError::Unchecked(check_error)) => {
-            ClarityRuntimeTxError::AnalysisError(check_error)
+            if check_error.rejectable() {
+                ClarityRuntimeTxError::Rejectable(clarity_error::Interpreter(
+                    InterpreterError::Unchecked(check_error),
+                ))
+            } else {
+                ClarityRuntimeTxError::AnalysisError(check_error)
+            }
         }
         clarity_error::AbortedByCallback(val, assets, events) => {
             ClarityRuntimeTxError::AbortedByCallback(val, assets, events)
@@ -429,13 +461,13 @@ impl StacksChainState {
         payer_account: StacksAccount,
     ) -> Result<u64, Error> {
         let (cur_burn_block_height, v1_unlock_ht, v2_unlock_ht) = clarity_tx
-            .with_clarity_db_readonly(|ref mut db| {
-                (
-                    db.get_current_burnchain_block_height(),
+            .with_clarity_db_readonly::<_, Result<_, InterpreterError>>(|ref mut db| {
+                Ok((
+                    db.get_current_burnchain_block_height()?,
                     db.get_v1_unlock_height(),
-                    db.get_v2_unlock_height(),
-                )
-            });
+                    db.get_v2_unlock_height()?,
+                ))
+            })?;
 
         let consolidated_balance = payer_account
             .stx_balance
@@ -443,7 +475,7 @@ impl StacksChainState {
                 cur_burn_block_height as u64,
                 v1_unlock_ht,
                 v2_unlock_ht,
-            );
+            )?;
 
         if consolidated_balance < fee as u128 {
             return Err(Error::InvalidFee);
@@ -504,12 +536,12 @@ impl StacksChainState {
         post_condition_mode: &TransactionPostConditionMode,
         origin_account: &StacksAccount,
         asset_map: &AssetMap,
-    ) -> bool {
+    ) -> Result<bool, InterpreterError> {
         let mut checked_fungible_assets: HashMap<PrincipalData, HashSet<AssetIdentifier>> =
             HashMap::new();
         let mut checked_nonfungible_assets: HashMap<
             PrincipalData,
-            HashMap<AssetIdentifier, HashSet<Value>>,
+            HashMap<AssetIdentifier, HashSet<HashableClarityValue>>,
         > = HashMap::new();
         let allow_unchecked_assets = *post_condition_mode == TransactionPostConditionMode::Allow;
 
@@ -534,7 +566,7 @@ impl StacksChainState {
                             "Post-condition check failure on STX owned by {}: {:?} {:?} {}",
                             account_principal, amount_sent_condition, condition_code, amount_sent
                         );
-                        return false;
+                        return Ok(false);
                     }
 
                     if let Some(ref mut asset_ids) =
@@ -577,7 +609,7 @@ impl StacksChainState {
                         .unwrap_or(0);
                     if !condition_code.check(*amount_sent_condition as u128, amount_sent) {
                         info!("Post-condition check failure on fungible asset {} owned by {}: {} {:?} {}", &asset_id, account_principal, amount_sent_condition, condition_code, amount_sent);
-                        return false;
+                        return Ok(false);
                     }
 
                     if let Some(ref mut asset_ids) =
@@ -611,23 +643,23 @@ impl StacksChainState {
                         .unwrap_or(&empty_assets);
                     if !condition_code.check(asset_value, assets_sent) {
                         info!("Post-condition check failure on non-fungible asset {} owned by {}: {:?} {:?}", &asset_id, account_principal, &asset_value, condition_code);
-                        return false;
+                        return Ok(false);
                     }
 
                     if let Some(ref mut asset_id_map) =
                         checked_nonfungible_assets.get_mut(&account_principal)
                     {
                         if let Some(ref mut asset_values) = asset_id_map.get_mut(&asset_id) {
-                            asset_values.insert(asset_value.clone());
+                            asset_values.insert(asset_value.clone().try_into()?);
                         } else {
                             let mut asset_set = HashSet::new();
-                            asset_set.insert(asset_value.clone());
+                            asset_set.insert(asset_value.clone().try_into()?);
                             asset_id_map.insert(asset_id, asset_set);
                         }
                     } else {
                         let mut asset_id_map = HashMap::new();
                         let mut asset_set = HashSet::new();
-                        asset_set.insert(asset_value.clone());
+                        asset_set.insert(asset_value.clone().try_into()?);
                         asset_id_map.insert(asset_id, asset_set);
                         checked_nonfungible_assets.insert(account_principal, asset_id_map);
                     }
@@ -651,20 +683,20 @@ impl StacksChainState {
                                 {
                                     // each value must be covered
                                     for v in values {
-                                        if !nfts.contains(&v) {
+                                        if !nfts.contains(&v.clone().try_into()?) {
                                             info!("Post-condition check failure: Non-fungible asset {} value {:?} was moved by {} but not checked", &asset_identifier, &v, &principal);
-                                            return false;
+                                            return Ok(false);
                                         }
                                     }
                                 } else {
                                     // no values covered
                                     info!("Post-condition check failure: No checks for non-fungible asset type {} moved by {}", &asset_identifier, &principal);
-                                    return false;
+                                    return Ok(false);
                                 }
                             } else {
                                 // no NFT for this principal
                                 info!("Post-condition check failure: No checks for any non-fungible assets, but moved {} by {}", &asset_identifier, &principal);
-                                return false;
+                                return Ok(false);
                             }
                         }
                         _ => {
@@ -674,18 +706,18 @@ impl StacksChainState {
                             {
                                 if !checked_ft_asset_ids.contains(&asset_identifier) {
                                     info!("Post-condition check failure: checks did not cover transfer of {} by {}", &asset_identifier, &principal);
-                                    return false;
+                                    return Ok(false);
                                 }
                             } else {
                                 info!("Post-condition check failure: No checks for fungible token type {} moved by {}", &asset_identifier, &principal);
-                                return false;
+                                return Ok(false);
                             }
                         }
                     }
                 }
             }
         }
-        return true;
+        return Ok(true);
     }
 
     /// Given two microblock headers, were they signed by the same key?
@@ -760,7 +792,7 @@ impl StacksChainState {
         let microblock_height_opt = env
             .global_context
             .database
-            .get_microblock_pubkey_hash_height(&pubkh);
+            .get_microblock_pubkey_hash_height(&pubkh)?;
         let current_height = env.global_context.database.get_current_block_height();
 
         // for the microblock public key hash we had to process
@@ -807,11 +839,15 @@ impl StacksChainState {
         let (reporter_principal, reported_seq) = if let Some((reporter, seq)) = env
             .global_context
             .database
-            .get_microblock_poison_report(mblock_pubk_height)
+            .get_microblock_poison_report(mblock_pubk_height)?
         {
             // account for report loaded
-            env.add_memory(TypeSignature::PrincipalType.size() as u64)
-                .map_err(|e| Error::from_cost_error(e, cost_before.clone(), &env.global_context))?;
+            env.add_memory(
+                TypeSignature::PrincipalType
+                    .size()
+                    .map_err(InterpreterError::from)? as u64,
+            )
+            .map_err(|e| Error::from_cost_error(e, cost_before.clone(), &env.global_context))?;
 
             // u128 sequence
             env.add_memory(16)
@@ -960,6 +996,7 @@ impl StacksChainState {
                             origin_account,
                             asset_map,
                         )
+                        .expect("FATAL: error while evaluating post-conditions")
                     },
                 );
 
@@ -996,7 +1033,7 @@ impl StacksChainState {
                                     tx.clone(),
                                     events,
                                     value.expect("BUG: Post condition contract call must provide would-have-been-returned value"),
-                                    assets.get_stx_burned_total(),
+                                    assets.get_stx_burned_total()?,
                                     total_cost);
                             return Ok(receipt);
                         }
@@ -1048,7 +1085,7 @@ impl StacksChainState {
                     tx.clone(),
                     events,
                     result,
-                    asset_map.get_stx_burned_total(),
+                    asset_map.get_stx_burned_total()?,
                     total_cost,
                 );
                 Ok(receipt)
@@ -1118,8 +1155,14 @@ impl StacksChainState {
                                         }
                                     }
                                 }
+                                if let clarity_error::Parse(err) = &other_error {
+                                    if err.rejectable() {
+                                        info!("Transaction {} is problematic and should have prevented this block from being relayed", tx.txid());
+                                        return Err(Error::ClarityError(other_error));
+                                    }
+                                }
                                 if let clarity_error::Analysis(err) = &other_error {
-                                    if let CheckErrors::SupertypeTooLarge = err.err {
+                                    if err.err.rejectable() {
                                         info!("Transaction {} is problematic and should have prevented this block from being relayed", tx.txid());
                                         return Err(Error::ClarityError(other_error));
                                     }
@@ -1169,6 +1212,7 @@ impl StacksChainState {
                             origin_account,
                             asset_map,
                         )
+                        .expect("FATAL: error while evaluating post-conditions")
                     },
                 );
 
@@ -1199,7 +1243,7 @@ impl StacksChainState {
                                 StacksTransactionReceipt::from_condition_aborted_smart_contract(
                                     tx.clone(),
                                     events,
-                                    assets.get_stx_burned_total(),
+                                    assets.get_stx_burned_total()?,
                                     contract_analysis,
                                     total_cost,
                                 );
@@ -1256,7 +1300,7 @@ impl StacksChainState {
                 let receipt = StacksTransactionReceipt::from_smart_contract(
                     tx.clone(),
                     events,
-                    asset_map.get_stx_burned_total(),
+                    asset_map.get_stx_burned_total()?,
                     contract_analysis,
                     total_cost,
                 );
@@ -1409,7 +1453,9 @@ impl StacksChainState {
             tx_receipt
         };
 
-        transaction.commit();
+        transaction
+            .commit()
+            .map_err(|e| Error::InvalidStacksTransaction(e.to_string(), false))?;
 
         Ok((fee, tx_receipt))
     }
@@ -6557,7 +6603,8 @@ pub mod test {
                 mode,
                 origin,
                 &ft_transfer_2,
-            );
+            )
+            .unwrap();
             if result != expected_result {
                 eprintln!(
                     "test failed:\nasset map: {:?}\nscenario: {:?}\n",
@@ -6909,7 +6956,8 @@ pub mod test {
                 mode,
                 origin,
                 &nft_transfer_2,
-            );
+            )
+            .unwrap();
             if result != expected_result {
                 eprintln!(
                     "test failed:\nasset map: {:?}\nscenario: {:?}\n",
@@ -7725,7 +7773,8 @@ pub mod test {
                     post_condition_mode,
                     origin_account,
                     asset_map,
-                );
+                )
+                .unwrap();
                 if result != expected_result {
                     eprintln!(
                         "test failed:\nasset map: {:?}\nscenario: {:?}\n",
@@ -7867,7 +7916,8 @@ pub mod test {
         assert_eq!(
             StacksChainState::get_account(&mut conn, &addr.into())
                 .stx_balance
-                .get_available_balance_at_burn_block(0, 0, 0),
+                .get_available_balance_at_burn_block(0, 0, 0)
+                .unwrap(),
             (1000000000 - fee) as u128
         );
 
@@ -8015,28 +8065,32 @@ pub mod test {
             assert_eq!(report_opt.unwrap(), (reporter_addr, 123));
 
             // result must encode poison information
-            let result_data = receipt.result.expect_tuple();
+            let result_data = receipt.result.expect_tuple().unwrap();
 
             let height = result_data
                 .get("block_height")
                 .unwrap()
                 .to_owned()
-                .expect_u128();
+                .expect_u128()
+                .unwrap();
             let mblock_pubkh = result_data
                 .get("microblock_pubkey_hash")
                 .unwrap()
                 .to_owned()
-                .expect_buff(20);
+                .expect_buff(20)
+                .unwrap();
             let reporter = result_data
                 .get("reporter")
                 .unwrap()
                 .to_owned()
-                .expect_principal();
+                .expect_principal()
+                .unwrap();
             let seq = result_data
                 .get("sequence")
                 .unwrap()
                 .to_owned()
-                .expect_u128();
+                .expect_u128()
+                .unwrap();
 
             assert_eq!(height, 1);
             assert_eq!(mblock_pubkh, block_pubkh.0.to_vec());
@@ -8265,28 +8319,32 @@ pub mod test {
             assert_eq!(report_opt.unwrap(), (reporter_addr_2, 122));
 
             // result must encode poison information
-            let result_data = receipt.result.expect_tuple();
+            let result_data = receipt.result.expect_tuple().unwrap();
 
             let height = result_data
                 .get("block_height")
                 .unwrap()
                 .to_owned()
-                .expect_u128();
+                .expect_u128()
+                .unwrap();
             let mblock_pubkh = result_data
                 .get("microblock_pubkey_hash")
                 .unwrap()
                 .to_owned()
-                .expect_buff(20);
+                .expect_buff(20)
+                .unwrap();
             let reporter = result_data
                 .get("reporter")
                 .unwrap()
                 .to_owned()
-                .expect_principal();
+                .expect_principal()
+                .unwrap();
             let seq = result_data
                 .get("sequence")
                 .unwrap()
                 .to_owned()
-                .expect_u128();
+                .expect_u128()
+                .unwrap();
 
             assert_eq!(height, 1);
             assert_eq!(mblock_pubkh, block_pubkh.0.to_vec());
diff --git a/src/chainstate/stacks/db/unconfirmed.rs b/src/chainstate/stacks/db/unconfirmed.rs
index da40d5a500..567962d0bf 100644
--- a/src/chainstate/stacks/db/unconfirmed.rs
+++ b/src/chainstate/stacks/db/unconfirmed.rs
@@ -507,7 +507,8 @@ impl StacksChainState {
         );
         unconfirmed
             .clarity_inst
-            .drop_unconfirmed_state(&unconfirmed.confirmed_chain_tip);
+            .drop_unconfirmed_state(&unconfirmed.confirmed_chain_tip)
+            .expect("FATAL: failed to drop unconfirmed state");
         debug!(
             "Dropped unconfirmed state off of {} ({})",
             &unconfirmed.confirmed_chain_tip, &unconfirmed.unconfirmed_chain_tip
@@ -862,7 +863,9 @@ mod test {
                 .chainstate()
                 .with_read_only_unconfirmed_clarity_tx(&sortdb.index_conn(), |clarity_tx| {
                     clarity_tx.with_clarity_db_readonly(|clarity_db| {
-                        clarity_db.get_account_stx_balance(&recv_addr.into())
+                        clarity_db
+                            .get_account_stx_balance(&recv_addr.into())
+                            .unwrap()
                     })
                 })
                 .unwrap()
@@ -879,7 +882,9 @@ mod test {
                 .chainstate()
                 .with_read_only_clarity_tx(&sortdb.index_conn(), &canonical_tip, |clarity_tx| {
                     clarity_tx.with_clarity_db_readonly(|clarity_db| {
-                        clarity_db.get_account_stx_balance(&recv_addr.into())
+                        clarity_db
+                            .get_account_stx_balance(&recv_addr.into())
+                            .unwrap()
                     })
                 })
                 .unwrap();
@@ -1087,7 +1092,9 @@ mod test {
                     .chainstate()
                     .with_read_only_unconfirmed_clarity_tx(&sortdb.index_conn(), |clarity_tx| {
                         clarity_tx.with_clarity_db_readonly(|clarity_db| {
-                            clarity_db.get_account_stx_balance(&recv_addr.into())
+                            clarity_db
+                                .get_account_stx_balance(&recv_addr.into())
+                                .unwrap()
                         })
                     })
                     .unwrap()
@@ -1107,7 +1114,9 @@ mod test {
                     .chainstate()
                     .with_read_only_clarity_tx(&sortdb.index_conn(), &canonical_tip, |clarity_tx| {
                         clarity_tx.with_clarity_db_readonly(|clarity_db| {
-                            clarity_db.get_account_stx_balance(&recv_addr.into())
+                            clarity_db
+                                .get_account_stx_balance(&recv_addr.into())
+                                .unwrap()
                         })
                     })
                     .unwrap();
@@ -1384,7 +1393,9 @@ mod test {
             .chainstate()
             .with_read_only_unconfirmed_clarity_tx(&sortdb.index_conn(), |clarity_tx| {
                 clarity_tx.with_clarity_db_readonly(|clarity_db| {
-                    clarity_db.get_account_stx_balance(&recv_addr.into())
+                    clarity_db
+                        .get_account_stx_balance(&recv_addr.into())
+                        .unwrap()
                 })
             })
             .unwrap()
diff --git a/src/chainstate/stacks/miner.rs b/src/chainstate/stacks/miner.rs
index 71881e304d..e682f3f7b0 100644
--- a/src/chainstate/stacks/miner.rs
+++ b/src/chainstate/stacks/miner.rs
@@ -114,7 +114,6 @@ impl MinerStatus {
     pub fn get_spend_amount(&self) -> u64 {
         return self.spend_amount;
     }
-
     pub fn set_spend_amount(&mut self, amt: u64) {
         self.spend_amount = amt;
     }
@@ -2141,7 +2140,7 @@ impl StacksBlockBuilder {
     }
 
     /// Finish up mining an epoch's transactions
-    pub fn epoch_finish(self, tx: ClarityTx) -> ExecutionCost {
+    pub fn epoch_finish(self, tx: ClarityTx) -> Result<ExecutionCost, clarity_error> {
         let new_consensus_hash = MINER_BLOCK_CONSENSUS_HASH.clone();
         let new_block_hash = MINER_BLOCK_HEADER_HASH.clone();
 
@@ -2153,7 +2152,7 @@ impl StacksBlockBuilder {
         //        let moved_name = format!("{}.mined", index_block_hash);
 
         // write out the trie...
-        let consumed = tx.commit_mined_block(&index_block_hash);
+        let consumed = tx.commit_mined_block(&index_block_hash)?;
 
         test_debug!(
             "\n\nMiner {}: Finished mining child of {}/{}. Trie is in mined_blocks table.\n",
@@ -2162,7 +2161,7 @@ impl StacksBlockBuilder {
             self.chain_tip.anchored_header.block_hash()
         );
 
-        consumed
+        Ok(consumed)
     }
     /// Unconditionally build an anchored block from a list of transactions.
     ///  Used in test cases
@@ -2239,7 +2238,7 @@ impl StacksBlockBuilder {
             None
         };
 
-        let cost = builder.epoch_finish(epoch_tx);
+        let cost = builder.epoch_finish(epoch_tx)?;
         Ok((block, size, cost, mblock_opt))
     }
 
@@ -2633,7 +2632,7 @@ impl StacksBlockBuilder {
         // save the block so we can build microblocks off of it
         let block = builder.mine_anchored_block(&mut epoch_tx);
         let size = builder.bytes_so_far;
-        let consumed = builder.epoch_finish(epoch_tx);
+        let consumed = builder.epoch_finish(epoch_tx)?;
 
         let ts_end = get_epoch_time_ms();
 
diff --git a/src/chainstate/stacks/mod.rs b/src/chainstate/stacks/mod.rs
index 74979b1ece..4ed4169d4a 100644
--- a/src/chainstate/stacks/mod.rs
+++ b/src/chainstate/stacks/mod.rs
@@ -84,7 +84,7 @@ pub use stacks_common::address::{
     C32_ADDRESS_VERSION_TESTNET_MULTISIG, C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
 };
 
-pub const STACKS_BLOCK_VERSION: u8 = 7;
+pub const STACKS_BLOCK_VERSION: u8 = 6;
 pub const STACKS_BLOCK_VERSION_AST_PRECHECK_SIZE: u8 = 1;
 
 pub const MAX_BLOCK_LEN: u32 = 2 * 1024 * 1024;
diff --git a/src/chainstate/stacks/tests/accounting.rs b/src/chainstate/stacks/tests/accounting.rs
index 44e9cadbcb..1fd5f5511b 100644
--- a/src/chainstate/stacks/tests/accounting.rs
+++ b/src/chainstate/stacks/tests/accounting.rs
@@ -1050,10 +1050,10 @@ fn test_get_block_info_v210() {
                     )
                     .unwrap();
 
-                    let list = list_val.expect_list();
-                    let block_reward_opt = list.get(0).cloned().unwrap().expect_optional();
-                    let miner_spend_winner = list.get(1).cloned().unwrap().expect_optional().unwrap().expect_u128();
-                    let miner_spend_total = list.get(2).cloned().unwrap().expect_optional().unwrap().expect_u128();
+                    let list = list_val.expect_list().unwrap();
+                    let block_reward_opt = list.get(0).cloned().unwrap().expect_optional().unwrap();
+                    let miner_spend_winner = list.get(1).cloned().unwrap().expect_optional().unwrap().unwrap().expect_u128().unwrap();
+                    let miner_spend_total = list.get(2).cloned().unwrap().expect_optional().unwrap().unwrap().expect_u128().unwrap();
 
                     eprintln!("i = {}, block_reward = {:?}, miner_spend_winner = {:?}, miner_spend_total = {:?}", i, &block_reward_opt, &miner_spend_winner, &miner_spend_total);
 
@@ -1092,7 +1092,7 @@ fn test_get_block_info_v210() {
                             };
 
                         eprintln!("i = {}, {} + {} + {} + {}", i, coinbase, tx_fees_anchored, tx_fees_streamed_produced, tx_fees_streamed_confirmed);
-                        assert_eq!(block_reward_opt.unwrap().expect_u128(), coinbase + tx_fees_anchored + tx_fees_streamed_produced + tx_fees_streamed_confirmed);
+                        assert_eq!(block_reward_opt.unwrap().expect_u128().unwrap(), coinbase + tx_fees_anchored + tx_fees_streamed_produced + tx_fees_streamed_confirmed);
                     }
                     else {
                         // genesis, or not yet mature
@@ -1352,10 +1352,10 @@ fn test_get_block_info_v210_no_microblocks() {
                     )
                     .unwrap();
 
-                    let list = list_val.expect_list();
-                    let block_reward_opt = list.get(0).cloned().unwrap().expect_optional();
-                    let miner_spend_winner = list.get(1).cloned().unwrap().expect_optional().unwrap().expect_u128();
-                    let miner_spend_total = list.get(2).cloned().unwrap().expect_optional().unwrap().expect_u128();
+                    let list = list_val.expect_list().unwrap();
+                    let block_reward_opt = list.get(0).cloned().unwrap().expect_optional().unwrap();
+                    let miner_spend_winner = list.get(1).cloned().unwrap().expect_optional().unwrap().unwrap().expect_u128().unwrap();
+                    let miner_spend_total = list.get(2).cloned().unwrap().expect_optional().unwrap().unwrap().expect_u128().unwrap();
 
                     eprintln!("i = {}, block_reward = {:?}, miner_spend_winner = {:?}, miner_spend_total = {:?}", i, &block_reward_opt, &miner_spend_winner, &miner_spend_total);
 
@@ -1382,7 +1382,7 @@ fn test_get_block_info_v210_no_microblocks() {
                         let tx_fees_streamed_confirmed = 0;
 
                         eprintln!("i = {}, {} + {} + {} + {}", i, coinbase, tx_fees_anchored, tx_fees_streamed_produced, tx_fees_streamed_confirmed);
-                        assert_eq!(block_reward_opt.unwrap().expect_u128(), coinbase + tx_fees_anchored + tx_fees_streamed_produced + tx_fees_streamed_confirmed);
+                        assert_eq!(block_reward_opt.unwrap().expect_u128().unwrap(), coinbase + tx_fees_anchored + tx_fees_streamed_produced + tx_fees_streamed_confirmed);
                     }
                     else {
                         // genesis, or not yet mature
@@ -1819,10 +1819,10 @@ fn test_coinbase_pay_to_alt_recipient_v210(pay_to_contract: bool) {
                     )
                     .unwrap();
 
-                    let list = list_val.expect_list();
-                    let block_reward_opt = list.get(0).cloned().unwrap().expect_optional();
-                    let miner_spend_winner = list.get(1).cloned().unwrap().expect_optional().unwrap().expect_u128();
-                    let miner_spend_total = list.get(2).cloned().unwrap().expect_optional().unwrap().expect_u128();
+                    let list = list_val.expect_list().unwrap();
+                    let block_reward_opt = list.get(0).cloned().unwrap().expect_optional().unwrap();
+                    let miner_spend_winner = list.get(1).cloned().unwrap().expect_optional().unwrap().unwrap().expect_u128().unwrap();
+                    let miner_spend_total = list.get(2).cloned().unwrap().expect_optional().unwrap().unwrap().expect_u128().unwrap();
 
                     if i >= 1 {
                         assert_eq!(miner_spend_winner, (1000 + i - 1) as u128);
@@ -1845,7 +1845,7 @@ fn test_coinbase_pay_to_alt_recipient_v210(pay_to_contract: bool) {
                             |env| env.eval_raw(&format!("(get-block-info? miner-address u{})", i))
                         )
                         .unwrap();
-                        let miner_address = miner_val.expect_optional().unwrap().expect_principal();
+                        let miner_address = miner_val.expect_optional().unwrap().unwrap().expect_principal().unwrap();
 
                         eprintln!("i = {}, block_reward = {:?}, miner_spend_winner = {:?}, miner_spend_total = {:?}, miner address = {}", i, &block_reward_opt, &miner_spend_winner, &miner_spend_total, miner_address);
                         assert_eq!(miner_address, coinbase_addresses[i - 1].to_account_principal());
@@ -1881,11 +1881,11 @@ fn test_coinbase_pay_to_alt_recipient_v210(pay_to_contract: bool) {
                         }
 
                         eprintln!("i = {}, {} + {} + {} + {}", i, coinbase, tx_fees_anchored, tx_fees_streamed_produced, tx_fees_streamed_confirmed);
-                        assert_eq!(block_reward_opt.clone().unwrap().expect_u128(), coinbase + tx_fees_anchored + tx_fees_streamed_produced + tx_fees_streamed_confirmed);
+                        assert_eq!(block_reward_opt.clone().unwrap().expect_u128().unwrap(), coinbase + tx_fees_anchored + tx_fees_streamed_produced + tx_fees_streamed_confirmed);
 
                         if i > 2 {
-                            eprintln!("recipient_total_reward: {} = {} + {}", recipient_total_reward + block_reward_opt.clone().unwrap().expect_u128(), recipient_total_reward, block_reward_opt.clone().unwrap().expect_u128());
-                            recipient_total_reward += block_reward_opt.clone().unwrap().expect_u128();
+                            eprintln!("recipient_total_reward: {} = {} + {}", recipient_total_reward + block_reward_opt.clone().unwrap().expect_u128().unwrap(), recipient_total_reward, block_reward_opt.clone().unwrap().expect_u128().unwrap());
+                            recipient_total_reward += block_reward_opt.clone().unwrap().expect_u128().unwrap();
                         }
                     }
                     else {
@@ -1930,7 +1930,7 @@ fn test_coinbase_pay_to_alt_recipient_v210(pay_to_contract: bool) {
                     },
                 )
                 .unwrap();
-            recipient_balance_val.expect_u128()
+            recipient_balance_val.expect_u128().unwrap()
         })
         .unwrap();
 
diff --git a/src/chainstate/stacks/tests/block_construction.rs b/src/chainstate/stacks/tests/block_construction.rs
index e1918fb74a..006e0dd134 100644
--- a/src/chainstate/stacks/tests/block_construction.rs
+++ b/src/chainstate/stacks/tests/block_construction.rs
@@ -2686,17 +2686,17 @@ fn test_build_microblock_stream_forks() {
         test_debug!(
             "Test {}: {}",
             &account.principal.to_string(),
-            account.stx_balance.get_total_balance()
+            account.stx_balance.get_total_balance().unwrap()
         );
         if (i as u64) < (num_blocks as u64) - MINER_REWARD_MATURITY - 1 {
             assert_eq!(
-                account.stx_balance.get_total_balance(),
+                account.stx_balance.get_total_balance().unwrap(),
                 (initial_balance as u128)
                     + (expected_coinbase * POISON_MICROBLOCK_COMMISSION_FRACTION) / 100
             );
         } else {
             assert_eq!(
-                account.stx_balance.get_total_balance(),
+                account.stx_balance.get_total_balance().unwrap(),
                 initial_balance as u128
             );
         }
@@ -3702,7 +3702,7 @@ fn test_contract_call_across_clarity_versions() {
                                     &addr_anchored, tenure_id
                                 ))
                                 .unwrap();
-                            let call_count = call_count_value.expect_u128();
+                            let call_count = call_count_value.expect_u128().unwrap();
                             assert_eq!(call_count, (num_blocks - tenure_id - 1) as u128);
 
                             // contract-call transaction worked
@@ -3712,7 +3712,7 @@ fn test_contract_call_across_clarity_versions() {
                                     &addr_anchored, tenure_id
                                 ))
                                 .unwrap();
-                            let call_count = call_count_value.expect_u128();
+                            let call_count = call_count_value.expect_u128().unwrap();
                             assert_eq!(call_count, (num_blocks - tenure_id - 1) as u128);
 
                             // at-block transaction worked
@@ -3722,7 +3722,7 @@ fn test_contract_call_across_clarity_versions() {
                                     &addr_anchored, tenure_id
                                 ))
                                 .unwrap();
-                            let call_count = at_block_count_value.expect_u128();
+                            let call_count = at_block_count_value.expect_u128().unwrap();
 
                             if tenure_id < num_blocks - 1 {
                                 assert_eq!(call_count, 1);
@@ -4367,12 +4367,12 @@ fn mempool_incorporate_pox_unlocks() {
 
                  let available_balance = chainstate.with_read_only_clarity_tx(&sortdb.index_conn(), &parent_tip.index_block_hash(), |clarity_tx| {
                      clarity_tx.with_clarity_db_readonly(|db| {
-                         let burn_block_height = db.get_current_burnchain_block_height() as u64;
+                         let burn_block_height = db.get_current_burnchain_block_height().unwrap() as u64;
                          let v1_unlock_height = db.get_v1_unlock_height();
-                         let v2_unlock_height = db.get_v2_unlock_height();
-                         let balance = db.get_account_stx_balance(&principal);
+                         let v2_unlock_height = db.get_v2_unlock_height().unwrap();
+                         let balance = db.get_account_stx_balance(&principal).unwrap();
                          info!("Checking balance"; "v1_unlock_height" => v1_unlock_height, "burn_block_height" => burn_block_height);
-                         balance.get_available_balance_at_burn_block(burn_block_height, v1_unlock_height, v2_unlock_height)
+                         balance.get_available_balance_at_burn_block(burn_block_height, v1_unlock_height, v2_unlock_height).unwrap()
                      })
                  }).unwrap();
 
@@ -4708,6 +4708,7 @@ fn paramaterized_mempool_walk_test(
     let b_2 = make_block(&mut chainstate, ConsensusHash([0x2; 20]), &b_1, 2, 2);
 
     let mut mempool_settings = MemPoolWalkSettings::default();
+    mempool_settings.min_tx_fee = 10;
     let mut tx_events = Vec::new();
 
     let txs = codec_all_transactions(
diff --git a/src/chainstate/stacks/tests/chain_histories.rs b/src/chainstate/stacks/tests/chain_histories.rs
index 220d45eb97..360fb21bbe 100644
--- a/src/chainstate/stacks/tests/chain_histories.rs
+++ b/src/chainstate/stacks/tests/chain_histories.rs
@@ -182,7 +182,7 @@ where
                     &all_prev_mining_rewards
                 ));
 
-                builder.epoch_finish(epoch);
+                builder.epoch_finish(epoch).unwrap();
                 (stacks_block, microblocks)
             },
         );
@@ -368,7 +368,7 @@ where
                     &all_prev_mining_rewards
                 ));
 
-                builder.epoch_finish(epoch);
+                builder.epoch_finish(epoch).unwrap();
                 (stacks_block, microblocks)
             },
         );
@@ -515,7 +515,7 @@ where
                     &all_prev_mining_rewards
                 ));
 
-                builder.epoch_finish(epoch);
+                builder.epoch_finish(epoch).unwrap();
                 (stacks_block, microblocks)
             },
         );
@@ -563,7 +563,7 @@ where
                     &all_prev_mining_rewards
                 ));
 
-                builder.epoch_finish(epoch);
+                builder.epoch_finish(epoch).unwrap();
                 (stacks_block, microblocks)
             },
         );
@@ -852,7 +852,7 @@ where
                     &all_prev_mining_rewards
                 ));
 
-                builder.epoch_finish(epoch);
+                builder.epoch_finish(epoch).unwrap();
                 (stacks_block, microblocks)
             },
         );
@@ -900,7 +900,7 @@ where
                     &all_prev_mining_rewards
                 ));
 
-                builder.epoch_finish(epoch);
+                builder.epoch_finish(epoch).unwrap();
                 (stacks_block, microblocks)
             },
         );
@@ -1117,7 +1117,7 @@ where
                     &all_prev_mining_rewards
                 ));
 
-                builder.epoch_finish(epoch);
+                builder.epoch_finish(epoch).unwrap();
                 (stacks_block, microblocks)
             },
         );
@@ -1166,7 +1166,7 @@ where
                     &all_prev_mining_rewards
                 ));
 
-                builder.epoch_finish(epoch);
+                builder.epoch_finish(epoch).unwrap();
                 (stacks_block, microblocks)
             },
         );
@@ -1465,7 +1465,7 @@ where
                     &all_prev_mining_rewards
                 ));
 
-                builder.epoch_finish(epoch);
+                builder.epoch_finish(epoch).unwrap();
                 (stacks_block, microblocks)
             },
         );
@@ -1510,7 +1510,7 @@ where
                     &all_prev_mining_rewards
                 ));
 
-                builder.epoch_finish(epoch);
+                builder.epoch_finish(epoch).unwrap();
                 (stacks_block, microblocks)
             },
         );
@@ -1712,7 +1712,7 @@ where
                     &all_prev_mining_rewards
                 ));
 
-                builder.epoch_finish(epoch);
+                builder.epoch_finish(epoch).unwrap();
                 (stacks_block, microblocks)
             },
         );
@@ -1760,7 +1760,7 @@ where
                     &all_prev_mining_rewards
                 ));
 
-                builder.epoch_finish(epoch);
+                builder.epoch_finish(epoch).unwrap();
                 (stacks_block, microblocks)
             },
         );
@@ -2020,7 +2020,7 @@ where
                     &all_prev_mining_rewards
                 ));
 
-                builder.epoch_finish(epoch);
+                builder.epoch_finish(epoch).unwrap();
                 (stacks_block, microblocks)
             },
         );
@@ -2065,7 +2065,7 @@ where
                     &all_prev_mining_rewards
                 ));
 
-                builder.epoch_finish(epoch);
+                builder.epoch_finish(epoch).unwrap();
                 (stacks_block, microblocks)
             },
         );
@@ -2267,7 +2267,7 @@ where
                     &all_prev_mining_rewards
                 ));
 
-                builder.epoch_finish(epoch);
+                builder.epoch_finish(epoch).unwrap();
                 (stacks_block, microblocks)
             },
         );
@@ -2315,7 +2315,7 @@ where
                     &all_prev_mining_rewards
                 ));
 
-                builder.epoch_finish(epoch);
+                builder.epoch_finish(epoch).unwrap();
                 (stacks_block, microblocks)
             },
         );
diff --git a/src/chainstate/stacks/tests/mod.rs b/src/chainstate/stacks/tests/mod.rs
index 77d5162b6d..8f6517049d 100644
--- a/src/chainstate/stacks/tests/mod.rs
+++ b/src/chainstate/stacks/tests/mod.rs
@@ -528,6 +528,7 @@ impl TestStacksNode {
     pub fn get_miner_balance(clarity_tx: &mut ClarityTx, addr: &StacksAddress) -> u128 {
         clarity_tx.with_clarity_db_readonly(|db| {
             db.get_account_stx_balance(&StandardPrincipalData::from(addr.clone()).into())
+                .unwrap()
                 .amount_unlocked()
         })
     }
@@ -855,6 +856,7 @@ pub fn check_mining_reward(
     // what was the miner's total spend?
     let miner_nonce = clarity_tx.with_clarity_db_readonly(|db| {
         db.get_account_nonce(&StandardPrincipalData::from(miner.origin_address().unwrap()).into())
+            .unwrap()
     });
 
     let mut spent_total = 0;
diff --git a/src/clarity_cli.rs b/src/clarity_cli.rs
index bfa8e26c0a..2a859a27c0 100644
--- a/src/clarity_cli.rs
+++ b/src/clarity_cli.rs
@@ -396,7 +396,9 @@ where
     let (headers_return, result) = {
         let marf_tx = marf_kv.begin(&from, &to);
         let (headers_return, marf_return, result) = f(headers_db, marf_tx);
-        marf_return.commit_to(&to);
+        marf_return
+            .commit_to(&to)
+            .expect("FATAL: failed to commit block");
         (headers_return, result)
     };
     (headers_return, marf_kv, result)
@@ -878,6 +880,8 @@ fn install_boot_code<C: ClarityStorage>(header_db: &CLIHeadersDB, marf: &mut C)
                     res
                 },
             )
+            .unwrap()
+            .0
             .unwrap();
     }
 
@@ -973,7 +977,7 @@ pub fn add_assets(result: &mut serde_json::Value, assets: bool, asset_map: Asset
 
 pub fn add_serialized_output(result: &mut serde_json::Value, value: Value) {
     let result_raw = {
-        let bytes = (&value).serialize_to_vec();
+        let bytes = (&value).serialize_to_vec().unwrap();
         bytes_to_hex(&bytes)
     };
     result["output_serialized"] = serde_json::to_value(result_raw.as_str()).unwrap();
@@ -1064,15 +1068,15 @@ pub fn invoke_command(invoked_by: &str, args: &[String]) -> (i32, Option<serde_j
                     db.begin();
                     for (principal, amount) in allocations.iter() {
                         let balance = STXBalance::initial(*amount as u128);
-                        let total_balance = balance.get_total_balance();
+                        let total_balance = balance.get_total_balance().unwrap();
 
-                        let mut snapshot = db.get_stx_balance_snapshot_genesis(principal);
+                        let mut snapshot = db.get_stx_balance_snapshot_genesis(principal).unwrap();
                         snapshot.set_balance(balance);
-                        snapshot.save();
+                        snapshot.save().unwrap();
 
                         println!("{} credited: {} uSTX", principal, total_balance);
                     }
-                    db.commit();
+                    db.commit().unwrap();
                 };
                 (header_db, kv, ())
             });
@@ -1233,7 +1237,8 @@ pub fn invoke_command(invoked_by: &str, args: &[String]) -> (i32, Option<serde_j
 
             if output_analysis {
                 result["analysis"] =
-                    serde_json::to_value(&build_contract_interface(&contract_analysis)).unwrap();
+                    serde_json::to_value(&build_contract_interface(&contract_analysis).unwrap())
+                        .unwrap();
             }
             (0, Some(result))
         }
@@ -1717,13 +1722,14 @@ pub fn invoke_command(invoked_by: &str, args: &[String]) -> (i32, Option<serde_j
                     save_coverage(coverage_folder, coverage, "launch");
 
                     if output_analysis {
-                        result["analysis"] =
-                            serde_json::to_value(&build_contract_interface(&contract_analysis))
-                                .unwrap();
+                        result["analysis"] = serde_json::to_value(
+                            &build_contract_interface(&contract_analysis).unwrap(),
+                        )
+                        .unwrap();
                     }
                     let events_json: Vec<_> = events
                         .into_iter()
-                        .map(|event| event.json_serialize(0, &Txid([0u8; 32]), true))
+                        .map(|event| event.json_serialize(0, &Txid([0u8; 32]), true).unwrap())
                         .collect();
 
                     result["events"] = serde_json::Value::Array(events_json);
@@ -1857,7 +1863,9 @@ pub fn invoke_command(invoked_by: &str, args: &[String]) -> (i32, Option<serde_j
 
                             let events_json: Vec<_> = events
                                 .into_iter()
-                                .map(|event| event.json_serialize(0, &Txid([0u8; 32]), true))
+                                .map(|event| {
+                                    event.json_serialize(0, &Txid([0u8; 32]), true).unwrap()
+                                })
                                 .collect();
 
                             result["events"] = serde_json::Value::Array(events_json);
diff --git a/src/clarity_vm/clarity.rs b/src/clarity_vm/clarity.rs
index 0e50f21a76..02d88332a7 100644
--- a/src/clarity_vm/clarity.rs
+++ b/src/clarity_vm/clarity.rs
@@ -541,9 +541,10 @@ impl ClarityInstance {
         conn
     }
 
-    pub fn drop_unconfirmed_state(&mut self, block: &StacksBlockId) {
+    pub fn drop_unconfirmed_state(&mut self, block: &StacksBlockId) -> Result<(), Error> {
         let datastore = self.datastore.begin_unconfirmed(block);
-        datastore.rollback_unconfirmed()
+        datastore.rollback_unconfirmed()?;
+        Ok(())
     }
 
     pub fn begin_unconfirmed<'a, 'b>(
@@ -606,9 +607,9 @@ impl ClarityInstance {
             let mut db = datastore.as_clarity_db(header_db, burn_state_db);
             db.begin();
             let result = db.get_clarity_epoch_version();
-            db.roll_back();
+            db.roll_back()?;
             result
-        };
+        }?;
 
         Ok(ClarityReadOnlyConnection {
             datastore,
@@ -639,9 +640,9 @@ impl ClarityInstance {
         let epoch_id = {
             clarity_db.begin();
             let result = clarity_db.get_clarity_epoch_version();
-            clarity_db.roll_back();
+            clarity_db.roll_back()?;
             result
-        };
+        }?;
 
         let mut env = OwnedEnvironment::new_free(self.mainnet, self.chain_id, clarity_db, epoch_id);
         env.eval_read_only_with_rules(contract, program, ast_rules)
@@ -664,7 +665,8 @@ impl<'a, 'b> ClarityConnection for ClarityBlockConnection<'a, 'b> {
             ClarityDatabase::new(&mut self.datastore, &self.header_db, &self.burn_state_db);
         db.begin();
         let (result, mut db) = to_do(db);
-        db.roll_back();
+        db.roll_back()
+            .expect("FATAL: failed to roll back from read-only context");
         result
     }
 
@@ -675,7 +677,8 @@ impl<'a, 'b> ClarityConnection for ClarityBlockConnection<'a, 'b> {
         let mut db = AnalysisDatabase::new(&mut self.datastore);
         db.begin();
         let result = to_do(&mut db);
-        db.roll_back();
+        db.roll_back()
+            .expect("FATAL: failed to roll back from read-only context");
         result
     }
 
@@ -695,7 +698,8 @@ impl ClarityConnection for ClarityReadOnlyConnection<'_> {
             .as_clarity_db(&self.header_db, &self.burn_state_db);
         db.begin();
         let (result, mut db) = to_do(db);
-        db.roll_back();
+        db.roll_back()
+            .expect("FATAL: failed to roll back changes in read-only context");
         result
     }
 
@@ -706,7 +710,8 @@ impl ClarityConnection for ClarityReadOnlyConnection<'_> {
         let mut db = self.datastore.as_analysis_db();
         db.begin();
         let result = to_do(&mut db);
-        db.roll_back();
+        db.roll_back()
+            .expect("FATAL: failed to roll back changes in read-only context");
         result
     }
 
@@ -718,7 +723,9 @@ impl ClarityConnection for ClarityReadOnlyConnection<'_> {
 impl<'a> PreCommitClarityBlock<'a> {
     pub fn commit(self) {
         debug!("Committing Clarity block connection"; "index_block" => %self.commit_to);
-        self.datastore.commit_to(&self.commit_to);
+        self.datastore
+            .commit_to(&self.commit_to)
+            .expect("FATAL: failed to commit block");
     }
 }
 
@@ -740,7 +747,9 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
         // this is a "lower-level" rollback than the roll backs performed in
         //   ClarityDatabase or AnalysisDatabase -- this is done at the backing store level.
         debug!("Rollback unconfirmed Clarity datastore");
-        self.datastore.rollback_unconfirmed();
+        self.datastore
+            .rollback_unconfirmed()
+            .expect("FATAL: failed to rollback block");
     }
 
     /// Commits all changes in the current block by
@@ -771,7 +780,9 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
     /// time of opening).
     pub fn commit_to_block(self, final_bhh: &StacksBlockId) -> LimitedCostTracker {
         debug!("Commit Clarity datastore to {}", final_bhh);
-        self.datastore.commit_to(final_bhh);
+        self.datastore
+            .commit_to(final_bhh)
+            .expect("FATAL: failed to commit block");
 
         self.cost_track.unwrap()
     }
@@ -782,11 +793,11 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
     ///    before this saves, it updates the metadata headers in
     ///    the sidestore so that they don't get stepped on after
     ///    a miner re-executes a constructed block.
-    pub fn commit_mined_block(self, bhh: &StacksBlockId) -> LimitedCostTracker {
+    pub fn commit_mined_block(self, bhh: &StacksBlockId) -> Result<LimitedCostTracker, Error> {
         debug!("Commit mined Clarity datastore to {}", bhh);
-        self.datastore.commit_mined_block(bhh);
+        self.datastore.commit_mined_block(bhh)?;
 
-        self.cost_track.unwrap()
+        Ok(self.cost_track.unwrap())
     }
 
     /// Save all unconfirmed state by
@@ -822,6 +833,7 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
             let boot_code_auth = boot_code_tx_auth(boot_code_address);
             let boot_code_nonce = self.with_clarity_db_readonly(|db| {
                 db.get_account_nonce(&boot_code_address.clone().into())
+                    .expect("FATAL: Failed to boot account nonce")
             });
             let boot_code_account = boot_code_acc(boot_code_address, boot_code_nonce);
 
@@ -849,7 +861,7 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
                 // bump the epoch in the Clarity DB
                 tx_conn
                     .with_clarity_db(|db| {
-                        db.set_clarity_epoch_version(StacksEpochId::Epoch2_05);
+                        db.set_clarity_epoch_version(StacksEpochId::Epoch2_05)?;
                         Ok(())
                     })
                     .unwrap();
@@ -934,6 +946,7 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
 
             let boot_code_nonce = self.with_clarity_db_readonly(|db| {
                 db.get_account_nonce(&boot_code_address.clone().into())
+                    .expect("FATAL: Failed to boot account nonce")
             });
 
             let boot_code_account = StacksAccount {
@@ -971,7 +984,7 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
                 // bump the epoch in the Clarity DB
                 tx_conn
                     .with_clarity_db(|db| {
-                        db.set_clarity_epoch_version(StacksEpochId::Epoch21);
+                        db.set_clarity_epoch_version(StacksEpochId::Epoch21)?;
                         Ok(())
                     })
                     .unwrap();
@@ -1042,7 +1055,7 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
                 // bump the epoch in the Clarity DB
                 tx_conn
                     .with_clarity_db(|db| {
-                        db.set_clarity_epoch_version(StacksEpochId::Epoch21);
+                        db.set_clarity_epoch_version(StacksEpochId::Epoch21)?;
                         Ok(())
                     })
                     .unwrap();
@@ -1095,7 +1108,7 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
                 // bump the epoch in the Clarity DB
                 tx_conn
                     .with_clarity_db(|db| {
-                        db.set_clarity_epoch_version(StacksEpochId::Epoch22);
+                        db.set_clarity_epoch_version(StacksEpochId::Epoch22)?;
                         Ok(())
                     })
                     .unwrap();
@@ -1124,7 +1137,7 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
                 // bump the epoch in the Clarity DB
                 tx_conn
                     .with_clarity_db(|db| {
-                        db.set_clarity_epoch_version(StacksEpochId::Epoch23);
+                        db.set_clarity_epoch_version(StacksEpochId::Epoch23)?;
                         Ok(())
                     })
                     .unwrap();
@@ -1151,7 +1164,7 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
                 // bump the epoch in the Clarity DB
                 tx_conn
                     .with_clarity_db(|db| {
-                        db.set_clarity_epoch_version(StacksEpochId::Epoch24);
+                        db.set_clarity_epoch_version(StacksEpochId::Epoch24)?;
                         Ok(())
                     })
                     .unwrap();
@@ -1198,6 +1211,7 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
 
             let boot_code_nonce = self.with_clarity_db_readonly(|db| {
                 db.get_account_nonce(&boot_code_address.clone().into())
+                    .expect("FATAL: Failed to boot account nonce")
             });
 
             let boot_code_account = StacksAccount {
@@ -1315,7 +1329,8 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
 
             let mut tx = self.start_transaction_processing();
             let r = todo(&mut tx);
-            tx.commit();
+            tx.commit()
+                .expect("FATAL: failed to commit unconditional free transaction");
             (old_cost_tracker, r)
         })
     }
@@ -1330,7 +1345,8 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
     {
         let mut tx = self.start_transaction_processing();
         let r = todo(&mut tx);
-        tx.commit();
+        tx.commit()
+            .expect("FATAL: failed to commit unconditional transaction");
         r
     }
 
@@ -1363,7 +1379,8 @@ impl<'a, 'b> ClarityConnection for ClarityTransactionConnection<'a, 'b> {
             );
             db.begin();
             let (r, mut db) = to_do(db);
-            db.roll_back();
+            db.roll_back()
+                .expect("FATAL: failed to rollback changes during read-only connection");
             (db.destroy().into(), r)
         })
     }
@@ -1375,7 +1392,8 @@ impl<'a, 'b> ClarityConnection for ClarityTransactionConnection<'a, 'b> {
         self.with_analysis_db(|mut db, cost_tracker| {
             db.begin();
             let result = to_do(&mut db);
-            db.roll_back();
+            db.roll_back()
+                .expect("FATAL: failed to rollback changes during read-only connection");
             (cost_tracker, result)
         })
     }
@@ -1414,6 +1432,7 @@ impl<'a, 'b> TransactionConnection for ClarityTransactionConnection<'a, 'b> {
     where
         A: FnOnce(&AssetMap, &mut ClarityDatabase) -> bool,
         F: FnOnce(&mut OwnedEnvironment) -> Result<(R, AssetMap, Vec<StacksTransactionEvent>), E>,
+        E: From<InterpreterError>,
     {
         using!(self.log, "log", |log| {
             using!(self.cost_track, "cost tracker", |cost_track| {
@@ -1443,16 +1462,18 @@ impl<'a, 'b> TransactionConnection for ClarityTransactionConnection<'a, 'b> {
                 let result = match result {
                     Ok((value, asset_map, events)) => {
                         let aborted = abort_call_back(&asset_map, &mut db);
-                        if aborted {
-                            db.roll_back();
-                        } else {
-                            db.commit();
+                        let db_result = if aborted { db.roll_back() } else { db.commit() };
+                        match db_result {
+                            Ok(_) => Ok((value, asset_map, events, aborted)),
+                            Err(e) => Err(e.into()),
                         }
-                        Ok((value, asset_map, events, aborted))
                     }
                     Err(e) => {
-                        db.roll_back();
-                        Err(e)
+                        let db_result = db.roll_back();
+                        match db_result {
+                            Ok(_) => Err(e),
+                            Err(db_err) => Err(db_err.into()),
+                        }
                     }
                 };
 
@@ -1492,11 +1513,16 @@ impl<'a, 'b> ClarityTransactionConnection<'a, 'b> {
 
             db.begin();
             let result = to_do(&mut db);
-            if result.is_ok() {
-                db.commit();
+            let db_result = if result.is_ok() {
+                db.commit()
             } else {
-                db.roll_back();
-            }
+                db.roll_back()
+            };
+
+            let result = match db_result {
+                Ok(_) => result,
+                Err(e) => Err(e.into()),
+            };
 
             (db.destroy().into(), result)
         })
@@ -1542,7 +1568,7 @@ impl<'a, 'b> ClarityTransactionConnection<'a, 'b> {
 
     /// Commit the changes from the edit log.
     /// panics if there is more than one open savepoint
-    pub fn commit(mut self) {
+    pub fn commit(mut self) -> Result<(), Error> {
         let log = self
             .log
             .take()
@@ -1554,12 +1580,13 @@ impl<'a, 'b> ClarityTransactionConnection<'a, 'b> {
                 rollback_wrapper.depth()
             );
         }
-        rollback_wrapper.commit();
+        rollback_wrapper.commit().map_err(InterpreterError::from)?;
         // now we can reset the memory usage for the edit-log
         self.cost_track
             .as_mut()
             .expect("BUG: Transaction connection lost cost tracker connection.")
             .reset_memory();
+        Ok(())
     }
 
     /// Evaluate a raw Clarity snippit
@@ -1796,7 +1823,7 @@ mod tests {
                 tx.save_analysis(&contract_identifier, &ct_analysis)
                     .unwrap();
 
-                tx.commit();
+                tx.commit().unwrap();
             }
 
             // should fail since the prior contract
@@ -1828,7 +1855,7 @@ mod tests {
                 )
                 .contains("ContractAlreadyExists"));
 
-                tx.commit();
+                tx.commit().unwrap();
             }
         }
     }
diff --git a/src/clarity_vm/database/marf.rs b/src/clarity_vm/database/marf.rs
index a1bb96cb9f..50677412e5 100644
--- a/src/clarity_vm/database/marf.rs
+++ b/src/clarity_vm/database/marf.rs
@@ -387,26 +387,29 @@ impl<'a> ClarityBackingStore for ReadOnlyMarfStore<'a> {
             .expect("Attempted to get the open chain tip from an unopened context.")
     }
 
-    fn get_with_proof(&mut self, key: &str) -> Option<(String, Vec<u8>)> {
+    fn get_with_proof(&mut self, key: &str) -> InterpreterResult<Option<(String, Vec<u8>)>> {
         self.marf
             .get_with_proof(&self.chain_tip, key)
             .or_else(|e| match e {
                 Error::NotFoundError => Ok(None),
                 _ => Err(e),
             })
-            .expect("ERROR: Unexpected MARF Failure on GET")
+            .map_err(|_| InterpreterError::Expect("ERROR: Unexpected MARF Failure on GET".into()))?
             .map(|(marf_value, proof)| {
                 let side_key = marf_value.to_hex();
                 let data =
-                    SqliteConnection::get(self.get_side_store(), &side_key).expect(&format!(
-                        "ERROR: MARF contained value_hash not found in side storage: {}",
-                        side_key
-                    ));
-                (data, proof.serialize_to_vec())
+                    SqliteConnection::get(self.get_side_store(), &side_key)?.ok_or_else(|| {
+                        InterpreterError::Expect(format!(
+                            "ERROR: MARF contained value_hash not found in side storage: {}",
+                            side_key
+                        ))
+                    })?;
+                Ok((data, proof.serialize_to_vec()))
             })
+            .transpose()
     }
 
-    fn get(&mut self, key: &str) -> Option<String> {
+    fn get(&mut self, key: &str) -> InterpreterResult<Option<String>> {
         trace!("MarfedKV get: {:?} tip={}", key, &self.chain_tip);
         self.marf
             .get(&self.chain_tip, key)
@@ -421,18 +424,22 @@ impl<'a> ClarityBackingStore for ReadOnlyMarfStore<'a> {
                 }
                 _ => Err(e),
             })
-            .expect("ERROR: Unexpected MARF Failure on GET")
+            .map_err(|_| InterpreterError::Expect("ERROR: Unexpected MARF Failure on GET".into()))?
             .map(|marf_value| {
                 let side_key = marf_value.to_hex();
                 trace!("MarfedKV get side-key for {:?}: {:?}", key, &side_key);
-                SqliteConnection::get(self.get_side_store(), &side_key).expect(&format!(
-                    "ERROR: MARF contained value_hash not found in side storage: {}",
-                    side_key
-                ))
+                SqliteConnection::get(self.get_side_store(), &side_key)?.ok_or_else(|| {
+                    InterpreterError::Expect(format!(
+                        "ERROR: MARF contained value_hash not found in side storage: {}",
+                        side_key
+                    ))
+                    .into()
+                })
             })
+            .transpose()
     }
 
-    fn put_all(&mut self, _items: Vec<(String, String)>) {
+    fn put_all(&mut self, _items: Vec<(String, String)>) -> InterpreterResult<()> {
         error!("Attempted to commit changes to read-only MARF");
         panic!("BUG: attempted commit to read-only MARF");
     }
@@ -455,26 +462,28 @@ impl<'a> WritableMarfStore<'a> {
         self.marf.drop_current();
     }
 
-    pub fn rollback_unconfirmed(self) {
+    pub fn rollback_unconfirmed(self) -> InterpreterResult<()> {
         debug!("Drop unconfirmed MARF trie {}", &self.chain_tip);
-        SqliteConnection::drop_metadata(self.marf.sqlite_tx(), &self.chain_tip);
+        SqliteConnection::drop_metadata(self.marf.sqlite_tx(), &self.chain_tip)?;
         self.marf.drop_unconfirmed();
+        Ok(())
     }
 
-    pub fn commit_to(self, final_bhh: &StacksBlockId) {
+    pub fn commit_to(self, final_bhh: &StacksBlockId) -> InterpreterResult<()> {
         debug!("commit_to({})", final_bhh);
-        SqliteConnection::commit_metadata_to(self.marf.sqlite_tx(), &self.chain_tip, final_bhh);
+        SqliteConnection::commit_metadata_to(self.marf.sqlite_tx(), &self.chain_tip, final_bhh)?;
 
         let _ = self.marf.commit_to(final_bhh).map_err(|e| {
             error!("Failed to commit to MARF block {}: {:?}", &final_bhh, &e);
-            panic!();
-        });
+            InterpreterError::Expect("Failed to commit to MARF block".into())
+        })?;
+        Ok(())
     }
 
     #[cfg(test)]
     pub fn test_commit(self) {
         let bhh = self.chain_tip.clone();
-        self.commit_to(&bhh);
+        self.commit_to(&bhh).unwrap();
     }
 
     pub fn commit_unconfirmed(self) {
@@ -489,7 +498,7 @@ impl<'a> WritableMarfStore<'a> {
     // This is used by miners
     //   so that the block validation and processing logic doesn't
     //   reprocess the same data as if it were already loaded
-    pub fn commit_mined_block(self, will_move_to: &StacksBlockId) {
+    pub fn commit_mined_block(self, will_move_to: &StacksBlockId) -> InterpreterResult<()> {
         debug!(
             "commit_mined_block: ({}->{})",
             &self.chain_tip, will_move_to
@@ -499,14 +508,15 @@ impl<'a> WritableMarfStore<'a> {
         //    included in the processed chainstate (like a block constructed during mining)
         //    _if_ for some reason, we do want to be able to access that mined chain state in the future,
         //    we should probably commit the data to a different table which does not have uniqueness constraints.
-        SqliteConnection::drop_metadata(self.marf.sqlite_tx(), &self.chain_tip);
+        SqliteConnection::drop_metadata(self.marf.sqlite_tx(), &self.chain_tip)?;
         let _ = self.marf.commit_mined(will_move_to).map_err(|e| {
             error!(
                 "Failed to commit to mined MARF block {}: {:?}",
                 &will_move_to, &e
             );
-            panic!();
-        });
+            InterpreterError::Expect("Failed to commit to MARF block".into())
+        })?;
+        Ok(())
     }
 
     pub fn seal(&mut self) -> TrieHash {
@@ -545,7 +555,7 @@ impl<'a> ClarityBackingStore for WritableMarfStore<'a> {
         Some(&handle_contract_call_special_cases)
     }
 
-    fn get(&mut self, key: &str) -> Option<String> {
+    fn get(&mut self, key: &str) -> InterpreterResult<Option<String>> {
         trace!("MarfedKV get: {:?} tip={}", key, &self.chain_tip);
         self.marf
             .get(&self.chain_tip, key)
@@ -560,34 +570,41 @@ impl<'a> ClarityBackingStore for WritableMarfStore<'a> {
                 }
                 _ => Err(e),
             })
-            .expect("ERROR: Unexpected MARF Failure on GET")
+            .map_err(|_| InterpreterError::Expect("ERROR: Unexpected MARF Failure on GET".into()))?
             .map(|marf_value| {
                 let side_key = marf_value.to_hex();
                 trace!("MarfedKV get side-key for {:?}: {:?}", key, &side_key);
-                SqliteConnection::get(self.marf.sqlite_tx(), &side_key).expect(&format!(
-                    "ERROR: MARF contained value_hash not found in side storage: {}",
-                    side_key
-                ))
+                SqliteConnection::get(self.marf.sqlite_tx(), &side_key)?.ok_or_else(|| {
+                    InterpreterError::Expect(format!(
+                        "ERROR: MARF contained value_hash not found in side storage: {}",
+                        side_key
+                    ))
+                    .into()
+                })
             })
+            .transpose()
     }
 
-    fn get_with_proof(&mut self, key: &str) -> Option<(String, Vec<u8>)> {
+    fn get_with_proof(&mut self, key: &str) -> InterpreterResult<Option<(String, Vec<u8>)>> {
         self.marf
             .get_with_proof(&self.chain_tip, key)
             .or_else(|e| match e {
                 Error::NotFoundError => Ok(None),
                 _ => Err(e),
             })
-            .expect("ERROR: Unexpected MARF Failure on GET")
+            .map_err(|_| InterpreterError::Expect("ERROR: Unexpected MARF Failure on GET".into()))?
             .map(|(marf_value, proof)| {
                 let side_key = marf_value.to_hex();
                 let data =
-                    SqliteConnection::get(self.marf.sqlite_tx(), &side_key).expect(&format!(
-                        "ERROR: MARF contained value_hash not found in side storage: {}",
-                        side_key
-                    ));
-                (data, proof.serialize_to_vec())
+                    SqliteConnection::get(self.marf.sqlite_tx(), &side_key)?.ok_or_else(|| {
+                        InterpreterError::Expect(format!(
+                            "ERROR: MARF contained value_hash not found in side storage: {}",
+                            side_key
+                        ))
+                    })?;
+                Ok((data, proof.serialize_to_vec()))
             })
+            .transpose()
     }
 
     fn get_side_store(&mut self) -> &Connection {
@@ -651,18 +668,18 @@ impl<'a> ClarityBackingStore for WritableMarfStore<'a> {
         }
     }
 
-    fn put_all(&mut self, items: Vec<(String, String)>) {
+    fn put_all(&mut self, items: Vec<(String, String)>) -> InterpreterResult<()> {
         let mut keys = Vec::new();
         let mut values = Vec::new();
         for (key, value) in items.into_iter() {
             trace!("MarfedKV put '{}' = '{}'", &key, &value);
             let marf_value = MARFValue::from_value(&value);
-            SqliteConnection::put(self.get_side_store(), &marf_value.to_hex(), &value);
+            SqliteConnection::put(self.get_side_store(), &marf_value.to_hex(), &value)?;
             keys.push(key);
             values.push(marf_value);
         }
         self.marf
             .insert_batch(&keys, values)
-            .expect("ERROR: Unexpected MARF Failure");
+            .map_err(|_| InterpreterError::Expect("ERROR: Unexpected MARF Failure".into()).into())
     }
 }
diff --git a/src/clarity_vm/database/mod.rs b/src/clarity_vm/database/mod.rs
index bb1514b4c7..fe35d1b045 100644
--- a/src/clarity_vm/database/mod.rs
+++ b/src/clarity_vm/database/mod.rs
@@ -671,12 +671,12 @@ impl ClarityBackingStore for MemoryBackingStore {
         Err(RuntimeErrorType::UnknownBlockHeaderHash(BlockHeaderHash(bhh.0)).into())
     }
 
-    fn get(&mut self, key: &str) -> Option<String> {
+    fn get(&mut self, key: &str) -> InterpreterResult<Option<String>> {
         SqliteConnection::get(self.get_side_store(), key)
     }
 
-    fn get_with_proof(&mut self, key: &str) -> Option<(String, Vec<u8>)> {
-        SqliteConnection::get(self.get_side_store(), key).map(|x| (x, vec![]))
+    fn get_with_proof(&mut self, key: &str) -> InterpreterResult<Option<(String, Vec<u8>)>> {
+        Ok(SqliteConnection::get(self.get_side_store(), key)?.map(|x| (x, vec![])))
     }
 
     fn get_side_store(&mut self) -> &Connection {
@@ -707,9 +707,10 @@ impl ClarityBackingStore for MemoryBackingStore {
         Some(&handle_contract_call_special_cases)
     }
 
-    fn put_all(&mut self, items: Vec<(String, String)>) {
+    fn put_all(&mut self, items: Vec<(String, String)>) -> InterpreterResult<()> {
         for (key, value) in items.into_iter() {
-            SqliteConnection::put(self.get_side_store(), &key, &value);
+            SqliteConnection::put(self.get_side_store(), &key, &value)?;
         }
+        Ok(())
     }
 }
diff --git a/src/clarity_vm/special.rs b/src/clarity_vm/special.rs
index e738c3b7df..0e436ea4fb 100644
--- a/src/clarity_vm/special.rs
+++ b/src/clarity_vm/special.rs
@@ -53,33 +53,40 @@ use crate::vm::costs::runtime_cost;
 fn parse_pox_stacking_result(
     result: &Value,
 ) -> std::result::Result<(PrincipalData, u128, u64), i128> {
-    match result.clone().expect_result() {
+    match result
+        .clone()
+        .expect_result()
+        .expect("FATAL: unexpected clarity value")
+    {
         Ok(res) => {
             // should have gotten back (ok { stacker: principal, lock-amount: uint, unlock-burn-height: uint .. } .. })))
-            let tuple_data = res.expect_tuple();
+            let tuple_data = res.expect_tuple().expect("FATAL: unexpected clarity value");
             let stacker = tuple_data
                 .get("stacker")
                 .expect(&format!("FATAL: no 'stacker'"))
                 .to_owned()
-                .expect_principal();
+                .expect_principal()
+                .expect("FATAL: unexpected clarity value");
 
             let lock_amount = tuple_data
                 .get("lock-amount")
                 .expect(&format!("FATAL: no 'lock-amount'"))
                 .to_owned()
-                .expect_u128();
+                .expect_u128()
+                .expect("FATAL: unexpected clarity value");
 
             let unlock_burn_height = tuple_data
                 .get("unlock-burn-height")
                 .expect(&format!("FATAL: no 'unlock-burn-height'"))
                 .to_owned()
                 .expect_u128()
+                .expect("FATAL: unexpected clarity value")
                 .try_into()
                 .expect("FATAL: 'unlock-burn-height' overflow");
 
             Ok((stacker, lock_amount, unlock_burn_height))
         }
-        Err(e) => Err(e.expect_i128()),
+        Err(e) => Err(e.expect_i128().expect("FATAL: unexpected clarity value")),
     }
 }
 
@@ -89,33 +96,40 @@ fn parse_pox_stacking_result(
 fn parse_pox_stacking_result_v1(
     result: &Value,
 ) -> std::result::Result<(PrincipalData, u128, u64), i128> {
-    match result.clone().expect_result() {
+    match result
+        .clone()
+        .expect_result()
+        .expect("FATAL: unexpected clarity value")
+    {
         Ok(res) => {
             // should have gotten back (ok (tuple (stacker principal) (lock-amount uint) (unlock-burn-height uint)))
-            let tuple_data = res.expect_tuple();
+            let tuple_data = res.expect_tuple().expect("FATAL: unexpected clarity value");
             let stacker = tuple_data
                 .get("stacker")
                 .expect(&format!("FATAL: no 'stacker'"))
                 .to_owned()
-                .expect_principal();
+                .expect_principal()
+                .expect("FATAL: unexpected clarity value");
 
             let lock_amount = tuple_data
                 .get("lock-amount")
                 .expect(&format!("FATAL: no 'lock-amount'"))
                 .to_owned()
-                .expect_u128();
+                .expect_u128()
+                .expect("FATAL: unexpected clarity value");
 
             let unlock_burn_height = tuple_data
                 .get("unlock-burn-height")
                 .expect(&format!("FATAL: no 'unlock-burn-height'"))
                 .to_owned()
                 .expect_u128()
+                .expect("FATAL: unexpected clarity value")
                 .try_into()
                 .expect("FATAL: 'unlock-burn-height' overflow");
 
             Ok((stacker, lock_amount, unlock_burn_height))
         }
-        Err(e) => Err(e.expect_i128()),
+        Err(e) => Err(e.expect_i128().expect("FATAL: unexpected clarity value")),
     }
 }
 
@@ -123,28 +137,34 @@ fn parse_pox_stacking_result_v1(
 ///  into a format more readily digestible in rust.
 /// Panics if the supplied value doesn't match the expected tuple structure
 fn parse_pox_extend_result(result: &Value) -> std::result::Result<(PrincipalData, u64), i128> {
-    match result.clone().expect_result() {
+    match result
+        .clone()
+        .expect_result()
+        .expect("FATAL: unexpected clarity value")
+    {
         Ok(res) => {
             // should have gotten back (ok { stacker: principal, unlock-burn-height: uint .. } .. })
-            let tuple_data = res.expect_tuple();
+            let tuple_data = res.expect_tuple().expect("FATAL: unexpected clarity value");
             let stacker = tuple_data
                 .get("stacker")
                 .expect(&format!("FATAL: no 'stacker'"))
                 .to_owned()
-                .expect_principal();
+                .expect_principal()
+                .expect("FATAL: unexpected clarity value");
 
             let unlock_burn_height = tuple_data
                 .get("unlock-burn-height")
                 .expect(&format!("FATAL: no 'unlock-burn-height'"))
                 .to_owned()
                 .expect_u128()
+                .expect("FATAL: unexpected clarity value")
                 .try_into()
                 .expect("FATAL: 'unlock-burn-height' overflow");
 
             Ok((stacker, unlock_burn_height))
         }
         // in the error case, the function should have returned `int` error code
-        Err(e) => Err(e.expect_i128()),
+        Err(e) => Err(e.expect_i128().expect("FATAL: unexpected clarity value")),
     }
 }
 
@@ -152,26 +172,32 @@ fn parse_pox_extend_result(result: &Value) -> std::result::Result<(PrincipalData
 ///  into a format more readily digestible in rust.
 /// Panics if the supplied value doesn't match the expected tuple structure
 fn parse_pox_increase(result: &Value) -> std::result::Result<(PrincipalData, u128), i128> {
-    match result.clone().expect_result() {
+    match result
+        .clone()
+        .expect_result()
+        .expect("FATAL: unexpected clarity value")
+    {
         Ok(res) => {
             // should have gotten back (ok { stacker: principal, total-locked: uint .. } .. })
-            let tuple_data = res.expect_tuple();
+            let tuple_data = res.expect_tuple().expect("FATAL: unexpected clarity value");
             let stacker = tuple_data
                 .get("stacker")
                 .expect(&format!("FATAL: no 'stacker'"))
                 .to_owned()
-                .expect_principal();
+                .expect_principal()
+                .expect("FATAL: unexpected clarity value");
 
             let total_locked = tuple_data
                 .get("total-locked")
                 .expect(&format!("FATAL: no 'total-locked'"))
                 .to_owned()
-                .expect_u128();
+                .expect_u128()
+                .expect("FATAL: unexpected clarity value");
 
             Ok((stacker, total_locked))
         }
         // in the error case, the function should have returned `int` error code
-        Err(e) => Err(e.expect_i128()),
+        Err(e) => Err(e.expect_i128().expect("FATAL: unexpected clarity value")),
     }
 }
 
@@ -644,8 +670,8 @@ fn synthesize_pox_2_or_3_event_info(
                         })?;
 
                     // merge them
-                    let base_event_tuple = base_event_info.expect_tuple();
-                    let data_tuple = data_event_info.expect_tuple();
+                    let base_event_tuple = base_event_info.expect_tuple()?;
+                    let data_tuple = data_event_info.expect_tuple()?;
                     let event_tuple = TupleData::shallow_merge(base_event_tuple, data_tuple)
                         .map_err(|e| {
                             error!("Failed to merge data-info and event-info: {:?}", &e);
@@ -1232,12 +1258,14 @@ pub fn handle_contract_call_special_cases(
     if *contract_id == boot_code_id(POX_1_NAME, global_context.mainnet) {
         if !is_pox_v1_read_only(function_name)
             && global_context.database.get_v1_unlock_height()
-                <= global_context.database.get_current_burnchain_block_height()
+                <= global_context
+                    .database
+                    .get_current_burnchain_block_height()?
         {
             // NOTE: get-pox-info is read-only, so it can call old pox v1 stuff
             warn!("PoX-1 function call attempted on an account after v1 unlock height";
                   "v1_unlock_ht" => global_context.database.get_v1_unlock_height(),
-                  "current_burn_ht" => global_context.database.get_current_burnchain_block_height(),
+                  "current_burn_ht" => global_context.database.get_current_burnchain_block_height()?,
                   "function_name" => function_name,
                   "contract_id" => %contract_id
             );
@@ -1248,8 +1276,8 @@ pub fn handle_contract_call_special_cases(
         if !is_pox_v2_read_only(function_name) && global_context.epoch_id >= StacksEpochId::Epoch22
         {
             warn!("PoX-2 function call attempted on an account after Epoch 2.2";
-                  "v2_unlock_ht" => global_context.database.get_v2_unlock_height(),
-                  "current_burn_ht" => global_context.database.get_current_burnchain_block_height(),
+                  "v2_unlock_ht" => global_context.database.get_v2_unlock_height()?,
+                  "current_burn_ht" => global_context.database.get_current_burnchain_block_height()?,
                   "function_name" => function_name,
                   "contract_id" => %contract_id
             );
diff --git a/src/clarity_vm/tests/analysis_costs.rs b/src/clarity_vm/tests/analysis_costs.rs
index 8483e3ba4b..aa0f0f9911 100644
--- a/src/clarity_vm/tests/analysis_costs.rs
+++ b/src/clarity_vm/tests/analysis_costs.rs
@@ -130,7 +130,7 @@ pub fn test_tracked_costs(
         );
 
         assert_eq!(
-            conn.with_clarity_db_readonly(|db| db.get_clarity_epoch_version()),
+            conn.with_clarity_db_readonly(|db| db.get_clarity_epoch_version().unwrap()),
             epoch
         );
 
diff --git a/src/clarity_vm/tests/costs.rs b/src/clarity_vm/tests/costs.rs
index 19b43ba1f3..b149aaeb6f 100644
--- a/src/clarity_vm/tests/costs.rs
+++ b/src/clarity_vm/tests/costs.rs
@@ -1190,7 +1190,7 @@ fn test_cost_contract_short_circuits(use_mainnet: bool, clarity_version: Clarity
                  confirmed-height: u1 }}",
             intercepted, "\"intercepted-function\"", cost_definer, "\"cost-definition\""
         );
-        let epoch = db.get_clarity_epoch_version();
+        let epoch = db.get_clarity_epoch_version().unwrap();
         db.set_entry_unknown_descriptor(
             voting_contract_to_use,
             "confirmed-proposals",
@@ -1199,7 +1199,7 @@ fn test_cost_contract_short_circuits(use_mainnet: bool, clarity_version: Clarity
             &epoch,
         )
         .unwrap();
-        db.commit();
+        db.commit().unwrap();
         store.test_commit();
     }
 
@@ -1512,7 +1512,7 @@ fn test_cost_voting_integration(use_mainnet: bool, clarity_version: ClarityVersi
                      confirmed-height: u1 }}",
                 intercepted_ct, intercepted_f, cost_ct, cost_f
             );
-            let epoch = db.get_clarity_epoch_version();
+            let epoch = db.get_clarity_epoch_version().unwrap();
             db.set_entry_unknown_descriptor(
                 voting_contract_to_use,
                 "confirmed-proposals",
@@ -1522,7 +1522,7 @@ fn test_cost_voting_integration(use_mainnet: bool, clarity_version: ClarityVersi
             )
             .unwrap();
         }
-        db.commit();
+        db.commit().unwrap();
         store.test_commit();
     }
 
@@ -1612,7 +1612,7 @@ fn test_cost_voting_integration(use_mainnet: bool, clarity_version: ClarityVersi
                     confirmed-height: u1 }}",
                 intercepted_ct, intercepted_f, cost_ct, cost_f
             );
-            let epoch = db.get_clarity_epoch_version();
+            let epoch = db.get_clarity_epoch_version().unwrap();
             db.set_entry_unknown_descriptor(
                 voting_contract_to_use,
                 "confirmed-proposals",
@@ -1622,7 +1622,7 @@ fn test_cost_voting_integration(use_mainnet: bool, clarity_version: ClarityVersi
             )
             .unwrap();
         }
-        db.commit();
+        db.commit().unwrap();
 
         store.test_commit();
     }
diff --git a/src/clarity_vm/tests/events.rs b/src/clarity_vm/tests/events.rs
index 75700a530e..b7d7ff9d5a 100644
--- a/src/clarity_vm/tests/events.rs
+++ b/src/clarity_vm/tests/events.rs
@@ -50,7 +50,7 @@ fn helper_execute_epoch(
 ) -> (Value, Vec<StacksTransactionEvent>) {
     let contract_id = QualifiedContractIdentifier::local("contract").unwrap();
     let address = "'SZ2J6ZY48GV1EZ5V2V5RB9MP66SW86PYKKQ9H6DPR";
-    let sender = execute(address).expect_principal();
+    let sender = execute(address).expect_principal().unwrap();
 
     let marf_kv = MarfedKV::temporary();
     let chain_id = test_only_mainnet_to_chain_id(use_mainnet);
@@ -76,7 +76,7 @@ fn helper_execute_epoch(
             // bump the epoch in the Clarity DB
             tx_conn
                 .with_clarity_db(|db| {
-                    db.set_clarity_epoch_version(epoch);
+                    db.set_clarity_epoch_version(epoch).unwrap();
                     Ok(())
                 })
                 .unwrap();
diff --git a/src/clarity_vm/tests/forking.rs b/src/clarity_vm/tests/forking.rs
index 3c18ebb1ef..0278c0a6df 100644
--- a/src/clarity_vm/tests/forking.rs
+++ b/src/clarity_vm/tests/forking.rs
@@ -84,7 +84,7 @@ fn test_at_block_mutations(#[case] version: ClarityVersion, #[case] epoch: Stack
         to_exec: &str,
     ) -> Result<Value> {
         let c = QualifiedContractIdentifier::local("contract").unwrap();
-        let p1 = execute(p1_str).expect_principal();
+        let p1 = execute(p1_str).expect_principal().unwrap();
         let mut placeholder_context =
             ContractContext::new(QualifiedContractIdentifier::transient(), version);
         eprintln!("Branched execution...");
@@ -163,7 +163,7 @@ fn test_at_block_good(#[case] version: ClarityVersion, #[case] epoch: StacksEpoc
         to_exec: &str,
     ) -> Result<Value> {
         let c = QualifiedContractIdentifier::local("contract").unwrap();
-        let p1 = execute(p1_str).expect_principal();
+        let p1 = execute(p1_str).expect_principal().unwrap();
         let mut placeholder_context =
             ContractContext::new(QualifiedContractIdentifier::transient(), version);
         eprintln!("Branched execution...");
diff --git a/src/clarity_vm/tests/large_contract.rs b/src/clarity_vm/tests/large_contract.rs
index 71503d7881..48d0f8e447 100644
--- a/src/clarity_vm/tests/large_contract.rs
+++ b/src/clarity_vm/tests/large_contract.rs
@@ -122,7 +122,7 @@ fn test_simple_token_system(#[case] version: ClarityVersion, #[case] epoch: Stac
 
     gb.as_transaction(|tx| {
         tx.with_clarity_db(|db| {
-            db.set_clarity_epoch_version(epoch);
+            db.set_clarity_epoch_version(epoch).unwrap();
             Ok(())
         })
         .unwrap();
@@ -514,7 +514,7 @@ fn inner_test_simple_naming_system(owned_env: &mut OwnedEnvironment, version: Cl
 
     {
         let mut env = owned_env.get_exec_environment(
-            Some(p2.clone().expect_principal()),
+            Some(p2.clone().expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -533,7 +533,7 @@ fn inner_test_simple_naming_system(owned_env: &mut OwnedEnvironment, version: Cl
 
     {
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal()),
+            Some(p1.clone().expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -561,7 +561,7 @@ fn inner_test_simple_naming_system(owned_env: &mut OwnedEnvironment, version: Cl
     {
         // shouldn't be able to register a name you didn't preorder!
         let mut env = owned_env.get_exec_environment(
-            Some(p2.clone().expect_principal()),
+            Some(p2.clone().expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -580,7 +580,7 @@ fn inner_test_simple_naming_system(owned_env: &mut OwnedEnvironment, version: Cl
     {
         // should work!
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal()),
+            Some(p1.clone().expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -598,7 +598,7 @@ fn inner_test_simple_naming_system(owned_env: &mut OwnedEnvironment, version: Cl
     {
         // try to underpay!
         let mut env = owned_env.get_exec_environment(
-            Some(p2.clone().expect_principal()),
+            Some(p2.clone().expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
diff --git a/src/core/mempool.rs b/src/core/mempool.rs
index aba585044f..5efb762815 100644
--- a/src/core/mempool.rs
+++ b/src/core/mempool.rs
@@ -22,7 +22,6 @@ use std::io::{Read, Write};
 use std::ops::Deref;
 use std::ops::DerefMut;
 use std::path::{Path, PathBuf};
-use std::str::FromStr;
 
 use rand::distributions::Uniform;
 use rand::prelude::Distribution;
@@ -293,51 +292,10 @@ impl MemPoolTxMetadata {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum MemPoolWalkTxTypes {
-    TokenTransfer,
-    SmartContract,
-    ContractCall,
-}
-
-impl FromStr for MemPoolWalkTxTypes {
-    type Err = &'static str;
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s {
-            "TokenTransfer" => {
-                return Ok(Self::TokenTransfer);
-            }
-            "SmartContract" => {
-                return Ok(Self::SmartContract);
-            }
-            "ContractCall" => {
-                return Ok(Self::ContractCall);
-            }
-            _ => {
-                return Err("Unknown mempool tx walk type");
-            }
-        }
-    }
-}
-
-impl MemPoolWalkTxTypes {
-    pub fn all() -> HashSet<MemPoolWalkTxTypes> {
-        [
-            MemPoolWalkTxTypes::TokenTransfer,
-            MemPoolWalkTxTypes::SmartContract,
-            MemPoolWalkTxTypes::ContractCall,
-        ]
-        .into_iter()
-        .collect()
-    }
-
-    pub fn only(selected: &[MemPoolWalkTxTypes]) -> HashSet<MemPoolWalkTxTypes> {
-        selected.iter().map(|x| x.clone()).collect()
-    }
-}
-
 #[derive(Debug, Clone)]
 pub struct MemPoolWalkSettings {
+    /// Minimum transaction fee that will be considered
+    pub min_tx_fee: u64,
     /// Maximum amount of time a miner will spend walking through mempool transactions, in
     /// milliseconds.  This is a soft deadline.
     pub max_walk_time_ms: u64,
@@ -350,43 +308,25 @@ pub struct MemPoolWalkSettings {
     /// Size of the candidate cache. These are the candidates that will be retried after each
     /// transaction is mined.
     pub candidate_retry_cache_size: u64,
-    /// Types of transactions we'll consider
-    pub txs_to_consider: HashSet<MemPoolWalkTxTypes>,
-    /// Origins for transactions that we'll consider
-    pub filter_origins: HashSet<StacksAddress>,
 }
 
 impl MemPoolWalkSettings {
     pub fn default() -> MemPoolWalkSettings {
         MemPoolWalkSettings {
+            min_tx_fee: 1,
             max_walk_time_ms: u64::max_value(),
             consider_no_estimate_tx_prob: 5,
             nonce_cache_size: 1024 * 1024,
             candidate_retry_cache_size: 64 * 1024,
-            txs_to_consider: [
-                MemPoolWalkTxTypes::TokenTransfer,
-                MemPoolWalkTxTypes::SmartContract,
-                MemPoolWalkTxTypes::ContractCall,
-            ]
-            .into_iter()
-            .collect(),
-            filter_origins: HashSet::new(),
         }
     }
     pub fn zero() -> MemPoolWalkSettings {
         MemPoolWalkSettings {
+            min_tx_fee: 0,
             max_walk_time_ms: u64::max_value(),
             consider_no_estimate_tx_prob: 5,
             nonce_cache_size: 1024 * 1024,
             candidate_retry_cache_size: 64 * 1024,
-            txs_to_consider: [
-                MemPoolWalkTxTypes::TokenTransfer,
-                MemPoolWalkTxTypes::SmartContract,
-                MemPoolWalkTxTypes::ContractCall,
-            ]
-            .into_iter()
-            .collect(),
-            filter_origins: HashSet::new(),
         }
     }
 }
@@ -758,8 +698,8 @@ impl<'a> MemPoolTx<'a> {
             let evict_txid = {
                 let num_recents = MemPoolDB::get_num_recent_txs(&dbtx)?;
                 if num_recents >= MAX_BLOOM_COUNTER_TXS.into() {
-                    // remove lowest-fee tx (they're paying the least, so replication is
-                    // deprioritized)
+                    // for now, remove lowest-fee tx in the recent tx set.
+                    // TODO: In the future, do it by lowest fee rate
                     let sql = "SELECT a.txid FROM mempool AS a LEFT OUTER JOIN removed_txids AS b ON a.txid = b.txid WHERE b.txid IS NULL AND a.height > ?1 ORDER BY a.tx_fee ASC LIMIT 1";
                     let args: &[&dyn ToSql] = &[&u64_to_sql(
                         height.saturating_sub(BLOOM_COUNTER_DEPTH as u64),
@@ -1599,49 +1539,6 @@ impl MemPoolDB {
                 }
             };
 
-            let (tx_type, do_consider) = match &tx_info.tx.payload {
-                TransactionPayload::TokenTransfer(..) => (
-                    "TokenTransfer".to_string(),
-                    settings
-                        .txs_to_consider
-                        .contains(&MemPoolWalkTxTypes::TokenTransfer),
-                ),
-                TransactionPayload::SmartContract(..) => (
-                    "SmartContract".to_string(),
-                    settings
-                        .txs_to_consider
-                        .contains(&MemPoolWalkTxTypes::SmartContract),
-                ),
-                TransactionPayload::ContractCall(..) => (
-                    "ContractCall".to_string(),
-                    settings
-                        .txs_to_consider
-                        .contains(&MemPoolWalkTxTypes::ContractCall),
-                ),
-                _ => ("".to_string(), true),
-            };
-            if !do_consider {
-                debug!("Will skip mempool tx, since it does not have an acceptable type";
-                       "txid" => %tx_info.tx.txid(),
-                       "type" => %tx_type);
-                continue;
-            }
-
-            let do_consider = if settings.filter_origins.len() > 0 {
-                settings
-                    .filter_origins
-                    .contains(&tx_info.metadata.origin_address)
-            } else {
-                true
-            };
-
-            if !do_consider {
-                debug!("Will skip mempool tx, since it does not have an allowed origin";
-                       "txid" => %tx_info.tx.txid(),
-                       "origin" => %tx_info.metadata.origin_address);
-                continue;
-            }
-
             let consider = ConsiderTransaction {
                 tx: tx_info,
                 update_estimate,
diff --git a/src/core/tests/mod.rs b/src/core/tests/mod.rs
index 1ad95d781f..3533ce2ad8 100644
--- a/src/core/tests/mod.rs
+++ b/src/core/tests/mod.rs
@@ -42,7 +42,6 @@ use crate::chainstate::stacks::{
 };
 use crate::core::mempool::db_get_all_nonces;
 use crate::core::mempool::MemPoolWalkSettings;
-use crate::core::mempool::MemPoolWalkTxTypes;
 use crate::core::mempool::TxTag;
 use crate::core::mempool::{BLOOM_COUNTER_DEPTH, BLOOM_COUNTER_ERROR_RATE, MAX_BLOOM_COUNTER_TXS};
 use crate::core::FIRST_BURNCHAIN_CONSENSUS_HASH;
@@ -279,7 +278,8 @@ fn mempool_walk_over_fork() {
     //   try to walk at b_4, we should be able to find
     //   the transaction at b_1
 
-    let mempool_settings = MemPoolWalkSettings::default();
+    let mut mempool_settings = MemPoolWalkSettings::default();
+    mempool_settings.min_tx_fee = 10;
     let mut tx_events = Vec::new();
     chainstate.with_read_only_clarity_tx(
         &TEST_BURN_STATE_DB,
@@ -614,6 +614,7 @@ fn test_iterate_candidates_consider_no_estimate_tx_prob() {
     let b_2 = make_block(&mut chainstate, ConsensusHash([0x2; 20]), &b_1, 2, 2);
 
     let mut mempool_settings = MemPoolWalkSettings::default();
+    mempool_settings.min_tx_fee = 10;
     let mut tx_events = Vec::new();
 
     let mut txs = codec_all_transactions(
@@ -808,7 +809,8 @@ fn test_iterate_candidates_skipped_transaction() {
     );
     let b_2 = make_block(&mut chainstate, ConsensusHash([0x2; 20]), &b_1, 2, 2);
 
-    let mempool_settings = MemPoolWalkSettings::default();
+    let mut mempool_settings = MemPoolWalkSettings::default();
+    mempool_settings.min_tx_fee = 10;
     let mut tx_events = Vec::new();
 
     let mut txs = codec_all_transactions(
@@ -920,7 +922,8 @@ fn test_iterate_candidates_processing_error_transaction() {
     );
     let b_2 = make_block(&mut chainstate, ConsensusHash([0x2; 20]), &b_1, 2, 2);
 
-    let mempool_settings = MemPoolWalkSettings::default();
+    let mut mempool_settings = MemPoolWalkSettings::default();
+    mempool_settings.min_tx_fee = 10;
     let mut tx_events = Vec::new();
 
     let mut txs = codec_all_transactions(
@@ -1034,7 +1037,8 @@ fn test_iterate_candidates_problematic_transaction() {
     );
     let b_2 = make_block(&mut chainstate, ConsensusHash([0x2; 20]), &b_1, 2, 2);
 
-    let mempool_settings = MemPoolWalkSettings::default();
+    let mut mempool_settings = MemPoolWalkSettings::default();
+    mempool_settings.min_tx_fee = 10;
     let mut tx_events = Vec::new();
 
     let mut txs = codec_all_transactions(
@@ -1149,6 +1153,7 @@ fn test_iterate_candidates_concurrent_write_lock() {
     let b_2 = make_block(&mut chainstate, ConsensusHash([0x2; 20]), &b_1, 2, 2);
 
     let mut mempool_settings = MemPoolWalkSettings::default();
+    mempool_settings.min_tx_fee = 10;
     let mut tx_events = Vec::new();
 
     let mut txs = codec_all_transactions(
@@ -3008,161 +3013,3 @@ fn test_drop_and_blacklist_txs_by_size() {
 
     assert_eq!(num_blacklisted, 5);
 }
-
-#[test]
-fn test_filter_txs_by_type() {
-    let mut chainstate = instantiate_chainstate(false, 0x80000000, function_name!());
-    let chainstate_path = chainstate_path(function_name!());
-    let mut mempool = MemPoolDB::open_test(false, 0x80000000, &chainstate_path).unwrap();
-
-    let addr = StacksAddress {
-        version: 1,
-        bytes: Hash160([0xff; 20]),
-    };
-    let mut txs = vec![];
-    let block_height = 10;
-    let mut total_len = 0;
-
-    let b_1 = make_block(
-        &mut chainstate,
-        ConsensusHash([0x1; 20]),
-        &(
-            FIRST_BURNCHAIN_CONSENSUS_HASH.clone(),
-            FIRST_STACKS_BLOCK_HASH.clone(),
-        ),
-        1,
-        1,
-    );
-    let b_2 = make_block(&mut chainstate, ConsensusHash([0x2; 20]), &b_1, 2, 2);
-
-    let mut mempool_tx = mempool.tx_begin().unwrap();
-    for i in 0..10 {
-        let pk = StacksPrivateKey::new();
-        let mut tx = StacksTransaction {
-            version: TransactionVersion::Testnet,
-            chain_id: 0x80000000,
-            auth: TransactionAuth::from_p2pkh(&pk).unwrap(),
-            anchor_mode: TransactionAnchorMode::Any,
-            post_condition_mode: TransactionPostConditionMode::Allow,
-            post_conditions: vec![],
-            payload: TransactionPayload::TokenTransfer(
-                addr.to_account_principal(),
-                123,
-                TokenTransferMemo([0u8; 34]),
-            ),
-        };
-        tx.set_tx_fee(1000);
-        tx.set_origin_nonce(0);
-
-        let txid = tx.txid();
-        let tx_bytes = tx.serialize_to_vec();
-        let origin_addr = tx.origin_address();
-        let origin_nonce = tx.get_origin_nonce();
-        let sponsor_addr = tx.sponsor_address().unwrap_or(origin_addr.clone());
-        let sponsor_nonce = tx.get_sponsor_nonce().unwrap_or(origin_nonce);
-        let tx_fee = tx.get_tx_fee();
-
-        total_len += tx_bytes.len();
-
-        // should succeed
-        MemPoolDB::try_add_tx(
-            &mut mempool_tx,
-            &mut chainstate,
-            &b_2.0,
-            &b_2.1,
-            txid.clone(),
-            tx_bytes,
-            tx_fee,
-            block_height as u64,
-            &origin_addr,
-            origin_nonce,
-            &sponsor_addr,
-            sponsor_nonce,
-            None,
-        )
-        .unwrap();
-
-        eprintln!("Added {} {}", i, &txid);
-        txs.push(tx);
-    }
-    mempool_tx.commit().unwrap();
-
-    let mut mempool_settings = MemPoolWalkSettings::default();
-    let mut tx_events = Vec::new();
-    mempool_settings.txs_to_consider = [
-        MemPoolWalkTxTypes::SmartContract,
-        MemPoolWalkTxTypes::ContractCall,
-    ]
-    .into_iter()
-    .collect();
-
-    chainstate.with_read_only_clarity_tx(
-        &TEST_BURN_STATE_DB,
-        &StacksBlockHeader::make_index_block_hash(&b_2.0, &b_2.1),
-        |clarity_conn| {
-            let mut count_txs = 0;
-            mempool
-                .iterate_candidates::<_, ChainstateError, _>(
-                    clarity_conn,
-                    &mut tx_events,
-                    2,
-                    mempool_settings.clone(),
-                    |_, available_tx, _| {
-                        count_txs += 1;
-                        Ok(Some(
-                            // Generate any success result
-                            TransactionResult::success(
-                                &available_tx.tx.tx,
-                                available_tx.tx.metadata.tx_fee,
-                                StacksTransactionReceipt::from_stx_transfer(
-                                    available_tx.tx.tx.clone(),
-                                    vec![],
-                                    Value::okay(Value::Bool(true)).unwrap(),
-                                    ExecutionCost::zero(),
-                                ),
-                            )
-                            .convert_to_event(),
-                        ))
-                    },
-                )
-                .unwrap();
-            assert_eq!(count_txs, 0);
-        },
-    );
-
-    mempool_settings.txs_to_consider = [MemPoolWalkTxTypes::TokenTransfer].into_iter().collect();
-
-    chainstate.with_read_only_clarity_tx(
-        &TEST_BURN_STATE_DB,
-        &StacksBlockHeader::make_index_block_hash(&b_2.0, &b_2.1),
-        |clarity_conn| {
-            let mut count_txs = 0;
-            mempool
-                .iterate_candidates::<_, ChainstateError, _>(
-                    clarity_conn,
-                    &mut tx_events,
-                    2,
-                    mempool_settings.clone(),
-                    |_, available_tx, _| {
-                        count_txs += 1;
-                        Ok(Some(
-                            // Generate any success result
-                            TransactionResult::success(
-                                &available_tx.tx.tx,
-                                available_tx.tx.metadata.tx_fee,
-                                StacksTransactionReceipt::from_stx_transfer(
-                                    available_tx.tx.tx.clone(),
-                                    vec![],
-                                    Value::okay(Value::Bool(true)).unwrap(),
-                                    ExecutionCost::zero(),
-                                ),
-                            )
-                            .convert_to_event(),
-                        ))
-                    },
-                )
-                .unwrap();
-            assert_eq!(count_txs, 10);
-        },
-    );
-}
diff --git a/src/cost_estimates/fee_scalar.rs b/src/cost_estimates/fee_scalar.rs
index 0e19b7a66b..ca252940cb 100644
--- a/src/cost_estimates/fee_scalar.rs
+++ b/src/cost_estimates/fee_scalar.rs
@@ -16,9 +16,6 @@ use crate::util_lib::db::u64_to_sql;
 
 use clarity::vm::costs::ExecutionCost;
 
-use clarity::vm::database::ClaritySerializable;
-use clarity::vm::database::STXBalance;
-
 use crate::chainstate::stacks::db::StacksEpochReceipt;
 use crate::chainstate::stacks::events::TransactionOrigin;
 
@@ -173,25 +170,7 @@ impl<M: CostMetric> FeeEstimator for ScalarFeeRateEstimator<M> {
                 let scalar_cost = match payload {
                     TransactionPayload::TokenTransfer(_, _, _) => {
                         // TokenTransfers *only* contribute tx_len, and just have an empty ExecutionCost.
-                        let stx_balance_len = STXBalance::LockedPoxThree {
-                            amount_unlocked: 1,
-                            amount_locked: 1,
-                            unlock_height: 1,
-                        }
-                        .serialize()
-                        .as_bytes()
-                        .len() as u64;
-                        self.metric.from_cost_and_len(
-                            &ExecutionCost {
-                                write_length: stx_balance_len,
-                                write_count: 1,
-                                read_length: 2 * stx_balance_len,
-                                read_count: 2,
-                                runtime: 4640, // taken from .costs-3
-                            },
-                            &block_limit,
-                            tx_size,
-                        )
+                        self.metric.from_len(tx_size)
                     }
                     TransactionPayload::Coinbase(..) => {
                         // Coinbase txs are "free", so they don't factor into the fee market.
diff --git a/src/main.rs b/src/main.rs
index 6e92a7296c..10ea712cbe 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -770,6 +770,7 @@ simulating a miner.
 
         let mut settings = BlockBuilderSettings::limited();
         settings.max_miner_time_ms = max_time;
+        settings.mempool_settings.min_tx_fee = min_fee;
 
         let result = StacksBlockBuilder::build_anchored_block(
             &chain_state,
diff --git a/src/net/download.rs b/src/net/download.rs
index a94286892b..c08e413533 100644
--- a/src/net/download.rs
+++ b/src/net/download.rs
@@ -3213,6 +3213,7 @@ pub mod test {
                     clarity_tx.with_clarity_db_readonly(|clarity_db| {
                         clarity_db
                             .get_account_nonce(&spending_account.origin_address().unwrap().into())
+                            .unwrap()
                     })
                 })
                 .unwrap()
diff --git a/src/net/http.rs b/src/net/http.rs
index a0a74fefdb..76487c3863 100644
--- a/src/net/http.rs
+++ b/src/net/http.rs
@@ -3038,7 +3038,7 @@ impl HttpRequestType {
             ) => {
                 let mut request_bytes = vec![];
                 key.serialize_write(&mut request_bytes)
-                    .map_err(net_error::WriteError)?;
+                    .map_err(|e| net_error::SerializeError(format!("{e:?}")))?;
                 let request_json = format!("\"{}\"", to_hex(&request_bytes));
 
                 HttpRequestPreamble::new_serialized(
@@ -3069,7 +3069,7 @@ impl HttpRequestType {
                 for arg in func_args.iter() {
                     let mut arg_bytes = vec![];
                     arg.serialize_write(&mut arg_bytes)
-                        .map_err(net_error::WriteError)?;
+                        .map_err(|e| net_error::SerializeError(format!("{e:?}")))?;
                     args.push(to_hex(&arg_bytes));
                 }
 
diff --git a/src/net/mod.rs b/src/net/mod.rs
index fe337f1c31..e2f1bb6e1a 100644
--- a/src/net/mod.rs
+++ b/src/net/mod.rs
@@ -3823,7 +3823,7 @@ pub mod test {
                             parent_microblock_header_opt.as_ref(),
                         );
 
-                    builder.epoch_finish(epoch);
+                    builder.epoch_finish(epoch).unwrap();
                     (stacks_block, microblocks)
                 },
             );
diff --git a/src/net/relay.rs b/src/net/relay.rs
index fa699fe6f1..9a7d3bb03a 100644
--- a/src/net/relay.rs
+++ b/src/net/relay.rs
@@ -3692,9 +3692,11 @@ pub mod test {
                         .chainstate
                         .with_read_only_clarity_tx(&sortdb.index_conn(), &chain_tip, |clarity_tx| {
                             clarity_tx.with_clarity_db_readonly(|clarity_db| {
-                                clarity_db.get_account_nonce(
-                                    &spending_account.origin_address().unwrap().into(),
-                                )
+                                clarity_db
+                                    .get_account_nonce(
+                                        &spending_account.origin_address().unwrap().into(),
+                                    )
+                                    .unwrap()
                             })
                         })
                         .unwrap();
diff --git a/src/net/rpc.rs b/src/net/rpc.rs
index 24a2136625..55992158e8 100644
--- a/src/net/rpc.rs
+++ b/src/net/rpc.rs
@@ -339,57 +339,69 @@ impl RPCPoxInfoData {
             .map_err(|_| net_error::NotFoundError)?;
 
         let res = match data {
-            Some(Ok(res)) => res.expect_result_ok().expect_tuple(),
+            Some(Ok(res)) => res
+                .expect_result_ok()
+                .map_err(|e| net_error::ClarityError(e.into()))?
+                .expect_tuple()
+                .map_err(|e| net_error::ClarityError(e.into()))?,
             _ => return Err(net_error::DBError(db_error::NotFoundError)),
         };
 
-        let first_burnchain_block_height = res
-            .get("first-burnchain-block-height")
-            .expect(&format!("FATAL: no 'first-burnchain-block-height'"))
-            .to_owned()
-            .expect_u128() as u64;
-
-        let min_stacking_increment_ustx = res
-            .get("min-amount-ustx")
-            .expect(&format!("FATAL: no 'min-amount-ustx'"))
-            .to_owned()
-            .expect_u128() as u64;
-
-        let prepare_cycle_length = res
-            .get("prepare-cycle-length")
-            .expect(&format!("FATAL: no 'prepare-cycle-length'"))
-            .to_owned()
-            .expect_u128() as u64;
-
-        let rejection_fraction = res
-            .get("rejection-fraction")
-            .expect(&format!("FATAL: no 'rejection-fraction'"))
-            .to_owned()
-            .expect_u128() as u64;
+        let first_burnchain_block_height =
+            res.get("first-burnchain-block-height")
+                .expect(&format!("FATAL: no 'first-burnchain-block-height'"))
+                .to_owned()
+                .expect_u128()
+                .map_err(|e| net_error::ClarityError(e.into()))? as u64;
+
+        let min_stacking_increment_ustx =
+            res.get("min-amount-ustx")
+                .expect(&format!("FATAL: no 'min-amount-ustx'"))
+                .to_owned()
+                .expect_u128()
+                .map_err(|e| net_error::ClarityError(e.into()))? as u64;
+
+        let prepare_cycle_length =
+            res.get("prepare-cycle-length")
+                .expect(&format!("FATAL: no 'prepare-cycle-length'"))
+                .to_owned()
+                .expect_u128()
+                .map_err(|e| net_error::ClarityError(e.into()))? as u64;
+
+        let rejection_fraction =
+            res.get("rejection-fraction")
+                .expect(&format!("FATAL: no 'rejection-fraction'"))
+                .to_owned()
+                .expect_u128()
+                .map_err(|e| net_error::ClarityError(e.into()))? as u64;
 
         let reward_cycle_id = res
             .get("reward-cycle-id")
             .expect(&format!("FATAL: no 'reward-cycle-id'"))
             .to_owned()
-            .expect_u128() as u64;
-
-        let reward_cycle_length = res
-            .get("reward-cycle-length")
-            .expect(&format!("FATAL: no 'reward-cycle-length'"))
-            .to_owned()
-            .expect_u128() as u64;
-
-        let current_rejection_votes = res
-            .get("current-rejection-votes")
-            .expect(&format!("FATAL: no 'current-rejection-votes'"))
-            .to_owned()
-            .expect_u128() as u64;
-
-        let total_liquid_supply_ustx = res
-            .get("total-liquid-supply-ustx")
-            .expect(&format!("FATAL: no 'total-liquid-supply-ustx'"))
-            .to_owned()
-            .expect_u128() as u64;
+            .expect_u128()
+            .map_err(|e| net_error::ClarityError(e.into()))? as u64;
+
+        let reward_cycle_length =
+            res.get("reward-cycle-length")
+                .expect(&format!("FATAL: no 'reward-cycle-length'"))
+                .to_owned()
+                .expect_u128()
+                .map_err(|e| net_error::ClarityError(e.into()))? as u64;
+
+        let current_rejection_votes =
+            res.get("current-rejection-votes")
+                .expect(&format!("FATAL: no 'current-rejection-votes'"))
+                .to_owned()
+                .expect_u128()
+                .map_err(|e| net_error::ClarityError(e.into()))? as u64;
+
+        let total_liquid_supply_ustx =
+            res.get("total-liquid-supply-ustx")
+                .expect(&format!("FATAL: no 'total-liquid-supply-ustx'"))
+                .to_owned()
+                .expect_u128()
+                .map_err(|e| net_error::ClarityError(e.into()))? as u64;
 
         let total_required = (total_liquid_supply_ustx as u128 / 100)
             .checked_mul(rejection_fraction as u128)
@@ -1273,17 +1285,22 @@ impl ConversationHttp {
             match chainstate.maybe_read_only_clarity_tx(&sortdb.index_conn(), tip, |clarity_tx| {
                 clarity_tx.with_clarity_db_readonly(|clarity_db| {
                     let key = ClarityDatabase::make_key_for_account_balance(&account);
-                    let burn_block_height = clarity_db.get_current_burnchain_block_height() as u64;
+                    let burn_block_height =
+                        clarity_db.get_current_burnchain_block_height().ok()? as u64;
                     let v1_unlock_height = clarity_db.get_v1_unlock_height();
-                    let v2_unlock_height = clarity_db.get_v2_unlock_height();
+                    let v2_unlock_height = clarity_db.get_v2_unlock_height().ok()?;
                     let (balance, balance_proof) = if with_proof {
                         clarity_db
                             .get_with_proof::<STXBalance>(&key)
+                            .ok()
+                            .flatten()
                             .map(|(a, b)| (a, Some(format!("0x{}", to_hex(&b)))))
                             .unwrap_or_else(|| (STXBalance::zero(), Some("".into())))
                     } else {
                         clarity_db
                             .get::<STXBalance>(&key)
+                            .ok()
+                            .flatten()
                             .map(|a| (a, None))
                             .unwrap_or_else(|| (STXBalance::zero(), None))
                     };
@@ -1292,20 +1309,26 @@ impl ConversationHttp {
                     let (nonce, nonce_proof) = if with_proof {
                         clarity_db
                             .get_with_proof(&key)
+                            .ok()
+                            .flatten()
                             .map(|(a, b)| (a, Some(format!("0x{}", to_hex(&b)))))
                             .unwrap_or_else(|| (0, Some("".into())))
                     } else {
                         clarity_db
                             .get(&key)
+                            .ok()
+                            .flatten()
                             .map(|a| (a, None))
                             .unwrap_or_else(|| (0, None))
                     };
 
-                    let unlocked = balance.get_available_balance_at_burn_block(
-                        burn_block_height,
-                        v1_unlock_height,
-                        v2_unlock_height,
-                    );
+                    let unlocked = balance
+                        .get_available_balance_at_burn_block(
+                            burn_block_height,
+                            v1_unlock_height,
+                            v2_unlock_height,
+                        )
+                        .ok()?;
                     let (locked, unlock_height) = balance.get_locked_balance_at_burn_block(
                         burn_block_height,
                         v1_unlock_height,
@@ -1315,18 +1338,18 @@ impl ConversationHttp {
                     let balance = format!("0x{}", to_hex(&unlocked.to_be_bytes()));
                     let locked = format!("0x{}", to_hex(&locked.to_be_bytes()));
 
-                    AccountEntryResponse {
+                    Some(AccountEntryResponse {
                         balance,
                         locked,
                         unlock_height,
                         nonce,
                         balance_proof,
                         nonce_proof,
-                    }
+                    })
                 })
             }) {
-                Ok(Some(data)) => HttpResponseType::GetAccount(response_metadata, data),
-                Ok(None) | Err(_) => {
+                Ok(Some(Some(data))) => HttpResponseType::GetAccount(response_metadata, data),
+                Ok(None) | Ok(Some(None)) | Err(_) => {
                     HttpResponseType::NotFound(response_metadata, "Chain tip not found".into())
                 }
             };
@@ -1366,9 +1389,11 @@ impl ConversationHttp {
                     let (value_hex, marf_proof): (String, _) = if with_proof {
                         clarity_db
                             .get_with_proof(&key)
+                            .ok()
+                            .flatten()
                             .map(|(a, b)| (a, Some(format!("0x{}", to_hex(&b)))))?
                     } else {
-                        clarity_db.get(&key).map(|a| (a, None))?
+                        clarity_db.get(&key).ok().flatten().map(|a| (a, None))?
                     };
 
                     let data = format!("0x{}", value_hex);
@@ -1408,27 +1433,35 @@ impl ConversationHttp {
         let contract_identifier =
             QualifiedContractIdentifier::new(contract_addr.clone().into(), contract_name.clone());
 
+        let none_response = Value::none()
+            .serialize_to_hex()
+            .map_err(|e| net_error::SerializeError(format!("{e:?}")))?;
+        let key = ClarityDatabase::make_key_for_data_map_entry(&contract_identifier, map_name, key)
+            .map_err(|e| net_error::SerializeError(format!("{e:?}")))?;
+
         let response =
             match chainstate.maybe_read_only_clarity_tx(&sortdb.index_conn(), tip, |clarity_tx| {
                 clarity_tx.with_clarity_db_readonly(|clarity_db| {
-                    let key = ClarityDatabase::make_key_for_data_map_entry(
-                        &contract_identifier,
-                        map_name,
-                        key,
-                    );
                     let (value_hex, marf_proof): (String, _) = if with_proof {
                         clarity_db
                             .get_with_proof(&key)
+                            .ok()
+                            .flatten()
                             .map(|(a, b)| (a, Some(format!("0x{}", to_hex(&b)))))
                             .unwrap_or_else(|| {
                                 test_debug!("No value for '{}' in {}", &key, tip);
-                                (Value::none().serialize_to_hex(), Some("".into()))
+                                (none_response, Some("".into()))
                             })
                     } else {
-                        clarity_db.get(&key).map(|a| (a, None)).unwrap_or_else(|| {
-                            test_debug!("No value for '{}' in {}", &key, tip);
-                            (Value::none().serialize_to_hex(), None)
-                        })
+                        clarity_db
+                            .get(&key)
+                            .ok()
+                            .flatten()
+                            .map(|a| (a, None))
+                            .unwrap_or_else(|| {
+                                test_debug!("No value for '{}' in {}", &key, tip);
+                                (none_response, None)
+                            })
                     };
 
                     let data = format!("0x{}", value_hex);
@@ -1521,14 +1554,20 @@ impl ConversationHttp {
             });
 
         let response = match data_opt_res {
-            Ok(Some(Ok(data))) => HttpResponseType::CallReadOnlyFunction(
-                response_metadata,
-                CallReadOnlyResponse {
-                    okay: true,
-                    result: Some(format!("0x{}", data.serialize_to_hex())),
-                    cause: None,
-                },
-            ),
+            Ok(Some(Ok(data))) => {
+                let hex_result = data
+                    .serialize_to_hex()
+                    .map_err(|e| net_error::SerializeError(format!("{e:?}")))?;
+
+                HttpResponseType::CallReadOnlyFunction(
+                    response_metadata,
+                    CallReadOnlyResponse {
+                        okay: true,
+                        result: Some(format!("0x{hex_result}")),
+                        cause: None,
+                    },
+                )
+            }
             Ok(Some(Err(e))) => match e {
                 Unchecked(CheckErrors::CostBalanceExceeded(actual_cost, _))
                     if actual_cost.write_count > 0 =>
@@ -1584,12 +1623,14 @@ impl ConversationHttp {
                     let contract_commit_key = make_contract_hash_key(&contract_identifier);
                     let (contract_commit, proof) = if with_proof {
                         db.get_with_proof::<ContractCommitment>(&contract_commit_key)
-                            .map(|(a, b)| (a, Some(format!("0x{}", to_hex(&b)))))
-                            .expect("BUG: obtained source, but couldn't get contract commit")
+                            .ok()
+                            .flatten()
+                            .map(|(a, b)| (a, Some(format!("0x{}", to_hex(&b)))))?
                     } else {
                         db.get::<ContractCommitment>(&contract_commit_key)
-                            .map(|a| (a, None))
-                            .expect("BUG: obtained source, but couldn't get contract commit")
+                            .ok()
+                            .flatten()
+                            .map(|a| (a, None))?
                     };
 
                     let publish_height = contract_commit.block_height;
@@ -1634,19 +1675,24 @@ impl ConversationHttp {
         let response =
             match chainstate.maybe_read_only_clarity_tx(&sortdb.index_conn(), tip, |clarity_tx| {
                 clarity_tx.with_clarity_db_readonly(|db| {
-                    let analysis = db.load_contract_analysis(&contract_identifier)?;
+                    let analysis = db
+                        .load_contract_analysis(&contract_identifier)
+                        .ok()
+                        .flatten()?;
                     if analysis.implemented_traits.contains(trait_id) {
                         Some(GetIsTraitImplementedResponse {
                             is_implemented: true,
                         })
                     } else {
-                        let trait_defining_contract =
-                            db.load_contract_analysis(&trait_id.contract_identifier)?;
+                        let trait_defining_contract = db
+                            .load_contract_analysis(&trait_id.contract_identifier)
+                            .ok()
+                            .flatten()?;
                         let trait_definition =
                             trait_defining_contract.get_defined_trait(&trait_id.name)?;
                         let is_implemented = analysis
                             .check_trait_compliance(
-                                &db.get_clarity_epoch_version(),
+                                &db.get_clarity_epoch_version().ok()?,
                                 trait_id,
                                 trait_definition,
                             )
@@ -1695,7 +1741,10 @@ impl ConversationHttp {
             match chainstate.maybe_read_only_clarity_tx(&sortdb.index_conn(), tip, |clarity_tx| {
                 let epoch = clarity_tx.get_epoch();
                 clarity_tx.with_analysis_db_readonly(|db| {
-                    let contract = db.load_contract(&contract_identifier, &epoch)?;
+                    let contract = db
+                        .load_contract(&contract_identifier, &epoch)
+                        .ok()
+                        .flatten()?;
                     contract.contract_interface
                 })
             }) {
diff --git a/testnet/stacks-node/Cargo.toml b/testnet/stacks-node/Cargo.toml
index 043d929c84..c36a27fb93 100644
--- a/testnet/stacks-node/Cargo.toml
+++ b/testnet/stacks-node/Cargo.toml
@@ -8,7 +8,7 @@ rust-version = "1.61"
 
 [dependencies]
 lazy_static = "1.4.0"
-pico-args = "0.5.0"
+pico-args = "0.3.1"
 rand = "0.7.3"
 serde = "1"
 serde_derive = "1"
@@ -21,7 +21,7 @@ async-std = { version = "1.6", features = ["attributes"] }
 http-types = "2.12"
 base64 = "0.12.0"
 backtrace = "0.3.50"
-libc = "0.2.151"
+libc = "0.2"
 slog = { version = "2.5.2", features = [ "max_level_trace" ] }
 clarity = { package = "clarity", path = "../../clarity/." }
 stacks_common = { package = "stacks-common", path = "../../stacks-common/." }
diff --git a/testnet/stacks-node/conf/testnet-follower-conf.toml b/testnet/stacks-node/conf/testnet-follower-conf.toml
index cb23477b27..6872666a2c 100644
--- a/testnet/stacks-node/conf/testnet-follower-conf.toml
+++ b/testnet/stacks-node/conf/testnet-follower-conf.toml
@@ -2,7 +2,7 @@
 # working_dir = "/dir/to/save/chainstate"
 rpc_bind = "0.0.0.0:20443"
 p2p_bind = "0.0.0.0:20444"
-bootstrap_node = "029266faff4c8e0ca4f934f34996a96af481df94a89b0c9bd515f3536a95682ddc@seed.testnet.hiro.so:30444"
+bootstrap_node = "029266faff4c8e0ca4f934f34996a96af481df94a89b0c9bd515f3536a95682ddc@seed.testnet.hiro.so:20444"
 wait_time_for_microblocks = 10000
 
 [burnchain]
diff --git a/testnet/stacks-node/conf/testnet-miner-conf.toml b/testnet/stacks-node/conf/testnet-miner-conf.toml
index ca52b33a23..379cbd3822 100644
--- a/testnet/stacks-node/conf/testnet-miner-conf.toml
+++ b/testnet/stacks-node/conf/testnet-miner-conf.toml
@@ -5,7 +5,7 @@ p2p_bind = "0.0.0.0:20444"
 seed = "<YOUR_SEED>"
 local_peer_seed = "<YOUR_SEED>"
 miner = true
-bootstrap_node = "029266faff4c8e0ca4f934f34996a96af481df94a89b0c9bd515f3536a95682ddc@seed.testnet.hiro.so:30444"
+bootstrap_node = "029266faff4c8e0ca4f934f34996a96af481df94a89b0c9bd515f3536a95682ddc@seed.testnet.hiro.so:20444"
 wait_time_for_microblocks = 10000
 
 [burnchain]
diff --git a/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs b/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
index 86521e9ced..8b23d48c1f 100644
--- a/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
+++ b/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
@@ -162,18 +162,6 @@ pub fn make_bitcoin_indexer(config: &Config) -> BitcoinIndexer {
     burnchain_indexer
 }
 
-pub fn get_satoshis_per_byte(config: &Config) -> u64 {
-    config.get_burnchain_config().satoshis_per_byte
-}
-
-pub fn get_rbf_fee_increment(config: &Config) -> u64 {
-    config.get_burnchain_config().rbf_fee_increment
-}
-
-pub fn get_max_rbf(config: &Config) -> u64 {
-    config.get_burnchain_config().max_rbf
-}
-
 impl LeaderBlockCommitFees {
     pub fn fees_from_previous_tx(
         &self,
@@ -183,7 +171,7 @@ impl LeaderBlockCommitFees {
         let mut fees = LeaderBlockCommitFees::estimated_fees_from_payload(payload, config);
         fees.spent_in_attempts = cmp::max(1, self.spent_in_attempts);
         fees.final_size = self.final_size;
-        fees.fee_rate = self.fee_rate + get_rbf_fee_increment(&config);
+        fees.fee_rate = self.fee_rate + config.burnchain.rbf_fee_increment;
         fees.is_rbf_enabled = true;
         fees
     }
@@ -202,7 +190,7 @@ impl LeaderBlockCommitFees {
         let value_per_transfer = payload.burn_fee / number_of_transfers;
         let sortition_fee = value_per_transfer * number_of_transfers;
         let spent_in_attempts = 0;
-        let fee_rate = get_satoshis_per_byte(&config);
+        let fee_rate = config.burnchain.satoshis_per_byte;
         let default_tx_size = config.burnchain.block_commit_tx_estimated_size;
 
         LeaderBlockCommitFees {
@@ -814,9 +802,8 @@ impl BitcoinRegtestController {
     ) -> Option<Transaction> {
         let public_key = signer.get_public_key();
 
-        // reload the config to find satoshis_per_byte changes
         let btc_miner_fee = self.config.burnchain.leader_key_tx_estimated_size
-            * get_satoshis_per_byte(&self.config);
+            * self.config.burnchain.satoshis_per_byte;
         let budget_for_outputs = DUST_UTXO_LIMIT;
         let total_required = btc_miner_fee + budget_for_outputs;
 
@@ -844,7 +831,7 @@ impl BitcoinRegtestController {
 
         tx.output = vec![consensus_output];
 
-        let fee_rate = get_satoshis_per_byte(&self.config);
+        let fee_rate = self.config.burnchain.satoshis_per_byte;
 
         self.finalize_tx(
             epoch_id,
@@ -938,6 +925,7 @@ impl BitcoinRegtestController {
     ) -> Option<Transaction> {
         let public_key = signer.get_public_key();
         let max_tx_size = 230;
+
         let (mut tx, mut utxos) = if let Some(utxo) = utxo_to_use {
             (
                 Transaction {
@@ -955,7 +943,7 @@ impl BitcoinRegtestController {
             self.prepare_tx(
                 epoch_id,
                 &public_key,
-                DUST_UTXO_LIMIT + max_tx_size * get_satoshis_per_byte(&self.config),
+                DUST_UTXO_LIMIT + max_tx_size * self.config.burnchain.satoshis_per_byte,
                 None,
                 None,
                 0,
@@ -989,7 +977,7 @@ impl BitcoinRegtestController {
             DUST_UTXO_LIMIT,
             0,
             max_tx_size,
-            get_satoshis_per_byte(&self.config),
+            self.config.burnchain.satoshis_per_byte,
             &mut utxos,
             signer,
         )?;
@@ -1038,7 +1026,7 @@ impl BitcoinRegtestController {
             self.prepare_tx(
                 epoch_id,
                 &public_key,
-                DUST_UTXO_LIMIT + max_tx_size * get_satoshis_per_byte(&self.config),
+                DUST_UTXO_LIMIT + max_tx_size * self.config.burnchain.satoshis_per_byte,
                 None,
                 None,
                 0,
@@ -1072,7 +1060,7 @@ impl BitcoinRegtestController {
             DUST_UTXO_LIMIT,
             0,
             max_tx_size,
-            get_satoshis_per_byte(&self.config),
+            self.config.burnchain.satoshis_per_byte,
             &mut utxos,
             signer,
         )?;
@@ -1107,7 +1095,7 @@ impl BitcoinRegtestController {
         let public_key = signer.get_public_key();
         let max_tx_size = 280;
 
-        let output_amt = DUST_UTXO_LIMIT + max_tx_size * get_satoshis_per_byte(&self.config);
+        let output_amt = DUST_UTXO_LIMIT + max_tx_size * self.config.burnchain.satoshis_per_byte;
         let (mut tx, mut utxos) =
             self.prepare_tx(epoch_id, &public_key, output_amt, None, None, 0)?;
 
@@ -1136,7 +1124,7 @@ impl BitcoinRegtestController {
             output_amt,
             0,
             max_tx_size,
-            get_satoshis_per_byte(&self.config),
+            self.config.burnchain.satoshis_per_byte,
             &mut utxos,
             signer,
         )?;
@@ -1334,11 +1322,11 @@ impl BitcoinRegtestController {
 
         // Stop as soon as the fee_rate is ${self.config.burnchain.max_rbf} percent higher, stop RBF
         if ongoing_op.fees.fee_rate
-            > (get_satoshis_per_byte(&self.config) * get_max_rbf(&self.config) / 100)
+            > (self.config.burnchain.satoshis_per_byte * self.config.burnchain.max_rbf / 100)
         {
             warn!(
                 "RBF'd block commits reached {}% satoshi per byte fee rate, not resubmitting",
-                get_max_rbf(&self.config)
+                self.config.burnchain.max_rbf
             );
             self.ongoing_block_commit = Some(ongoing_op);
             return None;
@@ -2501,31 +2489,3 @@ impl BitcoinRPCRequest {
         Ok(payload)
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use crate::config::DEFAULT_SATS_PER_VB;
-
-    use super::*;
-    use std::env::temp_dir;
-    use std::fs::File;
-    use std::io::Write;
-
-    #[test]
-    fn test_get_satoshis_per_byte() {
-        let dir = temp_dir();
-        let file_path = dir.as_path().join("config.toml");
-
-        let mut config = Config::default();
-
-        let satoshis_per_byte = get_satoshis_per_byte(&config);
-        assert_eq!(satoshis_per_byte, DEFAULT_SATS_PER_VB);
-
-        let mut file = File::create(&file_path).unwrap();
-        writeln!(file, "[burnchain]").unwrap();
-        writeln!(file, "satoshis_per_byte = 51").unwrap();
-        config.config_path = Some(file_path.to_str().unwrap().to_string());
-
-        assert_eq!(get_satoshis_per_byte(&config), 51);
-    }
-}
diff --git a/testnet/stacks-node/src/chain_data.rs b/testnet/stacks-node/src/chain_data.rs
deleted file mode 100644
index bd9e9e6173..0000000000
--- a/testnet/stacks-node/src/chain_data.rs
+++ /dev/null
@@ -1,1105 +0,0 @@
-// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
-// Copyright (C) 2020-2023 Stacks Open Internet Foundation
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-use std::collections::HashMap;
-use std::process::Command;
-use std::process::Stdio;
-
-use stacks::chainstate::burn::db::sortdb::SortitionDB;
-use stacks::chainstate::burn::db::sortdb::SortitionHandle;
-use stacks::chainstate::burn::distribution::BurnSamplePoint;
-use stacks::chainstate::burn::operations::leader_block_commit::{
-    MissedBlockCommit, BURN_BLOCK_MINED_AT_MODULUS,
-};
-use stacks::chainstate::burn::operations::LeaderBlockCommitOp;
-use stacks::chainstate::stacks::address::PoxAddress;
-
-use stacks::burnchains::bitcoin::address::BitcoinAddress;
-use stacks::burnchains::bitcoin::BitcoinNetworkType;
-use stacks::burnchains::bitcoin::BitcoinTxOutput;
-use stacks::burnchains::Burnchain;
-use stacks::burnchains::BurnchainSigner;
-use stacks::burnchains::Txid;
-use stacks_common::types::chainstate::BlockHeaderHash;
-use stacks_common::types::chainstate::BurnchainHeaderHash;
-use stacks_common::types::chainstate::VRFSeed;
-use stacks_common::util::hash::hex_bytes;
-
-use stacks::core::MINING_COMMITMENT_WINDOW;
-
-use stacks::util_lib::db::Error as DBError;
-
-use stacks::burnchains::Error as BurnchainError;
-
-pub struct MinerStats {
-    pub unconfirmed_commits_helper: String,
-}
-
-/// Unconfirmed block-commit transaction as emitted by our helper
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-struct UnconfirmedBlockCommit {
-    /// burnchain signer
-    address: String,
-    /// PoX payouts
-    pox_addrs: Vec<String>,
-    /// UTXO spent to create this block-commit
-    input_index: u32,
-    input_txid: String,
-    /// transaction ID
-    txid: String,
-    /// amount spent
-    burn: u64,
-}
-
-const DEADBEEF: [u8; 32] = [
-    0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef,
-    0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef,
-];
-
-impl MinerStats {
-    /// Find the burn distribution for a single sortition's block-commits and missed-commits
-    fn get_burn_distribution<SH: SortitionHandle>(
-        sort_handle: &mut SH,
-        burnchain: &Burnchain,
-        burn_block_height: u64,
-        block_commits: Vec<LeaderBlockCommitOp>,
-        missed_commits: Vec<MissedBlockCommit>,
-    ) -> Result<Vec<BurnSamplePoint>, BurnchainError> {
-        // assemble the commit windows
-        let mut windowed_block_commits = vec![block_commits];
-        let mut windowed_missed_commits = vec![];
-
-        if !burnchain.is_in_prepare_phase(burn_block_height) {
-            // PoX reward-phase is active!
-            // build a map of intended sortition -> missed commit for the missed commits
-            //   discovered in this block.
-            let mut missed_commits_map: HashMap<_, Vec<_>> = HashMap::new();
-            for missed in missed_commits.iter() {
-                if let Some(commits_at_sortition) =
-                    missed_commits_map.get_mut(&missed.intended_sortition)
-                {
-                    commits_at_sortition.push(missed);
-                } else {
-                    missed_commits_map.insert(missed.intended_sortition.clone(), vec![missed]);
-                }
-            }
-
-            for blocks_back in 0..(MINING_COMMITMENT_WINDOW - 1) {
-                if burn_block_height.saturating_sub(1) < (blocks_back as u64) {
-                    debug!("Mining commitment window shortened because block height is less than window size";
-                           "block_height" => %burn_block_height.saturating_sub(1),
-                           "window_size" => %MINING_COMMITMENT_WINDOW);
-                    break;
-                }
-                let block_height = (burn_block_height.saturating_sub(1)) - (blocks_back as u64);
-                let sortition_id = match sort_handle.get_block_snapshot_by_height(block_height)? {
-                    Some(sn) => sn.sortition_id,
-                    None => break,
-                };
-                windowed_block_commits.push(SortitionDB::get_block_commits_by_block(
-                    sort_handle.sqlite(),
-                    &sortition_id,
-                )?);
-                let mut missed_commits_at_height = SortitionDB::get_missed_commits_by_intended(
-                    sort_handle.sqlite(),
-                    &sortition_id,
-                )?;
-                if let Some(missed_commit_in_block) = missed_commits_map.remove(&sortition_id) {
-                    missed_commits_at_height
-                        .extend(missed_commit_in_block.into_iter().map(|x| x.clone()));
-                }
-
-                windowed_missed_commits.push(missed_commits_at_height);
-            }
-        } else {
-            // PoX reward-phase is not active
-            debug!(
-                "Block {} is in a prepare phase or post-PoX sunset, so no windowing will take place",
-                burn_block_height;
-            );
-
-            assert_eq!(windowed_block_commits.len(), 1);
-            assert_eq!(windowed_missed_commits.len(), 0);
-        }
-
-        // reverse vecs so that windows are in ascending block height order
-        windowed_block_commits.reverse();
-        windowed_missed_commits.reverse();
-
-        // figure out if the PoX sunset finished during the window,
-        // and/or which sortitions must be PoB due to them falling in a prepare phase.
-        let window_end_height = burn_block_height;
-        let window_start_height = window_end_height + 1 - (windowed_block_commits.len() as u64);
-        let mut burn_blocks = vec![false; windowed_block_commits.len()];
-
-        // set burn_blocks flags to accomodate prepare phases and PoX sunset
-        for (i, b) in burn_blocks.iter_mut().enumerate() {
-            if burnchain.is_in_prepare_phase(window_start_height + (i as u64)) {
-                // must burn
-                *b = true;
-            } else {
-                // must not burn
-                *b = false;
-            }
-        }
-
-        // not all commits in windowed_block_commits have been confirmed, so make sure that they
-        // are in the right order
-        let mut block_height_at_index = None;
-        for (index, commits) in windowed_block_commits.iter_mut().enumerate() {
-            let index = index as u64;
-            for commit in commits.iter_mut() {
-                if let Some((first_block_height, first_index)) = block_height_at_index {
-                    if commit.block_height != first_block_height + (index - first_index) {
-                        commit.block_height = first_block_height + (index - first_index);
-                    }
-                } else {
-                    block_height_at_index = Some((commit.block_height, index));
-                }
-            }
-        }
-
-        // calculate the burn distribution from these operations.
-        // The resulting distribution will contain the user burns that match block commits
-        let burn_dist = BurnSamplePoint::make_min_median_distribution(
-            windowed_block_commits,
-            windowed_missed_commits,
-            burn_blocks,
-        );
-
-        Ok(burn_dist)
-    }
-
-    fn fmt_bin_args(bin: &str, args: &[&str]) -> String {
-        let mut all = Vec::with_capacity(1 + args.len());
-        all.push(bin);
-        for arg in args {
-            all.push(arg);
-        }
-        all.join(" ")
-    }
-
-    /// Returns (exit code, stdout, stderr)
-    fn run_subprocess(
-        bin_fullpath: &str,
-        args: &[&str],
-    ) -> Result<(i32, Vec<u8>, Vec<u8>), String> {
-        let full_args = Self::fmt_bin_args(bin_fullpath, args);
-        let mut cmd = Command::new(bin_fullpath);
-        cmd.stdin(Stdio::piped())
-            .stdout(Stdio::piped())
-            .stderr(Stdio::piped())
-            .args(args);
-
-        debug!("Run: `{:?}`", &cmd);
-
-        let output = cmd
-            .spawn()
-            .map_err(|e| format!("Failed to run `{}`: {:?}", &full_args, &e))?
-            .wait_with_output()
-            .map_err(|ioe| format!("Failed to run `{}`: {:?}", &full_args, &ioe))?;
-
-        let exit_code = match output.status.code() {
-            Some(code) => code,
-            None => {
-                // failed due to signal
-                return Err(format!("Failed to run `{}`: killed by signal", &full_args));
-            }
-        };
-
-        Ok((exit_code, output.stdout, output.stderr))
-    }
-
-    /// Get the list of all unconfirmed block-commits.
-    pub fn get_unconfirmed_commits(
-        &self,
-        next_block_height: u64,
-        all_miners: &[&str],
-    ) -> Result<Vec<LeaderBlockCommitOp>, String> {
-        let (exit_code, stdout, _stderr) =
-            Self::run_subprocess(&self.unconfirmed_commits_helper, &all_miners)?;
-        if exit_code != 0 {
-            return Err(format!(
-                "Failed to run `{}`: exit code {}",
-                &self.unconfirmed_commits_helper, exit_code
-            ));
-        }
-
-        // decode stdout to JSON
-        let unconfirmed_commits: Vec<UnconfirmedBlockCommit> = serde_json::from_slice(&stdout)
-            .map_err(|e| {
-                format!(
-                    "Failed to decode output from `{}`: {:?}. Output was `{}`",
-                    &self.unconfirmed_commits_helper,
-                    &e,
-                    String::from_utf8_lossy(&stdout)
-                )
-            })?;
-
-        let mut unconfirmed_spends = vec![];
-        for unconfirmed_commit in unconfirmed_commits.into_iter() {
-            let Ok(txid) = Txid::from_hex(&unconfirmed_commit.txid) else {
-                return Err(format!("Not a valid txid: `{}`", &unconfirmed_commit.txid));
-            };
-            let Ok(input_txid) = Txid::from_hex(&unconfirmed_commit.input_txid) else {
-                return Err(format!(
-                    "Not a valid txid: `{}`",
-                    &unconfirmed_commit.input_txid
-                ));
-            };
-            let mut decoded_pox_addrs = vec![];
-            for pox_addr_hex in unconfirmed_commit.pox_addrs.iter() {
-                let Ok(pox_addr_bytes) = hex_bytes(&pox_addr_hex) else {
-                    return Err(format!("Not a hex string: `{}`", &pox_addr_hex));
-                };
-                let Some(bitcoin_addr) =
-                    BitcoinAddress::from_scriptpubkey(BitcoinNetworkType::Mainnet, &pox_addr_bytes)
-                else {
-                    return Err(format!(
-                        "Not a recognized Bitcoin scriptpubkey: {}",
-                        &pox_addr_hex
-                    ));
-                };
-                let Some(pox_addr) = PoxAddress::try_from_bitcoin_output(&BitcoinTxOutput {
-                    address: bitcoin_addr.clone(),
-                    units: 1,
-                }) else {
-                    return Err(format!("Not a recognized PoX address: {}", &bitcoin_addr));
-                };
-                decoded_pox_addrs.push(pox_addr);
-            }
-
-            // mocked commit
-            let mocked_commit = LeaderBlockCommitOp {
-                sunset_burn: 0,
-                block_header_hash: BlockHeaderHash(DEADBEEF.clone()),
-                new_seed: VRFSeed(DEADBEEF.clone()),
-                parent_block_ptr: 1,
-                parent_vtxindex: 1,
-                key_block_ptr: 1,
-                key_vtxindex: 1,
-                memo: vec![],
-                commit_outs: decoded_pox_addrs,
-                burn_fee: unconfirmed_commit.burn,
-                input: (input_txid, unconfirmed_commit.input_index),
-                apparent_sender: BurnchainSigner(unconfirmed_commit.address),
-                txid,
-                vtxindex: 1,
-                block_height: next_block_height,
-                burn_parent_modulus: ((next_block_height.saturating_sub(1))
-                    % BURN_BLOCK_MINED_AT_MODULUS) as u8,
-                burn_header_hash: BurnchainHeaderHash(DEADBEEF.clone()),
-            };
-
-            unconfirmed_spends.push(mocked_commit);
-        }
-        Ok(unconfirmed_spends)
-    }
-
-    /// Convert a list of burn sample points into a probability distribution by candidate's
-    /// apparent sender (e.g. miner address).
-    pub fn burn_dist_to_prob_dist(burn_dist: &[BurnSamplePoint]) -> HashMap<String, f64> {
-        if burn_dist.len() == 0 {
-            return HashMap::new();
-        }
-        if burn_dist.len() == 1 {
-            let mut ret = HashMap::new();
-            ret.insert(burn_dist[0].candidate.apparent_sender.to_string(), 1.0);
-            return ret;
-        }
-
-        let mut ret = HashMap::new();
-        for pt in burn_dist.iter() {
-            // take the upper 32 bits
-            let range_lower_64 = (pt.range_end - pt.range_start) >> 192;
-            let int_prob = (range_lower_64.low_u64() >> 32) as u32;
-
-            ret.insert(
-                pt.candidate.apparent_sender.to_string(),
-                (int_prob as f64) / (u32::MAX as f64),
-            );
-        }
-
-        ret
-    }
-
-    /// Get the spend distribution and total spend.
-    /// If the miner has both a confirmed and unconfirmed spend, then take the latter.
-    pub fn get_spend_distribution(
-        active_miners_and_commits: &[(String, LeaderBlockCommitOp)],
-        unconfirmed_block_commits: &[LeaderBlockCommitOp],
-        expected_pox_addrs: &[PoxAddress],
-    ) -> (HashMap<String, u64>, u64) {
-        let unconfirmed_block_commits: Vec<_> = unconfirmed_block_commits
-            .iter()
-            .filter(|commit| {
-                if commit.commit_outs.len() != expected_pox_addrs.len() {
-                    return false;
-                }
-                for i in 0..commit.commit_outs.len() {
-                    if commit.commit_outs[i].to_burnchain_repr()
-                        != expected_pox_addrs[i].to_burnchain_repr()
-                    {
-                        info!(
-                            "Skipping invalid unconfirmed block-commit: {:?} != {:?}",
-                            &commit.commit_outs[i].to_burnchain_repr(),
-                            expected_pox_addrs[i].to_burnchain_repr()
-                        );
-                        return false;
-                    }
-                }
-                true
-            })
-            .collect();
-
-        let mut total_spend = 0;
-        let mut dist = HashMap::new();
-        for commit in unconfirmed_block_commits {
-            let addr = commit.apparent_sender.to_string();
-            dist.insert(addr, commit.burn_fee);
-        }
-
-        for (_, commit) in active_miners_and_commits.iter() {
-            let addr = commit.apparent_sender.to_string();
-            if dist.contains_key(&addr) {
-                continue;
-            }
-            dist.insert(addr, commit.burn_fee);
-        }
-
-        for (_, spend) in dist.iter() {
-            total_spend += *spend;
-        }
-
-        (dist, total_spend)
-    }
-
-    /// Get the probability distribution for the Bitcoin block 6+ blocks in the future, assuming
-    /// all block-commit spends remain the same.
-    pub fn get_future_win_distribution(
-        active_miners_and_commits: &[(String, LeaderBlockCommitOp)],
-        unconfirmed_block_commits: &[LeaderBlockCommitOp],
-        expected_pox_addrs: &[PoxAddress],
-    ) -> HashMap<String, f64> {
-        let (dist, total_spend) = Self::get_spend_distribution(
-            active_miners_and_commits,
-            unconfirmed_block_commits,
-            &expected_pox_addrs,
-        );
-
-        let mut probs = HashMap::new();
-        for (addr, spend) in dist.into_iter() {
-            if total_spend == 0 {
-                probs.insert(addr, 0.0);
-            } else {
-                probs.insert(addr, (spend as f64) / (total_spend as f64));
-            }
-        }
-        probs
-    }
-
-    /// Get the burn distribution for the _next_ Bitcoin block, assuming that the given list of
-    /// block-commit data will get mined.  For miners that are known to the system but who do not
-    /// have unconfirmed block-commits, infer that they'll just mine the same block-commit value
-    /// again.
-    pub fn get_unconfirmed_burn_distribution(
-        &self,
-        burnchain: &Burnchain,
-        sortdb: &SortitionDB,
-        active_miners_and_commits: &[(String, LeaderBlockCommitOp)],
-        unconfirmed_block_commits: Vec<LeaderBlockCommitOp>,
-        expected_pox_addrs: &[PoxAddress],
-        at_block: Option<u64>,
-    ) -> Result<Vec<BurnSamplePoint>, BurnchainError> {
-        let mut commit_table = HashMap::new();
-        for commit in unconfirmed_block_commits.iter() {
-            commit_table.insert(commit.apparent_sender.to_string(), commit.clone());
-        }
-
-        let tip = if let Some(at_block) = at_block {
-            let tip = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn())?;
-            let ih = sortdb.index_handle(&tip.sortition_id);
-            ih.get_block_snapshot_by_height(at_block)?
-                .ok_or(BurnchainError::MissingParentBlock)?
-        } else {
-            SortitionDB::get_canonical_burn_chain_tip(sortdb.conn())?
-        };
-
-        let next_block_height = tip.block_height + 1;
-        let expected_input_index = if burnchain.is_in_prepare_phase(tip.block_height) {
-            LeaderBlockCommitOp::expected_chained_utxo(true)
-        } else {
-            LeaderBlockCommitOp::expected_chained_utxo(false)
-        };
-
-        for (miner, last_commit) in active_miners_and_commits.iter() {
-            if !commit_table.contains_key(miner) {
-                let mocked_commit = LeaderBlockCommitOp {
-                    sunset_burn: 0,
-                    block_header_hash: BlockHeaderHash(DEADBEEF.clone()),
-                    new_seed: VRFSeed(DEADBEEF.clone()),
-                    parent_block_ptr: 2,
-                    parent_vtxindex: 2,
-                    key_block_ptr: 2,
-                    key_vtxindex: 2,
-                    memo: vec![],
-                    commit_outs: expected_pox_addrs.to_vec(),
-                    burn_fee: last_commit.burn_fee,
-                    input: (last_commit.txid, expected_input_index),
-                    apparent_sender: last_commit.apparent_sender.clone(),
-                    txid: Txid(DEADBEEF.clone()),
-                    vtxindex: 1,
-                    block_height: next_block_height,
-                    burn_parent_modulus: ((next_block_height.saturating_sub(1))
-                        % BURN_BLOCK_MINED_AT_MODULUS)
-                        as u8,
-                    burn_header_hash: BurnchainHeaderHash(DEADBEEF.clone()),
-                };
-                commit_table.insert(miner.to_string(), mocked_commit);
-            }
-        }
-
-        let unconfirmed_block_commits: Vec<_> = commit_table
-            .into_values()
-            .filter(|commit| {
-                if commit.commit_outs.len() != expected_pox_addrs.len() {
-                    return false;
-                }
-                for i in 0..commit.commit_outs.len() {
-                    if commit.commit_outs[i].to_burnchain_repr()
-                        != expected_pox_addrs[i].to_burnchain_repr()
-                    {
-                        info!(
-                            "Skipping invalid unconfirmed block-commit: {:?} != {:?}",
-                            &commit.commit_outs[i].to_burnchain_repr(),
-                            expected_pox_addrs[i].to_burnchain_repr()
-                        );
-                        return false;
-                    }
-                }
-                true
-            })
-            .collect();
-
-        let mut handle = sortdb.index_handle(&tip.sortition_id);
-        Self::get_burn_distribution(
-            &mut handle,
-            burnchain,
-            tip.block_height + 1,
-            unconfirmed_block_commits,
-            vec![],
-        )
-    }
-
-    /// Given the sortition DB, get the list of all miners in the past MINING_COMMITMENT_WINDOW
-    /// blocks, as well as their last block-commits
-    pub fn get_active_miners(
-        sortdb: &SortitionDB,
-        at_burn_block: Option<u64>,
-    ) -> Result<Vec<(String, LeaderBlockCommitOp)>, DBError> {
-        let mut tip = if let Some(at_burn_block) = at_burn_block {
-            let tip = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn())?;
-            let ih = sortdb.index_handle(&tip.sortition_id);
-            ih.get_block_snapshot_by_height(at_burn_block)?
-                .ok_or(DBError::NotFoundError)?
-        } else {
-            SortitionDB::get_canonical_burn_chain_tip(sortdb.conn())?
-        };
-
-        let mut miners = HashMap::new();
-        for _i in 0..MINING_COMMITMENT_WINDOW {
-            let commits =
-                SortitionDB::get_block_commits_by_block(sortdb.conn(), &tip.sortition_id)?;
-            for commit in commits.into_iter() {
-                let miner = commit.apparent_sender.to_string();
-                if miners.get(&miner).is_none() {
-                    miners.insert(miner, commit);
-                }
-            }
-            tip = SortitionDB::get_block_snapshot(sortdb.conn(), &tip.parent_sortition_id)?
-                .ok_or(DBError::NotFoundError)?;
-        }
-        Ok(miners.into_iter().collect())
-    }
-}
-
-#[cfg(test)]
-pub mod tests {
-    use super::MinerStats;
-    use stacks::burnchains::BurnchainSigner;
-    use stacks::burnchains::Txid;
-    use stacks::chainstate::burn::distribution::BurnSamplePoint;
-    use stacks::chainstate::burn::operations::leader_block_commit::BURN_BLOCK_MINED_AT_MODULUS;
-    use stacks::chainstate::burn::operations::LeaderBlockCommitOp;
-    use stacks::chainstate::stacks::address::PoxAddress;
-    use stacks::chainstate::stacks::address::PoxAddressType20;
-    use stacks_common::types::chainstate::BlockHeaderHash;
-    use stacks_common::types::chainstate::BurnchainHeaderHash;
-    use stacks_common::types::chainstate::StacksAddress;
-    use stacks_common::types::chainstate::StacksPublicKey;
-    use stacks_common::types::chainstate::VRFSeed;
-    use stacks_common::util::hash::hex_bytes;
-    use stacks_common::util::hash::Hash160;
-    use stacks_common::util::uint::BitArray;
-    use stacks_common::util::uint::Uint256;
-
-    use std::fs;
-    use std::io::Write;
-
-    #[test]
-    fn test_burn_dist_to_prob_dist() {
-        let block_commit_1 = LeaderBlockCommitOp {
-            sunset_burn: 0,
-            block_header_hash: BlockHeaderHash([0x22; 32]),
-            new_seed: VRFSeed([0x33; 32]),
-            parent_block_ptr: 111,
-            parent_vtxindex: 456,
-            key_block_ptr: 123,
-            key_vtxindex: 456,
-            memo: vec![0x80],
-
-            burn_fee: 12345,
-            input: (Txid([0; 32]), 0),
-            apparent_sender: BurnchainSigner::new_p2pkh(
-                &StacksPublicKey::from_hex(
-                    "02d8015134d9db8178ac93acbc43170a2f20febba5087a5b0437058765ad5133d0",
-                )
-                .unwrap(),
-            ),
-
-            commit_outs: vec![],
-
-            txid: Txid::from_bytes_be(
-                &hex_bytes("3c07a0a93360bc85047bbaadd49e30c8af770f73a37e10fec400174d2e5f27cf")
-                    .unwrap(),
-            )
-            .unwrap(),
-            vtxindex: 443,
-            block_height: 124,
-            burn_parent_modulus: (123 % BURN_BLOCK_MINED_AT_MODULUS) as u8,
-            burn_header_hash: BurnchainHeaderHash([0x00; 32]),
-        };
-
-        let block_commit_2 = LeaderBlockCommitOp {
-            sunset_burn: 0,
-            block_header_hash: BlockHeaderHash([0x22; 32]),
-            new_seed: VRFSeed([0x33; 32]),
-            parent_block_ptr: 112,
-            parent_vtxindex: 111,
-            key_block_ptr: 122,
-            key_vtxindex: 457,
-            memo: vec![0x80],
-
-            burn_fee: 12345,
-            input: (Txid([0; 32]), 0),
-            apparent_sender: BurnchainSigner::new_p2pkh(
-                &StacksPublicKey::from_hex(
-                    "023616a344700c9455bf0b55cc65e404c7b8f82e815da885398a44f6dc70e64045",
-                )
-                .unwrap(),
-            ),
-
-            commit_outs: vec![],
-
-            txid: Txid::from_bytes_be(
-                &hex_bytes("3c07a0a93360bc85047bbaadd49e30c8af770f73a37e10fec400174d2e5f27d0")
-                    .unwrap(),
-            )
-            .unwrap(),
-            vtxindex: 444,
-            block_height: 124,
-            burn_parent_modulus: (123 % BURN_BLOCK_MINED_AT_MODULUS) as u8,
-            burn_header_hash: BurnchainHeaderHash::from_hex(
-                "0000000000000000000000000000000000000000000000000000000000000004",
-            )
-            .unwrap(),
-        };
-
-        let block_commit_3 = LeaderBlockCommitOp {
-            sunset_burn: 0,
-            block_header_hash: BlockHeaderHash([0x22; 32]),
-            new_seed: VRFSeed([0x33; 32]),
-            parent_block_ptr: 113,
-            parent_vtxindex: 111,
-            key_block_ptr: 121,
-            key_vtxindex: 10,
-            memo: vec![0x80],
-
-            burn_fee: 23456,
-            input: (Txid([0; 32]), 0),
-            apparent_sender: BurnchainSigner::new_p2pkh(
-                &StacksPublicKey::from_hex(
-                    "020a9b0a938a2226694fe4f867193cf0b78cd6264e4277fd686468a00a9afdc36d",
-                )
-                .unwrap(),
-            ),
-
-            commit_outs: vec![],
-
-            txid: Txid::from_bytes_be(
-                &hex_bytes("301dc687a9f06a1ae87a013f27133e9cec0843c2983567be73e185827c7c13de")
-                    .unwrap(),
-            )
-            .unwrap(),
-            vtxindex: 445,
-            block_height: 124,
-            burn_parent_modulus: (123 % BURN_BLOCK_MINED_AT_MODULUS) as u8,
-            burn_header_hash: BurnchainHeaderHash::from_hex(
-                "0000000000000000000000000000000000000000000000000000000000000004",
-            )
-            .unwrap(),
-        };
-        let burn_dist = vec![
-            BurnSamplePoint {
-                burns: block_commit_1.burn_fee.into(),
-                median_burn: block_commit_2.burn_fee.into(),
-                range_start: Uint256::zero(),
-                range_end: Uint256([
-                    0x3ed94d3cb0a84709,
-                    0x0963dded799a7c1a,
-                    0x70989faf596c8b65,
-                    0x41a3ed94d3cb0a84,
-                ]),
-                candidate: block_commit_1.clone(),
-                user_burns: vec![],
-            },
-            BurnSamplePoint {
-                burns: block_commit_2.burn_fee.into(),
-                median_burn: block_commit_2.burn_fee.into(),
-                range_start: Uint256([
-                    0x3ed94d3cb0a84709,
-                    0x0963dded799a7c1a,
-                    0x70989faf596c8b65,
-                    0x41a3ed94d3cb0a84,
-                ]),
-                range_end: Uint256([
-                    0x7db29a7961508e12,
-                    0x12c7bbdaf334f834,
-                    0xe1313f5eb2d916ca,
-                    0x8347db29a7961508,
-                ]),
-                candidate: block_commit_2.clone(),
-                user_burns: vec![],
-            },
-            BurnSamplePoint {
-                burns: (block_commit_3.burn_fee).into(),
-                median_burn: block_commit_3.burn_fee.into(),
-                range_start: Uint256([
-                    0x7db29a7961508e12,
-                    0x12c7bbdaf334f834,
-                    0xe1313f5eb2d916ca,
-                    0x8347db29a7961508,
-                ]),
-                range_end: Uint256::max(),
-                candidate: block_commit_3.clone(),
-                user_burns: vec![],
-            },
-        ];
-
-        let prob_dist = MinerStats::burn_dist_to_prob_dist(&burn_dist);
-        assert_eq!(prob_dist.len(), 3);
-        assert!(
-            (prob_dist
-                .get(&format!("{}", &block_commit_1.apparent_sender))
-                .unwrap()
-                - 0.25641)
-                .abs()
-                < 0.001
-        );
-        assert!(
-            (prob_dist
-                .get(&format!("{}", &block_commit_2.apparent_sender))
-                .unwrap()
-                - 0.25641)
-                .abs()
-                < 0.001
-        );
-        assert!(
-            (prob_dist
-                .get(&format!("{}", &block_commit_3.apparent_sender))
-                .unwrap()
-                - 0.48718)
-                .abs()
-                < 0.001
-        );
-    }
-
-    #[test]
-    fn test_get_unconfirmed_commits() {
-        use std::os::unix::fs::PermissionsExt;
-        let shell_code = r#"#!/bin/bash
-echo <<EOF '[
- {
-  "txid": "73c318be8cd272a73200b9630089d77a44342d84b2c0d81c937da714152cf402",
-  "burn": 555000,
-  "address": "1FCcoFSKWvNyhjazNvVdLLw8mGkGdcRMux",
-  "input_txid": "ef0dbf0fc4755de5e94843a4da7c1d943571299afb15f32b76bac5d18d8668ce",
-  "input_index": 3,
-  "pox_addrs": [
-      "0014db14133a9dbb1d0e16b60513453e48b6ff2847a9",
-      "a91418c42080a1e87fd02dd3fca94c4513f9ecfe741487"
-  ]
- }
-]'
-EOF
-"#;
-        let path = "/tmp/test-get-unconfirmed-commits.sh";
-        if fs::metadata(&path).is_ok() {
-            fs::remove_file(&path).unwrap();
-        }
-        {
-            let mut f = fs::File::create(&path).unwrap();
-            f.write_all(shell_code.as_bytes()).unwrap();
-
-            let md = f.metadata().unwrap();
-            let mut permissions = md.permissions();
-            permissions.set_mode(0o744);
-
-            fs::set_permissions(path, permissions).unwrap();
-            f.sync_all().unwrap();
-        }
-
-        let ms = MinerStats {
-            unconfirmed_commits_helper: path.to_string(),
-        };
-
-        let mut commits = ms.get_unconfirmed_commits(123, &[]).unwrap();
-        assert_eq!(commits.len(), 1);
-        let commit = commits.pop().unwrap();
-
-        assert_eq!(
-            commit.txid,
-            Txid::from_hex("73c318be8cd272a73200b9630089d77a44342d84b2c0d81c937da714152cf402")
-                .unwrap()
-        );
-        assert_eq!(commit.burn_fee, 555000);
-        assert_eq!(
-            commit.apparent_sender.0,
-            "1FCcoFSKWvNyhjazNvVdLLw8mGkGdcRMux".to_string()
-        );
-        assert_eq!(
-            commit.input.0,
-            Txid::from_hex("ef0dbf0fc4755de5e94843a4da7c1d943571299afb15f32b76bac5d18d8668ce")
-                .unwrap()
-        );
-        assert_eq!(commit.input.1, 3);
-        assert_eq!(commit.block_height, 123);
-
-        assert_eq!(
-            commit.commit_outs,
-            vec![
-                PoxAddress::Addr20(
-                    true,
-                    PoxAddressType20::P2WPKH,
-                    [
-                        219, 20, 19, 58, 157, 187, 29, 14, 22, 182, 5, 19, 69, 62, 72, 182, 255,
-                        40, 71, 169
-                    ]
-                ),
-                PoxAddress::Standard(
-                    StacksAddress {
-                        version: 20,
-                        bytes: Hash160([
-                            0x18, 0xc4, 0x20, 0x80, 0xa1, 0xe8, 0x7f, 0xd0, 0x2d, 0xd3, 0xfc, 0xa9,
-                            0x4c, 0x45, 0x13, 0xf9, 0xec, 0xfe, 0x74, 0x14
-                        ])
-                    },
-                    None
-                )
-            ]
-        );
-    }
-
-    #[test]
-    fn test_get_spend_and_win_distribution() {
-        let active_miners_and_commits = vec![
-            (
-                "miner-1".to_string(),
-                LeaderBlockCommitOp {
-                    sunset_burn: 0,
-                    block_header_hash: BlockHeaderHash([0x22; 32]),
-                    new_seed: VRFSeed([0x33; 32]),
-                    parent_block_ptr: 111,
-                    parent_vtxindex: 456,
-                    key_block_ptr: 123,
-                    key_vtxindex: 456,
-                    memo: vec![0x80],
-
-                    burn_fee: 2,
-                    input: (Txid([0; 32]), 0),
-                    apparent_sender: BurnchainSigner("miner-1".into()),
-
-                    commit_outs: vec![],
-
-                    txid: Txid::from_bytes_be(
-                        &hex_bytes(
-                            "3c07a0a93360bc85047bbaadd49e30c8af770f73a37e10fec400174d2e5f27cf",
-                        )
-                        .unwrap(),
-                    )
-                    .unwrap(),
-                    vtxindex: 443,
-                    block_height: 124,
-                    burn_parent_modulus: (123 % BURN_BLOCK_MINED_AT_MODULUS) as u8,
-                    burn_header_hash: BurnchainHeaderHash([0x00; 32]),
-                },
-            ),
-            (
-                "miner-2".to_string(),
-                LeaderBlockCommitOp {
-                    sunset_burn: 0,
-                    block_header_hash: BlockHeaderHash([0x22; 32]),
-                    new_seed: VRFSeed([0x33; 32]),
-                    parent_block_ptr: 112,
-                    parent_vtxindex: 111,
-                    key_block_ptr: 122,
-                    key_vtxindex: 457,
-                    memo: vec![0x80],
-
-                    burn_fee: 3,
-                    input: (Txid([0; 32]), 0),
-                    apparent_sender: BurnchainSigner("miner-2".into()),
-
-                    commit_outs: vec![],
-
-                    txid: Txid::from_bytes_be(
-                        &hex_bytes(
-                            "3c07a0a93360bc85047bbaadd49e30c8af770f73a37e10fec400174d2e5f27d0",
-                        )
-                        .unwrap(),
-                    )
-                    .unwrap(),
-                    vtxindex: 444,
-                    block_height: 124,
-                    burn_parent_modulus: (123 % BURN_BLOCK_MINED_AT_MODULUS) as u8,
-                    burn_header_hash: BurnchainHeaderHash::from_hex(
-                        "0000000000000000000000000000000000000000000000000000000000000004",
-                    )
-                    .unwrap(),
-                },
-            ),
-            (
-                "miner-3".to_string(),
-                LeaderBlockCommitOp {
-                    sunset_burn: 0,
-                    block_header_hash: BlockHeaderHash([0x22; 32]),
-                    new_seed: VRFSeed([0x33; 32]),
-                    parent_block_ptr: 113,
-                    parent_vtxindex: 111,
-                    key_block_ptr: 121,
-                    key_vtxindex: 10,
-                    memo: vec![0x80],
-
-                    burn_fee: 5,
-                    input: (Txid([0; 32]), 0),
-                    apparent_sender: BurnchainSigner("miner-3".into()),
-                    commit_outs: vec![],
-
-                    txid: Txid::from_bytes_be(
-                        &hex_bytes(
-                            "301dc687a9f06a1ae87a013f27133e9cec0843c2983567be73e185827c7c13de",
-                        )
-                        .unwrap(),
-                    )
-                    .unwrap(),
-                    vtxindex: 445,
-                    block_height: 124,
-                    burn_parent_modulus: (123 % BURN_BLOCK_MINED_AT_MODULUS) as u8,
-                    burn_header_hash: BurnchainHeaderHash::from_hex(
-                        "0000000000000000000000000000000000000000000000000000000000000004",
-                    )
-                    .unwrap(),
-                },
-            ),
-        ];
-
-        let unconfirmed_block_commits = vec![
-            LeaderBlockCommitOp {
-                sunset_burn: 0,
-                block_header_hash: BlockHeaderHash([0x22; 32]),
-                new_seed: VRFSeed([0x33; 32]),
-                parent_block_ptr: 124,
-                parent_vtxindex: 456,
-                key_block_ptr: 123,
-                key_vtxindex: 456,
-                memo: vec![0x80],
-
-                burn_fee: 2,
-                input: (Txid([0; 32]), 0),
-                apparent_sender: BurnchainSigner("miner-1".into()),
-
-                commit_outs: vec![],
-
-                txid: Txid::from_bytes_be(
-                    &hex_bytes("3c07a0a93360bc85047bbaadd49e30c8af770f73a37e10fec400174d2e5f27cf")
-                        .unwrap(),
-                )
-                .unwrap(),
-                vtxindex: 443,
-                block_height: 125,
-                burn_parent_modulus: (124 % BURN_BLOCK_MINED_AT_MODULUS) as u8,
-                burn_header_hash: BurnchainHeaderHash([0x01; 32]),
-            },
-            LeaderBlockCommitOp {
-                sunset_burn: 0,
-                block_header_hash: BlockHeaderHash([0x22; 32]),
-                new_seed: VRFSeed([0x33; 32]),
-                parent_block_ptr: 124,
-                parent_vtxindex: 444,
-                key_block_ptr: 123,
-                key_vtxindex: 456,
-                memo: vec![0x80],
-
-                burn_fee: 3,
-                input: (Txid([0; 32]), 0),
-                apparent_sender: BurnchainSigner("miner-2".into()),
-
-                commit_outs: vec![],
-
-                txid: Txid::from_bytes_be(
-                    &hex_bytes("3c07a0a93360bc85047bbaadd49e30c8af770f73a37e10fec400174d2e5f27cf")
-                        .unwrap(),
-                )
-                .unwrap(),
-                vtxindex: 444,
-                block_height: 125,
-                burn_parent_modulus: (124 % BURN_BLOCK_MINED_AT_MODULUS) as u8,
-                burn_header_hash: BurnchainHeaderHash([0x01; 32]),
-            },
-            LeaderBlockCommitOp {
-                sunset_burn: 0,
-                block_header_hash: BlockHeaderHash([0x22; 32]),
-                new_seed: VRFSeed([0x33; 32]),
-                parent_block_ptr: 124,
-                parent_vtxindex: 445,
-                key_block_ptr: 123,
-                key_vtxindex: 456,
-                memo: vec![0x80],
-
-                burn_fee: 10,
-                input: (Txid([0; 32]), 0),
-                apparent_sender: BurnchainSigner("miner-3".into()),
-
-                commit_outs: vec![],
-
-                txid: Txid::from_bytes_be(
-                    &hex_bytes("3c07a0a93360bc85047bbaadd49e30c8af770f73a37e10fec400174d2e5f27cf")
-                        .unwrap(),
-                )
-                .unwrap(),
-                vtxindex: 445,
-                block_height: 125,
-                burn_parent_modulus: (124 % BURN_BLOCK_MINED_AT_MODULUS) as u8,
-                burn_header_hash: BurnchainHeaderHash([0x01; 32]),
-            },
-            LeaderBlockCommitOp {
-                sunset_burn: 0,
-                block_header_hash: BlockHeaderHash([0x22; 32]),
-                new_seed: VRFSeed([0x33; 32]),
-                parent_block_ptr: 124,
-                parent_vtxindex: 445,
-                key_block_ptr: 123,
-                key_vtxindex: 456,
-                memo: vec![0x80],
-
-                burn_fee: 10,
-                input: (Txid([0; 32]), 0),
-                apparent_sender: BurnchainSigner("miner-4".into()),
-
-                commit_outs: vec![],
-
-                txid: Txid::from_bytes_be(
-                    &hex_bytes("3c07a0a93360bc85047bbaadd49e30c8af770f73a37e10fec400174d2e5f27cf")
-                        .unwrap(),
-                )
-                .unwrap(),
-                vtxindex: 446,
-                block_height: 125,
-                burn_parent_modulus: (124 % BURN_BLOCK_MINED_AT_MODULUS) as u8,
-                burn_header_hash: BurnchainHeaderHash([0x01; 32]),
-            },
-        ];
-
-        let (spend_dist, total_spend) = MinerStats::get_spend_distribution(
-            &active_miners_and_commits,
-            &unconfirmed_block_commits,
-            &[],
-        );
-        assert_eq!(total_spend, 2 + 3 + 10 + 10);
-
-        assert_eq!(spend_dist.len(), 4);
-        for miner in &[
-            "miner-1".to_string(),
-            "miner-2".to_string(),
-            "miner-3".to_string(),
-            "miner-4".to_string(),
-        ] {
-            let spend = *spend_dist
-                .get(miner)
-                .expect(&format!("no spend for {}", &miner));
-            match miner.as_str() {
-                "miner-1" => {
-                    assert_eq!(spend, 2);
-                }
-                "miner-2" => {
-                    assert_eq!(spend, 3);
-                }
-                "miner-3" => {
-                    assert_eq!(spend, 10);
-                }
-                "miner-4" => {
-                    assert_eq!(spend, 10);
-                }
-                _ => {
-                    panic!("unknown miner {}", &miner);
-                }
-            }
-        }
-
-        let win_probs = MinerStats::get_future_win_distribution(
-            &active_miners_and_commits,
-            &unconfirmed_block_commits,
-            &[],
-        );
-        for miner in &[
-            "miner-1".to_string(),
-            "miner-2".to_string(),
-            "miner-3".to_string(),
-            "miner-4".to_string(),
-        ] {
-            let prob = *win_probs
-                .get(miner)
-                .expect(&format!("no probability for {}", &miner));
-            match miner.as_str() {
-                "miner-1" => {
-                    assert!((prob - (2.0 / 25.0)).abs() < 0.00001);
-                }
-                "miner-2" => {
-                    assert!((prob - (3.0 / 25.0)).abs() < 0.00001);
-                }
-                "miner-3" => {
-                    assert!((prob - (10.0 / 25.0)).abs() < 0.00001);
-                }
-                "miner-4" => {
-                    assert!((prob - (10.0 / 25.0)).abs() < 0.00001);
-                }
-                _ => {
-                    panic!("unknown miner {}", &miner);
-                }
-            }
-        }
-    }
-}
diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index 5f02936109..c7b47f2aad 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -1,42 +1,45 @@
-use std::collections::HashSet;
 use std::convert::TryInto;
 use std::fs;
 use std::net::{SocketAddr, ToSocketAddrs};
 use std::path::PathBuf;
-use std::sync::{Arc, Mutex};
+use std::sync::Arc;
+use std::sync::Mutex;
 
 use rand::RngCore;
+
 use stacks::burnchains::bitcoin::BitcoinNetworkType;
-use stacks::burnchains::{Burnchain, MagicBytes, BLOCKSTACK_MAGIC_MAINNET};
+use stacks::burnchains::Burnchain;
+use stacks::burnchains::{MagicBytes, BLOCKSTACK_MAGIC_MAINNET};
 use stacks::chainstate::stacks::index::marf::MARFOpenOpts;
 use stacks::chainstate::stacks::index::storage::TrieHashCalculationMode;
-use stacks::chainstate::stacks::miner::{BlockBuilderSettings, MinerStatus};
+use stacks::chainstate::stacks::miner::BlockBuilderSettings;
+use stacks::chainstate::stacks::miner::MinerStatus;
 use stacks::chainstate::stacks::MAX_BLOCK_LEN;
 use stacks::core::mempool::MemPoolWalkSettings;
-use stacks::core::mempool::MemPoolWalkTxTypes;
+use stacks::core::StacksEpoch;
+use stacks::core::StacksEpochExtension;
+use stacks::core::StacksEpochId;
 use stacks::core::{
-    StacksEpoch, StacksEpochExtension, StacksEpochId, CHAIN_ID_MAINNET, CHAIN_ID_TESTNET,
-    PEER_VERSION_MAINNET, PEER_VERSION_TESTNET,
+    CHAIN_ID_MAINNET, CHAIN_ID_TESTNET, PEER_VERSION_MAINNET, PEER_VERSION_TESTNET,
 };
 use stacks::cost_estimates::fee_medians::WeightedMedianFeeRateEstimator;
 use stacks::cost_estimates::fee_rate_fuzzer::FeeRateFuzzer;
 use stacks::cost_estimates::fee_scalar::ScalarFeeRateEstimator;
-use stacks::cost_estimates::metrics::{CostMetric, ProportionalDotProduct};
-use stacks::cost_estimates::{CostEstimator, FeeEstimator, PessimisticEstimator};
+use stacks::cost_estimates::metrics::CostMetric;
+use stacks::cost_estimates::metrics::ProportionalDotProduct;
+use stacks::cost_estimates::CostEstimator;
+use stacks::cost_estimates::FeeEstimator;
+use stacks::cost_estimates::PessimisticEstimator;
 use stacks::net::connection::ConnectionOptions;
 use stacks::net::{Neighbor, NeighborKey, PeerAddress};
 use stacks::util::get_epoch_time_ms;
 use stacks::util::hash::hex_bytes;
-use stacks::util::secp256k1::{Secp256k1PrivateKey, Secp256k1PublicKey};
+use stacks::util::secp256k1::Secp256k1PrivateKey;
+use stacks::util::secp256k1::Secp256k1PublicKey;
 use stacks::vm::costs::ExecutionCost;
 use stacks::vm::types::{AssetIdentifier, PrincipalData, QualifiedContractIdentifier};
 
-use stacks_common::types::chainstate::StacksAddress;
-use stacks_common::types::Address;
-
-use crate::chain_data::MinerStats;
-
-pub const DEFAULT_SATS_PER_VB: u64 = 50;
+const DEFAULT_SATS_PER_VB: u64 = 50;
 const DEFAULT_MAX_RBF_RATE: u64 = 150; // 1.5x
 const DEFAULT_RBF_FEE_RATE_INCREMENT: u64 = 5;
 const LEADER_KEY_TX_ESTIM_SIZE: u64 = 290;
@@ -45,7 +48,6 @@ const INV_REWARD_CYCLES_TESTNET: u64 = 6;
 
 #[derive(Clone, Deserialize, Default, Debug)]
 pub struct ConfigFile {
-    pub __path: Option<String>, // Only used for config file reloads
     pub burnchain: Option<BurnchainConfigFile>,
     pub node: Option<NodeConfigFile>,
     pub ustx_balance: Option<Vec<InitialBalanceFile>>,
@@ -176,9 +178,7 @@ mod tests {
 impl ConfigFile {
     pub fn from_path(path: &str) -> Result<ConfigFile, String> {
         let content = fs::read_to_string(path).map_err(|e| format!("Invalid path: {}", &e))?;
-        let mut f = Self::from_str(&content)?;
-        f.__path = Some(path.to_string());
-        Ok(f)
+        Self::from_str(&content)
     }
 
     pub fn from_str(content: &str) -> Result<ConfigFile, String> {
@@ -206,7 +206,7 @@ impl ConfigFile {
         };
 
         let node = NodeConfigFile {
-            bootstrap_node: Some("029266faff4c8e0ca4f934f34996a96af481df94a89b0c9bd515f3536a95682ddc@seed.testnet.hiro.so:30444".to_string()),
+            bootstrap_node: Some("029266faff4c8e0ca4f934f34996a96af481df94a89b0c9bd515f3536a95682ddc@seed.testnet.hiro.so:20444".to_string()),
             miner: Some(false),
             ..NodeConfigFile::default()
         };
@@ -353,7 +353,6 @@ impl ConfigFile {
 
 #[derive(Clone, Debug)]
 pub struct Config {
-    pub config_path: Option<String>,
     pub burnchain: BurnchainConfig,
     pub node: NodeConfig,
     pub initial_balances: Vec<InitialBalance>,
@@ -395,36 +394,6 @@ lazy_static! {
 }
 
 impl Config {
-    /// get the up-to-date burnchain options from the config.
-    /// If the config file can't be loaded, then return the existing config
-    pub fn get_burnchain_config(&self) -> BurnchainConfig {
-        let Some(path) = &self.config_path else {
-            return self.burnchain.clone();
-        };
-        let Ok(config_file) = ConfigFile::from_path(path.as_str()) else {
-            return self.burnchain.clone();
-        };
-        let Ok(config) = Config::from_config_file(config_file) else {
-            return self.burnchain.clone();
-        };
-        config.burnchain
-    }
-
-    /// get the up-to-date miner options from the config
-    /// If the config can't be loaded for some reason, then return the existing config
-    pub fn get_miner_config(&self) -> MinerConfig {
-        let Some(path) = &self.config_path else {
-            return self.miner.clone();
-        };
-        let Ok(config_file) = ConfigFile::from_path(path.as_str()) else {
-            return self.miner.clone();
-        };
-        let Ok(config) = Config::from_config_file(config_file) else {
-            return self.miner.clone();
-        };
-        return config.miner;
-    }
-
     /// Apply any test settings to this burnchain config struct
     fn apply_test_settings(&self, burnchain: &mut Burnchain) {
         if self.burnchain.get_bitcoin_network().1 == BitcoinNetworkType::Mainnet {
@@ -912,6 +881,7 @@ impl Config {
         let miner_default_config = MinerConfig::default();
         let miner = match config_file.miner {
             Some(ref miner) => MinerConfig {
+                min_tx_fee: miner.min_tx_fee.unwrap_or(miner_default_config.min_tx_fee),
                 first_attempt_time_ms: miner
                     .first_attempt_time_ms
                     .unwrap_or(miner_default_config.first_attempt_time_ms),
@@ -939,52 +909,6 @@ impl Config {
                 unprocessed_block_deadline_secs: miner
                     .unprocessed_block_deadline_secs
                     .unwrap_or(miner_default_config.unprocessed_block_deadline_secs),
-                min_tx_count: miner.min_tx_count.unwrap_or(0),
-                only_increase_tx_count: miner.only_increase_tx_count.unwrap_or(false),
-                unconfirmed_commits_helper: miner.unconfirmed_commits_helper.clone(),
-                target_win_probability: miner.target_win_probability.unwrap_or(0.0),
-                activated_vrf_key_path: miner.activated_vrf_key_path.clone(),
-                fast_rampup: miner.fast_rampup.unwrap_or(true),
-                underperform_stop_threshold: miner.underperform_stop_threshold,
-                txs_to_consider: {
-                    if let Some(txs_to_consider) = &miner.txs_to_consider {
-                        txs_to_consider
-                            .split(",")
-                            .map(
-                                |txs_to_consider_str| match str::parse(txs_to_consider_str) {
-                                    Ok(txtype) => txtype,
-                                    Err(e) => {
-                                        panic!(
-                                            "could not parse '{}': {}",
-                                            &txs_to_consider_str, &e
-                                        );
-                                    }
-                                },
-                            )
-                            .collect()
-                    } else {
-                        MemPoolWalkTxTypes::all()
-                    }
-                },
-                filter_origins: {
-                    if let Some(filter_origins) = &miner.filter_origins {
-                        filter_origins
-                            .split(",")
-                            .map(|origin_str| match StacksAddress::from_string(origin_str) {
-                                Some(addr) => addr,
-                                None => {
-                                    panic!(
-                                        "could not parse '{}' into a Stacks address",
-                                        origin_str
-                                    );
-                                }
-                            })
-                            .collect()
-                    } else {
-                        HashSet::new()
-                    }
-                },
-                max_reorg_depth: miner.max_reorg_depth.unwrap_or(3),
             },
             None => miner_default_config,
         };
@@ -1224,7 +1148,6 @@ impl Config {
         };
 
         Ok(Config {
-            config_path: config_file.__path,
             node,
             burnchain,
             initial_balances,
@@ -1340,47 +1263,34 @@ impl Config {
         microblocks: bool,
         miner_status: Arc<Mutex<MinerStatus>>,
     ) -> BlockBuilderSettings {
-        let miner_config = self.get_miner_config();
         BlockBuilderSettings {
             max_miner_time_ms: if microblocks {
-                miner_config.microblock_attempt_time_ms
+                self.miner.microblock_attempt_time_ms
             } else if attempt <= 1 {
                 // first attempt to mine a block -- do so right away
-                miner_config.first_attempt_time_ms
+                self.miner.first_attempt_time_ms
             } else {
                 // second or later attempt to mine a block -- give it some time
-                miner_config.subsequent_attempt_time_ms
+                self.miner.subsequent_attempt_time_ms
             },
             mempool_settings: MemPoolWalkSettings {
+                min_tx_fee: self.miner.min_tx_fee,
                 max_walk_time_ms: if microblocks {
-                    miner_config.microblock_attempt_time_ms
+                    self.miner.microblock_attempt_time_ms
                 } else if attempt <= 1 {
                     // first attempt to mine a block -- do so right away
-                    miner_config.first_attempt_time_ms
+                    self.miner.first_attempt_time_ms
                 } else {
                     // second or later attempt to mine a block -- give it some time
-                    miner_config.subsequent_attempt_time_ms
+                    self.miner.subsequent_attempt_time_ms
                 },
-                consider_no_estimate_tx_prob: miner_config.probability_pick_no_estimate_tx,
-                nonce_cache_size: miner_config.nonce_cache_size,
-                candidate_retry_cache_size: miner_config.candidate_retry_cache_size,
-                txs_to_consider: miner_config.txs_to_consider,
-                filter_origins: miner_config.filter_origins,
+                consider_no_estimate_tx_prob: self.miner.probability_pick_no_estimate_tx,
+                nonce_cache_size: self.miner.nonce_cache_size,
+                candidate_retry_cache_size: self.miner.candidate_retry_cache_size,
             },
             miner_status,
         }
     }
-
-    pub fn get_miner_stats(&self) -> Option<MinerStats> {
-        let miner_config = self.get_miner_config();
-        if let Some(unconfirmed_commits_helper) = miner_config.unconfirmed_commits_helper.as_ref() {
-            let miner_stats = MinerStats {
-                unconfirmed_commits_helper: unconfirmed_commits_helper.clone(),
-            };
-            return Some(miner_stats);
-        }
-        None
-    }
 }
 
 impl std::default::Default for Config {
@@ -1398,7 +1308,6 @@ impl std::default::Default for Config {
         let estimation = FeeEstimationConfig::default();
 
         Config {
-            config_path: None,
             burnchain,
             node,
             initial_balances: vec![],
@@ -1965,8 +1874,9 @@ impl NodeConfig {
     }
 }
 
-#[derive(Clone, Debug, Default, PartialEq)]
+#[derive(Clone, Debug, Default)]
 pub struct MinerConfig {
+    pub min_tx_fee: u64,
     pub first_attempt_time_ms: u64,
     pub subsequent_attempt_time_ms: u64,
     pub microblock_attempt_time_ms: u64,
@@ -1980,58 +1890,22 @@ pub struct MinerConfig {
     pub nonce_cache_size: u64,
     pub candidate_retry_cache_size: u64,
     pub unprocessed_block_deadline_secs: u64,
-    /// minimum number of transactions that must be in a block if we're going to replace a pending
-    /// block-commit with a new block-commit
-    pub min_tx_count: u64,
-    /// Only allow a block's tx count to increase across RBFs.
-    pub only_increase_tx_count: bool,
-    /// Path to a script that prints out all unconfirmed block-commits for a list of addresses
-    pub unconfirmed_commits_helper: Option<String>,
-    /// Targeted win probability for this miner.  Used to deduce when to stop trying to mine.
-    pub target_win_probability: f64,
-    /// Path to a serialized RegisteredKey struct, which points to an already-registered VRF key
-    /// (so we don't have to go make a new one)
-    pub activated_vrf_key_path: Option<String>,
-    /// When estimating win probability, whether or not to use the assumed win rate 6+ blocks from
-    /// now (true), or the current win rate (false)
-    pub fast_rampup: bool,
-    /// Number of Bitcoin blocks which must pass where the boostes+neutrals are a minority, at which
-    /// point the miner will stop trying.
-    pub underperform_stop_threshold: Option<u64>,
-    /// Kinds of transactions to consider from the mempool.  This is used by boosted and neutral
-    /// miners to push past averse fee estimations.
-    pub txs_to_consider: HashSet<MemPoolWalkTxTypes>,
-    /// Origin addresses to whitelist when doing a mempool walk.  This is used by boosted and
-    /// neutral miners to push transactions through that are important to them.
-    pub filter_origins: HashSet<StacksAddress>,
-    /// When selecting the "nicest" tip, do not consider tips that are more than this many blocks
-    /// behind the highest tip.
-    pub max_reorg_depth: u64,
 }
 
 impl MinerConfig {
     pub fn default() -> MinerConfig {
         MinerConfig {
-            first_attempt_time_ms: 10,
-            subsequent_attempt_time_ms: 120_000,
+            min_tx_fee: 1,
+            first_attempt_time_ms: 5_000,
+            subsequent_attempt_time_ms: 30_000,
             microblock_attempt_time_ms: 30_000,
             probability_pick_no_estimate_tx: 5,
             block_reward_recipient: None,
             segwit: false,
             wait_for_block_download: true,
-            nonce_cache_size: 1024 * 1024,
-            candidate_retry_cache_size: 1024 * 1024,
+            nonce_cache_size: 10_000,
+            candidate_retry_cache_size: 10_000,
             unprocessed_block_deadline_secs: 30,
-            min_tx_count: 0,
-            only_increase_tx_count: false,
-            unconfirmed_commits_helper: None,
-            target_win_probability: 0.0,
-            activated_vrf_key_path: None,
-            fast_rampup: false,
-            underperform_stop_threshold: None,
-            txs_to_consider: MemPoolWalkTxTypes::all(),
-            filter_origins: HashSet::new(),
-            max_reorg_depth: 3,
         }
     }
 }
@@ -2138,6 +2012,7 @@ impl Default for FeeEstimationConfigFile {
 
 #[derive(Clone, Deserialize, Default, Debug)]
 pub struct MinerConfigFile {
+    pub min_tx_fee: Option<u64>,
     pub first_attempt_time_ms: Option<u64>,
     pub subsequent_attempt_time_ms: Option<u64>,
     pub microblock_attempt_time_ms: Option<u64>,
@@ -2147,16 +2022,6 @@ pub struct MinerConfigFile {
     pub nonce_cache_size: Option<u64>,
     pub candidate_retry_cache_size: Option<u64>,
     pub unprocessed_block_deadline_secs: Option<u64>,
-    pub min_tx_count: Option<u64>,
-    pub only_increase_tx_count: Option<bool>,
-    pub unconfirmed_commits_helper: Option<String>,
-    pub target_win_probability: Option<f64>,
-    pub activated_vrf_key_path: Option<String>,
-    pub fast_rampup: Option<bool>,
-    pub underperform_stop_threshold: Option<u64>,
-    pub txs_to_consider: Option<String>,
-    pub filter_origins: Option<String>,
-    pub max_reorg_depth: Option<u64>,
 }
 
 #[derive(Clone, Deserialize, Default, Debug)]
diff --git a/testnet/stacks-node/src/event_dispatcher.rs b/testnet/stacks-node/src/event_dispatcher.rs
index 0c49b7f2fa..d0a40bde3a 100644
--- a/testnet/stacks-node/src/event_dispatcher.rs
+++ b/testnet/stacks-node/src/event_dispatcher.rs
@@ -230,12 +230,16 @@ impl EventObserver {
         };
 
         let raw_result = {
-            let bytes = receipt.result.serialize_to_vec();
+            let bytes = receipt
+                .result
+                .serialize_to_vec()
+                .expect("FATAL: failed to serialize transaction receipt");
             bytes_to_hex(&bytes)
         };
         let contract_interface_json = {
             match &receipt.contract_analysis {
-                Some(analysis) => json!(build_contract_interface(analysis)),
+                Some(analysis) => json!(build_contract_interface(analysis)
+                    .expect("FATAL: failed to serialize contract publish receipt")),
                 None => json!(null),
             }
         };
@@ -308,7 +312,9 @@ impl EventObserver {
         let serialized_events: Vec<serde_json::Value> = filtered_events
             .iter()
             .map(|(event_index, (committed, txid, event))| {
-                event.json_serialize(*event_index, txid, *committed)
+                event
+                    .json_serialize(*event_index, txid, *committed)
+                    .unwrap()
             })
             .collect();
 
@@ -360,7 +366,9 @@ impl EventObserver {
         let serialized_events: Vec<serde_json::Value> = filtered_events
             .iter()
             .map(|(event_index, (committed, txid, event))| {
-                event.json_serialize(*event_index, txid, *committed)
+                event
+                    .json_serialize(*event_index, txid, *committed)
+                    .unwrap()
             })
             .collect();
 
diff --git a/testnet/stacks-node/src/main.rs b/testnet/stacks-node/src/main.rs
index 0c8b8ca9dd..3d904a2116 100644
--- a/testnet/stacks-node/src/main.rs
+++ b/testnet/stacks-node/src/main.rs
@@ -23,7 +23,6 @@ use stacks::util::hash::hex_bytes;
 pub mod monitoring;
 
 pub mod burnchains;
-pub mod chain_data;
 pub mod config;
 pub mod event_dispatcher;
 pub mod genesis_data;
@@ -35,8 +34,6 @@ pub mod run_loop;
 pub mod syncctl;
 pub mod tenure;
 
-use std::collections::HashMap;
-
 pub use self::burnchains::{
     BitcoinRegtestController, BurnchainController, BurnchainTip, MocknetController,
 };
@@ -47,18 +44,6 @@ pub use self::node::{ChainTip, Node};
 pub use self::run_loop::{helium, neon};
 pub use self::tenure::Tenure;
 
-use crate::neon_node::BlockMinerThread;
-
-use stacks::chainstate::burn::db::sortdb::SortitionDB;
-use stacks::chainstate::burn::operations::leader_block_commit::RewardSetInfo;
-use stacks::chainstate::coordinator::get_next_recipients;
-use stacks::chainstate::coordinator::OnChainRewardSetProvider;
-use stacks::chainstate::stacks::address::PoxAddress;
-use stacks::chainstate::stacks::db::StacksChainState;
-
-use crate::chain_data::MinerStats;
-use crate::neon_node::TipCandidate;
-
 use pico_args::Arguments;
 use std::env;
 
@@ -68,210 +53,6 @@ use std::process;
 
 use backtrace::Backtrace;
 
-/// Implmentation of `pick_best_tip` CLI option
-fn cli_pick_best_tip(config_path: &str, at_stacks_height: Option<u64>) -> TipCandidate {
-    info!("Loading config at path {}", config_path);
-    let config = match ConfigFile::from_path(config_path) {
-        Ok(config_file) => Config::from_config_file(config_file).unwrap(),
-        Err(e) => {
-            warn!("Invalid config file: {}", e);
-            process::exit(1);
-        }
-    };
-    let burn_db_path = config.get_burn_db_file_path();
-    let stacks_chainstate_path = config.get_chainstate_path_str();
-    let burnchain = config.get_burnchain();
-    let (mut chainstate, _) = StacksChainState::open(
-        config.is_mainnet(),
-        config.burnchain.chain_id,
-        &stacks_chainstate_path,
-        Some(config.node.get_marf_opts()),
-    )
-    .unwrap();
-    let mut sortdb =
-        SortitionDB::open(&burn_db_path, false, burnchain.pox_constants.clone()).unwrap();
-
-    let max_depth = config.miner.max_reorg_depth;
-
-    // There could be more than one possible chain tip. Go find them.
-    let stacks_tips = BlockMinerThread::load_candidate_tips(
-        &mut sortdb,
-        &mut chainstate,
-        max_depth,
-        at_stacks_height,
-    );
-
-    let best_tip = BlockMinerThread::inner_pick_best_tip(stacks_tips, HashMap::new()).unwrap();
-    best_tip
-}
-
-/// Implementation of `get_miner_spend` CLI option
-fn cli_get_miner_spend(
-    config_path: &str,
-    mine_start: Option<u64>,
-    at_burnchain_height: Option<u64>,
-) -> u64 {
-    info!("Loading config at path {}", config_path);
-    let config = match ConfigFile::from_path(&config_path) {
-        Ok(config_file) => Config::from_config_file(config_file).unwrap(),
-        Err(e) => {
-            warn!("Invalid config file: {}", e);
-            process::exit(1);
-        }
-    };
-    let keychain = Keychain::default(config.node.seed.clone());
-    let burn_db_path = config.get_burn_db_file_path();
-    let stacks_chainstate_path = config.get_chainstate_path_str();
-    let burnchain = config.get_burnchain();
-    let (mut chainstate, _) = StacksChainState::open(
-        config.is_mainnet(),
-        config.burnchain.chain_id,
-        &stacks_chainstate_path,
-        Some(config.node.get_marf_opts()),
-    )
-    .unwrap();
-    let mut sortdb =
-        SortitionDB::open(&burn_db_path, true, burnchain.pox_constants.clone()).unwrap();
-    let tip = if let Some(at_burnchain_height) = at_burnchain_height {
-        let tip = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn()).unwrap();
-        let ih = sortdb.index_handle(&tip.sortition_id);
-        ih.get_block_snapshot_by_height(at_burnchain_height)
-            .unwrap()
-            .unwrap()
-    } else {
-        SortitionDB::get_canonical_burn_chain_tip(sortdb.conn()).unwrap()
-    };
-
-    let recipients = get_next_recipients(
-        &tip,
-        &mut chainstate,
-        &mut sortdb,
-        &burnchain,
-        &OnChainRewardSetProvider(),
-        config.node.always_use_affirmation_maps,
-    )
-    .unwrap();
-
-    let commit_outs = if !burnchain.is_in_prepare_phase(tip.block_height + 1) {
-        RewardSetInfo::into_commit_outs(recipients, config.is_mainnet())
-    } else {
-        vec![PoxAddress::standard_burn_address(config.is_mainnet())]
-    };
-
-    let spend_amount = BlockMinerThread::get_mining_spend_amount(
-        &config,
-        &keychain,
-        &burnchain,
-        &mut sortdb,
-        &commit_outs,
-        mine_start.unwrap_or(tip.block_height),
-        at_burnchain_height,
-        |burn_block_height| {
-            let sortdb =
-                SortitionDB::open(&burn_db_path, true, burnchain.pox_constants.clone()).unwrap();
-            let Some(miner_stats) = config.get_miner_stats() else {
-                return 0.0;
-            };
-            let Ok(active_miners_and_commits) =
-                MinerStats::get_active_miners(&sortdb, Some(burn_block_height)).map_err(|e| {
-                    warn!("Failed to get active miners: {:?}", &e);
-                    e
-                })
-            else {
-                return 0.0;
-            };
-            if active_miners_and_commits.len() == 0 {
-                warn!("No active miners detected; using config file burn_fee_cap");
-                return 0.0;
-            }
-
-            let active_miners: Vec<_> = active_miners_and_commits
-                .iter()
-                .map(|(miner, _cmt)| miner.as_str())
-                .collect();
-
-            info!("Active miners: {:?}", &active_miners);
-
-            let Ok(unconfirmed_block_commits) = miner_stats
-                .get_unconfirmed_commits(burn_block_height + 1, &active_miners)
-                .map_err(|e| {
-                    warn!("Failed to find unconfirmed block-commits: {}", &e);
-                    e
-                })
-            else {
-                return 0.0;
-            };
-
-            let unconfirmed_miners_and_amounts: Vec<(String, u64)> = unconfirmed_block_commits
-                .iter()
-                .map(|cmt| (format!("{}", &cmt.apparent_sender), cmt.burn_fee))
-                .collect();
-
-            info!(
-                "Found unconfirmed block-commits: {:?}",
-                &unconfirmed_miners_and_amounts
-            );
-
-            let (spend_dist, _total_spend) = MinerStats::get_spend_distribution(
-                &active_miners_and_commits,
-                &unconfirmed_block_commits,
-                &commit_outs,
-            );
-            let win_probs = if config.miner.fast_rampup {
-                // look at spends 6+ blocks in the future
-                let win_probs = MinerStats::get_future_win_distribution(
-                    &active_miners_and_commits,
-                    &unconfirmed_block_commits,
-                    &commit_outs,
-                );
-                win_probs
-            } else {
-                // look at the current spends
-                let Ok(unconfirmed_burn_dist) = miner_stats
-                    .get_unconfirmed_burn_distribution(
-                        &burnchain,
-                        &sortdb,
-                        &active_miners_and_commits,
-                        unconfirmed_block_commits,
-                        &commit_outs,
-                        at_burnchain_height,
-                    )
-                    .map_err(|e| {
-                        warn!("Failed to get unconfirmed burn distribution: {:?}", &e);
-                        e
-                    })
-                else {
-                    return 0.0;
-                };
-
-                let win_probs = MinerStats::burn_dist_to_prob_dist(&unconfirmed_burn_dist);
-                win_probs
-            };
-
-            info!("Unconfirmed spend distribution: {:?}", &spend_dist);
-            info!(
-                "Unconfirmed win probabilities (fast_rampup={}): {:?}",
-                config.miner.fast_rampup, &win_probs
-            );
-
-            let miner_addrs = BlockMinerThread::get_miner_addrs(&config, &keychain);
-            let win_prob = miner_addrs
-                .iter()
-                .find_map(|x| win_probs.get(x))
-                .copied()
-                .unwrap_or(0.0);
-
-            info!(
-                "This miner's win probability at {} is {}",
-                tip.block_height, &win_prob
-            );
-            win_prob
-        },
-        |_burn_block_height, _win_prob| {},
-    );
-    spend_amount
-}
-
 fn main() {
     panic::set_hook(Box::new(|panic_info| {
         error!("Process abort due to thread panic: {}", panic_info);
@@ -313,24 +94,24 @@ fn main() {
 
     let config_file = match subcommand.as_str() {
         "mocknet" => {
-            args.finish();
+            args.finish().unwrap();
             ConfigFile::mocknet()
         }
         "helium" => {
-            args.finish();
+            args.finish().unwrap();
             ConfigFile::helium()
         }
         "testnet" => {
-            args.finish();
+            args.finish().unwrap();
             ConfigFile::xenon()
         }
         "mainnet" => {
-            args.finish();
+            args.finish().unwrap();
             ConfigFile::mainnet()
         }
         "check-config" => {
             let config_path: String = args.value_from_str("--config").unwrap();
-            args.finish();
+            args.finish().unwrap();
             info!("Loading config at path {}", config_path);
             let config_file = match ConfigFile::from_path(&config_path) {
                 Ok(config_file) => {
@@ -355,7 +136,7 @@ fn main() {
         }
         "start" => {
             let config_path: String = args.value_from_str("--config").unwrap();
-            args.finish();
+            args.finish().unwrap();
             info!("Loading config at path {}", config_path);
             match ConfigFile::from_path(&config_path) {
                 Ok(config_file) => config_file,
@@ -376,15 +157,14 @@ fn main() {
                     let conf =
                         Config::from_config_file(ConfigFile::from_path(&config_path).unwrap())
                             .unwrap();
-                    args.finish();
+                    args.finish().unwrap();
                     conf.node.seed
                 } else {
-                    let free_args = args.finish();
+                    let free_args = args.free().unwrap();
                     let seed_hex = free_args
                         .first()
                         .expect("`wif-for-seed` must be passed either a config file via the `--config` flag or a hex seed string");
-                    hex_bytes(seed_hex.to_str().unwrap())
-                        .expect("Seed should be a hex encoded string")
+                    hex_bytes(seed_hex).expect("Seed should be a hex encoded string")
                 }
             };
             let keychain = Keychain::default(seed);
@@ -398,26 +178,6 @@ fn main() {
             );
             return;
         }
-        "pick-best-tip" => {
-            let config_path: String = args.value_from_str("--config").unwrap();
-            let at_stacks_height: Option<u64> =
-                args.opt_value_from_str("--at-stacks-height").unwrap();
-            args.finish();
-
-            let best_tip = cli_pick_best_tip(&config_path, at_stacks_height);
-            println!("Best tip is {:?}", &best_tip);
-            process::exit(0);
-        }
-        "get-spend-amount" => {
-            let config_path: String = args.value_from_str("--config").unwrap();
-            let at_burnchain_height: Option<u64> =
-                args.opt_value_from_str("--at-bitcoin-height").unwrap();
-            args.finish();
-
-            let spend_amount = cli_get_miner_spend(&config_path, mine_start, at_burnchain_height);
-            println!("Will spend {}", spend_amount);
-            process::exit(0);
-        }
         _ => {
             print_help();
             return;
diff --git a/testnet/stacks-node/src/neon_node.rs b/testnet/stacks-node/src/neon_node.rs
index 865f5e2a9a..17eebf2c97 100644
--- a/testnet/stacks-node/src/neon_node.rs
+++ b/testnet/stacks-node/src/neon_node.rs
@@ -1,5 +1,5 @@
 // Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
-// Copyright (C) 2020-2024 Stacks Open Internet Foundation
+// Copyright (C) 2020 Stacks Open Internet Foundation
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -138,90 +138,91 @@
 ///
 /// This file may be refactored in the future into a full-fledged module.
 use std::cmp;
-use std::cmp::Ordering as CmpOrdering;
-use std::collections::{BTreeMap, HashMap, HashSet, VecDeque};
+use std::collections::HashMap;
+use std::collections::{HashSet, VecDeque};
 use std::convert::{TryFrom, TryInto};
 use std::default::Default;
-use std::fs;
-use std::io::{Read, Write};
+use std::mem;
 use std::net::SocketAddr;
-use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::mpsc::{Receiver, SyncSender, TrySendError};
-use std::sync::{Arc, Mutex};
-use std::thread::JoinHandle;
+use std::sync::{atomic::AtomicBool, atomic::Ordering, Arc, Mutex};
 use std::time::Duration;
-use std::{mem, thread};
-
-use clarity::vm::ast::ASTRules;
-use clarity::vm::types::PrincipalData;
-use stacks::burnchains::bitcoin::address::BitcoinAddress;
-use stacks::burnchains::bitcoin::address::LegacyBitcoinAddressType;
-use stacks::burnchains::db::BurnchainHeaderReader;
-use stacks::burnchains::{Burnchain, BurnchainParameters, Txid};
+use std::{thread, thread::JoinHandle};
 
+use stacks::burnchains::{db::BurnchainHeaderReader, Burnchain, BurnchainParameters, Txid};
 use stacks::chainstate::burn::db::sortdb::SortitionDB;
-use stacks::chainstate::burn::operations::leader_block_commit::{
-    RewardSetInfo, BURN_BLOCK_MINED_AT_MODULUS,
-};
 use stacks::chainstate::burn::operations::{
+    leader_block_commit::{RewardSetInfo, BURN_BLOCK_MINED_AT_MODULUS},
     BlockstackOperationType, LeaderBlockCommitOp, LeaderKeyRegisterOp,
 };
-use stacks::chainstate::burn::{BlockSnapshot, ConsensusHash};
+use stacks::chainstate::burn::BlockSnapshot;
+use stacks::chainstate::burn::ConsensusHash;
 use stacks::chainstate::coordinator::comm::CoordinatorChannels;
 use stacks::chainstate::coordinator::{get_next_recipients, OnChainRewardSetProvider};
 use stacks::chainstate::stacks::address::PoxAddress;
 use stacks::chainstate::stacks::db::unconfirmed::UnconfirmedTxMap;
-use stacks::chainstate::stacks::db::{
-    blocks::StagingBlock, StacksChainState, StacksHeaderInfo, MINER_REWARD_MATURITY,
-};
-use stacks::chainstate::stacks::miner::{
-    signal_mining_blocked, signal_mining_ready, BlockBuilderSettings, MinerStatus,
-    StacksMicroblockBuilder,
+use stacks::chainstate::stacks::db::StacksHeaderInfo;
+use stacks::chainstate::stacks::db::{StacksChainState, MINER_REWARD_MATURITY};
+use stacks::chainstate::stacks::Error as ChainstateError;
+use stacks::chainstate::stacks::StacksPublicKey;
+use stacks::chainstate::stacks::{
+    miner::get_mining_spend_amount, miner::signal_mining_blocked, miner::signal_mining_ready,
+    miner::BlockBuilderSettings, miner::MinerStatus, miner::StacksMicroblockBuilder,
+    StacksBlockBuilder, StacksBlockHeader,
 };
 use stacks::chainstate::stacks::{
-    CoinbasePayload, Error as ChainstateError, StacksBlock, StacksBlockBuilder, StacksBlockHeader,
-    StacksMicroblock, StacksPublicKey, StacksTransaction, StacksTransactionSigner,
+    CoinbasePayload, StacksBlock, StacksMicroblock, StacksTransaction, StacksTransactionSigner,
     TransactionAnchorMode, TransactionPayload, TransactionVersion,
 };
 use stacks::codec::StacksMessageCodec;
 use stacks::core::mempool::MemPoolDB;
-use stacks::core::{FIRST_BURNCHAIN_CONSENSUS_HASH, STACKS_EPOCH_2_4_MARKER};
-use stacks::cost_estimates::metrics::{CostMetric, UnitMetric};
-use stacks::cost_estimates::{CostEstimator, FeeEstimator, UnitEstimator};
-use stacks::monitoring;
+use stacks::core::FIRST_BURNCHAIN_CONSENSUS_HASH;
+use stacks::core::STACKS_EPOCH_2_4_MARKER;
+use stacks::cost_estimates::metrics::CostMetric;
+use stacks::cost_estimates::metrics::UnitMetric;
+use stacks::cost_estimates::UnitEstimator;
+use stacks::cost_estimates::{CostEstimator, FeeEstimator};
 use stacks::monitoring::{increment_stx_blocks_mined_counter, update_active_miners_count_gauge};
-use stacks::net::atlas::{AtlasConfig, AtlasDB, AttachmentInstance};
-use stacks::net::db::{LocalPeer, PeerDB};
-use stacks::net::dns::{DNSClient, DNSResolver};
-use stacks::net::p2p::PeerNetwork;
-use stacks::net::relay::Relayer;
-use stacks::net::rpc::RPCHandlerArgs;
-use stacks::net::{Error as NetError, NetworkResult, PeerAddress, ServiceFlags};
+use stacks::net::{
+    atlas::{AtlasConfig, AtlasDB, AttachmentInstance},
+    db::{LocalPeer, PeerDB},
+    dns::DNSClient,
+    dns::DNSResolver,
+    p2p::PeerNetwork,
+    relay::Relayer,
+    rpc::RPCHandlerArgs,
+    Error as NetError, NetworkResult, PeerAddress, ServiceFlags,
+};
 use stacks::types::chainstate::{
     BlockHeaderHash, BurnchainHeaderHash, SortitionId, StacksAddress, VRFSeed,
 };
 use stacks::types::StacksEpochId;
+use stacks::util::get_epoch_time_ms;
+use stacks::util::get_epoch_time_secs;
 use stacks::util::hash::{to_hex, Hash160, Sha256Sum};
 use stacks::util::secp256k1::Secp256k1PrivateKey;
 use stacks::util::vrf::VRFPublicKey;
-use stacks::util::{get_epoch_time_ms, get_epoch_time_secs};
 use stacks::util_lib::strings::{UrlString, VecDisplay};
 use stacks::vm::costs::ExecutionCost;
 
+use crate::burnchains::bitcoin_regtest_controller::BitcoinRegtestController;
+use crate::burnchains::bitcoin_regtest_controller::OngoingBlockCommit;
+use crate::burnchains::make_bitcoin_indexer;
+use crate::run_loop::neon::Counters;
+use crate::run_loop::neon::RunLoop;
+use crate::run_loop::RegisteredKey;
+use crate::ChainTip;
+
 use super::{BurnchainController, Config, EventDispatcher, Keychain};
+use crate::syncctl::PoxSyncWatchdogComms;
+use stacks::monitoring;
 
-use stacks_common::types::chainstate::{StacksBlockId, StacksPrivateKey};
-use stacks_common::types::PublicKey;
+use stacks_common::types::chainstate::StacksBlockId;
+use stacks_common::types::chainstate::StacksPrivateKey;
 use stacks_common::util::vrf::VRFProof;
 
-use crate::burnchains::bitcoin_regtest_controller::{BitcoinRegtestController, OngoingBlockCommit};
-use crate::burnchains::make_bitcoin_indexer;
-use crate::chain_data::MinerStats;
-use crate::config::MinerConfig;
-use crate::run_loop::neon::{Counters, RunLoop};
-use crate::run_loop::RegisteredKey;
-use crate::syncctl::PoxSyncWatchdogComms;
-use crate::ChainTip;
+use clarity::vm::ast::ASTRules;
+use clarity::vm::types::PrincipalData;
 
 pub const RELAYER_MAX_BUFFER: usize = 100;
 const VRF_MOCK_MINER_KEY: u64 = 1;
@@ -231,7 +232,7 @@ pub const BLOCK_PROCESSOR_STACK_SIZE: usize = 32 * 1024 * 1024; // 32 MB
 type MinedBlocks = HashMap<BlockHeaderHash, (AssembledAnchorBlock, Secp256k1PrivateKey)>;
 
 /// Result of running the miner thread.  It could produce a Stacks block or a microblock.
-pub(crate) enum MinerThreadResult {
+enum MinerThreadResult {
     Block(
         AssembledAnchorBlock,
         Secp256k1PrivateKey,
@@ -247,7 +248,7 @@ pub(crate) enum MinerThreadResult {
 /// linked to the burnchain and what view(s) the miner had of the burnchain before and after
 /// completing the block.
 #[derive(Clone)]
-pub struct AssembledAnchorBlock {
+struct AssembledAnchorBlock {
     /// Consensus hash of the parent Stacks block
     parent_consensus_hash: ConsensusHash,
     /// Burnchain tip's block hash when we finished mining
@@ -300,15 +301,6 @@ pub struct Globals {
     pub should_keep_running: Arc<AtomicBool>,
     /// Status of our VRF key registration state (shared between the main thread and the relayer)
     leader_key_registration_state: Arc<Mutex<LeaderKeyRegistrationState>>,
-    /// Last miner config loaded
-    last_miner_config: Arc<Mutex<Option<MinerConfig>>>,
-    /// burnchain height at which we start mining
-    start_mining_height: Arc<Mutex<u64>>,
-    /// estimated winning probability at given bitcoin block heights
-    estimated_winning_probs: Arc<Mutex<HashMap<u64, f64>>>,
-    /// previously-selected best tips
-    /// maps stacks height to tip candidate
-    previous_best_tips: Arc<Mutex<BTreeMap<u64, TipCandidate>>>,
 }
 
 /// Miner chain tip, on top of which to build microblocks
@@ -352,7 +344,6 @@ impl Globals {
         counters: Counters,
         sync_comms: PoxSyncWatchdogComms,
         should_keep_running: Arc<AtomicBool>,
-        start_mining_height: u64,
     ) -> Globals {
         Globals {
             last_sortition: Arc::new(Mutex::new(None)),
@@ -366,10 +357,6 @@ impl Globals {
             leader_key_registration_state: Arc::new(Mutex::new(
                 LeaderKeyRegistrationState::Inactive,
             )),
-            last_miner_config: Arc::new(Mutex::new(None)),
-            start_mining_height: Arc::new(Mutex::new(start_mining_height)),
-            estimated_winning_probs: Arc::new(Mutex::new(HashMap::new())),
-            previous_best_tips: Arc::new(Mutex::new(BTreeMap::new())),
         }
     }
 
@@ -509,8 +496,8 @@ impl Globals {
         &self,
         burn_block_height: u64,
         key_registers: Vec<LeaderKeyRegisterOp>,
-    ) -> Option<RegisteredKey> {
-        let mut activated_key = None;
+    ) -> bool {
+        let mut activated = false;
         match self.leader_key_registration_state.lock() {
             Ok(ref mut leader_key_registration_state) => {
                 for op in key_registers.into_iter() {
@@ -522,17 +509,14 @@ impl Globals {
                             burn_block_height, txid
                         );
                         if txid == op.txid {
-                            let active_key = RegisteredKey {
-                                target_block_height,
-                                vrf_public_key: op.public_key,
-                                block_height: op.block_height as u64,
-                                op_vtxindex: op.vtxindex as u32,
-                            };
-
                             **leader_key_registration_state =
-                                LeaderKeyRegistrationState::Active(active_key.clone());
-
-                            activated_key = Some(active_key);
+                                LeaderKeyRegistrationState::Active(RegisteredKey {
+                                    target_block_height,
+                                    vrf_public_key: op.public_key,
+                                    block_height: op.block_height as u64,
+                                    op_vtxindex: op.vtxindex as u32,
+                                });
+                            activated = true;
                         } else {
                             debug!(
                                 "key_register_op {} does not match our pending op {}",
@@ -547,126 +531,7 @@ impl Globals {
                 panic!();
             }
         }
-        activated_key
-    }
-
-    /// Directly set the leader key activation state from a saved key
-    pub fn resume_leader_key(&self, registered_key: RegisteredKey) {
-        match self.leader_key_registration_state.lock() {
-            Ok(ref mut leader_key_registration_state) => {
-                **leader_key_registration_state = LeaderKeyRegistrationState::Active(registered_key)
-            }
-            Err(_e) => {
-                error!("FATAL: failed to lock leader key registration state mutex");
-                panic!();
-            }
-        }
-    }
-
-    /// Get the last miner config loaded
-    pub fn get_last_miner_config(&self) -> Option<MinerConfig> {
-        match self.last_miner_config.lock() {
-            Ok(last_miner_config) => (*last_miner_config).clone(),
-            Err(_e) => {
-                error!("FATAL; failed to lock last miner config");
-                panic!();
-            }
-        }
-    }
-
-    /// Set the last miner config loaded
-    pub fn set_last_miner_config(&self, miner_config: MinerConfig) {
-        match self.last_miner_config.lock() {
-            Ok(ref mut last_miner_config) => **last_miner_config = Some(miner_config),
-            Err(_e) => {
-                error!("FATAL; failed to lock last miner config");
-                panic!();
-            }
-        }
-    }
-
-    /// Get the height at which we should start mining
-    pub fn get_start_mining_height(&self) -> u64 {
-        match self.start_mining_height.lock() {
-            Ok(ht) => *ht,
-            Err(_e) => {
-                error!("FATAL: failed to lock start_mining_height");
-                panic!();
-            }
-        }
-    }
-
-    /// Set the height at which we started mining.
-    /// Only takes effect if the current start mining height is 0.
-    pub fn set_start_mining_height_if_zero(&self, value: u64) {
-        match self.start_mining_height.lock() {
-            Ok(ref mut ht) => {
-                if **ht == 0 {
-                    **ht = value;
-                }
-            }
-            Err(_e) => {
-                error!("FATAL: failed to lock start_mining_height");
-                panic!();
-            }
-        }
-    }
-
-    /// Record an estimated winning probability
-    pub fn add_estimated_win_prob(&self, burn_height: u64, win_prob: f64) {
-        match self.estimated_winning_probs.lock() {
-            Ok(mut probs) => {
-                probs.insert(burn_height, win_prob);
-            }
-            Err(_e) => {
-                error!("FATAL: failed to lock estimated_winning_probs");
-                panic!();
-            }
-        }
-    }
-
-    /// Get the estimated winning probability, if we have one
-    pub fn get_estimated_win_prob(&self, burn_height: u64) -> Option<f64> {
-        match self.estimated_winning_probs.lock() {
-            Ok(probs) => probs.get(&burn_height).cloned(),
-            Err(_e) => {
-                error!("FATAL: failed to lock estimated_winning_probs");
-                panic!();
-            }
-        }
-    }
-
-    /// Record a best-tip
-    pub fn add_best_tip(&self, stacks_height: u64, tip_candidate: TipCandidate, max_depth: u64) {
-        match self.previous_best_tips.lock() {
-            Ok(mut tips) => {
-                tips.insert(stacks_height, tip_candidate);
-                let mut stale = vec![];
-                for (prev_height, _) in tips.iter() {
-                    if *prev_height + max_depth < stacks_height {
-                        stale.push(*prev_height);
-                    }
-                }
-                for height in stale.into_iter() {
-                    tips.remove(&height);
-                }
-            }
-            Err(_e) => {
-                error!("FATAL: failed to lock previous_best_tips");
-                panic!();
-            }
-        }
-    }
-
-    /// Get a best-tip at a previous height
-    pub fn get_best_tip(&self, stacks_height: u64) -> Option<TipCandidate> {
-        match self.previous_best_tips.lock() {
-            Ok(tips) => tips.get(&stacks_height).cloned(),
-            Err(_e) => {
-                error!("FATAL: failed to lock previous_best_tips");
-                panic!();
-            }
-        }
+        activated
     }
 }
 
@@ -880,7 +745,7 @@ pub struct RelayerThread {
     mined_stacks_block: bool,
 }
 
-pub(crate) struct BlockMinerThread {
+struct BlockMinerThread {
     /// node config struct
     config: Config,
     /// handle to global state
@@ -1198,6 +1063,8 @@ impl MicroblockMinerThread {
 
             #[cfg(any(test, feature = "testing"))]
             {
+                use std::fs;
+                use std::io::Write;
                 use std::path::Path;
                 if let Ok(path) = std::env::var("STACKS_BAD_BLOCKS_DIR") {
                     // record this microblock somewhere
@@ -1349,46 +1216,6 @@ impl MicroblockMinerThread {
     }
 }
 
-/// Candidate chain tip
-#[derive(Debug, Clone, PartialEq)]
-pub struct TipCandidate {
-    pub stacks_height: u64,
-    pub consensus_hash: ConsensusHash,
-    pub anchored_block_hash: BlockHeaderHash,
-    pub parent_consensus_hash: ConsensusHash,
-    pub parent_anchored_block_hash: BlockHeaderHash,
-    /// the block's sortition's burnchain height
-    pub burn_height: u64,
-    /// the number of Stacks blocks *at the same height* as this one, but from earlier sortitions
-    /// than `burn_height`
-    pub num_earlier_siblings: u64,
-}
-
-impl TipCandidate {
-    pub fn id(&self) -> StacksBlockId {
-        StacksBlockId::new(&self.consensus_hash, &self.anchored_block_hash)
-    }
-
-    pub fn parent_id(&self) -> StacksBlockId {
-        StacksBlockId::new(
-            &self.parent_consensus_hash,
-            &self.parent_anchored_block_hash,
-        )
-    }
-
-    pub fn new(tip: StagingBlock, burn_height: u64) -> Self {
-        Self {
-            stacks_height: tip.height,
-            consensus_hash: tip.consensus_hash,
-            anchored_block_hash: tip.anchored_block_hash,
-            parent_consensus_hash: tip.parent_consensus_hash,
-            parent_anchored_block_hash: tip.parent_anchored_block_hash,
-            burn_height,
-            num_earlier_siblings: 0,
-        }
-    }
-}
-
 impl BlockMinerThread {
     /// Instantiate the miner thread from its parent RelayerThread
     pub fn from_relayer_thread(
@@ -1411,12 +1238,11 @@ impl BlockMinerThread {
 
     /// Get the coinbase recipient address, if set in the config and if allowed in this epoch
     fn get_coinbase_recipient(&self, epoch_id: StacksEpochId) -> Option<PrincipalData> {
-        let miner_config = self.config.get_miner_config();
-        if epoch_id < StacksEpochId::Epoch21 && miner_config.block_reward_recipient.is_some() {
+        if epoch_id < StacksEpochId::Epoch21 && self.config.miner.block_reward_recipient.is_some() {
             warn!("Coinbase pay-to-contract is not supported in the current epoch");
             None
         } else {
-            miner_config.block_reward_recipient.clone()
+            self.config.miner.block_reward_recipient.clone()
         }
     }
 
@@ -1527,320 +1353,6 @@ impl BlockMinerThread {
         ret
     }
 
-    /// Load all candidate tips upon which to build.  This is all Stacks blocks whose heights are
-    /// less than or equal to at `at_stacks_height` (or the canonical chain tip height, if not given),
-    /// but greater than or equal to this end height minus `max_depth`.
-    /// Returns the list of all Stacks blocks up to max_depth blocks beneath it.
-    /// The blocks will be sorted first by stacks height, and then by burnchain height
-    pub(crate) fn load_candidate_tips(
-        burn_db: &mut SortitionDB,
-        chain_state: &mut StacksChainState,
-        max_depth: u64,
-        at_stacks_height: Option<u64>,
-    ) -> Vec<TipCandidate> {
-        let stacks_tips = if let Some(start_height) = at_stacks_height {
-            chain_state
-                .get_stacks_chain_tips_at_height(start_height)
-                .expect("FATAL: could not query chain tips at start height")
-        } else {
-            chain_state
-                .get_stacks_chain_tips(burn_db)
-                .expect("FATAL: could not query chain tips")
-        };
-
-        if stacks_tips.len() == 0 {
-            return vec![];
-        }
-
-        let mut considered = HashSet::new();
-        let mut candidates = vec![];
-        let end_height = stacks_tips[0].height;
-
-        for cur_height in end_height.saturating_sub(max_depth)..=end_height {
-            let stacks_tips = chain_state
-                .get_stacks_chain_tips_at_height(cur_height)
-                .expect("FATAL: could not query chain tips at height");
-
-            for tip in stacks_tips {
-                let index_block_hash =
-                    StacksBlockId::new(&tip.consensus_hash, &tip.anchored_block_hash);
-
-                if !considered.contains(&index_block_hash) {
-                    let burn_height = burn_db
-                        .get_consensus_hash_height(&tip.consensus_hash)
-                        .expect("FATAL: could not query burnchain block height")
-                        .expect("FATAL: no burnchain block height for Stacks tip");
-                    let candidate = TipCandidate::new(tip, burn_height);
-                    candidates.push(candidate);
-                    considered.insert(index_block_hash);
-                }
-            }
-        }
-        Self::sort_and_populate_candidates(candidates)
-    }
-
-    /// Put all tip candidates in order by stacks height, breaking ties with burnchain height.
-    /// Also, count up the number of earliersiblings each tip has -- i.e. the number of stacks
-    /// blocks that have the same height, but a later burnchain sortition.
-    pub(crate) fn sort_and_populate_candidates(
-        mut candidates: Vec<TipCandidate>,
-    ) -> Vec<TipCandidate> {
-        if candidates.len() == 0 {
-            return candidates;
-        }
-        candidates.sort_by(|tip1, tip2| {
-            // stacks block height, then burnchain block height
-            let ord = tip1.stacks_height.cmp(&tip2.stacks_height);
-            if ord == CmpOrdering::Equal {
-                return tip1.burn_height.cmp(&tip2.burn_height);
-            }
-            ord
-        });
-
-        // calculate the number of earlier siblings for each block.
-        // this is the number of stacks blocks at the same height, but later burnchain heights.
-        let mut idx = 0;
-        let mut cur_stacks_height = candidates[idx].stacks_height;
-        let mut num_siblings = 0;
-        loop {
-            idx += 1;
-            if idx >= candidates.len() {
-                break;
-            }
-            if cur_stacks_height == candidates[idx].stacks_height {
-                // same stacks height, so this block has one more earlier sibling than the last
-                num_siblings += 1;
-                candidates[idx].num_earlier_siblings = num_siblings;
-            } else {
-                // new stacks height, so no earlier siblings
-                num_siblings = 0;
-                cur_stacks_height = candidates[idx].stacks_height;
-                candidates[idx].num_earlier_siblings = 0;
-            }
-        }
-
-        candidates
-    }
-
-    /// Select the best tip to mine the next block on. Potential tips are all
-    /// leaf nodes where the Stacks block height is <= the max height -
-    /// max_reorg_depth. Each potential tip is then scored based on the amount
-    /// of orphans that its chain has caused -- that is, the number of orphans
-    /// that the tip _and all of its ancestors_ (up to `max_depth`) created.
-    /// The tip with the lowest score is composed of blocks that collectively made the fewest
-    /// orphans, and is thus the "nicest" chain with the least orphaning.  This is the tip that is
-    /// selected.
-    pub fn pick_best_tip(
-        globals: &Globals,
-        config: &Config,
-        burn_db: &mut SortitionDB,
-        chain_state: &mut StacksChainState,
-        at_stacks_height: Option<u64>,
-    ) -> Option<TipCandidate> {
-        info!("Picking best Stacks tip");
-        let miner_config = config.get_miner_config();
-        let max_depth = miner_config.max_reorg_depth;
-
-        // There could be more than one possible chain tip. Go find them.
-        let stacks_tips =
-            Self::load_candidate_tips(burn_db, chain_state, max_depth, at_stacks_height);
-
-        let mut previous_best_tips = HashMap::new();
-        for tip in stacks_tips.iter() {
-            let Some(prev_best_tip) = globals.get_best_tip(tip.stacks_height) else {
-                continue;
-            };
-            previous_best_tips.insert(tip.stacks_height, prev_best_tip);
-        }
-
-        let best_tip_opt = Self::inner_pick_best_tip(stacks_tips, previous_best_tips);
-        if let Some(best_tip) = best_tip_opt.as_ref() {
-            globals.add_best_tip(best_tip.stacks_height, best_tip.clone(), max_depth);
-        } else {
-            // no best-tip found; revert to old tie-breaker logic
-            info!("No best-tips found; using old tie-breaking logic");
-            return chain_state
-                .get_stacks_chain_tip(burn_db)
-                .expect("FATAL: could not load chain tip")
-                .map(|staging_block| {
-                    let burn_height = burn_db
-                        .get_consensus_hash_height(&staging_block.consensus_hash)
-                        .expect("FATAL: could not query burnchain block height")
-                        .expect("FATAL: no burnchain block height for Stacks tip");
-                    TipCandidate::new(staging_block, burn_height)
-                });
-        }
-        best_tip_opt
-    }
-
-    /// Given a list of sorted candidate tips, pick the best one.  See `Self::pick_best_tip()`.
-    /// Takes the list of stacks tips that are eligible to be built on, and a map of
-    /// previously-chosen best tips (so if we chose a tip in the past, we keep confirming it, even
-    /// if subsequent stacks blocks show up).  The previous best tips should be from recent Stacks
-    /// heights; it's important that older best-tips are forgotten in order to ensure that miners
-    /// will eventually (e.g. after `max_reorg_depth` Stacks blocks pass) stop trying to confirm a
-    /// now-orphaned previously-chosen best-tip.  If there are multiple best-tips that conflict in
-    /// `previosu_best_tips`, then only the highest one which the leaf could confirm will be
-    /// considered (since the node updates its understanding of the best-tip on each RunTenure).
-    pub(crate) fn inner_pick_best_tip(
-        stacks_tips: Vec<TipCandidate>,
-        previous_best_tips: HashMap<u64, TipCandidate>,
-    ) -> Option<TipCandidate> {
-        // identify leaf tips -- i.e. blocks with no children
-        let parent_consensus_hashes: HashSet<_> = stacks_tips
-            .iter()
-            .map(|x| x.parent_consensus_hash.clone())
-            .collect();
-
-        let mut leaf_tips: Vec<_> = stacks_tips
-            .iter()
-            .filter(|x| !parent_consensus_hashes.contains(&x.consensus_hash))
-            .collect();
-
-        if leaf_tips.len() == 0 {
-            return None;
-        }
-
-        // Make scoring deterministic in the case of a tie.
-        // Prefer leafs that were mined earlier on the burnchain,
-        // but which pass through previously-determined best tips.
-        leaf_tips.sort_by(|tip1, tip2| {
-            // stacks block height, then burnchain block height
-            let ord = tip1.stacks_height.cmp(&tip2.stacks_height);
-            if ord == CmpOrdering::Equal {
-                return tip1.burn_height.cmp(&tip2.burn_height);
-            }
-            ord
-        });
-
-        let mut scores = BTreeMap::new();
-        for (i, leaf_tip) in leaf_tips.iter().enumerate() {
-            let leaf_id = leaf_tip.id();
-            // Score each leaf tip as the number of preceding Stacks blocks that are _not_ an
-            // ancestor.  Because stacks_tips are in order by stacks height, a linear scan of this
-            // list will allow us to match all ancestors in the last max_depth Stacks blocks.
-            // `ancestor_ptr` tracks the next expected ancestor.
-            let mut ancestor_ptr = leaf_tip.parent_id();
-            let mut score: u64 = 0;
-            let mut score_summaries = vec![];
-
-            // find the highest stacks_tip we must confirm
-            let mut must_confirm = None;
-            for tip in stacks_tips.iter().rev() {
-                if let Some(prev_best_tip) = previous_best_tips.get(&tip.stacks_height) {
-                    if leaf_id != prev_best_tip.id() {
-                        // the `ancestor_ptr` must pass through this prior best-tip
-                        must_confirm = Some(prev_best_tip.clone());
-                        break;
-                    }
-                }
-            }
-
-            for tip in stacks_tips.iter().rev() {
-                if let Some(required_ancestor) = must_confirm.as_ref() {
-                    if tip.stacks_height < required_ancestor.stacks_height
-                        && leaf_tip.stacks_height >= required_ancestor.stacks_height
-                    {
-                        // This leaf does not confirm a previous-best-tip, so assign it the
-                        // worst-possible score.
-                        info!("Tip #{} {}/{} at {}:{} conflicts with a previous best-tip {}/{} at {}:{}",
-                              i,
-                              &leaf_tip.consensus_hash,
-                              &leaf_tip.anchored_block_hash,
-                              leaf_tip.burn_height,
-                              leaf_tip.stacks_height,
-                              &required_ancestor.consensus_hash,
-                              &required_ancestor.anchored_block_hash,
-                              required_ancestor.burn_height,
-                              required_ancestor.stacks_height
-                        );
-                        score = u64::MAX;
-                        score_summaries.push(format!("{} (best-tip reorged)", u64::MAX));
-                        break;
-                    }
-                }
-                if tip.id() == leaf_id {
-                    // we can't orphan ourselves
-                    continue;
-                }
-                if leaf_tip.stacks_height < tip.stacks_height {
-                    // this tip is further along than leaf_tip, so canonicalizing leaf_tip would
-                    // orphan `tip.stacks_height - leaf_tip.stacks_height` blocks.
-                    score = score.saturating_add(tip.stacks_height - leaf_tip.stacks_height);
-                    score_summaries.push(format!(
-                        "{} (stx height diff)",
-                        tip.stacks_height - leaf_tip.stacks_height
-                    ));
-                } else if leaf_tip.stacks_height == tip.stacks_height
-                    && leaf_tip.burn_height > tip.burn_height
-                {
-                    // this tip has the same stacks height as the leaf, but its sortition happened
-                    // earlier. This means that the leaf is trying to orphan this block and all
-                    // blocks sortition'ed up to this leaf.  The miner should have instead tried to
-                    // confirm this existing tip, instead of mine a sibling.
-                    score = score.saturating_add(tip.num_earlier_siblings + 1);
-                    score_summaries.push(format!("{} (uncles)", tip.num_earlier_siblings + 1));
-                }
-                if tip.id() == ancestor_ptr {
-                    // did we confirm a previous best-tip? If so, then clear this
-                    if let Some(required_ancestor) = must_confirm.take() {
-                        if required_ancestor.id() != tip.id() {
-                            // did not confirm, so restoroe
-                            must_confirm = Some(required_ancestor);
-                        }
-                    }
-
-                    // this stacks tip is the next ancestor.  However, that ancestor may have
-                    // earlier-sortition'ed siblings that confirming this tip would orphan, so count those.
-                    ancestor_ptr = tip.parent_id();
-                    score = score.saturating_add(tip.num_earlier_siblings);
-                    score_summaries.push(format!("{} (earlier sibs)", tip.num_earlier_siblings));
-                } else {
-                    // this stacks tip is not an ancestor, and would be orphaned if leaf_tip is
-                    // canonical.
-                    score = score.saturating_add(1);
-                    score_summaries.push(format!("{} (non-ancestor)", 1));
-                }
-            }
-
-            info!(
-                "Tip #{} {}/{} at {}:{} has score {} ({})",
-                i,
-                &leaf_tip.consensus_hash,
-                &leaf_tip.anchored_block_hash,
-                leaf_tip.burn_height,
-                leaf_tip.stacks_height,
-                score,
-                score_summaries.join(" + ").to_string()
-            );
-            if score < u64::MAX {
-                scores.insert(i, score);
-            }
-        }
-
-        if scores.len() == 0 {
-            // revert to prior tie-breaking scheme
-            return None;
-        }
-
-        // The lowest score is the "nicest" tip (least amount of orphaning)
-        let best_tip_idx = scores
-            .iter()
-            .min_by_key(|(_, score)| *score)
-            .expect("FATAL: candidates should not be empty here")
-            .0;
-
-        let best_tip = leaf_tips
-            .get(*best_tip_idx)
-            .expect("FATAL: candidates should not be empty");
-
-        info!(
-            "Best tip is #{} {}/{}",
-            best_tip_idx, &best_tip.consensus_hash, &best_tip.anchored_block_hash
-        );
-        Some((*best_tip).clone())
-    }
-
     /// Load up the parent block info for mining.
     /// If there's no parent because this is the first block, then return the genesis block's info.
     /// If we can't find the parent in the DB but we expect one, return None.
@@ -1848,25 +1360,22 @@ impl BlockMinerThread {
         &self,
         burn_db: &mut SortitionDB,
         chain_state: &mut StacksChainState,
-    ) -> (Option<ParentStacksBlockInfo>, bool) {
+    ) -> Option<ParentStacksBlockInfo> {
         if let Some(stacks_tip) = chain_state
             .get_stacks_chain_tip(burn_db)
             .expect("FATAL: could not query chain tip")
         {
-            let best_stacks_tip =
-                Self::pick_best_tip(&self.globals, &self.config, burn_db, chain_state, None)
-                    .expect("FATAL: no best chain tip");
             let miner_address = self
                 .keychain
                 .origin_address(self.config.is_mainnet())
                 .unwrap();
-            let parent_info = match ParentStacksBlockInfo::lookup(
+            match ParentStacksBlockInfo::lookup(
                 chain_state,
                 burn_db,
                 &self.burn_block,
                 miner_address,
-                &best_stacks_tip.consensus_hash,
-                &best_stacks_tip.anchored_block_hash,
+                &stacks_tip.consensus_hash,
+                &stacks_tip.anchored_block_hash,
             ) {
                 Ok(parent_info) => Some(parent_info),
                 Err(Error::BurnchainTipChanged) => {
@@ -1874,16 +1383,7 @@ impl BlockMinerThread {
                     None
                 }
                 Err(..) => None,
-            };
-            if parent_info.is_none() {
-                warn!(
-                    "No parent for best-tip {}/{}",
-                    &best_stacks_tip.consensus_hash, &best_stacks_tip.anchored_block_hash
-                );
             }
-            let canonical = best_stacks_tip.consensus_hash == stacks_tip.consensus_hash
-                && best_stacks_tip.anchored_block_hash == stacks_tip.anchored_block_hash;
-            (parent_info, canonical)
         } else {
             debug!("No Stacks chain tip known, will return a genesis block");
             let (network, _) = self.config.burnchain.get_bitcoin_network();
@@ -1897,30 +1397,26 @@ impl BlockMinerThread {
                 burnchain_params.first_block_timestamp.into(),
             );
 
-            (
-                Some(ParentStacksBlockInfo {
-                    stacks_parent_header: chain_tip.metadata,
-                    parent_consensus_hash: FIRST_BURNCHAIN_CONSENSUS_HASH.clone(),
-                    parent_block_burn_height: 0,
-                    parent_block_total_burn: 0,
-                    parent_winning_vtxindex: 0,
-                    coinbase_nonce: 0,
-                }),
-                true,
-            )
+            Some(ParentStacksBlockInfo {
+                stacks_parent_header: chain_tip.metadata,
+                parent_consensus_hash: FIRST_BURNCHAIN_CONSENSUS_HASH.clone(),
+                parent_block_burn_height: 0,
+                parent_block_total_burn: 0,
+                parent_winning_vtxindex: 0,
+                coinbase_nonce: 0,
+            })
         }
     }
 
     /// Determine which attempt this will be when mining a block, and whether or not an attempt
     /// should even be made.
-    /// Returns Some(attempt, max-txs) if we should attempt to mine (and what attempt it will be)
+    /// Returns Some(attempt) if we should attempt to mine (and what attempt it will be)
     /// Returns None if we should not mine.
     fn get_mine_attempt(
         &self,
         chain_state: &StacksChainState,
         parent_block_info: &ParentStacksBlockInfo,
-        force: bool,
-    ) -> Option<(u64, u64)> {
+    ) -> Option<u64> {
         let parent_consensus_hash = &parent_block_info.parent_consensus_hash;
         let stacks_parent_header = &parent_block_info.stacks_parent_header;
         let parent_block_burn_height = parent_block_info.parent_block_burn_height;
@@ -1929,28 +1425,22 @@ impl BlockMinerThread {
             Self::find_inflight_mined_blocks(self.burn_block.block_height, &self.last_mined_blocks);
 
         // has the tip changed from our previously-mined block for this epoch?
-        let (attempt, max_txs) = if last_mined_blocks.len() <= 1 {
+        let attempt = if last_mined_blocks.len() <= 1 {
             // always mine if we've not mined a block for this epoch yet, or
             // if we've mined just one attempt, unconditionally try again (so we
             // can use `subsequent_miner_time_ms` in this attempt)
             if last_mined_blocks.len() == 1 {
-                info!("Have only attempted one block; unconditionally trying again");
-            }
-            let attempt = last_mined_blocks.len() as u64 + 1;
-            let mut max_txs = 0;
-            for last_mined_block in last_mined_blocks.iter() {
-                max_txs = cmp::max(max_txs, last_mined_block.anchored_block.txs.len());
+                debug!("Have only attempted one block; unconditionally trying again");
             }
-            (attempt, max_txs)
+            last_mined_blocks.len() as u64 + 1
         } else {
             let mut best_attempt = 0;
-            let mut max_txs = 0;
-            info!(
+            debug!(
                 "Consider {} in-flight Stacks tip(s)",
                 &last_mined_blocks.len()
             );
             for prev_block in last_mined_blocks.iter() {
-                info!(
+                debug!(
                     "Consider in-flight block {} on Stacks tip {}/{} in {} with {} txs",
                     &prev_block.anchored_block.block_hash(),
                     &prev_block.parent_consensus_hash,
@@ -1958,7 +1448,6 @@ impl BlockMinerThread {
                     &prev_block.my_burn_hash,
                     &prev_block.anchored_block.txs.len()
                 );
-                max_txs = cmp::max(max_txs, prev_block.anchored_block.txs.len());
 
                 if prev_block.anchored_block.txs.len() == 1 && prev_block.attempt == 1 {
                     // Don't let the fact that we've built an empty block during this sortition
@@ -1994,51 +1483,47 @@ impl BlockMinerThread {
                                         as usize)
                                         + 1)
                         {
-                            if !force {
-                                // the chain tip hasn't changed since we attempted to build a block.  Use what we
-                                // already have.
-                                info!("Relayer: Stacks tip is unchanged since we last tried to mine a block off of {}/{} at height {} with {} txs, in {} at burn height {}, and no new microblocks ({} <= {} + 1)",
-                                       &prev_block.parent_consensus_hash, &prev_block.anchored_block.header.parent_block, prev_block.anchored_block.header.total_work.work,
-                                       prev_block.anchored_block.txs.len(), prev_block.my_burn_hash, parent_block_burn_height, stream.len(), prev_block.anchored_block.header.parent_microblock_sequence);
-
-                                return None;
-                            }
+                            // the chain tip hasn't changed since we attempted to build a block.  Use what we
+                            // already have.
+                            debug!("Relayer: Stacks tip is unchanged since we last tried to mine a block off of {}/{} at height {} with {} txs, in {} at burn height {}, and no new microblocks ({} <= {} + 1)",
+                                   &prev_block.parent_consensus_hash, &prev_block.anchored_block.header.parent_block, prev_block.anchored_block.header.total_work.work,
+                                   prev_block.anchored_block.txs.len(), prev_block.my_burn_hash, parent_block_burn_height, stream.len(), prev_block.anchored_block.header.parent_microblock_sequence);
+
+                            return None;
                         } else {
                             // there are new microblocks!
                             // TODO: only consider rebuilding our anchored block if we (a) have
                             // time, and (b) the new microblocks are worth more than the new BTC
                             // fee minus the old BTC fee
-                            info!("Relayer: Stacks tip is unchanged since we last tried to mine a block off of {}/{} at height {} with {} txs, in {} at burn height {}, but there are new microblocks ({} > {} + 1)",
+                            debug!("Relayer: Stacks tip is unchanged since we last tried to mine a block off of {}/{} at height {} with {} txs, in {} at burn height {}, but there are new microblocks ({} > {} + 1)",
                                    &prev_block.parent_consensus_hash, &prev_block.anchored_block.header.parent_block, prev_block.anchored_block.header.total_work.work,
                                    prev_block.anchored_block.txs.len(), prev_block.my_burn_hash, parent_block_burn_height, stream.len(), prev_block.anchored_block.header.parent_microblock_sequence);
 
                             best_attempt = cmp::max(best_attempt, prev_block.attempt);
                         }
                     } else {
-                        if !force {
-                            // no microblock stream to confirm, and the stacks tip hasn't changed
-                            info!("Relayer: Stacks tip is unchanged since we last tried to mine a block off of {}/{} at height {} with {} txs, in {} at burn height {}, and no microblocks present",
-                                   &prev_block.parent_consensus_hash, &prev_block.anchored_block.header.parent_block, prev_block.anchored_block.header.total_work.work,
-                                   prev_block.anchored_block.txs.len(), prev_block.my_burn_hash, parent_block_burn_height);
+                        // no microblock stream to confirm, and the stacks tip hasn't changed
+                        debug!("Relayer: Stacks tip is unchanged since we last tried to mine a block off of {}/{} at height {} with {} txs, in {} at burn height {}, and no microblocks present",
+                               &prev_block.parent_consensus_hash, &prev_block.anchored_block.header.parent_block, prev_block.anchored_block.header.total_work.work,
+                               prev_block.anchored_block.txs.len(), prev_block.my_burn_hash, parent_block_burn_height);
 
-                            return None;
-                        }
+                        return None;
                     }
                 } else {
                     if self.burn_block.burn_header_hash == prev_block.my_burn_hash {
                         // only try and re-mine if there was no sortition since the last chain tip
-                        info!("Relayer: Stacks tip has changed to {}/{} since we last tried to mine a block in {} at burn height {}; attempt was {} (for Stacks tip {}/{})",
+                        debug!("Relayer: Stacks tip has changed to {}/{} since we last tried to mine a block in {} at burn height {}; attempt was {} (for Stacks tip {}/{})",
                                parent_consensus_hash, stacks_parent_header.anchored_header.block_hash(), prev_block.my_burn_hash, parent_block_burn_height, prev_block.attempt, &prev_block.parent_consensus_hash, &prev_block.anchored_block.header.parent_block);
                         best_attempt = cmp::max(best_attempt, prev_block.attempt);
                     } else {
-                        info!("Relayer: Burn tip has changed to {} ({}) since we last tried to mine a block in {}",
+                        debug!("Relayer: Burn tip has changed to {} ({}) since we last tried to mine a block in {}",
                                &self.burn_block.burn_header_hash, self.burn_block.block_height, &prev_block.my_burn_hash);
                     }
                 }
             }
-            (best_attempt + 1, max_txs)
+            best_attempt + 1
         };
-        Some((attempt, u64::try_from(max_txs).expect("too many txs")))
+        Some(attempt)
     }
 
     /// Generate the VRF proof for the block we're going to build.
@@ -2202,214 +1687,6 @@ impl BlockMinerThread {
         microblock_info_opt.map(|(stream, _)| stream)
     }
 
-    /// Get the list of possible burn addresses this miner is using
-    pub fn get_miner_addrs(config: &Config, keychain: &Keychain) -> Vec<String> {
-        let mut op_signer = keychain.generate_op_signer();
-        let mut btc_addrs = vec![
-            // legacy
-            BitcoinAddress::from_bytes_legacy(
-                config.burnchain.get_bitcoin_network().1,
-                LegacyBitcoinAddressType::PublicKeyHash,
-                &Hash160::from_data(&op_signer.get_public_key().to_bytes()).0,
-            )
-            .expect("FATAL: failed to construct legacy bitcoin address"),
-        ];
-        if config.miner.segwit {
-            btc_addrs.push(
-                // segwit p2wpkh
-                BitcoinAddress::from_bytes_segwit_p2wpkh(
-                    config.burnchain.get_bitcoin_network().1,
-                    &Hash160::from_data(&op_signer.get_public_key().to_bytes_compressed()).0,
-                )
-                .expect("FATAL: failed to construct segwit p2wpkh address"),
-            );
-        }
-        btc_addrs
-            .into_iter()
-            .map(|addr| format!("{}", &addr))
-            .collect()
-    }
-
-    /// Obtain the target burn fee cap, when considering how well this miner is performing.
-    pub fn get_mining_spend_amount<F, G>(
-        config: &Config,
-        keychain: &Keychain,
-        burnchain: &Burnchain,
-        sortdb: &SortitionDB,
-        recipients: &[PoxAddress],
-        start_mine_height: u64,
-        at_burn_block: Option<u64>,
-        mut get_prior_winning_prob: F,
-        mut set_prior_winning_prob: G,
-    ) -> u64
-    where
-        F: FnMut(u64) -> f64,
-        G: FnMut(u64, f64),
-    {
-        let config_file_burn_fee_cap = config.get_burnchain_config().burn_fee_cap;
-        let miner_config = config.get_miner_config();
-
-        if miner_config.target_win_probability < 0.00001 {
-            // this field is effectively zero
-            return config_file_burn_fee_cap;
-        }
-        let Some(miner_stats) = config.get_miner_stats() else {
-            return config_file_burn_fee_cap;
-        };
-
-        let Ok(tip) = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn()).map_err(|e| {
-            warn!("Failed to load canonical burn chain tip: {:?}", &e);
-            e
-        }) else {
-            return config_file_burn_fee_cap;
-        };
-        let tip = if let Some(at_burn_block) = at_burn_block.as_ref() {
-            let ih = sortdb.index_handle(&tip.sortition_id);
-            let Ok(Some(ancestor_tip)) = ih.get_block_snapshot_by_height(*at_burn_block) else {
-                warn!(
-                    "Failed to load ancestor tip at burn height {}",
-                    at_burn_block
-                );
-                return config_file_burn_fee_cap;
-            };
-            ancestor_tip
-        } else {
-            tip
-        };
-
-        let Ok(active_miners_and_commits) = MinerStats::get_active_miners(sortdb, at_burn_block)
-            .map_err(|e| {
-                warn!("Failed to get active miners: {:?}", &e);
-                e
-            })
-        else {
-            return config_file_burn_fee_cap;
-        };
-        if active_miners_and_commits.len() == 0 {
-            warn!("No active miners detected; using config file burn_fee_cap");
-            return config_file_burn_fee_cap;
-        }
-
-        let active_miners: Vec<_> = active_miners_and_commits
-            .iter()
-            .map(|(miner, _cmt)| miner.as_str())
-            .collect();
-
-        info!("Active miners: {:?}", &active_miners);
-
-        let Ok(unconfirmed_block_commits) = miner_stats
-            .get_unconfirmed_commits(tip.block_height + 1, &active_miners)
-            .map_err(|e| {
-                warn!("Failed to find unconfirmed block-commits: {}", &e);
-                e
-            })
-        else {
-            return config_file_burn_fee_cap;
-        };
-
-        let unconfirmed_miners_and_amounts: Vec<(String, u64)> = unconfirmed_block_commits
-            .iter()
-            .map(|cmt| (cmt.apparent_sender.to_string(), cmt.burn_fee))
-            .collect();
-
-        info!(
-            "Found unconfirmed block-commits: {:?}",
-            &unconfirmed_miners_and_amounts
-        );
-
-        let (spend_dist, _total_spend) = MinerStats::get_spend_distribution(
-            &active_miners_and_commits,
-            &unconfirmed_block_commits,
-            &recipients,
-        );
-        let win_probs = if miner_config.fast_rampup {
-            // look at spends 6+ blocks in the future
-            let win_probs = MinerStats::get_future_win_distribution(
-                &active_miners_and_commits,
-                &unconfirmed_block_commits,
-                &recipients,
-            );
-            win_probs
-        } else {
-            // look at the current spends
-            let Ok(unconfirmed_burn_dist) = miner_stats
-                .get_unconfirmed_burn_distribution(
-                    burnchain,
-                    sortdb,
-                    &active_miners_and_commits,
-                    unconfirmed_block_commits,
-                    recipients,
-                    at_burn_block,
-                )
-                .map_err(|e| {
-                    warn!("Failed to get unconfirmed burn distribution: {:?}", &e);
-                    e
-                })
-            else {
-                return config_file_burn_fee_cap;
-            };
-
-            let win_probs = MinerStats::burn_dist_to_prob_dist(&unconfirmed_burn_dist);
-            win_probs
-        };
-
-        info!("Unconfirmed spend distribution: {:?}", &spend_dist);
-        info!(
-            "Unconfirmed win probabilities (fast_rampup={}): {:?}",
-            miner_config.fast_rampup, &win_probs
-        );
-
-        let miner_addrs = Self::get_miner_addrs(config, keychain);
-        let win_prob = miner_addrs
-            .iter()
-            .find_map(|x| win_probs.get(x))
-            .copied()
-            .unwrap_or(0.0);
-
-        info!(
-            "This miner's win probability at {} is {}",
-            tip.block_height, &win_prob
-        );
-        set_prior_winning_prob(tip.block_height, win_prob);
-
-        if win_prob < config.miner.target_win_probability {
-            // no mining strategy is viable, so just quit.
-            // Unless we're spinning up, that is.
-            if start_mine_height + 6 < tip.block_height
-                && config.miner.underperform_stop_threshold.is_some()
-            {
-                let underperform_stop_threshold =
-                    config.miner.underperform_stop_threshold.unwrap_or(0);
-                info!(
-                    "Miner is spun up, but is not meeting target win probability as of {}",
-                    tip.block_height
-                );
-                // we've spun up and we're underperforming. How long do we tolerate this?
-                let mut underperformed_count = 0;
-                for depth in 0..underperform_stop_threshold {
-                    let prior_burn_height = tip.block_height.saturating_sub(depth);
-                    let prior_win_prob = get_prior_winning_prob(prior_burn_height);
-                    if prior_win_prob < config.miner.target_win_probability {
-                        info!(
-                            "Miner underperformed in block {} ({}/{})",
-                            prior_burn_height, underperformed_count, underperform_stop_threshold
-                        );
-                        underperformed_count += 1;
-                    }
-                }
-                if underperformed_count == underperform_stop_threshold {
-                    warn!(
-                        "Miner underperformed since burn height {}; spinning down",
-                        start_mine_height + 6 + underperform_stop_threshold
-                    );
-                    return 0;
-                }
-            }
-        }
-
-        config_file_burn_fee_cap
-    }
-
     /// Produce the block-commit for this anchored block, if we can.
     /// Returns the op on success
     /// Returns None if we fail somehow.
@@ -2439,6 +1716,15 @@ impl BlockMinerThread {
             }
         };
 
+        // let burn_fee_cap = self.config.burnchain.burn_fee_cap;
+        let burn_fee_cap = get_mining_spend_amount(self.globals.get_miner_status());
+        let sunset_burn = self.burnchain.expected_sunset_burn(
+            self.burn_block.block_height + 1,
+            burn_fee_cap,
+            target_epoch_id,
+        );
+        let rest_commit = burn_fee_cap - sunset_burn;
+
         let commit_outs = if !self
             .burnchain
             .pox_constants
@@ -2452,32 +1738,6 @@ impl BlockMinerThread {
             vec![PoxAddress::standard_burn_address(self.config.is_mainnet())]
         };
 
-        let burn_fee_cap = Self::get_mining_spend_amount(
-            &self.config,
-            &self.keychain,
-            &self.burnchain,
-            burn_db,
-            &commit_outs,
-            self.globals.get_start_mining_height(),
-            None,
-            |block_height| {
-                self.globals
-                    .get_estimated_win_prob(block_height)
-                    .unwrap_or(0.0)
-            },
-            |block_height, win_prob| self.globals.add_estimated_win_prob(block_height, win_prob),
-        );
-        if burn_fee_cap == 0 {
-            warn!("Calculated burn_fee_cap is 0; will not mine");
-            return None;
-        }
-        let sunset_burn = self.burnchain.expected_sunset_burn(
-            self.burn_block.block_height + 1,
-            burn_fee_cap,
-            target_epoch_id,
-        );
-        let rest_commit = burn_fee_cap - sunset_burn;
-
         // let's commit, but target the current burnchain tip with our modulus
         let op = self.inner_generate_block_commit_op(
             block_hash,
@@ -2580,19 +1840,6 @@ impl BlockMinerThread {
             self.ongoing_commit.clone(),
         );
 
-        let miner_config = self.config.get_miner_config();
-        let last_miner_config_opt = self.globals.get_last_miner_config();
-        let force_remine = if let Some(last_miner_config) = last_miner_config_opt {
-            last_miner_config != miner_config
-        } else {
-            false
-        };
-        if force_remine {
-            info!("Miner config changed; forcing a re-mine attempt");
-        }
-
-        self.globals.set_last_miner_config(miner_config);
-
         // NOTE: read-write access is needed in order to be able to query the recipient set.
         // This is an artifact of the way the MARF is built (see #1449)
         let mut burn_db =
@@ -2618,14 +1865,8 @@ impl BlockMinerThread {
                 .ok()?
                 .expect("FATAL: no epoch defined")
                 .epoch_id;
-
-        let (Some(mut parent_block_info), _) =
-            self.load_block_parent_info(&mut burn_db, &mut chain_state)
-        else {
-            return None;
-        };
-        let (attempt, max_txs) =
-            self.get_mine_attempt(&chain_state, &parent_block_info, force_remine)?;
+        let mut parent_block_info = self.load_block_parent_info(&mut burn_db, &mut chain_state)?;
+        let attempt = self.get_mine_attempt(&chain_state, &parent_block_info)?;
         let vrf_proof = self.make_vrf_proof()?;
 
         // Generates a new secret key for signing the trail of microblocks
@@ -2738,24 +1979,6 @@ impl BlockMinerThread {
             }
         };
 
-        let miner_config = self.config.get_miner_config();
-
-        if attempt > 1
-            && miner_config.min_tx_count > 0
-            && u64::try_from(anchored_block.txs.len()).expect("too many txs")
-                < miner_config.min_tx_count
-        {
-            info!("Relayer: Succeeded assembling subsequent block with {} txs, but expected at least {}", anchored_block.txs.len(), miner_config.min_tx_count);
-            return None;
-        }
-
-        if miner_config.only_increase_tx_count
-            && max_txs > u64::try_from(anchored_block.txs.len()).expect("too many txs")
-        {
-            info!("Relayer: Succeeded assembling subsequent block with {} txs, but had previously produced a block with {} txs", anchored_block.txs.len(), max_txs);
-            return None;
-        }
-
         info!(
             "Relayer: Succeeded assembling {} block #{}: {}, with {} txs, attempt {}",
             if parent_block_info.parent_block_total_burn == 0 {
@@ -2779,11 +2002,6 @@ impl BlockMinerThread {
             &vrf_proof,
             target_epoch_id,
         )?;
-        let burn_fee = if let BlockstackOperationType::LeaderBlockCommit(ref op) = &op {
-            op.burn_fee
-        } else {
-            0
-        };
 
         // last chance -- confirm that the stacks tip is unchanged (since it could have taken long
         // enough to build this block that another block could have arrived), and confirm that all
@@ -2791,13 +2009,10 @@ impl BlockMinerThread {
         let cur_burn_chain_tip = SortitionDB::get_canonical_burn_chain_tip(burn_db.conn())
             .expect("FATAL: failed to query sortition DB for canonical burn chain tip");
 
-        if let Some(stacks_tip) = Self::pick_best_tip(
-            &self.globals,
-            &self.config,
-            &mut burn_db,
-            &mut chain_state,
-            None,
-        ) {
+        if let Some(stacks_tip) = chain_state
+            .get_stacks_chain_tip(&burn_db)
+            .expect("FATAL: could not query chain tip")
+        {
             let is_miner_blocked = self
                 .globals
                 .get_miner_status()
@@ -2809,7 +2024,7 @@ impl BlockMinerThread {
                 &self.burnchain,
                 &burn_db,
                 &chain_state,
-                miner_config.unprocessed_block_deadline_secs,
+                self.config.miner.unprocessed_block_deadline_secs,
             );
             if stacks_tip.anchored_block_hash != anchored_block.header.parent_block
                 || parent_block_info.parent_consensus_hash != stacks_tip.consensus_hash
@@ -2817,7 +2032,7 @@ impl BlockMinerThread {
                 || is_miner_blocked
                 || has_unprocessed
             {
-                info!(
+                debug!(
                     "Relayer: Cancel block-commit; chain tip(s) have changed or cancelled";
                     "block_hash" => %anchored_block.block_hash(),
                     "tx_count" => anchored_block.txs.len(),
@@ -2844,9 +2059,8 @@ impl BlockMinerThread {
         }
 
         let mut op_signer = self.keychain.generate_op_signer();
-        info!(
+        debug!(
             "Relayer: Submit block-commit";
-            "burn_fee" => burn_fee,
             "block_hash" => %anchored_block.block_hash(),
             "tx_count" => anchored_block.txs.len(),
             "target_height" => anchored_block.header.total_work.work,
@@ -3165,6 +2379,8 @@ impl RelayerThread {
             );
             #[cfg(any(test, feature = "testing"))]
             {
+                use std::fs;
+                use std::io::Write;
                 use std::path::Path;
                 if let Ok(path) = std::env::var("STACKS_BAD_BLOCKS_DIR") {
                     // record this block somewhere
@@ -3770,13 +2986,11 @@ impl RelayerThread {
             return None;
         }
 
-        let miner_config = self.config.get_miner_config();
-
         let has_unprocessed = BlockMinerThread::unprocessed_blocks_prevent_mining(
             &self.burnchain,
             self.sortdb_ref(),
             self.chainstate_ref(),
-            miner_config.unprocessed_block_deadline_secs,
+            self.config.miner.unprocessed_block_deadline_secs,
         );
         if has_unprocessed {
             debug!(
@@ -4167,36 +3381,6 @@ impl RelayerThread {
         self.miner_thread.is_none()
     }
 
-    /// Try loading up a saved VRF key
-    pub(crate) fn load_saved_vrf_key(path: &str) -> Option<RegisteredKey> {
-        let mut f = match fs::File::open(path) {
-            Ok(f) => f,
-            Err(e) => {
-                warn!("Could not open {}: {:?}", &path, &e);
-                return None;
-            }
-        };
-        let mut registered_key_bytes = vec![];
-        if let Err(e) = f.read_to_end(&mut registered_key_bytes) {
-            warn!(
-                "Failed to read registered key bytes from {}: {:?}",
-                path, &e
-            );
-            return None;
-        }
-
-        let Ok(registered_key) = serde_json::from_slice(&registered_key_bytes) else {
-            warn!(
-                "Did not load registered key from {}: could not decode JSON",
-                &path
-            );
-            return None;
-        };
-
-        info!("Loaded registered key from {}", &path);
-        Some(registered_key)
-    }
-
     /// Top-level dispatcher
     pub fn handle_directive(&mut self, directive: RelayerDirective) -> bool {
         debug!("Relayer: received next directive");
@@ -4208,18 +3392,10 @@ impl RelayerThread {
                 true
             }
             RelayerDirective::RegisterKey(last_burn_block) => {
-                let mut saved_key_opt = None;
-                if let Some(path) = self.config.miner.activated_vrf_key_path.as_ref() {
-                    saved_key_opt = Self::load_saved_vrf_key(&path);
-                }
-                if let Some(saved_key) = saved_key_opt {
-                    self.globals.resume_leader_key(saved_key);
-                } else {
-                    debug!("Relayer: directive Register VRF key");
-                    self.rotate_vrf_and_register(&last_burn_block);
-                    debug!("Relayer: directive Registered VRF key");
-                }
+                debug!("Relayer: directive Register VRF key");
+                self.rotate_vrf_and_register(&last_burn_block);
                 self.globals.counters.bump_blocks_processed();
+                debug!("Relayer: directive Registered VRF key");
                 true
             }
             RelayerDirective::ProcessTenure(consensus_hash, burn_hash, block_header_hash) => {
@@ -5158,7 +4334,6 @@ impl StacksNode {
     /// Called from the main thread.
     pub fn process_burnchain_state(
         &mut self,
-        config: &Config,
         sortdb: &SortitionDB,
         sort_id: &SortitionId,
         ibd: bool,
@@ -5201,46 +4376,18 @@ impl StacksNode {
             SortitionDB::get_leader_keys_by_block(&ic, &block_snapshot.sortition_id)
                 .expect("Unexpected SortitionDB error fetching key registers");
 
-        self.globals.set_last_sortition(block_snapshot);
-        let ret = last_sortitioned_block.map(|x| x.0);
-
         let num_key_registers = key_registers.len();
+
+        self.globals
+            .try_activate_leader_key_registration(block_height, key_registers);
+
         debug!(
             "Processed burnchain state at height {}: {} leader keys, {} block-commits (ibd = {})",
             block_height, num_key_registers, num_block_commits, ibd
         );
 
-        // save the registered VRF key
-        let activated_key_opt = self
-            .globals
-            .try_activate_leader_key_registration(block_height, key_registers);
-
-        let Some(activated_key) = activated_key_opt else {
-            return ret;
-        };
-        let Some(path) = config.miner.activated_vrf_key_path.as_ref() else {
-            return ret;
-        };
-        info!("Activated VRF key; saving to {}", &path);
-        let Ok(key_json) = serde_json::to_string(&activated_key) else {
-            warn!("Failed to serialize VRF key");
-            return ret;
-        };
-        let mut f = match fs::File::create(&path) {
-            Ok(f) => f,
-            Err(e) => {
-                warn!("Failed to create {}: {:?}", &path, &e);
-                return ret;
-            }
-        };
-
-        if let Err(e) = f.write_all(key_json.as_str().as_bytes()) {
-            warn!("Failed to write activated VRF key to {}: {:?}", &path, &e);
-            return ret;
-        }
-
-        info!("Saved activated VRF key to {}", &path);
-        return ret;
+        self.globals.set_last_sortition(block_snapshot);
+        last_sortitioned_block.map(|x| x.0)
     }
 
     /// Join all inner threads
diff --git a/testnet/stacks-node/src/run_loop/mod.rs b/testnet/stacks-node/src/run_loop/mod.rs
index 37d8ce1fa9..bbee55f1e6 100644
--- a/testnet/stacks-node/src/run_loop/mod.rs
+++ b/testnet/stacks-node/src/run_loop/mod.rs
@@ -151,7 +151,7 @@ impl RunLoopCallbacks {
     }
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize)]
+#[derive(Clone, Debug)]
 pub struct RegisteredKey {
     /// burn block height we intended this VRF key register to land in
     pub target_block_height: u64,
diff --git a/testnet/stacks-node/src/run_loop/neon.rs b/testnet/stacks-node/src/run_loop/neon.rs
index 983fee7a27..47b5df31ce 100644
--- a/testnet/stacks-node/src/run_loop/neon.rs
+++ b/testnet/stacks-node/src/run_loop/neon.rs
@@ -628,12 +628,11 @@ impl RunLoop {
         sortdb: &SortitionDB,
         last_stacks_pox_reorg_recover_time: &mut u128,
     ) {
-        let miner_config = config.get_miner_config();
         let delay = cmp::max(
             config.node.chain_liveness_poll_time_secs,
             cmp::max(
-                miner_config.first_attempt_time_ms,
-                miner_config.subsequent_attempt_time_ms,
+                config.miner.first_attempt_time_ms,
+                config.miner.subsequent_attempt_time_ms,
             ) / 1000,
         );
 
@@ -749,12 +748,11 @@ impl RunLoop {
         last_burn_pox_reorg_recover_time: &mut u128,
         last_announce_time: &mut u128,
     ) {
-        let miner_config = config.get_miner_config();
         let delay = cmp::max(
             config.node.chain_liveness_poll_time_secs,
             cmp::max(
-                miner_config.first_attempt_time_ms,
-                miner_config.subsequent_attempt_time_ms,
+                config.miner.first_attempt_time_ms,
+                config.miner.subsequent_attempt_time_ms,
             ) / 1000,
         );
 
@@ -979,7 +977,6 @@ impl RunLoop {
             self.counters.clone(),
             self.pox_watchdog_comms.clone(),
             self.should_keep_running.clone(),
-            mine_start,
         );
         self.set_globals(globals.clone());
 
@@ -1168,12 +1165,7 @@ impl RunLoop {
                         let sortition_id = &block.sortition_id;
 
                         // Have the node process the new block, that can include, or not, a sortition.
-                        node.process_burnchain_state(
-                            self.config(),
-                            burnchain.sortdb_mut(),
-                            sortition_id,
-                            ibd,
-                        );
+                        node.process_burnchain_state(burnchain.sortdb_mut(), sortition_id, ibd);
 
                         // Now, tell the relayer to check if it won a sortition during this block,
                         // and, if so, to process and advertize the block.  This is basically a
@@ -1243,7 +1235,6 @@ impl RunLoop {
                     // once we've synced to the chain tip once, don't apply this check again.
                     //  this prevents a possible corner case in the event of a PoX fork.
                     mine_start = 0;
-                    globals.set_start_mining_height_if_zero(sortition_db_height);
 
                     // at tip, and not downloading. proceed to mine.
                     if last_tenure_sortition_height != sortition_db_height {
diff --git a/testnet/stacks-node/src/tests/bitcoin_regtest.rs b/testnet/stacks-node/src/tests/bitcoin_regtest.rs
index 3814f7b880..2479a403cd 100644
--- a/testnet/stacks-node/src/tests/bitcoin_regtest.rs
+++ b/testnet/stacks-node/src/tests/bitcoin_regtest.rs
@@ -142,6 +142,7 @@ fn bitcoind_integration(segwit_flag: bool) {
     conf.burnchain.password = Some("secret".to_string());
     conf.burnchain.local_mining_public_key = Some("04ee0b1602eb18fef7986887a7e8769a30c9df981d33c8380d255edef003abdcd243a0eb74afdf6740e6c423e62aec631519a24cf5b1d62bf8a3e06ddc695dcb77".to_string());
 
+    conf.miner.min_tx_fee = 0;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
     conf.miner.segwit = segwit_flag;
diff --git a/testnet/stacks-node/src/tests/epoch_205.rs b/testnet/stacks-node/src/tests/epoch_205.rs
index b95ad46527..7d8543bd58 100644
--- a/testnet/stacks-node/src/tests/epoch_205.rs
+++ b/testnet/stacks-node/src/tests/epoch_205.rs
@@ -996,6 +996,7 @@ fn bigger_microblock_streams_in_2_05() {
     conf.node.max_microblocks = 65536;
     conf.burnchain.max_rbf = 1000000;
 
+    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
diff --git a/testnet/stacks-node/src/tests/epoch_21.rs b/testnet/stacks-node/src/tests/epoch_21.rs
index 1b9b7d02f6..69a6d0ac00 100644
--- a/testnet/stacks-node/src/tests/epoch_21.rs
+++ b/testnet/stacks-node/src/tests/epoch_21.rs
@@ -450,19 +450,21 @@ fn transition_adds_burn_block_height() {
                             false,
                         )
                         .unwrap();
-                        let pair = clarity_value.expect_tuple();
-                        let height = pair.get("height").unwrap().clone().expect_u128() as u64;
-                        let bhh_opt =
-                            pair.get("hash")
-                                .unwrap()
-                                .clone()
-                                .expect_optional()
-                                .map(|inner_buff| {
-                                    let buff_bytes_vec = inner_buff.expect_buff(32);
-                                    let mut buff_bytes = [0u8; 32];
-                                    buff_bytes.copy_from_slice(&buff_bytes_vec[0..32]);
-                                    BurnchainHeaderHash(buff_bytes)
-                                });
+                        let pair = clarity_value.expect_tuple().unwrap();
+                        let height =
+                            pair.get("height").unwrap().clone().expect_u128().unwrap() as u64;
+                        let bhh_opt = pair
+                            .get("hash")
+                            .unwrap()
+                            .clone()
+                            .expect_optional()
+                            .unwrap()
+                            .map(|inner_buff| {
+                                let buff_bytes_vec = inner_buff.expect_buff(32).unwrap();
+                                let mut buff_bytes = [0u8; 32];
+                                buff_bytes.copy_from_slice(&buff_bytes_vec[0..32]);
+                                BurnchainHeaderHash(buff_bytes)
+                            });
 
                         header_hashes.insert(height, bhh_opt);
                     }
@@ -1146,7 +1148,7 @@ fn transition_adds_get_pox_addr_recipients() {
         );
 
         submit_tx(&http_origin, &tx);
-        expected_pox_addrs.insert(pox_addr_tuple);
+        expected_pox_addrs.insert(pox_addr_tuple.to_string());
     }
 
     // stack some STX to segwit addressses
@@ -1186,7 +1188,7 @@ fn transition_adds_get_pox_addr_recipients() {
         );
 
         submit_tx(&http_origin, &tx);
-        expected_pox_addrs.insert(pox_addr_tuple);
+        expected_pox_addrs.insert(pox_addr_tuple.to_string());
     }
 
     let contract = "
@@ -1282,25 +1284,36 @@ fn transition_adds_get_pox_addr_recipients() {
                             false,
                         )
                         .unwrap();
-                        let pair = clarity_value.expect_tuple();
-                        let burn_block_height =
-                            pair.get("burn-height").unwrap().clone().expect_u128() as u64;
-                        let pox_addr_tuples_opt =
-                            pair.get("pox-addrs").unwrap().clone().expect_optional();
+                        let pair = clarity_value.expect_tuple().unwrap();
+                        let burn_block_height = pair
+                            .get("burn-height")
+                            .unwrap()
+                            .clone()
+                            .expect_u128()
+                            .unwrap() as u64;
+                        let pox_addr_tuples_opt = pair
+                            .get("pox-addrs")
+                            .unwrap()
+                            .clone()
+                            .expect_optional()
+                            .unwrap();
 
                         if let Some(pox_addr_tuples_list) = pox_addr_tuples_opt {
-                            let pox_addrs_and_payout_tuple = pox_addr_tuples_list.expect_tuple();
+                            let pox_addrs_and_payout_tuple =
+                                pox_addr_tuples_list.expect_tuple().unwrap();
                             let pox_addr_tuples = pox_addrs_and_payout_tuple
                                 .get("addrs")
                                 .unwrap()
                                 .to_owned()
-                                .expect_list();
+                                .expect_list()
+                                .unwrap();
 
                             let payout = pox_addrs_and_payout_tuple
                                 .get("payout")
                                 .unwrap()
                                 .to_owned()
-                                .expect_u128();
+                                .expect_u128()
+                                .unwrap();
 
                             // NOTE: there's an even number of payouts here, so this works
                             eprintln!("payout at {} = {}", burn_block_height, &payout);
@@ -1351,7 +1364,7 @@ fn transition_adds_get_pox_addr_recipients() {
         .map(|addr| Value::Tuple(addr.as_clarity_tuple().unwrap()))
     {
         eprintln!("Contains: {:?}", &addr);
-        assert!(expected_pox_addrs.contains(&addr));
+        assert!(expected_pox_addrs.contains(&addr.to_string()));
     }
 }
 
@@ -4987,6 +5000,7 @@ fn test_v1_unlock_height_with_current_stackers() {
     conf.node.wait_time_for_blocks = 1_000;
     conf.miner.wait_for_block_download = false;
 
+    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -5157,10 +5171,13 @@ fn test_v1_unlock_height_with_current_stackers() {
             )
             .expect_optional()
             .unwrap()
+            .unwrap()
             .expect_tuple()
+            .unwrap()
             .get_owned("addrs")
             .unwrap()
-            .expect_list();
+            .expect_list()
+            .unwrap();
 
         if height < 215 {
             if !burnchain_config.is_in_prepare_phase(height) {
@@ -5248,6 +5265,7 @@ fn test_v1_unlock_height_with_delay_and_current_stackers() {
     conf.node.wait_time_for_blocks = 1_000;
     conf.miner.wait_for_block_download = false;
 
+    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -5433,10 +5451,13 @@ fn test_v1_unlock_height_with_delay_and_current_stackers() {
             )
             .expect_optional()
             .unwrap()
+            .unwrap()
             .expect_tuple()
+            .unwrap()
             .get_owned("addrs")
             .unwrap()
-            .expect_list();
+            .expect_list()
+            .unwrap();
 
         debug!("Test burnchain height {}", height);
         if !burnchain_config.is_in_prepare_phase(height) {
diff --git a/testnet/stacks-node/src/tests/epoch_22.rs b/testnet/stacks-node/src/tests/epoch_22.rs
index 01e4e0f689..2abd127cfc 100644
--- a/testnet/stacks-node/src/tests/epoch_22.rs
+++ b/testnet/stacks-node/src/tests/epoch_22.rs
@@ -144,6 +144,7 @@ fn disable_pox() {
     conf.node.wait_time_for_blocks = 1_000;
     conf.miner.wait_for_block_download = false;
 
+    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -423,10 +424,13 @@ fn disable_pox() {
             )
             .expect_optional()
             .unwrap()
+            .unwrap()
             .expect_tuple()
+            .unwrap()
             .get_owned("addrs")
             .unwrap()
-            .expect_list();
+            .expect_list()
+            .unwrap();
 
         debug!("Test burnchain height {}", height);
         if !burnchain_config.is_in_prepare_phase(height) {
@@ -673,6 +677,7 @@ fn pox_2_unlock_all() {
     conf.node.wait_time_for_blocks = 1_000;
     conf.miner.wait_for_block_download = false;
 
+    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -1086,10 +1091,13 @@ fn pox_2_unlock_all() {
             )
             .expect_optional()
             .unwrap()
+            .unwrap()
             .expect_tuple()
+            .unwrap()
             .get_owned("addrs")
             .unwrap()
-            .expect_list();
+            .expect_list()
+            .unwrap();
 
         debug!("Test burnchain height {}", height);
         if !burnchain_config.is_in_prepare_phase(height) {
diff --git a/testnet/stacks-node/src/tests/epoch_23.rs b/testnet/stacks-node/src/tests/epoch_23.rs
index 59bce72857..58313947d8 100644
--- a/testnet/stacks-node/src/tests/epoch_23.rs
+++ b/testnet/stacks-node/src/tests/epoch_23.rs
@@ -104,6 +104,7 @@ fn trait_invocation_behavior() {
     conf.node.wait_time_for_blocks = 1_000;
     conf.miner.wait_for_block_download = false;
 
+    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
diff --git a/testnet/stacks-node/src/tests/epoch_24.rs b/testnet/stacks-node/src/tests/epoch_24.rs
index 3019047a37..189a4ba5eb 100644
--- a/testnet/stacks-node/src/tests/epoch_24.rs
+++ b/testnet/stacks-node/src/tests/epoch_24.rs
@@ -38,10 +38,13 @@ use crate::tests::bitcoin_regtest::BitcoinCoreController;
 use crate::{neon, BitcoinRegtestController, BurnchainController};
 use stacks::clarity_cli::vm_execute as execute;
 use stacks::core;
+use stacks::core::{
+    StacksEpoch, PEER_VERSION_EPOCH_2_2, PEER_VERSION_EPOCH_2_3, PEER_VERSION_EPOCH_2_4,
+};
 use stacks_common::address::{AddressHashMode, C32_ADDRESS_VERSION_TESTNET_SINGLESIG};
 use stacks_common::codec::StacksMessageCodec;
 use stacks_common::consts::STACKS_EPOCH_MAX;
-use stacks_common::types::Address;
+use stacks_common::types::{Address, StacksEpochId};
 use stacks_common::util::sleep_ms;
 
 #[cfg(test)]
@@ -147,6 +150,7 @@ fn fix_to_pox_contract() {
     conf.node.wait_time_for_blocks = 1_000;
     conf.miner.wait_for_block_download = false;
 
+    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -501,10 +505,13 @@ fn fix_to_pox_contract() {
             )
             .expect_optional()
             .unwrap()
+            .unwrap()
             .expect_tuple()
+            .unwrap()
             .get_owned("addrs")
             .unwrap()
-            .expect_list();
+            .expect_list()
+            .unwrap();
 
         debug!("Test burnchain height {}", height);
         if !burnchain_config.is_in_prepare_phase(height) {
@@ -782,6 +789,7 @@ fn verify_auto_unlock_behavior() {
     conf.node.wait_time_for_blocks = 1_000;
     conf.miner.wait_for_block_download = false;
 
+    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -1080,7 +1088,7 @@ fn verify_auto_unlock_behavior() {
 
     // Check that the "raw" reward sets for all cycles just contains entries for both addrs
     //  for the next few cycles.
-    for _cycle_number in first_v3_cycle..(first_v3_cycle + 6) {
+    for cycle_number in first_v3_cycle..(first_v3_cycle + 6) {
         let (mut chainstate, _) = StacksChainState::open(
             false,
             conf.burnchain.chain_id,
@@ -1166,7 +1174,7 @@ fn verify_auto_unlock_behavior() {
 
     // Check that the "raw" reward sets for all cycles just contains entries for the first
     //  address at the cycle start, since addr 2 was auto-unlocked.
-    for _cycle_number in first_v3_cycle..(first_v3_cycle + 6) {
+    for cycle_number in first_v3_cycle..(first_v3_cycle + 6) {
         let tip_info = get_chain_info(&conf);
         let tip_block_id =
             StacksBlockId::new(&tip_info.stacks_tip_consensus_hash, &tip_info.stacks_tip);
@@ -1217,10 +1225,13 @@ fn verify_auto_unlock_behavior() {
             )
             .expect_optional()
             .unwrap()
+            .unwrap()
             .expect_tuple()
+            .unwrap()
             .get_owned("addrs")
             .unwrap()
-            .expect_list();
+            .expect_list()
+            .unwrap();
 
         if !burnchain_config.is_in_prepare_phase(height) {
             if pox_addrs.len() > 0 {
diff --git a/testnet/stacks-node/src/tests/integrations.rs b/testnet/stacks-node/src/tests/integrations.rs
index 734422e3df..c7c833311a 100644
--- a/testnet/stacks-node/src/tests/integrations.rs
+++ b/testnet/stacks-node/src/tests/integrations.rs
@@ -186,6 +186,7 @@ fn integration_test_get_info() {
     });
 
     conf.burnchain.commit_anchor_block_within = 5000;
+    conf.miner.min_tx_fee = 0;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -490,7 +491,7 @@ fn integration_test_get_info() {
 
                 eprintln!("Test: POST {}", path);
                 let res = client.post(&path)
-                    .json(&key.serialize_to_hex())
+                    .json(&key.serialize_to_hex().unwrap())
                     .send()
                     .unwrap().json::<HashMap<String, String>>().unwrap();
                 let result_data = Value::try_deserialize_hex_untyped(&res["data"][2..]).unwrap();
@@ -505,7 +506,7 @@ fn integration_test_get_info() {
 
                 eprintln!("Test: POST {}", path);
                 let res = client.post(&path)
-                    .json(&key.serialize_to_hex())
+                    .json(&key.serialize_to_hex().unwrap())
                     .send()
                     .unwrap().json::<HashMap<String, String>>().unwrap();
                 let result_data = Value::try_deserialize_hex_untyped(&res["data"][2..]).unwrap();
@@ -522,7 +523,7 @@ fn integration_test_get_info() {
 
                 eprintln!("Test: POST {}", path);
                 let res = client.post(&path)
-                    .json(&key.serialize_to_hex())
+                    .json(&key.serialize_to_hex().unwrap())
                     .send()
                     .unwrap().json::<HashMap<String, String>>().unwrap();
 
@@ -543,7 +544,7 @@ fn integration_test_get_info() {
 
                 eprintln!("Test: POST {}", path);
                 let res = client.post(&path)
-                    .json(&key.serialize_to_hex())
+                    .json(&key.serialize_to_hex().unwrap())
                     .send()
                     .unwrap().json::<HashMap<String, String>>().unwrap();
 
@@ -626,7 +627,7 @@ fn integration_test_get_info() {
                 let res = client.get(&path).send().unwrap().json::<ContractInterface>().unwrap();
 
                 let contract_analysis = mem_type_check(GET_INFO_CONTRACT, ClarityVersion::Clarity2, StacksEpochId::Epoch21).unwrap().1;
-                let expected_interface = build_contract_interface(&contract_analysis);
+                let expected_interface = build_contract_interface(&contract_analysis).unwrap();
 
                 eprintln!("{}", serde_json::to_string(&expected_interface).unwrap());
 
@@ -671,7 +672,7 @@ fn integration_test_get_info() {
                 let body = CallReadOnlyRequestBody {
                     sender: "'SP139Q3N9RXCJCD1XVA4N5RYWQ5K9XQ0T9PKQ8EE5".into(),
                     sponsor: None,
-                    arguments: vec![Value::UInt(3).serialize_to_hex()]
+                    arguments: vec![Value::UInt(3).serialize_to_hex().unwrap()]
                 };
 
                 let res = client.post(&path)
@@ -739,7 +740,7 @@ fn integration_test_get_info() {
                 let body = CallReadOnlyRequestBody {
                     sender: "'SP139Q3N9RXCJCD1XVA4N5RYWQ5K9XQ0T9PKQ8EE5".into(),
                     sponsor: None,
-                    arguments: vec![Value::UInt(3).serialize_to_hex()]
+                    arguments: vec![Value::UInt(3).serialize_to_hex().unwrap()]
                 };
 
                 let res = client.post(&path)
@@ -762,7 +763,7 @@ fn integration_test_get_info() {
                 let body = CallReadOnlyRequestBody {
                     sender: "'SP139Q3N9RXCJCD1XVA4N5RYWQ5K9XQ0T9PKQ8EE5".into(),
                     sponsor: None,
-                    arguments: vec![Value::UInt(100).serialize_to_hex()]
+                    arguments: vec![Value::UInt(100).serialize_to_hex().unwrap()]
                 };
 
                 let res = client.post(&path)
@@ -1274,6 +1275,7 @@ fn contract_stx_transfer() {
                                         db.get_account_stx_balance(
                                             &contract_identifier.clone().into(),
                                         )
+                                        .unwrap()
                                         .amount_unlocked()
                                     })
                                 }
@@ -1291,7 +1293,9 @@ fn contract_stx_transfer() {
                                 &StacksBlockHeader::make_index_block_hash(&cur_tip.0, &cur_tip.1),
                                 |conn| {
                                     conn.with_clarity_db_readonly(|db| {
-                                        db.get_account_stx_balance(&addr_3).amount_unlocked()
+                                        db.get_account_stx_balance(&addr_3)
+                                            .unwrap()
+                                            .amount_unlocked()
                                     })
                                 }
                             )
@@ -1325,7 +1329,9 @@ fn contract_stx_transfer() {
                                 &StacksBlockHeader::make_index_block_hash(&cur_tip.0, &cur_tip.1),
                                 |conn| {
                                     conn.with_clarity_db_readonly(|db| {
-                                        db.get_account_stx_balance(&addr_2).amount_unlocked()
+                                        db.get_account_stx_balance(&addr_2)
+                                            .unwrap()
+                                            .amount_unlocked()
                                     })
                                 }
                             )
@@ -1343,6 +1349,7 @@ fn contract_stx_transfer() {
                                         db.get_account_stx_balance(
                                             &contract_identifier.clone().into(),
                                         )
+                                        .unwrap()
                                         .amount_unlocked()
                                     })
                                 }
@@ -1375,6 +1382,7 @@ fn contract_stx_transfer() {
                                         db.get_account_stx_balance(
                                             &contract_identifier.clone().into(),
                                         )
+                                        .unwrap()
                                         .amount_unlocked()
                                     })
                                 }
@@ -1392,7 +1400,9 @@ fn contract_stx_transfer() {
                                 &StacksBlockHeader::make_index_block_hash(&cur_tip.0, &cur_tip.1),
                                 |conn| {
                                     conn.with_clarity_db_readonly(|db| {
-                                        db.get_account_stx_balance(&addr_3).amount_unlocked()
+                                        db.get_account_stx_balance(&addr_3)
+                                            .unwrap()
+                                            .amount_unlocked()
                                     })
                                 }
                             )
@@ -1545,6 +1555,7 @@ fn mine_transactions_out_of_order() {
                                         db.get_account_stx_balance(
                                             &contract_identifier.clone().into(),
                                         )
+                                        .unwrap()
                                         .amount_unlocked()
                                     })
                                 }
@@ -1801,6 +1812,7 @@ fn bad_contract_tx_rollback() {
                                         db.get_account_stx_balance(
                                             &contract_identifier.clone().into(),
                                         )
+                                        .unwrap()
                                         .amount_unlocked()
                                     })
                                 }
@@ -1818,7 +1830,9 @@ fn bad_contract_tx_rollback() {
                                 &StacksBlockHeader::make_index_block_hash(&cur_tip.0, &cur_tip.1),
                                 |conn| {
                                     conn.with_clarity_db_readonly(|db| {
-                                        db.get_account_stx_balance(&addr_3).amount_unlocked()
+                                        db.get_account_stx_balance(&addr_3)
+                                            .unwrap()
+                                            .amount_unlocked()
                                     })
                                 }
                             )
diff --git a/testnet/stacks-node/src/tests/mod.rs b/testnet/stacks-node/src/tests/mod.rs
index d2af21db8a..94d6401c52 100644
--- a/testnet/stacks-node/src/tests/mod.rs
+++ b/testnet/stacks-node/src/tests/mod.rs
@@ -1,19 +1,3 @@
-// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
-// Copyright (C) 2020-2024 Stacks Open Internet Foundation
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-use std::collections::HashMap;
 use std::convert::TryInto;
 use std::sync::atomic::AtomicU64;
 use std::sync::Arc;
@@ -52,12 +36,8 @@ use stacks::core::StacksEpochExtension;
 use stacks::core::StacksEpochId;
 
 use super::burnchains::bitcoin_regtest_controller::ParsedUTXO;
-use super::neon_node::BlockMinerThread;
-use super::neon_node::TipCandidate;
 use super::Config;
 
-use stacks_common::types::chainstate::BlockHeaderHash;
-
 mod atlas;
 mod bitcoin_regtest;
 mod epoch_205;
@@ -541,6 +521,8 @@ fn should_succeed_mining_valid_txs() {
         100000,
     );
 
+    conf.miner.min_tx_fee = 0;
+
     let num_rounds = 6;
     let mut run_loop = RunLoop::new(conf.clone());
 
@@ -1014,332 +996,3 @@ fn test_btc_to_sat_errors() {
     assert!(ParsedUTXO::serialized_btc_to_sat("7.4e-7").is_none());
     assert!(ParsedUTXO::serialized_btc_to_sat("5.96e-6").is_none());
 }
-
-#[test]
-fn test_sort_and_populate_candidates() {
-    let empty: Vec<TipCandidate> = vec![];
-    assert_eq!(
-        empty,
-        BlockMinerThread::sort_and_populate_candidates(vec![])
-    );
-    let candidates = vec![
-        TipCandidate {
-            stacks_height: 1,
-            consensus_hash: ConsensusHash([0x01; 20]),
-            anchored_block_hash: BlockHeaderHash([0x01; 32]),
-            parent_consensus_hash: ConsensusHash([0x00; 20]),
-            parent_anchored_block_hash: BlockHeaderHash([0x00; 32]),
-            burn_height: 100,
-            num_earlier_siblings: 0,
-        },
-        TipCandidate {
-            stacks_height: 2,
-            consensus_hash: ConsensusHash([0x02; 20]),
-            anchored_block_hash: BlockHeaderHash([0x02; 32]),
-            parent_consensus_hash: ConsensusHash([0x01; 20]),
-            parent_anchored_block_hash: BlockHeaderHash([0x01; 32]),
-            burn_height: 102,
-            num_earlier_siblings: 0,
-        },
-        TipCandidate {
-            stacks_height: 2,
-            consensus_hash: ConsensusHash([0x12; 20]),
-            anchored_block_hash: BlockHeaderHash([0x12; 32]),
-            parent_consensus_hash: ConsensusHash([0x01; 20]),
-            parent_anchored_block_hash: BlockHeaderHash([0x01; 32]),
-            burn_height: 101,
-            num_earlier_siblings: 0,
-        },
-        TipCandidate {
-            stacks_height: 2,
-            consensus_hash: ConsensusHash([0x22; 20]),
-            anchored_block_hash: BlockHeaderHash([0x22; 32]),
-            parent_consensus_hash: ConsensusHash([0x01; 20]),
-            parent_anchored_block_hash: BlockHeaderHash([0x01; 32]),
-            burn_height: 104,
-            num_earlier_siblings: 0,
-        },
-        TipCandidate {
-            stacks_height: 4,
-            consensus_hash: ConsensusHash([0x04; 20]),
-            anchored_block_hash: BlockHeaderHash([0x04; 32]),
-            parent_consensus_hash: ConsensusHash([0x03; 20]),
-            parent_anchored_block_hash: BlockHeaderHash([0x03; 32]),
-            burn_height: 105,
-            num_earlier_siblings: 0,
-        },
-        TipCandidate {
-            stacks_height: 3,
-            consensus_hash: ConsensusHash([0x03; 20]),
-            anchored_block_hash: BlockHeaderHash([0x03; 32]),
-            parent_consensus_hash: ConsensusHash([0x02; 20]),
-            parent_anchored_block_hash: BlockHeaderHash([0x02; 32]),
-            burn_height: 105,
-            num_earlier_siblings: 0,
-        },
-    ];
-    let sorted_candidates = BlockMinerThread::sort_and_populate_candidates(candidates);
-    assert_eq!(
-        sorted_candidates,
-        vec![
-            TipCandidate {
-                stacks_height: 1,
-                consensus_hash: ConsensusHash([0x01; 20]),
-                anchored_block_hash: BlockHeaderHash([0x01; 32]),
-                parent_consensus_hash: ConsensusHash([0x00; 20]),
-                parent_anchored_block_hash: BlockHeaderHash([0x00; 32]),
-                burn_height: 100,
-                num_earlier_siblings: 0
-            },
-            TipCandidate {
-                stacks_height: 2,
-                consensus_hash: ConsensusHash([0x12; 20]),
-                anchored_block_hash: BlockHeaderHash([0x12; 32]),
-                parent_consensus_hash: ConsensusHash([0x01; 20]),
-                parent_anchored_block_hash: BlockHeaderHash([0x01; 32]),
-                burn_height: 101,
-                num_earlier_siblings: 0
-            },
-            TipCandidate {
-                stacks_height: 2,
-                consensus_hash: ConsensusHash([0x02; 20]),
-                anchored_block_hash: BlockHeaderHash([0x02; 32]),
-                parent_consensus_hash: ConsensusHash([0x01; 20]),
-                parent_anchored_block_hash: BlockHeaderHash([0x01; 32]),
-                burn_height: 102,
-                num_earlier_siblings: 1
-            },
-            TipCandidate {
-                stacks_height: 2,
-                consensus_hash: ConsensusHash([0x22; 20]),
-                anchored_block_hash: BlockHeaderHash([0x22; 32]),
-                parent_consensus_hash: ConsensusHash([0x01; 20]),
-                parent_anchored_block_hash: BlockHeaderHash([0x01; 32]),
-                burn_height: 104,
-                num_earlier_siblings: 2
-            },
-            TipCandidate {
-                stacks_height: 3,
-                consensus_hash: ConsensusHash([0x03; 20]),
-                anchored_block_hash: BlockHeaderHash([0x03; 32]),
-                parent_consensus_hash: ConsensusHash([0x02; 20]),
-                parent_anchored_block_hash: BlockHeaderHash([0x02; 32]),
-                burn_height: 105,
-                num_earlier_siblings: 0
-            },
-            TipCandidate {
-                stacks_height: 4,
-                consensus_hash: ConsensusHash([0x04; 20]),
-                anchored_block_hash: BlockHeaderHash([0x04; 32]),
-                parent_consensus_hash: ConsensusHash([0x03; 20]),
-                parent_anchored_block_hash: BlockHeaderHash([0x03; 32]),
-                burn_height: 105,
-                num_earlier_siblings: 0
-            }
-        ]
-    );
-}
-
-#[test]
-fn test_inner_pick_best_tip() {
-    // chain structure as folows:
-    //
-    // Bitcoin chain
-    // 100  101  102  103  104  105  106
-    //  |    |    |         |    |    |
-    // Stacks chain         |    |    |
-    //  1 <- 2    |         |.-- 3 <- 4
-    //    \       |         /
-    //     *----- 2 <------*|
-    //      \               |
-    //       *--------------2
-    //
-    // If there are no previous best-tips, then:
-    // At Bitcoin height 105, the best tip is (4,105)
-    // At Bitcoin height 104, the best tip is (3,104)
-    // At Bitcoin height 103, the best tip is (2,101)
-    // At Bitcoin height 102, the best tip is (2,101)
-    // At Bitcoin height 101, the best tip is (2,101)
-    // At Bitcoin height 100, the best tip is (1,100)
-    //
-    let candidates = vec![
-        TipCandidate {
-            stacks_height: 1,
-            consensus_hash: ConsensusHash([0x01; 20]),
-            anchored_block_hash: BlockHeaderHash([0x01; 32]),
-            parent_consensus_hash: ConsensusHash([0x00; 20]),
-            parent_anchored_block_hash: BlockHeaderHash([0x00; 32]),
-            burn_height: 100,
-            num_earlier_siblings: 0,
-        },
-        TipCandidate {
-            stacks_height: 2,
-            consensus_hash: ConsensusHash([0x02; 20]),
-            anchored_block_hash: BlockHeaderHash([0x02; 32]),
-            parent_consensus_hash: ConsensusHash([0x01; 20]),
-            parent_anchored_block_hash: BlockHeaderHash([0x01; 32]),
-            burn_height: 102,
-            num_earlier_siblings: 0,
-        },
-        TipCandidate {
-            stacks_height: 2,
-            consensus_hash: ConsensusHash([0x12; 20]),
-            anchored_block_hash: BlockHeaderHash([0x12; 32]),
-            parent_consensus_hash: ConsensusHash([0x01; 20]),
-            parent_anchored_block_hash: BlockHeaderHash([0x01; 32]),
-            burn_height: 101,
-            num_earlier_siblings: 0,
-        },
-        TipCandidate {
-            stacks_height: 2,
-            consensus_hash: ConsensusHash([0x22; 20]),
-            anchored_block_hash: BlockHeaderHash([0x22; 32]),
-            parent_consensus_hash: ConsensusHash([0x01; 20]),
-            parent_anchored_block_hash: BlockHeaderHash([0x01; 32]),
-            burn_height: 104,
-            num_earlier_siblings: 0,
-        },
-        TipCandidate {
-            stacks_height: 4,
-            consensus_hash: ConsensusHash([0x04; 20]),
-            anchored_block_hash: BlockHeaderHash([0x04; 32]),
-            parent_consensus_hash: ConsensusHash([0x03; 20]),
-            parent_anchored_block_hash: BlockHeaderHash([0x03; 32]),
-            burn_height: 106,
-            num_earlier_siblings: 0,
-        },
-        TipCandidate {
-            stacks_height: 3,
-            consensus_hash: ConsensusHash([0x03; 20]),
-            anchored_block_hash: BlockHeaderHash([0x03; 32]),
-            parent_consensus_hash: ConsensusHash([0x02; 20]),
-            parent_anchored_block_hash: BlockHeaderHash([0x02; 32]),
-            burn_height: 105,
-            num_earlier_siblings: 0,
-        },
-    ];
-
-    let sorted_candidates = BlockMinerThread::sort_and_populate_candidates(candidates.clone());
-    assert_eq!(
-        None,
-        BlockMinerThread::inner_pick_best_tip(vec![], HashMap::new())
-    );
-    assert_eq!(
-        Some(sorted_candidates[5].clone()),
-        BlockMinerThread::inner_pick_best_tip(sorted_candidates.clone(), HashMap::new())
-    );
-    assert_eq!(
-        Some(sorted_candidates[0].clone()),
-        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..1].to_vec(), HashMap::new())
-    );
-    assert_eq!(
-        Some(sorted_candidates[1].clone()),
-        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..2].to_vec(), HashMap::new())
-    );
-    assert_eq!(
-        Some(sorted_candidates[1].clone()),
-        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..3].to_vec(), HashMap::new())
-    );
-    assert_eq!(
-        Some(sorted_candidates[1].clone()),
-        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..4].to_vec(), HashMap::new())
-    );
-    assert_eq!(
-        Some(sorted_candidates[4].clone()),
-        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..5].to_vec(), HashMap::new())
-    );
-
-    // suppose now that we previously picked (2,104) as the best-tip.
-    // No other tips at Stacks height 2 will be accepted, nor will those at heights 3 and 4 (since
-    // they descend from the wrong height-2 block).
-    let mut best_tips = HashMap::new();
-    best_tips.insert(2, sorted_candidates[3].clone());
-
-    assert_eq!(
-        Some(sorted_candidates[3].clone()),
-        BlockMinerThread::inner_pick_best_tip(sorted_candidates.clone(), best_tips.clone())
-    );
-    assert_eq!(
-        Some(sorted_candidates[0].clone()),
-        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..1].to_vec(), best_tips.clone())
-    );
-    assert_eq!(
-        None,
-        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..2].to_vec(), best_tips.clone())
-    );
-    assert_eq!(
-        None,
-        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..3].to_vec(), best_tips.clone())
-    );
-    assert_eq!(
-        Some(sorted_candidates[3].clone()),
-        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..4].to_vec(), best_tips.clone())
-    );
-    assert_eq!(
-        Some(sorted_candidates[3].clone()),
-        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..5].to_vec(), best_tips.clone())
-    );
-
-    // now suppose that we previously picked (2,102) as the best-tip.
-    // Conflicting blocks are (2,101) and (2,104)
-    let mut best_tips = HashMap::new();
-    best_tips.insert(2, sorted_candidates[2].clone());
-
-    assert_eq!(
-        Some(sorted_candidates[5].clone()),
-        BlockMinerThread::inner_pick_best_tip(sorted_candidates.clone(), best_tips.clone())
-    );
-    assert_eq!(
-        Some(sorted_candidates[0].clone()),
-        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..1].to_vec(), best_tips.clone())
-    );
-    assert_eq!(
-        None,
-        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..2].to_vec(), best_tips.clone())
-    );
-    assert_eq!(
-        Some(sorted_candidates[2].clone()),
-        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..3].to_vec(), best_tips.clone())
-    );
-    assert_eq!(
-        Some(sorted_candidates[2].clone()),
-        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..4].to_vec(), best_tips.clone())
-    );
-    assert_eq!(
-        Some(sorted_candidates[4].clone()),
-        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..5].to_vec(), best_tips.clone())
-    );
-
-    // now suppose that we previously picked both (2,101) and (3,105) as the best-tips.
-    // these best-tips are in conflict, but that shouldn't prohibit us from choosing (4,106) as the
-    // best tip even though it doesn't confirm (2,101).  However, it would mean that (2,102) and
-    // (2,104) are in conflict.
-    let mut best_tips = HashMap::new();
-    best_tips.insert(2, sorted_candidates[1].clone());
-    best_tips.insert(3, sorted_candidates[4].clone());
-
-    assert_eq!(
-        Some(sorted_candidates[5].clone()),
-        BlockMinerThread::inner_pick_best_tip(sorted_candidates.clone(), best_tips.clone())
-    );
-    assert_eq!(
-        Some(sorted_candidates[0].clone()),
-        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..1].to_vec(), best_tips.clone())
-    );
-    assert_eq!(
-        Some(sorted_candidates[1].clone()),
-        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..2].to_vec(), best_tips.clone())
-    );
-    assert_eq!(
-        Some(sorted_candidates[1].clone()),
-        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..3].to_vec(), best_tips.clone())
-    );
-    assert_eq!(
-        Some(sorted_candidates[1].clone()),
-        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..4].to_vec(), best_tips.clone())
-    );
-    assert_eq!(
-        Some(sorted_candidates[1].clone()),
-        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..5].to_vec(), best_tips.clone())
-    );
-}
diff --git a/testnet/stacks-node/src/tests/neon_integrations.rs b/testnet/stacks-node/src/tests/neon_integrations.rs
index 312e1bf622..678365a0b1 100644
--- a/testnet/stacks-node/src/tests/neon_integrations.rs
+++ b/testnet/stacks-node/src/tests/neon_integrations.rs
@@ -1,61 +1,83 @@
-use std::collections::{HashMap, HashSet};
-use std::convert::TryFrom;
+use std::cmp;
+use std::fs;
 use std::path::Path;
-use std::sync::atomic::{AtomicU64, Ordering};
-use std::sync::{mpsc, Arc};
+use std::sync::mpsc;
+use std::sync::Arc;
 use std::time::{Duration, Instant};
-use std::{cmp, env, fs, thread};
+use std::{
+    collections::HashMap,
+    collections::HashSet,
+    sync::atomic::{AtomicU64, Ordering},
+};
+use std::{env, thread};
 
-use clarity::vm::ast::stack_depth_checker::AST_CALL_STACK_DEPTH_BUFFER;
-use clarity::vm::ast::ASTRules;
-use clarity::vm::MAX_CALL_STACK_DEPTH;
-use rand::Rng;
 use rusqlite::types::ToSql;
+
 use stacks::burnchains::bitcoin::address::{BitcoinAddress, LegacyBitcoinAddressType};
 use stacks::burnchains::bitcoin::BitcoinNetworkType;
-use stacks::burnchains::db::BurnchainDB;
-use stacks::burnchains::{Address, Burnchain, PoxConstants, Txid};
-use stacks::chainstate::burn::db::sortdb::SortitionDB;
+use stacks::burnchains::Txid;
 use stacks::chainstate::burn::operations::{
     BlockstackOperationType, DelegateStxOp, PreStxOp, TransferStxOp,
 };
-use stacks::chainstate::burn::ConsensusHash;
 use stacks::chainstate::coordinator::comm::CoordinatorChannels;
-use stacks::chainstate::stacks::db::StacksChainState;
-use stacks::chainstate::stacks::miner::{
-    signal_mining_blocked, signal_mining_ready, TransactionErrorEvent, TransactionEvent,
-    TransactionSuccessEvent,
-};
-use stacks::chainstate::stacks::{
-    StacksBlock, StacksBlockHeader, StacksMicroblock, StacksMicroblockHeader, StacksPrivateKey,
-    StacksPublicKey, StacksTransaction, TransactionContractCall, TransactionPayload,
-};
 use stacks::clarity_cli::vm_execute as execute;
 use stacks::codec::StacksMessageCodec;
 use stacks::core;
 use stacks::core::{
-    mempool::MemPoolWalkTxTypes, StacksEpoch, StacksEpochId, BLOCK_LIMIT_MAINNET_20,
-    BLOCK_LIMIT_MAINNET_205, BLOCK_LIMIT_MAINNET_21, CHAIN_ID_TESTNET, HELIUM_BLOCK_LIMIT_20,
-    PEER_VERSION_EPOCH_1_0, PEER_VERSION_EPOCH_2_0, PEER_VERSION_EPOCH_2_05,
-    PEER_VERSION_EPOCH_2_1,
+    StacksEpoch, StacksEpochId, BLOCK_LIMIT_MAINNET_20, BLOCK_LIMIT_MAINNET_205,
+    BLOCK_LIMIT_MAINNET_21, CHAIN_ID_TESTNET, HELIUM_BLOCK_LIMIT_20, PEER_VERSION_EPOCH_1_0,
+    PEER_VERSION_EPOCH_2_0, PEER_VERSION_EPOCH_2_05, PEER_VERSION_EPOCH_2_1,
 };
 use stacks::net::atlas::{AtlasConfig, AtlasDB, MAX_ATTACHMENT_INV_PAGES_PER_REQUEST};
 use stacks::net::{
     AccountEntryResponse, ContractSrcResponse, GetAttachmentResponse, GetAttachmentsInvResponse,
-    PostTransactionRequestBody, RPCFeeEstimateResponse, RPCPeerInfoData, RPCPoxInfoData,
-    StacksBlockAcceptedData, UnconfirmedTransactionResponse,
+    PostTransactionRequestBody, RPCPeerInfoData, StacksBlockAcceptedData,
+    UnconfirmedTransactionResponse,
 };
 use stacks::types::chainstate::{
     BlockHeaderHash, BurnchainHeaderHash, StacksAddress, StacksBlockId,
 };
-use stacks::util::hash::{bytes_to_hex, hex_bytes, to_hex, Hash160};
+use stacks::util::hash::Hash160;
+use stacks::util::hash::{bytes_to_hex, hex_bytes, to_hex};
 use stacks::util::secp256k1::Secp256k1PublicKey;
 use stacks::util::{get_epoch_time_ms, get_epoch_time_secs, sleep_ms};
 use stacks::util_lib::boot::boot_code_id;
-use stacks::util_lib::db::{query_row_columns, query_rows, u64_to_sql};
-use stacks::vm::costs::ExecutionCost;
 use stacks::vm::types::PrincipalData;
-use stacks::vm::{ClarityName, ClarityVersion, ContractName, Value};
+use stacks::vm::ClarityVersion;
+use stacks::vm::Value;
+use stacks::{
+    burnchains::db::BurnchainDB,
+    chainstate::{burn::ConsensusHash, stacks::StacksMicroblock},
+};
+use stacks::{
+    burnchains::{Address, Burnchain, PoxConstants},
+    vm::costs::ExecutionCost,
+};
+use stacks::{
+    chainstate::stacks::{
+        db::StacksChainState, StacksBlock, StacksBlockHeader, StacksMicroblockHeader,
+        StacksPrivateKey, StacksPublicKey, StacksTransaction, TransactionContractCall,
+        TransactionPayload,
+    },
+    net::RPCPoxInfoData,
+    util_lib::db::query_row_columns,
+    util_lib::db::query_rows,
+    util_lib::db::u64_to_sql,
+};
+
+use crate::{
+    burnchains::bitcoin_regtest_controller::UTXO, config::EventKeyType,
+    config::EventObserverConfig, config::InitialBalance, neon, operations::BurnchainOpSigner,
+    syncctl::PoxSyncWatchdogComms, BitcoinRegtestController, BurnchainController, Config,
+    ConfigFile, Keychain,
+};
+
+use crate::util::hash::{MerkleTree, Sha512Trunc256Sum};
+use crate::util::secp256k1::MessageSignature;
+
+use crate::neon_node::StacksNode;
+
+use rand::Rng;
 
 use super::bitcoin_regtest::BitcoinCoreController;
 use super::{
@@ -63,16 +85,23 @@ use super::{
     make_microblock, make_stacks_transfer, make_stacks_transfer_mblock_only, to_addr, ADDR_4, SK_1,
     SK_2,
 };
-use crate::burnchains::bitcoin_regtest_controller::UTXO;
-use crate::config::{EventKeyType, EventObserverConfig, FeeEstimatorName, InitialBalance};
-use crate::neon_node::{RelayerThread, StacksNode};
-use crate::operations::BurnchainOpSigner;
-use crate::stacks_common::types::PrivateKey;
-use crate::syncctl::PoxSyncWatchdogComms;
+
+use crate::config::FeeEstimatorName;
 use crate::tests::SK_3;
-use crate::util::hash::{MerkleTree, Sha512Trunc256Sum};
-use crate::util::secp256k1::MessageSignature;
-use crate::{neon, BitcoinRegtestController, BurnchainController, Config, ConfigFile, Keychain};
+use clarity::vm::ast::stack_depth_checker::AST_CALL_STACK_DEPTH_BUFFER;
+use clarity::vm::ast::ASTRules;
+use clarity::vm::MAX_CALL_STACK_DEPTH;
+use stacks::chainstate::burn::db::sortdb::SortitionDB;
+use stacks::chainstate::stacks::miner::{
+    signal_mining_blocked, signal_mining_ready, TransactionErrorEvent, TransactionEvent,
+    TransactionSuccessEvent,
+};
+use stacks::net::RPCFeeEstimateResponse;
+use stacks::vm::ClarityName;
+use stacks::vm::ContractName;
+use std::convert::TryFrom;
+
+use crate::stacks_common::types::PrivateKey;
 
 fn inner_neon_integration_test_conf(seed: Option<Vec<u8>>) -> (Config, StacksAddress) {
     let mut conf = super::new_test_conf();
@@ -141,6 +170,7 @@ fn inner_neon_integration_test_conf(seed: Option<Vec<u8>>) -> (Config, StacksAdd
     conf.burnchain.poll_time_secs = 1;
     conf.node.pox_sync_sample_secs = 0;
 
+    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -171,8 +201,9 @@ pub mod test_observer {
     use std::sync::Mutex;
     use std::thread;
 
+    use tokio;
+    use warp;
     use warp::Filter;
-    use {tokio, warp};
 
     use crate::event_dispatcher::{MinedBlockEvent, MinedMicroblockEvent};
 
@@ -1338,7 +1369,7 @@ fn liquid_ustx_integration() {
             if contract_call.function_name.as_str() == "execute" {
                 let raw_result = tx.get("raw_result").unwrap().as_str().unwrap();
                 let parsed = Value::try_deserialize_hex_untyped(&raw_result[2..]).unwrap();
-                let liquid_ustx = parsed.expect_result_ok().expect_u128();
+                let liquid_ustx = parsed.expect_result_ok().unwrap().expect_u128().unwrap();
                 assert!(liquid_ustx > 0, "Should be more liquid ustx than 0");
                 tested = true;
             }
@@ -2308,6 +2339,7 @@ fn microblock_fork_poison_integration_test() {
     conf.miner.subsequent_attempt_time_ms = 5_000;
     conf.node.wait_time_for_blocks = 1_000;
 
+    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -3055,6 +3087,9 @@ fn filter_low_fee_tx_integration_test() {
         });
     }
 
+    // exclude the first 5 transactions from miner consideration
+    conf.miner.min_tx_fee = 1500;
+
     let mut btcd_controller = BitcoinCoreController::new(conf.clone());
     btcd_controller
         .start_bitcoind()
@@ -3142,6 +3177,9 @@ fn filter_long_runtime_tx_integration_test() {
         });
     }
 
+    // all transactions have high-enough fees...
+    conf.miner.min_tx_fee = 1;
+
     // ...but none of them will be mined since we allot zero ms to do so
     conf.miner.first_attempt_time_ms = 0;
     conf.miner.subsequent_attempt_time_ms = 0;
@@ -3220,6 +3258,8 @@ fn miner_submit_twice() {
         amount: 1049230,
     });
 
+    // all transactions have high-enough fees...
+    conf.miner.min_tx_fee = 1;
     conf.node.mine_microblocks = false;
     // one should be mined in first attempt, and two should be in second attempt
     conf.miner.first_attempt_time_ms = 20;
@@ -3339,6 +3379,7 @@ fn size_check_integration_test() {
     conf.node.microblock_frequency = 5000;
     conf.miner.microblock_attempt_time_ms = 120_000;
 
+    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -3515,6 +3556,7 @@ fn size_overflow_unconfirmed_microblocks_integration_test() {
     conf.node.microblock_frequency = 5_000;
     conf.miner.microblock_attempt_time_ms = 120_000;
 
+    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -3711,6 +3753,7 @@ fn size_overflow_unconfirmed_stream_microblocks_integration_test() {
     conf.node.max_microblocks = 65536;
     conf.burnchain.max_rbf = 1000000;
 
+    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -3905,6 +3948,7 @@ fn size_overflow_unconfirmed_invalid_stream_microblocks_integration_test() {
     epochs[1].block_limit = core::BLOCK_LIMIT_MAINNET_20;
     conf.burnchain.epochs = Some(epochs);
 
+    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -4167,6 +4211,7 @@ fn runtime_overflow_unconfirmed_microblocks_integration_test() {
     conf.node.microblock_frequency = 15000;
     conf.miner.microblock_attempt_time_ms = 120_000;
 
+    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -4342,6 +4387,7 @@ fn block_replay_integration_test() {
     conf.node.wait_time_for_microblocks = 30000;
     conf.node.microblock_frequency = 5_000;
 
+    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -4792,6 +4838,7 @@ fn mining_events_integration_test() {
     conf.node.wait_time_for_microblocks = 1000;
     conf.node.microblock_frequency = 1000;
 
+    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -4870,7 +4917,15 @@ fn mining_events_integration_test() {
             execution_cost,
             ..
         }) => {
-            assert_eq!(result.clone().expect_result_ok().expect_bool(), true);
+            assert_eq!(
+                result
+                    .clone()
+                    .expect_result_ok()
+                    .unwrap()
+                    .expect_bool()
+                    .unwrap(),
+                true
+            );
             assert_eq!(fee, &620000);
             assert_eq!(
                 execution_cost,
@@ -4902,7 +4957,15 @@ fn mining_events_integration_test() {
                 txid.to_string(),
                 "3e04ada5426332bfef446ba0a06d124aace4ade5c11840f541bf88e2e919faf6"
             );
-            assert_eq!(result.clone().expect_result_ok().expect_bool(), true);
+            assert_eq!(
+                result
+                    .clone()
+                    .expect_result_ok()
+                    .unwrap()
+                    .expect_bool()
+                    .unwrap(),
+                true
+            );
         }
         _ => panic!("unexpected event type"),
     }
@@ -4915,7 +4978,15 @@ fn mining_events_integration_test() {
             execution_cost,
             ..
         }) => {
-            assert_eq!(result.clone().expect_result_ok().expect_bool(), true);
+            assert_eq!(
+                result
+                    .clone()
+                    .expect_result_ok()
+                    .unwrap()
+                    .expect_bool()
+                    .unwrap(),
+                true
+            );
             assert_eq!(fee, &600000);
             assert_eq!(
                 execution_cost,
@@ -5039,6 +5110,7 @@ fn block_limit_hit_integration_test() {
     conf.node.wait_time_for_microblocks = 30000;
     conf.node.microblock_frequency = 1000;
 
+    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -5256,6 +5328,7 @@ fn microblock_limit_hit_integration_test() {
     conf.burnchain.max_rbf = 10_000_000;
     conf.node.wait_time_for_blocks = 1_000;
 
+    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -5467,6 +5540,7 @@ fn block_large_tx_integration_test() {
     conf.burnchain.max_rbf = 10_000_000;
     conf.node.wait_time_for_blocks = 1_000;
 
+    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -5601,6 +5675,7 @@ fn microblock_large_tx_integration_test_FLAKY() {
     conf.node.wait_time_for_microblocks = 30000;
     conf.node.microblock_frequency = 1000;
 
+    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -10679,336 +10754,3 @@ fn microblock_miner_multiple_attempts() {
 
     channel.stop_chains_coordinator();
 }
-
-#[test]
-#[ignore]
-fn min_txs() {
-    if env::var("BITCOIND_TEST") != Ok("1".into()) {
-        return;
-    }
-
-    let spender_sk = StacksPrivateKey::new();
-    let spender_addr = to_addr(&spender_sk);
-    let spender_princ: PrincipalData = spender_addr.into();
-
-    let (mut conf, _miner_account) = neon_integration_test_conf();
-
-    test_observer::spawn();
-
-    conf.events_observers.push(EventObserverConfig {
-        endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
-        events_keys: vec![EventKeyType::AnyEvent],
-    });
-
-    conf.miner.min_tx_count = 4;
-    conf.miner.first_attempt_time_ms = 0;
-    conf.miner.activated_vrf_key_path = Some("/tmp/activate_vrf_key.min_txs.json".to_string());
-
-    if fs::metadata("/tmp/activate_vrf_key.min_txs.json").is_ok() {
-        fs::remove_file("/tmp/activate_vrf_key.min_txs.json").unwrap();
-    }
-
-    let spender_bal = 10_000_000_000 * (core::MICROSTACKS_PER_STACKS as u64);
-
-    conf.initial_balances.push(InitialBalance {
-        address: spender_princ.clone(),
-        amount: spender_bal,
-    });
-
-    let mut btcd_controller = BitcoinCoreController::new(conf.clone());
-    btcd_controller
-        .start_bitcoind()
-        .map_err(|_e| ())
-        .expect("Failed starting bitcoind");
-
-    let burnchain_config = Burnchain::regtest(&conf.get_burn_db_path());
-
-    let mut btc_regtest_controller = BitcoinRegtestController::with_burnchain(
-        conf.clone(),
-        None,
-        Some(burnchain_config.clone()),
-        None,
-    );
-    let http_origin = format!("http://{}", &conf.node.rpc_bind);
-
-    btc_regtest_controller.bootstrap_chain(201);
-
-    eprintln!("Chain bootstrapped...");
-
-    let mut run_loop = neon::RunLoop::new(conf.clone());
-    let blocks_processed = run_loop.get_blocks_processed_arc();
-    let _client = reqwest::blocking::Client::new();
-    let channel = run_loop.get_coordinator_channel().unwrap();
-
-    thread::spawn(move || run_loop.start(Some(burnchain_config), 0));
-
-    // give the run loop some time to start up!
-    wait_for_runloop(&blocks_processed);
-
-    // first block wakes up the run loop
-    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
-
-    // first block will hold our VRF registration
-    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
-
-    // second block will be the first mined Stacks block
-    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
-
-    let _sort_height = channel.get_sortitions_processed();
-
-    for i in 0..2 {
-        let code = format!("(print \"hello world {}\")", i);
-        let publish = make_contract_publish(
-            &spender_sk,
-            i as u64,
-            1000,
-            &format!("test-publish-{}", &i),
-            &code,
-        );
-        submit_tx(&http_origin, &publish);
-
-        debug!("Try to build too-small a block {}", &i);
-        next_block_and_wait_with_timeout(&mut btc_regtest_controller, &blocks_processed, 15);
-    }
-
-    let blocks = test_observer::get_blocks();
-    for block in blocks {
-        let transactions = block.get("transactions").unwrap().as_array().unwrap();
-        if transactions.len() > 1 {
-            debug!("Got block: {:?}", &block);
-            assert!(transactions.len() >= 4);
-        }
-    }
-
-    let saved_vrf_key = RelayerThread::load_saved_vrf_key("/tmp/activate_vrf_key.min_txs.json");
-    assert!(saved_vrf_key.is_some());
-
-    test_observer::clear();
-}
-
-#[test]
-#[ignore]
-fn filter_txs_by_type() {
-    if env::var("BITCOIND_TEST") != Ok("1".into()) {
-        return;
-    }
-
-    let spender_sk = StacksPrivateKey::new();
-    let spender_addr = to_addr(&spender_sk);
-    let spender_princ: PrincipalData = spender_addr.into();
-
-    let (mut conf, _miner_account) = neon_integration_test_conf();
-
-    test_observer::spawn();
-
-    conf.events_observers.push(EventObserverConfig {
-        endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
-        events_keys: vec![EventKeyType::AnyEvent],
-    });
-
-    conf.miner.min_tx_count = 4;
-    conf.miner.first_attempt_time_ms = 0;
-    conf.miner.activated_vrf_key_path = Some("/tmp/activate_vrf_key.filter_txs.json".to_string());
-    conf.miner.txs_to_consider = [MemPoolWalkTxTypes::TokenTransfer].into_iter().collect();
-
-    if fs::metadata("/tmp/activate_vrf_key.filter_txs.json").is_ok() {
-        fs::remove_file("/tmp/activate_vrf_key.filter_txs.json").unwrap();
-    }
-
-    let spender_bal = 10_000_000_000 * (core::MICROSTACKS_PER_STACKS as u64);
-
-    conf.initial_balances.push(InitialBalance {
-        address: spender_princ.clone(),
-        amount: spender_bal,
-    });
-
-    let mut btcd_controller = BitcoinCoreController::new(conf.clone());
-    btcd_controller
-        .start_bitcoind()
-        .map_err(|_e| ())
-        .expect("Failed starting bitcoind");
-
-    let burnchain_config = Burnchain::regtest(&conf.get_burn_db_path());
-
-    let mut btc_regtest_controller = BitcoinRegtestController::with_burnchain(
-        conf.clone(),
-        None,
-        Some(burnchain_config.clone()),
-        None,
-    );
-    let http_origin = format!("http://{}", &conf.node.rpc_bind);
-
-    btc_regtest_controller.bootstrap_chain(201);
-
-    eprintln!("Chain bootstrapped...");
-
-    let mut run_loop = neon::RunLoop::new(conf.clone());
-    let blocks_processed = run_loop.get_blocks_processed_arc();
-    let _client = reqwest::blocking::Client::new();
-    let channel = run_loop.get_coordinator_channel().unwrap();
-
-    thread::spawn(move || run_loop.start(Some(burnchain_config), 0));
-
-    // give the run loop some time to start up!
-    wait_for_runloop(&blocks_processed);
-
-    // first block wakes up the run loop
-    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
-
-    // first block will hold our VRF registration
-    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
-
-    // second block will be the first mined Stacks block
-    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
-
-    let _sort_height = channel.get_sortitions_processed();
-    let mut sent_txids = HashSet::new();
-    for i in 0..2 {
-        let code = format!("(print \"hello world {}\")", i);
-        let publish = make_contract_publish(
-            &spender_sk,
-            i as u64,
-            1000,
-            &format!("test-publish-{}", &i),
-            &code,
-        );
-        let parsed = StacksTransaction::consensus_deserialize(&mut &publish[..]).unwrap();
-        sent_txids.insert(parsed.txid());
-
-        submit_tx(&http_origin, &publish);
-        next_block_and_wait_with_timeout(&mut btc_regtest_controller, &blocks_processed, 15);
-    }
-
-    let blocks = test_observer::get_blocks();
-    for block in blocks {
-        info!("block: {:?}", &block);
-        let transactions = block.get("transactions").unwrap().as_array().unwrap();
-        for tx in transactions {
-            let raw_tx = tx.get("raw_tx").unwrap().as_str().unwrap();
-            if raw_tx == "0x00" {
-                continue;
-            }
-            let tx_bytes = hex_bytes(&raw_tx[2..]).unwrap();
-            let parsed = StacksTransaction::consensus_deserialize(&mut &tx_bytes[..]).unwrap();
-            if sent_txids.contains(&parsed.txid()) {
-                panic!("Included a smart contract");
-            }
-        }
-    }
-
-    let saved_vrf_key = RelayerThread::load_saved_vrf_key("/tmp/activate_vrf_key.filter_txs.json");
-    assert!(saved_vrf_key.is_some());
-
-    test_observer::clear();
-}
-
-#[test]
-#[ignore]
-fn filter_txs_by_origin() {
-    if env::var("BITCOIND_TEST") != Ok("1".into()) {
-        return;
-    }
-
-    let spender_sk = StacksPrivateKey::new();
-    let spender_addr = to_addr(&spender_sk);
-    let spender_princ: PrincipalData = spender_addr.into();
-
-    let (mut conf, _miner_account) = neon_integration_test_conf();
-
-    test_observer::spawn();
-
-    conf.events_observers.push(EventObserverConfig {
-        endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
-        events_keys: vec![EventKeyType::AnyEvent],
-    });
-
-    conf.miner.min_tx_count = 4;
-    conf.miner.first_attempt_time_ms = 0;
-    conf.miner.filter_origins =
-        [StacksAddress::from_string("STA2MZWV9N67TBYVWTE0PSSKMJ2F6YXW7DX96QAM").unwrap()]
-            .into_iter()
-            .collect();
-
-    let spender_bal = 10_000_000_000 * (core::MICROSTACKS_PER_STACKS as u64);
-
-    conf.initial_balances.push(InitialBalance {
-        address: spender_princ.clone(),
-        amount: spender_bal,
-    });
-
-    let mut btcd_controller = BitcoinCoreController::new(conf.clone());
-    btcd_controller
-        .start_bitcoind()
-        .map_err(|_e| ())
-        .expect("Failed starting bitcoind");
-
-    let burnchain_config = Burnchain::regtest(&conf.get_burn_db_path());
-
-    let mut btc_regtest_controller = BitcoinRegtestController::with_burnchain(
-        conf.clone(),
-        None,
-        Some(burnchain_config.clone()),
-        None,
-    );
-    let http_origin = format!("http://{}", &conf.node.rpc_bind);
-
-    btc_regtest_controller.bootstrap_chain(201);
-
-    eprintln!("Chain bootstrapped...");
-
-    let mut run_loop = neon::RunLoop::new(conf.clone());
-    let blocks_processed = run_loop.get_blocks_processed_arc();
-    let _client = reqwest::blocking::Client::new();
-    let channel = run_loop.get_coordinator_channel().unwrap();
-
-    thread::spawn(move || run_loop.start(Some(burnchain_config), 0));
-
-    // give the run loop some time to start up!
-    wait_for_runloop(&blocks_processed);
-
-    // first block wakes up the run loop
-    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
-
-    // first block will hold our VRF registration
-    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
-
-    // second block will be the first mined Stacks block
-    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
-
-    let _sort_height = channel.get_sortitions_processed();
-    let mut sent_txids = HashSet::new();
-    for i in 0..2 {
-        let code = format!("(print \"hello world {}\")", i);
-        let publish = make_contract_publish(
-            &spender_sk,
-            i as u64,
-            1000,
-            &format!("test-publish-{}", &i),
-            &code,
-        );
-        let parsed = StacksTransaction::consensus_deserialize(&mut &publish[..]).unwrap();
-        sent_txids.insert(parsed.txid());
-
-        submit_tx(&http_origin, &publish);
-        next_block_and_wait_with_timeout(&mut btc_regtest_controller, &blocks_processed, 15);
-    }
-
-    let blocks = test_observer::get_blocks();
-    for block in blocks {
-        info!("block: {:?}", &block);
-        let transactions = block.get("transactions").unwrap().as_array().unwrap();
-        for tx in transactions {
-            let raw_tx = tx.get("raw_tx").unwrap().as_str().unwrap();
-            if raw_tx == "0x00" {
-                continue;
-            }
-            let tx_bytes = hex_bytes(&raw_tx[2..]).unwrap();
-            let parsed = StacksTransaction::consensus_deserialize(&mut &tx_bytes[..]).unwrap();
-            if sent_txids.contains(&parsed.txid()) {
-                panic!("Included a smart contract");
-            }
-        }
-    }
-
-    test_observer::clear();
-}

From b6be51756f2b6c93d979b61434b86ef23014067a Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Thu, 18 Jan 2024 13:14:16 -0500
Subject: [PATCH 0391/1166] chore: cargo fmt

---
 Cargo.lock                                    |    4 +-
 src/burnchains/burnchain.rs                   |    4 +-
 src/chainstate/stacks/db/blocks.rs            |   22 +
 src/chainstate/stacks/miner.rs                |    1 +
 src/chainstate/stacks/mod.rs                  |    2 +-
 .../stacks/tests/block_construction.rs        |    1 -
 src/core/mempool.rs                           |  115 +-
 src/core/tests/mod.rs                         |  173 ++-
 src/cost_estimates/fee_scalar.rs              |   23 +-
 src/main.rs                                   |    1 -
 testnet/stacks-node/Cargo.toml                |    4 +-
 .../burnchains/bitcoin_regtest_controller.rs  |   66 +-
 testnet/stacks-node/src/chain_data.rs         | 1105 ++++++++++++++++
 testnet/stacks-node/src/config.rs             |  215 +++-
 testnet/stacks-node/src/main.rs               |  258 +++-
 testnet/stacks-node/src/neon_node.rs          | 1121 +++++++++++++++--
 testnet/stacks-node/src/run_loop/mod.rs       |    2 +-
 testnet/stacks-node/src/run_loop/neon.rs      |   19 +-
 .../stacks-node/src/tests/bitcoin_regtest.rs  |    1 -
 testnet/stacks-node/src/tests/epoch_205.rs    |    1 -
 testnet/stacks-node/src/tests/epoch_21.rs     |    2 -
 testnet/stacks-node/src/tests/epoch_22.rs     |    2 -
 testnet/stacks-node/src/tests/epoch_23.rs     |    1 -
 testnet/stacks-node/src/tests/epoch_24.rs     |   11 +-
 testnet/stacks-node/src/tests/integrations.rs |    1 -
 testnet/stacks-node/src/tests/mod.rs          |  351 +++++-
 .../src/tests/neon_integrations.rs            |  468 +++++--
 27 files changed, 3635 insertions(+), 339 deletions(-)
 create mode 100644 testnet/stacks-node/src/chain_data.rs

diff --git a/Cargo.lock b/Cargo.lock
index d4ea00d0b6..f952164fc8 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1820,9 +1820,9 @@ dependencies = [
 
 [[package]]
 name = "pico-args"
-version = "0.3.4"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28b9b4df73455c861d7cbf8be42f01d3b373ed7f02e378d55fa84eafc6f638b1"
+checksum = "5be167a7af36ee22fe3115051bc51f6e6c7054c9348e28deb4f49bd6f705a315"
 
 [[package]]
 name = "pin-project"
diff --git a/src/burnchains/burnchain.rs b/src/burnchains/burnchain.rs
index dc0b75de61..f90e05e4ee 100644
--- a/src/burnchains/burnchain.rs
+++ b/src/burnchains/burnchain.rs
@@ -316,7 +316,7 @@ impl BurnchainStateTransition {
 }
 
 impl BurnchainSigner {
-    #[cfg(test)]
+    #[cfg(any(test, feature = "testing"))]
     pub fn mock_parts(
         hash_mode: AddressHashMode,
         num_sigs: usize,
@@ -330,7 +330,7 @@ impl BurnchainSigner {
         BurnchainSigner(repr)
     }
 
-    #[cfg(test)]
+    #[cfg(any(test, feature = "testing"))]
     pub fn new_p2pkh(pubk: &StacksPublicKey) -> BurnchainSigner {
         BurnchainSigner::mock_parts(AddressHashMode::SerializeP2PKH, 1, vec![pubk.clone()])
     }
diff --git a/src/chainstate/stacks/db/blocks.rs b/src/chainstate/stacks/db/blocks.rs
index 86388349ae..fe35511210 100644
--- a/src/chainstate/stacks/db/blocks.rs
+++ b/src/chainstate/stacks/db/blocks.rs
@@ -7049,6 +7049,28 @@ impl StacksChainState {
         query_row(&self.db(), sql, args).map_err(Error::DBError)
     }
 
+    /// Get all possible canonical chain tips
+    pub fn get_stacks_chain_tips(&self, sortdb: &SortitionDB) -> Result<Vec<StagingBlock>, Error> {
+        let (consensus_hash, block_bhh) =
+            SortitionDB::get_canonical_stacks_chain_tip_hash(sortdb.conn())?;
+        let sql = "SELECT * FROM staging_blocks WHERE processed = 1 AND orphaned = 0 AND consensus_hash = ?1 AND anchored_block_hash = ?2";
+        let args: &[&dyn ToSql] = &[&consensus_hash, &block_bhh];
+        let Some(staging_block): Option<StagingBlock> =
+            query_row(&self.db(), sql, args).map_err(Error::DBError)?
+        else {
+            return Ok(vec![]);
+        };
+        self.get_stacks_chain_tips_at_height(staging_block.height)
+    }
+
+    /// Get all Stacks blocks at a given height
+    pub fn get_stacks_chain_tips_at_height(&self, height: u64) -> Result<Vec<StagingBlock>, Error> {
+        let sql =
+            "SELECT * FROM staging_blocks WHERE processed = 1 AND orphaned = 0 AND height = ?1";
+        let args: &[&dyn ToSql] = &[&u64_to_sql(height)?];
+        query_rows(&self.db(), sql, args).map_err(Error::DBError)
+    }
+
     /// Get the parent block of `staging_block`.
     pub fn get_stacks_block_parent(
         &self,
diff --git a/src/chainstate/stacks/miner.rs b/src/chainstate/stacks/miner.rs
index e682f3f7b0..863336d819 100644
--- a/src/chainstate/stacks/miner.rs
+++ b/src/chainstate/stacks/miner.rs
@@ -114,6 +114,7 @@ impl MinerStatus {
     pub fn get_spend_amount(&self) -> u64 {
         return self.spend_amount;
     }
+
     pub fn set_spend_amount(&mut self, amt: u64) {
         self.spend_amount = amt;
     }
diff --git a/src/chainstate/stacks/mod.rs b/src/chainstate/stacks/mod.rs
index 4ed4169d4a..74979b1ece 100644
--- a/src/chainstate/stacks/mod.rs
+++ b/src/chainstate/stacks/mod.rs
@@ -84,7 +84,7 @@ pub use stacks_common::address::{
     C32_ADDRESS_VERSION_TESTNET_MULTISIG, C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
 };
 
-pub const STACKS_BLOCK_VERSION: u8 = 6;
+pub const STACKS_BLOCK_VERSION: u8 = 7;
 pub const STACKS_BLOCK_VERSION_AST_PRECHECK_SIZE: u8 = 1;
 
 pub const MAX_BLOCK_LEN: u32 = 2 * 1024 * 1024;
diff --git a/src/chainstate/stacks/tests/block_construction.rs b/src/chainstate/stacks/tests/block_construction.rs
index 006e0dd134..b93af992fc 100644
--- a/src/chainstate/stacks/tests/block_construction.rs
+++ b/src/chainstate/stacks/tests/block_construction.rs
@@ -4708,7 +4708,6 @@ fn paramaterized_mempool_walk_test(
     let b_2 = make_block(&mut chainstate, ConsensusHash([0x2; 20]), &b_1, 2, 2);
 
     let mut mempool_settings = MemPoolWalkSettings::default();
-    mempool_settings.min_tx_fee = 10;
     let mut tx_events = Vec::new();
 
     let txs = codec_all_transactions(
diff --git a/src/core/mempool.rs b/src/core/mempool.rs
index 5efb762815..aba585044f 100644
--- a/src/core/mempool.rs
+++ b/src/core/mempool.rs
@@ -22,6 +22,7 @@ use std::io::{Read, Write};
 use std::ops::Deref;
 use std::ops::DerefMut;
 use std::path::{Path, PathBuf};
+use std::str::FromStr;
 
 use rand::distributions::Uniform;
 use rand::prelude::Distribution;
@@ -292,10 +293,51 @@ impl MemPoolTxMetadata {
     }
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum MemPoolWalkTxTypes {
+    TokenTransfer,
+    SmartContract,
+    ContractCall,
+}
+
+impl FromStr for MemPoolWalkTxTypes {
+    type Err = &'static str;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "TokenTransfer" => {
+                return Ok(Self::TokenTransfer);
+            }
+            "SmartContract" => {
+                return Ok(Self::SmartContract);
+            }
+            "ContractCall" => {
+                return Ok(Self::ContractCall);
+            }
+            _ => {
+                return Err("Unknown mempool tx walk type");
+            }
+        }
+    }
+}
+
+impl MemPoolWalkTxTypes {
+    pub fn all() -> HashSet<MemPoolWalkTxTypes> {
+        [
+            MemPoolWalkTxTypes::TokenTransfer,
+            MemPoolWalkTxTypes::SmartContract,
+            MemPoolWalkTxTypes::ContractCall,
+        ]
+        .into_iter()
+        .collect()
+    }
+
+    pub fn only(selected: &[MemPoolWalkTxTypes]) -> HashSet<MemPoolWalkTxTypes> {
+        selected.iter().map(|x| x.clone()).collect()
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct MemPoolWalkSettings {
-    /// Minimum transaction fee that will be considered
-    pub min_tx_fee: u64,
     /// Maximum amount of time a miner will spend walking through mempool transactions, in
     /// milliseconds.  This is a soft deadline.
     pub max_walk_time_ms: u64,
@@ -308,25 +350,43 @@ pub struct MemPoolWalkSettings {
     /// Size of the candidate cache. These are the candidates that will be retried after each
     /// transaction is mined.
     pub candidate_retry_cache_size: u64,
+    /// Types of transactions we'll consider
+    pub txs_to_consider: HashSet<MemPoolWalkTxTypes>,
+    /// Origins for transactions that we'll consider
+    pub filter_origins: HashSet<StacksAddress>,
 }
 
 impl MemPoolWalkSettings {
     pub fn default() -> MemPoolWalkSettings {
         MemPoolWalkSettings {
-            min_tx_fee: 1,
             max_walk_time_ms: u64::max_value(),
             consider_no_estimate_tx_prob: 5,
             nonce_cache_size: 1024 * 1024,
             candidate_retry_cache_size: 64 * 1024,
+            txs_to_consider: [
+                MemPoolWalkTxTypes::TokenTransfer,
+                MemPoolWalkTxTypes::SmartContract,
+                MemPoolWalkTxTypes::ContractCall,
+            ]
+            .into_iter()
+            .collect(),
+            filter_origins: HashSet::new(),
         }
     }
     pub fn zero() -> MemPoolWalkSettings {
         MemPoolWalkSettings {
-            min_tx_fee: 0,
             max_walk_time_ms: u64::max_value(),
             consider_no_estimate_tx_prob: 5,
             nonce_cache_size: 1024 * 1024,
             candidate_retry_cache_size: 64 * 1024,
+            txs_to_consider: [
+                MemPoolWalkTxTypes::TokenTransfer,
+                MemPoolWalkTxTypes::SmartContract,
+                MemPoolWalkTxTypes::ContractCall,
+            ]
+            .into_iter()
+            .collect(),
+            filter_origins: HashSet::new(),
         }
     }
 }
@@ -698,8 +758,8 @@ impl<'a> MemPoolTx<'a> {
             let evict_txid = {
                 let num_recents = MemPoolDB::get_num_recent_txs(&dbtx)?;
                 if num_recents >= MAX_BLOOM_COUNTER_TXS.into() {
-                    // for now, remove lowest-fee tx in the recent tx set.
-                    // TODO: In the future, do it by lowest fee rate
+                    // remove lowest-fee tx (they're paying the least, so replication is
+                    // deprioritized)
                     let sql = "SELECT a.txid FROM mempool AS a LEFT OUTER JOIN removed_txids AS b ON a.txid = b.txid WHERE b.txid IS NULL AND a.height > ?1 ORDER BY a.tx_fee ASC LIMIT 1";
                     let args: &[&dyn ToSql] = &[&u64_to_sql(
                         height.saturating_sub(BLOOM_COUNTER_DEPTH as u64),
@@ -1539,6 +1599,49 @@ impl MemPoolDB {
                 }
             };
 
+            let (tx_type, do_consider) = match &tx_info.tx.payload {
+                TransactionPayload::TokenTransfer(..) => (
+                    "TokenTransfer".to_string(),
+                    settings
+                        .txs_to_consider
+                        .contains(&MemPoolWalkTxTypes::TokenTransfer),
+                ),
+                TransactionPayload::SmartContract(..) => (
+                    "SmartContract".to_string(),
+                    settings
+                        .txs_to_consider
+                        .contains(&MemPoolWalkTxTypes::SmartContract),
+                ),
+                TransactionPayload::ContractCall(..) => (
+                    "ContractCall".to_string(),
+                    settings
+                        .txs_to_consider
+                        .contains(&MemPoolWalkTxTypes::ContractCall),
+                ),
+                _ => ("".to_string(), true),
+            };
+            if !do_consider {
+                debug!("Will skip mempool tx, since it does not have an acceptable type";
+                       "txid" => %tx_info.tx.txid(),
+                       "type" => %tx_type);
+                continue;
+            }
+
+            let do_consider = if settings.filter_origins.len() > 0 {
+                settings
+                    .filter_origins
+                    .contains(&tx_info.metadata.origin_address)
+            } else {
+                true
+            };
+
+            if !do_consider {
+                debug!("Will skip mempool tx, since it does not have an allowed origin";
+                       "txid" => %tx_info.tx.txid(),
+                       "origin" => %tx_info.metadata.origin_address);
+                continue;
+            }
+
             let consider = ConsiderTransaction {
                 tx: tx_info,
                 update_estimate,
diff --git a/src/core/tests/mod.rs b/src/core/tests/mod.rs
index 3533ce2ad8..1ad95d781f 100644
--- a/src/core/tests/mod.rs
+++ b/src/core/tests/mod.rs
@@ -42,6 +42,7 @@ use crate::chainstate::stacks::{
 };
 use crate::core::mempool::db_get_all_nonces;
 use crate::core::mempool::MemPoolWalkSettings;
+use crate::core::mempool::MemPoolWalkTxTypes;
 use crate::core::mempool::TxTag;
 use crate::core::mempool::{BLOOM_COUNTER_DEPTH, BLOOM_COUNTER_ERROR_RATE, MAX_BLOOM_COUNTER_TXS};
 use crate::core::FIRST_BURNCHAIN_CONSENSUS_HASH;
@@ -278,8 +279,7 @@ fn mempool_walk_over_fork() {
     //   try to walk at b_4, we should be able to find
     //   the transaction at b_1
 
-    let mut mempool_settings = MemPoolWalkSettings::default();
-    mempool_settings.min_tx_fee = 10;
+    let mempool_settings = MemPoolWalkSettings::default();
     let mut tx_events = Vec::new();
     chainstate.with_read_only_clarity_tx(
         &TEST_BURN_STATE_DB,
@@ -614,7 +614,6 @@ fn test_iterate_candidates_consider_no_estimate_tx_prob() {
     let b_2 = make_block(&mut chainstate, ConsensusHash([0x2; 20]), &b_1, 2, 2);
 
     let mut mempool_settings = MemPoolWalkSettings::default();
-    mempool_settings.min_tx_fee = 10;
     let mut tx_events = Vec::new();
 
     let mut txs = codec_all_transactions(
@@ -809,8 +808,7 @@ fn test_iterate_candidates_skipped_transaction() {
     );
     let b_2 = make_block(&mut chainstate, ConsensusHash([0x2; 20]), &b_1, 2, 2);
 
-    let mut mempool_settings = MemPoolWalkSettings::default();
-    mempool_settings.min_tx_fee = 10;
+    let mempool_settings = MemPoolWalkSettings::default();
     let mut tx_events = Vec::new();
 
     let mut txs = codec_all_transactions(
@@ -922,8 +920,7 @@ fn test_iterate_candidates_processing_error_transaction() {
     );
     let b_2 = make_block(&mut chainstate, ConsensusHash([0x2; 20]), &b_1, 2, 2);
 
-    let mut mempool_settings = MemPoolWalkSettings::default();
-    mempool_settings.min_tx_fee = 10;
+    let mempool_settings = MemPoolWalkSettings::default();
     let mut tx_events = Vec::new();
 
     let mut txs = codec_all_transactions(
@@ -1037,8 +1034,7 @@ fn test_iterate_candidates_problematic_transaction() {
     );
     let b_2 = make_block(&mut chainstate, ConsensusHash([0x2; 20]), &b_1, 2, 2);
 
-    let mut mempool_settings = MemPoolWalkSettings::default();
-    mempool_settings.min_tx_fee = 10;
+    let mempool_settings = MemPoolWalkSettings::default();
     let mut tx_events = Vec::new();
 
     let mut txs = codec_all_transactions(
@@ -1153,7 +1149,6 @@ fn test_iterate_candidates_concurrent_write_lock() {
     let b_2 = make_block(&mut chainstate, ConsensusHash([0x2; 20]), &b_1, 2, 2);
 
     let mut mempool_settings = MemPoolWalkSettings::default();
-    mempool_settings.min_tx_fee = 10;
     let mut tx_events = Vec::new();
 
     let mut txs = codec_all_transactions(
@@ -3013,3 +3008,161 @@ fn test_drop_and_blacklist_txs_by_size() {
 
     assert_eq!(num_blacklisted, 5);
 }
+
+#[test]
+fn test_filter_txs_by_type() {
+    let mut chainstate = instantiate_chainstate(false, 0x80000000, function_name!());
+    let chainstate_path = chainstate_path(function_name!());
+    let mut mempool = MemPoolDB::open_test(false, 0x80000000, &chainstate_path).unwrap();
+
+    let addr = StacksAddress {
+        version: 1,
+        bytes: Hash160([0xff; 20]),
+    };
+    let mut txs = vec![];
+    let block_height = 10;
+    let mut total_len = 0;
+
+    let b_1 = make_block(
+        &mut chainstate,
+        ConsensusHash([0x1; 20]),
+        &(
+            FIRST_BURNCHAIN_CONSENSUS_HASH.clone(),
+            FIRST_STACKS_BLOCK_HASH.clone(),
+        ),
+        1,
+        1,
+    );
+    let b_2 = make_block(&mut chainstate, ConsensusHash([0x2; 20]), &b_1, 2, 2);
+
+    let mut mempool_tx = mempool.tx_begin().unwrap();
+    for i in 0..10 {
+        let pk = StacksPrivateKey::new();
+        let mut tx = StacksTransaction {
+            version: TransactionVersion::Testnet,
+            chain_id: 0x80000000,
+            auth: TransactionAuth::from_p2pkh(&pk).unwrap(),
+            anchor_mode: TransactionAnchorMode::Any,
+            post_condition_mode: TransactionPostConditionMode::Allow,
+            post_conditions: vec![],
+            payload: TransactionPayload::TokenTransfer(
+                addr.to_account_principal(),
+                123,
+                TokenTransferMemo([0u8; 34]),
+            ),
+        };
+        tx.set_tx_fee(1000);
+        tx.set_origin_nonce(0);
+
+        let txid = tx.txid();
+        let tx_bytes = tx.serialize_to_vec();
+        let origin_addr = tx.origin_address();
+        let origin_nonce = tx.get_origin_nonce();
+        let sponsor_addr = tx.sponsor_address().unwrap_or(origin_addr.clone());
+        let sponsor_nonce = tx.get_sponsor_nonce().unwrap_or(origin_nonce);
+        let tx_fee = tx.get_tx_fee();
+
+        total_len += tx_bytes.len();
+
+        // should succeed
+        MemPoolDB::try_add_tx(
+            &mut mempool_tx,
+            &mut chainstate,
+            &b_2.0,
+            &b_2.1,
+            txid.clone(),
+            tx_bytes,
+            tx_fee,
+            block_height as u64,
+            &origin_addr,
+            origin_nonce,
+            &sponsor_addr,
+            sponsor_nonce,
+            None,
+        )
+        .unwrap();
+
+        eprintln!("Added {} {}", i, &txid);
+        txs.push(tx);
+    }
+    mempool_tx.commit().unwrap();
+
+    let mut mempool_settings = MemPoolWalkSettings::default();
+    let mut tx_events = Vec::new();
+    mempool_settings.txs_to_consider = [
+        MemPoolWalkTxTypes::SmartContract,
+        MemPoolWalkTxTypes::ContractCall,
+    ]
+    .into_iter()
+    .collect();
+
+    chainstate.with_read_only_clarity_tx(
+        &TEST_BURN_STATE_DB,
+        &StacksBlockHeader::make_index_block_hash(&b_2.0, &b_2.1),
+        |clarity_conn| {
+            let mut count_txs = 0;
+            mempool
+                .iterate_candidates::<_, ChainstateError, _>(
+                    clarity_conn,
+                    &mut tx_events,
+                    2,
+                    mempool_settings.clone(),
+                    |_, available_tx, _| {
+                        count_txs += 1;
+                        Ok(Some(
+                            // Generate any success result
+                            TransactionResult::success(
+                                &available_tx.tx.tx,
+                                available_tx.tx.metadata.tx_fee,
+                                StacksTransactionReceipt::from_stx_transfer(
+                                    available_tx.tx.tx.clone(),
+                                    vec![],
+                                    Value::okay(Value::Bool(true)).unwrap(),
+                                    ExecutionCost::zero(),
+                                ),
+                            )
+                            .convert_to_event(),
+                        ))
+                    },
+                )
+                .unwrap();
+            assert_eq!(count_txs, 0);
+        },
+    );
+
+    mempool_settings.txs_to_consider = [MemPoolWalkTxTypes::TokenTransfer].into_iter().collect();
+
+    chainstate.with_read_only_clarity_tx(
+        &TEST_BURN_STATE_DB,
+        &StacksBlockHeader::make_index_block_hash(&b_2.0, &b_2.1),
+        |clarity_conn| {
+            let mut count_txs = 0;
+            mempool
+                .iterate_candidates::<_, ChainstateError, _>(
+                    clarity_conn,
+                    &mut tx_events,
+                    2,
+                    mempool_settings.clone(),
+                    |_, available_tx, _| {
+                        count_txs += 1;
+                        Ok(Some(
+                            // Generate any success result
+                            TransactionResult::success(
+                                &available_tx.tx.tx,
+                                available_tx.tx.metadata.tx_fee,
+                                StacksTransactionReceipt::from_stx_transfer(
+                                    available_tx.tx.tx.clone(),
+                                    vec![],
+                                    Value::okay(Value::Bool(true)).unwrap(),
+                                    ExecutionCost::zero(),
+                                ),
+                            )
+                            .convert_to_event(),
+                        ))
+                    },
+                )
+                .unwrap();
+            assert_eq!(count_txs, 10);
+        },
+    );
+}
diff --git a/src/cost_estimates/fee_scalar.rs b/src/cost_estimates/fee_scalar.rs
index ca252940cb..0e19b7a66b 100644
--- a/src/cost_estimates/fee_scalar.rs
+++ b/src/cost_estimates/fee_scalar.rs
@@ -16,6 +16,9 @@ use crate::util_lib::db::u64_to_sql;
 
 use clarity::vm::costs::ExecutionCost;
 
+use clarity::vm::database::ClaritySerializable;
+use clarity::vm::database::STXBalance;
+
 use crate::chainstate::stacks::db::StacksEpochReceipt;
 use crate::chainstate::stacks::events::TransactionOrigin;
 
@@ -170,7 +173,25 @@ impl<M: CostMetric> FeeEstimator for ScalarFeeRateEstimator<M> {
                 let scalar_cost = match payload {
                     TransactionPayload::TokenTransfer(_, _, _) => {
                         // TokenTransfers *only* contribute tx_len, and just have an empty ExecutionCost.
-                        self.metric.from_len(tx_size)
+                        let stx_balance_len = STXBalance::LockedPoxThree {
+                            amount_unlocked: 1,
+                            amount_locked: 1,
+                            unlock_height: 1,
+                        }
+                        .serialize()
+                        .as_bytes()
+                        .len() as u64;
+                        self.metric.from_cost_and_len(
+                            &ExecutionCost {
+                                write_length: stx_balance_len,
+                                write_count: 1,
+                                read_length: 2 * stx_balance_len,
+                                read_count: 2,
+                                runtime: 4640, // taken from .costs-3
+                            },
+                            &block_limit,
+                            tx_size,
+                        )
                     }
                     TransactionPayload::Coinbase(..) => {
                         // Coinbase txs are "free", so they don't factor into the fee market.
diff --git a/src/main.rs b/src/main.rs
index 10ea712cbe..6e92a7296c 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -770,7 +770,6 @@ simulating a miner.
 
         let mut settings = BlockBuilderSettings::limited();
         settings.max_miner_time_ms = max_time;
-        settings.mempool_settings.min_tx_fee = min_fee;
 
         let result = StacksBlockBuilder::build_anchored_block(
             &chain_state,
diff --git a/testnet/stacks-node/Cargo.toml b/testnet/stacks-node/Cargo.toml
index c36a27fb93..043d929c84 100644
--- a/testnet/stacks-node/Cargo.toml
+++ b/testnet/stacks-node/Cargo.toml
@@ -8,7 +8,7 @@ rust-version = "1.61"
 
 [dependencies]
 lazy_static = "1.4.0"
-pico-args = "0.3.1"
+pico-args = "0.5.0"
 rand = "0.7.3"
 serde = "1"
 serde_derive = "1"
@@ -21,7 +21,7 @@ async-std = { version = "1.6", features = ["attributes"] }
 http-types = "2.12"
 base64 = "0.12.0"
 backtrace = "0.3.50"
-libc = "0.2"
+libc = "0.2.151"
 slog = { version = "2.5.2", features = [ "max_level_trace" ] }
 clarity = { package = "clarity", path = "../../clarity/." }
 stacks_common = { package = "stacks-common", path = "../../stacks-common/." }
diff --git a/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs b/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
index 8b23d48c1f..86521e9ced 100644
--- a/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
+++ b/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
@@ -162,6 +162,18 @@ pub fn make_bitcoin_indexer(config: &Config) -> BitcoinIndexer {
     burnchain_indexer
 }
 
+pub fn get_satoshis_per_byte(config: &Config) -> u64 {
+    config.get_burnchain_config().satoshis_per_byte
+}
+
+pub fn get_rbf_fee_increment(config: &Config) -> u64 {
+    config.get_burnchain_config().rbf_fee_increment
+}
+
+pub fn get_max_rbf(config: &Config) -> u64 {
+    config.get_burnchain_config().max_rbf
+}
+
 impl LeaderBlockCommitFees {
     pub fn fees_from_previous_tx(
         &self,
@@ -171,7 +183,7 @@ impl LeaderBlockCommitFees {
         let mut fees = LeaderBlockCommitFees::estimated_fees_from_payload(payload, config);
         fees.spent_in_attempts = cmp::max(1, self.spent_in_attempts);
         fees.final_size = self.final_size;
-        fees.fee_rate = self.fee_rate + config.burnchain.rbf_fee_increment;
+        fees.fee_rate = self.fee_rate + get_rbf_fee_increment(&config);
         fees.is_rbf_enabled = true;
         fees
     }
@@ -190,7 +202,7 @@ impl LeaderBlockCommitFees {
         let value_per_transfer = payload.burn_fee / number_of_transfers;
         let sortition_fee = value_per_transfer * number_of_transfers;
         let spent_in_attempts = 0;
-        let fee_rate = config.burnchain.satoshis_per_byte;
+        let fee_rate = get_satoshis_per_byte(&config);
         let default_tx_size = config.burnchain.block_commit_tx_estimated_size;
 
         LeaderBlockCommitFees {
@@ -802,8 +814,9 @@ impl BitcoinRegtestController {
     ) -> Option<Transaction> {
         let public_key = signer.get_public_key();
 
+        // reload the config to find satoshis_per_byte changes
         let btc_miner_fee = self.config.burnchain.leader_key_tx_estimated_size
-            * self.config.burnchain.satoshis_per_byte;
+            * get_satoshis_per_byte(&self.config);
         let budget_for_outputs = DUST_UTXO_LIMIT;
         let total_required = btc_miner_fee + budget_for_outputs;
 
@@ -831,7 +844,7 @@ impl BitcoinRegtestController {
 
         tx.output = vec![consensus_output];
 
-        let fee_rate = self.config.burnchain.satoshis_per_byte;
+        let fee_rate = get_satoshis_per_byte(&self.config);
 
         self.finalize_tx(
             epoch_id,
@@ -925,7 +938,6 @@ impl BitcoinRegtestController {
     ) -> Option<Transaction> {
         let public_key = signer.get_public_key();
         let max_tx_size = 230;
-
         let (mut tx, mut utxos) = if let Some(utxo) = utxo_to_use {
             (
                 Transaction {
@@ -943,7 +955,7 @@ impl BitcoinRegtestController {
             self.prepare_tx(
                 epoch_id,
                 &public_key,
-                DUST_UTXO_LIMIT + max_tx_size * self.config.burnchain.satoshis_per_byte,
+                DUST_UTXO_LIMIT + max_tx_size * get_satoshis_per_byte(&self.config),
                 None,
                 None,
                 0,
@@ -977,7 +989,7 @@ impl BitcoinRegtestController {
             DUST_UTXO_LIMIT,
             0,
             max_tx_size,
-            self.config.burnchain.satoshis_per_byte,
+            get_satoshis_per_byte(&self.config),
             &mut utxos,
             signer,
         )?;
@@ -1026,7 +1038,7 @@ impl BitcoinRegtestController {
             self.prepare_tx(
                 epoch_id,
                 &public_key,
-                DUST_UTXO_LIMIT + max_tx_size * self.config.burnchain.satoshis_per_byte,
+                DUST_UTXO_LIMIT + max_tx_size * get_satoshis_per_byte(&self.config),
                 None,
                 None,
                 0,
@@ -1060,7 +1072,7 @@ impl BitcoinRegtestController {
             DUST_UTXO_LIMIT,
             0,
             max_tx_size,
-            self.config.burnchain.satoshis_per_byte,
+            get_satoshis_per_byte(&self.config),
             &mut utxos,
             signer,
         )?;
@@ -1095,7 +1107,7 @@ impl BitcoinRegtestController {
         let public_key = signer.get_public_key();
         let max_tx_size = 280;
 
-        let output_amt = DUST_UTXO_LIMIT + max_tx_size * self.config.burnchain.satoshis_per_byte;
+        let output_amt = DUST_UTXO_LIMIT + max_tx_size * get_satoshis_per_byte(&self.config);
         let (mut tx, mut utxos) =
             self.prepare_tx(epoch_id, &public_key, output_amt, None, None, 0)?;
 
@@ -1124,7 +1136,7 @@ impl BitcoinRegtestController {
             output_amt,
             0,
             max_tx_size,
-            self.config.burnchain.satoshis_per_byte,
+            get_satoshis_per_byte(&self.config),
             &mut utxos,
             signer,
         )?;
@@ -1322,11 +1334,11 @@ impl BitcoinRegtestController {
 
         // Stop as soon as the fee_rate is ${self.config.burnchain.max_rbf} percent higher, stop RBF
         if ongoing_op.fees.fee_rate
-            > (self.config.burnchain.satoshis_per_byte * self.config.burnchain.max_rbf / 100)
+            > (get_satoshis_per_byte(&self.config) * get_max_rbf(&self.config) / 100)
         {
             warn!(
                 "RBF'd block commits reached {}% satoshi per byte fee rate, not resubmitting",
-                self.config.burnchain.max_rbf
+                get_max_rbf(&self.config)
             );
             self.ongoing_block_commit = Some(ongoing_op);
             return None;
@@ -2489,3 +2501,31 @@ impl BitcoinRPCRequest {
         Ok(payload)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::config::DEFAULT_SATS_PER_VB;
+
+    use super::*;
+    use std::env::temp_dir;
+    use std::fs::File;
+    use std::io::Write;
+
+    #[test]
+    fn test_get_satoshis_per_byte() {
+        let dir = temp_dir();
+        let file_path = dir.as_path().join("config.toml");
+
+        let mut config = Config::default();
+
+        let satoshis_per_byte = get_satoshis_per_byte(&config);
+        assert_eq!(satoshis_per_byte, DEFAULT_SATS_PER_VB);
+
+        let mut file = File::create(&file_path).unwrap();
+        writeln!(file, "[burnchain]").unwrap();
+        writeln!(file, "satoshis_per_byte = 51").unwrap();
+        config.config_path = Some(file_path.to_str().unwrap().to_string());
+
+        assert_eq!(get_satoshis_per_byte(&config), 51);
+    }
+}
diff --git a/testnet/stacks-node/src/chain_data.rs b/testnet/stacks-node/src/chain_data.rs
new file mode 100644
index 0000000000..bd9e9e6173
--- /dev/null
+++ b/testnet/stacks-node/src/chain_data.rs
@@ -0,0 +1,1105 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020-2023 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+use std::collections::HashMap;
+use std::process::Command;
+use std::process::Stdio;
+
+use stacks::chainstate::burn::db::sortdb::SortitionDB;
+use stacks::chainstate::burn::db::sortdb::SortitionHandle;
+use stacks::chainstate::burn::distribution::BurnSamplePoint;
+use stacks::chainstate::burn::operations::leader_block_commit::{
+    MissedBlockCommit, BURN_BLOCK_MINED_AT_MODULUS,
+};
+use stacks::chainstate::burn::operations::LeaderBlockCommitOp;
+use stacks::chainstate::stacks::address::PoxAddress;
+
+use stacks::burnchains::bitcoin::address::BitcoinAddress;
+use stacks::burnchains::bitcoin::BitcoinNetworkType;
+use stacks::burnchains::bitcoin::BitcoinTxOutput;
+use stacks::burnchains::Burnchain;
+use stacks::burnchains::BurnchainSigner;
+use stacks::burnchains::Txid;
+use stacks_common::types::chainstate::BlockHeaderHash;
+use stacks_common::types::chainstate::BurnchainHeaderHash;
+use stacks_common::types::chainstate::VRFSeed;
+use stacks_common::util::hash::hex_bytes;
+
+use stacks::core::MINING_COMMITMENT_WINDOW;
+
+use stacks::util_lib::db::Error as DBError;
+
+use stacks::burnchains::Error as BurnchainError;
+
+pub struct MinerStats {
+    pub unconfirmed_commits_helper: String,
+}
+
+/// Unconfirmed block-commit transaction as emitted by our helper
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+struct UnconfirmedBlockCommit {
+    /// burnchain signer
+    address: String,
+    /// PoX payouts
+    pox_addrs: Vec<String>,
+    /// UTXO spent to create this block-commit
+    input_index: u32,
+    input_txid: String,
+    /// transaction ID
+    txid: String,
+    /// amount spent
+    burn: u64,
+}
+
+const DEADBEEF: [u8; 32] = [
+    0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef,
+    0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef, 0xde, 0xad, 0xbe, 0xef,
+];
+
+impl MinerStats {
+    /// Find the burn distribution for a single sortition's block-commits and missed-commits
+    fn get_burn_distribution<SH: SortitionHandle>(
+        sort_handle: &mut SH,
+        burnchain: &Burnchain,
+        burn_block_height: u64,
+        block_commits: Vec<LeaderBlockCommitOp>,
+        missed_commits: Vec<MissedBlockCommit>,
+    ) -> Result<Vec<BurnSamplePoint>, BurnchainError> {
+        // assemble the commit windows
+        let mut windowed_block_commits = vec![block_commits];
+        let mut windowed_missed_commits = vec![];
+
+        if !burnchain.is_in_prepare_phase(burn_block_height) {
+            // PoX reward-phase is active!
+            // build a map of intended sortition -> missed commit for the missed commits
+            //   discovered in this block.
+            let mut missed_commits_map: HashMap<_, Vec<_>> = HashMap::new();
+            for missed in missed_commits.iter() {
+                if let Some(commits_at_sortition) =
+                    missed_commits_map.get_mut(&missed.intended_sortition)
+                {
+                    commits_at_sortition.push(missed);
+                } else {
+                    missed_commits_map.insert(missed.intended_sortition.clone(), vec![missed]);
+                }
+            }
+
+            for blocks_back in 0..(MINING_COMMITMENT_WINDOW - 1) {
+                if burn_block_height.saturating_sub(1) < (blocks_back as u64) {
+                    debug!("Mining commitment window shortened because block height is less than window size";
+                           "block_height" => %burn_block_height.saturating_sub(1),
+                           "window_size" => %MINING_COMMITMENT_WINDOW);
+                    break;
+                }
+                let block_height = (burn_block_height.saturating_sub(1)) - (blocks_back as u64);
+                let sortition_id = match sort_handle.get_block_snapshot_by_height(block_height)? {
+                    Some(sn) => sn.sortition_id,
+                    None => break,
+                };
+                windowed_block_commits.push(SortitionDB::get_block_commits_by_block(
+                    sort_handle.sqlite(),
+                    &sortition_id,
+                )?);
+                let mut missed_commits_at_height = SortitionDB::get_missed_commits_by_intended(
+                    sort_handle.sqlite(),
+                    &sortition_id,
+                )?;
+                if let Some(missed_commit_in_block) = missed_commits_map.remove(&sortition_id) {
+                    missed_commits_at_height
+                        .extend(missed_commit_in_block.into_iter().map(|x| x.clone()));
+                }
+
+                windowed_missed_commits.push(missed_commits_at_height);
+            }
+        } else {
+            // PoX reward-phase is not active
+            debug!(
+                "Block {} is in a prepare phase or post-PoX sunset, so no windowing will take place",
+                burn_block_height;
+            );
+
+            assert_eq!(windowed_block_commits.len(), 1);
+            assert_eq!(windowed_missed_commits.len(), 0);
+        }
+
+        // reverse vecs so that windows are in ascending block height order
+        windowed_block_commits.reverse();
+        windowed_missed_commits.reverse();
+
+        // figure out if the PoX sunset finished during the window,
+        // and/or which sortitions must be PoB due to them falling in a prepare phase.
+        let window_end_height = burn_block_height;
+        let window_start_height = window_end_height + 1 - (windowed_block_commits.len() as u64);
+        let mut burn_blocks = vec![false; windowed_block_commits.len()];
+
+        // set burn_blocks flags to accomodate prepare phases and PoX sunset
+        for (i, b) in burn_blocks.iter_mut().enumerate() {
+            if burnchain.is_in_prepare_phase(window_start_height + (i as u64)) {
+                // must burn
+                *b = true;
+            } else {
+                // must not burn
+                *b = false;
+            }
+        }
+
+        // not all commits in windowed_block_commits have been confirmed, so make sure that they
+        // are in the right order
+        let mut block_height_at_index = None;
+        for (index, commits) in windowed_block_commits.iter_mut().enumerate() {
+            let index = index as u64;
+            for commit in commits.iter_mut() {
+                if let Some((first_block_height, first_index)) = block_height_at_index {
+                    if commit.block_height != first_block_height + (index - first_index) {
+                        commit.block_height = first_block_height + (index - first_index);
+                    }
+                } else {
+                    block_height_at_index = Some((commit.block_height, index));
+                }
+            }
+        }
+
+        // calculate the burn distribution from these operations.
+        // The resulting distribution will contain the user burns that match block commits
+        let burn_dist = BurnSamplePoint::make_min_median_distribution(
+            windowed_block_commits,
+            windowed_missed_commits,
+            burn_blocks,
+        );
+
+        Ok(burn_dist)
+    }
+
+    fn fmt_bin_args(bin: &str, args: &[&str]) -> String {
+        let mut all = Vec::with_capacity(1 + args.len());
+        all.push(bin);
+        for arg in args {
+            all.push(arg);
+        }
+        all.join(" ")
+    }
+
+    /// Returns (exit code, stdout, stderr)
+    fn run_subprocess(
+        bin_fullpath: &str,
+        args: &[&str],
+    ) -> Result<(i32, Vec<u8>, Vec<u8>), String> {
+        let full_args = Self::fmt_bin_args(bin_fullpath, args);
+        let mut cmd = Command::new(bin_fullpath);
+        cmd.stdin(Stdio::piped())
+            .stdout(Stdio::piped())
+            .stderr(Stdio::piped())
+            .args(args);
+
+        debug!("Run: `{:?}`", &cmd);
+
+        let output = cmd
+            .spawn()
+            .map_err(|e| format!("Failed to run `{}`: {:?}", &full_args, &e))?
+            .wait_with_output()
+            .map_err(|ioe| format!("Failed to run `{}`: {:?}", &full_args, &ioe))?;
+
+        let exit_code = match output.status.code() {
+            Some(code) => code,
+            None => {
+                // failed due to signal
+                return Err(format!("Failed to run `{}`: killed by signal", &full_args));
+            }
+        };
+
+        Ok((exit_code, output.stdout, output.stderr))
+    }
+
+    /// Get the list of all unconfirmed block-commits.
+    pub fn get_unconfirmed_commits(
+        &self,
+        next_block_height: u64,
+        all_miners: &[&str],
+    ) -> Result<Vec<LeaderBlockCommitOp>, String> {
+        let (exit_code, stdout, _stderr) =
+            Self::run_subprocess(&self.unconfirmed_commits_helper, &all_miners)?;
+        if exit_code != 0 {
+            return Err(format!(
+                "Failed to run `{}`: exit code {}",
+                &self.unconfirmed_commits_helper, exit_code
+            ));
+        }
+
+        // decode stdout to JSON
+        let unconfirmed_commits: Vec<UnconfirmedBlockCommit> = serde_json::from_slice(&stdout)
+            .map_err(|e| {
+                format!(
+                    "Failed to decode output from `{}`: {:?}. Output was `{}`",
+                    &self.unconfirmed_commits_helper,
+                    &e,
+                    String::from_utf8_lossy(&stdout)
+                )
+            })?;
+
+        let mut unconfirmed_spends = vec![];
+        for unconfirmed_commit in unconfirmed_commits.into_iter() {
+            let Ok(txid) = Txid::from_hex(&unconfirmed_commit.txid) else {
+                return Err(format!("Not a valid txid: `{}`", &unconfirmed_commit.txid));
+            };
+            let Ok(input_txid) = Txid::from_hex(&unconfirmed_commit.input_txid) else {
+                return Err(format!(
+                    "Not a valid txid: `{}`",
+                    &unconfirmed_commit.input_txid
+                ));
+            };
+            let mut decoded_pox_addrs = vec![];
+            for pox_addr_hex in unconfirmed_commit.pox_addrs.iter() {
+                let Ok(pox_addr_bytes) = hex_bytes(&pox_addr_hex) else {
+                    return Err(format!("Not a hex string: `{}`", &pox_addr_hex));
+                };
+                let Some(bitcoin_addr) =
+                    BitcoinAddress::from_scriptpubkey(BitcoinNetworkType::Mainnet, &pox_addr_bytes)
+                else {
+                    return Err(format!(
+                        "Not a recognized Bitcoin scriptpubkey: {}",
+                        &pox_addr_hex
+                    ));
+                };
+                let Some(pox_addr) = PoxAddress::try_from_bitcoin_output(&BitcoinTxOutput {
+                    address: bitcoin_addr.clone(),
+                    units: 1,
+                }) else {
+                    return Err(format!("Not a recognized PoX address: {}", &bitcoin_addr));
+                };
+                decoded_pox_addrs.push(pox_addr);
+            }
+
+            // mocked commit
+            let mocked_commit = LeaderBlockCommitOp {
+                sunset_burn: 0,
+                block_header_hash: BlockHeaderHash(DEADBEEF.clone()),
+                new_seed: VRFSeed(DEADBEEF.clone()),
+                parent_block_ptr: 1,
+                parent_vtxindex: 1,
+                key_block_ptr: 1,
+                key_vtxindex: 1,
+                memo: vec![],
+                commit_outs: decoded_pox_addrs,
+                burn_fee: unconfirmed_commit.burn,
+                input: (input_txid, unconfirmed_commit.input_index),
+                apparent_sender: BurnchainSigner(unconfirmed_commit.address),
+                txid,
+                vtxindex: 1,
+                block_height: next_block_height,
+                burn_parent_modulus: ((next_block_height.saturating_sub(1))
+                    % BURN_BLOCK_MINED_AT_MODULUS) as u8,
+                burn_header_hash: BurnchainHeaderHash(DEADBEEF.clone()),
+            };
+
+            unconfirmed_spends.push(mocked_commit);
+        }
+        Ok(unconfirmed_spends)
+    }
+
+    /// Convert a list of burn sample points into a probability distribution by candidate's
+    /// apparent sender (e.g. miner address).
+    pub fn burn_dist_to_prob_dist(burn_dist: &[BurnSamplePoint]) -> HashMap<String, f64> {
+        if burn_dist.len() == 0 {
+            return HashMap::new();
+        }
+        if burn_dist.len() == 1 {
+            let mut ret = HashMap::new();
+            ret.insert(burn_dist[0].candidate.apparent_sender.to_string(), 1.0);
+            return ret;
+        }
+
+        let mut ret = HashMap::new();
+        for pt in burn_dist.iter() {
+            // take the upper 32 bits
+            let range_lower_64 = (pt.range_end - pt.range_start) >> 192;
+            let int_prob = (range_lower_64.low_u64() >> 32) as u32;
+
+            ret.insert(
+                pt.candidate.apparent_sender.to_string(),
+                (int_prob as f64) / (u32::MAX as f64),
+            );
+        }
+
+        ret
+    }
+
+    /// Get the spend distribution and total spend.
+    /// If the miner has both a confirmed and unconfirmed spend, then take the latter.
+    pub fn get_spend_distribution(
+        active_miners_and_commits: &[(String, LeaderBlockCommitOp)],
+        unconfirmed_block_commits: &[LeaderBlockCommitOp],
+        expected_pox_addrs: &[PoxAddress],
+    ) -> (HashMap<String, u64>, u64) {
+        let unconfirmed_block_commits: Vec<_> = unconfirmed_block_commits
+            .iter()
+            .filter(|commit| {
+                if commit.commit_outs.len() != expected_pox_addrs.len() {
+                    return false;
+                }
+                for i in 0..commit.commit_outs.len() {
+                    if commit.commit_outs[i].to_burnchain_repr()
+                        != expected_pox_addrs[i].to_burnchain_repr()
+                    {
+                        info!(
+                            "Skipping invalid unconfirmed block-commit: {:?} != {:?}",
+                            &commit.commit_outs[i].to_burnchain_repr(),
+                            expected_pox_addrs[i].to_burnchain_repr()
+                        );
+                        return false;
+                    }
+                }
+                true
+            })
+            .collect();
+
+        let mut total_spend = 0;
+        let mut dist = HashMap::new();
+        for commit in unconfirmed_block_commits {
+            let addr = commit.apparent_sender.to_string();
+            dist.insert(addr, commit.burn_fee);
+        }
+
+        for (_, commit) in active_miners_and_commits.iter() {
+            let addr = commit.apparent_sender.to_string();
+            if dist.contains_key(&addr) {
+                continue;
+            }
+            dist.insert(addr, commit.burn_fee);
+        }
+
+        for (_, spend) in dist.iter() {
+            total_spend += *spend;
+        }
+
+        (dist, total_spend)
+    }
+
+    /// Get the probability distribution for the Bitcoin block 6+ blocks in the future, assuming
+    /// all block-commit spends remain the same.
+    pub fn get_future_win_distribution(
+        active_miners_and_commits: &[(String, LeaderBlockCommitOp)],
+        unconfirmed_block_commits: &[LeaderBlockCommitOp],
+        expected_pox_addrs: &[PoxAddress],
+    ) -> HashMap<String, f64> {
+        let (dist, total_spend) = Self::get_spend_distribution(
+            active_miners_and_commits,
+            unconfirmed_block_commits,
+            &expected_pox_addrs,
+        );
+
+        let mut probs = HashMap::new();
+        for (addr, spend) in dist.into_iter() {
+            if total_spend == 0 {
+                probs.insert(addr, 0.0);
+            } else {
+                probs.insert(addr, (spend as f64) / (total_spend as f64));
+            }
+        }
+        probs
+    }
+
+    /// Get the burn distribution for the _next_ Bitcoin block, assuming that the given list of
+    /// block-commit data will get mined.  For miners that are known to the system but who do not
+    /// have unconfirmed block-commits, infer that they'll just mine the same block-commit value
+    /// again.
+    pub fn get_unconfirmed_burn_distribution(
+        &self,
+        burnchain: &Burnchain,
+        sortdb: &SortitionDB,
+        active_miners_and_commits: &[(String, LeaderBlockCommitOp)],
+        unconfirmed_block_commits: Vec<LeaderBlockCommitOp>,
+        expected_pox_addrs: &[PoxAddress],
+        at_block: Option<u64>,
+    ) -> Result<Vec<BurnSamplePoint>, BurnchainError> {
+        let mut commit_table = HashMap::new();
+        for commit in unconfirmed_block_commits.iter() {
+            commit_table.insert(commit.apparent_sender.to_string(), commit.clone());
+        }
+
+        let tip = if let Some(at_block) = at_block {
+            let tip = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn())?;
+            let ih = sortdb.index_handle(&tip.sortition_id);
+            ih.get_block_snapshot_by_height(at_block)?
+                .ok_or(BurnchainError::MissingParentBlock)?
+        } else {
+            SortitionDB::get_canonical_burn_chain_tip(sortdb.conn())?
+        };
+
+        let next_block_height = tip.block_height + 1;
+        let expected_input_index = if burnchain.is_in_prepare_phase(tip.block_height) {
+            LeaderBlockCommitOp::expected_chained_utxo(true)
+        } else {
+            LeaderBlockCommitOp::expected_chained_utxo(false)
+        };
+
+        for (miner, last_commit) in active_miners_and_commits.iter() {
+            if !commit_table.contains_key(miner) {
+                let mocked_commit = LeaderBlockCommitOp {
+                    sunset_burn: 0,
+                    block_header_hash: BlockHeaderHash(DEADBEEF.clone()),
+                    new_seed: VRFSeed(DEADBEEF.clone()),
+                    parent_block_ptr: 2,
+                    parent_vtxindex: 2,
+                    key_block_ptr: 2,
+                    key_vtxindex: 2,
+                    memo: vec![],
+                    commit_outs: expected_pox_addrs.to_vec(),
+                    burn_fee: last_commit.burn_fee,
+                    input: (last_commit.txid, expected_input_index),
+                    apparent_sender: last_commit.apparent_sender.clone(),
+                    txid: Txid(DEADBEEF.clone()),
+                    vtxindex: 1,
+                    block_height: next_block_height,
+                    burn_parent_modulus: ((next_block_height.saturating_sub(1))
+                        % BURN_BLOCK_MINED_AT_MODULUS)
+                        as u8,
+                    burn_header_hash: BurnchainHeaderHash(DEADBEEF.clone()),
+                };
+                commit_table.insert(miner.to_string(), mocked_commit);
+            }
+        }
+
+        let unconfirmed_block_commits: Vec<_> = commit_table
+            .into_values()
+            .filter(|commit| {
+                if commit.commit_outs.len() != expected_pox_addrs.len() {
+                    return false;
+                }
+                for i in 0..commit.commit_outs.len() {
+                    if commit.commit_outs[i].to_burnchain_repr()
+                        != expected_pox_addrs[i].to_burnchain_repr()
+                    {
+                        info!(
+                            "Skipping invalid unconfirmed block-commit: {:?} != {:?}",
+                            &commit.commit_outs[i].to_burnchain_repr(),
+                            expected_pox_addrs[i].to_burnchain_repr()
+                        );
+                        return false;
+                    }
+                }
+                true
+            })
+            .collect();
+
+        let mut handle = sortdb.index_handle(&tip.sortition_id);
+        Self::get_burn_distribution(
+            &mut handle,
+            burnchain,
+            tip.block_height + 1,
+            unconfirmed_block_commits,
+            vec![],
+        )
+    }
+
+    /// Given the sortition DB, get the list of all miners in the past MINING_COMMITMENT_WINDOW
+    /// blocks, as well as their last block-commits
+    pub fn get_active_miners(
+        sortdb: &SortitionDB,
+        at_burn_block: Option<u64>,
+    ) -> Result<Vec<(String, LeaderBlockCommitOp)>, DBError> {
+        let mut tip = if let Some(at_burn_block) = at_burn_block {
+            let tip = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn())?;
+            let ih = sortdb.index_handle(&tip.sortition_id);
+            ih.get_block_snapshot_by_height(at_burn_block)?
+                .ok_or(DBError::NotFoundError)?
+        } else {
+            SortitionDB::get_canonical_burn_chain_tip(sortdb.conn())?
+        };
+
+        let mut miners = HashMap::new();
+        for _i in 0..MINING_COMMITMENT_WINDOW {
+            let commits =
+                SortitionDB::get_block_commits_by_block(sortdb.conn(), &tip.sortition_id)?;
+            for commit in commits.into_iter() {
+                let miner = commit.apparent_sender.to_string();
+                if miners.get(&miner).is_none() {
+                    miners.insert(miner, commit);
+                }
+            }
+            tip = SortitionDB::get_block_snapshot(sortdb.conn(), &tip.parent_sortition_id)?
+                .ok_or(DBError::NotFoundError)?;
+        }
+        Ok(miners.into_iter().collect())
+    }
+}
+
+#[cfg(test)]
+pub mod tests {
+    use super::MinerStats;
+    use stacks::burnchains::BurnchainSigner;
+    use stacks::burnchains::Txid;
+    use stacks::chainstate::burn::distribution::BurnSamplePoint;
+    use stacks::chainstate::burn::operations::leader_block_commit::BURN_BLOCK_MINED_AT_MODULUS;
+    use stacks::chainstate::burn::operations::LeaderBlockCommitOp;
+    use stacks::chainstate::stacks::address::PoxAddress;
+    use stacks::chainstate::stacks::address::PoxAddressType20;
+    use stacks_common::types::chainstate::BlockHeaderHash;
+    use stacks_common::types::chainstate::BurnchainHeaderHash;
+    use stacks_common::types::chainstate::StacksAddress;
+    use stacks_common::types::chainstate::StacksPublicKey;
+    use stacks_common::types::chainstate::VRFSeed;
+    use stacks_common::util::hash::hex_bytes;
+    use stacks_common::util::hash::Hash160;
+    use stacks_common::util::uint::BitArray;
+    use stacks_common::util::uint::Uint256;
+
+    use std::fs;
+    use std::io::Write;
+
+    #[test]
+    fn test_burn_dist_to_prob_dist() {
+        let block_commit_1 = LeaderBlockCommitOp {
+            sunset_burn: 0,
+            block_header_hash: BlockHeaderHash([0x22; 32]),
+            new_seed: VRFSeed([0x33; 32]),
+            parent_block_ptr: 111,
+            parent_vtxindex: 456,
+            key_block_ptr: 123,
+            key_vtxindex: 456,
+            memo: vec![0x80],
+
+            burn_fee: 12345,
+            input: (Txid([0; 32]), 0),
+            apparent_sender: BurnchainSigner::new_p2pkh(
+                &StacksPublicKey::from_hex(
+                    "02d8015134d9db8178ac93acbc43170a2f20febba5087a5b0437058765ad5133d0",
+                )
+                .unwrap(),
+            ),
+
+            commit_outs: vec![],
+
+            txid: Txid::from_bytes_be(
+                &hex_bytes("3c07a0a93360bc85047bbaadd49e30c8af770f73a37e10fec400174d2e5f27cf")
+                    .unwrap(),
+            )
+            .unwrap(),
+            vtxindex: 443,
+            block_height: 124,
+            burn_parent_modulus: (123 % BURN_BLOCK_MINED_AT_MODULUS) as u8,
+            burn_header_hash: BurnchainHeaderHash([0x00; 32]),
+        };
+
+        let block_commit_2 = LeaderBlockCommitOp {
+            sunset_burn: 0,
+            block_header_hash: BlockHeaderHash([0x22; 32]),
+            new_seed: VRFSeed([0x33; 32]),
+            parent_block_ptr: 112,
+            parent_vtxindex: 111,
+            key_block_ptr: 122,
+            key_vtxindex: 457,
+            memo: vec![0x80],
+
+            burn_fee: 12345,
+            input: (Txid([0; 32]), 0),
+            apparent_sender: BurnchainSigner::new_p2pkh(
+                &StacksPublicKey::from_hex(
+                    "023616a344700c9455bf0b55cc65e404c7b8f82e815da885398a44f6dc70e64045",
+                )
+                .unwrap(),
+            ),
+
+            commit_outs: vec![],
+
+            txid: Txid::from_bytes_be(
+                &hex_bytes("3c07a0a93360bc85047bbaadd49e30c8af770f73a37e10fec400174d2e5f27d0")
+                    .unwrap(),
+            )
+            .unwrap(),
+            vtxindex: 444,
+            block_height: 124,
+            burn_parent_modulus: (123 % BURN_BLOCK_MINED_AT_MODULUS) as u8,
+            burn_header_hash: BurnchainHeaderHash::from_hex(
+                "0000000000000000000000000000000000000000000000000000000000000004",
+            )
+            .unwrap(),
+        };
+
+        let block_commit_3 = LeaderBlockCommitOp {
+            sunset_burn: 0,
+            block_header_hash: BlockHeaderHash([0x22; 32]),
+            new_seed: VRFSeed([0x33; 32]),
+            parent_block_ptr: 113,
+            parent_vtxindex: 111,
+            key_block_ptr: 121,
+            key_vtxindex: 10,
+            memo: vec![0x80],
+
+            burn_fee: 23456,
+            input: (Txid([0; 32]), 0),
+            apparent_sender: BurnchainSigner::new_p2pkh(
+                &StacksPublicKey::from_hex(
+                    "020a9b0a938a2226694fe4f867193cf0b78cd6264e4277fd686468a00a9afdc36d",
+                )
+                .unwrap(),
+            ),
+
+            commit_outs: vec![],
+
+            txid: Txid::from_bytes_be(
+                &hex_bytes("301dc687a9f06a1ae87a013f27133e9cec0843c2983567be73e185827c7c13de")
+                    .unwrap(),
+            )
+            .unwrap(),
+            vtxindex: 445,
+            block_height: 124,
+            burn_parent_modulus: (123 % BURN_BLOCK_MINED_AT_MODULUS) as u8,
+            burn_header_hash: BurnchainHeaderHash::from_hex(
+                "0000000000000000000000000000000000000000000000000000000000000004",
+            )
+            .unwrap(),
+        };
+        let burn_dist = vec![
+            BurnSamplePoint {
+                burns: block_commit_1.burn_fee.into(),
+                median_burn: block_commit_2.burn_fee.into(),
+                range_start: Uint256::zero(),
+                range_end: Uint256([
+                    0x3ed94d3cb0a84709,
+                    0x0963dded799a7c1a,
+                    0x70989faf596c8b65,
+                    0x41a3ed94d3cb0a84,
+                ]),
+                candidate: block_commit_1.clone(),
+                user_burns: vec![],
+            },
+            BurnSamplePoint {
+                burns: block_commit_2.burn_fee.into(),
+                median_burn: block_commit_2.burn_fee.into(),
+                range_start: Uint256([
+                    0x3ed94d3cb0a84709,
+                    0x0963dded799a7c1a,
+                    0x70989faf596c8b65,
+                    0x41a3ed94d3cb0a84,
+                ]),
+                range_end: Uint256([
+                    0x7db29a7961508e12,
+                    0x12c7bbdaf334f834,
+                    0xe1313f5eb2d916ca,
+                    0x8347db29a7961508,
+                ]),
+                candidate: block_commit_2.clone(),
+                user_burns: vec![],
+            },
+            BurnSamplePoint {
+                burns: (block_commit_3.burn_fee).into(),
+                median_burn: block_commit_3.burn_fee.into(),
+                range_start: Uint256([
+                    0x7db29a7961508e12,
+                    0x12c7bbdaf334f834,
+                    0xe1313f5eb2d916ca,
+                    0x8347db29a7961508,
+                ]),
+                range_end: Uint256::max(),
+                candidate: block_commit_3.clone(),
+                user_burns: vec![],
+            },
+        ];
+
+        let prob_dist = MinerStats::burn_dist_to_prob_dist(&burn_dist);
+        assert_eq!(prob_dist.len(), 3);
+        assert!(
+            (prob_dist
+                .get(&format!("{}", &block_commit_1.apparent_sender))
+                .unwrap()
+                - 0.25641)
+                .abs()
+                < 0.001
+        );
+        assert!(
+            (prob_dist
+                .get(&format!("{}", &block_commit_2.apparent_sender))
+                .unwrap()
+                - 0.25641)
+                .abs()
+                < 0.001
+        );
+        assert!(
+            (prob_dist
+                .get(&format!("{}", &block_commit_3.apparent_sender))
+                .unwrap()
+                - 0.48718)
+                .abs()
+                < 0.001
+        );
+    }
+
+    #[test]
+    fn test_get_unconfirmed_commits() {
+        use std::os::unix::fs::PermissionsExt;
+        let shell_code = r#"#!/bin/bash
+echo <<EOF '[
+ {
+  "txid": "73c318be8cd272a73200b9630089d77a44342d84b2c0d81c937da714152cf402",
+  "burn": 555000,
+  "address": "1FCcoFSKWvNyhjazNvVdLLw8mGkGdcRMux",
+  "input_txid": "ef0dbf0fc4755de5e94843a4da7c1d943571299afb15f32b76bac5d18d8668ce",
+  "input_index": 3,
+  "pox_addrs": [
+      "0014db14133a9dbb1d0e16b60513453e48b6ff2847a9",
+      "a91418c42080a1e87fd02dd3fca94c4513f9ecfe741487"
+  ]
+ }
+]'
+EOF
+"#;
+        let path = "/tmp/test-get-unconfirmed-commits.sh";
+        if fs::metadata(&path).is_ok() {
+            fs::remove_file(&path).unwrap();
+        }
+        {
+            let mut f = fs::File::create(&path).unwrap();
+            f.write_all(shell_code.as_bytes()).unwrap();
+
+            let md = f.metadata().unwrap();
+            let mut permissions = md.permissions();
+            permissions.set_mode(0o744);
+
+            fs::set_permissions(path, permissions).unwrap();
+            f.sync_all().unwrap();
+        }
+
+        let ms = MinerStats {
+            unconfirmed_commits_helper: path.to_string(),
+        };
+
+        let mut commits = ms.get_unconfirmed_commits(123, &[]).unwrap();
+        assert_eq!(commits.len(), 1);
+        let commit = commits.pop().unwrap();
+
+        assert_eq!(
+            commit.txid,
+            Txid::from_hex("73c318be8cd272a73200b9630089d77a44342d84b2c0d81c937da714152cf402")
+                .unwrap()
+        );
+        assert_eq!(commit.burn_fee, 555000);
+        assert_eq!(
+            commit.apparent_sender.0,
+            "1FCcoFSKWvNyhjazNvVdLLw8mGkGdcRMux".to_string()
+        );
+        assert_eq!(
+            commit.input.0,
+            Txid::from_hex("ef0dbf0fc4755de5e94843a4da7c1d943571299afb15f32b76bac5d18d8668ce")
+                .unwrap()
+        );
+        assert_eq!(commit.input.1, 3);
+        assert_eq!(commit.block_height, 123);
+
+        assert_eq!(
+            commit.commit_outs,
+            vec![
+                PoxAddress::Addr20(
+                    true,
+                    PoxAddressType20::P2WPKH,
+                    [
+                        219, 20, 19, 58, 157, 187, 29, 14, 22, 182, 5, 19, 69, 62, 72, 182, 255,
+                        40, 71, 169
+                    ]
+                ),
+                PoxAddress::Standard(
+                    StacksAddress {
+                        version: 20,
+                        bytes: Hash160([
+                            0x18, 0xc4, 0x20, 0x80, 0xa1, 0xe8, 0x7f, 0xd0, 0x2d, 0xd3, 0xfc, 0xa9,
+                            0x4c, 0x45, 0x13, 0xf9, 0xec, 0xfe, 0x74, 0x14
+                        ])
+                    },
+                    None
+                )
+            ]
+        );
+    }
+
+    #[test]
+    fn test_get_spend_and_win_distribution() {
+        let active_miners_and_commits = vec![
+            (
+                "miner-1".to_string(),
+                LeaderBlockCommitOp {
+                    sunset_burn: 0,
+                    block_header_hash: BlockHeaderHash([0x22; 32]),
+                    new_seed: VRFSeed([0x33; 32]),
+                    parent_block_ptr: 111,
+                    parent_vtxindex: 456,
+                    key_block_ptr: 123,
+                    key_vtxindex: 456,
+                    memo: vec![0x80],
+
+                    burn_fee: 2,
+                    input: (Txid([0; 32]), 0),
+                    apparent_sender: BurnchainSigner("miner-1".into()),
+
+                    commit_outs: vec![],
+
+                    txid: Txid::from_bytes_be(
+                        &hex_bytes(
+                            "3c07a0a93360bc85047bbaadd49e30c8af770f73a37e10fec400174d2e5f27cf",
+                        )
+                        .unwrap(),
+                    )
+                    .unwrap(),
+                    vtxindex: 443,
+                    block_height: 124,
+                    burn_parent_modulus: (123 % BURN_BLOCK_MINED_AT_MODULUS) as u8,
+                    burn_header_hash: BurnchainHeaderHash([0x00; 32]),
+                },
+            ),
+            (
+                "miner-2".to_string(),
+                LeaderBlockCommitOp {
+                    sunset_burn: 0,
+                    block_header_hash: BlockHeaderHash([0x22; 32]),
+                    new_seed: VRFSeed([0x33; 32]),
+                    parent_block_ptr: 112,
+                    parent_vtxindex: 111,
+                    key_block_ptr: 122,
+                    key_vtxindex: 457,
+                    memo: vec![0x80],
+
+                    burn_fee: 3,
+                    input: (Txid([0; 32]), 0),
+                    apparent_sender: BurnchainSigner("miner-2".into()),
+
+                    commit_outs: vec![],
+
+                    txid: Txid::from_bytes_be(
+                        &hex_bytes(
+                            "3c07a0a93360bc85047bbaadd49e30c8af770f73a37e10fec400174d2e5f27d0",
+                        )
+                        .unwrap(),
+                    )
+                    .unwrap(),
+                    vtxindex: 444,
+                    block_height: 124,
+                    burn_parent_modulus: (123 % BURN_BLOCK_MINED_AT_MODULUS) as u8,
+                    burn_header_hash: BurnchainHeaderHash::from_hex(
+                        "0000000000000000000000000000000000000000000000000000000000000004",
+                    )
+                    .unwrap(),
+                },
+            ),
+            (
+                "miner-3".to_string(),
+                LeaderBlockCommitOp {
+                    sunset_burn: 0,
+                    block_header_hash: BlockHeaderHash([0x22; 32]),
+                    new_seed: VRFSeed([0x33; 32]),
+                    parent_block_ptr: 113,
+                    parent_vtxindex: 111,
+                    key_block_ptr: 121,
+                    key_vtxindex: 10,
+                    memo: vec![0x80],
+
+                    burn_fee: 5,
+                    input: (Txid([0; 32]), 0),
+                    apparent_sender: BurnchainSigner("miner-3".into()),
+                    commit_outs: vec![],
+
+                    txid: Txid::from_bytes_be(
+                        &hex_bytes(
+                            "301dc687a9f06a1ae87a013f27133e9cec0843c2983567be73e185827c7c13de",
+                        )
+                        .unwrap(),
+                    )
+                    .unwrap(),
+                    vtxindex: 445,
+                    block_height: 124,
+                    burn_parent_modulus: (123 % BURN_BLOCK_MINED_AT_MODULUS) as u8,
+                    burn_header_hash: BurnchainHeaderHash::from_hex(
+                        "0000000000000000000000000000000000000000000000000000000000000004",
+                    )
+                    .unwrap(),
+                },
+            ),
+        ];
+
+        let unconfirmed_block_commits = vec![
+            LeaderBlockCommitOp {
+                sunset_burn: 0,
+                block_header_hash: BlockHeaderHash([0x22; 32]),
+                new_seed: VRFSeed([0x33; 32]),
+                parent_block_ptr: 124,
+                parent_vtxindex: 456,
+                key_block_ptr: 123,
+                key_vtxindex: 456,
+                memo: vec![0x80],
+
+                burn_fee: 2,
+                input: (Txid([0; 32]), 0),
+                apparent_sender: BurnchainSigner("miner-1".into()),
+
+                commit_outs: vec![],
+
+                txid: Txid::from_bytes_be(
+                    &hex_bytes("3c07a0a93360bc85047bbaadd49e30c8af770f73a37e10fec400174d2e5f27cf")
+                        .unwrap(),
+                )
+                .unwrap(),
+                vtxindex: 443,
+                block_height: 125,
+                burn_parent_modulus: (124 % BURN_BLOCK_MINED_AT_MODULUS) as u8,
+                burn_header_hash: BurnchainHeaderHash([0x01; 32]),
+            },
+            LeaderBlockCommitOp {
+                sunset_burn: 0,
+                block_header_hash: BlockHeaderHash([0x22; 32]),
+                new_seed: VRFSeed([0x33; 32]),
+                parent_block_ptr: 124,
+                parent_vtxindex: 444,
+                key_block_ptr: 123,
+                key_vtxindex: 456,
+                memo: vec![0x80],
+
+                burn_fee: 3,
+                input: (Txid([0; 32]), 0),
+                apparent_sender: BurnchainSigner("miner-2".into()),
+
+                commit_outs: vec![],
+
+                txid: Txid::from_bytes_be(
+                    &hex_bytes("3c07a0a93360bc85047bbaadd49e30c8af770f73a37e10fec400174d2e5f27cf")
+                        .unwrap(),
+                )
+                .unwrap(),
+                vtxindex: 444,
+                block_height: 125,
+                burn_parent_modulus: (124 % BURN_BLOCK_MINED_AT_MODULUS) as u8,
+                burn_header_hash: BurnchainHeaderHash([0x01; 32]),
+            },
+            LeaderBlockCommitOp {
+                sunset_burn: 0,
+                block_header_hash: BlockHeaderHash([0x22; 32]),
+                new_seed: VRFSeed([0x33; 32]),
+                parent_block_ptr: 124,
+                parent_vtxindex: 445,
+                key_block_ptr: 123,
+                key_vtxindex: 456,
+                memo: vec![0x80],
+
+                burn_fee: 10,
+                input: (Txid([0; 32]), 0),
+                apparent_sender: BurnchainSigner("miner-3".into()),
+
+                commit_outs: vec![],
+
+                txid: Txid::from_bytes_be(
+                    &hex_bytes("3c07a0a93360bc85047bbaadd49e30c8af770f73a37e10fec400174d2e5f27cf")
+                        .unwrap(),
+                )
+                .unwrap(),
+                vtxindex: 445,
+                block_height: 125,
+                burn_parent_modulus: (124 % BURN_BLOCK_MINED_AT_MODULUS) as u8,
+                burn_header_hash: BurnchainHeaderHash([0x01; 32]),
+            },
+            LeaderBlockCommitOp {
+                sunset_burn: 0,
+                block_header_hash: BlockHeaderHash([0x22; 32]),
+                new_seed: VRFSeed([0x33; 32]),
+                parent_block_ptr: 124,
+                parent_vtxindex: 445,
+                key_block_ptr: 123,
+                key_vtxindex: 456,
+                memo: vec![0x80],
+
+                burn_fee: 10,
+                input: (Txid([0; 32]), 0),
+                apparent_sender: BurnchainSigner("miner-4".into()),
+
+                commit_outs: vec![],
+
+                txid: Txid::from_bytes_be(
+                    &hex_bytes("3c07a0a93360bc85047bbaadd49e30c8af770f73a37e10fec400174d2e5f27cf")
+                        .unwrap(),
+                )
+                .unwrap(),
+                vtxindex: 446,
+                block_height: 125,
+                burn_parent_modulus: (124 % BURN_BLOCK_MINED_AT_MODULUS) as u8,
+                burn_header_hash: BurnchainHeaderHash([0x01; 32]),
+            },
+        ];
+
+        let (spend_dist, total_spend) = MinerStats::get_spend_distribution(
+            &active_miners_and_commits,
+            &unconfirmed_block_commits,
+            &[],
+        );
+        assert_eq!(total_spend, 2 + 3 + 10 + 10);
+
+        assert_eq!(spend_dist.len(), 4);
+        for miner in &[
+            "miner-1".to_string(),
+            "miner-2".to_string(),
+            "miner-3".to_string(),
+            "miner-4".to_string(),
+        ] {
+            let spend = *spend_dist
+                .get(miner)
+                .expect(&format!("no spend for {}", &miner));
+            match miner.as_str() {
+                "miner-1" => {
+                    assert_eq!(spend, 2);
+                }
+                "miner-2" => {
+                    assert_eq!(spend, 3);
+                }
+                "miner-3" => {
+                    assert_eq!(spend, 10);
+                }
+                "miner-4" => {
+                    assert_eq!(spend, 10);
+                }
+                _ => {
+                    panic!("unknown miner {}", &miner);
+                }
+            }
+        }
+
+        let win_probs = MinerStats::get_future_win_distribution(
+            &active_miners_and_commits,
+            &unconfirmed_block_commits,
+            &[],
+        );
+        for miner in &[
+            "miner-1".to_string(),
+            "miner-2".to_string(),
+            "miner-3".to_string(),
+            "miner-4".to_string(),
+        ] {
+            let prob = *win_probs
+                .get(miner)
+                .expect(&format!("no probability for {}", &miner));
+            match miner.as_str() {
+                "miner-1" => {
+                    assert!((prob - (2.0 / 25.0)).abs() < 0.00001);
+                }
+                "miner-2" => {
+                    assert!((prob - (3.0 / 25.0)).abs() < 0.00001);
+                }
+                "miner-3" => {
+                    assert!((prob - (10.0 / 25.0)).abs() < 0.00001);
+                }
+                "miner-4" => {
+                    assert!((prob - (10.0 / 25.0)).abs() < 0.00001);
+                }
+                _ => {
+                    panic!("unknown miner {}", &miner);
+                }
+            }
+        }
+    }
+}
diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index c7b47f2aad..0004b5bce2 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -1,45 +1,42 @@
+use std::collections::HashSet;
 use std::convert::TryInto;
 use std::fs;
 use std::net::{SocketAddr, ToSocketAddrs};
 use std::path::PathBuf;
-use std::sync::Arc;
-use std::sync::Mutex;
+use std::sync::{Arc, Mutex};
 
 use rand::RngCore;
-
 use stacks::burnchains::bitcoin::BitcoinNetworkType;
-use stacks::burnchains::Burnchain;
-use stacks::burnchains::{MagicBytes, BLOCKSTACK_MAGIC_MAINNET};
+use stacks::burnchains::{Burnchain, MagicBytes, BLOCKSTACK_MAGIC_MAINNET};
 use stacks::chainstate::stacks::index::marf::MARFOpenOpts;
 use stacks::chainstate::stacks::index::storage::TrieHashCalculationMode;
-use stacks::chainstate::stacks::miner::BlockBuilderSettings;
-use stacks::chainstate::stacks::miner::MinerStatus;
+use stacks::chainstate::stacks::miner::{BlockBuilderSettings, MinerStatus};
 use stacks::chainstate::stacks::MAX_BLOCK_LEN;
 use stacks::core::mempool::MemPoolWalkSettings;
-use stacks::core::StacksEpoch;
-use stacks::core::StacksEpochExtension;
-use stacks::core::StacksEpochId;
+use stacks::core::mempool::MemPoolWalkTxTypes;
 use stacks::core::{
-    CHAIN_ID_MAINNET, CHAIN_ID_TESTNET, PEER_VERSION_MAINNET, PEER_VERSION_TESTNET,
+    StacksEpoch, StacksEpochExtension, StacksEpochId, CHAIN_ID_MAINNET, CHAIN_ID_TESTNET,
+    PEER_VERSION_MAINNET, PEER_VERSION_TESTNET,
 };
 use stacks::cost_estimates::fee_medians::WeightedMedianFeeRateEstimator;
 use stacks::cost_estimates::fee_rate_fuzzer::FeeRateFuzzer;
 use stacks::cost_estimates::fee_scalar::ScalarFeeRateEstimator;
-use stacks::cost_estimates::metrics::CostMetric;
-use stacks::cost_estimates::metrics::ProportionalDotProduct;
-use stacks::cost_estimates::CostEstimator;
-use stacks::cost_estimates::FeeEstimator;
-use stacks::cost_estimates::PessimisticEstimator;
+use stacks::cost_estimates::metrics::{CostMetric, ProportionalDotProduct};
+use stacks::cost_estimates::{CostEstimator, FeeEstimator, PessimisticEstimator};
 use stacks::net::connection::ConnectionOptions;
 use stacks::net::{Neighbor, NeighborKey, PeerAddress};
 use stacks::util::get_epoch_time_ms;
 use stacks::util::hash::hex_bytes;
-use stacks::util::secp256k1::Secp256k1PrivateKey;
-use stacks::util::secp256k1::Secp256k1PublicKey;
+use stacks::util::secp256k1::{Secp256k1PrivateKey, Secp256k1PublicKey};
 use stacks::vm::costs::ExecutionCost;
 use stacks::vm::types::{AssetIdentifier, PrincipalData, QualifiedContractIdentifier};
 
-const DEFAULT_SATS_PER_VB: u64 = 50;
+use stacks_common::types::chainstate::StacksAddress;
+use stacks_common::types::Address;
+
+use crate::chain_data::MinerStats;
+
+pub const DEFAULT_SATS_PER_VB: u64 = 50;
 const DEFAULT_MAX_RBF_RATE: u64 = 150; // 1.5x
 const DEFAULT_RBF_FEE_RATE_INCREMENT: u64 = 5;
 const LEADER_KEY_TX_ESTIM_SIZE: u64 = 290;
@@ -48,6 +45,7 @@ const INV_REWARD_CYCLES_TESTNET: u64 = 6;
 
 #[derive(Clone, Deserialize, Default, Debug)]
 pub struct ConfigFile {
+    pub __path: Option<String>, // Only used for config file reloads
     pub burnchain: Option<BurnchainConfigFile>,
     pub node: Option<NodeConfigFile>,
     pub ustx_balance: Option<Vec<InitialBalanceFile>>,
@@ -178,7 +176,9 @@ mod tests {
 impl ConfigFile {
     pub fn from_path(path: &str) -> Result<ConfigFile, String> {
         let content = fs::read_to_string(path).map_err(|e| format!("Invalid path: {}", &e))?;
-        Self::from_str(&content)
+        let mut f = Self::from_str(&content)?;
+        f.__path = Some(path.to_string());
+        Ok(f)
     }
 
     pub fn from_str(content: &str) -> Result<ConfigFile, String> {
@@ -353,6 +353,7 @@ impl ConfigFile {
 
 #[derive(Clone, Debug)]
 pub struct Config {
+    pub config_path: Option<String>,
     pub burnchain: BurnchainConfig,
     pub node: NodeConfig,
     pub initial_balances: Vec<InitialBalance>,
@@ -394,6 +395,36 @@ lazy_static! {
 }
 
 impl Config {
+    /// get the up-to-date burnchain options from the config.
+    /// If the config file can't be loaded, then return the existing config
+    pub fn get_burnchain_config(&self) -> BurnchainConfig {
+        let Some(path) = &self.config_path else {
+            return self.burnchain.clone();
+        };
+        let Ok(config_file) = ConfigFile::from_path(path.as_str()) else {
+            return self.burnchain.clone();
+        };
+        let Ok(config) = Config::from_config_file(config_file) else {
+            return self.burnchain.clone();
+        };
+        config.burnchain
+    }
+
+    /// get the up-to-date miner options from the config
+    /// If the config can't be loaded for some reason, then return the existing config
+    pub fn get_miner_config(&self) -> MinerConfig {
+        let Some(path) = &self.config_path else {
+            return self.miner.clone();
+        };
+        let Ok(config_file) = ConfigFile::from_path(path.as_str()) else {
+            return self.miner.clone();
+        };
+        let Ok(config) = Config::from_config_file(config_file) else {
+            return self.miner.clone();
+        };
+        return config.miner;
+    }
+
     /// Apply any test settings to this burnchain config struct
     fn apply_test_settings(&self, burnchain: &mut Burnchain) {
         if self.burnchain.get_bitcoin_network().1 == BitcoinNetworkType::Mainnet {
@@ -881,7 +912,6 @@ impl Config {
         let miner_default_config = MinerConfig::default();
         let miner = match config_file.miner {
             Some(ref miner) => MinerConfig {
-                min_tx_fee: miner.min_tx_fee.unwrap_or(miner_default_config.min_tx_fee),
                 first_attempt_time_ms: miner
                     .first_attempt_time_ms
                     .unwrap_or(miner_default_config.first_attempt_time_ms),
@@ -909,6 +939,52 @@ impl Config {
                 unprocessed_block_deadline_secs: miner
                     .unprocessed_block_deadline_secs
                     .unwrap_or(miner_default_config.unprocessed_block_deadline_secs),
+                min_tx_count: miner.min_tx_count.unwrap_or(0),
+                only_increase_tx_count: miner.only_increase_tx_count.unwrap_or(false),
+                unconfirmed_commits_helper: miner.unconfirmed_commits_helper.clone(),
+                target_win_probability: miner.target_win_probability.unwrap_or(0.0),
+                activated_vrf_key_path: miner.activated_vrf_key_path.clone(),
+                fast_rampup: miner.fast_rampup.unwrap_or(true),
+                underperform_stop_threshold: miner.underperform_stop_threshold,
+                txs_to_consider: {
+                    if let Some(txs_to_consider) = &miner.txs_to_consider {
+                        txs_to_consider
+                            .split(",")
+                            .map(
+                                |txs_to_consider_str| match str::parse(txs_to_consider_str) {
+                                    Ok(txtype) => txtype,
+                                    Err(e) => {
+                                        panic!(
+                                            "could not parse '{}': {}",
+                                            &txs_to_consider_str, &e
+                                        );
+                                    }
+                                },
+                            )
+                            .collect()
+                    } else {
+                        MemPoolWalkTxTypes::all()
+                    }
+                },
+                filter_origins: {
+                    if let Some(filter_origins) = &miner.filter_origins {
+                        filter_origins
+                            .split(",")
+                            .map(|origin_str| match StacksAddress::from_string(origin_str) {
+                                Some(addr) => addr,
+                                None => {
+                                    panic!(
+                                        "could not parse '{}' into a Stacks address",
+                                        origin_str
+                                    );
+                                }
+                            })
+                            .collect()
+                    } else {
+                        HashSet::new()
+                    }
+                },
+                max_reorg_depth: miner.max_reorg_depth.unwrap_or(3),
             },
             None => miner_default_config,
         };
@@ -1148,6 +1224,7 @@ impl Config {
         };
 
         Ok(Config {
+            config_path: config_file.__path,
             node,
             burnchain,
             initial_balances,
@@ -1263,34 +1340,47 @@ impl Config {
         microblocks: bool,
         miner_status: Arc<Mutex<MinerStatus>>,
     ) -> BlockBuilderSettings {
+        let miner_config = self.get_miner_config();
         BlockBuilderSettings {
             max_miner_time_ms: if microblocks {
-                self.miner.microblock_attempt_time_ms
+                miner_config.microblock_attempt_time_ms
             } else if attempt <= 1 {
                 // first attempt to mine a block -- do so right away
-                self.miner.first_attempt_time_ms
+                miner_config.first_attempt_time_ms
             } else {
                 // second or later attempt to mine a block -- give it some time
-                self.miner.subsequent_attempt_time_ms
+                miner_config.subsequent_attempt_time_ms
             },
             mempool_settings: MemPoolWalkSettings {
-                min_tx_fee: self.miner.min_tx_fee,
                 max_walk_time_ms: if microblocks {
-                    self.miner.microblock_attempt_time_ms
+                    miner_config.microblock_attempt_time_ms
                 } else if attempt <= 1 {
                     // first attempt to mine a block -- do so right away
-                    self.miner.first_attempt_time_ms
+                    miner_config.first_attempt_time_ms
                 } else {
                     // second or later attempt to mine a block -- give it some time
-                    self.miner.subsequent_attempt_time_ms
+                    miner_config.subsequent_attempt_time_ms
                 },
-                consider_no_estimate_tx_prob: self.miner.probability_pick_no_estimate_tx,
-                nonce_cache_size: self.miner.nonce_cache_size,
-                candidate_retry_cache_size: self.miner.candidate_retry_cache_size,
+                consider_no_estimate_tx_prob: miner_config.probability_pick_no_estimate_tx,
+                nonce_cache_size: miner_config.nonce_cache_size,
+                candidate_retry_cache_size: miner_config.candidate_retry_cache_size,
+                txs_to_consider: miner_config.txs_to_consider,
+                filter_origins: miner_config.filter_origins,
             },
             miner_status,
         }
     }
+
+    pub fn get_miner_stats(&self) -> Option<MinerStats> {
+        let miner_config = self.get_miner_config();
+        if let Some(unconfirmed_commits_helper) = miner_config.unconfirmed_commits_helper.as_ref() {
+            let miner_stats = MinerStats {
+                unconfirmed_commits_helper: unconfirmed_commits_helper.clone(),
+            };
+            return Some(miner_stats);
+        }
+        None
+    }
 }
 
 impl std::default::Default for Config {
@@ -1308,6 +1398,7 @@ impl std::default::Default for Config {
         let estimation = FeeEstimationConfig::default();
 
         Config {
+            config_path: None,
             burnchain,
             node,
             initial_balances: vec![],
@@ -1874,9 +1965,8 @@ impl NodeConfig {
     }
 }
 
-#[derive(Clone, Debug, Default)]
+#[derive(Clone, Debug, Default, PartialEq)]
 pub struct MinerConfig {
-    pub min_tx_fee: u64,
     pub first_attempt_time_ms: u64,
     pub subsequent_attempt_time_ms: u64,
     pub microblock_attempt_time_ms: u64,
@@ -1890,22 +1980,58 @@ pub struct MinerConfig {
     pub nonce_cache_size: u64,
     pub candidate_retry_cache_size: u64,
     pub unprocessed_block_deadline_secs: u64,
+    /// minimum number of transactions that must be in a block if we're going to replace a pending
+    /// block-commit with a new block-commit
+    pub min_tx_count: u64,
+    /// Only allow a block's tx count to increase across RBFs.
+    pub only_increase_tx_count: bool,
+    /// Path to a script that prints out all unconfirmed block-commits for a list of addresses
+    pub unconfirmed_commits_helper: Option<String>,
+    /// Targeted win probability for this miner.  Used to deduce when to stop trying to mine.
+    pub target_win_probability: f64,
+    /// Path to a serialized RegisteredKey struct, which points to an already-registered VRF key
+    /// (so we don't have to go make a new one)
+    pub activated_vrf_key_path: Option<String>,
+    /// When estimating win probability, whether or not to use the assumed win rate 6+ blocks from
+    /// now (true), or the current win rate (false)
+    pub fast_rampup: bool,
+    /// Number of Bitcoin blocks which must pass where the boostes+neutrals are a minority, at which
+    /// point the miner will stop trying.
+    pub underperform_stop_threshold: Option<u64>,
+    /// Kinds of transactions to consider from the mempool.  This is used by boosted and neutral
+    /// miners to push past averse fee estimations.
+    pub txs_to_consider: HashSet<MemPoolWalkTxTypes>,
+    /// Origin addresses to whitelist when doing a mempool walk.  This is used by boosted and
+    /// neutral miners to push transactions through that are important to them.
+    pub filter_origins: HashSet<StacksAddress>,
+    /// When selecting the "nicest" tip, do not consider tips that are more than this many blocks
+    /// behind the highest tip.
+    pub max_reorg_depth: u64,
 }
 
 impl MinerConfig {
     pub fn default() -> MinerConfig {
         MinerConfig {
-            min_tx_fee: 1,
-            first_attempt_time_ms: 5_000,
-            subsequent_attempt_time_ms: 30_000,
+            first_attempt_time_ms: 10,
+            subsequent_attempt_time_ms: 120_000,
             microblock_attempt_time_ms: 30_000,
-            probability_pick_no_estimate_tx: 5,
+            probability_pick_no_estimate_tx: 25,
             block_reward_recipient: None,
             segwit: false,
             wait_for_block_download: true,
-            nonce_cache_size: 10_000,
-            candidate_retry_cache_size: 10_000,
+            nonce_cache_size: 1024 * 1024,
+            candidate_retry_cache_size: 1024 * 1024,
             unprocessed_block_deadline_secs: 30,
+            min_tx_count: 0,
+            only_increase_tx_count: false,
+            unconfirmed_commits_helper: None,
+            target_win_probability: 0.0,
+            activated_vrf_key_path: None,
+            fast_rampup: false,
+            underperform_stop_threshold: None,
+            txs_to_consider: MemPoolWalkTxTypes::all(),
+            filter_origins: HashSet::new(),
+            max_reorg_depth: 3,
         }
     }
 }
@@ -2012,7 +2138,6 @@ impl Default for FeeEstimationConfigFile {
 
 #[derive(Clone, Deserialize, Default, Debug)]
 pub struct MinerConfigFile {
-    pub min_tx_fee: Option<u64>,
     pub first_attempt_time_ms: Option<u64>,
     pub subsequent_attempt_time_ms: Option<u64>,
     pub microblock_attempt_time_ms: Option<u64>,
@@ -2022,6 +2147,16 @@ pub struct MinerConfigFile {
     pub nonce_cache_size: Option<u64>,
     pub candidate_retry_cache_size: Option<u64>,
     pub unprocessed_block_deadline_secs: Option<u64>,
+    pub min_tx_count: Option<u64>,
+    pub only_increase_tx_count: Option<bool>,
+    pub unconfirmed_commits_helper: Option<String>,
+    pub target_win_probability: Option<f64>,
+    pub activated_vrf_key_path: Option<String>,
+    pub fast_rampup: Option<bool>,
+    pub underperform_stop_threshold: Option<u64>,
+    pub txs_to_consider: Option<String>,
+    pub filter_origins: Option<String>,
+    pub max_reorg_depth: Option<u64>,
 }
 
 #[derive(Clone, Deserialize, Default, Debug)]
diff --git a/testnet/stacks-node/src/main.rs b/testnet/stacks-node/src/main.rs
index 3d904a2116..0c8b8ca9dd 100644
--- a/testnet/stacks-node/src/main.rs
+++ b/testnet/stacks-node/src/main.rs
@@ -23,6 +23,7 @@ use stacks::util::hash::hex_bytes;
 pub mod monitoring;
 
 pub mod burnchains;
+pub mod chain_data;
 pub mod config;
 pub mod event_dispatcher;
 pub mod genesis_data;
@@ -34,6 +35,8 @@ pub mod run_loop;
 pub mod syncctl;
 pub mod tenure;
 
+use std::collections::HashMap;
+
 pub use self::burnchains::{
     BitcoinRegtestController, BurnchainController, BurnchainTip, MocknetController,
 };
@@ -44,6 +47,18 @@ pub use self::node::{ChainTip, Node};
 pub use self::run_loop::{helium, neon};
 pub use self::tenure::Tenure;
 
+use crate::neon_node::BlockMinerThread;
+
+use stacks::chainstate::burn::db::sortdb::SortitionDB;
+use stacks::chainstate::burn::operations::leader_block_commit::RewardSetInfo;
+use stacks::chainstate::coordinator::get_next_recipients;
+use stacks::chainstate::coordinator::OnChainRewardSetProvider;
+use stacks::chainstate::stacks::address::PoxAddress;
+use stacks::chainstate::stacks::db::StacksChainState;
+
+use crate::chain_data::MinerStats;
+use crate::neon_node::TipCandidate;
+
 use pico_args::Arguments;
 use std::env;
 
@@ -53,6 +68,210 @@ use std::process;
 
 use backtrace::Backtrace;
 
+/// Implmentation of `pick_best_tip` CLI option
+fn cli_pick_best_tip(config_path: &str, at_stacks_height: Option<u64>) -> TipCandidate {
+    info!("Loading config at path {}", config_path);
+    let config = match ConfigFile::from_path(config_path) {
+        Ok(config_file) => Config::from_config_file(config_file).unwrap(),
+        Err(e) => {
+            warn!("Invalid config file: {}", e);
+            process::exit(1);
+        }
+    };
+    let burn_db_path = config.get_burn_db_file_path();
+    let stacks_chainstate_path = config.get_chainstate_path_str();
+    let burnchain = config.get_burnchain();
+    let (mut chainstate, _) = StacksChainState::open(
+        config.is_mainnet(),
+        config.burnchain.chain_id,
+        &stacks_chainstate_path,
+        Some(config.node.get_marf_opts()),
+    )
+    .unwrap();
+    let mut sortdb =
+        SortitionDB::open(&burn_db_path, false, burnchain.pox_constants.clone()).unwrap();
+
+    let max_depth = config.miner.max_reorg_depth;
+
+    // There could be more than one possible chain tip. Go find them.
+    let stacks_tips = BlockMinerThread::load_candidate_tips(
+        &mut sortdb,
+        &mut chainstate,
+        max_depth,
+        at_stacks_height,
+    );
+
+    let best_tip = BlockMinerThread::inner_pick_best_tip(stacks_tips, HashMap::new()).unwrap();
+    best_tip
+}
+
+/// Implementation of `get_miner_spend` CLI option
+fn cli_get_miner_spend(
+    config_path: &str,
+    mine_start: Option<u64>,
+    at_burnchain_height: Option<u64>,
+) -> u64 {
+    info!("Loading config at path {}", config_path);
+    let config = match ConfigFile::from_path(&config_path) {
+        Ok(config_file) => Config::from_config_file(config_file).unwrap(),
+        Err(e) => {
+            warn!("Invalid config file: {}", e);
+            process::exit(1);
+        }
+    };
+    let keychain = Keychain::default(config.node.seed.clone());
+    let burn_db_path = config.get_burn_db_file_path();
+    let stacks_chainstate_path = config.get_chainstate_path_str();
+    let burnchain = config.get_burnchain();
+    let (mut chainstate, _) = StacksChainState::open(
+        config.is_mainnet(),
+        config.burnchain.chain_id,
+        &stacks_chainstate_path,
+        Some(config.node.get_marf_opts()),
+    )
+    .unwrap();
+    let mut sortdb =
+        SortitionDB::open(&burn_db_path, true, burnchain.pox_constants.clone()).unwrap();
+    let tip = if let Some(at_burnchain_height) = at_burnchain_height {
+        let tip = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn()).unwrap();
+        let ih = sortdb.index_handle(&tip.sortition_id);
+        ih.get_block_snapshot_by_height(at_burnchain_height)
+            .unwrap()
+            .unwrap()
+    } else {
+        SortitionDB::get_canonical_burn_chain_tip(sortdb.conn()).unwrap()
+    };
+
+    let recipients = get_next_recipients(
+        &tip,
+        &mut chainstate,
+        &mut sortdb,
+        &burnchain,
+        &OnChainRewardSetProvider(),
+        config.node.always_use_affirmation_maps,
+    )
+    .unwrap();
+
+    let commit_outs = if !burnchain.is_in_prepare_phase(tip.block_height + 1) {
+        RewardSetInfo::into_commit_outs(recipients, config.is_mainnet())
+    } else {
+        vec![PoxAddress::standard_burn_address(config.is_mainnet())]
+    };
+
+    let spend_amount = BlockMinerThread::get_mining_spend_amount(
+        &config,
+        &keychain,
+        &burnchain,
+        &mut sortdb,
+        &commit_outs,
+        mine_start.unwrap_or(tip.block_height),
+        at_burnchain_height,
+        |burn_block_height| {
+            let sortdb =
+                SortitionDB::open(&burn_db_path, true, burnchain.pox_constants.clone()).unwrap();
+            let Some(miner_stats) = config.get_miner_stats() else {
+                return 0.0;
+            };
+            let Ok(active_miners_and_commits) =
+                MinerStats::get_active_miners(&sortdb, Some(burn_block_height)).map_err(|e| {
+                    warn!("Failed to get active miners: {:?}", &e);
+                    e
+                })
+            else {
+                return 0.0;
+            };
+            if active_miners_and_commits.len() == 0 {
+                warn!("No active miners detected; using config file burn_fee_cap");
+                return 0.0;
+            }
+
+            let active_miners: Vec<_> = active_miners_and_commits
+                .iter()
+                .map(|(miner, _cmt)| miner.as_str())
+                .collect();
+
+            info!("Active miners: {:?}", &active_miners);
+
+            let Ok(unconfirmed_block_commits) = miner_stats
+                .get_unconfirmed_commits(burn_block_height + 1, &active_miners)
+                .map_err(|e| {
+                    warn!("Failed to find unconfirmed block-commits: {}", &e);
+                    e
+                })
+            else {
+                return 0.0;
+            };
+
+            let unconfirmed_miners_and_amounts: Vec<(String, u64)> = unconfirmed_block_commits
+                .iter()
+                .map(|cmt| (format!("{}", &cmt.apparent_sender), cmt.burn_fee))
+                .collect();
+
+            info!(
+                "Found unconfirmed block-commits: {:?}",
+                &unconfirmed_miners_and_amounts
+            );
+
+            let (spend_dist, _total_spend) = MinerStats::get_spend_distribution(
+                &active_miners_and_commits,
+                &unconfirmed_block_commits,
+                &commit_outs,
+            );
+            let win_probs = if config.miner.fast_rampup {
+                // look at spends 6+ blocks in the future
+                let win_probs = MinerStats::get_future_win_distribution(
+                    &active_miners_and_commits,
+                    &unconfirmed_block_commits,
+                    &commit_outs,
+                );
+                win_probs
+            } else {
+                // look at the current spends
+                let Ok(unconfirmed_burn_dist) = miner_stats
+                    .get_unconfirmed_burn_distribution(
+                        &burnchain,
+                        &sortdb,
+                        &active_miners_and_commits,
+                        unconfirmed_block_commits,
+                        &commit_outs,
+                        at_burnchain_height,
+                    )
+                    .map_err(|e| {
+                        warn!("Failed to get unconfirmed burn distribution: {:?}", &e);
+                        e
+                    })
+                else {
+                    return 0.0;
+                };
+
+                let win_probs = MinerStats::burn_dist_to_prob_dist(&unconfirmed_burn_dist);
+                win_probs
+            };
+
+            info!("Unconfirmed spend distribution: {:?}", &spend_dist);
+            info!(
+                "Unconfirmed win probabilities (fast_rampup={}): {:?}",
+                config.miner.fast_rampup, &win_probs
+            );
+
+            let miner_addrs = BlockMinerThread::get_miner_addrs(&config, &keychain);
+            let win_prob = miner_addrs
+                .iter()
+                .find_map(|x| win_probs.get(x))
+                .copied()
+                .unwrap_or(0.0);
+
+            info!(
+                "This miner's win probability at {} is {}",
+                tip.block_height, &win_prob
+            );
+            win_prob
+        },
+        |_burn_block_height, _win_prob| {},
+    );
+    spend_amount
+}
+
 fn main() {
     panic::set_hook(Box::new(|panic_info| {
         error!("Process abort due to thread panic: {}", panic_info);
@@ -94,24 +313,24 @@ fn main() {
 
     let config_file = match subcommand.as_str() {
         "mocknet" => {
-            args.finish().unwrap();
+            args.finish();
             ConfigFile::mocknet()
         }
         "helium" => {
-            args.finish().unwrap();
+            args.finish();
             ConfigFile::helium()
         }
         "testnet" => {
-            args.finish().unwrap();
+            args.finish();
             ConfigFile::xenon()
         }
         "mainnet" => {
-            args.finish().unwrap();
+            args.finish();
             ConfigFile::mainnet()
         }
         "check-config" => {
             let config_path: String = args.value_from_str("--config").unwrap();
-            args.finish().unwrap();
+            args.finish();
             info!("Loading config at path {}", config_path);
             let config_file = match ConfigFile::from_path(&config_path) {
                 Ok(config_file) => {
@@ -136,7 +355,7 @@ fn main() {
         }
         "start" => {
             let config_path: String = args.value_from_str("--config").unwrap();
-            args.finish().unwrap();
+            args.finish();
             info!("Loading config at path {}", config_path);
             match ConfigFile::from_path(&config_path) {
                 Ok(config_file) => config_file,
@@ -157,14 +376,15 @@ fn main() {
                     let conf =
                         Config::from_config_file(ConfigFile::from_path(&config_path).unwrap())
                             .unwrap();
-                    args.finish().unwrap();
+                    args.finish();
                     conf.node.seed
                 } else {
-                    let free_args = args.free().unwrap();
+                    let free_args = args.finish();
                     let seed_hex = free_args
                         .first()
                         .expect("`wif-for-seed` must be passed either a config file via the `--config` flag or a hex seed string");
-                    hex_bytes(seed_hex).expect("Seed should be a hex encoded string")
+                    hex_bytes(seed_hex.to_str().unwrap())
+                        .expect("Seed should be a hex encoded string")
                 }
             };
             let keychain = Keychain::default(seed);
@@ -178,6 +398,26 @@ fn main() {
             );
             return;
         }
+        "pick-best-tip" => {
+            let config_path: String = args.value_from_str("--config").unwrap();
+            let at_stacks_height: Option<u64> =
+                args.opt_value_from_str("--at-stacks-height").unwrap();
+            args.finish();
+
+            let best_tip = cli_pick_best_tip(&config_path, at_stacks_height);
+            println!("Best tip is {:?}", &best_tip);
+            process::exit(0);
+        }
+        "get-spend-amount" => {
+            let config_path: String = args.value_from_str("--config").unwrap();
+            let at_burnchain_height: Option<u64> =
+                args.opt_value_from_str("--at-bitcoin-height").unwrap();
+            args.finish();
+
+            let spend_amount = cli_get_miner_spend(&config_path, mine_start, at_burnchain_height);
+            println!("Will spend {}", spend_amount);
+            process::exit(0);
+        }
         _ => {
             print_help();
             return;
diff --git a/testnet/stacks-node/src/neon_node.rs b/testnet/stacks-node/src/neon_node.rs
index 17eebf2c97..865f5e2a9a 100644
--- a/testnet/stacks-node/src/neon_node.rs
+++ b/testnet/stacks-node/src/neon_node.rs
@@ -1,5 +1,5 @@
 // Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
-// Copyright (C) 2020 Stacks Open Internet Foundation
+// Copyright (C) 2020-2024 Stacks Open Internet Foundation
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -138,91 +138,90 @@
 ///
 /// This file may be refactored in the future into a full-fledged module.
 use std::cmp;
-use std::collections::HashMap;
-use std::collections::{HashSet, VecDeque};
+use std::cmp::Ordering as CmpOrdering;
+use std::collections::{BTreeMap, HashMap, HashSet, VecDeque};
 use std::convert::{TryFrom, TryInto};
 use std::default::Default;
-use std::mem;
+use std::fs;
+use std::io::{Read, Write};
 use std::net::SocketAddr;
+use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::mpsc::{Receiver, SyncSender, TrySendError};
-use std::sync::{atomic::AtomicBool, atomic::Ordering, Arc, Mutex};
+use std::sync::{Arc, Mutex};
+use std::thread::JoinHandle;
 use std::time::Duration;
-use std::{thread, thread::JoinHandle};
+use std::{mem, thread};
+
+use clarity::vm::ast::ASTRules;
+use clarity::vm::types::PrincipalData;
+use stacks::burnchains::bitcoin::address::BitcoinAddress;
+use stacks::burnchains::bitcoin::address::LegacyBitcoinAddressType;
+use stacks::burnchains::db::BurnchainHeaderReader;
+use stacks::burnchains::{Burnchain, BurnchainParameters, Txid};
 
-use stacks::burnchains::{db::BurnchainHeaderReader, Burnchain, BurnchainParameters, Txid};
 use stacks::chainstate::burn::db::sortdb::SortitionDB;
+use stacks::chainstate::burn::operations::leader_block_commit::{
+    RewardSetInfo, BURN_BLOCK_MINED_AT_MODULUS,
+};
 use stacks::chainstate::burn::operations::{
-    leader_block_commit::{RewardSetInfo, BURN_BLOCK_MINED_AT_MODULUS},
     BlockstackOperationType, LeaderBlockCommitOp, LeaderKeyRegisterOp,
 };
-use stacks::chainstate::burn::BlockSnapshot;
-use stacks::chainstate::burn::ConsensusHash;
+use stacks::chainstate::burn::{BlockSnapshot, ConsensusHash};
 use stacks::chainstate::coordinator::comm::CoordinatorChannels;
 use stacks::chainstate::coordinator::{get_next_recipients, OnChainRewardSetProvider};
 use stacks::chainstate::stacks::address::PoxAddress;
 use stacks::chainstate::stacks::db::unconfirmed::UnconfirmedTxMap;
-use stacks::chainstate::stacks::db::StacksHeaderInfo;
-use stacks::chainstate::stacks::db::{StacksChainState, MINER_REWARD_MATURITY};
-use stacks::chainstate::stacks::Error as ChainstateError;
-use stacks::chainstate::stacks::StacksPublicKey;
-use stacks::chainstate::stacks::{
-    miner::get_mining_spend_amount, miner::signal_mining_blocked, miner::signal_mining_ready,
-    miner::BlockBuilderSettings, miner::MinerStatus, miner::StacksMicroblockBuilder,
-    StacksBlockBuilder, StacksBlockHeader,
+use stacks::chainstate::stacks::db::{
+    blocks::StagingBlock, StacksChainState, StacksHeaderInfo, MINER_REWARD_MATURITY,
+};
+use stacks::chainstate::stacks::miner::{
+    signal_mining_blocked, signal_mining_ready, BlockBuilderSettings, MinerStatus,
+    StacksMicroblockBuilder,
 };
 use stacks::chainstate::stacks::{
-    CoinbasePayload, StacksBlock, StacksMicroblock, StacksTransaction, StacksTransactionSigner,
+    CoinbasePayload, Error as ChainstateError, StacksBlock, StacksBlockBuilder, StacksBlockHeader,
+    StacksMicroblock, StacksPublicKey, StacksTransaction, StacksTransactionSigner,
     TransactionAnchorMode, TransactionPayload, TransactionVersion,
 };
 use stacks::codec::StacksMessageCodec;
 use stacks::core::mempool::MemPoolDB;
-use stacks::core::FIRST_BURNCHAIN_CONSENSUS_HASH;
-use stacks::core::STACKS_EPOCH_2_4_MARKER;
-use stacks::cost_estimates::metrics::CostMetric;
-use stacks::cost_estimates::metrics::UnitMetric;
-use stacks::cost_estimates::UnitEstimator;
-use stacks::cost_estimates::{CostEstimator, FeeEstimator};
+use stacks::core::{FIRST_BURNCHAIN_CONSENSUS_HASH, STACKS_EPOCH_2_4_MARKER};
+use stacks::cost_estimates::metrics::{CostMetric, UnitMetric};
+use stacks::cost_estimates::{CostEstimator, FeeEstimator, UnitEstimator};
+use stacks::monitoring;
 use stacks::monitoring::{increment_stx_blocks_mined_counter, update_active_miners_count_gauge};
-use stacks::net::{
-    atlas::{AtlasConfig, AtlasDB, AttachmentInstance},
-    db::{LocalPeer, PeerDB},
-    dns::DNSClient,
-    dns::DNSResolver,
-    p2p::PeerNetwork,
-    relay::Relayer,
-    rpc::RPCHandlerArgs,
-    Error as NetError, NetworkResult, PeerAddress, ServiceFlags,
-};
+use stacks::net::atlas::{AtlasConfig, AtlasDB, AttachmentInstance};
+use stacks::net::db::{LocalPeer, PeerDB};
+use stacks::net::dns::{DNSClient, DNSResolver};
+use stacks::net::p2p::PeerNetwork;
+use stacks::net::relay::Relayer;
+use stacks::net::rpc::RPCHandlerArgs;
+use stacks::net::{Error as NetError, NetworkResult, PeerAddress, ServiceFlags};
 use stacks::types::chainstate::{
     BlockHeaderHash, BurnchainHeaderHash, SortitionId, StacksAddress, VRFSeed,
 };
 use stacks::types::StacksEpochId;
-use stacks::util::get_epoch_time_ms;
-use stacks::util::get_epoch_time_secs;
 use stacks::util::hash::{to_hex, Hash160, Sha256Sum};
 use stacks::util::secp256k1::Secp256k1PrivateKey;
 use stacks::util::vrf::VRFPublicKey;
+use stacks::util::{get_epoch_time_ms, get_epoch_time_secs};
 use stacks::util_lib::strings::{UrlString, VecDisplay};
 use stacks::vm::costs::ExecutionCost;
 
-use crate::burnchains::bitcoin_regtest_controller::BitcoinRegtestController;
-use crate::burnchains::bitcoin_regtest_controller::OngoingBlockCommit;
-use crate::burnchains::make_bitcoin_indexer;
-use crate::run_loop::neon::Counters;
-use crate::run_loop::neon::RunLoop;
-use crate::run_loop::RegisteredKey;
-use crate::ChainTip;
-
 use super::{BurnchainController, Config, EventDispatcher, Keychain};
-use crate::syncctl::PoxSyncWatchdogComms;
-use stacks::monitoring;
 
-use stacks_common::types::chainstate::StacksBlockId;
-use stacks_common::types::chainstate::StacksPrivateKey;
+use stacks_common::types::chainstate::{StacksBlockId, StacksPrivateKey};
+use stacks_common::types::PublicKey;
 use stacks_common::util::vrf::VRFProof;
 
-use clarity::vm::ast::ASTRules;
-use clarity::vm::types::PrincipalData;
+use crate::burnchains::bitcoin_regtest_controller::{BitcoinRegtestController, OngoingBlockCommit};
+use crate::burnchains::make_bitcoin_indexer;
+use crate::chain_data::MinerStats;
+use crate::config::MinerConfig;
+use crate::run_loop::neon::{Counters, RunLoop};
+use crate::run_loop::RegisteredKey;
+use crate::syncctl::PoxSyncWatchdogComms;
+use crate::ChainTip;
 
 pub const RELAYER_MAX_BUFFER: usize = 100;
 const VRF_MOCK_MINER_KEY: u64 = 1;
@@ -232,7 +231,7 @@ pub const BLOCK_PROCESSOR_STACK_SIZE: usize = 32 * 1024 * 1024; // 32 MB
 type MinedBlocks = HashMap<BlockHeaderHash, (AssembledAnchorBlock, Secp256k1PrivateKey)>;
 
 /// Result of running the miner thread.  It could produce a Stacks block or a microblock.
-enum MinerThreadResult {
+pub(crate) enum MinerThreadResult {
     Block(
         AssembledAnchorBlock,
         Secp256k1PrivateKey,
@@ -248,7 +247,7 @@ enum MinerThreadResult {
 /// linked to the burnchain and what view(s) the miner had of the burnchain before and after
 /// completing the block.
 #[derive(Clone)]
-struct AssembledAnchorBlock {
+pub struct AssembledAnchorBlock {
     /// Consensus hash of the parent Stacks block
     parent_consensus_hash: ConsensusHash,
     /// Burnchain tip's block hash when we finished mining
@@ -301,6 +300,15 @@ pub struct Globals {
     pub should_keep_running: Arc<AtomicBool>,
     /// Status of our VRF key registration state (shared between the main thread and the relayer)
     leader_key_registration_state: Arc<Mutex<LeaderKeyRegistrationState>>,
+    /// Last miner config loaded
+    last_miner_config: Arc<Mutex<Option<MinerConfig>>>,
+    /// burnchain height at which we start mining
+    start_mining_height: Arc<Mutex<u64>>,
+    /// estimated winning probability at given bitcoin block heights
+    estimated_winning_probs: Arc<Mutex<HashMap<u64, f64>>>,
+    /// previously-selected best tips
+    /// maps stacks height to tip candidate
+    previous_best_tips: Arc<Mutex<BTreeMap<u64, TipCandidate>>>,
 }
 
 /// Miner chain tip, on top of which to build microblocks
@@ -344,6 +352,7 @@ impl Globals {
         counters: Counters,
         sync_comms: PoxSyncWatchdogComms,
         should_keep_running: Arc<AtomicBool>,
+        start_mining_height: u64,
     ) -> Globals {
         Globals {
             last_sortition: Arc::new(Mutex::new(None)),
@@ -357,6 +366,10 @@ impl Globals {
             leader_key_registration_state: Arc::new(Mutex::new(
                 LeaderKeyRegistrationState::Inactive,
             )),
+            last_miner_config: Arc::new(Mutex::new(None)),
+            start_mining_height: Arc::new(Mutex::new(start_mining_height)),
+            estimated_winning_probs: Arc::new(Mutex::new(HashMap::new())),
+            previous_best_tips: Arc::new(Mutex::new(BTreeMap::new())),
         }
     }
 
@@ -496,8 +509,8 @@ impl Globals {
         &self,
         burn_block_height: u64,
         key_registers: Vec<LeaderKeyRegisterOp>,
-    ) -> bool {
-        let mut activated = false;
+    ) -> Option<RegisteredKey> {
+        let mut activated_key = None;
         match self.leader_key_registration_state.lock() {
             Ok(ref mut leader_key_registration_state) => {
                 for op in key_registers.into_iter() {
@@ -509,14 +522,17 @@ impl Globals {
                             burn_block_height, txid
                         );
                         if txid == op.txid {
+                            let active_key = RegisteredKey {
+                                target_block_height,
+                                vrf_public_key: op.public_key,
+                                block_height: op.block_height as u64,
+                                op_vtxindex: op.vtxindex as u32,
+                            };
+
                             **leader_key_registration_state =
-                                LeaderKeyRegistrationState::Active(RegisteredKey {
-                                    target_block_height,
-                                    vrf_public_key: op.public_key,
-                                    block_height: op.block_height as u64,
-                                    op_vtxindex: op.vtxindex as u32,
-                                });
-                            activated = true;
+                                LeaderKeyRegistrationState::Active(active_key.clone());
+
+                            activated_key = Some(active_key);
                         } else {
                             debug!(
                                 "key_register_op {} does not match our pending op {}",
@@ -531,7 +547,126 @@ impl Globals {
                 panic!();
             }
         }
-        activated
+        activated_key
+    }
+
+    /// Directly set the leader key activation state from a saved key
+    pub fn resume_leader_key(&self, registered_key: RegisteredKey) {
+        match self.leader_key_registration_state.lock() {
+            Ok(ref mut leader_key_registration_state) => {
+                **leader_key_registration_state = LeaderKeyRegistrationState::Active(registered_key)
+            }
+            Err(_e) => {
+                error!("FATAL: failed to lock leader key registration state mutex");
+                panic!();
+            }
+        }
+    }
+
+    /// Get the last miner config loaded
+    pub fn get_last_miner_config(&self) -> Option<MinerConfig> {
+        match self.last_miner_config.lock() {
+            Ok(last_miner_config) => (*last_miner_config).clone(),
+            Err(_e) => {
+                error!("FATAL; failed to lock last miner config");
+                panic!();
+            }
+        }
+    }
+
+    /// Set the last miner config loaded
+    pub fn set_last_miner_config(&self, miner_config: MinerConfig) {
+        match self.last_miner_config.lock() {
+            Ok(ref mut last_miner_config) => **last_miner_config = Some(miner_config),
+            Err(_e) => {
+                error!("FATAL; failed to lock last miner config");
+                panic!();
+            }
+        }
+    }
+
+    /// Get the height at which we should start mining
+    pub fn get_start_mining_height(&self) -> u64 {
+        match self.start_mining_height.lock() {
+            Ok(ht) => *ht,
+            Err(_e) => {
+                error!("FATAL: failed to lock start_mining_height");
+                panic!();
+            }
+        }
+    }
+
+    /// Set the height at which we started mining.
+    /// Only takes effect if the current start mining height is 0.
+    pub fn set_start_mining_height_if_zero(&self, value: u64) {
+        match self.start_mining_height.lock() {
+            Ok(ref mut ht) => {
+                if **ht == 0 {
+                    **ht = value;
+                }
+            }
+            Err(_e) => {
+                error!("FATAL: failed to lock start_mining_height");
+                panic!();
+            }
+        }
+    }
+
+    /// Record an estimated winning probability
+    pub fn add_estimated_win_prob(&self, burn_height: u64, win_prob: f64) {
+        match self.estimated_winning_probs.lock() {
+            Ok(mut probs) => {
+                probs.insert(burn_height, win_prob);
+            }
+            Err(_e) => {
+                error!("FATAL: failed to lock estimated_winning_probs");
+                panic!();
+            }
+        }
+    }
+
+    /// Get the estimated winning probability, if we have one
+    pub fn get_estimated_win_prob(&self, burn_height: u64) -> Option<f64> {
+        match self.estimated_winning_probs.lock() {
+            Ok(probs) => probs.get(&burn_height).cloned(),
+            Err(_e) => {
+                error!("FATAL: failed to lock estimated_winning_probs");
+                panic!();
+            }
+        }
+    }
+
+    /// Record a best-tip
+    pub fn add_best_tip(&self, stacks_height: u64, tip_candidate: TipCandidate, max_depth: u64) {
+        match self.previous_best_tips.lock() {
+            Ok(mut tips) => {
+                tips.insert(stacks_height, tip_candidate);
+                let mut stale = vec![];
+                for (prev_height, _) in tips.iter() {
+                    if *prev_height + max_depth < stacks_height {
+                        stale.push(*prev_height);
+                    }
+                }
+                for height in stale.into_iter() {
+                    tips.remove(&height);
+                }
+            }
+            Err(_e) => {
+                error!("FATAL: failed to lock previous_best_tips");
+                panic!();
+            }
+        }
+    }
+
+    /// Get a best-tip at a previous height
+    pub fn get_best_tip(&self, stacks_height: u64) -> Option<TipCandidate> {
+        match self.previous_best_tips.lock() {
+            Ok(tips) => tips.get(&stacks_height).cloned(),
+            Err(_e) => {
+                error!("FATAL: failed to lock previous_best_tips");
+                panic!();
+            }
+        }
     }
 }
 
@@ -745,7 +880,7 @@ pub struct RelayerThread {
     mined_stacks_block: bool,
 }
 
-struct BlockMinerThread {
+pub(crate) struct BlockMinerThread {
     /// node config struct
     config: Config,
     /// handle to global state
@@ -1063,8 +1198,6 @@ impl MicroblockMinerThread {
 
             #[cfg(any(test, feature = "testing"))]
             {
-                use std::fs;
-                use std::io::Write;
                 use std::path::Path;
                 if let Ok(path) = std::env::var("STACKS_BAD_BLOCKS_DIR") {
                     // record this microblock somewhere
@@ -1216,6 +1349,46 @@ impl MicroblockMinerThread {
     }
 }
 
+/// Candidate chain tip
+#[derive(Debug, Clone, PartialEq)]
+pub struct TipCandidate {
+    pub stacks_height: u64,
+    pub consensus_hash: ConsensusHash,
+    pub anchored_block_hash: BlockHeaderHash,
+    pub parent_consensus_hash: ConsensusHash,
+    pub parent_anchored_block_hash: BlockHeaderHash,
+    /// the block's sortition's burnchain height
+    pub burn_height: u64,
+    /// the number of Stacks blocks *at the same height* as this one, but from earlier sortitions
+    /// than `burn_height`
+    pub num_earlier_siblings: u64,
+}
+
+impl TipCandidate {
+    pub fn id(&self) -> StacksBlockId {
+        StacksBlockId::new(&self.consensus_hash, &self.anchored_block_hash)
+    }
+
+    pub fn parent_id(&self) -> StacksBlockId {
+        StacksBlockId::new(
+            &self.parent_consensus_hash,
+            &self.parent_anchored_block_hash,
+        )
+    }
+
+    pub fn new(tip: StagingBlock, burn_height: u64) -> Self {
+        Self {
+            stacks_height: tip.height,
+            consensus_hash: tip.consensus_hash,
+            anchored_block_hash: tip.anchored_block_hash,
+            parent_consensus_hash: tip.parent_consensus_hash,
+            parent_anchored_block_hash: tip.parent_anchored_block_hash,
+            burn_height,
+            num_earlier_siblings: 0,
+        }
+    }
+}
+
 impl BlockMinerThread {
     /// Instantiate the miner thread from its parent RelayerThread
     pub fn from_relayer_thread(
@@ -1238,11 +1411,12 @@ impl BlockMinerThread {
 
     /// Get the coinbase recipient address, if set in the config and if allowed in this epoch
     fn get_coinbase_recipient(&self, epoch_id: StacksEpochId) -> Option<PrincipalData> {
-        if epoch_id < StacksEpochId::Epoch21 && self.config.miner.block_reward_recipient.is_some() {
+        let miner_config = self.config.get_miner_config();
+        if epoch_id < StacksEpochId::Epoch21 && miner_config.block_reward_recipient.is_some() {
             warn!("Coinbase pay-to-contract is not supported in the current epoch");
             None
         } else {
-            self.config.miner.block_reward_recipient.clone()
+            miner_config.block_reward_recipient.clone()
         }
     }
 
@@ -1353,6 +1527,320 @@ impl BlockMinerThread {
         ret
     }
 
+    /// Load all candidate tips upon which to build.  This is all Stacks blocks whose heights are
+    /// less than or equal to at `at_stacks_height` (or the canonical chain tip height, if not given),
+    /// but greater than or equal to this end height minus `max_depth`.
+    /// Returns the list of all Stacks blocks up to max_depth blocks beneath it.
+    /// The blocks will be sorted first by stacks height, and then by burnchain height
+    pub(crate) fn load_candidate_tips(
+        burn_db: &mut SortitionDB,
+        chain_state: &mut StacksChainState,
+        max_depth: u64,
+        at_stacks_height: Option<u64>,
+    ) -> Vec<TipCandidate> {
+        let stacks_tips = if let Some(start_height) = at_stacks_height {
+            chain_state
+                .get_stacks_chain_tips_at_height(start_height)
+                .expect("FATAL: could not query chain tips at start height")
+        } else {
+            chain_state
+                .get_stacks_chain_tips(burn_db)
+                .expect("FATAL: could not query chain tips")
+        };
+
+        if stacks_tips.len() == 0 {
+            return vec![];
+        }
+
+        let mut considered = HashSet::new();
+        let mut candidates = vec![];
+        let end_height = stacks_tips[0].height;
+
+        for cur_height in end_height.saturating_sub(max_depth)..=end_height {
+            let stacks_tips = chain_state
+                .get_stacks_chain_tips_at_height(cur_height)
+                .expect("FATAL: could not query chain tips at height");
+
+            for tip in stacks_tips {
+                let index_block_hash =
+                    StacksBlockId::new(&tip.consensus_hash, &tip.anchored_block_hash);
+
+                if !considered.contains(&index_block_hash) {
+                    let burn_height = burn_db
+                        .get_consensus_hash_height(&tip.consensus_hash)
+                        .expect("FATAL: could not query burnchain block height")
+                        .expect("FATAL: no burnchain block height for Stacks tip");
+                    let candidate = TipCandidate::new(tip, burn_height);
+                    candidates.push(candidate);
+                    considered.insert(index_block_hash);
+                }
+            }
+        }
+        Self::sort_and_populate_candidates(candidates)
+    }
+
+    /// Put all tip candidates in order by stacks height, breaking ties with burnchain height.
+    /// Also, count up the number of earliersiblings each tip has -- i.e. the number of stacks
+    /// blocks that have the same height, but a later burnchain sortition.
+    pub(crate) fn sort_and_populate_candidates(
+        mut candidates: Vec<TipCandidate>,
+    ) -> Vec<TipCandidate> {
+        if candidates.len() == 0 {
+            return candidates;
+        }
+        candidates.sort_by(|tip1, tip2| {
+            // stacks block height, then burnchain block height
+            let ord = tip1.stacks_height.cmp(&tip2.stacks_height);
+            if ord == CmpOrdering::Equal {
+                return tip1.burn_height.cmp(&tip2.burn_height);
+            }
+            ord
+        });
+
+        // calculate the number of earlier siblings for each block.
+        // this is the number of stacks blocks at the same height, but later burnchain heights.
+        let mut idx = 0;
+        let mut cur_stacks_height = candidates[idx].stacks_height;
+        let mut num_siblings = 0;
+        loop {
+            idx += 1;
+            if idx >= candidates.len() {
+                break;
+            }
+            if cur_stacks_height == candidates[idx].stacks_height {
+                // same stacks height, so this block has one more earlier sibling than the last
+                num_siblings += 1;
+                candidates[idx].num_earlier_siblings = num_siblings;
+            } else {
+                // new stacks height, so no earlier siblings
+                num_siblings = 0;
+                cur_stacks_height = candidates[idx].stacks_height;
+                candidates[idx].num_earlier_siblings = 0;
+            }
+        }
+
+        candidates
+    }
+
+    /// Select the best tip to mine the next block on. Potential tips are all
+    /// leaf nodes where the Stacks block height is <= the max height -
+    /// max_reorg_depth. Each potential tip is then scored based on the amount
+    /// of orphans that its chain has caused -- that is, the number of orphans
+    /// that the tip _and all of its ancestors_ (up to `max_depth`) created.
+    /// The tip with the lowest score is composed of blocks that collectively made the fewest
+    /// orphans, and is thus the "nicest" chain with the least orphaning.  This is the tip that is
+    /// selected.
+    pub fn pick_best_tip(
+        globals: &Globals,
+        config: &Config,
+        burn_db: &mut SortitionDB,
+        chain_state: &mut StacksChainState,
+        at_stacks_height: Option<u64>,
+    ) -> Option<TipCandidate> {
+        info!("Picking best Stacks tip");
+        let miner_config = config.get_miner_config();
+        let max_depth = miner_config.max_reorg_depth;
+
+        // There could be more than one possible chain tip. Go find them.
+        let stacks_tips =
+            Self::load_candidate_tips(burn_db, chain_state, max_depth, at_stacks_height);
+
+        let mut previous_best_tips = HashMap::new();
+        for tip in stacks_tips.iter() {
+            let Some(prev_best_tip) = globals.get_best_tip(tip.stacks_height) else {
+                continue;
+            };
+            previous_best_tips.insert(tip.stacks_height, prev_best_tip);
+        }
+
+        let best_tip_opt = Self::inner_pick_best_tip(stacks_tips, previous_best_tips);
+        if let Some(best_tip) = best_tip_opt.as_ref() {
+            globals.add_best_tip(best_tip.stacks_height, best_tip.clone(), max_depth);
+        } else {
+            // no best-tip found; revert to old tie-breaker logic
+            info!("No best-tips found; using old tie-breaking logic");
+            return chain_state
+                .get_stacks_chain_tip(burn_db)
+                .expect("FATAL: could not load chain tip")
+                .map(|staging_block| {
+                    let burn_height = burn_db
+                        .get_consensus_hash_height(&staging_block.consensus_hash)
+                        .expect("FATAL: could not query burnchain block height")
+                        .expect("FATAL: no burnchain block height for Stacks tip");
+                    TipCandidate::new(staging_block, burn_height)
+                });
+        }
+        best_tip_opt
+    }
+
+    /// Given a list of sorted candidate tips, pick the best one.  See `Self::pick_best_tip()`.
+    /// Takes the list of stacks tips that are eligible to be built on, and a map of
+    /// previously-chosen best tips (so if we chose a tip in the past, we keep confirming it, even
+    /// if subsequent stacks blocks show up).  The previous best tips should be from recent Stacks
+    /// heights; it's important that older best-tips are forgotten in order to ensure that miners
+    /// will eventually (e.g. after `max_reorg_depth` Stacks blocks pass) stop trying to confirm a
+    /// now-orphaned previously-chosen best-tip.  If there are multiple best-tips that conflict in
+    /// `previosu_best_tips`, then only the highest one which the leaf could confirm will be
+    /// considered (since the node updates its understanding of the best-tip on each RunTenure).
+    pub(crate) fn inner_pick_best_tip(
+        stacks_tips: Vec<TipCandidate>,
+        previous_best_tips: HashMap<u64, TipCandidate>,
+    ) -> Option<TipCandidate> {
+        // identify leaf tips -- i.e. blocks with no children
+        let parent_consensus_hashes: HashSet<_> = stacks_tips
+            .iter()
+            .map(|x| x.parent_consensus_hash.clone())
+            .collect();
+
+        let mut leaf_tips: Vec<_> = stacks_tips
+            .iter()
+            .filter(|x| !parent_consensus_hashes.contains(&x.consensus_hash))
+            .collect();
+
+        if leaf_tips.len() == 0 {
+            return None;
+        }
+
+        // Make scoring deterministic in the case of a tie.
+        // Prefer leafs that were mined earlier on the burnchain,
+        // but which pass through previously-determined best tips.
+        leaf_tips.sort_by(|tip1, tip2| {
+            // stacks block height, then burnchain block height
+            let ord = tip1.stacks_height.cmp(&tip2.stacks_height);
+            if ord == CmpOrdering::Equal {
+                return tip1.burn_height.cmp(&tip2.burn_height);
+            }
+            ord
+        });
+
+        let mut scores = BTreeMap::new();
+        for (i, leaf_tip) in leaf_tips.iter().enumerate() {
+            let leaf_id = leaf_tip.id();
+            // Score each leaf tip as the number of preceding Stacks blocks that are _not_ an
+            // ancestor.  Because stacks_tips are in order by stacks height, a linear scan of this
+            // list will allow us to match all ancestors in the last max_depth Stacks blocks.
+            // `ancestor_ptr` tracks the next expected ancestor.
+            let mut ancestor_ptr = leaf_tip.parent_id();
+            let mut score: u64 = 0;
+            let mut score_summaries = vec![];
+
+            // find the highest stacks_tip we must confirm
+            let mut must_confirm = None;
+            for tip in stacks_tips.iter().rev() {
+                if let Some(prev_best_tip) = previous_best_tips.get(&tip.stacks_height) {
+                    if leaf_id != prev_best_tip.id() {
+                        // the `ancestor_ptr` must pass through this prior best-tip
+                        must_confirm = Some(prev_best_tip.clone());
+                        break;
+                    }
+                }
+            }
+
+            for tip in stacks_tips.iter().rev() {
+                if let Some(required_ancestor) = must_confirm.as_ref() {
+                    if tip.stacks_height < required_ancestor.stacks_height
+                        && leaf_tip.stacks_height >= required_ancestor.stacks_height
+                    {
+                        // This leaf does not confirm a previous-best-tip, so assign it the
+                        // worst-possible score.
+                        info!("Tip #{} {}/{} at {}:{} conflicts with a previous best-tip {}/{} at {}:{}",
+                              i,
+                              &leaf_tip.consensus_hash,
+                              &leaf_tip.anchored_block_hash,
+                              leaf_tip.burn_height,
+                              leaf_tip.stacks_height,
+                              &required_ancestor.consensus_hash,
+                              &required_ancestor.anchored_block_hash,
+                              required_ancestor.burn_height,
+                              required_ancestor.stacks_height
+                        );
+                        score = u64::MAX;
+                        score_summaries.push(format!("{} (best-tip reorged)", u64::MAX));
+                        break;
+                    }
+                }
+                if tip.id() == leaf_id {
+                    // we can't orphan ourselves
+                    continue;
+                }
+                if leaf_tip.stacks_height < tip.stacks_height {
+                    // this tip is further along than leaf_tip, so canonicalizing leaf_tip would
+                    // orphan `tip.stacks_height - leaf_tip.stacks_height` blocks.
+                    score = score.saturating_add(tip.stacks_height - leaf_tip.stacks_height);
+                    score_summaries.push(format!(
+                        "{} (stx height diff)",
+                        tip.stacks_height - leaf_tip.stacks_height
+                    ));
+                } else if leaf_tip.stacks_height == tip.stacks_height
+                    && leaf_tip.burn_height > tip.burn_height
+                {
+                    // this tip has the same stacks height as the leaf, but its sortition happened
+                    // earlier. This means that the leaf is trying to orphan this block and all
+                    // blocks sortition'ed up to this leaf.  The miner should have instead tried to
+                    // confirm this existing tip, instead of mine a sibling.
+                    score = score.saturating_add(tip.num_earlier_siblings + 1);
+                    score_summaries.push(format!("{} (uncles)", tip.num_earlier_siblings + 1));
+                }
+                if tip.id() == ancestor_ptr {
+                    // did we confirm a previous best-tip? If so, then clear this
+                    if let Some(required_ancestor) = must_confirm.take() {
+                        if required_ancestor.id() != tip.id() {
+                            // did not confirm, so restoroe
+                            must_confirm = Some(required_ancestor);
+                        }
+                    }
+
+                    // this stacks tip is the next ancestor.  However, that ancestor may have
+                    // earlier-sortition'ed siblings that confirming this tip would orphan, so count those.
+                    ancestor_ptr = tip.parent_id();
+                    score = score.saturating_add(tip.num_earlier_siblings);
+                    score_summaries.push(format!("{} (earlier sibs)", tip.num_earlier_siblings));
+                } else {
+                    // this stacks tip is not an ancestor, and would be orphaned if leaf_tip is
+                    // canonical.
+                    score = score.saturating_add(1);
+                    score_summaries.push(format!("{} (non-ancestor)", 1));
+                }
+            }
+
+            info!(
+                "Tip #{} {}/{} at {}:{} has score {} ({})",
+                i,
+                &leaf_tip.consensus_hash,
+                &leaf_tip.anchored_block_hash,
+                leaf_tip.burn_height,
+                leaf_tip.stacks_height,
+                score,
+                score_summaries.join(" + ").to_string()
+            );
+            if score < u64::MAX {
+                scores.insert(i, score);
+            }
+        }
+
+        if scores.len() == 0 {
+            // revert to prior tie-breaking scheme
+            return None;
+        }
+
+        // The lowest score is the "nicest" tip (least amount of orphaning)
+        let best_tip_idx = scores
+            .iter()
+            .min_by_key(|(_, score)| *score)
+            .expect("FATAL: candidates should not be empty here")
+            .0;
+
+        let best_tip = leaf_tips
+            .get(*best_tip_idx)
+            .expect("FATAL: candidates should not be empty");
+
+        info!(
+            "Best tip is #{} {}/{}",
+            best_tip_idx, &best_tip.consensus_hash, &best_tip.anchored_block_hash
+        );
+        Some((*best_tip).clone())
+    }
+
     /// Load up the parent block info for mining.
     /// If there's no parent because this is the first block, then return the genesis block's info.
     /// If we can't find the parent in the DB but we expect one, return None.
@@ -1360,22 +1848,25 @@ impl BlockMinerThread {
         &self,
         burn_db: &mut SortitionDB,
         chain_state: &mut StacksChainState,
-    ) -> Option<ParentStacksBlockInfo> {
+    ) -> (Option<ParentStacksBlockInfo>, bool) {
         if let Some(stacks_tip) = chain_state
             .get_stacks_chain_tip(burn_db)
             .expect("FATAL: could not query chain tip")
         {
+            let best_stacks_tip =
+                Self::pick_best_tip(&self.globals, &self.config, burn_db, chain_state, None)
+                    .expect("FATAL: no best chain tip");
             let miner_address = self
                 .keychain
                 .origin_address(self.config.is_mainnet())
                 .unwrap();
-            match ParentStacksBlockInfo::lookup(
+            let parent_info = match ParentStacksBlockInfo::lookup(
                 chain_state,
                 burn_db,
                 &self.burn_block,
                 miner_address,
-                &stacks_tip.consensus_hash,
-                &stacks_tip.anchored_block_hash,
+                &best_stacks_tip.consensus_hash,
+                &best_stacks_tip.anchored_block_hash,
             ) {
                 Ok(parent_info) => Some(parent_info),
                 Err(Error::BurnchainTipChanged) => {
@@ -1383,7 +1874,16 @@ impl BlockMinerThread {
                     None
                 }
                 Err(..) => None,
+            };
+            if parent_info.is_none() {
+                warn!(
+                    "No parent for best-tip {}/{}",
+                    &best_stacks_tip.consensus_hash, &best_stacks_tip.anchored_block_hash
+                );
             }
+            let canonical = best_stacks_tip.consensus_hash == stacks_tip.consensus_hash
+                && best_stacks_tip.anchored_block_hash == stacks_tip.anchored_block_hash;
+            (parent_info, canonical)
         } else {
             debug!("No Stacks chain tip known, will return a genesis block");
             let (network, _) = self.config.burnchain.get_bitcoin_network();
@@ -1397,26 +1897,30 @@ impl BlockMinerThread {
                 burnchain_params.first_block_timestamp.into(),
             );
 
-            Some(ParentStacksBlockInfo {
-                stacks_parent_header: chain_tip.metadata,
-                parent_consensus_hash: FIRST_BURNCHAIN_CONSENSUS_HASH.clone(),
-                parent_block_burn_height: 0,
-                parent_block_total_burn: 0,
-                parent_winning_vtxindex: 0,
-                coinbase_nonce: 0,
-            })
+            (
+                Some(ParentStacksBlockInfo {
+                    stacks_parent_header: chain_tip.metadata,
+                    parent_consensus_hash: FIRST_BURNCHAIN_CONSENSUS_HASH.clone(),
+                    parent_block_burn_height: 0,
+                    parent_block_total_burn: 0,
+                    parent_winning_vtxindex: 0,
+                    coinbase_nonce: 0,
+                }),
+                true,
+            )
         }
     }
 
     /// Determine which attempt this will be when mining a block, and whether or not an attempt
     /// should even be made.
-    /// Returns Some(attempt) if we should attempt to mine (and what attempt it will be)
+    /// Returns Some(attempt, max-txs) if we should attempt to mine (and what attempt it will be)
     /// Returns None if we should not mine.
     fn get_mine_attempt(
         &self,
         chain_state: &StacksChainState,
         parent_block_info: &ParentStacksBlockInfo,
-    ) -> Option<u64> {
+        force: bool,
+    ) -> Option<(u64, u64)> {
         let parent_consensus_hash = &parent_block_info.parent_consensus_hash;
         let stacks_parent_header = &parent_block_info.stacks_parent_header;
         let parent_block_burn_height = parent_block_info.parent_block_burn_height;
@@ -1425,22 +1929,28 @@ impl BlockMinerThread {
             Self::find_inflight_mined_blocks(self.burn_block.block_height, &self.last_mined_blocks);
 
         // has the tip changed from our previously-mined block for this epoch?
-        let attempt = if last_mined_blocks.len() <= 1 {
+        let (attempt, max_txs) = if last_mined_blocks.len() <= 1 {
             // always mine if we've not mined a block for this epoch yet, or
             // if we've mined just one attempt, unconditionally try again (so we
             // can use `subsequent_miner_time_ms` in this attempt)
             if last_mined_blocks.len() == 1 {
-                debug!("Have only attempted one block; unconditionally trying again");
+                info!("Have only attempted one block; unconditionally trying again");
+            }
+            let attempt = last_mined_blocks.len() as u64 + 1;
+            let mut max_txs = 0;
+            for last_mined_block in last_mined_blocks.iter() {
+                max_txs = cmp::max(max_txs, last_mined_block.anchored_block.txs.len());
             }
-            last_mined_blocks.len() as u64 + 1
+            (attempt, max_txs)
         } else {
             let mut best_attempt = 0;
-            debug!(
+            let mut max_txs = 0;
+            info!(
                 "Consider {} in-flight Stacks tip(s)",
                 &last_mined_blocks.len()
             );
             for prev_block in last_mined_blocks.iter() {
-                debug!(
+                info!(
                     "Consider in-flight block {} on Stacks tip {}/{} in {} with {} txs",
                     &prev_block.anchored_block.block_hash(),
                     &prev_block.parent_consensus_hash,
@@ -1448,6 +1958,7 @@ impl BlockMinerThread {
                     &prev_block.my_burn_hash,
                     &prev_block.anchored_block.txs.len()
                 );
+                max_txs = cmp::max(max_txs, prev_block.anchored_block.txs.len());
 
                 if prev_block.anchored_block.txs.len() == 1 && prev_block.attempt == 1 {
                     // Don't let the fact that we've built an empty block during this sortition
@@ -1483,47 +1994,51 @@ impl BlockMinerThread {
                                         as usize)
                                         + 1)
                         {
-                            // the chain tip hasn't changed since we attempted to build a block.  Use what we
-                            // already have.
-                            debug!("Relayer: Stacks tip is unchanged since we last tried to mine a block off of {}/{} at height {} with {} txs, in {} at burn height {}, and no new microblocks ({} <= {} + 1)",
-                                   &prev_block.parent_consensus_hash, &prev_block.anchored_block.header.parent_block, prev_block.anchored_block.header.total_work.work,
-                                   prev_block.anchored_block.txs.len(), prev_block.my_burn_hash, parent_block_burn_height, stream.len(), prev_block.anchored_block.header.parent_microblock_sequence);
-
-                            return None;
+                            if !force {
+                                // the chain tip hasn't changed since we attempted to build a block.  Use what we
+                                // already have.
+                                info!("Relayer: Stacks tip is unchanged since we last tried to mine a block off of {}/{} at height {} with {} txs, in {} at burn height {}, and no new microblocks ({} <= {} + 1)",
+                                       &prev_block.parent_consensus_hash, &prev_block.anchored_block.header.parent_block, prev_block.anchored_block.header.total_work.work,
+                                       prev_block.anchored_block.txs.len(), prev_block.my_burn_hash, parent_block_burn_height, stream.len(), prev_block.anchored_block.header.parent_microblock_sequence);
+
+                                return None;
+                            }
                         } else {
                             // there are new microblocks!
                             // TODO: only consider rebuilding our anchored block if we (a) have
                             // time, and (b) the new microblocks are worth more than the new BTC
                             // fee minus the old BTC fee
-                            debug!("Relayer: Stacks tip is unchanged since we last tried to mine a block off of {}/{} at height {} with {} txs, in {} at burn height {}, but there are new microblocks ({} > {} + 1)",
+                            info!("Relayer: Stacks tip is unchanged since we last tried to mine a block off of {}/{} at height {} with {} txs, in {} at burn height {}, but there are new microblocks ({} > {} + 1)",
                                    &prev_block.parent_consensus_hash, &prev_block.anchored_block.header.parent_block, prev_block.anchored_block.header.total_work.work,
                                    prev_block.anchored_block.txs.len(), prev_block.my_burn_hash, parent_block_burn_height, stream.len(), prev_block.anchored_block.header.parent_microblock_sequence);
 
                             best_attempt = cmp::max(best_attempt, prev_block.attempt);
                         }
                     } else {
-                        // no microblock stream to confirm, and the stacks tip hasn't changed
-                        debug!("Relayer: Stacks tip is unchanged since we last tried to mine a block off of {}/{} at height {} with {} txs, in {} at burn height {}, and no microblocks present",
-                               &prev_block.parent_consensus_hash, &prev_block.anchored_block.header.parent_block, prev_block.anchored_block.header.total_work.work,
-                               prev_block.anchored_block.txs.len(), prev_block.my_burn_hash, parent_block_burn_height);
+                        if !force {
+                            // no microblock stream to confirm, and the stacks tip hasn't changed
+                            info!("Relayer: Stacks tip is unchanged since we last tried to mine a block off of {}/{} at height {} with {} txs, in {} at burn height {}, and no microblocks present",
+                                   &prev_block.parent_consensus_hash, &prev_block.anchored_block.header.parent_block, prev_block.anchored_block.header.total_work.work,
+                                   prev_block.anchored_block.txs.len(), prev_block.my_burn_hash, parent_block_burn_height);
 
-                        return None;
+                            return None;
+                        }
                     }
                 } else {
                     if self.burn_block.burn_header_hash == prev_block.my_burn_hash {
                         // only try and re-mine if there was no sortition since the last chain tip
-                        debug!("Relayer: Stacks tip has changed to {}/{} since we last tried to mine a block in {} at burn height {}; attempt was {} (for Stacks tip {}/{})",
+                        info!("Relayer: Stacks tip has changed to {}/{} since we last tried to mine a block in {} at burn height {}; attempt was {} (for Stacks tip {}/{})",
                                parent_consensus_hash, stacks_parent_header.anchored_header.block_hash(), prev_block.my_burn_hash, parent_block_burn_height, prev_block.attempt, &prev_block.parent_consensus_hash, &prev_block.anchored_block.header.parent_block);
                         best_attempt = cmp::max(best_attempt, prev_block.attempt);
                     } else {
-                        debug!("Relayer: Burn tip has changed to {} ({}) since we last tried to mine a block in {}",
+                        info!("Relayer: Burn tip has changed to {} ({}) since we last tried to mine a block in {}",
                                &self.burn_block.burn_header_hash, self.burn_block.block_height, &prev_block.my_burn_hash);
                     }
                 }
             }
-            best_attempt + 1
+            (best_attempt + 1, max_txs)
         };
-        Some(attempt)
+        Some((attempt, u64::try_from(max_txs).expect("too many txs")))
     }
 
     /// Generate the VRF proof for the block we're going to build.
@@ -1687,6 +2202,214 @@ impl BlockMinerThread {
         microblock_info_opt.map(|(stream, _)| stream)
     }
 
+    /// Get the list of possible burn addresses this miner is using
+    pub fn get_miner_addrs(config: &Config, keychain: &Keychain) -> Vec<String> {
+        let mut op_signer = keychain.generate_op_signer();
+        let mut btc_addrs = vec![
+            // legacy
+            BitcoinAddress::from_bytes_legacy(
+                config.burnchain.get_bitcoin_network().1,
+                LegacyBitcoinAddressType::PublicKeyHash,
+                &Hash160::from_data(&op_signer.get_public_key().to_bytes()).0,
+            )
+            .expect("FATAL: failed to construct legacy bitcoin address"),
+        ];
+        if config.miner.segwit {
+            btc_addrs.push(
+                // segwit p2wpkh
+                BitcoinAddress::from_bytes_segwit_p2wpkh(
+                    config.burnchain.get_bitcoin_network().1,
+                    &Hash160::from_data(&op_signer.get_public_key().to_bytes_compressed()).0,
+                )
+                .expect("FATAL: failed to construct segwit p2wpkh address"),
+            );
+        }
+        btc_addrs
+            .into_iter()
+            .map(|addr| format!("{}", &addr))
+            .collect()
+    }
+
+    /// Obtain the target burn fee cap, when considering how well this miner is performing.
+    pub fn get_mining_spend_amount<F, G>(
+        config: &Config,
+        keychain: &Keychain,
+        burnchain: &Burnchain,
+        sortdb: &SortitionDB,
+        recipients: &[PoxAddress],
+        start_mine_height: u64,
+        at_burn_block: Option<u64>,
+        mut get_prior_winning_prob: F,
+        mut set_prior_winning_prob: G,
+    ) -> u64
+    where
+        F: FnMut(u64) -> f64,
+        G: FnMut(u64, f64),
+    {
+        let config_file_burn_fee_cap = config.get_burnchain_config().burn_fee_cap;
+        let miner_config = config.get_miner_config();
+
+        if miner_config.target_win_probability < 0.00001 {
+            // this field is effectively zero
+            return config_file_burn_fee_cap;
+        }
+        let Some(miner_stats) = config.get_miner_stats() else {
+            return config_file_burn_fee_cap;
+        };
+
+        let Ok(tip) = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn()).map_err(|e| {
+            warn!("Failed to load canonical burn chain tip: {:?}", &e);
+            e
+        }) else {
+            return config_file_burn_fee_cap;
+        };
+        let tip = if let Some(at_burn_block) = at_burn_block.as_ref() {
+            let ih = sortdb.index_handle(&tip.sortition_id);
+            let Ok(Some(ancestor_tip)) = ih.get_block_snapshot_by_height(*at_burn_block) else {
+                warn!(
+                    "Failed to load ancestor tip at burn height {}",
+                    at_burn_block
+                );
+                return config_file_burn_fee_cap;
+            };
+            ancestor_tip
+        } else {
+            tip
+        };
+
+        let Ok(active_miners_and_commits) = MinerStats::get_active_miners(sortdb, at_burn_block)
+            .map_err(|e| {
+                warn!("Failed to get active miners: {:?}", &e);
+                e
+            })
+        else {
+            return config_file_burn_fee_cap;
+        };
+        if active_miners_and_commits.len() == 0 {
+            warn!("No active miners detected; using config file burn_fee_cap");
+            return config_file_burn_fee_cap;
+        }
+
+        let active_miners: Vec<_> = active_miners_and_commits
+            .iter()
+            .map(|(miner, _cmt)| miner.as_str())
+            .collect();
+
+        info!("Active miners: {:?}", &active_miners);
+
+        let Ok(unconfirmed_block_commits) = miner_stats
+            .get_unconfirmed_commits(tip.block_height + 1, &active_miners)
+            .map_err(|e| {
+                warn!("Failed to find unconfirmed block-commits: {}", &e);
+                e
+            })
+        else {
+            return config_file_burn_fee_cap;
+        };
+
+        let unconfirmed_miners_and_amounts: Vec<(String, u64)> = unconfirmed_block_commits
+            .iter()
+            .map(|cmt| (cmt.apparent_sender.to_string(), cmt.burn_fee))
+            .collect();
+
+        info!(
+            "Found unconfirmed block-commits: {:?}",
+            &unconfirmed_miners_and_amounts
+        );
+
+        let (spend_dist, _total_spend) = MinerStats::get_spend_distribution(
+            &active_miners_and_commits,
+            &unconfirmed_block_commits,
+            &recipients,
+        );
+        let win_probs = if miner_config.fast_rampup {
+            // look at spends 6+ blocks in the future
+            let win_probs = MinerStats::get_future_win_distribution(
+                &active_miners_and_commits,
+                &unconfirmed_block_commits,
+                &recipients,
+            );
+            win_probs
+        } else {
+            // look at the current spends
+            let Ok(unconfirmed_burn_dist) = miner_stats
+                .get_unconfirmed_burn_distribution(
+                    burnchain,
+                    sortdb,
+                    &active_miners_and_commits,
+                    unconfirmed_block_commits,
+                    recipients,
+                    at_burn_block,
+                )
+                .map_err(|e| {
+                    warn!("Failed to get unconfirmed burn distribution: {:?}", &e);
+                    e
+                })
+            else {
+                return config_file_burn_fee_cap;
+            };
+
+            let win_probs = MinerStats::burn_dist_to_prob_dist(&unconfirmed_burn_dist);
+            win_probs
+        };
+
+        info!("Unconfirmed spend distribution: {:?}", &spend_dist);
+        info!(
+            "Unconfirmed win probabilities (fast_rampup={}): {:?}",
+            miner_config.fast_rampup, &win_probs
+        );
+
+        let miner_addrs = Self::get_miner_addrs(config, keychain);
+        let win_prob = miner_addrs
+            .iter()
+            .find_map(|x| win_probs.get(x))
+            .copied()
+            .unwrap_or(0.0);
+
+        info!(
+            "This miner's win probability at {} is {}",
+            tip.block_height, &win_prob
+        );
+        set_prior_winning_prob(tip.block_height, win_prob);
+
+        if win_prob < config.miner.target_win_probability {
+            // no mining strategy is viable, so just quit.
+            // Unless we're spinning up, that is.
+            if start_mine_height + 6 < tip.block_height
+                && config.miner.underperform_stop_threshold.is_some()
+            {
+                let underperform_stop_threshold =
+                    config.miner.underperform_stop_threshold.unwrap_or(0);
+                info!(
+                    "Miner is spun up, but is not meeting target win probability as of {}",
+                    tip.block_height
+                );
+                // we've spun up and we're underperforming. How long do we tolerate this?
+                let mut underperformed_count = 0;
+                for depth in 0..underperform_stop_threshold {
+                    let prior_burn_height = tip.block_height.saturating_sub(depth);
+                    let prior_win_prob = get_prior_winning_prob(prior_burn_height);
+                    if prior_win_prob < config.miner.target_win_probability {
+                        info!(
+                            "Miner underperformed in block {} ({}/{})",
+                            prior_burn_height, underperformed_count, underperform_stop_threshold
+                        );
+                        underperformed_count += 1;
+                    }
+                }
+                if underperformed_count == underperform_stop_threshold {
+                    warn!(
+                        "Miner underperformed since burn height {}; spinning down",
+                        start_mine_height + 6 + underperform_stop_threshold
+                    );
+                    return 0;
+                }
+            }
+        }
+
+        config_file_burn_fee_cap
+    }
+
     /// Produce the block-commit for this anchored block, if we can.
     /// Returns the op on success
     /// Returns None if we fail somehow.
@@ -1716,15 +2439,6 @@ impl BlockMinerThread {
             }
         };
 
-        // let burn_fee_cap = self.config.burnchain.burn_fee_cap;
-        let burn_fee_cap = get_mining_spend_amount(self.globals.get_miner_status());
-        let sunset_burn = self.burnchain.expected_sunset_burn(
-            self.burn_block.block_height + 1,
-            burn_fee_cap,
-            target_epoch_id,
-        );
-        let rest_commit = burn_fee_cap - sunset_burn;
-
         let commit_outs = if !self
             .burnchain
             .pox_constants
@@ -1738,6 +2452,32 @@ impl BlockMinerThread {
             vec![PoxAddress::standard_burn_address(self.config.is_mainnet())]
         };
 
+        let burn_fee_cap = Self::get_mining_spend_amount(
+            &self.config,
+            &self.keychain,
+            &self.burnchain,
+            burn_db,
+            &commit_outs,
+            self.globals.get_start_mining_height(),
+            None,
+            |block_height| {
+                self.globals
+                    .get_estimated_win_prob(block_height)
+                    .unwrap_or(0.0)
+            },
+            |block_height, win_prob| self.globals.add_estimated_win_prob(block_height, win_prob),
+        );
+        if burn_fee_cap == 0 {
+            warn!("Calculated burn_fee_cap is 0; will not mine");
+            return None;
+        }
+        let sunset_burn = self.burnchain.expected_sunset_burn(
+            self.burn_block.block_height + 1,
+            burn_fee_cap,
+            target_epoch_id,
+        );
+        let rest_commit = burn_fee_cap - sunset_burn;
+
         // let's commit, but target the current burnchain tip with our modulus
         let op = self.inner_generate_block_commit_op(
             block_hash,
@@ -1840,6 +2580,19 @@ impl BlockMinerThread {
             self.ongoing_commit.clone(),
         );
 
+        let miner_config = self.config.get_miner_config();
+        let last_miner_config_opt = self.globals.get_last_miner_config();
+        let force_remine = if let Some(last_miner_config) = last_miner_config_opt {
+            last_miner_config != miner_config
+        } else {
+            false
+        };
+        if force_remine {
+            info!("Miner config changed; forcing a re-mine attempt");
+        }
+
+        self.globals.set_last_miner_config(miner_config);
+
         // NOTE: read-write access is needed in order to be able to query the recipient set.
         // This is an artifact of the way the MARF is built (see #1449)
         let mut burn_db =
@@ -1865,8 +2618,14 @@ impl BlockMinerThread {
                 .ok()?
                 .expect("FATAL: no epoch defined")
                 .epoch_id;
-        let mut parent_block_info = self.load_block_parent_info(&mut burn_db, &mut chain_state)?;
-        let attempt = self.get_mine_attempt(&chain_state, &parent_block_info)?;
+
+        let (Some(mut parent_block_info), _) =
+            self.load_block_parent_info(&mut burn_db, &mut chain_state)
+        else {
+            return None;
+        };
+        let (attempt, max_txs) =
+            self.get_mine_attempt(&chain_state, &parent_block_info, force_remine)?;
         let vrf_proof = self.make_vrf_proof()?;
 
         // Generates a new secret key for signing the trail of microblocks
@@ -1979,6 +2738,24 @@ impl BlockMinerThread {
             }
         };
 
+        let miner_config = self.config.get_miner_config();
+
+        if attempt > 1
+            && miner_config.min_tx_count > 0
+            && u64::try_from(anchored_block.txs.len()).expect("too many txs")
+                < miner_config.min_tx_count
+        {
+            info!("Relayer: Succeeded assembling subsequent block with {} txs, but expected at least {}", anchored_block.txs.len(), miner_config.min_tx_count);
+            return None;
+        }
+
+        if miner_config.only_increase_tx_count
+            && max_txs > u64::try_from(anchored_block.txs.len()).expect("too many txs")
+        {
+            info!("Relayer: Succeeded assembling subsequent block with {} txs, but had previously produced a block with {} txs", anchored_block.txs.len(), max_txs);
+            return None;
+        }
+
         info!(
             "Relayer: Succeeded assembling {} block #{}: {}, with {} txs, attempt {}",
             if parent_block_info.parent_block_total_burn == 0 {
@@ -2002,6 +2779,11 @@ impl BlockMinerThread {
             &vrf_proof,
             target_epoch_id,
         )?;
+        let burn_fee = if let BlockstackOperationType::LeaderBlockCommit(ref op) = &op {
+            op.burn_fee
+        } else {
+            0
+        };
 
         // last chance -- confirm that the stacks tip is unchanged (since it could have taken long
         // enough to build this block that another block could have arrived), and confirm that all
@@ -2009,10 +2791,13 @@ impl BlockMinerThread {
         let cur_burn_chain_tip = SortitionDB::get_canonical_burn_chain_tip(burn_db.conn())
             .expect("FATAL: failed to query sortition DB for canonical burn chain tip");
 
-        if let Some(stacks_tip) = chain_state
-            .get_stacks_chain_tip(&burn_db)
-            .expect("FATAL: could not query chain tip")
-        {
+        if let Some(stacks_tip) = Self::pick_best_tip(
+            &self.globals,
+            &self.config,
+            &mut burn_db,
+            &mut chain_state,
+            None,
+        ) {
             let is_miner_blocked = self
                 .globals
                 .get_miner_status()
@@ -2024,7 +2809,7 @@ impl BlockMinerThread {
                 &self.burnchain,
                 &burn_db,
                 &chain_state,
-                self.config.miner.unprocessed_block_deadline_secs,
+                miner_config.unprocessed_block_deadline_secs,
             );
             if stacks_tip.anchored_block_hash != anchored_block.header.parent_block
                 || parent_block_info.parent_consensus_hash != stacks_tip.consensus_hash
@@ -2032,7 +2817,7 @@ impl BlockMinerThread {
                 || is_miner_blocked
                 || has_unprocessed
             {
-                debug!(
+                info!(
                     "Relayer: Cancel block-commit; chain tip(s) have changed or cancelled";
                     "block_hash" => %anchored_block.block_hash(),
                     "tx_count" => anchored_block.txs.len(),
@@ -2059,8 +2844,9 @@ impl BlockMinerThread {
         }
 
         let mut op_signer = self.keychain.generate_op_signer();
-        debug!(
+        info!(
             "Relayer: Submit block-commit";
+            "burn_fee" => burn_fee,
             "block_hash" => %anchored_block.block_hash(),
             "tx_count" => anchored_block.txs.len(),
             "target_height" => anchored_block.header.total_work.work,
@@ -2379,8 +3165,6 @@ impl RelayerThread {
             );
             #[cfg(any(test, feature = "testing"))]
             {
-                use std::fs;
-                use std::io::Write;
                 use std::path::Path;
                 if let Ok(path) = std::env::var("STACKS_BAD_BLOCKS_DIR") {
                     // record this block somewhere
@@ -2986,11 +3770,13 @@ impl RelayerThread {
             return None;
         }
 
+        let miner_config = self.config.get_miner_config();
+
         let has_unprocessed = BlockMinerThread::unprocessed_blocks_prevent_mining(
             &self.burnchain,
             self.sortdb_ref(),
             self.chainstate_ref(),
-            self.config.miner.unprocessed_block_deadline_secs,
+            miner_config.unprocessed_block_deadline_secs,
         );
         if has_unprocessed {
             debug!(
@@ -3381,6 +4167,36 @@ impl RelayerThread {
         self.miner_thread.is_none()
     }
 
+    /// Try loading up a saved VRF key
+    pub(crate) fn load_saved_vrf_key(path: &str) -> Option<RegisteredKey> {
+        let mut f = match fs::File::open(path) {
+            Ok(f) => f,
+            Err(e) => {
+                warn!("Could not open {}: {:?}", &path, &e);
+                return None;
+            }
+        };
+        let mut registered_key_bytes = vec![];
+        if let Err(e) = f.read_to_end(&mut registered_key_bytes) {
+            warn!(
+                "Failed to read registered key bytes from {}: {:?}",
+                path, &e
+            );
+            return None;
+        }
+
+        let Ok(registered_key) = serde_json::from_slice(&registered_key_bytes) else {
+            warn!(
+                "Did not load registered key from {}: could not decode JSON",
+                &path
+            );
+            return None;
+        };
+
+        info!("Loaded registered key from {}", &path);
+        Some(registered_key)
+    }
+
     /// Top-level dispatcher
     pub fn handle_directive(&mut self, directive: RelayerDirective) -> bool {
         debug!("Relayer: received next directive");
@@ -3392,10 +4208,18 @@ impl RelayerThread {
                 true
             }
             RelayerDirective::RegisterKey(last_burn_block) => {
-                debug!("Relayer: directive Register VRF key");
-                self.rotate_vrf_and_register(&last_burn_block);
+                let mut saved_key_opt = None;
+                if let Some(path) = self.config.miner.activated_vrf_key_path.as_ref() {
+                    saved_key_opt = Self::load_saved_vrf_key(&path);
+                }
+                if let Some(saved_key) = saved_key_opt {
+                    self.globals.resume_leader_key(saved_key);
+                } else {
+                    debug!("Relayer: directive Register VRF key");
+                    self.rotate_vrf_and_register(&last_burn_block);
+                    debug!("Relayer: directive Registered VRF key");
+                }
                 self.globals.counters.bump_blocks_processed();
-                debug!("Relayer: directive Registered VRF key");
                 true
             }
             RelayerDirective::ProcessTenure(consensus_hash, burn_hash, block_header_hash) => {
@@ -4334,6 +5158,7 @@ impl StacksNode {
     /// Called from the main thread.
     pub fn process_burnchain_state(
         &mut self,
+        config: &Config,
         sortdb: &SortitionDB,
         sort_id: &SortitionId,
         ibd: bool,
@@ -4376,18 +5201,46 @@ impl StacksNode {
             SortitionDB::get_leader_keys_by_block(&ic, &block_snapshot.sortition_id)
                 .expect("Unexpected SortitionDB error fetching key registers");
 
-        let num_key_registers = key_registers.len();
-
-        self.globals
-            .try_activate_leader_key_registration(block_height, key_registers);
+        self.globals.set_last_sortition(block_snapshot);
+        let ret = last_sortitioned_block.map(|x| x.0);
 
+        let num_key_registers = key_registers.len();
         debug!(
             "Processed burnchain state at height {}: {} leader keys, {} block-commits (ibd = {})",
             block_height, num_key_registers, num_block_commits, ibd
         );
 
-        self.globals.set_last_sortition(block_snapshot);
-        last_sortitioned_block.map(|x| x.0)
+        // save the registered VRF key
+        let activated_key_opt = self
+            .globals
+            .try_activate_leader_key_registration(block_height, key_registers);
+
+        let Some(activated_key) = activated_key_opt else {
+            return ret;
+        };
+        let Some(path) = config.miner.activated_vrf_key_path.as_ref() else {
+            return ret;
+        };
+        info!("Activated VRF key; saving to {}", &path);
+        let Ok(key_json) = serde_json::to_string(&activated_key) else {
+            warn!("Failed to serialize VRF key");
+            return ret;
+        };
+        let mut f = match fs::File::create(&path) {
+            Ok(f) => f,
+            Err(e) => {
+                warn!("Failed to create {}: {:?}", &path, &e);
+                return ret;
+            }
+        };
+
+        if let Err(e) = f.write_all(key_json.as_str().as_bytes()) {
+            warn!("Failed to write activated VRF key to {}: {:?}", &path, &e);
+            return ret;
+        }
+
+        info!("Saved activated VRF key to {}", &path);
+        return ret;
     }
 
     /// Join all inner threads
diff --git a/testnet/stacks-node/src/run_loop/mod.rs b/testnet/stacks-node/src/run_loop/mod.rs
index bbee55f1e6..37d8ce1fa9 100644
--- a/testnet/stacks-node/src/run_loop/mod.rs
+++ b/testnet/stacks-node/src/run_loop/mod.rs
@@ -151,7 +151,7 @@ impl RunLoopCallbacks {
     }
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct RegisteredKey {
     /// burn block height we intended this VRF key register to land in
     pub target_block_height: u64,
diff --git a/testnet/stacks-node/src/run_loop/neon.rs b/testnet/stacks-node/src/run_loop/neon.rs
index 47b5df31ce..983fee7a27 100644
--- a/testnet/stacks-node/src/run_loop/neon.rs
+++ b/testnet/stacks-node/src/run_loop/neon.rs
@@ -628,11 +628,12 @@ impl RunLoop {
         sortdb: &SortitionDB,
         last_stacks_pox_reorg_recover_time: &mut u128,
     ) {
+        let miner_config = config.get_miner_config();
         let delay = cmp::max(
             config.node.chain_liveness_poll_time_secs,
             cmp::max(
-                config.miner.first_attempt_time_ms,
-                config.miner.subsequent_attempt_time_ms,
+                miner_config.first_attempt_time_ms,
+                miner_config.subsequent_attempt_time_ms,
             ) / 1000,
         );
 
@@ -748,11 +749,12 @@ impl RunLoop {
         last_burn_pox_reorg_recover_time: &mut u128,
         last_announce_time: &mut u128,
     ) {
+        let miner_config = config.get_miner_config();
         let delay = cmp::max(
             config.node.chain_liveness_poll_time_secs,
             cmp::max(
-                config.miner.first_attempt_time_ms,
-                config.miner.subsequent_attempt_time_ms,
+                miner_config.first_attempt_time_ms,
+                miner_config.subsequent_attempt_time_ms,
             ) / 1000,
         );
 
@@ -977,6 +979,7 @@ impl RunLoop {
             self.counters.clone(),
             self.pox_watchdog_comms.clone(),
             self.should_keep_running.clone(),
+            mine_start,
         );
         self.set_globals(globals.clone());
 
@@ -1165,7 +1168,12 @@ impl RunLoop {
                         let sortition_id = &block.sortition_id;
 
                         // Have the node process the new block, that can include, or not, a sortition.
-                        node.process_burnchain_state(burnchain.sortdb_mut(), sortition_id, ibd);
+                        node.process_burnchain_state(
+                            self.config(),
+                            burnchain.sortdb_mut(),
+                            sortition_id,
+                            ibd,
+                        );
 
                         // Now, tell the relayer to check if it won a sortition during this block,
                         // and, if so, to process and advertize the block.  This is basically a
@@ -1235,6 +1243,7 @@ impl RunLoop {
                     // once we've synced to the chain tip once, don't apply this check again.
                     //  this prevents a possible corner case in the event of a PoX fork.
                     mine_start = 0;
+                    globals.set_start_mining_height_if_zero(sortition_db_height);
 
                     // at tip, and not downloading. proceed to mine.
                     if last_tenure_sortition_height != sortition_db_height {
diff --git a/testnet/stacks-node/src/tests/bitcoin_regtest.rs b/testnet/stacks-node/src/tests/bitcoin_regtest.rs
index 2479a403cd..3814f7b880 100644
--- a/testnet/stacks-node/src/tests/bitcoin_regtest.rs
+++ b/testnet/stacks-node/src/tests/bitcoin_regtest.rs
@@ -142,7 +142,6 @@ fn bitcoind_integration(segwit_flag: bool) {
     conf.burnchain.password = Some("secret".to_string());
     conf.burnchain.local_mining_public_key = Some("04ee0b1602eb18fef7986887a7e8769a30c9df981d33c8380d255edef003abdcd243a0eb74afdf6740e6c423e62aec631519a24cf5b1d62bf8a3e06ddc695dcb77".to_string());
 
-    conf.miner.min_tx_fee = 0;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
     conf.miner.segwit = segwit_flag;
diff --git a/testnet/stacks-node/src/tests/epoch_205.rs b/testnet/stacks-node/src/tests/epoch_205.rs
index 7d8543bd58..b95ad46527 100644
--- a/testnet/stacks-node/src/tests/epoch_205.rs
+++ b/testnet/stacks-node/src/tests/epoch_205.rs
@@ -996,7 +996,6 @@ fn bigger_microblock_streams_in_2_05() {
     conf.node.max_microblocks = 65536;
     conf.burnchain.max_rbf = 1000000;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
diff --git a/testnet/stacks-node/src/tests/epoch_21.rs b/testnet/stacks-node/src/tests/epoch_21.rs
index 69a6d0ac00..f32c0edf15 100644
--- a/testnet/stacks-node/src/tests/epoch_21.rs
+++ b/testnet/stacks-node/src/tests/epoch_21.rs
@@ -5000,7 +5000,6 @@ fn test_v1_unlock_height_with_current_stackers() {
     conf.node.wait_time_for_blocks = 1_000;
     conf.miner.wait_for_block_download = false;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -5265,7 +5264,6 @@ fn test_v1_unlock_height_with_delay_and_current_stackers() {
     conf.node.wait_time_for_blocks = 1_000;
     conf.miner.wait_for_block_download = false;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
diff --git a/testnet/stacks-node/src/tests/epoch_22.rs b/testnet/stacks-node/src/tests/epoch_22.rs
index 2abd127cfc..ebdca835b7 100644
--- a/testnet/stacks-node/src/tests/epoch_22.rs
+++ b/testnet/stacks-node/src/tests/epoch_22.rs
@@ -144,7 +144,6 @@ fn disable_pox() {
     conf.node.wait_time_for_blocks = 1_000;
     conf.miner.wait_for_block_download = false;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -677,7 +676,6 @@ fn pox_2_unlock_all() {
     conf.node.wait_time_for_blocks = 1_000;
     conf.miner.wait_for_block_download = false;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
diff --git a/testnet/stacks-node/src/tests/epoch_23.rs b/testnet/stacks-node/src/tests/epoch_23.rs
index 58313947d8..59bce72857 100644
--- a/testnet/stacks-node/src/tests/epoch_23.rs
+++ b/testnet/stacks-node/src/tests/epoch_23.rs
@@ -104,7 +104,6 @@ fn trait_invocation_behavior() {
     conf.node.wait_time_for_blocks = 1_000;
     conf.miner.wait_for_block_download = false;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
diff --git a/testnet/stacks-node/src/tests/epoch_24.rs b/testnet/stacks-node/src/tests/epoch_24.rs
index 189a4ba5eb..9baf8f0fe5 100644
--- a/testnet/stacks-node/src/tests/epoch_24.rs
+++ b/testnet/stacks-node/src/tests/epoch_24.rs
@@ -38,13 +38,10 @@ use crate::tests::bitcoin_regtest::BitcoinCoreController;
 use crate::{neon, BitcoinRegtestController, BurnchainController};
 use stacks::clarity_cli::vm_execute as execute;
 use stacks::core;
-use stacks::core::{
-    StacksEpoch, PEER_VERSION_EPOCH_2_2, PEER_VERSION_EPOCH_2_3, PEER_VERSION_EPOCH_2_4,
-};
 use stacks_common::address::{AddressHashMode, C32_ADDRESS_VERSION_TESTNET_SINGLESIG};
 use stacks_common::codec::StacksMessageCodec;
 use stacks_common::consts::STACKS_EPOCH_MAX;
-use stacks_common::types::{Address, StacksEpochId};
+use stacks_common::types::Address;
 use stacks_common::util::sleep_ms;
 
 #[cfg(test)]
@@ -150,7 +147,6 @@ fn fix_to_pox_contract() {
     conf.node.wait_time_for_blocks = 1_000;
     conf.miner.wait_for_block_download = false;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -789,7 +785,6 @@ fn verify_auto_unlock_behavior() {
     conf.node.wait_time_for_blocks = 1_000;
     conf.miner.wait_for_block_download = false;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -1088,7 +1083,7 @@ fn verify_auto_unlock_behavior() {
 
     // Check that the "raw" reward sets for all cycles just contains entries for both addrs
     //  for the next few cycles.
-    for cycle_number in first_v3_cycle..(first_v3_cycle + 6) {
+    for _cycle_number in first_v3_cycle..(first_v3_cycle + 6) {
         let (mut chainstate, _) = StacksChainState::open(
             false,
             conf.burnchain.chain_id,
@@ -1174,7 +1169,7 @@ fn verify_auto_unlock_behavior() {
 
     // Check that the "raw" reward sets for all cycles just contains entries for the first
     //  address at the cycle start, since addr 2 was auto-unlocked.
-    for cycle_number in first_v3_cycle..(first_v3_cycle + 6) {
+    for _cycle_number in first_v3_cycle..(first_v3_cycle + 6) {
         let tip_info = get_chain_info(&conf);
         let tip_block_id =
             StacksBlockId::new(&tip_info.stacks_tip_consensus_hash, &tip_info.stacks_tip);
diff --git a/testnet/stacks-node/src/tests/integrations.rs b/testnet/stacks-node/src/tests/integrations.rs
index c7c833311a..5822472d8c 100644
--- a/testnet/stacks-node/src/tests/integrations.rs
+++ b/testnet/stacks-node/src/tests/integrations.rs
@@ -186,7 +186,6 @@ fn integration_test_get_info() {
     });
 
     conf.burnchain.commit_anchor_block_within = 5000;
-    conf.miner.min_tx_fee = 0;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
diff --git a/testnet/stacks-node/src/tests/mod.rs b/testnet/stacks-node/src/tests/mod.rs
index 94d6401c52..d2af21db8a 100644
--- a/testnet/stacks-node/src/tests/mod.rs
+++ b/testnet/stacks-node/src/tests/mod.rs
@@ -1,3 +1,19 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020-2024 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+use std::collections::HashMap;
 use std::convert::TryInto;
 use std::sync::atomic::AtomicU64;
 use std::sync::Arc;
@@ -36,8 +52,12 @@ use stacks::core::StacksEpochExtension;
 use stacks::core::StacksEpochId;
 
 use super::burnchains::bitcoin_regtest_controller::ParsedUTXO;
+use super::neon_node::BlockMinerThread;
+use super::neon_node::TipCandidate;
 use super::Config;
 
+use stacks_common::types::chainstate::BlockHeaderHash;
+
 mod atlas;
 mod bitcoin_regtest;
 mod epoch_205;
@@ -521,8 +541,6 @@ fn should_succeed_mining_valid_txs() {
         100000,
     );
 
-    conf.miner.min_tx_fee = 0;
-
     let num_rounds = 6;
     let mut run_loop = RunLoop::new(conf.clone());
 
@@ -996,3 +1014,332 @@ fn test_btc_to_sat_errors() {
     assert!(ParsedUTXO::serialized_btc_to_sat("7.4e-7").is_none());
     assert!(ParsedUTXO::serialized_btc_to_sat("5.96e-6").is_none());
 }
+
+#[test]
+fn test_sort_and_populate_candidates() {
+    let empty: Vec<TipCandidate> = vec![];
+    assert_eq!(
+        empty,
+        BlockMinerThread::sort_and_populate_candidates(vec![])
+    );
+    let candidates = vec![
+        TipCandidate {
+            stacks_height: 1,
+            consensus_hash: ConsensusHash([0x01; 20]),
+            anchored_block_hash: BlockHeaderHash([0x01; 32]),
+            parent_consensus_hash: ConsensusHash([0x00; 20]),
+            parent_anchored_block_hash: BlockHeaderHash([0x00; 32]),
+            burn_height: 100,
+            num_earlier_siblings: 0,
+        },
+        TipCandidate {
+            stacks_height: 2,
+            consensus_hash: ConsensusHash([0x02; 20]),
+            anchored_block_hash: BlockHeaderHash([0x02; 32]),
+            parent_consensus_hash: ConsensusHash([0x01; 20]),
+            parent_anchored_block_hash: BlockHeaderHash([0x01; 32]),
+            burn_height: 102,
+            num_earlier_siblings: 0,
+        },
+        TipCandidate {
+            stacks_height: 2,
+            consensus_hash: ConsensusHash([0x12; 20]),
+            anchored_block_hash: BlockHeaderHash([0x12; 32]),
+            parent_consensus_hash: ConsensusHash([0x01; 20]),
+            parent_anchored_block_hash: BlockHeaderHash([0x01; 32]),
+            burn_height: 101,
+            num_earlier_siblings: 0,
+        },
+        TipCandidate {
+            stacks_height: 2,
+            consensus_hash: ConsensusHash([0x22; 20]),
+            anchored_block_hash: BlockHeaderHash([0x22; 32]),
+            parent_consensus_hash: ConsensusHash([0x01; 20]),
+            parent_anchored_block_hash: BlockHeaderHash([0x01; 32]),
+            burn_height: 104,
+            num_earlier_siblings: 0,
+        },
+        TipCandidate {
+            stacks_height: 4,
+            consensus_hash: ConsensusHash([0x04; 20]),
+            anchored_block_hash: BlockHeaderHash([0x04; 32]),
+            parent_consensus_hash: ConsensusHash([0x03; 20]),
+            parent_anchored_block_hash: BlockHeaderHash([0x03; 32]),
+            burn_height: 105,
+            num_earlier_siblings: 0,
+        },
+        TipCandidate {
+            stacks_height: 3,
+            consensus_hash: ConsensusHash([0x03; 20]),
+            anchored_block_hash: BlockHeaderHash([0x03; 32]),
+            parent_consensus_hash: ConsensusHash([0x02; 20]),
+            parent_anchored_block_hash: BlockHeaderHash([0x02; 32]),
+            burn_height: 105,
+            num_earlier_siblings: 0,
+        },
+    ];
+    let sorted_candidates = BlockMinerThread::sort_and_populate_candidates(candidates);
+    assert_eq!(
+        sorted_candidates,
+        vec![
+            TipCandidate {
+                stacks_height: 1,
+                consensus_hash: ConsensusHash([0x01; 20]),
+                anchored_block_hash: BlockHeaderHash([0x01; 32]),
+                parent_consensus_hash: ConsensusHash([0x00; 20]),
+                parent_anchored_block_hash: BlockHeaderHash([0x00; 32]),
+                burn_height: 100,
+                num_earlier_siblings: 0
+            },
+            TipCandidate {
+                stacks_height: 2,
+                consensus_hash: ConsensusHash([0x12; 20]),
+                anchored_block_hash: BlockHeaderHash([0x12; 32]),
+                parent_consensus_hash: ConsensusHash([0x01; 20]),
+                parent_anchored_block_hash: BlockHeaderHash([0x01; 32]),
+                burn_height: 101,
+                num_earlier_siblings: 0
+            },
+            TipCandidate {
+                stacks_height: 2,
+                consensus_hash: ConsensusHash([0x02; 20]),
+                anchored_block_hash: BlockHeaderHash([0x02; 32]),
+                parent_consensus_hash: ConsensusHash([0x01; 20]),
+                parent_anchored_block_hash: BlockHeaderHash([0x01; 32]),
+                burn_height: 102,
+                num_earlier_siblings: 1
+            },
+            TipCandidate {
+                stacks_height: 2,
+                consensus_hash: ConsensusHash([0x22; 20]),
+                anchored_block_hash: BlockHeaderHash([0x22; 32]),
+                parent_consensus_hash: ConsensusHash([0x01; 20]),
+                parent_anchored_block_hash: BlockHeaderHash([0x01; 32]),
+                burn_height: 104,
+                num_earlier_siblings: 2
+            },
+            TipCandidate {
+                stacks_height: 3,
+                consensus_hash: ConsensusHash([0x03; 20]),
+                anchored_block_hash: BlockHeaderHash([0x03; 32]),
+                parent_consensus_hash: ConsensusHash([0x02; 20]),
+                parent_anchored_block_hash: BlockHeaderHash([0x02; 32]),
+                burn_height: 105,
+                num_earlier_siblings: 0
+            },
+            TipCandidate {
+                stacks_height: 4,
+                consensus_hash: ConsensusHash([0x04; 20]),
+                anchored_block_hash: BlockHeaderHash([0x04; 32]),
+                parent_consensus_hash: ConsensusHash([0x03; 20]),
+                parent_anchored_block_hash: BlockHeaderHash([0x03; 32]),
+                burn_height: 105,
+                num_earlier_siblings: 0
+            }
+        ]
+    );
+}
+
+#[test]
+fn test_inner_pick_best_tip() {
+    // chain structure as folows:
+    //
+    // Bitcoin chain
+    // 100  101  102  103  104  105  106
+    //  |    |    |         |    |    |
+    // Stacks chain         |    |    |
+    //  1 <- 2    |         |.-- 3 <- 4
+    //    \       |         /
+    //     *----- 2 <------*|
+    //      \               |
+    //       *--------------2
+    //
+    // If there are no previous best-tips, then:
+    // At Bitcoin height 105, the best tip is (4,105)
+    // At Bitcoin height 104, the best tip is (3,104)
+    // At Bitcoin height 103, the best tip is (2,101)
+    // At Bitcoin height 102, the best tip is (2,101)
+    // At Bitcoin height 101, the best tip is (2,101)
+    // At Bitcoin height 100, the best tip is (1,100)
+    //
+    let candidates = vec![
+        TipCandidate {
+            stacks_height: 1,
+            consensus_hash: ConsensusHash([0x01; 20]),
+            anchored_block_hash: BlockHeaderHash([0x01; 32]),
+            parent_consensus_hash: ConsensusHash([0x00; 20]),
+            parent_anchored_block_hash: BlockHeaderHash([0x00; 32]),
+            burn_height: 100,
+            num_earlier_siblings: 0,
+        },
+        TipCandidate {
+            stacks_height: 2,
+            consensus_hash: ConsensusHash([0x02; 20]),
+            anchored_block_hash: BlockHeaderHash([0x02; 32]),
+            parent_consensus_hash: ConsensusHash([0x01; 20]),
+            parent_anchored_block_hash: BlockHeaderHash([0x01; 32]),
+            burn_height: 102,
+            num_earlier_siblings: 0,
+        },
+        TipCandidate {
+            stacks_height: 2,
+            consensus_hash: ConsensusHash([0x12; 20]),
+            anchored_block_hash: BlockHeaderHash([0x12; 32]),
+            parent_consensus_hash: ConsensusHash([0x01; 20]),
+            parent_anchored_block_hash: BlockHeaderHash([0x01; 32]),
+            burn_height: 101,
+            num_earlier_siblings: 0,
+        },
+        TipCandidate {
+            stacks_height: 2,
+            consensus_hash: ConsensusHash([0x22; 20]),
+            anchored_block_hash: BlockHeaderHash([0x22; 32]),
+            parent_consensus_hash: ConsensusHash([0x01; 20]),
+            parent_anchored_block_hash: BlockHeaderHash([0x01; 32]),
+            burn_height: 104,
+            num_earlier_siblings: 0,
+        },
+        TipCandidate {
+            stacks_height: 4,
+            consensus_hash: ConsensusHash([0x04; 20]),
+            anchored_block_hash: BlockHeaderHash([0x04; 32]),
+            parent_consensus_hash: ConsensusHash([0x03; 20]),
+            parent_anchored_block_hash: BlockHeaderHash([0x03; 32]),
+            burn_height: 106,
+            num_earlier_siblings: 0,
+        },
+        TipCandidate {
+            stacks_height: 3,
+            consensus_hash: ConsensusHash([0x03; 20]),
+            anchored_block_hash: BlockHeaderHash([0x03; 32]),
+            parent_consensus_hash: ConsensusHash([0x02; 20]),
+            parent_anchored_block_hash: BlockHeaderHash([0x02; 32]),
+            burn_height: 105,
+            num_earlier_siblings: 0,
+        },
+    ];
+
+    let sorted_candidates = BlockMinerThread::sort_and_populate_candidates(candidates.clone());
+    assert_eq!(
+        None,
+        BlockMinerThread::inner_pick_best_tip(vec![], HashMap::new())
+    );
+    assert_eq!(
+        Some(sorted_candidates[5].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates.clone(), HashMap::new())
+    );
+    assert_eq!(
+        Some(sorted_candidates[0].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..1].to_vec(), HashMap::new())
+    );
+    assert_eq!(
+        Some(sorted_candidates[1].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..2].to_vec(), HashMap::new())
+    );
+    assert_eq!(
+        Some(sorted_candidates[1].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..3].to_vec(), HashMap::new())
+    );
+    assert_eq!(
+        Some(sorted_candidates[1].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..4].to_vec(), HashMap::new())
+    );
+    assert_eq!(
+        Some(sorted_candidates[4].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..5].to_vec(), HashMap::new())
+    );
+
+    // suppose now that we previously picked (2,104) as the best-tip.
+    // No other tips at Stacks height 2 will be accepted, nor will those at heights 3 and 4 (since
+    // they descend from the wrong height-2 block).
+    let mut best_tips = HashMap::new();
+    best_tips.insert(2, sorted_candidates[3].clone());
+
+    assert_eq!(
+        Some(sorted_candidates[3].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates.clone(), best_tips.clone())
+    );
+    assert_eq!(
+        Some(sorted_candidates[0].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..1].to_vec(), best_tips.clone())
+    );
+    assert_eq!(
+        None,
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..2].to_vec(), best_tips.clone())
+    );
+    assert_eq!(
+        None,
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..3].to_vec(), best_tips.clone())
+    );
+    assert_eq!(
+        Some(sorted_candidates[3].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..4].to_vec(), best_tips.clone())
+    );
+    assert_eq!(
+        Some(sorted_candidates[3].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..5].to_vec(), best_tips.clone())
+    );
+
+    // now suppose that we previously picked (2,102) as the best-tip.
+    // Conflicting blocks are (2,101) and (2,104)
+    let mut best_tips = HashMap::new();
+    best_tips.insert(2, sorted_candidates[2].clone());
+
+    assert_eq!(
+        Some(sorted_candidates[5].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates.clone(), best_tips.clone())
+    );
+    assert_eq!(
+        Some(sorted_candidates[0].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..1].to_vec(), best_tips.clone())
+    );
+    assert_eq!(
+        None,
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..2].to_vec(), best_tips.clone())
+    );
+    assert_eq!(
+        Some(sorted_candidates[2].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..3].to_vec(), best_tips.clone())
+    );
+    assert_eq!(
+        Some(sorted_candidates[2].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..4].to_vec(), best_tips.clone())
+    );
+    assert_eq!(
+        Some(sorted_candidates[4].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..5].to_vec(), best_tips.clone())
+    );
+
+    // now suppose that we previously picked both (2,101) and (3,105) as the best-tips.
+    // these best-tips are in conflict, but that shouldn't prohibit us from choosing (4,106) as the
+    // best tip even though it doesn't confirm (2,101).  However, it would mean that (2,102) and
+    // (2,104) are in conflict.
+    let mut best_tips = HashMap::new();
+    best_tips.insert(2, sorted_candidates[1].clone());
+    best_tips.insert(3, sorted_candidates[4].clone());
+
+    assert_eq!(
+        Some(sorted_candidates[5].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates.clone(), best_tips.clone())
+    );
+    assert_eq!(
+        Some(sorted_candidates[0].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..1].to_vec(), best_tips.clone())
+    );
+    assert_eq!(
+        Some(sorted_candidates[1].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..2].to_vec(), best_tips.clone())
+    );
+    assert_eq!(
+        Some(sorted_candidates[1].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..3].to_vec(), best_tips.clone())
+    );
+    assert_eq!(
+        Some(sorted_candidates[1].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..4].to_vec(), best_tips.clone())
+    );
+    assert_eq!(
+        Some(sorted_candidates[1].clone()),
+        BlockMinerThread::inner_pick_best_tip(sorted_candidates[0..5].to_vec(), best_tips.clone())
+    );
+}
diff --git a/testnet/stacks-node/src/tests/neon_integrations.rs b/testnet/stacks-node/src/tests/neon_integrations.rs
index 678365a0b1..02639255e0 100644
--- a/testnet/stacks-node/src/tests/neon_integrations.rs
+++ b/testnet/stacks-node/src/tests/neon_integrations.rs
@@ -1,83 +1,61 @@
-use std::cmp;
-use std::fs;
+use std::collections::{HashMap, HashSet};
+use std::convert::TryFrom;
 use std::path::Path;
-use std::sync::mpsc;
-use std::sync::Arc;
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::{mpsc, Arc};
 use std::time::{Duration, Instant};
-use std::{
-    collections::HashMap,
-    collections::HashSet,
-    sync::atomic::{AtomicU64, Ordering},
-};
-use std::{env, thread};
+use std::{cmp, env, fs, thread};
 
+use clarity::vm::ast::stack_depth_checker::AST_CALL_STACK_DEPTH_BUFFER;
+use clarity::vm::ast::ASTRules;
+use clarity::vm::MAX_CALL_STACK_DEPTH;
+use rand::Rng;
 use rusqlite::types::ToSql;
-
 use stacks::burnchains::bitcoin::address::{BitcoinAddress, LegacyBitcoinAddressType};
 use stacks::burnchains::bitcoin::BitcoinNetworkType;
-use stacks::burnchains::Txid;
+use stacks::burnchains::db::BurnchainDB;
+use stacks::burnchains::{Address, Burnchain, PoxConstants, Txid};
+use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::burn::operations::{
     BlockstackOperationType, DelegateStxOp, PreStxOp, TransferStxOp,
 };
+use stacks::chainstate::burn::ConsensusHash;
 use stacks::chainstate::coordinator::comm::CoordinatorChannels;
+use stacks::chainstate::stacks::db::StacksChainState;
+use stacks::chainstate::stacks::miner::{
+    signal_mining_blocked, signal_mining_ready, TransactionErrorEvent, TransactionEvent,
+    TransactionSuccessEvent,
+};
+use stacks::chainstate::stacks::{
+    StacksBlock, StacksBlockHeader, StacksMicroblock, StacksMicroblockHeader, StacksPrivateKey,
+    StacksPublicKey, StacksTransaction, TransactionContractCall, TransactionPayload,
+};
 use stacks::clarity_cli::vm_execute as execute;
 use stacks::codec::StacksMessageCodec;
 use stacks::core;
 use stacks::core::{
-    StacksEpoch, StacksEpochId, BLOCK_LIMIT_MAINNET_20, BLOCK_LIMIT_MAINNET_205,
-    BLOCK_LIMIT_MAINNET_21, CHAIN_ID_TESTNET, HELIUM_BLOCK_LIMIT_20, PEER_VERSION_EPOCH_1_0,
-    PEER_VERSION_EPOCH_2_0, PEER_VERSION_EPOCH_2_05, PEER_VERSION_EPOCH_2_1,
+    mempool::MemPoolWalkTxTypes, StacksEpoch, StacksEpochId, BLOCK_LIMIT_MAINNET_20,
+    BLOCK_LIMIT_MAINNET_205, BLOCK_LIMIT_MAINNET_21, CHAIN_ID_TESTNET, HELIUM_BLOCK_LIMIT_20,
+    PEER_VERSION_EPOCH_1_0, PEER_VERSION_EPOCH_2_0, PEER_VERSION_EPOCH_2_05,
+    PEER_VERSION_EPOCH_2_1,
 };
 use stacks::net::atlas::{AtlasConfig, AtlasDB, MAX_ATTACHMENT_INV_PAGES_PER_REQUEST};
 use stacks::net::{
     AccountEntryResponse, ContractSrcResponse, GetAttachmentResponse, GetAttachmentsInvResponse,
-    PostTransactionRequestBody, RPCPeerInfoData, StacksBlockAcceptedData,
-    UnconfirmedTransactionResponse,
+    PostTransactionRequestBody, RPCFeeEstimateResponse, RPCPeerInfoData, RPCPoxInfoData,
+    StacksBlockAcceptedData, UnconfirmedTransactionResponse,
 };
 use stacks::types::chainstate::{
     BlockHeaderHash, BurnchainHeaderHash, StacksAddress, StacksBlockId,
 };
-use stacks::util::hash::Hash160;
-use stacks::util::hash::{bytes_to_hex, hex_bytes, to_hex};
+use stacks::util::hash::{bytes_to_hex, hex_bytes, to_hex, Hash160};
 use stacks::util::secp256k1::Secp256k1PublicKey;
 use stacks::util::{get_epoch_time_ms, get_epoch_time_secs, sleep_ms};
 use stacks::util_lib::boot::boot_code_id;
+use stacks::util_lib::db::{query_row_columns, query_rows, u64_to_sql};
+use stacks::vm::costs::ExecutionCost;
 use stacks::vm::types::PrincipalData;
-use stacks::vm::ClarityVersion;
-use stacks::vm::Value;
-use stacks::{
-    burnchains::db::BurnchainDB,
-    chainstate::{burn::ConsensusHash, stacks::StacksMicroblock},
-};
-use stacks::{
-    burnchains::{Address, Burnchain, PoxConstants},
-    vm::costs::ExecutionCost,
-};
-use stacks::{
-    chainstate::stacks::{
-        db::StacksChainState, StacksBlock, StacksBlockHeader, StacksMicroblockHeader,
-        StacksPrivateKey, StacksPublicKey, StacksTransaction, TransactionContractCall,
-        TransactionPayload,
-    },
-    net::RPCPoxInfoData,
-    util_lib::db::query_row_columns,
-    util_lib::db::query_rows,
-    util_lib::db::u64_to_sql,
-};
-
-use crate::{
-    burnchains::bitcoin_regtest_controller::UTXO, config::EventKeyType,
-    config::EventObserverConfig, config::InitialBalance, neon, operations::BurnchainOpSigner,
-    syncctl::PoxSyncWatchdogComms, BitcoinRegtestController, BurnchainController, Config,
-    ConfigFile, Keychain,
-};
-
-use crate::util::hash::{MerkleTree, Sha512Trunc256Sum};
-use crate::util::secp256k1::MessageSignature;
-
-use crate::neon_node::StacksNode;
-
-use rand::Rng;
+use stacks::vm::{ClarityName, ClarityVersion, ContractName, Value};
 
 use super::bitcoin_regtest::BitcoinCoreController;
 use super::{
@@ -85,23 +63,16 @@ use super::{
     make_microblock, make_stacks_transfer, make_stacks_transfer_mblock_only, to_addr, ADDR_4, SK_1,
     SK_2,
 };
-
-use crate::config::FeeEstimatorName;
-use crate::tests::SK_3;
-use clarity::vm::ast::stack_depth_checker::AST_CALL_STACK_DEPTH_BUFFER;
-use clarity::vm::ast::ASTRules;
-use clarity::vm::MAX_CALL_STACK_DEPTH;
-use stacks::chainstate::burn::db::sortdb::SortitionDB;
-use stacks::chainstate::stacks::miner::{
-    signal_mining_blocked, signal_mining_ready, TransactionErrorEvent, TransactionEvent,
-    TransactionSuccessEvent,
-};
-use stacks::net::RPCFeeEstimateResponse;
-use stacks::vm::ClarityName;
-use stacks::vm::ContractName;
-use std::convert::TryFrom;
-
+use crate::burnchains::bitcoin_regtest_controller::UTXO;
+use crate::config::{EventKeyType, EventObserverConfig, FeeEstimatorName, InitialBalance};
+use crate::neon_node::{RelayerThread, StacksNode};
+use crate::operations::BurnchainOpSigner;
 use crate::stacks_common::types::PrivateKey;
+use crate::syncctl::PoxSyncWatchdogComms;
+use crate::tests::SK_3;
+use crate::util::hash::{MerkleTree, Sha512Trunc256Sum};
+use crate::util::secp256k1::MessageSignature;
+use crate::{neon, BitcoinRegtestController, BurnchainController, Config, ConfigFile, Keychain};
 
 fn inner_neon_integration_test_conf(seed: Option<Vec<u8>>) -> (Config, StacksAddress) {
     let mut conf = super::new_test_conf();
@@ -170,7 +141,6 @@ fn inner_neon_integration_test_conf(seed: Option<Vec<u8>>) -> (Config, StacksAdd
     conf.burnchain.poll_time_secs = 1;
     conf.node.pox_sync_sample_secs = 0;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -201,9 +171,8 @@ pub mod test_observer {
     use std::sync::Mutex;
     use std::thread;
 
-    use tokio;
-    use warp;
     use warp::Filter;
+    use {tokio, warp};
 
     use crate::event_dispatcher::{MinedBlockEvent, MinedMicroblockEvent};
 
@@ -2339,7 +2308,6 @@ fn microblock_fork_poison_integration_test() {
     conf.miner.subsequent_attempt_time_ms = 5_000;
     conf.node.wait_time_for_blocks = 1_000;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -3087,9 +3055,6 @@ fn filter_low_fee_tx_integration_test() {
         });
     }
 
-    // exclude the first 5 transactions from miner consideration
-    conf.miner.min_tx_fee = 1500;
-
     let mut btcd_controller = BitcoinCoreController::new(conf.clone());
     btcd_controller
         .start_bitcoind()
@@ -3177,9 +3142,6 @@ fn filter_long_runtime_tx_integration_test() {
         });
     }
 
-    // all transactions have high-enough fees...
-    conf.miner.min_tx_fee = 1;
-
     // ...but none of them will be mined since we allot zero ms to do so
     conf.miner.first_attempt_time_ms = 0;
     conf.miner.subsequent_attempt_time_ms = 0;
@@ -3258,8 +3220,6 @@ fn miner_submit_twice() {
         amount: 1049230,
     });
 
-    // all transactions have high-enough fees...
-    conf.miner.min_tx_fee = 1;
     conf.node.mine_microblocks = false;
     // one should be mined in first attempt, and two should be in second attempt
     conf.miner.first_attempt_time_ms = 20;
@@ -3379,7 +3339,6 @@ fn size_check_integration_test() {
     conf.node.microblock_frequency = 5000;
     conf.miner.microblock_attempt_time_ms = 120_000;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -3556,7 +3515,6 @@ fn size_overflow_unconfirmed_microblocks_integration_test() {
     conf.node.microblock_frequency = 5_000;
     conf.miner.microblock_attempt_time_ms = 120_000;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -3753,7 +3711,6 @@ fn size_overflow_unconfirmed_stream_microblocks_integration_test() {
     conf.node.max_microblocks = 65536;
     conf.burnchain.max_rbf = 1000000;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -3948,7 +3905,6 @@ fn size_overflow_unconfirmed_invalid_stream_microblocks_integration_test() {
     epochs[1].block_limit = core::BLOCK_LIMIT_MAINNET_20;
     conf.burnchain.epochs = Some(epochs);
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -4211,7 +4167,6 @@ fn runtime_overflow_unconfirmed_microblocks_integration_test() {
     conf.node.microblock_frequency = 15000;
     conf.miner.microblock_attempt_time_ms = 120_000;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -4387,7 +4342,6 @@ fn block_replay_integration_test() {
     conf.node.wait_time_for_microblocks = 30000;
     conf.node.microblock_frequency = 5_000;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -4838,7 +4792,6 @@ fn mining_events_integration_test() {
     conf.node.wait_time_for_microblocks = 1000;
     conf.node.microblock_frequency = 1000;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -5110,7 +5063,6 @@ fn block_limit_hit_integration_test() {
     conf.node.wait_time_for_microblocks = 30000;
     conf.node.microblock_frequency = 1000;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -5328,7 +5280,6 @@ fn microblock_limit_hit_integration_test() {
     conf.burnchain.max_rbf = 10_000_000;
     conf.node.wait_time_for_blocks = 1_000;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -5540,7 +5491,6 @@ fn block_large_tx_integration_test() {
     conf.burnchain.max_rbf = 10_000_000;
     conf.node.wait_time_for_blocks = 1_000;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -5675,7 +5625,6 @@ fn microblock_large_tx_integration_test_FLAKY() {
     conf.node.wait_time_for_microblocks = 30000;
     conf.node.microblock_frequency = 1000;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 
@@ -10754,3 +10703,336 @@ fn microblock_miner_multiple_attempts() {
 
     channel.stop_chains_coordinator();
 }
+
+#[test]
+#[ignore]
+fn min_txs() {
+    if env::var("BITCOIND_TEST") != Ok("1".into()) {
+        return;
+    }
+
+    let spender_sk = StacksPrivateKey::new();
+    let spender_addr = to_addr(&spender_sk);
+    let spender_princ: PrincipalData = spender_addr.into();
+
+    let (mut conf, _miner_account) = neon_integration_test_conf();
+
+    test_observer::spawn();
+
+    conf.events_observers.push(EventObserverConfig {
+        endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
+        events_keys: vec![EventKeyType::AnyEvent],
+    });
+
+    conf.miner.min_tx_count = 4;
+    conf.miner.first_attempt_time_ms = 0;
+    conf.miner.activated_vrf_key_path = Some("/tmp/activate_vrf_key.min_txs.json".to_string());
+
+    if fs::metadata("/tmp/activate_vrf_key.min_txs.json").is_ok() {
+        fs::remove_file("/tmp/activate_vrf_key.min_txs.json").unwrap();
+    }
+
+    let spender_bal = 10_000_000_000 * (core::MICROSTACKS_PER_STACKS as u64);
+
+    conf.initial_balances.push(InitialBalance {
+        address: spender_princ.clone(),
+        amount: spender_bal,
+    });
+
+    let mut btcd_controller = BitcoinCoreController::new(conf.clone());
+    btcd_controller
+        .start_bitcoind()
+        .map_err(|_e| ())
+        .expect("Failed starting bitcoind");
+
+    let burnchain_config = Burnchain::regtest(&conf.get_burn_db_path());
+
+    let mut btc_regtest_controller = BitcoinRegtestController::with_burnchain(
+        conf.clone(),
+        None,
+        Some(burnchain_config.clone()),
+        None,
+    );
+    let http_origin = format!("http://{}", &conf.node.rpc_bind);
+
+    btc_regtest_controller.bootstrap_chain(201);
+
+    eprintln!("Chain bootstrapped...");
+
+    let mut run_loop = neon::RunLoop::new(conf.clone());
+    let blocks_processed = run_loop.get_blocks_processed_arc();
+    let _client = reqwest::blocking::Client::new();
+    let channel = run_loop.get_coordinator_channel().unwrap();
+
+    thread::spawn(move || run_loop.start(Some(burnchain_config), 0));
+
+    // give the run loop some time to start up!
+    wait_for_runloop(&blocks_processed);
+
+    // first block wakes up the run loop
+    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+
+    // first block will hold our VRF registration
+    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+
+    // second block will be the first mined Stacks block
+    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+
+    let _sort_height = channel.get_sortitions_processed();
+
+    for i in 0..2 {
+        let code = format!("(print \"hello world {}\")", i);
+        let publish = make_contract_publish(
+            &spender_sk,
+            i as u64,
+            1000,
+            &format!("test-publish-{}", &i),
+            &code,
+        );
+        submit_tx(&http_origin, &publish);
+
+        debug!("Try to build too-small a block {}", &i);
+        next_block_and_wait_with_timeout(&mut btc_regtest_controller, &blocks_processed, 15);
+    }
+
+    let blocks = test_observer::get_blocks();
+    for block in blocks {
+        let transactions = block.get("transactions").unwrap().as_array().unwrap();
+        if transactions.len() > 1 {
+            debug!("Got block: {:?}", &block);
+            assert!(transactions.len() >= 4);
+        }
+    }
+
+    let saved_vrf_key = RelayerThread::load_saved_vrf_key("/tmp/activate_vrf_key.min_txs.json");
+    assert!(saved_vrf_key.is_some());
+
+    test_observer::clear();
+}
+
+#[test]
+#[ignore]
+fn filter_txs_by_type() {
+    if env::var("BITCOIND_TEST") != Ok("1".into()) {
+        return;
+    }
+
+    let spender_sk = StacksPrivateKey::new();
+    let spender_addr = to_addr(&spender_sk);
+    let spender_princ: PrincipalData = spender_addr.into();
+
+    let (mut conf, _miner_account) = neon_integration_test_conf();
+
+    test_observer::spawn();
+
+    conf.events_observers.push(EventObserverConfig {
+        endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
+        events_keys: vec![EventKeyType::AnyEvent],
+    });
+
+    conf.miner.min_tx_count = 4;
+    conf.miner.first_attempt_time_ms = 0;
+    conf.miner.activated_vrf_key_path = Some("/tmp/activate_vrf_key.filter_txs.json".to_string());
+    conf.miner.txs_to_consider = [MemPoolWalkTxTypes::TokenTransfer].into_iter().collect();
+
+    if fs::metadata("/tmp/activate_vrf_key.filter_txs.json").is_ok() {
+        fs::remove_file("/tmp/activate_vrf_key.filter_txs.json").unwrap();
+    }
+
+    let spender_bal = 10_000_000_000 * (core::MICROSTACKS_PER_STACKS as u64);
+
+    conf.initial_balances.push(InitialBalance {
+        address: spender_princ.clone(),
+        amount: spender_bal,
+    });
+
+    let mut btcd_controller = BitcoinCoreController::new(conf.clone());
+    btcd_controller
+        .start_bitcoind()
+        .map_err(|_e| ())
+        .expect("Failed starting bitcoind");
+
+    let burnchain_config = Burnchain::regtest(&conf.get_burn_db_path());
+
+    let mut btc_regtest_controller = BitcoinRegtestController::with_burnchain(
+        conf.clone(),
+        None,
+        Some(burnchain_config.clone()),
+        None,
+    );
+    let http_origin = format!("http://{}", &conf.node.rpc_bind);
+
+    btc_regtest_controller.bootstrap_chain(201);
+
+    eprintln!("Chain bootstrapped...");
+
+    let mut run_loop = neon::RunLoop::new(conf.clone());
+    let blocks_processed = run_loop.get_blocks_processed_arc();
+    let _client = reqwest::blocking::Client::new();
+    let channel = run_loop.get_coordinator_channel().unwrap();
+
+    thread::spawn(move || run_loop.start(Some(burnchain_config), 0));
+
+    // give the run loop some time to start up!
+    wait_for_runloop(&blocks_processed);
+
+    // first block wakes up the run loop
+    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+
+    // first block will hold our VRF registration
+    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+
+    // second block will be the first mined Stacks block
+    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+
+    let _sort_height = channel.get_sortitions_processed();
+    let mut sent_txids = HashSet::new();
+    for i in 0..2 {
+        let code = format!("(print \"hello world {}\")", i);
+        let publish = make_contract_publish(
+            &spender_sk,
+            i as u64,
+            1000,
+            &format!("test-publish-{}", &i),
+            &code,
+        );
+        let parsed = StacksTransaction::consensus_deserialize(&mut &publish[..]).unwrap();
+        sent_txids.insert(parsed.txid());
+
+        submit_tx(&http_origin, &publish);
+        next_block_and_wait_with_timeout(&mut btc_regtest_controller, &blocks_processed, 15);
+    }
+
+    let blocks = test_observer::get_blocks();
+    for block in blocks {
+        info!("block: {:?}", &block);
+        let transactions = block.get("transactions").unwrap().as_array().unwrap();
+        for tx in transactions {
+            let raw_tx = tx.get("raw_tx").unwrap().as_str().unwrap();
+            if raw_tx == "0x00" {
+                continue;
+            }
+            let tx_bytes = hex_bytes(&raw_tx[2..]).unwrap();
+            let parsed = StacksTransaction::consensus_deserialize(&mut &tx_bytes[..]).unwrap();
+            if sent_txids.contains(&parsed.txid()) {
+                panic!("Included a smart contract");
+            }
+        }
+    }
+
+    let saved_vrf_key = RelayerThread::load_saved_vrf_key("/tmp/activate_vrf_key.filter_txs.json");
+    assert!(saved_vrf_key.is_some());
+
+    test_observer::clear();
+}
+
+#[test]
+#[ignore]
+fn filter_txs_by_origin() {
+    if env::var("BITCOIND_TEST") != Ok("1".into()) {
+        return;
+    }
+
+    let spender_sk = StacksPrivateKey::new();
+    let spender_addr = to_addr(&spender_sk);
+    let spender_princ: PrincipalData = spender_addr.into();
+
+    let (mut conf, _miner_account) = neon_integration_test_conf();
+
+    test_observer::spawn();
+
+    conf.events_observers.push(EventObserverConfig {
+        endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
+        events_keys: vec![EventKeyType::AnyEvent],
+    });
+
+    conf.miner.min_tx_count = 4;
+    conf.miner.first_attempt_time_ms = 0;
+    conf.miner.filter_origins =
+        [StacksAddress::from_string("STA2MZWV9N67TBYVWTE0PSSKMJ2F6YXW7DX96QAM").unwrap()]
+            .into_iter()
+            .collect();
+
+    let spender_bal = 10_000_000_000 * (core::MICROSTACKS_PER_STACKS as u64);
+
+    conf.initial_balances.push(InitialBalance {
+        address: spender_princ.clone(),
+        amount: spender_bal,
+    });
+
+    let mut btcd_controller = BitcoinCoreController::new(conf.clone());
+    btcd_controller
+        .start_bitcoind()
+        .map_err(|_e| ())
+        .expect("Failed starting bitcoind");
+
+    let burnchain_config = Burnchain::regtest(&conf.get_burn_db_path());
+
+    let mut btc_regtest_controller = BitcoinRegtestController::with_burnchain(
+        conf.clone(),
+        None,
+        Some(burnchain_config.clone()),
+        None,
+    );
+    let http_origin = format!("http://{}", &conf.node.rpc_bind);
+
+    btc_regtest_controller.bootstrap_chain(201);
+
+    eprintln!("Chain bootstrapped...");
+
+    let mut run_loop = neon::RunLoop::new(conf.clone());
+    let blocks_processed = run_loop.get_blocks_processed_arc();
+    let _client = reqwest::blocking::Client::new();
+    let channel = run_loop.get_coordinator_channel().unwrap();
+
+    thread::spawn(move || run_loop.start(Some(burnchain_config), 0));
+
+    // give the run loop some time to start up!
+    wait_for_runloop(&blocks_processed);
+
+    // first block wakes up the run loop
+    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+
+    // first block will hold our VRF registration
+    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+
+    // second block will be the first mined Stacks block
+    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+
+    let _sort_height = channel.get_sortitions_processed();
+    let mut sent_txids = HashSet::new();
+    for i in 0..2 {
+        let code = format!("(print \"hello world {}\")", i);
+        let publish = make_contract_publish(
+            &spender_sk,
+            i as u64,
+            1000,
+            &format!("test-publish-{}", &i),
+            &code,
+        );
+        let parsed = StacksTransaction::consensus_deserialize(&mut &publish[..]).unwrap();
+        sent_txids.insert(parsed.txid());
+
+        submit_tx(&http_origin, &publish);
+        next_block_and_wait_with_timeout(&mut btc_regtest_controller, &blocks_processed, 15);
+    }
+
+    let blocks = test_observer::get_blocks();
+    for block in blocks {
+        info!("block: {:?}", &block);
+        let transactions = block.get("transactions").unwrap().as_array().unwrap();
+        for tx in transactions {
+            let raw_tx = tx.get("raw_tx").unwrap().as_str().unwrap();
+            if raw_tx == "0x00" {
+                continue;
+            }
+            let tx_bytes = hex_bytes(&raw_tx[2..]).unwrap();
+            let parsed = StacksTransaction::consensus_deserialize(&mut &tx_bytes[..]).unwrap();
+            if sent_txids.contains(&parsed.txid()) {
+                panic!("Included a smart contract");
+            }
+        }
+    }
+
+    test_observer::clear();
+}

From 1b9ac8373c94669c779cf9fcf6dfa519cac2e13d Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Thu, 18 Jan 2024 09:54:21 -0600
Subject: [PATCH 0392/1166] initial commit of bitvec struct

---
 stacks-common/src/bitvec.rs    | 195 +++++++++++++++++++++++++++++++++
 stacks-common/src/libcommon.rs |   2 +
 2 files changed, 197 insertions(+)
 create mode 100644 stacks-common/src/bitvec.rs

diff --git a/stacks-common/src/bitvec.rs b/stacks-common/src/bitvec.rs
new file mode 100644
index 0000000000..991aba63d6
--- /dev/null
+++ b/stacks-common/src/bitvec.rs
@@ -0,0 +1,195 @@
+use crate::codec::{
+    read_next, read_next_exact, write_next, Error as CodecError, StacksMessageCodec,
+};
+
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct BitVec {
+    data: Vec<u8>,
+    len: u16,
+}
+
+impl TryFrom<&[bool]> for BitVec {
+    type Error = String;
+
+    fn try_from(value: &[bool]) -> Result<Self, Self::Error> {
+        let len = value
+            .len()
+            .try_into()
+            .map_err(|_| "BitVec length must be u16")?;
+        if len == 0 {
+            return Err("BitVec length must be positive".into());
+        }
+        let mut bitvec = BitVec::zeros(len);
+        for (ix, bool_value) in value.iter().enumerate() {
+            let ix = ix.try_into().map_err(|_| "BitVec length must be u16")?;
+            // only need to set the bitvec value if `bool_value` is true,
+            // because we initialized with zeros
+            if *bool_value {
+                bitvec.set(ix, true)?;
+            }
+        }
+        Ok(bitvec)
+    }
+}
+
+impl StacksMessageCodec for BitVec {
+    fn consensus_serialize<W: std::io::Write>(&self, fd: &mut W) -> Result<(), CodecError> {
+        write_next(fd, &self.len)?;
+        write_next(fd, &self.data)
+    }
+
+    fn consensus_deserialize<R: std::io::Read>(fd: &mut R) -> Result<Self, CodecError> {
+        let len = read_next(fd)?;
+        if len == 0 {
+            return Err(CodecError::DeserializeError(
+                "BitVec lengths must be positive".to_string(),
+            ));
+        }
+
+        let data = read_next_exact(fd, Self::data_len(len).into())?;
+        Ok(BitVec { data, len })
+    }
+}
+
+impl BitVec {
+    /// Construct a new BitVec with all entries set to `false` and total length `len`
+    pub fn zeros(len: u16) -> BitVec {
+        let data = vec![0; usize::from(Self::data_len(len))];
+        BitVec { data, len }
+    }
+
+    pub fn len(&self) -> u16 {
+        self.len
+    }
+
+    fn data_len(len: u16) -> u16 {
+        len / 8 + if len % 8 == 0 { 0 } else { 1 }
+    }
+
+    /// Get a u8 with the (index % 8)th bit set to 1.
+    fn bit_index(index: u16) -> u8 {
+        1 << u8::try_from(index % 8).expect("FATAL: remainder 8 returned a non-u8 value")
+    }
+
+    pub fn get(&self, i: u16) -> Option<bool> {
+        if i >= self.len {
+            return None;
+        }
+        let vec_index = usize::from(i / 8);
+        let byte = self.data.get(vec_index)?;
+        let bit_index = Self::bit_index(i);
+        Some((*byte & bit_index) != 0)
+    }
+
+    pub fn set(&mut self, i: u16, val: bool) -> Result<(), String> {
+        if i >= self.len {
+            return Err(format!(
+                "Index `{i}` outside of bitvec length `{}`",
+                self.len
+            ));
+        }
+        let vec_index = usize::from(i / 8);
+        let Some(byte) = self.data.get_mut(vec_index) else {
+            return Err(format!(
+                "Index `{i}/8` outside of bitvec data length `{}`",
+                self.data.len()
+            ));
+        };
+        let bit_index = Self::bit_index(i);
+        if val {
+            *byte |= bit_index;
+        } else {
+            *byte &= !bit_index;
+        }
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::BitVec;
+    use crate::codec::StacksMessageCodec;
+
+    fn check_set_get(mut input: BitVec) {
+        let original_input = input.clone();
+        for i in 0..input.len() {
+            let original_value = input.get(i).unwrap();
+            input.set(i, false).unwrap();
+            assert_eq!(input.len(), original_input.len());
+            for j in 0..input.len() {
+                if j == i {
+                    continue;
+                }
+                assert_eq!(original_input.get(j), input.get(j));
+            }
+            assert_eq!(input.get(i), Some(false));
+            input.set(i, true).unwrap();
+            for j in 0..input.len() {
+                if j == i {
+                    continue;
+                }
+                assert_eq!(original_input.get(j), input.get(j));
+            }
+            assert_eq!(input.get(i), Some(true));
+            input.set(i, original_value).unwrap();
+            assert_eq!(input.get(i), Some(original_value));
+        }
+        assert_eq!(input, original_input);
+        assert!(input.set(input.len(), false).is_err());
+    }
+
+    fn check_serialization(input: &BitVec) {
+        let byte_ser = input.serialize_to_vec();
+        let deserialized = BitVec::consensus_deserialize(&mut byte_ser.as_slice()).unwrap();
+        assert_eq!(input, &deserialized);
+    }
+
+    fn check_ok_vector(input: &[bool]) {
+        let bitvec = BitVec::try_from(input).unwrap();
+        assert_eq!(bitvec.len(), input.len() as u16);
+        for (ix, value) in input.iter().enumerate() {
+            assert_eq!(bitvec.get(u16::try_from(ix).unwrap()), Some(*value));
+        }
+
+        check_serialization(&bitvec);
+        check_set_get(bitvec);
+    }
+
+    #[test]
+    fn vectors() {
+        let mut inputs = vec![
+            vec![true; 8],
+            vec![false; 8],
+            vec![true; 12],
+            vec![false; 12],
+            vec![false],
+            vec![true],
+            vec![false, true],
+            vec![true, false],
+        ];
+        for i in 0..8 {
+            let mut single_set_vec = vec![false; 8];
+            let mut single_unset_vec = vec![true; 8];
+            single_unset_vec[i] = false;
+            single_set_vec[i] = true;
+            inputs.push(single_set_vec);
+            inputs.push(single_unset_vec);
+        }
+        let large_set_vec = vec![false; u16::MAX.into()];
+        let large_unset_vec = vec![true; u16::MAX.into()];
+        inputs.push(large_set_vec);
+        inputs.push(large_unset_vec);
+
+        for i in 1..128 {
+            let mut bool_vec = vec![false; i];
+            for (j, val) in bool_vec.iter_mut().enumerate() {
+                *val = j % 2 == 0;
+            }
+            inputs.push(bool_vec);
+        }
+
+        for i in inputs.into_iter() {
+            check_ok_vector(i.as_slice());
+        }
+    }
+}
diff --git a/stacks-common/src/libcommon.rs b/stacks-common/src/libcommon.rs
index 1448a2f90c..2f19e74540 100644
--- a/stacks-common/src/libcommon.rs
+++ b/stacks-common/src/libcommon.rs
@@ -31,6 +31,8 @@ pub mod address;
 
 pub mod deps_common;
 
+pub mod bitvec;
+
 use crate::types::chainstate::{BlockHeaderHash, BurnchainHeaderHash, SortitionId, StacksBlockId};
 
 pub mod consts {

From 8508c381e2016e3c3f2e1a1968fb8f092daa546c Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Thu, 18 Jan 2024 13:41:22 -0500
Subject: [PATCH 0393/1166] Revert "Address clippy complaints in src/vm/"

This reverts commit 264831e1ba86e16bf480237a1c76182c23974866.
---
 clarity/src/vm/callables.rs       |  37 ++++++----
 clarity/src/vm/clarity.rs         |   3 +-
 clarity/src/vm/contexts.rs        | 110 ++++++++++++---------------
 clarity/src/vm/costs/mod.rs       |  29 ++++----
 clarity/src/vm/coverage.rs        |   6 --
 clarity/src/vm/diagnostic.rs      |  26 +++----
 clarity/src/vm/docs/contracts.rs  |   4 +-
 clarity/src/vm/docs/mod.rs        | 119 ++++++++++++++++--------------
 clarity/src/vm/errors.rs          |  14 ++--
 clarity/src/vm/mod.rs             |  66 +++++++++--------
 clarity/src/vm/representations.rs |   4 +-
 clarity/src/vm/test_util/mod.rs   |   2 +-
 12 files changed, 212 insertions(+), 208 deletions(-)

diff --git a/clarity/src/vm/callables.rs b/clarity/src/vm/callables.rs
index c589e4b397..7ae7e59ac1 100644
--- a/clarity/src/vm/callables.rs
+++ b/clarity/src/vm/callables.rs
@@ -38,8 +38,9 @@ use crate::vm::types::{
 };
 use crate::vm::{eval, Environment, LocalContext, Value};
 
-type SpecialFunctionType =
-    dyn Fn(&[SymbolicExpression], &mut Environment, &LocalContext) -> Result<Value>;
+use super::costs::CostOverflowingMath;
+use super::types::signatures::CallableSubtype;
+use super::ClarityVersion;
 
 pub enum CallableType {
     UserFunction(DefinedFunction),
@@ -53,7 +54,10 @@ pub enum CallableType {
         ClarityCostFunction,
         &'static dyn Fn(&[Value]) -> Result<u64>,
     ),
-    SpecialFunction(&'static str, &'static SpecialFunctionType),
+    SpecialFunction(
+        &'static str,
+        &'static dyn Fn(&[SymbolicExpression], &mut Environment, &LocalContext) -> Result<Value>,
+    ),
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
@@ -235,11 +239,7 @@ impl DefinedFunction {
                             )
                             .into());
                         }
-                        if context
-                            .variables
-                            .insert(name.clone(), value.clone())
-                            .is_some()
-                        {
+                        if let Some(_) = context.variables.insert(name.clone(), value.clone()) {
                             return Err(CheckErrors::NameAlreadyUsed(name.to_string()).into());
                         }
                     }
@@ -281,7 +281,7 @@ impl DefinedFunction {
                     }
                 }
 
-                if context.variables.insert(name.clone(), cast_value).is_some() {
+                if let Some(_) = context.variables.insert(name.clone(), cast_value) {
                     return Err(CheckErrors::NameAlreadyUsed(name.to_string()).into());
                 }
             }
@@ -318,7 +318,7 @@ impl DefinedFunction {
                     self.name.to_string(),
                 ))?;
 
-        let args = self.arg_types.to_vec();
+        let args = self.arg_types.iter().map(|a| a.clone()).collect();
         if !expected_sig.check_args_trait_compliance(epoch, args)? {
             return Err(
                 CheckErrors::BadTraitImplementation(trait_name, self.name.to_string()).into(),
@@ -388,12 +388,16 @@ impl CallableType {
 impl FunctionIdentifier {
     fn new_native_function(name: &str) -> FunctionIdentifier {
         let identifier = format!("_native_:{}", name);
-        FunctionIdentifier { identifier }
+        FunctionIdentifier {
+            identifier: identifier,
+        }
     }
 
     fn new_user_function(name: &str, context: &str) -> FunctionIdentifier {
         let identifier = format!("{}:{}", context, name);
-        FunctionIdentifier { identifier }
+        FunctionIdentifier {
+            identifier: identifier,
+        }
     }
 }
 
@@ -617,9 +621,12 @@ mod test {
         let cast_list = clarity2_implicit_cast(&list_opt_ty, &list_opt_contract).unwrap();
         let items = cast_list.expect_list();
         for item in items {
-            if let Some(cast_opt) = item.expect_optional() {
-                let cast_trait = cast_opt.expect_callable();
-                assert_eq!(&cast_trait.trait_identifier.unwrap(), &trait_identifier);
+            match item.expect_optional() {
+                Some(cast_opt) => {
+                    let cast_trait = cast_opt.expect_callable();
+                    assert_eq!(&cast_trait.trait_identifier.unwrap(), &trait_identifier);
+                }
+                None => (),
             }
         }
 
diff --git a/clarity/src/vm/clarity.rs b/clarity/src/vm/clarity.rs
index 1370dd7302..11a0732e78 100644
--- a/clarity/src/vm/clarity.rs
+++ b/clarity/src/vm/clarity.rs
@@ -113,7 +113,6 @@ pub trait ClarityConnection {
         self.with_clarity_db_readonly_owned(|mut db| (to_do(&mut db), db))
     }
 
-    #[allow(clippy::too_many_arguments)]
     fn with_readonly_clarity_env<F, R>(
         &mut self,
         mainnet: bool,
@@ -258,7 +257,7 @@ pub trait TransactionConnection: ClarityConnection {
             },
             |_, _| false,
         )
-        .map(|(value, assets, events, _)| (value, assets, events))
+        .and_then(|(value, assets, events, _)| Ok((value, assets, events)))
     }
 
     /// Execute a contract call in the current block.
diff --git a/clarity/src/vm/contexts.rs b/clarity/src/vm/contexts.rs
index de2fd278c9..7c53ed663d 100644
--- a/clarity/src/vm/contexts.rs
+++ b/clarity/src/vm/contexts.rs
@@ -14,7 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::collections::hash_map::Entry;
 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
 use std::convert::TryInto;
 use std::fmt;
@@ -243,12 +242,6 @@ pub type StackTrace = Vec<FunctionIdentifier>;
 
 pub const TRANSIENT_CONTRACT_NAME: &str = "__transient";
 
-impl Default for AssetMap {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
 impl AssetMap {
     pub fn new() -> AssetMap {
         AssetMap {
@@ -283,7 +276,7 @@ impl AssetMap {
         amount: u128,
     ) -> Result<u128> {
         let current_amount = match self.token_map.get(principal) {
-            Some(principal_map) => *principal_map.get(asset).unwrap_or(&0),
+            Some(principal_map) => *principal_map.get(&asset).unwrap_or(&0),
             None => 0,
         };
 
@@ -318,10 +311,10 @@ impl AssetMap {
 
         let principal_map = self.asset_map.get_mut(principal).unwrap(); // should always exist, because of checked insert above.
 
-        if let Entry::Vacant(e) = principal_map.entry(asset.clone()) {
-            e.insert(vec![transfered]);
-        } else {
+        if principal_map.contains_key(&asset) {
             principal_map.get_mut(&asset).unwrap().push(transfered);
+        } else {
+            principal_map.insert(asset, vec![transfered]);
         }
     }
 
@@ -376,11 +369,11 @@ impl AssetMap {
                 }
 
                 let landing_map = self.asset_map.get_mut(&principal).unwrap(); // should always exist, because of checked insert above.
-                if let Entry::Vacant(e) = landing_map.entry(asset.clone()) {
-                    e.insert(transfers);
-                } else {
+                if landing_map.contains_key(&asset) {
                     let landing_vec = landing_map.get_mut(&asset).unwrap();
                     landing_vec.append(&mut transfers);
+                } else {
+                    landing_map.insert(asset, transfers);
                 }
             }
         }
@@ -422,7 +415,10 @@ impl AssetMap {
                 map.insert(principal.clone(), HashMap::new());
                 map.get_mut(&principal).unwrap()
             };
-            output_map.insert(AssetIdentifier::STX(), AssetMapEntry::STX(stx_amount));
+            output_map.insert(
+                AssetIdentifier::STX(),
+                AssetMapEntry::STX(stx_amount as u128),
+            );
         }
 
         for (principal, stx_burned_amount) in self.burn_map.drain() {
@@ -434,7 +430,7 @@ impl AssetMap {
             };
             output_map.insert(
                 AssetIdentifier::STX_burned(),
-                AssetMapEntry::Burn(stx_burned_amount),
+                AssetMapEntry::Burn(stx_burned_amount as u128),
             );
         }
 
@@ -451,15 +447,21 @@ impl AssetMap {
             }
         }
 
-        map
+        return map;
     }
 
     pub fn get_stx(&self, principal: &PrincipalData) -> Option<u128> {
-        self.stx_map.get(principal).copied()
+        match self.stx_map.get(principal) {
+            Some(value) => Some(*value),
+            None => None,
+        }
     }
 
     pub fn get_stx_burned(&self, principal: &PrincipalData) -> Option<u128> {
-        self.burn_map.get(principal).copied()
+        match self.burn_map.get(principal) {
+            Some(value) => Some(*value),
+            None => None,
+        }
     }
 
     pub fn get_stx_burned_total(&self) -> u128 {
@@ -478,7 +480,10 @@ impl AssetMap {
         asset_identifier: &AssetIdentifier,
     ) -> Option<u128> {
         match self.token_map.get(principal) {
-            Some(assets) => assets.get(asset_identifier).copied(),
+            Some(ref assets) => match assets.get(asset_identifier) {
+                Some(value) => Some(*value),
+                None => None,
+            },
             None => None,
         }
     }
@@ -489,7 +494,7 @@ impl AssetMap {
         asset_identifier: &AssetIdentifier,
     ) -> Option<&Vec<Value>> {
         match self.asset_map.get(principal) {
-            Some(assets) => match assets.get(asset_identifier) {
+            Some(ref assets) => match assets.get(asset_identifier) {
                 Some(values) => Some(values),
                 None => None,
             },
@@ -503,7 +508,7 @@ impl fmt::Display for AssetMap {
         write!(f, "[")?;
         for (principal, principal_map) in self.token_map.iter() {
             for (asset, amount) in principal_map.iter() {
-                writeln!(f, "{} spent {} {}", principal, amount, asset)?;
+                write!(f, "{} spent {} {}\n", principal, amount, asset)?;
             }
         }
         for (principal, principal_map) in self.asset_map.iter() {
@@ -512,25 +517,19 @@ impl fmt::Display for AssetMap {
                 for t in transfer {
                     write!(f, "{}, ", t)?;
                 }
-                writeln!(f, "] {}", asset)?;
+                write!(f, "] {}\n", asset)?;
             }
         }
         for (principal, stx_amount) in self.stx_map.iter() {
-            writeln!(f, "{} spent {} microSTX", principal, stx_amount)?;
+            write!(f, "{} spent {} microSTX\n", principal, stx_amount)?;
         }
         for (principal, stx_burn_amount) in self.burn_map.iter() {
-            writeln!(f, "{} burned {} microSTX", principal, stx_burn_amount)?;
+            write!(f, "{} burned {} microSTX\n", principal, stx_burn_amount)?;
         }
         write!(f, "]")
     }
 }
 
-impl Default for EventBatch {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
 impl EventBatch {
     pub fn new() -> EventBatch {
         EventBatch { events: vec![] }
@@ -777,7 +776,7 @@ impl<'a, 'hooks> OwnedEnvironment<'a, 'hooks> {
                 let mut snapshot = env
                     .global_context
                     .database
-                    .get_stx_balance_snapshot(recipient);
+                    .get_stx_balance_snapshot(&recipient);
 
                 snapshot.credit(amount);
                 snapshot.save();
@@ -988,7 +987,7 @@ impl<'a, 'b, 'hooks> Environment<'a, 'b, 'hooks> {
         program: &str,
         rules: ast::ASTRules,
     ) -> Result<Value> {
-        let clarity_version = self.contract_context.clarity_version;
+        let clarity_version = self.contract_context.clarity_version.clone();
 
         let parsed = ast::build_ast_with_rules(
             contract_identifier,
@@ -1000,7 +999,7 @@ impl<'a, 'b, 'hooks> Environment<'a, 'b, 'hooks> {
         )?
         .expressions;
 
-        if parsed.is_empty() {
+        if parsed.len() < 1 {
             return Err(RuntimeErrorType::ParseError(
                 "Expected a program of at least length 1".to_string(),
             )
@@ -1016,7 +1015,7 @@ impl<'a, 'b, 'hooks> Environment<'a, 'b, 'hooks> {
 
         let result = {
             let mut nested_env = Environment::new(
-                self.global_context,
+                &mut self.global_context,
                 &contract.contract_context,
                 self.call_stack,
                 self.sender.clone(),
@@ -1043,7 +1042,7 @@ impl<'a, 'b, 'hooks> Environment<'a, 'b, 'hooks> {
 
     pub fn eval_raw_with_rules(&mut self, program: &str, rules: ast::ASTRules) -> Result<Value> {
         let contract_id = QualifiedContractIdentifier::transient();
-        let clarity_version = self.contract_context.clarity_version;
+        let clarity_version = self.contract_context.clarity_version.clone();
 
         let parsed = ast::build_ast_with_rules(
             &contract_id,
@@ -1055,14 +1054,15 @@ impl<'a, 'b, 'hooks> Environment<'a, 'b, 'hooks> {
         )?
         .expressions;
 
-        if parsed.is_empty() {
+        if parsed.len() < 1 {
             return Err(RuntimeErrorType::ParseError(
                 "Expected a program of at least length 1".to_string(),
             )
             .into());
         }
         let local_context = LocalContext::new();
-        eval(&parsed[0], self, &local_context)
+        let result = { eval(&parsed[0], self, &local_context) };
+        result
     }
 
     #[cfg(any(test, feature = "testing"))]
@@ -1185,7 +1185,7 @@ impl<'a, 'b, 'hooks> Environment<'a, 'b, 'hooks> {
                 Ok(value) => {
                     if let Some(handler) = self.global_context.database.get_cc_special_cases_handler() {
                         handler(
-                            self.global_context,
+                            &mut self.global_context,
                             self.sender.as_ref(),
                             self.sponsor.as_ref(),
                             contract_identifier,
@@ -1219,7 +1219,7 @@ impl<'a, 'b, 'hooks> Environment<'a, 'b, 'hooks> {
 
         let result = {
             let mut nested_env = Environment::new(
-                self.global_context,
+                &mut self.global_context,
                 next_contract_context,
                 self.call_stack,
                 self.sender.clone(),
@@ -1272,7 +1272,7 @@ impl<'a, 'b, 'hooks> Environment<'a, 'b, 'hooks> {
         contract_content: &str,
         ast_rules: ASTRules,
     ) -> Result<()> {
-        let clarity_version = self.contract_context.clarity_version;
+        let clarity_version = self.contract_context.clarity_version.clone();
 
         let contract_ast = ast::build_ast_with_rules(
             &contract_identifier,
@@ -1286,7 +1286,7 @@ impl<'a, 'b, 'hooks> Environment<'a, 'b, 'hooks> {
             contract_identifier,
             clarity_version,
             &contract_ast,
-            contract_content,
+            &contract_content,
         )
     }
 
@@ -1331,7 +1331,7 @@ impl<'a, 'b, 'hooks> Environment<'a, 'b, 'hooks> {
                 contract_identifier.clone(),
                 contract_content,
                 self.sponsor.clone(),
-                self.global_context,
+                &mut self.global_context,
                 contract_version,
             );
             self.drop_memory(memory_use);
@@ -1593,7 +1593,7 @@ impl<'a, 'hooks> GlobalContext<'a, 'hooks> {
     }
 
     pub fn is_top_level(&self) -> bool {
-        self.asset_maps.is_empty()
+        self.asset_maps.len() == 0
     }
 
     fn get_asset_map(&mut self) -> &mut AssetMap {
@@ -1645,9 +1645,9 @@ impl<'a, 'hooks> GlobalContext<'a, 'hooks> {
         F: FnOnce(&mut Self) -> Result<T>,
     {
         self.begin();
-        let result = f(self).map_err(|e| {
+        let result = f(self).or_else(|e| {
             self.roll_back();
-            e
+            Err(e)
         })?;
         self.commit()?;
         Ok(result)
@@ -1858,12 +1858,6 @@ impl ContractContext {
     }
 }
 
-impl<'a> Default for LocalContext<'a> {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
 impl<'a> LocalContext<'a> {
     pub fn new() -> LocalContext<'a> {
         LocalContext {
@@ -1921,12 +1915,6 @@ impl<'a> LocalContext<'a> {
     }
 }
 
-impl Default for CallStack {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
 impl CallStack {
     pub fn new() -> CallStack {
         CallStack {
@@ -1967,15 +1955,15 @@ impl CallStack {
                 )
                 .into());
             }
-            if tracked && !self.set.remove(function) {
+            if tracked && !self.set.remove(&function) {
                 panic!("Tried to remove tracked function from call stack, but could not find in current context.")
             }
             Ok(())
         } else {
-            Err(InterpreterError::InterpreterError(
+            return Err(InterpreterError::InterpreterError(
                 "Tried to remove item from empty call stack.".to_string(),
             )
-            .into())
+            .into());
         }
     }
 
diff --git a/clarity/src/vm/costs/mod.rs b/clarity/src/vm/costs/mod.rs
index c2c257755b..8b0ea788de 100644
--- a/clarity/src/vm/costs/mod.rs
+++ b/clarity/src/vm/costs/mod.rs
@@ -46,9 +46,9 @@ type Result<T> = std::result::Result<T, CostErrors>;
 pub const CLARITY_MEMORY_LIMIT: u64 = 100 * 1000 * 1000;
 
 // TODO: factor out into a boot lib?
-pub const COSTS_1_NAME: &str = "costs";
-pub const COSTS_2_NAME: &str = "costs-2";
-pub const COSTS_3_NAME: &str = "costs-3";
+pub const COSTS_1_NAME: &'static str = "costs";
+pub const COSTS_2_NAME: &'static str = "costs-2";
+pub const COSTS_3_NAME: &'static str = "costs-3";
 
 lazy_static! {
     static ref COST_TUPLE_TYPE_SIGNATURE: TypeSignature = TypeSignature::TupleType(
@@ -245,7 +245,6 @@ pub struct TrackerData {
     chain_id: u32,
 }
 
-#[allow(clippy::large_enum_variant)]
 #[derive(Clone)]
 pub enum LimitedCostTracker {
     Limited(TrackerData),
@@ -600,7 +599,7 @@ fn load_cost_functions(
                             continue;
                         }
                         for arg in &cost_func_type.args {
-                            if arg.signature != TypeSignature::UIntType {
+                            if &arg.signature != &TypeSignature::UIntType {
                                 warn!("Confirmed cost proposal invalid: contains non uint argument";
                                       "confirmed_proposal_id" => confirmed_proposal,
                                 );
@@ -753,7 +752,7 @@ impl TrackerData {
         let mut cost_contracts = HashMap::new();
         let mut m = HashMap::new();
         for f in ClarityCostFunction::ALL.iter() {
-            let cost_function_ref = cost_function_references.remove(f).unwrap_or_else(|| {
+            let cost_function_ref = cost_function_references.remove(&f).unwrap_or_else(|| {
                 ClarityCostFunctionReference::new(boot_costs_id.clone(), f.get_name())
             });
             if !cost_contracts.contains_key(&cost_function_ref.contract_id) {
@@ -799,7 +798,7 @@ impl TrackerData {
             clarity_db.roll_back();
         }
 
-        Ok(())
+        return Ok(());
     }
 }
 
@@ -810,7 +809,7 @@ impl LimitedCostTracker {
             Self::Free => ExecutionCost::zero(),
         }
     }
-    pub fn set_total(&mut self, total: ExecutionCost) {
+    pub fn set_total(&mut self, total: ExecutionCost) -> () {
         // used by the miner to "undo" the cost of a transaction when trying to pack a block.
         match self {
             Self::Limited(ref mut data) => data.total = total,
@@ -972,7 +971,7 @@ impl CostTracker for LimitedCostTracker {
         match self {
             Self::Free => {
                 // tracker is free, return zero!
-                Ok(ExecutionCost::zero())
+                return Ok(ExecutionCost::zero());
             }
             Self::Limited(ref mut data) => {
                 if cost_function == ClarityCostFunction::Unimplemented {
@@ -1112,13 +1111,16 @@ pub trait CostOverflowingMath<T> {
 
 impl CostOverflowingMath<u64> for u64 {
     fn cost_overflow_mul(self, other: u64) -> Result<u64> {
-        self.checked_mul(other).ok_or(CostErrors::CostOverflow)
+        self.checked_mul(other)
+            .ok_or_else(|| CostErrors::CostOverflow)
     }
     fn cost_overflow_add(self, other: u64) -> Result<u64> {
-        self.checked_add(other).ok_or(CostErrors::CostOverflow)
+        self.checked_add(other)
+            .ok_or_else(|| CostErrors::CostOverflow)
     }
     fn cost_overflow_sub(self, other: u64) -> Result<u64> {
-        self.checked_sub(other).ok_or(CostErrors::CostOverflow)
+        self.checked_sub(other)
+            .ok_or_else(|| CostErrors::CostOverflow)
     }
 }
 
@@ -1135,7 +1137,7 @@ impl ExecutionCost {
 
     /// Returns the percentage of self consumed in `numerator`'s largest proportion dimension.
     pub fn proportion_largest_dimension(&self, numerator: &ExecutionCost) -> u64 {
-        *[
+        [
             numerator.runtime / cmp::max(1, self.runtime / 100),
             numerator.write_length / cmp::max(1, self.write_length / 100),
             numerator.write_count / cmp::max(1, self.write_count / 100),
@@ -1145,6 +1147,7 @@ impl ExecutionCost {
         .iter()
         .max()
         .expect("BUG: should find maximum")
+        .clone()
     }
 
     /// Returns the dot product of this execution cost with `resolution`/block_limit
diff --git a/clarity/src/vm/coverage.rs b/clarity/src/vm/coverage.rs
index 4ac9d459a7..bfb01e89c1 100644
--- a/clarity/src/vm/coverage.rs
+++ b/clarity/src/vm/coverage.rs
@@ -25,12 +25,6 @@ struct CoverageFileInfo {
     coverage: HashMap<String, Vec<(u32, u64)>>,
 }
 
-impl Default for CoverageReporter {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
 impl CoverageReporter {
     pub fn new() -> CoverageReporter {
         CoverageReporter {
diff --git a/clarity/src/vm/diagnostic.rs b/clarity/src/vm/diagnostic.rs
index ee0ac0b56d..81939237d7 100644
--- a/clarity/src/vm/diagnostic.rs
+++ b/clarity/src/vm/diagnostic.rs
@@ -66,26 +66,24 @@ impl Diagnostic {
 impl fmt::Display for Diagnostic {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{:?}", self.level)?;
-        match self.spans.len().cmp(&1) {
-            std::cmp::Ordering::Equal => write!(
+        if self.spans.len() == 1 {
+            write!(
                 f,
-                " (line {}, column {}): ",
+                " (line {}, column {})",
                 self.spans[0].start_line, self.spans[0].start_column
-            )?,
-            std::cmp::Ordering::Greater => {
-                let lines: Vec<String> = self
-                    .spans
-                    .iter()
-                    .map(|s| format!("line: {}", s.start_line))
-                    .collect();
-                write!(f, " ({}): ", lines.join(", "))?;
-            }
-            std::cmp::Ordering::Less => {}
+            )?;
+        } else if self.spans.len() > 1 {
+            let lines: Vec<String> = self
+                .spans
+                .iter()
+                .map(|s| format!("line: {}", s.start_line))
+                .collect();
+            write!(f, " ({})", lines.join(", "))?;
         }
         write!(f, ": {}.", &self.message)?;
         if let Some(suggestion) = &self.suggestion {
             write!(f, "\n{}", suggestion)?;
         }
-        writeln!(f)
+        write!(f, "\n")
     }
 }
diff --git a/clarity/src/vm/docs/contracts.rs b/clarity/src/vm/docs/contracts.rs
index a8b9a5e3f9..5c8406d4fb 100644
--- a/clarity/src/vm/docs/contracts.rs
+++ b/clarity/src/vm/docs/contracts.rs
@@ -110,7 +110,7 @@ pub fn make_docs(content: &str, support_docs: &ContractSupportDocs) -> ContractR
             let description = support_docs
                 .descriptions
                 .get(func_name.as_str())
-                .unwrap_or_else(|| panic!("BUG: no description for {}", func_name.as_str()));
+                .expect(&format!("BUG: no description for {}", func_name.as_str()));
             make_func_ref(func_name, func_type, description)
         })
         .collect();
@@ -122,7 +122,7 @@ pub fn make_docs(content: &str, support_docs: &ContractSupportDocs) -> ContractR
             let description = support_docs
                 .descriptions
                 .get(func_name.as_str())
-                .unwrap_or_else(|| panic!("BUG: no description for {}", func_name.as_str()));
+                .expect(&format!("BUG: no description for {}", func_name.as_str()));
             make_func_ref(func_name, func_type, description)
         })
         .collect();
diff --git a/clarity/src/vm/docs/mod.rs b/clarity/src/vm/docs/mod.rs
index 034616c0f7..f43b82ff1b 100644
--- a/clarity/src/vm/docs/mod.rs
+++ b/clarity/src/vm/docs/mod.rs
@@ -788,11 +788,12 @@ pub fn get_output_type_string(function_type: &FunctionType) -> String {
         FunctionType::Binary(left, right, ref out_sig) => match out_sig {
             FunctionReturnsSignature::Fixed(out_type) => format!("{}", out_type),
             FunctionReturnsSignature::TypeOfArgAtPosition(pos) => {
-                let arg_sig = match pos {
-                        0 => left,
-                        1 => right,
+                let arg_sig: &FunctionArgSignature;
+                match pos {
+                        0 => arg_sig = left,
+                        1 => arg_sig = right,
                         _ => panic!("Index out of range: TypeOfArgAtPosition for FunctionType::Binary can only handle two arguments, zero-indexed (0 or 1).")
-                    };
+                    }
                 match arg_sig {
                     FunctionArgSignature::Single(arg_type) => format!("{}", arg_type),
                     FunctionArgSignature::Union(arg_types) => {
@@ -808,12 +809,15 @@ pub fn get_output_type_string(function_type: &FunctionType) -> String {
 
 pub fn get_signature(function_name: &str, function_type: &FunctionType) -> Option<String> {
     if let FunctionType::Fixed(FixedFunction { ref args, .. }) = function_type {
-        let in_names: Vec<String> = args.iter().map(|x| x.name.to_string()).collect();
+        let in_names: Vec<String> = args
+            .iter()
+            .map(|x| format!("{}", x.name.as_str()))
+            .collect();
         let arg_examples = in_names.join(" ");
         Some(format!(
             "({}{}{})",
             function_name,
-            if arg_examples.is_empty() { "" } else { " " },
+            if arg_examples.len() == 0 { "" } else { " " },
             arg_examples
         ))
     } else {
@@ -828,7 +832,7 @@ fn make_for_simple_native(
 ) -> FunctionAPI {
     let (input_type, output_type) = {
         if let TypedNativeFunction::Simple(SimpleNativeFunction(function_type)) =
-            TypedNativeFunction::type_native_function(function)
+            TypedNativeFunction::type_native_function(&function)
         {
             let input_type = get_input_type_string(&function_type);
             let output_type = get_output_type_string(&function_type);
@@ -844,8 +848,8 @@ fn make_for_simple_native(
     FunctionAPI {
         name: api.name.map_or(name, |x| x.to_string()),
         snippet: api.snippet.to_string(),
-        input_type,
-        output_type,
+        input_type: input_type,
+        output_type: output_type,
         signature: api.signature.to_string(),
         description: api.description.to_string(),
         example: api.example.to_string(),
@@ -2420,35 +2424,35 @@ pub fn make_api_reference(function: &NativeFunctions) -> FunctionAPI {
     use crate::vm::functions::NativeFunctions::*;
     let name = function.get_name();
     match function {
-        Add => make_for_simple_native(&ADD_API, function, name),
-        ToUInt => make_for_simple_native(&TO_UINT_API, function, name),
-        ToInt => make_for_simple_native(&TO_INT_API, function, name),
-        Subtract => make_for_simple_native(&SUB_API, function, name),
-        Multiply => make_for_simple_native(&MUL_API, function, name),
-        Divide => make_for_simple_native(&DIV_API, function, name),
-        BuffToIntLe => make_for_simple_native(&BUFF_TO_INT_LE_API, function, name),
-        BuffToUIntLe => make_for_simple_native(&BUFF_TO_UINT_LE_API, function, name),
-        BuffToIntBe => make_for_simple_native(&BUFF_TO_INT_BE_API, function, name),
-        BuffToUIntBe => make_for_simple_native(&BUFF_TO_UINT_BE_API, function, name),
-        IsStandard => make_for_simple_native(&IS_STANDARD_API, function, name),
-        PrincipalDestruct => make_for_simple_native(&PRINCPIPAL_DESTRUCT_API, function, name),
-        PrincipalConstruct => make_for_special(&PRINCIPAL_CONSTRUCT_API, function),
-        StringToInt => make_for_simple_native(&STRING_TO_INT_API, function, name),
-        StringToUInt => make_for_simple_native(&STRING_TO_UINT_API, function, name),
-        IntToAscii => make_for_simple_native(&INT_TO_ASCII_API, function, name),
-        IntToUtf8 => make_for_simple_native(&INT_TO_UTF8_API, function, name),
-        CmpGeq => make_for_simple_native(&GEQ_API, function, name),
-        CmpLeq => make_for_simple_native(&LEQ_API, function, name),
-        CmpLess => make_for_simple_native(&LESS_API, function, name),
-        CmpGreater => make_for_simple_native(&GREATER_API, function, name),
-        Modulo => make_for_simple_native(&MOD_API, function, name),
-        Power => make_for_simple_native(&POW_API, function, name),
-        Sqrti => make_for_simple_native(&SQRTI_API, function, name),
-        Log2 => make_for_simple_native(&LOG2_API, function, name),
-        BitwiseXor => make_for_simple_native(&XOR_API, function, name),
-        And => make_for_simple_native(&AND_API, function, name),
-        Or => make_for_simple_native(&OR_API, function, name),
-        Not => make_for_simple_native(&NOT_API, function, name),
+        Add => make_for_simple_native(&ADD_API, &function, name),
+        ToUInt => make_for_simple_native(&TO_UINT_API, &function, name),
+        ToInt => make_for_simple_native(&TO_INT_API, &function, name),
+        Subtract => make_for_simple_native(&SUB_API, &function, name),
+        Multiply => make_for_simple_native(&MUL_API, &function, name),
+        Divide => make_for_simple_native(&DIV_API, &function, name),
+        BuffToIntLe => make_for_simple_native(&BUFF_TO_INT_LE_API, &function, name),
+        BuffToUIntLe => make_for_simple_native(&BUFF_TO_UINT_LE_API, &function, name),
+        BuffToIntBe => make_for_simple_native(&BUFF_TO_INT_BE_API, &function, name),
+        BuffToUIntBe => make_for_simple_native(&BUFF_TO_UINT_BE_API, &function, name),
+        IsStandard => make_for_simple_native(&IS_STANDARD_API, &function, name),
+        PrincipalDestruct => make_for_simple_native(&PRINCPIPAL_DESTRUCT_API, &function, name),
+        PrincipalConstruct => make_for_special(&PRINCIPAL_CONSTRUCT_API, &function),
+        StringToInt => make_for_simple_native(&STRING_TO_INT_API, &function, name),
+        StringToUInt => make_for_simple_native(&STRING_TO_UINT_API, &function, name),
+        IntToAscii => make_for_simple_native(&INT_TO_ASCII_API, &function, name),
+        IntToUtf8 => make_for_simple_native(&INT_TO_UTF8_API, &function, name),
+        CmpGeq => make_for_simple_native(&GEQ_API, &function, name),
+        CmpLeq => make_for_simple_native(&LEQ_API, &function, name),
+        CmpLess => make_for_simple_native(&LESS_API, &function, name),
+        CmpGreater => make_for_simple_native(&GREATER_API, &function, name),
+        Modulo => make_for_simple_native(&MOD_API, &function, name),
+        Power => make_for_simple_native(&POW_API, &function, name),
+        Sqrti => make_for_simple_native(&SQRTI_API, &function, name),
+        Log2 => make_for_simple_native(&LOG2_API, &function, name),
+        BitwiseXor => make_for_simple_native(&XOR_API, &function, name),
+        And => make_for_simple_native(&AND_API, &function, name),
+        Or => make_for_simple_native(&OR_API, &function, name),
+        Not => make_for_simple_native(&NOT_API, &function, name),
         Equals => make_for_special(&EQUALS_API, function),
         If => make_for_special(&IF_API, function),
         Let => make_for_special(&LET_API, function),
@@ -2512,20 +2516,20 @@ pub fn make_api_reference(function: &NativeFunctions) -> FunctionAPI {
         BurnAsset => make_for_special(&BURN_ASSET, function),
         GetTokenSupply => make_for_special(&GET_TOKEN_SUPPLY, function),
         AtBlock => make_for_special(&AT_BLOCK, function),
-        GetStxBalance => make_for_simple_native(&STX_GET_BALANCE, function, name),
-        StxGetAccount => make_for_simple_native(&STX_GET_ACCOUNT, function, name),
+        GetStxBalance => make_for_simple_native(&STX_GET_BALANCE, &function, name),
+        StxGetAccount => make_for_simple_native(&STX_GET_ACCOUNT, &function, name),
         StxTransfer => make_for_special(&STX_TRANSFER, function),
         StxTransferMemo => make_for_special(&STX_TRANSFER_MEMO, function),
-        StxBurn => make_for_simple_native(&STX_BURN, function, name),
+        StxBurn => make_for_simple_native(&STX_BURN, &function, name),
         ToConsensusBuff => make_for_special(&TO_CONSENSUS_BUFF, function),
         FromConsensusBuff => make_for_special(&FROM_CONSENSUS_BUFF, function),
         ReplaceAt => make_for_special(&REPLACE_AT, function),
-        BitwiseXor2 => make_for_simple_native(&BITWISE_XOR_API, function, name),
-        BitwiseAnd => make_for_simple_native(&BITWISE_AND_API, function, name),
-        BitwiseOr => make_for_simple_native(&BITWISE_OR_API, function, name),
-        BitwiseNot => make_for_simple_native(&BITWISE_NOT_API, function, name),
-        BitwiseLShift => make_for_simple_native(&BITWISE_LEFT_SHIFT_API, function, name),
-        BitwiseRShift => make_for_simple_native(&BITWISE_RIGHT_SHIFT_API, function, name),
+        BitwiseXor2 => make_for_simple_native(&BITWISE_XOR_API, &function, name),
+        BitwiseAnd => make_for_simple_native(&BITWISE_AND_API, &function, name),
+        BitwiseOr => make_for_simple_native(&BITWISE_OR_API, &function, name),
+        BitwiseNot => make_for_simple_native(&BITWISE_NOT_API, &function, name),
+        BitwiseLShift => make_for_simple_native(&BITWISE_LEFT_SHIFT_API, &function, name),
+        BitwiseRShift => make_for_simple_native(&BITWISE_RIGHT_SHIFT_API, &function, name),
     }
 }
 
@@ -2601,7 +2605,7 @@ pub fn make_define_reference(define_type: &DefineFunctions) -> FunctionAPI {
 fn make_all_api_reference() -> ReferenceAPIs {
     let mut functions: Vec<_> = NativeFunctions::ALL
         .iter()
-        .map(make_api_reference)
+        .map(|x| make_api_reference(x))
         .collect();
     for data_type in DefineFunctions::ALL.iter() {
         functions.push(make_define_reference(data_type))
@@ -2615,7 +2619,7 @@ fn make_all_api_reference() -> ReferenceAPIs {
             keywords.push(api_ref)
         }
     }
-    keywords.sort_by(|x, y| x.name.cmp(y.name));
+    keywords.sort_by(|x, y| x.name.cmp(&y.name));
 
     ReferenceAPIs {
         functions,
@@ -2625,7 +2629,10 @@ fn make_all_api_reference() -> ReferenceAPIs {
 
 pub fn make_json_api_reference() -> String {
     let api_out = make_all_api_reference();
-    serde_json::to_string(&api_out).expect("Failed to serialize documentation")
+    format!(
+        "{}",
+        serde_json::to_string(&api_out).expect("Failed to serialize documentation")
+    )
 }
 
 #[cfg(test)]
@@ -2662,7 +2669,7 @@ mod test {
     const DOC_HEADER_DB: DocHeadersDB = DocHeadersDB {};
 
     impl MemoryBackingStore {
-        pub fn as_docs_clarity_db(&mut self) -> ClarityDatabase {
+        pub fn as_docs_clarity_db<'a>(&'a mut self) -> ClarityDatabase<'a> {
             ClarityDatabase::new(self, &DOC_HEADER_DB, &DOC_POX_STATE_DB)
         }
     }
@@ -2833,13 +2840,13 @@ mod test {
         let mut current_segment: String = "".into();
         for line in program.lines() {
             current_segment.push_str(line);
-            current_segment.push('\n');
+            current_segment.push_str("\n");
             if line.contains(";;") && line.contains("Returns ") {
                 segments.push(current_segment);
                 current_segment = "".into();
             }
         }
-        if !current_segment.is_empty() {
+        if current_segment.len() > 0 {
             segments.push(current_segment);
         }
 
@@ -2899,7 +2906,7 @@ mod test {
                     .type_map
                     .as_ref()
                     .unwrap()
-                    .get_type(analysis.expressions.last().unwrap())
+                    .get_type(&analysis.expressions.last().unwrap())
                     .cloned(),
             );
         }
@@ -2994,7 +3001,7 @@ mod test {
                     let mut analysis_db = store.as_analysis_db();
                     let mut parsed = ast::build_ast(
                         &contract_id,
-                        token_contract_content,
+                        &token_contract_content,
                         &mut (),
                         ClarityVersion::latest(),
                         StacksEpochId::latest(),
@@ -3063,7 +3070,7 @@ mod test {
 
                 env.initialize_contract(
                     contract_id,
-                    token_contract_content,
+                    &token_contract_content,
                     None,
                     ASTRules::PrecheckSize,
                 )
diff --git a/clarity/src/vm/errors.rs b/clarity/src/vm/errors.rs
index d03e75e034..1b7c8a7139 100644
--- a/clarity/src/vm/errors.rs
+++ b/clarity/src/vm/errors.rs
@@ -112,7 +112,7 @@ pub type InterpreterResult<R> = Result<R, Error>;
 
 impl<T> PartialEq<IncomparableError<T>> for IncomparableError<T> {
     fn eq(&self, _other: &IncomparableError<T>) -> bool {
-        false
+        return false;
     }
 }
 
@@ -132,12 +132,14 @@ impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
             Error::Runtime(ref err, ref stack) => {
-                write!(f, "{}", err)?;
+                match err {
+                    _ => write!(f, "{}", err),
+                }?;
 
                 if let Some(ref stack_trace) = stack {
                     write!(f, "\n Stack Trace: \n")?;
                     for item in stack_trace.iter() {
-                        writeln!(f, "{}", item)?;
+                        write!(f, "{}\n", item)?;
                     }
                 }
                 Ok(())
@@ -212,9 +214,9 @@ impl From<Error> for () {
     fn from(err: Error) -> Self {}
 }
 
-impl From<ShortReturnType> for Value {
-    fn from(val: ShortReturnType) -> Self {
-        match val {
+impl Into<Value> for ShortReturnType {
+    fn into(self) -> Value {
+        match self {
             ShortReturnType::ExpectedValue(v) => v,
             ShortReturnType::AssertionFailed(v) => v,
         }
diff --git a/clarity/src/vm/mod.rs b/clarity/src/vm/mod.rs
index 9c1a483ac3..e583540ef1 100644
--- a/clarity/src/vm/mod.rs
+++ b/clarity/src/vm/mod.rs
@@ -49,7 +49,6 @@ pub mod tests;
 #[cfg(any(test, feature = "testing"))]
 pub mod test_util;
 
-#[allow(clippy::result_large_err)]
 pub mod clarity;
 
 use std::collections::BTreeMap;
@@ -173,31 +172,33 @@ fn lookup_variable(name: &str, context: &LocalContext, env: &mut Environment) ->
             name
         ))
         .into())
-    } else if let Some(value) = variables::lookup_reserved_variable(name, context, env)? {
-        Ok(value)
     } else {
-        runtime_cost(
-            ClarityCostFunction::LookupVariableDepth,
-            env,
-            context.depth(),
-        )?;
-        if let Some(value) = context.lookup_variable(name) {
-            runtime_cost(ClarityCostFunction::LookupVariableSize, env, value.size())?;
-            Ok(value.clone())
-        } else if let Some(value) = env.contract_context.lookup_variable(name).cloned() {
-            runtime_cost(ClarityCostFunction::LookupVariableSize, env, value.size())?;
-            let (value, _) =
-                Value::sanitize_value(env.epoch(), &TypeSignature::type_of(&value), value)
-                    .ok_or_else(|| CheckErrors::CouldNotDetermineType)?;
+        if let Some(value) = variables::lookup_reserved_variable(name, context, env)? {
             Ok(value)
-        } else if let Some(callable_data) = context.lookup_callable_contract(name) {
-            if env.contract_context.get_clarity_version() < &ClarityVersion::Clarity2 {
-                Ok(callable_data.contract_identifier.clone().into())
+        } else {
+            runtime_cost(
+                ClarityCostFunction::LookupVariableDepth,
+                env,
+                context.depth(),
+            )?;
+            if let Some(value) = context.lookup_variable(name) {
+                runtime_cost(ClarityCostFunction::LookupVariableSize, env, value.size())?;
+                Ok(value.clone())
+            } else if let Some(value) = env.contract_context.lookup_variable(name).cloned() {
+                runtime_cost(ClarityCostFunction::LookupVariableSize, env, value.size())?;
+                let (value, _) =
+                    Value::sanitize_value(env.epoch(), &TypeSignature::type_of(&value), value)
+                        .ok_or_else(|| CheckErrors::CouldNotDetermineType)?;
+                Ok(value)
+            } else if let Some(callable_data) = context.lookup_callable_contract(name) {
+                if env.contract_context.get_clarity_version() < &ClarityVersion::Clarity2 {
+                    Ok(callable_data.contract_identifier.clone().into())
+                } else {
+                    Ok(Value::CallableContract(callable_data.clone()))
+                }
             } else {
-                Ok(Value::CallableContract(callable_data.clone()))
+                Err(CheckErrors::UndefinedVariable(name.to_string()).into())
             }
-        } else {
-            Err(CheckErrors::UndefinedVariable(name.to_string()).into())
         }
     }
 }
@@ -237,7 +238,10 @@ pub fn apply(
     //        only enough to do recursion detection.
 
     // do recursion check on user functions.
-    let track_recursion = matches!(function, CallableType::UserFunction(_));
+    let track_recursion = match function {
+        CallableType::UserFunction(_) => true,
+        _ => false,
+    };
 
     if track_recursion && env.call_stack.contains(&identifier) {
         return Err(CheckErrors::CircularReference(vec![identifier.to_string()]).into());
@@ -307,9 +311,9 @@ pub fn apply(
     }
 }
 
-pub fn eval(
+pub fn eval<'a>(
     exp: &SymbolicExpression,
-    env: &mut Environment,
+    env: &'a mut Environment,
     context: &LocalContext,
 ) -> Result<Value> {
     use crate::vm::representations::SymbolicExpressionType::{
@@ -325,7 +329,7 @@ pub fn eval(
 
     let res = match exp.expr {
         AtomValue(ref value) | LiteralValue(ref value) => Ok(value.clone()),
-        Atom(ref value) => lookup_variable(value, context, env),
+        Atom(ref value) => lookup_variable(&value, context, env),
         List(ref children) => {
             let (function_variable, rest) = children
                 .split_first()
@@ -334,8 +338,8 @@ pub fn eval(
             let function_name = function_variable
                 .match_atom()
                 .ok_or(CheckErrors::BadFunctionName)?;
-            let f = lookup_function(function_name, env)?;
-            apply(&f, rest, env, context)
+            let f = lookup_function(&function_name, env)?;
+            apply(&f, &rest, env, context)
         }
         TraitReference(_, _) | Field(_) => {
             return Err(InterpreterError::BadSymbolicRepresentation(
@@ -358,8 +362,10 @@ pub fn eval(
 pub fn is_reserved(name: &str, version: &ClarityVersion) -> bool {
     if let Some(_result) = functions::lookup_reserved_functions(name, version) {
         true
+    } else if variables::is_reserved_name(name, version) {
+        true
     } else {
-        variables::is_reserved_name(name, version)
+        false
     }
 }
 
@@ -624,7 +630,7 @@ mod test {
             func_body,
             DefineType::Private,
             &"do_work".into(),
-            "",
+            &"",
         );
 
         let context = LocalContext::new();
diff --git a/clarity/src/vm/representations.rs b/clarity/src/vm/representations.rs
index a7cc12fcef..1b52cad66e 100644
--- a/clarity/src/vm/representations.rs
+++ b/clarity/src/vm/representations.rs
@@ -119,8 +119,8 @@ impl StacksMessageCodec for ClarityName {
 
 impl StacksMessageCodec for ContractName {
     fn consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), codec_error> {
-        if self.as_bytes().len() < CONTRACT_MIN_NAME_LENGTH
-            || self.as_bytes().len() > CONTRACT_MAX_NAME_LENGTH
+        if self.as_bytes().len() < CONTRACT_MIN_NAME_LENGTH as usize
+            || self.as_bytes().len() > CONTRACT_MAX_NAME_LENGTH as usize
         {
             return Err(codec_error::SerializeError(format!(
                 "Failed to serialize contract name: too short or too long: {}",
diff --git a/clarity/src/vm/test_util/mod.rs b/clarity/src/vm/test_util/mod.rs
index 1368660275..d800b9b738 100644
--- a/clarity/src/vm/test_util/mod.rs
+++ b/clarity/src/vm/test_util/mod.rs
@@ -64,7 +64,7 @@ pub fn execute_on_network(s: &str, use_mainnet: bool) -> Value {
 
 pub fn symbols_from_values(vec: Vec<Value>) -> Vec<SymbolicExpression> {
     vec.into_iter()
-        .map(SymbolicExpression::atom_value)
+        .map(|value| SymbolicExpression::atom_value(value))
         .collect()
 }
 

From 598d4bf275de63e7cfb948bdd0c8d924a53025c0 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Thu, 18 Jan 2024 15:31:24 -0500
Subject: [PATCH 0394/1166] chore: merge change log

---
 CHANGELOG.md | 70 +++++++++++++++++++++++++---------------------------
 1 file changed, 33 insertions(+), 37 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index fc21d8eac5..abfcacf350 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,9 +5,24 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to the versioning scheme outlined in the [README.md](README.md).
 
-## [2.4.0.0.5]
+## [2.4.0.1.0]
 
-This introduces a set of improvements to the Stacks miner behavior.  In
+### Added
+
+- When the Clarity library is built with feature flag `developer-mode`, comments
+  from the source code are now attached to the `SymbolicExpression` nodes. This
+  will be useful for tools that use the Clarity library to analyze and
+  manipulate Clarity source code, e.g. a formatter.
+- New RPC endpoint at /v2/constant_val to fetch a constant from a contract.
+- A new subsystem, called StackerDB, has been added, which allows a set of
+  Stacks nodes to store off-chain data on behalf of a specially-crafter smart
+  contract. This is an opt-in feature; Stacks nodes explicitly subscribe to
+  StackerDB replicas in their config files.
+- Message definitions and codecs for Stacker DB, a replicated off-chain DB
+  hosted by subscribed Stacks nodes and controlled by smart contracts
+- Added 3 new public and regionally diverse bootstrap nodes: est.stacksnodes.org, cet.stacksnodes.org, sgt.stacksnodes.org
+
+In addition, this introduces a set of improvements to the Stacks miner behavior.  In
 particular:
 * The VRF public key can be re-used across node restarts.
 * Settings that affect mining are hot-reloaded from the config file.  They take
@@ -26,6 +41,22 @@ contract-calls).
 * When configured, the node will optionally only RBF block-commits if it can
   produce a block with strictly more transactions.
 
+### Changed
+
+- `developer-mode` is no longer enabled in the default feature set. This is the correct default behavior, since the stacks-node should NOT build with developer-mode enabled by default. Tools that need to use developer-mode should enable it explicitly.
+
+### Fixed
+
+- The transaction receipts for smart contract publish transactions now indicate
+  a result of `(err none)` if the top-level code of the smart contract contained
+  runtime error and include details about the error in the `vm_error` field of
+  the receipt. Fixes issues #3154, #3328.
+- Added config setting `burnchain.wallet_name` which addresses blank wallets no
+  longer being created by default in recent bitcoin versions. Fixes issue #3596
+- Use the current burnchain tip to lookup UTXOs (Issue #3733)
+- The node now gracefully shuts down even if it is in the middle of a handshake with
+  bitcoind. Fixes issue #3734.
+
 ## [2.4.0.0.4]
 
 This is a high-priority hotfix that addresses a bug in transaction processing which
@@ -56,41 +87,6 @@ could impact miner availability.
 This is a hotfix that changes the logging failure behavior from panicking to dropping
 the log message (PR #3784).
 
-## [Unreleased]
-
-### Added
-
-- When the Clarity library is built with feature flag `developer-mode`, comments
-  from the source code are now attached to the `SymbolicExpression` nodes. This
-  will be useful for tools that use the Clarity library to analyze and
-  manipulate Clarity source code, e.g. a formatter.
-- New RPC endpoint at /v2/constant_val to fetch a constant from a contract.
-- A new subsystem, called StackerDB, has been added, which allows a set of
-  Stacks nodes to store off-chain data on behalf of a specially-crafter smart
-  contract. This is an opt-in feature; Stacks nodes explicitly subscribe to
-  StackerDB replicas in their config files.
-- Message definitions and codecs for Stacker DB, a replicated off-chain DB
-  hosted by subscribed Stacks nodes and controlled by smart contracts
-- Added 3 new public and regionally diverse bootstrap nodes: est.stacksnodes.org, cet.stacksnodes.org, sgt.stacksnodes.org
-- satoshis_per_byte can be changed in the config file and miners will always use
-  the most up to date value
-
-### Changed
-
-- `developer-mode` is no longer enabled in the default feature set. This is the correct default behavior, since the stacks-node should NOT build with developer-mode enabled by default. Tools that need to use developer-mode should enable it explicitly.
-
-### Fixed
-
-- The transaction receipts for smart contract publish transactions now indicate
-  a result of `(err none)` if the top-level code of the smart contract contained
-  runtime error and include details about the error in the `vm_error` field of
-  the receipt. Fixes issues #3154, #3328.
-- Added config setting `burnchain.wallet_name` which addresses blank wallets no
-  longer being created by default in recent bitcoin versions. Fixes issue #3596
-- Use the current burnchain tip to lookup UTXOs (Issue #3733)
-- The node now gracefully shuts down even if it is in the middle of a handshake with
-  bitcoind. Fixes issue #3734.
-
 ## [2.4.0.0.1]
 
 This is a minor change to add `txid` fields into the log messages from failing

From d99bc2fb0dc4977164824dc081b88059ff6beb63 Mon Sep 17 00:00:00 2001
From: wileyj <2847772+wileyj@users.noreply.github.com>
Date: Wed, 17 Jan 2024 20:05:56 -0800
Subject: [PATCH 0395/1166] change --config= to --config

---
 .../init/org.stacks.stacks-blockchain.plist   |  2 +-
 contrib/init/stacks.init                      |  2 +-
 contrib/init/stacks.service                   |  2 +-
 docs/profiling.md                             | 39 +++++++++++++++----
 net-test/bin/start.sh                         |  6 +--
 testnet/stacks-node/src/main.rs               |  4 +-
 6 files changed, 39 insertions(+), 16 deletions(-)

diff --git a/contrib/init/org.stacks.stacks-blockchain.plist b/contrib/init/org.stacks.stacks-blockchain.plist
index 965b4fa300..e0429e75f7 100644
--- a/contrib/init/org.stacks.stacks-blockchain.plist
+++ b/contrib/init/org.stacks.stacks-blockchain.plist
@@ -8,7 +8,7 @@
 	<array>
 			<string>/usr/local/bin/stacks-node</string>
 			<string>start</string>
-			<string>--config=/etc/stacks-blockchain/Config.toml</string>
+			<string>--config /etc/stacks-blockchain/Config.toml</string>
 	</array>
 
 	<key>ProcessType</key>
diff --git a/contrib/init/stacks.init b/contrib/init/stacks.init
index fb60c297e8..9ef1e8bbe4 100644
--- a/contrib/init/stacks.init
+++ b/contrib/init/stacks.init
@@ -60,7 +60,7 @@ start() {
         return 1
     fi
     echo -n $"Starting $prog: "
-    $stacks_bin start --config="$stacks_config" > "$stacks_log" 2>&1 &
+    $stacks_bin start --config "$stacks_config" > "$stacks_log" 2>&1 &
     RETVAL=$?
     [ $RETVAL -eq 0 ] && touch "$lockfile"
     echo
diff --git a/contrib/init/stacks.service b/contrib/init/stacks.service
index edbb3cba65..9b83409ab1 100644
--- a/contrib/init/stacks.service
+++ b/contrib/init/stacks.service
@@ -11,7 +11,7 @@ ConditionPathExists=/etc/stacks-blockchain/Config.toml
 ConditionPathIsDirectory=/stacks-blockchain
 
 [Service]
-ExecStart=/usr/local/bin/stacks-node start --config=/etc/stacks-blockchain/Config.toml
+ExecStart=/usr/local/bin/stacks-node start --config /etc/stacks-blockchain/Config.toml
 
 # Make sure the config directory is readable by the service user
 PermissionsStartOnly=true
diff --git a/docs/profiling.md b/docs/profiling.md
index 35bbaf2f18..25f821d2c9 100644
--- a/docs/profiling.md
+++ b/docs/profiling.md
@@ -1,6 +1,7 @@
 # Profiling Tools
 
 This document describes several techniques to profile (i.e. find performance bottlenecks) the stacks-node mining loop, including:
+
 - configuring debug logging,
 - setting up a mock mining node,
 - recording inbound transactions,
@@ -15,7 +16,7 @@ Note that all bash commands in this document are run from the stacks-blockchain
 Validating the config file using `stacks-node check-config`:
 
 ```
-$ cargo run -r -p stacks-node --bin stacks-node check-config --config=testnet/stacks-node/conf/mainnet-mockminer-conf.toml
+$ cargo run -r -p stacks-node --bin stacks-node check-config --config testnet/stacks-node/conf/mainnet-mockminer-conf.toml
 INFO [1661276562.220137] [testnet/stacks-node/src/main.rs:82] [main] stacks-node 0.1.0 (tip-mine:c90476aa8a+, release build, macos [aarch64])
 INFO [1661276562.220363] [testnet/stacks-node/src/main.rs:115] [main] Loading config at path testnet/stacks-node/conf/mainnet-mockminer-conf.toml
 INFO [1661276562.233071] [testnet/stacks-node/src/main.rs:128] [main] Valid config!
@@ -24,7 +25,7 @@ INFO [1661276562.233071] [testnet/stacks-node/src/main.rs:128] [main] Valid conf
 Enabling debug logging using environment variable `STACKS_LOG_DEBUG=1`:
 
 ```
-$ STACKS_LOG_DEBUG=1 cargo run -r -p stacks-node --bin stacks-node check-config --config=testnet/stacks-node/conf/mainnet-mockminer-conf.toml
+$ STACKS_LOG_DEBUG=1 cargo run -r -p stacks-node --bin stacks-node check-config --config testnet/stacks-node/conf/mainnet-mockminer-conf.toml
 INFO [1661276562.220137] [testnet/stacks-node/src/main.rs:82] [main] stacks-node 0.1.0 (tip-mine:c90476aa8a+, release build, macos [aarch64])
 INFO [1661276562.220363] [testnet/stacks-node/src/main.rs:115] [main] Loading config at path testnet/stacks-node/conf/mainnet-mockminer-conf.toml
 DEBG [1661276562.222450] [testnet/stacks-node/src/main.rs:118] [main] Loaded config file: ConfigFile { burnchain: Some(BurnchainConfigFile { chain: Some("bitcoin"), burn_fee_cap: Some(1), mode: Some("mainnet"), commit_anchor_block_within: None, peer_host: Some("bitcoind.stacks.co"), peer_port: Some(8333), rpc_port: Some(8332), rpc_ssl: None, username: Some("blockstack"), password: Some("blockstacksystem"), timeout: None, magic_bytes: None, local_mining_public_key: None, process_exit_at_block_height: None, poll_time_secs: None, satoshis_per_byte: None, leader_key_tx_estimated_size: None, block_commit_tx_estimated_size: None, rbf_fee_increment: None, max_rbf: None, epochs: None }), node: Some(NodeConfigFile { name: None, seed: None, deny_nodes: None, working_dir: Some("/Users/igor/w/stacks-work/working_dir"), rpc_bind: Some("0.0.0.0:20443"), p2p_bind: Some("0.0.0.0:20444"), p2p_address: None, data_url: None, bootstrap_node: Some("02196f005965cebe6ddc3901b7b1cc1aa7a88f305bb8c5893456b8f9a605923893@seed.mainnet.hiro.so:20444"), local_peer_seed: None, miner: Some(true), mock_mining: Some(true), mine_microblocks: None, microblock_frequency: None, max_microblocks: None, wait_time_for_microblocks: None, prometheus_bind: None, marf_cache_strategy: None, marf_defer_hashing: None, pox_sync_sample_secs: None, use_test_genesis_chainstate: None }), ustx_balance: None, events_observer: Some([EventObserverConfigFile { endpoint: "localhost:3700", events_keys: ["*"] }]), connection_options: None, fee_estimation: None, miner: None }
@@ -34,7 +35,7 @@ INFO [1661276562.233071] [testnet/stacks-node/src/main.rs:128] [main] Valid conf
 Enabling json logging using environment variable `STACKS_LOG_JSON=1` and feature flag `slog_json`:
 
 ```
-$ STACKS_LOG_JSON=1 cargo run -F slog_json -r -p stacks-node --bin stacks-node check-config --config=testnet/stacks-node/conf/mainnet-mockminer-conf.toml
+$ STACKS_LOG_JSON=1 cargo run -F slog_json -r -p stacks-node --bin stacks-node check-config --config testnet/stacks-node/conf/mainnet-mockminer-conf.toml
 {"msg":"stacks-node 0.1.0 (tip-mine:c90476aa8a+, release build, macos [aarch64])","level":"INFO","ts":"2022-08-23T12:44:28.072462-05:00","thread":"main","line":82,"file":"testnet/stacks-node/src/main.rs"}
 {"msg":"Loading config at path testnet/stacks-node/conf/mainnet-mockminer-conf.toml","level":"INFO","ts":"2022-08-23T12:44:28.074238-05:00","thread":"main","line":115,"file":"testnet/stacks-node/src/main.rs"}
 {"msg":"Valid config!","level":"INFO","ts":"2022-08-23T12:44:28.089960-05:00","thread":"main","line":128,"file":"testnet/stacks-node/src/main.rs"}
@@ -53,6 +54,7 @@ $ export STACKS_SNAPSHOT_DIR=$STACKS_DIR/snapshot
 ## Setting up the mock mining node
 
 Download and extract an archived snapshot of mainnet working directory, provided by Hiro.
+
 ```
 $ wget -P $STACKS_DIR https://storage.googleapis.com/blockstack-publish/archiver-main/follower/mainnet-follower-latest.tar.gz
 $ tar xzvf $STACKS_DIR/mainnet-follower-latest.tar.gz -C $STACKS_DIR
@@ -65,17 +67,19 @@ We'll be using the `stacks-node` config file available at:
 Note that, for convenience, the `stacks-node` binary uses the environment variable `$STACKS_WORKING_DIR` to override the working directory location in the config file.
 
 ```
-$ cargo run -r -p stacks-node --bin stacks-node start --config=testnet/stacks-node/conf/mocknet-miner-conf.toml
+$ cargo run -r -p stacks-node --bin stacks-node start --config testnet/stacks-node/conf/mocknet-miner-conf.toml
 ```
 
 The `stacks-node` process will receive blocks starting from the latest block available in the Hiro archive.
 
 Check the latest tip height of our node.
+
 ```
 $ curl -s 127.0.0.1:20443/v2/info | jq .stacks_tip_height
 ```
 
 Compare our node's tip height to a public node's tip height to check when our node is fully synchronized.
+
 ```
 $ curl -s seed-0.mainnet.stacks.co:20443/v2/info | jq .stacks_tip_height
 ```
@@ -85,16 +89,19 @@ Once the node is synchronized, terminate the `stacks-node` process so we can set
 ## Recording blockchain events
 
 Run `stacks-events` to receive and archive events:
+
 ```
 $ cargo run -r -p stacks-node --bin stacks-events | tee $STACKS_DIR/events.log
 ```
 
 Run `stacks-node` with an event observer:
+
 ```
-$ STACKS_EVENT_OBSERVER=localhost:3700 cargo run -r -p stacks-node --bin stacks-node start --config=testnet/stacks-node/conf/mocknet-miner-conf.toml
+$ STACKS_EVENT_OBSERVER=localhost:3700 cargo run -r -p stacks-node --bin stacks-node start --config testnet/stacks-node/conf/mocknet-miner-conf.toml
 ```
 
 You should see output from `stacks-events` in `events.logs` similar to:
+
 ```
 $ tail -F $STACKS_DIR/events.log
 {"path":"drop_mempool_tx","payload":{"dropped_txids":["0x6f78047f15ac3309153fc34be94ed8895111304336aec1ff106b7de051021e17, ..., "ts":"2022-08-12T05:03:08.577Z"}
@@ -103,21 +110,25 @@ $ tail -F $STACKS_DIR/events.log
 ## Historical Mining
 
 Discover the first recorded block height:
+
 ```
 $ cat $STACKS_DIR/events.log | egrep new_block | head -1 | jq .payload.block_height
 ```
 
 Discover a lower bound number of recorded transactions. This is a lower bound because each line in the events file is a list of transactions.
+
 ```
 $ cat $STACKS_DIR/events.log | egrep new_mempool_tx | wc -l
 ```
 
 Make a snapshot of the working directory:
+
 ```
 $ cp -r $STACKS_WORKING_DIR $STACKS_SNAPSHOT_DIR
 ```
 
 Run the `tip-mine` benchmark:
+
 ```
 $ export STACKS_TIP_MINE_BLOCK_HEIGHT=71294
 $ export STACKS_TIP_MINE_NUM_TXS=100
@@ -137,9 +148,11 @@ INFO [1661274285.417171] [src/chainstate/stacks/miner.rs:1628] [main] Miner: min
 Successfully mined block @ height = 71295 off of bd4fa09ece02e7fd53493c96bd69b89155058f7b28d4a659d87d89644208f41e (96cc06519e670eefb674aa2e9cfe0cfae103d4da/f0f0caa2afaae75417f14fe2fad1e3fd52b0169e66cb045b4954b9ab78611f31) in 7310ms.
 Block 4a64e0a4012acb6748a08784876c23f6f61aba08b7c826db5b57832935278f33: 3227082 uSTX, 31587 bytes, cost ExecutionCost { write_length: 84090, write_count: 1170, read_length: 20381499, read_count: 7529, runtime: 103717315 }
 ```
+
 In this run, `tip-mine` mined a block with 87 transactions.
 
 Alternatively, you can run `cargo build` separately from the target binary `stacks-inspect` to avoid re-building and speed up profiling:
+
 ```
 $ cargo build -F disable-costs -r --bin stacks-inspect
 $ ./target/release/stacks-inspect tip-mine $STACKS_SNAPSHOT_DIR $STACKS_DIR/events.log $STACKS_TIP_MINE_BLOCK_HEIGHT $STACKS_TIP_MINE_NUM_TXS
@@ -158,16 +171,19 @@ $ cargo install flamegraph
 flamegraph-rs uses [dtrace](https://en.wikipedia.org/wiki/DTrace) for profiling on Mac.
 
 Build `stacks-inspect` using the feature `disable-costs` to disable the block cost limits:
+
 ```
 $ cargo build -F disable-costs -r --bin stacks-inspect
 ```
 
 Generate a flame graph:
+
 ```
 $ flamegraph --root -o perf.svg -e cpu-clock --min-width 1 --deterministic -- ./target/release/stacks-inspect tip-mine $STACKS_SNAPSHOT_DIR $STACKS_DIR/events.log $STACKS_TIP_MINE_BLOCK_HEIGHT $STACKS_TIP_MINE_NUM_TXS
 ```
 
 You can open the flame graph using a browser:
+
 ```
 $ open perf.svg
 ```
@@ -183,21 +199,25 @@ The Linux performance tool `perf` has a performance bug which has been fixed. If
 Background on the `perf` performance bug: https://eighty-twenty.org/2021/09/09/perf-addr2line-speed-improvement
 
 Find out your kernel version:
+
 ```
 $ uname -a
 Linux localhost 5.15.0-25-generic #26~16.04.1-Ubuntu SMP Tue Oct 1 16:30:39 UTC 2018 x86_64 x86_64 x86_64 GNU/Linux
 ```
 
 Install dependencies, clone the linux kernel source, checkout the version tag matching your kernel version and build perf:
+
 ```
-$ sudo apt install -y git libzstd-dev libunwind-dev libcap-dev libdw-dev libdwarf-dev libbfd-dev libelf-dev systemtap-sdt-dev binutils-dev libnuma-dev libiberty-dev bison flex 
+$ sudo apt install -y git libzstd-dev libunwind-dev libcap-dev libdw-dev libdwarf-dev libbfd-dev libelf-dev systemtap-sdt-dev binutils-dev libnuma-dev libiberty-dev bison flex
 $ git clone https://github.com/torvalds/linux.git
 $ git checkout v5.15
 $ cd linux/tools/perf && make
 ```
 
 #### Running perf
+
 Grant kernel permissions to perf:
+
 ```
 $ sudo sed -i "$ a kernel.perf_event_paranoid = -1" /etc/sysctl.conf
 $ sudo sed -i "$ a kernel.kptr_restrict = 0" /etc/sysctl.conf
@@ -205,6 +225,7 @@ $ sysctl --system
 ```
 
 Note that you need to uncomment the following in `.cargo/config` (see [flamegraph-rs](https://github.com/flamegraph-rs/flamegraph) for details)
+
 ```
 [target.x86_64-unknown-linux-gnu]
 linker = "/usr/bin/clang"
@@ -212,11 +233,13 @@ rustflags = ["-Clink-arg=-fuse-ld=lld", "-Clink-arg=-Wl,--no-rosegment"]
 ```
 
 Build `stacks-inspect` using the feature `disable-costs` to disable the block cost limits:
+
 ```
 $ cargo build -F disable-costs -r --bin stacks-inspect
 ```
 
 Generate a flame graph using the locally built `perf` binary:
+
 ```
 $ PERF=~/linux/tools/perf/perf flamegraph --cmd "record -F 97 --call-graph dwarf,65528 -g -e cpu-clock" -o perf.svg --min-width 0.5 --deterministic -- ./target/release/stacks-inspect tip-mine $STACKS_SNAPSHOT_DIR $STACKS_DIR/events.log $STACKS_TIP_MINE_BLOCK_HEIGHT $STACKS_TIP_MINE_NUM_TXS
 ```
@@ -225,11 +248,11 @@ Output flame graph is in `perf.svg`.
 
 ## Profiling SQLite queries
 
-Set the environment variable `STACKS_LOG_DEBUG=1` and use the cargo feature `profile-sqlite`: 
+Set the environment variable `STACKS_LOG_DEBUG=1` and use the cargo feature `profile-sqlite`:
 
 ```
 $ STACKS_LOG_DEBUG=1 cargo run -F profile-sqlite,disable-costs -r --bin stacks-inspect try-mine $STACKS_WORKING_DIR
 ...
 DEBG [1661217664.809057] [src/util_lib/db.rs:666] [main] sqlite trace profile {"millis":1,"query":"SELECT value FROM data_table WHERE key = ?"}
 ...
-```
\ No newline at end of file
+```
diff --git a/net-test/bin/start.sh b/net-test/bin/start.sh
index 4b750ad060..d21bb90f70 100755
--- a/net-test/bin/start.sh
+++ b/net-test/bin/start.sh
@@ -145,7 +145,7 @@ start_stacks_master_node() {
    logln "ok"
 
    log "[$$] Starting Stacks master node..."
-   BLOCKSTACK_DEBUG=1 RUST_BACKTRACE=full stacks-node start --config="$STACKS_MASTER_CONF" >"$STACKS_MASTER_LOGFILE" 2>&1 &
+   BLOCKSTACK_DEBUG=1 RUST_BACKTRACE=full stacks-node start --config "$STACKS_MASTER_CONF" >"$STACKS_MASTER_LOGFILE" 2>&1 &
    local STACKS_PID=$!
    logln "PID $STACKS_PID"
 
@@ -233,7 +233,7 @@ start_stacks_miner_node() {
    logln "ok"
    
    log "[$$] Starting Stacks miner node..."
-   BLOCKSTACK_DEBUG=1 RUST_BACKTRACE=full stacks-node start --config="$STACKS_MINER_CONF" >"$STACKS_MINER_LOGFILE" 2>&1 &
+   BLOCKSTACK_DEBUG=1 RUST_BACKTRACE=full stacks-node start --config "$STACKS_MINER_CONF" >"$STACKS_MINER_LOGFILE" 2>&1 &
    local STACKS_PID=$!
    logln "PID $STACKS_PID"
    
@@ -265,7 +265,7 @@ start_stacks_follower_node() {
    logln "ok"
    
    log "[$$] Starting Stacks follower node..."
-   BLOCKSTACK_DEBUG=1 RUST_BACKTRACE=full stacks-node start --config="$STACKS_FOLLOWER_CONF" >"$STACKS_FOLLOWER_LOGFILE" 2>&1 &
+   BLOCKSTACK_DEBUG=1 RUST_BACKTRACE=full stacks-node start --config "$STACKS_FOLLOWER_CONF" >"$STACKS_FOLLOWER_LOGFILE" 2>&1 &
    local STACKS_PID=$!
    logln "PID $STACKS_PID"
 
diff --git a/testnet/stacks-node/src/main.rs b/testnet/stacks-node/src/main.rs
index 6495beab74..a9b7a46e78 100644
--- a/testnet/stacks-node/src/main.rs
+++ b/testnet/stacks-node/src/main.rs
@@ -487,14 +487,14 @@ start\t\tStart a node with a config of your own. Can be used for joining a netwo
 \t\tArguments:
 \t\t  --config: path of the config (such as https://github.com/blockstack/stacks-blockchain/blob/master/testnet/stacks-node/conf/testnet-follower-conf.toml).
 \t\tExample:
-\t\t  stacks-node start --config=/path/to/config.toml
+\t\t  stacks-node start --config /path/to/config.toml
 
 check-config\t\tValidates the config file without starting up the node. Uses same arguments as start subcommand.
 
 version\t\tDisplay information about the current version and our release cycle.
 
 key-for-seed\tOutput the associated secret key for a burnchain signer created with a given seed.
-\t\tCan be passed a config file for the seed via the `--config=<file>` option *or* by supplying the hex seed on
+\t\tCan be passed a config file for the seed via the `--config <file>` option *or* by supplying the hex seed on
 \t\tthe command line directly.
 
 help\t\tDisplay this help.

From a7cf6454bd0ca5b9629de0e5ae843c1adfbbb5b9 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Thu, 18 Jan 2024 15:35:42 -0500
Subject: [PATCH 0396/1166] chore: cargo fmt

---
 .../src/vm/analysis/contract_interface_builder/mod.rs    | 9 +++++----
 clarity/src/vm/functions/arithmetic.rs                   | 6 ++----
 stackslib/src/chainstate/stacks/db/transactions.rs       | 3 ++-
 3 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/clarity/src/vm/analysis/contract_interface_builder/mod.rs b/clarity/src/vm/analysis/contract_interface_builder/mod.rs
index 337ccc6216..c9bc3c71c1 100644
--- a/clarity/src/vm/analysis/contract_interface_builder/mod.rs
+++ b/clarity/src/vm/analysis/contract_interface_builder/mod.rs
@@ -19,15 +19,16 @@ use std::collections::{BTreeMap, BTreeSet};
 use stacks_common::types::StacksEpochId;
 
 use crate::vm::analysis::types::ContractAnalysis;
+use crate::vm::analysis::CheckResult;
 use crate::vm::types::signatures::CallableSubtype;
 use crate::vm::types::{
     FixedFunction, FunctionArg, FunctionType, TupleTypeSignature, TypeSignature,
 };
-use crate::vm::{ClarityName, ClarityVersion};
-use crate::vm::CheckErrors;
-use crate::vm::analysis::CheckResult;
+use crate::vm::{CheckErrors, ClarityName, ClarityVersion};
 
-pub fn build_contract_interface(contract_analysis: &ContractAnalysis) -> CheckResult<ContractInterface> {
+pub fn build_contract_interface(
+    contract_analysis: &ContractAnalysis,
+) -> CheckResult<ContractInterface> {
     let mut contract_interface =
         ContractInterface::new(contract_analysis.epoch, contract_analysis.clarity_version);
 
diff --git a/clarity/src/vm/functions/arithmetic.rs b/clarity/src/vm/functions/arithmetic.rs
index e6d2696ee8..bd0edbf5eb 100644
--- a/clarity/src/vm/functions/arithmetic.rs
+++ b/clarity/src/vm/functions/arithmetic.rs
@@ -22,15 +22,13 @@ use integer_sqrt::IntegerSquareRoot;
 use crate::vm::costs::cost_functions::ClarityCostFunction;
 use crate::vm::costs::runtime_cost;
 use crate::vm::errors::{
-    check_argument_count, CheckErrors, InterpreterError,
-    InterpreterResult, RuntimeErrorType
+    check_argument_count, CheckErrors, InterpreterError, InterpreterResult, RuntimeErrorType,
 };
 use crate::vm::representations::{SymbolicExpression, SymbolicExpressionType};
 use crate::vm::types::signatures::ListTypeData;
 use crate::vm::types::TypeSignature::BoolType;
 use crate::vm::types::{
-    ASCIIData, BuffData, CharType, ListData, SequenceData,
-    TypeSignature, UTF8Data, Value,
+    ASCIIData, BuffData, CharType, ListData, SequenceData, TypeSignature, UTF8Data, Value,
 };
 use crate::vm::version::ClarityVersion;
 use crate::vm::{apply, eval, lookup_function, CallableType, Environment, LocalContext};
diff --git a/stackslib/src/chainstate/stacks/db/transactions.rs b/stackslib/src/chainstate/stacks/db/transactions.rs
index f30f9f812a..e5e0bf19e9 100644
--- a/stackslib/src/chainstate/stacks/db/transactions.rs
+++ b/stackslib/src/chainstate/stacks/db/transactions.rs
@@ -1561,7 +1561,8 @@ pub mod test {
             // bump the epoch in the Clarity DB
             tx_conn
                 .with_clarity_db(|db| {
-                    db.set_clarity_epoch_version(StacksEpochId::Epoch21).unwrap();
+                    db.set_clarity_epoch_version(StacksEpochId::Epoch21)
+                        .unwrap();
                     Ok(())
                 })
                 .unwrap();

From cb0f1b889d4428d98b6ef9a21feec91260815c58 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Thu, 18 Jan 2024 15:29:31 -0600
Subject: [PATCH 0397/1166] initial implementation of signer-set computation,
 add event dispatch endpoint

---
 CHANGELOG.md                                  |   7 ++
 stacks-common/src/bitvec.rs                   |  35 ++++++
 stackslib/src/chainstate/coordinator/mod.rs   |  60 ++++++++--
 stackslib/src/chainstate/coordinator/tests.rs |  27 ++++-
 .../chainstate/nakamoto/coordinator/mod.rs    |  27 +++--
 stackslib/src/chainstate/nakamoto/mod.rs      |  27 ++++-
 .../src/chainstate/nakamoto/tests/mod.rs      |  33 ++++--
 .../src/chainstate/nakamoto/tests/node.rs     |   2 +-
 stackslib/src/chainstate/stacks/boot/mod.rs   | 108 +++++++++++++++++-
 stackslib/src/chainstate/stacks/db/blocks.rs  |  12 ++
 .../src/chainstate/stacks/transaction.rs      |   6 +-
 stackslib/src/net/mod.rs                      |   6 +-
 testnet/stacks-node/src/event_dispatcher.rs   |  20 ++++
 testnet/stacks-node/src/mockamoto.rs          |   4 +-
 testnet/stacks-node/src/neon_node.rs          |   2 +-
 .../src/tests/nakamoto_integrations.rs        |   2 +-
 16 files changed, 327 insertions(+), 51 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 62cdd25a6b..5bae35428f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,13 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to the versioning scheme outlined in the [README.md](README.md).
 
+## [Next-Branch]
+
+### Added
+
+- New `/new_pox_anchor` endpoint for broadcasting PoX anchor block processing.
+- Stacker bitvec in NakamotoBlock
+
 ## [2.4.0.0.4]
 
 This is a high-priority hotfix that addresses a bug in transaction processing which
diff --git a/stacks-common/src/bitvec.rs b/stacks-common/src/bitvec.rs
index 991aba63d6..707fc960d5 100644
--- a/stacks-common/src/bitvec.rs
+++ b/stacks-common/src/bitvec.rs
@@ -1,6 +1,11 @@
+use rusqlite::types::{FromSql, FromSqlError, FromSqlResult, ToSqlOutput, ValueRef};
+use rusqlite::ToSql;
+use serde::{Deserialize, Serialize};
+
 use crate::codec::{
     read_next, read_next_exact, write_next, Error as CodecError, StacksMessageCodec,
 };
+use crate::util::hash::{bytes_to_hex, hex_bytes};
 
 #[derive(Clone, PartialEq, Eq, Debug)]
 pub struct BitVec {
@@ -51,6 +56,36 @@ impl StacksMessageCodec for BitVec {
     }
 }
 
+impl Serialize for BitVec {
+    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        let hex = bytes_to_hex(self.serialize_to_vec().as_slice());
+        serializer.serialize_str(&hex)
+    }
+}
+
+impl<'de> Deserialize<'de> for BitVec {
+    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        let hex: &str = Deserialize::deserialize(deserializer)?;
+        let bytes = hex_bytes(hex).map_err(serde::de::Error::custom)?;
+        Self::consensus_deserialize(&mut bytes.as_slice()).map_err(serde::de::Error::custom)
+    }
+}
+
+impl FromSql for BitVec {
+    fn column_result(value: ValueRef<'_>) -> FromSqlResult<Self> {
+        let bytes = hex_bytes(value.as_str()?).map_err(|e| FromSqlError::Other(Box::new(e)))?;
+        Self::consensus_deserialize(&mut bytes.as_slice())
+            .map_err(|e| FromSqlError::Other(Box::new(e)))
+    }
+}
+
+impl ToSql for BitVec {
+    fn to_sql(&self) -> rusqlite::Result<ToSqlOutput<'_>> {
+        let hex = bytes_to_hex(self.serialize_to_vec().as_slice());
+        Ok(hex.into())
+    }
+}
+
 impl BitVec {
     /// Construct a new BitVec with all entries set to `false` and total length `len`
     pub fn zeros(len: u16) -> BitVec {
diff --git a/stackslib/src/chainstate/coordinator/mod.rs b/stackslib/src/chainstate/coordinator/mod.rs
index 8f7b5c80bc..ed7361be21 100644
--- a/stackslib/src/chainstate/coordinator/mod.rs
+++ b/stackslib/src/chainstate/coordinator/mod.rs
@@ -33,6 +33,7 @@ use stacks_common::util::get_epoch_time_secs;
 
 pub use self::comm::CoordinatorCommunication;
 use super::stacks::boot::RewardSet;
+use super::stacks::db::blocks::DummyEventDispatcher;
 use crate::burnchains::affirmation::{AffirmationMap, AffirmationMapEntry};
 use crate::burnchains::bitcoin::indexer::BitcoinIndexer;
 use crate::burnchains::db::{
@@ -189,6 +190,13 @@ pub trait BlockEventDispatcher {
         burns: u64,
         reward_recipients: Vec<PoxAddress>,
     );
+
+    fn announce_reward_set(
+        &self,
+        reward_set: &RewardSet,
+        block_id: &StacksBlockId,
+        cycle_number: u64,
+    );
 }
 
 pub struct ChainsCoordinatorConfig {
@@ -280,9 +288,15 @@ pub trait RewardSetProvider {
     ) -> Result<RewardSet, Error>;
 }
 
-pub struct OnChainRewardSetProvider();
+pub struct OnChainRewardSetProvider<'a, T: BlockEventDispatcher>(pub Option<&'a T>);
 
-impl RewardSetProvider for OnChainRewardSetProvider {
+impl OnChainRewardSetProvider<'static, DummyEventDispatcher> {
+    pub fn new() -> Self {
+        Self(None)
+    }
+}
+
+impl<'a, T: BlockEventDispatcher> RewardSetProvider for OnChainRewardSetProvider<'a, T> {
     fn get_reward_set(
         &self,
         cycle_start_burn_height: u64,
@@ -296,30 +310,45 @@ impl RewardSetProvider for OnChainRewardSetProvider {
                 "FATAL: no epoch for burn height {}",
                 cycle_start_burn_height
             ));
-        if cur_epoch.epoch_id < StacksEpochId::Epoch30 {
+        // TODO: should Epoch-2.5 be included in `get_reward_set_nakamoto()`?
+        // The differences are:
+        //     (a) no minimum participation threshold (I think this *is* important)
+        //     (b) panicking assertion if there are no signing-keys set
+        // Apart from (a), this shouldn't matter: the signing-keys are always set whenever
+        //  the reward set is loaded from pox-4.
+        let reward_set = if cur_epoch.epoch_id < StacksEpochId::Epoch30 {
             // Stacks 2.x epoch
-            return self.get_reward_set_epoch2(
+            self.get_reward_set_epoch2(
                 cycle_start_burn_height,
                 chainstate,
                 burnchain,
                 sortdb,
                 block_id,
                 cur_epoch,
-            );
+            )?
         } else {
             // Nakamoto epoch
-            return self.get_reward_set_nakamoto(
+            self.get_reward_set_nakamoto(
                 cycle_start_burn_height,
                 chainstate,
                 burnchain,
                 sortdb,
                 block_id,
-            );
+            )?
+        };
+
+        if let Some(dispatcher) = self.0 {
+            let cycle = burnchain
+                .block_height_to_reward_cycle(cycle_start_burn_height)
+                .expect("FATAL: no reward cycle for burn height");
+            dispatcher.announce_reward_set(&reward_set, block_id, cycle);
         }
+
+        Ok(reward_set)
     }
 }
 
-impl OnChainRewardSetProvider {
+impl<'a, T: BlockEventDispatcher> OnChainRewardSetProvider<'a, T> {
     fn get_reward_set_epoch2(
         &self,
         // Todo: `current_burn_height` is a misleading name: should be the `cycle_start_burn_height`
@@ -417,13 +446,22 @@ impl<
         CE: CostEstimator + ?Sized,
         FE: FeeEstimator + ?Sized,
         B: BurnchainHeaderReader,
-    > ChainsCoordinator<'a, T, ArcCounterCoordinatorNotices, OnChainRewardSetProvider, CE, FE, B>
+    >
+    ChainsCoordinator<
+        'a,
+        T,
+        ArcCounterCoordinatorNotices,
+        OnChainRewardSetProvider<'a, T>,
+        CE,
+        FE,
+        B,
+    >
 {
     pub fn run(
         config: ChainsCoordinatorConfig,
         chain_state_db: StacksChainState,
         burnchain: Burnchain,
-        dispatcher: &'a mut T,
+        dispatcher: &'a T,
         comms: CoordinatorReceivers,
         atlas_config: AtlasConfig,
         cost_estimator: Option<&'a mut CE>,
@@ -462,7 +500,7 @@ impl<
             burnchain,
             dispatcher: Some(dispatcher),
             notifier: arc_notices,
-            reward_set_provider: OnChainRewardSetProvider(),
+            reward_set_provider: OnChainRewardSetProvider(Some(dispatcher)),
             cost_estimator,
             fee_estimator,
             atlas_config,
diff --git a/stackslib/src/chainstate/coordinator/tests.rs b/stackslib/src/chainstate/coordinator/tests.rs
index f5655c356b..79007d421e 100644
--- a/stackslib/src/chainstate/coordinator/tests.rs
+++ b/stackslib/src/chainstate/coordinator/tests.rs
@@ -447,15 +447,22 @@ impl BlockEventDispatcher for NullEventDispatcher {
 pub fn make_coordinator<'a>(
     path: &str,
     burnchain: Option<Burnchain>,
-) -> ChainsCoordinator<'a, NullEventDispatcher, (), OnChainRewardSetProvider, (), (), BitcoinIndexer>
-{
+) -> ChainsCoordinator<
+    'a,
+    NullEventDispatcher,
+    (),
+    OnChainRewardSetProvider<'a, NullEventDispatcher>,
+    (),
+    (),
+    BitcoinIndexer,
+> {
     let burnchain = burnchain.unwrap_or_else(|| get_burnchain(path, None));
     let indexer = BitcoinIndexer::new_unit_test(&burnchain.working_dir);
     ChainsCoordinator::test_new(
         &burnchain,
         0x80000000,
         path,
-        OnChainRewardSetProvider(),
+        OnChainRewardSetProvider(None),
         indexer,
     )
 }
@@ -464,15 +471,22 @@ pub fn make_coordinator_atlas<'a>(
     path: &str,
     burnchain: Option<Burnchain>,
     atlas_config: Option<AtlasConfig>,
-) -> ChainsCoordinator<'a, NullEventDispatcher, (), OnChainRewardSetProvider, (), (), BitcoinIndexer>
-{
+) -> ChainsCoordinator<
+    'a,
+    NullEventDispatcher,
+    (),
+    OnChainRewardSetProvider<'a, NullEventDispatcher>,
+    (),
+    (),
+    BitcoinIndexer,
+> {
     let burnchain = burnchain.unwrap_or_else(|| get_burnchain(path, None));
     let indexer = BitcoinIndexer::new_unit_test(&burnchain.working_dir);
     ChainsCoordinator::test_new_full(
         &burnchain,
         0x80000000,
         path,
-        OnChainRewardSetProvider(),
+        OnChainRewardSetProvider(None),
         None,
         indexer,
         atlas_config,
@@ -495,6 +509,7 @@ impl RewardSetProvider for StubbedRewardSetProvider {
             start_cycle_state: PoxStartCycleInfo {
                 missed_reward_slots: vec![],
             },
+            signers: None,
         })
     }
 }
diff --git a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
index e46c16c660..3501ef3c73 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
@@ -50,7 +50,7 @@ use crate::util_lib::db::Error as DBError;
 #[cfg(test)]
 pub mod tests;
 
-impl OnChainRewardSetProvider {
+impl<'a, T: BlockEventDispatcher> OnChainRewardSetProvider<'a, T> {
     pub fn get_reward_set_nakamoto(
         &self,
         cycle_start_burn_height: u64,
@@ -63,9 +63,20 @@ impl OnChainRewardSetProvider {
             .block_height_to_reward_cycle(cycle_start_burn_height)
             .expect("FATAL: no reward cycle for burn height");
 
-        let registered_addrs =
+        let mut registered_addrs =
             chainstate.get_reward_addresses_in_cycle(burnchain, sortdb, cycle, block_id)?;
 
+        // TODO (pox-4-workstream): the pox-4 contract must be able to return signing keys
+        //   associated with reward set entries (i.e., via `get-reward-set-pox-addresses`)
+        //   *not* stacking-state entries (as it is currently implemented). Until that's done,
+        //   this method just mocks that data.
+        for (index, entry) in registered_addrs.iter_mut().enumerate() {
+            let index = u64::try_from(index).expect("FATAL: more than u64 reward set entries");
+            let mut bytes = [0; 33];
+            bytes[0..8].copy_from_slice(&index.to_be_bytes());
+            entry.signing_key = Some(bytes);
+        }
+
         let liquid_ustx = chainstate.get_liquid_ustx(block_id);
 
         let (threshold, participation) = StacksChainState::get_reward_threshold_and_participation(
@@ -93,11 +104,13 @@ impl OnChainRewardSetProvider {
               "liquid_ustx" => liquid_ustx,
               "registered_addrs" => registered_addrs.len());
 
-        Ok(StacksChainState::make_reward_set(
-            threshold,
-            registered_addrs,
-            cur_epoch.epoch_id,
-        ))
+        let reward_set =
+            StacksChainState::make_reward_set(threshold, registered_addrs, cur_epoch.epoch_id);
+        if reward_set.signers.is_none() {
+            error!("FATAL: PoX reward set did not specify signer set in Nakamoto");
+            return Err(Error::PoXAnchorBlockRequired);
+        }
+        Ok(reward_set)
     }
 }
 
diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index 23662cab50..c99c243e01 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -27,6 +27,7 @@ use lazy_static::{__Deref, lazy_static};
 use rusqlite::types::{FromSql, FromSqlError};
 use rusqlite::{params, Connection, OptionalExtension, ToSql, NO_PARAMS};
 use sha2::{Digest as Sha2Digest, Sha512_256};
+use stacks_common::bitvec::BitVec;
 use stacks_common::codec::{
     read_next, write_next, Error as CodecError, StacksMessageCodec, MAX_MESSAGE_LEN,
     MAX_PAYLOAD_LEN,
@@ -189,6 +190,8 @@ lazy_static! {
                      miner_signature TEXT NOT NULL,
                      -- signers' signature over the block
                      signer_signature TEXT NOT NULL,
+                     -- bitvec capturing stacker participation in signature
+                     signer_bitvec TEXT NOT NULL,
           -- The following fields are not part of either the StacksHeaderInfo struct
           --   or its contained NakamotoBlockHeader struct, but are used for querying
                      -- what kind of header this is (nakamoto or stacks 2.x)
@@ -313,6 +316,8 @@ pub struct NakamotoBlockHeader {
     pub miner_signature: MessageSignature,
     /// Schnorr signature over the block header from the signer set active during the tenure.
     pub signer_signature: ThresholdSignature,
+    /// A bitvec which represents the signers that participated in this block signature.
+    pub signer_bitvec: BitVec,
 }
 
 impl FromRow<NakamotoBlockHeader> for NakamotoBlockHeader {
@@ -330,6 +335,7 @@ impl FromRow<NakamotoBlockHeader> for NakamotoBlockHeader {
         let state_index_root = row.get("state_index_root")?;
         let signer_signature = row.get("signer_signature")?;
         let miner_signature = row.get("miner_signature")?;
+        let signer_bitvec = row.get("signer_bitvec")?;
 
         Ok(NakamotoBlockHeader {
             version,
@@ -341,6 +347,7 @@ impl FromRow<NakamotoBlockHeader> for NakamotoBlockHeader {
             state_index_root,
             signer_signature,
             miner_signature,
+            signer_bitvec,
         })
     }
 }
@@ -364,6 +371,7 @@ impl StacksMessageCodec for NakamotoBlockHeader {
         write_next(fd, &self.state_index_root)?;
         write_next(fd, &self.miner_signature)?;
         write_next(fd, &self.signer_signature)?;
+        write_next(fd, &self.signer_bitvec)?;
 
         Ok(())
     }
@@ -379,6 +387,7 @@ impl StacksMessageCodec for NakamotoBlockHeader {
             state_index_root: read_next(fd)?,
             miner_signature: read_next(fd)?,
             signer_signature: read_next(fd)?,
+            signer_bitvec: read_next(fd)?,
         })
     }
 }
@@ -412,6 +421,7 @@ impl NakamotoBlockHeader {
         write_next(fd, &self.tx_merkle_root)?;
         write_next(fd, &self.state_index_root)?;
         write_next(fd, &self.miner_signature)?;
+        write_next(fd, &self.signer_bitvec)?;
         Ok(Sha512Trunc256Sum::from_hasher(hasher))
     }
 
@@ -463,8 +473,8 @@ impl NakamotoBlockHeader {
             tx_merkle_root: Sha512Trunc256Sum([0u8; 32]),
             state_index_root: TrieHash([0u8; 32]),
             miner_signature: MessageSignature::empty(),
-            // TODO: `mock()` should be updated to `empty()` and rustdocs updated
-            signer_signature: ThresholdSignature::mock(),
+            signer_signature: ThresholdSignature::empty(),
+            signer_bitvec: BitVec::zeros(1),
         }
     }
 
@@ -479,7 +489,8 @@ impl NakamotoBlockHeader {
             tx_merkle_root: Sha512Trunc256Sum([0u8; 32]),
             state_index_root: TrieHash([0u8; 32]),
             miner_signature: MessageSignature::empty(),
-            signer_signature: ThresholdSignature::mock(),
+            signer_signature: ThresholdSignature::empty(),
+            signer_bitvec: BitVec::zeros(1),
         }
     }
 
@@ -494,7 +505,8 @@ impl NakamotoBlockHeader {
             tx_merkle_root: Sha512Trunc256Sum([0u8; 32]),
             state_index_root: TrieHash([0u8; 32]),
             miner_signature: MessageSignature::empty(),
-            signer_signature: ThresholdSignature::mock(),
+            signer_signature: ThresholdSignature::empty(),
+            signer_bitvec: BitVec::zeros(1),
         }
     }
 }
@@ -2165,6 +2177,7 @@ impl NakamotoChainState {
             &header.parent_block_id,
             if tenure_changed { &1i64 } else { &0i64 },
             &vrf_proof_bytes.as_ref(),
+            &header.signer_bitvec,
         ];
 
         chainstate_tx.execute(
@@ -2184,8 +2197,10 @@ impl NakamotoChainState {
                      tenure_tx_fees,
                      parent_block_id,
                      tenure_changed,
-                     vrf_proof)
-                    VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14, ?15, ?16, ?17, ?18, ?19, ?20, ?21, ?22, ?23)",
+                     vrf_proof,
+                     signer_bitvec
+                    )
+                    VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14, ?15, ?16, ?17, ?18, ?19, ?20, ?21, ?22, ?23, ?24)",
             args
         )?;
 
diff --git a/stackslib/src/chainstate/nakamoto/tests/mod.rs b/stackslib/src/chainstate/nakamoto/tests/mod.rs
index 64f8fa3d13..28c52bd029 100644
--- a/stackslib/src/chainstate/nakamoto/tests/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/mod.rs
@@ -22,6 +22,7 @@ use clarity::vm::clarity::ClarityConnection;
 use clarity::vm::costs::ExecutionCost;
 use clarity::vm::types::StacksAddressExtensions;
 use stacks_common::address::AddressHashMode;
+use stacks_common::bitvec::BitVec;
 use stacks_common::codec::StacksMessageCodec;
 use stacks_common::consts::{FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH};
 use stacks_common::types::chainstate::{
@@ -116,10 +117,11 @@ fn codec_nakamoto_header() {
         tx_merkle_root: Sha512Trunc256Sum([0x06; 32]),
         state_index_root: TrieHash([0x07; 32]),
         miner_signature: MessageSignature::empty(),
-        signer_signature: ThresholdSignature::mock(),
+        signer_signature: ThresholdSignature::empty(),
+        signer_bitvec: BitVec::zeros(8),
     };
 
-    let bytes = vec![
+    let mut bytes = vec![
         // version
         0x01, // chain length
         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, // burn spent
@@ -147,6 +149,9 @@ fn codec_nakamoto_header() {
         0x00, 0x00, 0x00, 0x00, 0x00,
     ];
 
+    let signer_bitvec_serialization = "00080000000100";
+    bytes.append(&mut hex_bytes(signer_bitvec_serialization).unwrap());
+
     check_codec_and_corruption(&header, &bytes);
 }
 
@@ -162,7 +167,8 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
         tx_merkle_root: Sha512Trunc256Sum([0x06; 32]),
         state_index_root: TrieHash([0x07; 32]),
         miner_signature: MessageSignature::empty(),
-        signer_signature: ThresholdSignature::mock(),
+        signer_signature: ThresholdSignature::empty(),
+        signer_bitvec: BitVec::zeros(1),
     };
 
     // sortition-inducing tenure change
@@ -659,7 +665,8 @@ pub fn test_load_store_update_nakamoto_blocks() {
         tx_merkle_root: nakamoto_tx_merkle_root,
         state_index_root: TrieHash([0x07; 32]),
         miner_signature: MessageSignature::empty(),
-        signer_signature: ThresholdSignature::mock(),
+        signer_signature: ThresholdSignature::empty(),
+        signer_bitvec: BitVec::zeros(1),
     };
 
     let nakamoto_header_info = StacksHeaderInfo {
@@ -702,7 +709,8 @@ pub fn test_load_store_update_nakamoto_blocks() {
         tx_merkle_root: nakamoto_tx_merkle_root_2,
         state_index_root: TrieHash([0x07; 32]),
         miner_signature: MessageSignature::empty(),
-        signer_signature: ThresholdSignature::mock(),
+        signer_signature: ThresholdSignature::empty(),
+        signer_bitvec: BitVec::zeros(1),
     };
 
     let nakamoto_header_info_2 = StacksHeaderInfo {
@@ -1338,7 +1346,8 @@ fn test_nakamoto_block_static_verification() {
         tx_merkle_root: nakamoto_tx_merkle_root,
         state_index_root: TrieHash([0x07; 32]),
         miner_signature: MessageSignature::empty(),
-        signer_signature: ThresholdSignature::mock(),
+        signer_signature: ThresholdSignature::empty(),
+        signer_bitvec: BitVec::zeros(1),
     };
     nakamoto_header.sign_miner(&private_key).unwrap();
 
@@ -1356,7 +1365,8 @@ fn test_nakamoto_block_static_verification() {
         tx_merkle_root: nakamoto_tx_merkle_root_bad_ch,
         state_index_root: TrieHash([0x07; 32]),
         miner_signature: MessageSignature::empty(),
-        signer_signature: ThresholdSignature::mock(),
+        signer_signature: ThresholdSignature::empty(),
+        signer_bitvec: BitVec::zeros(1),
     };
     nakamoto_header_bad_ch.sign_miner(&private_key).unwrap();
 
@@ -1374,7 +1384,8 @@ fn test_nakamoto_block_static_verification() {
         tx_merkle_root: nakamoto_tx_merkle_root_bad_miner_sig,
         state_index_root: TrieHash([0x07; 32]),
         miner_signature: MessageSignature::empty(),
-        signer_signature: ThresholdSignature::mock(),
+        signer_signature: ThresholdSignature::empty(),
+        signer_bitvec: BitVec::zeros(1),
     };
     nakamoto_header_bad_miner_sig
         .sign_miner(&private_key)
@@ -1524,7 +1535,8 @@ pub fn test_get_highest_nakamoto_tenure() {
             tx_merkle_root: Sha512Trunc256Sum([0x00; 32]),
             state_index_root: TrieHash([0x00; 32]),
             miner_signature: MessageSignature::empty(),
-            signer_signature: ThresholdSignature::mock(),
+            signer_signature: ThresholdSignature::empty(),
+            signer_bitvec: BitVec::zeros(1),
         };
         let tenure_change = TenureChangePayload {
             tenure_consensus_hash: sn.consensus_hash.clone(),
@@ -1821,7 +1833,8 @@ fn test_make_miners_stackerdb_config() {
             tx_merkle_root: Sha512Trunc256Sum([0x06; 32]),
             state_index_root: TrieHash([0x07; 32]),
             miner_signature: MessageSignature::empty(),
-            signer_signature: ThresholdSignature::mock(),
+            signer_signature: ThresholdSignature::empty(),
+            signer_bitvec: BitVec::zeros(1),
         };
         let block = NakamotoBlock {
             header,
diff --git a/stackslib/src/chainstate/nakamoto/tests/node.rs b/stackslib/src/chainstate/nakamoto/tests/node.rs
index 9c96ca1e6c..fd69c3280f 100644
--- a/stackslib/src/chainstate/nakamoto/tests/node.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/node.rs
@@ -506,7 +506,7 @@ impl TestStacksNode {
             'a,
             TestEventObserver,
             (),
-            OnChainRewardSetProvider,
+            OnChainRewardSetProvider<'a, TestEventObserver>,
             (),
             (),
             BitcoinIndexer,
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 6cad2b1ca4..36883ad4b8 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -16,6 +16,7 @@
 
 use std::boxed::Box;
 use std::cmp;
+use std::collections::BTreeMap;
 use std::convert::{TryFrom, TryInto};
 
 use clarity::vm::analysis::CheckErrors;
@@ -34,11 +35,12 @@ use clarity::vm::types::{
 };
 use clarity::vm::{ClarityVersion, Environment, SymbolicExpression};
 use lazy_static::lazy_static;
+use serde::Deserialize;
 use stacks_common::address::AddressHashMode;
 use stacks_common::codec::StacksMessageCodec;
 use stacks_common::types;
 use stacks_common::types::chainstate::{BlockHeaderHash, StacksAddress, StacksBlockId};
-use stacks_common::util::hash::{to_hex, Hash160};
+use stacks_common::util::hash::{hex_bytes, to_hex, Hash160};
 use wsts::curve::point::{Compressed, Point};
 use wsts::curve::scalar::Scalar;
 
@@ -153,6 +155,7 @@ pub struct RawRewardSetEntry {
     pub reward_address: PoxAddress,
     pub amount_stacked: u128,
     pub stacker: Option<PrincipalData>,
+    pub signing_key: Option<[u8; 33]>,
 }
 
 #[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
@@ -166,10 +169,40 @@ pub struct PoxStartCycleInfo {
     pub missed_reward_slots: Vec<(PrincipalData, u128)>,
 }
 
+fn hex_serialize<S: serde::Serializer>(bytes: &[u8], s: S) -> Result<S::Ok, S::Error> {
+    let inst = to_hex(bytes);
+    s.serialize_str(inst.as_str())
+}
+
+fn hex_deserialize<'de, D: serde::Deserializer<'de>>(d: D) -> Result<[u8; 33], D::Error> {
+    let inst_str = String::deserialize(d)?;
+    let mut out = [0; 33];
+    let bytes = hex_bytes(&inst_str).map_err(serde::de::Error::custom)?;
+    if bytes.len() != out.len() {
+        return Err(serde::de::Error::invalid_length(
+            bytes.len(),
+            &"Expected hex-encoded buffer of byte-length 33",
+        ));
+    }
+    out.copy_from_slice(bytes.as_slice());
+    Ok(out)
+}
+
+#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
+pub struct NakamotoSignerEntry {
+    #[serde(serialize_with = "hex_serialize", deserialize_with = "hex_deserialize")]
+    pub signing_key: [u8; 33],
+    pub stacked_amt: u128,
+    pub slots: u32,
+}
+
 #[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
 pub struct RewardSet {
     pub rewarded_addresses: Vec<PoxAddress>,
     pub start_cycle_state: PoxStartCycleInfo,
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    // only generated for nakamoto reward sets
+    pub signers: Option<Vec<NakamotoSignerEntry>>,
 }
 
 const POX_CYCLE_START_HANDLED_VALUE: &'static str = "1";
@@ -196,6 +229,7 @@ impl RewardSet {
             start_cycle_state: PoxStartCycleInfo {
                 missed_reward_slots: vec![],
             },
+            signers: None,
         }
     }
 }
@@ -575,6 +609,58 @@ impl StacksChainState {
         .map(|value| value.expect_bool())
     }
 
+    pub fn make_signer_set(
+        threshold: u128,
+        entries: &[RawRewardSetEntry],
+    ) -> Option<Vec<NakamotoSignerEntry>> {
+        let Some(first_entry) = entries.first() else {
+            // entries is empty: there's no signer set
+            return None;
+        };
+        // signing keys must be all-or-nothing in the reward set
+        let expects_signing_keys = first_entry.signing_key.is_some();
+        for entry in entries.iter() {
+            if entry.signing_key.is_some() != expects_signing_keys {
+                panic!("FATAL: stacking-set contains mismatched entries with and without signing keys.");
+            }
+        }
+        if !expects_signing_keys {
+            return None;
+        }
+
+        let mut signer_set = BTreeMap::new();
+        for entry in entries.iter() {
+            let signing_key = entry.signing_key.as_ref().unwrap();
+            if let Some(existing_entry) = signer_set.get_mut(signing_key) {
+                *existing_entry += entry.amount_stacked;
+            } else {
+                signer_set.insert(signing_key.clone(), entry.amount_stacked);
+            };
+        }
+
+        let mut signer_set: Vec<_> = signer_set
+            .into_iter()
+            .filter_map(|(signing_key, stacked_amt)| {
+                let slots = u32::try_from(stacked_amt / threshold)
+                    .expect("CORRUPTION: Stacker claimed > u32::max() reward slots");
+                if slots == 0 {
+                    return None;
+                }
+                Some(NakamotoSignerEntry {
+                    signing_key,
+                    stacked_amt,
+                    slots,
+                })
+            })
+            .collect();
+
+        // finally, we must sort the signer set: the signer participation bit vector depends
+        //  on a consensus-critical ordering of the signer set.
+        signer_set.sort_by_key(|entry| entry.signing_key);
+
+        Some(signer_set)
+    }
+
     /// Given a threshold and set of registered addresses, return a reward set where
     ///   every entry address has stacked more than the threshold, and addresses
     ///   are repeated floor(stacked_amt / threshold) times.
@@ -593,10 +679,14 @@ impl StacksChainState {
         } else {
             addresses.sort_by_cached_key(|k| k.reward_address.to_burnchain_repr());
         }
+
+        let signer_set = Self::make_signer_set(threshold, &addresses);
+
         while let Some(RawRewardSetEntry {
             reward_address: address,
             amount_stacked: mut stacked_amt,
             stacker,
+            ..
         }) = addresses.pop()
         {
             let mut contributed_stackers = vec![];
@@ -673,6 +763,7 @@ impl StacksChainState {
             start_cycle_state: PoxStartCycleInfo {
                 missed_reward_slots: missed_slots,
             },
+            signers: signer_set,
         }
     }
 
@@ -800,6 +891,7 @@ impl StacksChainState {
                 reward_address,
                 amount_stacked: total_ustx,
                 stacker: None,
+                signing_key: None,
             })
         }
 
@@ -889,6 +981,7 @@ impl StacksChainState {
                 reward_address,
                 amount_stacked: total_ustx,
                 stacker,
+                signing_key: None,
             })
         }
 
@@ -978,6 +1071,7 @@ impl StacksChainState {
                 reward_address,
                 amount_stacked: total_ustx,
                 stacker,
+                signing_key: None,
             })
         }
 
@@ -1061,6 +1155,7 @@ impl StacksChainState {
                 reward_address,
                 amount_stacked: total_ustx,
                 stacker,
+                signing_key: None,
             })
         }
 
@@ -1209,6 +1304,7 @@ pub mod test {
                 ),
                 amount_stacked: 1500,
                 stacker: None,
+                signing_key: None,
             },
             RawRewardSetEntry {
                 reward_address: PoxAddress::Standard(
@@ -1218,6 +1314,7 @@ pub mod test {
 
                 amount_stacked: 500,
                 stacker: None,
+                signing_key: None,
             },
             RawRewardSetEntry {
                 reward_address: PoxAddress::Standard(
@@ -1226,6 +1323,7 @@ pub mod test {
                 ),
                 amount_stacked: 1500,
                 stacker: None,
+                signing_key: None,
             },
             RawRewardSetEntry {
                 reward_address: PoxAddress::Standard(
@@ -1234,6 +1332,7 @@ pub mod test {
                 ),
                 amount_stacked: 400,
                 stacker: None,
+                signing_key: None,
             },
         ];
         assert_eq!(
@@ -1283,6 +1382,7 @@ pub mod test {
                     reward_address: rand_pox_addr(),
                     amount_stacked: liquid,
                     stacker: None,
+                    signing_key: None,
                 }],
                 liquid,
             )
@@ -1309,6 +1409,7 @@ pub mod test {
                     reward_address: rand_pox_addr(),
                     amount_stacked: liquid / 4,
                     stacker: None,
+                    signing_key: None,
                 }],
                 liquid,
             )
@@ -1324,11 +1425,13 @@ pub mod test {
                         reward_address: rand_pox_addr(),
                         amount_stacked: liquid / 4,
                         stacker: None,
+                        signing_key: None,
                     },
                     RawRewardSetEntry {
                         reward_address: rand_pox_addr(),
                         amount_stacked: 10_000_000 * (MICROSTACKS_PER_STACKS as u128),
                         stacker: None,
+                        signing_key: None,
                     },
                 ],
                 liquid,
@@ -1346,11 +1449,13 @@ pub mod test {
                         reward_address: rand_pox_addr(),
                         amount_stacked: liquid / 4,
                         stacker: None,
+                        signing_key: None,
                     },
                     RawRewardSetEntry {
                         reward_address: rand_pox_addr(),
                         amount_stacked: MICROSTACKS_PER_STACKS as u128,
                         stacker: None,
+                        signing_key: None,
                     },
                 ],
                 liquid,
@@ -1367,6 +1472,7 @@ pub mod test {
                     reward_address: rand_pox_addr(),
                     amount_stacked: liquid,
                     stacker: None,
+                    signing_key: None,
                 }],
                 liquid,
             )
diff --git a/stackslib/src/chainstate/stacks/db/blocks.rs b/stackslib/src/chainstate/stacks/db/blocks.rs
index 44ee696b26..f42c18461f 100644
--- a/stackslib/src/chainstate/stacks/db/blocks.rs
+++ b/stackslib/src/chainstate/stacks/db/blocks.rs
@@ -208,6 +208,18 @@ impl BlockEventDispatcher for DummyEventDispatcher {
             "We should never try to announce to the dummy dispatcher"
         );
     }
+
+    fn announce_reward_set(
+        &self,
+        _reward_set: &RewardSet,
+        _block_id: &StacksBlockId,
+        _cycle_number: u64,
+    ) {
+        assert!(
+            false,
+            "We should never try to announce to the dummy dispatcher"
+        );
+    }
 }
 
 impl MemPoolRejection {
diff --git a/stackslib/src/chainstate/stacks/transaction.rs b/stackslib/src/chainstate/stacks/transaction.rs
index 248ab2180e..0c764ec83b 100644
--- a/stackslib/src/chainstate/stacks/transaction.rs
+++ b/stackslib/src/chainstate/stacks/transaction.rs
@@ -183,9 +183,9 @@ impl ThresholdSignature {
         self.0.verify(public_key, msg)
     }
 
-    /// Create mock data for testing. Not valid data
-    // TODO: `mock()` should be updated to `empty()` and rustdocs updated
-    pub fn mock() -> Self {
+    /// Create an empty/null signature. This is not valid data, but it is used
+    ///  as a placeholder in the header during mining.
+    pub fn empty() -> Self {
         Self(Secp256k1Signature {
             R: Secp256k1Point::G(),
             z: Secp256k1Scalar::new(),
diff --git a/stackslib/src/net/mod.rs b/stackslib/src/net/mod.rs
index 46f0d67141..dd92aba99b 100644
--- a/stackslib/src/net/mod.rs
+++ b/stackslib/src/net/mod.rs
@@ -2099,7 +2099,7 @@ pub mod test {
             'a,
             TestEventObserver,
             (),
-            OnChainRewardSetProvider,
+            OnChainRewardSetProvider<'a, TestEventObserver>,
             (),
             (),
             BitcoinIndexer,
@@ -2337,7 +2337,7 @@ pub mod test {
                 &config.burnchain,
                 config.network_id,
                 &test_path,
-                OnChainRewardSetProvider(),
+                OnChainRewardSetProvider(observer),
                 observer,
                 indexer,
                 None,
@@ -3342,7 +3342,7 @@ pub mod test {
                 &mut stacks_node.chainstate,
                 &mut sortdb,
                 &self.config.burnchain,
-                &OnChainRewardSetProvider(),
+                &OnChainRewardSetProvider::new(),
                 true,
             ) {
                 Ok(recipients) => {
diff --git a/testnet/stacks-node/src/event_dispatcher.rs b/testnet/stacks-node/src/event_dispatcher.rs
index 6c48ae9214..6787c11f3d 100644
--- a/testnet/stacks-node/src/event_dispatcher.rs
+++ b/testnet/stacks-node/src/event_dispatcher.rs
@@ -17,6 +17,7 @@ use stacks::chainstate::burn::ConsensusHash;
 use stacks::chainstate::coordinator::BlockEventDispatcher;
 use stacks::chainstate::nakamoto::NakamotoBlock;
 use stacks::chainstate::stacks::address::PoxAddress;
+use stacks::chainstate::stacks::boot::{NakamotoSignerEntry, RewardSet};
 use stacks::chainstate::stacks::db::accounts::MinerReward;
 use stacks::chainstate::stacks::db::unconfirmed::ProcessedUnconfirmedState;
 use stacks::chainstate::stacks::db::{MinerRewardInfo, StacksHeaderInfo};
@@ -71,6 +72,7 @@ pub const PATH_BURN_BLOCK_SUBMIT: &str = "new_burn_block";
 pub const PATH_BLOCK_PROCESSED: &str = "new_block";
 pub const PATH_ATTACHMENT_PROCESSED: &str = "attachments/new";
 pub const PATH_PROPOSAL_RESPONSE: &str = "proposal_response";
+pub const PATH_POX_ANCHOR: &str = "new_pox_anchor";
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct MinedBlockEvent {
@@ -103,6 +105,15 @@ pub struct MinedNakamotoBlockEvent {
     pub tx_events: Vec<TransactionEvent>,
 }
 
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct PoxAnchorBlockEvent {
+    /// the StacksBlockId of the PoX anchor block
+    pub block_id: String,
+    pub reward_cycle: u64,
+    pub total_stx_stacked: u128,
+    pub signer_set: Vec<NakamotoSignerEntry>,
+}
+
 impl EventObserver {
     pub fn send_payload(&self, payload: &serde_json::Value, path: &str) {
         let body = match serde_json::to_vec(&payload) {
@@ -614,6 +625,15 @@ impl BlockEventDispatcher for EventDispatcher {
             recipient_info,
         )
     }
+
+    fn announce_reward_set(
+        &self,
+        reward_set: &RewardSet,
+        block_id: &StacksBlockId,
+        cycle_number: u64,
+    ) {
+        todo!("Announce PoX block `{block_id}` for cycle `{cycle_number}`: {reward_set:?}");
+    }
 }
 
 impl EventDispatcher {
diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index 3227b50ec0..6fa831fd8f 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -70,6 +70,7 @@ use stacks::net::relay::Relayer;
 use stacks::net::stackerdb::StackerDBs;
 use stacks::util_lib::db::Error as DBError;
 use stacks_common::address::{AddressHashMode, C32_ADDRESS_VERSION_TESTNET_SINGLESIG};
+use stacks_common::bitvec::BitVec;
 use stacks_common::codec::StacksMessageCodec;
 use stacks_common::consts::{
     FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH, STACKS_EPOCH_MAX,
@@ -966,10 +967,11 @@ impl MockamotoNode {
                 burn_spent: sortition_tip.total_burn,
                 tx_merkle_root: tx_merkle_tree.root(),
                 state_index_root,
-                signer_signature: ThresholdSignature::mock(),
+                signer_signature: ThresholdSignature::empty(),
                 miner_signature: MessageSignature::empty(),
                 consensus_hash: sortition_tip.consensus_hash.clone(),
                 parent_block_id: StacksBlockId::new(&chain_tip_ch, &chain_tip_bh),
+                signer_bitvec: BitVec::zeros(1),
             },
             txs: builder.txs,
         };
diff --git a/testnet/stacks-node/src/neon_node.rs b/testnet/stacks-node/src/neon_node.rs
index 0305801107..f3c9307eec 100644
--- a/testnet/stacks-node/src/neon_node.rs
+++ b/testnet/stacks-node/src/neon_node.rs
@@ -1454,7 +1454,7 @@ impl BlockMinerThread {
             chain_state,
             burn_db,
             &self.burnchain,
-            &OnChainRewardSetProvider(),
+            &OnChainRewardSetProvider::new(),
             self.config.node.always_use_affirmation_maps,
         ) {
             Ok(x) => x,
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 0bbd826ca2..aa979bda0e 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -1420,7 +1420,7 @@ fn miner_writes_proposed_block_to_stackerdb() {
 
     let mut proposed_zero_block = proposed_block.clone();
     proposed_zero_block.header.miner_signature = MessageSignature::empty();
-    proposed_zero_block.header.signer_signature = ThresholdSignature::mock();
+    proposed_zero_block.header.signer_signature = ThresholdSignature::empty();
     let proposed_zero_block_hash = format!("0x{}", proposed_zero_block.header.block_hash());
 
     coord_channel

From e42195e7b8b6fc7456d6b3f154845bb948e07280 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Thu, 18 Jan 2024 18:01:49 -0500
Subject: [PATCH 0398/1166] chore:  a few fixes to neighbor lifecycle to make
 the node less chatty

---
 stackslib/src/net/connection.rs      |  2 +-
 stackslib/src/net/mod.rs             | 22 ++++++++-
 stackslib/src/net/neighbors/db.rs    | 68 +++++++++++++++++++---------
 stackslib/src/net/tests/neighbors.rs |  2 +-
 4 files changed, 68 insertions(+), 26 deletions(-)

diff --git a/stackslib/src/net/connection.rs b/stackslib/src/net/connection.rs
index 522a0f6343..195303b1a4 100644
--- a/stackslib/src/net/connection.rs
+++ b/stackslib/src/net/connection.rs
@@ -77,7 +77,7 @@ impl<P: ProtocolFamily> ReceiverNotify<P> {
         match self.receiver_input.send(msg) {
             Ok(_) => {}
             Err(e) => {
-                warn!(
+                debug!(
                     "Failed to reply message {} ({} {}): {:?}",
                     self.expected_seq, msg_name, msg_id, &e
                 );
diff --git a/stackslib/src/net/mod.rs b/stackslib/src/net/mod.rs
index 1a36569fd1..83f2d69a89 100644
--- a/stackslib/src/net/mod.rs
+++ b/stackslib/src/net/mod.rs
@@ -2393,6 +2393,7 @@ pub mod test {
                 &config.stacker_dbs,
                 &config.stacker_db_configs,
             );
+            let stackerdb_contracts: Vec<_> = stacker_dbs.keys().map(|cid| cid.clone()).collect();
 
             let mut peer_network = PeerNetwork::new(
                 peerdb,
@@ -2418,8 +2419,25 @@ pub mod test {
             let p2p_port = peer_network.bound_neighbor_key().port;
             let http_port = peer_network.http.as_ref().unwrap().http_server_addr.port();
 
-            config.server_port = p2p_port;
-            config.http_port = http_port;
+            config.data_url =
+                UrlString::try_from(format!("http://127.0.0.1:{}", http_port).as_str()).unwrap();
+
+            peer_network
+                .peerdb
+                .update_local_peer(
+                    config.network_id,
+                    config.burnchain.network_id,
+                    config.data_url.clone(),
+                    p2p_port,
+                    &stackerdb_contracts,
+                )
+                .unwrap();
+
+            let local_peer = PeerDB::get_local_peer(peer_network.peerdb.conn()).unwrap();
+            debug!(
+                "{:?}: initial neighbors: {:?}",
+                &local_peer, &config.initial_neighbors
+            );
 
             TestPeer {
                 config: config,
diff --git a/stackslib/src/net/neighbors/db.rs b/stackslib/src/net/neighbors/db.rs
index fd85f0ce1f..4e62000a78 100644
--- a/stackslib/src/net/neighbors/db.rs
+++ b/stackslib/src/net/neighbors/db.rs
@@ -176,6 +176,34 @@ pub trait NeighborWalkDB {
     /// Get the number of peers in a given AS
     fn get_asn_count(&self, network: &PeerNetwork, asn: u32) -> u64;
 
+    /// Pick neighbors with a minimum age for a walk
+    fn pick_walk_neighbors(
+        network: &PeerNetwork,
+        num_neighbors: u64,
+        min_age: u64,
+    ) -> Result<Vec<Neighbor>, net_error> {
+        let block_height = network.get_chain_view().burn_block_height;
+        let cur_epoch = network.get_current_epoch();
+        let neighbors = PeerDB::get_random_walk_neighbors(
+            &network.peerdb_conn(),
+            network.get_local_peer().network_id,
+            cur_epoch.network_epoch,
+            min_age,
+            num_neighbors as u32,
+            block_height,
+        )
+        .map_err(net_error::DBError)?;
+
+        if neighbors.len() == 0 {
+            debug!(
+                "{:?}: No neighbors available in the peer DB!",
+                network.get_local_peer()
+            );
+            return Err(net_error::NoSuchNeighbor);
+        }
+        Ok(neighbors)
+    }
+
     /// Get a random starting neighbor for an ongoing walk.
     /// Older but still fresh neighbors will be preferred -- a neighbor from the first 50th
     /// percentile of neighbors (by last contact time) will be selected at random.
@@ -184,17 +212,32 @@ pub trait NeighborWalkDB {
     fn get_next_walk_neighbor(&self, network: &PeerNetwork) -> Result<Neighbor, net_error> {
         // pick a random neighbor as a walking point.
         // favor neighbors with older last-contact times
-        let mut next_neighbors = self
+        let next_neighbors_res = self
             .get_fresh_random_neighbors(network, (NUM_NEIGHBORS as u64) * 2)
             .map_err(|e| {
                 debug!(
-                    "{:?}: Failed to load initial walk neighbors: {:?}",
+                    "{:?}: Failed to load fresh initial walk neighbors: {:?}",
+                    network.get_local_peer(),
+                    &e
+                );
+                e
+            });
+
+        let mut next_neighbors = if let Ok(neighbors) = next_neighbors_res {
+            neighbors
+        } else {
+            let any_neighbors = Self::pick_walk_neighbors(network, (NUM_NEIGHBORS as u64) * 2, 0)
+                .map_err(|e| {
+                info!(
+                    "{:?}: Failed to load any initial walk neighbors: {:?}",
                     network.get_local_peer(),
                     &e
                 );
                 e
             })?;
 
+            any_neighbors
+        };
         if next_neighbors.len() == 0 {
             return Err(net_error::NoSuchNeighbor);
         }
@@ -246,28 +289,9 @@ impl NeighborWalkDB for PeerDBNeighborWalk {
         network: &PeerNetwork,
         num_neighbors: u64,
     ) -> Result<Vec<Neighbor>, net_error> {
-        let block_height = network.get_chain_view().burn_block_height;
         let min_age =
             get_epoch_time_secs().saturating_sub(network.connection_opts.max_neighbor_age);
-        let cur_epoch = network.get_current_epoch();
-        let neighbors = PeerDB::get_random_walk_neighbors(
-            &network.peerdb_conn(),
-            network.get_local_peer().network_id,
-            cur_epoch.network_epoch,
-            min_age,
-            num_neighbors as u32,
-            block_height,
-        )
-        .map_err(net_error::DBError)?;
-
-        if neighbors.len() == 0 {
-            debug!(
-                "{:?}: No neighbors available in the peer DB!",
-                network.get_local_peer()
-            );
-            return Err(net_error::NoSuchNeighbor);
-        }
-        Ok(neighbors)
+        Self::pick_walk_neighbors(network, num_neighbors, min_age)
     }
 
     fn lookup_stale_neighbors(
diff --git a/stackslib/src/net/tests/neighbors.rs b/stackslib/src/net/tests/neighbors.rs
index 333543e7ca..f1937cb89b 100644
--- a/stackslib/src/net/tests/neighbors.rs
+++ b/stackslib/src/net/tests/neighbors.rs
@@ -2687,7 +2687,7 @@ where
 
         debug!("Random order = {:?}", &random_order);
         for i in random_order.into_iter() {
-            let _ = peers[i].step();
+            let _ = peers[i].step_with_ibd(false);
             let nk = peers[i].config.to_neighbor().addr;
             debug!("Step peer {:?}", &nk);
 

From b745833ef5dad4fcb5e011298b705ed267ea5b3a Mon Sep 17 00:00:00 2001
From: Joey Yandle <xoloki@gmail.com>
Date: Tue, 9 Jan 2024 10:10:54 -0500
Subject: [PATCH 0399/1166] change comment to get CI to run

---
 stacks-signer/src/config.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/stacks-signer/src/config.rs b/stacks-signer/src/config.rs
index aa031e7eb1..9261cc5a63 100644
--- a/stacks-signer/src/config.rs
+++ b/stacks-signer/src/config.rs
@@ -144,7 +144,8 @@ struct RawConfigFile {
     // FIXME: this should go away once .signers contract exists at pox-4 instantiation
     /// Signers' Stacker db contract identifier
     pub stackerdb_contract_id: String,
-    /// the 32 byte ECDSA private key used to sign blocks, chunks, and transactions
+
+    /// the 32 byte ECDSA private key used to sign blocks, chunks, transactions, and WSTS messages
     pub message_private_key: String,
     /// The hex representation of the signer's Stacks private key used for communicating
     /// with the Stacks Node, including writing to the Stacker DB instance.

From 3907d7ed3b7f234f0422603a3a4cc3e29e3945e3 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Thu, 18 Jan 2024 22:04:45 -0500
Subject: [PATCH 0400/1166] chore: move repetative info! to debug!

---
 testnet/stacks-node/src/config.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index 66056e5d7c..33bf70ac6e 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -1941,7 +1941,7 @@ impl NodeConfig {
         let (pubkey_str, hostport) = (parts[0], parts[1]);
         let pubkey = Secp256k1PublicKey::from_hex(pubkey_str)
             .expect(&format!("Invalid public key '{}'", pubkey_str));
-        info!("Resolve '{}'", &hostport);
+        debug!("Resolve '{}'", &hostport);
         let sockaddr = hostport.to_socket_addrs().unwrap().next().unwrap();
         let neighbor = NodeConfig::default_neighbor(sockaddr, pubkey, chain_id, peer_version);
         self.bootstrap_node.push(neighbor);

From 2d11073c32f0ebe8a21d168721224f7d626d9b96 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Fri, 19 Jan 2024 14:43:35 -0600
Subject: [PATCH 0401/1166] From expecting `(buff 33)` to `principal`

---
 clarity/src/vm/types/mod.rs                   |   9 --
 stacks-common/src/address/mod.rs              |   2 +-
 stacks-common/src/types/mod.rs                |  17 +-
 stackslib/src/chainstate/coordinator/tests.rs |   8 +
 .../chainstate/nakamoto/coordinator/mod.rs    |  11 +-
 stackslib/src/chainstate/stacks/boot/mod.rs   |  45 +++---
 stackslib/src/net/mod.rs                      |   9 ++
 testnet/stacks-node/src/config.rs             |   5 +
 testnet/stacks-node/src/event_dispatcher.rs   | 146 ++++++++----------
 9 files changed, 132 insertions(+), 120 deletions(-)

diff --git a/clarity/src/vm/types/mod.rs b/clarity/src/vm/types/mod.rs
index 8300f6582e..5aa298a139 100644
--- a/clarity/src/vm/types/mod.rs
+++ b/clarity/src/vm/types/mod.rs
@@ -1411,15 +1411,6 @@ impl From<StandardPrincipalData> for StacksAddress {
     }
 }
 
-impl From<PrincipalData> for StacksAddress {
-    fn from(principal: PrincipalData) -> Self {
-        match principal {
-            PrincipalData::Standard(standard_principal) => standard_principal.into(),
-            PrincipalData::Contract(contract_principal) => contract_principal.issuer.into(),
-        }
-    }
-}
-
 impl From<StandardPrincipalData> for Value {
     fn from(principal: StandardPrincipalData) -> Self {
         Value::Principal(PrincipalData::from(principal))
diff --git a/stacks-common/src/address/mod.rs b/stacks-common/src/address/mod.rs
index ad8545dca7..b4bcb936c9 100644
--- a/stacks-common/src/address/mod.rs
+++ b/stacks-common/src/address/mod.rs
@@ -150,7 +150,7 @@ impl TryFrom<u8> for AddressHashMode {
 /// Internally, the Stacks blockchain encodes address the same as Bitcoin
 /// single-sig address (p2pkh)
 /// Get back the hash of the address
-fn to_bits_p2pkh<K: PublicKey>(pubk: &K) -> Hash160 {
+pub fn to_bits_p2pkh<K: PublicKey>(pubk: &K) -> Hash160 {
     Hash160::from_data(&pubk.to_bytes())
 }
 
diff --git a/stacks-common/src/types/mod.rs b/stacks-common/src/types/mod.rs
index 603a5cef21..a4eec7369e 100644
--- a/stacks-common/src/types/mod.rs
+++ b/stacks-common/src/types/mod.rs
@@ -4,9 +4,9 @@ use std::fmt;
 
 use crate::address::c32::{c32_address, c32_address_decode};
 use crate::address::{
-    public_keys_to_address_hash, AddressHashMode, C32_ADDRESS_VERSION_MAINNET_MULTISIG,
-    C32_ADDRESS_VERSION_MAINNET_SINGLESIG, C32_ADDRESS_VERSION_TESTNET_MULTISIG,
-    C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
+    public_keys_to_address_hash, to_bits_p2pkh, AddressHashMode,
+    C32_ADDRESS_VERSION_MAINNET_MULTISIG, C32_ADDRESS_VERSION_MAINNET_SINGLESIG,
+    C32_ADDRESS_VERSION_TESTNET_MULTISIG, C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
 };
 use crate::deps_common::bitcoin::blockdata::transaction::TxOut;
 use crate::types::chainstate::{StacksAddress, StacksPublicKey};
@@ -212,6 +212,17 @@ impl StacksAddress {
         let hash_bits = public_keys_to_address_hash(hash_mode, num_sigs, pubkeys);
         Some(StacksAddress::new(version, hash_bits))
     }
+
+    /// Make a P2PKH StacksAddress
+    pub fn p2pkh(mainnet: bool, pubkey: &StacksPublicKey) -> StacksAddress {
+        let version = if mainnet {
+            C32_ADDRESS_VERSION_MAINNET_SINGLESIG
+        } else {
+            C32_ADDRESS_VERSION_TESTNET_SINGLESIG
+        };
+        let bytes = to_bits_p2pkh(pubkey);
+        Self { version, bytes }
+    }
 }
 
 impl std::fmt::Display for StacksAddress {
diff --git a/stackslib/src/chainstate/coordinator/tests.rs b/stackslib/src/chainstate/coordinator/tests.rs
index 79007d421e..2f40ead90b 100644
--- a/stackslib/src/chainstate/coordinator/tests.rs
+++ b/stackslib/src/chainstate/coordinator/tests.rs
@@ -442,6 +442,14 @@ impl BlockEventDispatcher for NullEventDispatcher {
         _slot_holders: Vec<PoxAddress>,
     ) {
     }
+
+    fn announce_reward_set(
+        &self,
+        _reward_set: &RewardSet,
+        _block_id: &StacksBlockId,
+        _cycle_number: u64,
+    ) {
+    }
 }
 
 pub fn make_coordinator<'a>(
diff --git a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
index 3501ef3c73..2613fc8b8a 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
@@ -18,8 +18,10 @@ use std::collections::VecDeque;
 use std::sync::{Arc, Mutex};
 
 use clarity::vm::database::BurnStateDB;
+use clarity::vm::types::PrincipalData;
 use stacks_common::types::chainstate::{
-    BlockHeaderHash, BurnchainHeaderHash, SortitionId, StacksBlockId,
+    BlockHeaderHash, BurnchainHeaderHash, SortitionId, StacksAddress, StacksBlockId,
+    StacksPrivateKey, StacksPublicKey,
 };
 use stacks_common::types::{StacksEpoch, StacksEpochId};
 
@@ -72,9 +74,10 @@ impl<'a, T: BlockEventDispatcher> OnChainRewardSetProvider<'a, T> {
         //   this method just mocks that data.
         for (index, entry) in registered_addrs.iter_mut().enumerate() {
             let index = u64::try_from(index).expect("FATAL: more than u64 reward set entries");
-            let mut bytes = [0; 33];
-            bytes[0..8].copy_from_slice(&index.to_be_bytes());
-            entry.signing_key = Some(bytes);
+            let sk = StacksPrivateKey::from_seed(&index.to_be_bytes());
+            let addr =
+                StacksAddress::p2pkh(chainstate.mainnet, &StacksPublicKey::from_private(&sk));
+            entry.signing_key = Some(addr.into());
         }
 
         let liquid_ustx = chainstate.get_liquid_ustx(block_id);
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 36883ad4b8..0944ea19f3 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -155,7 +155,7 @@ pub struct RawRewardSetEntry {
     pub reward_address: PoxAddress,
     pub amount_stacked: u128,
     pub stacker: Option<PrincipalData>,
-    pub signing_key: Option<[u8; 33]>,
+    pub signing_key: Option<PrincipalData>,
 }
 
 #[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
@@ -169,29 +169,23 @@ pub struct PoxStartCycleInfo {
     pub missed_reward_slots: Vec<(PrincipalData, u128)>,
 }
 
-fn hex_serialize<S: serde::Serializer>(bytes: &[u8], s: S) -> Result<S::Ok, S::Error> {
-    let inst = to_hex(bytes);
-    s.serialize_str(inst.as_str())
+fn addr_serialize<S: serde::Serializer>(addr: &StacksAddress, s: S) -> Result<S::Ok, S::Error> {
+    s.serialize_str(&addr.to_string())
 }
 
-fn hex_deserialize<'de, D: serde::Deserializer<'de>>(d: D) -> Result<[u8; 33], D::Error> {
-    let inst_str = String::deserialize(d)?;
-    let mut out = [0; 33];
-    let bytes = hex_bytes(&inst_str).map_err(serde::de::Error::custom)?;
-    if bytes.len() != out.len() {
-        return Err(serde::de::Error::invalid_length(
-            bytes.len(),
-            &"Expected hex-encoded buffer of byte-length 33",
-        ));
-    }
-    out.copy_from_slice(bytes.as_slice());
-    Ok(out)
+fn addr_deserialize<'de, D: serde::Deserializer<'de>>(d: D) -> Result<StacksAddress, D::Error> {
+    let addr_str = String::deserialize(d)?;
+    StacksAddress::from_string(&addr_str)
+        .ok_or_else(|| serde::de::Error::custom("Address must be a C32 encoded StacksAddress"))
 }
 
 #[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
 pub struct NakamotoSignerEntry {
-    #[serde(serialize_with = "hex_serialize", deserialize_with = "hex_deserialize")]
-    pub signing_key: [u8; 33],
+    #[serde(
+        serialize_with = "addr_serialize",
+        deserialize_with = "addr_deserialize"
+    )]
+    pub signing_address: StacksAddress,
     pub stacked_amt: u128,
     pub slots: u32,
 }
@@ -630,8 +624,13 @@ impl StacksChainState {
 
         let mut signer_set = BTreeMap::new();
         for entry in entries.iter() {
-            let signing_key = entry.signing_key.as_ref().unwrap();
-            if let Some(existing_entry) = signer_set.get_mut(signing_key) {
+            let signing_key = if let Some(PrincipalData::Standard(s)) = entry.signing_key.clone() {
+                StacksAddress::from(s)
+            } else {
+                // TODO: should figure out if in mainnet?
+                StacksAddress::burn_address(true)
+            };
+            if let Some(existing_entry) = signer_set.get_mut(&signing_key) {
                 *existing_entry += entry.amount_stacked;
             } else {
                 signer_set.insert(signing_key.clone(), entry.amount_stacked);
@@ -640,14 +639,14 @@ impl StacksChainState {
 
         let mut signer_set: Vec<_> = signer_set
             .into_iter()
-            .filter_map(|(signing_key, stacked_amt)| {
+            .filter_map(|(signing_address, stacked_amt)| {
                 let slots = u32::try_from(stacked_amt / threshold)
                     .expect("CORRUPTION: Stacker claimed > u32::max() reward slots");
                 if slots == 0 {
                     return None;
                 }
                 Some(NakamotoSignerEntry {
-                    signing_key,
+                    signing_address,
                     stacked_amt,
                     slots,
                 })
@@ -656,7 +655,7 @@ impl StacksChainState {
 
         // finally, we must sort the signer set: the signer participation bit vector depends
         //  on a consensus-critical ordering of the signer set.
-        signer_set.sort_by_key(|entry| entry.signing_key);
+        signer_set.sort_by_key(|entry| entry.signing_address);
 
         Some(signer_set)
     }
diff --git a/stackslib/src/net/mod.rs b/stackslib/src/net/mod.rs
index dd92aba99b..6a5406ddf0 100644
--- a/stackslib/src/net/mod.rs
+++ b/stackslib/src/net/mod.rs
@@ -1880,6 +1880,15 @@ pub mod test {
         ) {
             // pass
         }
+
+        fn announce_reward_set(
+            &self,
+            _reward_set: &RewardSet,
+            _block_id: &StacksBlockId,
+            _cycle_number: u64,
+        ) {
+            // pass
+        }
     }
 
     // describes a peer's initial configuration
diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index 0701219e0e..97693f6f78 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -2376,6 +2376,7 @@ pub enum EventKeyType {
     MinedMicroblocks,
     StackerDBChunks,
     BlockProposal,
+    StackerSet,
 }
 
 impl EventKeyType {
@@ -2408,6 +2409,10 @@ impl EventKeyType {
             return Some(EventKeyType::BlockProposal);
         }
 
+        if raw_key == "stacker_set" {
+            return Some(EventKeyType::StackerSet);
+        }
+
         let comps: Vec<_> = raw_key.split("::").collect();
         if comps.len() == 1 {
             let split: Vec<_> = comps[0].split(".").collect();
diff --git a/testnet/stacks-node/src/event_dispatcher.rs b/testnet/stacks-node/src/event_dispatcher.rs
index 6787c11f3d..a27dda6c46 100644
--- a/testnet/stacks-node/src/event_dispatcher.rs
+++ b/testnet/stacks-node/src/event_dispatcher.rs
@@ -72,7 +72,7 @@ pub const PATH_BURN_BLOCK_SUBMIT: &str = "new_burn_block";
 pub const PATH_BLOCK_PROCESSED: &str = "new_block";
 pub const PATH_ATTACHMENT_PROCESSED: &str = "attachments/new";
 pub const PATH_PROPOSAL_RESPONSE: &str = "proposal_response";
-pub const PATH_POX_ANCHOR: &str = "new_pox_anchor";
+pub const PATH_POX_ANCHOR: &str = "new_pox_set";
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct MinedBlockEvent {
@@ -452,6 +452,7 @@ pub struct EventDispatcher {
     mined_microblocks_observers_lookup: HashSet<u16>,
     stackerdb_observers_lookup: HashSet<u16>,
     block_proposal_observers_lookup: HashSet<u16>,
+    pox_stacker_set_observers_lookup: HashSet<u16>,
 }
 
 /// This struct is used specifically for receiving proposal responses.
@@ -632,7 +633,7 @@ impl BlockEventDispatcher for EventDispatcher {
         block_id: &StacksBlockId,
         cycle_number: u64,
     ) {
-        todo!("Announce PoX block `{block_id}` for cycle `{cycle_number}`: {reward_set:?}");
+        self.process_stacker_set(reward_set, block_id, cycle_number)
     }
 }
 
@@ -651,6 +652,7 @@ impl EventDispatcher {
             mined_microblocks_observers_lookup: HashSet::new(),
             stackerdb_observers_lookup: HashSet::new(),
             block_proposal_observers_lookup: HashSet::new(),
+            pox_stacker_set_observers_lookup: HashSet::new(),
         }
     }
 
@@ -663,18 +665,7 @@ impl EventDispatcher {
         recipient_info: Vec<PoxAddress>,
     ) {
         // lazily assemble payload only if we have observers
-        let interested_observers: Vec<_> = self
-            .registered_observers
-            .iter()
-            .enumerate()
-            .filter(|(obs_id, _observer)| {
-                self.burn_block_observers_lookup
-                    .contains(&(u16::try_from(*obs_id).expect("FATAL: more than 2^16 observers")))
-                    || self.any_event_observers_lookup.contains(
-                        &(u16::try_from(*obs_id).expect("FATAL: more than 2^16 observers")),
-                    )
-            })
-            .collect();
+        let interested_observers = self.filter_observers(&self.burn_block_observers_lookup, true);
         if interested_observers.len() < 1 {
             return;
         }
@@ -687,7 +678,7 @@ impl EventDispatcher {
             recipient_info,
         );
 
-        for (_, observer) in interested_observers.iter() {
+        for observer in interested_observers.iter() {
             observer.send_new_burn_block(&payload);
         }
     }
@@ -926,27 +917,58 @@ impl EventDispatcher {
         }
     }
 
-    pub fn process_new_mempool_txs(&self, txs: Vec<StacksTransaction>) {
-        // lazily assemble payload only if we have observers
-        let interested_observers: Vec<_> = self
-            .registered_observers
+    fn filter_observers(&self, lookup: &HashSet<u16>, include_any: bool) -> Vec<&EventObserver> {
+        self.registered_observers
             .iter()
             .enumerate()
-            .filter(|(obs_id, _observer)| {
-                self.mempool_observers_lookup
-                    .contains(&(u16::try_from(*obs_id).expect("FATAL: more than 2^16 observers")))
-                    || self.any_event_observers_lookup.contains(
-                        &(u16::try_from(*obs_id).expect("FATAL: more than 2^16 observers")),
-                    )
+            .filter_map(|(obs_id, observer)| {
+                let lookup_ix = u16::try_from(obs_id).expect("FATAL: more than 2^16 observers");
+                if lookup.contains(&lookup_ix) {
+                    return Some(observer);
+                } else if include_any && self.any_event_observers_lookup.contains(&lookup_ix) {
+                    return Some(observer);
+                } else {
+                    return None;
+                }
             })
-            .collect();
+            .collect()
+    }
+
+    fn process_stacker_set(
+        &self,
+        reward_set: &RewardSet,
+        block_id: &StacksBlockId,
+        cycle_number: u64,
+    ) {
+        let interested_observers =
+            self.filter_observers(&self.pox_stacker_set_observers_lookup, false);
+
+        if interested_observers.is_empty() {
+            return;
+        }
+
+        let payload = json!({
+            "stacker_set": reward_set,
+            "block_id": block_id,
+            "cycle_number": cycle_number
+        });
+
+        for observer in interested_observers.iter() {
+            observer.send_payload(&payload, PATH_POX_ANCHOR);
+        }
+    }
+
+    pub fn process_new_mempool_txs(&self, txs: Vec<StacksTransaction>) {
+        // lazily assemble payload only if we have observers
+        let interested_observers = self.filter_observers(&self.mempool_observers_lookup, true);
+
         if interested_observers.len() < 1 {
             return;
         }
 
         let payload = EventObserver::make_new_mempool_txs_payload(txs);
 
-        for (_, observer) in interested_observers.iter() {
+        for observer in interested_observers.iter() {
             observer.send_new_mempool_txs(&payload);
         }
     }
@@ -960,15 +982,8 @@ impl EventDispatcher {
         confirmed_microblock_cost: &ExecutionCost,
         tx_events: Vec<TransactionEvent>,
     ) {
-        let interested_observers: Vec<_> = self
-            .registered_observers
-            .iter()
-            .enumerate()
-            .filter(|(obs_id, _observer)| {
-                self.miner_observers_lookup
-                    .contains(&(u16::try_from(*obs_id).expect("FATAL: more than 2^16 observers")))
-            })
-            .collect();
+        let interested_observers = self.filter_observers(&self.miner_observers_lookup, false);
+
         if interested_observers.len() < 1 {
             return;
         }
@@ -984,7 +999,7 @@ impl EventDispatcher {
         })
         .unwrap();
 
-        for (_, observer) in interested_observers.iter() {
+        for observer in interested_observers.iter() {
             observer.send_mined_block(&payload);
         }
     }
@@ -996,15 +1011,8 @@ impl EventDispatcher {
         anchor_block_consensus_hash: ConsensusHash,
         anchor_block: BlockHeaderHash,
     ) {
-        let interested_observers: Vec<_> = self
-            .registered_observers
-            .iter()
-            .enumerate()
-            .filter(|(obs_id, _observer)| {
-                self.mined_microblocks_observers_lookup
-                    .contains(&(u16::try_from(*obs_id).expect("FATAL: more than 2^16 observers")))
-            })
-            .collect();
+        let interested_observers =
+            self.filter_observers(&self.mined_microblocks_observers_lookup, false);
         if interested_observers.len() < 1 {
             return;
         }
@@ -1018,7 +1026,7 @@ impl EventDispatcher {
         })
         .unwrap();
 
-        for (_, observer) in interested_observers.iter() {
+        for observer in interested_observers.iter() {
             observer.send_mined_microblock(&payload);
         }
     }
@@ -1031,15 +1039,7 @@ impl EventDispatcher {
         consumed: &ExecutionCost,
         tx_events: Vec<TransactionEvent>,
     ) {
-        let interested_observers: Vec<_> = self
-            .registered_observers
-            .iter()
-            .enumerate()
-            .filter(|(obs_id, _observer)| {
-                self.miner_observers_lookup
-                    .contains(&(u16::try_from(*obs_id).expect("FATAL: more than 2^16 observers")))
-            })
-            .collect();
+        let interested_observers = self.filter_observers(&self.miner_observers_lookup, false);
         if interested_observers.len() < 1 {
             return;
         }
@@ -1055,7 +1055,7 @@ impl EventDispatcher {
         })
         .unwrap();
 
-        for (_, observer) in interested_observers.iter() {
+        for observer in interested_observers.iter() {
             observer.send_mined_nakamoto_block(&payload);
         }
     }
@@ -1067,15 +1067,8 @@ impl EventDispatcher {
         contract_id: QualifiedContractIdentifier,
         new_chunks: Vec<StackerDBChunkData>,
     ) {
-        let interested_observers: Vec<_> = self
-            .registered_observers
-            .iter()
-            .enumerate()
-            .filter(|(obs_id, _observer)| {
-                self.stackerdb_observers_lookup
-                    .contains(&(u16::try_from(*obs_id).expect("FATAL: more than 2^16 observers")))
-            })
-            .collect();
+        let interested_observers = self.filter_observers(&self.stackerdb_observers_lookup, false);
+
         if interested_observers.len() < 1 {
             return;
         }
@@ -1086,25 +1079,15 @@ impl EventDispatcher {
         })
         .expect("FATAL: failed to serialize StackerDBChunksEvent to JSON");
 
-        for (_, observer) in interested_observers.iter() {
+        for observer in interested_observers.iter() {
             observer.send_stackerdb_chunks(&payload);
         }
     }
 
     pub fn process_dropped_mempool_txs(&self, txs: Vec<Txid>, reason: MemPoolDropReason) {
         // lazily assemble payload only if we have observers
-        let interested_observers: Vec<_> = self
-            .registered_observers
-            .iter()
-            .enumerate()
-            .filter(|(obs_id, _observer)| {
-                self.mempool_observers_lookup
-                    .contains(&(u16::try_from(*obs_id).expect("FATAL: more than 2^16 observers")))
-                    || self.any_event_observers_lookup.contains(
-                        &(u16::try_from(*obs_id).expect("FATAL: more than 2^16 observers")),
-                    )
-            })
-            .collect();
+        let interested_observers = self.filter_observers(&self.mempool_observers_lookup, true);
+
         if interested_observers.len() < 1 {
             return;
         }
@@ -1119,7 +1102,7 @@ impl EventDispatcher {
             "reason": reason.to_string(),
         });
 
-        for (_, observer) in interested_observers.iter() {
+        for observer in interested_observers.iter() {
             observer.send_dropped_mempool_txs(&payload);
         }
     }
@@ -1219,6 +1202,9 @@ impl EventDispatcher {
                 EventKeyType::BlockProposal => {
                     self.block_proposal_observers_lookup.insert(observer_index);
                 }
+                EventKeyType::StackerSet => {
+                    self.pox_stacker_set_observers_lookup.insert(observer_index);
+                }
             }
         }
 

From 3094df2b89a282582b95a1efb6d87bf5ddf55a78 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 19 Jan 2024 14:04:52 -0800
Subject: [PATCH 0402/1166] Update wsts version to 7.0

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 Cargo.lock                                    |  6 ++--
 Cargo.toml                                    |  2 +-
 stacks-signer/src/client/stackerdb.rs         | 20 ++++++------
 stacks-signer/src/config.rs                   | 32 +++++++++++++++----
 stacks-signer/src/runloop.rs                  |  7 ++--
 stackslib/Cargo.toml                          |  1 +
 .../src/chainstate/nakamoto/tests/node.rs     | 18 ++++++-----
 testnet/stacks-node/Cargo.toml                |  1 +
 testnet/stacks-node/src/mockamoto/signer.rs   | 16 ++++++----
 9 files changed, 65 insertions(+), 38 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 1eaf731f65..205c428b80 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3548,6 +3548,7 @@ dependencies = [
  "base64 0.12.3",
  "chrono",
  "clarity",
+ "hashbrown 0.14.0",
  "http-types",
  "lazy_static",
  "libc",
@@ -3615,6 +3616,7 @@ dependencies = [
  "criterion",
  "curve25519-dalek",
  "ed25519-dalek",
+ "hashbrown 0.14.0",
  "integer-sqrt",
  "lazy_static",
  "libc",
@@ -4714,9 +4716,9 @@ dependencies = [
 
 [[package]]
 name = "wsts"
-version = "6.1.0"
+version = "7.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c7db3d3fe28c359e0cdb7f7ad83e3316bda0ba982b8cd1bf0fbe73ae4127e4b"
+checksum = "c398736468f3322a43b6419be5315e68ae035e6565628603503c2a62ad726f36"
 dependencies = [
  "aes-gcm 0.10.2",
  "bs58 0.5.0",
diff --git a/Cargo.toml b/Cargo.toml
index 33f1720b77..4564ee800c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -14,7 +14,7 @@ members = [
 
 # Dependencies we want to keep the same between workspace members
 [workspace.dependencies]  
-wsts = "6.1"
+wsts = "7.0"
 rand_core = "0.6"
 rand = "0.8"
 
diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index 4631ecbd4d..c6c1a6e366 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -33,19 +33,20 @@ use crate::config::Config;
 /// Temporary placeholder for the number of slots allocated to a stacker-db writer. This will be retrieved from the stacker-db instance in the future
 /// See: https://github.com/stacks-network/stacks-blockchain/issues/3921
 /// Is equal to the number of message types
-pub const SIGNER_SLOTS_PER_USER: u32 = 10;
+pub const SIGNER_SLOTS_PER_USER: u32 = 11;
 
 // The slot IDS for each message type
 const DKG_BEGIN_SLOT_ID: u32 = 0;
 const DKG_PRIVATE_BEGIN_SLOT_ID: u32 = 1;
-const DKG_END_SLOT_ID: u32 = 2;
-const DKG_PUBLIC_SHARES_SLOT_ID: u32 = 3;
-const DKG_PRIVATE_SHARES_SLOT_ID: u32 = 4;
-const NONCE_REQUEST_SLOT_ID: u32 = 5;
-const NONCE_RESPONSE_SLOT_ID: u32 = 6;
-const SIGNATURE_SHARE_REQUEST_SLOT_ID: u32 = 7;
-const SIGNATURE_SHARE_RESPONSE_SLOT_ID: u32 = 8;
-const BLOCK_SLOT_ID: u32 = 9;
+const DKG_END_BEGIN_SLOT_ID: u32 = 2;
+const DKG_END_SLOT_ID: u32 = 3;
+const DKG_PUBLIC_SHARES_SLOT_ID: u32 = 4;
+const DKG_PRIVATE_SHARES_SLOT_ID: u32 = 5;
+const NONCE_REQUEST_SLOT_ID: u32 = 6;
+const NONCE_RESPONSE_SLOT_ID: u32 = 7;
+const SIGNATURE_SHARE_REQUEST_SLOT_ID: u32 = 8;
+const SIGNATURE_SHARE_RESPONSE_SLOT_ID: u32 = 9;
+const BLOCK_SLOT_ID: u32 = 10;
 
 /// The messages being sent through the stacker db contracts
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
@@ -122,6 +123,7 @@ impl SignerMessage {
             Self::Packet(packet) => match packet.msg {
                 Message::DkgBegin(_) => DKG_BEGIN_SLOT_ID,
                 Message::DkgPrivateBegin(_) => DKG_PRIVATE_BEGIN_SLOT_ID,
+                Message::DkgEndBegin(_) => DKG_END_BEGIN_SLOT_ID,
                 Message::DkgEnd(_) => DKG_END_SLOT_ID,
                 Message::DkgPublicShares(_) => DKG_PUBLIC_SHARES_SLOT_ID,
                 Message::DkgPrivateShares(_) => DKG_PRIVATE_SHARES_SLOT_ID,
diff --git a/stacks-signer/src/config.rs b/stacks-signer/src/config.rs
index 9261cc5a63..f83673e26c 100644
--- a/stacks-signer/src/config.rs
+++ b/stacks-signer/src/config.rs
@@ -36,7 +36,7 @@ use wsts::state_machine::PublicKeys;
 /// List of key_ids for each signer_id
 pub type SignerKeyIds = HashMap<u32, Vec<u32>>;
 
-const EVENT_TIMEOUT_MS: u64 = 5000;
+const EVENT_TIMEOUT_MS: u64 = 50;
 
 #[derive(thiserror::Error, Debug)]
 /// An error occurred parsing the provided configuration
@@ -119,6 +119,8 @@ pub struct Config {
     pub event_timeout: Duration,
     /// timeout to gather DkgPublicShares messages
     pub dkg_public_timeout: Option<Duration>,
+    /// timeout to gather DkgPrivateShares messages
+    pub dkg_private_timeout: Option<Duration>,
     /// timeout to gather DkgEnd messages
     pub dkg_end_timeout: Option<Duration>,
     /// timeout to gather nonces
@@ -159,7 +161,17 @@ struct RawConfigFile {
     /// The signer ID
     pub signer_id: u32,
     /// The time to wait (in millisecs) for a response from the stacker-db instance
-    pub event_timeout: Option<u64>,
+    pub event_timeout_ms: Option<u64>,
+    /// timeout in (millisecs) to gather DkgPublicShares messages
+    pub dkg_public_timeout_ms: Option<u64>,
+    /// timeout in (millisecs) to gather DkgPrivateShares messages
+    pub dkg_private_timeout_ms: Option<u64>,
+    /// timeout in (millisecs) to gather DkgEnd messages
+    pub dkg_end_timeout_ms: Option<u64>,
+    /// timeout in (millisecs) to gather nonces
+    pub nonce_timeout_ms: Option<u64>,
+    /// timeout in (millisecs) to gather signature shares
+    pub sign_timeout_ms: Option<u64>,
 }
 
 impl RawConfigFile {
@@ -270,7 +282,12 @@ impl TryFrom<RawConfigFile> for Config {
             signer_key_ids.insert(signer_key, s.key_ids.clone());
         }
         let event_timeout =
-            Duration::from_millis(raw_data.event_timeout.unwrap_or(EVENT_TIMEOUT_MS));
+            Duration::from_millis(raw_data.event_timeout_ms.unwrap_or(EVENT_TIMEOUT_MS));
+        let dkg_end_timeout = raw_data.dkg_end_timeout_ms.map(Duration::from_millis);
+        let dkg_public_timeout = raw_data.dkg_public_timeout_ms.map(Duration::from_millis);
+        let dkg_private_timeout = raw_data.dkg_private_timeout_ms.map(Duration::from_millis);
+        let nonce_timeout = raw_data.nonce_timeout_ms.map(Duration::from_millis);
+        let sign_timeout = raw_data.sign_timeout_ms.map(Duration::from_millis);
         Ok(Self {
             node_host,
             endpoint,
@@ -283,10 +300,11 @@ impl TryFrom<RawConfigFile> for Config {
             signer_id: raw_data.signer_id,
             signer_key_ids,
             event_timeout,
-            dkg_end_timeout: None,
-            dkg_public_timeout: None,
-            nonce_timeout: None,
-            sign_timeout: None,
+            dkg_end_timeout,
+            dkg_public_timeout,
+            dkg_private_timeout,
+            nonce_timeout,
+            sign_timeout,
         })
     }
 }
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 5f68359a1c..f165546130 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -373,14 +373,12 @@ impl From<&Config> for RunLoop<FireCoordinator<v2::Aggregator>> {
             .signer_key_ids
             .get(&config.signer_id)
             .unwrap()
-            .iter()
-            .map(|i| i - 1) // Signer::new (unlike Signer::from) doesn't do this
-            .collect::<Vec<u32>>();
+            .clone();
         // signer uses a Vec<u32> for its key_ids, but coordinator uses a HashSet for each signer since it needs to do lots of lookups
         let signer_key_ids = config
             .signer_key_ids
             .iter()
-            .map(|(i, ids)| (*i, ids.iter().map(|id| id - 1).collect::<HashSet<u32>>()))
+            .map(|(i, ids)| (*i, ids.iter().copied().collect::<HashSet<u32>>()))
             .collect::<HashMap<u32, HashSet<u32>>>();
 
         let coordinator_config = CoordinatorConfig {
@@ -390,6 +388,7 @@ impl From<&Config> for RunLoop<FireCoordinator<v2::Aggregator>> {
             num_keys: total_keys,
             message_private_key: config.message_private_key,
             dkg_public_timeout: config.dkg_public_timeout,
+            dkg_private_timeout: config.dkg_private_timeout,
             dkg_end_timeout: config.dkg_end_timeout,
             nonce_timeout: config.nonce_timeout,
             sign_timeout: config.sign_timeout,
diff --git a/stackslib/Cargo.toml b/stackslib/Cargo.toml
index c505d8429b..c5411353e2 100644
--- a/stackslib/Cargo.toml
+++ b/stackslib/Cargo.toml
@@ -57,6 +57,7 @@ libstackerdb = { path = "../libstackerdb" }
 siphasher = "0.3.7"
 wsts = {workspace = true}
 rand_core = {workspace = true}
+hashbrown = "0.14"
 
 [target.'cfg(unix)'.dependencies]
 nix = "0.23"
diff --git a/stackslib/src/chainstate/nakamoto/tests/node.rs b/stackslib/src/chainstate/nakamoto/tests/node.rs
index 9c96ca1e6c..4f59a3851e 100644
--- a/stackslib/src/chainstate/nakamoto/tests/node.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/node.rs
@@ -15,13 +15,14 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::cell::RefCell;
-use std::collections::{HashMap, HashSet, VecDeque};
+use std::collections::{HashSet, VecDeque};
 use std::path::{Path, PathBuf};
 use std::{fs, io};
 
 use clarity::vm::clarity::ClarityConnection;
 use clarity::vm::costs::{ExecutionCost, LimitedCostTracker};
 use clarity::vm::types::*;
+use hashbrown::HashMap;
 use rand::seq::SliceRandom;
 use rand::{thread_rng, Rng};
 use stacks_common::address::*;
@@ -70,7 +71,7 @@ pub struct TestSigners {
     /// The parties that will sign the blocks
     pub signer_parties: Vec<wsts::v2::Party>,
     /// The commitments to the polynomials for the aggregate public key
-    pub poly_commitments: Vec<wsts::common::PolyCommitment>,
+    pub poly_commitments: HashMap<u32, wsts::common::PolyCommitment>,
     /// The aggregate public key
     pub aggregate_public_key: Point,
     /// The total number of key ids distributed among signer_parties
@@ -85,7 +86,7 @@ impl Default for TestSigners {
         let num_keys = 10;
         let threshold = 7;
         let party_key_ids: Vec<Vec<u32>> =
-            vec![vec![0, 1, 2], vec![3, 4], vec![5, 6, 7], vec![8, 9]];
+            vec![vec![1, 2, 3], vec![4, 5], vec![6, 7, 8], vec![9, 10]];
         let num_parties = party_key_ids.len().try_into().unwrap();
 
         // Create the parties
@@ -111,10 +112,11 @@ impl Default for TestSigners {
                 panic!("Got secret errors from DKG: {:?}", secret_errors);
             }
         };
-        let aggregate_public_key = poly_commitments.iter().fold(
-            Point::default(),
-            |s, poly_commitment: &wsts::common::PolyCommitment| s + poly_commitment.poly[0],
-        );
+        let mut sig_aggregator = wsts::v2::Aggregator::new(num_keys, threshold);
+        sig_aggregator
+            .init(&poly_commitments)
+            .expect("aggregator init failed");
+        let aggregate_public_key = sig_aggregator.poly[0];
         Self {
             signer_parties,
             aggregate_public_key,
@@ -138,7 +140,7 @@ impl TestSigners {
 
         let mut sig_aggregator = wsts::v2::Aggregator::new(self.num_keys, self.threshold);
         sig_aggregator
-            .init(self.poly_commitments.clone())
+            .init(&self.poly_commitments)
             .expect("aggregator init failed");
         let signature = sig_aggregator
             .sign(msg.as_slice(), &nonces, &sig_shares, &key_ids)
diff --git a/testnet/stacks-node/Cargo.toml b/testnet/stacks-node/Cargo.toml
index 45e0ce231b..1647766d29 100644
--- a/testnet/stacks-node/Cargo.toml
+++ b/testnet/stacks-node/Cargo.toml
@@ -30,6 +30,7 @@ libsigner = { path = "../../libsigner" }
 wsts = { workspace = true }
 rand = { workspace = true }
 rand_core = { workspace = true }
+hashbrown = "0.14"
 
 [dev-dependencies]
 ring = "0.16.19"
diff --git a/testnet/stacks-node/src/mockamoto/signer.rs b/testnet/stacks-node/src/mockamoto/signer.rs
index 7e577b24f2..fadc98f570 100644
--- a/testnet/stacks-node/src/mockamoto/signer.rs
+++ b/testnet/stacks-node/src/mockamoto/signer.rs
@@ -1,3 +1,4 @@
+use hashbrown::HashMap;
 use rand::{CryptoRng, RngCore, SeedableRng};
 use stacks::chainstate::nakamoto::NakamotoBlock;
 use stacks::chainstate::stacks::ThresholdSignature;
@@ -13,7 +14,7 @@ pub struct SelfSigner {
     /// The parties that will sign the blocks
     pub signer_parties: Vec<wsts::v2::Party>,
     /// The commitments to the polynomials for the aggregate public key
-    pub poly_commitments: Vec<wsts::common::PolyCommitment>,
+    pub poly_commitments: HashMap<u32, wsts::common::PolyCommitment>,
     /// The aggregate public key
     pub aggregate_public_key: Point,
     /// The total number of key ids distributed among signer_parties
@@ -35,7 +36,7 @@ impl SelfSigner {
 
     fn from_rng<RNG: RngCore + CryptoRng>(mut rng: RNG) -> Self {
         // Create the parties
-        let mut signer_parties = [wsts::v2::Party::new(0, &[0], 1, 1, 1, &mut rng)];
+        let mut signer_parties = [wsts::v2::Party::new(0, &[1], 1, 1, 1, &mut rng)];
 
         // Generate an aggregate public key
         let poly_commitments = match wsts::v2::test_helpers::dkg(&mut signer_parties, &mut rng) {
@@ -48,11 +49,12 @@ impl SelfSigner {
         assert_eq!(poly_commitments.len(), 1);
         assert_eq!(signer_parties.len(), 1);
 
-        let aggregate_public_key = poly_commitments.iter().fold(
-            Point::default(),
-            |s, poly_commitment: &wsts::common::PolyCommitment| s + poly_commitment.poly[0],
-        );
+        let mut sig_aggregator = wsts::v2::Aggregator::new(1, 1);
+        sig_aggregator
+            .init(&poly_commitments)
+            .expect("aggregator init failed");
 
+        let aggregate_public_key = sig_aggregator.poly[0];
         Self {
             signer_parties: signer_parties.to_vec(),
             aggregate_public_key,
@@ -74,7 +76,7 @@ impl SelfSigner {
 
         let mut sig_aggregator = wsts::v2::Aggregator::new(self.num_keys, self.threshold);
         sig_aggregator
-            .init(self.poly_commitments.clone())
+            .init(&self.poly_commitments)
             .expect("aggregator init failed");
         let signature = sig_aggregator
             .sign(msg.as_slice(), &nonces, &sig_shares, &key_ids)

From 43c91b28477fc079c0694a5a9b4f1325f3dd6d45 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Fri, 19 Jan 2024 17:50:38 -0500
Subject: [PATCH 0403/1166] feat: optionally ignore neighbors on private
 networks

---
 stackslib/src/net/connection.rs     |  3 +++
 stackslib/src/net/neighbors/walk.rs | 20 +++++++++++++++-----
 2 files changed, 18 insertions(+), 5 deletions(-)

diff --git a/stackslib/src/net/connection.rs b/stackslib/src/net/connection.rs
index 195303b1a4..973c5f9e57 100644
--- a/stackslib/src/net/connection.rs
+++ b/stackslib/src/net/connection.rs
@@ -387,6 +387,8 @@ pub struct ConnectionOptions {
     pub socket_recv_buffer_size: u32,
     /// socket write buffer size
     pub socket_send_buffer_size: u32,
+    /// whether or not to announce or accept neighbors that are behind private networks
+    pub private_neighbors: bool,
 
     // fault injection
     pub disable_neighbor_walk: bool,
@@ -478,6 +480,7 @@ impl std::default::Default for ConnectionOptions {
             mempool_sync_timeout: 180, // how long a mempool sync can go for (3 minutes)
             socket_recv_buffer_size: 131072, // Linux default
             socket_send_buffer_size: 16384, // Linux default
+            private_neighbors: true,
 
             // no faults on by default
             disable_neighbor_walk: false,
diff --git a/stackslib/src/net/neighbors/walk.rs b/stackslib/src/net/neighbors/walk.rs
index 5cbda3c774..bd354eebe4 100644
--- a/stackslib/src/net/neighbors/walk.rs
+++ b/stackslib/src/net/neighbors/walk.rs
@@ -566,8 +566,14 @@ impl<DB: NeighborWalkDB, NC: NeighborComms> NeighborWalk<DB, NC> {
 
     /// Select neighbors that are routable, and ignore ones that are not.
     /// TODO: expand if we ever want to filter by unroutable network class or something
-    fn filter_sensible_neighbors(mut neighbors: Vec<NeighborAddress>) -> Vec<NeighborAddress> {
+    fn filter_sensible_neighbors(
+        mut neighbors: Vec<NeighborAddress>,
+        private_neighbors: bool,
+    ) -> Vec<NeighborAddress> {
         neighbors.retain(|neighbor| !neighbor.addrbytes.is_anynet());
+        if !private_neighbors {
+            neighbors.retain(|neighbor| !neighbor.addrbytes.is_in_private_range());
+        }
         neighbors
     }
 
@@ -644,8 +650,6 @@ impl<DB: NeighborWalkDB, NC: NeighborComms> NeighborWalk<DB, NC> {
         }
     }
 
-    /// Determine if a peer is routable from us
-
     /// Handle a HandshakeAcceptData.
     /// Update the PeerDB information from the handshake data, as well as `self.cur_neighbor`, if
     /// this neighbor was routable.  If it's not routable (i.e. we walked to an inbound neighbor),
@@ -834,7 +838,10 @@ impl<DB: NeighborWalkDB, NC: NeighborComms> NeighborWalk<DB, NC> {
                     &self.cur_neighbor.addr,
                     data.neighbors
                 );
-                let neighbors = Self::filter_sensible_neighbors(data.neighbors.clone());
+                let neighbors = Self::filter_sensible_neighbors(
+                    data.neighbors.clone(),
+                    network.get_connection_opts().private_neighbors,
+                );
                 let (mut found, to_resolve) = self
                     .neighbor_db
                     .lookup_stale_neighbors(network, &neighbors)?;
@@ -1278,7 +1285,10 @@ impl<DB: NeighborWalkDB, NC: NeighborComms> NeighborWalk<DB, NC> {
                         &nkey,
                         &data.neighbors
                     );
-                    let neighbors = Self::filter_sensible_neighbors(data.neighbors.clone());
+                    let neighbors = Self::filter_sensible_neighbors(
+                        data.neighbors.clone(),
+                        network.get_connection_opts().private_neighbors,
+                    );
                     self.resolved_getneighbors_neighbors
                         .insert(naddr, neighbors);
                 }

From 71355c514ceb5bbbff3d385f8a8c39d7979e541d Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Fri, 19 Jan 2024 21:54:58 -0500
Subject: [PATCH 0404/1166] fix: expose private_neighbors via config.rs

---
 testnet/stacks-node/src/config.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index 33bf70ac6e..7dd30eea21 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -1225,6 +1225,7 @@ impl Config {
                     handshake_timeout: opts.handshake_timeout.unwrap_or(5),
                     max_sockets: opts.max_sockets.unwrap_or(800) as usize,
                     antientropy_public: opts.antientropy_public.unwrap_or(true),
+                    private_neighbors: opts.private_neighbors.unwrap_or(true),
                     ..ConnectionOptions::default()
                 }
             }
@@ -2097,7 +2098,6 @@ pub struct ConnectionOptionsFile {
     pub max_inflight_attachments: Option<u64>,
     pub read_only_call_limit_write_length: Option<u64>,
     pub read_only_call_limit_read_length: Option<u64>,
-
     pub read_only_call_limit_write_count: Option<u64>,
     pub read_only_call_limit_read_count: Option<u64>,
     pub read_only_call_limit_runtime: Option<u64>,
@@ -2112,6 +2112,7 @@ pub struct ConnectionOptionsFile {
     pub disable_block_download: Option<bool>,
     pub force_disconnect_interval: Option<u64>,
     pub antientropy_public: Option<bool>,
+    pub private_neighbors: Option<bool>,
 }
 
 #[derive(Clone, Deserialize, Default, Debug)]

From 7e970964d1b1665ff218b6f52ef5db43f2832100 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Sat, 20 Jan 2024 16:00:00 -0600
Subject: [PATCH 0405/1166] integration test for stacker-set event and signing
 key assembly. currently failing: need to update to set for all pox-4 cycles

---
 .../src/tests/nakamoto_integrations.rs        | 48 ++++++++++++++++++-
 .../src/tests/neon_integrations.rs            | 48 ++++++++++++++++++-
 2 files changed, 93 insertions(+), 3 deletions(-)

diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index aa979bda0e..1bb94f6030 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -46,7 +46,8 @@ use stacks_common::address::AddressHashMode;
 use stacks_common::codec::StacksMessageCodec;
 use stacks_common::consts::STACKS_EPOCH_MAX;
 use stacks_common::types::chainstate::{StacksAddress, StacksPrivateKey, StacksPublicKey};
-use stacks_common::util::hash::to_hex;
+use stacks_common::types::PrivateKey;
+use stacks_common::util::hash::{to_hex, Sha512Sum};
 use stacks_common::util::secp256k1::{MessageSignature, Secp256k1PrivateKey};
 
 use super::bitcoin_regtest::BitcoinCoreController;
@@ -814,7 +815,7 @@ fn correct_burn_outs() {
     let observer_port = test_observer::EVENT_OBSERVER_PORT;
     naka_conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{observer_port}"),
-        events_keys: vec![EventKeyType::AnyEvent],
+        events_keys: vec![EventKeyType::AnyEvent, EventKeyType::StackerSet],
     });
 
     let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone());
@@ -901,6 +902,12 @@ fn correct_burn_outs() {
                 tests::to_addr(&account.0).bytes.to_hex(),
                 AddressHashMode::SerializeP2PKH as u8,
             ));
+            // create a new SK, mixing in the nonce, because signing keys cannot (currently)
+            //  be reused.
+            let mut seed_inputs = account.0.to_bytes();
+            seed_inputs.extend_from_slice(&account.2.nonce.to_be_bytes());
+            let new_sk = StacksPrivateKey::from_seed(Sha512Sum::from_data(&seed_inputs).as_bytes());
+            let pk_bytes = StacksPublicKey::from_private(&new_sk).to_bytes_compressed();
 
             let stacking_tx = tests::make_contract_call(
                 &account.0,
@@ -914,6 +921,7 @@ fn correct_burn_outs() {
                     pox_addr_tuple,
                     clarity::vm::Value::UInt(pox_info.current_burnchain_block_height.into()),
                     clarity::vm::Value::UInt(1),
+                    clarity::vm::Value::buff_from(pk_bytes).unwrap(),
                 ],
             );
             let txid = submit_tx(&http_origin, &stacking_tx);
@@ -952,6 +960,9 @@ fn correct_burn_outs() {
 
     // Mine nakamoto tenures
     for _i in 0..30 {
+        let prior_tip = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn())
+            .unwrap()
+            .block_height;
         if let Err(e) = next_block_and_mine_commit(
             &mut btc_regtest_controller,
             30,
@@ -961,6 +972,7 @@ fn correct_burn_outs() {
             warn!(
                 "Error while minting a bitcoin block and waiting for stacks-node activity: {e:?}"
             );
+            panic!();
         }
 
         let tip_sn = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn()).unwrap();
@@ -968,6 +980,10 @@ fn correct_burn_outs() {
             tip_sn.sortition,
             "The new chain tip must have had a sortition"
         );
+        assert!(
+            tip_sn.block_height > prior_tip,
+            "The new burnchain tip must have been processed"
+        );
     }
 
     coord_channel
@@ -976,6 +992,34 @@ fn correct_burn_outs() {
         .stop_chains_coordinator();
     run_loop_stopper.store(false, Ordering::SeqCst);
 
+    let stacker_sets = test_observer::get_stacker_sets();
+    info!("Stacker sets announced {:#?}", stacker_sets);
+    let mut sorted_stacker_sets = stacker_sets.clone();
+    sorted_stacker_sets.sort_by_key(|(_block_id, cycle_num, _reward_set)| *cycle_num);
+    assert_eq!(
+        sorted_stacker_sets, stacker_sets,
+        "Stacker set should be sorted by cycle number already"
+    );
+
+    let first_epoch_3_cycle = burnchain
+        .block_height_to_reward_cycle(epoch_3.start_height)
+        .unwrap();
+    for (_, cycle_number, reward_set) in stacker_sets.iter() {
+        if *cycle_number < first_epoch_3_cycle {
+            assert!(reward_set.signers.is_none());
+            // nothing else to check for < first_epoch_3_cycle
+            continue;
+        }
+        let Some(signers) = reward_set.signers.clone() else {
+            panic!("Signers should be set in any epoch-3 cycles. First epoch-3 cycle: {first_epoch_3_cycle}. Checked cycle number: {cycle_number}");
+        };
+        // there should be 1 stacker signer, and 1 reward address
+        assert_eq!(reward_set.rewarded_addresses.len(), 1);
+        assert_eq!(signers.len(), 1);
+        // the signer should have 1 "slot", because they stacked the minimum stacking amount
+        assert_eq!(signers[0].slots, 1);
+    }
+
     run_loop_thread.join().unwrap();
 }
 
diff --git a/testnet/stacks-node/src/tests/neon_integrations.rs b/testnet/stacks-node/src/tests/neon_integrations.rs
index 9cb4d1a33a..fccfeac3f1 100644
--- a/testnet/stacks-node/src/tests/neon_integrations.rs
+++ b/testnet/stacks-node/src/tests/neon_integrations.rs
@@ -177,8 +177,10 @@ pub mod test_observer {
     use std::sync::Mutex;
     use std::thread;
 
+    use stacks::chainstate::stacks::boot::RewardSet;
     use stacks::chainstate::stacks::events::StackerDBChunksEvent;
     use stacks::net::api::postblock_proposal::BlockValidateResponse;
+    use stacks_common::types::chainstate::StacksBlockId;
     use warp::Filter;
     use {tokio, warp};
 
@@ -197,6 +199,7 @@ pub mod test_observer {
     pub static MEMTXS_DROPPED: Mutex<Vec<(String, String)>> = Mutex::new(Vec::new());
     pub static ATTACHMENTS: Mutex<Vec<serde_json::Value>> = Mutex::new(Vec::new());
     pub static PROPOSAL_RESPONSES: Mutex<Vec<BlockValidateResponse>> = Mutex::new(Vec::new());
+    pub static STACKER_SETS: Mutex<Vec<(StacksBlockId, u64, RewardSet)>> = Mutex::new(Vec::new());
 
     async fn handle_proposal_response(
         response: serde_json::Value,
@@ -280,6 +283,40 @@ pub mod test_observer {
         Ok(warp::http::StatusCode::OK)
     }
 
+    async fn handle_pox_stacker_set(
+        stacker_set: serde_json::Value,
+    ) -> Result<impl warp::Reply, Infallible> {
+        let mut stacker_sets = STACKER_SETS.lock().unwrap();
+        let block_id = stacker_set
+            .as_object()
+            .expect("Expected JSON object for stacker set event")
+            .get("block_id")
+            .expect("Expected block_id field")
+            .as_str()
+            .expect("Expected string for block id")
+            .to_string();
+        let block_id = StacksBlockId::from_hex(&block_id)
+            .expect("Failed to parse block id field as StacksBlockId hex");
+        let cycle_number = stacker_set
+            .as_object()
+            .expect("Expected JSON object for stacker set event")
+            .get("cycle_number")
+            .expect("Expected field")
+            .as_u64()
+            .expect("Expected u64 for cycle number");
+        let stacker_set = serde_json::from_value(
+            stacker_set
+                .as_object()
+                .expect("Expected JSON object for stacker set event")
+                .get("stacker_set")
+                .expect("Expected field")
+                .clone(),
+        )
+        .expect("Failed to parse stacker set object");
+        stacker_sets.push((block_id, cycle_number, stacker_set));
+        Ok(warp::http::StatusCode::OK)
+    }
+
     /// Called by the process listening to events on a mined microblock event. The event is added
     /// to the mutex-guarded vector `MINED_MICROBLOCKS`.
     async fn handle_mined_microblock(
@@ -370,6 +407,10 @@ pub mod test_observer {
         Ok(warp::http::StatusCode::OK)
     }
 
+    pub fn get_stacker_sets() -> Vec<(StacksBlockId, u64, RewardSet)> {
+        STACKER_SETS.lock().unwrap().clone()
+    }
+
     pub fn get_memtxs() -> Vec<String> {
         MEMTXS.lock().unwrap().clone()
     }
@@ -460,6 +501,10 @@ pub mod test_observer {
             .and(warp::post())
             .and(warp::body::json())
             .and_then(handle_proposal_response);
+        let stacker_sets = warp::path!("new_pox_set")
+            .and(warp::post())
+            .and(warp::body::json())
+            .and_then(handle_pox_stacker_set);
 
         info!("Spawning event-observer warp server");
         warp::serve(
@@ -473,7 +518,8 @@ pub mod test_observer {
                 .or(mined_microblocks)
                 .or(mined_nakamoto_blocks)
                 .or(new_stackerdb_chunks)
-                .or(block_proposals),
+                .or(block_proposals)
+                .or(stacker_sets),
         )
         .run(([127, 0, 0, 1], port))
         .await

From de3704505da8db6316da4a4a409ffae1ff1ccc71 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Sun, 21 Jan 2024 09:35:11 -0600
Subject: [PATCH 0406/1166] updated nakamoto reward set choice, passing
 integration test

---
 stackslib/src/chainstate/coordinator/mod.rs   | 30 +++++++++++--------
 .../chainstate/nakamoto/coordinator/mod.rs    |  5 +++-
 2 files changed, 22 insertions(+), 13 deletions(-)

diff --git a/stackslib/src/chainstate/coordinator/mod.rs b/stackslib/src/chainstate/coordinator/mod.rs
index ed7361be21..85bfc83b48 100644
--- a/stackslib/src/chainstate/coordinator/mod.rs
+++ b/stackslib/src/chainstate/coordinator/mod.rs
@@ -307,16 +307,25 @@ impl<'a, T: BlockEventDispatcher> RewardSetProvider for OnChainRewardSetProvider
     ) -> Result<RewardSet, Error> {
         let cur_epoch = SortitionDB::get_stacks_epoch(sortdb.conn(), cycle_start_burn_height)?
             .expect(&format!(
-                "FATAL: no epoch for burn height {}",
-                cycle_start_burn_height
+                "FATAL: no epoch for burn height {cycle_start_burn_height}",
             ));
-        // TODO: should Epoch-2.5 be included in `get_reward_set_nakamoto()`?
-        // The differences are:
-        //     (a) no minimum participation threshold (I think this *is* important)
-        //     (b) panicking assertion if there are no signing-keys set
-        // Apart from (a), this shouldn't matter: the signing-keys are always set whenever
-        //  the reward set is loaded from pox-4.
-        let reward_set = if cur_epoch.epoch_id < StacksEpochId::Epoch30 {
+        let cycle = burnchain
+            .block_height_to_reward_cycle(cycle_start_burn_height)
+            .expect("FATAL: no reward cycle for burn height");
+        let is_nakamoto_reward_set = match SortitionDB::get_stacks_epoch_by_epoch_id(
+            sortdb.conn(),
+            &StacksEpochId::Epoch30,
+        )? {
+            Some(epoch_30) => {
+                let first_nakamoto_cycle = burnchain
+                    .block_height_to_reward_cycle(epoch_30.start_height)
+                    .expect("FATAL: no reward cycle for burn height");
+                first_nakamoto_cycle <= cycle
+            }
+            // if epoch-3.0 isn't defined, then never use a nakamoto reward set.
+            None => false,
+        };
+        let reward_set = if !is_nakamoto_reward_set {
             // Stacks 2.x epoch
             self.get_reward_set_epoch2(
                 cycle_start_burn_height,
@@ -338,9 +347,6 @@ impl<'a, T: BlockEventDispatcher> RewardSetProvider for OnChainRewardSetProvider
         };
 
         if let Some(dispatcher) = self.0 {
-            let cycle = burnchain
-                .block_height_to_reward_cycle(cycle_start_burn_height)
-                .expect("FATAL: no reward cycle for burn height");
             dispatcher.announce_reward_set(&reward_set, block_id, cycle);
         }
 
diff --git a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
index 2613fc8b8a..22e58158cb 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
@@ -94,7 +94,10 @@ impl<'a, T: BlockEventDispatcher> OnChainRewardSetProvider<'a, T> {
                 cycle_start_burn_height
             ));
 
-        if cur_epoch.epoch_id >= StacksEpochId::Epoch30 && participation == 0 {
+        // This method should only ever called if the current reward cycle is a nakamoto reward cycle
+        //  (i.e., its reward set is fetched for determining signer sets (and therefore agg keys).
+        //  Non participation is fatal.
+        if participation == 0 {
             // no one is stacking
             error!("No PoX participation");
             return Err(Error::PoXAnchorBlockRequired);

From ff7c5490366e4bd0f3205a40b94782bf4bfa14f9 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Sun, 21 Jan 2024 23:18:53 -0500
Subject: [PATCH 0407/1166] feat: add
 /v2/stackerdb/{contract-addr}/{contract-name}/replicas API endpoint, which
 returns a list of recently-seen neighbor addresses which replicate a
 particular StackerDB

---
 .../src/net/api/liststackerdbreplicas.rs      | 197 ++++++++++++++++++
 stackslib/src/net/api/mod.rs                  |   4 +
 .../net/api/tests/liststackerdbreplicas.rs    | 131 ++++++++++++
 stackslib/src/net/api/tests/mod.rs            |  31 +++
 stackslib/src/net/db.rs                       | 137 ++++++++----
 stackslib/src/net/mod.rs                      |   1 +
 stackslib/src/net/stackerdb/sync.rs           |   4 +
 7 files changed, 463 insertions(+), 42 deletions(-)
 create mode 100644 stackslib/src/net/api/liststackerdbreplicas.rs
 create mode 100644 stackslib/src/net/api/tests/liststackerdbreplicas.rs

diff --git a/stackslib/src/net/api/liststackerdbreplicas.rs b/stackslib/src/net/api/liststackerdbreplicas.rs
new file mode 100644
index 0000000000..c4184caa0c
--- /dev/null
+++ b/stackslib/src/net/api/liststackerdbreplicas.rs
@@ -0,0 +1,197 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020-2024 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+use std::io::{Read, Seek, SeekFrom, Write};
+use std::{fs, io};
+
+use clarity::vm::clarity::ClarityConnection;
+use clarity::vm::representations::{
+    CONTRACT_NAME_REGEX_STRING, PRINCIPAL_DATA_REGEX_STRING, STANDARD_PRINCIPAL_REGEX_STRING,
+};
+use clarity::vm::types::{PrincipalData, QualifiedContractIdentifier, StandardPrincipalData};
+use clarity::vm::{ClarityName, ContractName};
+use regex::{Captures, Regex};
+use serde::de::Error as de_Error;
+use stacks_common::codec::{StacksMessageCodec, MAX_MESSAGE_LEN};
+use stacks_common::types::chainstate::StacksBlockId;
+use stacks_common::types::net::PeerHost;
+use stacks_common::util::get_epoch_time_secs;
+use stacks_common::util::hash::to_hex;
+use {serde, serde_json};
+
+use crate::chainstate::stacks::db::StacksChainState;
+use crate::chainstate::stacks::{Error as ChainError, StacksBlock};
+use crate::net::db::PeerDB;
+use crate::net::http::{
+    parse_json, Error, HttpBadRequest, HttpChunkGenerator, HttpContentType, HttpNotFound,
+    HttpRequest, HttpRequestContents, HttpRequestPreamble, HttpResponse, HttpResponseContents,
+    HttpResponsePayload, HttpResponsePreamble, HttpServerError,
+};
+use crate::net::httpcore::{
+    request, HttpPreambleExtensions, HttpRequestContentsExtensions, RPCRequestHandler, StacksHttp,
+    StacksHttpRequest, StacksHttpResponse,
+};
+use crate::net::{Error as NetError, NeighborAddress, StacksNodeState, TipRequest, MAX_HEADERS};
+use crate::util_lib::db::{DBConn, Error as DBError};
+
+/// Largest number of replicas returned
+pub const MAX_LIST_REPLICAS: usize = 64;
+
+#[derive(Clone)]
+pub struct RPCListStackerDBReplicasRequestHandler {
+    pub contract_identifier: Option<QualifiedContractIdentifier>,
+}
+
+impl RPCListStackerDBReplicasRequestHandler {
+    pub fn new() -> Self {
+        Self {
+            contract_identifier: None,
+        }
+    }
+}
+
+/// Decode the HTTP request
+impl HttpRequest for RPCListStackerDBReplicasRequestHandler {
+    fn verb(&self) -> &'static str {
+        "GET"
+    }
+
+    fn path_regex(&self) -> Regex {
+        Regex::new(&format!(
+            r#"^/v2/stackerdb/(?P<address>{})/(?P<contract>{})/replicas$"#,
+            *STANDARD_PRINCIPAL_REGEX_STRING, *CONTRACT_NAME_REGEX_STRING
+        ))
+        .unwrap()
+    }
+
+    /// Try to decode this request.
+    /// There's nothing to load here, so just make sure the request is well-formed.
+    fn try_parse_request(
+        &mut self,
+        preamble: &HttpRequestPreamble,
+        captures: &Captures,
+        query: Option<&str>,
+        _body: &[u8],
+    ) -> Result<HttpRequestContents, Error> {
+        if preamble.get_content_length() != 0 {
+            return Err(Error::DecodeError(
+                "Invalid Http request: expected 0-length body".to_string(),
+            ));
+        }
+
+        let contract_identifier = request::get_contract_address(captures, "address", "contract")?;
+        self.contract_identifier = Some(contract_identifier);
+
+        Ok(HttpRequestContents::new().query_string(query))
+    }
+}
+
+impl RPCRequestHandler for RPCListStackerDBReplicasRequestHandler {
+    /// Reset internal state
+    fn restart(&mut self) {
+        self.contract_identifier = None;
+    }
+
+    /// Make the response
+    fn try_handle_request(
+        &mut self,
+        preamble: HttpRequestPreamble,
+        _contents: HttpRequestContents,
+        node: &mut StacksNodeState,
+    ) -> Result<(HttpResponsePreamble, HttpResponseContents), NetError> {
+        let contract_identifier = self
+            .contract_identifier
+            .take()
+            .ok_or(NetError::SendError("`contract_identifier` not set".into()))?;
+
+        let replicas_resp =
+            node.with_node_state(|network, _sortdb, _chainstate, _mempool, _rpc_args| {
+                PeerDB::find_stacker_db_replicas(
+                    network.peerdb_conn(),
+                    network.bound_neighbor_key().network_id,
+                    &contract_identifier,
+                    get_epoch_time_secs().saturating_sub(network.get_connection_opts().max_neighbor_age),
+                    MAX_LIST_REPLICAS
+                )
+                .map_err(|e| {
+                    warn!("Failed to find stackerdb replicas"; "contract_id" => %contract_identifier, "error" => %e);
+                    StacksHttpResponse::new_error(
+                        &preamble,
+                        &HttpServerError::new("Unable to list replicas of StackerDB".to_string())
+                    )
+                })
+            });
+
+        let naddrs_resp = match replicas_resp {
+            Ok(neighbors) => neighbors
+                .into_iter()
+                .map(|neighbor| NeighborAddress::from_neighbor(&neighbor))
+                .collect::<Vec<_>>(),
+            Err(response) => {
+                return response.try_into_contents().map_err(NetError::from);
+            }
+        };
+
+        let mut preamble = HttpResponsePreamble::ok_json(&preamble);
+        preamble.set_canonical_stacks_tip_height(Some(node.canonical_stacks_tip_height()));
+        let body = HttpResponseContents::try_from_json(&naddrs_resp)?;
+        Ok((preamble, body))
+    }
+}
+
+/// Decode the HTTP response
+impl HttpResponse for RPCListStackerDBReplicasRequestHandler {
+    /// Decode this response from a byte stream.  This is called by the client to decode this
+    /// message
+    fn try_parse_response(
+        &self,
+        preamble: &HttpResponsePreamble,
+        body: &[u8],
+    ) -> Result<HttpResponsePayload, Error> {
+        let metadata: Vec<NeighborAddress> = parse_json(preamble, body)?;
+        Ok(HttpResponsePayload::try_from_json(metadata)?)
+    }
+}
+
+impl StacksHttpRequest {
+    pub fn new_list_stackerdb_replicas(
+        host: PeerHost,
+        stackerdb_contract_id: QualifiedContractIdentifier,
+    ) -> StacksHttpRequest {
+        StacksHttpRequest::new_for_peer(
+            host,
+            "GET".into(),
+            format!(
+                "/v2/stackerdb/{}/{}/replicas",
+                &stackerdb_contract_id.issuer, &stackerdb_contract_id.name
+            ),
+            HttpRequestContents::new(),
+        )
+        .expect("FATAL: failed to construct request from infallible data")
+    }
+}
+
+impl StacksHttpResponse {
+    /// Decode an HTTP response into a list of replicas
+    /// If it fails, return Self::Error(..)
+    pub fn decode_stackerdb_replicas(self) -> Result<Vec<NeighborAddress>, NetError> {
+        let contents = self.get_http_payload_ok()?;
+        let contents_json: serde_json::Value = contents.try_into()?;
+        let resp: Vec<NeighborAddress> = serde_json::from_value(contents_json)
+            .map_err(|_e| NetError::DeserializeError("Failed to load from JSON".to_string()))?;
+        Ok(resp)
+    }
+}
diff --git a/stackslib/src/net/api/mod.rs b/stackslib/src/net/api/mod.rs
index 3eaa6148d2..d8b40b4680 100644
--- a/stackslib/src/net/api/mod.rs
+++ b/stackslib/src/net/api/mod.rs
@@ -55,6 +55,7 @@ pub mod getstackerdbchunk;
 pub mod getstackerdbmetadata;
 pub mod getstxtransfercost;
 pub mod gettransaction_unconfirmed;
+pub mod liststackerdbreplicas;
 pub mod postblock;
 pub mod postfeerate;
 pub mod postmempoolquery;
@@ -106,6 +107,9 @@ impl StacksHttp {
         self.register_rpc_endpoint(
             gettransaction_unconfirmed::RPCGetTransactionUnconfirmedRequestHandler::new(),
         );
+        self.register_rpc_endpoint(
+            liststackerdbreplicas::RPCListStackerDBReplicasRequestHandler::new(),
+        );
         self.register_rpc_endpoint(postblock::RPCPostBlockRequestHandler::new());
         self.register_rpc_endpoint(postfeerate::RPCPostFeeRateRequestHandler::new());
         self.register_rpc_endpoint(postmempoolquery::RPCMempoolQueryRequestHandler::new());
diff --git a/stackslib/src/net/api/tests/liststackerdbreplicas.rs b/stackslib/src/net/api/tests/liststackerdbreplicas.rs
new file mode 100644
index 0000000000..8c6504ea7e
--- /dev/null
+++ b/stackslib/src/net/api/tests/liststackerdbreplicas.rs
@@ -0,0 +1,131 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020-2023 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+use std::net::{IpAddr, Ipv4Addr, SocketAddr};
+
+use clarity::vm::types::{PrincipalData, QualifiedContractIdentifier, StacksAddressExtensions};
+use clarity::vm::{ClarityName, ContractName, Value};
+use stacks_common::types::chainstate::StacksAddress;
+use stacks_common::types::net::{PeerAddress, PeerHost};
+use stacks_common::types::Address;
+use stacks_common::util::hash::{Hash160, Sha512Trunc256Sum};
+use stacks_common::util::secp256k1::MessageSignature;
+
+use super::test_rpc;
+use crate::core::BLOCK_LIMIT_MAINNET_21;
+use crate::net::api::*;
+use crate::net::connection::ConnectionOptions;
+use crate::net::httpcore::{
+    HttpPreambleExtensions, HttpRequestContentsExtensions, RPCRequestHandler, StacksHttp,
+    StacksHttpRequest,
+};
+use crate::net::{ProtocolFamily, TipRequest};
+
+#[test]
+fn test_try_parse_request() {
+    let addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 33333);
+    let mut http = StacksHttp::new(addr.clone(), &ConnectionOptions::default());
+
+    let contract_identifier = QualifiedContractIdentifier::parse(
+        "ST2DS4MSWSGJ3W9FBC6BVT0Y92S345HY8N3T6AV7R.hello-world-unconfirmed",
+    )
+    .unwrap();
+    let request =
+        StacksHttpRequest::new_list_stackerdb_replicas(addr.into(), contract_identifier.clone());
+    let bytes = request.try_serialize().unwrap();
+
+    debug!("Request:\n{}\n", std::str::from_utf8(&bytes).unwrap());
+
+    let (parsed_preamble, offset) = http.read_preamble(&bytes).unwrap();
+    let mut handler = liststackerdbreplicas::RPCListStackerDBReplicasRequestHandler::new();
+    let mut parsed_request = http
+        .handle_try_parse_request(
+            &mut handler,
+            &parsed_preamble.expect_request(),
+            &bytes[offset..],
+        )
+        .unwrap();
+
+    assert_eq!(
+        handler.contract_identifier,
+        Some(contract_identifier.clone())
+    );
+
+    // parsed request consumes headers that would not be in a constructed reqeuest
+    parsed_request.clear_headers();
+    let (preamble, contents) = parsed_request.destruct();
+
+    assert_eq!(&preamble, request.preamble());
+
+    handler.restart();
+    assert!(handler.contract_identifier.is_none());
+}
+
+#[test]
+fn test_try_make_response() {
+    let addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 33333);
+
+    let mut requests = vec![];
+
+    let contract_identifier =
+        QualifiedContractIdentifier::parse("ST2DS4MSWSGJ3W9FBC6BVT0Y92S345HY8N3T6AV7R.hello-world")
+            .unwrap();
+    let none_contract_identifier = QualifiedContractIdentifier::parse(
+        "ST2DS4MSWSGJ3W9FBC6BVT0Y92S345HY8N3T6AV7R.does-not-ext",
+    )
+    .unwrap();
+
+    let request =
+        StacksHttpRequest::new_list_stackerdb_replicas(addr.into(), contract_identifier.clone());
+    requests.push(request);
+
+    // no contract
+    let request = StacksHttpRequest::new_list_stackerdb_replicas(
+        addr.into(),
+        none_contract_identifier.clone(),
+    );
+    requests.push(request);
+
+    let mut responses = test_rpc(function_name!(), requests);
+
+    let response = responses.remove(0);
+    debug!(
+        "Response:\n{}\n",
+        std::str::from_utf8(&response.try_serialize().unwrap()).unwrap()
+    );
+    assert_eq!(
+        response.preamble().get_canonical_stacks_tip_height(),
+        Some(1)
+    );
+
+    let mut resp = response.decode_stackerdb_replicas().unwrap();
+    assert_eq!(resp.len(), 1);
+    let naddr = resp.pop().unwrap();
+    assert_eq!(naddr.addrbytes, PeerAddress::from_ipv4(127, 0, 0, 1));
+    assert_eq!(naddr.port, 0);
+    assert_eq!(
+        naddr.public_key_hash,
+        Hash160::from_hex("9b92533ccc243e25eb6197bd03c9164642c7c8a8").unwrap()
+    );
+
+    let response = responses.remove(0);
+    debug!(
+        "Response:\n{}\n",
+        std::str::from_utf8(&response.try_serialize().unwrap()).unwrap()
+    );
+    let resp = response.decode_stackerdb_replicas().unwrap();
+    assert_eq!(resp.len(), 0);
+}
diff --git a/stackslib/src/net/api/tests/mod.rs b/stackslib/src/net/api/tests/mod.rs
index cc52a80e6e..6476962d1f 100644
--- a/stackslib/src/net/api/tests/mod.rs
+++ b/stackslib/src/net/api/tests/mod.rs
@@ -24,6 +24,7 @@ use stacks_common::codec::StacksMessageCodec;
 use stacks_common::types::chainstate::{
     BlockHeaderHash, ConsensusHash, StacksAddress, StacksBlockId, StacksPrivateKey, StacksPublicKey,
 };
+use stacks_common::util::get_epoch_time_secs;
 use stacks_common::util::hash::{Hash160, Sha512Trunc256Sum};
 use stacks_common::util::pipe::Pipe;
 
@@ -38,6 +39,7 @@ use crate::chainstate::stacks::{
     TransactionAuth, TransactionPayload, TransactionPostConditionMode, TransactionVersion,
 };
 use crate::core::MemPoolDB;
+use crate::net::db::PeerDB;
 use crate::net::httpcore::{StacksHttpRequest, StacksHttpResponse};
 use crate::net::relay::Relayer;
 use crate::net::rpc::ConversationHttp;
@@ -68,6 +70,7 @@ mod getstackerdbchunk;
 mod getstackerdbmetadata;
 mod getstxtransfercost;
 mod gettransaction_unconfirmed;
+mod liststackerdbreplicas;
 mod postblock;
 mod postfeerate;
 mod postmempoolquery;
@@ -237,6 +240,9 @@ impl<'a> TestRPC<'a> {
         let mut peer_1_config = TestPeerConfig::new(&format!("{}-peer1", test_name), 0, 0);
         let mut peer_2_config = TestPeerConfig::new(&format!("{}-peer2", test_name), 0, 0);
 
+        peer_1_config.private_key = privk1.clone();
+        peer_2_config.private_key = privk2.clone();
+
         peer_1_config.connection_opts.read_only_call_limit = ExecutionCost {
             write_length: 0,
             write_count: 0,
@@ -370,6 +376,31 @@ impl<'a> TestRPC<'a> {
             bytes.len() as u64
         };
 
+        // force peer 2 to know about peer 1
+        {
+            let tx = peer_2.network.peerdb.tx_begin().unwrap();
+            let mut neighbor = peer_1.config.to_neighbor();
+            neighbor.last_contact_time = get_epoch_time_secs();
+            PeerDB::try_insert_peer(
+                &tx,
+                &neighbor,
+                &[QualifiedContractIdentifier::new(
+                    addr1.clone().into(),
+                    "hello-world".into(),
+                )],
+            )
+            .unwrap();
+            tx.commit().unwrap();
+        }
+        // force peer 1 to know about peer 2
+        {
+            let tx = peer_1.network.peerdb.tx_begin().unwrap();
+            let mut neighbor = peer_2.config.to_neighbor();
+            neighbor.last_contact_time = get_epoch_time_secs();
+            PeerDB::try_insert_peer(&tx, &neighbor, &[]).unwrap();
+            tx.commit().unwrap();
+        }
+
         let tip =
             SortitionDB::get_canonical_burn_chain_tip(&peer_1.sortdb.as_ref().unwrap().conn())
                 .unwrap();
diff --git a/stackslib/src/net/db.rs b/stackslib/src/net/db.rs
index 25c4ed7e62..e19b041003 100644
--- a/stackslib/src/net/db.rs
+++ b/stackslib/src/net/db.rs
@@ -1770,29 +1770,27 @@ impl PeerDB {
     }
 
     /// Find out which peers replicate a particular stacker DB.
-    /// Return a randomized list of up to the given size.
+    /// Return a randomized list of up to the given size, where all
+    /// peers returned have a last-contact time greater than the given minimum age.
     pub fn find_stacker_db_replicas(
         conn: &DBConn,
         network_id: u32,
         smart_contract: &QualifiedContractIdentifier,
+        min_age: u64,
         max_count: usize,
     ) -> Result<Vec<Neighbor>, db_error> {
         if max_count == 0 {
             return Ok(vec![]);
         }
-        let mut slots = PeerDB::get_stacker_db_slots(conn, smart_contract)?;
-        slots.shuffle(&mut thread_rng());
-
-        let mut ret = vec![];
-        for slot in slots {
-            if let Some(neighbor) = PeerDB::get_peer_at(conn, network_id, slot)? {
-                ret.push(neighbor);
-                if ret.len() >= max_count {
-                    break;
-                }
-            }
-        }
-        Ok(ret)
+        let qry = "SELECT DISTINCT frontier.* FROM frontier JOIN stackerdb_peers ON stackerdb_peers.peer_slot = frontier.slot WHERE stackerdb_peers.smart_contract_id = ?1 AND frontier.network_id = ?2 AND frontier.last_contact_time >= ?3 ORDER BY RANDOM() LIMIT ?4";
+        let max_count_u32 = u32::try_from(max_count).unwrap_or(u32::MAX);
+        let args: &[&dyn ToSql] = &[
+            &smart_contract.to_string(),
+            &network_id,
+            &u64_to_sql(min_age)?,
+            &max_count_u32,
+        ];
+        query_rows(conn, qry, args)
     }
 }
 
@@ -2479,21 +2477,21 @@ mod test {
         }
 
         let replicas =
-            PeerDB::find_stacker_db_replicas(&db.conn, 0x9abcdef0, &stackerdbs[0], 1).unwrap();
+            PeerDB::find_stacker_db_replicas(&db.conn, 0x9abcdef0, &stackerdbs[0], 0, 1).unwrap();
         assert_eq!(replicas.len(), 1);
         assert_eq!(replicas[0], neighbor);
 
         let replicas =
-            PeerDB::find_stacker_db_replicas(&db.conn, 0x9abcdef0, &stackerdbs[0], 2).unwrap();
+            PeerDB::find_stacker_db_replicas(&db.conn, 0x9abcdef0, &stackerdbs[0], 0, 2).unwrap();
         assert_eq!(replicas.len(), 1);
         assert_eq!(replicas[0], neighbor);
 
         let replicas =
-            PeerDB::find_stacker_db_replicas(&db.conn, 0x9abcdef0, &stackerdbs[0], 0).unwrap();
+            PeerDB::find_stacker_db_replicas(&db.conn, 0x9abcdef0, &stackerdbs[0], 0, 0).unwrap();
         assert_eq!(replicas.len(), 0);
 
         let replicas =
-            PeerDB::find_stacker_db_replicas(&db.conn, 0x9abcdef1, &stackerdbs[0], 1).unwrap();
+            PeerDB::find_stacker_db_replicas(&db.conn, 0x9abcdef1, &stackerdbs[0], 0, 1).unwrap();
         assert_eq!(replicas.len(), 0);
 
         // insert new stacker DBs -- keep one the same, and add a different one
@@ -2523,17 +2521,50 @@ mod test {
         assert_eq!(neighbor_stackerdbs, changed_stackerdbs);
 
         let replicas =
-            PeerDB::find_stacker_db_replicas(&db.conn, 0x9abcdef0, &changed_stackerdbs[0], 1)
+            PeerDB::find_stacker_db_replicas(&db.conn, 0x9abcdef0, &changed_stackerdbs[0], 0, 1)
                 .unwrap();
         assert_eq!(replicas.len(), 1);
         assert_eq!(replicas[0], neighbor);
 
         let replicas =
-            PeerDB::find_stacker_db_replicas(&db.conn, 0x9abcdef0, &changed_stackerdbs[1], 1)
+            PeerDB::find_stacker_db_replicas(&db.conn, 0x9abcdef0, &changed_stackerdbs[1], 0, 1)
                 .unwrap();
         assert_eq!(replicas.len(), 1);
         assert_eq!(replicas[0], neighbor);
 
+        // query stacker DBs filtering by last-contact time
+        let replicas = PeerDB::find_stacker_db_replicas(
+            &db.conn,
+            0x9abcdef0,
+            &changed_stackerdbs[1],
+            1552509641,
+            1,
+        )
+        .unwrap();
+        assert_eq!(replicas.len(), 1);
+        assert_eq!(replicas[0], neighbor);
+
+        let replicas = PeerDB::find_stacker_db_replicas(
+            &db.conn,
+            0x9abcdef0,
+            &changed_stackerdbs[1],
+            1552509642,
+            1,
+        )
+        .unwrap();
+        assert_eq!(replicas.len(), 1);
+        assert_eq!(replicas[0], neighbor);
+
+        let replicas = PeerDB::find_stacker_db_replicas(
+            &db.conn,
+            0x9abcdef0,
+            &changed_stackerdbs[1],
+            1552509643,
+            1,
+        )
+        .unwrap();
+        assert_eq!(replicas.len(), 0);
+
         // clear stacker DBs
         {
             let tx = db.tx_begin().unwrap();
@@ -2549,12 +2580,12 @@ mod test {
         assert_eq!(neighbor_stackerdbs, []);
 
         let replicas =
-            PeerDB::find_stacker_db_replicas(&db.conn, 0x9abcdef0, &changed_stackerdbs[0], 1)
+            PeerDB::find_stacker_db_replicas(&db.conn, 0x9abcdef0, &changed_stackerdbs[0], 0, 1)
                 .unwrap();
         assert_eq!(replicas.len(), 0);
 
         let replicas =
-            PeerDB::find_stacker_db_replicas(&db.conn, 0x9abcdef0, &changed_stackerdbs[1], 1)
+            PeerDB::find_stacker_db_replicas(&db.conn, 0x9abcdef0, &changed_stackerdbs[1], 0, 1)
                 .unwrap();
         assert_eq!(replicas.len(), 0);
 
@@ -2587,32 +2618,54 @@ mod test {
             assert_eq!(neighbor_stackerdbs, replace_stackerdbs);
 
             let replicas =
-                PeerDB::find_stacker_db_replicas(&db.conn, 0x9abcdee0, &stackerdbs[0], 1).unwrap();
+                PeerDB::find_stacker_db_replicas(&db.conn, 0x9abcdee0, &stackerdbs[0], 0, 1)
+                    .unwrap();
             assert_eq!(replicas.len(), 0);
 
             let replicas =
-                PeerDB::find_stacker_db_replicas(&db.conn, 0x9abcdee0, &stackerdbs[1], 1).unwrap();
+                PeerDB::find_stacker_db_replicas(&db.conn, 0x9abcdee0, &stackerdbs[1], 0, 1)
+                    .unwrap();
             assert_eq!(replicas.len(), 0);
 
-            let replicas =
-                PeerDB::find_stacker_db_replicas(&db.conn, 0x9abcdef0, &changed_stackerdbs[0], 1)
-                    .unwrap();
+            let replicas = PeerDB::find_stacker_db_replicas(
+                &db.conn,
+                0x9abcdef0,
+                &changed_stackerdbs[0],
+                0,
+                1,
+            )
+            .unwrap();
             assert_eq!(replicas.len(), 0);
 
-            let replicas =
-                PeerDB::find_stacker_db_replicas(&db.conn, 0x9abcdef0, &changed_stackerdbs[1], 1)
-                    .unwrap();
+            let replicas = PeerDB::find_stacker_db_replicas(
+                &db.conn,
+                0x9abcdef0,
+                &changed_stackerdbs[1],
+                0,
+                1,
+            )
+            .unwrap();
             assert_eq!(replicas.len(), 0);
 
-            let replicas =
-                PeerDB::find_stacker_db_replicas(&db.conn, 0x9abcdef0, &replace_stackerdbs[0], 1)
-                    .unwrap();
+            let replicas = PeerDB::find_stacker_db_replicas(
+                &db.conn,
+                0x9abcdef0,
+                &replace_stackerdbs[0],
+                0,
+                1,
+            )
+            .unwrap();
             assert_eq!(replicas.len(), 1);
             assert_eq!(replicas[0], neighbor);
 
-            let replicas =
-                PeerDB::find_stacker_db_replicas(&db.conn, 0x9abcdef0, &replace_stackerdbs[1], 1)
-                    .unwrap();
+            let replicas = PeerDB::find_stacker_db_replicas(
+                &db.conn,
+                0x9abcdef0,
+                &replace_stackerdbs[1],
+                0,
+                1,
+            )
+            .unwrap();
             assert_eq!(replicas.len(), 1);
             assert_eq!(replicas[0], neighbor);
         }
@@ -2631,30 +2684,30 @@ mod test {
         }
 
         let replicas =
-            PeerDB::find_stacker_db_replicas(&db.conn, 0x9abcdef0, &stackerdbs[0], 1).unwrap();
+            PeerDB::find_stacker_db_replicas(&db.conn, 0x9abcdef0, &stackerdbs[0], 0, 1).unwrap();
         assert_eq!(replicas.len(), 0);
 
         let replicas =
-            PeerDB::find_stacker_db_replicas(&db.conn, 0x9abcdef0, &stackerdbs[1], 1).unwrap();
+            PeerDB::find_stacker_db_replicas(&db.conn, 0x9abcdef0, &stackerdbs[1], 0, 1).unwrap();
         assert_eq!(replicas.len(), 0);
 
         let replicas =
-            PeerDB::find_stacker_db_replicas(&db.conn, 0x9abcdef0, &changed_stackerdbs[0], 1)
+            PeerDB::find_stacker_db_replicas(&db.conn, 0x9abcdef0, &changed_stackerdbs[0], 0, 1)
                 .unwrap();
         assert_eq!(replicas.len(), 0);
 
         let replicas =
-            PeerDB::find_stacker_db_replicas(&db.conn, 0x9abcdef0, &changed_stackerdbs[1], 1)
+            PeerDB::find_stacker_db_replicas(&db.conn, 0x9abcdef0, &changed_stackerdbs[1], 0, 1)
                 .unwrap();
         assert_eq!(replicas.len(), 0);
 
         let replicas =
-            PeerDB::find_stacker_db_replicas(&db.conn, 0x9abcdef0, &replace_stackerdbs[0], 1)
+            PeerDB::find_stacker_db_replicas(&db.conn, 0x9abcdef0, &replace_stackerdbs[0], 0, 1)
                 .unwrap();
         assert_eq!(replicas.len(), 0);
 
         let replicas =
-            PeerDB::find_stacker_db_replicas(&db.conn, 0x9abcdef0, &replace_stackerdbs[1], 1)
+            PeerDB::find_stacker_db_replicas(&db.conn, 0x9abcdef0, &replace_stackerdbs[1], 0, 1)
                 .unwrap();
         assert_eq!(replicas.len(), 0);
     }
diff --git a/stackslib/src/net/mod.rs b/stackslib/src/net/mod.rs
index 83f2d69a89..f7bfe65fb1 100644
--- a/stackslib/src/net/mod.rs
+++ b/stackslib/src/net/mod.rs
@@ -2145,6 +2145,7 @@ pub mod test {
                     peerdb.conn(),
                     local_peer.network_id,
                     &contract_id,
+                    0,
                     10000000,
                 )
                 .unwrap()
diff --git a/stackslib/src/net/stackerdb/sync.rs b/stackslib/src/net/stackerdb/sync.rs
index a5d875d86e..a3f0d3303a 100644
--- a/stackslib/src/net/stackerdb/sync.rs
+++ b/stackslib/src/net/stackerdb/sync.rs
@@ -93,6 +93,8 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
                 network.peerdb_conn(),
                 network.get_local_peer().network_id,
                 &self.smart_contract_id,
+                get_epoch_time_secs()
+                    .saturating_sub(network.get_connection_opts().max_neighbor_age),
                 self.max_neighbors,
             )?
             .into_iter()
@@ -554,6 +556,8 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
                 network.peerdb_conn(),
                 network.get_local_peer().network_id,
                 &self.smart_contract_id,
+                get_epoch_time_secs()
+                    .saturating_sub(network.get_connection_opts().max_neighbor_age),
                 self.max_neighbors,
             )?
             .into_iter()

From 44b6aa7ffc3eeaf0f49b02457d38c717d1f9123c Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Sun, 21 Jan 2024 23:23:06 -0500
Subject: [PATCH 0408/1166] chore: don't connect to unroutable neighbors if
 private_neighbors is set to false

---
 stackslib/src/net/p2p.rs | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/stackslib/src/net/p2p.rs b/stackslib/src/net/p2p.rs
index 9c4492720b..e030e75676 100644
--- a/stackslib/src/net/p2p.rs
+++ b/stackslib/src/net/p2p.rs
@@ -1509,6 +1509,15 @@ impl PeerNetwork {
             return Err(net_error::AlreadyConnected(event_id, neighbor_key.clone()));
         }
 
+        // unroutable?
+        if !self.connection_opts.private_neighbors && neighbor_key.addrbytes.is_in_private_range() {
+            info!("{:?}: Peer {:?} is in private range and we are configured to drop private neighbors",
+                  &self.local_peer,
+                  &neighbor_key
+            );
+            return Err(net_error::Denied);
+        }
+
         // consider rate-limits on in-bound peers
         let num_outbound = PeerNetwork::count_outbound_conversations(&self.peers);
         if !outbound && (self.peers.len() as u64) - num_outbound >= self.connection_opts.num_clients

From 999b1ccaff3651b4e5b9a62ee66ba363cc2caf03 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Sun, 21 Jan 2024 23:49:22 -0500
Subject: [PATCH 0409/1166] chore: address PR feedback

---
 stackslib/src/chainstate/burn/mod.rs          |  9 ------
 stackslib/src/chainstate/nakamoto/tenure.rs   |  3 +-
 stackslib/src/net/chat.rs                     |  7 ++---
 stackslib/src/net/codec.rs                    | 29 +++++++++++++++----
 stackslib/src/net/inv/mod.rs                  |  3 --
 stackslib/src/net/inv/nakamoto.rs             | 20 ++++++-------
 stackslib/src/net/mod.rs                      |  4 ++-
 stackslib/src/net/neighbors/walk.rs           |  2 --
 .../net/{inv/tests => tests/inv}/epoch2x.rs   |  0
 .../src/net/{inv/tests => tests/inv}/mod.rs   |  0
 .../net/{inv/tests => tests/inv}/nakamoto.rs  |  0
 stackslib/src/net/tests/mod.rs                |  1 +
 12 files changed, 41 insertions(+), 37 deletions(-)
 rename stackslib/src/net/{inv/tests => tests/inv}/epoch2x.rs (100%)
 rename stackslib/src/net/{inv/tests => tests/inv}/mod.rs (100%)
 rename stackslib/src/net/{inv/tests => tests/inv}/nakamoto.rs (100%)

diff --git a/stackslib/src/chainstate/burn/mod.rs b/stackslib/src/chainstate/burn/mod.rs
index 55b917a3b9..4fc937afee 100644
--- a/stackslib/src/chainstate/burn/mod.rs
+++ b/stackslib/src/chainstate/burn/mod.rs
@@ -68,9 +68,6 @@ pub enum Opcodes {
     PreStx = 'p' as u8,
     TransferStx = '$' as u8,
     DelegateStx = '#' as u8,
-    PegIn = '<' as u8,
-    PegOutRequest = '>' as u8,
-    PegOutFulfill = '!' as u8,
 }
 
 // a burnchain block snapshot
@@ -205,17 +202,11 @@ impl Opcodes {
             Opcodes::PreStx => Self::HTTP_PRE_STX,
             Opcodes::TransferStx => Self::HTTP_TRANSFER_STX,
             Opcodes::DelegateStx => Self::HTTP_DELEGATE_STX,
-            Opcodes::PegIn => Self::HTTP_PEG_IN,
-            Opcodes::PegOutRequest => Self::HTTP_PEG_OUT_REQUEST,
-            Opcodes::PegOutFulfill => Self::HTTP_PEG_OUT_FULFILL,
         }
     }
 
     pub fn from_http_str(input: &str) -> Option<Opcodes> {
         let opcode = match input {
-            Self::HTTP_PEG_IN => Opcodes::PegIn,
-            Self::HTTP_PEG_OUT_REQUEST => Opcodes::PegOutRequest,
-            Self::HTTP_PEG_OUT_FULFILL => Opcodes::PegOutFulfill,
             Self::HTTP_BLOCK_COMMIT => Opcodes::LeaderBlockCommit,
             Self::HTTP_KEY_REGISTER => Opcodes::LeaderKeyRegister,
             Self::HTTP_BURN_SUPPORT => Opcodes::UserBurnSupport,
diff --git a/stackslib/src/chainstate/nakamoto/tenure.rs b/stackslib/src/chainstate/nakamoto/tenure.rs
index 4f14ba6447..914a2cf499 100644
--- a/stackslib/src/chainstate/nakamoto/tenure.rs
+++ b/stackslib/src/chainstate/nakamoto/tenure.rs
@@ -510,7 +510,8 @@ impl NakamotoChainState {
     }
 
     /// Get a nakamoto tenure-change by its tenure ID consensus hash.
-    /// Get the highest such record.
+    /// Get the highest such record.  It will be the last-processed BlockFound tenure
+    /// for the given sortition consensus hash.
     pub fn get_highest_nakamoto_tenure_change_by_tenure_id(
         headers_conn: &Connection,
         tenure_id_consensus_hash: &ConsensusHash,
diff --git a/stackslib/src/net/chat.rs b/stackslib/src/net/chat.rs
index 1939d41269..b4b833a5d1 100644
--- a/stackslib/src/net/chat.rs
+++ b/stackslib/src/net/chat.rs
@@ -1712,12 +1712,9 @@ impl ConversationP2P {
             chainstate,
             reward_cycle,
         )?;
-        let bitvec = NakamotoInvData::bools_to_bitvec(&bitvec_bools);
+        let nakamoto_inv = NakamotoInvData::new(&bitvec_bools);
 
-        Ok(StacksMessageType::NakamotoInv(NakamotoInvData {
-            tenures: bitvec,
-            bitlen: u16::try_from(bitvec_bools.len()).expect("reward cycle length exceeds u16"),
-        }))
+        Ok(StacksMessageType::NakamotoInv(nakamoto_inv))
     }
 
     /// Handle an inbound GetNakamotoInv request.
diff --git a/stackslib/src/net/codec.rs b/stackslib/src/net/codec.rs
index 8742924832..2bedb36495 100644
--- a/stackslib/src/net/codec.rs
+++ b/stackslib/src/net/codec.rs
@@ -48,6 +48,10 @@ use crate::core::PEER_VERSION_TESTNET;
 use crate::net::db::LocalPeer;
 use crate::net::{Error as net_error, *};
 
+pub fn bitvec_len(bitlen: u16) -> u16 {
+    (bitlen / 8) + (if bitlen % 8 != 0 { 1 } else { 0 })
+}
+
 impl Preamble {
     /// Make an empty preamble with the given version and fork-set identifier, and payload length.
     pub fn new(
@@ -251,8 +255,8 @@ impl StacksMessageCodec for BlocksInvData {
             ));
         }
 
-        let block_bitvec: Vec<u8> = read_next_exact::<_, u8>(fd, BITVEC_LEN!(bitlen))?;
-        let microblocks_bitvec: Vec<u8> = read_next_exact::<_, u8>(fd, BITVEC_LEN!(bitlen))?;
+        let block_bitvec: Vec<u8> = read_next_exact::<_, u8>(fd, bitvec_len(bitlen).into())?;
+        let microblocks_bitvec: Vec<u8> = read_next_exact::<_, u8>(fd, bitvec_len(bitlen).into())?;
 
         Ok(BlocksInvData {
             bitlen,
@@ -323,7 +327,7 @@ impl StacksMessageCodec for NakamotoInvData {
             ));
         }
 
-        let tenures: Vec<u8> = read_next_exact::<_, u8>(fd, BITVEC_LEN!(bitlen))?;
+        let tenures: Vec<u8> = read_next_exact::<_, u8>(fd, bitvec_len(bitlen).into())?;
         Ok(Self { bitlen, tenures })
     }
 }
@@ -336,8 +340,23 @@ impl NakamotoInvData {
         }
     }
 
+    pub fn new(bits: &[bool]) -> Self {
+        let bvl: u16 = bits
+            .len()
+            .try_into()
+            .expect("FATAL: tried to compress more than u16::MAX bools");
+        Self {
+            bitlen: bvl,
+            tenures: Self::bools_to_bitvec(bits),
+        }
+    }
+
     pub fn bools_to_bitvec(bits: &[bool]) -> Vec<u8> {
-        let mut bitvec = vec![0u8; (bits.len() / 8) + (if bits.len() % 8 != 0 { 1 } else { 0 })];
+        let bvl: u16 = bits
+            .len()
+            .try_into()
+            .expect("FATAL: tried to compress more than u16::MAX bools");
+        let mut bitvec = vec![0u8; bitvec_len(bvl) as usize];
         for (i, bit) in bits.iter().enumerate() {
             if *bit {
                 bitvec[i / 8] |= 1u8 << (i % 8);
@@ -405,7 +424,7 @@ impl StacksMessageCodec for PoxInvData {
             ));
         }
 
-        let pox_bitvec: Vec<u8> = read_next_exact::<_, u8>(fd, BITVEC_LEN!(bitlen))?;
+        let pox_bitvec: Vec<u8> = read_next_exact::<_, u8>(fd, bitvec_len(bitlen).into())?;
         Ok(PoxInvData {
             bitlen: bitlen,
             pox_bitvec: pox_bitvec,
diff --git a/stackslib/src/net/inv/mod.rs b/stackslib/src/net/inv/mod.rs
index 5a80e682a8..3757c87483 100644
--- a/stackslib/src/net/inv/mod.rs
+++ b/stackslib/src/net/inv/mod.rs
@@ -17,9 +17,6 @@
 pub mod epoch2x;
 pub mod nakamoto;
 
-#[cfg(test)]
-pub mod tests;
-
 // Stacks 2.x inventory state machine
 pub use inv2x::{INV_REWARD_CYCLES, INV_SYNC_INTERVAL};
 
diff --git a/stackslib/src/net/inv/nakamoto.rs b/stackslib/src/net/inv/nakamoto.rs
index eecefbc041..1db73c722a 100644
--- a/stackslib/src/net/inv/nakamoto.rs
+++ b/stackslib/src/net/inv/nakamoto.rs
@@ -104,16 +104,14 @@ impl InvGenerator {
         chainstate: &StacksChainState,
         tenure_id_consensus_hash: &ConsensusHash,
     ) -> Result<Option<InvTenureInfo>, NetError> {
-        let cur_tenure_info_opt =
-            if let Some(info_opt) = self.processed_tenures.get(&tenure_id_consensus_hash) {
-                Ok((*info_opt).clone())
-            } else {
-                let loaded_info_opt = InvTenureInfo::load(chainstate, &tenure_id_consensus_hash)?;
-                self.processed_tenures
-                    .insert(tenure_id_consensus_hash.clone(), loaded_info_opt.clone());
-                Ok(loaded_info_opt)
-            };
-        cur_tenure_info_opt
+        if let Some(info_opt) = self.processed_tenures.get(&tenure_id_consensus_hash) {
+            return Ok((*info_opt).clone());
+        };
+        // not cached so go load it
+        let loaded_info_opt = InvTenureInfo::load(chainstate, &tenure_id_consensus_hash)?;
+        self.processed_tenures
+            .insert(tenure_id_consensus_hash.clone(), loaded_info_opt.clone());
+        Ok(loaded_info_opt)
     }
 
     /// Generate an block inventory bit vector for a reward cycle.
@@ -174,7 +172,7 @@ impl InvGenerator {
                     .insert(cur_consensus_hash.clone(), loaded_info);
                 self.sortitions
                     .get(&cur_consensus_hash)
-                    .expect("infallbile: just inserted this data".into())
+                    .expect("infallible: just inserted this data".into())
             };
             let parent_sortition_consensus_hash = cur_sortition_info.parent_consensus_hash.clone();
 
diff --git a/stackslib/src/net/mod.rs b/stackslib/src/net/mod.rs
index eb2a41077e..3b6f8b783e 100644
--- a/stackslib/src/net/mod.rs
+++ b/stackslib/src/net/mod.rs
@@ -869,7 +869,9 @@ pub struct GetNakamotoInvData {
 }
 
 /// A bit vector that describes Nakamoto tenure availability.  Sent in reply for GetBlocksInv for
-/// Nakamoto block data.
+/// Nakamoto block data.  The ith bit in `tenures` will be set if (1) there is a sortition in the
+/// ith burnchain block in the requested reward cycle (note that 0 <= i < 2100 in production), and
+/// (2) the remote node not only has the tenure blocks, but has processed them.
 #[derive(Debug, Clone, PartialEq)]
 pub struct NakamotoInvData {
     /// Number of bits this tenure bit vector has (not to exceed the reward cycle length).
diff --git a/stackslib/src/net/neighbors/walk.rs b/stackslib/src/net/neighbors/walk.rs
index 5cbda3c774..f0b081f385 100644
--- a/stackslib/src/net/neighbors/walk.rs
+++ b/stackslib/src/net/neighbors/walk.rs
@@ -644,8 +644,6 @@ impl<DB: NeighborWalkDB, NC: NeighborComms> NeighborWalk<DB, NC> {
         }
     }
 
-    /// Determine if a peer is routable from us
-
     /// Handle a HandshakeAcceptData.
     /// Update the PeerDB information from the handshake data, as well as `self.cur_neighbor`, if
     /// this neighbor was routable.  If it's not routable (i.e. we walked to an inbound neighbor),
diff --git a/stackslib/src/net/inv/tests/epoch2x.rs b/stackslib/src/net/tests/inv/epoch2x.rs
similarity index 100%
rename from stackslib/src/net/inv/tests/epoch2x.rs
rename to stackslib/src/net/tests/inv/epoch2x.rs
diff --git a/stackslib/src/net/inv/tests/mod.rs b/stackslib/src/net/tests/inv/mod.rs
similarity index 100%
rename from stackslib/src/net/inv/tests/mod.rs
rename to stackslib/src/net/tests/inv/mod.rs
diff --git a/stackslib/src/net/inv/tests/nakamoto.rs b/stackslib/src/net/tests/inv/nakamoto.rs
similarity index 100%
rename from stackslib/src/net/inv/tests/nakamoto.rs
rename to stackslib/src/net/tests/inv/nakamoto.rs
diff --git a/stackslib/src/net/tests/mod.rs b/stackslib/src/net/tests/mod.rs
index 71aff78ed0..9f9d6d07ab 100644
--- a/stackslib/src/net/tests/mod.rs
+++ b/stackslib/src/net/tests/mod.rs
@@ -15,4 +15,5 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 pub mod httpcore;
+pub mod inv;
 pub mod neighbors;

From e5383ff3f3d45bf0c53f01328c78d0e9e4cce31f Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Mon, 22 Jan 2024 00:02:13 -0500
Subject: [PATCH 0410/1166] chore: cargo fmt

---
 stackslib/src/net/p2p.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/stackslib/src/net/p2p.rs b/stackslib/src/net/p2p.rs
index fec2f6989f..7e1f9ad9d1 100644
--- a/stackslib/src/net/p2p.rs
+++ b/stackslib/src/net/p2p.rs
@@ -354,7 +354,7 @@ pub struct PeerNetwork {
     /// Nakamoto-specific cache for sortition and tenure data, for the purposes of generating
     /// tenure inventories
     pub nakamoto_inv_generator: InvGenerator,
-    
+
     /// Thread handle for the async block proposal endpoint.
     block_proposal_thread: Option<JoinHandle<()>>,
 }
@@ -505,7 +505,7 @@ impl PeerNetwork {
             fault_last_disconnect: 0,
 
             nakamoto_inv_generator: InvGenerator::new(),
-            
+
             block_proposal_thread: None,
         };
 

From 6b86eaa7ac342f2a5184601ea9802f01d50768ea Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Mon, 22 Jan 2024 00:44:06 -0500
Subject: [PATCH 0411/1166] chore: fix build issue

---
 stackslib/src/net/chat.rs | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/stackslib/src/net/chat.rs b/stackslib/src/net/chat.rs
index 87a81baf8d..5138c0a7ba 100644
--- a/stackslib/src/net/chat.rs
+++ b/stackslib/src/net/chat.rs
@@ -5516,14 +5516,14 @@ mod test {
             test_debug!("send handshake");
             convo_send_recv(&mut convo_1, vec![&mut rh_1], &mut convo_2);
             let unhandled_2 = convo_2
-                .chat(&mut net_2, &sortdb_2, &mut chainstate_2)
+                .chat(&mut net_2, &sortdb_2, &mut chainstate_2, false)
                 .unwrap();
 
             // convo_1 has a handshakeaccept
             test_debug!("send handshake-accept");
             convo_send_recv(&mut convo_2, vec![&mut rh_1], &mut convo_1);
             let unhandled_1 = convo_1
-                .chat(&mut net_1, &sortdb_1, &mut chainstate_1)
+                .chat(&mut net_1, &sortdb_1, &mut chainstate_1, false)
                 .unwrap();
 
             let reply_1 = rh_1.recv(0).unwrap();
@@ -5598,14 +5598,14 @@ mod test {
             test_debug!("send getnakamotoinv");
             convo_send_recv(&mut convo_1, vec![&mut rh_1], &mut convo_2);
             let unhandled_2 = convo_2
-                .chat(&mut net_2, &sortdb_2, &mut chainstate_2)
+                .chat(&mut net_2, &sortdb_2, &mut chainstate_2, false)
                 .unwrap();
 
             // convo_1 gets back a nakamotoinv message
             test_debug!("send nakamotoinv");
             convo_send_recv(&mut convo_2, vec![&mut rh_1], &mut convo_1);
             let unhandled_1 = convo_1
-                .chat(&mut net_1, &sortdb_1, &mut chainstate_1)
+                .chat(&mut net_1, &sortdb_1, &mut chainstate_1, false)
                 .unwrap();
 
             let reply_1 = rh_1.recv(0).unwrap();
@@ -5648,14 +5648,14 @@ mod test {
             test_debug!("send getnakamotoinv (diverged)");
             convo_send_recv(&mut convo_1, vec![&mut rh_1], &mut convo_2);
             let unhandled_2 = convo_2
-                .chat(&mut net_2, &sortdb_2, &mut chainstate_2)
+                .chat(&mut net_2, &sortdb_2, &mut chainstate_2, false)
                 .unwrap();
 
             // convo_1 gets back a nack message
             test_debug!("send nack (diverged)");
             convo_send_recv(&mut convo_2, vec![&mut rh_1], &mut convo_1);
             let unhandled_1 = convo_1
-                .chat(&mut net_1, &sortdb_1, &mut chainstate_1)
+                .chat(&mut net_1, &sortdb_1, &mut chainstate_1, false)
                 .unwrap();
 
             let reply_1 = rh_1.recv(0).unwrap();

From c32ad7a40740dd2f9d988d8aeae9effd8e8d10ec Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Mon, 22 Jan 2024 10:25:43 -0500
Subject: [PATCH 0412/1166] chore: debug, not info

---
 stackslib/src/net/p2p.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stackslib/src/net/p2p.rs b/stackslib/src/net/p2p.rs
index e030e75676..780203504c 100644
--- a/stackslib/src/net/p2p.rs
+++ b/stackslib/src/net/p2p.rs
@@ -1511,7 +1511,7 @@ impl PeerNetwork {
 
         // unroutable?
         if !self.connection_opts.private_neighbors && neighbor_key.addrbytes.is_in_private_range() {
-            info!("{:?}: Peer {:?} is in private range and we are configured to drop private neighbors",
+            debug!("{:?}: Peer {:?} is in private range and we are configured to drop private neighbors",
                   &self.local_peer,
                   &neighbor_key
             );

From 806de84f571dff773be4cf387278d0df7fec63cc Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Mon, 22 Jan 2024 13:55:30 -0500
Subject: [PATCH 0413/1166] fix: repair connection network handle flush logic,
 and add a helper to stacks-inspect to decode a network message

---
 stackslib/src/main.rs           | 23 ++++++++++++++++++++++-
 stackslib/src/net/connection.rs |  6 +++++-
 2 files changed, 27 insertions(+), 2 deletions(-)

diff --git a/stackslib/src/main.rs b/stackslib/src/main.rs
index 03d2d2edfa..191c353fb8 100644
--- a/stackslib/src/main.rs
+++ b/stackslib/src/main.rs
@@ -68,13 +68,14 @@ use blockstack_lib::cost_estimates::UnitEstimator;
 use blockstack_lib::net::db::LocalPeer;
 use blockstack_lib::net::p2p::PeerNetwork;
 use blockstack_lib::net::relay::Relayer;
+use blockstack_lib::net::StacksMessage;
 use blockstack_lib::util_lib::db::sqlite_open;
 use blockstack_lib::util_lib::strings::UrlString;
 use libstackerdb::StackerDBChunkData;
 use rusqlite::types::ToSql;
 use rusqlite::{Connection, OpenFlags};
 use serde_json::Value;
-use stacks_common::codec::StacksMessageCodec;
+use stacks_common::codec::{read_next, StacksMessageCodec};
 use stacks_common::types::chainstate::{
     BlockHeaderHash, BurnchainHeaderHash, PoxId, StacksAddress, StacksBlockId,
 };
@@ -232,6 +233,26 @@ fn main() {
         process::exit(0);
     }
 
+    if argv[1] == "decode-net-message" {
+        let data: String = argv[2].clone();
+        let buf = if data == "-" {
+            let mut buffer = vec![];
+            io::stdin().read_to_end(&mut buffer).unwrap();
+            buffer
+        } else {
+            let data: serde_json::Value = serde_json::from_str(data.as_str()).unwrap();
+            let data_array = data.as_array().unwrap();
+            let mut buf = vec![];
+            for elem in data_array {
+                buf.push(elem.as_u64().unwrap() as u8);
+            }
+            buf
+        };
+        let msg: StacksMessage = read_next(&mut &buf[..]).unwrap();
+        println!("{:#?}", &msg);
+        process::exit(0);
+    }
+
     if argv[1] == "get-tenure" {
         if argv.len() < 4 {
             eprintln!("Usage: {} get-tenure CHAIN_STATE_DIR BLOCK_HASH", argv[0]);
diff --git a/stackslib/src/net/connection.rs b/stackslib/src/net/connection.rs
index 973c5f9e57..15f0e36a65 100644
--- a/stackslib/src/net/connection.rs
+++ b/stackslib/src/net/connection.rs
@@ -249,7 +249,11 @@ impl<P: ProtocolFamily> NetworkReplyHandle<P> {
             }
         };
         self.request_pipe_write = fd_opt;
-        Ok(ret)
+        if drop_on_success {
+            Ok(self.request_pipe_write.is_none())
+        } else {
+            Ok(ret)
+        }
     }
 
     /// Try to flush the inner pipe writer.  If we succeed, drop the inner pipe.

From 210c746f6f91e74626a8422edfe79ba7fe20a8fd Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Mon, 22 Jan 2024 17:17:24 -0500
Subject: [PATCH 0414/1166] fix: update local peer to indicate that we support
 stackerdb

---
 testnet/stacks-node/src/neon_node.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/testnet/stacks-node/src/neon_node.rs b/testnet/stacks-node/src/neon_node.rs
index 56f777076e..e2672109da 100644
--- a/testnet/stacks-node/src/neon_node.rs
+++ b/testnet/stacks-node/src/neon_node.rs
@@ -4801,12 +4801,12 @@ impl StacksNode {
             tx.commit().unwrap();
         }
 
-        // update services to indicate we can support mempool sync
+        // update services to indicate we can support mempool sync and stackerdb
         {
             let mut tx = peerdb.tx_begin().unwrap();
             PeerDB::set_local_services(
                 &mut tx,
-                (ServiceFlags::RPC as u16) | (ServiceFlags::RELAY as u16),
+                (ServiceFlags::RPC as u16) | (ServiceFlags::RELAY as u16) | (ServiceFlags::STACKERDB as u16),
             )
             .unwrap();
             tx.commit().unwrap();

From 69bdbe8358935f49580bdb6b34946f76914ff6b1 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Mon, 22 Jan 2024 17:18:41 -0500
Subject: [PATCH 0415/1166] chore: cargo fmt

---
 testnet/stacks-node/src/neon_node.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/testnet/stacks-node/src/neon_node.rs b/testnet/stacks-node/src/neon_node.rs
index e2672109da..3263371d4f 100644
--- a/testnet/stacks-node/src/neon_node.rs
+++ b/testnet/stacks-node/src/neon_node.rs
@@ -4806,7 +4806,9 @@ impl StacksNode {
             let mut tx = peerdb.tx_begin().unwrap();
             PeerDB::set_local_services(
                 &mut tx,
-                (ServiceFlags::RPC as u16) | (ServiceFlags::RELAY as u16) | (ServiceFlags::STACKERDB as u16),
+                (ServiceFlags::RPC as u16)
+                    | (ServiceFlags::RELAY as u16)
+                    | (ServiceFlags::STACKERDB as u16),
             )
             .unwrap();
             tx.commit().unwrap();

From 882ec500203e9981da0a75531705ecab99945b97 Mon Sep 17 00:00:00 2001
From: Arun <arun@arun.blog>
Date: Mon, 22 Jan 2024 16:41:56 -0800
Subject: [PATCH 0416/1166] Quote envvar to match documentation

---
 .github/workflows/docs-pr.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/docs-pr.yml b/.github/workflows/docs-pr.yml
index 29e49a9236..7543bdd750 100644
--- a/.github/workflows/docs-pr.yml
+++ b/.github/workflows/docs-pr.yml
@@ -66,12 +66,12 @@ jobs:
           git add src/_data/boot-contracts-reference.json
           if $(git diff --staged --quiet --exit-code); then
             echo "No reference.json changes, stopping"
-            echo "open_pr=0" >> $GITHUB_OUTPUT
+            echo "open_pr=0" >> "$GITHUB_OUTPUT"
           else
             git remote add robot https://github.com/$ROBOT_OWNER/$ROBOT_REPO
             git commit -m "auto: update Clarity references JSONs from stacks-core@${GITHUB_SHA}"
             git push robot $ROBOT_BRANCH
-            echo "open_pr=1" >> $GITHUB_OUTPUT
+            echo "open_pr=1" >> "$GITHUB_OUTPUT"
           fi
 
       - name: Open PR

From 0875d1022f66859e89b6858e178deea7de8884b3 Mon Sep 17 00:00:00 2001
From: ASuciuX <asuciu@hiro.so>
Date: Tue, 23 Jan 2024 03:17:43 +0200
Subject: [PATCH 0417/1166] feat: mutants docs - time related outcomes

---
 docs/ci-release.md | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/docs/ci-release.md b/docs/ci-release.md
index d6a3d9bc35..3dc245cb24 100644
--- a/docs/ci-release.md
+++ b/docs/ci-release.md
@@ -236,6 +236,14 @@ Since mutation testing is directly correlated to the written tests, there are sl
 
 Once all the jobs have finished testing mutants, the last job collects all the tested mutations from the previous jobs, combines them and outputs them to the `Summary` section of the workflow, at the bottom of the page. There, you can find all mutants on categories, with links to the function they tested, and a short description on how to fix the issue. The PR should only be approved/merged after all the mutants tested are in the `Caught` category.
 
+### Time required to run the workflow based on mutants outcome and packages' size
+
+- Small packages typically completed in under 30 minutes, aided by the use of shards.
+- Large packages like stackslib and stacks-node initially required about 20-25 minutes for build and test processes.
+    - Each "missed" and "caught" mutant took approximately 15 minutes. Using shards, this meant about 50-55 minutes for processing around 32 mutants (10-16 functions modified). Every additional 8 mutants added another 15 minutes to the runtime.
+    - "Unviable" mutants, which are functions lacking a Default implementation for their returned struct type, took less than a minute each.
+    - "Timeout" mutants typically required more time. However, these should be marked to be skipped (by adding a skip flag to their header) since they indicate functions unable to proceed in their test workflow with mutated values, as opposed to the original implementations.
+
 File:
 
 - [PR Differences Mutants](../.github/workflows/pr-differences-mutants.yml)

From 3c6578529150ff8e15619f816399b341cb144969 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Mon, 22 Jan 2024 22:13:04 -0500
Subject: [PATCH 0418/1166] chore: get stackerdb tests passing again; fix a
 couple bugs in the state machine that arise when there are no replicas (i.e.
 have the state machine error out instead of spin)

---
 stackslib/src/net/mod.rs                  |  3 +-
 stackslib/src/net/stackerdb/mod.rs        |  7 +-
 stackslib/src/net/stackerdb/sync.rs       | 93 ++++++++++++++---------
 stackslib/src/net/stackerdb/tests/sync.rs | 20 +++--
 testnet/stacks-node/src/neon_node.rs      | 13 +---
 5 files changed, 74 insertions(+), 62 deletions(-)

diff --git a/stackslib/src/net/mod.rs b/stackslib/src/net/mod.rs
index 83f2d69a89..c47ef274bf 100644
--- a/stackslib/src/net/mod.rs
+++ b/stackslib/src/net/mod.rs
@@ -2159,8 +2159,7 @@ pub mod test {
                     &db_config,
                     PeerNetworkComms::new(),
                     stacker_dbs,
-                )
-                .expect(&format!("FATAL: could not open '{}'", stackerdb_path));
+                );
 
                 stacker_db_syncs.insert(contract_id.clone(), (db_config.clone(), stacker_db_sync));
             }
diff --git a/stackslib/src/net/stackerdb/mod.rs b/stackslib/src/net/stackerdb/mod.rs
index 8520cec1f0..7164eb6bae 100644
--- a/stackslib/src/net/stackerdb/mod.rs
+++ b/stackslib/src/net/stackerdb/mod.rs
@@ -320,12 +320,7 @@ impl PeerNetwork {
                             "Failed to run StackerDB state machine for {}: {:?}",
                             &sc, &e
                         );
-                        if let Err(e) = stacker_db_sync.reset(Some(self), config) {
-                            info!(
-                                "Failed to reset StackerDB state machine for {}: {:?}",
-                                &sc, &e
-                            );
-                        }
+                        stacker_db_sync.reset(Some(self), config);
                     }
                 }
             } else {
diff --git a/stackslib/src/net/stackerdb/sync.rs b/stackslib/src/net/stackerdb/sync.rs
index a5d875d86e..6a1a0d5ebb 100644
--- a/stackslib/src/net/stackerdb/sync.rs
+++ b/stackslib/src/net/stackerdb/sync.rs
@@ -48,7 +48,7 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
         config: &StackerDBConfig,
         comms: NC,
         stackerdbs: StackerDBs,
-    ) -> Result<StackerDBSync<NC>, net_error> {
+    ) -> StackerDBSync<NC> {
         let mut dbsync = StackerDBSync {
             state: StackerDBSyncState::ConnectBegin,
             smart_contract_id: smart_contract,
@@ -73,8 +73,8 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
             last_run_ts: 0,
             need_resync: false,
         };
-        dbsync.reset(None, config)?;
-        Ok(dbsync)
+        dbsync.reset(None, config);
+        dbsync
     }
 
     /// Calculate the new set of replicas to contact.
@@ -116,7 +116,8 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
         &mut self,
         network: Option<&PeerNetwork>,
         config: &StackerDBConfig,
-    ) -> Result<StackerDBSyncResult, net_error> {
+    ) -> StackerDBSyncResult {
+        debug!("Reset with config {:?}", config);
         let mut chunks = vec![];
         let downloaded_chunks = mem::replace(&mut self.downloaded_chunks, HashMap::new());
         for (_, mut data) in downloaded_chunks.into_iter() {
@@ -135,7 +136,12 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
         // keep all connected replicas, and replenish from config hints and the DB as needed
         let connected_replicas = mem::replace(&mut self.connected_replicas, HashSet::new());
         let next_connected_replicas =
-            self.find_new_replicas(connected_replicas, network, config)?;
+            if let Ok(new_replicas) = self.find_new_replicas(connected_replicas, network, config) {
+                new_replicas
+            } else {
+                self.replicas.clone()
+            };
+
         self.replicas = next_connected_replicas;
 
         self.chunk_fetch_priorities.clear();
@@ -154,8 +160,9 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
         self.write_freq = config.write_freq;
 
         self.need_resync = false;
+        self.last_run_ts = get_epoch_time_secs();
 
-        Ok(result)
+        result
     }
 
     /// Get the set of connection IDs in use
@@ -201,7 +208,7 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
         for (i, local_version) in local_slot_versions.iter().enumerate() {
             let write_ts = local_write_timestamps[i];
             if write_ts + self.write_freq > now {
-                test_debug!(
+                debug!(
                     "{:?}: Chunk {} was written too frequently ({} + {} >= {}), so will not fetch chunk",
                     network.get_local_peer(),
                     i,
@@ -275,7 +282,7 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
         schedule.sort_by(|item_1, item_2| item_1.1.len().cmp(&item_2.1.len()));
         schedule.reverse();
 
-        test_debug!(
+        debug!(
             "{:?}: Will request up to {} chunks for {}",
             network.get_local_peer(),
             &schedule.len(),
@@ -367,7 +374,7 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
             .collect();
 
         schedule.sort_by(|item_1, item_2| item_1.1.len().cmp(&item_2.1.len()));
-        test_debug!(
+        debug!(
             "{:?}: Will push up to {} chunks for {}",
             network.get_local_peer(),
             &schedule.len(),
@@ -443,7 +450,7 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
             for (old_slot_id, old_version) in old_inv.slot_versions.iter().enumerate() {
                 if *old_version < new_inv.slot_versions[old_slot_id] {
                     // remote peer indicated that it has a newer version of this chunk.
-                    test_debug!(
+                    debug!(
                         "{:?}: peer {:?} has a newer version of slot {} ({} < {})",
                         _network.get_local_peer(),
                         &naddr,
@@ -529,7 +536,7 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
         }
 
         for (naddr, chunks_req) in to_send.into_iter() {
-            test_debug!("{:?}: send_getchunksinv_to_inbound_neighbors: Send StackerDBGetChunkInv to inbound {:?}", network.get_local_peer(), &naddr);
+            debug!("{:?}: send_getchunksinv_to_inbound_neighbors: Send StackerDBGetChunkInv to inbound {:?}", network.get_local_peer(), &naddr);
             if let Err(_e) = self.comms.neighbor_send(network, &naddr, chunks_req) {
                 info!(
                     "{:?}: Failed to send StackerDBGetChunkInv to inbound {:?}: {:?}",
@@ -561,7 +568,7 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
             .collect();
             self.replicas = replicas;
         }
-        test_debug!(
+        debug!(
             "{:?}: connect_begin: establish StackerDB sessions to {} neighbors",
             network.get_local_peer(),
             self.replicas.len()
@@ -574,7 +581,7 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
         let naddrs = mem::replace(&mut self.replicas, HashSet::new());
         for naddr in naddrs.into_iter() {
             if self.comms.has_neighbor_session(network, &naddr) {
-                test_debug!(
+                debug!(
                     "{:?}: connect_begin: already connected to StackerDB peer {:?}",
                     network.get_local_peer(),
                     &naddr
@@ -583,7 +590,7 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
                 continue;
             }
 
-            test_debug!(
+            debug!(
                 "{:?}: connect_begin: Send Handshake to StackerDB peer {:?}",
                 network.get_local_peer(),
                 &naddr
@@ -591,7 +598,7 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
             match self.comms.neighbor_session_begin(network, &naddr) {
                 Ok(true) => {
                     // connected!
-                    test_debug!(
+                    debug!(
                         "{:?}: connect_begin: connected to StackerDB peer {:?}",
                         network.get_local_peer(),
                         &naddr
@@ -662,7 +669,7 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
                 continue;
             }
 
-            test_debug!(
+            debug!(
                 "{:?}: connect_try_finish: Received StackerDBHandshakeAccept from {:?} for {:?}",
                 network.get_local_peer(),
                 &naddr,
@@ -680,7 +687,7 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
 
         if self.connected_replicas.len() == 0 {
             // no one to talk to
-            test_debug!(
+            debug!(
                 "{:?}: connect_try_finish: no valid replicas",
                 network.get_local_peer()
             );
@@ -698,13 +705,13 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
     pub fn getchunksinv_begin(&mut self, network: &mut PeerNetwork) {
         let naddrs = mem::replace(&mut self.connected_replicas, HashSet::new());
         let mut already_sent = vec![];
-        test_debug!(
+        debug!(
             "{:?}: getchunksinv_begin: Send StackerDBGetChunksInv to {} replicas",
             network.get_local_peer(),
             naddrs.len()
         );
         for naddr in naddrs.into_iter() {
-            test_debug!(
+            debug!(
                 "{:?}: getchunksinv_begin: Send StackerDBGetChunksInv to {:?}",
                 network.get_local_peer(),
                 &naddr
@@ -756,7 +763,7 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
                     continue;
                 }
             };
-            test_debug!(
+            debug!(
                 "{:?}: getchunksinv_try_finish: Received StackerDBChunkInv from {:?}",
                 network.get_local_peer(),
                 &naddr
@@ -781,20 +788,22 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
     /// Ask each prioritized replica for some chunks we need.
     /// Return Ok(true) if we processed all requested chunks
     /// Return Ok(false) if there are still some requests to make
-    pub fn getchunks_begin(&mut self, network: &mut PeerNetwork) -> bool {
+    pub fn getchunks_begin(&mut self, network: &mut PeerNetwork) -> Result<bool, net_error> {
         if self.chunk_fetch_priorities.len() == 0 {
             // done
-            return true;
+            return Ok(true);
         }
 
         let mut cur_priority = self.next_chunk_fetch_priority % self.chunk_fetch_priorities.len();
 
-        test_debug!(
+        debug!(
             "{:?}: getchunks_begin: Issue up to {} StackerDBGetChunk requests",
             &network.get_local_peer(),
             self.request_capacity
         );
 
+        let mut requested = 0;
+
         // fill up our comms with $capacity requests
         for _i in 0..self.request_capacity {
             if self.comms.count_inflight() >= self.request_capacity {
@@ -814,7 +823,7 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
                 continue;
             };
 
-            test_debug!(
+            debug!(
                 "{:?}: getchunks_begin: Send StackerDBGetChunk(db={},id={},ver={}) to {}",
                 &network.get_local_peer(),
                 &self.smart_contract_id,
@@ -840,15 +849,21 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
                 continue;
             }
 
+            requested += 1;
+
             // don't ask this neighbor again
             self.chunk_fetch_priorities[cur_priority].1.remove(idx);
 
             // next-prioritized chunk
             cur_priority = (cur_priority + 1) % self.chunk_fetch_priorities.len();
         }
+        if requested == 0 {
+            return Err(net_error::PeerNotConnected);
+        }
+
         self.next_chunk_fetch_priority = cur_priority;
 
-        self.chunk_fetch_priorities.len() == 0
+        Ok(self.chunk_fetch_priorities.len() == 0)
     }
 
     /// Collect chunk replies from neighbors
@@ -890,7 +905,7 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
             }
 
             // update bookkeeping
-            test_debug!(
+            debug!(
                 "{:?}: getchunks_try_finish: Received StackerDBChunk from {:?}",
                 network.get_local_peer(),
                 &naddr
@@ -916,12 +931,14 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
 
         let mut cur_priority = self.next_chunk_push_priority % self.chunk_push_priorities.len();
 
-        test_debug!(
+        debug!(
             "{:?}: pushchunks_begin: Send up to {} StackerDBChunk pushes",
             &network.get_local_peer(),
             self.chunk_push_priorities.len()
         );
 
+        let mut pushed = 0;
+
         // fill up our comms with $capacity requests
         for _i in 0..self.request_capacity {
             if self.comms.count_inflight() >= self.request_capacity {
@@ -938,7 +955,7 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
             let (idx, selected_neighbor) = if let Some(x) = selected_neighbor_opt {
                 x
             } else {
-                test_debug!("{:?}: pushchunks_begin: no available neighbor to send StackerDBChunk(db={},id={},ver={}) to",
+                debug!("{:?}: pushchunks_begin: no available neighbor to send StackerDBChunk(db={},id={},ver={}) to",
                     &network.get_local_peer(),
                     &self.smart_contract_id,
                     chunk_push.chunk_data.slot_id,
@@ -947,7 +964,7 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
                 continue;
             };
 
-            test_debug!(
+            debug!(
                 "{:?}: pushchunks_begin: Send StackerDBChunk(db={},id={},ver={}) to {}",
                 &network.get_local_peer(),
                 &self.smart_contract_id,
@@ -975,6 +992,8 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
                 continue;
             }
 
+            pushed += 1;
+
             // record what we just sent
             self.chunk_push_receipts
                 .insert(selected_neighbor.clone(), (slot_id, slot_version));
@@ -985,6 +1004,9 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
             // next-prioritized chunk
             cur_priority = (cur_priority + 1) % self.chunk_push_priorities.len();
         }
+        if pushed == 0 {
+            return Err(net_error::PeerNotConnected);
+        }
         self.next_chunk_push_priority = cur_priority;
         Ok(self.chunk_push_priorities.len() == 0)
     }
@@ -1022,7 +1044,7 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
             }
 
             // update bookkeeping
-            test_debug!(
+            debug!(
                 "{:?}: pushchunks_try_finish: Received StackerDBChunkInv from {:?}",
                 network.get_local_peer(),
                 &naddr
@@ -1060,7 +1082,7 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
 
     /// Forcibly wake up the state machine if it is throttled
     pub fn wakeup(&mut self) {
-        test_debug!("wake up StackerDB sync for {}", &self.smart_contract_id);
+        debug!("wake up StackerDB sync for {}", &self.smart_contract_id);
         self.last_run_ts = 0;
     }
 
@@ -1074,7 +1096,7 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
     ) -> Result<Option<StackerDBSyncResult>, net_error> {
         // throttle to write_freq
         if self.last_run_ts + config.write_freq > get_epoch_time_secs() {
-            test_debug!(
+            debug!(
                 "{:?}: stacker DB sync for {} is throttled until {}",
                 network.get_local_peer(),
                 &self.smart_contract_id,
@@ -1084,7 +1106,7 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
         }
 
         loop {
-            test_debug!(
+            debug!(
                 "{:?}: stacker DB sync state is {:?}",
                 network.get_local_peer(),
                 &self.state
@@ -1126,7 +1148,7 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
                         continue;
                     }
 
-                    let requests_finished = self.getchunks_begin(network);
+                    let requests_finished = self.getchunks_begin(network)?;
                     let inflight_finished = self.getchunks_try_finish(network, config)?;
                     let done = requests_finished && inflight_finished;
                     if done {
@@ -1155,9 +1177,8 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
                     }
                 }
                 StackerDBSyncState::Finished => {
-                    let result = self.reset(Some(network), config)?;
+                    let result = self.reset(Some(network), config);
                     self.state = StackerDBSyncState::ConnectBegin;
-                    self.last_run_ts = get_epoch_time_secs();
                     return Ok(Some(result));
                 }
             };
diff --git a/stackslib/src/net/stackerdb/tests/sync.rs b/stackslib/src/net/stackerdb/tests/sync.rs
index 92187820c0..7e1c5f15da 100644
--- a/stackslib/src/net/stackerdb/tests/sync.rs
+++ b/stackslib/src/net/stackerdb/tests/sync.rs
@@ -149,8 +149,7 @@ fn setup_stackerdb(peer: &mut TestPeer, idx: usize, fill: bool, num_slots: usize
         .unwrap()
         .get_mut(contract_id)
         .unwrap()
-        .reset(None, stackerdb_config)
-        .unwrap();
+        .reset(None, stackerdb_config);
 }
 
 /// Load up the entire stacker DB, including its metadata
@@ -228,8 +227,11 @@ fn test_stackerdb_replica_2_neighbors_1_chunk() {
         let mut i = 0;
         loop {
             // run peer network state-machines
-            let res_1 = peer_1.step();
-            let res_2 = peer_2.step();
+            peer_1.network.stacker_db_configs = peer_1_db_configs.clone();
+            peer_2.network.stacker_db_configs = peer_2_db_configs.clone();
+
+            let res_1 = peer_1.step_with_ibd(false);
+            let res_2 = peer_2.step_with_ibd(false);
 
             if let Ok(mut res) = res_1 {
                 Relayer::process_stacker_db_chunks(
@@ -347,8 +349,11 @@ fn inner_test_stackerdb_replica_2_neighbors_10_chunks(push_only: bool, base_port
         let mut i = 0;
         loop {
             // run peer network state-machines
-            let res_1 = peer_1.step();
-            let res_2 = peer_2.step();
+            peer_1.network.stacker_db_configs = peer_1_db_configs.clone();
+            peer_2.network.stacker_db_configs = peer_2_db_configs.clone();
+
+            let res_1 = peer_1.step_with_ibd(false);
+            let res_2 = peer_2.step_with_ibd(false);
 
             if let Ok(mut res) = res_1 {
                 Relayer::process_stacker_db_chunks(
@@ -485,7 +490,8 @@ fn inner_test_stackerdb_10_replicas_10_neighbors_line_10_chunks(push_only: bool,
         loop {
             // run peer network state-machines
             for i in 0..num_peers {
-                let res = peers[i].step();
+                peers[i].network.stacker_db_configs = peer_db_configs[i].clone();
+                let res = peers[i].step_with_ibd(false);
                 if let Ok(mut res) = res {
                     let rc_consensus_hash =
                         peers[i].network.get_chain_view().rc_consensus_hash.clone();
diff --git a/testnet/stacks-node/src/neon_node.rs b/testnet/stacks-node/src/neon_node.rs
index 3263371d4f..c44fe9448b 100644
--- a/testnet/stacks-node/src/neon_node.rs
+++ b/testnet/stacks-node/src/neon_node.rs
@@ -4895,21 +4895,12 @@ impl StacksNode {
                     }
                 }
             }
-            let stacker_db_sync = match StackerDBSync::new(
+            let stacker_db_sync = StackerDBSync::new(
                 stackerdb_contract_id.clone(),
                 &stacker_db_config,
                 PeerNetworkComms::new(),
                 stackerdbs,
-            ) {
-                Ok(s) => s,
-                Err(e) => {
-                    warn!(
-                        "Failed to instantiate StackerDB sync machine for {}: {:?}",
-                        stackerdb_contract_id, &e
-                    );
-                    continue;
-                }
-            };
+            );
 
             stackerdb_machines.insert(
                 stackerdb_contract_id.clone(),

From cfb1b6d8528e943448998fd3b938d580f7b8474c Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Mon, 22 Jan 2024 23:10:20 -0500
Subject: [PATCH 0419/1166] chore: throttle stackerdb sync to be at least one
 second

---
 stackslib/src/net/stackerdb/sync.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stackslib/src/net/stackerdb/sync.rs b/stackslib/src/net/stackerdb/sync.rs
index 6a1a0d5ebb..8be2146bff 100644
--- a/stackslib/src/net/stackerdb/sync.rs
+++ b/stackslib/src/net/stackerdb/sync.rs
@@ -1095,7 +1095,7 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
         config: &StackerDBConfig,
     ) -> Result<Option<StackerDBSyncResult>, net_error> {
         // throttle to write_freq
-        if self.last_run_ts + config.write_freq > get_epoch_time_secs() {
+        if self.last_run_ts + config.write_freq.max(1) > get_epoch_time_secs() {
             debug!(
                 "{:?}: stacker DB sync for {} is throttled until {}",
                 network.get_local_peer(),

From 2684ce5adb6692592a5b19963987441905acf759 Mon Sep 17 00:00:00 2001
From: Matthew Little <zone117x@gmail.com>
Date: Tue, 23 Jan 2024 16:17:02 +0100
Subject: [PATCH 0420/1166] fix: `delegate-stack-extend` arg order

---
 stackslib/src/chainstate/stacks/boot/pox-4.clar | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index 777473676e..63e9f7272a 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -1158,8 +1158,8 @@
 (define-public (delegate-stack-extend
                     (stacker principal)
                     (pox-addr { version: (buff 1), hashbytes: (buff 32) })
-                    (signer-key (buff 33))
-                    (extend-count uint))
+                    (extend-count uint)
+                    (signer-key (buff 33)))
     (let ((stacker-info (stx-account stacker))
           ;; to extend, there must already be an entry in the stacking-state
           (stacker-state (unwrap! (get-stacker-info stacker) (err ERR_STACK_EXTEND_NOT_LOCKED)))

From fcab3979b7ca71e85bff3eb5d3ed26af6929a608 Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Sat, 13 Jan 2024 17:07:45 -0500
Subject: [PATCH 0421/1166] added delegate-stack-extend test

---
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 134 ++++++++++++++++++
 1 file changed, 134 insertions(+)

diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index ac20ffca5f..cb7e438b7c 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -1701,6 +1701,140 @@ fn delegate_stack_stx_signer_key() {
     assert_eq!(state_signer_key.to_string(), signer_key_val.to_string());
 }
 
+#[test]
+fn delegate_stack_stx_extend_signer_key() {
+    let lock_period = 2;
+    let (burnchain, mut peer, keys, latest_block, block_height, mut coinbase_nonce) =
+        prepare_pox4_test(function_name!(), None);
+
+    let mut stacker_nonce = 0;
+    let stacker_key = &keys[0];
+    let delegate_nonce = 0;
+    let delegate_key = &keys[1];
+    let delegate_principal = PrincipalData::from(key_to_stacks_addr(delegate_key));
+
+    // (define-public (delegate-stx (amount-ustx uint)
+    //                          (delegate-to principal)
+    //                          (until-burn-ht (optional uint))
+    //                          (pox-addr (optional { version: (buff 1), hashbytes: (buff 32) })))
+    let pox_addr = make_pox_addr(
+        AddressHashMode::SerializeP2WSH,
+        key_to_stacks_addr(delegate_key).bytes,
+    );
+    let signer_key_val = Value::buff_from(vec![
+        0x03, 0xa0, 0xf9, 0x81, 0x8e, 0xa8, 0xc1, 0x4a, 0x82, 0x7b, 0xb1, 0x44, 0xae, 0xc9, 0xcf,
+        0xba, 0xeb, 0xa2, 0x25, 0xaf, 0x22, 0xbe, 0x18, 0xed, 0x78, 0xa2, 0xf2, 0x98, 0x10, 0x6f,
+        0x4e, 0x28, 0x1b,
+    ])
+    .unwrap();
+
+    let txs = vec![
+        make_pox_4_contract_call(
+            stacker_key,
+            stacker_nonce,
+            "delegate-stx",
+            vec![
+                Value::UInt(100),
+                delegate_principal.clone().into(),
+                Value::none(),
+                Value::Optional(OptionalData {
+                    data: Some(Box::new(pox_addr.clone())),
+                }),
+            ],
+        ),
+        make_pox_4_contract_call(
+            delegate_key,
+            delegate_nonce,
+            "delegate-stack-stx",
+            vec![
+                PrincipalData::from(key_to_stacks_addr(stacker_key)).into(),
+                Value::UInt(100),
+                pox_addr.clone(),
+                Value::UInt(block_height as u128),
+                Value::UInt(lock_period),
+                signer_key_val.clone(),
+            ],
+        ),
+    ];
+    // (define-public (delegate-stack-stx (stacker principal)
+    //                                (amount-ustx uint)
+    //                                (pox-addr { version: (buff 1), hashbytes: (buff 32) })
+    //                                (start-burn-ht uint)
+    //                                (lock-period uint)
+    //                                (signer-key (buff 33)))
+
+    let latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
+    let delegation_state = get_delegation_state_pox_4(
+        &mut peer,
+        &latest_block,
+        &key_to_stacks_addr(stacker_key).to_account_principal(),
+    )
+    .expect("No delegation state, delegate-stx failed")
+    .expect_tuple();
+
+    let stacking_state = get_stacking_state_pox_4(
+        &mut peer,
+        &latest_block,
+        &key_to_stacks_addr(stacker_key).to_account_principal(),
+    )
+    .expect("No stacking state, stack-stx failed")
+    .expect_tuple();
+
+    let state_signer_key = stacking_state.get("signer-key").unwrap();
+    assert_eq!(state_signer_key.to_string(), signer_key_val.to_string());
+
+    // (define-public (delegate-stack-extend (stacker principal)
+    //     (extend-count uint)
+    //     (pox-addr { version: (buff 1), hashbytes: (buff 32) })
+    //     (signer-key (buff 33)))
+
+    stacker_nonce += 1;
+
+    let mut latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
+    let stacking_state = get_stacking_state_pox_4(
+        &mut peer,
+        &latest_block,
+        &key_to_stacks_addr(stacker_key).to_account_principal(),
+    )
+    .expect("No stacking state, stack-stx failed")
+    .expect_tuple();
+
+    let state_signer_key = stacking_state.get("signer-key").unwrap();
+    assert_eq!(state_signer_key.to_string(), signer_key_val.to_string());
+
+    // now stack-extend with a new signer-key
+    let signer_key_new_val = Value::buff_from(vec![
+        0x02, 0xb6, 0x19, 0x6d, 0xe8, 0x8b, 0xce, 0xe7, 0x93, 0xfa, 0x9a, 0x8a, 0x85, 0x96, 0x9b,
+        0x64, 0x7f, 0x84, 0xc9, 0x0e, 0x9d, 0x13, 0xf9, 0xc8, 0xb8, 0xce, 0x42, 0x6c, 0xc8, 0x1a,
+        0x59, 0x98, 0x3c,
+    ])
+    .unwrap();
+
+    let update_txs = vec![make_pox_4_contract_call(
+        delegate_key,
+        stacker_nonce,
+        "delegate-stack-extend",
+        vec![PrincipalData::from(key_to_stacks_addr(stacker_key)).into(), pox_addr.clone(), signer_key_new_val.clone(), Value::UInt(1)],
+    )];
+
+    latest_block = peer.tenure_with_txs(&update_txs, &mut coinbase_nonce);
+    let new_stacking_state = get_stacking_state_pox_4(
+        &mut peer,
+        &latest_block,
+        &key_to_stacks_addr(stacker_key).to_account_principal(),
+    )
+    .unwrap()
+    .expect_tuple();
+
+    let state_signer_key_new = new_stacking_state.get("signer-key").unwrap();
+    assert_eq!(
+        state_signer_key_new.to_string(),
+        signer_key_new_val.to_string()
+    );
+
+
+}
+
 pub fn get_stacking_state_pox_4(
     peer: &mut TestPeer,
     tip: &StacksBlockId,

From 3c417c9517585691d0880661a13371ef3a9290b5 Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Sun, 14 Jan 2024 10:03:53 -0500
Subject: [PATCH 0422/1166] added stack-increase test

---
 stackslib/src/chainstate/stacks/boot/mod.rs   | 18 ++++
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 95 ++++++++++++++++++-
 2 files changed, 112 insertions(+), 1 deletion(-)

diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 663c4cf1d3..4ebdd8f59f 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -1821,6 +1821,24 @@ pub mod test {
         make_tx(key, nonce, 0, payload)
     }
 
+    pub fn make_pox_4_increase_stx(
+        key: &StacksPrivateKey,
+        nonce: u64,
+        amount: u128,
+    ) -> StacksTransaction {
+        let payload = TransactionPayload::new_contract_call(
+            boot_code_test_addr(),
+            POX_4_NAME,
+            "stack-increase",
+            vec![
+                Value::UInt(amount),
+            ],
+        )
+        .unwrap();
+
+        make_tx(key, nonce, 0, payload)
+    }
+
     pub fn make_pox_4_revoke_delegate_stx(key: &StacksPrivateKey, nonce: u64) -> StacksTransaction {
         let payload = TransactionPayload::new_contract_call(
             boot_code_test_addr(),
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index cb7e438b7c..40ddec61b9 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -1526,6 +1526,8 @@ fn stack_stx_signer_key_no_reuse() {
     let second_stacker_transactions =
         get_last_block_sender_transactions(&observer, second_stacker_address);
 
+        println!("second_stacker_transactions: {:?}", second_stacker_transactions[0].result);
+
     assert_eq!(second_stacker_transactions.len(), 1);
     assert_eq!(
         second_stacker_transactions
@@ -1703,7 +1705,7 @@ fn delegate_stack_stx_signer_key() {
 
 #[test]
 fn delegate_stack_stx_extend_signer_key() {
-    let lock_period = 2;
+    let lock_period: u128 = 2;
     let (burnchain, mut peer, keys, latest_block, block_height, mut coinbase_nonce) =
         prepare_pox4_test(function_name!(), None);
 
@@ -1835,6 +1837,94 @@ fn delegate_stack_stx_extend_signer_key() {
 
 }
 
+#[test]
+fn stack_increase() {
+    let lock_period = 2;
+    let observer = TestEventObserver::new();
+    let (burnchain, mut peer, keys, latest_block, block_height, mut coinbase_nonce) =
+        prepare_pox4_test(function_name!(), Some(&observer));
+
+    let mut stacker_nonce = 0;
+    let stacker_key = &keys[0];
+    let stacker_address = key_to_stacks_addr(stacker_key);
+    let min_ustx = get_stacking_minimum(&mut peer, &latest_block);
+    println!("min_ustx: {}", min_ustx);
+
+    // (define-public (stack-stx (amount-ustx uint)
+    //                       (pox-addr (tuple (version (buff 1)) (hashbytes (buff 32))))
+    //                       (start-burn-ht uint)
+    //                       (lock-period uint)
+    //                       (signer-key (buff 33)))
+    let pox_addr = make_pox_addr(
+        AddressHashMode::SerializeP2WSH,
+        key_to_stacks_addr(stacker_key).bytes,
+    );
+    let signer_key_val = Value::buff_from(vec![
+        0x03, 0xa0, 0xf9, 0x81, 0x8e, 0xa8, 0xc1, 0x4a, 0x82, 0x7b, 0xb1, 0x44, 0xae, 0xc9, 0xcf,
+        0xba, 0xeb, 0xa2, 0x25, 0xaf, 0x22, 0xbe, 0x18, 0xed, 0x78, 0xa2, 0xf2, 0x98, 0x10, 0x6f,
+        0x4e, 0x28, 0x1b,
+    ])
+    .unwrap();
+    let first_txs = vec![make_pox_4_contract_call(
+        stacker_key,
+        stacker_nonce,
+        "stack-stx",
+        vec![
+            Value::UInt(min_ustx),
+            pox_addr,
+            Value::UInt(block_height as u128),
+            Value::UInt(2),
+            signer_key_val.clone(),
+        ],
+    )];
+
+    let latest_block_1 = peer.tenure_with_txs(&first_txs, &mut coinbase_nonce);
+    let stacking_state = get_stacking_state_pox_4(
+        &mut peer,
+        &latest_block_1,
+        &key_to_stacks_addr(stacker_key).to_account_principal(),
+    )
+    .expect("No stacking state, stack-stx failed")
+    .expect_tuple();
+
+    let state_signer_key = stacking_state.get("signer-key").unwrap();
+    assert_eq!(state_signer_key.to_string(), signer_key_val.to_string());
+
+    stacker_nonce += 1;
+
+    // (define-public (stack-increase (increse-by uint)
+    let stack_increase = make_pox_4_increase_stx(
+        stacker_key,
+        stacker_nonce,
+        min_ustx
+    );
+    let latest_block_2 = peer.tenure_with_txs(&vec![stack_increase], &mut coinbase_nonce);
+    let stacker_transactions =
+        get_last_block_sender_transactions(&observer, stacker_address);
+    
+    let stacker_locked_amount: u128 = match &stacker_transactions[0].result {
+        Value::Response(ResponseData { committed: _, ref data }) => {
+            match **data {
+                Value::Tuple(TupleData { type_signature: _, ref data_map }) => {
+                    match data_map.get("total-locked") {
+                        Some(&Value::UInt(total_locked)) => {
+                            total_locked // Return the u128 value
+                        }
+                        _ => panic!("'total-locked' key not found or not a UInt"),
+                    }
+                }
+                _ => panic!("Response data is not a tuple"),
+            }
+        }
+        _ => panic!("Result is not a response"),
+    };
+    
+    assert_eq!(stacker_locked_amount, min_ustx * 2);  
+
+}
+
+
+
 pub fn get_stacking_state_pox_4(
     peer: &mut TestPeer,
     tip: &StacksBlockId,
@@ -1952,3 +2042,6 @@ pub fn get_last_block_sender_transactions(
         })
         .collect::<Vec<_>>()
 }
+
+// TODO
+// Helper that gets amount locked for a given address
\ No newline at end of file

From 461e7a501ba535399334088aeb60ce7b0b453689 Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Sun, 14 Jan 2024 10:10:51 -0500
Subject: [PATCH 0423/1166] remove TODO comment

---
 stackslib/src/chainstate/stacks/boot/pox_4_tests.rs | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 40ddec61b9..ea64c0555a 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -2041,7 +2041,4 @@ pub fn get_last_block_sender_transactions(
             false
         })
         .collect::<Vec<_>>()
-}
-
-// TODO
-// Helper that gets amount locked for a given address
\ No newline at end of file
+}
\ No newline at end of file

From bda299eb30059e39fdca8a94f700b56875f7e5e0 Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Sun, 14 Jan 2024 17:23:38 -0500
Subject: [PATCH 0424/1166] delegate-stack-increase wip

---
 stackslib/src/chainstate/stacks/boot/mod.rs   |  46 ++++++++
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 106 ++++++++++++++++++
 2 files changed, 152 insertions(+)

diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 4ebdd8f59f..0b96168fee 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -1821,6 +1821,52 @@ pub mod test {
         make_tx(key, nonce, 0, payload)
     }
 
+    pub fn make_pox_4_delegate_increase(
+        key: &StacksPrivateKey,
+        nonce: u64,
+        stacker: &PrincipalData,
+        pox_addr: Value,
+        amount: u128,
+    ) -> StacksTransaction {
+        //let addr_tuple = Value::Tuple(pox_addr.as_clarity_tuple().unwrap());
+        let payload = TransactionPayload::new_contract_call(
+            boot_code_test_addr(),
+            POX_4_NAME,
+            "delegate-stack-increase",
+            vec![
+                Value::Principal(stacker.clone()),
+                pox_addr,
+                Value::UInt(amount),
+            ],
+        )
+        .unwrap();
+
+        make_tx(key, nonce, 0, payload)
+    }
+
+
+    pub fn make_pox_4_aggregation_commit_indexed(
+        key: &StacksPrivateKey,
+        nonce: u64,
+        amount: u128,
+        delegate_to: PrincipalData,
+        until_burn_ht: Option<u128>,
+        pox_addr: PoxAddress,
+    ) -> StacksTransaction {
+        let addr_tuple = Value::Tuple(pox_addr.as_clarity_tuple().unwrap());
+        let payload = TransactionPayload::new_contract_call(
+            boot_code_test_addr(),
+            POX_4_NAME,
+            "stack-aggregation-commit-indexed",
+            vec![
+                addr_tuple,
+                Value::UInt(amount),
+            ],
+        ).unwrap();
+
+        make_tx(key, nonce, 0, payload)
+    }
+
     pub fn make_pox_4_increase_stx(
         key: &StacksPrivateKey,
         nonce: u64,
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index ea64c0555a..55ea0292b6 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -1923,7 +1923,113 @@ fn stack_increase() {
 
 }
 
+#[test]
+fn delegate_stack_increase() {
+    let lock_period: u128 = 2;
+    let observer = TestEventObserver::new();
+    let (burnchain, mut peer, keys, latest_block, block_height, mut coinbase_nonce) =
+        prepare_pox4_test(function_name!(), Some(&observer));
+
+    let mut stacker_nonce = 0;
+    let stacker_key = &keys[0];
+    let stacker_address = PrincipalData::from(
+        key_to_stacks_addr(stacker_key).to_account_principal(),
+    );
+    let delegate_nonce = 0;
+    let delegate_key = &keys[1];
+    let delegate_address = PrincipalData::from(
+        key_to_stacks_addr(delegate_key).to_account_principal(),
+    );
+    let min_ustx = get_stacking_minimum(&mut peer, &latest_block);
+
+    // (define-public (delegate-stx (amount-ustx uint)
+    //                          (delegate-to principal)
+    //                          (until-burn-ht (optional uint))
+    //                          (pox-addr (optional { version: (buff 1), hashbytes: (buff 32) })))
+    let pox_addr = make_pox_addr(
+        AddressHashMode::SerializeP2WSH,
+        key_to_stacks_addr(delegate_key).bytes,
+    );
+
+    let signer_key_val = Value::buff_from(vec![
+        0x03, 0xa0, 0xf9, 0x81, 0x8e, 0xa8, 0xc1, 0x4a, 0x82, 0x7b, 0xb1, 0x44, 0xae, 0xc9, 0xcf,
+        0xba, 0xeb, 0xa2, 0x25, 0xaf, 0x22, 0xbe, 0x18, 0xed, 0x78, 0xa2, 0xf2, 0x98, 0x10, 0x6f,
+        0x4e, 0x28, 0x1b,
+    ])
+    .unwrap();
+
+    let txs = vec![
+        make_pox_4_contract_call(
+            stacker_key,
+            stacker_nonce,
+            "delegate-stx",
+            vec![
+                Value::UInt(min_ustx*2),
+                Value::Principal(delegate_address.clone()),
+                Value::none(),
+                Value::Optional(OptionalData {
+                    data: Some(Box::new(pox_addr.clone())),
+                }),
+            ],
+        ),
+        make_pox_4_contract_call(
+            delegate_key,
+            delegate_nonce,
+            "delegate-stack-stx",
+            vec![
+                Value::Principal(stacker_address.clone()),
+                Value::UInt(min_ustx),
+                pox_addr.clone(),
+                Value::UInt(block_height as u128),
+                Value::UInt(lock_period),
+                signer_key_val.clone(),
+            ],
+        ),
+    ];
+    // (define-public (delegate-stack-stx (stacker principal)
+    //                                (amount-ustx uint)
+    //                                (pox-addr { version: (buff 1), hashbytes: (buff 32) })
+    //                                (start-burn-ht uint)
+    //                                (lock-period uint)
+    //                                (signer-key (buff 33)))
+
+    // (define-public (delegate-stack-extend (stacker principal)
+    //     (extend-count uint)
+    //     (pox-addr { version: (buff 1), hashbytes: (buff 32) })
+    //     (signer-key (buff 33)))
 
+    let latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
+
+    stacker_nonce += 1;
+
+    let delegate_increase = make_pox_4_delegate_increase(
+        delegate_key,
+        stacker_nonce,
+        &stacker_address,
+        pox_addr,
+        min_ustx,
+    );
+
+    let txs = vec![delegate_increase];
+
+    let latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
+
+    let delegate_transactions =
+            get_last_block_sender_transactions(&observer, delegate_address.into());
+
+    println!("delegate_transactions: {:?}", delegate_transactions);
+
+    let stacker_transactions =
+            get_last_block_sender_transactions(&observer, stacker_address.into());
+    
+    println!("stacker_transactions: {:?}", stacker_transactions);
+
+    // let state_signer_key_new = new_stacking_state.get("signer-key").unwrap();
+    // assert_eq!(
+    //     state_signer_key_new.to_string(),
+    //     signer_key_new_val.to_string()
+    // );
+}
 
 pub fn get_stacking_state_pox_4(
     peer: &mut TestPeer,

From fcdd2877f2df7c1f60ec36340c088c71c9650227 Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Mon, 15 Jan 2024 09:56:03 -0500
Subject: [PATCH 0425/1166] added delegate_increase test

---
 stackslib/src/chainstate/stacks/boot/mod.rs   |  13 +--
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 102 +++++++++++-------
 2 files changed, 68 insertions(+), 47 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 0b96168fee..e38932c428 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -1844,7 +1844,6 @@ pub mod test {
         make_tx(key, nonce, 0, payload)
     }
 
-
     pub fn make_pox_4_aggregation_commit_indexed(
         key: &StacksPrivateKey,
         nonce: u64,
@@ -1858,11 +1857,9 @@ pub mod test {
             boot_code_test_addr(),
             POX_4_NAME,
             "stack-aggregation-commit-indexed",
-            vec![
-                addr_tuple,
-                Value::UInt(amount),
-            ],
-        ).unwrap();
+            vec![addr_tuple, Value::UInt(amount)],
+        )
+        .unwrap();
 
         make_tx(key, nonce, 0, payload)
     }
@@ -1876,9 +1873,7 @@ pub mod test {
             boot_code_test_addr(),
             POX_4_NAME,
             "stack-increase",
-            vec![
-                Value::UInt(amount),
-            ],
+            vec![Value::UInt(amount)],
         )
         .unwrap();
 
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 55ea0292b6..a60f95681f 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -1526,7 +1526,10 @@ fn stack_stx_signer_key_no_reuse() {
     let second_stacker_transactions =
         get_last_block_sender_transactions(&observer, second_stacker_address);
 
-        println!("second_stacker_transactions: {:?}", second_stacker_transactions[0].result);
+    println!(
+        "second_stacker_transactions: {:?}",
+        second_stacker_transactions[0].result
+    );
 
     assert_eq!(second_stacker_transactions.len(), 1);
     assert_eq!(
@@ -1816,7 +1819,12 @@ fn delegate_stack_stx_extend_signer_key() {
         delegate_key,
         stacker_nonce,
         "delegate-stack-extend",
-        vec![PrincipalData::from(key_to_stacks_addr(stacker_key)).into(), pox_addr.clone(), signer_key_new_val.clone(), Value::UInt(1)],
+        vec![
+            PrincipalData::from(key_to_stacks_addr(stacker_key)).into(),
+            pox_addr.clone(),
+            signer_key_new_val.clone(),
+            Value::UInt(1),
+        ],
     )];
 
     latest_block = peer.tenure_with_txs(&update_txs, &mut coinbase_nonce);
@@ -1833,8 +1841,6 @@ fn delegate_stack_stx_extend_signer_key() {
         state_signer_key_new.to_string(),
         signer_key_new_val.to_string()
     );
-
-
 }
 
 #[test]
@@ -1893,19 +1899,20 @@ fn stack_increase() {
     stacker_nonce += 1;
 
     // (define-public (stack-increase (increse-by uint)
-    let stack_increase = make_pox_4_increase_stx(
-        stacker_key,
-        stacker_nonce,
-        min_ustx
-    );
+    let stack_increase = make_pox_4_increase_stx(stacker_key, stacker_nonce, min_ustx);
     let latest_block_2 = peer.tenure_with_txs(&vec![stack_increase], &mut coinbase_nonce);
-    let stacker_transactions =
-        get_last_block_sender_transactions(&observer, stacker_address);
-    
+    let stacker_transactions = get_last_block_sender_transactions(&observer, stacker_address);
+
     let stacker_locked_amount: u128 = match &stacker_transactions[0].result {
-        Value::Response(ResponseData { committed: _, ref data }) => {
+        Value::Response(ResponseData {
+            committed: _,
+            ref data,
+        }) => {
             match **data {
-                Value::Tuple(TupleData { type_signature: _, ref data_map }) => {
+                Value::Tuple(TupleData {
+                    type_signature: _,
+                    ref data_map,
+                }) => {
                     match data_map.get("total-locked") {
                         Some(&Value::UInt(total_locked)) => {
                             total_locked // Return the u128 value
@@ -1918,9 +1925,8 @@ fn stack_increase() {
         }
         _ => panic!("Result is not a response"),
     };
-    
-    assert_eq!(stacker_locked_amount, min_ustx * 2);  
 
+    assert_eq!(stacker_locked_amount, min_ustx * 2);
 }
 
 #[test]
@@ -1932,14 +1938,12 @@ fn delegate_stack_increase() {
 
     let mut stacker_nonce = 0;
     let stacker_key = &keys[0];
-    let stacker_address = PrincipalData::from(
-        key_to_stacks_addr(stacker_key).to_account_principal(),
-    );
-    let delegate_nonce = 0;
+    let stacker_address =
+        PrincipalData::from(key_to_stacks_addr(stacker_key).to_account_principal());
+    let mut delegate_nonce = 0;
     let delegate_key = &keys[1];
-    let delegate_address = PrincipalData::from(
-        key_to_stacks_addr(delegate_key).to_account_principal(),
-    );
+    let delegate_address =
+        PrincipalData::from(key_to_stacks_addr(delegate_key).to_account_principal());
     let min_ustx = get_stacking_minimum(&mut peer, &latest_block);
 
     // (define-public (delegate-stx (amount-ustx uint)
@@ -1964,7 +1968,7 @@ fn delegate_stack_increase() {
             stacker_nonce,
             "delegate-stx",
             vec![
-                Value::UInt(min_ustx*2),
+                Value::UInt(2 * min_ustx),
                 Value::Principal(delegate_address.clone()),
                 Value::none(),
                 Value::Optional(OptionalData {
@@ -2001,12 +2005,13 @@ fn delegate_stack_increase() {
     let latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
 
     stacker_nonce += 1;
+    delegate_nonce += 1;
 
     let delegate_increase = make_pox_4_delegate_increase(
         delegate_key,
-        stacker_nonce,
+        delegate_nonce,
         &stacker_address,
-        pox_addr,
+        pox_addr.clone(),
         min_ustx,
     );
 
@@ -2015,20 +2020,41 @@ fn delegate_stack_increase() {
     let latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
 
     let delegate_transactions =
-            get_last_block_sender_transactions(&observer, delegate_address.into());
+        get_last_block_sender_transactions(&observer, delegate_address.into());
 
-    println!("delegate_transactions: {:?}", delegate_transactions);
+    // println!("delegate_transactions: {:?}", delegate_transactions);
 
-    let stacker_transactions =
-            get_last_block_sender_transactions(&observer, stacker_address.into());
-    
-    println!("stacker_transactions: {:?}", stacker_transactions);
+    // let stacker_transactions =
+    //         get_last_block_sender_transactions(&observer, stacker_address.into());
 
-    // let state_signer_key_new = new_stacking_state.get("signer-key").unwrap();
-    // assert_eq!(
-    //     state_signer_key_new.to_string(),
-    //     signer_key_new_val.to_string()
-    // );
+    // println!("stacker_transactions: {:?}", stacker_transactions);
+
+    let stacker_locked_amount: u128 = match &delegate_transactions[0].result {
+        Value::Response(ResponseData {
+            committed: _,
+            ref data,
+        }) => {
+            match **data {
+                Value::Tuple(TupleData {
+                    type_signature: _,
+                    ref data_map,
+                }) => {
+                    match data_map.get("total-locked") {
+                        Some(&Value::UInt(total_locked)) => {
+                            total_locked // Return the u128 value
+                        }
+                        _ => panic!("'total-locked' key not found or not a UInt"),
+                    }
+                }
+                _ => panic!("Response data is not a tuple"),
+            }
+        }
+        _ => panic!("Result is not a response"),
+    };
+
+    println!("stacker_locked_amount: {:?}", stacker_locked_amount);
+
+    assert_eq!(stacker_locked_amount, min_ustx * 2);
 }
 
 pub fn get_stacking_state_pox_4(
@@ -2147,4 +2173,4 @@ pub fn get_last_block_sender_transactions(
             false
         })
         .collect::<Vec<_>>()
-}
\ No newline at end of file
+}

From bd2dc8d49d904cb8b98669a9a91221bac22008e3 Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Mon, 15 Jan 2024 17:31:14 -0500
Subject: [PATCH 0426/1166] three tests complete

---
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 19 +++++--------------
 1 file changed, 5 insertions(+), 14 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index a60f95681f..19ca71c6ec 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -14,7 +14,8 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::collections::{HashMap, HashSet, VecDeque};
+use std::any::Any;
+use std::collections::{BTreeMap, HashMap, HashSet, VecDeque};
 use std::convert::{TryFrom, TryInto};
 
 use clarity::vm::clarity::ClarityConnection;
@@ -1854,7 +1855,6 @@ fn stack_increase() {
     let stacker_key = &keys[0];
     let stacker_address = key_to_stacks_addr(stacker_key);
     let min_ustx = get_stacking_minimum(&mut peer, &latest_block);
-    println!("min_ustx: {}", min_ustx);
 
     // (define-public (stack-stx (amount-ustx uint)
     //                       (pox-addr (tuple (version (buff 1)) (hashbytes (buff 32))))
@@ -1884,10 +1884,10 @@ fn stack_increase() {
         ],
     )];
 
-    let latest_block_1 = peer.tenure_with_txs(&first_txs, &mut coinbase_nonce);
+    let latest_block = peer.tenure_with_txs(&first_txs, &mut coinbase_nonce);
     let stacking_state = get_stacking_state_pox_4(
         &mut peer,
-        &latest_block_1,
+        &latest_block,
         &key_to_stacks_addr(stacker_key).to_account_principal(),
     )
     .expect("No stacking state, stack-stx failed")
@@ -1900,7 +1900,7 @@ fn stack_increase() {
 
     // (define-public (stack-increase (increse-by uint)
     let stack_increase = make_pox_4_increase_stx(stacker_key, stacker_nonce, min_ustx);
-    let latest_block_2 = peer.tenure_with_txs(&vec![stack_increase], &mut coinbase_nonce);
+    let latest_block = peer.tenure_with_txs(&vec![stack_increase], &mut coinbase_nonce);
     let stacker_transactions = get_last_block_sender_transactions(&observer, stacker_address);
 
     let stacker_locked_amount: u128 = match &stacker_transactions[0].result {
@@ -2022,13 +2022,6 @@ fn delegate_stack_increase() {
     let delegate_transactions =
         get_last_block_sender_transactions(&observer, delegate_address.into());
 
-    // println!("delegate_transactions: {:?}", delegate_transactions);
-
-    // let stacker_transactions =
-    //         get_last_block_sender_transactions(&observer, stacker_address.into());
-
-    // println!("stacker_transactions: {:?}", stacker_transactions);
-
     let stacker_locked_amount: u128 = match &delegate_transactions[0].result {
         Value::Response(ResponseData {
             committed: _,
@@ -2052,8 +2045,6 @@ fn delegate_stack_increase() {
         _ => panic!("Result is not a response"),
     };
 
-    println!("stacker_locked_amount: {:?}", stacker_locked_amount);
-
     assert_eq!(stacker_locked_amount, min_ustx * 2);
 }
 

From 1978c0992c53ff8408cfff7f8d2648d2cb38f161 Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Tue, 16 Jan 2024 21:44:38 -0500
Subject: [PATCH 0427/1166] updated delegated_stack_stx_signer_key

---
 stackslib/src/chainstate/stacks/boot/mod.rs   | 29 ++++++-
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 81 +++++++------------
 2 files changed, 56 insertions(+), 54 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index e38932c428..938e49edff 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -1821,6 +1821,33 @@ pub mod test {
         make_tx(key, nonce, 0, payload)
     }
 
+    pub fn make_pox_4_delegate_stack_stx(
+        key: &StacksPrivateKey,
+        nonce: u64,
+        stacker: PrincipalData,
+        amount: u128,
+        pox_addr: PoxAddress,
+        start_burn_height: u128,
+        lock_period: u128,
+        signer_key: StacksPublicKey,
+    ) -> StacksTransaction {
+        let payload: TransactionPayload = TransactionPayload::new_contract_call(
+            boot_code_test_addr(),
+            POX_4_NAME,
+            "delegate-stack-stx",
+            vec![
+                Value::Principal(stacker.clone()),
+                Value::UInt(amount),
+                Value::Tuple(pox_addr.as_clarity_tuple().unwrap()),
+                Value::UInt(start_burn_height),
+                Value::UInt(lock_period),
+                Value::buff_from(signer_key.to_bytes_compressed()).unwrap(),
+            ],
+        ).unwrap();
+
+        make_tx(key, nonce, 0, payload)
+    }
+
     pub fn make_pox_4_delegate_increase(
         key: &StacksPrivateKey,
         nonce: u64,
@@ -1864,7 +1891,7 @@ pub mod test {
         make_tx(key, nonce, 0, payload)
     }
 
-    pub fn make_pox_4_increase_stx(
+    pub fn make_pox_4_stack_increase(
         key: &StacksPrivateKey,
         nonce: u64,
         amount: u128,
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 19ca71c6ec..08d06b1090 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -1527,11 +1527,6 @@ fn stack_stx_signer_key_no_reuse() {
     let second_stacker_transactions =
         get_last_block_sender_transactions(&observer, second_stacker_address);
 
-    println!(
-        "second_stacker_transactions: {:?}",
-        second_stacker_transactions[0].result
-    );
-
     assert_eq!(second_stacker_transactions.len(), 1);
     assert_eq!(
         second_stacker_transactions
@@ -1635,58 +1630,37 @@ fn delegate_stack_stx_signer_key() {
     let delegate_nonce = 0;
     let delegate_key = &keys[1];
     let delegate_principal = PrincipalData::from(key_to_stacks_addr(delegate_key));
+    let signer_private_key = &keys[2];
+    let signer_public_key = StacksPublicKey::from_private(signer_private_key);
 
-    // (define-public (delegate-stx (amount-ustx uint)
-    //                          (delegate-to principal)
-    //                          (until-burn-ht (optional uint))
-    //                          (pox-addr (optional { version: (buff 1), hashbytes: (buff 32) })))
-    let pox_addr = make_pox_addr(
-        AddressHashMode::SerializeP2WSH,
+    let pox_addr = PoxAddress::from_legacy(
+        AddressHashMode::SerializeP2PKH,
         key_to_stacks_addr(delegate_key).bytes,
     );
-    let signer_key_val = Value::buff_from(vec![
-        0x03, 0xa0, 0xf9, 0x81, 0x8e, 0xa8, 0xc1, 0x4a, 0x82, 0x7b, 0xb1, 0x44, 0xae, 0xc9, 0xcf,
-        0xba, 0xeb, 0xa2, 0x25, 0xaf, 0x22, 0xbe, 0x18, 0xed, 0x78, 0xa2, 0xf2, 0x98, 0x10, 0x6f,
-        0x4e, 0x28, 0x1b,
-    ])
-    .unwrap();
 
-    let txs = vec![
-        make_pox_4_contract_call(
-            stacker_key,
-            stacker_nonce,
-            "delegate-stx",
-            vec![
-                Value::UInt(100),
-                delegate_principal.clone().into(),
-                Value::none(),
-                Value::Optional(OptionalData {
-                    data: Some(Box::new(pox_addr.clone())),
-                }),
-            ],
-        ),
-        make_pox_4_contract_call(
-            delegate_key,
-            delegate_nonce,
-            "delegate-stack-stx",
-            vec![
-                PrincipalData::from(key_to_stacks_addr(stacker_key)).into(),
-                Value::UInt(100),
-                pox_addr,
-                Value::UInt(block_height as u128),
-                Value::UInt(lock_period),
-                signer_key_val.clone(),
-            ],
-        ),
-    ];
-    // (define-public (delegate-stack-stx (stacker principal)
-    //                                (amount-ustx uint)
-    //                                (pox-addr { version: (buff 1), hashbytes: (buff 32) })
-    //                                (start-burn-ht uint)
-    //                                (lock-period uint)
-    //                                (signer-key (buff 33)))
+    let delegate_stx:StacksTransaction = make_pox_4_delegate_stx(
+        stacker_key, 
+        stacker_nonce, 
+        100, 
+        delegate_principal.clone().into(), 
+        None, 
+        Some(pox_addr.clone()),
+    );
+
+    let delegate_stack_stx = make_pox_4_delegate_stack_stx(
+        delegate_key, 
+        delegate_nonce, 
+        PrincipalData::from(key_to_stacks_addr(stacker_key)).into(), 
+        100, 
+        pox_addr.clone(), 
+        block_height as u128,
+        lock_period,
+        signer_public_key);
+        
+    let txs = vec![delegate_stx, delegate_stack_stx];
 
     let latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
+
     let delegation_state = get_delegation_state_pox_4(
         &mut peer,
         &latest_block,
@@ -1704,7 +1678,8 @@ fn delegate_stack_stx_signer_key() {
     .expect_tuple();
 
     let state_signer_key = stacking_state.get("signer-key").unwrap();
-    assert_eq!(state_signer_key.to_string(), signer_key_val.to_string());
+
+    assert_eq!(state_signer_key.to_string()[2..],signer_public_key.to_hex());
 }
 
 #[test]
@@ -1899,7 +1874,7 @@ fn stack_increase() {
     stacker_nonce += 1;
 
     // (define-public (stack-increase (increse-by uint)
-    let stack_increase = make_pox_4_increase_stx(stacker_key, stacker_nonce, min_ustx);
+    let stack_increase = make_pox_4_stack_increase(stacker_key, stacker_nonce, min_ustx);
     let latest_block = peer.tenure_with_txs(&vec![stack_increase], &mut coinbase_nonce);
     let stacker_transactions = get_last_block_sender_transactions(&observer, stacker_address);
 

From ff78717d326939e41aea3768606f623ea2ac2e8e Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Wed, 17 Jan 2024 07:21:41 -0500
Subject: [PATCH 0428/1166] added make_pox_4_delegate_stack_extend to mod &
 cleaned up syntax

---
 stackslib/src/chainstate/stacks/boot/mod.rs   | 23 +++++
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 96 +++++++++----------
 2 files changed, 66 insertions(+), 53 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 938e49edff..ec02598e45 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -1848,6 +1848,29 @@ pub mod test {
         make_tx(key, nonce, 0, payload)
     }
 
+    pub fn make_pox_4_delegate_stack_extend(
+        key: &StacksPrivateKey,
+        nonce: u64,
+        stacker: PrincipalData,
+        pox_addr: PoxAddress,
+        extend_count: u128,
+        signer_key: StacksPublicKey,
+    ) -> StacksTransaction {
+        let payload: TransactionPayload = TransactionPayload::new_contract_call(
+            boot_code_test_addr(),
+            POX_4_NAME,
+            "delegate-stack-stx",
+            vec![
+                Value::Principal(stacker.clone()),
+                Value::Tuple(pox_addr.as_clarity_tuple().unwrap()),
+                Value::UInt(extend_count),
+                Value::buff_from(signer_key.to_bytes_compressed()).unwrap(),
+            ],
+        ).unwrap();
+
+        make_tx(key, nonce, 0, payload)
+    }
+
     pub fn make_pox_4_delegate_increase(
         key: &StacksPrivateKey,
         nonce: u64,
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 08d06b1090..9f90c132fd 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -1693,15 +1693,17 @@ fn delegate_stack_stx_extend_signer_key() {
     let delegate_nonce = 0;
     let delegate_key = &keys[1];
     let delegate_principal = PrincipalData::from(key_to_stacks_addr(delegate_key));
+    let signer_private_key = &keys[2];
+    let signer_public_key = StacksPublicKey::from_private(signer_private_key);
 
     // (define-public (delegate-stx (amount-ustx uint)
     //                          (delegate-to principal)
     //                          (until-burn-ht (optional uint))
     //                          (pox-addr (optional { version: (buff 1), hashbytes: (buff 32) })))
-    let pox_addr = make_pox_addr(
-        AddressHashMode::SerializeP2WSH,
-        key_to_stacks_addr(delegate_key).bytes,
-    );
+    // let pox_addr = make_pox_addr(
+    //     AddressHashMode::SerializeP2WSH,
+    //     key_to_stacks_addr(delegate_key).bytes,
+    // );
     let signer_key_val = Value::buff_from(vec![
         0x03, 0xa0, 0xf9, 0x81, 0x8e, 0xa8, 0xc1, 0x4a, 0x82, 0x7b, 0xb1, 0x44, 0xae, 0xc9, 0xcf,
         0xba, 0xeb, 0xa2, 0x25, 0xaf, 0x22, 0xbe, 0x18, 0xed, 0x78, 0xa2, 0xf2, 0x98, 0x10, 0x6f,
@@ -1709,42 +1711,34 @@ fn delegate_stack_stx_extend_signer_key() {
     ])
     .unwrap();
 
-    let txs = vec![
-        make_pox_4_contract_call(
-            stacker_key,
-            stacker_nonce,
-            "delegate-stx",
-            vec![
-                Value::UInt(100),
-                delegate_principal.clone().into(),
-                Value::none(),
-                Value::Optional(OptionalData {
-                    data: Some(Box::new(pox_addr.clone())),
-                }),
-            ],
-        ),
-        make_pox_4_contract_call(
-            delegate_key,
-            delegate_nonce,
-            "delegate-stack-stx",
-            vec![
-                PrincipalData::from(key_to_stacks_addr(stacker_key)).into(),
-                Value::UInt(100),
-                pox_addr.clone(),
-                Value::UInt(block_height as u128),
-                Value::UInt(lock_period),
-                signer_key_val.clone(),
-            ],
-        ),
-    ];
-    // (define-public (delegate-stack-stx (stacker principal)
-    //                                (amount-ustx uint)
-    //                                (pox-addr { version: (buff 1), hashbytes: (buff 32) })
-    //                                (start-burn-ht uint)
-    //                                (lock-period uint)
-    //                                (signer-key (buff 33)))
+    let pox_addr = PoxAddress::from_legacy(
+        AddressHashMode::SerializeP2PKH,
+        key_to_stacks_addr(delegate_key).bytes,
+    );
+
+    let delegate_stx:StacksTransaction = make_pox_4_delegate_stx(
+        stacker_key, 
+        stacker_nonce, 
+        100, 
+        delegate_principal.clone().into(), 
+        None, 
+        Some(pox_addr.clone()),
+    );
+
+    let delegate_stack_stx = make_pox_4_delegate_stack_stx(
+        delegate_key, 
+        delegate_nonce, 
+        PrincipalData::from(key_to_stacks_addr(stacker_key)).into(), 
+        100, 
+        pox_addr.clone(), 
+        block_height as u128,
+        lock_period,
+        signer_public_key.clone());
+
+    let txs = vec![delegate_stx, delegate_stack_stx];
 
     let latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
+    
     let delegation_state = get_delegation_state_pox_4(
         &mut peer,
         &latest_block,
@@ -1791,19 +1785,18 @@ fn delegate_stack_stx_extend_signer_key() {
     ])
     .unwrap();
 
-    let update_txs = vec![make_pox_4_contract_call(
-        delegate_key,
+    let delegate_stack_extend = make_pox_4_delegate_stack_extend(
+        stacker_key,
         stacker_nonce,
-        "delegate-stack-extend",
-        vec![
-            PrincipalData::from(key_to_stacks_addr(stacker_key)).into(),
-            pox_addr.clone(),
-            signer_key_new_val.clone(),
-            Value::UInt(1),
-        ],
-    )];
+        PrincipalData::from(key_to_stacks_addr(stacker_key)).into(),
+        pox_addr.clone(),
+        1,
+        signer_public_key.clone()
+    );
 
-    latest_block = peer.tenure_with_txs(&update_txs, &mut coinbase_nonce);
+    let txs = vec![delegate_stack_extend];
+
+    latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
     let new_stacking_state = get_stacking_state_pox_4(
         &mut peer,
         &latest_block,
@@ -1813,10 +1806,7 @@ fn delegate_stack_stx_extend_signer_key() {
     .expect_tuple();
 
     let state_signer_key_new = new_stacking_state.get("signer-key").unwrap();
-    assert_eq!(
-        state_signer_key_new.to_string(),
-        signer_key_new_val.to_string()
-    );
+    assert_eq!(state_signer_key_new.to_string(),signer_key_new_val.to_string());
 }
 
 #[test]

From cf71c13d2447bcfc2cfa4636809b2690bc8ee3e2 Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Wed, 17 Jan 2024 08:01:15 -0500
Subject: [PATCH 0429/1166] refactored delegate_stack_stx_extend_signer_key

---
 stackslib/src/chainstate/stacks/boot/mod.rs   |  2 +-
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 52 +++----------------
 2 files changed, 8 insertions(+), 46 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index ec02598e45..169253f8e6 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -1859,7 +1859,7 @@ pub mod test {
         let payload: TransactionPayload = TransactionPayload::new_contract_call(
             boot_code_test_addr(),
             POX_4_NAME,
-            "delegate-stack-stx",
+            "delegate-stack-extend",
             vec![
                 Value::Principal(stacker.clone()),
                 Value::Tuple(pox_addr.as_clarity_tuple().unwrap()),
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 9f90c132fd..ebd58c90b8 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -1632,7 +1632,6 @@ fn delegate_stack_stx_signer_key() {
     let delegate_principal = PrincipalData::from(key_to_stacks_addr(delegate_key));
     let signer_private_key = &keys[2];
     let signer_public_key = StacksPublicKey::from_private(signer_private_key);
-
     let pox_addr = PoxAddress::from_legacy(
         AddressHashMode::SerializeP2PKH,
         key_to_stacks_addr(delegate_key).bytes,
@@ -1695,22 +1694,6 @@ fn delegate_stack_stx_extend_signer_key() {
     let delegate_principal = PrincipalData::from(key_to_stacks_addr(delegate_key));
     let signer_private_key = &keys[2];
     let signer_public_key = StacksPublicKey::from_private(signer_private_key);
-
-    // (define-public (delegate-stx (amount-ustx uint)
-    //                          (delegate-to principal)
-    //                          (until-burn-ht (optional uint))
-    //                          (pox-addr (optional { version: (buff 1), hashbytes: (buff 32) })))
-    // let pox_addr = make_pox_addr(
-    //     AddressHashMode::SerializeP2WSH,
-    //     key_to_stacks_addr(delegate_key).bytes,
-    // );
-    let signer_key_val = Value::buff_from(vec![
-        0x03, 0xa0, 0xf9, 0x81, 0x8e, 0xa8, 0xc1, 0x4a, 0x82, 0x7b, 0xb1, 0x44, 0xae, 0xc9, 0xcf,
-        0xba, 0xeb, 0xa2, 0x25, 0xaf, 0x22, 0xbe, 0x18, 0xed, 0x78, 0xa2, 0xf2, 0x98, 0x10, 0x6f,
-        0x4e, 0x28, 0x1b,
-    ])
-    .unwrap();
-
     let pox_addr = PoxAddress::from_legacy(
         AddressHashMode::SerializeP2PKH,
         key_to_stacks_addr(delegate_key).bytes,
@@ -1756,47 +1739,26 @@ fn delegate_stack_stx_extend_signer_key() {
     .expect_tuple();
 
     let state_signer_key = stacking_state.get("signer-key").unwrap();
-    assert_eq!(state_signer_key.to_string(), signer_key_val.to_string());
-
-    // (define-public (delegate-stack-extend (stacker principal)
-    //     (extend-count uint)
-    //     (pox-addr { version: (buff 1), hashbytes: (buff 32) })
-    //     (signer-key (buff 33)))
+    assert_eq!(state_signer_key.to_string()[2..], signer_public_key.to_hex());
 
     stacker_nonce += 1;
 
-    let mut latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
-    let stacking_state = get_stacking_state_pox_4(
-        &mut peer,
-        &latest_block,
-        &key_to_stacks_addr(stacker_key).to_account_principal(),
-    )
-    .expect("No stacking state, stack-stx failed")
-    .expect_tuple();
 
-    let state_signer_key = stacking_state.get("signer-key").unwrap();
-    assert_eq!(state_signer_key.to_string(), signer_key_val.to_string());
-
-    // now stack-extend with a new signer-key
-    let signer_key_new_val = Value::buff_from(vec![
-        0x02, 0xb6, 0x19, 0x6d, 0xe8, 0x8b, 0xce, 0xe7, 0x93, 0xfa, 0x9a, 0x8a, 0x85, 0x96, 0x9b,
-        0x64, 0x7f, 0x84, 0xc9, 0x0e, 0x9d, 0x13, 0xf9, 0xc8, 0xb8, 0xce, 0x42, 0x6c, 0xc8, 0x1a,
-        0x59, 0x98, 0x3c,
-    ])
-    .unwrap();
+    let new_signer_private_key = &keys[3];
+    let new_signer_public_key = StacksPublicKey::from_private(new_signer_private_key);
 
     let delegate_stack_extend = make_pox_4_delegate_stack_extend(
-        stacker_key,
+        delegate_key,
         stacker_nonce,
         PrincipalData::from(key_to_stacks_addr(stacker_key)).into(),
         pox_addr.clone(),
         1,
-        signer_public_key.clone()
+        new_signer_public_key.clone()
     );
 
     let txs = vec![delegate_stack_extend];
 
-    latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
+    let latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
     let new_stacking_state = get_stacking_state_pox_4(
         &mut peer,
         &latest_block,
@@ -1806,7 +1768,7 @@ fn delegate_stack_stx_extend_signer_key() {
     .expect_tuple();
 
     let state_signer_key_new = new_stacking_state.get("signer-key").unwrap();
-    assert_eq!(state_signer_key_new.to_string(),signer_key_new_val.to_string());
+    assert_eq!(state_signer_key_new.to_string()[2..],new_signer_public_key.to_hex());
 }
 
 #[test]

From 78ef850647cd23fd8ae9bd38a5adb9770eb36ce0 Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Wed, 17 Jan 2024 09:42:24 -0500
Subject: [PATCH 0430/1166] refactored stack_increase

---
 stackslib/src/chainstate/stacks/boot/mod.rs   |   6 +-
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 120 +++++++++---------
 2 files changed, 64 insertions(+), 62 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 169253f8e6..419e58d68c 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -1843,7 +1843,8 @@ pub mod test {
                 Value::UInt(lock_period),
                 Value::buff_from(signer_key.to_bytes_compressed()).unwrap(),
             ],
-        ).unwrap();
+        )
+        .unwrap();
 
         make_tx(key, nonce, 0, payload)
     }
@@ -1866,7 +1867,8 @@ pub mod test {
                 Value::UInt(extend_count),
                 Value::buff_from(signer_key.to_bytes_compressed()).unwrap(),
             ],
-        ).unwrap();
+        )
+        .unwrap();
 
         make_tx(key, nonce, 0, payload)
     }
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index ebd58c90b8..ad0a8e8263 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -1637,25 +1637,26 @@ fn delegate_stack_stx_signer_key() {
         key_to_stacks_addr(delegate_key).bytes,
     );
 
-    let delegate_stx:StacksTransaction = make_pox_4_delegate_stx(
-        stacker_key, 
-        stacker_nonce, 
-        100, 
-        delegate_principal.clone().into(), 
-        None, 
+    let delegate_stx: StacksTransaction = make_pox_4_delegate_stx(
+        stacker_key,
+        stacker_nonce,
+        100,
+        delegate_principal.clone().into(),
+        None,
         Some(pox_addr.clone()),
     );
 
     let delegate_stack_stx = make_pox_4_delegate_stack_stx(
-        delegate_key, 
-        delegate_nonce, 
-        PrincipalData::from(key_to_stacks_addr(stacker_key)).into(), 
-        100, 
-        pox_addr.clone(), 
+        delegate_key,
+        delegate_nonce,
+        PrincipalData::from(key_to_stacks_addr(stacker_key)).into(),
+        100,
+        pox_addr.clone(),
         block_height as u128,
         lock_period,
-        signer_public_key);
-        
+        signer_public_key,
+    );
+
     let txs = vec![delegate_stx, delegate_stack_stx];
 
     let latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
@@ -1678,7 +1679,10 @@ fn delegate_stack_stx_signer_key() {
 
     let state_signer_key = stacking_state.get("signer-key").unwrap();
 
-    assert_eq!(state_signer_key.to_string()[2..],signer_public_key.to_hex());
+    assert_eq!(
+        state_signer_key.to_string()[2..],
+        signer_public_key.to_hex()
+    );
 }
 
 #[test]
@@ -1699,29 +1703,30 @@ fn delegate_stack_stx_extend_signer_key() {
         key_to_stacks_addr(delegate_key).bytes,
     );
 
-    let delegate_stx:StacksTransaction = make_pox_4_delegate_stx(
-        stacker_key, 
-        stacker_nonce, 
-        100, 
-        delegate_principal.clone().into(), 
-        None, 
+    let delegate_stx: StacksTransaction = make_pox_4_delegate_stx(
+        stacker_key,
+        stacker_nonce,
+        100,
+        delegate_principal.clone().into(),
+        None,
         Some(pox_addr.clone()),
     );
 
     let delegate_stack_stx = make_pox_4_delegate_stack_stx(
-        delegate_key, 
-        delegate_nonce, 
-        PrincipalData::from(key_to_stacks_addr(stacker_key)).into(), 
-        100, 
-        pox_addr.clone(), 
+        delegate_key,
+        delegate_nonce,
+        PrincipalData::from(key_to_stacks_addr(stacker_key)).into(),
+        100,
+        pox_addr.clone(),
         block_height as u128,
         lock_period,
-        signer_public_key.clone());
+        signer_public_key.clone(),
+    );
 
     let txs = vec![delegate_stx, delegate_stack_stx];
 
     let latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
-    
+
     let delegation_state = get_delegation_state_pox_4(
         &mut peer,
         &latest_block,
@@ -1739,11 +1744,13 @@ fn delegate_stack_stx_extend_signer_key() {
     .expect_tuple();
 
     let state_signer_key = stacking_state.get("signer-key").unwrap();
-    assert_eq!(state_signer_key.to_string()[2..], signer_public_key.to_hex());
+    assert_eq!(
+        state_signer_key.to_string()[2..],
+        signer_public_key.to_hex()
+    );
 
     stacker_nonce += 1;
 
-
     let new_signer_private_key = &keys[3];
     let new_signer_public_key = StacksPublicKey::from_private(new_signer_private_key);
 
@@ -1753,7 +1760,7 @@ fn delegate_stack_stx_extend_signer_key() {
         PrincipalData::from(key_to_stacks_addr(stacker_key)).into(),
         pox_addr.clone(),
         1,
-        new_signer_public_key.clone()
+        new_signer_public_key.clone(),
     );
 
     let txs = vec![delegate_stack_extend];
@@ -1768,7 +1775,10 @@ fn delegate_stack_stx_extend_signer_key() {
     .expect_tuple();
 
     let state_signer_key_new = new_stacking_state.get("signer-key").unwrap();
-    assert_eq!(state_signer_key_new.to_string()[2..],new_signer_public_key.to_hex());
+    assert_eq!(
+        state_signer_key_new.to_string()[2..],
+        new_signer_public_key.to_hex()
+    );
 }
 
 #[test]
@@ -1781,37 +1791,24 @@ fn stack_increase() {
     let mut stacker_nonce = 0;
     let stacker_key = &keys[0];
     let stacker_address = key_to_stacks_addr(stacker_key);
+    let signer_private_key = &keys[1];
+    let signer_public_key = StacksPublicKey::from_private(signer_private_key);
     let min_ustx = get_stacking_minimum(&mut peer, &latest_block);
+    let pox_addr = PoxAddress::from_legacy(AddressHashMode::SerializeP2PKH, stacker_address.bytes);
 
-    // (define-public (stack-stx (amount-ustx uint)
-    //                       (pox-addr (tuple (version (buff 1)) (hashbytes (buff 32))))
-    //                       (start-burn-ht uint)
-    //                       (lock-period uint)
-    //                       (signer-key (buff 33)))
-    let pox_addr = make_pox_addr(
-        AddressHashMode::SerializeP2WSH,
-        key_to_stacks_addr(stacker_key).bytes,
-    );
-    let signer_key_val = Value::buff_from(vec![
-        0x03, 0xa0, 0xf9, 0x81, 0x8e, 0xa8, 0xc1, 0x4a, 0x82, 0x7b, 0xb1, 0x44, 0xae, 0xc9, 0xcf,
-        0xba, 0xeb, 0xa2, 0x25, 0xaf, 0x22, 0xbe, 0x18, 0xed, 0x78, 0xa2, 0xf2, 0x98, 0x10, 0x6f,
-        0x4e, 0x28, 0x1b,
-    ])
-    .unwrap();
-    let first_txs = vec![make_pox_4_contract_call(
+    let stack_stx = make_pox_4_lockup(
         stacker_key,
         stacker_nonce,
-        "stack-stx",
-        vec![
-            Value::UInt(min_ustx),
-            pox_addr,
-            Value::UInt(block_height as u128),
-            Value::UInt(2),
-            signer_key_val.clone(),
-        ],
-    )];
+        min_ustx,
+        pox_addr.clone(),
+        lock_period,
+        signer_public_key.clone(),
+        block_height as u64,
+    );
+
+    let txs = vec![stack_stx];
 
-    let latest_block = peer.tenure_with_txs(&first_txs, &mut coinbase_nonce);
+    let latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
     let stacking_state = get_stacking_state_pox_4(
         &mut peer,
         &latest_block,
@@ -1821,13 +1818,16 @@ fn stack_increase() {
     .expect_tuple();
 
     let state_signer_key = stacking_state.get("signer-key").unwrap();
-    assert_eq!(state_signer_key.to_string(), signer_key_val.to_string());
+    assert_eq!(
+        state_signer_key.to_string()[2..],
+        signer_public_key.to_hex()
+    );
 
     stacker_nonce += 1;
 
-    // (define-public (stack-increase (increse-by uint)
     let stack_increase = make_pox_4_stack_increase(stacker_key, stacker_nonce, min_ustx);
-    let latest_block = peer.tenure_with_txs(&vec![stack_increase], &mut coinbase_nonce);
+    let txs = vec![stack_increase];
+    let latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
     let stacker_transactions = get_last_block_sender_transactions(&observer, stacker_address);
 
     let stacker_locked_amount: u128 = match &stacker_transactions[0].result {

From d7fc6546ea6aab75f7e542e00455fb61d18ae481 Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Wed, 17 Jan 2024 12:56:28 -0500
Subject: [PATCH 0431/1166] added delegate_stack_increase

---
 stackslib/src/chainstate/stacks/boot/mod.rs   |  4 +-
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 81 +++++++------------
 2 files changed, 30 insertions(+), 55 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 419e58d68c..cc9edfbf6e 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -1877,7 +1877,7 @@ pub mod test {
         key: &StacksPrivateKey,
         nonce: u64,
         stacker: &PrincipalData,
-        pox_addr: Value,
+        pox_addr: PoxAddress,
         amount: u128,
     ) -> StacksTransaction {
         //let addr_tuple = Value::Tuple(pox_addr.as_clarity_tuple().unwrap());
@@ -1887,7 +1887,7 @@ pub mod test {
             "delegate-stack-increase",
             vec![
                 Value::Principal(stacker.clone()),
-                pox_addr,
+                Value::Tuple(pox_addr.as_clarity_tuple().unwrap()),
                 Value::UInt(amount),
             ],
         )
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index ad0a8e8263..837d935016 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -1794,7 +1794,10 @@ fn stack_increase() {
     let signer_private_key = &keys[1];
     let signer_public_key = StacksPublicKey::from_private(signer_private_key);
     let min_ustx = get_stacking_minimum(&mut peer, &latest_block);
-    let pox_addr = PoxAddress::from_legacy(AddressHashMode::SerializeP2PKH, stacker_address.bytes);
+    let pox_addr = PoxAddress::from_legacy(
+        AddressHashMode::SerializeP2PKH,
+        key_to_stacks_addr(stacker_key).bytes,
+    );
 
     let stack_stx = make_pox_4_lockup(
         stacker_key,
@@ -1872,62 +1875,34 @@ fn delegate_stack_increase() {
     let delegate_address =
         PrincipalData::from(key_to_stacks_addr(delegate_key).to_account_principal());
     let min_ustx = get_stacking_minimum(&mut peer, &latest_block);
-
-    // (define-public (delegate-stx (amount-ustx uint)
-    //                          (delegate-to principal)
-    //                          (until-burn-ht (optional uint))
-    //                          (pox-addr (optional { version: (buff 1), hashbytes: (buff 32) })))
-    let pox_addr = make_pox_addr(
-        AddressHashMode::SerializeP2WSH,
+    let signer_private_key = &keys[2];
+    let signer_public_key = StacksPublicKey::from_private(signer_private_key);
+    let pox_addr = PoxAddress::from_legacy(
+        AddressHashMode::SerializeP2PKH,
         key_to_stacks_addr(delegate_key).bytes,
     );
 
-    let signer_key_val = Value::buff_from(vec![
-        0x03, 0xa0, 0xf9, 0x81, 0x8e, 0xa8, 0xc1, 0x4a, 0x82, 0x7b, 0xb1, 0x44, 0xae, 0xc9, 0xcf,
-        0xba, 0xeb, 0xa2, 0x25, 0xaf, 0x22, 0xbe, 0x18, 0xed, 0x78, 0xa2, 0xf2, 0x98, 0x10, 0x6f,
-        0x4e, 0x28, 0x1b,
-    ])
-    .unwrap();
+    let delegate_stx = make_pox_4_delegate_stx(
+        stacker_key,
+        stacker_nonce,
+        2 * min_ustx,
+        delegate_address.clone(),
+        None,
+        Some(pox_addr.clone()),
+    );
 
-    let txs = vec![
-        make_pox_4_contract_call(
-            stacker_key,
-            stacker_nonce,
-            "delegate-stx",
-            vec![
-                Value::UInt(2 * min_ustx),
-                Value::Principal(delegate_address.clone()),
-                Value::none(),
-                Value::Optional(OptionalData {
-                    data: Some(Box::new(pox_addr.clone())),
-                }),
-            ],
-        ),
-        make_pox_4_contract_call(
-            delegate_key,
-            delegate_nonce,
-            "delegate-stack-stx",
-            vec![
-                Value::Principal(stacker_address.clone()),
-                Value::UInt(min_ustx),
-                pox_addr.clone(),
-                Value::UInt(block_height as u128),
-                Value::UInt(lock_period),
-                signer_key_val.clone(),
-            ],
-        ),
-    ];
-    // (define-public (delegate-stack-stx (stacker principal)
-    //                                (amount-ustx uint)
-    //                                (pox-addr { version: (buff 1), hashbytes: (buff 32) })
-    //                                (start-burn-ht uint)
-    //                                (lock-period uint)
-    //                                (signer-key (buff 33)))
-
-    // (define-public (delegate-stack-extend (stacker principal)
-    //     (extend-count uint)
-    //     (pox-addr { version: (buff 1), hashbytes: (buff 32) })
-    //     (signer-key (buff 33)))
+    let delegate_stack_stx = make_pox_4_delegate_stack_stx(
+        delegate_key,
+        delegate_nonce,
+        PrincipalData::from(key_to_stacks_addr(stacker_key)).into(),
+        min_ustx,
+        pox_addr.clone(),
+        block_height as u128,
+        lock_period,
+        signer_public_key.clone(),
+    );
+
+    let txs = vec![delegate_stx, delegate_stack_stx];
 
     let latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
 

From 8dfb2cad5b0addaa961e99df61dddb5100805205 Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Thu, 18 Jan 2024 10:47:09 -0500
Subject: [PATCH 0432/1166] updated format in four assert-eqs instances

---
 .../src/chainstate/stacks/boot/pox_4_tests.rs    | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 837d935016..b280f5f725 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -1680,8 +1680,8 @@ fn delegate_stack_stx_signer_key() {
     let state_signer_key = stacking_state.get("signer-key").unwrap();
 
     assert_eq!(
-        state_signer_key.to_string()[2..],
-        signer_public_key.to_hex()
+        state_signer_key.to_string(),
+        format!("0x,{}", signer_public_key.to_hex())
     );
 }
 
@@ -1745,8 +1745,8 @@ fn delegate_stack_stx_extend_signer_key() {
 
     let state_signer_key = stacking_state.get("signer-key").unwrap();
     assert_eq!(
-        state_signer_key.to_string()[2..],
-        signer_public_key.to_hex()
+        state_signer_key.to_string(),
+        format!("0x,{}", signer_public_key.to_hex())
     );
 
     stacker_nonce += 1;
@@ -1776,8 +1776,8 @@ fn delegate_stack_stx_extend_signer_key() {
 
     let state_signer_key_new = new_stacking_state.get("signer-key").unwrap();
     assert_eq!(
-        state_signer_key_new.to_string()[2..],
-        new_signer_public_key.to_hex()
+        state_signer_key.to_string(),
+        format!("0x,{}", signer_public_key.to_hex())
     );
 }
 
@@ -1822,8 +1822,8 @@ fn stack_increase() {
 
     let state_signer_key = stacking_state.get("signer-key").unwrap();
     assert_eq!(
-        state_signer_key.to_string()[2..],
-        signer_public_key.to_hex()
+        state_signer_key.to_string(),
+        format!("0x,{}", signer_public_key.to_hex())
     );
 
     stacker_nonce += 1;

From 9291bacd86482acd5b2c3d18566afd65a66528b5 Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Thu, 18 Jan 2024 11:03:55 -0500
Subject: [PATCH 0433/1166] refactored extracted values

---
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 74 +++++++------------
 1 file changed, 28 insertions(+), 46 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index b280f5f725..c4388803d3 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -1833,30 +1833,21 @@ fn stack_increase() {
     let latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
     let stacker_transactions = get_last_block_sender_transactions(&observer, stacker_address);
 
-    let stacker_locked_amount: u128 = match &stacker_transactions[0].result {
-        Value::Response(ResponseData {
-            committed: _,
-            ref data,
-        }) => {
-            match **data {
-                Value::Tuple(TupleData {
-                    type_signature: _,
-                    ref data_map,
-                }) => {
-                    match data_map.get("total-locked") {
-                        Some(&Value::UInt(total_locked)) => {
-                            total_locked // Return the u128 value
-                        }
-                        _ => panic!("'total-locked' key not found or not a UInt"),
-                    }
-                }
-                _ => panic!("Response data is not a tuple"),
-            }
-        }
-        _ => panic!("Result is not a response"),
-    };
 
-    assert_eq!(stacker_locked_amount, min_ustx * 2);
+    let transaction_result = stacker_transactions
+        .first()
+        .map(|tx| tx.result.clone())
+        .unwrap();
+    let total_locked = transaction_result
+        .expect_result_ok()
+        .expect_tuple()
+        .data_map
+        .get("total-locked")
+        .expect("total-locked key not found")
+        .clone()
+        .expect_u128();
+    
+    assert_eq!(total_locked, min_ustx * 2);
 }
 
 #[test]
@@ -1924,30 +1915,21 @@ fn delegate_stack_increase() {
     let delegate_transactions =
         get_last_block_sender_transactions(&observer, delegate_address.into());
 
-    let stacker_locked_amount: u128 = match &delegate_transactions[0].result {
-        Value::Response(ResponseData {
-            committed: _,
-            ref data,
-        }) => {
-            match **data {
-                Value::Tuple(TupleData {
-                    type_signature: _,
-                    ref data_map,
-                }) => {
-                    match data_map.get("total-locked") {
-                        Some(&Value::UInt(total_locked)) => {
-                            total_locked // Return the u128 value
-                        }
-                        _ => panic!("'total-locked' key not found or not a UInt"),
-                    }
-                }
-                _ => panic!("Response data is not a tuple"),
-            }
-        }
-        _ => panic!("Result is not a response"),
-    };
+    let transaction_result = delegate_transactions
+        .first()
+        .map(|tx| tx.result.clone())
+        .unwrap();
+
+    let total_locked = transaction_result
+        .expect_result_ok()
+        .expect_tuple()
+        .data_map
+        .get("total-locked")
+        .expect("total-locked key not found")
+        .clone()
+        .expect_u128();
 
-    assert_eq!(stacker_locked_amount, min_ustx * 2);
+    assert_eq!(total_locked, min_ustx * 2);
 }
 
 pub fn get_stacking_state_pox_4(

From e95850cc2c61bdc6bfd274228f4687d1eaec17da Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Thu, 18 Jan 2024 11:08:33 -0500
Subject: [PATCH 0434/1166] last polishes

---
 stackslib/src/chainstate/stacks/boot/pox_4_tests.rs | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index c4388803d3..95abff31c9 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -1698,6 +1698,8 @@ fn delegate_stack_stx_extend_signer_key() {
     let delegate_principal = PrincipalData::from(key_to_stacks_addr(delegate_key));
     let signer_private_key = &keys[2];
     let signer_public_key = StacksPublicKey::from_private(signer_private_key);
+    let new_signer_private_key = &keys[3];
+    let new_signer_public_key = StacksPublicKey::from_private(new_signer_private_key);
     let pox_addr = PoxAddress::from_legacy(
         AddressHashMode::SerializeP2PKH,
         key_to_stacks_addr(delegate_key).bytes,
@@ -1751,9 +1753,6 @@ fn delegate_stack_stx_extend_signer_key() {
 
     stacker_nonce += 1;
 
-    let new_signer_private_key = &keys[3];
-    let new_signer_public_key = StacksPublicKey::from_private(new_signer_private_key);
-
     let delegate_stack_extend = make_pox_4_delegate_stack_extend(
         delegate_key,
         stacker_nonce,

From f6b7bf2fde5854bc2f126792439864eefce8b2cf Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Thu, 18 Jan 2024 11:15:41 -0500
Subject: [PATCH 0435/1166] forgot formatter

---
 stackslib/src/chainstate/stacks/boot/pox_4_tests.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 95abff31c9..bb31953bc7 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -1832,7 +1832,6 @@ fn stack_increase() {
     let latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
     let stacker_transactions = get_last_block_sender_transactions(&observer, stacker_address);
 
-
     let transaction_result = stacker_transactions
         .first()
         .map(|tx| tx.result.clone())
@@ -1845,7 +1844,7 @@ fn stack_increase() {
         .expect("total-locked key not found")
         .clone()
         .expect_u128();
-    
+
     assert_eq!(total_locked, min_ustx * 2);
 }
 

From b0d58da86e3064ab55206690b17244a19b2d166b Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Thu, 18 Jan 2024 14:52:13 -0500
Subject: [PATCH 0436/1166] fixed assert format

---
 stackslib/src/chainstate/stacks/boot/pox_4_tests.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index bb31953bc7..5dd14a45bd 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -1681,7 +1681,7 @@ fn delegate_stack_stx_signer_key() {
 
     assert_eq!(
         state_signer_key.to_string(),
-        format!("0x,{}", signer_public_key.to_hex())
+        format!("0x{}", signer_public_key.to_hex())
     );
 }
 
@@ -1748,7 +1748,7 @@ fn delegate_stack_stx_extend_signer_key() {
     let state_signer_key = stacking_state.get("signer-key").unwrap();
     assert_eq!(
         state_signer_key.to_string(),
-        format!("0x,{}", signer_public_key.to_hex())
+        format!("0x{}", signer_public_key.to_hex())
     );
 
     stacker_nonce += 1;
@@ -1775,8 +1775,8 @@ fn delegate_stack_stx_extend_signer_key() {
 
     let state_signer_key_new = new_stacking_state.get("signer-key").unwrap();
     assert_eq!(
-        state_signer_key.to_string(),
-        format!("0x,{}", signer_public_key.to_hex())
+        state_signer_key_new.to_string(),
+        format!("0x{}", new_signer_public_key.to_hex())
     );
 }
 

From a9a39c6d84db06f2ced7f6fcdb71410bf9ebc365 Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Thu, 18 Jan 2024 20:28:52 -0500
Subject: [PATCH 0437/1166] addressing comments

---
 stackslib/src/chainstate/stacks/boot/mod.rs   |  2 +-
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 53 +++++++++++--------
 2 files changed, 31 insertions(+), 24 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index cc9edfbf6e..37c48f1bfd 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -1873,7 +1873,7 @@ pub mod test {
         make_tx(key, nonce, 0, payload)
     }
 
-    pub fn make_pox_4_delegate_increase(
+    pub fn make_pox_4_delegate_stack_increase(
         key: &StacksPrivateKey,
         nonce: u64,
         stacker: &PrincipalData,
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 5dd14a45bd..337ed4e334 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -1674,7 +1674,7 @@ fn delegate_stack_stx_signer_key() {
         &latest_block,
         &key_to_stacks_addr(stacker_key).to_account_principal(),
     )
-    .expect("No stacking state, stack-stx failed")
+    .expect("No stacking state, delegate-stack-stx failed")
     .expect_tuple();
 
     let state_signer_key = stacking_state.get("signer-key").unwrap();
@@ -1822,7 +1822,7 @@ fn stack_increase() {
     let state_signer_key = stacking_state.get("signer-key").unwrap();
     assert_eq!(
         state_signer_key.to_string(),
-        format!("0x,{}", signer_public_key.to_hex())
+        format!("0x{}", signer_public_key.to_hex())
     );
 
     stacker_nonce += 1;
@@ -1832,20 +1832,24 @@ fn stack_increase() {
     let latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
     let stacker_transactions = get_last_block_sender_transactions(&observer, stacker_address);
 
-    let transaction_result = stacker_transactions
+    let actual_result = stacker_transactions
         .first()
         .map(|tx| tx.result.clone())
         .unwrap();
-    let total_locked = transaction_result
-        .expect_result_ok()
-        .expect_tuple()
-        .data_map
-        .get("total-locked")
-        .expect("total-locked key not found")
-        .clone()
-        .expect_u128();
 
-    assert_eq!(total_locked, min_ustx * 2);
+    let expected_result = Value::okay(Value::Tuple(
+        TupleData::from_data(vec![
+            (
+                "stacker".into(),
+                Value::Principal(PrincipalData::from(stacker_address.clone())),
+            ),
+            ("total-locked".into(), Value::UInt(min_ustx * 2)),
+        ])
+        .unwrap(),
+    ))
+    .unwrap();
+
+    assert_eq!(actual_result, expected_result);
 }
 
 #[test]
@@ -1898,7 +1902,7 @@ fn delegate_stack_increase() {
     stacker_nonce += 1;
     delegate_nonce += 1;
 
-    let delegate_increase = make_pox_4_delegate_increase(
+    let delegate_increase = make_pox_4_delegate_stack_increase(
         delegate_key,
         delegate_nonce,
         &stacker_address,
@@ -1913,21 +1917,24 @@ fn delegate_stack_increase() {
     let delegate_transactions =
         get_last_block_sender_transactions(&observer, delegate_address.into());
 
-    let transaction_result = delegate_transactions
+    let actual_result = delegate_transactions
         .first()
         .map(|tx| tx.result.clone())
         .unwrap();
 
-    let total_locked = transaction_result
-        .expect_result_ok()
-        .expect_tuple()
-        .data_map
-        .get("total-locked")
-        .expect("total-locked key not found")
-        .clone()
-        .expect_u128();
+    let expected_result = Value::okay(Value::Tuple(
+        TupleData::from_data(vec![
+            (
+                "stacker".into(),
+                Value::Principal(PrincipalData::from(stacker_address.clone())),
+            ),
+            ("total-locked".into(), Value::UInt(min_ustx * 2)),
+        ])
+        .unwrap(),
+    ))
+    .unwrap();
 
-    assert_eq!(total_locked, min_ustx * 2);
+    assert_eq!(actual_result, expected_result);
 }
 
 pub fn get_stacking_state_pox_4(

From ab1936f8f85c8741e0de94cbd77e92f7ee071503 Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Fri, 19 Jan 2024 06:51:01 -0500
Subject: [PATCH 0438/1166] removed unused import

---
 stackslib/src/chainstate/stacks/boot/pox_4_tests.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 337ed4e334..33049a2f18 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -14,7 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::any::Any;
 use std::collections::{BTreeMap, HashMap, HashSet, VecDeque};
 use std::convert::{TryFrom, TryInto};
 

From 5006870581bd7b9b9762903596ee1a71b178690a Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Fri, 19 Jan 2024 07:17:20 -0500
Subject: [PATCH 0439/1166] removed unused import

---
 stackslib/src/chainstate/stacks/boot/mod.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 37c48f1bfd..9922853f11 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -1880,7 +1880,6 @@ pub mod test {
         pox_addr: PoxAddress,
         amount: u128,
     ) -> StacksTransaction {
-        //let addr_tuple = Value::Tuple(pox_addr.as_clarity_tuple().unwrap());
         let payload = TransactionPayload::new_contract_call(
             boot_code_test_addr(),
             POX_4_NAME,

From 0a334eff189d11f1aea22ed59696bf4755aa32fb Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Mon, 22 Jan 2024 09:43:46 -0500
Subject: [PATCH 0440/1166] updated comments

---
 stackslib/src/chainstate/stacks/boot/mod.rs   | 42 +++++++++----------
 .../src/chainstate/stacks/boot/pox-4.clar     |  4 +-
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 22 ++++++++--
 3 files changed, 41 insertions(+), 27 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 9922853f11..16b8be74cc 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -1854,8 +1854,8 @@ pub mod test {
         nonce: u64,
         stacker: PrincipalData,
         pox_addr: PoxAddress,
-        extend_count: u128,
         signer_key: StacksPublicKey,
+        extend_count: u128,
     ) -> StacksTransaction {
         let payload: TransactionPayload = TransactionPayload::new_contract_call(
             boot_code_test_addr(),
@@ -1864,8 +1864,8 @@ pub mod test {
             vec![
                 Value::Principal(stacker.clone()),
                 Value::Tuple(pox_addr.as_clarity_tuple().unwrap()),
-                Value::UInt(extend_count),
                 Value::buff_from(signer_key.to_bytes_compressed()).unwrap(),
+                Value::UInt(extend_count),
             ],
         )
         .unwrap();
@@ -1873,58 +1873,58 @@ pub mod test {
         make_tx(key, nonce, 0, payload)
     }
 
-    pub fn make_pox_4_delegate_stack_increase(
+    pub fn make_pox_4_aggregation_commit_indexed(
         key: &StacksPrivateKey,
         nonce: u64,
-        stacker: &PrincipalData,
-        pox_addr: PoxAddress,
         amount: u128,
+        delegate_to: PrincipalData,
+        until_burn_ht: Option<u128>,
+        pox_addr: PoxAddress,
     ) -> StacksTransaction {
+        let addr_tuple = Value::Tuple(pox_addr.as_clarity_tuple().unwrap());
         let payload = TransactionPayload::new_contract_call(
             boot_code_test_addr(),
             POX_4_NAME,
-            "delegate-stack-increase",
-            vec![
-                Value::Principal(stacker.clone()),
-                Value::Tuple(pox_addr.as_clarity_tuple().unwrap()),
-                Value::UInt(amount),
-            ],
+            "stack-aggregation-commit-indexed",
+            vec![addr_tuple, Value::UInt(amount)],
         )
         .unwrap();
 
         make_tx(key, nonce, 0, payload)
     }
 
-    pub fn make_pox_4_aggregation_commit_indexed(
+    pub fn make_pox_4_stack_increase(
         key: &StacksPrivateKey,
         nonce: u64,
         amount: u128,
-        delegate_to: PrincipalData,
-        until_burn_ht: Option<u128>,
-        pox_addr: PoxAddress,
     ) -> StacksTransaction {
-        let addr_tuple = Value::Tuple(pox_addr.as_clarity_tuple().unwrap());
         let payload = TransactionPayload::new_contract_call(
             boot_code_test_addr(),
             POX_4_NAME,
-            "stack-aggregation-commit-indexed",
-            vec![addr_tuple, Value::UInt(amount)],
+            "stack-increase",
+            vec![Value::UInt(amount)],
         )
         .unwrap();
 
         make_tx(key, nonce, 0, payload)
     }
 
-    pub fn make_pox_4_stack_increase(
+    pub fn make_pox_4_delegate_stack_increase(
         key: &StacksPrivateKey,
         nonce: u64,
+        stacker: &PrincipalData,
+        pox_addr: PoxAddress,
         amount: u128,
     ) -> StacksTransaction {
         let payload = TransactionPayload::new_contract_call(
             boot_code_test_addr(),
             POX_4_NAME,
-            "stack-increase",
-            vec![Value::UInt(amount)],
+            "delegate-stack-increase",
+            vec![
+                Value::Principal(stacker.clone()),
+                Value::Tuple(pox_addr.as_clarity_tuple().unwrap()),
+                Value::UInt(amount),
+            ],
         )
         .unwrap();
 
diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index 63e9f7272a..777473676e 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -1158,8 +1158,8 @@
 (define-public (delegate-stack-extend
                     (stacker principal)
                     (pox-addr { version: (buff 1), hashbytes: (buff 32) })
-                    (extend-count uint)
-                    (signer-key (buff 33)))
+                    (signer-key (buff 33))
+                    (extend-count uint))
     (let ((stacker-info (stx-account stacker))
           ;; to extend, there must already be an entry in the stacking-state
           (stacker-state (unwrap! (get-stacker-info stacker) (err ERR_STACK_EXTEND_NOT_LOCKED)))
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 33049a2f18..ce945d06a6 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -14,7 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::collections::{BTreeMap, HashMap, HashSet, VecDeque};
+use std::collections::{ HashMap, HashSet, VecDeque};
 use std::convert::{TryFrom, TryInto};
 
 use clarity::vm::clarity::ClarityConnection;
@@ -1679,8 +1679,8 @@ fn delegate_stack_stx_signer_key() {
     let state_signer_key = stacking_state.get("signer-key").unwrap();
 
     assert_eq!(
-        state_signer_key.to_string(),
-        format!("0x{}", signer_public_key.to_hex())
+        state_signer_key,
+        signer_public_key
     );
 }
 
@@ -1724,6 +1724,8 @@ fn delegate_stack_stx_extend_signer_key() {
         signer_public_key.clone(),
     );
 
+    // Initial txs arr includes initial delegate_stx & delegate_stack_stx
+    // Both are pox_4 helpers found in mod.rs
     let txs = vec![delegate_stx, delegate_stack_stx];
 
     let latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
@@ -1744,6 +1746,7 @@ fn delegate_stack_stx_extend_signer_key() {
     .expect("No stacking state, stack-stx failed")
     .expect_tuple();
 
+    // Testing initial signer-key correctly set
     let state_signer_key = stacking_state.get("signer-key").unwrap();
     assert_eq!(
         state_signer_key.to_string(),
@@ -1757,10 +1760,11 @@ fn delegate_stack_stx_extend_signer_key() {
         stacker_nonce,
         PrincipalData::from(key_to_stacks_addr(stacker_key)).into(),
         pox_addr.clone(),
-        1,
         new_signer_public_key.clone(),
+        1,
     );
 
+    // Next tx arr calls a delegate_stack_extend pox_4 helper found in mod.rs
     let txs = vec![delegate_stack_extend];
 
     let latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
@@ -1772,6 +1776,7 @@ fn delegate_stack_stx_extend_signer_key() {
     .unwrap()
     .expect_tuple();
 
+    // Testing new signer-key correctly set
     let state_signer_key_new = new_stacking_state.get("signer-key").unwrap();
     assert_eq!(
         state_signer_key_new.to_string(),
@@ -1807,6 +1812,7 @@ fn stack_increase() {
         block_height as u64,
     );
 
+    // Initial tx arr includes a stack_stx pox_4 helper found in mod.rs
     let txs = vec![stack_stx];
 
     let latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
@@ -1818,6 +1824,7 @@ fn stack_increase() {
     .expect("No stacking state, stack-stx failed")
     .expect_tuple();
 
+    // Testing initial signer-key correctly set
     let state_signer_key = stacking_state.get("signer-key").unwrap();
     assert_eq!(
         state_signer_key.to_string(),
@@ -1827,6 +1834,7 @@ fn stack_increase() {
     stacker_nonce += 1;
 
     let stack_increase = make_pox_4_stack_increase(stacker_key, stacker_nonce, min_ustx);
+    // Next tx arr includes a stack_increase pox_4 helper found in mod.rs
     let txs = vec![stack_increase];
     let latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
     let stacker_transactions = get_last_block_sender_transactions(&observer, stacker_address);
@@ -1848,6 +1856,8 @@ fn stack_increase() {
     ))
     .unwrap();
 
+    // Testing stack_increase response is equal to expected response
+    // Test is straightforward because 'stack-increase' in PoX-4 is the same as PoX-3
     assert_eq!(actual_result, expected_result);
 }
 
@@ -1894,6 +1904,7 @@ fn delegate_stack_increase() {
         signer_public_key.clone(),
     );
 
+    // Initial tx arr includes a delegate_stx & delegate_stack_stx pox_4 helper found in mod.rs
     let txs = vec![delegate_stx, delegate_stack_stx];
 
     let latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
@@ -1909,6 +1920,7 @@ fn delegate_stack_increase() {
         min_ustx,
     );
 
+    // Next tx arr includes a delegate_increase pox_4 helper found in mod.rs
     let txs = vec![delegate_increase];
 
     let latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
@@ -1933,6 +1945,8 @@ fn delegate_stack_increase() {
     ))
     .unwrap();
 
+    // Testing stack_increase response is equal to expected response
+    // Test is straightforward because 'stack-increase' in PoX-4 is the same as PoX-3
     assert_eq!(actual_result, expected_result);
 }
 

From cc17e4a0d6c64c41596fce497fc8927b3e6ff339 Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Mon, 22 Jan 2024 09:44:39 -0500
Subject: [PATCH 0441/1166] fixed broken test

---
 stackslib/src/chainstate/stacks/boot/pox_4_tests.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index ce945d06a6..73d8a579ab 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -1679,8 +1679,8 @@ fn delegate_stack_stx_signer_key() {
     let state_signer_key = stacking_state.get("signer-key").unwrap();
 
     assert_eq!(
-        state_signer_key,
-        signer_public_key
+        state_signer_key.to_string(),
+        format!("0x{}", signer_public_key.to_hex())
     );
 }
 

From f12bf9574dffe5e0019cf96743c1f36bfb9c6794 Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Mon, 22 Jan 2024 13:27:34 -0500
Subject: [PATCH 0442/1166] updated asserts to check values instead of strings

---
 .../src/chainstate/stacks/boot/pox_4_tests.rs  | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 73d8a579ab..cec989a3ee 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -14,7 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::collections::{ HashMap, HashSet, VecDeque};
+use std::collections::{HashMap, HashSet, VecDeque};
 use std::convert::{TryFrom, TryInto};
 
 use clarity::vm::clarity::ClarityConnection;
@@ -1679,8 +1679,8 @@ fn delegate_stack_stx_signer_key() {
     let state_signer_key = stacking_state.get("signer-key").unwrap();
 
     assert_eq!(
-        state_signer_key.to_string(),
-        format!("0x{}", signer_public_key.to_hex())
+        state_signer_key,
+        &Value::buff_from(signer_public_key.to_bytes_compressed()).unwrap()
     );
 }
 
@@ -1749,8 +1749,8 @@ fn delegate_stack_stx_extend_signer_key() {
     // Testing initial signer-key correctly set
     let state_signer_key = stacking_state.get("signer-key").unwrap();
     assert_eq!(
-        state_signer_key.to_string(),
-        format!("0x{}", signer_public_key.to_hex())
+        state_signer_key,
+        &Value::buff_from(signer_public_key.to_bytes_compressed()).unwrap()
     );
 
     stacker_nonce += 1;
@@ -1779,8 +1779,8 @@ fn delegate_stack_stx_extend_signer_key() {
     // Testing new signer-key correctly set
     let state_signer_key_new = new_stacking_state.get("signer-key").unwrap();
     assert_eq!(
-        state_signer_key_new.to_string(),
-        format!("0x{}", new_signer_public_key.to_hex())
+        state_signer_key_new,
+        &Value::buff_from(new_signer_public_key.to_bytes_compressed()).unwrap()
     );
 }
 
@@ -1827,8 +1827,8 @@ fn stack_increase() {
     // Testing initial signer-key correctly set
     let state_signer_key = stacking_state.get("signer-key").unwrap();
     assert_eq!(
-        state_signer_key.to_string(),
-        format!("0x{}", signer_public_key.to_hex())
+        state_signer_key,
+        &Value::buff_from(signer_public_key.to_bytes_compressed()).unwrap()
     );
 
     stacker_nonce += 1;

From 185d1224efc37a9fbd3e6f778be7e9dca3e31c69 Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Mon, 22 Jan 2024 20:45:14 -0500
Subject: [PATCH 0443/1166] updated with alice & bob vars & comments

---
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 155 ++++++++++--------
 1 file changed, 87 insertions(+), 68 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index cec989a3ee..1e9a25bfde 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -1684,44 +1684,51 @@ fn delegate_stack_stx_signer_key() {
     );
 }
 
+// In this test case, Alice delegates to Bob.
+//  Bob then stacks the delegated stx for one cycle with an
+//  'old' signer key. The next cycle, Bob extends the delegation
+//  & rotates to a 'new' signer key.
+//
+// This test asserts that the signing key in Alice's stacking state
+//  is equal to Bob's 'new' signer key.
 #[test]
 fn delegate_stack_stx_extend_signer_key() {
-    let lock_period: u128 = 2;
+    let lock_period: u128 = 1;
     let (burnchain, mut peer, keys, latest_block, block_height, mut coinbase_nonce) =
         prepare_pox4_test(function_name!(), None);
 
-    let mut stacker_nonce = 0;
-    let stacker_key = &keys[0];
-    let delegate_nonce = 0;
-    let delegate_key = &keys[1];
-    let delegate_principal = PrincipalData::from(key_to_stacks_addr(delegate_key));
-    let signer_private_key = &keys[2];
-    let signer_public_key = StacksPublicKey::from_private(signer_private_key);
-    let new_signer_private_key = &keys[3];
-    let new_signer_public_key = StacksPublicKey::from_private(new_signer_private_key);
+    let mut alice_nonce = 0;
+    let alice_stacker_key = &keys[0];
+    let bob_nonce = 0;
+    let bob_delegate_private_key = &keys[1];
+    let bob_delegate_principal = PrincipalData::from(key_to_stacks_addr(bob_delegate_private_key));
+    let bob_old_signer_private_key = &keys[2];
+    let bob_old_signer_public_key = StacksPublicKey::from_private(bob_old_signer_private_key);
+    let bob_new_signer_private_key = &keys[3];
+    let bob_new_signer_public_key = StacksPublicKey::from_private(bob_new_signer_private_key);
     let pox_addr = PoxAddress::from_legacy(
         AddressHashMode::SerializeP2PKH,
-        key_to_stacks_addr(delegate_key).bytes,
+        key_to_stacks_addr(bob_delegate_private_key).bytes,
     );
 
     let delegate_stx: StacksTransaction = make_pox_4_delegate_stx(
-        stacker_key,
-        stacker_nonce,
+        alice_stacker_key,
+        alice_nonce,
         100,
-        delegate_principal.clone().into(),
+        bob_delegate_principal.clone().into(),
         None,
         Some(pox_addr.clone()),
     );
 
     let delegate_stack_stx = make_pox_4_delegate_stack_stx(
-        delegate_key,
-        delegate_nonce,
-        PrincipalData::from(key_to_stacks_addr(stacker_key)).into(),
+        bob_delegate_private_key,
+        bob_nonce,
+        PrincipalData::from(key_to_stacks_addr(alice_stacker_key)).into(),
         100,
         pox_addr.clone(),
         block_height as u128,
         lock_period,
-        signer_public_key.clone(),
+        bob_old_signer_public_key.clone(),
     );
 
     // Initial txs arr includes initial delegate_stx & delegate_stack_stx
@@ -1733,7 +1740,7 @@ fn delegate_stack_stx_extend_signer_key() {
     let delegation_state = get_delegation_state_pox_4(
         &mut peer,
         &latest_block,
-        &key_to_stacks_addr(stacker_key).to_account_principal(),
+        &key_to_stacks_addr(alice_stacker_key).to_account_principal(),
     )
     .expect("No delegation state, delegate-stx failed")
     .expect_tuple();
@@ -1741,7 +1748,7 @@ fn delegate_stack_stx_extend_signer_key() {
     let stacking_state = get_stacking_state_pox_4(
         &mut peer,
         &latest_block,
-        &key_to_stacks_addr(stacker_key).to_account_principal(),
+        &key_to_stacks_addr(alice_stacker_key).to_account_principal(),
     )
     .expect("No stacking state, stack-stx failed")
     .expect_tuple();
@@ -1750,17 +1757,17 @@ fn delegate_stack_stx_extend_signer_key() {
     let state_signer_key = stacking_state.get("signer-key").unwrap();
     assert_eq!(
         state_signer_key,
-        &Value::buff_from(signer_public_key.to_bytes_compressed()).unwrap()
+        &Value::buff_from(bob_old_signer_public_key.to_bytes_compressed()).unwrap()
     );
 
-    stacker_nonce += 1;
+    alice_nonce += 1;
 
     let delegate_stack_extend = make_pox_4_delegate_stack_extend(
-        delegate_key,
-        stacker_nonce,
-        PrincipalData::from(key_to_stacks_addr(stacker_key)).into(),
+        bob_delegate_private_key,
+        alice_nonce,
+        PrincipalData::from(key_to_stacks_addr(alice_stacker_key)).into(),
         pox_addr.clone(),
-        new_signer_public_key.clone(),
+        bob_new_signer_public_key.clone(),
         1,
     );
 
@@ -1771,7 +1778,7 @@ fn delegate_stack_stx_extend_signer_key() {
     let new_stacking_state = get_stacking_state_pox_4(
         &mut peer,
         &latest_block,
-        &key_to_stacks_addr(stacker_key).to_account_principal(),
+        &key_to_stacks_addr(alice_stacker_key).to_account_principal(),
     )
     .unwrap()
     .expect_tuple();
@@ -1780,10 +1787,17 @@ fn delegate_stack_stx_extend_signer_key() {
     let state_signer_key_new = new_stacking_state.get("signer-key").unwrap();
     assert_eq!(
         state_signer_key_new,
-        &Value::buff_from(new_signer_public_key.to_bytes_compressed()).unwrap()
+        &Value::buff_from(bob_new_signer_public_key.to_bytes_compressed()).unwrap()
     );
 }
 
+// In this test case, Alice is a solo stacker-signer.
+//  Alice stacks the stacking minimum for two cycles.
+//  In the next cycle, Alice calls stack-increase to increase
+//  her total-locked by a second stacking minimum.
+//
+// This test asserts that Alice's total-locked is equal to
+//  twice the stacking minimum after calling stack-increase.
 #[test]
 fn stack_increase() {
     let lock_period = 2;
@@ -1791,24 +1805,24 @@ fn stack_increase() {
     let (burnchain, mut peer, keys, latest_block, block_height, mut coinbase_nonce) =
         prepare_pox4_test(function_name!(), Some(&observer));
 
-    let mut stacker_nonce = 0;
-    let stacker_key = &keys[0];
-    let stacker_address = key_to_stacks_addr(stacker_key);
-    let signer_private_key = &keys[1];
-    let signer_public_key = StacksPublicKey::from_private(signer_private_key);
+    let mut alice_nonce = 0;
+    let alice_stacking_private_key = &keys[0];
+    let alice_address = key_to_stacks_addr(alice_stacking_private_key);
+    let alice_signing_private_key = &keys[1];
+    let alice_signing_public_key = StacksPublicKey::from_private(alice_signing_private_key);
     let min_ustx = get_stacking_minimum(&mut peer, &latest_block);
     let pox_addr = PoxAddress::from_legacy(
         AddressHashMode::SerializeP2PKH,
-        key_to_stacks_addr(stacker_key).bytes,
+        key_to_stacks_addr(alice_stacking_private_key).bytes,
     );
 
     let stack_stx = make_pox_4_lockup(
-        stacker_key,
-        stacker_nonce,
+        alice_stacking_private_key,
+        alice_nonce,
         min_ustx,
         pox_addr.clone(),
         lock_period,
-        signer_public_key.clone(),
+        alice_signing_public_key.clone(),
         block_height as u64,
     );
 
@@ -1819,7 +1833,7 @@ fn stack_increase() {
     let stacking_state = get_stacking_state_pox_4(
         &mut peer,
         &latest_block,
-        &key_to_stacks_addr(stacker_key).to_account_principal(),
+        &key_to_stacks_addr(alice_stacking_private_key).to_account_principal(),
     )
     .expect("No stacking state, stack-stx failed")
     .expect_tuple();
@@ -1828,16 +1842,17 @@ fn stack_increase() {
     let state_signer_key = stacking_state.get("signer-key").unwrap();
     assert_eq!(
         state_signer_key,
-        &Value::buff_from(signer_public_key.to_bytes_compressed()).unwrap()
+        &Value::buff_from(alice_signing_public_key.to_bytes_compressed()).unwrap()
     );
 
-    stacker_nonce += 1;
+    alice_nonce += 1;
 
-    let stack_increase = make_pox_4_stack_increase(stacker_key, stacker_nonce, min_ustx);
+    let stack_increase =
+        make_pox_4_stack_increase(alice_stacking_private_key, alice_nonce, min_ustx);
     // Next tx arr includes a stack_increase pox_4 helper found in mod.rs
     let txs = vec![stack_increase];
     let latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
-    let stacker_transactions = get_last_block_sender_transactions(&observer, stacker_address);
+    let stacker_transactions = get_last_block_sender_transactions(&observer, alice_address);
 
     let actual_result = stacker_transactions
         .first()
@@ -1848,7 +1863,7 @@ fn stack_increase() {
         TupleData::from_data(vec![
             (
                 "stacker".into(),
-                Value::Principal(PrincipalData::from(stacker_address.clone())),
+                Value::Principal(PrincipalData::from(alice_address.clone())),
             ),
             ("total-locked".into(), Value::UInt(min_ustx * 2)),
         ])
@@ -1861,6 +1876,12 @@ fn stack_increase() {
     assert_eq!(actual_result, expected_result);
 }
 
+// In this test case, Alice delegates twice the stacking minimum to Bob.
+//  Bob stacks half of Alice's funds. In the next cycle,
+//  Bob stacks Alice's remaining funds.
+//
+// This test asserts that Alice's total-locked is equal to
+//  twice the stacking minimum after calling delegate-stack-increase.
 #[test]
 fn delegate_stack_increase() {
     let lock_period: u128 = 2;
@@ -1868,40 +1889,39 @@ fn delegate_stack_increase() {
     let (burnchain, mut peer, keys, latest_block, block_height, mut coinbase_nonce) =
         prepare_pox4_test(function_name!(), Some(&observer));
 
-    let mut stacker_nonce = 0;
-    let stacker_key = &keys[0];
-    let stacker_address =
-        PrincipalData::from(key_to_stacks_addr(stacker_key).to_account_principal());
-    let mut delegate_nonce = 0;
-    let delegate_key = &keys[1];
-    let delegate_address =
-        PrincipalData::from(key_to_stacks_addr(delegate_key).to_account_principal());
+    let alice_nonce = 0;
+    let alice_key = &keys[0];
+    let alice_address = PrincipalData::from(key_to_stacks_addr(alice_key).to_account_principal());
+    let mut bob_nonce = 0;
+    let bob_delegate_key = &keys[1];
+    let bob_delegate_address =
+        PrincipalData::from(key_to_stacks_addr(bob_delegate_key).to_account_principal());
     let min_ustx = get_stacking_minimum(&mut peer, &latest_block);
-    let signer_private_key = &keys[2];
-    let signer_public_key = StacksPublicKey::from_private(signer_private_key);
+    let bob_signer_private_key = &keys[2];
+    let bob_signer_public_key = StacksPublicKey::from_private(bob_signer_private_key);
     let pox_addr = PoxAddress::from_legacy(
         AddressHashMode::SerializeP2PKH,
-        key_to_stacks_addr(delegate_key).bytes,
+        key_to_stacks_addr(bob_delegate_key).bytes,
     );
 
     let delegate_stx = make_pox_4_delegate_stx(
-        stacker_key,
-        stacker_nonce,
+        alice_key,
+        alice_nonce,
         2 * min_ustx,
-        delegate_address.clone(),
+        bob_delegate_address.clone(),
         None,
         Some(pox_addr.clone()),
     );
 
     let delegate_stack_stx = make_pox_4_delegate_stack_stx(
-        delegate_key,
-        delegate_nonce,
-        PrincipalData::from(key_to_stacks_addr(stacker_key)).into(),
+        bob_delegate_key,
+        bob_nonce,
+        PrincipalData::from(key_to_stacks_addr(alice_key)).into(),
         min_ustx,
         pox_addr.clone(),
         block_height as u128,
         lock_period,
-        signer_public_key.clone(),
+        bob_signer_public_key.clone(),
     );
 
     // Initial tx arr includes a delegate_stx & delegate_stack_stx pox_4 helper found in mod.rs
@@ -1909,13 +1929,12 @@ fn delegate_stack_increase() {
 
     let latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
 
-    stacker_nonce += 1;
-    delegate_nonce += 1;
+    bob_nonce += 1;
 
     let delegate_increase = make_pox_4_delegate_stack_increase(
-        delegate_key,
-        delegate_nonce,
-        &stacker_address,
+        bob_delegate_key,
+        bob_nonce,
+        &alice_address,
         pox_addr.clone(),
         min_ustx,
     );
@@ -1926,7 +1945,7 @@ fn delegate_stack_increase() {
     let latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
 
     let delegate_transactions =
-        get_last_block_sender_transactions(&observer, delegate_address.into());
+        get_last_block_sender_transactions(&observer, bob_delegate_address.into());
 
     let actual_result = delegate_transactions
         .first()
@@ -1937,7 +1956,7 @@ fn delegate_stack_increase() {
         TupleData::from_data(vec![
             (
                 "stacker".into(),
-                Value::Principal(PrincipalData::from(stacker_address.clone())),
+                Value::Principal(PrincipalData::from(alice_address.clone())),
             ),
             ("total-locked".into(), Value::UInt(min_ustx * 2)),
         ])

From d744a8b0aa7a0341138365c90c550c33414f3454 Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Tue, 23 Jan 2024 07:33:28 -0500
Subject: [PATCH 0444/1166] addressing map to cloned refactor

---
 stackslib/src/chainstate/stacks/boot/pox_4_tests.rs | 10 ++--------
 1 file changed, 2 insertions(+), 8 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 1e9a25bfde..9bf94f2e89 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -1854,10 +1854,7 @@ fn stack_increase() {
     let latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
     let stacker_transactions = get_last_block_sender_transactions(&observer, alice_address);
 
-    let actual_result = stacker_transactions
-        .first()
-        .map(|tx| tx.result.clone())
-        .unwrap();
+    let actual_result = stacker_transactions.first().cloned().unwrap().result;
 
     let expected_result = Value::okay(Value::Tuple(
         TupleData::from_data(vec![
@@ -1947,10 +1944,7 @@ fn delegate_stack_increase() {
     let delegate_transactions =
         get_last_block_sender_transactions(&observer, bob_delegate_address.into());
 
-    let actual_result = delegate_transactions
-        .first()
-        .map(|tx| tx.result.clone())
-        .unwrap();
+    let actual_result = delegate_transactions.first().cloned().unwrap().result;
 
     let expected_result = Value::okay(Value::Tuple(
         TupleData::from_data(vec![

From 3da5768db8566921f2bc27a580415bac68137b56 Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Tue, 23 Jan 2024 13:10:00 -0500
Subject: [PATCH 0445/1166] fixed delegate-stack-extend signature

---
 stackslib/src/chainstate/stacks/boot/mod.rs     | 2 +-
 stackslib/src/chainstate/stacks/boot/pox-4.clar | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 16b8be74cc..da7c97634d 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -1864,8 +1864,8 @@ pub mod test {
             vec![
                 Value::Principal(stacker.clone()),
                 Value::Tuple(pox_addr.as_clarity_tuple().unwrap()),
-                Value::buff_from(signer_key.to_bytes_compressed()).unwrap(),
                 Value::UInt(extend_count),
+                Value::buff_from(signer_key.to_bytes_compressed()).unwrap(),
             ],
         )
         .unwrap();
diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index 777473676e..63e9f7272a 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -1158,8 +1158,8 @@
 (define-public (delegate-stack-extend
                     (stacker principal)
                     (pox-addr { version: (buff 1), hashbytes: (buff 32) })
-                    (signer-key (buff 33))
-                    (extend-count uint))
+                    (extend-count uint)
+                    (signer-key (buff 33)))
     (let ((stacker-info (stx-account stacker))
           ;; to extend, there must already be an entry in the stacking-state
           (stacker-state (unwrap! (get-stacker-info stacker) (err ERR_STACK_EXTEND_NOT_LOCKED)))

From 1337c5701dd415ee9bb1b24fb18704359acbbc87 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Tue, 16 Jan 2024 16:37:43 -0500
Subject: [PATCH 0446/1166] Enable approval or rejection of a block via
 signature nonce request message overwrite

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/runloop.rs | 97 +++++++++++++++++++++++++++---------
 1 file changed, 73 insertions(+), 24 deletions(-)

diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index f165546130..8c32cbfa59 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -24,12 +24,15 @@ use blockstack_lib::net::api::postblock_proposal::BlockValidateResponse;
 use blockstack_lib::util_lib::boot::boot_code_id;
 use hashbrown::{HashMap, HashSet};
 use libsigner::{SignerEvent, SignerRunLoop};
+use libstackerdb::StackerDBChunkData;
 use slog::{slog_debug, slog_error, slog_info, slog_warn};
-use stacks_common::codec::read_next;
+use stacks_common::codec::{read_next, StacksMessageCodec};
+use stacks_common::util::hash::Sha512Trunc256Sum;
 use stacks_common::{debug, error, info, warn};
 use wsts::common::MerkleRoot;
 use wsts::curve::ecdsa;
-use wsts::net::Packet;
+use wsts::curve::keys::PublicKey;
+use wsts::net::{Message, Packet};
 use wsts::state_machine::coordinator::fire::Coordinator as FireCoordinator;
 use wsts::state_machine::coordinator::{Config as CoordinatorConfig, Coordinator};
 use wsts::state_machine::signer::Signer;
@@ -90,6 +93,8 @@ pub struct RunLoop<C> {
     pub state: State,
     /// Wether mainnet or not
     pub mainnet: bool,
+    /// Bytes we agreed to sign in a particular signing round
+    pub messages: HashMap<u64, Vec<u8>>,
 }
 
 impl<C: Coordinator> RunLoop<C> {
@@ -199,9 +204,8 @@ impl<C: Coordinator> RunLoop<C> {
                 let (coordinator_id, _) = calculate_coordinator(&self.signing_round.public_keys);
                 if coordinator_id == self.signing_round.signer_id {
                     // We are the coordinator. Trigger a signing round for this block
-                    let signature_hash = block_validate_ok.block.header.signature_hash().expect("BUG: Stacks node should never return a validated block with an invalid signature hash");
                     self.commands.push_back(RunLoopCommand::Sign {
-                        message: signature_hash.0.to_vec(),
+                        message: block_validate_ok.block.serialize_to_vec(),
                         is_taproot: false,
                         merkle_root: None,
                     });
@@ -237,27 +241,8 @@ impl<C: Coordinator> RunLoop<C> {
         let inbound_messages: Vec<Packet> = stackerdb_chunk_event
             .modified_slots
             .iter()
-            .filter_map(|chunk| {
-                // We only care about verified wsts packets. Ignore anything else
-                let signer_message = bincode::deserialize::<SignerMessage>(&chunk.data).ok()?;
-                let packet = match signer_message {
-                    SignerMessage::Packet(packet) => packet,
-                    _ => return None, // This is a message for miners to observe. Ignore it.
-                };
-                if packet.verify(&self.signing_round.public_keys, &coordinator_public_key) {
-                    debug!("Verified wsts packet: {:?}", &packet);
-                    Some(packet)
-                } else {
-                    None
-                }
-            })
+            .filter_map(|chunk| self.verify_chunk(chunk, &coordinator_public_key))
             .collect();
-
-        // First process all messages as a signer
-        // TODO: deserialize the packet into a block and verify its contents
-        // TODO: we need to be able to sign yes or no on a block...this needs to propogate
-        // to the singning round/coordinator that we are signing yes or no on a block
-        // self.verify_block_transactions(&block);
         let signer_outbound_messages = self
             .signing_round
             .process_inbound_messages(&inbound_messages)
@@ -300,6 +285,69 @@ impl<C: Coordinator> RunLoop<C> {
         }
     }
 
+    /// Helper function to verify a chunk is a valid wsts packet.
+    /// Note if the chunk is a NonceRequest for a block proposal, we will sign the block hash with an optional byte indicating a vote no if appropriate.
+    fn verify_chunk(
+        &mut self,
+        chunk: &StackerDBChunkData,
+        coordinator_public_key: &PublicKey,
+    ) -> Option<Packet> {
+        // We only care about verified wsts packets. Ignore anything else
+        let signer_message = bincode::deserialize::<SignerMessage>(&chunk.data).ok()?;
+        let mut packet = match signer_message {
+            SignerMessage::Packet(packet) => packet,
+            _ => return None, // This is a message for miners to observe. Ignore it.
+        };
+        if packet.verify(&self.signing_round.public_keys, coordinator_public_key) {
+            match &mut packet.msg {
+                Message::SignatureShareRequest(request) => {
+                    // A coordinator could have sent a signature share request with a different message than we agreed to sign
+                    // Either another message won majority or the coordinator is trying to cheat...Overwrite with our agreed upon value
+                    if let Some(message) = self.messages.remove(&request.sign_id) {
+                        request.message = message;
+                    }
+                    Some(packet)
+                }
+                Message::NonceRequest(request) => {
+                    // This is a Nonce Request...check if it is for a block proposal...
+                    let mut ptr = &request.message[..];
+                    let Some(block) = read_next::<NakamotoBlock, _>(&mut ptr).ok() else {
+                        debug!("Received a nonce request for an unknown message stream. Signing the nonce request as is.");
+                        return Some(packet);
+                    };
+                    let mut sign_message = block
+                        .header
+                        .signature_hash()
+                        .unwrap_or(Sha512Trunc256Sum::from_data(&[]))
+                        .0
+                        .to_vec();
+                    if !self.verify_block(&block) {
+                        // We don't like this block. Update the request to be across its hash with a byte indicating a vote no.
+                        debug!("Signing the block hash with a vote no.");
+                        sign_message.push(b'n');
+                    } else {
+                        debug!("Nothing to change...");
+                    }
+                    //Cache what we agreed to sign
+                    request.message = sign_message;
+                    Some(packet)
+                }
+                _ => Some(packet),
+            }
+        } else {
+            debug!("Failed to verify wsts packet: {:?}", &packet);
+            None
+        }
+    }
+
+    /// Helper function to verify a blocks contents
+    fn verify_block(&self, _block: &NakamotoBlock) -> bool {
+        // TODO: update to verify the block contents
+        // Check that we received a block proposal response that validated the current block. If not, we vote no.
+        // Check that it contains the necessary stacks transactions
+        true
+    }
+
     /// Helper function to extract block proposals from signature results and braodcast them to the stackerdb slot
     fn send_block_response_messages(&mut self, _operation_results: &[OperationResult]) {
         //TODO: Deserialize the signature result and broadcast an appropriate Reject or Approval message to stackerdb
@@ -415,6 +463,7 @@ impl From<&Config> for RunLoop<FireCoordinator<v2::Aggregator>> {
             commands: VecDeque::new(),
             state: State::Uninitialized,
             mainnet: config.network == Network::Mainnet,
+            messages: HashMap::new(),
         }
     }
 }

From 38d5a27f874c2e30647e41016e375378625fb312 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 19 Jan 2024 14:44:49 -0800
Subject: [PATCH 0447/1166] Broadcast block submissions in failure and success
 cases

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 Cargo.lock                              |   1 +
 stacks-signer/src/client/stackerdb.rs   |  36 ++-
 stacks-signer/src/runloop.rs            | 279 +++++++++++++++++++-----
 testnet/stacks-node/Cargo.toml          |   1 +
 testnet/stacks-node/src/tests/signer.rs |  38 +++-
 5 files changed, 292 insertions(+), 63 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 205c428b80..95607554c6 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3546,6 +3546,7 @@ dependencies = [
  "async-std",
  "backtrace",
  "base64 0.12.3",
+ "bincode",
  "chrono",
  "clarity",
  "hashbrown 0.14.0",
diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index c6c1a6e366..431c772e50 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -13,7 +13,6 @@
 //
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
-use blockstack_lib::burnchains::Txid;
 use blockstack_lib::chainstate::nakamoto::NakamotoBlock;
 use blockstack_lib::net::api::postblock_proposal::{BlockValidateReject, ValidateRejectCode};
 use clarity::vm::types::QualifiedContractIdentifier;
@@ -78,6 +77,17 @@ pub struct BlockRejection {
     pub block: NakamotoBlock,
 }
 
+impl BlockRejection {
+    /// Create a new BlockRejection for the provided block and reason code
+    pub fn new(block: NakamotoBlock, reason_code: RejectCode) -> Self {
+        Self {
+            reason: reason_code.to_string(),
+            reason_code,
+            block,
+        }
+    }
+}
+
 impl From<BlockValidateReject> for BlockRejection {
     fn from(reject: BlockValidateReject) -> Self {
         Self {
@@ -94,8 +104,22 @@ impl From<BlockValidateReject> for BlockRejection {
 pub enum RejectCode {
     /// RPC endpoint Validation failed
     ValidationFailed(ValidateRejectCode),
-    /// Missing expected transactions
-    MissingTransactions(Vec<Txid>),
+    /// Signers signed a block rejection
+    SignedRejection,
+    /// Invalid signature hash
+    InvalidSignatureHash,
+}
+
+impl std::fmt::Display for RejectCode {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        match self {
+            RejectCode::ValidationFailed(code) => write!(f, "Validation failed: {:?}", code),
+            RejectCode::SignedRejection => {
+                write!(f, "A threshold number of signers rejected the block.")
+            }
+            RejectCode::InvalidSignatureHash => write!(f, "The signature hash was invalid."),
+        }
+    }
 }
 
 impl From<Packet> for SignerMessage {
@@ -116,6 +140,12 @@ impl From<BlockRejection> for SignerMessage {
     }
 }
 
+impl From<BlockValidateReject> for SignerMessage {
+    fn from(rejection: BlockValidateReject) -> Self {
+        Self::BlockResponse(BlockResponse::Rejected(rejection.into()))
+    }
+}
+
 impl SignerMessage {
     /// Helper function to determine the slot ID for the provided stacker-db writer id
     pub fn slot_id(&self, id: u32) -> u32 {
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 8c32cbfa59..736fc9c13c 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -17,9 +17,11 @@ use std::collections::VecDeque;
 use std::sync::mpsc::Sender;
 use std::time::Duration;
 
+use blockstack_lib::burnchains::Txid;
 use blockstack_lib::chainstate::nakamoto::NakamotoBlock;
 use blockstack_lib::chainstate::stacks::boot::MINERS_NAME;
 use blockstack_lib::chainstate::stacks::events::StackerDBChunksEvent;
+use blockstack_lib::chainstate::stacks::ThresholdSignature;
 use blockstack_lib::net::api::postblock_proposal::BlockValidateResponse;
 use blockstack_lib::util_lib::boot::boot_code_id;
 use hashbrown::{HashMap, HashSet};
@@ -32,7 +34,7 @@ use stacks_common::{debug, error, info, warn};
 use wsts::common::MerkleRoot;
 use wsts::curve::ecdsa;
 use wsts::curve::keys::PublicKey;
-use wsts::net::{Message, Packet};
+use wsts::net::{Message, NonceRequest, Packet, SignatureShareRequest};
 use wsts::state_machine::coordinator::fire::Coordinator as FireCoordinator;
 use wsts::state_machine::coordinator::{Config as CoordinatorConfig, Coordinator};
 use wsts::state_machine::signer::Signer;
@@ -40,8 +42,8 @@ use wsts::state_machine::{OperationResult, PublicKeys};
 use wsts::v2;
 
 use crate::client::{
-    retry_with_exponential_backoff, BlockRejection, ClientError, SignerMessage, StackerDB,
-    StacksClient,
+    retry_with_exponential_backoff, BlockRejection, BlockResponse, ClientError, RejectCode,
+    SignerMessage, StackerDB, StacksClient,
 };
 use crate::config::{Config, Network};
 
@@ -75,6 +77,16 @@ pub enum State {
     Sign,
 }
 
+/// Additional Info about a proposed block
+pub struct BlockInfo {
+    /// The block we are considering
+    block: NakamotoBlock,
+    /// Our vote on the block if we have one yet
+    vote: Option<Vec<u8>>,
+    /// Whether the block contents are valid
+    valid: bool,
+}
+
 /// The runloop for the stacks signer
 pub struct RunLoop<C> {
     /// The timeout for events
@@ -93,8 +105,10 @@ pub struct RunLoop<C> {
     pub state: State,
     /// Wether mainnet or not
     pub mainnet: bool,
-    /// Bytes we agreed to sign in a particular signing round
-    pub messages: HashMap<u64, Vec<u8>>,
+    /// Observed blocks that we have seen so far
+    pub blocks: HashMap<Vec<u8>, BlockInfo>,
+    /// Transactions that we expect to see in the next block
+    pub transactions: Vec<Txid>,
 }
 
 impl<C: Coordinator> RunLoop<C> {
@@ -200,9 +214,23 @@ impl<C: Coordinator> RunLoop<C> {
     fn handle_block_validate_response(&mut self, block_validate_response: BlockValidateResponse) {
         match block_validate_response {
             BlockValidateResponse::Ok(block_validate_ok) => {
-                // This is a valid block proposal from the miner. Trigger a signing round for it.
+                self.blocks
+                    .entry(
+                        block_validate_ok
+                            .block
+                            .header
+                            .signature_hash()
+                            .unwrap_or(Sha512Trunc256Sum::from_data(&[]))
+                            .0
+                            .to_vec(),
+                    )
+                    .and_modify(|block_info| {
+                        block_info.valid = true;
+                    });
+                // This is a valid block proposal from the miner. Trigger a signing round for it if we are the coordinator
                 let (coordinator_id, _) = calculate_coordinator(&self.signing_round.public_keys);
                 if coordinator_id == self.signing_round.signer_id {
+                    debug!("Received a valid block proposal from the miner: {:?}\n Triggering a signing round over it...", block_validate_ok.block);
                     // We are the coordinator. Trigger a signing round for this block
                     self.commands.push_back(RunLoopCommand::Sign {
                         message: block_validate_ok.block.serialize_to_vec(),
@@ -212,17 +240,30 @@ impl<C: Coordinator> RunLoop<C> {
                 }
             }
             BlockValidateResponse::Reject(block_validate_reject) => {
-                warn!(
-                    "Received a block proposal that was rejected by the stacks node: {:?}",
+                // There is no point in triggering a sign round for this block if validation failed from the stacks node
+                debug!(
+                    "Received a block proposal that was rejected by the stacks node: {:?}\n. Broadcasting a rejection...",
                     block_validate_reject
                 );
+                self.blocks
+                    .entry(
+                        block_validate_reject
+                            .block
+                            .header
+                            .signature_hash()
+                            .unwrap_or(Sha512Trunc256Sum::from_data(&[]))
+                            .0
+                            .to_vec(),
+                    )
+                    .and_modify(|block_info| {
+                        block_info.valid = false;
+                    });
                 // Submit a rejection response to the .signers contract for miners
-                // to observe so they know to ignore it and to prove signers are doing work
-                let block_rejection = BlockRejection::from(block_validate_reject);
-                if let Err(e) = self
-                    .stackerdb
-                    .send_message_with_retry(self.signing_round.signer_id, block_rejection.into())
-                {
+                // to observe so they know to send another block and to prove signers are doing work);
+                if let Err(e) = self.stackerdb.send_message_with_retry(
+                    self.signing_round.signer_id,
+                    block_validate_reject.into(),
+                ) {
                     warn!("Failed to send block rejection to stacker-db: {:?}", e);
                 }
             }
@@ -274,9 +315,28 @@ impl<C: Coordinator> RunLoop<C> {
                 warn!("Received an unrecognized message type from .miners stacker-db slot id {}: {:?}", chunk.slot_id, ptr);
                 continue;
             };
-            //TODO: trigger the signing round here instead. Then deserialize the block and call the validation as you validate its contents
-            // https://github.com/stacks-network/stacks-core/issues/3930
-            // Received a block proposal from the miner. Submit it for verification.
+            let Ok(hash) = block.header.signature_hash() else {
+                warn!("Received a block proposal with an invalid signature hash. Broadcasting a block rejection...");
+                let block_rejection = BlockRejection::new(block, RejectCode::InvalidSignatureHash);
+                    // Submit signature result to miners to observe
+                    if let Err(e) = self
+                    .stackerdb
+                    .send_message_with_retry(self.signing_round.signer_id, block_rejection.into())
+                {
+                    warn!("Failed to send block submission to stacker-db: {:?}", e);
+                }
+                continue;
+            };
+            let hash_bytes = hash.0.to_vec();
+            // Store the block in our cache
+            self.blocks.insert(
+                hash_bytes,
+                BlockInfo {
+                    vote: None,
+                    valid: false,
+                    block: block.clone(),
+                },
+            );
             self.stacks_client
                 .submit_block_for_validation(block)
                 .unwrap_or_else(|e| {
@@ -285,8 +345,93 @@ impl<C: Coordinator> RunLoop<C> {
         }
     }
 
+    /// Helper function to validate a signature share request, updating its message where appropriate.
+    /// If the request is for a block it has already agreed to sign, it will overwrite the message with the agreed upon value
+    /// Returns whether the request is valid or not.
+    fn validate_signature_share_request(&self, request: &mut SignatureShareRequest) -> bool {
+        // A coordinator could have sent a signature share request with a different message than we agreed to sign
+        match self
+            .blocks
+            .get(&request.message)
+            .map(|block_info| &block_info.vote)
+        {
+            Some(Some(vote)) => {
+                // Overwrite with our agreed upon value in case another message won majority or the coordinator is trying to cheat...
+                request.message = vote.clone();
+                true
+            }
+            Some(None) => {
+                // We have seen this block before, but we have not agreed to sign it. TODO: ignore it
+                debug!("Received a signature share request for a block we have not validated yet.");
+                false
+            }
+            None => {
+                // We have not seen this block before.
+                // TODO: should probably ignore any messages that are not either sBTC transactons or Nakamoto blocks. Leave now for abitrary message signing
+                debug!("Received a signature share request for an unknown message stream. Signing it as is...");
+                true
+            }
+        }
+    }
+
+    /// Helper function to validate a nonce request, updating its message appropriately.
+    /// Note that if the request is for a block, we will update the request message
+    /// as either a hash indicating a vote no or the signature hash indicating a vote yes
+    /// Returns whether the request is valid or not
+    fn validate_nonce_request(&mut self, request: &mut NonceRequest) -> bool {
+        let mut ptr = &request.message[..];
+        let Some(block) = read_next::<NakamotoBlock, _>(&mut ptr).ok() else {
+            // TODO: we should probably reject requests to sign things that are not blocks or transactions (leave for now to enable testing abitrary signing)
+            warn!("Received a nonce request for an unknown message stream. Signing the nonce request as is.");
+            return true;
+        };
+        let Ok(hash) = block.header.signature_hash() else {
+            debug!("Received a nonce request for a block with an invalid signature hash. Ignore it.");
+            return false;
+        };
+        let mut hash_bytes = hash.0.to_vec();
+        let transactions = &self.transactions;
+        let block_info = self.blocks.entry(hash_bytes.clone()).or_insert(BlockInfo {
+            vote: None,
+            valid: false,
+            block: block.clone(),
+        });
+        // Validate the block contents
+        block_info.valid = Self::validate_block(block_info, transactions);
+        if !block_info.valid {
+            // We don't like this block. Update the request to be across its hash with a byte indicating a vote no.
+            debug!("Updating the request with a block hash with a vote no.");
+            hash_bytes.push(b'n');
+        } else {
+            debug!("The block passed validation. Update the request with the signature hash.");
+        }
+        // Cache our vote
+        block_info.vote = Some(hash_bytes.clone());
+        request.message = hash_bytes;
+        true
+    }
+
+    /// Helper function to validate a block's contents
+    fn validate_block(block_info: &BlockInfo, transactions: &[Txid]) -> bool {
+        if !block_info.valid {
+            return false;
+        }
+        // Ensure the block contains the transactions we care about
+        // TODO: add cast_aggregate_public_key to the list of transactions we care about.
+        // This will also need to be flushed from the cache once these transactions are in a signed block
+        for txid in transactions {
+            if block_info.block.txs.iter().any(|tx| &tx.txid() == txid) {
+                return false;
+            }
+        }
+        true
+    }
+
     /// Helper function to verify a chunk is a valid wsts packet.
-    /// Note if the chunk is a NonceRequest for a block proposal, we will sign the block hash with an optional byte indicating a vote no if appropriate.
+    /// NOTE: The packet will be updated if the signer wishes to respond to NonceRequest
+    /// and SignatureShareRequests with a different message than what the coordinator originally sent.
+    /// This is done to prevent a malicious coordinator from sending a different message than what was
+    /// agreed upon and to support the case where the signer wishes to reject a block by voting no
     fn verify_chunk(
         &mut self,
         chunk: &StackerDBChunkData,
@@ -301,57 +446,76 @@ impl<C: Coordinator> RunLoop<C> {
         if packet.verify(&self.signing_round.public_keys, coordinator_public_key) {
             match &mut packet.msg {
                 Message::SignatureShareRequest(request) => {
-                    // A coordinator could have sent a signature share request with a different message than we agreed to sign
-                    // Either another message won majority or the coordinator is trying to cheat...Overwrite with our agreed upon value
-                    if let Some(message) = self.messages.remove(&request.sign_id) {
-                        request.message = message;
+                    if !self.validate_signature_share_request(request) {
+                        return None;
                     }
-                    Some(packet)
                 }
                 Message::NonceRequest(request) => {
-                    // This is a Nonce Request...check if it is for a block proposal...
-                    let mut ptr = &request.message[..];
-                    let Some(block) = read_next::<NakamotoBlock, _>(&mut ptr).ok() else {
-                        debug!("Received a nonce request for an unknown message stream. Signing the nonce request as is.");
-                        return Some(packet);
-                    };
-                    let mut sign_message = block
-                        .header
-                        .signature_hash()
-                        .unwrap_or(Sha512Trunc256Sum::from_data(&[]))
-                        .0
-                        .to_vec();
-                    if !self.verify_block(&block) {
-                        // We don't like this block. Update the request to be across its hash with a byte indicating a vote no.
-                        debug!("Signing the block hash with a vote no.");
-                        sign_message.push(b'n');
-                    } else {
-                        debug!("Nothing to change...");
+                    if !self.validate_nonce_request(request) {
+                        return None;
                     }
-                    //Cache what we agreed to sign
-                    request.message = sign_message;
-                    Some(packet)
                 }
-                _ => Some(packet),
+                _ => {
+                    // Nothing to do for other message types
+                }
             }
+            Some(packet)
         } else {
             debug!("Failed to verify wsts packet: {:?}", &packet);
             None
         }
     }
 
-    /// Helper function to verify a blocks contents
-    fn verify_block(&self, _block: &NakamotoBlock) -> bool {
-        // TODO: update to verify the block contents
-        // Check that we received a block proposal response that validated the current block. If not, we vote no.
-        // Check that it contains the necessary stacks transactions
-        true
-    }
-
     /// Helper function to extract block proposals from signature results and braodcast them to the stackerdb slot
-    fn send_block_response_messages(&mut self, _operation_results: &[OperationResult]) {
-        //TODO: Deserialize the signature result and broadcast an appropriate Reject or Approval message to stackerdb
-        // https://github.com/stacks-network/stacks-core/issues/3930
+    fn send_block_response_messages(&mut self, operation_results: &[OperationResult]) {
+        let Some(aggregate_public_key) = &self
+            .coordinator
+            .get_aggregate_public_key() else {
+            debug!("No aggregate public key set. Cannot validate results. Ignoring signature results...");
+            return;
+        };
+        //Deserialize the signature result and broadcast an appropriate Reject or Approval message to stackerdb
+        for operation_result in operation_results {
+            // Signers only every trigger non-taproot signing rounds over blocks. Ignore SignTaproot results
+            if let OperationResult::Sign(signature) = operation_result {
+                let message = self.coordinator.get_message();
+                if !signature.verify(aggregate_public_key, &message) {
+                    debug!("Received a signature result for a block that was not signed by the aggregate public key...Ignoring");
+                    continue;
+                }
+
+                let Some(block_info) = self.blocks.remove(&message) else {
+                    debug!("Received a signature result for a block we have not seen before. Ignoring...");
+                    continue;
+                };
+
+                // Update the block signature hash with what the signers produced.
+                let mut block = block_info.block;
+                block.header.signer_signature = ThresholdSignature(signature.clone());
+
+                let block_submission = if block
+                    .header
+                    .signature_hash()
+                    .unwrap_or(Sha512Trunc256Sum::from_data(&[]))
+                    .0
+                    .to_vec()
+                    == message
+                {
+                    // we agreed to sign the block hash. Return an approval message
+                    BlockResponse::Accepted(block).into()
+                } else {
+                    // We signed a rejection message. Return a rejection message
+                    BlockRejection::new(block, RejectCode::SignedRejection).into()
+                };
+                // Submit signature result to miners to observe
+                if let Err(e) = self
+                    .stackerdb
+                    .send_message_with_retry(self.signing_round.signer_id, block_submission)
+                {
+                    warn!("Failed to send block submission to stacker-db: {:?}", e);
+                }
+            }
+        }
     }
 
     /// Helper function to send operation results across the provided channel
@@ -463,7 +627,8 @@ impl From<&Config> for RunLoop<FireCoordinator<v2::Aggregator>> {
             commands: VecDeque::new(),
             state: State::Uninitialized,
             mainnet: config.network == Network::Mainnet,
-            messages: HashMap::new(),
+            blocks: HashMap::new(),
+            transactions: Vec::new(),
         }
     }
 }
diff --git a/testnet/stacks-node/Cargo.toml b/testnet/stacks-node/Cargo.toml
index 1647766d29..bdd8bc35db 100644
--- a/testnet/stacks-node/Cargo.toml
+++ b/testnet/stacks-node/Cargo.toml
@@ -44,6 +44,7 @@ stacks-signer = { path = "../../stacks-signer" }
 tracing = "0.1.37"
 tracing-subscriber = { version = "0.3.17", features = ["env-filter"] }
 wsts = {workspace = true}
+bincode = "1.3.3"
 
 [dependencies.rusqlite]
 version = "=0.24.2"
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index 08a928d092..2aea176879 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -8,11 +8,11 @@ use clarity::vm::types::QualifiedContractIdentifier;
 use libsigner::{RunningSigner, Signer, SignerEventReceiver};
 use stacks::chainstate::coordinator::comm::CoordinatorChannels;
 use stacks::chainstate::stacks::boot::MINERS_NAME;
-use stacks::chainstate::stacks::StacksPrivateKey;
+use stacks::chainstate::stacks::{StacksPrivateKey, ThresholdSignature};
 use stacks::net::api::postblock_proposal::BlockValidateResponse;
 use stacks::util_lib::boot::boot_code_id;
 use stacks_common::types::chainstate::{StacksAddress, StacksPublicKey};
-use stacks_signer::client::SIGNER_SLOTS_PER_USER;
+use stacks_signer::client::{BlockResponse, SignerMessage, SIGNER_SLOTS_PER_USER};
 use stacks_signer::config::{Config as SignerConfig, Network};
 use stacks_signer::runloop::RunLoopCommand;
 use stacks_signer::utils::{build_signer_config_tomls, build_stackerdb_contract};
@@ -526,7 +526,7 @@ fn stackerdb_block_proposal() {
         thread::sleep(Duration::from_secs(1));
     }
     let validate_responses = test_observer::get_proposal_responses();
-    let proposed_block = match validate_responses.first().expect("No block proposal") {
+    let mut proposed_block = match validate_responses.first().expect("No block proposal") {
         BlockValidateResponse::Ok(block_validated) => block_validated.block.clone(),
         _ => panic!("Unexpected response"),
     };
@@ -538,5 +538,37 @@ fn stackerdb_block_proposal() {
         signature.verify(&aggregate_public_key, signature_hash.0.as_slice()),
         "Signature verification failed"
     );
+    // Verify that the signers broadcasted a signed NakamotoBlock back to the .signers contract
+    let t_start = std::time::Instant::now();
+    let mut chunk = None;
+    while chunk.is_none() {
+        assert!(
+            t_start.elapsed() < Duration::from_secs(30),
+            "Timed out while waiting for signers block response stacker db event"
+        );
+        thread::sleep(Duration::from_secs(1));
+
+        let nakamoto_blocks = test_observer::get_stackerdb_chunks();
+        for event in nakamoto_blocks {
+            // The tenth slot is the miners block slot
+            for slot in event.modified_slots {
+                if slot.slot_id == 10 {
+                    chunk = Some(slot.data);
+                    break;
+                }
+            }
+            if chunk.is_some() {
+                break;
+            }
+        }
+    }
+    let chunk = chunk.unwrap();
+    let signer_message = bincode::deserialize::<SignerMessage>(&chunk).unwrap();
+    if let SignerMessage::BlockResponse(BlockResponse::Accepted(block)) = signer_message {
+        proposed_block.header.signer_signature = ThresholdSignature(signature);
+        assert_eq!(block, proposed_block);
+    } else {
+        panic!("Received unexpected message");
+    }
     signer_test.shutdown();
 }

From 568b72873ce405c51c39cd14eecd4b379d7a4bfb Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 19 Jan 2024 15:17:28 -0800
Subject: [PATCH 0448/1166] CRC: use sha512Trunc256Sum for block hash and fix
 deserialization of it to remove extra byte if needed

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/runloop.rs | 66 +++++++++++++++++++-----------------
 1 file changed, 34 insertions(+), 32 deletions(-)

diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 736fc9c13c..a06bf2a3ae 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -106,7 +106,7 @@ pub struct RunLoop<C> {
     /// Wether mainnet or not
     pub mainnet: bool,
     /// Observed blocks that we have seen so far
-    pub blocks: HashMap<Vec<u8>, BlockInfo>,
+    pub blocks: HashMap<Sha512Trunc256Sum, BlockInfo>,
     /// Transactions that we expect to see in the next block
     pub transactions: Vec<Txid>,
 }
@@ -220,9 +220,7 @@ impl<C: Coordinator> RunLoop<C> {
                             .block
                             .header
                             .signature_hash()
-                            .unwrap_or(Sha512Trunc256Sum::from_data(&[]))
-                            .0
-                            .to_vec(),
+                            .unwrap_or(Sha512Trunc256Sum::from_data(&[])),
                     )
                     .and_modify(|block_info| {
                         block_info.valid = true;
@@ -251,9 +249,7 @@ impl<C: Coordinator> RunLoop<C> {
                             .block
                             .header
                             .signature_hash()
-                            .unwrap_or(Sha512Trunc256Sum::from_data(&[]))
-                            .0
-                            .to_vec(),
+                            .unwrap_or(Sha512Trunc256Sum::from_data(&[])),
                     )
                     .and_modify(|block_info| {
                         block_info.valid = false;
@@ -310,9 +306,8 @@ impl<C: Coordinator> RunLoop<C> {
     // Handle the stackerdb chunk event as a miner message
     fn handle_stackerdb_chunk_event_miners(&mut self, stackerdb_chunk_event: StackerDBChunksEvent) {
         for chunk in &stackerdb_chunk_event.modified_slots {
-            let mut ptr = &chunk.data[..];
-            let Some(block) = read_next::<NakamotoBlock, _>(&mut ptr).ok() else {
-                warn!("Received an unrecognized message type from .miners stacker-db slot id {}: {:?}", chunk.slot_id, ptr);
+            let Some(block) = read_next::<NakamotoBlock, _>(&mut &chunk.data[..]).ok() else {
+                warn!("Received an unrecognized message type from .miners stacker-db slot id {}: {:?}", chunk.slot_id, chunk.data);
                 continue;
             };
             let Ok(hash) = block.header.signature_hash() else {
@@ -327,10 +322,9 @@ impl<C: Coordinator> RunLoop<C> {
                 }
                 continue;
             };
-            let hash_bytes = hash.0.to_vec();
             // Store the block in our cache
             self.blocks.insert(
-                hash_bytes,
+                hash,
                 BlockInfo {
                     vote: None,
                     valid: false,
@@ -350,11 +344,17 @@ impl<C: Coordinator> RunLoop<C> {
     /// Returns whether the request is valid or not.
     fn validate_signature_share_request(&self, request: &mut SignatureShareRequest) -> bool {
         // A coordinator could have sent a signature share request with a different message than we agreed to sign
-        match self
-            .blocks
-            .get(&request.message)
-            .map(|block_info| &block_info.vote)
-        {
+        // This jankiness is because a coordinator could have sent a hash + 'n' byte and we need to pop that off...
+        // For now, if we have seen a message that is over a non hash, we will just sign it anyway so this is fine..
+        // TODO: fix this jankiness
+        let message = if request.message.len() == 32 {
+            &request.message[..32]
+        } else {
+            &request.message
+        };
+        let message =
+            Sha512Trunc256Sum::from_bytes(message).unwrap_or(Sha512Trunc256Sum::from_data(&[]));
+        match self.blocks.get(&message).map(|block_info| &block_info.vote) {
             Some(Some(vote)) => {
                 // Overwrite with our agreed upon value in case another message won majority or the coordinator is trying to cheat...
                 request.message = vote.clone();
@@ -379,8 +379,7 @@ impl<C: Coordinator> RunLoop<C> {
     /// as either a hash indicating a vote no or the signature hash indicating a vote yes
     /// Returns whether the request is valid or not
     fn validate_nonce_request(&mut self, request: &mut NonceRequest) -> bool {
-        let mut ptr = &request.message[..];
-        let Some(block) = read_next::<NakamotoBlock, _>(&mut ptr).ok() else {
+        let Some(block) = read_next::<NakamotoBlock, _>(&mut &request.message[..]).ok() else {
             // TODO: we should probably reject requests to sign things that are not blocks or transactions (leave for now to enable testing abitrary signing)
             warn!("Received a nonce request for an unknown message stream. Signing the nonce request as is.");
             return true;
@@ -389,13 +388,13 @@ impl<C: Coordinator> RunLoop<C> {
             debug!("Received a nonce request for a block with an invalid signature hash. Ignore it.");
             return false;
         };
-        let mut hash_bytes = hash.0.to_vec();
         let transactions = &self.transactions;
-        let block_info = self.blocks.entry(hash_bytes.clone()).or_insert(BlockInfo {
+        let block_info = self.blocks.entry(hash).or_insert(BlockInfo {
             vote: None,
             valid: false,
             block: block.clone(),
         });
+        let mut hash_bytes = hash.0.to_vec();
         // Validate the block contents
         block_info.valid = Self::validate_block(block_info, transactions);
         if !block_info.valid {
@@ -480,11 +479,20 @@ impl<C: Coordinator> RunLoop<C> {
             if let OperationResult::Sign(signature) = operation_result {
                 let message = self.coordinator.get_message();
                 if !signature.verify(aggregate_public_key, &message) {
-                    debug!("Received a signature result for a block that was not signed by the aggregate public key...Ignoring");
+                    warn!("Received an invalid signature result.");
                     continue;
                 }
-
-                let Some(block_info) = self.blocks.remove(&message) else {
+                // This jankiness is because a coordinator could have signed a rejection we need to find the underlying block hash
+                let block_hash_bytes = if message.len() > 32 {
+                    &message[..32]
+                } else {
+                    &message
+                };
+                let Some(block_hash) = Sha512Trunc256Sum::from_bytes(block_hash_bytes) else {
+                    debug!("Received a signature result for a signature over a non-block. Nothing to broadcast.");
+                    continue;
+                };
+                let Some(block_info) = self.blocks.remove(&block_hash) else {
                     debug!("Received a signature result for a block we have not seen before. Ignoring...");
                     continue;
                 };
@@ -493,20 +501,14 @@ impl<C: Coordinator> RunLoop<C> {
                 let mut block = block_info.block;
                 block.header.signer_signature = ThresholdSignature(signature.clone());
 
-                let block_submission = if block
-                    .header
-                    .signature_hash()
-                    .unwrap_or(Sha512Trunc256Sum::from_data(&[]))
-                    .0
-                    .to_vec()
-                    == message
-                {
+                let block_submission = if message == block_hash.0.to_vec() {
                     // we agreed to sign the block hash. Return an approval message
                     BlockResponse::Accepted(block).into()
                 } else {
                     // We signed a rejection message. Return a rejection message
                     BlockRejection::new(block, RejectCode::SignedRejection).into()
                 };
+
                 // Submit signature result to miners to observe
                 if let Err(e) = self
                     .stackerdb

From 17638dea227ff2bb6a73c6f501b63b3f619a87d7 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Mon, 22 Jan 2024 06:59:41 -0800
Subject: [PATCH 0449/1166] Add todo for storing a nonce request on the side

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/runloop.rs | 163 ++++++++++++++++++++++-------------
 1 file changed, 101 insertions(+), 62 deletions(-)

diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index a06bf2a3ae..42f77935b6 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -84,7 +84,18 @@ pub struct BlockInfo {
     /// Our vote on the block if we have one yet
     vote: Option<Vec<u8>>,
     /// Whether the block contents are valid
-    valid: bool,
+    valid: Option<bool>,
+}
+
+impl BlockInfo {
+    /// Create a new BlockInfo
+    pub fn new(block: NakamotoBlock) -> Self {
+        Self {
+            block,
+            vote: None,
+            valid: None,
+        }
+    }
 }
 
 /// The runloop for the stacks signer
@@ -214,17 +225,23 @@ impl<C: Coordinator> RunLoop<C> {
     fn handle_block_validate_response(&mut self, block_validate_response: BlockValidateResponse) {
         match block_validate_response {
             BlockValidateResponse::Ok(block_validate_ok) => {
-                self.blocks
-                    .entry(
-                        block_validate_ok
-                            .block
-                            .header
-                            .signature_hash()
-                            .unwrap_or(Sha512Trunc256Sum::from_data(&[])),
-                    )
-                    .and_modify(|block_info| {
-                        block_info.valid = true;
-                    });
+                let Ok(hash) = block_validate_ok.block.header.signature_hash() else {
+                    warn!("Received a block proposal with an invalid signature hash. Broadcasting a block rejection...");
+                    let block_rejection = BlockRejection::new(block_validate_ok.block, RejectCode::InvalidSignatureHash);
+                    // Submit signature result to miners to observe
+                    if let Err(e) = self
+                        .stackerdb
+                        .send_message_with_retry(self.signing_round.signer_id, block_rejection.into())
+                    {
+                        warn!("Failed to send block submission to stacker-db: {:?}", e);
+                    }
+                    return;
+                };
+                let block = self
+                    .blocks
+                    .entry(hash)
+                    .or_insert(BlockInfo::new(block_validate_ok.block.clone()));
+                block.valid = Some(true);
                 // This is a valid block proposal from the miner. Trigger a signing round for it if we are the coordinator
                 let (coordinator_id, _) = calculate_coordinator(&self.signing_round.public_keys);
                 if coordinator_id == self.signing_round.signer_id {
@@ -243,17 +260,23 @@ impl<C: Coordinator> RunLoop<C> {
                     "Received a block proposal that was rejected by the stacks node: {:?}\n. Broadcasting a rejection...",
                     block_validate_reject
                 );
-                self.blocks
-                    .entry(
-                        block_validate_reject
-                            .block
-                            .header
-                            .signature_hash()
-                            .unwrap_or(Sha512Trunc256Sum::from_data(&[])),
-                    )
-                    .and_modify(|block_info| {
-                        block_info.valid = false;
-                    });
+                let Ok(hash) = block_validate_reject.block.header.signature_hash() else {
+                    warn!("Received a block proposal with an invalid signature hash. Broadcasting a block rejection...");
+                    let block_rejection = BlockRejection::new(block_validate_reject.block, RejectCode::InvalidSignatureHash);
+                    // Submit signature result to miners to observe
+                    if let Err(e) = self
+                        .stackerdb
+                        .send_message_with_retry(self.signing_round.signer_id, block_rejection.into())
+                    {
+                        warn!("Failed to send block submission to stacker-db: {:?}", e);
+                    }
+                    return;
+                };
+                let block = self
+                    .blocks
+                    .entry(hash)
+                    .or_insert(BlockInfo::new(block_validate_reject.block.clone()));
+                block.valid = Some(false);
                 // Submit a rejection response to the .signers contract for miners
                 // to observe so they know to send another block and to prove signers are doing work);
                 if let Err(e) = self.stackerdb.send_message_with_retry(
@@ -323,14 +346,8 @@ impl<C: Coordinator> RunLoop<C> {
                 continue;
             };
             // Store the block in our cache
-            self.blocks.insert(
-                hash,
-                BlockInfo {
-                    vote: None,
-                    valid: false,
-                    block: block.clone(),
-                },
-            );
+            self.blocks.insert(hash, BlockInfo::new(block.clone()));
+            // Submit the block for validation
             self.stacks_client
                 .submit_block_for_validation(block)
                 .unwrap_or_else(|e| {
@@ -343,33 +360,42 @@ impl<C: Coordinator> RunLoop<C> {
     /// If the request is for a block it has already agreed to sign, it will overwrite the message with the agreed upon value
     /// Returns whether the request is valid or not.
     fn validate_signature_share_request(&self, request: &mut SignatureShareRequest) -> bool {
-        // A coordinator could have sent a signature share request with a different message than we agreed to sign
-        // This jankiness is because a coordinator could have sent a hash + 'n' byte and we need to pop that off...
-        // For now, if we have seen a message that is over a non hash, we will just sign it anyway so this is fine..
-        // TODO: fix this jankiness
-        let message = if request.message.len() == 32 {
+        let message_len = request.message.len();
+        // Note that the message must always be either 32 bytes (the block hash) or 33 bytes (block hash + b'n')
+        let hash_bytes = if message_len == 33 && request.message[32] == b'n' {
+            // Pop off the 'n' byte from the block hash
             &request.message[..32]
-        } else {
+        } else if message_len == 32 {
+            // This is the block hash
             &request.message
+        } else {
+            // We will only sign across block hashes or block hashes + b'n' byte
+            debug!("Received a signature share request for an unknown message stream. Reject it.");
+            return false;
         };
-        let message =
-            Sha512Trunc256Sum::from_bytes(message).unwrap_or(Sha512Trunc256Sum::from_data(&[]));
-        match self.blocks.get(&message).map(|block_info| &block_info.vote) {
+
+        let Some(hash) =
+            Sha512Trunc256Sum::from_bytes(hash_bytes) else {
+                // We will only sign across valid block hashes
+                debug!("Received a signature share request for an invalid block hash. Reject it.");
+                return false;
+            };
+        match self.blocks.get(&hash).map(|block_info| &block_info.vote) {
             Some(Some(vote)) => {
                 // Overwrite with our agreed upon value in case another message won majority or the coordinator is trying to cheat...
                 request.message = vote.clone();
                 true
             }
             Some(None) => {
-                // We have seen this block before, but we have not agreed to sign it. TODO: ignore it
-                debug!("Received a signature share request for a block we have not validated yet.");
+                // We never agreed to sign this block. Reject it. This can happen if the coordinator received enough votes to sign yes or no on a block before we received validation from the stacks node.
+                debug!("Received a signature share request for a block we never agreed to sign. Ignore it.");
                 false
             }
             None => {
-                // We have not seen this block before.
-                // TODO: should probably ignore any messages that are not either sBTC transactons or Nakamoto blocks. Leave now for abitrary message signing
-                debug!("Received a signature share request for an unknown message stream. Signing it as is...");
-                true
+                // We will only sign across block hashes or block hashes + b'n' byte for blocks we have seen a Nonce Request for (and subsequent validation)
+                // We are missing the context here necessary to make a decision therefore we outright reject the block
+                debug!("Received a signature share request from an unknown block. Reject it.");
+                false
             }
         }
     }
@@ -380,24 +406,40 @@ impl<C: Coordinator> RunLoop<C> {
     /// Returns whether the request is valid or not
     fn validate_nonce_request(&mut self, request: &mut NonceRequest) -> bool {
         let Some(block) = read_next::<NakamotoBlock, _>(&mut &request.message[..]).ok() else {
-            // TODO: we should probably reject requests to sign things that are not blocks or transactions (leave for now to enable testing abitrary signing)
-            warn!("Received a nonce request for an unknown message stream. Signing the nonce request as is.");
-            return true;
+            // We currently reject anything that is not a block
+            debug!("Received a nonce request for an unknown message stream. Reject it.");
+            return false;
         };
         let Ok(hash) = block.header.signature_hash() else {
-            debug!("Received a nonce request for a block with an invalid signature hash. Ignore it.");
+            debug!("Received a nonce request for a block with an invalid signature hash. Reject it");
             return false;
         };
         let transactions = &self.transactions;
-        let block_info = self.blocks.entry(hash).or_insert(BlockInfo {
-            vote: None,
-            valid: false,
-            block: block.clone(),
-        });
+        let Some(block_info) = self.blocks.get_mut(&hash) else {
+            // We have not seen this block before. Cache it. Send a RPC to the stacks node to validate it.
+            debug!("We have yet to handle out of order nonce request to block miner proposal. Rejecting it.");
+            // Store the block in our cache
+            self.blocks.insert(
+                hash, BlockInfo::new(block.clone()));
+            self.stacks_client
+                .submit_block_for_validation(block)
+                .unwrap_or_else(|e| {
+                    warn!("Failed to submit block for validation: {:?}", e);
+            });
+            // TODO: cache the NonceRequest to the side to reprocess after we receive back our validation response
+            return false;
+        };
+        if block_info.valid.is_none() {
+            // We have not yet received validation from the stacks node. Cache the request and wait for validation
+            // TODO: cache the Nonce Request and reprocess it later on validation
+            debug!("We have yet to receive validation from the stacks node for a nonce request. Reject it.");
+            return false;
+        }
         let mut hash_bytes = hash.0.to_vec();
         // Validate the block contents
-        block_info.valid = Self::validate_block(block_info, transactions);
-        if !block_info.valid {
+        if !block_info.valid.unwrap_or(false)
+            || !Self::verify_block_transactions(block_info, transactions)
+        {
             // We don't like this block. Update the request to be across its hash with a byte indicating a vote no.
             debug!("Updating the request with a block hash with a vote no.");
             hash_bytes.push(b'n');
@@ -410,11 +452,8 @@ impl<C: Coordinator> RunLoop<C> {
         true
     }
 
-    /// Helper function to validate a block's contents
-    fn validate_block(block_info: &BlockInfo, transactions: &[Txid]) -> bool {
-        if !block_info.valid {
-            return false;
-        }
+    /// Helper function to verify a block's transactions are as expected
+    fn verify_block_transactions(block_info: &BlockInfo, transactions: &[Txid]) -> bool {
         // Ensure the block contains the transactions we care about
         // TODO: add cast_aggregate_public_key to the list of transactions we care about.
         // This will also need to be flushed from the cache once these transactions are in a signed block

From 24aa81bb4a9bf2e3a65db61134b3ecad2f778df0 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Mon, 22 Jan 2024 12:57:10 -0800
Subject: [PATCH 0450/1166] Process out of order nonce requests and block
 validation responses

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 libsigner/src/runloop.rs                |  10 +-
 stacks-signer/src/config.rs             |   2 +-
 stacks-signer/src/main.rs               |  20 +-
 stacks-signer/src/runloop.rs            | 250 +++++++++++++++-------
 testnet/stacks-node/src/tests/signer.rs | 264 ++++++++++++++++++++++--
 5 files changed, 439 insertions(+), 107 deletions(-)

diff --git a/libsigner/src/runloop.rs b/libsigner/src/runloop.rs
index d1a2474a33..32b0326008 100644
--- a/libsigner/src/runloop.rs
+++ b/libsigner/src/runloop.rs
@@ -79,14 +79,8 @@ pub trait SignerRunLoop<R: Send, CMD: Send> {
                     return None;
                 }
             };
-            let next_command_opt = match command_recv.recv_timeout(poll_timeout) {
-                Ok(cmd) => Some(cmd),
-                Err(RecvTimeoutError::Timeout) => None,
-                Err(RecvTimeoutError::Disconnected) => {
-                    info!("Command receiver disconnected");
-                    return None;
-                }
-            };
+            // Do not block for commands
+            let next_command_opt = command_recv.try_recv().ok();
             if let Some(final_state) =
                 self.run_one_pass(next_event_opt, next_command_opt, result_send.clone())
             {
diff --git a/stacks-signer/src/config.rs b/stacks-signer/src/config.rs
index f83673e26c..58774b770e 100644
--- a/stacks-signer/src/config.rs
+++ b/stacks-signer/src/config.rs
@@ -36,7 +36,7 @@ use wsts::state_machine::PublicKeys;
 /// List of key_ids for each signer_id
 pub type SignerKeyIds = HashMap<u32, Vec<u32>>;
 
-const EVENT_TIMEOUT_MS: u64 = 50;
+const EVENT_TIMEOUT_MS: u64 = 5000;
 
 #[derive(thiserror::Error, Debug)]
 /// An error occurred parsing the provided configuration
diff --git a/stacks-signer/src/main.rs b/stacks-signer/src/main.rs
index a04d6a24f6..4fadef2797 100644
--- a/stacks-signer/src/main.rs
+++ b/stacks-signer/src/main.rs
@@ -33,16 +33,18 @@ use std::path::{Path, PathBuf};
 use std::sync::mpsc::{channel, Receiver, Sender};
 use std::time::Duration;
 
+use blockstack_lib::chainstate::nakamoto::NakamotoBlock;
 use clap::Parser;
 use clarity::vm::types::QualifiedContractIdentifier;
 use libsigner::{RunningSigner, Signer, SignerEventReceiver, SignerSession, StackerDBSession};
 use libstackerdb::StackerDBChunkData;
-use slog::slog_debug;
+use slog::{slog_debug, slog_error};
 use stacks_common::address::{
     AddressHashMode, C32_ADDRESS_VERSION_MAINNET_SINGLESIG, C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
 };
-use stacks_common::debug;
+use stacks_common::codec::read_next;
 use stacks_common::types::chainstate::{StacksAddress, StacksPrivateKey, StacksPublicKey};
+use stacks_common::{debug, error};
 use stacks_signer::cli::{
     Cli, Command, GenerateFilesArgs, GetChunkArgs, GetLatestChunkArgs, PutChunkArgs, RunDkgArgs,
     SignArgs, StackerDBArgs,
@@ -204,10 +206,15 @@ fn handle_dkg(args: RunDkgArgs) {
 fn handle_sign(args: SignArgs) {
     debug!("Signing message...");
     let spawned_signer = spawn_running_signer(&args.config);
+    let Some(block) = read_next::<NakamotoBlock, _>(&mut &args.data[..]).ok() else {
+        error!("Unable to parse provided message as a NakamotoBlock.");
+        spawned_signer.running_signer.stop();
+        return;
+    };
     spawned_signer
         .cmd_send
         .send(RunLoopCommand::Sign {
-            message: args.data,
+            block,
             is_taproot: false,
             merkle_root: None,
         })
@@ -220,12 +227,17 @@ fn handle_sign(args: SignArgs) {
 fn handle_dkg_sign(args: SignArgs) {
     debug!("Running DKG and signing message...");
     let spawned_signer = spawn_running_signer(&args.config);
+    let Some(block) = read_next::<NakamotoBlock, _>(&mut &args.data[..]).ok() else {
+        error!("Unable to parse provided message as a NakamotoBlock.");
+        spawned_signer.running_signer.stop();
+        return;
+    };
     // First execute DKG, then sign
     spawned_signer.cmd_send.send(RunLoopCommand::Dkg).unwrap();
     spawned_signer
         .cmd_send
         .send(RunLoopCommand::Sign {
-            message: args.data,
+            block,
             is_taproot: false,
             merkle_root: None,
         })
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 42f77935b6..772ef66df8 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -54,8 +54,8 @@ pub enum RunLoopCommand {
     Dkg,
     /// Sign a message
     Sign {
-        /// The bytes to sign
-        message: Vec<u8>,
+        /// The block to sign over
+        block: NakamotoBlock,
         /// Whether to make a taproot signature
         is_taproot: bool,
         /// Taproot merkle root
@@ -85,6 +85,10 @@ pub struct BlockInfo {
     vote: Option<Vec<u8>>,
     /// Whether the block contents are valid
     valid: Option<bool>,
+    /// The associated packet nonce request if we have one
+    nonce_request: Option<NonceRequest>,
+    /// Whether this block is already being signed over
+    signing_round: bool,
 }
 
 impl BlockInfo {
@@ -94,6 +98,19 @@ impl BlockInfo {
             block,
             vote: None,
             valid: None,
+            nonce_request: None,
+            signing_round: false,
+        }
+    }
+
+    /// Create a new BlockInfo with an associated nonce request packet
+    pub fn new_with_request(block: NakamotoBlock, nonce_request: NonceRequest) -> Self {
+        Self {
+            block,
+            vote: None,
+            valid: None,
+            nonce_request: Some(nonce_request),
+            signing_round: true,
         }
     }
 }
@@ -117,8 +134,10 @@ pub struct RunLoop<C> {
     /// Wether mainnet or not
     pub mainnet: bool,
     /// Observed blocks that we have seen so far
+    // TODO: cleanup storage and garbage collect this stuff
     pub blocks: HashMap<Sha512Trunc256Sum, BlockInfo>,
     /// Transactions that we expect to see in the next block
+    // TODO: fill this in and do proper garbage collection
     pub transactions: Vec<Txid>,
 }
 
@@ -168,21 +187,35 @@ impl<C: Coordinator> RunLoop<C> {
                 }
             }
             RunLoopCommand::Sign {
-                message,
+                block,
                 is_taproot,
                 merkle_root,
             } => {
-                info!("Signing message: {:?}", message);
-                match self
-                    .coordinator
-                    .start_signing_round(message, *is_taproot, *merkle_root)
-                {
+                let Ok(hash) = block.header.signature_hash() else {
+                    error!("Failed to sign block. Invalid signature hash.");
+                    return false;
+                };
+                let block_info = self
+                    .blocks
+                    .entry(hash)
+                    .or_insert_with(|| BlockInfo::new(block.clone()));
+                if block_info.signing_round {
+                    debug!("Received a sign command for a block we are already signing over. Ignore it.");
+                    return false;
+                }
+                info!("Signing block: {:?}", block);
+                match self.coordinator.start_signing_round(
+                    &block.serialize_to_vec(),
+                    *is_taproot,
+                    *merkle_root,
+                ) {
                     Ok(msg) => {
                         let ack = self
                             .stackerdb
                             .send_message_with_retry(self.signing_round.signer_id, msg.into());
                         debug!("ACK: {:?}", ack);
                         self.state = State::Sign;
+                        block_info.signing_round = true;
                         true
                     }
                     Err(e) => {
@@ -222,17 +255,25 @@ impl<C: Coordinator> RunLoop<C> {
     }
 
     /// Handle the block validate response returned from our prior calls to submit a block for validation
-    fn handle_block_validate_response(&mut self, block_validate_response: BlockValidateResponse) {
+    fn handle_block_validate_response(
+        &mut self,
+        block_validate_response: BlockValidateResponse,
+        res: Sender<Vec<OperationResult>>,
+    ) {
+        let transactions = &self.transactions;
         match block_validate_response {
             BlockValidateResponse::Ok(block_validate_ok) => {
                 let Ok(hash) = block_validate_ok.block.header.signature_hash() else {
                     warn!("Received a block proposal with an invalid signature hash. Broadcasting a block rejection...");
-                    let block_rejection = BlockRejection::new(block_validate_ok.block, RejectCode::InvalidSignatureHash);
+                    let block_rejection = BlockRejection::new(
+                        block_validate_ok.block,
+                        RejectCode::InvalidSignatureHash,
+                    );
                     // Submit signature result to miners to observe
-                    if let Err(e) = self
-                        .stackerdb
-                        .send_message_with_retry(self.signing_round.signer_id, block_rejection.into())
-                    {
+                    if let Err(e) = self.stackerdb.send_message_with_retry(
+                        self.signing_round.signer_id,
+                        block_rejection.into(),
+                    ) {
                         warn!("Failed to send block submission to stacker-db: {:?}", e);
                     }
                     return;
@@ -242,32 +283,63 @@ impl<C: Coordinator> RunLoop<C> {
                     .entry(hash)
                     .or_insert(BlockInfo::new(block_validate_ok.block.clone()));
                 block.valid = Some(true);
-                // This is a valid block proposal from the miner. Trigger a signing round for it if we are the coordinator
-                let (coordinator_id, _) = calculate_coordinator(&self.signing_round.public_keys);
-                if coordinator_id == self.signing_round.signer_id {
-                    debug!("Received a valid block proposal from the miner: {:?}\n Triggering a signing round over it...", block_validate_ok.block);
-                    // We are the coordinator. Trigger a signing round for this block
-                    self.commands.push_back(RunLoopCommand::Sign {
-                        message: block_validate_ok.block.serialize_to_vec(),
-                        is_taproot: false,
-                        merkle_root: None,
-                    });
+
+                if let Some(mut block_request) = block.nonce_request.take() {
+                    debug!("Received a block validate ok from the stacks node for a block we already received a nonce request for. Responding to the nonce request...");
+                    // We have an associated nonce request. Respond to it
+                    let mut hash_bytes = hash.0.to_vec();
+                    // Validate the block contents
+                    if !Self::verify_block_transactions(block, transactions) {
+                        // We don't like this block. Update the request to be across its hash with a byte indicating a vote no.
+                        debug!("Updating the request with a block hash with a vote no.");
+                        hash_bytes.push(b'n');
+                    } else {
+                        debug!("The block passed validation. Update the request with the signature hash.");
+                    }
+                    // Cache our vote
+                    block.vote = Some(hash_bytes.clone());
+                    block_request.message = hash_bytes;
+                    let packet = Packet {
+                        msg: Message::NonceRequest(NonceRequest {
+                            message: hash.0.to_vec(),
+                            ..block_request
+                        }),
+                        sig: vec![],
+                    };
+                    self.handle_packets(res, &[packet]);
+                } else {
+                    debug!("Received a block validate ok from the stacks node. Check if we need to trigger a signing round over it.");
+                    // This is a valid block proposal from the miner. Trigger a signing round for it if we are the coordinator and haven't already
+                    let (coordinator_id, _) =
+                        calculate_coordinator(&self.signing_round.public_keys);
+                    if !block.signing_round && coordinator_id == self.signing_round.signer_id {
+                        debug!("Received a valid block proposal from the miner. Triggering a signing round over it...");
+                        // We are the coordinator. Trigger a signing round for this block
+                        self.commands.push_back(RunLoopCommand::Sign {
+                            block: block_validate_ok.block,
+                            is_taproot: false,
+                            merkle_root: None,
+                        });
+                    }
                 }
             }
             BlockValidateResponse::Reject(block_validate_reject) => {
                 // There is no point in triggering a sign round for this block if validation failed from the stacks node
                 debug!(
-                    "Received a block proposal that was rejected by the stacks node: {:?}\n. Broadcasting a rejection...",
-                    block_validate_reject
-                );
+                            "Received a block proposal that was rejected by the stacks node: {:?}\n. Broadcasting a rejection...",
+                            block_validate_reject
+                        );
                 let Ok(hash) = block_validate_reject.block.header.signature_hash() else {
                     warn!("Received a block proposal with an invalid signature hash. Broadcasting a block rejection...");
-                    let block_rejection = BlockRejection::new(block_validate_reject.block, RejectCode::InvalidSignatureHash);
+                    let block_rejection = BlockRejection::new(
+                        block_validate_reject.block,
+                        RejectCode::InvalidSignatureHash,
+                    );
                     // Submit signature result to miners to observe
-                    if let Err(e) = self
-                        .stackerdb
-                        .send_message_with_retry(self.signing_round.signer_id, block_rejection.into())
-                    {
+                    if let Err(e) = self.stackerdb.send_message_with_retry(
+                        self.signing_round.signer_id,
+                        block_rejection.into(),
+                    ) {
                         warn!("Failed to send block submission to stacker-db: {:?}", e);
                     }
                     return;
@@ -277,6 +349,26 @@ impl<C: Coordinator> RunLoop<C> {
                     .entry(hash)
                     .or_insert(BlockInfo::new(block_validate_reject.block.clone()));
                 block.valid = Some(false);
+                if let Some(mut block_request) = block.nonce_request.take() {
+                    debug!("Received a block validate reject from the stacks node for a block we already received a nonce request for. Responding to the nonce request...");
+                    // We have an associated nonce request. Respond to it
+                    let mut hash_bytes = hash.0.to_vec();
+                    // Validate the block contents
+                    // We don't like this block. Update the request to be across its hash with a byte indicating a vote no.
+                    debug!("Updating the request with a block hash with a vote no.");
+                    hash_bytes.push(b'n');
+                    // Cache our vote
+                    block.vote = Some(hash_bytes.clone());
+                    block_request.message = hash_bytes;
+                    let packet = Packet {
+                        msg: Message::NonceRequest(NonceRequest {
+                            message: hash.0.to_vec(),
+                            ..block_request
+                        }),
+                        sig: vec![],
+                    };
+                    self.handle_packets(res, &[packet]);
+                }
                 // Submit a rejection response to the .signers contract for miners
                 // to observe so they know to send another block and to prove signers are doing work);
                 if let Err(e) = self.stackerdb.send_message_with_retry(
@@ -298,32 +390,12 @@ impl<C: Coordinator> RunLoop<C> {
         let (_coordinator_id, coordinator_public_key) =
             calculate_coordinator(&self.signing_round.public_keys);
 
-        let inbound_messages: Vec<Packet> = stackerdb_chunk_event
+        let inbound_packets: Vec<Packet> = stackerdb_chunk_event
             .modified_slots
             .iter()
             .filter_map(|chunk| self.verify_chunk(chunk, &coordinator_public_key))
             .collect();
-        let signer_outbound_messages = self
-            .signing_round
-            .process_inbound_messages(&inbound_messages)
-            .unwrap_or_else(|e| {
-                error!("Failed to process inbound messages as a signer: {e}");
-                vec![]
-            });
-
-        // Next process the message as the coordinator
-        let (coordinator_outbound_messages, operation_results) = self
-            .coordinator
-            .process_inbound_messages(&inbound_messages)
-            .unwrap_or_else(|e| {
-                error!("Failed to process inbound messages as a coordinator: {e}");
-                (vec![], vec![])
-            });
-
-        self.send_outbound_messages(signer_outbound_messages);
-        self.send_outbound_messages(coordinator_outbound_messages);
-        self.send_block_response_messages(&operation_results);
-        self.send_operation_results(res, operation_results);
+        self.handle_packets(res, &inbound_packets);
     }
 
     // Handle the stackerdb chunk event as a miner message
@@ -336,8 +408,8 @@ impl<C: Coordinator> RunLoop<C> {
             let Ok(hash) = block.header.signature_hash() else {
                 warn!("Received a block proposal with an invalid signature hash. Broadcasting a block rejection...");
                 let block_rejection = BlockRejection::new(block, RejectCode::InvalidSignatureHash);
-                    // Submit signature result to miners to observe
-                    if let Err(e) = self
+                // Submit signature result to miners to observe
+                if let Err(e) = self
                     .stackerdb
                     .send_message_with_retry(self.signing_round.signer_id, block_rejection.into())
                 {
@@ -356,6 +428,32 @@ impl<C: Coordinator> RunLoop<C> {
         }
     }
 
+    /// Helper function to process inbound packets as both a signer and a coordinator
+    /// Will send outbound packets and operation results as appropriate
+    fn handle_packets(&mut self, res: Sender<Vec<OperationResult>>, packets: &[Packet]) {
+        let signer_outbound_messages = self
+            .signing_round
+            .process_inbound_messages(packets)
+            .unwrap_or_else(|e| {
+                error!("Failed to process inbound messages as a signer: {e}");
+                vec![]
+            });
+
+        // Next process the message as the coordinator
+        let (coordinator_outbound_messages, operation_results) = self
+            .coordinator
+            .process_inbound_messages(packets)
+            .unwrap_or_else(|e| {
+                error!("Failed to process inbound messages as a coordinator: {e}");
+                (vec![], vec![])
+            });
+
+        self.send_outbound_messages(signer_outbound_messages);
+        self.send_outbound_messages(coordinator_outbound_messages);
+        self.send_block_response_messages(&operation_results);
+        self.send_operation_results(res, operation_results);
+    }
+
     /// Helper function to validate a signature share request, updating its message where appropriate.
     /// If the request is for a block it has already agreed to sign, it will overwrite the message with the agreed upon value
     /// Returns whether the request is valid or not.
@@ -374,12 +472,11 @@ impl<C: Coordinator> RunLoop<C> {
             return false;
         };
 
-        let Some(hash) =
-            Sha512Trunc256Sum::from_bytes(hash_bytes) else {
-                // We will only sign across valid block hashes
-                debug!("Received a signature share request for an invalid block hash. Reject it.");
-                return false;
-            };
+        let Some(hash) = Sha512Trunc256Sum::from_bytes(hash_bytes) else {
+            // We will only sign across valid block hashes
+            debug!("Received a signature share request for an invalid block hash. Reject it.");
+            return false;
+        };
         match self.blocks.get(&hash).map(|block_info| &block_info.vote) {
             Some(Some(vote)) => {
                 // Overwrite with our agreed upon value in case another message won majority or the coordinator is trying to cheat...
@@ -411,28 +508,31 @@ impl<C: Coordinator> RunLoop<C> {
             return false;
         };
         let Ok(hash) = block.header.signature_hash() else {
-            debug!("Received a nonce request for a block with an invalid signature hash. Reject it");
+            debug!(
+                "Received a nonce request for a block with an invalid signature hash. Reject it"
+            );
             return false;
         };
         let transactions = &self.transactions;
         let Some(block_info) = self.blocks.get_mut(&hash) else {
             // We have not seen this block before. Cache it. Send a RPC to the stacks node to validate it.
-            debug!("We have yet to handle out of order nonce request to block miner proposal. Rejecting it.");
+            debug!("We have received a block sign request for a block we have not seen before. Cache request and submit the block for validation...");
             // Store the block in our cache
             self.blocks.insert(
-                hash, BlockInfo::new(block.clone()));
+                hash,
+                BlockInfo::new_with_request(block.clone(), request.clone()),
+            );
             self.stacks_client
                 .submit_block_for_validation(block)
                 .unwrap_or_else(|e| {
                     warn!("Failed to submit block for validation: {:?}", e);
-            });
-            // TODO: cache the NonceRequest to the side to reprocess after we receive back our validation response
+                });
             return false;
         };
         if block_info.valid.is_none() {
             // We have not yet received validation from the stacks node. Cache the request and wait for validation
-            // TODO: cache the Nonce Request and reprocess it later on validation
-            debug!("We have yet to receive validation from the stacks node for a nonce request. Reject it.");
+            debug!("We have yet to receive validation from the stacks node for a nonce request. Cache the nonce request and wait for block validation...");
+            block_info.nonce_request = Some(request.clone());
             return false;
         }
         let mut hash_bytes = hash.0.to_vec();
@@ -506,9 +606,7 @@ impl<C: Coordinator> RunLoop<C> {
 
     /// Helper function to extract block proposals from signature results and braodcast them to the stackerdb slot
     fn send_block_response_messages(&mut self, operation_results: &[OperationResult]) {
-        let Some(aggregate_public_key) = &self
-            .coordinator
-            .get_aggregate_public_key() else {
+        let Some(aggregate_public_key) = &self.coordinator.get_aggregate_public_key() else {
             debug!("No aggregate public key set. Cannot validate results. Ignoring signature results...");
             return;
         };
@@ -708,7 +806,7 @@ impl<C: Coordinator> SignerRunLoop<Vec<OperationResult>, RunLoopCommand> for Run
         match event {
             Some(SignerEvent::BlockProposal(block_validate_response)) => {
                 debug!("Received a block proposal result from the stacks node...");
-                self.handle_block_validate_response(block_validate_response)
+                self.handle_block_validate_response(block_validate_response, res)
             }
             Some(SignerEvent::StackerDB(stackerdb_chunk_event)) => {
                 if stackerdb_chunk_event.contract_id == *self.stackerdb.signers_contract_id() {
@@ -722,9 +820,9 @@ impl<C: Coordinator> SignerRunLoop<Vec<OperationResult>, RunLoopCommand> for Run
                 } else {
                     // Ignore non miner or signer messages
                     debug!(
-                        "Received a StackerDB event for an unrecognized contract id: {:?}. Ignoring...",
-                        stackerdb_chunk_event.contract_id
-                    );
+                                "Received a StackerDB event for an unrecognized contract id: {:?}. Ignoring...",
+                                stackerdb_chunk_event.contract_id
+                            );
                 }
             }
             None => {
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index 2aea176879..d747d5d430 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -4,13 +4,22 @@ use std::sync::{Arc, Mutex};
 use std::time::Duration;
 use std::{env, thread};
 
+use clarity::vm::ast::ASTRules;
 use clarity::vm::types::QualifiedContractIdentifier;
 use libsigner::{RunningSigner, Signer, SignerEventReceiver};
+use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::coordinator::comm::CoordinatorChannels;
+use stacks::chainstate::nakamoto::miner::NakamotoBlockBuilder;
+use stacks::chainstate::nakamoto::NakamotoChainState;
 use stacks::chainstate::stacks::boot::MINERS_NAME;
-use stacks::chainstate::stacks::{StacksPrivateKey, ThresholdSignature};
+use stacks::chainstate::stacks::db::StacksChainState;
+use stacks::chainstate::stacks::miner::{BlockBuilder, BlockLimitFunction, TransactionResult};
+use stacks::chainstate::stacks::{
+    StacksPrivateKey, StacksTransaction, ThresholdSignature, TransactionPayload,
+};
 use stacks::net::api::postblock_proposal::BlockValidateResponse;
 use stacks::util_lib::boot::boot_code_id;
+use stacks_common::codec::StacksMessageCodec;
 use stacks_common::types::chainstate::{StacksAddress, StacksPublicKey};
 use stacks_signer::client::{BlockResponse, SignerMessage, SIGNER_SLOTS_PER_USER};
 use stacks_signer::config::{Config as SignerConfig, Network};
@@ -33,7 +42,7 @@ use crate::tests::nakamoto_integrations::{
 use crate::tests::neon_integrations::{
     next_block_and_wait, submit_tx, test_observer, wait_for_runloop,
 };
-use crate::tests::{make_contract_publish, to_addr};
+use crate::tests::{make_contract_publish, make_stacks_transfer, to_addr};
 use crate::{BitcoinRegtestController, BurnchainController};
 
 // Helper struct for holding the btc and stx neon nodes
@@ -63,6 +72,8 @@ struct SignerTest {
     pub running_coordinator: RunningSigner<SignerEventReceiver, Vec<OperationResult>>,
     // The running signer and its threads
     pub running_signers: Vec<RunningSigner<SignerEventReceiver, Vec<OperationResult>>>,
+    // The signer private keys
+    pub signer_stacks_private_keys: Vec<StacksPrivateKey>,
 }
 
 impl SignerTest {
@@ -140,6 +151,7 @@ impl SignerTest {
             coordinator_cmd_sender,
             running_coordinator,
             running_signers,
+            signer_stacks_private_keys,
         }
     }
 
@@ -325,6 +337,8 @@ fn setup_stx_btc_node(
 
 #[test]
 #[ignore]
+/// Test the signer can respond to external commands to perform DKG
+/// and sign a block with both taproot and non-taproot signatures
 fn stackerdb_dkg_sign() {
     if env::var("BITCOIND_TEST") != Ok("1".into()) {
         return;
@@ -336,18 +350,232 @@ fn stackerdb_dkg_sign() {
         .init();
 
     info!("------------------------- Test Setup -------------------------");
-    let signer_test = SignerTest::new(10, 400);
-    info!("------------------------- Test DKG and Sign -------------------------");
-    let now = std::time::Instant::now();
-    info!("signer_runloop: spawn send commands to do dkg and then sign");
+    let mut signer_test = SignerTest::new(10, 400);
+
+    // First run DKG in order to sign the block that arrives from the miners following a nakamoto block production
+
+    info!("------------------------- Test DKG -------------------------");
+    info!("signer_runloop: spawn send commands to do dkg");
+    let dkg_now = std::time::Instant::now();
     signer_test
         .coordinator_cmd_sender
         .send(RunLoopCommand::Dkg)
         .expect("failed to send Dkg command");
+    let mut aggregate_public_key_res = None;
+    for recv in signer_test.result_receivers.iter() {
+        let mut aggregate_public_key = None;
+        loop {
+            let results = recv.recv().expect("failed to recv results");
+            for result in results {
+                match result {
+                    OperationResult::Sign(sig) => {
+                        panic!("Received Signature ({},{})", &sig.R, &sig.z);
+                    }
+                    OperationResult::SignTaproot(proof) => {
+                        panic!("Received SchnorrProof ({},{})", &proof.r, &proof.s);
+                    }
+                    OperationResult::DkgError(dkg_error) => {
+                        panic!("Received DkgError {:?}", dkg_error);
+                    }
+                    OperationResult::SignError(sign_error) => {
+                        panic!("Received SignError {}", sign_error);
+                    }
+                    OperationResult::Dkg(point) => {
+                        info!("Received aggregate_group_key {point}");
+                        aggregate_public_key = Some(point);
+                    }
+                }
+            }
+            if aggregate_public_key.is_some() {
+                aggregate_public_key_res = aggregate_public_key;
+                break;
+            }
+        }
+    }
+    aggregate_public_key_res.expect("Failed to get aggregate public key");
+    let dkg_elapsed = dkg_now.elapsed();
+
+    let (vrfs_submitted, commits_submitted) = (
+        signer_test.running_nodes.vrfs_submitted.clone(),
+        signer_test.running_nodes.commits_submitted.clone(),
+    );
+
+    info!("------------------------- Mine a Nakamoto Tenure -------------------------");
+
+    // first block wakes up the run loop, wait until a key registration has been submitted.
+    next_block_and(
+        &mut signer_test.running_nodes.btc_regtest_controller,
+        60,
+        || {
+            let vrf_count = vrfs_submitted.load(Ordering::SeqCst);
+            Ok(vrf_count >= 1)
+        },
+    )
+    .unwrap();
+
+    // second block should confirm the VRF register, wait until a block commit is submitted
+    next_block_and(
+        &mut signer_test.running_nodes.btc_regtest_controller,
+        60,
+        || {
+            let commits_count = commits_submitted.load(Ordering::SeqCst);
+            Ok(commits_count >= 1)
+        },
+    )
+    .unwrap();
+
+    // Mine 1 nakamoto tenures
+    next_block_and_mine_commit(
+        &mut signer_test.running_nodes.btc_regtest_controller,
+        60,
+        &signer_test.running_nodes.coord_channel,
+        &commits_submitted,
+    )
+    .unwrap();
+
+    // Ensure we signed the proposed block and flush the operation results receiver of it
+    for recv in signer_test.result_receivers.iter() {
+        let mut frost_signature = None;
+        loop {
+            let results = recv.recv().expect("failed to recv results");
+            for result in results {
+                match result {
+                    OperationResult::Sign(sig) => {
+                        info!("Received Signature ({},{})", &sig.R, &sig.z);
+                        frost_signature = Some(sig);
+                    }
+                    OperationResult::SignTaproot(proof) => {
+                        panic!("Received SchnorrProof ({},{})", &proof.r, &proof.s);
+                    }
+                    OperationResult::DkgError(dkg_error) => {
+                        panic!("Received DkgError {:?}", dkg_error);
+                    }
+                    OperationResult::SignError(sign_error) => {
+                        panic!("Received SignError {}", sign_error);
+                    }
+                    OperationResult::Dkg(point) => {
+                        panic!("Received aggregate_group_key {point}");
+                    }
+                }
+            }
+            if frost_signature.is_some() {
+                break;
+            }
+        }
+    }
+
+    info!("Generating a valid block to sign...");
+
+    let burnchain = signer_test.running_nodes.conf.get_burnchain();
+    let sortdb = burnchain.open_sortition_db(true).unwrap();
+    let (mut chainstate, _) = StacksChainState::open(
+        signer_test.running_nodes.conf.is_mainnet(),
+        signer_test.running_nodes.conf.burnchain.chain_id,
+        &signer_test.running_nodes.conf.get_chainstate_path_str(),
+        None,
+    )
+    .unwrap();
+
+    // TODO (hack) instantiate the sortdb in the burnchain
+    _ = signer_test
+        .running_nodes
+        .btc_regtest_controller
+        .sortdb_mut();
+
+    // ----- Setup boilerplate finished, test block proposal API endpoint -----
+
+    let tip = NakamotoChainState::get_canonical_block_header(chainstate.db(), &sortdb)
+        .unwrap()
+        .unwrap();
+
+    let privk = signer_test
+        .running_nodes
+        .conf
+        .miner
+        .mining_key
+        .unwrap()
+        .clone();
+    let sort_tip = SortitionDB::get_canonical_sortition_tip(sortdb.conn())
+        .expect("Failed to get sortition tip");
+    let db_handle = sortdb.index_handle(&sort_tip);
+    let snapshot = db_handle
+        .get_block_snapshot(&tip.burn_header_hash)
+        .expect("Failed to get block snapshot")
+        .expect("No snapshot");
+    // Double check we got the right sortition
+    assert_eq!(
+        snapshot.consensus_hash, tip.consensus_hash,
+        "Found incorrect block snapshot"
+    );
+    let total_burn = snapshot.total_burn;
+    let tenure_change = None;
+    let coinbase = None;
+
+    let tenure_cause = tenure_change.and_then(|tx: &StacksTransaction| match &tx.payload {
+        TransactionPayload::TenureChange(tc) => Some(tc.cause),
+        _ => None,
+    });
+
+    let mut block = {
+        let mut builder = NakamotoBlockBuilder::new(
+            &tip,
+            &tip.consensus_hash,
+            total_burn,
+            tenure_change,
+            coinbase,
+        )
+        .expect("Failed to build Nakamoto block");
+
+        let burn_dbconn = signer_test
+            .running_nodes
+            .btc_regtest_controller
+            .sortdb_ref()
+            .index_conn();
+        let mut miner_tenure_info = builder
+            .load_tenure_info(&mut chainstate, &burn_dbconn, tenure_cause)
+            .unwrap();
+        let mut tenure_tx = builder
+            .tenure_begin(&burn_dbconn, &mut miner_tenure_info)
+            .unwrap();
+
+        let tx = make_stacks_transfer(
+            &signer_test.signer_stacks_private_keys[0],
+            0,
+            100,
+            &to_addr(&signer_test.signer_stacks_private_keys[1]).into(),
+            10000,
+        );
+        let tx = StacksTransaction::consensus_deserialize(&mut &tx[..])
+            .expect("Failed to deserialize transaction");
+        let tx_len = tx.tx_len();
+
+        let res = builder.try_mine_tx_with_len(
+            &mut tenure_tx,
+            &tx,
+            tx_len,
+            &BlockLimitFunction::NO_LIMIT_HIT,
+            ASTRules::PrecheckSize,
+        );
+        assert!(
+            matches!(res, TransactionResult::Success(..)),
+            "Transaction failed"
+        );
+        builder.mine_nakamoto_block(&mut tenure_tx)
+    };
+
+    // Sign the block
+    block
+        .header
+        .sign_miner(&privk)
+        .expect("Miner failed to sign");
+
+    info!("------------------------- Test Sign -------------------------");
+    let sign_now = std::time::Instant::now();
+    info!("signer_runloop: spawn send commands to do dkg and then sign");
     signer_test
         .coordinator_cmd_sender
         .send(RunLoopCommand::Sign {
-            message: vec![1, 2, 3, 4, 5],
+            block: block.clone(),
             is_taproot: false,
             merkle_root: None,
         })
@@ -355,23 +583,18 @@ fn stackerdb_dkg_sign() {
     signer_test
         .coordinator_cmd_sender
         .send(RunLoopCommand::Sign {
-            message: vec![1, 2, 3, 4, 5],
+            block,
             is_taproot: true,
             merkle_root: None,
         })
         .expect("failed to send taproot Sign command");
     for recv in signer_test.result_receivers.iter() {
-        let mut aggregate_group_key = None;
         let mut frost_signature = None;
         let mut schnorr_proof = None;
         loop {
             let results = recv.recv().expect("failed to recv results");
             for result in results {
                 match result {
-                    OperationResult::Dkg(point) => {
-                        info!("Received aggregate_group_key {point}");
-                        aggregate_group_key = Some(point);
-                    }
                     OperationResult::Sign(sig) => {
                         info!("Received Signature ({},{})", &sig.R, &sig.z);
                         frost_signature = Some(sig);
@@ -386,16 +609,20 @@ fn stackerdb_dkg_sign() {
                     OperationResult::SignError(sign_error) => {
                         panic!("Received SignError {}", sign_error);
                     }
+                    OperationResult::Dkg(point) => {
+                        info!("Received aggregate_group_key {point}");
+                    }
                 }
             }
-            if aggregate_group_key.is_some() && frost_signature.is_some() && schnorr_proof.is_some()
-            {
+            if frost_signature.is_some() && schnorr_proof.is_some() {
                 break;
             }
         }
     }
-    let elapsed = now.elapsed();
-    info!("DKG and Sign Time Elapsed: {:.2?}", elapsed);
+    let sign_elapsed = sign_now.elapsed();
+
+    info!("DKG Time Elapsed: {:.2?}", dkg_elapsed);
+    info!("Sign Time Elapsed: {:.2?}", sign_elapsed);
     signer_test.shutdown();
 }
 
@@ -416,7 +643,8 @@ fn stackerdb_dkg_sign() {
 ///
 /// Test Assertion:
 /// Signers return an operation result containing a valid signature across the miner's Nakamoto block's signature hash.
-/// TODO: update this test to assert that the signers broadcast a Nakamoto block response back to the miners
+/// Signers broadcasted a signed NakamotoBlock back to the .signers contract.
+/// TODO: update test to check miner received the signed block and appended it to the chain
 fn stackerdb_block_proposal() {
     if env::var("BITCOIND_TEST") != Ok("1".into()) {
         return;

From b60a79d30785f205acec3d4a9aa1ed404286b453 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Mon, 22 Jan 2024 14:38:45 -0800
Subject: [PATCH 0451/1166] Fix bug where I was overwriting the nonce request
 incorrectly

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/runloop.rs | 19 +++++++------------
 1 file changed, 7 insertions(+), 12 deletions(-)

diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 772ef66df8..644ded1350 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -249,7 +249,7 @@ impl<C: Coordinator> RunLoop<C> {
             State::Dkg | State::Sign => {
                 // We cannot execute the next command until the current one is finished...
                 // Do nothing...
-                debug!("Waiting for operation to finish");
+                debug!("Waiting for {:?} operation to finish", self.state);
             }
         }
     }
@@ -299,11 +299,9 @@ impl<C: Coordinator> RunLoop<C> {
                     // Cache our vote
                     block.vote = Some(hash_bytes.clone());
                     block_request.message = hash_bytes;
+                    // Send the nonce request through with our vote
                     let packet = Packet {
-                        msg: Message::NonceRequest(NonceRequest {
-                            message: hash.0.to_vec(),
-                            ..block_request
-                        }),
+                        msg: Message::NonceRequest(block_request),
                         sig: vec![],
                     };
                     self.handle_packets(res, &[packet]);
@@ -326,9 +324,8 @@ impl<C: Coordinator> RunLoop<C> {
             BlockValidateResponse::Reject(block_validate_reject) => {
                 // There is no point in triggering a sign round for this block if validation failed from the stacks node
                 debug!(
-                            "Received a block proposal that was rejected by the stacks node: {:?}\n. Broadcasting a rejection...",
-                            block_validate_reject
-                        );
+                    "Received a block proposal that was rejected by the stacks node. Broadcasting a rejection...",
+                );
                 let Ok(hash) = block_validate_reject.block.header.signature_hash() else {
                     warn!("Received a block proposal with an invalid signature hash. Broadcasting a block rejection...");
                     let block_rejection = BlockRejection::new(
@@ -360,11 +357,9 @@ impl<C: Coordinator> RunLoop<C> {
                     // Cache our vote
                     block.vote = Some(hash_bytes.clone());
                     block_request.message = hash_bytes;
+                    // Send the nonce request through with our vote
                     let packet = Packet {
-                        msg: Message::NonceRequest(NonceRequest {
-                            message: hash.0.to_vec(),
-                            ..block_request
-                        }),
+                        msg: Message::NonceRequest(block_request),
                         sig: vec![],
                     };
                     self.handle_packets(res, &[packet]);

From 3a6cf3024a8634cef5817544bdc3fe7d16bd0d66 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Mon, 22 Jan 2024 15:52:04 -0800
Subject: [PATCH 0452/1166] Code cleanup

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/runloop.rs | 195 ++++++++++++++---------------------
 1 file changed, 79 insertions(+), 116 deletions(-)

diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 644ded1350..cfe03a350d 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -261,109 +261,30 @@ impl<C: Coordinator> RunLoop<C> {
         res: Sender<Vec<OperationResult>>,
     ) {
         let transactions = &self.transactions;
-        match block_validate_response {
+        let (block_info, hash) = match block_validate_response {
             BlockValidateResponse::Ok(block_validate_ok) => {
                 let Ok(hash) = block_validate_ok.block.header.signature_hash() else {
-                    warn!("Received a block proposal with an invalid signature hash. Broadcasting a block rejection...");
-                    let block_rejection = BlockRejection::new(
-                        block_validate_ok.block,
-                        RejectCode::InvalidSignatureHash,
-                    );
-                    // Submit signature result to miners to observe
-                    if let Err(e) = self.stackerdb.send_message_with_retry(
-                        self.signing_round.signer_id,
-                        block_rejection.into(),
-                    ) {
-                        warn!("Failed to send block submission to stacker-db: {:?}", e);
-                    }
+                    self.broadcast_signature_hash_rejection(block_validate_ok.block);
                     return;
                 };
-                let block = self
+                let block_info = self
                     .blocks
                     .entry(hash)
                     .or_insert(BlockInfo::new(block_validate_ok.block.clone()));
-                block.valid = Some(true);
-
-                if let Some(mut block_request) = block.nonce_request.take() {
-                    debug!("Received a block validate ok from the stacks node for a block we already received a nonce request for. Responding to the nonce request...");
-                    // We have an associated nonce request. Respond to it
-                    let mut hash_bytes = hash.0.to_vec();
-                    // Validate the block contents
-                    if !Self::verify_block_transactions(block, transactions) {
-                        // We don't like this block. Update the request to be across its hash with a byte indicating a vote no.
-                        debug!("Updating the request with a block hash with a vote no.");
-                        hash_bytes.push(b'n');
-                    } else {
-                        debug!("The block passed validation. Update the request with the signature hash.");
-                    }
-                    // Cache our vote
-                    block.vote = Some(hash_bytes.clone());
-                    block_request.message = hash_bytes;
-                    // Send the nonce request through with our vote
-                    let packet = Packet {
-                        msg: Message::NonceRequest(block_request),
-                        sig: vec![],
-                    };
-                    self.handle_packets(res, &[packet]);
-                } else {
-                    debug!("Received a block validate ok from the stacks node. Check if we need to trigger a signing round over it.");
-                    // This is a valid block proposal from the miner. Trigger a signing round for it if we are the coordinator and haven't already
-                    let (coordinator_id, _) =
-                        calculate_coordinator(&self.signing_round.public_keys);
-                    if !block.signing_round && coordinator_id == self.signing_round.signer_id {
-                        debug!("Received a valid block proposal from the miner. Triggering a signing round over it...");
-                        // We are the coordinator. Trigger a signing round for this block
-                        self.commands.push_back(RunLoopCommand::Sign {
-                            block: block_validate_ok.block,
-                            is_taproot: false,
-                            merkle_root: None,
-                        });
-                    }
-                }
+                block_info.valid = Some(true);
+                (block_info, hash)
             }
             BlockValidateResponse::Reject(block_validate_reject) => {
                 // There is no point in triggering a sign round for this block if validation failed from the stacks node
-                debug!(
-                    "Received a block proposal that was rejected by the stacks node. Broadcasting a rejection...",
-                );
                 let Ok(hash) = block_validate_reject.block.header.signature_hash() else {
-                    warn!("Received a block proposal with an invalid signature hash. Broadcasting a block rejection...");
-                    let block_rejection = BlockRejection::new(
-                        block_validate_reject.block,
-                        RejectCode::InvalidSignatureHash,
-                    );
-                    // Submit signature result to miners to observe
-                    if let Err(e) = self.stackerdb.send_message_with_retry(
-                        self.signing_round.signer_id,
-                        block_rejection.into(),
-                    ) {
-                        warn!("Failed to send block submission to stacker-db: {:?}", e);
-                    }
+                    self.broadcast_signature_hash_rejection(block_validate_reject.block);
                     return;
                 };
-                let block = self
+                let block_info = self
                     .blocks
                     .entry(hash)
                     .or_insert(BlockInfo::new(block_validate_reject.block.clone()));
-                block.valid = Some(false);
-                if let Some(mut block_request) = block.nonce_request.take() {
-                    debug!("Received a block validate reject from the stacks node for a block we already received a nonce request for. Responding to the nonce request...");
-                    // We have an associated nonce request. Respond to it
-                    let mut hash_bytes = hash.0.to_vec();
-                    // Validate the block contents
-                    // We don't like this block. Update the request to be across its hash with a byte indicating a vote no.
-                    debug!("Updating the request with a block hash with a vote no.");
-                    hash_bytes.push(b'n');
-                    // Cache our vote
-                    block.vote = Some(hash_bytes.clone());
-                    block_request.message = hash_bytes;
-                    // Send the nonce request through with our vote
-                    let packet = Packet {
-                        msg: Message::NonceRequest(block_request),
-                        sig: vec![],
-                    };
-                    self.handle_packets(res, &[packet]);
-                }
+                block_info.valid = Some(false);
                 // Submit a rejection response to the .signers contract for miners
                 // to observe so they know to send another block and to prove signers are doing work);
                 if let Err(e) = self.stackerdb.send_message_with_retry(
@@ -372,11 +293,40 @@ impl<C: Coordinator> RunLoop<C> {
                 ) {
                     warn!("Failed to send block rejection to stacker-db: {:?}", e);
                 }
+                (block_info, hash)
+            }
+        };
+
+        if let Some(mut request) = block_info.nonce_request.take() {
+            debug!("Received a block validate response from the stacks node for a block we already received a nonce request for. Responding to the nonce request...");
+            // We have an associated nonce request. Respond to it
+            Self::determine_vote(block_info, &mut request, transactions, hash);
+            // Send the nonce request through with our vote
+            let packet = Packet {
+                msg: Message::NonceRequest(request),
+                sig: vec![],
+            };
+            self.handle_packets(res, &[packet]);
+        } else {
+            let (coordinator_id, _) = calculate_coordinator(&self.signing_round.public_keys);
+            if block_info.valid.unwrap_or(false)
+                && !block_info.signing_round
+                && coordinator_id == self.signing_round.signer_id
+            {
+                debug!("Received a valid block proposal from the miner. Triggering a signing round over it...");
+                // We are the coordinator. Trigger a signing round for this block
+                self.commands.push_back(RunLoopCommand::Sign {
+                    block: block_info.block.clone(),
+                    is_taproot: false,
+                    merkle_root: None,
+                });
+            } else {
+                debug!("Ignoring block proposal.");
             }
         }
     }
 
-    // Handle the stackerdb chunk event as a signer message
+    /// Handle the stackerdb chunk event as a signer message
     fn handle_stackerdb_chunk_event_signers(
         &mut self,
         stackerdb_chunk_event: StackerDBChunksEvent,
@@ -393,7 +343,7 @@ impl<C: Coordinator> RunLoop<C> {
         self.handle_packets(res, &inbound_packets);
     }
 
-    // Handle the stackerdb chunk event as a miner message
+    /// Handle the stackerdb chunk event as a miner message
     fn handle_stackerdb_chunk_event_miners(&mut self, stackerdb_chunk_event: StackerDBChunksEvent) {
         for chunk in &stackerdb_chunk_event.modified_slots {
             let Some(block) = read_next::<NakamotoBlock, _>(&mut &chunk.data[..]).ok() else {
@@ -423,7 +373,7 @@ impl<C: Coordinator> RunLoop<C> {
         }
     }
 
-    /// Helper function to process inbound packets as both a signer and a coordinator
+    /// Process inbound packets as both a signer and a coordinator
     /// Will send outbound packets and operation results as appropriate
     fn handle_packets(&mut self, res: Sender<Vec<OperationResult>>, packets: &[Packet]) {
         let signer_outbound_messages = self
@@ -449,7 +399,7 @@ impl<C: Coordinator> RunLoop<C> {
         self.send_operation_results(res, operation_results);
     }
 
-    /// Helper function to validate a signature share request, updating its message where appropriate.
+    /// Validate a signature share request, updating its message where appropriate.
     /// If the request is for a block it has already agreed to sign, it will overwrite the message with the agreed upon value
     /// Returns whether the request is valid or not.
     fn validate_signature_share_request(&self, request: &mut SignatureShareRequest) -> bool {
@@ -492,8 +442,8 @@ impl<C: Coordinator> RunLoop<C> {
         }
     }
 
-    /// Helper function to validate a nonce request, updating its message appropriately.
-    /// Note that if the request is for a block, we will update the request message
+    /// Validate a nonce request, updating its message appropriately.
+    /// If the request is for a block, we will update the request message
     /// as either a hash indicating a vote no or the signature hash indicating a vote yes
     /// Returns whether the request is valid or not
     fn validate_nonce_request(&mut self, request: &mut NonceRequest) -> bool {
@@ -530,37 +480,37 @@ impl<C: Coordinator> RunLoop<C> {
             block_info.nonce_request = Some(request.clone());
             return false;
         }
-        let mut hash_bytes = hash.0.to_vec();
+        Self::determine_vote(block_info, request, transactions, hash);
+        true
+    }
+
+    /// Determine the vote for a block and update the block info and nonce request accordingly
+    fn determine_vote(
+        block_info: &mut BlockInfo,
+        nonce_request: &mut NonceRequest,
+        transactions: &[Txid],
+        hash: Sha512Trunc256Sum,
+    ) {
+        let mut vote_bytes = hash.0.to_vec();
         // Validate the block contents
         if !block_info.valid.unwrap_or(false)
-            || !Self::verify_block_transactions(block_info, transactions)
+            || !transactions
+                .iter()
+                .all(|txid| block_info.block.txs.iter().any(|tx| &tx.txid() == txid))
         {
             // We don't like this block. Update the request to be across its hash with a byte indicating a vote no.
             debug!("Updating the request with a block hash with a vote no.");
-            hash_bytes.push(b'n');
+            vote_bytes.push(b'n');
         } else {
             debug!("The block passed validation. Update the request with the signature hash.");
         }
-        // Cache our vote
-        block_info.vote = Some(hash_bytes.clone());
-        request.message = hash_bytes;
-        true
-    }
 
-    /// Helper function to verify a block's transactions are as expected
-    fn verify_block_transactions(block_info: &BlockInfo, transactions: &[Txid]) -> bool {
-        // Ensure the block contains the transactions we care about
-        // TODO: add cast_aggregate_public_key to the list of transactions we care about.
-        // This will also need to be flushed from the cache once these transactions are in a signed block
-        for txid in transactions {
-            if block_info.block.txs.iter().any(|tx| &tx.txid() == txid) {
-                return false;
-            }
-        }
-        true
+        // Cache our vote
+        block_info.vote = Some(vote_bytes.clone());
+        nonce_request.message = vote_bytes;
     }
 
-    /// Helper function to verify a chunk is a valid wsts packet.
+    /// Verify a chunk is a valid wsts packet. Returns the packet if it is valid, else None.
     /// NOTE: The packet will be updated if the signer wishes to respond to NonceRequest
     /// and SignatureShareRequests with a different message than what the coordinator originally sent.
     /// This is done to prevent a malicious coordinator from sending a different message than what was
@@ -599,7 +549,7 @@ impl<C: Coordinator> RunLoop<C> {
         }
     }
 
-    /// Helper function to extract block proposals from signature results and braodcast them to the stackerdb slot
+    /// Extract block proposals from signature results and broadcast them to the stackerdb slot
     fn send_block_response_messages(&mut self, operation_results: &[OperationResult]) {
         let Some(aggregate_public_key) = &self.coordinator.get_aggregate_public_key() else {
             debug!("No aggregate public key set. Cannot validate results. Ignoring signature results...");
@@ -652,7 +602,7 @@ impl<C: Coordinator> RunLoop<C> {
         }
     }
 
-    /// Helper function to send operation results across the provided channel
+    /// Send any operation results across the provided channel, updating the state accordingly
     fn send_operation_results(
         &mut self,
         res: Sender<Vec<OperationResult>>,
@@ -673,7 +623,7 @@ impl<C: Coordinator> RunLoop<C> {
         }
     }
 
-    // Helper function for sending packets through stackerdb
+    /// Sending all provided packets through stackerdb with a retry
     fn send_outbound_messages(&mut self, outbound_messages: Vec<Packet>) {
         debug!(
             "Sending {} messages to other stacker-db instances.",
@@ -690,6 +640,19 @@ impl<C: Coordinator> RunLoop<C> {
             }
         }
     }
+
+    /// Broadcast a block rejection due to an invalid block signature hash
+    fn broadcast_signature_hash_rejection(&mut self, block: NakamotoBlock) {
+        debug!("Broadcasting a block rejection due to a block with an invalid signature hash...");
+        let block_rejection = BlockRejection::new(block, RejectCode::InvalidSignatureHash);
+        // Submit signature result to miners to observe
+        if let Err(e) = self
+            .stackerdb
+            .send_message_with_retry(self.signing_round.signer_id, block_rejection.into())
+        {
+            warn!("Failed to send block submission to stacker-db: {:?}", e);
+        }
+    }
 }
 
 impl From<&Config> for RunLoop<FireCoordinator<v2::Aggregator>> {

From 0733896d8e27d5628999e05ff0d0a574b5ff7e6f Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Mon, 22 Jan 2024 15:52:13 -0800
Subject: [PATCH 0453/1166] WIP: schnorr proof verification is failing

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 testnet/stacks-node/src/tests/signer.rs | 262 ++++++------------------
 1 file changed, 65 insertions(+), 197 deletions(-)

diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index d747d5d430..7f611fcfc8 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -4,29 +4,26 @@ use std::sync::{Arc, Mutex};
 use std::time::Duration;
 use std::{env, thread};
 
-use clarity::vm::ast::ASTRules;
 use clarity::vm::types::QualifiedContractIdentifier;
 use libsigner::{RunningSigner, Signer, SignerEventReceiver};
-use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::coordinator::comm::CoordinatorChannels;
-use stacks::chainstate::nakamoto::miner::NakamotoBlockBuilder;
-use stacks::chainstate::nakamoto::NakamotoChainState;
+use stacks::chainstate::nakamoto::{NakamotoBlock, NakamotoBlockHeader};
 use stacks::chainstate::stacks::boot::MINERS_NAME;
-use stacks::chainstate::stacks::db::StacksChainState;
-use stacks::chainstate::stacks::miner::{BlockBuilder, BlockLimitFunction, TransactionResult};
-use stacks::chainstate::stacks::{
-    StacksPrivateKey, StacksTransaction, ThresholdSignature, TransactionPayload,
-};
+use stacks::chainstate::stacks::{StacksPrivateKey, ThresholdSignature};
 use stacks::net::api::postblock_proposal::BlockValidateResponse;
 use stacks::util_lib::boot::boot_code_id;
-use stacks_common::codec::StacksMessageCodec;
-use stacks_common::types::chainstate::{StacksAddress, StacksPublicKey};
+use stacks_common::types::chainstate::{
+    ConsensusHash, StacksAddress, StacksBlockId, StacksPublicKey, TrieHash,
+};
+use stacks_common::util::hash::{MerkleTree, Sha512Trunc256Sum};
+use stacks_common::util::secp256k1::MessageSignature;
 use stacks_signer::client::{BlockResponse, SignerMessage, SIGNER_SLOTS_PER_USER};
 use stacks_signer::config::{Config as SignerConfig, Network};
 use stacks_signer::runloop::RunLoopCommand;
 use stacks_signer::utils::{build_signer_config_tomls, build_stackerdb_contract};
 use tracing_subscriber::prelude::*;
 use tracing_subscriber::{fmt, EnvFilter};
+use wsts::curve::point::Point;
 use wsts::state_machine::coordinator::fire::Coordinator as FireCoordinator;
 use wsts::state_machine::OperationResult;
 use wsts::v2;
@@ -42,7 +39,7 @@ use crate::tests::nakamoto_integrations::{
 use crate::tests::neon_integrations::{
     next_block_and_wait, submit_tx, test_observer, wait_for_runloop,
 };
-use crate::tests::{make_contract_publish, make_stacks_transfer, to_addr};
+use crate::tests::{make_contract_publish, to_addr};
 use crate::{BitcoinRegtestController, BurnchainController};
 
 // Helper struct for holding the btc and stx neon nodes
@@ -72,8 +69,6 @@ struct SignerTest {
     pub running_coordinator: RunningSigner<SignerEventReceiver, Vec<OperationResult>>,
     // The running signer and its threads
     pub running_signers: Vec<RunningSigner<SignerEventReceiver, Vec<OperationResult>>>,
-    // The signer private keys
-    pub signer_stacks_private_keys: Vec<StacksPrivateKey>,
 }
 
 impl SignerTest {
@@ -151,7 +146,6 @@ impl SignerTest {
             coordinator_cmd_sender,
             running_coordinator,
             running_signers,
-            signer_stacks_private_keys,
         }
     }
 
@@ -350,9 +344,44 @@ fn stackerdb_dkg_sign() {
         .init();
 
     info!("------------------------- Test Setup -------------------------");
-    let mut signer_test = SignerTest::new(10, 400);
 
-    // First run DKG in order to sign the block that arrives from the miners following a nakamoto block production
+    info!("Creating an invalid block to sign...");
+    let header = NakamotoBlockHeader {
+        version: 1,
+        chain_length: 2,
+        burn_spent: 3,
+        consensus_hash: ConsensusHash([0x04; 20]),
+        parent_block_id: StacksBlockId([0x05; 32]),
+        tx_merkle_root: Sha512Trunc256Sum([0x06; 32]),
+        state_index_root: TrieHash([0x07; 32]),
+        miner_signature: MessageSignature::empty(),
+        signer_signature: ThresholdSignature::mock(),
+    };
+    let mut block = NakamotoBlock {
+        header,
+        txs: vec![],
+    };
+    let tx_merkle_root = {
+        let txid_vecs = block
+            .txs
+            .iter()
+            .map(|tx| tx.txid().as_bytes().to_vec())
+            .collect();
+
+        MerkleTree::<Sha512Trunc256Sum>::new(&txid_vecs).root()
+    };
+    block.header.tx_merkle_root = tx_merkle_root;
+
+    // The block is valid so the signers should return a signature across its hash + b'n'
+    let mut msg = block
+        .header
+        .signature_hash()
+        .expect("Failed to get signature hash")
+        .0
+        .to_vec();
+    msg.push(b'n');
+
+    let signer_test = SignerTest::new(5, 5);
 
     info!("------------------------- Test DKG -------------------------");
     info!("signer_runloop: spawn send commands to do dkg");
@@ -361,7 +390,7 @@ fn stackerdb_dkg_sign() {
         .coordinator_cmd_sender
         .send(RunLoopCommand::Dkg)
         .expect("failed to send Dkg command");
-    let mut aggregate_public_key_res = None;
+    let mut key = Point::default();
     for recv in signer_test.result_receivers.iter() {
         let mut aggregate_public_key = None;
         loop {
@@ -386,189 +415,14 @@ fn stackerdb_dkg_sign() {
                     }
                 }
             }
-            if aggregate_public_key.is_some() {
-                aggregate_public_key_res = aggregate_public_key;
+            if aggregate_public_key.is_some() || dkg_now.elapsed() > Duration::from_secs(100) {
                 break;
             }
         }
+        key = aggregate_public_key.expect("Failed to get aggregate public key within 100 seconds");
     }
-    aggregate_public_key_res.expect("Failed to get aggregate public key");
     let dkg_elapsed = dkg_now.elapsed();
 
-    let (vrfs_submitted, commits_submitted) = (
-        signer_test.running_nodes.vrfs_submitted.clone(),
-        signer_test.running_nodes.commits_submitted.clone(),
-    );
-
-    info!("------------------------- Mine a Nakamoto Tenure -------------------------");
-
-    // first block wakes up the run loop, wait until a key registration has been submitted.
-    next_block_and(
-        &mut signer_test.running_nodes.btc_regtest_controller,
-        60,
-        || {
-            let vrf_count = vrfs_submitted.load(Ordering::SeqCst);
-            Ok(vrf_count >= 1)
-        },
-    )
-    .unwrap();
-
-    // second block should confirm the VRF register, wait until a block commit is submitted
-    next_block_and(
-        &mut signer_test.running_nodes.btc_regtest_controller,
-        60,
-        || {
-            let commits_count = commits_submitted.load(Ordering::SeqCst);
-            Ok(commits_count >= 1)
-        },
-    )
-    .unwrap();
-
-    // Mine 1 nakamoto tenures
-    next_block_and_mine_commit(
-        &mut signer_test.running_nodes.btc_regtest_controller,
-        60,
-        &signer_test.running_nodes.coord_channel,
-        &commits_submitted,
-    )
-    .unwrap();
-
-    // Ensure we signed the proposed block and flush the operation results receiver of it
-    for recv in signer_test.result_receivers.iter() {
-        let mut frost_signature = None;
-        loop {
-            let results = recv.recv().expect("failed to recv results");
-            for result in results {
-                match result {
-                    OperationResult::Sign(sig) => {
-                        info!("Received Signature ({},{})", &sig.R, &sig.z);
-                        frost_signature = Some(sig);
-                    }
-                    OperationResult::SignTaproot(proof) => {
-                        panic!("Received SchnorrProof ({},{})", &proof.r, &proof.s);
-                    }
-                    OperationResult::DkgError(dkg_error) => {
-                        panic!("Received DkgError {:?}", dkg_error);
-                    }
-                    OperationResult::SignError(sign_error) => {
-                        panic!("Received SignError {}", sign_error);
-                    }
-                    OperationResult::Dkg(point) => {
-                        panic!("Received aggregate_group_key {point}");
-                    }
-                }
-            }
-            if frost_signature.is_some() {
-                break;
-            }
-        }
-    }
-
-    info!("Generating a valid block to sign...");
-
-    let burnchain = signer_test.running_nodes.conf.get_burnchain();
-    let sortdb = burnchain.open_sortition_db(true).unwrap();
-    let (mut chainstate, _) = StacksChainState::open(
-        signer_test.running_nodes.conf.is_mainnet(),
-        signer_test.running_nodes.conf.burnchain.chain_id,
-        &signer_test.running_nodes.conf.get_chainstate_path_str(),
-        None,
-    )
-    .unwrap();
-
-    // TODO (hack) instantiate the sortdb in the burnchain
-    _ = signer_test
-        .running_nodes
-        .btc_regtest_controller
-        .sortdb_mut();
-
-    // ----- Setup boilerplate finished, test block proposal API endpoint -----
-
-    let tip = NakamotoChainState::get_canonical_block_header(chainstate.db(), &sortdb)
-        .unwrap()
-        .unwrap();
-
-    let privk = signer_test
-        .running_nodes
-        .conf
-        .miner
-        .mining_key
-        .unwrap()
-        .clone();
-    let sort_tip = SortitionDB::get_canonical_sortition_tip(sortdb.conn())
-        .expect("Failed to get sortition tip");
-    let db_handle = sortdb.index_handle(&sort_tip);
-    let snapshot = db_handle
-        .get_block_snapshot(&tip.burn_header_hash)
-        .expect("Failed to get block snapshot")
-        .expect("No snapshot");
-    // Double check we got the right sortition
-    assert_eq!(
-        snapshot.consensus_hash, tip.consensus_hash,
-        "Found incorrect block snapshot"
-    );
-    let total_burn = snapshot.total_burn;
-    let tenure_change = None;
-    let coinbase = None;
-
-    let tenure_cause = tenure_change.and_then(|tx: &StacksTransaction| match &tx.payload {
-        TransactionPayload::TenureChange(tc) => Some(tc.cause),
-        _ => None,
-    });
-
-    let mut block = {
-        let mut builder = NakamotoBlockBuilder::new(
-            &tip,
-            &tip.consensus_hash,
-            total_burn,
-            tenure_change,
-            coinbase,
-        )
-        .expect("Failed to build Nakamoto block");
-
-        let burn_dbconn = signer_test
-            .running_nodes
-            .btc_regtest_controller
-            .sortdb_ref()
-            .index_conn();
-        let mut miner_tenure_info = builder
-            .load_tenure_info(&mut chainstate, &burn_dbconn, tenure_cause)
-            .unwrap();
-        let mut tenure_tx = builder
-            .tenure_begin(&burn_dbconn, &mut miner_tenure_info)
-            .unwrap();
-
-        let tx = make_stacks_transfer(
-            &signer_test.signer_stacks_private_keys[0],
-            0,
-            100,
-            &to_addr(&signer_test.signer_stacks_private_keys[1]).into(),
-            10000,
-        );
-        let tx = StacksTransaction::consensus_deserialize(&mut &tx[..])
-            .expect("Failed to deserialize transaction");
-        let tx_len = tx.tx_len();
-
-        let res = builder.try_mine_tx_with_len(
-            &mut tenure_tx,
-            &tx,
-            tx_len,
-            &BlockLimitFunction::NO_LIMIT_HIT,
-            ASTRules::PrecheckSize,
-        );
-        assert!(
-            matches!(res, TransactionResult::Success(..)),
-            "Transaction failed"
-        );
-        builder.mine_nakamoto_block(&mut tenure_tx)
-    };
-
-    // Sign the block
-    block
-        .header
-        .sign_miner(&privk)
-        .expect("Miner failed to sign");
-
     info!("------------------------- Test Sign -------------------------");
     let sign_now = std::time::Instant::now();
     info!("signer_runloop: spawn send commands to do dkg and then sign");
@@ -610,14 +464,28 @@ fn stackerdb_dkg_sign() {
                         panic!("Received SignError {}", sign_error);
                     }
                     OperationResult::Dkg(point) => {
-                        info!("Received aggregate_group_key {point}");
+                        panic!("Received aggregate_group_key {point}");
                     }
                 }
             }
-            if frost_signature.is_some() && schnorr_proof.is_some() {
+            if frost_signature.is_some() && schnorr_proof.is_some()
+                || sign_now.elapsed() > Duration::from_secs(100)
+            {
                 break;
             }
         }
+        let frost_signature =
+            frost_signature.expect("Failed to get frost signature within 100 seconds");
+        assert!(
+            frost_signature.verify(&key, msg.as_slice()),
+            "Signature verification failed"
+        );
+        let schnorr_proof =
+            schnorr_proof.expect("Failed to get schnorr proof signature within 100 seconds");
+        assert!(
+            schnorr_proof.verify(&key.x(), &msg.as_slice()),
+            "Schnorr proof verification failed"
+        );
     }
     let sign_elapsed = sign_now.elapsed();
 

From 7ec7541b47e362752b4ffd683d6ef0cd10a95275 Mon Sep 17 00:00:00 2001
From: Joey Yandle <xoloki@gmail.com>
Date: Tue, 23 Jan 2024 11:20:26 -0500
Subject: [PATCH 0454/1166] need to check a SchnorrProof against a tweaked key,
 maybe need a SchnorrProof::verify_untweaked

---
 testnet/stacks-node/src/tests/signer.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index 7f611fcfc8..efff7b9771 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -468,7 +468,7 @@ fn stackerdb_dkg_sign() {
                     }
                 }
             }
-            if frost_signature.is_some() && schnorr_proof.is_some()
+            if (frost_signature.is_some() && schnorr_proof.is_some())
                 || sign_now.elapsed() > Duration::from_secs(100)
             {
                 break;
@@ -482,8 +482,9 @@ fn stackerdb_dkg_sign() {
         );
         let schnorr_proof =
             schnorr_proof.expect("Failed to get schnorr proof signature within 100 seconds");
+        let tweaked_key = wsts::compute::tweaked_public_key(&key, None);
         assert!(
-            schnorr_proof.verify(&key.x(), &msg.as_slice()),
+            schnorr_proof.verify(&tweaked_key.x(), &msg.as_slice()),
             "Schnorr proof verification failed"
         );
     }

From c846aeaa461cd188b42b009f900c2e9666e0ca97 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Tue, 23 Jan 2024 09:45:57 -0800
Subject: [PATCH 0455/1166] Revert accidental change to stackerdb_dkg_sign num
 of signers and keys

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 testnet/stacks-node/src/tests/signer.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index efff7b9771..0ee021858f 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -381,7 +381,7 @@ fn stackerdb_dkg_sign() {
         .to_vec();
     msg.push(b'n');
 
-    let signer_test = SignerTest::new(5, 5);
+    let signer_test = SignerTest::new(10, 400);
 
     info!("------------------------- Test DKG -------------------------");
     info!("signer_runloop: spawn send commands to do dkg");

From abbead4b91a6d98d711a53cd24dcab01829a12e3 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Tue, 23 Jan 2024 10:30:40 -0800
Subject: [PATCH 0456/1166] Cleanup tests

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 testnet/stacks-node/src/tests/signer.rs | 30 ++++++++++++++++---------
 1 file changed, 19 insertions(+), 11 deletions(-)

diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index 0ee021858f..9aec1a0e83 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -1,7 +1,7 @@
 use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
 use std::sync::mpsc::{channel, Receiver, Sender};
 use std::sync::{Arc, Mutex};
-use std::time::Duration;
+use std::time::{Duration, Instant};
 use std::{env, thread};
 
 use clarity::vm::types::QualifiedContractIdentifier;
@@ -372,7 +372,7 @@ fn stackerdb_dkg_sign() {
     };
     block.header.tx_merkle_root = tx_merkle_root;
 
-    // The block is valid so the signers should return a signature across its hash + b'n'
+    // The block is invalid so the signers should return a signature across its hash + b'n'
     let mut msg = block
         .header
         .signature_hash()
@@ -385,7 +385,7 @@ fn stackerdb_dkg_sign() {
 
     info!("------------------------- Test DKG -------------------------");
     info!("signer_runloop: spawn send commands to do dkg");
-    let dkg_now = std::time::Instant::now();
+    let dkg_now = Instant::now();
     signer_test
         .coordinator_cmd_sender
         .send(RunLoopCommand::Dkg)
@@ -394,7 +394,9 @@ fn stackerdb_dkg_sign() {
     for recv in signer_test.result_receivers.iter() {
         let mut aggregate_public_key = None;
         loop {
-            let results = recv.recv().expect("failed to recv results");
+            let results = recv
+                .recv_timeout(Duration::from_secs(30))
+                .expect("failed to recv dkg results");
             for result in results {
                 match result {
                     OperationResult::Sign(sig) => {
@@ -424,7 +426,7 @@ fn stackerdb_dkg_sign() {
     let dkg_elapsed = dkg_now.elapsed();
 
     info!("------------------------- Test Sign -------------------------");
-    let sign_now = std::time::Instant::now();
+    let sign_now = Instant::now();
     info!("signer_runloop: spawn send commands to do dkg and then sign");
     signer_test
         .coordinator_cmd_sender
@@ -446,7 +448,9 @@ fn stackerdb_dkg_sign() {
         let mut frost_signature = None;
         let mut schnorr_proof = None;
         loop {
-            let results = recv.recv().expect("failed to recv results");
+            let results = recv
+                .recv_timeout(Duration::from_secs(30))
+                .expect("failed to recv signature results");
             for result in results {
                 match result {
                     OperationResult::Sign(sig) => {
@@ -539,7 +543,9 @@ fn stackerdb_block_proposal() {
         .result_receivers
         .last()
         .expect("Failed to get coordinator recv");
-    let results = recv.recv().expect("failed to recv results");
+    let results = recv
+        .recv_timeout(Duration::from_secs(30))
+        .expect("failed to recv dkg results");
     for result in results {
         match result {
             OperationResult::Dkg(point) => {
@@ -597,7 +603,9 @@ fn stackerdb_block_proposal() {
         .result_receivers
         .last()
         .expect("Failed to retreive coordinator recv");
-    let results = recv.recv().expect("failed to recv results");
+    let results = recv
+        .recv_timeout(Duration::from_secs(30))
+        .expect("failed to recv signature results");
     let mut signature = None;
     for result in results {
         match result {
@@ -614,7 +622,7 @@ fn stackerdb_block_proposal() {
     let signature = signature.expect("Failed to get signature");
     // Wait for the block to show up in the test observer (Don't have to wait long as if we have received a signature,
     // we know that the signers have already received their block proposal events via their event observers)
-    let t_start = std::time::Instant::now();
+    let t_start = Instant::now();
     while test_observer::get_proposal_responses().is_empty() {
         assert!(
             t_start.elapsed() < Duration::from_secs(30),
@@ -636,14 +644,13 @@ fn stackerdb_block_proposal() {
         "Signature verification failed"
     );
     // Verify that the signers broadcasted a signed NakamotoBlock back to the .signers contract
-    let t_start = std::time::Instant::now();
+    let t_start = Instant::now();
     let mut chunk = None;
     while chunk.is_none() {
         assert!(
             t_start.elapsed() < Duration::from_secs(30),
             "Timed out while waiting for signers block response stacker db event"
         );
-        thread::sleep(Duration::from_secs(1));
 
         let nakamoto_blocks = test_observer::get_stackerdb_chunks();
         for event in nakamoto_blocks {
@@ -658,6 +665,7 @@ fn stackerdb_block_proposal() {
                 break;
             }
         }
+        thread::sleep(Duration::from_secs(1));
     }
     let chunk = chunk.unwrap();
     let signer_message = bincode::deserialize::<SignerMessage>(&chunk).unwrap();

From 0d8d736b2ce4f41bfb839e5a7c7b74c85e702e14 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Tue, 23 Jan 2024 15:35:53 -0600
Subject: [PATCH 0457/1166] feat: add MAX_SIZE generic to BitVec struct, set to
 4000 for signers vec

---
 stacks-common/src/bitvec.rs                   | 87 ++++++++++++++++---
 stackslib/src/chainstate/nakamoto/mod.rs      |  9 +-
 .../src/chainstate/nakamoto/tests/mod.rs      | 18 ++--
 testnet/stacks-node/src/mockamoto.rs          |  3 +-
 4 files changed, 90 insertions(+), 27 deletions(-)

diff --git a/stacks-common/src/bitvec.rs b/stacks-common/src/bitvec.rs
index 707fc960d5..00d1c18b69 100644
--- a/stacks-common/src/bitvec.rs
+++ b/stacks-common/src/bitvec.rs
@@ -8,12 +8,21 @@ use crate::codec::{
 use crate::util::hash::{bytes_to_hex, hex_bytes};
 
 #[derive(Clone, PartialEq, Eq, Debug)]
-pub struct BitVec {
+/// This data structure represents a list of booleans
+/// as a bitvector.
+///
+/// The generic argument `MAX_SIZE` specifies the maximum number of
+/// elements that the bit vector can hold. It is not the _actual_ size
+/// of the bitvec: if there are only 8 entries, the bitvector will
+/// just have a single byte, even if the MAX_SIZE is u16::MAX. This
+/// type parameter ensures that constructors and deserialization routines
+/// error if input data is too long.
+pub struct BitVec<const MAX_SIZE: u16> {
     data: Vec<u8>,
     len: u16,
 }
 
-impl TryFrom<&[bool]> for BitVec {
+impl<const MAX_SIZE: u16> TryFrom<&[bool]> for BitVec<MAX_SIZE> {
     type Error = String;
 
     fn try_from(value: &[bool]) -> Result<Self, Self::Error> {
@@ -24,7 +33,12 @@ impl TryFrom<&[bool]> for BitVec {
         if len == 0 {
             return Err("BitVec length must be positive".into());
         }
-        let mut bitvec = BitVec::zeros(len);
+        if len > MAX_SIZE {
+            return Err(format!(
+                "BitVec length is too long. Max size = {MAX_SIZE}, Input len = {len}"
+            ));
+        }
+        let mut bitvec = BitVec::zeros(len)?;
         for (ix, bool_value) in value.iter().enumerate() {
             let ix = ix.try_into().map_err(|_| "BitVec length must be u16")?;
             // only need to set the bitvec value if `bool_value` is true,
@@ -37,7 +51,7 @@ impl TryFrom<&[bool]> for BitVec {
     }
 }
 
-impl StacksMessageCodec for BitVec {
+impl<const MAX_SIZE: u16> StacksMessageCodec for BitVec<MAX_SIZE> {
     fn consensus_serialize<W: std::io::Write>(&self, fd: &mut W) -> Result<(), CodecError> {
         write_next(fd, &self.len)?;
         write_next(fd, &self.data)
@@ -50,20 +64,25 @@ impl StacksMessageCodec for BitVec {
                 "BitVec lengths must be positive".to_string(),
             ));
         }
+        if len > MAX_SIZE {
+            return Err(CodecError::DeserializeError(format!(
+                "BitVec length exceeded maximum. Max size = {MAX_SIZE}, len = {len}"
+            )));
+        }
 
         let data = read_next_exact(fd, Self::data_len(len).into())?;
         Ok(BitVec { data, len })
     }
 }
 
-impl Serialize for BitVec {
+impl<const MAX_SIZE: u16> Serialize for BitVec<MAX_SIZE> {
     fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
         let hex = bytes_to_hex(self.serialize_to_vec().as_slice());
         serializer.serialize_str(&hex)
     }
 }
 
-impl<'de> Deserialize<'de> for BitVec {
+impl<'de, const MAX_SIZE: u16> Deserialize<'de> for BitVec<MAX_SIZE> {
     fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
         let hex: &str = Deserialize::deserialize(deserializer)?;
         let bytes = hex_bytes(hex).map_err(serde::de::Error::custom)?;
@@ -71,7 +90,7 @@ impl<'de> Deserialize<'de> for BitVec {
     }
 }
 
-impl FromSql for BitVec {
+impl<const MAX_SIZE: u16> FromSql for BitVec<MAX_SIZE> {
     fn column_result(value: ValueRef<'_>) -> FromSqlResult<Self> {
         let bytes = hex_bytes(value.as_str()?).map_err(|e| FromSqlError::Other(Box::new(e)))?;
         Self::consensus_deserialize(&mut bytes.as_slice())
@@ -79,18 +98,23 @@ impl FromSql for BitVec {
     }
 }
 
-impl ToSql for BitVec {
+impl<const MAX_SIZE: u16> ToSql for BitVec<MAX_SIZE> {
     fn to_sql(&self) -> rusqlite::Result<ToSqlOutput<'_>> {
         let hex = bytes_to_hex(self.serialize_to_vec().as_slice());
         Ok(hex.into())
     }
 }
 
-impl BitVec {
+impl<const MAX_SIZE: u16> BitVec<MAX_SIZE> {
     /// Construct a new BitVec with all entries set to `false` and total length `len`
-    pub fn zeros(len: u16) -> BitVec {
+    pub fn zeros(len: u16) -> Result<BitVec<MAX_SIZE>, String> {
+        if len > MAX_SIZE {
+            return Err(format!(
+                "BitVec length is too long. Max size = {MAX_SIZE}, Input len = {len}"
+            ));
+        }
         let data = vec![0; usize::from(Self::data_len(len))];
-        BitVec { data, len }
+        Ok(BitVec { data, len })
     }
 
     pub fn len(&self) -> u16 {
@@ -145,7 +169,7 @@ mod test {
     use super::BitVec;
     use crate::codec::StacksMessageCodec;
 
-    fn check_set_get(mut input: BitVec) {
+    fn check_set_get(mut input: BitVec<{ u16::MAX }>) {
         let original_input = input.clone();
         for i in 0..input.len() {
             let original_value = input.get(i).unwrap();
@@ -173,7 +197,7 @@ mod test {
         assert!(input.set(input.len(), false).is_err());
     }
 
-    fn check_serialization(input: &BitVec) {
+    fn check_serialization(input: &BitVec<{ u16::MAX }>) {
         let byte_ser = input.serialize_to_vec();
         let deserialized = BitVec::consensus_deserialize(&mut byte_ser.as_slice()).unwrap();
         assert_eq!(input, &deserialized);
@@ -185,11 +209,48 @@ mod test {
         for (ix, value) in input.iter().enumerate() {
             assert_eq!(bitvec.get(u16::try_from(ix).unwrap()), Some(*value));
         }
+        // check that a length check will fail
+        let passed_len_2_check = BitVec::<2>::try_from(input).is_ok();
+        if input.len() <= 2 {
+            assert!(
+                passed_len_2_check,
+                "BitVec should pass assembly in length-2 max because input is length-2"
+            );
+        } else {
+            assert!(!passed_len_2_check, "BitVec should fail assembly in length-2 max because input is greater that length-2");
+        }
+        // check that a length check will fail on deserialization
+        let serialization = bitvec.serialize_to_vec();
+        let passed_len_2_deser =
+            BitVec::<2>::consensus_deserialize(&mut serialization.as_slice()).is_ok();
+        if input.len() <= 2 {
+            assert!(
+                passed_len_2_deser,
+                "BitVec should pass assembly in length-2 max because input is length-2"
+            );
+        } else {
+            assert!(!passed_len_2_deser, "BitVec should fail assembly in length-2 max because input is greater that length-2");
+        }
 
         check_serialization(&bitvec);
         check_set_get(bitvec);
     }
 
+    #[test]
+    fn zeros_constructor() {
+        let bitvec_zero_10 = BitVec::<10>::zeros(10).unwrap();
+        for i in 0..10 {
+            assert!(
+                !bitvec_zero_10.get(i).unwrap(),
+                "All values of zero vec should be false"
+            );
+        }
+        assert!(
+            BitVec::<2>::zeros(3).is_err(),
+            "Should fail to construct a length 3 zero vec when bound to bitlength 2"
+        );
+    }
+
     #[test]
     fn vectors() {
         let mut inputs = vec![
diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index c99c243e01..866be31d70 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -317,7 +317,8 @@ pub struct NakamotoBlockHeader {
     /// Schnorr signature over the block header from the signer set active during the tenure.
     pub signer_signature: ThresholdSignature,
     /// A bitvec which represents the signers that participated in this block signature.
-    pub signer_bitvec: BitVec,
+    /// The maximum number of entries in the bitvec is 4000.
+    pub signer_bitvec: BitVec<4000>,
 }
 
 impl FromRow<NakamotoBlockHeader> for NakamotoBlockHeader {
@@ -474,7 +475,7 @@ impl NakamotoBlockHeader {
             state_index_root: TrieHash([0u8; 32]),
             miner_signature: MessageSignature::empty(),
             signer_signature: ThresholdSignature::empty(),
-            signer_bitvec: BitVec::zeros(1),
+            signer_bitvec: BitVec::zeros(1).expect("BUG: bitvec of length-1 failed to construct"),
         }
     }
 
@@ -490,7 +491,7 @@ impl NakamotoBlockHeader {
             state_index_root: TrieHash([0u8; 32]),
             miner_signature: MessageSignature::empty(),
             signer_signature: ThresholdSignature::empty(),
-            signer_bitvec: BitVec::zeros(1),
+            signer_bitvec: BitVec::zeros(1).expect("BUG: bitvec of length-1 failed to construct"),
         }
     }
 
@@ -506,7 +507,7 @@ impl NakamotoBlockHeader {
             state_index_root: TrieHash([0u8; 32]),
             miner_signature: MessageSignature::empty(),
             signer_signature: ThresholdSignature::empty(),
-            signer_bitvec: BitVec::zeros(1),
+            signer_bitvec: BitVec::zeros(1).expect("BUG: bitvec of length-1 failed to construct"),
         }
     }
 }
diff --git a/stackslib/src/chainstate/nakamoto/tests/mod.rs b/stackslib/src/chainstate/nakamoto/tests/mod.rs
index 28c52bd029..46e88e8d64 100644
--- a/stackslib/src/chainstate/nakamoto/tests/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/mod.rs
@@ -118,7 +118,7 @@ fn codec_nakamoto_header() {
         state_index_root: TrieHash([0x07; 32]),
         miner_signature: MessageSignature::empty(),
         signer_signature: ThresholdSignature::empty(),
-        signer_bitvec: BitVec::zeros(8),
+        signer_bitvec: BitVec::zeros(8).unwrap(),
     };
 
     let mut bytes = vec![
@@ -168,7 +168,7 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
         state_index_root: TrieHash([0x07; 32]),
         miner_signature: MessageSignature::empty(),
         signer_signature: ThresholdSignature::empty(),
-        signer_bitvec: BitVec::zeros(1),
+        signer_bitvec: BitVec::zeros(1).unwrap(),
     };
 
     // sortition-inducing tenure change
@@ -666,7 +666,7 @@ pub fn test_load_store_update_nakamoto_blocks() {
         state_index_root: TrieHash([0x07; 32]),
         miner_signature: MessageSignature::empty(),
         signer_signature: ThresholdSignature::empty(),
-        signer_bitvec: BitVec::zeros(1),
+        signer_bitvec: BitVec::zeros(1).unwrap(),
     };
 
     let nakamoto_header_info = StacksHeaderInfo {
@@ -710,7 +710,7 @@ pub fn test_load_store_update_nakamoto_blocks() {
         state_index_root: TrieHash([0x07; 32]),
         miner_signature: MessageSignature::empty(),
         signer_signature: ThresholdSignature::empty(),
-        signer_bitvec: BitVec::zeros(1),
+        signer_bitvec: BitVec::zeros(1).unwrap(),
     };
 
     let nakamoto_header_info_2 = StacksHeaderInfo {
@@ -1347,7 +1347,7 @@ fn test_nakamoto_block_static_verification() {
         state_index_root: TrieHash([0x07; 32]),
         miner_signature: MessageSignature::empty(),
         signer_signature: ThresholdSignature::empty(),
-        signer_bitvec: BitVec::zeros(1),
+        signer_bitvec: BitVec::zeros(1).unwrap(),
     };
     nakamoto_header.sign_miner(&private_key).unwrap();
 
@@ -1366,7 +1366,7 @@ fn test_nakamoto_block_static_verification() {
         state_index_root: TrieHash([0x07; 32]),
         miner_signature: MessageSignature::empty(),
         signer_signature: ThresholdSignature::empty(),
-        signer_bitvec: BitVec::zeros(1),
+        signer_bitvec: BitVec::zeros(1).unwrap(),
     };
     nakamoto_header_bad_ch.sign_miner(&private_key).unwrap();
 
@@ -1385,7 +1385,7 @@ fn test_nakamoto_block_static_verification() {
         state_index_root: TrieHash([0x07; 32]),
         miner_signature: MessageSignature::empty(),
         signer_signature: ThresholdSignature::empty(),
-        signer_bitvec: BitVec::zeros(1),
+        signer_bitvec: BitVec::zeros(1).unwrap(),
     };
     nakamoto_header_bad_miner_sig
         .sign_miner(&private_key)
@@ -1536,7 +1536,7 @@ pub fn test_get_highest_nakamoto_tenure() {
             state_index_root: TrieHash([0x00; 32]),
             miner_signature: MessageSignature::empty(),
             signer_signature: ThresholdSignature::empty(),
-            signer_bitvec: BitVec::zeros(1),
+            signer_bitvec: BitVec::zeros(1).unwrap(),
         };
         let tenure_change = TenureChangePayload {
             tenure_consensus_hash: sn.consensus_hash.clone(),
@@ -1834,7 +1834,7 @@ fn test_make_miners_stackerdb_config() {
             state_index_root: TrieHash([0x07; 32]),
             miner_signature: MessageSignature::empty(),
             signer_signature: ThresholdSignature::empty(),
-            signer_bitvec: BitVec::zeros(1),
+            signer_bitvec: BitVec::zeros(1).unwrap(),
         };
         let block = NakamotoBlock {
             header,
diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index 6fa831fd8f..528a13018b 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -971,7 +971,8 @@ impl MockamotoNode {
                 miner_signature: MessageSignature::empty(),
                 consensus_hash: sortition_tip.consensus_hash.clone(),
                 parent_block_id: StacksBlockId::new(&chain_tip_ch, &chain_tip_bh),
-                signer_bitvec: BitVec::zeros(1),
+                signer_bitvec: BitVec::zeros(1)
+                    .expect("BUG: bitvec of length-1 failed to construct"),
             },
             txs: builder.txs,
         };

From c0355b28f8ffbe049a3cd77e33217687acbab925 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 23 Jan 2024 17:10:29 -0500
Subject: [PATCH 0458/1166] fix: if we hit message EOF, then return so that the
 caller can refill the write-end of the pipe

---
 stackslib/src/main.rs           | 15 ++++++++++++---
 stackslib/src/net/connection.rs | 10 +++++-----
 2 files changed, 17 insertions(+), 8 deletions(-)

diff --git a/stackslib/src/main.rs b/stackslib/src/main.rs
index 191c353fb8..7117a5d6f3 100644
--- a/stackslib/src/main.rs
+++ b/stackslib/src/main.rs
@@ -248,9 +248,18 @@ fn main() {
             }
             buf
         };
-        let msg: StacksMessage = read_next(&mut &buf[..]).unwrap();
-        println!("{:#?}", &msg);
-        process::exit(0);
+        match read_next::<StacksMessage, _>(&mut &buf[..]) {
+            Ok(msg) => {
+                println!("{:#?}", &msg);
+                process::exit(0);
+            }
+            Err(_) => {
+                let ptr = &mut &buf[..];
+                let mut debug_cursor = LogReader::from_reader(ptr);
+                let _ = read_next::<StacksMessage, _>(&mut debug_cursor);
+                process::exit(1);
+            }
+        }
     }
 
     if argv[1] == "get-tenure" {
diff --git a/stackslib/src/net/connection.rs b/stackslib/src/net/connection.rs
index 15f0e36a65..88f3fff39b 100644
--- a/stackslib/src/net/connection.rs
+++ b/stackslib/src/net/connection.rs
@@ -1062,9 +1062,8 @@ impl<P: ProtocolFamily> ConnectionOutbox<P> {
         let mut total_sent = 0;
         let mut blocked = false;
         let mut disconnected = false;
-        while !blocked && !disconnected {
-            let mut message_eof = false;
-
+        let mut message_eof = false;
+        while !blocked && !disconnected && !message_eof {
             if self.pending_message_fd.is_none() {
                 self.pending_message_fd = self.begin_next_message();
             }
@@ -1181,9 +1180,10 @@ impl<P: ProtocolFamily> ConnectionOutbox<P> {
         }
 
         test_debug!(
-            "Connection send_bytes finished: blocked = {}, disconnected = {}",
+            "Connection send_bytes finished: blocked = {}, disconnected = {}, eof = {}",
             blocked,
-            disconnected
+            disconnected,
+            message_eof,
         );
 
         if total_sent == 0 {

From d0c111a16177bffa2911ed27ff7800370fa1431b Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 23 Jan 2024 17:31:58 -0500
Subject: [PATCH 0459/1166] fix: if walk step times out, then error out

---
 stackslib/src/net/neighbors/walk.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stackslib/src/net/neighbors/walk.rs b/stackslib/src/net/neighbors/walk.rs
index bd354eebe4..45a3dd7cb4 100644
--- a/stackslib/src/net/neighbors/walk.rs
+++ b/stackslib/src/net/neighbors/walk.rs
@@ -1871,7 +1871,7 @@ impl<DB: NeighborWalkDB, NC: NeighborComms> NeighborWalk<DB, NC> {
                     &self.state,
                     self.walk_state_timeout
                 );
-                return Ok(None);
+                return Err(net_error::StepTimeout);
             }
 
             can_continue = match self.state {

From 6a048a7bb7752863d36f87227e8429825b087c8d Mon Sep 17 00:00:00 2001
From: Marzi <marzi@trustmachines.co>
Date: Mon, 22 Jan 2024 14:24:46 -0500
Subject: [PATCH 0460/1166] Select stacks-signer coordinator dynamically

---
 Cargo.lock                                |  1 +
 stacks-signer/Cargo.toml                  |  1 +
 stacks-signer/src/client/mod.rs           |  3 ++
 stacks-signer/src/client/stacks_client.rs | 43 ++++++++++++++++++++++
 stacks-signer/src/runloop.rs              | 45 +++++++++++++++++++----
 5 files changed, 86 insertions(+), 7 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 95607554c6..c702457fcc 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3595,6 +3595,7 @@ dependencies = [
  "serde_derive",
  "serde_json",
  "serde_stacker",
+ "sha2 0.10.6",
  "slog",
  "slog-json",
  "slog-term",
diff --git a/stacks-signer/Cargo.toml b/stacks-signer/Cargo.toml
index cd5571657f..29f5015643 100644
--- a/stacks-signer/Cargo.toml
+++ b/stacks-signer/Cargo.toml
@@ -42,6 +42,7 @@ toml = "0.5.6"
 tracing = "0.1.37"
 tracing-subscriber = { version = "0.3.17", features = ["env-filter"] }
 wsts = { workspace = true }
+sha2 = "0.10.6"
 
 [dependencies.serde_json]
 version = "1.0"
diff --git a/stacks-signer/src/client/mod.rs b/stacks-signer/src/client/mod.rs
index ec7e8e8235..3eb8881caf 100644
--- a/stacks-signer/src/client/mod.rs
+++ b/stacks-signer/src/client/mod.rs
@@ -39,6 +39,9 @@ const BACKOFF_MAX_INTERVAL: u64 = 16384;
 #[derive(thiserror::Error, Debug)]
 /// Client error type
 pub enum ClientError {
+    /// Error for when a response's format does not match the expected structure
+    #[error("Unexpected response format: {0}")]
+    UnexpectedResponseFormat(String),
     /// An error occurred serializing the message
     #[error("Unable to serialize stacker-db message: {0}")]
     StackerDBSerializationError(#[from] CodecError),
diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index e8a39b82cf..3519d1fd6e 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -67,6 +67,34 @@ impl From<&Config> for StacksClient {
 }
 
 impl StacksClient {
+    /// Retrieve the stacks tip consensus hash from the stacks node
+    pub fn get_stacks_tip_consensus_hash(&self) -> Result<String, ClientError> {
+        let send_request = || {
+            self.stacks_node_client
+                .get(self.core_info_path())
+                .send()
+                .map_err(backoff::Error::transient)
+        };
+
+        let response = retry_with_exponential_backoff(send_request)?;
+        if !response.status().is_success() {
+            return Err(ClientError::RequestFailure(response.status()));
+        }
+
+        let json_response = response
+            .json::<serde_json::Value>()
+            .map_err(ClientError::ReqwestError)?;
+
+        json_response["stacks_tip_consensus_hash"]
+            .as_str()
+            .ok_or_else(|| {
+                ClientError::UnexpectedResponseFormat(
+                    "Missing 'stacks_tip_consensus_hash' field".to_string(),
+                )
+            })
+            .map(|s| s.to_string())
+    }
+
     /// Submit the block proposal to the stacks node. The block will be validated and returned via the HTTP endpoint for Block events.
     pub fn submit_block_for_validation(&self, block: NakamotoBlock) -> Result<(), ClientError> {
         let block_proposal = NakamotoBlockProposal {
@@ -309,6 +337,10 @@ impl StacksClient {
     fn block_proposal_path(&self) -> String {
         format!("{}/v2/block_proposal", self.http_origin)
     }
+
+    fn core_info_path(&self) -> String {
+        format!("{}/v2/info", self.http_origin)
+    }
 }
 
 #[cfg(test)]
@@ -591,4 +623,15 @@ mod tests {
         );
         assert!(h.join().unwrap().is_ok());
     }
+
+    #[test]
+    fn core_info_call_for_consensus_hash_should_succeed() {
+        let config = TestConfig::new();
+        let h = spawn(move || config.client.get_stacks_tip_consensus_hash());
+        write_response(
+            config.mock_server,
+            b"HTTP/1.1 200 OK\n\n{\"stacks_tip_consensus_hash\": \"4e99f99bc4a05437abb8c7d0c306618f45b203196498e2ebe287f10497124958\"}",
+        );
+        assert!(h.join().unwrap().is_ok());
+    }
 }
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index cfe03a350d..3fa441c4b6 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -27,6 +27,7 @@ use blockstack_lib::util_lib::boot::boot_code_id;
 use hashbrown::{HashMap, HashSet};
 use libsigner::{SignerEvent, SignerRunLoop};
 use libstackerdb::StackerDBChunkData;
+use sha2::{Digest, Sha256};
 use slog::{slog_debug, slog_error, slog_info, slog_warn};
 use stacks_common::codec::{read_next, StacksMessageCodec};
 use stacks_common::util::hash::Sha512Trunc256Sum;
@@ -152,7 +153,8 @@ impl<C: Coordinator> RunLoop<C> {
         } else {
             debug!("Aggregate public key is not set. Coordinator must trigger DKG...");
             // Update the state to IDLE so we don't needlessy requeue the DKG command.
-            let (coordinator_id, _) = calculate_coordinator(&self.signing_round.public_keys);
+            let (coordinator_id, _) =
+                calculate_coordinator(&self.signing_round.public_keys, &self.stacks_client);
             if coordinator_id == self.signing_round.signer_id
                 && self.commands.front() != Some(&RunLoopCommand::Dkg)
             {
@@ -333,7 +335,11 @@ impl<C: Coordinator> RunLoop<C> {
         res: Sender<Vec<OperationResult>>,
     ) {
         let (_coordinator_id, coordinator_public_key) =
-            calculate_coordinator(&self.signing_round.public_keys);
+            calculate_coordinator(&self.signing_round.public_keys, &self.stacks_client);
+        debug!(
+            "Selected coordinator id and public key -> {:?} : {:?}",
+            &_coordinator_id, &coordinator_public_key
+        );
 
         let inbound_packets: Vec<Packet> = stackerdb_chunk_event
             .modified_slots
@@ -797,9 +803,34 @@ impl<C: Coordinator> SignerRunLoop<Vec<OperationResult>, RunLoopCommand> for Run
 }
 
 /// Helper function for determining the coordinator public key given the the public keys
-fn calculate_coordinator(public_keys: &PublicKeys) -> (u32, ecdsa::PublicKey) {
-    // TODO: do some sort of VRF here to calculate the public key
-    // See: https://github.com/stacks-network/stacks-blockchain/issues/3915
-    // Mockamato just uses the first signer_id as the coordinator for now
-    (0, public_keys.signers.get(&0).cloned().unwrap())
+fn calculate_coordinator(
+    public_keys: &PublicKeys,
+    stacks_client: &StacksClient,
+) -> (u32, ecdsa::PublicKey) {
+    let stacks_tip_consensus_hash = match stacks_client.get_stacks_tip_consensus_hash() {
+        Ok(hash) => hash,
+        Err(_) => return (0, public_keys.signers.get(&0).cloned().unwrap()),
+    };
+
+    // Create combined hash of each signer's public key with stacks_tip_consensus_hash
+    let mut selection_ids = public_keys
+        .signers
+        .iter()
+        .map(|(&id, pk)| {
+            let mut hasher = Sha256::new();
+            hasher.update(pk.to_bytes());
+            hasher.update(stacks_tip_consensus_hash.as_bytes());
+            (hasher.finalize().to_vec(), id)
+        })
+        .collect::<Vec<_>>();
+
+    // Sort the selection IDs based on the hash
+    selection_ids.sort_by_key(|(hash, _)| hash.clone());
+
+    // Get the first ID from the sorted list and retrieve its public key,
+    // or default to the first signer if none are found
+    selection_ids
+        .first()
+        .and_then(|(_, id)| public_keys.signers.get(id).map(|pk| (*id, pk.clone())))
+        .unwrap_or((0, public_keys.signers.get(&0).cloned().unwrap()))
 }

From 485164dbf96bd14e8bad82fe585c5061aa635a8b Mon Sep 17 00:00:00 2001
From: Marzi <marzi@trustmachines.co>
Date: Tue, 23 Jan 2024 01:30:31 -0500
Subject: [PATCH 0461/1166] Add unit tests for calculate_coordinator +
 incorporate review feedbacks

---
 Cargo.lock                                |   1 +
 Cargo.toml                                |   1 +
 stacks-signer/Cargo.toml                  |   3 +-
 stacks-signer/src/client/mod.rs           |   2 +-
 stacks-signer/src/client/stacks_client.rs |  36 +++++--
 stacks-signer/src/runloop.rs              | 120 +++++++++++++++++++++-
 6 files changed, 145 insertions(+), 18 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index c702457fcc..a905898c9d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3588,6 +3588,7 @@ dependencies = [
  "hashbrown 0.14.0",
  "libsigner",
  "libstackerdb",
+ "rand 0.8.5",
  "rand_core 0.6.4",
  "reqwest",
  "secp256k1",
diff --git a/Cargo.toml b/Cargo.toml
index 4564ee800c..e415444c82 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -17,6 +17,7 @@ members = [
 wsts = "7.0"
 rand_core = "0.6"
 rand = "0.8"
+sha2 = "0.10"
 
 # Use a bit more than default optimization for
 #  dev builds to speed up test execution
diff --git a/stacks-signer/Cargo.toml b/stacks-signer/Cargo.toml
index 29f5015643..4e05745197 100644
--- a/stacks-signer/Cargo.toml
+++ b/stacks-signer/Cargo.toml
@@ -42,7 +42,8 @@ toml = "0.5.6"
 tracing = "0.1.37"
 tracing-subscriber = { version = "0.3.17", features = ["env-filter"] }
 wsts = { workspace = true }
-sha2 = "0.10.6"
+sha2 = { workspace = true }
+rand = { workspace = true }
 
 [dependencies.serde_json]
 version = "1.0"
diff --git a/stacks-signer/src/client/mod.rs b/stacks-signer/src/client/mod.rs
index 3eb8881caf..bcfece5a84 100644
--- a/stacks-signer/src/client/mod.rs
+++ b/stacks-signer/src/client/mod.rs
@@ -17,7 +17,7 @@
 /// The stacker db module for communicating with the stackerdb contract
 mod stackerdb;
 /// The stacks node client module for communicating with the stacks node
-mod stacks_client;
+pub(crate) mod stacks_client;
 
 use std::time::Duration;
 
diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index 3519d1fd6e..ce581e0615 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -85,14 +85,17 @@ impl StacksClient {
             .json::<serde_json::Value>()
             .map_err(ClientError::ReqwestError)?;
 
-        json_response["stacks_tip_consensus_hash"]
-            .as_str()
+        let stacks_tip_consensus_hash = json_response
+            .get("stacks_tip_consensus_hash")
+            .and_then(|v| v.as_str())
+            .map(String::from)
             .ok_or_else(|| {
                 ClientError::UnexpectedResponseFormat(
-                    "Missing 'stacks_tip_consensus_hash' field".to_string(),
+                    "Missing or invalid 'stacks_tip_consensus_hash' field".to_string(),
                 )
-            })
-            .map(|s| s.to_string())
+            })?;
+
+        Ok(stacks_tip_consensus_hash)
     }
 
     /// Submit the block proposal to the stacks node. The block will be validated and returned via the HTTP endpoint for Block events.
@@ -344,7 +347,7 @@ impl StacksClient {
 }
 
 #[cfg(test)]
-mod tests {
+pub(crate) mod tests {
     use std::io::{BufWriter, Read, Write};
     use std::net::{SocketAddr, TcpListener};
     use std::thread::spawn;
@@ -352,13 +355,13 @@ mod tests {
     use super::*;
     use crate::client::ClientError;
 
-    struct TestConfig {
-        mock_server: TcpListener,
-        client: StacksClient,
+    pub(crate) struct TestConfig {
+        pub(crate) mock_server: TcpListener,
+        pub(crate) client: StacksClient,
     }
 
     impl TestConfig {
-        pub fn new() -> Self {
+        pub(crate) fn new() -> Self {
             let mut config = Config::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
 
             let mut mock_server_addr = SocketAddr::from(([127, 0, 0, 1], 0));
@@ -377,7 +380,7 @@ mod tests {
         }
     }
 
-    fn write_response(mock_server: TcpListener, bytes: &[u8]) -> [u8; 1024] {
+    pub(crate) fn write_response(mock_server: TcpListener, bytes: &[u8]) -> [u8; 1024] {
         debug!("Writing a response...");
         let mut request_bytes = [0u8; 1024];
         {
@@ -634,4 +637,15 @@ mod tests {
         );
         assert!(h.join().unwrap().is_ok());
     }
+
+    #[test]
+    fn core_info_call_with_invalid_response_should_fail() {
+        let config = TestConfig::new();
+        let h = spawn(move || config.client.get_stacks_tip_consensus_hash());
+        write_response(
+            config.mock_server,
+            b"HTTP/1.1 200 OK\n\n4e99f99bc4a05437abb8c7d0c306618f45b203196498e2ebe287f10497124958",
+        );
+        assert!(h.join().unwrap().is_err());
+    }
 }
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 3fa441c4b6..dba6653482 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -336,10 +336,6 @@ impl<C: Coordinator> RunLoop<C> {
     ) {
         let (_coordinator_id, coordinator_public_key) =
             calculate_coordinator(&self.signing_round.public_keys, &self.stacks_client);
-        debug!(
-            "Selected coordinator id and public key -> {:?} : {:?}",
-            &_coordinator_id, &coordinator_public_key
-        );
 
         let inbound_packets: Vec<Packet> = stackerdb_chunk_event
             .modified_slots
@@ -809,8 +805,15 @@ fn calculate_coordinator(
 ) -> (u32, ecdsa::PublicKey) {
     let stacks_tip_consensus_hash = match stacks_client.get_stacks_tip_consensus_hash() {
         Ok(hash) => hash,
-        Err(_) => return (0, public_keys.signers.get(&0).cloned().unwrap()),
+        Err(e) => {
+            eprintln!("Error fetching consensus hash: {:?}", e); // Log the error
+            return (0, public_keys.signers.get(&0).cloned().unwrap());
+        }
     };
+    debug!(
+        "Using stacks_tip_consensus_hash {:?} for selecting coordinator",
+        &stacks_tip_consensus_hash
+    );
 
     // Create combined hash of each signer's public key with stacks_tip_consensus_hash
     let mut selection_ids = public_keys
@@ -834,3 +837,110 @@ fn calculate_coordinator(
         .and_then(|(_, id)| public_keys.signers.get(id).map(|pk| (*id, pk.clone())))
         .unwrap_or((0, public_keys.signers.get(&0).cloned().unwrap()))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::client::stacks_client::tests::{write_response, TestConfig};
+    use rand::{distributions::Alphanumeric, Rng};
+    use std::net::TcpListener;
+    use std::thread::{sleep, spawn};
+
+    fn generate_random_consensus_hash(length: usize) -> String {
+        let random_consensus_hash = rand::thread_rng()
+            .sample_iter(&Alphanumeric)
+            .take(length)
+            .map(char::from)
+            .collect();
+
+        random_consensus_hash
+    }
+    fn mock_stacks_client_response(mock_server: TcpListener, random_consensus: bool) {
+        let consensus_hash = match random_consensus {
+            true => generate_random_consensus_hash(40),
+            false => "static_hash_value".to_string(),
+        };
+
+        let response = format!(
+            "HTTP/1.1 200 OK\n\n{{\"stacks_tip_consensus_hash\": \"{}\"}}",
+            consensus_hash
+        );
+
+        spawn(move || {
+            write_response(mock_server, response.as_bytes());
+        });
+        sleep(Duration::from_millis(100));
+    }
+
+    #[test]
+    fn calculate_coordinator_should_produce_unique_results() {
+        let config = Config::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
+        let number_of_tests = 5;
+
+        let mut results = Vec::new();
+
+        for _ in 0..number_of_tests {
+            let test_config = TestConfig::new();
+            mock_stacks_client_response(test_config.mock_server, true);
+
+            let (coordinator_id, coordinator_public_key) =
+                calculate_coordinator(&config.signer_ids_public_keys, &test_config.client);
+
+            results.push((coordinator_id, coordinator_public_key));
+        }
+
+        // Check that not all coordinator IDs are the same
+        let all_ids_same = results.iter().all(|&(id, _)| id == results[0].0);
+        assert!(!all_ids_same, "Not all coordinator IDs should be the same");
+
+        // Check that not all coordinator public keys are the same
+        let all_keys_same = results
+            .iter()
+            .all(|&(_, ref key)| key.key.data == results[0].1.key.data);
+        assert!(
+            !all_keys_same,
+            "Not all coordinator public keys should be the same"
+        );
+    }
+    fn generate_test_results(random_consensus: bool, count: usize) -> Vec<(u32, ecdsa::PublicKey)> {
+        let mut results = Vec::new();
+        let config = Config::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
+
+        for _ in 0..count {
+            let test_config = TestConfig::new();
+            mock_stacks_client_response(test_config.mock_server, random_consensus);
+            let result = calculate_coordinator(&config.signer_ids_public_keys, &test_config.client);
+            results.push(result);
+        }
+        results
+    }
+
+    #[test]
+    fn calculate_coordinator_results_should_vary_or_match_based_on_hash() {
+        let results_with_random_hash = generate_test_results(true, 5);
+        let all_ids_same = results_with_random_hash
+            .iter()
+            .all(|&(id, _)| id == results_with_random_hash[0].0);
+        let all_keys_same = results_with_random_hash
+            .iter()
+            .all(|&(_, ref key)| key.key.data == results_with_random_hash[0].1.key.data);
+        assert!(!all_ids_same, "Not all coordinator IDs should be the same");
+        assert!(
+            !all_keys_same,
+            "Not all coordinator public keys should be the same"
+        );
+
+        let results_with_static_hash = generate_test_results(false, 5);
+        let all_ids_same = results_with_static_hash
+            .iter()
+            .all(|&(id, _)| id == results_with_static_hash[0].0);
+        let all_keys_same = results_with_static_hash
+            .iter()
+            .all(|&(_, ref key)| key.key.data == results_with_static_hash[0].1.key.data);
+        assert!(all_ids_same, "All coordinator IDs should be the same");
+        assert!(
+            all_keys_same,
+            "All coordinator public keys should be the same"
+        );
+    }
+}

From 5487dfac8d053184c872d5b8f7c5f55034b268ce Mon Sep 17 00:00:00 2001
From: Marzi <marzi@trustmachines.co>
Date: Tue, 23 Jan 2024 15:50:17 -0500
Subject: [PATCH 0462/1166] Adjust signer integ test to set coordinator
 dynamically based on calculate_coordinator result

---
 stacks-signer/src/runloop.rs            |  4 +--
 testnet/stacks-node/src/tests/signer.rs | 43 ++++++++++++-------------
 2 files changed, 23 insertions(+), 24 deletions(-)

diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index dba6653482..9bc02d7c32 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -799,14 +799,14 @@ impl<C: Coordinator> SignerRunLoop<Vec<OperationResult>, RunLoopCommand> for Run
 }
 
 /// Helper function for determining the coordinator public key given the the public keys
-fn calculate_coordinator(
+pub fn calculate_coordinator(
     public_keys: &PublicKeys,
     stacks_client: &StacksClient,
 ) -> (u32, ecdsa::PublicKey) {
     let stacks_tip_consensus_hash = match stacks_client.get_stacks_tip_consensus_hash() {
         Ok(hash) => hash,
         Err(e) => {
-            eprintln!("Error fetching consensus hash: {:?}", e); // Log the error
+            error!("Error in fetching consensus hash: {:?}", e);
             return (0, public_keys.signers.get(&0).cloned().unwrap());
         }
     };
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index 9aec1a0e83..5f75868ccd 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -3,6 +3,7 @@ use std::sync::mpsc::{channel, Receiver, Sender};
 use std::sync::{Arc, Mutex};
 use std::time::{Duration, Instant};
 use std::{env, thread};
+use std::collections::HashMap;
 
 use clarity::vm::types::QualifiedContractIdentifier;
 use libsigner::{RunningSigner, Signer, SignerEventReceiver};
@@ -17,9 +18,9 @@ use stacks_common::types::chainstate::{
 };
 use stacks_common::util::hash::{MerkleTree, Sha512Trunc256Sum};
 use stacks_common::util::secp256k1::MessageSignature;
-use stacks_signer::client::{BlockResponse, SignerMessage, SIGNER_SLOTS_PER_USER};
+use stacks_signer::client::{BlockResponse, SignerMessage, StacksClient, SIGNER_SLOTS_PER_USER};
 use stacks_signer::config::{Config as SignerConfig, Network};
-use stacks_signer::runloop::RunLoopCommand;
+use stacks_signer::runloop::{calculate_coordinator, RunLoopCommand};
 use stacks_signer::utils::{build_signer_config_tomls, build_stackerdb_contract};
 use tracing_subscriber::prelude::*;
 use tracing_subscriber::{fmt, EnvFilter};
@@ -62,13 +63,13 @@ struct SignerTest {
     // The channel for sending commands to the coordinator
     pub coordinator_cmd_sender: Sender<RunLoopCommand>,
     // The channels for sending commands to the signers
-    pub _signer_cmd_senders: Vec<Sender<RunLoopCommand>>,
+    pub _signer_cmd_senders: HashMap<u32, Sender<RunLoopCommand>>,
     // The channels for receiving results from both the coordinator and the signers
     pub result_receivers: Vec<Receiver<Vec<OperationResult>>>,
     // The running coordinator and its threads
     pub running_coordinator: RunningSigner<SignerEventReceiver, Vec<OperationResult>>,
     // The running signer and its threads
-    pub running_signers: Vec<RunningSigner<SignerEventReceiver, Vec<OperationResult>>>,
+    pub running_signers: HashMap<u32, RunningSigner<SignerEventReceiver, Vec<OperationResult>>>,
 }
 
 impl SignerTest {
@@ -103,30 +104,18 @@ impl SignerTest {
             Some(Duration::from_millis(128)), // Timeout defaults to 5 seconds. Let's override it to 128 milliseconds.
         );
 
-        let mut running_signers = vec![];
-        let mut _signer_cmd_senders = vec![];
+        let mut running_signers = HashMap::new();
+        let mut _signer_cmd_senders = HashMap::new();
         // Spawn all the signers first to listen to the coordinator request for dkg
         let mut result_receivers = Vec::new();
-        for i in (1..num_signers).rev() {
+        for i in (0..num_signers).rev() {
             let (cmd_send, cmd_recv) = channel();
             let (res_send, res_recv) = channel();
             info!("spawn signer");
-            let running_signer = spawn_signer(&signer_configs[i as usize], cmd_recv, res_send);
-            running_signers.push(running_signer);
-            _signer_cmd_senders.push(cmd_send);
+            running_signers.insert(i, spawn_signer(&signer_configs[i as usize], cmd_recv, res_send));
+            _signer_cmd_senders.insert(i, cmd_send);
             result_receivers.push(res_recv);
         }
-        // Spawn coordinator second
-        let (coordinator_cmd_sender, coordinator_cmd_recv) = channel();
-        let (coordinator_res_send, coordinator_res_receiver) = channel();
-        info!("spawn coordinator");
-        let running_coordinator = spawn_signer(
-            &signer_configs[0],
-            coordinator_cmd_recv,
-            coordinator_res_send,
-        );
-
-        result_receivers.push(coordinator_res_receiver);
 
         // Setup the nodes and deploy the contract to it
         let node = setup_stx_btc_node(
@@ -139,6 +128,16 @@ impl SignerTest {
             &signer_configs,
         );
 
+        // Calculate which signer will be selected as the coordinator
+        let config = stacks_signer::config::Config::load_from_str(&signer_configs[0]).unwrap();
+        let stacks_client = StacksClient::from(&config);
+        let (coordinator_id, coordinator_pk) = calculate_coordinator(&config.signer_ids_public_keys, &stacks_client);
+        debug!("selected coordinator id and pub key: {:?} : {:?}", &coordinator_id, &coordinator_pk);
+
+        // Fetch the selected coordinator and its cmd_sender
+        let running_coordinator = running_signers.remove(&coordinator_id).expect("Coordinator not found");
+        let coordinator_cmd_sender = _signer_cmd_senders.remove(&coordinator_id).expect("Command sender not found");
+
         Self {
             running_nodes: node,
             result_receivers,
@@ -162,7 +161,7 @@ impl SignerTest {
 
         self.running_nodes.run_loop_thread.join().unwrap();
         // Stop the signers
-        for signer in self.running_signers {
+        for (_id, signer) in self.running_signers {
             assert!(signer.stop().is_none());
         }
         // Stop the coordinator

From 653a116511b01d4b2314606529e3c95bef700b72 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 23 Jan 2024 17:46:03 -0500
Subject: [PATCH 0463/1166] fix: blocked condition is true regardless of
 internal buffer contents

---
 stacks-common/src/util/pipe.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/stacks-common/src/util/pipe.rs b/stacks-common/src/util/pipe.rs
index 87cf461b8f..eda63deca3 100644
--- a/stacks-common/src/util/pipe.rs
+++ b/stacks-common/src/util/pipe.rs
@@ -168,12 +168,12 @@ impl PipeRead {
             }
         }
 
-        if disconnected && copied == 0 && self.buf.is_empty() {
+        if disconnected && copied == 0 {
             // out of data, and will never get more
             return Err(io::Error::from(io::ErrorKind::BrokenPipe));
         }
 
-        if blocked && copied == 0 && self.buf.is_empty() {
+        if blocked && copied == 0 {
             return Err(io::Error::from(io::ErrorKind::WouldBlock));
         }
 

From dce5a74ebfa75f15e31d0f45460ed39b90385e06 Mon Sep 17 00:00:00 2001
From: Marzi <marzi@trustmachines.co>
Date: Tue, 23 Jan 2024 18:05:40 -0500
Subject: [PATCH 0464/1166] Fix rustfmt

---
 testnet/stacks-node/src/tests/signer.rs | 23 +++++++++++++++++------
 1 file changed, 17 insertions(+), 6 deletions(-)

diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index 5f75868ccd..f15c28814a 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -1,9 +1,9 @@
+use std::collections::HashMap;
 use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
 use std::sync::mpsc::{channel, Receiver, Sender};
 use std::sync::{Arc, Mutex};
 use std::time::{Duration, Instant};
 use std::{env, thread};
-use std::collections::HashMap;
 
 use clarity::vm::types::QualifiedContractIdentifier;
 use libsigner::{RunningSigner, Signer, SignerEventReceiver};
@@ -112,7 +112,10 @@ impl SignerTest {
             let (cmd_send, cmd_recv) = channel();
             let (res_send, res_recv) = channel();
             info!("spawn signer");
-            running_signers.insert(i, spawn_signer(&signer_configs[i as usize], cmd_recv, res_send));
+            running_signers.insert(
+                i,
+                spawn_signer(&signer_configs[i as usize], cmd_recv, res_send),
+            );
             _signer_cmd_senders.insert(i, cmd_send);
             result_receivers.push(res_recv);
         }
@@ -131,12 +134,20 @@ impl SignerTest {
         // Calculate which signer will be selected as the coordinator
         let config = stacks_signer::config::Config::load_from_str(&signer_configs[0]).unwrap();
         let stacks_client = StacksClient::from(&config);
-        let (coordinator_id, coordinator_pk) = calculate_coordinator(&config.signer_ids_public_keys, &stacks_client);
-        debug!("selected coordinator id and pub key: {:?} : {:?}", &coordinator_id, &coordinator_pk);
+        let (coordinator_id, coordinator_pk) =
+            calculate_coordinator(&config.signer_ids_public_keys, &stacks_client);
+        debug!(
+            "selected coordinator id and pub key: {:?} : {:?}",
+            &coordinator_id, &coordinator_pk
+        );
 
         // Fetch the selected coordinator and its cmd_sender
-        let running_coordinator = running_signers.remove(&coordinator_id).expect("Coordinator not found");
-        let coordinator_cmd_sender = _signer_cmd_senders.remove(&coordinator_id).expect("Command sender not found");
+        let running_coordinator = running_signers
+            .remove(&coordinator_id)
+            .expect("Coordinator not found");
+        let coordinator_cmd_sender = _signer_cmd_senders
+            .remove(&coordinator_id)
+            .expect("Command sender not found");
 
         Self {
             running_nodes: node,

From 23acbf1984fb6ce03a9d54430cbe8ca927bb451a Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 23 Jan 2024 18:05:54 -0500
Subject: [PATCH 0465/1166] chore: reset stackerdb sync state on reset

---
 stackslib/src/net/stackerdb/sync.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/stackslib/src/net/stackerdb/sync.rs b/stackslib/src/net/stackerdb/sync.rs
index b780430433..951d99c45d 100644
--- a/stackslib/src/net/stackerdb/sync.rs
+++ b/stackslib/src/net/stackerdb/sync.rs
@@ -164,6 +164,7 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
         self.need_resync = false;
         self.last_run_ts = get_epoch_time_secs();
 
+        self.state = StackerDBSyncState::ConnectBegin;
         result
     }
 

From 4316924b924a37b8bdd494d33384cf944276f0f9 Mon Sep 17 00:00:00 2001
From: Marzi <marzi@trustmachines.co>
Date: Tue, 23 Jan 2024 18:27:39 -0500
Subject: [PATCH 0466/1166] Fix rebase bug

---
 stacks-signer/src/runloop.rs | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 9bc02d7c32..81a5587b14 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -310,7 +310,8 @@ impl<C: Coordinator> RunLoop<C> {
             };
             self.handle_packets(res, &[packet]);
         } else {
-            let (coordinator_id, _) = calculate_coordinator(&self.signing_round.public_keys);
+            let (coordinator_id, _) =
+                calculate_coordinator(&self.signing_round.public_keys, &self.stacks_client);
             if block_info.valid.unwrap_or(false)
                 && !block_info.signing_round
                 && coordinator_id == self.signing_round.signer_id
@@ -840,12 +841,15 @@ pub fn calculate_coordinator(
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use crate::client::stacks_client::tests::{write_response, TestConfig};
-    use rand::{distributions::Alphanumeric, Rng};
     use std::net::TcpListener;
     use std::thread::{sleep, spawn};
 
+    use rand::distributions::Alphanumeric;
+    use rand::Rng;
+
+    use super::*;
+    use crate::client::stacks_client::tests::{write_response, TestConfig};
+
     fn generate_random_consensus_hash(length: usize) -> String {
         let random_consensus_hash = rand::thread_rng()
             .sample_iter(&Alphanumeric)

From 3c8ec8fd2828c01fca5df541e4666b25acb3ebb6 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 23 Jan 2024 18:32:12 -0500
Subject: [PATCH 0467/1166] fix: don't buffer zero-length buffers; expand test
 coverage

---
 stacks-common/src/util/pipe.rs | 36 ++++++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)

diff --git a/stacks-common/src/util/pipe.rs b/stacks-common/src/util/pipe.rs
index eda63deca3..bb7482f949 100644
--- a/stacks-common/src/util/pipe.rs
+++ b/stacks-common/src/util/pipe.rs
@@ -187,6 +187,10 @@ impl PipeWrite {
     }
 
     fn write_or_buffer(&mut self, buf: &[u8]) -> io::Result<usize> {
+        if buf.len() == 0 {
+            return Ok(0);
+        }
+
         // add buf to our internal buffer...
         if self.buf.is_none() {
             let data = buf.to_vec();
@@ -528,10 +532,37 @@ mod test {
             assert_eq!(nr, segment.len());
             assert_eq!(*segment, bytes);
 
+            // subsequent read fails with EWOULDBLOCK
+            let mut next_bytes = vec![0u8];
+            let res = pipe_read.read(&mut next_bytes).unwrap_err();
+            assert_eq!(res.kind(), io::ErrorKind::WouldBlock);
+
             // flush should have succeeded
             let res = pipe_write.try_flush().unwrap();
             assert!(res);
         }
+
+        // subsequent read fails with EWOULDBLOCK
+        let mut next_bytes = vec![0u8];
+        let res = pipe_read.read(&mut next_bytes).unwrap_err();
+        assert_eq!(res.kind(), io::ErrorKind::WouldBlock);
+
+        // once the write end is dropped, then this data is still consumable but we get broken-pipe
+        // once it's all been read.
+        let _ = pipe_write.write(&[1u8, 1u8]).unwrap();
+        drop(pipe_write);
+
+        let mut next_bytes = vec![0u8];
+        let res = pipe_read.read(&mut next_bytes).unwrap();
+        assert_eq!(res, 1);
+
+        let mut next_bytes = vec![0u8];
+        let res = pipe_read.read(&mut next_bytes).unwrap();
+        assert_eq!(res, 1);
+
+        let mut next_bytes = vec![0u8];
+        let res = pipe_read.read(&mut next_bytes).unwrap_err();
+        assert_eq!(res.kind(), io::ErrorKind::BrokenPipe);
     }
 
     #[test]
@@ -586,6 +617,11 @@ mod test {
             assert_eq!(nr, segment.len() - 1);
             assert_eq!(*segment, bytes);
 
+            // subsequent read fails with EWOULDBLOCK
+            let mut next_bytes = vec![0u8];
+            let res = pipe_read.read(&mut next_bytes).unwrap_err();
+            assert_eq!(res.kind(), io::ErrorKind::WouldBlock);
+
             // flush should have succeeded
             let res = pipe_write.try_flush().unwrap();
             assert!(res);

From b289659d0217ea3ada7c87b87bf637b4b36164ad Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 23 Jan 2024 21:47:03 -0500
Subject: [PATCH 0468/1166] fix: don't partially-buffer p2p messages; send them
 all at once so if the handle goes out of scope, we don't send a partial
 message

---
 stackslib/src/net/chat.rs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/stackslib/src/net/chat.rs b/stackslib/src/net/chat.rs
index 664ab52c30..e26f17f894 100644
--- a/stackslib/src/net/chat.rs
+++ b/stackslib/src/net/chat.rs
@@ -986,7 +986,8 @@ impl ConversationP2P {
         let _seq = msg.request_id();
 
         let mut handle = self.connection.make_relay_handle(self.conn_id)?;
-        msg.consensus_serialize(&mut handle)?;
+        let buf = msg.serialize_to_vec();
+        handle.write_all(&buf)?;
 
         self.stats.msgs_tx += 1;
 
@@ -1011,7 +1012,8 @@ impl ConversationP2P {
         let mut handle =
             self.connection
                 .make_request_handle(msg.request_id(), ttl, self.conn_id)?;
-        msg.consensus_serialize(&mut handle)?;
+        let buf = msg.serialize_to_vec();
+        handle.write_all(&buf)?;
 
         self.stats.msgs_tx += 1;
 

From b736aaa121020e0ae2c3aa9808443f215204d722 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 23 Jan 2024 21:48:58 -0500
Subject: [PATCH 0469/1166] fix: compile error

---
 stackslib/src/net/chat.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/stackslib/src/net/chat.rs b/stackslib/src/net/chat.rs
index e26f17f894..d2b6313c9d 100644
--- a/stackslib/src/net/chat.rs
+++ b/stackslib/src/net/chat.rs
@@ -987,7 +987,7 @@ impl ConversationP2P {
 
         let mut handle = self.connection.make_relay_handle(self.conn_id)?;
         let buf = msg.serialize_to_vec();
-        handle.write_all(&buf)?;
+        handle.write_all(&buf).map_err(net_error::WriteError)?;
 
         self.stats.msgs_tx += 1;
 
@@ -1013,7 +1013,7 @@ impl ConversationP2P {
             self.connection
                 .make_request_handle(msg.request_id(), ttl, self.conn_id)?;
         let buf = msg.serialize_to_vec();
-        handle.write_all(&buf)?;
+        handle.write_all(&buf).map_err(net_error::WriteError)?;
 
         self.stats.msgs_tx += 1;
 

From ed24b979703ef074e887b8fcf1786d6315087a11 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 23 Jan 2024 22:19:58 -0500
Subject: [PATCH 0470/1166] fix: it's not a problem if we don't make any new
 requests for stackerdb chunks if there are already some inflight

---
 stackslib/src/net/stackerdb/sync.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stackslib/src/net/stackerdb/sync.rs b/stackslib/src/net/stackerdb/sync.rs
index 951d99c45d..60f0305437 100644
--- a/stackslib/src/net/stackerdb/sync.rs
+++ b/stackslib/src/net/stackerdb/sync.rs
@@ -862,7 +862,7 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
             // next-prioritized chunk
             cur_priority = (cur_priority + 1) % self.chunk_fetch_priorities.len();
         }
-        if requested == 0 {
+        if requested == 0 && self.comms.count_inflight() == 0 {
             return Err(net_error::PeerNotConnected);
         }
 

From 63a754817985513ad9e86bb00a57cd9a33d020fd Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Wed, 24 Jan 2024 16:53:37 -0500
Subject: [PATCH 0471/1166] chore: log specifically what messages get nacked in
 stackerdb replication, and treat a neighbor as having a session only if we
 have handshaked with it

---
 stackslib/src/net/chat.rs            |  2 +-
 stackslib/src/net/neighbors/comms.rs | 11 ++++++-----
 stackslib/src/net/stackerdb/mod.rs   |  2 ++
 stackslib/src/net/stackerdb/sync.rs  |  4 ++--
 4 files changed, 11 insertions(+), 8 deletions(-)

diff --git a/stackslib/src/net/chat.rs b/stackslib/src/net/chat.rs
index d2b6313c9d..223b7e1bbd 100644
--- a/stackslib/src/net/chat.rs
+++ b/stackslib/src/net/chat.rs
@@ -2487,7 +2487,7 @@ impl ConversationP2P {
                 Ok(None)
             }
             _ => {
-                test_debug!(
+                debug!(
                     "{:?}: Got unauthenticated message (type {}), will NACK",
                     &self,
                     msg.payload.get_message_name()
diff --git a/stackslib/src/net/neighbors/comms.rs b/stackslib/src/net/neighbors/comms.rs
index 75ea4c2ab6..38c59461fc 100644
--- a/stackslib/src/net/neighbors/comms.rs
+++ b/stackslib/src/net/neighbors/comms.rs
@@ -357,7 +357,7 @@ pub trait NeighborComms {
             }
             Err(Err(e)) => {
                 // disconnected
-                test_debug!(
+                debug!(
                     "{:?}: Failed to get reply: {:?}",
                     network.get_local_peer(),
                     &e
@@ -395,11 +395,12 @@ pub trait NeighborComms {
         }
     }
 
-    /// Are we connected already to a neighbor?
+    /// Are we connected and handshake'd already to a neighbor?
     fn has_neighbor_session<NK: ToNeighborKey>(&self, network: &PeerNetwork, nk: &NK) -> bool {
-        network
-            .get_neighbor_convo(&nk.to_neighbor_key(network))
-            .is_some()
+        let Some(convo) = network.get_neighbor_convo(&nk.to_neighbor_key(network)) else {
+            return false;
+        };
+        convo.is_authenticated() && convo.peer_version > 0
     }
 
     /// Reset all comms
diff --git a/stackslib/src/net/stackerdb/mod.rs b/stackslib/src/net/stackerdb/mod.rs
index 7164eb6bae..b37fde4e10 100644
--- a/stackslib/src/net/stackerdb/mod.rs
+++ b/stackslib/src/net/stackerdb/mod.rs
@@ -306,10 +306,12 @@ impl PeerNetwork {
                     Ok(Some(result)) => {
                         // clear broken nodes
                         for broken in result.broken.iter() {
+                            debug!("StackerDB replica is broken: {:?}", broken);
                             self.deregister_and_ban_neighbor(broken);
                         }
                         // clear dead nodes
                         for dead in result.dead.iter() {
+                            debug!("StackerDB replica is dead: {:?}", dead);
                             self.deregister_neighbor(dead);
                         }
                         results.push(result);
diff --git a/stackslib/src/net/stackerdb/sync.rs b/stackslib/src/net/stackerdb/sync.rs
index 60f0305437..4f3a0a5ab0 100644
--- a/stackslib/src/net/stackerdb/sync.rs
+++ b/stackslib/src/net/stackerdb/sync.rs
@@ -644,7 +644,7 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
                 }
                 StacksMessageType::Nack(data) => {
                     debug!(
-                        "{:?}: remote peer {:?} NACK'ed us with code {}",
+                        "{:?}: remote peer {:?} NACK'ed our StackerDBHandshake with code {}",
                         &network.get_local_peer(),
                         &naddr,
                         data.error_code
@@ -756,7 +756,7 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
                 }
                 StacksMessageType::Nack(data) => {
                     debug!(
-                        "{:?}: remote peer {:?} NACK'ed us with code {}",
+                        "{:?}: remote peer {:?} NACK'ed our StackerDBGetChunksInv us with code {}",
                         &network.get_local_peer(),
                         &naddr,
                         data.error_code

From f7751ae44df94cc64d59190322308ad02780c8a9 Mon Sep 17 00:00:00 2001
From: Marzi <marzi@trustmachines.co>
Date: Wed, 24 Jan 2024 17:11:43 -0500
Subject: [PATCH 0472/1166] Fixes/improvements from review comments

---
 Cargo.lock                                |  1 -
 Cargo.toml                                |  1 -
 stacks-signer/Cargo.toml                  |  1 -
 stacks-signer/src/client/stacks_client.rs |  2 +-
 stacks-signer/src/runloop.rs              | 30 +++++++++++------------
 testnet/stacks-node/src/tests/signer.rs   | 16 ++++++------
 6 files changed, 23 insertions(+), 28 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index a905898c9d..393e918a76 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3596,7 +3596,6 @@ dependencies = [
  "serde_derive",
  "serde_json",
  "serde_stacker",
- "sha2 0.10.6",
  "slog",
  "slog-json",
  "slog-term",
diff --git a/Cargo.toml b/Cargo.toml
index e415444c82..4564ee800c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -17,7 +17,6 @@ members = [
 wsts = "7.0"
 rand_core = "0.6"
 rand = "0.8"
-sha2 = "0.10"
 
 # Use a bit more than default optimization for
 #  dev builds to speed up test execution
diff --git a/stacks-signer/Cargo.toml b/stacks-signer/Cargo.toml
index 4e05745197..f680ce760e 100644
--- a/stacks-signer/Cargo.toml
+++ b/stacks-signer/Cargo.toml
@@ -42,7 +42,6 @@ toml = "0.5.6"
 tracing = "0.1.37"
 tracing-subscriber = { version = "0.3.17", features = ["env-filter"] }
 wsts = { workspace = true }
-sha2 = { workspace = true }
 rand = { workspace = true }
 
 [dependencies.serde_json]
diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index ce581e0615..76addc4418 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -633,7 +633,7 @@ pub(crate) mod tests {
         let h = spawn(move || config.client.get_stacks_tip_consensus_hash());
         write_response(
             config.mock_server,
-            b"HTTP/1.1 200 OK\n\n{\"stacks_tip_consensus_hash\": \"4e99f99bc4a05437abb8c7d0c306618f45b203196498e2ebe287f10497124958\"}",
+            b"HTTP/1.1 200 OK\n\n{\"stacks_tip_consensus_hash\": \"3b593b712f8310768bf16e58f378aea999b8aa3b\"}",
         );
         assert!(h.join().unwrap().is_ok());
     }
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 81a5587b14..2465b57532 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -27,10 +27,9 @@ use blockstack_lib::util_lib::boot::boot_code_id;
 use hashbrown::{HashMap, HashSet};
 use libsigner::{SignerEvent, SignerRunLoop};
 use libstackerdb::StackerDBChunkData;
-use sha2::{Digest, Sha256};
 use slog::{slog_debug, slog_error, slog_info, slog_warn};
 use stacks_common::codec::{read_next, StacksMessageCodec};
-use stacks_common::util::hash::Sha512Trunc256Sum;
+use stacks_common::util::hash::{Sha256Sum, Sha512Trunc256Sum};
 use stacks_common::{debug, error, info, warn};
 use wsts::common::MerkleRoot;
 use wsts::curve::ecdsa;
@@ -821,10 +820,13 @@ pub fn calculate_coordinator(
         .signers
         .iter()
         .map(|(&id, pk)| {
-            let mut hasher = Sha256::new();
-            hasher.update(pk.to_bytes());
-            hasher.update(stacks_tip_consensus_hash.as_bytes());
-            (hasher.finalize().to_vec(), id)
+            let pk_bytes = pk.to_bytes();
+            let mut buffer =
+                Vec::with_capacity(pk_bytes.len() + stacks_tip_consensus_hash.as_bytes().len());
+            buffer.extend_from_slice(&pk_bytes[..]);
+            buffer.extend_from_slice(stacks_tip_consensus_hash.as_bytes());
+            let digest = Sha256Sum::from_data(&buffer).as_bytes().to_vec();
+            (digest, id)
         })
         .collect::<Vec<_>>();
 
@@ -844,24 +846,20 @@ mod tests {
     use std::net::TcpListener;
     use std::thread::{sleep, spawn};
 
-    use rand::distributions::Alphanumeric;
+    use rand::distributions::Standard;
     use rand::Rng;
 
     use super::*;
     use crate::client::stacks_client::tests::{write_response, TestConfig};
 
-    fn generate_random_consensus_hash(length: usize) -> String {
-        let random_consensus_hash = rand::thread_rng()
-            .sample_iter(&Alphanumeric)
-            .take(length)
-            .map(char::from)
-            .collect();
-
-        random_consensus_hash
+    fn generate_random_consensus_hash() -> String {
+        let rng = rand::thread_rng();
+        let bytes: Vec<u8> = rng.sample_iter(Standard).take(20).collect();
+        bytes.iter().map(|b| format!("{:02x}", b)).collect()
     }
     fn mock_stacks_client_response(mock_server: TcpListener, random_consensus: bool) {
         let consensus_hash = match random_consensus {
-            true => generate_random_consensus_hash(40),
+            true => generate_random_consensus_hash(),
             false => "static_hash_value".to_string(),
         };
 
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index f15c28814a..0a2c78af71 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -63,7 +63,7 @@ struct SignerTest {
     // The channel for sending commands to the coordinator
     pub coordinator_cmd_sender: Sender<RunLoopCommand>,
     // The channels for sending commands to the signers
-    pub _signer_cmd_senders: HashMap<u32, Sender<RunLoopCommand>>,
+    pub signer_cmd_senders: HashMap<u32, Sender<RunLoopCommand>>,
     // The channels for receiving results from both the coordinator and the signers
     pub result_receivers: Vec<Receiver<Vec<OperationResult>>>,
     // The running coordinator and its threads
@@ -105,9 +105,9 @@ impl SignerTest {
         );
 
         let mut running_signers = HashMap::new();
-        let mut _signer_cmd_senders = HashMap::new();
-        // Spawn all the signers first to listen to the coordinator request for dkg
+        let mut signer_cmd_senders = HashMap::new();
         let mut result_receivers = Vec::new();
+        // Spawn all signers before the node to ensure their listening ports are open for the node event observer to bind to
         for i in (0..num_signers).rev() {
             let (cmd_send, cmd_recv) = channel();
             let (res_send, res_recv) = channel();
@@ -116,7 +116,7 @@ impl SignerTest {
                 i,
                 spawn_signer(&signer_configs[i as usize], cmd_recv, res_send),
             );
-            _signer_cmd_senders.insert(i, cmd_send);
+            signer_cmd_senders.insert(i, cmd_send);
             result_receivers.push(res_recv);
         }
 
@@ -136,8 +136,8 @@ impl SignerTest {
         let stacks_client = StacksClient::from(&config);
         let (coordinator_id, coordinator_pk) =
             calculate_coordinator(&config.signer_ids_public_keys, &stacks_client);
-        debug!(
-            "selected coordinator id and pub key: {:?} : {:?}",
+        info!(
+            "Selected coordinator id: {:?} with pk: {:?}",
             &coordinator_id, &coordinator_pk
         );
 
@@ -145,14 +145,14 @@ impl SignerTest {
         let running_coordinator = running_signers
             .remove(&coordinator_id)
             .expect("Coordinator not found");
-        let coordinator_cmd_sender = _signer_cmd_senders
+        let coordinator_cmd_sender = signer_cmd_senders
             .remove(&coordinator_id)
             .expect("Command sender not found");
 
         Self {
             running_nodes: node,
             result_receivers,
-            _signer_cmd_senders,
+            signer_cmd_senders,
             coordinator_cmd_sender,
             running_coordinator,
             running_signers,

From 401edeb7b90f3b499f12b73dac197836f5680440 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Wed, 24 Jan 2024 18:08:32 -0500
Subject: [PATCH 0473/1166] chore: don't re-send getchunksinv messages

---
 stackslib/src/net/stackerdb/sync.rs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/stackslib/src/net/stackerdb/sync.rs b/stackslib/src/net/stackerdb/sync.rs
index 4f3a0a5ab0..f9f8fbdcec 100644
--- a/stackslib/src/net/stackerdb/sync.rs
+++ b/stackslib/src/net/stackerdb/sync.rs
@@ -511,6 +511,10 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
             }
 
             let naddr = convo.to_neighbor_address();
+            if sent_naddr_set.contains(&naddr) {
+                continue;
+            }
+
             let has_reciprocal_outbound = network
                 .get_pubkey_events(&naddr.public_key_hash)
                 .iter()

From dd2a8a2229c8aa93a27ad037896451ae4e9ef7bf Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Wed, 24 Jan 2024 22:40:40 -0500
Subject: [PATCH 0474/1166] chore: coalesce replicas by ipaddr

---
 stackslib/src/net/stackerdb/sync.rs | 28 ++++++++++++++++++++++++++--
 1 file changed, 26 insertions(+), 2 deletions(-)

diff --git a/stackslib/src/net/stackerdb/sync.rs b/stackslib/src/net/stackerdb/sync.rs
index f9f8fbdcec..d6979107f2 100644
--- a/stackslib/src/net/stackerdb/sync.rs
+++ b/stackslib/src/net/stackerdb/sync.rs
@@ -77,6 +77,25 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
         dbsync
     }
 
+    /// Coalesce a list of peers such that each one has a unique IP:port
+    fn coalesce_peers_by_ipaddr(peers: Vec<NeighborAddress>) -> Vec<NeighborAddress> {
+        // coalesce peers on the same host:port
+        let mut same_host_port = HashSet::new();
+        let unique_ip_peers: Vec<_> = peers
+            .into_iter()
+            .filter_map(|naddr| {
+                if same_host_port.contains(&naddr.addrbytes.to_socketaddr(naddr.port)) {
+                    None
+                } else {
+                    same_host_port.insert(naddr.addrbytes.to_socketaddr(naddr.port));
+                    Some(naddr)
+                }
+            })
+            .collect();
+
+        unique_ip_peers
+    }
+
     /// Calculate the new set of replicas to contact.
     /// This is the same as the set that was connected on the last sync, plus any
     /// config hints and discovered nodes from the DB.
@@ -103,7 +122,10 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
             peers.extend(extra_peers);
         }
 
-        for peer in peers {
+        peers.shuffle(&mut thread_rng());
+
+        let unique_ip_peers = Self::coalesce_peers_by_ipaddr(peers);
+        for peer in unique_ip_peers {
             if connected_replicas.len() >= config.max_neighbors {
                 break;
             }
@@ -575,7 +597,9 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
             .into_iter()
             .map(|neighbor| NeighborAddress::from_neighbor(&neighbor))
             .collect();
-            self.replicas = replicas;
+
+            let unique_ip_peers = Self::coalesce_peers_by_ipaddr(replicas);
+            self.replicas = unique_ip_peers.into_iter().collect();
         }
         debug!(
             "{:?}: connect_begin: establish StackerDB sessions to {} neighbors",

From e6ae325abb03adf15acb7c94438bb38a02582168 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Thu, 25 Jan 2024 00:17:26 -0500
Subject: [PATCH 0475/1166] fix: count always-allowed nodes by pubkey, not port
 (which can omit inbound neighbors)

---
 stackslib/src/net/p2p.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/stackslib/src/net/p2p.rs b/stackslib/src/net/p2p.rs
index 780203504c..3e182ddf3c 100644
--- a/stackslib/src/net/p2p.rs
+++ b/stackslib/src/net/p2p.rs
@@ -989,9 +989,9 @@ impl PeerNetwork {
         let num_allowed_peers = allowed_peers.len();
         let mut count = 0;
         for allowed in allowed_peers {
-            if self.events.contains_key(&allowed.addr) {
-                count += 1;
-            }
+            let pubkh = Hash160::from_node_public_key(&allowed.public_key);
+            let events = self.get_pubkey_events(&pubkh);
+            count += events.len() as u64;
         }
         Ok((count, num_allowed_peers as u64))
     }

From c16d87c9d38814aaf35fc1d3720669bc45ddaf21 Mon Sep 17 00:00:00 2001
From: ASuciuX <asuciu@hiro.so>
Date: Thu, 25 Jan 2024 16:10:10 +0200
Subject: [PATCH 0476/1166] feat: update mutants doc format & some extra
 context

---
 .github/workflows/pr-differences-mutants.yml |  1 -
 docs/ci-release.md                           | 34 +++++++++++++++-----
 2 files changed, 26 insertions(+), 9 deletions(-)

diff --git a/.github/workflows/pr-differences-mutants.yml b/.github/workflows/pr-differences-mutants.yml
index ebed9fe65e..041db97591 100644
--- a/.github/workflows/pr-differences-mutants.yml
+++ b/.github/workflows/pr-differences-mutants.yml
@@ -120,7 +120,6 @@ jobs:
 
     runs-on: ubuntu-latest
 
-    if: always()
     needs:
       [
         check-big-packages-and-shards,
diff --git a/docs/ci-release.md b/docs/ci-release.md
index 3dc245cb24..ff0bca229b 100644
--- a/docs/ci-release.md
+++ b/docs/ci-release.md
@@ -230,11 +230,23 @@ ex: Branch is named `develop` and the PR is numbered `113`
 
 ## Mutation Testing
 
-When a new Pull Request (PR) is submitted, this feature evaluates the quality of the tests added or modified in the PR. It checks the new and altered functions through mutation testing. Mutation testing involves making small changes (mutations) to the code to check if the tests can detect these changes. The mutations are run with or without a [Github Actions matrix](https://docs.github.com/en/actions/using-jobs/using-a-matrix-for-your-jobs). The matrix is used when there is a large number of mutations to run.
+When a new Pull Request (PR) is submitted, this feature evaluates the quality of the tests added or modified in the PR.
+It checks the new and altered functions through mutation testing. 
+Mutation testing involves making small changes (mutations) to the code to check if the tests can detect these changes.
 
-Since mutation testing is directly correlated to the written tests, there are slower packages (due to the quantity or time it takes to run the tests) like `stackslib` or `stacks-node`. These mutations are run separately from the others, with one or more parallel jobs, depending on the amount of mutations found.
+The mutations are run with or without a [Github Actions matrix](https://docs.github.com/en/actions/using-jobs/using-a-matrix-for-your-jobs). 
+The matrix is used when there is a large number of mutations to run ([check doc specific cases](https://github.com/stacks-network/actions/blob/main/stacks-core/mutation-testing/check-packages-and-shards/README.md#outputs)).
+We utilize a matrix strategy with shards to enable parallel execution in GitHub Actions.
+This approach allows for the concurrent execution of multiple jobs across various runners.
+The total workload is divided across all shards, effectively reducing the overall duration of a workflow because the time taken is approximately the total time divided by the number of shards (+ initial build & test time).
+This is particularly advantageous for large packages that have significant build and test times, as it enhances efficiency and speeds up the process.
 
-Once all the jobs have finished testing mutants, the last job collects all the tested mutations from the previous jobs, combines them and outputs them to the `Summary` section of the workflow, at the bottom of the page. There, you can find all mutants on categories, with links to the function they tested, and a short description on how to fix the issue. The PR should only be approved/merged after all the mutants tested are in the `Caught` category.
+Since mutation testing is directly correlated to the written tests, there are slower packages (due to the quantity or time it takes to run the tests) like `stackslib` or `stacks-node`. 
+These mutations are run separately from the others, with one or more parallel jobs, depending on the amount of mutations found.
+
+Once all the jobs have finished testing mutants, the last job collects all the tested mutations from the previous jobs, combines them and outputs them to the `Summary` section of the workflow, at the bottom of the page. 
+There, you can find all mutants on categories, with links to the function they tested, and a short description on how to fix the issue. 
+The PR should only be approved/merged after all the mutants tested are in the `Caught` category.
 
 ### Time required to run the workflow based on mutants outcome and packages' size
 
@@ -250,13 +262,19 @@ File:
 
 ### Mutant Outcomes
 
-- caught — A test failed with this mutant applied. This is a good sign about test coverage.
+- caught — A test failed with this mutant applied. 
+This is a good sign about test coverage.
 
-- missed — No test failed with this mutation applied, which seems to indicate a gap in test coverage. Or, it may be that the mutant is undistinguishable from the correct code. In any case, you may wish to add a better test.
+- missed — No test failed with this mutation applied, which seems to indicate a gap in test coverage. 
+Or, it may be that the mutant is undistinguishable from the correct code. 
+In any case, you may wish to add a better test.
 
-- unviable — The attempted mutation doesn't compile. This is inconclusive about test coverage, since the function's return structure may not implement `Default::default()` (one of the mutations applied), hence causing the compile to fail. It is recommended to add `Default` implementation for the return structures of these functions, only mark that the function should be skipped as a last resort.
+- unviable — The attempted mutation doesn't compile. 
+This is inconclusive about test coverage, since the function's return structure may not implement `Default::default()` (one of the mutations applied), hence causing the compile to fail. 
+It is recommended to add `Default` implementation for the return structures of these functions, only mark that the function should be skipped as a last resort.
 
-- timeout — The mutation caused the test suite to run for a long time, until it was eventually killed. You might want to investigate the cause and only mark the function to be skipped if necessary.
+- timeout — The mutation caused the test suite to run for a long time, until it was eventually killed.
+You might want to investigate the cause and only mark the function to be skipped if necessary.
 
 ### Skipping Mutations
 
@@ -273,7 +291,7 @@ To mark functions as skipped, so they are not mutated:
 
 - You can avoid adding the dependency by using the slightly longer `#[cfg_attr(test, mutants::skip)]`.
 
-**Example:**
+### Example
 
 ```rust
 use std::time::{Duration, Instant};

From cc8f86dfeb1c0f56d5945570244fb226b53a0bd1 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Thu, 25 Jan 2024 09:57:25 -0500
Subject: [PATCH 0477/1166] fix: walk to always-allowed if we aren't connected
 to one yet

---
 stackslib/src/net/neighbors/mod.rs | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/stackslib/src/net/neighbors/mod.rs b/stackslib/src/net/neighbors/mod.rs
index 031e9f91a5..55728dae1d 100644
--- a/stackslib/src/net/neighbors/mod.rs
+++ b/stackslib/src/net/neighbors/mod.rs
@@ -213,9 +213,14 @@ impl PeerNetwork {
             &self.local_peer, self.walk_attempts
         );
 
+        let (num_always_connected, total_always_connected) = self
+            .count_connected_always_allowed_peers()
+            .unwrap_or((0, 0));
+
         // always ensure we're connected to always-allowed outbound peers
-        let walk_res = if ibd {
-            // always connect to bootstrap peers if in IBD
+        let walk_res = if ibd || (num_always_connected == 0 && total_always_connected > 0) {
+            // always connect to bootstrap peers if in IBD, or if we're not connected to an
+            // always-allowed peer already
             NeighborWalk::instantiate_walk_to_always_allowed(
                 self.get_neighbor_walk_db(),
                 self.get_neighbor_comms(),
@@ -309,6 +314,8 @@ impl PeerNetwork {
             debug!("{:?}: not connected to any always-allowed peers; forcing a walk reset to try and fix this", &self.local_peer);
             self.reset_walk();
 
+            // TODO: force choosing an always-allowed peer!
+            //
             need_new_peers = true;
         }
 

From a3567656973ff774fcc09abaebdd30830cc5101a Mon Sep 17 00:00:00 2001
From: MarvinJanssen <MarvinJanssen@users.noreply.github.com>
Date: Thu, 18 Jan 2024 22:48:10 +0100
Subject: [PATCH 0478/1166] wip: .signers contract with basic write

---
 stackslib/src/burnchains/mod.rs               |  11 +
 .../chainstate/nakamoto/coordinator/tests.rs  | 127 ++++++--
 stackslib/src/chainstate/nakamoto/mod.rs      | 179 +++++++++-
 .../src/chainstate/nakamoto/tests/mod.rs      |   6 +-
 .../src/chainstate/nakamoto/tests/node.rs     |  25 ++
 stackslib/src/chainstate/stacks/boot/mod.rs   |  12 +-
 .../src/chainstate/stacks/boot/pox-4.clar     |  61 +++-
 .../src/chainstate/stacks/boot/pox_4_tests.rs |   4 +-
 .../src/chainstate/stacks/boot/signers.clar   |  24 ++
 .../chainstate/stacks/boot/signers_tests.rs   | 305 ++++++++++++++++++
 stackslib/src/chainstate/stacks/db/mod.rs     |   2 +-
 stackslib/src/clarity_vm/clarity.rs           |  37 +++
 12 files changed, 734 insertions(+), 59 deletions(-)
 create mode 100644 stackslib/src/chainstate/stacks/boot/signers.clar
 create mode 100644 stackslib/src/chainstate/stacks/boot/signers_tests.rs

diff --git a/stackslib/src/burnchains/mod.rs b/stackslib/src/burnchains/mod.rs
index 8d1e8fcaae..1a9f0936d0 100644
--- a/stackslib/src/burnchains/mod.rs
+++ b/stackslib/src/burnchains/mod.rs
@@ -520,6 +520,17 @@ impl PoxConstants {
         (effective_height % u64::from(self.reward_cycle_length)) == 1
     }
 
+    pub fn is_prepare_phase_start(&self, first_block_height: u64, burn_height: u64) -> bool {
+        if burn_height < first_block_height {
+            false
+        } else {
+            let effective_height = burn_height - first_block_height;
+            (effective_height + u64::from(self.prepare_length))
+                % u64::from(self.reward_cycle_length)
+                == 0
+        }
+    }
+
     pub fn reward_cycle_to_block_height(&self, first_block_height: u64, reward_cycle: u64) -> u64 {
         // NOTE: the `+ 1` is because the height of the first block of a reward cycle is mod 1, not
         // mod 0.
diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index df115a6fba..2c71e3c0d3 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -24,6 +24,7 @@ use stacks_common::types::chainstate::{
     StacksAddress, StacksBlockId, StacksPrivateKey, StacksPublicKey,
 };
 use stacks_common::types::{Address, StacksEpoch};
+use stacks_common::util::secp256k1::Secp256k1PrivateKey;
 use stacks_common::util::vrf::VRFProof;
 use wsts::curve::point::Point;
 
@@ -31,9 +32,12 @@ use crate::chainstate::burn::db::sortdb::{SortitionDB, SortitionHandle};
 use crate::chainstate::burn::operations::BlockstackOperationType;
 use crate::chainstate::coordinator::tests::p2pkh_from;
 use crate::chainstate::nakamoto::tests::get_account;
-use crate::chainstate::nakamoto::tests::node::TestSigners;
+use crate::chainstate::nakamoto::tests::node::{TestSigners, TestStacker};
 use crate::chainstate::nakamoto::{NakamotoBlock, NakamotoChainState};
 use crate::chainstate::stacks::address::PoxAddress;
+use crate::chainstate::stacks::boot::test::{
+    key_to_stacks_addr, make_pox_4_aggregate_key, make_pox_4_lockup,
+};
 use crate::chainstate::stacks::boot::test::{make_pox_4_aggregate_key, make_pox_4_lockup};
 use crate::chainstate::stacks::boot::MINERS_NAME;
 use crate::chainstate::stacks::db::{MinerPaymentTxFees, StacksAccount, StacksChainState};
@@ -45,20 +49,19 @@ use crate::chainstate::stacks::{
 use crate::clarity::vm::types::StacksAddressExtensions;
 use crate::core::StacksEpochExtension;
 use crate::net::relay::Relayer;
+use crate::net::test::{TestEventObserver, TestPeer, TestPeerConfig};
 use crate::net::stackerdb::StackerDBConfig;
 use crate::net::test::{TestPeer, TestPeerConfig};
 use crate::util_lib::boot::boot_code_id;
 
 /// Bring a TestPeer into the Nakamoto Epoch
-fn advance_to_nakamoto(peer: &mut TestPeer) {
+fn advance_to_nakamoto(
+    peer: &mut TestPeer,
+    test_signers: &TestSigners,
+    test_stackers: Vec<&TestStacker>,
+) {
     let mut peer_nonce = 0;
     let private_key = peer.config.private_key.clone();
-    let signer_key = StacksPublicKey::from_slice(&[
-        0x02, 0xb6, 0x19, 0x6d, 0xe8, 0x8b, 0xce, 0xe7, 0x93, 0xfa, 0x9a, 0x8a, 0x85, 0x96, 0x9b,
-        0x64, 0x7f, 0x84, 0xc9, 0x0e, 0x9d, 0x13, 0xf9, 0xc8, 0xb8, 0xce, 0x42, 0x6c, 0xc8, 0x1a,
-        0x59, 0x98, 0x3c,
-    ])
-    .unwrap();
     let addr = StacksAddress::from_public_keys(
         C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
         &AddressHashMode::SerializeP2PKH,
@@ -70,17 +73,24 @@ fn advance_to_nakamoto(peer: &mut TestPeer) {
     for sortition_height in 0..11 {
         // stack to pox-3 in cycle 7
         let txs = if sortition_height == 6 {
-            // stack them all
-            let stack_tx = make_pox_4_lockup(
-                &private_key,
-                0,
-                1_000_000_000_000_000_000,
-                PoxAddress::from_legacy(AddressHashMode::SerializeP2PKH, addr.bytes.clone()),
-                12,
-                signer_key,
-                34,
-            );
-            vec![stack_tx]
+            // Make all the test Stackers stack
+            test_stackers
+                .iter()
+                .map(|test_stacker| {
+                    make_pox_4_lockup(
+                        &test_stacker.stacker_private_key,
+                        0,
+                        test_stacker.amount,
+                        PoxAddress::from_legacy(
+                            AddressHashMode::SerializeP2PKH,
+                            addr.bytes.clone(),
+                        ),
+                        12,
+                        StacksPublicKey::from_private(&test_stacker.signer_private_key),
+                        34,
+                    )
+                })
+                .collect()
         } else {
             vec![]
         };
@@ -92,11 +102,13 @@ fn advance_to_nakamoto(peer: &mut TestPeer) {
 
 /// Make a peer and transition it into the Nakamoto epoch.
 /// The node needs to be stacking; otherwise, Nakamoto won't activate.
-pub fn boot_nakamoto(
+pub fn boot_nakamoto<'a>(
     test_name: &str,
     mut initial_balances: Vec<(PrincipalData, u64)>,
-    aggregate_public_key: Point,
-) -> TestPeer {
+    test_signers: &TestSigners,
+    test_stackers: Option<Vec<&TestStacker>>,
+) -> TestPeer<'a> {
+    let aggregate_public_key = test_signers.aggregate_public_key.clone();
     let mut peer_config = TestPeerConfig::new(test_name, 0, 0);
     let private_key = peer_config.private_key.clone();
     let addr = StacksAddress::from_public_keys(
@@ -117,13 +129,45 @@ pub fn boot_nakamoto(
         .push(boot_code_id(MINERS_NAME, false));
     peer_config.epochs = Some(StacksEpoch::unit_test_3_0_only(37));
     peer_config.initial_balances = vec![(addr.to_account_principal(), 1_000_000_000_000_000_000)];
+
+    let test_stackers: Vec<TestStacker> = if let Some(stackers) = test_stackers {
+        stackers.into_iter().cloned().collect()
+    } else {
+        // Create a list of test Stackers and their signer keys
+        (0..test_signers.num_keys)
+            .map(|index| {
+                let stacker_private_key = StacksPrivateKey::from_seed(&index.to_be_bytes());
+                let signer_private_key = StacksPrivateKey::from_seed(&(index + 1000).to_be_bytes());
+                TestStacker {
+                    stacker_private_key,
+                    signer_private_key,
+                    amount: 1_000_000_000_000_000_000,
+                }
+            })
+            .collect()
+    };
+
+    // Create some balances for test Stackers
+    let mut stacker_balances = test_stackers
+        .iter()
+        .map(|test_stacker| {
+            (
+                PrincipalData::from(key_to_stacks_addr(&test_stacker.stacker_private_key)),
+                u64::try_from(test_stacker.amount).expect("Stacking amount too large"),
+            )
+        })
+        .collect();
+
+    peer_config.initial_balances.append(&mut stacker_balances);
     peer_config.initial_balances.append(&mut initial_balances);
     peer_config.burnchain.pox_constants.v2_unlock_height = 21;
     peer_config.burnchain.pox_constants.pox_3_activation_height = 26;
     peer_config.burnchain.pox_constants.v3_unlock_height = 27;
     peer_config.burnchain.pox_constants.pox_4_activation_height = 31;
     let mut peer = TestPeer::new(peer_config);
-    advance_to_nakamoto(&mut peer);
+
+    advance_to_nakamoto(&mut peer, &test_signers, test_stackers.iter().collect());
+
     peer
 }
 
@@ -134,8 +178,20 @@ fn make_replay_peer<'a>(peer: &'a mut TestPeer<'a>) -> TestPeer<'a> {
     replay_config.server_port = 0;
     replay_config.http_port = 0;
 
+    let private_key = peer.config.private_key.clone();
+    let signer_private_key = StacksPrivateKey::from_seed(&[3]);
+
     let mut replay_peer = TestPeer::new(replay_config);
-    advance_to_nakamoto(&mut replay_peer);
+    let observer = TestEventObserver::new();
+    advance_to_nakamoto(
+        &mut replay_peer,
+        &TestSigners::default(),
+        vec![&TestStacker {
+            stacker_private_key: private_key,
+            signer_private_key,
+            amount: 1_000_000_000_000_000_000,
+        }],
+    );
 
     // sanity check
     let replay_tip = {
@@ -162,7 +218,7 @@ fn make_replay_peer<'a>(peer: &'a mut TestPeer<'a>) -> TestPeer<'a> {
 }
 
 /// Make a token-transfer from a private key
-fn make_token_transfer(
+pub fn make_token_transfer(
     chainstate: &mut StacksChainState,
     sortdb: &SortitionDB,
     private_key: &StacksPrivateKey,
@@ -250,11 +306,7 @@ 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.clone(),
-    );
+    let mut peer = boot_nakamoto(function_name!(), vec![], &test_signers, None);
 
     let (burn_ops, mut tenure_change, miner_key) =
         peer.begin_nakamoto_tenure(TenureChangeCause::BlockFound);
@@ -313,7 +365,8 @@ 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.clone(),
+        &test_signers,
+        None,
     );
 
     let (burn_ops, mut tenure_change, miner_key) =
@@ -434,7 +487,8 @@ fn test_nakamoto_chainstate_getters() {
     let mut peer = boot_nakamoto(
         function_name!(),
         vec![(addr.into(), 100_000_000)],
-        test_signers.aggregate_public_key.clone(),
+        &test_signers,
+        None,
     );
 
     let sort_tip = {
@@ -923,7 +977,8 @@ 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.clone(),
+        &test_signers,
+        None,
     );
 
     let mut all_blocks = vec![];
@@ -1243,7 +1298,8 @@ 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.clone(),
+        &test_signers,
+        None,
     );
 
     let mut rc_burn_ops = vec![];
@@ -1571,7 +1627,8 @@ 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.clone(),
+        &test_signers,
+        None,
     );
 
     let mut all_blocks = vec![];
diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index 866be31d70..c296d6524a 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -14,14 +14,15 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::collections::HashSet;
+use std::collections::{HashMap, HashSet};
 use std::ops::DerefMut;
 
 use clarity::vm::ast::ASTRules;
 use clarity::vm::costs::{ExecutionCost, LimitedCostTracker};
-use clarity::vm::database::BurnStateDB;
+use clarity::vm::database::{BurnStateDB, ClarityDatabase};
 use clarity::vm::events::StacksTransactionEvent;
-use clarity::vm::types::StacksAddressExtensions;
+use clarity::vm::test_util::symbols_from_values;
+use clarity::vm::types::{PrincipalData, StacksAddressExtensions, TupleData};
 use clarity::vm::{ClarityVersion, SymbolicExpression, Value};
 use lazy_static::{__Deref, lazy_static};
 use rusqlite::types::{FromSql, FromSqlError};
@@ -52,19 +53,21 @@ use super::burn::db::sortdb::{
     SortitionHandleConn, SortitionHandleTx,
 };
 use super::burn::operations::{DelegateStxOp, StackStxOp, TransferStxOp};
-use super::stacks::boot::{BOOT_TEST_POX_4_AGG_KEY_CONTRACT, BOOT_TEST_POX_4_AGG_KEY_FNAME};
+use super::stacks::boot::{
+    BOOT_TEST_POX_4_AGG_KEY_CONTRACT, BOOT_TEST_POX_4_AGG_KEY_FNAME, SIGNERS_NAME,
+};
 use super::stacks::db::accounts::MinerReward;
 use super::stacks::db::blocks::StagingUserBurnSupport;
 use super::stacks::db::{
     ChainstateTx, ClarityTx, MinerPaymentSchedule, MinerPaymentTxFees, MinerRewardInfo,
     StacksBlockHeaderTypes, StacksDBTx, StacksEpochReceipt, StacksHeaderInfo,
 };
-use super::stacks::events::StacksTransactionReceipt;
+use super::stacks::events::{StacksTransactionReceipt, TransactionOrigin};
 use super::stacks::{
     Error as ChainstateError, StacksBlock, StacksBlockHeader, StacksMicroblock, StacksTransaction,
     TenureChangeError, TenureChangePayload, ThresholdSignature, TransactionPayload,
 };
-use crate::burnchains::{PoxConstants, Txid};
+use crate::burnchains::{Burnchain, PoxConstants, Txid};
 use crate::chainstate::burn::db::sortdb::SortitionDB;
 use crate::chainstate::burn::operations::{LeaderBlockCommitOp, LeaderKeyRegisterOp};
 use crate::chainstate::burn::{BlockSnapshot, SortitionHash};
@@ -76,17 +79,21 @@ use crate::chainstate::stacks::{
     TenureChangeCause, MINER_BLOCK_CONSENSUS_HASH, MINER_BLOCK_HEADER_HASH,
 };
 use crate::clarity::vm::clarity::{ClarityConnection, TransactionConnection};
-use crate::clarity_vm::clarity::{ClarityInstance, PreCommitClarityBlock};
+use crate::clarity_vm::clarity::{
+    ClarityInstance, ClarityTransactionConnection, PreCommitClarityBlock,
+};
 use crate::clarity_vm::database::SortitionDBRef;
 use crate::core::BOOT_BLOCK_HASH;
 use crate::monitoring;
 use crate::net::stackerdb::StackerDBConfig;
 use crate::net::Error as net_error;
+use crate::util_lib::boot;
 use crate::util_lib::boot::boot_code_id;
 use crate::util_lib::db::{
     query_int, query_row, query_row_panic, query_rows, u64_to_sql, DBConn, Error as DBError,
     FromRow,
 };
+use crate::{chainstate, monitoring};
 
 pub mod coordinator;
 pub mod miner;
@@ -1807,6 +1814,152 @@ impl NakamotoChainState {
         }
     }
 
+    pub fn calculate_signer_slots(
+        clarity: &mut ClarityTransactionConnection,
+        pox_constants: &PoxConstants,
+    ) -> Result<HashMap<Value, u128>, clarity::vm::errors::Error> {
+        let is_mainnet = clarity.is_mainnet();
+        let pox4_contract = &boot_code_id(POX_4_NAME, is_mainnet);
+        let reward_cycle = clarity
+            .eval_read_only(pox4_contract, &"(current-pox-reward-cycle)")
+            .unwrap()
+            .expect_u128();
+        let list_length = clarity
+            .eval_read_only(
+                pox4_contract,
+                &format!("(get-signer-key-list-length u{})", reward_cycle),
+            )
+            .unwrap()
+            .expect_u128();
+
+        let mut signers: HashMap<Value, u128> = HashMap::new();
+        let mut total_ustx: u128 = 0;
+        for index in 0..list_length {
+            if let Ok(Value::Optional(entry)) = clarity.eval_read_only(
+                pox4_contract,
+                &format!("(get-signer-key u{} u{})", reward_cycle, index),
+            ) {
+                if let Some(data) = entry.data {
+                    let data = data.expect_tuple();
+                    let key = data.get("signer-key")?.to_owned();
+                    let amount = data.get("ustx")?.to_owned().expect_u128();
+                    let sum = signers.get(&key).cloned().unwrap_or_default();
+                    //TODO HashMap insert order is not guaranteed
+                    signers.insert(key, sum + amount);
+                    total_ustx = total_ustx
+                        .checked_add(amount)
+                        .expect("CORRUPTION: Stacker stacked > u128 max amount");
+                }
+            }
+        }
+
+        // TODO: calculation
+        let threshold = total_ustx / 4000;
+        signers.retain(|_, value: &mut u128| {
+            if *value >= threshold {
+                *value = *value / threshold;
+                true
+            } else {
+                false
+            }
+        });
+        Ok(signers)
+    }
+    pub fn handle_signer_stackerdb_update(
+        clarity: &mut ClarityTransactionConnection,
+        chain_id: u32,
+        pox_constants: &PoxConstants,
+    ) -> Result<Vec<StacksTransactionEvent>, Error> {
+        let is_mainnet = clarity.is_mainnet();
+        let sender_addr = PrincipalData::from(boot::boot_code_addr(is_mainnet));
+        let signers_contract = &boot_code_id(SIGNERS_NAME, is_mainnet);
+
+        let signers = Self::calculate_signer_slots(clarity, pox_constants).unwrap_or_default();
+
+        let signers_list_data: Vec<Value> = signers
+            .iter()
+            .map(|(signer_key, slots)| {
+                let key =
+                    StacksPublicKey::from_slice(signer_key.to_owned().expect_buff(33).as_slice())
+                        .expect("TODO: invalid key");
+                let addr = StacksAddress::from_public_keys(
+                    if is_mainnet {
+                        C32_ADDRESS_VERSION_MAINNET_SINGLESIG
+                    } else {
+                        C32_ADDRESS_VERSION_TESTNET_SINGLESIG
+                    },
+                    &AddressHashMode::SerializeP2PKH,
+                    1,
+                    &vec![key],
+                )
+                .unwrap();
+                Value::Tuple(
+                    TupleData::from_data(vec![
+                        ("signer".into(), Value::Principal(PrincipalData::from(addr))),
+                        ("num-slots".into(), Value::UInt(slots.to_owned())),
+                    ])
+                    .unwrap(),
+                )
+            })
+            .collect();
+
+        info!(
+            "Handling stackerdb update, {} signers in list",
+            signers_list_data.len()
+        );
+
+        let signers_list = Value::cons_list_unsanitized(signers_list_data).unwrap();
+
+        let (value, _, events, _) = clarity
+            .with_abort_callback(
+                |vm_env| {
+                    vm_env.execute_in_env(sender_addr.clone(), None, None, |env| {
+                        env.execute_contract_allow_private(
+                            &signers_contract,
+                            "stackerdb-set-signer-slots",
+                            &symbols_from_values(vec![signers_list]),
+                            false,
+                        )
+                    })
+                },
+                |_, _| false,
+            )
+            .expect("FATAL: failed to update signer stackerdb");
+
+        if let Value::Response(data) = value {
+            if !data.committed {
+                info!("stackerdb update error, data: {}", data);
+            }
+        }
+        Ok(events)
+    }
+
+    pub fn check_and_handle_prepare_phase_start(
+        clarity_tx: &mut ClarityTx,
+        first_block_height: u64,
+        pox_constants: &PoxConstants,
+        burn_tip_height: u64,
+    ) -> Result<Vec<StacksTransactionEvent>, Error> {
+        if clarity_tx.get_epoch() < StacksEpochId::Epoch25
+            || !pox_constants.is_prepare_phase_start(first_block_height, burn_tip_height)
+        {
+            return Ok(vec![]);
+        }
+
+        info!(
+            "handling stackerdb update at burn height {}",
+            burn_tip_height
+        );
+
+        clarity_tx.block.as_free_transaction(|clarity| {
+            Self::handle_signer_stackerdb_update(
+                clarity,
+                clarity_tx.config.chain_id,
+                &pox_constants,
+            )
+        })
+    }
+
     /// Get the aggregate public key for a block.
     /// TODO: The block at which the aggregate public key is queried needs to be better defined.
     /// See https://github.com/stacks-network/stacks-core/issues/4109
@@ -2549,6 +2702,18 @@ impl NakamotoChainState {
             );
         }
 
+        // Handle signer stackerdb updates
+        if evaluated_epoch >= StacksEpochId::Epoch25 {
+            let receipts = Self::check_and_handle_prepare_phase_start(
+                &mut clarity_tx,
+                first_block_height,
+                &pox_constants,
+                burn_header_height.into(),
+            );
+            //TODO
+            // tx_receipts.extend(receipts);
+        }
+
         debug!(
             "Setup block: completed setup";
             "parent_consensus_hash" => %parent_consensus_hash,
diff --git a/stackslib/src/chainstate/nakamoto/tests/mod.rs b/stackslib/src/chainstate/nakamoto/tests/mod.rs
index 46e88e8d64..4ae3b965c5 100644
--- a/stackslib/src/chainstate/nakamoto/tests/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/mod.rs
@@ -1502,11 +1502,7 @@ fn make_fork_run_with_arrivals(
 #[test]
 pub fn test_get_highest_nakamoto_tenure() {
     let test_signers = TestSigners::default();
-    let mut peer = boot_nakamoto(
-        function_name!(),
-        vec![],
-        test_signers.aggregate_public_key.clone(),
-    );
+    let mut peer = boot_nakamoto(function_name!(), vec![], &test_signers, None);
 
     // extract chainstate and sortdb -- we don't need the peer anymore
     let chainstate = &mut peer.stacks_node.as_mut().unwrap().chainstate;
diff --git a/stackslib/src/chainstate/nakamoto/tests/node.rs b/stackslib/src/chainstate/nakamoto/tests/node.rs
index fd69c3280f..cc2930c1e2 100644
--- a/stackslib/src/chainstate/nakamoto/tests/node.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/node.rs
@@ -65,6 +65,31 @@ use crate::net::test::{TestPeer, TestPeerConfig, *};
 use crate::util_lib::boot::boot_code_addr;
 use crate::util_lib::db::Error as db_error;
 
+#[derive(Debug, Clone)]
+pub struct TestStacker {
+    pub stacker_private_key: StacksPrivateKey,
+    pub signer_private_key: StacksPrivateKey,
+    pub amount: u128,
+}
+
+impl TestStacker {
+    pub fn from_seed(seed: &[u8]) -> TestStacker {
+        let stacker_private_key = StacksPrivateKey::from_seed(seed);
+        let mut signer_seed = seed.to_vec();
+        signer_seed.append(&mut vec![0xff, 0x00, 0x00, 0x00]);
+        let signer_private_key = StacksPrivateKey::from_seed(signer_seed.as_slice());
+        TestStacker {
+            stacker_private_key,
+            signer_private_key,
+            amount: 1_000_000_000_000_000_000,
+        }
+    }
+
+    pub fn signer_public_key(&self) -> StacksPublicKey {
+        StacksPublicKey::from_private(&self.signer_private_key)
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct TestSigners {
     /// The parties that will sign the blocks
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 0944ea19f3..ddef99f688 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -25,10 +25,14 @@ use clarity::vm::clarity::{Error as ClarityError, TransactionConnection};
 use clarity::vm::contexts::ContractContext;
 use clarity::vm::costs::cost_functions::ClarityCostFunction;
 use clarity::vm::costs::{ClarityCostFunctionReference, CostStateSummary, LimitedCostTracker};
-use clarity::vm::database::{ClarityDatabase, NULL_BURN_STATE_DB, NULL_HEADER_DB};
-use clarity::vm::errors::{Error as VmError, InterpreterError};
+use clarity::vm::database::{
+    ClarityDatabase, DataVariableMetadata, NULL_BURN_STATE_DB, NULL_HEADER_DB,
+};
+use clarity::vm::errors::{Error as VmError, InterpreterError, InterpreterResult};
 use clarity::vm::events::StacksTransactionEvent;
 use clarity::vm::representations::{ClarityName, ContractName};
+use clarity::vm::tests::symbols_from_values;
+use clarity::vm::types::TypeSignature::UIntType;
 use clarity::vm::types::{
     PrincipalData, QualifiedContractIdentifier, SequenceData, StandardPrincipalData, TupleData,
     TypeSignature, Value,
@@ -75,10 +79,12 @@ pub const POX_1_NAME: &'static str = "pox";
 pub const POX_2_NAME: &'static str = "pox-2";
 pub const POX_3_NAME: &'static str = "pox-3";
 pub const POX_4_NAME: &'static str = "pox-4";
+pub const SIGNERS_NAME: &'static str = "signers";
 
 const POX_2_BODY: &'static str = std::include_str!("pox-2.clar");
 const POX_3_BODY: &'static str = std::include_str!("pox-3.clar");
 const POX_4_BODY: &'static str = std::include_str!("pox-4.clar");
+pub const SIGNERS_BODY: &'static str = std::include_str!("signers.clar");
 
 pub const COSTS_1_NAME: &'static str = "costs";
 pub const COSTS_2_NAME: &'static str = "costs-2";
@@ -1255,6 +1261,8 @@ pub mod pox_2_tests;
 pub mod pox_3_tests;
 #[cfg(test)]
 pub mod pox_4_tests;
+#[cfg(test)]
+mod signers_tests;
 
 #[cfg(test)]
 pub mod test {
diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index 5fe89998cc..fdadbce629 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -191,6 +191,15 @@
 ;; Stackers' signer keys that have been used before.
  (define-map used-signer-keys (buff 33) uint)
 
+;; Stackers' signer key locked Stacks per cycle
+(define-map signer-key-stx-total-ustx {reward-cycle: uint, signer-key: (buff 33)} uint)
+
+;; List of Stackers' signer key ustx commitments per cycle
+(define-map signer-key-ustx-list {reward-cycle: uint, index: uint} {signer-key: (buff 33), ustx: uint})
+
+;; Length of Stackers' signer key ustx commitment lists per cycle
+(define-map signer-key-ustx-list-len uint uint)
+
 ;; The stackers' aggregate public key
 ;;   for the given reward cycle
 (define-map aggregate-public-keys uint (buff 33))
@@ -260,6 +269,20 @@
         u0
         (get len (map-get? reward-cycle-pox-address-list-len { reward-cycle: reward-cycle }))))
 
+;; Get the signer key list length for a reward cycle.
+;; Note that this _does_ return duplicate signer keys.
+;; Used internally by the Stacks node, which will sum the amounts
+;; for each unique signer key and filter those that are below the
+;; minimum threshold.
+(define-read-only (get-signer-key-list-length (reward-cycle uint))
+  (default-to u0 (map-get? signer-key-ustx-list-len reward-cycle))
+)
+
+;; Called internally by the node to iterate through the list of signer keys in this reward cycle.
+(define-read-only (get-signer-key (reward-cycle uint) (index uint))
+  (map-get? signer-key-ustx-list {reward-cycle: reward-cycle, index: index})
+)
+
 ;; Add a single PoX address to a single reward cycle.
 ;; Used to build up a set of per-reward-cycle PoX addresses.
 ;; No checking will be done -- don't call if this PoX address is already registered in this reward cycle!
@@ -584,7 +607,10 @@
       (try! (can-stack-stx pox-addr amount-ustx first-reward-cycle lock-period))
 
       ;; ensure the signer key can be used
-      (try! (insert-signer-key signer-key))
+      (try! (insert-signer-key signer-key first-reward-cycle))
+
+      ;; update the total ustx for the signer key
+      (increment-signer-key-total-ustx first-reward-cycle signer-key amount-ustx)
 
       ;; register the PoX address with the amount stacked
       (let ((reward-set-indexes (try! (add-pox-addr-to-reward-cycles pox-addr first-reward-cycle lock-period amount-ustx tx-sender))))
@@ -846,7 +872,10 @@
         (err ERR_STACKING_INSUFFICIENT_FUNDS))
 
       ;; ensure the signer key can be used
-      (try! (insert-signer-key signer-key))
+      (try! (insert-signer-key signer-key first-reward-cycle))
+
+      ;; update the total ustx for the signer key
+     (increment-signer-key-total-ustx first-reward-cycle signer-key amount-ustx)
 
       ;; ensure that stacking can be performed
       (try! (minimal-can-stack-stx pox-addr amount-ustx first-reward-cycle lock-period))
@@ -994,7 +1023,10 @@
               (err ERR_STACKING_IS_DELEGATED))
 
     ;; ensure the signer key can be used
-    (try! (insert-signer-key signer-key))
+    (try! (insert-signer-key signer-key first-extend-cycle))
+
+    ;; update the total ustx for the signer key
+    (increment-signer-key-total-ustx first-reward-cycle signer-key amount-ustx)
 
     ;; TODO: add more assertions to sanity check the `stacker-info` values with
     ;;       the `stacker-state` values
@@ -1280,12 +1312,27 @@
     )
 )
 
-;; Check if a provided signer key is valid. For now it only asserts length.
+;; Check if a provided signer key is valid to use.
+;; - It must be a buffer with length 33.
+;; - It must be a new signer key, or a signer key that was first seen in this cycle.
 ;; *New in Stacks 3.0*
-(define-private (insert-signer-key (signer-key (buff 33)))
-    (begin
+(define-private (insert-signer-key (signer-key (buff 33)) (reward-cycle uint))
+    (let ((first-seen-cycle (default-to reward-cycle (map-get? used-signer-keys signer-key))))
       (asserts! (is-eq (len signer-key) u33) (err ERR_INVALID_SIGNER_KEY))
-      (asserts! (map-insert used-signer-keys signer-key burn-block-height) (err ERR_REUSED_SIGNER_KEY))
+      (asserts! (and (is-eq first-seen-cycle reward-cycle) (map-insert used-signer-keys signer-key reward-cycle)) (err ERR_REUSED_SIGNER_KEY))
       (ok true)
     )
 )
+
+;; Increment the total number of ustx for the specified signer key.
+;; *New in Stacks 3.0*
+(define-private (increment-signer-key-total-ustx (reward-cycle-id uint) (signer-key (buff 33)) (amount uint))
+  (let ((list-index (default-to u0 (map-get? signer-key-ustx-list-len reward-cycle-id))))
+    (map-set signer-key-ustx-list {reward-cycle: reward-cycle-id, index: list-index} {signer-key: signer-key, ustx: amount})
+    (map-set signer-key-ustx-list-len reward-cycle-id (+ list-index u1))
+    (map-set signer-key-stx-total-ustx
+      {reward-cycle: reward-cycle-id, signer-key: signer-key}
+      (+ (default-to u0 (map-get? signer-key-stx-total-ustx {reward-cycle: reward-cycle-id, signer-key: signer-key})) amount)
+    )
+  )
+)
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index ac20ffca5f..cf51aac9c3 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -86,7 +86,7 @@ fn get_tip(sortdb: Option<&SortitionDB>) -> BlockSnapshot {
     SortitionDB::get_canonical_burn_chain_tip(&sortdb.unwrap().conn()).unwrap()
 }
 
-fn make_test_epochs_pox() -> (Vec<StacksEpoch>, PoxConstants) {
+pub fn make_test_epochs_pox() -> (Vec<StacksEpoch>, PoxConstants) {
     let EMPTY_SORTITIONS = 25;
     let EPOCH_2_1_HEIGHT = EMPTY_SORTITIONS + 11; // 36
     let EPOCH_2_2_HEIGHT = EPOCH_2_1_HEIGHT + 14; // 50
@@ -1340,7 +1340,7 @@ fn pox_4_revoke_delegate_stx_events() {
     );
 }
 
-fn assert_latest_was_burn(peer: &mut TestPeer) {
+pub fn assert_latest_was_burn(peer: &mut TestPeer) {
     let tip = get_tip(peer.sortdb.as_ref());
     let tip_index_block = tip.get_canonical_stacks_block_id();
     let burn_height = tip.block_height - 1;
diff --git a/stackslib/src/chainstate/stacks/boot/signers.clar b/stackslib/src/chainstate/stacks/boot/signers.clar
new file mode 100644
index 0000000000..19dd27fc3a
--- /dev/null
+++ b/stackslib/src/chainstate/stacks/boot/signers.clar
@@ -0,0 +1,24 @@
+(define-data-var stackerdb-signer-slots (list 4000 { signer: principal, num-slots: uint }) (list))
+
+(define-private (stackerdb-set-signer-slots (signer-slots (list 4000 { signer: principal, num-slots: uint })))
+	(begin
+		(print signer-slots)
+		(ok (var-set stackerdb-signer-slots signer-slots))
+	)
+)
+
+(define-read-only (stackerdb-get-signer-slots)
+	(ok (var-get stackerdb-signer-slots))
+)
+
+(define-read-only (stackerdb-get-config)
+	(ok
+		{
+		chunk-size: u4096,
+		write-freq: u0,
+		max-writes: u4096,
+		max-neighbors: u32,
+		hint-replicas: (list)
+		}
+	)
+)
diff --git a/stackslib/src/chainstate/stacks/boot/signers_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_tests.rs
new file mode 100644
index 0000000000..8d094a8c18
--- /dev/null
+++ b/stackslib/src/chainstate/stacks/boot/signers_tests.rs
@@ -0,0 +1,305 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020-2023 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+use clarity::vm::clarity::ClarityConnection;
+use clarity::vm::contexts::OwnedEnvironment;
+use clarity::vm::costs::LimitedCostTracker;
+use clarity::vm::tests::symbols_from_values;
+use clarity::vm::types::{PrincipalData, QualifiedContractIdentifier, TupleData};
+use clarity::vm::Value::Principal;
+use clarity::vm::{ClarityName, ClarityVersion, ContractName, Value};
+use stacks_common::address::AddressHashMode;
+use stacks_common::types::chainstate::{
+    BurnchainHeaderHash, StacksBlockId, StacksPrivateKey, StacksPublicKey,
+};
+use stacks_common::types::PublicKey;
+
+use crate::burnchains::Burnchain;
+use crate::chainstate::burn::db::sortdb::SortitionDB;
+use crate::chainstate::burn::BlockSnapshot;
+use crate::chainstate::nakamoto::coordinator::tests::{boot_nakamoto, make_token_transfer};
+use crate::chainstate::nakamoto::tests::get_account;
+use crate::chainstate::nakamoto::tests::node::{TestSigners, TestStacker};
+use crate::chainstate::stacks::address::PoxAddress;
+use crate::chainstate::stacks::boot::pox_2_tests::with_clarity_db_ro;
+use crate::chainstate::stacks::boot::pox_4_tests::{
+    assert_latest_was_burn, get_last_block_sender_transactions, make_test_epochs_pox,
+    prepare_pox4_test,
+};
+use crate::chainstate::stacks::boot::test::{
+    instantiate_pox_peer_with_epoch, key_to_stacks_addr, make_pox_4_lockup, with_sortdb,
+};
+use crate::chainstate::stacks::boot::SIGNERS_NAME;
+use crate::chainstate::stacks::index::marf::MarfConnection;
+use crate::chainstate::stacks::{
+    StacksTransaction, StacksTransactionSigner, TenureChangeCause, TransactionAuth,
+    TransactionPayload, TransactionPostConditionMode, TransactionVersion,
+};
+use crate::clarity_vm::database::HeadersDBConn;
+use crate::core::BITCOIN_REGTEST_FIRST_BLOCK_HASH;
+use crate::net::test::{TestEventObserver, TestPeer};
+use crate::util_lib::boot::{boot_code_addr, boot_code_id, boot_code_test_addr};
+
+#[test]
+fn signers_get_config() {
+    let (burnchain, mut peer, keys, latest_block, ..) = prepare_pox4_test(function_name!(), None);
+
+    assert_eq!(
+        readonly_call(
+            &mut peer,
+            &latest_block,
+            "signers".into(),
+            "stackerdb-get-config".into(),
+            vec![],
+        ),
+        Value::okay(Value::Tuple(
+            TupleData::from_data(vec![
+                ("chunk-size".into(), Value::UInt(4096)),
+                ("write-freq".into(), Value::UInt(0)),
+                ("max-writes".into(), Value::UInt(4096)),
+                ("max-neighbors".into(), Value::UInt(32)),
+                (
+                    "hint-replicas".into(),
+                    Value::cons_list_unsanitized(vec![]).unwrap()
+                )
+            ])
+            .unwrap()
+        ))
+        .unwrap()
+    );
+}
+
+#[test]
+fn signers_get_signer_keys_from_pox4() {
+    let stacker_1 = TestStacker::from_seed(&[3, 4]);
+    let stacker_2 = TestStacker::from_seed(&[5, 6]);
+
+    let (mut peer, test_signers, latest_block_id) =
+        prepare_signers_test(function_name!(), Some(vec![&stacker_1, &stacker_2]));
+
+    let private_key = peer.config.private_key.clone();
+
+    let stacker_1_addr = key_to_stacks_addr(&stacker_1.stacker_private_key);
+    let stacker_2_addr = key_to_stacks_addr(&stacker_2.stacker_private_key);
+
+    let stacker_1_info = readonly_call(
+        &mut peer,
+        &latest_block_id,
+        "pox-4".into(),
+        "get-stacker-info".into(),
+        vec![Value::Principal(PrincipalData::from(stacker_1_addr))],
+    );
+
+    let stacker_2_info = readonly_call(
+        &mut peer,
+        &latest_block_id,
+        "pox-4".into(),
+        "get-stacker-info".into(),
+        vec![Value::Principal(PrincipalData::from(stacker_2_addr))],
+    );
+
+    let stacker_1_tuple = stacker_1_info.expect_optional().unwrap().expect_tuple();
+    let stacker_2_tuple = stacker_2_info.expect_optional().unwrap().expect_tuple();
+
+    assert_eq!(
+        stacker_1_tuple.get_owned("signer-key").unwrap(),
+        Value::buff_from(stacker_1.signer_public_key().to_bytes_compressed()).unwrap()
+    );
+
+    assert_eq!(
+        stacker_2_tuple.get_owned("signer-key").unwrap(),
+        Value::buff_from(stacker_2.signer_public_key().to_bytes_compressed()).unwrap()
+    );
+}
+
+#[test]
+fn signers_get_signer_keys_from_stackerdb() {
+    let stacker_1 = TestStacker::from_seed(&[3, 4]);
+    let stacker_2 = TestStacker::from_seed(&[5, 6]);
+
+    let (mut peer, test_signers, latest_block_id) =
+        prepare_signers_test(function_name!(), Some(vec![&stacker_1, &stacker_2]));
+
+    let private_key = peer.config.private_key.clone();
+
+    let signer_1_addr = key_to_stacks_addr(&stacker_1.signer_private_key);
+    let signer_2_addr = key_to_stacks_addr(&stacker_2.signer_private_key);
+
+    let signers = readonly_call(
+        &mut peer,
+        &latest_block_id,
+        "signers".into(),
+        "stackerdb-get-signer-slots".into(),
+        vec![],
+    )
+    .expect_result_ok()
+    .expect_list();
+
+    let expected_tuple_1 = TupleData::from_data(vec![
+        (
+            "signer".into(),
+            Principal(PrincipalData::from(signer_1_addr)),
+        ),
+        ("num-slots".into(), Value::UInt(2000)),
+    ])
+    .unwrap();
+
+    let expected_tuple_2 = TupleData::from_data(vec![
+        (
+            "signer".into(),
+            Principal(PrincipalData::from(signer_2_addr)),
+        ),
+        ("num-slots".into(), Value::UInt(2000)),
+    ])
+    .unwrap();
+
+    assert_eq!(signers.len(), 2);
+
+    let first_tuple = signers.first().unwrap().clone().expect_tuple();
+    let second_tuple = signers.last().unwrap().clone().expect_tuple();
+
+    // Tuples can be in either order
+    if first_tuple
+        .get("signer")
+        .unwrap()
+        .clone()
+        .expect_principal()
+        == PrincipalData::from(signer_1_addr)
+    {
+        assert_eq!(first_tuple, expected_tuple_1);
+        assert_eq!(second_tuple, expected_tuple_2);
+    } else {
+        assert_eq!(first_tuple, expected_tuple_2);
+        assert_eq!(second_tuple, expected_tuple_1);
+    }
+}
+
+fn prepare_signers_test<'a>(
+    test_name: &str,
+    stackers: Option<Vec<&TestStacker>>,
+) -> (TestPeer<'a>, TestSigners, StacksBlockId) {
+    let mut test_signers = TestSigners::default();
+
+    let mut peer = boot_nakamoto(test_name, vec![], &test_signers, stackers);
+
+    let (burn_ops, mut tenure_change, miner_key) =
+        peer.begin_nakamoto_tenure(TenureChangeCause::BlockFound);
+
+    let (_, _, consensus_hash) = peer.next_burnchain_block(burn_ops);
+
+    let vrf_proof = peer.make_nakamoto_vrf_proof(miner_key);
+
+    tenure_change.tenure_consensus_hash = consensus_hash.clone();
+    tenure_change.burn_view_consensus_hash = consensus_hash.clone();
+    let tenure_change_tx = peer
+        .miner
+        .make_nakamoto_tenure_change(tenure_change.clone());
+    let coinbase_tx = peer.miner.make_nakamoto_coinbase(None, vrf_proof);
+
+    let blocks_and_sizes = peer.make_nakamoto_tenure(
+        tenure_change_tx,
+        coinbase_tx,
+        &mut test_signers,
+        |_miner, _chainstate, _sort_dbconn, _blocks| vec![],
+    );
+    let latest_block_id = blocks_and_sizes.last().unwrap().0.block_id();
+
+    (peer, test_signers, latest_block_id)
+}
+
+fn advance_blocks(
+    peer: &mut TestPeer,
+    test_signers: &mut TestSigners,
+    stacker_private_key: &StacksPrivateKey,
+    num_blocks: u64,
+) -> StacksBlockId {
+    let current_height = peer.get_burnchain_view().unwrap().burn_block_height;
+
+    //let key = peer.config.private_key;
+
+    let (burn_ops, mut tenure_change, miner_key) =
+        peer.begin_nakamoto_tenure(TenureChangeCause::BlockFound);
+
+    let (_, _, consensus_hash) = peer.next_burnchain_block(burn_ops);
+
+    let vrf_proof = peer.make_nakamoto_vrf_proof(miner_key);
+
+    tenure_change.tenure_consensus_hash = consensus_hash.clone();
+    tenure_change.burn_view_consensus_hash = consensus_hash.clone();
+    let tenure_change_tx = peer
+        .miner
+        .make_nakamoto_tenure_change(tenure_change.clone());
+    let coinbase_tx = peer.miner.make_nakamoto_coinbase(None, vrf_proof);
+    let recipient_addr = boot_code_addr(false);
+    let blocks_and_sizes = peer.make_nakamoto_tenure(
+        tenure_change_tx,
+        coinbase_tx.clone(),
+        test_signers,
+        |miner, chainstate, sortdb, blocks| {
+            if blocks.len() < num_blocks as usize {
+                let addr = key_to_stacks_addr(&stacker_private_key);
+                let account = get_account(chainstate, sortdb, &addr);
+                let stx_transfer = make_token_transfer(
+                    chainstate,
+                    sortdb,
+                    &stacker_private_key,
+                    account.nonce,
+                    1,
+                    1,
+                    &recipient_addr,
+                );
+                vec![stx_transfer]
+            } else {
+                vec![]
+            }
+        },
+    );
+    info!("tenure length {}", blocks_and_sizes.len());
+    let latest_block_id = blocks_and_sizes.last().unwrap().0.block_id();
+    latest_block_id
+}
+
+fn readonly_call(
+    peer: &mut TestPeer,
+    tip: &StacksBlockId,
+    boot_contract: ContractName,
+    function_name: ClarityName,
+    args: Vec<Value>,
+) -> Value {
+    with_sortdb(peer, |chainstate, sortdb| {
+        chainstate.with_read_only_clarity_tx(&sortdb.index_conn(), tip, |connection| {
+            connection
+                .with_readonly_clarity_env(
+                    false,
+                    0x80000000,
+                    ClarityVersion::Clarity2,
+                    PrincipalData::from(boot_code_addr(false)),
+                    None,
+                    LimitedCostTracker::new_free(),
+                    |env| {
+                        env.execute_contract_allow_private(
+                            &boot_code_id(&boot_contract, false),
+                            &function_name,
+                            &symbols_from_values(args),
+                            true,
+                        )
+                    },
+                )
+                .unwrap()
+        })
+    })
+    .unwrap()
+}
diff --git a/stackslib/src/chainstate/stacks/db/mod.rs b/stackslib/src/chainstate/stacks/db/mod.rs
index d1cb81c6db..5843ea1b45 100644
--- a/stackslib/src/chainstate/stacks/db/mod.rs
+++ b/stackslib/src/chainstate/stacks/db/mod.rs
@@ -463,7 +463,7 @@ pub type StacksDBTx<'a> = IndexDBTx<'a, (), StacksBlockId>;
 pub type StacksDBConn<'a> = IndexDBConn<'a, (), StacksBlockId>;
 
 pub struct ClarityTx<'a, 'b> {
-    block: ClarityBlockConnection<'a, 'b>,
+    pub block: ClarityBlockConnection<'a, 'b>,
     pub config: DBConfig,
 }
 
diff --git a/stackslib/src/clarity_vm/clarity.rs b/stackslib/src/clarity_vm/clarity.rs
index c702d9b084..063f731159 100644
--- a/stackslib/src/clarity_vm/clarity.rs
+++ b/stackslib/src/clarity_vm/clarity.rs
@@ -49,6 +49,7 @@ use crate::chainstate::stacks::boot::{
     BOOT_TEST_POX_4_AGG_KEY_CONTRACT, BOOT_TEST_POX_4_AGG_KEY_FNAME, COSTS_2_NAME, COSTS_3_NAME,
     MINERS_NAME, POX_2_MAINNET_CODE, POX_2_NAME, POX_2_TESTNET_CODE, POX_3_MAINNET_CODE,
     POX_3_NAME, POX_3_TESTNET_CODE, POX_4_MAINNET_CODE, POX_4_NAME, POX_4_TESTNET_CODE,
+    SIGNERS_BODY, SIGNERS_NAME,
 };
 use crate::chainstate::stacks::db::{StacksAccount, StacksChainState};
 use crate::chainstate::stacks::events::{StacksTransactionEvent, StacksTransactionReceipt};
@@ -1418,6 +1419,42 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
                 );
             }
 
+            let signers_contract_id = boot_code_id(SIGNERS_NAME, mainnet);
+            let payload = TransactionPayload::SmartContract(
+                TransactionSmartContract {
+                    name: ContractName::try_from(SIGNERS_NAME)
+                        .expect("FATAL: invalid boot-code contract name"),
+                    code_body: StacksString::from_str(SIGNERS_BODY)
+                        .expect("FATAL: invalid boot code body"),
+                },
+                Some(ClarityVersion::Clarity2),
+            );
+
+            let signers_contract_tx =
+                StacksTransaction::new(tx_version.clone(), boot_code_auth.clone(), payload);
+
+            let signers_initialization_receipt = self.as_transaction(|tx_conn| {
+                // initialize with a synthetic transaction
+                debug!("Instantiate {} contract", &signers_contract_id);
+                let receipt = StacksChainState::process_transaction_payload(
+                    tx_conn,
+                    &signers_contract_tx,
+                    &boot_code_account,
+                    ASTRules::PrecheckSize,
+                )
+                .expect("FATAL: Failed to process .miners contract initialization");
+                receipt
+            });
+
+            if signers_initialization_receipt.result != Value::okay_true()
+                || signers_initialization_receipt.post_condition_aborted
+            {
+                panic!(
+                    "FATAL: Failure processing signers contract initialization: {:#?}",
+                    &signers_initialization_receipt
+                );
+            }
+
             debug!("Epoch 2.5 initialized");
             (old_cost_tracker, Ok(vec![pox_4_initialization_receipt]))
         })

From cbe0d2480dca607b256ab2da30b3107293f90b49 Mon Sep 17 00:00:00 2001
From: MarvinJanssen <MarvinJanssen@users.noreply.github.com>
Date: Tue, 23 Jan 2024 22:05:45 +0100
Subject: [PATCH 0479/1166] wip: add signer key to PoX reward set, change from
 buff 33 to principal, fix test to prepare for merge with #4269

---
 stackslib/src/chainstate/nakamoto/mod.rs      |  35 +++--
 .../src/chainstate/stacks/boot/pox-4.clar     | 138 ++++++------------
 .../chainstate/stacks/boot/signers_tests.rs   |   8 +-
 3 files changed, 70 insertions(+), 111 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index c296d6524a..29d3ba7234 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -14,7 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::collections::{HashMap, HashSet};
+use std::collections::{BTreeMap, HashMap, HashSet};
 use std::ops::DerefMut;
 
 use clarity::vm::ast::ASTRules;
@@ -1814,25 +1814,22 @@ impl NakamotoChainState {
         }
     }
 
-    pub fn calculate_signer_slots(
+    fn calculate_signer_slots(
         clarity: &mut ClarityTransactionConnection,
         pox_constants: &PoxConstants,
-    ) -> Result<HashMap<Value, u128>, clarity::vm::errors::Error> {
+        reward_cycle: u64,
+    ) -> Result<BTreeMap<Vec<u8>, u128>, ChainstateError> {
         let is_mainnet = clarity.is_mainnet();
         let pox4_contract = &boot_code_id(POX_4_NAME, is_mainnet);
-        let reward_cycle = clarity
-            .eval_read_only(pox4_contract, &"(current-pox-reward-cycle)")
-            .unwrap()
-            .expect_u128();
+
         let list_length = clarity
             .eval_read_only(
                 pox4_contract,
                 &format!("(get-signer-key-list-length u{})", reward_cycle),
-            )
-            .unwrap()
+            )?
             .expect_u128();
 
-        let mut signers: HashMap<Value, u128> = HashMap::new();
+        let mut signers: BTreeMap<Vec<u8>, u128> = BTreeMap::new();
         let mut total_ustx: u128 = 0;
         for index in 0..list_length {
             if let Ok(Value::Optional(entry)) = clarity.eval_read_only(
@@ -1841,10 +1838,9 @@ impl NakamotoChainState {
             ) {
                 if let Some(data) = entry.data {
                     let data = data.expect_tuple();
-                    let key = data.get("signer-key")?.to_owned();
+                    let key = data.get("signer-key")?.to_owned().expect_buff(33);
                     let amount = data.get("ustx")?.to_owned().expect_u128();
                     let sum = signers.get(&key).cloned().unwrap_or_default();
-                    //TODO HashMap insert order is not guaranteed
                     signers.insert(key, sum + amount);
                     total_ustx = total_ustx
                         .checked_add(amount)
@@ -1869,19 +1865,19 @@ impl NakamotoChainState {
         clarity: &mut ClarityTransactionConnection,
         chain_id: u32,
         pox_constants: &PoxConstants,
-    ) -> Result<Vec<StacksTransactionEvent>, Error> {
+        reward_cycle: u64,
+    ) -> Result<Vec<StacksTransactionEvent>, ChainstateError> {
         let is_mainnet = clarity.is_mainnet();
         let sender_addr = PrincipalData::from(boot::boot_code_addr(is_mainnet));
         let signers_contract = &boot_code_id(SIGNERS_NAME, is_mainnet);
 
-        let signers = Self::calculate_signer_slots(clarity, pox_constants).unwrap_or_default();
+        let signers =
+            Self::calculate_signer_slots(clarity, pox_constants, reward_cycle).unwrap_or_default();
 
         let signers_list_data: Vec<Value> = signers
             .iter()
             .map(|(signer_key, slots)| {
-                let key =
-                    StacksPublicKey::from_slice(signer_key.to_owned().expect_buff(33).as_slice())
-                        .expect("TODO: invalid key");
+                let key = StacksPublicKey::from_slice(signer_key.as_slice()).unwrap();
                 let addr = StacksAddress::from_public_keys(
                     if is_mainnet {
                         C32_ADDRESS_VERSION_MAINNET_SINGLESIG
@@ -1939,7 +1935,7 @@ impl NakamotoChainState {
         first_block_height: u64,
         pox_constants: &PoxConstants,
         burn_tip_height: u64,
-    ) -> Result<Vec<StacksTransactionEvent>, Error> {
+    ) -> Result<Vec<StacksTransactionEvent>, ChainstateError> {
         if clarity_tx.get_epoch() < StacksEpochId::Epoch25
             || !pox_constants.is_prepare_phase_start(first_block_height, burn_tip_height)
         {
@@ -1956,6 +1952,9 @@ impl NakamotoChainState {
                 clarity,
                 clarity_tx.config.chain_id,
                 &pox_constants,
+                pox_constants
+                    .block_height_to_reward_cycle(first_block_height, burn_tip_height)
+                    .expect("FATAL: no reward cycle for block height"),
             )
         })
     }
diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index fdadbce629..b75d22a720 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -115,7 +115,7 @@
         reward-set-indexes: (list 12 uint),
         ;; principal of the delegate, if stacker has delegated
         delegated-to: (optional principal),
-        signer-key: (buff 33)
+        signer-key: principal
     }
 )
 
@@ -152,7 +152,8 @@
     {
         pox-addr: { version: (buff 1), hashbytes: (buff 32) },
         total-ustx: uint,
-        stacker: (optional principal)
+        stacker: (optional principal),
+        signer: principal
     }
 )
 
@@ -171,7 +172,7 @@
         reward-cycle: uint,
         sender: principal
     }
-    { stacked-amount: uint }
+    { stacked-amount: uint, signer: principal }
 )
 
 ;; This is identical to partial-stacked-by-cycle, but its data is never deleted.
@@ -185,21 +186,9 @@
         reward-cycle: uint,
         sender: principal
     }
-    { stacked-amount: uint }
+    { stacked-amount: uint, signer: principal }
 )
 
-;; Stackers' signer keys that have been used before.
- (define-map used-signer-keys (buff 33) uint)
-
-;; Stackers' signer key locked Stacks per cycle
-(define-map signer-key-stx-total-ustx {reward-cycle: uint, signer-key: (buff 33)} uint)
-
-;; List of Stackers' signer key ustx commitments per cycle
-(define-map signer-key-ustx-list {reward-cycle: uint, index: uint} {signer-key: (buff 33), ustx: uint})
-
-;; Length of Stackers' signer key ustx commitment lists per cycle
-(define-map signer-key-ustx-list-len uint uint)
-
 ;; The stackers' aggregate public key
 ;;   for the given reward cycle
 (define-map aggregate-public-keys uint (buff 33))
@@ -269,20 +258,6 @@
         u0
         (get len (map-get? reward-cycle-pox-address-list-len { reward-cycle: reward-cycle }))))
 
-;; Get the signer key list length for a reward cycle.
-;; Note that this _does_ return duplicate signer keys.
-;; Used internally by the Stacks node, which will sum the amounts
-;; for each unique signer key and filter those that are below the
-;; minimum threshold.
-(define-read-only (get-signer-key-list-length (reward-cycle uint))
-  (default-to u0 (map-get? signer-key-ustx-list-len reward-cycle))
-)
-
-;; Called internally by the node to iterate through the list of signer keys in this reward cycle.
-(define-read-only (get-signer-key (reward-cycle uint) (index uint))
-  (map-get? signer-key-ustx-list {reward-cycle: reward-cycle, index: index})
-)
-
 ;; Add a single PoX address to a single reward cycle.
 ;; Used to build up a set of per-reward-cycle PoX addresses.
 ;; No checking will be done -- don't call if this PoX address is already registered in this reward cycle!
@@ -290,11 +265,12 @@
 (define-private (append-reward-cycle-pox-addr (pox-addr (tuple (version (buff 1)) (hashbytes (buff 32))))
                                               (reward-cycle uint)
                                               (amount-ustx uint)
-                                              (stacker (optional principal)))
+                                              (stacker (optional principal))
+                                              (signer principal))
     (let ((sz (get-reward-set-size reward-cycle)))
         (map-set reward-cycle-pox-address-list
             { reward-cycle: reward-cycle, index: sz }
-            { pox-addr: pox-addr, total-ustx: amount-ustx, stacker: stacker })
+            { pox-addr: pox-addr, total-ustx: amount-ustx, stacker: stacker, signer: signer })
         (map-set reward-cycle-pox-address-list-len
             { reward-cycle: reward-cycle }
             { len: (+ u1 sz) })
@@ -383,6 +359,7 @@
                                                             (first-reward-cycle uint)
                                                             (num-cycles uint)
                                                             (stacker (optional principal))
+                                                            (signer principal)
                                                             (amount-ustx uint)
                                                             (i uint))))
     (let ((reward-cycle (+ (get first-reward-cycle params) (get i params)))
@@ -397,6 +374,7 @@
                         reward-cycle
                         (get amount-ustx params)
                         (get stacker params)
+                        (get signer params)
                         )))
                   ;; update running total
                   (map-set reward-cycle-total-stacked
@@ -411,6 +389,7 @@
         num-cycles: num-cycles,
         amount-ustx: (get amount-ustx params),
         stacker: (get stacker params),
+        signer: (get signer params),
         reward-set-indexes: (match
             reward-set-index new (unwrap-panic (as-max-len? (append (get reward-set-indexes params) new) u12))
             (get reward-set-indexes params)),
@@ -424,11 +403,12 @@
                                                (first-reward-cycle uint)
                                                (num-cycles uint)
                                                (amount-ustx uint)
-                                               (stacker principal))
+                                               (stacker principal)
+                                               (signer principal))
   (let ((cycle-indexes (list u0 u1 u2 u3 u4 u5 u6 u7 u8 u9 u10 u11))
         (results (fold add-pox-addr-to-ith-reward-cycle cycle-indexes
                          { pox-addr: pox-addr, first-reward-cycle: first-reward-cycle, num-cycles: num-cycles,
-                           reward-set-indexes: (list), amount-ustx: amount-ustx, i: u0, stacker: (some stacker) }))
+                           reward-set-indexes: (list), amount-ustx: amount-ustx, i: u0, stacker: (some stacker), signer: signer }))
         (reward-set-indexes (get reward-set-indexes results)))
     ;; For safety, add up the number of times (add-principal-to-ith-reward-cycle) returns 1.
     ;; It _should_ be equal to num-cycles.
@@ -439,10 +419,12 @@
 (define-private (add-pox-partial-stacked-to-ith-cycle
                  (cycle-index uint)
                  (params { pox-addr: { version: (buff 1), hashbytes: (buff 32) },
+                           signer: principal,
                            reward-cycle: uint,
                            num-cycles: uint,
                            amount-ustx: uint }))
   (let ((pox-addr     (get pox-addr     params))
+        (signer       (get signer       params))
         (num-cycles   (get num-cycles   params))
         (reward-cycle (get reward-cycle params))
         (amount-ustx  (get amount-ustx  params)))
@@ -456,9 +438,10 @@
           ;; otherwise, add to the partial-stacked-by-cycle
           (map-set partial-stacked-by-cycle
                    { sender: tx-sender, pox-addr: pox-addr, reward-cycle: reward-cycle }
-                   { stacked-amount: (+ amount-ustx current-amount) }))
+                   { stacked-amount: (+ amount-ustx current-amount), signer: signer }))
       ;; produce the next params tuple
       { pox-addr: pox-addr,
+        signer: signer,
         reward-cycle: (+ u1 reward-cycle),
         num-cycles: num-cycles,
         amount-ustx: amount-ustx })))
@@ -467,12 +450,13 @@
 ;; A PoX address can be added to at most 12 consecutive cycles.
 ;; No checking is done.
 (define-private (add-pox-partial-stacked (pox-addr (tuple (version (buff 1)) (hashbytes (buff 32))))
+                                         (signer principal)
                                          (first-reward-cycle uint)
                                          (num-cycles uint)
                                          (amount-ustx uint))
   (let ((cycle-indexes (list u0 u1 u2 u3 u4 u5 u6 u7 u8 u9 u10 u11)))
     (fold add-pox-partial-stacked-to-ith-cycle cycle-indexes
-          { pox-addr: pox-addr, reward-cycle: first-reward-cycle, num-cycles: num-cycles, amount-ustx: amount-ustx })
+          { pox-addr: pox-addr, signer: signer, reward-cycle: first-reward-cycle, num-cycles: num-cycles, amount-ustx: amount-ustx })
     true))
 
 ;; What is the minimum number of uSTX to be stacked in the given reward cycle?
@@ -606,14 +590,8 @@
       ;; ensure that stacking can be performed
       (try! (can-stack-stx pox-addr amount-ustx first-reward-cycle lock-period))
 
-      ;; ensure the signer key can be used
-      (try! (insert-signer-key signer-key first-reward-cycle))
-
-      ;; update the total ustx for the signer key
-      (increment-signer-key-total-ustx first-reward-cycle signer-key amount-ustx)
-
       ;; register the PoX address with the amount stacked
-      (let ((reward-set-indexes (try! (add-pox-addr-to-reward-cycles pox-addr first-reward-cycle lock-period amount-ustx tx-sender))))
+      (let ((reward-set-indexes (try! (add-pox-addr-to-reward-cycles pox-addr first-reward-cycle lock-period amount-ustx tx-sender (try! (signer-key-buff-to-principal signer-key))))))
           ;; add stacker record
          (map-set stacking-state
            { stacker: tx-sender }
@@ -622,7 +600,7 @@
              first-reward-cycle: first-reward-cycle,
              lock-period: lock-period,
              delegated-to: none,
-             signer-key: signer-key })
+             signer-key: (try! (signer-key-buff-to-principal signer-key)) })
 
           ;; return the lock-up information, so the node can actually carry out the lock.
           (ok { stacker: tx-sender, lock-amount: amount-ustx, signer-key: signer-key, unlock-burn-height: (reward-cycle-to-burn-height (+ first-reward-cycle lock-period)) }))))
@@ -717,6 +695,7 @@
                      num-cycles: u1,
                      reward-set-indexes: (list),
                      stacker: none,
+                     signer: (get signer partial-stacked),
                      amount-ustx: amount-ustx,
                      i: u0 }))
            (pox-addr-index (unwrap-panic
@@ -805,7 +784,8 @@
                    { reward-cycle: reward-cycle, index: reward-cycle-index }
                    { pox-addr: pox-addr,
                      total-ustx: increased-ustx,
-                     stacker: none })
+                     stacker: none,
+                     signer: (get signer partial-stacked) })
 
           ;; update the total ustx in this cycle
           (map-set reward-cycle-total-stacked
@@ -832,7 +812,8 @@
     ;; this stacker's first reward cycle is the _next_ reward cycle
     (let ((first-reward-cycle (+ u1 (current-pox-reward-cycle)))
           (specified-reward-cycle (+ u1 (burn-height-to-reward-cycle start-burn-ht)))
-          (unlock-burn-height (reward-cycle-to-burn-height (+ (current-pox-reward-cycle) u1 lock-period))))
+          (unlock-burn-height (reward-cycle-to-burn-height (+ (current-pox-reward-cycle) u1 lock-period)))
+          (signer (try! (signer-key-buff-to-principal signer-key))))
       ;; the start-burn-ht must result in the next reward cycle, do not allow stackers
       ;;  to "post-date" their `stack-stx` transaction
       (asserts! (is-eq first-reward-cycle specified-reward-cycle)
@@ -871,18 +852,12 @@
       (asserts! (>= (stx-get-balance stacker) amount-ustx)
         (err ERR_STACKING_INSUFFICIENT_FUNDS))
 
-      ;; ensure the signer key can be used
-      (try! (insert-signer-key signer-key first-reward-cycle))
-
-      ;; update the total ustx for the signer key
-     (increment-signer-key-total-ustx first-reward-cycle signer-key amount-ustx)
-
       ;; ensure that stacking can be performed
       (try! (minimal-can-stack-stx pox-addr amount-ustx first-reward-cycle lock-period))
 
       ;; register the PoX address with the amount stacked via partial stacking
       ;;   before it can be included in the reward set, this must be committed!
-      (add-pox-partial-stacked pox-addr first-reward-cycle lock-period amount-ustx)
+      (add-pox-partial-stacked pox-addr signer first-reward-cycle lock-period amount-ustx)
 
       ;; add stacker record
       (map-set stacking-state
@@ -892,7 +867,7 @@
           reward-set-indexes: (list),
           lock-period: lock-period,
           delegated-to: (some tx-sender),
-          signer-key: signer-key })
+          signer-key: signer })
 
       ;; return the lock-up information, so the node can actually carry out the lock.
       (ok { stacker: stacker,
@@ -918,26 +893,29 @@
 ;; `(some stacker)` as the listed stacker, and must be an upcoming reward cycle.
 (define-private (increase-reward-cycle-entry
                   (reward-cycle-index uint)
-                  (updates (optional { first-cycle: uint, reward-cycle: uint, stacker: principal, add-amount: uint })))
+                  (updates (optional { first-cycle: uint, reward-cycle: uint, stacker: principal, signer: principal, add-amount: uint })))
     (let ((data (try! updates))
           (first-cycle (get first-cycle data))
           (reward-cycle (get reward-cycle data)))
     (if (> first-cycle reward-cycle)
         ;; not at first cycle to process yet
-        (some { first-cycle: first-cycle, reward-cycle: (+ u1 reward-cycle), stacker: (get stacker data), add-amount: (get add-amount data) })
+        (some { first-cycle: first-cycle, reward-cycle: (+ u1 reward-cycle), stacker: (get stacker data), signer: (get signer data), add-amount: (get add-amount data) })
         (let ((existing-entry (unwrap-panic (map-get? reward-cycle-pox-address-list { reward-cycle: reward-cycle, index: reward-cycle-index })))
               (existing-total (unwrap-panic (map-get? reward-cycle-total-stacked { reward-cycle: reward-cycle })))
               (add-amount (get add-amount data))
               (total-ustx (+ (get total-ustx existing-total) add-amount)))
             ;; stacker must match
             (asserts! (is-eq (get stacker existing-entry) (some (get stacker data))) none)
+            ;; signer must match
+            (asserts! (is-eq (get signer existing-entry) (get signer data)) none)
             ;; update the pox-address list
             (map-set reward-cycle-pox-address-list
                      { reward-cycle: reward-cycle, index: reward-cycle-index }
                      { pox-addr: (get pox-addr existing-entry),
                        ;; This addresses the bug in pox-2 (see SIP-022)
                        total-ustx: (+ (get total-ustx existing-entry) add-amount),
-                       stacker: (some (get stacker data)) })
+                       stacker: (some (get stacker data)),
+                       signer: (get signer data) })
             ;; update the total
             (map-set reward-cycle-total-stacked
                      { reward-cycle: reward-cycle }
@@ -945,6 +923,7 @@
             (some { first-cycle: first-cycle,
                     reward-cycle: (+ u1 reward-cycle),
                     stacker: (get stacker data),
+                    signer: (get signer data),
                     add-amount: (get add-amount data) })))))
 
 ;; Increase the number of STX locked.
@@ -985,6 +964,7 @@
             (some { first-cycle: first-increased-cycle,
                     reward-cycle: (get first-reward-cycle stacker-state),
                     stacker: tx-sender,
+                    signer: (get signer-key stacker-state),
                     add-amount: increase-by })))
             (err ERR_STACKING_UNREACHABLE))
       ;; NOTE: stacking-state map is unchanged: it does not track amount-stacked in PoX-4
@@ -1022,12 +1002,6 @@
     (asserts! (is-none (get delegated-to stacker-state))
               (err ERR_STACKING_IS_DELEGATED))
 
-    ;; ensure the signer key can be used
-    (try! (insert-signer-key signer-key first-extend-cycle))
-
-    ;; update the total ustx for the signer key
-    (increment-signer-key-total-ustx first-reward-cycle signer-key amount-ustx)
-
     ;; TODO: add more assertions to sanity check the `stacker-info` values with
     ;;       the `stacker-state` values
 
@@ -1057,7 +1031,7 @@
 
       ;; register the PoX address with the amount stacked
       ;;   for the new cycles
-      (let ((extended-reward-set-indexes (try! (add-pox-addr-to-reward-cycles pox-addr first-extend-cycle extend-count amount-ustx tx-sender)))
+      (let ((extended-reward-set-indexes (try! (add-pox-addr-to-reward-cycles pox-addr first-extend-cycle extend-count amount-ustx tx-sender (try! (signer-key-buff-to-principal signer-key)))))
             (reward-set-indexes
                 ;; use the active stacker state and extend the existing reward-set-indexes
                 (let ((cur-cycle-index (- first-reward-cycle (get first-reward-cycle stacker-state)))
@@ -1075,7 +1049,7 @@
               first-reward-cycle: first-reward-cycle,
               lock-period: lock-period,
               delegated-to: none,
-              signer-key: signer-key })
+              signer-key: (try! (signer-key-buff-to-principal signer-key)) })
 
         ;; return lock-up information
         (ok { stacker: tx-sender, unlock-burn-height: new-unlock-ht })))))
@@ -1161,7 +1135,7 @@
 
       ;; register the PoX address with the amount stacked via partial stacking
       ;;   before it can be included in the reward set, this must be committed!
-      (add-pox-partial-stacked pox-addr first-increase-cycle cycle-count increase-by)
+      (add-pox-partial-stacked pox-addr (get signer-key stacker-state) first-increase-cycle cycle-count increase-by)
 
       ;; stacking-state is unchanged, so no need to update
 
@@ -1196,7 +1170,8 @@
 
      (let ((last-extend-cycle  (- (+ first-extend-cycle extend-count) u1))
            (lock-period (+ u1 (- last-extend-cycle first-reward-cycle)))
-           (new-unlock-ht (reward-cycle-to-burn-height (+ u1 last-extend-cycle))))
+           (new-unlock-ht (reward-cycle-to-burn-height (+ u1 last-extend-cycle)))
+           (signer (try! (signer-key-buff-to-principal signer-key))))
 
       ;; first cycle must be after the current cycle
       (asserts! (> first-extend-cycle cur-cycle) (err ERR_STACKING_INVALID_LOCK_PERIOD))
@@ -1251,7 +1226,7 @@
 
       ;; register the PoX address with the amount stacked via partial stacking
       ;;   before it can be included in the reward set, this must be committed!
-      (add-pox-partial-stacked pox-addr first-extend-cycle extend-count amount-ustx)
+      (add-pox-partial-stacked pox-addr signer first-extend-cycle extend-count amount-ustx)
 
       (map-set stacking-state
         { stacker: stacker }
@@ -1260,7 +1235,7 @@
           first-reward-cycle: first-reward-cycle,
           lock-period: lock-period,
           delegated-to: (some tx-sender),
-          signer-key: signer-key })
+          signer-key: signer })
 
       ;; return the lock-up information, so the node can actually carry out the lock.
       (ok { stacker: stacker,
@@ -1312,27 +1287,8 @@
     )
 )
 
-;; Check if a provided signer key is valid to use.
-;; - It must be a buffer with length 33.
-;; - It must be a new signer key, or a signer key that was first seen in this cycle.
+;; Converts a buff 33 to a standard principal, returning an error if it fails.
 ;; *New in Stacks 3.0*
-(define-private (insert-signer-key (signer-key (buff 33)) (reward-cycle uint))
-    (let ((first-seen-cycle (default-to reward-cycle (map-get? used-signer-keys signer-key))))
-      (asserts! (is-eq (len signer-key) u33) (err ERR_INVALID_SIGNER_KEY))
-      (asserts! (and (is-eq first-seen-cycle reward-cycle) (map-insert used-signer-keys signer-key reward-cycle)) (err ERR_REUSED_SIGNER_KEY))
-      (ok true)
-    )
-)
-
-;; Increment the total number of ustx for the specified signer key.
-;; *New in Stacks 3.0*
-(define-private (increment-signer-key-total-ustx (reward-cycle-id uint) (signer-key (buff 33)) (amount uint))
-  (let ((list-index (default-to u0 (map-get? signer-key-ustx-list-len reward-cycle-id))))
-    (map-set signer-key-ustx-list {reward-cycle: reward-cycle-id, index: list-index} {signer-key: signer-key, ustx: amount})
-    (map-set signer-key-ustx-list-len reward-cycle-id (+ list-index u1))
-    (map-set signer-key-stx-total-ustx
-      {reward-cycle: reward-cycle-id, signer-key: signer-key}
-      (+ (default-to u0 (map-get? signer-key-stx-total-ustx {reward-cycle: reward-cycle-id, signer-key: signer-key})) amount)
-    )
-  )
+(define-private (signer-key-buff-to-principal (signer-key (buff 33)))
+  (ok (unwrap! (principal-of? signer-key) (err ERR_INVALID_SIGNER_KEY)))
 )
diff --git a/stackslib/src/chainstate/stacks/boot/signers_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_tests.rs
index 8d094a8c18..bf0ba9cfc2 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_tests.rs
@@ -95,6 +95,9 @@ fn signers_get_signer_keys_from_pox4() {
     let stacker_1_addr = key_to_stacks_addr(&stacker_1.stacker_private_key);
     let stacker_2_addr = key_to_stacks_addr(&stacker_2.stacker_private_key);
 
+    let signer_1_addr = key_to_stacks_addr(&stacker_1.signer_private_key);
+    let signer_2_addr = key_to_stacks_addr(&stacker_2.signer_private_key);
+
     let stacker_1_info = readonly_call(
         &mut peer,
         &latest_block_id,
@@ -116,16 +119,17 @@ fn signers_get_signer_keys_from_pox4() {
 
     assert_eq!(
         stacker_1_tuple.get_owned("signer-key").unwrap(),
-        Value::buff_from(stacker_1.signer_public_key().to_bytes_compressed()).unwrap()
+        Value::Principal(PrincipalData::from(signer_1_addr))
     );
 
     assert_eq!(
         stacker_2_tuple.get_owned("signer-key").unwrap(),
-        Value::buff_from(stacker_2.signer_public_key().to_bytes_compressed()).unwrap()
+        Value::Principal(PrincipalData::from(signer_2_addr))
     );
 }
 
 #[test]
+#[ignore = "to be updated when the signer keys are processed in make_reward_set"]
 fn signers_get_signer_keys_from_stackerdb() {
     let stacker_1 = TestStacker::from_seed(&[3, 4]);
     let stacker_2 = TestStacker::from_seed(&[5, 6]);

From d92a36884875bd8e8d7c0a4cfb580b043028aa99 Mon Sep 17 00:00:00 2001
From: MarvinJanssen <MarvinJanssen@users.noreply.github.com>
Date: Wed, 24 Jan 2024 01:09:42 +0100
Subject: [PATCH 0480/1166] wip: use make_reward_set to calculate signer set
 and write to .signers, update end to end test

---
 .../chainstate/nakamoto/coordinator/mod.rs    |  12 --
 .../chainstate/nakamoto/coordinator/tests.rs  |   4 +-
 stackslib/src/chainstate/nakamoto/mod.rs      | 146 +++++++++++-------
 .../src/chainstate/nakamoto/tests/mod.rs      |   6 +-
 stackslib/src/chainstate/stacks/boot/mod.rs   |  56 ++++---
 .../chainstate/stacks/boot/signers_tests.rs   |  65 ++++----
 6 files changed, 151 insertions(+), 138 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
index 22e58158cb..7df8719ca4 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
@@ -68,18 +68,6 @@ impl<'a, T: BlockEventDispatcher> OnChainRewardSetProvider<'a, T> {
         let mut registered_addrs =
             chainstate.get_reward_addresses_in_cycle(burnchain, sortdb, cycle, block_id)?;
 
-        // TODO (pox-4-workstream): the pox-4 contract must be able to return signing keys
-        //   associated with reward set entries (i.e., via `get-reward-set-pox-addresses`)
-        //   *not* stacking-state entries (as it is currently implemented). Until that's done,
-        //   this method just mocks that data.
-        for (index, entry) in registered_addrs.iter_mut().enumerate() {
-            let index = u64::try_from(index).expect("FATAL: more than u64 reward set entries");
-            let sk = StacksPrivateKey::from_seed(&index.to_be_bytes());
-            let addr =
-                StacksAddress::p2pkh(chainstate.mainnet, &StacksPublicKey::from_private(&sk));
-            entry.signing_key = Some(addr.into());
-        }
-
         let liquid_ustx = chainstate.get_liquid_ustx(block_id);
 
         let (threshold, participation) = StacksChainState::get_reward_threshold_and_participation(
diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index 2c71e3c0d3..2e77195f26 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -38,7 +38,6 @@ use crate::chainstate::stacks::address::PoxAddress;
 use crate::chainstate::stacks::boot::test::{
     key_to_stacks_addr, make_pox_4_aggregate_key, make_pox_4_lockup,
 };
-use crate::chainstate::stacks::boot::test::{make_pox_4_aggregate_key, make_pox_4_lockup};
 use crate::chainstate::stacks::boot::MINERS_NAME;
 use crate::chainstate::stacks::db::{MinerPaymentTxFees, StacksAccount, StacksChainState};
 use crate::chainstate::stacks::{
@@ -49,9 +48,8 @@ use crate::chainstate::stacks::{
 use crate::clarity::vm::types::StacksAddressExtensions;
 use crate::core::StacksEpochExtension;
 use crate::net::relay::Relayer;
-use crate::net::test::{TestEventObserver, TestPeer, TestPeerConfig};
 use crate::net::stackerdb::StackerDBConfig;
-use crate::net::test::{TestPeer, TestPeerConfig};
+use crate::net::test::{TestEventObserver, TestPeer, TestPeerConfig};
 use crate::util_lib::boot::boot_code_id;
 
 /// Bring a TestPeer into the Nakamoto Epoch
diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index 29d3ba7234..b7391c16d3 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -54,7 +54,8 @@ use super::burn::db::sortdb::{
 };
 use super::burn::operations::{DelegateStxOp, StackStxOp, TransferStxOp};
 use super::stacks::boot::{
-    BOOT_TEST_POX_4_AGG_KEY_CONTRACT, BOOT_TEST_POX_4_AGG_KEY_FNAME, SIGNERS_NAME,
+    RawRewardSetEntry, BOOT_TEST_POX_4_AGG_KEY_CONTRACT, BOOT_TEST_POX_4_AGG_KEY_FNAME,
+    SIGNERS_NAME,
 };
 use super::stacks::db::accounts::MinerReward;
 use super::stacks::db::blocks::StagingUserBurnSupport;
@@ -73,6 +74,8 @@ use crate::chainstate::burn::operations::{LeaderBlockCommitOp, LeaderKeyRegister
 use crate::chainstate::burn::{BlockSnapshot, SortitionHash};
 use crate::chainstate::coordinator::{BlockEventDispatcher, Error};
 use crate::chainstate::nakamoto::tenure::NAKAMOTO_TENURES_SCHEMA;
+use crate::chainstate::stacks::address::PoxAddress;
+use crate::chainstate::stacks::boot::test::get_reward_addresses_with_par_tip;
 use crate::chainstate::stacks::boot::POX_4_NAME;
 use crate::chainstate::stacks::db::{DBConfig as ChainstateConfig, StacksChainState};
 use crate::chainstate::stacks::{
@@ -84,7 +87,6 @@ use crate::clarity_vm::clarity::{
 };
 use crate::clarity_vm::database::SortitionDBRef;
 use crate::core::BOOT_BLOCK_HASH;
-use crate::monitoring;
 use crate::net::stackerdb::StackerDBConfig;
 use crate::net::Error as net_error;
 use crate::util_lib::boot;
@@ -1814,52 +1816,80 @@ impl NakamotoChainState {
         }
     }
 
-    fn calculate_signer_slots(
+    fn get_reward_slots(
         clarity: &mut ClarityTransactionConnection,
         pox_constants: &PoxConstants,
         reward_cycle: u64,
-    ) -> Result<BTreeMap<Vec<u8>, u128>, ChainstateError> {
+    ) -> Result<Vec<RawRewardSetEntry>, ChainstateError> {
         let is_mainnet = clarity.is_mainnet();
         let pox4_contract = &boot_code_id(POX_4_NAME, is_mainnet);
 
         let list_length = clarity
             .eval_read_only(
                 pox4_contract,
-                &format!("(get-signer-key-list-length u{})", reward_cycle),
+                &format!("(get-reward-set-size u{})", reward_cycle),
             )?
             .expect_u128();
 
-        let mut signers: BTreeMap<Vec<u8>, u128> = BTreeMap::new();
-        let mut total_ustx: u128 = 0;
+        let mut slots = vec![];
         for index in 0..list_length {
-            if let Ok(Value::Optional(entry)) = clarity.eval_read_only(
-                pox4_contract,
-                &format!("(get-signer-key u{} u{})", reward_cycle, index),
-            ) {
-                if let Some(data) = entry.data {
-                    let data = data.expect_tuple();
-                    let key = data.get("signer-key")?.to_owned().expect_buff(33);
-                    let amount = data.get("ustx")?.to_owned().expect_u128();
-                    let sum = signers.get(&key).cloned().unwrap_or_default();
-                    signers.insert(key, sum + amount);
-                    total_ustx = total_ustx
-                        .checked_add(amount)
-                        .expect("CORRUPTION: Stacker stacked > u128 max amount");
-                }
-            }
+            let entry = clarity
+                .eval_read_only(
+                    pox4_contract,
+                    &format!("(get-reward-set-pox-address u{} u{})", reward_cycle, index),
+                )?
+                .expect_optional()
+                .expect(&format!(
+                    "FATAL: missing PoX address in slot {} out of {} in reward cycle {}",
+                    index, list_length, reward_cycle
+                ))
+                .expect_tuple();
+
+            let pox_addr_tuple = entry
+                .get("pox-addr")
+                .expect(&format!("FATAL: no `pox-addr` in return value from (get-reward-set-pox-address u{} u{})", reward_cycle, index))
+                .to_owned();
+
+            let reward_address = PoxAddress::try_from_pox_tuple(is_mainnet, &pox_addr_tuple)
+                .expect(&format!(
+                    "FATAL: not a valid PoX address: {:?}",
+                    &pox_addr_tuple
+                ));
+
+            let total_ustx = entry
+                .get("total-ustx")
+                .expect(&format!("FATAL: no 'total-ustx' in return value from (get-reward-set-pox-address u{} u{})", reward_cycle, index))
+                .to_owned()
+                .expect_u128();
+
+            let stacker = entry
+                .get("stacker")
+                .expect(&format!(
+                    "FATAL: no 'stacker' in return value from (get-reward-set-pox-address u{} u{})",
+                    reward_cycle, index
+                ))
+                .to_owned()
+                .expect_optional()
+                .map(|value| value.expect_principal());
+
+            let signer = entry
+                .get("signer")
+                .expect(&format!(
+                    "FATAL: no 'signer' in return value from (get-reward-set-pox-address u{} u{})",
+                    reward_cycle, index
+                ))
+                .to_owned()
+                .expect_principal();
+
+            slots.push(RawRewardSetEntry {
+                reward_address,
+                amount_stacked: total_ustx,
+                stacker,
+                signer: Some(signer),
+            })
         }
 
-        // TODO: calculation
-        let threshold = total_ustx / 4000;
-        signers.retain(|_, value: &mut u128| {
-            if *value >= threshold {
-                *value = *value / threshold;
-                true
-            } else {
-                false
-            }
-        });
-        Ok(signers)
+        Ok(slots)
     }
     pub fn handle_signer_stackerdb_update(
         clarity: &mut ClarityTransactionConnection,
@@ -1871,41 +1901,36 @@ impl NakamotoChainState {
         let sender_addr = PrincipalData::from(boot::boot_code_addr(is_mainnet));
         let signers_contract = &boot_code_id(SIGNERS_NAME, is_mainnet);
 
-        let signers =
-            Self::calculate_signer_slots(clarity, pox_constants, reward_cycle).unwrap_or_default();
+        let liquid_ustx = clarity.with_clarity_db_readonly(|db| db.get_total_liquid_ustx());
 
-        let signers_list_data: Vec<Value> = signers
+        let reward_slots = Self::get_reward_slots(clarity, &pox_constants, reward_cycle)?;
+        let (threshold, participation) = StacksChainState::get_reward_threshold_and_participation(
+            &pox_constants,
+            &reward_slots[..],
+            liquid_ustx,
+        );
+        let reward_set =
+            StacksChainState::make_reward_set(threshold, reward_slots, StacksEpochId::Epoch30);
+
+        //TODO remove unwraps
+        let signers_list = reward_set
+            .signers
+            .unwrap()
             .iter()
-            .map(|(signer_key, slots)| {
-                let key = StacksPublicKey::from_slice(signer_key.as_slice()).unwrap();
-                let addr = StacksAddress::from_public_keys(
-                    if is_mainnet {
-                        C32_ADDRESS_VERSION_MAINNET_SINGLESIG
-                    } else {
-                        C32_ADDRESS_VERSION_TESTNET_SINGLESIG
-                    },
-                    &AddressHashMode::SerializeP2PKH,
-                    1,
-                    &vec![key],
-                )
-                .unwrap();
+            .map(|signer| {
                 Value::Tuple(
                     TupleData::from_data(vec![
-                        ("signer".into(), Value::Principal(PrincipalData::from(addr))),
-                        ("num-slots".into(), Value::UInt(slots.to_owned())),
+                        (
+                            "signer".into(),
+                            Value::Principal(PrincipalData::from(signer.signing_address)),
+                        ),
+                        ("num-slots".into(), Value::UInt(signer.slots.into())),
                     ])
                     .unwrap(),
                 )
             })
             .collect();
 
-        info!(
-            "Handling stackerdb update, {} signers in list",
-            signers_list_data.len()
-        );
-
-        let signers_list = Value::cons_list_unsanitized(signers_list_data).unwrap();
-
         let (value, _, events, _) = clarity
             .with_abort_callback(
                 |vm_env| {
@@ -1913,7 +1938,9 @@ impl NakamotoChainState {
                         env.execute_contract_allow_private(
                             &signers_contract,
                             "stackerdb-set-signer-slots",
-                            &symbols_from_values(vec![signers_list]),
+                            &symbols_from_values(vec![
+                                Value::cons_list_unsanitized(signers_list).unwrap()
+                            ]),
                             false,
                         )
                     })
@@ -1927,6 +1954,7 @@ impl NakamotoChainState {
                 info!("stackerdb update error, data: {}", data);
             }
         }
+
         Ok(events)
     }
 
diff --git a/stackslib/src/chainstate/nakamoto/tests/mod.rs b/stackslib/src/chainstate/nakamoto/tests/mod.rs
index 4ae3b965c5..c6c8217463 100644
--- a/stackslib/src/chainstate/nakamoto/tests/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/mod.rs
@@ -1644,11 +1644,7 @@ pub fn test_get_highest_nakamoto_tenure() {
 #[test]
 fn test_make_miners_stackerdb_config() {
     let test_signers = TestSigners::default();
-    let mut peer = boot_nakamoto(
-        function_name!(),
-        vec![],
-        test_signers.aggregate_public_key.clone(),
-    );
+    let mut peer = boot_nakamoto(function_name!(), vec![], &test_signers, None);
 
     let naka_miner_hash160 = peer.miner.nakamoto_miner_hash160();
     let miner_keys: Vec<_> = (0..10).map(|_| StacksPrivateKey::new()).collect();
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index ddef99f688..643db82798 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -161,7 +161,7 @@ pub struct RawRewardSetEntry {
     pub reward_address: PoxAddress,
     pub amount_stacked: u128,
     pub stacker: Option<PrincipalData>,
-    pub signing_key: Option<PrincipalData>,
+    pub signer: Option<PrincipalData>,
 }
 
 #[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
@@ -618,9 +618,9 @@ impl StacksChainState {
             return None;
         };
         // signing keys must be all-or-nothing in the reward set
-        let expects_signing_keys = first_entry.signing_key.is_some();
+        let expects_signing_keys = first_entry.signer.is_some();
         for entry in entries.iter() {
-            if entry.signing_key.is_some() != expects_signing_keys {
+            if entry.signer.is_some() != expects_signing_keys {
                 panic!("FATAL: stacking-set contains mismatched entries with and without signing keys.");
             }
         }
@@ -630,7 +630,7 @@ impl StacksChainState {
 
         let mut signer_set = BTreeMap::new();
         for entry in entries.iter() {
-            let signing_key = if let Some(PrincipalData::Standard(s)) = entry.signing_key.clone() {
+            let signing_key = if let Some(PrincipalData::Standard(s)) = entry.signer.clone() {
                 StacksAddress::from(s)
             } else {
                 // TODO: should figure out if in mainnet?
@@ -896,7 +896,7 @@ impl StacksChainState {
                 reward_address,
                 amount_stacked: total_ustx,
                 stacker: None,
-                signing_key: None,
+                signer: None,
             })
         }
 
@@ -986,7 +986,7 @@ impl StacksChainState {
                 reward_address,
                 amount_stacked: total_ustx,
                 stacker,
-                signing_key: None,
+                signer: None,
             })
         }
 
@@ -1076,7 +1076,7 @@ impl StacksChainState {
                 reward_address,
                 amount_stacked: total_ustx,
                 stacker,
-                signing_key: None,
+                signer: None,
             })
         }
 
@@ -1108,7 +1108,13 @@ impl StacksChainState {
 
         let mut ret = vec![];
         for i in 0..num_addrs {
-            // value should be (optional (tuple (pox-addr (tuple (...))) (total-ustx uint))).
+            // value should be:
+            // (optional {
+            //     pox-addr: { version: (buff 1), hashbytes: (buff 32) },
+            //     total-ustx: uint,
+            //     stacker: (optional principal),
+            //     signer: principal
+            // })
             let tuple = self
                 .eval_boot_code_read_only(
                     sortdb,
@@ -1150,17 +1156,27 @@ impl StacksChainState {
                 .expect_optional()
                 .map(|value| value.expect_principal());
 
+            let signer = tuple
+                .get("signer")
+                .expect(&format!(
+                    "FATAL: no 'signer' in return value from (get-reward-set-pox-address u{} u{})",
+                    reward_cycle, i
+                ))
+                .to_owned()
+                .expect_principal();
+
             debug!(
                 "Parsed PoX reward address";
                 "stacked_ustx" => total_ustx,
                 "reward_address" => %reward_address,
                 "stacker" => ?stacker,
+                "signer" => ?signer
             );
             ret.push(RawRewardSetEntry {
                 reward_address,
                 amount_stacked: total_ustx,
                 stacker,
-                signing_key: None,
+                signer: Some(signer),
             })
         }
 
@@ -1311,7 +1327,7 @@ pub mod test {
                 ),
                 amount_stacked: 1500,
                 stacker: None,
-                signing_key: None,
+                signer: None,
             },
             RawRewardSetEntry {
                 reward_address: PoxAddress::Standard(
@@ -1321,7 +1337,7 @@ pub mod test {
 
                 amount_stacked: 500,
                 stacker: None,
-                signing_key: None,
+                signer: None,
             },
             RawRewardSetEntry {
                 reward_address: PoxAddress::Standard(
@@ -1330,7 +1346,7 @@ pub mod test {
                 ),
                 amount_stacked: 1500,
                 stacker: None,
-                signing_key: None,
+                signer: None,
             },
             RawRewardSetEntry {
                 reward_address: PoxAddress::Standard(
@@ -1339,7 +1355,7 @@ pub mod test {
                 ),
                 amount_stacked: 400,
                 stacker: None,
-                signing_key: None,
+                signer: None,
             },
         ];
         assert_eq!(
@@ -1389,7 +1405,7 @@ pub mod test {
                     reward_address: rand_pox_addr(),
                     amount_stacked: liquid,
                     stacker: None,
-                    signing_key: None,
+                    signer: None,
                 }],
                 liquid,
             )
@@ -1416,7 +1432,7 @@ pub mod test {
                     reward_address: rand_pox_addr(),
                     amount_stacked: liquid / 4,
                     stacker: None,
-                    signing_key: None,
+                    signer: None,
                 }],
                 liquid,
             )
@@ -1432,13 +1448,13 @@ pub mod test {
                         reward_address: rand_pox_addr(),
                         amount_stacked: liquid / 4,
                         stacker: None,
-                        signing_key: None,
+                        signer: None,
                     },
                     RawRewardSetEntry {
                         reward_address: rand_pox_addr(),
                         amount_stacked: 10_000_000 * (MICROSTACKS_PER_STACKS as u128),
                         stacker: None,
-                        signing_key: None,
+                        signer: None,
                     },
                 ],
                 liquid,
@@ -1456,13 +1472,13 @@ pub mod test {
                         reward_address: rand_pox_addr(),
                         amount_stacked: liquid / 4,
                         stacker: None,
-                        signing_key: None,
+                        signer: None,
                     },
                     RawRewardSetEntry {
                         reward_address: rand_pox_addr(),
                         amount_stacked: MICROSTACKS_PER_STACKS as u128,
                         stacker: None,
-                        signing_key: None,
+                        signer: None,
                     },
                 ],
                 liquid,
@@ -1479,7 +1495,7 @@ pub mod test {
                     reward_address: rand_pox_addr(),
                     amount_stacked: liquid,
                     stacker: None,
-                    signing_key: None,
+                    signer: None,
                 }],
                 liquid,
             )
diff --git a/stackslib/src/chainstate/stacks/boot/signers_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_tests.rs
index bf0ba9cfc2..4a31ac8b0e 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_tests.rs
@@ -129,7 +129,6 @@ fn signers_get_signer_keys_from_pox4() {
 }
 
 #[test]
-#[ignore = "to be updated when the signer keys are processed in make_reward_set"]
 fn signers_get_signer_keys_from_stackerdb() {
     let stacker_1 = TestStacker::from_seed(&[3, 4]);
     let stacker_2 = TestStacker::from_seed(&[5, 6]);
@@ -149,46 +148,34 @@ fn signers_get_signer_keys_from_stackerdb() {
         "stackerdb-get-signer-slots".into(),
         vec![],
     )
-    .expect_result_ok()
-    .expect_list();
+    .expect_result_ok();
 
-    let expected_tuple_1 = TupleData::from_data(vec![
-        (
-            "signer".into(),
-            Principal(PrincipalData::from(signer_1_addr)),
-        ),
-        ("num-slots".into(), Value::UInt(2000)),
-    ])
-    .unwrap();
-
-    let expected_tuple_2 = TupleData::from_data(vec![
-        (
-            "signer".into(),
-            Principal(PrincipalData::from(signer_2_addr)),
-        ),
-        ("num-slots".into(), Value::UInt(2000)),
-    ])
-    .unwrap();
-
-    assert_eq!(signers.len(), 2);
-
-    let first_tuple = signers.first().unwrap().clone().expect_tuple();
-    let second_tuple = signers.last().unwrap().clone().expect_tuple();
-
-    // Tuples can be in either order
-    if first_tuple
-        .get("signer")
+    assert_eq!(
+        signers,
+        Value::cons_list_unsanitized(vec![
+            Value::Tuple(
+                TupleData::from_data(vec![
+                    (
+                        "signer".into(),
+                        Principal(PrincipalData::from(signer_2_addr)),
+                    ),
+                    ("num-slots".into(), Value::UInt(2)),
+                ])
+                .unwrap()
+            ),
+            Value::Tuple(
+                TupleData::from_data(vec![
+                    (
+                        "signer".into(),
+                        Principal(PrincipalData::from(signer_1_addr)),
+                    ),
+                    ("num-slots".into(), Value::UInt(2)),
+                ])
+                .unwrap()
+            )
+        ])
         .unwrap()
-        .clone()
-        .expect_principal()
-        == PrincipalData::from(signer_1_addr)
-    {
-        assert_eq!(first_tuple, expected_tuple_1);
-        assert_eq!(second_tuple, expected_tuple_2);
-    } else {
-        assert_eq!(first_tuple, expected_tuple_2);
-        assert_eq!(second_tuple, expected_tuple_1);
-    }
+    );
 }
 
 fn prepare_signers_test<'a>(

From e9fd4a9cf7de7ac60d77bbae23d1bd44badc2df5 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Wed, 24 Jan 2024 15:57:13 -0600
Subject: [PATCH 0481/1166] feat: more rigor when applying .signers
 transformations, fix tests, update anchor block selection, fix miner issue

---
 stackslib/src/burnchains/mod.rs               |  34 ++-
 .../chainstate/nakamoto/coordinator/mod.rs    | 199 ++++++++----------
 .../chainstate/nakamoto/coordinator/tests.rs  |  20 +-
 stackslib/src/chainstate/nakamoto/miner.rs    |  16 +-
 stackslib/src/chainstate/nakamoto/mod.rs      | 160 ++++++++++----
 .../src/chainstate/nakamoto/tests/node.rs     |   1 +
 .../chainstate/stacks/boot/contract_tests.rs  |  29 +++
 stackslib/src/chainstate/stacks/boot/mod.rs   |  19 +-
 .../src/chainstate/stacks/boot/signers.clar   |  28 ++-
 stackslib/src/chainstate/stacks/db/blocks.rs  |  11 +
 stackslib/src/chainstate/stacks/db/mod.rs     |   2 +-
 stackslib/src/clarity_vm/clarity.rs           |  33 +++
 stackslib/src/net/mod.rs                      |   4 +-
 13 files changed, 355 insertions(+), 201 deletions(-)

diff --git a/stackslib/src/burnchains/mod.rs b/stackslib/src/burnchains/mod.rs
index 1a9f0936d0..f610382241 100644
--- a/stackslib/src/burnchains/mod.rs
+++ b/stackslib/src/burnchains/mod.rs
@@ -520,17 +520,6 @@ impl PoxConstants {
         (effective_height % u64::from(self.reward_cycle_length)) == 1
     }
 
-    pub fn is_prepare_phase_start(&self, first_block_height: u64, burn_height: u64) -> bool {
-        if burn_height < first_block_height {
-            false
-        } else {
-            let effective_height = burn_height - first_block_height;
-            (effective_height + u64::from(self.prepare_length))
-                % u64::from(self.reward_cycle_length)
-                == 0
-        }
-    }
-
     pub fn reward_cycle_to_block_height(&self, first_block_height: u64, reward_cycle: u64) -> u64 {
         // NOTE: the `+ 1` is because the height of the first block of a reward cycle is mod 1, not
         // mod 0.
@@ -549,6 +538,29 @@ impl PoxConstants {
         )
     }
 
+    /// Return the reward cycle that the current prepare phase corresponds to if `block_height` is _in_ a prepare
+    /// phase. If it is not in a prepare phase, return None.
+    pub fn reward_cycle_of_prepare_phase(
+        &self,
+        first_block_height: u64,
+        block_height: u64,
+    ) -> Option<u64> {
+        if !self.is_in_prepare_phase(first_block_height, block_height) {
+            return None;
+        }
+        // the None branches here should be unreachable, because if `first_block_height > block_height`,
+        //   `is_in_prepare_phase` would have returned false, but no need to be unsafe anyways.
+        let effective_height = block_height.checked_sub(first_block_height)?;
+        let current_cycle = self.block_height_to_reward_cycle(first_block_height, block_height)?;
+        if effective_height % u64::from(self.reward_cycle_length) == 0 {
+            // if this is the "mod 0" block of a prepare phase, its corresponding reward cycle is the current one
+            Some(current_cycle)
+        } else {
+            // otherwise, the corresponding reward cycle is actually the _next_ reward cycle
+            Some(current_cycle + 1)
+        }
+    }
+
     pub fn is_in_prepare_phase(&self, first_block_height: u64, block_height: u64) -> bool {
         Self::static_is_in_prepare_phase(
             first_block_height,
diff --git a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
index 7df8719ca4..de145b6eec 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
@@ -61,11 +61,13 @@ impl<'a, T: BlockEventDispatcher> OnChainRewardSetProvider<'a, T> {
         sortdb: &SortitionDB,
         block_id: &StacksBlockId,
     ) -> Result<RewardSet, Error> {
+        // TODO: this method should read the .signers contract to get the reward set entries.
+        //   they will have been set via `NakamotoChainState::check_and_handle_prepare_phase_start()`.
         let cycle = burnchain
             .block_height_to_reward_cycle(cycle_start_burn_height)
             .expect("FATAL: no reward cycle for burn height");
 
-        let mut registered_addrs =
+        let registered_addrs =
             chainstate.get_reward_addresses_in_cycle(burnchain, sortdb, cycle, block_id)?;
 
         let liquid_ustx = chainstate.get_liquid_ustx(block_id);
@@ -194,9 +196,9 @@ pub fn get_nakamoto_reward_cycle_info<U: RewardSetProvider>(
           "reward_cycle_length" => burnchain.pox_constants.reward_cycle_length,
           "prepare_phase_length" => burnchain.pox_constants.prepare_length);
 
-    // find the last tenure-start Stacks block processed in the preceeding prepare phase
-    // (i.e. the first block in the tenure of the parent of the first Stacks block processed in the prepare phase).
-    // Note that we may not have processed it yet.  But, if we do find it, then it's
+    // Find the first Stacks block in this reward cycle's preceding prepare phase.
+    // This block will have invoked `.signers.stackerdb-set-signer-slots()` with the reward set.
+    // Note that we may not have processed it yet. But, if we do find it, then it's
     // unique (and since Nakamoto Stacks blocks are processed in order, the anchor block
     // cannot change later).
     let prepare_phase_sortitions =
@@ -215,125 +217,99 @@ pub fn get_nakamoto_reward_cycle_info<U: RewardSetProvider>(
         return Ok(None);
     };
 
-    for sn in prepare_phase_sortitions.into_iter() {
-        if !sn.sortition {
-            continue;
-        }
+    // iterate over the prepare_phase_sortitions, finding the first such sortition
+    //  with a processed stacks block
+    let Some(anchor_block_header) = prepare_phase_sortitions
+        .into_iter()
+        .find_map(|sn| {
+            if !sn.sortition {
+                return None
+            }
 
-        // find the first Stacks block processed in the prepare phase
-        let parent_block_id = if let Some(nakamoto_start_block) =
-            NakamotoChainState::get_nakamoto_tenure_start_block_header(
+            match NakamotoChainState::get_nakamoto_tenure_start_block_header(
                 chain_state.db(),
                 &sn.consensus_hash,
-            )? {
-            nakamoto_start_block
-                .anchored_header
-                .as_stacks_nakamoto()
-                // TODO: maybe `get_nakamoto_tenure_start_block_header` should
-                //       return a type that doesn't require this unwrapping?
-                .expect("FATAL: queried non-Nakamoto tenure start header")
-                .parent_block_id
-        } else {
-            let Some(block_header) =
-                StacksChainState::get_stacks_block_header_info_by_consensus_hash(
-                    chain_state.db(),
-                    &sn.consensus_hash,
-                )?
-            else {
-                // no header for this snapshot (possibly invalid)
-                debug!("Failed to find block by consensus hash"; "consensus_hash" => %sn.consensus_hash);
-                continue;
-            };
-            let Some(parent_block_id) = StacksChainState::get_parent_block_id(
-                chain_state.db(),
-                &block_header.index_block_hash(),
-            )?
-            else {
-                debug!("Failed to get parent block"; "block_id" => %block_header.index_block_hash());
-                continue;
-            };
-            parent_block_id
-        };
-
-        // find the tenure-start block of the tenure of the parent of this Stacks block.
-        // in epoch 2, this is the preceding anchor block
-        // in nakamoto, this is the tenure-start block of the preceding tenure
-        let parent_block_header =
-            NakamotoChainState::get_block_header(chain_state.db(), &parent_block_id)?
-                .expect("FATAL: no parent for processed Stacks block in prepare phase");
-
-        let anchor_block_header = match &parent_block_header.anchored_header {
-            StacksBlockHeaderTypes::Epoch2(..) => parent_block_header.clone(),
-            StacksBlockHeaderTypes::Nakamoto(..) => {
-                NakamotoChainState::get_nakamoto_tenure_start_block_header(
-                    chain_state.db(),
-                    &parent_block_header.consensus_hash,
-                )?
-                .expect("FATAL: no parent for processed Stacks block in prepare phase")
+            ) {
+                Ok(Some(x)) => return Some(Ok(x)),
+                Err(e) => return Some(Err(e)),
+                Ok(None) => {}, // pass: if cannot find nakamoto block, maybe it was a 2.x block?
             }
-        };
 
-        let anchor_block_sn = SortitionDB::get_block_snapshot_consensus(
-            sort_db.conn(),
-            &anchor_block_header.consensus_hash,
-        )?
-        .expect("FATAL: no snapshot for winning PoX anchor block");
-
-        // make sure the `anchor_block` field is the same as whatever goes into the block-commit,
-        // or PoX ancestry queries won't work
-        let (block_id, stacks_block_hash) = match anchor_block_header.anchored_header {
-            StacksBlockHeaderTypes::Epoch2(header) => (
-                StacksBlockId::new(&anchor_block_header.consensus_hash, &header.block_hash()),
-                header.block_hash(),
-            ),
-            StacksBlockHeaderTypes::Nakamoto(header) => {
-                (header.block_id(), BlockHeaderHash(header.block_id().0))
+            match StacksChainState::get_stacks_block_header_info_by_consensus_hash(
+                chain_state.db(),
+                &sn.consensus_hash,
+            ){
+                Ok(Some(x)) => return Some(Ok(x)),
+                Err(e) => return Some(Err(e)),
+                Ok(None) => {
+                    // no header for this snapshot (possibly invalid)
+                    debug!("Failed to find block by consensus hash"; "consensus_hash" => %sn.consensus_hash);
+                    return None
+                }
             }
+        })
+        // if there was a chainstate error during the lookup, yield the error
+        .transpose()? else {
+            // no stacks block known yet
+            info!("No PoX anchor block known yet for cycle {reward_cycle}");
+            return Ok(None)
         };
 
-        let txid = anchor_block_sn.winning_block_txid;
-
-        info!(
-            "Anchor block selected";
-            "cycle" => reward_cycle,
-            "block_id" => %block_id,
-            "consensus_hash" => %anchor_block_header.consensus_hash,
-            "burn_height" => anchor_block_header.burn_header_height,
-            "anchor_chain_tip" => %parent_block_header.index_block_hash(),
-            "anchor_chain_tip_height" => %parent_block_header.burn_header_height,
-            "first_prepare_sortition_id" => %first_sortition_id
-        );
+    let anchor_block_sn = SortitionDB::get_block_snapshot_consensus(
+        sort_db.conn(),
+        &anchor_block_header.consensus_hash,
+    )?
+    .expect("FATAL: no snapshot for winning PoX anchor block");
+
+    // make sure the `anchor_block` field is the same as whatever goes into the block-commit,
+    // or PoX ancestry queries won't work
+    let (block_id, stacks_block_hash) = match anchor_block_header.anchored_header {
+        StacksBlockHeaderTypes::Epoch2(ref header) => (
+            StacksBlockId::new(&anchor_block_header.consensus_hash, &header.block_hash()),
+            header.block_hash(),
+        ),
+        StacksBlockHeaderTypes::Nakamoto(ref header) => {
+            (header.block_id(), BlockHeaderHash(header.block_id().0))
+        }
+    };
 
-        let reward_set = provider.get_reward_set(
-            reward_start_height,
-            chain_state,
-            burnchain,
-            sort_db,
-            &block_id,
-        )?;
-        debug!(
-            "Stacks anchor block (ch {}) {} cycle {} is processed",
-            &anchor_block_header.consensus_hash, &block_id, reward_cycle
-        );
-        let anchor_status =
-            PoxAnchorBlockStatus::SelectedAndKnown(stacks_block_hash, txid, reward_set);
+    let txid = anchor_block_sn.winning_block_txid;
+
+    info!(
+        "Anchor block selected";
+        "cycle" => reward_cycle,
+        "block_id" => %block_id,
+        "consensus_hash" => %anchor_block_header.consensus_hash,
+        "burn_height" => anchor_block_header.burn_header_height,
+        "anchor_chain_tip" => %anchor_block_header.index_block_hash(),
+        "anchor_chain_tip_height" => %anchor_block_header.burn_header_height,
+        "first_prepare_sortition_id" => %first_sortition_id
+    );
 
-        let rc_info = RewardCycleInfo {
-            reward_cycle,
-            anchor_status,
-        };
+    let reward_set = provider.get_reward_set(
+        reward_start_height,
+        chain_state,
+        burnchain,
+        sort_db,
+        &block_id,
+    )?;
+    debug!(
+        "Stacks anchor block (ch {}) {} cycle {} is processed",
+        &anchor_block_header.consensus_hash, &block_id, reward_cycle
+    );
+    let anchor_status = PoxAnchorBlockStatus::SelectedAndKnown(stacks_block_hash, txid, reward_set);
 
-        // persist this
-        let mut tx = sort_db.tx_begin()?;
-        SortitionDB::store_preprocessed_reward_set(&mut tx, &first_sortition_id, &rc_info)?;
-        tx.commit()?;
+    let rc_info = RewardCycleInfo {
+        reward_cycle,
+        anchor_status,
+    };
 
-        return Ok(Some(rc_info));
-    }
+    // persist this
+    let mut tx = sort_db.tx_begin()?;
+    SortitionDB::store_preprocessed_reward_set(&mut tx, &first_sortition_id, &rc_info)?;
+    tx.commit()?;
 
-    // no stacks block known yet
-    info!("No PoX anchor block known yet for cycle {}", reward_cycle);
-    return Ok(None);
+    return Ok(Some(rc_info));
 }
 
 /// Get the next PoX recipients in the Nakamoto epoch.
@@ -398,9 +374,6 @@ impl<
     /// to ensure that the PoX stackers have been selected for this cycle.  This means that we
     /// don't proceed to process Nakamoto blocks until the reward cycle has begun.  Also, the last
     /// reward cycle of epoch2 _must_ be PoX so we have stackers who can sign.
-    ///
-    /// TODO: how do signers register their initial keys?  Can we just deploy a pre-registration
-    /// contract?
     pub fn can_process_nakamoto(&mut self) -> Result<bool, Error> {
         let canonical_sortition_tip = self
             .canonical_sortition_tip
diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index 2e77195f26..633f480604 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -56,7 +56,7 @@ use crate::util_lib::boot::boot_code_id;
 fn advance_to_nakamoto(
     peer: &mut TestPeer,
     test_signers: &TestSigners,
-    test_stackers: Vec<&TestStacker>,
+    test_stackers: Vec<TestStacker>,
 ) {
     let mut peer_nonce = 0;
     let private_key = peer.config.private_key.clone();
@@ -162,9 +162,10 @@ pub fn boot_nakamoto<'a>(
     peer_config.burnchain.pox_constants.pox_3_activation_height = 26;
     peer_config.burnchain.pox_constants.v3_unlock_height = 27;
     peer_config.burnchain.pox_constants.pox_4_activation_height = 31;
+    peer_config.test_stackers = Some(test_stackers.clone());
     let mut peer = TestPeer::new(peer_config);
 
-    advance_to_nakamoto(&mut peer, &test_signers, test_stackers.iter().collect());
+    advance_to_nakamoto(&mut peer, &test_signers, test_stackers);
 
     peer
 }
@@ -175,21 +176,12 @@ fn make_replay_peer<'a>(peer: &'a mut TestPeer<'a>) -> TestPeer<'a> {
     replay_config.test_name = format!("{}.replay", &peer.config.test_name);
     replay_config.server_port = 0;
     replay_config.http_port = 0;
+    replay_config.test_stackers = peer.config.test_stackers.clone();
 
-    let private_key = peer.config.private_key.clone();
-    let signer_private_key = StacksPrivateKey::from_seed(&[3]);
-
+    let test_stackers = replay_config.test_stackers.clone().unwrap_or(vec![]);
     let mut replay_peer = TestPeer::new(replay_config);
     let observer = TestEventObserver::new();
-    advance_to_nakamoto(
-        &mut replay_peer,
-        &TestSigners::default(),
-        vec![&TestStacker {
-            stacker_private_key: private_key,
-            signer_private_key,
-            amount: 1_000_000_000_000_000_000,
-        }],
-    );
+    advance_to_nakamoto(&mut replay_peer, &TestSigners::default(), test_stackers);
 
     // sanity check
     let replay_tip = {
diff --git a/stackslib/src/chainstate/nakamoto/miner.rs b/stackslib/src/chainstate/nakamoto/miner.rs
index b4f44bdd2a..1f71f7031c 100644
--- a/stackslib/src/chainstate/nakamoto/miner.rs
+++ b/stackslib/src/chainstate/nakamoto/miner.rs
@@ -224,11 +224,17 @@ impl NakamotoBlockBuilder {
     ) -> Result<MinerTenureInfo<'a>, Error> {
         debug!("Nakamoto miner tenure begin");
 
-        let burn_tip = SortitionDB::get_canonical_chain_tip_bhh(burn_dbconn.conn())?;
-        let burn_tip_height = u32::try_from(
-            SortitionDB::get_canonical_burn_chain_tip(burn_dbconn.conn())?.block_height,
-        )
-        .expect("block height overflow");
+        // must build off of the header's consensus hash as the burnchain view, not the canonical_tip_bhh:
+        let burn_sn = SortitionDB::get_block_snapshot_consensus(burn_dbconn.conn(), &self.header.consensus_hash)?
+            .ok_or_else(|| {
+                warn!(
+                    "Could not mine. The expected burnchain consensus hash has not been processed by our SortitionDB";
+                    "consensus_hash" => %self.header.consensus_hash
+                );
+                Error::NoSuchBlockError
+            })?;
+        let burn_tip = burn_sn.burn_header_hash;
+        let burn_tip_height = u32::try_from(burn_sn.block_height).expect("block height overflow");
 
         let mainnet = chainstate.config().mainnet;
 
diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index b7391c16d3..56c9fad9a9 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -21,7 +21,6 @@ use clarity::vm::ast::ASTRules;
 use clarity::vm::costs::{ExecutionCost, LimitedCostTracker};
 use clarity::vm::database::{BurnStateDB, ClarityDatabase};
 use clarity::vm::events::StacksTransactionEvent;
-use clarity::vm::test_util::symbols_from_values;
 use clarity::vm::types::{PrincipalData, StacksAddressExtensions, TupleData};
 use clarity::vm::{ClarityVersion, SymbolicExpression, Value};
 use lazy_static::{__Deref, lazy_static};
@@ -54,8 +53,8 @@ use super::burn::db::sortdb::{
 };
 use super::burn::operations::{DelegateStxOp, StackStxOp, TransferStxOp};
 use super::stacks::boot::{
-    RawRewardSetEntry, BOOT_TEST_POX_4_AGG_KEY_CONTRACT, BOOT_TEST_POX_4_AGG_KEY_FNAME,
-    SIGNERS_NAME,
+    PoxVersions, RawRewardSetEntry, BOOT_TEST_POX_4_AGG_KEY_CONTRACT,
+    BOOT_TEST_POX_4_AGG_KEY_FNAME, SIGNERS_MAX_LIST_SIZE, SIGNERS_NAME,
 };
 use super::stacks::db::accounts::MinerReward;
 use super::stacks::db::blocks::StagingUserBurnSupport;
@@ -75,8 +74,7 @@ use crate::chainstate::burn::{BlockSnapshot, SortitionHash};
 use crate::chainstate::coordinator::{BlockEventDispatcher, Error};
 use crate::chainstate::nakamoto::tenure::NAKAMOTO_TENURES_SCHEMA;
 use crate::chainstate::stacks::address::PoxAddress;
-use crate::chainstate::stacks::boot::test::get_reward_addresses_with_par_tip;
-use crate::chainstate::stacks::boot::POX_4_NAME;
+use crate::chainstate::stacks::boot::{POX_4_NAME, SIGNERS_UPDATE_STATE};
 use crate::chainstate::stacks::db::{DBConfig as ChainstateConfig, StacksChainState};
 use crate::chainstate::stacks::{
     TenureChangeCause, MINER_BLOCK_CONSENSUS_HASH, MINER_BLOCK_HEADER_HASH,
@@ -1818,25 +1816,39 @@ impl NakamotoChainState {
 
     fn get_reward_slots(
         clarity: &mut ClarityTransactionConnection,
-        pox_constants: &PoxConstants,
         reward_cycle: u64,
+        pox_contract: &str,
     ) -> Result<Vec<RawRewardSetEntry>, ChainstateError> {
         let is_mainnet = clarity.is_mainnet();
-        let pox4_contract = &boot_code_id(POX_4_NAME, is_mainnet);
+        if !matches!(
+            PoxVersions::lookup_by_name(pox_contract),
+            Some(PoxVersions::Pox4)
+        ) {
+            error!("Invoked Nakamoto reward-set fetch on non-pox-4 contract");
+            return Err(ChainstateError::DefunctPoxContract);
+        }
+        let pox_contract = &boot_code_id(pox_contract, is_mainnet);
 
         let list_length = clarity
-            .eval_read_only(
-                pox4_contract,
-                &format!("(get-reward-set-size u{})", reward_cycle),
+            .eval_method_read_only(
+                pox_contract,
+                "get-reward-set-size",
+                &[SymbolicExpression::atom_value(Value::UInt(
+                    reward_cycle.into(),
+                ))],
             )?
             .expect_u128();
 
         let mut slots = vec![];
         for index in 0..list_length {
             let entry = clarity
-                .eval_read_only(
-                    pox4_contract,
-                    &format!("(get-reward-set-pox-address u{} u{})", reward_cycle, index),
+                .eval_method_read_only(
+                    pox_contract,
+                    "get-reward-set-pox-address",
+                    &[
+                        SymbolicExpression::atom_value(Value::UInt(reward_cycle.into())),
+                        SymbolicExpression::atom_value(Value::UInt(index)),
+                    ],
                 )?
                 .expect_optional()
                 .expect(&format!(
@@ -1891,20 +1903,20 @@ impl NakamotoChainState {
 
         Ok(slots)
     }
+
     pub fn handle_signer_stackerdb_update(
         clarity: &mut ClarityTransactionConnection,
-        chain_id: u32,
         pox_constants: &PoxConstants,
         reward_cycle: u64,
+        pox_contract: &str,
     ) -> Result<Vec<StacksTransactionEvent>, ChainstateError> {
         let is_mainnet = clarity.is_mainnet();
         let sender_addr = PrincipalData::from(boot::boot_code_addr(is_mainnet));
         let signers_contract = &boot_code_id(SIGNERS_NAME, is_mainnet);
 
         let liquid_ustx = clarity.with_clarity_db_readonly(|db| db.get_total_liquid_ustx());
-
-        let reward_slots = Self::get_reward_slots(clarity, &pox_constants, reward_cycle)?;
-        let (threshold, participation) = StacksChainState::get_reward_threshold_and_participation(
+        let reward_slots = Self::get_reward_slots(clarity, reward_cycle, pox_contract)?;
+        let (threshold, _participation) = StacksChainState::get_reward_threshold_and_participation(
             &pox_constants,
             &reward_slots[..],
             liquid_ustx,
@@ -1912,10 +1924,9 @@ impl NakamotoChainState {
         let reward_set =
             StacksChainState::make_reward_set(threshold, reward_slots, StacksEpochId::Epoch30);
 
-        //TODO remove unwraps
-        let signers_list = reward_set
+        let signers_list: Vec<_> = reward_set
             .signers
-            .unwrap()
+            .ok_or(ChainstateError::PoxNoRewardCycle)?
             .iter()
             .map(|signer| {
                 Value::Tuple(
@@ -1926,11 +1937,28 @@ impl NakamotoChainState {
                         ),
                         ("num-slots".into(), Value::UInt(signer.slots.into())),
                     ])
-                    .unwrap(),
+                    .expect(
+                        "BUG: Failed to construct `{ signer: principal, num-slots: u64 }` tuple",
+                    ),
                 )
             })
             .collect();
 
+        if signers_list.len() > SIGNERS_MAX_LIST_SIZE {
+            panic!(
+                "FATAL: signers list returned by reward set calculations longer than maximum ({} > {})",
+                signers_list.len(),
+                SIGNERS_MAX_LIST_SIZE,
+            );
+        }
+
+        let args = [
+            SymbolicExpression::atom_value(Value::cons_list_unsanitized(signers_list).expect(
+                "BUG: Failed to construct `(list 4000 { signer: principal, num-slots: u64 })` list",
+            )),
+            SymbolicExpression::atom_value(Value::UInt(reward_cycle.into())),
+        ];
+
         let (value, _, events, _) = clarity
             .with_abort_callback(
                 |vm_env| {
@@ -1938,9 +1966,7 @@ impl NakamotoChainState {
                         env.execute_contract_allow_private(
                             &signers_contract,
                             "stackerdb-set-signer-slots",
-                            &symbols_from_values(vec![
-                                Value::cons_list_unsanitized(signers_list).unwrap()
-                            ]),
+                            &args,
                             false,
                         )
                     })
@@ -1949,9 +1975,14 @@ impl NakamotoChainState {
             )
             .expect("FATAL: failed to update signer stackerdb");
 
-        if let Value::Response(data) = value {
+        if let Value::Response(ref data) = value {
             if !data.committed {
-                info!("stackerdb update error, data: {}", data);
+                error!(
+                    "Error while updating .signers contract";
+                    "reward_cycle" => reward_cycle,
+                    "cc_response" => %value,
+                );
+                panic!();
             }
         }
 
@@ -1964,25 +1995,76 @@ impl NakamotoChainState {
         pox_constants: &PoxConstants,
         burn_tip_height: u64,
     ) -> Result<Vec<StacksTransactionEvent>, ChainstateError> {
-        if clarity_tx.get_epoch() < StacksEpochId::Epoch25
-            || !pox_constants.is_prepare_phase_start(first_block_height, burn_tip_height)
-        {
+        let current_epoch = clarity_tx.get_epoch();
+        if current_epoch < StacksEpochId::Epoch25 {
+            // before Epoch-2.5, no need for special handling
+            return Ok(vec![]);
+        }
+        // now, determine if we are in a prepare phase, and we are the first
+        //  block in this prepare phase in our fork
+        if !pox_constants.is_in_prepare_phase(first_block_height, burn_tip_height) {
+            // if we're not in a prepare phase, don't need to do anything
+            return Ok(vec![]);
+        }
+
+        let Some(cycle_of_prepare_phase) =
+            pox_constants.reward_cycle_of_prepare_phase(first_block_height, burn_tip_height)
+        else {
+            // if we're not in a prepare phase, don't need to do anything
+            return Ok(vec![]);
+        };
+
+        let active_pox_contract = pox_constants.active_pox_contract(burn_tip_height);
+        if !matches!(
+            PoxVersions::lookup_by_name(active_pox_contract),
+            Some(PoxVersions::Pox4)
+        ) {
+            debug!(
+                "Active PoX contract is not PoX-4, skipping .signers updates until PoX-4 is active"
+            );
+            return Ok(vec![]);
+        }
+
+        let signers_contract = &boot_code_id(SIGNERS_NAME, clarity_tx.config.mainnet);
+
+        // are we the first block in the prepare phase in our fork?
+        let needs_update = clarity_tx.connection().with_clarity_db_readonly(|clarity_db| {
+            if !clarity_db.has_contract(signers_contract) {
+                // if there's no signers contract, no need to update anything.
+                return false
+            }
+            let Ok(value) = clarity_db.lookup_variable_unknown_descriptor(
+                signers_contract,
+                SIGNERS_UPDATE_STATE,
+                &current_epoch,
+            ) else {
+                error!("FATAL: Failed to read `{SIGNERS_UPDATE_STATE}` variable from .signers contract");
+                panic!();
+            };
+            let cycle_number = value.expect_u128();
+            // if the cycle_number is less than `cycle_of_prepare_phase`, we need to update
+            //  the .signers state.
+            cycle_number < cycle_of_prepare_phase.into()
+        });
+
+        if !needs_update {
+            debug!("Current cycle has already been setup in .signers or .signers is not initialized yet");
             return Ok(vec![]);
         }
 
         info!(
-            "handling stackerdb update at burn height {}",
-            burn_tip_height
+            "Performing .signers state update";
+            "burn_height" => burn_tip_height,
+            "for_cycle" => cycle_of_prepare_phase,
+            "signers_contract" => %signers_contract,
         );
 
-        clarity_tx.block.as_free_transaction(|clarity| {
+        clarity_tx.connection().as_free_transaction(|clarity| {
             Self::handle_signer_stackerdb_update(
                 clarity,
-                clarity_tx.config.chain_id,
                 &pox_constants,
-                pox_constants
-                    .block_height_to_reward_cycle(first_block_height, burn_tip_height)
-                    .expect("FATAL: no reward cycle for block height"),
+                cycle_of_prepare_phase,
+                active_pox_contract,
             )
         })
     }
@@ -2731,14 +2813,12 @@ impl NakamotoChainState {
 
         // Handle signer stackerdb updates
         if evaluated_epoch >= StacksEpochId::Epoch25 {
-            let receipts = Self::check_and_handle_prepare_phase_start(
+            let _events = Self::check_and_handle_prepare_phase_start(
                 &mut clarity_tx,
                 first_block_height,
                 &pox_constants,
                 burn_header_height.into(),
-            );
-            //TODO
-            // tx_receipts.extend(receipts);
+            )?;
         }
 
         debug!(
diff --git a/stackslib/src/chainstate/nakamoto/tests/node.rs b/stackslib/src/chainstate/nakamoto/tests/node.rs
index cc2930c1e2..3918653d90 100644
--- a/stackslib/src/chainstate/nakamoto/tests/node.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/node.rs
@@ -622,6 +622,7 @@ impl TestStacksNode {
 
             let sort_tip = SortitionDB::get_canonical_sortition_tip(sortdb.conn()).unwrap();
             let mut sort_handle = sortdb.index_handle(&sort_tip);
+            info!("Processing the new nakamoto block");
             let accepted = match Relayer::process_new_nakamoto_block(
                 sortdb,
                 &mut sort_handle,
diff --git a/stackslib/src/chainstate/stacks/boot/contract_tests.rs b/stackslib/src/chainstate/stacks/boot/contract_tests.rs
index bd7941f73e..c0a98a5944 100644
--- a/stackslib/src/chainstate/stacks/boot/contract_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/contract_tests.rs
@@ -29,6 +29,7 @@ use stacks_common::types::chainstate::{
 };
 use stacks_common::util::hash::{to_hex, Sha256Sum, Sha512Trunc256Sum};
 
+use super::SIGNERS_MAX_LIST_SIZE;
 use crate::burnchains::{Burnchain, PoxConstants};
 use crate::chainstate::burn::ConsensusHash;
 use crate::chainstate::stacks::address::PoxAddress;
@@ -1685,6 +1686,34 @@ fn test_deploy_smart_contract(
     })
 }
 
+#[test]
+// test that the maximum stackerdb list size will fit in a value
+fn max_stackerdb_list() {
+    let signers_list: Vec<_> = (0..SIGNERS_MAX_LIST_SIZE)
+        .into_iter()
+        .map(|signer_ix| {
+            let signer_address = StacksAddress {
+                version: 0,
+                bytes: Hash160::from_data(&signer_ix.to_be_bytes()),
+            };
+            Value::Tuple(
+                TupleData::from_data(vec![
+                    (
+                        "signer".into(),
+                        Value::Principal(PrincipalData::from(signer_address)),
+                    ),
+                    ("num-slots".into(), Value::UInt(1)),
+                ])
+                .expect("BUG: Failed to construct `{ signer: principal, num-slots: u64 }` tuple"),
+            )
+        })
+        .collect();
+
+    assert_eq!(signers_list.len(), SIGNERS_MAX_LIST_SIZE);
+    Value::cons_list_unsanitized(signers_list)
+        .expect("Failed to construct `(list 4000 { signer: principal, num-slots: u64 })` list");
+}
+
 #[test]
 fn recency_tests() {
     let mut sim = ClarityTestSim::new();
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 643db82798..7c60e1164f 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -31,7 +31,6 @@ use clarity::vm::database::{
 use clarity::vm::errors::{Error as VmError, InterpreterError, InterpreterResult};
 use clarity::vm::events::StacksTransactionEvent;
 use clarity::vm::representations::{ClarityName, ContractName};
-use clarity::vm::tests::symbols_from_values;
 use clarity::vm::types::TypeSignature::UIntType;
 use clarity::vm::types::{
     PrincipalData, QualifiedContractIdentifier, SequenceData, StandardPrincipalData, TupleData,
@@ -80,6 +79,10 @@ pub const POX_2_NAME: &'static str = "pox-2";
 pub const POX_3_NAME: &'static str = "pox-3";
 pub const POX_4_NAME: &'static str = "pox-4";
 pub const SIGNERS_NAME: &'static str = "signers";
+/// This is the name of a variable in the `.signers` contract which tracks the most recently updated
+/// reward cycle number.
+pub const SIGNERS_UPDATE_STATE: &'static str = "last-set-cycle";
+pub const SIGNERS_MAX_LIST_SIZE: usize = 4000;
 
 const POX_2_BODY: &'static str = std::include_str!("pox-2.clar");
 const POX_3_BODY: &'static str = std::include_str!("pox-3.clar");
@@ -164,6 +167,20 @@ pub struct RawRewardSetEntry {
     pub signer: Option<PrincipalData>,
 }
 
+/// This enum captures the names of the PoX contracts by version.
+// This should deprecate the const values `POX_version_NAME`, but
+// that is the kind of refactor that should be in its own PR.
+// Having an enum here is useful for a bunch of reasons, but chiefly:
+//   * we'll be able to add an Ord implementation, so that we can
+//     do much easier version checks
+//   * static enforcement of matches
+define_named_enum!(PoxVersions {
+    Pox1("pox"),
+    Pox2("pox-2"),
+    Pox3("pox-3"),
+    Pox4("pox-4"),
+});
+
 #[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
 pub struct PoxStartCycleInfo {
     /// This data contains the set of principals who missed a reward slot
diff --git a/stackslib/src/chainstate/stacks/boot/signers.clar b/stackslib/src/chainstate/stacks/boot/signers.clar
index 19dd27fc3a..3a78605778 100644
--- a/stackslib/src/chainstate/stacks/boot/signers.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers.clar
@@ -1,24 +1,22 @@
+(define-data-var last-set-cycle uint u0)
 (define-data-var stackerdb-signer-slots (list 4000 { signer: principal, num-slots: uint }) (list))
 
-(define-private (stackerdb-set-signer-slots (signer-slots (list 4000 { signer: principal, num-slots: uint })))
+(define-private (stackerdb-set-signer-slots 
+                   (signer-slots (list 4000 { signer: principal, num-slots: uint }))
+                   (reward-cycle uint))
 	(begin
 		(print signer-slots)
-		(ok (var-set stackerdb-signer-slots signer-slots))
-	)
-)
+        (var-set last-set-cycle reward-cycle)
+		(ok (var-set stackerdb-signer-slots signer-slots))))
 
 (define-read-only (stackerdb-get-signer-slots)
-	(ok (var-get stackerdb-signer-slots))
-)
+	(ok (var-get stackerdb-signer-slots)))
 
 (define-read-only (stackerdb-get-config)
 	(ok
-		{
-		chunk-size: u4096,
-		write-freq: u0,
-		max-writes: u4096,
-		max-neighbors: u32,
-		hint-replicas: (list)
-		}
-	)
-)
+		{ chunk-size: u4096,
+		  write-freq: u0,
+		  max-writes: u4096,
+		  max-neighbors: u32,
+		  hint-replicas: (list) }
+	))
diff --git a/stackslib/src/chainstate/stacks/db/blocks.rs b/stackslib/src/chainstate/stacks/db/blocks.rs
index f42c18461f..4deeb57443 100644
--- a/stackslib/src/chainstate/stacks/db/blocks.rs
+++ b/stackslib/src/chainstate/stacks/db/blocks.rs
@@ -5140,6 +5140,17 @@ impl StacksChainState {
             );
         }
 
+        // Handle signer stackerdb updates
+        let first_block_height = burn_dbconn.get_burn_start_height();
+        if evaluated_epoch >= StacksEpochId::Epoch25 {
+            let _events = NakamotoChainState::check_and_handle_prepare_phase_start(
+                &mut clarity_tx,
+                first_block_height.into(),
+                &pox_constants,
+                burn_tip_height.into(),
+            )?;
+        }
+
         debug!(
             "Setup block: ready to go for {}/{}",
             &chain_tip.consensus_hash,
diff --git a/stackslib/src/chainstate/stacks/db/mod.rs b/stackslib/src/chainstate/stacks/db/mod.rs
index 5843ea1b45..d1cb81c6db 100644
--- a/stackslib/src/chainstate/stacks/db/mod.rs
+++ b/stackslib/src/chainstate/stacks/db/mod.rs
@@ -463,7 +463,7 @@ pub type StacksDBTx<'a> = IndexDBTx<'a, (), StacksBlockId>;
 pub type StacksDBConn<'a> = IndexDBConn<'a, (), StacksBlockId>;
 
 pub struct ClarityTx<'a, 'b> {
-    pub block: ClarityBlockConnection<'a, 'b>,
+    block: ClarityBlockConnection<'a, 'b>,
     pub config: DBConfig,
 }
 
diff --git a/stackslib/src/clarity_vm/clarity.rs b/stackslib/src/clarity_vm/clarity.rs
index 063f731159..889e9c03ab 100644
--- a/stackslib/src/clarity_vm/clarity.rs
+++ b/stackslib/src/clarity_vm/clarity.rs
@@ -1771,6 +1771,39 @@ impl<'a, 'b> ClarityTransactionConnection<'a, 'b> {
             .reset_memory();
     }
 
+    /// Evaluate a method of a clarity contract in a read-only environment.
+    /// This does not check if the method itself attempted to write,
+    ///  but will always rollback any changes.
+    ///
+    /// The method is invoked as if the contract itself is the tx-sender.
+    ///
+    /// This method *is not* free: it will update the cost-tracker of
+    /// the transaction connection. If the transaction connection is a
+    /// free transaction, then these costs will be free, but
+    /// otherwise, the cost tracker will be invoked like normal.
+    pub fn eval_method_read_only(
+        &mut self,
+        contract: &QualifiedContractIdentifier,
+        method: &str,
+        args: &[SymbolicExpression],
+    ) -> Result<Value, Error> {
+        let (result, _, _, _) = self.with_abort_callback(
+            |vm_env| {
+                vm_env
+                    .execute_transaction(
+                        PrincipalData::Contract(contract.clone()),
+                        None,
+                        contract.clone(),
+                        method,
+                        args,
+                    )
+                    .map_err(Error::from)
+            },
+            |_, _| true,
+        )?;
+        Ok(result)
+    }
+
     /// Evaluate a raw Clarity snippit
     #[cfg(test)]
     pub fn clarity_eval_raw(&mut self, code: &str) -> Result<Value, Error> {
diff --git a/stackslib/src/net/mod.rs b/stackslib/src/net/mod.rs
index 6a5406ddf0..bfd4f56e4c 100644
--- a/stackslib/src/net/mod.rs
+++ b/stackslib/src/net/mod.rs
@@ -1594,7 +1594,7 @@ pub mod test {
     use crate::chainstate::burn::*;
     use crate::chainstate::coordinator::tests::*;
     use crate::chainstate::coordinator::*;
-    use crate::chainstate::nakamoto::tests::node::TestSigners;
+    use crate::chainstate::nakamoto::tests::node::{TestSigners, TestStacker};
     use crate::chainstate::stacks::address::PoxAddress;
     use crate::chainstate::stacks::boot::test::get_parent_tip;
     use crate::chainstate::stacks::boot::*;
@@ -1928,6 +1928,7 @@ pub mod test {
         pub services: u16,
         /// aggregate public key to use
         pub aggregate_public_key: Option<Point>,
+        pub test_stackers: Option<Vec<TestStacker>>,
     }
 
     impl TestPeerConfig {
@@ -1992,6 +1993,7 @@ pub mod test {
                     | (ServiceFlags::RPC as u16)
                     | (ServiceFlags::STACKERDB as u16),
                 aggregate_public_key: None,
+                test_stackers: None,
             }
         }
 

From a7056048902f7bdb43b3bfc3816ae41a703bc4e6 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Tue, 23 Jan 2024 13:04:17 -0800
Subject: [PATCH 0482/1166] Move filtering of messages out ot stacks-signer
 into libsigner

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 Cargo.lock                                  |   1 +
 libsigner/Cargo.toml                        |   1 +
 libsigner/src/events.rs                     | 325 +++++++++++++++-----
 libsigner/src/libsigner.rs                  |   3 +-
 libsigner/src/tests/mod.rs                  |  74 +++--
 stacks-signer/src/client/stackerdb.rs       | 145 +--------
 stacks-signer/src/config.rs                 |   8 +
 stacks-signer/src/main.rs                   |  11 +-
 stacks-signer/src/runloop.rs                |  90 ++----
 stackslib/src/chainstate/stacks/boot/mod.rs |   1 +
 testnet/stacks-node/src/tests/signer.rs     |  23 +-
 11 files changed, 347 insertions(+), 335 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 393e918a76..10f8f4cbd9 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1971,6 +1971,7 @@ dependencies = [
 name = "libsigner"
 version = "0.0.1"
 dependencies = [
+ "bincode",
  "clarity",
  "libc",
  "libstackerdb",
diff --git a/libsigner/Cargo.toml b/libsigner/Cargo.toml
index ee7338ea17..d115a7475b 100644
--- a/libsigner/Cargo.toml
+++ b/libsigner/Cargo.toml
@@ -16,6 +16,7 @@ name = "libsigner"
 path = "./src/libsigner.rs"
 
 [dependencies]
+bincode = "1.3.3"
 clarity = { path = "../clarity" }
 libc = "0.2"
 libstackerdb = { path = "../libstackerdb" }
diff --git a/libsigner/src/events.rs b/libsigner/src/events.rs
index dde39a3f83..4e914e13da 100644
--- a/libsigner/src/events.rs
+++ b/libsigner/src/events.rs
@@ -21,9 +21,11 @@ use std::sync::mpsc::Sender;
 use std::sync::Arc;
 
 use blockstack_lib::chainstate::nakamoto::NakamotoBlock;
-use blockstack_lib::chainstate::stacks::boot::MINERS_NAME;
+use blockstack_lib::chainstate::stacks::boot::{MINERS_NAME, SIGNERS_NAME};
 use blockstack_lib::chainstate::stacks::events::StackerDBChunksEvent;
-use blockstack_lib::net::api::postblock_proposal::BlockValidateResponse;
+use blockstack_lib::net::api::postblock_proposal::{
+    BlockValidateReject, BlockValidateResponse, ValidateRejectCode,
+};
 use blockstack_lib::util_lib::boot::boot_code_id;
 use clarity::vm::types::QualifiedContractIdentifier;
 use serde::{Deserialize, Serialize};
@@ -38,13 +40,155 @@ use wsts::net::{Message, Packet};
 use crate::http::{decode_http_body, decode_http_request};
 use crate::EventError;
 
+/// Temporary placeholder for the number of slots allocated to a stacker-db writer. This will be retrieved from the stacker-db instance in the future
+/// See: https://github.com/stacks-network/stacks-blockchain/issues/3921
+/// Is equal to the number of message types
+pub const SIGNER_SLOTS_PER_USER: u32 = 11;
+
+// The slot IDS for each message type
+const DKG_BEGIN_SLOT_ID: u32 = 0;
+const DKG_PRIVATE_BEGIN_SLOT_ID: u32 = 1;
+const DKG_END_BEGIN_SLOT_ID: u32 = 2;
+const DKG_END_SLOT_ID: u32 = 3;
+const DKG_PUBLIC_SHARES_SLOT_ID: u32 = 4;
+const DKG_PRIVATE_SHARES_SLOT_ID: u32 = 5;
+const NONCE_REQUEST_SLOT_ID: u32 = 6;
+const NONCE_RESPONSE_SLOT_ID: u32 = 7;
+const SIGNATURE_SHARE_REQUEST_SLOT_ID: u32 = 8;
+const SIGNATURE_SHARE_RESPONSE_SLOT_ID: u32 = 9;
+/// The slot ID for the block response for miners to observe
+pub const BLOCK_SLOT_ID: u32 = 10;
+
+/// The messages being sent through the stacker db contracts
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum SignerMessage {
+    /// The signed/validated Nakamoto block for miners to observe
+    BlockResponse(BlockResponse),
+    /// DKG and Signing round data for other signers to observe
+    Packet(Packet),
+}
+
+/// The response that a signer sends back to observing miners
+/// either accepting or rejecting a Nakamoto block with the corresponding reason
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum BlockResponse {
+    /// The Nakamoto block was accepted and therefore signed
+    Accepted(NakamotoBlock),
+    /// The Nakamoto block was rejected and therefore not signed
+    Rejected(BlockRejection),
+}
+
+/// A rejection response from a signer for a proposed block
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BlockRejection {
+    /// The reason for the rejection
+    pub reason: String,
+    /// The reason code for the rejection
+    pub reason_code: RejectCode,
+    /// The block that was rejected
+    pub block: NakamotoBlock,
+}
+
+impl BlockRejection {
+    /// Create a new BlockRejection for the provided block and reason code
+    pub fn new(block: NakamotoBlock, reason_code: RejectCode) -> Self {
+        Self {
+            reason: reason_code.to_string(),
+            reason_code,
+            block,
+        }
+    }
+}
+
+impl From<BlockValidateReject> for BlockRejection {
+    fn from(reject: BlockValidateReject) -> Self {
+        Self {
+            reason: reject.reason,
+            reason_code: RejectCode::ValidationFailed(reject.reason_code),
+            block: reject.block,
+        }
+    }
+}
+
+/// This enum is used to supply a `reason_code` for block rejections
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[repr(u8)]
+pub enum RejectCode {
+    /// RPC endpoint Validation failed
+    ValidationFailed(ValidateRejectCode),
+    /// Signers signed a block rejection
+    SignedRejection,
+    /// Invalid signature hash
+    InvalidSignatureHash,
+}
+
+impl std::fmt::Display for RejectCode {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        match self {
+            RejectCode::ValidationFailed(code) => write!(f, "Validation failed: {:?}", code),
+            RejectCode::SignedRejection => {
+                write!(f, "A threshold number of signers rejected the block.")
+            }
+            RejectCode::InvalidSignatureHash => write!(f, "The signature hash was invalid."),
+        }
+    }
+}
+
+impl From<Packet> for SignerMessage {
+    fn from(packet: Packet) -> Self {
+        Self::Packet(packet)
+    }
+}
+
+impl From<BlockResponse> for SignerMessage {
+    fn from(block_response: BlockResponse) -> Self {
+        Self::BlockResponse(block_response)
+    }
+}
+
+impl From<BlockRejection> for SignerMessage {
+    fn from(block_rejection: BlockRejection) -> Self {
+        Self::BlockResponse(BlockResponse::Rejected(block_rejection))
+    }
+}
+
+impl From<BlockValidateReject> for SignerMessage {
+    fn from(rejection: BlockValidateReject) -> Self {
+        Self::BlockResponse(BlockResponse::Rejected(rejection.into()))
+    }
+}
+
+impl SignerMessage {
+    /// Helper function to determine the slot ID for the provided stacker-db writer id
+    pub fn slot_id(&self, id: u32) -> u32 {
+        let slot_id = match self {
+            Self::Packet(packet) => match packet.msg {
+                Message::DkgBegin(_) => DKG_BEGIN_SLOT_ID,
+                Message::DkgPrivateBegin(_) => DKG_PRIVATE_BEGIN_SLOT_ID,
+                Message::DkgEndBegin(_) => DKG_END_BEGIN_SLOT_ID,
+                Message::DkgEnd(_) => DKG_END_SLOT_ID,
+                Message::DkgPublicShares(_) => DKG_PUBLIC_SHARES_SLOT_ID,
+                Message::DkgPrivateShares(_) => DKG_PRIVATE_SHARES_SLOT_ID,
+                Message::NonceRequest(_) => NONCE_REQUEST_SLOT_ID,
+                Message::NonceResponse(_) => NONCE_RESPONSE_SLOT_ID,
+                Message::SignatureShareRequest(_) => SIGNATURE_SHARE_REQUEST_SLOT_ID,
+                Message::SignatureShareResponse(_) => SIGNATURE_SHARE_RESPONSE_SLOT_ID,
+            },
+            Self::BlockResponse(_) => BLOCK_SLOT_ID,
+        };
+        SIGNER_SLOTS_PER_USER * id + slot_id
+    }
+}
+
 /// Event enum for newly-arrived signer subscribed events
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub enum SignerEvent {
-    /// A new stackerDB chunk was received
-    StackerDB(StackerDBChunksEvent),
-    /// A new block proposal was received
-    BlockProposal(BlockValidateResponse),
+    /// The miner proposed blocks for signers to observe and sign
+    ProposedBlocks(Vec<NakamotoBlock>),
+    /// The signer messages for other signers and miners to observe
+    SignerMessages(Vec<SignerMessage>),
+    /// A new block proposal validation response from the node
+    BlockValidationResponse(BlockValidateResponse),
 }
 
 /// Trait to implement a stop-signaler for the event receiver thread.
@@ -55,7 +199,7 @@ pub trait EventStopSignaler {
     fn send(&mut self);
 }
 
-/// Trait to implement to handle StackerDB and BlockProposal events sent by the Stacks node
+/// Trait to implement to handle signer specific events sent by the Stacks node
 pub trait EventReceiver {
     /// The implementation of ST will ensure that a call to ST::send() will cause
     /// the call to `is_stopped()` below to return true.
@@ -120,25 +264,31 @@ pub struct SignerEventReceiver {
     out_channels: Vec<Sender<SignerEvent>>,
     /// inter-thread stop variable -- if set to true, then the `main_loop` will exit
     stop_signal: Arc<AtomicBool>,
+    /// Whether the receiver is running on mainnet
+    is_mainnet: bool,
 }
 
 impl SignerEventReceiver {
     /// Make a new Signer event receiver, and return both the receiver and the read end of a
     /// channel into which node-received data can be obtained.
-    pub fn new(contract_ids: Vec<QualifiedContractIdentifier>) -> SignerEventReceiver {
+    pub fn new(
+        contract_ids: Vec<QualifiedContractIdentifier>,
+        is_mainnet: bool,
+    ) -> SignerEventReceiver {
         SignerEventReceiver {
             stackerdb_contract_ids: contract_ids,
             http_server: None,
             local_addr: None,
             out_channels: vec![],
             stop_signal: Arc::new(AtomicBool::new(false)),
+            is_mainnet,
         }
     }
 
     /// Do something with the socket
     pub fn with_server<F, R>(&mut self, todo: F) -> Result<R, EventError>
     where
-        F: FnOnce(&SignerEventReceiver, &mut HttpServer, &[QualifiedContractIdentifier]) -> R,
+        F: FnOnce(&SignerEventReceiver, &mut HttpServer, bool) -> R,
     {
         let mut server = if let Some(s) = self.http_server.take() {
             s
@@ -146,7 +296,7 @@ impl SignerEventReceiver {
             return Err(EventError::NotBound);
         };
 
-        let res = todo(self, &mut server, &self.stackerdb_contract_ids);
+        let res = todo(self, &mut server, self.is_mainnet);
 
         self.http_server = Some(server);
         Ok(res)
@@ -203,14 +353,12 @@ impl EventReceiver for SignerEventReceiver {
     /// Errors are recoverable -- the caller should call this method again even if it returns an
     /// error.
     fn next_event(&mut self) -> Result<SignerEvent, EventError> {
-        self.with_server(|event_receiver, http_server, contract_ids| {
-            let mut request = http_server.recv()?;
-
+        self.with_server(|event_receiver, http_server, is_mainnet| {
             // were we asked to terminate?
             if event_receiver.is_stopped() {
                 return Err(EventError::Terminated);
             }
-
+            let request = http_server.recv()?;
             if request.method() != &HttpMethod::Post {
                 return Err(EventError::MalformedRequest(format!(
                     "Unrecognized method '{}'",
@@ -218,71 +366,9 @@ impl EventReceiver for SignerEventReceiver {
                 )));
             }
             if request.url() == "/stackerdb_chunks" {
-                debug!("Got stackerdb_chunks event");
-                let mut body = String::new();
-                if let Err(e) = request
-                    .as_reader()
-                    .read_to_string(&mut body) {
-                    error!("Failed to read body: {:?}", &e);
-
-                    request
-                        .respond(HttpResponse::empty(200u16))
-                        .expect("response failed");
-                    return Err(EventError::MalformedRequest(format!(
-                        "Failed to read body: {:?}",
-                        &e
-                    )));
-                    }
-
-                let event: StackerDBChunksEvent =
-                    serde_json::from_slice(body.as_bytes()).map_err(|e| {
-                        EventError::Deserialize(format!("Could not decode body to JSON: {:?}", &e))
-                    })?;
-
-                if !contract_ids.contains(&event.contract_id) {
-                    info!(
-                        "[{:?}] next_event got event from an unexpected contract id {}, return OK so other side doesn't keep sending this",
-                        event_receiver.local_addr,
-                        event.contract_id
-                    );
-                    request
-                        .respond(HttpResponse::empty(200u16))
-                        .expect("response failed");
-                    return Err(EventError::UnrecognizedStackerDBContract(event.contract_id));
-                }
-
-                request
-                    .respond(HttpResponse::empty(200u16))
-                    .expect("response failed");
-
-                Ok(SignerEvent::StackerDB(event))
+                process_stackerdb_event(event_receiver.local_addr, request, is_mainnet)
             } else if request.url() == "/proposal_response" {
-                debug!("Got proposal_response event");
-                let mut body = String::new();
-                if let Err(e) = request
-                    .as_reader()
-                    .read_to_string(&mut body) {
-                    error!("Failed to read body: {:?}", &e);
-
-                    request
-                        .respond(HttpResponse::empty(200u16))
-                        .expect("response failed");
-                    return Err(EventError::MalformedRequest(format!(
-                        "Failed to read body: {:?}",
-                        &e
-                    )));
-                    }
-
-                let event: BlockValidateResponse =
-                    serde_json::from_slice(body.as_bytes()).map_err(|e| {
-                        EventError::Deserialize(format!("Could not decode body to JSON: {:?}", &e))
-                    })?;
-
-                request
-                    .respond(HttpResponse::empty(200u16))
-                    .expect("response failed");
-
-                Ok(SignerEvent::BlockProposal(event))
+                process_proposal_response(request)
             } else {
                 let url = request.url().to_string();
 
@@ -349,3 +435,86 @@ impl EventReceiver for SignerEventReceiver {
         }
     }
 }
+
+/// Process a stackerdb event from the node
+fn process_stackerdb_event(
+    local_addr: Option<SocketAddr>,
+    mut request: HttpRequest,
+    is_mainnet: bool,
+) -> Result<SignerEvent, EventError> {
+    debug!("Got stackerdb_chunks event");
+    let mut body = String::new();
+    if let Err(e) = request.as_reader().read_to_string(&mut body) {
+        error!("Failed to read body: {:?}", &e);
+
+        request
+            .respond(HttpResponse::empty(200u16))
+            .expect("response failed");
+        return Err(EventError::MalformedRequest(format!(
+            "Failed to read body: {:?}",
+            &e
+        )));
+    }
+
+    let event: StackerDBChunksEvent = serde_json::from_slice(body.as_bytes())
+        .map_err(|e| EventError::Deserialize(format!("Could not decode body to JSON: {:?}", &e)))?;
+
+    let signer_event = if event.contract_id == boot_code_id(MINERS_NAME, is_mainnet) {
+        let blocks: Vec<NakamotoBlock> = event
+            .modified_slots
+            .iter()
+            .filter_map(|chunk| read_next::<NakamotoBlock, _>(&mut &chunk.data[..]).ok())
+            .collect();
+        SignerEvent::ProposedBlocks(blocks)
+    } else if event.contract_id.name.to_string() == SIGNERS_NAME {
+        // TODO: fix this to be against boot_code_id(SIGNERS_NAME, is_mainnet) when .signers is deployed
+        let signer_messages: Vec<SignerMessage> = event
+            .modified_slots
+            .iter()
+            .filter_map(|chunk| bincode::deserialize::<SignerMessage>(&chunk.data).ok())
+            .collect();
+        SignerEvent::SignerMessages(signer_messages)
+    } else {
+        info!(
+            "[{:?}] next_event got event from an unexpected contract id {}, return OK so other side doesn't keep sending this",
+            local_addr,
+            event.contract_id
+        );
+        request
+            .respond(HttpResponse::empty(200u16))
+            .expect("response failed");
+        return Err(EventError::UnrecognizedStackerDBContract(event.contract_id));
+    };
+
+    request
+        .respond(HttpResponse::empty(200u16))
+        .expect("response failed");
+
+    Ok(signer_event)
+}
+
+/// Process a proposal response from the node
+fn process_proposal_response(mut request: HttpRequest) -> Result<SignerEvent, EventError> {
+    debug!("Got proposal_response event");
+    let mut body = String::new();
+    if let Err(e) = request.as_reader().read_to_string(&mut body) {
+        error!("Failed to read body: {:?}", &e);
+
+        request
+            .respond(HttpResponse::empty(200u16))
+            .expect("response failed");
+        return Err(EventError::MalformedRequest(format!(
+            "Failed to read body: {:?}",
+            &e
+        )));
+    }
+
+    let event: BlockValidateResponse = serde_json::from_slice(body.as_bytes())
+        .map_err(|e| EventError::Deserialize(format!("Could not decode body to JSON: {:?}", &e)))?;
+
+    request
+        .respond(HttpResponse::empty(200u16))
+        .expect("response failed");
+
+    Ok(SignerEvent::BlockValidationResponse(event))
+}
diff --git a/libsigner/src/libsigner.rs b/libsigner/src/libsigner.rs
index b7f983f8c3..8b10b3fafb 100644
--- a/libsigner/src/libsigner.rs
+++ b/libsigner/src/libsigner.rs
@@ -44,7 +44,8 @@ mod session;
 
 pub use crate::error::{EventError, RPCError};
 pub use crate::events::{
-    EventReceiver, EventStopSignaler, SignerEvent, SignerEventReceiver, SignerStopSignaler,
+    BlockRejection, BlockResponse, EventReceiver, EventStopSignaler, RejectCode, SignerEvent,
+    SignerEventReceiver, SignerMessage, SignerStopSignaler, BLOCK_SLOT_ID, SIGNER_SLOTS_PER_USER,
 };
 pub use crate::runloop::{RunningSigner, Signer, SignerRunLoop};
 pub use crate::session::{SignerSession, StackerDBSession};
diff --git a/libsigner/src/tests/mod.rs b/libsigner/src/tests/mod.rs
index 0048b7435c..deefc1018f 100644
--- a/libsigner/src/tests/mod.rs
+++ b/libsigner/src/tests/mod.rs
@@ -22,13 +22,16 @@ use std::sync::mpsc::{channel, Receiver, Sender};
 use std::time::Duration;
 use std::{mem, thread};
 
+use blockstack_lib::chainstate::stacks::boot::SIGNERS_NAME;
 use blockstack_lib::chainstate::stacks::events::StackerDBChunksEvent;
+use blockstack_lib::util_lib::boot::boot_code_id;
 use clarity::vm::types::QualifiedContractIdentifier;
 use libstackerdb::StackerDBChunkData;
 use stacks_common::util::secp256k1::Secp256k1PrivateKey;
 use stacks_common::util::sleep_ms;
+use wsts::net::{DkgBegin, Packet};
 
-use crate::events::SignerEvent;
+use crate::events::{SignerEvent, SignerMessage};
 use crate::{Signer, SignerEventReceiver, SignerRunLoop};
 
 /// Simple runloop implementation.  It receives `max_events` events and returns `events` from the
@@ -87,28 +90,27 @@ impl SignerRunLoop<Vec<SignerEvent>, Command> for SimpleRunLoop {
 /// and the signer runloop.
 #[test]
 fn test_simple_signer() {
-    let ev = SignerEventReceiver::new(vec![QualifiedContractIdentifier::parse(
-        "ST2DS4MSWSGJ3W9FBC6BVT0Y92S345HY8N3T6AV7R.hello-world",
-    )
-    .unwrap()]);
+    let contract_id =
+        QualifiedContractIdentifier::parse("ST2DS4MSWSGJ3W9FBC6BVT0Y92S345HY8N3T6AV7R.signers")
+            .unwrap(); // TODO: change to boot_code_id(SIGNERS_NAME, false) when .signers is deployed
+    let ev = SignerEventReceiver::new(vec![contract_id.clone()], false);
     let (_cmd_send, cmd_recv) = channel();
     let (res_send, _res_recv) = channel();
     let mut signer = Signer::new(SimpleRunLoop::new(5), ev, cmd_recv, res_send);
     let endpoint: SocketAddr = "127.0.0.1:30000".parse().unwrap();
-
     let mut chunks = vec![];
     for i in 0..5 {
         let privk = Secp256k1PrivateKey::new();
-        let mut chunk = StackerDBChunkData::new(i as u32, 1, "hello world".as_bytes().to_vec());
+        let msg = wsts::net::Message::DkgBegin(DkgBegin { dkg_id: 0 });
+        let message = SignerMessage::Packet(Packet { msg, sig: vec![] });
+        let message_bytes = bincode::serialize(&message).unwrap();
+        let mut chunk = StackerDBChunkData::new(i as u32, 1, message_bytes);
         chunk.sign(&privk).unwrap();
 
-        let chunk_event = SignerEvent::StackerDB(StackerDBChunksEvent {
-            contract_id: QualifiedContractIdentifier::parse(
-                "ST2DS4MSWSGJ3W9FBC6BVT0Y92S345HY8N3T6AV7R.hello-world",
-            )
-            .unwrap(),
+        let chunk_event = StackerDBChunksEvent {
+            contract_id: contract_id.clone(),
             modified_slots: vec![chunk],
-        });
+        };
         chunks.push(chunk_event);
     }
 
@@ -126,42 +128,38 @@ fn test_simple_signer() {
                 }
             };
 
-            match &thread_chunks[num_sent] {
-                SignerEvent::StackerDB(ev) => {
-                    let body = serde_json::to_string(ev).unwrap();
-                    let req = format!("POST /stackerdb_chunks HTTP/1.0\r\nConnection: close\r\nContent-Length: {}\r\n\r\n{}", &body.len(), body);
-                    debug!("Send:\n{}", &req);
+            let ev = &thread_chunks[num_sent];
+            let body = serde_json::to_string(ev).unwrap();
+            let req = format!("POST /stackerdb_chunks HTTP/1.0\r\nConnection: close\r\nContent-Length: {}\r\n\r\n{}", &body.len(), body);
+            debug!("Send:\n{}", &req);
 
-                    sock.write_all(req.as_bytes()).unwrap();
-                    sock.flush().unwrap();
+            sock.write_all(req.as_bytes()).unwrap();
+            sock.flush().unwrap();
 
-                    num_sent += 1;
-                }
-                _ => panic!("Unexpected event type"),
-            }
+            num_sent += 1;
         }
     });
 
     let running_signer = signer.spawn(endpoint).unwrap();
     sleep_ms(5000);
-    let mut accepted_events = running_signer.stop().unwrap();
+    let accepted_events = running_signer.stop().unwrap();
 
-    chunks.sort_by(|ev1, ev2| match (ev1, ev2) {
-        (SignerEvent::StackerDB(ev1), SignerEvent::StackerDB(ev2)) => ev1.modified_slots[0]
-            .slot_id
-            .partial_cmp(&ev2.modified_slots[0].slot_id)
-            .unwrap(),
-        _ => panic!("Unexpected event type"),
-    });
-    accepted_events.sort_by(|ev1, ev2| match (ev1, ev2) {
-        (SignerEvent::StackerDB(ev1), SignerEvent::StackerDB(ev2)) => ev1.modified_slots[0]
+    chunks.sort_by(|ev1, ev2| {
+        ev1.modified_slots[0]
             .slot_id
             .partial_cmp(&ev2.modified_slots[0].slot_id)
-            .unwrap(),
-        _ => panic!("Unexpected event type"),
+            .unwrap()
     });
 
-    // runloop got the event that the mocked stacks node sent
-    assert_eq!(accepted_events, chunks);
+    let sent_events: Vec<SignerEvent> = chunks
+        .iter()
+        .map(|chunk| {
+            let msg = chunk.modified_slots[0].data.clone();
+            let signer_message: SignerMessage = bincode::deserialize(&msg).unwrap();
+            SignerEvent::SignerMessages(vec![signer_message])
+        })
+        .collect();
+
+    assert_eq!(sent_events, accepted_events);
     mock_stacks_node.join().unwrap();
 }
diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index 431c772e50..e5bdfd09f1 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -13,161 +13,18 @@
 //
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
-use blockstack_lib::chainstate::nakamoto::NakamotoBlock;
-use blockstack_lib::net::api::postblock_proposal::{BlockValidateReject, ValidateRejectCode};
 use clarity::vm::types::QualifiedContractIdentifier;
 use hashbrown::HashMap;
-use libsigner::{SignerSession, StackerDBSession};
+use libsigner::{SignerMessage, SignerSession, StackerDBSession};
 use libstackerdb::{StackerDBChunkAckData, StackerDBChunkData};
-use serde_derive::{Deserialize, Serialize};
 use slog::{slog_debug, slog_warn};
 use stacks_common::types::chainstate::StacksPrivateKey;
 use stacks_common::{debug, warn};
-use wsts::net::{Message, Packet};
 
 use super::ClientError;
 use crate::client::retry_with_exponential_backoff;
 use crate::config::Config;
 
-/// Temporary placeholder for the number of slots allocated to a stacker-db writer. This will be retrieved from the stacker-db instance in the future
-/// See: https://github.com/stacks-network/stacks-blockchain/issues/3921
-/// Is equal to the number of message types
-pub const SIGNER_SLOTS_PER_USER: u32 = 11;
-
-// The slot IDS for each message type
-const DKG_BEGIN_SLOT_ID: u32 = 0;
-const DKG_PRIVATE_BEGIN_SLOT_ID: u32 = 1;
-const DKG_END_BEGIN_SLOT_ID: u32 = 2;
-const DKG_END_SLOT_ID: u32 = 3;
-const DKG_PUBLIC_SHARES_SLOT_ID: u32 = 4;
-const DKG_PRIVATE_SHARES_SLOT_ID: u32 = 5;
-const NONCE_REQUEST_SLOT_ID: u32 = 6;
-const NONCE_RESPONSE_SLOT_ID: u32 = 7;
-const SIGNATURE_SHARE_REQUEST_SLOT_ID: u32 = 8;
-const SIGNATURE_SHARE_RESPONSE_SLOT_ID: u32 = 9;
-const BLOCK_SLOT_ID: u32 = 10;
-
-/// The messages being sent through the stacker db contracts
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub enum SignerMessage {
-    /// The signed/validated Nakamoto block for miners to observe
-    BlockResponse(BlockResponse),
-    /// DKG and Signing round data for other signers to observe
-    Packet(Packet),
-}
-
-/// The response that a signer sends back to observing miners
-/// either accepting or rejecting a Nakamoto block with the corresponding reason
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub enum BlockResponse {
-    /// The Nakamoto block was accepted and therefore signed
-    Accepted(NakamotoBlock),
-    /// The Nakamoto block was rejected and therefore not signed
-    Rejected(BlockRejection),
-}
-
-/// A rejection response from a signer for a proposed block
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct BlockRejection {
-    /// The reason for the rejection
-    pub reason: String,
-    /// The reason code for the rejection
-    pub reason_code: RejectCode,
-    /// The block that was rejected
-    pub block: NakamotoBlock,
-}
-
-impl BlockRejection {
-    /// Create a new BlockRejection for the provided block and reason code
-    pub fn new(block: NakamotoBlock, reason_code: RejectCode) -> Self {
-        Self {
-            reason: reason_code.to_string(),
-            reason_code,
-            block,
-        }
-    }
-}
-
-impl From<BlockValidateReject> for BlockRejection {
-    fn from(reject: BlockValidateReject) -> Self {
-        Self {
-            reason: reject.reason,
-            reason_code: RejectCode::ValidationFailed(reject.reason_code),
-            block: reject.block,
-        }
-    }
-}
-
-/// This enum is used to supply a `reason_code` for block rejections
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[repr(u8)]
-pub enum RejectCode {
-    /// RPC endpoint Validation failed
-    ValidationFailed(ValidateRejectCode),
-    /// Signers signed a block rejection
-    SignedRejection,
-    /// Invalid signature hash
-    InvalidSignatureHash,
-}
-
-impl std::fmt::Display for RejectCode {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        match self {
-            RejectCode::ValidationFailed(code) => write!(f, "Validation failed: {:?}", code),
-            RejectCode::SignedRejection => {
-                write!(f, "A threshold number of signers rejected the block.")
-            }
-            RejectCode::InvalidSignatureHash => write!(f, "The signature hash was invalid."),
-        }
-    }
-}
-
-impl From<Packet> for SignerMessage {
-    fn from(packet: Packet) -> Self {
-        Self::Packet(packet)
-    }
-}
-
-impl From<BlockResponse> for SignerMessage {
-    fn from(block_response: BlockResponse) -> Self {
-        Self::BlockResponse(block_response)
-    }
-}
-
-impl From<BlockRejection> for SignerMessage {
-    fn from(block_rejection: BlockRejection) -> Self {
-        Self::BlockResponse(BlockResponse::Rejected(block_rejection))
-    }
-}
-
-impl From<BlockValidateReject> for SignerMessage {
-    fn from(rejection: BlockValidateReject) -> Self {
-        Self::BlockResponse(BlockResponse::Rejected(rejection.into()))
-    }
-}
-
-impl SignerMessage {
-    /// Helper function to determine the slot ID for the provided stacker-db writer id
-    pub fn slot_id(&self, id: u32) -> u32 {
-        let slot_id = match self {
-            Self::Packet(packet) => match packet.msg {
-                Message::DkgBegin(_) => DKG_BEGIN_SLOT_ID,
-                Message::DkgPrivateBegin(_) => DKG_PRIVATE_BEGIN_SLOT_ID,
-                Message::DkgEndBegin(_) => DKG_END_BEGIN_SLOT_ID,
-                Message::DkgEnd(_) => DKG_END_SLOT_ID,
-                Message::DkgPublicShares(_) => DKG_PUBLIC_SHARES_SLOT_ID,
-                Message::DkgPrivateShares(_) => DKG_PRIVATE_SHARES_SLOT_ID,
-                Message::NonceRequest(_) => NONCE_REQUEST_SLOT_ID,
-                Message::NonceResponse(_) => NONCE_RESPONSE_SLOT_ID,
-                Message::SignatureShareRequest(_) => SIGNATURE_SHARE_REQUEST_SLOT_ID,
-                Message::SignatureShareResponse(_) => SIGNATURE_SHARE_RESPONSE_SLOT_ID,
-            },
-            Self::BlockResponse(_) => BLOCK_SLOT_ID,
-        };
-        SIGNER_SLOTS_PER_USER * id + slot_id
-    }
-}
-
 /// The StackerDB client for communicating with the .signers contract
 pub struct StackerDB {
     /// The stacker-db session for the signer StackerDB
diff --git a/stacks-signer/src/config.rs b/stacks-signer/src/config.rs
index 58774b770e..c9d086df32 100644
--- a/stacks-signer/src/config.rs
+++ b/stacks-signer/src/config.rs
@@ -91,6 +91,14 @@ impl Network {
             Self::Testnet | Self::Mocknet => TransactionVersion::Testnet,
         }
     }
+
+    /// Check if the network is Mainnet or not
+    pub fn is_mainnet(&self) -> bool {
+        match self {
+            Self::Mainnet => true,
+            Self::Testnet | Self::Mocknet => false,
+        }
+    }
 }
 
 /// The parsed configuration for the signer
diff --git a/stacks-signer/src/main.rs b/stacks-signer/src/main.rs
index 4fadef2797..99bfb31d01 100644
--- a/stacks-signer/src/main.rs
+++ b/stacks-signer/src/main.rs
@@ -36,7 +36,10 @@ use std::time::Duration;
 use blockstack_lib::chainstate::nakamoto::NakamotoBlock;
 use clap::Parser;
 use clarity::vm::types::QualifiedContractIdentifier;
-use libsigner::{RunningSigner, Signer, SignerEventReceiver, SignerSession, StackerDBSession};
+use libsigner::{
+    RunningSigner, Signer, SignerEventReceiver, SignerSession, StackerDBSession,
+    SIGNER_SLOTS_PER_USER,
+};
 use libstackerdb::StackerDBChunkData;
 use slog::{slog_debug, slog_error};
 use stacks_common::address::{
@@ -49,7 +52,6 @@ use stacks_signer::cli::{
     Cli, Command, GenerateFilesArgs, GetChunkArgs, GetLatestChunkArgs, PutChunkArgs, RunDkgArgs,
     SignArgs, StackerDBArgs,
 };
-use stacks_signer::client::SIGNER_SLOTS_PER_USER;
 use stacks_signer::config::{Config, Network};
 use stacks_signer::runloop::{RunLoop, RunLoopCommand};
 use stacks_signer::utils::{build_signer_config_tomls, build_stackerdb_contract};
@@ -90,7 +92,10 @@ fn spawn_running_signer(path: &PathBuf) -> SpawnedSigner {
     let config = Config::try_from(path).unwrap();
     let (cmd_send, cmd_recv) = channel();
     let (res_send, res_recv) = channel();
-    let ev = SignerEventReceiver::new(vec![config.stackerdb_contract_id.clone()]);
+    let ev = SignerEventReceiver::new(
+        vec![config.stackerdb_contract_id.clone()],
+        config.network.is_mainnet(),
+    );
     let runloop: RunLoop<FireCoordinator<v2::Aggregator>> = RunLoop::from(&config);
     let mut signer: Signer<
         RunLoopCommand,
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 2465b57532..e7b7ae008c 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -19,14 +19,12 @@ use std::time::Duration;
 
 use blockstack_lib::burnchains::Txid;
 use blockstack_lib::chainstate::nakamoto::NakamotoBlock;
-use blockstack_lib::chainstate::stacks::boot::MINERS_NAME;
-use blockstack_lib::chainstate::stacks::events::StackerDBChunksEvent;
 use blockstack_lib::chainstate::stacks::ThresholdSignature;
 use blockstack_lib::net::api::postblock_proposal::BlockValidateResponse;
-use blockstack_lib::util_lib::boot::boot_code_id;
 use hashbrown::{HashMap, HashSet};
-use libsigner::{SignerEvent, SignerRunLoop};
-use libstackerdb::StackerDBChunkData;
+use libsigner::{
+    BlockRejection, BlockResponse, RejectCode, SignerEvent, SignerMessage, SignerRunLoop,
+};
 use slog::{slog_debug, slog_error, slog_info, slog_warn};
 use stacks_common::codec::{read_next, StacksMessageCodec};
 use stacks_common::util::hash::{Sha256Sum, Sha512Trunc256Sum};
@@ -41,10 +39,7 @@ use wsts::state_machine::signer::Signer;
 use wsts::state_machine::{OperationResult, PublicKeys};
 use wsts::v2;
 
-use crate::client::{
-    retry_with_exponential_backoff, BlockRejection, BlockResponse, ClientError, RejectCode,
-    SignerMessage, StackerDB, StacksClient,
-};
+use crate::client::{retry_with_exponential_backoff, ClientError, StackerDB, StacksClient};
 use crate::config::{Config, Network};
 
 /// Which operation to perform
@@ -328,40 +323,31 @@ impl<C: Coordinator> RunLoop<C> {
         }
     }
 
-    /// Handle the stackerdb chunk event as a signer message
-    fn handle_stackerdb_chunk_event_signers(
+    /// Handle signer messages submitted to signers stackerdb
+    fn handle_signer_messages(
         &mut self,
-        stackerdb_chunk_event: StackerDBChunksEvent,
         res: Sender<Vec<OperationResult>>,
+        messages: Vec<SignerMessage>,
     ) {
         let (_coordinator_id, coordinator_public_key) =
             calculate_coordinator(&self.signing_round.public_keys, &self.stacks_client);
-
-        let inbound_packets: Vec<Packet> = stackerdb_chunk_event
-            .modified_slots
-            .iter()
-            .filter_map(|chunk| self.verify_chunk(chunk, &coordinator_public_key))
+        let packets: Vec<Packet> = messages
+            .into_iter()
+            .filter_map(|msg| match msg {
+                SignerMessage::BlockResponse(_) => None,
+                SignerMessage::Packet(packet) => {
+                    self.verify_packet(packet, &coordinator_public_key)
+                }
+            })
             .collect();
-        self.handle_packets(res, &inbound_packets);
+        self.handle_packets(res, &packets);
     }
 
-    /// Handle the stackerdb chunk event as a miner message
-    fn handle_stackerdb_chunk_event_miners(&mut self, stackerdb_chunk_event: StackerDBChunksEvent) {
-        for chunk in &stackerdb_chunk_event.modified_slots {
-            let Some(block) = read_next::<NakamotoBlock, _>(&mut &chunk.data[..]).ok() else {
-                warn!("Received an unrecognized message type from .miners stacker-db slot id {}: {:?}", chunk.slot_id, chunk.data);
-                continue;
-            };
+    /// Handle proposed blocks submitted by the miners to stackerdb
+    fn handle_proposed_blocks(&mut self, blocks: Vec<NakamotoBlock>) {
+        for block in blocks {
             let Ok(hash) = block.header.signature_hash() else {
-                warn!("Received a block proposal with an invalid signature hash. Broadcasting a block rejection...");
-                let block_rejection = BlockRejection::new(block, RejectCode::InvalidSignatureHash);
-                // Submit signature result to miners to observe
-                if let Err(e) = self
-                    .stackerdb
-                    .send_message_with_retry(self.signing_round.signer_id, block_rejection.into())
-                {
-                    warn!("Failed to send block submission to stacker-db: {:?}", e);
-                }
+                self.broadcast_signature_hash_rejection(block);
                 continue;
             };
             // Store the block in our cache
@@ -517,17 +503,12 @@ impl<C: Coordinator> RunLoop<C> {
     /// and SignatureShareRequests with a different message than what the coordinator originally sent.
     /// This is done to prevent a malicious coordinator from sending a different message than what was
     /// agreed upon and to support the case where the signer wishes to reject a block by voting no
-    fn verify_chunk(
+    fn verify_packet(
         &mut self,
-        chunk: &StackerDBChunkData,
+        mut packet: Packet,
         coordinator_public_key: &PublicKey,
     ) -> Option<Packet> {
-        // We only care about verified wsts packets. Ignore anything else
-        let signer_message = bincode::deserialize::<SignerMessage>(&chunk.data).ok()?;
-        let mut packet = match signer_message {
-            SignerMessage::Packet(packet) => packet,
-            _ => return None, // This is a message for miners to observe. Ignore it.
-        };
+        // We only care about verified wsts packets. Ignore anything else.
         if packet.verify(&self.signing_round.public_keys, coordinator_public_key) {
             match &mut packet.msg {
                 Message::SignatureShareRequest(request) => {
@@ -764,26 +745,17 @@ impl<C: Coordinator> SignerRunLoop<Vec<OperationResult>, RunLoopCommand> for Run
         // Process any arrived events
         debug!("Processing event: {:?}", event);
         match event {
-            Some(SignerEvent::BlockProposal(block_validate_response)) => {
+            Some(SignerEvent::BlockValidationResponse(block_validate_response)) => {
                 debug!("Received a block proposal result from the stacks node...");
                 self.handle_block_validate_response(block_validate_response, res)
             }
-            Some(SignerEvent::StackerDB(stackerdb_chunk_event)) => {
-                if stackerdb_chunk_event.contract_id == *self.stackerdb.signers_contract_id() {
-                    debug!("Received a StackerDB event for the .signers contract...");
-                    self.handle_stackerdb_chunk_event_signers(stackerdb_chunk_event, res);
-                } else if stackerdb_chunk_event.contract_id
-                    == boot_code_id(MINERS_NAME, self.mainnet)
-                {
-                    debug!("Received a StackerDB event for the .miners contract...");
-                    self.handle_stackerdb_chunk_event_miners(stackerdb_chunk_event);
-                } else {
-                    // Ignore non miner or signer messages
-                    debug!(
-                                "Received a StackerDB event for an unrecognized contract id: {:?}. Ignoring...",
-                                stackerdb_chunk_event.contract_id
-                            );
-                }
+            Some(SignerEvent::SignerMessages(messages)) => {
+                debug!("Received messages from the other signers...");
+                self.handle_signer_messages(res, messages);
+            }
+            Some(SignerEvent::ProposedBlocks(blocks)) => {
+                debug!("Received block proposals from the miners...");
+                self.handle_proposed_blocks(blocks);
             }
             None => {
                 // No event. Do nothing.
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index da7c97634d..47042478af 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -88,6 +88,7 @@ pub const BOOT_TEST_POX_4_AGG_KEY_CONTRACT: &'static str = "pox-4-agg-test-boote
 pub const BOOT_TEST_POX_4_AGG_KEY_FNAME: &'static str = "aggregate-key";
 
 pub const MINERS_NAME: &'static str = "miners";
+pub const SIGNERS_NAME: &'static str = "signers";
 
 pub mod docs;
 
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index 0a2c78af71..a62b53985e 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -6,20 +6,21 @@ use std::time::{Duration, Instant};
 use std::{env, thread};
 
 use clarity::vm::types::QualifiedContractIdentifier;
-use libsigner::{RunningSigner, Signer, SignerEventReceiver};
+use libsigner::{
+    BlockResponse, RunningSigner, Signer, SignerEventReceiver, SignerMessage, BLOCK_SLOT_ID,
+    SIGNER_SLOTS_PER_USER,
+};
 use stacks::chainstate::coordinator::comm::CoordinatorChannels;
 use stacks::chainstate::nakamoto::{NakamotoBlock, NakamotoBlockHeader};
-use stacks::chainstate::stacks::boot::MINERS_NAME;
 use stacks::chainstate::stacks::{StacksPrivateKey, ThresholdSignature};
 use stacks::net::api::postblock_proposal::BlockValidateResponse;
-use stacks::util_lib::boot::boot_code_id;
 use stacks_common::types::chainstate::{
     ConsensusHash, StacksAddress, StacksBlockId, StacksPublicKey, TrieHash,
 };
 use stacks_common::util::hash::{MerkleTree, Sha512Trunc256Sum};
 use stacks_common::util::secp256k1::MessageSignature;
-use stacks_signer::client::{BlockResponse, SignerMessage, StacksClient, SIGNER_SLOTS_PER_USER};
-use stacks_signer::config::{Config as SignerConfig, Network};
+use stacks_signer::client::StacksClient;
+use stacks_signer::config::Config as SignerConfig;
 use stacks_signer::runloop::{calculate_coordinator, RunLoopCommand};
 use stacks_signer::utils::{build_signer_config_tomls, build_stackerdb_contract};
 use tracing_subscriber::prelude::*;
@@ -63,7 +64,7 @@ struct SignerTest {
     // The channel for sending commands to the coordinator
     pub coordinator_cmd_sender: Sender<RunLoopCommand>,
     // The channels for sending commands to the signers
-    pub signer_cmd_senders: HashMap<u32, Sender<RunLoopCommand>>,
+    pub _signer_cmd_senders: HashMap<u32, Sender<RunLoopCommand>>,
     // The channels for receiving results from both the coordinator and the signers
     pub result_receivers: Vec<Receiver<Vec<OperationResult>>>,
     // The running coordinator and its threads
@@ -152,7 +153,7 @@ impl SignerTest {
         Self {
             running_nodes: node,
             result_receivers,
-            signer_cmd_senders,
+            _signer_cmd_senders: signer_cmd_senders,
             coordinator_cmd_sender,
             running_coordinator,
             running_signers,
@@ -186,10 +187,8 @@ fn spawn_signer(
     sender: Sender<Vec<OperationResult>>,
 ) -> RunningSigner<SignerEventReceiver, Vec<OperationResult>> {
     let config = stacks_signer::config::Config::load_from_str(data).unwrap();
-    let ev = SignerEventReceiver::new(vec![
-        boot_code_id(MINERS_NAME, config.network == Network::Mainnet),
-        config.stackerdb_contract_id.clone(),
-    ]);
+    let is_mainnet = config.network.is_mainnet();
+    let ev = SignerEventReceiver::new(vec![config.stackerdb_contract_id.clone()], is_mainnet);
     let runloop: stacks_signer::runloop::RunLoop<FireCoordinator<v2::Aggregator>> =
         stacks_signer::runloop::RunLoop::from(&config);
     let mut signer: Signer<
@@ -666,7 +665,7 @@ fn stackerdb_block_proposal() {
         for event in nakamoto_blocks {
             // The tenth slot is the miners block slot
             for slot in event.modified_slots {
-                if slot.slot_id == 10 {
+                if slot.slot_id == BLOCK_SLOT_ID {
                     chunk = Some(slot.data);
                     break;
                 }

From 100dd71fcba2bb7b0b44368218fa89dacea1ce0e Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Thu, 25 Jan 2024 12:19:03 -0600
Subject: [PATCH 0483/1166] feat: remove signing-key from stacking-state,
 partial-stacked-stx, fix tests

---
 stackslib/src/chainstate/nakamoto/mod.rs      |  45 +--
 .../src/chainstate/stacks/boot/pox-4.clar     |  72 ++---
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 278 ++++++++++--------
 .../chainstate/stacks/boot/signers_tests.rs   |  46 ---
 4 files changed, 211 insertions(+), 230 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index 56c9fad9a9..0575f0c331 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -1916,7 +1916,7 @@ impl NakamotoChainState {
 
         let liquid_ustx = clarity.with_clarity_db_readonly(|db| db.get_total_liquid_ustx());
         let reward_slots = Self::get_reward_slots(clarity, reward_cycle, pox_contract)?;
-        let (threshold, _participation) = StacksChainState::get_reward_threshold_and_participation(
+        let (threshold, participation) = StacksChainState::get_reward_threshold_and_participation(
             &pox_constants,
             &reward_slots[..],
             liquid_ustx,
@@ -1924,26 +1924,29 @@ impl NakamotoChainState {
         let reward_set =
             StacksChainState::make_reward_set(threshold, reward_slots, StacksEpochId::Epoch30);
 
-        let signers_list: Vec<_> = reward_set
-            .signers
-            .ok_or(ChainstateError::PoxNoRewardCycle)?
-            .iter()
-            .map(|signer| {
-                Value::Tuple(
-                    TupleData::from_data(vec![
-                        (
-                            "signer".into(),
-                            Value::Principal(PrincipalData::from(signer.signing_address)),
-                        ),
-                        ("num-slots".into(), Value::UInt(signer.slots.into())),
-                    ])
-                    .expect(
-                        "BUG: Failed to construct `{ signer: principal, num-slots: u64 }` tuple",
-                    ),
-                )
-            })
-            .collect();
-
+        let signers_list = if participation == 0 {
+            vec![]
+        } else {
+            reward_set
+                .signers
+                .ok_or(ChainstateError::PoxNoRewardCycle)?
+                .iter()
+                .map(|signer| {
+                    Value::Tuple(
+                        TupleData::from_data(vec![
+                            (
+                                "signer".into(),
+                                Value::Principal(PrincipalData::from(signer.signing_address)),
+                            ),
+                            ("num-slots".into(), Value::UInt(signer.slots.into())),
+                        ])
+                            .expect(
+                                "BUG: Failed to construct `{ signer: principal, num-slots: u64 }` tuple",
+                            ),
+                    )
+                })
+                .collect()
+        };
         if signers_list.len() > SIGNERS_MAX_LIST_SIZE {
             panic!(
                 "FATAL: signers list returned by reward set calculations longer than maximum ({} > {})",
diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index b75d22a720..76b97633b2 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -115,7 +115,6 @@
         reward-set-indexes: (list 12 uint),
         ;; principal of the delegate, if stacker has delegated
         delegated-to: (optional principal),
-        signer-key: principal
     }
 )
 
@@ -172,7 +171,7 @@
         reward-cycle: uint,
         sender: principal
     }
-    { stacked-amount: uint, signer: principal }
+    { stacked-amount: uint }
 )
 
 ;; This is identical to partial-stacked-by-cycle, but its data is never deleted.
@@ -186,7 +185,7 @@
         reward-cycle: uint,
         sender: principal
     }
-    { stacked-amount: uint, signer: principal }
+    { stacked-amount: uint }
 )
 
 ;; The stackers' aggregate public key
@@ -419,12 +418,10 @@
 (define-private (add-pox-partial-stacked-to-ith-cycle
                  (cycle-index uint)
                  (params { pox-addr: { version: (buff 1), hashbytes: (buff 32) },
-                           signer: principal,
                            reward-cycle: uint,
                            num-cycles: uint,
                            amount-ustx: uint }))
   (let ((pox-addr     (get pox-addr     params))
-        (signer       (get signer       params))
         (num-cycles   (get num-cycles   params))
         (reward-cycle (get reward-cycle params))
         (amount-ustx  (get amount-ustx  params)))
@@ -438,10 +435,9 @@
           ;; otherwise, add to the partial-stacked-by-cycle
           (map-set partial-stacked-by-cycle
                    { sender: tx-sender, pox-addr: pox-addr, reward-cycle: reward-cycle }
-                   { stacked-amount: (+ amount-ustx current-amount), signer: signer }))
+                   { stacked-amount: (+ amount-ustx current-amount) }))
       ;; produce the next params tuple
       { pox-addr: pox-addr,
-        signer: signer,
         reward-cycle: (+ u1 reward-cycle),
         num-cycles: num-cycles,
         amount-ustx: amount-ustx })))
@@ -450,13 +446,12 @@
 ;; A PoX address can be added to at most 12 consecutive cycles.
 ;; No checking is done.
 (define-private (add-pox-partial-stacked (pox-addr (tuple (version (buff 1)) (hashbytes (buff 32))))
-                                         (signer principal)
                                          (first-reward-cycle uint)
                                          (num-cycles uint)
                                          (amount-ustx uint))
   (let ((cycle-indexes (list u0 u1 u2 u3 u4 u5 u6 u7 u8 u9 u10 u11)))
     (fold add-pox-partial-stacked-to-ith-cycle cycle-indexes
-          { pox-addr: pox-addr, signer: signer, reward-cycle: first-reward-cycle, num-cycles: num-cycles, amount-ustx: amount-ustx })
+          { pox-addr: pox-addr, reward-cycle: first-reward-cycle, num-cycles: num-cycles, amount-ustx: amount-ustx })
     true))
 
 ;; What is the minimum number of uSTX to be stacked in the given reward cycle?
@@ -599,8 +594,7 @@
              reward-set-indexes: reward-set-indexes,
              first-reward-cycle: first-reward-cycle,
              lock-period: lock-period,
-             delegated-to: none,
-             signer-key: (try! (signer-key-buff-to-principal signer-key)) })
+             delegated-to: none })
 
           ;; return the lock-up information, so the node can actually carry out the lock.
           (ok { stacker: tx-sender, lock-amount: amount-ustx, signer-key: signer-key, unlock-burn-height: (reward-cycle-to-burn-height (+ first-reward-cycle lock-period)) }))))
@@ -675,11 +669,13 @@
 ;;
 ;; *New in Stacks 2.1.*
 (define-private (inner-stack-aggregation-commit (pox-addr { version: (buff 1), hashbytes: (buff 32) })
-                                                (reward-cycle uint))
+                                                (reward-cycle uint)
+                                                (signer-key (buff 33)))
   (let ((partial-stacked
          ;; fetch the partial commitments
          (unwrap! (map-get? partial-stacked-by-cycle { pox-addr: pox-addr, sender: tx-sender, reward-cycle: reward-cycle })
-                  (err ERR_STACKING_NO_SUCH_PRINCIPAL))))
+                  (err ERR_STACKING_NO_SUCH_PRINCIPAL)))
+         (signer (try! (signer-key-buff-to-principal signer-key))))
     ;; must be called directly by the tx-sender or by an allowed contract-caller
     (asserts! (check-caller-allowed)
               (err ERR_STACKING_PERMISSION_DENIED))
@@ -695,7 +691,7 @@
                      num-cycles: u1,
                      reward-set-indexes: (list),
                      stacker: none,
-                     signer: (get signer partial-stacked),
+                     signer: signer,
                      amount-ustx: amount-ustx,
                      i: u0 }))
            (pox-addr-index (unwrap-panic
@@ -715,16 +711,18 @@
 ;; Returns (ok true) on success
 ;; Returns (err ...) on failure.
 (define-public (stack-aggregation-commit (pox-addr { version: (buff 1), hashbytes: (buff 32) })
-                                         (reward-cycle uint))
-    (match (inner-stack-aggregation-commit pox-addr reward-cycle)
+                                         (reward-cycle uint)
+                                         (signer-key (buff 33)))
+    (match (inner-stack-aggregation-commit pox-addr reward-cycle signer-key)
         pox-addr-index (ok true)
         commit-err (err commit-err)))
 
 ;; Public interface to `inner-stack-aggregation-commit`.  See its documentation for details.
 ;; *New in Stacks 2.1.*
 (define-public (stack-aggregation-commit-indexed (pox-addr { version: (buff 1), hashbytes: (buff 32) })
-                                                 (reward-cycle uint))
-    (inner-stack-aggregation-commit pox-addr reward-cycle))
+                                                 (reward-cycle uint)
+                                                 (signer-key (buff 33)))
+    (inner-stack-aggregation-commit pox-addr reward-cycle signer-key))
 
 ;; Commit partially stacked STX to a PoX address which has already received some STX (more than the Stacking min).
 ;; This allows a delegator to lock up marginally more STX from new delegates, even if they collectively do not
@@ -785,7 +783,8 @@
                    { pox-addr: pox-addr,
                      total-ustx: increased-ustx,
                      stacker: none,
-                     signer: (get signer partial-stacked) })
+                     ;; TODO: this must be authorized with a signature, or tx-sender allowance!
+                     signer: (get signer existing-entry) })
 
           ;; update the total ustx in this cycle
           (map-set reward-cycle-total-stacked
@@ -807,13 +806,11 @@
                                    (amount-ustx uint)
                                    (pox-addr { version: (buff 1), hashbytes: (buff 32) })
                                    (start-burn-ht uint)
-                                   (lock-period uint)
-                                   (signer-key (buff 33)))
+                                   (lock-period uint))
     ;; this stacker's first reward cycle is the _next_ reward cycle
     (let ((first-reward-cycle (+ u1 (current-pox-reward-cycle)))
           (specified-reward-cycle (+ u1 (burn-height-to-reward-cycle start-burn-ht)))
-          (unlock-burn-height (reward-cycle-to-burn-height (+ (current-pox-reward-cycle) u1 lock-period)))
-          (signer (try! (signer-key-buff-to-principal signer-key))))
+          (unlock-burn-height (reward-cycle-to-burn-height (+ (current-pox-reward-cycle) u1 lock-period))))
       ;; the start-burn-ht must result in the next reward cycle, do not allow stackers
       ;;  to "post-date" their `stack-stx` transaction
       (asserts! (is-eq first-reward-cycle specified-reward-cycle)
@@ -857,7 +854,7 @@
 
       ;; register the PoX address with the amount stacked via partial stacking
       ;;   before it can be included in the reward set, this must be committed!
-      (add-pox-partial-stacked pox-addr signer first-reward-cycle lock-period amount-ustx)
+      (add-pox-partial-stacked pox-addr first-reward-cycle lock-period amount-ustx)
 
       ;; add stacker record
       (map-set stacking-state
@@ -866,8 +863,7 @@
           first-reward-cycle: first-reward-cycle,
           reward-set-indexes: (list),
           lock-period: lock-period,
-          delegated-to: (some tx-sender),
-          signer-key: signer })
+          delegated-to: (some tx-sender) })
 
       ;; return the lock-up information, so the node can actually carry out the lock.
       (ok { stacker: stacker,
@@ -893,21 +889,19 @@
 ;; `(some stacker)` as the listed stacker, and must be an upcoming reward cycle.
 (define-private (increase-reward-cycle-entry
                   (reward-cycle-index uint)
-                  (updates (optional { first-cycle: uint, reward-cycle: uint, stacker: principal, signer: principal, add-amount: uint })))
+                  (updates (optional { first-cycle: uint, reward-cycle: uint, stacker: principal, add-amount: uint })))
     (let ((data (try! updates))
           (first-cycle (get first-cycle data))
           (reward-cycle (get reward-cycle data)))
     (if (> first-cycle reward-cycle)
         ;; not at first cycle to process yet
-        (some { first-cycle: first-cycle, reward-cycle: (+ u1 reward-cycle), stacker: (get stacker data), signer: (get signer data), add-amount: (get add-amount data) })
+        (some { first-cycle: first-cycle, reward-cycle: (+ u1 reward-cycle), stacker: (get stacker data), add-amount: (get add-amount data) })
         (let ((existing-entry (unwrap-panic (map-get? reward-cycle-pox-address-list { reward-cycle: reward-cycle, index: reward-cycle-index })))
               (existing-total (unwrap-panic (map-get? reward-cycle-total-stacked { reward-cycle: reward-cycle })))
               (add-amount (get add-amount data))
               (total-ustx (+ (get total-ustx existing-total) add-amount)))
             ;; stacker must match
             (asserts! (is-eq (get stacker existing-entry) (some (get stacker data))) none)
-            ;; signer must match
-            (asserts! (is-eq (get signer existing-entry) (get signer data)) none)
             ;; update the pox-address list
             (map-set reward-cycle-pox-address-list
                      { reward-cycle: reward-cycle, index: reward-cycle-index }
@@ -915,7 +909,7 @@
                        ;; This addresses the bug in pox-2 (see SIP-022)
                        total-ustx: (+ (get total-ustx existing-entry) add-amount),
                        stacker: (some (get stacker data)),
-                       signer: (get signer data) })
+                       signer: (get signer existing-entry) })
             ;; update the total
             (map-set reward-cycle-total-stacked
                      { reward-cycle: reward-cycle }
@@ -923,7 +917,6 @@
             (some { first-cycle: first-cycle,
                     reward-cycle: (+ u1 reward-cycle),
                     stacker: (get stacker data),
-                    signer: (get signer data),
                     add-amount: (get add-amount data) })))))
 
 ;; Increase the number of STX locked.
@@ -964,7 +957,6 @@
             (some { first-cycle: first-increased-cycle,
                     reward-cycle: (get first-reward-cycle stacker-state),
                     stacker: tx-sender,
-                    signer: (get signer-key stacker-state),
                     add-amount: increase-by })))
             (err ERR_STACKING_UNREACHABLE))
       ;; NOTE: stacking-state map is unchanged: it does not track amount-stacked in PoX-4
@@ -1048,8 +1040,7 @@
               reward-set-indexes: reward-set-indexes,
               first-reward-cycle: first-reward-cycle,
               lock-period: lock-period,
-              delegated-to: none,
-              signer-key: (try! (signer-key-buff-to-principal signer-key)) })
+              delegated-to: none })
 
         ;; return lock-up information
         (ok { stacker: tx-sender, unlock-burn-height: new-unlock-ht })))))
@@ -1135,7 +1126,7 @@
 
       ;; register the PoX address with the amount stacked via partial stacking
       ;;   before it can be included in the reward set, this must be committed!
-      (add-pox-partial-stacked pox-addr (get signer-key stacker-state) first-increase-cycle cycle-count increase-by)
+      (add-pox-partial-stacked pox-addr first-increase-cycle cycle-count increase-by)
 
       ;; stacking-state is unchanged, so no need to update
 
@@ -1150,7 +1141,6 @@
 (define-public (delegate-stack-extend
                     (stacker principal)
                     (pox-addr { version: (buff 1), hashbytes: (buff 32) })
-                    (signer-key (buff 33))
                     (extend-count uint))
     (let ((stacker-info (stx-account stacker))
           ;; to extend, there must already be an entry in the stacking-state
@@ -1170,8 +1160,7 @@
 
      (let ((last-extend-cycle  (- (+ first-extend-cycle extend-count) u1))
            (lock-period (+ u1 (- last-extend-cycle first-reward-cycle)))
-           (new-unlock-ht (reward-cycle-to-burn-height (+ u1 last-extend-cycle)))
-           (signer (try! (signer-key-buff-to-principal signer-key))))
+           (new-unlock-ht (reward-cycle-to-burn-height (+ u1 last-extend-cycle))))
 
       ;; first cycle must be after the current cycle
       (asserts! (> first-extend-cycle cur-cycle) (err ERR_STACKING_INVALID_LOCK_PERIOD))
@@ -1226,7 +1215,7 @@
 
       ;; register the PoX address with the amount stacked via partial stacking
       ;;   before it can be included in the reward set, this must be committed!
-      (add-pox-partial-stacked pox-addr signer first-extend-cycle extend-count amount-ustx)
+      (add-pox-partial-stacked pox-addr first-extend-cycle extend-count amount-ustx)
 
       (map-set stacking-state
         { stacker: stacker }
@@ -1234,8 +1223,7 @@
           reward-set-indexes: (list),
           first-reward-cycle: first-reward-cycle,
           lock-period: lock-period,
-          delegated-to: (some tx-sender),
-          signer-key: signer })
+          delegated-to: (some tx-sender) })
 
       ;; return the lock-up information, so the node can actually carry out the lock.
       (ok { stacker: stacker,
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index cf51aac9c3..591a4bb019 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -41,7 +41,7 @@ use stacks_common::types::chainstate::{
 };
 use stacks_common::types::Address;
 use stacks_common::util::hash::{hex_bytes, to_hex, Sha256Sum, Sha512Trunc256Sum};
-use stacks_common::util::secp256k1::Secp256k1PrivateKey;
+use stacks_common::util::secp256k1::{Secp256k1PrivateKey, Secp256k1PublicKey};
 use wsts::curve::point::{Compressed, Point};
 
 use super::test::*;
@@ -786,13 +786,13 @@ fn pox_lock_unlock() {
 
     assert_eq!(burnchain.pox_constants.reward_slots(), 6);
     let mut coinbase_nonce = 0;
-    let mut latest_block;
+    let mut latest_block = None;
 
     // Advance into pox4
     let target_height = burnchain.pox_constants.pox_4_activation_height;
     // produce blocks until the first reward phase that everyone should be in
     while get_tip(peer.sortdb.as_ref()).block_height < u64::from(target_height) {
-        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+        latest_block = Some(peer.tenure_with_txs(&[], &mut coinbase_nonce));
         // if we reach epoch 2.1, perform the check
         if get_tip(peer.sortdb.as_ref()).block_height > epochs[3].start_height {
             assert_latest_was_burn(&mut peer);
@@ -814,8 +814,10 @@ fn pox_lock_unlock() {
             AddressHashMode::SerializeP2WPKH,
             AddressHashMode::SerializeP2WSH,
         ])
-        .map(|(key, hash_mode)| {
+        .enumerate()
+        .map(|(ix, (key, hash_mode))| {
             let pox_addr = PoxAddress::from_legacy(hash_mode, key_to_stacks_addr(key).bytes);
+            let lock_period = if ix == 3 { 12 } else { lock_period };
             txs.push(make_pox_4_lockup(
                 key,
                 0,
@@ -830,7 +832,7 @@ fn pox_lock_unlock() {
         .collect();
 
     info!("Submitting stacking txs");
-    latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
+    let mut latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
 
     // Advance to start of rewards cycle stackers are participating in
     let target_height = burnchain.pox_constants.pox_4_activation_height + 5;
@@ -859,6 +861,8 @@ fn pox_lock_unlock() {
         let balances = balances_from_keys(&mut peer, &latest_block, &keys);
         assert!(balances[0].amount_locked() > 0);
         assert!(balances[1].amount_locked() > 0);
+        assert!(balances[2].amount_locked() > 0);
+        assert!(balances[3].amount_locked() > 0);
 
         info!("Checking we have 2 stackers for cycle {cycle}");
         for i in 0..reward_blocks {
@@ -893,15 +897,34 @@ fn pox_lock_unlock() {
     }
 
     info!("Checking STX unlocked after {lock_period} cycles");
-    for _ in 0..burnchain.pox_constants.reward_cycle_length {
+    let mut rewarded = HashSet::new();
+    for i in 0..burnchain.pox_constants.reward_cycle_length {
         latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
-        assert_latest_was_burn(&mut peer);
+        // only 1 entry in reward set now, but they get 5 slots -- so that's 3 blocks
+        info!("Checking {i}th block of next reward cycle");
+        if i < 3 {
+            assert_latest_was_pox(&mut peer)
+                .into_iter()
+                .filter(|addr| !addr.is_burn())
+                .for_each(|addr| {
+                    rewarded.insert(addr);
+                });
+        } else {
+            assert_latest_was_burn(&mut peer);
+        }
     }
 
-    info!("Checking that stackers have no STX locked");
+    assert_eq!(rewarded.len(), 1);
+    assert!(
+        rewarded.contains(&stackers[3]),
+        "Reward set should include the index-3 stacker"
+    );
+
+    info!("Checking that stackers[0..2] have no STX locked");
     let balances = balances_from_keys(&mut peer, &latest_block, &keys);
     assert_eq!(balances[0].amount_locked(), 0);
     assert_eq!(balances[1].amount_locked(), 0);
+    assert_eq!(balances[2].amount_locked(), 0);
 }
 
 /// Test that pox3 methods fail once pox4 is activated
@@ -1206,7 +1229,7 @@ fn pox_4_revoke_delegate_stx_events() {
 
     assert_eq!(burnchain.pox_constants.reward_slots(), 6);
     let mut coinbase_nonce = 0;
-    let mut latest_block;
+    let mut latest_block = None;
 
     // alice
     let alice = keys.pop().unwrap();
@@ -1219,19 +1242,43 @@ fn pox_4_revoke_delegate_stx_events() {
     let bob_principal = PrincipalData::from(bob_address.clone());
     let bob_pox_addr = make_pox_addr(AddressHashMode::SerializeP2PKH, bob_address.bytes.clone());
 
+    // steph the solo stacker stacks stx so nakamoto signer set stays stacking.
+    let steph = keys.pop().unwrap();
+    let steph_address = key_to_stacks_addr(&steph);
+    let steph_principal = PrincipalData::from(steph_address.clone());
+    let steph_pox_addr =
+        make_pox_addr(AddressHashMode::SerializeP2PKH, steph_address.bytes.clone());
+
+    let steph_signing_key = Secp256k1PublicKey::from_private(&steph);
+    let steph_key_val = Value::buff_from(steph_signing_key.to_bytes_compressed()).unwrap();
+
     let mut alice_nonce = 0;
 
     // Advance into pox4
     let target_height = burnchain.pox_constants.pox_4_activation_height;
     // produce blocks until the first reward phase that everyone should be in
     while get_tip(peer.sortdb.as_ref()).block_height < u64::from(target_height) {
-        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+        latest_block = Some(peer.tenure_with_txs(&[], &mut coinbase_nonce));
     }
 
     info!(
         "Block height: {}",
         get_tip(peer.sortdb.as_ref()).block_height
     );
+    let block_height = get_tip(peer.sortdb.as_ref()).block_height;
+    let min_ustx = get_stacking_minimum(&mut peer, &latest_block.unwrap());
+    let steph_stacking = make_pox_4_contract_call(
+        &steph,
+        0,
+        "stack-stx",
+        vec![
+            Value::UInt(min_ustx),
+            steph_pox_addr,
+            Value::UInt(block_height as u128),
+            Value::UInt(12),
+            steph_key_val,
+        ],
+    );
 
     // alice delegates 100 STX to Bob
     let alice_delegation_amount = 100_000_000;
@@ -1255,7 +1302,7 @@ fn pox_4_revoke_delegate_stx_events() {
     alice_nonce += 1;
 
     peer.tenure_with_txs(
-        &[alice_delegate, alice_revoke, alice_revoke_2],
+        &[steph_stacking, alice_delegate, alice_revoke, alice_revoke_2],
         &mut coinbase_nonce,
     );
 
@@ -1431,19 +1478,19 @@ fn stack_stx_signer_key() {
         AddressHashMode::SerializeP2WSH,
         key_to_stacks_addr(stacker_key).bytes,
     );
-    let signer_key_val = Value::buff_from(vec![
-        0x03, 0xa0, 0xf9, 0x81, 0x8e, 0xa8, 0xc1, 0x4a, 0x82, 0x7b, 0xb1, 0x44, 0xae, 0xc9, 0xcf,
-        0xba, 0xeb, 0xa2, 0x25, 0xaf, 0x22, 0xbe, 0x18, 0xed, 0x78, 0xa2, 0xf2, 0x98, 0x10, 0x6f,
-        0x4e, 0x28, 0x1b,
-    ])
-    .unwrap();
+
+    let signer_bytes =
+        hex_bytes("03a0f9818ea8c14a827bb144aec9cfbaeba225af22be18ed78a2f298106f4e281b").unwrap();
+    let signer_key = Secp256k1PublicKey::from_slice(&signer_bytes).unwrap();
+    let signer_key_val = Value::buff_from(signer_bytes).unwrap();
+
     let txs = vec![make_pox_4_contract_call(
         stacker_key,
         stacker_nonce,
         "stack-stx",
         vec![
             Value::UInt(min_ustx),
-            pox_addr,
+            pox_addr.clone(),
             Value::UInt(block_height as u128),
             Value::UInt(2),
             signer_key_val.clone(),
@@ -1459,81 +1506,21 @@ fn stack_stx_signer_key() {
     .expect("No stacking state, stack-stx failed")
     .expect_tuple();
 
-    let state_signer_key = stacking_state.get("signer-key").unwrap();
-    assert_eq!(state_signer_key.to_string(), signer_key_val.to_string());
-}
-
-#[test]
-fn stack_stx_signer_key_no_reuse() {
-    let lock_period = 2;
-    let observer = TestEventObserver::new();
-    let (burnchain, mut peer, keys, latest_block, block_height, mut coinbase_nonce) =
-        prepare_pox4_test(function_name!(), Some(&observer));
-
-    let first_stacker_nonce = 0;
-    let second_stacker_nonce = 0;
-    let first_stacker_key = &keys[0];
-    let second_stacker_key = &keys[1];
-    let second_stacker_address = key_to_stacks_addr(second_stacker_key);
-    let min_ustx = get_stacking_minimum(&mut peer, &latest_block);
-
-    let pox_addr = make_pox_addr(
-        AddressHashMode::SerializeP2WSH,
-        key_to_stacks_addr(first_stacker_key).bytes,
+    let next_reward_cycle = 1 + burnchain
+        .block_height_to_reward_cycle(block_height)
+        .unwrap();
+    let reward_cycle_ht = burnchain.reward_cycle_to_block_height(next_reward_cycle);
+    let mut reward_set = get_reward_set_entries_at(&mut peer, &latest_block, reward_cycle_ht);
+    assert_eq!(reward_set.len(), 1);
+    let reward_entry = reward_set.pop().unwrap();
+    assert_eq!(
+        PoxAddress::try_from_pox_tuple(false, &pox_addr).unwrap(),
+        reward_entry.reward_address
     );
-    let signer_key_val = Value::buff_from(vec![
-        0x03, 0xa0, 0xf9, 0x81, 0x8e, 0xa8, 0xc1, 0x4a, 0x82, 0x7b, 0xb1, 0x44, 0xae, 0xc9, 0xcf,
-        0xba, 0xeb, 0xa2, 0x25, 0xaf, 0x22, 0xbe, 0x18, 0xed, 0x78, 0xa2, 0xf2, 0x98, 0x10, 0x6f,
-        0x4e, 0x28, 0x1b,
-    ])
-    .unwrap();
-    let txs = vec![
-        make_pox_4_contract_call(
-            first_stacker_key,
-            first_stacker_nonce,
-            "stack-stx",
-            vec![
-                Value::UInt(min_ustx),
-                pox_addr.clone(),
-                Value::UInt(block_height as u128),
-                Value::UInt(2),
-                signer_key_val.clone(),
-            ],
-        ),
-        make_pox_4_contract_call(
-            second_stacker_key,
-            second_stacker_nonce,
-            "stack-stx",
-            vec![
-                Value::UInt(min_ustx),
-                pox_addr.clone(),
-                Value::UInt(block_height as u128),
-                Value::UInt(2),
-                signer_key_val.clone(),
-            ],
-        ),
-    ];
-
-    let latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
-    let first_stacking_state = get_stacking_state_pox_4(
-        &mut peer,
-        &latest_block,
-        &key_to_stacks_addr(first_stacker_key).to_account_principal(),
-    )
-    .expect("No stacking state, stack-stx failed")
-    .expect_tuple();
-
-    let second_stacker_transactions =
-        get_last_block_sender_transactions(&observer, second_stacker_address);
-
-    assert_eq!(second_stacker_transactions.len(), 1);
     assert_eq!(
-        second_stacker_transactions
-            .get(0)
-            .expect("Stacker should have one transaction")
-            .result,
-        Value::error(Value::Int(ERR_REUSED_SIGNER_KEY)).unwrap()
-    )
+        reward_entry.signer.unwrap(),
+        StacksAddress::p2pkh(false, &signer_key).into(),
+    );
 }
 
 #[test]
@@ -1551,12 +1538,21 @@ fn stack_extend_signer_key() {
         key_to_stacks_addr(stacker_key).bytes,
     );
 
-    let signer_key_val = Value::buff_from(vec![
-        0x03, 0xa0, 0xf9, 0x81, 0x8e, 0xa8, 0xc1, 0x4a, 0x82, 0x7b, 0xb1, 0x44, 0xae, 0xc9, 0xcf,
-        0xba, 0xeb, 0xa2, 0x25, 0xaf, 0x22, 0xbe, 0x18, 0xed, 0x78, 0xa2, 0xf2, 0x98, 0x10, 0x6f,
-        0x4e, 0x28, 0x1b,
-    ])
-    .unwrap();
+    let signer_sk = Secp256k1PrivateKey::from_seed(&[0]);
+    let signer_extend_sk = Secp256k1PrivateKey::from_seed(&[1]);
+
+    let signer_key = Secp256k1PublicKey::from_private(&signer_sk);
+    let signer_bytes = signer_key.to_bytes_compressed();
+    let signer_key_val = Value::buff_from(signer_bytes).unwrap();
+
+    let signer_extend_key = Secp256k1PublicKey::from_private(&signer_extend_sk);
+    let signer_extend_bytes = signer_extend_key.to_bytes_compressed();
+    let signer_extend_key_val = Value::buff_from(signer_extend_bytes).unwrap();
+
+    let next_reward_cycle = 1 + burnchain
+        .block_height_to_reward_cycle(block_height)
+        .unwrap();
+
     let txs = vec![make_pox_4_contract_call(
         stacker_key,
         stacker_nonce,
@@ -1581,16 +1577,7 @@ fn stack_extend_signer_key() {
     .expect("No stacking state, stack-stx failed")
     .expect_tuple();
 
-    let state_signer_key = stacking_state.get("signer-key").unwrap();
-    assert_eq!(state_signer_key.to_string(), signer_key_val.to_string());
-
     // now stack-extend with a new signer-key
-    let signer_key_new_val = Value::buff_from(vec![
-        0x02, 0xb6, 0x19, 0x6d, 0xe8, 0x8b, 0xce, 0xe7, 0x93, 0xfa, 0x9a, 0x8a, 0x85, 0x96, 0x9b,
-        0x64, 0x7f, 0x84, 0xc9, 0x0e, 0x9d, 0x13, 0xf9, 0xc8, 0xb8, 0xce, 0x42, 0x6c, 0xc8, 0x1a,
-        0x59, 0x98, 0x3c,
-    ])
-    .unwrap();
 
     // (define-public (stack-extend (extend-count uint)
     //                          (pox-addr { version: (buff 1), hashbytes: (buff 32) })
@@ -1599,7 +1586,11 @@ fn stack_extend_signer_key() {
         stacker_key,
         stacker_nonce,
         "stack-extend",
-        vec![Value::UInt(1), pox_addr, signer_key_new_val.clone()],
+        vec![
+            Value::UInt(1),
+            pox_addr.clone(),
+            signer_extend_key_val.clone(),
+        ],
     )];
 
     latest_block = peer.tenure_with_txs(&update_txs, &mut coinbase_nonce);
@@ -1611,10 +1602,32 @@ fn stack_extend_signer_key() {
     .unwrap()
     .expect_tuple();
 
-    let state_signer_key_new = new_stacking_state.get("signer-key").unwrap();
+    let extend_reward_cycle = 2 + next_reward_cycle;
+    let reward_cycle_ht = burnchain.reward_cycle_to_block_height(next_reward_cycle);
+    let extend_cycle_ht = burnchain.reward_cycle_to_block_height(extend_reward_cycle);
+
+    let mut reward_set = get_reward_set_entries_at(&mut peer, &latest_block, reward_cycle_ht);
+    assert_eq!(reward_set.len(), 1);
+    let reward_entry = reward_set.pop().unwrap();
+    assert_eq!(
+        PoxAddress::try_from_pox_tuple(false, &pox_addr).unwrap(),
+        reward_entry.reward_address
+    );
+    assert_eq!(
+        reward_entry.signer.unwrap(),
+        StacksAddress::p2pkh(false, &signer_key).into(),
+    );
+
+    let mut reward_set = get_reward_set_entries_at(&mut peer, &latest_block, extend_cycle_ht);
+    assert_eq!(reward_set.len(), 1);
+    let reward_entry = reward_set.pop().unwrap();
     assert_eq!(
-        state_signer_key_new.to_string(),
-        signer_key_new_val.to_string()
+        PoxAddress::try_from_pox_tuple(false, &pox_addr).unwrap(),
+        reward_entry.reward_address
+    );
+    assert_eq!(
+        reward_entry.signer.unwrap(),
+        StacksAddress::p2pkh(false, &signer_extend_key).into(),
     );
 }
 
@@ -1630,6 +1643,10 @@ fn delegate_stack_stx_signer_key() {
     let delegate_key = &keys[1];
     let delegate_principal = PrincipalData::from(key_to_stacks_addr(delegate_key));
 
+    let next_reward_cycle = 1 + burnchain
+        .block_height_to_reward_cycle(block_height)
+        .unwrap();
+
     // (define-public (delegate-stx (amount-ustx uint)
     //                          (delegate-to principal)
     //                          (until-burn-ht (optional uint))
@@ -1638,12 +1655,12 @@ fn delegate_stack_stx_signer_key() {
         AddressHashMode::SerializeP2WSH,
         key_to_stacks_addr(delegate_key).bytes,
     );
-    let signer_key_val = Value::buff_from(vec![
-        0x03, 0xa0, 0xf9, 0x81, 0x8e, 0xa8, 0xc1, 0x4a, 0x82, 0x7b, 0xb1, 0x44, 0xae, 0xc9, 0xcf,
-        0xba, 0xeb, 0xa2, 0x25, 0xaf, 0x22, 0xbe, 0x18, 0xed, 0x78, 0xa2, 0xf2, 0x98, 0x10, 0x6f,
-        0x4e, 0x28, 0x1b,
-    ])
-    .unwrap();
+    let signer_bytes =
+        hex_bytes("03a0f9818ea8c14a827bb144aec9cfbaeba225af22be18ed78a2f298106f4e281b").unwrap();
+    let signer_key = Secp256k1PublicKey::from_slice(&signer_bytes).unwrap();
+    let signer_key_val = Value::buff_from(signer_bytes).unwrap();
+
+    let min_ustx = get_stacking_minimum(&mut peer, &latest_block);
 
     let txs = vec![
         make_pox_4_contract_call(
@@ -1651,7 +1668,7 @@ fn delegate_stack_stx_signer_key() {
             stacker_nonce,
             "delegate-stx",
             vec![
-                Value::UInt(100),
+                Value::UInt(min_ustx + 1),
                 delegate_principal.clone().into(),
                 Value::none(),
                 Value::Optional(OptionalData {
@@ -1665,10 +1682,19 @@ fn delegate_stack_stx_signer_key() {
             "delegate-stack-stx",
             vec![
                 PrincipalData::from(key_to_stacks_addr(stacker_key)).into(),
-                Value::UInt(100),
-                pox_addr,
+                Value::UInt(min_ustx + 1),
+                pox_addr.clone(),
                 Value::UInt(block_height as u128),
                 Value::UInt(lock_period),
+            ],
+        ),
+        make_pox_4_contract_call(
+            delegate_key,
+            delegate_nonce + 1,
+            "stack-aggregation-commit",
+            vec![
+                pox_addr.clone(),
+                Value::UInt(next_reward_cycle.into()),
                 signer_key_val.clone(),
             ],
         ),
@@ -1697,8 +1723,18 @@ fn delegate_stack_stx_signer_key() {
     .expect("No stacking state, stack-stx failed")
     .expect_tuple();
 
-    let state_signer_key = stacking_state.get("signer-key").unwrap();
-    assert_eq!(state_signer_key.to_string(), signer_key_val.to_string());
+    let reward_cycle_ht = burnchain.reward_cycle_to_block_height(next_reward_cycle);
+    let mut reward_set = get_reward_set_entries_at(&mut peer, &latest_block, reward_cycle_ht);
+    assert_eq!(reward_set.len(), 1);
+    let reward_entry = reward_set.pop().unwrap();
+    assert_eq!(
+        PoxAddress::try_from_pox_tuple(false, &pox_addr).unwrap(),
+        reward_entry.reward_address
+    );
+    assert_eq!(
+        reward_entry.signer.unwrap(),
+        StacksAddress::p2pkh(false, &signer_key).into(),
+    );
 }
 
 pub fn get_stacking_state_pox_4(
diff --git a/stackslib/src/chainstate/stacks/boot/signers_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_tests.rs
index 4a31ac8b0e..c5a36bae2b 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_tests.rs
@@ -82,52 +82,6 @@ fn signers_get_config() {
     );
 }
 
-#[test]
-fn signers_get_signer_keys_from_pox4() {
-    let stacker_1 = TestStacker::from_seed(&[3, 4]);
-    let stacker_2 = TestStacker::from_seed(&[5, 6]);
-
-    let (mut peer, test_signers, latest_block_id) =
-        prepare_signers_test(function_name!(), Some(vec![&stacker_1, &stacker_2]));
-
-    let private_key = peer.config.private_key.clone();
-
-    let stacker_1_addr = key_to_stacks_addr(&stacker_1.stacker_private_key);
-    let stacker_2_addr = key_to_stacks_addr(&stacker_2.stacker_private_key);
-
-    let signer_1_addr = key_to_stacks_addr(&stacker_1.signer_private_key);
-    let signer_2_addr = key_to_stacks_addr(&stacker_2.signer_private_key);
-
-    let stacker_1_info = readonly_call(
-        &mut peer,
-        &latest_block_id,
-        "pox-4".into(),
-        "get-stacker-info".into(),
-        vec![Value::Principal(PrincipalData::from(stacker_1_addr))],
-    );
-
-    let stacker_2_info = readonly_call(
-        &mut peer,
-        &latest_block_id,
-        "pox-4".into(),
-        "get-stacker-info".into(),
-        vec![Value::Principal(PrincipalData::from(stacker_2_addr))],
-    );
-
-    let stacker_1_tuple = stacker_1_info.expect_optional().unwrap().expect_tuple();
-    let stacker_2_tuple = stacker_2_info.expect_optional().unwrap().expect_tuple();
-
-    assert_eq!(
-        stacker_1_tuple.get_owned("signer-key").unwrap(),
-        Value::Principal(PrincipalData::from(signer_1_addr))
-    );
-
-    assert_eq!(
-        stacker_2_tuple.get_owned("signer-key").unwrap(),
-        Value::Principal(PrincipalData::from(signer_2_addr))
-    );
-}
-
 #[test]
 fn signers_get_signer_keys_from_stackerdb() {
     let stacker_1 = TestStacker::from_seed(&[3, 4]);

From b6ea0993208a402ac1525e9f3933ef8a86217375 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Thu, 25 Jan 2024 13:40:26 -0500
Subject: [PATCH 0484/1166] fix: if we have private_neighbors = false, then
 don't bother selecting neighbors to walk to from there

---
 stackslib/src/net/neighbors/db.rs | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)

diff --git a/stackslib/src/net/neighbors/db.rs b/stackslib/src/net/neighbors/db.rs
index 4e62000a78..2f694b31ad 100644
--- a/stackslib/src/net/neighbors/db.rs
+++ b/stackslib/src/net/neighbors/db.rs
@@ -223,7 +223,7 @@ pub trait NeighborWalkDB {
                 e
             });
 
-        let mut next_neighbors = if let Ok(neighbors) = next_neighbors_res {
+        let db_neighbors = if let Ok(neighbors) = next_neighbors_res {
             neighbors
         } else {
             let any_neighbors = Self::pick_walk_neighbors(network, (NUM_NEIGHBORS as u64) * 2, 0)
@@ -238,6 +238,20 @@ pub trait NeighborWalkDB {
 
             any_neighbors
         };
+
+        let mut next_neighbors: Vec<_> = db_neighbors
+            .into_iter()
+            .filter_map(|neighbor| {
+                if network.get_connection_opts().private_neighbors
+                    && neighbor.addr.addrbytes.is_in_private_range()
+                {
+                    None
+                } else {
+                    Some(neighbor)
+                }
+            })
+            .collect();
+
         if next_neighbors.len() == 0 {
             return Err(net_error::NoSuchNeighbor);
         }

From 5794ee8152a365b41c6de8a71006ffb7fe3583a9 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Thu, 25 Jan 2024 13:41:39 -0500
Subject: [PATCH 0485/1166] fix: missing !

---
 stackslib/src/net/neighbors/db.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stackslib/src/net/neighbors/db.rs b/stackslib/src/net/neighbors/db.rs
index 2f694b31ad..5a40ac9677 100644
--- a/stackslib/src/net/neighbors/db.rs
+++ b/stackslib/src/net/neighbors/db.rs
@@ -242,7 +242,7 @@ pub trait NeighborWalkDB {
         let mut next_neighbors: Vec<_> = db_neighbors
             .into_iter()
             .filter_map(|neighbor| {
-                if network.get_connection_opts().private_neighbors
+                if !network.get_connection_opts().private_neighbors
                     && neighbor.addr.addrbytes.is_in_private_range()
                 {
                     None

From a7559a30ebee9a47536ee7839aa2dbed550e0741 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Thu, 25 Jan 2024 13:11:46 -0600
Subject: [PATCH 0486/1166] signing internal representation: from principal ->
 (buff 33)

---
 stacks-common/src/types/mod.rs                | 12 +++-
 stackslib/src/chainstate/nakamoto/mod.rs      | 18 ++++--
 stackslib/src/chainstate/stacks/boot/mod.rs   | 60 ++++++++++++-------
 .../src/chainstate/stacks/boot/pox-4.clar     | 23 +++----
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 27 +++------
 .../chainstate/stacks/boot/signers_tests.rs   | 56 +++++++++--------
 6 files changed, 105 insertions(+), 91 deletions(-)

diff --git a/stacks-common/src/types/mod.rs b/stacks-common/src/types/mod.rs
index a4eec7369e..998edda48e 100644
--- a/stacks-common/src/types/mod.rs
+++ b/stacks-common/src/types/mod.rs
@@ -215,13 +215,21 @@ impl StacksAddress {
 
     /// Make a P2PKH StacksAddress
     pub fn p2pkh(mainnet: bool, pubkey: &StacksPublicKey) -> StacksAddress {
+        let bytes = to_bits_p2pkh(pubkey);
+        Self::p2pkh_from_hash(mainnet, bytes)
+    }
+
+    /// Make a P2PKH StacksAddress
+    pub fn p2pkh_from_hash(mainnet: bool, hash: Hash160) -> StacksAddress {
         let version = if mainnet {
             C32_ADDRESS_VERSION_MAINNET_SINGLESIG
         } else {
             C32_ADDRESS_VERSION_TESTNET_SINGLESIG
         };
-        let bytes = to_bits_p2pkh(pubkey);
-        Self { version, bytes }
+        Self {
+            version,
+            bytes: hash,
+        }
     }
 }
 
diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index 0575f0c331..fbd3625430 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -54,7 +54,7 @@ use super::burn::db::sortdb::{
 use super::burn::operations::{DelegateStxOp, StackStxOp, TransferStxOp};
 use super::stacks::boot::{
     PoxVersions, RawRewardSetEntry, BOOT_TEST_POX_4_AGG_KEY_CONTRACT,
-    BOOT_TEST_POX_4_AGG_KEY_FNAME, SIGNERS_MAX_LIST_SIZE, SIGNERS_NAME,
+    BOOT_TEST_POX_4_AGG_KEY_FNAME, SIGNERS_MAX_LIST_SIZE, SIGNERS_NAME, SIGNERS_PK_LEN,
 };
 use super::stacks::db::accounts::MinerReward;
 use super::stacks::db::blocks::StagingUserBurnSupport;
@@ -1891,13 +1891,21 @@ impl NakamotoChainState {
                     reward_cycle, index
                 ))
                 .to_owned()
-                .expect_principal();
+                .expect_buff(SIGNERS_PK_LEN);
+            // (buff 33) only enforces max size, not min size, so we need to do a len check
+            let pk_bytes = if signer.len() == SIGNERS_PK_LEN {
+                let mut bytes = [0; SIGNERS_PK_LEN];
+                bytes.copy_from_slice(signer.as_slice());
+                bytes
+            } else {
+                [0; SIGNERS_PK_LEN]
+            };
 
             slots.push(RawRewardSetEntry {
                 reward_address,
                 amount_stacked: total_ustx,
                 stacker,
-                signer: Some(signer),
+                signer: Some(pk_bytes),
             })
         }
 
@@ -1932,11 +1940,13 @@ impl NakamotoChainState {
                 .ok_or(ChainstateError::PoxNoRewardCycle)?
                 .iter()
                 .map(|signer| {
+                    let signer_hash = Hash160::from_data(&signer.signing_key);
+                    let signing_address = StacksAddress::p2pkh_from_hash(is_mainnet, signer_hash);
                     Value::Tuple(
                         TupleData::from_data(vec![
                             (
                                 "signer".into(),
-                                Value::Principal(PrincipalData::from(signer.signing_address)),
+                                Value::Principal(PrincipalData::from(signing_address)),
                             ),
                             ("num-slots".into(), Value::UInt(signer.slots.into())),
                         ])
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 7c60e1164f..9288f89556 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -83,6 +83,7 @@ pub const SIGNERS_NAME: &'static str = "signers";
 /// reward cycle number.
 pub const SIGNERS_UPDATE_STATE: &'static str = "last-set-cycle";
 pub const SIGNERS_MAX_LIST_SIZE: usize = 4000;
+pub const SIGNERS_PK_LEN: usize = 33;
 
 const POX_2_BODY: &'static str = std::include_str!("pox-2.clar");
 const POX_3_BODY: &'static str = std::include_str!("pox-3.clar");
@@ -164,7 +165,7 @@ pub struct RawRewardSetEntry {
     pub reward_address: PoxAddress,
     pub amount_stacked: u128,
     pub stacker: Option<PrincipalData>,
-    pub signer: Option<PrincipalData>,
+    pub signer: Option<[u8; SIGNERS_PK_LEN]>,
 }
 
 /// This enum captures the names of the PoX contracts by version.
@@ -192,23 +193,30 @@ pub struct PoxStartCycleInfo {
     pub missed_reward_slots: Vec<(PrincipalData, u128)>,
 }
 
-fn addr_serialize<S: serde::Serializer>(addr: &StacksAddress, s: S) -> Result<S::Ok, S::Error> {
-    s.serialize_str(&addr.to_string())
+fn hex_serialize<S: serde::Serializer>(addr: &[u8; 33], s: S) -> Result<S::Ok, S::Error> {
+    s.serialize_str(&to_hex(addr))
 }
 
-fn addr_deserialize<'de, D: serde::Deserializer<'de>>(d: D) -> Result<StacksAddress, D::Error> {
-    let addr_str = String::deserialize(d)?;
-    StacksAddress::from_string(&addr_str)
-        .ok_or_else(|| serde::de::Error::custom("Address must be a C32 encoded StacksAddress"))
+fn hex_deserialize<'de, D: serde::Deserializer<'de>>(
+    d: D,
+) -> Result<[u8; SIGNERS_PK_LEN], D::Error> {
+    let hex_str = String::deserialize(d)?;
+    let bytes_vec = hex_bytes(&hex_str).map_err(serde::de::Error::custom)?;
+    if bytes_vec.len() != SIGNERS_PK_LEN {
+        return Err(serde::de::Error::invalid_length(
+            bytes_vec.len(),
+            &"array of len == SIGNERS_PK_LEN",
+        ));
+    }
+    let mut bytes = [0; SIGNERS_PK_LEN];
+    bytes.copy_from_slice(bytes_vec.as_slice());
+    Ok(bytes)
 }
 
 #[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
 pub struct NakamotoSignerEntry {
-    #[serde(
-        serialize_with = "addr_serialize",
-        deserialize_with = "addr_deserialize"
-    )]
-    pub signing_address: StacksAddress,
+    #[serde(serialize_with = "hex_serialize", deserialize_with = "hex_deserialize")]
+    pub signing_key: [u8; 33],
     pub stacked_amt: u128,
     pub slots: u32,
 }
@@ -647,12 +655,10 @@ impl StacksChainState {
 
         let mut signer_set = BTreeMap::new();
         for entry in entries.iter() {
-            let signing_key = if let Some(PrincipalData::Standard(s)) = entry.signer.clone() {
-                StacksAddress::from(s)
-            } else {
-                // TODO: should figure out if in mainnet?
-                StacksAddress::burn_address(true)
-            };
+            let signing_key = entry
+                .signer
+                .clone()
+                .expect("BUG: signing keys should all be set in reward-sets with any signing keys");
             if let Some(existing_entry) = signer_set.get_mut(&signing_key) {
                 *existing_entry += entry.amount_stacked;
             } else {
@@ -662,14 +668,14 @@ impl StacksChainState {
 
         let mut signer_set: Vec<_> = signer_set
             .into_iter()
-            .filter_map(|(signing_address, stacked_amt)| {
+            .filter_map(|(signing_key, stacked_amt)| {
                 let slots = u32::try_from(stacked_amt / threshold)
                     .expect("CORRUPTION: Stacker claimed > u32::max() reward slots");
                 if slots == 0 {
                     return None;
                 }
                 Some(NakamotoSignerEntry {
-                    signing_address,
+                    signing_key,
                     stacked_amt,
                     slots,
                 })
@@ -678,7 +684,7 @@ impl StacksChainState {
 
         // finally, we must sort the signer set: the signer participation bit vector depends
         //  on a consensus-critical ordering of the signer set.
-        signer_set.sort_by_key(|entry| entry.signing_address);
+        signer_set.sort_by_key(|entry| entry.signing_key);
 
         Some(signer_set)
     }
@@ -1180,7 +1186,15 @@ impl StacksChainState {
                     reward_cycle, i
                 ))
                 .to_owned()
-                .expect_principal();
+                .expect_buff(SIGNERS_PK_LEN);
+            // (buff 33) only enforces max size, not min size, so we need to do a len check
+            let pk_bytes = if signer.len() == SIGNERS_PK_LEN {
+                let mut bytes = [0; SIGNERS_PK_LEN];
+                bytes.copy_from_slice(signer.as_slice());
+                bytes
+            } else {
+                [0; SIGNERS_PK_LEN]
+            };
 
             debug!(
                 "Parsed PoX reward address";
@@ -1193,7 +1207,7 @@ impl StacksChainState {
                 reward_address,
                 amount_stacked: total_ustx,
                 stacker,
-                signer: Some(signer),
+                signer: Some(pk_bytes),
             })
         }
 
diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index 76b97633b2..7887aa474a 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -152,7 +152,7 @@
         pox-addr: { version: (buff 1), hashbytes: (buff 32) },
         total-ustx: uint,
         stacker: (optional principal),
-        signer: principal
+        signer: (buff 33)
     }
 )
 
@@ -265,7 +265,7 @@
                                               (reward-cycle uint)
                                               (amount-ustx uint)
                                               (stacker (optional principal))
-                                              (signer principal))
+                                              (signer (buff 33)))
     (let ((sz (get-reward-set-size reward-cycle)))
         (map-set reward-cycle-pox-address-list
             { reward-cycle: reward-cycle, index: sz }
@@ -358,7 +358,7 @@
                                                             (first-reward-cycle uint)
                                                             (num-cycles uint)
                                                             (stacker (optional principal))
-                                                            (signer principal)
+                                                            (signer (buff 33))
                                                             (amount-ustx uint)
                                                             (i uint))))
     (let ((reward-cycle (+ (get first-reward-cycle params) (get i params)))
@@ -403,7 +403,7 @@
                                                (num-cycles uint)
                                                (amount-ustx uint)
                                                (stacker principal)
-                                               (signer principal))
+                                               (signer (buff 33)))
   (let ((cycle-indexes (list u0 u1 u2 u3 u4 u5 u6 u7 u8 u9 u10 u11))
         (results (fold add-pox-addr-to-ith-reward-cycle cycle-indexes
                          { pox-addr: pox-addr, first-reward-cycle: first-reward-cycle, num-cycles: num-cycles,
@@ -586,7 +586,7 @@
       (try! (can-stack-stx pox-addr amount-ustx first-reward-cycle lock-period))
 
       ;; register the PoX address with the amount stacked
-      (let ((reward-set-indexes (try! (add-pox-addr-to-reward-cycles pox-addr first-reward-cycle lock-period amount-ustx tx-sender (try! (signer-key-buff-to-principal signer-key))))))
+      (let ((reward-set-indexes (try! (add-pox-addr-to-reward-cycles pox-addr first-reward-cycle lock-period amount-ustx tx-sender signer-key))))
           ;; add stacker record
          (map-set stacking-state
            { stacker: tx-sender }
@@ -674,8 +674,7 @@
   (let ((partial-stacked
          ;; fetch the partial commitments
          (unwrap! (map-get? partial-stacked-by-cycle { pox-addr: pox-addr, sender: tx-sender, reward-cycle: reward-cycle })
-                  (err ERR_STACKING_NO_SUCH_PRINCIPAL)))
-         (signer (try! (signer-key-buff-to-principal signer-key))))
+                  (err ERR_STACKING_NO_SUCH_PRINCIPAL))))
     ;; must be called directly by the tx-sender or by an allowed contract-caller
     (asserts! (check-caller-allowed)
               (err ERR_STACKING_PERMISSION_DENIED))
@@ -691,7 +690,7 @@
                      num-cycles: u1,
                      reward-set-indexes: (list),
                      stacker: none,
-                     signer: signer,
+                     signer: signer-key,
                      amount-ustx: amount-ustx,
                      i: u0 }))
            (pox-addr-index (unwrap-panic
@@ -1023,7 +1022,7 @@
 
       ;; register the PoX address with the amount stacked
       ;;   for the new cycles
-      (let ((extended-reward-set-indexes (try! (add-pox-addr-to-reward-cycles pox-addr first-extend-cycle extend-count amount-ustx tx-sender (try! (signer-key-buff-to-principal signer-key)))))
+      (let ((extended-reward-set-indexes (try! (add-pox-addr-to-reward-cycles pox-addr first-extend-cycle extend-count amount-ustx tx-sender signer-key)))
             (reward-set-indexes
                 ;; use the active stacker state and extend the existing reward-set-indexes
                 (let ((cur-cycle-index (- first-reward-cycle (get first-reward-cycle stacker-state)))
@@ -1274,9 +1273,3 @@
         (ok (map-set aggregate-public-keys reward-cycle aggregate-public-key))
     )
 )
-
-;; Converts a buff 33 to a standard principal, returning an error if it fails.
-;; *New in Stacks 3.0*
-(define-private (signer-key-buff-to-principal (signer-key (buff 33)))
-  (ok (unwrap! (principal-of? signer-key) (err ERR_INVALID_SIGNER_KEY)))
-)
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 591a4bb019..0313800de3 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -1482,7 +1482,7 @@ fn stack_stx_signer_key() {
     let signer_bytes =
         hex_bytes("03a0f9818ea8c14a827bb144aec9cfbaeba225af22be18ed78a2f298106f4e281b").unwrap();
     let signer_key = Secp256k1PublicKey::from_slice(&signer_bytes).unwrap();
-    let signer_key_val = Value::buff_from(signer_bytes).unwrap();
+    let signer_key_val = Value::buff_from(signer_bytes.clone()).unwrap();
 
     let txs = vec![make_pox_4_contract_call(
         stacker_key,
@@ -1517,10 +1517,7 @@ fn stack_stx_signer_key() {
         PoxAddress::try_from_pox_tuple(false, &pox_addr).unwrap(),
         reward_entry.reward_address
     );
-    assert_eq!(
-        reward_entry.signer.unwrap(),
-        StacksAddress::p2pkh(false, &signer_key).into(),
-    );
+    assert_eq!(&reward_entry.signer.unwrap(), &signer_bytes.as_slice());
 }
 
 #[test]
@@ -1543,11 +1540,11 @@ fn stack_extend_signer_key() {
 
     let signer_key = Secp256k1PublicKey::from_private(&signer_sk);
     let signer_bytes = signer_key.to_bytes_compressed();
-    let signer_key_val = Value::buff_from(signer_bytes).unwrap();
+    let signer_key_val = Value::buff_from(signer_bytes.clone()).unwrap();
 
     let signer_extend_key = Secp256k1PublicKey::from_private(&signer_extend_sk);
     let signer_extend_bytes = signer_extend_key.to_bytes_compressed();
-    let signer_extend_key_val = Value::buff_from(signer_extend_bytes).unwrap();
+    let signer_extend_key_val = Value::buff_from(signer_extend_bytes.clone()).unwrap();
 
     let next_reward_cycle = 1 + burnchain
         .block_height_to_reward_cycle(block_height)
@@ -1613,10 +1610,7 @@ fn stack_extend_signer_key() {
         PoxAddress::try_from_pox_tuple(false, &pox_addr).unwrap(),
         reward_entry.reward_address
     );
-    assert_eq!(
-        reward_entry.signer.unwrap(),
-        StacksAddress::p2pkh(false, &signer_key).into(),
-    );
+    assert_eq!(&reward_entry.signer.unwrap(), signer_bytes.as_slice(),);
 
     let mut reward_set = get_reward_set_entries_at(&mut peer, &latest_block, extend_cycle_ht);
     assert_eq!(reward_set.len(), 1);
@@ -1626,8 +1620,8 @@ fn stack_extend_signer_key() {
         reward_entry.reward_address
     );
     assert_eq!(
-        reward_entry.signer.unwrap(),
-        StacksAddress::p2pkh(false, &signer_extend_key).into(),
+        &reward_entry.signer.unwrap(),
+        signer_extend_bytes.as_slice(),
     );
 }
 
@@ -1658,7 +1652,7 @@ fn delegate_stack_stx_signer_key() {
     let signer_bytes =
         hex_bytes("03a0f9818ea8c14a827bb144aec9cfbaeba225af22be18ed78a2f298106f4e281b").unwrap();
     let signer_key = Secp256k1PublicKey::from_slice(&signer_bytes).unwrap();
-    let signer_key_val = Value::buff_from(signer_bytes).unwrap();
+    let signer_key_val = Value::buff_from(signer_bytes.clone()).unwrap();
 
     let min_ustx = get_stacking_minimum(&mut peer, &latest_block);
 
@@ -1731,10 +1725,7 @@ fn delegate_stack_stx_signer_key() {
         PoxAddress::try_from_pox_tuple(false, &pox_addr).unwrap(),
         reward_entry.reward_address
     );
-    assert_eq!(
-        reward_entry.signer.unwrap(),
-        StacksAddress::p2pkh(false, &signer_key).into(),
-    );
+    assert_eq!(&reward_entry.signer.unwrap(), signer_bytes.as_slice(),);
 }
 
 pub fn get_stacking_state_pox_4(
diff --git a/stackslib/src/chainstate/stacks/boot/signers_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_tests.rs
index c5a36bae2b..03c4c6527b 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_tests.rs
@@ -23,9 +23,10 @@ use clarity::vm::Value::Principal;
 use clarity::vm::{ClarityName, ClarityVersion, ContractName, Value};
 use stacks_common::address::AddressHashMode;
 use stacks_common::types::chainstate::{
-    BurnchainHeaderHash, StacksBlockId, StacksPrivateKey, StacksPublicKey,
+    BurnchainHeaderHash, StacksAddress, StacksBlockId, StacksPrivateKey, StacksPublicKey,
 };
 use stacks_common::types::PublicKey;
+use stacks_common::util::secp256k1::Secp256k1PublicKey;
 
 use crate::burnchains::Burnchain;
 use crate::chainstate::burn::db::sortdb::SortitionDB;
@@ -92,8 +93,30 @@ fn signers_get_signer_keys_from_stackerdb() {
 
     let private_key = peer.config.private_key.clone();
 
-    let signer_1_addr = key_to_stacks_addr(&stacker_1.signer_private_key);
-    let signer_2_addr = key_to_stacks_addr(&stacker_2.signer_private_key);
+    let mut expected_signers: Vec<_> =
+        [&stacker_1.signer_private_key, &stacker_2.signer_private_key]
+            .iter()
+            .map(|sk| {
+                let pk = Secp256k1PublicKey::from_private(sk);
+                let pk_bytes = pk.to_bytes_compressed();
+                let signer_addr = StacksAddress::p2pkh(false, &pk);
+                let stackerdb_entry = TupleData::from_data(vec![
+                    ("signer".into(), PrincipalData::from(signer_addr).into()),
+                    ("num-slots".into(), Value::UInt(2)),
+                ])
+                .unwrap();
+                (pk_bytes, stackerdb_entry)
+            })
+            .collect();
+    // should be sorted by the pk bytes
+    expected_signers.sort_by_key(|x| x.0.clone());
+    let expected_stackerdb_slots = Value::cons_list_unsanitized(
+        expected_signers
+            .into_iter()
+            .map(|(_pk, entry)| Value::from(entry))
+            .collect(),
+    )
+    .unwrap();
 
     let signers = readonly_call(
         &mut peer,
@@ -104,32 +127,7 @@ fn signers_get_signer_keys_from_stackerdb() {
     )
     .expect_result_ok();
 
-    assert_eq!(
-        signers,
-        Value::cons_list_unsanitized(vec![
-            Value::Tuple(
-                TupleData::from_data(vec![
-                    (
-                        "signer".into(),
-                        Principal(PrincipalData::from(signer_2_addr)),
-                    ),
-                    ("num-slots".into(), Value::UInt(2)),
-                ])
-                .unwrap()
-            ),
-            Value::Tuple(
-                TupleData::from_data(vec![
-                    (
-                        "signer".into(),
-                        Principal(PrincipalData::from(signer_1_addr)),
-                    ),
-                    ("num-slots".into(), Value::UInt(2)),
-                ])
-                .unwrap()
-            )
-        ])
-        .unwrap()
-    );
+    assert_eq!(signers, expected_stackerdb_slots);
 }
 
 fn prepare_signers_test<'a>(

From 0589cf7539a539bedf149b88749a1c02cd9b9e7e Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Thu, 25 Jan 2024 13:42:11 -0600
Subject: [PATCH 0487/1166] test: unit tests for make_signer_set

---
 .../chainstate/stacks/boot/signers_tests.rs   | 111 +++++++++++++++++-
 1 file changed, 110 insertions(+), 1 deletion(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_tests.rs
index 03c4c6527b..57029ed738 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_tests.rs
@@ -28,6 +28,7 @@ use stacks_common::types::chainstate::{
 use stacks_common::types::PublicKey;
 use stacks_common::util::secp256k1::Secp256k1PublicKey;
 
+use super::{RawRewardSetEntry, SIGNERS_PK_LEN};
 use crate::burnchains::Burnchain;
 use crate::chainstate::burn::db::sortdb::SortitionDB;
 use crate::chainstate::burn::BlockSnapshot;
@@ -43,7 +44,8 @@ use crate::chainstate::stacks::boot::pox_4_tests::{
 use crate::chainstate::stacks::boot::test::{
     instantiate_pox_peer_with_epoch, key_to_stacks_addr, make_pox_4_lockup, with_sortdb,
 };
-use crate::chainstate::stacks::boot::SIGNERS_NAME;
+use crate::chainstate::stacks::boot::{NakamotoSignerEntry, SIGNERS_NAME};
+use crate::chainstate::stacks::db::StacksChainState;
 use crate::chainstate::stacks::index::marf::MarfConnection;
 use crate::chainstate::stacks::{
     StacksTransaction, StacksTransactionSigner, TenureChangeCause, TransactionAuth,
@@ -54,6 +56,113 @@ use crate::core::BITCOIN_REGTEST_FIRST_BLOCK_HASH;
 use crate::net::test::{TestEventObserver, TestPeer};
 use crate::util_lib::boot::{boot_code_addr, boot_code_id, boot_code_test_addr};
 
+#[test]
+fn make_signer_units() {
+    assert_eq!(StacksChainState::make_signer_set(100, &[]), None);
+
+    fn stub_entry(signer: u64, amount: u128) -> RawRewardSetEntry {
+        let mut signer_bytes = [0; SIGNERS_PK_LEN];
+        signer_bytes[0..8].copy_from_slice(&signer.to_be_bytes());
+        RawRewardSetEntry {
+            signer: Some(signer_bytes),
+            stacker: None,
+            reward_address: PoxAddress::standard_burn_address(false),
+            amount_stacked: amount,
+        }
+    }
+    fn stub_out(signer: u64, amount: u128, slots: u32) -> NakamotoSignerEntry {
+        let mut signer_bytes = [0; SIGNERS_PK_LEN];
+        signer_bytes[0..8].copy_from_slice(&signer.to_be_bytes());
+        NakamotoSignerEntry {
+            signing_key: signer_bytes,
+            stacked_amt: amount,
+            slots,
+        }
+    }
+
+    fn perform_test(threshold: u128, input: &[(u64, u128)], expected: &[(u64, u128, u32)]) {
+        let in_entries: Vec<_> = input
+            .iter()
+            .map(|(signer, amount)| stub_entry(*signer, *amount))
+            .collect();
+        let expected: Vec<_> = expected
+            .iter()
+            .map(|(signer, amount, slots)| stub_out(*signer, *amount, *slots))
+            .collect();
+        assert_eq!(
+            StacksChainState::make_signer_set(threshold, &in_entries),
+            Some(expected)
+        );
+    }
+
+    let threshold = 10_000;
+    let input_set = [
+        (2, 10_001),
+        (0, 10_000),
+        (1, 10_000),
+        (0, 30_000),
+        (2, 9_999),
+        (1, 1),
+    ];
+    let expected = [(0, 40_000, 4), (1, 10_001, 1), (2, 20_000, 2)];
+
+    perform_test(threshold, &input_set, &expected);
+
+    let threshold = 10_000;
+    let input_set = [
+        (2, 10_001),
+        (0, 10_000),
+        (1, 10_000),
+        (0, 30_000),
+        (2, 9_999),
+        (1, 1),
+        (3, 9_999),
+    ];
+    let expected = [(0, 40_000, 4), (1, 10_001, 1), (2, 20_000, 2)];
+
+    perform_test(threshold, &input_set, &expected);
+}
+
+#[test]
+#[should_panic]
+fn make_signer_sanity_panic_0() {
+    let bad_set = [
+        RawRewardSetEntry {
+            reward_address: PoxAddress::standard_burn_address(false),
+            amount_stacked: 10,
+            stacker: None,
+            signer: Some([0; SIGNERS_PK_LEN]),
+        },
+        RawRewardSetEntry {
+            reward_address: PoxAddress::standard_burn_address(false),
+            amount_stacked: 10,
+            stacker: None,
+            signer: None,
+        },
+    ];
+    StacksChainState::make_signer_set(5, &bad_set);
+}
+
+#[test]
+#[should_panic]
+fn make_signer_sanity_panic_1() {
+    let bad_set = [
+        RawRewardSetEntry {
+            reward_address: PoxAddress::standard_burn_address(false),
+            amount_stacked: 10,
+            stacker: None,
+            signer: None,
+        },
+        RawRewardSetEntry {
+            reward_address: PoxAddress::standard_burn_address(false),
+            amount_stacked: 10,
+            stacker: None,
+            signer: Some([0; SIGNERS_PK_LEN]),
+        },
+    ];
+    StacksChainState::make_signer_set(5, &bad_set);
+}
+
 #[test]
 fn signers_get_config() {
     let (burnchain, mut peer, keys, latest_block, ..) = prepare_pox4_test(function_name!(), None);

From 2652810f2651311303ff7f689bda712657597382 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Thu, 25 Jan 2024 13:15:07 -0800
Subject: [PATCH 0488/1166] Cleanup expects inside events.rs

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 libsigner/src/events.rs | 36 ++++++++++++++++++------------------
 1 file changed, 18 insertions(+), 18 deletions(-)

diff --git a/libsigner/src/events.rs b/libsigner/src/events.rs
index 4e914e13da..04bc0a1efd 100644
--- a/libsigner/src/events.rs
+++ b/libsigner/src/events.rs
@@ -378,9 +378,9 @@ impl EventReceiver for SignerEventReceiver {
                     request.url()
                 );
 
-                request
-                    .respond(HttpResponse::empty(200u16))
-                    .expect("response failed");
+                if let Err(e) = request.respond(HttpResponse::empty(200u16)) {
+                    error!("Failed to respond to request: {:?}", &e);
+                }
                 Err(EventError::UnrecognizedEvent(url))
             }
         })?
@@ -447,9 +447,9 @@ fn process_stackerdb_event(
     if let Err(e) = request.as_reader().read_to_string(&mut body) {
         error!("Failed to read body: {:?}", &e);
 
-        request
-            .respond(HttpResponse::empty(200u16))
-            .expect("response failed");
+        if let Err(e) = request.respond(HttpResponse::empty(200u16)) {
+            error!("Failed to respond to request: {:?}", &e);
+        };
         return Err(EventError::MalformedRequest(format!(
             "Failed to read body: {:?}",
             &e
@@ -480,15 +480,15 @@ fn process_stackerdb_event(
             local_addr,
             event.contract_id
         );
-        request
-            .respond(HttpResponse::empty(200u16))
-            .expect("response failed");
+        if let Err(e) = request.respond(HttpResponse::empty(200u16)) {
+            error!("Failed to respond to request: {:?}", &e);
+        }
         return Err(EventError::UnrecognizedStackerDBContract(event.contract_id));
     };
 
-    request
-        .respond(HttpResponse::empty(200u16))
-        .expect("response failed");
+    if let Err(e) = request.respond(HttpResponse::empty(200u16)) {
+        error!("Failed to respond to request: {:?}", &e);
+    }
 
     Ok(signer_event)
 }
@@ -500,9 +500,9 @@ fn process_proposal_response(mut request: HttpRequest) -> Result<SignerEvent, Ev
     if let Err(e) = request.as_reader().read_to_string(&mut body) {
         error!("Failed to read body: {:?}", &e);
 
-        request
-            .respond(HttpResponse::empty(200u16))
-            .expect("response failed");
+        if let Err(e) = request.respond(HttpResponse::empty(200u16)) {
+            error!("Failed to respond to request: {:?}", &e);
+        }
         return Err(EventError::MalformedRequest(format!(
             "Failed to read body: {:?}",
             &e
@@ -512,9 +512,9 @@ fn process_proposal_response(mut request: HttpRequest) -> Result<SignerEvent, Ev
     let event: BlockValidateResponse = serde_json::from_slice(body.as_bytes())
         .map_err(|e| EventError::Deserialize(format!("Could not decode body to JSON: {:?}", &e)))?;
 
-    request
-        .respond(HttpResponse::empty(200u16))
-        .expect("response failed");
+    if let Err(e) = request.respond(HttpResponse::empty(200u16)) {
+        error!("Failed to respond to request: {:?}", &e);
+    }
 
     Ok(SignerEvent::BlockValidationResponse(event))
 }

From 0969079197e0ecac5b00925593c255b7ad824e76 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Thu, 25 Jan 2024 13:16:15 -0800
Subject: [PATCH 0489/1166] Cleanup processing operation results

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 libsigner/src/events.rs      |   7 ++
 stacks-signer/src/runloop.rs | 176 ++++++++++++++++++++++++-----------
 2 files changed, 131 insertions(+), 52 deletions(-)

diff --git a/libsigner/src/events.rs b/libsigner/src/events.rs
index 04bc0a1efd..702bee7302 100644
--- a/libsigner/src/events.rs
+++ b/libsigner/src/events.rs
@@ -120,6 +120,8 @@ pub enum RejectCode {
     SignedRejection,
     /// Invalid signature hash
     InvalidSignatureHash,
+    /// Insufficient signers agreed to sign the block
+    InsufficientSigners(Vec<u32>),
 }
 
 impl std::fmt::Display for RejectCode {
@@ -130,6 +132,11 @@ impl std::fmt::Display for RejectCode {
                 write!(f, "A threshold number of signers rejected the block.")
             }
             RejectCode::InvalidSignatureHash => write!(f, "The signature hash was invalid."),
+            RejectCode::InsufficientSigners(malicious_signers) => write!(
+                f,
+                "Insufficient signers agreed to sign the block. The following signers are malicious: {:?}",
+                malicious_signers
+            ),
         }
     }
 }
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index e7b7ae008c..9046898396 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -29,14 +29,14 @@ use slog::{slog_debug, slog_error, slog_info, slog_warn};
 use stacks_common::codec::{read_next, StacksMessageCodec};
 use stacks_common::util::hash::{Sha256Sum, Sha512Trunc256Sum};
 use stacks_common::{debug, error, info, warn};
-use wsts::common::MerkleRoot;
+use wsts::common::{MerkleRoot, Signature};
 use wsts::curve::ecdsa;
 use wsts::curve::keys::PublicKey;
 use wsts::net::{Message, NonceRequest, Packet, SignatureShareRequest};
 use wsts::state_machine::coordinator::fire::Coordinator as FireCoordinator;
 use wsts::state_machine::coordinator::{Config as CoordinatorConfig, Coordinator};
 use wsts::state_machine::signer::Signer;
-use wsts::state_machine::{OperationResult, PublicKeys};
+use wsts::state_machine::{OperationResult, PublicKeys, SignError};
 use wsts::v2;
 
 use crate::client::{retry_with_exponential_backoff, ClientError, StackerDB, StacksClient};
@@ -381,10 +381,14 @@ impl<C: Coordinator> RunLoop<C> {
                 (vec![], vec![])
             });
 
+        if !operation_results.is_empty() {
+            // We have finished a signing or DKG round. Update state accordingly
+            self.state = State::Idle;
+            self.process_operation_results(&operation_results);
+            self.send_operation_results(res, operation_results);
+        }
         self.send_outbound_messages(signer_outbound_messages);
         self.send_outbound_messages(coordinator_outbound_messages);
-        self.send_block_response_messages(&operation_results);
-        self.send_operation_results(res, operation_results);
     }
 
     /// Validate a signature share request, updating its message where appropriate.
@@ -532,76 +536,144 @@ impl<C: Coordinator> RunLoop<C> {
         }
     }
 
-    /// Extract block proposals from signature results and broadcast them to the stackerdb slot
-    fn send_block_response_messages(&mut self, operation_results: &[OperationResult]) {
-        let Some(aggregate_public_key) = &self.coordinator.get_aggregate_public_key() else {
-            debug!("No aggregate public key set. Cannot validate results. Ignoring signature results...");
-            return;
-        };
-        //Deserialize the signature result and broadcast an appropriate Reject or Approval message to stackerdb
+    /// Processes the operation results, broadcasting block acceptance or rejection messages
+    /// and DKG vote results accordingly
+    fn process_operation_results(&mut self, operation_results: &[OperationResult]) {
         for operation_result in operation_results {
             // Signers only every trigger non-taproot signing rounds over blocks. Ignore SignTaproot results
-            if let OperationResult::Sign(signature) = operation_result {
-                let message = self.coordinator.get_message();
-                if !signature.verify(aggregate_public_key, &message) {
-                    warn!("Received an invalid signature result.");
-                    continue;
+            match operation_result {
+                OperationResult::Sign(signature) => {
+                    self.process_signature(signature);
                 }
-                // This jankiness is because a coordinator could have signed a rejection we need to find the underlying block hash
-                let block_hash_bytes = if message.len() > 32 {
-                    &message[..32]
-                } else {
-                    &message
-                };
-                let Some(block_hash) = Sha512Trunc256Sum::from_bytes(block_hash_bytes) else {
-                    debug!("Received a signature result for a signature over a non-block. Nothing to broadcast.");
-                    continue;
-                };
-                let Some(block_info) = self.blocks.remove(&block_hash) else {
-                    debug!("Received a signature result for a block we have not seen before. Ignoring...");
-                    continue;
-                };
+                OperationResult::SignTaproot(_) => {
+                    debug!("Received a signature result for a taproot signature. Nothing to broadcast as we currently sign blocks with a FROST signature.");
+                }
+                OperationResult::Dkg(_point) => {
+                    // TODO: cast the aggregate public key for the latest round here
+                }
+                OperationResult::SignError(e) => {
+                    self.process_sign_error(e);
+                }
+                OperationResult::DkgError(e) => {
+                    warn!("Received a DKG error: {:?}", e);
+                }
+            }
+        }
+    }
 
-                // Update the block signature hash with what the signers produced.
-                let mut block = block_info.block;
-                block.header.signer_signature = ThresholdSignature(signature.clone());
+    /// Process a signature from a signing round by deserializing the signature and
+    /// broadcasting an appropriate Reject or Approval message to stackerdb
+    fn process_signature(&mut self, signature: &Signature) {
+        //Deserialize the signature result and broadcast an appropriate Reject or Approval message to stackerdb
+        //TODO: should this retreive the aggregate public key from the stacks node instead as it might have changed since this round commenced?
+        // Or should we broadcast it anyway and rely on the miners to repropose a block if the key changed?
+        let Some(aggregate_public_key) = &self.coordinator.get_aggregate_public_key() else {
+            debug!("No aggregate public key set. Cannot validate signature...");
+            return;
+        };
+        let message = self.coordinator.get_message();
+        // This jankiness is because a coordinator could have signed a rejection we need to find the underlying block hash
+        let block_hash_bytes = if message.len() > 32 {
+            &message[..32]
+        } else {
+            &message
+        };
+        let Some(block_hash) = Sha512Trunc256Sum::from_bytes(block_hash_bytes) else {
+            debug!("Received a signature result for a signature over a non-block. Nothing to broadcast.");
+            return;
+        };
+        let Some(block_info) = self.blocks.remove(&block_hash) else {
+            debug!("Received a signature result for a block we have not seen before. Ignoring...");
+            return;
+        };
+        // This signature is no longer valid. Do not broadcast it.
+        if !signature.verify(aggregate_public_key, &message) {
+            warn!("Received an invalid signature result across the block. Do not broadcast it.");
+            // TODO: should we reinsert it and trigger a sign round across the block again?
+            return;
+        }
+        // Update the block signature hash with what the signers produced.
+        let mut block = block_info.block;
+        block.header.signer_signature = ThresholdSignature(signature.clone());
 
-                let block_submission = if message == block_hash.0.to_vec() {
-                    // we agreed to sign the block hash. Return an approval message
-                    BlockResponse::Accepted(block).into()
-                } else {
-                    // We signed a rejection message. Return a rejection message
-                    BlockRejection::new(block, RejectCode::SignedRejection).into()
-                };
+        let block_submission = if message == block_hash.0.to_vec() {
+            // we agreed to sign the block hash. Return an approval message
+            BlockResponse::Accepted(block).into()
+        } else {
+            // We signed a rejection message. Return a rejection message
+            BlockRejection::new(block, RejectCode::SignedRejection).into()
+        };
 
+        // Submit signature result to miners to observe
+        if let Err(e) = self
+            .stackerdb
+            .send_message_with_retry(self.signing_round.signer_id, block_submission)
+        {
+            warn!("Failed to send block submission to stacker-db: {:?}", e);
+        }
+    }
+
+    /// Process a sign error from a signing round, broadcasting a rejection message to stackerdb accordingly
+    fn process_sign_error(&mut self, e: &SignError) {
+        warn!("Received a signature error: {:?}", e);
+        match e {
+            SignError::NonceTimeout(_valid_signers, _malicious_signers) => {
+                //TODO: report these malicious signers
+                debug!("Received a nonce timeout.");
+            }
+            SignError::InsufficientSigners(malicious_signers) => {
+                let message = self.coordinator.get_message();
+                let block = read_next::<NakamotoBlock, _>(&mut &message[..]).ok().unwrap_or({
+                    // This is not a block so maybe its across its hash
+                    // This jankiness is because a coordinator could have signed a rejection we need to find the underlying block hash
+                    let block_hash_bytes = if message.len() > 32 {
+                        &message[..32]
+                    } else {
+                        &message
+                    };
+                    let Some(block_hash) = Sha512Trunc256Sum::from_bytes(block_hash_bytes) else {
+                        debug!("Received a signature result for a signature over a non-block. Nothing to broadcast.");
+                        return;
+                    };
+                    let Some(block_info) = self.blocks.remove(&block_hash) else {
+                        debug!("Received a signature result for a block we have not seen before. Ignoring...");
+                        return;
+                    };
+                    block_info.block
+                });
+                // We don't have enough signers to sign the block. Broadcast a rejection
+                let block_rejection = BlockRejection::new(
+                    block,
+                    RejectCode::InsufficientSigners(malicious_signers.clone()),
+                );
                 // Submit signature result to miners to observe
                 if let Err(e) = self
                     .stackerdb
-                    .send_message_with_retry(self.signing_round.signer_id, block_submission)
+                    .send_message_with_retry(self.signing_round.signer_id, block_rejection.into())
                 {
                     warn!("Failed to send block submission to stacker-db: {:?}", e);
                 }
             }
+            SignError::Aggregator(e) => {
+                warn!("Received an aggregator error: {:?}", e);
+            }
         }
+        // TODO: should reattempt to sign the block here or should we just broadcast a rejection or do nothing and wait for the signers to propose a new block?
     }
 
-    /// Send any operation results across the provided channel, updating the state accordingly
+    /// Send any operation results across the provided channel
     fn send_operation_results(
         &mut self,
         res: Sender<Vec<OperationResult>>,
         operation_results: Vec<OperationResult>,
     ) {
         let nmb_results = operation_results.len();
-        if nmb_results > 0 {
-            // We finished our command. Update the state
-            self.state = State::Idle;
-            match res.send(operation_results) {
-                Ok(_) => {
-                    debug!("Successfully sent {} operation result(s)", nmb_results)
-                }
-                Err(e) => {
-                    warn!("Failed to send operation results: {:?}", e);
-                }
+        match res.send(operation_results) {
+            Ok(_) => {
+                debug!("Successfully sent {} operation result(s)", nmb_results)
+            }
+            Err(e) => {
+                warn!("Failed to send operation results: {:?}", e);
             }
         }
     }

From b5a2a5a5d20ff8404b7995a3641d3fce6d0239f8 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Thu, 25 Jan 2024 13:27:24 -0800
Subject: [PATCH 0490/1166] Replace signature_hash with signer_signature_hash
 and rename signature_hash

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/runloop.rs                  | 29 ++++++++++---------
 stackslib/src/chainstate/nakamoto/mod.rs      |  6 ++--
 testnet/stacks-node/src/mockamoto.rs          |  2 +-
 .../stacks-node/src/nakamoto_node/miner.rs    |  2 +-
 testnet/stacks-node/src/tests/signer.rs       |  4 +--
 5 files changed, 22 insertions(+), 21 deletions(-)

diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 9046898396..24857adacd 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -139,7 +139,6 @@ pub struct RunLoop<C> {
 impl<C: Coordinator> RunLoop<C> {
     /// Initialize the signer, reading the stacker-db state and setting the aggregate public key
     fn initialize(&mut self) -> Result<(), ClientError> {
-        // TODO: update to read stacker db to get state.
         // Check if the aggregate key is set in the pox contract
         if let Some(key) = self.stacks_client.get_aggregate_public_key()? {
             debug!("Aggregate public key is set: {:?}", key);
@@ -187,7 +186,7 @@ impl<C: Coordinator> RunLoop<C> {
                 is_taproot,
                 merkle_root,
             } => {
-                let Ok(hash) = block.header.signature_hash() else {
+                let Ok(hash) = block.header.signer_signature_hash() else {
                     error!("Failed to sign block. Invalid signature hash.");
                     return false;
                 };
@@ -259,7 +258,7 @@ impl<C: Coordinator> RunLoop<C> {
         let transactions = &self.transactions;
         let (block_info, hash) = match block_validate_response {
             BlockValidateResponse::Ok(block_validate_ok) => {
-                let Ok(hash) = block_validate_ok.block.header.signature_hash() else {
+                let Ok(hash) = block_validate_ok.block.header.signer_signature_hash() else {
                     self.broadcast_signature_hash_rejection(block_validate_ok.block);
                     return;
                 };
@@ -272,7 +271,7 @@ impl<C: Coordinator> RunLoop<C> {
             }
             BlockValidateResponse::Reject(block_validate_reject) => {
                 // There is no point in triggering a sign round for this block if validation failed from the stacks node
-                let Ok(hash) = block_validate_reject.block.header.signature_hash() else {
+                let Ok(hash) = block_validate_reject.block.header.signer_signature_hash() else {
                     self.broadcast_signature_hash_rejection(block_validate_reject.block);
                     return;
                 };
@@ -346,7 +345,7 @@ impl<C: Coordinator> RunLoop<C> {
     /// Handle proposed blocks submitted by the miners to stackerdb
     fn handle_proposed_blocks(&mut self, blocks: Vec<NakamotoBlock>) {
         for block in blocks {
-            let Ok(hash) = block.header.signature_hash() else {
+            let Ok(hash) = block.header.signer_signature_hash() else {
                 self.broadcast_signature_hash_rejection(block);
                 continue;
             };
@@ -382,7 +381,8 @@ impl<C: Coordinator> RunLoop<C> {
             });
 
         if !operation_results.is_empty() {
-            // We have finished a signing or DKG round. Update state accordingly
+            // We have finished a signing or DKG round, either successfully or due to error.
+            // Regardless of the why, update our state to Idle as we should not expect the operation to continue.
             self.state = State::Idle;
             self.process_operation_results(&operation_results);
             self.send_operation_results(res, operation_results);
@@ -421,13 +421,16 @@ impl<C: Coordinator> RunLoop<C> {
                 true
             }
             Some(None) => {
-                // We never agreed to sign this block. Reject it. This can happen if the coordinator received enough votes to sign yes or no on a block before we received validation from the stacks node.
+                // We never agreed to sign this block. Reject it.
+                // This can happen if the coordinator received enough votes to sign yes
+                // or no on a block before we received validation from the stacks node.
                 debug!("Received a signature share request for a block we never agreed to sign. Ignore it.");
                 false
             }
             None => {
-                // We will only sign across block hashes or block hashes + b'n' byte for blocks we have seen a Nonce Request for (and subsequent validation)
-                // We are missing the context here necessary to make a decision therefore we outright reject the block
+                // We will only sign across block hashes or block hashes + b'n' byte for
+                // blocks we have seen a Nonce Request for (and subsequent validation)
+                // We are missing the context here necessary to make a decision. Reject the block
                 debug!("Received a signature share request from an unknown block. Reject it.");
                 false
             }
@@ -444,7 +447,7 @@ impl<C: Coordinator> RunLoop<C> {
             debug!("Received a nonce request for an unknown message stream. Reject it.");
             return false;
         };
-        let Ok(hash) = block.header.signature_hash() else {
+        let Ok(hash) = block.header.signer_signature_hash() else {
             debug!(
                 "Received a nonce request for a block with an invalid signature hash. Reject it"
             );
@@ -453,7 +456,7 @@ impl<C: Coordinator> RunLoop<C> {
         let transactions = &self.transactions;
         let Some(block_info) = self.blocks.get_mut(&hash) else {
             // We have not seen this block before. Cache it. Send a RPC to the stacks node to validate it.
-            debug!("We have received a block sign request for a block we have not seen before. Cache request and submit the block for validation...");
+            debug!("We have received a block sign request for a block we have not seen before. Cache the nonce request and submit the block for validation...");
             // Store the block in our cache
             self.blocks.insert(
                 hash,
@@ -564,9 +567,7 @@ impl<C: Coordinator> RunLoop<C> {
     /// Process a signature from a signing round by deserializing the signature and
     /// broadcasting an appropriate Reject or Approval message to stackerdb
     fn process_signature(&mut self, signature: &Signature) {
-        //Deserialize the signature result and broadcast an appropriate Reject or Approval message to stackerdb
-        //TODO: should this retreive the aggregate public key from the stacks node instead as it might have changed since this round commenced?
-        // Or should we broadcast it anyway and rely on the miners to repropose a block if the key changed?
+        // Deserialize the signature result and broadcast an appropriate Reject or Approval message to stackerdb
         let Some(aggregate_public_key) = &self.coordinator.get_aggregate_public_key() else {
             debug!("No aggregate public key set. Cannot validate signature...");
             return;
diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index 23662cab50..074018d756 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -386,7 +386,7 @@ impl StacksMessageCodec for NakamotoBlockHeader {
 impl NakamotoBlockHeader {
     /// Calculate the message digest for miners to sign.
     /// This includes all fields _except_ the signatures.
-    pub fn signature_hash(&self) -> Result<Sha512Trunc256Sum, CodecError> {
+    pub fn miner_signature_hash(&self) -> Result<Sha512Trunc256Sum, CodecError> {
         let mut hasher = Sha512_256::new();
         let fd = &mut hasher;
         write_next(fd, &self.version)?;
@@ -416,7 +416,7 @@ impl NakamotoBlockHeader {
     }
 
     pub fn recover_miner_pk(&self) -> Option<StacksPublicKey> {
-        let signed_hash = self.signature_hash().ok()?;
+        let signed_hash = self.miner_signature_hash().ok()?;
         let recovered_pk =
             StacksPublicKey::recover_to_pubkey(signed_hash.bits(), &self.miner_signature).ok()?;
 
@@ -438,7 +438,7 @@ impl NakamotoBlockHeader {
 
     /// Sign the block header by the miner
     pub fn sign_miner(&mut self, privk: &StacksPrivateKey) -> Result<(), ChainstateError> {
-        let sighash = self.signature_hash()?.0;
+        let sighash = self.miner_signature_hash()?.0;
         let sig = privk
             .sign(&sighash)
             .map_err(|se| net_error::SigningError(se.to_string()))?;
diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index 3227b50ec0..bb92048b00 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -976,7 +976,7 @@ impl MockamotoNode {
 
         let miner_signature = self
             .miner_key
-            .sign(block.header.signature_hash().unwrap().as_bytes())
+            .sign(block.header.miner_signature_hash().unwrap().as_bytes())
             .unwrap();
 
         block.header.miner_signature = miner_signature;
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index 7aec8ce6bb..ffa50de4a3 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -565,7 +565,7 @@ impl BlockMinerThread {
             .sign(
                 block
                     .header
-                    .signature_hash()
+                    .miner_signature_hash()
                     .map_err(|_| NakamotoNodeError::SigningError("Could not create sighash"))?
                     .as_bytes(),
             )
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index a62b53985e..00397b4967 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -384,7 +384,7 @@ fn stackerdb_dkg_sign() {
     // The block is invalid so the signers should return a signature across its hash + b'n'
     let mut msg = block
         .header
-        .signature_hash()
+        .signer_signature_hash()
         .expect("Failed to get signature hash")
         .0
         .to_vec();
@@ -646,7 +646,7 @@ fn stackerdb_block_proposal() {
     };
     let signature_hash = proposed_block
         .header
-        .signature_hash()
+        .signer_signature_hash()
         .expect("Unable to retrieve signature hash from proposed block");
     assert!(
         signature.verify(&aggregate_public_key, signature_hash.0.as_slice()),

From 5510b17695f7a12479d6b8ac986a6f9fbe877126 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Thu, 25 Jan 2024 16:05:30 -0600
Subject: [PATCH 0491/1166] set MAX_WRITES, CHUNK_SIZE in .signers

---
 stackslib/src/chainstate/stacks/boot/signers.clar | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers.clar b/stackslib/src/chainstate/stacks/boot/signers.clar
index 3a78605778..42edf8ef0e 100644
--- a/stackslib/src/chainstate/stacks/boot/signers.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers.clar
@@ -1,11 +1,12 @@
 (define-data-var last-set-cycle uint u0)
 (define-data-var stackerdb-signer-slots (list 4000 { signer: principal, num-slots: uint }) (list))
+(define-constant MAX_WRITES u340282366920938463463374607431768211455)
+(define-constant CHUNK_SIZE (* u2 u1024 u1024))
 
 (define-private (stackerdb-set-signer-slots 
                    (signer-slots (list 4000 { signer: principal, num-slots: uint }))
                    (reward-cycle uint))
 	(begin
-		(print signer-slots)
         (var-set last-set-cycle reward-cycle)
 		(ok (var-set stackerdb-signer-slots signer-slots))))
 
@@ -14,9 +15,9 @@
 
 (define-read-only (stackerdb-get-config)
 	(ok
-		{ chunk-size: u4096,
+		{ chunk-size: CHUNK_SIZE,
 		  write-freq: u0,
-		  max-writes: u4096,
+		  max-writes: MAX_WRITES,
 		  max-neighbors: u32,
 		  hint-replicas: (list) }
 	))

From a12ca4b61e5761ad7368cb41f0116dc67a7812f4 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Fri, 26 Jan 2024 09:42:02 -0600
Subject: [PATCH 0492/1166] chore: add CHANGELOG and fix test

---
 CHANGELOG.md                            | 6 ++++++
 testnet/stacks-node/src/tests/signer.rs | 4 +++-
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5bae35428f..71827d9d5f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -12,6 +12,12 @@ and this project adheres to the versioning scheme outlined in the [README.md](RE
 - New `/new_pox_anchor` endpoint for broadcasting PoX anchor block processing.
 - Stacker bitvec in NakamotoBlock
 
+### Modified
+
+- `pox-4.aggregation-commit` contains a signing-key parameter (like
+  `stack-stx` and `stack-extend`), the signing-key parameter is removed from
+  `delegate-*` functions.
+
 ## [2.4.0.0.4]
 
 This is a high-priority hotfix that addresses a bug in transaction processing which
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index 0a2c78af71..e12714955d 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -13,6 +13,7 @@ use stacks::chainstate::stacks::boot::MINERS_NAME;
 use stacks::chainstate::stacks::{StacksPrivateKey, ThresholdSignature};
 use stacks::net::api::postblock_proposal::BlockValidateResponse;
 use stacks::util_lib::boot::boot_code_id;
+use stacks_common::bitvec::BitVec;
 use stacks_common::types::chainstate::{
     ConsensusHash, StacksAddress, StacksBlockId, StacksPublicKey, TrieHash,
 };
@@ -365,7 +366,8 @@ fn stackerdb_dkg_sign() {
         tx_merkle_root: Sha512Trunc256Sum([0x06; 32]),
         state_index_root: TrieHash([0x07; 32]),
         miner_signature: MessageSignature::empty(),
-        signer_signature: ThresholdSignature::mock(),
+        signer_signature: ThresholdSignature::empty(),
+        signer_bitvec: BitVec::zeros(1).unwrap(),
     };
     let mut block = NakamotoBlock {
         header,

From 99730e0c66699912cd011944845436a8725c55fe Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Fri, 26 Jan 2024 10:18:09 -0600
Subject: [PATCH 0493/1166] remove unused struct

---
 testnet/stacks-node/src/event_dispatcher.rs | 11 +----------
 1 file changed, 1 insertion(+), 10 deletions(-)

diff --git a/testnet/stacks-node/src/event_dispatcher.rs b/testnet/stacks-node/src/event_dispatcher.rs
index a27dda6c46..faa333e093 100644
--- a/testnet/stacks-node/src/event_dispatcher.rs
+++ b/testnet/stacks-node/src/event_dispatcher.rs
@@ -17,7 +17,7 @@ use stacks::chainstate::burn::ConsensusHash;
 use stacks::chainstate::coordinator::BlockEventDispatcher;
 use stacks::chainstate::nakamoto::NakamotoBlock;
 use stacks::chainstate::stacks::address::PoxAddress;
-use stacks::chainstate::stacks::boot::{NakamotoSignerEntry, RewardSet};
+use stacks::chainstate::stacks::boot::RewardSet;
 use stacks::chainstate::stacks::db::accounts::MinerReward;
 use stacks::chainstate::stacks::db::unconfirmed::ProcessedUnconfirmedState;
 use stacks::chainstate::stacks::db::{MinerRewardInfo, StacksHeaderInfo};
@@ -105,15 +105,6 @@ pub struct MinedNakamotoBlockEvent {
     pub tx_events: Vec<TransactionEvent>,
 }
 
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct PoxAnchorBlockEvent {
-    /// the StacksBlockId of the PoX anchor block
-    pub block_id: String,
-    pub reward_cycle: u64,
-    pub total_stx_stacked: u128,
-    pub signer_set: Vec<NakamotoSignerEntry>,
-}
-
 impl EventObserver {
     pub fn send_payload(&self, payload: &serde_json::Value, path: &str) {
         let body = match serde_json::to_vec(&payload) {

From 7b7067b705485e2a33cf7154bd1bf88a6cb69e12 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Fri, 26 Jan 2024 13:56:37 -0500
Subject: [PATCH 0494/1166] fix: only return routable replicas, and include
 localpeer if needed

---
 .../src/net/api/liststackerdbreplicas.rs      | 32 ++++++++++++++++---
 1 file changed, 27 insertions(+), 5 deletions(-)

diff --git a/stackslib/src/net/api/liststackerdbreplicas.rs b/stackslib/src/net/api/liststackerdbreplicas.rs
index c4184caa0c..0d4acb0f04 100644
--- a/stackslib/src/net/api/liststackerdbreplicas.rs
+++ b/stackslib/src/net/api/liststackerdbreplicas.rs
@@ -117,9 +117,9 @@ impl RPCRequestHandler for RPCListStackerDBReplicasRequestHandler {
             .take()
             .ok_or(NetError::SendError("`contract_identifier` not set".into()))?;
 
-        let replicas_resp =
+        let (replicas_resp, local_peer, allow_private) =
             node.with_node_state(|network, _sortdb, _chainstate, _mempool, _rpc_args| {
-                PeerDB::find_stacker_db_replicas(
+                let replicas_resp = PeerDB::find_stacker_db_replicas(
                     network.peerdb_conn(),
                     network.bound_neighbor_key().network_id,
                     &contract_identifier,
@@ -132,22 +132,44 @@ impl RPCRequestHandler for RPCListStackerDBReplicasRequestHandler {
                         &preamble,
                         &HttpServerError::new("Unable to list replicas of StackerDB".to_string())
                     )
-                })
+                });
+                let local_peer_resp = network.get_local_peer().clone();
+                (replicas_resp, local_peer_resp, network.get_connection_opts().private_neighbors)
             });
 
-        let naddrs_resp = match replicas_resp {
+        let mut naddrs = match replicas_resp {
             Ok(neighbors) => neighbors
                 .into_iter()
                 .map(|neighbor| NeighborAddress::from_neighbor(&neighbor))
+                .filter(|naddr| {
+                    if naddr.addrbytes.is_anynet() {
+                        // don't expose 0.0.0.0 or ::1
+                        return false;
+                    }
+                    if !allow_private && naddr.addrbytes.is_in_private_range() {
+                        // filter unroutable network addresses
+                        return false;
+                    }
+                    true
+                })
                 .collect::<Vec<_>>(),
             Err(response) => {
                 return response.try_into_contents().map_err(NetError::from);
             }
         };
 
+        if local_peer
+            .stacker_dbs
+            .iter()
+            .find(|contract_id| contract_id == &&contract_identifier)
+            .is_some()
+        {
+            naddrs.insert(0, local_peer.to_public_neighbor_addr());
+        }
+
         let mut preamble = HttpResponsePreamble::ok_json(&preamble);
         preamble.set_canonical_stacks_tip_height(Some(node.canonical_stacks_tip_height()));
-        let body = HttpResponseContents::try_from_json(&naddrs_resp)?;
+        let body = HttpResponseContents::try_from_json(&naddrs)?;
         Ok((preamble, body))
     }
 }

From 683931ca0218f997af1a98773bd4768bb272c4dd Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Fri, 26 Jan 2024 13:56:52 -0500
Subject: [PATCH 0495/1166] feat: helper to get neighbor address of local peer,
 given its public IP address

---
 stackslib/src/net/db.rs | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/stackslib/src/net/db.rs b/stackslib/src/net/db.rs
index e19b041003..246210bb28 100644
--- a/stackslib/src/net/db.rs
+++ b/stackslib/src/net/db.rs
@@ -185,6 +185,21 @@ impl LocalPeer {
             )),
         }
     }
+
+    /// Best-effort attempt to calculate a publicly-routable neighbor address for local peer
+    pub fn to_public_neighbor_addr(&self) -> NeighborAddress {
+        if let Some((peer_addr, peer_port)) = self.public_ip_address.as_ref() {
+            NeighborAddress {
+                addrbytes: peer_addr.clone(),
+                port: *peer_port,
+                public_key_hash: Hash160::from_node_public_key(&StacksPublicKey::from_private(
+                    &self.private_key,
+                )),
+            }
+        } else {
+            self.to_neighbor_addr()
+        }
+    }
 }
 
 impl FromRow<LocalPeer> for LocalPeer {

From 7b597c3a14e55ecd12bab5584108f9213e7b9f8e Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Fri, 26 Jan 2024 13:57:08 -0500
Subject: [PATCH 0496/1166] fix: don't stop an ongoing walk just because we
 don't yet have a connection to an always-allowed peer

---
 stackslib/src/net/neighbors/mod.rs  | 21 ++-------------------
 stackslib/src/net/neighbors/walk.rs |  1 -
 2 files changed, 2 insertions(+), 20 deletions(-)

diff --git a/stackslib/src/net/neighbors/mod.rs b/stackslib/src/net/neighbors/mod.rs
index 55728dae1d..9f2e78151c 100644
--- a/stackslib/src/net/neighbors/mod.rs
+++ b/stackslib/src/net/neighbors/mod.rs
@@ -303,27 +303,10 @@ impl PeerNetwork {
     /// Returns true if we instantiated the walk.
     /// Returns false if not.
     fn setup_walk(&mut self, ibd: bool) -> bool {
-        // we unconditionally need to begin walking if we're not connected to any always-allowed
-        // peer
-        let mut need_new_peers = false;
-        let (num_always_connected, total_always_connected) = self
-            .count_connected_always_allowed_peers()
-            .unwrap_or((0, 0));
-        if num_always_connected == 0 && total_always_connected > 0 {
-            // force a reset
-            debug!("{:?}: not connected to any always-allowed peers; forcing a walk reset to try and fix this", &self.local_peer);
-            self.reset_walk();
-
-            // TODO: force choosing an always-allowed peer!
-            //
-            need_new_peers = true;
-        }
-
         if self.walk.is_none() {
             // time to do a walk yet?
-            if !need_new_peers
-                && (self.walk_count > self.connection_opts.num_initial_walks
-                    || self.walk_retries > self.connection_opts.walk_retry_count)
+            if (self.walk_count > self.connection_opts.num_initial_walks
+                || self.walk_retries > self.connection_opts.walk_retry_count)
                 && self.walk_deadline > get_epoch_time_secs()
             {
                 // we've done enough walks for an initial mixing, or we can't connect to anyone,
diff --git a/stackslib/src/net/neighbors/walk.rs b/stackslib/src/net/neighbors/walk.rs
index 45a3dd7cb4..b5da2d642b 100644
--- a/stackslib/src/net/neighbors/walk.rs
+++ b/stackslib/src/net/neighbors/walk.rs
@@ -565,7 +565,6 @@ impl<DB: NeighborWalkDB, NC: NeighborComms> NeighborWalk<DB, NC> {
     }
 
     /// Select neighbors that are routable, and ignore ones that are not.
-    /// TODO: expand if we ever want to filter by unroutable network class or something
     fn filter_sensible_neighbors(
         mut neighbors: Vec<NeighborAddress>,
         private_neighbors: bool,

From 4c461c2b18d4c1e03f392167b9d3d2be6a9c486d Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Fri, 26 Jan 2024 14:00:00 -0500
Subject: [PATCH 0497/1166] refactor: query old neighbors for stackerdbs if we
 dont' have new ones

---
 stackslib/src/net/stackerdb/sync.rs | 94 ++++++++++++++++-------------
 1 file changed, 53 insertions(+), 41 deletions(-)

diff --git a/stackslib/src/net/stackerdb/sync.rs b/stackslib/src/net/stackerdb/sync.rs
index d6979107f2..9ea3f1ee9a 100644
--- a/stackslib/src/net/stackerdb/sync.rs
+++ b/stackslib/src/net/stackerdb/sync.rs
@@ -77,23 +77,58 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
         dbsync
     }
 
-    /// Coalesce a list of peers such that each one has a unique IP:port
-    fn coalesce_peers_by_ipaddr(peers: Vec<NeighborAddress>) -> Vec<NeighborAddress> {
-        // coalesce peers on the same host:port
-        let mut same_host_port = HashSet::new();
-        let unique_ip_peers: Vec<_> = peers
+    /// Find stackerdb replicas and apply filtering rules
+    fn find_qualified_replicas(
+        &self,
+        network: &PeerNetwork,
+    ) -> Result<HashSet<NeighborAddress>, net_error> {
+        let mut found = HashSet::new();
+        let mut min_age =
+            get_epoch_time_secs().saturating_sub(network.get_connection_opts().max_neighbor_age);
+        while found.len() < self.max_neighbors && min_age != 0 {
+            let peers_iter = PeerDB::find_stacker_db_replicas(
+                network.peerdb_conn(),
+                network.get_local_peer().network_id,
+                &self.smart_contract_id,
+                min_age,
+                self.max_neighbors,
+            )?
             .into_iter()
-            .filter_map(|naddr| {
-                if same_host_port.contains(&naddr.addrbytes.to_socketaddr(naddr.port)) {
-                    None
-                } else {
-                    same_host_port.insert(naddr.addrbytes.to_socketaddr(naddr.port));
-                    Some(naddr)
-                }
+            .map(|neighbor| {
+                (
+                    NeighborAddress::from_neighbor(&neighbor),
+                    neighbor.last_contact_time,
+                )
             })
-            .collect();
+            .filter(|(naddr, _)| {
+                if naddr.addrbytes.is_anynet() {
+                    return false;
+                }
+                if !network.get_connection_opts().private_neighbors
+                    && naddr.addrbytes.is_in_private_range()
+                {
+                    return false;
+                }
+                true
+            });
+
+            for (peer, last_contact) in peers_iter {
+                found.insert(peer);
+                if found.len() >= self.max_neighbors {
+                    break;
+                }
+                min_age = min_age.min(last_contact);
+            }
 
-        unique_ip_peers
+            // search for older neighbors
+            if min_age > 1 {
+                min_age = 1;
+            }
+            else if min_age == 1 {
+                min_age = 0;
+            }
+        }
+        Ok(found)
     }
 
     /// Calculate the new set of replicas to contact.
@@ -108,24 +143,13 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
         // keep all connected replicas, and replenish from config hints and the DB as needed
         let mut peers = config.hint_replicas.clone();
         if let Some(network) = network {
-            let extra_peers: Vec<_> = PeerDB::find_stacker_db_replicas(
-                network.peerdb_conn(),
-                network.get_local_peer().network_id,
-                &self.smart_contract_id,
-                get_epoch_time_secs()
-                    .saturating_sub(network.get_connection_opts().max_neighbor_age),
-                self.max_neighbors,
-            )?
-            .into_iter()
-            .map(|neighbor| NeighborAddress::from_neighbor(&neighbor))
-            .collect();
+            let extra_peers = self.find_qualified_replicas(network)?;
             peers.extend(extra_peers);
         }
 
         peers.shuffle(&mut thread_rng());
 
-        let unique_ip_peers = Self::coalesce_peers_by_ipaddr(peers);
-        for peer in unique_ip_peers {
+        for peer in peers {
             if connected_replicas.len() >= config.max_neighbors {
                 break;
             }
@@ -586,20 +610,8 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
     pub fn connect_begin(&mut self, network: &mut PeerNetwork) -> Result<bool, net_error> {
         if self.replicas.len() == 0 {
             // find some from the peer Db
-            let replicas = PeerDB::find_stacker_db_replicas(
-                network.peerdb_conn(),
-                network.get_local_peer().network_id,
-                &self.smart_contract_id,
-                get_epoch_time_secs()
-                    .saturating_sub(network.get_connection_opts().max_neighbor_age),
-                self.max_neighbors,
-            )?
-            .into_iter()
-            .map(|neighbor| NeighborAddress::from_neighbor(&neighbor))
-            .collect();
-
-            let unique_ip_peers = Self::coalesce_peers_by_ipaddr(replicas);
-            self.replicas = unique_ip_peers.into_iter().collect();
+            let replicas = self.find_qualified_replicas(network)?;
+            self.replicas = replicas;
         }
         debug!(
             "{:?}: connect_begin: establish StackerDB sessions to {} neighbors",

From 67d57113ea3e129043ea9222c5116df6f8fcb268 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Fri, 26 Jan 2024 15:09:38 -0500
Subject: [PATCH 0498/1166] chore: cargo fmt

---
 stackslib/src/net/stackerdb/sync.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/stackslib/src/net/stackerdb/sync.rs b/stackslib/src/net/stackerdb/sync.rs
index 9ea3f1ee9a..ad14ba4b57 100644
--- a/stackslib/src/net/stackerdb/sync.rs
+++ b/stackslib/src/net/stackerdb/sync.rs
@@ -123,9 +123,9 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
             // search for older neighbors
             if min_age > 1 {
                 min_age = 1;
-            }
-            else if min_age == 1 {
+            } else if min_age == 1 {
                 min_age = 0;
+                break;
             }
         }
         Ok(found)

From 40ecd039510f80e3364c478b53087f0e0fe21a14 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Fri, 26 Jan 2024 15:39:46 -0500
Subject: [PATCH 0499/1166] fix: ::1 and 127.0.0.0/8 are private range
 addresses

---
 stacks-common/src/types/net.rs      | 6 ++++--
 stackslib/src/net/neighbors/walk.rs | 4 +++-
 stackslib/src/net/stackerdb/sync.rs | 5 ++---
 3 files changed, 9 insertions(+), 6 deletions(-)

diff --git a/stacks-common/src/types/net.rs b/stacks-common/src/types/net.rs
index 25c86a82de..0e3285b59a 100644
--- a/stacks-common/src/types/net.rs
+++ b/stacks-common/src/types/net.rs
@@ -209,12 +209,14 @@ impl PeerAddress {
     /// Is this a private IP address?
     pub fn is_in_private_range(&self) -> bool {
         if self.is_ipv4() {
-            // 10.0.0.0/8, 172.16.0.0/12, or 192.168.0.0/16
+            // 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16, or 127.0.0.0/8
             self.0[12] == 10
                 || (self.0[12] == 172 && self.0[13] >= 16 && self.0[13] <= 31)
                 || (self.0[12] == 192 && self.0[13] == 168)
+                || self.0[12] == 127
         } else {
-            self.0[0] >= 0xfc
+            // private address (fc00::/7) or localhost (::1)
+            self.0[0] >= 0xfc || (self.0[0..15] == [0u8; 15] && self.0[15] == 1)
         }
     }
 
diff --git a/stackslib/src/net/neighbors/walk.rs b/stackslib/src/net/neighbors/walk.rs
index b5da2d642b..642195a589 100644
--- a/stackslib/src/net/neighbors/walk.rs
+++ b/stackslib/src/net/neighbors/walk.rs
@@ -673,7 +673,9 @@ impl<DB: NeighborWalkDB, NC: NeighborComms> NeighborWalk<DB, NC> {
         // just use the one we used to contact it.  This can happen if the
         // node is behind a load-balancer, or is doing port-forwarding,
         // etc.
-        if neighbor_from_handshake.addr.addrbytes.is_in_private_range() {
+        if neighbor_from_handshake.addr.addrbytes.is_in_private_range()
+            || neighbor_from_handshake.addr.addrbytes.is_anynet()
+        {
             debug!(
                 "{}: outbound neighbor gave private IP address {:?}; assuming it meant {:?}",
                 local_peer_str, &neighbor_from_handshake.addr, &self.cur_neighbor.addr
diff --git a/stackslib/src/net/stackerdb/sync.rs b/stackslib/src/net/stackerdb/sync.rs
index ad14ba4b57..d01d4ff03f 100644
--- a/stackslib/src/net/stackerdb/sync.rs
+++ b/stackslib/src/net/stackerdb/sync.rs
@@ -85,7 +85,7 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
         let mut found = HashSet::new();
         let mut min_age =
             get_epoch_time_secs().saturating_sub(network.get_connection_opts().max_neighbor_age);
-        while found.len() < self.max_neighbors && min_age != 0 {
+        while found.len() < self.max_neighbors {
             let peers_iter = PeerDB::find_stacker_db_replicas(
                 network.peerdb_conn(),
                 network.get_local_peer().network_id,
@@ -123,8 +123,7 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
             // search for older neighbors
             if min_age > 1 {
                 min_age = 1;
-            } else if min_age == 1 {
-                min_age = 0;
+            } else if min_age <= 1 {
                 break;
             }
         }

From f2774c704b71afde1db79cb704ae48e86a00f5bb Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Fri, 19 Jan 2024 11:14:39 -0800
Subject: [PATCH 0500/1166] feat: default to `.signers` boot contract in signer
 config

---
 stacks-signer/src/config.rs | 54 ++++++++++++++++++++++++++++++-------
 1 file changed, 45 insertions(+), 9 deletions(-)

diff --git a/stacks-signer/src/config.rs b/stacks-signer/src/config.rs
index c9d086df32..259cf9335d 100644
--- a/stacks-signer/src/config.rs
+++ b/stacks-signer/src/config.rs
@@ -21,6 +21,7 @@ use std::path::PathBuf;
 use std::time::Duration;
 
 use blockstack_lib::chainstate::stacks::TransactionVersion;
+use blockstack_lib::util_lib::boot::boot_code_id;
 use clarity::vm::types::QualifiedContractIdentifier;
 use hashbrown::HashMap;
 use serde::Deserialize;
@@ -151,9 +152,8 @@ struct RawConfigFile {
     pub node_host: String,
     /// endpoint to event receiver
     pub endpoint: String,
-    // FIXME: this should go away once .signers contract exists at pox-4 instantiation
     /// Signers' Stacker db contract identifier
-    pub stackerdb_contract_id: String,
+    pub stackerdb_contract_id: Option<String>,
 
     /// the 32 byte ECDSA private key used to sign blocks, chunks, transactions, and WSTS messages
     pub message_private_key: String,
@@ -236,13 +236,12 @@ impl TryFrom<RawConfigFile> for Config {
                 raw_data.endpoint.clone(),
             ))?;
 
-        let stackerdb_contract_id =
-            QualifiedContractIdentifier::parse(&raw_data.stackerdb_contract_id).map_err(|_| {
-                ConfigError::BadField(
-                    "stackerdb_contract_id".to_string(),
-                    raw_data.stackerdb_contract_id,
-                )
-            })?;
+        let stackerdb_contract_id = match raw_data.stackerdb_contract_id {
+            Some(id) => QualifiedContractIdentifier::parse(&id).map_err(|_| {
+                ConfigError::BadField("stackerdb_contract_id".to_string(), id.clone())
+            })?,
+            None => boot_code_id("signers", raw_data.network == Network::Mainnet),
+        };
 
         let message_private_key =
             Scalar::try_from(raw_data.message_private_key.as_str()).map_err(|_| {
@@ -338,3 +337,40 @@ impl Config {
         Self::try_from(&PathBuf::from(path))
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::Network;
+    use super::{Config, RawConfigFile};
+    use blockstack_lib::util_lib::boot::boot_code_id;
+
+    fn create_raw_config(overrides: impl FnOnce(&mut RawConfigFile)) -> RawConfigFile {
+        let mut config = RawConfigFile {
+            node_host: "127.0.0.1:20443".to_string(),
+            endpoint: "127.0.0.1:30000".to_string(),
+            stackerdb_contract_id: None,
+            message_private_key: "2ZCxUV9BAKJrGnTPaamKHb4HVgj9ArQgEhowuTe7uRt3".to_string(),
+            stacks_private_key:
+                "69be0e68947fa7128702761151dc8d9b39ee1401e547781bb2ec3e5b4eb1b36f01".to_string(),
+            network: Network::Testnet,
+            signers: vec![],
+            signer_id: 0,
+            event_timeout: None,
+        };
+        overrides(&mut config);
+        config
+    }
+
+    #[test]
+    fn test_config_default_signerdb() {
+        let testnet_config = create_raw_config(|_| {});
+
+        let config = Config::try_from(testnet_config).expect("Failed to parse config");
+        assert_eq!(config.stackerdb_contract_id, boot_code_id("signers", false));
+
+        let mainnet_config = create_raw_config(|c| c.network = Network::Mainnet);
+
+        let config = Config::try_from(mainnet_config).expect("Failed to parse config");
+        assert_eq!(config.stackerdb_contract_id, boot_code_id("signers", true));
+    }
+}

From c5ca3dfb6464a50000ef1dd993a3db2c2e93faf4 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Fri, 19 Jan 2024 15:53:29 -0800
Subject: [PATCH 0501/1166] fix: rename `event_timeout` to `event_timeout_ms`
 after rebase

---
 stacks-signer/src/config.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stacks-signer/src/config.rs b/stacks-signer/src/config.rs
index 259cf9335d..bf82293857 100644
--- a/stacks-signer/src/config.rs
+++ b/stacks-signer/src/config.rs
@@ -355,7 +355,7 @@ mod tests {
             network: Network::Testnet,
             signers: vec![],
             signer_id: 0,
-            event_timeout: None,
+            event_timeout_ms: None,
         };
         overrides(&mut config);
         config

From 19c6b31e175b8faae510272cc5bc95b63ec42df8 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Mon, 22 Jan 2024 08:11:26 -0800
Subject: [PATCH 0502/1166] fix: add new signer config fields to test

---
 stacks-signer/src/config.rs | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/stacks-signer/src/config.rs b/stacks-signer/src/config.rs
index bf82293857..0d1b453157 100644
--- a/stacks-signer/src/config.rs
+++ b/stacks-signer/src/config.rs
@@ -356,6 +356,11 @@ mod tests {
             signers: vec![],
             signer_id: 0,
             event_timeout_ms: None,
+            dkg_end_timeout_ms: None,
+            dkg_public_timeout_ms: None,
+            dkg_private_timeout_ms: None,
+            nonce_timeout_ms: None,
+            sign_timeout_ms: None,
         };
         overrides(&mut config);
         config

From c75589ded7fb6a0817969579d9fd8024f04e1e4d Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Fri, 19 Jan 2024 14:43:04 -0800
Subject: [PATCH 0503/1166] feat: include stacks-signer in CI images

---
 .github/actions/dockerfiles/Dockerfile.debian-source | 4 ++--
 build-scripts/Dockerfile.linux-glibc-arm64           | 2 +-
 build-scripts/Dockerfile.linux-glibc-armv7           | 2 +-
 build-scripts/Dockerfile.linux-glibc-x64             | 2 +-
 build-scripts/Dockerfile.linux-musl-arm64            | 2 +-
 build-scripts/Dockerfile.linux-musl-armv7            | 2 +-
 build-scripts/Dockerfile.linux-musl-x64              | 2 +-
 build-scripts/Dockerfile.macos-arm64                 | 2 +-
 build-scripts/Dockerfile.macos-x64                   | 2 +-
 9 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/.github/actions/dockerfiles/Dockerfile.debian-source b/.github/actions/dockerfiles/Dockerfile.debian-source
index d1604170f4..cbdcb9dcda 100644
--- a/.github/actions/dockerfiles/Dockerfile.debian-source
+++ b/.github/actions/dockerfiles/Dockerfile.debian-source
@@ -12,7 +12,7 @@ COPY . .
 RUN apt-get update && apt-get install -y git libclang-dev
 
 # Run all the build steps in ramdisk in an attempt to speed things up
-RUN target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
+RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
     && cd ${BUILD_DIR} \
     && rustup target add ${TARGET} \
     && rustup component add rustfmt \
@@ -21,5 +21,5 @@ RUN target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
     && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
 
 FROM --platform=${TARGETPLATFORM} debian:bookworm
-COPY --from=build /out/stacks-node /bin/
+COPY --from=build /out/stacks-node /out/stacks-signer /bin/
 CMD ["stacks-node", "mainnet"]
diff --git a/build-scripts/Dockerfile.linux-glibc-arm64 b/build-scripts/Dockerfile.linux-glibc-arm64
index 7ce50b6a68..6b3bc1c1b5 100644
--- a/build-scripts/Dockerfile.linux-glibc-arm64
+++ b/build-scripts/Dockerfile.linux-glibc-arm64
@@ -23,4 +23,4 @@ RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
     && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
 
 FROM scratch AS export-stage
-COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
+COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /out/stacks-signer /
diff --git a/build-scripts/Dockerfile.linux-glibc-armv7 b/build-scripts/Dockerfile.linux-glibc-armv7
index eb893baeb6..3272bec5a0 100644
--- a/build-scripts/Dockerfile.linux-glibc-armv7
+++ b/build-scripts/Dockerfile.linux-glibc-armv7
@@ -23,4 +23,4 @@ RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
     && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
 
 FROM scratch AS export-stage
-COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
\ No newline at end of file
+COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /out/stacks-signer /
\ No newline at end of file
diff --git a/build-scripts/Dockerfile.linux-glibc-x64 b/build-scripts/Dockerfile.linux-glibc-x64
index 2db13cb51e..114e66eca3 100644
--- a/build-scripts/Dockerfile.linux-glibc-x64
+++ b/build-scripts/Dockerfile.linux-glibc-x64
@@ -20,4 +20,4 @@ RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
     && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
 
 FROM scratch AS export-stage
-COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
+COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /out/stacks-signer /
diff --git a/build-scripts/Dockerfile.linux-musl-arm64 b/build-scripts/Dockerfile.linux-musl-arm64
index 135e6f9fc9..bf67030dad 100644
--- a/build-scripts/Dockerfile.linux-musl-arm64
+++ b/build-scripts/Dockerfile.linux-musl-arm64
@@ -18,4 +18,4 @@ RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
     && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
 
 FROM scratch AS export-stage
-COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
+COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /out/stacks-signer /
diff --git a/build-scripts/Dockerfile.linux-musl-armv7 b/build-scripts/Dockerfile.linux-musl-armv7
index 57b93b47ec..1f72e7802f 100644
--- a/build-scripts/Dockerfile.linux-musl-armv7
+++ b/build-scripts/Dockerfile.linux-musl-armv7
@@ -18,4 +18,4 @@ RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
     && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
 
 FROM scratch AS export-stage
-COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
\ No newline at end of file
+COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /out/stacks-signer /
\ No newline at end of file
diff --git a/build-scripts/Dockerfile.linux-musl-x64 b/build-scripts/Dockerfile.linux-musl-x64
index 73e64b4d67..66354ead17 100644
--- a/build-scripts/Dockerfile.linux-musl-x64
+++ b/build-scripts/Dockerfile.linux-musl-x64
@@ -20,4 +20,4 @@ RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
     && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
 
 FROM scratch AS export-stage
-COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
+COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /out/stacks-signer /
diff --git a/build-scripts/Dockerfile.macos-arm64 b/build-scripts/Dockerfile.macos-arm64
index d6b80f267a..a0213bfc1d 100644
--- a/build-scripts/Dockerfile.macos-arm64
+++ b/build-scripts/Dockerfile.macos-arm64
@@ -26,4 +26,4 @@ RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
     && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
 
 FROM scratch AS export-stage
-COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
+COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /out/stacks-signer /
diff --git a/build-scripts/Dockerfile.macos-x64 b/build-scripts/Dockerfile.macos-x64
index 5403b2fe87..4863528f62 100644
--- a/build-scripts/Dockerfile.macos-x64
+++ b/build-scripts/Dockerfile.macos-x64
@@ -26,4 +26,4 @@ RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
     && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
 
 FROM scratch AS export-stage
-COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
+COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /out/stacks-signer /

From f859298dc09500b7b40f5290f32329f7c8d8d4ea Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Fri, 26 Jan 2024 09:35:49 -0800
Subject: [PATCH 0504/1166] fix: remove signer from release builds

---
 build-scripts/Dockerfile.linux-glibc-arm64 | 2 +-
 build-scripts/Dockerfile.linux-glibc-armv7 | 2 +-
 build-scripts/Dockerfile.linux-glibc-x64   | 2 +-
 build-scripts/Dockerfile.linux-musl-arm64  | 2 +-
 build-scripts/Dockerfile.linux-musl-armv7  | 2 +-
 build-scripts/Dockerfile.linux-musl-x64    | 2 +-
 build-scripts/Dockerfile.macos-arm64       | 2 +-
 build-scripts/Dockerfile.macos-x64         | 2 +-
 8 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/build-scripts/Dockerfile.linux-glibc-arm64 b/build-scripts/Dockerfile.linux-glibc-arm64
index 6b3bc1c1b5..7ce50b6a68 100644
--- a/build-scripts/Dockerfile.linux-glibc-arm64
+++ b/build-scripts/Dockerfile.linux-glibc-arm64
@@ -23,4 +23,4 @@ RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
     && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
 
 FROM scratch AS export-stage
-COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /out/stacks-signer /
+COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
diff --git a/build-scripts/Dockerfile.linux-glibc-armv7 b/build-scripts/Dockerfile.linux-glibc-armv7
index 3272bec5a0..eb893baeb6 100644
--- a/build-scripts/Dockerfile.linux-glibc-armv7
+++ b/build-scripts/Dockerfile.linux-glibc-armv7
@@ -23,4 +23,4 @@ RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
     && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
 
 FROM scratch AS export-stage
-COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /out/stacks-signer /
\ No newline at end of file
+COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
\ No newline at end of file
diff --git a/build-scripts/Dockerfile.linux-glibc-x64 b/build-scripts/Dockerfile.linux-glibc-x64
index 114e66eca3..2db13cb51e 100644
--- a/build-scripts/Dockerfile.linux-glibc-x64
+++ b/build-scripts/Dockerfile.linux-glibc-x64
@@ -20,4 +20,4 @@ RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
     && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
 
 FROM scratch AS export-stage
-COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /out/stacks-signer /
+COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
diff --git a/build-scripts/Dockerfile.linux-musl-arm64 b/build-scripts/Dockerfile.linux-musl-arm64
index bf67030dad..135e6f9fc9 100644
--- a/build-scripts/Dockerfile.linux-musl-arm64
+++ b/build-scripts/Dockerfile.linux-musl-arm64
@@ -18,4 +18,4 @@ RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
     && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
 
 FROM scratch AS export-stage
-COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /out/stacks-signer /
+COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
diff --git a/build-scripts/Dockerfile.linux-musl-armv7 b/build-scripts/Dockerfile.linux-musl-armv7
index 1f72e7802f..57b93b47ec 100644
--- a/build-scripts/Dockerfile.linux-musl-armv7
+++ b/build-scripts/Dockerfile.linux-musl-armv7
@@ -18,4 +18,4 @@ RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
     && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
 
 FROM scratch AS export-stage
-COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /out/stacks-signer /
\ No newline at end of file
+COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
\ No newline at end of file
diff --git a/build-scripts/Dockerfile.linux-musl-x64 b/build-scripts/Dockerfile.linux-musl-x64
index 66354ead17..73e64b4d67 100644
--- a/build-scripts/Dockerfile.linux-musl-x64
+++ b/build-scripts/Dockerfile.linux-musl-x64
@@ -20,4 +20,4 @@ RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
     && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
 
 FROM scratch AS export-stage
-COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /out/stacks-signer /
+COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
diff --git a/build-scripts/Dockerfile.macos-arm64 b/build-scripts/Dockerfile.macos-arm64
index a0213bfc1d..d6b80f267a 100644
--- a/build-scripts/Dockerfile.macos-arm64
+++ b/build-scripts/Dockerfile.macos-arm64
@@ -26,4 +26,4 @@ RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
     && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
 
 FROM scratch AS export-stage
-COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /out/stacks-signer /
+COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
diff --git a/build-scripts/Dockerfile.macos-x64 b/build-scripts/Dockerfile.macos-x64
index 4863528f62..5403b2fe87 100644
--- a/build-scripts/Dockerfile.macos-x64
+++ b/build-scripts/Dockerfile.macos-x64
@@ -26,4 +26,4 @@ RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
     && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
 
 FROM scratch AS export-stage
-COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /out/stacks-signer /
+COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /

From 4d3c3dd3fd6dfa9868656943400dca85f64af9a6 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Fri, 26 Jan 2024 16:21:08 -0600
Subject: [PATCH 0505/1166] correct merge artifacts, fix test

---
 stackslib/src/chainstate/stacks/boot/mod.rs           | 1 -
 stackslib/src/chainstate/stacks/boot/signers_tests.rs | 4 ++--
 testnet/stacks-node/src/tests/signer.rs               | 1 -
 3 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 3799fd2730..2f9695d428 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -100,7 +100,6 @@ pub const BOOT_TEST_POX_4_AGG_KEY_CONTRACT: &'static str = "pox-4-agg-test-boote
 pub const BOOT_TEST_POX_4_AGG_KEY_FNAME: &'static str = "aggregate-key";
 
 pub const MINERS_NAME: &'static str = "miners";
-pub const SIGNERS_NAME: &'static str = "signers";
 
 pub mod docs;
 
diff --git a/stackslib/src/chainstate/stacks/boot/signers_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_tests.rs
index 57029ed738..42f80fb599 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_tests.rs
@@ -177,9 +177,9 @@ fn signers_get_config() {
         ),
         Value::okay(Value::Tuple(
             TupleData::from_data(vec![
-                ("chunk-size".into(), Value::UInt(4096)),
+                ("chunk-size".into(), Value::UInt(2 * 1024 * 1024)),
                 ("write-freq".into(), Value::UInt(0)),
-                ("max-writes".into(), Value::UInt(4096)),
+                ("max-writes".into(), Value::UInt(u128::MAX)),
                 ("max-neighbors".into(), Value::UInt(32)),
                 (
                     "hint-replicas".into(),
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index 8a002167d9..219b1f1fe2 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -14,7 +14,6 @@ use stacks::chainstate::coordinator::comm::CoordinatorChannels;
 use stacks::chainstate::nakamoto::{NakamotoBlock, NakamotoBlockHeader};
 use stacks::chainstate::stacks::{StacksPrivateKey, ThresholdSignature};
 use stacks::net::api::postblock_proposal::BlockValidateResponse;
-use stacks::util_lib::boot::boot_code_id;
 use stacks_common::bitvec::BitVec;
 use stacks_common::types::chainstate::{
     ConsensusHash, StacksAddress, StacksBlockId, StacksPublicKey, TrieHash,

From 1341d08b106c6e36690601d31151c51ff998e7f4 Mon Sep 17 00:00:00 2001
From: friedger <mail@friedger.de>
Date: Wed, 10 Jan 2024 11:44:05 +0100
Subject: [PATCH 0506/1166] feat: add pox-4-vote contract

---
 contrib/core-contract-tests/Clarinet.toml     |  6 ++
 stackslib/src/chainstate/stacks/boot/mod.rs   |  3 +-
 .../chainstate/stacks/boot/pox-4-vote.clar    | 56 +++++++++++++++++++
 3 files changed, 64 insertions(+), 1 deletion(-)
 create mode 100644 stackslib/src/chainstate/stacks/boot/pox-4-vote.clar

diff --git a/contrib/core-contract-tests/Clarinet.toml b/contrib/core-contract-tests/Clarinet.toml
index 075681d4ef..d380e19b19 100644
--- a/contrib/core-contract-tests/Clarinet.toml
+++ b/contrib/core-contract-tests/Clarinet.toml
@@ -15,3 +15,9 @@ path = "../../stackslib/src/chainstate/stacks/boot/pox-4.clar"
 depends_on = []
 clarity = 2
 epoch = 2.4
+
+[contracts.pox-4-vote]
+path = "../../stackslib/src/chainstate/stacks/boot/pox-4-vote.clar"
+depends_on = []
+clarity = 2
+epoch = 2.4
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 2f9695d428..a5e0f6b07d 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -16,7 +16,6 @@
 
 use std::boxed::Box;
 use std::cmp;
-use std::collections::BTreeMap;
 use std::convert::{TryFrom, TryInto};
 
 use clarity::vm::analysis::CheckErrors;
@@ -89,6 +88,7 @@ const POX_2_BODY: &'static str = std::include_str!("pox-2.clar");
 const POX_3_BODY: &'static str = std::include_str!("pox-3.clar");
 const POX_4_BODY: &'static str = std::include_str!("pox-4.clar");
 pub const SIGNERS_BODY: &'static str = std::include_str!("signers.clar");
+const POX_4_VOTE_BODY: &'static str = std::include_str!("pox-4-vote.clar");
 
 pub const COSTS_1_NAME: &'static str = "costs";
 pub const COSTS_2_NAME: &'static str = "costs-2";
@@ -117,6 +117,7 @@ lazy_static! {
     pub static ref POX_3_TESTNET_CODE: String =
         format!("{}\n{}", BOOT_CODE_POX_TESTNET_CONSTS, POX_3_BODY);
     pub static ref POX_4_CODE: String = format!("{}", POX_4_BODY);
+    pub static ref POX_4_VOTE_CODE: String = format!("{}", POX_4_VOTE_BODY);
     pub static ref BOOT_CODE_COST_VOTING_TESTNET: String = make_testnet_cost_voting();
     pub static ref STACKS_BOOT_CODE_MAINNET: [(&'static str, &'static str); 6] = [
         ("pox", &BOOT_CODE_POX_MAINNET),
diff --git a/stackslib/src/chainstate/stacks/boot/pox-4-vote.clar b/stackslib/src/chainstate/stacks/boot/pox-4-vote.clar
new file mode 100644
index 0000000000..4dddc7bf3d
--- /dev/null
+++ b/stackslib/src/chainstate/stacks/boot/pox-4-vote.clar
@@ -0,0 +1,56 @@
+;;
+;; @contract voting for the aggregated public key
+;;
+
+;; maps dkg round and signer to proposed aggregated public key
+(define-map votes {reward-cycle: uint, round: uint, signer: principal} {aggregated-public-key: (buff 33), reward-slots: uint})
+;; maps dkg rount and aggregated public key to weights of signers supporting this key so far
+(define-map tally {reward-cycle: uint, round: uint, aggregate-public-key: (buff 33)} uint)
+
+(define-constant err-not-allowed (err u10000))
+(define-constant err-incorrect-reward-cycle (err u10001))
+(define-constant err-incorrect-round (err u10002))
+(define-constant err-invalid-aggregated-public-key (err u10003))
+(define-constant err-duplicate-vote (err u10004))
+(define-constant err-invalid-burn-block-height (err u10005))
+
+(define-data-var last-round uint u0)
+(define-data-var is-state-1-active bool true)
+(define-data-var state-1 {reward-cycle: uint, round: uint, aggregated-public-key: (optional (buff 33)),
+    total-votes: uint}  {reward-cycle: u0, round: u0, aggregated-public-key: none, total-votes: u0})
+(define-data-var state-2 {reward-cycle: uint, round: uint, aggregated-public-key: (optional (buff 33)),
+    total-votes: uint}  {reward-cycle: u0, round: u0, aggregated-public-key: none, total-votes: u0})
+
+;; get voting info by burn block height
+(define-read-only (get-info (height uint))
+    (ok (at-block (unwrap! (get-block-info? id-header-hash height) err-invalid-burn-block-height) (get-current-info))))
+
+;; get current voting info
+(define-read-only (get-current-info)
+    (if (var-get is-state-1-active) (var-get state-1) (var-get state-2)))
+
+(define-read-only (get-signer-public-key (signer principal) (reward-cycle uint))
+    ;; TODO replace with contract-call to pox-4::get-signer-public-key
+    ;; defined in PR https://github.com/stacks-network/stacks-core/pull/4092
+    ;; (contract-call? .pox-4 get-signer-public-key reward-cycle signer)
+    (some 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20))
+
+(define-read-only (get-signer-slots (signer-public-key (buff 33)) (reward-cycle uint))
+    u1000000000000)
+
+(define-read-only (current-reward-cycle)
+    u0)
+
+(define-public (vote-for-aggregated-public-key (key (buff 33)) (reward-cycle uint) (round uint) (tapleaves (list 4001 (buff 33))))
+    (let ((signer-public-key (unwrap! (get-signer-public-key tx-sender reward-cycle) err-not-allowed))
+            ;; one slot, one vote
+            (num-slots (get-signer-slots signer-public-key reward-cycle))
+            (tally-key {reward-cycle: reward-cycle, round: round, aggregate-public-key: key})
+            (new-total (+ num-slots (default-to u0 (map-get? tally tally-key))))
+            (current-round (var-get last-round)))
+        (asserts! (is-eq reward-cycle (current-reward-cycle)) err-incorrect-reward-cycle)
+        (asserts! (is-eq round current-round) err-incorrect-round)
+        (asserts! (is-eq (len key) u33) err-invalid-aggregated-public-key)
+        (asserts! (map-set votes {reward-cycle: reward-cycle, round: round, signer: tx-sender} {aggregated-public-key: key, reward-slots: num-slots}) err-duplicate-vote)
+        (map-set tally tally-key new-total)
+        (ok true)))
\ No newline at end of file

From d1915c7c27ef6c94b30c234490b870d3b976c82e Mon Sep 17 00:00:00 2001
From: friedger <mail@friedger.de>
Date: Wed, 10 Jan 2024 14:18:11 +0100
Subject: [PATCH 0507/1166] chore: add pox_4_vote_tests.rs

---
 stackslib/src/chainstate/stacks/boot/mod.rs   |  35 +++++
 .../stacks/boot/pox_4_vote_tests.rs           | 146 ++++++++++++++++++
 2 files changed, 181 insertions(+)
 create mode 100644 stackslib/src/chainstate/stacks/boot/pox_4_vote_tests.rs

diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index a5e0f6b07d..5dde4b24d5 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -77,6 +77,7 @@ pub const POX_1_NAME: &'static str = "pox";
 pub const POX_2_NAME: &'static str = "pox-2";
 pub const POX_3_NAME: &'static str = "pox-3";
 pub const POX_4_NAME: &'static str = "pox-4";
+pub const POX_4_VOTE_NAME: &'static str = "pox-4-vote";
 pub const SIGNERS_NAME: &'static str = "signers";
 /// This is the name of a variable in the `.signers` contract which tracks the most recently updated
 /// reward cycle number.
@@ -1307,6 +1308,8 @@ pub mod pox_3_tests;
 #[cfg(test)]
 pub mod pox_4_tests;
 #[cfg(test)]
+pub mod pox_4_vote_tests;
+#[cfg(test)]
 mod signers_tests;
 
 #[cfg(test)]
@@ -1875,6 +1878,38 @@ pub mod test {
         make_tx(key, nonce, 0, payload)
     }
 
+    pub fn make_pox_4_vote_for_aggregated_public_key(
+        key: &StacksPrivateKey,
+        nonce: u64,
+        reward_cycle: u64,
+        aggregate_public_key: &Point,
+    ) -> StacksTransaction {
+        let aggregate_public_key = Value::buff_from(aggregate_public_key.compress().data.to_vec())
+            .expect("Failed to serialize aggregate public key");
+        let payload = TransactionPayload::new_contract_call(
+            boot_code_test_addr(),
+            POX_4_VOTE_NAME,
+            "vote-for-aggregated-public-key",
+            vec![
+                aggregate_public_key,
+                Value::UInt(reward_cycle as u128),
+                Value::UInt(0),
+                Value::Sequence(SequenceData::List(ListData {
+                    data: [].to_vec(),
+                    type_signature: ListTypeData::new_list(
+                        TypeSignature::SequenceType(SequenceSubtype::BufferType(
+                            BufferLength::try_from(33u32).unwrap(),
+                        )),
+                        4001,
+                    )
+                    .unwrap(),
+                })),
+            ],
+        )
+        .unwrap();
+        make_tx(key, nonce, 0, payload)
+    }
+
     pub fn make_pox_2_increase(
         key: &StacksPrivateKey,
         nonce: u64,
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_vote_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_vote_tests.rs
new file mode 100644
index 0000000000..3bdb94ae4c
--- /dev/null
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_vote_tests.rs
@@ -0,0 +1,146 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020-2024 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+use std::collections::{HashMap, HashSet, VecDeque};
+use std::convert::{TryFrom, TryInto};
+
+use clarity::vm::clarity::ClarityConnection;
+use clarity::vm::contexts::OwnedEnvironment;
+use clarity::vm::contracts::Contract;
+use clarity::vm::costs::{CostOverflowingMath, LimitedCostTracker};
+use clarity::vm::database::*;
+use clarity::vm::errors::{
+    CheckErrors, Error, IncomparableError, InterpreterError, InterpreterResult, RuntimeErrorType,
+};
+use clarity::vm::eval;
+use clarity::vm::events::StacksTransactionEvent;
+use clarity::vm::representations::SymbolicExpression;
+use clarity::vm::tests::{execute, is_committed, is_err_code, symbols_from_values};
+use clarity::vm::types::Value::Response;
+use clarity::vm::types::{
+    BuffData, OptionalData, PrincipalData, QualifiedContractIdentifier, ResponseData, SequenceData,
+    StacksAddressExtensions, StandardPrincipalData, TupleData, TupleTypeSignature, TypeSignature,
+    Value, NONE,
+};
+use stacks_common::address::AddressHashMode;
+use stacks_common::types::chainstate::{
+    BlockHeaderHash, BurnchainHeaderHash, StacksAddress, StacksBlockId, VRFSeed,
+};
+use stacks_common::types::Address;
+use stacks_common::util::hash::{hex_bytes, to_hex, Sha256Sum, Sha512Trunc256Sum};
+use stacks_common::util::secp256k1::Secp256k1PrivateKey;
+use wsts::curve::point::{Compressed, Point};
+
+use super::test::*;
+use super::RawRewardSetEntry;
+use crate::burnchains::{Burnchain, PoxConstants};
+use crate::chainstate::burn::db::sortdb::SortitionDB;
+use crate::chainstate::burn::operations::*;
+use crate::chainstate::burn::{BlockSnapshot, ConsensusHash};
+use crate::chainstate::stacks::address::{PoxAddress, PoxAddressType20, PoxAddressType32};
+use crate::chainstate::stacks::boot::pox_2_tests::{
+    check_pox_print_event, generate_pox_clarity_value, get_reward_set_entries_at,
+    get_stacking_state_pox, get_stx_account_at, with_clarity_db_ro, PoxPrintFields,
+    StackingStateCheckData,
+};
+use crate::chainstate::stacks::boot::pox_4_tests::{assert_latest_was_burn, get_tip, make_test_epochs_pox};
+use crate::chainstate::stacks::boot::{
+    BOOT_CODE_COST_VOTING_TESTNET as BOOT_CODE_COST_VOTING, BOOT_CODE_POX_TESTNET,
+};
+use crate::chainstate::stacks::db::{
+    MinerPaymentSchedule, StacksChainState, StacksHeaderInfo, MINER_REWARD_MATURITY,
+};
+use crate::chainstate::stacks::events::{StacksTransactionReceipt, TransactionOrigin};
+use crate::chainstate::stacks::index::marf::MarfConnection;
+use crate::chainstate::stacks::index::MarfTrieId;
+use crate::chainstate::stacks::tests::make_coinbase;
+use crate::chainstate::stacks::*;
+use crate::clarity_vm::clarity::{ClarityBlockConnection, Error as ClarityError};
+use crate::clarity_vm::database::marf::{MarfedKV, WritableMarfStore};
+use crate::clarity_vm::database::HeadersDBConn;
+use crate::core::*;
+use crate::net::test::{TestEventObserver, TestPeer};
+use crate::util_lib::boot::boot_code_id;
+use crate::util_lib::db::{DBConn, FromRow};
+
+pub fn prepare_pox4_test<'a>(
+    test_name: &str,
+    observer: Option<&'a TestEventObserver>,
+) -> (
+    Burnchain,
+    TestPeer<'a>,
+    Vec<StacksPrivateKey>,
+    StacksBlockId,
+    u64,
+    usize,
+) {
+    let (epochs, pox_constants) = make_test_epochs_pox();
+
+    let mut burnchain = Burnchain::default_unittest(
+        0,
+        &BurnchainHeaderHash::from_hex(BITCOIN_REGTEST_FIRST_BLOCK_HASH).unwrap(),
+    );
+    burnchain.pox_constants = pox_constants.clone();
+
+    let (mut peer, keys) =
+        instantiate_pox_peer_with_epoch(&burnchain, test_name, Some(epochs.clone()), observer);
+
+    assert_eq!(burnchain.pox_constants.reward_slots(), 6);
+    let mut coinbase_nonce = 0;
+
+    // Advance into pox4
+    let target_height = burnchain.pox_constants.pox_4_activation_height;
+    let mut latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    while get_tip(peer.sortdb.as_ref()).block_height < u64::from(target_height) {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+        // if we reach epoch 2.1, perform the check
+        if get_tip(peer.sortdb.as_ref()).block_height > epochs[3].start_height {
+            assert_latest_was_burn(&mut peer);
+        }
+    }
+
+    let block_height = get_tip(peer.sortdb.as_ref()).block_height;
+
+    info!("Block height: {}", block_height);
+
+    (
+        burnchain,
+        peer,
+        keys,
+        latest_block,
+        block_height,
+        coinbase_nonce,
+    )
+}
+
+#[test]
+fn tally_aggregated_public_key() {
+
+   let (burnchain, mut peer, keys, latest_block, block_height, mut coinbase_nonce) =
+        prepare_pox4_test(function_name!(), None);
+
+    let signer_nonce = 0;
+    let signer_key = &keys[0];
+    let signer_principal = PrincipalData::from(key_to_stacks_addr(signer_key));
+    let cycle_id = 1;
+    let aggreated_public_key: Point = Point::new();
+
+    let txs = vec![
+        make_pox_4_vote_for_aggregated_public_key(signer_key, signer_nonce, cycle_id, &aggreated_public_key)
+    ];
+
+    let latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
+}

From b758988c2023773de5d9b62aafdba6239aab6a79 Mon Sep 17 00:00:00 2001
From: friedger <mail@friedger.de>
Date: Wed, 10 Jan 2024 15:03:44 +0100
Subject: [PATCH 0508/1166] chore: use aggregate public key as name

---
 stackslib/src/chainstate/stacks/boot/mod.rs   |  4 ++--
 .../chainstate/stacks/boot/pox-4-vote.clar    | 24 +++++++++----------
 .../stacks/boot/pox_4_vote_tests.rs           |  4 ++--
 3 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 5dde4b24d5..f2d9daf2fa 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -1878,7 +1878,7 @@ pub mod test {
         make_tx(key, nonce, 0, payload)
     }
 
-    pub fn make_pox_4_vote_for_aggregated_public_key(
+    pub fn make_pox_4_vote_for_aggregate_public_key(
         key: &StacksPrivateKey,
         nonce: u64,
         reward_cycle: u64,
@@ -1889,7 +1889,7 @@ pub mod test {
         let payload = TransactionPayload::new_contract_call(
             boot_code_test_addr(),
             POX_4_VOTE_NAME,
-            "vote-for-aggregated-public-key",
+            "vote-for-aggregate-public-key",
             vec![
                 aggregate_public_key,
                 Value::UInt(reward_cycle as u128),
diff --git a/stackslib/src/chainstate/stacks/boot/pox-4-vote.clar b/stackslib/src/chainstate/stacks/boot/pox-4-vote.clar
index 4dddc7bf3d..852a5daa1f 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4-vote.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4-vote.clar
@@ -1,25 +1,25 @@
 ;;
-;; @contract voting for the aggregated public key
+;; @contract voting for the aggregate public key
 ;;
 
-;; maps dkg round and signer to proposed aggregated public key
-(define-map votes {reward-cycle: uint, round: uint, signer: principal} {aggregated-public-key: (buff 33), reward-slots: uint})
-;; maps dkg rount and aggregated public key to weights of signers supporting this key so far
+;; maps dkg round and signer to proposed aggregate public key
+(define-map votes {reward-cycle: uint, round: uint, signer: principal} {aggregate-public-key: (buff 33), reward-slots: uint})
+;; maps dkg round and aggregate public key to weights of signers supporting this key so far
 (define-map tally {reward-cycle: uint, round: uint, aggregate-public-key: (buff 33)} uint)
 
 (define-constant err-not-allowed (err u10000))
 (define-constant err-incorrect-reward-cycle (err u10001))
 (define-constant err-incorrect-round (err u10002))
-(define-constant err-invalid-aggregated-public-key (err u10003))
+(define-constant err-invalid-aggregate-public-key (err u10003))
 (define-constant err-duplicate-vote (err u10004))
 (define-constant err-invalid-burn-block-height (err u10005))
 
 (define-data-var last-round uint u0)
 (define-data-var is-state-1-active bool true)
-(define-data-var state-1 {reward-cycle: uint, round: uint, aggregated-public-key: (optional (buff 33)),
-    total-votes: uint}  {reward-cycle: u0, round: u0, aggregated-public-key: none, total-votes: u0})
-(define-data-var state-2 {reward-cycle: uint, round: uint, aggregated-public-key: (optional (buff 33)),
-    total-votes: uint}  {reward-cycle: u0, round: u0, aggregated-public-key: none, total-votes: u0})
+(define-data-var state-1 {reward-cycle: uint, round: uint, aggregate-public-key: (optional (buff 33)),
+    total-votes: uint}  {reward-cycle: u0, round: u0, aggregate-public-key: none, total-votes: u0})
+(define-data-var state-2 {reward-cycle: uint, round: uint, aggregate-public-key: (optional (buff 33)),
+    total-votes: uint}  {reward-cycle: u0, round: u0, aggregate-public-key: none, total-votes: u0})
 
 ;; get voting info by burn block height
 (define-read-only (get-info (height uint))
@@ -41,7 +41,7 @@
 (define-read-only (current-reward-cycle)
     u0)
 
-(define-public (vote-for-aggregated-public-key (key (buff 33)) (reward-cycle uint) (round uint) (tapleaves (list 4001 (buff 33))))
+(define-public (vote-for-aggregate-public-key (key (buff 33)) (reward-cycle uint) (round uint) (tapleaves (list 4001 (buff 33))))
     (let ((signer-public-key (unwrap! (get-signer-public-key tx-sender reward-cycle) err-not-allowed))
             ;; one slot, one vote
             (num-slots (get-signer-slots signer-public-key reward-cycle))
@@ -50,7 +50,7 @@
             (current-round (var-get last-round)))
         (asserts! (is-eq reward-cycle (current-reward-cycle)) err-incorrect-reward-cycle)
         (asserts! (is-eq round current-round) err-incorrect-round)
-        (asserts! (is-eq (len key) u33) err-invalid-aggregated-public-key)
-        (asserts! (map-set votes {reward-cycle: reward-cycle, round: round, signer: tx-sender} {aggregated-public-key: key, reward-slots: num-slots}) err-duplicate-vote)
+        (asserts! (is-eq (len key) u33) err-invalid-aggregate-public-key)
+        (asserts! (map-set votes {reward-cycle: reward-cycle, round: round, signer: tx-sender} {aggregate-public-key: key, reward-slots: num-slots}) err-duplicate-vote)
         (map-set tally tally-key new-total)
         (ok true)))
\ No newline at end of file
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_vote_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_vote_tests.rs
index 3bdb94ae4c..7d04f9c496 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_vote_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_vote_tests.rs
@@ -127,7 +127,7 @@ pub fn prepare_pox4_test<'a>(
 }
 
 #[test]
-fn tally_aggregated_public_key() {
+fn vote_for_aggregate_public_key() {
 
    let (burnchain, mut peer, keys, latest_block, block_height, mut coinbase_nonce) =
         prepare_pox4_test(function_name!(), None);
@@ -139,7 +139,7 @@ fn tally_aggregated_public_key() {
     let aggreated_public_key: Point = Point::new();
 
     let txs = vec![
-        make_pox_4_vote_for_aggregated_public_key(signer_key, signer_nonce, cycle_id, &aggreated_public_key)
+        make_pox_4_vote_for_aggregate_public_key(signer_key, signer_nonce, cycle_id, &aggreated_public_key)
     ];
 
     let latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);

From 30861a61444a1d52f99a706febf4406b29357a5d Mon Sep 17 00:00:00 2001
From: friedger <mail@friedger.de>
Date: Mon, 29 Jan 2024 16:55:05 +0100
Subject: [PATCH 0509/1166] chore: restore pox_4_vote after rebase

---
 contrib/core-contract-tests/Clarinet.toml     |  6 ++
 stackslib/src/chainstate/stacks/boot/mod.rs   | 52 +++++++---
 .../chainstate/stacks/boot/pox-4-vote.clar    | 47 +++++----
 .../src/chainstate/stacks/boot/pox_4_tests.rs |  2 +-
 .../stacks/boot/pox_4_vote_tests.rs           | 97 ++++++++++++++++---
 .../src/chainstate/stacks/boot/signers.clar   |  4 +
 6 files changed, 162 insertions(+), 46 deletions(-)

diff --git a/contrib/core-contract-tests/Clarinet.toml b/contrib/core-contract-tests/Clarinet.toml
index d380e19b19..04da62b42a 100644
--- a/contrib/core-contract-tests/Clarinet.toml
+++ b/contrib/core-contract-tests/Clarinet.toml
@@ -16,6 +16,12 @@ depends_on = []
 clarity = 2
 epoch = 2.4
 
+[contracts.signers]
+path = "../../stackslib/src/chainstate/stacks/boot/signers.clar"
+depends_on = []
+clarity = 2
+epoch = 2.4
+
 [contracts.pox-4-vote]
 path = "../../stackslib/src/chainstate/stacks/boot/pox-4-vote.clar"
 depends_on = []
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index f2d9daf2fa..8de21ee1dd 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -16,6 +16,7 @@
 
 use std::boxed::Box;
 use std::cmp;
+use std::collections::BTreeMap;
 use std::convert::{TryFrom, TryInto};
 
 use clarity::vm::analysis::CheckErrors;
@@ -1318,7 +1319,9 @@ pub mod test {
     use std::convert::From;
     use std::fs;
 
+    use clarity::boot_util::boot_code_addr;
     use clarity::vm::contracts::Contract;
+    use clarity::vm::tests::symbols_from_values;
     use clarity::vm::types::*;
     use stacks_common::util::hash::to_hex;
     use stacks_common::util::*;
@@ -1881,8 +1884,9 @@ pub mod test {
     pub fn make_pox_4_vote_for_aggregate_public_key(
         key: &StacksPrivateKey,
         nonce: u64,
-        reward_cycle: u64,
         aggregate_public_key: &Point,
+        reward_cycle: u128,
+        round: u128,
     ) -> StacksTransaction {
         let aggregate_public_key = Value::buff_from(aggregate_public_key.compress().data.to_vec())
             .expect("Failed to serialize aggregate public key");
@@ -1892,18 +1896,8 @@ pub mod test {
             "vote-for-aggregate-public-key",
             vec![
                 aggregate_public_key,
-                Value::UInt(reward_cycle as u128),
-                Value::UInt(0),
-                Value::Sequence(SequenceData::List(ListData {
-                    data: [].to_vec(),
-                    type_signature: ListTypeData::new_list(
-                        TypeSignature::SequenceType(SequenceSubtype::BufferType(
-                            BufferLength::try_from(33u32).unwrap(),
-                        )),
-                        4001,
-                    )
-                    .unwrap(),
-                })),
+                Value::UInt(reward_cycle),
+                Value::UInt(round),
             ],
         )
         .unwrap();
@@ -2222,6 +2216,38 @@ pub mod test {
         make_tx(key, nonce, 0, payload)
     }
 
+    pub fn readonly_call(
+        peer: &mut TestPeer,
+        tip: &StacksBlockId,
+        boot_contract: ContractName,
+        function_name: ClarityName,
+        args: Vec<Value>,
+    ) -> Value {
+        with_sortdb(peer, |chainstate, sortdb| {
+            chainstate.with_read_only_clarity_tx(&sortdb.index_conn(), tip, |connection| {
+                connection
+                    .with_readonly_clarity_env(
+                        false,
+                        0x80000000,
+                        ClarityVersion::Clarity2,
+                        PrincipalData::from(boot_code_addr(false)),
+                        None,
+                        LimitedCostTracker::new_free(),
+                        |env| {
+                            env.execute_contract_allow_private(
+                                &boot_code_id(&boot_contract, false),
+                                &function_name,
+                                &symbols_from_values(args),
+                                true,
+                            )
+                        },
+                    )
+                    .unwrap()
+            })
+        })
+        .unwrap()
+    }
+
     // make a stream of invalid pox-lockup transactions
     fn make_invalid_pox_lockups(key: &StacksPrivateKey, mut nonce: u64) -> Vec<StacksTransaction> {
         let mut ret = vec![];
diff --git a/stackslib/src/chainstate/stacks/boot/pox-4-vote.clar b/stackslib/src/chainstate/stacks/boot/pox-4-vote.clar
index 852a5daa1f..d70356d45e 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4-vote.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4-vote.clar
@@ -6,14 +6,19 @@
 (define-map votes {reward-cycle: uint, round: uint, signer: principal} {aggregate-public-key: (buff 33), reward-slots: uint})
 ;; maps dkg round and aggregate public key to weights of signers supporting this key so far
 (define-map tally {reward-cycle: uint, round: uint, aggregate-public-key: (buff 33)} uint)
+;; maps aggregate public keys to rewards cycles and rounds
+(define-map used-aggregate-public-keys (buff 33) {reward-cycle: uint, round: uint})
 
 (define-constant err-not-allowed (err u10000))
 (define-constant err-incorrect-reward-cycle (err u10001))
-(define-constant err-incorrect-round (err u10002))
-(define-constant err-invalid-aggregate-public-key (err u10003))
+(define-constant err-invalid-aggregate-public-key (err u10002))
+(define-constant err-duplicate-aggregate-public-key (err u10003))
 (define-constant err-duplicate-vote (err u10004))
 (define-constant err-invalid-burn-block-height (err u10005))
 
+(define-constant pox-info
+    (unwrap-panic (contract-call? .pox-4 get-pox-info)))
+
 (define-data-var last-round uint u0)
 (define-data-var is-state-1-active bool true)
 (define-data-var state-1 {reward-cycle: uint, round: uint, aggregate-public-key: (optional (buff 33)),
@@ -29,28 +34,30 @@
 (define-read-only (get-current-info)
     (if (var-get is-state-1-active) (var-get state-1) (var-get state-2)))
 
-(define-read-only (get-signer-public-key (signer principal) (reward-cycle uint))
-    ;; TODO replace with contract-call to pox-4::get-signer-public-key
-    ;; defined in PR https://github.com/stacks-network/stacks-core/pull/4092
-    ;; (contract-call? .pox-4 get-signer-public-key reward-cycle signer)
-    (some 0x0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f20))
-
-(define-read-only (get-signer-slots (signer-public-key (buff 33)) (reward-cycle uint))
-    u1000000000000)
+(define-read-only (burn-height-to-reward-cycle (height uint))
+    (/ (- height (get first-burnchain-block-height pox-info)) (get reward-cycle-length pox-info)))
 
 (define-read-only (current-reward-cycle)
-    u0)
-
-(define-public (vote-for-aggregate-public-key (key (buff 33)) (reward-cycle uint) (round uint) (tapleaves (list 4001 (buff 33))))
-    (let ((signer-public-key (unwrap! (get-signer-public-key tx-sender reward-cycle) err-not-allowed))
+    (burn-height-to-reward-cycle burn-block-height))
+    
+(define-read-only (get-signer-slots (signer principal) (reward-cycle uint))
+    (contract-call? .signers get-signer-slots signer reward-cycle))
+
+;; aggregate public key must be unique and can be used only once per cylce and round
+(define-read-only (is-unique-aggregated-public-key (key (buff 33)) (dkg-id {reward-cycle: uint, round: uint}))
+    (match (map-get? used-aggregate-public-keys key)
+        when (is-eq when dkg-id)
+        true))
+
+(define-public (vote-for-aggregate-public-key (key (buff 33)) (reward-cycle uint) (round uint))
+    (let ((tally-key {reward-cycle: reward-cycle, round: round, aggregate-public-key: key})
             ;; one slot, one vote
-            (num-slots (get-signer-slots signer-public-key reward-cycle))
-            (tally-key {reward-cycle: reward-cycle, round: round, aggregate-public-key: key})
-            (new-total (+ num-slots (default-to u0 (map-get? tally tally-key))))
-            (current-round (var-get last-round)))
+            (num-slots (unwrap! (get-signer-slots tx-sender reward-cycle) err-not-allowed))
+            (new-total (+ num-slots (default-to u0 (map-get? tally tally-key)))))
         (asserts! (is-eq reward-cycle (current-reward-cycle)) err-incorrect-reward-cycle)
-        (asserts! (is-eq round current-round) err-incorrect-round)
         (asserts! (is-eq (len key) u33) err-invalid-aggregate-public-key)
-        (asserts! (map-set votes {reward-cycle: reward-cycle, round: round, signer: tx-sender} {aggregate-public-key: key, reward-slots: num-slots}) err-duplicate-vote)
+        (asserts! (is-unique-aggregated-public-key key {reward-cycle: reward-cycle, round: round}) err-duplicate-aggregate-public-key)
+        (asserts! (map-insert votes {reward-cycle: reward-cycle, round: round, signer: tx-sender} {aggregate-public-key: key, reward-slots: num-slots}) err-duplicate-vote)
         (map-set tally tally-key new-total)
+        (print "voted")
         (ok true)))
\ No newline at end of file
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 69ba7f8e84..c92520a57c 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -82,7 +82,7 @@ const ERR_REUSED_SIGNER_KEY: i128 = 33;
 
 /// Return the BlockSnapshot for the latest sortition in the provided
 ///  SortitionDB option-reference. Panics on any errors.
-fn get_tip(sortdb: Option<&SortitionDB>) -> BlockSnapshot {
+pub fn get_tip(sortdb: Option<&SortitionDB>) -> BlockSnapshot {
     SortitionDB::get_canonical_burn_chain_tip(&sortdb.unwrap().conn()).unwrap()
 }
 
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_vote_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_vote_tests.rs
index 7d04f9c496..98c774b5c2 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_vote_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_vote_tests.rs
@@ -56,9 +56,11 @@ use crate::chainstate::stacks::boot::pox_2_tests::{
     get_stacking_state_pox, get_stx_account_at, with_clarity_db_ro, PoxPrintFields,
     StackingStateCheckData,
 };
-use crate::chainstate::stacks::boot::pox_4_tests::{assert_latest_was_burn, get_tip, make_test_epochs_pox};
+use crate::chainstate::stacks::boot::pox_4_tests::{
+    assert_latest_was_burn, get_last_block_sender_transactions, get_tip, make_test_epochs_pox,
+};
 use crate::chainstate::stacks::boot::{
-    BOOT_CODE_COST_VOTING_TESTNET as BOOT_CODE_COST_VOTING, BOOT_CODE_POX_TESTNET,
+    BOOT_CODE_COST_VOTING_TESTNET as BOOT_CODE_COST_VOTING, BOOT_CODE_POX_TESTNET, POX_4_VOTE_NAME
 };
 use crate::chainstate::stacks::db::{
     MinerPaymentSchedule, StacksChainState, StacksHeaderInfo, MINER_REWARD_MATURITY,
@@ -128,19 +130,90 @@ pub fn prepare_pox4_test<'a>(
 
 #[test]
 fn vote_for_aggregate_public_key() {
+    let observer = TestEventObserver::new();
+
+    let (burnchain, mut peer, keys, latest_block_id, block_height, mut coinbase_nonce) =
+        prepare_pox4_test(function_name!(), Some(&observer));
+
+    let current_reward_cycle = readonly_call(
+        &mut peer,
+        &latest_block_id,
+        POX_4_VOTE_NAME.into(),
+        "current-reward-cycle".into(),
+        vec![],
+    )
+    .expect_u128();
 
-   let (burnchain, mut peer, keys, latest_block, block_height, mut coinbase_nonce) =
-        prepare_pox4_test(function_name!(), None);
+    assert_eq!(current_reward_cycle, 22);
 
-    let signer_nonce = 0;
+    let mut signer_nonce = 0;
     let signer_key = &keys[0];
-    let signer_principal = PrincipalData::from(key_to_stacks_addr(signer_key));
-    let cycle_id = 1;
-    let aggreated_public_key: Point = Point::new();
+    let signer_address = key_to_stacks_addr(signer_key);
+    let signer_principal = PrincipalData::from(signer_address);
+    let cycle_id = current_reward_cycle;
+    let aggregated_public_key: Point = Point::new();
+
+    // cast a vote for the aggregate public key
+    let txs = vec![make_pox_4_vote_for_aggregate_public_key(
+        signer_key,
+        signer_nonce,
+        &aggregated_public_key,
+        cycle_id,
+        0,
+    )];
+
+    let latest_block_id = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
+    let tx_receipts = get_last_block_sender_transactions(&observer, signer_address);
+    assert_eq!(tx_receipts.len(), 1);
+    assert_eq!(
+        tx_receipts[0].result,
+        Value::Response(ResponseData {
+            committed: true,
+            data: Box::new(Value::Bool(true))
+        })
+    );
 
-    let txs = vec![
-        make_pox_4_vote_for_aggregate_public_key(signer_key, signer_nonce, cycle_id, &aggreated_public_key)
-    ];
+    signer_nonce += 1;
 
-    let latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
+    // cast same vote twice
+    let txs = vec![make_pox_4_vote_for_aggregate_public_key(
+        signer_key,
+        signer_nonce,
+        &aggregated_public_key,
+        cycle_id,
+        0,
+    )];
+
+    let latest_block_id = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
+    let tx_receipts = get_last_block_sender_transactions(&observer, signer_address);
+    assert_eq!(tx_receipts.len(), 1);
+    assert_eq!(
+        tx_receipts[0].result,
+        Value::Response(ResponseData {
+            committed: false,
+            data: Box::new(Value::UInt(10004)) // err-duplicate-vote
+        })
+    );
+
+    signer_nonce += 1;
+
+    // cast vote too late
+    let txs = vec![make_pox_4_vote_for_aggregate_public_key(
+        signer_key,
+        signer_nonce,
+        &aggregated_public_key,
+        cycle_id - 1,
+        0,
+    )];
+
+    let latest_block_id = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
+    let tx_receipts = get_last_block_sender_transactions(&observer, signer_address);
+    assert_eq!(tx_receipts.len(), 1);
+    assert_eq!(
+        tx_receipts[0].result,
+        Value::Response(ResponseData {
+            committed: false,
+            data: Box::new(Value::UInt(10001)) // err-incorrect-reward-cycle
+        })
+    ); 
 }
diff --git a/stackslib/src/chainstate/stacks/boot/signers.clar b/stackslib/src/chainstate/stacks/boot/signers.clar
index 42edf8ef0e..3970679333 100644
--- a/stackslib/src/chainstate/stacks/boot/signers.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers.clar
@@ -13,6 +13,10 @@
 (define-read-only (stackerdb-get-signer-slots)
 	(ok (var-get stackerdb-signer-slots)))
 
+(define-read-only (get-signer-slots (signer principal) (reward-cycle uint))
+	(ok u1)
+)
+
 (define-read-only (stackerdb-get-config)
 	(ok
 		{ chunk-size: CHUNK_SIZE,

From 36af678646d6368e8595985bf96682978e3d8480 Mon Sep 17 00:00:00 2001
From: friedger <mail@friedger.de>
Date: Mon, 29 Jan 2024 17:13:56 +0100
Subject: [PATCH 0510/1166] feat: add last voting rounds

---
 .../chainstate/stacks/boot/pox-4-vote.clar    | 32 +++++++++------
 .../stacks/boot/pox_4_vote_tests.rs           |  6 +--
 stackslib/src/clarity_vm/clarity.rs           | 40 ++++++++++++++++++-
 3 files changed, 62 insertions(+), 16 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox-4-vote.clar b/stackslib/src/chainstate/stacks/boot/pox-4-vote.clar
index d70356d45e..6da008f54b 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4-vote.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4-vote.clar
@@ -11,15 +11,18 @@
 
 (define-constant err-not-allowed (err u10000))
 (define-constant err-incorrect-reward-cycle (err u10001))
-(define-constant err-invalid-aggregate-public-key (err u10002))
-(define-constant err-duplicate-aggregate-public-key (err u10003))
-(define-constant err-duplicate-vote (err u10004))
-(define-constant err-invalid-burn-block-height (err u10005))
+(define-constant err-old-round (err u10002))
+(define-constant err-invalid-aggregate-public-key (err u10003))
+(define-constant err-duplicate-aggregate-public-key (err u10004))
+(define-constant err-duplicate-vote (err u10005))
+(define-constant err-invalid-burn-block-height (err u10006))
 
 (define-constant pox-info
     (unwrap-panic (contract-call? .pox-4 get-pox-info)))
 
-(define-data-var last-round uint u0)
+;; maps reward-cycle ids to last round
+(define-map rounds uint uint)
+
 (define-data-var is-state-1-active bool true)
 (define-data-var state-1 {reward-cycle: uint, round: uint, aggregate-public-key: (optional (buff 33)),
     total-votes: uint}  {reward-cycle: u0, round: u0, aggregate-public-key: none, total-votes: u0})
@@ -43,11 +46,9 @@
 (define-read-only (get-signer-slots (signer principal) (reward-cycle uint))
     (contract-call? .signers get-signer-slots signer reward-cycle))
 
-;; aggregate public key must be unique and can be used only once per cylce and round
-(define-read-only (is-unique-aggregated-public-key (key (buff 33)) (dkg-id {reward-cycle: uint, round: uint}))
-    (match (map-get? used-aggregate-public-keys key)
-        when (is-eq when dkg-id)
-        true))
+;; aggregate public key must be unique and can be used only in a single cycle-round pair
+(define-read-only (is-valid-aggregated-public-key (key (buff 33)) (dkg-id {reward-cycle: uint, round: uint}))
+    (is-eq (default-to dkg-id (map-get? used-aggregate-public-keys key)) dkg-id))
 
 (define-public (vote-for-aggregate-public-key (key (buff 33)) (reward-cycle uint) (round uint))
     (let ((tally-key {reward-cycle: reward-cycle, round: round, aggregate-public-key: key})
@@ -55,9 +56,16 @@
             (num-slots (unwrap! (get-signer-slots tx-sender reward-cycle) err-not-allowed))
             (new-total (+ num-slots (default-to u0 (map-get? tally tally-key)))))
         (asserts! (is-eq reward-cycle (current-reward-cycle)) err-incorrect-reward-cycle)
+        (asserts! (>= round (default-to u0 (map-get? rounds reward-cycle))) err-old-round)
         (asserts! (is-eq (len key) u33) err-invalid-aggregate-public-key)
-        (asserts! (is-unique-aggregated-public-key key {reward-cycle: reward-cycle, round: round}) err-duplicate-aggregate-public-key)
+        (asserts! (is-valid-aggregated-public-key key {reward-cycle: reward-cycle, round: round}) err-duplicate-aggregate-public-key)
         (asserts! (map-insert votes {reward-cycle: reward-cycle, round: round, signer: tx-sender} {aggregate-public-key: key, reward-slots: num-slots}) err-duplicate-vote)
         (map-set tally tally-key new-total)
+        (update-last-round reward-cycle round)
         (print "voted")
-        (ok true)))
\ No newline at end of file
+        (ok true)))
+
+(define-private (update-last-round (reward-cycle uint) (round uint))
+    (match (map-get? rounds reward-cycle)
+        last-round (and (> round last-round) (map-set rounds reward-cycle round))
+        true))
\ No newline at end of file
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_vote_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_vote_tests.rs
index 98c774b5c2..4ee149a197 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_vote_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_vote_tests.rs
@@ -60,7 +60,7 @@ use crate::chainstate::stacks::boot::pox_4_tests::{
     assert_latest_was_burn, get_last_block_sender_transactions, get_tip, make_test_epochs_pox,
 };
 use crate::chainstate::stacks::boot::{
-    BOOT_CODE_COST_VOTING_TESTNET as BOOT_CODE_COST_VOTING, BOOT_CODE_POX_TESTNET, POX_4_VOTE_NAME
+    BOOT_CODE_COST_VOTING_TESTNET as BOOT_CODE_COST_VOTING, BOOT_CODE_POX_TESTNET, POX_4_VOTE_NAME,
 };
 use crate::chainstate::stacks::db::{
     MinerPaymentSchedule, StacksChainState, StacksHeaderInfo, MINER_REWARD_MATURITY,
@@ -191,7 +191,7 @@ fn vote_for_aggregate_public_key() {
         tx_receipts[0].result,
         Value::Response(ResponseData {
             committed: false,
-            data: Box::new(Value::UInt(10004)) // err-duplicate-vote
+            data: Box::new(Value::UInt(10005)) // err-duplicate-vote
         })
     );
 
@@ -215,5 +215,5 @@ fn vote_for_aggregate_public_key() {
             committed: false,
             data: Box::new(Value::UInt(10001)) // err-incorrect-reward-cycle
         })
-    ); 
+    );
 }
diff --git a/stackslib/src/clarity_vm/clarity.rs b/stackslib/src/clarity_vm/clarity.rs
index ca898da558..3b37db550f 100644
--- a/stackslib/src/clarity_vm/clarity.rs
+++ b/stackslib/src/clarity_vm/clarity.rs
@@ -48,7 +48,8 @@ use crate::chainstate::stacks::boot::{
     BOOT_CODE_COST_VOTING_TESTNET as BOOT_CODE_COST_VOTING, BOOT_CODE_POX_TESTNET,
     BOOT_TEST_POX_4_AGG_KEY_CONTRACT, BOOT_TEST_POX_4_AGG_KEY_FNAME, COSTS_2_NAME, COSTS_3_NAME,
     MINERS_NAME, POX_2_MAINNET_CODE, POX_2_NAME, POX_2_TESTNET_CODE, POX_3_MAINNET_CODE,
-    POX_3_NAME, POX_3_TESTNET_CODE, POX_4_CODE, POX_4_NAME, SIGNERS_BODY, SIGNERS_NAME,
+    POX_3_NAME, POX_3_TESTNET_CODE, POX_4_CODE, POX_4_NAME, POX_4_VOTE_CODE, POX_4_VOTE_NAME,
+    SIGNERS_BODY, SIGNERS_NAME,
 };
 use crate::chainstate::stacks::db::{StacksAccount, StacksChainState};
 use crate::chainstate::stacks::events::{StacksTransactionEvent, StacksTransactionReceipt};
@@ -1449,6 +1450,43 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
                 );
             }
 
+            let pox_4_vote_code = &*POX_4_VOTE_CODE;
+            let pox_4_vote_contract_id = boot_code_id(POX_4_VOTE_NAME, mainnet);
+            let payload = TransactionPayload::SmartContract(
+                TransactionSmartContract {
+                    name: ContractName::try_from(POX_4_VOTE_NAME)
+                        .expect("FATAL: invalid boot-code contract name"),
+                    code_body: StacksString::from_str(pox_4_vote_code)
+                        .expect("FATAL: invalid boot code body"),
+                },
+                Some(ClarityVersion::Clarity2),
+            );
+
+            let signers_contract_tx =
+                StacksTransaction::new(tx_version.clone(), boot_code_auth.clone(), payload);
+
+            let pox_4_vote_initialization_receipt = self.as_transaction(|tx_conn| {
+                // initialize with a synthetic transaction
+                debug!("Instantiate {} contract", &pox_4_vote_contract_id);
+                let receipt = StacksChainState::process_transaction_payload(
+                    tx_conn,
+                    &signers_contract_tx,
+                    &boot_code_account,
+                    ASTRules::PrecheckSize,
+                )
+                .expect("FATAL: Failed to process .pox-4-vote contract initialization");
+                receipt
+            });
+
+            if pox_4_vote_initialization_receipt.result != Value::okay_true()
+                || pox_4_vote_initialization_receipt.post_condition_aborted
+            {
+                panic!(
+                    "FATAL: Failure processing pox-4-vote contract initialization: {:#?}",
+                    &pox_4_vote_initialization_receipt
+                );
+            }
+
             debug!("Epoch 2.5 initialized");
             (old_cost_tracker, Ok(vec![pox_4_initialization_receipt]))
         })

From 4e124e9ae55390e4b75318fa6ef9cc558cd7cc4d Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 26 Jan 2024 14:01:19 -0800
Subject: [PATCH 0511/1166] Make signer_signature_hash infallible and use it
 instead of block for proposal results and sending signatures back to miners

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 libsigner/src/events.rs                       |  39 +++++--
 stacks-signer/src/runloop.rs                  | 109 +++++++-----------
 stackslib/src/chainstate/nakamoto/mod.rs      |  26 ++++-
 .../src/chainstate/nakamoto/tests/node.rs     |   6 +-
 stackslib/src/net/api/postblock_proposal.rs   |  16 +--
 testnet/stacks-node/src/mockamoto.rs          |   2 +-
 testnet/stacks-node/src/mockamoto/signer.rs   |   6 +-
 .../stacks-node/src/nakamoto_node/miner.rs    |   8 +-
 testnet/stacks-node/src/tests/signer.rs       |  35 +++---
 9 files changed, 117 insertions(+), 130 deletions(-)

diff --git a/libsigner/src/events.rs b/libsigner/src/events.rs
index 702bee7302..0702f4b0ff 100644
--- a/libsigner/src/events.rs
+++ b/libsigner/src/events.rs
@@ -23,6 +23,7 @@ use std::sync::Arc;
 use blockstack_lib::chainstate::nakamoto::NakamotoBlock;
 use blockstack_lib::chainstate::stacks::boot::{MINERS_NAME, SIGNERS_NAME};
 use blockstack_lib::chainstate::stacks::events::StackerDBChunksEvent;
+use blockstack_lib::chainstate::stacks::{StacksTransaction, ThresholdSignature};
 use blockstack_lib::net::api::postblock_proposal::{
     BlockValidateReject, BlockValidateResponse, ValidateRejectCode,
 };
@@ -32,9 +33,11 @@ use serde::{Deserialize, Serialize};
 use stacks_common::codec::{
     read_next, read_next_at_most, write_next, Error as CodecError, StacksMessageCodec,
 };
+use stacks_common::util::hash::Sha512Trunc256Sum;
 use tiny_http::{
     Method as HttpMethod, Request as HttpRequest, Response as HttpResponse, Server as HttpServer,
 };
+use wsts::common::Signature;
 use wsts::net::{Message, Packet};
 
 use crate::http::{decode_http_body, decode_http_request};
@@ -73,11 +76,26 @@ pub enum SignerMessage {
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub enum BlockResponse {
     /// The Nakamoto block was accepted and therefore signed
-    Accepted(NakamotoBlock),
+    Accepted((Sha512Trunc256Sum, ThresholdSignature)),
     /// The Nakamoto block was rejected and therefore not signed
     Rejected(BlockRejection),
 }
 
+impl BlockResponse {
+    /// Create a new accepted BlockResponse for the provided block signer signature hash and signature
+    pub fn accepted(hash: Sha512Trunc256Sum, sig: Signature) -> Self {
+        Self::Accepted((hash, ThresholdSignature(sig)))
+    }
+
+    /// Create a new rejected BlockResponse for the provided block signer signature hash and signature
+    pub fn rejected(hash: Sha512Trunc256Sum, sig: Signature) -> Self {
+        Self::Rejected(BlockRejection::new(
+            hash,
+            RejectCode::SignedRejection(ThresholdSignature(sig)),
+        ))
+    }
+}
+
 /// A rejection response from a signer for a proposed block
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub struct BlockRejection {
@@ -85,17 +103,17 @@ pub struct BlockRejection {
     pub reason: String,
     /// The reason code for the rejection
     pub reason_code: RejectCode,
-    /// The block that was rejected
-    pub block: NakamotoBlock,
+    /// The signer signature hash of the block that was rejected
+    pub signer_signature_hash: Sha512Trunc256Sum,
 }
 
 impl BlockRejection {
     /// Create a new BlockRejection for the provided block and reason code
-    pub fn new(block: NakamotoBlock, reason_code: RejectCode) -> Self {
+    pub fn new(signer_signature_hash: Sha512Trunc256Sum, reason_code: RejectCode) -> Self {
         Self {
             reason: reason_code.to_string(),
             reason_code,
-            block,
+            signer_signature_hash,
         }
     }
 }
@@ -105,7 +123,7 @@ impl From<BlockValidateReject> for BlockRejection {
         Self {
             reason: reject.reason,
             reason_code: RejectCode::ValidationFailed(reject.reason_code),
-            block: reject.block,
+            signer_signature_hash: reject.signer_signature_hash,
         }
     }
 }
@@ -117,9 +135,7 @@ pub enum RejectCode {
     /// RPC endpoint Validation failed
     ValidationFailed(ValidateRejectCode),
     /// Signers signed a block rejection
-    SignedRejection,
-    /// Invalid signature hash
-    InvalidSignatureHash,
+    SignedRejection(ThresholdSignature),
     /// Insufficient signers agreed to sign the block
     InsufficientSigners(Vec<u32>),
 }
@@ -128,10 +144,9 @@ impl std::fmt::Display for RejectCode {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
             RejectCode::ValidationFailed(code) => write!(f, "Validation failed: {:?}", code),
-            RejectCode::SignedRejection => {
-                write!(f, "A threshold number of signers rejected the block.")
+            RejectCode::SignedRejection(sig) => {
+                write!(f, "A threshold number of signers rejected the block with the following signature: {:?}.", sig)
             }
-            RejectCode::InvalidSignatureHash => write!(f, "The signature hash was invalid."),
             RejectCode::InsufficientSigners(malicious_signers) => write!(
                 f,
                 "Insufficient signers agreed to sign the block. The following signers are malicious: {:?}",
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 24857adacd..74cb94f453 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -19,7 +19,6 @@ use std::time::Duration;
 
 use blockstack_lib::burnchains::Txid;
 use blockstack_lib::chainstate::nakamoto::NakamotoBlock;
-use blockstack_lib::chainstate::stacks::ThresholdSignature;
 use blockstack_lib::net::api::postblock_proposal::BlockValidateResponse;
 use hashbrown::{HashMap, HashSet};
 use libsigner::{
@@ -186,13 +185,10 @@ impl<C: Coordinator> RunLoop<C> {
                 is_taproot,
                 merkle_root,
             } => {
-                let Ok(hash) = block.header.signer_signature_hash() else {
-                    error!("Failed to sign block. Invalid signature hash.");
-                    return false;
-                };
+                let signer_signature_hash = block.header.signer_signature_hash();
                 let block_info = self
                     .blocks
-                    .entry(hash)
+                    .entry(signer_signature_hash)
                     .or_insert_with(|| BlockInfo::new(block.clone()));
                 if block_info.signing_round {
                     debug!("Received a sign command for a block we are already signing over. Ignore it.");
@@ -256,29 +252,27 @@ impl<C: Coordinator> RunLoop<C> {
         res: Sender<Vec<OperationResult>>,
     ) {
         let transactions = &self.transactions;
-        let (block_info, hash) = match block_validate_response {
+        let block_info = match block_validate_response {
             BlockValidateResponse::Ok(block_validate_ok) => {
-                let Ok(hash) = block_validate_ok.block.header.signer_signature_hash() else {
-                    self.broadcast_signature_hash_rejection(block_validate_ok.block);
-                    return;
-                };
-                let block_info = self
+                let Some(block_info) = self
                     .blocks
-                    .entry(hash)
-                    .or_insert(BlockInfo::new(block_validate_ok.block.clone()));
+                    .get_mut(&block_validate_ok.signer_signature_hash) else {
+                        // We have not seen this block before. Why are we getting a response for it?
+                        debug!("Received a block validate response for a block we have not seen before. Ignoring...");
+                        return;
+                    };
                 block_info.valid = Some(true);
-                (block_info, hash)
+                block_info
             }
             BlockValidateResponse::Reject(block_validate_reject) => {
                 // There is no point in triggering a sign round for this block if validation failed from the stacks node
-                let Ok(hash) = block_validate_reject.block.header.signer_signature_hash() else {
-                    self.broadcast_signature_hash_rejection(block_validate_reject.block);
-                    return;
-                };
-                let block_info = self
+                let Some(block_info) = self
                     .blocks
-                    .entry(hash)
-                    .or_insert(BlockInfo::new(block_validate_reject.block.clone()));
+                    .get_mut(&block_validate_reject.signer_signature_hash) else {
+                        // We have not seen this block before. Why are we getting a response for it?
+                        debug!("Received a block validate response for a block we have not seen before. Ignoring...");
+                        return;
+                    };
                 block_info.valid = Some(false);
                 // Submit a rejection response to the .signers contract for miners
                 // to observe so they know to send another block and to prove signers are doing work);
@@ -288,14 +282,14 @@ impl<C: Coordinator> RunLoop<C> {
                 ) {
                     warn!("Failed to send block rejection to stacker-db: {:?}", e);
                 }
-                (block_info, hash)
+                block_info
             }
         };
 
         if let Some(mut request) = block_info.nonce_request.take() {
             debug!("Received a block validate response from the stacks node for a block we already received a nonce request for. Responding to the nonce request...");
             // We have an associated nonce request. Respond to it
-            Self::determine_vote(block_info, &mut request, transactions, hash);
+            Self::determine_vote(block_info, &mut request, transactions);
             // Send the nonce request through with our vote
             let packet = Packet {
                 msg: Message::NonceRequest(request),
@@ -345,12 +339,11 @@ impl<C: Coordinator> RunLoop<C> {
     /// Handle proposed blocks submitted by the miners to stackerdb
     fn handle_proposed_blocks(&mut self, blocks: Vec<NakamotoBlock>) {
         for block in blocks {
-            let Ok(hash) = block.header.signer_signature_hash() else {
-                self.broadcast_signature_hash_rejection(block);
-                continue;
-            };
             // Store the block in our cache
-            self.blocks.insert(hash, BlockInfo::new(block.clone()));
+            self.blocks.insert(
+                block.header.signer_signature_hash(),
+                BlockInfo::new(block.clone()),
+            );
             // Submit the block for validation
             self.stacks_client
                 .submit_block_for_validation(block)
@@ -447,19 +440,14 @@ impl<C: Coordinator> RunLoop<C> {
             debug!("Received a nonce request for an unknown message stream. Reject it.");
             return false;
         };
-        let Ok(hash) = block.header.signer_signature_hash() else {
-            debug!(
-                "Received a nonce request for a block with an invalid signature hash. Reject it"
-            );
-            return false;
-        };
         let transactions = &self.transactions;
-        let Some(block_info) = self.blocks.get_mut(&hash) else {
+        let signer_signature_hash = block.header.signer_signature_hash();
+        let Some(block_info) = self.blocks.get_mut(&signer_signature_hash) else {
             // We have not seen this block before. Cache it. Send a RPC to the stacks node to validate it.
             debug!("We have received a block sign request for a block we have not seen before. Cache the nonce request and submit the block for validation...");
             // Store the block in our cache
             self.blocks.insert(
-                hash,
+                signer_signature_hash,
                 BlockInfo::new_with_request(block.clone(), request.clone()),
             );
             self.stacks_client
@@ -475,7 +463,7 @@ impl<C: Coordinator> RunLoop<C> {
             block_info.nonce_request = Some(request.clone());
             return false;
         }
-        Self::determine_vote(block_info, request, transactions, hash);
+        Self::determine_vote(block_info, request, transactions);
         true
     }
 
@@ -484,9 +472,8 @@ impl<C: Coordinator> RunLoop<C> {
         block_info: &mut BlockInfo,
         nonce_request: &mut NonceRequest,
         transactions: &[Txid],
-        hash: Sha512Trunc256Sum,
     ) {
-        let mut vote_bytes = hash.0.to_vec();
+        let mut vote_bytes = block_info.block.header.signer_signature_hash().0.to_vec();
         // Validate the block contents
         if !block_info.valid.unwrap_or(false)
             || !transactions
@@ -574,35 +561,32 @@ impl<C: Coordinator> RunLoop<C> {
         };
         let message = self.coordinator.get_message();
         // This jankiness is because a coordinator could have signed a rejection we need to find the underlying block hash
-        let block_hash_bytes = if message.len() > 32 {
+        let signer_signature_hash_bytes = if message.len() > 32 {
             &message[..32]
         } else {
             &message
         };
-        let Some(block_hash) = Sha512Trunc256Sum::from_bytes(block_hash_bytes) else {
+        let Some(signer_signature_hash) = Sha512Trunc256Sum::from_bytes(signer_signature_hash_bytes) else {
             debug!("Received a signature result for a signature over a non-block. Nothing to broadcast.");
             return;
         };
-        let Some(block_info) = self.blocks.remove(&block_hash) else {
-            debug!("Received a signature result for a block we have not seen before. Ignoring...");
-            return;
-        };
+
+        // TODO: proper garbage collection...This is currently our only cleanup of blocks
+        self.blocks.remove(&signer_signature_hash);
+
         // This signature is no longer valid. Do not broadcast it.
         if !signature.verify(aggregate_public_key, &message) {
             warn!("Received an invalid signature result across the block. Do not broadcast it.");
             // TODO: should we reinsert it and trigger a sign round across the block again?
             return;
         }
-        // Update the block signature hash with what the signers produced.
-        let mut block = block_info.block;
-        block.header.signer_signature = ThresholdSignature(signature.clone());
 
-        let block_submission = if message == block_hash.0.to_vec() {
+        let block_submission = if message == signer_signature_hash.0.to_vec() {
             // we agreed to sign the block hash. Return an approval message
-            BlockResponse::Accepted(block).into()
+            BlockResponse::accepted(signer_signature_hash, signature.clone()).into()
         } else {
             // We signed a rejection message. Return a rejection message
-            BlockRejection::new(block, RejectCode::SignedRejection).into()
+            BlockResponse::rejected(signer_signature_hash, signature.clone()).into()
         };
 
         // Submit signature result to miners to observe
@@ -627,16 +611,16 @@ impl<C: Coordinator> RunLoop<C> {
                 let block = read_next::<NakamotoBlock, _>(&mut &message[..]).ok().unwrap_or({
                     // This is not a block so maybe its across its hash
                     // This jankiness is because a coordinator could have signed a rejection we need to find the underlying block hash
-                    let block_hash_bytes = if message.len() > 32 {
+                    let signer_signature_hash_bytes = if message.len() > 32 {
                         &message[..32]
                     } else {
                         &message
                     };
-                    let Some(block_hash) = Sha512Trunc256Sum::from_bytes(block_hash_bytes) else {
+                    let Some(signer_signature_hash) = Sha512Trunc256Sum::from_bytes(signer_signature_hash_bytes) else {
                         debug!("Received a signature result for a signature over a non-block. Nothing to broadcast.");
                         return;
                     };
-                    let Some(block_info) = self.blocks.remove(&block_hash) else {
+                    let Some(block_info) = self.blocks.remove(&signer_signature_hash) else {
                         debug!("Received a signature result for a block we have not seen before. Ignoring...");
                         return;
                     };
@@ -644,7 +628,7 @@ impl<C: Coordinator> RunLoop<C> {
                 });
                 // We don't have enough signers to sign the block. Broadcast a rejection
                 let block_rejection = BlockRejection::new(
-                    block,
+                    block.header.signer_signature_hash(),
                     RejectCode::InsufficientSigners(malicious_signers.clone()),
                 );
                 // Submit signature result to miners to observe
@@ -696,19 +680,6 @@ impl<C: Coordinator> RunLoop<C> {
             }
         }
     }
-
-    /// Broadcast a block rejection due to an invalid block signature hash
-    fn broadcast_signature_hash_rejection(&mut self, block: NakamotoBlock) {
-        debug!("Broadcasting a block rejection due to a block with an invalid signature hash...");
-        let block_rejection = BlockRejection::new(block, RejectCode::InvalidSignatureHash);
-        // Submit signature result to miners to observe
-        if let Err(e) = self
-            .stackerdb
-            .send_message_with_retry(self.signing_round.signer_id, block_rejection.into())
-        {
-            warn!("Failed to send block submission to stacker-db: {:?}", e);
-        }
-    }
 }
 
 impl From<&Config> for RunLoop<FireCoordinator<v2::Aggregator>> {
diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index 074018d756..e739c3de89 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -386,7 +386,21 @@ impl StacksMessageCodec for NakamotoBlockHeader {
 impl NakamotoBlockHeader {
     /// Calculate the message digest for miners to sign.
     /// This includes all fields _except_ the signatures.
-    pub fn miner_signature_hash(&self) -> Result<Sha512Trunc256Sum, CodecError> {
+    pub fn miner_signature_hash(&self) -> Sha512Trunc256Sum {
+        self.miner_signature_hash_inner()
+            .expect("BUG: failed to calculate miner signature hash")
+    }
+
+    /// Calculate the message digest for signers to sign.
+    /// This includes all fields _except_ the signer signature.
+    pub fn signer_signature_hash(&self) -> Sha512Trunc256Sum {
+        self.signer_signature_hash_inner()
+            .expect("BUG: failed to calculate signer signature hash")
+    }
+
+    /// Inner calculation of the message digest for miners to sign.
+    /// This includes all fields _except_ the signatures.
+    fn miner_signature_hash_inner(&self) -> Result<Sha512Trunc256Sum, CodecError> {
         let mut hasher = Sha512_256::new();
         let fd = &mut hasher;
         write_next(fd, &self.version)?;
@@ -399,9 +413,9 @@ impl NakamotoBlockHeader {
         Ok(Sha512Trunc256Sum::from_hasher(hasher))
     }
 
-    /// Calculate the message digest for stackers to sign.
+    /// Inner calculation of the message digest for stackers to sign.
     /// This includes all fields _except_ the stacker signature.
-    pub fn signer_signature_hash(&self) -> Result<Sha512Trunc256Sum, CodecError> {
+    fn signer_signature_hash_inner(&self) -> Result<Sha512Trunc256Sum, CodecError> {
         let mut hasher = Sha512_256::new();
         let fd = &mut hasher;
         write_next(fd, &self.version)?;
@@ -416,7 +430,7 @@ impl NakamotoBlockHeader {
     }
 
     pub fn recover_miner_pk(&self) -> Option<StacksPublicKey> {
-        let signed_hash = self.miner_signature_hash().ok()?;
+        let signed_hash = self.miner_signature_hash();
         let recovered_pk =
             StacksPublicKey::recover_to_pubkey(signed_hash.bits(), &self.miner_signature).ok()?;
 
@@ -438,7 +452,7 @@ impl NakamotoBlockHeader {
 
     /// Sign the block header by the miner
     pub fn sign_miner(&mut self, privk: &StacksPrivateKey) -> Result<(), ChainstateError> {
-        let sighash = self.miner_signature_hash()?.0;
+        let sighash = self.miner_signature_hash().0;
         let sig = privk
             .sign(&sighash)
             .map_err(|se| net_error::SigningError(se.to_string()))?;
@@ -1707,7 +1721,7 @@ impl NakamotoChainState {
         if !db_handle.expects_signer_signature(
             &block.header.consensus_hash,
             schnorr_signature,
-            &block.header.signer_signature_hash()?.0,
+            &block.header.signer_signature_hash().0,
             aggregate_public_key,
         )? {
             let msg = format!("Received block, but the stacker signature does not match the active stacking cycle");
diff --git a/stackslib/src/chainstate/nakamoto/tests/node.rs b/stackslib/src/chainstate/nakamoto/tests/node.rs
index 4f59a3851e..d9c9bc54e7 100644
--- a/stackslib/src/chainstate/nakamoto/tests/node.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/node.rs
@@ -130,11 +130,7 @@ impl Default for TestSigners {
 impl TestSigners {
     pub fn sign_nakamoto_block(&mut self, block: &mut NakamotoBlock) {
         let mut rng = rand_core::OsRng;
-        let msg = block
-            .header
-            .signer_signature_hash()
-            .expect("Failed to determine the block header signature hash for signers.")
-            .0;
+        let msg = block.header.signer_signature_hash().0;
         let (nonces, sig_shares, key_ids) =
             wsts::v2::test_helpers::sign(msg.as_slice(), &mut self.signer_parties, &mut rng);
 
diff --git a/stackslib/src/net/api/postblock_proposal.rs b/stackslib/src/net/api/postblock_proposal.rs
index 4091aabb5a..5d7b5f8321 100644
--- a/stackslib/src/net/api/postblock_proposal.rs
+++ b/stackslib/src/net/api/postblock_proposal.rs
@@ -31,7 +31,7 @@ use stacks_common::types::chainstate::{
 use stacks_common::types::net::PeerHost;
 use stacks_common::types::StacksPublicKeyBuffer;
 use stacks_common::util::get_epoch_time_ms;
-use stacks_common::util::hash::{hex_bytes, to_hex, Hash160, Sha256Sum};
+use stacks_common::util::hash::{hex_bytes, to_hex, Hash160, Sha256Sum, Sha512Trunc256Sum};
 use stacks_common::util::retry::BoundReader;
 
 use crate::burnchains::affirmation::AffirmationMap;
@@ -90,8 +90,7 @@ fn hex_deser_block<'de, D: serde::Deserializer<'de>>(d: D) -> Result<NakamotoBlo
 ///  that the stacks-node thinks should be rejected.
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct BlockValidateReject {
-    #[serde(serialize_with = "hex_ser_block", deserialize_with = "hex_deser_block")]
-    pub block: NakamotoBlock,
+    pub signer_signature_hash: Sha512Trunc256Sum,
     pub reason: String,
     pub reason_code: ValidateRejectCode,
 }
@@ -119,8 +118,7 @@ where
 ///  that the stacks-node thinks is acceptable.
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct BlockValidateOk {
-    #[serde(serialize_with = "hex_ser_block", deserialize_with = "hex_deser_block")]
-    pub block: NakamotoBlock,
+    pub signer_signature_hash: Sha512Trunc256Sum,
     pub cost: ExecutionCost,
     pub size: u64,
 }
@@ -166,7 +164,7 @@ impl NakamotoBlockProposal {
                 let result =
                     self.validate(&sortdb, &mut chainstate)
                         .map_err(|reason| BlockValidateReject {
-                            block: self.block.clone(),
+                            signer_signature_hash: self.block.header.signer_signature_hash(),
                             reason_code: reason.reason_code,
                             reason: reason.reason,
                         });
@@ -326,7 +324,11 @@ impl NakamotoBlockProposal {
             })
         );
 
-        Ok(BlockValidateOk { block, cost, size })
+        Ok(BlockValidateOk {
+            signer_signature_hash: block.header.signer_signature_hash(),
+            cost,
+            size,
+        })
     }
 }
 
diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index bb92048b00..aadfb2feca 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -976,7 +976,7 @@ impl MockamotoNode {
 
         let miner_signature = self
             .miner_key
-            .sign(block.header.miner_signature_hash().unwrap().as_bytes())
+            .sign(block.header.miner_signature_hash().as_bytes())
             .unwrap();
 
         block.header.miner_signature = miner_signature;
diff --git a/testnet/stacks-node/src/mockamoto/signer.rs b/testnet/stacks-node/src/mockamoto/signer.rs
index fadc98f570..48c4eb57c0 100644
--- a/testnet/stacks-node/src/mockamoto/signer.rs
+++ b/testnet/stacks-node/src/mockamoto/signer.rs
@@ -66,11 +66,7 @@ impl SelfSigner {
 
     pub fn sign_nakamoto_block(&mut self, block: &mut NakamotoBlock) {
         let mut rng = rand::rngs::OsRng::default();
-        let msg = block
-            .header
-            .signer_signature_hash()
-            .expect("Failed to determine the block header signature hash for signers.")
-            .0;
+        let msg = block.header.signer_signature_hash().0;
         let (nonces, sig_shares, key_ids) =
             wsts::v2::test_helpers::sign(msg.as_slice(), &mut self.signer_parties, &mut rng);
 
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index ffa50de4a3..fef3379fbd 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -562,13 +562,7 @@ impl BlockMinerThread {
 
         let mining_key = self.keychain.get_nakamoto_sk();
         let miner_signature = mining_key
-            .sign(
-                block
-                    .header
-                    .miner_signature_hash()
-                    .map_err(|_| NakamotoNodeError::SigningError("Could not create sighash"))?
-                    .as_bytes(),
-            )
+            .sign(block.header.miner_signature_hash().as_bytes())
             .map_err(NakamotoNodeError::SigningError)?;
         block.header.miner_signature = miner_signature;
 
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index 00397b4967..4d066cd223 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -382,12 +382,7 @@ fn stackerdb_dkg_sign() {
     block.header.tx_merkle_root = tx_merkle_root;
 
     // The block is invalid so the signers should return a signature across its hash + b'n'
-    let mut msg = block
-        .header
-        .signer_signature_hash()
-        .expect("Failed to get signature hash")
-        .0
-        .to_vec();
+    let mut msg = block.header.signer_signature_hash().0.to_vec();
     msg.push(b'n');
 
     let signer_test = SignerTest::new(10, 400);
@@ -640,16 +635,16 @@ fn stackerdb_block_proposal() {
         thread::sleep(Duration::from_secs(1));
     }
     let validate_responses = test_observer::get_proposal_responses();
-    let mut proposed_block = match validate_responses.first().expect("No block proposal") {
-        BlockValidateResponse::Ok(block_validated) => block_validated.block.clone(),
-        _ => panic!("Unexpected response"),
-    };
-    let signature_hash = proposed_block
-        .header
-        .signer_signature_hash()
-        .expect("Unable to retrieve signature hash from proposed block");
+    let proposed_signer_signature_hash =
+        match validate_responses.first().expect("No block proposal") {
+            BlockValidateResponse::Ok(block_validated) => block_validated.signer_signature_hash,
+            _ => panic!("Unexpected response"),
+        };
     assert!(
-        signature.verify(&aggregate_public_key, signature_hash.0.as_slice()),
+        signature.verify(
+            &aggregate_public_key,
+            proposed_signer_signature_hash.0.as_slice()
+        ),
         "Signature verification failed"
     );
     // Verify that the signers broadcasted a signed NakamotoBlock back to the .signers contract
@@ -678,9 +673,13 @@ fn stackerdb_block_proposal() {
     }
     let chunk = chunk.unwrap();
     let signer_message = bincode::deserialize::<SignerMessage>(&chunk).unwrap();
-    if let SignerMessage::BlockResponse(BlockResponse::Accepted(block)) = signer_message {
-        proposed_block.header.signer_signature = ThresholdSignature(signature);
-        assert_eq!(block, proposed_block);
+    if let SignerMessage::BlockResponse(BlockResponse::Accepted((
+        block_signer_signature_hash,
+        block_signature,
+    ))) = signer_message
+    {
+        assert_eq!(block_signer_signature_hash, proposed_signer_signature_hash);
+        assert_eq!(block_signature, ThresholdSignature(signature));
     } else {
         panic!("Received unexpected message");
     }

From d8eac4310ef04f3e4e36af26c0b9fad98d1970a7 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 26 Jan 2024 14:11:35 -0800
Subject: [PATCH 0512/1166] Cargo fmt stuff

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/config.rs  |  4 ++--
 stacks-signer/src/runloop.rs | 26 +++++++++++++++-----------
 2 files changed, 17 insertions(+), 13 deletions(-)

diff --git a/stacks-signer/src/config.rs b/stacks-signer/src/config.rs
index 0d1b453157..dbc8e0abf4 100644
--- a/stacks-signer/src/config.rs
+++ b/stacks-signer/src/config.rs
@@ -340,10 +340,10 @@ impl Config {
 
 #[cfg(test)]
 mod tests {
-    use super::Network;
-    use super::{Config, RawConfigFile};
     use blockstack_lib::util_lib::boot::boot_code_id;
 
+    use super::{Config, Network, RawConfigFile};
+
     fn create_raw_config(overrides: impl FnOnce(&mut RawConfigFile)) -> RawConfigFile {
         let mut config = RawConfigFile {
             node_host: "127.0.0.1:20443".to_string(),
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 74cb94f453..81342ed427 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -256,11 +256,12 @@ impl<C: Coordinator> RunLoop<C> {
             BlockValidateResponse::Ok(block_validate_ok) => {
                 let Some(block_info) = self
                     .blocks
-                    .get_mut(&block_validate_ok.signer_signature_hash) else {
-                        // We have not seen this block before. Why are we getting a response for it?
-                        debug!("Received a block validate response for a block we have not seen before. Ignoring...");
-                        return;
-                    };
+                    .get_mut(&block_validate_ok.signer_signature_hash)
+                else {
+                    // We have not seen this block before. Why are we getting a response for it?
+                    debug!("Received a block validate response for a block we have not seen before. Ignoring...");
+                    return;
+                };
                 block_info.valid = Some(true);
                 block_info
             }
@@ -268,11 +269,12 @@ impl<C: Coordinator> RunLoop<C> {
                 // There is no point in triggering a sign round for this block if validation failed from the stacks node
                 let Some(block_info) = self
                     .blocks
-                    .get_mut(&block_validate_reject.signer_signature_hash) else {
-                        // We have not seen this block before. Why are we getting a response for it?
-                        debug!("Received a block validate response for a block we have not seen before. Ignoring...");
-                        return;
-                    };
+                    .get_mut(&block_validate_reject.signer_signature_hash)
+                else {
+                    // We have not seen this block before. Why are we getting a response for it?
+                    debug!("Received a block validate response for a block we have not seen before. Ignoring...");
+                    return;
+                };
                 block_info.valid = Some(false);
                 // Submit a rejection response to the .signers contract for miners
                 // to observe so they know to send another block and to prove signers are doing work);
@@ -566,7 +568,9 @@ impl<C: Coordinator> RunLoop<C> {
         } else {
             &message
         };
-        let Some(signer_signature_hash) = Sha512Trunc256Sum::from_bytes(signer_signature_hash_bytes) else {
+        let Some(signer_signature_hash) =
+            Sha512Trunc256Sum::from_bytes(signer_signature_hash_bytes)
+        else {
             debug!("Received a signature result for a signature over a non-block. Nothing to broadcast.");
             return;
         };

From d7674bab0dc1c3a722d462de4c1647bfc65cedef Mon Sep 17 00:00:00 2001
From: ASuciuX <asuciu@hiro.so>
Date: Mon, 29 Jan 2024 19:02:41 +0200
Subject: [PATCH 0513/1166] feat: mutants - add pr differences file for 'next'
 branch

---
 .github/workflows/pr-differences-mutants.yml | 139 +++++++++++++++++++
 1 file changed, 139 insertions(+)
 create mode 100644 .github/workflows/pr-differences-mutants.yml

diff --git a/.github/workflows/pr-differences-mutants.yml b/.github/workflows/pr-differences-mutants.yml
new file mode 100644
index 0000000000..041db97591
--- /dev/null
+++ b/.github/workflows/pr-differences-mutants.yml
@@ -0,0 +1,139 @@
+name: PR Differences Mutants
+
+on:
+  pull_request:
+    types:
+      - opened
+      - reopened
+      - synchronize
+      - ready_for_review
+    paths:
+      - "**.rs"
+
+concurrency:
+  group: pr-differences-${{ github.head_ref || github.ref || github.run_id }}
+  # Always cancel duplicate jobs
+  cancel-in-progress: true
+
+jobs:
+  # Check and output whether to run big (`stacks-node`/`stackslib`) or small (others) packages with or without shards
+  check-big-packages-and-shards:
+    name: Check Packages and Shards
+
+    runs-on: ubuntu-latest
+
+    outputs:
+      run_big_packages: ${{ steps.check_packages_and_shards.outputs.run_big_packages }}
+      big_packages_with_shards: ${{ steps.check_packages_and_shards.outputs.big_packages_with_shards }}
+      run_small_packages: ${{ steps.check_packages_and_shards.outputs.run_small_packages }}
+      small_packages_with_shards: ${{ steps.check_packages_and_shards.outputs.small_packages_with_shards }}
+
+    steps:
+      - id: check_packages_and_shards
+        uses: stacks-network/actions/stacks-core/mutation-testing/check-packages-and-shards@main
+
+  # Mutation testing - Execute on PR on small packages that have functions modified (normal run, no shards)
+  pr-differences-mutants-small-normal:
+    name: Mutation Testing - Normal, Small
+
+    needs: check-big-packages-and-shards
+
+    if: ${{ needs.check-big-packages-and-shards.outputs.run_small_packages == 'true' && needs.check-big-packages-and-shards.outputs.small_packages_with_shards == 'false' }}
+
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Run mutants on diffs
+        uses: stacks-network/actions/stacks-core/mutation-testing/pr-differences@main
+        with:
+          package-dimension: "small"
+
+  # Mutation testing - Execute on PR on small packages that have functions modified (run with strategy matrix shards)
+  pr-differences-mutants-small-shards:
+    name: Mutation Testing - Shards, Small
+
+    needs: check-big-packages-and-shards
+
+    if: ${{ needs.check-big-packages-and-shards.outputs.run_small_packages == 'true' && needs.check-big-packages-and-shards.outputs.small_packages_with_shards == 'true' }}
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      fail-fast: false
+      matrix:
+        shard: [0, 1, 2, 3]
+
+    steps:
+      - name: Run mutants on diffs
+        uses: stacks-network/actions/stacks-core/mutation-testing/pr-differences@main
+        with:
+          shard: ${{ matrix.shard }}
+          package-dimension: "small"
+
+  # Mutation testing - Execute on PR on big packages that have functions modified (normal run, no shards)
+  pr-differences-mutants-big-normal:
+    name: Mutation Testing - Normal, Big
+
+    needs: check-big-packages-and-shards
+
+    if: ${{ needs.check-big-packages-and-shards.outputs.run_big_packages == 'true' && needs.check-big-packages-and-shards.outputs.big_packages_with_shards == 'false' }}
+
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Run Run mutants on diffs
+        env:
+          BITCOIND_TEST: 1
+          RUST_BACKTRACE: full
+        uses: stacks-network/actions/stacks-core/mutation-testing/pr-differences@main
+        with:
+          package-dimension: "big"
+
+  # Mutation testing - Execute on PR on big packages that have functions modified (run with strategy matrix shards)
+  pr-differences-mutants-big-shards:
+    name: Mutation Testing - Shards, Big
+
+    needs: check-big-packages-and-shards
+
+    if: ${{ needs.check-big-packages-and-shards.outputs.run_big_packages == 'true' && needs.check-big-packages-and-shards.outputs.big_packages_with_shards == 'true' }}
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      fail-fast: false
+      matrix:
+        shard: [0, 1, 2, 3, 4, 5, 6, 7]
+
+    steps:
+      - name: Run mutants on diffs
+        env:
+          BITCOIND_TEST: 1
+          RUST_BACKTRACE: full
+        uses: stacks-network/actions/stacks-core/mutation-testing/pr-differences@main
+        with:
+          shard: ${{ matrix.shard }}
+          package-dimension: "big"
+
+  # Output the mutants and fail the workflow if there are missed/timeout/unviable mutants
+  output-mutants:
+    name: Output Mutants
+
+    runs-on: ubuntu-latest
+
+    needs:
+      [
+        check-big-packages-and-shards,
+        pr-differences-mutants-small-normal,
+        pr-differences-mutants-small-shards,
+        pr-differences-mutants-big-normal,
+        pr-differences-mutants-big-shards,
+      ]
+
+    steps:
+      - name: Output Mutants
+        uses: stacks-network/actions/stacks-core/mutation-testing/output-pr-mutants@main
+        with:
+          big_packages: ${{ needs.check-big-packages-and-shards.outputs.run_big_packages }}
+          shards_for_big_packages: ${{ needs.check-big-packages-and-shards.outputs.big_packages_with_shards }}
+          small_packages: ${{ needs.check-big-packages-and-shards.outputs.run_small_packages }}
+          shards_for_small_packages: ${{ needs.check-big-packages-and-shards.outputs.small_packages_with_shards }}

From 1067cdb27d2a60527d8208cf100cd1de94fb898f Mon Sep 17 00:00:00 2001
From: friedger <mail@friedger.de>
Date: Mon, 29 Jan 2024 18:06:57 +0100
Subject: [PATCH 0514/1166] chore: add get-last-round function

---
 .../tests/pox-4/pox-4-vote.test.ts            | 106 ++++++++++++++++++
 .../chainstate/stacks/boot/pox-4-vote.clar    |   5 +-
 2 files changed, 110 insertions(+), 1 deletion(-)
 create mode 100644 contrib/core-contract-tests/tests/pox-4/pox-4-vote.test.ts

diff --git a/contrib/core-contract-tests/tests/pox-4/pox-4-vote.test.ts b/contrib/core-contract-tests/tests/pox-4/pox-4-vote.test.ts
new file mode 100644
index 0000000000..aadf3e4a6b
--- /dev/null
+++ b/contrib/core-contract-tests/tests/pox-4/pox-4-vote.test.ts
@@ -0,0 +1,106 @@
+import { Cl } from "@stacks/transactions";
+import { beforeEach, describe, expect, it } from "vitest";
+import { createHash } from "node:crypto";
+
+const accounts = simnet.getAccounts();
+const alice = accounts.get("wallet_1")!;
+const bob = accounts.get("wallet_2")!;
+const charlie = accounts.get("wallet_3")!;
+
+const ERR_INVALID_AGGREGATE_PUBLIC_KEY = 10003;
+
+describe("test pox-4-vote contract voting rounds", () => {
+    it("should return none before any vote", () => {
+
+        const { result: resultRound } = simnet.callReadOnlyFn(
+            "pox-4-vote",
+            "get-last-round",
+            [Cl.uint(0)],
+            alice,
+        );
+        expect(resultRound).toEqual(Cl.none());
+    })
+
+    it("should return none after invalid vote", () => {
+        const { result: resultVote } = simnet.callPublicFn("pox-4-vote", "vote-for-aggregate-public-key",
+            [Cl.bufferFromHex("12"), Cl.uint(0), Cl.uint(0),], alice);
+        expect(resultVote).toEqual(Cl.error(Cl.uint(ERR_INVALID_AGGREGATE_PUBLIC_KEY)));
+
+        const { result: resultRound } = simnet.callReadOnlyFn(
+            "pox-4-vote",
+            "get-last-round",
+            [Cl.uint(0)],
+            alice,
+        );
+        expect(resultRound).toEqual(Cl.none());
+
+    })
+
+    it("should return round after valid vote", () => {
+        const { result: resultVote } = simnet.callPublicFn("pox-4-vote", "vote-for-aggregate-public-key",
+            [Cl.bufferFromHex("123456789a123456789a123456789a123456789a123456789a123456789a010203"), Cl.uint(0), Cl.uint(0),], alice);
+        expect(resultVote).toEqual(Cl.ok(Cl.bool(true)));
+
+        const { result: resultRound } = simnet.callReadOnlyFn(
+            "pox-4-vote",
+            "get-last-round",
+            [Cl.uint(0)],
+            alice,
+        );
+        expect(resultRound).toEqual(Cl.some(Cl.uint(0)));
+
+    })
+
+    it("should return last round after valid votes for two rounds", () => {
+        // Alice votes for cycle 0, round 0
+        const { result: resultVoteAlice } = simnet.callPublicFn("pox-4-vote", "vote-for-aggregate-public-key",
+            [Cl.bufferFromHex("123456789a123456789a123456789a123456789a123456789a123456789a010203"), Cl.uint(0), Cl.uint(0),], alice);
+        expect(resultVoteAlice).toEqual(Cl.ok(Cl.bool(true)));
+
+        // Bob votes for cycle 0, round 1
+        const { result: resultVoteBob } = simnet.callPublicFn("pox-4-vote", "vote-for-aggregate-public-key",
+            [Cl.bufferFromHex("123456789a123456789a123456789a123456789a123456789a123456789ab0b1b2"), Cl.uint(0), Cl.uint(1),], bob);
+        expect(resultVoteBob).toEqual(Cl.ok(Cl.bool(true)));
+
+        const { result: resultLastRound0 } = simnet.callReadOnlyFn(
+            "pox-4-vote",
+            "get-last-round",
+            [Cl.uint(0)],
+            alice,
+        );
+        expect(resultLastRound0).toEqual(Cl.some(Cl.uint(1)));
+    })
+
+    it("should return last round after valid votes for different cycles", () => {
+        // Alice votes for cycle 0, round 1
+        const { result: resultVoteAlice } = simnet.callPublicFn("pox-4-vote", "vote-for-aggregate-public-key",
+            [Cl.bufferFromHex("123456789a123456789a123456789a123456789a123456789a123456789a010203"), Cl.uint(0), Cl.uint(1),], alice);
+        expect(resultVoteAlice).toEqual(Cl.ok(Cl.bool(true)));
+
+        // advance to next cycle
+        simnet.mineEmptyBlocks(1050);
+
+        // Bob votes for cycle 1, round 0
+        const { result: resultVoteBob } = simnet.callPublicFn("pox-4-vote", "vote-for-aggregate-public-key",
+            [Cl.bufferFromHex("123456789a123456789a123456789a123456789a123456789a123456789ab0b1b2"), Cl.uint(1), Cl.uint(0),], bob);
+        expect(resultVoteBob).toEqual(Cl.ok(Cl.bool(true)));
+
+        const { result: resultLastRound0 } = simnet.callReadOnlyFn(
+            "pox-4-vote",
+            "get-last-round",
+            [Cl.uint(0)],
+            alice,
+        );
+        expect(resultLastRound0).toEqual(Cl.some(Cl.uint(1)));
+
+
+        const { result: resultLastRound1 } = simnet.callReadOnlyFn(
+            "pox-4-vote",
+            "get-last-round",
+            [Cl.uint(1)],
+            alice,
+        );
+        expect(resultLastRound1).toEqual(Cl.some(Cl.uint(0)));
+
+    })
+});
\ No newline at end of file
diff --git a/stackslib/src/chainstate/stacks/boot/pox-4-vote.clar b/stackslib/src/chainstate/stacks/boot/pox-4-vote.clar
index 6da008f54b..119067c718 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4-vote.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4-vote.clar
@@ -43,6 +43,9 @@
 (define-read-only (current-reward-cycle)
     (burn-height-to-reward-cycle burn-block-height))
     
+(define-read-only (get-last-round (reward-cycle uint))
+    (map-get? rounds reward-cycle))
+
 (define-read-only (get-signer-slots (signer principal) (reward-cycle uint))
     (contract-call? .signers get-signer-slots signer reward-cycle))
 
@@ -68,4 +71,4 @@
 (define-private (update-last-round (reward-cycle uint) (round uint))
     (match (map-get? rounds reward-cycle)
         last-round (and (> round last-round) (map-set rounds reward-cycle round))
-        true))
\ No newline at end of file
+        (map-set rounds reward-cycle round)))
\ No newline at end of file

From dea6f4160a8abafa53a925ad96b39fc5648d365d Mon Sep 17 00:00:00 2001
From: ASuciuX <asuciu@hiro.so>
Date: Mon, 29 Jan 2024 19:22:30 +0200
Subject: [PATCH 0515/1166] feat: add mutants documentation

---
 docs/ci-release.md | 95 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 95 insertions(+)

diff --git a/docs/ci-release.md b/docs/ci-release.md
index f042b05ed2..ff0bca229b 100644
--- a/docs/ci-release.md
+++ b/docs/ci-release.md
@@ -228,4 +228,99 @@ ex: Branch is named `develop` and the PR is numbered `113`
   - `stacks-core:2.1.0.0.0`
   - `stacks-core:latest`
 
+## Mutation Testing
+
+When a new Pull Request (PR) is submitted, this feature evaluates the quality of the tests added or modified in the PR.
+It checks the new and altered functions through mutation testing. 
+Mutation testing involves making small changes (mutations) to the code to check if the tests can detect these changes.
+
+The mutations are run with or without a [Github Actions matrix](https://docs.github.com/en/actions/using-jobs/using-a-matrix-for-your-jobs). 
+The matrix is used when there is a large number of mutations to run ([check doc specific cases](https://github.com/stacks-network/actions/blob/main/stacks-core/mutation-testing/check-packages-and-shards/README.md#outputs)).
+We utilize a matrix strategy with shards to enable parallel execution in GitHub Actions.
+This approach allows for the concurrent execution of multiple jobs across various runners.
+The total workload is divided across all shards, effectively reducing the overall duration of a workflow because the time taken is approximately the total time divided by the number of shards (+ initial build & test time).
+This is particularly advantageous for large packages that have significant build and test times, as it enhances efficiency and speeds up the process.
+
+Since mutation testing is directly correlated to the written tests, there are slower packages (due to the quantity or time it takes to run the tests) like `stackslib` or `stacks-node`. 
+These mutations are run separately from the others, with one or more parallel jobs, depending on the amount of mutations found.
+
+Once all the jobs have finished testing mutants, the last job collects all the tested mutations from the previous jobs, combines them and outputs them to the `Summary` section of the workflow, at the bottom of the page. 
+There, you can find all mutants on categories, with links to the function they tested, and a short description on how to fix the issue. 
+The PR should only be approved/merged after all the mutants tested are in the `Caught` category.
+
+### Time required to run the workflow based on mutants outcome and packages' size
+
+- Small packages typically completed in under 30 minutes, aided by the use of shards.
+- Large packages like stackslib and stacks-node initially required about 20-25 minutes for build and test processes.
+    - Each "missed" and "caught" mutant took approximately 15 minutes. Using shards, this meant about 50-55 minutes for processing around 32 mutants (10-16 functions modified). Every additional 8 mutants added another 15 minutes to the runtime.
+    - "Unviable" mutants, which are functions lacking a Default implementation for their returned struct type, took less than a minute each.
+    - "Timeout" mutants typically required more time. However, these should be marked to be skipped (by adding a skip flag to their header) since they indicate functions unable to proceed in their test workflow with mutated values, as opposed to the original implementations.
+
+File:
+
+- [PR Differences Mutants](../.github/workflows/pr-differences-mutants.yml)
+
+### Mutant Outcomes
+
+- caught — A test failed with this mutant applied. 
+This is a good sign about test coverage.
+
+- missed — No test failed with this mutation applied, which seems to indicate a gap in test coverage. 
+Or, it may be that the mutant is undistinguishable from the correct code. 
+In any case, you may wish to add a better test.
+
+- unviable — The attempted mutation doesn't compile. 
+This is inconclusive about test coverage, since the function's return structure may not implement `Default::default()` (one of the mutations applied), hence causing the compile to fail. 
+It is recommended to add `Default` implementation for the return structures of these functions, only mark that the function should be skipped as a last resort.
+
+- timeout — The mutation caused the test suite to run for a long time, until it was eventually killed.
+You might want to investigate the cause and only mark the function to be skipped if necessary.
+
+### Skipping Mutations
+
+Some functions may be inherently hard to cover with tests, for example if:
+
+- Generated mutants cause tests to hang.
+- You've chosen to test the functionality by human inspection or some higher-level integration tests.
+- The function has side effects or performance characteristics that are hard to test.
+- You've decided that the function is not important to test.
+
+To mark functions as skipped, so they are not mutated:
+
+- Add a Cargo dependency of the [mutants](https://crates.io/crates/mutants) crate, version `0.0.3` or later (this must be a regular `dependency`, not a `dev-dependency`, because the annotation will be on non-test code) and mark functions with `#[mutants::skip]`, or
+
+- You can avoid adding the dependency by using the slightly longer `#[cfg_attr(test, mutants::skip)]`.
+
+### Example
+
+```rust
+use std::time::{Duration, Instant};
+
+/// Returns true if the program should stop
+#[cfg_attr(test, mutants::skip)] // Returning false would cause a hang
+fn should_stop() -> bool {
+    true
+}
+
+pub fn controlled_loop() {
+    let start = Instant::now();
+    for i in 0.. {
+        println!("{}", i);
+        if should_stop() {
+            break;
+        }
+        if start.elapsed() > Duration::from_secs(60 * 5) {
+            panic!("timed out");
+        }
+    }
+}
+
+mod test {
+    #[test]
+    fn controlled_loop_terminates() {
+        super::controlled_loop()
+    }
+}
+```
+
 ---

From 6f92ef329a08fa605018848167d78fe56815e53b Mon Sep 17 00:00:00 2001
From: friedger <mail@friedger.de>
Date: Mon, 29 Jan 2024 18:32:04 +0100
Subject: [PATCH 0516/1166] chore: add more tests, remove is-state-1-active

---
 .../tests/pox-4/pox-4-vote.test.ts            | 280 ++++++++++++------
 .../chainstate/stacks/boot/pox-4-vote.clar    |   4 +-
 2 files changed, 188 insertions(+), 96 deletions(-)

diff --git a/contrib/core-contract-tests/tests/pox-4/pox-4-vote.test.ts b/contrib/core-contract-tests/tests/pox-4/pox-4-vote.test.ts
index aadf3e4a6b..f62b525acc 100644
--- a/contrib/core-contract-tests/tests/pox-4/pox-4-vote.test.ts
+++ b/contrib/core-contract-tests/tests/pox-4/pox-4-vote.test.ts
@@ -1,106 +1,198 @@
 import { Cl } from "@stacks/transactions";
 import { beforeEach, describe, expect, it } from "vitest";
-import { createHash } from "node:crypto";
 
 const accounts = simnet.getAccounts();
 const alice = accounts.get("wallet_1")!;
 const bob = accounts.get("wallet_2")!;
 const charlie = accounts.get("wallet_3")!;
 
+const ERR_NOT_ALLOWED = 10000;
+const ERR_INCORRECT_REWARD_CYCLE = 10001;
+const ERR_OLD_ROUND = 10002;
 const ERR_INVALID_AGGREGATE_PUBLIC_KEY = 10003;
+const ERR_DUPLICATE_AGGREGATE_PUBLIC_KEY = 10004
+const ERR_DUPLICATE_VOTE = 10005;
+const ERR_INVALID_BURN_BLOCK_HEIGHT = 10006
+
+const KEY_1 = "123456789a123456789a123456789a123456789a123456789a123456789a010203";
+const KEY_2 = "123456789a123456789a123456789a123456789a123456789a123456789ab0b1b2";
 
 describe("test pox-4-vote contract voting rounds", () => {
-    it("should return none before any vote", () => {
-
-        const { result: resultRound } = simnet.callReadOnlyFn(
-            "pox-4-vote",
-            "get-last-round",
-            [Cl.uint(0)],
-            alice,
-        );
-        expect(resultRound).toEqual(Cl.none());
-    })
-
-    it("should return none after invalid vote", () => {
-        const { result: resultVote } = simnet.callPublicFn("pox-4-vote", "vote-for-aggregate-public-key",
-            [Cl.bufferFromHex("12"), Cl.uint(0), Cl.uint(0),], alice);
-        expect(resultVote).toEqual(Cl.error(Cl.uint(ERR_INVALID_AGGREGATE_PUBLIC_KEY)));
-
-        const { result: resultRound } = simnet.callReadOnlyFn(
-            "pox-4-vote",
-            "get-last-round",
-            [Cl.uint(0)],
-            alice,
-        );
-        expect(resultRound).toEqual(Cl.none());
-
-    })
-
-    it("should return round after valid vote", () => {
-        const { result: resultVote } = simnet.callPublicFn("pox-4-vote", "vote-for-aggregate-public-key",
-            [Cl.bufferFromHex("123456789a123456789a123456789a123456789a123456789a123456789a010203"), Cl.uint(0), Cl.uint(0),], alice);
-        expect(resultVote).toEqual(Cl.ok(Cl.bool(true)));
-
-        const { result: resultRound } = simnet.callReadOnlyFn(
-            "pox-4-vote",
-            "get-last-round",
-            [Cl.uint(0)],
-            alice,
-        );
-        expect(resultRound).toEqual(Cl.some(Cl.uint(0)));
-
-    })
-
-    it("should return last round after valid votes for two rounds", () => {
-        // Alice votes for cycle 0, round 0
-        const { result: resultVoteAlice } = simnet.callPublicFn("pox-4-vote", "vote-for-aggregate-public-key",
-            [Cl.bufferFromHex("123456789a123456789a123456789a123456789a123456789a123456789a010203"), Cl.uint(0), Cl.uint(0),], alice);
-        expect(resultVoteAlice).toEqual(Cl.ok(Cl.bool(true)));
-
-        // Bob votes for cycle 0, round 1
-        const { result: resultVoteBob } = simnet.callPublicFn("pox-4-vote", "vote-for-aggregate-public-key",
-            [Cl.bufferFromHex("123456789a123456789a123456789a123456789a123456789a123456789ab0b1b2"), Cl.uint(0), Cl.uint(1),], bob);
-        expect(resultVoteBob).toEqual(Cl.ok(Cl.bool(true)));
-
-        const { result: resultLastRound0 } = simnet.callReadOnlyFn(
-            "pox-4-vote",
-            "get-last-round",
-            [Cl.uint(0)],
-            alice,
-        );
-        expect(resultLastRound0).toEqual(Cl.some(Cl.uint(1)));
-    })
-
-    it("should return last round after valid votes for different cycles", () => {
-        // Alice votes for cycle 0, round 1
-        const { result: resultVoteAlice } = simnet.callPublicFn("pox-4-vote", "vote-for-aggregate-public-key",
-            [Cl.bufferFromHex("123456789a123456789a123456789a123456789a123456789a123456789a010203"), Cl.uint(0), Cl.uint(1),], alice);
-        expect(resultVoteAlice).toEqual(Cl.ok(Cl.bool(true)));
-
-        // advance to next cycle
-        simnet.mineEmptyBlocks(1050);
-
-        // Bob votes for cycle 1, round 0
-        const { result: resultVoteBob } = simnet.callPublicFn("pox-4-vote", "vote-for-aggregate-public-key",
-            [Cl.bufferFromHex("123456789a123456789a123456789a123456789a123456789a123456789ab0b1b2"), Cl.uint(1), Cl.uint(0),], bob);
-        expect(resultVoteBob).toEqual(Cl.ok(Cl.bool(true)));
-
-        const { result: resultLastRound0 } = simnet.callReadOnlyFn(
-            "pox-4-vote",
-            "get-last-round",
-            [Cl.uint(0)],
-            alice,
-        );
-        expect(resultLastRound0).toEqual(Cl.some(Cl.uint(1)));
-
-
-        const { result: resultLastRound1 } = simnet.callReadOnlyFn(
-            "pox-4-vote",
-            "get-last-round",
-            [Cl.uint(1)],
-            alice,
-        );
-        expect(resultLastRound1).toEqual(Cl.some(Cl.uint(0)));
-
-    })
+    describe("test get-last-round", () => {
+        it("should return none before any vote", () => {
+
+            const { result: resultRound } = simnet.callReadOnlyFn(
+                "pox-4-vote",
+                "get-last-round",
+                [Cl.uint(0)],
+                alice,
+            );
+            expect(resultRound).toEqual(Cl.none());
+        })
+
+        it("should return none after invalid vote", () => {
+            const { result: resultVote } = simnet.callPublicFn("pox-4-vote", "vote-for-aggregate-public-key",
+                [Cl.bufferFromHex("12"), Cl.uint(0), Cl.uint(0),], alice);
+            expect(resultVote).toEqual(Cl.error(Cl.uint(ERR_INVALID_AGGREGATE_PUBLIC_KEY)));
+
+            const { result: resultRound } = simnet.callReadOnlyFn(
+                "pox-4-vote",
+                "get-last-round",
+                [Cl.uint(0)],
+                alice,
+            );
+            expect(resultRound).toEqual(Cl.none());
+
+        })
+
+        it("should return round after valid vote", () => {
+            const { result: resultVote } = simnet.callPublicFn("pox-4-vote", "vote-for-aggregate-public-key",
+                [Cl.bufferFromHex(KEY_1), Cl.uint(0), Cl.uint(0),], alice);
+            expect(resultVote).toEqual(Cl.ok(Cl.bool(true)));
+
+            const { result: resultRound } = simnet.callReadOnlyFn(
+                "pox-4-vote",
+                "get-last-round",
+                [Cl.uint(0)],
+                alice,
+            );
+            expect(resultRound).toEqual(Cl.some(Cl.uint(0)));
+
+        })
+
+        it("should return last round after valid votes for two rounds", () => {
+            // Alice votes for cycle 0, round 0
+            const { result: resultVoteAlice } = simnet.callPublicFn("pox-4-vote", "vote-for-aggregate-public-key",
+                [Cl.bufferFromHex(KEY_1), Cl.uint(0), Cl.uint(0),], alice);
+            expect(resultVoteAlice).toEqual(Cl.ok(Cl.bool(true)));
+
+            // Bob votes for cycle 0, round 1
+            const { result: resultVoteBob } = simnet.callPublicFn("pox-4-vote", "vote-for-aggregate-public-key",
+                [Cl.bufferFromHex(KEY_2), Cl.uint(0), Cl.uint(1),], bob);
+            expect(resultVoteBob).toEqual(Cl.ok(Cl.bool(true)));
+
+            const { result: resultLastRound0 } = simnet.callReadOnlyFn(
+                "pox-4-vote",
+                "get-last-round",
+                [Cl.uint(0)],
+                alice,
+            );
+            expect(resultLastRound0).toEqual(Cl.some(Cl.uint(1)));
+        })
+
+        it("should return last round after valid votes for different cycles", () => {
+            // Alice votes for cycle 0, round 1
+            const { result: resultVoteAlice } = simnet.callPublicFn("pox-4-vote", "vote-for-aggregate-public-key",
+                [Cl.bufferFromHex(KEY_1), Cl.uint(0), Cl.uint(1),], alice);
+            expect(resultVoteAlice).toEqual(Cl.ok(Cl.bool(true)));
+
+            // advance to next cycle
+            simnet.mineEmptyBlocks(1050);
+
+            // Bob votes for cycle 1, round 0
+            const { result: resultVoteBob } = simnet.callPublicFn("pox-4-vote", "vote-for-aggregate-public-key",
+                [Cl.bufferFromHex(KEY_2), Cl.uint(1), Cl.uint(0),], bob);
+            expect(resultVoteBob).toEqual(Cl.ok(Cl.bool(true)));
+
+            const { result: resultLastRound0 } = simnet.callReadOnlyFn(
+                "pox-4-vote",
+                "get-last-round",
+                [Cl.uint(0)],
+                alice,
+            );
+            expect(resultLastRound0).toEqual(Cl.some(Cl.uint(1)));
+
+
+            const { result: resultLastRound1 } = simnet.callReadOnlyFn(
+                "pox-4-vote",
+                "get-last-round",
+                [Cl.uint(1)],
+                alice,
+            );
+            expect(resultLastRound1).toEqual(Cl.some(Cl.uint(0)));
+
+        })
+
+    }),
+
+        describe("test voting", () => {
+
+            it("should fail on same key for different round", () => {
+                // Alice votes for cycle 0, round 0
+                const { result: resultVoteAlice } = simnet.callPublicFn("pox-4-vote", "vote-for-aggregate-public-key",
+                    [Cl.bufferFromHex(KEY_1), Cl.uint(0), Cl.uint(0),], alice);
+                expect(resultVoteAlice).toEqual(Cl.ok(Cl.bool(true)));
+
+                // Bob votes for cycle 0, round 1
+                const { result: resultVoteBob } = simnet.callPublicFn("pox-4-vote", "vote-for-aggregate-public-key",
+                    [Cl.bufferFromHex(KEY_1), Cl.uint(0), Cl.uint(1),], bob);
+                expect(resultVoteBob).toEqual(Cl.error(Cl.uint(ERR_DUPLICATE_AGGREGATE_PUBLIC_KEY)));
+
+            })
+
+            it("should fail on same key for different cycles", () => {
+                // Alice votes for cycle 0, round 0
+                const { result: resultVoteAlice } = simnet.callPublicFn("pox-4-vote", "vote-for-aggregate-public-key",
+                    [Cl.bufferFromHex(KEY_1), Cl.uint(0), Cl.uint(0),], alice);
+                expect(resultVoteAlice).toEqual(Cl.ok(Cl.bool(true)));
+
+                // advance to next cycle
+                simnet.mineEmptyBlocks(1050);
+
+                // Bob votes for cycle 1, round 0
+                const { result: resultVoteBob } = simnet.callPublicFn("pox-4-vote", "vote-for-aggregate-public-key",
+                    [Cl.bufferFromHex(KEY_1), Cl.uint(1), Cl.uint(0),], bob);
+                expect(resultVoteBob).toEqual(Cl.error(Cl.uint(ERR_DUPLICATE_AGGREGATE_PUBLIC_KEY)));
+
+            })
+
+            it("should fail on same key for different cycles", () => {
+                // Alice votes for cycle 0, round 0
+                const { result: resultVoteAlice } = simnet.callPublicFn("pox-4-vote", "vote-for-aggregate-public-key",
+                    [Cl.bufferFromHex(KEY_1), Cl.uint(0), Cl.uint(0),], alice);
+                expect(resultVoteAlice).toEqual(Cl.ok(Cl.bool(true)));
+
+                // advance to next cycle
+                simnet.mineEmptyBlocks(1050);
+
+                // Bob votes for cycle 1, round 0
+                const { result: resultVoteBob } = simnet.callPublicFn("pox-4-vote", "vote-for-aggregate-public-key",
+                    [Cl.bufferFromHex(KEY_1), Cl.uint(1), Cl.uint(0),], bob);
+                expect(resultVoteBob).toEqual(Cl.error(Cl.uint(ERR_DUPLICATE_AGGREGATE_PUBLIC_KEY)));
+
+            })
+
+            it("should fail on second vote for same cycle and round", () => {
+                // Alice votes for cycle 0, round 0
+                const { result: resultVoteAlice } = simnet.callPublicFn("pox-4-vote", "vote-for-aggregate-public-key",
+                    [Cl.bufferFromHex(KEY_1), Cl.uint(0), Cl.uint(0),], alice);
+                expect(resultVoteAlice).toEqual(Cl.ok(Cl.bool(true)));
+
+                // Alice votes for cycle 0, round 0 again
+                const { result: resultVoteAlice2 } = simnet.callPublicFn("pox-4-vote", "vote-for-aggregate-public-key",
+                    [Cl.bufferFromHex(KEY_1), Cl.uint(0), Cl.uint(0),], alice);
+                expect(resultVoteAlice2).toEqual(Cl.error(Cl.uint(ERR_DUPLICATE_VOTE)));
+
+            })
+
+            it("should fail on early vote", () => {
+                // Alice votes for cycle 1, round 0 during cycle 0
+                const { result: resultVoteAlice } = simnet.callPublicFn("pox-4-vote", "vote-for-aggregate-public-key",
+                    [Cl.bufferFromHex(KEY_1), Cl.uint(1), Cl.uint(0),], alice);
+                expect(resultVoteAlice).toEqual(Cl.error(Cl.uint(ERR_INCORRECT_REWARD_CYCLE)));
+
+            })
+
+            it("should fail on late round", () => {
+                // Alice votes for cycle 0, round 1
+                const { result: resultVoteAlice } = simnet.callPublicFn("pox-4-vote", "vote-for-aggregate-public-key",
+                    [Cl.bufferFromHex(KEY_1), Cl.uint(0), Cl.uint(1),], alice);
+                expect(resultVoteAlice).toEqual(Cl.ok(Cl.bool(true)));
+
+                // Bob votes for cycle 0, round 0
+                const { result: resultVoteBob } = simnet.callPublicFn("pox-4-vote", "vote-for-aggregate-public-key",
+                    [Cl.bufferFromHex(KEY_1), Cl.uint(0), Cl.uint(0),], bob);
+                expect(resultVoteBob).toEqual(Cl.error(Cl.uint(ERR_OLD_ROUND)));
+            })
+        })
 });
\ No newline at end of file
diff --git a/stackslib/src/chainstate/stacks/boot/pox-4-vote.clar b/stackslib/src/chainstate/stacks/boot/pox-4-vote.clar
index 119067c718..73176f9292 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4-vote.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4-vote.clar
@@ -23,7 +23,6 @@
 ;; maps reward-cycle ids to last round
 (define-map rounds uint uint)
 
-(define-data-var is-state-1-active bool true)
 (define-data-var state-1 {reward-cycle: uint, round: uint, aggregate-public-key: (optional (buff 33)),
     total-votes: uint}  {reward-cycle: u0, round: u0, aggregate-public-key: none, total-votes: u0})
 (define-data-var state-2 {reward-cycle: uint, round: uint, aggregate-public-key: (optional (buff 33)),
@@ -35,7 +34,7 @@
 
 ;; get current voting info
 (define-read-only (get-current-info)
-    (if (var-get is-state-1-active) (var-get state-1) (var-get state-2)))
+    (if (is-eq (/ (current-reward-cycle 2) 0)) (var-get state-1) (var-get state-2)))
 
 (define-read-only (burn-height-to-reward-cycle (height uint))
     (/ (- height (get first-burnchain-block-height pox-info)) (get reward-cycle-length pox-info)))
@@ -64,6 +63,7 @@
         (asserts! (is-valid-aggregated-public-key key {reward-cycle: reward-cycle, round: round}) err-duplicate-aggregate-public-key)
         (asserts! (map-insert votes {reward-cycle: reward-cycle, round: round, signer: tx-sender} {aggregate-public-key: key, reward-slots: num-slots}) err-duplicate-vote)
         (map-set tally tally-key new-total)
+        (map-set used-aggregate-public-keys key {reward-cycle: reward-cycle, round: round})
         (update-last-round reward-cycle round)
         (print "voted")
         (ok true)))

From 1800919b8954ac0457db6f9cd9bcc005754ae40b Mon Sep 17 00:00:00 2001
From: friedger <mail@friedger.de>
Date: Mon, 29 Jan 2024 18:38:23 +0100
Subject: [PATCH 0517/1166] fix: use correct type and brackets

---
 stackslib/src/chainstate/stacks/boot/pox-4-vote.clar | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox-4-vote.clar b/stackslib/src/chainstate/stacks/boot/pox-4-vote.clar
index 73176f9292..ea5c49c554 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4-vote.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4-vote.clar
@@ -34,7 +34,7 @@
 
 ;; get current voting info
 (define-read-only (get-current-info)
-    (if (is-eq (/ (current-reward-cycle 2) 0)) (var-get state-1) (var-get state-2)))
+    (if (is-eq (/ (current-reward-cycle) u2) u0) (var-get state-1) (var-get state-2)))
 
 (define-read-only (burn-height-to-reward-cycle (height uint))
     (/ (- height (get first-burnchain-block-height pox-info)) (get reward-cycle-length pox-info)))

From a8be048fa18ad25274570961b97805e0fba7f337 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Mon, 29 Jan 2024 13:54:36 -0500
Subject: [PATCH 0518/1166] fix: fix failing unit test

---
 stackslib/src/net/api/tests/liststackerdbreplicas.rs | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/stackslib/src/net/api/tests/liststackerdbreplicas.rs b/stackslib/src/net/api/tests/liststackerdbreplicas.rs
index 8c6504ea7e..c26f29c520 100644
--- a/stackslib/src/net/api/tests/liststackerdbreplicas.rs
+++ b/stackslib/src/net/api/tests/liststackerdbreplicas.rs
@@ -111,9 +111,10 @@ fn test_try_make_response() {
         Some(1)
     );
 
-    let mut resp = response.decode_stackerdb_replicas().unwrap();
-    assert_eq!(resp.len(), 1);
-    let naddr = resp.pop().unwrap();
+    let resp = response.decode_stackerdb_replicas().unwrap();
+    assert_eq!(resp.len(), 2);
+
+    let naddr = resp.last().clone().unwrap();
     assert_eq!(naddr.addrbytes, PeerAddress::from_ipv4(127, 0, 0, 1));
     assert_eq!(naddr.port, 0);
     assert_eq!(

From 9501bd2caf1d99cb913e4eea78e35974ace56071 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Mon, 22 Jan 2024 08:31:52 -0800
Subject: [PATCH 0519/1166] feat: add GET `/status` endpoint to signer

---
 libsigner/src/events.rs      | 16 ++++++++++++++++
 stacks-signer/src/runloop.rs |  3 +++
 2 files changed, 19 insertions(+)

diff --git a/libsigner/src/events.rs b/libsigner/src/events.rs
index 0702f4b0ff..19b5133758 100644
--- a/libsigner/src/events.rs
+++ b/libsigner/src/events.rs
@@ -211,6 +211,8 @@ pub enum SignerEvent {
     SignerMessages(Vec<SignerMessage>),
     /// A new block proposal validation response from the node
     BlockValidationResponse(BlockValidateResponse),
+    /// Status endpoint request
+    StatusCheck,
 }
 
 /// Trait to implement a stop-signaler for the event receiver thread.
@@ -381,6 +383,20 @@ impl EventReceiver for SignerEventReceiver {
                 return Err(EventError::Terminated);
             }
             let request = http_server.recv()?;
+
+            if request.method() == &HttpMethod::Get {
+                if request.url() == "/status" {
+                    request
+                    .respond(HttpResponse::from_string("OK"))
+                    .expect("response failed");
+                    return Ok(SignerEvent::StatusCheck);
+                }
+                return Err(EventError::MalformedRequest(format!(
+                    "Unrecognized GET request '{}'",
+                    &request.url(),
+                )));
+            }
+
             if request.method() != &HttpMethod::Post {
                 return Err(EventError::MalformedRequest(format!(
                     "Unrecognized method '{}'",
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 81342ed427..740c84a79b 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -805,6 +805,9 @@ impl<C: Coordinator> SignerRunLoop<Vec<OperationResult>, RunLoopCommand> for Run
                 debug!("Received block proposals from the miners...");
                 self.handle_proposed_blocks(blocks);
             }
+            Some(SignerEvent::StatusCheck) => {
+                debug!("Received a status check event.")
+            }
             None => {
                 // No event. Do nothing.
                 debug!("No event received")

From bdb2e3c02e5747e5ca19b683eaad26eadd945dee Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Tue, 23 Jan 2024 09:56:22 -0800
Subject: [PATCH 0520/1166] chore: add test for signer status endpoint

---
 libsigner/src/events.rs    | 16 +++++-----------
 libsigner/src/tests/mod.rs | 20 +++++++++++++++++++-
 2 files changed, 24 insertions(+), 12 deletions(-)

diff --git a/libsigner/src/events.rs b/libsigner/src/events.rs
index 19b5133758..4bacbdd20b 100644
--- a/libsigner/src/events.rs
+++ b/libsigner/src/events.rs
@@ -384,17 +384,11 @@ impl EventReceiver for SignerEventReceiver {
             }
             let request = http_server.recv()?;
 
-            if request.method() == &HttpMethod::Get {
-                if request.url() == "/status" {
-                    request
-                    .respond(HttpResponse::from_string("OK"))
-                    .expect("response failed");
-                    return Ok(SignerEvent::StatusCheck);
-                }
-                return Err(EventError::MalformedRequest(format!(
-                    "Unrecognized GET request '{}'",
-                    &request.url(),
-                )));
+            if request.url() == "/status" {
+                request
+                .respond(HttpResponse::from_string("OK"))
+                .expect("response failed");
+                return Ok(SignerEvent::StatusCheck);
             }
 
             if request.method() != &HttpMethod::Post {
diff --git a/libsigner/src/tests/mod.rs b/libsigner/src/tests/mod.rs
index deefc1018f..60889fc8c1 100644
--- a/libsigner/src/tests/mod.rs
+++ b/libsigner/src/tests/mod.rs
@@ -16,7 +16,7 @@
 
 mod http;
 
-use std::io::Write;
+use std::io::{Read, Write};
 use std::net::{SocketAddr, TcpStream, ToSocketAddrs};
 use std::sync::mpsc::{channel, Receiver, Sender};
 use std::time::Duration;
@@ -138,6 +138,24 @@ fn test_simple_signer() {
 
             num_sent += 1;
         }
+        // Test the /status endpoint
+        {
+            let mut sock = match TcpStream::connect(endpoint) {
+                Ok(sock) => sock,
+                Err(..) => {
+                    sleep_ms(100);
+                    return;
+                }
+            };
+            let req = "GET /status HTTP/1.0\r\nConnection: close\r\n\r\n";
+            sock.write_all(req.as_bytes()).unwrap();
+            let mut buf = [0; 128];
+            sock.read(&mut buf).unwrap();
+            let res_str = std::str::from_utf8(&buf).unwrap();
+            let expected_status_res = "HTTP/1.0 200 OK\r\n";
+            assert_eq!(expected_status_res, &res_str[..expected_status_res.len()]);
+            sock.flush().unwrap();
+        }
     });
 
     let running_signer = signer.spawn(endpoint).unwrap();

From 070a3ea4449e1396fd89466a641550e90e800da2 Mon Sep 17 00:00:00 2001
From: friedger <mail@friedger.de>
Date: Mon, 29 Jan 2024 23:08:36 +0100
Subject: [PATCH 0521/1166] feat: add get-vote

---
 .../tests/pox-4/pox-4-vote.test.ts            | 33 +++++++++++++++++++
 .../chainstate/stacks/boot/pox-4-vote.clar    |  3 ++
 2 files changed, 36 insertions(+)

diff --git a/contrib/core-contract-tests/tests/pox-4/pox-4-vote.test.ts b/contrib/core-contract-tests/tests/pox-4/pox-4-vote.test.ts
index f62b525acc..00cbd29eb5 100644
--- a/contrib/core-contract-tests/tests/pox-4/pox-4-vote.test.ts
+++ b/contrib/core-contract-tests/tests/pox-4/pox-4-vote.test.ts
@@ -195,4 +195,37 @@ describe("test pox-4-vote contract voting rounds", () => {
                 expect(resultVoteBob).toEqual(Cl.error(Cl.uint(ERR_OLD_ROUND)));
             })
         })
+
+    describe("test get-vote", () => {
+        it("should return correct aggregate-public-key and shared", () => {
+            // Alice votes for cycle 0, round 0
+            const { result: resultVoteAlice } = simnet.callPublicFn("pox-4-vote", "vote-for-aggregate-public-key",
+                [Cl.bufferFromHex(KEY_1), Cl.uint(0), Cl.uint(0),], alice);
+            expect(resultVoteAlice).toEqual(Cl.ok(Cl.bool(true)));
+
+            const { result: vote } = simnet.callReadOnlyFn(
+                "pox-4-vote",
+                "get-vote",
+                [Cl.uint(0), Cl.uint(0), Cl.standardPrincipal(alice)],
+                alice,
+            );
+            expect(vote).toEqual(Cl.some(Cl.tuple({
+                "aggregate-public-key": Cl.bufferFromHex(KEY_1),
+                "reward-slots":
+                    Cl.uint(1)
+            })));
+
+        });
+
+        it("should return none when not yet voted", () => {
+            const { result: vote } = simnet.callReadOnlyFn(
+                "pox-4-vote",
+                "get-vote",
+                [Cl.uint(0), Cl.uint(0), Cl.standardPrincipal(alice)],
+                alice,
+            );
+            expect(vote).toEqual(Cl.none());
+
+        });
+    })
 });
\ No newline at end of file
diff --git a/stackslib/src/chainstate/stacks/boot/pox-4-vote.clar b/stackslib/src/chainstate/stacks/boot/pox-4-vote.clar
index ea5c49c554..c41f2a9f9c 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4-vote.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4-vote.clar
@@ -45,6 +45,9 @@
 (define-read-only (get-last-round (reward-cycle uint))
     (map-get? rounds reward-cycle))
 
+(define-read-only (get-vote (reward-cycle uint) (round uint) (signer principal))
+    (map-get? votes {reward-cycle: reward-cycle, round: round, signer: signer}))
+    
 (define-read-only (get-signer-slots (signer principal) (reward-cycle uint))
     (contract-call? .signers get-signer-slots signer reward-cycle))
 

From f243be052aea2661fb1412e763cabafe2d5d1caf Mon Sep 17 00:00:00 2001
From: friedger <mail@friedger.de>
Date: Tue, 30 Jan 2024 09:56:16 +0100
Subject: [PATCH 0522/1166] chore: rename pox-4-vote to signers-voting

---
 contrib/core-contract-tests/Clarinet.toml     |  4 +-
 ...-4-vote.test.ts => signers-voting.test.ts} | 54 +++++++++----------
 stackslib/src/chainstate/stacks/boot/mod.rs   | 14 ++---
 .../{pox-4-vote.clar => signers-voting.clar}  |  0
 ..._vote_tests.rs => signers_voting_tests.rs} |  3 +-
 stackslib/src/clarity_vm/clarity.rs           | 26 ++++-----
 6 files changed, 51 insertions(+), 50 deletions(-)
 rename contrib/core-contract-tests/tests/pox-4/{pox-4-vote.test.ts => signers-voting.test.ts} (86%)
 rename stackslib/src/chainstate/stacks/boot/{pox-4-vote.clar => signers-voting.clar} (100%)
 rename stackslib/src/chainstate/stacks/boot/{pox_4_vote_tests.rs => signers_voting_tests.rs} (99%)

diff --git a/contrib/core-contract-tests/Clarinet.toml b/contrib/core-contract-tests/Clarinet.toml
index 04da62b42a..7bd70e4745 100644
--- a/contrib/core-contract-tests/Clarinet.toml
+++ b/contrib/core-contract-tests/Clarinet.toml
@@ -22,8 +22,8 @@ depends_on = []
 clarity = 2
 epoch = 2.4
 
-[contracts.pox-4-vote]
-path = "../../stackslib/src/chainstate/stacks/boot/pox-4-vote.clar"
+[contracts.signers-voting]
+path = "../../stackslib/src/chainstate/stacks/boot/signers-voting.clar"
 depends_on = []
 clarity = 2
 epoch = 2.4
diff --git a/contrib/core-contract-tests/tests/pox-4/pox-4-vote.test.ts b/contrib/core-contract-tests/tests/pox-4/signers-voting.test.ts
similarity index 86%
rename from contrib/core-contract-tests/tests/pox-4/pox-4-vote.test.ts
rename to contrib/core-contract-tests/tests/pox-4/signers-voting.test.ts
index 00cbd29eb5..56216eb78a 100644
--- a/contrib/core-contract-tests/tests/pox-4/pox-4-vote.test.ts
+++ b/contrib/core-contract-tests/tests/pox-4/signers-voting.test.ts
@@ -17,12 +17,12 @@ const ERR_INVALID_BURN_BLOCK_HEIGHT = 10006
 const KEY_1 = "123456789a123456789a123456789a123456789a123456789a123456789a010203";
 const KEY_2 = "123456789a123456789a123456789a123456789a123456789a123456789ab0b1b2";
 
-describe("test pox-4-vote contract voting rounds", () => {
+describe("test signers-voting contract voting rounds", () => {
     describe("test get-last-round", () => {
         it("should return none before any vote", () => {
 
             const { result: resultRound } = simnet.callReadOnlyFn(
-                "pox-4-vote",
+                "signers-voting",
                 "get-last-round",
                 [Cl.uint(0)],
                 alice,
@@ -31,12 +31,12 @@ describe("test pox-4-vote contract voting rounds", () => {
         })
 
         it("should return none after invalid vote", () => {
-            const { result: resultVote } = simnet.callPublicFn("pox-4-vote", "vote-for-aggregate-public-key",
+            const { result: resultVote } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
                 [Cl.bufferFromHex("12"), Cl.uint(0), Cl.uint(0),], alice);
             expect(resultVote).toEqual(Cl.error(Cl.uint(ERR_INVALID_AGGREGATE_PUBLIC_KEY)));
 
             const { result: resultRound } = simnet.callReadOnlyFn(
-                "pox-4-vote",
+                "signers-voting",
                 "get-last-round",
                 [Cl.uint(0)],
                 alice,
@@ -46,12 +46,12 @@ describe("test pox-4-vote contract voting rounds", () => {
         })
 
         it("should return round after valid vote", () => {
-            const { result: resultVote } = simnet.callPublicFn("pox-4-vote", "vote-for-aggregate-public-key",
+            const { result: resultVote } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
                 [Cl.bufferFromHex(KEY_1), Cl.uint(0), Cl.uint(0),], alice);
             expect(resultVote).toEqual(Cl.ok(Cl.bool(true)));
 
             const { result: resultRound } = simnet.callReadOnlyFn(
-                "pox-4-vote",
+                "signers-voting",
                 "get-last-round",
                 [Cl.uint(0)],
                 alice,
@@ -62,17 +62,17 @@ describe("test pox-4-vote contract voting rounds", () => {
 
         it("should return last round after valid votes for two rounds", () => {
             // Alice votes for cycle 0, round 0
-            const { result: resultVoteAlice } = simnet.callPublicFn("pox-4-vote", "vote-for-aggregate-public-key",
+            const { result: resultVoteAlice } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
                 [Cl.bufferFromHex(KEY_1), Cl.uint(0), Cl.uint(0),], alice);
             expect(resultVoteAlice).toEqual(Cl.ok(Cl.bool(true)));
 
             // Bob votes for cycle 0, round 1
-            const { result: resultVoteBob } = simnet.callPublicFn("pox-4-vote", "vote-for-aggregate-public-key",
+            const { result: resultVoteBob } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
                 [Cl.bufferFromHex(KEY_2), Cl.uint(0), Cl.uint(1),], bob);
             expect(resultVoteBob).toEqual(Cl.ok(Cl.bool(true)));
 
             const { result: resultLastRound0 } = simnet.callReadOnlyFn(
-                "pox-4-vote",
+                "signers-voting",
                 "get-last-round",
                 [Cl.uint(0)],
                 alice,
@@ -82,7 +82,7 @@ describe("test pox-4-vote contract voting rounds", () => {
 
         it("should return last round after valid votes for different cycles", () => {
             // Alice votes for cycle 0, round 1
-            const { result: resultVoteAlice } = simnet.callPublicFn("pox-4-vote", "vote-for-aggregate-public-key",
+            const { result: resultVoteAlice } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
                 [Cl.bufferFromHex(KEY_1), Cl.uint(0), Cl.uint(1),], alice);
             expect(resultVoteAlice).toEqual(Cl.ok(Cl.bool(true)));
 
@@ -90,12 +90,12 @@ describe("test pox-4-vote contract voting rounds", () => {
             simnet.mineEmptyBlocks(1050);
 
             // Bob votes for cycle 1, round 0
-            const { result: resultVoteBob } = simnet.callPublicFn("pox-4-vote", "vote-for-aggregate-public-key",
+            const { result: resultVoteBob } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
                 [Cl.bufferFromHex(KEY_2), Cl.uint(1), Cl.uint(0),], bob);
             expect(resultVoteBob).toEqual(Cl.ok(Cl.bool(true)));
 
             const { result: resultLastRound0 } = simnet.callReadOnlyFn(
-                "pox-4-vote",
+                "signers-voting",
                 "get-last-round",
                 [Cl.uint(0)],
                 alice,
@@ -104,7 +104,7 @@ describe("test pox-4-vote contract voting rounds", () => {
 
 
             const { result: resultLastRound1 } = simnet.callReadOnlyFn(
-                "pox-4-vote",
+                "signers-voting",
                 "get-last-round",
                 [Cl.uint(1)],
                 alice,
@@ -119,12 +119,12 @@ describe("test pox-4-vote contract voting rounds", () => {
 
             it("should fail on same key for different round", () => {
                 // Alice votes for cycle 0, round 0
-                const { result: resultVoteAlice } = simnet.callPublicFn("pox-4-vote", "vote-for-aggregate-public-key",
+                const { result: resultVoteAlice } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
                     [Cl.bufferFromHex(KEY_1), Cl.uint(0), Cl.uint(0),], alice);
                 expect(resultVoteAlice).toEqual(Cl.ok(Cl.bool(true)));
 
                 // Bob votes for cycle 0, round 1
-                const { result: resultVoteBob } = simnet.callPublicFn("pox-4-vote", "vote-for-aggregate-public-key",
+                const { result: resultVoteBob } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
                     [Cl.bufferFromHex(KEY_1), Cl.uint(0), Cl.uint(1),], bob);
                 expect(resultVoteBob).toEqual(Cl.error(Cl.uint(ERR_DUPLICATE_AGGREGATE_PUBLIC_KEY)));
 
@@ -132,7 +132,7 @@ describe("test pox-4-vote contract voting rounds", () => {
 
             it("should fail on same key for different cycles", () => {
                 // Alice votes for cycle 0, round 0
-                const { result: resultVoteAlice } = simnet.callPublicFn("pox-4-vote", "vote-for-aggregate-public-key",
+                const { result: resultVoteAlice } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
                     [Cl.bufferFromHex(KEY_1), Cl.uint(0), Cl.uint(0),], alice);
                 expect(resultVoteAlice).toEqual(Cl.ok(Cl.bool(true)));
 
@@ -140,7 +140,7 @@ describe("test pox-4-vote contract voting rounds", () => {
                 simnet.mineEmptyBlocks(1050);
 
                 // Bob votes for cycle 1, round 0
-                const { result: resultVoteBob } = simnet.callPublicFn("pox-4-vote", "vote-for-aggregate-public-key",
+                const { result: resultVoteBob } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
                     [Cl.bufferFromHex(KEY_1), Cl.uint(1), Cl.uint(0),], bob);
                 expect(resultVoteBob).toEqual(Cl.error(Cl.uint(ERR_DUPLICATE_AGGREGATE_PUBLIC_KEY)));
 
@@ -148,7 +148,7 @@ describe("test pox-4-vote contract voting rounds", () => {
 
             it("should fail on same key for different cycles", () => {
                 // Alice votes for cycle 0, round 0
-                const { result: resultVoteAlice } = simnet.callPublicFn("pox-4-vote", "vote-for-aggregate-public-key",
+                const { result: resultVoteAlice } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
                     [Cl.bufferFromHex(KEY_1), Cl.uint(0), Cl.uint(0),], alice);
                 expect(resultVoteAlice).toEqual(Cl.ok(Cl.bool(true)));
 
@@ -156,7 +156,7 @@ describe("test pox-4-vote contract voting rounds", () => {
                 simnet.mineEmptyBlocks(1050);
 
                 // Bob votes for cycle 1, round 0
-                const { result: resultVoteBob } = simnet.callPublicFn("pox-4-vote", "vote-for-aggregate-public-key",
+                const { result: resultVoteBob } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
                     [Cl.bufferFromHex(KEY_1), Cl.uint(1), Cl.uint(0),], bob);
                 expect(resultVoteBob).toEqual(Cl.error(Cl.uint(ERR_DUPLICATE_AGGREGATE_PUBLIC_KEY)));
 
@@ -164,12 +164,12 @@ describe("test pox-4-vote contract voting rounds", () => {
 
             it("should fail on second vote for same cycle and round", () => {
                 // Alice votes for cycle 0, round 0
-                const { result: resultVoteAlice } = simnet.callPublicFn("pox-4-vote", "vote-for-aggregate-public-key",
+                const { result: resultVoteAlice } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
                     [Cl.bufferFromHex(KEY_1), Cl.uint(0), Cl.uint(0),], alice);
                 expect(resultVoteAlice).toEqual(Cl.ok(Cl.bool(true)));
 
                 // Alice votes for cycle 0, round 0 again
-                const { result: resultVoteAlice2 } = simnet.callPublicFn("pox-4-vote", "vote-for-aggregate-public-key",
+                const { result: resultVoteAlice2 } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
                     [Cl.bufferFromHex(KEY_1), Cl.uint(0), Cl.uint(0),], alice);
                 expect(resultVoteAlice2).toEqual(Cl.error(Cl.uint(ERR_DUPLICATE_VOTE)));
 
@@ -177,7 +177,7 @@ describe("test pox-4-vote contract voting rounds", () => {
 
             it("should fail on early vote", () => {
                 // Alice votes for cycle 1, round 0 during cycle 0
-                const { result: resultVoteAlice } = simnet.callPublicFn("pox-4-vote", "vote-for-aggregate-public-key",
+                const { result: resultVoteAlice } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
                     [Cl.bufferFromHex(KEY_1), Cl.uint(1), Cl.uint(0),], alice);
                 expect(resultVoteAlice).toEqual(Cl.error(Cl.uint(ERR_INCORRECT_REWARD_CYCLE)));
 
@@ -185,12 +185,12 @@ describe("test pox-4-vote contract voting rounds", () => {
 
             it("should fail on late round", () => {
                 // Alice votes for cycle 0, round 1
-                const { result: resultVoteAlice } = simnet.callPublicFn("pox-4-vote", "vote-for-aggregate-public-key",
+                const { result: resultVoteAlice } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
                     [Cl.bufferFromHex(KEY_1), Cl.uint(0), Cl.uint(1),], alice);
                 expect(resultVoteAlice).toEqual(Cl.ok(Cl.bool(true)));
 
                 // Bob votes for cycle 0, round 0
-                const { result: resultVoteBob } = simnet.callPublicFn("pox-4-vote", "vote-for-aggregate-public-key",
+                const { result: resultVoteBob } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
                     [Cl.bufferFromHex(KEY_1), Cl.uint(0), Cl.uint(0),], bob);
                 expect(resultVoteBob).toEqual(Cl.error(Cl.uint(ERR_OLD_ROUND)));
             })
@@ -199,12 +199,12 @@ describe("test pox-4-vote contract voting rounds", () => {
     describe("test get-vote", () => {
         it("should return correct aggregate-public-key and shared", () => {
             // Alice votes for cycle 0, round 0
-            const { result: resultVoteAlice } = simnet.callPublicFn("pox-4-vote", "vote-for-aggregate-public-key",
+            const { result: resultVoteAlice } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
                 [Cl.bufferFromHex(KEY_1), Cl.uint(0), Cl.uint(0),], alice);
             expect(resultVoteAlice).toEqual(Cl.ok(Cl.bool(true)));
 
             const { result: vote } = simnet.callReadOnlyFn(
-                "pox-4-vote",
+                "signers-voting",
                 "get-vote",
                 [Cl.uint(0), Cl.uint(0), Cl.standardPrincipal(alice)],
                 alice,
@@ -219,7 +219,7 @@ describe("test pox-4-vote contract voting rounds", () => {
 
         it("should return none when not yet voted", () => {
             const { result: vote } = simnet.callReadOnlyFn(
-                "pox-4-vote",
+                "signers-voting",
                 "get-vote",
                 [Cl.uint(0), Cl.uint(0), Cl.standardPrincipal(alice)],
                 alice,
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 8de21ee1dd..3c00cf737c 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -78,8 +78,8 @@ pub const POX_1_NAME: &'static str = "pox";
 pub const POX_2_NAME: &'static str = "pox-2";
 pub const POX_3_NAME: &'static str = "pox-3";
 pub const POX_4_NAME: &'static str = "pox-4";
-pub const POX_4_VOTE_NAME: &'static str = "pox-4-vote";
 pub const SIGNERS_NAME: &'static str = "signers";
+pub const SIGNERS_VOTING_NAME: &'static str = "signers-voting";
 /// This is the name of a variable in the `.signers` contract which tracks the most recently updated
 /// reward cycle number.
 pub const SIGNERS_UPDATE_STATE: &'static str = "last-set-cycle";
@@ -90,7 +90,7 @@ const POX_2_BODY: &'static str = std::include_str!("pox-2.clar");
 const POX_3_BODY: &'static str = std::include_str!("pox-3.clar");
 const POX_4_BODY: &'static str = std::include_str!("pox-4.clar");
 pub const SIGNERS_BODY: &'static str = std::include_str!("signers.clar");
-const POX_4_VOTE_BODY: &'static str = std::include_str!("pox-4-vote.clar");
+const SIGNERS_VOTING_BODY: &'static str = std::include_str!("signers-voting.clar");
 
 pub const COSTS_1_NAME: &'static str = "costs";
 pub const COSTS_2_NAME: &'static str = "costs-2";
@@ -119,7 +119,7 @@ lazy_static! {
     pub static ref POX_3_TESTNET_CODE: String =
         format!("{}\n{}", BOOT_CODE_POX_TESTNET_CONSTS, POX_3_BODY);
     pub static ref POX_4_CODE: String = format!("{}", POX_4_BODY);
-    pub static ref POX_4_VOTE_CODE: String = format!("{}", POX_4_VOTE_BODY);
+    pub static ref SIGNER_VOTING_CODE: String = format!("{}", SIGNERS_VOTING_BODY);
     pub static ref BOOT_CODE_COST_VOTING_TESTNET: String = make_testnet_cost_voting();
     pub static ref STACKS_BOOT_CODE_MAINNET: [(&'static str, &'static str); 6] = [
         ("pox", &BOOT_CODE_POX_MAINNET),
@@ -1309,9 +1309,9 @@ pub mod pox_3_tests;
 #[cfg(test)]
 pub mod pox_4_tests;
 #[cfg(test)]
-pub mod pox_4_vote_tests;
-#[cfg(test)]
 mod signers_tests;
+#[cfg(test)]
+pub mod signers_voting_tests;
 
 #[cfg(test)]
 pub mod test {
@@ -1881,7 +1881,7 @@ pub mod test {
         make_tx(key, nonce, 0, payload)
     }
 
-    pub fn make_pox_4_vote_for_aggregate_public_key(
+    pub fn make_signers_vote_for_aggregate_public_key(
         key: &StacksPrivateKey,
         nonce: u64,
         aggregate_public_key: &Point,
@@ -1892,7 +1892,7 @@ pub mod test {
             .expect("Failed to serialize aggregate public key");
         let payload = TransactionPayload::new_contract_call(
             boot_code_test_addr(),
-            POX_4_VOTE_NAME,
+            SIGNERS_VOTING_NAME,
             "vote-for-aggregate-public-key",
             vec![
                 aggregate_public_key,
diff --git a/stackslib/src/chainstate/stacks/boot/pox-4-vote.clar b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
similarity index 100%
rename from stackslib/src/chainstate/stacks/boot/pox-4-vote.clar
rename to stackslib/src/chainstate/stacks/boot/signers-voting.clar
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_vote_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
similarity index 99%
rename from stackslib/src/chainstate/stacks/boot/pox_4_vote_tests.rs
rename to stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
index 4ee149a197..4e14b55cb9 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_vote_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
@@ -60,7 +60,8 @@ use crate::chainstate::stacks::boot::pox_4_tests::{
     assert_latest_was_burn, get_last_block_sender_transactions, get_tip, make_test_epochs_pox,
 };
 use crate::chainstate::stacks::boot::{
-    BOOT_CODE_COST_VOTING_TESTNET as BOOT_CODE_COST_VOTING, BOOT_CODE_POX_TESTNET, POX_4_VOTE_NAME,
+    BOOT_CODE_COST_VOTING_TESTNET as BOOT_CODE_COST_VOTING, BOOT_CODE_POX_TESTNET,
+    SIGNERS_VOTING_NAME,
 };
 use crate::chainstate::stacks::db::{
     MinerPaymentSchedule, StacksChainState, StacksHeaderInfo, MINER_REWARD_MATURITY,
diff --git a/stackslib/src/clarity_vm/clarity.rs b/stackslib/src/clarity_vm/clarity.rs
index 3b37db550f..59eccc84b5 100644
--- a/stackslib/src/clarity_vm/clarity.rs
+++ b/stackslib/src/clarity_vm/clarity.rs
@@ -48,8 +48,8 @@ use crate::chainstate::stacks::boot::{
     BOOT_CODE_COST_VOTING_TESTNET as BOOT_CODE_COST_VOTING, BOOT_CODE_POX_TESTNET,
     BOOT_TEST_POX_4_AGG_KEY_CONTRACT, BOOT_TEST_POX_4_AGG_KEY_FNAME, COSTS_2_NAME, COSTS_3_NAME,
     MINERS_NAME, POX_2_MAINNET_CODE, POX_2_NAME, POX_2_TESTNET_CODE, POX_3_MAINNET_CODE,
-    POX_3_NAME, POX_3_TESTNET_CODE, POX_4_CODE, POX_4_NAME, POX_4_VOTE_CODE, POX_4_VOTE_NAME,
-    SIGNERS_BODY, SIGNERS_NAME,
+    POX_3_NAME, POX_3_TESTNET_CODE, POX_4_CODE, POX_4_NAME, SIGNERS_BODY, SIGNERS_NAME,
+    SIGNERS_VOTING_NAME, SIGNER_VOTING_CODE,
 };
 use crate::chainstate::stacks::db::{StacksAccount, StacksChainState};
 use crate::chainstate::stacks::events::{StacksTransactionEvent, StacksTransactionReceipt};
@@ -1450,13 +1450,13 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
                 );
             }
 
-            let pox_4_vote_code = &*POX_4_VOTE_CODE;
-            let pox_4_vote_contract_id = boot_code_id(POX_4_VOTE_NAME, mainnet);
+            let signers_voting_code = &*SIGNER_VOTING_CODE;
+            let signers_voting_contract_id = boot_code_id(SIGNERS_VOTING_NAME, mainnet);
             let payload = TransactionPayload::SmartContract(
                 TransactionSmartContract {
-                    name: ContractName::try_from(POX_4_VOTE_NAME)
+                    name: ContractName::try_from(SIGNERS_VOTING_NAME)
                         .expect("FATAL: invalid boot-code contract name"),
-                    code_body: StacksString::from_str(pox_4_vote_code)
+                    code_body: StacksString::from_str(signers_voting_code)
                         .expect("FATAL: invalid boot code body"),
                 },
                 Some(ClarityVersion::Clarity2),
@@ -1465,25 +1465,25 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
             let signers_contract_tx =
                 StacksTransaction::new(tx_version.clone(), boot_code_auth.clone(), payload);
 
-            let pox_4_vote_initialization_receipt = self.as_transaction(|tx_conn| {
+            let signers_voting_initialization_receipt = self.as_transaction(|tx_conn| {
                 // initialize with a synthetic transaction
-                debug!("Instantiate {} contract", &pox_4_vote_contract_id);
+                debug!("Instantiate {} contract", &signers_voting_contract_id);
                 let receipt = StacksChainState::process_transaction_payload(
                     tx_conn,
                     &signers_contract_tx,
                     &boot_code_account,
                     ASTRules::PrecheckSize,
                 )
-                .expect("FATAL: Failed to process .pox-4-vote contract initialization");
+                .expect("FATAL: Failed to process .signers-voting contract initialization");
                 receipt
             });
 
-            if pox_4_vote_initialization_receipt.result != Value::okay_true()
-                || pox_4_vote_initialization_receipt.post_condition_aborted
+            if signers_voting_initialization_receipt.result != Value::okay_true()
+                || signers_voting_initialization_receipt.post_condition_aborted
             {
                 panic!(
-                    "FATAL: Failure processing pox-4-vote contract initialization: {:#?}",
-                    &pox_4_vote_initialization_receipt
+                    "FATAL: Failure processing signers-voting contract initialization: {:#?}",
+                    &signers_voting_initialization_receipt
                 );
             }
 

From d0a98088f9ef0caff956a0652162cdc00b568715 Mon Sep 17 00:00:00 2001
From: friedger <mail@friedger.de>
Date: Tue, 30 Jan 2024 09:58:01 +0100
Subject: [PATCH 0523/1166] chore: improve mod calculation

---
 stackslib/src/chainstate/stacks/boot/signers-voting.clar | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers-voting.clar b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
index c41f2a9f9c..dd8e135c5e 100644
--- a/stackslib/src/chainstate/stacks/boot/signers-voting.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
@@ -34,7 +34,7 @@
 
 ;; get current voting info
 (define-read-only (get-current-info)
-    (if (is-eq (/ (current-reward-cycle) u2) u0) (var-get state-1) (var-get state-2)))
+    (if (is-eq (mod (current-reward-cycle) u2)) (var-get state-1) (var-get state-2)))
 
 (define-read-only (burn-height-to-reward-cycle (height uint))
     (/ (- height (get first-burnchain-block-height pox-info)) (get reward-cycle-length pox-info)))

From 68e1ee1f240516a68342acd1f7185893108a5782 Mon Sep 17 00:00:00 2001
From: friedger <mail@friedger.de>
Date: Tue, 30 Jan 2024 11:12:06 +0100
Subject: [PATCH 0524/1166] fix: use correct build function

---
 .../src/chainstate/stacks/boot/signers_voting_tests.rs    | 8 ++++----
 stackslib/src/clarity_vm/clarity.rs                       | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
index 4e14b55cb9..478173e1f3 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
@@ -139,7 +139,7 @@ fn vote_for_aggregate_public_key() {
     let current_reward_cycle = readonly_call(
         &mut peer,
         &latest_block_id,
-        POX_4_VOTE_NAME.into(),
+        SIGNERS_VOTING_NAME.into(),
         "current-reward-cycle".into(),
         vec![],
     )
@@ -155,7 +155,7 @@ fn vote_for_aggregate_public_key() {
     let aggregated_public_key: Point = Point::new();
 
     // cast a vote for the aggregate public key
-    let txs = vec![make_pox_4_vote_for_aggregate_public_key(
+    let txs = vec![make_signers_vote_for_aggregate_public_key(
         signer_key,
         signer_nonce,
         &aggregated_public_key,
@@ -177,7 +177,7 @@ fn vote_for_aggregate_public_key() {
     signer_nonce += 1;
 
     // cast same vote twice
-    let txs = vec![make_pox_4_vote_for_aggregate_public_key(
+    let txs = vec![make_signers_vote_for_aggregate_public_key(
         signer_key,
         signer_nonce,
         &aggregated_public_key,
@@ -199,7 +199,7 @@ fn vote_for_aggregate_public_key() {
     signer_nonce += 1;
 
     // cast vote too late
-    let txs = vec![make_pox_4_vote_for_aggregate_public_key(
+    let txs = vec![make_signers_vote_for_aggregate_public_key(
         signer_key,
         signer_nonce,
         &aggregated_public_key,
diff --git a/stackslib/src/clarity_vm/clarity.rs b/stackslib/src/clarity_vm/clarity.rs
index 59eccc84b5..0c19aeb6cf 100644
--- a/stackslib/src/clarity_vm/clarity.rs
+++ b/stackslib/src/clarity_vm/clarity.rs
@@ -1437,7 +1437,7 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
                     &boot_code_account,
                     ASTRules::PrecheckSize,
                 )
-                .expect("FATAL: Failed to process .miners contract initialization");
+                .expect("FATAL: Failed to process .signers contract initialization");
                 receipt
             });
 

From a80f4b9564a6dab4e91aed91441081c331a42bdf Mon Sep 17 00:00:00 2001
From: friedger <mail@friedger.de>
Date: Tue, 30 Jan 2024 11:14:28 +0100
Subject: [PATCH 0525/1166] feat: implement get-signer-slots checks

---
 .../stacks/boot/signers-voting.clar           | 49 +++++++++++++------
 .../src/chainstate/stacks/boot/signers.clar   |  7 ++-
 2 files changed, 39 insertions(+), 17 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers-voting.clar b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
index dd8e135c5e..ed8315af00 100644
--- a/stackslib/src/chainstate/stacks/boot/signers-voting.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
@@ -9,13 +9,14 @@
 ;; maps aggregate public keys to rewards cycles and rounds
 (define-map used-aggregate-public-keys (buff 33) {reward-cycle: uint, round: uint})
 
-(define-constant err-not-allowed (err u10000))
-(define-constant err-incorrect-reward-cycle (err u10001))
-(define-constant err-old-round (err u10002))
-(define-constant err-invalid-aggregate-public-key (err u10003))
-(define-constant err-duplicate-aggregate-public-key (err u10004))
-(define-constant err-duplicate-vote (err u10005))
-(define-constant err-invalid-burn-block-height (err u10006))
+(define-constant err-signer-index-mismatch (err u10000))
+(define-constant err-invalid-signer-index (err u10001))
+(define-constant err-out-of-voting-window (err u10002))
+(define-constant err-old-round (err u10003))
+(define-constant err-invalid-aggregate-public-key (err u10004))
+(define-constant err-duplicate-aggregate-public-key (err u10005))
+(define-constant err-duplicate-vote (err u10006))
+(define-constant err-invalid-burn-block-height (err u10007))
 
 (define-constant pox-info
     (unwrap-panic (contract-call? .pox-4 get-pox-info)))
@@ -39,28 +40,46 @@
 (define-read-only (burn-height-to-reward-cycle (height uint))
     (/ (- height (get first-burnchain-block-height pox-info)) (get reward-cycle-length pox-info)))
 
+(define-read-only (reward-cycle-to-burn-height (reward-cycle uint))
+    (+ (* reward-cycle (get reward-cycle-length pox-info)) (get first-burnchain-block-height pox-info)))
+
 (define-read-only (current-reward-cycle)
     (burn-height-to-reward-cycle burn-block-height))
-    
+
 (define-read-only (get-last-round (reward-cycle uint))
     (map-get? rounds reward-cycle))
 
 (define-read-only (get-vote (reward-cycle uint) (round uint) (signer principal))
     (map-get? votes {reward-cycle: reward-cycle, round: round, signer: signer}))
-    
-(define-read-only (get-signer-slots (signer principal) (reward-cycle uint))
-    (contract-call? .signers get-signer-slots signer reward-cycle))
+
+(define-read-only (get-signer-slots (signer-index uint) (reward-cycle uint))
+    (let ((height (reward-cycle-to-burn-height reward-cycle)))
+            (ok (at-block
+                (unwrap! (get-block-info? id-header-hash height) err-invalid-burn-block-height)
+                    (get-current-signer-slots signer-index)))))
+
+(define-read-only (get-current-signer-slots (signer-index uint))
+    (let ((details (unwrap! (unwrap-panic (contract-call? .signers stackerdb-get-signer-by-index signer-index)) err-invalid-signer-index)))
+        (asserts! (is-eq (get signer details) tx-sender) err-signer-index-mismatch)
+        (ok (get num-slots details))))
 
 ;; aggregate public key must be unique and can be used only in a single cycle-round pair
 (define-read-only (is-valid-aggregated-public-key (key (buff 33)) (dkg-id {reward-cycle: uint, round: uint}))
     (is-eq (default-to dkg-id (map-get? used-aggregate-public-keys key)) dkg-id))
 
-(define-public (vote-for-aggregate-public-key (key (buff 33)) (reward-cycle uint) (round uint))
-    (let ((tally-key {reward-cycle: reward-cycle, round: round, aggregate-public-key: key})
+(define-private (is-in-voting-window (height uint) (reward-cycle uint))
+    (let ((last-cycle (unwrap-panic (contract-call? .signers stackerdb-get-last-set-cycle))))
+        (and (is-eq last-cycle reward-cycle)
+            (< (mod (- height (get first-burnchain-block-height pox-info)) (get reward-cycle-length pox-info))
+                (get prepare-cycle-length pox-info)))))
+
+(define-public (vote-for-aggregate-public-key (signer-index uint) (key (buff 33)) (round uint))
+    (let ((reward-cycle (burn-height-to-reward-cycle burn-block-height))
+            (tally-key {reward-cycle: reward-cycle, round: round, aggregate-public-key: key})
             ;; one slot, one vote
-            (num-slots (unwrap! (get-signer-slots tx-sender reward-cycle) err-not-allowed))
+            (num-slots (try! (try! (get-signer-slots signer-index reward-cycle))))
             (new-total (+ num-slots (default-to u0 (map-get? tally tally-key)))))
-        (asserts! (is-eq reward-cycle (current-reward-cycle)) err-incorrect-reward-cycle)
+        (asserts! (is-in-voting-window burn-block-height reward-cycle) err-out-of-voting-window)
         (asserts! (>= round (default-to u0 (map-get? rounds reward-cycle))) err-old-round)
         (asserts! (is-eq (len key) u33) err-invalid-aggregate-public-key)
         (asserts! (is-valid-aggregated-public-key key {reward-cycle: reward-cycle, round: round}) err-duplicate-aggregate-public-key)
diff --git a/stackslib/src/chainstate/stacks/boot/signers.clar b/stackslib/src/chainstate/stacks/boot/signers.clar
index 3970679333..a901dc0f94 100644
--- a/stackslib/src/chainstate/stacks/boot/signers.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers.clar
@@ -13,8 +13,8 @@
 (define-read-only (stackerdb-get-signer-slots)
 	(ok (var-get stackerdb-signer-slots)))
 
-(define-read-only (get-signer-slots (signer principal) (reward-cycle uint))
-	(ok u1)
+(define-read-only (stackerdb-get-signer-by-index (signer-index uint))
+	(ok (element-at (var-get stackerdb-signer-slots) signer-index))
 )
 
 (define-read-only (stackerdb-get-config)
@@ -25,3 +25,6 @@
 		  max-neighbors: u32,
 		  hint-replicas: (list) }
 	))
+
+(define-read-only (stackerdb-get-last-set-cycle)
+	(ok (var-get last-set-cycle)))
\ No newline at end of file

From d9701e895975bbd4c0d3979f949a086b0f9db34c Mon Sep 17 00:00:00 2001
From: friedger <mail@friedger.de>
Date: Tue, 30 Jan 2024 11:15:39 +0100
Subject: [PATCH 0526/1166] fix: use correct arguments

---
 .../tests/pox-4/signers-voting.test.ts        | 53 ++++++++++---------
 1 file changed, 27 insertions(+), 26 deletions(-)

diff --git a/contrib/core-contract-tests/tests/pox-4/signers-voting.test.ts b/contrib/core-contract-tests/tests/pox-4/signers-voting.test.ts
index 56216eb78a..80cbb8ba36 100644
--- a/contrib/core-contract-tests/tests/pox-4/signers-voting.test.ts
+++ b/contrib/core-contract-tests/tests/pox-4/signers-voting.test.ts
@@ -6,13 +6,14 @@ const alice = accounts.get("wallet_1")!;
 const bob = accounts.get("wallet_2")!;
 const charlie = accounts.get("wallet_3")!;
 
-const ERR_NOT_ALLOWED = 10000;
-const ERR_INCORRECT_REWARD_CYCLE = 10001;
-const ERR_OLD_ROUND = 10002;
-const ERR_INVALID_AGGREGATE_PUBLIC_KEY = 10003;
-const ERR_DUPLICATE_AGGREGATE_PUBLIC_KEY = 10004
-const ERR_DUPLICATE_VOTE = 10005;
-const ERR_INVALID_BURN_BLOCK_HEIGHT = 10006
+const ERR_SIGNER_INDEX_MISMATCH = 10000;
+const ERR_INVALID_SIGNER_INDEX = 10001;
+const ERR_OUT_OF_VOTING_WINDOW = 10002
+const ERR_OLD_ROUND = 10003;
+const ERR_INVALID_AGGREGATE_PUBLIC_KEY = 10004;
+const ERR_DUPLICATE_AGGREGATE_PUBLIC_KEY = 10005;
+const ERR_DUPLICATE_VOTE = 10006;
+const ERR_INVALID_BURN_BLOCK_HEIGHT = 10007
 
 const KEY_1 = "123456789a123456789a123456789a123456789a123456789a123456789a010203";
 const KEY_2 = "123456789a123456789a123456789a123456789a123456789a123456789ab0b1b2";
@@ -32,7 +33,7 @@ describe("test signers-voting contract voting rounds", () => {
 
         it("should return none after invalid vote", () => {
             const { result: resultVote } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
-                [Cl.bufferFromHex("12"), Cl.uint(0), Cl.uint(0),], alice);
+                [Cl.uint(0), Cl.bufferFromHex("12"), Cl.uint(0),], alice);
             expect(resultVote).toEqual(Cl.error(Cl.uint(ERR_INVALID_AGGREGATE_PUBLIC_KEY)));
 
             const { result: resultRound } = simnet.callReadOnlyFn(
@@ -47,7 +48,7 @@ describe("test signers-voting contract voting rounds", () => {
 
         it("should return round after valid vote", () => {
             const { result: resultVote } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
-                [Cl.bufferFromHex(KEY_1), Cl.uint(0), Cl.uint(0),], alice);
+                [Cl.uint(0), Cl.bufferFromHex(KEY_1), Cl.uint(0),], alice);
             expect(resultVote).toEqual(Cl.ok(Cl.bool(true)));
 
             const { result: resultRound } = simnet.callReadOnlyFn(
@@ -63,12 +64,12 @@ describe("test signers-voting contract voting rounds", () => {
         it("should return last round after valid votes for two rounds", () => {
             // Alice votes for cycle 0, round 0
             const { result: resultVoteAlice } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
-                [Cl.bufferFromHex(KEY_1), Cl.uint(0), Cl.uint(0),], alice);
+                [Cl.uint(0), Cl.bufferFromHex(KEY_1), Cl.uint(0),], alice);
             expect(resultVoteAlice).toEqual(Cl.ok(Cl.bool(true)));
 
             // Bob votes for cycle 0, round 1
             const { result: resultVoteBob } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
-                [Cl.bufferFromHex(KEY_2), Cl.uint(0), Cl.uint(1),], bob);
+                [Cl.uint(1), Cl.bufferFromHex(KEY_2), Cl.uint(1),], bob);
             expect(resultVoteBob).toEqual(Cl.ok(Cl.bool(true)));
 
             const { result: resultLastRound0 } = simnet.callReadOnlyFn(
@@ -83,7 +84,7 @@ describe("test signers-voting contract voting rounds", () => {
         it("should return last round after valid votes for different cycles", () => {
             // Alice votes for cycle 0, round 1
             const { result: resultVoteAlice } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
-                [Cl.bufferFromHex(KEY_1), Cl.uint(0), Cl.uint(1),], alice);
+                [Cl.uint(0), Cl.bufferFromHex(KEY_1), Cl.uint(1),], alice);
             expect(resultVoteAlice).toEqual(Cl.ok(Cl.bool(true)));
 
             // advance to next cycle
@@ -91,7 +92,7 @@ describe("test signers-voting contract voting rounds", () => {
 
             // Bob votes for cycle 1, round 0
             const { result: resultVoteBob } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
-                [Cl.bufferFromHex(KEY_2), Cl.uint(1), Cl.uint(0),], bob);
+                [Cl.uint(1), Cl.bufferFromHex(KEY_2), Cl.uint(0),], bob);
             expect(resultVoteBob).toEqual(Cl.ok(Cl.bool(true)));
 
             const { result: resultLastRound0 } = simnet.callReadOnlyFn(
@@ -120,12 +121,12 @@ describe("test signers-voting contract voting rounds", () => {
             it("should fail on same key for different round", () => {
                 // Alice votes for cycle 0, round 0
                 const { result: resultVoteAlice } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
-                    [Cl.bufferFromHex(KEY_1), Cl.uint(0), Cl.uint(0),], alice);
+                    [Cl.uint(0), Cl.bufferFromHex(KEY_1), Cl.uint(0),], alice);
                 expect(resultVoteAlice).toEqual(Cl.ok(Cl.bool(true)));
 
                 // Bob votes for cycle 0, round 1
                 const { result: resultVoteBob } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
-                    [Cl.bufferFromHex(KEY_1), Cl.uint(0), Cl.uint(1),], bob);
+                    [Cl.uint(1), Cl.bufferFromHex(KEY_1), Cl.uint(1),], bob);
                 expect(resultVoteBob).toEqual(Cl.error(Cl.uint(ERR_DUPLICATE_AGGREGATE_PUBLIC_KEY)));
 
             })
@@ -133,7 +134,7 @@ describe("test signers-voting contract voting rounds", () => {
             it("should fail on same key for different cycles", () => {
                 // Alice votes for cycle 0, round 0
                 const { result: resultVoteAlice } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
-                    [Cl.bufferFromHex(KEY_1), Cl.uint(0), Cl.uint(0),], alice);
+                    [Cl.uint(0), Cl.bufferFromHex(KEY_1), Cl.uint(0),], alice);
                 expect(resultVoteAlice).toEqual(Cl.ok(Cl.bool(true)));
 
                 // advance to next cycle
@@ -141,7 +142,7 @@ describe("test signers-voting contract voting rounds", () => {
 
                 // Bob votes for cycle 1, round 0
                 const { result: resultVoteBob } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
-                    [Cl.bufferFromHex(KEY_1), Cl.uint(1), Cl.uint(0),], bob);
+                    [Cl.uint(1), Cl.bufferFromHex(KEY_1), Cl.uint(0),], bob);
                 expect(resultVoteBob).toEqual(Cl.error(Cl.uint(ERR_DUPLICATE_AGGREGATE_PUBLIC_KEY)));
 
             })
@@ -149,7 +150,7 @@ describe("test signers-voting contract voting rounds", () => {
             it("should fail on same key for different cycles", () => {
                 // Alice votes for cycle 0, round 0
                 const { result: resultVoteAlice } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
-                    [Cl.bufferFromHex(KEY_1), Cl.uint(0), Cl.uint(0),], alice);
+                    [Cl.uint(0), Cl.bufferFromHex(KEY_1), Cl.uint(0),], alice);
                 expect(resultVoteAlice).toEqual(Cl.ok(Cl.bool(true)));
 
                 // advance to next cycle
@@ -157,7 +158,7 @@ describe("test signers-voting contract voting rounds", () => {
 
                 // Bob votes for cycle 1, round 0
                 const { result: resultVoteBob } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
-                    [Cl.bufferFromHex(KEY_1), Cl.uint(1), Cl.uint(0),], bob);
+                    [Cl.uint(1), Cl.bufferFromHex(KEY_1), Cl.uint(0),], bob);
                 expect(resultVoteBob).toEqual(Cl.error(Cl.uint(ERR_DUPLICATE_AGGREGATE_PUBLIC_KEY)));
 
             })
@@ -165,12 +166,12 @@ describe("test signers-voting contract voting rounds", () => {
             it("should fail on second vote for same cycle and round", () => {
                 // Alice votes for cycle 0, round 0
                 const { result: resultVoteAlice } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
-                    [Cl.bufferFromHex(KEY_1), Cl.uint(0), Cl.uint(0),], alice);
+                    [Cl.uint(0), Cl.bufferFromHex(KEY_1), Cl.uint(0),], alice);
                 expect(resultVoteAlice).toEqual(Cl.ok(Cl.bool(true)));
 
                 // Alice votes for cycle 0, round 0 again
                 const { result: resultVoteAlice2 } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
-                    [Cl.bufferFromHex(KEY_1), Cl.uint(0), Cl.uint(0),], alice);
+                    [Cl.uint(0), Cl.bufferFromHex(KEY_1), Cl.uint(0),], alice);
                 expect(resultVoteAlice2).toEqual(Cl.error(Cl.uint(ERR_DUPLICATE_VOTE)));
 
             })
@@ -178,20 +179,20 @@ describe("test signers-voting contract voting rounds", () => {
             it("should fail on early vote", () => {
                 // Alice votes for cycle 1, round 0 during cycle 0
                 const { result: resultVoteAlice } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
-                    [Cl.bufferFromHex(KEY_1), Cl.uint(1), Cl.uint(0),], alice);
-                expect(resultVoteAlice).toEqual(Cl.error(Cl.uint(ERR_INCORRECT_REWARD_CYCLE)));
+                    [Cl.uint(0), Cl.bufferFromHex(KEY_1), Cl.uint(0),], alice);
+                expect(resultVoteAlice).toEqual(Cl.error(Cl.uint(ERR_INVALID_SIGNER_INDEX)));
 
             })
 
             it("should fail on late round", () => {
                 // Alice votes for cycle 0, round 1
                 const { result: resultVoteAlice } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
-                    [Cl.bufferFromHex(KEY_1), Cl.uint(0), Cl.uint(1),], alice);
+                    [Cl.uint(0), Cl.bufferFromHex(KEY_1), Cl.uint(1),], alice);
                 expect(resultVoteAlice).toEqual(Cl.ok(Cl.bool(true)));
 
                 // Bob votes for cycle 0, round 0
                 const { result: resultVoteBob } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
-                    [Cl.bufferFromHex(KEY_1), Cl.uint(0), Cl.uint(0),], bob);
+                    [Cl.uint(1), Cl.bufferFromHex(KEY_1), Cl.uint(0),], bob);
                 expect(resultVoteBob).toEqual(Cl.error(Cl.uint(ERR_OLD_ROUND)));
             })
         })
@@ -200,7 +201,7 @@ describe("test signers-voting contract voting rounds", () => {
         it("should return correct aggregate-public-key and shared", () => {
             // Alice votes for cycle 0, round 0
             const { result: resultVoteAlice } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
-                [Cl.bufferFromHex(KEY_1), Cl.uint(0), Cl.uint(0),], alice);
+                [Cl.uint(0), Cl.bufferFromHex(KEY_1), Cl.uint(0),], alice);
             expect(resultVoteAlice).toEqual(Cl.ok(Cl.bool(true)));
 
             const { result: vote } = simnet.callReadOnlyFn(

From c883ff089cb5d86a3339201627c1480b792b2b34 Mon Sep 17 00:00:00 2001
From: friedger <mail@friedger.de>
Date: Tue, 30 Jan 2024 11:22:07 +0100
Subject: [PATCH 0527/1166] fix: remove untestable calls, add more tests

---
 .../tests/pox-4/signers-voting.test.ts        | 231 ++----------------
 1 file changed, 26 insertions(+), 205 deletions(-)

diff --git a/contrib/core-contract-tests/tests/pox-4/signers-voting.test.ts b/contrib/core-contract-tests/tests/pox-4/signers-voting.test.ts
index 80cbb8ba36..7195877656 100644
--- a/contrib/core-contract-tests/tests/pox-4/signers-voting.test.ts
+++ b/contrib/core-contract-tests/tests/pox-4/signers-voting.test.ts
@@ -17,216 +17,37 @@ const ERR_INVALID_BURN_BLOCK_HEIGHT = 10007
 
 const KEY_1 = "123456789a123456789a123456789a123456789a123456789a123456789a010203";
 const KEY_2 = "123456789a123456789a123456789a123456789a123456789a123456789ab0b1b2";
+const SIGNERS_VOTING = "signers-voting";
 
 describe("test signers-voting contract voting rounds", () => {
-    describe("test get-last-round", () => {
-        it("should return none before any vote", () => {
-
-            const { result: resultRound } = simnet.callReadOnlyFn(
-                "signers-voting",
-                "get-last-round",
-                [Cl.uint(0)],
-                alice,
-            );
-            expect(resultRound).toEqual(Cl.none());
-        })
-
-        it("should return none after invalid vote", () => {
-            const { result: resultVote } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
-                [Cl.uint(0), Cl.bufferFromHex("12"), Cl.uint(0),], alice);
-            expect(resultVote).toEqual(Cl.error(Cl.uint(ERR_INVALID_AGGREGATE_PUBLIC_KEY)));
-
-            const { result: resultRound } = simnet.callReadOnlyFn(
-                "signers-voting",
-                "get-last-round",
-                [Cl.uint(0)],
-                alice,
-            );
-            expect(resultRound).toEqual(Cl.none());
-
-        })
-
-        it("should return round after valid vote", () => {
-            const { result: resultVote } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
-                [Cl.uint(0), Cl.bufferFromHex(KEY_1), Cl.uint(0),], alice);
-            expect(resultVote).toEqual(Cl.ok(Cl.bool(true)));
-
-            const { result: resultRound } = simnet.callReadOnlyFn(
-                "signers-voting",
-                "get-last-round",
-                [Cl.uint(0)],
-                alice,
-            );
-            expect(resultRound).toEqual(Cl.some(Cl.uint(0)));
-
-        })
-
-        it("should return last round after valid votes for two rounds", () => {
-            // Alice votes for cycle 0, round 0
-            const { result: resultVoteAlice } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
-                [Cl.uint(0), Cl.bufferFromHex(KEY_1), Cl.uint(0),], alice);
-            expect(resultVoteAlice).toEqual(Cl.ok(Cl.bool(true)));
-
-            // Bob votes for cycle 0, round 1
-            const { result: resultVoteBob } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
-                [Cl.uint(1), Cl.bufferFromHex(KEY_2), Cl.uint(1),], bob);
-            expect(resultVoteBob).toEqual(Cl.ok(Cl.bool(true)));
-
-            const { result: resultLastRound0 } = simnet.callReadOnlyFn(
-                "signers-voting",
-                "get-last-round",
-                [Cl.uint(0)],
-                alice,
-            );
-            expect(resultLastRound0).toEqual(Cl.some(Cl.uint(1)));
-        })
-
-        it("should return last round after valid votes for different cycles", () => {
-            // Alice votes for cycle 0, round 1
-            const { result: resultVoteAlice } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
-                [Cl.uint(0), Cl.bufferFromHex(KEY_1), Cl.uint(1),], alice);
-            expect(resultVoteAlice).toEqual(Cl.ok(Cl.bool(true)));
-
-            // advance to next cycle
-            simnet.mineEmptyBlocks(1050);
-
-            // Bob votes for cycle 1, round 0
-            const { result: resultVoteBob } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
-                [Cl.uint(1), Cl.bufferFromHex(KEY_2), Cl.uint(0),], bob);
-            expect(resultVoteBob).toEqual(Cl.ok(Cl.bool(true)));
-
-            const { result: resultLastRound0 } = simnet.callReadOnlyFn(
-                "signers-voting",
-                "get-last-round",
-                [Cl.uint(0)],
-                alice,
-            );
-            expect(resultLastRound0).toEqual(Cl.some(Cl.uint(1)));
-
-
-            const { result: resultLastRound1 } = simnet.callReadOnlyFn(
-                "signers-voting",
-                "get-last-round",
+    describe("test pox-info", () => {
+        it("should return correct burn-height", () => {
+            const { result:result1 } = simnet.callReadOnlyFn(SIGNERS_VOTING,
+                "reward-cycle-to-burn-height",
                 [Cl.uint(1)],
-                alice,
-            );
-            expect(resultLastRound1).toEqual(Cl.some(Cl.uint(0)));
-
+                alice)
+            expect(result1).toEqual(Cl.uint(1050))
+
+            const { result:result2 } = simnet.callReadOnlyFn(SIGNERS_VOTING,
+                "reward-cycle-to-burn-height",
+                [Cl.uint(2)],
+                alice)
+            expect(result2).toEqual(Cl.uint(2100))
         })
 
-    }),
-
-        describe("test voting", () => {
-
-            it("should fail on same key for different round", () => {
-                // Alice votes for cycle 0, round 0
-                const { result: resultVoteAlice } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
-                    [Cl.uint(0), Cl.bufferFromHex(KEY_1), Cl.uint(0),], alice);
-                expect(resultVoteAlice).toEqual(Cl.ok(Cl.bool(true)));
-
-                // Bob votes for cycle 0, round 1
-                const { result: resultVoteBob } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
-                    [Cl.uint(1), Cl.bufferFromHex(KEY_1), Cl.uint(1),], bob);
-                expect(resultVoteBob).toEqual(Cl.error(Cl.uint(ERR_DUPLICATE_AGGREGATE_PUBLIC_KEY)));
-
-            })
-
-            it("should fail on same key for different cycles", () => {
-                // Alice votes for cycle 0, round 0
-                const { result: resultVoteAlice } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
-                    [Cl.uint(0), Cl.bufferFromHex(KEY_1), Cl.uint(0),], alice);
-                expect(resultVoteAlice).toEqual(Cl.ok(Cl.bool(true)));
-
-                // advance to next cycle
-                simnet.mineEmptyBlocks(1050);
-
-                // Bob votes for cycle 1, round 0
-                const { result: resultVoteBob } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
-                    [Cl.uint(1), Cl.bufferFromHex(KEY_1), Cl.uint(0),], bob);
-                expect(resultVoteBob).toEqual(Cl.error(Cl.uint(ERR_DUPLICATE_AGGREGATE_PUBLIC_KEY)));
-
-            })
-
-            it("should fail on same key for different cycles", () => {
-                // Alice votes for cycle 0, round 0
-                const { result: resultVoteAlice } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
-                    [Cl.uint(0), Cl.bufferFromHex(KEY_1), Cl.uint(0),], alice);
-                expect(resultVoteAlice).toEqual(Cl.ok(Cl.bool(true)));
-
-                // advance to next cycle
-                simnet.mineEmptyBlocks(1050);
-
-                // Bob votes for cycle 1, round 0
-                const { result: resultVoteBob } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
-                    [Cl.uint(1), Cl.bufferFromHex(KEY_1), Cl.uint(0),], bob);
-                expect(resultVoteBob).toEqual(Cl.error(Cl.uint(ERR_DUPLICATE_AGGREGATE_PUBLIC_KEY)));
-
-            })
-
-            it("should fail on second vote for same cycle and round", () => {
-                // Alice votes for cycle 0, round 0
-                const { result: resultVoteAlice } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
-                    [Cl.uint(0), Cl.bufferFromHex(KEY_1), Cl.uint(0),], alice);
-                expect(resultVoteAlice).toEqual(Cl.ok(Cl.bool(true)));
-
-                // Alice votes for cycle 0, round 0 again
-                const { result: resultVoteAlice2 } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
-                    [Cl.uint(0), Cl.bufferFromHex(KEY_1), Cl.uint(0),], alice);
-                expect(resultVoteAlice2).toEqual(Cl.error(Cl.uint(ERR_DUPLICATE_VOTE)));
-
-            })
-
-            it("should fail on early vote", () => {
-                // Alice votes for cycle 1, round 0 during cycle 0
-                const { result: resultVoteAlice } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
-                    [Cl.uint(0), Cl.bufferFromHex(KEY_1), Cl.uint(0),], alice);
-                expect(resultVoteAlice).toEqual(Cl.error(Cl.uint(ERR_INVALID_SIGNER_INDEX)));
-
-            })
-
-            it("should fail on late round", () => {
-                // Alice votes for cycle 0, round 1
-                const { result: resultVoteAlice } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
-                    [Cl.uint(0), Cl.bufferFromHex(KEY_1), Cl.uint(1),], alice);
-                expect(resultVoteAlice).toEqual(Cl.ok(Cl.bool(true)));
-
-                // Bob votes for cycle 0, round 0
-                const { result: resultVoteBob } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
-                    [Cl.uint(1), Cl.bufferFromHex(KEY_1), Cl.uint(0),], bob);
-                expect(resultVoteBob).toEqual(Cl.error(Cl.uint(ERR_OLD_ROUND)));
-            })
+        it("should return correct reward-cycle", () => {
+            const { result: result1 } = simnet.callReadOnlyFn(SIGNERS_VOTING,
+                "burn-height-to-reward-cycle",
+                [Cl.uint(1)],
+                alice)
+            expect(result1).toEqual(Cl.uint(0))
+
+            const { result: result2000 } = simnet.callReadOnlyFn(SIGNERS_VOTING,
+                "burn-height-to-reward-cycle",
+                [Cl.uint(2000)],
+                alice)
+            expect(result2000).toEqual(Cl.uint(1))
         })
-
-    describe("test get-vote", () => {
-        it("should return correct aggregate-public-key and shared", () => {
-            // Alice votes for cycle 0, round 0
-            const { result: resultVoteAlice } = simnet.callPublicFn("signers-voting", "vote-for-aggregate-public-key",
-                [Cl.uint(0), Cl.bufferFromHex(KEY_1), Cl.uint(0),], alice);
-            expect(resultVoteAlice).toEqual(Cl.ok(Cl.bool(true)));
-
-            const { result: vote } = simnet.callReadOnlyFn(
-                "signers-voting",
-                "get-vote",
-                [Cl.uint(0), Cl.uint(0), Cl.standardPrincipal(alice)],
-                alice,
-            );
-            expect(vote).toEqual(Cl.some(Cl.tuple({
-                "aggregate-public-key": Cl.bufferFromHex(KEY_1),
-                "reward-slots":
-                    Cl.uint(1)
-            })));
-
-        });
-
-        it("should return none when not yet voted", () => {
-            const { result: vote } = simnet.callReadOnlyFn(
-                "signers-voting",
-                "get-vote",
-                [Cl.uint(0), Cl.uint(0), Cl.standardPrincipal(alice)],
-                alice,
-            );
-            expect(vote).toEqual(Cl.none());
-
-        });
     })
+
 });
\ No newline at end of file

From 4c22d75ea37a52e70c724e4fb9a579ae3e14c770 Mon Sep 17 00:00:00 2001
From: friedger <mail@friedger.de>
Date: Tue, 30 Jan 2024 15:17:25 +0100
Subject: [PATCH 0528/1166] chore: add test for voting

---
 .../tests/pox-4/signers-voting.test.ts        |  39 +++
 .../chainstate/nakamoto/coordinator/tests.rs  |  12 +-
 .../src/chainstate/nakamoto/tests/mod.rs      |   4 +-
 stackslib/src/chainstate/stacks/boot/mod.rs   |   7 +-
 .../stacks/boot/signers-voting.clar           |  14 +-
 .../chainstate/stacks/boot/signers_tests.rs   |  20 +-
 .../stacks/boot/signers_voting_tests.rs       | 250 ++++++++++++++----
 7 files changed, 277 insertions(+), 69 deletions(-)

diff --git a/contrib/core-contract-tests/tests/pox-4/signers-voting.test.ts b/contrib/core-contract-tests/tests/pox-4/signers-voting.test.ts
index 7195877656..5953dee4d7 100644
--- a/contrib/core-contract-tests/tests/pox-4/signers-voting.test.ts
+++ b/contrib/core-contract-tests/tests/pox-4/signers-voting.test.ts
@@ -48,6 +48,45 @@ describe("test signers-voting contract voting rounds", () => {
                 alice)
             expect(result2000).toEqual(Cl.uint(1))
         })
+
+        it("should return true if in prepare phase", () => {
+            const { result:result999 } = simnet.callReadOnlyFn(SIGNERS_VOTING,
+                "is-in-prepare-phase",
+                [Cl.uint(999)],
+                alice)
+            expect(result999).toEqual(Cl.bool(false))
+
+            const { result } = simnet.callReadOnlyFn(SIGNERS_VOTING,
+                "is-in-prepare-phase",
+                [Cl.uint(1000)],
+                alice)
+            expect(result).toEqual(Cl.bool(true))
+
+            const { result: result1001 } = simnet.callReadOnlyFn(SIGNERS_VOTING,
+                "is-in-prepare-phase",
+                [Cl.uint(1001)],
+                alice)
+            expect(result1001).toEqual(Cl.bool(true))
+
+
+            const { result: result0 } = simnet.callReadOnlyFn(SIGNERS_VOTING,
+                "is-in-prepare-phase",
+                [Cl.uint(1049)],
+                alice)
+            expect(result0).toEqual(Cl.bool(true))
+
+            const { result: result1 } = simnet.callReadOnlyFn(SIGNERS_VOTING,
+                "is-in-prepare-phase",
+                [Cl.uint(1050)],
+                alice)
+            expect(result1).toEqual(Cl.bool(false))
+
+            const { result: result2 } = simnet.callReadOnlyFn(SIGNERS_VOTING,
+                "is-in-prepare-phase",
+                [Cl.uint(1051)],
+                alice)
+            expect(result2).toEqual(Cl.bool(false))
+        })
     })
 
 });
\ No newline at end of file
diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index 633f480604..4c645e438a 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -105,6 +105,7 @@ pub fn boot_nakamoto<'a>(
     mut initial_balances: Vec<(PrincipalData, u64)>,
     test_signers: &TestSigners,
     test_stackers: Option<Vec<&TestStacker>>,
+    observer: Option<&'a TestEventObserver>,
 ) -> TestPeer<'a> {
     let aggregate_public_key = test_signers.aggregate_public_key.clone();
     let mut peer_config = TestPeerConfig::new(test_name, 0, 0);
@@ -151,7 +152,7 @@ pub fn boot_nakamoto<'a>(
         .map(|test_stacker| {
             (
                 PrincipalData::from(key_to_stacks_addr(&test_stacker.stacker_private_key)),
-                u64::try_from(test_stacker.amount).expect("Stacking amount too large"),
+                u64::try_from(test_stacker.amount + 10000).expect("Stacking amount too large"),
             )
         })
         .collect();
@@ -163,7 +164,7 @@ pub fn boot_nakamoto<'a>(
     peer_config.burnchain.pox_constants.v3_unlock_height = 27;
     peer_config.burnchain.pox_constants.pox_4_activation_height = 31;
     peer_config.test_stackers = Some(test_stackers.clone());
-    let mut peer = TestPeer::new(peer_config);
+    let mut peer = TestPeer::new_with_observer(peer_config, observer);
 
     advance_to_nakamoto(&mut peer, &test_signers, test_stackers);
 
@@ -296,7 +297,7 @@ 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, None);
+    let mut peer = boot_nakamoto(function_name!(), vec![], &test_signers, None, None);
 
     let (burn_ops, mut tenure_change, miner_key) =
         peer.begin_nakamoto_tenure(TenureChangeCause::BlockFound);
@@ -357,6 +358,7 @@ fn test_simple_nakamoto_coordinator_1_tenure_10_blocks() {
         vec![(addr.into(), 100_000_000)],
         &test_signers,
         None,
+        None,
     );
 
     let (burn_ops, mut tenure_change, miner_key) =
@@ -479,6 +481,7 @@ fn test_nakamoto_chainstate_getters() {
         vec![(addr.into(), 100_000_000)],
         &test_signers,
         None,
+        None,
     );
 
     let sort_tip = {
@@ -969,6 +972,7 @@ fn test_simple_nakamoto_coordinator_10_tenures_10_blocks() {
         vec![(addr.into(), 100_000_000)],
         &test_signers,
         None,
+        None,
     );
 
     let mut all_blocks = vec![];
@@ -1290,6 +1294,7 @@ fn test_simple_nakamoto_coordinator_2_tenures_3_sortitions() {
         vec![(addr.into(), 100_000_000)],
         &test_signers,
         None,
+        None,
     );
 
     let mut rc_burn_ops = vec![];
@@ -1619,6 +1624,7 @@ fn test_simple_nakamoto_coordinator_10_tenures_and_extensions_10_blocks() {
         vec![(addr.into(), 100_000_000)],
         &test_signers,
         None,
+        None,
     );
 
     let mut all_blocks = vec![];
diff --git a/stackslib/src/chainstate/nakamoto/tests/mod.rs b/stackslib/src/chainstate/nakamoto/tests/mod.rs
index c6c8217463..9df80e73f9 100644
--- a/stackslib/src/chainstate/nakamoto/tests/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/mod.rs
@@ -1502,7 +1502,7 @@ fn make_fork_run_with_arrivals(
 #[test]
 pub fn test_get_highest_nakamoto_tenure() {
     let test_signers = TestSigners::default();
-    let mut peer = boot_nakamoto(function_name!(), vec![], &test_signers, None);
+    let mut peer = boot_nakamoto(function_name!(), vec![], &test_signers, None, None);
 
     // extract chainstate and sortdb -- we don't need the peer anymore
     let chainstate = &mut peer.stacks_node.as_mut().unwrap().chainstate;
@@ -1644,7 +1644,7 @@ pub fn test_get_highest_nakamoto_tenure() {
 #[test]
 fn test_make_miners_stackerdb_config() {
     let test_signers = TestSigners::default();
-    let mut peer = boot_nakamoto(function_name!(), vec![], &test_signers, None);
+    let mut peer = boot_nakamoto(function_name!(), vec![], &test_signers, None, None);
 
     let naka_miner_hash160 = peer.miner.nakamoto_miner_hash160();
     let miner_keys: Vec<_> = (0..10).map(|_| StacksPrivateKey::new()).collect();
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 3c00cf737c..7361a99aec 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -1884,8 +1884,8 @@ pub mod test {
     pub fn make_signers_vote_for_aggregate_public_key(
         key: &StacksPrivateKey,
         nonce: u64,
+        signer_index: u128,
         aggregate_public_key: &Point,
-        reward_cycle: u128,
         round: u128,
     ) -> StacksTransaction {
         let aggregate_public_key = Value::buff_from(aggregate_public_key.compress().data.to_vec())
@@ -1895,13 +1895,14 @@ pub mod test {
             SIGNERS_VOTING_NAME,
             "vote-for-aggregate-public-key",
             vec![
+                Value::UInt(signer_index),
                 aggregate_public_key,
-                Value::UInt(reward_cycle),
                 Value::UInt(round),
             ],
         )
         .unwrap();
-        make_tx(key, nonce, 0, payload)
+        // TODO set tx_fee back to 0 once these txs are free
+        make_tx(key, nonce, 1, payload)
     }
 
     pub fn make_pox_2_increase(
diff --git a/stackslib/src/chainstate/stacks/boot/signers-voting.clar b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
index ed8315af00..82a7919583 100644
--- a/stackslib/src/chainstate/stacks/boot/signers-voting.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
@@ -67,17 +67,23 @@
 (define-read-only (is-valid-aggregated-public-key (key (buff 33)) (dkg-id {reward-cycle: uint, round: uint}))
     (is-eq (default-to dkg-id (map-get? used-aggregate-public-keys key)) dkg-id))
 
+(define-read-only (is-in-prepare-phase (height uint))
+    (< (mod (+ (- height (get first-burnchain-block-height pox-info))
+                (get prepare-cycle-length pox-info))
+             (get reward-cycle-length pox-info)
+            )
+        (get prepare-cycle-length pox-info)))
+
 (define-private (is-in-voting-window (height uint) (reward-cycle uint))
     (let ((last-cycle (unwrap-panic (contract-call? .signers stackerdb-get-last-set-cycle))))
         (and (is-eq last-cycle reward-cycle)
-            (< (mod (- height (get first-burnchain-block-height pox-info)) (get reward-cycle-length pox-info))
-                (get prepare-cycle-length pox-info)))))
+            (is-in-prepare-phase height))))
 
 (define-public (vote-for-aggregate-public-key (signer-index uint) (key (buff 33)) (round uint))
-    (let ((reward-cycle (burn-height-to-reward-cycle burn-block-height))
+    (let ((reward-cycle (+ u1 (burn-height-to-reward-cycle burn-block-height)))
             (tally-key {reward-cycle: reward-cycle, round: round, aggregate-public-key: key})
             ;; one slot, one vote
-            (num-slots (try! (try! (get-signer-slots signer-index reward-cycle))))
+            (num-slots (try! (get-current-signer-slots signer-index)))
             (new-total (+ num-slots (default-to u0 (map-get? tally tally-key)))))
         (asserts! (is-in-voting-window burn-block-height reward-cycle) err-out-of-voting-window)
         (asserts! (>= round (default-to u0 (map-get? rounds reward-cycle))) err-old-round)
diff --git a/stackslib/src/chainstate/stacks/boot/signers_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_tests.rs
index 42f80fb599..d9ea4618b7 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_tests.rs
@@ -197,8 +197,12 @@ fn signers_get_signer_keys_from_stackerdb() {
     let stacker_1 = TestStacker::from_seed(&[3, 4]);
     let stacker_2 = TestStacker::from_seed(&[5, 6]);
 
-    let (mut peer, test_signers, latest_block_id) =
-        prepare_signers_test(function_name!(), Some(vec![&stacker_1, &stacker_2]));
+    let (mut peer, test_signers, latest_block_id) = prepare_signers_test(
+        function_name!(),
+        vec![],
+        Some(vec![&stacker_1, &stacker_2]),
+        None,
+    );
 
     let private_key = peer.config.private_key.clone();
 
@@ -239,13 +243,21 @@ fn signers_get_signer_keys_from_stackerdb() {
     assert_eq!(signers, expected_stackerdb_slots);
 }
 
-fn prepare_signers_test<'a>(
+pub fn prepare_signers_test<'a>(
     test_name: &str,
+    initial_balances: Vec<(PrincipalData, u64)>,
     stackers: Option<Vec<&TestStacker>>,
+    observer: Option<&'a TestEventObserver>,
 ) -> (TestPeer<'a>, TestSigners, StacksBlockId) {
     let mut test_signers = TestSigners::default();
 
-    let mut peer = boot_nakamoto(test_name, vec![], &test_signers, stackers);
+    let mut peer = boot_nakamoto(
+        test_name,
+        initial_balances,
+        &test_signers,
+        stackers,
+        observer,
+    );
 
     let (burn_ops, mut tenure_change, miner_key) =
         peer.begin_nakamoto_tenure(TenureChangeCause::BlockFound);
diff --git a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
index 478173e1f3..571c11984e 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
@@ -17,6 +17,7 @@
 use std::collections::{HashMap, HashSet, VecDeque};
 use std::convert::{TryFrom, TryInto};
 
+use clarity::boot_util::boot_code_addr;
 use clarity::vm::clarity::ClarityConnection;
 use clarity::vm::contexts::OwnedEnvironment;
 use clarity::vm::contracts::Contract;
@@ -47,9 +48,13 @@ use wsts::curve::point::{Compressed, Point};
 use super::test::*;
 use super::RawRewardSetEntry;
 use crate::burnchains::{Burnchain, PoxConstants};
-use crate::chainstate::burn::db::sortdb::SortitionDB;
+use crate::chainstate::burn::db::sortdb::{self, SortitionDB};
 use crate::chainstate::burn::operations::*;
 use crate::chainstate::burn::{BlockSnapshot, ConsensusHash};
+use crate::chainstate::nakamoto::coordinator::tests::make_token_transfer;
+use crate::chainstate::nakamoto::tests::get_account;
+use crate::chainstate::nakamoto::tests::node::{TestSigners, TestStacker};
+use crate::chainstate::nakamoto::NakamotoBlock;
 use crate::chainstate::stacks::address::{PoxAddress, PoxAddressType20, PoxAddressType32};
 use crate::chainstate::stacks::boot::pox_2_tests::{
     check_pox_print_event, generate_pox_clarity_value, get_reward_set_entries_at,
@@ -59,8 +64,9 @@ use crate::chainstate::stacks::boot::pox_2_tests::{
 use crate::chainstate::stacks::boot::pox_4_tests::{
     assert_latest_was_burn, get_last_block_sender_transactions, get_tip, make_test_epochs_pox,
 };
+use crate::chainstate::stacks::boot::signers_tests::prepare_signers_test;
 use crate::chainstate::stacks::boot::{
-    BOOT_CODE_COST_VOTING_TESTNET as BOOT_CODE_COST_VOTING, BOOT_CODE_POX_TESTNET,
+    BOOT_CODE_COST_VOTING_TESTNET as BOOT_CODE_COST_VOTING, BOOT_CODE_POX_TESTNET, SIGNERS_NAME,
     SIGNERS_VOTING_NAME,
 };
 use crate::chainstate::stacks::db::{
@@ -70,7 +76,7 @@ use crate::chainstate::stacks::events::{StacksTransactionReceipt, TransactionOri
 use crate::chainstate::stacks::index::marf::MarfConnection;
 use crate::chainstate::stacks::index::MarfTrieId;
 use crate::chainstate::stacks::tests::make_coinbase;
-use crate::chainstate::stacks::*;
+use crate::chainstate::{self, stacks::*};
 use crate::clarity_vm::clarity::{ClarityBlockConnection, Error as ClarityError};
 use crate::clarity_vm::database::marf::{MarfedKV, WritableMarfStore};
 use crate::clarity_vm::database::HeadersDBConn;
@@ -131,10 +137,18 @@ pub fn prepare_pox4_test<'a>(
 
 #[test]
 fn vote_for_aggregate_public_key() {
+    let stacker_1 = TestStacker::from_seed(&[3, 4]);
+    let stacker_2 = TestStacker::from_seed(&[5, 6]);
     let observer = TestEventObserver::new();
 
-    let (burnchain, mut peer, keys, latest_block_id, block_height, mut coinbase_nonce) =
-        prepare_pox4_test(function_name!(), Some(&observer));
+    let signer = key_to_stacks_addr(&stacker_1.signer_private_key).to_account_principal();
+
+    let (mut peer, mut test_signers, latest_block_id) = prepare_signers_test(
+        function_name!(),
+        vec![(signer, 1000)],
+        Some(vec![&stacker_1, &stacker_2]),
+        Some(&observer),
+    );
 
     let current_reward_cycle = readonly_call(
         &mut peer,
@@ -145,76 +159,206 @@ fn vote_for_aggregate_public_key() {
     )
     .expect_u128();
 
-    assert_eq!(current_reward_cycle, 22);
+    assert_eq!(current_reward_cycle, 7);
+
+    let last_set_cycle = readonly_call(
+        &mut peer,
+        &latest_block_id,
+        SIGNERS_NAME.into(),
+        "stackerdb-get-last-set-cycle".into(),
+        vec![],
+    )
+    .expect_result_ok()
+    .expect_u128();
+
+    assert_eq!(last_set_cycle, 7);
 
-    let mut signer_nonce = 0;
-    let signer_key = &keys[0];
+    let signer_nonce = 0;
+    let signer_key = &stacker_1.signer_private_key;
     let signer_address = key_to_stacks_addr(signer_key);
     let signer_principal = PrincipalData::from(signer_address);
     let cycle_id = current_reward_cycle;
+
+    let signers = readonly_call(
+        &mut peer,
+        &latest_block_id,
+        "signers".into(),
+        "stackerdb-get-signer-slots".into(),
+        vec![],
+    )
+    .expect_result_ok()
+    .expect_list();
+
+    let signer_index = signers
+        .iter()
+        .position(|value| {
+            value
+                .clone()
+                .expect_tuple()
+                .get("signer")
+                .unwrap()
+                .clone()
+                .expect_principal()
+                == signer_address.to_account_principal()
+        })
+        .expect("signer not found") as u128;
+
     let aggregated_public_key: Point = Point::new();
 
-    // cast a vote for the aggregate public key
-    let txs = vec![make_signers_vote_for_aggregate_public_key(
+    let mut stacker_1_nonce: u64 = 1;
+    let dummy_tx_1 = make_dummy_tx(
+        &mut peer,
+        &stacker_1.stacker_private_key,
+        &mut stacker_1_nonce,
+    );
+    let dummy_tx_2 = make_dummy_tx(
+        &mut peer,
+        &stacker_1.stacker_private_key,
+        &mut stacker_1_nonce,
+    );
+    let dummy_tx_3 = make_dummy_tx(
+        &mut peer,
+        &stacker_1.stacker_private_key,
+        &mut stacker_1_nonce,
+    );
+    let dummy_tx_4 = make_dummy_tx(
+        &mut peer,
+        &stacker_1.stacker_private_key,
+        &mut stacker_1_nonce,
+    );
+    let dummy_tx_5 = make_dummy_tx(
+        &mut peer,
+        &stacker_1.stacker_private_key,
+        &mut stacker_1_nonce,
+    );
+    let dummy_tx_6 = make_dummy_tx(
+        &mut peer,
+        &stacker_1.stacker_private_key,
+        &mut stacker_1_nonce,
+    );
+
+    let txs = vec![
+        // cast a vote for the aggregate public key
+        make_signers_vote_for_aggregate_public_key(
+            signer_key,
+            signer_nonce,
+            signer_index,
+            &aggregated_public_key,
+            0,
+        ),
+        // cast the vote twice
+        make_signers_vote_for_aggregate_public_key(
+            signer_key,
+            signer_nonce + 1,
+            signer_index,
+            &aggregated_public_key,
+            0,
+        ),
+    ];
+
+    let txids: Vec<Txid> = txs.clone().iter().map(|t| t.txid()).collect();
+    dbg!(txids);
+
+    //
+    // vote in the last burn block of prepare phase
+    //
+
+    nakamoto_tenure(
+        &mut peer,
+        &mut test_signers,
+        vec![vec![dummy_tx_1]],
         signer_key,
-        signer_nonce,
-        &aggregated_public_key,
-        cycle_id,
-        0,
-    )];
+    );
 
-    let latest_block_id = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
-    let tx_receipts = get_last_block_sender_transactions(&observer, signer_address);
-    assert_eq!(tx_receipts.len(), 1);
+    nakamoto_tenure(
+        &mut peer,
+        &mut test_signers,
+        vec![vec![dummy_tx_2]],
+        signer_key,
+    );
+
+    // vote now
+    let blocks_and_sizes = nakamoto_tenure(&mut peer, &mut test_signers, vec![txs], signer_key);
+    let block = observer.get_blocks().last().unwrap().clone();
+    let receipts = block.receipts.as_slice();
+    assert_eq!(receipts.len(), 2);
+    // ignore tenure change tx
+    // ignore coinbase tx
+    let tx1 = &receipts[receipts.len() - 2];
     assert_eq!(
-        tx_receipts[0].result,
+        tx1.result,
         Value::Response(ResponseData {
             committed: true,
             data: Box::new(Value::Bool(true))
         })
     );
 
-    signer_nonce += 1;
-
-    // cast same vote twice
-    let txs = vec![make_signers_vote_for_aggregate_public_key(
-        signer_key,
-        signer_nonce,
-        &aggregated_public_key,
-        cycle_id,
-        0,
-    )];
-
-    let latest_block_id = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
-    let tx_receipts = get_last_block_sender_transactions(&observer, signer_address);
-    assert_eq!(tx_receipts.len(), 1);
+    let tx2 = &receipts[receipts.len() - 1];
     assert_eq!(
-        tx_receipts[0].result,
+        tx2.result,
         Value::Response(ResponseData {
             committed: false,
-            data: Box::new(Value::UInt(10005)) // err-duplicate-vote
+            data: Box::new(Value::UInt(10006)) // err-duplicate-vote
         })
     );
+}
 
-    signer_nonce += 1;
+fn nakamoto_tenure(
+    peer: &mut TestPeer,
+    test_signers: &mut TestSigners,
+    txs_of_blocks: Vec<Vec<StacksTransaction>>,
+    stacker_private_key: &StacksPrivateKey,
+) -> Vec<(NakamotoBlock, u64, ExecutionCost)> {
+    let current_height = peer.get_burnchain_view().unwrap().burn_block_height;
 
-    // cast vote too late
-    let txs = vec![make_signers_vote_for_aggregate_public_key(
-        signer_key,
-        signer_nonce,
-        &aggregated_public_key,
-        cycle_id - 1,
-        0,
-    )];
+    info!("current height: {}", current_height);
 
-    let latest_block_id = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
-    let tx_receipts = get_last_block_sender_transactions(&observer, signer_address);
-    assert_eq!(tx_receipts.len(), 1);
-    assert_eq!(
-        tx_receipts[0].result,
-        Value::Response(ResponseData {
-            committed: false,
-            data: Box::new(Value::UInt(10001)) // err-incorrect-reward-cycle
-        })
+    let (burn_ops, mut tenure_change, miner_key) =
+        peer.begin_nakamoto_tenure(TenureChangeCause::BlockFound);
+
+    let (_, _, consensus_hash) = peer.next_burnchain_block(burn_ops);
+
+    let vrf_proof = peer.make_nakamoto_vrf_proof(miner_key);
+
+    tenure_change.tenure_consensus_hash = consensus_hash.clone();
+    tenure_change.burn_view_consensus_hash = consensus_hash.clone();
+    let tenure_change_tx = peer
+        .miner
+        .make_nakamoto_tenure_change(tenure_change.clone());
+    let coinbase_tx = peer.miner.make_nakamoto_coinbase(None, vrf_proof);
+    let recipient_addr = boot_code_addr(false);
+    let mut mutable_txs_of_blocks = txs_of_blocks.clone();
+    mutable_txs_of_blocks.reverse();
+    let blocks_and_sizes = peer.make_nakamoto_tenure(
+        tenure_change_tx,
+        coinbase_tx.clone(),
+        test_signers,
+        |miner, chainstate, sortdb, blocks| mutable_txs_of_blocks.pop().unwrap_or(vec![]),
     );
+    info!("tenure length {}", blocks_and_sizes.len());
+    blocks_and_sizes
+}
+
+fn make_dummy_tx(
+    peer: &mut TestPeer,
+    private_key: &StacksPrivateKey,
+    nonce: &mut u64,
+) -> StacksTransaction {
+    peer.with_db_state(|sortdb, chainstate, _, _| {
+        let addr = key_to_stacks_addr(&private_key);
+        let account = get_account(chainstate, sortdb, &addr);
+        let recipient_addr = boot_code_addr(false);
+        let stx_transfer = make_token_transfer(
+            chainstate,
+            sortdb,
+            &private_key,
+            *nonce,
+            1,
+            1,
+            &recipient_addr,
+        );
+        *nonce += 1;
+        Ok(stx_transfer)
+    })
+    .unwrap()
 }

From 26d4833a7d11225ad4f07df13fcf4f5ab49d98a7 Mon Sep 17 00:00:00 2001
From: friedger <mail@friedger.de>
Date: Tue, 30 Jan 2024 18:34:35 +0100
Subject: [PATCH 0529/1166] chore: refactor test

---
 .../chainstate/stacks/boot/signers_tests.rs   |  65 ++++++-
 .../stacks/boot/signers_voting_tests.rs       | 159 ++++++++++--------
 2 files changed, 152 insertions(+), 72 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_tests.rs
index d9ea4618b7..bcd47d4177 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_tests.rs
@@ -18,7 +18,9 @@ use clarity::vm::clarity::ClarityConnection;
 use clarity::vm::contexts::OwnedEnvironment;
 use clarity::vm::costs::LimitedCostTracker;
 use clarity::vm::tests::symbols_from_values;
-use clarity::vm::types::{PrincipalData, QualifiedContractIdentifier, TupleData};
+use clarity::vm::types::{
+    PrincipalData, QualifiedContractIdentifier, StacksAddressExtensions, TupleData,
+};
 use clarity::vm::Value::Principal;
 use clarity::vm::{ClarityName, ClarityVersion, ContractName, Value};
 use stacks_common::address::AddressHashMode;
@@ -44,7 +46,7 @@ use crate::chainstate::stacks::boot::pox_4_tests::{
 use crate::chainstate::stacks::boot::test::{
     instantiate_pox_peer_with_epoch, key_to_stacks_addr, make_pox_4_lockup, with_sortdb,
 };
-use crate::chainstate::stacks::boot::{NakamotoSignerEntry, SIGNERS_NAME};
+use crate::chainstate::stacks::boot::{NakamotoSignerEntry, SIGNERS_NAME, SIGNERS_VOTING_NAME};
 use crate::chainstate::stacks::db::StacksChainState;
 use crate::chainstate::stacks::index::marf::MarfConnection;
 use crate::chainstate::stacks::{
@@ -197,7 +199,7 @@ fn signers_get_signer_keys_from_stackerdb() {
     let stacker_1 = TestStacker::from_seed(&[3, 4]);
     let stacker_2 = TestStacker::from_seed(&[5, 6]);
 
-    let (mut peer, test_signers, latest_block_id) = prepare_signers_test(
+    let (mut peer, test_signers, latest_block_id, _) = prepare_signers_test(
         function_name!(),
         vec![],
         Some(vec![&stacker_1, &stacker_2]),
@@ -248,7 +250,7 @@ pub fn prepare_signers_test<'a>(
     initial_balances: Vec<(PrincipalData, u64)>,
     stackers: Option<Vec<&TestStacker>>,
     observer: Option<&'a TestEventObserver>,
-) -> (TestPeer<'a>, TestSigners, StacksBlockId) {
+) -> (TestPeer<'a>, TestSigners, StacksBlockId, u128) {
     let mut test_signers = TestSigners::default();
 
     let mut peer = boot_nakamoto(
@@ -281,7 +283,30 @@ pub fn prepare_signers_test<'a>(
     );
     let latest_block_id = blocks_and_sizes.last().unwrap().0.block_id();
 
-    (peer, test_signers, latest_block_id)
+    let current_reward_cycle = readonly_call(
+        &mut peer,
+        &latest_block_id,
+        SIGNERS_VOTING_NAME.into(),
+        "current-reward-cycle".into(),
+        vec![],
+    )
+    .expect_u128();
+
+    assert_eq!(current_reward_cycle, 7);
+
+    let last_set_cycle = readonly_call(
+        &mut peer,
+        &latest_block_id,
+        SIGNERS_NAME.into(),
+        "stackerdb-get-last-set-cycle".into(),
+        vec![],
+    )
+    .expect_result_ok()
+    .expect_u128();
+
+    assert_eq!(last_set_cycle, 7);
+
+    (peer, test_signers, latest_block_id, current_reward_cycle)
 }
 
 fn advance_blocks(
@@ -367,3 +392,33 @@ fn readonly_call(
     })
     .unwrap()
 }
+
+pub fn get_signer_index(
+    peer: &mut TestPeer<'_>,
+    latest_block_id: StacksBlockId,
+    signer_address: StacksAddress,
+) -> u128 {
+    let signers = readonly_call(
+        peer,
+        &latest_block_id,
+        "signers".into(),
+        "stackerdb-get-signer-slots".into(),
+        vec![],
+    )
+    .expect_result_ok()
+    .expect_list();
+
+    signers
+        .iter()
+        .position(|value| {
+            value
+                .clone()
+                .expect_tuple()
+                .get("signer")
+                .unwrap()
+                .clone()
+                .expect_principal()
+                == signer_address.to_account_principal()
+        })
+        .expect("signer not found") as u128
+}
diff --git a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
index 571c11984e..bca7ce54b0 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
@@ -64,7 +64,7 @@ use crate::chainstate::stacks::boot::pox_2_tests::{
 use crate::chainstate::stacks::boot::pox_4_tests::{
     assert_latest_was_burn, get_last_block_sender_transactions, get_tip, make_test_epochs_pox,
 };
-use crate::chainstate::stacks::boot::signers_tests::prepare_signers_test;
+use crate::chainstate::stacks::boot::signers_tests::{get_signer_index, prepare_signers_test};
 use crate::chainstate::stacks::boot::{
     BOOT_CODE_COST_VOTING_TESTNET as BOOT_CODE_COST_VOTING, BOOT_CODE_POX_TESTNET, SIGNERS_NAME,
     SIGNERS_VOTING_NAME,
@@ -136,42 +136,21 @@ pub fn prepare_pox4_test<'a>(
 }
 
 #[test]
-fn vote_for_aggregate_public_key() {
+fn vote_for_aggregate_public_key_in_first_block() {
     let stacker_1 = TestStacker::from_seed(&[3, 4]);
     let stacker_2 = TestStacker::from_seed(&[5, 6]);
     let observer = TestEventObserver::new();
 
     let signer = key_to_stacks_addr(&stacker_1.signer_private_key).to_account_principal();
 
-    let (mut peer, mut test_signers, latest_block_id) = prepare_signers_test(
+    let (mut peer, mut test_signers, latest_block_id, current_reward_cycle) = prepare_signers_test(
         function_name!(),
         vec![(signer, 1000)],
         Some(vec![&stacker_1, &stacker_2]),
         Some(&observer),
     );
 
-    let current_reward_cycle = readonly_call(
-        &mut peer,
-        &latest_block_id,
-        SIGNERS_VOTING_NAME.into(),
-        "current-reward-cycle".into(),
-        vec![],
-    )
-    .expect_u128();
-
-    assert_eq!(current_reward_cycle, 7);
-
-    let last_set_cycle = readonly_call(
-        &mut peer,
-        &latest_block_id,
-        SIGNERS_NAME.into(),
-        "stackerdb-get-last-set-cycle".into(),
-        vec![],
-    )
-    .expect_result_ok()
-    .expect_u128();
-
-    assert_eq!(last_set_cycle, 7);
+    // create vote txs
 
     let signer_nonce = 0;
     let signer_key = &stacker_1.signer_private_key;
@@ -179,32 +158,81 @@ fn vote_for_aggregate_public_key() {
     let signer_principal = PrincipalData::from(signer_address);
     let cycle_id = current_reward_cycle;
 
-    let signers = readonly_call(
-        &mut peer,
-        &latest_block_id,
-        "signers".into(),
-        "stackerdb-get-signer-slots".into(),
-        vec![],
-    )
-    .expect_result_ok()
-    .expect_list();
-
-    let signer_index = signers
-        .iter()
-        .position(|value| {
-            value
-                .clone()
-                .expect_tuple()
-                .get("signer")
-                .unwrap()
-                .clone()
-                .expect_principal()
-                == signer_address.to_account_principal()
-        })
-        .expect("signer not found") as u128;
+    let signer_index = get_signer_index(&mut peer, latest_block_id, signer_address);
 
     let aggregated_public_key: Point = Point::new();
 
+    let txs = vec![
+        // cast a vote for the aggregate public key
+        make_signers_vote_for_aggregate_public_key(
+            signer_key,
+            signer_nonce,
+            signer_index,
+            &aggregated_public_key,
+            0,
+        ),
+        // cast the vote twice
+        make_signers_vote_for_aggregate_public_key(
+            signer_key,
+            signer_nonce + 1,
+            signer_index,
+            &aggregated_public_key,
+            0,
+        ),
+    ];
+
+    let txids: Vec<Txid> = txs.clone().iter().map(|t| t.txid()).collect();
+    dbg!(txids);
+
+    //
+    // vote in the first burn block of prepare phase
+    //
+    let blocks_and_sizes = nakamoto_tenure(&mut peer, &mut test_signers, vec![txs], signer_key);
+
+    // check the last two txs in the last block
+    let block = observer.get_blocks().last().unwrap().clone();
+    let receipts = block.receipts.as_slice();
+    assert_eq!(receipts.len(), 4);
+
+    // ignore tenure change tx
+    // ignore tenure coinbase tx
+
+    // first vote should succeed
+    let tx1 = &receipts[receipts.len() - 2];
+    assert_eq!(
+        tx1.result,
+        Value::Response(ResponseData {
+            committed: true,
+            data: Box::new(Value::Bool(true))
+        })
+    );
+
+    // second vote should fail with duplicate vote error
+    let tx2 = &receipts[receipts.len() - 1];
+    assert_eq!(
+        tx2.result,
+        Value::Response(ResponseData {
+            committed: false,
+            data: Box::new(Value::UInt(10006)) // err-duplicate-vote
+        })
+    );
+}
+
+#[test]
+fn vote_for_aggregate_public_key_in_last_block() {
+    let stacker_1 = TestStacker::from_seed(&[3, 4]);
+    let stacker_2 = TestStacker::from_seed(&[5, 6]);
+    let observer = TestEventObserver::new();
+
+    let signer = key_to_stacks_addr(&stacker_1.signer_private_key).to_account_principal();
+
+    let (mut peer, mut test_signers, latest_block_id, current_reward_cycle) = prepare_signers_test(
+        function_name!(),
+        vec![(signer, 1000)],
+        Some(vec![&stacker_1, &stacker_2]),
+        Some(&observer),
+    );
+
     let mut stacker_1_nonce: u64 = 1;
     let dummy_tx_1 = make_dummy_tx(
         &mut peer,
@@ -221,21 +249,15 @@ fn vote_for_aggregate_public_key() {
         &stacker_1.stacker_private_key,
         &mut stacker_1_nonce,
     );
-    let dummy_tx_4 = make_dummy_tx(
-        &mut peer,
-        &stacker_1.stacker_private_key,
-        &mut stacker_1_nonce,
-    );
-    let dummy_tx_5 = make_dummy_tx(
-        &mut peer,
-        &stacker_1.stacker_private_key,
-        &mut stacker_1_nonce,
-    );
-    let dummy_tx_6 = make_dummy_tx(
-        &mut peer,
-        &stacker_1.stacker_private_key,
-        &mut stacker_1_nonce,
-    );
+
+    // create vote txs
+    let signer_nonce = 0;
+    let signer_key = &stacker_1.signer_private_key;
+    let signer_address = key_to_stacks_addr(signer_key);
+    let signer_principal = PrincipalData::from(signer_address);
+    let cycle_id = current_reward_cycle;
+    let signer_index = get_signer_index(&mut peer, latest_block_id, signer_address);
+    let aggregated_public_key: Point = Point::new();
 
     let txs = vec![
         // cast a vote for the aggregate public key
@@ -277,13 +299,15 @@ fn vote_for_aggregate_public_key() {
         signer_key,
     );
 
-    // vote now
+    // vote in second block of tenure
     let blocks_and_sizes = nakamoto_tenure(&mut peer, &mut test_signers, vec![txs], signer_key);
+
+    // check the last two txs in the last block
     let block = observer.get_blocks().last().unwrap().clone();
     let receipts = block.receipts.as_slice();
-    assert_eq!(receipts.len(), 2);
-    // ignore tenure change tx
-    // ignore coinbase tx
+    assert_eq!(receipts.len(), 4);
+
+    // first vote should succeed
     let tx1 = &receipts[receipts.len() - 2];
     assert_eq!(
         tx1.result,
@@ -293,6 +317,7 @@ fn vote_for_aggregate_public_key() {
         })
     );
 
+    // second vote should fail with duplicate vote error
     let tx2 = &receipts[receipts.len() - 1];
     assert_eq!(
         tx2.result,

From 893a7c69dfb0e5e3414d071190d7f3f863c73412 Mon Sep 17 00:00:00 2001
From: wileyj <2847772+wileyj@users.noreply.github.com>
Date: Tue, 30 Jan 2024 10:25:32 -0800
Subject: [PATCH 0530/1166] Target specific binaries for release builds

---
 build-scripts/Dockerfile.linux-glibc-arm64 | 2 +-
 build-scripts/Dockerfile.linux-glibc-armv7 | 4 ++--
 build-scripts/Dockerfile.linux-glibc-x64   | 2 +-
 build-scripts/Dockerfile.linux-musl-arm64  | 3 ++-
 build-scripts/Dockerfile.linux-musl-armv7  | 4 ++--
 build-scripts/Dockerfile.linux-musl-x64    | 3 ++-
 build-scripts/Dockerfile.macos-arm64       | 3 ++-
 build-scripts/Dockerfile.macos-x64         | 3 ++-
 build-scripts/Dockerfile.windows-x64       | 4 ++--
 9 files changed, 16 insertions(+), 12 deletions(-)

diff --git a/build-scripts/Dockerfile.linux-glibc-arm64 b/build-scripts/Dockerfile.linux-glibc-arm64
index 7ce50b6a68..11e38f8804 100644
--- a/build-scripts/Dockerfile.linux-glibc-arm64
+++ b/build-scripts/Dockerfile.linux-glibc-arm64
@@ -18,7 +18,7 @@ RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
     && CC=aarch64-linux-gnu-gcc \
     CC_aarch64_unknown_linux_gnu=aarch64-linux-gnu-gcc \
     CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER=aarch64-linux-gnu-gcc \
-    cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} \
+    cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli \
     && mkdir -p /out \
     && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
 
diff --git a/build-scripts/Dockerfile.linux-glibc-armv7 b/build-scripts/Dockerfile.linux-glibc-armv7
index eb893baeb6..cc05298dfe 100644
--- a/build-scripts/Dockerfile.linux-glibc-armv7
+++ b/build-scripts/Dockerfile.linux-glibc-armv7
@@ -18,9 +18,9 @@ RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
     && CC=arm-linux-gnueabihf-gcc \
     CC_armv7_unknown_linux_gnueabihf=arm-linux-gnueabihf-gcc \
     CARGO_TARGET_ARMV7_UNKNOWN_LINUX_GNUEABIHF_LINKER=arm-linux-gnueabihf-gcc \
-    cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} \
+    cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli \
     && mkdir -p /out \
     && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
 
 FROM scratch AS export-stage
-COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
\ No newline at end of file
+COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
diff --git a/build-scripts/Dockerfile.linux-glibc-x64 b/build-scripts/Dockerfile.linux-glibc-x64
index 2db13cb51e..7d0591023d 100644
--- a/build-scripts/Dockerfile.linux-glibc-x64
+++ b/build-scripts/Dockerfile.linux-glibc-x64
@@ -15,7 +15,7 @@ RUN apt-get update && apt-get install -y git
 RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
     && cd ${BUILD_DIR} \
     && rustup target add ${TARGET} \
-    && cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} \
+    && cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli \
     && mkdir -p /out \
     && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
 
diff --git a/build-scripts/Dockerfile.linux-musl-arm64 b/build-scripts/Dockerfile.linux-musl-arm64
index 135e6f9fc9..24a07f018a 100644
--- a/build-scripts/Dockerfile.linux-musl-arm64
+++ b/build-scripts/Dockerfile.linux-musl-arm64
@@ -13,9 +13,10 @@ COPY . .
 RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
     && cd ${BUILD_DIR} \
     && rustup target add ${TARGET} \
-    && cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} \
+    && cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli \
     && mkdir -p /out \
     && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
 
 FROM scratch AS export-stage
 COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
+
diff --git a/build-scripts/Dockerfile.linux-musl-armv7 b/build-scripts/Dockerfile.linux-musl-armv7
index 57b93b47ec..2ce5a99912 100644
--- a/build-scripts/Dockerfile.linux-musl-armv7
+++ b/build-scripts/Dockerfile.linux-musl-armv7
@@ -13,9 +13,9 @@ COPY . .
 RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
     && cd ${BUILD_DIR} \
     && rustup target add ${TARGET} \
-    && cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} \
+    && cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli \
     && mkdir -p /out \
     && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
 
 FROM scratch AS export-stage
-COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
\ No newline at end of file
+COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
diff --git a/build-scripts/Dockerfile.linux-musl-x64 b/build-scripts/Dockerfile.linux-musl-x64
index 73e64b4d67..e34c629d62 100644
--- a/build-scripts/Dockerfile.linux-musl-x64
+++ b/build-scripts/Dockerfile.linux-musl-x64
@@ -15,9 +15,10 @@ RUN apk update && apk add git musl-dev
 RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
     && cd ${BUILD_DIR} \
     && rustup target add ${TARGET} \
-    && cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} \
+    && cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli \
     && mkdir -p /out \
     && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
 
 FROM scratch AS export-stage
 COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
+
diff --git a/build-scripts/Dockerfile.macos-arm64 b/build-scripts/Dockerfile.macos-arm64
index d6b80f267a..0fd8a1e4c3 100644
--- a/build-scripts/Dockerfile.macos-arm64
+++ b/build-scripts/Dockerfile.macos-arm64
@@ -21,9 +21,10 @@ RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
     && cd ${BUILD_DIR} \
     && rustup target add ${TARGET} \
     && . /opt/osxcross/env-macos-aarch64 \
-    && cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} \
+    && cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli \
     && mkdir -p /out \
     && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
 
 FROM scratch AS export-stage
 COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
+
diff --git a/build-scripts/Dockerfile.macos-x64 b/build-scripts/Dockerfile.macos-x64
index 5403b2fe87..d73aa35f98 100644
--- a/build-scripts/Dockerfile.macos-x64
+++ b/build-scripts/Dockerfile.macos-x64
@@ -21,9 +21,10 @@ RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
     && cd ${BUILD_DIR} \
     && rustup target add ${TARGET} \
     && . /opt/osxcross/env-macos-x86_64 \
-    && cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} \
+    && cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli \
     && mkdir -p /out \
     && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
 
 FROM scratch AS export-stage
 COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
+
diff --git a/build-scripts/Dockerfile.windows-x64 b/build-scripts/Dockerfile.windows-x64
index c3ffcd5d29..c1f1e87a7e 100644
--- a/build-scripts/Dockerfile.windows-x64
+++ b/build-scripts/Dockerfile.windows-x64
@@ -17,9 +17,9 @@ RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
     && rustup target add ${TARGET} \
     && CC_x86_64_pc_windows_gnu=x86_64-w64-mingw32-gcc \
     CARGO_TARGET_X86_64_PC_WINDOWS_GNU_LINKER=x86_64-w64-mingw32-gcc \
-    cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} \
+    cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli \
     && mkdir -p /out \
     && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
 
 FROM scratch AS export-stage
-COPY --from=build /out/stacks-inspect.exe /out/blockstack-cli.exe /out/clarity-cli.exe /out/stacks-node.exe /
\ No newline at end of file
+COPY --from=build /out/stacks-inspect.exe /out/blockstack-cli.exe /out/clarity-cli.exe /out/stacks-node.exe /

From 43d869593a9bc3b0b5ca8550971d6afdc3d2f805 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Mon, 29 Jan 2024 15:22:54 -0800
Subject: [PATCH 0531/1166] fix: modify simple signer test to fix intermittent
 failure

---
 libsigner/src/tests/mod.rs | 66 ++++++++++++++++++++++++++------------
 1 file changed, 46 insertions(+), 20 deletions(-)

diff --git a/libsigner/src/tests/mod.rs b/libsigner/src/tests/mod.rs
index 60889fc8c1..b53fd00afa 100644
--- a/libsigner/src/tests/mod.rs
+++ b/libsigner/src/tests/mod.rs
@@ -96,10 +96,11 @@ fn test_simple_signer() {
     let ev = SignerEventReceiver::new(vec![contract_id.clone()], false);
     let (_cmd_send, cmd_recv) = channel();
     let (res_send, _res_recv) = channel();
-    let mut signer = Signer::new(SimpleRunLoop::new(5), ev, cmd_recv, res_send);
+    let max_events = 5;
+    let mut signer = Signer::new(SimpleRunLoop::new(max_events), ev, cmd_recv, res_send);
     let endpoint: SocketAddr = "127.0.0.1:30000".parse().unwrap();
     let mut chunks = vec![];
-    for i in 0..5 {
+    for i in 0..max_events {
         let privk = Secp256k1PrivateKey::new();
         let msg = wsts::net::Message::DkgBegin(DkgBegin { dkg_id: 0 });
         let message = SignerMessage::Packet(Packet { msg, sig: vec![] });
@@ -138,24 +139,6 @@ fn test_simple_signer() {
 
             num_sent += 1;
         }
-        // Test the /status endpoint
-        {
-            let mut sock = match TcpStream::connect(endpoint) {
-                Ok(sock) => sock,
-                Err(..) => {
-                    sleep_ms(100);
-                    return;
-                }
-            };
-            let req = "GET /status HTTP/1.0\r\nConnection: close\r\n\r\n";
-            sock.write_all(req.as_bytes()).unwrap();
-            let mut buf = [0; 128];
-            sock.read(&mut buf).unwrap();
-            let res_str = std::str::from_utf8(&buf).unwrap();
-            let expected_status_res = "HTTP/1.0 200 OK\r\n";
-            assert_eq!(expected_status_res, &res_str[..expected_status_res.len()]);
-            sock.flush().unwrap();
-        }
     });
 
     let running_signer = signer.spawn(endpoint).unwrap();
@@ -181,3 +164,46 @@ fn test_simple_signer() {
     assert_eq!(sent_events, accepted_events);
     mock_stacks_node.join().unwrap();
 }
+
+#[test]
+fn test_status_endpoint() {
+    let contract_id =
+        QualifiedContractIdentifier::parse("ST2DS4MSWSGJ3W9FBC6BVT0Y92S345HY8N3T6AV7R.signers")
+            .unwrap(); // TODO: change to boot_code_id(SIGNERS_NAME, false) when .signers is deployed
+    let ev = SignerEventReceiver::new(vec![contract_id.clone()], false);
+    let (_cmd_send, cmd_recv) = channel();
+    let (res_send, _res_recv) = channel();
+    let max_events = 1;
+    let mut signer = Signer::new(SimpleRunLoop::new(max_events), ev, cmd_recv, res_send);
+    let endpoint: SocketAddr = "127.0.0.1:31000".parse().unwrap();
+
+    // simulate a node that's trying to push data
+    let mock_stacks_node = thread::spawn(move || {
+        let mut sock = match TcpStream::connect(endpoint) {
+            Ok(sock) => sock,
+            Err(e) => {
+                eprint!("Error connecting to {}: {}", endpoint, e);
+                sleep_ms(100);
+                return;
+            }
+        };
+        let req = "GET /status HTTP/1.0\r\nConnection: close\r\n\r\n";
+
+        sock.write_all(req.as_bytes()).unwrap();
+        let mut buf = [0; 128];
+        sock.read(&mut buf).unwrap();
+        let res_str = std::str::from_utf8(&buf).unwrap();
+        let expected_status_res = "HTTP/1.0 200 OK\r\n";
+        assert_eq!(expected_status_res, &res_str[..expected_status_res.len()]);
+        sock.flush().unwrap();
+    });
+
+    let running_signer = signer.spawn(endpoint).unwrap();
+    sleep_ms(3000);
+    let accepted_events = running_signer.stop().unwrap();
+
+    let sent_events: Vec<SignerEvent> = vec![SignerEvent::StatusCheck];
+
+    assert_eq!(sent_events, accepted_events);
+    mock_stacks_node.join().unwrap();
+}

From 0354edd9866e6c2c569971003c74b2b2cc5e2cdd Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Wed, 31 Jan 2024 00:09:43 -0500
Subject: [PATCH 0532/1166] chore: expand warning for having an invalid
 block-commit

---
 .../src/chainstate/burn/operations/leader_block_commit.rs     | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/stackslib/src/chainstate/burn/operations/leader_block_commit.rs b/stackslib/src/chainstate/burn/operations/leader_block_commit.rs
index 426447c350..38c9fb1c2d 100644
--- a/stackslib/src/chainstate/burn/operations/leader_block_commit.rs
+++ b/stackslib/src/chainstate/burn/operations/leader_block_commit.rs
@@ -682,9 +682,9 @@ impl LeaderBlockCommitOp {
                             op_error::BlockCommitAnchorCheck})?;
                     if descended_from_anchor != expect_pox_descendant {
                         if descended_from_anchor {
-                            warn!("Invalid block commit: descended from PoX anchor, but used burn outputs");
+                            warn!("Invalid block commit: descended from PoX anchor {}, but used burn outputs", &reward_set_info.anchor_block);
                         } else {
-                            warn!("Invalid block commit: not descended from PoX anchor, but used PoX outputs");
+                            warn!("Invalid block commit: not descended from PoX anchor {}, but used PoX outputs", &reward_set_info.anchor_block);
                         }
                         return Err(op_error::BlockCommitBadOutputs);
                     }

From 7602c55b9648fb7ade486ba8010eb4b0ce2b322b Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Wed, 31 Jan 2024 00:10:09 -0500
Subject: [PATCH 0533/1166] fix: correct the number of expected successful
 tenures

---
 stackslib/src/chainstate/nakamoto/coordinator/tests.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index b1e21205e9..6783a20e8f 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -1731,7 +1731,7 @@ pub fn simple_nakamoto_coordinator_10_extended_tenures_10_sortitions() -> TestPe
         assert!(last_block.header.consensus_hash == sort_tip.consensus_hash);
         assert_eq!(highest_tenure.coinbase_height, 12 + i);
         assert_eq!(highest_tenure.cause, TenureChangeCause::Extended);
-        assert_eq!(highest_tenure.tenure_index, 8 * (i + 1));
+        assert_eq!(highest_tenure.tenure_index, 10 * (i + 1));
         assert_eq!(
             highest_tenure.num_blocks_confirmed,
             (blocks.len() as u32) - 1

From 655f10431aa0153b4cfe94803f08b31d540e6f36 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Wed, 31 Jan 2024 00:10:45 -0500
Subject: [PATCH 0534/1166] fix: correctly find the parent sortition for a new
 nakamoto tenure

---
 .../src/chainstate/nakamoto/tests/node.rs     | 88 +++++++++++++------
 1 file changed, 60 insertions(+), 28 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/tests/node.rs b/stackslib/src/chainstate/nakamoto/tests/node.rs
index ac71cf6721..21b6c17756 100644
--- a/stackslib/src/chainstate/nakamoto/tests/node.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/node.rs
@@ -244,7 +244,6 @@ impl TestMiner {
         tx_tenure_change.anchor_mode = TransactionAnchorMode::OnChainOnly;
         tx_tenure_change.auth.set_origin_nonce(self.nonce);
 
-        // TODO: This needs to be changed to an aggregate signature from the stackers
         let mut tx_signer = StacksTransactionSigner::new(&tx_tenure_change);
         self.sign_as_origin(&mut tx_signer);
         let tx_tenure_change_signed = tx_signer.get_tx().unwrap();
@@ -289,9 +288,22 @@ impl TestStacksNode {
             None => None,
             Some(block_commit_op) => {
                 let last_tenure_id = block_commit_op.last_tenure_id();
+                debug!(
+                    "Last block commit was for {}: {:?}",
+                    &last_tenure_id, &block_commit_op
+                );
                 match self.nakamoto_commit_ops.get(&last_tenure_id) {
-                    None => None,
-                    Some(idx) => self.nakamoto_blocks.get(*idx).cloned(),
+                    None => {
+                        debug!("No Nakamoto index for {}", &last_tenure_id);
+                        None
+                    }
+                    Some(idx) => match self.nakamoto_blocks.get(*idx) {
+                        Some(nakamoto_blocks) => Some(nakamoto_blocks.clone()),
+                        None => {
+                            debug!("Nakamoto block index {} does not correspond to list of mined nakamoto tenures (len {})", idx, self.nakamoto_blocks.len());
+                            None
+                        }
+                    },
                 }
             }
         }
@@ -319,6 +331,7 @@ impl TestStacksNode {
         burn_amount: u64,
         miner_key: &LeaderKeyRegisterOp,
         parent_block_snapshot_opt: Option<&BlockSnapshot>,
+        expect_success: bool,
     ) -> LeaderBlockCommitOp {
         test_debug!(
             "Miner {}: Commit to Nakamoto tenure starting at {}",
@@ -357,18 +370,25 @@ impl TestStacksNode {
         );
 
         test_debug!(
-            "Miner {}: Nakamoto tenure commit transaction builds on {},{} (parent snapshot is {:?})",
+            "Miner {}: Nakamoto tenure commit transaction builds on {},{} (parent snapshot is {:?}). Expect success? {}",
             miner.id,
             block_commit_op.parent_block_ptr,
             block_commit_op.parent_vtxindex,
-            &parent_block_snapshot_opt
+            &parent_block_snapshot_opt,
+            expect_success
         );
 
-        // NOTE: self.nakamoto_commit_ops[block_header_hash] now contains an index into
-        // self.nakamoto_blocks that doesn't exist.  The caller needs to follow this call with a
-        // call to self.add_nakamoto_tenure_blocks()
-        self.nakamoto_commit_ops
-            .insert(last_tenure_id.clone(), self.nakamoto_blocks.len());
+        if expect_success {
+            // NOTE: self.nakamoto_commit_ops[block_header_hash] now contains an index into
+            // self.nakamoto_blocks that doesn't exist.  The caller needs to follow this call with a
+            // call to self.add_nakamoto_tenure_blocks()
+            self.nakamoto_commit_ops
+                .insert(last_tenure_id.clone(), self.nakamoto_blocks.len());
+        } else {
+            // this extends the last tenure
+            self.nakamoto_commit_ops
+                .insert(last_tenure_id.clone(), self.nakamoto_blocks.len() - 1);
+        }
         block_commit_op
     }
 
@@ -480,6 +500,7 @@ impl TestStacksNode {
                     &hdr.consensus_hash,
                 )
                 .unwrap();
+                debug!("Tenure length of {} is {}", &hdr.consensus_hash, tenure_len);
                 (hdr.index_block_hash(), hdr.consensus_hash, tenure_len)
             } else {
                 // building atop epoch2
@@ -509,6 +530,7 @@ impl TestStacksNode {
             burn_amount,
             miner_key,
             Some(&parent_block_snapshot),
+            tenure_change_cause == TenureChangeCause::BlockFound,
         );
 
         (block_commit_op, tenure_change_payload)
@@ -544,10 +566,6 @@ impl TestStacksNode {
             &[(NakamotoBlock, u64, ExecutionCost)],
         ) -> Vec<StacksTransaction>,
     {
-        let miner_addr = miner.origin_address().unwrap();
-        let miner_account = get_account(chainstate, sortdb, &miner_addr);
-        miner.set_nonce(miner_account.nonce);
-
         let mut blocks = vec![];
         let mut block_count = 0;
         loop {
@@ -752,25 +770,38 @@ impl<'a> TestPeer<'a> {
     ) {
         let tip = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn()).unwrap();
         if let Some(parent_blocks) = stacks_node.get_last_nakamoto_tenure(miner) {
+            debug!("Parent will be a Nakamoto block");
+
             // parent is an epoch 3 nakamoto block
             let first_parent = parent_blocks.first().unwrap();
-            let parent_tenure_id = StacksBlockId::new(
+            debug!("First parent is {:?}", first_parent);
+
+            let first_parent_sn = SortitionDB::get_block_snapshot_consensus(
+                sortdb.conn(),
                 &first_parent.header.consensus_hash,
-                &first_parent.header.block_hash(),
-            );
-            let ic = sortdb.index_conn();
-            let parent_sortition_opt = SortitionDB::get_block_snapshot_for_winning_nakamoto_tenure(
-                &ic,
-                &tip.sortition_id,
-                &parent_tenure_id,
             )
+            .unwrap()
             .unwrap();
-            if parent_sortition_opt.is_none() {
-                warn!(
-                    "No parent sortition: tip.sortition_id = {}, parent_tenure_id = {}",
-                    &tip.sortition_id, &parent_tenure_id
-                );
-            }
+
+            assert!(first_parent_sn.sortition);
+
+            let parent_sortition_id = SortitionDB::get_block_commit_parent_sortition_id(
+                sortdb.conn(),
+                &first_parent_sn.winning_block_txid,
+                &first_parent_sn.sortition_id,
+            )
+            .unwrap()
+            .unwrap();
+            let parent_sortition =
+                SortitionDB::get_block_snapshot(sortdb.conn(), &parent_sortition_id)
+                    .unwrap()
+                    .unwrap();
+
+            debug!(
+                "First parent Nakamoto block sortition: {:?}",
+                &parent_sortition
+            );
+            let parent_sortition_opt = Some(parent_sortition);
 
             let last_tenure_id = StacksBlockId::new(
                 &first_parent.header.consensus_hash,
@@ -787,6 +818,7 @@ impl<'a> TestPeer<'a> {
             let (parent_opt, parent_sortition_opt) = if let Some(parent_block) =
                 stacks_node.get_last_anchored_block(miner)
             {
+                debug!("Parent will be a Stacks 2.x block");
                 let ic = sortdb.index_conn();
                 let sort_opt = SortitionDB::get_block_snapshot_for_winning_stacks_block(
                     &ic,

From 6aa97e0c2731f19ea142be9638bf6387a344c31f Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Wed, 31 Jan 2024 00:11:10 -0500
Subject: [PATCH 0535/1166] fix: log how many blocks a tenure-change confirms

---
 stackslib/src/chainstate/stacks/db/transactions.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/stackslib/src/chainstate/stacks/db/transactions.rs b/stackslib/src/chainstate/stacks/db/transactions.rs
index 1d24ded61b..d722c9ba49 100644
--- a/stackslib/src/chainstate/stacks/db/transactions.rs
+++ b/stackslib/src/chainstate/stacks/db/transactions.rs
@@ -1364,7 +1364,10 @@ impl StacksChainState {
                     TenureChangeCause::Extended => {
                         // the stackers granted a tenure extension.
                         // reset the runtime cost
-                        debug!("TenureChange extends block tenure");
+                        debug!(
+                            "TenureChange extends block tenure (confirms {} blocks)",
+                            &payload.previous_tenure_blocks
+                        );
                     }
                 }
 

From 8f4a3b0da547e28ec9f170d29c92bcb08bcf2906 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Wed, 31 Jan 2024 00:11:26 -0500
Subject: [PATCH 0536/1166] feat: log the variant of a coinbase or
 tenure-change

---
 stackslib/src/chainstate/stacks/mod.rs | 21 ++++++++++++++++++---
 1 file changed, 18 insertions(+), 3 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/mod.rs b/stackslib/src/chainstate/stacks/mod.rs
index 81523ecfec..62248a6873 100644
--- a/stackslib/src/chainstate/stacks/mod.rs
+++ b/stackslib/src/chainstate/stacks/mod.rs
@@ -768,10 +768,25 @@ impl TransactionPayload {
         match self {
             TransactionPayload::TokenTransfer(..) => "TokenTransfer",
             TransactionPayload::ContractCall(..) => "ContractCall",
-            TransactionPayload::SmartContract(..) => "SmartContract",
+            TransactionPayload::SmartContract(_, version_opt) => {
+                if version_opt.is_some() {
+                    "SmartContract(Versioned)"
+                } else {
+                    "SmartContract"
+                }
+            }
             TransactionPayload::PoisonMicroblock(..) => "PoisonMicroblock",
-            TransactionPayload::Coinbase(..) => "Coinbase",
-            TransactionPayload::TenureChange(..) => "TenureChange",
+            TransactionPayload::Coinbase(_, _, vrf_opt) => {
+                if vrf_opt.is_some() {
+                    "Coinbase(Nakamoto)"
+                } else {
+                    "Coinbase"
+                }
+            }
+            TransactionPayload::TenureChange(payload) => match payload.cause {
+                TenureChangeCause::BlockFound => "TenureChange(BlockFound)",
+                TenureChangeCause::Extended => "TenureChange(Extension)",
+            },
         }
     }
 }

From 0412525fc5eefb0dcc67042153aa388fc6efdca2 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Wed, 31 Jan 2024 00:11:45 -0500
Subject: [PATCH 0537/1166] feat: implement a declarative test framework for
 generating nakamoto chain histories

---
 stackslib/src/net/tests/mod.rs | 728 +++++++++++++++++++++++++++++++++
 1 file changed, 728 insertions(+)

diff --git a/stackslib/src/net/tests/mod.rs b/stackslib/src/net/tests/mod.rs
index 9f9d6d07ab..5fd3d65e9a 100644
--- a/stackslib/src/net/tests/mod.rs
+++ b/stackslib/src/net/tests/mod.rs
@@ -17,3 +17,731 @@
 pub mod httpcore;
 pub mod inv;
 pub mod neighbors;
+
+use clarity::vm::clarity::ClarityConnection;
+use clarity::vm::types::PrincipalData;
+use rand::prelude::SliceRandom;
+use rand::{thread_rng, Rng, RngCore};
+use stacks_common::address::{AddressHashMode, C32_ADDRESS_VERSION_TESTNET_SINGLESIG};
+use stacks_common::consts::{FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH};
+use stacks_common::types::chainstate::{
+    StacksAddress, StacksBlockId, StacksPrivateKey, StacksPublicKey,
+};
+use stacks_common::types::Address;
+use stacks_common::util::vrf::VRFProof;
+use wsts::curve::point::Point;
+
+use crate::burnchains::PoxConstants;
+use crate::chainstate::burn::db::sortdb::{SortitionDB, SortitionHandle};
+use crate::chainstate::burn::operations::BlockstackOperationType;
+use crate::chainstate::coordinator::tests::p2pkh_from;
+use crate::chainstate::nakamoto::coordinator::tests::boot_nakamoto;
+use crate::chainstate::nakamoto::tests::get_account;
+use crate::chainstate::nakamoto::tests::node::{TestSigners, TestStacker};
+use crate::chainstate::nakamoto::{NakamotoBlock, NakamotoChainState};
+use crate::chainstate::stacks::address::PoxAddress;
+use crate::chainstate::stacks::boot::test::{
+    key_to_stacks_addr, make_pox_4_aggregate_key, make_pox_4_lockup,
+};
+use crate::chainstate::stacks::boot::MINERS_NAME;
+use crate::chainstate::stacks::db::{MinerPaymentTxFees, StacksAccount, StacksChainState};
+use crate::chainstate::stacks::events::TransactionOrigin;
+use crate::chainstate::stacks::{
+    CoinbasePayload, StacksTransaction, StacksTransactionSigner, TenureChangeCause,
+    TenureChangePayload, TokenTransferMemo, TransactionAnchorMode, TransactionAuth,
+    TransactionPayload, TransactionVersion,
+};
+use crate::clarity::vm::types::StacksAddressExtensions;
+use crate::core::{StacksEpoch, StacksEpochExtension};
+use crate::net::relay::Relayer;
+use crate::net::stackerdb::StackerDBConfig;
+use crate::net::test::{TestEventObserver, TestPeer, TestPeerConfig};
+use crate::util_lib::boot::boot_code_id;
+
+/// One step of a simulated Nakamoto node's bootup procedure.
+#[derive(Debug, PartialEq, Clone)]
+pub enum NakamotoBootStep {
+    Block(Vec<StacksTransaction>),
+    TenureExtend(Vec<StacksTransaction>),
+}
+
+#[derive(Debug, PartialEq, Clone)]
+pub enum NakamotoBootTenure {
+    Sortition(Vec<NakamotoBootStep>),
+    NoSortition(Vec<NakamotoBootStep>),
+}
+
+pub struct NakamotoBootPlan {
+    pub test_name: String,
+    pub pox_constants: PoxConstants,
+    pub private_key: StacksPrivateKey,
+    pub initial_balances: Vec<(PrincipalData, u64)>,
+    pub test_stackers: Option<Vec<TestStacker>>,
+    pub test_signers: Option<TestSigners>,
+    pub observer: Option<TestEventObserver>,
+}
+
+impl NakamotoBootPlan {
+    pub fn new(test_name: &str) -> Self {
+        Self {
+            test_name: test_name.to_string(),
+            pox_constants: TestPeerConfig::default().burnchain.pox_constants,
+            private_key: StacksPrivateKey::from_seed(&[2]),
+            initial_balances: vec![],
+            test_stackers: None,
+            test_signers: None,
+            observer: Some(TestEventObserver::new()),
+        }
+    }
+
+    pub fn with_private_key(mut self, privk: StacksPrivateKey) -> Self {
+        self.private_key = privk;
+        self
+    }
+
+    pub fn with_pox_constants(mut self, cycle_length: u32, prepare_length: u32) -> Self {
+        let new_consts = PoxConstants::new(
+            cycle_length,
+            prepare_length,
+            (80 * prepare_length / 100).max(1),
+            0,
+            0,
+            u64::MAX,
+            u64::MAX,
+            // v1 unlocks at start of second reward cycle
+            cycle_length + 2,
+            // v2 unlocks at start of third cycle
+            2 * cycle_length + 1,
+            // v3 unlocks at start of fourth cycle
+            3 * cycle_length + 1,
+            // pox-3 activates at start of third cycle, just before v2 unlock
+            2 * cycle_length + 1,
+            // pox-4 activates at start of fourth reward cycle, just before v3 unlock
+            3 * cycle_length + 1,
+        );
+        self.pox_constants = new_consts;
+        self
+    }
+
+    pub fn with_initial_balances(mut self, initial_balances: Vec<(PrincipalData, u64)>) -> Self {
+        self.initial_balances = initial_balances;
+        self
+    }
+
+    pub fn with_test_stackers(mut self, test_stackers: Vec<TestStacker>) -> Self {
+        self.test_stackers = Some(test_stackers);
+        self
+    }
+
+    pub fn with_test_signers(mut self, test_signers: TestSigners) -> Self {
+        self.test_signers = Some(test_signers);
+        self
+    }
+
+    /// This is the first tenure in which nakamoto blocks will be built.
+    /// However, it is also the last sortition for an epoch 2.x block.
+    pub fn nakamoto_start_burn_height(pox_consts: &PoxConstants) -> u64 {
+        (pox_consts.pox_4_activation_height + pox_consts.reward_cycle_length).into()
+    }
+
+    /// This is the first tenure which is a nakamoto sortition.
+    pub fn nakamoto_first_tenure_height(pox_consts: &PoxConstants) -> u64 {
+        Self::nakamoto_start_burn_height(pox_consts) + 1
+    }
+
+    /// Check the boot plan transactions against the generated blocks
+    fn check_blocks_against_boot_plan(
+        blocks: &[NakamotoBlock],
+        boot_steps: &[NakamotoBootStep],
+        num_expected_transactions: usize,
+    ) {
+        assert_eq!(blocks.len(), boot_steps.len());
+        let mut num_transactions = 0;
+        for (block, boot_step) in blocks.iter().zip(boot_steps.iter()) {
+            num_transactions += block.txs.len();
+            let boot_step_txs = match boot_step {
+                NakamotoBootStep::TenureExtend(txs) => txs.clone(),
+                NakamotoBootStep::Block(txs) => txs.clone(),
+            };
+            let mut planned_txs = vec![];
+            for tx in block.txs.iter() {
+                match tx.payload {
+                    TransactionPayload::Coinbase(..) | TransactionPayload::TenureChange(..) => {
+                        continue;
+                    }
+                    _ => {
+                        planned_txs.push(tx.clone());
+                    }
+                }
+            }
+            assert_eq!(planned_txs.len(), boot_step_txs.len());
+            for (block_tx, boot_step_tx) in planned_txs.iter().zip(boot_step_txs.iter()) {
+                assert_eq!(block_tx.txid(), boot_step_tx.txid());
+            }
+        }
+        assert_eq!(
+            num_expected_transactions, num_transactions,
+            "Failed to mine at least one transaction in this block"
+        );
+    }
+
+    /// Make a peer and transition it into the Nakamoto epoch.
+    /// The node needs to be stacking; otherwise, Nakamoto won't activate.
+    fn boot_nakamoto<'a>(
+        mut self,
+        aggregate_public_key: Point,
+        observer: Option<&'a TestEventObserver>,
+    ) -> TestPeer<'a> {
+        let mut peer_config = TestPeerConfig::new(&self.test_name, 0, 0);
+        peer_config.private_key = self.private_key.clone();
+        let addr = StacksAddress::from_public_keys(
+            C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
+            &AddressHashMode::SerializeP2PKH,
+            1,
+            &vec![StacksPublicKey::from_private(&self.private_key)],
+        )
+        .unwrap();
+
+        // reward cycles are 5 blocks long
+        // first 25 blocks are boot-up
+        // reward cycle 6 instantiates pox-3
+        // we stack in reward cycle 7 so pox-3 is evaluated to find reward set participation
+        peer_config.aggregate_public_key = Some(aggregate_public_key.clone());
+        peer_config
+            .stacker_dbs
+            .push(boot_code_id(MINERS_NAME, false));
+        peer_config.epochs = Some(StacksEpoch::unit_test_3_0_only(
+            (self.pox_constants.pox_4_activation_height
+                + self.pox_constants.reward_cycle_length
+                + 1)
+            .into(),
+        ));
+        peer_config.initial_balances =
+            vec![(addr.to_account_principal(), 1_000_000_000_000_000_000)];
+        peer_config
+            .initial_balances
+            .append(&mut self.initial_balances.clone());
+
+        let test_stackers: Vec<TestStacker> = if let Some(stackers) = self.test_stackers.take() {
+            stackers.into_iter().collect()
+        } else {
+            // Create a list of test Stackers and their signer keys
+            let num_keys = self
+                .test_signers
+                .as_ref()
+                .unwrap_or(&TestSigners::default())
+                .num_keys;
+            (0..num_keys)
+                .map(|index| {
+                    let stacker_private_key = StacksPrivateKey::from_seed(&index.to_be_bytes());
+                    let signer_private_key =
+                        StacksPrivateKey::from_seed(&(index + 1000).to_be_bytes());
+                    TestStacker {
+                        stacker_private_key,
+                        signer_private_key,
+                        amount: 1_000_000_000_000_000_000,
+                    }
+                })
+                .collect()
+        };
+
+        // Create some balances for test Stackers
+        let mut stacker_balances = test_stackers
+            .iter()
+            .map(|test_stacker| {
+                (
+                    PrincipalData::from(key_to_stacks_addr(&test_stacker.stacker_private_key)),
+                    u64::try_from(test_stacker.amount).expect("Stacking amount too large"),
+                )
+            })
+            .collect();
+
+        peer_config.initial_balances.append(&mut stacker_balances);
+        peer_config.test_stackers = Some(test_stackers.clone());
+        peer_config.burnchain.pox_constants = self.pox_constants.clone();
+        let mut peer = TestPeer::new_with_observer(peer_config, observer);
+        self.advance_to_nakamoto(&mut peer);
+        peer
+    }
+
+    /// Bring a TestPeer into the Nakamoto Epoch
+    fn advance_to_nakamoto(&self, peer: &mut TestPeer) {
+        let mut peer_nonce = 0;
+        let addr = StacksAddress::from_public_keys(
+            C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
+            &AddressHashMode::SerializeP2PKH,
+            1,
+            &vec![StacksPublicKey::from_private(&self.private_key)],
+        )
+        .unwrap();
+
+        let tip = {
+            let sort_db = peer.sortdb.as_mut().unwrap();
+            let tip = SortitionDB::get_canonical_burn_chain_tip(sort_db.conn()).unwrap();
+            tip
+        };
+
+        debug!("\n\n======================");
+        debug!("PoxConstants = {:#?}", &peer.config.burnchain.pox_constants);
+        debug!("tip = {}", tip.block_height);
+        debug!("========================\n\n");
+
+        // advance to just past pox-3 unlock
+        let mut sortition_height = tip.block_height;
+        while sortition_height
+            <= peer
+                .config
+                .burnchain
+                .pox_constants
+                .pox_4_activation_height
+                .into()
+        {
+            peer.tenure_with_txs(&vec![], &mut peer_nonce);
+            let tip = {
+                let sort_db = peer.sortdb.as_mut().unwrap();
+                let tip = SortitionDB::get_canonical_burn_chain_tip(sort_db.conn()).unwrap();
+                tip
+            };
+            sortition_height = tip.block_height;
+        }
+
+        debug!("\n\n======================");
+        debug!("Make PoX-4 lockups");
+        debug!("========================\n\n");
+
+        // Make all the test Stackers stack
+        let stack_txs: Vec<_> = peer
+            .config
+            .test_stackers
+            .clone()
+            .unwrap_or(vec![])
+            .iter()
+            .map(|test_stacker| {
+                make_pox_4_lockup(
+                    &test_stacker.stacker_private_key,
+                    0,
+                    test_stacker.amount,
+                    PoxAddress::from_legacy(AddressHashMode::SerializeP2PKH, addr.bytes.clone()),
+                    12,
+                    StacksPublicKey::from_private(&test_stacker.signer_private_key),
+                    34,
+                )
+            })
+            .collect();
+
+        peer.tenure_with_txs(&stack_txs, &mut peer_nonce);
+
+        debug!("\n\n======================");
+        debug!("Advance to Epoch 3.0");
+        debug!("========================\n\n");
+
+        // advance to the start of epoch 3.0
+        while sortition_height
+            < Self::nakamoto_start_burn_height(&peer.config.burnchain.pox_constants)
+        {
+            peer.tenure_with_txs(&vec![], &mut peer_nonce);
+            let tip = {
+                let sort_db = peer.sortdb.as_mut().unwrap();
+                let tip = SortitionDB::get_canonical_burn_chain_tip(sort_db.conn()).unwrap();
+                tip
+            };
+            sortition_height = tip.block_height;
+        }
+
+        debug!("\n\n======================");
+        debug!("Welcome to Nakamoto!");
+        debug!("========================\n\n");
+    }
+
+    pub fn boot_into_nakamoto_peer<'a>(
+        self,
+        boot_plan: Vec<NakamotoBootTenure>,
+        observer: Option<&'a TestEventObserver>,
+    ) -> TestPeer<'a> {
+        let mut test_signers = self.test_signers.clone().unwrap_or(TestSigners::default());
+        let mut peer = self.boot_nakamoto(test_signers.aggregate_public_key.clone(), observer);
+
+        let mut all_blocks = vec![];
+        let mut rc_burn_ops = vec![];
+        let mut consensus_hashes = vec![];
+        let mut last_tenure_change: Option<TenureChangePayload> = None;
+        let mut blocks_since_last_tenure = 0;
+        let stx_miner_key = peer.miner.nakamoto_miner_key();
+
+        debug!("\n\nProcess plan with {} steps", boot_plan.len());
+
+        for (x, plan_tenure) in boot_plan.into_iter().enumerate() {
+            debug!("\n\nProcess plan step {} {:?}", &x, &plan_tenure);
+
+            match plan_tenure {
+                NakamotoBootTenure::NoSortition(boot_steps) => {
+                    assert!(boot_steps.len() > 0);
+                    // just extend the last sortition
+                    let (burn_ops, tenure_change_extend, miner_key) =
+                        peer.begin_nakamoto_tenure(TenureChangeCause::Extended);
+                    let (_, _, next_consensus_hash) = peer.next_burnchain_block(burn_ops.clone());
+
+                    rc_burn_ops.push(burn_ops);
+
+                    let tenure_change = last_tenure_change.clone().unwrap();
+                    let blocks: Vec<NakamotoBlock> = all_blocks.last().cloned().unwrap();
+
+                    // extending last tenure
+                    let tenure_change_extend = tenure_change.extend(
+                        next_consensus_hash,
+                        blocks.last().cloned().unwrap().header.block_id(),
+                        blocks_since_last_tenure,
+                    );
+                    let tenure_change_tx = peer
+                        .miner
+                        .make_nakamoto_tenure_change(tenure_change_extend.clone());
+
+                    debug!("\n\nExtend across empty sortition {}: blocks.len() = {}, blocks_since_last_tenure = {}\n\n", &next_consensus_hash, blocks.len(), blocks_since_last_tenure);
+
+                    let mut i = 0;
+                    let mut num_expected_transactions = 1; // expect tenure-extension
+
+                    let blocks_and_sizes = peer.make_nakamoto_tenure_extension(
+                        tenure_change_tx,
+                        &mut test_signers,
+                        |miner, chainstate, sortdb, blocks_so_far| {
+                            if i >= boot_steps.len() {
+                                return vec![];
+                            }
+                            let next_step = &boot_steps[i];
+                            i += 1;
+
+                            let mut txs = vec![];
+                            let last_block_opt = blocks_so_far
+                                .last()
+                                .as_ref()
+                                .map(|(block, _size, _cost)| block.header.block_id());
+
+                            match next_step {
+                                NakamotoBootStep::TenureExtend(transactions) => {
+                                    assert!(transactions.len() > 0);
+                                    if let Some(last_block) = last_block_opt {
+                                        let tenure_extension = tenure_change.extend(
+                                            next_consensus_hash.clone(),
+                                            last_block.clone(),
+                                            blocks_since_last_tenure
+                                        );
+                                        let tenure_extension_tx =
+                                            miner.make_nakamoto_tenure_change(tenure_extension.clone());
+
+                                        txs.push(tenure_extension_tx);
+                                        txs.extend_from_slice(&transactions[..]);
+                                        num_expected_transactions += 1 + transactions.len();
+                                    }
+                                    debug!("\n\nExtend current tenure in empty tenure {} (blocks so far: {}, blocks_since_last_tenure = {}, steps so far: {})\n\n", &next_consensus_hash, blocks_so_far.len(), blocks_since_last_tenure, i);
+                                }
+                                NakamotoBootStep::Block(transactions) => {
+                                    assert!(transactions.len() > 0);
+                                    debug!("\n\nMake block {} with {} transactions in empty tenure {}\n\n", blocks_so_far.len(), transactions.len(), &next_consensus_hash);
+                                    txs.extend_from_slice(&transactions[..]);
+                                    num_expected_transactions += transactions.len();
+                                }
+                            }
+
+                            blocks_since_last_tenure += 1;
+                            txs
+                        });
+
+                    consensus_hashes.push(next_consensus_hash);
+
+                    let blocks: Vec<NakamotoBlock> = blocks_and_sizes
+                        .into_iter()
+                        .map(|(block, _, _)| block)
+                        .collect();
+
+                    Self::check_blocks_against_boot_plan(
+                        &blocks,
+                        &boot_steps,
+                        num_expected_transactions,
+                    );
+                    all_blocks.push(blocks);
+                }
+                NakamotoBootTenure::Sortition(boot_steps) => {
+                    assert!(boot_steps.len() > 0);
+                    let (burn_ops, mut tenure_change, miner_key) =
+                        peer.begin_nakamoto_tenure(TenureChangeCause::BlockFound);
+                    let (_, _, consensus_hash) = peer.next_burnchain_block(burn_ops.clone());
+                    let vrf_proof = peer.make_nakamoto_vrf_proof(miner_key);
+
+                    tenure_change.tenure_consensus_hash = consensus_hash.clone();
+                    tenure_change.burn_view_consensus_hash = consensus_hash.clone();
+
+                    last_tenure_change = Some(tenure_change.clone());
+
+                    let tenure_change_tx = peer
+                        .miner
+                        .make_nakamoto_tenure_change(tenure_change.clone());
+
+                    let coinbase_tx = peer.miner.make_nakamoto_coinbase(None, vrf_proof);
+
+                    debug!("\n\nNew tenure: {}\n\n", &consensus_hash);
+
+                    let mut i = 0;
+                    let mut num_expected_transactions = 2; // tenure-change and coinbase
+                    blocks_since_last_tenure = 0;
+
+                    let blocks_and_sizes = peer.make_nakamoto_tenure(
+                        tenure_change_tx,
+                        coinbase_tx,
+                        &mut test_signers,
+                        |miner, chainstate, sortdb, blocks_so_far| {
+                            if i >= boot_steps.len() {
+                                return vec![];
+                            }
+                            let next_step = &boot_steps[i];
+                            i += 1;
+
+                            let mut txs = vec![];
+                            let last_block_opt = blocks_so_far
+                                .last()
+                                .as_ref()
+                                .map(|(block, _size, _cost)| block.header.block_id());
+
+                            match next_step {
+                                NakamotoBootStep::TenureExtend(transactions) => {
+                                    assert!(transactions.len() > 0);
+                                    if let Some(last_block) = last_block_opt {
+                                        let tenure_extension = tenure_change.extend(
+                                            consensus_hash.clone(),
+                                            last_block.clone(),
+                                            blocks_since_last_tenure // blocks_so_far.len() as u32,
+                                        );
+                                        let tenure_extension_tx =
+                                            miner.make_nakamoto_tenure_change(tenure_extension.clone());
+
+                                        txs.push(tenure_extension_tx);
+                                        txs.extend_from_slice(&transactions[..]);
+                                        num_expected_transactions += 1 + transactions.len();
+                                    }
+                                    debug!("\n\nExtend current tenure {} (blocks so far: {}, steps so far: {})\n\n", &consensus_hash, blocks_so_far.len(), i);
+                                }
+                                NakamotoBootStep::Block(transactions) => {
+                                    assert!(transactions.len() > 0);
+                                    debug!("\n\nMake block {} with {} transactions in tenure {}\n\n", blocks_so_far.len(), transactions.len(), &consensus_hash);
+                                    txs.extend_from_slice(&transactions[..]);
+                                    num_expected_transactions += transactions.len();
+                                }
+                            }
+
+                            blocks_since_last_tenure += 1;
+                            txs
+                        });
+
+                    consensus_hashes.push(consensus_hash);
+                    let blocks: Vec<NakamotoBlock> = blocks_and_sizes
+                        .into_iter()
+                        .map(|(block, _, _)| block)
+                        .collect();
+
+                    Self::check_blocks_against_boot_plan(
+                        &blocks,
+                        &boot_steps,
+                        num_expected_transactions,
+                    );
+
+                    all_blocks.push(blocks);
+                }
+            }
+        }
+        // check that our tenure-extends have been getting applied
+        let (highest_tenure, sort_tip) = {
+            let chainstate = &mut peer.stacks_node.as_mut().unwrap().chainstate;
+            let sort_db = peer.sortdb.as_mut().unwrap();
+            let tip = SortitionDB::get_canonical_burn_chain_tip(sort_db.conn()).unwrap();
+            let tenure =
+                NakamotoChainState::get_highest_nakamoto_tenure(chainstate.db(), sort_db.conn())
+                    .unwrap()
+                    .unwrap();
+            (tenure, tip)
+        };
+
+        let last_block = all_blocks
+            .last()
+            .as_ref()
+            .cloned()
+            .unwrap()
+            .last()
+            .cloned()
+            .unwrap();
+        assert_eq!(
+            highest_tenure.tenure_id_consensus_hash,
+            last_block.header.consensus_hash
+        );
+        assert_eq!(
+            highest_tenure.burn_view_consensus_hash,
+            sort_tip.consensus_hash
+        );
+
+        // verify all transactions succeeded.
+        // already checked that `all_blocks` matches the boot plan, so just check that each
+        // transaction in `all_blocks` ran to completion
+        if let Some(observer) = observer {
+            let observed_blocks = observer.get_blocks();
+            let mut block_idx = (peer.config.burnchain.pox_constants.pox_4_activation_height
+                + peer.config.burnchain.pox_constants.reward_cycle_length
+                - 25) as usize;
+            for tenure in all_blocks {
+                for block in tenure {
+                    let observed_block = &observed_blocks[block_idx];
+                    block_idx += 1;
+
+                    assert_eq!(
+                        observed_block.metadata.anchored_header.block_hash(),
+                        block.header.block_hash()
+                    );
+
+                    // each transaction was mined in the same order as described in the boot plan,
+                    // and it succeeded.
+                    let mut burn_receipts = vec![];
+                    let mut stacks_receipts = vec![];
+                    for receipt in observed_block.receipts.iter() {
+                        match &receipt.transaction {
+                            TransactionOrigin::Stacks(..) => {
+                                stacks_receipts.push(receipt);
+                            }
+                            TransactionOrigin::Burn(..) => burn_receipts.push(receipt),
+                        }
+                    }
+
+                    assert_eq!(stacks_receipts.len(), block.txs.len());
+                    for (receipt, tx) in stacks_receipts.iter().zip(block.txs.iter()) {
+                        // transactions processed in the same order
+                        assert_eq!(receipt.transaction.txid(), tx.txid());
+                        // no CheckErrors
+                        assert!(receipt.vm_error.is_none());
+                        // transaction was not aborted post-hoc
+                        assert!(!receipt.post_condition_aborted);
+                    }
+                }
+            }
+        }
+        peer
+    }
+}
+
+#[test]
+fn test_boot_nakamoto_peer() {
+    let private_key = StacksPrivateKey::from_seed(&[2]);
+    let addr = StacksAddress::from_public_keys(
+        C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
+        &AddressHashMode::SerializeP2PKH,
+        1,
+        &vec![StacksPublicKey::from_private(&private_key)],
+    )
+    .unwrap();
+    let recipient_addr =
+        StacksAddress::from_string("ST2YM3J4KQK09V670TD6ZZ1XYNYCNGCWCVTASN5VM").unwrap();
+
+    let mut sender_nonce = 0;
+
+    let mut next_stx_transfer = || {
+        let mut stx_transfer = StacksTransaction::new(
+            TransactionVersion::Testnet,
+            TransactionAuth::from_p2pkh(&private_key).unwrap(),
+            TransactionPayload::TokenTransfer(
+                recipient_addr.clone().to_account_principal(),
+                1,
+                TokenTransferMemo([0x00; 34]),
+            ),
+        );
+        stx_transfer.chain_id = 0x80000000;
+        stx_transfer.anchor_mode = TransactionAnchorMode::OnChainOnly;
+        stx_transfer.set_tx_fee(1);
+        stx_transfer.auth.set_origin_nonce(sender_nonce);
+        sender_nonce += 1;
+
+        let mut tx_signer = StacksTransactionSigner::new(&stx_transfer);
+        tx_signer.sign_origin(&private_key).unwrap();
+        let stx_transfer_signed = tx_signer.get_tx().unwrap();
+
+        stx_transfer_signed
+    };
+
+    let boot_tenures = vec![
+        // reward cycle 1
+        NakamotoBootTenure::Sortition(vec![
+            NakamotoBootStep::Block(vec![next_stx_transfer()]),
+            NakamotoBootStep::Block(vec![next_stx_transfer()]),
+            NakamotoBootStep::Block(vec![next_stx_transfer()]),
+            NakamotoBootStep::Block(vec![next_stx_transfer()]),
+            NakamotoBootStep::Block(vec![next_stx_transfer()]),
+            NakamotoBootStep::Block(vec![next_stx_transfer()]),
+            NakamotoBootStep::Block(vec![next_stx_transfer()]),
+            NakamotoBootStep::Block(vec![next_stx_transfer()]),
+            NakamotoBootStep::Block(vec![next_stx_transfer()]),
+            NakamotoBootStep::Block(vec![next_stx_transfer()]),
+        ]),
+        NakamotoBootTenure::Sortition(vec![NakamotoBootStep::Block(vec![next_stx_transfer()])]),
+        NakamotoBootTenure::Sortition(vec![NakamotoBootStep::Block(vec![next_stx_transfer()])]),
+        NakamotoBootTenure::Sortition(vec![NakamotoBootStep::Block(vec![next_stx_transfer()])]),
+        NakamotoBootTenure::Sortition(vec![
+            NakamotoBootStep::Block(vec![next_stx_transfer()]),
+            NakamotoBootStep::TenureExtend(vec![next_stx_transfer()]),
+            NakamotoBootStep::Block(vec![next_stx_transfer()]),
+            NakamotoBootStep::TenureExtend(vec![next_stx_transfer()]),
+            NakamotoBootStep::Block(vec![next_stx_transfer()]),
+            NakamotoBootStep::TenureExtend(vec![next_stx_transfer()]),
+            NakamotoBootStep::Block(vec![next_stx_transfer()]),
+            NakamotoBootStep::TenureExtend(vec![next_stx_transfer()]),
+        ]),
+        NakamotoBootTenure::NoSortition(vec![NakamotoBootStep::Block(vec![next_stx_transfer()])]),
+        // prepare phase for 2
+        NakamotoBootTenure::NoSortition(vec![NakamotoBootStep::Block(vec![next_stx_transfer()])]),
+        NakamotoBootTenure::Sortition(vec![NakamotoBootStep::Block(vec![next_stx_transfer()])]),
+        NakamotoBootTenure::Sortition(vec![NakamotoBootStep::Block(vec![next_stx_transfer()])]),
+        // reward cycle 2
+        NakamotoBootTenure::Sortition(vec![NakamotoBootStep::Block(vec![next_stx_transfer()])]),
+        NakamotoBootTenure::NoSortition(vec![NakamotoBootStep::Block(vec![next_stx_transfer()])]),
+        NakamotoBootTenure::NoSortition(vec![NakamotoBootStep::Block(vec![next_stx_transfer()])]),
+        NakamotoBootTenure::NoSortition(vec![NakamotoBootStep::Block(vec![next_stx_transfer()])]),
+        NakamotoBootTenure::NoSortition(vec![NakamotoBootStep::Block(vec![next_stx_transfer()])]),
+        NakamotoBootTenure::NoSortition(vec![NakamotoBootStep::Block(vec![next_stx_transfer()])]),
+        NakamotoBootTenure::NoSortition(vec![NakamotoBootStep::Block(vec![next_stx_transfer()])]),
+        // prepare phase for 3
+        NakamotoBootTenure::Sortition(vec![
+            NakamotoBootStep::Block(vec![next_stx_transfer()]),
+            NakamotoBootStep::TenureExtend(vec![next_stx_transfer()]),
+            NakamotoBootStep::Block(vec![next_stx_transfer()]),
+            NakamotoBootStep::TenureExtend(vec![next_stx_transfer()]),
+            NakamotoBootStep::Block(vec![next_stx_transfer()]),
+            NakamotoBootStep::TenureExtend(vec![next_stx_transfer()]),
+            NakamotoBootStep::Block(vec![next_stx_transfer()]),
+            NakamotoBootStep::TenureExtend(vec![next_stx_transfer()]),
+        ]),
+        NakamotoBootTenure::Sortition(vec![
+            NakamotoBootStep::Block(vec![next_stx_transfer()]),
+            NakamotoBootStep::TenureExtend(vec![next_stx_transfer()]),
+            NakamotoBootStep::Block(vec![next_stx_transfer()]),
+            NakamotoBootStep::TenureExtend(vec![next_stx_transfer()]),
+            NakamotoBootStep::Block(vec![next_stx_transfer()]),
+            NakamotoBootStep::TenureExtend(vec![next_stx_transfer()]),
+            NakamotoBootStep::Block(vec![next_stx_transfer()]),
+            NakamotoBootStep::TenureExtend(vec![next_stx_transfer()]),
+        ]),
+        NakamotoBootTenure::Sortition(vec![
+            NakamotoBootStep::Block(vec![next_stx_transfer()]),
+            NakamotoBootStep::TenureExtend(vec![next_stx_transfer()]),
+            NakamotoBootStep::Block(vec![next_stx_transfer()]),
+            NakamotoBootStep::TenureExtend(vec![next_stx_transfer()]),
+            NakamotoBootStep::Block(vec![next_stx_transfer()]),
+            NakamotoBootStep::TenureExtend(vec![next_stx_transfer()]),
+            NakamotoBootStep::Block(vec![next_stx_transfer()]),
+            NakamotoBootStep::TenureExtend(vec![next_stx_transfer()]),
+        ]),
+        // reward cycle 3
+        NakamotoBootTenure::Sortition(vec![NakamotoBootStep::Block(vec![next_stx_transfer()])]),
+    ];
+
+    let plan = NakamotoBootPlan::new(&function_name!())
+        .with_private_key(private_key)
+        .with_pox_constants(10, 3)
+        .with_initial_balances(vec![(addr.into(), 1_000_000)]);
+
+    let observer = TestEventObserver::new();
+    let peer = plan.boot_into_nakamoto_peer(boot_tenures, Some(&observer));
+}

From 300aeda09fd8ad5536a6cd6423ed28f112db4923 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Wed, 31 Jan 2024 00:12:10 -0500
Subject: [PATCH 0538/1166] chore: expand test coverage for inventory
 generation using the new declarative nakamoto chain history test framework

---
 stackslib/src/net/tests/inv/nakamoto.rs | 369 ++++++++++++++++++++----
 1 file changed, 316 insertions(+), 53 deletions(-)

diff --git a/stackslib/src/net/tests/inv/nakamoto.rs b/stackslib/src/net/tests/inv/nakamoto.rs
index f962123d1c..e622fd728d 100644
--- a/stackslib/src/net/tests/inv/nakamoto.rs
+++ b/stackslib/src/net/tests/inv/nakamoto.rs
@@ -20,8 +20,9 @@ use std::sync::mpsc::sync_channel;
 use std::thread;
 use std::thread::JoinHandle;
 
+use stacks_common::address::{AddressHashMode, C32_ADDRESS_VERSION_TESTNET_SINGLESIG};
 use stacks_common::codec::{read_next, StacksMessageCodec};
-use stacks_common::types::chainstate::StacksPrivateKey;
+use stacks_common::types::chainstate::{StacksAddress, StacksPrivateKey, StacksPublicKey};
 use stacks_common::types::StacksEpoch;
 
 use crate::chainstate::burn::db::sortdb::SortitionDB;
@@ -33,20 +34,27 @@ use crate::chainstate::nakamoto::coordinator::tests::{
 };
 use crate::chainstate::nakamoto::NakamotoChainState;
 use crate::chainstate::stacks::db::StacksChainState;
+use crate::chainstate::stacks::{
+    StacksTransaction, StacksTransactionSigner, TokenTransferMemo, TransactionAnchorMode,
+    TransactionAuth, TransactionPayload, TransactionVersion,
+};
+use crate::clarity::vm::types::StacksAddressExtensions;
 use crate::core::StacksEpochExtension;
 use crate::net::inv::nakamoto::InvGenerator;
-use crate::net::test::TestPeer;
+use crate::net::test::{TestEventObserver, TestPeer};
+use crate::net::tests::{NakamotoBootPlan, NakamotoBootStep, NakamotoBootTenure};
 use crate::net::{
     Error as NetError, GetNakamotoInvData, HandshakeData, NakamotoInvData, StacksMessage,
     StacksMessageType,
 };
+use crate::stacks_common::types::Address;
 use crate::util_lib::db::Error as DBError;
 
 /// Handshake with and get the reward cycle inventories for a range of reward cycles
-fn peer_get_nakamoto_invs(
-    mut peer: TestPeer<'static>,
+fn peer_get_nakamoto_invs<'a>(
+    mut peer: TestPeer<'a>,
     reward_cycles: &[u64],
-) -> (TestPeer<'static>, Vec<StacksMessageType>) {
+) -> (TestPeer<'a>, Vec<StacksMessageType>) {
     let privk = StacksPrivateKey::new();
     let mut convo = peer.make_client_convo();
     let client_peer = peer.make_client_local_peer(privk.clone());
@@ -80,63 +88,65 @@ fn peer_get_nakamoto_invs(
 
     let (shutdown_send, shutdown_recv) = sync_channel(1);
     let join_handle = thread::spawn(move || {
-        loop {
-            peer.step_with_ibd(false).unwrap();
-            if let Ok(..) = shutdown_recv.try_recv() {
-                break;
+        let mut tcp_socket = TcpStream::connect(peer_addr).unwrap();
+
+        // first, handshake
+        let handshake_data =
+            StacksMessageType::Handshake(HandshakeData::from_local_peer(&client_peer));
+        let signed_handshake_data = convo
+            .sign_message(&chain_view, &privk, handshake_data)
+            .unwrap();
+        signed_handshake_data
+            .consensus_serialize(&mut tcp_socket)
+            .unwrap();
+
+        // read back handshake-accept
+        let msg: StacksMessage = read_next(&mut tcp_socket).unwrap();
+        match msg.payload {
+            StacksMessageType::HandshakeAccept(..)
+            | StacksMessageType::StackerDBHandshakeAccept(..) => {}
+            x => {
+                error!("Peer returned {:?}", &x);
+                panic!();
             }
         }
-        peer
-    });
 
-    let mut tcp_socket = TcpStream::connect(peer_addr).unwrap();
-
-    // first, handshake
-    let handshake_data = StacksMessageType::Handshake(HandshakeData::from_local_peer(&client_peer));
-    let signed_handshake_data = convo
-        .sign_message(&chain_view, &privk, handshake_data)
-        .unwrap();
-    signed_handshake_data
-        .consensus_serialize(&mut tcp_socket)
-        .unwrap();
-
-    // read back handshake-accept
-    let msg: StacksMessage = read_next(&mut tcp_socket).unwrap();
-    match msg.payload {
-        StacksMessageType::HandshakeAccept(..)
-        | StacksMessageType::StackerDBHandshakeAccept(..) => {}
-        x => {
-            error!("Peer returned {:?}", &x);
-            panic!();
+        let mut replies = vec![];
+        for get_nakamoto_inv in get_nakamoto_invs {
+            // send getnakamotoinv
+            get_nakamoto_inv
+                .consensus_serialize(&mut tcp_socket)
+                .unwrap();
+
+            loop {
+                // read back the message
+                let msg: StacksMessage = read_next(&mut tcp_socket).unwrap();
+                let is_inv_reply = if let StacksMessageType::NakamotoInv(..) = &msg.payload {
+                    true
+                } else {
+                    false
+                };
+                if is_inv_reply {
+                    replies.push(msg.payload);
+                    break;
+                } else {
+                    debug!("Got spurious meessage {:?}", &msg);
+                }
+            }
         }
-    }
 
-    let mut replies = vec![];
-    for get_nakamoto_inv in get_nakamoto_invs {
-        // send getnakamotoinv
-        get_nakamoto_inv
-            .consensus_serialize(&mut tcp_socket)
-            .unwrap();
+        shutdown_send.send(true).unwrap();
+        replies
+    });
 
-        loop {
-            // read back the message
-            let msg: StacksMessage = read_next(&mut tcp_socket).unwrap();
-            let is_inv_reply = if let StacksMessageType::NakamotoInv(..) = &msg.payload {
-                true
-            } else {
-                false
-            };
-            if is_inv_reply {
-                replies.push(msg.payload);
-                break;
-            } else {
-                debug!("Got spurious meessage {:?}", &msg);
-            }
+    loop {
+        peer.step_with_ibd(false).unwrap();
+        if let Ok(..) = shutdown_recv.try_recv() {
+            break;
         }
     }
 
-    shutdown_send.send(true).unwrap();
-    let peer = join_handle.join().unwrap();
+    let replies = join_handle.join().unwrap();
 
     (peer, replies)
 }
@@ -300,3 +310,256 @@ fn test_nakamoto_inv_10_extended_tenures_10_sortitions() {
         assert_eq!(bitvec.len() as u16, inv.bitlen);
     }
 }
+
+fn make_nakamoto_peer_from_invs<'a>(
+    test_name: &str,
+    observer: &'a TestEventObserver,
+    rc_len: u32,
+    prepare_len: u32,
+    bitvecs: Vec<Vec<bool>>,
+) -> TestPeer<'a> {
+    for bitvec in bitvecs.iter() {
+        assert_eq!(bitvec.len() as u32, rc_len);
+    }
+
+    let private_key = StacksPrivateKey::from_seed(&[2]);
+    let addr = StacksAddress::from_public_keys(
+        C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
+        &AddressHashMode::SerializeP2PKH,
+        1,
+        &vec![StacksPublicKey::from_private(&private_key)],
+    )
+    .unwrap();
+    let recipient_addr =
+        StacksAddress::from_string("ST2YM3J4KQK09V670TD6ZZ1XYNYCNGCWCVTASN5VM").unwrap();
+
+    let mut sender_nonce = 0;
+
+    let mut next_stx_transfer = || {
+        let mut stx_transfer = StacksTransaction::new(
+            TransactionVersion::Testnet,
+            TransactionAuth::from_p2pkh(&private_key).unwrap(),
+            TransactionPayload::TokenTransfer(
+                recipient_addr.clone().to_account_principal(),
+                1,
+                TokenTransferMemo([0x00; 34]),
+            ),
+        );
+        stx_transfer.chain_id = 0x80000000;
+        stx_transfer.anchor_mode = TransactionAnchorMode::OnChainOnly;
+        stx_transfer.set_tx_fee(1);
+        stx_transfer.auth.set_origin_nonce(sender_nonce);
+        sender_nonce += 1;
+
+        let mut tx_signer = StacksTransactionSigner::new(&stx_transfer);
+        tx_signer.sign_origin(&private_key).unwrap();
+        let stx_transfer_signed = tx_signer.get_tx().unwrap();
+
+        stx_transfer_signed
+    };
+
+    let mut boot_tenures = vec![];
+    for bitvec in bitvecs.iter() {
+        for has_tenure in bitvec {
+            if *has_tenure {
+                boot_tenures.push(NakamotoBootTenure::Sortition(vec![
+                    NakamotoBootStep::Block(vec![next_stx_transfer()]),
+                    NakamotoBootStep::Block(vec![next_stx_transfer()]),
+                    NakamotoBootStep::Block(vec![next_stx_transfer()]),
+                    NakamotoBootStep::Block(vec![next_stx_transfer()]),
+                    NakamotoBootStep::Block(vec![next_stx_transfer()]),
+                    NakamotoBootStep::Block(vec![next_stx_transfer()]),
+                    NakamotoBootStep::Block(vec![next_stx_transfer()]),
+                    NakamotoBootStep::Block(vec![next_stx_transfer()]),
+                    NakamotoBootStep::Block(vec![next_stx_transfer()]),
+                    NakamotoBootStep::Block(vec![next_stx_transfer()]),
+                ]));
+            } else {
+                boot_tenures.push(NakamotoBootTenure::NoSortition(vec![
+                    NakamotoBootStep::Block(vec![next_stx_transfer()]),
+                    NakamotoBootStep::TenureExtend(vec![next_stx_transfer()]),
+                    NakamotoBootStep::Block(vec![next_stx_transfer()]),
+                    NakamotoBootStep::TenureExtend(vec![next_stx_transfer()]),
+                    NakamotoBootStep::Block(vec![next_stx_transfer()]),
+                    NakamotoBootStep::TenureExtend(vec![next_stx_transfer()]),
+                    NakamotoBootStep::Block(vec![next_stx_transfer()]),
+                    NakamotoBootStep::TenureExtend(vec![next_stx_transfer()]),
+                ]));
+            }
+        }
+    }
+
+    let plan = NakamotoBootPlan::new(test_name)
+        .with_private_key(private_key)
+        .with_pox_constants(rc_len, prepare_len)
+        .with_initial_balances(vec![(addr.into(), 1_000_000)]);
+
+    let peer = plan.boot_into_nakamoto_peer(boot_tenures, Some(observer));
+    peer
+}
+
+fn check_inv_messages(
+    bitvecs: Vec<Vec<bool>>,
+    rc_len: u32,
+    nakamoto_start_burn_height: u64,
+    messages: Vec<StacksMessageType>,
+) {
+    for (msg_idx, msg) in messages.into_iter().enumerate() {
+        let StacksMessageType::NakamotoInv(inv) = msg else {
+            panic!("Did not receive an inv for reward cycle {}", msg_idx);
+        };
+        for bit in 0..(inv.bitlen as usize) {
+            let burn_block_height = (msg_idx as u64) * u64::from(rc_len) + (bit as u64);
+            let msg_bit = inv.tenures[bit / 8] & (1 << (bit % 8)) != 0;
+            if burn_block_height < nakamoto_start_burn_height {
+                // inv doesn't cover epoch 2
+                assert!(
+                    !msg_bit,
+                    "Bit {} in message {} is set but is before nakamoto-start height {} ({})",
+                    bit, msg_idx, nakamoto_start_burn_height, burn_block_height
+                );
+                continue;
+            }
+
+            let inv_offset: u64 = burn_block_height - nakamoto_start_burn_height;
+            let bitvec_idx = (inv_offset / u64::from(rc_len)) as usize;
+            let expected_bit = if bitvec_idx >= bitvecs.len() {
+                false
+            } else {
+                bitvecs[bitvec_idx][(inv_offset % u64::from(rc_len)) as usize]
+            };
+            assert_eq!(msg_bit, expected_bit, "Bit {} in message {} is {}, but expected {}. burn_block_height = {}, inv_offset = {}, bitvec_idx = {}, nakamoto_start_burn_height = {}",
+                       bit, msg_idx, msg_bit, expected_bit, burn_block_height, inv_offset, bitvec_idx, nakamoto_start_burn_height);
+        }
+    }
+}
+
+#[test]
+fn test_nakamoto_invs_full() {
+    let observer = TestEventObserver::new();
+    let bitvecs = vec![
+        vec![true, true, true, true, true, true, true, true, true, true],
+        vec![true, true, true, true, true, true, true, true, true, true],
+        vec![true, true, true, true, true, true, true, true, true, true],
+        vec![true, true, true, true, true, true, true, true, true, true],
+        vec![true, true, true, true, true, true, true, true, true, true],
+    ];
+
+    let peer = make_nakamoto_peer_from_invs(function_name!(), &observer, 10, 3, bitvecs.clone());
+    let (peer, reward_cycle_invs) =
+        peer_get_nakamoto_invs(peer, &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]);
+
+    let nakamoto_start =
+        NakamotoBootPlan::nakamoto_first_tenure_height(&peer.config.burnchain.pox_constants);
+
+    eprintln!("{:#?}", &reward_cycle_invs);
+    assert_eq!(reward_cycle_invs.len(), 10);
+    check_inv_messages(bitvecs, 10, nakamoto_start, reward_cycle_invs);
+}
+
+#[test]
+fn test_nakamoto_invs_alternating() {
+    let observer = TestEventObserver::new();
+    let bitvecs = vec![
+        vec![
+            true, false, true, false, true, false, true, true, true, true,
+        ],
+        vec![
+            false, true, false, true, false, true, false, true, true, true,
+        ],
+        vec![
+            true, false, true, false, true, false, true, true, true, true,
+        ],
+        vec![
+            false, true, false, true, false, true, false, true, true, true,
+        ],
+        vec![
+            true, false, true, false, true, false, true, true, true, true,
+        ],
+    ];
+
+    let peer = make_nakamoto_peer_from_invs(function_name!(), &observer, 10, 3, bitvecs.clone());
+    let (peer, reward_cycle_invs) =
+        peer_get_nakamoto_invs(peer, &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]);
+
+    let nakamoto_start =
+        NakamotoBootPlan::nakamoto_first_tenure_height(&peer.config.burnchain.pox_constants);
+
+    eprintln!("{:#?}", &reward_cycle_invs);
+    assert_eq!(reward_cycle_invs.len(), 10);
+    check_inv_messages(bitvecs, 10, nakamoto_start, reward_cycle_invs);
+}
+
+#[test]
+fn test_nakamoto_invs_sparse() {
+    let observer = TestEventObserver::new();
+    let bitvecs = vec![
+        vec![
+            true, false, false, false, false, false, false, true, true, true,
+        ],
+        vec![
+            false, true, false, false, false, false, false, true, true, true,
+        ],
+        vec![
+            false, false, true, false, false, false, false, true, true, true,
+        ],
+        vec![
+            false, false, false, true, false, false, false, true, true, true,
+        ],
+        vec![
+            false, false, false, false, true, false, false, true, true, true,
+        ],
+        vec![
+            false, false, false, false, false, true, false, true, true, true,
+        ],
+        vec![
+            false, false, false, false, false, false, true, true, true, true,
+        ],
+    ];
+
+    let peer = make_nakamoto_peer_from_invs(function_name!(), &observer, 10, 3, bitvecs.clone());
+    let (peer, reward_cycle_invs) =
+        peer_get_nakamoto_invs(peer, &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]);
+
+    let nakamoto_start =
+        NakamotoBootPlan::nakamoto_first_tenure_height(&peer.config.burnchain.pox_constants);
+
+    eprintln!("{:#?}", &reward_cycle_invs);
+    assert_eq!(reward_cycle_invs.len(), 12);
+    check_inv_messages(bitvecs, 10, nakamoto_start, reward_cycle_invs);
+}
+
+#[test]
+fn test_nakamoto_invs_different_anchor_blocks() {
+    let observer = TestEventObserver::new();
+    let bitvecs = vec![
+        vec![true, true, true, true, true, true, false, true, true, true],
+        vec![true, true, true, true, true, false, false, true, true, true],
+        vec![
+            true, true, true, true, false, false, false, true, true, true,
+        ],
+        vec![
+            true, true, true, false, false, false, false, true, true, true,
+        ],
+        vec![
+            true, true, false, false, false, false, false, true, true, true,
+        ],
+        vec![
+            true, false, false, false, false, false, false, true, true, true,
+        ],
+        vec![
+            false, false, false, false, false, false, false, true, true, true,
+        ],
+    ];
+
+    let peer = make_nakamoto_peer_from_invs(function_name!(), &observer, 10, 3, bitvecs.clone());
+    let (peer, reward_cycle_invs) =
+        peer_get_nakamoto_invs(peer, &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]);
+
+    let nakamoto_start =
+        NakamotoBootPlan::nakamoto_first_tenure_height(&peer.config.burnchain.pox_constants);
+
+    eprintln!("{:#?}", &reward_cycle_invs);
+    assert_eq!(reward_cycle_invs.len(), 12);
+    check_inv_messages(bitvecs, 10, nakamoto_start, reward_cycle_invs);
+}

From cc5b772a7dbdf6d6d06ad66b29c1403f44612532 Mon Sep 17 00:00:00 2001
From: friedger <mail@friedger.de>
Date: Wed, 31 Jan 2024 08:25:21 +0100
Subject: [PATCH 0539/1166] fix: use state_2 on odd cycles

---
 .../tests/pox-4/signers-voting.test.ts        |  2 +-
 .../stacks/boot/signers-voting.clar           |  6 +-
 .../stacks/boot/signers_voting_tests.rs       | 94 ++++++++++++++-----
 3 files changed, 73 insertions(+), 29 deletions(-)

diff --git a/contrib/core-contract-tests/tests/pox-4/signers-voting.test.ts b/contrib/core-contract-tests/tests/pox-4/signers-voting.test.ts
index 5953dee4d7..96b45d426c 100644
--- a/contrib/core-contract-tests/tests/pox-4/signers-voting.test.ts
+++ b/contrib/core-contract-tests/tests/pox-4/signers-voting.test.ts
@@ -10,7 +10,7 @@ const ERR_SIGNER_INDEX_MISMATCH = 10000;
 const ERR_INVALID_SIGNER_INDEX = 10001;
 const ERR_OUT_OF_VOTING_WINDOW = 10002
 const ERR_OLD_ROUND = 10003;
-const ERR_INVALID_AGGREGATE_PUBLIC_KEY = 10004;
+const ERR_ILL_FORMED_AGGREGATE_PUBLIC_KEY = 10004;
 const ERR_DUPLICATE_AGGREGATE_PUBLIC_KEY = 10005;
 const ERR_DUPLICATE_VOTE = 10006;
 const ERR_INVALID_BURN_BLOCK_HEIGHT = 10007
diff --git a/stackslib/src/chainstate/stacks/boot/signers-voting.clar b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
index 82a7919583..e16e07e9b3 100644
--- a/stackslib/src/chainstate/stacks/boot/signers-voting.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
@@ -13,7 +13,7 @@
 (define-constant err-invalid-signer-index (err u10001))
 (define-constant err-out-of-voting-window (err u10002))
 (define-constant err-old-round (err u10003))
-(define-constant err-invalid-aggregate-public-key (err u10004))
+(define-constant err-ill-formed-aggregate-public-key (err u10004))
 (define-constant err-duplicate-aggregate-public-key (err u10005))
 (define-constant err-duplicate-vote (err u10006))
 (define-constant err-invalid-burn-block-height (err u10007))
@@ -35,7 +35,7 @@
 
 ;; get current voting info
 (define-read-only (get-current-info)
-    (if (is-eq (mod (current-reward-cycle) u2)) (var-get state-1) (var-get state-2)))
+    (if (is-eq u0 (mod (current-reward-cycle) u2)) (var-get state-1) (var-get state-2)))
 
 (define-read-only (burn-height-to-reward-cycle (height uint))
     (/ (- height (get first-burnchain-block-height pox-info)) (get reward-cycle-length pox-info)))
@@ -87,7 +87,7 @@
             (new-total (+ num-slots (default-to u0 (map-get? tally tally-key)))))
         (asserts! (is-in-voting-window burn-block-height reward-cycle) err-out-of-voting-window)
         (asserts! (>= round (default-to u0 (map-get? rounds reward-cycle))) err-old-round)
-        (asserts! (is-eq (len key) u33) err-invalid-aggregate-public-key)
+        (asserts! (is-eq (len key) u33) err-ill-formed-aggregate-public-key)
         (asserts! (is-valid-aggregated-public-key key {reward-cycle: reward-cycle, round: round}) err-duplicate-aggregate-public-key)
         (asserts! (map-insert votes {reward-cycle: reward-cycle, round: round, signer: tx-sender} {aggregate-public-key: key, reward-slots: num-slots}) err-duplicate-vote)
         (map-set tally tally-key new-total)
diff --git a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
index bca7ce54b0..229e4118a9 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
@@ -218,17 +218,22 @@ fn vote_for_aggregate_public_key_in_first_block() {
     );
 }
 
+/// In this test case, Alice votes in the first block of the last tenure of the prepare phase.
+/// Bob votes in the second block of that tenure.
+/// Alice can vote successfully.
+/// Bob is out of the voting window.
 #[test]
 fn vote_for_aggregate_public_key_in_last_block() {
     let stacker_1 = TestStacker::from_seed(&[3, 4]);
     let stacker_2 = TestStacker::from_seed(&[5, 6]);
     let observer = TestEventObserver::new();
 
-    let signer = key_to_stacks_addr(&stacker_1.signer_private_key).to_account_principal();
+    let signer_1 = key_to_stacks_addr(&stacker_1.signer_private_key).to_account_principal();
+    let signer_2 = key_to_stacks_addr(&stacker_2.signer_private_key).to_account_principal();
 
     let (mut peer, mut test_signers, latest_block_id, current_reward_cycle) = prepare_signers_test(
         function_name!(),
-        vec![(signer, 1000)],
+        vec![(signer_1, 1000), (signer_2, 1000)],
         Some(vec![&stacker_1, &stacker_2]),
         Some(&observer),
     );
@@ -250,36 +255,52 @@ fn vote_for_aggregate_public_key_in_last_block() {
         &mut stacker_1_nonce,
     );
 
-    // create vote txs
-    let signer_nonce = 0;
-    let signer_key = &stacker_1.signer_private_key;
-    let signer_address = key_to_stacks_addr(signer_key);
-    let signer_principal = PrincipalData::from(signer_address);
-    let cycle_id = current_reward_cycle;
-    let signer_index = get_signer_index(&mut peer, latest_block_id, signer_address);
+    let cycle_id: u128 = current_reward_cycle;
     let aggregated_public_key: Point = Point::new();
 
-    let txs = vec![
+    // create vote txs for alice
+    let signer_1_nonce = 0;
+    let signer_1_key = &stacker_1.signer_private_key;
+    let signer_1_address = key_to_stacks_addr(signer_1_key);
+    let signer_1_principal = PrincipalData::from(signer_1_address);
+    let signer_1_index = get_signer_index(&mut peer, latest_block_id, signer_1_address);
+
+    let txs_1 = vec![
         // cast a vote for the aggregate public key
         make_signers_vote_for_aggregate_public_key(
-            signer_key,
-            signer_nonce,
-            signer_index,
+            signer_1_key,
+            signer_1_nonce,
+            signer_1_index,
             &aggregated_public_key,
             0,
         ),
         // cast the vote twice
         make_signers_vote_for_aggregate_public_key(
-            signer_key,
-            signer_nonce + 1,
-            signer_index,
+            signer_1_key,
+            signer_1_nonce + 1,
+            signer_1_index,
             &aggregated_public_key,
             0,
         ),
     ];
 
-    let txids: Vec<Txid> = txs.clone().iter().map(|t| t.txid()).collect();
-    dbg!(txids);
+    // create vote txs for bob
+    let signer_2_nonce = 0;
+    let signer_2_key = &stacker_2.signer_private_key;
+    let signer_2_address = key_to_stacks_addr(signer_2_key);
+    let signer_2_principal = PrincipalData::from(signer_2_address);
+    let signer_2_index = get_signer_index(&mut peer, latest_block_id, signer_2_address);
+
+    let txs_2 = vec![
+        // cast a vote for the aggregate public key
+        make_signers_vote_for_aggregate_public_key(
+            signer_2_key,
+            signer_2_nonce,
+            signer_2_index,
+            &aggregated_public_key,
+            0,
+        ),
+    ];
 
     //
     // vote in the last burn block of prepare phase
@@ -289,22 +310,30 @@ fn vote_for_aggregate_public_key_in_last_block() {
         &mut peer,
         &mut test_signers,
         vec![vec![dummy_tx_1]],
-        signer_key,
+        signer_1_key,
     );
 
     nakamoto_tenure(
         &mut peer,
         &mut test_signers,
         vec![vec![dummy_tx_2]],
-        signer_key,
+        signer_1_key,
     );
 
-    // vote in second block of tenure
-    let blocks_and_sizes = nakamoto_tenure(&mut peer, &mut test_signers, vec![txs], signer_key);
+    // alice votes in first block of tenure
+    // bob votes in second block of tenure
+    let blocks_and_sizes = nakamoto_tenure(
+        &mut peer,
+        &mut test_signers,
+        vec![txs_1, txs_2],
+        signer_1_key,
+    );
 
-    // check the last two txs in the last block
-    let block = observer.get_blocks().last().unwrap().clone();
-    let receipts = block.receipts.as_slice();
+    // check alice's and bob's txs
+    let blocks = observer.get_blocks();
+    // alice's block
+    let block = &blocks[blocks.len() - 2].clone();
+    let receipts = &block.receipts;
     assert_eq!(receipts.len(), 4);
 
     // first vote should succeed
@@ -326,6 +355,21 @@ fn vote_for_aggregate_public_key_in_last_block() {
             data: Box::new(Value::UInt(10006)) // err-duplicate-vote
         })
     );
+
+    // bob's block
+    let block = blocks.last().unwrap().clone();
+    let receipts = block.receipts.as_slice();
+    assert_eq!(receipts.len(), 1);
+
+    // vote should succeed
+    let tx1 = &receipts[receipts.len() - 1];
+    assert_eq!(
+        tx1.result,
+        Value::Response(ResponseData {
+            committed: false,
+            data: Box::new(Value::UInt(10002)) // err-out-of-voting-window
+        })
+    );
 }
 
 fn nakamoto_tenure(

From 0cc9c45b9b01b1cd693cfc70457829904b7174c1 Mon Sep 17 00:00:00 2001
From: friedger <mail@friedger.de>
Date: Wed, 31 Jan 2024 15:13:11 +0100
Subject: [PATCH 0540/1166] chore: use only one state, cleanup

---
 .../chainstate/nakamoto/coordinator/tests.rs  |  2 +-
 stackslib/src/chainstate/stacks/boot/mod.rs   | 32 -------------------
 .../stacks/boot/signers-voting.clar           |  5 ++-
 .../stacks/boot/signers_voting_tests.rs       | 16 ++++++----
 4 files changed, 14 insertions(+), 41 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index 4c645e438a..055fd05210 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -136,7 +136,7 @@ pub fn boot_nakamoto<'a>(
         (0..test_signers.num_keys)
             .map(|index| {
                 let stacker_private_key = StacksPrivateKey::from_seed(&index.to_be_bytes());
-                let signer_private_key = StacksPrivateKey::from_seed(&(index + 1000).to_be_bytes());
+                let signer_private_key = StacksPrivateKey::from_seed(&index.to_be_bytes());
                 TestStacker {
                     stacker_private_key,
                     signer_private_key,
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 7361a99aec..f4b57ab470 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -2217,38 +2217,6 @@ pub mod test {
         make_tx(key, nonce, 0, payload)
     }
 
-    pub fn readonly_call(
-        peer: &mut TestPeer,
-        tip: &StacksBlockId,
-        boot_contract: ContractName,
-        function_name: ClarityName,
-        args: Vec<Value>,
-    ) -> Value {
-        with_sortdb(peer, |chainstate, sortdb| {
-            chainstate.with_read_only_clarity_tx(&sortdb.index_conn(), tip, |connection| {
-                connection
-                    .with_readonly_clarity_env(
-                        false,
-                        0x80000000,
-                        ClarityVersion::Clarity2,
-                        PrincipalData::from(boot_code_addr(false)),
-                        None,
-                        LimitedCostTracker::new_free(),
-                        |env| {
-                            env.execute_contract_allow_private(
-                                &boot_code_id(&boot_contract, false),
-                                &function_name,
-                                &symbols_from_values(args),
-                                true,
-                            )
-                        },
-                    )
-                    .unwrap()
-            })
-        })
-        .unwrap()
-    }
-
     // make a stream of invalid pox-lockup transactions
     fn make_invalid_pox_lockups(key: &StacksPrivateKey, mut nonce: u64) -> Vec<StacksTransaction> {
         let mut ret = vec![];
diff --git a/stackslib/src/chainstate/stacks/boot/signers-voting.clar b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
index e16e07e9b3..d193386128 100644
--- a/stackslib/src/chainstate/stacks/boot/signers-voting.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
@@ -35,7 +35,7 @@
 
 ;; get current voting info
 (define-read-only (get-current-info)
-    (if (is-eq u0 (mod (current-reward-cycle) u2)) (var-get state-1) (var-get state-2)))
+    (var-get state-1))
 
 (define-read-only (burn-height-to-reward-cycle (height uint))
     (/ (- height (get first-burnchain-block-height pox-info)) (get reward-cycle-length pox-info)))
@@ -52,6 +52,9 @@
 (define-read-only (get-vote (reward-cycle uint) (round uint) (signer principal))
     (map-get? votes {reward-cycle: reward-cycle, round: round, signer: signer}))
 
+(define-read-only (get-tally (reward-cycle uint) (round uint) (aggregate-public-key (buff 33)))
+    (map-get? tally {reward-cycle: reward-cycle, round: round, aggregate-public-key: aggregate-public-key}))
+
 (define-read-only (get-signer-slots (signer-index uint) (reward-cycle uint))
     (let ((height (reward-cycle-to-burn-height reward-cycle)))
             (ok (at-block
diff --git a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
index 229e4118a9..f31ced3e06 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
@@ -135,6 +135,9 @@ pub fn prepare_pox4_test<'a>(
     )
 }
 
+/// In this test case, Alice votes in the first block of the first tenure of the prepare phase.
+/// Alice can vote successfully.
+/// A second vote on the same key and round fails with "duplicate vote" error
 #[test]
 fn vote_for_aggregate_public_key_in_first_block() {
     let stacker_1 = TestStacker::from_seed(&[3, 4]);
@@ -160,7 +163,10 @@ fn vote_for_aggregate_public_key_in_first_block() {
 
     let signer_index = get_signer_index(&mut peer, latest_block_id, signer_address);
 
-    let aggregated_public_key: Point = Point::new();
+    let aggregate_public_key: Point = Point::new();
+    let aggreagte_public_key_value =
+        Value::buff_from(aggregate_public_key.compress().data.to_vec())
+            .expect("Failed to serialize aggregate public key");
 
     let txs = vec![
         // cast a vote for the aggregate public key
@@ -168,7 +174,7 @@ fn vote_for_aggregate_public_key_in_first_block() {
             signer_key,
             signer_nonce,
             signer_index,
-            &aggregated_public_key,
+            &aggregate_public_key,
             0,
         ),
         // cast the vote twice
@@ -176,14 +182,11 @@ fn vote_for_aggregate_public_key_in_first_block() {
             signer_key,
             signer_nonce + 1,
             signer_index,
-            &aggregated_public_key,
+            &aggregate_public_key,
             0,
         ),
     ];
 
-    let txids: Vec<Txid> = txs.clone().iter().map(|t| t.txid()).collect();
-    dbg!(txids);
-
     //
     // vote in the first burn block of prepare phase
     //
@@ -193,7 +196,6 @@ fn vote_for_aggregate_public_key_in_first_block() {
     let block = observer.get_blocks().last().unwrap().clone();
     let receipts = block.receipts.as_slice();
     assert_eq!(receipts.len(), 4);
-
     // ignore tenure change tx
     // ignore tenure coinbase tx
 

From 8a009c7a53922f99076bc89b88e331b1a3d28e7f Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Fri, 26 Jan 2024 15:57:39 -0600
Subject: [PATCH 0541/1166] feat: read reward set from state updated in
 .signers

---
 clarity/src/vm/database/clarity_db.rs         |  16 +
 clarity/src/vm/errors.rs                      |   1 +
 stackslib/src/chainstate/coordinator/mod.rs   |  70 +++-
 stackslib/src/chainstate/coordinator/tests.rs |  11 +
 .../chainstate/nakamoto/coordinator/mod.rs    |  74 ++--
 .../chainstate/nakamoto/coordinator/tests.rs  |  57 ++-
 stackslib/src/chainstate/nakamoto/mod.rs      | 325 +++------------
 .../src/chainstate/nakamoto/signer_set.rs     | 386 ++++++++++++++++++
 .../src/chainstate/nakamoto/tests/mod.rs      |   8 +-
 .../src/chainstate/nakamoto/tests/node.rs     |  16 +
 stackslib/src/chainstate/stacks/boot/mod.rs   |  70 +---
 .../src/chainstate/stacks/boot/signers.clar   |   5 +-
 .../chainstate/stacks/boot/signers_tests.rs   |   4 +-
 .../stacks/boot/signers_voting_tests.rs       |   4 +-
 stackslib/src/chainstate/stacks/db/blocks.rs  |  23 +-
 15 files changed, 656 insertions(+), 414 deletions(-)
 create mode 100644 stackslib/src/chainstate/nakamoto/signer_set.rs

diff --git a/clarity/src/vm/database/clarity_db.rs b/clarity/src/vm/database/clarity_db.rs
index 1c0a6c86bb..3f2175b765 100644
--- a/clarity/src/vm/database/clarity_db.rs
+++ b/clarity/src/vm/database/clarity_db.rs
@@ -611,6 +611,22 @@ impl<'a> ClarityDatabase<'a> {
         self.store.insert_metadata(contract_identifier, key, data);
     }
 
+    /// Set a metadata entry if it hasn't already been set, yielding
+    ///  a runtime error if it was. This should only be called by post-nakamoto
+    ///  contexts.
+    pub fn try_set_metadata(
+        &mut self,
+        contract_identifier: &QualifiedContractIdentifier,
+        key: &str,
+        data: &str,
+    ) -> Result<()> {
+        if self.store.has_metadata_entry(contract_identifier, key) {
+            Err(Error::Runtime(RuntimeErrorType::MetadataAlreadySet, None))
+        } else {
+            Ok(self.store.insert_metadata(contract_identifier, key, data))
+        }
+    }
+
     fn insert_metadata<T: ClaritySerializable>(
         &mut self,
         contract_identifier: &QualifiedContractIdentifier,
diff --git a/clarity/src/vm/errors.rs b/clarity/src/vm/errors.rs
index d03e75e034..a640488285 100644
--- a/clarity/src/vm/errors.rs
+++ b/clarity/src/vm/errors.rs
@@ -100,6 +100,7 @@ pub enum RuntimeErrorType {
     UnwrapFailure,
     DefunctPoxContract,
     PoxAlreadyLocked,
+    MetadataAlreadySet,
 }
 
 #[derive(Debug, PartialEq)]
diff --git a/stackslib/src/chainstate/coordinator/mod.rs b/stackslib/src/chainstate/coordinator/mod.rs
index 85bfc83b48..3bc1f890a5 100644
--- a/stackslib/src/chainstate/coordinator/mod.rs
+++ b/stackslib/src/chainstate/coordinator/mod.rs
@@ -286,6 +286,15 @@ pub trait RewardSetProvider {
         sortdb: &SortitionDB,
         block_id: &StacksBlockId,
     ) -> Result<RewardSet, Error>;
+
+    fn get_reward_set_nakamoto(
+        &self,
+        cycle_start_burn_height: u64,
+        chainstate: &mut StacksChainState,
+        burnchain: &Burnchain,
+        sortdb: &SortitionDB,
+        block_id: &StacksBlockId,
+    ) -> Result<RewardSet, Error>;
 }
 
 pub struct OnChainRewardSetProvider<'a, T: BlockEventDispatcher>(pub Option<&'a T>);
@@ -312,6 +321,14 @@ impl<'a, T: BlockEventDispatcher> RewardSetProvider for OnChainRewardSetProvider
         let cycle = burnchain
             .block_height_to_reward_cycle(cycle_start_burn_height)
             .expect("FATAL: no reward cycle for burn height");
+        // `self.get_reward_set_nakamoto` reads the reward set from data written during
+        //   updates to .signers
+        // `self.get_reward_set_epoch2` reads the reward set from the `.pox-*` contract
+        //
+        //  Data **cannot** be read from `.signers` in epoch 2.5 because the write occurs
+        //   in the first block of the prepare phase, but the PoX anchor block is *before*
+        //   the prepare phase. Therefore
+
         let is_nakamoto_reward_set = match SortitionDB::get_stacks_epoch_by_epoch_id(
             sortdb.conn(),
             &StacksEpochId::Epoch30,
@@ -325,26 +342,22 @@ impl<'a, T: BlockEventDispatcher> RewardSetProvider for OnChainRewardSetProvider
             // if epoch-3.0 isn't defined, then never use a nakamoto reward set.
             None => false,
         };
-        let reward_set = if !is_nakamoto_reward_set {
-            // Stacks 2.x epoch
-            self.get_reward_set_epoch2(
-                cycle_start_burn_height,
-                chainstate,
-                burnchain,
-                sortdb,
-                block_id,
-                cur_epoch,
-            )?
-        } else {
-            // Nakamoto epoch
-            self.get_reward_set_nakamoto(
-                cycle_start_burn_height,
-                chainstate,
-                burnchain,
-                sortdb,
-                block_id,
-            )?
-        };
+
+        let reward_set = self.get_reward_set_epoch2(
+            cycle_start_burn_height,
+            chainstate,
+            burnchain,
+            sortdb,
+            block_id,
+            cur_epoch,
+        )?;
+
+        if is_nakamoto_reward_set {
+            if reward_set.signers.is_none() || reward_set.signers == Some(vec![]) {
+                error!("FATAL: Signer sets are empty in a reward set that will be used in nakamoto"; "reward_set" => ?reward_set);
+                return Err(Error::PoXAnchorBlockRequired);
+            }
+        }
 
         if let Some(dispatcher) = self.0 {
             dispatcher.announce_reward_set(&reward_set, block_id, cycle);
@@ -352,6 +365,23 @@ impl<'a, T: BlockEventDispatcher> RewardSetProvider for OnChainRewardSetProvider
 
         Ok(reward_set)
     }
+
+    fn get_reward_set_nakamoto(
+        &self,
+        cycle_start_burn_height: u64,
+        chainstate: &mut StacksChainState,
+        burnchain: &Burnchain,
+        sortdb: &SortitionDB,
+        block_id: &StacksBlockId,
+    ) -> Result<RewardSet, Error> {
+        self.read_reward_set_nakamoto(
+            cycle_start_burn_height,
+            chainstate,
+            burnchain,
+            sortdb,
+            block_id,
+        )
+    }
 }
 
 impl<'a, T: BlockEventDispatcher> OnChainRewardSetProvider<'a, T> {
diff --git a/stackslib/src/chainstate/coordinator/tests.rs b/stackslib/src/chainstate/coordinator/tests.rs
index 2f40ead90b..e2eb464625 100644
--- a/stackslib/src/chainstate/coordinator/tests.rs
+++ b/stackslib/src/chainstate/coordinator/tests.rs
@@ -520,6 +520,17 @@ impl RewardSetProvider for StubbedRewardSetProvider {
             signers: None,
         })
     }
+
+    fn get_reward_set_nakamoto(
+        &self,
+        cycle_start_burn_height: u64,
+        chainstate: &mut StacksChainState,
+        burnchain: &Burnchain,
+        sortdb: &SortitionDB,
+        block_id: &StacksBlockId,
+    ) -> Result<RewardSet, CoordError> {
+        panic!("Stubbed reward set provider cannot be invoked in nakamoto")
+    }
 }
 
 fn make_reward_set_coordinator<'a>(
diff --git a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
index de145b6eec..c24ceca34f 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
@@ -17,6 +17,7 @@
 use std::collections::VecDeque;
 use std::sync::{Arc, Mutex};
 
+use clarity::vm::clarity::ClarityConnection;
 use clarity::vm::database::BurnStateDB;
 use clarity::vm::types::PrincipalData;
 use stacks_common::types::chainstate::{
@@ -40,7 +41,7 @@ use crate::chainstate::coordinator::{
     RewardSetProvider,
 };
 use crate::chainstate::nakamoto::NakamotoChainState;
-use crate::chainstate::stacks::boot::RewardSet;
+use crate::chainstate::stacks::boot::{RewardSet, SIGNERS_NAME};
 use crate::chainstate::stacks::db::{StacksBlockHeaderTypes, StacksChainState};
 use crate::chainstate::stacks::miner::{signal_mining_blocked, signal_mining_ready, MinerStatus};
 use crate::chainstate::stacks::Error as ChainstateError;
@@ -53,7 +54,8 @@ use crate::util_lib::db::Error as DBError;
 pub mod tests;
 
 impl<'a, T: BlockEventDispatcher> OnChainRewardSetProvider<'a, T> {
-    pub fn get_reward_set_nakamoto(
+    /// Read a reward_set written while updating .signers
+    pub fn read_reward_set_nakamoto(
         &self,
         cycle_start_burn_height: u64,
         chainstate: &mut StacksChainState,
@@ -61,51 +63,65 @@ impl<'a, T: BlockEventDispatcher> OnChainRewardSetProvider<'a, T> {
         sortdb: &SortitionDB,
         block_id: &StacksBlockId,
     ) -> Result<RewardSet, Error> {
-        // TODO: this method should read the .signers contract to get the reward set entries.
-        //   they will have been set via `NakamotoChainState::check_and_handle_prepare_phase_start()`.
         let cycle = burnchain
             .block_height_to_reward_cycle(cycle_start_burn_height)
             .expect("FATAL: no reward cycle for burn height");
+        // figure out the block ID
+        let Some(coinbase_height_of_calculation) = chainstate
+            .eval_boot_code_read_only(
+                sortdb,
+                block_id,
+                SIGNERS_NAME,
+                &format!("(map-get? cycle-set-height u{})", cycle),
+            )?
+            .expect_optional()
+            .map(|x| u64::try_from(x.expect_u128()).expect("FATAL: block height exceeded u64"))
+        else {
+            error!(
+                "The reward set was not written to .signers before it was needed by Nakamoto";
+                "cycle_number" => cycle,
+            );
+            return Err(Error::PoXAnchorBlockRequired);
+        };
 
-        let registered_addrs =
-            chainstate.get_reward_addresses_in_cycle(burnchain, sortdb, cycle, block_id)?;
-
-        let liquid_ustx = chainstate.get_liquid_ustx(block_id);
-
-        let (threshold, participation) = StacksChainState::get_reward_threshold_and_participation(
-            &burnchain.pox_constants,
-            &registered_addrs[..],
-            liquid_ustx,
-        );
+        let Some(reward_set_block) = NakamotoChainState::get_header_by_coinbase_height(
+            &mut chainstate.index_tx_begin()?,
+            block_id,
+            coinbase_height_of_calculation,
+        )?
+        else {
+            error!("Failed to find the block in which .signers was written");
+            return Err(Error::PoXAnchorBlockRequired);
+        };
 
-        let cur_epoch = SortitionDB::get_stacks_epoch(sortdb.conn(), cycle_start_burn_height)?
-            .expect(&format!(
-                "FATAL: no epoch defined for burn height {}",
-                cycle_start_burn_height
-            ));
+        let Some(reward_set) = NakamotoChainState::get_reward_set(
+            chainstate.db(),
+            &reward_set_block.index_block_hash(),
+        )?
+        else {
+            error!("No reward set stored at the block in which .signers was written");
+            return Err(Error::PoXAnchorBlockRequired);
+        };
 
         // This method should only ever called if the current reward cycle is a nakamoto reward cycle
         //  (i.e., its reward set is fetched for determining signer sets (and therefore agg keys).
         //  Non participation is fatal.
-        if participation == 0 {
+        if reward_set.rewarded_addresses.is_empty() {
             // no one is stacking
             error!("No PoX participation");
             return Err(Error::PoXAnchorBlockRequired);
         }
 
-        info!("PoX reward cycle threshold computed";
-              "burn_height" => cycle_start_burn_height,
-              "threshold" => threshold,
-              "participation" => participation,
-              "liquid_ustx" => liquid_ustx,
-              "registered_addrs" => registered_addrs.len());
+        info!(
+            "PoX reward set loaded from written block state";
+            "reward_set_block_id" => %reward_set_block.index_block_hash(),
+        );
 
-        let reward_set =
-            StacksChainState::make_reward_set(threshold, registered_addrs, cur_epoch.epoch_id);
         if reward_set.signers.is_none() {
             error!("FATAL: PoX reward set did not specify signer set in Nakamoto");
             return Err(Error::PoXAnchorBlockRequired);
         }
+
         Ok(reward_set)
     }
 }
@@ -286,7 +302,7 @@ pub fn get_nakamoto_reward_cycle_info<U: RewardSetProvider>(
         "first_prepare_sortition_id" => %first_sortition_id
     );
 
-    let reward_set = provider.get_reward_set(
+    let reward_set = provider.get_reward_set_nakamoto(
         reward_start_height,
         chain_state,
         burnchain,
diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index 055fd05210..d0eaea4fe3 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -56,7 +56,7 @@ use crate::util_lib::boot::boot_code_id;
 fn advance_to_nakamoto(
     peer: &mut TestPeer,
     test_signers: &TestSigners,
-    test_stackers: Vec<TestStacker>,
+    test_stackers: &[TestStacker],
 ) {
     let mut peer_nonce = 0;
     let private_key = peer.config.private_key.clone();
@@ -68,6 +68,10 @@ fn advance_to_nakamoto(
     )
     .unwrap();
 
+    // use the signing key of addr, otherwise the test stackers
+    //  will not stack enough for any single signing key
+    // let signing_key = StacksPublicKey::from_private(&private_key);
+
     for sortition_height in 0..11 {
         // stack to pox-3 in cycle 7
         let txs = if sortition_height == 6 {
@@ -75,6 +79,8 @@ fn advance_to_nakamoto(
             test_stackers
                 .iter()
                 .map(|test_stacker| {
+                    let signing_key =
+                        StacksPublicKey::from_private(&test_stacker.signer_private_key);
                     make_pox_4_lockup(
                         &test_stacker.stacker_private_key,
                         0,
@@ -84,7 +90,7 @@ fn advance_to_nakamoto(
                             addr.bytes.clone(),
                         ),
                         12,
-                        StacksPublicKey::from_private(&test_stacker.signer_private_key),
+                        signing_key,
                         34,
                     )
                 })
@@ -104,7 +110,7 @@ pub fn boot_nakamoto<'a>(
     test_name: &str,
     mut initial_balances: Vec<(PrincipalData, u64)>,
     test_signers: &TestSigners,
-    test_stackers: Option<Vec<&TestStacker>>,
+    test_stackers: &[TestStacker],
     observer: Option<&'a TestEventObserver>,
 ) -> TestPeer<'a> {
     let aggregate_public_key = test_signers.aggregate_public_key.clone();
@@ -129,23 +135,6 @@ pub fn boot_nakamoto<'a>(
     peer_config.epochs = Some(StacksEpoch::unit_test_3_0_only(37));
     peer_config.initial_balances = vec![(addr.to_account_principal(), 1_000_000_000_000_000_000)];
 
-    let test_stackers: Vec<TestStacker> = if let Some(stackers) = test_stackers {
-        stackers.into_iter().cloned().collect()
-    } else {
-        // Create a list of test Stackers and their signer keys
-        (0..test_signers.num_keys)
-            .map(|index| {
-                let stacker_private_key = StacksPrivateKey::from_seed(&index.to_be_bytes());
-                let signer_private_key = StacksPrivateKey::from_seed(&index.to_be_bytes());
-                TestStacker {
-                    stacker_private_key,
-                    signer_private_key,
-                    amount: 1_000_000_000_000_000_000,
-                }
-            })
-            .collect()
-    };
-
     // Create some balances for test Stackers
     let mut stacker_balances = test_stackers
         .iter()
@@ -163,7 +152,7 @@ pub fn boot_nakamoto<'a>(
     peer_config.burnchain.pox_constants.pox_3_activation_height = 26;
     peer_config.burnchain.pox_constants.v3_unlock_height = 27;
     peer_config.burnchain.pox_constants.pox_4_activation_height = 31;
-    peer_config.test_stackers = Some(test_stackers.clone());
+    peer_config.test_stackers = Some(test_stackers.to_vec());
     let mut peer = TestPeer::new_with_observer(peer_config, observer);
 
     advance_to_nakamoto(&mut peer, &test_signers, test_stackers);
@@ -182,7 +171,11 @@ fn make_replay_peer<'a>(peer: &'a mut TestPeer<'a>) -> TestPeer<'a> {
     let test_stackers = replay_config.test_stackers.clone().unwrap_or(vec![]);
     let mut replay_peer = TestPeer::new(replay_config);
     let observer = TestEventObserver::new();
-    advance_to_nakamoto(&mut replay_peer, &TestSigners::default(), test_stackers);
+    advance_to_nakamoto(
+        &mut replay_peer,
+        &TestSigners::default(),
+        test_stackers.as_slice(),
+    );
 
     // sanity check
     let replay_tip = {
@@ -297,7 +290,8 @@ 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, None, None);
+    let test_stackers = TestStacker::common_signing_set(&test_signers);
+    let mut peer = boot_nakamoto(function_name!(), vec![], &test_signers, &test_stackers, None);
 
     let (burn_ops, mut tenure_change, miner_key) =
         peer.begin_nakamoto_tenure(TenureChangeCause::BlockFound);
@@ -353,11 +347,12 @@ fn test_simple_nakamoto_coordinator_1_tenure_10_blocks() {
     .unwrap();
 
     let mut test_signers = TestSigners::default();
+    let test_stackers = TestStacker::common_signing_set(&test_signers);
     let mut peer = boot_nakamoto(
         function_name!(),
         vec![(addr.into(), 100_000_000)],
         &test_signers,
-        None,
+        &test_stackers,
         None,
     );
 
@@ -476,12 +471,13 @@ fn test_nakamoto_chainstate_getters() {
     )
     .unwrap();
     let mut test_signers = TestSigners::default();
+    let test_stackers = TestStacker::common_signing_set(&test_signers);
     let mut peer = boot_nakamoto(
         function_name!(),
         vec![(addr.into(), 100_000_000)],
         &test_signers,
-        None,
-        None,
+        &test_stackers,
+        None
     );
 
     let sort_tip = {
@@ -967,11 +963,12 @@ fn test_simple_nakamoto_coordinator_10_tenures_10_blocks() {
     .unwrap();
 
     let mut test_signers = TestSigners::default();
+    let test_stackers = TestStacker::common_signing_set(&test_signers);
     let mut peer = boot_nakamoto(
         function_name!(),
         vec![(addr.into(), 100_000_000)],
         &test_signers,
-        None,
+        &test_stackers,
         None,
     );
 
@@ -1289,11 +1286,12 @@ fn test_simple_nakamoto_coordinator_2_tenures_3_sortitions() {
     )
     .unwrap();
     let mut test_signers = TestSigners::default();
+    let test_stackers = TestStacker::common_signing_set(&test_signers);
     let mut peer = boot_nakamoto(
         function_name!(),
         vec![(addr.into(), 100_000_000)],
         &test_signers,
-        None,
+        &test_stackers,
         None,
     );
 
@@ -1619,11 +1617,12 @@ fn test_simple_nakamoto_coordinator_10_tenures_and_extensions_10_blocks() {
     )
     .unwrap();
     let mut test_signers = TestSigners::default();
+    let test_stackers = TestStacker::common_signing_set(&test_signers);
     let mut peer = boot_nakamoto(
         function_name!(),
         vec![(addr.into(), 100_000_000)],
         &test_signers,
-        None,
+        &test_stackers,
         None,
     );
 
diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index a6ad43e671..2ce0307bd9 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -47,13 +47,14 @@ use stacks_common::util::secp256k1::MessageSignature;
 use stacks_common::util::vrf::{VRFProof, VRFPublicKey, VRF};
 use wsts::curve::point::Point;
 
+use self::signer_set::SignerCalculation;
 use super::burn::db::sortdb::{
     get_ancestor_sort_id, get_ancestor_sort_id_tx, get_block_commit_by_txid, SortitionHandle,
     SortitionHandleConn, SortitionHandleTx,
 };
 use super::burn::operations::{DelegateStxOp, StackStxOp, TransferStxOp};
 use super::stacks::boot::{
-    PoxVersions, RawRewardSetEntry, BOOT_TEST_POX_4_AGG_KEY_CONTRACT,
+    PoxVersions, RawRewardSetEntry, RewardSet, BOOT_TEST_POX_4_AGG_KEY_CONTRACT,
     BOOT_TEST_POX_4_AGG_KEY_FNAME, SIGNERS_MAX_LIST_SIZE, SIGNERS_NAME, SIGNERS_PK_LEN,
 };
 use super::stacks::db::accounts::MinerReward;
@@ -72,6 +73,7 @@ use crate::chainstate::burn::db::sortdb::SortitionDB;
 use crate::chainstate::burn::operations::{LeaderBlockCommitOp, LeaderKeyRegisterOp};
 use crate::chainstate::burn::{BlockSnapshot, SortitionHash};
 use crate::chainstate::coordinator::{BlockEventDispatcher, Error};
+use crate::chainstate::nakamoto::signer_set::NakamotoSigners;
 use crate::chainstate::nakamoto::tenure::NAKAMOTO_TENURES_SCHEMA;
 use crate::chainstate::stacks::address::PoxAddress;
 use crate::chainstate::stacks::boot::{POX_4_NAME, SIGNERS_UPDATE_STATE};
@@ -99,6 +101,7 @@ pub mod coordinator;
 pub mod miner;
 pub mod tenure;
 
+pub mod signer_set;
 #[cfg(test)]
 pub mod tests;
 
@@ -161,6 +164,14 @@ lazy_static! {
                     
                      PRIMARY KEY(block_hash,consensus_hash)
     );"#.into(),
+    r#"
+    -- Table for storing calculated reward sets. This must be in the Chainstate DB because calculation occurs
+    --   during block processing.
+    CREATE TABLE nakamoto_reward_sets (
+                     index_block_hash TEXT NOT NULL,
+                     reward_set TEXT NOT NULL,
+                     PRIMARY KEY (index_block_hash)
+    );"#.into(),
     NAKAMOTO_TENURES_SCHEMA.into(),
     r#"
       -- Table for Nakamoto block headers
@@ -297,6 +308,8 @@ pub struct SetupBlockResult<'a, 'b> {
     pub burn_delegate_stx_ops: Vec<DelegateStxOp>,
     /// STX auto-unlock events from PoX
     pub auto_unlock_events: Vec<StacksTransactionEvent>,
+    /// Result of a signer set calculation if one occurred
+    pub signer_set_calc: Option<SignerCalculation>,
 }
 
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
@@ -1828,274 +1841,6 @@ impl NakamotoChainState {
         }
     }
 
-    fn get_reward_slots(
-        clarity: &mut ClarityTransactionConnection,
-        reward_cycle: u64,
-        pox_contract: &str,
-    ) -> Result<Vec<RawRewardSetEntry>, ChainstateError> {
-        let is_mainnet = clarity.is_mainnet();
-        if !matches!(
-            PoxVersions::lookup_by_name(pox_contract),
-            Some(PoxVersions::Pox4)
-        ) {
-            error!("Invoked Nakamoto reward-set fetch on non-pox-4 contract");
-            return Err(ChainstateError::DefunctPoxContract);
-        }
-        let pox_contract = &boot_code_id(pox_contract, is_mainnet);
-
-        let list_length = clarity
-            .eval_method_read_only(
-                pox_contract,
-                "get-reward-set-size",
-                &[SymbolicExpression::atom_value(Value::UInt(
-                    reward_cycle.into(),
-                ))],
-            )?
-            .expect_u128();
-
-        let mut slots = vec![];
-        for index in 0..list_length {
-            let entry = clarity
-                .eval_method_read_only(
-                    pox_contract,
-                    "get-reward-set-pox-address",
-                    &[
-                        SymbolicExpression::atom_value(Value::UInt(reward_cycle.into())),
-                        SymbolicExpression::atom_value(Value::UInt(index)),
-                    ],
-                )?
-                .expect_optional()
-                .expect(&format!(
-                    "FATAL: missing PoX address in slot {} out of {} in reward cycle {}",
-                    index, list_length, reward_cycle
-                ))
-                .expect_tuple();
-
-            let pox_addr_tuple = entry
-                .get("pox-addr")
-                .expect(&format!("FATAL: no `pox-addr` in return value from (get-reward-set-pox-address u{} u{})", reward_cycle, index))
-                .to_owned();
-
-            let reward_address = PoxAddress::try_from_pox_tuple(is_mainnet, &pox_addr_tuple)
-                .expect(&format!(
-                    "FATAL: not a valid PoX address: {:?}",
-                    &pox_addr_tuple
-                ));
-
-            let total_ustx = entry
-                .get("total-ustx")
-                .expect(&format!("FATAL: no 'total-ustx' in return value from (get-reward-set-pox-address u{} u{})", reward_cycle, index))
-                .to_owned()
-                .expect_u128();
-
-            let stacker = entry
-                .get("stacker")
-                .expect(&format!(
-                    "FATAL: no 'stacker' in return value from (get-reward-set-pox-address u{} u{})",
-                    reward_cycle, index
-                ))
-                .to_owned()
-                .expect_optional()
-                .map(|value| value.expect_principal());
-
-            let signer = entry
-                .get("signer")
-                .expect(&format!(
-                    "FATAL: no 'signer' in return value from (get-reward-set-pox-address u{} u{})",
-                    reward_cycle, index
-                ))
-                .to_owned()
-                .expect_buff(SIGNERS_PK_LEN);
-            // (buff 33) only enforces max size, not min size, so we need to do a len check
-            let pk_bytes = if signer.len() == SIGNERS_PK_LEN {
-                let mut bytes = [0; SIGNERS_PK_LEN];
-                bytes.copy_from_slice(signer.as_slice());
-                bytes
-            } else {
-                [0; SIGNERS_PK_LEN]
-            };
-
-            slots.push(RawRewardSetEntry {
-                reward_address,
-                amount_stacked: total_ustx,
-                stacker,
-                signer: Some(pk_bytes),
-            })
-        }
-
-        Ok(slots)
-    }
-
-    pub fn handle_signer_stackerdb_update(
-        clarity: &mut ClarityTransactionConnection,
-        pox_constants: &PoxConstants,
-        reward_cycle: u64,
-        pox_contract: &str,
-    ) -> Result<Vec<StacksTransactionEvent>, ChainstateError> {
-        let is_mainnet = clarity.is_mainnet();
-        let sender_addr = PrincipalData::from(boot::boot_code_addr(is_mainnet));
-        let signers_contract = &boot_code_id(SIGNERS_NAME, is_mainnet);
-
-        let liquid_ustx = clarity.with_clarity_db_readonly(|db| db.get_total_liquid_ustx());
-        let reward_slots = Self::get_reward_slots(clarity, reward_cycle, pox_contract)?;
-        let (threshold, participation) = StacksChainState::get_reward_threshold_and_participation(
-            &pox_constants,
-            &reward_slots[..],
-            liquid_ustx,
-        );
-        let reward_set =
-            StacksChainState::make_reward_set(threshold, reward_slots, StacksEpochId::Epoch30);
-
-        let signers_list = if participation == 0 {
-            vec![]
-        } else {
-            reward_set
-                .signers
-                .ok_or(ChainstateError::PoxNoRewardCycle)?
-                .iter()
-                .map(|signer| {
-                    let signer_hash = Hash160::from_data(&signer.signing_key);
-                    let signing_address = StacksAddress::p2pkh_from_hash(is_mainnet, signer_hash);
-                    Value::Tuple(
-                        TupleData::from_data(vec![
-                            (
-                                "signer".into(),
-                                Value::Principal(PrincipalData::from(signing_address)),
-                            ),
-                            ("num-slots".into(), Value::UInt(signer.slots.into())),
-                        ])
-                            .expect(
-                                "BUG: Failed to construct `{ signer: principal, num-slots: u64 }` tuple",
-                            ),
-                    )
-                })
-                .collect()
-        };
-        if signers_list.len() > SIGNERS_MAX_LIST_SIZE {
-            panic!(
-                "FATAL: signers list returned by reward set calculations longer than maximum ({} > {})",
-                signers_list.len(),
-                SIGNERS_MAX_LIST_SIZE,
-            );
-        }
-
-        let args = [
-            SymbolicExpression::atom_value(Value::cons_list_unsanitized(signers_list).expect(
-                "BUG: Failed to construct `(list 4000 { signer: principal, num-slots: u64 })` list",
-            )),
-            SymbolicExpression::atom_value(Value::UInt(reward_cycle.into())),
-        ];
-
-        let (value, _, events, _) = clarity
-            .with_abort_callback(
-                |vm_env| {
-                    vm_env.execute_in_env(sender_addr.clone(), None, None, |env| {
-                        env.execute_contract_allow_private(
-                            &signers_contract,
-                            "stackerdb-set-signer-slots",
-                            &args,
-                            false,
-                        )
-                    })
-                },
-                |_, _| false,
-            )
-            .expect("FATAL: failed to update signer stackerdb");
-
-        if let Value::Response(ref data) = value {
-            if !data.committed {
-                error!(
-                    "Error while updating .signers contract";
-                    "reward_cycle" => reward_cycle,
-                    "cc_response" => %value,
-                );
-                panic!();
-            }
-        }
-
-        Ok(events)
-    }
-
-    pub fn check_and_handle_prepare_phase_start(
-        clarity_tx: &mut ClarityTx,
-        first_block_height: u64,
-        pox_constants: &PoxConstants,
-        burn_tip_height: u64,
-    ) -> Result<Vec<StacksTransactionEvent>, ChainstateError> {
-        let current_epoch = clarity_tx.get_epoch();
-        if current_epoch < StacksEpochId::Epoch25 {
-            // before Epoch-2.5, no need for special handling
-            return Ok(vec![]);
-        }
-        // now, determine if we are in a prepare phase, and we are the first
-        //  block in this prepare phase in our fork
-        if !pox_constants.is_in_prepare_phase(first_block_height, burn_tip_height) {
-            // if we're not in a prepare phase, don't need to do anything
-            return Ok(vec![]);
-        }
-
-        let Some(cycle_of_prepare_phase) =
-            pox_constants.reward_cycle_of_prepare_phase(first_block_height, burn_tip_height)
-        else {
-            // if we're not in a prepare phase, don't need to do anything
-            return Ok(vec![]);
-        };
-
-        let active_pox_contract = pox_constants.active_pox_contract(burn_tip_height);
-        if !matches!(
-            PoxVersions::lookup_by_name(active_pox_contract),
-            Some(PoxVersions::Pox4)
-        ) {
-            debug!(
-                "Active PoX contract is not PoX-4, skipping .signers updates until PoX-4 is active"
-            );
-            return Ok(vec![]);
-        }
-
-        let signers_contract = &boot_code_id(SIGNERS_NAME, clarity_tx.config.mainnet);
-
-        // are we the first block in the prepare phase in our fork?
-        let needs_update = clarity_tx.connection().with_clarity_db_readonly(|clarity_db| {
-            if !clarity_db.has_contract(signers_contract) {
-                // if there's no signers contract, no need to update anything.
-                return false
-            }
-            let Ok(value) = clarity_db.lookup_variable_unknown_descriptor(
-                signers_contract,
-                SIGNERS_UPDATE_STATE,
-                &current_epoch,
-            ) else {
-                error!("FATAL: Failed to read `{SIGNERS_UPDATE_STATE}` variable from .signers contract");
-                panic!();
-            };
-            let cycle_number = value.expect_u128();
-            // if the cycle_number is less than `cycle_of_prepare_phase`, we need to update
-            //  the .signers state.
-            cycle_number < cycle_of_prepare_phase.into()
-        });
-
-        if !needs_update {
-            debug!("Current cycle has already been setup in .signers or .signers is not initialized yet");
-            return Ok(vec![]);
-        }
-
-        info!(
-            "Performing .signers state update";
-            "burn_height" => burn_tip_height,
-            "for_cycle" => cycle_of_prepare_phase,
-            "signers_contract" => %signers_contract,
-        );
-
-        clarity_tx.connection().as_free_transaction(|clarity| {
-            Self::handle_signer_stackerdb_update(
-                clarity,
-                &pox_constants,
-                cycle_of_prepare_phase,
-                active_pox_contract,
-            )
-        })
-    }
-
     /// Get the aggregate public key for a block.
     /// TODO: The block at which the aggregate public key is queried needs to be better defined.
     /// See https://github.com/stacks-network/stacks-core/issues/4109
@@ -2649,6 +2394,33 @@ impl NakamotoChainState {
         Ok(new_tip_info)
     }
 
+    pub fn write_reward_set(
+        tx: &mut ChainstateTx,
+        block_id: &StacksBlockId,
+        reward_set: &RewardSet,
+    ) -> Result<(), ChainstateError> {
+        let sql = "INSERT INTO nakamoto_reward_sets (index_block_hash, reward_set) VALUES (?, ?)";
+        let args = rusqlite::params![block_id, &reward_set.metadata_serialize(),];
+        tx.execute(sql, args)?;
+        Ok(())
+    }
+
+    pub fn get_reward_set(
+        chainstate_db: &Connection,
+        block_id: &StacksBlockId,
+    ) -> Result<Option<RewardSet>, ChainstateError> {
+        let sql = "SELECT reward_set FROM nakamoto_reward_sets WHERE index_block_hash = ?";
+        chainstate_db
+            .query_row(sql, &[block_id], |row| {
+                let reward_set: String = row.get(0)?;
+                let reward_set = RewardSet::metadata_deserialize(&reward_set)
+                    .map_err(|s| FromSqlError::Other(s.into()))?;
+                Ok(reward_set)
+            })
+            .optional()
+            .map_err(ChainstateError::from)
+    }
+
     /// Begin block-processing and return all of the pre-processed state within a
     /// `SetupBlockResult`.
     ///
@@ -2839,13 +2611,17 @@ impl NakamotoChainState {
         }
 
         // Handle signer stackerdb updates
+        let signer_set_calc;
         if evaluated_epoch >= StacksEpochId::Epoch25 {
-            let _events = Self::check_and_handle_prepare_phase_start(
+            signer_set_calc = NakamotoSigners::check_and_handle_prepare_phase_start(
                 &mut clarity_tx,
                 first_block_height,
                 &pox_constants,
                 burn_header_height.into(),
+                coinbase_height,
             )?;
+        } else {
+            signer_set_calc = None;
         }
 
         debug!(
@@ -2864,6 +2640,7 @@ impl NakamotoChainState {
             burn_transfer_stx_ops: transfer_burn_ops,
             auto_unlock_events,
             burn_delegate_stx_ops: delegate_burn_ops,
+            signer_set_calc,
         })
     }
 
@@ -3155,6 +2932,7 @@ impl NakamotoChainState {
             burn_transfer_stx_ops,
             burn_delegate_stx_ops,
             mut auto_unlock_events,
+            signer_set_calc,
         } = Self::setup_block(
             chainstate_tx,
             clarity_instance,
@@ -3322,6 +3100,13 @@ impl NakamotoChainState {
         let new_block_id = new_tip.index_block_hash();
         chainstate_tx.log_transactions_processed(&new_block_id, &tx_receipts);
 
+        // store the reward set calculated during this block if it happened
+        // NOTE: miner and proposal evaluation should not invoke this because
+        //  it depends on knowing the StacksBlockId.
+        if let Some(signer_calculation) = signer_set_calc {
+            Self::write_reward_set(chainstate_tx, &new_block_id, &signer_calculation.reward_set)?
+        }
+
         monitoring::set_last_block_transaction_count(u64::try_from(block.txs.len()).unwrap());
         monitoring::set_last_execution_cost_observed(&block_execution_cost, &block_limit);
 
diff --git a/stackslib/src/chainstate/nakamoto/signer_set.rs b/stackslib/src/chainstate/nakamoto/signer_set.rs
new file mode 100644
index 0000000000..e0ac40199d
--- /dev/null
+++ b/stackslib/src/chainstate/nakamoto/signer_set.rs
@@ -0,0 +1,386 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020-2023 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+use std::collections::{BTreeMap, HashMap, HashSet};
+use std::ops::DerefMut;
+
+use clarity::vm::ast::ASTRules;
+use clarity::vm::costs::{ExecutionCost, LimitedCostTracker};
+use clarity::vm::database::{BurnStateDB, ClarityDatabase};
+use clarity::vm::events::StacksTransactionEvent;
+use clarity::vm::types::{PrincipalData, StacksAddressExtensions, TupleData};
+use clarity::vm::{ClarityVersion, SymbolicExpression, Value};
+use lazy_static::{__Deref, lazy_static};
+use rusqlite::types::{FromSql, FromSqlError};
+use rusqlite::{params, Connection, OptionalExtension, ToSql, NO_PARAMS};
+use sha2::{Digest as Sha2Digest, Sha512_256};
+use stacks_common::bitvec::BitVec;
+use stacks_common::codec::{
+    read_next, write_next, Error as CodecError, StacksMessageCodec, MAX_MESSAGE_LEN,
+    MAX_PAYLOAD_LEN,
+};
+use stacks_common::consts::{
+    FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH, MINER_REWARD_MATURITY,
+};
+use stacks_common::types::chainstate::{
+    BlockHeaderHash, BurnchainHeaderHash, ConsensusHash, StacksAddress, StacksBlockId,
+    StacksPrivateKey, StacksPublicKey, TrieHash, VRFSeed,
+};
+use stacks_common::types::{PrivateKey, StacksEpochId};
+use stacks_common::util::get_epoch_time_secs;
+use stacks_common::util::hash::{to_hex, Hash160, MerkleHashFunc, MerkleTree, Sha512Trunc256Sum};
+use stacks_common::util::retry::BoundReader;
+use stacks_common::util::secp256k1::MessageSignature;
+use stacks_common::util::vrf::{VRFProof, VRFPublicKey, VRF};
+use wsts::curve::point::Point;
+
+use crate::burnchains::{Burnchain, PoxConstants, Txid};
+use crate::chainstate::burn::db::sortdb::{
+    get_ancestor_sort_id, get_ancestor_sort_id_tx, get_block_commit_by_txid, SortitionDB,
+    SortitionHandle, SortitionHandleConn, SortitionHandleTx,
+};
+use crate::chainstate::burn::operations::{
+    DelegateStxOp, LeaderBlockCommitOp, LeaderKeyRegisterOp, StackStxOp, TransferStxOp,
+};
+use crate::chainstate::burn::{BlockSnapshot, SortitionHash};
+use crate::chainstate::coordinator::{BlockEventDispatcher, Error};
+use crate::chainstate::nakamoto::tenure::NAKAMOTO_TENURES_SCHEMA;
+use crate::chainstate::stacks::address::PoxAddress;
+use crate::chainstate::stacks::boot::{
+    PoxVersions, RawRewardSetEntry, RewardSet, BOOT_TEST_POX_4_AGG_KEY_CONTRACT,
+    BOOT_TEST_POX_4_AGG_KEY_FNAME, POX_4_NAME, SIGNERS_MAX_LIST_SIZE, SIGNERS_NAME, SIGNERS_PK_LEN,
+    SIGNERS_UPDATE_STATE,
+};
+use crate::chainstate::stacks::db::blocks::StagingUserBurnSupport;
+use crate::chainstate::stacks::db::{
+    ChainstateTx, ClarityTx, DBConfig as ChainstateConfig, MinerPaymentSchedule,
+    MinerPaymentTxFees, MinerRewardInfo, StacksBlockHeaderTypes, StacksChainState, StacksDBTx,
+    StacksEpochReceipt, StacksHeaderInfo,
+};
+use crate::chainstate::stacks::events::{StacksTransactionReceipt, TransactionOrigin};
+use crate::chainstate::stacks::{
+    Error as ChainstateError, StacksBlock, StacksBlockHeader, StacksMicroblock, StacksTransaction,
+    TenureChangeCause, TenureChangeError, TenureChangePayload, ThresholdSignature,
+    TransactionPayload, MINER_BLOCK_CONSENSUS_HASH, MINER_BLOCK_HEADER_HASH,
+};
+use crate::clarity::vm::clarity::{ClarityConnection, TransactionConnection};
+use crate::clarity_vm::clarity::{
+    ClarityInstance, ClarityTransactionConnection, PreCommitClarityBlock,
+};
+use crate::clarity_vm::database::SortitionDBRef;
+use crate::core::BOOT_BLOCK_HASH;
+use crate::net::stackerdb::StackerDBConfig;
+use crate::net::Error as net_error;
+use crate::util_lib::boot;
+use crate::util_lib::boot::boot_code_id;
+use crate::util_lib::db::{
+    query_int, query_row, query_row_panic, query_rows, u64_to_sql, DBConn, Error as DBError,
+    FromRow,
+};
+use crate::{chainstate, monitoring};
+
+pub struct NakamotoSigners();
+
+pub struct SignerCalculation {
+    pub reward_set: RewardSet,
+    pub events: Vec<StacksTransactionEvent>,
+}
+
+impl RawRewardSetEntry {
+    pub fn from_pox_4_tuple(is_mainnet: bool, tuple: TupleData) -> Self {
+        let mut tuple_data = tuple.data_map;
+
+        let pox_addr_tuple = tuple_data
+            .remove("pox-addr")
+            .expect("FATAL: no `pox-addr` in return value from (get-reward-set-pox-address)");
+
+        let reward_address = PoxAddress::try_from_pox_tuple(is_mainnet, &pox_addr_tuple)
+            .expect(&format!("FATAL: not a valid PoX address: {pox_addr_tuple}"));
+
+        let total_ustx = tuple_data
+            .remove("total-ustx")
+            .expect(
+                "FATAL: no 'total-ustx' in return value from (pox-4.get-reward-set-pox-address)",
+            )
+            .expect_u128();
+
+        let stacker = tuple_data
+            .remove("stacker")
+            .expect("FATAL: no 'stacker' in return value from (pox-4.get-reward-set-pox-address)")
+            .expect_optional()
+            .map(|value| value.expect_principal());
+
+        let signer = tuple_data
+            .remove("signer")
+            .expect("FATAL: no 'signer' in return value from (pox-4.get-reward-set-pox-address)")
+            .expect_buff(SIGNERS_PK_LEN);
+
+        // (buff 33) only enforces max size, not min size, so we need to do a len check
+        let pk_bytes = if signer.len() == SIGNERS_PK_LEN {
+            let mut bytes = [0; SIGNERS_PK_LEN];
+            bytes.copy_from_slice(signer.as_slice());
+            bytes
+        } else {
+            [0; SIGNERS_PK_LEN]
+        };
+
+        debug!(
+            "Parsed PoX reward address";
+            "stacked_ustx" => total_ustx,
+            "reward_address" => %reward_address,
+            "stacker" => ?stacker,
+            "signer" => to_hex(&signer),
+        );
+
+        Self {
+            reward_address,
+            amount_stacked: total_ustx,
+            stacker,
+            signer: Some(pk_bytes),
+        }
+    }
+}
+
+impl NakamotoSigners {
+    fn get_reward_slots(
+        clarity: &mut ClarityTransactionConnection,
+        reward_cycle: u64,
+        pox_contract: &str,
+    ) -> Result<Vec<RawRewardSetEntry>, ChainstateError> {
+        let is_mainnet = clarity.is_mainnet();
+        if !matches!(
+            PoxVersions::lookup_by_name(pox_contract),
+            Some(PoxVersions::Pox4)
+        ) {
+            error!("Invoked Nakamoto reward-set fetch on non-pox-4 contract");
+            return Err(ChainstateError::DefunctPoxContract);
+        }
+        let pox_contract = &boot_code_id(pox_contract, is_mainnet);
+
+        let list_length = clarity
+            .eval_method_read_only(
+                pox_contract,
+                "get-reward-set-size",
+                &[SymbolicExpression::atom_value(Value::UInt(
+                    reward_cycle.into(),
+                ))],
+            )?
+            .expect_u128();
+
+        let mut slots = vec![];
+        for index in 0..list_length {
+            let tuple = clarity
+                .eval_method_read_only(
+                    pox_contract,
+                    "get-reward-set-pox-address",
+                    &[
+                        SymbolicExpression::atom_value(Value::UInt(reward_cycle.into())),
+                        SymbolicExpression::atom_value(Value::UInt(index)),
+                    ],
+                )?
+                .expect_optional()
+                .expect(&format!(
+                    "FATAL: missing PoX address in slot {} out of {} in reward cycle {}",
+                    index, list_length, reward_cycle
+                ))
+                .expect_tuple();
+
+            let entry = RawRewardSetEntry::from_pox_4_tuple(is_mainnet, tuple);
+
+            slots.push(entry)
+        }
+
+        Ok(slots)
+    }
+
+    pub fn handle_signer_stackerdb_update(
+        clarity: &mut ClarityTransactionConnection,
+        pox_constants: &PoxConstants,
+        reward_cycle: u64,
+        pox_contract: &str,
+        coinbase_height: u64,
+    ) -> Result<SignerCalculation, ChainstateError> {
+        let is_mainnet = clarity.is_mainnet();
+        let sender_addr = PrincipalData::from(boot::boot_code_addr(is_mainnet));
+        let signers_contract = &boot_code_id(SIGNERS_NAME, is_mainnet);
+
+        let liquid_ustx = clarity.with_clarity_db_readonly(|db| db.get_total_liquid_ustx());
+        let reward_slots = Self::get_reward_slots(clarity, reward_cycle, pox_contract)?;
+        let (threshold, participation) = StacksChainState::get_reward_threshold_and_participation(
+            &pox_constants,
+            &reward_slots[..],
+            liquid_ustx,
+        );
+        let reward_set =
+            StacksChainState::make_reward_set(threshold, reward_slots, StacksEpochId::Epoch30);
+
+        let signers_list = if participation == 0 {
+            vec![]
+        } else {
+            reward_set
+                .signers
+                .as_ref()
+                .ok_or(ChainstateError::PoxNoRewardCycle)?
+                .iter()
+                .map(|signer| {
+                    let signer_hash = Hash160::from_data(&signer.signing_key);
+                    let signing_address = StacksAddress::p2pkh_from_hash(is_mainnet, signer_hash);
+                    Value::Tuple(
+                        TupleData::from_data(vec![
+                            (
+                                "signer".into(),
+                                Value::Principal(PrincipalData::from(signing_address)),
+                            ),
+                            ("num-slots".into(), Value::UInt(signer.slots.into())),
+                        ])
+                            .expect(
+                                "BUG: Failed to construct `{ signer: principal, num-slots: u64 }` tuple",
+                            ),
+                    )
+                })
+                .collect()
+        };
+        if signers_list.len() > SIGNERS_MAX_LIST_SIZE {
+            panic!(
+                "FATAL: signers list returned by reward set calculations longer than maximum ({} > {})",
+                signers_list.len(),
+                SIGNERS_MAX_LIST_SIZE,
+            );
+        }
+
+        let args = [
+            SymbolicExpression::atom_value(Value::cons_list_unsanitized(signers_list).expect(
+                "BUG: Failed to construct `(list 4000 { signer: principal, num-slots: u64 })` list",
+            )),
+            SymbolicExpression::atom_value(Value::UInt(reward_cycle.into())),
+            SymbolicExpression::atom_value(Value::UInt(coinbase_height.into())),
+        ];
+
+        let (value, _, events, _) = clarity
+            .with_abort_callback(
+                |vm_env| {
+                    vm_env.execute_in_env(sender_addr.clone(), None, None, |env| {
+                        env.execute_contract_allow_private(
+                            &signers_contract,
+                            "stackerdb-set-signer-slots",
+                            &args,
+                            false,
+                        )
+                    })
+                },
+                |_, _| false,
+            )
+            .expect("FATAL: failed to update signer stackerdb");
+
+        if let Value::Response(ref data) = value {
+            if !data.committed {
+                error!(
+                    "Error while updating .signers contract";
+                    "reward_cycle" => reward_cycle,
+                    "cc_response" => %value,
+                );
+                panic!();
+            }
+        }
+
+        Ok(SignerCalculation { events, reward_set })
+    }
+
+    pub fn check_and_handle_prepare_phase_start(
+        clarity_tx: &mut ClarityTx,
+        first_block_height: u64,
+        pox_constants: &PoxConstants,
+        burn_tip_height: u64,
+        coinbase_height: u64,
+    ) -> Result<Option<SignerCalculation>, ChainstateError> {
+        let current_epoch = clarity_tx.get_epoch();
+        if current_epoch < StacksEpochId::Epoch25 {
+            // before Epoch-2.5, no need for special handling
+            return Ok(None);
+        }
+        // now, determine if we are in a prepare phase, and we are the first
+        //  block in this prepare phase in our fork
+        if !pox_constants.is_in_prepare_phase(first_block_height, burn_tip_height) {
+            // if we're not in a prepare phase, don't need to do anything
+            return Ok(None);
+        }
+
+        let Some(cycle_of_prepare_phase) =
+            pox_constants.reward_cycle_of_prepare_phase(first_block_height, burn_tip_height)
+        else {
+            // if we're not in a prepare phase, don't need to do anything
+            return Ok(None);
+        };
+
+        let active_pox_contract = pox_constants.active_pox_contract(burn_tip_height);
+        if !matches!(
+            PoxVersions::lookup_by_name(active_pox_contract),
+            Some(PoxVersions::Pox4)
+        ) {
+            debug!(
+                "Active PoX contract is not PoX-4, skipping .signers updates until PoX-4 is active"
+            );
+            return Ok(None);
+        }
+
+        let signers_contract = &boot_code_id(SIGNERS_NAME, clarity_tx.config.mainnet);
+
+        // are we the first block in the prepare phase in our fork?
+        let needs_update = clarity_tx.connection().with_clarity_db_readonly(|clarity_db| {
+            if !clarity_db.has_contract(signers_contract) {
+                // if there's no signers contract, no need to update anything.
+                return false
+            }
+            let Ok(value) = clarity_db.lookup_variable_unknown_descriptor(
+                signers_contract,
+                SIGNERS_UPDATE_STATE,
+                &current_epoch,
+            ) else {
+                error!("FATAL: Failed to read `{SIGNERS_UPDATE_STATE}` variable from .signers contract");
+                panic!();
+            };
+            let cycle_number = value.expect_u128();
+            // if the cycle_number is less than `cycle_of_prepare_phase`, we need to update
+            //  the .signers state.
+            cycle_number < cycle_of_prepare_phase.into()
+        });
+
+        if !needs_update {
+            debug!("Current cycle has already been setup in .signers or .signers is not initialized yet");
+            return Ok(None);
+        }
+
+        info!(
+            "Performing .signers state update";
+            "burn_height" => burn_tip_height,
+            "for_cycle" => cycle_of_prepare_phase,
+            "signers_contract" => %signers_contract,
+        );
+
+        clarity_tx
+            .connection()
+            .as_free_transaction(|clarity| {
+                Self::handle_signer_stackerdb_update(
+                    clarity,
+                    &pox_constants,
+                    cycle_of_prepare_phase,
+                    active_pox_contract,
+                    coinbase_height,
+                )
+            })
+            .map(|calculation| Some(calculation))
+    }
+}
diff --git a/stackslib/src/chainstate/nakamoto/tests/mod.rs b/stackslib/src/chainstate/nakamoto/tests/mod.rs
index 9df80e73f9..07a6ec533a 100644
--- a/stackslib/src/chainstate/nakamoto/tests/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/mod.rs
@@ -52,7 +52,7 @@ use crate::chainstate::coordinator::tests::{
 use crate::chainstate::nakamoto::coordinator::tests::boot_nakamoto;
 use crate::chainstate::nakamoto::miner::NakamotoBlockBuilder;
 use crate::chainstate::nakamoto::tenure::NakamotoTenure;
-use crate::chainstate::nakamoto::tests::node::TestSigners;
+use crate::chainstate::nakamoto::tests::node::{TestSigners, TestStacker};
 use crate::chainstate::nakamoto::{
     NakamotoBlock, NakamotoBlockHeader, NakamotoChainState, FIRST_STACKS_BLOCK_ID,
 };
@@ -1502,7 +1502,8 @@ fn make_fork_run_with_arrivals(
 #[test]
 pub fn test_get_highest_nakamoto_tenure() {
     let test_signers = TestSigners::default();
-    let mut peer = boot_nakamoto(function_name!(), vec![], &test_signers, None, None);
+    let test_stackers = TestStacker::common_signing_set(&test_signers);
+    let mut peer = boot_nakamoto(function_name!(), vec![], &test_signers, &test_stackers, None);
 
     // extract chainstate and sortdb -- we don't need the peer anymore
     let chainstate = &mut peer.stacks_node.as_mut().unwrap().chainstate;
@@ -1644,7 +1645,8 @@ pub fn test_get_highest_nakamoto_tenure() {
 #[test]
 fn test_make_miners_stackerdb_config() {
     let test_signers = TestSigners::default();
-    let mut peer = boot_nakamoto(function_name!(), vec![], &test_signers, None, None);
+    let test_stackers = TestStacker::common_signing_set(&test_signers);
+    let mut peer = boot_nakamoto(function_name!(), vec![], &test_signers, &test_stackers, None);
 
     let naka_miner_hash160 = peer.miner.nakamoto_miner_hash160();
     let miner_keys: Vec<_> = (0..10).map(|_| StacksPrivateKey::new()).collect();
diff --git a/stackslib/src/chainstate/nakamoto/tests/node.rs b/stackslib/src/chainstate/nakamoto/tests/node.rs
index ac71cf6721..e50838a1d1 100644
--- a/stackslib/src/chainstate/nakamoto/tests/node.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/node.rs
@@ -74,6 +74,7 @@ pub struct TestStacker {
 }
 
 impl TestStacker {
+    pub const DEFAULT_STACKER_AMOUNT: u128 = 1_000_000_000_000_000_000;
     pub fn from_seed(seed: &[u8]) -> TestStacker {
         let stacker_private_key = StacksPrivateKey::from_seed(seed);
         let mut signer_seed = seed.to_vec();
@@ -89,6 +90,21 @@ impl TestStacker {
     pub fn signer_public_key(&self) -> StacksPublicKey {
         StacksPublicKey::from_private(&self.signer_private_key)
     }
+
+    /// make a set of stackers who will share a single signing key and stack with
+    /// `Self::DEFAULT_STACKER_AMOUNT`
+    pub fn common_signing_set(test_signers: &TestSigners) -> Vec<TestStacker> {
+        let mut signing_key_seed = test_signers.num_keys.to_be_bytes().to_vec();
+        signing_key_seed.extend_from_slice(&[1, 1, 1, 1]);
+        let signing_key = StacksPrivateKey::from_seed(signing_key_seed.as_slice());
+        (0..test_signers.num_keys)
+            .map(|index| TestStacker {
+                signer_private_key: signing_key.clone(),
+                stacker_private_key: StacksPrivateKey::from_seed(&index.to_be_bytes()),
+                amount: Self::DEFAULT_STACKER_AMOUNT,
+            })
+            .collect()
+    }
 }
 
 #[derive(Debug, Clone)]
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index f4b57ab470..25349c3bde 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -257,6 +257,16 @@ impl RewardSet {
             signers: None,
         }
     }
+
+    /// Serialization used when stored as ClarityDB metadata
+    pub fn metadata_serialize(&self) -> String {
+        serde_json::to_string(self).expect("FATAL: failure to serialize RewardSet struct")
+    }
+
+    /// Deserializer corresponding to `RewardSet::metadata_serialize`
+    pub fn metadata_deserialize(from: &str) -> Result<RewardSet, String> {
+        serde_json::from_str(from).map_err(|e| e.to_string())
+    }
 }
 
 impl StacksChainState {
@@ -514,7 +524,7 @@ impl StacksChainState {
         Ok(total_events)
     }
 
-    fn eval_boot_code_read_only(
+    pub fn eval_boot_code_read_only(
         &mut self,
         sortdb: &SortitionDB,
         stacks_block_id: &StacksBlockId,
@@ -1152,63 +1162,9 @@ impl StacksChainState {
                 ))
                 .expect_tuple();
 
-            let pox_addr_tuple = tuple
-                .get("pox-addr")
-                .expect(&format!("FATAL: no `pox-addr` in return value from (get-reward-set-pox-address u{} u{})", reward_cycle, i))
-                .to_owned();
-
-            let reward_address = PoxAddress::try_from_pox_tuple(self.mainnet, &pox_addr_tuple)
-                .expect(&format!(
-                    "FATAL: not a valid PoX address: {:?}",
-                    &pox_addr_tuple
-                ));
-
-            let total_ustx = tuple
-                .get("total-ustx")
-                .expect(&format!("FATAL: no 'total-ustx' in return value from (get-reward-set-pox-address u{} u{})", reward_cycle, i))
-                .to_owned()
-                .expect_u128();
-
-            let stacker = tuple
-                .get("stacker")
-                .expect(&format!(
-                    "FATAL: no 'stacker' in return value from (get-reward-set-pox-address u{} u{})",
-                    reward_cycle, i
-                ))
-                .to_owned()
-                .expect_optional()
-                .map(|value| value.expect_principal());
-
-            let signer = tuple
-                .get("signer")
-                .expect(&format!(
-                    "FATAL: no 'signer' in return value from (get-reward-set-pox-address u{} u{})",
-                    reward_cycle, i
-                ))
-                .to_owned()
-                .expect_buff(SIGNERS_PK_LEN);
-            // (buff 33) only enforces max size, not min size, so we need to do a len check
-            let pk_bytes = if signer.len() == SIGNERS_PK_LEN {
-                let mut bytes = [0; SIGNERS_PK_LEN];
-                bytes.copy_from_slice(signer.as_slice());
-                bytes
-            } else {
-                [0; SIGNERS_PK_LEN]
-            };
+            let entry = RawRewardSetEntry::from_pox_4_tuple(self.mainnet, tuple);
 
-            debug!(
-                "Parsed PoX reward address";
-                "stacked_ustx" => total_ustx,
-                "reward_address" => %reward_address,
-                "stacker" => ?stacker,
-                "signer" => ?signer
-            );
-            ret.push(RawRewardSetEntry {
-                reward_address,
-                amount_stacked: total_ustx,
-                stacker,
-                signer: Some(pk_bytes),
-            })
+            ret.push(entry)
         }
 
         Ok(ret)
diff --git a/stackslib/src/chainstate/stacks/boot/signers.clar b/stackslib/src/chainstate/stacks/boot/signers.clar
index a901dc0f94..71adb33bd7 100644
--- a/stackslib/src/chainstate/stacks/boot/signers.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers.clar
@@ -1,12 +1,15 @@
 (define-data-var last-set-cycle uint u0)
 (define-data-var stackerdb-signer-slots (list 4000 { signer: principal, num-slots: uint }) (list))
+(define-map cycle-set-height uint uint)
 (define-constant MAX_WRITES u340282366920938463463374607431768211455)
 (define-constant CHUNK_SIZE (* u2 u1024 u1024))
 
 (define-private (stackerdb-set-signer-slots 
                    (signer-slots (list 4000 { signer: principal, num-slots: uint }))
-                   (reward-cycle uint))
+                   (reward-cycle uint)
+                   (set-at-height uint))
 	(begin
+        (map-set cycle-set-height reward-cycle set-at-height)
         (var-set last-set-cycle reward-cycle)
 		(ok (var-set stackerdb-signer-slots signer-slots))))
 
diff --git a/stackslib/src/chainstate/stacks/boot/signers_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_tests.rs
index bcd47d4177..900f5a215a 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_tests.rs
@@ -202,7 +202,7 @@ fn signers_get_signer_keys_from_stackerdb() {
     let (mut peer, test_signers, latest_block_id, _) = prepare_signers_test(
         function_name!(),
         vec![],
-        Some(vec![&stacker_1, &stacker_2]),
+        &[stacker_1.clone(), stacker_2.clone()],
         None,
     );
 
@@ -248,7 +248,7 @@ fn signers_get_signer_keys_from_stackerdb() {
 pub fn prepare_signers_test<'a>(
     test_name: &str,
     initial_balances: Vec<(PrincipalData, u64)>,
-    stackers: Option<Vec<&TestStacker>>,
+    stackers: &[TestStacker],
     observer: Option<&'a TestEventObserver>,
 ) -> (TestPeer<'a>, TestSigners, StacksBlockId, u128) {
     let mut test_signers = TestSigners::default();
diff --git a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
index f31ced3e06..d4634d7ec0 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
@@ -149,7 +149,7 @@ fn vote_for_aggregate_public_key_in_first_block() {
     let (mut peer, mut test_signers, latest_block_id, current_reward_cycle) = prepare_signers_test(
         function_name!(),
         vec![(signer, 1000)],
-        Some(vec![&stacker_1, &stacker_2]),
+        &[stacker_1.clone(), stacker_2.clone()],
         Some(&observer),
     );
 
@@ -236,7 +236,7 @@ fn vote_for_aggregate_public_key_in_last_block() {
     let (mut peer, mut test_signers, latest_block_id, current_reward_cycle) = prepare_signers_test(
         function_name!(),
         vec![(signer_1, 1000), (signer_2, 1000)],
-        Some(vec![&stacker_1, &stacker_2]),
+        &[stacker_1.clone(), stacker_2.clone()],
         Some(&observer),
     );
 
diff --git a/stackslib/src/chainstate/stacks/db/blocks.rs b/stackslib/src/chainstate/stacks/db/blocks.rs
index 4deeb57443..51f708c63a 100644
--- a/stackslib/src/chainstate/stacks/db/blocks.rs
+++ b/stackslib/src/chainstate/stacks/db/blocks.rs
@@ -52,6 +52,7 @@ use crate::chainstate::burn::db::sortdb::*;
 use crate::chainstate::burn::operations::*;
 use crate::chainstate::burn::BlockSnapshot;
 use crate::chainstate::coordinator::BlockEventDispatcher;
+use crate::chainstate::nakamoto::signer_set::{NakamotoSigners, SignerCalculation};
 use crate::chainstate::nakamoto::NakamotoChainState;
 use crate::chainstate::stacks::address::{PoxAddress, StacksAddressExtensions};
 use crate::chainstate::stacks::db::accounts::MinerReward;
@@ -168,6 +169,8 @@ pub struct SetupBlockResult<'a, 'b> {
     pub burn_transfer_stx_ops: Vec<TransferStxOp>,
     pub auto_unlock_events: Vec<StacksTransactionEvent>,
     pub burn_delegate_stx_ops: Vec<DelegateStxOp>,
+    /// Result of a signer set calculation if one occurred
+    pub signer_set_calc: Option<SignerCalculation>,
 }
 
 pub struct DummyEventDispatcher;
@@ -5142,13 +5145,17 @@ impl StacksChainState {
 
         // Handle signer stackerdb updates
         let first_block_height = burn_dbconn.get_burn_start_height();
+        let signer_set_calc;
         if evaluated_epoch >= StacksEpochId::Epoch25 {
-            let _events = NakamotoChainState::check_and_handle_prepare_phase_start(
+            signer_set_calc = NakamotoSigners::check_and_handle_prepare_phase_start(
                 &mut clarity_tx,
                 first_block_height.into(),
                 &pox_constants,
                 burn_tip_height.into(),
+                chain_tip.stacks_block_height,
             )?;
+        } else {
+            signer_set_calc = None;
         }
 
         debug!(
@@ -5170,6 +5177,7 @@ impl StacksChainState {
             burn_transfer_stx_ops: transfer_burn_ops,
             auto_unlock_events,
             burn_delegate_stx_ops: delegate_burn_ops,
+            signer_set_calc,
         })
     }
 
@@ -5365,6 +5373,7 @@ impl StacksChainState {
             burn_transfer_stx_ops,
             mut auto_unlock_events,
             burn_delegate_stx_ops,
+            signer_set_calc,
         } = StacksChainState::setup_block(
             chainstate_tx,
             clarity_instance,
@@ -5664,6 +5673,18 @@ impl StacksChainState {
 
         chainstate_tx.log_transactions_processed(&new_tip.index_block_hash(), &tx_receipts);
 
+        // store the reward set calculated during this block if it happened
+        // NOTE: miner and proposal evaluation should not invoke this because
+        //  it depends on knowing the StacksBlockId.
+        if let Some(signer_calculation) = signer_set_calc {
+            let new_block_id = new_tip.index_block_hash();
+            NakamotoChainState::write_reward_set(
+                chainstate_tx,
+                &new_block_id,
+                &signer_calculation.reward_set,
+            )?
+        }
+
         set_last_block_transaction_count(
             u64::try_from(block.txs.len()).expect("more than 2^64 txs"),
         );

From d4c3519d1baf8af1241ff09fbec5d3a9c351f4de Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Mon, 29 Jan 2024 15:17:10 -0600
Subject: [PATCH 0542/1166] feat: add `stacker_set` RPC endpoint

* expand e2e correct_burns test to invoke the new RPC endpoint
* fix reward-set storage information to write correct coinbase height
---
 CHANGELOG.md                                  |   1 +
 .../get_stacker_set.400.example.json          |   4 +
 .../core-node/get_stacker_set.example.json    |  25 ++
 docs/rpc/openapi.yaml                         |  24 ++
 stackslib/src/chainstate/coordinator/mod.rs   |   1 +
 .../chainstate/nakamoto/coordinator/mod.rs    |  65 ++++-
 stackslib/src/chainstate/nakamoto/mod.rs      |   2 +-
 .../src/chainstate/nakamoto/signer_set.rs     |   1 +
 stackslib/src/chainstate/stacks/db/blocks.rs  |  33 +--
 stackslib/src/net/api/getstackers.rs          | 225 ++++++++++++++++++
 stackslib/src/net/api/mod.rs                  |   2 +
 .../src/tests/nakamoto_integrations.rs        |  34 ++-
 12 files changed, 385 insertions(+), 32 deletions(-)
 create mode 100644 docs/rpc/api/core-node/get_stacker_set.400.example.json
 create mode 100644 docs/rpc/api/core-node/get_stacker_set.example.json
 create mode 100644 stackslib/src/net/api/getstackers.rs

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 71827d9d5f..49169bb95a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,6 +9,7 @@ and this project adheres to the versioning scheme outlined in the [README.md](RE
 
 ### Added
 
+- New RPC endpoint `/v2/stacker_set/{cycle_number}` to fetch stacker sets in PoX-4
 - New `/new_pox_anchor` endpoint for broadcasting PoX anchor block processing.
 - Stacker bitvec in NakamotoBlock
 
diff --git a/docs/rpc/api/core-node/get_stacker_set.400.example.json b/docs/rpc/api/core-node/get_stacker_set.400.example.json
new file mode 100644
index 0000000000..0ca1688c68
--- /dev/null
+++ b/docs/rpc/api/core-node/get_stacker_set.400.example.json
@@ -0,0 +1,4 @@
+{
+  "response": "error",
+  "err_msg": "Could not read reward set. Prepare phase may not have started for this cycle yet. Cycle = 22, Err= PoXAnchorBlockRequired"
+}
diff --git a/docs/rpc/api/core-node/get_stacker_set.example.json b/docs/rpc/api/core-node/get_stacker_set.example.json
new file mode 100644
index 0000000000..1bcd3fad59
--- /dev/null
+++ b/docs/rpc/api/core-node/get_stacker_set.example.json
@@ -0,0 +1,25 @@
+{
+  "stacker_set": {
+    "rewarded_addresses": [
+      {
+        "Standard": [
+          {
+            "bytes": "dc5f18421006ee2b98ab972edfa7268a981e3f00",
+            "version": 26
+          },
+          "SerializeP2PKH"
+        ]
+      }
+    ],
+    "signers": [
+      {
+        "signing_key": "02d0a27e4f1bf186b4391eecfcc4d4a0d403684ad089b477b8548a69dd6378bf26",
+        "slots": 1,
+        "stacked_amt": 2143020000000000
+      }
+    ],
+    "start_cycle_state": {
+      "missed_reward_slots": []
+    }
+  }
+}
diff --git a/docs/rpc/openapi.yaml b/docs/rpc/openapi.yaml
index d554b96242..6018a61ba3 100644
--- a/docs/rpc/openapi.yaml
+++ b/docs/rpc/openapi.yaml
@@ -583,3 +583,27 @@ paths:
           application/json:
             example:
               $ref: ./api/core-node/post-block-proposal-req.example.json
+
+  /v2/stacker_set/{cycle_number}:
+    get:
+      summary: Fetch the stacker and signer set information for a given cycle.
+      tags:
+        - Mining
+      operationId: get_stacker_set
+      description: |
+        Used to get stacker and signer set information for a given cycle.
+
+        This will only return information for cycles started in Epoch-2.5 where PoX-4 was active.
+      responses:
+        200:
+          description: Information for the given reward cycle
+          content:
+            application/json:
+              example:
+                $ref: ./api/core-node/get_stacker_set.example.json
+        400:
+          description: Could not fetch the given reward set
+          content:
+            application/json:
+              example:
+                $ref: ./api/core-node/get_stacker_set.400.example.json
diff --git a/stackslib/src/chainstate/coordinator/mod.rs b/stackslib/src/chainstate/coordinator/mod.rs
index 3bc1f890a5..66bc70a4c4 100644
--- a/stackslib/src/chainstate/coordinator/mod.rs
+++ b/stackslib/src/chainstate/coordinator/mod.rs
@@ -380,6 +380,7 @@ impl<'a, T: BlockEventDispatcher> RewardSetProvider for OnChainRewardSetProvider
             burnchain,
             sortdb,
             block_id,
+            false,
         )
     }
 }
diff --git a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
index c24ceca34f..68976d6283 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
@@ -55,6 +55,9 @@ pub mod tests;
 
 impl<'a, T: BlockEventDispatcher> OnChainRewardSetProvider<'a, T> {
     /// Read a reward_set written while updating .signers
+    /// `debug_log` should be set to true if the reward set loading should
+    ///  log messages as `debug!` instead of `error!` or `info!`. This allows
+    ///  RPC endpoints to expose this without flooding loggers.
     pub fn read_reward_set_nakamoto(
         &self,
         cycle_start_burn_height: u64,
@@ -62,6 +65,7 @@ impl<'a, T: BlockEventDispatcher> OnChainRewardSetProvider<'a, T> {
         burnchain: &Burnchain,
         sortdb: &SortitionDB,
         block_id: &StacksBlockId,
+        debug_log: bool,
     ) -> Result<RewardSet, Error> {
         let cycle = burnchain
             .block_height_to_reward_cycle(cycle_start_burn_height)
@@ -77,10 +81,17 @@ impl<'a, T: BlockEventDispatcher> OnChainRewardSetProvider<'a, T> {
             .expect_optional()
             .map(|x| u64::try_from(x.expect_u128()).expect("FATAL: block height exceeded u64"))
         else {
-            error!(
-                "The reward set was not written to .signers before it was needed by Nakamoto";
-                "cycle_number" => cycle,
-            );
+            if debug_log {
+                debug!(
+                    "The reward set was not written to .signers before it was needed by Nakamoto";
+                    "cycle_number" => cycle,
+                );
+            } else {
+                error!(
+                    "The reward set was not written to .signers before it was needed by Nakamoto";
+                    "cycle_number" => cycle,
+                );
+            }
             return Err(Error::PoXAnchorBlockRequired);
         };
 
@@ -90,7 +101,11 @@ impl<'a, T: BlockEventDispatcher> OnChainRewardSetProvider<'a, T> {
             coinbase_height_of_calculation,
         )?
         else {
-            error!("Failed to find the block in which .signers was written");
+            if debug_log {
+                debug!("Failed to find the block in which .signers was written");
+            } else {
+                error!("Failed to find the block in which .signers was written");
+            }
             return Err(Error::PoXAnchorBlockRequired);
         };
 
@@ -99,7 +114,18 @@ impl<'a, T: BlockEventDispatcher> OnChainRewardSetProvider<'a, T> {
             &reward_set_block.index_block_hash(),
         )?
         else {
-            error!("No reward set stored at the block in which .signers was written");
+            if debug_log {
+                debug!(
+                    "No reward set stored at the block in which .signers was written";
+                    "checked_block" => %reward_set_block.index_block_hash()
+                );
+            } else {
+                error!(
+                    "No reward set stored at the block in which .signers was written";
+                    "checked_block" => %reward_set_block.index_block_hash(),
+                    "coinbase_height_of_calculation" => coinbase_height_of_calculation,
+                );
+            }
             return Err(Error::PoXAnchorBlockRequired);
         };
 
@@ -108,17 +134,32 @@ impl<'a, T: BlockEventDispatcher> OnChainRewardSetProvider<'a, T> {
         //  Non participation is fatal.
         if reward_set.rewarded_addresses.is_empty() {
             // no one is stacking
-            error!("No PoX participation");
+            if debug_log {
+                debug!("No PoX participation");
+            } else {
+                error!("No PoX participation");
+            }
             return Err(Error::PoXAnchorBlockRequired);
         }
 
-        info!(
-            "PoX reward set loaded from written block state";
-            "reward_set_block_id" => %reward_set_block.index_block_hash(),
-        );
+        if debug_log {
+            debug!(
+                "PoX reward set loaded from written block state";
+                "reward_set_block_id" => %reward_set_block.index_block_hash(),
+            );
+        } else {
+            info!(
+                "PoX reward set loaded from written block state";
+                "reward_set_block_id" => %reward_set_block.index_block_hash(),
+            );
+        }
 
         if reward_set.signers.is_none() {
-            error!("FATAL: PoX reward set did not specify signer set in Nakamoto");
+            if debug_log {
+                debug!("FATAL: PoX reward set did not specify signer set in Nakamoto");
+            } else {
+                error!("FATAL: PoX reward set did not specify signer set in Nakamoto");
+            }
             return Err(Error::PoXAnchorBlockRequired);
         }
 
diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index 2ce0307bd9..70b7428bcb 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -2511,7 +2511,7 @@ impl NakamotoChainState {
                 Self::calculate_matured_miner_rewards(
                     &mut clarity_tx,
                     sortition_dbconn.sqlite_conn(),
-                    coinbase_height,
+                    coinbase_height + 1,
                     matured_rewards_schedule,
                 )
             })
diff --git a/stackslib/src/chainstate/nakamoto/signer_set.rs b/stackslib/src/chainstate/nakamoto/signer_set.rs
index e0ac40199d..261133e3f2 100644
--- a/stackslib/src/chainstate/nakamoto/signer_set.rs
+++ b/stackslib/src/chainstate/nakamoto/signer_set.rs
@@ -367,6 +367,7 @@ impl NakamotoSigners {
             "Performing .signers state update";
             "burn_height" => burn_tip_height,
             "for_cycle" => cycle_of_prepare_phase,
+            "coinbase_height" => coinbase_height,
             "signers_contract" => %signers_contract,
         );
 
diff --git a/stackslib/src/chainstate/stacks/db/blocks.rs b/stackslib/src/chainstate/stacks/db/blocks.rs
index 51f708c63a..89f04db41e 100644
--- a/stackslib/src/chainstate/stacks/db/blocks.rs
+++ b/stackslib/src/chainstate/stacks/db/blocks.rs
@@ -5086,6 +5086,24 @@ impl StacksChainState {
 
         let evaluated_epoch = clarity_tx.get_epoch();
 
+        // Handle signer stackerdb updates
+        // this must happen *before* any state transformations from burn ops, rewards unlocking, etc.
+        // this ensures that the .signers updates will match the PoX anchor block calculation in Epoch 2.5
+        let first_block_height = burn_dbconn.get_burn_start_height();
+        let signer_set_calc;
+        if evaluated_epoch >= StacksEpochId::Epoch25 {
+            signer_set_calc = NakamotoSigners::check_and_handle_prepare_phase_start(
+                &mut clarity_tx,
+                first_block_height.into(),
+                &pox_constants,
+                burn_tip_height.into(),
+                // this is the block height that the write occurs *during*
+                chain_tip.stacks_block_height + 1,
+            )?;
+        } else {
+            signer_set_calc = None;
+        }
+
         let auto_unlock_events = if evaluated_epoch >= StacksEpochId::Epoch21 {
             let unlock_events = Self::check_and_handle_reward_start(
                 burn_tip_height.into(),
@@ -5143,21 +5161,6 @@ impl StacksChainState {
             );
         }
 
-        // Handle signer stackerdb updates
-        let first_block_height = burn_dbconn.get_burn_start_height();
-        let signer_set_calc;
-        if evaluated_epoch >= StacksEpochId::Epoch25 {
-            signer_set_calc = NakamotoSigners::check_and_handle_prepare_phase_start(
-                &mut clarity_tx,
-                first_block_height.into(),
-                &pox_constants,
-                burn_tip_height.into(),
-                chain_tip.stacks_block_height,
-            )?;
-        } else {
-            signer_set_calc = None;
-        }
-
         debug!(
             "Setup block: ready to go for {}/{}",
             &chain_tip.consensus_hash,
diff --git a/stackslib/src/net/api/getstackers.rs b/stackslib/src/net/api/getstackers.rs
new file mode 100644
index 0000000000..f6a41ea0ff
--- /dev/null
+++ b/stackslib/src/net/api/getstackers.rs
@@ -0,0 +1,225 @@
+// Copyright (C) 2024 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+use regex::{Captures, Regex};
+use serde_json::json;
+use stacks_common::types::chainstate::StacksBlockId;
+use stacks_common::types::net::PeerHost;
+use stacks_common::util::hash::Sha256Sum;
+
+use crate::burnchains::Burnchain;
+use crate::chainstate::burn::db::sortdb::SortitionDB;
+use crate::chainstate::coordinator::OnChainRewardSetProvider;
+use crate::chainstate::stacks::boot::{
+    PoxVersions, RewardSet, POX_1_NAME, POX_2_NAME, POX_3_NAME, POX_4_NAME,
+};
+use crate::chainstate::stacks::db::StacksChainState;
+use crate::chainstate::stacks::Error as ChainError;
+use crate::core::mempool::MemPoolDB;
+use crate::net::http::{
+    parse_json, Error, HttpBadRequest, HttpNotFound, HttpRequest, HttpRequestContents,
+    HttpRequestPreamble, HttpResponse, HttpResponseContents, HttpResponsePayload,
+    HttpResponsePreamble, HttpServerError,
+};
+use crate::net::httpcore::{
+    HttpPreambleExtensions, HttpRequestContentsExtensions, RPCRequestHandler, StacksHttp,
+    StacksHttpRequest, StacksHttpResponse,
+};
+use crate::net::p2p::PeerNetwork;
+use crate::net::{Error as NetError, StacksNodeState, TipRequest};
+use crate::util_lib::boot::boot_code_id;
+use crate::util_lib::db::Error as DBError;
+
+#[derive(Clone, Default)]
+pub struct GetStackersRequestHandler {
+    cycle_number: Option<u64>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct GetStackersResponse {
+    pub stacker_set: RewardSet,
+}
+
+impl GetStackersResponse {
+    pub fn load(
+        sortdb: &SortitionDB,
+        chainstate: &mut StacksChainState,
+        tip: &StacksBlockId,
+        burnchain: &Burnchain,
+        cycle_number: u64,
+    ) -> Result<Self, String> {
+        let cycle_start_height = burnchain.reward_cycle_to_block_height(cycle_number);
+
+        let pox_contract_name = burnchain
+            .pox_constants
+            .active_pox_contract(cycle_start_height);
+        let pox_version = PoxVersions::lookup_by_name(pox_contract_name)
+            .ok_or("Failed to lookup PoX contract version at tip")?;
+        if !matches!(pox_version, PoxVersions::Pox4) {
+            return Err(
+                "Active PoX contract version at tip is Pre-PoX-4, the signer set is not fetchable"
+                    .into(),
+            );
+        }
+
+        let provider = OnChainRewardSetProvider::new();
+        let stacker_set = provider.read_reward_set_nakamoto(
+            cycle_start_height,
+            chainstate,
+            burnchain,
+            sortdb,
+            tip,
+            false,
+        ).map_err(
+            |e| format!("Could not read reward set. Prepare phase may not have started for this cycle yet. Cycle = {cycle_number}, Err = {e:?}")
+        )?;
+
+        Ok(Self { stacker_set })
+    }
+}
+
+/// Decode the HTTP request
+impl HttpRequest for GetStackersRequestHandler {
+    fn verb(&self) -> &'static str {
+        "GET"
+    }
+
+    fn path_regex(&self) -> Regex {
+        Regex::new(r#"^/v2/stacker_set/(?P<cycle_num>[0-9]{1,20})$"#).unwrap()
+    }
+
+    /// Try to decode this request.
+    /// There's nothing to load here, so just make sure the request is well-formed.
+    fn try_parse_request(
+        &mut self,
+        preamble: &HttpRequestPreamble,
+        captures: &Captures,
+        query: Option<&str>,
+        _body: &[u8],
+    ) -> Result<HttpRequestContents, Error> {
+        if preamble.get_content_length() != 0 {
+            return Err(Error::DecodeError(
+                "Invalid Http request: expected 0-length body".into(),
+            ));
+        }
+
+        let Some(cycle_num_str) = captures.name("cycle_num") else {
+            return Err(Error::DecodeError(
+                "Missing in request path: `cycle_num`".into(),
+            ));
+        };
+        let cycle_num = u64::from_str_radix(cycle_num_str.into(), 10)
+            .map_err(|e| Error::DecodeError(format!("Failed to parse cycle number: {e}")))?;
+
+        self.cycle_number = Some(cycle_num);
+
+        Ok(HttpRequestContents::new().query_string(query))
+    }
+}
+
+impl RPCRequestHandler for GetStackersRequestHandler {
+    /// Reset internal state
+    fn restart(&mut self) {
+        self.cycle_number = None;
+    }
+
+    /// Make the response
+    fn try_handle_request(
+        &mut self,
+        preamble: HttpRequestPreamble,
+        contents: HttpRequestContents,
+        node: &mut StacksNodeState,
+    ) -> Result<(HttpResponsePreamble, HttpResponseContents), NetError> {
+        let tip = match node.load_stacks_chain_tip(&preamble, &contents) {
+            Ok(tip) => tip,
+            Err(error_resp) => {
+                return error_resp.try_into_contents().map_err(NetError::from);
+            }
+        };
+        let Some(cycle_number) = self.cycle_number.clone() else {
+            return StacksHttpResponse::new_error(
+                    &preamble,
+                    &HttpBadRequest::new_json(json!({"response": "error", "err_msg": "Failed to read cycle number in request"}))
+                )
+                    .try_into_contents()
+                    .map_err(NetError::from);
+        };
+
+        let stacker_response =
+            node.with_node_state(|network, sortdb, chainstate, _mempool, _rpc_args| {
+                GetStackersResponse::load(
+                    sortdb,
+                    chainstate,
+                    &tip,
+                    network.get_burnchain(),
+                    cycle_number,
+                )
+            });
+
+        let response = match stacker_response {
+            Ok(response) => response,
+            Err(err_str) => {
+                return StacksHttpResponse::new_error(
+                    &preamble,
+                    &HttpBadRequest::new_json(json!({"response": "error", "err_msg": err_str})),
+                )
+                .try_into_contents()
+                .map_err(NetError::from)
+            }
+        };
+
+        let mut preamble = HttpResponsePreamble::ok_json(&preamble);
+        preamble.set_canonical_stacks_tip_height(Some(node.canonical_stacks_tip_height()));
+        let body = HttpResponseContents::try_from_json(&response)?;
+        Ok((preamble, body))
+    }
+}
+
+impl HttpResponse for GetStackersRequestHandler {
+    fn try_parse_response(
+        &self,
+        preamble: &HttpResponsePreamble,
+        body: &[u8],
+    ) -> Result<HttpResponsePayload, Error> {
+        let response: GetStackersResponse = parse_json(preamble, body)?;
+        Ok(HttpResponsePayload::try_from_json(response)?)
+    }
+}
+
+impl StacksHttpRequest {
+    /// Make a new getinfo request to this endpoint
+    pub fn new_getstackers(
+        host: PeerHost,
+        cycle_num: u64,
+        tip_req: TipRequest,
+    ) -> StacksHttpRequest {
+        StacksHttpRequest::new_for_peer(
+            host,
+            "GET".into(),
+            format!("/v2/stacker_set/{cycle_num}"),
+            HttpRequestContents::new().for_tip(tip_req),
+        )
+        .expect("FATAL: failed to construct request from infallible data")
+    }
+}
+
+impl StacksHttpResponse {
+    pub fn decode_stacker_set(self) -> Result<GetStackersResponse, NetError> {
+        let contents = self.get_http_payload_ok()?;
+        let response_json: serde_json::Value = contents.try_into()?;
+        let response: GetStackersResponse = serde_json::from_value(response_json)
+            .map_err(|_e| Error::DecodeError("Failed to decode JSON".to_string()))?;
+        Ok(response)
+    }
+}
diff --git a/stackslib/src/net/api/mod.rs b/stackslib/src/net/api/mod.rs
index 5c8f6d9cf1..d3644fe23b 100644
--- a/stackslib/src/net/api/mod.rs
+++ b/stackslib/src/net/api/mod.rs
@@ -53,6 +53,7 @@ pub mod getneighbors;
 pub mod getpoxinfo;
 pub mod getstackerdbchunk;
 pub mod getstackerdbmetadata;
+pub mod getstackers;
 pub mod getstxtransfercost;
 pub mod gettransaction_unconfirmed;
 pub mod postblock;
@@ -114,6 +115,7 @@ impl StacksHttp {
         self.register_rpc_endpoint(postmicroblock::RPCPostMicroblockRequestHandler::new());
         self.register_rpc_endpoint(poststackerdbchunk::RPCPostStackerDBChunkRequestHandler::new());
         self.register_rpc_endpoint(posttransaction::RPCPostTransactionRequestHandler::new());
+        self.register_rpc_endpoint(getstackers::GetStackersRequestHandler::default());
     }
 }
 
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 1bb94f6030..d20e2ac582 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -38,6 +38,7 @@ use stacks::core::{
     PEER_VERSION_EPOCH_2_1, PEER_VERSION_EPOCH_2_2, PEER_VERSION_EPOCH_2_3, PEER_VERSION_EPOCH_2_4,
     PEER_VERSION_EPOCH_2_5, PEER_VERSION_EPOCH_3_0,
 };
+use stacks::net::api::getstackers::GetStackersResponse;
 use stacks::net::api::postblock_proposal::{
     BlockValidateReject, BlockValidateResponse, NakamotoBlockProposal, ValidateRejectCode,
 };
@@ -133,6 +134,20 @@ lazy_static! {
     ];
 }
 
+pub fn get_stacker_set(http_origin: &str, cycle: u64) -> GetStackersResponse {
+    let client = reqwest::blocking::Client::new();
+    let path = format!("{http_origin}/v2/stacker_set/{cycle}");
+    let res = client
+        .get(&path)
+        .send()
+        .unwrap()
+        .json::<serde_json::Value>()
+        .unwrap();
+    info!("Stacker set response: {res}");
+    let res = serde_json::from_value(res).unwrap();
+    res
+}
+
 pub fn add_initial_balances(
     conf: &mut Config,
     accounts: usize,
@@ -939,6 +954,21 @@ fn correct_burn_outs() {
 
     info!("Bootstrapped to Epoch-3.0 boundary, Epoch2x miner should stop");
 
+    // we should already be able to query the stacker set via RPC
+    let burnchain = naka_conf.get_burnchain();
+    let first_epoch_3_cycle = burnchain
+        .block_height_to_reward_cycle(epoch_3.start_height)
+        .unwrap();
+
+    let http_origin = format!("http://{}", &naka_conf.node.rpc_bind);
+    let stacker_response = get_stacker_set(&http_origin, first_epoch_3_cycle);
+    assert!(stacker_response.stacker_set.signers.is_some());
+    assert_eq!(
+        stacker_response.stacker_set.signers.as_ref().unwrap().len(),
+        1
+    );
+    assert_eq!(stacker_response.stacker_set.rewarded_addresses.len(), 1);
+
     // first block wakes up the run loop, wait until a key registration has been submitted.
     next_block_and(&mut btc_regtest_controller, 60, || {
         let vrf_count = vrfs_submitted.load(Ordering::SeqCst);
@@ -955,7 +985,6 @@ fn correct_burn_outs() {
 
     info!("Bootstrapped to Epoch-3.0 boundary, mining nakamoto blocks");
 
-    let burnchain = naka_conf.get_burnchain();
     let sortdb = burnchain.open_sortition_db(true).unwrap();
 
     // Mine nakamoto tenures
@@ -1001,9 +1030,6 @@ fn correct_burn_outs() {
         "Stacker set should be sorted by cycle number already"
     );
 
-    let first_epoch_3_cycle = burnchain
-        .block_height_to_reward_cycle(epoch_3.start_height)
-        .unwrap();
     for (_, cycle_number, reward_set) in stacker_sets.iter() {
         if *cycle_number < first_epoch_3_cycle {
             assert!(reward_set.signers.is_none());

From b92dcddc20c2c39fddcbfb587ab2e56c007de763 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Tue, 30 Jan 2024 17:04:49 -0600
Subject: [PATCH 0543/1166] fix: no need to bump coinbase height

---
 stackslib/src/chainstate/nakamoto/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index 70b7428bcb..2ce0307bd9 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -2511,7 +2511,7 @@ impl NakamotoChainState {
                 Self::calculate_matured_miner_rewards(
                     &mut clarity_tx,
                     sortition_dbconn.sqlite_conn(),
-                    coinbase_height + 1,
+                    coinbase_height,
                     matured_rewards_schedule,
                 )
             })

From 0ace4d0081e716f3cb43cd55fb539c618b1abc18 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Wed, 31 Jan 2024 14:41:18 -0600
Subject: [PATCH 0544/1166] chore: fmt-stacks

---
 .../src/chainstate/nakamoto/coordinator/tests.rs | 10 ++++++++--
 stackslib/src/chainstate/nakamoto/tests/mod.rs   | 16 ++++++++++++++--
 .../stacks/boot/signers_voting_tests.rs          |  3 ++-
 3 files changed, 24 insertions(+), 5 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index d0eaea4fe3..0b28b4e0b2 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -291,7 +291,13 @@ fn replay_reward_cycle(
 fn test_simple_nakamoto_coordinator_bootup() {
     let mut test_signers = TestSigners::default();
     let test_stackers = TestStacker::common_signing_set(&test_signers);
-    let mut peer = boot_nakamoto(function_name!(), vec![], &test_signers, &test_stackers, None);
+    let mut peer = boot_nakamoto(
+        function_name!(),
+        vec![],
+        &test_signers,
+        &test_stackers,
+        None,
+    );
 
     let (burn_ops, mut tenure_change, miner_key) =
         peer.begin_nakamoto_tenure(TenureChangeCause::BlockFound);
@@ -477,7 +483,7 @@ fn test_nakamoto_chainstate_getters() {
         vec![(addr.into(), 100_000_000)],
         &test_signers,
         &test_stackers,
-        None
+        None,
     );
 
     let sort_tip = {
diff --git a/stackslib/src/chainstate/nakamoto/tests/mod.rs b/stackslib/src/chainstate/nakamoto/tests/mod.rs
index 07a6ec533a..d2de8b67dc 100644
--- a/stackslib/src/chainstate/nakamoto/tests/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/mod.rs
@@ -1503,7 +1503,13 @@ fn make_fork_run_with_arrivals(
 pub fn test_get_highest_nakamoto_tenure() {
     let test_signers = TestSigners::default();
     let test_stackers = TestStacker::common_signing_set(&test_signers);
-    let mut peer = boot_nakamoto(function_name!(), vec![], &test_signers, &test_stackers, None);
+    let mut peer = boot_nakamoto(
+        function_name!(),
+        vec![],
+        &test_signers,
+        &test_stackers,
+        None,
+    );
 
     // extract chainstate and sortdb -- we don't need the peer anymore
     let chainstate = &mut peer.stacks_node.as_mut().unwrap().chainstate;
@@ -1646,7 +1652,13 @@ pub fn test_get_highest_nakamoto_tenure() {
 fn test_make_miners_stackerdb_config() {
     let test_signers = TestSigners::default();
     let test_stackers = TestStacker::common_signing_set(&test_signers);
-    let mut peer = boot_nakamoto(function_name!(), vec![], &test_signers, &test_stackers, None);
+    let mut peer = boot_nakamoto(
+        function_name!(),
+        vec![],
+        &test_signers,
+        &test_stackers,
+        None,
+    );
 
     let naka_miner_hash160 = peer.miner.nakamoto_miner_hash160();
     let miner_keys: Vec<_> = (0..10).map(|_| StacksPrivateKey::new()).collect();
diff --git a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
index d4634d7ec0..370eea72df 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
@@ -76,7 +76,8 @@ use crate::chainstate::stacks::events::{StacksTransactionReceipt, TransactionOri
 use crate::chainstate::stacks::index::marf::MarfConnection;
 use crate::chainstate::stacks::index::MarfTrieId;
 use crate::chainstate::stacks::tests::make_coinbase;
-use crate::chainstate::{self, stacks::*};
+use crate::chainstate::stacks::*;
+use crate::chainstate::{self};
 use crate::clarity_vm::clarity::{ClarityBlockConnection, Error as ClarityError};
 use crate::clarity_vm::database::marf::{MarfedKV, WritableMarfStore};
 use crate::clarity_vm::database::HeadersDBConn;

From 340e1d985ada9603cc810ab7b9c63a31dd10526e Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Tue, 30 Jan 2024 22:03:16 -0600
Subject: [PATCH 0545/1166] feat: add paging to StackerDB

Paging supports larger StackerDB instances
---
 stackslib/src/chainstate/stacks/db/mod.rs   |  45 ++-
 stackslib/src/net/api/tests/mod.rs          |  16 +-
 stackslib/src/net/stackerdb/config.rs       | 305 ++++++++++++++------
 stackslib/src/net/stackerdb/mod.rs          |   7 +-
 stackslib/src/net/stackerdb/tests/config.rs |  30 +-
 5 files changed, 311 insertions(+), 92 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/db/mod.rs b/stackslib/src/chainstate/stacks/db/mod.rs
index d1cb81c6db..97553eec02 100644
--- a/stackslib/src/chainstate/stacks/db/mod.rs
+++ b/stackslib/src/chainstate/stacks/db/mod.rs
@@ -33,7 +33,7 @@ use clarity::vm::database::{
 use clarity::vm::events::*;
 use clarity::vm::representations::{ClarityName, ContractName};
 use clarity::vm::types::TupleData;
-use clarity::vm::Value;
+use clarity::vm::{SymbolicExpression, Value};
 use lazy_static::lazy_static;
 use rusqlite::types::ToSql;
 use rusqlite::{Connection, OpenFlags, OptionalExtension, Row, Transaction, NO_PARAMS};
@@ -1913,6 +1913,49 @@ impl StacksChainState {
         )
     }
 
+    /// Execute a public function in `contract` from a read-only DB context
+    ///  Any mutations that occur will be rolled-back before returning, regardless of
+    ///  an okay or error result.
+    pub fn eval_fn_read_only(
+        &mut self,
+        burn_dbconn: &dyn BurnStateDB,
+        parent_id_bhh: &StacksBlockId,
+        contract: &QualifiedContractIdentifier,
+        function: &str,
+        args: &[Value],
+    ) -> Result<Value, clarity_error> {
+        let headers_db = HeadersDBConn(self.state_index.sqlite_conn());
+        let mut conn = self.clarity_state.read_only_connection_checked(
+            parent_id_bhh,
+            &headers_db,
+            burn_dbconn,
+        )?;
+
+        let args: Vec<_> = args
+            .iter()
+            .map(|x| SymbolicExpression::atom_value(x.clone()))
+            .collect();
+
+        let result = conn.with_readonly_clarity_env(
+            self.mainnet,
+            self.chain_id,
+            ClarityVersion::latest(),
+            contract.clone().into(),
+            None,
+            LimitedCostTracker::Free,
+            |env| {
+                env.execute_contract(
+                    contract, function, &args,
+                    // read-only is set to `false` so that non-read-only functions
+                    //  can be executed. any transformation is rolled back.
+                    false,
+                )
+            },
+        )?;
+
+        Ok(result)
+    }
+
     pub fn db(&self) -> &DBConn {
         self.state_index.sqlite_conn()
     }
diff --git a/stackslib/src/net/api/tests/mod.rs b/stackslib/src/net/api/tests/mod.rs
index 7800aa3c84..cd01692faa 100644
--- a/stackslib/src/net/api/tests/mod.rs
+++ b/stackslib/src/net/api/tests/mod.rs
@@ -107,17 +107,21 @@ const TEST_CONTRACT: &'static str = "
 
     (define-public (do-test) (ok u0))
 
+    (define-read-only (stackerdb-get-page-count) (ok u1))
+
     ;; stacker DB
-    (define-read-only (stackerdb-get-signer-slots)
-        (ok (list
-            {
+    (define-read-only (stackerdb-get-signer-slots (page uint))
+        (if (is-eq page u0)
+            (ok (list
+              {
                 signer: 'ST2DS4MSWSGJ3W9FBC6BVT0Y92S345HY8N3T6AV7R,
                 num-slots: u3
-            }
-            {
+              }
+              {
                 signer: 'STVN97YYA10MY5F6KQJHKNYJNM24C4A1AT39WRW,
                 num-slots: u3
-            })))
+              }))
+            (err u1)))
 
     (define-read-only (stackerdb-get-config)
         (ok {
diff --git a/stackslib/src/net/stackerdb/config.rs b/stackslib/src/net/stackerdb/config.rs
index 31a58b660b..92ab1b4347 100644
--- a/stackslib/src/net/stackerdb/config.rs
+++ b/stackslib/src/net/stackerdb/config.rs
@@ -22,7 +22,9 @@
 /// (define-trait stackerdb-trait
 ///
 ///     ;; Get the list of (signer, num-slots) that make up this DB
-///     (define-public (stackerdb-get-signer-slots) (response (list 4096 { signer: principal, num-slots: uint }) uint))
+///     (define-public (stackerdb-get-signer-slots (uint)) (response (list 4096 { signer: principal, num-slots: uint }) uint))
+///
+///     (define-public (stackerdb-get-page-count) (response uint bool))
 ///
 ///     ;; Get the control metadata for this DB
 ///     (define-public (stackerdb-get-config)
@@ -44,8 +46,8 @@ use clarity::vm::clarity::ClarityConnection;
 use clarity::vm::database::BurnStateDB;
 use clarity::vm::types::{
     BufferLength, FixedFunction, FunctionType, ListTypeData, PrincipalData,
-    QualifiedContractIdentifier, SequenceSubtype, StandardPrincipalData, TupleTypeSignature,
-    TypeSignature,
+    QualifiedContractIdentifier, SequenceData, SequenceSubtype, StandardPrincipalData,
+    TupleTypeSignature, TypeSignature, Value as ClarityValue,
 };
 use clarity::vm::ClarityName;
 use lazy_static::lazy_static;
@@ -54,6 +56,7 @@ use stacks_common::types::net::PeerAddress;
 use stacks_common::types::StacksEpochId;
 use stacks_common::util::hash::Hash160;
 
+use super::{STACKERDB_PAGE_COUNT_FUNCTION, STACKERDB_PAGE_MAX, STACKERDB_SLOTS_FUNCTION};
 use crate::chainstate::burn::db::sortdb::SortitionDB;
 use crate::chainstate::nakamoto::NakamotoChainState;
 use crate::chainstate::stacks::db::StacksChainState;
@@ -67,9 +70,20 @@ use crate::net::{Error as NetError, NeighborAddress};
 const MAX_HINT_REPLICAS: u32 = 128;
 
 lazy_static! {
-    pub static ref REQUIRED_FUNCTIONS: [(ClarityName, TypeSignature); 2] = [
+    pub static ref REQUIRED_FUNCTIONS: [(ClarityName, Vec<TypeSignature>, TypeSignature); 3] = [
+        (
+            super::STACKERDB_PAGE_COUNT_FUNCTION.into(),
+            vec![],
+            TypeSignature::new_response(
+                TypeSignature::UIntType,
+                TypeSignature::UIntType,
+            ).expect("FATAL: failed to construct (response int int)")
+        ),
         (
-            "stackerdb-get-signer-slots".into(),
+            super::STACKERDB_SLOTS_FUNCTION.into(),
+            vec![
+                TypeSignature::UIntType
+            ],
             TypeSignature::new_response(
                 ListTypeData::new_list(
                     TupleTypeSignature::try_from(vec![
@@ -78,7 +92,7 @@ lazy_static! {
                     ])
                     .expect("FATAL: failed to construct signer list type")
                     .into(),
-                    STACKERDB_INV_MAX
+                    super::STACKERDB_PAGE_MAX
                 )
                 .expect("FATAL: could not construct signer list type")
                 .into(),
@@ -86,7 +100,8 @@ lazy_static! {
             ).expect("FATAL: failed to construct response with signer slots"),
         ),
         (
-            "stackerdb-get-config".into(),
+            super::STACKERDB_CONFIG_FUNCTION.into(),
+            vec![],
             TypeSignature::new_response(
                 TypeSignature::TupleType(
                     TupleTypeSignature::try_from(vec![
@@ -123,108 +138,250 @@ impl StackerDBConfig {
     /// Returns Ok(..) if the contract is valid
     /// Returns Err(reason) if the contract is invalid.  A human-readable reason will be given.
     fn is_contract_valid(epoch: &StacksEpochId, analysis: ContractAnalysis) -> Result<(), String> {
-        for (name, func_return_type) in REQUIRED_FUNCTIONS.iter() {
+        for (name, expected_args, expected_return) in REQUIRED_FUNCTIONS.iter() {
             let func = if let Some(f) = analysis.read_only_function_types.get(name) {
                 f
             } else if let Some(f) = analysis.public_function_types.get(name) {
                 f
             } else {
-                let reason = format!("Contract is missing function '{}'", name);
+                let reason = format!("Contract is missing function '{name}'");
                 return Err(reason);
             };
 
-            match func {
-                FunctionType::Fixed(FixedFunction { args, returns }) => {
-                    if args.len() != 0 {
-                        let reason = format!("Contract function '{}' has an invalid signature: it must take zero arguments", name);
-                        return Err(reason);
-                    }
-                    if !func_return_type
-                        .admits_type(epoch, &returns)
-                        .unwrap_or(false)
-                    {
-                        let reason = format!("Contract function '{}' has an invalid return type: expected {:?}, got {:?}", name, func_return_type, returns);
-                        return Err(reason);
-                    }
-                }
-                _ => {
-                    let reason = format!("Contract function '{}' is not a fixed function", name);
-                    return Err(reason);
+            let FunctionType::Fixed(func) = func else {
+                return Err(format!("Function '{name}' must be a fixed function"));
+            };
+
+            if func.args.len() != expected_args.len() {
+                let reason = format!(
+                    "Function '{name}' has an invalid signature: it must have {} args",
+                    expected_args.len()
+                );
+                return Err(reason);
+            }
+            for (actual_arg, expected_arg) in func.args.iter().zip(expected_args.iter()) {
+                if !actual_arg
+                    .signature
+                    .admits_type(epoch, expected_arg)
+                    .unwrap_or(false)
+                {
+                    return Err(format!("Function '{name}' has an invalid argument type: expected {expected_arg}, got {actual_arg}"));
                 }
             }
+
+            if !expected_return
+                .admits_type(epoch, &func.returns)
+                .unwrap_or(false)
+            {
+                return Err(format!("Function '{name}' has an invalid return type: expected {expected_return}, got {}", &func.returns));
+            }
         }
         Ok(())
     }
 
-    /// Evaluate the contract to get its signer slots
-    fn eval_signer_slots(
+    fn eval_page_count(
         chainstate: &mut StacksChainState,
         burn_dbconn: &dyn BurnStateDB,
         contract_id: &QualifiedContractIdentifier,
         tip: &StacksBlockId,
-    ) -> Result<Vec<(StacksAddress, u32)>, NetError> {
-        let value = chainstate.eval_read_only(
+    ) -> Result<u32, NetError> {
+        let pages_val = chainstate.eval_fn_read_only(
             burn_dbconn,
             tip,
             contract_id,
-            "(stackerdb-get-signer-slots)",
+            STACKERDB_PAGE_COUNT_FUNCTION,
+            &[],
         )?;
 
-        let result = value.expect_result();
-        let slot_list = match result {
-            Err(err_val) => {
-                let err_code = err_val.expect_u128();
+        if !matches!(pages_val, ClarityValue::Response(_)) {
+            let reason = format!("StackerDB fn `{contract_id}.{STACKERDB_PAGE_COUNT_FUNCTION}` returned unexpected non-response type");
+            warn!("{reason}");
+            return Err(NetError::InvalidStackerDBContract(
+                contract_id.clone(),
+                reason,
+            ));
+        }
+
+        let ClarityValue::UInt(pages) = pages_val
+            .expect_result()
+            .map_err(|err_val| {
                 let reason = format!(
-                    "Contract {} failed to run `stackerdb-get-signer-slots`: error u{}",
-                    contract_id, &err_code
+                    "StackerDB fn `{contract_id}.{STACKERDB_PAGE_COUNT_FUNCTION}` failed: error {err_val}",
                 );
-                warn!("{}", &reason);
-                return Err(NetError::InvalidStackerDBContract(
+                warn!("{reason}");
+                NetError::InvalidStackerDBContract(
                     contract_id.clone(),
                     reason,
-                ));
-            }
-            Ok(ok_val) => ok_val.expect_list(),
+                )
+            })?
+        else {
+            let reason = format!("StackerDB fn `{contract_id}.{STACKERDB_PAGE_COUNT_FUNCTION}` returned unexpected non-uint ok type");
+            warn!("{reason}");
+            return Err(NetError::InvalidStackerDBContract(
+                contract_id.clone(), reason));
         };
 
-        let mut total_num_slots = 0u32;
-        let mut ret = vec![];
-        for slot_value in slot_list.into_iter() {
-            let slot_data = slot_value.expect_tuple();
-            let signer_principal = slot_data
-                .get("signer")
-                .expect("FATAL: no 'signer'")
-                .clone()
-                .expect_principal();
-            let num_slots_uint = slot_data
-                .get("num-slots")
-                .expect("FATAL: no 'num-slots'")
-                .clone()
-                .expect_u128();
-
-            if num_slots_uint > (STACKERDB_INV_MAX as u128) {
+        pages.try_into().map_err(
+            |_| {
                 let reason = format!(
-                    "Contract {} stipulated more than maximum number of slots for one signer ({})",
-                    contract_id, STACKERDB_INV_MAX
+                    "StackerDB fn `{contract_id}.{STACKERDB_PAGE_COUNT_FUNCTION}` returned page count outside of u32 range",
                 );
-                warn!("{}", &reason);
+                warn!("{reason}");
+                NetError::InvalidStackerDBContract(
+                    contract_id.clone(),
+                    reason,
+                )
+            }
+        )
+    }
+
+    fn parse_slot_entry(
+        entry: ClarityValue,
+        contract_id: &QualifiedContractIdentifier,
+    ) -> Result<(StacksAddress, u32), String> {
+        let ClarityValue::Tuple(slot_data) = entry else {
+            let reason = format!(
+                "StackerDB fn `{contract_id}.{STACKERDB_SLOTS_FUNCTION}` returned non-tuple slot entry",
+            );
+            return Err(reason);
+        };
+
+        let Ok(ClarityValue::Principal(signer_principal)) = slot_data.get("signer") else {
+            let reason = format!(
+                "StackerDB fn `{contract_id}.{STACKERDB_SLOTS_FUNCTION}` returned tuple without `signer` entry of type `principal`",
+            );
+            return Err(reason);
+        };
+
+        let Ok(ClarityValue::UInt(num_slots)) = slot_data.get("num-slots") else {
+            let reason = format!(
+                "StackerDB fn `{contract_id}.{STACKERDB_SLOTS_FUNCTION}` returned tuple without `num-slots` entry of type `uint`",
+            );
+            return Err(reason);
+        };
+
+        let num_slots = u32::try_from(*num_slots)
+            .map_err(|_| format!("Contract `{contract_id}` set too many slots for one signer (max = {STACKERDB_PAGE_MAX})"))?;
+        if num_slots > STACKERDB_PAGE_MAX {
+            return Err(format!("Contract `{contract_id}` set too many slots for one signer (max = {STACKERDB_PAGE_MAX})"));
+        }
+
+        let PrincipalData::Standard(standard_principal) = signer_principal else {
+            return Err(format!(
+                "StackerDB contract `{contract_id}` set a contract principal as a writer, which is not supported"
+            ));
+        };
+        let addr = StacksAddress::from(standard_principal.clone());
+        Ok((addr, num_slots))
+    }
+
+    fn eval_signer_slots(
+        chainstate: &mut StacksChainState,
+        burn_dbconn: &dyn BurnStateDB,
+        contract_id: &QualifiedContractIdentifier,
+        tip: &StacksBlockId,
+    ) -> Result<Vec<(StacksAddress, u32)>, NetError> {
+        let page_count = Self::eval_page_count(chainstate, burn_dbconn, contract_id, tip)?;
+        if page_count == 0 {
+            debug!("StackerDB contract {contract_id} specified zero pages");
+            return Ok(vec![]);
+        }
+        let mut return_set: Option<Vec<(StacksAddress, u32)>> = None;
+        let mut total_num_slots = 0u32;
+        for page in 0..page_count {
+            let (mut new_entries, total_new_slots) =
+                Self::eval_signer_slots_page(chainstate, burn_dbconn, contract_id, tip, page)?;
+            total_num_slots = total_num_slots
+                .checked_add(total_new_slots)
+                .ok_or_else(|| {
+                    NetError::OverflowError(format!(
+                        "Contract {contract_id} set more than u32::MAX slots",
+                    ))
+                })?;
+            if total_num_slots > STACKERDB_INV_MAX {
+                let reason =
+                    format!("Contract {contract_id} set more than the maximum number of slots in a page (max = {STACKERDB_PAGE_MAX})",);
+                warn!("{reason}");
                 return Err(NetError::InvalidStackerDBContract(
                     contract_id.clone(),
                     reason,
                 ));
             }
-            let num_slots = num_slots_uint as u32;
+            // avoid buffering on the first page
+            if let Some(ref mut return_set) = return_set {
+                return_set.append(&mut new_entries);
+            } else {
+                return_set = Some(new_entries);
+            };
+        }
+        Ok(return_set.unwrap_or_else(|| vec![]))
+    }
+
+    /// Evaluate the contract to get its signer slots
+    fn eval_signer_slots_page(
+        chainstate: &mut StacksChainState,
+        burn_dbconn: &dyn BurnStateDB,
+        contract_id: &QualifiedContractIdentifier,
+        tip: &StacksBlockId,
+        page: u32,
+    ) -> Result<(Vec<(StacksAddress, u32)>, u32), NetError> {
+        let resp_value = chainstate.eval_fn_read_only(
+            burn_dbconn,
+            tip,
+            contract_id,
+            STACKERDB_SLOTS_FUNCTION,
+            &[ClarityValue::UInt(page.into())],
+        )?;
+
+        if !matches!(resp_value, ClarityValue::Response(_)) {
+            let reason = format!("StackerDB fn `{contract_id}.{STACKERDB_SLOTS_FUNCTION}` returned unexpected non-response type");
+            warn!("{reason}");
+            return Err(NetError::InvalidStackerDBContract(
+                contract_id.clone(),
+                reason,
+            ));
+        }
+
+        let slot_list_val = resp_value.expect_result().map_err(|err_val| {
+            let reason = format!(
+                "StackerDB fn `{contract_id}.{STACKERDB_SLOTS_FUNCTION}` failed: error {err_val}",
+            );
+            warn!("{reason}");
+            NetError::InvalidStackerDBContract(contract_id.clone(), reason)
+        })?;
+
+        let slot_list = if let ClarityValue::Sequence(SequenceData::List(list_data)) = slot_list_val
+        {
+            list_data.data
+        } else {
+            let reason = format!("StackerDB fn `{contract_id}.{STACKERDB_SLOTS_FUNCTION}` returned unexpected non-list ok type");
+            warn!("{reason}");
+            return Err(NetError::InvalidStackerDBContract(
+                contract_id.clone(),
+                reason,
+            ));
+        };
+
+        let mut total_num_slots = 0u32;
+        let mut ret = vec![];
+        for slot_value in slot_list.into_iter() {
+            let (addr, num_slots) =
+                Self::parse_slot_entry(slot_value, contract_id).map_err(|reason| {
+                    warn!("{reason}");
+                    NetError::InvalidStackerDBContract(contract_id.clone(), reason)
+                })?;
+
             total_num_slots =
                 total_num_slots
                     .checked_add(num_slots)
                     .ok_or(NetError::OverflowError(format!(
-                        "Contract {} stipulates more than u32::MAX slots",
+                        "Contract {} set more than u32::MAX slots",
                         &contract_id
                     )))?;
 
-            if total_num_slots > STACKERDB_INV_MAX.into() {
+            if total_num_slots > STACKERDB_PAGE_MAX.into() {
                 let reason = format!(
-                    "Contract {} stipulated more than the maximum number of slots",
+                    "Contract {} set more than the maximum number of slots",
                     contract_id
                 );
                 warn!("{}", &reason);
@@ -234,25 +391,9 @@ impl StackerDBConfig {
                 ));
             }
 
-            // standard principals only
-            let addr = match signer_principal {
-                PrincipalData::Contract(..) => {
-                    let reason = format!("Contract {} stipulated a contract principal as a writer, which is not supported", contract_id);
-                    warn!("{}", &reason);
-                    return Err(NetError::InvalidStackerDBContract(
-                        contract_id.clone(),
-                        reason,
-                    ));
-                }
-                PrincipalData::Standard(StandardPrincipalData(version, bytes)) => StacksAddress {
-                    version,
-                    bytes: Hash160(bytes),
-                },
-            };
-
             ret.push((addr, num_slots));
         }
-        Ok(ret)
+        Ok((ret, total_num_slots))
     }
 
     /// Evaluate the contract to get its config
diff --git a/stackslib/src/net/stackerdb/mod.rs b/stackslib/src/net/stackerdb/mod.rs
index 243a7324d4..2d99daedd8 100644
--- a/stackslib/src/net/stackerdb/mod.rs
+++ b/stackslib/src/net/stackerdb/mod.rs
@@ -142,7 +142,12 @@ use crate::util_lib::boot::boot_code_id;
 use crate::util_lib::db::{DBConn, DBTx, Error as db_error};
 
 /// maximum chunk inventory size
-pub const STACKERDB_INV_MAX: u32 = 4096;
+pub const STACKERDB_INV_MAX: u32 = STACKERDB_PAGE_MAX * 2;
+pub const STACKERDB_PAGE_MAX: u32 = 4096;
+
+pub const STACKERDB_PAGE_COUNT_FUNCTION: &str = "stackerdb-get-page-count";
+pub const STACKERDB_SLOTS_FUNCTION: &str = "stackerdb-get-signer-slots";
+pub const STACKERDB_CONFIG_FUNCTION: &str = "stackerdb-get-config";
 
 /// Final result of synchronizing state with a remote set of DB replicas
 pub struct StackerDBSyncResult {
diff --git a/stackslib/src/net/stackerdb/tests/config.rs b/stackslib/src/net/stackerdb/tests/config.rs
index 9600ed79a8..aea894c057 100644
--- a/stackslib/src/net/stackerdb/tests/config.rs
+++ b/stackslib/src/net/stackerdb/tests/config.rs
@@ -122,9 +122,11 @@ fn test_valid_and_invalid_stackerdb_configs() {
         (
             // valid
             r#"
-            (define-public (stackerdb-get-signer-slots)
+            (define-public (stackerdb-get-signer-slots (page uint))
                 (ok (list { signer: 'ST2TFVBMRPS5SSNP98DQKQ5JNB2B6NZM91C4K3P7B, num-slots: u3 })))
 
+            (define-public (stackerdb-get-page-count) (ok u1))
+
             (define-public (stackerdb-get-config)
                 (ok {
                     chunk-size: u123,
@@ -163,9 +165,11 @@ fn test_valid_and_invalid_stackerdb_configs() {
         (
             // valid
             r#"
-            (define-read-only (stackerdb-get-signer-slots)
+            (define-read-only (stackerdb-get-signer-slots (page uint))
                 (ok (list { signer: 'ST2TFVBMRPS5SSNP98DQKQ5JNB2B6NZM91C4K3P7B, num-slots: u3 })))
 
+            (define-public (stackerdb-get-page-count) (ok u1))
+
             (define-read-only (stackerdb-get-config)
                 (ok {
                     chunk-size: u123,
@@ -201,6 +205,28 @@ fn test_valid_and_invalid_stackerdb_configs() {
                 max_neighbors: 7,
             }),
         ),
+        (
+            // valid
+            r#"
+            (define-read-only (stackerdb-get-signer-slots (page uint))
+                (ok (list { signer: 'ST2TFVBMRPS5SSNP98DQKQ5JNB2B6NZM91C4K3P7B, num-slots: u3 })))
+
+            (define-read-only (stackerdb-get-config)
+                (ok {
+                    chunk-size: u123,
+                    write-freq: u4,
+                    max-writes: u56,
+                    max-neighbors: u7,
+                    hint-replicas: (list
+                        {
+                            addr: (list u0 u0 u0 u0 u0 u0 u0 u0 u0 u0 u255 u255 u127 u0 u0 u1),
+                            port: u8901,
+                            public-key-hash: 0x0123456789abcdef0123456789abcdef01234567
+                        })
+                }))
+            "#,
+            None,
+        ),
         (
             // invalid -- missing function
             r#"

From d79de76cffa7b66e4bfaeae322596d7bc45e0176 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Wed, 31 Jan 2024 14:16:04 -0600
Subject: [PATCH 0546/1166] feat: update .signers to use StackerDB paging

* make signer-slots a const in stacks-common
* update the .signers maintenance to separate voting share from StackerDB slots
* update .signers to use and alternate 2 pages of signers
---
 libsigner/src/events.rs                       |  6 +--
 stacks-common/src/libcommon.rs                |  4 ++
 .../src/chainstate/nakamoto/signer_set.rs     | 51 +++++++++++++++++--
 .../stacks/boot/signers-voting.clar           | 14 +++--
 .../src/chainstate/stacks/boot/signers.clar   | 35 ++++++++++---
 .../chainstate/stacks/boot/signers_tests.rs   | 19 +++++--
 .../stacks/boot/signers_voting_tests.rs       | 14 +++--
 stackslib/src/net/stackerdb/mod.rs            |  1 +
 8 files changed, 105 insertions(+), 39 deletions(-)

diff --git a/libsigner/src/events.rs b/libsigner/src/events.rs
index 4bacbdd20b..cc88b5e31c 100644
--- a/libsigner/src/events.rs
+++ b/libsigner/src/events.rs
@@ -33,6 +33,7 @@ use serde::{Deserialize, Serialize};
 use stacks_common::codec::{
     read_next, read_next_at_most, write_next, Error as CodecError, StacksMessageCodec,
 };
+pub use stacks_common::consts::SIGNER_SLOTS_PER_USER;
 use stacks_common::util::hash::Sha512Trunc256Sum;
 use tiny_http::{
     Method as HttpMethod, Request as HttpRequest, Response as HttpResponse, Server as HttpServer,
@@ -43,11 +44,6 @@ use wsts::net::{Message, Packet};
 use crate::http::{decode_http_body, decode_http_request};
 use crate::EventError;
 
-/// Temporary placeholder for the number of slots allocated to a stacker-db writer. This will be retrieved from the stacker-db instance in the future
-/// See: https://github.com/stacks-network/stacks-blockchain/issues/3921
-/// Is equal to the number of message types
-pub const SIGNER_SLOTS_PER_USER: u32 = 11;
-
 // The slot IDS for each message type
 const DKG_BEGIN_SLOT_ID: u32 = 0;
 const DKG_PRIVATE_BEGIN_SLOT_ID: u32 = 1;
diff --git a/stacks-common/src/libcommon.rs b/stacks-common/src/libcommon.rs
index 2f19e74540..8ab7510adc 100644
--- a/stacks-common/src/libcommon.rs
+++ b/stacks-common/src/libcommon.rs
@@ -59,4 +59,8 @@ pub mod consts {
     pub const MINER_REWARD_MATURITY: u64 = 100;
 
     pub const STACKS_EPOCH_MAX: u64 = i64::MAX as u64;
+
+    /// The number of StackerDB slots each signing key needs
+    ///  to use to participate in DKG and block validation signing.
+    pub const SIGNER_SLOTS_PER_USER: u32 = 11;
 }
diff --git a/stackslib/src/chainstate/nakamoto/signer_set.rs b/stackslib/src/chainstate/nakamoto/signer_set.rs
index 261133e3f2..8e700df831 100644
--- a/stackslib/src/chainstate/nakamoto/signer_set.rs
+++ b/stackslib/src/chainstate/nakamoto/signer_set.rs
@@ -33,7 +33,7 @@ use stacks_common::codec::{
     MAX_PAYLOAD_LEN,
 };
 use stacks_common::consts::{
-    FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH, MINER_REWARD_MATURITY,
+    self, FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH, MINER_REWARD_MATURITY,
 };
 use stacks_common::types::chainstate::{
     BlockHeaderHash, BurnchainHeaderHash, ConsensusHash, StacksAddress, StacksBlockId,
@@ -227,6 +227,33 @@ impl NakamotoSigners {
         let reward_set =
             StacksChainState::make_reward_set(threshold, reward_slots, StacksEpochId::Epoch30);
 
+        let stackerdb_list = if participation == 0 {
+            vec![]
+        } else {
+            reward_set
+                .signers
+                .as_ref()
+                .ok_or(ChainstateError::PoxNoRewardCycle)?
+                .iter()
+                .map(|signer| {
+                    let signer_hash = Hash160::from_data(&signer.signing_key);
+                    let signing_address = StacksAddress::p2pkh_from_hash(is_mainnet, signer_hash);
+                    Value::Tuple(
+                        TupleData::from_data(vec![
+                            (
+                                "signer".into(),
+                                Value::Principal(PrincipalData::from(signing_address)),
+                            ),
+                            ("num-slots".into(), Value::UInt(consts::SIGNER_SLOTS_PER_USER.into())),
+                        ])
+                            .expect(
+                                "BUG: Failed to construct `{ signer: principal, num-slots: u64 }` tuple",
+                            ),
+                    )
+                })
+                .collect()
+        };
+
         let signers_list = if participation == 0 {
             vec![]
         } else {
@@ -244,7 +271,7 @@ impl NakamotoSigners {
                                 "signer".into(),
                                 Value::Principal(PrincipalData::from(signing_address)),
                             ),
-                            ("num-slots".into(), Value::UInt(signer.slots.into())),
+                            ("weight".into(), Value::UInt(signer.slots.into())),
                         ])
                             .expect(
                                 "BUG: Failed to construct `{ signer: principal, num-slots: u64 }` tuple",
@@ -253,6 +280,7 @@ impl NakamotoSigners {
                 })
                 .collect()
         };
+
         if signers_list.len() > SIGNERS_MAX_LIST_SIZE {
             panic!(
                 "FATAL: signers list returned by reward set calculations longer than maximum ({} > {})",
@@ -261,14 +289,21 @@ impl NakamotoSigners {
             );
         }
 
-        let args = [
-            SymbolicExpression::atom_value(Value::cons_list_unsanitized(signers_list).expect(
+        let set_stackerdb_args = [
+            SymbolicExpression::atom_value(Value::cons_list_unsanitized(stackerdb_list).expect(
                 "BUG: Failed to construct `(list 4000 { signer: principal, num-slots: u64 })` list",
             )),
             SymbolicExpression::atom_value(Value::UInt(reward_cycle.into())),
             SymbolicExpression::atom_value(Value::UInt(coinbase_height.into())),
         ];
 
+        let set_signers_args = [
+            SymbolicExpression::atom_value(Value::UInt(reward_cycle.into())),
+            SymbolicExpression::atom_value(Value::cons_list_unsanitized(signers_list).expect(
+                "BUG: Failed to construct `(list 4000 { signer: principal, weight: u64 })` list",
+            )),
+        ];
+
         let (value, _, events, _) = clarity
             .with_abort_callback(
                 |vm_env| {
@@ -276,7 +311,13 @@ impl NakamotoSigners {
                         env.execute_contract_allow_private(
                             &signers_contract,
                             "stackerdb-set-signer-slots",
-                            &args,
+                            &set_stackerdb_args,
+                            false,
+                        )?;
+                        env.execute_contract_allow_private(
+                            &signers_contract,
+                            "stackerdb-set-signers",
+                            &set_signers_args,
                             false,
                         )
                     })
diff --git a/stackslib/src/chainstate/stacks/boot/signers-voting.clar b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
index d193386128..4dccdd73a7 100644
--- a/stackslib/src/chainstate/stacks/boot/signers-voting.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
@@ -55,16 +55,14 @@
 (define-read-only (get-tally (reward-cycle uint) (round uint) (aggregate-public-key (buff 33)))
     (map-get? tally {reward-cycle: reward-cycle, round: round, aggregate-public-key: aggregate-public-key}))
 
-(define-read-only (get-signer-slots (signer-index uint) (reward-cycle uint))
-    (let ((height (reward-cycle-to-burn-height reward-cycle)))
-            (ok (at-block
-                (unwrap! (get-block-info? id-header-hash height) err-invalid-burn-block-height)
-                    (get-current-signer-slots signer-index)))))
-
 (define-read-only (get-current-signer-slots (signer-index uint))
-    (let ((details (unwrap! (unwrap-panic (contract-call? .signers stackerdb-get-signer-by-index signer-index)) err-invalid-signer-index)))
+    (let ((cycle (+ u1 (burn-height-to-reward-cycle burn-block-height))))
+      (get-signer-slots signer-index cycle)))
+
+(define-read-only (get-signer-slots (signer-index uint) (reward-cycle uint))
+    (let ((details (unwrap! (try! (contract-call? .signers stackerdb-get-signer-by-index reward-cycle signer-index)) err-invalid-signer-index)))
         (asserts! (is-eq (get signer details) tx-sender) err-signer-index-mismatch)
-        (ok (get num-slots details))))
+        (ok (get weight details))))
 
 ;; aggregate public key must be unique and can be used only in a single cycle-round pair
 (define-read-only (is-valid-aggregated-public-key (key (buff 33)) (dkg-id {reward-cycle: uint, round: uint}))
diff --git a/stackslib/src/chainstate/stacks/boot/signers.clar b/stackslib/src/chainstate/stacks/boot/signers.clar
index 71adb33bd7..2943b4b627 100644
--- a/stackslib/src/chainstate/stacks/boot/signers.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers.clar
@@ -1,24 +1,43 @@
 (define-data-var last-set-cycle uint u0)
-(define-data-var stackerdb-signer-slots (list 4000 { signer: principal, num-slots: uint }) (list))
+(define-data-var stackerdb-signer-slots-0 (list 4000 { signer: principal, num-slots: uint }) (list))
+(define-data-var stackerdb-signer-slots-1 (list 4000 { signer: principal, num-slots: uint }) (list))
 (define-map cycle-set-height uint uint)
 (define-constant MAX_WRITES u340282366920938463463374607431768211455)
 (define-constant CHUNK_SIZE (* u2 u1024 u1024))
+(define-constant ERR_NO_SUCH_PAGE u1)
+(define-constant ERR_CYCLE_NOT_SET u2)
+(define-map cycle-signer-set uint (list 4000 { signer: principal, weight: uint }))
 
 (define-private (stackerdb-set-signer-slots 
                    (signer-slots (list 4000 { signer: principal, num-slots: uint }))
                    (reward-cycle uint)
                    (set-at-height uint))
-	(begin
+	(let ((cycle-mod (mod reward-cycle u2)))
         (map-set cycle-set-height reward-cycle set-at-height)
         (var-set last-set-cycle reward-cycle)
-		(ok (var-set stackerdb-signer-slots signer-slots))))
+        (if (is-eq cycle-mod u0)
+            (ok (var-set stackerdb-signer-slots-0 signer-slots))
+            (ok (var-set stackerdb-signer-slots-1 signer-slots)))))
 
-(define-read-only (stackerdb-get-signer-slots)
-	(ok (var-get stackerdb-signer-slots)))
+(define-private (stackerdb-set-signers
+                 (reward-cycle uint)
+                 (signers (list 4000 { signer: principal, weight: uint })))
+     (begin
+      (asserts! (is-eq (var-get last-set-cycle) reward-cycle) (err ERR_CYCLE_NOT_SET))
+      (ok (map-set cycle-signer-set reward-cycle signers))))
 
-(define-read-only (stackerdb-get-signer-by-index (signer-index uint))
-	(ok (element-at (var-get stackerdb-signer-slots) signer-index))
-)
+(define-read-only (get-signers (cycle uint))
+     (map-get? cycle-signer-set cycle))
+
+(define-read-only (stackerdb-get-page-count) (ok u2))
+
+(define-read-only (stackerdb-get-signer-slots (page uint))
+    (if (is-eq page u0)      (ok (var-get stackerdb-signer-slots-0))
+        (if (is-eq page u1)  (ok (var-get stackerdb-signer-slots-1))
+        (err ERR_NO_SUCH_PAGE))))
+
+(define-read-only (stackerdb-get-signer-by-index (cycle uint) (signer-index uint))
+	(ok (element-at (unwrap! (map-get? cycle-signer-set cycle) (err ERR_CYCLE_NOT_SET)) signer-index)))
 
 (define-read-only (stackerdb-get-config)
 	(ok
diff --git a/stackslib/src/chainstate/stacks/boot/signers_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_tests.rs
index 900f5a215a..475143f8c0 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_tests.rs
@@ -24,6 +24,7 @@ use clarity::vm::types::{
 use clarity::vm::Value::Principal;
 use clarity::vm::{ClarityName, ClarityVersion, ContractName, Value};
 use stacks_common::address::AddressHashMode;
+use stacks_common::consts;
 use stacks_common::types::chainstate::{
     BurnchainHeaderHash, StacksAddress, StacksBlockId, StacksPrivateKey, StacksPublicKey,
 };
@@ -55,6 +56,9 @@ use crate::chainstate::stacks::{
 };
 use crate::clarity_vm::database::HeadersDBConn;
 use crate::core::BITCOIN_REGTEST_FIRST_BLOCK_HASH;
+use crate::net::stackerdb::{
+    STACKERDB_CONFIG_FUNCTION, STACKERDB_INV_MAX, STACKERDB_SLOTS_FUNCTION,
+};
 use crate::net::test::{TestEventObserver, TestPeer};
 use crate::util_lib::boot::{boot_code_addr, boot_code_id, boot_code_test_addr};
 
@@ -174,7 +178,7 @@ fn signers_get_config() {
             &mut peer,
             &latest_block,
             "signers".into(),
-            "stackerdb-get-config".into(),
+            STACKERDB_CONFIG_FUNCTION.into(),
             vec![],
         ),
         Value::okay(Value::Tuple(
@@ -217,7 +221,10 @@ fn signers_get_signer_keys_from_stackerdb() {
                 let signer_addr = StacksAddress::p2pkh(false, &pk);
                 let stackerdb_entry = TupleData::from_data(vec![
                     ("signer".into(), PrincipalData::from(signer_addr).into()),
-                    ("num-slots".into(), Value::UInt(2)),
+                    (
+                        "num-slots".into(),
+                        Value::UInt(consts::SIGNER_SLOTS_PER_USER.into()),
+                    ),
                 ])
                 .unwrap();
                 (pk_bytes, stackerdb_entry)
@@ -237,8 +244,8 @@ fn signers_get_signer_keys_from_stackerdb() {
         &mut peer,
         &latest_block_id,
         "signers".into(),
-        "stackerdb-get-signer-slots".into(),
-        vec![],
+        STACKERDB_SLOTS_FUNCTION.into(),
+        vec![Value::UInt(1)],
     )
     .expect_result_ok();
 
@@ -397,13 +404,15 @@ pub fn get_signer_index(
     peer: &mut TestPeer<'_>,
     latest_block_id: StacksBlockId,
     signer_address: StacksAddress,
+    cycle_index: u128,
 ) -> u128 {
+    let cycle_mod = cycle_index % 2;
     let signers = readonly_call(
         peer,
         &latest_block_id,
         "signers".into(),
         "stackerdb-get-signer-slots".into(),
-        vec![],
+        vec![Value::UInt(cycle_mod)],
     )
     .expect_result_ok()
     .expect_list();
diff --git a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
index 370eea72df..9fff91e6b7 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
@@ -162,12 +162,9 @@ fn vote_for_aggregate_public_key_in_first_block() {
     let signer_principal = PrincipalData::from(signer_address);
     let cycle_id = current_reward_cycle;
 
-    let signer_index = get_signer_index(&mut peer, latest_block_id, signer_address);
+    let signer_index = get_signer_index(&mut peer, latest_block_id, signer_address, cycle_id);
 
     let aggregate_public_key: Point = Point::new();
-    let aggreagte_public_key_value =
-        Value::buff_from(aggregate_public_key.compress().data.to_vec())
-            .expect("Failed to serialize aggregate public key");
 
     let txs = vec![
         // cast a vote for the aggregate public key
@@ -266,7 +263,7 @@ fn vote_for_aggregate_public_key_in_last_block() {
     let signer_1_key = &stacker_1.signer_private_key;
     let signer_1_address = key_to_stacks_addr(signer_1_key);
     let signer_1_principal = PrincipalData::from(signer_1_address);
-    let signer_1_index = get_signer_index(&mut peer, latest_block_id, signer_1_address);
+    let signer_1_index = get_signer_index(&mut peer, latest_block_id, signer_1_address, cycle_id);
 
     let txs_1 = vec![
         // cast a vote for the aggregate public key
@@ -292,7 +289,7 @@ fn vote_for_aggregate_public_key_in_last_block() {
     let signer_2_key = &stacker_2.signer_private_key;
     let signer_2_address = key_to_stacks_addr(signer_2_key);
     let signer_2_principal = PrincipalData::from(signer_2_address);
-    let signer_2_index = get_signer_index(&mut peer, latest_block_id, signer_2_address);
+    let signer_2_index = get_signer_index(&mut peer, latest_block_id, signer_2_address, cycle_id);
 
     let txs_2 = vec![
         // cast a vote for the aggregate public key
@@ -364,13 +361,14 @@ fn vote_for_aggregate_public_key_in_last_block() {
     let receipts = block.receipts.as_slice();
     assert_eq!(receipts.len(), 1);
 
-    // vote should succeed
+    // vote fails because the reward cycle has changed
+    //  and the signer set hasn't been set yet.
     let tx1 = &receipts[receipts.len() - 1];
     assert_eq!(
         tx1.result,
         Value::Response(ResponseData {
             committed: false,
-            data: Box::new(Value::UInt(10002)) // err-out-of-voting-window
+            data: Box::new(Value::UInt(2)) // err-out-of-voting-window
         })
     );
 }
diff --git a/stackslib/src/net/stackerdb/mod.rs b/stackslib/src/net/stackerdb/mod.rs
index 2d99daedd8..1fbebba59f 100644
--- a/stackslib/src/net/stackerdb/mod.rs
+++ b/stackslib/src/net/stackerdb/mod.rs
@@ -143,6 +143,7 @@ use crate::util_lib::db::{DBConn, DBTx, Error as db_error};
 
 /// maximum chunk inventory size
 pub const STACKERDB_INV_MAX: u32 = STACKERDB_PAGE_MAX * 2;
+/// maximum size of a single inventory page
 pub const STACKERDB_PAGE_MAX: u32 = 4096;
 
 pub const STACKERDB_PAGE_COUNT_FUNCTION: &str = "stackerdb-get-page-count";

From 0f494d2607040536262a833b70ff915ca4c071ad Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Thu, 1 Feb 2024 10:56:46 -0600
Subject: [PATCH 0547/1166] fix: expand read-only call limits in test for
 larger hello-world contract

---
 stackslib/src/net/api/tests/mod.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/stackslib/src/net/api/tests/mod.rs b/stackslib/src/net/api/tests/mod.rs
index cd01692faa..eb1adb0fe7 100644
--- a/stackslib/src/net/api/tests/mod.rs
+++ b/stackslib/src/net/api/tests/mod.rs
@@ -244,18 +244,18 @@ impl<'a> TestRPC<'a> {
         peer_1_config.connection_opts.read_only_call_limit = ExecutionCost {
             write_length: 0,
             write_count: 0,
-            read_length: 1500,
+            read_length: 2000,
             read_count: 3,
-            runtime: 1500000,
+            runtime: 2000000,
         };
         peer_1_config.connection_opts.maximum_call_argument_size = 4096;
 
         peer_2_config.connection_opts.read_only_call_limit = ExecutionCost {
             write_length: 0,
             write_count: 0,
-            read_length: 1500,
+            read_length: 2000,
             read_count: 3,
-            runtime: 1500000,
+            runtime: 2000000,
         };
         peer_2_config.connection_opts.maximum_call_argument_size = 4096;
 

From 577d46d72890746cee80bc4eea92532cf7c95c25 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Thu, 1 Feb 2024 11:33:37 -0600
Subject: [PATCH 0548/1166] fix: replace page slot limit with a page length
 limit

---
 stackslib/src/net/stackerdb/config.rs | 44 ++++++++++++++++++++-------
 stackslib/src/net/stackerdb/mod.rs    |  9 ++++--
 2 files changed, 39 insertions(+), 14 deletions(-)

diff --git a/stackslib/src/net/stackerdb/config.rs b/stackslib/src/net/stackerdb/config.rs
index 92ab1b4347..21c1a92eb3 100644
--- a/stackslib/src/net/stackerdb/config.rs
+++ b/stackslib/src/net/stackerdb/config.rs
@@ -56,14 +56,18 @@ use stacks_common::types::net::PeerAddress;
 use stacks_common::types::StacksEpochId;
 use stacks_common::util::hash::Hash160;
 
-use super::{STACKERDB_PAGE_COUNT_FUNCTION, STACKERDB_PAGE_MAX, STACKERDB_SLOTS_FUNCTION};
+use super::{
+    STACKERDB_MAX_PAGE_COUNT, STACKERDB_PAGE_COUNT_FUNCTION, STACKERDB_PAGE_LIST_MAX,
+    STACKERDB_SLOTS_FUNCTION,
+};
 use crate::chainstate::burn::db::sortdb::SortitionDB;
 use crate::chainstate::nakamoto::NakamotoChainState;
 use crate::chainstate::stacks::db::StacksChainState;
 use crate::chainstate::stacks::Error as chainstate_error;
 use crate::clarity_vm::clarity::{ClarityReadOnlyConnection, Error as clarity_error};
 use crate::net::stackerdb::{
-    StackerDBConfig, StackerDBs, STACKERDB_INV_MAX, STACKERDB_MAX_CHUNK_SIZE,
+    StackerDBConfig, StackerDBs, STACKERDB_CONFIG_FUNCTION, STACKERDB_INV_MAX,
+    STACKERDB_MAX_CHUNK_SIZE,
 };
 use crate::net::{Error as NetError, NeighborAddress};
 
@@ -72,7 +76,7 @@ const MAX_HINT_REPLICAS: u32 = 128;
 lazy_static! {
     pub static ref REQUIRED_FUNCTIONS: [(ClarityName, Vec<TypeSignature>, TypeSignature); 3] = [
         (
-            super::STACKERDB_PAGE_COUNT_FUNCTION.into(),
+            STACKERDB_PAGE_COUNT_FUNCTION.into(),
             vec![],
             TypeSignature::new_response(
                 TypeSignature::UIntType,
@@ -80,7 +84,7 @@ lazy_static! {
             ).expect("FATAL: failed to construct (response int int)")
         ),
         (
-            super::STACKERDB_SLOTS_FUNCTION.into(),
+            STACKERDB_SLOTS_FUNCTION.into(),
             vec![
                 TypeSignature::UIntType
             ],
@@ -92,7 +96,7 @@ lazy_static! {
                     ])
                     .expect("FATAL: failed to construct signer list type")
                     .into(),
-                    super::STACKERDB_PAGE_MAX
+                    STACKERDB_PAGE_LIST_MAX
                 )
                 .expect("FATAL: could not construct signer list type")
                 .into(),
@@ -100,7 +104,7 @@ lazy_static! {
             ).expect("FATAL: failed to construct response with signer slots"),
         ),
         (
-            super::STACKERDB_CONFIG_FUNCTION.into(),
+            STACKERDB_CONFIG_FUNCTION.into(),
             vec![],
             TypeSignature::new_response(
                 TypeSignature::TupleType(
@@ -261,9 +265,9 @@ impl StackerDBConfig {
         };
 
         let num_slots = u32::try_from(*num_slots)
-            .map_err(|_| format!("Contract `{contract_id}` set too many slots for one signer (max = {STACKERDB_PAGE_MAX})"))?;
-        if num_slots > STACKERDB_PAGE_MAX {
-            return Err(format!("Contract `{contract_id}` set too many slots for one signer (max = {STACKERDB_PAGE_MAX})"));
+            .map_err(|_| format!("Contract `{contract_id}` set too many slots for one signer (max = {STACKERDB_INV_MAX})"))?;
+        if num_slots > STACKERDB_INV_MAX {
+            return Err(format!("Contract `{contract_id}` set too many slots for one signer (max = {STACKERDB_INV_MAX})"));
         }
 
         let PrincipalData::Standard(standard_principal) = signer_principal else {
@@ -286,6 +290,15 @@ impl StackerDBConfig {
             debug!("StackerDB contract {contract_id} specified zero pages");
             return Ok(vec![]);
         }
+        if page_count > STACKERDB_MAX_PAGE_COUNT {
+            let reason = format!("Contract {contract_id} set more than maximum number of pages (max = {STACKERDB_MAX_PAGE_COUNT}");
+            warn!("{reason}");
+            return Err(NetError::InvalidStackerDBContract(
+                contract_id.clone(),
+                reason,
+            ));
+        }
+
         let mut return_set: Option<Vec<(StacksAddress, u32)>> = None;
         let mut total_num_slots = 0u32;
         for page in 0..page_count {
@@ -300,7 +313,7 @@ impl StackerDBConfig {
                 })?;
             if total_num_slots > STACKERDB_INV_MAX {
                 let reason =
-                    format!("Contract {contract_id} set more than the maximum number of slots in a page (max = {STACKERDB_PAGE_MAX})",);
+                    format!("Contract {contract_id} set more than the maximum number of slots in a page (max = {STACKERDB_INV_MAX})",);
                 warn!("{reason}");
                 return Err(NetError::InvalidStackerDBContract(
                     contract_id.clone(),
@@ -362,6 +375,15 @@ impl StackerDBConfig {
             ));
         };
 
+        if slot_list.len() > usize::try_from(STACKERDB_PAGE_LIST_MAX).unwrap() {
+            let reason = format!("StackerDB fn `{contract_id}.{STACKERDB_SLOTS_FUNCTION}` returned too long list (max len={STACKERDB_PAGE_LIST_MAX})");
+            warn!("{reason}");
+            return Err(NetError::InvalidStackerDBContract(
+                contract_id.clone(),
+                reason,
+            ));
+        }
+
         let mut total_num_slots = 0u32;
         let mut ret = vec![];
         for slot_value in slot_list.into_iter() {
@@ -379,7 +401,7 @@ impl StackerDBConfig {
                         &contract_id
                     )))?;
 
-            if total_num_slots > STACKERDB_PAGE_MAX.into() {
+            if total_num_slots > STACKERDB_INV_MAX.into() {
                 let reason = format!(
                     "Contract {} set more than the maximum number of slots",
                     contract_id
diff --git a/stackslib/src/net/stackerdb/mod.rs b/stackslib/src/net/stackerdb/mod.rs
index 1fbebba59f..7ee3799945 100644
--- a/stackslib/src/net/stackerdb/mod.rs
+++ b/stackslib/src/net/stackerdb/mod.rs
@@ -122,6 +122,7 @@ use std::collections::{HashMap, HashSet};
 
 use clarity::vm::types::QualifiedContractIdentifier;
 use libstackerdb::{SlotMetadata, STACKERDB_MAX_CHUNK_SIZE};
+use stacks_common::consts::SIGNER_SLOTS_PER_USER;
 use stacks_common::types::chainstate::{ConsensusHash, StacksAddress};
 use stacks_common::util::get_epoch_time_secs;
 use stacks_common::util::hash::Sha512Trunc256Sum;
@@ -142,9 +143,11 @@ use crate::util_lib::boot::boot_code_id;
 use crate::util_lib::db::{DBConn, DBTx, Error as db_error};
 
 /// maximum chunk inventory size
-pub const STACKERDB_INV_MAX: u32 = STACKERDB_PAGE_MAX * 2;
-/// maximum size of a single inventory page
-pub const STACKERDB_PAGE_MAX: u32 = 4096;
+pub const STACKERDB_INV_MAX: u32 = 2 * 4000 * SIGNER_SLOTS_PER_USER;
+/// maximum length of an inventory page's Clarity list
+pub const STACKERDB_PAGE_LIST_MAX: u32 = 4096;
+/// maximum number of pages that can be used in a StackerDB contract
+pub const STACKERDB_MAX_PAGE_COUNT: u32 = 2;
 
 pub const STACKERDB_PAGE_COUNT_FUNCTION: &str = "stackerdb-get-page-count";
 pub const STACKERDB_SLOTS_FUNCTION: &str = "stackerdb-get-signer-slots";

From 74e3cedeec5215f3286af6565c1503e578a848fb Mon Sep 17 00:00:00 2001
From: Matthew Little <zone117x@gmail.com>
Date: Thu, 1 Feb 2024 19:33:19 +0100
Subject: [PATCH 0549/1166] feat: add signer-key to synthetic pox events

---
 pox-locking/src/events.rs | 17 +++++++++++++----
 1 file changed, 13 insertions(+), 4 deletions(-)

diff --git a/pox-locking/src/events.rs b/pox-locking/src/events.rs
index 32909f47b1..cc727f2cae 100644
--- a/pox-locking/src/events.rs
+++ b/pox-locking/src/events.rs
@@ -127,7 +127,9 @@ fn create_event_info_data_code(
                         start-burn-height: {start_burn_height},
                         ;; how long to lock, in burn blocks
                         ;; equal to args[3]
-                        lock-period: {lock_period}
+                        lock-period: {lock_period},
+                        ;; equal to args[4]
+                        signer-key: {signer_key}
                     }}
                 }}
                 "#,
@@ -135,6 +137,7 @@ fn create_event_info_data_code(
                 lock_period = &args[3],
                 pox_addr = &args[1],
                 start_burn_height = &args[2],
+                signer_key = &args.get(3).map_or("none".to_string(), |v| v.to_string()),
             )
         }
         "delegate-stack-stx" => {
@@ -244,12 +247,15 @@ fn create_event_info_data_code(
                         ;; equal to args[0]
                         extend-count: {extend_count},
                         ;; new unlock burnchain block height
-                        unlock-burn-height: new-unlock-ht
+                        unlock-burn-height: new-unlock-ht,
+                        ;; equal to args[2]
+                        signer-key: {signer_key}
                     }}
                 }})
                 "#,
                 extend_count = &args[0],
                 pox_addr = &args[1],
+                signer_key = &args.get(2).map_or("none".to_string(), |v| v.to_string()),
             )
         }
         "delegate-stack-extend" => {
@@ -307,12 +313,15 @@ fn create_event_info_data_code(
                                         (unwrap-panic (map-get? logged-partial-stacked-by-cycle
                                             {{ pox-addr: {pox_addr}, sender: tx-sender, reward-cycle: {reward_cycle} }}))),
                         ;; delegator (this is the caller)
-                        delegator: tx-sender
+                        delegator: tx-sender,
+                        ;; equal to args[2]
+                        signer-key: {signer_key}
                     }}
                 }}
                 "#,
                 pox_addr = &args[0],
-                reward_cycle = &args[1]
+                reward_cycle = &args[1],
+                signer_key = &args.get(2).map_or("none".to_string(), |v| v.to_string()),
             )
         }
         "delegate-stx" => {

From 6f3f55d2aa649ec2c5956d8956e6a76e737091ac Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Thu, 1 Feb 2024 14:06:04 -0500
Subject: [PATCH 0550/1166] chore: Fix default Clippy warnings in `./clarity`

---
 clarity/src/vm/analysis/read_only_checker/mod.rs | 2 +-
 clarity/src/vm/ast/definition_sorter/mod.rs      | 4 ++--
 clarity/src/vm/database/clarity_db.rs            | 7 ++-----
 clarity/src/vm/functions/assets.rs               | 9 +++------
 clarity/src/vm/functions/mod.rs                  | 2 +-
 5 files changed, 9 insertions(+), 15 deletions(-)

diff --git a/clarity/src/vm/analysis/read_only_checker/mod.rs b/clarity/src/vm/analysis/read_only_checker/mod.rs
index 8261eb8eec..07b080fc43 100644
--- a/clarity/src/vm/analysis/read_only_checker/mod.rs
+++ b/clarity/src/vm/analysis/read_only_checker/mod.rs
@@ -169,7 +169,7 @@ impl<'a, 'b> ReadOnlyChecker<'a, 'b> {
         body: &SymbolicExpression,
     ) -> CheckResult<(ClarityName, bool)> {
         let function_name = signature
-            .get(0)
+            .first()
             .ok_or(CheckErrors::DefineFunctionBadSignature)?
             .match_atom()
             .ok_or(CheckErrors::BadFunctionName)?;
diff --git a/clarity/src/vm/ast/definition_sorter/mod.rs b/clarity/src/vm/ast/definition_sorter/mod.rs
index b7d5b67387..8d50055b0c 100644
--- a/clarity/src/vm/ast/definition_sorter/mod.rs
+++ b/clarity/src/vm/ast/definition_sorter/mod.rs
@@ -384,8 +384,8 @@ impl DefinitionSorter {
             DefineFunctions::lookup_by_name(function_name)?;
             Some(args)
         }?;
-        let defined_name = match args.get(0)?.match_list() {
-            Some(list) => list.get(0)?,
+        let defined_name = match args.first()?.match_list() {
+            Some(list) => list.first()?,
             _ => &args[0],
         };
         let tle_name = defined_name.match_atom()?;
diff --git a/clarity/src/vm/database/clarity_db.rs b/clarity/src/vm/database/clarity_db.rs
index 1c0a6c86bb..7eba4fc31b 100644
--- a/clarity/src/vm/database/clarity_db.rs
+++ b/clarity/src/vm/database/clarity_db.rs
@@ -1082,13 +1082,10 @@ impl<'a> ClarityDatabase<'a> {
         let value = Value::Tuple(
             TupleData::from_data(vec![
                 (
-                    ClarityName::try_from("reporter").expect("BUG: valid string representation"),
+                    ClarityName::from("reporter"),
                     Value::Principal(PrincipalData::Standard(reporter.clone())),
                 ),
-                (
-                    ClarityName::try_from("sequence").expect("BUG: valid string representation"),
-                    Value::UInt(seq as u128),
-                ),
+                (ClarityName::from("sequence"), Value::UInt(seq as u128)),
             ])
             .expect("BUG: valid tuple representation"),
         );
diff --git a/clarity/src/vm/functions/assets.rs b/clarity/src/vm/functions/assets.rs
index 53fe0af4cc..a513205c81 100644
--- a/clarity/src/vm/functions/assets.rs
+++ b/clarity/src/vm/functions/assets.rs
@@ -239,15 +239,12 @@ pub fn special_stx_account(
 
     TupleData::from_data(vec![
         (
-            "unlocked".try_into().unwrap(),
+            "unlocked".into(),
             Value::UInt(stx_balance.amount_unlocked()),
         ),
+        ("locked".into(), Value::UInt(stx_balance.amount_locked())),
         (
-            "locked".try_into().unwrap(),
-            Value::UInt(stx_balance.amount_locked()),
-        ),
-        (
-            "unlock-height".try_into().unwrap(),
+            "unlock-height".into(),
             Value::UInt(u128::from(stx_balance.effective_unlock_height(
                 v1_unlock_ht,
                 v2_unlock_ht,
diff --git a/clarity/src/vm/functions/mod.rs b/clarity/src/vm/functions/mod.rs
index 479f79581b..d3bdaf086a 100644
--- a/clarity/src/vm/functions/mod.rs
+++ b/clarity/src/vm/functions/mod.rs
@@ -609,7 +609,7 @@ fn special_print(
     env: &mut Environment,
     context: &LocalContext,
 ) -> Result<Value> {
-    let arg = args.get(0).ok_or_else(|| {
+    let arg = args.first().ok_or_else(|| {
         InterpreterError::BadSymbolicRepresentation("Print should have an argument".into())
     })?;
     let input = eval(arg, env, context)?;

From 0310a14d3e254a2d9326e511abfc029d095b7351 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Thu, 1 Feb 2024 14:30:45 -0500
Subject: [PATCH 0551/1166] chore: Fix default Clippy warnings in
 `./stacks-common`

---
 stacks-common/src/util/hash.rs | 27 ++++++++-------------------
 1 file changed, 8 insertions(+), 19 deletions(-)

diff --git a/stacks-common/src/util/hash.rs b/stacks-common/src/util/hash.rs
index 63c38b3dd8..dcf76c1839 100644
--- a/stacks-common/src/util/hash.rs
+++ b/stacks-common/src/util/hash.rs
@@ -302,13 +302,13 @@ impl MerkleHashFunc for Sha512Trunc256Sum {
 
 impl Keccak256Hash {
     pub fn from_data(data: &[u8]) -> Keccak256Hash {
-        Keccak256Hash(Keccak256::digest(data).try_into().unwrap())
+        Keccak256Hash(Keccak256::digest(data).into())
     }
 }
 
 impl Sha256Sum {
     pub fn from_data(data: &[u8]) -> Sha256Sum {
-        Sha256Sum(Sha256::digest(data).try_into().unwrap())
+        Sha256Sum(Sha256::digest(data).into())
     }
     pub fn zero() -> Sha256Sum {
         Sha256Sum([0u8; 32])
@@ -318,7 +318,7 @@ impl Sha256Sum {
 impl DoubleSha256 {
     pub fn from_data(data: &[u8]) -> DoubleSha256 {
         let hashed = Sha256::digest(Sha256::digest(data));
-        DoubleSha256(hashed.try_into().unwrap())
+        DoubleSha256(hashed.into())
     }
 
     /// Converts a hash to a little-endian Uint256
@@ -419,8 +419,8 @@ where
         loop {
             // next row
             let i = nodes.len() - 1;
-            let mut row_hashes = vec![];
-            row_hashes.reserve(nodes[i].len() / 2);
+            let capacity = (nodes[i].len() + 1) / 2;
+            let mut row_hashes = Vec::with_capacity(capacity);
 
             for j in 0..(nodes[i].len() / 2) {
                 let h = MerkleTree::get_node_hash(&nodes[i][2 * j], &nodes[i][2 * j + 1]);
@@ -536,15 +536,9 @@ where
     /// will be None if the data isn't a leaf.
     pub fn path(&self, data: &[u8]) -> Option<MerklePath<H>> {
         let leaf_hash = MerkleTree::get_leaf_hash(data);
-        let mut hash_index = match self.find_hash_index(&leaf_hash, 0) {
-            None => {
-                return None;
-            }
-            Some(i) => i,
-        };
+        let mut hash_index = self.find_hash_index(&leaf_hash, 0)?;
 
-        let mut path: MerklePath<H> = vec![];
-        path.reserve(self.nodes.len());
+        let mut path: MerklePath<H> = Vec::with_capacity(self.nodes.len());
 
         let mut next_hash = leaf_hash;
 
@@ -565,12 +559,7 @@ where
             }
 
             next_hash = MerkleTree::get_node_hash(&left, &right);
-            hash_index = match self.find_hash_index(&next_hash, i + 1) {
-                None => {
-                    return None;
-                }
-                Some(hi) => hi,
-            };
+            hash_index = self.find_hash_index(&next_hash, i + 1)?;
         }
 
         Some(path)

From 40be4b6e11312fe1a371990e3533bbd0a0be0c0e Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Thu, 1 Feb 2024 14:36:31 -0600
Subject: [PATCH 0552/1166] fix: update testing .signers contract

---
 stacks-signer/src/utils.rs | 45 +++++++++++++++++++-------------------
 1 file changed, 22 insertions(+), 23 deletions(-)

diff --git a/stacks-signer/src/utils.rs b/stacks-signer/src/utils.rs
index 5e7af9a4e0..1524d31d47 100644
--- a/stacks-signer/src/utils.rs
+++ b/stacks-signer/src/utils.rs
@@ -113,28 +113,27 @@ pub fn build_stackerdb_contract(
     signer_stacks_addresses: &[StacksAddress],
     slots_per_user: u32,
 ) -> String {
-    let mut stackerdb_contract = String::new(); // "
-    stackerdb_contract += "        ;; stacker DB\n";
-    stackerdb_contract += "        (define-read-only (stackerdb-get-signer-slots)\n";
-    stackerdb_contract += "            (ok (list\n";
-    for signer_stacks_address in signer_stacks_addresses {
-        stackerdb_contract += "                {\n";
-        stackerdb_contract +=
-            format!("                    signer: '{},\n", signer_stacks_address).as_str();
-        stackerdb_contract +=
-            format!("                    num-slots: u{}\n", slots_per_user).as_str();
-        stackerdb_contract += "                }\n";
-    }
-    stackerdb_contract += "                )))\n";
-    stackerdb_contract += "\n";
-    stackerdb_contract += "        (define-read-only (stackerdb-get-config)\n";
-    stackerdb_contract += "            (ok {\n";
-    stackerdb_contract += "                chunk-size: u4096,\n";
-    stackerdb_contract += "                write-freq: u0,\n";
-    stackerdb_contract += "                max-writes: u4096,\n";
-    stackerdb_contract += "                max-neighbors: u32,\n";
-    stackerdb_contract += "                hint-replicas: (list )\n";
-    stackerdb_contract += "            }))\n";
-    stackerdb_contract += "    ";
+    let stackers_list: Vec<String> = signer_stacks_addresses
+        .iter()
+        .map(|signer_addr| format!("{{ signer: '{signer_addr}, num-slots: u{slots_per_user}}}"))
+        .collect();
+    let stackers_joined = stackers_list.join(" ");
+
+    let stackerdb_contract = format!(
+        "
+        ;; stacker DB
+        (define-read-only (stackerdb-get-signer-slots (page uint))
+          (ok (list {stackers_joined})))
+        (define-read-only (stackerdb-get-page-count) (ok u1))
+        (define-read-only (stackerdb-get-config)
+          (ok {{
+                 chunk-size: u4096,
+                 write-freq: u0,
+                 max-writes: u4096,
+                 max-neighbors: u32,
+                 hint-replicas: (list )
+               }} ))
+    "
+    );
     stackerdb_contract
 }

From 0ade31549ad20c1c4f1483c535bdbdac9a771935 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Thu, 1 Feb 2024 16:02:27 -0500
Subject: [PATCH 0553/1166] chore: Fix `clippy::perf` warnings in `./stackslib`
 (except `large_enum_variant` and `result_large_err`)

---
 stackslib/src/blockstack_cli.rs               |   2 +-
 stackslib/src/burnchains/affirmation.rs       |  35 ++--
 stackslib/src/burnchains/bitcoin/bits.rs      |   4 +-
 stackslib/src/burnchains/bitcoin/indexer.rs   |   4 +-
 stackslib/src/burnchains/burnchain.rs         |  49 ++---
 stackslib/src/burnchains/db.rs                |  60 +++---
 .../src/chainstate/burn/db/processing.rs      |  18 +-
 stackslib/src/chainstate/burn/db/sortdb.rs    | 165 +++++++++-------
 stackslib/src/chainstate/burn/distribution.rs |   9 +-
 stackslib/src/chainstate/burn/mod.rs          |  10 +-
 .../burn/operations/leader_block_commit.rs    |  10 +-
 .../burn/operations/leader_key_register.rs    |   2 +-
 .../burn/operations/user_burn_support.rs      |   2 +-
 stackslib/src/chainstate/coordinator/mod.rs   | 182 +++++++++---------
 .../chainstate/nakamoto/coordinator/mod.rs    |  41 ++--
 stackslib/src/chainstate/nakamoto/mod.rs      |  50 +++--
 stackslib/src/chainstate/stacks/block.rs      |   2 +-
 stackslib/src/chainstate/stacks/boot/mod.rs   | 102 +++++-----
 stackslib/src/chainstate/stacks/db/blocks.rs  |  59 +++---
 stackslib/src/chainstate/stacks/db/mod.rs     |  12 +-
 .../src/chainstate/stacks/db/unconfirmed.rs   |   2 +-
 stackslib/src/chainstate/stacks/index/bits.rs |   2 +-
 stackslib/src/chainstate/stacks/index/marf.rs |  20 +-
 stackslib/src/chainstate/stacks/index/mod.rs  |  17 +-
 stackslib/src/chainstate/stacks/index/node.rs |   8 +-
 .../src/chainstate/stacks/index/trie_sql.rs   |   2 +-
 stackslib/src/chainstate/stacks/miner.rs      |   2 +-
 stackslib/src/clarity_cli.rs                  |   7 +-
 stackslib/src/clarity_vm/clarity.rs           |  14 +-
 stackslib/src/clarity_vm/database/marf.rs     | 100 ++++++----
 stackslib/src/clarity_vm/database/mod.rs      |  30 +--
 stackslib/src/main.rs                         |  26 +--
 stackslib/src/net/api/getattachmentsinv.rs    |   2 +-
 stackslib/src/net/api/getpoxinfo.rs           |  18 +-
 stackslib/src/net/chat.rs                     |   6 +-
 stackslib/src/net/db.rs                       |   2 +-
 stackslib/src/net/p2p.rs                      |  10 +-
 stackslib/src/net/poll.rs                     |  11 +-
 stackslib/src/net/prune.rs                    |  14 +-
 stackslib/src/net/stackerdb/db.rs             |   2 +-
 stackslib/src/util_lib/db.rs                  |   2 +-
 41 files changed, 584 insertions(+), 531 deletions(-)

diff --git a/stackslib/src/blockstack_cli.rs b/stackslib/src/blockstack_cli.rs
index e85d02bc7f..a636b6343e 100644
--- a/stackslib/src/blockstack_cli.rs
+++ b/stackslib/src/blockstack_cli.rs
@@ -597,7 +597,7 @@ fn generate_secret_key(args: &[String], version: TransactionVersion) -> Result<S
 }}",
         sk.to_hex(),
         pk.to_hex(),
-        address.to_string()
+        address
     ))
 }
 
diff --git a/stackslib/src/burnchains/affirmation.rs b/stackslib/src/burnchains/affirmation.rs
index b7a83f2f1b..245807bb64 100644
--- a/stackslib/src/burnchains/affirmation.rs
+++ b/stackslib/src/burnchains/affirmation.rs
@@ -554,10 +554,12 @@ pub fn read_prepare_phase_commits<B: BurnchainHeaderReader>(
     let mut ret = vec![];
     for header in headers.into_iter() {
         let blk = BurnchainDB::get_burnchain_block(&burnchain_tx.conn(), &header.block_hash)
-            .expect(&format!(
-                "BUG: failed to load prepare-phase block {} ({})",
-                &header.block_hash, header.block_height
-            ));
+            .unwrap_or_else(|_| {
+                panic!(
+                    "BUG: failed to load prepare-phase block {} ({})",
+                    &header.block_hash, header.block_height
+                )
+            });
 
         let mut block_ops = vec![];
         for op in blk.ops.into_iter() {
@@ -639,10 +641,12 @@ pub fn read_parent_block_commits<B: BurnchainHeaderReader>(
 
             let mut found = false;
             let blk = BurnchainDB::get_burnchain_block(burnchain_tx.conn(), &hdr.block_hash)
-                .expect(&format!(
-                    "BUG: failed to load existing block {} ({})",
-                    &hdr.block_hash, &hdr.block_height
-                ));
+                .unwrap_or_else(|_| {
+                    panic!(
+                        "BUG: failed to load existing block {} ({})",
+                        &hdr.block_hash, &hdr.block_height
+                    )
+                });
 
             for parent_op in blk.ops.into_iter() {
                 if let BlockstackOperationType::LeaderBlockCommit(parent_opdata) = parent_op {
@@ -942,18 +946,17 @@ pub fn find_heaviest_block_commit<B: BurnchainHeaderReader>(
     let heaviest_ancestor_header = indexer
         .read_burnchain_headers(ancestor_block, ancestor_block + 1)?
         .first()
-        .expect(&format!(
-            "BUG: no block headers for height {}",
-            ancestor_block
-        ))
+        .unwrap_or_else(|| panic!("BUG: no block headers for height {}", ancestor_block))
         .to_owned();
 
     let heaviest_ancestor_block =
         BurnchainDB::get_burnchain_block(burnchain_tx.conn(), &heaviest_ancestor_header.block_hash)
-            .expect(&format!(
-                "BUG: no ancestor block {:?} ({})",
-                &heaviest_ancestor_header.block_hash, heaviest_ancestor_header.block_height
-            ));
+            .unwrap_or_else(|_| {
+                panic!(
+                    "BUG: no ancestor block {:?} ({})",
+                    &heaviest_ancestor_header.block_hash, heaviest_ancestor_header.block_height
+                )
+            });
 
     // find the PoX anchor block-commit, if it exists at all
     // (note that it may not -- a rich attacker can force F*w confirmations with lots of BTC on a
diff --git a/stackslib/src/burnchains/bitcoin/bits.rs b/stackslib/src/burnchains/bitcoin/bits.rs
index ec721fba3e..2fb1f8a493 100644
--- a/stackslib/src/burnchains/bitcoin/bits.rs
+++ b/stackslib/src/burnchains/bitcoin/bits.rs
@@ -572,13 +572,13 @@ impl BitcoinTxOutput {
             BitcoinAddress::from_bytes_legacy(
                 network_id,
                 LegacyBitcoinAddressType::PublicKeyHash,
-                &script_bytes[3..23].to_vec(),
+                &script_bytes[3..23],
             )
         } else if script_pubkey.is_p2sh() {
             BitcoinAddress::from_bytes_legacy(
                 network_id,
                 LegacyBitcoinAddressType::ScriptHash,
-                &script_bytes[2..22].to_vec(),
+                &script_bytes[2..22],
             )
         } else {
             Err(btc_error::InvalidByteSequence)
diff --git a/stackslib/src/burnchains/bitcoin/indexer.rs b/stackslib/src/burnchains/bitcoin/indexer.rs
index c3346b7bab..2d3e981e27 100644
--- a/stackslib/src/burnchains/bitcoin/indexer.rs
+++ b/stackslib/src/burnchains/bitcoin/indexer.rs
@@ -569,7 +569,9 @@ impl BitcoinIndexer {
                         test_debug!("Copy interval {} to {}", interval, &reorg_headers_path);
                         let work_score = canonical_spv_client
                             .find_interval_work(interval)?
-                            .expect(&format!("FATAL: no work score for interval {}", interval));
+                            .unwrap_or_else(|| {
+                                panic!("FATAL: no work score for interval {}", interval)
+                            });
                         reorg_spv_client.store_interval_work(interval, work_score)?;
                     }
                 }
diff --git a/stackslib/src/burnchains/burnchain.rs b/stackslib/src/burnchains/burnchain.rs
index b11866f6cd..e4706db29f 100644
--- a/stackslib/src/burnchains/burnchain.rs
+++ b/stackslib/src/burnchains/burnchain.rs
@@ -156,10 +156,12 @@ impl BurnchainStateTransition {
 
         // what epoch are we in?
         let epoch_id = SortitionDB::get_stacks_epoch(sort_tx, parent_snapshot.block_height + 1)?
-            .expect(&format!(
-                "FATAL: no epoch defined at burn height {}",
-                parent_snapshot.block_height + 1
-            ))
+            .unwrap_or_else(|| {
+                panic!(
+                    "FATAL: no epoch defined at burn height {}",
+                    parent_snapshot.block_height + 1
+                )
+            })
             .epoch_id;
 
         if !burnchain.is_in_prepare_phase(parent_snapshot.block_height + 1)
@@ -547,8 +549,7 @@ impl Burnchain {
     }
 
     pub fn regtest(working_dir: &str) -> Burnchain {
-        let ret =
-            Burnchain::new(working_dir, &"bitcoin".to_string(), &"regtest".to_string()).unwrap();
+        let ret = Burnchain::new(working_dir, "bitcoin", "regtest").unwrap();
         ret
     }
 
@@ -565,8 +566,7 @@ impl Burnchain {
         rng.fill_bytes(&mut byte_tail);
 
         let tmp_path = format!("/tmp/stacks-node-tests/unit-tests-{}", &to_hex(&byte_tail));
-        let mut ret =
-            Burnchain::new(&tmp_path, &"bitcoin".to_string(), &"mainnet".to_string()).unwrap();
+        let mut ret = Burnchain::new(&tmp_path, "bitcoin", "mainnet").unwrap();
         ret.first_block_height = first_block_height;
         ret.initial_reward_start_block = first_block_height;
         ret.first_block_hash = first_block_hash.clone();
@@ -1001,11 +1001,13 @@ impl Burnchain {
             &block.block_hash()
         );
 
-        let cur_epoch =
-            SortitionDB::get_stacks_epoch(db.conn(), block.block_height())?.expect(&format!(
-                "FATAL: no epoch for burn block height {}",
-                block.block_height()
-            ));
+        let cur_epoch = SortitionDB::get_stacks_epoch(db.conn(), block.block_height())?
+            .unwrap_or_else(|| {
+                panic!(
+                    "FATAL: no epoch for burn block height {}",
+                    block.block_height()
+                )
+            });
 
         let header = block.header();
         let blockstack_txs = burnchain_db.store_new_burnchain_block(
@@ -1206,10 +1208,9 @@ impl Burnchain {
 
                     let cur_epoch =
                         SortitionDB::get_stacks_epoch(parser_sortdb.conn(), ipc_block.height())?
-                            .expect(&format!(
-                                "FATAL: no stacks epoch defined for {}",
-                                ipc_block.height()
-                            ));
+                            .unwrap_or_else(|| {
+                                panic!("FATAL: no stacks epoch defined for {}", ipc_block.height())
+                            });
 
                     let parse_start = get_epoch_time_ms();
                     let burnchain_block = parser.parse(&ipc_block, cur_epoch.epoch_id)?;
@@ -1541,9 +1542,10 @@ impl Burnchain {
                     debug!("Try recv next block");
 
                     let cur_epoch =
-                        SortitionDB::get_stacks_epoch(sortdb.conn(), ipc_block.height())?.expect(
-                            &format!("FATAL: no stacks epoch defined for {}", ipc_block.height()),
-                        );
+                        SortitionDB::get_stacks_epoch(sortdb.conn(), ipc_block.height())?
+                            .unwrap_or_else(|| {
+                                panic!("FATAL: no stacks epoch defined for {}", ipc_block.height())
+                            });
 
                     let parse_start = get_epoch_time_ms();
                     let burnchain_block = parser.parse(&ipc_block, cur_epoch.epoch_id)?;
@@ -1580,9 +1582,10 @@ impl Burnchain {
                             continue;
                         }
 
-                        let epoch_index = StacksEpoch::find_epoch(&epochs, block_height).expect(
-                            &format!("FATAL: no epoch defined for height {}", block_height),
-                        );
+                        let epoch_index = StacksEpoch::find_epoch(&epochs, block_height)
+                            .unwrap_or_else(|| {
+                                panic!("FATAL: no epoch defined for height {}", block_height)
+                            });
 
                         let epoch_id = epochs[epoch_index].epoch_id;
 
diff --git a/stackslib/src/burnchains/db.rs b/stackslib/src/burnchains/db.rs
index e9b9f640b2..67c0f24a3c 100644
--- a/stackslib/src/burnchains/db.rs
+++ b/stackslib/src/burnchains/db.rs
@@ -570,10 +570,15 @@ impl<'a> BurnchainDBTransaction<'a> {
 
         let parent_metadata =
             BurnchainDB::get_commit_metadata(&self.sql_tx, &parent.burn_header_hash, &parent.txid)?
-                .expect(&format!(
-                    "BUG: no metadata found for parent block-commit {},{},{} in {}",
-                    parent.block_height, parent.vtxindex, &parent.txid, &parent.burn_header_hash
-                ));
+                .unwrap_or_else(|| {
+                    panic!(
+                        "BUG: no metadata found for parent block-commit {},{},{} in {}",
+                        parent.block_height,
+                        parent.vtxindex,
+                        &parent.txid,
+                        &parent.burn_header_hash
+                    )
+                });
 
         let (am, affirmed_reward_cycle) = if anchor_block.is_some() && descends_from_anchor_block {
             // this block-commit assumes the affirmation map of the anchor block as a prefix of its
@@ -630,7 +635,7 @@ impl<'a> BurnchainDBTransaction<'a> {
                 Some(parent_ab_rc) => {
                     // parent affirmed some past anchor block
                     let ab_metadata = BurnchainDB::get_canonical_anchor_block_commit_metadata(&self.sql_tx, indexer, parent_ab_rc)?
-                        .expect(&format!("BUG: parent descends from a reward cycle with an anchor block ({}), but no anchor block found", parent_ab_rc));
+                        .unwrap_or_else(|| panic!("BUG: parent descends from a reward cycle with an anchor block ({}), but no anchor block found", parent_ab_rc));
 
                     let mut am =
                         BurnchainDB::get_affirmation_map(&self.sql_tx, ab_metadata.affirmation_id)?
@@ -709,7 +714,7 @@ impl<'a> BurnchainDBTransaction<'a> {
             // affirmation map already exists.
             if cfg!(test) {
                 let _am_weight = BurnchainDB::get_affirmation_weight(&self.sql_tx, am_id)?
-                    .expect(&format!("BUG: no affirmation map {}", &am_id));
+                    .unwrap_or_else(|| panic!("BUG: no affirmation map {}", &am_id));
 
                 test_debug!("Affirmation map of prepare-phase block-commit {},{},{} (parent {},{}) is old: {:?} weight {} affirmed {:?}",
                             &block_commit.txid, block_commit.block_height, block_commit.vtxindex, block_commit.parent_block_ptr, block_commit.parent_vtxindex, &am, _am_weight, &affirmed_reward_cycle);
@@ -741,10 +746,15 @@ impl<'a> BurnchainDBTransaction<'a> {
 
         let parent_metadata =
             BurnchainDB::get_commit_metadata(&self.sql_tx, &parent.burn_header_hash, &parent.txid)?
-                .expect(&format!(
-                    "BUG: no metadata found for existing block commit {},{},{} in {}",
-                    parent.block_height, parent.vtxindex, &parent.txid, &parent.burn_header_hash
-                ));
+                .unwrap_or_else(|| {
+                    panic!(
+                        "BUG: no metadata found for existing block commit {},{},{} in {}",
+                        parent.block_height,
+                        parent.vtxindex,
+                        &parent.txid,
+                        &parent.burn_header_hash
+                    )
+                });
 
         test_debug!(
             "Reward-phase commit {},{},{} has parent {},{}, anchor block {:?}",
@@ -823,7 +833,7 @@ impl<'a> BurnchainDBTransaction<'a> {
             // affirmation map already exists.
             if cfg!(test) {
                 let _am_weight = BurnchainDB::get_affirmation_weight(&self.sql_tx, am_id)?
-                    .expect(&format!("BUG: no affirmation map {}", &am_id));
+                    .unwrap_or_else(|| panic!("BUG: no affirmation map {}", &am_id));
 
                 test_debug!("Affirmation map of reward-phase block-commit {},{},{} (parent {},{}) is old: {:?} weight {}",
                             &block_commit.txid, block_commit.block_height, block_commit.vtxindex, block_commit.parent_block_ptr, block_commit.parent_vtxindex, &am, _am_weight);
@@ -984,7 +994,7 @@ impl BurnchainDB {
                         let ppath = Path::new(path);
                         let pparent_path = ppath
                             .parent()
-                            .expect(&format!("BUG: no parent of '{}'", path));
+                            .unwrap_or_else(|| panic!("BUG: no parent of '{}'", path));
                         fs::create_dir_all(&pparent_path)
                             .map_err(|e| BurnchainError::from(DBError::IOError(e)))?;
 
@@ -1572,21 +1582,23 @@ impl BurnchainDB {
                     return Ok(am);
                 }
 
-                let am = BurnchainDB::get_affirmation_map(conn, metadata.affirmation_id)?.expect(
-                    &format!(
-                        "BUG: failed to load affirmation map {}",
-                        metadata.affirmation_id
-                    ),
-                );
+                let am = BurnchainDB::get_affirmation_map(conn, metadata.affirmation_id)?
+                    .unwrap_or_else(|| {
+                        panic!(
+                            "BUG: failed to load affirmation map {}",
+                            metadata.affirmation_id
+                        )
+                    });
 
                 if cfg!(test) {
                     let _weight =
-                        BurnchainDB::get_affirmation_weight(conn, metadata.affirmation_id)?.expect(
-                            &format!(
-                                "BUG: have affirmation map {} but no weight",
-                                &metadata.affirmation_id
-                            ),
-                        );
+                        BurnchainDB::get_affirmation_weight(conn, metadata.affirmation_id)?
+                            .unwrap_or_else(|| {
+                                panic!(
+                                    "BUG: have affirmation map {} but no weight",
+                                    &metadata.affirmation_id
+                                )
+                            });
 
                     test_debug!(
                         "Heaviest anchor block affirmation map is {:?} (ID {}, weight {})",
diff --git a/stackslib/src/chainstate/burn/db/processing.rs b/stackslib/src/chainstate/burn/db/processing.rs
index bf1e83efd9..0c899770d4 100644
--- a/stackslib/src/chainstate/burn/db/processing.rs
+++ b/stackslib/src/chainstate/burn/db/processing.rs
@@ -135,17 +135,13 @@ impl<'a> SortitionHandleTx<'a> {
         let total_burn = state_transition
             .accepted_ops
             .iter()
-            .fold(Some(0u64), |acc, op| {
-                if let Some(acc) = acc {
-                    let bf = match op {
-                        BlockstackOperationType::LeaderBlockCommit(ref op) => op.burn_fee,
-                        BlockstackOperationType::UserBurnSupport(ref op) => op.burn_fee,
-                        _ => 0,
-                    };
-                    acc.checked_add(bf)
-                } else {
-                    None
-                }
+            .try_fold(0u64, |acc, op| {
+                let bf = match op {
+                    BlockstackOperationType::LeaderBlockCommit(ref op) => op.burn_fee,
+                    BlockstackOperationType::UserBurnSupport(ref op) => op.burn_fee,
+                    _ => 0,
+                };
+                acc.checked_add(bf)
             });
 
         let txids = state_transition
diff --git a/stackslib/src/chainstate/burn/db/sortdb.rs b/stackslib/src/chainstate/burn/db/sortdb.rs
index 0be1c77487..97cd8a1032 100644
--- a/stackslib/src/chainstate/burn/db/sortdb.rs
+++ b/stackslib/src/chainstate/burn/db/sortdb.rs
@@ -1175,10 +1175,12 @@ impl<'a> SortitionHandleTx<'a> {
                     leader_key_vtxindex,
                     &parent_tip.sortition_id,
                 )?
-                .expect(&format!(
-                    "FATAL: no leader key for accepted block commit {} (at {},{})",
-                    &block_candidates[i].txid, leader_key_block_height, leader_key_vtxindex
-                ));
+                .unwrap_or_else(|| {
+                    panic!(
+                        "FATAL: no leader key for accepted block commit {} (at {},{})",
+                        &block_candidates[i].txid, leader_key_block_height, leader_key_vtxindex
+                    )
+                });
 
             leader_keys.push(leader_key);
         }
@@ -1246,10 +1248,12 @@ impl<'a> SortitionHandleTx<'a> {
         };
 
         let ancestor_hash = match self.get_indexed(&get_from, &db_keys::last_sortition())? {
-            Some(hex_str) => BurnchainHeaderHash::from_hex(&hex_str).expect(&format!(
-                "FATAL: corrupt database: failed to parse {} into a hex string",
-                &hex_str
-            )),
+            Some(hex_str) => BurnchainHeaderHash::from_hex(&hex_str).unwrap_or_else(|_| {
+                panic!(
+                    "FATAL: corrupt database: failed to parse {} into a hex string",
+                    &hex_str
+                )
+            }),
             None => {
                 // no prior sortitions, so get the first
                 return SortitionDB::get_first_block_snapshot(self.tx());
@@ -1258,10 +1262,9 @@ impl<'a> SortitionHandleTx<'a> {
 
         self.get_block_snapshot(&ancestor_hash, &chain_tip)
             .map(|snapshot_opt| {
-                snapshot_opt.expect(&format!(
-                    "FATAL: corrupt index: no snapshot {}",
-                    ancestor_hash
-                ))
+                snapshot_opt.unwrap_or_else(|| {
+                    panic!("FATAL: corrupt index: no snapshot {}", ancestor_hash)
+                })
             })
     }
 
@@ -1356,10 +1359,12 @@ impl<'a> SortitionHandleTx<'a> {
         for _i in oldest_height..current_block_height {
             let ancestor_snapshot = self
                 .get_block_snapshot(&last_snapshot.parent_burn_header_hash, &chain_tip)?
-                .expect(&format!(
-                    "Discontiguous index: missing block {}",
-                    last_snapshot.parent_burn_header_hash
-                ));
+                .unwrap_or_else(|| {
+                    panic!(
+                        "Discontiguous index: missing block {}",
+                        last_snapshot.parent_burn_header_hash
+                    )
+                });
             if check(&ancestor_snapshot.consensus_hash) {
                 return Ok(true);
             }
@@ -1608,10 +1613,12 @@ impl<'a> SortitionHandleTx<'a> {
     ) -> Result<PoxAddress, db_error> {
         let entry_str = self
             .get_indexed(sortition_id, &db_keys::pox_reward_set_entry(entry_ix))?
-            .expect(&format!(
-                "CORRUPTION: expected reward set entry at index={}, but not found",
-                entry_ix
-            ));
+            .unwrap_or_else(|| {
+                panic!(
+                    "CORRUPTION: expected reward set entry at index={}, but not found",
+                    entry_ix
+                )
+            });
         Ok(PoxAddress::from_db_string(&entry_str).expect("FATAL: could not decode PoX address"))
     }
 
@@ -1724,10 +1731,12 @@ impl<'a> SortitionHandleTx<'a> {
             .ok_or(db_error::NotFoundError)?;
 
         let cur_epoch =
-            SortitionDB::get_stacks_epoch(self, block_sn.block_height)?.expect(&format!(
-                "FATAL: no epoch defined for burn height {}",
-                block_sn.block_height
-            ));
+            SortitionDB::get_stacks_epoch(self, block_sn.block_height)?.unwrap_or_else(|| {
+                panic!(
+                    "FATAL: no epoch defined for burn height {}",
+                    block_sn.block_height
+                )
+            });
 
         if cur_epoch.epoch_id >= StacksEpochId::Epoch30 {
             // Nakamoto blocks are always processed in order since the chain can't fork
@@ -2185,10 +2194,12 @@ impl<'a> SortitionHandleConn<'a> {
         };
 
         let ancestor_hash = match self.get_indexed(&get_from, &db_keys::last_sortition())? {
-            Some(hex_str) => BurnchainHeaderHash::from_hex(&hex_str).expect(&format!(
-                "FATAL: corrupt database: failed to parse {} into a hex string",
-                &hex_str
-            )),
+            Some(hex_str) => BurnchainHeaderHash::from_hex(&hex_str).unwrap_or_else(|_| {
+                panic!(
+                    "FATAL: corrupt database: failed to parse {} into a hex string",
+                    &hex_str
+                )
+            }),
             None => {
                 // no prior sortitions, so get the first
                 return self.get_first_block_snapshot();
@@ -2196,10 +2207,8 @@ impl<'a> SortitionHandleConn<'a> {
         };
 
         self.get_block_snapshot(&ancestor_hash).map(|snapshot_opt| {
-            snapshot_opt.expect(&format!(
-                "FATAL: corrupt index: no snapshot {}",
-                ancestor_hash
-            ))
+            snapshot_opt
+                .unwrap_or_else(|| panic!("FATAL: corrupt index: no snapshot {}", ancestor_hash))
         })
     }
 
@@ -2911,7 +2920,7 @@ impl SortitionDB {
         let mut first_sn = first_snapshot.clone();
         first_sn.sortition_id = SortitionId::sentinel();
         let (index_root, pox_payout) =
-            db_tx.index_add_fork_info(&mut first_sn, &first_snapshot, &vec![], None, None, None)?;
+            db_tx.index_add_fork_info(&mut first_sn, &first_snapshot, &[], None, None, None)?;
         first_snapshot.index_root = index_root;
 
         db_tx.insert_block_snapshot(&first_snapshot, pox_payout)?;
@@ -3599,10 +3608,12 @@ impl<'a> SortitionDBConn<'a> {
                 db_handle.conn(),
                 &ancestor_consensus_hash,
             )?
-            .expect(&format!(
-                "Discontiguous index: missing block for consensus hash {}",
-                ancestor_consensus_hash
-            ));
+            .unwrap_or_else(|| {
+                panic!(
+                    "Discontiguous index: missing block for consensus hash {}",
+                    ancestor_consensus_hash
+                )
+            });
 
             // this can happen if this call is interleaved with a PoX invalidation transaction
             if !ancestor_snapshot.pox_valid {
@@ -3627,10 +3638,12 @@ impl<'a> SortitionDBConn<'a> {
                 db_handle.conn(),
                 &ancestor_snapshot.parent_sortition_id,
             )?
-            .expect(&format!(
-                "Discontiguous index: missing parent block of parent burn header hash {}",
-                &ancestor_snapshot.parent_burn_header_hash
-            ));
+            .unwrap_or_else(|| {
+                panic!(
+                    "Discontiguous index: missing parent block of parent burn header hash {}",
+                    &ancestor_snapshot.parent_burn_header_hash
+                )
+            });
 
             ancestor_consensus_hash = ancestor_snapshot_parent.consensus_hash;
         }
@@ -3693,10 +3706,12 @@ impl<'a> SortitionDBConn<'a> {
     ) -> Result<PoxAddress, db_error> {
         let entry_str = self
             .get_indexed(sortition_id, &db_keys::pox_reward_set_entry(entry_ix))?
-            .expect(&format!(
-                "CORRUPTION: expected reward set entry at index={}, but not found",
-                entry_ix
-            ));
+            .unwrap_or_else(|| {
+                panic!(
+                    "CORRUPTION: expected reward set entry at index={}, but not found",
+                    entry_ix
+                )
+            });
         Ok(PoxAddress::from_db_string(&entry_str).expect("FATAL: could not decode PoX address"))
     }
 
@@ -3917,10 +3932,8 @@ impl SortitionDB {
             None => return Ok(None),
         };
         let snapshot =
-            SortitionDB::get_block_snapshot(self.conn(), &prepare_end_sortid)?.expect(&format!(
-            "BUG: Sortition ID for prepare phase end is known, but no BlockSnapshot is stored: {}",
-            &prepare_end_sortid
-        ));
+            SortitionDB::get_block_snapshot(self.conn(), &prepare_end_sortid)?.unwrap_or_else(|| panic!("BUG: Sortition ID for prepare phase end is known, but no BlockSnapshot is stored: {}",
+            &prepare_end_sortid));
         Ok(Some(snapshot))
     }
 
@@ -4019,10 +4032,12 @@ impl SortitionDB {
             })?;
 
         let cur_epoch = SortitionDB::get_stacks_epoch(self.conn(), burn_header.block_height)?
-            .expect(&format!(
-                "FATAL: no epoch defined for burn height {}",
-                burn_header.block_height
-            ));
+            .unwrap_or_else(|| {
+                panic!(
+                    "FATAL: no epoch defined for burn height {}",
+                    burn_header.block_height
+                )
+            });
 
         let mut sortition_db_handle = SortitionHandleTx::begin(self, &parent_sort_id)?;
         let parent_snapshot = sortition_db_handle
@@ -4120,12 +4135,13 @@ impl SortitionDB {
             .mix_burn_header(&parent_snapshot.burn_header_hash);
 
         let cur_epoch =
-            SortitionDB::get_stacks_epoch(self.conn(), parent_snapshot.block_height + 1)?.expect(
-                &format!(
-                    "FATAL: no epoch defined for burn height {}",
-                    parent_snapshot.block_height + 1
-                ),
-            );
+            SortitionDB::get_stacks_epoch(self.conn(), parent_snapshot.block_height + 1)?
+                .unwrap_or_else(|| {
+                    panic!(
+                        "FATAL: no epoch defined for burn height {}",
+                        parent_snapshot.block_height + 1
+                    )
+                });
 
         let mut sortition_db_handle =
             SortitionHandleTx::begin(self, &parent_snapshot.sortition_id)?;
@@ -4446,10 +4462,13 @@ impl SortitionDB {
         conn: &Connection,
     ) -> Result<(ConsensusHash, BlockHeaderHash, u64), db_error> {
         let sn = SortitionDB::get_canonical_burn_chain_tip(conn)?;
-        let cur_epoch = SortitionDB::get_stacks_epoch(conn, sn.block_height)?.expect(&format!(
-            "FATAL: no epoch defined for burn height {}",
-            sn.block_height
-        ));
+        let cur_epoch =
+            SortitionDB::get_stacks_epoch(conn, sn.block_height)?.unwrap_or_else(|| {
+                panic!(
+                    "FATAL: no epoch defined for burn height {}",
+                    sn.block_height
+                )
+            });
 
         if cur_epoch.epoch_id >= StacksEpochId::Epoch30 {
             // nakamoto behavior -- look to the stacks_chain_tip table
@@ -5069,10 +5088,12 @@ impl SortitionDB {
         };
 
         let ancestor_hash = match tx.get_indexed(&get_from, &db_keys::last_sortition())? {
-            Some(hex_str) => BurnchainHeaderHash::from_hex(&hex_str).expect(&format!(
-                "FATAL: corrupt database: failed to parse {} into a hex string",
-                &hex_str
-            )),
+            Some(hex_str) => BurnchainHeaderHash::from_hex(&hex_str).unwrap_or_else(|_| {
+                panic!(
+                    "FATAL: corrupt database: failed to parse {} into a hex string",
+                    &hex_str
+                )
+            }),
             None => {
                 // no prior sortitions, so get the first
                 return SortitionDB::get_first_block_snapshot(tx);
@@ -5131,10 +5152,12 @@ impl<'a> SortitionHandleTx<'a> {
         sn.index_root = root_hash.clone();
 
         let cur_epoch =
-            SortitionDB::get_stacks_epoch(self, snapshot.block_height)?.expect(&format!(
-                "FATAL: no epoch defined for burn height {}",
-                snapshot.block_height
-            ));
+            SortitionDB::get_stacks_epoch(self, snapshot.block_height)?.unwrap_or_else(|| {
+                panic!(
+                    "FATAL: no epoch defined for burn height {}",
+                    snapshot.block_height
+                )
+            });
 
         if cur_epoch.epoch_id >= StacksEpochId::Epoch30 {
             // nakamoto behavior
diff --git a/stackslib/src/chainstate/burn/distribution.rs b/stackslib/src/chainstate/burn/distribution.rs
index 8e76950d3a..213b2f00fe 100644
--- a/stackslib/src/chainstate/burn/distribution.rs
+++ b/stackslib/src/chainstate/burn/distribution.rs
@@ -390,12 +390,9 @@ impl BurnSamplePoint {
     pub fn get_total_burns(burn_dist: &[BurnSamplePoint]) -> Option<u64> {
         burn_dist
             .iter()
-            .fold(Some(0), |burns_so_far, sample_point| {
-                if let Some(burns_so_far) = burns_so_far {
-                    burns_so_far.checked_add(sample_point.burns.try_into().ok()?)
-                } else {
-                    None
-                }
+            .try_fold(0u64, |burns_so_far, sample_point| {
+                let n = u64::try_from(sample_point.burns).ok()?;
+                burns_so_far.checked_add(n)
             })
     }
 }
diff --git a/stackslib/src/chainstate/burn/mod.rs b/stackslib/src/chainstate/burn/mod.rs
index 55b917a3b9..08d08cebd5 100644
--- a/stackslib/src/chainstate/burn/mod.rs
+++ b/stackslib/src/chainstate/burn/mod.rs
@@ -361,10 +361,12 @@ impl ConsensusHashExtensions for ConsensusHash {
             let prev_block: u64 = block_height - (((1 as u64) << i) - 1);
             let prev_ch = sort_tx
                 .get_consensus_at(prev_block)
-                .expect(&format!(
-                    "FATAL: failed to get consensus hash at {} in fork {}",
-                    prev_block, &sort_tx.context.chain_tip
-                ))
+                .unwrap_or_else(|_| {
+                    panic!(
+                        "FATAL: failed to get consensus hash at {} in fork {}",
+                        prev_block, &sort_tx.context.chain_tip
+                    )
+                })
                 .unwrap_or(ConsensusHash::empty());
 
             debug!("Consensus at {}: {}", prev_block, &prev_ch);
diff --git a/stackslib/src/chainstate/burn/operations/leader_block_commit.rs b/stackslib/src/chainstate/burn/operations/leader_block_commit.rs
index 426447c350..ab06f718ce 100644
--- a/stackslib/src/chainstate/burn/operations/leader_block_commit.rs
+++ b/stackslib/src/chainstate/burn/operations/leader_block_commit.rs
@@ -979,10 +979,12 @@ impl LeaderBlockCommitOp {
             );
             return Err(op_error::BlockCommitBadInput);
         }
-        let epoch = SortitionDB::get_stacks_epoch(tx, self.block_height)?.expect(&format!(
-            "FATAL: impossible block height: no epoch defined for {}",
-            self.block_height
-        ));
+        let epoch = SortitionDB::get_stacks_epoch(tx, self.block_height)?.unwrap_or_else(|| {
+            panic!(
+                "FATAL: impossible block height: no epoch defined for {}",
+                self.block_height
+            )
+        });
 
         let intended_modulus = (self.burn_block_mined_at() + 1) % BURN_BLOCK_MINED_AT_MODULUS;
         let actual_modulus = self.block_height % BURN_BLOCK_MINED_AT_MODULUS;
diff --git a/stackslib/src/chainstate/burn/operations/leader_key_register.rs b/stackslib/src/chainstate/burn/operations/leader_key_register.rs
index 7f317f8466..22c88df6d7 100644
--- a/stackslib/src/chainstate/burn/operations/leader_key_register.rs
+++ b/stackslib/src/chainstate/burn/operations/leader_key_register.rs
@@ -110,7 +110,7 @@ impl LeaderKeyRegisterOp {
 
         let consensus_hash = ConsensusHash::from_bytes(&data[0..20])
             .expect("FATAL: invalid byte slice for consensus hash");
-        let pubkey = match VRFPublicKey::from_bytes(&data[20..52].to_vec()) {
+        let pubkey = match VRFPublicKey::from_bytes(&data[20..52]) {
             Some(pubk) => pubk,
             None => {
                 warn!("Invalid VRF public key");
diff --git a/stackslib/src/chainstate/burn/operations/user_burn_support.rs b/stackslib/src/chainstate/burn/operations/user_burn_support.rs
index cd17b39a27..cd0ff1a4f5 100644
--- a/stackslib/src/chainstate/burn/operations/user_burn_support.rs
+++ b/stackslib/src/chainstate/burn/operations/user_burn_support.rs
@@ -70,7 +70,7 @@ impl UserBurnSupportOp {
 
         let consensus_hash = ConsensusHash::from_vec(&consensus_hash_trunc)
             .expect("FATAL: invalid data slice for consensus hash");
-        let pubkey = match VRFPublicKey::from_bytes(&data[19..51].to_vec()) {
+        let pubkey = match VRFPublicKey::from_bytes(&data[19..51]) {
             Some(pubk) => pubk,
             None => {
                 warn!("Invalid VRF public key");
diff --git a/stackslib/src/chainstate/coordinator/mod.rs b/stackslib/src/chainstate/coordinator/mod.rs
index 85bfc83b48..1ff286d841 100644
--- a/stackslib/src/chainstate/coordinator/mod.rs
+++ b/stackslib/src/chainstate/coordinator/mod.rs
@@ -306,9 +306,7 @@ impl<'a, T: BlockEventDispatcher> RewardSetProvider for OnChainRewardSetProvider
         block_id: &StacksBlockId,
     ) -> Result<RewardSet, Error> {
         let cur_epoch = SortitionDB::get_stacks_epoch(sortdb.conn(), cycle_start_burn_height)?
-            .expect(&format!(
-                "FATAL: no epoch for burn height {cycle_start_burn_height}",
-            ));
+            .unwrap_or_else(|| panic!("FATAL: no epoch for burn height {cycle_start_burn_height}"));
         let cycle = burnchain
             .block_height_to_reward_cycle(cycle_start_burn_height)
             .expect("FATAL: no reward cycle for burn height");
@@ -718,9 +716,8 @@ pub fn get_reward_cycle_info<U: RewardSetProvider>(
     provider: &U,
     always_use_affirmation_maps: bool,
 ) -> Result<Option<RewardCycleInfo>, Error> {
-    let epoch_at_height = SortitionDB::get_stacks_epoch(sort_db.conn(), burn_height)?.expect(
-        &format!("FATAL: no epoch defined for burn height {}", burn_height),
-    );
+    let epoch_at_height = SortitionDB::get_stacks_epoch(sort_db.conn(), burn_height)?
+        .unwrap_or_else(|| panic!("FATAL: no epoch defined for burn height {}", burn_height));
     if !burnchain.is_reward_cycle_start(burn_height) {
         return Ok(None);
     }
@@ -1658,7 +1655,7 @@ impl<
 
         let sortition_height =
             SortitionDB::get_block_snapshot(self.sortition_db.conn(), &sortition_tip)?
-                .expect(&format!("FATAL: no sortition {}", &sortition_tip))
+                .unwrap_or_else(|| panic!("FATAL: no sortition {}", &sortition_tip))
                 .block_height;
 
         let sortition_reward_cycle = self
@@ -1812,10 +1809,12 @@ impl<
                 first_invalidate_start_block - 1,
             )
             .expect("FATAL: failed to read burnchain DB")
-            .expect(&format!(
-                "FATAL: no burnchain block {}",
-                first_invalidate_start_block - 1
-            ));
+            .unwrap_or_else(|| {
+                panic!(
+                    "FATAL: no burnchain block {}",
+                    first_invalidate_start_block - 1
+                )
+            });
 
             // find the burnchain block hash and height of the first burnchain block in which we'll
             // invalidate all descendant sortitions, no matter what.
@@ -1824,10 +1823,12 @@ impl<
                 last_invalidate_start_block - 1,
             )
             .expect("FATAL: failed to read burnchain DB")
-            .expect(&format!(
-                "FATAL: no burnchain block {}",
-                last_invalidate_start_block - 1
-            ));
+            .unwrap_or_else(|| {
+                panic!(
+                    "FATAL: no burnchain block {}",
+                    last_invalidate_start_block - 1
+                )
+            });
 
             // let invalidation_height = revalidate_sn.block_height;
             let invalidation_height = revalidated_burn_header.block_height;
@@ -1842,10 +1843,12 @@ impl<
                         last_invalidate_start_block - 1,
                         &sortition_tip,
                     )?
-                    .expect(&format!(
-                        "BUG: no ancestral sortition at height {}",
-                        last_invalidate_start_block - 1
-                    ));
+                    .unwrap_or_else(|| {
+                        panic!(
+                            "BUG: no ancestral sortition at height {}",
+                            last_invalidate_start_block - 1
+                        )
+                    });
 
                     valid_sortitions
                         .last()
@@ -1898,12 +1901,8 @@ impl<
                             &valid_sn.winning_stacks_block_hash,
                         ).expect("FATAL: failed to query chainstate DB");
 
-                        SortitionDB::revalidate_snapshot_with_block(sort_tx, &valid_sn.sortition_id, &canonical_ch, &canonical_bhh, canonical_height, Some(block_known)).expect(
-                            &format!(
-                                "FATAL: failed to revalidate sortition {}",
-                                valid_sn.sortition_id
-                            ),
-                        );
+                        SortitionDB::revalidate_snapshot_with_block(sort_tx, &valid_sn.sortition_id, &canonical_ch, &canonical_bhh, canonical_height, Some(block_known)).unwrap_or_else(|_| panic!("FATAL: failed to revalidate sortition {}",
+                                valid_sn.sortition_id));
                     }
 
                     // recalculate highest valid sortition with revalidated snapshots
@@ -1914,10 +1913,8 @@ impl<
                             &sortition_tip,
                         )
                         .expect("FATAL: failed to query the sortition DB")
-                        .expect(&format!(
-                            "BUG: no ancestral sortition at height {}",
-                            last_invalidate_start_block - 1
-                        ));
+                        .unwrap_or_else(|| panic!("BUG: no ancestral sortition at height {}",
+                            last_invalidate_start_block - 1));
 
                         valid_sortitions
                             .last()
@@ -1962,12 +1959,8 @@ impl<
                             &dirty_sort_sn.winning_stacks_block_hash,
                         ).expect("FATAL: failed to query chainstate DB");
 
-                        SortitionDB::revalidate_snapshot_with_block(sort_tx, dirty_sort_id, &canonical_ch, &canonical_bhh, canonical_height, Some(block_known)).expect(
-                            &format!(
-                                "FATAL: failed to revalidate dirty sortition {}",
-                                dirty_sort_id
-                            ),
-                        );
+                        SortitionDB::revalidate_snapshot_with_block(sort_tx, dirty_sort_id, &canonical_ch, &canonical_bhh, canonical_height, Some(block_known)).unwrap_or_else(|_| panic!("FATAL: failed to revalidate dirty sortition {}",
+                                dirty_sort_id));
                     }
 
                     // recalculate highest valid stacks tip once more
@@ -1996,12 +1989,8 @@ impl<
                         &highest_valid_sn.winning_stacks_block_hash,
                     ).expect("FATAL: failed to query chainstate DB");
 
-                    SortitionDB::revalidate_snapshot_with_block(sort_tx, &highest_valid_sortition_id, &canonical_ch, &canonical_bhh, canonical_height, Some(block_known)).expect(
-                        &format!(
-                            "FATAL: failed to revalidate highest valid sortition {}",
-                            &highest_valid_sortition_id
-                        ),
-                    );
+                    SortitionDB::revalidate_snapshot_with_block(sort_tx, &highest_valid_sortition_id, &canonical_ch, &canonical_bhh, canonical_height, Some(block_known)).unwrap_or_else(|_| panic!("FATAL: failed to revalidate highest valid sortition {}",
+                            &highest_valid_sortition_id));
                 },
             )?;
 
@@ -2276,9 +2265,10 @@ impl<
         rc_info: &mut RewardCycleInfo,
     ) -> Result<Option<BlockHeaderHash>, Error> {
         let cur_epoch =
-            SortitionDB::get_stacks_epoch(self.sortition_db.conn(), header.block_height)?.expect(
-                &format!("BUG: no epoch defined at height {}", header.block_height),
-            );
+            SortitionDB::get_stacks_epoch(self.sortition_db.conn(), header.block_height)?
+                .unwrap_or_else(|| {
+                    panic!("BUG: no epoch defined at height {}", header.block_height)
+                });
 
         if cur_epoch.epoch_id >= StacksEpochId::Epoch21 || self.config.always_use_affirmation_maps {
             // potentially have an anchor block, but only process the next reward cycle (and
@@ -2342,10 +2332,12 @@ impl<
         // burnchain has advanced to epoch 3.0, but has our sortition DB?
         let canonical_snapshot = match self.canonical_sortition_tip.as_ref() {
             Some(sn_tip) => SortitionDB::get_block_snapshot(self.sortition_db.conn(), sn_tip)?
-                .expect(&format!(
-                    "FATAL: do not have previously-calculated highest valid sortition tip {}",
-                    sn_tip
-                )),
+                .unwrap_or_else(|| {
+                    panic!(
+                        "FATAL: do not have previously-calculated highest valid sortition tip {}",
+                        sn_tip
+                    )
+                }),
             None => SortitionDB::get_canonical_burn_chain_tip(&self.sortition_db.conn())?,
         };
         let target_epoch_index = StacksEpoch::find_epoch(&epochs, canonical_snapshot.block_height)
@@ -2400,20 +2392,24 @@ impl<
         // only do this if affirmation maps are supported in this epoch.
         let before_canonical_snapshot = match self.canonical_sortition_tip.as_ref() {
             Some(sn_tip) => SortitionDB::get_block_snapshot(self.sortition_db.conn(), sn_tip)?
-                .expect(&format!(
-                    "FATAL: do not have previously-calculated highest valid sortition tip {}",
-                    sn_tip
-                )),
+                .unwrap_or_else(|| {
+                    panic!(
+                        "FATAL: do not have previously-calculated highest valid sortition tip {}",
+                        sn_tip
+                    )
+                }),
             None => SortitionDB::get_canonical_burn_chain_tip(&self.sortition_db.conn())?,
         };
         let cur_epoch = SortitionDB::get_stacks_epoch(
             self.sortition_db.conn(),
             before_canonical_snapshot.block_height,
         )?
-        .expect(&format!(
-            "BUG: no epoch defined at height {}",
-            before_canonical_snapshot.block_height
-        ));
+        .unwrap_or_else(|| {
+            panic!(
+                "BUG: no epoch defined at height {}",
+                before_canonical_snapshot.block_height
+            )
+        });
 
         if self.affirmation_maps_active(&cur_epoch.epoch_id) {
             self.handle_affirmation_reorg()?;
@@ -2422,10 +2418,12 @@ impl<
         // Retrieve canonical burnchain chain tip from the BurnchainBlocksDB
         let canonical_snapshot = match self.canonical_sortition_tip.as_ref() {
             Some(sn_tip) => SortitionDB::get_block_snapshot(self.sortition_db.conn(), sn_tip)?
-                .expect(&format!(
-                    "FATAL: do not have previously-calculated highest valid sortition tip {}",
-                    sn_tip
-                )),
+                .unwrap_or_else(|| {
+                    panic!(
+                        "FATAL: do not have previously-calculated highest valid sortition tip {}",
+                        sn_tip
+                    )
+                }),
             None => SortitionDB::get_canonical_burn_chain_tip(&self.sortition_db.conn())?,
         };
 
@@ -2748,10 +2746,14 @@ impl<
 
         // Retrieve canonical burnchain chain tip from the BurnchainBlocksDB
         let canonical_snapshot = match self.canonical_sortition_tip.as_ref() {
-            Some(sn_tip) => SortitionDB::get_block_snapshot(&sort_tx, sn_tip)?.expect(&format!(
-                "FATAL: do not have previously-calculated highest valid sortition tip {}",
-                sn_tip
-            )),
+            Some(sn_tip) => {
+                SortitionDB::get_block_snapshot(&sort_tx, sn_tip)?.unwrap_or_else(|| {
+                    panic!(
+                        "FATAL: do not have previously-calculated highest valid sortition tip {}",
+                        sn_tip
+                    )
+                })
+            }
             None => SortitionDB::get_canonical_burn_chain_tip(&sort_tx)?,
         };
         let highest_valid_sortition_id = canonical_snapshot.sortition_id;
@@ -2804,10 +2806,12 @@ impl<
             canonical_height,
             Some(block_known),
         )
-        .expect(&format!(
-            "FATAL: failed to revalidate highest valid sortition {}",
-            &highest_valid_sortition_id
-        ));
+        .unwrap_or_else(|_| {
+            panic!(
+                "FATAL: failed to revalidate highest valid sortition {}",
+                &highest_valid_sortition_id
+            )
+        });
 
         sort_tx.commit()?;
 
@@ -3124,10 +3128,12 @@ impl<
                     self.sortition_db.conn(),
                     pox_anchor_snapshot.block_height,
                 )?
-                .expect(&format!(
-                    "BUG: no epoch defined at height {}",
-                    pox_anchor_snapshot.block_height
-                ));
+                .unwrap_or_else(|| {
+                    panic!(
+                        "BUG: no epoch defined at height {}",
+                        pox_anchor_snapshot.block_height
+                    )
+                });
                 if cur_epoch.epoch_id < StacksEpochId::Epoch21 {
                     panic!("FATAL: found Stacks block that 2.0/2.05 rules would treat as an anchor block, but that 2.1+ would not");
                 }
@@ -3185,10 +3191,12 @@ impl<
                         self.sortition_db.conn(),
                         &canonical_sortition_tip,
                     )?
-                    .expect(&format!(
-                        "FAIL: could not find data for the canonical sortition {}",
-                        &canonical_sortition_tip
-                    ));
+                    .unwrap_or_else(|| {
+                        panic!(
+                            "FAIL: could not find data for the canonical sortition {}",
+                            &canonical_sortition_tip
+                        )
+                    });
                     let new_canonical_stacks_block =
                         new_canonical_block_snapshot.get_canonical_stacks_block_id();
 
@@ -3262,10 +3270,12 @@ impl<
                             self.sortition_db.conn(),
                             winner_snapshot.block_height,
                         )?
-                        .expect(&format!(
-                            "BUG: no epoch defined at height {}",
-                            winner_snapshot.block_height
-                        ));
+                        .unwrap_or_else(|| {
+                            panic!(
+                                "BUG: no epoch defined at height {}",
+                                winner_snapshot.block_height
+                            )
+                        });
 
                         if self.affirmation_maps_active(&cur_epoch.epoch_id) {
                             if let Some(pox_anchor) =
@@ -3321,10 +3331,8 @@ impl<
         let mut prep_end = self
             .sortition_db
             .get_prepare_end_for(sortition_id, &block_id)?
-            .expect(&format!(
-                "FAIL: expected to get a sortition for a chosen anchor block {}, but not found.",
-                &block_id
-            ));
+            .unwrap_or_else(|| panic!("FAIL: expected to get a sortition for a chosen anchor block {}, but not found.",
+                &block_id));
 
         // was this block a pox anchor for an even earlier reward cycle?
         while let Some(older_prep_end) = self
@@ -3365,10 +3373,8 @@ pub fn check_chainstate_db_versions(
         // check sortition DB and load up the current epoch
         let max_height = SortitionDB::get_highest_block_height_from_path(&sortdb_path)
             .expect("FATAL: could not query sortition DB for maximum block height");
-        let cur_epoch_idx = StacksEpoch::find_epoch(epochs, max_height).expect(&format!(
-            "FATAL: no epoch defined for burn height {}",
-            max_height
-        ));
+        let cur_epoch_idx = StacksEpoch::find_epoch(epochs, max_height)
+            .unwrap_or_else(|| panic!("FATAL: no epoch defined for burn height {}", max_height));
         let cur_epoch = epochs[cur_epoch_idx].epoch_id;
 
         // save for later
diff --git a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
index de145b6eec..4ba670f2b4 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
@@ -79,10 +79,12 @@ impl<'a, T: BlockEventDispatcher> OnChainRewardSetProvider<'a, T> {
         );
 
         let cur_epoch = SortitionDB::get_stacks_epoch(sortdb.conn(), cycle_start_burn_height)?
-            .expect(&format!(
-                "FATAL: no epoch defined for burn height {}",
-                cycle_start_burn_height
-            ));
+            .unwrap_or_else(|| {
+                panic!(
+                    "FATAL: no epoch defined for burn height {}",
+                    cycle_start_burn_height
+                )
+            });
 
         // This method should only ever called if the current reward cycle is a nakamoto reward cycle
         //  (i.e., its reward set is fetched for determining signer sets (and therefore agg keys).
@@ -168,10 +170,7 @@ pub fn get_nakamoto_reward_cycle_info<U: RewardSetProvider>(
     provider: &U,
 ) -> Result<Option<RewardCycleInfo>, Error> {
     let epoch_at_height = SortitionDB::get_stacks_epoch(sort_db.conn(), burn_height)?
-        .expect(&format!(
-            "FATAL: no epoch defined for burn height {}",
-            burn_height
-        ))
+        .unwrap_or_else(|| panic!("FATAL: no epoch defined for burn height {}", burn_height))
         .epoch_id;
 
     assert!(
@@ -387,10 +386,12 @@ impl<
         // what epoch are we in?
         let cur_epoch =
             SortitionDB::get_stacks_epoch(self.sortition_db.conn(), canonical_sn.block_height)?
-                .expect(&format!(
-                    "BUG: no epoch defined at height {}",
-                    canonical_sn.block_height
-                ));
+                .unwrap_or_else(|| {
+                    panic!(
+                        "BUG: no epoch defined at height {}",
+                        canonical_sn.block_height
+                    )
+                });
 
         if cur_epoch.epoch_id < StacksEpochId::Epoch30 {
             return Ok(false);
@@ -584,10 +585,12 @@ impl<
                 &self.sortition_db.conn(),
                 &canonical_stacks_consensus_hash,
             )?
-            .expect(&format!(
-                "FATAL: unreachable: consensus hash {} has no snapshot",
-                &canonical_stacks_consensus_hash
-            ));
+            .unwrap_or_else(|| {
+                panic!(
+                    "FATAL: unreachable: consensus hash {} has no snapshot",
+                    &canonical_stacks_consensus_hash
+                )
+            });
 
             // are we in the prepare phase?
             if !self.burnchain.is_in_prepare_phase(stacks_sn.block_height) {
@@ -599,9 +602,9 @@ impl<
             let current_reward_cycle = self
                 .burnchain
                 .block_height_to_reward_cycle(stacks_sn.block_height)
-                .expect(&format!(
-                    "FATAL: unreachable: burnchain block height has no reward cycle"
-                ));
+                .unwrap_or_else(|| {
+                    panic!("FATAL: unreachable: burnchain block height has no reward cycle")
+                });
 
             let last_processed_reward_cycle = {
                 let ic = self.sortition_db.index_handle(&canonical_sortition_tip);
diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index a6ad43e671..4eeab4c1bd 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -270,10 +270,7 @@ pub struct MaturedMinerRewards {
 impl MaturedMinerRewards {
     /// Get the list of miner rewards this struct represents
     pub fn consolidate(&self) -> Vec<MinerReward> {
-        let mut ret = vec![];
-        ret.push(self.recipient.clone());
-        ret.push(self.parent_reward.clone());
-        ret
+        vec![self.recipient.clone(), self.parent_reward.clone()]
     }
 }
 
@@ -1329,11 +1326,13 @@ impl NakamotoChainState {
             sort_tx,
             &next_ready_block.header.consensus_hash,
         )?
-        .expect(&format!(
-            "CORRUPTION: staging Nakamoto block {}/{} does not correspond to a burn block",
-            &next_ready_block.header.consensus_hash,
-            &next_ready_block.header.block_hash()
-        ));
+        .unwrap_or_else(|| {
+            panic!(
+                "CORRUPTION: staging Nakamoto block {}/{} does not correspond to a burn block",
+                &next_ready_block.header.consensus_hash,
+                &next_ready_block.header.block_hash()
+            )
+        });
 
         debug!("Process staging Nakamoto block";
                "consensus_hash" => %next_ready_block.header.consensus_hash,
@@ -1865,45 +1864,40 @@ impl NakamotoChainState {
                     ],
                 )?
                 .expect_optional()
-                .expect(&format!(
-                    "FATAL: missing PoX address in slot {} out of {} in reward cycle {}",
-                    index, list_length, reward_cycle
-                ))
+                .unwrap_or_else(|| {
+                    panic!(
+                        "FATAL: missing PoX address in slot {} out of {} in reward cycle {}",
+                        index, list_length, reward_cycle
+                    )
+                })
                 .expect_tuple();
 
             let pox_addr_tuple = entry
                 .get("pox-addr")
-                .expect(&format!("FATAL: no `pox-addr` in return value from (get-reward-set-pox-address u{} u{})", reward_cycle, index))
+                .unwrap_or_else(|_| panic!("FATAL: no `pox-addr` in return value from (get-reward-set-pox-address u{} u{})", reward_cycle, index))
                 .to_owned();
 
             let reward_address = PoxAddress::try_from_pox_tuple(is_mainnet, &pox_addr_tuple)
-                .expect(&format!(
-                    "FATAL: not a valid PoX address: {:?}",
-                    &pox_addr_tuple
-                ));
+                .unwrap_or_else(|| panic!("FATAL: not a valid PoX address: {:?}", &pox_addr_tuple));
 
             let total_ustx = entry
                 .get("total-ustx")
-                .expect(&format!("FATAL: no 'total-ustx' in return value from (get-reward-set-pox-address u{} u{})", reward_cycle, index))
+                .unwrap_or_else(|_| panic!("FATAL: no 'total-ustx' in return value from (get-reward-set-pox-address u{} u{})", reward_cycle, index))
                 .to_owned()
                 .expect_u128();
 
             let stacker = entry
                 .get("stacker")
-                .expect(&format!(
-                    "FATAL: no 'stacker' in return value from (get-reward-set-pox-address u{} u{})",
-                    reward_cycle, index
-                ))
+                .unwrap_or_else(|_| panic!("FATAL: no 'stacker' in return value from (get-reward-set-pox-address u{} u{})",
+                    reward_cycle, index))
                 .to_owned()
                 .expect_optional()
                 .map(|value| value.expect_principal());
 
             let signer = entry
                 .get("signer")
-                .expect(&format!(
-                    "FATAL: no 'signer' in return value from (get-reward-set-pox-address u{} u{})",
-                    reward_cycle, index
-                ))
+                .unwrap_or_else(|_| panic!("FATAL: no 'signer' in return value from (get-reward-set-pox-address u{} u{})",
+                    reward_cycle, index))
                 .to_owned()
                 .expect_buff(SIGNERS_PK_LEN);
             // (buff 33) only enforces max size, not min size, so we need to do a len check
@@ -2939,7 +2933,7 @@ impl NakamotoChainState {
                     vm_env.execute_contract_allow_private(
                         &boot_code_id(POX_4_NAME, mainnet),
                         "get-aggregate-public-key",
-                        &vec![SymbolicExpression::atom_value(Value::UInt(u128::from(
+                        &[SymbolicExpression::atom_value(Value::UInt(u128::from(
                             parent_reward_cycle,
                         )))],
                         true,
diff --git a/stackslib/src/chainstate/stacks/block.rs b/stackslib/src/chainstate/stacks/block.rs
index 011ff9baa8..2932231103 100644
--- a/stackslib/src/chainstate/stacks/block.rs
+++ b/stackslib/src/chainstate/stacks/block.rs
@@ -256,7 +256,7 @@ impl StacksBlockHeader {
         let valid = match VRF::verify(
             &leader_key.public_key,
             &self.proof,
-            &sortition_chain_tip.sortition_hash.as_bytes().to_vec(),
+            sortition_chain_tip.sortition_hash.as_bytes().as_ref(),
         ) {
             Ok(v) => {
                 if !v {
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index f4b57ab470..98906bdf61 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -589,7 +589,7 @@ impl StacksChainState {
                         env.execute_contract(
                             &contract_identifier,
                             function,
-                            &vec![SymbolicExpression::atom_value(Value::UInt(reward_cycle))],
+                            &[SymbolicExpression::atom_value(Value::UInt(reward_cycle))],
                             true,
                         )
                     },
@@ -888,26 +888,25 @@ impl StacksChainState {
                     &format!("(get-reward-set-pox-address u{} u{})", reward_cycle, i),
                 )?
                 .expect_optional()
-                .expect(&format!(
-                    "FATAL: missing PoX address in slot {} out of {} in reward cycle {}",
-                    i, num_addrs, reward_cycle
-                ))
+                .unwrap_or_else(|| {
+                    panic!(
+                        "FATAL: missing PoX address in slot {} out of {} in reward cycle {}",
+                        i, num_addrs, reward_cycle
+                    )
+                })
                 .expect_tuple();
 
             let pox_addr_tuple = tuple_data
                 .get("pox-addr")
-                .expect(&format!("FATAL: no 'pox-addr' in return value from (get-reward-set-pox-address u{} u{})", reward_cycle, i))
+                .unwrap_or_else(|_| panic!("FATAL: no 'pox-addr' in return value from (get-reward-set-pox-address u{} u{})", reward_cycle, i))
                 .to_owned();
 
             let reward_address = PoxAddress::try_from_pox_tuple(self.mainnet, &pox_addr_tuple)
-                .expect(&format!(
-                    "FATAL: not a valid PoX address: {:?}",
-                    &pox_addr_tuple
-                ));
+                .unwrap_or_else(|| panic!("FATAL: not a valid PoX address: {:?}", &pox_addr_tuple));
 
             let total_ustx = tuple_data
                 .get("total-ustx")
-                .expect(&format!("FATAL: no 'total-ustx' in return value from (get-reward-set-pox-address u{} u{})", reward_cycle, i))
+                .unwrap_or_else(|_| panic!("FATAL: no 'total-ustx' in return value from (get-reward-set-pox-address u{} u{})", reward_cycle, i))
                 .to_owned()
                 .expect_u128();
 
@@ -966,35 +965,32 @@ impl StacksChainState {
                     &format!("(get-reward-set-pox-address u{} u{})", reward_cycle, i),
                 )?
                 .expect_optional()
-                .expect(&format!(
-                    "FATAL: missing PoX address in slot {} out of {} in reward cycle {}",
-                    i, num_addrs, reward_cycle
-                ))
+                .unwrap_or_else(|| {
+                    panic!(
+                        "FATAL: missing PoX address in slot {} out of {} in reward cycle {}",
+                        i, num_addrs, reward_cycle
+                    )
+                })
                 .expect_tuple();
 
             let pox_addr_tuple = tuple
                 .get("pox-addr")
-                .expect(&format!("FATAL: no `pox-addr` in return value from (get-reward-set-pox-address u{} u{})", reward_cycle, i))
+                .unwrap_or_else(|_| panic!("FATAL: no `pox-addr` in return value from (get-reward-set-pox-address u{} u{})", reward_cycle, i))
                 .to_owned();
 
             let reward_address = PoxAddress::try_from_pox_tuple(self.mainnet, &pox_addr_tuple)
-                .expect(&format!(
-                    "FATAL: not a valid PoX address: {:?}",
-                    &pox_addr_tuple
-                ));
+                .unwrap_or_else(|| panic!("FATAL: not a valid PoX address: {:?}", &pox_addr_tuple));
 
             let total_ustx = tuple
                 .get("total-ustx")
-                .expect(&format!("FATAL: no 'total-ustx' in return value from (get-reward-set-pox-address u{} u{})", reward_cycle, i))
+                .unwrap_or_else(|_| panic!("FATAL: no 'total-ustx' in return value from (get-reward-set-pox-address u{} u{})", reward_cycle, i))
                 .to_owned()
                 .expect_u128();
 
             let stacker = tuple
                 .get("stacker")
-                .expect(&format!(
-                    "FATAL: no 'stacker' in return value from (get-reward-set-pox-address u{} u{})",
-                    reward_cycle, i
-                ))
+                .unwrap_or_else(|_| panic!("FATAL: no 'stacker' in return value from (get-reward-set-pox-address u{} u{})",
+                    reward_cycle, i))
                 .to_owned()
                 .expect_optional()
                 .map(|value| value.expect_principal());
@@ -1056,35 +1052,32 @@ impl StacksChainState {
                     &format!("(get-reward-set-pox-address u{} u{})", reward_cycle, i),
                 )?
                 .expect_optional()
-                .expect(&format!(
-                    "FATAL: missing PoX address in slot {} out of {} in reward cycle {}",
-                    i, num_addrs, reward_cycle
-                ))
+                .unwrap_or_else(|| {
+                    panic!(
+                        "FATAL: missing PoX address in slot {} out of {} in reward cycle {}",
+                        i, num_addrs, reward_cycle
+                    )
+                })
                 .expect_tuple();
 
             let pox_addr_tuple = tuple
                 .get("pox-addr")
-                .expect(&format!("FATAL: no `pox-addr` in return value from (get-reward-set-pox-address u{} u{})", reward_cycle, i))
+                .unwrap_or_else(|_| panic!("FATAL: no `pox-addr` in return value from (get-reward-set-pox-address u{} u{})", reward_cycle, i))
                 .to_owned();
 
             let reward_address = PoxAddress::try_from_pox_tuple(self.mainnet, &pox_addr_tuple)
-                .expect(&format!(
-                    "FATAL: not a valid PoX address: {:?}",
-                    &pox_addr_tuple
-                ));
+                .unwrap_or_else(|| panic!("FATAL: not a valid PoX address: {:?}", &pox_addr_tuple));
 
             let total_ustx = tuple
                 .get("total-ustx")
-                .expect(&format!("FATAL: no 'total-ustx' in return value from (get-reward-set-pox-address u{} u{})", reward_cycle, i))
+                .unwrap_or_else(|_| panic!("FATAL: no 'total-ustx' in return value from (get-reward-set-pox-address u{} u{})", reward_cycle, i))
                 .to_owned()
                 .expect_u128();
 
             let stacker = tuple
                 .get("stacker")
-                .expect(&format!(
-                    "FATAL: no 'stacker' in return value from (get-reward-set-pox-address u{} u{})",
-                    reward_cycle, i
-                ))
+                .unwrap_or_else(|_| panic!("FATAL: no 'stacker' in return value from (get-reward-set-pox-address u{} u{})",
+                    reward_cycle, i))
                 .to_owned()
                 .expect_optional()
                 .map(|value| value.expect_principal());
@@ -1146,45 +1139,40 @@ impl StacksChainState {
                     &format!("(get-reward-set-pox-address u{} u{})", reward_cycle, i),
                 )?
                 .expect_optional()
-                .expect(&format!(
-                    "FATAL: missing PoX address in slot {} out of {} in reward cycle {}",
-                    i, num_addrs, reward_cycle
-                ))
+                .unwrap_or_else(|| {
+                    panic!(
+                        "FATAL: missing PoX address in slot {} out of {} in reward cycle {}",
+                        i, num_addrs, reward_cycle
+                    )
+                })
                 .expect_tuple();
 
             let pox_addr_tuple = tuple
                 .get("pox-addr")
-                .expect(&format!("FATAL: no `pox-addr` in return value from (get-reward-set-pox-address u{} u{})", reward_cycle, i))
+                .unwrap_or_else(|_| panic!("FATAL: no `pox-addr` in return value from (get-reward-set-pox-address u{} u{})", reward_cycle, i))
                 .to_owned();
 
             let reward_address = PoxAddress::try_from_pox_tuple(self.mainnet, &pox_addr_tuple)
-                .expect(&format!(
-                    "FATAL: not a valid PoX address: {:?}",
-                    &pox_addr_tuple
-                ));
+                .unwrap_or_else(|| panic!("FATAL: not a valid PoX address: {:?}", &pox_addr_tuple));
 
             let total_ustx = tuple
                 .get("total-ustx")
-                .expect(&format!("FATAL: no 'total-ustx' in return value from (get-reward-set-pox-address u{} u{})", reward_cycle, i))
+                .unwrap_or_else(|_| panic!("FATAL: no 'total-ustx' in return value from (get-reward-set-pox-address u{} u{})", reward_cycle, i))
                 .to_owned()
                 .expect_u128();
 
             let stacker = tuple
                 .get("stacker")
-                .expect(&format!(
-                    "FATAL: no 'stacker' in return value from (get-reward-set-pox-address u{} u{})",
-                    reward_cycle, i
-                ))
+                .unwrap_or_else(|_| panic!("FATAL: no 'stacker' in return value from (get-reward-set-pox-address u{} u{})",
+                    reward_cycle, i))
                 .to_owned()
                 .expect_optional()
                 .map(|value| value.expect_principal());
 
             let signer = tuple
                 .get("signer")
-                .expect(&format!(
-                    "FATAL: no 'signer' in return value from (get-reward-set-pox-address u{} u{})",
-                    reward_cycle, i
-                ))
+                .unwrap_or_else(|_| panic!("FATAL: no 'signer' in return value from (get-reward-set-pox-address u{} u{})",
+                    reward_cycle, i))
                 .to_owned()
                 .expect_buff(SIGNERS_PK_LEN);
             // (buff 33) only enforces max size, not min size, so we need to do a len check
diff --git a/stackslib/src/chainstate/stacks/db/blocks.rs b/stackslib/src/chainstate/stacks/db/blocks.rs
index 4deeb57443..9421b66634 100644
--- a/stackslib/src/chainstate/stacks/db/blocks.rs
+++ b/stackslib/src/chainstate/stacks/db/blocks.rs
@@ -705,7 +705,7 @@ impl StacksChainState {
                 .expect("FATAL: failed to create block directory");
 
         let sz = fs::metadata(&block_path)
-            .expect(&format!("FATAL: failed to stat '{}'", &block_path))
+            .unwrap_or_else(|_| panic!("FATAL: failed to stat '{}'", &block_path))
             .len();
 
         if sz > 0 {
@@ -721,18 +721,22 @@ impl StacksChainState {
                 .expect("FATAL: index block path did not have file name");
             invalid_path.set_extension(&format!("invalid-{}", &random_bytes_str));
 
-            fs::copy(&block_path, &invalid_path).expect(&format!(
-                "FATAL: failed to copy '{}' to '{}'",
-                &block_path,
-                &invalid_path.to_string_lossy(),
-            ));
+            fs::copy(&block_path, &invalid_path).unwrap_or_else(|_| {
+                panic!(
+                    "FATAL: failed to copy '{}' to '{}'",
+                    &block_path,
+                    &invalid_path.to_string_lossy()
+                )
+            });
 
             // already freed?
             let sz = fs::metadata(&invalid_path)
-                .expect(&format!(
-                    "FATAL: failed to stat '{}'",
-                    &invalid_path.to_string_lossy()
-                ))
+                .unwrap_or_else(|_| {
+                    panic!(
+                        "FATAL: failed to stat '{}'",
+                        &invalid_path.to_string_lossy()
+                    )
+                })
                 .len();
 
             if sz > 0 {
@@ -742,10 +746,9 @@ impl StacksChainState {
                     .write(true)
                     .truncate(true)
                     .open(&block_path)
-                    .expect(&format!(
-                        "FATAL: Failed to mark block path '{}' as free",
-                        &block_path
-                    ));
+                    .unwrap_or_else(|_| {
+                        panic!("FATAL: Failed to mark block path '{}' as free", &block_path)
+                    });
             }
         }
     }
@@ -1219,13 +1222,15 @@ impl StacksChainState {
         loop {
             let microblock =
                 match StacksChainState::load_staging_microblock_bytes(blocks_conn, &mblock_hash)? {
-                    Some(mblock_data) => StacksMicroblock::consensus_deserialize(
-                        &mut &mblock_data[..],
-                    )
-                    .expect(&format!(
-                        "CORRUPTION: failed to parse microblock data for {}/{}-{}",
-                        parent_consensus_hash, parent_anchored_block_hash, &mblock_hash,
-                    )),
+                    Some(mblock_data) => {
+                        StacksMicroblock::consensus_deserialize(&mut &mblock_data[..])
+                            .unwrap_or_else(|_| {
+                                panic!(
+                                    "CORRUPTION: failed to parse microblock data for {}/{}-{}",
+                                    parent_consensus_hash, parent_anchored_block_hash, &mblock_hash
+                                )
+                            })
+                    }
                     None => {
                         test_debug!(
                             "No such microblock (processed={}): {}/{}-{} ({})",
@@ -1391,10 +1396,12 @@ impl StacksChainState {
                 blocks_conn,
                 &staging_microblocks[i].microblock_hash,
             )?
-            .expect(&format!(
-                "BUG: have record for {}-{} but no data",
-                &parent_index_block_hash, &staging_microblocks[i].microblock_hash
-            ));
+            .unwrap_or_else(|| {
+                panic!(
+                    "BUG: have record for {}-{} but no data",
+                    &parent_index_block_hash, &staging_microblocks[i].microblock_hash
+                )
+            });
 
             let mblock = match StacksMicroblock::consensus_deserialize(&mut &mblock_data[..]) {
                 Ok(mb) => mb,
@@ -2401,7 +2408,7 @@ impl StacksChainState {
                 StacksChainState::free_block(blocks_path, consensus_hash, anchored_block_hash);
             }
             Err(_) => {
-                StacksChainState::atomic_file_write(&block_path, &vec![])?;
+                StacksChainState::atomic_file_write(&block_path, &[])?;
             }
         }
 
diff --git a/stackslib/src/chainstate/stacks/db/mod.rs b/stackslib/src/chainstate/stacks/db/mod.rs
index d1cb81c6db..1c5c03c37a 100644
--- a/stackslib/src/chainstate/stacks/db/mod.rs
+++ b/stackslib/src/chainstate/stacks/db/mod.rs
@@ -1028,11 +1028,7 @@ impl StacksChainState {
     }
 
     pub fn load_db_config(conn: &DBConn) -> Result<DBConfig, db_error> {
-        let config = query_row::<DBConfig, _>(
-            conn,
-            &"SELECT * FROM db_config LIMIT 1".to_string(),
-            NO_PARAMS,
-        )?;
+        let config = query_row::<DBConfig, _>(conn, "SELECT * FROM db_config LIMIT 1", NO_PARAMS)?;
         Ok(config.expect("BUG: no db_config installed"))
     }
 
@@ -1409,7 +1405,7 @@ impl StacksChainState {
                                         Value::UInt(entry.no_vowel_discount.into());
                                     let buckets: Vec<_> = entry
                                         .buckets
-                                        .split(";")
+                                        .split(';')
                                         .map(|e| Value::UInt(e.parse::<u64>().unwrap().into()))
                                         .collect();
                                     assert_eq!(buckets.len(), 16);
@@ -1461,7 +1457,7 @@ impl StacksChainState {
                             let initial_names = get_names();
                             for entry in initial_names {
                                 let components: Vec<_> =
-                                    entry.fully_qualified_name.split(".").collect();
+                                    entry.fully_qualified_name.split('.').collect();
                                 assert_eq!(components.len(), 2);
 
                                 let namespace = {
@@ -1625,7 +1621,7 @@ impl StacksChainState {
                     MAINNET_2_0_GENESIS_ROOT_HASH,
                     "Incorrect root hash for genesis block computed. expected={} computed={}",
                     MAINNET_2_0_GENESIS_ROOT_HASH,
-                    genesis_root_hash.to_string()
+                    genesis_root_hash
                 )
             }
         }
diff --git a/stackslib/src/chainstate/stacks/db/unconfirmed.rs b/stackslib/src/chainstate/stacks/db/unconfirmed.rs
index c3d11c9627..24a4498cea 100644
--- a/stackslib/src/chainstate/stacks/db/unconfirmed.rs
+++ b/stackslib/src/chainstate/stacks/db/unconfirmed.rs
@@ -302,7 +302,7 @@ impl UnconfirmedState {
                 let (stx_fees, stx_burns, receipts) =
                     match StacksChainState::process_microblocks_transactions(
                         &mut clarity_tx,
-                        &vec![mblock.clone()],
+                        &[mblock.clone()],
                         ast_rules,
                     ) {
                         Ok(x) => x,
diff --git a/stackslib/src/chainstate/stacks/index/bits.rs b/stackslib/src/chainstate/stacks/index/bits.rs
index 88869d4172..e212b03299 100644
--- a/stackslib/src/chainstate/stacks/index/bits.rs
+++ b/stackslib/src/chainstate/stacks/index/bits.rs
@@ -89,7 +89,7 @@ pub fn check_node_id(nid: u8) -> bool {
 /// Helper to return the number of children in a Trie, given its ID.
 pub fn node_id_to_ptr_count(node_id: u8) -> usize {
     match TrieNodeID::from_u8(clear_backptr(node_id))
-        .expect(&format!("Unknown node ID {}", node_id))
+        .unwrap_or_else(|| panic!("Unknown node ID {}", node_id))
     {
         TrieNodeID::Leaf => 1,
         TrieNodeID::Node4 => 4,
diff --git a/stackslib/src/chainstate/stacks/index/marf.rs b/stackslib/src/chainstate/stacks/index/marf.rs
index 6cec632373..630454eabb 100644
--- a/stackslib/src/chainstate/stacks/index/marf.rs
+++ b/stackslib/src/chainstate/stacks/index/marf.rs
@@ -712,10 +712,12 @@ impl<T: MarfTrieId> MARF<T> {
     fn root_copy(storage: &mut TrieStorageConnection<T>, prev_block_hash: &T) -> Result<(), Error> {
         let (cur_block_hash, cur_block_id) = storage.get_cur_block_and_id();
         storage.open_block(prev_block_hash)?;
-        let prev_block_identifier = storage.get_cur_block_identifier().expect(&format!(
-            "called open_block on {}, but found no identifier",
-            prev_block_hash
-        ));
+        let prev_block_identifier = storage.get_cur_block_identifier().unwrap_or_else(|_| {
+            panic!(
+                "called open_block on {}, but found no identifier",
+                prev_block_hash
+            )
+        });
 
         let (mut prev_root, _) = Trie::read_root(storage)?;
         let new_root_hash = MARF::<T>::node_copy_update(&mut prev_root, prev_block_identifier)?;
@@ -743,7 +745,7 @@ impl<T: MarfTrieId> MARF<T> {
             // brand new storage
             trace!("Brand new storage -- start with {:?}", new_bhh);
             storage.extend_to_block(new_bhh)?;
-            let node = TrieNode256::new(&vec![]);
+            let node = TrieNode256::new(&[]);
             let hash = get_node_hash(&node, &vec![], storage.deref_mut());
             let root_ptr = storage.root_ptr();
             storage.write_nodetype(root_ptr, &TrieNodeType::Node256(Box::new(node)), hash)?;
@@ -982,7 +984,7 @@ impl<T: MarfTrieId> MARF<T> {
 
         storage.format()?;
         storage.extend_to_block(first_block_hash)?;
-        let node = TrieNode256::new(&vec![]);
+        let node = TrieNode256::new(&[]);
         let hash = get_node_hash(&node, &vec![], storage.deref_mut());
         let root_ptr = storage.root_ptr();
         let node_type = TrieNodeType::Node256(Box::new(node));
@@ -1259,7 +1261,7 @@ impl<T: MarfTrieId> MARF<T> {
             .enumerate()
             .zip(values[0..last].iter())
             .try_for_each(|((index, key), value)| {
-                let marf_leaf = TrieLeaf::from_value(&vec![], value.clone());
+                let marf_leaf = TrieLeaf::from_value(&[], value.clone());
                 let path = TriePath::from_key(key);
 
                 if eta_enabled {
@@ -1277,7 +1279,7 @@ impl<T: MarfTrieId> MARF<T> {
 
         if result.is_ok() {
             // last insert updates the root with the skiplist hash
-            let marf_leaf = TrieLeaf::from_value(&vec![], values[last].clone());
+            let marf_leaf = TrieLeaf::from_value(&[], values[last].clone());
             let path = TriePath::from_key(&keys[last]);
             result = MARF::insert_leaf(conn, block_hash, &path, &marf_leaf);
         }
@@ -1353,7 +1355,7 @@ impl<T: MarfTrieId> MARF<T> {
         if self.storage.readonly() {
             return Err(Error::ReadOnlyError);
         }
-        let marf_leaf = TrieLeaf::from_value(&vec![], value);
+        let marf_leaf = TrieLeaf::from_value(&[], value);
         let path = TriePath::from_key(key);
         self.insert_raw(path, marf_leaf)
     }
diff --git a/stackslib/src/chainstate/stacks/index/mod.rs b/stackslib/src/chainstate/stacks/index/mod.rs
index a712ee01a8..eb082747c5 100644
--- a/stackslib/src/chainstate/stacks/index/mod.rs
+++ b/stackslib/src/chainstate/stacks/index/mod.rs
@@ -233,9 +233,7 @@ impl From<u32> for MARFValue {
         if h.len() > MARF_VALUE_ENCODED_SIZE as usize {
             panic!("Cannot convert a u32 into a MARF Value.");
         }
-        for i in 0..h.len() {
-            d[i] = h[i];
-        }
+        d[..h.len()].copy_from_slice(&h[..]);
         MARFValue(d)
     }
 }
@@ -247,9 +245,7 @@ impl<T: MarfTrieId> From<T> for MARFValue {
         if h.len() > MARF_VALUE_ENCODED_SIZE as usize {
             panic!("Cannot convert a BHH into a MARF Value.");
         }
-        for i in 0..h.len() {
-            d[i] = h[i];
-        }
+        d[..h.len()].copy_from_slice(&h[..]);
         MARFValue(d)
     }
 }
@@ -258,9 +254,8 @@ impl From<MARFValue> for u32 {
     fn from(m: MARFValue) -> u32 {
         let h = m.0;
         let mut d = [0u8; 4];
-        for i in 0..4 {
-            d[i] = h[i];
-        }
+
+        d[..4].copy_from_slice(&h[..4]);
         for i in 4..h.len() {
             if h[i] != 0 {
                 panic!("Failed to convert MARF value into u32: data stored after 4th byte");
@@ -274,9 +269,7 @@ impl MARFValue {
     /// Construct from a TRIEHASH_ENCODED_SIZE-length slice
     pub fn from_value_hash_bytes(h: &[u8; TRIEHASH_ENCODED_SIZE]) -> MARFValue {
         let mut d = [0u8; MARF_VALUE_ENCODED_SIZE as usize];
-        for i in 0..TRIEHASH_ENCODED_SIZE {
-            d[i] = h[i];
-        }
+        d[..TRIEHASH_ENCODED_SIZE].copy_from_slice(&h[..TRIEHASH_ENCODED_SIZE]);
         MARFValue(d)
     }
 
diff --git a/stackslib/src/chainstate/stacks/index/node.rs b/stackslib/src/chainstate/stacks/index/node.rs
index ece5943949..109dbaa8fc 100644
--- a/stackslib/src/chainstate/stacks/index/node.rs
+++ b/stackslib/src/chainstate/stacks/index/node.rs
@@ -701,12 +701,10 @@ impl TrieNode16 {
     /// Promote a Node4 to a Node16
     pub fn from_node4(node4: &TrieNode4) -> TrieNode16 {
         let mut ptrs = [TriePtr::default(); 16];
-        for i in 0..4 {
-            ptrs[i] = node4.ptrs[i].clone();
-        }
+        ptrs[..4].copy_from_slice(&node4.ptrs[..4]);
         TrieNode16 {
             path: node4.path.clone(),
-            ptrs: ptrs,
+            ptrs,
         }
     }
 }
@@ -1166,7 +1164,7 @@ impl TrieNode for TrieLeaf {
     }
 
     fn empty() -> TrieLeaf {
-        TrieLeaf::new(&vec![], &[0u8; 40].to_vec())
+        TrieLeaf::new(&[], &[0u8; 40].to_vec())
     }
 
     fn walk(&self, _chr: u8) -> Option<TriePtr> {
diff --git a/stackslib/src/chainstate/stacks/index/trie_sql.rs b/stackslib/src/chainstate/stacks/index/trie_sql.rs
index 787a3b125a..d538ed7e50 100644
--- a/stackslib/src/chainstate/stacks/index/trie_sql.rs
+++ b/stackslib/src/chainstate/stacks/index/trie_sql.rs
@@ -388,7 +388,7 @@ pub fn write_trie_blob_to_unconfirmed<T: MarfTrieId>(
     };
 
     let block_id = get_unconfirmed_block_identifier(conn, block_hash)?
-        .expect(&format!("BUG: stored {} but got no block ID", block_hash));
+        .unwrap_or_else(|| panic!("BUG: stored {} but got no block ID", block_hash));
 
     debug!(
         "Wrote unconfirmed block trie {} to rowid {}",
diff --git a/stackslib/src/chainstate/stacks/miner.rs b/stackslib/src/chainstate/stacks/miner.rs
index 52c484ae1d..cc1cf25d76 100644
--- a/stackslib/src/chainstate/stacks/miner.rs
+++ b/stackslib/src/chainstate/stacks/miner.rs
@@ -1845,7 +1845,7 @@ impl StacksBlockBuilder {
                               "parent_index_hash" => %parent_index_hash,
                               "parent_consensus_hash" => %self.parent_consensus_hash,
                               "parent_microblock_hash" => match self.parent_microblock_hash.as_ref() {
-                                  Some(x) => format!("Some({})", x.to_string()),
+                                  Some(x) => format!("Some({x})"),
                                   None => "None".to_string(),
                               },
                               "error" => ?e);
diff --git a/stackslib/src/clarity_cli.rs b/stackslib/src/clarity_cli.rs
index 831853ff47..02dc8e3cf1 100644
--- a/stackslib/src/clarity_cli.rs
+++ b/stackslib/src/clarity_cli.rs
@@ -340,10 +340,7 @@ fn get_cli_db_path(db_path: &str) -> String {
     cli_db_path_buf.push("cli.sqlite");
     let cli_db_path = cli_db_path_buf
         .to_str()
-        .expect(&format!(
-            "FATAL: failed to convert '{}' to a string",
-            db_path
-        ))
+        .unwrap_or_else(|| panic!("FATAL: failed to convert '{}' to a string", db_path))
         .to_string();
     cli_db_path
 }
@@ -393,7 +390,7 @@ where
 {
     // store CLI data alongside the MARF database state
     let from = StacksBlockId::from_hex(blockhash)
-        .expect(&format!("FATAL: failed to parse inputted blockhash"));
+        .unwrap_or_else(|_| panic!("FATAL: failed to parse inputted blockhash: {blockhash}"));
     let to = StacksBlockId([2u8; 32]); // 0x0202020202 ... (pattern not used anywhere else)
 
     let marf_tx = marf_kv.begin(&from, &to);
diff --git a/stackslib/src/clarity_vm/clarity.rs b/stackslib/src/clarity_vm/clarity.rs
index 0c19aeb6cf..d4c8b799bf 100644
--- a/stackslib/src/clarity_vm/clarity.rs
+++ b/stackslib/src/clarity_vm/clarity.rs
@@ -263,14 +263,10 @@ impl ClarityInstance {
 
         let burn_height = header_db
             .get_burn_block_height_for_block(stacks_block)
-            .expect(&format!(
-                "Failed to get burn block height of {}",
-                stacks_block
-            ));
-        burn_state_db.get_stacks_epoch(burn_height).expect(&format!(
-            "Failed to get Stacks epoch for height = {}",
-            burn_height
-        ))
+            .unwrap_or_else(|| panic!("Failed to get burn block height of {}", stacks_block));
+        burn_state_db
+            .get_stacks_epoch(burn_height)
+            .unwrap_or_else(|| panic!("Failed to get Stacks epoch for height = {}", burn_height))
     }
 
     pub fn begin_block<'a, 'b>(
@@ -570,7 +566,7 @@ impl ClarityInstance {
         burn_state_db: &'a dyn BurnStateDB,
     ) -> ClarityReadOnlyConnection<'a> {
         self.read_only_connection_checked(at_block, header_db, burn_state_db)
-            .expect(&format!("BUG: failed to open block {}", at_block))
+            .unwrap_or_else(|_| panic!("BUG: failed to open block {}", at_block))
     }
 
     /// Open a read-only connection at `at_block`. This will be evaluated in the Stacks epoch that
diff --git a/stackslib/src/clarity_vm/database/marf.rs b/stackslib/src/clarity_vm/database/marf.rs
index c4c869d119..936d1456ab 100644
--- a/stackslib/src/clarity_vm/database/marf.rs
+++ b/stackslib/src/clarity_vm/database/marf.rs
@@ -195,14 +195,18 @@ impl MarfedKV {
         current: &StacksBlockId,
         next: &StacksBlockId,
     ) -> WritableMarfStore<'a> {
-        let mut tx = self.marf.begin_tx().expect(&format!(
-            "ERROR: Failed to begin new MARF block {} - {})",
-            current, next
-        ));
-        tx.begin(current, next).expect(&format!(
-            "ERROR: Failed to begin new MARF block {} - {})",
-            current, next
-        ));
+        let mut tx = self.marf.begin_tx().unwrap_or_else(|_| {
+            panic!(
+                "ERROR: Failed to begin new MARF block {} - {})",
+                current, next
+            )
+        });
+        tx.begin(current, next).unwrap_or_else(|_| {
+            panic!(
+                "ERROR: Failed to begin new MARF block {} - {})",
+                current, next
+            )
+        });
 
         let chain_tip = tx
             .get_open_chain_tip()
@@ -216,14 +220,18 @@ impl MarfedKV {
     }
 
     pub fn begin_unconfirmed<'a>(&'a mut self, current: &StacksBlockId) -> WritableMarfStore<'a> {
-        let mut tx = self.marf.begin_tx().expect(&format!(
-            "ERROR: Failed to begin new unconfirmed MARF block for {})",
-            current
-        ));
-        tx.begin_unconfirmed(current).expect(&format!(
-            "ERROR: Failed to begin new unconfirmed MARF block for {})",
-            current
-        ));
+        let mut tx = self.marf.begin_tx().unwrap_or_else(|_| {
+            panic!(
+                "ERROR: Failed to begin new unconfirmed MARF block for {})",
+                current
+            )
+        });
+        tx.begin_unconfirmed(current).unwrap_or_else(|_| {
+            panic!(
+                "ERROR: Failed to begin new unconfirmed MARF block for {})",
+                current
+            )
+        });
 
         let chain_tip = tx
             .get_open_chain_tip()
@@ -362,10 +370,12 @@ impl<'a> ClarityBackingStore for ReadOnlyMarfStore<'a> {
     fn get_block_at_height(&mut self, block_height: u32) -> Option<StacksBlockId> {
         self.marf
             .get_bhh_at_height(&self.chain_tip, block_height)
-            .expect(&format!(
-                "Unexpected MARF failure: failed to get block at height {} off of {}.",
-                block_height, &self.chain_tip
-            ))
+            .unwrap_or_else(|_| {
+                panic!(
+                    "Unexpected MARF failure: failed to get block at height {} off of {}.",
+                    block_height, &self.chain_tip
+                )
+            })
             .map(|x| StacksBlockId(x.to_bytes()))
     }
 
@@ -396,10 +406,12 @@ impl<'a> ClarityBackingStore for ReadOnlyMarfStore<'a> {
             .map(|(marf_value, proof)| {
                 let side_key = marf_value.to_hex();
                 let data =
-                    SqliteConnection::get(self.get_side_store(), &side_key).expect(&format!(
-                        "ERROR: MARF contained value_hash not found in side storage: {}",
-                        side_key
-                    ));
+                    SqliteConnection::get(self.get_side_store(), &side_key).unwrap_or_else(|| {
+                        panic!(
+                            "ERROR: MARF contained value_hash not found in side storage: {}",
+                            side_key
+                        )
+                    });
                 (data, proof.serialize_to_vec())
             })
     }
@@ -423,10 +435,12 @@ impl<'a> ClarityBackingStore for ReadOnlyMarfStore<'a> {
             .map(|marf_value| {
                 let side_key = marf_value.to_hex();
                 trace!("MarfedKV get side-key for {:?}: {:?}", key, &side_key);
-                SqliteConnection::get(self.get_side_store(), &side_key).expect(&format!(
-                    "ERROR: MARF contained value_hash not found in side storage: {}",
-                    side_key
-                ))
+                SqliteConnection::get(self.get_side_store(), &side_key).unwrap_or_else(|| {
+                    panic!(
+                        "ERROR: MARF contained value_hash not found in side storage: {}",
+                        side_key
+                    )
+                })
             })
     }
 
@@ -562,10 +576,12 @@ impl<'a> ClarityBackingStore for WritableMarfStore<'a> {
             .map(|marf_value| {
                 let side_key = marf_value.to_hex();
                 trace!("MarfedKV get side-key for {:?}: {:?}", key, &side_key);
-                SqliteConnection::get(self.marf.sqlite_tx(), &side_key).expect(&format!(
-                    "ERROR: MARF contained value_hash not found in side storage: {}",
-                    side_key
-                ))
+                SqliteConnection::get(self.marf.sqlite_tx(), &side_key).unwrap_or_else(|| {
+                    panic!(
+                        "ERROR: MARF contained value_hash not found in side storage: {}",
+                        side_key
+                    )
+                })
             })
     }
 
@@ -580,10 +596,12 @@ impl<'a> ClarityBackingStore for WritableMarfStore<'a> {
             .map(|(marf_value, proof)| {
                 let side_key = marf_value.to_hex();
                 let data =
-                    SqliteConnection::get(self.marf.sqlite_tx(), &side_key).expect(&format!(
-                        "ERROR: MARF contained value_hash not found in side storage: {}",
-                        side_key
-                    ));
+                    SqliteConnection::get(self.marf.sqlite_tx(), &side_key).unwrap_or_else(|| {
+                        panic!(
+                            "ERROR: MARF contained value_hash not found in side storage: {}",
+                            side_key
+                        )
+                    });
                 (data, proof.serialize_to_vec())
             })
     }
@@ -595,10 +613,12 @@ impl<'a> ClarityBackingStore for WritableMarfStore<'a> {
     fn get_block_at_height(&mut self, height: u32) -> Option<StacksBlockId> {
         self.marf
             .get_block_at_height(height, &self.chain_tip)
-            .expect(&format!(
-                "Unexpected MARF failure: failed to get block at height {} off of {}.",
-                height, &self.chain_tip
-            ))
+            .unwrap_or_else(|_| {
+                panic!(
+                    "Unexpected MARF failure: failed to get block at height {} off of {}.",
+                    height, &self.chain_tip
+                )
+            })
     }
 
     fn get_open_chain_tip(&mut self) -> StacksBlockId {
diff --git a/stackslib/src/clarity_vm/database/mod.rs b/stackslib/src/clarity_vm/database/mod.rs
index 212ef96c77..c28399717b 100644
--- a/stackslib/src/clarity_vm/database/mod.rs
+++ b/stackslib/src/clarity_vm/database/mod.rs
@@ -283,10 +283,12 @@ where
             |x| Ok(loader(x)),
         )
         .optional()
-        .expect(&format!(
-            "Unexpected SQL failure querying block header table for '{}'",
-            column_name
-        ))
+        .unwrap_or_else(|_| {
+            panic!(
+                "Unexpected SQL failure querying block header table for '{}'",
+                column_name
+            )
+        })
     {
         return Some(result);
     }
@@ -300,10 +302,12 @@ where
         |x| Ok(loader(x)),
     )
     .optional()
-    .expect(&format!(
-        "Unexpected SQL failure querying block header table for '{}'",
-        column_name
-    ))
+    .unwrap_or_else(|_| {
+        panic!(
+            "Unexpected SQL failure querying block header table for '{}'",
+            column_name
+        )
+    })
 }
 
 fn get_miner_column<F, R>(
@@ -325,10 +329,12 @@ where
         |x| Ok(loader(x)),
     )
     .optional()
-    .expect(&format!(
-        "Unexpected SQL failure querying miner payment table for '{}'",
-        column_name
-    ))
+    .unwrap_or_else(|_| {
+        panic!(
+            "Unexpected SQL failure querying miner payment table for '{}'",
+            column_name
+        )
+    })
 }
 
 fn get_matured_reward(conn: &DBConn, child_id_bhh: &StacksBlockId) -> Option<MinerReward> {
diff --git a/stackslib/src/main.rs b/stackslib/src/main.rs
index 69fb050fd3..8271115af5 100644
--- a/stackslib/src/main.rs
+++ b/stackslib/src/main.rs
@@ -214,7 +214,8 @@ fn main() {
         }
 
         let block_path = &argv[2];
-        let block_data = fs::read(block_path).expect(&format!("Failed to open {}", block_path));
+        let block_data =
+            fs::read(block_path).unwrap_or_else(|_| panic!("Failed to open {block_path}"));
 
         let block = StacksBlock::consensus_deserialize(&mut io::Cursor::new(&block_data))
             .map_err(|_e| {
@@ -325,7 +326,7 @@ Given a <working-dir>, obtain a 2100 header hash block inventory (with an empty
         let chain_state_path = format!("{}/mainnet/chainstate/", &argv[2]);
 
         let sort_db = SortitionDB::open(&sort_db_path, false, PoxConstants::mainnet_default())
-            .expect(&format!("Failed to open {}", &sort_db_path));
+            .unwrap_or_else(|_| panic!("Failed to open {sort_db_path}"));
         let chain_id = CHAIN_ID_MAINNET;
         let (chain_state, _) = StacksChainState::open(true, chain_id, &chain_state_path, None)
             .expect("Failed to open stacks chain state");
@@ -372,7 +373,7 @@ check if the associated microblocks can be downloaded
         let chain_state_path = format!("{}/mainnet/chainstate/", &argv[2]);
 
         let sort_db = SortitionDB::open(&sort_db_path, false, PoxConstants::mainnet_default())
-            .expect(&format!("Failed to open {}", &sort_db_path));
+            .unwrap_or_else(|_| panic!("Failed to open {sort_db_path}"));
         let chain_id = CHAIN_ID_MAINNET;
         let (chain_state, _) = StacksChainState::open(true, chain_id, &chain_state_path, None)
             .expect("Failed to open stacks chain state");
@@ -483,7 +484,7 @@ check if the associated microblocks can be downloaded
             .unwrap_or(start_height);
 
         let sort_db = SortitionDB::open(&argv[2], false, PoxConstants::mainnet_default())
-            .expect(&format!("Failed to open {}", argv[2]));
+            .unwrap_or_else(|_| panic!("Failed to open {}", argv[2]));
         let chain_tip = SortitionDB::get_canonical_sortition_tip(sort_db.conn())
             .expect("Failed to get sortition chain tip");
         let sort_conn = sort_db.index_handle(&chain_tip);
@@ -554,7 +555,7 @@ simulating a miner.
         }
 
         let sort_db = SortitionDB::open(&sort_db_path, false, PoxConstants::mainnet_default())
-            .expect(&format!("Failed to open {}", &sort_db_path));
+            .unwrap_or_else(|_| panic!("Failed to open {sort_db_path}"));
         let chain_id = CHAIN_ID_MAINNET;
         let (chain_state, _) = StacksChainState::open(true, chain_id, &chain_state_path, None)
             .expect("Failed to open stacks chain state");
@@ -663,7 +664,8 @@ simulating a miner.
         }
 
         let mblock_path = &argv[2];
-        let mblock_data = fs::read(mblock_path).expect(&format!("Failed to open {}", mblock_path));
+        let mblock_data =
+            fs::read(mblock_path).unwrap_or_else(|_| panic!("Failed to open {mblock_path}"));
 
         let mut cursor = io::Cursor::new(&mblock_data);
         let mut debug_cursor = LogReader::from_reader(&mut cursor);
@@ -732,10 +734,8 @@ simulating a miner.
                 },
             );
 
-            let row = res.expect(&format!(
-                "Failed to query DB for MARF value hash {}",
-                &value
-            ));
+            let row =
+                res.unwrap_or_else(|_| panic!("Failed to query DB for MARF value hash {value}"));
             println!("{}", row);
         } else {
             println!("(undefined)");
@@ -749,8 +749,8 @@ simulating a miner.
             eprintln!("Usage: {} exec_program [program-file.clar]", argv[0]);
             process::exit(1);
         }
-        let program: String =
-            fs::read_to_string(&argv[2]).expect(&format!("Error reading file: {}", argv[2]));
+        let program: String = fs::read_to_string(&argv[2])
+            .unwrap_or_else(|_| panic!("Error reading file: {}", argv[2]));
         let clarity_version = ClarityVersion::default_for_epoch(clarity_cli::DEFAULT_CLI_EPOCH);
         match clarity_cli::vm_execute(&program, clarity_version) {
             Ok(Some(result)) => println!("{}", result),
@@ -1248,7 +1248,7 @@ simulating a miner.
     let mine_max_txns: u64 = argv[5].parse().expect("Could not parse mine-num-txns");
 
     let sort_db = SortitionDB::open(&sort_db_path, false, PoxConstants::mainnet_default())
-        .expect(&format!("Failed to open {}", &sort_db_path));
+        .unwrap_or_else(|_| panic!("Failed to open {sort_db_path}"));
     let chain_id = CHAIN_ID_MAINNET;
     let mut chain_state = StacksChainState::open(true, chain_id, &chain_state_path, None)
         .expect("Failed to open stacks chain state")
diff --git a/stackslib/src/net/api/getattachmentsinv.rs b/stackslib/src/net/api/getattachmentsinv.rs
index d41898a731..1a1439f345 100644
--- a/stackslib/src/net/api/getattachmentsinv.rs
+++ b/stackslib/src/net/api/getattachmentsinv.rs
@@ -93,7 +93,7 @@ impl HttpRequest for RPCGetAttachmentsInvRequestHandler {
                 index_block_hash = StacksBlockId::from_hex(&value).ok();
             } else if key == "pages_indexes" {
                 if let Ok(pages_indexes_value) = value.parse::<String>() {
-                    for entry in pages_indexes_value.split(",") {
+                    for entry in pages_indexes_value.split(',') {
                         if let Ok(page_index) = entry.parse::<u32>() {
                             page_indexes.insert(page_index);
                         }
diff --git a/stackslib/src/net/api/getpoxinfo.rs b/stackslib/src/net/api/getpoxinfo.rs
index 32c9ed6dbf..49620a0991 100644
--- a/stackslib/src/net/api/getpoxinfo.rs
+++ b/stackslib/src/net/api/getpoxinfo.rs
@@ -174,7 +174,7 @@ impl RPCPoxInfoData {
                     sender,
                     None,
                     cost_track,
-                    |env| env.execute_contract(&contract_identifier, function, &vec![], true),
+                    |env| env.execute_contract(&contract_identifier, function, &[], true),
                 )
             })
             .map_err(|_| NetError::NotFoundError)?;
@@ -186,37 +186,37 @@ impl RPCPoxInfoData {
 
         let first_burnchain_block_height = res
             .get("first-burnchain-block-height")
-            .expect(&format!("FATAL: no 'first-burnchain-block-height'"))
+            .unwrap_or_else(|_| panic!("FATAL: no 'first-burnchain-block-height'"))
             .to_owned()
             .expect_u128() as u64;
 
         let min_stacking_increment_ustx = res
             .get("min-amount-ustx")
-            .expect(&format!("FATAL: no 'min-amount-ustx'"))
+            .unwrap_or_else(|_| panic!("FATAL: no 'min-amount-ustx'"))
             .to_owned()
             .expect_u128() as u64;
 
         let prepare_cycle_length = res
             .get("prepare-cycle-length")
-            .expect(&format!("FATAL: no 'prepare-cycle-length'"))
+            .unwrap_or_else(|_| panic!("FATAL: no 'prepare-cycle-length'"))
             .to_owned()
             .expect_u128() as u64;
 
         let reward_cycle_id = res
             .get("reward-cycle-id")
-            .expect(&format!("FATAL: no 'reward-cycle-id'"))
+            .unwrap_or_else(|_| panic!("FATAL: no 'reward-cycle-id'"))
             .to_owned()
             .expect_u128() as u64;
 
         let reward_cycle_length = res
             .get("reward-cycle-length")
-            .expect(&format!("FATAL: no 'reward-cycle-length'"))
+            .unwrap_or_else(|_| panic!("FATAL: no 'reward-cycle-length'"))
             .to_owned()
             .expect_u128() as u64;
 
         let total_liquid_supply_ustx = res
             .get("total-liquid-supply-ustx")
-            .expect(&format!("FATAL: no 'total-liquid-supply-ustx'"))
+            .unwrap_or_else(|_| panic!("FATAL: no 'total-liquid-supply-ustx'"))
             .to_owned()
             .expect_u128() as u64;
 
@@ -227,13 +227,13 @@ impl RPCPoxInfoData {
         let (rejection_fraction, rejection_votes_left_required) = if has_rejection_data {
             let rejection_fraction = res
                 .get("rejection-fraction")
-                .expect(&format!("FATAL: no 'rejection-fraction'"))
+                .unwrap_or_else(|_| panic!("FATAL: no 'rejection-fraction'"))
                 .to_owned()
                 .expect_u128() as u64;
 
             let current_rejection_votes = res
                 .get("current-rejection-votes")
-                .expect(&format!("FATAL: no 'current-rejection-votes'"))
+                .unwrap_or_else(|_| panic!("FATAL: no 'current-rejection-votes'"))
                 .to_owned()
                 .expect_u128() as u64;
 
diff --git a/stackslib/src/net/chat.rs b/stackslib/src/net/chat.rs
index 79a659e937..68f1f2f896 100644
--- a/stackslib/src/net/chat.rs
+++ b/stackslib/src/net/chat.rs
@@ -715,10 +715,8 @@ impl ConversationP2P {
 
     /// Get the current epoch
     fn get_current_epoch(&self, cur_burn_height: u64) -> StacksEpoch {
-        let epoch_index = StacksEpoch::find_epoch(&self.epochs, cur_burn_height).expect(&format!(
-            "BUG: block {} is not in a known epoch",
-            cur_burn_height
-        ));
+        let epoch_index = StacksEpoch::find_epoch(&self.epochs, cur_burn_height)
+            .unwrap_or_else(|| panic!("BUG: block {} is not in a known epoch", cur_burn_height));
         let epoch = self.epochs[epoch_index].clone();
         epoch
     }
diff --git a/stackslib/src/net/db.rs b/stackslib/src/net/db.rs
index 25c4ed7e62..443e1358c8 100644
--- a/stackslib/src/net/db.rs
+++ b/stackslib/src/net/db.rs
@@ -804,7 +804,7 @@ impl PeerDB {
     ) -> Result<(), db_error> {
         tx.execute(
             "UPDATE local_peer SET addrbytes = ?1, port = ?2",
-            &[&to_bin(&addrbytes.as_bytes().to_vec()), &port as &dyn ToSql],
+            &[&to_bin(addrbytes.as_bytes().as_ref()), &port as &dyn ToSql],
         )
         .map_err(db_error::SqliteError)?;
 
diff --git a/stackslib/src/net/p2p.rs b/stackslib/src/net/p2p.rs
index 36f680c269..fa335ac25f 100644
--- a/stackslib/src/net/p2p.rs
+++ b/stackslib/src/net/p2p.rs
@@ -528,10 +528,12 @@ impl PeerNetwork {
     /// Get the current epoch
     pub fn get_current_epoch(&self) -> StacksEpoch {
         let epoch_index = StacksEpoch::find_epoch(&self.epochs, self.chain_view.burn_block_height)
-            .expect(&format!(
-                "BUG: block {} is not in a known epoch",
-                &self.chain_view.burn_block_height
-            ));
+            .unwrap_or_else(|| {
+                panic!(
+                    "BUG: block {} is not in a known epoch",
+                    &self.chain_view.burn_block_height
+                )
+            });
         let epoch = self.epochs[epoch_index].clone();
         epoch
     }
diff --git a/stackslib/src/net/poll.rs b/stackslib/src/net/poll.rs
index 5941741bc1..c508d01934 100644
--- a/stackslib/src/net/poll.rs
+++ b/stackslib/src/net/poll.rs
@@ -394,10 +394,13 @@ impl NetworkState {
                 // server token?
                 if token == server.server_event {
                     // new inbound connection(s)
-                    let poll_state = poll_states.get_mut(&usize::from(token)).expect(&format!(
-                        "BUG: FATAL: no poll state registered for server {}",
-                        usize::from(token)
-                    ));
+                    let poll_state =
+                        poll_states.get_mut(&usize::from(token)).unwrap_or_else(|| {
+                            panic!(
+                                "BUG: FATAL: no poll state registered for server {}",
+                                usize::from(token)
+                            )
+                        });
 
                     loop {
                         let (client_sock, client_addr) = match server.server_socket.accept() {
diff --git a/stackslib/src/net/prune.rs b/stackslib/src/net/prune.rs
index b2b7ff6c32..512c922c3c 100644
--- a/stackslib/src/net/prune.rs
+++ b/stackslib/src/net/prune.rs
@@ -71,10 +71,12 @@ impl PeerNetwork {
                         Some(peer) => {
                             let stats = convo.stats.clone();
                             let org = peer.org;
-                            if org_neighbor.contains_key(&org) {
-                                org_neighbor.get_mut(&org).unwrap().push((nk, stats));
+                            if let std::collections::hash_map::Entry::Vacant(e) =
+                                org_neighbor.entry(org)
+                            {
+                                e.insert(vec![(nk, stats)]);
                             } else {
-                                org_neighbor.insert(org, vec![(nk, stats)]);
+                                org_neighbor.get_mut(&org).unwrap().push((nk, stats));
                             }
                         }
                     };
@@ -326,8 +328,10 @@ impl PeerNetwork {
                 Some(ref convo) => {
                     if !convo.stats.outbound {
                         let stats = convo.stats.clone();
-                        if !ip_neighbor.contains_key(&nk.addrbytes) {
-                            ip_neighbor.insert(nk.addrbytes, vec![(*event_id, nk.clone(), stats)]);
+                        if let std::collections::hash_map::Entry::Vacant(e) =
+                            ip_neighbor.entry(nk.addrbytes)
+                        {
+                            e.insert(vec![(*event_id, nk.clone(), stats)]);
                         } else {
                             ip_neighbor.get_mut(&nk.addrbytes).unwrap().push((
                                 *event_id,
diff --git a/stackslib/src/net/stackerdb/db.rs b/stackslib/src/net/stackerdb/db.rs
index 3adc8845a7..4d195d12a2 100644
--- a/stackslib/src/net/stackerdb/db.rs
+++ b/stackslib/src/net/stackerdb/db.rs
@@ -446,7 +446,7 @@ impl StackerDBs {
                 let ppath = Path::new(path);
                 let pparent_path = ppath
                     .parent()
-                    .expect(&format!("BUG: no parent of '{}'", path));
+                    .unwrap_or_else(|| panic!("BUG: no parent of '{}'", path));
                 fs::create_dir_all(&pparent_path).map_err(|e| db_error::IOError(e))?;
 
                 OpenFlags::SQLITE_OPEN_READ_WRITE | OpenFlags::SQLITE_OPEN_CREATE
diff --git a/stackslib/src/util_lib/db.rs b/stackslib/src/util_lib/db.rs
index e10ca1b886..6a4af83130 100644
--- a/stackslib/src/util_lib/db.rs
+++ b/stackslib/src/util_lib/db.rs
@@ -783,7 +783,7 @@ fn get_indexed<T: MarfTrieId, M: MarfConnection<T>>(
     match index.get(header_hash, key) {
         Ok(Some(marf_value)) => {
             let value = load_indexed(index.sqlite_conn(), &marf_value)?
-                .expect(&format!("FATAL: corrupt index: key '{}' from {} is present in the index but missing a value in the DB", &key, &header_hash));
+                .unwrap_or_else(|| panic!("FATAL: corrupt index: key '{}' from {} is present in the index but missing a value in the DB", &key, &header_hash));
             Ok(Some(value))
         }
         Ok(None) => Ok(None),

From 8af4e1ac25007dd0ea17c983d02cc25d4035b388 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Thu, 1 Feb 2024 16:46:31 -0500
Subject: [PATCH 0554/1166] chore: Fix `clippy::perf` warnings in
 `./testnet/stacks-node` (except `large_enum_variant` and `result_large_err`)

---
 .../burnchains/bitcoin_regtest_controller.rs  |  4 +-
 testnet/stacks-node/src/config.rs             | 22 +++++----
 testnet/stacks-node/src/event_dispatcher.rs   |  8 ++--
 testnet/stacks-node/src/keychain.rs           |  4 +-
 .../stacks-node/src/nakamoto_node/miner.rs    | 17 +++----
 testnet/stacks-node/src/nakamoto_node/peer.rs | 18 +++----
 testnet/stacks-node/src/neon_node.rs          | 46 ++++++++++--------
 testnet/stacks-node/src/node.rs               | 47 ++++++++++---------
 testnet/stacks-node/src/run_loop/mod.rs       |  4 +-
 testnet/stacks-node/src/syncctl.rs            |  4 +-
 10 files changed, 93 insertions(+), 81 deletions(-)

diff --git a/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs b/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
index 24b99f2795..5cf6cab091 100644
--- a/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
+++ b/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
@@ -2122,7 +2122,7 @@ impl ParsedUTXO {
     }
 
     pub fn serialized_btc_to_sat(amount: &str) -> Option<u64> {
-        let comps: Vec<&str> = amount.split(".").collect();
+        let comps: Vec<&str> = amount.split('.').collect();
         match comps[..] {
             [lhs, rhs] => {
                 if rhs.len() > 8 {
@@ -2198,7 +2198,7 @@ impl BitcoinRPCRequest {
                 _ => None,
             };
             let url = config.burnchain.get_rpc_url(wallet_id);
-            Url::parse(&url).expect(&format!("Unable to parse {} as a URL", url))
+            Url::parse(&url).unwrap_or_else(|_| panic!("Unable to parse {} as a URL", url))
         };
         debug!(
             "BitcoinRPC builder '{}': {:?}:{:?}@{}",
diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index 97693f6f78..2485a614b6 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -868,7 +868,7 @@ impl Config {
             None => default_burnchain_config,
         };
 
-        let supported_modes = vec![
+        let supported_modes = [
             "mocknet",
             "helium",
             "neon",
@@ -1057,10 +1057,12 @@ impl Config {
     pub fn get_estimates_path(&self) -> PathBuf {
         let mut path = self.get_chainstate_path();
         path.push("estimates");
-        fs::create_dir_all(&path).expect(&format!(
-            "Failed to create `estimates` directory at {}",
-            path.to_string_lossy()
-        ));
+        fs::create_dir_all(&path).unwrap_or_else(|_| {
+            panic!(
+                "Failed to create `estimates` directory at {}",
+                path.to_string_lossy()
+            )
+        });
         path
     }
 
@@ -1846,7 +1848,7 @@ impl NodeConfig {
     }
 
     pub fn add_bootstrap_node(&mut self, bootstrap_node: &str, chain_id: u32, peer_version: u32) {
-        let parts: Vec<&str> = bootstrap_node.split("@").collect();
+        let parts: Vec<&str> = bootstrap_node.split('@').collect();
         if parts.len() != 2 {
             panic!(
                 "Invalid bootstrap node '{}': expected PUBKEY@IP:PORT",
@@ -1855,7 +1857,7 @@ impl NodeConfig {
         }
         let (pubkey_str, hostport) = (parts[0], parts[1]);
         let pubkey = Secp256k1PublicKey::from_hex(pubkey_str)
-            .expect(&format!("Invalid public key '{}'", pubkey_str));
+            .unwrap_or_else(|_| panic!("Invalid public key '{}'", pubkey_str));
         info!("Resolve '{}'", &hostport);
         let sockaddr = hostport.to_socket_addrs().unwrap().next().unwrap();
         let neighbor = NodeConfig::default_neighbor(sockaddr, pubkey, chain_id, peer_version);
@@ -1868,7 +1870,7 @@ impl NodeConfig {
         chain_id: u32,
         peer_version: u32,
     ) {
-        let parts: Vec<&str> = bootstrap_nodes.split(",").collect();
+        let parts: Vec<&str> = bootstrap_nodes.split(',').collect();
         for part in parts.into_iter() {
             if part.len() > 0 {
                 self.add_bootstrap_node(&part, chain_id, peer_version);
@@ -1888,7 +1890,7 @@ impl NodeConfig {
     }
 
     pub fn set_deny_nodes(&mut self, deny_nodes: String, chain_id: u32, peer_version: u32) {
-        let parts: Vec<&str> = deny_nodes.split(",").collect();
+        let parts: Vec<&str> = deny_nodes.split(',').collect();
         for part in parts.into_iter() {
             if part.len() > 0 {
                 self.add_deny_node(&part, chain_id, peer_version);
@@ -2415,7 +2417,7 @@ impl EventKeyType {
 
         let comps: Vec<_> = raw_key.split("::").collect();
         if comps.len() == 1 {
-            let split: Vec<_> = comps[0].split(".").collect();
+            let split: Vec<_> = comps[0].split('.').collect();
             if split.len() != 3 {
                 return None;
             }
diff --git a/testnet/stacks-node/src/event_dispatcher.rs b/testnet/stacks-node/src/event_dispatcher.rs
index faa333e093..e8375de0be 100644
--- a/testnet/stacks-node/src/event_dispatcher.rs
+++ b/testnet/stacks-node/src/event_dispatcher.rs
@@ -116,15 +116,13 @@ impl EventObserver {
         };
 
         let url = {
-            let joined_components = match path.starts_with("/") {
+            let joined_components = match path.starts_with('/') {
                 true => format!("{}{}", &self.endpoint, path),
                 false => format!("{}/{}", &self.endpoint, path),
             };
             let url = format!("http://{}", joined_components);
-            Url::parse(&url).expect(&format!(
-                "Event dispatcher: unable to parse {} as a URL",
-                url
-            ))
+            Url::parse(&url)
+                .unwrap_or_else(|_| panic!("Event dispatcher: unable to parse {} as a URL", url))
         };
 
         let backoff = Duration::from_millis((1.0 * 1_000.0) as u64);
diff --git a/testnet/stacks-node/src/keychain.rs b/testnet/stacks-node/src/keychain.rs
index d2575cb2b9..05d8df49a3 100644
--- a/testnet/stacks-node/src/keychain.rs
+++ b/testnet/stacks-node/src/keychain.rs
@@ -120,10 +120,10 @@ impl Keychain {
     /// `block_height` must be the _same_ block height called to make_vrf_keypair()
     pub fn generate_proof(&self, block_height: u64, bytes: &[u8; 32]) -> VRFProof {
         let (pk, sk) = self.make_vrf_keypair(block_height);
-        let proof = VRF::prove(&sk, &bytes.to_vec());
+        let proof = VRF::prove(&sk, bytes.as_ref());
 
         // Ensure that the proof is valid by verifying
-        let is_valid = match VRF::verify(&pk, &proof, &bytes.to_vec()) {
+        let is_valid = match VRF::verify(&pk, &proof, bytes.as_ref()) {
             Ok(v) => v,
             Err(_) => false,
         };
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index fef3379fbd..28d85948dc 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -188,10 +188,9 @@ impl BlockMinerThread {
                 ) {
                     Ok(Some(chunk)) => {
                         // Propose the block to the observing signers through the .miners stackerdb instance
-                        let rpc_sock = self.config.node.rpc_bind.parse().expect(&format!(
-                            "Failed to parse socket: {}",
-                            &self.config.node.rpc_bind
-                        ));
+                        let rpc_sock = self.config.node.rpc_bind.parse().unwrap_or_else(|_| {
+                            panic!("Failed to parse socket: {}", &self.config.node.rpc_bind)
+                        });
 
                         let miner_contract_id = boot_code_id(MINERS_NAME, self.config.is_mainnet());
                         let mut miners_stackerdb =
@@ -716,10 +715,12 @@ impl ParentStacksBlockInfo {
                     &stacks_tip_header.index_block_hash(),
                     |conn| StacksChainState::get_account(conn, &principal),
                 )
-                .expect(&format!(
-                    "BUG: stacks tip block {} no longer exists after we queried it",
-                    &stacks_tip_header.index_block_hash(),
-                ));
+                .unwrap_or_else(|| {
+                    panic!(
+                        "BUG: stacks tip block {} no longer exists after we queried it",
+                        &stacks_tip_header.index_block_hash()
+                    )
+                });
             account.nonce
         };
 
diff --git a/testnet/stacks-node/src/nakamoto_node/peer.rs b/testnet/stacks-node/src/nakamoto_node/peer.rs
index 376c437723..e6e02bd19e 100644
--- a/testnet/stacks-node/src/nakamoto_node/peer.rs
+++ b/testnet/stacks-node/src/nakamoto_node/peer.rs
@@ -172,14 +172,16 @@ impl PeerThread {
         let chainstate =
             open_chainstate_with_faults(&config).expect("FATAL: could not open chainstate DB");
 
-        let p2p_sock: SocketAddr = config.node.p2p_bind.parse().expect(&format!(
-            "Failed to parse socket: {}",
-            &config.node.p2p_bind
-        ));
-        let rpc_sock = config.node.rpc_bind.parse().expect(&format!(
-            "Failed to parse socket: {}",
-            &config.node.rpc_bind
-        ));
+        let p2p_sock: SocketAddr = config
+            .node
+            .p2p_bind
+            .parse()
+            .unwrap_or_else(|_| panic!("Failed to parse socket: {}", &config.node.p2p_bind));
+        let rpc_sock = config
+            .node
+            .rpc_bind
+            .parse()
+            .unwrap_or_else(|_| panic!("Failed to parse socket: {}", &config.node.rpc_bind));
 
         net.bind(&p2p_sock, &rpc_sock)
             .expect("BUG: PeerNetwork could not bind or is already bound");
diff --git a/testnet/stacks-node/src/neon_node.rs b/testnet/stacks-node/src/neon_node.rs
index f3c9307eec..25dee5bb4c 100644
--- a/testnet/stacks-node/src/neon_node.rs
+++ b/testnet/stacks-node/src/neon_node.rs
@@ -3280,10 +3280,12 @@ impl ParentStacksBlockInfo {
                     &StacksBlockHeader::make_index_block_hash(mine_tip_ch, mine_tip_bh),
                     |conn| StacksChainState::get_account(conn, &principal),
                 )
-                .expect(&format!(
-                    "BUG: stacks tip block {}/{} no longer exists after we queried it",
-                    mine_tip_ch, mine_tip_bh
-                ));
+                .unwrap_or_else(|| {
+                    panic!(
+                        "BUG: stacks tip block {}/{} no longer exists after we queried it",
+                        mine_tip_ch, mine_tip_bh
+                    )
+                });
             account.nonce
         };
 
@@ -3384,14 +3386,16 @@ impl PeerThread {
         let chainstate =
             open_chainstate_with_faults(&config).expect("FATAL: could not open chainstate DB");
 
-        let p2p_sock: SocketAddr = config.node.p2p_bind.parse().expect(&format!(
-            "Failed to parse socket: {}",
-            &config.node.p2p_bind
-        ));
-        let rpc_sock = config.node.rpc_bind.parse().expect(&format!(
-            "Failed to parse socket: {}",
-            &config.node.rpc_bind
-        ));
+        let p2p_sock: SocketAddr = config
+            .node
+            .p2p_bind
+            .parse()
+            .unwrap_or_else(|_| panic!("Failed to parse socket: {}", &config.node.p2p_bind));
+        let rpc_sock = config
+            .node
+            .rpc_bind
+            .parse()
+            .unwrap_or_else(|_| panic!("Failed to parse socket: {}", &config.node.rpc_bind));
 
         net.bind(&p2p_sock, &rpc_sock)
             .expect("BUG: PeerNetwork could not bind or is already bound");
@@ -3689,14 +3693,16 @@ impl StacksNode {
             warn!("Without a peer to bootstrap from, the node will start mining a new chain");
         }
 
-        let p2p_sock: SocketAddr = config.node.p2p_bind.parse().expect(&format!(
-            "Failed to parse socket: {}",
-            &config.node.p2p_bind
-        ));
-        let p2p_addr: SocketAddr = config.node.p2p_address.parse().expect(&format!(
-            "Failed to parse socket: {}",
-            &config.node.p2p_address
-        ));
+        let p2p_sock: SocketAddr = config
+            .node
+            .p2p_bind
+            .parse()
+            .unwrap_or_else(|_| panic!("Failed to parse socket: {}", &config.node.p2p_bind));
+        let p2p_addr: SocketAddr = config
+            .node
+            .p2p_address
+            .parse()
+            .unwrap_or_else(|_| panic!("Failed to parse socket: {}", &config.node.p2p_address));
         let node_privkey = Secp256k1PrivateKey::from_seed(&config.node.local_peer_seed);
 
         let mut peerdb = PeerDB::connect(
diff --git a/testnet/stacks-node/src/node.rs b/testnet/stacks-node/src/node.rs
index 5b32de84e0..31d2ce0c55 100644
--- a/testnet/stacks-node/src/node.rs
+++ b/testnet/stacks-node/src/node.rs
@@ -413,18 +413,17 @@ impl Node {
 
         println!("BOOTSTRAP WITH {:?}", initial_neighbors);
 
-        let rpc_sock: SocketAddr = self.config.node.rpc_bind.parse().expect(&format!(
-            "Failed to parse socket: {}",
-            &self.config.node.rpc_bind
-        ));
-        let p2p_sock: SocketAddr = self.config.node.p2p_bind.parse().expect(&format!(
-            "Failed to parse socket: {}",
-            &self.config.node.p2p_bind
-        ));
-        let p2p_addr: SocketAddr = self.config.node.p2p_address.parse().expect(&format!(
-            "Failed to parse socket: {}",
-            &self.config.node.p2p_address
-        ));
+        let rpc_sock: SocketAddr =
+            self.config.node.rpc_bind.parse().unwrap_or_else(|_| {
+                panic!("Failed to parse socket: {}", &self.config.node.rpc_bind)
+            });
+        let p2p_sock: SocketAddr =
+            self.config.node.p2p_bind.parse().unwrap_or_else(|_| {
+                panic!("Failed to parse socket: {}", &self.config.node.p2p_bind)
+            });
+        let p2p_addr: SocketAddr = self.config.node.p2p_address.parse().unwrap_or_else(|_| {
+            panic!("Failed to parse socket: {}", &self.config.node.p2p_address)
+        });
         let node_privkey = {
             let mut re_hashed_seed = self.config.node.local_peer_seed.clone();
             let my_private_key = loop {
@@ -774,16 +773,20 @@ impl Node {
                 &anchored_block.header.parent_block,
                 consensus_hash,
             )
-            .expect(&format!(
-                "BUG: could not query chainstate to find parent consensus hash of {}/{}",
-                consensus_hash,
-                &anchored_block.block_hash()
-            ))
-            .expect(&format!(
-                "BUG: no such parent of block {}/{}",
-                consensus_hash,
-                &anchored_block.block_hash()
-            ));
+            .unwrap_or_else(|_| {
+                panic!(
+                    "BUG: could not query chainstate to find parent consensus hash of {}/{}",
+                    consensus_hash,
+                    &anchored_block.block_hash()
+                )
+            })
+            .unwrap_or_else(|| {
+                panic!(
+                    "BUG: no such parent of block {}/{}",
+                    consensus_hash,
+                    &anchored_block.block_hash()
+                )
+            });
 
             // Preprocess the anchored block
             self.chain_state
diff --git a/testnet/stacks-node/src/run_loop/mod.rs b/testnet/stacks-node/src/run_loop/mod.rs
index 9ad4fd583e..c38fa18eb9 100644
--- a/testnet/stacks-node/src/run_loop/mod.rs
+++ b/testnet/stacks-node/src/run_loop/mod.rs
@@ -125,7 +125,7 @@ impl RunLoopCallbacks {
             match &tx.payload {
                 TransactionPayload::Coinbase(..) => println!("   Coinbase"),
                 TransactionPayload::SmartContract(contract, ..) => println!("   Publish smart contract\n**************************\n{:?}\n**************************", contract.code_body),
-                TransactionPayload::TokenTransfer(recipent, amount, _) => println!("   Transfering {} µSTX to {}", amount, recipent.to_string()),
+                TransactionPayload::TokenTransfer(recipent, amount, _) => println!("   Transfering {} µSTX to {}", amount, recipent),
                 _ => println!("   {:?}", tx.payload)
             }
         }
@@ -184,7 +184,7 @@ pub fn announce_boot_receipts(
         boot_receipts,
         &StacksBlockId::sentinel(),
         Txid([0x00; 32]),
-        &vec![],
+        &[],
         None,
         block_header_0.burn_header_hash.clone(),
         block_header_0.burn_header_height,
diff --git a/testnet/stacks-node/src/syncctl.rs b/testnet/stacks-node/src/syncctl.rs
index 85a3404c42..ff68126a83 100644
--- a/testnet/stacks-node/src/syncctl.rs
+++ b/testnet/stacks-node/src/syncctl.rs
@@ -344,7 +344,7 @@ impl PoxSyncWatchdog {
     ) -> f64 {
         let this_reward_cycle = burnchain
             .block_height_to_reward_cycle(tip_height)
-            .expect(&format!("BUG: no reward cycle for {}", tip_height));
+            .unwrap_or_else(|| panic!("BUG: no reward cycle for {}", tip_height));
         let prev_reward_cycle = this_reward_cycle.saturating_sub(1);
 
         let start_height = burnchain.reward_cycle_to_block_height(prev_reward_cycle);
@@ -372,7 +372,7 @@ impl PoxSyncWatchdog {
     ) -> f64 {
         let this_reward_cycle = burnchain
             .block_height_to_reward_cycle(tip_height)
-            .expect(&format!("BUG: no reward cycle for {}", tip_height));
+            .unwrap_or_else(|| panic!("BUG: no reward cycle for {}", tip_height));
         let prev_reward_cycle = this_reward_cycle.saturating_sub(1);
 
         let start_height = burnchain.reward_cycle_to_block_height(prev_reward_cycle);

From 07d19097b96baf7c5116542268126d965d70f4f7 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Thu, 1 Feb 2024 16:54:29 -0500
Subject: [PATCH 0555/1166] chore: Fix `clippy::perf` warnings in
 `./stx-genesis`

---
 stx-genesis/src/lib.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stx-genesis/src/lib.rs b/stx-genesis/src/lib.rs
index 9d25704b7b..883eb8302b 100644
--- a/stx-genesis/src/lib.rs
+++ b/stx-genesis/src/lib.rs
@@ -129,7 +129,7 @@ fn iter_deflated_csv(deflate_bytes: &'static [u8]) -> Box<dyn Iterator<Item = Ve
     let line_iter = buff_reader
         .lines()
         .map(|line| line.unwrap())
-        .map(|line| line.split(",").map(String::from).collect());
+        .map(|line| line.split(',').map(String::from).collect());
     return Box::new(line_iter);
 }
 

From 8143326346bd7fcddf10952a21902e2011417d13 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Thu, 1 Feb 2024 17:46:23 -0500
Subject: [PATCH 0556/1166] merge develop to next

---
 clarity/src/vm/database/clarity_db.rs         |   8 +-
 clarity/src/vm/database/structures.rs         |  44 ++--
 clarity/src/vm/functions/assets.rs            |   8 +-
 pox-locking/src/events.rs                     |   5 +-
 pox-locking/src/lib.rs                        |   4 +-
 pox-locking/src/pox_4.rs                      |  30 +--
 stacks-signer/src/client/mod.rs               |  10 +
 stacks-signer/src/client/stacks_client.rs     |   4 +-
 stackslib/src/chainstate/coordinator/tests.rs |  57 ++---
 stackslib/src/chainstate/nakamoto/miner.rs    |   8 +-
 stackslib/src/chainstate/nakamoto/mod.rs      |  43 ++--
 stackslib/src/chainstate/stacks/boot/mod.rs   |  36 +--
 .../stacks/boot/signers_voting_tests.rs       |   3 +-
 stackslib/src/chainstate/stacks/db/blocks.rs  |  23 +-
 .../src/chainstate/stacks/db/transactions.rs  |  13 +-
 stackslib/src/chainstate/stacks/miner.rs      |  10 +-
 stackslib/src/clarity_vm/clarity.rs           |  73 +++---
 stackslib/src/net/api/getaccount.rs           |  18 +-
 stackslib/src/net/api/getpoxinfo.rs           |   4 +-
 stackslib/src/net/api/postblock_proposal.rs   |   2 +-
 stackslib/src/net/stackerdb/config.rs         |   2 +-
 stackslib/src/net/stackerdb/sync.rs           |   1 -
 testnet/stacks-node/Cargo.toml                |   1 -
 testnet/stacks-node/src/config.rs             |  54 ++---
 testnet/stacks-node/src/globals.rs            | 210 +++++++++++++++---
 testnet/stacks-node/src/main.rs               |  11 +-
 testnet/stacks-node/src/mockamoto.rs          |  11 +-
 testnet/stacks-node/src/mockamoto/signer.rs   |   2 +-
 testnet/stacks-node/src/neon_node.rs          |  30 +--
 testnet/stacks-node/src/run_loop/nakamoto.rs  |   1 +
 .../src/tests/nakamoto_integrations.rs        |   1 -
 31 files changed, 447 insertions(+), 280 deletions(-)

diff --git a/clarity/src/vm/database/clarity_db.rs b/clarity/src/vm/database/clarity_db.rs
index e9bb7b39f4..de4d5e0c47 100644
--- a/clarity/src/vm/database/clarity_db.rs
+++ b/clarity/src/vm/database/clarity_db.rs
@@ -899,11 +899,11 @@ impl<'a> ClarityDatabase<'a> {
 
     /// Return the height for PoX v3 -> v4 auto unlocks
     ///   from the burn state db
-    pub fn get_v3_unlock_height(&mut self) -> u32 {
-        if self.get_clarity_epoch_version() >= StacksEpochId::Epoch24 {
-            self.burn_state_db.get_v3_unlock_height()
+    pub fn get_v3_unlock_height(&mut self) -> Result<u32> {
+        if self.get_clarity_epoch_version()? >= StacksEpochId::Epoch24 {
+            Ok(self.burn_state_db.get_v3_unlock_height())
         } else {
-            u32::MAX
+            Ok(u32::MAX)
         }
     }
 
diff --git a/clarity/src/vm/database/structures.rs b/clarity/src/vm/database/structures.rs
index 50c788386d..53c7fbd681 100644
--- a/clarity/src/vm/database/structures.rs
+++ b/clarity/src/vm/database/structures.rs
@@ -416,14 +416,15 @@ impl<'db, 'conn> STXBalanceSnapshot<'db, 'conn> {
         let v1_unlock_height = self.db_ref.get_v1_unlock_height();
         let v2_unlock_height = self.db_ref.get_v2_unlock_height()?;
         let v3_unlock_height = self.db_ref.get_v3_unlock_height()?;
-        self.balance
+        Ok(self
+            .balance
             .canonical_repr_at_block(
                 self.burn_block_height,
                 v1_unlock_height,
                 v2_unlock_height,
                 v3_unlock_height,
             )?
-            .0
+            .0)
     }
 
     pub fn has_locked_tokens(&mut self) -> Result<bool> {
@@ -804,8 +805,8 @@ impl<'db, 'conn> STXBalanceSnapshot<'db, 'conn> {
     /// Lock `amount_to_lock` tokens on this account until `unlock_burn_height`.
     /// After calling, this method will set the balance to a "LockedPoxFour" balance,
     ///  because this method is only invoked as a result of PoX4 interactions
-    pub fn lock_tokens_v4(&mut self, amount_to_lock: u128, unlock_burn_height: u64) {
-        let unlocked = self.unlock_available_tokens_if_any();
+    pub fn lock_tokens_v4(&mut self, amount_to_lock: u128, unlock_burn_height: u64) -> Result<()> {
+        let unlocked = self.unlock_available_tokens_if_any()?;
         if unlocked > 0 {
             debug!("Consolidated after account-token-lock");
         }
@@ -818,7 +819,7 @@ impl<'db, 'conn> STXBalanceSnapshot<'db, 'conn> {
             panic!("FATAL: cannot set a lock with expired unlock burn height");
         }
 
-        if self.has_locked_tokens() {
+        if self.has_locked_tokens()? {
             // caller needs to have checked this
             panic!("FATAL: account already has locked tokens");
         }
@@ -828,7 +829,7 @@ impl<'db, 'conn> STXBalanceSnapshot<'db, 'conn> {
 
         let new_amount_unlocked = self
             .balance
-            .get_total_balance()
+            .get_total_balance()?
             .checked_sub(amount_to_lock)
             .expect("FATAL: account locks more STX than balance possessed");
 
@@ -837,18 +838,19 @@ impl<'db, 'conn> STXBalanceSnapshot<'db, 'conn> {
             amount_locked: amount_to_lock,
             unlock_height: unlock_burn_height,
         };
+        Ok(())
     }
 
     /// Extend this account's current lock to `unlock_burn_height`.
     /// After calling, this method will set the balance to a "LockedPoxFour" balance,
     ///  because this method is only invoked as a result of PoX3 interactions
-    pub fn extend_lock_v4(&mut self, unlock_burn_height: u64) {
-        let unlocked = self.unlock_available_tokens_if_any();
+    pub fn extend_lock_v4(&mut self, unlock_burn_height: u64) -> Result<()> {
+        let unlocked = self.unlock_available_tokens_if_any()?;
         if unlocked > 0 {
             debug!("Consolidated after extend-token-lock");
         }
 
-        if !self.has_locked_tokens() {
+        if !self.has_locked_tokens()? {
             // caller needs to have checked this
             panic!("FATAL: account does not have locked tokens");
         }
@@ -863,22 +865,23 @@ impl<'db, 'conn> STXBalanceSnapshot<'db, 'conn> {
             amount_locked: self.balance.amount_locked(),
             unlock_height: unlock_burn_height,
         };
+        Ok(())
     }
 
     /// Increase the account's current lock to `new_total_locked`.
     /// Panics if `self` was not locked by V3 PoX.
-    pub fn increase_lock_v4(&mut self, new_total_locked: u128) {
-        let unlocked = self.unlock_available_tokens_if_any();
+    pub fn increase_lock_v4(&mut self, new_total_locked: u128) -> Result<()> {
+        let unlocked = self.unlock_available_tokens_if_any()?;
         if unlocked > 0 {
             debug!("Consolidated after extend-token-lock");
         }
 
-        if !self.has_locked_tokens() {
+        if !self.has_locked_tokens()? {
             // caller needs to have checked this
             panic!("FATAL: account does not have locked tokens");
         }
 
-        if !self.is_v4_locked() {
+        if !self.is_v4_locked()? {
             // caller needs to have checked this
             panic!("FATAL: account must be locked by pox-3");
         }
@@ -902,15 +905,16 @@ impl<'db, 'conn> STXBalanceSnapshot<'db, 'conn> {
             amount_locked: new_total_locked,
             unlock_height: self.balance.unlock_height(),
         };
+        Ok(())
     }
 
     /// Return true iff `self` represents a snapshot that has a lock
     ///  created by PoX v3.
-    pub fn is_v4_locked(&mut self) -> bool {
-        matches!(
-            self.canonical_balance_repr(),
-            STXBalance::LockedPoxFour { .. }
-        )
+    pub fn is_v4_locked(&mut self) -> Result<bool> {
+        match self.canonical_balance_repr()? {
+            STXBalance::LockedPoxFour { .. } => Ok(true),
+            _ => Ok(false),
+        }
     }
 
     /////////////// GENERAL //////////////////////
@@ -1168,7 +1172,7 @@ impl STXBalance {
             v1_unlock_height,
             v2_unlock_height,
             v3_unlock_height,
-        )? {
+        ) {
             self.get_total_balance()
         } else {
             let out = match self {
@@ -1202,7 +1206,7 @@ impl STXBalance {
             v1_unlock_height,
             v2_unlock_height,
             v3_unlock_height,
-        )? {
+        ) {
             (0, 0)
         } else {
             match self {
diff --git a/clarity/src/vm/functions/assets.rs b/clarity/src/vm/functions/assets.rs
index 3918aa7fcf..3e926f2cc7 100644
--- a/clarity/src/vm/functions/assets.rs
+++ b/clarity/src/vm/functions/assets.rs
@@ -254,9 +254,11 @@ pub fn special_stx_account(
             "unlock-height"
                 .try_into()
                 .map_err(|_| InterpreterError::Expect("Bad special tuple name".into()))?,
-            Value::UInt(u128::from(
-                stx_balance.effective_unlock_height(v1_unlock_ht, v2_unlock_ht, v3_unlock_ht),
-            )),
+            Value::UInt(u128::from(stx_balance.effective_unlock_height(
+                v1_unlock_ht,
+                v2_unlock_ht,
+                v3_unlock_ht,
+            ))),
         ),
     ])
     .map(Value::Tuple)
diff --git a/pox-locking/src/events.rs b/pox-locking/src/events.rs
index 5e183b0ad4..e7011ed396 100644
--- a/pox-locking/src/events.rs
+++ b/pox-locking/src/events.rs
@@ -354,6 +354,7 @@ fn create_event_info_data_code(
                         .map(|boxed_value| *boxed_value)
                         .unwrap()
                         .expect_tuple()
+                        .expect("FATAL: unexpected clarity value")
                         .get("delegated-to")
                         .unwrap()
                 )
@@ -410,9 +411,7 @@ pub fn synthesize_pox_event_info(
     test_debug!("Evaluate snippet:\n{}", &code_snippet);
     test_debug!("Evaluate data code:\n{}", &data_snippet);
 
-    let pox_contract = global_context
-        .database
-        .get_contract(contract_id)?;
+    let pox_contract = global_context.database.get_contract(contract_id)?;
 
     let event_info = global_context
         .special_cc_handler_execute_read_only(
diff --git a/pox-locking/src/lib.rs b/pox-locking/src/lib.rs
index 1d81a5575a..90f625f3ab 100644
--- a/pox-locking/src/lib.rs
+++ b/pox-locking/src/lib.rs
@@ -119,8 +119,8 @@ pub fn handle_contract_call_special_cases(
         if !pox_3::is_read_only(function_name) && global_context.epoch_id >= StacksEpochId::Epoch25
         {
             warn!("PoX-3 function call attempted on an account after Epoch 2.5";
-                  "v3_unlock_ht" => global_context.database.get_v3_unlock_height(),
-                  "current_burn_ht" => global_context.database.get_current_burnchain_block_height(),
+                  "v3_unlock_ht" => global_context.database.get_v3_unlock_height()?,
+                  "current_burn_ht" => global_context.database.get_current_burnchain_block_height()?,
                   "function_name" => function_name,
                   "contract_id" => %contract_id
             );
diff --git a/pox-locking/src/pox_4.rs b/pox-locking/src/pox_4.rs
index b21df2408f..8eda9a2e89 100644
--- a/pox-locking/src/pox_4.rs
+++ b/pox-locking/src/pox_4.rs
@@ -43,15 +43,15 @@ pub fn pox_lock_v4(
     assert!(unlock_burn_height > 0);
     assert!(lock_amount > 0);
 
-    let mut snapshot = db.get_stx_balance_snapshot(principal);
+    let mut snapshot = db.get_stx_balance_snapshot(principal)?;
 
-    if snapshot.has_locked_tokens() {
+    if snapshot.has_locked_tokens()? {
         return Err(LockingError::PoxAlreadyLocked);
     }
-    if !snapshot.can_transfer(lock_amount) {
+    if !snapshot.can_transfer(lock_amount)? {
         return Err(LockingError::PoxInsufficientBalance);
     }
-    snapshot.lock_tokens_v4(lock_amount, unlock_burn_height);
+    snapshot.lock_tokens_v4(lock_amount, unlock_burn_height)?;
 
     debug!(
         "PoX v4 lock applied";
@@ -61,7 +61,7 @@ pub fn pox_lock_v4(
         "account" => %principal,
     );
 
-    snapshot.save();
+    snapshot.save()?;
     Ok(())
 }
 
@@ -79,13 +79,13 @@ pub fn pox_lock_extend_v4(
 ) -> Result<u128, LockingError> {
     assert!(unlock_burn_height > 0);
 
-    let mut snapshot = db.get_stx_balance_snapshot(principal);
+    let mut snapshot = db.get_stx_balance_snapshot(principal)?;
 
-    if !snapshot.has_locked_tokens() {
+    if !snapshot.has_locked_tokens()? {
         return Err(LockingError::PoxExtendNotLocked);
     }
 
-    snapshot.extend_lock_v4(unlock_burn_height);
+    snapshot.extend_lock_v4(unlock_burn_height)?;
 
     let amount_locked = snapshot.balance().amount_locked();
 
@@ -97,7 +97,7 @@ pub fn pox_lock_extend_v4(
         "account" => %principal,
     );
 
-    snapshot.save();
+    snapshot.save()?;
     Ok(amount_locked)
 }
 
@@ -115,13 +115,13 @@ pub fn pox_lock_increase_v4(
 ) -> Result<STXBalance, LockingError> {
     assert!(new_total_locked > 0);
 
-    let mut snapshot = db.get_stx_balance_snapshot(principal);
+    let mut snapshot = db.get_stx_balance_snapshot(principal)?;
 
-    if !snapshot.has_locked_tokens() {
+    if !snapshot.has_locked_tokens()? {
         return Err(LockingError::PoxExtendNotLocked);
     }
 
-    let bal = snapshot.canonical_balance_repr();
+    let bal = snapshot.canonical_balance_repr()?;
     let total_amount = bal
         .amount_unlocked()
         .checked_add(bal.amount_locked())
@@ -134,9 +134,9 @@ pub fn pox_lock_increase_v4(
         return Err(LockingError::PoxInvalidIncrease);
     }
 
-    snapshot.increase_lock_v4(new_total_locked);
+    snapshot.increase_lock_v4(new_total_locked)?;
 
-    let out_balance = snapshot.canonical_balance_repr();
+    let out_balance = snapshot.canonical_balance_repr()?;
 
     debug!(
         "PoX v4 lock increased";
@@ -146,7 +146,7 @@ pub fn pox_lock_increase_v4(
         "account" => %principal,
     );
 
-    snapshot.save();
+    snapshot.save()?;
     Ok(out_balance)
 }
 
diff --git a/stacks-signer/src/client/mod.rs b/stacks-signer/src/client/mod.rs
index bcfece5a84..aae9edcea2 100644
--- a/stacks-signer/src/client/mod.rs
+++ b/stacks-signer/src/client/mod.rs
@@ -21,6 +21,7 @@ pub(crate) mod stacks_client;
 
 use std::time::Duration;
 
+use clarity::vm::errors::Error as ClarityError;
 use clarity::vm::types::serialization::SerializationError;
 use clarity::vm::Value as ClarityValue;
 use libsigner::RPCError;
@@ -78,6 +79,15 @@ pub enum ClientError {
     /// Backoff retry timeout
     #[error("Backoff retry timeout occurred. Stacks node may be down.")]
     RetryTimeout,
+    /// Clarity interpreter error
+    #[error("Clarity interpreter error: {0}")]
+    ClarityError(ClarityError),
+}
+
+impl From<ClarityError> for ClientError {
+    fn from(e: ClarityError) -> ClientError {
+        ClientError::ClarityError(e)
+    }
 }
 
 /// Retry a function F with an exponential backoff and notification on transient failure
diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index 7f8d030685..935b74cf97 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -172,13 +172,13 @@ impl StacksClient {
         debug!("Parsing aggregate public key: {hex}...");
         // Due to pox 4 definition, the aggregate public key is always an optional clarity value hence the use of expect
         // If this fails, we have bigger problems than the signer crashing...
-        let value_opt = ClarityValue::try_deserialize_hex_untyped(hex)?.expect_optional();
+        let value_opt = ClarityValue::try_deserialize_hex_untyped(hex)?.expect_optional()?;
         let Some(value) = value_opt else {
             return Ok(None);
         };
         // A point should have 33 bytes exactly due to the pox 4 definition hence the use of expect
         // If this fails, we have bigger problems than the signer crashing...
-        let data = value.clone().expect_buff(33);
+        let data = value.clone().expect_buff(33)?;
         // It is possible that the point was invalid though when voted upon and this cannot be prevented by pox 4 definitions...
         // Pass up this error if the conversions fail.
         let compressed_data = Compressed::try_from(data.as_slice())
diff --git a/stackslib/src/chainstate/coordinator/tests.rs b/stackslib/src/chainstate/coordinator/tests.rs
index e0d9cc9c0c..b823545f30 100644
--- a/stackslib/src/chainstate/coordinator/tests.rs
+++ b/stackslib/src/chainstate/coordinator/tests.rs
@@ -3232,43 +3232,50 @@ fn test_stx_transfer_btc_ops() {
 
             if ix > 2 {
                 assert_eq!(
-                    sender_balance.get_available_balance_at_burn_block(
-                        burn_height as u64,
-                        pox_v1_unlock_ht,
-                        pox_v2_unlock_ht,
-                        pox_v3_unlock_ht,
-                    )
-                    .unwrap(),
+                    sender_balance
+                        .get_available_balance_at_burn_block(
+                            burn_height as u64,
+                            pox_v1_unlock_ht,
+                            pox_v2_unlock_ht,
+                            pox_v3_unlock_ht,
+                        )
+                        .unwrap(),
                     (balance as u128) - transfer_amt,
                     "Transfer should have decremented balance"
                 );
                 assert_eq!(
-                    recipient_balance.get_available_balance_at_burn_block(
-                        burn_height as u64,
-                        pox_v1_unlock_ht,
-                        pox_v2_unlock_ht,
-                        pox_v3_unlock_ht,
-                    ).unwrap(),
+                    recipient_balance
+                        .get_available_balance_at_burn_block(
+                            burn_height as u64,
+                            pox_v1_unlock_ht,
+                            pox_v2_unlock_ht,
+                            pox_v3_unlock_ht,
+                        )
+                        .unwrap(),
                     transfer_amt,
                     "Recipient should have incremented balance"
                 );
             } else {
                 assert_eq!(
-                    sender_balance.get_available_balance_at_burn_block(
-                        burn_height as u64,
-                        pox_v1_unlock_ht,
-                        pox_v2_unlock_ht,
-                        pox_v3_unlock_ht,
-                    ).unwrap(),
+                    sender_balance
+                        .get_available_balance_at_burn_block(
+                            burn_height as u64,
+                            pox_v1_unlock_ht,
+                            pox_v2_unlock_ht,
+                            pox_v3_unlock_ht,
+                        )
+                        .unwrap(),
                     balance as u128,
                 );
                 assert_eq!(
-                    recipient_balance.get_available_balance_at_burn_block(
-                        burn_height as u64,
-                        pox_v1_unlock_ht,
-                        pox_v2_unlock_ht,
-                        pox_v3_unlock_ht,
-                    ).unwrap(),
+                    recipient_balance
+                        .get_available_balance_at_burn_block(
+                            burn_height as u64,
+                            pox_v1_unlock_ht,
+                            pox_v2_unlock_ht,
+                            pox_v3_unlock_ht,
+                        )
+                        .unwrap(),
                     0,
                 );
             }
diff --git a/stackslib/src/chainstate/nakamoto/miner.rs b/stackslib/src/chainstate/nakamoto/miner.rs
index 1f71f7031c..ebcd0cbb99 100644
--- a/stackslib/src/chainstate/nakamoto/miner.rs
+++ b/stackslib/src/chainstate/nakamoto/miner.rs
@@ -324,7 +324,7 @@ impl NakamotoBlockBuilder {
 
     /// Finish up mining an epoch's transactions.
     /// Return the ExecutionCost consumed so far.
-    pub fn tenure_finish(self, tx: ClarityTx) -> ExecutionCost {
+    pub fn tenure_finish(self, tx: ClarityTx) -> Result<ExecutionCost, Error> {
         let new_consensus_hash = MINER_BLOCK_CONSENSUS_HASH.clone();
         let new_block_hash = MINER_BLOCK_HEADER_HASH.clone();
 
@@ -332,11 +332,11 @@ impl NakamotoBlockBuilder {
             StacksBlockHeader::make_index_block_hash(&new_consensus_hash, &new_block_hash);
 
         // write out the trie...
-        let consumed = tx.commit_mined_block(&index_block_hash);
+        let consumed = tx.commit_mined_block(&index_block_hash)?;
 
         test_debug!("\n\nFinished mining. Trie is in mined_blocks table.\n",);
 
-        consumed
+        Ok(consumed)
     }
 
     /// Finish constructing a Nakamoto block.
@@ -477,7 +477,7 @@ impl NakamotoBlockBuilder {
         // save the block so we can build microblocks off of it
         let block = builder.mine_nakamoto_block(&mut tenure_tx);
         let size = builder.bytes_so_far;
-        let consumed = builder.tenure_finish(tenure_tx);
+        let consumed = builder.tenure_finish(tenure_tx)?;
 
         let ts_end = get_epoch_time_ms();
 
diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index a6ad43e671..78af526912 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -81,7 +81,7 @@ use crate::chainstate::stacks::{
 };
 use crate::clarity::vm::clarity::{ClarityConnection, TransactionConnection};
 use crate::clarity_vm::clarity::{
-    ClarityInstance, ClarityTransactionConnection, PreCommitClarityBlock,
+    ClarityInstance, ClarityTransactionConnection, Error as ClarityError, PreCommitClarityBlock,
 };
 use crate::clarity_vm::database::SortitionDBRef;
 use crate::core::BOOT_BLOCK_HASH;
@@ -1851,7 +1851,7 @@ impl NakamotoChainState {
                     reward_cycle.into(),
                 ))],
             )?
-            .expect_u128();
+            .expect_u128()?;
 
         let mut slots = vec![];
         for index in 0..list_length {
@@ -1864,12 +1864,12 @@ impl NakamotoChainState {
                         SymbolicExpression::atom_value(Value::UInt(index)),
                     ],
                 )?
-                .expect_optional()
+                .expect_optional()?
                 .expect(&format!(
                     "FATAL: missing PoX address in slot {} out of {} in reward cycle {}",
                     index, list_length, reward_cycle
                 ))
-                .expect_tuple();
+                .expect_tuple()?;
 
             let pox_addr_tuple = entry
                 .get("pox-addr")
@@ -1886,17 +1886,21 @@ impl NakamotoChainState {
                 .get("total-ustx")
                 .expect(&format!("FATAL: no 'total-ustx' in return value from (get-reward-set-pox-address u{} u{})", reward_cycle, index))
                 .to_owned()
-                .expect_u128();
+                .expect_u128()?;
 
-            let stacker = entry
+            let stacker_opt = entry
                 .get("stacker")
                 .expect(&format!(
                     "FATAL: no 'stacker' in return value from (get-reward-set-pox-address u{} u{})",
                     reward_cycle, index
                 ))
                 .to_owned()
-                .expect_optional()
-                .map(|value| value.expect_principal());
+                .expect_optional()?;
+
+            let stacker = match stacker_opt {
+                Some(stacker_value) => Some(stacker_value.expect_principal()?),
+                None => None,
+            };
 
             let signer = entry
                 .get("signer")
@@ -1905,7 +1909,7 @@ impl NakamotoChainState {
                     reward_cycle, index
                 ))
                 .to_owned()
-                .expect_buff(SIGNERS_PK_LEN);
+                .expect_buff(SIGNERS_PK_LEN)?;
             // (buff 33) only enforces max size, not min size, so we need to do a len check
             let pk_bytes = if signer.len() == SIGNERS_PK_LEN {
                 let mut bytes = [0; SIGNERS_PK_LEN];
@@ -1936,7 +1940,7 @@ impl NakamotoChainState {
         let sender_addr = PrincipalData::from(boot::boot_code_addr(is_mainnet));
         let signers_contract = &boot_code_id(SIGNERS_NAME, is_mainnet);
 
-        let liquid_ustx = clarity.with_clarity_db_readonly(|db| db.get_total_liquid_ustx());
+        let liquid_ustx = clarity.with_clarity_db_readonly(|db| db.get_total_liquid_ustx())?;
         let reward_slots = Self::get_reward_slots(clarity, reward_cycle, pox_contract)?;
         let (threshold, participation) = StacksChainState::get_reward_threshold_and_participation(
             &pox_constants,
@@ -2058,7 +2062,7 @@ impl NakamotoChainState {
         let needs_update = clarity_tx.connection().with_clarity_db_readonly(|clarity_db| {
             if !clarity_db.has_contract(signers_contract) {
                 // if there's no signers contract, no need to update anything.
-                return false
+                return Ok::<_, ChainstateError>(false);
             }
             let Ok(value) = clarity_db.lookup_variable_unknown_descriptor(
                 signers_contract,
@@ -2068,11 +2072,11 @@ impl NakamotoChainState {
                 error!("FATAL: Failed to read `{SIGNERS_UPDATE_STATE}` variable from .signers contract");
                 panic!();
             };
-            let cycle_number = value.expect_u128();
+            let cycle_number = value.expect_u128().map_err(|e| ChainstateError::ClarityError(ClarityError::Interpreter(e)))?;
             // if the cycle_number is less than `cycle_of_prepare_phase`, we need to update
             //  the .signers state.
-            cycle_number < cycle_of_prepare_phase.into()
-        });
+            Ok::<_, ChainstateError>(cycle_number < cycle_of_prepare_phase.into())
+        })?;
 
         if !needs_update {
             debug!("Current cycle has already been setup in .signers or .signers is not initialized yet");
@@ -2948,10 +2952,13 @@ impl NakamotoChainState {
             )
             .ok()
             .map(|agg_key_value| {
-                let agg_key_opt = agg_key_value.expect_optional().map(|agg_key_buff| {
-                    Value::buff_from(agg_key_buff.expect_buff(33))
-                        .expect("failed to reconstruct buffer")
-                });
+                let agg_key_opt = agg_key_value
+                    .expect_optional()
+                    .expect("FATAL: not an optional")
+                    .map(|agg_key_buff| {
+                        Value::buff_from(agg_key_buff.expect_buff(33).expect("FATAL: not a buff"))
+                            .expect("failed to reconstruct buffer")
+                    });
                 agg_key_opt
             })
             .flatten()
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 509769916a..1294091f5e 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -1171,7 +1171,7 @@ impl StacksChainState {
                 POX_4_NAME,
                 &format!("(get-reward-set-size u{})", reward_cycle),
             )?
-            .expect_u128();
+            .expect_u128()?;
 
         debug!(
             "At block {:?} (reward cycle {}): {} PoX reward addresses",
@@ -1194,12 +1194,12 @@ impl StacksChainState {
                     POX_4_NAME,
                     &format!("(get-reward-set-pox-address u{} u{})", reward_cycle, i),
                 )?
-                .expect_optional()
+                .expect_optional()?
                 .expect(&format!(
                     "FATAL: missing PoX address in slot {} out of {} in reward cycle {}",
                     i, num_addrs, reward_cycle
                 ))
-                .expect_tuple();
+                .expect_tuple()?;
 
             let pox_addr_tuple = tuple
                 .get("pox-addr")
@@ -1216,17 +1216,21 @@ impl StacksChainState {
                 .get("total-ustx")
                 .expect(&format!("FATAL: no 'total-ustx' in return value from (get-reward-set-pox-address u{} u{})", reward_cycle, i))
                 .to_owned()
-                .expect_u128();
+                .expect_u128()?;
 
-            let stacker = tuple
+            let stacker_opt = tuple
                 .get("stacker")
                 .expect(&format!(
                     "FATAL: no 'stacker' in return value from (get-reward-set-pox-address u{} u{})",
                     reward_cycle, i
                 ))
                 .to_owned()
-                .expect_optional()
-                .map(|value| value.expect_principal());
+                .expect_optional()?;
+
+            let stacker = match stacker_opt {
+                Some(stacker_value) => Some(stacker_value.expect_principal()?),
+                None => None,
+            };
 
             let signer = tuple
                 .get("signer")
@@ -1235,7 +1239,7 @@ impl StacksChainState {
                     reward_cycle, i
                 ))
                 .to_owned()
-                .expect_buff(SIGNERS_PK_LEN);
+                .expect_buff(SIGNERS_PK_LEN)?;
             // (buff 33) only enforces max size, not min size, so we need to do a len check
             let pk_bytes = if signer.len() == SIGNERS_PK_LEN {
                 let mut bytes = [0; SIGNERS_PK_LEN];
@@ -1330,21 +1334,25 @@ impl StacksChainState {
         block_id: &StacksBlockId,
         reward_cycle: u64,
     ) -> Result<Option<Point>, Error> {
-        let aggregate_public_key = self
+        let aggregate_public_key_opt = self
             .eval_boot_code_read_only(
                 sortdb,
                 block_id,
                 POX_4_NAME,
                 &format!("(get-aggregate-public-key u{})", reward_cycle),
             )?
-            .expect_optional()
-            .map(|value| {
+            .expect_optional()?;
+
+        let aggregate_public_key = match aggregate_public_key_opt {
+            Some(value) => {
                 // A point should have 33 bytes exactly.
-                let data = value.expect_buff(33);
+                let data = value.expect_buff(33)?;
                 let msg = "Pox-4 get-aggregate-public-key returned a corrupted value.";
                 let compressed_data = Compressed::try_from(data.as_slice()).expect(msg);
-                Point::try_from(&compressed_data).expect(msg)
-            });
+                Some(Point::try_from(&compressed_data).expect(msg))
+            }
+            None => None,
+        };
         Ok(aggregate_public_key)
     }
 }
diff --git a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
index f31ced3e06..d7ac4912ac 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
@@ -76,7 +76,8 @@ use crate::chainstate::stacks::events::{StacksTransactionReceipt, TransactionOri
 use crate::chainstate::stacks::index::marf::MarfConnection;
 use crate::chainstate::stacks::index::MarfTrieId;
 use crate::chainstate::stacks::tests::make_coinbase;
-use crate::chainstate::{self, stacks::*};
+use crate::chainstate::stacks::*;
+use crate::chainstate::{self};
 use crate::clarity_vm::clarity::{ClarityBlockConnection, Error as ClarityError};
 use crate::clarity_vm::database::marf::{MarfedKV, WritableMarfStore};
 use crate::clarity_vm::database::HeadersDBConn;
diff --git a/stackslib/src/chainstate/stacks/db/blocks.rs b/stackslib/src/chainstate/stacks/db/blocks.rs
index bc27be5042..cfc22cdd95 100644
--- a/stackslib/src/chainstate/stacks/db/blocks.rs
+++ b/stackslib/src/chainstate/stacks/db/blocks.rs
@@ -6491,17 +6491,18 @@ impl StacksChainState {
             return Err(MemPoolRejection::BadAddressVersionByte);
         }
 
-        let (block_height, v1_unlock_height, v2_unlock_height) = clarity_connection
-            .with_clarity_db_readonly::<_, Result<_, clarity::vm::errors::Error>>(
-                |ref mut db| {
-                    Ok((
-                        db.get_current_burnchain_block_height()? as u64,
-                        db.get_v1_unlock_height(),
-                        db.get_v2_unlock_height()?,
-                        db.get_v3_unlock_height()?
-                    ))
-                },
-            )?;
+        let (block_height, v1_unlock_height, v2_unlock_height, v3_unlock_height) =
+            clarity_connection
+                .with_clarity_db_readonly::<_, Result<_, clarity::vm::errors::Error>>(
+                    |ref mut db| {
+                        Ok((
+                            db.get_current_burnchain_block_height()? as u64,
+                            db.get_v1_unlock_height(),
+                            db.get_v2_unlock_height()?,
+                            db.get_v3_unlock_height()?,
+                        ))
+                    },
+                )?;
 
         // 5: the paying account must have enough funds
         if !payer.stx_balance.can_transfer_at_burn_block(
diff --git a/stackslib/src/chainstate/stacks/db/transactions.rs b/stackslib/src/chainstate/stacks/db/transactions.rs
index 21c635ff14..794b3b8a61 100644
--- a/stackslib/src/chainstate/stacks/db/transactions.rs
+++ b/stackslib/src/chainstate/stacks/db/transactions.rs
@@ -492,12 +492,13 @@ impl StacksChainState {
     ) -> Result<u64, Error> {
         let (cur_burn_block_height, v1_unlock_ht, v2_unlock_ht, v3_unlock_ht) = clarity_tx
             .with_clarity_db_readonly(|ref mut db| {
-                (
+                let res: Result<_, Error> = Ok((
                     db.get_current_burnchain_block_height()?,
                     db.get_v1_unlock_height(),
                     db.get_v2_unlock_height()?,
                     db.get_v3_unlock_height()?,
-                )
+                ));
+                res
             })?;
 
         let consolidated_balance = payer_account
@@ -876,11 +877,11 @@ impl StacksChainState {
             .get_microblock_poison_report(mblock_pubk_height)?
         {
             // account for report loaded
-            env.add_memory(
-                u64:from(TypeSignature::PrincipalType
+            env.add_memory(u64::from(
+                TypeSignature::PrincipalType
                     .size()
-                    .map_err(InterpreterError::from)?),
-            )
+                    .map_err(InterpreterError::from)?,
+            ))
             .map_err(|e| Error::from_cost_error(e, cost_before.clone(), &env.global_context))?;
 
             // u128 sequence
diff --git a/stackslib/src/chainstate/stacks/miner.rs b/stackslib/src/chainstate/stacks/miner.rs
index 4858e86bd9..b7eb827ef6 100644
--- a/stackslib/src/chainstate/stacks/miner.rs
+++ b/stackslib/src/chainstate/stacks/miner.rs
@@ -1933,7 +1933,7 @@ impl StacksBlockBuilder {
     }
 
     /// Finish up mining an epoch's transactions
-    pub fn epoch_finish(self, tx: ClarityTx) -> ExecutionCost {
+    pub fn epoch_finish(self, tx: ClarityTx) -> Result<ExecutionCost, Error> {
         let new_consensus_hash = MINER_BLOCK_CONSENSUS_HASH.clone();
         let new_block_hash = MINER_BLOCK_HEADER_HASH.clone();
 
@@ -1945,7 +1945,7 @@ impl StacksBlockBuilder {
         //        let moved_name = format!("{}.mined", index_block_hash);
 
         // write out the trie...
-        let consumed = tx.commit_mined_block(&index_block_hash);
+        let consumed = tx.commit_mined_block(&index_block_hash)?;
 
         test_debug!(
             "\n\nMiner {}: Finished mining child of {}/{}. Trie is in mined_blocks table.\n",
@@ -1954,7 +1954,7 @@ impl StacksBlockBuilder {
             self.chain_tip.anchored_header.block_hash()
         );
 
-        consumed
+        Ok(consumed)
     }
     /// Unconditionally build an anchored block from a list of transactions.
     ///  Used in test cases
@@ -2031,7 +2031,7 @@ impl StacksBlockBuilder {
             None
         };
 
-        let cost = builder.epoch_finish(epoch_tx);
+        let cost = builder.epoch_finish(epoch_tx)?;
         Ok((block, size, cost, mblock_opt))
     }
 
@@ -2459,7 +2459,7 @@ impl StacksBlockBuilder {
         // save the block so we can build microblocks off of it
         let block = builder.mine_anchored_block(&mut epoch_tx);
         let size = builder.bytes_so_far;
-        let consumed = builder.epoch_finish(epoch_tx);
+        let consumed = builder.epoch_finish(epoch_tx)?;
 
         let ts_end = get_epoch_time_ms();
 
diff --git a/stackslib/src/clarity_vm/clarity.rs b/stackslib/src/clarity_vm/clarity.rs
index 7926cc1e76..b534fcb8c3 100644
--- a/stackslib/src/clarity_vm/clarity.rs
+++ b/stackslib/src/clarity_vm/clarity.rs
@@ -795,8 +795,9 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
     /// Get the boot code account
     fn get_boot_code_account(&mut self) -> Result<StacksAccount, Error> {
         let boot_code_address = boot_code_addr(self.mainnet);
-        let boot_code_nonce = self
-            .with_clarity_db_readonly(|db| db.get_account_nonce(&boot_code_address.clone().into()));
+        let boot_code_nonce = self.with_clarity_db_readonly(|db| {
+            db.get_account_nonce(&boot_code_address.clone().into())
+        })?;
 
         let boot_code_account = boot_code_acc(boot_code_address, boot_code_nonce);
         Ok(boot_code_account)
@@ -819,13 +820,9 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
                 TransactionVersion::Testnet
             };
 
-            let boot_code_address = boot_code_addr(mainnet);
-            let boot_code_auth = boot_code_tx_auth(boot_code_address);
-            let boot_code_nonce = self.with_clarity_db_readonly(|db| {
-                db.get_account_nonce(&boot_code_address.clone().into())
-                    .expect("FATAL: Failed to boot account nonce")
-            });
-            let boot_code_account = boot_code_acc(boot_code_address, boot_code_nonce);
+            let boot_code_account = self
+                .get_boot_code_account()
+                .expect("FATAL: failed to get boot code account");
 
             // instantiate costs 2 contract...
             let cost_2_code = if mainnet {
@@ -845,7 +842,6 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
             );
 
             let boot_code_address = boot_code_addr(self.mainnet);
-
             let boot_code_auth = boot_code_tx_auth(boot_code_address.clone());
 
             let costs_2_contract_tx =
@@ -1279,7 +1275,7 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
                 // bump the epoch in the Clarity DB
                 tx_conn
                     .with_clarity_db(|db| {
-                        db.set_clarity_epoch_version(StacksEpochId::Epoch25);
+                        db.set_clarity_epoch_version(StacksEpochId::Epoch25)?;
                         Ok(())
                     })
                     .unwrap();
@@ -1309,10 +1305,6 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
                 TransactionVersion::Testnet
             };
 
-            let boot_code_address = boot_code_addr(mainnet);
-
-            let boot_code_auth = boot_code_tx_auth(boot_code_address.clone());
-
             let boot_code_account = self
                 .get_boot_code_account()
                 .expect("FATAL: did not get boot account");
@@ -1330,31 +1322,40 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
                 Some(ClarityVersion::Clarity2),
             );
 
+            let boot_code_address = boot_code_addr(mainnet);
+            let boot_code_auth = boot_code_tx_auth(boot_code_address.clone());
+
             let pox_4_contract_tx =
                 StacksTransaction::new(tx_version.clone(), boot_code_auth.clone(), payload);
 
             let initialized_agg_key = if !mainnet {
-                self.with_readonly_clarity_env(
-                    false,
-                    self.chain_id,
-                    ClarityVersion::Clarity2,
-                    StacksAddress::burn_address(false).into(),
-                    None,
-                    LimitedCostTracker::Free,
-                    |vm_env| {
-                        vm_env.execute_contract_allow_private(
-                            &boot_code_id(BOOT_TEST_POX_4_AGG_KEY_CONTRACT, false),
-                            BOOT_TEST_POX_4_AGG_KEY_FNAME,
-                            &[],
-                            true,
+                let agg_key_value_opt = self
+                    .with_readonly_clarity_env(
+                        false,
+                        self.chain_id,
+                        ClarityVersion::Clarity2,
+                        StacksAddress::burn_address(false).into(),
+                        None,
+                        LimitedCostTracker::Free,
+                        |vm_env| {
+                            vm_env.execute_contract_allow_private(
+                                &boot_code_id(BOOT_TEST_POX_4_AGG_KEY_CONTRACT, false),
+                                BOOT_TEST_POX_4_AGG_KEY_FNAME,
+                                &[],
+                                true,
+                            )
+                        },
+                    )
+                    .map(|agg_key_value| {
+                        Ok::<_, InterpreterError>(
+                            Value::buff_from(agg_key_value.expect_buff(33)?)
+                                .expect("failed to reconstruct buffer"),
                         )
-                    },
-                )
-                .ok()
-                .map(|agg_key_value| {
-                    Value::buff_from(agg_key_value.expect_buff(33))
-                        .expect("failed to reconstruct buffer")
-                })
+                    })
+                    .ok()
+                    .transpose()
+                    .expect("FATAL: failed to load aggregate public key");
+                agg_key_value_opt
             } else {
                 None
             };
@@ -1533,7 +1534,7 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
                 // bump the epoch in the Clarity DB
                 tx_conn
                     .with_clarity_db(|db| {
-                        db.set_clarity_epoch_version(StacksEpochId::Epoch30);
+                        db.set_clarity_epoch_version(StacksEpochId::Epoch30)?;
                         Ok(())
                     })
                     .unwrap();
diff --git a/stackslib/src/net/api/getaccount.rs b/stackslib/src/net/api/getaccount.rs
index a61cb40e05..f29f62cb9b 100644
--- a/stackslib/src/net/api/getaccount.rs
+++ b/stackslib/src/net/api/getaccount.rs
@@ -148,8 +148,8 @@ impl RPCRequestHandler for RPCGetAccountRequestHandler {
                         let burn_block_height =
                             clarity_db.get_current_burnchain_block_height().ok()? as u64;
                         let v1_unlock_height = clarity_db.get_v1_unlock_height();
-                        let v2_unlock_height = clarity_db.get_v2_unlock_height()?;
-                        let v3_unlock_height = clarity_db.get_v3_unlock_height()?;
+                        let v2_unlock_height = clarity_db.get_v2_unlock_height().ok()?;
+                        let v3_unlock_height = clarity_db.get_v3_unlock_height().ok()?;
                         let (balance, balance_proof) = if with_proof {
                             clarity_db
                                 .get_with_proof::<STXBalance>(&key)
@@ -183,12 +183,14 @@ impl RPCRequestHandler for RPCGetAccountRequestHandler {
                                 .unwrap_or_else(|| (0, None))
                         };
 
-                        let unlocked = balance.get_available_balance_at_burn_block(
-                            burn_block_height,
-                            v1_unlock_height,
-                            v2_unlock_height,
-                            v3_unlock_height,
-                        ).ok()?;
+                        let unlocked = balance
+                            .get_available_balance_at_burn_block(
+                                burn_block_height,
+                                v1_unlock_height,
+                                v2_unlock_height,
+                                v3_unlock_height,
+                            )
+                            .ok()?;
 
                         let (locked, unlock_height) = balance.get_locked_balance_at_burn_block(
                             burn_block_height,
diff --git a/stackslib/src/net/api/getpoxinfo.rs b/stackslib/src/net/api/getpoxinfo.rs
index c8cb166d49..d476d27a62 100644
--- a/stackslib/src/net/api/getpoxinfo.rs
+++ b/stackslib/src/net/api/getpoxinfo.rs
@@ -229,13 +229,13 @@ impl RPCPoxInfoData {
                 .get("rejection-fraction")
                 .expect(&format!("FATAL: no 'rejection-fraction'"))
                 .to_owned()
-                .expect_u128() as u64;
+                .expect_u128()? as u64;
 
             let current_rejection_votes = res
                 .get("current-rejection-votes")
                 .expect(&format!("FATAL: no 'current-rejection-votes'"))
                 .to_owned()
-                .expect_u128() as u64;
+                .expect_u128()? as u64;
 
             let total_required = (total_liquid_supply_ustx as u128 / 100)
                 .checked_mul(rejection_fraction as u128)
diff --git a/stackslib/src/net/api/postblock_proposal.rs b/stackslib/src/net/api/postblock_proposal.rs
index 5d7b5f8321..c0f3fa019d 100644
--- a/stackslib/src/net/api/postblock_proposal.rs
+++ b/stackslib/src/net/api/postblock_proposal.rs
@@ -284,7 +284,7 @@ impl NakamotoBlockProposal {
 
         let mut block = builder.mine_nakamoto_block(&mut tenure_tx);
         let size = builder.get_bytes_so_far();
-        let cost = builder.tenure_finish(tenure_tx);
+        let cost = builder.tenure_finish(tenure_tx)?;
 
         // Clone signatures from block proposal
         // These have already been validated by `validate_nakamoto_block_burnchain()``
diff --git a/stackslib/src/net/stackerdb/config.rs b/stackslib/src/net/stackerdb/config.rs
index 8cd9ce4b20..0ff401e0c9 100644
--- a/stackslib/src/net/stackerdb/config.rs
+++ b/stackslib/src/net/stackerdb/config.rs
@@ -473,7 +473,7 @@ impl StackerDBConfig {
                     // contract must exist or this errors out
                     let analysis = db
                         .load_contract_analysis(contract_id)?
-                        .ok_or(net_error::NoSuchStackerDB(contract_id.clone()))?;
+                        .ok_or(NetError::NoSuchStackerDB(contract_id.clone()))?;
 
                     // contract must be consistent with StackerDB control interface
                     if let Err(invalid_reason) =
diff --git a/stackslib/src/net/stackerdb/sync.rs b/stackslib/src/net/stackerdb/sync.rs
index d01d4ff03f..8e98852e3e 100644
--- a/stackslib/src/net/stackerdb/sync.rs
+++ b/stackslib/src/net/stackerdb/sync.rs
@@ -42,7 +42,6 @@ const MAX_CHUNKS_IN_FLIGHT: usize = 6;
 const MAX_DB_NEIGHBORS: usize = 32;
 
 impl<NC: NeighborComms> StackerDBSync<NC> {
-    /// TODO: replace `stackerdbs` with a type parameter
     pub fn new(
         smart_contract: QualifiedContractIdentifier,
         config: &StackerDBConfig,
diff --git a/testnet/stacks-node/Cargo.toml b/testnet/stacks-node/Cargo.toml
index c19bad88a0..ed2b8f6690 100644
--- a/testnet/stacks-node/Cargo.toml
+++ b/testnet/stacks-node/Cargo.toml
@@ -9,7 +9,6 @@ rust-version = "1.61"
 [dependencies]
 lazy_static = "1.4.0"
 pico-args = "0.5.0"
-rand = "0.7.3"
 serde = "1"
 serde_derive = "1"
 serde_json = { version = "1.0", features = ["arbitrary_precision", "raw_value"] }
diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index 1de0dda354..344f7bbb8b 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -40,8 +40,8 @@ use stacks_common::util::get_epoch_time_ms;
 use stacks_common::util::hash::hex_bytes;
 use stacks_common::util::secp256k1::{Secp256k1PrivateKey, Secp256k1PublicKey};
 
-use crate::mockamoto::signer::SelfSigner;
 use crate::chain_data::MinerStats;
+use crate::mockamoto::signer::SelfSigner;
 
 pub const DEFAULT_SATS_PER_VB: u64 = 50;
 const DEFAULT_MAX_RBF_RATE: u64 = 150; // 1.5x
@@ -506,17 +506,6 @@ impl Config {
         self.miner.self_signing_key.clone()
     }
 
-    /// get the up-to-date burnchain from the config
-    pub fn get_burnchain_config(&self) -> Result<BurnchainConfig, String> {
-        if let Some(path) = &self.config_path {
-            let config_file = ConfigFile::from_path(path.as_str())?;
-            let config = Config::from_config_file(config_file)?;
-            Ok(config.burnchain)
-        } else {
-            Ok(self.burnchain.clone())
-        }
-    }
- 
     /// get the up-to-date burnchain options from the config.
     /// If the config file can't be loaded, then return the existing config
     pub fn get_burnchain_config(&self) -> BurnchainConfig {
@@ -1959,7 +1948,7 @@ impl NodeConfig {
     }
 }
 
-#[derive(Clone, Debug, Default, PartialEq)]
+#[derive(Clone, Debug, PartialEq)]
 pub struct MinerConfig {
     pub first_attempt_time_ms: u64,
     pub subsequent_attempt_time_ms: u64,
@@ -2362,7 +2351,6 @@ pub struct MinerConfigFile {
 impl MinerConfigFile {
     fn into_config_default(self, miner_default_config: MinerConfig) -> Result<MinerConfig, String> {
         Ok(MinerConfig {
-            min_tx_fee: self.min_tx_fee.unwrap_or(miner_default_config.min_tx_fee),
             first_attempt_time_ms: self
                 .first_attempt_time_ms
                 .unwrap_or(miner_default_config.first_attempt_time_ms),
@@ -2410,25 +2398,28 @@ impl MinerConfigFile {
                 .wait_on_interim_blocks_ms
                 .map(Duration::from_millis)
                 .unwrap_or(miner_default_config.wait_on_interim_blocks),
-            min_tx_count: miner_default_config.min_tx_count.unwrap_or(0),
-            only_increase_tx_count: miner_default_config.only_increase_tx_count.unwrap_or(false),
-            unconfirmed_commits_helper: miner_default_config.unconfirmed_commits_helper.clone(),
-            target_win_probability: miner_default_config.target_win_probability.unwrap_or(0.0),
-            activated_vrf_key_path: miner_default_config.activated_vrf_key_path.clone(),
-            fast_rampup: miner_default_config.fast_rampup.unwrap_or(true),
-            underperform_stop_threshold: miner_default_config.underperform_stop_threshold,
+            min_tx_count: self
+                .min_tx_count
+                .unwrap_or(miner_default_config.min_tx_count),
+            only_increase_tx_count: self
+                .only_increase_tx_count
+                .unwrap_or(miner_default_config.only_increase_tx_count),
+            unconfirmed_commits_helper: self.unconfirmed_commits_helper.clone(),
+            target_win_probability: self
+                .target_win_probability
+                .unwrap_or(miner_default_config.target_win_probability),
+            activated_vrf_key_path: self.activated_vrf_key_path.clone(),
+            fast_rampup: self.fast_rampup.unwrap_or(miner_default_config.fast_rampup),
+            underperform_stop_threshold: self.underperform_stop_threshold,
             txs_to_consider: {
-                if let Some(txs_to_consider) = &miner_default_config.txs_to_consider {
+                if let Some(txs_to_consider) = &self.txs_to_consider {
                     txs_to_consider
                         .split(",")
                         .map(
                             |txs_to_consider_str| match str::parse(txs_to_consider_str) {
                                 Ok(txtype) => txtype,
                                 Err(e) => {
-                                    panic!(
-                                        "could not parse '{}': {}",
-                                        &txs_to_consider_str, &e
-                                    );
+                                    panic!("could not parse '{}': {}", &txs_to_consider_str, &e);
                                 }
                             },
                         )
@@ -2438,16 +2429,13 @@ impl MinerConfigFile {
                 }
             },
             filter_origins: {
-                if let Some(filter_origins) = &miner_default_config.filter_origins {
+                if let Some(filter_origins) = &self.filter_origins {
                     filter_origins
                         .split(",")
                         .map(|origin_str| match StacksAddress::from_string(origin_str) {
                             Some(addr) => addr,
                             None => {
-                                panic!(
-                                    "could not parse '{}' into a Stacks address",
-                                    origin_str
-                                );
+                                panic!("could not parse '{}' into a Stacks address", origin_str);
                             }
                         })
                         .collect()
@@ -2455,7 +2443,9 @@ impl MinerConfigFile {
                     HashSet::new()
                 }
             },
-            max_reorg_depth: miner_default_config.max_reorg_depth.unwrap_or(3),
+            max_reorg_depth: self
+                .max_reorg_depth
+                .unwrap_or(miner_default_config.max_reorg_depth),
         })
     }
 }
diff --git a/testnet/stacks-node/src/globals.rs b/testnet/stacks-node/src/globals.rs
index bd1560477c..5e126c2714 100644
--- a/testnet/stacks-node/src/globals.rs
+++ b/testnet/stacks-node/src/globals.rs
@@ -1,3 +1,4 @@
+use std::collections::{BTreeMap, HashMap};
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::mpsc::SyncSender;
 use std::sync::{Arc, Mutex};
@@ -12,10 +13,12 @@ use stacks::chainstate::stacks::miner::MinerStatus;
 use stacks::net::NetworkResult;
 use stacks_common::types::chainstate::{BlockHeaderHash, BurnchainHeaderHash, ConsensusHash};
 
+use crate::config::MinerConfig;
 use crate::neon::Counters;
 use crate::neon_node::LeaderKeyRegistrationState;
 use crate::run_loop::RegisteredKey;
 use crate::syncctl::PoxSyncWatchdogComms;
+use crate::TipCandidate;
 
 pub type NeonGlobals = Globals<RelayerDirective>;
 
@@ -57,6 +60,15 @@ pub struct Globals<T> {
     pub should_keep_running: Arc<AtomicBool>,
     /// Status of our VRF key registration state (shared between the main thread and the relayer)
     leader_key_registration_state: Arc<Mutex<LeaderKeyRegistrationState>>,
+    /// Last miner config loaded
+    last_miner_config: Arc<Mutex<Option<MinerConfig>>>,
+    /// burnchain height at which we start mining
+    start_mining_height: Arc<Mutex<u64>>,
+    /// estimated winning probability at given bitcoin block heights
+    estimated_winning_probs: Arc<Mutex<HashMap<u64, f64>>>,
+    /// previously-selected best tips
+    /// maps stacks height to tip candidate
+    previous_best_tips: Arc<Mutex<BTreeMap<u64, TipCandidate>>>,
 }
 
 // Need to manually implement Clone, because [derive(Clone)] requires
@@ -74,6 +86,10 @@ impl<T> Clone for Globals<T> {
             sync_comms: self.sync_comms.clone(),
             should_keep_running: self.should_keep_running.clone(),
             leader_key_registration_state: self.leader_key_registration_state.clone(),
+            last_miner_config: self.last_miner_config.clone(),
+            start_mining_height: self.start_mining_height.clone(),
+            estimated_winning_probs: self.estimated_winning_probs.clone(),
+            previous_best_tips: self.previous_best_tips.clone(),
         }
     }
 }
@@ -86,6 +102,7 @@ impl<T> Globals<T> {
         counters: Counters,
         sync_comms: PoxSyncWatchdogComms,
         should_keep_running: Arc<AtomicBool>,
+        start_mining_height: u64,
     ) -> Globals<T> {
         Globals {
             last_sortition: Arc::new(Mutex::new(None)),
@@ -99,6 +116,10 @@ impl<T> Globals<T> {
             leader_key_registration_state: Arc::new(Mutex::new(
                 LeaderKeyRegistrationState::Inactive,
             )),
+            last_miner_config: Arc::new(Mutex::new(None)),
+            start_mining_height: Arc::new(Mutex::new(start_mining_height)),
+            estimated_winning_probs: Arc::new(Mutex::new(HashMap::new())),
+            previous_best_tips: Arc::new(Mutex::new(BTreeMap::new())),
         }
     }
 
@@ -246,44 +267,163 @@ impl<T> Globals<T> {
         &self,
         burn_block_height: u64,
         key_registers: Vec<LeaderKeyRegisterOp>,
-    ) -> bool {
-        let mut activated = false;
-        let mut key_state = self
-            .leader_key_registration_state
-            .lock()
-            .unwrap_or_else(|e| {
-                // can only happen due to a thread panic in the relayer
-                error!("FATAL: leader key registration mutex is poisoned: {e:?}");
+    ) -> Option<RegisteredKey> {
+        let mut activated_key = None;
+        match self.leader_key_registration_state.lock() {
+            Ok(ref mut leader_key_registration_state) => {
+                for op in key_registers.into_iter() {
+                    if let LeaderKeyRegistrationState::Pending(target_block_height, txid) =
+                        **leader_key_registration_state
+                    {
+                        info!(
+                            "Received burnchain block #{} including key_register_op - {}",
+                            burn_block_height, txid
+                        );
+                        if txid == op.txid {
+                            let active_key = RegisteredKey {
+                                target_block_height,
+                                vrf_public_key: op.public_key,
+                                block_height: op.block_height as u64,
+                                op_vtxindex: op.vtxindex as u32,
+                            };
+
+                            **leader_key_registration_state =
+                                LeaderKeyRegistrationState::Active(active_key.clone());
+
+                            activated_key = Some(active_key);
+                        } else {
+                            debug!(
+                                "key_register_op {} does not match our pending op {}",
+                                txid, &op.txid
+                            );
+                        }
+                    }
+                }
+            }
+            Err(_e) => {
+                error!("FATAL: failed to lock leader key registration state mutex");
                 panic!();
-            });
-        // if key_state is anything but pending, then we don't activate
-        let LeaderKeyRegistrationState::Pending(target_block_height, txid) = *key_state else {
-            return false;
-        };
-        for op in key_registers.into_iter() {
-            info!(
-                "Processing burnchain block with key_register_op";
-                "burn_block_height" => burn_block_height,
-                "txid" => %op.txid,
-                "checking_txid" => %txid,
-            );
-
-            if txid == op.txid {
-                *key_state = LeaderKeyRegistrationState::Active(RegisteredKey {
-                    target_block_height,
-                    vrf_public_key: op.public_key,
-                    block_height: u64::from(op.block_height),
-                    op_vtxindex: u32::from(op.vtxindex),
-                });
-                activated = true;
-            } else {
-                debug!(
-                    "key_register_op {} does not match our pending op {}",
-                    txid, &op.txid
-                );
             }
         }
+        activated_key
+    }
 
-        activated
+    /// Directly set the leader key activation state from a saved key
+    pub fn resume_leader_key(&self, registered_key: RegisteredKey) {
+        match self.leader_key_registration_state.lock() {
+            Ok(ref mut leader_key_registration_state) => {
+                **leader_key_registration_state = LeaderKeyRegistrationState::Active(registered_key)
+            }
+            Err(_e) => {
+                error!("FATAL: failed to lock leader key registration state mutex");
+                panic!();
+            }
+        }
+    }
+
+    /// Get the last miner config loaded
+    pub fn get_last_miner_config(&self) -> Option<MinerConfig> {
+        match self.last_miner_config.lock() {
+            Ok(last_miner_config) => (*last_miner_config).clone(),
+            Err(_e) => {
+                error!("FATAL; failed to lock last miner config");
+                panic!();
+            }
+        }
+    }
+
+    /// Set the last miner config loaded
+    pub fn set_last_miner_config(&self, miner_config: MinerConfig) {
+        match self.last_miner_config.lock() {
+            Ok(ref mut last_miner_config) => **last_miner_config = Some(miner_config),
+            Err(_e) => {
+                error!("FATAL; failed to lock last miner config");
+                panic!();
+            }
+        }
+    }
+
+    /// Get the height at which we should start mining
+    pub fn get_start_mining_height(&self) -> u64 {
+        match self.start_mining_height.lock() {
+            Ok(ht) => *ht,
+            Err(_e) => {
+                error!("FATAL: failed to lock start_mining_height");
+                panic!();
+            }
+        }
+    }
+
+    /// Set the height at which we started mining.
+    /// Only takes effect if the current start mining height is 0.
+    pub fn set_start_mining_height_if_zero(&self, value: u64) {
+        match self.start_mining_height.lock() {
+            Ok(ref mut ht) => {
+                if **ht == 0 {
+                    **ht = value;
+                }
+            }
+            Err(_e) => {
+                error!("FATAL: failed to lock start_mining_height");
+                panic!();
+            }
+        }
+    }
+
+    /// Record an estimated winning probability
+    pub fn add_estimated_win_prob(&self, burn_height: u64, win_prob: f64) {
+        match self.estimated_winning_probs.lock() {
+            Ok(mut probs) => {
+                probs.insert(burn_height, win_prob);
+            }
+            Err(_e) => {
+                error!("FATAL: failed to lock estimated_winning_probs");
+                panic!();
+            }
+        }
+    }
+
+    /// Get the estimated winning probability, if we have one
+    pub fn get_estimated_win_prob(&self, burn_height: u64) -> Option<f64> {
+        match self.estimated_winning_probs.lock() {
+            Ok(probs) => probs.get(&burn_height).cloned(),
+            Err(_e) => {
+                error!("FATAL: failed to lock estimated_winning_probs");
+                panic!();
+            }
+        }
+    }
+
+    /// Record a best-tip
+    pub fn add_best_tip(&self, stacks_height: u64, tip_candidate: TipCandidate, max_depth: u64) {
+        match self.previous_best_tips.lock() {
+            Ok(mut tips) => {
+                tips.insert(stacks_height, tip_candidate);
+                let mut stale = vec![];
+                for (prev_height, _) in tips.iter() {
+                    if *prev_height + max_depth < stacks_height {
+                        stale.push(*prev_height);
+                    }
+                }
+                for height in stale.into_iter() {
+                    tips.remove(&height);
+                }
+            }
+            Err(_e) => {
+                error!("FATAL: failed to lock previous_best_tips");
+                panic!();
+            }
+        }
+    }
+
+    /// Get a best-tip at a previous height
+    pub fn get_best_tip(&self, stacks_height: u64) -> Option<TipCandidate> {
+        match self.previous_best_tips.lock() {
+            Ok(tips) => tips.get(&stacks_height).cloned(),
+            Err(_e) => {
+                error!("FATAL: failed to lock previous_best_tips");
+                panic!();
+            }
+        }
     }
 }
diff --git a/testnet/stacks-node/src/main.rs b/testnet/stacks-node/src/main.rs
index 8156e31686..3418ed9726 100644
--- a/testnet/stacks-node/src/main.rs
+++ b/testnet/stacks-node/src/main.rs
@@ -41,6 +41,7 @@ use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::burn::operations::leader_block_commit::RewardSetInfo;
 use stacks::chainstate::coordinator::{get_next_recipients, OnChainRewardSetProvider};
 use stacks::chainstate::stacks::address::PoxAddress;
+use stacks::chainstate::stacks::db::blocks::DummyEventDispatcher;
 use stacks::chainstate::stacks::db::StacksChainState;
 
 pub use self::burnchains::{
@@ -52,11 +53,10 @@ pub use self::keychain::Keychain;
 pub use self::node::{ChainTip, Node};
 pub use self::run_loop::{helium, neon};
 pub use self::tenure::Tenure;
-use crate::mockamoto::MockamotoNode;
-use crate::run_loop::boot_nakamoto;
-
 use crate::chain_data::MinerStats;
+use crate::mockamoto::MockamotoNode;
 use crate::neon_node::{BlockMinerThread, TipCandidate};
+use crate::run_loop::boot_nakamoto;
 
 /// Implmentation of `pick_best_tip` CLI option
 fn cli_pick_best_tip(config_path: &str, at_stacks_height: Option<u64>) -> TipCandidate {
@@ -132,12 +132,13 @@ fn cli_get_miner_spend(
         SortitionDB::get_canonical_burn_chain_tip(sortdb.conn()).unwrap()
     };
 
+    let no_dispatcher: Option<&DummyEventDispatcher> = None;
     let recipients = get_next_recipients(
         &tip,
         &mut chainstate,
         &mut sortdb,
         &burnchain,
-        &OnChainRewardSetProvider(),
+        &OnChainRewardSetProvider(no_dispatcher),
         config.node.always_use_affirmation_maps,
     )
     .unwrap();
@@ -318,7 +319,7 @@ fn main() {
             ConfigFile::mainnet()
         }
         "mockamoto" => {
-            args.finish().unwrap();
+            args.finish();
             ConfigFile::mockamoto()
         }
         "check-config" => {
diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index 84a9efd353..9f11a872ef 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -453,6 +453,7 @@ impl MockamotoNode {
             counters,
             sync_comms,
             should_keep_running,
+            0,
         );
 
         let mut event_dispatcher = EventDispatcher::new();
@@ -954,10 +955,12 @@ impl MockamotoNode {
 
         let state_index_root = clarity_tx.seal();
         let tx_merkle_tree: MerkleTree<Sha512Trunc256Sum> = builder.txs.iter().collect();
-        clarity_tx.commit_mined_block(&StacksBlockId::new(
-            &MINER_BLOCK_CONSENSUS_HASH,
-            &MINER_BLOCK_HEADER_HASH,
-        ));
+        clarity_tx
+            .commit_mined_block(&StacksBlockId::new(
+                &MINER_BLOCK_CONSENSUS_HASH,
+                &MINER_BLOCK_HEADER_HASH,
+            ))
+            .unwrap();
         chainstate_tx.commit().unwrap();
 
         let mut block = NakamotoBlock {
diff --git a/testnet/stacks-node/src/mockamoto/signer.rs b/testnet/stacks-node/src/mockamoto/signer.rs
index 48c4eb57c0..60bf2afbbf 100644
--- a/testnet/stacks-node/src/mockamoto/signer.rs
+++ b/testnet/stacks-node/src/mockamoto/signer.rs
@@ -9,7 +9,7 @@ use wsts::traits::Aggregator;
 ///  signing its own aggregate public key.
 /// This is used in `mockamoto` and `nakamoto-neon` operation
 ///  by the miner in order to self-sign blocks.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct SelfSigner {
     /// The parties that will sign the blocks
     pub signer_parties: Vec<wsts::v2::Party>,
diff --git a/testnet/stacks-node/src/neon_node.rs b/testnet/stacks-node/src/neon_node.rs
index 8e315a6405..3eb117326e 100644
--- a/testnet/stacks-node/src/neon_node.rs
+++ b/testnet/stacks-node/src/neon_node.rs
@@ -167,11 +167,9 @@ use stacks::chainstate::coordinator::{get_next_recipients, OnChainRewardSetProvi
 use stacks::chainstate::nakamoto::NakamotoChainState;
 use stacks::chainstate::stacks::address::PoxAddress;
 use stacks::chainstate::stacks::db::blocks::StagingBlock;
-use stacks::chainstate::stacks::db::unconfirmed::UnconfirmedTxMap;
 use stacks::chainstate::stacks::db::{StacksChainState, StacksHeaderInfo, MINER_REWARD_MATURITY};
 use stacks::chainstate::stacks::miner::{
-    signal_mining_blocked, signal_mining_ready, BlockBuilderSettings, MinerStatus,
-    StacksMicroblockBuilder,
+    signal_mining_blocked, signal_mining_ready, BlockBuilderSettings, StacksMicroblockBuilder,
 };
 use stacks::chainstate::stacks::{
     CoinbasePayload, Error as ChainstateError, StacksBlock, StacksBlockBuilder, StacksBlockHeader,
@@ -211,11 +209,9 @@ use crate::burnchains::bitcoin_regtest_controller::{
     addr2str, BitcoinRegtestController, OngoingBlockCommit,
 };
 use crate::burnchains::make_bitcoin_indexer;
+use crate::chain_data::MinerStats;
 use crate::globals::{NeonGlobals as Globals, RelayerDirective};
 use crate::run_loop::neon::RunLoop;
-use crate::chain_data::MinerStats;
-use crate::config::MinerConfig;
-use crate::run_loop::neon::{Counters, RunLoop};
 use crate::run_loop::RegisteredKey;
 use crate::ChainTip;
 
@@ -2434,7 +2430,8 @@ impl BlockMinerThread {
                 &chain_state,
                 miner_config.unprocessed_block_deadline_secs,
             );
-            if stacks_tip.anchored_header.block_hash() != anchored_block.header.parent_block
+
+            if stacks_tip.anchored_block_hash != anchored_block.header.parent_block
                 || parent_block_info.parent_consensus_hash != stacks_tip.consensus_hash
                 || cur_burn_chain_tip.burn_header_hash != self.burn_block.burn_header_hash
                 || is_miner_blocked
@@ -2453,7 +2450,7 @@ impl BlockMinerThread {
                     "old_tip_burn_block_height" => self.burn_block.block_height,
                     "old_tip_burn_block_sortition_id" => %self.burn_block.sortition_id,
                     "attempt" => attempt,
-                    "new_stacks_tip_block_hash" => %stacks_tip.anchored_header.block_hash(),
+                    "new_stacks_tip_block_hash" => %stacks_tip.anchored_block_hash,
                     "new_stacks_tip_consensus_hash" => %stacks_tip.consensus_hash,
                     "new_tip_burn_block_height" => cur_burn_chain_tip.block_height,
                     "new_tip_burn_block_sortition_id" => %cur_burn_chain_tip.sortition_id,
@@ -4518,21 +4515,12 @@ impl StacksNode {
             stackerdb_configs.keys().cloned().collect();
         for (contract_id, stackerdb_config) in stackerdb_configs {
             let stackerdbs = StackerDBs::connect(&config.get_stacker_db_file_path(), true).unwrap();
-            let stacker_db_sync = match StackerDBSync::new(
+            let stacker_db_sync = StackerDBSync::new(
                 contract_id.clone(),
                 &stackerdb_config,
                 PeerNetworkComms::new(),
                 stackerdbs,
-            ) {
-                Ok(s) => s,
-                Err(e) => {
-                    warn!(
-                        "Failed to instantiate StackerDB sync machine for {contract_id}: {:?}",
-                        &e
-                    );
-                    continue;
-                }
-            };
+            );
             stackerdb_machines.insert(contract_id, (stackerdb_config, stacker_db_sync));
         }
         let peerdb = Self::setup_peer_db(config, &burnchain, &stackerdb_contract_ids);
@@ -4916,14 +4904,18 @@ impl StacksNode {
         let Some(activated_key) = activated_key_opt else {
             return ret;
         };
+
         let Some(path) = config.miner.activated_vrf_key_path.as_ref() else {
             return ret;
         };
+
         info!("Activated VRF key; saving to {}", &path);
+
         let Ok(key_json) = serde_json::to_string(&activated_key) else {
             warn!("Failed to serialize VRF key");
             return ret;
         };
+
         let mut f = match fs::File::create(&path) {
             Ok(f) => f,
             Err(e) => {
diff --git a/testnet/stacks-node/src/run_loop/nakamoto.rs b/testnet/stacks-node/src/run_loop/nakamoto.rs
index d5e57646a0..8483dcb138 100644
--- a/testnet/stacks-node/src/run_loop/nakamoto.rs
+++ b/testnet/stacks-node/src/run_loop/nakamoto.rs
@@ -425,6 +425,7 @@ impl RunLoop {
             self.counters.clone(),
             self.pox_watchdog_comms.clone(),
             self.should_keep_running.clone(),
+            mine_start,
         );
         self.set_globals(globals.clone());
 
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 1bb94f6030..84db7656ed 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -196,7 +196,6 @@ pub fn naka_neon_integration_conf(seed: Option<&[u8]>) -> (Config, StacksAddress
     conf.burnchain.poll_time_secs = 1;
     conf.node.pox_sync_sample_secs = 0;
 
-    conf.miner.min_tx_fee = 1;
     conf.miner.first_attempt_time_ms = i64::max_value() as u64;
     conf.miner.subsequent_attempt_time_ms = i64::max_value() as u64;
 

From 2908565ec5d4108224d81f2f74cf6e1d74adca1d Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Thu, 1 Feb 2024 17:50:29 -0500
Subject: [PATCH 0557/1166] chore: Fix `clippy::iter_with_drain` in `./clarity`
 and `./stacks-common`

---
 clarity/src/vm/analysis/type_checker/v2_05/mod.rs      |  4 ++--
 .../src/vm/analysis/type_checker/v2_05/natives/mod.rs  |  4 ++--
 clarity/src/vm/analysis/type_checker/v2_1/mod.rs       |  4 ++--
 .../src/vm/analysis/type_checker/v2_1/natives/mod.rs   |  4 ++--
 clarity/src/vm/ast/parser/v1.rs                        |  4 ++--
 clarity/src/vm/callables.rs                            |  8 ++++----
 clarity/src/vm/contexts.rs                             | 10 +++++-----
 clarity/src/vm/types/mod.rs                            |  8 ++++----
 clarity/src/vm/types/signatures.rs                     |  4 ++--
 stacks-common/src/address/c32.rs                       |  2 +-
 stacks-common/src/util/chunked_encoding.rs             |  9 ++-------
 11 files changed, 28 insertions(+), 33 deletions(-)

diff --git a/clarity/src/vm/analysis/type_checker/v2_05/mod.rs b/clarity/src/vm/analysis/type_checker/v2_05/mod.rs
index ad80733f80..19eae7b979 100644
--- a/clarity/src/vm/analysis/type_checker/v2_05/mod.rs
+++ b/clarity/src/vm/analysis/type_checker/v2_05/mod.rs
@@ -550,7 +550,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> {
         let function_name = function_name
             .match_atom()
             .ok_or(CheckErrors::BadFunctionName)?;
-        let mut args = parse_name_type_pairs::<()>(StacksEpochId::Epoch2_05, args, &mut ())
+        let args = parse_name_type_pairs::<()>(StacksEpochId::Epoch2_05, args, &mut ())
             .map_err(|_| CheckErrors::BadSyntaxBinding)?;
 
         if self.function_return_tracker.is_some() {
@@ -603,7 +603,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> {
                 self.function_return_tracker = None;
 
                 let func_args: Vec<FunctionArg> = args
-                    .drain(..)
+                    .into_iter()
                     .map(|(arg_name, arg_type)| FunctionArg::new(arg_type, arg_name))
                     .collect();
 
diff --git a/clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs b/clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs
index 67a90ae5a5..637c315183 100644
--- a/clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs
+++ b/clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs
@@ -320,10 +320,10 @@ fn check_special_equals(
 ) -> TypeResult {
     check_arguments_at_least(1, args)?;
 
-    let mut arg_types = checker.type_check_all(args, context)?;
+    let arg_types = checker.type_check_all(args, context)?;
 
     let mut arg_type = arg_types[0].clone();
-    for x_type in arg_types.drain(..) {
+    for x_type in arg_types.into_iter() {
         analysis_typecheck_cost(checker, &x_type, &arg_type)?;
         arg_type = TypeSignature::least_supertype(&StacksEpochId::Epoch2_05, &x_type, &arg_type)
             .map_err(|_| CheckErrors::TypeError(x_type, arg_type))?;
diff --git a/clarity/src/vm/analysis/type_checker/v2_1/mod.rs b/clarity/src/vm/analysis/type_checker/v2_1/mod.rs
index 1686c5c2a2..f7e48d87d9 100644
--- a/clarity/src/vm/analysis/type_checker/v2_1/mod.rs
+++ b/clarity/src/vm/analysis/type_checker/v2_1/mod.rs
@@ -1059,7 +1059,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> {
         let function_name = function_name
             .match_atom()
             .ok_or(CheckErrors::BadFunctionName)?;
-        let mut args = parse_name_type_pairs::<()>(StacksEpochId::Epoch21, args, &mut ())
+        let args = parse_name_type_pairs::<()>(StacksEpochId::Epoch21, args, &mut ())
             .map_err(|_| CheckErrors::BadSyntaxBinding)?;
 
         if self.function_return_tracker.is_some() {
@@ -1113,7 +1113,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> {
                 self.function_return_tracker = None;
 
                 let func_args: Vec<FunctionArg> = args
-                    .drain(..)
+                    .into_iter()
                     .map(|(arg_name, arg_type)| FunctionArg::new(arg_type, arg_name))
                     .collect();
 
diff --git a/clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs b/clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs
index 55401f1817..2f2062b42e 100644
--- a/clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs
+++ b/clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs
@@ -325,10 +325,10 @@ fn check_special_equals(
 ) -> TypeResult {
     check_arguments_at_least(1, args)?;
 
-    let mut arg_types = checker.type_check_all(args, context)?;
+    let arg_types = checker.type_check_all(args, context)?;
 
     let mut arg_type = arg_types[0].clone();
-    for x_type in arg_types.drain(..) {
+    for x_type in arg_types.into_iter() {
         analysis_typecheck_cost(checker, &x_type, &arg_type)?;
         arg_type = TypeSignature::least_supertype(&StacksEpochId::Epoch21, &x_type, &arg_type)
             .map_err(|_| CheckErrors::TypeError(x_type, arg_type))?;
diff --git a/clarity/src/vm/ast/parser/v1.rs b/clarity/src/vm/ast/parser/v1.rs
index b6d3aaf24e..9f3bd21855 100644
--- a/clarity/src/vm/ast/parser/v1.rs
+++ b/clarity/src/vm/ast/parser/v1.rs
@@ -506,12 +506,12 @@ fn handle_expression(
     }
 }
 
-pub fn parse_lexed(mut input: Vec<(LexItem, u32, u32)>) -> ParseResult<Vec<PreSymbolicExpression>> {
+pub fn parse_lexed(input: Vec<(LexItem, u32, u32)>) -> ParseResult<Vec<PreSymbolicExpression>> {
     let mut parse_stack = Vec::new();
 
     let mut output_list = Vec::new();
 
-    for (item, line_pos, column_pos) in input.drain(..) {
+    for (item, line_pos, column_pos) in input.into_iter() {
         match item {
             LexItem::LeftParen => {
                 // start new list.
diff --git a/clarity/src/vm/callables.rs b/clarity/src/vm/callables.rs
index c589e4b397..99ff3a1987 100644
--- a/clarity/src/vm/callables.rs
+++ b/clarity/src/vm/callables.rs
@@ -123,13 +123,13 @@ impl fmt::Display for FunctionIdentifier {
 
 impl DefinedFunction {
     pub fn new(
-        mut arguments: Vec<(ClarityName, TypeSignature)>,
+        arguments: Vec<(ClarityName, TypeSignature)>,
         body: SymbolicExpression,
         define_type: DefineType,
         name: &ClarityName,
         context_name: &str,
     ) -> DefinedFunction {
-        let (argument_names, types) = arguments.drain(..).unzip();
+        let (argument_names, types) = arguments.into_iter().unzip();
 
         DefinedFunction {
             identifier: FunctionIdentifier::new_user_function(name, context_name),
@@ -164,14 +164,14 @@ impl DefinedFunction {
             ))?
         }
 
-        let mut arg_iterator: Vec<_> = self
+        let arg_iterator: Vec<_> = self
             .arguments
             .iter()
             .zip(self.arg_types.iter())
             .zip(args.iter())
             .collect();
 
-        for arg in arg_iterator.drain(..) {
+        for arg in arg_iterator.into_iter() {
             let ((name, type_sig), value) = arg;
 
             // Clarity 1 behavior
diff --git a/clarity/src/vm/contexts.rs b/clarity/src/vm/contexts.rs
index 90d916b73d..61f9912253 100644
--- a/clarity/src/vm/contexts.rs
+++ b/clarity/src/vm/contexts.rs
@@ -349,8 +349,8 @@ impl AssetMap {
     //   aborting _all_ changes in the event of an error, leaving self unchanged
     pub fn commit_other(&mut self, mut other: AssetMap) -> Result<()> {
         let mut to_add = Vec::new();
-        let mut stx_to_add = Vec::new();
-        let mut stx_burn_to_add = Vec::new();
+        let mut stx_to_add = Vec::with_capacity(other.stx_map.len());
+        let mut stx_burn_to_add = Vec::with_capacity(other.burn_map.len());
 
         for (principal, mut principal_map) in other.token_map.drain() {
             for (asset, amount) in principal_map.drain() {
@@ -386,15 +386,15 @@ impl AssetMap {
             }
         }
 
-        for (principal, stx_amount) in stx_to_add.drain(..) {
+        for (principal, stx_amount) in stx_to_add.into_iter() {
             self.stx_map.insert(principal, stx_amount);
         }
 
-        for (principal, stx_burn_amount) in stx_burn_to_add.drain(..) {
+        for (principal, stx_burn_amount) in stx_burn_to_add.into_iter() {
             self.burn_map.insert(principal, stx_burn_amount);
         }
 
-        for (principal, asset, amount) in to_add.drain(..) {
+        for (principal, asset, amount) in to_add.into_iter() {
             if !self.token_map.contains_key(&principal) {
                 self.token_map.insert(principal.clone(), HashMap::new());
             }
diff --git a/clarity/src/vm/types/mod.rs b/clarity/src/vm/types/mod.rs
index 5aa298a139..ebac5d9323 100644
--- a/clarity/src/vm/types/mod.rs
+++ b/clarity/src/vm/types/mod.rs
@@ -1484,10 +1484,10 @@ impl TupleData {
         self.data_map.is_empty()
     }
 
-    pub fn from_data(mut data: Vec<(ClarityName, Value)>) -> Result<TupleData> {
+    pub fn from_data(data: Vec<(ClarityName, Value)>) -> Result<TupleData> {
         let mut type_map = BTreeMap::new();
         let mut data_map = BTreeMap::new();
-        for (name, value) in data.drain(..) {
+        for (name, value) in data.into_iter() {
             let type_info = TypeSignature::type_of(&value);
             if type_map.contains_key(&name) {
                 return Err(CheckErrors::NameAlreadyUsed(name.into()).into());
@@ -1502,11 +1502,11 @@ impl TupleData {
 
     pub fn from_data_typed(
         epoch: &StacksEpochId,
-        mut data: Vec<(ClarityName, Value)>,
+        data: Vec<(ClarityName, Value)>,
         expected: &TupleTypeSignature,
     ) -> Result<TupleData> {
         let mut data_map = BTreeMap::new();
-        for (name, value) in data.drain(..) {
+        for (name, value) in data.into_iter() {
             let expected_type = expected
                 .field_type(&name)
                 .ok_or(InterpreterError::FailureConstructingTupleWithType)?;
diff --git a/clarity/src/vm/types/signatures.rs b/clarity/src/vm/types/signatures.rs
index 5c010c1db5..caf75f3cc4 100644
--- a/clarity/src/vm/types/signatures.rs
+++ b/clarity/src/vm/types/signatures.rs
@@ -810,13 +810,13 @@ impl TypeSignature {
 
 impl TryFrom<Vec<(ClarityName, TypeSignature)>> for TupleTypeSignature {
     type Error = CheckErrors;
-    fn try_from(mut type_data: Vec<(ClarityName, TypeSignature)>) -> Result<TupleTypeSignature> {
+    fn try_from(type_data: Vec<(ClarityName, TypeSignature)>) -> Result<TupleTypeSignature> {
         if type_data.is_empty() {
             return Err(CheckErrors::EmptyTuplesNotAllowed);
         }
 
         let mut type_map = BTreeMap::new();
-        for (name, type_info) in type_data.drain(..) {
+        for (name, type_info) in type_data.into_iter() {
             if let Entry::Vacant(e) = type_map.entry(name.clone()) {
                 e.insert(type_info);
             } else {
diff --git a/stacks-common/src/address/c32.rs b/stacks-common/src/address/c32.rs
index 60fa7e6552..2f3a0925d7 100644
--- a/stacks-common/src/address/c32.rs
+++ b/stacks-common/src/address/c32.rs
@@ -221,7 +221,7 @@ fn c32_encode(input_bytes: &[u8]) -> String {
         }
     }
 
-    let result: Vec<u8> = result.drain(..).rev().collect();
+    let result: Vec<u8> = result.into_iter().rev().collect();
     String::from_utf8(result).unwrap()
 }
 
diff --git a/stacks-common/src/util/chunked_encoding.rs b/stacks-common/src/util/chunked_encoding.rs
index bb1b869eee..235a9d14e8 100644
--- a/stacks-common/src/util/chunked_encoding.rs
+++ b/stacks-common/src/util/chunked_encoding.rs
@@ -498,13 +498,8 @@ mod test {
         }
     }
 
-    fn vec_u8(mut v: Vec<&str>) -> Vec<Vec<u8>> {
-        let mut ret = vec![];
-        for s_vec in v.drain(..) {
-            let v_u8 = s_vec.as_bytes().to_vec();
-            ret.push(v_u8);
-        }
-        ret
+    fn vec_u8(v: Vec<&str>) -> Vec<Vec<u8>> {
+        v.into_iter().map(|s| s.as_bytes().to_vec()).collect()
     }
 
     #[test]

From 3555f720ed3becffe5be48fcafda665ff4f89da0 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Thu, 1 Feb 2024 17:56:32 -0500
Subject: [PATCH 0558/1166] chore: Fix `clippy::single_char_add_str`

---
 stackslib/src/blockstack_cli.rs                | 10 +++++-----
 .../src/clarity_vm/tests/large_contract.rs     | 18 +++++++++---------
 testnet/stacks-node/src/tests/integrations.rs  |  6 +++---
 .../stacks-node/src/tests/neon_integrations.rs | 10 +++++-----
 4 files changed, 22 insertions(+), 22 deletions(-)

diff --git a/stackslib/src/blockstack_cli.rs b/stackslib/src/blockstack_cli.rs
index a636b6343e..f82e760ad0 100644
--- a/stackslib/src/blockstack_cli.rs
+++ b/stackslib/src/blockstack_cli.rs
@@ -672,7 +672,7 @@ fn decode_transaction(args: &[String], _version: TransactionVersion) -> Result<S
             for buf in debug_cursor.log().iter() {
                 ret.push_str(&format!("   {}", to_hex(buf)));
             }
-            ret.push_str("\n");
+            ret.push('\n');
             Ok(ret)
         }
     }
@@ -711,7 +711,7 @@ fn decode_header(args: &[String], _version: TransactionVersion) -> Result<String
             for buf in debug_cursor.log().iter() {
                 ret.push_str(&format!("   {}", to_hex(buf)));
             }
-            ret.push_str("\n");
+            ret.push('\n');
             Ok(ret)
         }
     }
@@ -748,7 +748,7 @@ fn decode_block(args: &[String], _version: TransactionVersion) -> Result<String,
             for buf in debug_cursor.log().iter() {
                 ret.push_str(&format!("   {}", to_hex(buf)));
             }
-            ret.push_str("\n");
+            ret.push('\n');
             Ok(ret)
         }
     }
@@ -787,7 +787,7 @@ fn decode_microblock(args: &[String], _version: TransactionVersion) -> Result<St
             for buf in debug_cursor.log().iter() {
                 ret.push_str(&format!("   {}", to_hex(buf)));
             }
-            ret.push_str("\n");
+            ret.push('\n');
             Ok(ret)
         }
     }
@@ -826,7 +826,7 @@ fn decode_microblocks(args: &[String], _version: TransactionVersion) -> Result<S
             for buf in debug_cursor.log().iter() {
                 ret.push_str(&format!("   {}\n", to_hex(buf)));
             }
-            ret.push_str("\n");
+            ret.push('\n');
             Ok(ret)
         }
     }
diff --git a/stackslib/src/clarity_vm/tests/large_contract.rs b/stackslib/src/clarity_vm/tests/large_contract.rs
index db1f2ea08d..4a31666ccd 100644
--- a/stackslib/src/clarity_vm/tests/large_contract.rs
+++ b/stackslib/src/clarity_vm/tests/large_contract.rs
@@ -688,7 +688,7 @@ pub fn rollback_log_memory_test(
         let mut contract = define_data_var.to_string();
         for i in 0..20 {
             let cur_size = format!("{}", 2u32.pow(i));
-            contract.push_str("\n");
+            contract.push('\n');
             contract.push_str(&format!(
                 "(var-set XZ (concat (unwrap-panic (as-max-len? (var-get XZ) u{}))
                                              (unwrap-panic (as-max-len? (var-get XZ) u{}))))",
@@ -697,7 +697,7 @@ pub fn rollback_log_memory_test(
         }
         for i in 0..EXPLODE_N {
             let exploder = format!("(define-data-var var-{} (buff 1048576) (var-get XZ))", i);
-            contract.push_str("\n");
+            contract.push('\n');
             contract.push_str(&exploder);
         }
 
@@ -757,7 +757,7 @@ pub fn let_memory_test(#[case] clarity_version: ClarityVersion, #[case] epoch_id
 
         let mut contract = define_data_var.to_string();
         for i in 0..20 {
-            contract.push_str("\n");
+            contract.push('\n');
             contract.push_str(&format!(
                 "(define-constant buff-{} (concat buff-{} buff-{}))",
                 i + 1,
@@ -766,7 +766,7 @@ pub fn let_memory_test(#[case] clarity_version: ClarityVersion, #[case] epoch_id
             ));
         }
 
-        contract.push_str("\n");
+        contract.push('\n');
         contract.push_str("(let (");
 
         for i in 0..EXPLODE_N {
@@ -835,7 +835,7 @@ pub fn argument_memory_test(
 
         let mut contract = define_data_var.to_string();
         for i in 0..20 {
-            contract.push_str("\n");
+            contract.push('\n');
             contract.push_str(&format!(
                 "(define-constant buff-{} (concat buff-{} buff-{}))",
                 i + 1,
@@ -844,7 +844,7 @@ pub fn argument_memory_test(
             ));
         }
 
-        contract.push_str("\n");
+        contract.push('\n');
         contract.push_str("(is-eq ");
 
         for _i in 0..EXPLODE_N {
@@ -852,7 +852,7 @@ pub fn argument_memory_test(
             contract.push_str(exploder);
         }
 
-        contract.push_str(")");
+        contract.push(')');
 
         conn.as_transaction(|conn| {
             let (ct_ast, _ct_analysis) = conn
@@ -911,7 +911,7 @@ pub fn fcall_memory_test(#[case] clarity_version: ClarityVersion, #[case] epoch_
 
         let mut contract = define_data_var.to_string();
         for i in 0..20 {
-            contract.push_str("\n");
+            contract.push('\n');
             contract.push_str(&format!(
                 "(define-constant buff-{} (concat buff-{} buff-{}))",
                 i + 1,
@@ -920,7 +920,7 @@ pub fn fcall_memory_test(#[case] clarity_version: ClarityVersion, #[case] epoch_
             ));
         }
 
-        contract.push_str("\n");
+        contract.push('\n');
 
         for i in 0..FUNCS {
             contract.push_str(&format!("(define-private (call-{})\n", i));
diff --git a/testnet/stacks-node/src/tests/integrations.rs b/testnet/stacks-node/src/tests/integrations.rs
index 16e6897196..a4ee8af95e 100644
--- a/testnet/stacks-node/src/tests/integrations.rs
+++ b/testnet/stacks-node/src/tests/integrations.rs
@@ -1855,7 +1855,7 @@ fn make_expensive_contract(inner_loop: &str, other_decl: &str) -> String {
     let mut contract = "(define-constant list-0 (list 0))".to_string();
 
     for i in 0..10 {
-        contract.push_str("\n");
+        contract.push('\n');
         contract.push_str(&format!(
             "(define-constant list-{} (concat list-{} list-{}))",
             i + 1,
@@ -1864,9 +1864,9 @@ fn make_expensive_contract(inner_loop: &str, other_decl: &str) -> String {
         ));
     }
 
-    contract.push_str("\n");
+    contract.push('\n');
     contract.push_str(other_decl);
-    contract.push_str("\n");
+    contract.push('\n');
     contract.push_str(inner_loop);
 
     write!(
diff --git a/testnet/stacks-node/src/tests/neon_integrations.rs b/testnet/stacks-node/src/tests/neon_integrations.rs
index fccfeac3f1..8b9f87e38f 100644
--- a/testnet/stacks-node/src/tests/neon_integrations.rs
+++ b/testnet/stacks-node/src/tests/neon_integrations.rs
@@ -3571,7 +3571,7 @@ fn size_check_integration_test() {
 
     let mut giant_contract = "(define-public (f) (ok 1))".to_string();
     for _i in 0..(1024 * 1024 + 500) {
-        giant_contract.push_str(" ");
+        giant_contract.push(' ');
     }
 
     let spender_sks: Vec<_> = (0..10)
@@ -3734,13 +3734,13 @@ fn size_overflow_unconfirmed_microblocks_integration_test() {
     // stuff a gigantic contract into the anchored block
     let mut giant_contract = "(define-public (f) (ok 1))".to_string();
     for _i in 0..(1024 * 1024 + 500) {
-        giant_contract.push_str(" ");
+        giant_contract.push(' ');
     }
 
     // small-sized contracts for microblocks
     let mut small_contract = "(define-public (f) (ok 1))".to_string();
     for _i in 0..(1024 * 1024 + 500) {
-        small_contract.push_str(" ");
+        small_contract.push(' ');
     }
 
     let spender_sks: Vec<_> = (0..5)
@@ -3951,7 +3951,7 @@ fn size_overflow_unconfirmed_stream_microblocks_integration_test() {
 
     let mut small_contract = "(define-public (f) (ok 1))".to_string();
     for _i in 0..((1024 * 1024 + 500) / 3) {
-        small_contract.push_str(" ");
+        small_contract.push(' ');
     }
 
     let spender_sks: Vec<_> = (0..20)
@@ -4142,7 +4142,7 @@ fn size_overflow_unconfirmed_invalid_stream_microblocks_integration_test() {
 
     let mut small_contract = "(define-public (f) (ok 1))".to_string();
     for _i in 0..((1024 * 1024 + 500) / 8) {
-        small_contract.push_str(" ");
+        small_contract.push(' ');
     }
 
     let spender_sks: Vec<_> = (0..25)

From d404e5f793be011d3d3473271717a4653c5e0853 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Thu, 1 Feb 2024 18:10:39 -0500
Subject: [PATCH 0559/1166] fix: compiler errors from merge

---
 stackslib/src/main.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/stackslib/src/main.rs b/stackslib/src/main.rs
index 4b70487260..bd060579c6 100644
--- a/stackslib/src/main.rs
+++ b/stackslib/src/main.rs
@@ -70,6 +70,7 @@ use libstackerdb::StackerDBChunkData;
 use rusqlite::types::ToSql;
 use rusqlite::{Connection, OpenFlags};
 use serde_json::{json, Value};
+use stacks_common::codec::{read_next, StacksMessageCodec};
 use stacks_common::types::chainstate::{
     BlockHeaderHash, BurnchainHeaderHash, PoxId, StacksAddress, StacksBlockId,
 };

From 0066cea58645fe416ad6a81c16b7533bfb38887d Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Thu, 1 Feb 2024 23:37:06 -0500
Subject: [PATCH 0560/1166] fix: fix more merge errors

---
 .../chainstate/nakamoto/coordinator/tests.rs  |  6 ++--
 .../src/chainstate/nakamoto/tests/node.rs     |  2 +-
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 29 ++++++++++++++-----
 .../chainstate/stacks/boot/signers_tests.rs   | 16 +++++++---
 stackslib/src/net/mod.rs                      |  9 ++----
 5 files changed, 41 insertions(+), 21 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index 055fd05210..1c81c08276 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -1105,7 +1105,8 @@ fn test_simple_nakamoto_coordinator_10_tenures_10_blocks() {
 
         let stx_balance = clarity_instance
             .read_only_connection(&block_id, &chainstate_tx, &sort_db_tx)
-            .with_clarity_db_readonly(|db| db.get_account_stx_balance(&miner.clone().into()));
+            .with_clarity_db_readonly(|db| db.get_account_stx_balance(&miner.clone().into()))
+            .unwrap();
 
         // only count matured rewards (last 3 blocks are not mature)
         let block_fee = if i > 3 {
@@ -1788,7 +1789,8 @@ fn test_simple_nakamoto_coordinator_10_tenures_and_extensions_10_blocks() {
 
         let stx_balance = clarity_instance
             .read_only_connection(&block_id, &chainstate_tx, &sort_db_tx)
-            .with_clarity_db_readonly(|db| db.get_account_stx_balance(&miner.clone().into()));
+            .with_clarity_db_readonly(|db| db.get_account_stx_balance(&miner.clone().into()))
+            .unwrap();
 
         // it's 1 * 10 because it's 1 uSTX per token-transfer, and 10 per tenure
         let expected_total_tx_fees = 1 * 10 * (i as u128).saturating_sub(3);
diff --git a/stackslib/src/chainstate/nakamoto/tests/node.rs b/stackslib/src/chainstate/nakamoto/tests/node.rs
index ac71cf6721..030a437c4b 100644
--- a/stackslib/src/chainstate/nakamoto/tests/node.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/node.rs
@@ -731,7 +731,7 @@ impl TestStacksNode {
         }
         let block = builder.mine_nakamoto_block(&mut tenure_tx);
         let size = builder.bytes_so_far;
-        let cost = builder.tenure_finish(tenure_tx);
+        let cost = builder.tenure_finish(tenure_tx).unwrap();
         Ok((block, size, cost))
     }
 }
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index c92520a57c..d912620659 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -746,14 +746,17 @@ fn get_burn_pox_addr_info(peer: &mut TestPeer) -> (Vec<PoxAddress>, u128) {
     })
     .unwrap()
     .expect_optional()
-    .expect("FATAL: expected list")
-    .expect_tuple();
+    .unwrap()
+    .unwrap()
+    .expect_tuple()
+    .unwrap();
 
     let addrs = addrs_and_payout
         .get("addrs")
         .unwrap()
         .to_owned()
         .expect_list()
+        .unwrap()
         .into_iter()
         .map(|tuple| PoxAddress::try_from_pox_tuple(false, &tuple).unwrap())
         .collect();
@@ -762,7 +765,8 @@ fn get_burn_pox_addr_info(peer: &mut TestPeer) -> (Vec<PoxAddress>, u128) {
         .get("payout")
         .unwrap()
         .to_owned()
-        .expect_u128();
+        .expect_u128()
+        .unwrap();
     (addrs, payout)
 }
 
@@ -1016,7 +1020,13 @@ fn pox_3_defunct() {
 
     assert_eq!(receipts.len(), txs.len());
     for r in receipts.iter() {
-        let err = r.result.clone().expect_result_err().expect_optional();
+        let err = r
+            .result
+            .clone()
+            .expect_result_err()
+            .unwrap()
+            .expect_optional()
+            .unwrap();
         assert!(err.is_none());
     }
 
@@ -2104,7 +2114,7 @@ pub fn get_stacking_state_pox_4(
         let lookup_tuple = Value::Tuple(
             TupleData::from_data(vec![("stacker".into(), account.clone().into())]).unwrap(),
         );
-        let epoch = db.get_clarity_epoch_version();
+        let epoch = db.get_clarity_epoch_version().unwrap();
         db.fetch_entry_unknown_descriptor(
             &boot_code_id(boot::POX_4_NAME, false),
             "stacking-state",
@@ -2113,6 +2123,7 @@ pub fn get_stacking_state_pox_4(
         )
         .unwrap()
         .expect_optional()
+        .unwrap()
     })
 }
 
@@ -2134,7 +2145,7 @@ pub fn get_partially_stacked_state_pox_4(
         ])
         .unwrap()
         .into();
-        let epoch = db.get_clarity_epoch_version();
+        let epoch = db.get_clarity_epoch_version().unwrap();
         db.fetch_entry_unknown_descriptor(
             &boot_code_id(boot::POX_4_NAME, false),
             "partial-stacked-by-cycle",
@@ -2143,11 +2154,14 @@ pub fn get_partially_stacked_state_pox_4(
         )
         .unwrap()
         .expect_optional()
+        .unwrap()
         .map(|v| {
             v.expect_tuple()
+                .unwrap()
                 .get_owned("stacked-amount")
                 .unwrap()
                 .expect_u128()
+                .unwrap()
         })
     })
 }
@@ -2161,7 +2175,7 @@ pub fn get_delegation_state_pox_4(
         let lookup_tuple = Value::Tuple(
             TupleData::from_data(vec![("stacker".into(), account.clone().into())]).unwrap(),
         );
-        let epoch = db.get_clarity_epoch_version();
+        let epoch = db.get_clarity_epoch_version().unwrap();
         db.fetch_entry_unknown_descriptor(
             &boot_code_id(boot::POX_4_NAME, false),
             "delegation-state",
@@ -2170,6 +2184,7 @@ pub fn get_delegation_state_pox_4(
         )
         .unwrap()
         .expect_optional()
+        .unwrap()
     })
 }
 
diff --git a/stackslib/src/chainstate/stacks/boot/signers_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_tests.rs
index bcd47d4177..004e437dfb 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_tests.rs
@@ -240,7 +240,8 @@ fn signers_get_signer_keys_from_stackerdb() {
         "stackerdb-get-signer-slots".into(),
         vec![],
     )
-    .expect_result_ok();
+    .expect_result_ok()
+    .unwrap();
 
     assert_eq!(signers, expected_stackerdb_slots);
 }
@@ -290,7 +291,8 @@ pub fn prepare_signers_test<'a>(
         "current-reward-cycle".into(),
         vec![],
     )
-    .expect_u128();
+    .expect_u128()
+    .unwrap();
 
     assert_eq!(current_reward_cycle, 7);
 
@@ -302,7 +304,9 @@ pub fn prepare_signers_test<'a>(
         vec![],
     )
     .expect_result_ok()
-    .expect_u128();
+    .unwrap()
+    .expect_u128()
+    .unwrap();
 
     assert_eq!(last_set_cycle, 7);
 
@@ -406,7 +410,9 @@ pub fn get_signer_index(
         vec![],
     )
     .expect_result_ok()
-    .expect_list();
+    .unwrap()
+    .expect_list()
+    .unwrap();
 
     signers
         .iter()
@@ -414,10 +420,12 @@ pub fn get_signer_index(
             value
                 .clone()
                 .expect_tuple()
+                .unwrap()
                 .get("signer")
                 .unwrap()
                 .clone()
                 .expect_principal()
+                .unwrap()
                 == signer_address.to_account_principal()
         })
         .expect("signer not found") as u128
diff --git a/stackslib/src/net/mod.rs b/stackslib/src/net/mod.rs
index 6e4932ea96..5214acc4ce 100644
--- a/stackslib/src/net/mod.rs
+++ b/stackslib/src/net/mod.rs
@@ -2445,13 +2445,8 @@ pub mod test {
             let stacker_db_syncs =
                 Self::init_stackerdb_syncs(&test_path, &peerdb, &mut stackerdb_configs);
 
-            let stacker_dbs = Self::init_stacker_dbs(
-                &test_path,
-                &peerdb,
-                &config.stacker_dbs,
-                &config.stacker_db_configs,
-            );
-            let stackerdb_contracts: Vec<_> = stacker_dbs.keys().map(|cid| cid.clone()).collect();
+            let stackerdb_contracts: Vec<_> =
+                stacker_db_syncs.keys().map(|cid| cid.clone()).collect();
 
             let mut peer_network = PeerNetwork::new(
                 peerdb,

From 74648edb13d96918501460fdefeeb7da0e43215e Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Thu, 1 Feb 2024 23:46:43 -0500
Subject: [PATCH 0561/1166] docs: describe loop invariants

---
 stackslib/src/net/inv/nakamoto.rs | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/stackslib/src/net/inv/nakamoto.rs b/stackslib/src/net/inv/nakamoto.rs
index 1db73c722a..cb31d4faba 100644
--- a/stackslib/src/net/inv/nakamoto.rs
+++ b/stackslib/src/net/inv/nakamoto.rs
@@ -153,6 +153,28 @@ impl InvGenerator {
 
         let mut cur_tenure_opt = self.get_processed_tenure(chainstate, &cur_consensus_hash)?;
 
+        // loop variables and invariants:
+        //
+        // * `cur_height` is a "cursor" that gets used to populate the bitmap. It corresponds
+        // to a burnchain block height (since inventory bitvectors correspond to sortitions).
+        // It gets decremented once per loop pass.  The loop terminates once the reward cycle
+        // for `cur_height` is less than the given `reward_cycle`.
+        //
+        // * `cur_consensus_hash` refers to the consensus hash of the sortition at `cur_height`. It
+        // is updated once per loop pass.
+        //
+        // * `tenure_status` is the bit vector itself.  On each pass of this loop, `true` or
+        // `false` is pushed to it.  When the loop exits, `tenure_status` will have a `true` or
+        // `false` value for each sortition in the given reward cycle.
+        //
+        // `cur_tenure_opt` refers to the tenure that is active as of `cur_height`, if there is one.
+        // If there is an active tenure in `cur_height`, then if the sortition at `cur_height`
+        // matches the `tenure_id_consensus_hash` of `cur_tenure_opt`, `cur_tenure_opt` is
+        // set to its parent tenure, and we push `true` to `tenure_status`.  This is the only
+        // time we do this, since since `cur_tenure_opt`'s `tenure_id_consensus_hash` only
+        // ever matches `cur_consensus_hash` if a tenure began at `cur_height`.  If a tenure did _not_
+        // begin at `cur_height`, or if there is no active tenure at `cur_height`, then `tenure_status`.
+        // will have `false` for `cur_height`'s bit.
         loop {
             let cur_reward_cycle = sortdb
                 .pox_constants

From 5c14a440d26c012a0df59f1de0ede7b7a0ea76cd Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Thu, 1 Feb 2024 13:03:52 -0800
Subject: [PATCH 0562/1166] fix: incorrect arg index in synthetic event

---
 pox-locking/src/events.rs | 35 ++++++++++++++++++++++++++++++-----
 1 file changed, 30 insertions(+), 5 deletions(-)

diff --git a/pox-locking/src/events.rs b/pox-locking/src/events.rs
index cc727f2cae..769cbc7e11 100644
--- a/pox-locking/src/events.rs
+++ b/pox-locking/src/events.rs
@@ -137,7 +137,7 @@ fn create_event_info_data_code(
                 lock_period = &args[3],
                 pox_addr = &args[1],
                 start_burn_height = &args[2],
-                signer_key = &args.get(3).map_or("none".to_string(), |v| v.to_string()),
+                signer_key = &args.get(4).unwrap_or(&Value::none()),
             )
         }
         "delegate-stack-stx" => {
@@ -295,9 +295,7 @@ fn create_event_info_data_code(
                 extend_count = &args[2]
             )
         }
-        "stack-aggregation-commit"
-        | "stack-aggregation-commit-indexed"
-        | "stack-aggregation-increase" => {
+        "stack-aggregation-commit" | "stack-aggregation-commit-indexed" => {
             format!(
                 r#"
                 {{
@@ -321,7 +319,34 @@ fn create_event_info_data_code(
                 "#,
                 pox_addr = &args[0],
                 reward_cycle = &args[1],
-                signer_key = &args.get(2).map_or("none".to_string(), |v| v.to_string()),
+                signer_key = &args.get(2).unwrap_or(&Value::none()),
+            )
+        }
+        "stack-aggregation-increase" => {
+            format!(
+                r#"
+                {{
+                    data: {{
+                        ;; pox addr locked up
+                        ;; equal to args[0] in all methods
+                        pox-addr: {pox_addr},
+                        ;; reward cycle locked up
+                        ;; equal to args[1] in all methods
+                        reward-cycle: {reward_cycle},
+                        ;; amount locked behind this PoX address by this method
+                        amount-ustx: (get stacked-amount
+                                        (unwrap-panic (map-get? logged-partial-stacked-by-cycle
+                                            {{ pox-addr: {pox_addr}, sender: tx-sender, reward-cycle: {reward_cycle} }}))),
+                        ;; delegator (this is the caller)
+                        delegator: tx-sender,
+                        ;; equal to args[2]
+                        reward-cycle-index: {reward_cycle_index}
+                    }}
+                }}
+                "#,
+                pox_addr = &args[0],
+                reward_cycle = &args[1],
+                reward_cycle_index = &args.get(2).unwrap_or(&Value::none()),
             )
         }
         "delegate-stx" => {

From ec8ed12db4b8d030690648d548725326f6b099b3 Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Thu, 1 Feb 2024 10:38:24 -0500
Subject: [PATCH 0563/1166] updated print statement

---
 stackslib/src/chainstate/stacks/boot/signers-voting.clar | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers-voting.clar b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
index d193386128..73eb32799d 100644
--- a/stackslib/src/chainstate/stacks/boot/signers-voting.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
@@ -96,7 +96,7 @@
         (map-set tally tally-key new-total)
         (map-set used-aggregate-public-keys key {reward-cycle: reward-cycle, round: round})
         (update-last-round reward-cycle round)
-        (print "voted")
+        (print new-total)
         (ok true)))
 
 (define-private (update-last-round (reward-cycle uint) (round uint))

From 1dd68d127e80d38107aa7d5c46e5815937f2d8de Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Thu, 1 Feb 2024 11:36:22 -0500
Subject: [PATCH 0564/1166] updated print w/ more items

---
 stackslib/src/chainstate/stacks/boot/signers-voting.clar | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers-voting.clar b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
index 73eb32799d..2fabd86f60 100644
--- a/stackslib/src/chainstate/stacks/boot/signers-voting.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
@@ -96,7 +96,13 @@
         (map-set tally tally-key new-total)
         (map-set used-aggregate-public-keys key {reward-cycle: reward-cycle, round: round})
         (update-last-round reward-cycle round)
-        (print new-total)
+        (print { 
+            event: "voted", 
+            signer: tx-sender, 
+            reward-cycle: reward-cycle, 
+            round: round, 
+            key: key 
+            new-total: new-total })
         (ok true)))
 
 (define-private (update-last-round (reward-cycle uint) (round uint))

From cb19a6f54d5128e76cd422819ed3935fd2b8ca63 Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Thu, 1 Feb 2024 11:43:45 -0500
Subject: [PATCH 0565/1166] forgot formatting

---
 stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
index f31ced3e06..d7ac4912ac 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
@@ -76,7 +76,8 @@ use crate::chainstate::stacks::events::{StacksTransactionReceipt, TransactionOri
 use crate::chainstate::stacks::index::marf::MarfConnection;
 use crate::chainstate::stacks::index::MarfTrieId;
 use crate::chainstate::stacks::tests::make_coinbase;
-use crate::chainstate::{self, stacks::*};
+use crate::chainstate::stacks::*;
+use crate::chainstate::{self};
 use crate::clarity_vm::clarity::{ClarityBlockConnection, Error as ClarityError};
 use crate::clarity_vm::database::marf::{MarfedKV, WritableMarfStore};
 use crate::clarity_vm::database::HeadersDBConn;

From 339829fcb86d7b4b56d1ac0d90ac5343761ab6b3 Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Thu, 1 Feb 2024 12:41:41 -0500
Subject: [PATCH 0566/1166] missing comma

---
 stackslib/src/chainstate/stacks/boot/signers-voting.clar | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers-voting.clar b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
index 2fabd86f60..eef0ab52d7 100644
--- a/stackslib/src/chainstate/stacks/boot/signers-voting.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
@@ -101,7 +101,7 @@
             signer: tx-sender, 
             reward-cycle: reward-cycle, 
             round: round, 
-            key: key 
+            key: key, 
             new-total: new-total })
         (ok true)))
 

From c9376e43332d53dab94cb51e13e910e2738ad04e Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Fri, 2 Feb 2024 10:35:09 -0500
Subject: [PATCH 0567/1166] chore: log headers on failure to decode http
 resposne

---
 libsigner/src/http.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/libsigner/src/http.rs b/libsigner/src/http.rs
index 8926a3c4ef..78ae50a2b5 100644
--- a/libsigner/src/http.rs
+++ b/libsigner/src/http.rs
@@ -260,6 +260,7 @@ pub fn run_http_request<S: Read + Write>(
     if body_offset >= buf.len() {
         // no body
         debug!("No HTTP body");
+        debug!("Headers: {:?}", &headers);
         return Ok(vec![]);
     }
 

From a0e633a9245eba540db945c20008974e43e665a0 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Fri, 2 Feb 2024 12:08:04 -0500
Subject: [PATCH 0568/1166] chore: Fix `clippy::perf` warnings introduced by
 merge

---
 clarity/src/vm/docs/contracts.rs           |  4 ++--
 libsigner/src/tests/http.rs                |  2 +-
 stackslib/src/blockstack_cli.rs            |  2 +-
 testnet/stacks-node/src/chain_data.rs      |  4 ++--
 testnet/stacks-node/src/config.rs          |  6 +++---
 testnet/stacks-node/src/keychain.rs        |  4 ++--
 testnet/stacks-node/src/mockamoto/tests.rs |  7 +++----
 testnet/stacks-node/src/neon_node.rs       | 22 ++++++++++------------
 8 files changed, 24 insertions(+), 27 deletions(-)

diff --git a/clarity/src/vm/docs/contracts.rs b/clarity/src/vm/docs/contracts.rs
index ff864b26db..95c363ab72 100644
--- a/clarity/src/vm/docs/contracts.rs
+++ b/clarity/src/vm/docs/contracts.rs
@@ -113,7 +113,7 @@ pub fn make_docs(content: &str, support_docs: &ContractSupportDocs) -> ContractR
             let description = support_docs
                 .descriptions
                 .get(func_name.as_str())
-                .expect(&format!("BUG: no description for {}", func_name.as_str()));
+                .unwrap_or_else(|| panic!("BUG: no description for {}", func_name.as_str()));
             make_func_ref(func_name, func_type, description)
         })
         .collect();
@@ -125,7 +125,7 @@ pub fn make_docs(content: &str, support_docs: &ContractSupportDocs) -> ContractR
             let description = support_docs
                 .descriptions
                 .get(func_name.as_str())
-                .expect(&format!("BUG: no description for {}", func_name.as_str()));
+                .unwrap_or_else(|| panic!("BUG: no description for {}", func_name.as_str()));
             make_func_ref(func_name, func_type, description)
         })
         .collect();
diff --git a/libsigner/src/tests/http.rs b/libsigner/src/tests/http.rs
index eb187700e8..4582b07160 100644
--- a/libsigner/src/tests/http.rs
+++ b/libsigner/src/tests/http.rs
@@ -150,7 +150,7 @@ fn test_decode_http_response_err() {
 
 #[test]
 fn test_decode_http_body() {
-    let tests = vec![
+    let tests = [
         (true, ""),
         (true, "this is the song that never ends"),
         (false, ""),
diff --git a/stackslib/src/blockstack_cli.rs b/stackslib/src/blockstack_cli.rs
index f82e760ad0..d708383f14 100644
--- a/stackslib/src/blockstack_cli.rs
+++ b/stackslib/src/blockstack_cli.rs
@@ -891,7 +891,7 @@ mod test {
     fn generate_should_work() {
         assert!(main_handler(vec!["generate-sk".into(), "--testnet".into()]).is_ok());
         assert!(main_handler(vec!["generate-sk".into()]).is_ok());
-        assert!(generate_secret_key(&vec!["-h".into()], TransactionVersion::Mainnet).is_err());
+        assert!(generate_secret_key(&["-h".into()], TransactionVersion::Mainnet).is_err());
     }
 
     fn to_string_vec(x: &[&str]) -> Vec<String> {
diff --git a/testnet/stacks-node/src/chain_data.rs b/testnet/stacks-node/src/chain_data.rs
index 587fece9bc..ac1ff4199b 100644
--- a/testnet/stacks-node/src/chain_data.rs
+++ b/testnet/stacks-node/src/chain_data.rs
@@ -1032,7 +1032,7 @@ EOF
         ] {
             let spend = *spend_dist
                 .get(miner)
-                .expect(&format!("no spend for {}", &miner));
+                .unwrap_or_else(|| panic!("no spend for {}", &miner));
             match miner.as_str() {
                 "miner-1" => {
                     assert_eq!(spend, 2);
@@ -1065,7 +1065,7 @@ EOF
         ] {
             let prob = *win_probs
                 .get(miner)
-                .expect(&format!("no probability for {}", &miner));
+                .unwrap_or_else(|| panic!("no probability for {}", &miner));
             match miner.as_str() {
                 "miner-1" => {
                     assert!((prob - (2.0 / 25.0)).abs() < 0.00001);
diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index b017ef831b..90da7dfb90 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -1891,7 +1891,7 @@ impl NodeConfig {
         }
         let (pubkey_str, hostport) = (parts[0], parts[1]);
         let pubkey = Secp256k1PublicKey::from_hex(pubkey_str)
-            .expect(&format!("Invalid public key '{}'", pubkey_str));
+            .unwrap_or_else(|_| panic!("Invalid public key '{pubkey_str}'"));
         debug!("Resolve '{}'", &hostport);
         let sockaddr = hostport.to_socket_addrs().unwrap().next().unwrap();
         let neighbor = NodeConfig::default_neighbor(sockaddr, pubkey, chain_id, peer_version);
@@ -2416,7 +2416,7 @@ impl MinerConfigFile {
             txs_to_consider: {
                 if let Some(txs_to_consider) = &self.txs_to_consider {
                     txs_to_consider
-                        .split(",")
+                        .split(',')
                         .map(
                             |txs_to_consider_str| match str::parse(txs_to_consider_str) {
                                 Ok(txtype) => txtype,
@@ -2433,7 +2433,7 @@ impl MinerConfigFile {
             filter_origins: {
                 if let Some(filter_origins) = &self.filter_origins {
                     filter_origins
-                        .split(",")
+                        .split(',')
                         .map(|origin_str| match StacksAddress::from_string(origin_str) {
                             Some(addr) => addr,
                             None => {
diff --git a/testnet/stacks-node/src/keychain.rs b/testnet/stacks-node/src/keychain.rs
index 05d8df49a3..c9ed722a9e 100644
--- a/testnet/stacks-node/src/keychain.rs
+++ b/testnet/stacks-node/src/keychain.rs
@@ -371,9 +371,9 @@ mod tests {
             };
 
             // Generate the proof
-            let proof = VRF::prove(&vrf_sk, &bytes.to_vec());
+            let proof = VRF::prove(&vrf_sk, bytes.as_ref());
             // Ensure that the proof is valid by verifying
-            let is_valid = match VRF::verify(vrf_pk, &proof, &bytes.to_vec()) {
+            let is_valid = match VRF::verify(vrf_pk, &proof, bytes.as_ref()) {
                 Ok(v) => v,
                 Err(_) => false,
             };
diff --git a/testnet/stacks-node/src/mockamoto/tests.rs b/testnet/stacks-node/src/mockamoto/tests.rs
index f1020cf35f..52450dc475 100644
--- a/testnet/stacks-node/src/mockamoto/tests.rs
+++ b/testnet/stacks-node/src/mockamoto/tests.rs
@@ -272,13 +272,12 @@ fn observe_set_aggregate_key() {
             mockamoto.sortdb.first_block_height,
             sortition_tip.block_height,
         )
-        .expect(
-            format!(
+        .unwrap_or_else(|| {
+            panic!(
                 "Failed to determine reward cycle of block height: {}",
                 sortition_tip.block_height
             )
-            .as_str(),
-        );
+        });
 
     let node_thread = thread::Builder::new()
         .name("mockamoto-main".into())
diff --git a/testnet/stacks-node/src/neon_node.rs b/testnet/stacks-node/src/neon_node.rs
index 5dc89ae9ba..ca80ac3244 100644
--- a/testnet/stacks-node/src/neon_node.rs
+++ b/testnet/stacks-node/src/neon_node.rs
@@ -820,13 +820,13 @@ impl MicroblockMinerThread {
                     // record this microblock somewhere
                     if !fs::metadata(&path).is_ok() {
                         fs::create_dir_all(&path)
-                            .expect(&format!("FATAL: could not create '{}'", &path));
+                            .unwrap_or_else(|_| panic!("FATAL: could not create '{}'", &path));
                     }
 
                     let path = Path::new(&path);
                     let path = path.join(Path::new(&format!("{}", &mined_microblock.block_hash())));
                     let mut file = fs::File::create(&path)
-                        .expect(&format!("FATAL: could not create '{:?}'", &path));
+                        .unwrap_or_else(|_| panic!("FATAL: could not create '{:?}'", &path));
 
                     let mblock_bits = mined_microblock.serialize_to_vec();
                     let mblock_bits_hex = to_hex(&mblock_bits);
@@ -835,10 +835,9 @@ impl MicroblockMinerThread {
                         r#"{{"microblock":"{}","parent_consensus":"{}","parent_block":"{}"}}"#,
                         &mblock_bits_hex, &self.parent_consensus_hash, &self.parent_block_hash
                     );
-                    file.write_all(&mblock_json.as_bytes()).expect(&format!(
-                        "FATAL: failed to write microblock bits to '{:?}'",
-                        &path
-                    ));
+                    file.write_all(&mblock_json.as_bytes()).unwrap_or_else(|_| {
+                        panic!("FATAL: failed to write microblock bits to '{:?}'", &path)
+                    });
                     info!(
                         "Fault injection: bad microblock {} saved to {}",
                         &mined_microblock.block_hash(),
@@ -2790,13 +2789,13 @@ impl RelayerThread {
                     // record this block somewhere
                     if !fs::metadata(&path).is_ok() {
                         fs::create_dir_all(&path)
-                            .expect(&format!("FATAL: could not create '{}'", &path));
+                            .unwrap_or_else(|_| panic!("FATAL: could not create '{}'", &path));
                     }
 
                     let path = Path::new(&path);
                     let path = path.join(Path::new(&format!("{}", &anchored_block.block_hash())));
                     let mut file = fs::File::create(&path)
-                        .expect(&format!("FATAL: could not create '{:?}'", &path));
+                        .unwrap_or_else(|_| panic!("FATAL: could not create '{:?}'", &path));
 
                     let block_bits = anchored_block.serialize_to_vec();
                     let block_bits_hex = to_hex(&block_bits);
@@ -2804,10 +2803,9 @@ impl RelayerThread {
                         r#"{{"block":"{}","consensus":"{}"}}"#,
                         &block_bits_hex, &consensus_hash
                     );
-                    file.write_all(&block_json.as_bytes()).expect(&format!(
-                        "FATAL: failed to write block bits to '{:?}'",
-                        &path
-                    ));
+                    file.write_all(&block_json.as_bytes()).unwrap_or_else(|_| {
+                        panic!("FATAL: failed to write block bits to '{:?}'", &path)
+                    });
                     info!(
                         "Fault injection: bad block {} saved to {}",
                         &anchored_block.block_hash(),

From dd3b2b8bf1887d36430f365aaf3fc7f0f5fca585 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Fri, 2 Feb 2024 12:13:09 -0500
Subject: [PATCH 0569/1166] fix: fix flaky integration test for writing to
 stackerdb

---
 stackslib/src/net/api/getstackerdbchunk.rs             | 5 ++++-
 stackslib/src/net/api/poststackerdbchunk.rs            | 2 ++
 testnet/stacks-node/src/tests/nakamoto_integrations.rs | 8 +++++++-
 3 files changed, 13 insertions(+), 2 deletions(-)

diff --git a/stackslib/src/net/api/getstackerdbchunk.rs b/stackslib/src/net/api/getstackerdbchunk.rs
index 72bd80685a..fe80969c8b 100644
--- a/stackslib/src/net/api/getstackerdbchunk.rs
+++ b/stackslib/src/net/api/getstackerdbchunk.rs
@@ -153,7 +153,10 @@ impl RPCRequestHandler for RPCGetStackerDBChunkRequestHandler {
                 };
 
                 match chunk_res {
-                    Ok(Some(chunk)) => Ok(chunk),
+                    Ok(Some(chunk)) => {
+                        debug!("Loaded {}-byte chunk for {} slot {} version {:?}", chunk.len(), &contract_identifier, slot_id, &slot_version);
+                        Ok(chunk)
+                    }
                     Ok(None) | Err(NetError::NoSuchStackerDB(..)) => {
                         // not found
                         Err(StacksHttpResponse::new_error(
diff --git a/stackslib/src/net/api/poststackerdbchunk.rs b/stackslib/src/net/api/poststackerdbchunk.rs
index 3ca82b4141..64287ae96f 100644
--- a/stackslib/src/net/api/poststackerdbchunk.rs
+++ b/stackslib/src/net/api/poststackerdbchunk.rs
@@ -253,6 +253,8 @@ impl RPCRequestHandler for RPCPostStackerDBChunkRequestHandler {
                     ));
                 }
 
+                debug!("Wrote {}-byte chunk to {} slot {} version {}", &stackerdb_chunk.data.len(), &contract_identifier, stackerdb_chunk.slot_id, stackerdb_chunk.slot_version);
+
                 // success!
                 let ack = StackerDBChunkAckData {
                     accepted: true,
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 1bb94f6030..2e8af2526d 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -1447,11 +1447,17 @@ fn miner_writes_proposed_block_to_stackerdb() {
         .clone()
         .parse()
         .expect("Failed to parse socket");
+
+    let sortdb = naka_conf.get_burnchain().open_sortition_db(true).unwrap();
+    let burn_height = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn())
+        .unwrap()
+        .block_height as u32;
+
     let chunk = std::thread::spawn(move || {
         let miner_contract_id = boot_code_id(MINERS_NAME, false);
         let mut miners_stackerdb = StackerDBSession::new(rpc_sock, miner_contract_id);
         miners_stackerdb
-            .get_latest_chunk(0)
+            .get_latest_chunk(burn_height % 2)
             .expect("Failed to get latest chunk from the miner slot ID")
             .expect("No chunk found")
     })

From b21bbd1d96c19b667eb604ff1bf1025c8de0d9e3 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Fri, 2 Feb 2024 13:01:55 -0500
Subject: [PATCH 0570/1166] fix: cargo fmt

---
 stackslib/src/net/api/getstackerdbchunk.rs  | 8 +++++++-
 stackslib/src/net/api/poststackerdbchunk.rs | 8 +++++++-
 2 files changed, 14 insertions(+), 2 deletions(-)

diff --git a/stackslib/src/net/api/getstackerdbchunk.rs b/stackslib/src/net/api/getstackerdbchunk.rs
index fe80969c8b..84b5269287 100644
--- a/stackslib/src/net/api/getstackerdbchunk.rs
+++ b/stackslib/src/net/api/getstackerdbchunk.rs
@@ -154,7 +154,13 @@ impl RPCRequestHandler for RPCGetStackerDBChunkRequestHandler {
 
                 match chunk_res {
                     Ok(Some(chunk)) => {
-                        debug!("Loaded {}-byte chunk for {} slot {} version {:?}", chunk.len(), &contract_identifier, slot_id, &slot_version);
+                        debug!(
+                            "Loaded {}-byte chunk for {} slot {} version {:?}",
+                            chunk.len(),
+                            &contract_identifier,
+                            slot_id,
+                            &slot_version
+                        );
                         Ok(chunk)
                     }
                     Ok(None) | Err(NetError::NoSuchStackerDB(..)) => {
diff --git a/stackslib/src/net/api/poststackerdbchunk.rs b/stackslib/src/net/api/poststackerdbchunk.rs
index 64287ae96f..57eb7ea2db 100644
--- a/stackslib/src/net/api/poststackerdbchunk.rs
+++ b/stackslib/src/net/api/poststackerdbchunk.rs
@@ -253,7 +253,13 @@ impl RPCRequestHandler for RPCPostStackerDBChunkRequestHandler {
                     ));
                 }
 
-                debug!("Wrote {}-byte chunk to {} slot {} version {}", &stackerdb_chunk.data.len(), &contract_identifier, stackerdb_chunk.slot_id, stackerdb_chunk.slot_version);
+                debug!(
+                    "Wrote {}-byte chunk to {} slot {} version {}",
+                    &stackerdb_chunk.data.len(),
+                    &contract_identifier,
+                    stackerdb_chunk.slot_id,
+                    stackerdb_chunk.slot_version
+                );
 
                 // success!
                 let ack = StackerDBChunkAckData {

From 47365bf195f2329ea89223b0dd01120571f62ae4 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Fri, 2 Feb 2024 13:11:50 -0500
Subject: [PATCH 0571/1166] chore: Fix `clippy::needless_collect`

---
 testnet/stacks-node/src/config.rs | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index 90da7dfb90..eed652e1cd 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -1904,8 +1904,7 @@ impl NodeConfig {
         chain_id: u32,
         peer_version: u32,
     ) {
-        let parts: Vec<&str> = bootstrap_nodes.split(',').collect();
-        for part in parts.into_iter() {
+        for part in bootstrap_nodes.split(',') {
             if part.len() > 0 {
                 self.add_bootstrap_node(&part, chain_id, peer_version);
             }
@@ -1924,8 +1923,7 @@ impl NodeConfig {
     }
 
     pub fn set_deny_nodes(&mut self, deny_nodes: String, chain_id: u32, peer_version: u32) {
-        let parts: Vec<&str> = deny_nodes.split(',').collect();
-        for part in parts.into_iter() {
+        for part in deny_nodes.split(',') {
             if part.len() > 0 {
                 self.add_deny_node(&part, chain_id, peer_version);
             }

From 38f70961f52975e1682ab9f3b3e5f07570f26e1f Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Fri, 2 Feb 2024 13:24:17 -0500
Subject: [PATCH 0572/1166] chore: Fix `clippy::needless_pass_by_ref_mut` in
 `./clarity`

---
 clarity/src/vm/analysis/mod.rs                    | 2 +-
 clarity/src/vm/analysis/trait_checker/mod.rs      | 2 +-
 clarity/src/vm/analysis/type_checker/v2_05/mod.rs | 2 +-
 clarity/src/vm/analysis/type_checker/v2_1/mod.rs  | 2 +-
 clarity/src/vm/contexts.rs                        | 2 +-
 5 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/clarity/src/vm/analysis/mod.rs b/clarity/src/vm/analysis/mod.rs
index 539979798e..5825305a33 100644
--- a/clarity/src/vm/analysis/mod.rs
+++ b/clarity/src/vm/analysis/mod.rs
@@ -117,7 +117,7 @@ pub fn type_check(
 
 pub fn run_analysis(
     contract_identifier: &QualifiedContractIdentifier,
-    expressions: &mut [SymbolicExpression],
+    expressions: &[SymbolicExpression],
     analysis_db: &mut AnalysisDatabase,
     save_contract: bool,
     cost_tracker: LimitedCostTracker,
diff --git a/clarity/src/vm/analysis/trait_checker/mod.rs b/clarity/src/vm/analysis/trait_checker/mod.rs
index 811d436a1f..5382face4f 100644
--- a/clarity/src/vm/analysis/trait_checker/mod.rs
+++ b/clarity/src/vm/analysis/trait_checker/mod.rs
@@ -50,7 +50,7 @@ impl TraitChecker {
 
     pub fn run(
         &mut self,
-        contract_analysis: &mut ContractAnalysis,
+        contract_analysis: &ContractAnalysis,
         analysis_db: &mut AnalysisDatabase,
     ) -> CheckResult<()> {
         for trait_identifier in &contract_analysis.implemented_traits {
diff --git a/clarity/src/vm/analysis/type_checker/v2_05/mod.rs b/clarity/src/vm/analysis/type_checker/v2_05/mod.rs
index d55da249a1..cbe7b2764f 100644
--- a/clarity/src/vm/analysis/type_checker/v2_05/mod.rs
+++ b/clarity/src/vm/analysis/type_checker/v2_05/mod.rs
@@ -393,7 +393,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> {
         }
     }
 
-    pub fn run(&mut self, contract_analysis: &mut ContractAnalysis) -> CheckResult<()> {
+    pub fn run(&mut self, contract_analysis: &ContractAnalysis) -> CheckResult<()> {
         // charge for the eventual storage cost of the analysis --
         //  it is linear in the size of the AST.
         let mut size: u64 = 0;
diff --git a/clarity/src/vm/analysis/type_checker/v2_1/mod.rs b/clarity/src/vm/analysis/type_checker/v2_1/mod.rs
index e567b3d188..24cc3d018a 100644
--- a/clarity/src/vm/analysis/type_checker/v2_1/mod.rs
+++ b/clarity/src/vm/analysis/type_checker/v2_1/mod.rs
@@ -931,7 +931,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> {
         }
     }
 
-    pub fn run(&mut self, contract_analysis: &mut ContractAnalysis) -> CheckResult<()> {
+    pub fn run(&mut self, contract_analysis: &ContractAnalysis) -> CheckResult<()> {
         // charge for the eventual storage cost of the analysis --
         //  it is linear in the size of the AST.
         let mut size: u64 = 0;
diff --git a/clarity/src/vm/contexts.rs b/clarity/src/vm/contexts.rs
index 08293e6366..a1c9f090f8 100644
--- a/clarity/src/vm/contexts.rs
+++ b/clarity/src/vm/contexts.rs
@@ -611,7 +611,7 @@ impl<'a, 'hooks> OwnedEnvironment<'a, 'hooks> {
         &'b mut self,
         sender: Option<PrincipalData>,
         sponsor: Option<PrincipalData>,
-        context: &'b mut ContractContext,
+        context: &'b ContractContext,
     ) -> Environment<'b, 'a, 'hooks> {
         Environment::new(
             &mut self.context,

From a19ea1a57e6712ba1a1ee9498cea6b8a90391536 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Fri, 2 Feb 2024 13:40:15 -0500
Subject: [PATCH 0573/1166] chore: Fix `clippy::redundant_clone` in `./clarity`

---
 .../analysis/type_checker/v2_1/tests/mod.rs   |  16 +--
 clarity/src/vm/analysis/types.rs              |   2 +-
 clarity/src/vm/ast/definition_sorter/tests.rs |   2 +-
 clarity/src/vm/ast/parser/v2/mod.rs           |  42 +++----
 clarity/src/vm/callables.rs                   |  18 +--
 clarity/src/vm/contexts.rs                    |  26 ++---
 clarity/src/vm/docs/mod.rs                    |   8 +-
 clarity/src/vm/tests/assets.rs                | 109 +++++++++---------
 clarity/src/vm/tests/contracts.rs             |  31 +++--
 clarity/src/vm/tests/sequences.rs             |   6 +-
 clarity/src/vm/tests/simple_apply_eval.rs     |   6 +-
 clarity/src/vm/tests/traits.rs                |  66 +++++------
 clarity/src/vm/types/mod.rs                   |   4 +-
 clarity/src/vm/types/serialization.rs         |   8 +-
 clarity/src/vm/types/signatures.rs            |  19 +--
 15 files changed, 169 insertions(+), 194 deletions(-)

diff --git a/clarity/src/vm/analysis/type_checker/v2_1/tests/mod.rs b/clarity/src/vm/analysis/type_checker/v2_1/tests/mod.rs
index a6feabefa0..d8733cfab8 100644
--- a/clarity/src/vm/analysis/type_checker/v2_1/tests/mod.rs
+++ b/clarity/src/vm/analysis/type_checker/v2_1/tests/mod.rs
@@ -1690,8 +1690,8 @@ fn test_replace_at_buff() {
         CheckErrors::IncorrectArgumentCount(3, 4),
         CheckErrors::IncorrectArgumentCount(3, 2),
         CheckErrors::TypeError(
-            SequenceType(BufferType(buff_len.clone())),
-            SequenceType(BufferType(buff_len_two.clone())),
+            SequenceType(BufferType(buff_len)),
+            SequenceType(BufferType(buff_len_two)),
         ),
     ];
     for (bad_test, expected) in bad.iter().zip(bad_expected.iter()) {
@@ -1746,8 +1746,8 @@ fn test_replace_at_ascii() {
         CheckErrors::IncorrectArgumentCount(3, 4),
         CheckErrors::IncorrectArgumentCount(3, 2),
         CheckErrors::TypeError(
-            SequenceType(StringType(ASCII(buff_len.clone()))),
-            SequenceType(StringType(ASCII(buff_len_two.clone()))),
+            SequenceType(StringType(ASCII(buff_len))),
+            SequenceType(StringType(ASCII(buff_len_two))),
         ),
     ];
     for (bad_test, expected) in bad.iter().zip(bad_expected.iter()) {
@@ -1796,14 +1796,14 @@ fn test_replace_at_utf8() {
         ),
         CheckErrors::TypeError(
             SequenceType(StringType(UTF8(str_len.clone()))),
-            SequenceType(BufferType(buff_len.clone())),
+            SequenceType(BufferType(buff_len)),
         ),
         CheckErrors::TypeError(UIntType, IntType),
         CheckErrors::IncorrectArgumentCount(3, 4),
         CheckErrors::IncorrectArgumentCount(3, 2),
         CheckErrors::TypeError(
-            SequenceType(StringType(UTF8(str_len.clone()))),
-            SequenceType(StringType(UTF8(str_len_two.clone()))),
+            SequenceType(StringType(UTF8(str_len))),
+            SequenceType(StringType(UTF8(str_len_two))),
         ),
     ];
     for (bad_test, expected) in bad.iter().zip(bad_expected.iter()) {
@@ -3399,7 +3399,7 @@ fn test_trait_args() {
         },
         TraitIdentifier {
             name: ClarityName::from("trait-bar"),
-            contract_identifier: contract_identifier.clone(),
+            contract_identifier: contract_identifier,
         },
     )];
 
diff --git a/clarity/src/vm/analysis/types.rs b/clarity/src/vm/analysis/types.rs
index 2471919b54..401c353b1b 100644
--- a/clarity/src/vm/analysis/types.rs
+++ b/clarity/src/vm/analysis/types.rs
@@ -366,7 +366,7 @@ mod test {
         {
             assert_eq!(
                 fixed.args[1].signature,
-                TypeSignature::CallableType(CallableSubtype::Trait(trait_id.clone()))
+                TypeSignature::CallableType(CallableSubtype::Trait(trait_id))
             );
         } else {
             panic!("Expected fixed function type");
diff --git a/clarity/src/vm/ast/definition_sorter/tests.rs b/clarity/src/vm/ast/definition_sorter/tests.rs
index 02996004a7..d0b24164ae 100644
--- a/clarity/src/vm/ast/definition_sorter/tests.rs
+++ b/clarity/src/vm/ast/definition_sorter/tests.rs
@@ -38,7 +38,7 @@ fn test_clarity_versions_definition_sorter(#[case] version: ClarityVersion) {}
 fn run_scoped_parsing_helper(contract: &str, version: ClarityVersion) -> ParseResult<ContractAST> {
     let contract_identifier = QualifiedContractIdentifier::transient();
     let pre_expressions = parser::v1::parse(contract)?;
-    let mut contract_ast = ContractAST::new(contract_identifier.clone(), pre_expressions);
+    let mut contract_ast = ContractAST::new(contract_identifier, pre_expressions);
     ExpressionIdentifier::run_pre_expression_pass(&mut contract_ast, version)?;
     DefinitionSorter::run_pass(&mut contract_ast, &mut (), version)?;
     Ok(contract_ast)
diff --git a/clarity/src/vm/ast/parser/v2/mod.rs b/clarity/src/vm/ast/parser/v2/mod.rs
index 499d1e728c..75a622a7c0 100644
--- a/clarity/src/vm/ast/parser/v2/mod.rs
+++ b/clarity/src/vm/ast/parser/v2/mod.rs
@@ -262,7 +262,7 @@ impl<'a> Parser<'a> {
                             // Report an error, then skip this token
                             self.add_diagnostic(
                                 ParseErrors::UnexpectedToken(token.token.clone()),
-                                token.span.clone(),
+                                token.span,
                             )?;
                             *whitespace = self.ignore_whitespace();
                             Ok(None)
@@ -376,7 +376,7 @@ impl<'a> Parser<'a> {
                                 // This indicates we have reached the end of the input.
                                 // Create a placeholder value so that parsing can continue,
                                 // then return.
-                                let eof_span = last_token.span.clone();
+                                let eof_span = last_token.span;
 
                                 self.add_diagnostic(
                                     ParseErrors::TupleValueExpected,
@@ -428,9 +428,7 @@ impl<'a> Parser<'a> {
                         return Ok(Some(e));
                     }
                     Token::Eof => (),
-                    _ => {
-                        self.add_diagnostic(ParseErrors::TupleCommaExpectedv2, token.span.clone())?
-                    }
+                    _ => self.add_diagnostic(ParseErrors::TupleCommaExpectedv2, token.span)?,
                 }
 
                 let mut comments = self.ignore_whitespace_and_comments();
@@ -463,7 +461,7 @@ impl<'a> Parser<'a> {
     fn open_tuple(&mut self, lbrace: PlacedToken) -> ParseResult<SetupTupleResult> {
         let mut open_tuple = OpenTuple {
             nodes: vec![],
-            span: lbrace.span.clone(),
+            span: lbrace.span,
             expects: OpenTupleStatus::ParseKey,
             diagnostic_token: self.peek_next_token(),
         };
@@ -474,10 +472,7 @@ impl<'a> Parser<'a> {
         let token = self.peek_next_token();
         match token.token {
             Token::Comma => {
-                self.add_diagnostic(
-                    ParseErrors::UnexpectedToken(token.token),
-                    token.span.clone(),
-                )?;
+                self.add_diagnostic(ParseErrors::UnexpectedToken(token.token), token.span)?;
                 self.next_token();
             }
             Token::Rbrace => {
@@ -548,10 +543,7 @@ impl<'a> Parser<'a> {
                 }) => {
                     span.end_line = token_span.end_line;
                     span.end_column = token_span.end_column;
-                    self.add_diagnostic(
-                        ParseErrors::ExpectedContractIdentifier,
-                        token_span.clone(),
-                    )?;
+                    self.add_diagnostic(ParseErrors::ExpectedContractIdentifier, token_span)?;
                     let mut placeholder = PreSymbolicExpression::placeholder(format!(
                         "'{}.{}",
                         principal,
@@ -561,7 +553,7 @@ impl<'a> Parser<'a> {
                     return Ok(placeholder);
                 }
                 None => {
-                    self.add_diagnostic(ParseErrors::ExpectedContractIdentifier, dot.span.clone())?;
+                    self.add_diagnostic(ParseErrors::ExpectedContractIdentifier, dot.span)?;
                     let mut placeholder =
                         PreSymbolicExpression::placeholder(format!("'{}.", principal));
                     placeholder.copy_span(&span);
@@ -572,7 +564,7 @@ impl<'a> Parser<'a> {
             if name.len() > MAX_CONTRACT_NAME_LEN {
                 self.add_diagnostic(
                     ParseErrors::ContractNameTooLong(name.clone()),
-                    contract_span.clone(),
+                    contract_span,
                 )?;
                 let mut placeholder =
                     PreSymbolicExpression::placeholder(format!("'{}.{}", principal, name));
@@ -584,7 +576,7 @@ impl<'a> Parser<'a> {
                 Err(_) => {
                     self.add_diagnostic(
                         ParseErrors::IllegalContractName(name.clone()),
-                        contract_span.clone(),
+                        contract_span,
                     )?;
                     let mut placeholder =
                         PreSymbolicExpression::placeholder(format!("'{}.{}", principal, name));
@@ -639,10 +631,7 @@ impl<'a> Parser<'a> {
                     }
                 };
                 if name.len() > MAX_STRING_LEN {
-                    self.add_diagnostic(
-                        ParseErrors::NameTooLong(name.clone()),
-                        trait_span.clone(),
-                    )?;
+                    self.add_diagnostic(ParseErrors::NameTooLong(name.clone()), trait_span)?;
                     let mut placeholder =
                         PreSymbolicExpression::placeholder(format!("'{}.{}", contract_id, name,));
                     placeholder.copy_span(&span);
@@ -653,7 +642,7 @@ impl<'a> Parser<'a> {
                     Err(_) => {
                         self.add_diagnostic(
                             ParseErrors::IllegalTraitName(name.clone()),
-                            trait_span.clone(),
+                            trait_span,
                         )?;
                         let mut placeholder = PreSymbolicExpression::placeholder(format!(
                             "'{}.{}",
@@ -728,7 +717,7 @@ impl<'a> Parser<'a> {
             Err(_) => {
                 self.add_diagnostic(
                     ParseErrors::IllegalContractName(name.clone()),
-                    contract_span.clone(),
+                    contract_span,
                 )?;
                 let mut placeholder = PreSymbolicExpression::placeholder(format!(".{}", name));
                 placeholder.copy_span(&span);
@@ -775,7 +764,7 @@ impl<'a> Parser<'a> {
                 }
             };
             if name.len() > MAX_STRING_LEN {
-                self.add_diagnostic(ParseErrors::NameTooLong(name.clone()), trait_span.clone())?;
+                self.add_diagnostic(ParseErrors::NameTooLong(name.clone()), trait_span)?;
                 let mut placeholder =
                     PreSymbolicExpression::placeholder(format!(".{}.{}", contract_name, name));
                 placeholder.copy_span(&span);
@@ -784,10 +773,7 @@ impl<'a> Parser<'a> {
             let trait_name = match ClarityName::try_from(name.clone()) {
                 Ok(id) => id,
                 Err(_) => {
-                    self.add_diagnostic(
-                        ParseErrors::IllegalTraitName(name.clone()),
-                        trait_span.clone(),
-                    )?;
+                    self.add_diagnostic(ParseErrors::IllegalTraitName(name.clone()), trait_span)?;
                     let mut placeholder =
                         PreSymbolicExpression::placeholder(format!(".{}.{}", contract_name, name));
                     placeholder.copy_span(&span);
diff --git a/clarity/src/vm/callables.rs b/clarity/src/vm/callables.rs
index 9b00aebc2e..bda9f19a45 100644
--- a/clarity/src/vm/callables.rs
+++ b/clarity/src/vm/callables.rs
@@ -537,7 +537,7 @@ mod test {
             trait_identifier: None,
         });
         let contract2 = Value::CallableContract(CallableData {
-            contract_identifier: contract_identifier2.clone(),
+            contract_identifier: contract_identifier2,
             trait_identifier: None,
         });
         let cast_contract = clarity2_implicit_cast(&trait_ty, &contract).unwrap();
@@ -599,7 +599,7 @@ mod test {
         // {a: principal} -> {a: <trait>}
         let a_name = ClarityName::from("a");
         let tuple_ty = TypeSignature::TupleType(
-            TupleTypeSignature::try_from(vec![(a_name.clone(), trait_ty.clone())]).unwrap(),
+            TupleTypeSignature::try_from(vec![(a_name.clone(), trait_ty)]).unwrap(),
         );
         let contract_tuple_ty = TypeSignature::TupleType(
             TupleTypeSignature::try_from(vec![(a_name.clone(), TypeSignature::PrincipalType)])
@@ -648,7 +648,7 @@ mod test {
         }
 
         // (list (response principal uint)) -> (list (response <trait> uint))
-        let list_res_ty = TypeSignature::list_of(response_ok_ty.clone(), 4).unwrap();
+        let list_res_ty = TypeSignature::list_of(response_ok_ty, 4).unwrap();
         let list_res_contract = Value::list_from(vec![
             Value::okay(contract.clone()).unwrap(),
             Value::okay(contract2.clone()).unwrap(),
@@ -678,12 +678,12 @@ mod test {
         }
 
         // (optional (list (response uint principal))) -> (optional (list (response uint <trait>)))
-        let list_res_ty = TypeSignature::list_of(response_err_ty.clone(), 4).unwrap();
+        let list_res_ty = TypeSignature::list_of(response_err_ty, 4).unwrap();
         let opt_list_res_ty = TypeSignature::new_option(list_res_ty).unwrap();
         let list_res_contract = Value::list_from(vec![
             Value::error(contract.clone()).unwrap(),
             Value::error(contract2.clone()).unwrap(),
-            Value::error(contract2.clone()).unwrap(),
+            Value::error(contract2).unwrap(),
         ])
         .unwrap();
         let opt_list_res_contract = Value::some(list_res_contract).unwrap();
@@ -696,9 +696,9 @@ mod test {
         }
 
         // (optional (optional principal)) -> (optional (optional <trait>))
-        let optional_optional_ty = TypeSignature::new_option(optional_ty.clone()).unwrap();
-        let optional_contract = Value::some(contract.clone()).unwrap();
-        let optional_optional_contract = Value::some(optional_contract.clone()).unwrap();
+        let optional_optional_ty = TypeSignature::new_option(optional_ty).unwrap();
+        let optional_contract = Value::some(contract).unwrap();
+        let optional_optional_contract = Value::some(optional_contract).unwrap();
         let cast_optional =
             clarity2_implicit_cast(&optional_optional_ty, &optional_optional_contract).unwrap();
 
@@ -741,7 +741,7 @@ mod test {
         f.canonicalize_types(&StacksEpochId::Epoch21);
         assert_eq!(
             f.arg_types[0],
-            TypeSignature::CallableType(CallableSubtype::Trait(trait_id.clone()))
+            TypeSignature::CallableType(CallableSubtype::Trait(trait_id))
         );
     }
 }
diff --git a/clarity/src/vm/contexts.rs b/clarity/src/vm/contexts.rs
index a1c9f090f8..f59fc2d659 100644
--- a/clarity/src/vm/contexts.rs
+++ b/clarity/src/vm/contexts.rs
@@ -671,7 +671,7 @@ impl<'a, 'hooks> OwnedEnvironment<'a, 'hooks> {
     ) -> Result<((), AssetMap, Vec<StacksTransactionEvent>)> {
         self.execute_in_env(
             contract_identifier.issuer.clone().into(),
-            sponsor.clone(),
+            sponsor,
             None,
             |exec_env| {
                 exec_env.initialize_contract(contract_identifier, contract_content, ast_rules)
@@ -689,7 +689,7 @@ impl<'a, 'hooks> OwnedEnvironment<'a, 'hooks> {
     ) -> Result<((), AssetMap, Vec<StacksTransactionEvent>)> {
         self.execute_in_env(
             contract_identifier.issuer.clone().into(),
-            sponsor.clone(),
+            sponsor,
             Some(ContractContext::new(
                 QualifiedContractIdentifier::transient(),
                 version,
@@ -710,7 +710,7 @@ impl<'a, 'hooks> OwnedEnvironment<'a, 'hooks> {
     ) -> Result<((), AssetMap, Vec<StacksTransactionEvent>)> {
         self.execute_in_env(
             contract_identifier.issuer.clone().into(),
-            sponsor.clone(),
+            sponsor,
             Some(ContractContext::new(
                 QualifiedContractIdentifier::transient(),
                 clarity_version,
@@ -1990,11 +1990,11 @@ mod test {
         let p2 = PrincipalData::Contract(b_contract_id.clone());
 
         let t1 = AssetIdentifier {
-            contract_identifier: a_contract_id.clone(),
+            contract_identifier: a_contract_id,
             asset_name: "a".into(),
         };
         let _t2 = AssetIdentifier {
-            contract_identifier: b_contract_id.clone(),
+            contract_identifier: b_contract_id,
             asset_name: "a".into(),
         };
 
@@ -2029,27 +2029,27 @@ mod test {
         let p3 = PrincipalData::Contract(c_contract_id.clone());
         let _p4 = PrincipalData::Contract(d_contract_id.clone());
         let _p5 = PrincipalData::Contract(e_contract_id.clone());
-        let _p6 = PrincipalData::Contract(f_contract_id.clone());
-        let _p7 = PrincipalData::Contract(g_contract_id.clone());
+        let _p6 = PrincipalData::Contract(f_contract_id);
+        let _p7 = PrincipalData::Contract(g_contract_id);
 
         let t1 = AssetIdentifier {
-            contract_identifier: a_contract_id.clone(),
+            contract_identifier: a_contract_id,
             asset_name: "a".into(),
         };
         let t2 = AssetIdentifier {
-            contract_identifier: b_contract_id.clone(),
+            contract_identifier: b_contract_id,
             asset_name: "a".into(),
         };
         let t3 = AssetIdentifier {
-            contract_identifier: c_contract_id.clone(),
+            contract_identifier: c_contract_id,
             asset_name: "a".into(),
         };
         let t4 = AssetIdentifier {
-            contract_identifier: d_contract_id.clone(),
+            contract_identifier: d_contract_id,
             asset_name: "a".into(),
         };
         let t5 = AssetIdentifier {
-            contract_identifier: e_contract_id.clone(),
+            contract_identifier: e_contract_id,
             asset_name: "a".into(),
         };
         let t6 = AssetIdentifier::STX();
@@ -2187,7 +2187,7 @@ mod test {
                 .get("alpha")
                 .unwrap()
                 .args[0],
-            TypeSignature::CallableType(CallableSubtype::Trait(trait_id.clone()))
+            TypeSignature::CallableType(CallableSubtype::Trait(trait_id))
         );
     }
 }
diff --git a/clarity/src/vm/docs/mod.rs b/clarity/src/vm/docs/mod.rs
index fbf85fba48..50ca695e46 100644
--- a/clarity/src/vm/docs/mod.rs
+++ b/clarity/src/vm/docs/mod.rs
@@ -2564,7 +2564,7 @@ fn make_keyword_reference(variable: &NativeVariables) -> Option<KeywordAPI> {
 
 fn make_for_special(api: &SpecialAPI, function: &NativeFunctions) -> FunctionAPI {
     FunctionAPI {
-        name: function.get_name().to_string(),
+        name: function.get_name(),
         snippet: api.snippet.to_string(),
         input_type: api.input_type.to_string(),
         output_type: api.output_type.to_string(),
@@ -3182,7 +3182,7 @@ mod test {
                 TypeSignature::IntType,
                 TypeSignature::PrincipalType,
             ]),
-            ret.clone(),
+            ret,
         );
         result = get_input_type_string(&function_type);
         assert_eq!(result, "uint, uint | uint, int | uint, principal | principal, uint | principal, int | principal, principal | int, uint | int, int | int, principal");
@@ -3210,7 +3210,7 @@ mod test {
                 TypeSignature::IntType,
                 TypeSignature::PrincipalType,
             ],
-            ret.clone(),
+            ret,
         );
         result = get_input_type_string(&function_type);
         assert_eq!(result, "uint | int | principal");
@@ -3225,7 +3225,7 @@ mod test {
         result = get_input_type_string(&function_type);
         assert_eq!(result, "int, ...");
 
-        function_type = FunctionType::Variadic(TypeSignature::PrincipalType, ret.clone());
+        function_type = FunctionType::Variadic(TypeSignature::PrincipalType, ret);
         result = get_input_type_string(&function_type);
         assert_eq!(result, "principal, ...");
     }
diff --git a/clarity/src/vm/tests/assets.rs b/clarity/src/vm/tests/assets.rs
index 0f6551c366..c537e66751 100644
--- a/clarity/src/vm/tests/assets.rs
+++ b/clarity/src/vm/tests/assets.rs
@@ -178,7 +178,7 @@ fn test_native_stx_ops(epoch: StacksEpochId, mut env_factory: TopLevelMemoryEnvi
     let token_contract_id =
         QualifiedContractIdentifier::new(p1_std_principal_data.clone(), "tokens".into());
     let second_contract_id =
-        QualifiedContractIdentifier::new(p1_std_principal_data.clone(), "second".into());
+        QualifiedContractIdentifier::new(p1_std_principal_data, "second".into());
 
     owned_env
         .initialize_contract(
@@ -332,7 +332,7 @@ fn test_native_stx_ops(epoch: StacksEpochId, mut env_factory: TopLevelMemoryEnvi
         p2_principal.clone(),
         &token_contract_id,
         "balance-stx",
-        &symbols_from_values(vec![nonexistent_principal.clone()]),
+        &symbols_from_values(vec![nonexistent_principal]),
     )
     .unwrap();
 
@@ -377,7 +377,7 @@ fn test_native_stx_ops(epoch: StacksEpochId, mut env_factory: TopLevelMemoryEnvi
         p3_principal.clone(),
         &token_contract_id,
         "xfer-stx",
-        &symbols_from_values(vec![Value::UInt(1), p3.clone(), p1.clone()]),
+        &symbols_from_values(vec![Value::UInt(1), p3.clone(), p1]),
     )
     .unwrap();
 
@@ -395,7 +395,7 @@ fn test_native_stx_ops(epoch: StacksEpochId, mut env_factory: TopLevelMemoryEnvi
         p2_principal.clone(),
         &token_contract_id,
         "to-contract",
-        &symbols_from_values(vec![Value::UInt(10), p2.clone()]),
+        &symbols_from_values(vec![Value::UInt(10), p2]),
     )
     .unwrap();
 
@@ -419,7 +419,7 @@ fn test_native_stx_ops(epoch: StacksEpochId, mut env_factory: TopLevelMemoryEnvi
         p2_principal.clone(),
         &token_contract_id,
         "balance-stx",
-        &symbols_from_values(vec![contract_principal.clone()]),
+        &symbols_from_values(vec![contract_principal]),
     )
     .unwrap();
 
@@ -432,7 +432,7 @@ fn test_native_stx_ops(epoch: StacksEpochId, mut env_factory: TopLevelMemoryEnvi
         p3_principal.clone(),
         &token_contract_id,
         "from-contract",
-        &symbols_from_values(vec![Value::UInt(10), p3.clone()]),
+        &symbols_from_values(vec![Value::UInt(10), p3]),
     )
     .unwrap();
 
@@ -477,7 +477,7 @@ fn test_native_stx_ops(epoch: StacksEpochId, mut env_factory: TopLevelMemoryEnvi
 
     let (result, asset_map, _events) = execute_transaction(
         &mut owned_env,
-        p3_principal.clone(),
+        p3_principal,
         &token_contract_id,
         "from-contract",
         &symbols_from_values(vec![Value::UInt(100), second_contract_id.clone().into()]),
@@ -541,7 +541,7 @@ fn test_simple_token_system(
     };
 
     let token_contract_id =
-        QualifiedContractIdentifier::new(p1_std_principal_data.clone(), "tokens".into());
+        QualifiedContractIdentifier::new(p1_std_principal_data, "tokens".into());
 
     let token_identifier = AssetIdentifier {
         contract_identifier: token_contract_id.clone(),
@@ -562,7 +562,7 @@ fn test_simple_token_system(
     let (result, asset_map, _events) = execute_transaction(
         &mut owned_env,
         p2_principal.clone(),
-        &token_contract_id.clone(),
+        &token_contract_id,
         "my-token-transfer",
         &symbols_from_values(vec![p1.clone(), Value::UInt(210)]),
     )
@@ -574,7 +574,7 @@ fn test_simple_token_system(
     let (result, asset_map, _events) = execute_transaction(
         &mut owned_env,
         p1_principal.clone(),
-        &token_contract_id.clone(),
+        &token_contract_id,
         "my-token-transfer",
         &symbols_from_values(vec![p2.clone(), Value::UInt(9000)]),
     )
@@ -583,14 +583,14 @@ fn test_simple_token_system(
 
     let asset_map = asset_map.to_table();
     assert_eq!(
-        asset_map[&p1_principal.clone()][&token_identifier],
+        asset_map[&p1_principal][&token_identifier],
         AssetMapEntry::Token(9000)
     );
 
     let (result, asset_map, _events) = execute_transaction(
         &mut owned_env,
         p1_principal.clone(),
-        &token_contract_id.clone(),
+        &token_contract_id,
         "my-token-transfer",
         &symbols_from_values(vec![p2.clone(), Value::UInt(1001)]),
     )
@@ -602,7 +602,7 @@ fn test_simple_token_system(
     let (result, asset_map, _events) = execute_transaction(
         &mut owned_env,
         p1_principal.clone(),
-        &token_contract_id.clone(),
+        &token_contract_id,
         "my-token-transfer",
         &symbols_from_values(vec![p1.clone(), Value::UInt(1000)]),
     )
@@ -614,7 +614,7 @@ fn test_simple_token_system(
     let err = execute_transaction(
         &mut owned_env,
         p1_principal.clone(),
-        &token_contract_id.clone(),
+        &token_contract_id,
         "my-token-transfer",
         &symbols_from_values(vec![p1.clone(), Value::Int(-1)]),
     )
@@ -628,7 +628,7 @@ fn test_simple_token_system(
     let (result, asset_map, _events) = execute_transaction(
         &mut owned_env,
         p1_principal.clone(),
-        &token_contract_id.clone(),
+        &token_contract_id,
         "my-ft-get-balance",
         &symbols_from_values(vec![p1.clone()]),
     )
@@ -640,7 +640,7 @@ fn test_simple_token_system(
     let (result, asset_map, _events) = execute_transaction(
         &mut owned_env,
         p1_principal.clone(),
-        &token_contract_id.clone(),
+        &token_contract_id,
         "my-ft-get-balance",
         &symbols_from_values(vec![p2.clone()]),
     )
@@ -652,7 +652,7 @@ fn test_simple_token_system(
     let (result, asset_map, _events) = execute_transaction(
         &mut owned_env,
         p1_principal.clone(),
-        &token_contract_id.clone(),
+        &token_contract_id,
         "faucet",
         &[],
     )
@@ -669,7 +669,7 @@ fn test_simple_token_system(
     let (result, asset_map, _events) = execute_transaction(
         &mut owned_env,
         p1_principal.clone(),
-        &token_contract_id.clone(),
+        &token_contract_id,
         "faucet",
         &[],
     )
@@ -685,7 +685,7 @@ fn test_simple_token_system(
     let (result, asset_map, _events) = execute_transaction(
         &mut owned_env,
         p1_principal.clone(),
-        &token_contract_id.clone(),
+        &token_contract_id,
         "faucet",
         &[],
     )
@@ -701,9 +701,9 @@ fn test_simple_token_system(
     let (result, _asset_map, _events) = execute_transaction(
         &mut owned_env,
         p1_principal.clone(),
-        &token_contract_id.clone(),
+        &token_contract_id,
         "my-ft-get-balance",
-        &symbols_from_values(vec![p1.clone()]),
+        &symbols_from_values(vec![p1]),
     )
     .unwrap();
 
@@ -713,7 +713,7 @@ fn test_simple_token_system(
     let (result, _asset_map, _events) = execute_transaction(
         &mut owned_env,
         p1_principal.clone(),
-        &token_contract_id.clone(),
+        &token_contract_id,
         "get-total-supply",
         &symbols_from_values(vec![]),
     )
@@ -724,7 +724,7 @@ fn test_simple_token_system(
     let (result, asset_map, _events) = execute_transaction(
         &mut owned_env,
         p2_principal.clone(),
-        &token_contract_id.clone(),
+        &token_contract_id,
         "burn",
         &symbols_from_values(vec![Value::UInt(100), p2.clone()]),
     )
@@ -741,7 +741,7 @@ fn test_simple_token_system(
     let (result, _asset_map, _events) = execute_transaction(
         &mut owned_env,
         p1_principal.clone(),
-        &token_contract_id.clone(),
+        &token_contract_id,
         "my-ft-get-balance",
         &symbols_from_values(vec![p2.clone()]),
     )
@@ -753,7 +753,7 @@ fn test_simple_token_system(
     let (result, _asset_map, _events) = execute_transaction(
         &mut owned_env,
         p1_principal.clone(),
-        &token_contract_id.clone(),
+        &token_contract_id,
         "get-total-supply",
         &symbols_from_values(vec![]),
     )
@@ -764,7 +764,7 @@ fn test_simple_token_system(
     let (result, _asset_map, _events) = execute_transaction(
         &mut owned_env,
         p2_principal.clone(),
-        &token_contract_id.clone(),
+        &token_contract_id,
         "burn",
         &symbols_from_values(vec![Value::UInt(9101), p2.clone()]),
     )
@@ -777,7 +777,7 @@ fn test_simple_token_system(
     let (result, _asset_map, _events) = execute_transaction(
         &mut owned_env,
         p2_principal.clone(),
-        &token_contract_id.clone(),
+        &token_contract_id,
         "burn",
         &symbols_from_values(vec![Value::UInt(0), p2.clone()]),
     )
@@ -791,9 +791,9 @@ fn test_simple_token_system(
     let (result, asset_map, _events) = execute_transaction(
         &mut owned_env,
         p1_principal.clone(),
-        &token_contract_id.clone(),
+        &token_contract_id,
         "burn",
-        &symbols_from_values(vec![Value::UInt(1), p2.clone()]),
+        &symbols_from_values(vec![Value::UInt(1), p2]),
     )
     .unwrap();
 
@@ -806,8 +806,8 @@ fn test_simple_token_system(
 
     let (result, asset_map, _events) = execute_transaction(
         &mut owned_env,
-        p1_principal.clone(),
-        &token_contract_id.clone(),
+        p1_principal,
+        &token_contract_id,
         "mint-after",
         &symbols_from_values(vec![Value::UInt(25)]),
     )
@@ -847,7 +847,7 @@ fn test_total_supply(epoch: StacksEpochId, mut env_factory: TopLevelMemoryEnviro
     };
 
     let token_contract_id =
-        QualifiedContractIdentifier::new(p1_std_principal_data.clone(), "tokens".into());
+        QualifiedContractIdentifier::new(p1_std_principal_data, "tokens".into());
     let err = owned_env
         .initialize_contract(
             token_contract_id.clone(),
@@ -886,7 +886,7 @@ fn test_total_supply(epoch: StacksEpochId, mut env_factory: TopLevelMemoryEnviro
     let (result, _asset_map, _events) = execute_transaction(
         &mut owned_env,
         p1_principal.clone(),
-        &token_contract_id.clone(),
+        &token_contract_id,
         "gated-faucet",
         &symbols_from_values(vec![Value::Bool(true)]),
     )
@@ -896,7 +896,7 @@ fn test_total_supply(epoch: StacksEpochId, mut env_factory: TopLevelMemoryEnviro
     let (result, _asset_map, _events) = execute_transaction(
         &mut owned_env,
         p1_principal.clone(),
-        &token_contract_id.clone(),
+        &token_contract_id,
         "gated-faucet",
         &symbols_from_values(vec![Value::Bool(false)]),
     )
@@ -906,7 +906,7 @@ fn test_total_supply(epoch: StacksEpochId, mut env_factory: TopLevelMemoryEnviro
     let (result, _asset_map, _events) = execute_transaction(
         &mut owned_env,
         p1_principal.clone(),
-        &token_contract_id.clone(),
+        &token_contract_id,
         "gated-faucet",
         &symbols_from_values(vec![Value::Bool(true)]),
     )
@@ -915,8 +915,8 @@ fn test_total_supply(epoch: StacksEpochId, mut env_factory: TopLevelMemoryEnviro
 
     let err = execute_transaction(
         &mut owned_env,
-        p1_principal.clone(),
-        &token_contract_id.clone(),
+        p1_principal,
+        &token_contract_id,
         "gated-faucet",
         &symbols_from_values(vec![Value::Bool(false)]),
     )
@@ -949,11 +949,11 @@ fn test_overlapping_nfts(
     let names_contract_id =
         QualifiedContractIdentifier::new(p1_std_principal_data.clone(), "names".into());
     let names_2_contract_id =
-        QualifiedContractIdentifier::new(p1_std_principal_data.clone(), "names-2".into());
+        QualifiedContractIdentifier::new(p1_std_principal_data, "names-2".into());
 
     owned_env
         .initialize_contract(
-            tokens_contract_id.clone(),
+            tokens_contract_id,
             tokens_contract,
             None,
             ASTRules::PrecheckSize,
@@ -961,7 +961,7 @@ fn test_overlapping_nfts(
         .unwrap();
     owned_env
         .initialize_contract(
-            names_contract_id.clone(),
+            names_contract_id,
             names_contract,
             None,
             ASTRules::PrecheckSize,
@@ -969,7 +969,7 @@ fn test_overlapping_nfts(
         .unwrap();
     owned_env
         .initialize_contract(
-            names_2_contract_id.clone(),
+            names_2_contract_id,
             names_contract,
             None,
             ASTRules::PrecheckSize,
@@ -1016,7 +1016,7 @@ fn test_simple_naming_system(
         QualifiedContractIdentifier::new(p1_std_principal_data.clone(), "names".into());
 
     let names_identifier = AssetIdentifier {
-        contract_identifier: names_contract_id.clone(),
+        contract_identifier: names_contract_id,
         asset_name: "names".into(),
     };
     let tokens_identifier = AssetIdentifier {
@@ -1030,15 +1030,14 @@ fn test_simple_naming_system(
 
     owned_env
         .initialize_contract(
-            tokens_contract_id.clone(),
+            tokens_contract_id,
             tokens_contract,
             None,
             ASTRules::PrecheckSize,
         )
         .unwrap();
 
-    let names_contract_id =
-        QualifiedContractIdentifier::new(p1_std_principal_data.clone(), "names".into());
+    let names_contract_id = QualifiedContractIdentifier::new(p1_std_principal_data, "names".into());
     owned_env
         .initialize_contract(
             names_contract_id.clone(),
@@ -1075,7 +1074,7 @@ fn test_simple_naming_system(
         p1_principal.clone(),
         &names_contract_id,
         "preorder",
-        &symbols_from_values(vec![name_hash_expensive_0.clone(), Value::UInt(1000)]),
+        &symbols_from_values(vec![name_hash_expensive_0, Value::UInt(1000)]),
     )
     .unwrap();
 
@@ -1142,7 +1141,7 @@ fn test_simple_naming_system(
 
     let asset_map = asset_map.to_table();
     assert_eq!(
-        asset_map[&p1_principal.clone()][&tokens_identifier],
+        asset_map[&p1_principal][&tokens_identifier],
         AssetMapEntry::Token(1001)
     );
 
@@ -1223,11 +1222,11 @@ fn test_simple_naming_system(
 
     assert!(is_committed(&result));
     assert_eq!(
-        asset_map[&p1_principal.clone()][&names_identifier],
+        asset_map[&p1_principal][&names_identifier],
         AssetMapEntry::Asset(vec![Value::Int(5)])
     );
     assert_eq!(
-        asset_map[&p1_principal.clone()][&tokens_identifier],
+        asset_map[&p1_principal][&tokens_identifier],
         AssetMapEntry::Token(1)
     );
 
@@ -1238,7 +1237,7 @@ fn test_simple_naming_system(
         p2_principal.clone(),
         &names_contract_id,
         "preorder",
-        &symbols_from_values(vec![name_hash_expensive_1.clone(), Value::UInt(100)]),
+        &symbols_from_values(vec![name_hash_expensive_1, Value::UInt(100)]),
     )
     .unwrap();
 
@@ -1262,7 +1261,7 @@ fn test_simple_naming_system(
         p2_principal.clone(),
         &names_contract_id,
         "preorder",
-        &symbols_from_values(vec![name_hash_cheap_0.clone(), Value::UInt(100)]),
+        &symbols_from_values(vec![name_hash_cheap_0, Value::UInt(100)]),
     )
     .unwrap();
 
@@ -1356,10 +1355,10 @@ fn test_simple_naming_system(
     // p2 re-burning 5 should succeed.
     let (result, _asset_map, _events) = execute_transaction(
         &mut owned_env,
-        p2_principal.clone(),
+        p2_principal,
         &names_contract_id,
         "force-burn",
-        &symbols_from_values(vec![Value::Int(5), p2.clone()]),
+        &symbols_from_values(vec![Value::Int(5), p2]),
     )
     .unwrap();
     assert!(!is_committed(&result));
@@ -1368,7 +1367,7 @@ fn test_simple_naming_system(
     // p1 re-minting 5 should succeed
     let (result, asset_map, _events) = execute_transaction(
         &mut owned_env,
-        p1_principal.clone(),
+        p1_principal,
         &names_contract_id,
         "force-mint",
         &symbols_from_values(vec![Value::Int(5)]),
@@ -1383,7 +1382,7 @@ fn test_simple_naming_system(
         assert_eq!(
             env.eval_read_only(&names_contract_id.clone(), "(nft-get-owner? names 5)")
                 .unwrap(),
-            Value::some(p1.clone()).unwrap()
+            Value::some(p1).unwrap()
         );
     }
 }
diff --git a/clarity/src/vm/tests/contracts.rs b/clarity/src/vm/tests/contracts.rs
index 98a0342e4f..817a74917b 100644
--- a/clarity/src/vm/tests/contracts.rs
+++ b/clarity/src/vm/tests/contracts.rs
@@ -229,7 +229,7 @@ fn test_contract_caller(epoch: StacksEpochId, mut env_factory: MemoryEnvironment
                 false
             )
             .unwrap(),
-            Value::cons_list_unsanitized(vec![c_b.clone(), p1.clone()]).unwrap()
+            Value::cons_list_unsanitized(vec![c_b.clone(), p1]).unwrap()
         );
         assert_eq!(
             env.execute_contract(
@@ -239,7 +239,7 @@ fn test_contract_caller(epoch: StacksEpochId, mut env_factory: MemoryEnvironment
                 false
             )
             .unwrap(),
-            Value::cons_list_unsanitized(vec![c_b.clone(), c_b.clone()]).unwrap()
+            Value::cons_list_unsanitized(vec![c_b.clone(), c_b]).unwrap()
         );
     }
 }
@@ -287,7 +287,7 @@ fn tx_sponsor_contract_asserts(env: &mut Environment, sponsor: Option<PrincipalD
             false
         )
         .unwrap(),
-        Value::cons_list_unsanitized(vec![sponsor.clone()]).unwrap()
+        Value::cons_list_unsanitized(vec![sponsor]).unwrap()
     );
 }
 
@@ -349,18 +349,15 @@ fn test_tx_sponsor(epoch: StacksEpochId, mut env_factory: MemoryEnvironmentGener
             sponsor.clone(),
             &mut placeholder_context,
         );
-        tx_sponsor_contract_asserts(&mut env, sponsor.clone());
+        tx_sponsor_contract_asserts(&mut env, sponsor);
     }
 
     // Sponsor is none in this code block.
     {
         let sponsor = None;
-        let mut env = owned_env.get_exec_environment(
-            Some(p1.clone()),
-            sponsor.clone(),
-            &mut placeholder_context,
-        );
-        tx_sponsor_contract_asserts(&mut env, sponsor.clone());
+        let mut env =
+            owned_env.get_exec_environment(Some(p1), sponsor.clone(), &mut placeholder_context);
+        tx_sponsor_contract_asserts(&mut env, sponsor);
     }
 }
 
@@ -441,7 +438,7 @@ fn test_fully_qualified_contract_call(
                 false
             )
             .unwrap(),
-            Value::cons_list_unsanitized(vec![c_b.clone(), p1.clone()]).unwrap()
+            Value::cons_list_unsanitized(vec![c_b.clone(), p1]).unwrap()
         );
         assert_eq!(
             env.execute_contract(
@@ -451,7 +448,7 @@ fn test_fully_qualified_contract_call(
                 false
             )
             .unwrap(),
-            Value::cons_list_unsanitized(vec![c_b.clone(), c_b.clone()]).unwrap()
+            Value::cons_list_unsanitized(vec![c_b.clone(), c_b]).unwrap()
         );
     }
 }
@@ -577,7 +574,7 @@ fn test_simple_naming_system(epoch: StacksEpochId, mut env_factory: MemoryEnviro
             &env.execute_contract(
                 &QualifiedContractIdentifier::local("names").unwrap(),
                 "preorder",
-                &symbols_from_values(vec![name_hash_expensive_0.clone(), Value::UInt(1000)]),
+                &symbols_from_values(vec![name_hash_expensive_0, Value::UInt(1000)]),
                 false
             )
             .unwrap(),
@@ -607,7 +604,7 @@ fn test_simple_naming_system(epoch: StacksEpochId, mut env_factory: MemoryEnviro
     {
         // should work!
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal().unwrap()),
+            Some(p1.expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -633,7 +630,7 @@ fn test_simple_naming_system(epoch: StacksEpochId, mut env_factory: MemoryEnviro
             &env.execute_contract(
                 &QualifiedContractIdentifier::local("names").unwrap(),
                 "preorder",
-                &symbols_from_values(vec![name_hash_expensive_1.clone(), Value::UInt(100)]),
+                &symbols_from_values(vec![name_hash_expensive_1, Value::UInt(100)]),
                 false
             )
             .unwrap()
@@ -654,7 +651,7 @@ fn test_simple_naming_system(epoch: StacksEpochId, mut env_factory: MemoryEnviro
             &env.execute_contract(
                 &QualifiedContractIdentifier::local("names").unwrap(),
                 "preorder",
-                &symbols_from_values(vec![name_hash_cheap_0.clone(), Value::UInt(100)]),
+                &symbols_from_values(vec![name_hash_cheap_0, Value::UInt(100)]),
                 false
             )
             .unwrap()
@@ -674,7 +671,7 @@ fn test_simple_naming_system(epoch: StacksEpochId, mut env_factory: MemoryEnviro
             &env.execute_contract(
                 &QualifiedContractIdentifier::local("names").unwrap(),
                 "register",
-                &symbols_from_values(vec![p2.clone(), Value::Int(100001), Value::Int(0)]),
+                &symbols_from_values(vec![p2, Value::Int(100001), Value::Int(0)]),
                 false
             )
             .unwrap(),
diff --git a/clarity/src/vm/tests/sequences.rs b/clarity/src/vm/tests/sequences.rs
index bba6413dd9..51de0e4023 100644
--- a/clarity/src/vm/tests/sequences.rs
+++ b/clarity/src/vm/tests/sequences.rs
@@ -798,7 +798,7 @@ fn test_simple_buff_replace_at() {
     assert_eq!(
         execute_v2("(replace-at? 0x445522 u0 0x0044)").unwrap_err(),
         CheckErrors::TypeValueError(
-            SequenceType(BufferType(buff_len.clone())),
+            SequenceType(BufferType(buff_len)),
             Value::buff_from(vec![0, 68]).unwrap()
         )
         .into()
@@ -875,7 +875,7 @@ fn test_simple_string_ascii_replace_at() {
     assert_eq!(
         execute_v2("(replace-at? \"abc\" u0 \"de\")").unwrap_err(),
         CheckErrors::TypeValueError(
-            SequenceType(StringType(ASCII(buff_len.clone()))),
+            SequenceType(StringType(ASCII(buff_len))),
             Value::string_ascii_from_bytes("de".into()).unwrap()
         )
         .into()
@@ -956,7 +956,7 @@ fn test_simple_string_utf8_replace_at() {
     assert_eq!(
         execute_v2("(replace-at? u\"abc\" u0 u\"de\")").unwrap_err(),
         CheckErrors::TypeValueError(
-            TypeSignature::SequenceType(StringType(StringSubtype::UTF8(str_len.clone()))),
+            TypeSignature::SequenceType(StringType(StringSubtype::UTF8(str_len))),
             Value::string_utf8_from_string_utf8_literal("de".to_string()).unwrap()
         )
         .into()
diff --git a/clarity/src/vm/tests/simple_apply_eval.rs b/clarity/src/vm/tests/simple_apply_eval.rs
index e7bc9cc221..d9e52c0222 100644
--- a/clarity/src/vm/tests/simple_apply_eval.rs
+++ b/clarity/src/vm/tests/simple_apply_eval.rs
@@ -431,7 +431,7 @@ fn test_secp256k1() {
     .unwrap();
     eprintln!("addr from privk {:?}", &addr);
     let principal = addr.to_account_principal();
-    if let PrincipalData::Standard(data) = principal.clone() {
+    if let PrincipalData::Standard(data) = principal {
         eprintln!("test_secp256k1 principal {:?}", data.to_address());
     }
 
@@ -506,7 +506,7 @@ fn test_principal_of_fix() {
 
     // Clarity2, mainnet, should have a mainnet principal.
     assert_eq!(
-        Value::Principal(mainnet_principal.clone()),
+        Value::Principal(mainnet_principal),
         execute_with_parameters(
             principal_of_program,
             ClarityVersion::Clarity2,
@@ -548,7 +548,7 @@ fn test_principal_of_fix() {
 
     // Clarity1, testnet, should have a testnet principal.
     assert_eq!(
-        Value::Principal(testnet_principal.clone()),
+        Value::Principal(testnet_principal),
         execute_with_parameters(
             principal_of_program,
             ClarityVersion::Clarity1,
diff --git a/clarity/src/vm/tests/traits.rs b/clarity/src/vm/tests/traits.rs
index 82b23e41af..250ebc3412 100644
--- a/clarity/src/vm/tests/traits.rs
+++ b/clarity/src/vm/tests/traits.rs
@@ -66,7 +66,7 @@ fn test_dynamic_dispatch_by_defining_trait(
             QualifiedContractIdentifier::local("target-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal().unwrap()),
+            Some(p1.expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -124,7 +124,7 @@ fn test_dynamic_dispatch_pass_trait_nested_in_let(
             QualifiedContractIdentifier::local("target-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal().unwrap()),
+            Some(p1.expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -181,7 +181,7 @@ fn test_dynamic_dispatch_pass_trait(
             QualifiedContractIdentifier::local("target-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal().unwrap()),
+            Some(p1.expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -237,7 +237,7 @@ fn test_dynamic_dispatch_intra_contract_call(
             QualifiedContractIdentifier::local("dispatching-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal().unwrap()),
+            Some(p1.expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -302,7 +302,7 @@ fn test_dynamic_dispatch_by_implementing_imported_trait(
             QualifiedContractIdentifier::local("target-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal().unwrap()),
+            Some(p1.expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -367,7 +367,7 @@ fn test_dynamic_dispatch_by_implementing_imported_trait_mul_funcs(
             QualifiedContractIdentifier::local("target-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal().unwrap()),
+            Some(p1.expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -429,7 +429,7 @@ fn test_dynamic_dispatch_by_importing_trait(
             QualifiedContractIdentifier::local("target-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal().unwrap()),
+            Some(p1.expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -513,7 +513,7 @@ fn test_dynamic_dispatch_including_nested_trait(
             QualifiedContractIdentifier::local("target-nested-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal().unwrap()),
+            Some(p1.expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -568,7 +568,7 @@ fn test_dynamic_dispatch_mismatched_args(
             QualifiedContractIdentifier::local("target-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal().unwrap()),
+            Some(p1.expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -625,7 +625,7 @@ fn test_dynamic_dispatch_mismatched_returned(
             QualifiedContractIdentifier::local("target-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal().unwrap()),
+            Some(p1.expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -685,7 +685,7 @@ fn test_reentrant_dynamic_dispatch(
             QualifiedContractIdentifier::local("target-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal().unwrap()),
+            Some(p1.expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -742,7 +742,7 @@ fn test_readwrite_dynamic_dispatch(
             QualifiedContractIdentifier::local("target-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal().unwrap()),
+            Some(p1.expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -799,7 +799,7 @@ fn test_readwrite_violation_dynamic_dispatch(
             QualifiedContractIdentifier::local("target-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal().unwrap()),
+            Some(p1.expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -872,7 +872,7 @@ fn test_bad_call_with_trait(
 
     {
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal().unwrap()),
+            Some(p1.expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -940,7 +940,7 @@ fn test_good_call_with_trait(
 
     {
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal().unwrap()),
+            Some(p1.expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -1012,7 +1012,7 @@ fn test_good_call_2_with_trait(
             QualifiedContractIdentifier::local("implem").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal().unwrap()),
+            Some(p1.expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -1077,7 +1077,7 @@ fn test_dynamic_dispatch_pass_literal_principal_as_trait_in_user_defined_functio
             QualifiedContractIdentifier::local("target-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal().unwrap()),
+            Some(p1.expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -1141,7 +1141,7 @@ fn test_contract_of_value(
         ));
         let result_contract = target_contract.clone();
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal().unwrap()),
+            Some(p1.expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -1208,7 +1208,7 @@ fn test_contract_of_no_impl(
         ));
         let result_contract = target_contract.clone();
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal().unwrap()),
+            Some(p1.expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -1266,7 +1266,7 @@ fn test_return_trait_with_contract_of_wrapped_in_begin(
             QualifiedContractIdentifier::local("target-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal().unwrap()),
+            Some(p1.expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -1323,7 +1323,7 @@ fn test_return_trait_with_contract_of_wrapped_in_let(
             QualifiedContractIdentifier::local("target-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal().unwrap()),
+            Some(p1.expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -1378,7 +1378,7 @@ fn test_return_trait_with_contract_of(
             QualifiedContractIdentifier::local("target-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal().unwrap()),
+            Some(p1.expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -1443,7 +1443,7 @@ fn test_pass_trait_to_subtrait(epoch: StacksEpochId, mut env_factory: MemoryEnvi
             QualifiedContractIdentifier::local("target-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal().unwrap()),
+            Some(p1.expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -1506,7 +1506,7 @@ fn test_embedded_trait(epoch: StacksEpochId, mut env_factory: MemoryEnvironmentG
         ));
         let opt_target = Value::some(target_contract).unwrap();
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal().unwrap()),
+            Some(p1.expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -1578,7 +1578,7 @@ fn test_pass_embedded_trait_to_subtrait_optional(
             QualifiedContractIdentifier::local("target-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal().unwrap()),
+            Some(p1.expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -1650,7 +1650,7 @@ fn test_pass_embedded_trait_to_subtrait_ok(
             QualifiedContractIdentifier::local("target-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal().unwrap()),
+            Some(p1.expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -1722,7 +1722,7 @@ fn test_pass_embedded_trait_to_subtrait_err(
             QualifiedContractIdentifier::local("target-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal().unwrap()),
+            Some(p1.expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -1794,7 +1794,7 @@ fn test_pass_embedded_trait_to_subtrait_list(
             QualifiedContractIdentifier::local("target-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal().unwrap()),
+            Some(p1.expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -1869,7 +1869,7 @@ fn test_pass_embedded_trait_to_subtrait_list_option(
             QualifiedContractIdentifier::local("target-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal().unwrap()),
+            Some(p1.expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -1944,7 +1944,7 @@ fn test_pass_embedded_trait_to_subtrait_option_list(
             QualifiedContractIdentifier::local("target-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal().unwrap()),
+            Some(p1.expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -2005,7 +2005,7 @@ fn test_let_trait(epoch: StacksEpochId, mut env_factory: MemoryEnvironmentGenera
             QualifiedContractIdentifier::local("target-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal().unwrap()),
+            Some(p1.expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -2070,7 +2070,7 @@ fn test_let3_trait(epoch: StacksEpochId, mut env_factory: MemoryEnvironmentGener
             QualifiedContractIdentifier::local("target-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal().unwrap()),
+            Some(p1.expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
@@ -2131,7 +2131,7 @@ fn test_pass_principal_literal_to_trait(
             QualifiedContractIdentifier::local("target-contract").unwrap(),
         ));
         let mut env = owned_env.get_exec_environment(
-            Some(p1.clone().expect_principal().unwrap()),
+            Some(p1.expect_principal().unwrap()),
             None,
             &mut placeholder_context,
         );
diff --git a/clarity/src/vm/types/mod.rs b/clarity/src/vm/types/mod.rs
index 89b242e5a1..06eea08966 100644
--- a/clarity/src/vm/types/mod.rs
+++ b/clarity/src/vm/types/mod.rs
@@ -1676,7 +1676,7 @@ mod test {
             Err(CheckErrors::TypeSignatureTooDeep.into())
         );
         assert_eq!(
-            Value::some(inner_value.clone()),
+            Value::some(inner_value),
             Err(CheckErrors::TypeSignatureTooDeep.into())
         );
 
@@ -1764,7 +1764,7 @@ mod test {
         );
         assert_eq!(buff.clone().expect_buff(10).unwrap(), vec![1, 2, 3, 4, 5]);
         assert_eq!(
-            buff.clone().expect_buff_padded(10, 1).unwrap(),
+            buff.expect_buff_padded(10, 1).unwrap(),
             vec![1, 2, 3, 4, 5, 1, 1, 1, 1, 1]
         );
     }
diff --git a/clarity/src/vm/types/serialization.rs b/clarity/src/vm/types/serialization.rs
index efb616cdb4..8f1862d3a1 100644
--- a/clarity/src/vm/types/serialization.rs
+++ b/clarity/src/vm/types/serialization.rs
@@ -728,7 +728,7 @@ impl Value {
                                 // unwrap is safe because of the match condition
                                 #[allow(clippy::unwrap_used)]
                                 return Err(SerializationError::DeserializeExpected(
-                                    expected_type.unwrap().clone(),
+                                    expected_type.unwrap(),
                                 ));
                             }
                             (Some(list_type), Some(list_type.get_list_item_type()))
@@ -781,7 +781,7 @@ impl Value {
                                     // unwrap is safe because of the match condition
                                     #[allow(clippy::unwrap_used)]
                                     return Err(SerializationError::DeserializeExpected(
-                                        expected_type.unwrap().clone(),
+                                        expected_type.unwrap(),
                                     ));
                                 }
                             } else {
@@ -789,7 +789,7 @@ impl Value {
                                     // unwrap is safe because of the match condition
                                     #[allow(clippy::unwrap_used)]
                                     return Err(SerializationError::DeserializeExpected(
-                                        expected_type.unwrap().clone(),
+                                        expected_type.unwrap(),
                                     ));
                                 }
                             }
@@ -1488,7 +1488,7 @@ pub mod tests {
         );
         // parent list longer than expected
         test_bad_expectation(
-            list_list_int.clone(),
+            list_list_int,
             TypeSignature::from_string("(list 0 (list 2 uint))", version, epoch),
         );
 
diff --git a/clarity/src/vm/types/signatures.rs b/clarity/src/vm/types/signatures.rs
index f81fe138d2..a0dc5cf3e8 100644
--- a/clarity/src/vm/types/signatures.rs
+++ b/clarity/src/vm/types/signatures.rs
@@ -2138,10 +2138,7 @@ mod test {
         ];
         let list_union2 = ListUnionType(callables2.clone().into());
         let list_union_merged = ListUnionType(HashSet::from_iter(
-            [callables.clone(), callables2.clone()]
-                .concat()
-                .iter()
-                .cloned(),
+            [callables, callables2].concat().iter().cloned(),
         ));
         let callable_principals = [
             CallableSubtype::Principal(QualifiedContractIdentifier::local("foo").unwrap()),
@@ -2514,11 +2511,8 @@ mod test {
                     )
                     .unwrap(),
                 ),
-                TypeSignature::new_response(
-                    TypeSignature::PrincipalType,
-                    list_union_merged.clone(),
-                )
-                .unwrap(),
+                TypeSignature::new_response(TypeSignature::PrincipalType, list_union_merged)
+                    .unwrap(),
             ),
         ];
 
@@ -2588,7 +2582,7 @@ mod test {
             (list_union.clone(), TypeSignature::PrincipalType),
             (
                 TypeSignature::min_string_ascii().unwrap(),
-                list_union_principals.clone(),
+                list_union_principals,
             ),
             (
                 TypeSignature::list_of(
@@ -2618,10 +2612,9 @@ mod test {
                 TypeSignature::new_option(TypeSignature::min_string_utf8().unwrap()).unwrap(),
             ),
             (
-                TypeSignature::new_response(TypeSignature::PrincipalType, list_union.clone())
-                    .unwrap(),
+                TypeSignature::new_response(TypeSignature::PrincipalType, list_union).unwrap(),
                 TypeSignature::new_response(
-                    list_union2.clone(),
+                    list_union2,
                     TypeSignature::CallableType(CallableSubtype::Principal(
                         QualifiedContractIdentifier::transient(),
                     )),

From cc6fb99d8f5740bc51f5388c1ec0ff6dfedf48e5 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Fri, 2 Feb 2024 13:54:42 -0500
Subject: [PATCH 0574/1166] chore: Fix `clippy::redundant_clone`

---
 libsigner/src/tests/mod.rs                                | 2 +-
 libstackerdb/src/tests/mod.rs                             | 2 +-
 stacks-signer/src/config.rs                               | 2 --
 .../src/burnchains/bitcoin_regtest_controller.rs          | 8 ++++----
 testnet/stacks-node/src/main.rs                           | 3 +--
 testnet/stacks-node/src/nakamoto_node.rs                  | 2 +-
 testnet/stacks-node/src/nakamoto_node/miner.rs            | 7 ++-----
 testnet/stacks-node/src/nakamoto_node/relayer.rs          | 2 +-
 testnet/stacks-node/src/neon_node.rs                      | 6 +++---
 testnet/stacks-node/src/node.rs                           | 4 ++--
 testnet/stacks-node/src/run_loop/boot_nakamoto.rs         | 3 +--
 testnet/stacks-node/src/run_loop/nakamoto.rs              | 2 +-
 testnet/stacks-node/src/run_loop/neon.rs                  | 4 ++--
 13 files changed, 20 insertions(+), 27 deletions(-)

diff --git a/libsigner/src/tests/mod.rs b/libsigner/src/tests/mod.rs
index b53fd00afa..4991292bf4 100644
--- a/libsigner/src/tests/mod.rs
+++ b/libsigner/src/tests/mod.rs
@@ -170,7 +170,7 @@ fn test_status_endpoint() {
     let contract_id =
         QualifiedContractIdentifier::parse("ST2DS4MSWSGJ3W9FBC6BVT0Y92S345HY8N3T6AV7R.signers")
             .unwrap(); // TODO: change to boot_code_id(SIGNERS_NAME, false) when .signers is deployed
-    let ev = SignerEventReceiver::new(vec![contract_id.clone()], false);
+    let ev = SignerEventReceiver::new(vec![contract_id], false);
     let (_cmd_send, cmd_recv) = channel();
     let (res_send, _res_recv) = channel();
     let max_events = 1;
diff --git a/libstackerdb/src/tests/mod.rs b/libstackerdb/src/tests/mod.rs
index bd63ae7c56..b0135eb72d 100644
--- a/libstackerdb/src/tests/mod.rs
+++ b/libstackerdb/src/tests/mod.rs
@@ -101,7 +101,7 @@ fn test_stackerdb_paths() {
     );
 
     assert_eq!(
-        stackerdb_post_chunk_path(contract_id.clone()),
+        stackerdb_post_chunk_path(contract_id),
         "/v2/stackerdb/SP1Y0NECNCJ6YDVM7GQ594FF065NN3NT72FASBXB8/hello-world/chunks".to_string()
     );
 }
diff --git a/stacks-signer/src/config.rs b/stacks-signer/src/config.rs
index dbc8e0abf4..6b9e908da1 100644
--- a/stacks-signer/src/config.rs
+++ b/stacks-signer/src/config.rs
@@ -214,7 +214,6 @@ impl TryFrom<RawConfigFile> for Config {
     fn try_from(raw_data: RawConfigFile) -> Result<Self, Self::Error> {
         let node_host = raw_data
             .node_host
-            .clone()
             .to_socket_addrs()
             .map_err(|_| {
                 ConfigError::BadField("node_host".to_string(), raw_data.node_host.clone())
@@ -227,7 +226,6 @@ impl TryFrom<RawConfigFile> for Config {
 
         let endpoint = raw_data
             .endpoint
-            .clone()
             .to_socket_addrs()
             .map_err(|_| ConfigError::BadField("endpoint".to_string(), raw_data.endpoint.clone()))?
             .next()
diff --git a/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs b/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
index 5022f452bc..cd28fe08f6 100644
--- a/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
+++ b/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
@@ -152,7 +152,7 @@ pub fn make_bitcoin_indexer(
     let (_, network_type) = config.burnchain.get_bitcoin_network();
     let indexer_runtime = BitcoinIndexerRuntime::new(network_type);
     let burnchain_indexer = BitcoinIndexer {
-        config: indexer_config.clone(),
+        config: indexer_config,
         runtime: indexer_runtime,
         should_keep_running: should_keep_running,
     };
@@ -314,7 +314,7 @@ impl BitcoinRegtestController {
         let (_, network_type) = config.burnchain.get_bitcoin_network();
         let indexer_runtime = BitcoinIndexerRuntime::new(network_type);
         let burnchain_indexer = BitcoinIndexer {
-            config: indexer_config.clone(),
+            config: indexer_config,
             runtime: indexer_runtime,
             should_keep_running: should_keep_running.clone(),
         };
@@ -360,7 +360,7 @@ impl BitcoinRegtestController {
         let (_, network_type) = config.burnchain.get_bitcoin_network();
         let indexer_runtime = BitcoinIndexerRuntime::new(network_type);
         let burnchain_indexer = BitcoinIndexer {
-            config: indexer_config.clone(),
+            config: indexer_config,
             runtime: indexer_runtime,
             should_keep_running: None,
         };
@@ -516,7 +516,7 @@ impl BitcoinRegtestController {
                     // don't wait for heights beyond the burnchain tip.
                     if block_for_sortitions {
                         self.wait_for_sortitions(
-                            coordinator_comms.clone(),
+                            coordinator_comms,
                             target_block_height_opt.unwrap_or(x.block_height),
                         )?;
                     }
diff --git a/testnet/stacks-node/src/main.rs b/testnet/stacks-node/src/main.rs
index 3418ed9726..218780d6a7 100644
--- a/testnet/stacks-node/src/main.rs
+++ b/testnet/stacks-node/src/main.rs
@@ -78,8 +78,7 @@ fn cli_pick_best_tip(config_path: &str, at_stacks_height: Option<u64>) -> TipCan
         Some(config.node.get_marf_opts()),
     )
     .unwrap();
-    let mut sortdb =
-        SortitionDB::open(&burn_db_path, false, burnchain.pox_constants.clone()).unwrap();
+    let mut sortdb = SortitionDB::open(&burn_db_path, false, burnchain.pox_constants).unwrap();
 
     let max_depth = config.miner.max_reorg_depth;
 
diff --git a/testnet/stacks-node/src/nakamoto_node.rs b/testnet/stacks-node/src/nakamoto_node.rs
index ddcbc197f7..6255f97200 100644
--- a/testnet/stacks-node/src/nakamoto_node.rs
+++ b/testnet/stacks-node/src/nakamoto_node.rs
@@ -151,7 +151,7 @@ impl StacksNode {
             .connect_mempool_db()
             .expect("FATAL: database failure opening mempool");
 
-        let mut p2p_net = NeonNode::setup_peer_network(&config, &atlas_config, burnchain.clone());
+        let mut p2p_net = NeonNode::setup_peer_network(&config, &atlas_config, burnchain);
 
         let stackerdbs = StackerDBs::connect(&config.get_stacker_db_file_path(), true)
             .expect("FATAL: failed to connect to stacker DB");
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index 28d85948dc..5e3421a984 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -506,11 +506,8 @@ impl BlockMinerThread {
                 par_tenure_info.parent_tenure_blocks,
                 self.keychain.get_nakamoto_pkh(),
             )?;
-            let coinbase_tx = self.generate_coinbase_tx(
-                current_miner_nonce + 1,
-                target_epoch_id,
-                vrf_proof.clone(),
-            );
+            let coinbase_tx =
+                self.generate_coinbase_tx(current_miner_nonce + 1, target_epoch_id, vrf_proof);
             NakamotoTenureInfo {
                 coinbase_tx: Some(coinbase_tx),
                 tenure_change_tx: Some(tenure_change_tx),
diff --git a/testnet/stacks-node/src/nakamoto_node/relayer.rs b/testnet/stacks-node/src/nakamoto_node/relayer.rs
index 1fb8462648..1ee3135c24 100644
--- a/testnet/stacks-node/src/nakamoto_node/relayer.rs
+++ b/testnet/stacks-node/src/nakamoto_node/relayer.rs
@@ -186,7 +186,7 @@ impl RelayerThread {
         let bitcoin_controller = BitcoinRegtestController::new_dummy(config.clone());
 
         RelayerThread {
-            config: config.clone(),
+            config: config,
             sortdb,
             chainstate,
             mempool,
diff --git a/testnet/stacks-node/src/neon_node.rs b/testnet/stacks-node/src/neon_node.rs
index ca80ac3244..a9c0393674 100644
--- a/testnet/stacks-node/src/neon_node.rs
+++ b/testnet/stacks-node/src/neon_node.rs
@@ -580,7 +580,7 @@ impl MicroblockMinerThread {
 
         // NOTE: read-write access is needed in order to be able to query the recipient set.
         // This is an artifact of the way the MARF is built (see #1449)
-        let sortdb = SortitionDB::open(&burn_db_path, true, burnchain.pox_constants.clone())
+        let sortdb = SortitionDB::open(&burn_db_path, true, burnchain.pox_constants)
             .map_err(|e| {
                 error!(
                     "Relayer: Could not open sortdb '{}' ({:?}); skipping tenure",
@@ -1032,7 +1032,7 @@ impl BlockMinerThread {
             warn!("Coinbase pay-to-contract is not supported in the current epoch");
             None
         } else {
-            miner_config.block_reward_recipient.clone()
+            miner_config.block_reward_recipient
         }
     }
 
@@ -4688,7 +4688,7 @@ impl StacksNode {
 
         let _ = Self::setup_mempool_db(&config);
 
-        let mut p2p_net = Self::setup_peer_network(&config, &atlas_config, burnchain.clone());
+        let mut p2p_net = Self::setup_peer_network(&config, &atlas_config, burnchain);
 
         let stackerdbs = StackerDBs::connect(&config.get_stacker_db_file_path(), true)
             .expect("FATAL: failed to connect to stacker DB");
diff --git a/testnet/stacks-node/src/node.rs b/testnet/stacks-node/src/node.rs
index 31d2ce0c55..cdebdbc781 100644
--- a/testnet/stacks-node/src/node.rs
+++ b/testnet/stacks-node/src/node.rs
@@ -637,7 +637,7 @@ impl Node {
         let sortdb = SortitionDB::open(
             &self.config.get_burn_db_file_path(),
             true,
-            burnchain.pox_constants.clone(),
+            burnchain.pox_constants,
         )
         .expect("Error while opening sortition db");
         let tip = SortitionDB::get_canonical_burn_chain_tip(&sortdb.conn())
@@ -733,7 +733,7 @@ impl Node {
             let sortdb = SortitionDB::open(
                 &self.config.get_burn_db_file_path(),
                 true,
-                burnchain.pox_constants.clone(),
+                burnchain.pox_constants,
             )
             .expect("Error while opening sortition db");
 
diff --git a/testnet/stacks-node/src/run_loop/boot_nakamoto.rs b/testnet/stacks-node/src/run_loop/boot_nakamoto.rs
index 4485a4cace..dec1ca757f 100644
--- a/testnet/stacks-node/src/run_loop/boot_nakamoto.rs
+++ b/testnet/stacks-node/src/run_loop/boot_nakamoto.rs
@@ -206,8 +206,7 @@ impl BootRunLoop {
             return Ok(0);
         }
 
-        let Ok(sortdb) = SortitionDB::open(&sortdb_path, false, burnchain.pox_constants.clone())
-        else {
+        let Ok(sortdb) = SortitionDB::open(&sortdb_path, false, burnchain.pox_constants) else {
             info!("Failed to open Sortition DB while checking current burn height, assuming height = 0");
             return Ok(0);
         };
diff --git a/testnet/stacks-node/src/run_loop/nakamoto.rs b/testnet/stacks-node/src/run_loop/nakamoto.rs
index 8483dcb138..0b3702a994 100644
--- a/testnet/stacks-node/src/run_loop/nakamoto.rs
+++ b/testnet/stacks-node/src/run_loop/nakamoto.rs
@@ -457,7 +457,7 @@ impl RunLoop {
             sn
         };
 
-        globals.set_last_sortition(burnchain_tip_snapshot.clone());
+        globals.set_last_sortition(burnchain_tip_snapshot);
 
         // Boot up the p2p network and relayer, and figure out how many sortitions we have so far
         // (it could be non-zero if the node is resuming from chainstate)
diff --git a/testnet/stacks-node/src/run_loop/neon.rs b/testnet/stacks-node/src/run_loop/neon.rs
index 899326b676..58910aef86 100644
--- a/testnet/stacks-node/src/run_loop/neon.rs
+++ b/testnet/stacks-node/src/run_loop/neon.rs
@@ -399,7 +399,7 @@ impl RunLoop {
             config.clone(),
             Some(coordinator_senders),
             burnchain_opt,
-            Some(should_keep_running.clone()),
+            Some(should_keep_running),
         );
 
         let burnchain = burnchain_controller.get_burnchain();
@@ -1065,7 +1065,7 @@ impl RunLoop {
             sn
         };
 
-        globals.set_last_sortition(burnchain_tip_snapshot.clone());
+        globals.set_last_sortition(burnchain_tip_snapshot);
 
         // Boot up the p2p network and relayer, and figure out how many sortitions we have so far
         // (it could be non-zero if the node is resuming from chainstate)

From 22a456755cb85d65480b28ea57783723e8eaaec4 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Fri, 2 Feb 2024 13:57:41 -0500
Subject: [PATCH 0575/1166] fix: fix failing unit test

---
 stackslib/src/net/api/tests/liststackerdbreplicas.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/stackslib/src/net/api/tests/liststackerdbreplicas.rs b/stackslib/src/net/api/tests/liststackerdbreplicas.rs
index c26f29c520..7941e6232e 100644
--- a/stackslib/src/net/api/tests/liststackerdbreplicas.rs
+++ b/stackslib/src/net/api/tests/liststackerdbreplicas.rs
@@ -116,7 +116,6 @@ fn test_try_make_response() {
 
     let naddr = resp.last().clone().unwrap();
     assert_eq!(naddr.addrbytes, PeerAddress::from_ipv4(127, 0, 0, 1));
-    assert_eq!(naddr.port, 0);
     assert_eq!(
         naddr.public_key_hash,
         Hash160::from_hex("9b92533ccc243e25eb6197bd03c9164642c7c8a8").unwrap()

From 44b8f56a86a76ffdaaec898f7872f798884e6391 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Tue, 23 Jan 2024 14:07:33 -0800
Subject: [PATCH 0576/1166] feat: add sip18 structured data signing

---
 stacks-common/src/util/secp256k1.rs           |   5 +
 stackslib/src/util_lib/mod.rs                 |   1 +
 .../src/util_lib/signed_structured_data.rs    | 122 ++++++++++++++++++
 3 files changed, 128 insertions(+)
 create mode 100644 stackslib/src/util_lib/signed_structured_data.rs

diff --git a/stacks-common/src/util/secp256k1.rs b/stacks-common/src/util/secp256k1.rs
index 8a84a4bedd..5d1a5f5aeb 100644
--- a/stacks-common/src/util/secp256k1.rs
+++ b/stacks-common/src/util/secp256k1.rs
@@ -109,6 +109,11 @@ impl MessageSignature {
             Err(_) => None,
         }
     }
+
+    /// Convert from VRS to RSV
+    pub fn to_rsv(&self) -> Vec<u8> {
+        [&self.0[1..], &self.0[0..1]].concat()
+    }
 }
 
 #[cfg(any(test, feature = "testing"))]
diff --git a/stackslib/src/util_lib/mod.rs b/stackslib/src/util_lib/mod.rs
index 85b09a3af6..83a7ab2a25 100644
--- a/stackslib/src/util_lib/mod.rs
+++ b/stackslib/src/util_lib/mod.rs
@@ -2,6 +2,7 @@
 pub mod db;
 pub mod bloom;
 pub mod boot;
+pub mod signed_structured_data;
 pub mod strings;
 
 #[cfg(test)]
diff --git a/stackslib/src/util_lib/signed_structured_data.rs b/stackslib/src/util_lib/signed_structured_data.rs
new file mode 100644
index 0000000000..32f9ef2f4b
--- /dev/null
+++ b/stackslib/src/util_lib/signed_structured_data.rs
@@ -0,0 +1,122 @@
+use clarity::vm::Value;
+use stacks_common::{
+    codec::StacksMessageCodec,
+    types::PrivateKey,
+    util::{
+        hash::{to_hex, Sha256Sum},
+        secp256k1::{MessageSignature, Secp256k1PrivateKey},
+    },
+};
+
+/// Message prefix for signed structured data. "SIP018" in ascii
+pub const STRUCTURED_DATA_PREFIX: [u8; 6] = [0x53, 0x49, 0x50, 0x30, 0x31, 0x38];
+
+pub fn structured_data_hash(value: Value) -> Sha256Sum {
+    let bytes = value.serialize_to_vec();
+    Sha256Sum::from_data(&bytes)
+}
+
+/// Generate a message hash for signing structured Clarity data.
+/// Reference [SIP018](https://github.com/stacksgov/sips/blob/main/sips/sip-018/sip-018-signed-structured-data.md) for more information.
+pub fn structured_data_message_hash(structured_data: Value, domain: Value) -> Sha256Sum {
+    let message = [
+        STRUCTURED_DATA_PREFIX.as_ref(),
+        structured_data_hash(domain).as_bytes(),
+        structured_data_hash(structured_data).as_bytes(),
+    ]
+    .concat();
+
+    Sha256Sum::from_data(&message)
+}
+
+/// Sign structured Clarity data with a given private key.
+/// Reference [SIP018](https://github.com/stacksgov/sips/blob/main/sips/sip-018/sip-018-signed-structured-data.md) for more information.
+pub fn sign_structured_data(
+    structured_data: Value,
+    domain: Value,
+    private_key: &Secp256k1PrivateKey,
+) -> Result<MessageSignature, &str> {
+    let msg_hash = structured_data_message_hash(structured_data, domain);
+    private_key.sign(msg_hash.as_bytes())
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use clarity::vm::types::{TupleData, Value};
+    use stacks_common::{consts::CHAIN_ID_MAINNET, util::hash::to_hex};
+
+    /// [SIP18 test vectors](https://github.com/stacksgov/sips/blob/main/sips/sip-018/sip-018-signed-structured-data.md)
+    #[test]
+    fn test_sip18_ref_structured_data_hash() {
+        let value = Value::string_ascii_from_bytes("Hello World".into()).unwrap();
+        let msg_hash = structured_data_hash(value);
+        assert_eq!(
+            to_hex(msg_hash.as_bytes()),
+            "5297eef9765c466d945ad1cb2c81b30b9fed6c165575dc9226e9edf78b8cd9e8"
+        )
+    }
+
+    /// [SIP18 test vectors](https://github.com/stacksgov/sips/blob/main/sips/sip-018/sip-018-signed-structured-data.md)
+    #[test]
+    fn test_sip18_ref_message_hashing() {
+        let domain = Value::Tuple(
+            TupleData::from_data(vec![
+                (
+                    "name".into(),
+                    Value::string_ascii_from_bytes("Test App".into()).unwrap(),
+                ),
+                (
+                    "version".into(),
+                    Value::string_ascii_from_bytes("1.0.0".into()).unwrap(),
+                ),
+                ("chain-id".into(), Value::UInt(CHAIN_ID_MAINNET.into())),
+            ])
+            .unwrap(),
+        );
+        let data = Value::string_ascii_from_bytes("Hello World".into()).unwrap();
+
+        let msg_hash = structured_data_message_hash(data, domain);
+
+        assert_eq!(
+            to_hex(msg_hash.as_bytes()),
+            "1bfdab6d4158313ce34073fbb8d6b0fc32c154d439def12247a0f44bb2225259"
+        );
+    }
+
+    /// [SIP18 test vectors](https://github.com/stacksgov/sips/blob/main/sips/sip-018/sip-018-signed-structured-data.md)
+    #[test]
+    fn test_sip18_ref_signing() {
+        let key = Secp256k1PrivateKey::from_hex(
+            "753b7cc01a1a2e86221266a154af739463fce51219d97e4f856cd7200c3bd2a601",
+        )
+        .unwrap();
+        let domain = Value::Tuple(
+            TupleData::from_data(vec![
+                (
+                    "name".into(),
+                    Value::string_ascii_from_bytes("Test App".into()).unwrap(),
+                ),
+                (
+                    "version".into(),
+                    Value::string_ascii_from_bytes("1.0.0".into()).unwrap(),
+                ),
+                ("chain-id".into(), Value::UInt(CHAIN_ID_MAINNET.into())),
+            ])
+            .unwrap(),
+        );
+        let data = Value::string_ascii_from_bytes("Hello World".into()).unwrap();
+        let signature =
+            sign_structured_data(data, domain, &key).expect("Failed to sign structured data");
+
+        let signature_rsv = signature.to_rsv();
+
+        assert_eq!(to_hex(signature_rsv.as_slice()), "8b94e45701d857c9f1d1d70e8b2ca076045dae4920fb0160be0642a68cd78de072ab527b5c5277a593baeb2a8b657c216b99f7abb5d14af35b4bf12ba6460ba401");
+    }
+
+    #[test]
+    fn test_prefix_bytes() {
+        let hex = to_hex(STRUCTURED_DATA_PREFIX.as_ref());
+        assert_eq!(hex, "534950303138");
+    }
+}

From 1bdc815c744ad11e8eb624314d7e754b4bf2b897 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Mon, 22 Jan 2024 16:51:18 -0800
Subject: [PATCH 0577/1166] feat: verify signing-key in delegate-stack-stx

feat: require signature from signer in `delegate-stx`
---
 stackslib/src/chainstate/stacks/boot/mod.rs   | 77 ++++++++++++++++++-
 .../src/chainstate/stacks/boot/pox-4.clar     | 39 ++++++++++
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 27 +++++--
 3 files changed, 134 insertions(+), 9 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 1294091f5e..5fc2ab3cf4 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -1380,7 +1380,9 @@ pub mod test {
     use clarity::vm::contracts::Contract;
     use clarity::vm::tests::symbols_from_values;
     use clarity::vm::types::*;
-    use stacks_common::util::hash::to_hex;
+    use stacks_common::types::PrivateKey;
+    use stacks_common::util::hash::Sha256Sum;
+    use stacks_common::util::secp256k1::Secp256k1PrivateKey;
     use stacks_common::util::*;
 
     use super::*;
@@ -1399,6 +1401,7 @@ pub mod test {
     use crate::core::{StacksEpochId, *};
     use crate::net::test::*;
     use crate::util_lib::boot::{boot_code_id, boot_code_test_addr};
+    use crate::util_lib::signed_structured_data::sign_structured_data;
 
     pub const TESTNET_STACKING_THRESHOLD_25: u128 = 8000;
 
@@ -2204,6 +2207,70 @@ pub mod test {
         make_tx(key, nonce, 0, payload)
     }
 
+    pub fn make_signer_key_signature(
+        stacker: &PrincipalData,
+        signer_key: &StacksPrivateKey,
+        reward_cycle: u128,
+    ) -> Vec<u8> {
+        let domain_tuple = Value::Tuple(
+            TupleData::from_data(vec![
+                (
+                    "name".into(),
+                    Value::string_ascii_from_bytes("pox-4-signer".into()).unwrap(),
+                ),
+                (
+                    "version".into(),
+                    Value::string_ascii_from_bytes("1.0.0".into()).unwrap(),
+                ),
+                ("chain-id".into(), Value::UInt(CHAIN_ID_TESTNET.into())),
+            ])
+            .unwrap(),
+        );
+
+        let data_tuple = Value::Tuple(
+            TupleData::from_data(vec![
+                ("stacker".into(), Value::Principal(stacker.clone())),
+                ("reward-cycle".into(), Value::UInt(reward_cycle)),
+            ])
+            .unwrap(),
+        );
+
+        let signature = sign_structured_data(data_tuple, domain_tuple, signer_key).unwrap();
+
+        signature.to_rsv()
+    }
+
+    pub fn make_delegate_stx_signature(
+        stacker: &PrincipalData,
+        delegator_key: &Secp256k1PrivateKey,
+        reward_cycle: u128,
+    ) -> Vec<u8> {
+        let msg_tuple = Value::Tuple(
+            TupleData::from_data(vec![
+                ("stacker".into(), Value::Principal(stacker.clone())),
+                ("reward-cycle".into(), Value::UInt(reward_cycle)),
+            ])
+            .unwrap(),
+        );
+
+        let mut tuple_bytes = vec![];
+        msg_tuple
+            .serialize_write(&mut tuple_bytes)
+            .expect("Failed to serialize delegate sig data");
+        let msg_hash = Sha256Sum::from_data(&tuple_bytes).as_bytes().to_vec();
+
+        let signature = &delegator_key
+            .sign(&msg_hash)
+            .expect("Unable to sign delegate sig data");
+
+        // Convert signature into rsv as needed for `secp256k1-recover?`
+        let mut ret_bytes = Vec::new();
+        ret_bytes.extend(&signature[1..]);
+        ret_bytes.push(signature[0]);
+
+        ret_bytes
+    }
+
     fn make_tx(
         key: &StacksPrivateKey,
         nonce: u64,
@@ -2526,6 +2593,14 @@ pub mod test {
         parent_tip
     }
 
+    pub fn get_current_reward_cycle(peer: &TestPeer, burnchain: &Burnchain) -> u128 {
+        let tip = SortitionDB::get_canonical_burn_chain_tip(&peer.sortdb.as_ref().unwrap().conn())
+            .unwrap();
+        burnchain
+            .block_height_to_reward_cycle(tip.block_height)
+            .unwrap() as u128
+    }
+
     #[test]
     fn test_liquid_ustx() {
         let mut burnchain = Burnchain::default_unittest(
diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index 22f7a41310..2574e3e952 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -30,6 +30,7 @@
 (define-constant ERR_INVALID_SIGNER_KEY 32)
 (define-constant ERR_REUSED_SIGNER_KEY 33)
 (define-constant ERR_DELEGATION_ALREADY_REVOKED 34)
+(define-constant ERR_DELEGATION_INVALID_SIGNATURE (err 35))
 
 ;; Valid values for burnchain address versions.
 ;; These first four correspond to address hash modes in Stacks 2.1,
@@ -636,6 +637,7 @@
                              (delegate-to principal)
                              (until-burn-ht (optional uint))
                              (pox-addr (optional { version: (buff 1), hashbytes: (buff 32) })))
+                             
     (begin
       ;; must be called directly by the tx-sender or by an allowed contract-caller
       (asserts! (check-caller-allowed)
@@ -670,6 +672,43 @@
 
       (ok true)))
 
+(define-read-only (get-signer-key-message-hash (signer-key (buff 33)) (stacker principal))
+  (let
+    (
+      (domain { name: "pox-4-signer", version: "1.0.0", chain-id: chain-id })
+      (data-hash (sha256 (unwrap-panic 
+        (to-consensus-buff? { stacker: stacker, reward-cycle: (current-pox-reward-cycle) }))))
+      (domain-hash (sha256 (unwrap-panic (to-consensus-buff? domain))))
+    )
+    (sha256 (concat
+      0x534950303138
+      (concat domain-hash
+      data-hash)))
+  )
+)
+
+;; Verify a signature from the signing key for this specific stacker.
+;; The message hash is the sha256 of the consensus hash of the tuple 
+;; `{ stacker, reward-cycle }`. Note that `reward-cycle` corresponds to the
+;; _current_ reward cycle, not the reward cycle at which the delegation will start.
+;; The public key is recovered from the signature and compared to the pubkey hash
+;; of the delegator.
+(define-read-only (verify-signing-key-signature (stacker principal)
+                                                (signing-key (buff 33))
+                                                (signer-sig (buff 65)))
+  (let
+    (
+      ;; (msg { stacker: stacker, reward-cycle: (current-pox-reward-cycle) })
+      ;; (msg-bytes (unwrap! (to-consensus-buff? msg) ERR_DELEGATION_INVALID_SIGNATURE)) ;;TODO
+      ;; ;; (msg-hash (sha256 msg-bytes))
+      (msg-hash (get-signer-key-message-hash signing-key stacker))
+      (pubkey (unwrap! (secp256k1-recover? msg-hash signer-sig) ERR_DELEGATION_INVALID_SIGNATURE)) ;; TODO
+    )
+    (asserts! (is-eq pubkey signing-key) ERR_DELEGATION_INVALID_SIGNATURE)
+    (ok true)
+  )                                            
+)
+
 ;; Commit partially stacked STX and allocate a new PoX reward address slot.
 ;;   This allows a stacker/delegate to lock fewer STX than the minimal threshold in multiple transactions,
 ;;   so long as: 1. The pox-addr is the same.
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index d912620659..e5c4d3c612 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -39,7 +39,7 @@ use stacks_common::address::AddressHashMode;
 use stacks_common::types::chainstate::{
     BlockHeaderHash, BurnchainHeaderHash, StacksAddress, StacksBlockId, VRFSeed,
 };
-use stacks_common::types::Address;
+use stacks_common::types::{Address, PrivateKey};
 use stacks_common::util::hash::{hex_bytes, to_hex, Sha256Sum, Sha512Trunc256Sum};
 use stacks_common::util::secp256k1::{Secp256k1PrivateKey, Secp256k1PublicKey};
 use wsts::curve::point::{Compressed, Point};
@@ -50,6 +50,7 @@ use crate::burnchains::{Burnchain, PoxConstants};
 use crate::chainstate::burn::db::sortdb::SortitionDB;
 use crate::chainstate::burn::operations::*;
 use crate::chainstate::burn::{BlockSnapshot, ConsensusHash};
+use crate::chainstate::coordinator::tests::pox_addr_from;
 use crate::chainstate::stacks::address::{PoxAddress, PoxAddressType20, PoxAddressType32};
 use crate::chainstate::stacks::boot::pox_2_tests::{
     check_pox_print_event, generate_pox_clarity_value, get_reward_set_entries_at,
@@ -1292,6 +1293,9 @@ fn pox_4_revoke_delegate_stx_events() {
 
     // alice delegates 100 STX to Bob
     let alice_delegation_amount = 100_000_000;
+    let cur_reward_cycle = get_current_reward_cycle(&peer, &burnchain);
+    let signature = make_delegate_stx_signature(&alice_principal, &bob, cur_reward_cycle);
+    let alice_delegate_nonce = alice_nonce;
     let alice_delegate = make_pox_4_delegate_stx(
         &alice,
         alice_nonce,
@@ -1299,6 +1303,7 @@ fn pox_4_revoke_delegate_stx_events() {
         bob_principal,
         None,
         None,
+        // &signature,
     );
     let alice_delegate_nonce = alice_nonce;
     alice_nonce += 1;
@@ -1326,6 +1331,7 @@ fn pox_4_revoke_delegate_stx_events() {
         PrincipalData::from(bob_address.clone()),
         Some(target_height as u128),
         None,
+        // &signature,
     );
     let alice_delegate_2_nonce = alice_nonce;
     alice_nonce += 1;
@@ -1358,6 +1364,12 @@ fn pox_4_revoke_delegate_stx_events() {
     }
     assert_eq!(alice_txs.len() as u64, 5);
 
+    let first_delegate_tx = &alice_txs.get(&alice_delegate_nonce);
+    assert_eq!(
+        first_delegate_tx.unwrap().clone().result,
+        Value::okay_true()
+    );
+
     // check event for first revoke delegation tx
     let revoke_delegation_tx_events = &alice_txs.get(&alice_revoke_nonce).unwrap().clone().events;
     assert_eq!(revoke_delegation_tx_events.len() as u64, 1);
@@ -1643,6 +1655,7 @@ fn delegate_stack_stx_signer_key() {
 
     let stacker_nonce = 0;
     let stacker_key = &keys[0];
+    let stacker_principal = PrincipalData::from(key_to_stacks_addr(stacker_key));
     let delegate_nonce = 0;
     let delegate_key = &keys[1];
     let delegate_principal = PrincipalData::from(key_to_stacks_addr(delegate_key));
@@ -1702,12 +1715,6 @@ fn delegate_stack_stx_signer_key() {
             ],
         ),
     ];
-    // (define-public (delegate-stack-stx (stacker principal)
-    //                                (amount-ustx uint)
-    //                                (pox-addr { version: (buff 1), hashbytes: (buff 32) })
-    //                                (start-burn-ht uint)
-    //                                (lock-period uint)
-    //                                (signer-key (buff 33)))
 
     let latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
 
@@ -1784,6 +1791,8 @@ fn delegate_stack_stx_extend_signer_key() {
         Some(pox_addr.clone()),
     );
 
+    let alice_principal = PrincipalData::from(key_to_stacks_addr(alice_stacker_key));
+
     let delegate_stack_stx = make_pox_4_delegate_stack_stx(
         bob_delegate_private_key,
         bob_nonce,
@@ -2033,10 +2042,12 @@ fn delegate_stack_increase() {
         Some(pox_addr.clone()),
     );
 
+    let alice_principal = PrincipalData::from(key_to_stacks_addr(alice_key));
+
     let delegate_stack_stx = make_pox_4_delegate_stack_stx(
         bob_delegate_key,
         bob_nonce,
-        PrincipalData::from(key_to_stacks_addr(alice_key)).into(),
+        alice_principal,
         min_ustx,
         pox_addr.clone(),
         block_height as u128,

From bdd9c5f7b0e80794d2d17cec600a90aa89784f8d Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Tue, 23 Jan 2024 16:00:46 -0800
Subject: [PATCH 0578/1166] feat: unit tests for `verify-signing-key-signature`

---
 stackslib/src/chainstate/stacks/boot/mod.rs   |  31 ---
 .../src/chainstate/stacks/boot/pox-4.clar     |   4 +-
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 205 +++++++++++++++++-
 3 files changed, 197 insertions(+), 43 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 5fc2ab3cf4..f577243c3a 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -2240,37 +2240,6 @@ pub mod test {
         signature.to_rsv()
     }
 
-    pub fn make_delegate_stx_signature(
-        stacker: &PrincipalData,
-        delegator_key: &Secp256k1PrivateKey,
-        reward_cycle: u128,
-    ) -> Vec<u8> {
-        let msg_tuple = Value::Tuple(
-            TupleData::from_data(vec![
-                ("stacker".into(), Value::Principal(stacker.clone())),
-                ("reward-cycle".into(), Value::UInt(reward_cycle)),
-            ])
-            .unwrap(),
-        );
-
-        let mut tuple_bytes = vec![];
-        msg_tuple
-            .serialize_write(&mut tuple_bytes)
-            .expect("Failed to serialize delegate sig data");
-        let msg_hash = Sha256Sum::from_data(&tuple_bytes).as_bytes().to_vec();
-
-        let signature = &delegator_key
-            .sign(&msg_hash)
-            .expect("Unable to sign delegate sig data");
-
-        // Convert signature into rsv as needed for `secp256k1-recover?`
-        let mut ret_bytes = Vec::new();
-        ret_bytes.extend(&signature[1..]);
-        ret_bytes.push(signature[0]);
-
-        ret_bytes
-    }
-
     fn make_tx(
         key: &StacksPrivateKey,
         nonce: u64,
diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index 2574e3e952..c5d333035a 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -672,6 +672,7 @@
 
       (ok true)))
 
+;; Generate a message hash following the SIP018 standard.
 (define-read-only (get-signer-key-message-hash (signer-key (buff 33)) (stacker principal))
   (let
     (
@@ -698,9 +699,6 @@
                                                 (signer-sig (buff 65)))
   (let
     (
-      ;; (msg { stacker: stacker, reward-cycle: (current-pox-reward-cycle) })
-      ;; (msg-bytes (unwrap! (to-consensus-buff? msg) ERR_DELEGATION_INVALID_SIGNATURE)) ;;TODO
-      ;; ;; (msg-hash (sha256 msg-bytes))
       (msg-hash (get-signer-key-message-hash signing-key stacker))
       (pubkey (unwrap! (secp256k1-recover? msg-hash signer-sig) ERR_DELEGATION_INVALID_SIGNATURE)) ;; TODO
     )
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index e5c4d3c612..b6654f9e60 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -76,6 +76,7 @@ use crate::core::*;
 use crate::net::test::{TestEventObserver, TestPeer};
 use crate::util_lib::boot::boot_code_id;
 use crate::util_lib::db::{DBConn, FromRow};
+use crate::util_lib::signed_structured_data::structured_data_message_hash;
 
 const USTX_PER_HOLDER: u128 = 1_000_000;
 
@@ -1293,8 +1294,6 @@ fn pox_4_revoke_delegate_stx_events() {
 
     // alice delegates 100 STX to Bob
     let alice_delegation_amount = 100_000_000;
-    let cur_reward_cycle = get_current_reward_cycle(&peer, &burnchain);
-    let signature = make_delegate_stx_signature(&alice_principal, &bob, cur_reward_cycle);
     let alice_delegate_nonce = alice_nonce;
     let alice_delegate = make_pox_4_delegate_stx(
         &alice,
@@ -1409,6 +1408,191 @@ fn pox_4_revoke_delegate_stx_events() {
     );
 }
 
+fn generate_signer_key_sig_msg_hash(
+    stacker: &PrincipalData,
+    signer_key: &Secp256k1PrivateKey,
+    reward_cycle: u128,
+) -> Sha256Sum {
+    let domain_tuple = Value::Tuple(
+        TupleData::from_data(vec![
+            (
+                "name".into(),
+                Value::string_ascii_from_bytes("pox-4-signer".into()).unwrap(),
+            ),
+            (
+                "version".into(),
+                Value::string_ascii_from_bytes("1.0.0".into()).unwrap(),
+            ),
+            ("chain-id".into(), Value::UInt(CHAIN_ID_TESTNET.into())),
+        ])
+        .unwrap(),
+    );
+    let data_tuple = Value::Tuple(
+        TupleData::from_data(vec![
+            ("stacker".into(), Value::Principal(stacker.clone())),
+            ("reward-cycle".into(), Value::UInt(reward_cycle)),
+        ])
+        .unwrap(),
+    );
+
+    structured_data_message_hash(data_tuple, domain_tuple)
+}
+
+fn validate_signer_key_sig(
+    signature: &Vec<u8>,
+    signing_key: &Secp256k1PublicKey,
+    stacker: &PrincipalData,
+    peer: &mut TestPeer,
+    burnchain: &Burnchain,
+    coinbase_nonce: &mut usize,
+    latest_block: &StacksBlockId,
+) -> Value {
+    let result: Value = with_sortdb(peer, |ref mut chainstate, ref mut sortdb| {
+        chainstate
+            .with_read_only_clarity_tx(&sortdb.index_conn(), &latest_block, |clarity_tx| {
+                clarity_tx
+                    .with_readonly_clarity_env(
+                        false,
+                        0x80000000,
+                        ClarityVersion::Clarity2,
+                        PrincipalData::Standard(StandardPrincipalData::transient()),
+                        None,
+                        LimitedCostTracker::new_free(),
+                        |env| {
+                            let program = format!(
+                                "(verify-signing-key-signature '{} 0x{} 0x{})",
+                                stacker.to_string(),
+                                signing_key.to_hex(),
+                                to_hex(&signature),
+                            );
+                            env.eval_read_only(&boot_code_id("pox-4", false), &program)
+                        },
+                    )
+                    .unwrap()
+            })
+            .unwrap()
+    });
+    result
+}
+
+#[test]
+fn validate_signer_key_sigs() {
+    let (epochs, pox_constants) = make_test_epochs_pox();
+
+    let mut burnchain = Burnchain::default_unittest(
+        0,
+        &BurnchainHeaderHash::from_hex(BITCOIN_REGTEST_FIRST_BLOCK_HASH).unwrap(),
+    );
+    burnchain.pox_constants = pox_constants.clone();
+
+    let observer = TestEventObserver::new();
+
+    let (mut peer, mut keys) = instantiate_pox_peer_with_epoch(
+        &burnchain,
+        function_name!(),
+        Some(epochs.clone()),
+        Some(&observer),
+    );
+
+    assert_eq!(burnchain.pox_constants.reward_slots(), 6);
+    let mut coinbase_nonce = 0;
+    let mut latest_block;
+
+    // alice
+    let alice = keys.pop().unwrap();
+    let alice_address = key_to_stacks_addr(&alice);
+    let alice_principal = PrincipalData::from(alice_address.clone());
+
+    // bob
+    let bob = keys.pop().unwrap();
+    let bob_address = key_to_stacks_addr(&bob);
+    let bob_principal = PrincipalData::from(bob_address.clone());
+    let bob_pox_addr = make_pox_addr(AddressHashMode::SerializeP2PKH, bob_address.bytes.clone());
+    let bob_public_key = StacksPublicKey::from_private(&bob);
+
+    // Advance into pox4
+    let target_height = burnchain.pox_constants.pox_4_activation_height;
+    // produce blocks until the first reward phase that everyone should be in
+    while get_tip(peer.sortdb.as_ref()).block_height < u64::from(target_height) {
+        latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+    }
+
+    latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
+
+    let reward_cycle = get_current_reward_cycle(&peer, &burnchain);
+
+    let expected_error = Value::error(Value::Int(35)).unwrap();
+
+    // Test 1: invalid block-height used in signature
+
+    let last_reward_cycle = reward_cycle - 1;
+    let signature = make_signer_key_signature(&alice_principal, &bob, last_reward_cycle);
+
+    let result = validate_signer_key_sig(
+        &signature,
+        &bob_public_key,
+        &alice_principal,
+        &mut peer,
+        &burnchain,
+        &mut coinbase_nonce,
+        &latest_block,
+    );
+    assert_eq!(result, expected_error);
+
+    // Test 2: Invalid stacker used in signature
+
+    let signature = make_signer_key_signature(&bob_principal, &bob, reward_cycle);
+
+    let result = validate_signer_key_sig(
+        &signature,
+        &bob_public_key,
+        &alice_principal, // different stacker
+        &mut peer,
+        &burnchain,
+        &mut coinbase_nonce,
+        &latest_block,
+    );
+
+    assert_eq!(result, expected_error);
+
+    // Test 3: Invalid signer key used in signature
+
+    let signature = make_signer_key_signature(&alice_principal, &alice, reward_cycle);
+
+    let result = validate_signer_key_sig(
+        &signature,
+        &bob_public_key, // different key
+        &alice_principal,
+        &mut peer,
+        &burnchain,
+        &mut coinbase_nonce,
+        &latest_block,
+    );
+
+    assert_eq!(result, expected_error);
+
+    // Test 4: using a valid signature
+
+    // println!("Reward cycle: {}", reward_cycle);
+    // let reward_cycle = get_current_reward_cycle(&peer, &burnchain);
+    // println!("Reward cycle: {}", reward_cycle);
+    // // println!("")
+
+    let signature = make_signer_key_signature(&alice_principal, &bob, reward_cycle);
+
+    let result = validate_signer_key_sig(
+        &signature,
+        &bob_public_key,
+        &alice_principal,
+        &mut peer,
+        &burnchain,
+        &mut coinbase_nonce,
+        &latest_block,
+    );
+
+    assert_eq!(result, Value::okay_true());
+}
+
 pub fn assert_latest_was_burn(peer: &mut TestPeer) {
     let tip = get_tip(peer.sortdb.as_ref());
     let tip_index_block = tip.get_canonical_stacks_block_id();
@@ -1824,6 +2008,13 @@ fn delegate_stack_stx_extend_signer_key() {
     )
     .expect("No stacking state, stack-stx failed")
     .expect_tuple();
+    let delegation_state = get_delegation_state_pox_4(&mut peer, &latest_block, &alice_principal)
+        .expect("No delegation state, delegate-stx failed")
+        .expect_tuple();
+
+    let stacking_state = get_stacking_state_pox_4(&mut peer, &latest_block, &alice_principal)
+        .expect("No stacking state, stack-stx failed")
+        .expect_tuple();
 
     let next_reward_cycle = 1 + burnchain
         .block_height_to_reward_cycle(block_height)
@@ -1885,13 +2076,9 @@ fn delegate_stack_stx_extend_signer_key() {
     let txs = vec![delegate_stack_extend, agg_tx_0, agg_tx_1];
 
     let latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
-    let new_stacking_state = get_stacking_state_pox_4(
-        &mut peer,
-        &latest_block,
-        &key_to_stacks_addr(alice_stacker_key).to_account_principal(),
-    )
-    .unwrap()
-    .expect_tuple();
+    let new_stacking_state = get_stacking_state_pox_4(&mut peer, &latest_block, &alice_principal)
+        .unwrap()
+        .expect_tuple();
 
     let reward_cycle_ht = burnchain.reward_cycle_to_block_height(next_reward_cycle);
     let extend_cycle_ht = burnchain.reward_cycle_to_block_height(extend_cycle);

From ed61fce416cddc37e92b99035d8f5964ec2f6ac7 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Wed, 24 Jan 2024 09:21:00 -0800
Subject: [PATCH 0579/1166] feat: validate signer-key in stack-stx

---
 .../chainstate/nakamoto/coordinator/tests.rs  | 11 ++-
 stackslib/src/chainstate/stacks/boot/mod.rs   | 15 +++
 .../src/chainstate/stacks/boot/pox-4.clar     |  4 +
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 93 +++++++++++++++----
 4 files changed, 103 insertions(+), 20 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index 551348bffc..2564417845 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -36,7 +36,7 @@ use crate::chainstate::nakamoto::tests::node::{TestSigners, TestStacker};
 use crate::chainstate::nakamoto::{NakamotoBlock, NakamotoChainState};
 use crate::chainstate::stacks::address::PoxAddress;
 use crate::chainstate::stacks::boot::test::{
-    key_to_stacks_addr, make_pox_4_aggregate_key, make_pox_4_lockup,
+    key_to_stacks_addr, make_pox_4_aggregate_key, make_pox_4_lockup, make_signer_key_signature,
 };
 use crate::chainstate::stacks::boot::MINERS_NAME;
 use crate::chainstate::stacks::db::{MinerPaymentTxFees, StacksAccount, StacksChainState};
@@ -75,6 +75,14 @@ fn advance_to_nakamoto(
             test_stackers
                 .iter()
                 .map(|test_stacker| {
+                    let reward_cycle = 6;
+                    let stacker =
+                        PrincipalData::from(key_to_stacks_addr(&test_stacker.stacker_private_key));
+                    let signature = make_signer_key_signature(
+                        &stacker,
+                        &test_stacker.signer_private_key,
+                        reward_cycle,
+                    );
                     make_pox_4_lockup(
                         &test_stacker.stacker_private_key,
                         0,
@@ -86,6 +94,7 @@ fn advance_to_nakamoto(
                         12,
                         StacksPublicKey::from_private(&test_stacker.signer_private_key),
                         34,
+                        signature,
                     )
                 })
                 .collect()
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index f577243c3a..0bc6d9a6b7 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -1891,6 +1891,7 @@ pub mod test {
         lock_period: u128,
         signer_key: StacksPublicKey,
         burn_ht: u64,
+        signature: Vec<u8>,
     ) -> StacksTransaction {
         let addr_tuple = Value::Tuple(addr.as_clarity_tuple().unwrap());
         let payload = TransactionPayload::new_contract_call(
@@ -1902,6 +1903,7 @@ pub mod test {
                 addr_tuple,
                 Value::UInt(burn_ht as u128),
                 Value::UInt(lock_period),
+                Value::buff_from(signature).unwrap(),
                 Value::buff_from(signer_key.to_bytes_compressed()).unwrap(),
             ],
         )
@@ -2237,6 +2239,19 @@ pub mod test {
 
         let signature = sign_structured_data(data_tuple, domain_tuple, signer_key).unwrap();
 
+        {
+            // debugging
+            let key_hex = signer_key.to_hex();
+            let sig_hex = to_hex(&signature.to_rsv());
+            println!(
+                "\n\nDebugging signatures: {} {} {} {}\n\n",
+                stacker.to_string(),
+                reward_cycle,
+                sig_hex,
+                key_hex
+            );
+        }
+
         signature.to_rsv()
     }
 
diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index c5d333035a..ec9b1c4e0d 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -572,6 +572,7 @@
                           (pox-addr (tuple (version (buff 1)) (hashbytes (buff 32))))
                           (start-burn-ht uint)
                           (lock-period uint)
+                          (signer-sig (buff 65))
                           (signer-key (buff 33)))
     ;; this stacker's first reward cycle is the _next_ reward cycle
     (let ((first-reward-cycle (+ u1 (current-pox-reward-cycle)))
@@ -597,6 +598,9 @@
       (asserts! (>= (stx-get-balance tx-sender) amount-ustx)
         (err ERR_STACKING_INSUFFICIENT_FUNDS))
 
+      ;; Validate ownership of the given signer key
+      (try! (verify-signing-key-signature tx-sender signer-key signer-sig))
+
       ;; ensure that stacking can be performed
       (try! (can-stack-stx pox-addr amount-ustx first-reward-cycle lock-period))
 
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index b6654f9e60..8fa227eb8a 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -481,6 +481,14 @@ fn pox_extend_transition() {
     }
 
     let tip = get_tip(peer.sortdb.as_ref());
+
+    let alice_signer_private = Secp256k1PrivateKey::new();
+    let alice_signer_key = Secp256k1PublicKey::from_private(&alice_signer_private);
+
+    let reward_cycle = get_current_reward_cycle(&peer, &burnchain);
+
+    let alice_signature =
+        make_signer_key_signature(&alice_principal, &alice_signer_private, reward_cycle);
     let alice_lockup = make_pox_4_lockup(
         &alice,
         2,
@@ -490,8 +498,9 @@ fn pox_extend_transition() {
             key_to_stacks_addr(&alice).bytes,
         ),
         4,
-        StacksPublicKey::default(),
+        alice_signer_key,
         tip.block_height,
+        alice_signature,
     );
     let alice_pox_4_lock_nonce = 2;
     let alice_first_pox_4_unlock_height =
@@ -535,16 +544,29 @@ fn pox_extend_transition() {
         latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
     }
 
-    let bob_signer_key: [u8; 33] = [
-        0x02, 0xb6, 0x19, 0x6d, 0xe8, 0x8b, 0xce, 0xe7, 0x93, 0xfa, 0x9a, 0x8a, 0x85, 0x96, 0x9b,
-        0x64, 0x7f, 0x84, 0xc9, 0x0e, 0x9d, 0x13, 0xf9, 0xc8, 0xb8, 0xce, 0x42, 0x6c, 0xc8, 0x1a,
-        0x59, 0x98, 0x3c,
-    ];
-    let alice_signer_key: [u8; 33] = [
-        0x03, 0xa0, 0xf9, 0x81, 0x8e, 0xa8, 0xc1, 0x4a, 0x82, 0x7b, 0xb1, 0x44, 0xae, 0xc9, 0xcf,
-        0xba, 0xeb, 0xa2, 0x25, 0xaf, 0x22, 0xbe, 0x18, 0xed, 0x78, 0xa2, 0xf2, 0x98, 0x10, 0x6f,
-        0x4e, 0x28, 0x1b,
-    ];
+    let bob_signer_private = Secp256k1PrivateKey::new();
+    let bob_signer_key = Secp256k1PublicKey::from_private(&bob_signer_private);
+
+    // let bob_signer_key: [u8; 33] = [
+    //     0x02, 0xb6, 0x19, 0x6d, 0xe8, 0x8b, 0xce, 0xe7, 0x93, 0xfa, 0x9a, 0x8a, 0x85, 0x96, 0x9b,
+    //     0x64, 0x7f, 0x84, 0xc9, 0x0e, 0x9d, 0x13, 0xf9, 0xc8, 0xb8, 0xce, 0x42, 0x6c, 0xc8, 0x1a,
+    //     0x59, 0x98, 0x3c,
+    // ];
+    // let alice_signer_key: [u8; 33] = [
+    //     0x03, 0xa0, 0xf9, 0x81, 0x8e, 0xa8, 0xc1, 0x4a, 0x82, 0x7b, 0xb1, 0x44, 0xae, 0xc9, 0xcf,
+    //     0xba, 0xeb, 0xa2, 0x25, 0xaf, 0x22, 0xbe, 0x18, 0xed, 0x78, 0xa2, 0xf2, 0x98, 0x10, 0x6f,
+    //     0x4e, 0x28, 0x1b,
+    // ];
+
+    let alice_signer_private = Secp256k1PrivateKey::new();
+    let alice_signer_key = Secp256k1PublicKey::from_private(&alice_signer_private);
+
+    let reward_cycle = get_current_reward_cycle(&peer, &burnchain);
+
+    let bob_signature =
+        make_signer_key_signature(&bob_principal, &bob_signer_private, reward_cycle);
+    let alice_signature =
+        make_signer_key_signature(&alice_principal, &alice_signer_private, reward_cycle);
 
     let tip = get_tip(peer.sortdb.as_ref());
     let bob_lockup = make_pox_4_lockup(
@@ -556,8 +578,9 @@ fn pox_extend_transition() {
             key_to_stacks_addr(&bob).bytes,
         ),
         3,
-        StacksPublicKey::from_slice(&bob_signer_key).unwrap(),
+        StacksPublicKey::from_private(&bob_signer_private),
         tip.block_height,
+        bob_signature,
     );
 
     // Alice can stack-extend in PoX v2
@@ -569,7 +592,7 @@ fn pox_extend_transition() {
             key_to_stacks_addr(&alice).bytes,
         ),
         6,
-        StacksPublicKey::from_slice(&alice_signer_key).unwrap(),
+        StacksPublicKey::from_private(&alice_signer_private),
     );
 
     let alice_pox_4_extend_nonce = 3;
@@ -812,6 +835,7 @@ fn pox_lock_unlock() {
 
     let mut txs = vec![];
     let tip_height = get_tip(peer.sortdb.as_ref()).block_height;
+    let reward_cycle = burnchain.block_height_to_reward_cycle(tip_height).unwrap() as u128;
     let stackers: Vec<_> = keys
         .iter()
         .zip([
@@ -824,14 +848,19 @@ fn pox_lock_unlock() {
         .map(|(ix, (key, hash_mode))| {
             let pox_addr = PoxAddress::from_legacy(hash_mode, key_to_stacks_addr(key).bytes);
             let lock_period = if ix == 3 { 12 } else { lock_period };
+            let signer_key = key;
+            let signer_public = Secp256k1PublicKey::from_private(&signer_key);
+            let stacker = PrincipalData::from(key_to_stacks_addr(key));
+            let signature = make_signer_key_signature(&stacker, &signer_key, reward_cycle);
             txs.push(make_pox_4_lockup(
                 key,
                 0,
                 1024 * POX_THRESHOLD_STEPS_USTX,
                 pox_addr.clone(),
                 lock_period,
-                StacksPublicKey::default(),
+                StacksPublicKey::from_private(&signer_key),
                 tip_height,
+                signature,
             ));
             pox_addr
         })
@@ -1674,6 +1703,14 @@ fn stack_stx_signer_key() {
     let stacker_nonce = 0;
     let stacker_key = &keys[0];
     let min_ustx = get_stacking_minimum(&mut peer, &latest_block);
+    let stacker = PrincipalData::from(key_to_stacks_addr(stacker_key));
+    let signer_key = &keys[1];
+    let signer_public_key = StacksPublicKey::from_private(signer_key);
+    let signer_key_val = Value::buff_from(signer_public_key.to_bytes_compressed()).unwrap();
+
+    let reward_cycle = get_current_reward_cycle(&peer, &burnchain);
+
+    let signature = make_signer_key_signature(&stacker, &signer_key, reward_cycle);
 
     // (define-public (stack-stx (amount-ustx uint)
     //                       (pox-addr (tuple (version (buff 1)) (hashbytes (buff 32))))
@@ -1685,10 +1722,10 @@ fn stack_stx_signer_key() {
         key_to_stacks_addr(stacker_key).bytes,
     );
 
-    let signer_bytes =
-        hex_bytes("03a0f9818ea8c14a827bb144aec9cfbaeba225af22be18ed78a2f298106f4e281b").unwrap();
-    let signer_key = Secp256k1PublicKey::from_slice(&signer_bytes).unwrap();
-    let signer_key_val = Value::buff_from(signer_bytes.clone()).unwrap();
+    // let signer_bytes =
+    //     hex_bytes("03a0f9818ea8c14a827bb144aec9cfbaeba225af22be18ed78a2f298106f4e281b").unwrap();
+    // let signer_key = Secp256k1PublicKey::from_slice(&signer_bytes).unwrap();
+    // let signer_key_val = Value::buff_from(signer_bytes.clone()).unwrap();
 
     let txs = vec![make_pox_4_contract_call(
         stacker_key,
@@ -1699,6 +1736,7 @@ fn stack_stx_signer_key() {
             pox_addr.clone(),
             Value::UInt(block_height as u128),
             Value::UInt(2),
+            Value::buff_from(signature.clone()).unwrap(),
             signer_key_val.clone(),
         ],
     )];
@@ -1723,7 +1761,10 @@ fn stack_stx_signer_key() {
         PoxAddress::try_from_pox_tuple(false, &pox_addr).unwrap(),
         reward_entry.reward_address
     );
-    assert_eq!(&reward_entry.signer.unwrap(), &signer_bytes.as_slice());
+    assert_eq!(
+        &reward_entry.signer.unwrap(),
+        &signer_public_key.to_bytes_compressed().as_slice(),
+    );
 }
 
 #[test]
@@ -1734,6 +1775,7 @@ fn stack_extend_signer_key() {
 
     let mut stacker_nonce = 0;
     let stacker_key = &keys[0];
+    let stacker = PrincipalData::from(key_to_stacks_addr(stacker_key));
     let min_ustx = get_stacking_minimum(&mut peer, &latest_block) * 2;
 
     let pox_addr = make_pox_addr(
@@ -1755,6 +1797,13 @@ fn stack_extend_signer_key() {
     let next_reward_cycle = 1 + burnchain
         .block_height_to_reward_cycle(block_height)
         .unwrap();
+    // let signer_key = &keys[1];
+    // let signer_public_key = StacksPublicKey::from_private(signer_key);
+    // let signer_key_val = Value::buff_from(signer_public_key.to_bytes_compressed()).unwrap();
+
+    let reward_cycle = get_current_reward_cycle(&peer, &burnchain);
+
+    let signature = make_signer_key_signature(&stacker, &signer_sk, reward_cycle);
 
     let txs = vec![make_pox_4_contract_call(
         stacker_key,
@@ -1765,6 +1814,7 @@ fn stack_extend_signer_key() {
             pox_addr.clone(),
             Value::UInt(block_height as u128),
             Value::UInt(2),
+            Value::buff_from(signature.clone()).unwrap(),
             signer_key_val.clone(),
         ],
     )];
@@ -2126,6 +2176,10 @@ fn stack_increase() {
         key_to_stacks_addr(alice_stacking_private_key).bytes,
     );
 
+    let alice_stacker = PrincipalData::from(alice_address.clone());
+    let reward_cycle = get_current_reward_cycle(&peer, &burnchain);
+    let signature = make_signer_key_signature(&alice_stacker, &signing_sk, reward_cycle);
+
     let stack_stx = make_pox_4_lockup(
         alice_stacking_private_key,
         alice_nonce,
@@ -2134,6 +2188,7 @@ fn stack_increase() {
         lock_period,
         signing_pk,
         block_height as u64,
+        signature,
     );
 
     // Initial tx arr includes a stack_stx pox_4 helper found in mod.rs

From 11b46abd6f83ac21b305605ee0bda8baab2f514a Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Wed, 24 Jan 2024 10:11:50 -0800
Subject: [PATCH 0580/1166] feat: add signer-sig to stack-extend

---
 stackslib/src/chainstate/stacks/boot/mod.rs   |  15 +-
 .../src/chainstate/stacks/boot/pox-4.clar     |  51 ++-
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 364 +++++++++++++-----
 .../src/util_lib/signed_structured_data.rs    |  16 +
 .../src/tests/nakamoto_integrations.rs        |  81 +++-
 testnet/stacks-node/src/tests/signer.rs       |   8 +-
 6 files changed, 402 insertions(+), 133 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 0bc6d9a6b7..7e7f0a51ea 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -2042,6 +2042,7 @@ pub mod test {
         addr: PoxAddress,
         lock_period: u128,
         signer_key: StacksPublicKey,
+        signature: Vec<u8>,
     ) -> StacksTransaction {
         let addr_tuple = Value::Tuple(addr.as_clarity_tuple().unwrap());
         let payload = TransactionPayload::new_contract_call(
@@ -2051,6 +2052,7 @@ pub mod test {
             vec![
                 Value::UInt(lock_period),
                 addr_tuple,
+                Value::buff_from(signature).unwrap(),
                 Value::buff_from(signer_key.to_bytes_compressed()).unwrap(),
             ],
         )
@@ -2239,19 +2241,6 @@ pub mod test {
 
         let signature = sign_structured_data(data_tuple, domain_tuple, signer_key).unwrap();
 
-        {
-            // debugging
-            let key_hex = signer_key.to_hex();
-            let sig_hex = to_hex(&signature.to_rsv());
-            println!(
-                "\n\nDebugging signatures: {} {} {} {}\n\n",
-                stacker.to_string(),
-                reward_cycle,
-                sig_hex,
-                key_hex
-            );
-        }
-
         signature.to_rsv()
     }
 
diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index ec9b1c4e0d..5afc6c2b9f 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -30,7 +30,8 @@
 (define-constant ERR_INVALID_SIGNER_KEY 32)
 (define-constant ERR_REUSED_SIGNER_KEY 33)
 (define-constant ERR_DELEGATION_ALREADY_REVOKED 34)
-(define-constant ERR_DELEGATION_INVALID_SIGNATURE (err 35))
+(define-constant ERR_INVALID_SIGNATURE_PUBKEY 35)
+(define-constant ERR_INVALID_SIGNATURE_RECOVER 36)
 
 ;; Valid values for burnchain address versions.
 ;; These first four correspond to address hash modes in Stacks 2.1,
@@ -67,6 +68,9 @@
 ;; Stacking thresholds
 (define-constant STACKING_THRESHOLD_25 (if is-in-mainnet u20000 u8000))
 
+;; SIP18 message prefix
+(define-constant SIP018_MSG_PREFIX 0x534950303138)
+
 ;; Data vars that store a copy of the burnchain configuration.
 ;; Implemented as data-vars, so that different configurations can be
 ;; used in e.g. test harnesses.
@@ -195,7 +199,7 @@
 ;; partial-stacked-by-cycle right after it was deleted (so, subsequent calls
 ;; to the `stack-aggregation-*` functions will overwrite this).
 (define-map logged-partial-stacked-by-cycle
-    { 
+    {
         pox-addr: { version: (buff 1), hashbytes: (buff 32) },
         reward-cycle: uint,
         sender: principal
@@ -599,7 +603,7 @@
         (err ERR_STACKING_INSUFFICIENT_FUNDS))
 
       ;; Validate ownership of the given signer key
-      (try! (verify-signing-key-signature tx-sender signer-key signer-sig))
+      (try! (verify-signer-key-sig tx-sender signer-sig signer-key))
 
       ;; ensure that stacking can be performed
       (try! (can-stack-stx pox-addr amount-ustx first-reward-cycle lock-period))
@@ -641,7 +645,7 @@
                              (delegate-to principal)
                              (until-burn-ht (optional uint))
                              (pox-addr (optional { version: (buff 1), hashbytes: (buff 32) })))
-                             
+
     (begin
       ;; must be called directly by the tx-sender or by an allowed contract-caller
       (asserts! (check-caller-allowed)
@@ -676,39 +680,42 @@
 
       (ok true)))
 
-;; Generate a message hash following the SIP018 standard.
-(define-read-only (get-signer-key-message-hash (signer-key (buff 33)) (stacker principal))
+;; Generate a message hash for validating a signer key.
+;; The message hash follows SIP018 for signing structured data. The structured data
+;; is the tuple `{ stacker, reward-cycle }`. The domain is
+;; `{ name: "pox-4-signer", version: "1.0.0", chain-id: chain-id }`.
+(define-read-only (get-signer-key-message-hash (stacker principal))
   (let
     (
       (domain { name: "pox-4-signer", version: "1.0.0", chain-id: chain-id })
-      (data-hash (sha256 (unwrap-panic 
+      (data-hash (sha256 (unwrap-panic
         (to-consensus-buff? { stacker: stacker, reward-cycle: (current-pox-reward-cycle) }))))
       (domain-hash (sha256 (unwrap-panic (to-consensus-buff? domain))))
     )
     (sha256 (concat
-      0x534950303138
+      SIP018_MSG_PREFIX
       (concat domain-hash
       data-hash)))
   )
 )
 
 ;; Verify a signature from the signing key for this specific stacker.
-;; The message hash is the sha256 of the consensus hash of the tuple 
-;; `{ stacker, reward-cycle }`. Note that `reward-cycle` corresponds to the
-;; _current_ reward cycle, not the reward cycle at which the delegation will start.
-;; The public key is recovered from the signature and compared to the pubkey hash
-;; of the delegator.
-(define-read-only (verify-signing-key-signature (stacker principal)
-                                                (signing-key (buff 33))
-                                                (signer-sig (buff 65)))
+;; See `get-signer-key-message-hash` for details on the message hash.
+;;
+;; Note that `reward-cycle` corresponds to the _current_ reward cycle,
+;; not the reward cycle at which the delegation will start.
+;; The public key is recovered from the signature and compared to `signer-key`.
+(define-read-only (verify-signer-key-sig (stacker principal)
+                                         (signer-sig (buff 65))
+                                         (signer-key (buff 33)))
   (let
     (
-      (msg-hash (get-signer-key-message-hash signing-key stacker))
-      (pubkey (unwrap! (secp256k1-recover? msg-hash signer-sig) ERR_DELEGATION_INVALID_SIGNATURE)) ;; TODO
+      (msg-hash (get-signer-key-message-hash stacker))
+      (pubkey (unwrap! (secp256k1-recover? msg-hash signer-sig) (err ERR_INVALID_SIGNATURE_RECOVER)))
     )
-    (asserts! (is-eq pubkey signing-key) ERR_DELEGATION_INVALID_SIGNATURE)
+    (asserts! (is-eq pubkey signer-key) (err ERR_INVALID_SIGNATURE_PUBKEY))
     (ok true)
-  )                                            
+  )
 )
 
 ;; Commit partially stacked STX and allocate a new PoX reward address slot.
@@ -1023,6 +1030,7 @@
 ;;    used for signing. The `tx-sender` can thus decide to change the key when extending.
 (define-public (stack-extend (extend-count uint)
                              (pox-addr { version: (buff 1), hashbytes: (buff 32) })
+                             (signer-sig (buff 65))
                              (signer-key (buff 33)))
    (let ((stacker-info (stx-account tx-sender))
          ;; to extend, there must already be an etry in the stacking-state
@@ -1048,6 +1056,9 @@
     (asserts! (is-none (get delegated-to stacker-state))
               (err ERR_STACKING_IS_DELEGATED))
 
+    ;; Verify signature from delegate that allows this sender for this cycle
+    (try! (verify-signer-key-sig tx-sender signer-sig signer-key))
+
     ;; TODO: add more assertions to sanity check the `stacker-info` values with
     ;;       the `stacker-state` values
 
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 8fa227eb8a..8593eebd8b 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -480,6 +480,14 @@ fn pox_extend_transition() {
         latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
     }
 
+    // Key 3
+    let alice_signer_private = keys.pop().unwrap();
+    let alice_signer_key = StacksPublicKey::from_private(&alice_signer_private);
+    let reward_cycle = get_current_reward_cycle(&peer, &burnchain);
+
+    let alice_signature =
+        make_signer_key_signature(&alice_principal, &alice_signer_private, reward_cycle);
+
     let tip = get_tip(peer.sortdb.as_ref());
 
     let alice_signer_private = Secp256k1PrivateKey::new();
@@ -583,6 +591,13 @@ fn pox_extend_transition() {
         bob_signature,
     );
 
+    // new signing key needed
+    let alice_signer_private = Secp256k1PrivateKey::default();
+    let alice_signer_key = StacksPublicKey::from_private(&alice_signer_private);
+
+    let alice_signature =
+        make_signer_key_signature(&alice_principal, &alice_signer_private, reward_cycle);
+
     // Alice can stack-extend in PoX v2
     let alice_lockup = make_pox_4_extend(
         &alice,
@@ -592,7 +607,8 @@ fn pox_extend_transition() {
             key_to_stacks_addr(&alice).bytes,
         ),
         6,
-        StacksPublicKey::from_private(&alice_signer_private),
+        alice_signer_key,
+        alice_signature,
     );
 
     let alice_pox_4_extend_nonce = 3;
@@ -654,7 +670,6 @@ fn pox_extend_transition() {
         for r in b.receipts.into_iter() {
             if let TransactionOrigin::Stacks(ref t) = r.transaction {
                 let addr = t.auth.origin().address_testnet();
-                eprintln!("TX addr: {}", addr);
                 if addr == alice_address {
                     alice_txs.insert(t.auth.get_origin_nonce(), r);
                 } else if addr == bob_address {
@@ -849,7 +864,6 @@ fn pox_lock_unlock() {
             let pox_addr = PoxAddress::from_legacy(hash_mode, key_to_stacks_addr(key).bytes);
             let lock_period = if ix == 3 { 12 } else { lock_period };
             let signer_key = key;
-            let signer_public = Secp256k1PublicKey::from_private(&signer_key);
             let stacker = PrincipalData::from(key_to_stacks_addr(key));
             let signature = make_signer_key_signature(&stacker, &signer_key, reward_cycle);
             txs.push(make_pox_4_lockup(
@@ -1281,7 +1295,6 @@ fn pox_4_revoke_delegate_stx_events() {
     let bob = keys.pop().unwrap();
     let bob_address = key_to_stacks_addr(&bob);
     let bob_principal = PrincipalData::from(bob_address.clone());
-    let bob_pox_addr = make_pox_addr(AddressHashMode::SerializeP2PKH, bob_address.bytes.clone());
 
     // steph the solo stacker stacks stx so nakamoto signer set stays stacking.
     let steph = keys.pop().unwrap();
@@ -1323,7 +1336,6 @@ fn pox_4_revoke_delegate_stx_events() {
 
     // alice delegates 100 STX to Bob
     let alice_delegation_amount = 100_000_000;
-    let alice_delegate_nonce = alice_nonce;
     let alice_delegate = make_pox_4_delegate_stx(
         &alice,
         alice_nonce,
@@ -1331,7 +1343,6 @@ fn pox_4_revoke_delegate_stx_events() {
         bob_principal,
         None,
         None,
-        // &signature,
     );
     let alice_delegate_nonce = alice_nonce;
     alice_nonce += 1;
@@ -1359,7 +1370,6 @@ fn pox_4_revoke_delegate_stx_events() {
         PrincipalData::from(bob_address.clone()),
         Some(target_height as u128),
         None,
-        // &signature,
     );
     let alice_delegate_2_nonce = alice_nonce;
     alice_nonce += 1;
@@ -1437,43 +1447,11 @@ fn pox_4_revoke_delegate_stx_events() {
     );
 }
 
-fn generate_signer_key_sig_msg_hash(
-    stacker: &PrincipalData,
-    signer_key: &Secp256k1PrivateKey,
-    reward_cycle: u128,
-) -> Sha256Sum {
-    let domain_tuple = Value::Tuple(
-        TupleData::from_data(vec![
-            (
-                "name".into(),
-                Value::string_ascii_from_bytes("pox-4-signer".into()).unwrap(),
-            ),
-            (
-                "version".into(),
-                Value::string_ascii_from_bytes("1.0.0".into()).unwrap(),
-            ),
-            ("chain-id".into(), Value::UInt(CHAIN_ID_TESTNET.into())),
-        ])
-        .unwrap(),
-    );
-    let data_tuple = Value::Tuple(
-        TupleData::from_data(vec![
-            ("stacker".into(), Value::Principal(stacker.clone())),
-            ("reward-cycle".into(), Value::UInt(reward_cycle)),
-        ])
-        .unwrap(),
-    );
-
-    structured_data_message_hash(data_tuple, domain_tuple)
-}
-
-fn validate_signer_key_sig(
+fn verify_signer_key_sig(
     signature: &Vec<u8>,
     signing_key: &Secp256k1PublicKey,
     stacker: &PrincipalData,
     peer: &mut TestPeer,
-    burnchain: &Burnchain,
-    coinbase_nonce: &mut usize,
     latest_block: &StacksBlockId,
 ) -> Value {
     let result: Value = with_sortdb(peer, |ref mut chainstate, ref mut sortdb| {
@@ -1489,10 +1467,10 @@ fn validate_signer_key_sig(
                         LimitedCostTracker::new_free(),
                         |env| {
                             let program = format!(
-                                "(verify-signing-key-signature '{} 0x{} 0x{})",
+                                "(verify-signer-key-sig '{} 0x{} 0x{})",
                                 stacker.to_string(),
-                                signing_key.to_hex(),
                                 to_hex(&signature),
+                                signing_key.to_hex(),
                             );
                             env.eval_read_only(&boot_code_id("pox-4", false), &program)
                         },
@@ -1505,7 +1483,7 @@ fn validate_signer_key_sig(
 }
 
 #[test]
-fn validate_signer_key_sigs() {
+fn verify_signer_key_signatures() {
     let (epochs, pox_constants) = make_test_epochs_pox();
 
     let mut burnchain = Burnchain::default_unittest(
@@ -1536,7 +1514,6 @@ fn validate_signer_key_sigs() {
     let bob = keys.pop().unwrap();
     let bob_address = key_to_stacks_addr(&bob);
     let bob_principal = PrincipalData::from(bob_address.clone());
-    let bob_pox_addr = make_pox_addr(AddressHashMode::SerializeP2PKH, bob_address.bytes.clone());
     let bob_public_key = StacksPublicKey::from_private(&bob);
 
     // Advance into pox4
@@ -1552,18 +1529,16 @@ fn validate_signer_key_sigs() {
 
     let expected_error = Value::error(Value::Int(35)).unwrap();
 
-    // Test 1: invalid block-height used in signature
+    // Test 1: invalid reward cycle used in signature
 
     let last_reward_cycle = reward_cycle - 1;
     let signature = make_signer_key_signature(&alice_principal, &bob, last_reward_cycle);
 
-    let result = validate_signer_key_sig(
+    let result = verify_signer_key_sig(
         &signature,
         &bob_public_key,
         &alice_principal,
         &mut peer,
-        &burnchain,
-        &mut coinbase_nonce,
         &latest_block,
     );
     assert_eq!(result, expected_error);
@@ -1572,13 +1547,11 @@ fn validate_signer_key_sigs() {
 
     let signature = make_signer_key_signature(&bob_principal, &bob, reward_cycle);
 
-    let result = validate_signer_key_sig(
+    let result = verify_signer_key_sig(
         &signature,
         &bob_public_key,
         &alice_principal, // different stacker
         &mut peer,
-        &burnchain,
-        &mut coinbase_nonce,
         &latest_block,
     );
 
@@ -1588,13 +1561,11 @@ fn validate_signer_key_sigs() {
 
     let signature = make_signer_key_signature(&alice_principal, &alice, reward_cycle);
 
-    let result = validate_signer_key_sig(
+    let result = verify_signer_key_sig(
         &signature,
         &bob_public_key, // different key
         &alice_principal,
         &mut peer,
-        &burnchain,
-        &mut coinbase_nonce,
         &latest_block,
     );
 
@@ -1602,26 +1573,241 @@ fn validate_signer_key_sigs() {
 
     // Test 4: using a valid signature
 
-    // println!("Reward cycle: {}", reward_cycle);
-    // let reward_cycle = get_current_reward_cycle(&peer, &burnchain);
-    // println!("Reward cycle: {}", reward_cycle);
-    // // println!("")
-
     let signature = make_signer_key_signature(&alice_principal, &bob, reward_cycle);
 
-    let result = validate_signer_key_sig(
+    let result = verify_signer_key_sig(
         &signature,
         &bob_public_key,
         &alice_principal,
         &mut peer,
-        &burnchain,
-        &mut coinbase_nonce,
         &latest_block,
     );
 
     assert_eq!(result, Value::okay_true());
 }
 
+#[test]
+fn stack_stx_verify_signer_sig() {
+    let lock_period = 2;
+    let observer = TestEventObserver::new();
+    let (burnchain, mut peer, keys, latest_block, block_height, coinbase_nonce) =
+        prepare_pox4_test(function_name!(), Some(&observer));
+
+    let mut coinbase_nonce = coinbase_nonce;
+
+    let mut stacker_nonce = 0;
+    let stacker_key = &keys[0];
+    let min_ustx = get_stacking_minimum(&mut peer, &latest_block);
+    let stacker_addr = key_to_stacks_addr(&stacker_key);
+    let stacker = PrincipalData::from(stacker_addr);
+    let signer_key = &keys[1];
+    let signer_public_key = StacksPublicKey::from_private(signer_key);
+    let pox_addr = pox_addr_from(&stacker_key);
+
+    let second_stacker = &keys[2];
+    let second_stacker_addr = key_to_stacks_addr(second_stacker);
+    let second_stacker_principal = PrincipalData::from(second_stacker_addr);
+
+    let reward_cycle = get_current_reward_cycle(&peer, &burnchain);
+
+    // Test 1: invalid reward cycle
+    let signature = make_signer_key_signature(&stacker, &signer_key, reward_cycle - 1);
+    let invalid_cycle_nonce = stacker_nonce;
+    let invalid_cycle_stack = make_pox_4_lockup(
+        &stacker_key,
+        stacker_nonce,
+        min_ustx,
+        pox_addr.clone(),
+        lock_period,
+        signer_public_key.clone(),
+        block_height,
+        signature,
+    );
+
+    // test 2: invalid stacker
+    stacker_nonce += 1;
+    let signature = make_signer_key_signature(&second_stacker_principal, &signer_key, reward_cycle);
+    let invalid_stacker_nonce = stacker_nonce;
+    let invalid_stacker_tx = make_pox_4_lockup(
+        &stacker_key,
+        stacker_nonce,
+        min_ustx,
+        pox_addr.clone(),
+        lock_period,
+        signer_public_key.clone(),
+        block_height,
+        signature,
+    );
+
+    // Test 3: invalid key used to sign
+    stacker_nonce += 1;
+    let signature = make_signer_key_signature(&stacker, &second_stacker, reward_cycle);
+    let invalid_key_nonce = stacker_nonce;
+    let invalid_key_tx = make_pox_4_lockup(
+        &stacker_key,
+        stacker_nonce,
+        min_ustx,
+        pox_addr.clone(),
+        lock_period,
+        signer_public_key.clone(),
+        block_height,
+        signature,
+    );
+
+    // Test 4: valid signature
+    stacker_nonce += 1;
+    let signature = make_signer_key_signature(&stacker, &signer_key, reward_cycle);
+    let valid_nonce = stacker_nonce;
+    let valid_tx = make_pox_4_lockup(
+        &stacker_key,
+        stacker_nonce,
+        min_ustx,
+        pox_addr,
+        lock_period,
+        signer_public_key.clone(),
+        block_height,
+        signature,
+    );
+
+    let txs = vec![
+        invalid_cycle_stack,
+        invalid_stacker_tx,
+        invalid_key_tx,
+        valid_tx,
+    ];
+
+    peer.tenure_with_txs(&txs, &mut coinbase_nonce);
+
+    let stacker_txs = get_last_block_sender_transactions(&observer, stacker_addr);
+    let expected_error = Value::error(Value::Int(35)).unwrap();
+
+    assert_eq!(stacker_txs.len(), (valid_nonce + 1) as usize);
+    let tx_result =
+        |nonce: u64| -> Value { stacker_txs.get(nonce as usize).unwrap().result.clone() };
+    assert_eq!(tx_result(invalid_cycle_nonce), expected_error);
+    assert_eq!(tx_result(invalid_stacker_nonce), expected_error);
+    assert_eq!(tx_result(invalid_key_nonce), expected_error);
+
+    // valid tx should succeed
+    tx_result(valid_nonce).expect_result_ok();
+}
+
+#[test]
+fn stack_extend_verify_sig() {
+    let lock_period = 2;
+    let observer = TestEventObserver::new();
+    let (burnchain, mut peer, keys, latest_block, block_height, coinbase_nonce) =
+        prepare_pox4_test(function_name!(), Some(&observer));
+
+    let mut coinbase_nonce = coinbase_nonce;
+
+    let mut stacker_nonce = 0;
+    let stacker_key = &keys[0];
+    let min_ustx = get_stacking_minimum(&mut peer, &latest_block);
+    let stacker_addr = key_to_stacks_addr(&stacker_key);
+    let stacker = PrincipalData::from(stacker_addr);
+    let signer_key = &keys[1];
+    let signer_public_key = StacksPublicKey::from_private(signer_key);
+    let pox_addr = pox_addr_from(&signer_key);
+
+    let reward_cycle = get_current_reward_cycle(&peer, &burnchain);
+
+    // Setup: stack-stx
+    let signature = make_signer_key_signature(&stacker, &signer_key, reward_cycle);
+    let stack_nonce = stacker_nonce;
+    let stack_tx = make_pox_4_lockup(
+        &stacker_key,
+        stacker_nonce,
+        min_ustx,
+        pox_addr.clone(),
+        lock_period,
+        signer_public_key.clone(),
+        block_height,
+        signature,
+    );
+
+    // We need a new signer-key for the extend tx
+    let signer_key = Secp256k1PrivateKey::new();
+    let signer_public_key = StacksPublicKey::from_private(&signer_key);
+
+    // Test 1: invalid reward cycle
+    let signature = make_signer_key_signature(&stacker, &signer_key, reward_cycle - 1);
+    stacker_nonce += 1;
+    let invalid_cycle_nonce = stacker_nonce;
+    let invalid_cycle_tx = make_pox_4_extend(
+        &stacker_key,
+        stacker_nonce,
+        pox_addr.clone(),
+        lock_period,
+        signer_public_key.clone(),
+        signature,
+    );
+
+    // Test 2: invalid stacker
+    stacker_nonce += 1;
+    let other_stacker = PrincipalData::from(key_to_stacks_addr(&Secp256k1PrivateKey::new()));
+    let signature = make_signer_key_signature(&other_stacker, &signer_key, reward_cycle);
+    let invalid_stacker_nonce = stacker_nonce;
+    let invalid_stacker_tx = make_pox_4_extend(
+        &stacker_key,
+        stacker_nonce,
+        pox_addr.clone(),
+        lock_period,
+        signer_public_key.clone(),
+        signature,
+    );
+
+    // Test 3: invalid key used to sign
+    stacker_nonce += 1;
+    let other_key = Secp256k1PrivateKey::new();
+    let signature = make_signer_key_signature(&stacker, &other_key, reward_cycle);
+    let invalid_key_nonce = stacker_nonce;
+    let invalid_key_tx = make_pox_4_extend(
+        &stacker_key,
+        stacker_nonce,
+        pox_addr.clone(),
+        lock_period,
+        signer_public_key.clone(),
+        signature,
+    );
+
+    // Test 4: valid stack-extend
+    stacker_nonce += 1;
+    let signature = make_signer_key_signature(&stacker, &signer_key, reward_cycle);
+    let valid_nonce = stacker_nonce;
+    let valid_tx = make_pox_4_extend(
+        &stacker_key,
+        stacker_nonce,
+        pox_addr,
+        lock_period,
+        signer_public_key.clone(),
+        signature,
+    );
+
+    peer.tenure_with_txs(
+        &[
+            stack_tx,
+            invalid_cycle_tx,
+            invalid_stacker_tx,
+            invalid_key_tx,
+            valid_tx,
+        ],
+        &mut coinbase_nonce,
+    );
+
+    let stacker_txs = get_last_block_sender_transactions(&observer, stacker_addr);
+
+    let tx_result =
+        |nonce: u64| -> Value { stacker_txs.get(nonce as usize).unwrap().result.clone() };
+
+    let expected_error = Value::error(Value::Int(35)).unwrap();
+    tx_result(stack_nonce).expect_result_ok();
+    assert_eq!(tx_result(invalid_cycle_nonce), expected_error);
+    assert_eq!(tx_result(invalid_stacker_nonce), expected_error);
+    assert_eq!(tx_result(invalid_key_nonce), expected_error);
+    tx_result(valid_nonce).expect_result_ok();
+}
+
 pub fn assert_latest_was_burn(peer: &mut TestPeer) {
     let tip = get_tip(peer.sortdb.as_ref());
     let tip_index_block = tip.get_canonical_stacks_block_id();
@@ -1696,7 +1882,6 @@ fn balances_from_keys(
 
 #[test]
 fn stack_stx_signer_key() {
-    let lock_period = 2;
     let (burnchain, mut peer, keys, latest_block, block_height, mut coinbase_nonce) =
         prepare_pox4_test(function_name!(), None);
 
@@ -1778,7 +1963,11 @@ fn stack_extend_signer_key() {
     let stacker = PrincipalData::from(key_to_stacks_addr(stacker_key));
     let min_ustx = get_stacking_minimum(&mut peer, &latest_block) * 2;
 
-    let pox_addr = make_pox_addr(
+    let pox_addr = PoxAddress::from_legacy(
+        AddressHashMode::SerializeP2WSH,
+        key_to_stacks_addr(stacker_key).bytes,
+    );
+    let pox_addr_val = make_pox_addr(
         AddressHashMode::SerializeP2WSH,
         key_to_stacks_addr(stacker_key).bytes,
     );
@@ -1805,32 +1994,25 @@ fn stack_extend_signer_key() {
 
     let signature = make_signer_key_signature(&stacker, &signer_sk, reward_cycle);
 
-    let txs = vec![make_pox_4_contract_call(
-        stacker_key,
+    let txs = vec![make_pox_4_lockup(
+        &stacker_key,
         stacker_nonce,
-        "stack-stx",
-        vec![
-            Value::UInt(min_ustx),
-            pox_addr.clone(),
-            Value::UInt(block_height as u128),
-            Value::UInt(2),
-            Value::buff_from(signature.clone()).unwrap(),
-            signer_key_val.clone(),
-        ],
+        min_ustx,
+        pox_addr.clone(),
+        lock_period,
+        signer_key,
+        block_height,
+        signature,
     )];
 
     stacker_nonce += 1;
 
     let mut latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
-    let stacking_state = get_stacking_state_pox_4(
-        &mut peer,
-        &latest_block,
-        &key_to_stacks_addr(stacker_key).to_account_principal(),
-    )
-    .expect("No stacking state, stack-stx failed")
-    .expect_tuple();
 
-    // now stack-extend with a new signer-key
+    let signer_key_new = &keys[2];
+    let signer_public_key_new = StacksPublicKey::from_private(signer_key_new);
+
+    let signature = make_signer_key_signature(&stacker, &signer_extend_sk, reward_cycle);
 
     // (define-public (stack-extend (extend-count uint)
     //                          (pox-addr { version: (buff 1), hashbytes: (buff 32) })
@@ -1841,7 +2023,8 @@ fn stack_extend_signer_key() {
         "stack-extend",
         vec![
             Value::UInt(1),
-            pox_addr.clone(),
+            pox_addr_val.clone(),
+            Value::buff_from(signature.clone()).unwrap(),
             signer_extend_key_val.clone(),
         ],
     )];
@@ -1863,7 +2046,7 @@ fn stack_extend_signer_key() {
     assert_eq!(reward_set.len(), 1);
     let reward_entry = reward_set.pop().unwrap();
     assert_eq!(
-        PoxAddress::try_from_pox_tuple(false, &pox_addr).unwrap(),
+        PoxAddress::try_from_pox_tuple(false, &pox_addr_val).unwrap(),
         reward_entry.reward_address
     );
     assert_eq!(&reward_entry.signer.unwrap(), signer_bytes.as_slice(),);
@@ -1872,7 +2055,7 @@ fn stack_extend_signer_key() {
     assert_eq!(reward_set.len(), 1);
     let reward_entry = reward_set.pop().unwrap();
     assert_eq!(
-        PoxAddress::try_from_pox_tuple(false, &pox_addr).unwrap(),
+        PoxAddress::try_from_pox_tuple(false, &pox_addr_val).unwrap(),
         reward_entry.reward_address
     );
     assert_eq!(
@@ -2092,6 +2275,9 @@ fn delegate_stack_stx_extend_signer_key() {
 
     bob_nonce += 1;
 
+    // let signature =
+    //     make_signer_key_signature(&alice_principal, &bob_new_signer_private_key, reward_cycle);
+
     let delegate_stack_extend = make_pox_4_delegate_stack_extend(
         bob_delegate_private_key,
         bob_nonce,
@@ -2175,6 +2361,12 @@ fn stack_increase() {
         AddressHashMode::SerializeP2PKH,
         key_to_stacks_addr(alice_stacking_private_key).bytes,
     );
+    let reward_cycle = get_current_reward_cycle(&peer, &burnchain);
+    let signature = make_signer_key_signature(
+        &PrincipalData::from(alice_address.clone()),
+        &signing_sk,
+        reward_cycle,
+    );
 
     let alice_stacker = PrincipalData::from(alice_address.clone());
     let reward_cycle = get_current_reward_cycle(&peer, &burnchain);
diff --git a/stackslib/src/util_lib/signed_structured_data.rs b/stackslib/src/util_lib/signed_structured_data.rs
index 32f9ef2f4b..213abfa50c 100644
--- a/stackslib/src/util_lib/signed_structured_data.rs
+++ b/stackslib/src/util_lib/signed_structured_data.rs
@@ -1,3 +1,19 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020-2021 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
 use clarity::vm::Value;
 use stacks_common::{
     codec::StacksMessageCodec,
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 84db7656ed..5cb440efd9 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -42,9 +42,10 @@ use stacks::net::api::postblock_proposal::{
     BlockValidateReject, BlockValidateResponse, NakamotoBlockProposal, ValidateRejectCode,
 };
 use stacks::util_lib::boot::boot_code_id;
-use stacks_common::address::AddressHashMode;
+use stacks::util_lib::signed_structured_data::sign_structured_data;
+use stacks_common::address::{AddressHashMode, C32_ADDRESS_VERSION_TESTNET_SINGLESIG};
 use stacks_common::codec::StacksMessageCodec;
-use stacks_common::consts::STACKS_EPOCH_MAX;
+use stacks_common::consts::{CHAIN_ID_TESTNET, STACKS_EPOCH_MAX};
 use stacks_common::types::chainstate::{StacksAddress, StacksPrivateKey, StacksPublicKey};
 use stacks_common::types::PrivateKey;
 use stacks_common::util::hash::{to_hex, Sha512Sum};
@@ -337,7 +338,7 @@ pub fn boot_to_epoch_3(
     naka_conf: &Config,
     blocks_processed: &RunLoopCounter,
     stacker_sk: Secp256k1PrivateKey,
-    signer_pk: StacksPublicKey,
+    signer_sk: Secp256k1PrivateKey,
     btc_regtest_controller: &mut BitcoinRegtestController,
 ) {
     let epochs = naka_conf.burnchain.epochs.clone().unwrap();
@@ -360,6 +361,21 @@ pub fn boot_to_epoch_3(
         AddressHashMode::SerializeP2PKH as u8,
     ));
 
+    let stacker = StacksAddress::from_public_keys(
+        C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
+        &AddressHashMode::SerializeP2PKH,
+        1,
+        &vec![StacksPublicKey::from_private(&stacker_sk)],
+    )
+    .unwrap();
+    let reward_cycle = 7 as u128;
+    let signer_pubkey = StacksPublicKey::from_private(&signer_sk);
+    let signature = make_signer_key_signature(
+        &PrincipalData::from(stacker.clone()),
+        &signer_sk,
+        reward_cycle,
+    );
+
     let stacking_tx = tests::make_contract_call(
         &stacker_sk,
         0,
@@ -372,7 +388,8 @@ pub fn boot_to_epoch_3(
             pox_addr_tuple,
             clarity::vm::Value::UInt(205),
             clarity::vm::Value::UInt(12),
-            clarity::vm::Value::buff_from(signer_pk.to_bytes_compressed()).unwrap(),
+            clarity::vm::Value::buff_from(signature).unwrap(),
+            clarity::vm::Value::buff_from(signer_pubkey.to_bytes_compressed()).unwrap(),
         ],
     );
 
@@ -388,6 +405,48 @@ pub fn boot_to_epoch_3(
     info!("Bootstrapped to Epoch-3.0 boundary, Epoch2x miner should stop");
 }
 
+fn make_signer_key_signature(
+    stacker: &PrincipalData,
+    signer_key: &StacksPrivateKey,
+    reward_cycle: u128,
+) -> Vec<u8> {
+    let domain_tuple = clarity::vm::Value::Tuple(
+        clarity::vm::types::TupleData::from_data(vec![
+            (
+                "name".into(),
+                clarity::vm::Value::string_ascii_from_bytes("pox-4-signer".into()).unwrap(),
+            ),
+            (
+                "version".into(),
+                clarity::vm::Value::string_ascii_from_bytes("1.0.0".into()).unwrap(),
+            ),
+            (
+                "chain-id".into(),
+                clarity::vm::Value::UInt(CHAIN_ID_TESTNET.into()),
+            ),
+        ])
+        .unwrap(),
+    );
+
+    let data_tuple = clarity::vm::Value::Tuple(
+        clarity::vm::types::TupleData::from_data(vec![
+            (
+                "stacker".into(),
+                clarity::vm::Value::Principal(stacker.clone()),
+            ),
+            (
+                "reward-cycle".into(),
+                clarity::vm::Value::UInt(reward_cycle),
+            ),
+        ])
+        .unwrap(),
+    );
+
+    let signature = sign_structured_data(data_tuple, domain_tuple, signer_key).unwrap();
+
+    signature.to_rsv()
+}
+
 #[test]
 #[ignore]
 /// This test spins up a nakamoto-neon node.
@@ -410,7 +469,7 @@ fn simple_neon_integration() {
     let sender_sk = Secp256k1PrivateKey::new();
     // setup sender + recipient for a test stx transfer
     let sender_addr = tests::to_addr(&sender_sk);
-    let sender_signer_key = StacksPublicKey::new();
+    let sender_signer_sk = Secp256k1PrivateKey::new();
     let send_amt = 1000;
     let send_fee = 100;
     naka_conf.add_initial_balance(
@@ -451,7 +510,7 @@ fn simple_neon_integration() {
         &naka_conf,
         &blocks_processed,
         stacker_sk,
-        sender_signer_key,
+        sender_signer_sk,
         &mut btc_regtest_controller,
     );
 
@@ -622,7 +681,7 @@ fn mine_multiple_per_tenure_integration() {
     let http_origin = format!("http://{}", &naka_conf.node.rpc_bind);
     naka_conf.miner.wait_on_interim_blocks = Duration::from_secs(1);
     let sender_sk = Secp256k1PrivateKey::new();
-    let sender_signer_key = StacksPublicKey::new();
+    let sender_signer_key = Secp256k1PrivateKey::new();
     let tenure_count = 5;
     let inter_blocks_per_tenure = 9;
     // setup sender + recipient for some test stx transfers
@@ -908,6 +967,9 @@ fn correct_burn_outs() {
             let new_sk = StacksPrivateKey::from_seed(Sha512Sum::from_data(&seed_inputs).as_bytes());
             let pk_bytes = StacksPublicKey::from_private(&new_sk).to_bytes_compressed();
 
+            let reward_cycle = pox_info.current_cycle.id;
+            let signature = make_signer_key_signature(&account.1, &new_sk, reward_cycle.into());
+
             let stacking_tx = tests::make_contract_call(
                 &account.0,
                 account.2.nonce,
@@ -920,6 +982,7 @@ fn correct_burn_outs() {
                     pox_addr_tuple,
                     clarity::vm::Value::UInt(pox_info.current_burnchain_block_height.into()),
                     clarity::vm::Value::UInt(1),
+                    clarity::vm::Value::buff_from(signature).unwrap(),
                     clarity::vm::Value::buff_from(pk_bytes).unwrap(),
                 ],
             );
@@ -1069,7 +1132,7 @@ fn block_proposal_api_endpoint() {
         &conf,
         &blocks_processed,
         stacker_sk,
-        StacksPublicKey::new(),
+        Secp256k1PrivateKey::default(),
         &mut btc_regtest_controller,
     );
 
@@ -1412,7 +1475,7 @@ fn miner_writes_proposed_block_to_stackerdb() {
         &naka_conf,
         &blocks_processed,
         stacker_sk,
-        StacksPublicKey::new(),
+        Secp256k1PrivateKey::default(),
         &mut btc_regtest_controller,
     );
 
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index fedc6a301a..2613a2dbb6 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -15,11 +15,9 @@ use stacks::chainstate::nakamoto::{NakamotoBlock, NakamotoBlockHeader};
 use stacks::chainstate::stacks::{StacksPrivateKey, ThresholdSignature};
 use stacks::net::api::postblock_proposal::BlockValidateResponse;
 use stacks_common::bitvec::BitVec;
-use stacks_common::types::chainstate::{
-    ConsensusHash, StacksAddress, StacksBlockId, StacksPublicKey, TrieHash,
-};
+use stacks_common::types::chainstate::{ConsensusHash, StacksAddress, StacksBlockId, TrieHash};
 use stacks_common::util::hash::{MerkleTree, Sha512Trunc256Sum};
-use stacks_common::util::secp256k1::MessageSignature;
+use stacks_common::util::secp256k1::{MessageSignature, Secp256k1PrivateKey};
 use stacks_signer::client::StacksClient;
 use stacks_signer::config::Config as SignerConfig;
 use stacks_signer::runloop::{calculate_coordinator, RunLoopCommand};
@@ -321,7 +319,7 @@ fn setup_stx_btc_node(
         &naka_conf,
         &blocks_processed,
         stacker_sk,
-        StacksPublicKey::new(),
+        Secp256k1PrivateKey::default(),
         &mut btc_regtest_controller,
     );
 

From ffa1946da4fe58a0bc8aea2df1bc9ee185a5331f Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Mon, 29 Jan 2024 09:33:12 -0800
Subject: [PATCH 0581/1166] feat: add signer-sig to `stack-aggregation-commit`

---
 .../src/chainstate/stacks/boot/pox-4.clar     |  8 +++-
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 42 +++++++++++++++----
 2 files changed, 40 insertions(+), 10 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index 5afc6c2b9f..e9e174397f 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -732,6 +732,7 @@
 ;; *New in Stacks 2.1.*
 (define-private (inner-stack-aggregation-commit (pox-addr { version: (buff 1), hashbytes: (buff 32) })
                                                 (reward-cycle uint)
+                                                (signer-sig (buff 65))
                                                 (signer-key (buff 33)))
   (let ((partial-stacked
          ;; fetch the partial commitments
@@ -740,6 +741,7 @@
     ;; must be called directly by the tx-sender or by an allowed contract-caller
     (asserts! (check-caller-allowed)
               (err ERR_STACKING_PERMISSION_DENIED))
+    (try! (verify-signer-key-sig tx-sender signer-sig signer-key))
     (let ((amount-ustx (get stacked-amount partial-stacked)))
       (try! (can-stack-stx pox-addr amount-ustx reward-cycle u1))
       ;; Add the pox addr to the reward cycle, and extract the index of the PoX address
@@ -773,8 +775,9 @@
 ;; Returns (err ...) on failure.
 (define-public (stack-aggregation-commit (pox-addr { version: (buff 1), hashbytes: (buff 32) })
                                          (reward-cycle uint)
+                                         (signer-sig (buff 65))
                                          (signer-key (buff 33)))
-    (match (inner-stack-aggregation-commit pox-addr reward-cycle signer-key)
+    (match (inner-stack-aggregation-commit pox-addr reward-cycle signer-sig signer-key)
         pox-addr-index (ok true)
         commit-err (err commit-err)))
 
@@ -782,8 +785,9 @@
 ;; *New in Stacks 2.1.*
 (define-public (stack-aggregation-commit-indexed (pox-addr { version: (buff 1), hashbytes: (buff 32) })
                                                  (reward-cycle uint)
+                                                 (signer-sig (buff 65))
                                                  (signer-key (buff 33)))
-    (inner-stack-aggregation-commit pox-addr reward-cycle signer-key))
+    (inner-stack-aggregation-commit pox-addr reward-cycle signer-sig signer-key))
 
 ;; Commit partially stacked STX to a PoX address which has already received some STX (more than the Stacking min).
 ;; This allows a delegator to lock up marginally more STX from new delegates, even if they collectively do not
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 8593eebd8b..9c602c1579 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -2089,12 +2089,17 @@ fn delegate_stack_stx_signer_key() {
         AddressHashMode::SerializeP2WSH,
         key_to_stacks_addr(delegate_key).bytes,
     );
-    let signer_bytes =
-        hex_bytes("03a0f9818ea8c14a827bb144aec9cfbaeba225af22be18ed78a2f298106f4e281b").unwrap();
-    let signer_key = Secp256k1PublicKey::from_slice(&signer_bytes).unwrap();
-    let signer_key_val = Value::buff_from(signer_bytes.clone()).unwrap();
+    let signer_sk = Secp256k1PrivateKey::from_seed(&[1, 1, 1]);
+    let signer_key = Secp256k1PublicKey::from_private(&signer_sk);
+    let signer_key_val = Value::buff_from(signer_key.to_bytes_compressed()).unwrap();
     let min_ustx = get_stacking_minimum(&mut peer, &latest_block);
 
+    let signature = make_signer_key_signature(
+        &delegate_principal,
+        &signer_sk,
+        (next_reward_cycle - 1).into(),
+    );
+
     let txs = vec![
         make_pox_4_contract_call(
             stacker_key,
@@ -2128,6 +2133,7 @@ fn delegate_stack_stx_signer_key() {
             vec![
                 pox_addr.clone(),
                 Value::UInt(next_reward_cycle.into()),
+                Value::buff_from(signature).unwrap(),
                 signer_key_val.clone(),
             ],
         ),
@@ -2159,7 +2165,10 @@ fn delegate_stack_stx_signer_key() {
         PoxAddress::try_from_pox_tuple(false, &pox_addr).unwrap(),
         reward_entry.reward_address
     );
-    assert_eq!(&reward_entry.signer.unwrap(), signer_bytes.as_slice(),);
+    assert_eq!(
+        &reward_entry.signer.unwrap(),
+        signer_key.to_bytes_compressed().as_slice()
+    );
 }
 
 // In this test case, Alice delegates to Bob.
@@ -2249,10 +2258,12 @@ fn delegate_stack_stx_extend_signer_key() {
         .expect("No stacking state, stack-stx failed")
         .expect_tuple();
 
-    let next_reward_cycle = 1 + burnchain
+    let reward_cycle = burnchain
         .block_height_to_reward_cycle(block_height)
         .unwrap();
 
+    let next_reward_cycle = 1 + reward_cycle;
+
     let extend_cycle = 1 + next_reward_cycle;
 
     let partially_stacked_0 = get_partially_stacked_state_pox_4(
@@ -2275,8 +2286,8 @@ fn delegate_stack_stx_extend_signer_key() {
 
     bob_nonce += 1;
 
-    // let signature =
-    //     make_signer_key_signature(&alice_principal, &bob_new_signer_private_key, reward_cycle);
+    let signature =
+        make_signer_key_signature(&bob_delegate_principal, &signer_sk, reward_cycle.into());
 
     let delegate_stack_extend = make_pox_4_delegate_stack_extend(
         bob_delegate_private_key,
@@ -2293,10 +2304,17 @@ fn delegate_stack_stx_extend_signer_key() {
         vec![
             pox_addr.as_clarity_tuple().unwrap().into(),
             Value::UInt(next_reward_cycle.into()),
+            Value::buff_from(signature).unwrap(),
             signer_key_val.clone(),
         ],
     );
 
+    let extend_signature = make_signer_key_signature(
+        &bob_delegate_principal,
+        &signer_extend_sk,
+        reward_cycle.into(),
+    );
+
     let agg_tx_1 = make_pox_4_contract_call(
         bob_delegate_private_key,
         bob_nonce + 2,
@@ -2304,6 +2322,7 @@ fn delegate_stack_stx_extend_signer_key() {
         vec![
             pox_addr.as_clarity_tuple().unwrap().into(),
             Value::UInt(extend_cycle.into()),
+            Value::buff_from(extend_signature).unwrap(),
             signer_extend_key_val.clone(),
         ],
     );
@@ -2503,6 +2522,12 @@ fn delegate_stack_increase() {
         min_ustx,
     );
 
+    let signature = make_signer_key_signature(
+        &bob_delegate_address,
+        &signer_sk,
+        (next_reward_cycle - 1).into(),
+    );
+
     let agg_tx = make_pox_4_contract_call(
         bob_delegate_key,
         bob_nonce + 1,
@@ -2510,6 +2535,7 @@ fn delegate_stack_increase() {
         vec![
             pox_addr.as_clarity_tuple().unwrap().into(),
             Value::UInt(next_reward_cycle.into()),
+            Value::buff_from(signature).unwrap(),
             signer_key_val.clone(),
         ],
     );

From 353c154db88a422f4dafe98b200d3aca0aeadee5 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Mon, 29 Jan 2024 10:48:05 -0800
Subject: [PATCH 0582/1166] feat: use `pox-addr` in signer sig message hash

---
 .../chainstate/nakamoto/coordinator/tests.rs  |  19 +-
 stackslib/src/chainstate/stacks/boot/mod.rs   |   7 +-
 .../src/chainstate/stacks/boot/pox-4.clar     |  16 +-
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 202 ++++++------------
 .../src/tests/nakamoto_integrations.rs        |  47 ++--
 5 files changed, 109 insertions(+), 182 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index 2564417845..91d5007f98 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -30,7 +30,7 @@ use wsts::curve::point::Point;
 
 use crate::chainstate::burn::db::sortdb::{SortitionDB, SortitionHandle};
 use crate::chainstate::burn::operations::BlockstackOperationType;
-use crate::chainstate::coordinator::tests::p2pkh_from;
+use crate::chainstate::coordinator::tests::{p2pkh_from, pox_addr_from};
 use crate::chainstate::nakamoto::tests::get_account;
 use crate::chainstate::nakamoto::tests::node::{TestSigners, TestStacker};
 use crate::chainstate::nakamoto::{NakamotoBlock, NakamotoChainState};
@@ -75,22 +75,17 @@ fn advance_to_nakamoto(
             test_stackers
                 .iter()
                 .map(|test_stacker| {
-                    let reward_cycle = 6;
-                    let stacker =
-                        PrincipalData::from(key_to_stacks_addr(&test_stacker.stacker_private_key));
-                    let signature = make_signer_key_signature(
-                        &stacker,
-                        &test_stacker.signer_private_key,
-                        reward_cycle,
+                    let pox_addr = PoxAddress::from_legacy(
+                        AddressHashMode::SerializeP2PKH,
+                        addr.bytes.clone(),
                     );
+                    let signature =
+                        make_signer_key_signature(&pox_addr, &test_stacker.signer_private_key, 6);
                     make_pox_4_lockup(
                         &test_stacker.stacker_private_key,
                         0,
                         test_stacker.amount,
-                        PoxAddress::from_legacy(
-                            AddressHashMode::SerializeP2PKH,
-                            addr.bytes.clone(),
-                        ),
+                        pox_addr.clone(),
                         12,
                         StacksPublicKey::from_private(&test_stacker.signer_private_key),
                         34,
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 7e7f0a51ea..8489c3a3be 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -2212,7 +2212,7 @@ pub mod test {
     }
 
     pub fn make_signer_key_signature(
-        stacker: &PrincipalData,
+        pox_addr: &PoxAddress,
         signer_key: &StacksPrivateKey,
         reward_cycle: u128,
     ) -> Vec<u8> {
@@ -2233,7 +2233,10 @@ pub mod test {
 
         let data_tuple = Value::Tuple(
             TupleData::from_data(vec![
-                ("stacker".into(), Value::Principal(stacker.clone())),
+                (
+                    "pox-addr".into(),
+                    pox_addr.clone().as_clarity_tuple().unwrap().into(),
+                ),
                 ("reward-cycle".into(), Value::UInt(reward_cycle)),
             ])
             .unwrap(),
diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index e9e174397f..44799e9715 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -603,7 +603,7 @@
         (err ERR_STACKING_INSUFFICIENT_FUNDS))
 
       ;; Validate ownership of the given signer key
-      (try! (verify-signer-key-sig tx-sender signer-sig signer-key))
+      (try! (verify-signer-key-sig pox-addr signer-sig signer-key))
 
       ;; ensure that stacking can be performed
       (try! (can-stack-stx pox-addr amount-ustx first-reward-cycle lock-period))
@@ -682,14 +682,14 @@
 
 ;; Generate a message hash for validating a signer key.
 ;; The message hash follows SIP018 for signing structured data. The structured data
-;; is the tuple `{ stacker, reward-cycle }`. The domain is
+;; is the tuple `{ pox-addr: { version, hashbytes }, reward-cycle }`. The domain is
 ;; `{ name: "pox-4-signer", version: "1.0.0", chain-id: chain-id }`.
-(define-read-only (get-signer-key-message-hash (stacker principal))
+(define-read-only (get-signer-key-message-hash (pox-addr { version: (buff 1), hashbytes: (buff 32) }))
   (let
     (
       (domain { name: "pox-4-signer", version: "1.0.0", chain-id: chain-id })
       (data-hash (sha256 (unwrap-panic
-        (to-consensus-buff? { stacker: stacker, reward-cycle: (current-pox-reward-cycle) }))))
+        (to-consensus-buff? { pox-addr: pox-addr, reward-cycle: (current-pox-reward-cycle) }))))
       (domain-hash (sha256 (unwrap-panic (to-consensus-buff? domain))))
     )
     (sha256 (concat
@@ -705,12 +705,12 @@
 ;; Note that `reward-cycle` corresponds to the _current_ reward cycle,
 ;; not the reward cycle at which the delegation will start.
 ;; The public key is recovered from the signature and compared to `signer-key`.
-(define-read-only (verify-signer-key-sig (stacker principal)
+(define-read-only (verify-signer-key-sig (pox-addr { version: (buff 1), hashbytes: (buff 32) })
                                          (signer-sig (buff 65))
                                          (signer-key (buff 33)))
   (let
     (
-      (msg-hash (get-signer-key-message-hash stacker))
+      (msg-hash (get-signer-key-message-hash pox-addr))
       (pubkey (unwrap! (secp256k1-recover? msg-hash signer-sig) (err ERR_INVALID_SIGNATURE_RECOVER)))
     )
     (asserts! (is-eq pubkey signer-key) (err ERR_INVALID_SIGNATURE_PUBKEY))
@@ -741,7 +741,7 @@
     ;; must be called directly by the tx-sender or by an allowed contract-caller
     (asserts! (check-caller-allowed)
               (err ERR_STACKING_PERMISSION_DENIED))
-    (try! (verify-signer-key-sig tx-sender signer-sig signer-key))
+    (try! (verify-signer-key-sig pox-addr signer-sig signer-key))
     (let ((amount-ustx (get stacked-amount partial-stacked)))
       (try! (can-stack-stx pox-addr amount-ustx reward-cycle u1))
       ;; Add the pox addr to the reward cycle, and extract the index of the PoX address
@@ -1061,7 +1061,7 @@
               (err ERR_STACKING_IS_DELEGATED))
 
     ;; Verify signature from delegate that allows this sender for this cycle
-    (try! (verify-signer-key-sig tx-sender signer-sig signer-key))
+    (try! (verify-signer-key-sig pox-addr signer-sig signer-key))
 
     ;; TODO: add more assertions to sanity check the `stacker-info` values with
     ;;       the `stacker-state` values
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 9c602c1579..bf61a5befe 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -480,14 +480,6 @@ fn pox_extend_transition() {
         latest_block = peer.tenure_with_txs(&[], &mut coinbase_nonce);
     }
 
-    // Key 3
-    let alice_signer_private = keys.pop().unwrap();
-    let alice_signer_key = StacksPublicKey::from_private(&alice_signer_private);
-    let reward_cycle = get_current_reward_cycle(&peer, &burnchain);
-
-    let alice_signature =
-        make_signer_key_signature(&alice_principal, &alice_signer_private, reward_cycle);
-
     let tip = get_tip(peer.sortdb.as_ref());
 
     let alice_signer_private = Secp256k1PrivateKey::new();
@@ -495,8 +487,13 @@ fn pox_extend_transition() {
 
     let reward_cycle = get_current_reward_cycle(&peer, &burnchain);
 
+    let alice_pox_addr = PoxAddress::from_legacy(
+        AddressHashMode::SerializeP2PKH,
+        key_to_stacks_addr(&alice).bytes,
+    );
+
     let alice_signature =
-        make_signer_key_signature(&alice_principal, &alice_signer_private, reward_cycle);
+        make_signer_key_signature(&alice_pox_addr, &alice_signer_private, reward_cycle);
     let alice_lockup = make_pox_4_lockup(
         &alice,
         2,
@@ -553,38 +550,22 @@ fn pox_extend_transition() {
     }
 
     let bob_signer_private = Secp256k1PrivateKey::new();
-    let bob_signer_key = Secp256k1PublicKey::from_private(&bob_signer_private);
-
-    // let bob_signer_key: [u8; 33] = [
-    //     0x02, 0xb6, 0x19, 0x6d, 0xe8, 0x8b, 0xce, 0xe7, 0x93, 0xfa, 0x9a, 0x8a, 0x85, 0x96, 0x9b,
-    //     0x64, 0x7f, 0x84, 0xc9, 0x0e, 0x9d, 0x13, 0xf9, 0xc8, 0xb8, 0xce, 0x42, 0x6c, 0xc8, 0x1a,
-    //     0x59, 0x98, 0x3c,
-    // ];
-    // let alice_signer_key: [u8; 33] = [
-    //     0x03, 0xa0, 0xf9, 0x81, 0x8e, 0xa8, 0xc1, 0x4a, 0x82, 0x7b, 0xb1, 0x44, 0xae, 0xc9, 0xcf,
-    //     0xba, 0xeb, 0xa2, 0x25, 0xaf, 0x22, 0xbe, 0x18, 0xed, 0x78, 0xa2, 0xf2, 0x98, 0x10, 0x6f,
-    //     0x4e, 0x28, 0x1b,
-    // ];
-
-    let alice_signer_private = Secp256k1PrivateKey::new();
-    let alice_signer_key = Secp256k1PublicKey::from_private(&alice_signer_private);
 
     let reward_cycle = get_current_reward_cycle(&peer, &burnchain);
 
-    let bob_signature =
-        make_signer_key_signature(&bob_principal, &bob_signer_private, reward_cycle);
-    let alice_signature =
-        make_signer_key_signature(&alice_principal, &alice_signer_private, reward_cycle);
+    let bob_pox_addr = PoxAddress::from_legacy(
+        AddressHashMode::SerializeP2PKH,
+        key_to_stacks_addr(&bob).bytes,
+    );
+
+    let bob_signature = make_signer_key_signature(&bob_pox_addr, &bob_signer_private, reward_cycle);
 
     let tip = get_tip(peer.sortdb.as_ref());
     let bob_lockup = make_pox_4_lockup(
         &bob,
         2,
         BOB_LOCKUP,
-        PoxAddress::from_legacy(
-            AddressHashMode::SerializeP2PKH,
-            key_to_stacks_addr(&bob).bytes,
-        ),
+        bob_pox_addr.clone(),
         3,
         StacksPublicKey::from_private(&bob_signer_private),
         tip.block_height,
@@ -596,16 +577,13 @@ fn pox_extend_transition() {
     let alice_signer_key = StacksPublicKey::from_private(&alice_signer_private);
 
     let alice_signature =
-        make_signer_key_signature(&alice_principal, &alice_signer_private, reward_cycle);
+        make_signer_key_signature(&alice_pox_addr, &alice_signer_private, reward_cycle);
 
     // Alice can stack-extend in PoX v2
     let alice_lockup = make_pox_4_extend(
         &alice,
         3,
-        PoxAddress::from_legacy(
-            AddressHashMode::SerializeP2PKH,
-            key_to_stacks_addr(&alice).bytes,
-        ),
+        alice_pox_addr.clone(),
         6,
         alice_signer_key,
         alice_signature,
@@ -864,8 +842,7 @@ fn pox_lock_unlock() {
             let pox_addr = PoxAddress::from_legacy(hash_mode, key_to_stacks_addr(key).bytes);
             let lock_period = if ix == 3 { 12 } else { lock_period };
             let signer_key = key;
-            let stacker = PrincipalData::from(key_to_stacks_addr(key));
-            let signature = make_signer_key_signature(&stacker, &signer_key, reward_cycle);
+            let signature = make_signer_key_signature(&pox_addr, &signer_key, reward_cycle);
             txs.push(make_pox_4_lockup(
                 key,
                 0,
@@ -1450,7 +1427,7 @@ fn pox_4_revoke_delegate_stx_events() {
 fn verify_signer_key_sig(
     signature: &Vec<u8>,
     signing_key: &Secp256k1PublicKey,
-    stacker: &PrincipalData,
+    pox_addr: &PoxAddress,
     peer: &mut TestPeer,
     latest_block: &StacksBlockId,
 ) -> Value {
@@ -1467,8 +1444,8 @@ fn verify_signer_key_sig(
                         LimitedCostTracker::new_free(),
                         |env| {
                             let program = format!(
-                                "(verify-signer-key-sig '{} 0x{} 0x{})",
-                                stacker.to_string(),
+                                "(verify-signer-key-sig {} 0x{} 0x{})",
+                                Value::Tuple(pox_addr.clone().as_clarity_tuple().unwrap()),
                                 to_hex(&signature),
                                 signing_key.to_hex(),
                             );
@@ -1508,12 +1485,10 @@ fn verify_signer_key_signatures() {
     // alice
     let alice = keys.pop().unwrap();
     let alice_address = key_to_stacks_addr(&alice);
-    let alice_principal = PrincipalData::from(alice_address.clone());
 
     // bob
     let bob = keys.pop().unwrap();
     let bob_address = key_to_stacks_addr(&bob);
-    let bob_principal = PrincipalData::from(bob_address.clone());
     let bob_public_key = StacksPublicKey::from_private(&bob);
 
     // Advance into pox4
@@ -1529,28 +1504,32 @@ fn verify_signer_key_signatures() {
 
     let expected_error = Value::error(Value::Int(35)).unwrap();
 
+    let alice_pox_addr =
+        PoxAddress::from_legacy(AddressHashMode::SerializeP2PKH, alice_address.bytes.clone());
+    let bob_pox_addr = PoxAddress::from_legacy(AddressHashMode::SerializeP2PKH, bob_address.bytes);
+
     // Test 1: invalid reward cycle used in signature
 
     let last_reward_cycle = reward_cycle - 1;
-    let signature = make_signer_key_signature(&alice_principal, &bob, last_reward_cycle);
+    let signature = make_signer_key_signature(&bob_pox_addr, &bob, last_reward_cycle);
 
     let result = verify_signer_key_sig(
         &signature,
         &bob_public_key,
-        &alice_principal,
+        &bob_pox_addr,
         &mut peer,
         &latest_block,
     );
     assert_eq!(result, expected_error);
 
-    // Test 2: Invalid stacker used in signature
+    // Test 2: Invalid pox-addr used in signature
 
-    let signature = make_signer_key_signature(&bob_principal, &bob, reward_cycle);
+    let signature = make_signer_key_signature(&alice_pox_addr, &bob, reward_cycle);
 
     let result = verify_signer_key_sig(
         &signature,
         &bob_public_key,
-        &alice_principal, // different stacker
+        &bob_pox_addr, // wrong pox-addr
         &mut peer,
         &latest_block,
     );
@@ -1559,12 +1538,12 @@ fn verify_signer_key_signatures() {
 
     // Test 3: Invalid signer key used in signature
 
-    let signature = make_signer_key_signature(&alice_principal, &alice, reward_cycle);
+    let signature = make_signer_key_signature(&bob_pox_addr, &alice, reward_cycle);
 
     let result = verify_signer_key_sig(
         &signature,
         &bob_public_key, // different key
-        &alice_principal,
+        &bob_pox_addr,
         &mut peer,
         &latest_block,
     );
@@ -1573,12 +1552,12 @@ fn verify_signer_key_signatures() {
 
     // Test 4: using a valid signature
 
-    let signature = make_signer_key_signature(&alice_principal, &bob, reward_cycle);
+    let signature = make_signer_key_signature(&bob_pox_addr, &bob, reward_cycle);
 
     let result = verify_signer_key_sig(
         &signature,
         &bob_public_key,
-        &alice_principal,
+        &bob_pox_addr,
         &mut peer,
         &latest_block,
     );
@@ -1599,19 +1578,21 @@ fn stack_stx_verify_signer_sig() {
     let stacker_key = &keys[0];
     let min_ustx = get_stacking_minimum(&mut peer, &latest_block);
     let stacker_addr = key_to_stacks_addr(&stacker_key);
-    let stacker = PrincipalData::from(stacker_addr);
     let signer_key = &keys[1];
     let signer_public_key = StacksPublicKey::from_private(signer_key);
     let pox_addr = pox_addr_from(&stacker_key);
 
     let second_stacker = &keys[2];
     let second_stacker_addr = key_to_stacks_addr(second_stacker);
-    let second_stacker_principal = PrincipalData::from(second_stacker_addr);
+    let second_stacker_pox_addr = PoxAddress::from_legacy(
+        AddressHashMode::SerializeP2PKH,
+        second_stacker_addr.bytes.clone(),
+    );
 
     let reward_cycle = get_current_reward_cycle(&peer, &burnchain);
 
     // Test 1: invalid reward cycle
-    let signature = make_signer_key_signature(&stacker, &signer_key, reward_cycle - 1);
+    let signature = make_signer_key_signature(&pox_addr, &signer_key, reward_cycle - 1);
     let invalid_cycle_nonce = stacker_nonce;
     let invalid_cycle_stack = make_pox_4_lockup(
         &stacker_key,
@@ -1626,7 +1607,7 @@ fn stack_stx_verify_signer_sig() {
 
     // test 2: invalid stacker
     stacker_nonce += 1;
-    let signature = make_signer_key_signature(&second_stacker_principal, &signer_key, reward_cycle);
+    let signature = make_signer_key_signature(&second_stacker_pox_addr, &signer_key, reward_cycle);
     let invalid_stacker_nonce = stacker_nonce;
     let invalid_stacker_tx = make_pox_4_lockup(
         &stacker_key,
@@ -1641,7 +1622,7 @@ fn stack_stx_verify_signer_sig() {
 
     // Test 3: invalid key used to sign
     stacker_nonce += 1;
-    let signature = make_signer_key_signature(&stacker, &second_stacker, reward_cycle);
+    let signature = make_signer_key_signature(&pox_addr, &second_stacker, reward_cycle);
     let invalid_key_nonce = stacker_nonce;
     let invalid_key_tx = make_pox_4_lockup(
         &stacker_key,
@@ -1656,7 +1637,7 @@ fn stack_stx_verify_signer_sig() {
 
     // Test 4: valid signature
     stacker_nonce += 1;
-    let signature = make_signer_key_signature(&stacker, &signer_key, reward_cycle);
+    let signature = make_signer_key_signature(&pox_addr, &signer_key, reward_cycle);
     let valid_nonce = stacker_nonce;
     let valid_tx = make_pox_4_lockup(
         &stacker_key,
@@ -1705,7 +1686,6 @@ fn stack_extend_verify_sig() {
     let stacker_key = &keys[0];
     let min_ustx = get_stacking_minimum(&mut peer, &latest_block);
     let stacker_addr = key_to_stacks_addr(&stacker_key);
-    let stacker = PrincipalData::from(stacker_addr);
     let signer_key = &keys[1];
     let signer_public_key = StacksPublicKey::from_private(signer_key);
     let pox_addr = pox_addr_from(&signer_key);
@@ -1713,7 +1693,7 @@ fn stack_extend_verify_sig() {
     let reward_cycle = get_current_reward_cycle(&peer, &burnchain);
 
     // Setup: stack-stx
-    let signature = make_signer_key_signature(&stacker, &signer_key, reward_cycle);
+    let signature = make_signer_key_signature(&pox_addr, &signer_key, reward_cycle);
     let stack_nonce = stacker_nonce;
     let stack_tx = make_pox_4_lockup(
         &stacker_key,
@@ -1731,7 +1711,7 @@ fn stack_extend_verify_sig() {
     let signer_public_key = StacksPublicKey::from_private(&signer_key);
 
     // Test 1: invalid reward cycle
-    let signature = make_signer_key_signature(&stacker, &signer_key, reward_cycle - 1);
+    let signature = make_signer_key_signature(&pox_addr, &signer_key, reward_cycle - 1);
     stacker_nonce += 1;
     let invalid_cycle_nonce = stacker_nonce;
     let invalid_cycle_tx = make_pox_4_extend(
@@ -1743,10 +1723,10 @@ fn stack_extend_verify_sig() {
         signature,
     );
 
-    // Test 2: invalid stacker
+    // Test 2: invalid pox-addr
     stacker_nonce += 1;
-    let other_stacker = PrincipalData::from(key_to_stacks_addr(&Secp256k1PrivateKey::new()));
-    let signature = make_signer_key_signature(&other_stacker, &signer_key, reward_cycle);
+    let other_pox_addr = pox_addr_from(&Secp256k1PrivateKey::new());
+    let signature = make_signer_key_signature(&other_pox_addr, &signer_key, reward_cycle);
     let invalid_stacker_nonce = stacker_nonce;
     let invalid_stacker_tx = make_pox_4_extend(
         &stacker_key,
@@ -1760,7 +1740,7 @@ fn stack_extend_verify_sig() {
     // Test 3: invalid key used to sign
     stacker_nonce += 1;
     let other_key = Secp256k1PrivateKey::new();
-    let signature = make_signer_key_signature(&stacker, &other_key, reward_cycle);
+    let signature = make_signer_key_signature(&pox_addr, &other_key, reward_cycle);
     let invalid_key_nonce = stacker_nonce;
     let invalid_key_tx = make_pox_4_extend(
         &stacker_key,
@@ -1773,7 +1753,7 @@ fn stack_extend_verify_sig() {
 
     // Test 4: valid stack-extend
     stacker_nonce += 1;
-    let signature = make_signer_key_signature(&stacker, &signer_key, reward_cycle);
+    let signature = make_signer_key_signature(&pox_addr, &signer_key, reward_cycle);
     let valid_nonce = stacker_nonce;
     let valid_tx = make_pox_4_extend(
         &stacker_key,
@@ -1888,29 +1868,20 @@ fn stack_stx_signer_key() {
     let stacker_nonce = 0;
     let stacker_key = &keys[0];
     let min_ustx = get_stacking_minimum(&mut peer, &latest_block);
-    let stacker = PrincipalData::from(key_to_stacks_addr(stacker_key));
     let signer_key = &keys[1];
     let signer_public_key = StacksPublicKey::from_private(signer_key);
     let signer_key_val = Value::buff_from(signer_public_key.to_bytes_compressed()).unwrap();
 
     let reward_cycle = get_current_reward_cycle(&peer, &burnchain);
 
-    let signature = make_signer_key_signature(&stacker, &signer_key, reward_cycle);
-
     // (define-public (stack-stx (amount-ustx uint)
     //                       (pox-addr (tuple (version (buff 1)) (hashbytes (buff 32))))
     //                       (start-burn-ht uint)
     //                       (lock-period uint)
     //                       (signer-key (buff 33)))
-    let pox_addr = make_pox_addr(
-        AddressHashMode::SerializeP2WSH,
-        key_to_stacks_addr(stacker_key).bytes,
-    );
-
-    // let signer_bytes =
-    //     hex_bytes("03a0f9818ea8c14a827bb144aec9cfbaeba225af22be18ed78a2f298106f4e281b").unwrap();
-    // let signer_key = Secp256k1PublicKey::from_slice(&signer_bytes).unwrap();
-    // let signer_key_val = Value::buff_from(signer_bytes.clone()).unwrap();
+    let pox_addr = pox_addr_from(&stacker_key);
+    let pox_addr_val = Value::Tuple(pox_addr.clone().as_clarity_tuple().unwrap());
+    let signature = make_signer_key_signature(&pox_addr, &signer_key, reward_cycle);
 
     let txs = vec![make_pox_4_contract_call(
         stacker_key,
@@ -1918,7 +1889,7 @@ fn stack_stx_signer_key() {
         "stack-stx",
         vec![
             Value::UInt(min_ustx),
-            pox_addr.clone(),
+            pox_addr_val.clone(),
             Value::UInt(block_height as u128),
             Value::UInt(2),
             Value::buff_from(signature.clone()).unwrap(),
@@ -1943,7 +1914,7 @@ fn stack_stx_signer_key() {
     assert_eq!(reward_set.len(), 1);
     let reward_entry = reward_set.pop().unwrap();
     assert_eq!(
-        PoxAddress::try_from_pox_tuple(false, &pox_addr).unwrap(),
+        PoxAddress::try_from_pox_tuple(false, &pox_addr_val).unwrap(),
         reward_entry.reward_address
     );
     assert_eq!(
@@ -1960,24 +1931,16 @@ fn stack_extend_signer_key() {
 
     let mut stacker_nonce = 0;
     let stacker_key = &keys[0];
-    let stacker = PrincipalData::from(key_to_stacks_addr(stacker_key));
     let min_ustx = get_stacking_minimum(&mut peer, &latest_block) * 2;
 
-    let pox_addr = PoxAddress::from_legacy(
-        AddressHashMode::SerializeP2WSH,
-        key_to_stacks_addr(stacker_key).bytes,
-    );
-    let pox_addr_val = make_pox_addr(
-        AddressHashMode::SerializeP2WSH,
-        key_to_stacks_addr(stacker_key).bytes,
-    );
+    let pox_addr = pox_addr_from(&stacker_key);
+    let pox_addr_val = Value::Tuple(pox_addr.clone().as_clarity_tuple().unwrap());
 
     let signer_sk = Secp256k1PrivateKey::from_seed(&[0]);
     let signer_extend_sk = Secp256k1PrivateKey::from_seed(&[1]);
 
     let signer_key = Secp256k1PublicKey::from_private(&signer_sk);
     let signer_bytes = signer_key.to_bytes_compressed();
-    let signer_key_val = Value::buff_from(signer_bytes.clone()).unwrap();
 
     let signer_extend_key = Secp256k1PublicKey::from_private(&signer_extend_sk);
     let signer_extend_bytes = signer_extend_key.to_bytes_compressed();
@@ -1986,13 +1949,10 @@ fn stack_extend_signer_key() {
     let next_reward_cycle = 1 + burnchain
         .block_height_to_reward_cycle(block_height)
         .unwrap();
-    // let signer_key = &keys[1];
-    // let signer_public_key = StacksPublicKey::from_private(signer_key);
-    // let signer_key_val = Value::buff_from(signer_public_key.to_bytes_compressed()).unwrap();
 
     let reward_cycle = get_current_reward_cycle(&peer, &burnchain);
 
-    let signature = make_signer_key_signature(&stacker, &signer_sk, reward_cycle);
+    let signature = make_signer_key_signature(&pox_addr, &signer_sk, reward_cycle);
 
     let txs = vec![make_pox_4_lockup(
         &stacker_key,
@@ -2009,10 +1969,7 @@ fn stack_extend_signer_key() {
 
     let mut latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
 
-    let signer_key_new = &keys[2];
-    let signer_public_key_new = StacksPublicKey::from_private(signer_key_new);
-
-    let signature = make_signer_key_signature(&stacker, &signer_extend_sk, reward_cycle);
+    let signature = make_signer_key_signature(&pox_addr, &signer_extend_sk, reward_cycle);
 
     // (define-public (stack-extend (extend-count uint)
     //                          (pox-addr { version: (buff 1), hashbytes: (buff 32) })
@@ -2072,7 +2029,6 @@ fn delegate_stack_stx_signer_key() {
 
     let stacker_nonce = 0;
     let stacker_key = &keys[0];
-    let stacker_principal = PrincipalData::from(key_to_stacks_addr(stacker_key));
     let delegate_nonce = 0;
     let delegate_key = &keys[1];
     let delegate_principal = PrincipalData::from(key_to_stacks_addr(delegate_key));
@@ -2085,20 +2041,15 @@ fn delegate_stack_stx_signer_key() {
     //                          (delegate-to principal)
     //                          (until-burn-ht (optional uint))
     //                          (pox-addr (optional { version: (buff 1), hashbytes: (buff 32) })))
-    let pox_addr = make_pox_addr(
-        AddressHashMode::SerializeP2WSH,
-        key_to_stacks_addr(delegate_key).bytes,
-    );
+    let pox_addr = pox_addr_from(&stacker_key);
+    let pox_addr_val = Value::Tuple(pox_addr.clone().as_clarity_tuple().unwrap());
     let signer_sk = Secp256k1PrivateKey::from_seed(&[1, 1, 1]);
     let signer_key = Secp256k1PublicKey::from_private(&signer_sk);
     let signer_key_val = Value::buff_from(signer_key.to_bytes_compressed()).unwrap();
     let min_ustx = get_stacking_minimum(&mut peer, &latest_block);
 
-    let signature = make_signer_key_signature(
-        &delegate_principal,
-        &signer_sk,
-        (next_reward_cycle - 1).into(),
-    );
+    let signature =
+        make_signer_key_signature(&pox_addr, &signer_sk, (next_reward_cycle - 1).into());
 
     let txs = vec![
         make_pox_4_contract_call(
@@ -2110,7 +2061,7 @@ fn delegate_stack_stx_signer_key() {
                 delegate_principal.clone().into(),
                 Value::none(),
                 Value::Optional(OptionalData {
-                    data: Some(Box::new(pox_addr.clone())),
+                    data: Some(Box::new(pox_addr_val.clone())),
                 }),
             ],
         ),
@@ -2121,7 +2072,7 @@ fn delegate_stack_stx_signer_key() {
             vec![
                 PrincipalData::from(key_to_stacks_addr(stacker_key)).into(),
                 Value::UInt(min_ustx + 1),
-                pox_addr.clone(),
+                pox_addr_val.clone(),
                 Value::UInt(block_height as u128),
                 Value::UInt(lock_period),
             ],
@@ -2131,7 +2082,7 @@ fn delegate_stack_stx_signer_key() {
             delegate_nonce + 1,
             "stack-aggregation-commit",
             vec![
-                pox_addr.clone(),
+                pox_addr_val.clone(),
                 Value::UInt(next_reward_cycle.into()),
                 Value::buff_from(signature).unwrap(),
                 signer_key_val.clone(),
@@ -2162,7 +2113,7 @@ fn delegate_stack_stx_signer_key() {
     assert_eq!(reward_set.len(), 1);
     let reward_entry = reward_set.pop().unwrap();
     assert_eq!(
-        PoxAddress::try_from_pox_tuple(false, &pox_addr).unwrap(),
+        PoxAddress::try_from_pox_tuple(false, &pox_addr_val).unwrap(),
         reward_entry.reward_address
     );
     assert_eq!(
@@ -2286,8 +2237,7 @@ fn delegate_stack_stx_extend_signer_key() {
 
     bob_nonce += 1;
 
-    let signature =
-        make_signer_key_signature(&bob_delegate_principal, &signer_sk, reward_cycle.into());
+    let signature = make_signer_key_signature(&pox_addr, &signer_sk, reward_cycle.into());
 
     let delegate_stack_extend = make_pox_4_delegate_stack_extend(
         bob_delegate_private_key,
@@ -2309,11 +2259,8 @@ fn delegate_stack_stx_extend_signer_key() {
         ],
     );
 
-    let extend_signature = make_signer_key_signature(
-        &bob_delegate_principal,
-        &signer_extend_sk,
-        reward_cycle.into(),
-    );
+    let extend_signature =
+        make_signer_key_signature(&pox_addr, &signer_extend_sk, reward_cycle.into());
 
     let agg_tx_1 = make_pox_4_contract_call(
         bob_delegate_private_key,
@@ -2381,15 +2328,9 @@ fn stack_increase() {
         key_to_stacks_addr(alice_stacking_private_key).bytes,
     );
     let reward_cycle = get_current_reward_cycle(&peer, &burnchain);
-    let signature = make_signer_key_signature(
-        &PrincipalData::from(alice_address.clone()),
-        &signing_sk,
-        reward_cycle,
-    );
 
-    let alice_stacker = PrincipalData::from(alice_address.clone());
     let reward_cycle = get_current_reward_cycle(&peer, &burnchain);
-    let signature = make_signer_key_signature(&alice_stacker, &signing_sk, reward_cycle);
+    let signature = make_signer_key_signature(&pox_addr, &signing_sk, reward_cycle);
 
     let stack_stx = make_pox_4_lockup(
         alice_stacking_private_key,
@@ -2522,11 +2463,8 @@ fn delegate_stack_increase() {
         min_ustx,
     );
 
-    let signature = make_signer_key_signature(
-        &bob_delegate_address,
-        &signer_sk,
-        (next_reward_cycle - 1).into(),
-    );
+    let signature =
+        make_signer_key_signature(&pox_addr, &signer_sk, (next_reward_cycle - 1).into());
 
     let agg_tx = make_pox_4_contract_call(
         bob_delegate_key,
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 5cb440efd9..c7559c158c 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -28,6 +28,7 @@ use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::coordinator::comm::CoordinatorChannels;
 use stacks::chainstate::nakamoto::miner::NakamotoBlockBuilder;
 use stacks::chainstate::nakamoto::{NakamotoBlock, NakamotoChainState};
+use stacks::chainstate::stacks::address::PoxAddress;
 use stacks::chainstate::stacks::boot::MINERS_NAME;
 use stacks::chainstate::stacks::db::StacksChainState;
 use stacks::chainstate::stacks::miner::{BlockBuilder, BlockLimitFunction, TransactionResult};
@@ -43,7 +44,7 @@ use stacks::net::api::postblock_proposal::{
 };
 use stacks::util_lib::boot::boot_code_id;
 use stacks::util_lib::signed_structured_data::sign_structured_data;
-use stacks_common::address::{AddressHashMode, C32_ADDRESS_VERSION_TESTNET_SINGLESIG};
+use stacks_common::address::AddressHashMode;
 use stacks_common::codec::StacksMessageCodec;
 use stacks_common::consts::{CHAIN_ID_TESTNET, STACKS_EPOCH_MAX};
 use stacks_common::types::chainstate::{StacksAddress, StacksPrivateKey, StacksPublicKey};
@@ -355,26 +356,15 @@ pub fn boot_to_epoch_3(
     next_block_and_wait(btc_regtest_controller, &blocks_processed);
 
     // stack enough to activate pox-4
-    let pox_addr_tuple = clarity::vm::tests::execute(&format!(
-        "{{ hashbytes: 0x{}, version: 0x{:02x} }}",
-        to_hex(&[0; 20]),
-        AddressHashMode::SerializeP2PKH as u8,
-    ));
-
-    let stacker = StacksAddress::from_public_keys(
-        C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
-        &AddressHashMode::SerializeP2PKH,
-        1,
-        &vec![StacksPublicKey::from_private(&stacker_sk)],
-    )
-    .unwrap();
+
+    let pox_addr = PoxAddress::from_legacy(
+        AddressHashMode::SerializeP2PKH,
+        tests::to_addr(&stacker_sk).bytes,
+    );
+    let pox_addr_tuple: clarity::vm::Value = pox_addr.clone().as_clarity_tuple().unwrap().into();
     let reward_cycle = 7 as u128;
     let signer_pubkey = StacksPublicKey::from_private(&signer_sk);
-    let signature = make_signer_key_signature(
-        &PrincipalData::from(stacker.clone()),
-        &signer_sk,
-        reward_cycle,
-    );
+    let signature = make_signer_key_signature(&pox_addr, &signer_sk, reward_cycle);
 
     let stacking_tx = tests::make_contract_call(
         &stacker_sk,
@@ -406,7 +396,7 @@ pub fn boot_to_epoch_3(
 }
 
 fn make_signer_key_signature(
-    stacker: &PrincipalData,
+    pox_addr: &PoxAddress,
     signer_key: &StacksPrivateKey,
     reward_cycle: u128,
 ) -> Vec<u8> {
@@ -431,8 +421,8 @@ fn make_signer_key_signature(
     let data_tuple = clarity::vm::Value::Tuple(
         clarity::vm::types::TupleData::from_data(vec![
             (
-                "stacker".into(),
-                clarity::vm::Value::Principal(stacker.clone()),
+                "pox-addr".into(),
+                pox_addr.clone().as_clarity_tuple().unwrap().into(),
             ),
             (
                 "reward-cycle".into(),
@@ -955,11 +945,12 @@ fn correct_burn_outs() {
                 continue;
             };
 
-            let pox_addr_tuple = clarity::vm::tests::execute(&format!(
-                "{{ hashbytes: 0x{}, version: 0x{:02x} }}",
-                tests::to_addr(&account.0).bytes.to_hex(),
-                AddressHashMode::SerializeP2PKH as u8,
-            ));
+            let pox_addr = PoxAddress::from_legacy(
+                AddressHashMode::SerializeP2PKH,
+                tests::to_addr(&account.0).bytes,
+            );
+            let pox_addr_tuple: clarity::vm::Value =
+                pox_addr.clone().as_clarity_tuple().unwrap().into();
             // create a new SK, mixing in the nonce, because signing keys cannot (currently)
             //  be reused.
             let mut seed_inputs = account.0.to_bytes();
@@ -968,7 +959,7 @@ fn correct_burn_outs() {
             let pk_bytes = StacksPublicKey::from_private(&new_sk).to_bytes_compressed();
 
             let reward_cycle = pox_info.current_cycle.id;
-            let signature = make_signer_key_signature(&account.1, &new_sk, reward_cycle.into());
+            let signature = make_signer_key_signature(&pox_addr, &new_sk, reward_cycle.into());
 
             let stacking_tx = tests::make_contract_call(
                 &account.0,

From 1baec49caaa572f20688156d90255761d29c6639 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Mon, 29 Jan 2024 13:22:48 -0800
Subject: [PATCH 0583/1166] feat: helper function to generate structured domain
 tuple

---
 stackslib/src/chainstate/stacks/boot/mod.rs   | 19 ++------
 .../src/util_lib/signed_structured_data.rs    | 20 +++++++-
 .../src/tests/nakamoto_integrations.rs        | 46 ++++++-------------
 3 files changed, 37 insertions(+), 48 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 8489c3a3be..b5eb9ff98b 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -1401,7 +1401,9 @@ pub mod test {
     use crate::core::{StacksEpochId, *};
     use crate::net::test::*;
     use crate::util_lib::boot::{boot_code_id, boot_code_test_addr};
-    use crate::util_lib::signed_structured_data::sign_structured_data;
+    use crate::util_lib::signed_structured_data::{
+        make_structured_data_domain, sign_structured_data,
+    };
 
     pub const TESTNET_STACKING_THRESHOLD_25: u128 = 8000;
 
@@ -2216,20 +2218,7 @@ pub mod test {
         signer_key: &StacksPrivateKey,
         reward_cycle: u128,
     ) -> Vec<u8> {
-        let domain_tuple = Value::Tuple(
-            TupleData::from_data(vec![
-                (
-                    "name".into(),
-                    Value::string_ascii_from_bytes("pox-4-signer".into()).unwrap(),
-                ),
-                (
-                    "version".into(),
-                    Value::string_ascii_from_bytes("1.0.0".into()).unwrap(),
-                ),
-                ("chain-id".into(), Value::UInt(CHAIN_ID_TESTNET.into())),
-            ])
-            .unwrap(),
-        );
+        let domain_tuple = make_structured_data_domain("pox-4-signer", "1.0.0", CHAIN_ID_TESTNET);
 
         let data_tuple = Value::Tuple(
             TupleData::from_data(vec![
diff --git a/stackslib/src/util_lib/signed_structured_data.rs b/stackslib/src/util_lib/signed_structured_data.rs
index 213abfa50c..5d87f9d04f 100644
--- a/stackslib/src/util_lib/signed_structured_data.rs
+++ b/stackslib/src/util_lib/signed_structured_data.rs
@@ -14,7 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use clarity::vm::Value;
+use clarity::vm::{types::TupleData, Value};
 use stacks_common::{
     codec::StacksMessageCodec,
     types::PrivateKey,
@@ -56,6 +56,24 @@ pub fn sign_structured_data(
     private_key.sign(msg_hash.as_bytes())
 }
 
+// Helper function to generate domain for structured data hash
+pub fn make_structured_data_domain(name: &str, version: &str, chain_id: u32) -> Value {
+    Value::Tuple(
+        TupleData::from_data(vec![
+            (
+                "name".into(),
+                Value::string_ascii_from_bytes(name.into()).unwrap(),
+            ),
+            (
+                "version".into(),
+                Value::string_ascii_from_bytes(version.into()).unwrap(),
+            ),
+            ("chain-id".into(), Value::UInt(chain_id.into())),
+        ])
+        .unwrap(),
+    )
+}
+
 #[cfg(test)]
 mod test {
     use super::*;
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index c7559c158c..953d4c97f7 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -43,7 +43,7 @@ use stacks::net::api::postblock_proposal::{
     BlockValidateReject, BlockValidateResponse, NakamotoBlockProposal, ValidateRejectCode,
 };
 use stacks::util_lib::boot::boot_code_id;
-use stacks::util_lib::signed_structured_data::sign_structured_data;
+use stacks::util_lib::signed_structured_data::{make_structured_data_domain, sign_structured_data};
 use stacks_common::address::AddressHashMode;
 use stacks_common::codec::StacksMessageCodec;
 use stacks_common::consts::{CHAIN_ID_TESTNET, STACKS_EPOCH_MAX};
@@ -400,39 +400,21 @@ fn make_signer_key_signature(
     signer_key: &StacksPrivateKey,
     reward_cycle: u128,
 ) -> Vec<u8> {
-    let domain_tuple = clarity::vm::Value::Tuple(
-        clarity::vm::types::TupleData::from_data(vec![
-            (
-                "name".into(),
-                clarity::vm::Value::string_ascii_from_bytes("pox-4-signer".into()).unwrap(),
-            ),
-            (
-                "version".into(),
-                clarity::vm::Value::string_ascii_from_bytes("1.0.0".into()).unwrap(),
-            ),
-            (
-                "chain-id".into(),
-                clarity::vm::Value::UInt(CHAIN_ID_TESTNET.into()),
-            ),
-        ])
-        .unwrap(),
-    );
+    let domain_tuple = make_structured_data_domain("pox-4-signer", "1.0.0", CHAIN_ID_TESTNET);
 
-    let data_tuple = clarity::vm::Value::Tuple(
-        clarity::vm::types::TupleData::from_data(vec![
-            (
-                "pox-addr".into(),
-                pox_addr.clone().as_clarity_tuple().unwrap().into(),
-            ),
-            (
-                "reward-cycle".into(),
-                clarity::vm::Value::UInt(reward_cycle),
-            ),
-        ])
-        .unwrap(),
-    );
+    let data_tuple = clarity::vm::types::TupleData::from_data(vec![
+        (
+            "pox-addr".into(),
+            pox_addr.clone().as_clarity_tuple().unwrap().into(),
+        ),
+        (
+            "reward-cycle".into(),
+            clarity::vm::Value::UInt(reward_cycle),
+        ),
+    ])
+    .unwrap();
 
-    let signature = sign_structured_data(data_tuple, domain_tuple, signer_key).unwrap();
+    let signature = sign_structured_data(data_tuple.into(), domain_tuple, signer_key).unwrap();
 
     signature.to_rsv()
 }

From 020997c8e5e17585769cff23c528413f426f01e1 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Mon, 29 Jan 2024 13:52:19 -0800
Subject: [PATCH 0584/1166] feat: explicit sig validation tests for
 `stack-agg-commit`

---
 stackslib/src/chainstate/stacks/boot/mod.rs   |  17 ++-
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 131 ++++++++++++++++++
 2 files changed, 142 insertions(+), 6 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index b5eb9ff98b..3b5aa6e2c0 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -1382,7 +1382,7 @@ pub mod test {
     use clarity::vm::types::*;
     use stacks_common::types::PrivateKey;
     use stacks_common::util::hash::Sha256Sum;
-    use stacks_common::util::secp256k1::Secp256k1PrivateKey;
+    use stacks_common::util::secp256k1::{Secp256k1PrivateKey, Secp256k1PublicKey};
     use stacks_common::util::*;
 
     use super::*;
@@ -2146,17 +2146,22 @@ pub mod test {
     pub fn make_pox_4_aggregation_commit_indexed(
         key: &StacksPrivateKey,
         nonce: u64,
-        amount: u128,
-        delegate_to: PrincipalData,
-        until_burn_ht: Option<u128>,
-        pox_addr: PoxAddress,
+        pox_addr: &PoxAddress,
+        reward_cycle: u128,
+        signature: Vec<u8>,
+        signer_key: &Secp256k1PublicKey,
     ) -> StacksTransaction {
         let addr_tuple = Value::Tuple(pox_addr.as_clarity_tuple().unwrap());
         let payload = TransactionPayload::new_contract_call(
             boot_code_test_addr(),
             POX_4_NAME,
             "stack-aggregation-commit-indexed",
-            vec![addr_tuple, Value::UInt(amount)],
+            vec![
+                addr_tuple,
+                Value::UInt(reward_cycle),
+                Value::buff_from(signature).unwrap(),
+                Value::buff_from(signer_key.to_bytes_compressed()).unwrap(),
+            ],
         )
         .unwrap();
 
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index bf61a5befe..104644364d 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -1788,6 +1788,137 @@ fn stack_extend_verify_sig() {
     tx_result(valid_nonce).expect_result_ok();
 }
 
+#[test]
+/// Tests for verifying signatures in `stack-aggregation-commit`
+fn stack_agg_commit_verify_sig() {
+    let lock_period = 2;
+    let observer = TestEventObserver::new();
+    let (burnchain, mut peer, keys, latest_block, block_height, coinbase_nonce) =
+        prepare_pox4_test(function_name!(), Some(&observer));
+
+    let mut coinbase_nonce = coinbase_nonce;
+
+    let mut delegate_nonce = 0;
+    let stacker_nonce = 0;
+    let min_ustx = get_stacking_minimum(&mut peer, &latest_block);
+
+    let stacker_key = &keys[0];
+    let stacker_addr = PrincipalData::from(key_to_stacks_addr(&stacker_key));
+
+    let signer_sk = &keys[1];
+    let signer_pk = StacksPublicKey::from_private(signer_sk);
+
+    let delegate_key = &keys[2];
+    let delegate_addr = key_to_stacks_addr(&delegate_key);
+
+    let pox_addr = pox_addr_from(&delegate_key);
+
+    let reward_cycle = burnchain
+        .block_height_to_reward_cycle(block_height)
+        .unwrap() as u128;
+    let next_reward_cycle = reward_cycle + 1;
+
+    // Setup: delegate-stx and delegate-stack-stx
+
+    let delegate_tx = make_pox_4_delegate_stx(
+        &stacker_key,
+        stacker_nonce,
+        min_ustx,
+        delegate_addr.clone().into(),
+        None,
+        None,
+    );
+
+    let delegate_stack_stx_nonce = delegate_nonce;
+    let delegate_stack_stx_tx = make_pox_4_delegate_stack_stx(
+        &delegate_key,
+        delegate_nonce,
+        stacker_addr,
+        min_ustx,
+        pox_addr.clone(),
+        block_height.into(),
+        lock_period,
+    );
+
+    // Test 1: invalid reward cycle
+    delegate_nonce += 1;
+    let next_reward_cycle = reward_cycle + 1; // wrong cycle for signature
+    let signature = make_signer_key_signature(&pox_addr, &signer_sk, next_reward_cycle);
+    let invalid_cycle_nonce = delegate_nonce;
+    let invalid_cycle_tx = make_pox_4_aggregation_commit_indexed(
+        &delegate_key,
+        delegate_nonce,
+        &pox_addr,
+        next_reward_cycle,
+        signature,
+        &signer_pk,
+    );
+
+    // Test 2: invalid pox addr
+    delegate_nonce += 1;
+    let other_pox_addr = pox_addr_from(&Secp256k1PrivateKey::new());
+    let signature = make_signer_key_signature(&other_pox_addr, &signer_sk, reward_cycle);
+    let invalid_pox_addr_nonce = delegate_nonce;
+    let invalid_stacker_tx = make_pox_4_aggregation_commit_indexed(
+        &delegate_key,
+        delegate_nonce,
+        &pox_addr,
+        next_reward_cycle,
+        signature,
+        &signer_pk,
+    );
+
+    // Test 3: invalid signature
+    delegate_nonce += 1;
+    let signature = make_signer_key_signature(&pox_addr, &delegate_key, reward_cycle);
+    let invalid_key_nonce = delegate_nonce;
+    let invalid_key_tx = make_pox_4_aggregation_commit_indexed(
+        &delegate_key,
+        delegate_nonce,
+        &pox_addr,
+        next_reward_cycle,
+        signature,
+        &signer_pk,
+    );
+
+    // Test 4: valid signature
+    delegate_nonce += 1;
+    let signature = make_signer_key_signature(&pox_addr, &signer_sk, reward_cycle);
+    let valid_nonce = delegate_nonce;
+    let valid_tx = make_pox_4_aggregation_commit_indexed(
+        &delegate_key,
+        delegate_nonce,
+        &pox_addr,
+        next_reward_cycle,
+        signature,
+        &signer_pk,
+    );
+
+    peer.tenure_with_txs(
+        &[
+            delegate_tx,
+            delegate_stack_stx_tx,
+            invalid_cycle_tx,
+            invalid_stacker_tx,
+            invalid_key_tx,
+            valid_tx,
+        ],
+        &mut coinbase_nonce,
+    );
+
+    let txs = get_last_block_sender_transactions(&observer, delegate_addr);
+
+    let tx_result = |nonce: u64| -> Value { txs.get(nonce as usize).unwrap().result.clone() };
+
+    let expected_error = Value::error(Value::Int(35)).unwrap();
+
+    tx_result(delegate_stack_stx_nonce).expect_result_ok();
+    assert_eq!(tx_result(invalid_cycle_nonce), expected_error);
+    assert_eq!(tx_result(invalid_pox_addr_nonce), expected_error);
+    assert_eq!(tx_result(invalid_key_nonce), expected_error);
+    tx_result(valid_nonce).expect_result_ok();
+}
+
 pub fn assert_latest_was_burn(peer: &mut TestPeer) {
     let tip = get_tip(peer.sortdb.as_ref());
     let tip_index_block = tip.get_canonical_stacks_block_id();

From 10246f6afc9a64dc28a76d5e224a7875773cc210 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Wed, 31 Jan 2024 15:34:54 -0800
Subject: [PATCH 0585/1166] fix: improve `expect` msg, remove duplicate code

---
 stackslib/src/chainstate/stacks/boot/pox_4_tests.rs | 9 +--------
 1 file changed, 1 insertion(+), 8 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 104644364d..66c08e05b3 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -2325,19 +2325,12 @@ fn delegate_stack_stx_extend_signer_key() {
     .expect("No delegation state, delegate-stx failed")
     .expect_tuple();
 
-    let stacking_state = get_stacking_state_pox_4(
-        &mut peer,
-        &latest_block,
-        &key_to_stacks_addr(alice_stacker_key).into(),
-    )
-    .expect("No stacking state, stack-stx failed")
-    .expect_tuple();
     let delegation_state = get_delegation_state_pox_4(&mut peer, &latest_block, &alice_principal)
         .expect("No delegation state, delegate-stx failed")
         .expect_tuple();
 
     let stacking_state = get_stacking_state_pox_4(&mut peer, &latest_block, &alice_principal)
-        .expect("No stacking state, stack-stx failed")
+        .expect("No stacking state, bob called delegate-stack-stx that failed here")
         .expect_tuple();
 
     let reward_cycle = burnchain

From 30decf864581ba7eb2be3e97254cb50e1b415bcc Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Fri, 2 Feb 2024 09:15:22 -0800
Subject: [PATCH 0586/1166] fix: signer sig in nakamoto integrations

---
 testnet/stacks-node/src/tests/nakamoto_integrations.rs | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 953d4c97f7..666967345d 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -357,14 +357,19 @@ pub fn boot_to_epoch_3(
 
     // stack enough to activate pox-4
 
+    let block_height = btc_regtest_controller.get_headers_height();
+    let reward_cycle = btc_regtest_controller
+        .get_burnchain()
+        .block_height_to_reward_cycle(block_height)
+        .unwrap();
+
     let pox_addr = PoxAddress::from_legacy(
         AddressHashMode::SerializeP2PKH,
         tests::to_addr(&stacker_sk).bytes,
     );
     let pox_addr_tuple: clarity::vm::Value = pox_addr.clone().as_clarity_tuple().unwrap().into();
-    let reward_cycle = 7 as u128;
     let signer_pubkey = StacksPublicKey::from_private(&signer_sk);
-    let signature = make_signer_key_signature(&pox_addr, &signer_sk, reward_cycle);
+    let signature = make_signer_key_signature(&pox_addr, &signer_sk, reward_cycle.into());
 
     let stacking_tx = tests::make_contract_call(
         &stacker_sk,

From db11669d4a573c6fd029869fcc8d8a191d06f7fc Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Fri, 2 Feb 2024 09:53:24 -0800
Subject: [PATCH 0587/1166] fix: generating sha in signed_structured_data

---
 stackslib/src/util_lib/signed_structured_data.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stackslib/src/util_lib/signed_structured_data.rs b/stackslib/src/util_lib/signed_structured_data.rs
index 5d87f9d04f..ea4931b3d3 100644
--- a/stackslib/src/util_lib/signed_structured_data.rs
+++ b/stackslib/src/util_lib/signed_structured_data.rs
@@ -29,7 +29,7 @@ pub const STRUCTURED_DATA_PREFIX: [u8; 6] = [0x53, 0x49, 0x50, 0x30, 0x31, 0x38]
 
 pub fn structured_data_hash(value: Value) -> Sha256Sum {
     let bytes = value.serialize_to_vec();
-    Sha256Sum::from_data(&bytes)
+    Sha256Sum::from_data(&bytes.as_slice())
 }
 
 /// Generate a message hash for signing structured Clarity data.

From 1d7caa7c62f0c5ccdda592364840e3406cf66725 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Fri, 2 Feb 2024 10:08:08 -0800
Subject: [PATCH 0588/1166] fix: try fixing compiler error on serialization

---
 stackslib/src/util_lib/signed_structured_data.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/stackslib/src/util_lib/signed_structured_data.rs b/stackslib/src/util_lib/signed_structured_data.rs
index ea4931b3d3..17db6d32fc 100644
--- a/stackslib/src/util_lib/signed_structured_data.rs
+++ b/stackslib/src/util_lib/signed_structured_data.rs
@@ -28,7 +28,8 @@ use stacks_common::{
 pub const STRUCTURED_DATA_PREFIX: [u8; 6] = [0x53, 0x49, 0x50, 0x30, 0x31, 0x38];
 
 pub fn structured_data_hash(value: Value) -> Sha256Sum {
-    let bytes = value.serialize_to_vec();
+    let mut bytes = vec![];
+    value.serialize_write(&mut bytes).unwrap();
     Sha256Sum::from_data(&bytes.as_slice())
 }
 

From 4bb930d49d7d398773894b03210b8285b07faf78 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Fri, 2 Feb 2024 12:28:36 -0800
Subject: [PATCH 0589/1166] fix: proper stack-stx signature in mockamoto tests

---
 testnet/stacks-node/src/mockamoto.rs | 44 ++++++++++++++++++++++++++--
 1 file changed, 41 insertions(+), 3 deletions(-)

diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index 9f11a872ef..7b570b1e3c 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -69,6 +69,7 @@ use stacks::net::atlas::{AtlasConfig, AtlasDB};
 use stacks::net::relay::Relayer;
 use stacks::net::stackerdb::StackerDBs;
 use stacks::util_lib::db::Error as DBError;
+use stacks::util_lib::signed_structured_data::{make_structured_data_domain, sign_structured_data};
 use stacks_common::address::{AddressHashMode, C32_ADDRESS_VERSION_TESTNET_SINGLESIG};
 use stacks_common::bitvec::BitVec;
 use stacks_common::codec::StacksMessageCodec;
@@ -81,7 +82,7 @@ use stacks_common::types::chainstate::{
 };
 use stacks_common::types::{PrivateKey, StacksEpochId};
 use stacks_common::util::hash::{to_hex, Hash160, MerkleTree, Sha512Trunc256Sum};
-use stacks_common::util::secp256k1::{MessageSignature, Secp256k1PublicKey};
+use stacks_common::util::secp256k1::{MessageSignature, Secp256k1PrivateKey, Secp256k1PublicKey};
 use stacks_common::util::vrf::{VRFPrivateKey, VRFProof, VRFPublicKey, VRF};
 
 use self::signer::SelfSigner;
@@ -832,8 +833,18 @@ impl MockamotoNode {
             Some(AddressHashMode::SerializeP2PKH),
         );
 
-        let mut signer_key = miner_nonce.to_be_bytes().to_vec();
-        signer_key.resize(33, 0);
+        let signer_sk = Secp256k1PrivateKey::from_seed(&miner_nonce.to_be_bytes());
+        let signer_key = Secp256k1PublicKey::from_private(&signer_sk).to_bytes_compressed();
+
+        let block_height = sortition_tip.block_height;
+        let reward_cycle = self
+            .sortdb
+            .pox_constants
+            .block_height_to_reward_cycle(self.sortdb.first_block_height, block_height)
+            .unwrap();
+
+        let signature =
+            make_signer_key_signature(&pox_address, &signer_sk, reward_cycle.into(), chain_id);
 
         let stack_stx_payload = if parent_chain_length < 2 {
             TransactionPayload::ContractCall(TransactionContractCall {
@@ -845,6 +856,7 @@ impl MockamotoNode {
                     pox_address.as_clarity_tuple().unwrap().into(),
                     ClarityValue::UInt(u128::from(parent_burn_height)),
                     ClarityValue::UInt(12),
+                    ClarityValue::buff_from(signature).unwrap(),
                     ClarityValue::buff_from(signer_key).unwrap(),
                 ],
             })
@@ -858,6 +870,7 @@ impl MockamotoNode {
                 function_args: vec![
                     ClarityValue::UInt(5),
                     pox_address.as_clarity_tuple().unwrap().into(),
+                    ClarityValue::buff_from(signature).unwrap(),
                     ClarityValue::buff_from(signer_key).unwrap(),
                 ],
             })
@@ -1019,3 +1032,28 @@ impl MockamotoNode {
         Ok(chain_length)
     }
 }
+
+fn make_signer_key_signature(
+    pox_addr: &PoxAddress,
+    signer_key: &StacksPrivateKey,
+    reward_cycle: u128,
+    chain_id: u32,
+) -> Vec<u8> {
+    let domain_tuple = make_structured_data_domain("pox-4-signer", "1.0.0", chain_id);
+
+    let data_tuple = clarity::vm::types::TupleData::from_data(vec![
+        (
+            "pox-addr".into(),
+            pox_addr.clone().as_clarity_tuple().unwrap().into(),
+        ),
+        (
+            "reward-cycle".into(),
+            clarity::vm::Value::UInt(reward_cycle),
+        ),
+    ])
+    .unwrap();
+
+    let signature = sign_structured_data(data_tuple.into(), domain_tuple, signer_key).unwrap();
+
+    signature.to_rsv()
+}

From aa3fd46f241897da86b79c27f0300352ea51c235 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Fri, 2 Feb 2024 12:28:56 -0800
Subject: [PATCH 0590/1166] fix: arguments used in synthetic pox events

---
 pox-locking/src/events.rs | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/pox-locking/src/events.rs b/pox-locking/src/events.rs
index 81ab9fdee5..ac5c0cc443 100644
--- a/pox-locking/src/events.rs
+++ b/pox-locking/src/events.rs
@@ -129,6 +129,8 @@ fn create_event_info_data_code(
                         ;; equal to args[3]
                         lock-period: {lock_period},
                         ;; equal to args[4]
+                        signer-sig: {signer_sig}
+                        ;; equal to args[5]
                         signer-key: {signer_key}
                     }}
                 }}
@@ -137,7 +139,8 @@ fn create_event_info_data_code(
                 lock_period = &args[3],
                 pox_addr = &args[1],
                 start_burn_height = &args[2],
-                signer_key = &args.get(4).unwrap_or(&Value::none()),
+                signer_sig = &args.get(4).unwrap_or(&Value::none()),
+                signer_key = &args.get(5).unwrap_or(&Value::none()),
             )
         }
         "delegate-stack-stx" => {
@@ -313,13 +316,16 @@ fn create_event_info_data_code(
                         ;; delegator (this is the caller)
                         delegator: tx-sender,
                         ;; equal to args[2]
+                        signer-sig: {signer_sig}
+                        ;; equal to args[3]
                         signer-key: {signer_key}
                     }}
                 }}
                 "#,
                 pox_addr = &args[0],
                 reward_cycle = &args[1],
-                signer_key = &args.get(2).unwrap_or(&Value::none()),
+                signer_sig = &args.get(2).unwrap_or(&Value::none()),
+                signer_key = &args.get(3).unwrap_or(&Value::none()),
             )
         }
         "stack-aggregation-increase" => {

From a5b313518078246af3debd38b1d6f2daf20dafb4 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Fri, 2 Feb 2024 12:32:52 -0800
Subject: [PATCH 0591/1166] fix: typo in synthetic events

---
 pox-locking/src/events.rs | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/pox-locking/src/events.rs b/pox-locking/src/events.rs
index ac5c0cc443..a3f08d9df6 100644
--- a/pox-locking/src/events.rs
+++ b/pox-locking/src/events.rs
@@ -129,9 +129,9 @@ fn create_event_info_data_code(
                         ;; equal to args[3]
                         lock-period: {lock_period},
                         ;; equal to args[4]
-                        signer-sig: {signer_sig}
+                        signer-sig: {signer_sig},
                         ;; equal to args[5]
-                        signer-key: {signer_key}
+                        signer-key: {signer_key},
                     }}
                 }}
                 "#,
@@ -167,7 +167,7 @@ fn create_event_info_data_code(
                         delegator: tx-sender,
                         ;; stacker
                         ;; equal to args[0]
-                        stacker: '{stacker}
+                        stacker: '{stacker},
                     }}
                 }}
                 "#,
@@ -252,13 +252,16 @@ fn create_event_info_data_code(
                         ;; new unlock burnchain block height
                         unlock-burn-height: new-unlock-ht,
                         ;; equal to args[2]
-                        signer-key: {signer_key}
+                        signer-sig: {signer_sig},
+                        ;; equal to args[3]
+                        signer-key: {signer_key},
                     }}
                 }})
                 "#,
                 extend_count = &args[0],
                 pox_addr = &args[1],
-                signer_key = &args.get(2).map_or("none".to_string(), |v| v.to_string()),
+                signer_sig = &args.get(2).unwrap_or(&Value::none()),
+                signer_key = &args.get(3).map_or("none".to_string(), |v| v.to_string()),
             )
         }
         "delegate-stack-extend" => {

From 53427cfb768b30321fe6213a208a322085652218 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Fri, 2 Feb 2024 13:05:24 -0800
Subject: [PATCH 0592/1166] feat: test for correct lock event

---
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 20 +++++++++++++++++--
 1 file changed, 18 insertions(+), 2 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 66c08e05b3..45a2bf2313 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -26,7 +26,7 @@ use clarity::vm::errors::{
     CheckErrors, Error, IncomparableError, InterpreterError, InterpreterResult, RuntimeErrorType,
 };
 use clarity::vm::eval;
-use clarity::vm::events::StacksTransactionEvent;
+use clarity::vm::events::{STXEventType, STXLockEventData, StacksTransactionEvent};
 use clarity::vm::representations::SymbolicExpression;
 use clarity::vm::tests::{execute, is_committed, is_err_code, symbols_from_values};
 use clarity::vm::types::Value::Response;
@@ -1993,8 +1993,9 @@ fn balances_from_keys(
 
 #[test]
 fn stack_stx_signer_key() {
+    let observer = TestEventObserver::new();
     let (burnchain, mut peer, keys, latest_block, block_height, mut coinbase_nonce) =
-        prepare_pox4_test(function_name!(), None);
+        prepare_pox4_test(function_name!(), Some(&observer));
 
     let stacker_nonce = 0;
     let stacker_key = &keys[0];
@@ -2037,6 +2038,21 @@ fn stack_stx_signer_key() {
     .expect("No stacking state, stack-stx failed")
     .expect_tuple();
 
+    let stacker_txs =
+        get_last_block_sender_transactions(&observer, key_to_stacks_addr(&stacker_key));
+
+    let stacking_tx = stacker_txs.get(0).unwrap();
+    let events: Vec<&STXLockEventData> = stacking_tx
+        .events
+        .iter()
+        .filter_map(|e| match e {
+            StacksTransactionEvent::STXEvent(STXEventType::STXLockEvent(data)) => Some(data),
+            _ => None,
+        })
+        .collect();
+
+    assert_eq!(events.get(0).unwrap().locked_amount, min_ustx);
+
     let next_reward_cycle = 1 + burnchain
         .block_height_to_reward_cycle(block_height)
         .unwrap();

From 3c0bbb26e6e6c5205bd9f91dee5208d7754cf423 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Fri, 2 Feb 2024 13:41:23 -0800
Subject: [PATCH 0593/1166] fix: fix stack-stx sig in new tests from merge

---
 stackslib/src/net/tests/mod.rs | 17 +++++++++++++++--
 1 file changed, 15 insertions(+), 2 deletions(-)

diff --git a/stackslib/src/net/tests/mod.rs b/stackslib/src/net/tests/mod.rs
index 5fd3d65e9a..c05919eac7 100644
--- a/stackslib/src/net/tests/mod.rs
+++ b/stackslib/src/net/tests/mod.rs
@@ -41,7 +41,7 @@ use crate::chainstate::nakamoto::tests::node::{TestSigners, TestStacker};
 use crate::chainstate::nakamoto::{NakamotoBlock, NakamotoChainState};
 use crate::chainstate::stacks::address::PoxAddress;
 use crate::chainstate::stacks::boot::test::{
-    key_to_stacks_addr, make_pox_4_aggregate_key, make_pox_4_lockup,
+    key_to_stacks_addr, make_pox_4_aggregate_key, make_pox_4_lockup, make_signer_key_signature,
 };
 use crate::chainstate::stacks::boot::MINERS_NAME;
 use crate::chainstate::stacks::db::{MinerPaymentTxFees, StacksAccount, StacksChainState};
@@ -309,6 +309,11 @@ impl NakamotoBootPlan {
         debug!("Make PoX-4 lockups");
         debug!("========================\n\n");
 
+        let reward_cycle = peer
+            .config
+            .burnchain
+            .reward_cycle_to_block_height(sortition_height);
+
         // Make all the test Stackers stack
         let stack_txs: Vec<_> = peer
             .config
@@ -317,14 +322,22 @@ impl NakamotoBootPlan {
             .unwrap_or(vec![])
             .iter()
             .map(|test_stacker| {
+                let pox_addr =
+                    PoxAddress::from_legacy(AddressHashMode::SerializeP2PKH, addr.bytes.clone());
+                let signature = make_signer_key_signature(
+                    &pox_addr,
+                    &test_stacker.signer_private_key,
+                    reward_cycle.into(),
+                );
                 make_pox_4_lockup(
                     &test_stacker.stacker_private_key,
                     0,
                     test_stacker.amount,
-                    PoxAddress::from_legacy(AddressHashMode::SerializeP2PKH, addr.bytes.clone()),
+                    pox_addr,
                     12,
                     StacksPublicKey::from_private(&test_stacker.signer_private_key),
                     34,
+                    signature,
                 )
             })
             .collect();

From 7f71cbdff62c83f8a8dcc24cfe9b677bccef0751 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Fri, 2 Feb 2024 14:07:42 -0800
Subject: [PATCH 0594/1166] fix: compiler unhandled result error

---
 pox-locking/src/events.rs                     |  4 ++--
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 20 ++++++++++++++-----
 2 files changed, 17 insertions(+), 7 deletions(-)

diff --git a/pox-locking/src/events.rs b/pox-locking/src/events.rs
index a3f08d9df6..6460455ba0 100644
--- a/pox-locking/src/events.rs
+++ b/pox-locking/src/events.rs
@@ -319,9 +319,9 @@ fn create_event_info_data_code(
                         ;; delegator (this is the caller)
                         delegator: tx-sender,
                         ;; equal to args[2]
-                        signer-sig: {signer_sig}
+                        signer-sig: {signer_sig},
                         ;; equal to args[3]
-                        signer-key: {signer_key}
+                        signer-key: {signer_key},
                     }}
                 }}
                 "#,
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 45a2bf2313..a779149e3a 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -1670,7 +1670,9 @@ fn stack_stx_verify_signer_sig() {
     assert_eq!(tx_result(invalid_key_nonce), expected_error);
 
     // valid tx should succeed
-    tx_result(valid_nonce).expect_result_ok();
+    tx_result(valid_nonce)
+        .expect_result_ok()
+        .expect("Expected ok result from tx");
 }
 
 #[test]
@@ -1781,11 +1783,15 @@ fn stack_extend_verify_sig() {
         |nonce: u64| -> Value { stacker_txs.get(nonce as usize).unwrap().result.clone() };
 
     let expected_error = Value::error(Value::Int(35)).unwrap();
-    tx_result(stack_nonce).expect_result_ok();
+    tx_result(stack_nonce)
+        .expect_result_ok()
+        .expect("Expected ok result from tx");
     assert_eq!(tx_result(invalid_cycle_nonce), expected_error);
     assert_eq!(tx_result(invalid_stacker_nonce), expected_error);
     assert_eq!(tx_result(invalid_key_nonce), expected_error);
-    tx_result(valid_nonce).expect_result_ok();
+    tx_result(valid_nonce)
+        .expect_result_ok()
+        .expect("Expected ok result from tx");
 }
 
 #[test]
@@ -1912,11 +1918,15 @@ fn stack_agg_commit_verify_sig() {
 
     let expected_error = Value::error(Value::Int(35)).unwrap();
 
-    tx_result(delegate_stack_stx_nonce).expect_result_ok();
+    tx_result(delegate_stack_stx_nonce)
+        .expect_result_ok()
+        .expect("Expected ok result from tx");
     assert_eq!(tx_result(invalid_cycle_nonce), expected_error);
     assert_eq!(tx_result(invalid_pox_addr_nonce), expected_error);
     assert_eq!(tx_result(invalid_key_nonce), expected_error);
-    tx_result(valid_nonce).expect_result_ok();
+    tx_result(valid_nonce)
+        .expect_result_ok()
+        .expect("Expected ok result from tx");
 }
 
 pub fn assert_latest_was_burn(peer: &mut TestPeer) {

From 9286c3210a0dde45295b4f5ec7726dbde03cfdc6 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Thu, 25 Jan 2024 13:44:33 -0800
Subject: [PATCH 0595/1166] Make miner retrieve signer messages from stackerdb
 to get a signed block

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stackslib/src/net/stackerdb/db.rs             |  28 ++++
 testnet/stacks-node/Cargo.toml                |   2 +-
 testnet/stacks-node/src/config.rs             |  17 +++
 .../stacks-node/src/nakamoto_node/miner.rs    | 137 ++++++++++++++++--
 4 files changed, 171 insertions(+), 13 deletions(-)

diff --git a/stackslib/src/net/stackerdb/db.rs b/stackslib/src/net/stackerdb/db.rs
index 3adc8845a7..0e1665cea7 100644
--- a/stackslib/src/net/stackerdb/db.rs
+++ b/stackslib/src/net/stackerdb/db.rs
@@ -537,6 +537,19 @@ impl StackerDBs {
         query_row(&self.conn, &sql, args).map_err(|e| e.into())
     }
 
+    /// Get all principals who can write to a particular stacker DB.
+    /// Returns Ok(list of addr) if this contract exists in the DB
+    /// Returns Err(..) if the DB doesn't exist of some other DB error happens
+    pub fn get_signers(
+        &self,
+        smart_contract: &QualifiedContractIdentifier,
+    ) -> Result<Vec<StacksAddress>, net_error> {
+        let stackerdb_id = self.get_stackerdb_id(smart_contract)?;
+        let sql = "SELECT signer FROM chunks WHERE stackerdb_id = ?1 GROUP BY signer";
+        let args: &[&dyn ToSql] = &[&stackerdb_id];
+        query_rows(&self.conn, &sql, args).map_err(|e| e.into())
+    }
+
     /// Get the slot metadata
     pub fn get_slot_metadata(
         &self,
@@ -627,6 +640,21 @@ impl StackerDBs {
             .map_err(|e| e.into())
     }
 
+    /// Get the latest chunk out of the database for each provided slot
+    /// Returns Ok(list of data)
+    /// Returns Err(..) if the DB does not exist, or some other DB error occurs
+    pub fn get_latest_chunks(
+        &self,
+        smart_contract: &QualifiedContractIdentifier,
+        slot_ids: &[u32],
+    ) -> Result<Vec<Option<Vec<u8>>>, net_error> {
+        let mut results = vec![];
+        for slot_id in slot_ids {
+            results.push(self.get_latest_chunk(smart_contract, *slot_id)?);
+        }
+        Ok(results)
+    }
+
     /// Get a versioned chunk out of this database.  If the version is not present, then None will
     /// be returned.
     pub fn get_chunk(
diff --git a/testnet/stacks-node/Cargo.toml b/testnet/stacks-node/Cargo.toml
index ed2b8f6690..ae68c95398 100644
--- a/testnet/stacks-node/Cargo.toml
+++ b/testnet/stacks-node/Cargo.toml
@@ -31,6 +31,7 @@ wsts = { workspace = true }
 rand = { workspace = true }
 rand_core = { workspace = true }
 hashbrown = "0.14"
+bincode = "1.3.3"
 
 [dev-dependencies]
 ring = "0.16.19"
@@ -44,7 +45,6 @@ stacks-signer = { path = "../../stacks-signer" }
 tracing = "0.1.37"
 tracing-subscriber = { version = "0.3.17", features = ["env-filter"] }
 wsts = {workspace = true}
-bincode = "1.3.3"
 
 [dependencies.rusqlite]
 version = "=0.24.2"
diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index 344f7bbb8b..8300973247 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -1994,6 +1994,10 @@ pub struct MinerConfig {
     /// When selecting the "nicest" tip, do not consider tips that are more than this many blocks
     /// behind the highest tip.
     pub max_reorg_depth: u64,
+    /// Amount of time while mining in nakamoto to wait for signers to respond to a proposed block
+    pub wait_on_signers: Duration,
+    /// The number of rejections as a percentage for a block to receive from signers before proposing a new block
+    pub signer_rejection_threshold: usize,
 }
 
 impl Default for MinerConfig {
@@ -2022,6 +2026,9 @@ impl Default for MinerConfig {
             txs_to_consider: MemPoolWalkTxTypes::all(),
             filter_origins: HashSet::new(),
             max_reorg_depth: 3,
+            // TODO: update to a sane value based on stackerdb benchmarking
+            wait_on_signers: Duration::from_millis(10_000),
+            signer_rejection_threshold: 30,
         }
     }
 }
@@ -2346,6 +2353,8 @@ pub struct MinerConfigFile {
     pub txs_to_consider: Option<String>,
     pub filter_origins: Option<String>,
     pub max_reorg_depth: Option<u64>,
+    pub wait_on_signers_ms: Option<u64>,
+    pub signer_rection_threshold: Option<usize>,
 }
 
 impl MinerConfigFile {
@@ -2446,6 +2455,14 @@ impl MinerConfigFile {
             max_reorg_depth: self
                 .max_reorg_depth
                 .unwrap_or(miner_default_config.max_reorg_depth),
+            wait_on_signers: self
+                .wait_on_signers_ms
+                .map(Duration::from_millis)
+                .unwrap_or(miner_default_config.wait_on_signers),
+            signer_rejection_threshold: self
+                .signer_rection_threshold
+                .map(|threshold| std::cmp::min(threshold, 100))
+                .unwrap_or(miner_default_config.signer_rejection_threshold),
         })
     }
 }
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index fef3379fbd..4ec9cedefc 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -20,13 +20,16 @@ use std::time::{Duration, Instant};
 
 use clarity::boot_util::boot_code_id;
 use clarity::vm::types::PrincipalData;
-use libsigner::{SignerSession, StackerDBSession};
+use libsigner::{
+    BlockResponse, SignerMessage, SignerSession, StackerDBSession, BLOCK_SLOT_ID,
+    SIGNER_SLOTS_PER_USER,
+};
 use stacks::burnchains::{Burnchain, BurnchainParameters};
 use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::burn::{BlockSnapshot, ConsensusHash};
 use stacks::chainstate::nakamoto::miner::{NakamotoBlockBuilder, NakamotoTenureInfo};
 use stacks::chainstate::nakamoto::{NakamotoBlock, NakamotoChainState};
-use stacks::chainstate::stacks::boot::MINERS_NAME;
+use stacks::chainstate::stacks::boot::{MINERS_NAME, SIGNERS_NAME};
 use stacks::chainstate::stacks::db::{StacksChainState, StacksHeaderInfo};
 use stacks::chainstate::stacks::{
     CoinbasePayload, Error as ChainstateError, StacksTransaction, StacksTransactionSigner,
@@ -37,8 +40,9 @@ use stacks::core::FIRST_BURNCHAIN_CONSENSUS_HASH;
 use stacks::net::stackerdb::StackerDBs;
 use stacks_common::types::chainstate::{StacksAddress, StacksBlockId};
 use stacks_common::types::{PrivateKey, StacksEpochId};
-use stacks_common::util::hash::Hash160;
+use stacks_common::util::hash::{Hash160, Sha512Trunc256Sum};
 use stacks_common::util::vrf::VRFProof;
+use wsts::curve::point::Point;
 
 use super::relayer::RelayerThread;
 use super::{Config, Error as NakamotoNodeError, EventDispatcher, Keychain};
@@ -51,6 +55,9 @@ use crate::{neon_node, ChainTip};
 /// If the miner was interrupted while mining a block, how long should the
 ///  miner thread sleep before trying again?
 const ABORT_TRY_AGAIN_MS: u64 = 200;
+/// If the signers have not responded to a block proposal, how long should
+///  the miner thread sleep before trying again?
+const WAIT_FOR_SIGNERS_MS: u64 = 200;
 
 pub enum MinerDirective {
     /// The miner won sortition so they should begin a new tenure
@@ -140,6 +147,14 @@ impl BlockMinerThread {
         let miners_contract_id = boot_code_id(MINERS_NAME, self.config.is_mainnet());
         let stackerdbs = StackerDBs::connect(&self.config.get_stacker_db_file_path(), true)
             .expect("FATAL: failed to connect to stacker DB");
+        let rpc_sock = self.config.node.rpc_bind.parse().expect(&format!(
+            "Failed to parse socket: {}",
+            &self.config.node.rpc_bind
+        ));
+        let Some(miner_privkey) = self.config.miner.mining_key else {
+            warn!("No mining key configured, cannot mine");
+            return;
+        };
         // now, actually run this tenure
         loop {
             let new_block = loop {
@@ -174,10 +189,11 @@ impl BlockMinerThread {
             let tip = SortitionDB::get_canonical_burn_chain_tip(sort_db.conn())
                 .expect("FATAL: could not retrieve chain tip");
             if let Some(new_block) = new_block {
-                let Some(miner_privkey) = self.config.miner.mining_key else {
-                    warn!("No mining key configured, cannot mine");
-                    return;
-                };
+                let signer_signature_hash = new_block
+                    .header
+                    .signer_signature_hash()
+                    .expect("FATAL: failed to mine a block with a valid signer signature hash");
+
                 match NakamotoBlockBuilder::make_stackerdb_block_proposal(
                     &sort_db,
                     &tip,
@@ -188,11 +204,6 @@ impl BlockMinerThread {
                 ) {
                     Ok(Some(chunk)) => {
                         // Propose the block to the observing signers through the .miners stackerdb instance
-                        let rpc_sock = self.config.node.rpc_bind.parse().expect(&format!(
-                            "Failed to parse socket: {}",
-                            &self.config.node.rpc_bind
-                        ));
-
                         let miner_contract_id = boot_code_id(MINERS_NAME, self.config.is_mainnet());
                         let mut miners_stackerdb =
                             StackerDBSession::new(rpc_sock, miner_contract_id);
@@ -213,6 +224,24 @@ impl BlockMinerThread {
                         warn!("Failed to propose block to stackerdb: {e:?}");
                     }
                 }
+                let mut chain_state = neon_node::open_chainstate_with_faults(&self.config)
+                    .expect("FATAL: could not open chainstate DB");
+                if let Ok(aggregate_public_key) = NakamotoChainState::get_aggregate_public_key(
+                    &mut chain_state,
+                    &sort_db,
+                    &sort_db.index_handle_at_tip(),
+                    &new_block,
+                ) {
+                    if let Some(_signed_block) = self.wait_for_signed_block(
+                        &stackerdbs,
+                        &aggregate_public_key,
+                        &signer_signature_hash,
+                    ) {
+                        // TODO: append the signed block instead of the self signed block
+                    } else {
+                        debug!("Failed to get a signed block from signers");
+                    }
+                };
                 if let Some(self_signer) = self.config.self_signing() {
                     if let Err(e) = self.self_sign_and_broadcast(self_signer, new_block.clone()) {
                         warn!("Error self-signing block: {e:?}");
@@ -241,6 +270,90 @@ impl BlockMinerThread {
         }
     }
 
+    fn wait_for_signed_block(
+        &self,
+        stackerdbs: &StackerDBs,
+        aggregate_public_key: &Point,
+        signer_signature_hash: &Sha512Trunc256Sum,
+    ) -> Option<NakamotoBlock> {
+        let stackerdb_contracts = stackerdbs
+            .get_stackerdb_contract_ids()
+            .expect("FATAL: could not get the stacker DB contract ids");
+        // TODO: get this directly instead of this jankiness when .signers is a boot contract
+        let signers_contract_id = boot_code_id(SIGNERS_NAME, self.config.is_mainnet());
+        if !stackerdb_contracts.contains(&signers_contract_id) {
+            debug!("No signers contract found, cannot wait for signers");
+            return None;
+        };
+        // Get the block slot for every signer
+        let slot_ids = stackerdbs
+            .get_signers(&signers_contract_id)
+            .expect("FATAL: could not get signers from stacker DB")
+            .iter()
+            .enumerate()
+            .map(|(id, _)| id as u32 * SIGNER_SLOTS_PER_USER + BLOCK_SLOT_ID)
+            .collect::<Vec<u32>>();
+        // If more than a threshold percentage of the signers reject the block, we should not wait any further
+        let rejection_threshold =
+            slot_ids.len() / 100 * self.config.miner.signer_rejection_threshold;
+        let mut num_rejections = 0;
+        let now = Instant::now();
+        while now.elapsed() < self.config.miner.wait_on_signers {
+            // Get the block responses from the signers for the block we just proposed
+            let signer_messages: Vec<SignerMessage> = stackerdbs
+                .get_latest_chunks(&signers_contract_id, &slot_ids)
+                .expect("FATAL: could not get latest chunks from stacker DB")
+                .into_iter()
+                .filter_map(|chunk| {
+                    chunk.and_then(|chunk| bincode::deserialize::<SignerMessage>(&chunk).ok())
+                })
+                .collect();
+            for signer_message in signer_messages {
+                match signer_message {
+                    SignerMessage::BlockResponse(BlockResponse::Accepted(block)) => {
+                        if block.header.signer_signature_hash().ok()? == *signer_signature_hash
+                            && block
+                                .header
+                                .signer_signature
+                                .verify(aggregate_public_key, &signer_signature_hash.0)
+                        {
+                            // We verified that the returned block contains a valid signature across the signer signature hash of our original block request
+                            // Let's just immediately attempt to append the block without waiting for more signer messages
+                            return Some(block);
+                        }
+                    }
+                    SignerMessage::BlockResponse(BlockResponse::Rejected(block_rejection)) => {
+                        // First check that this block rejection is for the block we proposed
+                        if block_rejection.block.header.signer_signature_hash().ok()?
+                            == *signer_signature_hash
+                        {
+                            let signature = block_rejection.block.header.signer_signature;
+                            let mut message = signer_signature_hash.0.to_vec();
+                            message.push(b'n');
+                            if signature.verify(aggregate_public_key, &message) {
+                                // We received a verified rejection. We will NEVER get a signed block from the signers for this particular block
+                                return None;
+                            } else if signature
+                                .verify(aggregate_public_key, &signer_signature_hash.0)
+                            {
+                                // We received an unverified rejection. We will keep waiting for a threshold number of rejections
+                                num_rejections += 1;
+                                if num_rejections > rejection_threshold {
+                                    return None;
+                                }
+                            }
+                        }
+                    }
+                    _ => {} // Any other message is ignored
+                }
+            }
+            // We have not received a signed block or enough information to reject the proposed block. Wait a bit and try again.
+            thread::sleep(Duration::from_millis(WAIT_FOR_SIGNERS_MS));
+        }
+        // We have waited for the signers for too long: stop waiting so we can propose a new block
+        None
+    }
+
     fn self_sign_and_broadcast(
         &self,
         mut signer: SelfSigner,

From 078684f16639a718246730676461ba8ca5d75290 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Tue, 30 Jan 2024 10:27:43 -0800
Subject: [PATCH 0596/1166] Fix build issues due to rebase

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 .../stacks-node/src/nakamoto_node/miner.rs    | 94 +++++++++++--------
 testnet/stacks-node/src/tests/signer.rs       |  2 +-
 2 files changed, 55 insertions(+), 41 deletions(-)

diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index 4ec9cedefc..ff2bd0b51d 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -20,8 +20,9 @@ use std::time::{Duration, Instant};
 
 use clarity::boot_util::boot_code_id;
 use clarity::vm::types::PrincipalData;
+use hashbrown::HashSet;
 use libsigner::{
-    BlockResponse, SignerMessage, SignerSession, StackerDBSession, BLOCK_SLOT_ID,
+    BlockResponse, RejectCode, SignerMessage, SignerSession, StackerDBSession, BLOCK_SLOT_ID,
     SIGNER_SLOTS_PER_USER,
 };
 use stacks::burnchains::{Burnchain, BurnchainParameters};
@@ -33,8 +34,8 @@ use stacks::chainstate::stacks::boot::{MINERS_NAME, SIGNERS_NAME};
 use stacks::chainstate::stacks::db::{StacksChainState, StacksHeaderInfo};
 use stacks::chainstate::stacks::{
     CoinbasePayload, Error as ChainstateError, StacksTransaction, StacksTransactionSigner,
-    TenureChangeCause, TenureChangePayload, TransactionAnchorMode, TransactionPayload,
-    TransactionVersion,
+    TenureChangeCause, TenureChangePayload, ThresholdSignature, TransactionAnchorMode,
+    TransactionPayload, TransactionVersion,
 };
 use stacks::core::FIRST_BURNCHAIN_CONSENSUS_HASH;
 use stacks::net::stackerdb::StackerDBs;
@@ -188,11 +189,8 @@ impl BlockMinerThread {
             .expect("FATAL: could not open sortition DB");
             let tip = SortitionDB::get_canonical_burn_chain_tip(sort_db.conn())
                 .expect("FATAL: could not retrieve chain tip");
-            if let Some(new_block) = new_block {
-                let signer_signature_hash = new_block
-                    .header
-                    .signer_signature_hash()
-                    .expect("FATAL: failed to mine a block with a valid signer signature hash");
+            if let Some(mut new_block) = new_block {
+                let signer_signature_hash = new_block.header.signer_signature_hash();
 
                 match NakamotoBlockBuilder::make_stackerdb_block_proposal(
                     &sort_db,
@@ -232,12 +230,13 @@ impl BlockMinerThread {
                     &sort_db.index_handle_at_tip(),
                     &new_block,
                 ) {
-                    if let Some(_signed_block) = self.wait_for_signed_block(
+                    if let Some(signature) = self.wait_for_signature(
                         &stackerdbs,
                         &aggregate_public_key,
                         &signer_signature_hash,
                     ) {
-                        // TODO: append the signed block instead of the self signed block
+                        // TODO remove self signing once casting aggregate vote is done
+                        new_block.header.signer_signature = signature;
                     } else {
                         debug!("Failed to get a signed block from signers");
                     }
@@ -270,12 +269,12 @@ impl BlockMinerThread {
         }
     }
 
-    fn wait_for_signed_block(
+    fn wait_for_signature(
         &self,
         stackerdbs: &StackerDBs,
         aggregate_public_key: &Point,
         signer_signature_hash: &Sha512Trunc256Sum,
-    ) -> Option<NakamotoBlock> {
+    ) -> Option<ThresholdSignature> {
         let stackerdb_contracts = stackerdbs
             .get_stackerdb_contract_ids()
             .expect("FATAL: could not get the stacker DB contract ids");
@@ -296,51 +295,66 @@ impl BlockMinerThread {
         // If more than a threshold percentage of the signers reject the block, we should not wait any further
         let rejection_threshold =
             slot_ids.len() / 100 * self.config.miner.signer_rejection_threshold;
-        let mut num_rejections = 0;
+        let mut rejections = HashSet::new();
         let now = Instant::now();
         while now.elapsed() < self.config.miner.wait_on_signers {
             // Get the block responses from the signers for the block we just proposed
-            let signer_messages: Vec<SignerMessage> = stackerdbs
+            let signer_chunks = stackerdbs
                 .get_latest_chunks(&signers_contract_id, &slot_ids)
-                .expect("FATAL: could not get latest chunks from stacker DB")
-                .into_iter()
-                .filter_map(|chunk| {
-                    chunk.and_then(|chunk| bincode::deserialize::<SignerMessage>(&chunk).ok())
+                .expect("FATAL: could not get latest chunks from stacker DB");
+            let signer_messages: Vec<(u32, SignerMessage)> = slot_ids
+                .iter()
+                .zip(signer_chunks.into_iter())
+                .filter_map(|(slot_id, chunk)| {
+                    chunk.and_then(|chunk| {
+                        bincode::deserialize::<SignerMessage>(&chunk)
+                            .ok()
+                            .map(|msg| (*slot_id, msg))
+                    })
                 })
                 .collect();
-            for signer_message in signer_messages {
+            for (signer_id, signer_message) in signer_messages {
                 match signer_message {
-                    SignerMessage::BlockResponse(BlockResponse::Accepted(block)) => {
-                        if block.header.signer_signature_hash().ok()? == *signer_signature_hash
-                            && block
-                                .header
-                                .signer_signature
+                    SignerMessage::BlockResponse(BlockResponse::Accepted((hash, signature))) => {
+                        // First check that this signature is for the block we proposed and that it is valid
+                        if hash == *signer_signature_hash
+                            && signature
+                                .0
                                 .verify(aggregate_public_key, &signer_signature_hash.0)
                         {
-                            // We verified that the returned block contains a valid signature across the signer signature hash of our original block request
-                            // Let's just immediately attempt to append the block without waiting for more signer messages
-                            return Some(block);
+                            // The signature is valid across the signer signature hash of the original proposed block
+                            // Immediately return and update the block with this new signature before appending it to the chain
+                            return Some(signature);
                         }
+                        // We received an accepted block for some unknown block hash...Useless! Ignore it.
+                        // Keep waiting for a threshold number of signers to either reject the proposed block
+                        // or return valid signature to show up across the proposed block
                     }
                     SignerMessage::BlockResponse(BlockResponse::Rejected(block_rejection)) => {
                         // First check that this block rejection is for the block we proposed
-                        if block_rejection.block.header.signer_signature_hash().ok()?
-                            == *signer_signature_hash
+                        if block_rejection.signer_signature_hash != *signer_signature_hash {
+                            // This rejection is not for the block we proposed, so we can ignore it
+                            continue;
+                        }
+                        if let RejectCode::SignedRejection(signature) = block_rejection.reason_code
                         {
-                            let signature = block_rejection.block.header.signer_signature;
                             let mut message = signer_signature_hash.0.to_vec();
                             message.push(b'n');
-                            if signature.verify(aggregate_public_key, &message) {
-                                // We received a verified rejection. We will NEVER get a signed block from the signers for this particular block
+                            if signature.0.verify(aggregate_public_key, &message) {
+                                // A threshold number of signers signed a denial of the proposed block
+                                // Miner will NEVER get a signed block from the signers for this particular block
+                                // Immediately return and attempt to mine a new block
+                                return None;
+                            }
+                        } else {
+                            // We received a rejection that is not signed. We will keep waiting for a threshold number of rejections.
+                            // Ensure that we do not double count a rejection from the same signer.
+                            rejections.insert(signer_id);
+                            if rejections.len() > rejection_threshold {
+                                // A threshold number of signers rejected the proposed block.
+                                // Miner will likely never get a signed block from the signers for this particular block
+                                // Return and attempt to mine a new block
                                 return None;
-                            } else if signature
-                                .verify(aggregate_public_key, &signer_signature_hash.0)
-                            {
-                                // We received an unverified rejection. We will keep waiting for a threshold number of rejections
-                                num_rejections += 1;
-                                if num_rejections > rejection_threshold {
-                                    return None;
-                                }
                             }
                         }
                     }
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index fedc6a301a..45aa72047f 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -522,7 +522,7 @@ fn stackerdb_dkg_sign() {
 ///
 /// Test Assertion:
 /// Signers return an operation result containing a valid signature across the miner's Nakamoto block's signature hash.
-/// Signers broadcasted a signed NakamotoBlock back to the .signers contract.
+/// Signers broadcasted a signature across the miner's proposed block back to the .signers contract.
 /// TODO: update test to check miner received the signed block and appended it to the chain
 fn stackerdb_block_proposal() {
     if env::var("BITCOIND_TEST") != Ok("1".into()) {

From c84e4441cc91d57f8542a93fa90c962cb998166e Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 31 Jan 2024 10:21:13 -0800
Subject: [PATCH 0597/1166] Remove bincode by adding serialization functions
 for all wsts Packet types

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 Cargo.lock                                    |   15 +-
 libsigner/Cargo.toml                          |    6 +-
 libsigner/src/events.rs                       |  173 +--
 libsigner/src/libsigner.rs                    |    7 +-
 libsigner/src/messages.rs                     | 1213 +++++++++++++++++
 libsigner/src/tests/http.rs                   |    2 +-
 libsigner/src/tests/mod.rs                    |   13 +-
 stacks-signer/Cargo.toml                      |    1 -
 stacks-signer/src/client/stackerdb.rs         |    3 +-
 stackslib/src/net/api/postblock_proposal.rs   |   16 +
 testnet/stacks-node/Cargo.toml                |    1 -
 .../stacks-node/src/nakamoto_node/miner.rs    |    3 +-
 testnet/stacks-node/src/tests/signer.rs       |    3 +-
 13 files changed, 1268 insertions(+), 188 deletions(-)
 create mode 100644 libsigner/src/messages.rs

diff --git a/Cargo.lock b/Cargo.lock
index 8b8954d7c8..c1fbd59c22 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -441,15 +441,6 @@ version = "0.21.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a4a4ddaa51a5bc52a6948f74c06d20aaaddb71924eab79b8c97a8c556e942d6a"
 
-[[package]]
-name = "bincode"
-version = "1.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"
-dependencies = [
- "serde",
-]
-
 [[package]]
 name = "bindgen"
 version = "0.64.0"
@@ -1971,10 +1962,12 @@ dependencies = [
 name = "libsigner"
 version = "0.0.1"
 dependencies = [
- "bincode",
  "clarity",
+ "hashbrown 0.14.0",
  "libc",
  "libstackerdb",
+ "rand 0.8.5",
+ "rand_core 0.6.4",
  "secp256k1",
  "serde",
  "serde_derive",
@@ -3547,7 +3540,6 @@ dependencies = [
  "async-std",
  "backtrace",
  "base64 0.12.3",
- "bincode",
  "chrono",
  "clarity",
  "hashbrown 0.14.0",
@@ -3583,7 +3575,6 @@ name = "stacks-signer"
 version = "0.0.1"
 dependencies = [
  "backoff",
- "bincode",
  "clap 4.4.1",
  "clarity",
  "hashbrown 0.14.0",
diff --git a/libsigner/Cargo.toml b/libsigner/Cargo.toml
index d115a7475b..1d935d6257 100644
--- a/libsigner/Cargo.toml
+++ b/libsigner/Cargo.toml
@@ -16,8 +16,8 @@ name = "libsigner"
 path = "./src/libsigner.rs"
 
 [dependencies]
-bincode = "1.3.3"
 clarity = { path = "../clarity" }
+hashbrown = "0.14"
 libc = "0.2"
 libstackerdb = { path = "../libstackerdb" }
 serde = "1"
@@ -32,6 +32,10 @@ thiserror = "1.0"
 tiny_http = "0.12"
 wsts = { workspace = true }
 
+[dev-dependencies]
+rand_core = { workspace = true }
+rand = { workspace = true }
+
 [dependencies.serde_json]
 version = "1.0"
 features = ["arbitrary_precision", "unbounded_depth"]
diff --git a/libsigner/src/events.rs b/libsigner/src/events.rs
index 4bacbdd20b..e4d7100b21 100644
--- a/libsigner/src/events.rs
+++ b/libsigner/src/events.rs
@@ -28,179 +28,26 @@ use blockstack_lib::net::api::postblock_proposal::{
     BlockValidateReject, BlockValidateResponse, ValidateRejectCode,
 };
 use blockstack_lib::util_lib::boot::boot_code_id;
+use clarity::vm::types::serialization::SerializationError;
 use clarity::vm::types::QualifiedContractIdentifier;
 use serde::{Deserialize, Serialize};
 use stacks_common::codec::{
-    read_next, read_next_at_most, write_next, Error as CodecError, StacksMessageCodec,
+    read_next, read_next_at_most, read_next_exact, write_next, Error as CodecError,
+    StacksMessageCodec,
 };
 use stacks_common::util::hash::Sha512Trunc256Sum;
 use tiny_http::{
     Method as HttpMethod, Request as HttpRequest, Response as HttpResponse, Server as HttpServer,
 };
 use wsts::common::Signature;
-use wsts::net::{Message, Packet};
+use wsts::net::{
+    DkgBegin, DkgEnd, DkgEndBegin, DkgPrivateBegin, DkgPrivateShares, DkgPublicShares, DkgStatus,
+    Message, NonceRequest, NonceResponse, Packet, SignatureShareRequest, SignatureShareResponse,
+};
+use wsts::state_machine::signer;
 
 use crate::http::{decode_http_body, decode_http_request};
-use crate::EventError;
-
-/// Temporary placeholder for the number of slots allocated to a stacker-db writer. This will be retrieved from the stacker-db instance in the future
-/// See: https://github.com/stacks-network/stacks-blockchain/issues/3921
-/// Is equal to the number of message types
-pub const SIGNER_SLOTS_PER_USER: u32 = 11;
-
-// The slot IDS for each message type
-const DKG_BEGIN_SLOT_ID: u32 = 0;
-const DKG_PRIVATE_BEGIN_SLOT_ID: u32 = 1;
-const DKG_END_BEGIN_SLOT_ID: u32 = 2;
-const DKG_END_SLOT_ID: u32 = 3;
-const DKG_PUBLIC_SHARES_SLOT_ID: u32 = 4;
-const DKG_PRIVATE_SHARES_SLOT_ID: u32 = 5;
-const NONCE_REQUEST_SLOT_ID: u32 = 6;
-const NONCE_RESPONSE_SLOT_ID: u32 = 7;
-const SIGNATURE_SHARE_REQUEST_SLOT_ID: u32 = 8;
-const SIGNATURE_SHARE_RESPONSE_SLOT_ID: u32 = 9;
-/// The slot ID for the block response for miners to observe
-pub const BLOCK_SLOT_ID: u32 = 10;
-
-/// The messages being sent through the stacker db contracts
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub enum SignerMessage {
-    /// The signed/validated Nakamoto block for miners to observe
-    BlockResponse(BlockResponse),
-    /// DKG and Signing round data for other signers to observe
-    Packet(Packet),
-}
-
-/// The response that a signer sends back to observing miners
-/// either accepting or rejecting a Nakamoto block with the corresponding reason
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub enum BlockResponse {
-    /// The Nakamoto block was accepted and therefore signed
-    Accepted((Sha512Trunc256Sum, ThresholdSignature)),
-    /// The Nakamoto block was rejected and therefore not signed
-    Rejected(BlockRejection),
-}
-
-impl BlockResponse {
-    /// Create a new accepted BlockResponse for the provided block signer signature hash and signature
-    pub fn accepted(hash: Sha512Trunc256Sum, sig: Signature) -> Self {
-        Self::Accepted((hash, ThresholdSignature(sig)))
-    }
-
-    /// Create a new rejected BlockResponse for the provided block signer signature hash and signature
-    pub fn rejected(hash: Sha512Trunc256Sum, sig: Signature) -> Self {
-        Self::Rejected(BlockRejection::new(
-            hash,
-            RejectCode::SignedRejection(ThresholdSignature(sig)),
-        ))
-    }
-}
-
-/// A rejection response from a signer for a proposed block
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct BlockRejection {
-    /// The reason for the rejection
-    pub reason: String,
-    /// The reason code for the rejection
-    pub reason_code: RejectCode,
-    /// The signer signature hash of the block that was rejected
-    pub signer_signature_hash: Sha512Trunc256Sum,
-}
-
-impl BlockRejection {
-    /// Create a new BlockRejection for the provided block and reason code
-    pub fn new(signer_signature_hash: Sha512Trunc256Sum, reason_code: RejectCode) -> Self {
-        Self {
-            reason: reason_code.to_string(),
-            reason_code,
-            signer_signature_hash,
-        }
-    }
-}
-
-impl From<BlockValidateReject> for BlockRejection {
-    fn from(reject: BlockValidateReject) -> Self {
-        Self {
-            reason: reject.reason,
-            reason_code: RejectCode::ValidationFailed(reject.reason_code),
-            signer_signature_hash: reject.signer_signature_hash,
-        }
-    }
-}
-
-/// This enum is used to supply a `reason_code` for block rejections
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[repr(u8)]
-pub enum RejectCode {
-    /// RPC endpoint Validation failed
-    ValidationFailed(ValidateRejectCode),
-    /// Signers signed a block rejection
-    SignedRejection(ThresholdSignature),
-    /// Insufficient signers agreed to sign the block
-    InsufficientSigners(Vec<u32>),
-}
-
-impl std::fmt::Display for RejectCode {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        match self {
-            RejectCode::ValidationFailed(code) => write!(f, "Validation failed: {:?}", code),
-            RejectCode::SignedRejection(sig) => {
-                write!(f, "A threshold number of signers rejected the block with the following signature: {:?}.", sig)
-            }
-            RejectCode::InsufficientSigners(malicious_signers) => write!(
-                f,
-                "Insufficient signers agreed to sign the block. The following signers are malicious: {:?}",
-                malicious_signers
-            ),
-        }
-    }
-}
-
-impl From<Packet> for SignerMessage {
-    fn from(packet: Packet) -> Self {
-        Self::Packet(packet)
-    }
-}
-
-impl From<BlockResponse> for SignerMessage {
-    fn from(block_response: BlockResponse) -> Self {
-        Self::BlockResponse(block_response)
-    }
-}
-
-impl From<BlockRejection> for SignerMessage {
-    fn from(block_rejection: BlockRejection) -> Self {
-        Self::BlockResponse(BlockResponse::Rejected(block_rejection))
-    }
-}
-
-impl From<BlockValidateReject> for SignerMessage {
-    fn from(rejection: BlockValidateReject) -> Self {
-        Self::BlockResponse(BlockResponse::Rejected(rejection.into()))
-    }
-}
-
-impl SignerMessage {
-    /// Helper function to determine the slot ID for the provided stacker-db writer id
-    pub fn slot_id(&self, id: u32) -> u32 {
-        let slot_id = match self {
-            Self::Packet(packet) => match packet.msg {
-                Message::DkgBegin(_) => DKG_BEGIN_SLOT_ID,
-                Message::DkgPrivateBegin(_) => DKG_PRIVATE_BEGIN_SLOT_ID,
-                Message::DkgEndBegin(_) => DKG_END_BEGIN_SLOT_ID,
-                Message::DkgEnd(_) => DKG_END_SLOT_ID,
-                Message::DkgPublicShares(_) => DKG_PUBLIC_SHARES_SLOT_ID,
-                Message::DkgPrivateShares(_) => DKG_PRIVATE_SHARES_SLOT_ID,
-                Message::NonceRequest(_) => NONCE_REQUEST_SLOT_ID,
-                Message::NonceResponse(_) => NONCE_RESPONSE_SLOT_ID,
-                Message::SignatureShareRequest(_) => SIGNATURE_SHARE_REQUEST_SLOT_ID,
-                Message::SignatureShareResponse(_) => SIGNATURE_SHARE_RESPONSE_SLOT_ID,
-            },
-            Self::BlockResponse(_) => BLOCK_SLOT_ID,
-        };
-        SIGNER_SLOTS_PER_USER * id + slot_id
-    }
-}
+use crate::{EventError, SignerMessage};
 
 /// Event enum for newly-arrived signer subscribed events
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
@@ -503,7 +350,7 @@ fn process_stackerdb_event(
         let signer_messages: Vec<SignerMessage> = event
             .modified_slots
             .iter()
-            .filter_map(|chunk| bincode::deserialize::<SignerMessage>(&chunk.data).ok())
+            .filter_map(|chunk| read_next::<SignerMessage, _>(&mut &chunk.data[..]).ok())
             .collect();
         SignerEvent::SignerMessages(signer_messages)
     } else {
diff --git a/libsigner/src/libsigner.rs b/libsigner/src/libsigner.rs
index 8b10b3fafb..16f7ec626b 100644
--- a/libsigner/src/libsigner.rs
+++ b/libsigner/src/libsigner.rs
@@ -39,13 +39,16 @@ mod tests;
 mod error;
 mod events;
 mod http;
+mod messages;
 mod runloop;
 mod session;
 
 pub use crate::error::{EventError, RPCError};
 pub use crate::events::{
-    BlockRejection, BlockResponse, EventReceiver, EventStopSignaler, RejectCode, SignerEvent,
-    SignerEventReceiver, SignerMessage, SignerStopSignaler, BLOCK_SLOT_ID, SIGNER_SLOTS_PER_USER,
+    EventReceiver, EventStopSignaler, SignerEvent, SignerEventReceiver, SignerStopSignaler,
+};
+pub use crate::messages::{
+    BlockRejection, BlockResponse, RejectCode, SignerMessage, BLOCK_SLOT_ID, SIGNER_SLOTS_PER_USER,
 };
 pub use crate::runloop::{RunningSigner, Signer, SignerRunLoop};
 pub use crate::session::{SignerSession, StackerDBSession};
diff --git a/libsigner/src/messages.rs b/libsigner/src/messages.rs
new file mode 100644
index 0000000000..f9a243e859
--- /dev/null
+++ b/libsigner/src/messages.rs
@@ -0,0 +1,1213 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020-2024 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+use std::io::{Read, Write};
+use std::net::{SocketAddr, TcpListener, TcpStream};
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::mpsc::Sender;
+use std::sync::Arc;
+
+use blockstack_lib::chainstate::nakamoto::NakamotoBlock;
+use blockstack_lib::chainstate::stacks::boot::{MINERS_NAME, SIGNERS_NAME};
+use blockstack_lib::chainstate::stacks::events::StackerDBChunksEvent;
+use blockstack_lib::chainstate::stacks::{StacksTransaction, ThresholdSignature};
+use blockstack_lib::net::api::postblock_proposal::{
+    BlockValidateReject, BlockValidateResponse, ValidateRejectCode,
+};
+use blockstack_lib::util_lib::boot::boot_code_id;
+use clarity::vm::types::serialization::SerializationError;
+use clarity::vm::types::QualifiedContractIdentifier;
+use hashbrown::HashMap;
+use serde::{Deserialize, Serialize};
+use stacks_common::codec::{
+    read_next, read_next_at_most, read_next_exact, write_next, Error as CodecError,
+    StacksMessageCodec,
+};
+use stacks_common::util::hash::Sha512Trunc256Sum;
+use tiny_http::{
+    Method as HttpMethod, Request as HttpRequest, Response as HttpResponse, Server as HttpServer,
+};
+use wsts::common::{PolyCommitment, PublicNonce, Signature, SignatureShare};
+use wsts::curve::point::{Compressed, Point};
+use wsts::curve::scalar::Scalar;
+use wsts::net::{
+    DkgBegin, DkgEnd, DkgEndBegin, DkgPrivateBegin, DkgPrivateShares, DkgPublicShares, DkgStatus,
+    Message, NonceRequest, NonceResponse, Packet, SignatureShareRequest, SignatureShareResponse,
+};
+use wsts::schnorr::ID;
+use wsts::state_machine::signer;
+
+use crate::http::{decode_http_body, decode_http_request};
+use crate::EventError;
+
+/// Temporary placeholder for the number of slots allocated to a stacker-db writer. This will be retrieved from the stacker-db instance in the future
+/// See: https://github.com/stacks-network/stacks-blockchain/issues/3921
+/// Is equal to the number of message types
+pub const SIGNER_SLOTS_PER_USER: u32 = 11;
+
+// The slot IDS for each message type
+const DKG_BEGIN_SLOT_ID: u32 = 0;
+const DKG_PRIVATE_BEGIN_SLOT_ID: u32 = 1;
+const DKG_END_BEGIN_SLOT_ID: u32 = 2;
+const DKG_END_SLOT_ID: u32 = 3;
+const DKG_PUBLIC_SHARES_SLOT_ID: u32 = 4;
+const DKG_PRIVATE_SHARES_SLOT_ID: u32 = 5;
+const NONCE_REQUEST_SLOT_ID: u32 = 6;
+const NONCE_RESPONSE_SLOT_ID: u32 = 7;
+const SIGNATURE_SHARE_REQUEST_SLOT_ID: u32 = 8;
+const SIGNATURE_SHARE_RESPONSE_SLOT_ID: u32 = 9;
+/// The slot ID for the block response for miners to observe
+pub const BLOCK_SLOT_ID: u32 = 10;
+
+define_u8_enum!(TypePrefix {
+    BlockResponse = 0,
+    Packet = 1,
+    DkgBegin = 2,
+    DkgPrivateBegin = 3,
+    DkgEndBegin = 4,
+    DkgEnd = 5,
+    DkgPublicShares = 6,
+    DkgPrivateShares = 7,
+    NonceRequest = 8,
+    NonceResponse = 9,
+    SignatureShareRequest = 10,
+    SignatureShareResponse = 11,
+    DkgStatusSuccess = 12,
+    DkgStatusFailure = 13
+});
+
+impl TryFrom<u8> for TypePrefix {
+    type Error = CodecError;
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        match value {
+            0 => Ok(TypePrefix::BlockResponse),
+            1 => Ok(TypePrefix::Packet),
+            2 => Ok(TypePrefix::DkgBegin),
+            3 => Ok(TypePrefix::DkgPrivateBegin),
+            4 => Ok(TypePrefix::DkgEndBegin),
+            5 => Ok(TypePrefix::DkgEnd),
+            6 => Ok(TypePrefix::DkgPublicShares),
+            7 => Ok(TypePrefix::DkgPrivateShares),
+            8 => Ok(TypePrefix::NonceRequest),
+            9 => Ok(TypePrefix::NonceResponse),
+            10 => Ok(TypePrefix::SignatureShareRequest),
+            11 => Ok(TypePrefix::SignatureShareResponse),
+            12 => Ok(TypePrefix::DkgStatusSuccess),
+            13 => Ok(TypePrefix::DkgStatusFailure),
+            _ => Err(CodecError::DeserializeError(format!(
+                "Unknown type prefix: {}",
+                value
+            ))),
+        }
+    }
+}
+
+impl From<&SignerMessage> for TypePrefix {
+    fn from(message: &SignerMessage) -> Self {
+        match message {
+            SignerMessage::Packet(_) => TypePrefix::Packet,
+            SignerMessage::BlockResponse(_) => TypePrefix::BlockResponse,
+        }
+    }
+}
+
+impl From<&Packet> for TypePrefix {
+    fn from(packet: &Packet) -> Self {
+        match packet.msg {
+            Message::DkgBegin(_) => TypePrefix::DkgBegin,
+            Message::DkgPrivateBegin(_) => TypePrefix::DkgPrivateBegin,
+            Message::DkgEndBegin(_) => TypePrefix::DkgEndBegin,
+            Message::DkgEnd(_) => TypePrefix::DkgEnd,
+            Message::DkgPublicShares(_) => TypePrefix::DkgPublicShares,
+            Message::DkgPrivateShares(_) => TypePrefix::DkgPrivateShares,
+            Message::NonceRequest(_) => TypePrefix::NonceRequest,
+            Message::NonceResponse(_) => TypePrefix::NonceResponse,
+            Message::SignatureShareRequest(_) => TypePrefix::SignatureShareRequest,
+            Message::SignatureShareResponse(_) => TypePrefix::SignatureShareResponse,
+        }
+    }
+}
+
+/// The messages being sent through the stacker db contracts
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum SignerMessage {
+    /// The signed/validated Nakamoto block for miners to observe
+    BlockResponse(BlockResponse),
+    /// DKG and Signing round data for other signers to observe
+    Packet(Packet),
+}
+
+impl StacksMessageCodec for SignerMessage {
+    fn consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), CodecError> {
+        write_next(fd, &(TypePrefix::from(self) as u8))?;
+        match self {
+            SignerMessage::Packet(packet) => {
+                consensus_serialize_packet(fd, packet)?;
+            }
+            SignerMessage::BlockResponse(block_response) => {
+                write_next(fd, block_response)?;
+            }
+        };
+        Ok(())
+    }
+
+    fn consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, CodecError> {
+        let type_prefix_byte = read_next::<u8, _>(fd)?;
+        let type_prefix = TypePrefix::try_from(type_prefix_byte)?;
+        let message = match type_prefix {
+            TypePrefix::Packet => {
+                let packet = consensus_deserialize_packet(fd)?;
+                SignerMessage::Packet(packet)
+            }
+            TypePrefix::BlockResponse => {
+                let block_response = read_next::<BlockResponse, _>(fd)?;
+                SignerMessage::BlockResponse(block_response)
+            }
+            _ => {
+                return Err(CodecError::DeserializeError(format!(
+                    "Unknown signer message type prefix: {}",
+                    type_prefix_byte
+                )))
+            }
+        };
+        Ok(message)
+    }
+}
+
+fn consensus_serialize_scalar<W: Write>(fd: &mut W, scalar: &Scalar) -> Result<(), CodecError> {
+    write_next(fd, &scalar.to_bytes())
+}
+
+fn consensus_deserialize_scalar<R: Read>(fd: &mut R) -> Result<Scalar, CodecError> {
+    let scalar_bytes = read_next::<[u8; 32], _>(fd)?;
+    Ok(Scalar::from(scalar_bytes))
+}
+
+fn consensus_serialize_point<W: Write>(fd: &mut W, point: &Point) -> Result<(), CodecError> {
+    write_next(fd, &point.compress().as_bytes().to_vec())
+}
+
+fn consensus_deserialize_point<R: Read>(fd: &mut R) -> Result<Point, CodecError> {
+    let compressed_bytes: Vec<u8> = read_next(fd)?;
+    let compressed = Compressed::try_from(compressed_bytes.as_slice())
+        .map_err(|e| CodecError::DeserializeError(e.to_string()))?;
+    Point::try_from(&compressed).map_err(|e| CodecError::DeserializeError(e.to_string()))
+}
+
+fn consensus_serialize_dkg_begin<W: Write>(
+    fd: &mut W,
+    dkg_begin: &DkgBegin,
+) -> Result<(), CodecError> {
+    write_next(fd, &dkg_begin.dkg_id)
+}
+
+fn consensus_deserialize_dkg_begin<R: Read>(fd: &mut R) -> Result<DkgBegin, CodecError> {
+    let dkg_id = read_next::<u64, _>(fd)?;
+    Ok(DkgBegin { dkg_id })
+}
+
+fn consensus_serialize_dkg_private_begin<W: Write>(
+    fd: &mut W,
+    dkg_private_begin: &DkgPrivateBegin,
+) -> Result<(), CodecError> {
+    write_next(fd, &dkg_private_begin.dkg_id)?;
+    write_next(fd, &dkg_private_begin.signer_ids)?;
+    write_next(fd, &dkg_private_begin.key_ids)
+}
+
+fn consensus_deserialize_dkg_private_begin<R: Read>(
+    fd: &mut R,
+) -> Result<DkgPrivateBegin, CodecError> {
+    let dkg_id = read_next::<u64, _>(fd)?;
+    let signer_ids = read_next::<Vec<u32>, _>(fd)?;
+    let key_ids = read_next::<Vec<u32>, _>(fd)?;
+    Ok(DkgPrivateBegin {
+        dkg_id,
+        signer_ids,
+        key_ids,
+    })
+}
+
+fn consensus_serialize_dkg_end_begin<W: Write>(
+    fd: &mut W,
+    dkg_end_begin: &DkgEndBegin,
+) -> Result<(), CodecError> {
+    write_next(fd, &dkg_end_begin.dkg_id)?;
+    write_next(fd, &dkg_end_begin.signer_ids)?;
+    write_next(fd, &dkg_end_begin.key_ids)
+}
+
+fn consensus_deserialize_dkg_end_begin<R: Read>(fd: &mut R) -> Result<DkgEndBegin, CodecError> {
+    let dkg_id = read_next::<u64, _>(fd)?;
+    let signer_ids = read_next::<Vec<u32>, _>(fd)?;
+    let key_ids = read_next::<Vec<u32>, _>(fd)?;
+    Ok(DkgEndBegin {
+        dkg_id,
+        signer_ids,
+        key_ids,
+    })
+}
+
+fn consensus_serialize_dkg_end<W: Write>(fd: &mut W, dkg_end: &DkgEnd) -> Result<(), CodecError> {
+    write_next(fd, &dkg_end.dkg_id)?;
+    write_next(fd, &dkg_end.signer_id)?;
+    match &dkg_end.status {
+        DkgStatus::Success => write_next(fd, &0u8),
+        DkgStatus::Failure(failure) => {
+            write_next(fd, &1u8)?;
+            write_next(fd, &failure.as_bytes().to_vec())
+        }
+    }
+}
+
+fn consensus_deserialize_dkg_end<R: Read>(fd: &mut R) -> Result<DkgEnd, CodecError> {
+    let dkg_id = read_next::<u64, _>(fd)?;
+    let signer_id = read_next::<u32, _>(fd)?;
+    let status_type_prefix = read_next::<u8, _>(fd)?;
+    let status = match status_type_prefix {
+        0 => DkgStatus::Success,
+        1 => {
+            let failure_bytes: Vec<u8> = read_next(fd)?;
+            let failure = String::from_utf8(failure_bytes)
+                .map_err(|e| CodecError::DeserializeError(e.to_string()))?;
+            DkgStatus::Failure(failure)
+        }
+        _ => {
+            return Err(CodecError::DeserializeError(format!(
+                "Unknown DKG status type prefix: {}",
+                status_type_prefix
+            )))
+        }
+    };
+    Ok(DkgEnd {
+        dkg_id,
+        signer_id,
+        status,
+    })
+}
+
+fn consensus_serialize_dkg_public_shares<W: Write>(
+    fd: &mut W,
+    dkg_public_shares: &DkgPublicShares,
+) -> Result<(), CodecError> {
+    write_next(fd, &dkg_public_shares.dkg_id)?;
+    write_next(fd, &dkg_public_shares.signer_id)?;
+    write_next(fd, &(dkg_public_shares.comms.len() as u32))?;
+    for (id, comm) in &dkg_public_shares.comms {
+        write_next(fd, id)?;
+        consensus_serialize_scalar(fd, &comm.id.id)?;
+        consensus_serialize_point(fd, &comm.id.kG)?;
+        consensus_serialize_scalar(fd, &comm.id.kca)?;
+        write_next(fd, &(comm.poly.len() as u32))?;
+        for poly in comm.poly.iter() {
+            consensus_serialize_point(fd, poly)?
+        }
+    }
+    Ok(())
+}
+
+#[allow(non_snake_case)]
+fn consensus_deserialize_dkg_public_shares<R: Read>(
+    fd: &mut R,
+) -> Result<DkgPublicShares, CodecError> {
+    let dkg_id = read_next::<u64, _>(fd)?;
+    let signer_id = read_next::<u32, _>(fd)?;
+    let num_shares = read_next::<u32, _>(fd)?;
+    let mut comms = Vec::new();
+    for _ in 0..num_shares {
+        let id = read_next::<u32, _>(fd)?;
+        let scalar_id = consensus_deserialize_scalar(fd)?;
+        let kG = consensus_deserialize_point(fd)?;
+        let kca = consensus_deserialize_scalar(fd)?;
+        let num_poly_coeffs = read_next::<u32, _>(fd)?;
+        let mut poly = Vec::new();
+        for _ in 0..num_poly_coeffs {
+            poly.push(consensus_deserialize_point(fd)?);
+        }
+        comms.push((
+            id,
+            PolyCommitment {
+                id: ID {
+                    id: scalar_id,
+                    kG,
+                    kca,
+                },
+                poly,
+            },
+        ));
+    }
+    Ok(DkgPublicShares {
+        dkg_id,
+        signer_id,
+        comms,
+    })
+}
+
+fn consensus_serialize_dkg_private_shares<W: Write>(
+    fd: &mut W,
+    dkg_private_shares: &DkgPrivateShares,
+) -> Result<(), CodecError> {
+    write_next(fd, &dkg_private_shares.dkg_id)?;
+    write_next(fd, &dkg_private_shares.signer_id)?;
+    write_next(fd, &(dkg_private_shares.shares.len() as u32))?;
+    for (id, share_map) in &dkg_private_shares.shares {
+        write_next(fd, id)?;
+        write_next(fd, &(share_map.len() as u32))?;
+        for (id, share) in share_map {
+            write_next(fd, id)?;
+            write_next(fd, share)?;
+        }
+    }
+    Ok(())
+}
+
+fn consensus_deserialize_dkg_private_shares<R: Read>(
+    fd: &mut R,
+) -> Result<DkgPrivateShares, CodecError> {
+    let dkg_id = read_next::<u64, _>(fd)?;
+    let signer_id = read_next::<u32, _>(fd)?;
+    let num_shares = read_next::<u32, _>(fd)?;
+    let mut shares = Vec::new();
+    for _ in 0..num_shares {
+        let id = read_next::<u32, _>(fd)?;
+        let num_share_map = read_next::<u32, _>(fd)?;
+        let mut share_map = HashMap::new();
+        for _ in 0..num_share_map {
+            let id = read_next::<u32, _>(fd)?;
+            let share: Vec<u8> = read_next(fd)?;
+            share_map.insert(id, share);
+        }
+        shares.push((id, share_map));
+    }
+    Ok(DkgPrivateShares {
+        dkg_id,
+        signer_id,
+        shares,
+    })
+}
+
+fn consensus_serialize_nonce_request<W: Write>(
+    fd: &mut W,
+    nonce_request: &NonceRequest,
+) -> Result<(), CodecError> {
+    write_next(fd, &nonce_request.dkg_id)?;
+    write_next(fd, &nonce_request.sign_id)?;
+    write_next(fd, &nonce_request.sign_iter_id)?;
+    write_next(fd, &nonce_request.message)?;
+    write_next(fd, &(nonce_request.is_taproot as u8))?;
+    write_next(fd, &(nonce_request.merkle_root.is_some() as u8))?;
+    if let Some(merkle_root) = nonce_request.merkle_root {
+        write_next(fd, &merkle_root)?;
+    }
+    Ok(())
+}
+
+fn consensus_deserialize_nonce_request<R: Read>(fd: &mut R) -> Result<NonceRequest, CodecError> {
+    let dkg_id = read_next::<u64, _>(fd)?;
+    let sign_id = read_next::<u64, _>(fd)?;
+    let sign_iter_id = read_next::<u64, _>(fd)?;
+    let message = read_next::<Vec<u8>, _>(fd)?;
+    let is_taproot = read_next::<u8, _>(fd)? != 0;
+    let has_merkle_root = read_next::<u8, _>(fd)? != 0;
+    let merkle_root = if has_merkle_root {
+        Some(read_next::<[u8; 32], _>(fd)?)
+    } else {
+        None
+    };
+
+    Ok(NonceRequest {
+        dkg_id,
+        sign_id,
+        sign_iter_id,
+        message,
+        is_taproot,
+        merkle_root,
+    })
+}
+
+fn consensus_serialize_nonce_response<W: Write>(
+    fd: &mut W,
+    nonce_response: &NonceResponse,
+) -> Result<(), CodecError> {
+    write_next(fd, &nonce_response.dkg_id)?;
+    write_next(fd, &nonce_response.sign_id)?;
+    write_next(fd, &nonce_response.sign_iter_id)?;
+    write_next(fd, &nonce_response.signer_id)?;
+    write_next(fd, &nonce_response.key_ids)?;
+    write_next(fd, &(nonce_response.nonces.len() as u32))?;
+    for nonce in &nonce_response.nonces {
+        consensus_serialize_point(fd, &nonce.D)?;
+        consensus_serialize_point(fd, &nonce.E)?;
+    }
+
+    write_next(fd, &nonce_response.message)?;
+    Ok(())
+}
+
+#[allow(non_snake_case)]
+fn consensus_deserialize_nonce_response<R: Read>(fd: &mut R) -> Result<NonceResponse, CodecError> {
+    let dkg_id = read_next::<u64, _>(fd)?;
+    let sign_id = read_next::<u64, _>(fd)?;
+    let sign_iter_id = read_next::<u64, _>(fd)?;
+    let signer_id = read_next::<u32, _>(fd)?;
+    let key_ids = read_next::<Vec<u32>, _>(fd)?;
+    let num_nonces = read_next::<u32, _>(fd)?;
+    let mut nonces = Vec::new();
+    for _ in 0..num_nonces {
+        let D = consensus_deserialize_point(fd)?;
+        let E = consensus_deserialize_point(fd)?;
+        nonces.push(PublicNonce { D, E });
+    }
+    let message = read_next::<Vec<u8>, _>(fd)?;
+
+    Ok(NonceResponse {
+        dkg_id,
+        sign_id,
+        sign_iter_id,
+        signer_id,
+        key_ids,
+        nonces,
+        message,
+    })
+}
+
+fn consensus_serialize_signature_share_request<W: Write>(
+    fd: &mut W,
+    signature_share_request: &SignatureShareRequest,
+) -> Result<(), CodecError> {
+    write_next(fd, &signature_share_request.dkg_id)?;
+    write_next(fd, &signature_share_request.sign_id)?;
+    write_next(fd, &signature_share_request.sign_iter_id)?;
+    write_next(fd, &(signature_share_request.nonce_responses.len() as u32))?;
+    for nonce_response in &signature_share_request.nonce_responses {
+        consensus_serialize_nonce_response(fd, nonce_response)?;
+    }
+    write_next(fd, &signature_share_request.message)?;
+    write_next(fd, &(signature_share_request.is_taproot as u8))?;
+    write_next(fd, &(signature_share_request.merkle_root.is_some() as u8))?;
+    if let Some(merkle_root) = signature_share_request.merkle_root {
+        write_next(fd, &merkle_root)?;
+    }
+    Ok(())
+}
+
+fn consensus_deserialize_signature_share_request<R: Read>(
+    fd: &mut R,
+) -> Result<SignatureShareRequest, CodecError> {
+    let dkg_id = read_next::<u64, _>(fd)?;
+    let sign_id = read_next::<u64, _>(fd)?;
+    let sign_iter_id = read_next::<u64, _>(fd)?;
+    let num_nonce_responses = read_next::<u32, _>(fd)?;
+    let mut nonce_responses = Vec::new();
+    for _ in 0..num_nonce_responses {
+        nonce_responses.push(consensus_deserialize_nonce_response(fd)?);
+    }
+    let message = read_next::<Vec<u8>, _>(fd)?;
+    let is_taproot = read_next::<u8, _>(fd)? != 0;
+    let has_merkle_root = read_next::<u8, _>(fd)? != 0;
+    let merkle_root = if has_merkle_root {
+        Some(read_next::<[u8; 32], _>(fd)?)
+    } else {
+        None
+    };
+
+    Ok(SignatureShareRequest {
+        dkg_id,
+        sign_id,
+        sign_iter_id,
+        nonce_responses,
+        message,
+        is_taproot,
+        merkle_root,
+    })
+}
+
+fn consensus_serialize_signature_share_response<W: Write>(
+    fd: &mut W,
+    signature_share_response: &SignatureShareResponse,
+) -> Result<(), CodecError> {
+    write_next(fd, &signature_share_response.dkg_id)?;
+    write_next(fd, &signature_share_response.sign_id)?;
+    write_next(fd, &signature_share_response.sign_iter_id)?;
+    write_next(fd, &signature_share_response.signer_id)?;
+    write_next(
+        fd,
+        &(signature_share_response.signature_shares.len() as u32),
+    )?;
+    for share in &signature_share_response.signature_shares {
+        write_next(fd, &share.id)?;
+        consensus_serialize_scalar(fd, &share.z_i)?;
+        write_next(fd, &share.key_ids)?;
+    }
+    Ok(())
+}
+
+fn consensus_deserialize_signature_share_response<R: Read>(
+    fd: &mut R,
+) -> Result<SignatureShareResponse, CodecError> {
+    let dkg_id = read_next::<u64, _>(fd)?;
+    let sign_id = read_next::<u64, _>(fd)?;
+    let sign_iter_id = read_next::<u64, _>(fd)?;
+    let signer_id = read_next::<u32, _>(fd)?;
+    let num_shares = read_next::<u32, _>(fd)?;
+    let mut signature_shares = Vec::new();
+    for _ in 0..num_shares {
+        let id = read_next::<u32, _>(fd)?;
+        let z_i = consensus_deserialize_scalar(fd)?;
+        let key_ids = read_next::<Vec<u32>, _>(fd)?;
+        signature_shares.push(SignatureShare { id, z_i, key_ids });
+    }
+    Ok(SignatureShareResponse {
+        dkg_id,
+        sign_id,
+        sign_iter_id,
+        signer_id,
+        signature_shares,
+    })
+}
+
+pub fn consensus_serialize_message<W: Write>(
+    fd: &mut W,
+    message: &Message,
+) -> Result<(), CodecError> {
+    match message {
+        Message::DkgBegin(dkg_begin) => {
+            consensus_serialize_dkg_begin(fd, dkg_begin)?;
+        }
+        Message::DkgPrivateBegin(dkg_private_begin) => {
+            consensus_serialize_dkg_private_begin(fd, dkg_private_begin)?;
+        }
+        Message::DkgEndBegin(dkg_end_begin) => {
+            consensus_serialize_dkg_end_begin(fd, dkg_end_begin)?;
+        }
+        Message::DkgEnd(dkg_end) => {
+            consensus_serialize_dkg_end(fd, dkg_end)?;
+        }
+        Message::DkgPublicShares(dkg_public_shares) => {
+            consensus_serialize_dkg_public_shares(fd, dkg_public_shares)?;
+        }
+        Message::DkgPrivateShares(dkg_private_shares) => {
+            consensus_serialize_dkg_private_shares(fd, dkg_private_shares)?;
+        }
+        Message::NonceRequest(nonce_request) => {
+            consensus_serialize_nonce_request(fd, nonce_request)?;
+        }
+        Message::NonceResponse(nonce_response) => {
+            consensus_serialize_nonce_response(fd, nonce_response)?;
+        }
+        Message::SignatureShareRequest(signature_share_request) => {
+            consensus_serialize_signature_share_request(fd, signature_share_request)?;
+        }
+        Message::SignatureShareResponse(signature_share_response) => {
+            consensus_serialize_signature_share_response(fd, signature_share_response)?;
+        }
+    }
+    Ok(())
+}
+
+fn consensus_serialize_packet<W: Write>(fd: &mut W, packet: &Packet) -> Result<(), CodecError> {
+    write_next(fd, &(TypePrefix::from(packet) as u8))?;
+    consensus_serialize_message(fd, &packet.msg)?;
+    write_next(fd, &packet.sig)?;
+    Ok(())
+}
+
+fn consensus_deserialize_packet<R: Read>(fd: &mut R) -> Result<Packet, CodecError> {
+    let type_prefix_byte = read_next::<u8, _>(fd)?;
+    let type_prefix = TypePrefix::try_from(type_prefix_byte)?;
+    let msg = match type_prefix {
+        TypePrefix::DkgBegin => Message::DkgBegin(consensus_deserialize_dkg_begin(fd)?),
+        TypePrefix::DkgPrivateBegin => {
+            Message::DkgPrivateBegin(consensus_deserialize_dkg_private_begin(fd)?)
+        }
+        TypePrefix::DkgEndBegin => Message::DkgEndBegin(consensus_deserialize_dkg_end_begin(fd)?),
+        TypePrefix::DkgEnd => Message::DkgEnd(consensus_deserialize_dkg_end(fd)?),
+        TypePrefix::DkgPublicShares => {
+            Message::DkgPublicShares(consensus_deserialize_dkg_public_shares(fd)?)
+        }
+        TypePrefix::DkgPrivateShares => {
+            Message::DkgPrivateShares(consensus_deserialize_dkg_private_shares(fd)?)
+        }
+        TypePrefix::NonceRequest => Message::NonceRequest(consensus_deserialize_nonce_request(fd)?),
+        TypePrefix::NonceResponse => {
+            Message::NonceResponse(consensus_deserialize_nonce_response(fd)?)
+        }
+        TypePrefix::SignatureShareRequest => {
+            Message::SignatureShareRequest(consensus_deserialize_signature_share_request(fd)?)
+        }
+        TypePrefix::SignatureShareResponse => {
+            Message::SignatureShareResponse(consensus_deserialize_signature_share_response(fd)?)
+        }
+        _ => {
+            return Err(CodecError::DeserializeError(format!(
+                "Unknown packet type prefix: {}",
+                type_prefix_byte
+            )))
+        }
+    };
+    let sig: Vec<u8> = read_next(fd)?;
+    Ok(Packet { msg, sig })
+}
+
+/// The response that a signer sends back to observing miners
+/// either accepting or rejecting a Nakamoto block with the corresponding reason
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum BlockResponse {
+    /// The Nakamoto block was accepted and therefore signed
+    Accepted((Sha512Trunc256Sum, ThresholdSignature)),
+    /// The Nakamoto block was rejected and therefore not signed
+    Rejected(BlockRejection),
+}
+
+impl BlockResponse {
+    /// Create a new accepted BlockResponse for the provided block signer signature hash and signature
+    pub fn accepted(hash: Sha512Trunc256Sum, sig: Signature) -> Self {
+        Self::Accepted((hash, ThresholdSignature(sig)))
+    }
+
+    /// Create a new rejected BlockResponse for the provided block signer signature hash and signature
+    pub fn rejected(hash: Sha512Trunc256Sum, sig: Signature) -> Self {
+        Self::Rejected(BlockRejection::new(
+            hash,
+            RejectCode::SignedRejection(ThresholdSignature(sig)),
+        ))
+    }
+}
+
+impl StacksMessageCodec for BlockResponse {
+    fn consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), CodecError> {
+        match self {
+            BlockResponse::Accepted((hash, sig)) => {
+                write_next(fd, &0u8)?;
+                write_next(fd, hash)?;
+                write_next(fd, sig)?;
+            }
+            BlockResponse::Rejected(rejection) => {
+                write_next(fd, &1u8)?;
+                write_next(fd, rejection)?;
+            }
+        };
+        Ok(())
+    }
+
+    fn consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, CodecError> {
+        let type_prefix = read_next::<u8, _>(fd)?;
+        let response = match type_prefix {
+            0 => {
+                let hash = read_next::<Sha512Trunc256Sum, _>(fd)?;
+                let sig = read_next::<ThresholdSignature, _>(fd)?;
+                BlockResponse::Accepted((hash, sig))
+            }
+            1 => {
+                let rejection = read_next::<BlockRejection, _>(fd)?;
+                BlockResponse::Rejected(rejection)
+            }
+            _ => {
+                return Err(CodecError::DeserializeError(format!(
+                    "Unknown block response type prefix: {}",
+                    type_prefix
+                )))
+            }
+        };
+        Ok(response)
+    }
+}
+/// A rejection response from a signer for a proposed block
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BlockRejection {
+    /// The reason for the rejection
+    pub reason: String,
+    /// The reason code for the rejection
+    pub reason_code: RejectCode,
+    /// The signer signature hash of the block that was rejected
+    pub signer_signature_hash: Sha512Trunc256Sum,
+}
+
+impl BlockRejection {
+    /// Create a new BlockRejection for the provided block and reason code
+    pub fn new(signer_signature_hash: Sha512Trunc256Sum, reason_code: RejectCode) -> Self {
+        Self {
+            reason: reason_code.to_string(),
+            reason_code,
+            signer_signature_hash,
+        }
+    }
+}
+
+impl StacksMessageCodec for BlockRejection {
+    fn consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), CodecError> {
+        write_next(fd, &self.reason.as_bytes().to_vec())?;
+        write_next(fd, &self.reason_code)?;
+        write_next(fd, &self.signer_signature_hash)?;
+        Ok(())
+    }
+
+    fn consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, CodecError> {
+        let reason_bytes = read_next::<Vec<u8>, _>(fd)?;
+        let reason = String::from_utf8(reason_bytes).map_err(|e| {
+            CodecError::DeserializeError(format!("Failed to decode reason string: {:?}", &e))
+        })?;
+        let reason_code = read_next::<RejectCode, _>(fd)?;
+        let signer_signature_hash = read_next::<Sha512Trunc256Sum, _>(fd)?;
+        Ok(Self {
+            reason,
+            reason_code,
+            signer_signature_hash,
+        })
+    }
+}
+
+impl From<BlockValidateReject> for BlockRejection {
+    fn from(reject: BlockValidateReject) -> Self {
+        Self {
+            reason: reject.reason,
+            reason_code: RejectCode::ValidationFailed(reject.reason_code),
+            signer_signature_hash: reject.signer_signature_hash,
+        }
+    }
+}
+
+/// This enum is used to supply a `reason_code` for block rejections
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub enum RejectCode {
+    /// RPC endpoint Validation failed
+    ValidationFailed(ValidateRejectCode),
+    /// Signers signed a block rejection
+    SignedRejection(ThresholdSignature),
+    /// Insufficient signers agreed to sign the block
+    InsufficientSigners(Vec<u32>),
+}
+
+impl StacksMessageCodec for RejectCode {
+    fn consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), CodecError> {
+        match self {
+            RejectCode::ValidationFailed(code) => {
+                write_next(fd, &0u8)?;
+                write_next(fd, &(code.clone() as u8))?
+            }
+            RejectCode::SignedRejection(sig) => {
+                write_next(fd, &1u8)?;
+                write_next(fd, sig)?
+            }
+            RejectCode::InsufficientSigners(malicious_signers) => {
+                write_next(fd, &2u8)?;
+                write_next(fd, malicious_signers)?
+            }
+        };
+        Ok(())
+    }
+
+    fn consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, CodecError> {
+        let type_prefix = read_next::<u8, _>(fd)?;
+        let code = match type_prefix {
+            0 => RejectCode::ValidationFailed(
+                ValidateRejectCode::try_from(read_next::<u8, _>(fd)?).map_err(|e| {
+                    CodecError::DeserializeError(format!(
+                        "Failed to decode validation reject code: {:?}",
+                        &e
+                    ))
+                })?,
+            ),
+            1 => RejectCode::SignedRejection(read_next::<ThresholdSignature, _>(fd)?),
+            2 => RejectCode::InsufficientSigners(read_next::<Vec<u32>, _>(fd)?),
+            _ => {
+                return Err(CodecError::DeserializeError(format!(
+                    "Unknown reject code type prefix: {}",
+                    type_prefix
+                )))
+            }
+        };
+        Ok(code)
+    }
+}
+
+impl std::fmt::Display for RejectCode {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        match self {
+            RejectCode::ValidationFailed(code) => write!(f, "Validation failed: {:?}", code),
+            RejectCode::SignedRejection(sig) => {
+                write!(f, "A threshold number of signers rejected the block with the following signature: {:?}.", sig)
+            }
+            RejectCode::InsufficientSigners(malicious_signers) => write!(
+                f,
+                "Insufficient signers agreed to sign the block. The following signers are malicious: {:?}",
+                malicious_signers
+            ),
+        }
+    }
+}
+
+impl From<Packet> for SignerMessage {
+    fn from(packet: Packet) -> Self {
+        Self::Packet(packet)
+    }
+}
+
+impl From<BlockResponse> for SignerMessage {
+    fn from(block_response: BlockResponse) -> Self {
+        Self::BlockResponse(block_response)
+    }
+}
+
+impl From<BlockRejection> for SignerMessage {
+    fn from(block_rejection: BlockRejection) -> Self {
+        Self::BlockResponse(BlockResponse::Rejected(block_rejection))
+    }
+}
+
+impl From<BlockValidateReject> for SignerMessage {
+    fn from(rejection: BlockValidateReject) -> Self {
+        Self::BlockResponse(BlockResponse::Rejected(rejection.into()))
+    }
+}
+
+impl SignerMessage {
+    /// Helper function to determine the slot ID for the provided stacker-db writer id
+    pub fn slot_id(&self, id: u32) -> u32 {
+        let slot_id = match self {
+            Self::Packet(packet) => match packet.msg {
+                Message::DkgBegin(_) => DKG_BEGIN_SLOT_ID,
+                Message::DkgPrivateBegin(_) => DKG_PRIVATE_BEGIN_SLOT_ID,
+                Message::DkgEndBegin(_) => DKG_END_BEGIN_SLOT_ID,
+                Message::DkgEnd(_) => DKG_END_SLOT_ID,
+                Message::DkgPublicShares(_) => DKG_PUBLIC_SHARES_SLOT_ID,
+                Message::DkgPrivateShares(_) => DKG_PRIVATE_SHARES_SLOT_ID,
+                Message::NonceRequest(_) => NONCE_REQUEST_SLOT_ID,
+                Message::NonceResponse(_) => NONCE_RESPONSE_SLOT_ID,
+                Message::SignatureShareRequest(_) => SIGNATURE_SHARE_REQUEST_SLOT_ID,
+                Message::SignatureShareResponse(_) => SIGNATURE_SHARE_RESPONSE_SLOT_ID,
+            },
+            Self::BlockResponse(_) => BLOCK_SLOT_ID,
+        };
+        SIGNER_SLOTS_PER_USER * id + slot_id
+    }
+}
+
+#[cfg(test)]
+mod test {
+
+    use rand::Rng;
+    use rand_core::OsRng;
+    use wsts::common::Signature;
+
+    use super::*;
+    #[test]
+    fn serde_reject_code() {
+        let code = RejectCode::ValidationFailed(ValidateRejectCode::InvalidBlock);
+        let serialized_code = code.serialize_to_vec();
+        let deserialized_code = read_next::<RejectCode, _>(&mut &serialized_code[..])
+            .expect("Failed to deserialize RejectCode");
+        assert_eq!(code, deserialized_code);
+
+        let code = RejectCode::SignedRejection(ThresholdSignature::empty());
+        let serialized_code = code.serialize_to_vec();
+        let deserialized_code = read_next::<RejectCode, _>(&mut &serialized_code[..])
+            .expect("Failed to deserialize RejectCode");
+        assert_eq!(code, deserialized_code);
+
+        let code = RejectCode::InsufficientSigners(vec![0, 1, 2]);
+        let serialized_code = code.serialize_to_vec();
+        let deserialized_code = read_next::<RejectCode, _>(&mut &serialized_code[..])
+            .expect("Failed to deserialize RejectCode");
+        assert_eq!(code, deserialized_code);
+    }
+
+    #[test]
+    fn serde_block_rejection() {
+        let rejection = BlockRejection::new(
+            Sha512Trunc256Sum([0u8; 32]),
+            RejectCode::ValidationFailed(ValidateRejectCode::InvalidBlock),
+        );
+        let serialized_rejection = rejection.serialize_to_vec();
+        let deserialized_rejection = read_next::<BlockRejection, _>(&mut &serialized_rejection[..])
+            .expect("Failed to deserialize BlockRejection");
+        assert_eq!(rejection, deserialized_rejection);
+
+        let rejection = BlockRejection::new(
+            Sha512Trunc256Sum([1u8; 32]),
+            RejectCode::SignedRejection(ThresholdSignature::empty()),
+        );
+        let serialized_rejection = rejection.serialize_to_vec();
+        let deserialized_rejection = read_next::<BlockRejection, _>(&mut &serialized_rejection[..])
+            .expect("Failed to deserialize BlockRejection");
+        assert_eq!(rejection, deserialized_rejection);
+
+        let rejection = BlockRejection::new(
+            Sha512Trunc256Sum([2u8; 32]),
+            RejectCode::InsufficientSigners(vec![0, 1, 2]),
+        );
+        let serialized_rejection = rejection.serialize_to_vec();
+        let deserialized_rejection = read_next::<BlockRejection, _>(&mut &serialized_rejection[..])
+            .expect("Failed to deserialize BlockRejection");
+        assert_eq!(rejection, deserialized_rejection);
+    }
+
+    #[test]
+    fn serde_block_response() {
+        let response =
+            BlockResponse::Accepted((Sha512Trunc256Sum([0u8; 32]), ThresholdSignature::empty()));
+        let serialized_response = response.serialize_to_vec();
+        let deserialized_response = read_next::<BlockResponse, _>(&mut &serialized_response[..])
+            .expect("Failed to deserialize BlockResponse");
+        assert_eq!(response, deserialized_response);
+
+        let response = BlockResponse::Rejected(BlockRejection::new(
+            Sha512Trunc256Sum([1u8; 32]),
+            RejectCode::ValidationFailed(ValidateRejectCode::InvalidBlock),
+        ));
+        let serialized_response = response.serialize_to_vec();
+        let deserialized_response = read_next::<BlockResponse, _>(&mut &serialized_response[..])
+            .expect("Failed to deserialize BlockResponse");
+        assert_eq!(response, deserialized_response);
+    }
+
+    #[test]
+    fn serde_point_scalar() {
+        let mut rng = OsRng;
+        let scalar = Scalar::random(&mut rng);
+        let mut serialized_scalar = vec![];
+        consensus_serialize_scalar(&mut serialized_scalar, &scalar)
+            .expect("serialization to buffer failed.");
+        let deserialized_scalar = consensus_deserialize_scalar(&mut &serialized_scalar[..])
+            .expect("Failed to deserialize Scalar");
+        assert_eq!(scalar, deserialized_scalar);
+
+        let point = Point::from(scalar);
+        let mut serialized_point = vec![];
+        consensus_serialize_point(&mut serialized_point, &point)
+            .expect("serialization to buffer failed.");
+        let deserialized_point = consensus_deserialize_point(&mut &serialized_point[..])
+            .expect("Failed to deserialize Point");
+        assert_eq!(point, deserialized_point);
+    }
+
+    fn test_fixture_packet(msg: Message) {
+        let packet = Packet {
+            msg,
+            sig: vec![1u8; 20],
+        };
+        let mut serialized_packet = vec![];
+        consensus_serialize_packet(&mut serialized_packet, &packet)
+            .expect("serialization to buffer failed.");
+        let deserialized_packet = consensus_deserialize_packet(&mut &serialized_packet[..])
+            .expect("Failed to deserialize Packet");
+        assert_eq!(packet, deserialized_packet);
+    }
+
+    #[test]
+    fn serde_packet() {
+        // Test DKG begin Packet
+        test_fixture_packet(Message::DkgBegin(DkgBegin { dkg_id: 0 }));
+
+        let dkg_id = rand::thread_rng().gen();
+        let signer_id = rand::thread_rng().gen();
+        let sign_id = rand::thread_rng().gen();
+        let sign_iter_id = rand::thread_rng().gen();
+        let mut signer_ids = [0u32; 100];
+        rand::thread_rng().fill(&mut signer_ids[..]);
+
+        let mut key_ids = [0u32; 100];
+        rand::thread_rng().fill(&mut key_ids[..]);
+        let nmb_items = rand::thread_rng().gen_range(1..100);
+
+        // Test DKG private begin Packet
+        test_fixture_packet(Message::DkgPrivateBegin(DkgPrivateBegin {
+            dkg_id,
+            signer_ids: signer_ids.to_vec(),
+            key_ids: key_ids.to_vec(),
+        }));
+
+        // Test DKG end begin Packet
+        test_fixture_packet(Message::DkgEndBegin(DkgEndBegin {
+            dkg_id,
+            signer_ids: signer_ids.to_vec(),
+            key_ids: key_ids.to_vec(),
+        }));
+
+        // Test DKG end Packet Success
+        test_fixture_packet(Message::DkgEnd(DkgEnd {
+            dkg_id,
+            signer_id,
+            status: DkgStatus::Success,
+        }));
+
+        // Test DKG end Packet Failure
+        test_fixture_packet(Message::DkgEnd(DkgEnd {
+            dkg_id,
+            signer_id,
+            status: DkgStatus::Failure("failure".to_string()),
+        }));
+
+        // Test DKG public shares Packet
+        let rng = &mut OsRng;
+        let comms = (0..nmb_items)
+            .map(|i| {
+                (
+                    i,
+                    PolyCommitment {
+                        id: ID {
+                            id: Scalar::random(rng),
+                            kG: Point::from(Scalar::random(rng)),
+                            kca: Scalar::random(rng),
+                        },
+                        poly: vec![
+                            Point::from(Scalar::random(rng)),
+                            Point::from(Scalar::random(rng)),
+                        ],
+                    },
+                )
+            })
+            .collect();
+        test_fixture_packet(Message::DkgPublicShares(DkgPublicShares {
+            dkg_id,
+            signer_id,
+            comms,
+        }));
+
+        // Test DKG private shares Packet
+        let mut shares = vec![];
+        for i in 0..nmb_items {
+            let mut shares_map = HashMap::new();
+            for i in 0..nmb_items {
+                let mut bytes = [0u8; 20];
+                rng.fill(&mut bytes[..]);
+                shares_map.insert(i, bytes.to_vec());
+            }
+            shares.push((i, shares_map));
+        }
+        test_fixture_packet(Message::DkgPrivateShares(DkgPrivateShares {
+            dkg_id,
+            signer_id,
+            shares,
+        }));
+
+        // Test Nonce request Packet with merkle root
+        let mut message = [0u8; 40];
+        rng.fill(&mut message[..]);
+        let mut merkle_root_bytes = [0u8; 32];
+        rng.fill(&mut merkle_root_bytes[..]);
+        let merkle_root = Some(merkle_root_bytes);
+
+        test_fixture_packet(Message::NonceRequest(NonceRequest {
+            dkg_id,
+            sign_id,
+            sign_iter_id,
+            message: message.to_vec(),
+            is_taproot: true,
+            merkle_root,
+        }));
+
+        // Test Nonce request Packet with no merkle root
+        test_fixture_packet(Message::NonceRequest(NonceRequest {
+            dkg_id,
+            sign_id,
+            sign_iter_id,
+            message: message.to_vec(),
+            is_taproot: false,
+            merkle_root: None,
+        }));
+
+        // Test Nonce response Packet
+        let mut nonces = vec![];
+        for _ in 0..nmb_items {
+            nonces.push(PublicNonce {
+                D: Point::from(Scalar::random(rng)),
+                E: Point::from(Scalar::random(rng)),
+            });
+        }
+        let nonce_response = NonceResponse {
+            dkg_id,
+            sign_id,
+            sign_iter_id,
+            signer_id,
+            key_ids: key_ids.to_vec(),
+            nonces,
+            message: message.to_vec(),
+        };
+        test_fixture_packet(Message::NonceResponse(nonce_response.clone()));
+
+        // Test Signature share request Packet with merkle root and nonce response
+        test_fixture_packet(Message::SignatureShareRequest(SignatureShareRequest {
+            dkg_id,
+            sign_id,
+            sign_iter_id,
+            nonce_responses: vec![nonce_response],
+            message: message.to_vec(),
+            is_taproot: true,
+            merkle_root,
+        }));
+
+        // Test Signature share request Packet with no merkle root and nonce response
+        test_fixture_packet(Message::SignatureShareRequest(SignatureShareRequest {
+            dkg_id,
+            sign_id,
+            sign_iter_id,
+            nonce_responses: vec![],
+            message: message.to_vec(),
+            is_taproot: false,
+            merkle_root: None,
+        }));
+
+        // Test Signature share response Packet
+        let mut signature_shares = vec![];
+        for i in 0..nmb_items {
+            let mut key_ids = vec![];
+            for i in 0..nmb_items {
+                key_ids.push(i);
+            }
+            signature_shares.push(SignatureShare {
+                id: i,
+                z_i: Scalar::random(rng),
+                key_ids,
+            });
+        }
+        test_fixture_packet(Message::SignatureShareResponse(SignatureShareResponse {
+            dkg_id,
+            sign_id,
+            sign_iter_id,
+            signer_id,
+            signature_shares,
+        }));
+    }
+
+    #[test]
+    fn serde_signer_message() {
+        let rng = &mut OsRng;
+        let signer_message = SignerMessage::Packet(Packet {
+            msg: Message::DkgBegin(DkgBegin { dkg_id: 0 }),
+            sig: vec![1u8; 20],
+        });
+
+        let serialized_signer_message = signer_message.serialize_to_vec();
+        let deserialized_signer_message =
+            read_next::<SignerMessage, _>(&mut &serialized_signer_message[..])
+                .expect("Failed to deserialize SignerMessage");
+        assert_eq!(signer_message, deserialized_signer_message);
+
+        let signer_message = SignerMessage::BlockResponse(BlockResponse::Accepted((
+            Sha512Trunc256Sum([2u8; 32]),
+            ThresholdSignature(Signature {
+                R: Point::from(Scalar::random(rng)),
+                z: Scalar::random(rng),
+            }),
+        )));
+        let serialized_signer_message = signer_message.serialize_to_vec();
+        let deserialized_signer_message =
+            read_next::<SignerMessage, _>(&mut &serialized_signer_message[..])
+                .expect("Failed to deserialize SignerMessage");
+        assert_eq!(signer_message, deserialized_signer_message);
+    }
+}
diff --git a/libsigner/src/tests/http.rs b/libsigner/src/tests/http.rs
index eb187700e8..4582b07160 100644
--- a/libsigner/src/tests/http.rs
+++ b/libsigner/src/tests/http.rs
@@ -150,7 +150,7 @@ fn test_decode_http_response_err() {
 
 #[test]
 fn test_decode_http_body() {
-    let tests = vec![
+    let tests = [
         (true, ""),
         (true, "this is the song that never ends"),
         (false, ""),
diff --git a/libsigner/src/tests/mod.rs b/libsigner/src/tests/mod.rs
index b53fd00afa..c3e60e9fbf 100644
--- a/libsigner/src/tests/mod.rs
+++ b/libsigner/src/tests/mod.rs
@@ -27,11 +27,16 @@ use blockstack_lib::chainstate::stacks::events::StackerDBChunksEvent;
 use blockstack_lib::util_lib::boot::boot_code_id;
 use clarity::vm::types::QualifiedContractIdentifier;
 use libstackerdb::StackerDBChunkData;
+use stacks_common::codec::{
+    read_next, read_next_at_most, read_next_exact, write_next, Error as CodecError,
+    StacksMessageCodec,
+};
 use stacks_common::util::secp256k1::Secp256k1PrivateKey;
 use stacks_common::util::sleep_ms;
 use wsts::net::{DkgBegin, Packet};
 
-use crate::events::{SignerEvent, SignerMessage};
+use crate::events::SignerEvent;
+use crate::messages::SignerMessage;
 use crate::{Signer, SignerEventReceiver, SignerRunLoop};
 
 /// Simple runloop implementation.  It receives `max_events` events and returns `events` from the
@@ -104,7 +109,7 @@ fn test_simple_signer() {
         let privk = Secp256k1PrivateKey::new();
         let msg = wsts::net::Message::DkgBegin(DkgBegin { dkg_id: 0 });
         let message = SignerMessage::Packet(Packet { msg, sig: vec![] });
-        let message_bytes = bincode::serialize(&message).unwrap();
+        let message_bytes = message.serialize_to_vec();
         let mut chunk = StackerDBChunkData::new(i as u32, 1, message_bytes);
         chunk.sign(&privk).unwrap();
 
@@ -156,7 +161,7 @@ fn test_simple_signer() {
         .iter()
         .map(|chunk| {
             let msg = chunk.modified_slots[0].data.clone();
-            let signer_message: SignerMessage = bincode::deserialize(&msg).unwrap();
+            let signer_message = read_next::<SignerMessage, _>(&mut &msg[..]).unwrap();
             SignerEvent::SignerMessages(vec![signer_message])
         })
         .collect();
@@ -191,7 +196,7 @@ fn test_status_endpoint() {
 
         sock.write_all(req.as_bytes()).unwrap();
         let mut buf = [0; 128];
-        sock.read(&mut buf).unwrap();
+        let _ = sock.read(&mut buf).unwrap();
         let res_str = std::str::from_utf8(&buf).unwrap();
         let expected_status_res = "HTTP/1.0 200 OK\r\n";
         assert_eq!(expected_status_res, &res_str[..expected_status_res.len()]);
diff --git a/stacks-signer/Cargo.toml b/stacks-signer/Cargo.toml
index f680ce760e..e37c5b4552 100644
--- a/stacks-signer/Cargo.toml
+++ b/stacks-signer/Cargo.toml
@@ -21,7 +21,6 @@ path = "src/main.rs"
 
 [dependencies]
 backoff = "0.4"
-bincode = "1.3.3"
 clarity = { path = "../clarity" }
 clap = { version = "4.1.1", features = ["derive", "env"] }
 hashbrown = "0.14"
diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index e5bdfd09f1..607f3b4b2f 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -18,6 +18,7 @@ use hashbrown::HashMap;
 use libsigner::{SignerMessage, SignerSession, StackerDBSession};
 use libstackerdb::{StackerDBChunkAckData, StackerDBChunkData};
 use slog::{slog_debug, slog_warn};
+use stacks_common::codec::StacksMessageCodec;
 use stacks_common::types::chainstate::StacksPrivateKey;
 use stacks_common::{debug, warn};
 
@@ -55,7 +56,7 @@ impl StackerDB {
         id: u32,
         message: SignerMessage,
     ) -> Result<StackerDBChunkAckData, ClientError> {
-        let message_bytes = bincode::serialize(&message).unwrap();
+        let message_bytes = message.serialize_to_vec();
         let slot_id = message.slot_id(id);
 
         loop {
diff --git a/stackslib/src/net/api/postblock_proposal.rs b/stackslib/src/net/api/postblock_proposal.rs
index c0f3fa019d..469aac955b 100644
--- a/stackslib/src/net/api/postblock_proposal.rs
+++ b/stackslib/src/net/api/postblock_proposal.rs
@@ -67,6 +67,7 @@ use crate::util_lib::db::Error as DBError;
 ///  rejection responses. This is serialized as an enum with string
 ///  type (in jsonschema terminology).
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[repr(u8)]
 pub enum ValidateRejectCode {
     BadBlockHash,
     BadTransaction,
@@ -75,6 +76,21 @@ pub enum ValidateRejectCode {
     UnknownParent,
 }
 
+impl TryFrom<u8> for ValidateRejectCode {
+    type Error = String;
+
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        match value {
+            0 => Ok(ValidateRejectCode::BadBlockHash),
+            1 => Ok(ValidateRejectCode::BadTransaction),
+            2 => Ok(ValidateRejectCode::InvalidBlock),
+            3 => Ok(ValidateRejectCode::ChainstateError),
+            4 => Ok(ValidateRejectCode::UnknownParent),
+            _ => Err(format!("Invalid value for ValidateRejectCode: {value}")),
+        }
+    }
+}
+
 fn hex_ser_block<S: serde::Serializer>(b: &NakamotoBlock, s: S) -> Result<S::Ok, S::Error> {
     let inst = to_hex(&b.serialize_to_vec());
     s.serialize_str(inst.as_str())
diff --git a/testnet/stacks-node/Cargo.toml b/testnet/stacks-node/Cargo.toml
index ae68c95398..ae53315a7f 100644
--- a/testnet/stacks-node/Cargo.toml
+++ b/testnet/stacks-node/Cargo.toml
@@ -31,7 +31,6 @@ wsts = { workspace = true }
 rand = { workspace = true }
 rand_core = { workspace = true }
 hashbrown = "0.14"
-bincode = "1.3.3"
 
 [dev-dependencies]
 ring = "0.16.19"
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index ff2bd0b51d..daa78dd7a6 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -39,6 +39,7 @@ use stacks::chainstate::stacks::{
 };
 use stacks::core::FIRST_BURNCHAIN_CONSENSUS_HASH;
 use stacks::net::stackerdb::StackerDBs;
+use stacks_common::codec::read_next;
 use stacks_common::types::chainstate::{StacksAddress, StacksBlockId};
 use stacks_common::types::{PrivateKey, StacksEpochId};
 use stacks_common::util::hash::{Hash160, Sha512Trunc256Sum};
@@ -307,7 +308,7 @@ impl BlockMinerThread {
                 .zip(signer_chunks.into_iter())
                 .filter_map(|(slot_id, chunk)| {
                     chunk.and_then(|chunk| {
-                        bincode::deserialize::<SignerMessage>(&chunk)
+                        read_next::<SignerMessage, _>(&mut &chunk[..])
                             .ok()
                             .map(|msg| (*slot_id, msg))
                     })
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index 45aa72047f..4caa6c8c92 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -15,6 +15,7 @@ use stacks::chainstate::nakamoto::{NakamotoBlock, NakamotoBlockHeader};
 use stacks::chainstate::stacks::{StacksPrivateKey, ThresholdSignature};
 use stacks::net::api::postblock_proposal::BlockValidateResponse;
 use stacks_common::bitvec::BitVec;
+use stacks_common::codec::read_next;
 use stacks_common::types::chainstate::{
     ConsensusHash, StacksAddress, StacksBlockId, StacksPublicKey, TrieHash,
 };
@@ -674,7 +675,7 @@ fn stackerdb_block_proposal() {
         thread::sleep(Duration::from_secs(1));
     }
     let chunk = chunk.unwrap();
-    let signer_message = bincode::deserialize::<SignerMessage>(&chunk).unwrap();
+    let signer_message = read_next::<SignerMessage, _>(&mut &chunk[..]).unwrap();
     if let SignerMessage::BlockResponse(BlockResponse::Accepted((
         block_signer_signature_hash,
         block_signature,

From 75e50ac0a424865f518f2f48cce9d7eb58f65a45 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 31 Jan 2024 12:27:49 -0800
Subject: [PATCH 0598/1166] CRC: cleanup type prefix enum and move
 wait_for_signature and broadcast into the same function

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 libsigner/src/messages.rs                     | 22 +----
 stackslib/src/net/api/postblock_proposal.rs   | 35 +++----
 testnet/stacks-node/src/nakamoto_node.rs      |  3 +-
 .../stacks-node/src/nakamoto_node/miner.rs    | 98 +++++++++++++------
 4 files changed, 85 insertions(+), 73 deletions(-)

diff --git a/libsigner/src/messages.rs b/libsigner/src/messages.rs
index f9a243e859..d1f132d257 100644
--- a/libsigner/src/messages.rs
+++ b/libsigner/src/messages.rs
@@ -92,26 +92,8 @@ define_u8_enum!(TypePrefix {
 impl TryFrom<u8> for TypePrefix {
     type Error = CodecError;
     fn try_from(value: u8) -> Result<Self, Self::Error> {
-        match value {
-            0 => Ok(TypePrefix::BlockResponse),
-            1 => Ok(TypePrefix::Packet),
-            2 => Ok(TypePrefix::DkgBegin),
-            3 => Ok(TypePrefix::DkgPrivateBegin),
-            4 => Ok(TypePrefix::DkgEndBegin),
-            5 => Ok(TypePrefix::DkgEnd),
-            6 => Ok(TypePrefix::DkgPublicShares),
-            7 => Ok(TypePrefix::DkgPrivateShares),
-            8 => Ok(TypePrefix::NonceRequest),
-            9 => Ok(TypePrefix::NonceResponse),
-            10 => Ok(TypePrefix::SignatureShareRequest),
-            11 => Ok(TypePrefix::SignatureShareResponse),
-            12 => Ok(TypePrefix::DkgStatusSuccess),
-            13 => Ok(TypePrefix::DkgStatusFailure),
-            _ => Err(CodecError::DeserializeError(format!(
-                "Unknown type prefix: {}",
-                value
-            ))),
-        }
+        Self::from_u8(value)
+            .ok_or_else(|| CodecError::DeserializeError(format!("Unknown type prefix: {value}")))
     }
 }
 
diff --git a/stackslib/src/net/api/postblock_proposal.rs b/stackslib/src/net/api/postblock_proposal.rs
index 469aac955b..72b85c5778 100644
--- a/stackslib/src/net/api/postblock_proposal.rs
+++ b/stackslib/src/net/api/postblock_proposal.rs
@@ -63,31 +63,22 @@ use crate::net::{
 };
 use crate::util_lib::db::Error as DBError;
 
-/// This enum is used to supply a `reason_code` for validation
-///  rejection responses. This is serialized as an enum with string
-///  type (in jsonschema terminology).
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[repr(u8)]
-pub enum ValidateRejectCode {
-    BadBlockHash,
-    BadTransaction,
-    InvalidBlock,
-    ChainstateError,
-    UnknownParent,
-}
+// This enum is used to supply a `reason_code` for validation
+//  rejection responses. This is serialized as an enum with string
+//  type (in jsonschema terminology).
+define_u8_enum![ValidateRejectCode {
+    BadBlockHash = 0,
+    BadTransaction = 1,
+    InvalidBlock = 2,
+    ChainstateError = 3,
+    UnknownParent = 4
+}];
 
 impl TryFrom<u8> for ValidateRejectCode {
-    type Error = String;
-
+    type Error = CodecError;
     fn try_from(value: u8) -> Result<Self, Self::Error> {
-        match value {
-            0 => Ok(ValidateRejectCode::BadBlockHash),
-            1 => Ok(ValidateRejectCode::BadTransaction),
-            2 => Ok(ValidateRejectCode::InvalidBlock),
-            3 => Ok(ValidateRejectCode::ChainstateError),
-            4 => Ok(ValidateRejectCode::UnknownParent),
-            _ => Err(format!("Invalid value for ValidateRejectCode: {value}")),
-        }
+        Self::from_u8(value)
+            .ok_or_else(|| CodecError::DeserializeError(format!("Unknown type prefix: {value}")))
     }
 }
 
diff --git a/testnet/stacks-node/src/nakamoto_node.rs b/testnet/stacks-node/src/nakamoto_node.rs
index ddcbc197f7..abb98b35ea 100644
--- a/testnet/stacks-node/src/nakamoto_node.rs
+++ b/testnet/stacks-node/src/nakamoto_node.rs
@@ -93,7 +93,8 @@ pub enum Error {
     BadVrfConstruction,
     CannotSelfSign,
     MiningFailure(ChainstateError),
-    SigningError(&'static str),
+    MinerSignatureError(&'static str),
+    SignerSignatureError(&'static str),
     // The thread that we tried to send to has closed
     ChannelClosed,
 }
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index daa78dd7a6..bd64f968e9 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -190,7 +190,7 @@ impl BlockMinerThread {
             .expect("FATAL: could not open sortition DB");
             let tip = SortitionDB::get_canonical_burn_chain_tip(sort_db.conn())
                 .expect("FATAL: could not retrieve chain tip");
-            if let Some(mut new_block) = new_block {
+            if let Some(new_block) = new_block {
                 let signer_signature_hash = new_block.header.signer_signature_hash();
 
                 match NakamotoBlockBuilder::make_stackerdb_block_proposal(
@@ -223,25 +223,7 @@ impl BlockMinerThread {
                         warn!("Failed to propose block to stackerdb: {e:?}");
                     }
                 }
-                let mut chain_state = neon_node::open_chainstate_with_faults(&self.config)
-                    .expect("FATAL: could not open chainstate DB");
-                if let Ok(aggregate_public_key) = NakamotoChainState::get_aggregate_public_key(
-                    &mut chain_state,
-                    &sort_db,
-                    &sort_db.index_handle_at_tip(),
-                    &new_block,
-                ) {
-                    if let Some(signature) = self.wait_for_signature(
-                        &stackerdbs,
-                        &aggregate_public_key,
-                        &signer_signature_hash,
-                    ) {
-                        // TODO remove self signing once casting aggregate vote is done
-                        new_block.header.signer_signature = signature;
-                    } else {
-                        debug!("Failed to get a signed block from signers");
-                    }
-                };
+
                 if let Some(self_signer) = self.config.self_signing() {
                     if let Err(e) = self.self_sign_and_broadcast(self_signer, new_block.clone()) {
                         warn!("Error self-signing block: {e:?}");
@@ -249,7 +231,13 @@ impl BlockMinerThread {
                         self.globals.coord().announce_new_stacks_block();
                     }
                 } else {
-                    warn!("Not self-signing: nakamoto node does not support stacker-signer-protocol yet");
+                    if let Err(e) =
+                        self.wait_for_signer_signature_and_broadcast(&stackerdbs, new_block.clone())
+                    {
+                        warn!("Error broadcasting block: {e:?}");
+                    } else {
+                        self.globals.coord().announce_new_stacks_block();
+                    }
                 }
 
                 self.globals.counters.bump_naka_mined_blocks();
@@ -270,20 +258,21 @@ impl BlockMinerThread {
         }
     }
 
-    fn wait_for_signature(
+    fn wait_for_signer_signature(
         &self,
         stackerdbs: &StackerDBs,
         aggregate_public_key: &Point,
         signer_signature_hash: &Sha512Trunc256Sum,
-    ) -> Option<ThresholdSignature> {
+    ) -> Result<ThresholdSignature, NakamotoNodeError> {
         let stackerdb_contracts = stackerdbs
             .get_stackerdb_contract_ids()
             .expect("FATAL: could not get the stacker DB contract ids");
         // TODO: get this directly instead of this jankiness when .signers is a boot contract
         let signers_contract_id = boot_code_id(SIGNERS_NAME, self.config.is_mainnet());
         if !stackerdb_contracts.contains(&signers_contract_id) {
-            debug!("No signers contract found, cannot wait for signers");
-            return None;
+            return Err(NakamotoNodeError::SignerSignatureError(
+                "No signers contract found, cannot wait for signers",
+            ));
         };
         // Get the block slot for every signer
         let slot_ids = stackerdbs
@@ -325,7 +314,7 @@ impl BlockMinerThread {
                         {
                             // The signature is valid across the signer signature hash of the original proposed block
                             // Immediately return and update the block with this new signature before appending it to the chain
-                            return Some(signature);
+                            return Ok(signature);
                         }
                         // We received an accepted block for some unknown block hash...Useless! Ignore it.
                         // Keep waiting for a threshold number of signers to either reject the proposed block
@@ -345,7 +334,9 @@ impl BlockMinerThread {
                                 // A threshold number of signers signed a denial of the proposed block
                                 // Miner will NEVER get a signed block from the signers for this particular block
                                 // Immediately return and attempt to mine a new block
-                                return None;
+                                return Err(NakamotoNodeError::SignerSignatureError(
+                                    "Signers signed a rejection of the proposed block",
+                                ));
                             }
                         } else {
                             // We received a rejection that is not signed. We will keep waiting for a threshold number of rejections.
@@ -355,7 +346,9 @@ impl BlockMinerThread {
                                 // A threshold number of signers rejected the proposed block.
                                 // Miner will likely never get a signed block from the signers for this particular block
                                 // Return and attempt to mine a new block
-                                return None;
+                                return Err(NakamotoNodeError::SignerSignatureError(
+                                    "Threshold number of signers rejected the proposed block",
+                                ));
                             }
                         }
                     }
@@ -366,7 +359,52 @@ impl BlockMinerThread {
             thread::sleep(Duration::from_millis(WAIT_FOR_SIGNERS_MS));
         }
         // We have waited for the signers for too long: stop waiting so we can propose a new block
-        None
+        Err(NakamotoNodeError::SignerSignatureError(
+            "Timed out waiting for signers",
+        ))
+    }
+
+    fn wait_for_signer_signature_and_broadcast(
+        &self,
+        stackerdbs: &StackerDBs,
+        mut block: NakamotoBlock,
+    ) -> Result<(), ChainstateError> {
+        let mut chain_state = neon_node::open_chainstate_with_faults(&self.config)
+            .expect("FATAL: could not open chainstate DB");
+        let chainstate_config = chain_state.config();
+        let sort_db = SortitionDB::open(
+            &self.config.get_burn_db_file_path(),
+            true,
+            self.burnchain.pox_constants.clone(),
+        )
+        .expect("FATAL: could not open sortition DB");
+        let mut sortition_handle = sort_db.index_handle_at_tip();
+        let aggregate_public_key = NakamotoChainState::get_aggregate_public_key(
+            &mut chain_state,
+            &sort_db,
+            &sortition_handle,
+            &block,
+        )?;
+        let signature = self
+            .wait_for_signer_signature(
+                &stackerdbs,
+                &aggregate_public_key,
+                &block.header.signer_signature_hash(),
+            )
+            .map_err(|e| {
+                ChainstateError::InvalidStacksBlock(format!("Invalid Nakamoto block: {e:?}"))
+            })?;
+        block.header.signer_signature = signature;
+        let staging_tx = chain_state.staging_db_tx_begin()?;
+        NakamotoChainState::accept_block(
+            &chainstate_config,
+            block,
+            &mut sortition_handle,
+            &staging_tx,
+            &aggregate_public_key,
+        )?;
+        staging_tx.commit()?;
+        Ok(())
     }
 
     fn self_sign_and_broadcast(
@@ -691,7 +729,7 @@ impl BlockMinerThread {
         let mining_key = self.keychain.get_nakamoto_sk();
         let miner_signature = mining_key
             .sign(block.header.miner_signature_hash().as_bytes())
-            .map_err(NakamotoNodeError::SigningError)?;
+            .map_err(NakamotoNodeError::MinerSignatureError)?;
         block.header.miner_signature = miner_signature;
 
         info!(

From dd006d49fb08a25d60c656dcec806a52888d5223 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 2 Feb 2024 10:39:48 -0800
Subject: [PATCH 0599/1166] CRC: add trait for wsts struct serde

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 libsigner/src/messages.rs                     | 884 +++++++++---------
 testnet/stacks-node/src/config.rs             |   8 -
 .../stacks-node/src/nakamoto_node/miner.rs    |   5 +-
 3 files changed, 460 insertions(+), 437 deletions(-)

diff --git a/libsigner/src/messages.rs b/libsigner/src/messages.rs
index d1f132d257..bf2caa1f96 100644
--- a/libsigner/src/messages.rs
+++ b/libsigner/src/messages.rs
@@ -137,7 +137,7 @@ impl StacksMessageCodec for SignerMessage {
         write_next(fd, &(TypePrefix::from(self) as u8))?;
         match self {
             SignerMessage::Packet(packet) => {
-                consensus_serialize_packet(fd, packet)?;
+                packet.inner_consensus_serialize(fd)?;
             }
             SignerMessage::BlockResponse(block_response) => {
                 write_next(fd, block_response)?;
@@ -151,7 +151,7 @@ impl StacksMessageCodec for SignerMessage {
         let type_prefix = TypePrefix::try_from(type_prefix_byte)?;
         let message = match type_prefix {
             TypePrefix::Packet => {
-                let packet = consensus_deserialize_packet(fd)?;
+                let packet = Packet::inner_consensus_deserialize(fd)?;
                 SignerMessage::Packet(packet)
             }
             TypePrefix::BlockResponse => {
@@ -169,479 +169,510 @@ impl StacksMessageCodec for SignerMessage {
     }
 }
 
-fn consensus_serialize_scalar<W: Write>(fd: &mut W, scalar: &Scalar) -> Result<(), CodecError> {
-    write_next(fd, &scalar.to_bytes())
+/// Work around for the fact that a lot of the structs being desierialized are not defined in messages.rs
+pub trait StacksMessageCodecExtensions: Sized {
+    fn inner_consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), CodecError>;
+    fn inner_consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, CodecError>;
 }
 
-fn consensus_deserialize_scalar<R: Read>(fd: &mut R) -> Result<Scalar, CodecError> {
-    let scalar_bytes = read_next::<[u8; 32], _>(fd)?;
-    Ok(Scalar::from(scalar_bytes))
-}
-
-fn consensus_serialize_point<W: Write>(fd: &mut W, point: &Point) -> Result<(), CodecError> {
-    write_next(fd, &point.compress().as_bytes().to_vec())
-}
-
-fn consensus_deserialize_point<R: Read>(fd: &mut R) -> Result<Point, CodecError> {
-    let compressed_bytes: Vec<u8> = read_next(fd)?;
-    let compressed = Compressed::try_from(compressed_bytes.as_slice())
-        .map_err(|e| CodecError::DeserializeError(e.to_string()))?;
-    Point::try_from(&compressed).map_err(|e| CodecError::DeserializeError(e.to_string()))
-}
-
-fn consensus_serialize_dkg_begin<W: Write>(
-    fd: &mut W,
-    dkg_begin: &DkgBegin,
-) -> Result<(), CodecError> {
-    write_next(fd, &dkg_begin.dkg_id)
-}
-
-fn consensus_deserialize_dkg_begin<R: Read>(fd: &mut R) -> Result<DkgBegin, CodecError> {
-    let dkg_id = read_next::<u64, _>(fd)?;
-    Ok(DkgBegin { dkg_id })
-}
-
-fn consensus_serialize_dkg_private_begin<W: Write>(
-    fd: &mut W,
-    dkg_private_begin: &DkgPrivateBegin,
-) -> Result<(), CodecError> {
-    write_next(fd, &dkg_private_begin.dkg_id)?;
-    write_next(fd, &dkg_private_begin.signer_ids)?;
-    write_next(fd, &dkg_private_begin.key_ids)
+impl StacksMessageCodecExtensions for Scalar {
+    fn inner_consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), CodecError> {
+        write_next(fd, &self.to_bytes())
+    }
+    fn inner_consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, CodecError> {
+        let scalar_bytes = read_next::<[u8; 32], _>(fd)?;
+        Ok(Scalar::from(scalar_bytes))
+    }
 }
 
-fn consensus_deserialize_dkg_private_begin<R: Read>(
-    fd: &mut R,
-) -> Result<DkgPrivateBegin, CodecError> {
-    let dkg_id = read_next::<u64, _>(fd)?;
-    let signer_ids = read_next::<Vec<u32>, _>(fd)?;
-    let key_ids = read_next::<Vec<u32>, _>(fd)?;
-    Ok(DkgPrivateBegin {
-        dkg_id,
-        signer_ids,
-        key_ids,
-    })
+impl StacksMessageCodecExtensions for Point {
+    fn inner_consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), CodecError> {
+        write_next(fd, &self.compress().as_bytes().to_vec())
+    }
+    fn inner_consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, CodecError> {
+        let compressed_bytes: Vec<u8> = read_next(fd)?;
+        let compressed = Compressed::try_from(compressed_bytes.as_slice())
+            .map_err(|e| CodecError::DeserializeError(e.to_string()))?;
+        Ok(
+            Point::try_from(&compressed)
+                .map_err(|e| CodecError::DeserializeError(e.to_string()))?,
+        )
+    }
 }
 
-fn consensus_serialize_dkg_end_begin<W: Write>(
-    fd: &mut W,
-    dkg_end_begin: &DkgEndBegin,
-) -> Result<(), CodecError> {
-    write_next(fd, &dkg_end_begin.dkg_id)?;
-    write_next(fd, &dkg_end_begin.signer_ids)?;
-    write_next(fd, &dkg_end_begin.key_ids)
+impl StacksMessageCodecExtensions for DkgBegin {
+    fn inner_consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), CodecError> {
+        write_next(fd, &self.dkg_id)
+    }
+    fn inner_consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, CodecError> {
+        let dkg_id = read_next::<u64, _>(fd)?;
+        Ok(DkgBegin { dkg_id })
+    }
 }
 
-fn consensus_deserialize_dkg_end_begin<R: Read>(fd: &mut R) -> Result<DkgEndBegin, CodecError> {
-    let dkg_id = read_next::<u64, _>(fd)?;
-    let signer_ids = read_next::<Vec<u32>, _>(fd)?;
-    let key_ids = read_next::<Vec<u32>, _>(fd)?;
-    Ok(DkgEndBegin {
-        dkg_id,
-        signer_ids,
-        key_ids,
-    })
+impl StacksMessageCodecExtensions for DkgPrivateBegin {
+    fn inner_consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), CodecError> {
+        write_next(fd, &self.dkg_id)?;
+        write_next(fd, &self.signer_ids)?;
+        write_next(fd, &self.key_ids)
+    }
+    fn inner_consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, CodecError> {
+        let dkg_id = read_next::<u64, _>(fd)?;
+        let signer_ids = read_next::<Vec<u32>, _>(fd)?;
+        let key_ids = read_next::<Vec<u32>, _>(fd)?;
+        Ok(DkgPrivateBegin {
+            dkg_id,
+            signer_ids,
+            key_ids,
+        })
+    }
 }
 
-fn consensus_serialize_dkg_end<W: Write>(fd: &mut W, dkg_end: &DkgEnd) -> Result<(), CodecError> {
-    write_next(fd, &dkg_end.dkg_id)?;
-    write_next(fd, &dkg_end.signer_id)?;
-    match &dkg_end.status {
-        DkgStatus::Success => write_next(fd, &0u8),
-        DkgStatus::Failure(failure) => {
-            write_next(fd, &1u8)?;
-            write_next(fd, &failure.as_bytes().to_vec())
-        }
+impl StacksMessageCodecExtensions for DkgEndBegin {
+    fn inner_consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), CodecError> {
+        write_next(fd, &self.dkg_id)?;
+        write_next(fd, &self.signer_ids)?;
+        write_next(fd, &self.key_ids)
+    }
+    fn inner_consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, CodecError> {
+        let dkg_id = read_next::<u64, _>(fd)?;
+        let signer_ids = read_next::<Vec<u32>, _>(fd)?;
+        let key_ids = read_next::<Vec<u32>, _>(fd)?;
+        Ok(DkgEndBegin {
+            dkg_id,
+            signer_ids,
+            key_ids,
+        })
     }
 }
 
-fn consensus_deserialize_dkg_end<R: Read>(fd: &mut R) -> Result<DkgEnd, CodecError> {
-    let dkg_id = read_next::<u64, _>(fd)?;
-    let signer_id = read_next::<u32, _>(fd)?;
-    let status_type_prefix = read_next::<u8, _>(fd)?;
-    let status = match status_type_prefix {
-        0 => DkgStatus::Success,
-        1 => {
-            let failure_bytes: Vec<u8> = read_next(fd)?;
-            let failure = String::from_utf8(failure_bytes)
-                .map_err(|e| CodecError::DeserializeError(e.to_string()))?;
-            DkgStatus::Failure(failure)
-        }
-        _ => {
-            return Err(CodecError::DeserializeError(format!(
-                "Unknown DKG status type prefix: {}",
-                status_type_prefix
-            )))
+impl StacksMessageCodecExtensions for DkgEnd {
+    fn inner_consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), CodecError> {
+        write_next(fd, &self.dkg_id)?;
+        write_next(fd, &self.signer_id)?;
+        match &self.status {
+            DkgStatus::Success => write_next(fd, &0u8),
+            DkgStatus::Failure(failure) => {
+                write_next(fd, &1u8)?;
+                write_next(fd, &failure.as_bytes().to_vec())
+            }
         }
-    };
-    Ok(DkgEnd {
-        dkg_id,
-        signer_id,
-        status,
-    })
+    }
+    fn inner_consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, CodecError> {
+        let dkg_id = read_next::<u64, _>(fd)?;
+        let signer_id = read_next::<u32, _>(fd)?;
+        let status_type_prefix = read_next::<u8, _>(fd)?;
+        let status = match status_type_prefix {
+            0 => DkgStatus::Success,
+            1 => {
+                let failure_bytes: Vec<u8> = read_next(fd)?;
+                let failure = String::from_utf8(failure_bytes)
+                    .map_err(|e| CodecError::DeserializeError(e.to_string()))?;
+                DkgStatus::Failure(failure)
+            }
+            _ => {
+                return Err(CodecError::DeserializeError(format!(
+                    "Unknown DKG status type prefix: {}",
+                    status_type_prefix
+                )))
+            }
+        };
+        Ok(DkgEnd {
+            dkg_id,
+            signer_id,
+            status,
+        })
+    }
 }
 
-fn consensus_serialize_dkg_public_shares<W: Write>(
-    fd: &mut W,
-    dkg_public_shares: &DkgPublicShares,
-) -> Result<(), CodecError> {
-    write_next(fd, &dkg_public_shares.dkg_id)?;
-    write_next(fd, &dkg_public_shares.signer_id)?;
-    write_next(fd, &(dkg_public_shares.comms.len() as u32))?;
-    for (id, comm) in &dkg_public_shares.comms {
-        write_next(fd, id)?;
-        consensus_serialize_scalar(fd, &comm.id.id)?;
-        consensus_serialize_point(fd, &comm.id.kG)?;
-        consensus_serialize_scalar(fd, &comm.id.kca)?;
-        write_next(fd, &(comm.poly.len() as u32))?;
-        for poly in comm.poly.iter() {
-            consensus_serialize_point(fd, poly)?
+impl StacksMessageCodecExtensions for DkgPublicShares {
+    fn inner_consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), CodecError> {
+        write_next(fd, &self.dkg_id)?;
+        write_next(fd, &self.signer_id)?;
+        write_next(fd, &(self.comms.len() as u32))?;
+        for (id, comm) in &self.comms {
+            write_next(fd, id)?;
+            comm.id.id.inner_consensus_serialize(fd)?;
+            comm.id.kG.inner_consensus_serialize(fd)?;
+            comm.id.kca.inner_consensus_serialize(fd)?;
+            write_next(fd, &(comm.poly.len() as u32))?;
+            for poly in comm.poly.iter() {
+                poly.inner_consensus_serialize(fd)?
+            }
         }
+        Ok(())
     }
-    Ok(())
-}
 
-#[allow(non_snake_case)]
-fn consensus_deserialize_dkg_public_shares<R: Read>(
-    fd: &mut R,
-) -> Result<DkgPublicShares, CodecError> {
-    let dkg_id = read_next::<u64, _>(fd)?;
-    let signer_id = read_next::<u32, _>(fd)?;
-    let num_shares = read_next::<u32, _>(fd)?;
-    let mut comms = Vec::new();
-    for _ in 0..num_shares {
-        let id = read_next::<u32, _>(fd)?;
-        let scalar_id = consensus_deserialize_scalar(fd)?;
-        let kG = consensus_deserialize_point(fd)?;
-        let kca = consensus_deserialize_scalar(fd)?;
-        let num_poly_coeffs = read_next::<u32, _>(fd)?;
-        let mut poly = Vec::new();
-        for _ in 0..num_poly_coeffs {
-            poly.push(consensus_deserialize_point(fd)?);
-        }
-        comms.push((
-            id,
-            PolyCommitment {
-                id: ID {
-                    id: scalar_id,
-                    kG,
-                    kca,
+    #[allow(non_snake_case)]
+    fn inner_consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, CodecError> {
+        let dkg_id = read_next::<u64, _>(fd)?;
+        let signer_id = read_next::<u32, _>(fd)?;
+        let num_shares = read_next::<u32, _>(fd)?;
+        let mut comms = Vec::new();
+        for _ in 0..num_shares {
+            let id = read_next::<u32, _>(fd)?;
+            let scalar_id = Scalar::inner_consensus_deserialize(fd)?;
+            let kG = Point::inner_consensus_deserialize(fd)?;
+            let kca = Scalar::inner_consensus_deserialize(fd)?;
+            let num_poly_coeffs = read_next::<u32, _>(fd)?;
+            let mut poly = Vec::new();
+            for _ in 0..num_poly_coeffs {
+                poly.push(Point::inner_consensus_deserialize(fd)?);
+            }
+            comms.push((
+                id,
+                PolyCommitment {
+                    id: ID {
+                        id: scalar_id,
+                        kG,
+                        kca,
+                    },
+                    poly,
                 },
-                poly,
-            },
-        ));
+            ));
+        }
+        Ok(DkgPublicShares {
+            dkg_id,
+            signer_id,
+            comms,
+        })
     }
-    Ok(DkgPublicShares {
-        dkg_id,
-        signer_id,
-        comms,
-    })
 }
 
-fn consensus_serialize_dkg_private_shares<W: Write>(
-    fd: &mut W,
-    dkg_private_shares: &DkgPrivateShares,
-) -> Result<(), CodecError> {
-    write_next(fd, &dkg_private_shares.dkg_id)?;
-    write_next(fd, &dkg_private_shares.signer_id)?;
-    write_next(fd, &(dkg_private_shares.shares.len() as u32))?;
-    for (id, share_map) in &dkg_private_shares.shares {
-        write_next(fd, id)?;
-        write_next(fd, &(share_map.len() as u32))?;
-        for (id, share) in share_map {
+impl StacksMessageCodecExtensions for DkgPrivateShares {
+    fn inner_consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), CodecError> {
+        write_next(fd, &self.dkg_id)?;
+        write_next(fd, &self.signer_id)?;
+        write_next(fd, &(self.shares.len() as u32))?;
+        for (id, share_map) in &self.shares {
             write_next(fd, id)?;
-            write_next(fd, share)?;
+            write_next(fd, &(share_map.len() as u32))?;
+            for (id, share) in share_map {
+                write_next(fd, id)?;
+                write_next(fd, share)?;
+            }
         }
+        Ok(())
     }
-    Ok(())
-}
 
-fn consensus_deserialize_dkg_private_shares<R: Read>(
-    fd: &mut R,
-) -> Result<DkgPrivateShares, CodecError> {
-    let dkg_id = read_next::<u64, _>(fd)?;
-    let signer_id = read_next::<u32, _>(fd)?;
-    let num_shares = read_next::<u32, _>(fd)?;
-    let mut shares = Vec::new();
-    for _ in 0..num_shares {
-        let id = read_next::<u32, _>(fd)?;
-        let num_share_map = read_next::<u32, _>(fd)?;
-        let mut share_map = HashMap::new();
-        for _ in 0..num_share_map {
+    fn inner_consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, CodecError> {
+        let dkg_id = read_next::<u64, _>(fd)?;
+        let signer_id = read_next::<u32, _>(fd)?;
+        let num_shares = read_next::<u32, _>(fd)?;
+        let mut shares = Vec::new();
+        for _ in 0..num_shares {
             let id = read_next::<u32, _>(fd)?;
-            let share: Vec<u8> = read_next(fd)?;
-            share_map.insert(id, share);
+            let num_share_map = read_next::<u32, _>(fd)?;
+            let mut share_map = HashMap::new();
+            for _ in 0..num_share_map {
+                let id = read_next::<u32, _>(fd)?;
+                let share: Vec<u8> = read_next(fd)?;
+                share_map.insert(id, share);
+            }
+            shares.push((id, share_map));
         }
-        shares.push((id, share_map));
+        Ok(DkgPrivateShares {
+            dkg_id,
+            signer_id,
+            shares,
+        })
     }
-    Ok(DkgPrivateShares {
-        dkg_id,
-        signer_id,
-        shares,
-    })
 }
 
-fn consensus_serialize_nonce_request<W: Write>(
-    fd: &mut W,
-    nonce_request: &NonceRequest,
-) -> Result<(), CodecError> {
-    write_next(fd, &nonce_request.dkg_id)?;
-    write_next(fd, &nonce_request.sign_id)?;
-    write_next(fd, &nonce_request.sign_iter_id)?;
-    write_next(fd, &nonce_request.message)?;
-    write_next(fd, &(nonce_request.is_taproot as u8))?;
-    write_next(fd, &(nonce_request.merkle_root.is_some() as u8))?;
-    if let Some(merkle_root) = nonce_request.merkle_root {
-        write_next(fd, &merkle_root)?;
+impl StacksMessageCodecExtensions for NonceRequest {
+    fn inner_consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), CodecError> {
+        write_next(fd, &self.dkg_id)?;
+        write_next(fd, &self.sign_id)?;
+        write_next(fd, &self.sign_iter_id)?;
+        write_next(fd, &self.message)?;
+        write_next(fd, &(self.is_taproot as u8))?;
+        write_next(fd, &(self.merkle_root.is_some() as u8))?;
+        if let Some(merkle_root) = self.merkle_root {
+            write_next(fd, &merkle_root)?;
+        }
+        Ok(())
     }
-    Ok(())
-}
 
-fn consensus_deserialize_nonce_request<R: Read>(fd: &mut R) -> Result<NonceRequest, CodecError> {
-    let dkg_id = read_next::<u64, _>(fd)?;
-    let sign_id = read_next::<u64, _>(fd)?;
-    let sign_iter_id = read_next::<u64, _>(fd)?;
-    let message = read_next::<Vec<u8>, _>(fd)?;
-    let is_taproot = read_next::<u8, _>(fd)? != 0;
-    let has_merkle_root = read_next::<u8, _>(fd)? != 0;
-    let merkle_root = if has_merkle_root {
-        Some(read_next::<[u8; 32], _>(fd)?)
-    } else {
-        None
-    };
-
-    Ok(NonceRequest {
-        dkg_id,
-        sign_id,
-        sign_iter_id,
-        message,
-        is_taproot,
-        merkle_root,
-    })
+    fn inner_consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, CodecError> {
+        let dkg_id = read_next::<u64, _>(fd)?;
+        let sign_id = read_next::<u64, _>(fd)?;
+        let sign_iter_id = read_next::<u64, _>(fd)?;
+        let message = read_next::<Vec<u8>, _>(fd)?;
+        let is_taproot = read_next::<u8, _>(fd)? != 0;
+        let has_merkle_root = read_next::<u8, _>(fd)? != 0;
+        let merkle_root = if has_merkle_root {
+            Some(read_next::<[u8; 32], _>(fd)?)
+        } else {
+            None
+        };
+
+        Ok(NonceRequest {
+            dkg_id,
+            sign_id,
+            sign_iter_id,
+            message,
+            is_taproot,
+            merkle_root,
+        })
+    }
 }
 
-fn consensus_serialize_nonce_response<W: Write>(
-    fd: &mut W,
-    nonce_response: &NonceResponse,
-) -> Result<(), CodecError> {
-    write_next(fd, &nonce_response.dkg_id)?;
-    write_next(fd, &nonce_response.sign_id)?;
-    write_next(fd, &nonce_response.sign_iter_id)?;
-    write_next(fd, &nonce_response.signer_id)?;
-    write_next(fd, &nonce_response.key_ids)?;
-    write_next(fd, &(nonce_response.nonces.len() as u32))?;
-    for nonce in &nonce_response.nonces {
-        consensus_serialize_point(fd, &nonce.D)?;
-        consensus_serialize_point(fd, &nonce.E)?;
+impl StacksMessageCodecExtensions for NonceResponse {
+    fn inner_consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), CodecError> {
+        write_next(fd, &self.dkg_id)?;
+        write_next(fd, &self.sign_id)?;
+        write_next(fd, &self.sign_iter_id)?;
+        write_next(fd, &self.signer_id)?;
+        write_next(fd, &self.key_ids)?;
+        write_next(fd, &(self.nonces.len() as u32))?;
+        for nonce in &self.nonces {
+            nonce.D.inner_consensus_serialize(fd)?;
+            nonce.E.inner_consensus_serialize(fd)?;
+        }
+        write_next(fd, &self.message)?;
+        Ok(())
     }
 
-    write_next(fd, &nonce_response.message)?;
-    Ok(())
-}
+    #[allow(non_snake_case)]
+    fn inner_consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, CodecError> {
+        let dkg_id = read_next::<u64, _>(fd)?;
+        let sign_id = read_next::<u64, _>(fd)?;
+        let sign_iter_id = read_next::<u64, _>(fd)?;
+        let signer_id = read_next::<u32, _>(fd)?;
+        let key_ids = read_next::<Vec<u32>, _>(fd)?;
+        let num_nonces = read_next::<u32, _>(fd)?;
+        let mut nonces = Vec::new();
+        for _ in 0..num_nonces {
+            let D = Point::inner_consensus_deserialize(fd)?;
+            let E = Point::inner_consensus_deserialize(fd)?;
+            nonces.push(PublicNonce { D, E });
+        }
+        let message = read_next::<Vec<u8>, _>(fd)?;
 
-#[allow(non_snake_case)]
-fn consensus_deserialize_nonce_response<R: Read>(fd: &mut R) -> Result<NonceResponse, CodecError> {
-    let dkg_id = read_next::<u64, _>(fd)?;
-    let sign_id = read_next::<u64, _>(fd)?;
-    let sign_iter_id = read_next::<u64, _>(fd)?;
-    let signer_id = read_next::<u32, _>(fd)?;
-    let key_ids = read_next::<Vec<u32>, _>(fd)?;
-    let num_nonces = read_next::<u32, _>(fd)?;
-    let mut nonces = Vec::new();
-    for _ in 0..num_nonces {
-        let D = consensus_deserialize_point(fd)?;
-        let E = consensus_deserialize_point(fd)?;
-        nonces.push(PublicNonce { D, E });
+        Ok(NonceResponse {
+            dkg_id,
+            sign_id,
+            sign_iter_id,
+            signer_id,
+            key_ids,
+            nonces,
+            message,
+        })
     }
-    let message = read_next::<Vec<u8>, _>(fd)?;
-
-    Ok(NonceResponse {
-        dkg_id,
-        sign_id,
-        sign_iter_id,
-        signer_id,
-        key_ids,
-        nonces,
-        message,
-    })
 }
 
-fn consensus_serialize_signature_share_request<W: Write>(
-    fd: &mut W,
-    signature_share_request: &SignatureShareRequest,
-) -> Result<(), CodecError> {
-    write_next(fd, &signature_share_request.dkg_id)?;
-    write_next(fd, &signature_share_request.sign_id)?;
-    write_next(fd, &signature_share_request.sign_iter_id)?;
-    write_next(fd, &(signature_share_request.nonce_responses.len() as u32))?;
-    for nonce_response in &signature_share_request.nonce_responses {
-        consensus_serialize_nonce_response(fd, nonce_response)?;
-    }
-    write_next(fd, &signature_share_request.message)?;
-    write_next(fd, &(signature_share_request.is_taproot as u8))?;
-    write_next(fd, &(signature_share_request.merkle_root.is_some() as u8))?;
-    if let Some(merkle_root) = signature_share_request.merkle_root {
-        write_next(fd, &merkle_root)?;
+impl StacksMessageCodecExtensions for SignatureShareRequest {
+    fn inner_consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), CodecError> {
+        write_next(fd, &self.dkg_id)?;
+        write_next(fd, &self.sign_id)?;
+        write_next(fd, &self.sign_iter_id)?;
+        write_next(fd, &(self.nonce_responses.len() as u32))?;
+        for nonce_response in &self.nonce_responses {
+            nonce_response.inner_consensus_serialize(fd)?;
+        }
+        write_next(fd, &self.message)?;
+        write_next(fd, &(self.is_taproot as u8))?;
+        write_next(fd, &(self.merkle_root.is_some() as u8))?;
+        if let Some(merkle_root) = self.merkle_root {
+            write_next(fd, &merkle_root)?;
+        }
+        Ok(())
     }
-    Ok(())
-}
 
-fn consensus_deserialize_signature_share_request<R: Read>(
-    fd: &mut R,
-) -> Result<SignatureShareRequest, CodecError> {
-    let dkg_id = read_next::<u64, _>(fd)?;
-    let sign_id = read_next::<u64, _>(fd)?;
-    let sign_iter_id = read_next::<u64, _>(fd)?;
-    let num_nonce_responses = read_next::<u32, _>(fd)?;
-    let mut nonce_responses = Vec::new();
-    for _ in 0..num_nonce_responses {
-        nonce_responses.push(consensus_deserialize_nonce_response(fd)?);
+    fn inner_consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, CodecError> {
+        let dkg_id = read_next::<u64, _>(fd)?;
+        let sign_id = read_next::<u64, _>(fd)?;
+        let sign_iter_id = read_next::<u64, _>(fd)?;
+        let num_nonce_responses = read_next::<u32, _>(fd)?;
+        let mut nonce_responses = Vec::new();
+        for _ in 0..num_nonce_responses {
+            nonce_responses.push(NonceResponse::inner_consensus_deserialize(fd)?);
+        }
+        let message = read_next::<Vec<u8>, _>(fd)?;
+        let is_taproot = read_next::<u8, _>(fd)? != 0;
+        let has_merkle_root = read_next::<u8, _>(fd)? != 0;
+        let merkle_root = if has_merkle_root {
+            Some(read_next::<[u8; 32], _>(fd)?)
+        } else {
+            None
+        };
+
+        Ok(SignatureShareRequest {
+            dkg_id,
+            sign_id,
+            sign_iter_id,
+            nonce_responses,
+            message,
+            is_taproot,
+            merkle_root,
+        })
     }
-    let message = read_next::<Vec<u8>, _>(fd)?;
-    let is_taproot = read_next::<u8, _>(fd)? != 0;
-    let has_merkle_root = read_next::<u8, _>(fd)? != 0;
-    let merkle_root = if has_merkle_root {
-        Some(read_next::<[u8; 32], _>(fd)?)
-    } else {
-        None
-    };
-
-    Ok(SignatureShareRequest {
-        dkg_id,
-        sign_id,
-        sign_iter_id,
-        nonce_responses,
-        message,
-        is_taproot,
-        merkle_root,
-    })
 }
 
-fn consensus_serialize_signature_share_response<W: Write>(
-    fd: &mut W,
-    signature_share_response: &SignatureShareResponse,
-) -> Result<(), CodecError> {
-    write_next(fd, &signature_share_response.dkg_id)?;
-    write_next(fd, &signature_share_response.sign_id)?;
-    write_next(fd, &signature_share_response.sign_iter_id)?;
-    write_next(fd, &signature_share_response.signer_id)?;
-    write_next(
-        fd,
-        &(signature_share_response.signature_shares.len() as u32),
-    )?;
-    for share in &signature_share_response.signature_shares {
-        write_next(fd, &share.id)?;
-        consensus_serialize_scalar(fd, &share.z_i)?;
-        write_next(fd, &share.key_ids)?;
+impl StacksMessageCodecExtensions for SignatureShareResponse {
+    fn inner_consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), CodecError> {
+        write_next(fd, &self.dkg_id)?;
+        write_next(fd, &self.sign_id)?;
+        write_next(fd, &self.sign_iter_id)?;
+        write_next(fd, &self.signer_id)?;
+        write_next(fd, &(self.signature_shares.len() as u32))?;
+        for share in &self.signature_shares {
+            write_next(fd, &share.id)?;
+            share.z_i.inner_consensus_serialize(fd)?;
+            write_next(fd, &share.key_ids)?;
+        }
+        Ok(())
     }
-    Ok(())
-}
 
-fn consensus_deserialize_signature_share_response<R: Read>(
-    fd: &mut R,
-) -> Result<SignatureShareResponse, CodecError> {
-    let dkg_id = read_next::<u64, _>(fd)?;
-    let sign_id = read_next::<u64, _>(fd)?;
-    let sign_iter_id = read_next::<u64, _>(fd)?;
-    let signer_id = read_next::<u32, _>(fd)?;
-    let num_shares = read_next::<u32, _>(fd)?;
-    let mut signature_shares = Vec::new();
-    for _ in 0..num_shares {
-        let id = read_next::<u32, _>(fd)?;
-        let z_i = consensus_deserialize_scalar(fd)?;
-        let key_ids = read_next::<Vec<u32>, _>(fd)?;
-        signature_shares.push(SignatureShare { id, z_i, key_ids });
+    fn inner_consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, CodecError> {
+        let dkg_id = read_next::<u64, _>(fd)?;
+        let sign_id = read_next::<u64, _>(fd)?;
+        let sign_iter_id = read_next::<u64, _>(fd)?;
+        let signer_id = read_next::<u32, _>(fd)?;
+        let num_shares = read_next::<u32, _>(fd)?;
+        let mut signature_shares = Vec::new();
+        for _ in 0..num_shares {
+            let id = read_next::<u32, _>(fd)?;
+            let z_i = Scalar::inner_consensus_deserialize(fd)?;
+            let key_ids = read_next::<Vec<u32>, _>(fd)?;
+            signature_shares.push(SignatureShare { id, z_i, key_ids });
+        }
+        Ok(SignatureShareResponse {
+            dkg_id,
+            sign_id,
+            sign_iter_id,
+            signer_id,
+            signature_shares,
+        })
     }
-    Ok(SignatureShareResponse {
-        dkg_id,
-        sign_id,
-        sign_iter_id,
-        signer_id,
-        signature_shares,
-    })
 }
 
-pub fn consensus_serialize_message<W: Write>(
-    fd: &mut W,
-    message: &Message,
-) -> Result<(), CodecError> {
-    match message {
-        Message::DkgBegin(dkg_begin) => {
-            consensus_serialize_dkg_begin(fd, dkg_begin)?;
-        }
-        Message::DkgPrivateBegin(dkg_private_begin) => {
-            consensus_serialize_dkg_private_begin(fd, dkg_private_begin)?;
-        }
-        Message::DkgEndBegin(dkg_end_begin) => {
-            consensus_serialize_dkg_end_begin(fd, dkg_end_begin)?;
-        }
-        Message::DkgEnd(dkg_end) => {
-            consensus_serialize_dkg_end(fd, dkg_end)?;
-        }
-        Message::DkgPublicShares(dkg_public_shares) => {
-            consensus_serialize_dkg_public_shares(fd, dkg_public_shares)?;
-        }
-        Message::DkgPrivateShares(dkg_private_shares) => {
-            consensus_serialize_dkg_private_shares(fd, dkg_private_shares)?;
-        }
-        Message::NonceRequest(nonce_request) => {
-            consensus_serialize_nonce_request(fd, nonce_request)?;
-        }
-        Message::NonceResponse(nonce_response) => {
-            consensus_serialize_nonce_response(fd, nonce_response)?;
-        }
-        Message::SignatureShareRequest(signature_share_request) => {
-            consensus_serialize_signature_share_request(fd, signature_share_request)?;
-        }
-        Message::SignatureShareResponse(signature_share_response) => {
-            consensus_serialize_signature_share_response(fd, signature_share_response)?;
+impl StacksMessageCodecExtensions for Message {
+    fn inner_consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), CodecError> {
+        match self {
+            Message::DkgBegin(dkg_begin) => {
+                dkg_begin.inner_consensus_serialize(fd)?;
+            }
+            Message::DkgPrivateBegin(dkg_private_begin) => {
+                dkg_private_begin.inner_consensus_serialize(fd)?;
+            }
+            Message::DkgEndBegin(dkg_end_begin) => {
+                dkg_end_begin.inner_consensus_serialize(fd)?;
+            }
+            Message::DkgEnd(dkg_end) => {
+                dkg_end.inner_consensus_serialize(fd)?;
+            }
+            Message::DkgPublicShares(dkg_public_shares) => {
+                dkg_public_shares.inner_consensus_serialize(fd)?;
+            }
+            Message::DkgPrivateShares(dkg_private_shares) => {
+                dkg_private_shares.inner_consensus_serialize(fd)?;
+            }
+            Message::NonceRequest(nonce_request) => {
+                nonce_request.inner_consensus_serialize(fd)?;
+            }
+            Message::NonceResponse(nonce_response) => {
+                nonce_response.inner_consensus_serialize(fd)?;
+            }
+            Message::SignatureShareRequest(signature_share_request) => {
+                signature_share_request.inner_consensus_serialize(fd)?;
+            }
+            Message::SignatureShareResponse(signature_share_response) => {
+                signature_share_response.inner_consensus_serialize(fd)?;
+            }
         }
+        Ok(())
     }
-    Ok(())
-}
 
-fn consensus_serialize_packet<W: Write>(fd: &mut W, packet: &Packet) -> Result<(), CodecError> {
-    write_next(fd, &(TypePrefix::from(packet) as u8))?;
-    consensus_serialize_message(fd, &packet.msg)?;
-    write_next(fd, &packet.sig)?;
-    Ok(())
+    fn inner_consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, CodecError> {
+        let type_prefix_byte = read_next::<u8, _>(fd)?;
+        let type_prefix = TypePrefix::try_from(type_prefix_byte)?;
+        let message = match type_prefix {
+            TypePrefix::DkgBegin => Message::DkgBegin(DkgBegin::inner_consensus_deserialize(fd)?),
+            TypePrefix::DkgPrivateBegin => {
+                Message::DkgPrivateBegin(DkgPrivateBegin::inner_consensus_deserialize(fd)?)
+            }
+            TypePrefix::DkgEndBegin => {
+                Message::DkgEndBegin(DkgEndBegin::inner_consensus_deserialize(fd)?)
+            }
+            TypePrefix::DkgEnd => Message::DkgEnd(DkgEnd::inner_consensus_deserialize(fd)?),
+            TypePrefix::DkgPublicShares => {
+                Message::DkgPublicShares(DkgPublicShares::inner_consensus_deserialize(fd)?)
+            }
+            TypePrefix::DkgPrivateShares => {
+                Message::DkgPrivateShares(DkgPrivateShares::inner_consensus_deserialize(fd)?)
+            }
+            TypePrefix::NonceRequest => {
+                Message::NonceRequest(NonceRequest::inner_consensus_deserialize(fd)?)
+            }
+            TypePrefix::NonceResponse => {
+                Message::NonceResponse(NonceResponse::inner_consensus_deserialize(fd)?)
+            }
+            TypePrefix::SignatureShareRequest => Message::SignatureShareRequest(
+                SignatureShareRequest::inner_consensus_deserialize(fd)?,
+            ),
+            TypePrefix::SignatureShareResponse => Message::SignatureShareResponse(
+                SignatureShareResponse::inner_consensus_deserialize(fd)?,
+            ),
+            _ => {
+                return Err(CodecError::DeserializeError(format!(
+                    "Unknown message type prefix: {}",
+                    type_prefix_byte
+                )))
+            }
+        };
+        Ok(message)
+    }
 }
 
-fn consensus_deserialize_packet<R: Read>(fd: &mut R) -> Result<Packet, CodecError> {
-    let type_prefix_byte = read_next::<u8, _>(fd)?;
-    let type_prefix = TypePrefix::try_from(type_prefix_byte)?;
-    let msg = match type_prefix {
-        TypePrefix::DkgBegin => Message::DkgBegin(consensus_deserialize_dkg_begin(fd)?),
-        TypePrefix::DkgPrivateBegin => {
-            Message::DkgPrivateBegin(consensus_deserialize_dkg_private_begin(fd)?)
-        }
-        TypePrefix::DkgEndBegin => Message::DkgEndBegin(consensus_deserialize_dkg_end_begin(fd)?),
-        TypePrefix::DkgEnd => Message::DkgEnd(consensus_deserialize_dkg_end(fd)?),
-        TypePrefix::DkgPublicShares => {
-            Message::DkgPublicShares(consensus_deserialize_dkg_public_shares(fd)?)
-        }
-        TypePrefix::DkgPrivateShares => {
-            Message::DkgPrivateShares(consensus_deserialize_dkg_private_shares(fd)?)
-        }
-        TypePrefix::NonceRequest => Message::NonceRequest(consensus_deserialize_nonce_request(fd)?),
-        TypePrefix::NonceResponse => {
-            Message::NonceResponse(consensus_deserialize_nonce_response(fd)?)
-        }
-        TypePrefix::SignatureShareRequest => {
-            Message::SignatureShareRequest(consensus_deserialize_signature_share_request(fd)?)
-        }
-        TypePrefix::SignatureShareResponse => {
-            Message::SignatureShareResponse(consensus_deserialize_signature_share_response(fd)?)
-        }
-        _ => {
-            return Err(CodecError::DeserializeError(format!(
-                "Unknown packet type prefix: {}",
-                type_prefix_byte
-            )))
-        }
-    };
-    let sig: Vec<u8> = read_next(fd)?;
-    Ok(Packet { msg, sig })
+impl StacksMessageCodecExtensions for Packet {
+    fn inner_consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), CodecError> {
+        write_next(fd, &(TypePrefix::from(self) as u8))?;
+        self.msg.inner_consensus_serialize(fd)?;
+        write_next(fd, &self.sig)?;
+        Ok(())
+    }
+
+    fn inner_consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, CodecError> {
+        let type_prefix_byte = read_next::<u8, _>(fd)?;
+        let type_prefix = TypePrefix::try_from(type_prefix_byte)?;
+        let msg = match type_prefix {
+            TypePrefix::DkgBegin => Message::DkgBegin(DkgBegin::inner_consensus_deserialize(fd)?),
+            TypePrefix::DkgPrivateBegin => {
+                Message::DkgPrivateBegin(DkgPrivateBegin::inner_consensus_deserialize(fd)?)
+            }
+            TypePrefix::DkgEndBegin => {
+                Message::DkgEndBegin(DkgEndBegin::inner_consensus_deserialize(fd)?)
+            }
+            TypePrefix::DkgEnd => Message::DkgEnd(DkgEnd::inner_consensus_deserialize(fd)?),
+            TypePrefix::DkgPublicShares => {
+                Message::DkgPublicShares(DkgPublicShares::inner_consensus_deserialize(fd)?)
+            }
+            TypePrefix::DkgPrivateShares => {
+                Message::DkgPrivateShares(DkgPrivateShares::inner_consensus_deserialize(fd)?)
+            }
+            TypePrefix::NonceRequest => {
+                Message::NonceRequest(NonceRequest::inner_consensus_deserialize(fd)?)
+            }
+            TypePrefix::NonceResponse => {
+                Message::NonceResponse(NonceResponse::inner_consensus_deserialize(fd)?)
+            }
+            TypePrefix::SignatureShareRequest => Message::SignatureShareRequest(
+                SignatureShareRequest::inner_consensus_deserialize(fd)?,
+            ),
+            TypePrefix::SignatureShareResponse => Message::SignatureShareResponse(
+                SignatureShareResponse::inner_consensus_deserialize(fd)?,
+            ),
+            _ => {
+                return Err(CodecError::DeserializeError(format!(
+                    "Unknown packet type prefix: {}",
+                    type_prefix_byte
+                )))
+            }
+        };
+        let sig: Vec<u8> = read_next(fd)?;
+        Ok(Packet { msg, sig })
+    }
 }
 
 /// The response that a signer sends back to observing miners
@@ -885,7 +916,7 @@ mod test {
     use rand_core::OsRng;
     use wsts::common::Signature;
 
-    use super::*;
+    use super::{StacksMessageCodecExtensions, *};
     #[test]
     fn serde_reject_code() {
         let code = RejectCode::ValidationFailed(ValidateRejectCode::InvalidBlock);
@@ -961,17 +992,19 @@ mod test {
         let mut rng = OsRng;
         let scalar = Scalar::random(&mut rng);
         let mut serialized_scalar = vec![];
-        consensus_serialize_scalar(&mut serialized_scalar, &scalar)
+        scalar
+            .inner_consensus_serialize(&mut serialized_scalar)
             .expect("serialization to buffer failed.");
-        let deserialized_scalar = consensus_deserialize_scalar(&mut &serialized_scalar[..])
+        let deserialized_scalar = Scalar::inner_consensus_deserialize(&mut &serialized_scalar[..])
             .expect("Failed to deserialize Scalar");
         assert_eq!(scalar, deserialized_scalar);
 
         let point = Point::from(scalar);
         let mut serialized_point = vec![];
-        consensus_serialize_point(&mut serialized_point, &point)
+        point
+            .inner_consensus_serialize(&mut serialized_point)
             .expect("serialization to buffer failed.");
-        let deserialized_point = consensus_deserialize_point(&mut &serialized_point[..])
+        let deserialized_point = Point::inner_consensus_deserialize(&mut &serialized_point[..])
             .expect("Failed to deserialize Point");
         assert_eq!(point, deserialized_point);
     }
@@ -982,9 +1015,10 @@ mod test {
             sig: vec![1u8; 20],
         };
         let mut serialized_packet = vec![];
-        consensus_serialize_packet(&mut serialized_packet, &packet)
+        packet
+            .inner_consensus_serialize(&mut serialized_packet)
             .expect("serialization to buffer failed.");
-        let deserialized_packet = consensus_deserialize_packet(&mut &serialized_packet[..])
+        let deserialized_packet = Packet::inner_consensus_deserialize(&mut &serialized_packet[..])
             .expect("Failed to deserialize Packet");
         assert_eq!(packet, deserialized_packet);
     }
diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index 8300973247..6efe382aa6 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -1996,8 +1996,6 @@ pub struct MinerConfig {
     pub max_reorg_depth: u64,
     /// Amount of time while mining in nakamoto to wait for signers to respond to a proposed block
     pub wait_on_signers: Duration,
-    /// The number of rejections as a percentage for a block to receive from signers before proposing a new block
-    pub signer_rejection_threshold: usize,
 }
 
 impl Default for MinerConfig {
@@ -2028,7 +2026,6 @@ impl Default for MinerConfig {
             max_reorg_depth: 3,
             // TODO: update to a sane value based on stackerdb benchmarking
             wait_on_signers: Duration::from_millis(10_000),
-            signer_rejection_threshold: 30,
         }
     }
 }
@@ -2354,7 +2351,6 @@ pub struct MinerConfigFile {
     pub filter_origins: Option<String>,
     pub max_reorg_depth: Option<u64>,
     pub wait_on_signers_ms: Option<u64>,
-    pub signer_rection_threshold: Option<usize>,
 }
 
 impl MinerConfigFile {
@@ -2459,10 +2455,6 @@ impl MinerConfigFile {
                 .wait_on_signers_ms
                 .map(Duration::from_millis)
                 .unwrap_or(miner_default_config.wait_on_signers),
-            signer_rejection_threshold: self
-                .signer_rection_threshold
-                .map(|threshold| std::cmp::min(threshold, 100))
-                .unwrap_or(miner_default_config.signer_rejection_threshold),
         })
     }
 }
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index bd64f968e9..bd78df0491 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -191,8 +191,6 @@ impl BlockMinerThread {
             let tip = SortitionDB::get_canonical_burn_chain_tip(sort_db.conn())
                 .expect("FATAL: could not retrieve chain tip");
             if let Some(new_block) = new_block {
-                let signer_signature_hash = new_block.header.signer_signature_hash();
-
                 match NakamotoBlockBuilder::make_stackerdb_block_proposal(
                     &sort_db,
                     &tip,
@@ -283,8 +281,7 @@ impl BlockMinerThread {
             .map(|(id, _)| id as u32 * SIGNER_SLOTS_PER_USER + BLOCK_SLOT_ID)
             .collect::<Vec<u32>>();
         // If more than a threshold percentage of the signers reject the block, we should not wait any further
-        let rejection_threshold =
-            slot_ids.len() / 100 * self.config.miner.signer_rejection_threshold;
+        let rejection_threshold = slot_ids.len() / 10 * 7;
         let mut rejections = HashSet::new();
         let now = Instant::now();
         while now.elapsed() < self.config.miner.wait_on_signers {

From 7203da2da4b249baa1714fa5abab93670bd4b21c Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 26 Jan 2024 10:58:01 -0800
Subject: [PATCH 0600/1166] Add deserialization of RPCPeerInfoData and
 get_burn_block_height and update tests

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/stacks_client.rs | 88 +++++++++++++++--------
 stacks-signer/src/runloop.rs              |  6 +-
 2 files changed, 62 insertions(+), 32 deletions(-)

diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index 935b74cf97..a85179f80e 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -22,6 +22,7 @@ use blockstack_lib::chainstate::stacks::{
     TransactionSpendingCondition, TransactionVersion,
 };
 use blockstack_lib::net::api::callreadonly::CallReadOnlyResponse;
+use blockstack_lib::net::api::getinfo::RPCPeerInfoData;
 use blockstack_lib::net::api::getpoxinfo::RPCPoxInfoData;
 use blockstack_lib::net::api::postblock_proposal::NakamotoBlockProposal;
 use blockstack_lib::util_lib::boot::boot_code_id;
@@ -31,7 +32,9 @@ use slog::slog_debug;
 use stacks_common::codec::StacksMessageCodec;
 use stacks_common::consts::CHAIN_ID_MAINNET;
 use stacks_common::debug;
-use stacks_common::types::chainstate::{StacksAddress, StacksPrivateKey, StacksPublicKey};
+use stacks_common::types::chainstate::{
+    ConsensusHash, StacksAddress, StacksPrivateKey, StacksPublicKey,
+};
 use wsts::curve::point::{Compressed, Point};
 
 use crate::client::{retry_with_exponential_backoff, ClientError};
@@ -68,34 +71,15 @@ impl From<&Config> for StacksClient {
 
 impl StacksClient {
     /// Retrieve the stacks tip consensus hash from the stacks node
-    pub fn get_stacks_tip_consensus_hash(&self) -> Result<String, ClientError> {
-        let send_request = || {
-            self.stacks_node_client
-                .get(self.core_info_path())
-                .send()
-                .map_err(backoff::Error::transient)
-        };
-
-        let response = retry_with_exponential_backoff(send_request)?;
-        if !response.status().is_success() {
-            return Err(ClientError::RequestFailure(response.status()));
-        }
-
-        let json_response = response
-            .json::<serde_json::Value>()
-            .map_err(ClientError::ReqwestError)?;
-
-        let stacks_tip_consensus_hash = json_response
-            .get("stacks_tip_consensus_hash")
-            .and_then(|v| v.as_str())
-            .map(String::from)
-            .ok_or_else(|| {
-                ClientError::UnexpectedResponseFormat(
-                    "Missing or invalid 'stacks_tip_consensus_hash' field".to_string(),
-                )
-            })?;
+    pub fn get_stacks_tip_consensus_hash(&self) -> Result<ConsensusHash, ClientError> {
+        let peer_info = self.get_peer_info()?;
+        Ok(peer_info.stacks_tip_consensus_hash)
+    }
 
-        Ok(stacks_tip_consensus_hash)
+    /// Retrieve the burn tip height from the stacks node
+    pub fn get_burn_block_height(&self) -> Result<u64, ClientError> {
+        let peer_info = self.get_peer_info()?;
+        Ok(peer_info.burn_block_height)
     }
 
     /// Submit the block proposal to the stacks node. The block will be validated and returned via the HTTP endpoint for Block events.
@@ -137,6 +121,23 @@ impl StacksClient {
         self.parse_aggregate_public_key(&contract_response_hex)
     }
 
+    // Helper function to retrieve the peer info data from the stacks node
+    fn get_peer_info(&self) -> Result<RPCPeerInfoData, ClientError> {
+        debug!("Getting stacks node info...");
+        let send_request = || {
+            self.stacks_node_client
+                .get(self.core_info_path())
+                .send()
+                .map_err(backoff::Error::transient)
+        };
+        let response = retry_with_exponential_backoff(send_request)?;
+        if !response.status().is_success() {
+            return Err(ClientError::RequestFailure(response.status()));
+        }
+        let peer_info_data = response.json::<RPCPeerInfoData>()?;
+        Ok(peer_info_data)
+    }
+
     // Helper function to retrieve the pox data from the stacks node
     fn get_pox_data(&self) -> Result<RPCPoxInfoData, ClientError> {
         debug!("Getting pox data...");
@@ -639,9 +640,13 @@ pub(crate) mod tests {
         let h = spawn(move || config.client.get_stacks_tip_consensus_hash());
         write_response(
             config.mock_server,
-            b"HTTP/1.1 200 OK\n\n{\"stacks_tip_consensus_hash\": \"3b593b712f8310768bf16e58f378aea999b8aa3b\"}",
+            b"HTTP/1.1 200 OK\n\n{\"stacks_tip_consensus_hash\":\"64c8c3049ff6b939c65828e3168210e6bb32d880\",\"peer_version\":4207599113,\"pox_consensus\":\"64c8c3049ff6b939c65828e3168210e6bb32d880\",\"burn_block_height\":2575799,\"stable_pox_consensus\":\"72277bf9a3b115e13c0942825480d6cee0e9a0e8\",\"stable_burn_block_height\":2575792,\"server_version\":\"stacks-node d657bdd (feat/epoch-2.4:d657bdd, release build, linux [x86_64])\",\"network_id\":2147483648,\"parent_network_id\":118034699,\"stacks_tip_height\":145152,\"stacks_tip\":\"77219884fe434c0fa270d65592b4f082ab3e5d9922ac2bdaac34310aedc3d298\",\"genesis_chainstate_hash\":\"74237aa39aa50a83de11a4f53e9d3bb7d43461d1de9873f402e5453ae60bc59b\",\"unanchored_tip\":\"dde44222b6e6d81583b6b9c55db83e8716943ae9d0dc332fc39448ddd9b99dc2\",\"unanchored_seq\":0,\"exit_at_block_height\":null,\"node_public_key\":\"023c940136d5795d9dd82c0e87f4dd6a2a1db245444e7d70e34bb9605c3c3917b0\",\"node_public_key_hash\":\"e26cce8f6abe06b9fc81c3b11bcc821d2f1b8fd0\"}",
+        );
+        let consensus_hash = h.join().unwrap().expect("Failed to deserialize response");
+        assert_eq!(
+            consensus_hash.to_hex(),
+            "64c8c3049ff6b939c65828e3168210e6bb32d880"
         );
-        assert!(h.join().unwrap().is_ok());
     }
 
     #[test]
@@ -654,4 +659,27 @@ pub(crate) mod tests {
         );
         assert!(h.join().unwrap().is_err());
     }
+
+    #[test]
+    fn core_info_call_for_burn_block_height_should_succeed() {
+        let config = TestConfig::new();
+        let h = spawn(move || config.client.get_burn_block_height());
+        write_response(
+            config.mock_server,
+            b"HTTP/1.1 200 OK\n\n{\"burn_block_height\":2575799,\"peer_version\":4207599113,\"pox_consensus\":\"64c8c3049ff6b939c65828e3168210e6bb32d880\",\"stable_pox_consensus\":\"72277bf9a3b115e13c0942825480d6cee0e9a0e8\",\"stable_burn_block_height\":2575792,\"server_version\":\"stacks-node d657bdd (feat/epoch-2.4:d657bdd, release build, linux [x86_64])\",\"network_id\":2147483648,\"parent_network_id\":118034699,\"stacks_tip_height\":145152,\"stacks_tip\":\"77219884fe434c0fa270d65592b4f082ab3e5d9922ac2bdaac34310aedc3d298\",\"stacks_tip_consensus_hash\":\"64c8c3049ff6b939c65828e3168210e6bb32d880\",\"genesis_chainstate_hash\":\"74237aa39aa50a83de11a4f53e9d3bb7d43461d1de9873f402e5453ae60bc59b\",\"unanchored_tip\":\"dde44222b6e6d81583b6b9c55db83e8716943ae9d0dc332fc39448ddd9b99dc2\",\"unanchored_seq\":0,\"exit_at_block_height\":null,\"node_public_key\":\"023c940136d5795d9dd82c0e87f4dd6a2a1db245444e7d70e34bb9605c3c3917b0\",\"node_public_key_hash\":\"e26cce8f6abe06b9fc81c3b11bcc821d2f1b8fd0\"}",
+        );
+        let burn_block_height = h.join().unwrap().expect("Failed to deserialize response");
+        assert_eq!(burn_block_height, 2575799);
+    }
+
+    #[test]
+    fn core_info_call_for_burn_block_height_should_fail() {
+        let config = TestConfig::new();
+        let h = spawn(move || config.client.get_burn_block_height());
+        write_response(
+            config.mock_server,
+            b"HTTP/1.1 200 OK\n\n4e99f99bc4a05437abb8c7d0c306618f45b203196498e2ebe287f10497124958",
+        );
+        assert!(h.join().unwrap().is_err());
+    }
 }
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 740c84a79b..2e5e2b1ed0 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -880,14 +880,16 @@ mod tests {
         let bytes: Vec<u8> = rng.sample_iter(Standard).take(20).collect();
         bytes.iter().map(|b| format!("{:02x}", b)).collect()
     }
+
     fn mock_stacks_client_response(mock_server: TcpListener, random_consensus: bool) {
         let consensus_hash = match random_consensus {
             true => generate_random_consensus_hash(),
-            false => "static_hash_value".to_string(),
+            false => "64c8c3049ff6b939c65828e3168210e6bb32d880".to_string(),
         };
 
+        println!("{}", consensus_hash);
         let response = format!(
-            "HTTP/1.1 200 OK\n\n{{\"stacks_tip_consensus_hash\": \"{}\"}}",
+            "HTTP/1.1 200 OK\n\n{{\"stacks_tip_consensus_hash\":\"{}\",\"peer_version\":4207599113,\"pox_consensus\":\"64c8c3049ff6b939c65828e3168210e6bb32d880\",\"burn_block_height\":2575799,\"stable_pox_consensus\":\"72277bf9a3b115e13c0942825480d6cee0e9a0e8\",\"stable_burn_block_height\":2575792,\"server_version\":\"stacks-node d657bdd (feat/epoch-2.4:d657bdd, release build, linux [x86_64])\",\"network_id\":2147483648,\"parent_network_id\":118034699,\"stacks_tip_height\":145152,\"stacks_tip\":\"77219884fe434c0fa270d65592b4f082ab3e5d9922ac2bdaac34310aedc3d298\",\"genesis_chainstate_hash\":\"74237aa39aa50a83de11a4f53e9d3bb7d43461d1de9873f402e5453ae60bc59b\",\"unanchored_tip\":\"dde44222b6e6d81583b6b9c55db83e8716943ae9d0dc332fc39448ddd9b99dc2\",\"unanchored_seq\":0,\"exit_at_block_height\":null,\"node_public_key\":\"023c940136d5795d9dd82c0e87f4dd6a2a1db245444e7d70e34bb9605c3c3917b0\",\"node_public_key_hash\":\"e26cce8f6abe06b9fc81c3b11bcc821d2f1b8fd0\"}}",
             consensus_hash
         );
 

From 223de46bb25183c2f5273e5330eb91f5415cab0b Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 26 Jan 2024 11:09:15 -0800
Subject: [PATCH 0601/1166] Add helper function to check if stacks node is pre
 epoch 3.0 activation

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/stacks_client.rs | 23 +++++++++++++++++++----
 1 file changed, 19 insertions(+), 4 deletions(-)

diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index a85179f80e..0eeba3f270 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -21,6 +21,9 @@ use blockstack_lib::chainstate::stacks::{
     TransactionContractCall, TransactionPayload, TransactionPostConditionMode,
     TransactionSpendingCondition, TransactionVersion,
 };
+use blockstack_lib::core::{
+    BITCOIN_MAINNET_STACKS_30_BURN_HEIGHT, BITCOIN_TESTNET_STACKS_30_BURN_HEIGHT,
+};
 use blockstack_lib::net::api::callreadonly::CallReadOnlyResponse;
 use blockstack_lib::net::api::getinfo::RPCPeerInfoData;
 use blockstack_lib::net::api::getpoxinfo::RPCPoxInfoData;
@@ -76,10 +79,16 @@ impl StacksClient {
         Ok(peer_info.stacks_tip_consensus_hash)
     }
 
-    /// Retrieve the burn tip height from the stacks node
-    pub fn get_burn_block_height(&self) -> Result<u64, ClientError> {
-        let peer_info = self.get_peer_info()?;
-        Ok(peer_info.burn_block_height)
+    /// Determine if the stacks node is pre or post epoch 3.0 activation
+    pub fn is_pre_nakamoto(&self) -> Result<bool, ClientError> {
+        let is_mainnet = self.chain_id == CHAIN_ID_MAINNET;
+        let burn_block_height = self.get_burn_block_height()?;
+        let epoch_30_activation_height = if is_mainnet {
+            BITCOIN_MAINNET_STACKS_30_BURN_HEIGHT
+        } else {
+            BITCOIN_TESTNET_STACKS_30_BURN_HEIGHT
+        };
+        Ok(burn_block_height >= epoch_30_activation_height)
     }
 
     /// Submit the block proposal to the stacks node. The block will be validated and returned via the HTTP endpoint for Block events.
@@ -155,6 +164,12 @@ impl StacksClient {
         Ok(pox_info_data)
     }
 
+    /// Helper function to retrieve the burn tip height from the stacks node
+    fn get_burn_block_height(&self) -> Result<u64, ClientError> {
+        let peer_info = self.get_peer_info()?;
+        Ok(peer_info.burn_block_height)
+    }
+
     /// Helper function to retrieve the current reward cycle number from the stacks node
     fn get_current_reward_cycle(&self) -> Result<u64, ClientError> {
         let pox_data = self.get_pox_data()?;

From 8997b22729d322370b1db0310614c89da64a11ac Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 26 Jan 2024 12:19:23 -0800
Subject: [PATCH 0602/1166] Add SignerMessage::Transactions to event.rs and
 update rest of code

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 libsigner/src/libsigner.rs   |  1 +
 libsigner/src/messages.rs    | 83 ++++++++++++++++++++++++++++++------
 stacks-signer/src/runloop.rs |  2 +-
 3 files changed, 72 insertions(+), 14 deletions(-)

diff --git a/libsigner/src/libsigner.rs b/libsigner/src/libsigner.rs
index 16f7ec626b..c934d7afd2 100644
--- a/libsigner/src/libsigner.rs
+++ b/libsigner/src/libsigner.rs
@@ -49,6 +49,7 @@ pub use crate::events::{
 };
 pub use crate::messages::{
     BlockRejection, BlockResponse, RejectCode, SignerMessage, BLOCK_SLOT_ID, SIGNER_SLOTS_PER_USER,
+    TRANSACTIONS_SLOT_ID,
 };
 pub use crate::runloop::{RunningSigner, Signer, SignerRunLoop};
 pub use crate::session::{SignerSession, StackerDBSession};
diff --git a/libsigner/src/messages.rs b/libsigner/src/messages.rs
index bf2caa1f96..7b017fd499 100644
--- a/libsigner/src/messages.rs
+++ b/libsigner/src/messages.rs
@@ -56,7 +56,7 @@ use crate::EventError;
 /// Temporary placeholder for the number of slots allocated to a stacker-db writer. This will be retrieved from the stacker-db instance in the future
 /// See: https://github.com/stacks-network/stacks-blockchain/issues/3921
 /// Is equal to the number of message types
-pub const SIGNER_SLOTS_PER_USER: u32 = 11;
+pub const SIGNER_SLOTS_PER_USER: u32 = 12;
 
 // The slot IDS for each message type
 const DKG_BEGIN_SLOT_ID: u32 = 0;
@@ -71,22 +71,25 @@ const SIGNATURE_SHARE_REQUEST_SLOT_ID: u32 = 8;
 const SIGNATURE_SHARE_RESPONSE_SLOT_ID: u32 = 9;
 /// The slot ID for the block response for miners to observe
 pub const BLOCK_SLOT_ID: u32 = 10;
+/// The slot ID for the transactions list for miners and signers to observe
+pub const TRANSACTIONS_SLOT_ID: u32 = 11;
 
 define_u8_enum!(TypePrefix {
     BlockResponse = 0,
     Packet = 1,
-    DkgBegin = 2,
-    DkgPrivateBegin = 3,
-    DkgEndBegin = 4,
-    DkgEnd = 5,
-    DkgPublicShares = 6,
-    DkgPrivateShares = 7,
-    NonceRequest = 8,
-    NonceResponse = 9,
-    SignatureShareRequest = 10,
-    SignatureShareResponse = 11,
-    DkgStatusSuccess = 12,
-    DkgStatusFailure = 13
+    Transactions = 2,
+    DkgBegin = 3,
+    DkgPrivateBegin = 4,
+    DkgEndBegin = 5,
+    DkgEnd = 6,
+    DkgPublicShares = 7,
+    DkgPrivateShares = 8,
+    NonceRequest = 9,
+    NonceResponse = 10,
+    SignatureShareRequest = 11,
+    SignatureShareResponse = 12,
+    DkgStatusSuccess = 13,
+    DkgStatusFailure = 14
 });
 
 impl TryFrom<u8> for TypePrefix {
@@ -102,6 +105,7 @@ impl From<&SignerMessage> for TypePrefix {
         match message {
             SignerMessage::Packet(_) => TypePrefix::Packet,
             SignerMessage::BlockResponse(_) => TypePrefix::BlockResponse,
+            SignerMessage::Transactions(_) => TypePrefix::Transactions,
         }
     }
 }
@@ -130,6 +134,8 @@ pub enum SignerMessage {
     BlockResponse(BlockResponse),
     /// DKG and Signing round data for other signers to observe
     Packet(Packet),
+    /// The list of transactions for miners and signers to observe that this signer cares about
+    Transactions(Vec<StacksTransaction>),
 }
 
 impl StacksMessageCodec for SignerMessage {
@@ -142,6 +148,9 @@ impl StacksMessageCodec for SignerMessage {
             SignerMessage::BlockResponse(block_response) => {
                 write_next(fd, block_response)?;
             }
+            SignerMessage::Transactions(transactions) => {
+                write_next(fd, transactions)?;
+            }
         };
         Ok(())
     }
@@ -158,6 +167,10 @@ impl StacksMessageCodec for SignerMessage {
                 let block_response = read_next::<BlockResponse, _>(fd)?;
                 SignerMessage::BlockResponse(block_response)
             }
+            TypePrefix::Transactions => {
+                let transactions = read_next::<Vec<StacksTransaction>, _>(fd)?;
+                SignerMessage::Transactions(transactions)
+            }
             _ => {
                 return Err(CodecError::DeserializeError(format!(
                     "Unknown signer message type prefix: {}",
@@ -802,6 +815,10 @@ pub enum RejectCode {
     SignedRejection(ThresholdSignature),
     /// Insufficient signers agreed to sign the block
     InsufficientSigners(Vec<u32>),
+    /// Missing the following expected transactions
+    MissingTransactions(Vec<StacksTransaction>),
+    /// The block was rejected due to connectivity issues with the signer
+    ConnectivityIssues,
 }
 
 impl StacksMessageCodec for RejectCode {
@@ -819,6 +836,11 @@ impl StacksMessageCodec for RejectCode {
                 write_next(fd, &2u8)?;
                 write_next(fd, malicious_signers)?
             }
+            RejectCode::MissingTransactions(missing_transactions) => {
+                write_next(fd, &3u8)?;
+                write_next(fd, missing_transactions)?
+            }
+            RejectCode::ConnectivityIssues => write_next(fd, &4u8)?,
         };
         Ok(())
     }
@@ -859,6 +881,15 @@ impl std::fmt::Display for RejectCode {
                 "Insufficient signers agreed to sign the block. The following signers are malicious: {:?}",
                 malicious_signers
             ),
+            RejectCode::MissingTransactions(missing_transactions) => write!(
+                f,
+                "Missing the following expected transactions: {:?}",
+                missing_transactions.iter().map(|tx| tx.txid()).collect::<Vec<_>>()
+            ),
+            RejectCode::ConnectivityIssues => write!(
+                f,
+                "The block was rejected due to connectivity issues with the signer."
+            ),
         }
     }
 }
@@ -904,6 +935,7 @@ impl SignerMessage {
                 Message::SignatureShareResponse(_) => SIGNATURE_SHARE_RESPONSE_SLOT_ID,
             },
             Self::BlockResponse(_) => BLOCK_SLOT_ID,
+            Self::Transactions(_) => TRANSACTIONS_SLOT_ID,
         };
         SIGNER_SLOTS_PER_USER * id + slot_id
     }
@@ -912,8 +944,10 @@ impl SignerMessage {
 #[cfg(test)]
 mod test {
 
+    use blockstack_lib::{chainstate::stacks::{TransactionAnchorMode, TransactionAuth, TransactionPayload, TransactionPostConditionMode, TransactionSmartContract, TransactionVersion}, util_lib::strings::StacksString};
     use rand::Rng;
     use rand_core::OsRng;
+    use stacks_common::{consts::CHAIN_ID_TESTNET, types::chainstate::StacksPrivateKey};
     use wsts::common::Signature;
 
     use super::{StacksMessageCodecExtensions, *};
@@ -1225,5 +1259,28 @@ mod test {
             read_next::<SignerMessage, _>(&mut &serialized_signer_message[..])
                 .expect("Failed to deserialize SignerMessage");
         assert_eq!(signer_message, deserialized_signer_message);
+    
+        let sk = StacksPrivateKey::new();
+        let tx = StacksTransaction {
+            version: TransactionVersion::Testnet,
+            chain_id: CHAIN_ID_TESTNET,
+            auth: TransactionAuth::from_p2pkh(&sk).unwrap(),
+            anchor_mode: TransactionAnchorMode::Any,
+            post_condition_mode: TransactionPostConditionMode::Allow,
+            post_conditions: vec![],
+            payload: TransactionPayload::SmartContract(
+                TransactionSmartContract {
+                    name: "test-contract".into(),
+                    code_body: StacksString::from_str("(/ 1 0)").unwrap(),
+                },
+                None,
+            ),
+        };
+        let signer_message = SignerMessage::Transactions(vec![tx]);
+        let serialized_signer_message = signer_message.serialize_to_vec();
+        let deserialized_signer_message =
+            read_next::<SignerMessage, _>(&mut &serialized_signer_message[..])
+                .expect("Failed to deserialize SignerMessage");
+        assert_eq!(signer_message, deserialized_signer_message);
     }
 }
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 2e5e2b1ed0..d541f94438 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -329,7 +329,7 @@ impl<C: Coordinator> RunLoop<C> {
         let packets: Vec<Packet> = messages
             .into_iter()
             .filter_map(|msg| match msg {
-                SignerMessage::BlockResponse(_) => None,
+                SignerMessage::BlockResponse(_) | SignerMessage::Transactions(_) => None,
                 SignerMessage::Packet(packet) => {
                     self.verify_packet(packet, &coordinator_public_key)
                 }

From 1744375b4ef3c7331b89059e43758a9f8c0e19b8 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 26 Jan 2024 12:20:52 -0800
Subject: [PATCH 0603/1166] get stacks transactions from signers stackerdb slot

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/stackerdb.rs | 32 +++++++++++++++++++++++-
 stacks-signer/src/runloop.rs          | 36 +++++++++++++++++++++------
 2 files changed, 59 insertions(+), 9 deletions(-)

diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index 607f3b4b2f..3126e76153 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -1,3 +1,4 @@
+use blockstack_lib::chainstate::stacks::StacksTransaction;
 // Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
 // Copyright (C) 2020-2024 Stacks Open Internet Foundation
 //
@@ -15,7 +16,9 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 use clarity::vm::types::QualifiedContractIdentifier;
 use hashbrown::HashMap;
-use libsigner::{SignerMessage, SignerSession, StackerDBSession};
+use libsigner::{
+    SignerMessage, SignerSession, StackerDBSession, SIGNER_SLOTS_PER_USER, TRANSACTIONS_SLOT_ID,
+};
 use libstackerdb::{StackerDBChunkAckData, StackerDBChunkData};
 use slog::{slog_debug, slog_warn};
 use stacks_common::codec::StacksMessageCodec;
@@ -91,6 +94,33 @@ impl StackerDB {
         }
     }
 
+    /// Get the latest signer transactions from signer ids
+    // TODO: update to actually retry
+    pub fn get_signer_transactions(
+        &mut self,
+        signer_ids: &[u32],
+    ) -> Result<Vec<StacksTransaction>, ClientError> {
+        let slot_ids: Vec<_> = signer_ids
+            .iter()
+            .map(|id| id * SIGNER_SLOTS_PER_USER + TRANSACTIONS_SLOT_ID)
+            .collect();
+
+        let mut transactions = Vec::new();
+        let chunks = self
+            .signers_stackerdb_session
+            .get_latest_chunks(&slot_ids)?;
+        for chunk in chunks {
+            if let Some(data) = chunk {
+                let message: SignerMessage = bincode::deserialize(&data).unwrap();
+                if let SignerMessage::Transactions(chunk_transactions) = message {
+                    transactions.extend(chunk_transactions);
+                } else {
+                    warn!("Signer wrote an unexpected type to the transactions slot");
+                }
+            }
+        }
+        Ok(transactions)
+    }
     /// Retrieve the signer contract id
     pub fn signers_contract_id(&self) -> &QualifiedContractIdentifier {
         &self.signers_stackerdb_session.stackerdb_contract_id
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index d541f94438..3e749727eb 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -17,8 +17,8 @@ use std::collections::VecDeque;
 use std::sync::mpsc::Sender;
 use std::time::Duration;
 
-use blockstack_lib::burnchains::Txid;
 use blockstack_lib::chainstate::nakamoto::NakamotoBlock;
+use blockstack_lib::chainstate::stacks::StacksTransaction;
 use blockstack_lib::net::api::postblock_proposal::BlockValidateResponse;
 use hashbrown::{HashMap, HashSet};
 use libsigner::{
@@ -132,7 +132,7 @@ pub struct RunLoop<C> {
     pub blocks: HashMap<Sha512Trunc256Sum, BlockInfo>,
     /// Transactions that we expect to see in the next block
     // TODO: fill this in and do proper garbage collection
-    pub transactions: Vec<Txid>,
+    pub transactions: Vec<StacksTransaction>,
 }
 
 impl<C: Coordinator> RunLoop<C> {
@@ -251,7 +251,6 @@ impl<C: Coordinator> RunLoop<C> {
         block_validate_response: BlockValidateResponse,
         res: Sender<Vec<OperationResult>>,
     ) {
-        let transactions = &self.transactions;
         let block_info = match block_validate_response {
             BlockValidateResponse::Ok(block_validate_ok) => {
                 let Some(block_info) = self
@@ -291,7 +290,18 @@ impl<C: Coordinator> RunLoop<C> {
         if let Some(mut request) = block_info.nonce_request.take() {
             debug!("Received a block validate response from the stacks node for a block we already received a nonce request for. Responding to the nonce request...");
             // We have an associated nonce request. Respond to it
-            Self::determine_vote(block_info, &mut request, transactions);
+            let signer_ids: Vec<_> = self
+                .signing_round
+                .public_keys
+                .signers
+                .keys()
+                .cloned()
+                .collect();
+            let Ok(transactions) = self.stackerdb.get_signer_transactions(&signer_ids) else {
+                // Failed to connect to the stacks node to get transcations. Cannot validate the block.
+                return;
+            };
+            Self::determine_vote(block_info, &mut request, &transactions);
             // Send the nonce request through with our vote
             let packet = Packet {
                 msg: Message::NonceRequest(request),
@@ -442,7 +452,6 @@ impl<C: Coordinator> RunLoop<C> {
             debug!("Received a nonce request for an unknown message stream. Reject it.");
             return false;
         };
-        let transactions = &self.transactions;
         let signer_signature_hash = block.header.signer_signature_hash();
         let Some(block_info) = self.blocks.get_mut(&signer_signature_hash) else {
             // We have not seen this block before. Cache it. Send a RPC to the stacks node to validate it.
@@ -465,7 +474,18 @@ impl<C: Coordinator> RunLoop<C> {
             block_info.nonce_request = Some(request.clone());
             return false;
         }
-        Self::determine_vote(block_info, request, transactions);
+        let signer_ids: Vec<_> = self
+            .signing_round
+            .public_keys
+            .signers
+            .keys()
+            .cloned()
+            .collect();
+        let Ok(transactions) = self.stackerdb.get_signer_transactions(&signer_ids) else {
+            // Failed to connect to the stacks node to get transcations. Cannot validate the block.
+            return false;
+        };
+        Self::determine_vote(block_info, request, &transactions);
         true
     }
 
@@ -473,14 +493,14 @@ impl<C: Coordinator> RunLoop<C> {
     fn determine_vote(
         block_info: &mut BlockInfo,
         nonce_request: &mut NonceRequest,
-        transactions: &[Txid],
+        transactions: &[StacksTransaction],
     ) {
         let mut vote_bytes = block_info.block.header.signer_signature_hash().0.to_vec();
         // Validate the block contents
         if !block_info.valid.unwrap_or(false)
             || !transactions
                 .iter()
-                .all(|txid| block_info.block.txs.iter().any(|tx| &tx.txid() == txid))
+                .all(|transaction| block_info.block.txs.contains(transaction))
         {
             // We don't like this block. Update the request to be across its hash with a byte indicating a vote no.
             debug!("Updating the request with a block hash with a vote no.");

From f408e151ecacc4f6a726ffe44b1d01649887d1b7 Mon Sep 17 00:00:00 2001
From: Marzi <marzik@Marzis-MBP.fios-router.home>
Date: Fri, 26 Jan 2024 17:40:57 -0500
Subject: [PATCH 0604/1166] Update get_signer_transactions to retry

---
 stacks-signer/src/client/stackerdb.rs | 45 ++++++++++++++++-----------
 stacks-signer/src/runloop.rs          |  4 +--
 2 files changed, 29 insertions(+), 20 deletions(-)

diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index 3126e76153..631cbf203e 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -95,31 +95,40 @@ impl StackerDB {
     }
 
     /// Get the latest signer transactions from signer ids
-    // TODO: update to actually retry
-    pub fn get_signer_transactions(
+    pub fn get_signer_transactions_with_retry(
         &mut self,
         signer_ids: &[u32],
     ) -> Result<Vec<StacksTransaction>, ClientError> {
-        let slot_ids: Vec<_> = signer_ids
-            .iter()
-            .map(|id| id * SIGNER_SLOTS_PER_USER + TRANSACTIONS_SLOT_ID)
-            .collect();
+        loop {
+            let slot_ids: Vec<_> = signer_ids
+                .iter()
+                .map(|id| id * SIGNER_SLOTS_PER_USER + TRANSACTIONS_SLOT_ID)
+                .collect();
 
-        let mut transactions = Vec::new();
-        let chunks = self
-            .signers_stackerdb_session
-            .get_latest_chunks(&slot_ids)?;
-        for chunk in chunks {
-            if let Some(data) = chunk {
-                let message: SignerMessage = bincode::deserialize(&data).unwrap();
-                if let SignerMessage::Transactions(chunk_transactions) = message {
-                    transactions.extend(chunk_transactions);
-                } else {
-                    warn!("Signer wrote an unexpected type to the transactions slot");
+            let send_request = || {
+                     self.signers_stackerdb_session
+                    .get_latest_chunks(&slot_ids)
+                    .map_err(backoff::Error::transient)
+            };
+            let chunk_ack = retry_with_exponential_backoff(send_request)?;
+            let mut transactions = Vec::new();
+
+            if !chunk_ack.is_empty() {
+                for chunk in chunk_ack{
+                    if let Some(data) = chunk {
+                        let message: SignerMessage = bincode::deserialize(&data).unwrap();
+                        if let SignerMessage::Transactions(chunk_transactions) = message {
+                            transactions.extend(chunk_transactions);
+                        } else {
+                            warn!("Signer wrote an unexpected type to the transactions slot");
+                        }
+                    }
                 }
+                return Ok(transactions)
+            } else {
+                warn!("Recieved empty chuncks from stackerdb: {:?}", chunk_ack);
             }
         }
-        Ok(transactions)
     }
     /// Retrieve the signer contract id
     pub fn signers_contract_id(&self) -> &QualifiedContractIdentifier {
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 3e749727eb..5f0cddfa85 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -297,7 +297,7 @@ impl<C: Coordinator> RunLoop<C> {
                 .keys()
                 .cloned()
                 .collect();
-            let Ok(transactions) = self.stackerdb.get_signer_transactions(&signer_ids) else {
+            let Ok(transactions) = self.stackerdb.get_signer_transactions_with_retry(&signer_ids) else {
                 // Failed to connect to the stacks node to get transcations. Cannot validate the block.
                 return;
             };
@@ -481,7 +481,7 @@ impl<C: Coordinator> RunLoop<C> {
             .keys()
             .cloned()
             .collect();
-        let Ok(transactions) = self.stackerdb.get_signer_transactions(&signer_ids) else {
+        let Ok(transactions) = self.stackerdb.get_signer_transactions_with_retry(&signer_ids) else {
             // Failed to connect to the stacks node to get transcations. Cannot validate the block.
             return false;
         };

From 5f9418a23f1a64a99ca203da5380b32b6718da88 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 26 Jan 2024 14:43:47 -0800
Subject: [PATCH 0605/1166] Cargo fmt stuff

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/stackerdb.rs |  6 +++---
 stacks-signer/src/runloop.rs          | 10 ++++++++--
 2 files changed, 11 insertions(+), 5 deletions(-)

diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index 631cbf203e..1f859b137a 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -106,7 +106,7 @@ impl StackerDB {
                 .collect();
 
             let send_request = || {
-                     self.signers_stackerdb_session
+                self.signers_stackerdb_session
                     .get_latest_chunks(&slot_ids)
                     .map_err(backoff::Error::transient)
             };
@@ -114,7 +114,7 @@ impl StackerDB {
             let mut transactions = Vec::new();
 
             if !chunk_ack.is_empty() {
-                for chunk in chunk_ack{
+                for chunk in chunk_ack {
                     if let Some(data) = chunk {
                         let message: SignerMessage = bincode::deserialize(&data).unwrap();
                         if let SignerMessage::Transactions(chunk_transactions) = message {
@@ -124,7 +124,7 @@ impl StackerDB {
                         }
                     }
                 }
-                return Ok(transactions)
+                return Ok(transactions);
             } else {
                 warn!("Recieved empty chuncks from stackerdb: {:?}", chunk_ack);
             }
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 5f0cddfa85..e887b7890a 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -297,7 +297,10 @@ impl<C: Coordinator> RunLoop<C> {
                 .keys()
                 .cloned()
                 .collect();
-            let Ok(transactions) = self.stackerdb.get_signer_transactions_with_retry(&signer_ids) else {
+            let Ok(transactions) = self
+                .stackerdb
+                .get_signer_transactions_with_retry(&signer_ids)
+            else {
                 // Failed to connect to the stacks node to get transcations. Cannot validate the block.
                 return;
             };
@@ -481,7 +484,10 @@ impl<C: Coordinator> RunLoop<C> {
             .keys()
             .cloned()
             .collect();
-        let Ok(transactions) = self.stackerdb.get_signer_transactions_with_retry(&signer_ids) else {
+        let Ok(transactions) = self
+            .stackerdb
+            .get_signer_transactions_with_retry(&signer_ids)
+        else {
             // Failed to connect to the stacks node to get transcations. Cannot validate the block.
             return false;
         };

From 32bd01d1895e9ec8a01ae300650143a5cff2b3ef Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 26 Jan 2024 15:43:31 -0800
Subject: [PATCH 0606/1166] Remove unwrap in get_signer_transactions_with_retry

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/stackerdb.rs | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index 1f859b137a..2347082a56 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -116,11 +116,14 @@ impl StackerDB {
             if !chunk_ack.is_empty() {
                 for chunk in chunk_ack {
                     if let Some(data) = chunk {
-                        let message: SignerMessage = bincode::deserialize(&data).unwrap();
-                        if let SignerMessage::Transactions(chunk_transactions) = message {
-                            transactions.extend(chunk_transactions);
+                        if let Ok(message) = bincode::deserialize::<SignerMessage>(&data) {
+                            if let SignerMessage::Transactions(chunk_transactions) = message {
+                                transactions.extend(chunk_transactions);
+                            } else {
+                                warn!("Signer wrote an unexpected type to the transactions slot");
+                            }
                         } else {
-                            warn!("Signer wrote an unexpected type to the transactions slot");
+                            warn!("Failed to deserialize chunk data into a SignerMessage");
                         }
                     }
                 }

From 2afb1fb2e18186ecfa74f9105de082afd04e5342 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 26 Jan 2024 15:45:20 -0800
Subject: [PATCH 0607/1166] Add transaction verification function

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/config.rs  |  12 ++--
 stacks-signer/src/runloop.rs | 136 +++++++++++++++++------------------
 2 files changed, 74 insertions(+), 74 deletions(-)

diff --git a/stacks-signer/src/config.rs b/stacks-signer/src/config.rs
index dbc8e0abf4..8a9111ab97 100644
--- a/stacks-signer/src/config.rs
+++ b/stacks-signer/src/config.rs
@@ -124,6 +124,8 @@ pub struct Config {
     pub signer_key_ids: SignerKeyIds,
     /// This signer's ID
     pub signer_id: u32,
+    /// All signer IDs participating in the current reward cycle
+    pub signer_ids: Vec<u32>,
     /// The time to wait for a response from the stacker-db instance
     pub event_timeout: Duration,
     /// timeout to gather DkgPublicShares messages
@@ -266,6 +268,7 @@ impl TryFrom<RawConfigFile> for Config {
             &vec![stacks_public_key],
         )
         .ok_or(ConfigError::UnsupportedAddressVersion)?;
+        let mut signer_ids = vec![];
         let mut public_keys = PublicKeys::default();
         let mut signer_key_ids = SignerKeyIds::default();
         for (i, s) in raw_data.signers.iter().enumerate() {
@@ -283,10 +286,10 @@ impl TryFrom<RawConfigFile> for Config {
                 }
                 public_keys.key_ids.insert(*key_id, signer_public_key);
             }
-            //We start our signer and key IDs from 1 hence the + 1;
-            let signer_key = u32::try_from(i).unwrap();
-            public_keys.signers.insert(signer_key, signer_public_key);
-            signer_key_ids.insert(signer_key, s.key_ids.clone());
+            let signer_id = u32::try_from(i).unwrap();
+            public_keys.signers.insert(signer_id, signer_public_key);
+            signer_key_ids.insert(signer_id, s.key_ids.clone());
+            signer_ids.push(signer_id);
         }
         let event_timeout =
             Duration::from_millis(raw_data.event_timeout_ms.unwrap_or(EVENT_TIMEOUT_MS));
@@ -305,6 +308,7 @@ impl TryFrom<RawConfigFile> for Config {
             network: raw_data.network,
             signer_ids_public_keys: public_keys,
             signer_id: raw_data.signer_id,
+            signer_ids,
             signer_key_ids,
             event_timeout,
             dkg_end_timeout,
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index e887b7890a..937914634f 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -82,7 +82,7 @@ pub struct BlockInfo {
     /// The associated packet nonce request if we have one
     nonce_request: Option<NonceRequest>,
     /// Whether this block is already being signed over
-    signing_round: bool,
+    signed_over: bool,
 }
 
 impl BlockInfo {
@@ -93,7 +93,7 @@ impl BlockInfo {
             vote: None,
             valid: None,
             nonce_request: None,
-            signing_round: false,
+            signed_over: false,
         }
     }
 
@@ -104,7 +104,7 @@ impl BlockInfo {
             vote: None,
             valid: None,
             nonce_request: Some(nonce_request),
-            signing_round: true,
+            signed_over: true,
         }
     }
 }
@@ -133,6 +133,10 @@ pub struct RunLoop<C> {
     /// Transactions that we expect to see in the next block
     // TODO: fill this in and do proper garbage collection
     pub transactions: Vec<StacksTransaction>,
+    /// This signer's ID
+    pub signer_id: u32,
+    /// The IDs of all signers partipating in the current reward cycle
+    pub signer_ids: Vec<u32>,
 }
 
 impl<C: Coordinator> RunLoop<C> {
@@ -147,7 +151,7 @@ impl<C: Coordinator> RunLoop<C> {
             // Update the state to IDLE so we don't needlessy requeue the DKG command.
             let (coordinator_id, _) =
                 calculate_coordinator(&self.signing_round.public_keys, &self.stacks_client);
-            if coordinator_id == self.signing_round.signer_id
+            if coordinator_id == self.signer_id
                 && self.commands.front() != Some(&RunLoopCommand::Dkg)
             {
                 self.commands.push_front(RunLoopCommand::Dkg);
@@ -167,7 +171,7 @@ impl<C: Coordinator> RunLoop<C> {
                     Ok(msg) => {
                         let ack = self
                             .stackerdb
-                            .send_message_with_retry(self.signing_round.signer_id, msg.into());
+                            .send_message_with_retry(self.signer_id, msg.into());
                         debug!("ACK: {:?}", ack);
                         self.state = State::Dkg;
                         true
@@ -190,7 +194,7 @@ impl<C: Coordinator> RunLoop<C> {
                     .blocks
                     .entry(signer_signature_hash)
                     .or_insert_with(|| BlockInfo::new(block.clone()));
-                if block_info.signing_round {
+                if block_info.signed_over {
                     debug!("Received a sign command for a block we are already signing over. Ignore it.");
                     return false;
                 }
@@ -203,10 +207,10 @@ impl<C: Coordinator> RunLoop<C> {
                     Ok(msg) => {
                         let ack = self
                             .stackerdb
-                            .send_message_with_retry(self.signing_round.signer_id, msg.into());
+                            .send_message_with_retry(self.signer_id, msg.into());
                         debug!("ACK: {:?}", ack);
                         self.state = State::Sign;
-                        block_info.signing_round = true;
+                        block_info.signed_over = true;
                         true
                     }
                     Err(e) => {
@@ -253,15 +257,18 @@ impl<C: Coordinator> RunLoop<C> {
     ) {
         let block_info = match block_validate_response {
             BlockValidateResponse::Ok(block_validate_ok) => {
-                let Some(block_info) = self
-                    .blocks
-                    .get_mut(&block_validate_ok.signer_signature_hash)
-                else {
+                let signer_signature_hash = block_validate_ok.signer_signature_hash;
+                let Some(block_info) = self.blocks.get_mut(&signer_signature_hash) else {
                     // We have not seen this block before. Why are we getting a response for it?
                     debug!("Received a block validate response for a block we have not seen before. Ignoring...");
                     return;
                 };
-                block_info.valid = Some(true);
+                let are_transactions_verified = Self::verify_transactions(
+                    &mut self.stackerdb,
+                    &self.signer_ids,
+                    &block_info.block,
+                );
+                block_info.valid = Some(are_transactions_verified);
                 block_info
             }
             BlockValidateResponse::Reject(block_validate_reject) => {
@@ -277,37 +284,23 @@ impl<C: Coordinator> RunLoop<C> {
                 block_info.valid = Some(false);
                 // Submit a rejection response to the .signers contract for miners
                 // to observe so they know to send another block and to prove signers are doing work);
-                if let Err(e) = self.stackerdb.send_message_with_retry(
-                    self.signing_round.signer_id,
-                    block_validate_reject.into(),
-                ) {
+                if let Err(e) = self
+                    .stackerdb
+                    .send_message_with_retry(self.signer_id, block_validate_reject.into())
+                {
                     warn!("Failed to send block rejection to stacker-db: {:?}", e);
                 }
                 block_info
             }
         };
 
-        if let Some(mut request) = block_info.nonce_request.take() {
+        if let Some(mut nonce_request) = block_info.nonce_request.take() {
             debug!("Received a block validate response from the stacks node for a block we already received a nonce request for. Responding to the nonce request...");
-            // We have an associated nonce request. Respond to it
-            let signer_ids: Vec<_> = self
-                .signing_round
-                .public_keys
-                .signers
-                .keys()
-                .cloned()
-                .collect();
-            let Ok(transactions) = self
-                .stackerdb
-                .get_signer_transactions_with_retry(&signer_ids)
-            else {
-                // Failed to connect to the stacks node to get transcations. Cannot validate the block.
-                return;
-            };
-            Self::determine_vote(block_info, &mut request, &transactions);
+            // We have received validation from the stacks node. Determine our vote and update the request message
+            Self::determine_vote(block_info, &mut nonce_request);
             // Send the nonce request through with our vote
             let packet = Packet {
-                msg: Message::NonceRequest(request),
+                msg: Message::NonceRequest(nonce_request),
                 sig: vec![],
             };
             self.handle_packets(res, &[packet]);
@@ -315,8 +308,8 @@ impl<C: Coordinator> RunLoop<C> {
             let (coordinator_id, _) =
                 calculate_coordinator(&self.signing_round.public_keys, &self.stacks_client);
             if block_info.valid.unwrap_or(false)
-                && !block_info.signing_round
-                && coordinator_id == self.signing_round.signer_id
+                && !block_info.signed_over
+                && coordinator_id == self.signer_id
             {
                 debug!("Received a valid block proposal from the miner. Triggering a signing round over it...");
                 // We are the coordinator. Trigger a signing round for this block
@@ -449,8 +442,9 @@ impl<C: Coordinator> RunLoop<C> {
     /// If the request is for a block, we will update the request message
     /// as either a hash indicating a vote no or the signature hash indicating a vote yes
     /// Returns whether the request is valid or not
-    fn validate_nonce_request(&mut self, request: &mut NonceRequest) -> bool {
-        let Some(block) = read_next::<NakamotoBlock, _>(&mut &request.message[..]).ok() else {
+    fn validate_nonce_request(&mut self, nonce_request: &mut NonceRequest) -> bool {
+        let Some(block) = read_next::<NakamotoBlock, _>(&mut &nonce_request.message[..]).ok()
+        else {
             // We currently reject anything that is not a block
             debug!("Received a nonce request for an unknown message stream. Reject it.");
             return false;
@@ -462,7 +456,7 @@ impl<C: Coordinator> RunLoop<C> {
             // Store the block in our cache
             self.blocks.insert(
                 signer_signature_hash,
-                BlockInfo::new_with_request(block.clone(), request.clone()),
+                BlockInfo::new_with_request(block.clone(), nonce_request.clone()),
             );
             self.stacks_client
                 .submit_block_for_validation(block)
@@ -471,43 +465,43 @@ impl<C: Coordinator> RunLoop<C> {
                 });
             return false;
         };
+
         if block_info.valid.is_none() {
             // We have not yet received validation from the stacks node. Cache the request and wait for validation
             debug!("We have yet to receive validation from the stacks node for a nonce request. Cache the nonce request and wait for block validation...");
-            block_info.nonce_request = Some(request.clone());
+            block_info.nonce_request = Some(nonce_request.clone());
             return false;
         }
-        let signer_ids: Vec<_> = self
-            .signing_round
-            .public_keys
-            .signers
-            .keys()
-            .cloned()
-            .collect();
-        let Ok(transactions) = self
-            .stackerdb
-            .get_signer_transactions_with_retry(&signer_ids)
-        else {
-            // Failed to connect to the stacks node to get transcations. Cannot validate the block.
-            return false;
-        };
-        Self::determine_vote(block_info, request, &transactions);
+
+        Self::determine_vote(block_info, nonce_request);
         true
     }
 
+    /// Verify that the proposed block contains the transactions we expect
+    fn verify_transactions(
+        stackerdb: &mut StackerDB,
+        signer_ids: &[u32],
+        block: &NakamotoBlock,
+    ) -> bool {
+        if let Ok(transactions) = stackerdb.get_signer_transactions_with_retry(&signer_ids) {
+            // Ensure the block contains the transactions we expect
+            // Filter out transactions that are not special cased transactions
+            // Filter out transactions that have already been confirmed (can happen if a signer did not update stacker db since the last block was processed)
+            // TODO: broadcast to the node that we are missing the specific transactions as a hint
+            transactions
+                .iter()
+                .all(|transaction| block.txs.contains(transaction))
+        } else {
+            // Failed to connect to the stacks node to get transactions. Cannot validate the block.
+            false
+        }
+    }
+
     /// Determine the vote for a block and update the block info and nonce request accordingly
-    fn determine_vote(
-        block_info: &mut BlockInfo,
-        nonce_request: &mut NonceRequest,
-        transactions: &[StacksTransaction],
-    ) {
+    fn determine_vote(block_info: &mut BlockInfo, nonce_request: &mut NonceRequest) {
         let mut vote_bytes = block_info.block.header.signer_signature_hash().0.to_vec();
         // Validate the block contents
-        if !block_info.valid.unwrap_or(false)
-            || !transactions
-                .iter()
-                .all(|transaction| block_info.block.txs.contains(transaction))
-        {
+        if !block_info.valid.unwrap_or(false) {
             // We don't like this block. Update the request to be across its hash with a byte indicating a vote no.
             debug!("Updating the request with a block hash with a vote no.");
             vote_bytes.push(b'n');
@@ -622,7 +616,7 @@ impl<C: Coordinator> RunLoop<C> {
         // Submit signature result to miners to observe
         if let Err(e) = self
             .stackerdb
-            .send_message_with_retry(self.signing_round.signer_id, block_submission)
+            .send_message_with_retry(self.signer_id, block_submission)
         {
             warn!("Failed to send block submission to stacker-db: {:?}", e);
         }
@@ -664,7 +658,7 @@ impl<C: Coordinator> RunLoop<C> {
                 // Submit signature result to miners to observe
                 if let Err(e) = self
                     .stackerdb
-                    .send_message_with_retry(self.signing_round.signer_id, block_rejection.into())
+                    .send_message_with_retry(self.signer_id, block_rejection.into())
                 {
                     warn!("Failed to send block submission to stacker-db: {:?}", e);
                 }
@@ -702,7 +696,7 @@ impl<C: Coordinator> RunLoop<C> {
         for msg in outbound_messages {
             let ack = self
                 .stackerdb
-                .send_message_with_retry(self.signing_round.signer_id, msg.into());
+                .send_message_with_retry(self.signer_id, msg.into());
             if let Ok(ack) = ack {
                 debug!("ACK: {:?}", ack);
             } else {
@@ -783,6 +777,8 @@ impl From<&Config> for RunLoop<FireCoordinator<v2::Aggregator>> {
             mainnet: config.network == Network::Mainnet,
             blocks: HashMap::new(),
             transactions: Vec::new(),
+            signer_ids: config.signer_ids.clone(),
+            signer_id: config.signer_id,
         }
     }
 }
@@ -804,7 +800,7 @@ impl<C: Coordinator> SignerRunLoop<Vec<OperationResult>, RunLoopCommand> for Run
     ) -> Option<Vec<OperationResult>> {
         info!(
             "Running one pass for signer ID# {}. Current state: {:?}",
-            self.signing_round.signer_id, self.state
+            self.signer_id, self.state
         );
         if let Some(command) = cmd {
             self.commands.push_back(command);

From c4fb9fdecebc5248d64eceab262b1f40d6c012dc Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 26 Jan 2024 16:41:15 -0800
Subject: [PATCH 0608/1166] Broadcast missing transactions to the miner as a
 hint

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 libsigner/src/messages.rs             | 11 +++--
 stacks-signer/src/client/stackerdb.rs | 10 ++--
 stacks-signer/src/runloop.rs          | 66 +++++++++++++++++----------
 3 files changed, 57 insertions(+), 30 deletions(-)

diff --git a/libsigner/src/messages.rs b/libsigner/src/messages.rs
index 7b017fd499..e40970c59d 100644
--- a/libsigner/src/messages.rs
+++ b/libsigner/src/messages.rs
@@ -944,10 +944,15 @@ impl SignerMessage {
 #[cfg(test)]
 mod test {
 
-    use blockstack_lib::{chainstate::stacks::{TransactionAnchorMode, TransactionAuth, TransactionPayload, TransactionPostConditionMode, TransactionSmartContract, TransactionVersion}, util_lib::strings::StacksString};
+    use blockstack_lib::chainstate::stacks::{
+        TransactionAnchorMode, TransactionAuth, TransactionPayload, TransactionPostConditionMode,
+        TransactionSmartContract, TransactionVersion,
+    };
+    use blockstack_lib::util_lib::strings::StacksString;
     use rand::Rng;
     use rand_core::OsRng;
-    use stacks_common::{consts::CHAIN_ID_TESTNET, types::chainstate::StacksPrivateKey};
+    use stacks_common::consts::CHAIN_ID_TESTNET;
+    use stacks_common::types::chainstate::StacksPrivateKey;
     use wsts::common::Signature;
 
     use super::{StacksMessageCodecExtensions, *};
@@ -1259,7 +1264,7 @@ mod test {
             read_next::<SignerMessage, _>(&mut &serialized_signer_message[..])
                 .expect("Failed to deserialize SignerMessage");
         assert_eq!(signer_message, deserialized_signer_message);
-    
+
         let sk = StacksPrivateKey::new();
         let tx = StacksTransaction {
             version: TransactionVersion::Testnet,
diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index 2347082a56..f0c150ab33 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -21,7 +21,7 @@ use libsigner::{
 };
 use libstackerdb::{StackerDBChunkAckData, StackerDBChunkData};
 use slog::{slog_debug, slog_warn};
-use stacks_common::codec::StacksMessageCodec;
+use stacks_common::codec::{read_next, StacksMessageCodec};
 use stacks_common::types::chainstate::StacksPrivateKey;
 use stacks_common::{debug, warn};
 
@@ -37,6 +37,8 @@ pub struct StackerDB {
     stacks_private_key: StacksPrivateKey,
     /// A map of a slot ID to last chunk version
     slot_versions: HashMap<u32, u32>,
+    /// The signer ID
+    signer_id: u32,
 }
 
 impl From<&Config> for StackerDB {
@@ -48,6 +50,7 @@ impl From<&Config> for StackerDB {
             ),
             stacks_private_key: config.stacks_private_key,
             slot_versions: HashMap::new(),
+            signer_id: config.signer_id,
         }
     }
 }
@@ -56,11 +59,10 @@ impl StackerDB {
     /// Sends messages to the .signers stacker-db with an exponential backoff retry
     pub fn send_message_with_retry(
         &mut self,
-        id: u32,
         message: SignerMessage,
     ) -> Result<StackerDBChunkAckData, ClientError> {
         let message_bytes = message.serialize_to_vec();
-        let slot_id = message.slot_id(id);
+        let slot_id = message.slot_id(self.signer_id);
 
         loop {
             let slot_version = *self.slot_versions.entry(slot_id).or_insert(0) + 1;
@@ -116,7 +118,7 @@ impl StackerDB {
             if !chunk_ack.is_empty() {
                 for chunk in chunk_ack {
                     if let Some(data) = chunk {
-                        if let Ok(message) = bincode::deserialize::<SignerMessage>(&data) {
+                        if let Ok(message) = read_next::<SignerMessage, _>(&mut &data[..]) {
                             if let SignerMessage::Transactions(chunk_transactions) = message {
                                 transactions.extend(chunk_transactions);
                             } else {
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 937914634f..4ecd0775d0 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -169,9 +169,7 @@ impl<C: Coordinator> RunLoop<C> {
                 info!("Starting DKG");
                 match self.coordinator.start_dkg_round() {
                     Ok(msg) => {
-                        let ack = self
-                            .stackerdb
-                            .send_message_with_retry(self.signer_id, msg.into());
+                        let ack = self.stackerdb.send_message_with_retry(msg.into());
                         debug!("ACK: {:?}", ack);
                         self.state = State::Dkg;
                         true
@@ -205,9 +203,7 @@ impl<C: Coordinator> RunLoop<C> {
                     *merkle_root,
                 ) {
                     Ok(msg) => {
-                        let ack = self
-                            .stackerdb
-                            .send_message_with_retry(self.signer_id, msg.into());
+                        let ack = self.stackerdb.send_message_with_retry(msg.into());
                         debug!("ACK: {:?}", ack);
                         self.state = State::Sign;
                         block_info.signed_over = true;
@@ -284,9 +280,10 @@ impl<C: Coordinator> RunLoop<C> {
                 block_info.valid = Some(false);
                 // Submit a rejection response to the .signers contract for miners
                 // to observe so they know to send another block and to prove signers are doing work);
+                debug!("Broadcasting a block rejection due to stacks node validation failure...");
                 if let Err(e) = self
                     .stackerdb
-                    .send_message_with_retry(self.signer_id, block_validate_reject.into())
+                    .send_message_with_retry(block_validate_reject.into())
                 {
                     warn!("Failed to send block rejection to stacker-db: {:?}", e);
                 }
@@ -319,7 +316,7 @@ impl<C: Coordinator> RunLoop<C> {
                     merkle_root: None,
                 });
             } else {
-                debug!("Ignoring block proposal.");
+                debug!("Ignoring block proposal.\nValid: {:?}\nSigned Over: {:?}\nCoordinator ID: {:?}\nOur ID: {:?}", block_info.valid, block_info.signed_over, coordinator_id, self.signer_id);
             }
         }
     }
@@ -485,14 +482,42 @@ impl<C: Coordinator> RunLoop<C> {
     ) -> bool {
         if let Ok(transactions) = stackerdb.get_signer_transactions_with_retry(&signer_ids) {
             // Ensure the block contains the transactions we expect
-            // Filter out transactions that are not special cased transactions
-            // Filter out transactions that have already been confirmed (can happen if a signer did not update stacker db since the last block was processed)
-            // TODO: broadcast to the node that we are missing the specific transactions as a hint
-            transactions
-                .iter()
-                .all(|transaction| block.txs.contains(transaction))
+            // TODO: Filter out transactions that are not special cased transactions
+            // TODO: Filter out transactions that have already been confirmed (can happen if a signer did not update stacker db since the last block was processed)
+            let missing_transactions: Vec<_> = transactions
+                .into_iter()
+                .filter_map(|transaction| {
+                    if !block.txs.contains(&transaction) {
+                        Some(transaction)
+                    } else {
+                        None
+                    }
+                })
+                .collect();
+            let are_transactions_verified = missing_transactions.is_empty();
+            if !are_transactions_verified {
+                debug!("Broadcasting a block rejection due to missing expected transactions...");
+                let block_rejection = BlockRejection::new(
+                    block.header.signer_signature_hash(),
+                    RejectCode::MissingTransactions(missing_transactions),
+                );
+                // Submit signature result to miners to observe
+                if let Err(e) = stackerdb.send_message_with_retry(block_rejection.into()) {
+                    warn!("Failed to send block submission to stacker-db: {:?}", e);
+                }
+            }
+            are_transactions_verified
         } else {
-            // Failed to connect to the stacks node to get transactions. Cannot validate the block.
+            // Failed to connect to the stacks node to get transactions. Cannot validate the block. Reject it.
+            debug!("Broadcasting a block rejection due to signer connectivity issues...");
+            let block_rejection = BlockRejection::new(
+                block.header.signer_signature_hash(),
+                RejectCode::ConnectivityIssues,
+            );
+            // Submit signature result to miners to observe
+            if let Err(e) = stackerdb.send_message_with_retry(block_rejection.into()) {
+                warn!("Failed to send block submission to stacker-db: {:?}", e);
+            }
             false
         }
     }
@@ -614,10 +639,7 @@ impl<C: Coordinator> RunLoop<C> {
         };
 
         // Submit signature result to miners to observe
-        if let Err(e) = self
-            .stackerdb
-            .send_message_with_retry(self.signer_id, block_submission)
-        {
+        if let Err(e) = self.stackerdb.send_message_with_retry(block_submission) {
             warn!("Failed to send block submission to stacker-db: {:?}", e);
         }
     }
@@ -658,7 +680,7 @@ impl<C: Coordinator> RunLoop<C> {
                 // Submit signature result to miners to observe
                 if let Err(e) = self
                     .stackerdb
-                    .send_message_with_retry(self.signer_id, block_rejection.into())
+                    .send_message_with_retry(block_rejection.into())
                 {
                     warn!("Failed to send block submission to stacker-db: {:?}", e);
                 }
@@ -694,9 +716,7 @@ impl<C: Coordinator> RunLoop<C> {
             outbound_messages.len()
         );
         for msg in outbound_messages {
-            let ack = self
-                .stackerdb
-                .send_message_with_retry(self.signer_id, msg.into());
+            let ack = self.stackerdb.send_message_with_retry(msg.into());
             if let Ok(ack) = ack {
                 debug!("ACK: {:?}", ack);
             } else {

From e6c1c93aef8ddbb7a4d60fc7d194967a293d7bcd Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 26 Jan 2024 16:45:22 -0800
Subject: [PATCH 0609/1166] Broadcast expected transactions to the stackerdb
 instance for miners and signers to observe

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/runloop.rs            | 12 ++++++++++++
 testnet/stacks-node/src/tests/signer.rs |  2 +-
 2 files changed, 13 insertions(+), 1 deletion(-)

diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 4ecd0775d0..d243acbf3b 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -587,6 +587,18 @@ impl<C: Coordinator> RunLoop<C> {
                 }
                 OperationResult::Dkg(_point) => {
                     // TODO: cast the aggregate public key for the latest round here
+                    // Broadcast via traditional methods to the stacks node if we are pre nakamoto or we cannot determine our Epoch
+                    if self.stacks_client.is_pre_nakamoto().unwrap_or(false) {
+                        // We are in the pre-nakamoto phase. Broadcast the aggregate public key stx transaction to the stacks node via the mempool
+                    }
+                    // Always broadcast the transactions to stackerdb so miners and signers can observe it when building and validating the block, respectively.
+                    let signer_message = SignerMessage::Transactions(self.transactions.clone());
+                    if let Err(e) = self
+                        .stackerdb
+                        .send_message_with_retry(self.signing_round.signer_id, signer_message)
+                    {
+                        warn!("Failed to update transactions in stacker-db: {:?}", e);
+                    }
                 }
                 OperationResult::SignError(e) => {
                     self.process_sign_error(e);
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index 4caa6c8c92..8c19ab2adc 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -661,7 +661,7 @@ fn stackerdb_block_proposal() {
 
         let nakamoto_blocks = test_observer::get_stackerdb_chunks();
         for event in nakamoto_blocks {
-            // The tenth slot is the miners block slot
+            // Only care about the miners block slot
             for slot in event.modified_slots {
                 if slot.slot_id == BLOCK_SLOT_ID {
                     chunk = Some(slot.data);

From 119e2bfb6667df0ef945c75424636f3b7bd43529 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 26 Jan 2024 17:36:42 -0800
Subject: [PATCH 0610/1166] Add get signer transactions with retry unit test

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/mod.rs           | 48 ++++++++++++++++++
 stacks-signer/src/client/stackerdb.rs     | 60 +++++++++++++++++++++--
 stacks-signer/src/client/stacks_client.rs | 42 ++--------------
 stacks-signer/src/runloop.rs              |  2 +-
 4 files changed, 107 insertions(+), 45 deletions(-)

diff --git a/stacks-signer/src/client/mod.rs b/stacks-signer/src/client/mod.rs
index aae9edcea2..59f853b377 100644
--- a/stacks-signer/src/client/mod.rs
+++ b/stacks-signer/src/client/mod.rs
@@ -109,3 +109,51 @@ where
 
     backoff::retry_notify(backoff_timer, request_fn, notify).map_err(|_| ClientError::RetryTimeout)
 }
+
+#[cfg(test)]
+pub(crate) mod tests {
+    use std::io::{Read, Write};
+    use std::net::{SocketAddr, TcpListener};
+
+    use super::*;
+    use crate::config::Config;
+
+    pub(crate) struct TestConfig {
+        pub(crate) mock_server: TcpListener,
+        pub(crate) client: StacksClient,
+        pub(crate) stackerdb: StackerDB,
+    }
+
+    impl TestConfig {
+        pub(crate) fn new() -> Self {
+            let mut config = Config::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
+
+            let mut mock_server_addr = SocketAddr::from(([127, 0, 0, 1], 0));
+            // Ask the OS to assign a random port to listen on by passing 0
+            let mock_server = TcpListener::bind(mock_server_addr).unwrap();
+
+            // Update the config to use this port
+            mock_server_addr.set_port(mock_server.local_addr().unwrap().port());
+            config.node_host = mock_server_addr;
+
+            let client = StacksClient::from(&config);
+            let stackerdb = StackerDB::from(&config);
+            Self {
+                mock_server,
+                client,
+                stackerdb,
+            }
+        }
+    }
+
+    pub(crate) fn write_response(mock_server: TcpListener, bytes: &[u8]) -> [u8; 1024] {
+        debug!("Writing a response...");
+        let mut request_bytes = [0u8; 1024];
+        {
+            let mut stream = mock_server.accept().unwrap().0;
+            let _ = stream.read(&mut request_bytes).unwrap();
+            stream.write_all(bytes).unwrap();
+        }
+        request_bytes
+    }
+}
diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index f0c150ab33..37e1dec4cb 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -101,12 +101,11 @@ impl StackerDB {
         &mut self,
         signer_ids: &[u32],
     ) -> Result<Vec<StacksTransaction>, ClientError> {
+        let slot_ids: Vec<_> = signer_ids
+            .iter()
+            .map(|id| id * SIGNER_SLOTS_PER_USER + TRANSACTIONS_SLOT_ID)
+            .collect();
         loop {
-            let slot_ids: Vec<_> = signer_ids
-                .iter()
-                .map(|id| id * SIGNER_SLOTS_PER_USER + TRANSACTIONS_SLOT_ID)
-                .collect();
-
             let send_request = || {
                 self.signers_stackerdb_session
                     .get_latest_chunks(&slot_ids)
@@ -140,3 +139,54 @@ impl StackerDB {
         &self.signers_stackerdb_session.stackerdb_contract_id
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use std::thread::spawn;
+
+    use blockstack_lib::chainstate::stacks::{
+        TransactionAnchorMode, TransactionAuth, TransactionPayload, TransactionPostConditionMode,
+        TransactionSmartContract, TransactionVersion,
+    };
+    use blockstack_lib::util_lib::strings::StacksString;
+
+    use super::*;
+    use crate::client::tests::{write_response, TestConfig};
+
+    #[test]
+    fn get_signer_transactions_with_retry_should_succeed() {
+        let mut config = TestConfig::new();
+        let sk = StacksPrivateKey::new();
+        let tx = StacksTransaction {
+            version: TransactionVersion::Testnet,
+            chain_id: 0,
+            auth: TransactionAuth::from_p2pkh(&sk).unwrap(),
+            anchor_mode: TransactionAnchorMode::Any,
+            post_condition_mode: TransactionPostConditionMode::Allow,
+            post_conditions: vec![],
+            payload: TransactionPayload::SmartContract(
+                TransactionSmartContract {
+                    name: "test-contract".into(),
+                    code_body: StacksString::from_str("(/ 1 0)").unwrap(),
+                },
+                None,
+            ),
+        };
+
+        let signer_message = SignerMessage::Transactions(vec![tx.clone()]);
+        let message = bincode::serialize(&signer_message).unwrap();
+
+        let signer_ids = vec![0];
+        let h = spawn(move || {
+            config
+                .stackerdb
+                .get_signer_transactions_with_retry(&signer_ids)
+        });
+        let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
+        response_bytes.extend(message);
+        write_response(config.mock_server, response_bytes.as_slice());
+        let transactions = h.join().unwrap().unwrap();
+        assert_eq!(transactions.len(), 1);
+        assert_eq!(transactions[0], tx);
+    }
+}
diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index 0eeba3f270..f627f98483 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -369,50 +369,14 @@ impl StacksClient {
 }
 
 #[cfg(test)]
-pub(crate) mod tests {
-    use std::io::{BufWriter, Read, Write};
-    use std::net::{SocketAddr, TcpListener};
+mod tests {
+    use std::io::{BufWriter, Write};
     use std::thread::spawn;
 
     use super::*;
+    use crate::client::tests::{write_response, TestConfig};
     use crate::client::ClientError;
 
-    pub(crate) struct TestConfig {
-        pub(crate) mock_server: TcpListener,
-        pub(crate) client: StacksClient,
-    }
-
-    impl TestConfig {
-        pub(crate) fn new() -> Self {
-            let mut config = Config::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
-
-            let mut mock_server_addr = SocketAddr::from(([127, 0, 0, 1], 0));
-            // Ask the OS to assign a random port to listen on by passing 0
-            let mock_server = TcpListener::bind(mock_server_addr).unwrap();
-
-            // Update the config to use this port
-            mock_server_addr.set_port(mock_server.local_addr().unwrap().port());
-            config.node_host = mock_server_addr;
-
-            let client = StacksClient::from(&config);
-            Self {
-                mock_server,
-                client,
-            }
-        }
-    }
-
-    pub(crate) fn write_response(mock_server: TcpListener, bytes: &[u8]) -> [u8; 1024] {
-        debug!("Writing a response...");
-        let mut request_bytes = [0u8; 1024];
-        {
-            let mut stream = mock_server.accept().unwrap().0;
-            let _ = stream.read(&mut request_bytes).unwrap();
-            stream.write_all(bytes).unwrap();
-        }
-        request_bytes
-    }
-
     #[test]
     fn read_only_contract_call_200_success() {
         let config = TestConfig::new();
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index d243acbf3b..675e0fcb5b 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -927,7 +927,7 @@ mod tests {
     use rand::Rng;
 
     use super::*;
-    use crate::client::stacks_client::tests::{write_response, TestConfig};
+    use crate::client::tests::{write_response, TestConfig};
 
     fn generate_random_consensus_hash() -> String {
         let rng = rand::thread_rng();

From 517157a00b124970c0ab45ef51b92fe98d3d2cc1 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Mon, 29 Jan 2024 09:48:19 -0800
Subject: [PATCH 0611/1166] Add missing chnage to remove extra arg from send
 message with retry

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/runloop.rs | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 675e0fcb5b..851520ae17 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -593,10 +593,7 @@ impl<C: Coordinator> RunLoop<C> {
                     }
                     // Always broadcast the transactions to stackerdb so miners and signers can observe it when building and validating the block, respectively.
                     let signer_message = SignerMessage::Transactions(self.transactions.clone());
-                    if let Err(e) = self
-                        .stackerdb
-                        .send_message_with_retry(self.signing_round.signer_id, signer_message)
-                    {
+                    if let Err(e) = self.stackerdb.send_message_with_retry(signer_message) {
                         warn!("Failed to update transactions in stacker-db: {:?}", e);
                     }
                 }

From 8a75ba9ecd1d1e71a9095f8097f745162636773f Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Mon, 29 Jan 2024 12:13:19 -0800
Subject: [PATCH 0612/1166] Filter on only special cased transactions from
 valid signer ids when verifying transactions

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/stackerdb.rs     |   8 +-
 stacks-signer/src/client/stacks_client.rs |  58 +++++++++-
 stacks-signer/src/runloop.rs              | 131 ++++++++++++++++------
 3 files changed, 158 insertions(+), 39 deletions(-)

diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index 37e1dec4cb..3f779478f0 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -100,7 +100,7 @@ impl StackerDB {
     pub fn get_signer_transactions_with_retry(
         &mut self,
         signer_ids: &[u32],
-    ) -> Result<Vec<StacksTransaction>, ClientError> {
+    ) -> Result<Vec<(u32, Vec<StacksTransaction>)>, ClientError> {
         let slot_ids: Vec<_> = signer_ids
             .iter()
             .map(|id| id * SIGNER_SLOTS_PER_USER + TRANSACTIONS_SLOT_ID)
@@ -115,11 +115,11 @@ impl StackerDB {
             let mut transactions = Vec::new();
 
             if !chunk_ack.is_empty() {
-                for chunk in chunk_ack {
+                for (signer_id, chunk) in chunk_ack.iter().enumerate() {
                     if let Some(data) = chunk {
                         if let Ok(message) = read_next::<SignerMessage, _>(&mut &data[..]) {
                             if let SignerMessage::Transactions(chunk_transactions) = message {
-                                transactions.extend(chunk_transactions);
+                                transactions.push((signer_id as u32, chunk_transactions));
                             } else {
                                 warn!("Signer wrote an unexpected type to the transactions slot");
                             }
@@ -187,6 +187,6 @@ mod tests {
         write_response(config.mock_server, response_bytes.as_slice());
         let transactions = h.join().unwrap().unwrap();
         assert_eq!(transactions.len(), 1);
-        assert_eq!(transactions[0], tx);
+        assert_eq!(transactions[0], (0, vec![tx]));
     }
 }
diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index f627f98483..17aae54e96 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -25,6 +25,7 @@ use blockstack_lib::core::{
     BITCOIN_MAINNET_STACKS_30_BURN_HEIGHT, BITCOIN_TESTNET_STACKS_30_BURN_HEIGHT,
 };
 use blockstack_lib::net::api::callreadonly::CallReadOnlyResponse;
+use blockstack_lib::net::api::getaccount::AccountEntryResponse;
 use blockstack_lib::net::api::getinfo::RPCPeerInfoData;
 use blockstack_lib::net::api::getpoxinfo::RPCPoxInfoData;
 use blockstack_lib::net::api::postblock_proposal::NakamotoBlockProposal;
@@ -130,6 +131,12 @@ impl StacksClient {
         self.parse_aggregate_public_key(&contract_response_hex)
     }
 
+    /// Retrieve the current account nonce for the provided address
+    pub fn get_account_nonce(&self, address: &StacksAddress) -> Result<u64, ClientError> {
+        let account_entry = self.get_account_entry(address)?;
+        Ok(account_entry.nonce)
+    }
+
     // Helper function to retrieve the peer info data from the stacks node
     fn get_peer_info(&self) -> Result<RPCPeerInfoData, ClientError> {
         debug!("Getting stacks node info...");
@@ -183,6 +190,26 @@ impl StacksClient {
         todo!("Get the next possible nonce from the stacks node");
     }
 
+    /// Helper function to retrieve the account info from the stacks node for a specific address
+    fn get_account_entry(
+        &self,
+        address: &StacksAddress,
+    ) -> Result<AccountEntryResponse, ClientError> {
+        debug!("Getting account info...");
+        let send_request = || {
+            self.stacks_node_client
+                .get(self.accounts_path(address))
+                .send()
+                .map_err(backoff::Error::transient)
+        };
+        let response = retry_with_exponential_backoff(send_request)?;
+        if !response.status().is_success() {
+            return Err(ClientError::RequestFailure(response.status()));
+        }
+        let account_entry = response.json::<AccountEntryResponse>()?;
+        Ok(account_entry)
+    }
+
     /// Helper function that attempts to deserialize a clarity hex string as the aggregate public key
     fn parse_aggregate_public_key(&self, hex: &str) -> Result<Option<Point>, ClientError> {
         debug!("Parsing aggregate public key: {hex}...");
@@ -253,7 +280,7 @@ impl StacksClient {
         // https://github.com/stacks-network/stacks-blockchain/issues/4006
         // Note: if set to 0 now, will cause a failure (MemPoolRejection::FeeTooLow)
         unsigned_tx.set_tx_fee(10_000);
-        unsigned_tx.set_origin_nonce(self.get_next_possible_nonce()?);
+        unsigned_tx.set_origin_nonce(self.get_account_nonce(&self.stacks_address)?);
 
         unsigned_tx.anchor_mode = TransactionAnchorMode::Any;
         unsigned_tx.post_condition_mode = TransactionPostConditionMode::Allow;
@@ -366,6 +393,10 @@ impl StacksClient {
     fn core_info_path(&self) -> String {
         format!("{}/v2/info", self.http_origin)
     }
+
+    fn accounts_path(&self, stacks_address: &StacksAddress) -> String {
+        format!("{}/v2/accounts/{stacks_address}", self.http_origin)
+    }
 }
 
 #[cfg(test)]
@@ -661,4 +692,29 @@ mod tests {
         );
         assert!(h.join().unwrap().is_err());
     }
+
+    #[test]
+    fn get_account_nonce_should_succeed() {
+        let config = TestConfig::new();
+        let address = config.client.stacks_address;
+        let h = spawn(move || config.client.get_account_nonce(&address));
+        write_response(
+            config.mock_server,
+            b"HTTP/1.1 200 OK\n\n{\"nonce\":0,\"balance\":\"0x00000000000000000000000000000000\",\"locked\":\"0x00000000000000000000000000000000\",\"unlock_height\":0,\"balance_proof\":\"\",\"nonce_proof\":\"\"}"
+        );
+        let nonce = h.join().unwrap().expect("Failed to deserialize response");
+        assert_eq!(nonce, 0);
+    }
+
+    #[test]
+    fn get_account_nonce_should_fail() {
+        let config = TestConfig::new();
+        let address = config.client.stacks_address;
+        let h = spawn(move || config.client.get_account_nonce(&address));
+        write_response(
+            config.mock_server,
+            b"HTTP/1.1 200 OK\n\n{\"nonce\":\"invalid nonce\",\"balance\":\"0x00000000000000000000000000000000\",\"locked\":\"0x00000000000000000000000000000000\",\"unlock_height\":0,\"balance_proof\":\"\",\"nonce_proof\":\"\"}"
+        );
+        assert!(h.join().unwrap().is_err());
+    }
 }
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 851520ae17..4fe496aedc 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -25,7 +25,11 @@ use libsigner::{
     BlockRejection, BlockResponse, RejectCode, SignerEvent, SignerMessage, SignerRunLoop,
 };
 use slog::{slog_debug, slog_error, slog_info, slog_warn};
+use stacks_common::address::{
+    AddressHashMode, C32_ADDRESS_VERSION_MAINNET_SINGLESIG, C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
+};
 use stacks_common::codec::{read_next, StacksMessageCodec};
+use stacks_common::types::chainstate::{StacksAddress, StacksPublicKey};
 use stacks_common::util::hash::{Sha256Sum, Sha512Trunc256Sum};
 use stacks_common::{debug, error, info, warn};
 use wsts::common::{MerkleRoot, Signature};
@@ -254,25 +258,22 @@ impl<C: Coordinator> RunLoop<C> {
         let block_info = match block_validate_response {
             BlockValidateResponse::Ok(block_validate_ok) => {
                 let signer_signature_hash = block_validate_ok.signer_signature_hash;
-                let Some(block_info) = self.blocks.get_mut(&signer_signature_hash) else {
+                // For mutability reasons, we need to take the block_info out of the map and add it back after processing
+                let Some(mut block_info) = self.blocks.remove(&signer_signature_hash) else {
                     // We have not seen this block before. Why are we getting a response for it?
                     debug!("Received a block validate response for a block we have not seen before. Ignoring...");
                     return;
                 };
-                let are_transactions_verified = Self::verify_transactions(
-                    &mut self.stackerdb,
-                    &self.signer_ids,
-                    &block_info.block,
-                );
-                block_info.valid = Some(are_transactions_verified);
-                block_info
+                let is_valid = self.verify_transactions(&block_info.block);
+                block_info.valid = Some(is_valid);
+                // Add the block info back to the map
+                self.blocks
+                    .entry(signer_signature_hash)
+                    .or_insert(block_info)
             }
             BlockValidateResponse::Reject(block_validate_reject) => {
-                // There is no point in triggering a sign round for this block if validation failed from the stacks node
-                let Some(block_info) = self
-                    .blocks
-                    .get_mut(&block_validate_reject.signer_signature_hash)
-                else {
+                let signer_signature_hash = block_validate_reject.signer_signature_hash;
+                let Some(block_info) = self.blocks.get_mut(&signer_signature_hash) else {
                     // We have not seen this block before. Why are we getting a response for it?
                     debug!("Received a block validate response for a block we have not seen before. Ignoring...");
                     return;
@@ -308,15 +309,26 @@ impl<C: Coordinator> RunLoop<C> {
                 && !block_info.signed_over
                 && coordinator_id == self.signer_id
             {
-                debug!("Received a valid block proposal from the miner. Triggering a signing round over it...");
                 // We are the coordinator. Trigger a signing round for this block
+                debug!(
+                    "Signer triggering a signing round over the block.";
+                    "block_hash" => block_info.block.header.block_hash(),
+                    "signer_id" => self.signer_id,
+                );
                 self.commands.push_back(RunLoopCommand::Sign {
                     block: block_info.block.clone(),
                     is_taproot: false,
                     merkle_root: None,
                 });
             } else {
-                debug!("Ignoring block proposal.\nValid: {:?}\nSigned Over: {:?}\nCoordinator ID: {:?}\nOur ID: {:?}", block_info.valid, block_info.signed_over, coordinator_id, self.signer_id);
+                debug!(
+                    "Signer ignoring block.";
+                    "block_hash" => block_info.block.header.block_hash(),
+                    "valid" => block_info.valid,
+                    "signed_over" => block_info.signed_over,
+                    "coordinator_id" => coordinator_id,
+                    "signer_id" => self.signer_id,
+                );
             }
         }
     }
@@ -474,39 +486,36 @@ impl<C: Coordinator> RunLoop<C> {
         true
     }
 
-    /// Verify that the proposed block contains the transactions we expect
-    fn verify_transactions(
-        stackerdb: &mut StackerDB,
-        signer_ids: &[u32],
-        block: &NakamotoBlock,
-    ) -> bool {
-        if let Ok(transactions) = stackerdb.get_signer_transactions_with_retry(&signer_ids) {
+    /// Verify the transactions in a block are as expected
+    fn verify_transactions(&mut self, block: &NakamotoBlock) -> bool {
+        if let Ok(expected_transactions) = self.get_expected_transactions() {
             // Ensure the block contains the transactions we expect
-            // TODO: Filter out transactions that are not special cased transactions
-            // TODO: Filter out transactions that have already been confirmed (can happen if a signer did not update stacker db since the last block was processed)
-            let missing_transactions: Vec<_> = transactions
+            let missing_transactions = expected_transactions
                 .into_iter()
-                .filter_map(|transaction| {
-                    if !block.txs.contains(&transaction) {
-                        Some(transaction)
+                .filter_map(|tx| {
+                    if !block.txs.contains(&tx) {
+                        Some(tx)
                     } else {
                         None
                     }
                 })
-                .collect();
-            let are_transactions_verified = missing_transactions.is_empty();
-            if !are_transactions_verified {
+                .collect::<Vec<_>>();
+            let is_valid = missing_transactions.is_empty();
+            if !is_valid {
                 debug!("Broadcasting a block rejection due to missing expected transactions...");
                 let block_rejection = BlockRejection::new(
                     block.header.signer_signature_hash(),
                     RejectCode::MissingTransactions(missing_transactions),
                 );
                 // Submit signature result to miners to observe
-                if let Err(e) = stackerdb.send_message_with_retry(block_rejection.into()) {
+                if let Err(e) = self
+                    .stackerdb
+                    .send_message_with_retry(block_rejection.into())
+                {
                     warn!("Failed to send block submission to stacker-db: {:?}", e);
                 }
             }
-            are_transactions_verified
+            is_valid
         } else {
             // Failed to connect to the stacks node to get transactions. Cannot validate the block. Reject it.
             debug!("Broadcasting a block rejection due to signer connectivity issues...");
@@ -515,13 +524,67 @@ impl<C: Coordinator> RunLoop<C> {
                 RejectCode::ConnectivityIssues,
             );
             // Submit signature result to miners to observe
-            if let Err(e) = stackerdb.send_message_with_retry(block_rejection.into()) {
+            if let Err(e) = self
+                .stackerdb
+                .send_message_with_retry(block_rejection.into())
+            {
                 warn!("Failed to send block submission to stacker-db: {:?}", e);
             }
             false
         }
     }
 
+    /// Get the transactions we expect to see in the next block
+    fn get_expected_transactions(&mut self) -> Result<Vec<StacksTransaction>, ClientError> {
+        let signer_ids = self
+            .signing_round
+            .public_keys
+            .signers
+            .keys()
+            .into_iter()
+            .cloned()
+            .collect::<Vec<_>>();
+        let transactions = self
+            .stackerdb
+            .get_signer_transactions_with_retry(&signer_ids)?;
+        let mut expected_transactions = vec![];
+        for (signer_id, signer_transactions) in transactions {
+            let Some(public_key) = self.signing_round.public_keys.signers.get(&signer_id) else {
+                // Received a transaction for a signer we do not know about. Ignore it.
+                continue;
+            };
+            let version = if self.mainnet {
+                C32_ADDRESS_VERSION_MAINNET_SINGLESIG
+            } else {
+                C32_ADDRESS_VERSION_TESTNET_SINGLESIG
+            };
+            let stacks_public_key = StacksPublicKey::from_slice(public_key.to_bytes().as_slice()).expect("BUG: This should never fail as we only add valid public keys to the signing round.");
+            let stacks_address = StacksAddress::from_public_keys(
+                version,
+                &AddressHashMode::SerializeP2PKH,
+                1,
+                &vec![stacks_public_key],
+            ).expect("BUG: This should never fail as we only add valid public keys to the signing round.");
+            let Ok(account_nonce) = self.stacks_client.get_account_nonce(&stacks_address) else {
+                warn!("Unable to get account nonce for signer id {signer_id}. Ignoring their transactions.");
+                continue;
+            };
+            for signer_transaction in signer_transactions {
+                // TODO: Filter out transactions that are not special cased transactions (cast votes, etc.)
+                // Filter out transactions that have already been confirmed (can happen if a signer did not update stacker db since the last block was processed)
+                if signer_transaction.origin_address() != stacks_address
+                    || signer_transaction.get_origin_nonce() < account_nonce
+                {
+                    debug!("Received a transaction for signer id {signer_id} that is either not valid or has already been confirmed. Ignoring it.");
+                    continue;
+                } else {
+                    expected_transactions.push(signer_transaction);
+                }
+            }
+        }
+        Ok(expected_transactions)
+    }
+
     /// Determine the vote for a block and update the block info and nonce request accordingly
     fn determine_vote(block_info: &mut BlockInfo, nonce_request: &mut NonceRequest) {
         let mut vote_bytes = block_info.block.header.signer_signature_hash().0.to_vec();

From c9318fe5a36944f1602ba4350842de2566a398ad Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Tue, 30 Jan 2024 09:56:05 -0800
Subject: [PATCH 0613/1166] use stackerdb writers to verify transaction comes
 from expected sender and add a test

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/stackerdb.rs      |  61 ++++--
 stacks-signer/src/client/stacks_client.rs  |  54 +++++
 stacks-signer/src/config.rs                |  32 +--
 stacks-signer/src/main.rs                  |  24 +--
 stacks-signer/src/runloop.rs               |  37 ++--
 stacks-signer/src/tests/conf/signer-0.toml |  19 +-
 stacks-signer/src/tests/conf/signer-1.toml |  19 +-
 stacks-signer/src/tests/conf/signer-2.toml |  19 +-
 stacks-signer/src/tests/conf/signer-3.toml |  19 +-
 stacks-signer/src/tests/conf/signer-4.toml |  19 +-
 stacks-signer/src/utils.rs                 |  56 +++--
 testnet/stacks-node/src/tests/signer.rs    | 232 ++++++++++++++++++++-
 12 files changed, 438 insertions(+), 153 deletions(-)

diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index 3f779478f0..19720e012a 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -1,3 +1,5 @@
+use std::net::SocketAddr;
+
 use blockstack_lib::chainstate::stacks::StacksTransaction;
 // Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
 // Copyright (C) 2020-2024 Stacks Open Internet Foundation
@@ -56,6 +58,21 @@ impl From<&Config> for StackerDB {
 }
 
 impl StackerDB {
+    /// Create a new StackerDB client
+    pub fn new(
+        host: SocketAddr,
+        stackerdb_contract_id: QualifiedContractIdentifier,
+        stacks_private_key: StacksPrivateKey,
+        signer_id: u32,
+    ) -> Self {
+        Self {
+            signers_stackerdb_session: StackerDBSession::new(host, stackerdb_contract_id),
+            stacks_private_key,
+            slot_versions: HashMap::new(),
+            signer_id,
+        }
+    }
+
     /// Sends messages to the .signers stacker-db with an exponential backoff retry
     pub fn send_message_with_retry(
         &mut self,
@@ -68,7 +85,10 @@ impl StackerDB {
             let slot_version = *self.slot_versions.entry(slot_id).or_insert(0) + 1;
             let mut chunk = StackerDBChunkData::new(slot_id, slot_version, message_bytes.clone());
             chunk.sign(&self.stacks_private_key)?;
-            debug!("Sending a chunk to stackerdb!\n{:?}", &chunk);
+            debug!(
+                "Sending a chunk to stackerdb slot ID {slot_id} with version {slot_version}!\n{:?}",
+                &chunk
+            );
             let send_request = || {
                 self.signers_stackerdb_session
                     .put_chunk(&chunk)
@@ -86,7 +106,7 @@ impl StackerDB {
             if let Some(reason) = chunk_ack.reason {
                 // TODO: fix this jankiness. Update stackerdb to use an error code mapping instead of just a string
                 // See: https://github.com/stacks-network/stacks-blockchain/issues/3917
-                if reason == "Data for this slot and version already exist" {
+                if reason.contains("Data for this slot and version already exist") {
                     warn!("Failed to send message to stackerdb due to wrong version number {}. Incrementing and retrying...", slot_version);
                 } else {
                     warn!("Failed to send message to stackerdb: {}", reason);
@@ -105,6 +125,10 @@ impl StackerDB {
             .iter()
             .map(|id| id * SIGNER_SLOTS_PER_USER + TRANSACTIONS_SLOT_ID)
             .collect();
+        debug!(
+            "Getting latest chunks from stackerdb for the following signers: {:?}",
+            signer_ids
+        );
         loop {
             let send_request = || {
                 self.signers_stackerdb_session
@@ -113,25 +137,28 @@ impl StackerDB {
             };
             let chunk_ack = retry_with_exponential_backoff(send_request)?;
             let mut transactions = Vec::new();
-
-            if !chunk_ack.is_empty() {
-                for (signer_id, chunk) in chunk_ack.iter().enumerate() {
-                    if let Some(data) = chunk {
-                        if let Ok(message) = read_next::<SignerMessage, _>(&mut &data[..]) {
-                            if let SignerMessage::Transactions(chunk_transactions) = message {
-                                transactions.push((signer_id as u32, chunk_transactions));
-                            } else {
-                                warn!("Signer wrote an unexpected type to the transactions slot");
-                            }
+            for (i, chunk) in chunk_ack.iter().enumerate() {
+                if let Some(data) = chunk {
+                    if let Ok(message) = read_next::<SignerMessage, _>(&mut &data[..]) {
+                        if let SignerMessage::Transactions(chunk_transactions) = message {
+                            let signer_id = *signer_ids.get(i).expect(
+                                "BUG: retrieved an unequal amount of chunks to requested chunks",
+                            );
+                            debug!(
+                                "Retrieved {} transactions from signer ID {}.",
+                                chunk_transactions.len(),
+                                signer_id
+                            );
+                            transactions.push((signer_id, chunk_transactions));
                         } else {
-                            warn!("Failed to deserialize chunk data into a SignerMessage");
+                            warn!("Signer wrote an unexpected type to the transactions slot");
                         }
+                    } else {
+                        warn!("Failed to deserialize chunk data into a SignerMessage");
                     }
                 }
-                return Ok(transactions);
-            } else {
-                warn!("Recieved empty chuncks from stackerdb: {:?}", chunk_ack);
             }
+            return Ok(transactions);
         }
     }
     /// Retrieve the signer contract id
@@ -174,7 +201,7 @@ mod tests {
         };
 
         let signer_message = SignerMessage::Transactions(vec![tx.clone()]);
-        let message = bincode::serialize(&signer_message).unwrap();
+        let message = signer_message.serialize_to_vec();
 
         let signer_ids = vec![0];
         let h = spawn(move || {
diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index 17aae54e96..70e4a7b8d4 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -30,6 +30,7 @@ use blockstack_lib::net::api::getinfo::RPCPeerInfoData;
 use blockstack_lib::net::api::getpoxinfo::RPCPoxInfoData;
 use blockstack_lib::net::api::postblock_proposal::NakamotoBlockProposal;
 use blockstack_lib::util_lib::boot::boot_code_id;
+use clarity::vm::types::{PrincipalData, QualifiedContractIdentifier};
 use clarity::vm::{ClarityName, ContractName, Value as ClarityValue};
 use serde_json::json;
 use slog::slog_debug;
@@ -74,6 +75,23 @@ impl From<&Config> for StacksClient {
 }
 
 impl StacksClient {
+    /// Retrieve the signer slots stored within the stackerdb contract
+    pub fn get_stackerdb_signer_slots(
+        &self,
+        stackerdb_contract: &QualifiedContractIdentifier,
+    ) -> Result<Vec<(StacksAddress, u128)>, ClientError> {
+        let function_name_str = "stackerdb-get-signer-slots";
+        let function_name = ClarityName::try_from(function_name_str)
+            .map_err(|_| ClientError::InvalidClarityName(function_name_str.to_string()))?;
+        let function_args = &[];
+        let contract_response_hex = self.read_only_contract_call_with_retry(
+            &stackerdb_contract.issuer.clone().into(),
+            &stackerdb_contract.name,
+            &function_name,
+            function_args,
+        )?;
+        self.parse_signer_slots(&contract_response_hex)
+    }
     /// Retrieve the stacks tip consensus hash from the stacks node
     pub fn get_stacks_tip_consensus_hash(&self) -> Result<ConsensusHash, ClientError> {
         let peer_info = self.get_peer_info()?;
@@ -231,6 +249,28 @@ impl StacksClient {
         Ok(Some(point))
     }
 
+    /// Helper function  that attempts to deserialize a clarity hext string as a list of signer slots and their associated number of signer slots
+    fn parse_signer_slots(&self, hex: &str) -> Result<Vec<(StacksAddress, u128)>, ClientError> {
+        debug!("Parsing signer slots: {hex}...");
+        // Due to .signers definition, the  signer slots is always a result of a list of tuples of signer addresses and the number of slots they have
+        // If this fails, we have bigger problems than the signer crashing...
+        let value = ClarityValue::try_deserialize_hex_untyped(hex)?.expect_result_ok()?;
+        let values = value.expect_list()?;
+        let mut signer_slots = Vec::with_capacity(values.len());
+        for value in values {
+            let tuple_data = value.expect_tuple()?;
+            let principal_data = tuple_data.get("signer")?.clone().expect_principal()?;
+            let signer = if let PrincipalData::Standard(signer) = principal_data {
+                signer.into()
+            } else {
+                panic!("Invalid signer data type")
+            };
+            let num_slots = tuple_data.get("num-slots")?.clone().expect_u128()?;
+            signer_slots.push((signer, num_slots));
+        }
+        Ok(signer_slots)
+    }
+
     /// Sends a transaction to the stacks node for a modifying contract call
     #[allow(dead_code)]
     fn transaction_contract_call(
@@ -404,6 +444,8 @@ mod tests {
     use std::io::{BufWriter, Write};
     use std::thread::spawn;
 
+    use libsigner::SIGNER_SLOTS_PER_USER;
+
     use super::*;
     use crate::client::tests::{write_response, TestConfig};
     use crate::client::ClientError;
@@ -717,4 +759,16 @@ mod tests {
         );
         assert!(h.join().unwrap().is_err());
     }
+
+    #[test]
+    fn parse_valid_signer_slots_should_succeed() {
+        let config = TestConfig::new();
+        let clarity_value_hex =
+            "0x070b000000050c00000002096e756d2d736c6f7473010000000000000000000000000000000c067369676e6572051a8195196a9a7cf9c37cb13e1ed69a7bc047a84e050c00000002096e756d2d736c6f7473010000000000000000000000000000000c067369676e6572051a6505471146dcf722f0580911183f28bef30a8a890c00000002096e756d2d736c6f7473010000000000000000000000000000000c067369676e6572051a1d7f8e3936e5da5f32982cc47f31d7df9fb1b38a0c00000002096e756d2d736c6f7473010000000000000000000000000000000c067369676e6572051a126d1a814313c952e34c7840acec9211e1727fb80c00000002096e756d2d736c6f7473010000000000000000000000000000000c067369676e6572051a7374ea6bb39f2e8d3d334d62b9f302a977de339a";
+        let signer_slots = config.client.parse_signer_slots(clarity_value_hex).unwrap();
+        assert_eq!(signer_slots.len(), 5);
+        signer_slots
+            .into_iter()
+            .for_each(|(_address, slots)| assert!(slots == SIGNER_SLOTS_PER_USER as u128));
+    }
 }
diff --git a/stacks-signer/src/config.rs b/stacks-signer/src/config.rs
index 8a9111ab97..e5eb2fc4b2 100644
--- a/stacks-signer/src/config.rs
+++ b/stacks-signer/src/config.rs
@@ -30,6 +30,7 @@ use stacks_common::address::{
 };
 use stacks_common::consts::{CHAIN_ID_MAINNET, CHAIN_ID_TESTNET};
 use stacks_common::types::chainstate::{StacksAddress, StacksPrivateKey, StacksPublicKey};
+use stacks_common::types::PrivateKey;
 use wsts::curve::ecdsa;
 use wsts::curve::scalar::Scalar;
 use wsts::state_machine::PublicKeys;
@@ -68,6 +69,17 @@ pub enum Network {
     Mocknet,
 }
 
+impl std::fmt::Display for Network {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let network = match self {
+            Self::Mainnet => "mainnet",
+            Self::Testnet => "testnet",
+            Self::Mocknet => "mocknet",
+        };
+        write!(f, "{}", network)
+    }
+}
+
 impl Network {
     /// Converts a Network enum variant to a corresponding chain id
     pub fn to_chain_id(&self) -> u32 {
@@ -111,7 +123,7 @@ pub struct Config {
     /// smart contract that controls the target signers' stackerdb
     pub stackerdb_contract_id: QualifiedContractIdentifier,
     /// The Scalar representation of the private key for signer communication
-    pub message_private_key: Scalar,
+    pub ecdsa_private_key: Scalar,
     /// The signer's Stacks private key
     pub stacks_private_key: StacksPrivateKey,
     /// The signer's Stacks address
@@ -156,9 +168,6 @@ struct RawConfigFile {
     pub endpoint: String,
     /// Signers' Stacker db contract identifier
     pub stackerdb_contract_id: Option<String>,
-
-    /// the 32 byte ECDSA private key used to sign blocks, chunks, transactions, and WSTS messages
-    pub message_private_key: String,
     /// The hex representation of the signer's Stacks private key used for communicating
     /// with the Stacks Node, including writing to the Stacker DB instance.
     pub stacks_private_key: String,
@@ -245,16 +254,16 @@ impl TryFrom<RawConfigFile> for Config {
             None => boot_code_id("signers", raw_data.network == Network::Mainnet),
         };
 
-        let message_private_key =
-            Scalar::try_from(raw_data.message_private_key.as_str()).map_err(|_| {
+        let stacks_private_key =
+            StacksPrivateKey::from_hex(&raw_data.stacks_private_key).map_err(|_| {
                 ConfigError::BadField(
-                    "message_private_key".to_string(),
-                    raw_data.message_private_key.clone(),
+                    "stacks_private_key".to_string(),
+                    raw_data.stacks_private_key.clone(),
                 )
             })?;
 
-        let stacks_private_key =
-            StacksPrivateKey::from_hex(&raw_data.stacks_private_key).map_err(|_| {
+        let ecdsa_private_key =
+            Scalar::try_from(&stacks_private_key.to_bytes()[..32]).map_err(|_| {
                 ConfigError::BadField(
                     "stacks_private_key".to_string(),
                     raw_data.stacks_private_key.clone(),
@@ -302,7 +311,7 @@ impl TryFrom<RawConfigFile> for Config {
             node_host,
             endpoint,
             stackerdb_contract_id,
-            message_private_key,
+            ecdsa_private_key,
             stacks_private_key,
             stacks_address,
             network: raw_data.network,
@@ -353,7 +362,6 @@ mod tests {
             node_host: "127.0.0.1:20443".to_string(),
             endpoint: "127.0.0.1:30000".to_string(),
             stackerdb_contract_id: None,
-            message_private_key: "2ZCxUV9BAKJrGnTPaamKHb4HVgj9ArQgEhowuTe7uRt3".to_string(),
             stacks_private_key:
                 "69be0e68947fa7128702761151dc8d9b39ee1401e547781bb2ec3e5b4eb1b36f01".to_string(),
             network: Network::Testnet,
diff --git a/stacks-signer/src/main.rs b/stacks-signer/src/main.rs
index 99bfb31d01..8e0034d8f0 100644
--- a/stacks-signer/src/main.rs
+++ b/stacks-signer/src/main.rs
@@ -42,19 +42,16 @@ use libsigner::{
 };
 use libstackerdb::StackerDBChunkData;
 use slog::{slog_debug, slog_error};
-use stacks_common::address::{
-    AddressHashMode, C32_ADDRESS_VERSION_MAINNET_SINGLESIG, C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
-};
 use stacks_common::codec::read_next;
-use stacks_common::types::chainstate::{StacksAddress, StacksPrivateKey, StacksPublicKey};
+use stacks_common::types::chainstate::{StacksAddress, StacksPrivateKey};
 use stacks_common::{debug, error};
 use stacks_signer::cli::{
     Cli, Command, GenerateFilesArgs, GetChunkArgs, GetLatestChunkArgs, PutChunkArgs, RunDkgArgs,
     SignArgs, StackerDBArgs,
 };
-use stacks_signer::config::{Config, Network};
+use stacks_signer::config::Config;
 use stacks_signer::runloop::{RunLoop, RunLoopCommand};
-use stacks_signer::utils::{build_signer_config_tomls, build_stackerdb_contract};
+use stacks_signer::utils::{build_signer_config_tomls, build_stackerdb_contract, to_addr};
 use tracing_subscriber::prelude::*;
 use tracing_subscriber::{fmt, EnvFilter};
 use wsts::state_machine::coordinator::fire::Coordinator as FireCoordinator;
@@ -302,6 +299,7 @@ fn handle_generate_files(args: GenerateFilesArgs) {
         &args.host.to_string(),
         &args.signers_contract.to_string(),
         args.timeout.map(Duration::from_millis),
+        &args.network,
     );
     debug!("Built {:?} signer config tomls.", signer_config_tomls.len());
     for (i, file_contents) in signer_config_tomls.iter().enumerate() {
@@ -357,19 +355,5 @@ fn main() {
     }
 }
 
-fn to_addr(stacks_private_key: &StacksPrivateKey, network: &Network) -> StacksAddress {
-    let version = match network {
-        Network::Mainnet => C32_ADDRESS_VERSION_MAINNET_SINGLESIG,
-        Network::Testnet | Network::Mocknet => C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
-    };
-    StacksAddress::from_public_keys(
-        version,
-        &AddressHashMode::SerializeP2PKH,
-        1,
-        &vec![StacksPublicKey::from_private(stacks_private_key)],
-    )
-    .unwrap()
-}
-
 #[cfg(test)]
 pub mod tests;
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 4fe496aedc..2d27640f6c 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -25,11 +25,8 @@ use libsigner::{
     BlockRejection, BlockResponse, RejectCode, SignerEvent, SignerMessage, SignerRunLoop,
 };
 use slog::{slog_debug, slog_error, slog_info, slog_warn};
-use stacks_common::address::{
-    AddressHashMode, C32_ADDRESS_VERSION_MAINNET_SINGLESIG, C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
-};
 use stacks_common::codec::{read_next, StacksMessageCodec};
-use stacks_common::types::chainstate::{StacksAddress, StacksPublicKey};
+use stacks_common::types::chainstate::StacksAddress;
 use stacks_common::util::hash::{Sha256Sum, Sha512Trunc256Sum};
 use stacks_common::{debug, error, info, warn};
 use wsts::common::{MerkleRoot, Signature};
@@ -141,6 +138,8 @@ pub struct RunLoop<C> {
     pub signer_id: u32,
     /// The IDs of all signers partipating in the current reward cycle
     pub signer_ids: Vec<u32>,
+    /// The stacks addresses of the signers participating in the current reward cycle
+    pub signer_addresses: Vec<StacksAddress>,
 }
 
 impl<C: Coordinator> RunLoop<C> {
@@ -161,6 +160,13 @@ impl<C: Coordinator> RunLoop<C> {
                 self.commands.push_front(RunLoopCommand::Dkg);
             }
         }
+        // Get the signer writers from the stacker-db to verify transactions against
+        self.signer_addresses = self
+            .stacks_client
+            .get_stackerdb_signer_slots(self.stackerdb.signers_contract_id())?
+            .into_iter()
+            .map(|(address, _)| address)
+            .collect();
         self.state = State::Idle;
         Ok(())
     }
@@ -549,30 +555,18 @@ impl<C: Coordinator> RunLoop<C> {
             .get_signer_transactions_with_retry(&signer_ids)?;
         let mut expected_transactions = vec![];
         for (signer_id, signer_transactions) in transactions {
-            let Some(public_key) = self.signing_round.public_keys.signers.get(&signer_id) else {
+            let Some(stacks_address) = self.signer_addresses.get(signer_id as usize) else {
                 // Received a transaction for a signer we do not know about. Ignore it.
                 continue;
             };
-            let version = if self.mainnet {
-                C32_ADDRESS_VERSION_MAINNET_SINGLESIG
-            } else {
-                C32_ADDRESS_VERSION_TESTNET_SINGLESIG
-            };
-            let stacks_public_key = StacksPublicKey::from_slice(public_key.to_bytes().as_slice()).expect("BUG: This should never fail as we only add valid public keys to the signing round.");
-            let stacks_address = StacksAddress::from_public_keys(
-                version,
-                &AddressHashMode::SerializeP2PKH,
-                1,
-                &vec![stacks_public_key],
-            ).expect("BUG: This should never fail as we only add valid public keys to the signing round.");
-            let Ok(account_nonce) = self.stacks_client.get_account_nonce(&stacks_address) else {
+            let Ok(account_nonce) = self.stacks_client.get_account_nonce(stacks_address) else {
                 warn!("Unable to get account nonce for signer id {signer_id}. Ignoring their transactions.");
                 continue;
             };
             for signer_transaction in signer_transactions {
                 // TODO: Filter out transactions that are not special cased transactions (cast votes, etc.)
                 // Filter out transactions that have already been confirmed (can happen if a signer did not update stacker db since the last block was processed)
-                if signer_transaction.origin_address() != stacks_address
+                if signer_transaction.origin_address() != *stacks_address
                     || signer_transaction.get_origin_nonce() < account_nonce
                 {
                     debug!("Received a transaction for signer id {signer_id} that is either not valid or has already been confirmed. Ignoring it.");
@@ -838,7 +832,7 @@ impl From<&Config> for RunLoop<FireCoordinator<v2::Aggregator>> {
             dkg_threshold,
             num_signers: total_signers,
             num_keys: total_keys,
-            message_private_key: config.message_private_key,
+            message_private_key: config.ecdsa_private_key,
             dkg_public_timeout: config.dkg_public_timeout,
             dkg_private_timeout: config.dkg_private_timeout,
             dkg_end_timeout: config.dkg_end_timeout,
@@ -853,7 +847,7 @@ impl From<&Config> for RunLoop<FireCoordinator<v2::Aggregator>> {
             total_keys,
             config.signer_id,
             key_ids,
-            config.message_private_key,
+            config.ecdsa_private_key,
             config.signer_ids_public_keys.clone(),
         );
         let stacks_client = StacksClient::from(config);
@@ -871,6 +865,7 @@ impl From<&Config> for RunLoop<FireCoordinator<v2::Aggregator>> {
             transactions: Vec::new(),
             signer_ids: config.signer_ids.clone(),
             signer_id: config.signer_id,
+            signer_addresses: vec![],
         }
     }
 }
diff --git a/stacks-signer/src/tests/conf/signer-0.toml b/stacks-signer/src/tests/conf/signer-0.toml
index ee510d563e..86d79c9490 100644
--- a/stacks-signer/src/tests/conf/signer-0.toml
+++ b/stacks-signer/src/tests/conf/signer-0.toml
@@ -1,19 +1,14 @@
 
-message_private_key = "2ZCxUV9BAKJrGnTPaamKHb4HVgj9ArQgEhowuTe7uRt3"
-stacks_private_key = "69be0e68947fa7128702761151dc8d9b39ee1401e547781bb2ec3e5b4eb1b36f01"
+stacks_private_key = "6a1fc1a3183018c6d79a4e11e154d2bdad2d89ac8bc1b0a021de8b4d28774fbb01"
 node_host = "127.0.0.1:20443"
 endpoint = "localhost:30000"
 network = "testnet"
 stackerdb_contract_id = "ST11Z60137Y96MF89K1KKRTA3CR6B25WY1Y931668.signers-stackerdb"
 signer_id = 0
 signers = [
-            {public_key = "swBaKxfzs4pQne7spxhrkF6AtB34WEcreAkJ8mPcqx3t", key_ids = [1, 2, 3, 4]}
-        ,
-            {public_key = "yDJhntuJczbss1XGDmyWtG9Wpw5NDqoBBnedxmyhKiFN", key_ids = [5, 6, 7, 8]}
-        ,
-            {public_key = "xNVCph6zd7HLLJcuwrWz1gNbFoPHjXxn7cyRvvTYhP3U", key_ids = [9, 10, 11, 12]}
-        ,
-            {public_key = "p2wFfLEbwGCmxCR5eGa46Ct6i3BVjFrvBixRn7FnCQjA", key_ids = [13, 14, 15, 16]}
-        ,
-            {public_key = "26jpUNnJPvzDJRJg3hfBn5s5MR4eQ4LLTokjrSDzByh4i", key_ids = [17, 18, 19, 20]}
-        ]
+    {public_key = "27MvzC7LYTFfjBQdZropBqzWSKQYgFVHWh3YXchYrh5Ug", key_ids = [1, 2, 3, 4]},
+    {public_key = "f1Y6JdedrZyaZLnScbXbc1A7DhdLMjCipKCxkKUA93YQ", key_ids = [5, 6, 7, 8]},
+    {public_key = "nKPew4JetMvV97EghsdikNMhgyYF37ZeNvmJNSJueyjQ", key_ids = [9, 10, 11, 12]},
+    {public_key = "x3LcNnYgKKFBUaf9fZTEGHghFCQQyd6F9XNWj7nRXLt7", key_ids = [13, 14, 15, 16]},
+    {public_key = "nUVH972kFxpKbD62muCb9L48nTKqNw11yp3vFM9VDzqw", key_ids = [17, 18, 19, 20]}
+]
diff --git a/stacks-signer/src/tests/conf/signer-1.toml b/stacks-signer/src/tests/conf/signer-1.toml
index 73d5cb6a69..114c25ed23 100644
--- a/stacks-signer/src/tests/conf/signer-1.toml
+++ b/stacks-signer/src/tests/conf/signer-1.toml
@@ -1,19 +1,14 @@
 
-message_private_key = "vZTMaCTufQ9YtZPUcqqKRgbxWWkLTxU5iySooPw81D1"
-stacks_private_key = "fd5a538e8548e9d6a4a4060a43d0142356df022a4b8fd8ed4a7d0663825f8d2c01"
+stacks_private_key = "126e916e77359ccf521e168feea1fcb9626c59dc375cae00c7464303381c7dff01"
 node_host = "127.0.0.1:20443"
 endpoint = "localhost:30001"
 network = "testnet"
 stackerdb_contract_id = "ST11Z60137Y96MF89K1KKRTA3CR6B25WY1Y931668.signers-stackerdb"
 signer_id = 1
 signers = [
-            {public_key = "swBaKxfzs4pQne7spxhrkF6AtB34WEcreAkJ8mPcqx3t", key_ids = [1, 2, 3, 4]}
-        ,
-            {public_key = "yDJhntuJczbss1XGDmyWtG9Wpw5NDqoBBnedxmyhKiFN", key_ids = [5, 6, 7, 8]}
-        ,
-            {public_key = "xNVCph6zd7HLLJcuwrWz1gNbFoPHjXxn7cyRvvTYhP3U", key_ids = [9, 10, 11, 12]}
-        ,
-            {public_key = "p2wFfLEbwGCmxCR5eGa46Ct6i3BVjFrvBixRn7FnCQjA", key_ids = [13, 14, 15, 16]}
-        ,
-            {public_key = "26jpUNnJPvzDJRJg3hfBn5s5MR4eQ4LLTokjrSDzByh4i", key_ids = [17, 18, 19, 20]}
-        ]
+    {public_key = "27MvzC7LYTFfjBQdZropBqzWSKQYgFVHWh3YXchYrh5Ug", key_ids = [1, 2, 3, 4]},
+    {public_key = "f1Y6JdedrZyaZLnScbXbc1A7DhdLMjCipKCxkKUA93YQ", key_ids = [5, 6, 7, 8]},
+    {public_key = "nKPew4JetMvV97EghsdikNMhgyYF37ZeNvmJNSJueyjQ", key_ids = [9, 10, 11, 12]},
+    {public_key = "x3LcNnYgKKFBUaf9fZTEGHghFCQQyd6F9XNWj7nRXLt7", key_ids = [13, 14, 15, 16]},
+    {public_key = "nUVH972kFxpKbD62muCb9L48nTKqNw11yp3vFM9VDzqw", key_ids = [17, 18, 19, 20]}
+]
diff --git a/stacks-signer/src/tests/conf/signer-2.toml b/stacks-signer/src/tests/conf/signer-2.toml
index 7ff263940d..d37072f4e9 100644
--- a/stacks-signer/src/tests/conf/signer-2.toml
+++ b/stacks-signer/src/tests/conf/signer-2.toml
@@ -1,19 +1,14 @@
 
-message_private_key = "BZNqcMp82XykQ2z6NLc2h5cTJpPcLQ9AuKVtG4Ut7FY3"
-stacks_private_key = "74e8e8550a5210b89461128c600e4bf611d1553e6809308bc012dbb0fbb4818d01"
+stacks_private_key = "b169d0d1408f66d16beb321857f525f9014dfc289f1aeedbcf96e78afeb8eb4001"
 node_host = "127.0.0.1:20443"
 endpoint = "localhost:30002"
 network = "testnet"
 stackerdb_contract_id = "ST11Z60137Y96MF89K1KKRTA3CR6B25WY1Y931668.signers-stackerdb"
 signer_id = 2
 signers = [
-            {public_key = "swBaKxfzs4pQne7spxhrkF6AtB34WEcreAkJ8mPcqx3t", key_ids = [1, 2, 3, 4]}
-        ,
-            {public_key = "yDJhntuJczbss1XGDmyWtG9Wpw5NDqoBBnedxmyhKiFN", key_ids = [5, 6, 7, 8]}
-        ,
-            {public_key = "xNVCph6zd7HLLJcuwrWz1gNbFoPHjXxn7cyRvvTYhP3U", key_ids = [9, 10, 11, 12]}
-        ,
-            {public_key = "p2wFfLEbwGCmxCR5eGa46Ct6i3BVjFrvBixRn7FnCQjA", key_ids = [13, 14, 15, 16]}
-        ,
-            {public_key = "26jpUNnJPvzDJRJg3hfBn5s5MR4eQ4LLTokjrSDzByh4i", key_ids = [17, 18, 19, 20]}
-        ]
+    {public_key = "27MvzC7LYTFfjBQdZropBqzWSKQYgFVHWh3YXchYrh5Ug", key_ids = [1, 2, 3, 4]},
+    {public_key = "f1Y6JdedrZyaZLnScbXbc1A7DhdLMjCipKCxkKUA93YQ", key_ids = [5, 6, 7, 8]},
+    {public_key = "nKPew4JetMvV97EghsdikNMhgyYF37ZeNvmJNSJueyjQ", key_ids = [9, 10, 11, 12]},
+    {public_key = "x3LcNnYgKKFBUaf9fZTEGHghFCQQyd6F9XNWj7nRXLt7", key_ids = [13, 14, 15, 16]},
+    {public_key = "nUVH972kFxpKbD62muCb9L48nTKqNw11yp3vFM9VDzqw", key_ids = [17, 18, 19, 20]}
+]
diff --git a/stacks-signer/src/tests/conf/signer-3.toml b/stacks-signer/src/tests/conf/signer-3.toml
index e7ac219a40..4f6fb7ff25 100644
--- a/stacks-signer/src/tests/conf/signer-3.toml
+++ b/stacks-signer/src/tests/conf/signer-3.toml
@@ -1,19 +1,14 @@
 
-message_private_key = "3fMkii13QRwRqrwgcLtxmAAcqCfGwpY3ANZLYMWD8qUj"
-stacks_private_key = "803fa7b9c8a39ed368f160b3dcbfaa8f677fc157ffbccb46ee3e4a32a37f12d201"
+stacks_private_key = "63cef3cd8880969b7f2450ca13b9ca57fd3cd3f7ee57ec6ed7654a84d39181e401"
 node_host = "127.0.0.1:20443"
 endpoint = "localhost:30003"
 network = "testnet"
 stackerdb_contract_id = "ST11Z60137Y96MF89K1KKRTA3CR6B25WY1Y931668.signers-stackerdb"
 signer_id = 3
 signers = [
-            {public_key = "swBaKxfzs4pQne7spxhrkF6AtB34WEcreAkJ8mPcqx3t", key_ids = [1, 2, 3, 4]}
-        ,
-            {public_key = "yDJhntuJczbss1XGDmyWtG9Wpw5NDqoBBnedxmyhKiFN", key_ids = [5, 6, 7, 8]}
-        ,
-            {public_key = "xNVCph6zd7HLLJcuwrWz1gNbFoPHjXxn7cyRvvTYhP3U", key_ids = [9, 10, 11, 12]}
-        ,
-            {public_key = "p2wFfLEbwGCmxCR5eGa46Ct6i3BVjFrvBixRn7FnCQjA", key_ids = [13, 14, 15, 16]}
-        ,
-            {public_key = "26jpUNnJPvzDJRJg3hfBn5s5MR4eQ4LLTokjrSDzByh4i", key_ids = [17, 18, 19, 20]}
-        ]
+    {public_key = "27MvzC7LYTFfjBQdZropBqzWSKQYgFVHWh3YXchYrh5Ug", key_ids = [1, 2, 3, 4]},
+    {public_key = "f1Y6JdedrZyaZLnScbXbc1A7DhdLMjCipKCxkKUA93YQ", key_ids = [5, 6, 7, 8]},
+    {public_key = "nKPew4JetMvV97EghsdikNMhgyYF37ZeNvmJNSJueyjQ", key_ids = [9, 10, 11, 12]},
+    {public_key = "x3LcNnYgKKFBUaf9fZTEGHghFCQQyd6F9XNWj7nRXLt7", key_ids = [13, 14, 15, 16]},
+    {public_key = "nUVH972kFxpKbD62muCb9L48nTKqNw11yp3vFM9VDzqw", key_ids = [17, 18, 19, 20]}
+]
diff --git a/stacks-signer/src/tests/conf/signer-4.toml b/stacks-signer/src/tests/conf/signer-4.toml
index c2eb3f37d0..fa15e83cfd 100644
--- a/stacks-signer/src/tests/conf/signer-4.toml
+++ b/stacks-signer/src/tests/conf/signer-4.toml
@@ -1,19 +1,14 @@
 
-message_private_key = "9hn4j7pm37WyG6WMX25dn8j8v8E2uyTCDRPNrucjDWn1"
-stacks_private_key = "1bfdf386114aacf355fe018a1ec7ac728fa05ca20a6131a70f686291bb9b31ca01"
+stacks_private_key = "e427196ae29197b1db6d5495ff26bf0675f48a4f07b200c0814b95734ecda60f01"
 node_host = "127.0.0.1:20443"
 endpoint = "localhost:30004"
 network = "testnet"
 stackerdb_contract_id = "ST11Z60137Y96MF89K1KKRTA3CR6B25WY1Y931668.signers-stackerdb"
 signer_id = 4
 signers = [
-            {public_key = "swBaKxfzs4pQne7spxhrkF6AtB34WEcreAkJ8mPcqx3t", key_ids = [1, 2, 3, 4]}
-        ,
-            {public_key = "yDJhntuJczbss1XGDmyWtG9Wpw5NDqoBBnedxmyhKiFN", key_ids = [5, 6, 7, 8]}
-        ,
-            {public_key = "xNVCph6zd7HLLJcuwrWz1gNbFoPHjXxn7cyRvvTYhP3U", key_ids = [9, 10, 11, 12]}
-        ,
-            {public_key = "p2wFfLEbwGCmxCR5eGa46Ct6i3BVjFrvBixRn7FnCQjA", key_ids = [13, 14, 15, 16]}
-        ,
-            {public_key = "26jpUNnJPvzDJRJg3hfBn5s5MR4eQ4LLTokjrSDzByh4i", key_ids = [17, 18, 19, 20]}
-        ]
+    {public_key = "27MvzC7LYTFfjBQdZropBqzWSKQYgFVHWh3YXchYrh5Ug", key_ids = [1, 2, 3, 4]},
+    {public_key = "f1Y6JdedrZyaZLnScbXbc1A7DhdLMjCipKCxkKUA93YQ", key_ids = [5, 6, 7, 8]},
+    {public_key = "nKPew4JetMvV97EghsdikNMhgyYF37ZeNvmJNSJueyjQ", key_ids = [9, 10, 11, 12]},
+    {public_key = "x3LcNnYgKKFBUaf9fZTEGHghFCQQyd6F9XNWj7nRXLt7", key_ids = [13, 14, 15, 16]},
+    {public_key = "nUVH972kFxpKbD62muCb9L48nTKqNw11yp3vFM9VDzqw", key_ids = [17, 18, 19, 20]}
+]
diff --git a/stacks-signer/src/utils.rs b/stacks-signer/src/utils.rs
index 5e7af9a4e0..18b374778b 100644
--- a/stacks-signer/src/utils.rs
+++ b/stacks-signer/src/utils.rs
@@ -15,23 +15,28 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 use std::time::Duration;
 
-use rand_core::OsRng;
 use slog::slog_debug;
+use stacks_common::address::{
+    AddressHashMode, C32_ADDRESS_VERSION_MAINNET_SINGLESIG, C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
+};
 use stacks_common::debug;
-use stacks_common::types::chainstate::{StacksAddress, StacksPrivateKey};
+use stacks_common::types::chainstate::{StacksAddress, StacksPrivateKey, StacksPublicKey};
+use stacks_common::types::PrivateKey;
 use wsts::curve::ecdsa;
 use wsts::curve::scalar::Scalar;
 
+use crate::config::Network;
+
 /// Helper function for building a signer config for each provided signer private key
 pub fn build_signer_config_tomls(
-    signer_stacks_private_keys: &[StacksPrivateKey],
+    stacks_private_keys: &[StacksPrivateKey],
     num_keys: u32,
     node_host: &str,
     stackerdb_contract_id: &str,
     timeout: Option<Duration>,
+    network: &Network,
 ) -> Vec<String> {
-    let num_signers = signer_stacks_private_keys.len() as u32;
-    let mut rng = OsRng;
+    let num_signers = stacks_private_keys.len() as u32;
     let keys_per_signer = num_keys / num_signers;
     let mut key_id: u32 = 1;
     let mut key_ids = Vec::new();
@@ -52,40 +57,40 @@ pub fn build_signer_config_tomls(
         }
         key_ids.push(ids.join(", "));
     }
-    let signer_ecdsa_private_keys = (0..num_signers)
-        .map(|_| Scalar::random(&mut rng))
-        .collect::<Vec<Scalar>>();
 
     let mut signer_config_tomls = vec![];
     let mut signers_array = String::new();
+
     signers_array += "signers = [";
-    for (i, private_key) in signer_ecdsa_private_keys.iter().enumerate() {
-        let ecdsa_public_key = ecdsa::PublicKey::new(private_key).unwrap().to_string();
+    for (i, stacks_private_key) in stacks_private_keys.iter().enumerate() {
+        let scalar = Scalar::try_from(&stacks_private_key.to_bytes()[..32])
+            .expect("BUG: failed to convert the StacksPrivateKey to a Scalar");
+        let ecdsa_public_key = ecdsa::PublicKey::new(&scalar)
+            .expect("BUG: failed to get a ecdsa::PublicKey from the provided Scalar")
+            .to_string();
         let ids = key_ids[i].clone();
         signers_array += &format!(
             r#"
-            {{public_key = "{ecdsa_public_key}", key_ids = [{ids}]}}
-        "#
+    {{public_key = "{ecdsa_public_key}", key_ids = [{ids}]}}"#
         );
-        if i != signer_ecdsa_private_keys.len() - 1 {
+        if i != stacks_private_keys.len() - 1 {
             signers_array += ",";
         }
     }
-    signers_array += "]";
+    signers_array += "\n]";
+
     let mut port = 30000;
-    for (i, stacks_private_key) in signer_stacks_private_keys.iter().enumerate() {
+    for (i, stacks_private_key) in stacks_private_keys.iter().enumerate() {
         let endpoint = format!("localhost:{}", port);
         port += 1;
         let id = i;
-        let message_private_key = signer_ecdsa_private_keys[i].to_string();
         let stacks_private_key = stacks_private_key.to_hex();
         let mut signer_config_toml = format!(
             r#"
-message_private_key = "{message_private_key}"
 stacks_private_key = "{stacks_private_key}"
 node_host = "{node_host}"
 endpoint = "{endpoint}"
-network = "testnet"
+network = "{network}"
 stackerdb_contract_id = "{stackerdb_contract_id}"
 signer_id = {id}
 {signers_array}
@@ -138,3 +143,18 @@ pub fn build_stackerdb_contract(
     stackerdb_contract += "    ";
     stackerdb_contract
 }
+
+/// Helper function to convert a private key to a Stacks address
+pub fn to_addr(stacks_private_key: &StacksPrivateKey, network: &Network) -> StacksAddress {
+    let version = match network {
+        Network::Mainnet => C32_ADDRESS_VERSION_MAINNET_SINGLESIG,
+        Network::Testnet | Network::Mocknet => C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
+    };
+    StacksAddress::from_public_keys(
+        version,
+        &AddressHashMode::SerializeP2PKH,
+        1,
+        &vec![StacksPublicKey::from_private(stacks_private_key)],
+    )
+    .expect("BUG: failed to generate address from private key")
+}
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index 8c19ab2adc..88b2fb28ba 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -1,4 +1,5 @@
 use std::collections::HashMap;
+use std::net::ToSocketAddrs;
 use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
 use std::sync::mpsc::{channel, Receiver, Sender};
 use std::sync::{Arc, Mutex};
@@ -7,13 +8,19 @@ use std::{env, thread};
 
 use clarity::vm::types::QualifiedContractIdentifier;
 use libsigner::{
-    BlockResponse, RunningSigner, Signer, SignerEventReceiver, SignerMessage, BLOCK_SLOT_ID,
-    SIGNER_SLOTS_PER_USER,
+    BlockResponse, RejectCode, RunningSigner, Signer, SignerEventReceiver, SignerMessage,
+    BLOCK_SLOT_ID, SIGNER_SLOTS_PER_USER,
 };
 use stacks::chainstate::coordinator::comm::CoordinatorChannels;
 use stacks::chainstate::nakamoto::{NakamotoBlock, NakamotoBlockHeader};
-use stacks::chainstate::stacks::{StacksPrivateKey, ThresholdSignature};
+use stacks::chainstate::stacks::boot::SIGNERS_NAME;
+use stacks::chainstate::stacks::{
+    StacksPrivateKey, StacksTransaction, ThresholdSignature, TransactionAnchorMode,
+    TransactionAuth, TransactionPayload, TransactionPostConditionMode, TransactionSmartContract,
+    TransactionVersion,
+};
 use stacks::net::api::postblock_proposal::BlockValidateResponse;
+use stacks::util_lib::strings::StacksString;
 use stacks_common::bitvec::BitVec;
 use stacks_common::codec::read_next;
 use stacks_common::types::chainstate::{
@@ -21,8 +28,8 @@ use stacks_common::types::chainstate::{
 };
 use stacks_common::util::hash::{MerkleTree, Sha512Trunc256Sum};
 use stacks_common::util::secp256k1::MessageSignature;
-use stacks_signer::client::StacksClient;
-use stacks_signer::config::Config as SignerConfig;
+use stacks_signer::client::{StackerDB, StacksClient};
+use stacks_signer::config::{Config as SignerConfig, Network};
 use stacks_signer::runloop::{calculate_coordinator, RunLoopCommand};
 use stacks_signer::utils::{build_signer_config_tomls, build_stackerdb_contract};
 use tracing_subscriber::prelude::*;
@@ -73,6 +80,8 @@ struct SignerTest {
     pub running_coordinator: RunningSigner<SignerEventReceiver, Vec<OperationResult>>,
     // The running signer and its threads
     pub running_signers: HashMap<u32, RunningSigner<SignerEventReceiver, Vec<OperationResult>>>,
+    // the private keys of the signers
+    pub signer_stacks_private_keys: Vec<StacksPrivateKey>,
 }
 
 impl SignerTest {
@@ -105,6 +114,7 @@ impl SignerTest {
             &naka_conf.node.rpc_bind,
             &signers_stacker_db_contract_id.to_string(),
             Some(Duration::from_millis(128)), // Timeout defaults to 5 seconds. Let's override it to 128 milliseconds.
+            &Network::Testnet,
         );
 
         let mut running_signers = HashMap::new();
@@ -159,6 +169,7 @@ impl SignerTest {
             coordinator_cmd_sender,
             running_coordinator,
             running_signers,
+            signer_stacks_private_keys,
         }
     }
 
@@ -688,3 +699,214 @@ fn stackerdb_block_proposal() {
     }
     signer_test.shutdown();
 }
+
+#[test]
+#[ignore]
+/// Test that signers will reject a miners block proposal if it is missing expected transactions
+///
+/// Test Setup:
+/// The test spins up five stacks signers, one miner Nakamoto node, and a corresponding bitcoind.
+/// The stacks node is advanced to epoch 3.0. and signers perform a DKG round (this should be removed
+/// once we have proper casting of the vote during epoch 2.5).
+///
+/// Test Execution:
+/// The node attempts to mine a Nakamoto tenure, sending a block to the observing signers via the
+/// .miners stacker db instance. The signers submit the block to the stacks node for verification.
+/// Upon receiving a Block Validation response approving the block, the signers verify that it contains
+/// all expected transactions. As it does not, the signers reject the block and do not sign it.
+///
+/// Test Assertion:
+/// Signers broadcast rejections with the list of missing transactions back to the miners stackerdb instance
+fn stackerdb_block_proposal_missing_transactions() {
+    if env::var("BITCOIND_TEST") != Ok("1".into()) {
+        return;
+    }
+
+    tracing_subscriber::registry()
+        .with(fmt::layer())
+        .with(EnvFilter::from_default_env())
+        .init();
+
+    info!("------------------------- Test Setup -------------------------");
+    let mut signer_test = SignerTest::new(5, 5);
+
+    let host = signer_test
+        .running_nodes
+        .conf
+        .node
+        .rpc_bind
+        .to_socket_addrs()
+        .unwrap()
+        .next()
+        .unwrap();
+    let signer_stacker_db = signer_test
+        .running_nodes
+        .conf
+        .node
+        .stacker_dbs
+        .iter()
+        .find(|id| id.name.to_string() == SIGNERS_NAME)
+        .unwrap()
+        .clone();
+    let signer_id = 0;
+    let signer_private_key = signer_test
+        .signer_stacks_private_keys
+        .get(signer_id)
+        .expect("Cannot find signer private key for signer id 0")
+        .clone();
+    let mut stackerdb = StackerDB::new(host, signer_stacker_db, signer_private_key, 0);
+    // Create a valid transaction signed by the signer private key coresponding to the slot into which it is being inserted (signer id 0)
+    let mut valid_tx = StacksTransaction {
+        version: TransactionVersion::Testnet,
+        chain_id: 0,
+        auth: TransactionAuth::from_p2pkh(&signer_private_key).unwrap(),
+        anchor_mode: TransactionAnchorMode::Any,
+        post_condition_mode: TransactionPostConditionMode::Allow,
+        post_conditions: vec![],
+        payload: TransactionPayload::SmartContract(
+            TransactionSmartContract {
+                name: "test-contract".into(),
+                code_body: StacksString::from_str("(/ 1 0)").unwrap(),
+            },
+            None,
+        ),
+    };
+    valid_tx.set_origin_nonce(0);
+
+    // Create a transaction signed by a different private key
+    // This transaction will be invalid as it is signed by a different private key than the one that corresponds to the slot into which it is being inserted
+    let invalid_signer_id = 1;
+    let invalid_signer_private_key = signer_test
+        .signer_stacks_private_keys
+        .get(invalid_signer_id)
+        .expect("Cannot find signer private key for signer id 1")
+        .clone();
+    let mut invalid_tx = StacksTransaction {
+        version: TransactionVersion::Testnet,
+        chain_id: 0,
+        auth: TransactionAuth::from_p2pkh(&invalid_signer_private_key).unwrap(),
+        anchor_mode: TransactionAnchorMode::Any,
+        post_condition_mode: TransactionPostConditionMode::Allow,
+        post_conditions: vec![],
+        payload: TransactionPayload::SmartContract(
+            TransactionSmartContract {
+                name: "test-contract".into(),
+                code_body: StacksString::from_str("(/ 1 0)").unwrap(),
+            },
+            None,
+        ),
+    };
+    invalid_tx.set_origin_nonce(0);
+
+    // First run DKG in order to sign the block that arrives from the miners following a nakamoto block production
+    // TODO: remove this forcibly running DKG once we have casting of the vote automagically happening during epoch 2.5
+    info!("signer_runloop: spawn send commands to do dkg");
+    signer_test
+        .coordinator_cmd_sender
+        .send(RunLoopCommand::Dkg)
+        .expect("failed to send Dkg command");
+    let recv = signer_test
+        .result_receivers
+        .last()
+        .expect("Failed to get coordinator recv");
+    let results = recv
+        .recv_timeout(Duration::from_secs(30))
+        .expect("failed to recv dkg results");
+    for result in results {
+        match result {
+            OperationResult::Dkg(point) => {
+                info!("Received aggregate_group_key {point}");
+                break;
+            }
+            _ => {
+                panic!("Received Unexpected result");
+            }
+        }
+    }
+
+    // Following stacker DKG, submit transactions to stackerdb for the signers to pick up during block verification
+    stackerdb
+        .send_message_with_retry(SignerMessage::Transactions(vec![
+            valid_tx.clone(),
+            invalid_tx,
+        ]))
+        .expect("Failed to write expected transactions to stackerdb");
+
+    let (vrfs_submitted, commits_submitted) = (
+        signer_test.running_nodes.vrfs_submitted.clone(),
+        signer_test.running_nodes.commits_submitted.clone(),
+    );
+
+    info!("------------------------- Test Block Rejected -------------------------");
+
+    info!("Mining a Nakamoto tenure...");
+
+    // first block wakes up the run loop, wait until a key registration has been submitted.
+    next_block_and(
+        &mut signer_test.running_nodes.btc_regtest_controller,
+        60,
+        || {
+            let vrf_count = vrfs_submitted.load(Ordering::SeqCst);
+            Ok(vrf_count >= 1)
+        },
+    )
+    .unwrap();
+
+    // second block should confirm the VRF register, wait until a block commit is submitted
+    next_block_and(
+        &mut signer_test.running_nodes.btc_regtest_controller,
+        60,
+        || {
+            let commits_count = commits_submitted.load(Ordering::SeqCst);
+            Ok(commits_count >= 1)
+        },
+    )
+    .unwrap();
+
+    // Mine 1 nakamoto tenure
+    next_block_and_mine_commit(
+        &mut signer_test.running_nodes.btc_regtest_controller,
+        60,
+        &signer_test.running_nodes.coord_channel,
+        &commits_submitted,
+    )
+    .unwrap();
+
+    // Verify that the signers broadcasted a series of rejections with missing transactions back to the miner
+    let t_start = Instant::now();
+    let mut chunk = None;
+    while chunk.is_none() {
+        assert!(
+            t_start.elapsed() < Duration::from_secs(30),
+            "Timed out while waiting for signers block response stacker db event"
+        );
+
+        let nakamoto_blocks = test_observer::get_stackerdb_chunks();
+        for event in nakamoto_blocks {
+            // Only care about the miners block slot
+            for slot in event.modified_slots {
+                if slot.slot_id == BLOCK_SLOT_ID {
+                    chunk = Some(slot.data);
+                    break;
+                }
+            }
+            if chunk.is_some() {
+                break;
+            }
+        }
+        thread::sleep(Duration::from_secs(1));
+    }
+    let chunk = chunk.unwrap();
+    let signer_message = read_next::<SignerMessage, _>(&mut &chunk[..]).unwrap();
+    if let SignerMessage::BlockResponse(BlockResponse::Rejected(block_rejection)) = signer_message {
+        // Verify we are missing the valid tx that we expect to see in the block
+        if let RejectCode::MissingTransactions(missing_txs) = block_rejection.reason_code {
+            assert_eq!(missing_txs, vec![valid_tx]);
+        } else {
+            panic!("Received unexpected rejection reason");
+        }
+    } else {
+        panic!("Received unexpected message");
+    }
+    signer_test.shutdown();
+}

From 055791cf1bb53b38c4f472043a3b1c4df1b57453 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Tue, 30 Jan 2024 15:25:54 -0800
Subject: [PATCH 0614/1166] Clippy cleanup

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/stackerdb.rs     | 51 +++++++++++------------
 stacks-signer/src/client/stacks_client.rs | 34 +++++++--------
 stacks-signer/src/main.rs                 |  2 +-
 stacks-signer/src/runloop.rs              | 16 ++++---
 4 files changed, 52 insertions(+), 51 deletions(-)

diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index 19720e012a..b362634903 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -129,38 +129,37 @@ impl StackerDB {
             "Getting latest chunks from stackerdb for the following signers: {:?}",
             signer_ids
         );
-        loop {
-            let send_request = || {
-                self.signers_stackerdb_session
-                    .get_latest_chunks(&slot_ids)
-                    .map_err(backoff::Error::transient)
-            };
-            let chunk_ack = retry_with_exponential_backoff(send_request)?;
-            let mut transactions = Vec::new();
-            for (i, chunk) in chunk_ack.iter().enumerate() {
-                if let Some(data) = chunk {
-                    if let Ok(message) = read_next::<SignerMessage, _>(&mut &data[..]) {
-                        if let SignerMessage::Transactions(chunk_transactions) = message {
-                            let signer_id = *signer_ids.get(i).expect(
-                                "BUG: retrieved an unequal amount of chunks to requested chunks",
-                            );
-                            debug!(
-                                "Retrieved {} transactions from signer ID {}.",
-                                chunk_transactions.len(),
-                                signer_id
-                            );
-                            transactions.push((signer_id, chunk_transactions));
-                        } else {
-                            warn!("Signer wrote an unexpected type to the transactions slot");
-                        }
+        let send_request = || {
+            self.signers_stackerdb_session
+                .get_latest_chunks(&slot_ids)
+                .map_err(backoff::Error::transient)
+        };
+        let chunk_ack = retry_with_exponential_backoff(send_request)?;
+        let mut transactions = Vec::new();
+        for (i, chunk) in chunk_ack.iter().enumerate() {
+            if let Some(data) = chunk {
+                if let Ok(message) = read_next::<SignerMessage, _>(&mut &data[..]) {
+                    if let SignerMessage::Transactions(chunk_transactions) = message {
+                        let signer_id = *signer_ids.get(i).expect(
+                            "BUG: retrieved an unequal amount of chunks to requested chunks",
+                        );
+                        debug!(
+                            "Retrieved {} transactions from signer ID {}.",
+                            chunk_transactions.len(),
+                            signer_id
+                        );
+                        transactions.push((signer_id, chunk_transactions));
                     } else {
-                        warn!("Failed to deserialize chunk data into a SignerMessage");
+                        warn!("Signer wrote an unexpected type to the transactions slot");
                     }
+                } else {
+                    warn!("Failed to deserialize chunk data into a SignerMessage");
                 }
             }
-            return Ok(transactions);
         }
+        Ok(transactions)
     }
+
     /// Retrieve the signer contract id
     pub fn signers_contract_id(&self) -> &QualifiedContractIdentifier {
         &self.signers_stackerdb_session.stackerdb_contract_id
diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index 70e4a7b8d4..8f1ee3eaf0 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -81,8 +81,7 @@ impl StacksClient {
         stackerdb_contract: &QualifiedContractIdentifier,
     ) -> Result<Vec<(StacksAddress, u128)>, ClientError> {
         let function_name_str = "stackerdb-get-signer-slots";
-        let function_name = ClarityName::try_from(function_name_str)
-            .map_err(|_| ClientError::InvalidClarityName(function_name_str.to_string()))?;
+        let function_name = ClarityName::from(function_name_str);
         let function_args = &[];
         let contract_response_hex = self.read_only_contract_call_with_retry(
             &stackerdb_contract.issuer.clone().into(),
@@ -136,8 +135,7 @@ impl StacksClient {
     pub fn get_aggregate_public_key(&self) -> Result<Option<Point>, ClientError> {
         let reward_cycle = self.get_current_reward_cycle()?;
         let function_name_str = "get-aggregate-public-key";
-        let function_name = ClarityName::try_from(function_name_str)
-            .map_err(|_| ClientError::InvalidClarityName(function_name_str.to_string()))?;
+        let function_name = ClarityName::from(function_name_str);
         let pox_contract_id = boot_code_id(POX_4_NAME, self.chain_id == CHAIN_ID_MAINNET);
         let function_args = &[ClarityValue::UInt(reward_cycle as u128)];
         let contract_response_hex = self.read_only_contract_call_with_retry(
@@ -456,8 +454,8 @@ mod tests {
         let h = spawn(move || {
             config.client.read_only_contract_call_with_retry(
                 &config.client.stacks_address,
-                &ContractName::try_from("contract-name").unwrap(),
-                &ClarityName::try_from("function-name").unwrap(),
+                &ContractName::from("contract-name"),
+                &ClarityName::from("function-name"),
                 &[],
             )
         });
@@ -475,8 +473,8 @@ mod tests {
         let h = spawn(move || {
             config.client.read_only_contract_call_with_retry(
                 &config.client.stacks_address,
-                &ContractName::try_from("contract-name").unwrap(),
-                &ClarityName::try_from("function-name").unwrap(),
+                &ContractName::from("contract-name"),
+                &ClarityName::from("function-name"),
                 &[ClarityValue::UInt(10_u128)],
             )
         });
@@ -494,8 +492,8 @@ mod tests {
         let h = spawn(move || {
             config.client.read_only_contract_call_with_retry(
                 &config.client.stacks_address,
-                &ContractName::try_from("contract-name").unwrap(),
-                &ClarityName::try_from("function-name").unwrap(),
+                &ContractName::from("contract-name"),
+                &ClarityName::from("function-name"),
                 &[],
             )
         });
@@ -514,8 +512,8 @@ mod tests {
         let h = spawn(move || {
             config.client.read_only_contract_call_with_retry(
                 &config.client.stacks_address,
-                &ContractName::try_from("contract-name").unwrap(),
-                &ClarityName::try_from("function-name").unwrap(),
+                &ContractName::from("contract-name"),
+                &ClarityName::from("function-name"),
                 &[],
             )
         });
@@ -536,8 +534,8 @@ mod tests {
         let h = spawn(move || {
             config.client.read_only_contract_call_with_retry(
                 &config.client.stacks_address,
-                &ContractName::try_from("contract-name").unwrap(),
-                &ClarityName::try_from("function-name").unwrap(),
+                &ContractName::from("contract-name"),
+                &ClarityName::from("function-name"),
                 &[],
             )
         });
@@ -627,8 +625,8 @@ mod tests {
             .client
             .build_signed_transaction(
                 &config.client.stacks_address,
-                ContractName::try_from("contract-name").unwrap(),
-                ClarityName::try_from("function-name").unwrap(),
+                ContractName::from("contract-name"),
+                ClarityName::from("function-name"),
                 &[],
             )
             .unwrap();
@@ -674,8 +672,8 @@ mod tests {
         let h = spawn(move || {
             config.client.transaction_contract_call(
                 &config.client.stacks_address,
-                ContractName::try_from("contract-name").unwrap(),
-                ClarityName::try_from("function-name").unwrap(),
+                ContractName::from("contract-name"),
+                ClarityName::from("function-name"),
                 &[],
             )
         });
diff --git a/stacks-signer/src/main.rs b/stacks-signer/src/main.rs
index 8e0034d8f0..934d599f51 100644
--- a/stacks-signer/src/main.rs
+++ b/stacks-signer/src/main.rs
@@ -262,7 +262,7 @@ fn handle_run(args: RunDkgArgs) {
 fn handle_generate_files(args: GenerateFilesArgs) {
     debug!("Generating files...");
     let signer_stacks_private_keys = if let Some(path) = args.private_keys {
-        let file = File::open(&path).unwrap();
+        let file = File::open(path).unwrap();
         let reader = io::BufReader::new(file);
 
         let private_keys: Vec<String> = reader.lines().collect::<Result<_, _>>().unwrap();
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 2d27640f6c..7ccd3bbde4 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -547,7 +547,6 @@ impl<C: Coordinator> RunLoop<C> {
             .public_keys
             .signers
             .keys()
-            .into_iter()
             .cloned()
             .collect::<Vec<_>>();
         let transactions = self
@@ -969,12 +968,13 @@ pub fn calculate_coordinator(
     // or default to the first signer if none are found
     selection_ids
         .first()
-        .and_then(|(_, id)| public_keys.signers.get(id).map(|pk| (*id, pk.clone())))
+        .and_then(|(_, id)| public_keys.signers.get(id).map(|pk| (*id, *pk)))
         .unwrap_or((0, public_keys.signers.get(&0).cloned().unwrap()))
 }
 
 #[cfg(test)]
 mod tests {
+    use std::fmt::Write;
     use std::net::TcpListener;
     use std::thread::{sleep, spawn};
 
@@ -987,7 +987,11 @@ mod tests {
     fn generate_random_consensus_hash() -> String {
         let rng = rand::thread_rng();
         let bytes: Vec<u8> = rng.sample_iter(Standard).take(20).collect();
-        bytes.iter().map(|b| format!("{:02x}", b)).collect()
+        let hex_string = bytes.iter().fold(String::new(), |mut acc, &b| {
+            write!(&mut acc, "{:02x}", b).expect("Error writing to string");
+            acc
+        });
+        hex_string
     }
 
     fn mock_stacks_client_response(mock_server: TcpListener, random_consensus: bool) {
@@ -1032,7 +1036,7 @@ mod tests {
         // Check that not all coordinator public keys are the same
         let all_keys_same = results
             .iter()
-            .all(|&(_, ref key)| key.key.data == results[0].1.key.data);
+            .all(|&(_, key)| key.key.data == results[0].1.key.data);
         assert!(
             !all_keys_same,
             "Not all coordinator public keys should be the same"
@@ -1059,7 +1063,7 @@ mod tests {
             .all(|&(id, _)| id == results_with_random_hash[0].0);
         let all_keys_same = results_with_random_hash
             .iter()
-            .all(|&(_, ref key)| key.key.data == results_with_random_hash[0].1.key.data);
+            .all(|&(_, key)| key.key.data == results_with_random_hash[0].1.key.data);
         assert!(!all_ids_same, "Not all coordinator IDs should be the same");
         assert!(
             !all_keys_same,
@@ -1072,7 +1076,7 @@ mod tests {
             .all(|&(id, _)| id == results_with_static_hash[0].0);
         let all_keys_same = results_with_static_hash
             .iter()
-            .all(|&(_, ref key)| key.key.data == results_with_static_hash[0].1.key.data);
+            .all(|&(_, key)| key.key.data == results_with_static_hash[0].1.key.data);
         assert!(all_ids_same, "All coordinator IDs should be the same");
         assert!(
             all_keys_same,

From 07b69b16b5afbdd30f53b0fddd5846662d0f43db Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Thu, 1 Feb 2024 14:40:01 -0800
Subject: [PATCH 0615/1166] Add tests to filtering of invalid transactions

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/mod.rs           |  15 +
 stacks-signer/src/client/stackerdb.rs     |   7 +-
 stacks-signer/src/client/stacks_client.rs | 345 +++++++++++++++-------
 stacks-signer/src/config.rs               |   1 +
 stacks-signer/src/runloop.rs              | 264 ++++++++++++++---
 5 files changed, 488 insertions(+), 144 deletions(-)

diff --git a/stacks-signer/src/client/mod.rs b/stacks-signer/src/client/mod.rs
index 59f853b377..7342df7d0d 100644
--- a/stacks-signer/src/client/mod.rs
+++ b/stacks-signer/src/client/mod.rs
@@ -122,6 +122,7 @@ pub(crate) mod tests {
         pub(crate) mock_server: TcpListener,
         pub(crate) client: StacksClient,
         pub(crate) stackerdb: StackerDB,
+        pub(crate) config: Config,
     }
 
     impl TestConfig {
@@ -142,6 +143,20 @@ pub(crate) mod tests {
                 mock_server,
                 client,
                 stackerdb,
+                config,
+            }
+        }
+
+        pub(crate) fn from_config(config: Config) -> Self {
+            let mock_server = TcpListener::bind(config.node_host).unwrap();
+
+            let client = StacksClient::from(&config);
+            let stackerdb = StackerDB::from(&config);
+            Self {
+                mock_server,
+                client,
+                stackerdb,
+                config,
             }
         }
     }
diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index b362634903..dc87597e64 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -120,7 +120,7 @@ impl StackerDB {
     pub fn get_signer_transactions_with_retry(
         &mut self,
         signer_ids: &[u32],
-    ) -> Result<Vec<(u32, Vec<StacksTransaction>)>, ClientError> {
+    ) -> Result<Vec<StacksTransaction>, ClientError> {
         let slot_ids: Vec<_> = signer_ids
             .iter()
             .map(|id| id * SIGNER_SLOTS_PER_USER + TRANSACTIONS_SLOT_ID)
@@ -148,7 +148,7 @@ impl StackerDB {
                             chunk_transactions.len(),
                             signer_id
                         );
-                        transactions.push((signer_id, chunk_transactions));
+                        transactions.extend(chunk_transactions);
                     } else {
                         warn!("Signer wrote an unexpected type to the transactions slot");
                     }
@@ -212,7 +212,6 @@ mod tests {
         response_bytes.extend(message);
         write_response(config.mock_server, response_bytes.as_slice());
         let transactions = h.join().unwrap().unwrap();
-        assert_eq!(transactions.len(), 1);
-        assert_eq!(transactions[0], (0, vec![tx]));
+        assert_eq!(transactions, vec![tx]);
     }
 }
diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index 8f1ee3eaf0..14093db2ac 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -22,7 +22,8 @@ use blockstack_lib::chainstate::stacks::{
     TransactionSpendingCondition, TransactionVersion,
 };
 use blockstack_lib::core::{
-    BITCOIN_MAINNET_STACKS_30_BURN_HEIGHT, BITCOIN_TESTNET_STACKS_30_BURN_HEIGHT,
+    BITCOIN_MAINNET_STACKS_25_BURN_HEIGHT, BITCOIN_MAINNET_STACKS_30_BURN_HEIGHT,
+    BITCOIN_TESTNET_STACKS_25_BURN_HEIGHT, BITCOIN_TESTNET_STACKS_30_BURN_HEIGHT,
 };
 use blockstack_lib::net::api::callreadonly::CallReadOnlyResponse;
 use blockstack_lib::net::api::getaccount::AccountEntryResponse;
@@ -61,6 +62,17 @@ pub struct StacksClient {
     stacks_node_client: reqwest::blocking::Client,
 }
 
+/// The supported epoch IDs
+#[derive(Debug, PartialEq)]
+pub enum EpochId {
+    /// The mainnet epoch ID
+    Epoch30,
+    /// The testnet epoch ID
+    Epoch25,
+    /// Unsuporrted epoch ID
+    UnsupportedEpoch,
+}
+
 impl From<&Config> for StacksClient {
     fn from(config: &Config) -> Self {
         Self {
@@ -83,13 +95,13 @@ impl StacksClient {
         let function_name_str = "stackerdb-get-signer-slots";
         let function_name = ClarityName::from(function_name_str);
         let function_args = &[];
-        let contract_response_hex = self.read_only_contract_call_with_retry(
+        let value = self.read_only_contract_call_with_retry(
             &stackerdb_contract.issuer.clone().into(),
             &stackerdb_contract.name,
             &function_name,
             function_args,
         )?;
-        self.parse_signer_slots(&contract_response_hex)
+        self.parse_signer_slots(value)
     }
     /// Retrieve the stacks tip consensus hash from the stacks node
     pub fn get_stacks_tip_consensus_hash(&self) -> Result<ConsensusHash, ClientError> {
@@ -97,16 +109,30 @@ impl StacksClient {
         Ok(peer_info.stacks_tip_consensus_hash)
     }
 
-    /// Determine if the stacks node is pre or post epoch 3.0 activation
-    pub fn is_pre_nakamoto(&self) -> Result<bool, ClientError> {
+    /// Determine the stacks node current epoch
+    pub fn get_node_epoch(&self) -> Result<EpochId, ClientError> {
         let is_mainnet = self.chain_id == CHAIN_ID_MAINNET;
         let burn_block_height = self.get_burn_block_height()?;
-        let epoch_30_activation_height = if is_mainnet {
-            BITCOIN_MAINNET_STACKS_30_BURN_HEIGHT
+
+        let (epoch25_activation_height, epoch_30_activation_height) = if is_mainnet {
+            (
+                BITCOIN_MAINNET_STACKS_25_BURN_HEIGHT,
+                BITCOIN_MAINNET_STACKS_30_BURN_HEIGHT,
+            )
         } else {
-            BITCOIN_TESTNET_STACKS_30_BURN_HEIGHT
+            (
+                BITCOIN_TESTNET_STACKS_25_BURN_HEIGHT,
+                BITCOIN_TESTNET_STACKS_30_BURN_HEIGHT,
+            )
         };
-        Ok(burn_block_height >= epoch_30_activation_height)
+
+        if burn_block_height < epoch25_activation_height {
+            Ok(EpochId::UnsupportedEpoch)
+        } else if burn_block_height < epoch_30_activation_height {
+            Ok(EpochId::Epoch25)
+        } else {
+            Ok(EpochId::Epoch30)
+        }
     }
 
     /// Submit the block proposal to the stacks node. The block will be validated and returned via the HTTP endpoint for Block events.
@@ -138,13 +164,13 @@ impl StacksClient {
         let function_name = ClarityName::from(function_name_str);
         let pox_contract_id = boot_code_id(POX_4_NAME, self.chain_id == CHAIN_ID_MAINNET);
         let function_args = &[ClarityValue::UInt(reward_cycle as u128)];
-        let contract_response_hex = self.read_only_contract_call_with_retry(
+        let value = self.read_only_contract_call_with_retry(
             &pox_contract_id.issuer.into(),
             &pox_contract_id.name,
             &function_name,
             function_args,
         )?;
-        self.parse_aggregate_public_key(&contract_response_hex)
+        self.parse_aggregate_public_key(value)
     }
 
     /// Retrieve the current account nonce for the provided address
@@ -227,11 +253,14 @@ impl StacksClient {
     }
 
     /// Helper function that attempts to deserialize a clarity hex string as the aggregate public key
-    fn parse_aggregate_public_key(&self, hex: &str) -> Result<Option<Point>, ClientError> {
-        debug!("Parsing aggregate public key: {hex}...");
+    fn parse_aggregate_public_key(
+        &self,
+        value: ClarityValue,
+    ) -> Result<Option<Point>, ClientError> {
+        debug!("Parsing aggregate public key...");
         // Due to pox 4 definition, the aggregate public key is always an optional clarity value hence the use of expect
         // If this fails, we have bigger problems than the signer crashing...
-        let value_opt = ClarityValue::try_deserialize_hex_untyped(hex)?.expect_optional()?;
+        let value_opt = value.expect_optional()?;
         let Some(value) = value_opt else {
             return Ok(None);
         };
@@ -248,11 +277,14 @@ impl StacksClient {
     }
 
     /// Helper function  that attempts to deserialize a clarity hext string as a list of signer slots and their associated number of signer slots
-    fn parse_signer_slots(&self, hex: &str) -> Result<Vec<(StacksAddress, u128)>, ClientError> {
-        debug!("Parsing signer slots: {hex}...");
-        // Due to .signers definition, the  signer slots is always a result of a list of tuples of signer addresses and the number of slots they have
+    fn parse_signer_slots(
+        &self,
+        value: ClarityValue,
+    ) -> Result<Vec<(StacksAddress, u128)>, ClientError> {
+        debug!("Parsing signer slots...");
+        // Due to .signers definition, the  signer slots is always an OK result of a list of tuples of signer addresses and the number of slots they have
         // If this fails, we have bigger problems than the signer crashing...
-        let value = ClarityValue::try_deserialize_hex_untyped(hex)?.expect_result_ok()?;
+        let value = value.clone().expect_result_ok()?;
         let values = value.expect_list()?;
         let mut signer_slots = Vec::with_capacity(values.len());
         for value in values {
@@ -279,63 +311,22 @@ impl StacksClient {
         function_args: &[ClarityValue],
     ) -> Result<Txid, ClientError> {
         debug!("Making a contract call to {contract_addr}.{contract_name}...");
-        let signed_tx = self.build_signed_transaction(
+        let nonce = self.get_account_nonce(&self.stacks_address)?;
+        // TODO: make tx_fee configurable
+        let signed_tx = Self::build_signed_contract_call_transaction(
             contract_addr,
             contract_name,
             function_name,
             function_args,
+            &self.stacks_private_key,
+            self.tx_version,
+            self.chain_id,
+            nonce,
+            10_000,
         )?;
         self.submit_tx(&signed_tx)
     }
 
-    /// Helper function to create a stacks transaction for a modifying contract call
-    fn build_signed_transaction(
-        &self,
-        contract_addr: &StacksAddress,
-        contract_name: ContractName,
-        function_name: ClarityName,
-        function_args: &[ClarityValue],
-    ) -> Result<StacksTransaction, ClientError> {
-        let tx_payload = TransactionPayload::ContractCall(TransactionContractCall {
-            address: *contract_addr,
-            contract_name,
-            function_name,
-            function_args: function_args.to_vec(),
-        });
-        let public_key = StacksPublicKey::from_private(&self.stacks_private_key);
-        let tx_auth = TransactionAuth::Standard(
-            TransactionSpendingCondition::new_singlesig_p2pkh(public_key).ok_or(
-                ClientError::TransactionGenerationFailure(format!(
-                    "Failed to create spending condition from public key: {}",
-                    public_key.to_hex()
-                )),
-            )?,
-        );
-
-        let mut unsigned_tx = StacksTransaction::new(self.tx_version, tx_auth, tx_payload);
-
-        // FIXME: Because signers are given priority, we can put down a tx fee of 0
-        // https://github.com/stacks-network/stacks-blockchain/issues/4006
-        // Note: if set to 0 now, will cause a failure (MemPoolRejection::FeeTooLow)
-        unsigned_tx.set_tx_fee(10_000);
-        unsigned_tx.set_origin_nonce(self.get_account_nonce(&self.stacks_address)?);
-
-        unsigned_tx.anchor_mode = TransactionAnchorMode::Any;
-        unsigned_tx.post_condition_mode = TransactionPostConditionMode::Allow;
-        unsigned_tx.chain_id = self.chain_id;
-
-        let mut tx_signer = StacksTransactionSigner::new(&unsigned_tx);
-        tx_signer
-            .sign_origin(&self.stacks_private_key)
-            .map_err(|e| ClientError::TransactionGenerationFailure(e.to_string()))?;
-
-        tx_signer
-            .get_tx()
-            .ok_or(ClientError::TransactionGenerationFailure(
-                "Failed to generate transaction from a transaction signer".to_string(),
-            ))
-    }
-
     /// Helper function to submit a transaction to the Stacks node
     fn submit_tx(&self, tx: &StacksTransaction) -> Result<Txid, ClientError> {
         let txid = tx.txid();
@@ -362,7 +353,7 @@ impl StacksClient {
         contract_name: &ContractName,
         function_name: &ClarityName,
         function_args: &[ClarityValue],
-    ) -> Result<String, ClientError> {
+    ) -> Result<ClarityValue, ClientError> {
         debug!(
             "Calling read-only function {function_name} with args {:?}...",
             function_args
@@ -401,7 +392,9 @@ impl StacksClient {
                     .unwrap_or("unknown".to_string())
             )));
         }
-        Ok(call_read_only_response.result.unwrap_or_default())
+        let hex = call_read_only_response.result.unwrap_or_default();
+        let value = ClarityValue::try_deserialize_hex_untyped(&hex)?;
+        Ok(value)
     }
 
     fn pox_path(&self) -> String {
@@ -433,7 +426,59 @@ impl StacksClient {
     }
 
     fn accounts_path(&self, stacks_address: &StacksAddress) -> String {
-        format!("{}/v2/accounts/{stacks_address}", self.http_origin)
+        format!("{}/v2/accounts/{stacks_address}?proof=0", self.http_origin)
+    }
+
+    /// Helper function to create a stacks transaction for a modifying contract call
+    pub fn build_signed_contract_call_transaction(
+        contract_addr: &StacksAddress,
+        contract_name: ContractName,
+        function_name: ClarityName,
+        function_args: &[ClarityValue],
+        stacks_private_key: &StacksPrivateKey,
+        tx_version: TransactionVersion,
+        chain_id: u32,
+        nonce: u64,
+        tx_fee: u64,
+    ) -> Result<StacksTransaction, ClientError> {
+        let tx_payload = TransactionPayload::ContractCall(TransactionContractCall {
+            address: *contract_addr,
+            contract_name,
+            function_name,
+            function_args: function_args.to_vec(),
+        });
+        let public_key = StacksPublicKey::from_private(stacks_private_key);
+        let tx_auth = TransactionAuth::Standard(
+            TransactionSpendingCondition::new_singlesig_p2pkh(public_key).ok_or(
+                ClientError::TransactionGenerationFailure(format!(
+                    "Failed to create spending condition from public key: {}",
+                    public_key.to_hex()
+                )),
+            )?,
+        );
+
+        let mut unsigned_tx = StacksTransaction::new(tx_version, tx_auth, tx_payload);
+
+        // FIXME: Because signers are given priority, we can put down a tx fee of 0
+        // https://github.com/stacks-network/stacks-blockchain/issues/4006
+        // Note: if set to 0 now, will cause a failure (MemPoolRejection::FeeTooLow)
+        unsigned_tx.set_tx_fee(tx_fee);
+        unsigned_tx.set_origin_nonce(nonce);
+
+        unsigned_tx.anchor_mode = TransactionAnchorMode::Any;
+        unsigned_tx.post_condition_mode = TransactionPostConditionMode::Allow;
+        unsigned_tx.chain_id = chain_id;
+
+        let mut tx_signer = StacksTransactionSigner::new(&unsigned_tx);
+        tx_signer
+            .sign_origin(stacks_private_key)
+            .map_err(|e| ClientError::TransactionGenerationFailure(e.to_string()))?;
+
+        tx_signer
+            .get_tx()
+            .ok_or(ClientError::TransactionGenerationFailure(
+                "Failed to generate transaction from a transaction signer".to_string(),
+            ))
     }
 }
 
@@ -443,6 +488,8 @@ mod tests {
     use std::thread::spawn;
 
     use libsigner::SIGNER_SLOTS_PER_USER;
+    use stacks_common::consts::CHAIN_ID_TESTNET;
+    use wsts::curve::scalar::Scalar;
 
     use super::*;
     use crate::client::tests::{write_response, TestConfig};
@@ -451,6 +498,9 @@ mod tests {
     #[test]
     fn read_only_contract_call_200_success() {
         let config = TestConfig::new();
+        let value = ClarityValue::UInt(10_u128);
+        let hex = value.to_string();
+        let response_bytes = format!("HTTP/1.1 200 OK\n\n{{\"okay\":true,\"result\":\"{hex}\"}}",);
         let h = spawn(move || {
             config.client.read_only_contract_call_with_retry(
                 &config.client.stacks_address,
@@ -459,17 +509,17 @@ mod tests {
                 &[],
             )
         });
-        write_response(
-            config.mock_server,
-            b"HTTP/1.1 200 OK\n\n{\"okay\":true,\"result\":\"0x070d0000000473425443\"}",
-        );
+        write_response(config.mock_server, response_bytes.as_bytes());
         let result = h.join().unwrap().unwrap();
-        assert_eq!(result, "0x070d0000000473425443");
+        assert_eq!(result, value);
     }
 
     #[test]
     fn read_only_contract_call_with_function_args_200_success() {
         let config = TestConfig::new();
+        let value = ClarityValue::UInt(10_u128);
+        let hex = value.to_string();
+        let response_bytes = format!("HTTP/1.1 200 OK\n\n{{\"okay\":true,\"result\":\"{hex}\"}}",);
         let h = spawn(move || {
             config.client.read_only_contract_call_with_retry(
                 &config.client.stacks_address,
@@ -478,12 +528,9 @@ mod tests {
                 &[ClarityValue::UInt(10_u128)],
             )
         });
-        write_response(
-            config.mock_server,
-            b"HTTP/1.1 200 OK\n\n{\"okay\":true,\"result\":\"0x070d0000000473425443\"}",
-        );
+        write_response(config.mock_server, response_bytes.as_bytes());
         let result = h.join().unwrap().unwrap();
-        assert_eq!(result, "0x070d0000000473425443");
+        assert_eq!(result, value);
     }
 
     #[test]
@@ -583,53 +630,96 @@ mod tests {
         assert!(matches!(res, Err(ClientError::ReqwestError(_))));
     }
 
+    #[test]
+    fn get_aggregate_public_key_should_succeed() {
+        let current_reward_cycle_response = b"HTTP/1.1 200 Ok\n\n{\"contract_id\":\"ST000000000000000000002AMW42H.pox-3\",\"pox_activation_threshold_ustx\":829371801288885,\"first_burnchain_block_height\":2000000,\"current_burnchain_block_height\":2572192,\"prepare_phase_block_length\":50,\"reward_phase_block_length\":1000,\"reward_slots\":2000,\"rejection_fraction\":12,\"total_liquid_supply_ustx\":41468590064444294,\"current_cycle\":{\"id\":544,\"min_threshold_ustx\":5190000000000,\"stacked_ustx\":853258144644000,\"is_pox_active\":true},\"next_cycle\":{\"id\":545,\"min_threshold_ustx\":5190000000000,\"min_increment_ustx\":5183573758055,\"stacked_ustx\":847278759574000,\"prepare_phase_start_block_height\":2572200,\"blocks_until_prepare_phase\":8,\"reward_phase_start_block_height\":2572250,\"blocks_until_reward_phase\":58,\"ustx_until_pox_rejection\":4976230807733304},\"min_amount_ustx\":5190000000000,\"prepare_cycle_length\":50,\"reward_cycle_id\":544,\"reward_cycle_length\":1050,\"rejection_votes_left_required\":4976230807733304,\"next_reward_cycle_in\":58,\"contract_versions\":[{\"contract_id\":\"ST000000000000000000002AMW42H.pox\",\"activation_burnchain_block_height\":2000000,\"first_reward_cycle_id\":0},{\"contract_id\":\"ST000000000000000000002AMW42H.pox-2\",\"activation_burnchain_block_height\":2422102,\"first_reward_cycle_id\":403},{\"contract_id\":\"ST000000000000000000002AMW42H.pox-3\",\"activation_burnchain_block_height\":2432545,\"first_reward_cycle_id\":412}]}";
+        let orig_point = Point::from(Scalar::random(&mut rand::thread_rng()));
+        let clarity_value = ClarityValue::some(
+            ClarityValue::buff_from(orig_point.compress().as_bytes().to_vec())
+                .expect("BUG: Failed to create clarity value from point"),
+        )
+        .expect("BUG: Failed to create clarity value from point");
+        let hex = clarity_value
+            .serialize_to_hex()
+            .expect("Failed to serialize clarity value");
+        let response = format!("HTTP/1.1 200 OK\n\n{{\"okay\":true,\"result\":\"{hex}\"}}");
+
+        let test_config = TestConfig::new();
+        let config = test_config.config;
+        let h = spawn(move || test_config.client.get_aggregate_public_key());
+        write_response(test_config.mock_server, current_reward_cycle_response);
+
+        let test_config = TestConfig::from_config(config);
+        write_response(test_config.mock_server, response.as_bytes());
+        let res = h.join().unwrap().unwrap();
+        assert_eq!(res, Some(orig_point));
+
+        let clarity_value = ClarityValue::none();
+        let hex = clarity_value
+            .serialize_to_hex()
+            .expect("Failed to serialize clarity value");
+        let response = format!("HTTP/1.1 200 OK\n\n{{\"okay\":true,\"result\":\"{hex}\"}}");
+
+        let test_config = TestConfig::new();
+        let config = test_config.config;
+        let h = spawn(move || test_config.client.get_aggregate_public_key());
+        write_response(test_config.mock_server, current_reward_cycle_response);
+
+        let test_config = TestConfig::from_config(config);
+        write_response(test_config.mock_server, response.as_bytes());
+
+        let res = h.join().unwrap().unwrap();
+        assert!(res.is_none());
+    }
+
     #[test]
     fn parse_valid_aggregate_public_key_should_succeed() {
         let config = TestConfig::new();
-        let clarity_value_hex =
-            "0x0a020000002103beca18a0e51ea31d8e66f58a245d54791b277ad08e1e9826bf5f814334ac77e0";
+        let orig_point = Point::from(Scalar::random(&mut rand::thread_rng()));
+        let clarity_value = ClarityValue::some(
+            ClarityValue::buff_from(orig_point.compress().as_bytes().to_vec())
+                .expect("BUG: Failed to create clarity value from point"),
+        )
+        .expect("BUG: Failed to create clarity value from point");
         let result = config
             .client
-            .parse_aggregate_public_key(clarity_value_hex)
+            .parse_aggregate_public_key(clarity_value)
             .unwrap();
-        assert_eq!(
-            result.map(|point| point.to_string()),
-            Some("27XiJwhYDWdUrYAFNejKDhmY22jU1hmwyQ5nVDUJZPmbm".to_string())
-        );
+        assert_eq!(result, Some(orig_point));
 
-        let clarity_value_hex = "0x09";
-        let result = config
-            .client
-            .parse_aggregate_public_key(clarity_value_hex)
-            .unwrap();
+        let value = ClarityValue::none();
+        let result = config.client.parse_aggregate_public_key(value).unwrap();
         assert!(result.is_none());
     }
 
     #[test]
     fn parse_invalid_aggregate_public_key_should_fail() {
         let config = TestConfig::new();
-        let clarity_value_hex = "0x00";
-        let result = config.client.parse_aggregate_public_key(clarity_value_hex);
+        let value = ClarityValue::UInt(10_u128);
+        let result = config.client.parse_aggregate_public_key(value);
         assert!(matches!(
             result,
             Err(ClientError::ClaritySerializationError(..))
         ));
-        // TODO: add further tests for malformed clarity values (an optional of any other type for example)
     }
 
     #[ignore]
     #[test]
     fn transaction_contract_call_should_send_bytes_to_node() {
         let config = TestConfig::new();
-        let tx = config
-            .client
-            .build_signed_transaction(
-                &config.client.stacks_address,
-                ContractName::from("contract-name"),
-                ClarityName::from("function-name"),
-                &[],
-            )
-            .unwrap();
+        let private_key = StacksPrivateKey::new();
+        let tx = StacksClient::build_signed_contract_call_transaction(
+            &config.client.stacks_address,
+            ContractName::from("contract-name"),
+            ClarityName::from("function-name"),
+            &[],
+            &private_key,
+            TransactionVersion::Testnet,
+            CHAIN_ID_TESTNET,
+            0,
+            10_000,
+        )
+        .unwrap();
 
         let mut tx_bytes = [0u8; 1024];
         {
@@ -740,7 +830,7 @@ mod tests {
         let h = spawn(move || config.client.get_account_nonce(&address));
         write_response(
             config.mock_server,
-            b"HTTP/1.1 200 OK\n\n{\"nonce\":0,\"balance\":\"0x00000000000000000000000000000000\",\"locked\":\"0x00000000000000000000000000000000\",\"unlock_height\":0,\"balance_proof\":\"\",\"nonce_proof\":\"\"}"
+            b"HTTP/1.1 200 OK\n\n{\"nonce\":0,\"balance\":\"0x00000000000000000000000000000000\",\"locked\":\"0x00000000000000000000000000000000\",\"unlock_height\":0}"
         );
         let nonce = h.join().unwrap().expect("Failed to deserialize response");
         assert_eq!(nonce, 0);
@@ -753,7 +843,7 @@ mod tests {
         let h = spawn(move || config.client.get_account_nonce(&address));
         write_response(
             config.mock_server,
-            b"HTTP/1.1 200 OK\n\n{\"nonce\":\"invalid nonce\",\"balance\":\"0x00000000000000000000000000000000\",\"locked\":\"0x00000000000000000000000000000000\",\"unlock_height\":0,\"balance_proof\":\"\",\"nonce_proof\":\"\"}"
+            b"HTTP/1.1 200 OK\n\n{\"nonce\":\"invalid nonce\",\"balance\":\"0x00000000000000000000000000000000\",\"locked\":\"0x00000000000000000000000000000000\",\"unlock_height\":0}"
         );
         assert!(h.join().unwrap().is_err());
     }
@@ -763,10 +853,51 @@ mod tests {
         let config = TestConfig::new();
         let clarity_value_hex =
             "0x070b000000050c00000002096e756d2d736c6f7473010000000000000000000000000000000c067369676e6572051a8195196a9a7cf9c37cb13e1ed69a7bc047a84e050c00000002096e756d2d736c6f7473010000000000000000000000000000000c067369676e6572051a6505471146dcf722f0580911183f28bef30a8a890c00000002096e756d2d736c6f7473010000000000000000000000000000000c067369676e6572051a1d7f8e3936e5da5f32982cc47f31d7df9fb1b38a0c00000002096e756d2d736c6f7473010000000000000000000000000000000c067369676e6572051a126d1a814313c952e34c7840acec9211e1727fb80c00000002096e756d2d736c6f7473010000000000000000000000000000000c067369676e6572051a7374ea6bb39f2e8d3d334d62b9f302a977de339a";
-        let signer_slots = config.client.parse_signer_slots(clarity_value_hex).unwrap();
+        let value = ClarityValue::try_deserialize_hex_untyped(clarity_value_hex).unwrap();
+        let signer_slots = config.client.parse_signer_slots(value).unwrap();
         assert_eq!(signer_slots.len(), 5);
         signer_slots
             .into_iter()
             .for_each(|(_address, slots)| assert!(slots == SIGNER_SLOTS_PER_USER as u128));
     }
+
+    #[test]
+    fn get_node_epoch_should_succeed() {
+        let config = TestConfig::new();
+        let h = spawn(move || config.client.get_node_epoch());
+        write_response(
+            config.mock_server,
+            b"HTTP/1.1 200 OK\n\n{\"burn_block_height\":2575799,\"peer_version\":4207599113,\"pox_consensus\":\"64c8c3049ff6b939c65828e3168210e6bb32d880\",\"stable_pox_consensus\":\"72277bf9a3b115e13c0942825480d6cee0e9a0e8\",\"stable_burn_block_height\":2575792,\"server_version\":\"stacks-node d657bdd (feat/epoch-2.4:d657bdd, release build, linux [x86_64])\",\"network_id\":2147483648,\"parent_network_id\":118034699,\"stacks_tip_height\":145152,\"stacks_tip\":\"77219884fe434c0fa270d65592b4f082ab3e5d9922ac2bdaac34310aedc3d298\",\"stacks_tip_consensus_hash\":\"64c8c3049ff6b939c65828e3168210e6bb32d880\",\"genesis_chainstate_hash\":\"74237aa39aa50a83de11a4f53e9d3bb7d43461d1de9873f402e5453ae60bc59b\",\"unanchored_tip\":\"dde44222b6e6d81583b6b9c55db83e8716943ae9d0dc332fc39448ddd9b99dc2\",\"unanchored_seq\":0,\"exit_at_block_height\":null,\"node_public_key\":\"023c940136d5795d9dd82c0e87f4dd6a2a1db245444e7d70e34bb9605c3c3917b0\",\"node_public_key_hash\":\"e26cce8f6abe06b9fc81c3b11bcc821d2f1b8fd0\"}",
+        );
+        let epoch = h.join().unwrap().expect("Failed to deserialize response");
+        assert_eq!(epoch, EpochId::UnsupportedEpoch);
+
+        let config = TestConfig::new();
+        let h = spawn(move || config.client.get_node_epoch());
+        let height = BITCOIN_TESTNET_STACKS_25_BURN_HEIGHT;
+        let response_bytes = format!("HTTP/1.1 200 OK\n\n{{\"burn_block_height\":{height},\"peer_version\":4207599113,\"pox_consensus\":\"64c8c3049ff6b939c65828e3168210e6bb32d880\",\"stable_pox_consensus\":\"72277bf9a3b115e13c0942825480d6cee0e9a0e8\",\"stable_burn_block_height\":2575792,\"server_version\":\"stacks-node d657bdd (feat/epoch-2.4:d657bdd, release build, linux [x86_64])\",\"network_id\":2147483648,\"parent_network_id\":118034699,\"stacks_tip_height\":145152,\"stacks_tip\":\"77219884fe434c0fa270d65592b4f082ab3e5d9922ac2bdaac34310aedc3d298\",\"stacks_tip_consensus_hash\":\"64c8c3049ff6b939c65828e3168210e6bb32d880\",\"genesis_chainstate_hash\":\"74237aa39aa50a83de11a4f53e9d3bb7d43461d1de9873f402e5453ae60bc59b\",\"unanchored_tip\":\"dde44222b6e6d81583b6b9c55db83e8716943ae9d0dc332fc39448ddd9b99dc2\",\"unanchored_seq\":0,\"exit_at_block_height\":null,\"node_public_key\":\"023c940136d5795d9dd82c0e87f4dd6a2a1db245444e7d70e34bb9605c3c3917b0\",\"node_public_key_hash\":\"e26cce8f6abe06b9fc81c3b11bcc821d2f1b8fd0\"}}");
+
+        write_response(config.mock_server, response_bytes.as_bytes());
+        let epoch = h.join().unwrap().expect("Failed to deserialize response");
+        assert_eq!(epoch, EpochId::Epoch25);
+
+        let config = TestConfig::new();
+        let h = spawn(move || config.client.get_node_epoch());
+        let height = BITCOIN_TESTNET_STACKS_30_BURN_HEIGHT;
+        let response_bytes = format!("HTTP/1.1 200 OK\n\n{{\"burn_block_height\":{height},\"peer_version\":4207599113,\"pox_consensus\":\"64c8c3049ff6b939c65828e3168210e6bb32d880\",\"stable_pox_consensus\":\"72277bf9a3b115e13c0942825480d6cee0e9a0e8\",\"stable_burn_block_height\":2575792,\"server_version\":\"stacks-node d657bdd (feat/epoch-2.4:d657bdd, release build, linux [x86_64])\",\"network_id\":2147483648,\"parent_network_id\":118034699,\"stacks_tip_height\":145152,\"stacks_tip\":\"77219884fe434c0fa270d65592b4f082ab3e5d9922ac2bdaac34310aedc3d298\",\"stacks_tip_consensus_hash\":\"64c8c3049ff6b939c65828e3168210e6bb32d880\",\"genesis_chainstate_hash\":\"74237aa39aa50a83de11a4f53e9d3bb7d43461d1de9873f402e5453ae60bc59b\",\"unanchored_tip\":\"dde44222b6e6d81583b6b9c55db83e8716943ae9d0dc332fc39448ddd9b99dc2\",\"unanchored_seq\":0,\"exit_at_block_height\":null,\"node_public_key\":\"023c940136d5795d9dd82c0e87f4dd6a2a1db245444e7d70e34bb9605c3c3917b0\",\"node_public_key_hash\":\"e26cce8f6abe06b9fc81c3b11bcc821d2f1b8fd0\"}}");
+        write_response(config.mock_server, response_bytes.as_bytes());
+        let epoch = h.join().unwrap().expect("Failed to deserialize response");
+        assert_eq!(epoch, EpochId::Epoch30);
+    }
+
+    #[test]
+    fn get_node_epoch_should_fail() {
+        let config = TestConfig::new();
+        let h = spawn(move || config.client.get_node_epoch());
+        write_response(
+            config.mock_server,
+            b"HTTP/1.1 200 OK\n\n4e99f99bc4a05437abb8c7d0c306618f45b203196498e2ebe287f10497124958",
+        );
+        assert!(h.join().unwrap().is_err());
+    }
 }
diff --git a/stacks-signer/src/config.rs b/stacks-signer/src/config.rs
index e5eb2fc4b2..d89ae603d7 100644
--- a/stacks-signer/src/config.rs
+++ b/stacks-signer/src/config.rs
@@ -115,6 +115,7 @@ impl Network {
 }
 
 /// The parsed configuration for the signer
+#[derive(Clone, Debug)]
 pub struct Config {
     /// endpoint to the stacks node
     pub node_host: SocketAddr,
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 7ccd3bbde4..9aea89b74b 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -39,7 +39,9 @@ use wsts::state_machine::signer::Signer;
 use wsts::state_machine::{OperationResult, PublicKeys, SignError};
 use wsts::v2;
 
-use crate::client::{retry_with_exponential_backoff, ClientError, StackerDB, StacksClient};
+use crate::client::{
+    retry_with_exponential_backoff, ClientError, EpochId, StackerDB, StacksClient,
+};
 use crate::config::{Config, Network};
 
 /// Which operation to perform
@@ -495,11 +497,13 @@ impl<C: Coordinator> RunLoop<C> {
     /// Verify the transactions in a block are as expected
     fn verify_transactions(&mut self, block: &NakamotoBlock) -> bool {
         if let Ok(expected_transactions) = self.get_expected_transactions() {
+            //It might be worth building a hashset of the blocks' txids and checking that against the expected transaction's txid.
+            let block_tx_hashset = block.txs.iter().map(|tx| tx.txid()).collect::<HashSet<_>>();
             // Ensure the block contains the transactions we expect
             let missing_transactions = expected_transactions
                 .into_iter()
                 .filter_map(|tx| {
-                    if !block.txs.contains(&tx) {
+                    if !block_tx_hashset.contains(&tx.txid()) {
                         Some(tx)
                     } else {
                         None
@@ -540,6 +544,31 @@ impl<C: Coordinator> RunLoop<C> {
         }
     }
 
+    /// Filter out invalid transactions from the list of transactions
+    fn filter_out_invalid_transactions(
+        &self,
+        proposed_transactions: Vec<StacksTransaction>,
+    ) -> Vec<StacksTransaction> {
+        let mut expected_transactions = vec![];
+        for transaction in proposed_transactions {
+            // TODO: Filter out transactions that are not special cased transactions (cast votes, etc.)
+            // Filter out transactions that have already been confirmed (can happen if a signer did not update stacker db since the last block was processed)
+            let origin_address = transaction.origin_address();
+            let origin_nonce = transaction.get_origin_nonce();
+            let Ok(account_nonce) = self.stacks_client.get_account_nonce(&origin_address) else {
+                warn!("Unable to get account for address: {origin_address}. Ignoring it for this block...");
+                continue;
+            };
+            if !self.signer_addresses.contains(&origin_address) || origin_nonce < account_nonce {
+                debug!("Received a transaction for signer id that is either not valid or has already been confirmed. Ignoring it.");
+                continue;
+            } else {
+                expected_transactions.push(transaction);
+            }
+        }
+        expected_transactions
+    }
+
     /// Get the transactions we expect to see in the next block
     fn get_expected_transactions(&mut self) -> Result<Vec<StacksTransaction>, ClientError> {
         let signer_ids = self
@@ -552,30 +581,7 @@ impl<C: Coordinator> RunLoop<C> {
         let transactions = self
             .stackerdb
             .get_signer_transactions_with_retry(&signer_ids)?;
-        let mut expected_transactions = vec![];
-        for (signer_id, signer_transactions) in transactions {
-            let Some(stacks_address) = self.signer_addresses.get(signer_id as usize) else {
-                // Received a transaction for a signer we do not know about. Ignore it.
-                continue;
-            };
-            let Ok(account_nonce) = self.stacks_client.get_account_nonce(stacks_address) else {
-                warn!("Unable to get account nonce for signer id {signer_id}. Ignoring their transactions.");
-                continue;
-            };
-            for signer_transaction in signer_transactions {
-                // TODO: Filter out transactions that are not special cased transactions (cast votes, etc.)
-                // Filter out transactions that have already been confirmed (can happen if a signer did not update stacker db since the last block was processed)
-                if signer_transaction.origin_address() != *stacks_address
-                    || signer_transaction.get_origin_nonce() < account_nonce
-                {
-                    debug!("Received a transaction for signer id {signer_id} that is either not valid or has already been confirmed. Ignoring it.");
-                    continue;
-                } else {
-                    expected_transactions.push(signer_transaction);
-                }
-            }
-        }
-        Ok(expected_transactions)
+        Ok(self.filter_out_invalid_transactions(transactions))
     }
 
     /// Determine the vote for a block and update the block info and nonce request accordingly
@@ -644,13 +650,26 @@ impl<C: Coordinator> RunLoop<C> {
                 OperationResult::Dkg(_point) => {
                     // TODO: cast the aggregate public key for the latest round here
                     // Broadcast via traditional methods to the stacks node if we are pre nakamoto or we cannot determine our Epoch
-                    if self.stacks_client.is_pre_nakamoto().unwrap_or(false) {
-                        // We are in the pre-nakamoto phase. Broadcast the aggregate public key stx transaction to the stacks node via the mempool
-                    }
-                    // Always broadcast the transactions to stackerdb so miners and signers can observe it when building and validating the block, respectively.
-                    let signer_message = SignerMessage::Transactions(self.transactions.clone());
-                    if let Err(e) = self.stackerdb.send_message_with_retry(signer_message) {
-                        warn!("Failed to update transactions in stacker-db: {:?}", e);
+                    let epoch = self
+                        .stacks_client
+                        .get_node_epoch()
+                        .unwrap_or(EpochId::UnsupportedEpoch);
+                    match epoch {
+                        EpochId::UnsupportedEpoch => {
+                            debug!("Received a DKG result, but are in an unsupported epoch. Do not broadcast the result.");
+                        }
+                        EpochId::Epoch25 => {
+                            debug!("Received a DKG result, but are in epoch 2.5. Broadcast the transaction to the mempool.");
+                            //TODO: Cast the aggregate public key vote here
+                        }
+                        EpochId::Epoch30 => {
+                            debug!("Received a DKG result, but are in epoch 3. Broadcast the transaction to stackerDB.");
+                            let signer_message =
+                                SignerMessage::Transactions(self.transactions.clone());
+                            if let Err(e) = self.stackerdb.send_message_with_retry(signer_message) {
+                                warn!("Failed to update transactions in stacker-db: {:?}", e);
+                            }
+                        }
                     }
                 }
                 OperationResult::SignError(e) => {
@@ -978,8 +997,18 @@ mod tests {
     use std::net::TcpListener;
     use std::thread::{sleep, spawn};
 
+    use blockstack_lib::chainstate::stacks::boot::SIGNERS_VOTING_NAME;
+    use blockstack_lib::chainstate::stacks::TransactionVersion;
+    use blockstack_lib::util_lib::boot::boot_code_addr;
+    use clarity::vm::types::{ResponseData, TupleData};
+    use clarity::vm::{ClarityName, Value as ClarityValue};
+    use libsigner::SIGNER_SLOTS_PER_USER;
     use rand::distributions::Standard;
     use rand::Rng;
+    use stacks_common::types::chainstate::StacksPrivateKey;
+    use stacks_common::util::hash::Hash160;
+    use wsts::curve::point::Point;
+    use wsts::curve::scalar::Scalar;
 
     use super::*;
     use crate::client::tests::{write_response, TestConfig};
@@ -1083,4 +1112,173 @@ mod tests {
             "All coordinator public keys should be the same"
         );
     }
+
+    fn build_get_signer_slots_response(config: &Config) -> String {
+        let mut signers_public_keys = config
+            .signer_ids_public_keys
+            .signers
+            .iter()
+            .map(|(signer_id, signer_public_key)| {
+                let bytes = signer_public_key.to_bytes();
+                let signer_hash = Hash160::from_data(&bytes);
+                let signing_address = StacksAddress::p2pkh_from_hash(false, signer_hash);
+                (signer_id, signing_address)
+            })
+            .collect::<Vec<_>>();
+        signers_public_keys.sort_by(|(a, _), (b, _)| a.cmp(b));
+
+        let mut list_data = vec![];
+        for (_, signers_public_key) in signers_public_keys {
+            let tuple_data = vec![
+                (
+                    ClarityName::from("signer"),
+                    ClarityValue::Principal(signers_public_key.into()),
+                ),
+                (
+                    ClarityName::from("num-slots"),
+                    ClarityValue::UInt(SIGNER_SLOTS_PER_USER as u128),
+                ),
+            ];
+            let tuple = ClarityValue::Tuple(
+                TupleData::from_data(tuple_data).expect("Failed to create tuple data"),
+            );
+            list_data.push(tuple);
+        }
+
+        let result_data =
+            ClarityValue::cons_list_unsanitized(list_data).expect("Failed to construct list data");
+        let response_clarity = ClarityValue::Response(ResponseData {
+            committed: true,
+            data: Box::new(result_data),
+        });
+        let hex = response_clarity
+            .serialize_to_hex()
+            .expect("Failed to serialize clarity value");
+        format!("HTTP/1.1 200 OK\n\n{{\"okay\":true,\"result\":\"{hex}\"}}")
+    }
+
+    fn build_get_aggregate_public_key_response_some() -> (String, String) {
+        let current_reward_cycle_response = "HTTP/1.1 200 Ok\n\n{\"contract_id\":\"ST000000000000000000002AMW42H.pox-3\",\"pox_activation_threshold_ustx\":829371801288885,\"first_burnchain_block_height\":2000000,\"current_burnchain_block_height\":2572192,\"prepare_phase_block_length\":50,\"reward_phase_block_length\":1000,\"reward_slots\":2000,\"rejection_fraction\":12,\"total_liquid_supply_ustx\":41468590064444294,\"current_cycle\":{\"id\":544,\"min_threshold_ustx\":5190000000000,\"stacked_ustx\":853258144644000,\"is_pox_active\":true},\"next_cycle\":{\"id\":545,\"min_threshold_ustx\":5190000000000,\"min_increment_ustx\":5183573758055,\"stacked_ustx\":847278759574000,\"prepare_phase_start_block_height\":2572200,\"blocks_until_prepare_phase\":8,\"reward_phase_start_block_height\":2572250,\"blocks_until_reward_phase\":58,\"ustx_until_pox_rejection\":4976230807733304},\"min_amount_ustx\":5190000000000,\"prepare_cycle_length\":50,\"reward_cycle_id\":544,\"reward_cycle_length\":1050,\"rejection_votes_left_required\":4976230807733304,\"next_reward_cycle_in\":58,\"contract_versions\":[{\"contract_id\":\"ST000000000000000000002AMW42H.pox\",\"activation_burnchain_block_height\":2000000,\"first_reward_cycle_id\":0},{\"contract_id\":\"ST000000000000000000002AMW42H.pox-2\",\"activation_burnchain_block_height\":2422102,\"first_reward_cycle_id\":403},{\"contract_id\":\"ST000000000000000000002AMW42H.pox-3\",\"activation_burnchain_block_height\":2432545,\"first_reward_cycle_id\":412}]}".to_string();
+        let orig_point = Point::from(Scalar::random(&mut rand::thread_rng()));
+        let clarity_value = ClarityValue::some(
+            ClarityValue::buff_from(orig_point.compress().as_bytes().to_vec())
+                .expect("BUG: Failed to create clarity value from point"),
+        )
+        .expect("BUG: Failed to create clarity value from point");
+        let hex = clarity_value
+            .serialize_to_hex()
+            .expect("Failed to serialize clarity value");
+        let point_response = format!("HTTP/1.1 200 OK\n\n{{\"okay\":true,\"result\":\"{hex}\"}}");
+
+        (current_reward_cycle_response, point_response)
+    }
+
+    fn simulate_initialize_response(config: Config) {
+        let (current_reward_cycle_response, aggregate_key_response) =
+            build_get_aggregate_public_key_response_some();
+        let signer_slots_response = build_get_signer_slots_response(&config);
+        let test_config = TestConfig::from_config(config.clone());
+        write_response(
+            test_config.mock_server,
+            current_reward_cycle_response.as_bytes(),
+        );
+        let test_config = TestConfig::from_config(config.clone());
+        write_response(test_config.mock_server, aggregate_key_response.as_bytes());
+
+        let test_config = TestConfig::from_config(config);
+        write_response(test_config.mock_server, signer_slots_response.as_bytes());
+    }
+
+    #[allow(dead_code)]
+    fn simulate_get_transactions_response(config: Config) {
+        let (current_reward_cycle_response, aggregate_key_response) =
+            build_get_aggregate_public_key_response_some();
+        let signer_slots_response = build_get_signer_slots_response(&config);
+        let test_config = TestConfig::from_config(config.clone());
+        write_response(
+            test_config.mock_server,
+            current_reward_cycle_response.as_bytes(),
+        );
+        let test_config = TestConfig::from_config(config.clone());
+        write_response(test_config.mock_server, aggregate_key_response.as_bytes());
+
+        let test_config = TestConfig::from_config(config);
+        write_response(test_config.mock_server, signer_slots_response.as_bytes());
+    }
+
+    fn simulate_get_account_nonce_response(config: Config, num_responses: usize) {
+        for _ in 0..num_responses {
+            let nonce_response = b"HTTP/1.1 200 OK\n\n{\"nonce\":1,\"balance\":\"0x00000000000000000000000000000000\",\"locked\":\"0x00000000000000000000000000000000\",\"unlock_height\":0}";
+            let test_config = TestConfig::from_config(config.clone());
+            write_response(test_config.mock_server, nonce_response);
+        }
+    }
+
+    #[test]
+    fn filter_out_invalid_transactions() {
+        // Create a runloop of a valid signer
+        let config = Config::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
+        let mut valid_signer_runloop: RunLoop<FireCoordinator<v2::Aggregator>> =
+            RunLoop::from(&config);
+
+        let signer_private_key = config.stacks_private_key;
+        let non_signer_private_key = StacksPrivateKey::new();
+        let signers_contract_addr = boot_code_addr(false);
+        // Create a valid transaction signed by the signer private key coresponding to the slot into which it is being inserted (signer id 0)
+        // TODO use cast_aggregate_vote_tx fn to create a valid transaction when it is implmented and update this test
+        let valid_tx = StacksClient::build_signed_contract_call_transaction(
+            &signers_contract_addr,
+            SIGNERS_VOTING_NAME.into(),
+            "fake-function".into(),
+            &[],
+            &signer_private_key,
+            TransactionVersion::Testnet,
+            config.network.to_chain_id(),
+            1,
+            10,
+        )
+        .unwrap();
+        let invalid_tx_bad_signer = StacksClient::build_signed_contract_call_transaction(
+            &signers_contract_addr,
+            SIGNERS_VOTING_NAME.into(),
+            "fake-function".into(),
+            &[],
+            &non_signer_private_key,
+            TransactionVersion::Testnet,
+            config.network.to_chain_id(),
+            0,
+            10,
+        )
+        .unwrap();
+        let invalid_tx_outdated_nonce = StacksClient::build_signed_contract_call_transaction(
+            &signers_contract_addr,
+            SIGNERS_VOTING_NAME.into(),
+            "fake-function".into(),
+            &[],
+            &signer_private_key,
+            TransactionVersion::Testnet,
+            config.network.to_chain_id(),
+            0,
+            5,
+        )
+        .unwrap();
+
+        let transactions = vec![
+            valid_tx.clone(),
+            invalid_tx_outdated_nonce,
+            invalid_tx_bad_signer,
+        ];
+        let num_transactions = transactions.len();
+        let h = spawn(move || {
+            valid_signer_runloop.initialize().unwrap();
+            valid_signer_runloop.filter_out_invalid_transactions(transactions)
+        });
+
+        // Must initialize the signers before attempting to retrieve their transactions
+        simulate_initialize_response(config.clone());
+        simulate_get_account_nonce_response(config, num_transactions);
+
+        let filtered_txs = h.join().unwrap();
+        assert_eq!(filtered_txs, vec![valid_tx]);
+    }
 }

From c5102b1afd4f6200dd4a62066b27caf3c6846ea0 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Thu, 1 Feb 2024 15:38:02 -0800
Subject: [PATCH 0616/1166] Add tests to filtering of invalid transactions

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/stackerdb.rs |  10 ++-
 stacks-signer/src/runloop.rs          | 108 ++++++++++++++------------
 2 files changed, 68 insertions(+), 50 deletions(-)

diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index dc87597e64..eedd5f3b5e 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -202,7 +202,7 @@ mod tests {
         let signer_message = SignerMessage::Transactions(vec![tx.clone()]);
         let message = signer_message.serialize_to_vec();
 
-        let signer_ids = vec![0];
+        let signer_ids = vec![0, 1];
         let h = spawn(move || {
             config
                 .stackerdb
@@ -211,6 +211,14 @@ mod tests {
         let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
         response_bytes.extend(message);
         write_response(config.mock_server, response_bytes.as_slice());
+
+        let signer_message = SignerMessage::Transactions(vec![]);
+        let message = signer_message.serialize_to_vec();
+        let test_config = TestConfig::from_config(config.config);
+        let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
+        response_bytes.extend(message);
+        write_response(test_config.mock_server, response_bytes.as_slice());
+
         let transactions = h.join().unwrap().unwrap();
         assert_eq!(transactions, vec![tx]);
     }
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 9aea89b74b..35c780a4fb 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -544,31 +544,6 @@ impl<C: Coordinator> RunLoop<C> {
         }
     }
 
-    /// Filter out invalid transactions from the list of transactions
-    fn filter_out_invalid_transactions(
-        &self,
-        proposed_transactions: Vec<StacksTransaction>,
-    ) -> Vec<StacksTransaction> {
-        let mut expected_transactions = vec![];
-        for transaction in proposed_transactions {
-            // TODO: Filter out transactions that are not special cased transactions (cast votes, etc.)
-            // Filter out transactions that have already been confirmed (can happen if a signer did not update stacker db since the last block was processed)
-            let origin_address = transaction.origin_address();
-            let origin_nonce = transaction.get_origin_nonce();
-            let Ok(account_nonce) = self.stacks_client.get_account_nonce(&origin_address) else {
-                warn!("Unable to get account for address: {origin_address}. Ignoring it for this block...");
-                continue;
-            };
-            if !self.signer_addresses.contains(&origin_address) || origin_nonce < account_nonce {
-                debug!("Received a transaction for signer id that is either not valid or has already been confirmed. Ignoring it.");
-                continue;
-            } else {
-                expected_transactions.push(transaction);
-            }
-        }
-        expected_transactions
-    }
-
     /// Get the transactions we expect to see in the next block
     fn get_expected_transactions(&mut self) -> Result<Vec<StacksTransaction>, ClientError> {
         let signer_ids = self
@@ -580,8 +555,22 @@ impl<C: Coordinator> RunLoop<C> {
             .collect::<Vec<_>>();
         let transactions = self
             .stackerdb
-            .get_signer_transactions_with_retry(&signer_ids)?;
-        Ok(self.filter_out_invalid_transactions(transactions))
+            .get_signer_transactions_with_retry(&signer_ids)?.into_iter().filter_map(|transaction| {
+                // TODO: Filter out transactions that are not special cased transactions (cast votes, etc.)
+                // Filter out transactions that have already been confirmed (can happen if a signer did not update stacker db since the last block was processed)
+                let origin_address = transaction.origin_address();
+                let origin_nonce = transaction.get_origin_nonce();
+                let Ok(account_nonce) = self.stacks_client.get_account_nonce(&origin_address) else {
+                    warn!("Unable to get account for address: {origin_address}. Ignoring it for this block...");
+                    return None;
+                };
+                if !self.signer_addresses.contains(&origin_address) || origin_nonce < account_nonce {
+                    debug!("Received a transaction for signer id that is either not valid or has already been confirmed. Ignoring it.");
+                    return None;
+                }
+                Some(transaction)
+            }).collect();
+        Ok(transactions)
     }
 
     /// Determine the vote for a block and update the block info and nonce request accordingly
@@ -1189,25 +1178,8 @@ mod tests {
         write_response(test_config.mock_server, signer_slots_response.as_bytes());
     }
 
-    #[allow(dead_code)]
-    fn simulate_get_transactions_response(config: Config) {
-        let (current_reward_cycle_response, aggregate_key_response) =
-            build_get_aggregate_public_key_response_some();
-        let signer_slots_response = build_get_signer_slots_response(&config);
-        let test_config = TestConfig::from_config(config.clone());
-        write_response(
-            test_config.mock_server,
-            current_reward_cycle_response.as_bytes(),
-        );
-        let test_config = TestConfig::from_config(config.clone());
-        write_response(test_config.mock_server, aggregate_key_response.as_bytes());
-
-        let test_config = TestConfig::from_config(config);
-        write_response(test_config.mock_server, signer_slots_response.as_bytes());
-    }
-
-    fn simulate_get_account_nonce_response(config: Config, num_responses: usize) {
-        for _ in 0..num_responses {
+    fn simulate_nonce_response(config: &Config, num_transactions: usize) {
+        for _ in 0..num_transactions {
             let nonce_response = b"HTTP/1.1 200 OK\n\n{\"nonce\":1,\"balance\":\"0x00000000000000000000000000000000\",\"locked\":\"0x00000000000000000000000000000000\",\"unlock_height\":0}";
             let test_config = TestConfig::from_config(config.clone());
             write_response(test_config.mock_server, nonce_response);
@@ -1215,7 +1187,7 @@ mod tests {
     }
 
     #[test]
-    fn filter_out_invalid_transactions() {
+    fn get_expected_transactions_should_filter_invalid_transactions() {
         // Create a runloop of a valid signer
         let config = Config::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
         let mut valid_signer_runloop: RunLoop<FireCoordinator<v2::Aggregator>> =
@@ -1269,14 +1241,52 @@ mod tests {
             invalid_tx_bad_signer,
         ];
         let num_transactions = transactions.len();
+
         let h = spawn(move || {
             valid_signer_runloop.initialize().unwrap();
-            valid_signer_runloop.filter_out_invalid_transactions(transactions)
+            valid_signer_runloop.get_expected_transactions().unwrap()
         });
 
         // Must initialize the signers before attempting to retrieve their transactions
         simulate_initialize_response(config.clone());
-        simulate_get_account_nonce_response(config, num_transactions);
+
+        // Simulate the response to the request for transactions
+        let signer_message = SignerMessage::Transactions(transactions);
+        let message = signer_message.serialize_to_vec();
+        let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
+        response_bytes.extend(message);
+        let test_config = TestConfig::from_config(config.clone());
+        write_response(test_config.mock_server, response_bytes.as_slice());
+
+        let signer_message = SignerMessage::Transactions(vec![]);
+        let message = signer_message.serialize_to_vec();
+        let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
+        response_bytes.extend(message);
+        let test_config = TestConfig::from_config(config.clone());
+        write_response(test_config.mock_server, response_bytes.as_slice());
+
+        let signer_message = SignerMessage::Transactions(vec![]);
+        let message = signer_message.serialize_to_vec();
+        let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
+        response_bytes.extend(message);
+        let test_config = TestConfig::from_config(config.clone());
+        write_response(test_config.mock_server, response_bytes.as_slice());
+
+        let signer_message = SignerMessage::Transactions(vec![]);
+        let message = signer_message.serialize_to_vec();
+        let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
+        response_bytes.extend(message);
+        let test_config = TestConfig::from_config(config.clone());
+        write_response(test_config.mock_server, response_bytes.as_slice());
+
+        let signer_message = SignerMessage::Transactions(vec![]);
+        let message = signer_message.serialize_to_vec();
+        let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
+        response_bytes.extend(message);
+        let test_config = TestConfig::from_config(config.clone());
+        write_response(test_config.mock_server, response_bytes.as_slice());
+
+        simulate_nonce_response(&config, num_transactions);
 
         let filtered_txs = h.join().unwrap();
         assert_eq!(filtered_txs, vec![valid_tx]);

From 3c2f3a4baa5294c2e3b5893312cd7588eb388e6c Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Thu, 1 Feb 2024 16:42:03 -0800
Subject: [PATCH 0617/1166] Add verify transactions valid test

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/stackerdb.rs |  36 ++++++++
 stacks-signer/src/runloop.rs          | 118 +++++++++++++++++++++++++-
 2 files changed, 151 insertions(+), 3 deletions(-)

diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index eedd5f3b5e..2385ff4b85 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -222,4 +222,40 @@ mod tests {
         let transactions = h.join().unwrap().unwrap();
         assert_eq!(transactions, vec![tx]);
     }
+
+    #[test]
+    fn send_signer_message_with_retry_should_succeed() {
+        let mut config = TestConfig::new();
+        let sk = StacksPrivateKey::new();
+        let tx = StacksTransaction {
+            version: TransactionVersion::Testnet,
+            chain_id: 0,
+            auth: TransactionAuth::from_p2pkh(&sk).unwrap(),
+            anchor_mode: TransactionAnchorMode::Any,
+            post_condition_mode: TransactionPostConditionMode::Allow,
+            post_conditions: vec![],
+            payload: TransactionPayload::SmartContract(
+                TransactionSmartContract {
+                    name: "test-contract".into(),
+                    code_body: StacksString::from_str("(/ 1 0)").unwrap(),
+                },
+                None,
+            ),
+        };
+
+        let signer_message = SignerMessage::Transactions(vec![tx.clone()]);
+        let ack = StackerDBChunkAckData {
+            accepted: true,
+            reason: None,
+            metadata: None,
+        };
+
+        let h = spawn(move || config.stackerdb.send_message_with_retry(signer_message));
+
+        let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
+        let payload = serde_json::to_string(&ack).expect("Failed to serialize ack");
+        response_bytes.extend(payload.as_bytes());
+        write_response(config.mock_server, response_bytes.as_slice());
+        assert_eq!(ack, h.join().unwrap().unwrap());
+    }
 }
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 35c780a4fb..fec71d3151 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -986,16 +986,21 @@ mod tests {
     use std::net::TcpListener;
     use std::thread::{sleep, spawn};
 
+    use blockstack_lib::chainstate::nakamoto::NakamotoBlockHeader;
     use blockstack_lib::chainstate::stacks::boot::SIGNERS_VOTING_NAME;
-    use blockstack_lib::chainstate::stacks::TransactionVersion;
+    use blockstack_lib::chainstate::stacks::{ThresholdSignature, TransactionVersion};
     use blockstack_lib::util_lib::boot::boot_code_addr;
     use clarity::vm::types::{ResponseData, TupleData};
     use clarity::vm::{ClarityName, Value as ClarityValue};
     use libsigner::SIGNER_SLOTS_PER_USER;
     use rand::distributions::Standard;
     use rand::Rng;
-    use stacks_common::types::chainstate::StacksPrivateKey;
-    use stacks_common::util::hash::Hash160;
+    use stacks_common::bitvec::BitVec;
+    use stacks_common::types::chainstate::{
+        ConsensusHash, StacksBlockId, StacksPrivateKey, TrieHash,
+    };
+    use stacks_common::util::hash::{Hash160, MerkleTree};
+    use stacks_common::util::secp256k1::MessageSignature;
     use wsts::curve::point::Point;
     use wsts::curve::scalar::Scalar;
 
@@ -1291,4 +1296,111 @@ mod tests {
         let filtered_txs = h.join().unwrap();
         assert_eq!(filtered_txs, vec![valid_tx]);
     }
+
+    #[test]
+    fn verify_transactions_valid() {
+        let config = Config::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
+        let mut runloop: RunLoop<FireCoordinator<v2::Aggregator>> = RunLoop::from(&config);
+
+        let signer_private_key = config.stacks_private_key;
+        let signers_contract_addr = boot_code_addr(false);
+        // Create a valid transaction signed by the signer private key coresponding to the slot into which it is being inserted (signer id 0)
+        // TODO use cast_aggregate_vote_tx fn to create a valid transaction when it is implmented and update this test
+        let valid_tx = StacksClient::build_signed_contract_call_transaction(
+            &signers_contract_addr,
+            SIGNERS_VOTING_NAME.into(),
+            "fake-function".into(),
+            &[],
+            &signer_private_key,
+            TransactionVersion::Testnet,
+            config.network.to_chain_id(),
+            1,
+            10,
+        )
+        .unwrap();
+
+        // Create a block
+        let header = NakamotoBlockHeader {
+            version: 1,
+            chain_length: 2,
+            burn_spent: 3,
+            consensus_hash: ConsensusHash([0x04; 20]),
+            parent_block_id: StacksBlockId([0x05; 32]),
+            tx_merkle_root: Sha512Trunc256Sum([0x06; 32]),
+            state_index_root: TrieHash([0x07; 32]),
+            miner_signature: MessageSignature::empty(),
+            signer_signature: ThresholdSignature::empty(),
+            signer_bitvec: BitVec::zeros(1).unwrap(),
+        };
+        let mut block = NakamotoBlock {
+            header,
+            txs: vec![valid_tx.clone()],
+        };
+        let tx_merkle_root = {
+            let txid_vecs = block
+                .txs
+                .iter()
+                .map(|tx| tx.txid().as_bytes().to_vec())
+                .collect();
+
+            MerkleTree::<Sha512Trunc256Sum>::new(&txid_vecs).root()
+        };
+        block.header.tx_merkle_root = tx_merkle_root;
+
+        // Ensure this is a block the signer has seen already
+        runloop.blocks.insert(
+            block.header.signer_signature_hash(),
+            BlockInfo::new(block.clone()),
+        );
+
+        let h = spawn(move || {
+            runloop.initialize().unwrap();
+            runloop.verify_transactions(&block)
+        });
+
+        // Must initialize the signers before attempting to retrieve their transactions
+        simulate_initialize_response(config.clone());
+
+        // Simulate the response to the request for transactions with the expected transaction
+        let signer_message = SignerMessage::Transactions(vec![valid_tx]);
+        let message = bincode::serialize(&signer_message).unwrap();
+        let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
+        response_bytes.extend(message);
+        let test_config = TestConfig::from_config(config.clone());
+        write_response(test_config.mock_server, response_bytes.as_slice());
+
+        let signer_message = SignerMessage::Transactions(vec![]);
+        let message = bincode::serialize(&signer_message).unwrap();
+        let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
+        response_bytes.extend(message);
+        let test_config = TestConfig::from_config(config.clone());
+        write_response(test_config.mock_server, response_bytes.as_slice());
+
+        let signer_message = SignerMessage::Transactions(vec![]);
+        let message = bincode::serialize(&signer_message).unwrap();
+        let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
+        response_bytes.extend(message);
+        let test_config = TestConfig::from_config(config.clone());
+        write_response(test_config.mock_server, response_bytes.as_slice());
+
+        let signer_message = SignerMessage::Transactions(vec![]);
+        let message = bincode::serialize(&signer_message).unwrap();
+        let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
+        response_bytes.extend(message);
+        let test_config = TestConfig::from_config(config.clone());
+        write_response(test_config.mock_server, response_bytes.as_slice());
+
+        let signer_message = SignerMessage::Transactions(vec![]);
+        let message = bincode::serialize(&signer_message).unwrap();
+        let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
+        response_bytes.extend(message);
+        let test_config = TestConfig::from_config(config.clone());
+        write_response(test_config.mock_server, response_bytes.as_slice());
+
+        simulate_nonce_response(&config, 1);
+        //simulate_send_message_with_retry_response(config.clone());
+
+        let valid = h.join().unwrap();
+        assert!(valid);
+    }
 }

From c9f38f66f26b5fc42026f7f1fd6f8f8b760d4269 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 2 Feb 2024 14:50:09 -0800
Subject: [PATCH 0618/1166] CRC: cleanup nits and test failures due to clarity
 changes

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/Cargo.toml                  |  1 +
 stacks-signer/src/client/stackerdb.rs     | 45 ++++++++++++-----------
 stacks-signer/src/client/stacks_client.rs | 16 ++++----
 stacks-signer/src/runloop.rs              | 12 +++---
 stacks-signer/src/utils.rs                | 16 ++------
 5 files changed, 41 insertions(+), 49 deletions(-)

diff --git a/stacks-signer/Cargo.toml b/stacks-signer/Cargo.toml
index e37c5b4552..5c65c43397 100644
--- a/stacks-signer/Cargo.toml
+++ b/stacks-signer/Cargo.toml
@@ -50,3 +50,4 @@ features = ["arbitrary_precision", "unbounded_depth"]
 [dependencies.secp256k1]
 version = "0.24.3"
 features = ["serde", "recovery"]
+
diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index 2385ff4b85..771dc5ff6d 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -137,25 +137,27 @@ impl StackerDB {
         let chunk_ack = retry_with_exponential_backoff(send_request)?;
         let mut transactions = Vec::new();
         for (i, chunk) in chunk_ack.iter().enumerate() {
-            if let Some(data) = chunk {
-                if let Ok(message) = read_next::<SignerMessage, _>(&mut &data[..]) {
-                    if let SignerMessage::Transactions(chunk_transactions) = message {
-                        let signer_id = *signer_ids.get(i).expect(
-                            "BUG: retrieved an unequal amount of chunks to requested chunks",
-                        );
-                        debug!(
-                            "Retrieved {} transactions from signer ID {}.",
-                            chunk_transactions.len(),
-                            signer_id
-                        );
-                        transactions.extend(chunk_transactions);
-                    } else {
-                        warn!("Signer wrote an unexpected type to the transactions slot");
-                    }
-                } else {
-                    warn!("Failed to deserialize chunk data into a SignerMessage");
-                }
-            }
+            let signer_id = *signer_ids
+                .get(i)
+                .expect("BUG: retrieved an unequal amount of chunks to requested chunks");
+            let Some(data) = chunk else {
+                continue;
+            };
+            let Ok(message) = read_next::<SignerMessage, _>(&mut &data[..]) else {
+                warn!("Failed to deserialize chunk data into a SignerMessage");
+                continue;
+            };
+
+            let SignerMessage::Transactions(chunk_transactions) = message else {
+                warn!("Signer wrote an unexpected type to the transactions slot");
+                continue;
+            };
+            debug!(
+                "Retrieved {} transactions from signer ID {}.",
+                chunk_transactions.len(),
+                signer_id
+            );
+            transactions.extend(chunk_transactions);
         }
         Ok(transactions)
     }
@@ -249,12 +251,11 @@ mod tests {
             reason: None,
             metadata: None,
         };
-
-        let h = spawn(move || config.stackerdb.send_message_with_retry(signer_message));
-
         let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
         let payload = serde_json::to_string(&ack).expect("Failed to serialize ack");
         response_bytes.extend(payload.as_bytes());
+        let h = spawn(move || config.stackerdb.send_message_with_retry(signer_message));
+        std::thread::sleep(std::time::Duration::from_millis(100));
         write_response(config.mock_server, response_bytes.as_slice());
         assert_eq!(ack, h.join().unwrap().unwrap());
     }
diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index 14093db2ac..cb9573d830 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -293,7 +293,7 @@ impl StacksClient {
             let signer = if let PrincipalData::Standard(signer) = principal_data {
                 signer.into()
             } else {
-                panic!("Invalid signer data type")
+                panic!("BUG: Signers stackerdb contract is corrupted");
             };
             let num_slots = tuple_data.get("num-slots")?.clone().expect_u128()?;
             signer_slots.push((signer, num_slots));
@@ -493,13 +493,14 @@ mod tests {
 
     use super::*;
     use crate::client::tests::{write_response, TestConfig};
-    use crate::client::ClientError;
 
     #[test]
     fn read_only_contract_call_200_success() {
         let config = TestConfig::new();
         let value = ClarityValue::UInt(10_u128);
-        let hex = value.to_string();
+        let hex = value
+            .serialize_to_hex()
+            .expect("Failed to serialize hex value");
         let response_bytes = format!("HTTP/1.1 200 OK\n\n{{\"okay\":true,\"result\":\"{hex}\"}}",);
         let h = spawn(move || {
             config.client.read_only_contract_call_with_retry(
@@ -518,7 +519,9 @@ mod tests {
     fn read_only_contract_call_with_function_args_200_success() {
         let config = TestConfig::new();
         let value = ClarityValue::UInt(10_u128);
-        let hex = value.to_string();
+        let hex = value
+            .serialize_to_hex()
+            .expect("Failed to serialize hex value");
         let response_bytes = format!("HTTP/1.1 200 OK\n\n{{\"okay\":true,\"result\":\"{hex}\"}}",);
         let h = spawn(move || {
             config.client.read_only_contract_call_with_retry(
@@ -697,10 +700,7 @@ mod tests {
         let config = TestConfig::new();
         let value = ClarityValue::UInt(10_u128);
         let result = config.client.parse_aggregate_public_key(value);
-        assert!(matches!(
-            result,
-            Err(ClientError::ClaritySerializationError(..))
-        ));
+        assert!(result.is_err())
     }
 
     #[ignore]
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index fec71d3151..69b820b298 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -289,7 +289,7 @@ impl<C: Coordinator> RunLoop<C> {
                 block_info.valid = Some(false);
                 // Submit a rejection response to the .signers contract for miners
                 // to observe so they know to send another block and to prove signers are doing work);
-                debug!("Broadcasting a block rejection due to stacks node validation failure...");
+                warn!("Broadcasting a block rejection due to stacks node validation failure...");
                 if let Err(e) = self
                     .stackerdb
                     .send_message_with_retry(block_validate_reject.into())
@@ -1363,35 +1363,35 @@ mod tests {
 
         // Simulate the response to the request for transactions with the expected transaction
         let signer_message = SignerMessage::Transactions(vec![valid_tx]);
-        let message = bincode::serialize(&signer_message).unwrap();
+        let message = signer_message.serialize_to_vec();
         let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
         response_bytes.extend(message);
         let test_config = TestConfig::from_config(config.clone());
         write_response(test_config.mock_server, response_bytes.as_slice());
 
         let signer_message = SignerMessage::Transactions(vec![]);
-        let message = bincode::serialize(&signer_message).unwrap();
+        let message = signer_message.serialize_to_vec();
         let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
         response_bytes.extend(message);
         let test_config = TestConfig::from_config(config.clone());
         write_response(test_config.mock_server, response_bytes.as_slice());
 
         let signer_message = SignerMessage::Transactions(vec![]);
-        let message = bincode::serialize(&signer_message).unwrap();
+        let message = signer_message.serialize_to_vec();
         let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
         response_bytes.extend(message);
         let test_config = TestConfig::from_config(config.clone());
         write_response(test_config.mock_server, response_bytes.as_slice());
 
         let signer_message = SignerMessage::Transactions(vec![]);
-        let message = bincode::serialize(&signer_message).unwrap();
+        let message = signer_message.serialize_to_vec();
         let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
         response_bytes.extend(message);
         let test_config = TestConfig::from_config(config.clone());
         write_response(test_config.mock_server, response_bytes.as_slice());
 
         let signer_message = SignerMessage::Transactions(vec![]);
-        let message = bincode::serialize(&signer_message).unwrap();
+        let message = signer_message.serialize_to_vec();
         let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
         response_bytes.extend(message);
         let test_config = TestConfig::from_config(config.clone());
diff --git a/stacks-signer/src/utils.rs b/stacks-signer/src/utils.rs
index 18b374778b..15e5c8110b 100644
--- a/stacks-signer/src/utils.rs
+++ b/stacks-signer/src/utils.rs
@@ -16,9 +16,6 @@
 use std::time::Duration;
 
 use slog::slog_debug;
-use stacks_common::address::{
-    AddressHashMode, C32_ADDRESS_VERSION_MAINNET_SINGLESIG, C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
-};
 use stacks_common::debug;
 use stacks_common::types::chainstate::{StacksAddress, StacksPrivateKey, StacksPublicKey};
 use stacks_common::types::PrivateKey;
@@ -146,15 +143,8 @@ pub fn build_stackerdb_contract(
 
 /// Helper function to convert a private key to a Stacks address
 pub fn to_addr(stacks_private_key: &StacksPrivateKey, network: &Network) -> StacksAddress {
-    let version = match network {
-        Network::Mainnet => C32_ADDRESS_VERSION_MAINNET_SINGLESIG,
-        Network::Testnet | Network::Mocknet => C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
-    };
-    StacksAddress::from_public_keys(
-        version,
-        &AddressHashMode::SerializeP2PKH,
-        1,
-        &vec![StacksPublicKey::from_private(stacks_private_key)],
+    StacksAddress::p2pkh(
+        network.is_mainnet(),
+        &StacksPublicKey::from_private(stacks_private_key),
     )
-    .expect("BUG: failed to generate address from private key")
 }

From 4440414fb31515446366360510bda20b193638b5 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 2 Feb 2024 16:54:10 -0800
Subject: [PATCH 0619/1166] Cleanup RejectCode serde and fix tmissing
 transactions test

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 libsigner/src/messages.rs               | 255 +++++++++++++-----------
 testnet/stacks-node/src/tests/signer.rs |   9 +-
 2 files changed, 139 insertions(+), 125 deletions(-)

diff --git a/libsigner/src/messages.rs b/libsigner/src/messages.rs
index e40970c59d..477712b224 100644
--- a/libsigner/src/messages.rs
+++ b/libsigner/src/messages.rs
@@ -74,55 +74,95 @@ pub const BLOCK_SLOT_ID: u32 = 10;
 /// The slot ID for the transactions list for miners and signers to observe
 pub const TRANSACTIONS_SLOT_ID: u32 = 11;
 
-define_u8_enum!(TypePrefix {
+define_u8_enum!(SignerMessageTypePrefix {
     BlockResponse = 0,
     Packet = 1,
-    Transactions = 2,
-    DkgBegin = 3,
-    DkgPrivateBegin = 4,
-    DkgEndBegin = 5,
-    DkgEnd = 6,
-    DkgPublicShares = 7,
-    DkgPrivateShares = 8,
-    NonceRequest = 9,
-    NonceResponse = 10,
-    SignatureShareRequest = 11,
-    SignatureShareResponse = 12,
-    DkgStatusSuccess = 13,
-    DkgStatusFailure = 14
+    Transactions = 2
 });
 
-impl TryFrom<u8> for TypePrefix {
+impl TryFrom<u8> for SignerMessageTypePrefix {
     type Error = CodecError;
     fn try_from(value: u8) -> Result<Self, Self::Error> {
-        Self::from_u8(value)
-            .ok_or_else(|| CodecError::DeserializeError(format!("Unknown type prefix: {value}")))
+        Self::from_u8(value).ok_or_else(|| {
+            CodecError::DeserializeError(format!("Unknown signer message type prefix: {value}"))
+        })
     }
 }
 
-impl From<&SignerMessage> for TypePrefix {
+impl From<&SignerMessage> for SignerMessageTypePrefix {
     fn from(message: &SignerMessage) -> Self {
         match message {
-            SignerMessage::Packet(_) => TypePrefix::Packet,
-            SignerMessage::BlockResponse(_) => TypePrefix::BlockResponse,
-            SignerMessage::Transactions(_) => TypePrefix::Transactions,
+            SignerMessage::Packet(_) => SignerMessageTypePrefix::Packet,
+            SignerMessage::BlockResponse(_) => SignerMessageTypePrefix::BlockResponse,
+            SignerMessage::Transactions(_) => SignerMessageTypePrefix::Transactions,
         }
     }
 }
 
-impl From<&Packet> for TypePrefix {
-    fn from(packet: &Packet) -> Self {
-        match packet.msg {
-            Message::DkgBegin(_) => TypePrefix::DkgBegin,
-            Message::DkgPrivateBegin(_) => TypePrefix::DkgPrivateBegin,
-            Message::DkgEndBegin(_) => TypePrefix::DkgEndBegin,
-            Message::DkgEnd(_) => TypePrefix::DkgEnd,
-            Message::DkgPublicShares(_) => TypePrefix::DkgPublicShares,
-            Message::DkgPrivateShares(_) => TypePrefix::DkgPrivateShares,
-            Message::NonceRequest(_) => TypePrefix::NonceRequest,
-            Message::NonceResponse(_) => TypePrefix::NonceResponse,
-            Message::SignatureShareRequest(_) => TypePrefix::SignatureShareRequest,
-            Message::SignatureShareResponse(_) => TypePrefix::SignatureShareResponse,
+define_u8_enum!(MessageTypePrefix {
+    DkgBegin = 0,
+    DkgPrivateBegin = 1,
+    DkgEndBegin = 2,
+    DkgEnd = 3,
+    DkgPublicShares = 4,
+    DkgPrivateShares = 5,
+    NonceRequest = 6,
+    NonceResponse = 7,
+    SignatureShareRequest = 8,
+    SignatureShareResponse = 9
+});
+
+impl From<&Message> for MessageTypePrefix {
+    fn from(msg: &Message) -> Self {
+        match msg {
+            Message::DkgBegin(_) => MessageTypePrefix::DkgBegin,
+            Message::DkgPrivateBegin(_) => MessageTypePrefix::DkgPrivateBegin,
+            Message::DkgEndBegin(_) => MessageTypePrefix::DkgEndBegin,
+            Message::DkgEnd(_) => MessageTypePrefix::DkgEnd,
+            Message::DkgPublicShares(_) => MessageTypePrefix::DkgPublicShares,
+            Message::DkgPrivateShares(_) => MessageTypePrefix::DkgPrivateShares,
+            Message::NonceRequest(_) => MessageTypePrefix::NonceRequest,
+            Message::NonceResponse(_) => MessageTypePrefix::NonceResponse,
+            Message::SignatureShareRequest(_) => MessageTypePrefix::SignatureShareRequest,
+            Message::SignatureShareResponse(_) => MessageTypePrefix::SignatureShareResponse,
+        }
+    }
+}
+
+impl TryFrom<u8> for MessageTypePrefix {
+    type Error = CodecError;
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        Self::from_u8(value).ok_or_else(|| {
+            CodecError::DeserializeError(format!("Unknown packet type prefix: {value}"))
+        })
+    }
+}
+
+define_u8_enum!(RejectCodeTypePrefix{
+    ValidationFailed = 0,
+    SignedRejection = 1,
+    InsufficientSigners = 2,
+    MissingTransactions = 3,
+    ConnectivityIssues = 4
+});
+
+impl TryFrom<u8> for RejectCodeTypePrefix {
+    type Error = CodecError;
+    fn try_from(value: u8) -> Result<Self, Self::Error> {
+        Self::from_u8(value).ok_or_else(|| {
+            CodecError::DeserializeError(format!("Unknown reject code type prefix: {value}"))
+        })
+    }
+}
+
+impl From<&RejectCode> for RejectCodeTypePrefix {
+    fn from(reject_code: &RejectCode) -> Self {
+        match reject_code {
+            RejectCode::ValidationFailed(_) => RejectCodeTypePrefix::ValidationFailed,
+            RejectCode::SignedRejection(_) => RejectCodeTypePrefix::SignedRejection,
+            RejectCode::InsufficientSigners(_) => RejectCodeTypePrefix::InsufficientSigners,
+            RejectCode::MissingTransactions(_) => RejectCodeTypePrefix::MissingTransactions,
+            RejectCode::ConnectivityIssues => RejectCodeTypePrefix::ConnectivityIssues,
         }
     }
 }
@@ -140,7 +180,7 @@ pub enum SignerMessage {
 
 impl StacksMessageCodec for SignerMessage {
     fn consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), CodecError> {
-        write_next(fd, &(TypePrefix::from(self) as u8))?;
+        write_next(fd, &(SignerMessageTypePrefix::from(self) as u8))?;
         match self {
             SignerMessage::Packet(packet) => {
                 packet.inner_consensus_serialize(fd)?;
@@ -157,26 +197,20 @@ impl StacksMessageCodec for SignerMessage {
 
     fn consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, CodecError> {
         let type_prefix_byte = read_next::<u8, _>(fd)?;
-        let type_prefix = TypePrefix::try_from(type_prefix_byte)?;
+        let type_prefix = SignerMessageTypePrefix::try_from(type_prefix_byte)?;
         let message = match type_prefix {
-            TypePrefix::Packet => {
+            SignerMessageTypePrefix::Packet => {
                 let packet = Packet::inner_consensus_deserialize(fd)?;
                 SignerMessage::Packet(packet)
             }
-            TypePrefix::BlockResponse => {
+            SignerMessageTypePrefix::BlockResponse => {
                 let block_response = read_next::<BlockResponse, _>(fd)?;
                 SignerMessage::BlockResponse(block_response)
             }
-            TypePrefix::Transactions => {
+            SignerMessageTypePrefix::Transactions => {
                 let transactions = read_next::<Vec<StacksTransaction>, _>(fd)?;
                 SignerMessage::Transactions(transactions)
             }
-            _ => {
-                return Err(CodecError::DeserializeError(format!(
-                    "Unknown signer message type prefix: {}",
-                    type_prefix_byte
-                )))
-            }
         };
         Ok(message)
     }
@@ -562,6 +596,7 @@ impl StacksMessageCodecExtensions for SignatureShareResponse {
 
 impl StacksMessageCodecExtensions for Message {
     fn inner_consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), CodecError> {
+        write_next(fd, &(MessageTypePrefix::from(self) as u8))?;
         match self {
             Message::DkgBegin(dkg_begin) => {
                 dkg_begin.inner_consensus_serialize(fd)?;
@@ -599,40 +634,36 @@ impl StacksMessageCodecExtensions for Message {
 
     fn inner_consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, CodecError> {
         let type_prefix_byte = read_next::<u8, _>(fd)?;
-        let type_prefix = TypePrefix::try_from(type_prefix_byte)?;
+        let type_prefix = MessageTypePrefix::try_from(type_prefix_byte)?;
         let message = match type_prefix {
-            TypePrefix::DkgBegin => Message::DkgBegin(DkgBegin::inner_consensus_deserialize(fd)?),
-            TypePrefix::DkgPrivateBegin => {
+            MessageTypePrefix::DkgBegin => {
+                Message::DkgBegin(DkgBegin::inner_consensus_deserialize(fd)?)
+            }
+            MessageTypePrefix::DkgPrivateBegin => {
                 Message::DkgPrivateBegin(DkgPrivateBegin::inner_consensus_deserialize(fd)?)
             }
-            TypePrefix::DkgEndBegin => {
+            MessageTypePrefix::DkgEndBegin => {
                 Message::DkgEndBegin(DkgEndBegin::inner_consensus_deserialize(fd)?)
             }
-            TypePrefix::DkgEnd => Message::DkgEnd(DkgEnd::inner_consensus_deserialize(fd)?),
-            TypePrefix::DkgPublicShares => {
+            MessageTypePrefix::DkgEnd => Message::DkgEnd(DkgEnd::inner_consensus_deserialize(fd)?),
+            MessageTypePrefix::DkgPublicShares => {
                 Message::DkgPublicShares(DkgPublicShares::inner_consensus_deserialize(fd)?)
             }
-            TypePrefix::DkgPrivateShares => {
+            MessageTypePrefix::DkgPrivateShares => {
                 Message::DkgPrivateShares(DkgPrivateShares::inner_consensus_deserialize(fd)?)
             }
-            TypePrefix::NonceRequest => {
+            MessageTypePrefix::NonceRequest => {
                 Message::NonceRequest(NonceRequest::inner_consensus_deserialize(fd)?)
             }
-            TypePrefix::NonceResponse => {
+            MessageTypePrefix::NonceResponse => {
                 Message::NonceResponse(NonceResponse::inner_consensus_deserialize(fd)?)
             }
-            TypePrefix::SignatureShareRequest => Message::SignatureShareRequest(
+            MessageTypePrefix::SignatureShareRequest => Message::SignatureShareRequest(
                 SignatureShareRequest::inner_consensus_deserialize(fd)?,
             ),
-            TypePrefix::SignatureShareResponse => Message::SignatureShareResponse(
+            MessageTypePrefix::SignatureShareResponse => Message::SignatureShareResponse(
                 SignatureShareResponse::inner_consensus_deserialize(fd)?,
             ),
-            _ => {
-                return Err(CodecError::DeserializeError(format!(
-                    "Unknown message type prefix: {}",
-                    type_prefix_byte
-                )))
-            }
         };
         Ok(message)
     }
@@ -640,49 +671,13 @@ impl StacksMessageCodecExtensions for Message {
 
 impl StacksMessageCodecExtensions for Packet {
     fn inner_consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), CodecError> {
-        write_next(fd, &(TypePrefix::from(self) as u8))?;
         self.msg.inner_consensus_serialize(fd)?;
         write_next(fd, &self.sig)?;
         Ok(())
     }
 
     fn inner_consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, CodecError> {
-        let type_prefix_byte = read_next::<u8, _>(fd)?;
-        let type_prefix = TypePrefix::try_from(type_prefix_byte)?;
-        let msg = match type_prefix {
-            TypePrefix::DkgBegin => Message::DkgBegin(DkgBegin::inner_consensus_deserialize(fd)?),
-            TypePrefix::DkgPrivateBegin => {
-                Message::DkgPrivateBegin(DkgPrivateBegin::inner_consensus_deserialize(fd)?)
-            }
-            TypePrefix::DkgEndBegin => {
-                Message::DkgEndBegin(DkgEndBegin::inner_consensus_deserialize(fd)?)
-            }
-            TypePrefix::DkgEnd => Message::DkgEnd(DkgEnd::inner_consensus_deserialize(fd)?),
-            TypePrefix::DkgPublicShares => {
-                Message::DkgPublicShares(DkgPublicShares::inner_consensus_deserialize(fd)?)
-            }
-            TypePrefix::DkgPrivateShares => {
-                Message::DkgPrivateShares(DkgPrivateShares::inner_consensus_deserialize(fd)?)
-            }
-            TypePrefix::NonceRequest => {
-                Message::NonceRequest(NonceRequest::inner_consensus_deserialize(fd)?)
-            }
-            TypePrefix::NonceResponse => {
-                Message::NonceResponse(NonceResponse::inner_consensus_deserialize(fd)?)
-            }
-            TypePrefix::SignatureShareRequest => Message::SignatureShareRequest(
-                SignatureShareRequest::inner_consensus_deserialize(fd)?,
-            ),
-            TypePrefix::SignatureShareResponse => Message::SignatureShareResponse(
-                SignatureShareResponse::inner_consensus_deserialize(fd)?,
-            ),
-            _ => {
-                return Err(CodecError::DeserializeError(format!(
-                    "Unknown packet type prefix: {}",
-                    type_prefix_byte
-                )))
-            }
-        };
+        let msg = Message::inner_consensus_deserialize(fd)?;
         let sig: Vec<u8> = read_next(fd)?;
         Ok(Packet { msg, sig })
     }
@@ -823,21 +818,14 @@ pub enum RejectCode {
 
 impl StacksMessageCodec for RejectCode {
     fn consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), CodecError> {
+        write_next(fd, &(RejectCodeTypePrefix::from(self) as u8))?;
         match self {
-            RejectCode::ValidationFailed(code) => {
-                write_next(fd, &0u8)?;
-                write_next(fd, &(code.clone() as u8))?
-            }
-            RejectCode::SignedRejection(sig) => {
-                write_next(fd, &1u8)?;
-                write_next(fd, sig)?
-            }
+            RejectCode::ValidationFailed(code) => write_next(fd, &(code.clone() as u8))?,
+            RejectCode::SignedRejection(sig) => write_next(fd, sig)?,
             RejectCode::InsufficientSigners(malicious_signers) => {
-                write_next(fd, &2u8)?;
                 write_next(fd, malicious_signers)?
             }
             RejectCode::MissingTransactions(missing_transactions) => {
-                write_next(fd, &3u8)?;
                 write_next(fd, missing_transactions)?
             }
             RejectCode::ConnectivityIssues => write_next(fd, &4u8)?,
@@ -846,9 +834,10 @@ impl StacksMessageCodec for RejectCode {
     }
 
     fn consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, CodecError> {
-        let type_prefix = read_next::<u8, _>(fd)?;
+        let type_prefix_byte = read_next::<u8, _>(fd)?;
+        let type_prefix = RejectCodeTypePrefix::try_from(type_prefix_byte)?;
         let code = match type_prefix {
-            0 => RejectCode::ValidationFailed(
+            RejectCodeTypePrefix::ValidationFailed => RejectCode::ValidationFailed(
                 ValidateRejectCode::try_from(read_next::<u8, _>(fd)?).map_err(|e| {
                     CodecError::DeserializeError(format!(
                         "Failed to decode validation reject code: {:?}",
@@ -856,14 +845,16 @@ impl StacksMessageCodec for RejectCode {
                     ))
                 })?,
             ),
-            1 => RejectCode::SignedRejection(read_next::<ThresholdSignature, _>(fd)?),
-            2 => RejectCode::InsufficientSigners(read_next::<Vec<u32>, _>(fd)?),
-            _ => {
-                return Err(CodecError::DeserializeError(format!(
-                    "Unknown reject code type prefix: {}",
-                    type_prefix
-                )))
+            RejectCodeTypePrefix::SignedRejection => {
+                RejectCode::SignedRejection(read_next::<ThresholdSignature, _>(fd)?)
+            }
+            RejectCodeTypePrefix::InsufficientSigners => {
+                RejectCode::InsufficientSigners(read_next::<Vec<u32>, _>(fd)?)
             }
+            RejectCodeTypePrefix::MissingTransactions => {
+                RejectCode::MissingTransactions(read_next::<Vec<StacksTransaction>, _>(fd)?)
+            }
+            RejectCodeTypePrefix::ConnectivityIssues => RejectCode::ConnectivityIssues,
         };
         Ok(code)
     }
@@ -975,6 +966,34 @@ mod test {
         let deserialized_code = read_next::<RejectCode, _>(&mut &serialized_code[..])
             .expect("Failed to deserialize RejectCode");
         assert_eq!(code, deserialized_code);
+
+        let sk = StacksPrivateKey::new();
+        let tx = StacksTransaction {
+            version: TransactionVersion::Testnet,
+            chain_id: CHAIN_ID_TESTNET,
+            auth: TransactionAuth::from_p2pkh(&sk).unwrap(),
+            anchor_mode: TransactionAnchorMode::Any,
+            post_condition_mode: TransactionPostConditionMode::Allow,
+            post_conditions: vec![],
+            payload: TransactionPayload::SmartContract(
+                TransactionSmartContract {
+                    name: "test-contract".into(),
+                    code_body: StacksString::from_str("(/ 1 0)").unwrap(),
+                },
+                None,
+            ),
+        };
+        let code = RejectCode::MissingTransactions(vec![tx]);
+        let serialized_code = code.serialize_to_vec();
+        let deserialized_code = read_next::<RejectCode, _>(&mut &serialized_code[..])
+            .expect("Failed to deserialize RejectCode");
+        assert_eq!(code, deserialized_code);
+
+        let code = RejectCode::ConnectivityIssues;
+        let serialized_code = code.serialize_to_vec();
+        let deserialized_code = read_next::<RejectCode, _>(&mut &serialized_code[..])
+            .expect("Failed to deserialize RejectCode");
+        assert_eq!(code, deserialized_code);
     }
 
     #[test]
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index 88b2fb28ba..80b52d78bd 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -774,13 +774,8 @@ fn stackerdb_block_proposal_missing_transactions() {
     valid_tx.set_origin_nonce(0);
 
     // Create a transaction signed by a different private key
-    // This transaction will be invalid as it is signed by a different private key than the one that corresponds to the slot into which it is being inserted
-    let invalid_signer_id = 1;
-    let invalid_signer_private_key = signer_test
-        .signer_stacks_private_keys
-        .get(invalid_signer_id)
-        .expect("Cannot find signer private key for signer id 1")
-        .clone();
+    // This transaction will be invalid as it is signed by a non signer private key
+    let invalid_signer_private_key = StacksPrivateKey::new();
     let mut invalid_tx = StacksTransaction {
         version: TransactionVersion::Testnet,
         chain_id: 0,

From 61302a7892ce3a9a8533c1abac59f0c79392dd38 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Fri, 26 Jan 2024 15:57:39 -0600
Subject: [PATCH 0620/1166] feat: read reward set from state updated in
 .signers

---
 clarity/src/vm/database/clarity_db.rs         |  16 +
 clarity/src/vm/errors.rs                      |   1 +
 stackslib/src/chainstate/coordinator/mod.rs   |  70 +++-
 stackslib/src/chainstate/coordinator/tests.rs |  11 +
 .../chainstate/nakamoto/coordinator/mod.rs    |  74 ++--
 .../chainstate/nakamoto/coordinator/tests.rs  |  57 ++-
 stackslib/src/chainstate/nakamoto/mod.rs      | 329 +++------------
 .../src/chainstate/nakamoto/signer_set.rs     | 386 ++++++++++++++++++
 .../src/chainstate/nakamoto/tests/mod.rs      |   8 +-
 .../src/chainstate/nakamoto/tests/node.rs     |  16 +
 stackslib/src/chainstate/stacks/boot/mod.rs   |  75 +---
 .../src/chainstate/stacks/boot/signers.clar   |   5 +-
 .../chainstate/stacks/boot/signers_tests.rs   |   4 +-
 .../stacks/boot/signers_voting_tests.rs       |   4 +-
 stackslib/src/chainstate/stacks/db/blocks.rs  |  23 +-
 15 files changed, 656 insertions(+), 423 deletions(-)
 create mode 100644 stackslib/src/chainstate/nakamoto/signer_set.rs

diff --git a/clarity/src/vm/database/clarity_db.rs b/clarity/src/vm/database/clarity_db.rs
index de4d5e0c47..45d60bb62b 100644
--- a/clarity/src/vm/database/clarity_db.rs
+++ b/clarity/src/vm/database/clarity_db.rs
@@ -619,6 +619,22 @@ impl<'a> ClarityDatabase<'a> {
             .map_err(|e| e.into())
     }
 
+    /// Set a metadata entry if it hasn't already been set, yielding
+    ///  a runtime error if it was. This should only be called by post-nakamoto
+    ///  contexts.
+    pub fn try_set_metadata(
+        &mut self,
+        contract_identifier: &QualifiedContractIdentifier,
+        key: &str,
+        data: &str,
+    ) -> Result<()> {
+        if self.store.has_metadata_entry(contract_identifier, key) {
+            Err(Error::Runtime(RuntimeErrorType::MetadataAlreadySet, None))
+        } else {
+            Ok(self.store.insert_metadata(contract_identifier, key, data))
+        }
+    }
+
     fn insert_metadata<T: ClaritySerializable>(
         &mut self,
         contract_identifier: &QualifiedContractIdentifier,
diff --git a/clarity/src/vm/errors.rs b/clarity/src/vm/errors.rs
index fb8808936a..55977ec6aa 100644
--- a/clarity/src/vm/errors.rs
+++ b/clarity/src/vm/errors.rs
@@ -102,6 +102,7 @@ pub enum RuntimeErrorType {
     UnwrapFailure,
     DefunctPoxContract,
     PoxAlreadyLocked,
+    MetadataAlreadySet,
 }
 
 #[derive(Debug, PartialEq)]
diff --git a/stackslib/src/chainstate/coordinator/mod.rs b/stackslib/src/chainstate/coordinator/mod.rs
index 85bfc83b48..3bc1f890a5 100644
--- a/stackslib/src/chainstate/coordinator/mod.rs
+++ b/stackslib/src/chainstate/coordinator/mod.rs
@@ -286,6 +286,15 @@ pub trait RewardSetProvider {
         sortdb: &SortitionDB,
         block_id: &StacksBlockId,
     ) -> Result<RewardSet, Error>;
+
+    fn get_reward_set_nakamoto(
+        &self,
+        cycle_start_burn_height: u64,
+        chainstate: &mut StacksChainState,
+        burnchain: &Burnchain,
+        sortdb: &SortitionDB,
+        block_id: &StacksBlockId,
+    ) -> Result<RewardSet, Error>;
 }
 
 pub struct OnChainRewardSetProvider<'a, T: BlockEventDispatcher>(pub Option<&'a T>);
@@ -312,6 +321,14 @@ impl<'a, T: BlockEventDispatcher> RewardSetProvider for OnChainRewardSetProvider
         let cycle = burnchain
             .block_height_to_reward_cycle(cycle_start_burn_height)
             .expect("FATAL: no reward cycle for burn height");
+        // `self.get_reward_set_nakamoto` reads the reward set from data written during
+        //   updates to .signers
+        // `self.get_reward_set_epoch2` reads the reward set from the `.pox-*` contract
+        //
+        //  Data **cannot** be read from `.signers` in epoch 2.5 because the write occurs
+        //   in the first block of the prepare phase, but the PoX anchor block is *before*
+        //   the prepare phase. Therefore
+
         let is_nakamoto_reward_set = match SortitionDB::get_stacks_epoch_by_epoch_id(
             sortdb.conn(),
             &StacksEpochId::Epoch30,
@@ -325,26 +342,22 @@ impl<'a, T: BlockEventDispatcher> RewardSetProvider for OnChainRewardSetProvider
             // if epoch-3.0 isn't defined, then never use a nakamoto reward set.
             None => false,
         };
-        let reward_set = if !is_nakamoto_reward_set {
-            // Stacks 2.x epoch
-            self.get_reward_set_epoch2(
-                cycle_start_burn_height,
-                chainstate,
-                burnchain,
-                sortdb,
-                block_id,
-                cur_epoch,
-            )?
-        } else {
-            // Nakamoto epoch
-            self.get_reward_set_nakamoto(
-                cycle_start_burn_height,
-                chainstate,
-                burnchain,
-                sortdb,
-                block_id,
-            )?
-        };
+
+        let reward_set = self.get_reward_set_epoch2(
+            cycle_start_burn_height,
+            chainstate,
+            burnchain,
+            sortdb,
+            block_id,
+            cur_epoch,
+        )?;
+
+        if is_nakamoto_reward_set {
+            if reward_set.signers.is_none() || reward_set.signers == Some(vec![]) {
+                error!("FATAL: Signer sets are empty in a reward set that will be used in nakamoto"; "reward_set" => ?reward_set);
+                return Err(Error::PoXAnchorBlockRequired);
+            }
+        }
 
         if let Some(dispatcher) = self.0 {
             dispatcher.announce_reward_set(&reward_set, block_id, cycle);
@@ -352,6 +365,23 @@ impl<'a, T: BlockEventDispatcher> RewardSetProvider for OnChainRewardSetProvider
 
         Ok(reward_set)
     }
+
+    fn get_reward_set_nakamoto(
+        &self,
+        cycle_start_burn_height: u64,
+        chainstate: &mut StacksChainState,
+        burnchain: &Burnchain,
+        sortdb: &SortitionDB,
+        block_id: &StacksBlockId,
+    ) -> Result<RewardSet, Error> {
+        self.read_reward_set_nakamoto(
+            cycle_start_burn_height,
+            chainstate,
+            burnchain,
+            sortdb,
+            block_id,
+        )
+    }
 }
 
 impl<'a, T: BlockEventDispatcher> OnChainRewardSetProvider<'a, T> {
diff --git a/stackslib/src/chainstate/coordinator/tests.rs b/stackslib/src/chainstate/coordinator/tests.rs
index b823545f30..2882bd2cd0 100644
--- a/stackslib/src/chainstate/coordinator/tests.rs
+++ b/stackslib/src/chainstate/coordinator/tests.rs
@@ -520,6 +520,17 @@ impl RewardSetProvider for StubbedRewardSetProvider {
             signers: None,
         })
     }
+
+    fn get_reward_set_nakamoto(
+        &self,
+        cycle_start_burn_height: u64,
+        chainstate: &mut StacksChainState,
+        burnchain: &Burnchain,
+        sortdb: &SortitionDB,
+        block_id: &StacksBlockId,
+    ) -> Result<RewardSet, CoordError> {
+        panic!("Stubbed reward set provider cannot be invoked in nakamoto")
+    }
 }
 
 fn make_reward_set_coordinator<'a>(
diff --git a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
index de145b6eec..c24ceca34f 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
@@ -17,6 +17,7 @@
 use std::collections::VecDeque;
 use std::sync::{Arc, Mutex};
 
+use clarity::vm::clarity::ClarityConnection;
 use clarity::vm::database::BurnStateDB;
 use clarity::vm::types::PrincipalData;
 use stacks_common::types::chainstate::{
@@ -40,7 +41,7 @@ use crate::chainstate::coordinator::{
     RewardSetProvider,
 };
 use crate::chainstate::nakamoto::NakamotoChainState;
-use crate::chainstate::stacks::boot::RewardSet;
+use crate::chainstate::stacks::boot::{RewardSet, SIGNERS_NAME};
 use crate::chainstate::stacks::db::{StacksBlockHeaderTypes, StacksChainState};
 use crate::chainstate::stacks::miner::{signal_mining_blocked, signal_mining_ready, MinerStatus};
 use crate::chainstate::stacks::Error as ChainstateError;
@@ -53,7 +54,8 @@ use crate::util_lib::db::Error as DBError;
 pub mod tests;
 
 impl<'a, T: BlockEventDispatcher> OnChainRewardSetProvider<'a, T> {
-    pub fn get_reward_set_nakamoto(
+    /// Read a reward_set written while updating .signers
+    pub fn read_reward_set_nakamoto(
         &self,
         cycle_start_burn_height: u64,
         chainstate: &mut StacksChainState,
@@ -61,51 +63,65 @@ impl<'a, T: BlockEventDispatcher> OnChainRewardSetProvider<'a, T> {
         sortdb: &SortitionDB,
         block_id: &StacksBlockId,
     ) -> Result<RewardSet, Error> {
-        // TODO: this method should read the .signers contract to get the reward set entries.
-        //   they will have been set via `NakamotoChainState::check_and_handle_prepare_phase_start()`.
         let cycle = burnchain
             .block_height_to_reward_cycle(cycle_start_burn_height)
             .expect("FATAL: no reward cycle for burn height");
+        // figure out the block ID
+        let Some(coinbase_height_of_calculation) = chainstate
+            .eval_boot_code_read_only(
+                sortdb,
+                block_id,
+                SIGNERS_NAME,
+                &format!("(map-get? cycle-set-height u{})", cycle),
+            )?
+            .expect_optional()
+            .map(|x| u64::try_from(x.expect_u128()).expect("FATAL: block height exceeded u64"))
+        else {
+            error!(
+                "The reward set was not written to .signers before it was needed by Nakamoto";
+                "cycle_number" => cycle,
+            );
+            return Err(Error::PoXAnchorBlockRequired);
+        };
 
-        let registered_addrs =
-            chainstate.get_reward_addresses_in_cycle(burnchain, sortdb, cycle, block_id)?;
-
-        let liquid_ustx = chainstate.get_liquid_ustx(block_id);
-
-        let (threshold, participation) = StacksChainState::get_reward_threshold_and_participation(
-            &burnchain.pox_constants,
-            &registered_addrs[..],
-            liquid_ustx,
-        );
+        let Some(reward_set_block) = NakamotoChainState::get_header_by_coinbase_height(
+            &mut chainstate.index_tx_begin()?,
+            block_id,
+            coinbase_height_of_calculation,
+        )?
+        else {
+            error!("Failed to find the block in which .signers was written");
+            return Err(Error::PoXAnchorBlockRequired);
+        };
 
-        let cur_epoch = SortitionDB::get_stacks_epoch(sortdb.conn(), cycle_start_burn_height)?
-            .expect(&format!(
-                "FATAL: no epoch defined for burn height {}",
-                cycle_start_burn_height
-            ));
+        let Some(reward_set) = NakamotoChainState::get_reward_set(
+            chainstate.db(),
+            &reward_set_block.index_block_hash(),
+        )?
+        else {
+            error!("No reward set stored at the block in which .signers was written");
+            return Err(Error::PoXAnchorBlockRequired);
+        };
 
         // This method should only ever called if the current reward cycle is a nakamoto reward cycle
         //  (i.e., its reward set is fetched for determining signer sets (and therefore agg keys).
         //  Non participation is fatal.
-        if participation == 0 {
+        if reward_set.rewarded_addresses.is_empty() {
             // no one is stacking
             error!("No PoX participation");
             return Err(Error::PoXAnchorBlockRequired);
         }
 
-        info!("PoX reward cycle threshold computed";
-              "burn_height" => cycle_start_burn_height,
-              "threshold" => threshold,
-              "participation" => participation,
-              "liquid_ustx" => liquid_ustx,
-              "registered_addrs" => registered_addrs.len());
+        info!(
+            "PoX reward set loaded from written block state";
+            "reward_set_block_id" => %reward_set_block.index_block_hash(),
+        );
 
-        let reward_set =
-            StacksChainState::make_reward_set(threshold, registered_addrs, cur_epoch.epoch_id);
         if reward_set.signers.is_none() {
             error!("FATAL: PoX reward set did not specify signer set in Nakamoto");
             return Err(Error::PoXAnchorBlockRequired);
         }
+
         Ok(reward_set)
     }
 }
@@ -286,7 +302,7 @@ pub fn get_nakamoto_reward_cycle_info<U: RewardSetProvider>(
         "first_prepare_sortition_id" => %first_sortition_id
     );
 
-    let reward_set = provider.get_reward_set(
+    let reward_set = provider.get_reward_set_nakamoto(
         reward_start_height,
         chain_state,
         burnchain,
diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index 551348bffc..5689bf1d29 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -56,7 +56,7 @@ use crate::util_lib::boot::boot_code_id;
 fn advance_to_nakamoto(
     peer: &mut TestPeer,
     test_signers: &TestSigners,
-    test_stackers: Vec<TestStacker>,
+    test_stackers: &[TestStacker],
 ) {
     let mut peer_nonce = 0;
     let private_key = peer.config.private_key.clone();
@@ -68,6 +68,10 @@ fn advance_to_nakamoto(
     )
     .unwrap();
 
+    // use the signing key of addr, otherwise the test stackers
+    //  will not stack enough for any single signing key
+    // let signing_key = StacksPublicKey::from_private(&private_key);
+
     for sortition_height in 0..11 {
         // stack to pox-3 in cycle 7
         let txs = if sortition_height == 6 {
@@ -75,6 +79,8 @@ fn advance_to_nakamoto(
             test_stackers
                 .iter()
                 .map(|test_stacker| {
+                    let signing_key =
+                        StacksPublicKey::from_private(&test_stacker.signer_private_key);
                     make_pox_4_lockup(
                         &test_stacker.stacker_private_key,
                         0,
@@ -84,7 +90,7 @@ fn advance_to_nakamoto(
                             addr.bytes.clone(),
                         ),
                         12,
-                        StacksPublicKey::from_private(&test_stacker.signer_private_key),
+                        signing_key,
                         34,
                     )
                 })
@@ -104,7 +110,7 @@ pub fn boot_nakamoto<'a>(
     test_name: &str,
     mut initial_balances: Vec<(PrincipalData, u64)>,
     test_signers: &TestSigners,
-    test_stackers: Option<Vec<&TestStacker>>,
+    test_stackers: &[TestStacker],
     observer: Option<&'a TestEventObserver>,
 ) -> TestPeer<'a> {
     let aggregate_public_key = test_signers.aggregate_public_key.clone();
@@ -129,23 +135,6 @@ pub fn boot_nakamoto<'a>(
     peer_config.epochs = Some(StacksEpoch::unit_test_3_0_only(37));
     peer_config.initial_balances = vec![(addr.to_account_principal(), 1_000_000_000_000_000_000)];
 
-    let test_stackers: Vec<TestStacker> = if let Some(stackers) = test_stackers {
-        stackers.into_iter().cloned().collect()
-    } else {
-        // Create a list of test Stackers and their signer keys
-        (0..test_signers.num_keys)
-            .map(|index| {
-                let stacker_private_key = StacksPrivateKey::from_seed(&index.to_be_bytes());
-                let signer_private_key = StacksPrivateKey::from_seed(&index.to_be_bytes());
-                TestStacker {
-                    stacker_private_key,
-                    signer_private_key,
-                    amount: 1_000_000_000_000_000_000,
-                }
-            })
-            .collect()
-    };
-
     // Create some balances for test Stackers
     let mut stacker_balances = test_stackers
         .iter()
@@ -163,7 +152,7 @@ pub fn boot_nakamoto<'a>(
     peer_config.burnchain.pox_constants.pox_3_activation_height = 26;
     peer_config.burnchain.pox_constants.v3_unlock_height = 27;
     peer_config.burnchain.pox_constants.pox_4_activation_height = 31;
-    peer_config.test_stackers = Some(test_stackers.clone());
+    peer_config.test_stackers = Some(test_stackers.to_vec());
     let mut peer = TestPeer::new_with_observer(peer_config, observer);
 
     advance_to_nakamoto(&mut peer, &test_signers, test_stackers);
@@ -182,7 +171,11 @@ fn make_replay_peer<'a>(peer: &mut TestPeer<'a>) -> TestPeer<'a> {
     let test_stackers = replay_config.test_stackers.clone().unwrap_or(vec![]);
     let mut replay_peer = TestPeer::new(replay_config);
     let observer = TestEventObserver::new();
-    advance_to_nakamoto(&mut replay_peer, &TestSigners::default(), test_stackers);
+    advance_to_nakamoto(
+        &mut replay_peer,
+        &TestSigners::default(),
+        test_stackers.as_slice(),
+    );
 
     // sanity check
     let replay_tip = {
@@ -297,7 +290,8 @@ 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, None, None);
+    let test_stackers = TestStacker::common_signing_set(&test_signers);
+    let mut peer = boot_nakamoto(function_name!(), vec![], &test_signers, &test_stackers, None);
 
     let (burn_ops, mut tenure_change, miner_key) =
         peer.begin_nakamoto_tenure(TenureChangeCause::BlockFound);
@@ -353,11 +347,12 @@ fn test_simple_nakamoto_coordinator_1_tenure_10_blocks() {
     .unwrap();
 
     let mut test_signers = TestSigners::default();
+    let test_stackers = TestStacker::common_signing_set(&test_signers);
     let mut peer = boot_nakamoto(
         function_name!(),
         vec![(addr.into(), 100_000_000)],
         &test_signers,
-        None,
+        &test_stackers,
         None,
     );
 
@@ -476,12 +471,13 @@ fn test_nakamoto_chainstate_getters() {
     )
     .unwrap();
     let mut test_signers = TestSigners::default();
+    let test_stackers = TestStacker::common_signing_set(&test_signers);
     let mut peer = boot_nakamoto(
         function_name!(),
         vec![(addr.into(), 100_000_000)],
         &test_signers,
-        None,
-        None,
+        &test_stackers,
+        None
     );
 
     let sort_tip = {
@@ -966,11 +962,12 @@ pub fn simple_nakamoto_coordinator_10_tenures_10_sortitions<'a>() -> TestPeer<'a
     .unwrap();
 
     let mut test_signers = TestSigners::default();
+    let test_stackers = TestStacker::common_signing_set(&test_signers);
     let mut peer = boot_nakamoto(
         function_name!(),
         vec![(addr.into(), 100_000_000)],
         &test_signers,
-        None,
+        &test_stackers,
         None,
     );
 
@@ -1295,11 +1292,12 @@ pub fn simple_nakamoto_coordinator_2_tenures_3_sortitions<'a>() -> TestPeer<'a>
     )
     .unwrap();
     let mut test_signers = TestSigners::default();
+    let test_stackers = TestStacker::common_signing_set(&test_signers);
     let mut peer = boot_nakamoto(
         function_name!(),
         vec![(addr.into(), 100_000_000)],
         &test_signers,
-        None,
+        &test_stackers,
         None,
     );
 
@@ -1631,11 +1629,12 @@ pub fn simple_nakamoto_coordinator_10_extended_tenures_10_sortitions() -> TestPe
     )
     .unwrap();
     let mut test_signers = TestSigners::default();
+    let test_stackers = TestStacker::common_signing_set(&test_signers);
     let mut peer = boot_nakamoto(
         function_name!(),
         vec![(addr.into(), 100_000_000)],
         &test_signers,
-        None,
+        &test_stackers,
         None,
     );
 
diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index 78af526912..638bbb48d0 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -47,13 +47,14 @@ use stacks_common::util::secp256k1::MessageSignature;
 use stacks_common::util::vrf::{VRFProof, VRFPublicKey, VRF};
 use wsts::curve::point::Point;
 
+use self::signer_set::SignerCalculation;
 use super::burn::db::sortdb::{
     get_ancestor_sort_id, get_ancestor_sort_id_tx, get_block_commit_by_txid, SortitionHandle,
     SortitionHandleConn, SortitionHandleTx,
 };
 use super::burn::operations::{DelegateStxOp, StackStxOp, TransferStxOp};
 use super::stacks::boot::{
-    PoxVersions, RawRewardSetEntry, BOOT_TEST_POX_4_AGG_KEY_CONTRACT,
+    PoxVersions, RawRewardSetEntry, RewardSet, BOOT_TEST_POX_4_AGG_KEY_CONTRACT,
     BOOT_TEST_POX_4_AGG_KEY_FNAME, SIGNERS_MAX_LIST_SIZE, SIGNERS_NAME, SIGNERS_PK_LEN,
 };
 use super::stacks::db::accounts::MinerReward;
@@ -72,6 +73,7 @@ use crate::chainstate::burn::db::sortdb::SortitionDB;
 use crate::chainstate::burn::operations::{LeaderBlockCommitOp, LeaderKeyRegisterOp};
 use crate::chainstate::burn::{BlockSnapshot, SortitionHash};
 use crate::chainstate::coordinator::{BlockEventDispatcher, Error};
+use crate::chainstate::nakamoto::signer_set::NakamotoSigners;
 use crate::chainstate::nakamoto::tenure::NAKAMOTO_TENURES_SCHEMA;
 use crate::chainstate::stacks::address::PoxAddress;
 use crate::chainstate::stacks::boot::{POX_4_NAME, SIGNERS_UPDATE_STATE};
@@ -99,6 +101,7 @@ pub mod coordinator;
 pub mod miner;
 pub mod tenure;
 
+pub mod signer_set;
 #[cfg(test)]
 pub mod tests;
 
@@ -161,6 +164,14 @@ lazy_static! {
                     
                      PRIMARY KEY(block_hash,consensus_hash)
     );"#.into(),
+    r#"
+    -- Table for storing calculated reward sets. This must be in the Chainstate DB because calculation occurs
+    --   during block processing.
+    CREATE TABLE nakamoto_reward_sets (
+                     index_block_hash TEXT NOT NULL,
+                     reward_set TEXT NOT NULL,
+                     PRIMARY KEY (index_block_hash)
+    );"#.into(),
     NAKAMOTO_TENURES_SCHEMA.into(),
     r#"
       -- Table for Nakamoto block headers
@@ -297,6 +308,8 @@ pub struct SetupBlockResult<'a, 'b> {
     pub burn_delegate_stx_ops: Vec<DelegateStxOp>,
     /// STX auto-unlock events from PoX
     pub auto_unlock_events: Vec<StacksTransactionEvent>,
+    /// Result of a signer set calculation if one occurred
+    pub signer_set_calc: Option<SignerCalculation>,
 }
 
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
@@ -1828,278 +1841,6 @@ impl NakamotoChainState {
         }
     }
 
-    fn get_reward_slots(
-        clarity: &mut ClarityTransactionConnection,
-        reward_cycle: u64,
-        pox_contract: &str,
-    ) -> Result<Vec<RawRewardSetEntry>, ChainstateError> {
-        let is_mainnet = clarity.is_mainnet();
-        if !matches!(
-            PoxVersions::lookup_by_name(pox_contract),
-            Some(PoxVersions::Pox4)
-        ) {
-            error!("Invoked Nakamoto reward-set fetch on non-pox-4 contract");
-            return Err(ChainstateError::DefunctPoxContract);
-        }
-        let pox_contract = &boot_code_id(pox_contract, is_mainnet);
-
-        let list_length = clarity
-            .eval_method_read_only(
-                pox_contract,
-                "get-reward-set-size",
-                &[SymbolicExpression::atom_value(Value::UInt(
-                    reward_cycle.into(),
-                ))],
-            )?
-            .expect_u128()?;
-
-        let mut slots = vec![];
-        for index in 0..list_length {
-            let entry = clarity
-                .eval_method_read_only(
-                    pox_contract,
-                    "get-reward-set-pox-address",
-                    &[
-                        SymbolicExpression::atom_value(Value::UInt(reward_cycle.into())),
-                        SymbolicExpression::atom_value(Value::UInt(index)),
-                    ],
-                )?
-                .expect_optional()?
-                .expect(&format!(
-                    "FATAL: missing PoX address in slot {} out of {} in reward cycle {}",
-                    index, list_length, reward_cycle
-                ))
-                .expect_tuple()?;
-
-            let pox_addr_tuple = entry
-                .get("pox-addr")
-                .expect(&format!("FATAL: no `pox-addr` in return value from (get-reward-set-pox-address u{} u{})", reward_cycle, index))
-                .to_owned();
-
-            let reward_address = PoxAddress::try_from_pox_tuple(is_mainnet, &pox_addr_tuple)
-                .expect(&format!(
-                    "FATAL: not a valid PoX address: {:?}",
-                    &pox_addr_tuple
-                ));
-
-            let total_ustx = entry
-                .get("total-ustx")
-                .expect(&format!("FATAL: no 'total-ustx' in return value from (get-reward-set-pox-address u{} u{})", reward_cycle, index))
-                .to_owned()
-                .expect_u128()?;
-
-            let stacker_opt = entry
-                .get("stacker")
-                .expect(&format!(
-                    "FATAL: no 'stacker' in return value from (get-reward-set-pox-address u{} u{})",
-                    reward_cycle, index
-                ))
-                .to_owned()
-                .expect_optional()?;
-
-            let stacker = match stacker_opt {
-                Some(stacker_value) => Some(stacker_value.expect_principal()?),
-                None => None,
-            };
-
-            let signer = entry
-                .get("signer")
-                .expect(&format!(
-                    "FATAL: no 'signer' in return value from (get-reward-set-pox-address u{} u{})",
-                    reward_cycle, index
-                ))
-                .to_owned()
-                .expect_buff(SIGNERS_PK_LEN)?;
-            // (buff 33) only enforces max size, not min size, so we need to do a len check
-            let pk_bytes = if signer.len() == SIGNERS_PK_LEN {
-                let mut bytes = [0; SIGNERS_PK_LEN];
-                bytes.copy_from_slice(signer.as_slice());
-                bytes
-            } else {
-                [0; SIGNERS_PK_LEN]
-            };
-
-            slots.push(RawRewardSetEntry {
-                reward_address,
-                amount_stacked: total_ustx,
-                stacker,
-                signer: Some(pk_bytes),
-            })
-        }
-
-        Ok(slots)
-    }
-
-    pub fn handle_signer_stackerdb_update(
-        clarity: &mut ClarityTransactionConnection,
-        pox_constants: &PoxConstants,
-        reward_cycle: u64,
-        pox_contract: &str,
-    ) -> Result<Vec<StacksTransactionEvent>, ChainstateError> {
-        let is_mainnet = clarity.is_mainnet();
-        let sender_addr = PrincipalData::from(boot::boot_code_addr(is_mainnet));
-        let signers_contract = &boot_code_id(SIGNERS_NAME, is_mainnet);
-
-        let liquid_ustx = clarity.with_clarity_db_readonly(|db| db.get_total_liquid_ustx())?;
-        let reward_slots = Self::get_reward_slots(clarity, reward_cycle, pox_contract)?;
-        let (threshold, participation) = StacksChainState::get_reward_threshold_and_participation(
-            &pox_constants,
-            &reward_slots[..],
-            liquid_ustx,
-        );
-        let reward_set =
-            StacksChainState::make_reward_set(threshold, reward_slots, StacksEpochId::Epoch30);
-
-        let signers_list = if participation == 0 {
-            vec![]
-        } else {
-            reward_set
-                .signers
-                .ok_or(ChainstateError::PoxNoRewardCycle)?
-                .iter()
-                .map(|signer| {
-                    let signer_hash = Hash160::from_data(&signer.signing_key);
-                    let signing_address = StacksAddress::p2pkh_from_hash(is_mainnet, signer_hash);
-                    Value::Tuple(
-                        TupleData::from_data(vec![
-                            (
-                                "signer".into(),
-                                Value::Principal(PrincipalData::from(signing_address)),
-                            ),
-                            ("num-slots".into(), Value::UInt(signer.slots.into())),
-                        ])
-                            .expect(
-                                "BUG: Failed to construct `{ signer: principal, num-slots: u64 }` tuple",
-                            ),
-                    )
-                })
-                .collect()
-        };
-        if signers_list.len() > SIGNERS_MAX_LIST_SIZE {
-            panic!(
-                "FATAL: signers list returned by reward set calculations longer than maximum ({} > {})",
-                signers_list.len(),
-                SIGNERS_MAX_LIST_SIZE,
-            );
-        }
-
-        let args = [
-            SymbolicExpression::atom_value(Value::cons_list_unsanitized(signers_list).expect(
-                "BUG: Failed to construct `(list 4000 { signer: principal, num-slots: u64 })` list",
-            )),
-            SymbolicExpression::atom_value(Value::UInt(reward_cycle.into())),
-        ];
-
-        let (value, _, events, _) = clarity
-            .with_abort_callback(
-                |vm_env| {
-                    vm_env.execute_in_env(sender_addr.clone(), None, None, |env| {
-                        env.execute_contract_allow_private(
-                            &signers_contract,
-                            "stackerdb-set-signer-slots",
-                            &args,
-                            false,
-                        )
-                    })
-                },
-                |_, _| false,
-            )
-            .expect("FATAL: failed to update signer stackerdb");
-
-        if let Value::Response(ref data) = value {
-            if !data.committed {
-                error!(
-                    "Error while updating .signers contract";
-                    "reward_cycle" => reward_cycle,
-                    "cc_response" => %value,
-                );
-                panic!();
-            }
-        }
-
-        Ok(events)
-    }
-
-    pub fn check_and_handle_prepare_phase_start(
-        clarity_tx: &mut ClarityTx,
-        first_block_height: u64,
-        pox_constants: &PoxConstants,
-        burn_tip_height: u64,
-    ) -> Result<Vec<StacksTransactionEvent>, ChainstateError> {
-        let current_epoch = clarity_tx.get_epoch();
-        if current_epoch < StacksEpochId::Epoch25 {
-            // before Epoch-2.5, no need for special handling
-            return Ok(vec![]);
-        }
-        // now, determine if we are in a prepare phase, and we are the first
-        //  block in this prepare phase in our fork
-        if !pox_constants.is_in_prepare_phase(first_block_height, burn_tip_height) {
-            // if we're not in a prepare phase, don't need to do anything
-            return Ok(vec![]);
-        }
-
-        let Some(cycle_of_prepare_phase) =
-            pox_constants.reward_cycle_of_prepare_phase(first_block_height, burn_tip_height)
-        else {
-            // if we're not in a prepare phase, don't need to do anything
-            return Ok(vec![]);
-        };
-
-        let active_pox_contract = pox_constants.active_pox_contract(burn_tip_height);
-        if !matches!(
-            PoxVersions::lookup_by_name(active_pox_contract),
-            Some(PoxVersions::Pox4)
-        ) {
-            debug!(
-                "Active PoX contract is not PoX-4, skipping .signers updates until PoX-4 is active"
-            );
-            return Ok(vec![]);
-        }
-
-        let signers_contract = &boot_code_id(SIGNERS_NAME, clarity_tx.config.mainnet);
-
-        // are we the first block in the prepare phase in our fork?
-        let needs_update = clarity_tx.connection().with_clarity_db_readonly(|clarity_db| {
-            if !clarity_db.has_contract(signers_contract) {
-                // if there's no signers contract, no need to update anything.
-                return Ok::<_, ChainstateError>(false);
-            }
-            let Ok(value) = clarity_db.lookup_variable_unknown_descriptor(
-                signers_contract,
-                SIGNERS_UPDATE_STATE,
-                &current_epoch,
-            ) else {
-                error!("FATAL: Failed to read `{SIGNERS_UPDATE_STATE}` variable from .signers contract");
-                panic!();
-            };
-            let cycle_number = value.expect_u128().map_err(|e| ChainstateError::ClarityError(ClarityError::Interpreter(e)))?;
-            // if the cycle_number is less than `cycle_of_prepare_phase`, we need to update
-            //  the .signers state.
-            Ok::<_, ChainstateError>(cycle_number < cycle_of_prepare_phase.into())
-        })?;
-
-        if !needs_update {
-            debug!("Current cycle has already been setup in .signers or .signers is not initialized yet");
-            return Ok(vec![]);
-        }
-
-        info!(
-            "Performing .signers state update";
-            "burn_height" => burn_tip_height,
-            "for_cycle" => cycle_of_prepare_phase,
-            "signers_contract" => %signers_contract,
-        );
-
-        clarity_tx.connection().as_free_transaction(|clarity| {
-            Self::handle_signer_stackerdb_update(
-                clarity,
-                &pox_constants,
-                cycle_of_prepare_phase,
-                active_pox_contract,
-            )
-        })
-    }
-
     /// Get the aggregate public key for a block.
     /// TODO: The block at which the aggregate public key is queried needs to be better defined.
     /// See https://github.com/stacks-network/stacks-core/issues/4109
@@ -2653,6 +2394,33 @@ impl NakamotoChainState {
         Ok(new_tip_info)
     }
 
+    pub fn write_reward_set(
+        tx: &mut ChainstateTx,
+        block_id: &StacksBlockId,
+        reward_set: &RewardSet,
+    ) -> Result<(), ChainstateError> {
+        let sql = "INSERT INTO nakamoto_reward_sets (index_block_hash, reward_set) VALUES (?, ?)";
+        let args = rusqlite::params![block_id, &reward_set.metadata_serialize(),];
+        tx.execute(sql, args)?;
+        Ok(())
+    }
+
+    pub fn get_reward_set(
+        chainstate_db: &Connection,
+        block_id: &StacksBlockId,
+    ) -> Result<Option<RewardSet>, ChainstateError> {
+        let sql = "SELECT reward_set FROM nakamoto_reward_sets WHERE index_block_hash = ?";
+        chainstate_db
+            .query_row(sql, &[block_id], |row| {
+                let reward_set: String = row.get(0)?;
+                let reward_set = RewardSet::metadata_deserialize(&reward_set)
+                    .map_err(|s| FromSqlError::Other(s.into()))?;
+                Ok(reward_set)
+            })
+            .optional()
+            .map_err(ChainstateError::from)
+    }
+
     /// Begin block-processing and return all of the pre-processed state within a
     /// `SetupBlockResult`.
     ///
@@ -2843,13 +2611,17 @@ impl NakamotoChainState {
         }
 
         // Handle signer stackerdb updates
+        let signer_set_calc;
         if evaluated_epoch >= StacksEpochId::Epoch25 {
-            let _events = Self::check_and_handle_prepare_phase_start(
+            signer_set_calc = NakamotoSigners::check_and_handle_prepare_phase_start(
                 &mut clarity_tx,
                 first_block_height,
                 &pox_constants,
                 burn_header_height.into(),
+                coinbase_height,
             )?;
+        } else {
+            signer_set_calc = None;
         }
 
         debug!(
@@ -2868,6 +2640,7 @@ impl NakamotoChainState {
             burn_transfer_stx_ops: transfer_burn_ops,
             auto_unlock_events,
             burn_delegate_stx_ops: delegate_burn_ops,
+            signer_set_calc,
         })
     }
 
@@ -3162,6 +2935,7 @@ impl NakamotoChainState {
             burn_transfer_stx_ops,
             burn_delegate_stx_ops,
             mut auto_unlock_events,
+            signer_set_calc,
         } = Self::setup_block(
             chainstate_tx,
             clarity_instance,
@@ -3329,6 +3103,13 @@ impl NakamotoChainState {
         let new_block_id = new_tip.index_block_hash();
         chainstate_tx.log_transactions_processed(&new_block_id, &tx_receipts);
 
+        // store the reward set calculated during this block if it happened
+        // NOTE: miner and proposal evaluation should not invoke this because
+        //  it depends on knowing the StacksBlockId.
+        if let Some(signer_calculation) = signer_set_calc {
+            Self::write_reward_set(chainstate_tx, &new_block_id, &signer_calculation.reward_set)?
+        }
+
         monitoring::set_last_block_transaction_count(u64::try_from(block.txs.len()).unwrap());
         monitoring::set_last_execution_cost_observed(&block_execution_cost, &block_limit);
 
diff --git a/stackslib/src/chainstate/nakamoto/signer_set.rs b/stackslib/src/chainstate/nakamoto/signer_set.rs
new file mode 100644
index 0000000000..e0ac40199d
--- /dev/null
+++ b/stackslib/src/chainstate/nakamoto/signer_set.rs
@@ -0,0 +1,386 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020-2023 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+use std::collections::{BTreeMap, HashMap, HashSet};
+use std::ops::DerefMut;
+
+use clarity::vm::ast::ASTRules;
+use clarity::vm::costs::{ExecutionCost, LimitedCostTracker};
+use clarity::vm::database::{BurnStateDB, ClarityDatabase};
+use clarity::vm::events::StacksTransactionEvent;
+use clarity::vm::types::{PrincipalData, StacksAddressExtensions, TupleData};
+use clarity::vm::{ClarityVersion, SymbolicExpression, Value};
+use lazy_static::{__Deref, lazy_static};
+use rusqlite::types::{FromSql, FromSqlError};
+use rusqlite::{params, Connection, OptionalExtension, ToSql, NO_PARAMS};
+use sha2::{Digest as Sha2Digest, Sha512_256};
+use stacks_common::bitvec::BitVec;
+use stacks_common::codec::{
+    read_next, write_next, Error as CodecError, StacksMessageCodec, MAX_MESSAGE_LEN,
+    MAX_PAYLOAD_LEN,
+};
+use stacks_common::consts::{
+    FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH, MINER_REWARD_MATURITY,
+};
+use stacks_common::types::chainstate::{
+    BlockHeaderHash, BurnchainHeaderHash, ConsensusHash, StacksAddress, StacksBlockId,
+    StacksPrivateKey, StacksPublicKey, TrieHash, VRFSeed,
+};
+use stacks_common::types::{PrivateKey, StacksEpochId};
+use stacks_common::util::get_epoch_time_secs;
+use stacks_common::util::hash::{to_hex, Hash160, MerkleHashFunc, MerkleTree, Sha512Trunc256Sum};
+use stacks_common::util::retry::BoundReader;
+use stacks_common::util::secp256k1::MessageSignature;
+use stacks_common::util::vrf::{VRFProof, VRFPublicKey, VRF};
+use wsts::curve::point::Point;
+
+use crate::burnchains::{Burnchain, PoxConstants, Txid};
+use crate::chainstate::burn::db::sortdb::{
+    get_ancestor_sort_id, get_ancestor_sort_id_tx, get_block_commit_by_txid, SortitionDB,
+    SortitionHandle, SortitionHandleConn, SortitionHandleTx,
+};
+use crate::chainstate::burn::operations::{
+    DelegateStxOp, LeaderBlockCommitOp, LeaderKeyRegisterOp, StackStxOp, TransferStxOp,
+};
+use crate::chainstate::burn::{BlockSnapshot, SortitionHash};
+use crate::chainstate::coordinator::{BlockEventDispatcher, Error};
+use crate::chainstate::nakamoto::tenure::NAKAMOTO_TENURES_SCHEMA;
+use crate::chainstate::stacks::address::PoxAddress;
+use crate::chainstate::stacks::boot::{
+    PoxVersions, RawRewardSetEntry, RewardSet, BOOT_TEST_POX_4_AGG_KEY_CONTRACT,
+    BOOT_TEST_POX_4_AGG_KEY_FNAME, POX_4_NAME, SIGNERS_MAX_LIST_SIZE, SIGNERS_NAME, SIGNERS_PK_LEN,
+    SIGNERS_UPDATE_STATE,
+};
+use crate::chainstate::stacks::db::blocks::StagingUserBurnSupport;
+use crate::chainstate::stacks::db::{
+    ChainstateTx, ClarityTx, DBConfig as ChainstateConfig, MinerPaymentSchedule,
+    MinerPaymentTxFees, MinerRewardInfo, StacksBlockHeaderTypes, StacksChainState, StacksDBTx,
+    StacksEpochReceipt, StacksHeaderInfo,
+};
+use crate::chainstate::stacks::events::{StacksTransactionReceipt, TransactionOrigin};
+use crate::chainstate::stacks::{
+    Error as ChainstateError, StacksBlock, StacksBlockHeader, StacksMicroblock, StacksTransaction,
+    TenureChangeCause, TenureChangeError, TenureChangePayload, ThresholdSignature,
+    TransactionPayload, MINER_BLOCK_CONSENSUS_HASH, MINER_BLOCK_HEADER_HASH,
+};
+use crate::clarity::vm::clarity::{ClarityConnection, TransactionConnection};
+use crate::clarity_vm::clarity::{
+    ClarityInstance, ClarityTransactionConnection, PreCommitClarityBlock,
+};
+use crate::clarity_vm::database::SortitionDBRef;
+use crate::core::BOOT_BLOCK_HASH;
+use crate::net::stackerdb::StackerDBConfig;
+use crate::net::Error as net_error;
+use crate::util_lib::boot;
+use crate::util_lib::boot::boot_code_id;
+use crate::util_lib::db::{
+    query_int, query_row, query_row_panic, query_rows, u64_to_sql, DBConn, Error as DBError,
+    FromRow,
+};
+use crate::{chainstate, monitoring};
+
+pub struct NakamotoSigners();
+
+pub struct SignerCalculation {
+    pub reward_set: RewardSet,
+    pub events: Vec<StacksTransactionEvent>,
+}
+
+impl RawRewardSetEntry {
+    pub fn from_pox_4_tuple(is_mainnet: bool, tuple: TupleData) -> Self {
+        let mut tuple_data = tuple.data_map;
+
+        let pox_addr_tuple = tuple_data
+            .remove("pox-addr")
+            .expect("FATAL: no `pox-addr` in return value from (get-reward-set-pox-address)");
+
+        let reward_address = PoxAddress::try_from_pox_tuple(is_mainnet, &pox_addr_tuple)
+            .expect(&format!("FATAL: not a valid PoX address: {pox_addr_tuple}"));
+
+        let total_ustx = tuple_data
+            .remove("total-ustx")
+            .expect(
+                "FATAL: no 'total-ustx' in return value from (pox-4.get-reward-set-pox-address)",
+            )
+            .expect_u128();
+
+        let stacker = tuple_data
+            .remove("stacker")
+            .expect("FATAL: no 'stacker' in return value from (pox-4.get-reward-set-pox-address)")
+            .expect_optional()
+            .map(|value| value.expect_principal());
+
+        let signer = tuple_data
+            .remove("signer")
+            .expect("FATAL: no 'signer' in return value from (pox-4.get-reward-set-pox-address)")
+            .expect_buff(SIGNERS_PK_LEN);
+
+        // (buff 33) only enforces max size, not min size, so we need to do a len check
+        let pk_bytes = if signer.len() == SIGNERS_PK_LEN {
+            let mut bytes = [0; SIGNERS_PK_LEN];
+            bytes.copy_from_slice(signer.as_slice());
+            bytes
+        } else {
+            [0; SIGNERS_PK_LEN]
+        };
+
+        debug!(
+            "Parsed PoX reward address";
+            "stacked_ustx" => total_ustx,
+            "reward_address" => %reward_address,
+            "stacker" => ?stacker,
+            "signer" => to_hex(&signer),
+        );
+
+        Self {
+            reward_address,
+            amount_stacked: total_ustx,
+            stacker,
+            signer: Some(pk_bytes),
+        }
+    }
+}
+
+impl NakamotoSigners {
+    fn get_reward_slots(
+        clarity: &mut ClarityTransactionConnection,
+        reward_cycle: u64,
+        pox_contract: &str,
+    ) -> Result<Vec<RawRewardSetEntry>, ChainstateError> {
+        let is_mainnet = clarity.is_mainnet();
+        if !matches!(
+            PoxVersions::lookup_by_name(pox_contract),
+            Some(PoxVersions::Pox4)
+        ) {
+            error!("Invoked Nakamoto reward-set fetch on non-pox-4 contract");
+            return Err(ChainstateError::DefunctPoxContract);
+        }
+        let pox_contract = &boot_code_id(pox_contract, is_mainnet);
+
+        let list_length = clarity
+            .eval_method_read_only(
+                pox_contract,
+                "get-reward-set-size",
+                &[SymbolicExpression::atom_value(Value::UInt(
+                    reward_cycle.into(),
+                ))],
+            )?
+            .expect_u128();
+
+        let mut slots = vec![];
+        for index in 0..list_length {
+            let tuple = clarity
+                .eval_method_read_only(
+                    pox_contract,
+                    "get-reward-set-pox-address",
+                    &[
+                        SymbolicExpression::atom_value(Value::UInt(reward_cycle.into())),
+                        SymbolicExpression::atom_value(Value::UInt(index)),
+                    ],
+                )?
+                .expect_optional()
+                .expect(&format!(
+                    "FATAL: missing PoX address in slot {} out of {} in reward cycle {}",
+                    index, list_length, reward_cycle
+                ))
+                .expect_tuple();
+
+            let entry = RawRewardSetEntry::from_pox_4_tuple(is_mainnet, tuple);
+
+            slots.push(entry)
+        }
+
+        Ok(slots)
+    }
+
+    pub fn handle_signer_stackerdb_update(
+        clarity: &mut ClarityTransactionConnection,
+        pox_constants: &PoxConstants,
+        reward_cycle: u64,
+        pox_contract: &str,
+        coinbase_height: u64,
+    ) -> Result<SignerCalculation, ChainstateError> {
+        let is_mainnet = clarity.is_mainnet();
+        let sender_addr = PrincipalData::from(boot::boot_code_addr(is_mainnet));
+        let signers_contract = &boot_code_id(SIGNERS_NAME, is_mainnet);
+
+        let liquid_ustx = clarity.with_clarity_db_readonly(|db| db.get_total_liquid_ustx());
+        let reward_slots = Self::get_reward_slots(clarity, reward_cycle, pox_contract)?;
+        let (threshold, participation) = StacksChainState::get_reward_threshold_and_participation(
+            &pox_constants,
+            &reward_slots[..],
+            liquid_ustx,
+        );
+        let reward_set =
+            StacksChainState::make_reward_set(threshold, reward_slots, StacksEpochId::Epoch30);
+
+        let signers_list = if participation == 0 {
+            vec![]
+        } else {
+            reward_set
+                .signers
+                .as_ref()
+                .ok_or(ChainstateError::PoxNoRewardCycle)?
+                .iter()
+                .map(|signer| {
+                    let signer_hash = Hash160::from_data(&signer.signing_key);
+                    let signing_address = StacksAddress::p2pkh_from_hash(is_mainnet, signer_hash);
+                    Value::Tuple(
+                        TupleData::from_data(vec![
+                            (
+                                "signer".into(),
+                                Value::Principal(PrincipalData::from(signing_address)),
+                            ),
+                            ("num-slots".into(), Value::UInt(signer.slots.into())),
+                        ])
+                            .expect(
+                                "BUG: Failed to construct `{ signer: principal, num-slots: u64 }` tuple",
+                            ),
+                    )
+                })
+                .collect()
+        };
+        if signers_list.len() > SIGNERS_MAX_LIST_SIZE {
+            panic!(
+                "FATAL: signers list returned by reward set calculations longer than maximum ({} > {})",
+                signers_list.len(),
+                SIGNERS_MAX_LIST_SIZE,
+            );
+        }
+
+        let args = [
+            SymbolicExpression::atom_value(Value::cons_list_unsanitized(signers_list).expect(
+                "BUG: Failed to construct `(list 4000 { signer: principal, num-slots: u64 })` list",
+            )),
+            SymbolicExpression::atom_value(Value::UInt(reward_cycle.into())),
+            SymbolicExpression::atom_value(Value::UInt(coinbase_height.into())),
+        ];
+
+        let (value, _, events, _) = clarity
+            .with_abort_callback(
+                |vm_env| {
+                    vm_env.execute_in_env(sender_addr.clone(), None, None, |env| {
+                        env.execute_contract_allow_private(
+                            &signers_contract,
+                            "stackerdb-set-signer-slots",
+                            &args,
+                            false,
+                        )
+                    })
+                },
+                |_, _| false,
+            )
+            .expect("FATAL: failed to update signer stackerdb");
+
+        if let Value::Response(ref data) = value {
+            if !data.committed {
+                error!(
+                    "Error while updating .signers contract";
+                    "reward_cycle" => reward_cycle,
+                    "cc_response" => %value,
+                );
+                panic!();
+            }
+        }
+
+        Ok(SignerCalculation { events, reward_set })
+    }
+
+    pub fn check_and_handle_prepare_phase_start(
+        clarity_tx: &mut ClarityTx,
+        first_block_height: u64,
+        pox_constants: &PoxConstants,
+        burn_tip_height: u64,
+        coinbase_height: u64,
+    ) -> Result<Option<SignerCalculation>, ChainstateError> {
+        let current_epoch = clarity_tx.get_epoch();
+        if current_epoch < StacksEpochId::Epoch25 {
+            // before Epoch-2.5, no need for special handling
+            return Ok(None);
+        }
+        // now, determine if we are in a prepare phase, and we are the first
+        //  block in this prepare phase in our fork
+        if !pox_constants.is_in_prepare_phase(first_block_height, burn_tip_height) {
+            // if we're not in a prepare phase, don't need to do anything
+            return Ok(None);
+        }
+
+        let Some(cycle_of_prepare_phase) =
+            pox_constants.reward_cycle_of_prepare_phase(first_block_height, burn_tip_height)
+        else {
+            // if we're not in a prepare phase, don't need to do anything
+            return Ok(None);
+        };
+
+        let active_pox_contract = pox_constants.active_pox_contract(burn_tip_height);
+        if !matches!(
+            PoxVersions::lookup_by_name(active_pox_contract),
+            Some(PoxVersions::Pox4)
+        ) {
+            debug!(
+                "Active PoX contract is not PoX-4, skipping .signers updates until PoX-4 is active"
+            );
+            return Ok(None);
+        }
+
+        let signers_contract = &boot_code_id(SIGNERS_NAME, clarity_tx.config.mainnet);
+
+        // are we the first block in the prepare phase in our fork?
+        let needs_update = clarity_tx.connection().with_clarity_db_readonly(|clarity_db| {
+            if !clarity_db.has_contract(signers_contract) {
+                // if there's no signers contract, no need to update anything.
+                return false
+            }
+            let Ok(value) = clarity_db.lookup_variable_unknown_descriptor(
+                signers_contract,
+                SIGNERS_UPDATE_STATE,
+                &current_epoch,
+            ) else {
+                error!("FATAL: Failed to read `{SIGNERS_UPDATE_STATE}` variable from .signers contract");
+                panic!();
+            };
+            let cycle_number = value.expect_u128();
+            // if the cycle_number is less than `cycle_of_prepare_phase`, we need to update
+            //  the .signers state.
+            cycle_number < cycle_of_prepare_phase.into()
+        });
+
+        if !needs_update {
+            debug!("Current cycle has already been setup in .signers or .signers is not initialized yet");
+            return Ok(None);
+        }
+
+        info!(
+            "Performing .signers state update";
+            "burn_height" => burn_tip_height,
+            "for_cycle" => cycle_of_prepare_phase,
+            "signers_contract" => %signers_contract,
+        );
+
+        clarity_tx
+            .connection()
+            .as_free_transaction(|clarity| {
+                Self::handle_signer_stackerdb_update(
+                    clarity,
+                    &pox_constants,
+                    cycle_of_prepare_phase,
+                    active_pox_contract,
+                    coinbase_height,
+                )
+            })
+            .map(|calculation| Some(calculation))
+    }
+}
diff --git a/stackslib/src/chainstate/nakamoto/tests/mod.rs b/stackslib/src/chainstate/nakamoto/tests/mod.rs
index 9df80e73f9..07a6ec533a 100644
--- a/stackslib/src/chainstate/nakamoto/tests/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/mod.rs
@@ -52,7 +52,7 @@ use crate::chainstate::coordinator::tests::{
 use crate::chainstate::nakamoto::coordinator::tests::boot_nakamoto;
 use crate::chainstate::nakamoto::miner::NakamotoBlockBuilder;
 use crate::chainstate::nakamoto::tenure::NakamotoTenure;
-use crate::chainstate::nakamoto::tests::node::TestSigners;
+use crate::chainstate::nakamoto::tests::node::{TestSigners, TestStacker};
 use crate::chainstate::nakamoto::{
     NakamotoBlock, NakamotoBlockHeader, NakamotoChainState, FIRST_STACKS_BLOCK_ID,
 };
@@ -1502,7 +1502,8 @@ fn make_fork_run_with_arrivals(
 #[test]
 pub fn test_get_highest_nakamoto_tenure() {
     let test_signers = TestSigners::default();
-    let mut peer = boot_nakamoto(function_name!(), vec![], &test_signers, None, None);
+    let test_stackers = TestStacker::common_signing_set(&test_signers);
+    let mut peer = boot_nakamoto(function_name!(), vec![], &test_signers, &test_stackers, None);
 
     // extract chainstate and sortdb -- we don't need the peer anymore
     let chainstate = &mut peer.stacks_node.as_mut().unwrap().chainstate;
@@ -1644,7 +1645,8 @@ pub fn test_get_highest_nakamoto_tenure() {
 #[test]
 fn test_make_miners_stackerdb_config() {
     let test_signers = TestSigners::default();
-    let mut peer = boot_nakamoto(function_name!(), vec![], &test_signers, None, None);
+    let test_stackers = TestStacker::common_signing_set(&test_signers);
+    let mut peer = boot_nakamoto(function_name!(), vec![], &test_signers, &test_stackers, None);
 
     let naka_miner_hash160 = peer.miner.nakamoto_miner_hash160();
     let miner_keys: Vec<_> = (0..10).map(|_| StacksPrivateKey::new()).collect();
diff --git a/stackslib/src/chainstate/nakamoto/tests/node.rs b/stackslib/src/chainstate/nakamoto/tests/node.rs
index df70c57e98..1b4828c024 100644
--- a/stackslib/src/chainstate/nakamoto/tests/node.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/node.rs
@@ -74,6 +74,7 @@ pub struct TestStacker {
 }
 
 impl TestStacker {
+    pub const DEFAULT_STACKER_AMOUNT: u128 = 1_000_000_000_000_000_000;
     pub fn from_seed(seed: &[u8]) -> TestStacker {
         let stacker_private_key = StacksPrivateKey::from_seed(seed);
         let mut signer_seed = seed.to_vec();
@@ -89,6 +90,21 @@ impl TestStacker {
     pub fn signer_public_key(&self) -> StacksPublicKey {
         StacksPublicKey::from_private(&self.signer_private_key)
     }
+
+    /// make a set of stackers who will share a single signing key and stack with
+    /// `Self::DEFAULT_STACKER_AMOUNT`
+    pub fn common_signing_set(test_signers: &TestSigners) -> Vec<TestStacker> {
+        let mut signing_key_seed = test_signers.num_keys.to_be_bytes().to_vec();
+        signing_key_seed.extend_from_slice(&[1, 1, 1, 1]);
+        let signing_key = StacksPrivateKey::from_seed(signing_key_seed.as_slice());
+        (0..test_signers.num_keys)
+            .map(|index| TestStacker {
+                signer_private_key: signing_key.clone(),
+                stacker_private_key: StacksPrivateKey::from_seed(&index.to_be_bytes()),
+                amount: Self::DEFAULT_STACKER_AMOUNT,
+            })
+            .collect()
+    }
 }
 
 #[derive(Debug, Clone)]
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 1294091f5e..9c8ad4321f 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -257,6 +257,16 @@ impl RewardSet {
             signers: None,
         }
     }
+
+    /// Serialization used when stored as ClarityDB metadata
+    pub fn metadata_serialize(&self) -> String {
+        serde_json::to_string(self).expect("FATAL: failure to serialize RewardSet struct")
+    }
+
+    /// Deserializer corresponding to `RewardSet::metadata_serialize`
+    pub fn metadata_deserialize(from: &str) -> Result<RewardSet, String> {
+        serde_json::from_str(from).map_err(|e| e.to_string())
+    }
 }
 
 impl StacksChainState {
@@ -526,7 +536,7 @@ impl StacksChainState {
         Ok(total_events)
     }
 
-    fn eval_boot_code_read_only(
+    pub fn eval_boot_code_read_only(
         &mut self,
         sortdb: &SortitionDB,
         stacks_block_id: &StacksBlockId,
@@ -1201,67 +1211,8 @@ impl StacksChainState {
                 ))
                 .expect_tuple()?;
 
-            let pox_addr_tuple = tuple
-                .get("pox-addr")
-                .expect(&format!("FATAL: no `pox-addr` in return value from (get-reward-set-pox-address u{} u{})", reward_cycle, i))
-                .to_owned();
-
-            let reward_address = PoxAddress::try_from_pox_tuple(self.mainnet, &pox_addr_tuple)
-                .expect(&format!(
-                    "FATAL: not a valid PoX address: {:?}",
-                    &pox_addr_tuple
-                ));
-
-            let total_ustx = tuple
-                .get("total-ustx")
-                .expect(&format!("FATAL: no 'total-ustx' in return value from (get-reward-set-pox-address u{} u{})", reward_cycle, i))
-                .to_owned()
-                .expect_u128()?;
-
-            let stacker_opt = tuple
-                .get("stacker")
-                .expect(&format!(
-                    "FATAL: no 'stacker' in return value from (get-reward-set-pox-address u{} u{})",
-                    reward_cycle, i
-                ))
-                .to_owned()
-                .expect_optional()?;
-
-            let stacker = match stacker_opt {
-                Some(stacker_value) => Some(stacker_value.expect_principal()?),
-                None => None,
-            };
-
-            let signer = tuple
-                .get("signer")
-                .expect(&format!(
-                    "FATAL: no 'signer' in return value from (get-reward-set-pox-address u{} u{})",
-                    reward_cycle, i
-                ))
-                .to_owned()
-                .expect_buff(SIGNERS_PK_LEN)?;
-            // (buff 33) only enforces max size, not min size, so we need to do a len check
-            let pk_bytes = if signer.len() == SIGNERS_PK_LEN {
-                let mut bytes = [0; SIGNERS_PK_LEN];
-                bytes.copy_from_slice(signer.as_slice());
-                bytes
-            } else {
-                [0; SIGNERS_PK_LEN]
-            };
-
-            debug!(
-                "Parsed PoX reward address";
-                "stacked_ustx" => total_ustx,
-                "reward_address" => %reward_address,
-                "stacker" => ?stacker,
-                "signer" => ?signer
-            );
-            ret.push(RawRewardSetEntry {
-                reward_address,
-                amount_stacked: total_ustx,
-                stacker,
-                signer: Some(pk_bytes),
-            })
+            let entry = RawRewardSetEntry::from_pox_4_tuple(self.mainnet, tuple);
+            ret.push(entry)
         }
 
         Ok(ret)
diff --git a/stackslib/src/chainstate/stacks/boot/signers.clar b/stackslib/src/chainstate/stacks/boot/signers.clar
index a901dc0f94..71adb33bd7 100644
--- a/stackslib/src/chainstate/stacks/boot/signers.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers.clar
@@ -1,12 +1,15 @@
 (define-data-var last-set-cycle uint u0)
 (define-data-var stackerdb-signer-slots (list 4000 { signer: principal, num-slots: uint }) (list))
+(define-map cycle-set-height uint uint)
 (define-constant MAX_WRITES u340282366920938463463374607431768211455)
 (define-constant CHUNK_SIZE (* u2 u1024 u1024))
 
 (define-private (stackerdb-set-signer-slots 
                    (signer-slots (list 4000 { signer: principal, num-slots: uint }))
-                   (reward-cycle uint))
+                   (reward-cycle uint)
+                   (set-at-height uint))
 	(begin
+        (map-set cycle-set-height reward-cycle set-at-height)
         (var-set last-set-cycle reward-cycle)
 		(ok (var-set stackerdb-signer-slots signer-slots))))
 
diff --git a/stackslib/src/chainstate/stacks/boot/signers_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_tests.rs
index 004e437dfb..45090fa63f 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_tests.rs
@@ -202,7 +202,7 @@ fn signers_get_signer_keys_from_stackerdb() {
     let (mut peer, test_signers, latest_block_id, _) = prepare_signers_test(
         function_name!(),
         vec![],
-        Some(vec![&stacker_1, &stacker_2]),
+        &[stacker_1.clone(), stacker_2.clone()],
         None,
     );
 
@@ -249,7 +249,7 @@ fn signers_get_signer_keys_from_stackerdb() {
 pub fn prepare_signers_test<'a>(
     test_name: &str,
     initial_balances: Vec<(PrincipalData, u64)>,
-    stackers: Option<Vec<&TestStacker>>,
+    stackers: &[TestStacker],
     observer: Option<&'a TestEventObserver>,
 ) -> (TestPeer<'a>, TestSigners, StacksBlockId, u128) {
     let mut test_signers = TestSigners::default();
diff --git a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
index d7ac4912ac..370eea72df 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
@@ -150,7 +150,7 @@ fn vote_for_aggregate_public_key_in_first_block() {
     let (mut peer, mut test_signers, latest_block_id, current_reward_cycle) = prepare_signers_test(
         function_name!(),
         vec![(signer, 1000)],
-        Some(vec![&stacker_1, &stacker_2]),
+        &[stacker_1.clone(), stacker_2.clone()],
         Some(&observer),
     );
 
@@ -237,7 +237,7 @@ fn vote_for_aggregate_public_key_in_last_block() {
     let (mut peer, mut test_signers, latest_block_id, current_reward_cycle) = prepare_signers_test(
         function_name!(),
         vec![(signer_1, 1000), (signer_2, 1000)],
-        Some(vec![&stacker_1, &stacker_2]),
+        &[stacker_1.clone(), stacker_2.clone()],
         Some(&observer),
     );
 
diff --git a/stackslib/src/chainstate/stacks/db/blocks.rs b/stackslib/src/chainstate/stacks/db/blocks.rs
index cfc22cdd95..d2e80e3e6a 100644
--- a/stackslib/src/chainstate/stacks/db/blocks.rs
+++ b/stackslib/src/chainstate/stacks/db/blocks.rs
@@ -52,6 +52,7 @@ use crate::chainstate::burn::db::sortdb::*;
 use crate::chainstate::burn::operations::*;
 use crate::chainstate::burn::BlockSnapshot;
 use crate::chainstate::coordinator::BlockEventDispatcher;
+use crate::chainstate::nakamoto::signer_set::{NakamotoSigners, SignerCalculation};
 use crate::chainstate::nakamoto::NakamotoChainState;
 use crate::chainstate::stacks::address::{PoxAddress, StacksAddressExtensions};
 use crate::chainstate::stacks::db::accounts::MinerReward;
@@ -168,6 +169,8 @@ pub struct SetupBlockResult<'a, 'b> {
     pub burn_transfer_stx_ops: Vec<TransferStxOp>,
     pub auto_unlock_events: Vec<StacksTransactionEvent>,
     pub burn_delegate_stx_ops: Vec<DelegateStxOp>,
+    /// Result of a signer set calculation if one occurred
+    pub signer_set_calc: Option<SignerCalculation>,
 }
 
 pub struct DummyEventDispatcher;
@@ -5149,13 +5152,17 @@ impl StacksChainState {
 
         // Handle signer stackerdb updates
         let first_block_height = burn_dbconn.get_burn_start_height();
+        let signer_set_calc;
         if evaluated_epoch >= StacksEpochId::Epoch25 {
-            let _events = NakamotoChainState::check_and_handle_prepare_phase_start(
+            signer_set_calc = NakamotoSigners::check_and_handle_prepare_phase_start(
                 &mut clarity_tx,
                 first_block_height.into(),
                 &pox_constants,
                 burn_tip_height.into(),
+                chain_tip.stacks_block_height,
             )?;
+        } else {
+            signer_set_calc = None;
         }
 
         debug!(
@@ -5177,6 +5184,7 @@ impl StacksChainState {
             burn_transfer_stx_ops: transfer_burn_ops,
             auto_unlock_events,
             burn_delegate_stx_ops: delegate_burn_ops,
+            signer_set_calc,
         })
     }
 
@@ -5372,6 +5380,7 @@ impl StacksChainState {
             burn_transfer_stx_ops,
             mut auto_unlock_events,
             burn_delegate_stx_ops,
+            signer_set_calc,
         } = StacksChainState::setup_block(
             chainstate_tx,
             clarity_instance,
@@ -5671,6 +5680,18 @@ impl StacksChainState {
 
         chainstate_tx.log_transactions_processed(&new_tip.index_block_hash(), &tx_receipts);
 
+        // store the reward set calculated during this block if it happened
+        // NOTE: miner and proposal evaluation should not invoke this because
+        //  it depends on knowing the StacksBlockId.
+        if let Some(signer_calculation) = signer_set_calc {
+            let new_block_id = new_tip.index_block_hash();
+            NakamotoChainState::write_reward_set(
+                chainstate_tx,
+                &new_block_id,
+                &signer_calculation.reward_set,
+            )?
+        }
+
         set_last_block_transaction_count(
             u64::try_from(block.txs.len()).expect("more than 2^64 txs"),
         );

From c44ba3615cb07c767e323ec4cb6e9cb5f11a7924 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Mon, 29 Jan 2024 15:17:10 -0600
Subject: [PATCH 0621/1166] feat: add `stacker_set` RPC endpoint

* expand e2e correct_burns test to invoke the new RPC endpoint
* fix reward-set storage information to write correct coinbase height
---
 CHANGELOG.md                                  |   1 +
 .../get_stacker_set.400.example.json          |   4 +
 .../core-node/get_stacker_set.example.json    |  25 ++
 docs/rpc/openapi.yaml                         |  24 ++
 stackslib/src/chainstate/coordinator/mod.rs   |   1 +
 .../chainstate/nakamoto/coordinator/mod.rs    |  65 ++++-
 stackslib/src/chainstate/nakamoto/mod.rs      |   2 +-
 .../src/chainstate/nakamoto/signer_set.rs     |   1 +
 stackslib/src/chainstate/stacks/db/blocks.rs  |  33 +--
 stackslib/src/net/api/getstackers.rs          | 225 ++++++++++++++++++
 stackslib/src/net/api/mod.rs                  |   2 +
 .../src/tests/nakamoto_integrations.rs        |  34 ++-
 12 files changed, 385 insertions(+), 32 deletions(-)
 create mode 100644 docs/rpc/api/core-node/get_stacker_set.400.example.json
 create mode 100644 docs/rpc/api/core-node/get_stacker_set.example.json
 create mode 100644 stackslib/src/net/api/getstackers.rs

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 85b27ce83f..ffba4b176f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,6 +9,7 @@ and this project adheres to the versioning scheme outlined in the [README.md](RE
 
 ### Added
 
+- New RPC endpoint `/v2/stacker_set/{cycle_number}` to fetch stacker sets in PoX-4
 - New `/new_pox_anchor` endpoint for broadcasting PoX anchor block processing.
 - Stacker bitvec in NakamotoBlock
 
diff --git a/docs/rpc/api/core-node/get_stacker_set.400.example.json b/docs/rpc/api/core-node/get_stacker_set.400.example.json
new file mode 100644
index 0000000000..0ca1688c68
--- /dev/null
+++ b/docs/rpc/api/core-node/get_stacker_set.400.example.json
@@ -0,0 +1,4 @@
+{
+  "response": "error",
+  "err_msg": "Could not read reward set. Prepare phase may not have started for this cycle yet. Cycle = 22, Err= PoXAnchorBlockRequired"
+}
diff --git a/docs/rpc/api/core-node/get_stacker_set.example.json b/docs/rpc/api/core-node/get_stacker_set.example.json
new file mode 100644
index 0000000000..1bcd3fad59
--- /dev/null
+++ b/docs/rpc/api/core-node/get_stacker_set.example.json
@@ -0,0 +1,25 @@
+{
+  "stacker_set": {
+    "rewarded_addresses": [
+      {
+        "Standard": [
+          {
+            "bytes": "dc5f18421006ee2b98ab972edfa7268a981e3f00",
+            "version": 26
+          },
+          "SerializeP2PKH"
+        ]
+      }
+    ],
+    "signers": [
+      {
+        "signing_key": "02d0a27e4f1bf186b4391eecfcc4d4a0d403684ad089b477b8548a69dd6378bf26",
+        "slots": 1,
+        "stacked_amt": 2143020000000000
+      }
+    ],
+    "start_cycle_state": {
+      "missed_reward_slots": []
+    }
+  }
+}
diff --git a/docs/rpc/openapi.yaml b/docs/rpc/openapi.yaml
index d554b96242..6018a61ba3 100644
--- a/docs/rpc/openapi.yaml
+++ b/docs/rpc/openapi.yaml
@@ -583,3 +583,27 @@ paths:
           application/json:
             example:
               $ref: ./api/core-node/post-block-proposal-req.example.json
+
+  /v2/stacker_set/{cycle_number}:
+    get:
+      summary: Fetch the stacker and signer set information for a given cycle.
+      tags:
+        - Mining
+      operationId: get_stacker_set
+      description: |
+        Used to get stacker and signer set information for a given cycle.
+
+        This will only return information for cycles started in Epoch-2.5 where PoX-4 was active.
+      responses:
+        200:
+          description: Information for the given reward cycle
+          content:
+            application/json:
+              example:
+                $ref: ./api/core-node/get_stacker_set.example.json
+        400:
+          description: Could not fetch the given reward set
+          content:
+            application/json:
+              example:
+                $ref: ./api/core-node/get_stacker_set.400.example.json
diff --git a/stackslib/src/chainstate/coordinator/mod.rs b/stackslib/src/chainstate/coordinator/mod.rs
index 3bc1f890a5..66bc70a4c4 100644
--- a/stackslib/src/chainstate/coordinator/mod.rs
+++ b/stackslib/src/chainstate/coordinator/mod.rs
@@ -380,6 +380,7 @@ impl<'a, T: BlockEventDispatcher> RewardSetProvider for OnChainRewardSetProvider
             burnchain,
             sortdb,
             block_id,
+            false,
         )
     }
 }
diff --git a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
index c24ceca34f..68976d6283 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
@@ -55,6 +55,9 @@ pub mod tests;
 
 impl<'a, T: BlockEventDispatcher> OnChainRewardSetProvider<'a, T> {
     /// Read a reward_set written while updating .signers
+    /// `debug_log` should be set to true if the reward set loading should
+    ///  log messages as `debug!` instead of `error!` or `info!`. This allows
+    ///  RPC endpoints to expose this without flooding loggers.
     pub fn read_reward_set_nakamoto(
         &self,
         cycle_start_burn_height: u64,
@@ -62,6 +65,7 @@ impl<'a, T: BlockEventDispatcher> OnChainRewardSetProvider<'a, T> {
         burnchain: &Burnchain,
         sortdb: &SortitionDB,
         block_id: &StacksBlockId,
+        debug_log: bool,
     ) -> Result<RewardSet, Error> {
         let cycle = burnchain
             .block_height_to_reward_cycle(cycle_start_burn_height)
@@ -77,10 +81,17 @@ impl<'a, T: BlockEventDispatcher> OnChainRewardSetProvider<'a, T> {
             .expect_optional()
             .map(|x| u64::try_from(x.expect_u128()).expect("FATAL: block height exceeded u64"))
         else {
-            error!(
-                "The reward set was not written to .signers before it was needed by Nakamoto";
-                "cycle_number" => cycle,
-            );
+            if debug_log {
+                debug!(
+                    "The reward set was not written to .signers before it was needed by Nakamoto";
+                    "cycle_number" => cycle,
+                );
+            } else {
+                error!(
+                    "The reward set was not written to .signers before it was needed by Nakamoto";
+                    "cycle_number" => cycle,
+                );
+            }
             return Err(Error::PoXAnchorBlockRequired);
         };
 
@@ -90,7 +101,11 @@ impl<'a, T: BlockEventDispatcher> OnChainRewardSetProvider<'a, T> {
             coinbase_height_of_calculation,
         )?
         else {
-            error!("Failed to find the block in which .signers was written");
+            if debug_log {
+                debug!("Failed to find the block in which .signers was written");
+            } else {
+                error!("Failed to find the block in which .signers was written");
+            }
             return Err(Error::PoXAnchorBlockRequired);
         };
 
@@ -99,7 +114,18 @@ impl<'a, T: BlockEventDispatcher> OnChainRewardSetProvider<'a, T> {
             &reward_set_block.index_block_hash(),
         )?
         else {
-            error!("No reward set stored at the block in which .signers was written");
+            if debug_log {
+                debug!(
+                    "No reward set stored at the block in which .signers was written";
+                    "checked_block" => %reward_set_block.index_block_hash()
+                );
+            } else {
+                error!(
+                    "No reward set stored at the block in which .signers was written";
+                    "checked_block" => %reward_set_block.index_block_hash(),
+                    "coinbase_height_of_calculation" => coinbase_height_of_calculation,
+                );
+            }
             return Err(Error::PoXAnchorBlockRequired);
         };
 
@@ -108,17 +134,32 @@ impl<'a, T: BlockEventDispatcher> OnChainRewardSetProvider<'a, T> {
         //  Non participation is fatal.
         if reward_set.rewarded_addresses.is_empty() {
             // no one is stacking
-            error!("No PoX participation");
+            if debug_log {
+                debug!("No PoX participation");
+            } else {
+                error!("No PoX participation");
+            }
             return Err(Error::PoXAnchorBlockRequired);
         }
 
-        info!(
-            "PoX reward set loaded from written block state";
-            "reward_set_block_id" => %reward_set_block.index_block_hash(),
-        );
+        if debug_log {
+            debug!(
+                "PoX reward set loaded from written block state";
+                "reward_set_block_id" => %reward_set_block.index_block_hash(),
+            );
+        } else {
+            info!(
+                "PoX reward set loaded from written block state";
+                "reward_set_block_id" => %reward_set_block.index_block_hash(),
+            );
+        }
 
         if reward_set.signers.is_none() {
-            error!("FATAL: PoX reward set did not specify signer set in Nakamoto");
+            if debug_log {
+                debug!("FATAL: PoX reward set did not specify signer set in Nakamoto");
+            } else {
+                error!("FATAL: PoX reward set did not specify signer set in Nakamoto");
+            }
             return Err(Error::PoXAnchorBlockRequired);
         }
 
diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index 638bbb48d0..2b1ea6b1e7 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -2511,7 +2511,7 @@ impl NakamotoChainState {
                 Self::calculate_matured_miner_rewards(
                     &mut clarity_tx,
                     sortition_dbconn.sqlite_conn(),
-                    coinbase_height,
+                    coinbase_height + 1,
                     matured_rewards_schedule,
                 )
             })
diff --git a/stackslib/src/chainstate/nakamoto/signer_set.rs b/stackslib/src/chainstate/nakamoto/signer_set.rs
index e0ac40199d..261133e3f2 100644
--- a/stackslib/src/chainstate/nakamoto/signer_set.rs
+++ b/stackslib/src/chainstate/nakamoto/signer_set.rs
@@ -367,6 +367,7 @@ impl NakamotoSigners {
             "Performing .signers state update";
             "burn_height" => burn_tip_height,
             "for_cycle" => cycle_of_prepare_phase,
+            "coinbase_height" => coinbase_height,
             "signers_contract" => %signers_contract,
         );
 
diff --git a/stackslib/src/chainstate/stacks/db/blocks.rs b/stackslib/src/chainstate/stacks/db/blocks.rs
index d2e80e3e6a..fc3920902d 100644
--- a/stackslib/src/chainstate/stacks/db/blocks.rs
+++ b/stackslib/src/chainstate/stacks/db/blocks.rs
@@ -5093,6 +5093,24 @@ impl StacksChainState {
 
         let evaluated_epoch = clarity_tx.get_epoch();
 
+        // Handle signer stackerdb updates
+        // this must happen *before* any state transformations from burn ops, rewards unlocking, etc.
+        // this ensures that the .signers updates will match the PoX anchor block calculation in Epoch 2.5
+        let first_block_height = burn_dbconn.get_burn_start_height();
+        let signer_set_calc;
+        if evaluated_epoch >= StacksEpochId::Epoch25 {
+            signer_set_calc = NakamotoSigners::check_and_handle_prepare_phase_start(
+                &mut clarity_tx,
+                first_block_height.into(),
+                &pox_constants,
+                burn_tip_height.into(),
+                // this is the block height that the write occurs *during*
+                chain_tip.stacks_block_height + 1,
+            )?;
+        } else {
+            signer_set_calc = None;
+        }
+
         let auto_unlock_events = if evaluated_epoch >= StacksEpochId::Epoch21 {
             let unlock_events = Self::check_and_handle_reward_start(
                 burn_tip_height.into(),
@@ -5150,21 +5168,6 @@ impl StacksChainState {
             );
         }
 
-        // Handle signer stackerdb updates
-        let first_block_height = burn_dbconn.get_burn_start_height();
-        let signer_set_calc;
-        if evaluated_epoch >= StacksEpochId::Epoch25 {
-            signer_set_calc = NakamotoSigners::check_and_handle_prepare_phase_start(
-                &mut clarity_tx,
-                first_block_height.into(),
-                &pox_constants,
-                burn_tip_height.into(),
-                chain_tip.stacks_block_height,
-            )?;
-        } else {
-            signer_set_calc = None;
-        }
-
         debug!(
             "Setup block: ready to go for {}/{}",
             &chain_tip.consensus_hash,
diff --git a/stackslib/src/net/api/getstackers.rs b/stackslib/src/net/api/getstackers.rs
new file mode 100644
index 0000000000..f6a41ea0ff
--- /dev/null
+++ b/stackslib/src/net/api/getstackers.rs
@@ -0,0 +1,225 @@
+// Copyright (C) 2024 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+use regex::{Captures, Regex};
+use serde_json::json;
+use stacks_common::types::chainstate::StacksBlockId;
+use stacks_common::types::net::PeerHost;
+use stacks_common::util::hash::Sha256Sum;
+
+use crate::burnchains::Burnchain;
+use crate::chainstate::burn::db::sortdb::SortitionDB;
+use crate::chainstate::coordinator::OnChainRewardSetProvider;
+use crate::chainstate::stacks::boot::{
+    PoxVersions, RewardSet, POX_1_NAME, POX_2_NAME, POX_3_NAME, POX_4_NAME,
+};
+use crate::chainstate::stacks::db::StacksChainState;
+use crate::chainstate::stacks::Error as ChainError;
+use crate::core::mempool::MemPoolDB;
+use crate::net::http::{
+    parse_json, Error, HttpBadRequest, HttpNotFound, HttpRequest, HttpRequestContents,
+    HttpRequestPreamble, HttpResponse, HttpResponseContents, HttpResponsePayload,
+    HttpResponsePreamble, HttpServerError,
+};
+use crate::net::httpcore::{
+    HttpPreambleExtensions, HttpRequestContentsExtensions, RPCRequestHandler, StacksHttp,
+    StacksHttpRequest, StacksHttpResponse,
+};
+use crate::net::p2p::PeerNetwork;
+use crate::net::{Error as NetError, StacksNodeState, TipRequest};
+use crate::util_lib::boot::boot_code_id;
+use crate::util_lib::db::Error as DBError;
+
+#[derive(Clone, Default)]
+pub struct GetStackersRequestHandler {
+    cycle_number: Option<u64>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct GetStackersResponse {
+    pub stacker_set: RewardSet,
+}
+
+impl GetStackersResponse {
+    pub fn load(
+        sortdb: &SortitionDB,
+        chainstate: &mut StacksChainState,
+        tip: &StacksBlockId,
+        burnchain: &Burnchain,
+        cycle_number: u64,
+    ) -> Result<Self, String> {
+        let cycle_start_height = burnchain.reward_cycle_to_block_height(cycle_number);
+
+        let pox_contract_name = burnchain
+            .pox_constants
+            .active_pox_contract(cycle_start_height);
+        let pox_version = PoxVersions::lookup_by_name(pox_contract_name)
+            .ok_or("Failed to lookup PoX contract version at tip")?;
+        if !matches!(pox_version, PoxVersions::Pox4) {
+            return Err(
+                "Active PoX contract version at tip is Pre-PoX-4, the signer set is not fetchable"
+                    .into(),
+            );
+        }
+
+        let provider = OnChainRewardSetProvider::new();
+        let stacker_set = provider.read_reward_set_nakamoto(
+            cycle_start_height,
+            chainstate,
+            burnchain,
+            sortdb,
+            tip,
+            false,
+        ).map_err(
+            |e| format!("Could not read reward set. Prepare phase may not have started for this cycle yet. Cycle = {cycle_number}, Err = {e:?}")
+        )?;
+
+        Ok(Self { stacker_set })
+    }
+}
+
+/// Decode the HTTP request
+impl HttpRequest for GetStackersRequestHandler {
+    fn verb(&self) -> &'static str {
+        "GET"
+    }
+
+    fn path_regex(&self) -> Regex {
+        Regex::new(r#"^/v2/stacker_set/(?P<cycle_num>[0-9]{1,20})$"#).unwrap()
+    }
+
+    /// Try to decode this request.
+    /// There's nothing to load here, so just make sure the request is well-formed.
+    fn try_parse_request(
+        &mut self,
+        preamble: &HttpRequestPreamble,
+        captures: &Captures,
+        query: Option<&str>,
+        _body: &[u8],
+    ) -> Result<HttpRequestContents, Error> {
+        if preamble.get_content_length() != 0 {
+            return Err(Error::DecodeError(
+                "Invalid Http request: expected 0-length body".into(),
+            ));
+        }
+
+        let Some(cycle_num_str) = captures.name("cycle_num") else {
+            return Err(Error::DecodeError(
+                "Missing in request path: `cycle_num`".into(),
+            ));
+        };
+        let cycle_num = u64::from_str_radix(cycle_num_str.into(), 10)
+            .map_err(|e| Error::DecodeError(format!("Failed to parse cycle number: {e}")))?;
+
+        self.cycle_number = Some(cycle_num);
+
+        Ok(HttpRequestContents::new().query_string(query))
+    }
+}
+
+impl RPCRequestHandler for GetStackersRequestHandler {
+    /// Reset internal state
+    fn restart(&mut self) {
+        self.cycle_number = None;
+    }
+
+    /// Make the response
+    fn try_handle_request(
+        &mut self,
+        preamble: HttpRequestPreamble,
+        contents: HttpRequestContents,
+        node: &mut StacksNodeState,
+    ) -> Result<(HttpResponsePreamble, HttpResponseContents), NetError> {
+        let tip = match node.load_stacks_chain_tip(&preamble, &contents) {
+            Ok(tip) => tip,
+            Err(error_resp) => {
+                return error_resp.try_into_contents().map_err(NetError::from);
+            }
+        };
+        let Some(cycle_number) = self.cycle_number.clone() else {
+            return StacksHttpResponse::new_error(
+                    &preamble,
+                    &HttpBadRequest::new_json(json!({"response": "error", "err_msg": "Failed to read cycle number in request"}))
+                )
+                    .try_into_contents()
+                    .map_err(NetError::from);
+        };
+
+        let stacker_response =
+            node.with_node_state(|network, sortdb, chainstate, _mempool, _rpc_args| {
+                GetStackersResponse::load(
+                    sortdb,
+                    chainstate,
+                    &tip,
+                    network.get_burnchain(),
+                    cycle_number,
+                )
+            });
+
+        let response = match stacker_response {
+            Ok(response) => response,
+            Err(err_str) => {
+                return StacksHttpResponse::new_error(
+                    &preamble,
+                    &HttpBadRequest::new_json(json!({"response": "error", "err_msg": err_str})),
+                )
+                .try_into_contents()
+                .map_err(NetError::from)
+            }
+        };
+
+        let mut preamble = HttpResponsePreamble::ok_json(&preamble);
+        preamble.set_canonical_stacks_tip_height(Some(node.canonical_stacks_tip_height()));
+        let body = HttpResponseContents::try_from_json(&response)?;
+        Ok((preamble, body))
+    }
+}
+
+impl HttpResponse for GetStackersRequestHandler {
+    fn try_parse_response(
+        &self,
+        preamble: &HttpResponsePreamble,
+        body: &[u8],
+    ) -> Result<HttpResponsePayload, Error> {
+        let response: GetStackersResponse = parse_json(preamble, body)?;
+        Ok(HttpResponsePayload::try_from_json(response)?)
+    }
+}
+
+impl StacksHttpRequest {
+    /// Make a new getinfo request to this endpoint
+    pub fn new_getstackers(
+        host: PeerHost,
+        cycle_num: u64,
+        tip_req: TipRequest,
+    ) -> StacksHttpRequest {
+        StacksHttpRequest::new_for_peer(
+            host,
+            "GET".into(),
+            format!("/v2/stacker_set/{cycle_num}"),
+            HttpRequestContents::new().for_tip(tip_req),
+        )
+        .expect("FATAL: failed to construct request from infallible data")
+    }
+}
+
+impl StacksHttpResponse {
+    pub fn decode_stacker_set(self) -> Result<GetStackersResponse, NetError> {
+        let contents = self.get_http_payload_ok()?;
+        let response_json: serde_json::Value = contents.try_into()?;
+        let response: GetStackersResponse = serde_json::from_value(response_json)
+            .map_err(|_e| Error::DecodeError("Failed to decode JSON".to_string()))?;
+        Ok(response)
+    }
+}
diff --git a/stackslib/src/net/api/mod.rs b/stackslib/src/net/api/mod.rs
index c2efdb3402..03b8526112 100644
--- a/stackslib/src/net/api/mod.rs
+++ b/stackslib/src/net/api/mod.rs
@@ -53,6 +53,7 @@ pub mod getneighbors;
 pub mod getpoxinfo;
 pub mod getstackerdbchunk;
 pub mod getstackerdbmetadata;
+pub mod getstackers;
 pub mod getstxtransfercost;
 pub mod gettransaction_unconfirmed;
 pub mod liststackerdbreplicas;
@@ -118,6 +119,7 @@ impl StacksHttp {
         self.register_rpc_endpoint(postmicroblock::RPCPostMicroblockRequestHandler::new());
         self.register_rpc_endpoint(poststackerdbchunk::RPCPostStackerDBChunkRequestHandler::new());
         self.register_rpc_endpoint(posttransaction::RPCPostTransactionRequestHandler::new());
+        self.register_rpc_endpoint(getstackers::GetStackersRequestHandler::default());
     }
 }
 
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 84db7656ed..b6f7f30bcd 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -38,6 +38,7 @@ use stacks::core::{
     PEER_VERSION_EPOCH_2_1, PEER_VERSION_EPOCH_2_2, PEER_VERSION_EPOCH_2_3, PEER_VERSION_EPOCH_2_4,
     PEER_VERSION_EPOCH_2_5, PEER_VERSION_EPOCH_3_0,
 };
+use stacks::net::api::getstackers::GetStackersResponse;
 use stacks::net::api::postblock_proposal::{
     BlockValidateReject, BlockValidateResponse, NakamotoBlockProposal, ValidateRejectCode,
 };
@@ -133,6 +134,20 @@ lazy_static! {
     ];
 }
 
+pub fn get_stacker_set(http_origin: &str, cycle: u64) -> GetStackersResponse {
+    let client = reqwest::blocking::Client::new();
+    let path = format!("{http_origin}/v2/stacker_set/{cycle}");
+    let res = client
+        .get(&path)
+        .send()
+        .unwrap()
+        .json::<serde_json::Value>()
+        .unwrap();
+    info!("Stacker set response: {res}");
+    let res = serde_json::from_value(res).unwrap();
+    res
+}
+
 pub fn add_initial_balances(
     conf: &mut Config,
     accounts: usize,
@@ -938,6 +953,21 @@ fn correct_burn_outs() {
 
     info!("Bootstrapped to Epoch-3.0 boundary, Epoch2x miner should stop");
 
+    // we should already be able to query the stacker set via RPC
+    let burnchain = naka_conf.get_burnchain();
+    let first_epoch_3_cycle = burnchain
+        .block_height_to_reward_cycle(epoch_3.start_height)
+        .unwrap();
+
+    let http_origin = format!("http://{}", &naka_conf.node.rpc_bind);
+    let stacker_response = get_stacker_set(&http_origin, first_epoch_3_cycle);
+    assert!(stacker_response.stacker_set.signers.is_some());
+    assert_eq!(
+        stacker_response.stacker_set.signers.as_ref().unwrap().len(),
+        1
+    );
+    assert_eq!(stacker_response.stacker_set.rewarded_addresses.len(), 1);
+
     // first block wakes up the run loop, wait until a key registration has been submitted.
     next_block_and(&mut btc_regtest_controller, 60, || {
         let vrf_count = vrfs_submitted.load(Ordering::SeqCst);
@@ -954,7 +984,6 @@ fn correct_burn_outs() {
 
     info!("Bootstrapped to Epoch-3.0 boundary, mining nakamoto blocks");
 
-    let burnchain = naka_conf.get_burnchain();
     let sortdb = burnchain.open_sortition_db(true).unwrap();
 
     // Mine nakamoto tenures
@@ -1000,9 +1029,6 @@ fn correct_burn_outs() {
         "Stacker set should be sorted by cycle number already"
     );
 
-    let first_epoch_3_cycle = burnchain
-        .block_height_to_reward_cycle(epoch_3.start_height)
-        .unwrap();
     for (_, cycle_number, reward_set) in stacker_sets.iter() {
         if *cycle_number < first_epoch_3_cycle {
             assert!(reward_set.signers.is_none());

From 4cb5be5039d58ca4e3b6d342849c9498ec414d43 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Tue, 30 Jan 2024 17:04:49 -0600
Subject: [PATCH 0622/1166] fix: no need to bump coinbase height

---
 stackslib/src/chainstate/nakamoto/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index 2b1ea6b1e7..638bbb48d0 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -2511,7 +2511,7 @@ impl NakamotoChainState {
                 Self::calculate_matured_miner_rewards(
                     &mut clarity_tx,
                     sortition_dbconn.sqlite_conn(),
-                    coinbase_height + 1,
+                    coinbase_height,
                     matured_rewards_schedule,
                 )
             })

From 05e0f6973a4724686d3fa0e98002a3f3c2c9168a Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Wed, 31 Jan 2024 14:41:18 -0600
Subject: [PATCH 0623/1166] chore: fmt-stacks

---
 .../src/chainstate/nakamoto/coordinator/tests.rs | 10 ++++++++--
 stackslib/src/chainstate/nakamoto/tests/mod.rs   | 16 ++++++++++++++--
 2 files changed, 22 insertions(+), 4 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index 5689bf1d29..161d0079dd 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -291,7 +291,13 @@ fn replay_reward_cycle(
 fn test_simple_nakamoto_coordinator_bootup() {
     let mut test_signers = TestSigners::default();
     let test_stackers = TestStacker::common_signing_set(&test_signers);
-    let mut peer = boot_nakamoto(function_name!(), vec![], &test_signers, &test_stackers, None);
+    let mut peer = boot_nakamoto(
+        function_name!(),
+        vec![],
+        &test_signers,
+        &test_stackers,
+        None,
+    );
 
     let (burn_ops, mut tenure_change, miner_key) =
         peer.begin_nakamoto_tenure(TenureChangeCause::BlockFound);
@@ -477,7 +483,7 @@ fn test_nakamoto_chainstate_getters() {
         vec![(addr.into(), 100_000_000)],
         &test_signers,
         &test_stackers,
-        None
+        None,
     );
 
     let sort_tip = {
diff --git a/stackslib/src/chainstate/nakamoto/tests/mod.rs b/stackslib/src/chainstate/nakamoto/tests/mod.rs
index 07a6ec533a..d2de8b67dc 100644
--- a/stackslib/src/chainstate/nakamoto/tests/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/mod.rs
@@ -1503,7 +1503,13 @@ fn make_fork_run_with_arrivals(
 pub fn test_get_highest_nakamoto_tenure() {
     let test_signers = TestSigners::default();
     let test_stackers = TestStacker::common_signing_set(&test_signers);
-    let mut peer = boot_nakamoto(function_name!(), vec![], &test_signers, &test_stackers, None);
+    let mut peer = boot_nakamoto(
+        function_name!(),
+        vec![],
+        &test_signers,
+        &test_stackers,
+        None,
+    );
 
     // extract chainstate and sortdb -- we don't need the peer anymore
     let chainstate = &mut peer.stacks_node.as_mut().unwrap().chainstate;
@@ -1646,7 +1652,13 @@ pub fn test_get_highest_nakamoto_tenure() {
 fn test_make_miners_stackerdb_config() {
     let test_signers = TestSigners::default();
     let test_stackers = TestStacker::common_signing_set(&test_signers);
-    let mut peer = boot_nakamoto(function_name!(), vec![], &test_signers, &test_stackers, None);
+    let mut peer = boot_nakamoto(
+        function_name!(),
+        vec![],
+        &test_signers,
+        &test_stackers,
+        None,
+    );
 
     let naka_miner_hash160 = peer.miner.nakamoto_miner_hash160();
     let miner_keys: Vec<_> = (0..10).map(|_| StacksPrivateKey::new()).collect();

From 85a243b1898bea80cea47f6a3d429d3d44ef1176 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Thu, 1 Feb 2024 11:04:54 -0600
Subject: [PATCH 0624/1166] ci: add correct_burn_outs to workflows

---
 .github/workflows/bitcoin-tests.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/workflows/bitcoin-tests.yml b/.github/workflows/bitcoin-tests.yml
index 675fa0bf6c..ae465bbd44 100644
--- a/.github/workflows/bitcoin-tests.yml
+++ b/.github/workflows/bitcoin-tests.yml
@@ -75,6 +75,7 @@ jobs:
           - tests::nakamoto_integrations::mine_multiple_per_tenure_integration
           - tests::nakamoto_integrations::block_proposal_api_endpoint
           - tests::nakamoto_integrations::miner_writes_proposed_block_to_stackerdb
+          - tests::nakamoto_integrations::correct_burn_outs
           - tests::signer::stackerdb_dkg_sign
           - tests::signer::stackerdb_block_proposal
     steps:

From 6ded8d7a7e52609970668645be4469de5ab031cd Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Thu, 1 Feb 2024 12:25:08 -0600
Subject: [PATCH 0625/1166] chore: address PR comments

---
 clarity/src/vm/database/clarity_db.rs         | 16 ----
 stackslib/src/chainstate/coordinator/mod.rs   |  4 +-
 .../chainstate/nakamoto/coordinator/mod.rs    | 95 +++++++++----------
 .../chainstate/nakamoto/coordinator/tests.rs  |  4 -
 .../src/chainstate/nakamoto/signer_set.rs     |  3 +-
 stackslib/src/net/api/getstackers.rs          |  2 +-
 stackslib/src/net/api/mod.rs                  |  2 +-
 7 files changed, 52 insertions(+), 74 deletions(-)

diff --git a/clarity/src/vm/database/clarity_db.rs b/clarity/src/vm/database/clarity_db.rs
index 45d60bb62b..de4d5e0c47 100644
--- a/clarity/src/vm/database/clarity_db.rs
+++ b/clarity/src/vm/database/clarity_db.rs
@@ -619,22 +619,6 @@ impl<'a> ClarityDatabase<'a> {
             .map_err(|e| e.into())
     }
 
-    /// Set a metadata entry if it hasn't already been set, yielding
-    ///  a runtime error if it was. This should only be called by post-nakamoto
-    ///  contexts.
-    pub fn try_set_metadata(
-        &mut self,
-        contract_identifier: &QualifiedContractIdentifier,
-        key: &str,
-        data: &str,
-    ) -> Result<()> {
-        if self.store.has_metadata_entry(contract_identifier, key) {
-            Err(Error::Runtime(RuntimeErrorType::MetadataAlreadySet, None))
-        } else {
-            Ok(self.store.insert_metadata(contract_identifier, key, data))
-        }
-    }
-
     fn insert_metadata<T: ClaritySerializable>(
         &mut self,
         contract_identifier: &QualifiedContractIdentifier,
diff --git a/stackslib/src/chainstate/coordinator/mod.rs b/stackslib/src/chainstate/coordinator/mod.rs
index 66bc70a4c4..beb29b5661 100644
--- a/stackslib/src/chainstate/coordinator/mod.rs
+++ b/stackslib/src/chainstate/coordinator/mod.rs
@@ -327,7 +327,9 @@ impl<'a, T: BlockEventDispatcher> RewardSetProvider for OnChainRewardSetProvider
         //
         //  Data **cannot** be read from `.signers` in epoch 2.5 because the write occurs
         //   in the first block of the prepare phase, but the PoX anchor block is *before*
-        //   the prepare phase. Therefore
+        //   the prepare phase. Therefore, we fetch the reward set in the 2.x style, and then
+        //   apply the necessary nakamoto assertions if the reward set is going to be
+        //   active in Nakamoto (i.e., check for signer set existence).
 
         let is_nakamoto_reward_set = match SortitionDB::get_stacks_epoch_by_epoch_id(
             sortdb.conn(),
diff --git a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
index 68976d6283..937f7102a2 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
@@ -53,6 +53,26 @@ use crate::util_lib::db::Error as DBError;
 #[cfg(test)]
 pub mod tests;
 
+macro_rules! err_or_debug {
+    ($debug_bool:expr, $($arg:tt)*) => ({
+        if $debug_bool {
+            debug!($($arg)*)
+        } else {
+            error!($($arg)*)
+        }
+    })
+}
+
+macro_rules! inf_or_debug {
+    ($debug_bool:expr, $($arg:tt)*) => ({
+        if $debug_bool {
+            debug!($($arg)*)
+        } else {
+            info!($($arg)*)
+        }
+    })
+}
+
 impl<'a, T: BlockEventDispatcher> OnChainRewardSetProvider<'a, T> {
     /// Read a reward_set written while updating .signers
     /// `debug_log` should be set to true if the reward set loading should
@@ -70,6 +90,7 @@ impl<'a, T: BlockEventDispatcher> OnChainRewardSetProvider<'a, T> {
         let cycle = burnchain
             .block_height_to_reward_cycle(cycle_start_burn_height)
             .expect("FATAL: no reward cycle for burn height");
+
         // figure out the block ID
         let Some(coinbase_height_of_calculation) = chainstate
             .eval_boot_code_read_only(
@@ -81,17 +102,11 @@ impl<'a, T: BlockEventDispatcher> OnChainRewardSetProvider<'a, T> {
             .expect_optional()
             .map(|x| u64::try_from(x.expect_u128()).expect("FATAL: block height exceeded u64"))
         else {
-            if debug_log {
-                debug!(
-                    "The reward set was not written to .signers before it was needed by Nakamoto";
-                    "cycle_number" => cycle,
-                );
-            } else {
-                error!(
-                    "The reward set was not written to .signers before it was needed by Nakamoto";
-                    "cycle_number" => cycle,
-                );
-            }
+            err_or_debug!(
+                debug_log,
+                "The reward set was not written to .signers before it was needed by Nakamoto";
+                "cycle_number" => cycle,
+            );
             return Err(Error::PoXAnchorBlockRequired);
         };
 
@@ -101,11 +116,10 @@ impl<'a, T: BlockEventDispatcher> OnChainRewardSetProvider<'a, T> {
             coinbase_height_of_calculation,
         )?
         else {
-            if debug_log {
-                debug!("Failed to find the block in which .signers was written");
-            } else {
-                error!("Failed to find the block in which .signers was written");
-            }
+            err_or_debug!(
+                debug_log,
+                "Failed to find the block in which .signers was written"
+            );
             return Err(Error::PoXAnchorBlockRequired);
         };
 
@@ -114,18 +128,12 @@ impl<'a, T: BlockEventDispatcher> OnChainRewardSetProvider<'a, T> {
             &reward_set_block.index_block_hash(),
         )?
         else {
-            if debug_log {
-                debug!(
-                    "No reward set stored at the block in which .signers was written";
-                    "checked_block" => %reward_set_block.index_block_hash()
-                );
-            } else {
-                error!(
-                    "No reward set stored at the block in which .signers was written";
-                    "checked_block" => %reward_set_block.index_block_hash(),
-                    "coinbase_height_of_calculation" => coinbase_height_of_calculation,
-                );
-            }
+            err_or_debug!(
+                debug_log,
+                "No reward set stored at the block in which .signers was written";
+                "checked_block" => %reward_set_block.index_block_hash(),
+                "coinbase_height_of_calculation" => coinbase_height_of_calculation,
+            );
             return Err(Error::PoXAnchorBlockRequired);
         };
 
@@ -134,32 +142,21 @@ impl<'a, T: BlockEventDispatcher> OnChainRewardSetProvider<'a, T> {
         //  Non participation is fatal.
         if reward_set.rewarded_addresses.is_empty() {
             // no one is stacking
-            if debug_log {
-                debug!("No PoX participation");
-            } else {
-                error!("No PoX participation");
-            }
+            err_or_debug!(debug_log, "No PoX participation");
             return Err(Error::PoXAnchorBlockRequired);
         }
 
-        if debug_log {
-            debug!(
-                "PoX reward set loaded from written block state";
-                "reward_set_block_id" => %reward_set_block.index_block_hash(),
-            );
-        } else {
-            info!(
-                "PoX reward set loaded from written block state";
-                "reward_set_block_id" => %reward_set_block.index_block_hash(),
-            );
-        }
+        inf_or_debug!(
+            debug_log,
+            "PoX reward set loaded from written block state";
+            "reward_set_block_id" => %reward_set_block.index_block_hash(),
+        );
 
         if reward_set.signers.is_none() {
-            if debug_log {
-                debug!("FATAL: PoX reward set did not specify signer set in Nakamoto");
-            } else {
-                error!("FATAL: PoX reward set did not specify signer set in Nakamoto");
-            }
+            err_or_debug!(
+                debug_log,
+                "FATAL: PoX reward set did not specify signer set in Nakamoto"
+            );
             return Err(Error::PoXAnchorBlockRequired);
         }
 
diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index 161d0079dd..8dae7a39db 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -68,10 +68,6 @@ fn advance_to_nakamoto(
     )
     .unwrap();
 
-    // use the signing key of addr, otherwise the test stackers
-    //  will not stack enough for any single signing key
-    // let signing_key = StacksPublicKey::from_private(&private_key);
-
     for sortition_height in 0..11 {
         // stack to pox-3 in cycle 7
         let txs = if sortition_height == 6 {
diff --git a/stackslib/src/chainstate/nakamoto/signer_set.rs b/stackslib/src/chainstate/nakamoto/signer_set.rs
index 261133e3f2..6ad605c35f 100644
--- a/stackslib/src/chainstate/nakamoto/signer_set.rs
+++ b/stackslib/src/chainstate/nakamoto/signer_set.rs
@@ -1,5 +1,4 @@
-// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
-// Copyright (C) 2020-2023 Stacks Open Internet Foundation
+// Copyright (C) 2024 Stacks Open Internet Foundation
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
diff --git a/stackslib/src/net/api/getstackers.rs b/stackslib/src/net/api/getstackers.rs
index f6a41ea0ff..2c5c1240d1 100644
--- a/stackslib/src/net/api/getstackers.rs
+++ b/stackslib/src/net/api/getstackers.rs
@@ -80,7 +80,7 @@ impl GetStackersResponse {
             burnchain,
             sortdb,
             tip,
-            false,
+            true,
         ).map_err(
             |e| format!("Could not read reward set. Prepare phase may not have started for this cycle yet. Cycle = {cycle_number}, Err = {e:?}")
         )?;
diff --git a/stackslib/src/net/api/mod.rs b/stackslib/src/net/api/mod.rs
index 03b8526112..e55e309374 100644
--- a/stackslib/src/net/api/mod.rs
+++ b/stackslib/src/net/api/mod.rs
@@ -106,6 +106,7 @@ impl StacksHttp {
         self.register_rpc_endpoint(
             getstackerdbmetadata::RPCGetStackerDBMetadataRequestHandler::new(),
         );
+        self.register_rpc_endpoint(getstackers::GetStackersRequestHandler::default());
         self.register_rpc_endpoint(
             gettransaction_unconfirmed::RPCGetTransactionUnconfirmedRequestHandler::new(),
         );
@@ -119,7 +120,6 @@ impl StacksHttp {
         self.register_rpc_endpoint(postmicroblock::RPCPostMicroblockRequestHandler::new());
         self.register_rpc_endpoint(poststackerdbchunk::RPCPostStackerDBChunkRequestHandler::new());
         self.register_rpc_endpoint(posttransaction::RPCPostTransactionRequestHandler::new());
-        self.register_rpc_endpoint(getstackers::GetStackersRequestHandler::default());
     }
 }
 

From c6a54db6018277d17ef065c1fbfefdba5d5b7922 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Fri, 2 Feb 2024 21:17:18 -0600
Subject: [PATCH 0626/1166] fix: address merge issues from `next`

---
 stackslib/src/burnchains/burnchain.rs         | 12 +++++++
 .../chainstate/nakamoto/coordinator/mod.rs    | 13 ++++---
 .../src/chainstate/nakamoto/signer_set.rs     | 35 ++++++++++---------
 stackslib/src/chainstate/stacks/boot/mod.rs   |  2 +-
 4 files changed, 40 insertions(+), 22 deletions(-)

diff --git a/stackslib/src/burnchains/burnchain.rs b/stackslib/src/burnchains/burnchain.rs
index c7f85471ff..10f04d5044 100644
--- a/stackslib/src/burnchains/burnchain.rs
+++ b/stackslib/src/burnchains/burnchain.rs
@@ -489,6 +489,18 @@ impl Burnchain {
             .reward_cycle_to_block_height(self.first_block_height, reward_cycle)
     }
 
+    pub fn next_reward_cycle(&self, block_height: u64) -> Option<u64> {
+        let cycle = self.block_height_to_reward_cycle(block_height)?;
+        let effective_height = block_height.checked_sub(self.first_block_height)?;
+        let next_bump = 
+            if effective_height % u64::from(self.pox_constants.reward_cycle_length) == 0 {
+                0
+            } else {
+                1
+            };
+        Some(cycle + next_bump)
+    }
+
     pub fn block_height_to_reward_cycle(&self, block_height: u64) -> Option<u64> {
         self.pox_constants
             .block_height_to_reward_cycle(self.first_block_height, block_height)
diff --git a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
index 937f7102a2..15973cd291 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
@@ -100,7 +100,13 @@ impl<'a, T: BlockEventDispatcher> OnChainRewardSetProvider<'a, T> {
                 &format!("(map-get? cycle-set-height u{})", cycle),
             )?
             .expect_optional()
-            .map(|x| u64::try_from(x.expect_u128()).expect("FATAL: block height exceeded u64"))
+            .map_err(|e| Error::ChainstateError(e.into()))?
+            .map(|x| {
+                let as_u128 = x.expect_u128()?;
+                Ok(u64::try_from(as_u128).expect("FATAL: block height exceeded u64"))
+            })
+            .transpose()
+            .map_err(|e| Error::ChainstateError(ChainstateError::ClarityError(e)))?
         else {
             err_or_debug!(
                 debug_log,
@@ -239,9 +245,8 @@ pub fn get_nakamoto_reward_cycle_info<U: RewardSetProvider>(
 
     // calculating the reward set for the _next_ reward cycle
     let reward_cycle = burnchain
-        .block_height_to_reward_cycle(burn_height)
-        .expect("FATAL: no reward cycle for burn height")
-        + 1;
+        .next_reward_cycle(burn_height)
+        .expect("FATAL: no reward cycle for burn height");
     let reward_start_height = burnchain.reward_cycle_to_block_height(reward_cycle);
 
     debug!("Processing reward set for Nakamoto reward cycle";
diff --git a/stackslib/src/chainstate/nakamoto/signer_set.rs b/stackslib/src/chainstate/nakamoto/signer_set.rs
index 6ad605c35f..c0bfbfe078 100644
--- a/stackslib/src/chainstate/nakamoto/signer_set.rs
+++ b/stackslib/src/chainstate/nakamoto/signer_set.rs
@@ -99,7 +99,7 @@ pub struct SignerCalculation {
 }
 
 impl RawRewardSetEntry {
-    pub fn from_pox_4_tuple(is_mainnet: bool, tuple: TupleData) -> Self {
+    pub fn from_pox_4_tuple(is_mainnet: bool, tuple: TupleData) -> Result<Self, ChainstateError> {
         let mut tuple_data = tuple.data_map;
 
         let pox_addr_tuple = tuple_data
@@ -114,18 +114,19 @@ impl RawRewardSetEntry {
             .expect(
                 "FATAL: no 'total-ustx' in return value from (pox-4.get-reward-set-pox-address)",
             )
-            .expect_u128();
+            .expect_u128()?;
 
         let stacker = tuple_data
             .remove("stacker")
             .expect("FATAL: no 'stacker' in return value from (pox-4.get-reward-set-pox-address)")
-            .expect_optional()
-            .map(|value| value.expect_principal());
+            .expect_optional()?
+            .map(|value| value.expect_principal())
+            .transpose()?;
 
         let signer = tuple_data
             .remove("signer")
             .expect("FATAL: no 'signer' in return value from (pox-4.get-reward-set-pox-address)")
-            .expect_buff(SIGNERS_PK_LEN);
+            .expect_buff(SIGNERS_PK_LEN)?;
 
         // (buff 33) only enforces max size, not min size, so we need to do a len check
         let pk_bytes = if signer.len() == SIGNERS_PK_LEN {
@@ -144,12 +145,12 @@ impl RawRewardSetEntry {
             "signer" => to_hex(&signer),
         );
 
-        Self {
+        Ok(Self {
             reward_address,
             amount_stacked: total_ustx,
             stacker,
             signer: Some(pk_bytes),
-        }
+        })
     }
 }
 
@@ -177,7 +178,7 @@ impl NakamotoSigners {
                     reward_cycle.into(),
                 ))],
             )?
-            .expect_u128();
+            .expect_u128()?;
 
         let mut slots = vec![];
         for index in 0..list_length {
@@ -190,14 +191,14 @@ impl NakamotoSigners {
                         SymbolicExpression::atom_value(Value::UInt(index)),
                     ],
                 )?
-                .expect_optional()
+                .expect_optional()?
                 .expect(&format!(
                     "FATAL: missing PoX address in slot {} out of {} in reward cycle {}",
                     index, list_length, reward_cycle
                 ))
-                .expect_tuple();
+                .expect_tuple()?;
 
-            let entry = RawRewardSetEntry::from_pox_4_tuple(is_mainnet, tuple);
+            let entry = RawRewardSetEntry::from_pox_4_tuple(is_mainnet, tuple)?;
 
             slots.push(entry)
         }
@@ -216,7 +217,7 @@ impl NakamotoSigners {
         let sender_addr = PrincipalData::from(boot::boot_code_addr(is_mainnet));
         let signers_contract = &boot_code_id(SIGNERS_NAME, is_mainnet);
 
-        let liquid_ustx = clarity.with_clarity_db_readonly(|db| db.get_total_liquid_ustx());
+        let liquid_ustx = clarity.with_clarity_db_readonly(|db| db.get_total_liquid_ustx())?;
         let reward_slots = Self::get_reward_slots(clarity, reward_cycle, pox_contract)?;
         let (threshold, participation) = StacksChainState::get_reward_threshold_and_participation(
             &pox_constants,
@@ -338,10 +339,10 @@ impl NakamotoSigners {
         let signers_contract = &boot_code_id(SIGNERS_NAME, clarity_tx.config.mainnet);
 
         // are we the first block in the prepare phase in our fork?
-        let needs_update = clarity_tx.connection().with_clarity_db_readonly(|clarity_db| {
+        let needs_update: Result<_, ChainstateError>  = clarity_tx.connection().with_clarity_db_readonly(|clarity_db| {
             if !clarity_db.has_contract(signers_contract) {
                 // if there's no signers contract, no need to update anything.
-                return false
+                return Ok(false)
             }
             let Ok(value) = clarity_db.lookup_variable_unknown_descriptor(
                 signers_contract,
@@ -351,13 +352,13 @@ impl NakamotoSigners {
                 error!("FATAL: Failed to read `{SIGNERS_UPDATE_STATE}` variable from .signers contract");
                 panic!();
             };
-            let cycle_number = value.expect_u128();
+            let cycle_number = value.expect_u128()?;
             // if the cycle_number is less than `cycle_of_prepare_phase`, we need to update
             //  the .signers state.
-            cycle_number < cycle_of_prepare_phase.into()
+            Ok(cycle_number < cycle_of_prepare_phase.into())
         });
 
-        if !needs_update {
+        if !needs_update? {
             debug!("Current cycle has already been setup in .signers or .signers is not initialized yet");
             return Ok(None);
         }
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 9c8ad4321f..a99a15b032 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -1211,7 +1211,7 @@ impl StacksChainState {
                 ))
                 .expect_tuple()?;
 
-            let entry = RawRewardSetEntry::from_pox_4_tuple(self.mainnet, tuple);
+            let entry = RawRewardSetEntry::from_pox_4_tuple(self.mainnet, tuple)?;
             ret.push(entry)
         }
 

From c90d0b4ce1e5de40d34e55d61e621b85c99327c3 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Fri, 2 Feb 2024 21:19:31 -0600
Subject: [PATCH 0627/1166] chore: cargo fmt-stacks

---
 stackslib/src/burnchains/burnchain.rs | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/stackslib/src/burnchains/burnchain.rs b/stackslib/src/burnchains/burnchain.rs
index 10f04d5044..d4d936b332 100644
--- a/stackslib/src/burnchains/burnchain.rs
+++ b/stackslib/src/burnchains/burnchain.rs
@@ -492,12 +492,12 @@ impl Burnchain {
     pub fn next_reward_cycle(&self, block_height: u64) -> Option<u64> {
         let cycle = self.block_height_to_reward_cycle(block_height)?;
         let effective_height = block_height.checked_sub(self.first_block_height)?;
-        let next_bump = 
-            if effective_height % u64::from(self.pox_constants.reward_cycle_length) == 0 {
-                0
-            } else {
-                1
-            };
+        let next_bump = if effective_height % u64::from(self.pox_constants.reward_cycle_length) == 0
+        {
+            0
+        } else {
+            1
+        };
         Some(cycle + next_bump)
     }
 

From 603ff721addbf36375620db5323f8f05da746bae Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Mon, 5 Feb 2024 07:50:31 -0800
Subject: [PATCH 0628/1166] feat: add explicit `reward-cycle` to
 verify-signer-signature functions

---
 stackslib/src/chainstate/stacks/boot/pox-4.clar     | 13 +++++++------
 stackslib/src/chainstate/stacks/boot/pox_4_tests.rs | 10 ++++++++--
 2 files changed, 15 insertions(+), 8 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index 44799e9715..45224ac41a 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -603,7 +603,7 @@
         (err ERR_STACKING_INSUFFICIENT_FUNDS))
 
       ;; Validate ownership of the given signer key
-      (try! (verify-signer-key-sig pox-addr signer-sig signer-key))
+      (try! (verify-signer-key-sig pox-addr (- first-reward-cycle u1) signer-sig signer-key))
 
       ;; ensure that stacking can be performed
       (try! (can-stack-stx pox-addr amount-ustx first-reward-cycle lock-period))
@@ -684,12 +684,12 @@
 ;; The message hash follows SIP018 for signing structured data. The structured data
 ;; is the tuple `{ pox-addr: { version, hashbytes }, reward-cycle }`. The domain is
 ;; `{ name: "pox-4-signer", version: "1.0.0", chain-id: chain-id }`.
-(define-read-only (get-signer-key-message-hash (pox-addr { version: (buff 1), hashbytes: (buff 32) }))
+(define-read-only (get-signer-key-message-hash (pox-addr { version: (buff 1), hashbytes: (buff 32) }) (reward-cycle uint))
   (let
     (
       (domain { name: "pox-4-signer", version: "1.0.0", chain-id: chain-id })
       (data-hash (sha256 (unwrap-panic
-        (to-consensus-buff? { pox-addr: pox-addr, reward-cycle: (current-pox-reward-cycle) }))))
+        (to-consensus-buff? { pox-addr: pox-addr, reward-cycle: reward-cycle }))))
       (domain-hash (sha256 (unwrap-panic (to-consensus-buff? domain))))
     )
     (sha256 (concat
@@ -706,11 +706,12 @@
 ;; not the reward cycle at which the delegation will start.
 ;; The public key is recovered from the signature and compared to `signer-key`.
 (define-read-only (verify-signer-key-sig (pox-addr { version: (buff 1), hashbytes: (buff 32) })
+                                         (reward-cycle uint)
                                          (signer-sig (buff 65))
                                          (signer-key (buff 33)))
   (let
     (
-      (msg-hash (get-signer-key-message-hash pox-addr))
+      (msg-hash (get-signer-key-message-hash pox-addr reward-cycle))
       (pubkey (unwrap! (secp256k1-recover? msg-hash signer-sig) (err ERR_INVALID_SIGNATURE_RECOVER)))
     )
     (asserts! (is-eq pubkey signer-key) (err ERR_INVALID_SIGNATURE_PUBKEY))
@@ -741,7 +742,7 @@
     ;; must be called directly by the tx-sender or by an allowed contract-caller
     (asserts! (check-caller-allowed)
               (err ERR_STACKING_PERMISSION_DENIED))
-    (try! (verify-signer-key-sig pox-addr signer-sig signer-key))
+    (try! (verify-signer-key-sig pox-addr (- reward-cycle u1) signer-sig signer-key))
     (let ((amount-ustx (get stacked-amount partial-stacked)))
       (try! (can-stack-stx pox-addr amount-ustx reward-cycle u1))
       ;; Add the pox addr to the reward cycle, and extract the index of the PoX address
@@ -1061,7 +1062,7 @@
               (err ERR_STACKING_IS_DELEGATED))
 
     ;; Verify signature from delegate that allows this sender for this cycle
-    (try! (verify-signer-key-sig pox-addr signer-sig signer-key))
+    (try! (verify-signer-key-sig pox-addr cur-cycle signer-sig signer-key))
 
     ;; TODO: add more assertions to sanity check the `stacker-info` values with
     ;;       the `stacker-state` values
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index a779149e3a..070818397a 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -1430,6 +1430,7 @@ fn verify_signer_key_sig(
     pox_addr: &PoxAddress,
     peer: &mut TestPeer,
     latest_block: &StacksBlockId,
+    reward_cycle: u128,
 ) -> Value {
     let result: Value = with_sortdb(peer, |ref mut chainstate, ref mut sortdb| {
         chainstate
@@ -1444,8 +1445,9 @@ fn verify_signer_key_sig(
                         LimitedCostTracker::new_free(),
                         |env| {
                             let program = format!(
-                                "(verify-signer-key-sig {} 0x{} 0x{})",
+                                "(verify-signer-key-sig {} u{} 0x{} 0x{})",
                                 Value::Tuple(pox_addr.clone().as_clarity_tuple().unwrap()),
+                                reward_cycle,
                                 to_hex(&signature),
                                 signing_key.to_hex(),
                             );
@@ -1519,6 +1521,7 @@ fn verify_signer_key_signatures() {
         &bob_pox_addr,
         &mut peer,
         &latest_block,
+        reward_cycle,
     );
     assert_eq!(result, expected_error);
 
@@ -1532,6 +1535,7 @@ fn verify_signer_key_signatures() {
         &bob_pox_addr, // wrong pox-addr
         &mut peer,
         &latest_block,
+        reward_cycle,
     );
 
     assert_eq!(result, expected_error);
@@ -1546,6 +1550,7 @@ fn verify_signer_key_signatures() {
         &bob_pox_addr,
         &mut peer,
         &latest_block,
+        reward_cycle,
     );
 
     assert_eq!(result, expected_error);
@@ -1560,6 +1565,7 @@ fn verify_signer_key_signatures() {
         &bob_pox_addr,
         &mut peer,
         &latest_block,
+        reward_cycle,
     );
 
     assert_eq!(result, Value::okay_true());
@@ -2410,7 +2416,7 @@ fn delegate_stack_stx_extend_signer_key() {
     );
 
     let extend_signature =
-        make_signer_key_signature(&pox_addr, &signer_extend_sk, reward_cycle.into());
+        make_signer_key_signature(&pox_addr, &signer_extend_sk, (extend_cycle - 1).into());
 
     let agg_tx_1 = make_pox_4_contract_call(
         bob_delegate_private_key,

From 581bd0b74ee5fc836976e39b566c778db72bb7ff Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Mon, 5 Feb 2024 08:19:03 -0800
Subject: [PATCH 0629/1166] fix: typo from merge

---
 testnet/stacks-node/src/tests/signer.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index 8d97dda4ef..ca047785fa 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -114,6 +114,7 @@ impl SignerTest {
             &naka_conf.node.rpc_bind,
             &signers_stacker_db_contract_id.to_string(),
             Some(Duration::from_millis(128)), // Timeout defaults to 5 seconds. Let's override it to 128 milliseconds.
+            &Network::Testnet,
         );
 
         let mut running_signers = HashMap::new();

From 2c120adf5469a5cfba1e01e64846b5736646fd43 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Mon, 5 Feb 2024 13:00:40 -0600
Subject: [PATCH 0630/1166] fix get_stacker_set docs

---
 docs/rpc/api/core-node/get_stacker_set.400.example.json | 2 +-
 docs/rpc/openapi.yaml                                   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/rpc/api/core-node/get_stacker_set.400.example.json b/docs/rpc/api/core-node/get_stacker_set.400.example.json
index 0ca1688c68..263129a1c6 100644
--- a/docs/rpc/api/core-node/get_stacker_set.400.example.json
+++ b/docs/rpc/api/core-node/get_stacker_set.400.example.json
@@ -1,4 +1,4 @@
 {
   "response": "error",
-  "err_msg": "Could not read reward set. Prepare phase may not have started for this cycle yet. Cycle = 22, Err= PoXAnchorBlockRequired"
+  "err_msg": "Could not read reward set. Prepare phase may not have started for this cycle yet. Cycle = 22, Err = PoXAnchorBlockRequired"
 }
diff --git a/docs/rpc/openapi.yaml b/docs/rpc/openapi.yaml
index 6018a61ba3..ceaf0e4a9d 100644
--- a/docs/rpc/openapi.yaml
+++ b/docs/rpc/openapi.yaml
@@ -593,7 +593,7 @@ paths:
       description: |
         Used to get stacker and signer set information for a given cycle.
 
-        This will only return information for cycles started in Epoch-2.5 where PoX-4 was active.
+        This will only return information for cycles started in Epoch-2.5 where PoX-4 was active and subsequent cycles.
       responses:
         200:
           description: Information for the given reward cycle

From 660059f49cf692ff2fbc766ea63697e5a4616f82 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Mon, 5 Feb 2024 11:10:31 -0800
Subject: [PATCH 0631/1166] wip: updated pox-4 signature data

---
 .../chainstate/nakamoto/coordinator/tests.rs  |  10 +-
 stackslib/src/chainstate/stacks/boot/mod.rs   |  28 +-
 .../src/chainstate/stacks/boot/pox-4.clar     |  34 ++-
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 248 +++++++++++++++---
 stackslib/src/net/tests/mod.rs                |   2 +
 .../src/util_lib/signed_structured_data.rs    |  80 +++++-
 testnet/stacks-node/src/tests/signer.rs       |   4 +-
 7 files changed, 338 insertions(+), 68 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index 91d5007f98..6b79fae534 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -51,6 +51,7 @@ use crate::net::relay::Relayer;
 use crate::net::stackerdb::StackerDBConfig;
 use crate::net::test::{TestEventObserver, TestPeer, TestPeerConfig};
 use crate::util_lib::boot::boot_code_id;
+use crate::util_lib::signed_structured_data::pox4::Pox4SignatureTopic;
 
 /// Bring a TestPeer into the Nakamoto Epoch
 fn advance_to_nakamoto(
@@ -79,8 +80,13 @@ fn advance_to_nakamoto(
                         AddressHashMode::SerializeP2PKH,
                         addr.bytes.clone(),
                     );
-                    let signature =
-                        make_signer_key_signature(&pox_addr, &test_stacker.signer_private_key, 6);
+                    let signature = make_signer_key_signature(
+                        &pox_addr,
+                        &test_stacker.signer_private_key,
+                        6,
+                        &Pox4SignatureTopic::StackStx,
+                        12_u128,
+                    );
                     make_pox_4_lockup(
                         &test_stacker.stacker_private_key,
                         0,
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 3b5aa6e2c0..04132a8a16 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -1401,6 +1401,9 @@ pub mod test {
     use crate::core::{StacksEpochId, *};
     use crate::net::test::*;
     use crate::util_lib::boot::{boot_code_id, boot_code_test_addr};
+    use crate::util_lib::signed_structured_data::pox4::{
+        make_pox_4_signer_key_signature, Pox4SignatureTopic,
+    };
     use crate::util_lib::signed_structured_data::{
         make_structured_data_domain, sign_structured_data,
     };
@@ -2222,21 +2225,18 @@ pub mod test {
         pox_addr: &PoxAddress,
         signer_key: &StacksPrivateKey,
         reward_cycle: u128,
+        topic: &Pox4SignatureTopic,
+        period: u128,
     ) -> Vec<u8> {
-        let domain_tuple = make_structured_data_domain("pox-4-signer", "1.0.0", CHAIN_ID_TESTNET);
-
-        let data_tuple = Value::Tuple(
-            TupleData::from_data(vec![
-                (
-                    "pox-addr".into(),
-                    pox_addr.clone().as_clarity_tuple().unwrap().into(),
-                ),
-                ("reward-cycle".into(), Value::UInt(reward_cycle)),
-            ])
-            .unwrap(),
-        );
-
-        let signature = sign_structured_data(data_tuple, domain_tuple, signer_key).unwrap();
+        let signature = make_pox_4_signer_key_signature(
+            pox_addr,
+            signer_key,
+            reward_cycle,
+            topic,
+            CHAIN_ID_TESTNET,
+            period,
+        )
+        .unwrap();
 
         signature.to_rsv()
     }
diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index 45224ac41a..a0be44d554 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -603,7 +603,7 @@
         (err ERR_STACKING_INSUFFICIENT_FUNDS))
 
       ;; Validate ownership of the given signer key
-      (try! (verify-signer-key-sig pox-addr (- first-reward-cycle u1) signer-sig signer-key))
+      (try! (verify-signer-key-sig pox-addr (- first-reward-cycle u1) "stack-stx" lock-period signer-sig signer-key))
 
       ;; ensure that stacking can be performed
       (try! (can-stack-stx pox-addr amount-ustx first-reward-cycle lock-period))
@@ -684,12 +684,20 @@
 ;; The message hash follows SIP018 for signing structured data. The structured data
 ;; is the tuple `{ pox-addr: { version, hashbytes }, reward-cycle }`. The domain is
 ;; `{ name: "pox-4-signer", version: "1.0.0", chain-id: chain-id }`.
-(define-read-only (get-signer-key-message-hash (pox-addr { version: (buff 1), hashbytes: (buff 32) }) (reward-cycle uint))
+(define-read-only (get-signer-key-message-hash (pox-addr { version: (buff 1), hashbytes: (buff 32) }) 
+                                               (reward-cycle uint)
+                                               (topic (string-ascii 12))
+                                               (period uint))
   (let
     (
       (domain { name: "pox-4-signer", version: "1.0.0", chain-id: chain-id })
       (data-hash (sha256 (unwrap-panic
-        (to-consensus-buff? { pox-addr: pox-addr, reward-cycle: reward-cycle }))))
+        (to-consensus-buff? { 
+          pox-addr: pox-addr, 
+          reward-cycle: reward-cycle,
+          topic: topic,
+          period: period,
+        }))))
       (domain-hash (sha256 (unwrap-panic (to-consensus-buff? domain))))
     )
     (sha256 (concat
@@ -707,14 +715,18 @@
 ;; The public key is recovered from the signature and compared to `signer-key`.
 (define-read-only (verify-signer-key-sig (pox-addr { version: (buff 1), hashbytes: (buff 32) })
                                          (reward-cycle uint)
+                                         (topic (string-ascii 12))
+                                         (period uint)
                                          (signer-sig (buff 65))
                                          (signer-key (buff 33)))
-  (let
-    (
-      (msg-hash (get-signer-key-message-hash pox-addr reward-cycle))
-      (pubkey (unwrap! (secp256k1-recover? msg-hash signer-sig) (err ERR_INVALID_SIGNATURE_RECOVER)))
-    )
-    (asserts! (is-eq pubkey signer-key) (err ERR_INVALID_SIGNATURE_PUBKEY))
+  (begin
+    (asserts! 
+      (is-eq 
+        (unwrap! (secp256k1-recover? 
+          (get-signer-key-message-hash pox-addr reward-cycle topic period) 
+          signer-sig) (err ERR_INVALID_SIGNATURE_RECOVER)) 
+        signer-key) 
+      (err ERR_INVALID_SIGNATURE_PUBKEY))
     (ok true)
   )
 )
@@ -742,7 +754,7 @@
     ;; must be called directly by the tx-sender or by an allowed contract-caller
     (asserts! (check-caller-allowed)
               (err ERR_STACKING_PERMISSION_DENIED))
-    (try! (verify-signer-key-sig pox-addr (- reward-cycle u1) signer-sig signer-key))
+    (try! (verify-signer-key-sig pox-addr (- reward-cycle u1) "agg-commit" u1 signer-sig signer-key))
     (let ((amount-ustx (get stacked-amount partial-stacked)))
       (try! (can-stack-stx pox-addr amount-ustx reward-cycle u1))
       ;; Add the pox addr to the reward cycle, and extract the index of the PoX address
@@ -1062,7 +1074,7 @@
               (err ERR_STACKING_IS_DELEGATED))
 
     ;; Verify signature from delegate that allows this sender for this cycle
-    (try! (verify-signer-key-sig pox-addr cur-cycle signer-sig signer-key))
+    (try! (verify-signer-key-sig pox-addr cur-cycle "stack-extend" extend-count signer-sig signer-key))
 
     ;; TODO: add more assertions to sanity check the `stacker-info` values with
     ;;       the `stacker-state` values
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 070818397a..f851c097d4 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -76,6 +76,7 @@ use crate::core::*;
 use crate::net::test::{TestEventObserver, TestPeer};
 use crate::util_lib::boot::boot_code_id;
 use crate::util_lib::db::{DBConn, FromRow};
+use crate::util_lib::signed_structured_data::pox4::Pox4SignatureTopic;
 use crate::util_lib::signed_structured_data::structured_data_message_hash;
 
 const USTX_PER_HOLDER: u128 = 1_000_000;
@@ -492,8 +493,13 @@ fn pox_extend_transition() {
         key_to_stacks_addr(&alice).bytes,
     );
 
-    let alice_signature =
-        make_signer_key_signature(&alice_pox_addr, &alice_signer_private, reward_cycle);
+    let alice_signature = make_signer_key_signature(
+        &alice_pox_addr,
+        &alice_signer_private,
+        reward_cycle,
+        &Pox4SignatureTopic::StackStx,
+        4_u128,
+    );
     let alice_lockup = make_pox_4_lockup(
         &alice,
         2,
@@ -558,7 +564,13 @@ fn pox_extend_transition() {
         key_to_stacks_addr(&bob).bytes,
     );
 
-    let bob_signature = make_signer_key_signature(&bob_pox_addr, &bob_signer_private, reward_cycle);
+    let bob_signature = make_signer_key_signature(
+        &bob_pox_addr,
+        &bob_signer_private,
+        reward_cycle,
+        &Pox4SignatureTopic::StackStx,
+        3_u128,
+    );
 
     let tip = get_tip(peer.sortdb.as_ref());
     let bob_lockup = make_pox_4_lockup(
@@ -576,8 +588,13 @@ fn pox_extend_transition() {
     let alice_signer_private = Secp256k1PrivateKey::default();
     let alice_signer_key = StacksPublicKey::from_private(&alice_signer_private);
 
-    let alice_signature =
-        make_signer_key_signature(&alice_pox_addr, &alice_signer_private, reward_cycle);
+    let alice_signature = make_signer_key_signature(
+        &alice_pox_addr,
+        &alice_signer_private,
+        reward_cycle,
+        &Pox4SignatureTopic::StackExtend,
+        6_u128,
+    );
 
     // Alice can stack-extend in PoX v2
     let alice_lockup = make_pox_4_extend(
@@ -842,7 +859,13 @@ fn pox_lock_unlock() {
             let pox_addr = PoxAddress::from_legacy(hash_mode, key_to_stacks_addr(key).bytes);
             let lock_period = if ix == 3 { 12 } else { lock_period };
             let signer_key = key;
-            let signature = make_signer_key_signature(&pox_addr, &signer_key, reward_cycle);
+            let signature = make_signer_key_signature(
+                &pox_addr,
+                &signer_key,
+                reward_cycle,
+                &Pox4SignatureTopic::StackStx,
+                lock_period.into(),
+            );
             txs.push(make_pox_4_lockup(
                 key,
                 0,
@@ -1431,6 +1454,8 @@ fn verify_signer_key_sig(
     peer: &mut TestPeer,
     latest_block: &StacksBlockId,
     reward_cycle: u128,
+    period: u128,
+    topic: &str,
 ) -> Value {
     let result: Value = with_sortdb(peer, |ref mut chainstate, ref mut sortdb| {
         chainstate
@@ -1445,9 +1470,11 @@ fn verify_signer_key_sig(
                         LimitedCostTracker::new_free(),
                         |env| {
                             let program = format!(
-                                "(verify-signer-key-sig {} u{} 0x{} 0x{})",
+                                "(verify-signer-key-sig {} u{} \"{}\" u{} 0x{} 0x{})",
                                 Value::Tuple(pox_addr.clone().as_clarity_tuple().unwrap()),
                                 reward_cycle,
+                                topic,
+                                period,
                                 to_hex(&signature),
                                 signing_key.to_hex(),
                             );
@@ -1510,10 +1537,15 @@ fn verify_signer_key_signatures() {
         PoxAddress::from_legacy(AddressHashMode::SerializeP2PKH, alice_address.bytes.clone());
     let bob_pox_addr = PoxAddress::from_legacy(AddressHashMode::SerializeP2PKH, bob_address.bytes);
 
+    let period = 1_u128;
+
+    let topic = Pox4SignatureTopic::StackStx;
+
     // Test 1: invalid reward cycle used in signature
 
     let last_reward_cycle = reward_cycle - 1;
-    let signature = make_signer_key_signature(&bob_pox_addr, &bob, last_reward_cycle);
+    let signature =
+        make_signer_key_signature(&bob_pox_addr, &bob, last_reward_cycle, &topic, period);
 
     let result = verify_signer_key_sig(
         &signature,
@@ -1522,12 +1554,14 @@ fn verify_signer_key_signatures() {
         &mut peer,
         &latest_block,
         reward_cycle,
+        period,
+        topic.as_str(),
     );
     assert_eq!(result, expected_error);
 
     // Test 2: Invalid pox-addr used in signature
 
-    let signature = make_signer_key_signature(&alice_pox_addr, &bob, reward_cycle);
+    let signature = make_signer_key_signature(&alice_pox_addr, &bob, reward_cycle, &topic, period);
 
     let result = verify_signer_key_sig(
         &signature,
@@ -1536,13 +1570,15 @@ fn verify_signer_key_signatures() {
         &mut peer,
         &latest_block,
         reward_cycle,
+        period,
+        topic.as_str(),
     );
 
     assert_eq!(result, expected_error);
 
     // Test 3: Invalid signer key used in signature
 
-    let signature = make_signer_key_signature(&bob_pox_addr, &alice, reward_cycle);
+    let signature = make_signer_key_signature(&bob_pox_addr, &alice, reward_cycle, &topic, period);
 
     let result = verify_signer_key_sig(
         &signature,
@@ -1551,13 +1587,51 @@ fn verify_signer_key_signatures() {
         &mut peer,
         &latest_block,
         reward_cycle,
+        period,
+        topic.as_str(),
+    );
+
+    assert_eq!(result, expected_error);
+
+    // Test 4: invalid topic
+    let signature = make_signer_key_signature(
+        &bob_pox_addr,
+        &bob,
+        reward_cycle,
+        &Pox4SignatureTopic::StackStx,
+        period,
+    );
+    let result = verify_signer_key_sig(
+        &signature,
+        &bob_public_key,
+        &bob_pox_addr,
+        &mut peer,
+        &latest_block,
+        reward_cycle,
+        period,
+        Pox4SignatureTopic::StackExtend.as_str(), // different
     );
 
     assert_eq!(result, expected_error);
 
-    // Test 4: using a valid signature
+    // Test 5: invalid period
+    let signature = make_signer_key_signature(&bob_pox_addr, &bob, reward_cycle, &topic, period);
+    let result = verify_signer_key_sig(
+        &signature,
+        &bob_public_key,
+        &bob_pox_addr,
+        &mut peer,
+        &latest_block,
+        reward_cycle,
+        period + 1, // different
+        topic.as_str(),
+    );
 
-    let signature = make_signer_key_signature(&bob_pox_addr, &bob, reward_cycle);
+    assert_eq!(result, expected_error);
+
+    // Test 6: using a valid signature
+
+    let signature = make_signer_key_signature(&bob_pox_addr, &bob, reward_cycle, &topic, period);
 
     let result = verify_signer_key_sig(
         &signature,
@@ -1566,6 +1640,8 @@ fn verify_signer_key_signatures() {
         &mut peer,
         &latest_block,
         reward_cycle,
+        period,
+        topic.as_str(),
     );
 
     assert_eq!(result, Value::okay_true());
@@ -1597,8 +1673,16 @@ fn stack_stx_verify_signer_sig() {
 
     let reward_cycle = get_current_reward_cycle(&peer, &burnchain);
 
+    let topic = Pox4SignatureTopic::StackStx;
+
     // Test 1: invalid reward cycle
-    let signature = make_signer_key_signature(&pox_addr, &signer_key, reward_cycle - 1);
+    let signature = make_signer_key_signature(
+        &pox_addr,
+        &signer_key,
+        reward_cycle - 1,
+        &topic,
+        lock_period,
+    );
     let invalid_cycle_nonce = stacker_nonce;
     let invalid_cycle_stack = make_pox_4_lockup(
         &stacker_key,
@@ -1611,9 +1695,15 @@ fn stack_stx_verify_signer_sig() {
         signature,
     );
 
-    // test 2: invalid stacker
+    // test 2: invalid pox addr
     stacker_nonce += 1;
-    let signature = make_signer_key_signature(&second_stacker_pox_addr, &signer_key, reward_cycle);
+    let signature = make_signer_key_signature(
+        &second_stacker_pox_addr,
+        &signer_key,
+        reward_cycle,
+        &topic,
+        lock_period,
+    );
     let invalid_stacker_nonce = stacker_nonce;
     let invalid_stacker_tx = make_pox_4_lockup(
         &stacker_key,
@@ -1628,7 +1718,13 @@ fn stack_stx_verify_signer_sig() {
 
     // Test 3: invalid key used to sign
     stacker_nonce += 1;
-    let signature = make_signer_key_signature(&pox_addr, &second_stacker, reward_cycle);
+    let signature = make_signer_key_signature(
+        &pox_addr,
+        &second_stacker,
+        reward_cycle,
+        &topic,
+        lock_period,
+    );
     let invalid_key_nonce = stacker_nonce;
     let invalid_key_tx = make_pox_4_lockup(
         &stacker_key,
@@ -1641,9 +1737,12 @@ fn stack_stx_verify_signer_sig() {
         signature,
     );
 
+    // TODO: test invalid period and topic in signature
+
     // Test 4: valid signature
     stacker_nonce += 1;
-    let signature = make_signer_key_signature(&pox_addr, &signer_key, reward_cycle);
+    let signature =
+        make_signer_key_signature(&pox_addr, &signer_key, reward_cycle, &topic, lock_period);
     let valid_nonce = stacker_nonce;
     let valid_tx = make_pox_4_lockup(
         &stacker_key,
@@ -1699,9 +1798,16 @@ fn stack_extend_verify_sig() {
     let pox_addr = pox_addr_from(&signer_key);
 
     let reward_cycle = get_current_reward_cycle(&peer, &burnchain);
+    let topic = Pox4SignatureTopic::StackExtend;
 
     // Setup: stack-stx
-    let signature = make_signer_key_signature(&pox_addr, &signer_key, reward_cycle);
+    let signature = make_signer_key_signature(
+        &pox_addr,
+        &signer_key,
+        reward_cycle,
+        &Pox4SignatureTopic::StackStx,
+        lock_period,
+    );
     let stack_nonce = stacker_nonce;
     let stack_tx = make_pox_4_lockup(
         &stacker_key,
@@ -1719,7 +1825,13 @@ fn stack_extend_verify_sig() {
     let signer_public_key = StacksPublicKey::from_private(&signer_key);
 
     // Test 1: invalid reward cycle
-    let signature = make_signer_key_signature(&pox_addr, &signer_key, reward_cycle - 1);
+    let signature = make_signer_key_signature(
+        &pox_addr,
+        &signer_key,
+        reward_cycle - 1,
+        &topic,
+        lock_period,
+    );
     stacker_nonce += 1;
     let invalid_cycle_nonce = stacker_nonce;
     let invalid_cycle_tx = make_pox_4_extend(
@@ -1734,7 +1846,13 @@ fn stack_extend_verify_sig() {
     // Test 2: invalid pox-addr
     stacker_nonce += 1;
     let other_pox_addr = pox_addr_from(&Secp256k1PrivateKey::new());
-    let signature = make_signer_key_signature(&other_pox_addr, &signer_key, reward_cycle);
+    let signature = make_signer_key_signature(
+        &other_pox_addr,
+        &signer_key,
+        reward_cycle,
+        &topic,
+        lock_period,
+    );
     let invalid_stacker_nonce = stacker_nonce;
     let invalid_stacker_tx = make_pox_4_extend(
         &stacker_key,
@@ -1748,7 +1866,8 @@ fn stack_extend_verify_sig() {
     // Test 3: invalid key used to sign
     stacker_nonce += 1;
     let other_key = Secp256k1PrivateKey::new();
-    let signature = make_signer_key_signature(&pox_addr, &other_key, reward_cycle);
+    let signature =
+        make_signer_key_signature(&pox_addr, &other_key, reward_cycle, &topic, lock_period);
     let invalid_key_nonce = stacker_nonce;
     let invalid_key_tx = make_pox_4_extend(
         &stacker_key,
@@ -1759,9 +1878,12 @@ fn stack_extend_verify_sig() {
         signature,
     );
 
+    // TODO: test invalid period and topic in signature
+
     // Test 4: valid stack-extend
     stacker_nonce += 1;
-    let signature = make_signer_key_signature(&pox_addr, &signer_key, reward_cycle);
+    let signature =
+        make_signer_key_signature(&pox_addr, &signer_key, reward_cycle, &topic, lock_period);
     let valid_nonce = stacker_nonce;
     let valid_tx = make_pox_4_extend(
         &stacker_key,
@@ -1852,10 +1974,13 @@ fn stack_agg_commit_verify_sig() {
         lock_period,
     );
 
+    let topic = Pox4SignatureTopic::AggregationCommit;
+
     // Test 1: invalid reward cycle
     delegate_nonce += 1;
     let next_reward_cycle = reward_cycle + 1; // wrong cycle for signature
-    let signature = make_signer_key_signature(&pox_addr, &signer_sk, next_reward_cycle);
+    let signature =
+        make_signer_key_signature(&pox_addr, &signer_sk, next_reward_cycle, &topic, 1_u128);
     let invalid_cycle_nonce = delegate_nonce;
     let invalid_cycle_tx = make_pox_4_aggregation_commit_indexed(
         &delegate_key,
@@ -1869,7 +1994,8 @@ fn stack_agg_commit_verify_sig() {
     // Test 2: invalid pox addr
     delegate_nonce += 1;
     let other_pox_addr = pox_addr_from(&Secp256k1PrivateKey::new());
-    let signature = make_signer_key_signature(&other_pox_addr, &signer_sk, reward_cycle);
+    let signature =
+        make_signer_key_signature(&other_pox_addr, &signer_sk, reward_cycle, &topic, 1_u128);
     let invalid_pox_addr_nonce = delegate_nonce;
     let invalid_stacker_tx = make_pox_4_aggregation_commit_indexed(
         &delegate_key,
@@ -1882,7 +2008,8 @@ fn stack_agg_commit_verify_sig() {
 
     // Test 3: invalid signature
     delegate_nonce += 1;
-    let signature = make_signer_key_signature(&pox_addr, &delegate_key, reward_cycle);
+    let signature =
+        make_signer_key_signature(&pox_addr, &delegate_key, reward_cycle, &topic, 1_u128);
     let invalid_key_nonce = delegate_nonce;
     let invalid_key_tx = make_pox_4_aggregation_commit_indexed(
         &delegate_key,
@@ -1893,9 +2020,11 @@ fn stack_agg_commit_verify_sig() {
         &signer_pk,
     );
 
+    // TODO: test invalid period and topic in signature
+
     // Test 4: valid signature
     delegate_nonce += 1;
-    let signature = make_signer_key_signature(&pox_addr, &signer_sk, reward_cycle);
+    let signature = make_signer_key_signature(&pox_addr, &signer_sk, reward_cycle, &topic, 1_u128);
     let valid_nonce = delegate_nonce;
     let valid_tx = make_pox_4_aggregation_commit_indexed(
         &delegate_key,
@@ -2029,7 +2158,13 @@ fn stack_stx_signer_key() {
     //                       (signer-key (buff 33)))
     let pox_addr = pox_addr_from(&stacker_key);
     let pox_addr_val = Value::Tuple(pox_addr.clone().as_clarity_tuple().unwrap());
-    let signature = make_signer_key_signature(&pox_addr, &signer_key, reward_cycle);
+    let signature = make_signer_key_signature(
+        &pox_addr,
+        &signer_key,
+        reward_cycle,
+        &Pox4SignatureTopic::StackStx,
+        2_u128,
+    );
 
     let txs = vec![make_pox_4_contract_call(
         stacker_key,
@@ -2115,7 +2250,13 @@ fn stack_extend_signer_key() {
 
     let reward_cycle = get_current_reward_cycle(&peer, &burnchain);
 
-    let signature = make_signer_key_signature(&pox_addr, &signer_sk, reward_cycle);
+    let signature = make_signer_key_signature(
+        &pox_addr,
+        &signer_sk,
+        reward_cycle,
+        &Pox4SignatureTopic::StackStx,
+        lock_period,
+    );
 
     let txs = vec![make_pox_4_lockup(
         &stacker_key,
@@ -2132,7 +2273,13 @@ fn stack_extend_signer_key() {
 
     let mut latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
 
-    let signature = make_signer_key_signature(&pox_addr, &signer_extend_sk, reward_cycle);
+    let signature = make_signer_key_signature(
+        &pox_addr,
+        &signer_extend_sk,
+        reward_cycle,
+        &Pox4SignatureTopic::StackExtend,
+        1_u128,
+    );
 
     // (define-public (stack-extend (extend-count uint)
     //                          (pox-addr { version: (buff 1), hashbytes: (buff 32) })
@@ -2211,8 +2358,13 @@ fn delegate_stack_stx_signer_key() {
     let signer_key_val = Value::buff_from(signer_key.to_bytes_compressed()).unwrap();
     let min_ustx = get_stacking_minimum(&mut peer, &latest_block);
 
-    let signature =
-        make_signer_key_signature(&pox_addr, &signer_sk, (next_reward_cycle - 1).into());
+    let signature = make_signer_key_signature(
+        &pox_addr,
+        &signer_sk,
+        (next_reward_cycle - 1).into(),
+        &Pox4SignatureTopic::AggregationCommit,
+        1_u128,
+    );
 
     let txs = vec![
         make_pox_4_contract_call(
@@ -2393,7 +2545,13 @@ fn delegate_stack_stx_extend_signer_key() {
 
     bob_nonce += 1;
 
-    let signature = make_signer_key_signature(&pox_addr, &signer_sk, reward_cycle.into());
+    let signature = make_signer_key_signature(
+        &pox_addr,
+        &signer_sk,
+        reward_cycle.into(),
+        &Pox4SignatureTopic::AggregationCommit,
+        1_u128,
+    );
 
     let delegate_stack_extend = make_pox_4_delegate_stack_extend(
         bob_delegate_private_key,
@@ -2415,8 +2573,13 @@ fn delegate_stack_stx_extend_signer_key() {
         ],
     );
 
-    let extend_signature =
-        make_signer_key_signature(&pox_addr, &signer_extend_sk, (extend_cycle - 1).into());
+    let extend_signature = make_signer_key_signature(
+        &pox_addr,
+        &signer_extend_sk,
+        (extend_cycle - 1).into(),
+        &Pox4SignatureTopic::AggregationCommit,
+        1_u128,
+    );
 
     let agg_tx_1 = make_pox_4_contract_call(
         bob_delegate_private_key,
@@ -2486,7 +2649,13 @@ fn stack_increase() {
     let reward_cycle = get_current_reward_cycle(&peer, &burnchain);
 
     let reward_cycle = get_current_reward_cycle(&peer, &burnchain);
-    let signature = make_signer_key_signature(&pox_addr, &signing_sk, reward_cycle);
+    let signature = make_signer_key_signature(
+        &pox_addr,
+        &signing_sk,
+        reward_cycle,
+        &Pox4SignatureTopic::StackStx,
+        lock_period,
+    );
 
     let stack_stx = make_pox_4_lockup(
         alice_stacking_private_key,
@@ -2619,8 +2788,13 @@ fn delegate_stack_increase() {
         min_ustx,
     );
 
-    let signature =
-        make_signer_key_signature(&pox_addr, &signer_sk, (next_reward_cycle - 1).into());
+    let signature = make_signer_key_signature(
+        &pox_addr,
+        &signer_sk,
+        (next_reward_cycle - 1).into(),
+        &Pox4SignatureTopic::AggregationCommit,
+        1_u128,
+    );
 
     let agg_tx = make_pox_4_contract_call(
         bob_delegate_key,
diff --git a/stackslib/src/net/tests/mod.rs b/stackslib/src/net/tests/mod.rs
index c05919eac7..531fc56fff 100644
--- a/stackslib/src/net/tests/mod.rs
+++ b/stackslib/src/net/tests/mod.rs
@@ -328,6 +328,8 @@ impl NakamotoBootPlan {
                     &pox_addr,
                     &test_stacker.signer_private_key,
                     reward_cycle.into(),
+                    &crate::util_lib::signed_structured_data::pox4::Pox4SignatureTopic::StackStx,
+                    12_u128,
                 );
                 make_pox_4_lockup(
                     &test_stacker.stacker_private_key,
diff --git a/stackslib/src/util_lib/signed_structured_data.rs b/stackslib/src/util_lib/signed_structured_data.rs
index 17db6d32fc..dbfb030590 100644
--- a/stackslib/src/util_lib/signed_structured_data.rs
+++ b/stackslib/src/util_lib/signed_structured_data.rs
@@ -17,13 +17,15 @@
 use clarity::vm::{types::TupleData, Value};
 use stacks_common::{
     codec::StacksMessageCodec,
-    types::PrivateKey,
+    types::{chainstate::StacksPrivateKey, PrivateKey},
     util::{
         hash::{to_hex, Sha256Sum},
         secp256k1::{MessageSignature, Secp256k1PrivateKey},
     },
 };
 
+use crate::chainstate::stacks::address::PoxAddress;
+
 /// Message prefix for signed structured data. "SIP018" in ascii
 pub const STRUCTURED_DATA_PREFIX: [u8; 6] = [0x53, 0x49, 0x50, 0x30, 0x31, 0x38];
 
@@ -75,6 +77,82 @@ pub fn make_structured_data_domain(name: &str, version: &str, chain_id: u32) ->
     )
 }
 
+pub mod pox4 {
+    use super::{
+        make_structured_data_domain, structured_data_message_hash, MessageSignature, PoxAddress,
+        PrivateKey, Sha256Sum, StacksPrivateKey, TupleData, Value,
+    };
+    pub enum Pox4SignatureTopic {
+        StackStx,
+        AggregationCommit,
+        StackExtend,
+    }
+
+    impl Pox4SignatureTopic {
+        pub fn as_str(&self) -> &'static str {
+            match self {
+                Pox4SignatureTopic::StackStx => "stack-stx",
+                Pox4SignatureTopic::AggregationCommit => "agg-commit",
+                Pox4SignatureTopic::StackExtend => "stack-extend",
+            }
+        }
+    }
+
+    pub fn make_pox_4_signed_data_domain(chain_id: u32) -> Value {
+        make_structured_data_domain("pox-4-signer", "1.0.0", chain_id)
+    }
+
+    pub fn make_pox_4_signer_key_message_hash(
+        pox_addr: &PoxAddress,
+        reward_cycle: u128,
+        topic: &Pox4SignatureTopic,
+        chain_id: u32,
+        period: u128,
+    ) -> Sha256Sum {
+        let domain_tuple = make_pox_4_signed_data_domain(chain_id);
+        let data_tuple = Value::Tuple(
+            TupleData::from_data(vec![
+                (
+                    "pox-addr".into(),
+                    pox_addr.clone().as_clarity_tuple().unwrap().into(),
+                ),
+                ("reward-cycle".into(), Value::UInt(reward_cycle)),
+                ("period".into(), Value::UInt(period)),
+                (
+                    "topic".into(),
+                    Value::string_ascii_from_bytes(topic.as_str().into()).unwrap(),
+                ),
+            ])
+            .unwrap(),
+        );
+        structured_data_message_hash(data_tuple, domain_tuple)
+    }
+
+    impl Into<Pox4SignatureTopic> for &'static str {
+        fn into(self) -> Pox4SignatureTopic {
+            match self {
+                "stack-stx" => Pox4SignatureTopic::StackStx,
+                "agg-commit" => Pox4SignatureTopic::AggregationCommit,
+                "stack-extend" => Pox4SignatureTopic::StackExtend,
+                _ => panic!("Invalid pox-4 signature topic"),
+            }
+        }
+    }
+
+    pub fn make_pox_4_signer_key_signature(
+        pox_addr: &PoxAddress,
+        signer_key: &StacksPrivateKey,
+        reward_cycle: u128,
+        topic: &Pox4SignatureTopic,
+        chain_id: u32,
+        period: u128,
+    ) -> Result<MessageSignature, &'static str> {
+        let msg_hash =
+            make_pox_4_signer_key_message_hash(pox_addr, reward_cycle, topic, chain_id, period);
+        signer_key.sign(msg_hash.as_bytes())
+    }
+}
+
 #[cfg(test)]
 mod test {
     use super::*;
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index ca047785fa..8546e5e451 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -23,9 +23,7 @@ use stacks::net::api::postblock_proposal::BlockValidateResponse;
 use stacks::util_lib::strings::StacksString;
 use stacks_common::bitvec::BitVec;
 use stacks_common::codec::read_next;
-use stacks_common::types::chainstate::{
-    ConsensusHash, StacksAddress, StacksBlockId, StacksPublicKey, TrieHash,
-};
+use stacks_common::types::chainstate::{ConsensusHash, StacksAddress, StacksBlockId, TrieHash};
 use stacks_common::util::hash::{MerkleTree, Sha512Trunc256Sum};
 use stacks_common::util::secp256k1::{MessageSignature, Secp256k1PrivateKey};
 use stacks_signer::client::{StackerDB, StacksClient};

From 20d78690fe0cd545e18fa1a8eecf6db2c1eb7b35 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Sun, 4 Feb 2024 18:29:44 -0800
Subject: [PATCH 0632/1166] Use serial to ensure tests do not clash

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 Cargo.lock                            | 81 +++++++++++++++++++++++++++
 stacks-signer/Cargo.toml              |  3 +
 stacks-signer/src/client/stackerdb.rs |  3 +
 stacks-signer/src/runloop.rs          |  3 +
 4 files changed, 90 insertions(+)

diff --git a/Cargo.lock b/Cargo.lock
index c1fbd59c22..53868a05a0 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1054,6 +1054,19 @@ dependencies = [
  "syn 1.0.109",
 ]
 
+[[package]]
+name = "dashmap"
+version = "5.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "907076dfda823b0b36d2a1bb5f90c96660a5bbcd7729e10727f07858f22c4edc"
+dependencies = [
+ "cfg-if 1.0.0",
+ "hashbrown 0.12.3",
+ "lock_api",
+ "once_cell",
+ "parking_lot_core",
+]
+
 [[package]]
 name = "digest"
 version = "0.8.1"
@@ -2029,6 +2042,16 @@ version = "0.4.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c4cd1a83af159aa67994778be9070f0ae1bd732942279cabb14f86f986a21456"
 
+[[package]]
+name = "lock_api"
+version = "0.4.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3c168f8615b12bc01f9c17e2eb0cc07dcae1940121185446edc3744920e8ef45"
+dependencies = [
+ "autocfg",
+ "scopeguard",
+]
+
 [[package]]
 name = "log"
 version = "0.4.17"
@@ -2402,6 +2425,29 @@ version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "427c3892f9e783d91cc128285287e70a59e206ca452770ece88a76f7a3eddd72"
 
+[[package]]
+name = "parking_lot"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3742b2c103b9f06bc9fff0a37ff4912935851bee6d36f3c02bcc755bcfec228f"
+dependencies = [
+ "lock_api",
+ "parking_lot_core",
+]
+
+[[package]]
+name = "parking_lot_core"
+version = "0.9.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c42a9226546d68acdd9c0a280d17ce19bfe27a46bf68784e4066115788d008e"
+dependencies = [
+ "cfg-if 1.0.0",
+ "libc",
+ "redox_syscall 0.4.1",
+ "smallvec",
+ "windows-targets 0.48.5",
+]
+
 [[package]]
 name = "peeking_take_while"
 version = "0.1.2"
@@ -2775,6 +2821,15 @@ dependencies = [
  "bitflags 1.3.2",
 ]
 
+[[package]]
+name = "redox_syscall"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa"
+dependencies = [
+ "bitflags 1.3.2",
+]
+
 [[package]]
 name = "redox_users"
 version = "0.4.3"
@@ -3297,6 +3352,31 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "serial_test"
+version = "3.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "953ad9342b3aaca7cb43c45c097dd008d4907070394bd0751a0aa8817e5a018d"
+dependencies = [
+ "dashmap",
+ "futures",
+ "lazy_static",
+ "log",
+ "parking_lot",
+ "serial_test_derive",
+]
+
+[[package]]
+name = "serial_test_derive"
+version = "3.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b93fb4adc70021ac1b47f7d45e8cc4169baaa7ea58483bc5b721d19a26202212"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.29",
+]
+
 [[package]]
 name = "sha1"
 version = "0.6.1"
@@ -3588,6 +3668,7 @@ dependencies = [
  "serde_derive",
  "serde_json",
  "serde_stacker",
+ "serial_test",
  "slog",
  "slog-json",
  "slog-term",
diff --git a/stacks-signer/Cargo.toml b/stacks-signer/Cargo.toml
index 5c65c43397..77d747fe78 100644
--- a/stacks-signer/Cargo.toml
+++ b/stacks-signer/Cargo.toml
@@ -43,6 +43,9 @@ tracing-subscriber = { version = "0.3.17", features = ["env-filter"] }
 wsts = { workspace = true }
 rand = { workspace = true }
 
+[dev-dependencies]
+serial_test = "3.0.0"
+
 [dependencies.serde_json]
 version = "1.0"
 features = ["arbitrary_precision", "unbounded_depth"]
diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index 771dc5ff6d..73e30d67e2 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -177,11 +177,13 @@ mod tests {
         TransactionSmartContract, TransactionVersion,
     };
     use blockstack_lib::util_lib::strings::StacksString;
+    use serial_test::serial;
 
     use super::*;
     use crate::client::tests::{write_response, TestConfig};
 
     #[test]
+    #[serial]
     fn get_signer_transactions_with_retry_should_succeed() {
         let mut config = TestConfig::new();
         let sk = StacksPrivateKey::new();
@@ -226,6 +228,7 @@ mod tests {
     }
 
     #[test]
+    #[serial]
     fn send_signer_message_with_retry_should_succeed() {
         let mut config = TestConfig::new();
         let sk = StacksPrivateKey::new();
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 69b820b298..96a1e897ff 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -995,6 +995,7 @@ mod tests {
     use libsigner::SIGNER_SLOTS_PER_USER;
     use rand::distributions::Standard;
     use rand::Rng;
+    use serial_test::serial;
     use stacks_common::bitvec::BitVec;
     use stacks_common::types::chainstate::{
         ConsensusHash, StacksBlockId, StacksPrivateKey, TrieHash,
@@ -1192,6 +1193,7 @@ mod tests {
     }
 
     #[test]
+    #[serial]
     fn get_expected_transactions_should_filter_invalid_transactions() {
         // Create a runloop of a valid signer
         let config = Config::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
@@ -1298,6 +1300,7 @@ mod tests {
     }
 
     #[test]
+    #[serial]
     fn verify_transactions_valid() {
         let config = Config::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
         let mut runloop: RunLoop<FireCoordinator<v2::Aggregator>> = RunLoop::from(&config);

From f091ba2c32c752b766979bb533caa82e083688cb Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Fri, 26 Jan 2024 15:57:39 -0600
Subject: [PATCH 0633/1166] feat: read reward set from state updated in
 .signers

---
 stackslib/src/chainstate/nakamoto/coordinator/mod.rs   | 1 -
 stackslib/src/chainstate/nakamoto/coordinator/tests.rs | 4 ++++
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
index 15973cd291..ce99f78e1b 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
@@ -90,7 +90,6 @@ impl<'a, T: BlockEventDispatcher> OnChainRewardSetProvider<'a, T> {
         let cycle = burnchain
             .block_height_to_reward_cycle(cycle_start_burn_height)
             .expect("FATAL: no reward cycle for burn height");
-
         // figure out the block ID
         let Some(coinbase_height_of_calculation) = chainstate
             .eval_boot_code_read_only(
diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index 8dae7a39db..161d0079dd 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -68,6 +68,10 @@ fn advance_to_nakamoto(
     )
     .unwrap();
 
+    // use the signing key of addr, otherwise the test stackers
+    //  will not stack enough for any single signing key
+    // let signing_key = StacksPublicKey::from_private(&private_key);
+
     for sortition_height in 0..11 {
         // stack to pox-3 in cycle 7
         let txs = if sortition_height == 6 {

From 57e6c00e2da2e64c0941f37993e3f9cc1ae92442 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Mon, 29 Jan 2024 15:17:10 -0600
Subject: [PATCH 0634/1166] feat: add `stacker_set` RPC endpoint

* expand e2e correct_burns test to invoke the new RPC endpoint
* fix reward-set storage information to write correct coinbase height
---
 stackslib/src/chainstate/nakamoto/mod.rs | 2 +-
 stackslib/src/net/api/mod.rs             | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index 638bbb48d0..2b1ea6b1e7 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -2511,7 +2511,7 @@ impl NakamotoChainState {
                 Self::calculate_matured_miner_rewards(
                     &mut clarity_tx,
                     sortition_dbconn.sqlite_conn(),
-                    coinbase_height,
+                    coinbase_height + 1,
                     matured_rewards_schedule,
                 )
             })
diff --git a/stackslib/src/net/api/mod.rs b/stackslib/src/net/api/mod.rs
index e55e309374..4b45c9f4e0 100644
--- a/stackslib/src/net/api/mod.rs
+++ b/stackslib/src/net/api/mod.rs
@@ -120,6 +120,7 @@ impl StacksHttp {
         self.register_rpc_endpoint(postmicroblock::RPCPostMicroblockRequestHandler::new());
         self.register_rpc_endpoint(poststackerdbchunk::RPCPostStackerDBChunkRequestHandler::new());
         self.register_rpc_endpoint(posttransaction::RPCPostTransactionRequestHandler::new());
+        self.register_rpc_endpoint(getstackers::GetStackersRequestHandler::default());
     }
 }
 

From 3396b24d478e564c250fe468d68b028db3ba48fd Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Tue, 30 Jan 2024 22:03:16 -0600
Subject: [PATCH 0635/1166] feat: add paging to StackerDB

Paging supports larger StackerDB instances
---
 stackslib/src/chainstate/stacks/db/mod.rs   |  45 ++-
 stackslib/src/net/api/tests/mod.rs          |  16 +-
 stackslib/src/net/stackerdb/config.rs       | 305 ++++++++++++++------
 stackslib/src/net/stackerdb/mod.rs          |   7 +-
 stackslib/src/net/stackerdb/tests/config.rs |  30 +-
 5 files changed, 311 insertions(+), 92 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/db/mod.rs b/stackslib/src/chainstate/stacks/db/mod.rs
index 25d80950f1..7e8ef09161 100644
--- a/stackslib/src/chainstate/stacks/db/mod.rs
+++ b/stackslib/src/chainstate/stacks/db/mod.rs
@@ -33,7 +33,7 @@ use clarity::vm::database::{
 use clarity::vm::events::*;
 use clarity::vm::representations::{ClarityName, ContractName};
 use clarity::vm::types::TupleData;
-use clarity::vm::Value;
+use clarity::vm::{SymbolicExpression, Value};
 use lazy_static::lazy_static;
 use rusqlite::types::ToSql;
 use rusqlite::{Connection, OpenFlags, OptionalExtension, Row, Transaction, NO_PARAMS};
@@ -1916,6 +1916,49 @@ impl StacksChainState {
         )
     }
 
+    /// Execute a public function in `contract` from a read-only DB context
+    ///  Any mutations that occur will be rolled-back before returning, regardless of
+    ///  an okay or error result.
+    pub fn eval_fn_read_only(
+        &mut self,
+        burn_dbconn: &dyn BurnStateDB,
+        parent_id_bhh: &StacksBlockId,
+        contract: &QualifiedContractIdentifier,
+        function: &str,
+        args: &[Value],
+    ) -> Result<Value, clarity_error> {
+        let headers_db = HeadersDBConn(self.state_index.sqlite_conn());
+        let mut conn = self.clarity_state.read_only_connection_checked(
+            parent_id_bhh,
+            &headers_db,
+            burn_dbconn,
+        )?;
+
+        let args: Vec<_> = args
+            .iter()
+            .map(|x| SymbolicExpression::atom_value(x.clone()))
+            .collect();
+
+        let result = conn.with_readonly_clarity_env(
+            self.mainnet,
+            self.chain_id,
+            ClarityVersion::latest(),
+            contract.clone().into(),
+            None,
+            LimitedCostTracker::Free,
+            |env| {
+                env.execute_contract(
+                    contract, function, &args,
+                    // read-only is set to `false` so that non-read-only functions
+                    //  can be executed. any transformation is rolled back.
+                    false,
+                )
+            },
+        )?;
+
+        Ok(result)
+    }
+
     pub fn db(&self) -> &DBConn {
         self.state_index.sqlite_conn()
     }
diff --git a/stackslib/src/net/api/tests/mod.rs b/stackslib/src/net/api/tests/mod.rs
index 34a50e29d5..674d54ebaf 100644
--- a/stackslib/src/net/api/tests/mod.rs
+++ b/stackslib/src/net/api/tests/mod.rs
@@ -110,17 +110,21 @@ const TEST_CONTRACT: &'static str = "
 
     (define-public (do-test) (ok u0))
 
+    (define-read-only (stackerdb-get-page-count) (ok u1))
+
     ;; stacker DB
-    (define-read-only (stackerdb-get-signer-slots)
-        (ok (list
-            {
+    (define-read-only (stackerdb-get-signer-slots (page uint))
+        (if (is-eq page u0)
+            (ok (list
+              {
                 signer: 'ST2DS4MSWSGJ3W9FBC6BVT0Y92S345HY8N3T6AV7R,
                 num-slots: u3
-            }
-            {
+              }
+              {
                 signer: 'STVN97YYA10MY5F6KQJHKNYJNM24C4A1AT39WRW,
                 num-slots: u3
-            })))
+              }))
+            (err u1)))
 
     (define-read-only (stackerdb-get-config)
         (ok {
diff --git a/stackslib/src/net/stackerdb/config.rs b/stackslib/src/net/stackerdb/config.rs
index 0ff401e0c9..c1be197c33 100644
--- a/stackslib/src/net/stackerdb/config.rs
+++ b/stackslib/src/net/stackerdb/config.rs
@@ -22,7 +22,9 @@
 /// (define-trait stackerdb-trait
 ///
 ///     ;; Get the list of (signer, num-slots) that make up this DB
-///     (define-public (stackerdb-get-signer-slots) (response (list 4096 { signer: principal, num-slots: uint }) uint))
+///     (define-public (stackerdb-get-signer-slots (uint)) (response (list 4096 { signer: principal, num-slots: uint }) uint))
+///
+///     (define-public (stackerdb-get-page-count) (response uint bool))
 ///
 ///     ;; Get the control metadata for this DB
 ///     (define-public (stackerdb-get-config)
@@ -44,8 +46,8 @@ use clarity::vm::clarity::ClarityConnection;
 use clarity::vm::database::BurnStateDB;
 use clarity::vm::types::{
     BufferLength, FixedFunction, FunctionType, ListTypeData, PrincipalData,
-    QualifiedContractIdentifier, SequenceSubtype, StandardPrincipalData, TupleTypeSignature,
-    TypeSignature,
+    QualifiedContractIdentifier, SequenceData, SequenceSubtype, StandardPrincipalData,
+    TupleTypeSignature, TypeSignature, Value as ClarityValue,
 };
 use clarity::vm::ClarityName;
 use lazy_static::lazy_static;
@@ -54,6 +56,7 @@ use stacks_common::types::net::PeerAddress;
 use stacks_common::types::StacksEpochId;
 use stacks_common::util::hash::Hash160;
 
+use super::{STACKERDB_PAGE_COUNT_FUNCTION, STACKERDB_PAGE_MAX, STACKERDB_SLOTS_FUNCTION};
 use crate::chainstate::burn::db::sortdb::SortitionDB;
 use crate::chainstate::nakamoto::NakamotoChainState;
 use crate::chainstate::stacks::db::StacksChainState;
@@ -67,9 +70,20 @@ use crate::net::{Error as NetError, NeighborAddress};
 const MAX_HINT_REPLICAS: u32 = 128;
 
 lazy_static! {
-    pub static ref REQUIRED_FUNCTIONS: [(ClarityName, TypeSignature); 2] = [
+    pub static ref REQUIRED_FUNCTIONS: [(ClarityName, Vec<TypeSignature>, TypeSignature); 3] = [
+        (
+            super::STACKERDB_PAGE_COUNT_FUNCTION.into(),
+            vec![],
+            TypeSignature::new_response(
+                TypeSignature::UIntType,
+                TypeSignature::UIntType,
+            ).expect("FATAL: failed to construct (response int int)")
+        ),
         (
-            "stackerdb-get-signer-slots".into(),
+            super::STACKERDB_SLOTS_FUNCTION.into(),
+            vec![
+                TypeSignature::UIntType
+            ],
             TypeSignature::new_response(
                 ListTypeData::new_list(
                     TupleTypeSignature::try_from(vec![
@@ -78,7 +92,7 @@ lazy_static! {
                     ])
                     .expect("FATAL: failed to construct signer list type")
                     .into(),
-                    STACKERDB_INV_MAX
+                    super::STACKERDB_PAGE_MAX
                 )
                 .expect("FATAL: could not construct signer list type")
                 .into(),
@@ -86,7 +100,8 @@ lazy_static! {
             ).expect("FATAL: failed to construct response with signer slots"),
         ),
         (
-            "stackerdb-get-config".into(),
+            super::STACKERDB_CONFIG_FUNCTION.into(),
+            vec![],
             TypeSignature::new_response(
                 TypeSignature::TupleType(
                     TupleTypeSignature::try_from(vec![
@@ -123,108 +138,250 @@ impl StackerDBConfig {
     /// Returns Ok(..) if the contract is valid
     /// Returns Err(reason) if the contract is invalid.  A human-readable reason will be given.
     fn is_contract_valid(epoch: &StacksEpochId, analysis: ContractAnalysis) -> Result<(), String> {
-        for (name, func_return_type) in REQUIRED_FUNCTIONS.iter() {
+        for (name, expected_args, expected_return) in REQUIRED_FUNCTIONS.iter() {
             let func = if let Some(f) = analysis.read_only_function_types.get(name) {
                 f
             } else if let Some(f) = analysis.public_function_types.get(name) {
                 f
             } else {
-                let reason = format!("Contract is missing function '{}'", name);
+                let reason = format!("Contract is missing function '{name}'");
                 return Err(reason);
             };
 
-            match func {
-                FunctionType::Fixed(FixedFunction { args, returns }) => {
-                    if args.len() != 0 {
-                        let reason = format!("Contract function '{}' has an invalid signature: it must take zero arguments", name);
-                        return Err(reason);
-                    }
-                    if !func_return_type
-                        .admits_type(epoch, &returns)
-                        .unwrap_or(false)
-                    {
-                        let reason = format!("Contract function '{}' has an invalid return type: expected {:?}, got {:?}", name, func_return_type, returns);
-                        return Err(reason);
-                    }
-                }
-                _ => {
-                    let reason = format!("Contract function '{}' is not a fixed function", name);
-                    return Err(reason);
+            let FunctionType::Fixed(func) = func else {
+                return Err(format!("Function '{name}' must be a fixed function"));
+            };
+
+            if func.args.len() != expected_args.len() {
+                let reason = format!(
+                    "Function '{name}' has an invalid signature: it must have {} args",
+                    expected_args.len()
+                );
+                return Err(reason);
+            }
+            for (actual_arg, expected_arg) in func.args.iter().zip(expected_args.iter()) {
+                if !actual_arg
+                    .signature
+                    .admits_type(epoch, expected_arg)
+                    .unwrap_or(false)
+                {
+                    return Err(format!("Function '{name}' has an invalid argument type: expected {expected_arg}, got {actual_arg}"));
                 }
             }
+
+            if !expected_return
+                .admits_type(epoch, &func.returns)
+                .unwrap_or(false)
+            {
+                return Err(format!("Function '{name}' has an invalid return type: expected {expected_return}, got {}", &func.returns));
+            }
         }
         Ok(())
     }
 
-    /// Evaluate the contract to get its signer slots
-    fn eval_signer_slots(
+    fn eval_page_count(
         chainstate: &mut StacksChainState,
         burn_dbconn: &dyn BurnStateDB,
         contract_id: &QualifiedContractIdentifier,
         tip: &StacksBlockId,
-    ) -> Result<Vec<(StacksAddress, u32)>, NetError> {
-        let value = chainstate.eval_read_only(
+    ) -> Result<u32, NetError> {
+        let pages_val = chainstate.eval_fn_read_only(
             burn_dbconn,
             tip,
             contract_id,
-            "(stackerdb-get-signer-slots)",
+            STACKERDB_PAGE_COUNT_FUNCTION,
+            &[],
         )?;
 
-        let result = value.expect_result()?;
-        let slot_list = match result {
-            Err(err_val) => {
-                let err_code = err_val.expect_u128()?;
+        if !matches!(pages_val, ClarityValue::Response(_)) {
+            let reason = format!("StackerDB fn `{contract_id}.{STACKERDB_PAGE_COUNT_FUNCTION}` returned unexpected non-response type");
+            warn!("{reason}");
+            return Err(NetError::InvalidStackerDBContract(
+                contract_id.clone(),
+                reason,
+            ));
+        }
+
+        let ClarityValue::UInt(pages) = pages_val
+            .expect_result()?
+            .map_err(|err_val| {
                 let reason = format!(
-                    "Contract {} failed to run `stackerdb-get-signer-slots`: error u{}",
-                    contract_id, &err_code
+                    "StackerDB fn `{contract_id}.{STACKERDB_PAGE_COUNT_FUNCTION}` failed: error {err_val}",
                 );
-                warn!("{}", &reason);
-                return Err(NetError::InvalidStackerDBContract(
+                warn!("{reason}");
+                NetError::InvalidStackerDBContract(
                     contract_id.clone(),
                     reason,
-                ));
-            }
-            Ok(ok_val) => ok_val.expect_list()?,
+                )
+            })?
+        else {
+            let reason = format!("StackerDB fn `{contract_id}.{STACKERDB_PAGE_COUNT_FUNCTION}` returned unexpected non-uint ok type");
+            warn!("{reason}");
+            return Err(NetError::InvalidStackerDBContract(
+                contract_id.clone(), reason));
         };
 
-        let mut total_num_slots = 0u32;
-        let mut ret = vec![];
-        for slot_value in slot_list.into_iter() {
-            let slot_data = slot_value.expect_tuple()?;
-            let signer_principal = slot_data
-                .get("signer")
-                .expect("FATAL: no 'signer'")
-                .clone()
-                .expect_principal()?;
-            let num_slots_uint = slot_data
-                .get("num-slots")
-                .expect("FATAL: no 'num-slots'")
-                .clone()
-                .expect_u128()?;
-
-            if num_slots_uint > (STACKERDB_INV_MAX as u128) {
+        pages.try_into().map_err(
+            |_| {
                 let reason = format!(
-                    "Contract {} stipulated more than maximum number of slots for one signer ({})",
-                    contract_id, STACKERDB_INV_MAX
+                    "StackerDB fn `{contract_id}.{STACKERDB_PAGE_COUNT_FUNCTION}` returned page count outside of u32 range",
                 );
-                warn!("{}", &reason);
+                warn!("{reason}");
+                NetError::InvalidStackerDBContract(
+                    contract_id.clone(),
+                    reason,
+                )
+            }
+        )
+    }
+
+    fn parse_slot_entry(
+        entry: ClarityValue,
+        contract_id: &QualifiedContractIdentifier,
+    ) -> Result<(StacksAddress, u32), String> {
+        let ClarityValue::Tuple(slot_data) = entry else {
+            let reason = format!(
+                "StackerDB fn `{contract_id}.{STACKERDB_SLOTS_FUNCTION}` returned non-tuple slot entry",
+            );
+            return Err(reason);
+        };
+
+        let Ok(ClarityValue::Principal(signer_principal)) = slot_data.get("signer") else {
+            let reason = format!(
+                "StackerDB fn `{contract_id}.{STACKERDB_SLOTS_FUNCTION}` returned tuple without `signer` entry of type `principal`",
+            );
+            return Err(reason);
+        };
+
+        let Ok(ClarityValue::UInt(num_slots)) = slot_data.get("num-slots") else {
+            let reason = format!(
+                "StackerDB fn `{contract_id}.{STACKERDB_SLOTS_FUNCTION}` returned tuple without `num-slots` entry of type `uint`",
+            );
+            return Err(reason);
+        };
+
+        let num_slots = u32::try_from(*num_slots)
+            .map_err(|_| format!("Contract `{contract_id}` set too many slots for one signer (max = {STACKERDB_PAGE_MAX})"))?;
+        if num_slots > STACKERDB_PAGE_MAX {
+            return Err(format!("Contract `{contract_id}` set too many slots for one signer (max = {STACKERDB_PAGE_MAX})"));
+        }
+
+        let PrincipalData::Standard(standard_principal) = signer_principal else {
+            return Err(format!(
+                "StackerDB contract `{contract_id}` set a contract principal as a writer, which is not supported"
+            ));
+        };
+        let addr = StacksAddress::from(standard_principal.clone());
+        Ok((addr, num_slots))
+    }
+
+    fn eval_signer_slots(
+        chainstate: &mut StacksChainState,
+        burn_dbconn: &dyn BurnStateDB,
+        contract_id: &QualifiedContractIdentifier,
+        tip: &StacksBlockId,
+    ) -> Result<Vec<(StacksAddress, u32)>, NetError> {
+        let page_count = Self::eval_page_count(chainstate, burn_dbconn, contract_id, tip)?;
+        if page_count == 0 {
+            debug!("StackerDB contract {contract_id} specified zero pages");
+            return Ok(vec![]);
+        }
+        let mut return_set: Option<Vec<(StacksAddress, u32)>> = None;
+        let mut total_num_slots = 0u32;
+        for page in 0..page_count {
+            let (mut new_entries, total_new_slots) =
+                Self::eval_signer_slots_page(chainstate, burn_dbconn, contract_id, tip, page)?;
+            total_num_slots = total_num_slots
+                .checked_add(total_new_slots)
+                .ok_or_else(|| {
+                    NetError::OverflowError(format!(
+                        "Contract {contract_id} set more than u32::MAX slots",
+                    ))
+                })?;
+            if total_num_slots > STACKERDB_INV_MAX {
+                let reason =
+                    format!("Contract {contract_id} set more than the maximum number of slots in a page (max = {STACKERDB_PAGE_MAX})",);
+                warn!("{reason}");
                 return Err(NetError::InvalidStackerDBContract(
                     contract_id.clone(),
                     reason,
                 ));
             }
-            let num_slots = num_slots_uint as u32;
+            // avoid buffering on the first page
+            if let Some(ref mut return_set) = return_set {
+                return_set.append(&mut new_entries);
+            } else {
+                return_set = Some(new_entries);
+            };
+        }
+        Ok(return_set.unwrap_or_else(|| vec![]))
+    }
+
+    /// Evaluate the contract to get its signer slots
+    fn eval_signer_slots_page(
+        chainstate: &mut StacksChainState,
+        burn_dbconn: &dyn BurnStateDB,
+        contract_id: &QualifiedContractIdentifier,
+        tip: &StacksBlockId,
+        page: u32,
+    ) -> Result<(Vec<(StacksAddress, u32)>, u32), NetError> {
+        let resp_value = chainstate.eval_fn_read_only(
+            burn_dbconn,
+            tip,
+            contract_id,
+            STACKERDB_SLOTS_FUNCTION,
+            &[ClarityValue::UInt(page.into())],
+        )?;
+
+        if !matches!(resp_value, ClarityValue::Response(_)) {
+            let reason = format!("StackerDB fn `{contract_id}.{STACKERDB_SLOTS_FUNCTION}` returned unexpected non-response type");
+            warn!("{reason}");
+            return Err(NetError::InvalidStackerDBContract(
+                contract_id.clone(),
+                reason,
+            ));
+        }
+
+        let slot_list_val = resp_value.expect_result()?.map_err(|err_val| {
+            let reason = format!(
+                "StackerDB fn `{contract_id}.{STACKERDB_SLOTS_FUNCTION}` failed: error {err_val}",
+            );
+            warn!("{reason}");
+            NetError::InvalidStackerDBContract(contract_id.clone(), reason)
+        })?;
+
+        let slot_list = if let ClarityValue::Sequence(SequenceData::List(list_data)) = slot_list_val
+        {
+            list_data.data
+        } else {
+            let reason = format!("StackerDB fn `{contract_id}.{STACKERDB_SLOTS_FUNCTION}` returned unexpected non-list ok type");
+            warn!("{reason}");
+            return Err(NetError::InvalidStackerDBContract(
+                contract_id.clone(),
+                reason,
+            ));
+        };
+
+        let mut total_num_slots = 0u32;
+        let mut ret = vec![];
+        for slot_value in slot_list.into_iter() {
+            let (addr, num_slots) =
+                Self::parse_slot_entry(slot_value, contract_id).map_err(|reason| {
+                    warn!("{reason}");
+                    NetError::InvalidStackerDBContract(contract_id.clone(), reason)
+                })?;
+
             total_num_slots =
                 total_num_slots
                     .checked_add(num_slots)
                     .ok_or(NetError::OverflowError(format!(
-                        "Contract {} stipulates more than u32::MAX slots",
+                        "Contract {} set more than u32::MAX slots",
                         &contract_id
                     )))?;
 
-            if total_num_slots > STACKERDB_INV_MAX.into() {
+            if total_num_slots > STACKERDB_PAGE_MAX.into() {
                 let reason = format!(
-                    "Contract {} stipulated more than the maximum number of slots",
+                    "Contract {} set more than the maximum number of slots",
                     contract_id
                 );
                 warn!("{}", &reason);
@@ -234,25 +391,9 @@ impl StackerDBConfig {
                 ));
             }
 
-            // standard principals only
-            let addr = match signer_principal {
-                PrincipalData::Contract(..) => {
-                    let reason = format!("Contract {} stipulated a contract principal as a writer, which is not supported", contract_id);
-                    warn!("{}", &reason);
-                    return Err(NetError::InvalidStackerDBContract(
-                        contract_id.clone(),
-                        reason,
-                    ));
-                }
-                PrincipalData::Standard(StandardPrincipalData(version, bytes)) => StacksAddress {
-                    version,
-                    bytes: Hash160(bytes),
-                },
-            };
-
             ret.push((addr, num_slots));
         }
-        Ok(ret)
+        Ok((ret, total_num_slots))
     }
 
     /// Evaluate the contract to get its config
diff --git a/stackslib/src/net/stackerdb/mod.rs b/stackslib/src/net/stackerdb/mod.rs
index ee44a30229..31c544b939 100644
--- a/stackslib/src/net/stackerdb/mod.rs
+++ b/stackslib/src/net/stackerdb/mod.rs
@@ -142,7 +142,12 @@ use crate::util_lib::boot::boot_code_id;
 use crate::util_lib::db::{DBConn, DBTx, Error as db_error};
 
 /// maximum chunk inventory size
-pub const STACKERDB_INV_MAX: u32 = 4096;
+pub const STACKERDB_INV_MAX: u32 = STACKERDB_PAGE_MAX * 2;
+pub const STACKERDB_PAGE_MAX: u32 = 4096;
+
+pub const STACKERDB_PAGE_COUNT_FUNCTION: &str = "stackerdb-get-page-count";
+pub const STACKERDB_SLOTS_FUNCTION: &str = "stackerdb-get-signer-slots";
+pub const STACKERDB_CONFIG_FUNCTION: &str = "stackerdb-get-config";
 
 /// Final result of synchronizing state with a remote set of DB replicas
 pub struct StackerDBSyncResult {
diff --git a/stackslib/src/net/stackerdb/tests/config.rs b/stackslib/src/net/stackerdb/tests/config.rs
index 9600ed79a8..aea894c057 100644
--- a/stackslib/src/net/stackerdb/tests/config.rs
+++ b/stackslib/src/net/stackerdb/tests/config.rs
@@ -122,9 +122,11 @@ fn test_valid_and_invalid_stackerdb_configs() {
         (
             // valid
             r#"
-            (define-public (stackerdb-get-signer-slots)
+            (define-public (stackerdb-get-signer-slots (page uint))
                 (ok (list { signer: 'ST2TFVBMRPS5SSNP98DQKQ5JNB2B6NZM91C4K3P7B, num-slots: u3 })))
 
+            (define-public (stackerdb-get-page-count) (ok u1))
+
             (define-public (stackerdb-get-config)
                 (ok {
                     chunk-size: u123,
@@ -163,9 +165,11 @@ fn test_valid_and_invalid_stackerdb_configs() {
         (
             // valid
             r#"
-            (define-read-only (stackerdb-get-signer-slots)
+            (define-read-only (stackerdb-get-signer-slots (page uint))
                 (ok (list { signer: 'ST2TFVBMRPS5SSNP98DQKQ5JNB2B6NZM91C4K3P7B, num-slots: u3 })))
 
+            (define-public (stackerdb-get-page-count) (ok u1))
+
             (define-read-only (stackerdb-get-config)
                 (ok {
                     chunk-size: u123,
@@ -201,6 +205,28 @@ fn test_valid_and_invalid_stackerdb_configs() {
                 max_neighbors: 7,
             }),
         ),
+        (
+            // valid
+            r#"
+            (define-read-only (stackerdb-get-signer-slots (page uint))
+                (ok (list { signer: 'ST2TFVBMRPS5SSNP98DQKQ5JNB2B6NZM91C4K3P7B, num-slots: u3 })))
+
+            (define-read-only (stackerdb-get-config)
+                (ok {
+                    chunk-size: u123,
+                    write-freq: u4,
+                    max-writes: u56,
+                    max-neighbors: u7,
+                    hint-replicas: (list
+                        {
+                            addr: (list u0 u0 u0 u0 u0 u0 u0 u0 u0 u0 u255 u255 u127 u0 u0 u1),
+                            port: u8901,
+                            public-key-hash: 0x0123456789abcdef0123456789abcdef01234567
+                        })
+                }))
+            "#,
+            None,
+        ),
         (
             // invalid -- missing function
             r#"

From ee583594ef37d048505adbcb068ac4323b67094a Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Wed, 31 Jan 2024 14:16:04 -0600
Subject: [PATCH 0636/1166] feat: update .signers to use StackerDB paging

* make signer-slots a const in stacks-common
* update the .signers maintenance to separate voting share from StackerDB slots
* update .signers to use and alternate 2 pages of signers
---
 libsigner/src/events.rs                       | 157 ++++++++++++++++++
 stacks-common/src/libcommon.rs                |   4 +
 .../src/chainstate/nakamoto/signer_set.rs     |  51 +++++-
 .../stacks/boot/signers-voting.clar           |  14 +-
 .../src/chainstate/stacks/boot/signers.clar   |  35 +++-
 .../chainstate/stacks/boot/signers_tests.rs   |  19 ++-
 .../stacks/boot/signers_voting_tests.rs       |  14 +-
 stackslib/src/net/stackerdb/mod.rs            |   1 +
 8 files changed, 261 insertions(+), 34 deletions(-)

diff --git a/libsigner/src/events.rs b/libsigner/src/events.rs
index e4d7100b21..9f7fafcb71 100644
--- a/libsigner/src/events.rs
+++ b/libsigner/src/events.rs
@@ -35,6 +35,7 @@ use stacks_common::codec::{
     read_next, read_next_at_most, read_next_exact, write_next, Error as CodecError,
     StacksMessageCodec,
 };
+pub use stacks_common::consts::SIGNER_SLOTS_PER_USER;
 use stacks_common::util::hash::Sha512Trunc256Sum;
 use tiny_http::{
     Method as HttpMethod, Request as HttpRequest, Response as HttpResponse, Server as HttpServer,
@@ -48,6 +49,162 @@ use wsts::state_machine::signer;
 
 use crate::http::{decode_http_body, decode_http_request};
 use crate::{EventError, SignerMessage};
+use crate::EventError;
+
+// The slot IDS for each message type
+const DKG_BEGIN_SLOT_ID: u32 = 0;
+const DKG_PRIVATE_BEGIN_SLOT_ID: u32 = 1;
+const DKG_END_BEGIN_SLOT_ID: u32 = 2;
+const DKG_END_SLOT_ID: u32 = 3;
+const DKG_PUBLIC_SHARES_SLOT_ID: u32 = 4;
+const DKG_PRIVATE_SHARES_SLOT_ID: u32 = 5;
+const NONCE_REQUEST_SLOT_ID: u32 = 6;
+const NONCE_RESPONSE_SLOT_ID: u32 = 7;
+const SIGNATURE_SHARE_REQUEST_SLOT_ID: u32 = 8;
+const SIGNATURE_SHARE_RESPONSE_SLOT_ID: u32 = 9;
+/// The slot ID for the block response for miners to observe
+pub const BLOCK_SLOT_ID: u32 = 10;
+
+/// The messages being sent through the stacker db contracts
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum SignerMessage {
+    /// The signed/validated Nakamoto block for miners to observe
+    BlockResponse(BlockResponse),
+    /// DKG and Signing round data for other signers to observe
+    Packet(Packet),
+}
+
+/// The response that a signer sends back to observing miners
+/// either accepting or rejecting a Nakamoto block with the corresponding reason
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum BlockResponse {
+    /// The Nakamoto block was accepted and therefore signed
+    Accepted((Sha512Trunc256Sum, ThresholdSignature)),
+    /// The Nakamoto block was rejected and therefore not signed
+    Rejected(BlockRejection),
+}
+
+impl BlockResponse {
+    /// Create a new accepted BlockResponse for the provided block signer signature hash and signature
+    pub fn accepted(hash: Sha512Trunc256Sum, sig: Signature) -> Self {
+        Self::Accepted((hash, ThresholdSignature(sig)))
+    }
+
+    /// Create a new rejected BlockResponse for the provided block signer signature hash and signature
+    pub fn rejected(hash: Sha512Trunc256Sum, sig: Signature) -> Self {
+        Self::Rejected(BlockRejection::new(
+            hash,
+            RejectCode::SignedRejection(ThresholdSignature(sig)),
+        ))
+    }
+}
+
+/// A rejection response from a signer for a proposed block
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct BlockRejection {
+    /// The reason for the rejection
+    pub reason: String,
+    /// The reason code for the rejection
+    pub reason_code: RejectCode,
+    /// The signer signature hash of the block that was rejected
+    pub signer_signature_hash: Sha512Trunc256Sum,
+}
+
+impl BlockRejection {
+    /// Create a new BlockRejection for the provided block and reason code
+    pub fn new(signer_signature_hash: Sha512Trunc256Sum, reason_code: RejectCode) -> Self {
+        Self {
+            reason: reason_code.to_string(),
+            reason_code,
+            signer_signature_hash,
+        }
+    }
+}
+
+impl From<BlockValidateReject> for BlockRejection {
+    fn from(reject: BlockValidateReject) -> Self {
+        Self {
+            reason: reject.reason,
+            reason_code: RejectCode::ValidationFailed(reject.reason_code),
+            signer_signature_hash: reject.signer_signature_hash,
+        }
+    }
+}
+
+/// This enum is used to supply a `reason_code` for block rejections
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[repr(u8)]
+pub enum RejectCode {
+    /// RPC endpoint Validation failed
+    ValidationFailed(ValidateRejectCode),
+    /// Signers signed a block rejection
+    SignedRejection(ThresholdSignature),
+    /// Insufficient signers agreed to sign the block
+    InsufficientSigners(Vec<u32>),
+}
+
+impl std::fmt::Display for RejectCode {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        match self {
+            RejectCode::ValidationFailed(code) => write!(f, "Validation failed: {:?}", code),
+            RejectCode::SignedRejection(sig) => {
+                write!(f, "A threshold number of signers rejected the block with the following signature: {:?}.", sig)
+            }
+            RejectCode::InsufficientSigners(malicious_signers) => write!(
+                f,
+                "Insufficient signers agreed to sign the block. The following signers are malicious: {:?}",
+                malicious_signers
+            ),
+        }
+    }
+}
+
+impl From<Packet> for SignerMessage {
+    fn from(packet: Packet) -> Self {
+        Self::Packet(packet)
+    }
+}
+
+impl From<BlockResponse> for SignerMessage {
+    fn from(block_response: BlockResponse) -> Self {
+        Self::BlockResponse(block_response)
+    }
+}
+
+impl From<BlockRejection> for SignerMessage {
+    fn from(block_rejection: BlockRejection) -> Self {
+        Self::BlockResponse(BlockResponse::Rejected(block_rejection))
+    }
+}
+
+impl From<BlockValidateReject> for SignerMessage {
+    fn from(rejection: BlockValidateReject) -> Self {
+        Self::BlockResponse(BlockResponse::Rejected(rejection.into()))
+    }
+}
+
+impl SignerMessage {
+    /// Helper function to determine the slot ID for the provided stacker-db writer id
+    pub fn slot_id(&self, id: u32) -> u32 {
+        let slot_id = match self {
+            Self::Packet(packet) => match packet.msg {
+                Message::DkgBegin(_) => DKG_BEGIN_SLOT_ID,
+                Message::DkgPrivateBegin(_) => DKG_PRIVATE_BEGIN_SLOT_ID,
+                Message::DkgEndBegin(_) => DKG_END_BEGIN_SLOT_ID,
+                Message::DkgEnd(_) => DKG_END_SLOT_ID,
+                Message::DkgPublicShares(_) => DKG_PUBLIC_SHARES_SLOT_ID,
+                Message::DkgPrivateShares(_) => DKG_PRIVATE_SHARES_SLOT_ID,
+                Message::NonceRequest(_) => NONCE_REQUEST_SLOT_ID,
+                Message::NonceResponse(_) => NONCE_RESPONSE_SLOT_ID,
+                Message::SignatureShareRequest(_) => SIGNATURE_SHARE_REQUEST_SLOT_ID,
+                Message::SignatureShareResponse(_) => SIGNATURE_SHARE_RESPONSE_SLOT_ID,
+            },
+            Self::BlockResponse(_) => BLOCK_SLOT_ID,
+        };
+        SIGNER_SLOTS_PER_USER * id + slot_id
+    }
+}
+>>>>>>> d79de76cf (feat: update .signers to use StackerDB paging)
 
 /// Event enum for newly-arrived signer subscribed events
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
diff --git a/stacks-common/src/libcommon.rs b/stacks-common/src/libcommon.rs
index 2f19e74540..8ab7510adc 100644
--- a/stacks-common/src/libcommon.rs
+++ b/stacks-common/src/libcommon.rs
@@ -59,4 +59,8 @@ pub mod consts {
     pub const MINER_REWARD_MATURITY: u64 = 100;
 
     pub const STACKS_EPOCH_MAX: u64 = i64::MAX as u64;
+
+    /// The number of StackerDB slots each signing key needs
+    ///  to use to participate in DKG and block validation signing.
+    pub const SIGNER_SLOTS_PER_USER: u32 = 11;
 }
diff --git a/stackslib/src/chainstate/nakamoto/signer_set.rs b/stackslib/src/chainstate/nakamoto/signer_set.rs
index c0bfbfe078..c1be1db1ea 100644
--- a/stackslib/src/chainstate/nakamoto/signer_set.rs
+++ b/stackslib/src/chainstate/nakamoto/signer_set.rs
@@ -32,7 +32,7 @@ use stacks_common::codec::{
     MAX_PAYLOAD_LEN,
 };
 use stacks_common::consts::{
-    FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH, MINER_REWARD_MATURITY,
+    self, FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH, MINER_REWARD_MATURITY,
 };
 use stacks_common::types::chainstate::{
     BlockHeaderHash, BurnchainHeaderHash, ConsensusHash, StacksAddress, StacksBlockId,
@@ -227,6 +227,33 @@ impl NakamotoSigners {
         let reward_set =
             StacksChainState::make_reward_set(threshold, reward_slots, StacksEpochId::Epoch30);
 
+        let stackerdb_list = if participation == 0 {
+            vec![]
+        } else {
+            reward_set
+                .signers
+                .as_ref()
+                .ok_or(ChainstateError::PoxNoRewardCycle)?
+                .iter()
+                .map(|signer| {
+                    let signer_hash = Hash160::from_data(&signer.signing_key);
+                    let signing_address = StacksAddress::p2pkh_from_hash(is_mainnet, signer_hash);
+                    Value::Tuple(
+                        TupleData::from_data(vec![
+                            (
+                                "signer".into(),
+                                Value::Principal(PrincipalData::from(signing_address)),
+                            ),
+                            ("num-slots".into(), Value::UInt(consts::SIGNER_SLOTS_PER_USER.into())),
+                        ])
+                            .expect(
+                                "BUG: Failed to construct `{ signer: principal, num-slots: u64 }` tuple",
+                            ),
+                    )
+                })
+                .collect()
+        };
+
         let signers_list = if participation == 0 {
             vec![]
         } else {
@@ -244,7 +271,7 @@ impl NakamotoSigners {
                                 "signer".into(),
                                 Value::Principal(PrincipalData::from(signing_address)),
                             ),
-                            ("num-slots".into(), Value::UInt(signer.slots.into())),
+                            ("weight".into(), Value::UInt(signer.slots.into())),
                         ])
                             .expect(
                                 "BUG: Failed to construct `{ signer: principal, num-slots: u64 }` tuple",
@@ -253,6 +280,7 @@ impl NakamotoSigners {
                 })
                 .collect()
         };
+
         if signers_list.len() > SIGNERS_MAX_LIST_SIZE {
             panic!(
                 "FATAL: signers list returned by reward set calculations longer than maximum ({} > {})",
@@ -261,14 +289,21 @@ impl NakamotoSigners {
             );
         }
 
-        let args = [
-            SymbolicExpression::atom_value(Value::cons_list_unsanitized(signers_list).expect(
+        let set_stackerdb_args = [
+            SymbolicExpression::atom_value(Value::cons_list_unsanitized(stackerdb_list).expect(
                 "BUG: Failed to construct `(list 4000 { signer: principal, num-slots: u64 })` list",
             )),
             SymbolicExpression::atom_value(Value::UInt(reward_cycle.into())),
             SymbolicExpression::atom_value(Value::UInt(coinbase_height.into())),
         ];
 
+        let set_signers_args = [
+            SymbolicExpression::atom_value(Value::UInt(reward_cycle.into())),
+            SymbolicExpression::atom_value(Value::cons_list_unsanitized(signers_list).expect(
+                "BUG: Failed to construct `(list 4000 { signer: principal, weight: u64 })` list",
+            )),
+        ];
+
         let (value, _, events, _) = clarity
             .with_abort_callback(
                 |vm_env| {
@@ -276,7 +311,13 @@ impl NakamotoSigners {
                         env.execute_contract_allow_private(
                             &signers_contract,
                             "stackerdb-set-signer-slots",
-                            &args,
+                            &set_stackerdb_args,
+                            false,
+                        )?;
+                        env.execute_contract_allow_private(
+                            &signers_contract,
+                            "stackerdb-set-signers",
+                            &set_signers_args,
                             false,
                         )
                     })
diff --git a/stackslib/src/chainstate/stacks/boot/signers-voting.clar b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
index eef0ab52d7..c5a89c965a 100644
--- a/stackslib/src/chainstate/stacks/boot/signers-voting.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
@@ -55,16 +55,14 @@
 (define-read-only (get-tally (reward-cycle uint) (round uint) (aggregate-public-key (buff 33)))
     (map-get? tally {reward-cycle: reward-cycle, round: round, aggregate-public-key: aggregate-public-key}))
 
-(define-read-only (get-signer-slots (signer-index uint) (reward-cycle uint))
-    (let ((height (reward-cycle-to-burn-height reward-cycle)))
-            (ok (at-block
-                (unwrap! (get-block-info? id-header-hash height) err-invalid-burn-block-height)
-                    (get-current-signer-slots signer-index)))))
-
 (define-read-only (get-current-signer-slots (signer-index uint))
-    (let ((details (unwrap! (unwrap-panic (contract-call? .signers stackerdb-get-signer-by-index signer-index)) err-invalid-signer-index)))
+    (let ((cycle (+ u1 (burn-height-to-reward-cycle burn-block-height))))
+      (get-signer-slots signer-index cycle)))
+
+(define-read-only (get-signer-slots (signer-index uint) (reward-cycle uint))
+    (let ((details (unwrap! (try! (contract-call? .signers stackerdb-get-signer-by-index reward-cycle signer-index)) err-invalid-signer-index)))
         (asserts! (is-eq (get signer details) tx-sender) err-signer-index-mismatch)
-        (ok (get num-slots details))))
+        (ok (get weight details))))
 
 ;; aggregate public key must be unique and can be used only in a single cycle-round pair
 (define-read-only (is-valid-aggregated-public-key (key (buff 33)) (dkg-id {reward-cycle: uint, round: uint}))
diff --git a/stackslib/src/chainstate/stacks/boot/signers.clar b/stackslib/src/chainstate/stacks/boot/signers.clar
index 71adb33bd7..2943b4b627 100644
--- a/stackslib/src/chainstate/stacks/boot/signers.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers.clar
@@ -1,24 +1,43 @@
 (define-data-var last-set-cycle uint u0)
-(define-data-var stackerdb-signer-slots (list 4000 { signer: principal, num-slots: uint }) (list))
+(define-data-var stackerdb-signer-slots-0 (list 4000 { signer: principal, num-slots: uint }) (list))
+(define-data-var stackerdb-signer-slots-1 (list 4000 { signer: principal, num-slots: uint }) (list))
 (define-map cycle-set-height uint uint)
 (define-constant MAX_WRITES u340282366920938463463374607431768211455)
 (define-constant CHUNK_SIZE (* u2 u1024 u1024))
+(define-constant ERR_NO_SUCH_PAGE u1)
+(define-constant ERR_CYCLE_NOT_SET u2)
+(define-map cycle-signer-set uint (list 4000 { signer: principal, weight: uint }))
 
 (define-private (stackerdb-set-signer-slots 
                    (signer-slots (list 4000 { signer: principal, num-slots: uint }))
                    (reward-cycle uint)
                    (set-at-height uint))
-	(begin
+	(let ((cycle-mod (mod reward-cycle u2)))
         (map-set cycle-set-height reward-cycle set-at-height)
         (var-set last-set-cycle reward-cycle)
-		(ok (var-set stackerdb-signer-slots signer-slots))))
+        (if (is-eq cycle-mod u0)
+            (ok (var-set stackerdb-signer-slots-0 signer-slots))
+            (ok (var-set stackerdb-signer-slots-1 signer-slots)))))
 
-(define-read-only (stackerdb-get-signer-slots)
-	(ok (var-get stackerdb-signer-slots)))
+(define-private (stackerdb-set-signers
+                 (reward-cycle uint)
+                 (signers (list 4000 { signer: principal, weight: uint })))
+     (begin
+      (asserts! (is-eq (var-get last-set-cycle) reward-cycle) (err ERR_CYCLE_NOT_SET))
+      (ok (map-set cycle-signer-set reward-cycle signers))))
 
-(define-read-only (stackerdb-get-signer-by-index (signer-index uint))
-	(ok (element-at (var-get stackerdb-signer-slots) signer-index))
-)
+(define-read-only (get-signers (cycle uint))
+     (map-get? cycle-signer-set cycle))
+
+(define-read-only (stackerdb-get-page-count) (ok u2))
+
+(define-read-only (stackerdb-get-signer-slots (page uint))
+    (if (is-eq page u0)      (ok (var-get stackerdb-signer-slots-0))
+        (if (is-eq page u1)  (ok (var-get stackerdb-signer-slots-1))
+        (err ERR_NO_SUCH_PAGE))))
+
+(define-read-only (stackerdb-get-signer-by-index (cycle uint) (signer-index uint))
+	(ok (element-at (unwrap! (map-get? cycle-signer-set cycle) (err ERR_CYCLE_NOT_SET)) signer-index)))
 
 (define-read-only (stackerdb-get-config)
 	(ok
diff --git a/stackslib/src/chainstate/stacks/boot/signers_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_tests.rs
index 45090fa63f..c3e0c27313 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_tests.rs
@@ -24,6 +24,7 @@ use clarity::vm::types::{
 use clarity::vm::Value::Principal;
 use clarity::vm::{ClarityName, ClarityVersion, ContractName, Value};
 use stacks_common::address::AddressHashMode;
+use stacks_common::consts;
 use stacks_common::types::chainstate::{
     BurnchainHeaderHash, StacksAddress, StacksBlockId, StacksPrivateKey, StacksPublicKey,
 };
@@ -55,6 +56,9 @@ use crate::chainstate::stacks::{
 };
 use crate::clarity_vm::database::HeadersDBConn;
 use crate::core::BITCOIN_REGTEST_FIRST_BLOCK_HASH;
+use crate::net::stackerdb::{
+    STACKERDB_CONFIG_FUNCTION, STACKERDB_INV_MAX, STACKERDB_SLOTS_FUNCTION,
+};
 use crate::net::test::{TestEventObserver, TestPeer};
 use crate::util_lib::boot::{boot_code_addr, boot_code_id, boot_code_test_addr};
 
@@ -174,7 +178,7 @@ fn signers_get_config() {
             &mut peer,
             &latest_block,
             "signers".into(),
-            "stackerdb-get-config".into(),
+            STACKERDB_CONFIG_FUNCTION.into(),
             vec![],
         ),
         Value::okay(Value::Tuple(
@@ -217,7 +221,10 @@ fn signers_get_signer_keys_from_stackerdb() {
                 let signer_addr = StacksAddress::p2pkh(false, &pk);
                 let stackerdb_entry = TupleData::from_data(vec![
                     ("signer".into(), PrincipalData::from(signer_addr).into()),
-                    ("num-slots".into(), Value::UInt(2)),
+                    (
+                        "num-slots".into(),
+                        Value::UInt(consts::SIGNER_SLOTS_PER_USER.into()),
+                    ),
                 ])
                 .unwrap();
                 (pk_bytes, stackerdb_entry)
@@ -237,8 +244,8 @@ fn signers_get_signer_keys_from_stackerdb() {
         &mut peer,
         &latest_block_id,
         "signers".into(),
-        "stackerdb-get-signer-slots".into(),
-        vec![],
+        STACKERDB_SLOTS_FUNCTION.into(),
+        vec![Value::UInt(1)],
     )
     .expect_result_ok()
     .unwrap();
@@ -401,13 +408,15 @@ pub fn get_signer_index(
     peer: &mut TestPeer<'_>,
     latest_block_id: StacksBlockId,
     signer_address: StacksAddress,
+    cycle_index: u128,
 ) -> u128 {
+    let cycle_mod = cycle_index % 2;
     let signers = readonly_call(
         peer,
         &latest_block_id,
         "signers".into(),
         "stackerdb-get-signer-slots".into(),
-        vec![],
+        vec![Value::UInt(cycle_mod)],
     )
     .expect_result_ok()
     .unwrap()
diff --git a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
index 370eea72df..9fff91e6b7 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
@@ -162,12 +162,9 @@ fn vote_for_aggregate_public_key_in_first_block() {
     let signer_principal = PrincipalData::from(signer_address);
     let cycle_id = current_reward_cycle;
 
-    let signer_index = get_signer_index(&mut peer, latest_block_id, signer_address);
+    let signer_index = get_signer_index(&mut peer, latest_block_id, signer_address, cycle_id);
 
     let aggregate_public_key: Point = Point::new();
-    let aggreagte_public_key_value =
-        Value::buff_from(aggregate_public_key.compress().data.to_vec())
-            .expect("Failed to serialize aggregate public key");
 
     let txs = vec![
         // cast a vote for the aggregate public key
@@ -266,7 +263,7 @@ fn vote_for_aggregate_public_key_in_last_block() {
     let signer_1_key = &stacker_1.signer_private_key;
     let signer_1_address = key_to_stacks_addr(signer_1_key);
     let signer_1_principal = PrincipalData::from(signer_1_address);
-    let signer_1_index = get_signer_index(&mut peer, latest_block_id, signer_1_address);
+    let signer_1_index = get_signer_index(&mut peer, latest_block_id, signer_1_address, cycle_id);
 
     let txs_1 = vec![
         // cast a vote for the aggregate public key
@@ -292,7 +289,7 @@ fn vote_for_aggregate_public_key_in_last_block() {
     let signer_2_key = &stacker_2.signer_private_key;
     let signer_2_address = key_to_stacks_addr(signer_2_key);
     let signer_2_principal = PrincipalData::from(signer_2_address);
-    let signer_2_index = get_signer_index(&mut peer, latest_block_id, signer_2_address);
+    let signer_2_index = get_signer_index(&mut peer, latest_block_id, signer_2_address, cycle_id);
 
     let txs_2 = vec![
         // cast a vote for the aggregate public key
@@ -364,13 +361,14 @@ fn vote_for_aggregate_public_key_in_last_block() {
     let receipts = block.receipts.as_slice();
     assert_eq!(receipts.len(), 1);
 
-    // vote should succeed
+    // vote fails because the reward cycle has changed
+    //  and the signer set hasn't been set yet.
     let tx1 = &receipts[receipts.len() - 1];
     assert_eq!(
         tx1.result,
         Value::Response(ResponseData {
             committed: false,
-            data: Box::new(Value::UInt(10002)) // err-out-of-voting-window
+            data: Box::new(Value::UInt(2)) // err-out-of-voting-window
         })
     );
 }
diff --git a/stackslib/src/net/stackerdb/mod.rs b/stackslib/src/net/stackerdb/mod.rs
index 31c544b939..7a4334a01f 100644
--- a/stackslib/src/net/stackerdb/mod.rs
+++ b/stackslib/src/net/stackerdb/mod.rs
@@ -143,6 +143,7 @@ use crate::util_lib::db::{DBConn, DBTx, Error as db_error};
 
 /// maximum chunk inventory size
 pub const STACKERDB_INV_MAX: u32 = STACKERDB_PAGE_MAX * 2;
+/// maximum size of a single inventory page
 pub const STACKERDB_PAGE_MAX: u32 = 4096;
 
 pub const STACKERDB_PAGE_COUNT_FUNCTION: &str = "stackerdb-get-page-count";

From 8938d8fde7ffc0d5ea8d36705b919a559ef0c417 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Thu, 1 Feb 2024 10:56:46 -0600
Subject: [PATCH 0637/1166] fix: expand read-only call limits in test for
 larger hello-world contract

---
 stackslib/src/net/api/tests/mod.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/stackslib/src/net/api/tests/mod.rs b/stackslib/src/net/api/tests/mod.rs
index 674d54ebaf..2aa2d8dfcb 100644
--- a/stackslib/src/net/api/tests/mod.rs
+++ b/stackslib/src/net/api/tests/mod.rs
@@ -250,18 +250,18 @@ impl<'a> TestRPC<'a> {
         peer_1_config.connection_opts.read_only_call_limit = ExecutionCost {
             write_length: 0,
             write_count: 0,
-            read_length: 1500,
+            read_length: 2000,
             read_count: 3,
-            runtime: 1500000,
+            runtime: 2000000,
         };
         peer_1_config.connection_opts.maximum_call_argument_size = 4096;
 
         peer_2_config.connection_opts.read_only_call_limit = ExecutionCost {
             write_length: 0,
             write_count: 0,
-            read_length: 1500,
+            read_length: 2000,
             read_count: 3,
-            runtime: 1500000,
+            runtime: 2000000,
         };
         peer_2_config.connection_opts.maximum_call_argument_size = 4096;
 

From 93d499ff3034b209f79dcf287223a48fd1a82451 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Thu, 1 Feb 2024 11:33:37 -0600
Subject: [PATCH 0638/1166] fix: replace page slot limit with a page length
 limit

---
 stackslib/src/net/stackerdb/config.rs | 44 ++++++++++++++++++++-------
 stackslib/src/net/stackerdb/mod.rs    |  9 ++++--
 2 files changed, 39 insertions(+), 14 deletions(-)

diff --git a/stackslib/src/net/stackerdb/config.rs b/stackslib/src/net/stackerdb/config.rs
index c1be197c33..4afc366cc8 100644
--- a/stackslib/src/net/stackerdb/config.rs
+++ b/stackslib/src/net/stackerdb/config.rs
@@ -56,14 +56,18 @@ use stacks_common::types::net::PeerAddress;
 use stacks_common::types::StacksEpochId;
 use stacks_common::util::hash::Hash160;
 
-use super::{STACKERDB_PAGE_COUNT_FUNCTION, STACKERDB_PAGE_MAX, STACKERDB_SLOTS_FUNCTION};
+use super::{
+    STACKERDB_MAX_PAGE_COUNT, STACKERDB_PAGE_COUNT_FUNCTION, STACKERDB_PAGE_LIST_MAX,
+    STACKERDB_SLOTS_FUNCTION,
+};
 use crate::chainstate::burn::db::sortdb::SortitionDB;
 use crate::chainstate::nakamoto::NakamotoChainState;
 use crate::chainstate::stacks::db::StacksChainState;
 use crate::chainstate::stacks::Error as chainstate_error;
 use crate::clarity_vm::clarity::{ClarityReadOnlyConnection, Error as clarity_error};
 use crate::net::stackerdb::{
-    StackerDBConfig, StackerDBs, STACKERDB_INV_MAX, STACKERDB_MAX_CHUNK_SIZE,
+    StackerDBConfig, StackerDBs, STACKERDB_CONFIG_FUNCTION, STACKERDB_INV_MAX,
+    STACKERDB_MAX_CHUNK_SIZE,
 };
 use crate::net::{Error as NetError, NeighborAddress};
 
@@ -72,7 +76,7 @@ const MAX_HINT_REPLICAS: u32 = 128;
 lazy_static! {
     pub static ref REQUIRED_FUNCTIONS: [(ClarityName, Vec<TypeSignature>, TypeSignature); 3] = [
         (
-            super::STACKERDB_PAGE_COUNT_FUNCTION.into(),
+            STACKERDB_PAGE_COUNT_FUNCTION.into(),
             vec![],
             TypeSignature::new_response(
                 TypeSignature::UIntType,
@@ -80,7 +84,7 @@ lazy_static! {
             ).expect("FATAL: failed to construct (response int int)")
         ),
         (
-            super::STACKERDB_SLOTS_FUNCTION.into(),
+            STACKERDB_SLOTS_FUNCTION.into(),
             vec![
                 TypeSignature::UIntType
             ],
@@ -92,7 +96,7 @@ lazy_static! {
                     ])
                     .expect("FATAL: failed to construct signer list type")
                     .into(),
-                    super::STACKERDB_PAGE_MAX
+                    STACKERDB_PAGE_LIST_MAX
                 )
                 .expect("FATAL: could not construct signer list type")
                 .into(),
@@ -100,7 +104,7 @@ lazy_static! {
             ).expect("FATAL: failed to construct response with signer slots"),
         ),
         (
-            super::STACKERDB_CONFIG_FUNCTION.into(),
+            STACKERDB_CONFIG_FUNCTION.into(),
             vec![],
             TypeSignature::new_response(
                 TypeSignature::TupleType(
@@ -261,9 +265,9 @@ impl StackerDBConfig {
         };
 
         let num_slots = u32::try_from(*num_slots)
-            .map_err(|_| format!("Contract `{contract_id}` set too many slots for one signer (max = {STACKERDB_PAGE_MAX})"))?;
-        if num_slots > STACKERDB_PAGE_MAX {
-            return Err(format!("Contract `{contract_id}` set too many slots for one signer (max = {STACKERDB_PAGE_MAX})"));
+            .map_err(|_| format!("Contract `{contract_id}` set too many slots for one signer (max = {STACKERDB_INV_MAX})"))?;
+        if num_slots > STACKERDB_INV_MAX {
+            return Err(format!("Contract `{contract_id}` set too many slots for one signer (max = {STACKERDB_INV_MAX})"));
         }
 
         let PrincipalData::Standard(standard_principal) = signer_principal else {
@@ -286,6 +290,15 @@ impl StackerDBConfig {
             debug!("StackerDB contract {contract_id} specified zero pages");
             return Ok(vec![]);
         }
+        if page_count > STACKERDB_MAX_PAGE_COUNT {
+            let reason = format!("Contract {contract_id} set more than maximum number of pages (max = {STACKERDB_MAX_PAGE_COUNT}");
+            warn!("{reason}");
+            return Err(NetError::InvalidStackerDBContract(
+                contract_id.clone(),
+                reason,
+            ));
+        }
+
         let mut return_set: Option<Vec<(StacksAddress, u32)>> = None;
         let mut total_num_slots = 0u32;
         for page in 0..page_count {
@@ -300,7 +313,7 @@ impl StackerDBConfig {
                 })?;
             if total_num_slots > STACKERDB_INV_MAX {
                 let reason =
-                    format!("Contract {contract_id} set more than the maximum number of slots in a page (max = {STACKERDB_PAGE_MAX})",);
+                    format!("Contract {contract_id} set more than the maximum number of slots in a page (max = {STACKERDB_INV_MAX})",);
                 warn!("{reason}");
                 return Err(NetError::InvalidStackerDBContract(
                     contract_id.clone(),
@@ -362,6 +375,15 @@ impl StackerDBConfig {
             ));
         };
 
+        if slot_list.len() > usize::try_from(STACKERDB_PAGE_LIST_MAX).unwrap() {
+            let reason = format!("StackerDB fn `{contract_id}.{STACKERDB_SLOTS_FUNCTION}` returned too long list (max len={STACKERDB_PAGE_LIST_MAX})");
+            warn!("{reason}");
+            return Err(NetError::InvalidStackerDBContract(
+                contract_id.clone(),
+                reason,
+            ));
+        }
+
         let mut total_num_slots = 0u32;
         let mut ret = vec![];
         for slot_value in slot_list.into_iter() {
@@ -379,7 +401,7 @@ impl StackerDBConfig {
                         &contract_id
                     )))?;
 
-            if total_num_slots > STACKERDB_PAGE_MAX.into() {
+            if total_num_slots > STACKERDB_INV_MAX.into() {
                 let reason = format!(
                     "Contract {} set more than the maximum number of slots",
                     contract_id
diff --git a/stackslib/src/net/stackerdb/mod.rs b/stackslib/src/net/stackerdb/mod.rs
index 7a4334a01f..69e41256e5 100644
--- a/stackslib/src/net/stackerdb/mod.rs
+++ b/stackslib/src/net/stackerdb/mod.rs
@@ -122,6 +122,7 @@ use std::collections::{HashMap, HashSet};
 
 use clarity::vm::types::QualifiedContractIdentifier;
 use libstackerdb::{SlotMetadata, STACKERDB_MAX_CHUNK_SIZE};
+use stacks_common::consts::SIGNER_SLOTS_PER_USER;
 use stacks_common::types::chainstate::{ConsensusHash, StacksAddress};
 use stacks_common::util::get_epoch_time_secs;
 use stacks_common::util::hash::Sha512Trunc256Sum;
@@ -142,9 +143,11 @@ use crate::util_lib::boot::boot_code_id;
 use crate::util_lib::db::{DBConn, DBTx, Error as db_error};
 
 /// maximum chunk inventory size
-pub const STACKERDB_INV_MAX: u32 = STACKERDB_PAGE_MAX * 2;
-/// maximum size of a single inventory page
-pub const STACKERDB_PAGE_MAX: u32 = 4096;
+pub const STACKERDB_INV_MAX: u32 = 2 * 4000 * SIGNER_SLOTS_PER_USER;
+/// maximum length of an inventory page's Clarity list
+pub const STACKERDB_PAGE_LIST_MAX: u32 = 4096;
+/// maximum number of pages that can be used in a StackerDB contract
+pub const STACKERDB_MAX_PAGE_COUNT: u32 = 2;
 
 pub const STACKERDB_PAGE_COUNT_FUNCTION: &str = "stackerdb-get-page-count";
 pub const STACKERDB_SLOTS_FUNCTION: &str = "stackerdb-get-signer-slots";

From 267058f0dbd969dc833f7f97744cf60fc8f06bac Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Thu, 1 Feb 2024 14:36:31 -0600
Subject: [PATCH 0639/1166] fix: update testing .signers contract

---
 stacks-signer/src/utils.rs | 45 +++++++++++++++++++-------------------
 1 file changed, 22 insertions(+), 23 deletions(-)

diff --git a/stacks-signer/src/utils.rs b/stacks-signer/src/utils.rs
index 15e5c8110b..1c934cd465 100644
--- a/stacks-signer/src/utils.rs
+++ b/stacks-signer/src/utils.rs
@@ -115,29 +115,28 @@ pub fn build_stackerdb_contract(
     signer_stacks_addresses: &[StacksAddress],
     slots_per_user: u32,
 ) -> String {
-    let mut stackerdb_contract = String::new(); // "
-    stackerdb_contract += "        ;; stacker DB\n";
-    stackerdb_contract += "        (define-read-only (stackerdb-get-signer-slots)\n";
-    stackerdb_contract += "            (ok (list\n";
-    for signer_stacks_address in signer_stacks_addresses {
-        stackerdb_contract += "                {\n";
-        stackerdb_contract +=
-            format!("                    signer: '{},\n", signer_stacks_address).as_str();
-        stackerdb_contract +=
-            format!("                    num-slots: u{}\n", slots_per_user).as_str();
-        stackerdb_contract += "                }\n";
-    }
-    stackerdb_contract += "                )))\n";
-    stackerdb_contract += "\n";
-    stackerdb_contract += "        (define-read-only (stackerdb-get-config)\n";
-    stackerdb_contract += "            (ok {\n";
-    stackerdb_contract += "                chunk-size: u4096,\n";
-    stackerdb_contract += "                write-freq: u0,\n";
-    stackerdb_contract += "                max-writes: u4096,\n";
-    stackerdb_contract += "                max-neighbors: u32,\n";
-    stackerdb_contract += "                hint-replicas: (list )\n";
-    stackerdb_contract += "            }))\n";
-    stackerdb_contract += "    ";
+    let stackers_list: Vec<String> = signer_stacks_addresses
+        .iter()
+        .map(|signer_addr| format!("{{ signer: '{signer_addr}, num-slots: u{slots_per_user}}}"))
+        .collect();
+    let stackers_joined = stackers_list.join(" ");
+
+    let stackerdb_contract = format!(
+        "
+        ;; stacker DB
+        (define-read-only (stackerdb-get-signer-slots (page uint))
+          (ok (list {stackers_joined})))
+        (define-read-only (stackerdb-get-page-count) (ok u1))
+        (define-read-only (stackerdb-get-config)
+          (ok {{
+                 chunk-size: u4096,
+                 write-freq: u0,
+                 max-writes: u4096,
+                 max-neighbors: u32,
+                 hint-replicas: (list )
+               }} ))
+    "
+    );
     stackerdb_contract
 }
 

From 1f9b1843b5829a767a7b709123de346117594fec Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Mon, 5 Feb 2024 13:28:54 -0600
Subject: [PATCH 0640/1166] fix: rebase artifact

---
 libsigner/src/events.rs | 156 ----------------------------------------
 1 file changed, 156 deletions(-)

diff --git a/libsigner/src/events.rs b/libsigner/src/events.rs
index 9f7fafcb71..9d33e4bd6c 100644
--- a/libsigner/src/events.rs
+++ b/libsigner/src/events.rs
@@ -49,162 +49,6 @@ use wsts::state_machine::signer;
 
 use crate::http::{decode_http_body, decode_http_request};
 use crate::{EventError, SignerMessage};
-use crate::EventError;
-
-// The slot IDS for each message type
-const DKG_BEGIN_SLOT_ID: u32 = 0;
-const DKG_PRIVATE_BEGIN_SLOT_ID: u32 = 1;
-const DKG_END_BEGIN_SLOT_ID: u32 = 2;
-const DKG_END_SLOT_ID: u32 = 3;
-const DKG_PUBLIC_SHARES_SLOT_ID: u32 = 4;
-const DKG_PRIVATE_SHARES_SLOT_ID: u32 = 5;
-const NONCE_REQUEST_SLOT_ID: u32 = 6;
-const NONCE_RESPONSE_SLOT_ID: u32 = 7;
-const SIGNATURE_SHARE_REQUEST_SLOT_ID: u32 = 8;
-const SIGNATURE_SHARE_RESPONSE_SLOT_ID: u32 = 9;
-/// The slot ID for the block response for miners to observe
-pub const BLOCK_SLOT_ID: u32 = 10;
-
-/// The messages being sent through the stacker db contracts
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub enum SignerMessage {
-    /// The signed/validated Nakamoto block for miners to observe
-    BlockResponse(BlockResponse),
-    /// DKG and Signing round data for other signers to observe
-    Packet(Packet),
-}
-
-/// The response that a signer sends back to observing miners
-/// either accepting or rejecting a Nakamoto block with the corresponding reason
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub enum BlockResponse {
-    /// The Nakamoto block was accepted and therefore signed
-    Accepted((Sha512Trunc256Sum, ThresholdSignature)),
-    /// The Nakamoto block was rejected and therefore not signed
-    Rejected(BlockRejection),
-}
-
-impl BlockResponse {
-    /// Create a new accepted BlockResponse for the provided block signer signature hash and signature
-    pub fn accepted(hash: Sha512Trunc256Sum, sig: Signature) -> Self {
-        Self::Accepted((hash, ThresholdSignature(sig)))
-    }
-
-    /// Create a new rejected BlockResponse for the provided block signer signature hash and signature
-    pub fn rejected(hash: Sha512Trunc256Sum, sig: Signature) -> Self {
-        Self::Rejected(BlockRejection::new(
-            hash,
-            RejectCode::SignedRejection(ThresholdSignature(sig)),
-        ))
-    }
-}
-
-/// A rejection response from a signer for a proposed block
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct BlockRejection {
-    /// The reason for the rejection
-    pub reason: String,
-    /// The reason code for the rejection
-    pub reason_code: RejectCode,
-    /// The signer signature hash of the block that was rejected
-    pub signer_signature_hash: Sha512Trunc256Sum,
-}
-
-impl BlockRejection {
-    /// Create a new BlockRejection for the provided block and reason code
-    pub fn new(signer_signature_hash: Sha512Trunc256Sum, reason_code: RejectCode) -> Self {
-        Self {
-            reason: reason_code.to_string(),
-            reason_code,
-            signer_signature_hash,
-        }
-    }
-}
-
-impl From<BlockValidateReject> for BlockRejection {
-    fn from(reject: BlockValidateReject) -> Self {
-        Self {
-            reason: reject.reason,
-            reason_code: RejectCode::ValidationFailed(reject.reason_code),
-            signer_signature_hash: reject.signer_signature_hash,
-        }
-    }
-}
-
-/// This enum is used to supply a `reason_code` for block rejections
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[repr(u8)]
-pub enum RejectCode {
-    /// RPC endpoint Validation failed
-    ValidationFailed(ValidateRejectCode),
-    /// Signers signed a block rejection
-    SignedRejection(ThresholdSignature),
-    /// Insufficient signers agreed to sign the block
-    InsufficientSigners(Vec<u32>),
-}
-
-impl std::fmt::Display for RejectCode {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        match self {
-            RejectCode::ValidationFailed(code) => write!(f, "Validation failed: {:?}", code),
-            RejectCode::SignedRejection(sig) => {
-                write!(f, "A threshold number of signers rejected the block with the following signature: {:?}.", sig)
-            }
-            RejectCode::InsufficientSigners(malicious_signers) => write!(
-                f,
-                "Insufficient signers agreed to sign the block. The following signers are malicious: {:?}",
-                malicious_signers
-            ),
-        }
-    }
-}
-
-impl From<Packet> for SignerMessage {
-    fn from(packet: Packet) -> Self {
-        Self::Packet(packet)
-    }
-}
-
-impl From<BlockResponse> for SignerMessage {
-    fn from(block_response: BlockResponse) -> Self {
-        Self::BlockResponse(block_response)
-    }
-}
-
-impl From<BlockRejection> for SignerMessage {
-    fn from(block_rejection: BlockRejection) -> Self {
-        Self::BlockResponse(BlockResponse::Rejected(block_rejection))
-    }
-}
-
-impl From<BlockValidateReject> for SignerMessage {
-    fn from(rejection: BlockValidateReject) -> Self {
-        Self::BlockResponse(BlockResponse::Rejected(rejection.into()))
-    }
-}
-
-impl SignerMessage {
-    /// Helper function to determine the slot ID for the provided stacker-db writer id
-    pub fn slot_id(&self, id: u32) -> u32 {
-        let slot_id = match self {
-            Self::Packet(packet) => match packet.msg {
-                Message::DkgBegin(_) => DKG_BEGIN_SLOT_ID,
-                Message::DkgPrivateBegin(_) => DKG_PRIVATE_BEGIN_SLOT_ID,
-                Message::DkgEndBegin(_) => DKG_END_BEGIN_SLOT_ID,
-                Message::DkgEnd(_) => DKG_END_SLOT_ID,
-                Message::DkgPublicShares(_) => DKG_PUBLIC_SHARES_SLOT_ID,
-                Message::DkgPrivateShares(_) => DKG_PRIVATE_SHARES_SLOT_ID,
-                Message::NonceRequest(_) => NONCE_REQUEST_SLOT_ID,
-                Message::NonceResponse(_) => NONCE_RESPONSE_SLOT_ID,
-                Message::SignatureShareRequest(_) => SIGNATURE_SHARE_REQUEST_SLOT_ID,
-                Message::SignatureShareResponse(_) => SIGNATURE_SHARE_RESPONSE_SLOT_ID,
-            },
-            Self::BlockResponse(_) => BLOCK_SLOT_ID,
-        };
-        SIGNER_SLOTS_PER_USER * id + slot_id
-    }
-}
->>>>>>> d79de76cf (feat: update .signers to use StackerDB paging)
 
 /// Event enum for newly-arrived signer subscribed events
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]

From 2d1f1aeb8f4493c6dd077de639d9a5dad027c03e Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Mon, 5 Feb 2024 12:33:23 -0800
Subject: [PATCH 0641/1166] Use the same slot id for retrieving the proposed
 block

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 .../stacks-node/src/tests/nakamoto_integrations.rs   | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 962990067e..a2129475fe 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -1448,20 +1448,24 @@ fn miner_writes_proposed_block_to_stackerdb() {
         .expect("Failed to parse socket");
 
     let sortdb = naka_conf.get_burnchain().open_sortition_db(true).unwrap();
-    let burn_height = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn())
-        .unwrap()
-        .block_height as u32;
+    let tip = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn()).unwrap();
+    let miner_pubkey =
+        StacksPublicKey::from_private(&naka_conf.get_miner_config().mining_key.unwrap());
+    let slot_id = NakamotoChainState::get_miner_slot(&sortdb, &tip, &miner_pubkey)
+        .expect("Unable to get miner slot")
+        .expect("No miner slot exists");
 
     let chunk = std::thread::spawn(move || {
         let miner_contract_id = boot_code_id(MINERS_NAME, false);
         let mut miners_stackerdb = StackerDBSession::new(rpc_sock, miner_contract_id);
         miners_stackerdb
-            .get_latest_chunk(burn_height % 2)
+            .get_latest_chunk(slot_id)
             .expect("Failed to get latest chunk from the miner slot ID")
             .expect("No chunk found")
     })
     .join()
     .expect("Failed to join chunk handle");
+
     // We should now successfully deserialize a chunk
     let proposed_block = NakamotoBlock::consensus_deserialize(&mut &chunk[..])
         .expect("Failed to deserialize chunk into block");

From 7ce897a39f0057af1fb41d78abd29f56cf9514af Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 6 Feb 2024 13:09:55 -0500
Subject: [PATCH 0642/1166] fix: signer DBs only have to start with .signers

---
 libsigner/src/events.rs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/libsigner/src/events.rs b/libsigner/src/events.rs
index 9d33e4bd6c..588d025838 100644
--- a/libsigner/src/events.rs
+++ b/libsigner/src/events.rs
@@ -346,8 +346,10 @@ fn process_stackerdb_event(
             .filter_map(|chunk| read_next::<NakamotoBlock, _>(&mut &chunk.data[..]).ok())
             .collect();
         SignerEvent::ProposedBlocks(blocks)
-    } else if event.contract_id.name.to_string() == SIGNERS_NAME {
-        // TODO: fix this to be against boot_code_id(SIGNERS_NAME, is_mainnet) when .signers is deployed
+    } else if event.contract_id.name.to_string().starts_with(SIGNERS_NAME)
+        && event.contract_id.issuer.1 == [0u8; 20]
+    {
+        // signer-XXX-YYY boot contract
         let signer_messages: Vec<SignerMessage> = event
             .modified_slots
             .iter()

From 02cdd05d0af8085abce8e794203464323f8e8d1e Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 6 Feb 2024 13:10:27 -0500
Subject: [PATCH 0643/1166] chore: remove slot_id calculation since there's one
 DB per message type

---
 libsigner/src/messages.rs | 47 +++++++++++++++++++--------------------
 1 file changed, 23 insertions(+), 24 deletions(-)

diff --git a/libsigner/src/messages.rs b/libsigner/src/messages.rs
index 477712b224..658264919d 100644
--- a/libsigner/src/messages.rs
+++ b/libsigner/src/messages.rs
@@ -21,7 +21,6 @@ use std::sync::mpsc::Sender;
 use std::sync::Arc;
 
 use blockstack_lib::chainstate::nakamoto::NakamotoBlock;
-use blockstack_lib::chainstate::stacks::boot::{MINERS_NAME, SIGNERS_NAME};
 use blockstack_lib::chainstate::stacks::events::StackerDBChunksEvent;
 use blockstack_lib::chainstate::stacks::{StacksTransaction, ThresholdSignature};
 use blockstack_lib::net::api::postblock_proposal::{
@@ -178,6 +177,29 @@ pub enum SignerMessage {
     Transactions(Vec<StacksTransaction>),
 }
 
+impl SignerMessage {
+    /// Helper function to determine the slot ID for the provided stacker-db writer id
+    pub fn msg_id(&self) -> u32 {
+        let msg_id = match self {
+            Self::Packet(packet) => match packet.msg {
+                Message::DkgBegin(_) => DKG_BEGIN_SLOT_ID,
+                Message::DkgPrivateBegin(_) => DKG_PRIVATE_BEGIN_SLOT_ID,
+                Message::DkgEndBegin(_) => DKG_END_BEGIN_SLOT_ID,
+                Message::DkgEnd(_) => DKG_END_SLOT_ID,
+                Message::DkgPublicShares(_) => DKG_PUBLIC_SHARES_SLOT_ID,
+                Message::DkgPrivateShares(_) => DKG_PRIVATE_SHARES_SLOT_ID,
+                Message::NonceRequest(_) => NONCE_REQUEST_SLOT_ID,
+                Message::NonceResponse(_) => NONCE_RESPONSE_SLOT_ID,
+                Message::SignatureShareRequest(_) => SIGNATURE_SHARE_REQUEST_SLOT_ID,
+                Message::SignatureShareResponse(_) => SIGNATURE_SHARE_RESPONSE_SLOT_ID,
+            },
+            Self::BlockResponse(_) => BLOCK_SLOT_ID,
+            Self::Transactions(_) => TRANSACTIONS_SLOT_ID,
+        };
+        msg_id
+    }
+}
+
 impl StacksMessageCodec for SignerMessage {
     fn consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), CodecError> {
         write_next(fd, &(SignerMessageTypePrefix::from(self) as u8))?;
@@ -909,29 +931,6 @@ impl From<BlockValidateReject> for SignerMessage {
     }
 }
 
-impl SignerMessage {
-    /// Helper function to determine the slot ID for the provided stacker-db writer id
-    pub fn slot_id(&self, id: u32) -> u32 {
-        let slot_id = match self {
-            Self::Packet(packet) => match packet.msg {
-                Message::DkgBegin(_) => DKG_BEGIN_SLOT_ID,
-                Message::DkgPrivateBegin(_) => DKG_PRIVATE_BEGIN_SLOT_ID,
-                Message::DkgEndBegin(_) => DKG_END_BEGIN_SLOT_ID,
-                Message::DkgEnd(_) => DKG_END_SLOT_ID,
-                Message::DkgPublicShares(_) => DKG_PUBLIC_SHARES_SLOT_ID,
-                Message::DkgPrivateShares(_) => DKG_PRIVATE_SHARES_SLOT_ID,
-                Message::NonceRequest(_) => NONCE_REQUEST_SLOT_ID,
-                Message::NonceResponse(_) => NONCE_RESPONSE_SLOT_ID,
-                Message::SignatureShareRequest(_) => SIGNATURE_SHARE_REQUEST_SLOT_ID,
-                Message::SignatureShareResponse(_) => SIGNATURE_SHARE_RESPONSE_SLOT_ID,
-            },
-            Self::BlockResponse(_) => BLOCK_SLOT_ID,
-            Self::Transactions(_) => TRANSACTIONS_SLOT_ID,
-        };
-        SIGNER_SLOTS_PER_USER * id + slot_id
-    }
-}
-
 #[cfg(test)]
 mod test {
 

From 8f6659566d0787be3dbee9169e97188b5dcdf0b4 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 6 Feb 2024 13:10:47 -0500
Subject: [PATCH 0644/1166] fix: use boot_code_id

---
 libsigner/src/tests/mod.rs | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/libsigner/src/tests/mod.rs b/libsigner/src/tests/mod.rs
index c3e60e9fbf..ec6ad70473 100644
--- a/libsigner/src/tests/mod.rs
+++ b/libsigner/src/tests/mod.rs
@@ -95,9 +95,7 @@ impl SignerRunLoop<Vec<SignerEvent>, Command> for SimpleRunLoop {
 /// and the signer runloop.
 #[test]
 fn test_simple_signer() {
-    let contract_id =
-        QualifiedContractIdentifier::parse("ST2DS4MSWSGJ3W9FBC6BVT0Y92S345HY8N3T6AV7R.signers")
-            .unwrap(); // TODO: change to boot_code_id(SIGNERS_NAME, false) when .signers is deployed
+    let contract_id = boot_code_id(SIGNERS_NAME, false);
     let ev = SignerEventReceiver::new(vec![contract_id.clone()], false);
     let (_cmd_send, cmd_recv) = channel();
     let (res_send, _res_recv) = channel();

From def1a1cf5783cab0ae9ce6989373c28dc811d246 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 6 Feb 2024 13:10:58 -0500
Subject: [PATCH 0645/1166] fix: signer slots per user is now 12

---
 stacks-common/src/libcommon.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stacks-common/src/libcommon.rs b/stacks-common/src/libcommon.rs
index 8ab7510adc..2f7221bd59 100644
--- a/stacks-common/src/libcommon.rs
+++ b/stacks-common/src/libcommon.rs
@@ -62,5 +62,5 @@ pub mod consts {
 
     /// The number of StackerDB slots each signing key needs
     ///  to use to participate in DKG and block validation signing.
-    pub const SIGNER_SLOTS_PER_USER: u32 = 11;
+    pub const SIGNER_SLOTS_PER_USER: u32 = 12;
 }

From 10d996a71dbb6336ca356e0acdc1d79e581053fb Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 6 Feb 2024 13:11:16 -0500
Subject: [PATCH 0646/1166] chore: write messages to their own stackerdbs (and
 maintain sessions to each of them)

---
 stacks-signer/src/client/stackerdb.rs | 109 ++++++++++++++++++++++----
 1 file changed, 93 insertions(+), 16 deletions(-)

diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index 771dc5ff6d..3ce3691669 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -1,5 +1,6 @@
 use std::net::SocketAddr;
 
+use blockstack_lib::chainstate::stacks::boot::make_signers_db_name;
 use blockstack_lib::chainstate::stacks::StacksTransaction;
 // Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
 // Copyright (C) 2020-2024 Stacks Open Internet Foundation
@@ -17,13 +18,13 @@ use blockstack_lib::chainstate::stacks::StacksTransaction;
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 use clarity::vm::types::QualifiedContractIdentifier;
+use clarity::vm::ContractName;
 use hashbrown::HashMap;
-use libsigner::{
-    SignerMessage, SignerSession, StackerDBSession, SIGNER_SLOTS_PER_USER, TRANSACTIONS_SLOT_ID,
-};
+use libsigner::{SignerMessage, SignerSession, StackerDBSession, TRANSACTIONS_SLOT_ID};
 use libstackerdb::{StackerDBChunkAckData, StackerDBChunkData};
 use slog::{slog_debug, slog_warn};
 use stacks_common::codec::{read_next, StacksMessageCodec};
+use stacks_common::consts::SIGNER_SLOTS_PER_USER;
 use stacks_common::types::chainstate::StacksPrivateKey;
 use stacks_common::{debug, warn};
 
@@ -33,26 +34,50 @@ use crate::config::Config;
 
 /// The StackerDB client for communicating with the .signers contract
 pub struct StackerDB {
-    /// The stacker-db session for the signer StackerDB
+    /// The stacker-db session for the signer StackerDB.  Used for querying signer addresses and
+    /// other system metadata.
     signers_stackerdb_session: StackerDBSession,
+    /// The stacker-db sessions for each signer set and message type.
+    /// Maps (signer-set, message ID) to the DB session.
+    signers_message_stackerdb_sessions: HashMap<(u32, u32), StackerDBSession>,
     /// The private key used in all stacks node communications
     stacks_private_key: StacksPrivateKey,
-    /// A map of a slot ID to last chunk version
-    slot_versions: HashMap<u32, u32>,
+    /// A map of a (signer-set, message ID) to last chunk version for each session
+    slot_versions: HashMap<(u32, u32), HashMap<u32, u32>>,
     /// The signer ID
     signer_id: u32,
+    /// Which signer set to use (0 or 1).
+    /// Depends on whether or not we're signing in an even or odd reward cycle
+    signer_set: u32,
 }
 
 impl From<&Config> for StackerDB {
     fn from(config: &Config) -> Self {
+        let mut signers_message_stackerdb_sessions = HashMap::new();
+        for signer_set in 0..2 {
+            for msg_id in 0..SIGNER_SLOTS_PER_USER {
+                signers_message_stackerdb_sessions.insert(
+                    (signer_set, msg_id),
+                    StackerDBSession::new(
+                        config.node_host.clone(),
+                        QualifiedContractIdentifier::new(
+                            config.stackerdb_contract_id.issuer.clone(),
+                            ContractName::from(make_signers_db_name(signer_set, msg_id).as_str()),
+                        ),
+                    ),
+                );
+            }
+        }
         Self {
             signers_stackerdb_session: StackerDBSession::new(
                 config.node_host,
                 config.stackerdb_contract_id.clone(),
             ),
+            signers_message_stackerdb_sessions,
             stacks_private_key: config.stacks_private_key,
             slot_versions: HashMap::new(),
             signer_id: config.signer_id,
+            signer_set: 0,
         }
     }
 }
@@ -65,11 +90,28 @@ impl StackerDB {
         stacks_private_key: StacksPrivateKey,
         signer_id: u32,
     ) -> Self {
+        let mut signers_message_stackerdb_sessions = HashMap::new();
+        for signer_set in 0..2 {
+            for msg_id in 0..SIGNER_SLOTS_PER_USER {
+                signers_message_stackerdb_sessions.insert(
+                    (signer_set, msg_id),
+                    StackerDBSession::new(
+                        host.clone(),
+                        QualifiedContractIdentifier::new(
+                            stackerdb_contract_id.issuer.clone(),
+                            ContractName::from(make_signers_db_name(signer_set, msg_id).as_str()),
+                        ),
+                    ),
+                );
+            }
+        }
         Self {
             signers_stackerdb_session: StackerDBSession::new(host, stackerdb_contract_id),
+            signers_message_stackerdb_sessions,
             stacks_private_key,
             slot_versions: HashMap::new(),
             signer_id,
+            signer_set: 0,
         }
     }
 
@@ -79,23 +121,48 @@ impl StackerDB {
         message: SignerMessage,
     ) -> Result<StackerDBChunkAckData, ClientError> {
         let message_bytes = message.serialize_to_vec();
-        let slot_id = message.slot_id(self.signer_id);
-
+        let msg_id = message.msg_id();
+        let signer_set = self.signer_set;
+        let slot_id = self.signer_id;
         loop {
-            let slot_version = *self.slot_versions.entry(slot_id).or_insert(0) + 1;
+            let slot_version =
+                if let Some(versions) = self.slot_versions.get_mut(&(signer_set, msg_id)) {
+                    if let Some(version) = versions.get(&slot_id) {
+                        *version
+                    } else {
+                        versions.insert(slot_id, 0);
+                        1
+                    }
+                } else {
+                    let mut versions = HashMap::new();
+                    versions.insert(slot_id, 0);
+                    self.slot_versions.insert((signer_set, msg_id), versions);
+                    1
+                };
+
             let mut chunk = StackerDBChunkData::new(slot_id, slot_version, message_bytes.clone());
             chunk.sign(&self.stacks_private_key)?;
+
+            let Some(session) = self
+                .signers_message_stackerdb_sessions
+                .get_mut(&(signer_set, msg_id))
+            else {
+                panic!("FATAL: would loop forever trying to send a message with ID {}, for which we don't have a session", msg_id);
+            };
+
             debug!(
-                "Sending a chunk to stackerdb slot ID {slot_id} with version {slot_version}!\n{:?}",
+                "Sending a chunk to stackerdb slot ID {slot_id} with version {slot_version} to contract {:?}!\n{:?}",
+                &session.stackerdb_contract_id,
                 &chunk
             );
-            let send_request = || {
-                self.signers_stackerdb_session
-                    .put_chunk(&chunk)
-                    .map_err(backoff::Error::transient)
-            };
+
+            let send_request = || session.put_chunk(&chunk).map_err(backoff::Error::transient);
             let chunk_ack: StackerDBChunkAckData = retry_with_exponential_backoff(send_request)?;
-            self.slot_versions.insert(slot_id, slot_version);
+
+            if let Some(versions) = self.slot_versions.get_mut(&(signer_set, msg_id)) {
+                // NOTE: per the above, this is always executed
+                versions.insert(slot_id, slot_version);
+            }
 
             if chunk_ack.accepted {
                 debug!("Chunk accepted by stackerdb: {:?}", chunk_ack);
@@ -166,6 +233,16 @@ impl StackerDB {
     pub fn signers_contract_id(&self) -> &QualifiedContractIdentifier {
         &self.signers_stackerdb_session.stackerdb_contract_id
     }
+
+    /// Retrieve the signer set this stackerdb client is attached to
+    pub fn get_signer_set(&self) -> u32 {
+        self.signer_set
+    }
+
+    /// Set the signer set from a reward cycle
+    pub fn set_signer_set(&mut self, set: u32) {
+        self.signer_set = set
+    }
 }
 
 #[cfg(test)]

From 874d0c29d64e81e3efe59a3b5a061afb9f344cac Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 6 Feb 2024 13:11:53 -0500
Subject: [PATCH 0647/1166] fix: load signer list by page

---
 stacks-signer/src/client/stacks_client.rs | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index cb9573d830..77a0c5bae1 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -32,7 +32,7 @@ use blockstack_lib::net::api::getpoxinfo::RPCPoxInfoData;
 use blockstack_lib::net::api::postblock_proposal::NakamotoBlockProposal;
 use blockstack_lib::util_lib::boot::boot_code_id;
 use clarity::vm::types::{PrincipalData, QualifiedContractIdentifier};
-use clarity::vm::{ClarityName, ContractName, Value as ClarityValue};
+use clarity::vm::{ClarityName, ContractName, Value as ClarityValue, Value};
 use serde_json::json;
 use slog::slog_debug;
 use stacks_common::codec::StacksMessageCodec;
@@ -91,10 +91,11 @@ impl StacksClient {
     pub fn get_stackerdb_signer_slots(
         &self,
         stackerdb_contract: &QualifiedContractIdentifier,
+        page: u32,
     ) -> Result<Vec<(StacksAddress, u128)>, ClientError> {
-        let function_name_str = "stackerdb-get-signer-slots";
+        let function_name_str = "stackerdb-get-signer-slots-page";
         let function_name = ClarityName::from(function_name_str);
-        let function_args = &[];
+        let function_args = &[Value::UInt(page.into())];
         let value = self.read_only_contract_call_with_retry(
             &stackerdb_contract.issuer.clone().into(),
             &stackerdb_contract.name,
@@ -220,7 +221,7 @@ impl StacksClient {
     }
 
     /// Helper function to retrieve the current reward cycle number from the stacks node
-    fn get_current_reward_cycle(&self) -> Result<u64, ClientError> {
+    pub fn get_current_reward_cycle(&self) -> Result<u64, ClientError> {
         let pox_data = self.get_pox_data()?;
         Ok(pox_data.reward_cycle_id)
     }

From d781b241e2c7c6b5e1a9b7ccc200f97ef990320e Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 6 Feb 2024 13:12:09 -0500
Subject: [PATCH 0648/1166] chore: determine which signer set the signer is
 running in (temporary work-around to get testing working)

---
 stacks-signer/src/runloop.rs | 29 ++++++++++++++++++++++++++++-
 1 file changed, 28 insertions(+), 1 deletion(-)

diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 69b820b298..a7e925cfd7 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -138,6 +138,8 @@ pub struct RunLoop<C> {
     pub transactions: Vec<StacksTransaction>,
     /// This signer's ID
     pub signer_id: u32,
+    /// The signer set for this runloop
+    pub signer_set: Option<u32>,
     /// The IDs of all signers partipating in the current reward cycle
     pub signer_ids: Vec<u32>,
     /// The stacks addresses of the signers participating in the current reward cycle
@@ -145,6 +147,22 @@ pub struct RunLoop<C> {
 }
 
 impl<C: Coordinator> RunLoop<C> {
+    /// Get and store the signer set assignment for this runloop.
+    /// This assigns the runloop to the _next_ reward cycle, not the current one.
+    fn get_or_set_signer_set(&mut self) -> Result<u32, ClientError> {
+        if let Some(signer_set) = self.signer_set.as_ref() {
+            return Ok(*signer_set);
+        } else {
+            let rc = u32::try_from(self.stacks_client.get_current_reward_cycle()?)
+                .expect("FATAL: reward cycle exceeds u32::MAX")
+                + 1;
+            debug!("Next reward cycle is {}", rc);
+            self.signer_set = Some(rc % 2);
+            self.stackerdb.set_signer_set(rc % 2);
+            Ok(rc % 2)
+        }
+    }
+
     /// Initialize the signer, reading the stacker-db state and setting the aggregate public key
     fn initialize(&mut self) -> Result<(), ClientError> {
         // Check if the aggregate key is set in the pox contract
@@ -162,10 +180,18 @@ impl<C: Coordinator> RunLoop<C> {
                 self.commands.push_front(RunLoopCommand::Dkg);
             }
         }
+
+        // determine what signer set we're using, so we use the right stackerdb replicas
+        let signer_set = self.get_or_set_signer_set()?;
+        debug!("Self-assigning to signer set {}", signer_set);
+
         // Get the signer writers from the stacker-db to verify transactions against
         self.signer_addresses = self
             .stacks_client
-            .get_stackerdb_signer_slots(self.stackerdb.signers_contract_id())?
+            .get_stackerdb_signer_slots(
+                self.stackerdb.signers_contract_id(),
+                self.stackerdb.get_signer_set(),
+            )?
             .into_iter()
             .map(|(address, _)| address)
             .collect();
@@ -872,6 +898,7 @@ impl From<&Config> for RunLoop<FireCoordinator<v2::Aggregator>> {
             transactions: Vec::new(),
             signer_ids: config.signer_ids.clone(),
             signer_id: config.signer_id,
+            signer_set: None, // will be updated on .initialize()
             signer_addresses: vec![],
         }
     }

From fb9ec7970e7630617d7a4bd1b13556d421033fb6 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 6 Feb 2024 13:12:33 -0500
Subject: [PATCH 0649/1166] chore: fix merge artifact

---
 stackslib/src/chainstate/nakamoto/coordinator/mod.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
index c07f1bac4e..ce99f78e1b 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
@@ -91,7 +91,7 @@ impl<'a, T: BlockEventDispatcher> OnChainRewardSetProvider<'a, T> {
             .block_height_to_reward_cycle(cycle_start_burn_height)
             .expect("FATAL: no reward cycle for burn height");
         // figure out the block ID
-        let Ok(Some(coinbase_height_of_calculation)) = chainstate
+        let Some(coinbase_height_of_calculation) = chainstate
             .eval_boot_code_read_only(
                 sortdb,
                 block_id,

From f6ef6ab955d216b7b3408b3e63ce7cab61a75092 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 6 Feb 2024 13:12:48 -0500
Subject: [PATCH 0650/1166] chore: remove commented-out code

---
 stackslib/src/chainstate/nakamoto/coordinator/tests.rs | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index 161d0079dd..8dae7a39db 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -68,10 +68,6 @@ fn advance_to_nakamoto(
     )
     .unwrap();
 
-    // use the signing key of addr, otherwise the test stackers
-    //  will not stack enough for any single signing key
-    // let signing_key = StacksPublicKey::from_private(&private_key);
-
     for sortition_height in 0..11 {
         // stack to pox-3 in cycle 7
         let txs = if sortition_height == 6 {

From 82946e66185f21f199a05bcb2a966a756ad87182 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 6 Feb 2024 13:13:09 -0500
Subject: [PATCH 0651/1166] fix: one signer slot per stackerdb

---
 stackslib/src/chainstate/nakamoto/signer_set.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stackslib/src/chainstate/nakamoto/signer_set.rs b/stackslib/src/chainstate/nakamoto/signer_set.rs
index 08f94aea02..0cf70f391f 100644
--- a/stackslib/src/chainstate/nakamoto/signer_set.rs
+++ b/stackslib/src/chainstate/nakamoto/signer_set.rs
@@ -245,7 +245,7 @@ impl NakamotoSigners {
                                 "signer".into(),
                                 Value::Principal(PrincipalData::from(signing_address)),
                             ),
-                            ("num-slots".into(), Value::UInt(consts::SIGNER_SLOTS_PER_USER.into())),
+                            ("num-slots".into(), Value::UInt(1))
                         ])
                             .expect(
                                 "BUG: Failed to construct `{ signer: principal, num-slots: u64 }` tuple",

From df723951b97614614f75e2cc067898178615b172 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 6 Feb 2024 13:13:22 -0500
Subject: [PATCH 0652/1166] chore: add method to generate stackerdb contract id

---
 stackslib/src/chainstate/stacks/boot/mod.rs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 2c95cfe68b..cef755ecec 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -90,6 +90,8 @@ const POX_2_BODY: &'static str = std::include_str!("pox-2.clar");
 const POX_3_BODY: &'static str = std::include_str!("pox-3.clar");
 const POX_4_BODY: &'static str = std::include_str!("pox-4.clar");
 pub const SIGNERS_BODY: &'static str = std::include_str!("signers.clar");
+pub const SIGNERS_DB_0_BODY: &'static str = std::include_str!("signers-0-xxx.clar");
+pub const SIGNERS_DB_1_BODY: &'static str = std::include_str!("signers-1-xxx.clar");
 const SIGNERS_VOTING_BODY: &'static str = std::include_str!("signers-voting.clar");
 
 pub const COSTS_1_NAME: &'static str = "costs";
@@ -160,6 +162,10 @@ pub fn make_contract_id(addr: &StacksAddress, name: &str) -> QualifiedContractId
     )
 }
 
+pub fn make_signers_db_name(signer_set: u32, message_id: u32) -> String {
+    format!("{}-{}-{}", &SIGNERS_NAME, signer_set, message_id)
+}
+
 #[derive(Clone, Debug)]
 pub struct RawRewardSetEntry {
     pub reward_address: PoxAddress,

From 4005d508e2e3f008afbc74f508f5b581d5655b27 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 6 Feb 2024 13:13:44 -0500
Subject: [PATCH 0653/1166] feat: add signer DB template contracts

---
 stackslib/src/chainstate/stacks/boot/signers-0-xxx.clar | 8 ++++++++
 stackslib/src/chainstate/stacks/boot/signers-1-xxx.clar | 8 ++++++++
 2 files changed, 16 insertions(+)
 create mode 100644 stackslib/src/chainstate/stacks/boot/signers-0-xxx.clar
 create mode 100644 stackslib/src/chainstate/stacks/boot/signers-1-xxx.clar

diff --git a/stackslib/src/chainstate/stacks/boot/signers-0-xxx.clar b/stackslib/src/chainstate/stacks/boot/signers-0-xxx.clar
new file mode 100644
index 0000000000..df174be4fa
--- /dev/null
+++ b/stackslib/src/chainstate/stacks/boot/signers-0-xxx.clar
@@ -0,0 +1,8 @@
+;; A StackerDB for a specific message type for signer set 0.
+;; The contract name indicates which -- it has the form `signers-0-{:message_id}`.
+
+(define-read-only (stackerdb-get-signer-slots)
+    (contract-call? .signers stackerdb-get-signer-slots-page u0))
+
+(define-read-only (stackerdb-get-config)
+    (contract-call? .signers stackerdb-get-config))
diff --git a/stackslib/src/chainstate/stacks/boot/signers-1-xxx.clar b/stackslib/src/chainstate/stacks/boot/signers-1-xxx.clar
new file mode 100644
index 0000000000..63a87d8560
--- /dev/null
+++ b/stackslib/src/chainstate/stacks/boot/signers-1-xxx.clar
@@ -0,0 +1,8 @@
+;; A StackerDB for a specific message type for signer set 1.
+;; The contract name indicates which -- it has the form `signers-1-{:message_id}`.
+
+(define-read-only (stackerdb-get-signer-slots)
+    (contract-call? .signers stackerdb-get-signer-slots-page u1))
+
+(define-read-only (stackerdb-get-config)
+    (contract-call? .signers stackerdb-get-config))

From 802f7d37e7fcd780423e7d5692d47667a1922ab6 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 6 Feb 2024 13:14:06 -0500
Subject: [PATCH 0654/1166] remove old signer DB contract

---
 stackslib/src/chainstate/stacks/boot/signers-db.clar | 8 --------
 1 file changed, 8 deletions(-)
 delete mode 100644 stackslib/src/chainstate/stacks/boot/signers-db.clar

diff --git a/stackslib/src/chainstate/stacks/boot/signers-db.clar b/stackslib/src/chainstate/stacks/boot/signers-db.clar
deleted file mode 100644
index c050ccc4a5..0000000000
--- a/stackslib/src/chainstate/stacks/boot/signers-db.clar
+++ /dev/null
@@ -1,8 +0,0 @@
-;; A StackerDB for a specific message type for a specific signer set.
-;; The contract name indicates which -- it has the form `signers-{:signer_set}-{:message_id}`.
-
-(define-read-only (stackerdb-get-signer-slots)
-    (contract-call? .signers stackerdb-get-signer-slots))
-
-(define-read-only (stackerdb-get-config)
-    (contract-call? .signers stackerdb-get-config))

From 97747fd2dd08337cfb3c3705a30eab7e58fd875c Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 6 Feb 2024 13:14:23 -0500
Subject: [PATCH 0655/1166] fix: clean up contract-calls to signers

---
 stackslib/src/chainstate/stacks/boot/signers-voting.clar | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers-voting.clar b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
index c5a89c965a..4b780a0712 100644
--- a/stackslib/src/chainstate/stacks/boot/signers-voting.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
@@ -60,7 +60,7 @@
       (get-signer-slots signer-index cycle)))
 
 (define-read-only (get-signer-slots (signer-index uint) (reward-cycle uint))
-    (let ((details (unwrap! (try! (contract-call? .signers stackerdb-get-signer-by-index reward-cycle signer-index)) err-invalid-signer-index)))
+    (let ((details (unwrap! (try! (contract-call? .signers get-signer-by-index reward-cycle signer-index)) err-invalid-signer-index)))
         (asserts! (is-eq (get signer details) tx-sender) err-signer-index-mismatch)
         (ok (get weight details))))
 
@@ -76,7 +76,7 @@
         (get prepare-cycle-length pox-info)))
 
 (define-private (is-in-voting-window (height uint) (reward-cycle uint))
-    (let ((last-cycle (unwrap-panic (contract-call? .signers stackerdb-get-last-set-cycle))))
+    (let ((last-cycle (unwrap-panic (contract-call? .signers get-last-set-cycle))))
         (and (is-eq last-cycle reward-cycle)
             (is-in-prepare-phase height))))
 
@@ -106,4 +106,4 @@
 (define-private (update-last-round (reward-cycle uint) (round uint))
     (match (map-get? rounds reward-cycle)
         last-round (and (> round last-round) (map-set rounds reward-cycle round))
-        (map-set rounds reward-cycle round)))
\ No newline at end of file
+        (map-set rounds reward-cycle round)))

From 710869e77ce928db76f8407d02f5181fa50f6aa1 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 6 Feb 2024 13:14:44 -0500
Subject: [PATCH 0656/1166] fix: update signers.clar so that it's just a
 repository of metadata for other signers DB contracts

---
 .../src/chainstate/stacks/boot/signers.clar   | 31 ++++++++++++-------
 1 file changed, 20 insertions(+), 11 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers.clar b/stackslib/src/chainstate/stacks/boot/signers.clar
index 2943b4b627..14f8edaa7d 100644
--- a/stackslib/src/chainstate/stacks/boot/signers.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers.clar
@@ -2,12 +2,15 @@
 (define-data-var stackerdb-signer-slots-0 (list 4000 { signer: principal, num-slots: uint }) (list))
 (define-data-var stackerdb-signer-slots-1 (list 4000 { signer: principal, num-slots: uint }) (list))
 (define-map cycle-set-height uint uint)
-(define-constant MAX_WRITES u340282366920938463463374607431768211455)
+(define-constant MAX_WRITES u4294967295)
 (define-constant CHUNK_SIZE (* u2 u1024 u1024))
 (define-constant ERR_NO_SUCH_PAGE u1)
 (define-constant ERR_CYCLE_NOT_SET u2)
 (define-map cycle-signer-set uint (list 4000 { signer: principal, weight: uint }))
 
+;; Called internally by the Stacks node.
+;; Stores the stackerdb signer slots for a given reward cycle.
+;; Since there is one stackerdb per signer message, the `num-slots` field will always be u1.
 (define-private (stackerdb-set-signer-slots 
                    (signer-slots (list 4000 { signer: principal, num-slots: uint }))
                    (reward-cycle uint)
@@ -19,6 +22,8 @@
             (ok (var-set stackerdb-signer-slots-0 signer-slots))
             (ok (var-set stackerdb-signer-slots-1 signer-slots)))))
 
+;; Called internally by te Stacks node.
+;; Sets the list of signers and weights for a given reward cycle.
 (define-private (stackerdb-set-signers
                  (reward-cycle uint)
                  (signers (list 4000 { signer: principal, weight: uint })))
@@ -26,27 +31,31 @@
       (asserts! (is-eq (var-get last-set-cycle) reward-cycle) (err ERR_CYCLE_NOT_SET))
       (ok (map-set cycle-signer-set reward-cycle signers))))
 
+;; Get the list of signers and weights for a given reward cycle.
 (define-read-only (get-signers (cycle uint))
      (map-get? cycle-signer-set cycle))
 
-(define-read-only (stackerdb-get-page-count) (ok u2))
-
-(define-read-only (stackerdb-get-signer-slots (page uint))
-    (if (is-eq page u0)      (ok (var-get stackerdb-signer-slots-0))
+;; called by .signers-(0|1)-xxx contracts to get the signers for their respective signing sets
+(define-read-only (stackerdb-get-signer-slots-page (page uint))
+    (if (is-eq page u0)     (ok (var-get stackerdb-signer-slots-0))
         (if (is-eq page u1)  (ok (var-get stackerdb-signer-slots-1))
-        (err ERR_NO_SUCH_PAGE))))
+            (err ERR_NO_SUCH_PAGE))))
 
-(define-read-only (stackerdb-get-signer-by-index (cycle uint) (signer-index uint))
+;; Get a signer's signing weight by a given index.
+;; Used by other contracts (e.g. the voting contract) 
+(define-read-only (get-signer-by-index (cycle uint) (signer-index uint))
 	(ok (element-at (unwrap! (map-get? cycle-signer-set cycle) (err ERR_CYCLE_NOT_SET)) signer-index)))
 
+;; called by .signers-(0|1)-xxx contracts
+;; NOTE: the node may ignore `write-freq`, since not all stackerdbs will be needed at a given time
 (define-read-only (stackerdb-get-config)
 	(ok
 		{ chunk-size: CHUNK_SIZE,
-		  write-freq: u0,
+		  write-freq: u0, 
 		  max-writes: MAX_WRITES,
 		  max-neighbors: u32,
-		  hint-replicas: (list) }
+		  hint-replicas: (list ) }
 	))
 
-(define-read-only (stackerdb-get-last-set-cycle)
-	(ok (var-get last-set-cycle)))
\ No newline at end of file
+(define-read-only (get-last-set-cycle)
+	(ok (var-get last-set-cycle)))

From e6ab1d00bd410e517ba3abbe317c8ee6ad8caf08 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 6 Feb 2024 13:15:05 -0500
Subject: [PATCH 0657/1166] chore: test coverage for signer DB contracts

---
 .../chainstate/stacks/boot/signers_tests.rs   | 109 ++++++++++++++++--
 1 file changed, 99 insertions(+), 10 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_tests.rs
index c3e0c27313..f0ba773f64 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_tests.rs
@@ -25,6 +25,7 @@ use clarity::vm::Value::Principal;
 use clarity::vm::{ClarityName, ClarityVersion, ContractName, Value};
 use stacks_common::address::AddressHashMode;
 use stacks_common::consts;
+use stacks_common::consts::SIGNER_SLOTS_PER_USER;
 use stacks_common::types::chainstate::{
     BurnchainHeaderHash, StacksAddress, StacksBlockId, StacksPrivateKey, StacksPublicKey,
 };
@@ -56,9 +57,7 @@ use crate::chainstate::stacks::{
 };
 use crate::clarity_vm::database::HeadersDBConn;
 use crate::core::BITCOIN_REGTEST_FIRST_BLOCK_HASH;
-use crate::net::stackerdb::{
-    STACKERDB_CONFIG_FUNCTION, STACKERDB_INV_MAX, STACKERDB_SLOTS_FUNCTION,
-};
+use crate::net::stackerdb::{STACKERDB_CONFIG_FUNCTION, STACKERDB_INV_MAX};
 use crate::net::test::{TestEventObserver, TestPeer};
 use crate::util_lib::boot::{boot_code_addr, boot_code_id, boot_code_test_addr};
 
@@ -196,6 +195,36 @@ fn signers_get_config() {
         ))
         .unwrap()
     );
+
+    for signer_set in 0..2 {
+        for message_id in 0..SIGNER_SLOTS_PER_USER {
+            let contract_name = format!("signers-{}-{}", &signer_set, &message_id);
+            let config = readonly_call(
+                &mut peer,
+                &latest_block,
+                contract_name.as_str().into(),
+                STACKERDB_CONFIG_FUNCTION.into(),
+                vec![],
+            );
+            assert_eq!(
+                config,
+                Value::okay(Value::Tuple(
+                    TupleData::from_data(vec![
+                        ("chunk-size".into(), Value::UInt(2 * 1024 * 1024)),
+                        ("write-freq".into(), Value::UInt(0)),
+                        ("max-writes".into(), Value::UInt(u128::MAX)),
+                        ("max-neighbors".into(), Value::UInt(32)),
+                        (
+                            "hint-replicas".into(),
+                            Value::cons_list_unsanitized(vec![]).unwrap()
+                        )
+                    ])
+                    .unwrap()
+                ))
+                .unwrap()
+            )
+        }
+    }
 }
 
 #[test]
@@ -221,10 +250,7 @@ fn signers_get_signer_keys_from_stackerdb() {
                 let signer_addr = StacksAddress::p2pkh(false, &pk);
                 let stackerdb_entry = TupleData::from_data(vec![
                     ("signer".into(), PrincipalData::from(signer_addr).into()),
-                    (
-                        "num-slots".into(),
-                        Value::UInt(consts::SIGNER_SLOTS_PER_USER.into()),
-                    ),
+                    ("num-slots".into(), Value::UInt(1)),
                 ])
                 .unwrap();
                 (pk_bytes, stackerdb_entry)
@@ -244,7 +270,7 @@ fn signers_get_signer_keys_from_stackerdb() {
         &mut peer,
         &latest_block_id,
         "signers".into(),
-        STACKERDB_SLOTS_FUNCTION.into(),
+        "stackerdb-get-signer-slots-page".into(),
         vec![Value::UInt(1)],
     )
     .expect_result_ok()
@@ -253,6 +279,69 @@ fn signers_get_signer_keys_from_stackerdb() {
     assert_eq!(signers, expected_stackerdb_slots);
 }
 
+#[test]
+fn signers_db_get_slots() {
+    let stacker_1 = TestStacker::from_seed(&[3, 4]);
+    let stacker_2 = TestStacker::from_seed(&[5, 6]);
+
+    let (mut peer, test_signers, latest_block_id, _) = prepare_signers_test(
+        function_name!(),
+        vec![],
+        &[stacker_1.clone(), stacker_2.clone()],
+        None,
+    );
+
+    let private_key = peer.config.private_key.clone();
+
+    let mut expected_signers: Vec<_> =
+        [&stacker_1.signer_private_key, &stacker_2.signer_private_key]
+            .iter()
+            .map(|sk| {
+                let pk = Secp256k1PublicKey::from_private(sk);
+                let pk_bytes = pk.to_bytes_compressed();
+                let signer_addr = StacksAddress::p2pkh(false, &pk);
+                let stackerdb_entry = TupleData::from_data(vec![
+                    ("signer".into(), PrincipalData::from(signer_addr).into()),
+                    ("num-slots".into(), Value::UInt(1)),
+                ])
+                .unwrap();
+                (pk_bytes, stackerdb_entry)
+            })
+            .collect();
+
+    // should be sorted by the pk bytes
+    expected_signers.sort_by_key(|x| x.0.clone());
+    let expected_stackerdb_slots = Value::cons_list_unsanitized(
+        expected_signers
+            .into_iter()
+            .map(|(_pk, entry)| Value::from(entry))
+            .collect(),
+    )
+    .unwrap();
+
+    for signer_set in 0..2 {
+        for message_id in 0..SIGNER_SLOTS_PER_USER {
+            let contract_name = format!("signers-{}-{}", &signer_set, &message_id);
+            let signers = readonly_call(
+                &mut peer,
+                &latest_block_id,
+                contract_name.as_str().into(),
+                "stackerdb-get-signer-slots".into(),
+                vec![],
+            )
+            .expect_result_ok()
+            .unwrap();
+
+            debug!("Check .{}", &contract_name);
+            if signer_set == 0 {
+                assert_eq!(signers.expect_list().unwrap(), vec![]);
+            } else {
+                assert_eq!(signers, expected_stackerdb_slots);
+            }
+        }
+    }
+}
+
 pub fn prepare_signers_test<'a>(
     test_name: &str,
     initial_balances: Vec<(PrincipalData, u64)>,
@@ -307,7 +396,7 @@ pub fn prepare_signers_test<'a>(
         &mut peer,
         &latest_block_id,
         SIGNERS_NAME.into(),
-        "stackerdb-get-last-set-cycle".into(),
+        "get-last-set-cycle".into(),
         vec![],
     )
     .expect_result_ok()
@@ -415,7 +504,7 @@ pub fn get_signer_index(
         peer,
         &latest_block_id,
         "signers".into(),
-        "stackerdb-get-signer-slots".into(),
+        "stackerdb-get-signer-slots-page".into(),
         vec![Value::UInt(cycle_mod)],
     )
     .expect_result_ok()

From ac65334ef3503dadfa19e9b9bc11f179f56a2096 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 6 Feb 2024 13:15:21 -0500
Subject: [PATCH 0658/1166] feat: instantiate signer DB contracts on epoch 2.5

---
 stackslib/src/clarity_vm/clarity.rs | 70 +++++++++++++++++++++++++----
 1 file changed, 62 insertions(+), 8 deletions(-)

diff --git a/stackslib/src/clarity_vm/clarity.rs b/stackslib/src/clarity_vm/clarity.rs
index b534fcb8c3..32e0b842ce 100644
--- a/stackslib/src/clarity_vm/clarity.rs
+++ b/stackslib/src/clarity_vm/clarity.rs
@@ -36,7 +36,7 @@ use clarity::vm::types::{
     TypeSignature, Value,
 };
 use clarity::vm::{analysis, ast, ClarityVersion, ContractName};
-use stacks_common::consts::CHAIN_ID_TESTNET;
+use stacks_common::consts::{CHAIN_ID_TESTNET, SIGNER_SLOTS_PER_USER};
 use stacks_common::types::chainstate::{
     BlockHeaderHash, BurnchainHeaderHash, SortitionId, StacksAddress, StacksBlockId, TrieHash,
 };
@@ -44,12 +44,12 @@ use stacks_common::util::secp256k1::MessageSignature;
 
 use crate::burnchains::{Burnchain, PoxConstants};
 use crate::chainstate::stacks::boot::{
-    BOOT_CODE_COSTS, BOOT_CODE_COSTS_2, BOOT_CODE_COSTS_2_TESTNET, BOOT_CODE_COSTS_3,
-    BOOT_CODE_COST_VOTING_TESTNET as BOOT_CODE_COST_VOTING, BOOT_CODE_POX_TESTNET,
-    BOOT_TEST_POX_4_AGG_KEY_CONTRACT, BOOT_TEST_POX_4_AGG_KEY_FNAME, COSTS_2_NAME, COSTS_3_NAME,
-    MINERS_NAME, POX_2_MAINNET_CODE, POX_2_NAME, POX_2_TESTNET_CODE, POX_3_MAINNET_CODE,
-    POX_3_NAME, POX_3_TESTNET_CODE, POX_4_CODE, POX_4_NAME, SIGNERS_BODY, SIGNERS_NAME,
-    SIGNERS_VOTING_NAME, SIGNER_VOTING_CODE,
+    make_signers_db_name, BOOT_CODE_COSTS, BOOT_CODE_COSTS_2, BOOT_CODE_COSTS_2_TESTNET,
+    BOOT_CODE_COSTS_3, BOOT_CODE_COST_VOTING_TESTNET as BOOT_CODE_COST_VOTING,
+    BOOT_CODE_POX_TESTNET, BOOT_TEST_POX_4_AGG_KEY_CONTRACT, BOOT_TEST_POX_4_AGG_KEY_FNAME,
+    COSTS_2_NAME, COSTS_3_NAME, MINERS_NAME, POX_2_MAINNET_CODE, POX_2_NAME, POX_2_TESTNET_CODE,
+    POX_3_MAINNET_CODE, POX_3_NAME, POX_3_TESTNET_CODE, POX_4_CODE, POX_4_NAME, SIGNERS_BODY,
+    SIGNERS_DB_0_BODY, SIGNERS_DB_1_BODY, SIGNERS_NAME, SIGNERS_VOTING_NAME, SIGNER_VOTING_CODE,
 };
 use crate::chainstate::stacks::db::{StacksAccount, StacksChainState};
 use crate::chainstate::stacks::events::{StacksTransactionEvent, StacksTransactionReceipt};
@@ -1305,6 +1305,8 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
                 TransactionVersion::Testnet
             };
 
+            let mut receipts = vec![];
+
             let boot_code_account = self
                 .get_boot_code_account()
                 .expect("FATAL: did not get boot account");
@@ -1443,6 +1445,7 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
                     &pox_4_initialization_receipt
                 );
             }
+            receipts.push(pox_4_initialization_receipt);
 
             let signers_contract_id = boot_code_id(SIGNERS_NAME, mainnet);
             let payload = TransactionPayload::SmartContract(
@@ -1479,6 +1482,56 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
                     &signers_initialization_receipt
                 );
             }
+            receipts.push(signers_initialization_receipt);
+
+            // stackerdb contracts for each message type
+            for signer_set in 0..2 {
+                for message_id in 0..SIGNER_SLOTS_PER_USER {
+                    let signers_name = make_signers_db_name(signer_set, message_id);
+                    let signers_contract_id = boot_code_id(&signers_name, mainnet);
+                    let body = if signer_set == 0 {
+                        SIGNERS_DB_0_BODY
+                    } else {
+                        SIGNERS_DB_1_BODY
+                    };
+                    let payload = TransactionPayload::SmartContract(
+                        TransactionSmartContract {
+                            name: ContractName::try_from(signers_name.clone())
+                                .expect("FATAL: invalid boot-code contract name"),
+                            code_body: StacksString::from_str(body)
+                                .expect("FATAL: invalid boot code body"),
+                        },
+                        Some(ClarityVersion::Clarity2),
+                    );
+
+                    let signers_contract_tx =
+                        StacksTransaction::new(tx_version.clone(), boot_code_auth.clone(), payload);
+
+                    let signers_db_receipt = self.as_transaction(|tx_conn| {
+                        // initialize with a synthetic transaction
+                        debug!("Instantiate {} contract", &signers_contract_id);
+                        let receipt = StacksChainState::process_transaction_payload(
+                            tx_conn,
+                            &signers_contract_tx,
+                            &boot_code_account,
+                            ASTRules::PrecheckSize,
+                        )
+                        .expect("FATAL: Failed to process .signers DB contract initialization");
+                        receipt
+                    });
+
+                    if signers_db_receipt.result != Value::okay_true()
+                        || signers_db_receipt.post_condition_aborted
+                    {
+                        panic!(
+                            "FATAL: Failure processing signers DB contract initialization: {:#?}",
+                            &signers_db_receipt
+                        );
+                    }
+
+                    receipts.push(signers_db_receipt);
+                }
+            }
 
             let signers_voting_code = &*SIGNER_VOTING_CODE;
             let signers_voting_contract_id = boot_code_id(SIGNERS_VOTING_NAME, mainnet);
@@ -1516,9 +1569,10 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
                     &signers_voting_initialization_receipt
                 );
             }
+            receipts.push(signers_voting_initialization_receipt);
 
             debug!("Epoch 2.5 initialized");
-            (old_cost_tracker, Ok(vec![pox_4_initialization_receipt]))
+            (old_cost_tracker, Ok(receipts))
         })
     }
 

From 6ca0285cd758b9a70e400211076fd73c1812adce Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 6 Feb 2024 13:15:37 -0500
Subject: [PATCH 0659/1166] fix: detect and return bad-signer errors

---
 stackslib/src/net/api/poststackerdbchunk.rs | 24 ++++++++++++++++-----
 1 file changed, 19 insertions(+), 5 deletions(-)

diff --git a/stackslib/src/net/api/poststackerdbchunk.rs b/stackslib/src/net/api/poststackerdbchunk.rs
index 57eb7ea2db..0caae735dd 100644
--- a/stackslib/src/net/api/poststackerdbchunk.rs
+++ b/stackslib/src/net/api/poststackerdbchunk.rs
@@ -117,6 +117,7 @@ impl HttpRequest for RPCPostStackerDBChunkRequestHandler {
 pub enum StackerDBErrorCodes {
     DataAlreadyExists,
     NoSuchSlot,
+    BadSigner,
 }
 
 impl StackerDBErrorCodes {
@@ -124,6 +125,7 @@ impl StackerDBErrorCodes {
         match self {
             Self::DataAlreadyExists => 0,
             Self::NoSuchSlot => 1,
+            Self::BadSigner => 2,
         }
     }
 
@@ -131,6 +133,7 @@ impl StackerDBErrorCodes {
         match self {
             Self::DataAlreadyExists => "Data for this slot and version already exist",
             Self::NoSuchSlot => "No such StackerDB slot",
+            Self::BadSigner => "Signature does not match slot signer",
         }
     }
 
@@ -184,11 +187,18 @@ impl RPCRequestHandler for RPCPostStackerDBChunkRequestHandler {
                         &HttpNotFound::new("StackerDB not found".to_string()),
                     ));
                 }
-                if let Err(_e) = tx.try_replace_chunk(
+                if let Err(e) = tx.try_replace_chunk(
                     &contract_identifier,
                     &stackerdb_chunk.get_slot_metadata(),
                     &stackerdb_chunk.data,
                 ) {
+                    test_debug!(
+                        "Failed to replace chunk {}.{} in {}: {:?}",
+                        stackerdb_chunk.slot_id,
+                        stackerdb_chunk.slot_version,
+                        &contract_identifier,
+                        &e
+                    );
                     let slot_metadata_opt =
                         match tx.get_slot_metadata(&contract_identifier, stackerdb_chunk.slot_id) {
                             Ok(slot_opt) => slot_opt,
@@ -210,11 +220,15 @@ impl RPCRequestHandler for RPCPostStackerDBChunkRequestHandler {
 
                     let (reason, slot_metadata_opt) = if let Some(slot_metadata) = slot_metadata_opt
                     {
+                        let code = if let NetError::BadSlotSigner(..) = e {
+                            StackerDBErrorCodes::BadSigner
+                        } else {
+                            StackerDBErrorCodes::DataAlreadyExists
+                        };
+
                         (
-                            serde_json::to_string(
-                                &StackerDBErrorCodes::DataAlreadyExists.into_json(),
-                            )
-                            .unwrap_or("(unable to encode JSON)".to_string()),
+                            serde_json::to_string(&code.into_json())
+                                .unwrap_or("(unable to encode JSON)".to_string()),
                             Some(slot_metadata),
                         )
                     } else {

From c909a1fc88e6477c8c970de6da52299344b4c740 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 6 Feb 2024 13:16:35 -0500
Subject: [PATCH 0660/1166] fix: revert multi-page stackerdb system

---
 stackslib/src/net/stackerdb/config.rs | 194 +++++++++++---------------
 1 file changed, 79 insertions(+), 115 deletions(-)

diff --git a/stackslib/src/net/stackerdb/config.rs b/stackslib/src/net/stackerdb/config.rs
index 7ad41ba119..cd730878b1 100644
--- a/stackslib/src/net/stackerdb/config.rs
+++ b/stackslib/src/net/stackerdb/config.rs
@@ -65,7 +65,7 @@ use crate::chainstate::stacks::Error as chainstate_error;
 use crate::clarity_vm::clarity::{ClarityReadOnlyConnection, Error as clarity_error};
 use crate::net::stackerdb::{
     StackerDBConfig, StackerDBs, STACKERDB_CONFIG_FUNCTION, STACKERDB_INV_MAX,
-    STACKERDB_MAX_CHUNK_SIZE, STACKERDB_SLOTS_FUNCTION,
+    STACKERDB_MAX_CHUNK_SIZE,
 };
 use crate::net::{Error as NetError, NeighborAddress};
 
@@ -221,114 +221,64 @@ impl StackerDBConfig {
             burn_dbconn,
             tip,
             contract_id,
-            "({STACKERDB_SLOTS_FUNCTION})",
+            "(stackerdb-get-signer-slots)",
         )?;
 
-        let mut return_set: Option<Vec<(StacksAddress, u32)>> = None;
-        let mut total_num_slots = 0u32;
-        for page in 0..page_count {
-            let (mut new_entries, total_new_slots) =
-                Self::eval_signer_slots_page(chainstate, burn_dbconn, contract_id, tip, page)?;
-            total_num_slots = total_num_slots
-                .checked_add(total_new_slots)
-                .ok_or_else(|| {
-                    NetError::OverflowError(format!(
-                        "Contract {contract_id} set more than u32::MAX slots",
-                    ))
-                })?;
-            if total_num_slots > STACKERDB_INV_MAX {
-                let reason =
-                    format!("Contract {contract_id} set more than the maximum number of slots in a page (max = {STACKERDB_INV_MAX})",);
-                warn!("{reason}");
+        let result = value.expect_result()?;
+        let slot_list = match result {
+            Err(err_val) => {
+                let err_code = err_val.expect_u128()?;
+                let reason = format!(
+                    "Contract {} failed to run `stackerdb-get-signer-slots`: error u{}",
+                    contract_id, &err_code
+                );
+                warn!("{}", &reason);
                 return Err(NetError::InvalidStackerDBContract(
                     contract_id.clone(),
                     reason,
                 ));
             }
-            // avoid buffering on the first page
-            if let Some(ref mut return_set) = return_set {
-                return_set.append(&mut new_entries);
-            } else {
-                return_set = Some(new_entries);
-            };
-        }
-        Ok(return_set.unwrap_or_else(|| vec![]))
-    }
-
-    /// Evaluate the contract to get its signer slots
-    fn eval_signer_slots_page(
-        chainstate: &mut StacksChainState,
-        burn_dbconn: &dyn BurnStateDB,
-        contract_id: &QualifiedContractIdentifier,
-        tip: &StacksBlockId,
-        page: u32,
-    ) -> Result<(Vec<(StacksAddress, u32)>, u32), NetError> {
-        let resp_value = chainstate.eval_fn_read_only(
-            burn_dbconn,
-            tip,
-            contract_id,
-            STACKERDB_SLOTS_FUNCTION,
-            &[ClarityValue::UInt(page.into())],
-        )?;
-
-        if !matches!(resp_value, ClarityValue::Response(_)) {
-            let reason = format!("StackerDB fn `{contract_id}.{STACKERDB_SLOTS_FUNCTION}` returned unexpected non-response type");
-            warn!("{reason}");
-            return Err(NetError::InvalidStackerDBContract(
-                contract_id.clone(),
-                reason,
-            ));
-        }
-
-        let slot_list_val = resp_value.expect_result()?.map_err(|err_val| {
-            let reason = format!(
-                "StackerDB fn `{contract_id}.{STACKERDB_SLOTS_FUNCTION}` failed: error {err_val}",
-            );
-            warn!("{reason}");
-            NetError::InvalidStackerDBContract(contract_id.clone(), reason)
-        })?;
-
-        let slot_list = if let ClarityValue::Sequence(SequenceData::List(list_data)) = slot_list_val
-        {
-            list_data.data
-        } else {
-            let reason = format!("StackerDB fn `{contract_id}.{STACKERDB_SLOTS_FUNCTION}` returned unexpected non-list ok type");
-            warn!("{reason}");
-            return Err(NetError::InvalidStackerDBContract(
-                contract_id.clone(),
-                reason,
-            ));
+            Ok(ok_val) => ok_val.expect_list()?,
         };
 
-        if slot_list.len() > usize::try_from(STACKERDB_INV_MAX).unwrap() {
-            let reason = format!("StackerDB fn `{contract_id}.{STACKERDB_SLOTS_FUNCTION}` returned too long list (max len={STACKERDB_INV_MAX})");
-            warn!("{reason}");
-            return Err(NetError::InvalidStackerDBContract(
-                contract_id.clone(),
-                reason,
-            ));
-        }
-
         let mut total_num_slots = 0u32;
         let mut ret = vec![];
         for slot_value in slot_list.into_iter() {
-            let (addr, num_slots) =
-                Self::parse_slot_entry(slot_value, contract_id).map_err(|reason| {
-                    warn!("{reason}");
-                    NetError::InvalidStackerDBContract(contract_id.clone(), reason)
-                })?;
+            let slot_data = slot_value.expect_tuple()?;
+            let signer_principal = slot_data
+                .get("signer")
+                .expect("FATAL: no 'signer'")
+                .clone()
+                .expect_principal()?;
+            let num_slots_uint = slot_data
+                .get("num-slots")
+                .expect("FATAL: no 'num-slots'")
+                .clone()
+                .expect_u128()?;
 
+            if num_slots_uint > (STACKERDB_INV_MAX as u128) {
+                let reason = format!(
+                    "Contract {} stipulated more than maximum number of slots for one signer ({})",
+                    contract_id, STACKERDB_INV_MAX
+                );
+                warn!("{}", &reason);
+                return Err(NetError::InvalidStackerDBContract(
+                    contract_id.clone(),
+                    reason,
+                ));
+            }
+            let num_slots = num_slots_uint as u32;
             total_num_slots =
                 total_num_slots
                     .checked_add(num_slots)
                     .ok_or(NetError::OverflowError(format!(
-                        "Contract {} set more than u32::MAX slots",
+                        "Contract {} stipulates more than u32::MAX slots",
                         &contract_id
                     )))?;
 
             if total_num_slots > STACKERDB_INV_MAX.into() {
                 let reason = format!(
-                    "Contract {} set more than the maximum number of slots",
+                    "Contract {} stipulated more than the maximum number of slots",
                     contract_id
                 );
                 warn!("{}", &reason);
@@ -338,9 +288,25 @@ impl StackerDBConfig {
                 ));
             }
 
+            // standard principals only
+            let addr = match signer_principal {
+                PrincipalData::Contract(..) => {
+                    let reason = format!("Contract {} stipulated a contract principal as a writer, which is not supported", contract_id);
+                    warn!("{}", &reason);
+                    return Err(NetError::InvalidStackerDBContract(
+                        contract_id.clone(),
+                        reason,
+                    ));
+                }
+                PrincipalData::Standard(StandardPrincipalData(version, bytes)) => StacksAddress {
+                    version,
+                    bytes: Hash160(bytes),
+                },
+            };
+
             ret.push((addr, num_slots));
         }
-        Ok((ret, total_num_slots))
+        Ok(ret)
     }
 
     /// Evaluate the contract to get its config
@@ -554,33 +520,31 @@ impl StackerDBConfig {
         let dbconn = sortition_db.index_conn();
 
         // check the target contract
-        let res =
-            chainstate.maybe_read_only_clarity_tx(&dbconn, &chain_tip_hash, |clarity_tx| {
-                // determine if this contract exists and conforms to this trait
-                clarity_tx.with_clarity_db_readonly(|db| {
-                    // contract must exist or this errors out
-                    let analysis = db
-                        .load_contract_analysis(contract_id)?
-                        .ok_or(NetError::NoSuchStackerDB(contract_id.clone()))?;
-
-                    // contract must be consistent with StackerDB control interface
-                    if let Err(invalid_reason) =
-                        Self::is_contract_valid(&cur_epoch.epoch_id, analysis)
-                    {
-                        let reason = format!(
-                            "Contract {} does not conform to StackerDB trait: {}",
-                            contract_id, invalid_reason
-                        );
-                        warn!("{}", &reason);
-                        return Err(NetError::InvalidStackerDBContract(
-                            contract_id.clone(),
-                            reason,
-                        ));
-                    }
-
-                    Ok(())
-                })
-            })?;
+        let res = chainstate.with_read_only_clarity_tx(&dbconn, &chain_tip_hash, |clarity_tx| {
+            // determine if this contract exists and conforms to this trait
+            clarity_tx.with_clarity_db_readonly(|db| {
+                // contract must exist or this errors out
+                let analysis = db
+                    .load_contract_analysis(contract_id)?
+                    .ok_or(NetError::NoSuchStackerDB(contract_id.clone()))?;
+
+                // contract must be consistent with StackerDB control interface
+                if let Err(invalid_reason) = Self::is_contract_valid(&cur_epoch.epoch_id, analysis)
+                {
+                    let reason = format!(
+                        "Contract {} does not conform to StackerDB trait: {}",
+                        contract_id, invalid_reason
+                    );
+                    warn!("{}", &reason);
+                    return Err(NetError::InvalidStackerDBContract(
+                        contract_id.clone(),
+                        reason,
+                    ));
+                }
+
+                Ok(())
+            })
+        });
 
         if res.is_none() {
             let reason = format!(

From 93b1e70a822d6d6ee34647265550f876832fa7ae Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 6 Feb 2024 13:16:49 -0500
Subject: [PATCH 0661/1166] chore: log config reloads

---
 stackslib/src/net/stackerdb/mod.rs | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/stackslib/src/net/stackerdb/mod.rs b/stackslib/src/net/stackerdb/mod.rs
index 979b0bec3e..89d5d422a7 100644
--- a/stackslib/src/net/stackerdb/mod.rs
+++ b/stackslib/src/net/stackerdb/mod.rs
@@ -153,9 +153,6 @@ pub const STACKERDB_PAGE_COUNT_FUNCTION: &str = "stackerdb-get-page-count";
 pub const STACKERDB_SLOTS_FUNCTION: &str = "stackerdb-get-signer-slots";
 pub const STACKERDB_CONFIG_FUNCTION: &str = "stackerdb-get-config";
 
-pub const STACKERDB_SLOTS_FUNCTION: &str = "stackerdb-get-signer-slots";
-pub const STACKERDB_CONFIG_FUNCTION: &str = "stackerdb-get-config";
-
 /// Final result of synchronizing state with a remote set of DB replicas
 pub struct StackerDBSyncResult {
     /// which contract this is a replica for
@@ -317,6 +314,7 @@ impl StackerDBs {
             }
             // Even if we failed to create or reconfigure the DB, we still want to keep track of them
             // so that we can attempt to create/reconfigure them again later.
+            debug!("Reloaded configuration for {}", &stackerdb_contract_id);
             new_stackerdb_configs.insert(stackerdb_contract_id, new_config);
         }
         Ok(new_stackerdb_configs)

From 3eb3b545fcc4dafe90c9515b6a4e0cd9607e18b7 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 6 Feb 2024 13:17:05 -0500
Subject: [PATCH 0662/1166] chore: log contract ID with sync completion

---
 stackslib/src/net/stackerdb/sync.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stackslib/src/net/stackerdb/sync.rs b/stackslib/src/net/stackerdb/sync.rs
index 8e98852e3e..bf76092a72 100644
--- a/stackslib/src/net/stackerdb/sync.rs
+++ b/stackslib/src/net/stackerdb/sync.rs
@@ -163,7 +163,7 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
         network: Option<&PeerNetwork>,
         config: &StackerDBConfig,
     ) -> StackerDBSyncResult {
-        debug!("Reset with config {:?}", config);
+        debug!("Reset {} with config {:?}", &self.smart_contract_id, config);
         let mut chunks = vec![];
         let downloaded_chunks = mem::replace(&mut self.downloaded_chunks, HashMap::new());
         for (_, mut data) in downloaded_chunks.into_iter() {

From b10679b605494c7c674c73e72175592c41e9ef56 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 6 Feb 2024 13:17:20 -0500
Subject: [PATCH 0663/1166] feat: add `signer = bool` option to [node] so that
 the node will automatically subscribe to all the signer DB contracts if it's
 acting as a signer's node

---
 testnet/stacks-node/src/config.rs | 29 ++++++++++++++++++++++++++---
 1 file changed, 26 insertions(+), 3 deletions(-)

diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index 6efe382aa6..5f22d63f5a 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -12,7 +12,7 @@ use lazy_static::lazy_static;
 use rand::RngCore;
 use stacks::burnchains::bitcoin::BitcoinNetworkType;
 use stacks::burnchains::{Burnchain, MagicBytes, BLOCKSTACK_MAGIC_MAINNET};
-use stacks::chainstate::stacks::boot::MINERS_NAME;
+use stacks::chainstate::stacks::boot::{make_signers_db_name, MINERS_NAME};
 use stacks::chainstate::stacks::index::marf::MARFOpenOpts;
 use stacks::chainstate::stacks::index::storage::TrieHashCalculationMode;
 use stacks::chainstate::stacks::miner::{BlockBuilderSettings, MinerStatus};
@@ -33,6 +33,7 @@ use stacks::net::{Neighbor, NeighborKey};
 use stacks::util_lib::boot::boot_code_id;
 use stacks::util_lib::db::Error as DBError;
 use stacks_common::address::{AddressHashMode, C32_ADDRESS_VERSION_TESTNET_SINGLESIG};
+use stacks_common::consts::SIGNER_SLOTS_PER_USER;
 use stacks_common::types::chainstate::StacksAddress;
 use stacks_common::types::net::PeerAddress;
 use stacks_common::types::Address;
@@ -216,6 +217,7 @@ impl ConfigFile {
         let node = NodeConfigFile {
             bootstrap_node: Some("029266faff4c8e0ca4f934f34996a96af481df94a89b0c9bd515f3536a95682ddc@seed.testnet.hiro.so:30444".to_string()),
             miner: Some(false),
+            stacker: Some(false),
             ..NodeConfigFile::default()
         };
 
@@ -261,6 +263,7 @@ impl ConfigFile {
         let node = NodeConfigFile {
             bootstrap_node: Some("02196f005965cebe6ddc3901b7b1cc1aa7a88f305bb8c5893456b8f9a605923893@seed.mainnet.hiro.so:20444,02539449ad94e6e6392d8c1deb2b4e61f80ae2a18964349bc14336d8b903c46a8c@cet.stacksnodes.org:20444,02ececc8ce79b8adf813f13a0255f8ae58d4357309ba0cedd523d9f1a306fcfb79@sgt.stacksnodes.org:20444,0303144ba518fe7a0fb56a8a7d488f950307a4330f146e1e1458fc63fb33defe96@est.stacksnodes.org:20444".to_string()),
             miner: Some(false),
+            stacker: Some(false),
             ..NodeConfigFile::default()
         };
 
@@ -329,6 +332,7 @@ impl ConfigFile {
         let node = NodeConfigFile {
             bootstrap_node: None,
             miner: Some(true),
+            stacker: Some(true),
             ..NodeConfigFile::default()
         };
 
@@ -392,6 +396,7 @@ impl ConfigFile {
 
         let node = NodeConfigFile {
             miner: Some(false),
+            stacker: Some(false),
             ..NodeConfigFile::default()
         };
 
@@ -411,6 +416,7 @@ impl ConfigFile {
 
         let node = NodeConfigFile {
             miner: Some(false),
+            stacker: Some(false),
             ..NodeConfigFile::default()
         };
 
@@ -957,13 +963,25 @@ impl Config {
         }
 
         let miners_contract_id = boot_code_id(MINERS_NAME, is_mainnet);
-        if node.miner
+        if (node.stacker || node.miner)
             && burnchain.mode == "nakamoto-neon"
             && !node.stacker_dbs.contains(&miners_contract_id)
         {
-            debug!("A miner must subscribe to the {miners_contract_id} stacker db contract. Forcibly subscribing...");
+            debug!("A miner/stacker must subscribe to the {miners_contract_id} stacker db contract. Forcibly subscribing...");
             node.stacker_dbs.push(miners_contract_id);
         }
+        if (node.stacker || node.miner) && burnchain.mode == "nakamoto-neon" {
+            for signer_set in 0..2 {
+                for message_id in 0..SIGNER_SLOTS_PER_USER {
+                    let contract_name = make_signers_db_name(signer_set, message_id);
+                    let contract_id = boot_code_id(contract_name.as_str(), is_mainnet);
+                    if !node.stacker_dbs.contains(&contract_id) {
+                        debug!("A miner/stacker must subscribe to the {contract_id} stacker db contract. Forcibly subscribing...");
+                        node.stacker_dbs.push(contract_id);
+                    }
+                }
+            }
+        }
 
         let miner = match config_file.miner {
             Some(miner) => miner.into_config_default(miner_default_config)?,
@@ -1545,6 +1563,7 @@ pub struct NodeConfig {
     pub bootstrap_node: Vec<Neighbor>,
     pub deny_nodes: Vec<Neighbor>,
     pub miner: bool,
+    pub stacker: bool,
     pub mock_mining: bool,
     pub mine_microblocks: bool,
     pub microblock_frequency: u64,
@@ -1832,6 +1851,7 @@ impl Default for NodeConfig {
             deny_nodes: vec![],
             local_peer_seed: local_peer_seed.to_vec(),
             miner: false,
+            stacker: false,
             mock_mining: false,
             mine_microblocks: true,
             microblock_frequency: 30_000,
@@ -2213,6 +2233,7 @@ pub struct NodeConfigFile {
     pub bootstrap_node: Option<String>,
     pub local_peer_seed: Option<String>,
     pub miner: Option<bool>,
+    pub stacker: Option<bool>,
     pub mock_mining: Option<bool>,
     pub mine_microblocks: Option<bool>,
     pub microblock_frequency: Option<u64>,
@@ -2240,6 +2261,7 @@ impl NodeConfigFile {
     fn into_config_default(self, default_node_config: NodeConfig) -> Result<NodeConfig, String> {
         let rpc_bind = self.rpc_bind.unwrap_or(default_node_config.rpc_bind);
         let miner = self.miner.unwrap_or(default_node_config.miner);
+        let stacker = self.stacker.unwrap_or(default_node_config.stacker);
         let node_config = NodeConfig {
             name: self.name.unwrap_or(default_node_config.name),
             seed: match self.seed {
@@ -2264,6 +2286,7 @@ impl NodeConfigFile {
                 None => default_node_config.local_peer_seed,
             },
             miner,
+            stacker,
             mock_mining: self.mock_mining.unwrap_or(default_node_config.mock_mining),
             mine_microblocks: self
                 .mine_microblocks

From 9ea60ff956a49c5d1febdeec43780cff31735eeb Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 6 Feb 2024 13:18:02 -0500
Subject: [PATCH 0664/1166] feat: boot into nakamoto with many stackers

---
 .../src/tests/nakamoto_integrations.rs        | 60 ++++++++++---------
 1 file changed, 32 insertions(+), 28 deletions(-)

diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 8cc19c9b13..8011677d32 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -63,7 +63,7 @@ use crate::tests::neon_integrations::{
 use crate::tests::{make_stacks_transfer, to_addr};
 use crate::{tests, BitcoinRegtestController, BurnchainController, Config, ConfigFile, Keychain};
 
-static POX_4_DEFAULT_STACKER_BALANCE: u64 = 100_000_000_000_000;
+pub static POX_4_DEFAULT_STACKER_BALANCE: u64 = 100_000_000_000_000;
 static POX_4_DEFAULT_STACKER_STX_AMT: u128 = 99_000_000_000_000;
 
 lazy_static! {
@@ -346,15 +346,17 @@ pub fn setup_stacker(naka_conf: &mut Config) -> Secp256k1PrivateKey {
 }
 
 ///
-/// * `stacker_sk` - must be a private key for sending a large `stack-stx` transaction in order
+/// * `stacker_sks` - must be a private key for sending a large `stack-stx` transaction in order
 ///   for pox-4 to activate
 pub fn boot_to_epoch_3(
     naka_conf: &Config,
     blocks_processed: &RunLoopCounter,
-    stacker_sk: Secp256k1PrivateKey,
-    signer_pk: StacksPublicKey,
+    stacker_sks: &[Secp256k1PrivateKey],
+    signer_pks: &[StacksPublicKey],
     btc_regtest_controller: &mut BitcoinRegtestController,
 ) {
+    assert_eq!(stacker_sks.len(), signer_pks.len());
+
     let epochs = naka_conf.burnchain.epochs.clone().unwrap();
     let epoch_3 = &epochs[StacksEpoch::find_epoch_by_id(&epochs, StacksEpochId::Epoch30).unwrap()];
 
@@ -375,23 +377,25 @@ pub fn boot_to_epoch_3(
         AddressHashMode::SerializeP2PKH as u8,
     ));
 
-    let stacking_tx = tests::make_contract_call(
-        &stacker_sk,
-        0,
-        1000,
-        &StacksAddress::burn_address(false),
-        "pox-4",
-        "stack-stx",
-        &[
-            clarity::vm::Value::UInt(POX_4_DEFAULT_STACKER_STX_AMT),
-            pox_addr_tuple,
-            clarity::vm::Value::UInt(205),
-            clarity::vm::Value::UInt(12),
-            clarity::vm::Value::buff_from(signer_pk.to_bytes_compressed()).unwrap(),
-        ],
-    );
+    for (stacker_sk, signer_pk) in stacker_sks.iter().zip(signer_pks.iter()) {
+        let stacking_tx = tests::make_contract_call(
+            &stacker_sk,
+            0,
+            1000,
+            &StacksAddress::burn_address(false),
+            "pox-4",
+            "stack-stx",
+            &[
+                clarity::vm::Value::UInt(POX_4_DEFAULT_STACKER_STX_AMT),
+                pox_addr_tuple.clone(),
+                clarity::vm::Value::UInt(205),
+                clarity::vm::Value::UInt(12),
+                clarity::vm::Value::buff_from(signer_pk.to_bytes_compressed()).unwrap(),
+            ],
+        );
 
-    submit_tx(&http_origin, &stacking_tx);
+        submit_tx(&http_origin, &stacking_tx);
+    }
 
     run_until_burnchain_height(
         btc_regtest_controller,
@@ -465,8 +469,8 @@ fn simple_neon_integration() {
     boot_to_epoch_3(
         &naka_conf,
         &blocks_processed,
-        stacker_sk,
-        sender_signer_key,
+        &vec![stacker_sk],
+        &vec![sender_signer_key],
         &mut btc_regtest_controller,
     );
 
@@ -685,8 +689,8 @@ fn mine_multiple_per_tenure_integration() {
     boot_to_epoch_3(
         &naka_conf,
         &blocks_processed,
-        stacker_sk,
-        sender_signer_key,
+        &vec![stacker_sk],
+        &vec![sender_signer_key],
         &mut btc_regtest_controller,
     );
 
@@ -1094,8 +1098,8 @@ fn block_proposal_api_endpoint() {
     boot_to_epoch_3(
         &conf,
         &blocks_processed,
-        stacker_sk,
-        StacksPublicKey::new(),
+        &vec![stacker_sk],
+        &vec![StacksPublicKey::new()],
         &mut btc_regtest_controller,
     );
 
@@ -1437,8 +1441,8 @@ fn miner_writes_proposed_block_to_stackerdb() {
     boot_to_epoch_3(
         &naka_conf,
         &blocks_processed,
-        stacker_sk,
-        StacksPublicKey::new(),
+        &vec![stacker_sk],
+        &vec![StacksPublicKey::new()],
         &mut btc_regtest_controller,
     );
 

From c75571e257736c8921d90492ee002babd08a0816 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 6 Feb 2024 13:18:16 -0500
Subject: [PATCH 0665/1166] WIP: get stackerdb-driven DKG test to work with
 lots of small stackerdbs

---
 testnet/stacks-node/src/tests/signer.rs | 87 +++++++++----------------
 1 file changed, 30 insertions(+), 57 deletions(-)

diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index 80b52d78bd..6e6bf02cee 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -6,14 +6,15 @@ use std::sync::{Arc, Mutex};
 use std::time::{Duration, Instant};
 use std::{env, thread};
 
+use clarity::boot_util::boot_code_id;
 use clarity::vm::types::QualifiedContractIdentifier;
 use libsigner::{
     BlockResponse, RejectCode, RunningSigner, Signer, SignerEventReceiver, SignerMessage,
-    BLOCK_SLOT_ID, SIGNER_SLOTS_PER_USER,
+    BLOCK_SLOT_ID,
 };
 use stacks::chainstate::coordinator::comm::CoordinatorChannels;
 use stacks::chainstate::nakamoto::{NakamotoBlock, NakamotoBlockHeader};
-use stacks::chainstate::stacks::boot::SIGNERS_NAME;
+use stacks::chainstate::stacks::boot::{make_signers_db_name, SIGNERS_NAME};
 use stacks::chainstate::stacks::{
     StacksPrivateKey, StacksTransaction, ThresholdSignature, TransactionAnchorMode,
     TransactionAuth, TransactionPayload, TransactionPostConditionMode, TransactionSmartContract,
@@ -23,6 +24,7 @@ use stacks::net::api::postblock_proposal::BlockValidateResponse;
 use stacks::util_lib::strings::StacksString;
 use stacks_common::bitvec::BitVec;
 use stacks_common::codec::read_next;
+use stacks_common::consts::SIGNER_SLOTS_PER_USER;
 use stacks_common::types::chainstate::{
     ConsensusHash, StacksAddress, StacksBlockId, StacksPublicKey, TrieHash,
 };
@@ -31,7 +33,7 @@ use stacks_common::util::secp256k1::MessageSignature;
 use stacks_signer::client::{StackerDB, StacksClient};
 use stacks_signer::config::{Config as SignerConfig, Network};
 use stacks_signer::runloop::{calculate_coordinator, RunLoopCommand};
-use stacks_signer::utils::{build_signer_config_tomls, build_stackerdb_contract};
+use stacks_signer::utils::build_signer_config_tomls;
 use tracing_subscriber::prelude::*;
 use tracing_subscriber::{fmt, EnvFilter};
 use wsts::curve::point::Point;
@@ -45,12 +47,10 @@ use crate::run_loop::boot_nakamoto;
 use crate::tests::bitcoin_regtest::BitcoinCoreController;
 use crate::tests::nakamoto_integrations::{
     boot_to_epoch_3, naka_neon_integration_conf, next_block_and, next_block_and_mine_commit,
-    setup_stacker,
+    setup_stacker, POX_4_DEFAULT_STACKER_BALANCE,
 };
-use crate::tests::neon_integrations::{
-    next_block_and_wait, submit_tx, test_observer, wait_for_runloop,
-};
-use crate::tests::{make_contract_publish, to_addr};
+use crate::tests::neon_integrations::{next_block_and_wait, test_observer, wait_for_runloop};
+use crate::tests::to_addr;
 use crate::{BitcoinRegtestController, BurnchainController};
 
 // Helper struct for holding the btc and stx neon nodes
@@ -87,23 +87,12 @@ struct SignerTest {
 impl SignerTest {
     fn new(num_signers: u32, num_keys: u32) -> Self {
         // Generate Signer Data
-        let publisher_private_key = StacksPrivateKey::new();
         let signer_stacks_private_keys = (0..num_signers)
             .map(|_| StacksPrivateKey::new())
             .collect::<Vec<StacksPrivateKey>>();
-        let signer_stacks_addresses = signer_stacks_private_keys
-            .iter()
-            .map(to_addr)
-            .collect::<Vec<StacksAddress>>();
 
         // Build the stackerdb signers contract
-        // TODO: Remove this once it is a boot contract
-        let signers_stackerdb_contract =
-            build_stackerdb_contract(&signer_stacks_addresses, SIGNER_SLOTS_PER_USER);
-        let signers_stacker_db_contract_id = QualifiedContractIdentifier::new(
-            to_addr(&publisher_private_key).into(),
-            "signers".into(),
-        );
+        let signers_stacker_db_contract_id = boot_code_id("signers".into(), false);
 
         let (naka_conf, _miner_account) = naka_neon_integration_conf(None);
 
@@ -138,9 +127,6 @@ impl SignerTest {
             naka_conf,
             num_signers,
             &signer_stacks_private_keys,
-            &publisher_private_key,
-            &signers_stackerdb_contract,
-            &signers_stacker_db_contract_id,
             &signer_configs,
         );
 
@@ -222,9 +208,6 @@ fn setup_stx_btc_node(
     mut naka_conf: NeonConfig,
     num_signers: u32,
     signer_stacks_private_keys: &[StacksPrivateKey],
-    publisher_private_key: &StacksPrivateKey,
-    stackerdb_contract: &str,
-    stackerdb_contract_id: &QualifiedContractIdentifier,
     signer_config_tomls: &Vec<String>,
 ) -> RunningNodes {
     // Spawn the endpoints for observing signers
@@ -237,6 +220,11 @@ fn setup_stx_btc_node(
         });
     }
 
+    let signer_stacks_pubks: Vec<_> = signer_stacks_private_keys
+        .iter()
+        .map(|pk| StacksPublicKey::from_private(pk))
+        .collect();
+
     // Spawn a test observer for verification purposes
     test_observer::spawn();
     let observer_port = test_observer::EVENT_OBSERVER_PORT;
@@ -248,25 +236,27 @@ fn setup_stx_btc_node(
     // The signers need some initial balances in order to pay for epoch 2.5 transaction votes
     let mut initial_balances = Vec::new();
 
-    initial_balances.push(InitialBalance {
-        address: to_addr(publisher_private_key).into(),
-        amount: 10_000_000_000_000,
-    });
-
+    // TODO: separate keys for stacking and signing (because they'll be different in prod)
     for i in 0..num_signers {
         initial_balances.push(InitialBalance {
             address: to_addr(&signer_stacks_private_keys[i as usize]).into(),
-            amount: 10_000_000_000_000,
+            amount: POX_4_DEFAULT_STACKER_BALANCE,
         });
     }
     naka_conf.initial_balances.append(&mut initial_balances);
-    naka_conf
-        .node
-        .stacker_dbs
-        .push(stackerdb_contract_id.clone());
+    naka_conf.node.stacker = true;
     naka_conf.miner.wait_on_interim_blocks = Duration::from_secs(1000);
 
-    let stacker_sk = setup_stacker(&mut naka_conf);
+    for signer_set in 0..2 {
+        for message_id in 0..SIGNER_SLOTS_PER_USER {
+            let contract_name = make_signers_db_name(signer_set, message_id);
+            let contract_id = boot_code_id(contract_name.as_str(), false);
+            if !naka_conf.node.stacker_dbs.contains(&contract_id) {
+                debug!("A miner/stacker must subscribe to the {contract_id} stacker db contract. Forcibly subscribing...");
+                naka_conf.node.stacker_dbs.push(contract_id);
+            }
+        }
+    }
 
     info!("Make new BitcoinCoreController");
     let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone());
@@ -311,29 +301,12 @@ fn setup_stx_btc_node(
     info!("Mine third block...");
     next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
 
-    info!("Send signers stacker-db contract-publish...");
-    let http_origin = format!("http://{}", &naka_conf.node.rpc_bind);
-
-    let tx_fee = 100_000;
-    let tx = make_contract_publish(
-        publisher_private_key,
-        0,
-        tx_fee,
-        &stackerdb_contract_id.name,
-        stackerdb_contract,
-    );
-    submit_tx(&http_origin, &tx);
-    // mine it
-    info!("Mining the signers stackerdb contract: {stackerdb_contract_id}");
-    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
-    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
-
     info!("Boot to epoch 3.0 to activate pox-4...");
     boot_to_epoch_3(
         &naka_conf,
         &blocks_processed,
-        stacker_sk,
-        StacksPublicKey::new(),
+        signer_stacks_private_keys,
+        &signer_stacks_pubks,
         &mut btc_regtest_controller,
     );
 
@@ -534,7 +507,7 @@ fn stackerdb_dkg_sign() {
 ///
 /// Test Assertion:
 /// Signers return an operation result containing a valid signature across the miner's Nakamoto block's signature hash.
-/// Signers broadcasted a signature across the miner's proposed block back to the .signers contract.
+/// Signers broadcasted a signature across the miner's proposed block back to the respective .signers-XXX-YYY contract.
 /// TODO: update test to check miner received the signed block and appended it to the chain
 fn stackerdb_block_proposal() {
     if env::var("BITCOIND_TEST") != Ok("1".into()) {

From 853494ac23bc6c0e8fd26d3e69287e9739fb3024 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Tue, 6 Feb 2024 10:53:45 -0800
Subject: [PATCH 0666/1166] feat: updated stack-stx signatures in integration
 tests

---
 testnet/stacks-node/src/mockamoto.rs          | 54 +++++++++----------
 .../src/tests/nakamoto_integrations.rs        | 50 ++++++++---------
 2 files changed, 47 insertions(+), 57 deletions(-)

diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index 7b570b1e3c..77a0993b8f 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -69,12 +69,14 @@ use stacks::net::atlas::{AtlasConfig, AtlasDB};
 use stacks::net::relay::Relayer;
 use stacks::net::stackerdb::StackerDBs;
 use stacks::util_lib::db::Error as DBError;
-use stacks::util_lib::signed_structured_data::{make_structured_data_domain, sign_structured_data};
+use stacks::util_lib::signed_structured_data::pox4::{
+    make_pox_4_signer_key_signature, Pox4SignatureTopic,
+};
 use stacks_common::address::{AddressHashMode, C32_ADDRESS_VERSION_TESTNET_SINGLESIG};
 use stacks_common::bitvec::BitVec;
 use stacks_common::codec::StacksMessageCodec;
 use stacks_common::consts::{
-    FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH, STACKS_EPOCH_MAX,
+    CHAIN_ID_TESTNET, FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH, STACKS_EPOCH_MAX,
 };
 use stacks_common::types::chainstate::{
     BlockHeaderHash, BurnchainHeaderHash, ConsensusHash, StacksAddress, StacksBlockId,
@@ -843,10 +845,17 @@ impl MockamotoNode {
             .block_height_to_reward_cycle(self.sortdb.first_block_height, block_height)
             .unwrap();
 
-        let signature =
-            make_signer_key_signature(&pox_address, &signer_sk, reward_cycle.into(), chain_id);
-
         let stack_stx_payload = if parent_chain_length < 2 {
+            let signature = make_pox_4_signer_key_signature(
+                &pox_address,
+                &signer_sk,
+                reward_cycle.into(),
+                &Pox4SignatureTopic::StackStx,
+                CHAIN_ID_TESTNET,
+                12_u128,
+            )
+            .unwrap()
+            .to_rsv();
             TransactionPayload::ContractCall(TransactionContractCall {
                 address: StacksAddress::burn_address(false),
                 contract_name: "pox-4".try_into().unwrap(),
@@ -861,6 +870,16 @@ impl MockamotoNode {
                 ],
             })
         } else {
+            let signature = make_pox_4_signer_key_signature(
+                &pox_address,
+                &signer_sk,
+                reward_cycle.into(),
+                &Pox4SignatureTopic::StackExtend,
+                CHAIN_ID_TESTNET,
+                5_u128,
+            )
+            .unwrap()
+            .to_rsv();
             // NOTE: stack-extend doesn't currently work, because the PoX-4 lockup
             //  special functions have not been implemented.
             TransactionPayload::ContractCall(TransactionContractCall {
@@ -1032,28 +1051,3 @@ impl MockamotoNode {
         Ok(chain_length)
     }
 }
-
-fn make_signer_key_signature(
-    pox_addr: &PoxAddress,
-    signer_key: &StacksPrivateKey,
-    reward_cycle: u128,
-    chain_id: u32,
-) -> Vec<u8> {
-    let domain_tuple = make_structured_data_domain("pox-4-signer", "1.0.0", chain_id);
-
-    let data_tuple = clarity::vm::types::TupleData::from_data(vec![
-        (
-            "pox-addr".into(),
-            pox_addr.clone().as_clarity_tuple().unwrap().into(),
-        ),
-        (
-            "reward-cycle".into(),
-            clarity::vm::Value::UInt(reward_cycle),
-        ),
-    ])
-    .unwrap();
-
-    let signature = sign_structured_data(data_tuple.into(), domain_tuple, signer_key).unwrap();
-
-    signature.to_rsv()
-}
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 7792594cac..213095b625 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -43,7 +43,9 @@ use stacks::net::api::postblock_proposal::{
     BlockValidateReject, BlockValidateResponse, NakamotoBlockProposal, ValidateRejectCode,
 };
 use stacks::util_lib::boot::boot_code_id;
-use stacks::util_lib::signed_structured_data::{make_structured_data_domain, sign_structured_data};
+use stacks::util_lib::signed_structured_data::pox4::{
+    make_pox_4_signer_key_signature, Pox4SignatureTopic,
+};
 use stacks_common::address::AddressHashMode;
 use stacks_common::codec::StacksMessageCodec;
 use stacks_common::consts::{CHAIN_ID_TESTNET, STACKS_EPOCH_MAX};
@@ -369,7 +371,16 @@ pub fn boot_to_epoch_3(
     );
     let pox_addr_tuple: clarity::vm::Value = pox_addr.clone().as_clarity_tuple().unwrap().into();
     let signer_pubkey = StacksPublicKey::from_private(&signer_sk);
-    let signature = make_signer_key_signature(&pox_addr, &signer_sk, reward_cycle.into());
+    let signature = make_pox_4_signer_key_signature(
+        &pox_addr,
+        &signer_sk,
+        reward_cycle.into(),
+        &Pox4SignatureTopic::StackStx,
+        CHAIN_ID_TESTNET,
+        12_u128,
+    )
+    .unwrap()
+    .to_rsv();
 
     let stacking_tx = tests::make_contract_call(
         &stacker_sk,
@@ -400,30 +411,6 @@ pub fn boot_to_epoch_3(
     info!("Bootstrapped to Epoch-3.0 boundary, Epoch2x miner should stop");
 }
 
-fn make_signer_key_signature(
-    pox_addr: &PoxAddress,
-    signer_key: &StacksPrivateKey,
-    reward_cycle: u128,
-) -> Vec<u8> {
-    let domain_tuple = make_structured_data_domain("pox-4-signer", "1.0.0", CHAIN_ID_TESTNET);
-
-    let data_tuple = clarity::vm::types::TupleData::from_data(vec![
-        (
-            "pox-addr".into(),
-            pox_addr.clone().as_clarity_tuple().unwrap().into(),
-        ),
-        (
-            "reward-cycle".into(),
-            clarity::vm::Value::UInt(reward_cycle),
-        ),
-    ])
-    .unwrap();
-
-    let signature = sign_structured_data(data_tuple.into(), domain_tuple, signer_key).unwrap();
-
-    signature.to_rsv()
-}
-
 #[test]
 #[ignore]
 /// This test spins up a nakamoto-neon node.
@@ -946,7 +933,16 @@ fn correct_burn_outs() {
             let pk_bytes = StacksPublicKey::from_private(&new_sk).to_bytes_compressed();
 
             let reward_cycle = pox_info.current_cycle.id;
-            let signature = make_signer_key_signature(&pox_addr, &new_sk, reward_cycle.into());
+            let signature = make_pox_4_signer_key_signature(
+                &pox_addr,
+                &new_sk,
+                reward_cycle.into(),
+                &Pox4SignatureTopic::StackStx,
+                CHAIN_ID_TESTNET,
+                1_u128,
+            )
+            .unwrap()
+            .to_rsv();
 
             let stacking_tx = tests::make_contract_call(
                 &account.0,

From 9504544a0017b2b21710f36f0000b86e2d21e614 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Tue, 6 Feb 2024 11:07:55 -0800
Subject: [PATCH 0667/1166] fix: use provided `reward-cycle` in sig for
 stack-agg-commit

---
 .../src/chainstate/stacks/boot/pox-4.clar     |   2 +-
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 127 +++++++++++++++---
 2 files changed, 111 insertions(+), 18 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index a0be44d554..aa93b5b8dc 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -754,7 +754,7 @@
     ;; must be called directly by the tx-sender or by an allowed contract-caller
     (asserts! (check-caller-allowed)
               (err ERR_STACKING_PERMISSION_DENIED))
-    (try! (verify-signer-key-sig pox-addr (- reward-cycle u1) "agg-commit" u1 signer-sig signer-key))
+    (try! (verify-signer-key-sig pox-addr reward-cycle "agg-commit" u1 signer-sig signer-key))
     (let ((amount-ustx (get stacked-amount partial-stacked)))
       (try! (can-stack-stx pox-addr amount-ustx reward-cycle u1))
       ;; Add the pox addr to the reward cycle, and extract the index of the PoX address
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index f851c097d4..adad61bb39 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -1737,9 +1737,49 @@ fn stack_stx_verify_signer_sig() {
         signature,
     );
 
-    // TODO: test invalid period and topic in signature
+    // Test 4: invalid topic
+    stacker_nonce += 1;
+    let signature = make_signer_key_signature(
+        &pox_addr,
+        &signer_key,
+        reward_cycle,
+        &Pox4SignatureTopic::StackExtend, // wrong topic
+        lock_period,
+    );
+    let invalid_topic_nonce = stacker_nonce;
+    let invalid_topic_tx = make_pox_4_lockup(
+        &stacker_key,
+        stacker_nonce,
+        min_ustx,
+        pox_addr.clone(),
+        lock_period,
+        signer_public_key.clone(),
+        block_height,
+        signature,
+    );
+
+    // Test 5: invalid period
+    stacker_nonce += 1;
+    let signature = make_signer_key_signature(
+        &pox_addr,
+        &signer_key,
+        reward_cycle,
+        &topic,
+        lock_period + 1, // wrong period
+    );
+    let invalid_period_nonce = stacker_nonce;
+    let invalid_period_tx = make_pox_4_lockup(
+        &stacker_key,
+        stacker_nonce,
+        min_ustx,
+        pox_addr.clone(),
+        lock_period,
+        signer_public_key.clone(),
+        block_height,
+        signature,
+    );
 
-    // Test 4: valid signature
+    // Test 6: valid signature
     stacker_nonce += 1;
     let signature =
         make_signer_key_signature(&pox_addr, &signer_key, reward_cycle, &topic, lock_period);
@@ -1759,6 +1799,8 @@ fn stack_stx_verify_signer_sig() {
         invalid_cycle_stack,
         invalid_stacker_tx,
         invalid_key_tx,
+        invalid_topic_tx,
+        invalid_period_tx,
         valid_tx,
     ];
 
@@ -1773,6 +1815,8 @@ fn stack_stx_verify_signer_sig() {
     assert_eq!(tx_result(invalid_cycle_nonce), expected_error);
     assert_eq!(tx_result(invalid_stacker_nonce), expected_error);
     assert_eq!(tx_result(invalid_key_nonce), expected_error);
+    assert_eq!(tx_result(invalid_period_nonce), expected_error);
+    assert_eq!(tx_result(invalid_topic_nonce), expected_error);
 
     // valid tx should succeed
     tx_result(valid_nonce)
@@ -1878,8 +1922,6 @@ fn stack_extend_verify_sig() {
         signature,
     );
 
-    // TODO: test invalid period and topic in signature
-
     // Test 4: valid stack-extend
     stacker_nonce += 1;
     let signature =
@@ -1978,9 +2020,14 @@ fn stack_agg_commit_verify_sig() {
 
     // Test 1: invalid reward cycle
     delegate_nonce += 1;
-    let next_reward_cycle = reward_cycle + 1; // wrong cycle for signature
-    let signature =
-        make_signer_key_signature(&pox_addr, &signer_sk, next_reward_cycle, &topic, 1_u128);
+    let next_reward_cycle = reward_cycle + 1;
+    let signature = make_signer_key_signature(
+        &pox_addr,
+        &signer_sk,
+        reward_cycle, // wrong cycle
+        &topic,
+        1_u128,
+    );
     let invalid_cycle_nonce = delegate_nonce;
     let invalid_cycle_tx = make_pox_4_aggregation_commit_indexed(
         &delegate_key,
@@ -1994,8 +2041,13 @@ fn stack_agg_commit_verify_sig() {
     // Test 2: invalid pox addr
     delegate_nonce += 1;
     let other_pox_addr = pox_addr_from(&Secp256k1PrivateKey::new());
-    let signature =
-        make_signer_key_signature(&other_pox_addr, &signer_sk, reward_cycle, &topic, 1_u128);
+    let signature = make_signer_key_signature(
+        &other_pox_addr,
+        &signer_sk,
+        next_reward_cycle,
+        &topic,
+        1_u128,
+    );
     let invalid_pox_addr_nonce = delegate_nonce;
     let invalid_stacker_tx = make_pox_4_aggregation_commit_indexed(
         &delegate_key,
@@ -2009,7 +2061,7 @@ fn stack_agg_commit_verify_sig() {
     // Test 3: invalid signature
     delegate_nonce += 1;
     let signature =
-        make_signer_key_signature(&pox_addr, &delegate_key, reward_cycle, &topic, 1_u128);
+        make_signer_key_signature(&pox_addr, &delegate_key, next_reward_cycle, &topic, 1_u128);
     let invalid_key_nonce = delegate_nonce;
     let invalid_key_tx = make_pox_4_aggregation_commit_indexed(
         &delegate_key,
@@ -2020,11 +2072,48 @@ fn stack_agg_commit_verify_sig() {
         &signer_pk,
     );
 
-    // TODO: test invalid period and topic in signature
+    // Test 4: invalid period in signature
+    delegate_nonce += 1;
+    let signature = make_signer_key_signature(
+        &pox_addr,
+        &signer_sk,
+        next_reward_cycle,
+        &topic,
+        2_u128, // wrong period
+    );
+    let invalid_period_nonce = delegate_nonce;
+    let invalid_period_tx = make_pox_4_aggregation_commit_indexed(
+        &delegate_key,
+        delegate_nonce,
+        &pox_addr,
+        next_reward_cycle,
+        signature,
+        &signer_pk,
+    );
+
+    // Test 5: invalid topic in signature
+    delegate_nonce += 1;
+    let signature = make_signer_key_signature(
+        &pox_addr,
+        &signer_sk,
+        next_reward_cycle,
+        &Pox4SignatureTopic::StackStx, // wrong topic
+        1_u128,
+    );
+    let invalid_topic_nonce = delegate_nonce;
+    let invalid_topic_tx = make_pox_4_aggregation_commit_indexed(
+        &delegate_key,
+        delegate_nonce,
+        &pox_addr,
+        next_reward_cycle,
+        signature,
+        &signer_pk,
+    );
 
-    // Test 4: valid signature
+    // Test 6: valid signature
     delegate_nonce += 1;
-    let signature = make_signer_key_signature(&pox_addr, &signer_sk, reward_cycle, &topic, 1_u128);
+    let signature =
+        make_signer_key_signature(&pox_addr, &signer_sk, next_reward_cycle, &topic, 1_u128);
     let valid_nonce = delegate_nonce;
     let valid_tx = make_pox_4_aggregation_commit_indexed(
         &delegate_key,
@@ -2042,6 +2131,8 @@ fn stack_agg_commit_verify_sig() {
             invalid_cycle_tx,
             invalid_stacker_tx,
             invalid_key_tx,
+            invalid_period_tx,
+            invalid_topic_tx,
             valid_tx,
         ],
         &mut coinbase_nonce,
@@ -2059,6 +2150,8 @@ fn stack_agg_commit_verify_sig() {
     assert_eq!(tx_result(invalid_cycle_nonce), expected_error);
     assert_eq!(tx_result(invalid_pox_addr_nonce), expected_error);
     assert_eq!(tx_result(invalid_key_nonce), expected_error);
+    assert_eq!(tx_result(invalid_period_nonce), expected_error);
+    assert_eq!(tx_result(invalid_topic_nonce), expected_error);
     tx_result(valid_nonce)
         .expect_result_ok()
         .expect("Expected ok result from tx");
@@ -2361,7 +2454,7 @@ fn delegate_stack_stx_signer_key() {
     let signature = make_signer_key_signature(
         &pox_addr,
         &signer_sk,
-        (next_reward_cycle - 1).into(),
+        next_reward_cycle.into(),
         &Pox4SignatureTopic::AggregationCommit,
         1_u128,
     );
@@ -2548,7 +2641,7 @@ fn delegate_stack_stx_extend_signer_key() {
     let signature = make_signer_key_signature(
         &pox_addr,
         &signer_sk,
-        reward_cycle.into(),
+        next_reward_cycle.into(),
         &Pox4SignatureTopic::AggregationCommit,
         1_u128,
     );
@@ -2576,7 +2669,7 @@ fn delegate_stack_stx_extend_signer_key() {
     let extend_signature = make_signer_key_signature(
         &pox_addr,
         &signer_extend_sk,
-        (extend_cycle - 1).into(),
+        extend_cycle.into(),
         &Pox4SignatureTopic::AggregationCommit,
         1_u128,
     );
@@ -2791,7 +2884,7 @@ fn delegate_stack_increase() {
     let signature = make_signer_key_signature(
         &pox_addr,
         &signer_sk,
-        (next_reward_cycle - 1).into(),
+        next_reward_cycle.into(),
         &Pox4SignatureTopic::AggregationCommit,
         1_u128,
     );

From 5a661fd27a9d266ea21f19a495e559c364e5fb7b Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 6 Feb 2024 14:19:00 -0500
Subject: [PATCH 0668/1166] fix: rc_consensus_hash in the burn view is the
 stacks tip consensus hash, not the reward cycle consensus hash

---
 stackslib/src/chainstate/burn/db/sortdb.rs | 32 ++++++++++++----------
 1 file changed, 17 insertions(+), 15 deletions(-)

diff --git a/stackslib/src/chainstate/burn/db/sortdb.rs b/stackslib/src/chainstate/burn/db/sortdb.rs
index 4c63a28968..c6ebd99a7a 100644
--- a/stackslib/src/chainstate/burn/db/sortdb.rs
+++ b/stackslib/src/chainstate/burn/db/sortdb.rs
@@ -3883,26 +3883,13 @@ impl SortitionDB {
             .unwrap_or(&burnchain.first_block_hash)
             .clone();
 
-        let rc = burnchain
-            .block_height_to_reward_cycle(chain_tip.block_height)
-            .expect("FATAL: block height does not have a reward cycle");
-
-        let rc_height = burnchain.reward_cycle_to_block_height(rc);
-        let rc_consensus_hash = SortitionDB::get_ancestor_snapshot(
-            conn,
-            cmp::min(chain_tip.block_height, rc_height),
-            &chain_tip.sortition_id,
-        )?
-        .map(|sn| sn.consensus_hash)
-        .ok_or(db_error::NotFoundError)?;
-
         test_debug!(
             "Chain view: {},{}-{},{},{}",
             chain_tip.block_height,
             chain_tip.burn_header_hash,
             stable_block_height,
             &burn_stable_block_hash,
-            &rc_consensus_hash,
+            &chain_tip.canonical_stacks_tip_consensus_hash,
         );
         Ok(BurnchainView {
             burn_block_height: chain_tip.block_height,
@@ -3910,7 +3897,7 @@ impl SortitionDB {
             burn_stable_block_height: stable_block_height,
             burn_stable_block_hash: burn_stable_block_hash,
             last_burn_block_hashes: last_burn_block_hashes,
-            rc_consensus_hash,
+            rc_consensus_hash: chain_tip.canonical_stacks_tip_consensus_hash,
         })
     }
 }
@@ -4099,6 +4086,21 @@ impl SortitionDB {
         Ok((consensus_hash, stacks_block_hash))
     }
 
+    #[cfg(test)]
+    pub fn set_canonical_stacks_chain_tip(
+        conn: &Connection,
+        ch: &ConsensusHash,
+        bhh: &BlockHeaderHash,
+        height: u64,
+    ) -> Result<(), db_error> {
+        let tip = SortitionDB::get_canonical_burn_chain_tip(conn)?;
+        let args: &[&dyn ToSql] = &[ch, bhh, &u64_to_sql(height)?, &tip.sortition_id];
+        conn.execute("UPDATE snapshots SET canonical_stacks_tip_consensus_hash = ?1, canonical_stacks_tip_hash = ?2, canonical_stacks_tip_height = ?3
+                    WHERE sortition_id = ?4", args)
+            .map_err(db_error::SqliteError)?;
+        Ok(())
+    }
+
     /// Get the maximum arrival index for any known snapshot.
     fn get_max_arrival_index(conn: &Connection) -> Result<u64, db_error> {
         match conn

From ec96e7afd35400d2ec4ff069e475093805db3f5e Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 6 Feb 2024 14:19:00 -0500
Subject: [PATCH 0669/1166] fix: rc_consensus_hash in the burn view is the
 stacks tip consensus hash, not the reward cycle consensus hash

---
 stackslib/src/chainstate/burn/db/sortdb.rs | 32 ++++++++++++----------
 1 file changed, 17 insertions(+), 15 deletions(-)

diff --git a/stackslib/src/chainstate/burn/db/sortdb.rs b/stackslib/src/chainstate/burn/db/sortdb.rs
index 4c63a28968..c6ebd99a7a 100644
--- a/stackslib/src/chainstate/burn/db/sortdb.rs
+++ b/stackslib/src/chainstate/burn/db/sortdb.rs
@@ -3883,26 +3883,13 @@ impl SortitionDB {
             .unwrap_or(&burnchain.first_block_hash)
             .clone();
 
-        let rc = burnchain
-            .block_height_to_reward_cycle(chain_tip.block_height)
-            .expect("FATAL: block height does not have a reward cycle");
-
-        let rc_height = burnchain.reward_cycle_to_block_height(rc);
-        let rc_consensus_hash = SortitionDB::get_ancestor_snapshot(
-            conn,
-            cmp::min(chain_tip.block_height, rc_height),
-            &chain_tip.sortition_id,
-        )?
-        .map(|sn| sn.consensus_hash)
-        .ok_or(db_error::NotFoundError)?;
-
         test_debug!(
             "Chain view: {},{}-{},{},{}",
             chain_tip.block_height,
             chain_tip.burn_header_hash,
             stable_block_height,
             &burn_stable_block_hash,
-            &rc_consensus_hash,
+            &chain_tip.canonical_stacks_tip_consensus_hash,
         );
         Ok(BurnchainView {
             burn_block_height: chain_tip.block_height,
@@ -3910,7 +3897,7 @@ impl SortitionDB {
             burn_stable_block_height: stable_block_height,
             burn_stable_block_hash: burn_stable_block_hash,
             last_burn_block_hashes: last_burn_block_hashes,
-            rc_consensus_hash,
+            rc_consensus_hash: chain_tip.canonical_stacks_tip_consensus_hash,
         })
     }
 }
@@ -4099,6 +4086,21 @@ impl SortitionDB {
         Ok((consensus_hash, stacks_block_hash))
     }
 
+    #[cfg(test)]
+    pub fn set_canonical_stacks_chain_tip(
+        conn: &Connection,
+        ch: &ConsensusHash,
+        bhh: &BlockHeaderHash,
+        height: u64,
+    ) -> Result<(), db_error> {
+        let tip = SortitionDB::get_canonical_burn_chain_tip(conn)?;
+        let args: &[&dyn ToSql] = &[ch, bhh, &u64_to_sql(height)?, &tip.sortition_id];
+        conn.execute("UPDATE snapshots SET canonical_stacks_tip_consensus_hash = ?1, canonical_stacks_tip_hash = ?2, canonical_stacks_tip_height = ?3
+                    WHERE sortition_id = ?4", args)
+            .map_err(db_error::SqliteError)?;
+        Ok(())
+    }
+
     /// Get the maximum arrival index for any known snapshot.
     fn get_max_arrival_index(conn: &Connection) -> Result<u64, db_error> {
         match conn

From bc716db03038581abba7099c0b9c9bcdfff147d7 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 6 Feb 2024 14:19:58 -0500
Subject: [PATCH 0670/1166] fix: a bad slot signature should be a distinct
 error

---
 stackslib/src/net/api/poststackerdbchunk.rs | 24 ++++++++++++++++-----
 1 file changed, 19 insertions(+), 5 deletions(-)

diff --git a/stackslib/src/net/api/poststackerdbchunk.rs b/stackslib/src/net/api/poststackerdbchunk.rs
index 190ba1f710..371a75b5a2 100644
--- a/stackslib/src/net/api/poststackerdbchunk.rs
+++ b/stackslib/src/net/api/poststackerdbchunk.rs
@@ -116,6 +116,7 @@ impl HttpRequest for RPCPostStackerDBChunkRequestHandler {
 pub enum StackerDBErrorCodes {
     DataAlreadyExists,
     NoSuchSlot,
+    BadSigner,
 }
 
 impl StackerDBErrorCodes {
@@ -123,6 +124,7 @@ impl StackerDBErrorCodes {
         match self {
             Self::DataAlreadyExists => 0,
             Self::NoSuchSlot => 1,
+            Self::BadSigner => 2,
         }
     }
 
@@ -130,6 +132,7 @@ impl StackerDBErrorCodes {
         match self {
             Self::DataAlreadyExists => "Data for this slot and version already exist",
             Self::NoSuchSlot => "No such StackerDB slot",
+            Self::BadSigner => "Signature does not match slot signer",
         }
     }
 
@@ -183,11 +186,18 @@ impl RPCRequestHandler for RPCPostStackerDBChunkRequestHandler {
                         &HttpNotFound::new("StackerDB not found".to_string()),
                     ));
                 }
-                if let Err(_e) = tx.try_replace_chunk(
+                if let Err(e) = tx.try_replace_chunk(
                     &contract_identifier,
                     &stackerdb_chunk.get_slot_metadata(),
                     &stackerdb_chunk.data,
                 ) {
+                    test_debug!(
+                        "Failed to replace chunk {}.{} in {}: {:?}",
+                        stackerdb_chunk.slot_id,
+                        stackerdb_chunk.slot_version,
+                        &contract_identifier,
+                        &e
+                    );
                     let slot_metadata_opt =
                         match tx.get_slot_metadata(&contract_identifier, stackerdb_chunk.slot_id) {
                             Ok(slot_opt) => slot_opt,
@@ -209,11 +219,15 @@ impl RPCRequestHandler for RPCPostStackerDBChunkRequestHandler {
 
                     let (reason, slot_metadata_opt) = if let Some(slot_metadata) = slot_metadata_opt
                     {
+                        let code = if let NetError::BadSlotSigner(..) = e {
+                            StackerDBErrorCodes::BadSigner
+                        } else {
+                            StackerDBErrorCodes::DataAlreadyExists
+                        };
+
                         (
-                            serde_json::to_string(
-                                &StackerDBErrorCodes::DataAlreadyExists.into_json(),
-                            )
-                            .unwrap_or("(unable to encode JSON)".to_string()),
+                            serde_json::to_string(&code.into_json())
+                                .unwrap_or("(unable to encode JSON)".to_string()),
                             Some(slot_metadata),
                         )
                     } else {

From 99c209c9f18f61521082d38d239a323c2efb262e Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 6 Feb 2024 14:22:46 -0500
Subject: [PATCH 0671/1166] fix: NACK getchunks and getchunksinv requests with
 NackErrorCodes::StaleView if the rc_consensus_hash doesn't match

---
 stackslib/src/net/chat.rs | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/stackslib/src/net/chat.rs b/stackslib/src/net/chat.rs
index 223b7e1bbd..7b1d4cc7f9 100644
--- a/stackslib/src/net/chat.rs
+++ b/stackslib/src/net/chat.rs
@@ -1339,8 +1339,8 @@ impl ConversationP2P {
                 self.update_from_stacker_db_handshake_data(stackerdb_accept);
             } else {
                 // remote peer's burnchain view has diverged, so assume no longer replicating (we
-                // can't talk to it anyway).  This can happen once per reward cycle for a few
-                // minutes as nodes begin the next reward cycle, but it's harmless -- at worst, it
+                // can't talk to it anyway).  This can happen once per burnchain block for a few
+                // seconds as nodes begin processing the next Stacks blocks, but it's harmless -- at worst, it
                 // just means that no stacker DB replication happens between this peer and
                 // localhost during this time.
                 self.clear_stacker_db_handshake_data();
@@ -1779,13 +1779,16 @@ impl ConversationP2P {
         let local_peer = network.get_local_peer();
         let burnchain_view = network.get_chain_view();
 
+        // remote peer's Stacks chain tip is different from ours, meaning it might have a different
+        // stackerdb configuration view (and we won't be able to authenticate their chunks, and
+        // vice versa)
         if burnchain_view.rc_consensus_hash != getchunkinv.rc_consensus_hash {
             debug!(
                 "{:?}: NACK StackerDBGetChunkInv; {} != {}",
                 local_peer, &burnchain_view.rc_consensus_hash, &getchunkinv.rc_consensus_hash
             );
             return Ok(StacksMessageType::Nack(NackData::new(
-                NackErrorCodes::InvalidPoxFork,
+                NackErrorCodes::StaleView,
             )));
         }
 
@@ -1827,7 +1830,7 @@ impl ConversationP2P {
                 local_peer, &burnchain_view.rc_consensus_hash, &getchunk.rc_consensus_hash
             );
             return Ok(StacksMessageType::Nack(NackData::new(
-                NackErrorCodes::InvalidPoxFork,
+                NackErrorCodes::StaleView,
             )));
         }
 

From b259ba3e85b3ba579ec994f4d03d6210b73d3ef4 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 6 Feb 2024 14:23:15 -0500
Subject: [PATCH 0672/1166] fix: fix comments on rc_consensus_hash

---
 stackslib/src/net/mod.rs | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/stackslib/src/net/mod.rs b/stackslib/src/net/mod.rs
index 2d806e2866..a5d516a3cf 100644
--- a/stackslib/src/net/mod.rs
+++ b/stackslib/src/net/mod.rs
@@ -975,6 +975,7 @@ pub mod NackErrorCodes {
     pub const InvalidMessage: u32 = 5;
     pub const NoSuchDB: u32 = 6;
     pub const StaleVersion: u32 = 7;
+    pub const StaleView: u32 = 8;
 }
 
 #[derive(Debug, Clone, PartialEq)]
@@ -997,7 +998,9 @@ pub struct NatPunchData {
 /// Inform the remote peer of (a page of) the list of stacker DB contracts this node supports
 #[derive(Debug, Clone, PartialEq)]
 pub struct StackerDBHandshakeData {
-    /// current reward cycle ID
+    /// current reward cycle consensus hash (i.e. the consensus hash of the Stacks tip in the
+    /// current reward cycle, which commits to both the Stacks block tip and the underlying PoX
+    /// history).
     pub rc_consensus_hash: ConsensusHash,
     /// list of smart contracts that we index.
     /// there can be as many as 256 entries.
@@ -1009,7 +1012,7 @@ pub struct StackerDBHandshakeData {
 pub struct StackerDBGetChunkInvData {
     /// smart contract being used to determine chunk quantity and order
     pub contract_id: QualifiedContractIdentifier,
-    /// consensus hash of the sortition that started this reward cycle
+    /// consensus hash of the Stacks chain tip in this reward cycle
     pub rc_consensus_hash: ConsensusHash,
 }
 
@@ -1028,7 +1031,7 @@ pub struct StackerDBChunkInvData {
 pub struct StackerDBGetChunkData {
     /// smart contract being used to determine slot quantity and order
     pub contract_id: QualifiedContractIdentifier,
-    /// consensus hash of the sortition that started this reward cycle
+    /// consensus hash of the Stacks chain tip in this reward cycle
     pub rc_consensus_hash: ConsensusHash,
     /// slot ID
     pub slot_id: u32,
@@ -1041,7 +1044,7 @@ pub struct StackerDBGetChunkData {
 pub struct StackerDBPushChunkData {
     /// smart contract being used to determine chunk quantity and order
     pub contract_id: QualifiedContractIdentifier,
-    /// consensus hash of the sortition that started this reward cycle
+    /// consensus hash of the Stacks chain tip in this reward cycle
     pub rc_consensus_hash: ConsensusHash,
     /// the pushed chunk
     pub chunk_data: StackerDBChunkData,

From 8e049789f55740e389107f705ca6bdbe1aac6987 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 6 Feb 2024 14:23:29 -0500
Subject: [PATCH 0673/1166] fix: force an initial burnchain view load for the
 p2p network if it hasn't completed a full state-machine pass yet

---
 stackslib/src/net/p2p.rs | 19 +++++++++++++++++--
 1 file changed, 17 insertions(+), 2 deletions(-)

diff --git a/stackslib/src/net/p2p.rs b/stackslib/src/net/p2p.rs
index 3e182ddf3c..074f3ee4ce 100644
--- a/stackslib/src/net/p2p.rs
+++ b/stackslib/src/net/p2p.rs
@@ -5224,7 +5224,12 @@ impl PeerNetwork {
         // update burnchain snapshot if we need to (careful -- it's expensive)
         let sn = SortitionDB::get_canonical_burn_chain_tip(&sortdb.conn())?;
         let mut ret: HashMap<NeighborKey, Vec<StacksMessage>> = HashMap::new();
-        if sn.block_height != self.chain_view.burn_block_height {
+        let mut need_stackerdb_refresh = sn.canonical_stacks_tip_consensus_hash
+            != self.burnchain_tip.canonical_stacks_tip_consensus_hash;
+
+        if sn.block_height != self.chain_view.burn_block_height
+            || self.num_state_machine_passes == 0
+        {
             debug!(
                 "{:?}: load chain view for burn block {}",
                 &self.local_peer, sn.block_height
@@ -5303,7 +5308,17 @@ impl PeerNetwork {
                 .get_last_selected_anchor_block_txid()?
                 .unwrap_or(Txid([0x00; 32]));
 
-            // refresh stackerdb configs
+            test_debug!(
+                "{:?}: chain view is {:?}",
+                &self.get_local_peer(),
+                &self.chain_view
+            );
+            need_stackerdb_refresh = true;
+        }
+
+        if need_stackerdb_refresh {
+            // refresh stackerdb configs -- canonical stacks tip has changed
+            debug!("{:?}: Refresh all stackerdbs", &self.get_local_peer());
             let mut new_stackerdb_configs = HashMap::new();
             let stacker_db_configs = mem::replace(&mut self.stacker_db_configs, HashMap::new());
             for (stackerdb_contract_id, stackerdb_config) in stacker_db_configs.into_iter() {

From ec918217bfe18806f627ea292a48509d039e31e8 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 6 Feb 2024 14:23:53 -0500
Subject: [PATCH 0674/1166] feat: test neighbors with stale views

---
 stackslib/src/net/stackerdb/mod.rs | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/stackslib/src/net/stackerdb/mod.rs b/stackslib/src/net/stackerdb/mod.rs
index b37fde4e10..bdba2aca94 100644
--- a/stackslib/src/net/stackerdb/mod.rs
+++ b/stackslib/src/net/stackerdb/mod.rs
@@ -151,6 +151,8 @@ pub struct StackerDBSyncResult {
     dead: HashSet<NeighborKey>,
     /// neighbors that misbehaved while syncing
     broken: HashSet<NeighborKey>,
+    /// neighbors that have stale views, but are otherwise online
+    pub(crate) stale: HashSet<NeighborAddress>,
 }
 
 /// Settings for the Stacker DB
@@ -262,6 +264,8 @@ pub struct StackerDBSync<NC: NeighborComms> {
     /// whether or not we should immediately re-fetch chunks because we learned about new chunks
     /// from our peers when they replied to our chunk-pushes with new inventory state
     need_resync: bool,
+    /// Track stale neighbors
+    pub(crate) stale_neighbors: HashSet<NeighborAddress>,
 }
 
 impl StackerDBSyncResult {
@@ -274,6 +278,7 @@ impl StackerDBSyncResult {
             chunks_to_store: vec![chunk.chunk_data],
             dead: HashSet::new(),
             broken: HashSet::new(),
+            stale: HashSet::new(),
         }
     }
 }

From adba5786dc1da70d9f1a815ddd39db7176039a80 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 6 Feb 2024 14:24:12 -0500
Subject: [PATCH 0675/1166] feat: track neighbors with stale views

---
 stackslib/src/net/stackerdb/sync.rs | 25 ++++++++++++++++++++++---
 1 file changed, 22 insertions(+), 3 deletions(-)

diff --git a/stackslib/src/net/stackerdb/sync.rs b/stackslib/src/net/stackerdb/sync.rs
index d01d4ff03f..0d10fc3217 100644
--- a/stackslib/src/net/stackerdb/sync.rs
+++ b/stackslib/src/net/stackerdb/sync.rs
@@ -33,9 +33,9 @@ use crate::net::stackerdb::{
     StackerDBConfig, StackerDBSync, StackerDBSyncResult, StackerDBSyncState, StackerDBs,
 };
 use crate::net::{
-    Error as net_error, NackData, Neighbor, NeighborAddress, NeighborKey, StackerDBChunkData,
-    StackerDBChunkInvData, StackerDBGetChunkData, StackerDBGetChunkInvData, StackerDBPushChunkData,
-    StacksMessageType,
+    Error as net_error, NackData, NackErrorCodes, Neighbor, NeighborAddress, NeighborKey,
+    StackerDBChunkData, StackerDBChunkInvData, StackerDBGetChunkData, StackerDBGetChunkInvData,
+    StackerDBPushChunkData, StacksMessageType,
 };
 
 const MAX_CHUNKS_IN_FLIGHT: usize = 6;
@@ -72,6 +72,7 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
             total_pushed: 0,
             last_run_ts: 0,
             need_resync: false,
+            stale_neighbors: HashSet::new(),
         };
         dbsync.reset(None, config);
         dbsync
@@ -178,6 +179,7 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
             chunks_to_store: chunks,
             dead: self.comms.take_dead_neighbors(),
             broken: self.comms.take_broken_neighbors(),
+            stale: std::mem::replace(&mut self.stale_neighbors, HashSet::new()),
         };
 
         // keep all connected replicas, and replenish from config hints and the DB as needed
@@ -677,6 +679,7 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
                             &network.get_chain_view().rc_consensus_hash,
                             &db_data.rc_consensus_hash
                         );
+                        self.connected_replicas.remove(&naddr);
                         continue;
                     }
                     db_data
@@ -688,6 +691,10 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
                         &naddr,
                         data.error_code
                     );
+                    self.connected_replicas.remove(&naddr);
+                    if data.error_code == NackErrorCodes::StaleView {
+                        self.stale_neighbors.insert(naddr);
+                    }
                     continue;
                 }
                 x => {
@@ -800,10 +807,15 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
                         &naddr,
                         data.error_code
                     );
+                    self.connected_replicas.remove(&naddr);
+                    if data.error_code == NackErrorCodes::StaleView {
+                        self.stale_neighbors.insert(naddr);
+                    }
                     continue;
                 }
                 x => {
                     info!("Received unexpected message {:?}", &x);
+                    self.connected_replicas.remove(&naddr);
                     continue;
                 }
             };
@@ -929,10 +941,14 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
                         data.error_code
                     );
                     self.connected_replicas.remove(&naddr);
+                    if data.error_code == NackErrorCodes::StaleView {
+                        self.stale_neighbors.insert(naddr);
+                    }
                     continue;
                 }
                 x => {
                     info!("Received unexpected message {:?}", &x);
+                    self.connected_replicas.remove(&naddr);
                     continue;
                 }
             };
@@ -1072,6 +1088,9 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
                         data.error_code
                     );
                     self.connected_replicas.remove(&naddr);
+                    if data.error_code == NackErrorCodes::StaleView {
+                        self.stale_neighbors.insert(naddr);
+                    }
                     continue;
                 }
                 x => {

From 4eb625a8ffa1ea1092b8b38de01b65eea2f75110 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 6 Feb 2024 14:24:25 -0500
Subject: [PATCH 0676/1166] chore: test that a peer with a stale view will not
 be acknowledged, but it will once its view converges

---
 stackslib/src/net/stackerdb/tests/sync.rs | 196 +++++++++++++++++++++-
 1 file changed, 195 insertions(+), 1 deletion(-)

diff --git a/stackslib/src/net/stackerdb/tests/sync.rs b/stackslib/src/net/stackerdb/tests/sync.rs
index 7e1c5f15da..544208bf0f 100644
--- a/stackslib/src/net/stackerdb/tests/sync.rs
+++ b/stackslib/src/net/stackerdb/tests/sync.rs
@@ -26,11 +26,12 @@ use stacks_common::address::{
     AddressHashMode, C32_ADDRESS_VERSION_MAINNET_MULTISIG, C32_ADDRESS_VERSION_MAINNET_SINGLESIG,
 };
 use stacks_common::types::chainstate::{
-    ConsensusHash, StacksAddress, StacksPrivateKey, StacksPublicKey,
+    BlockHeaderHash, ConsensusHash, StacksAddress, StacksPrivateKey, StacksPublicKey,
 };
 use stacks_common::util::hash::{Hash160, Sha512Trunc256Sum};
 use stacks_common::util::secp256k1::{MessageSignature, Secp256k1PrivateKey};
 
+use crate::chainstate::burn::db::sortdb::SortitionDB;
 use crate::net::relay::Relayer;
 use crate::net::stackerdb::db::SlotValidation;
 use crate::net::stackerdb::{StackerDBConfig, StackerDBs};
@@ -280,6 +281,199 @@ fn test_stackerdb_replica_2_neighbors_1_chunk() {
     })
 }
 
+#[test]
+fn test_stackerdb_replica_2_neighbors_1_chunk_stale_view() {
+    with_timeout(600, || {
+        std::env::set_var("STACKS_TEST_DISABLE_EDGE_TRIGGER_TEST", "1");
+        let mut peer_1_config = TestPeerConfig::from_port(BASE_PORT);
+        let mut peer_2_config = TestPeerConfig::from_port(BASE_PORT + 2);
+
+        peer_1_config.allowed = -1;
+        peer_2_config.allowed = -1;
+
+        // short-lived walks...
+        peer_1_config.connection_opts.walk_max_duration = 10;
+        peer_2_config.connection_opts.walk_max_duration = 10;
+
+        // peer 1 crawls peer 2, and peer 2 crawls peer 1
+        peer_1_config.add_neighbor(&peer_2_config.to_neighbor());
+        peer_2_config.add_neighbor(&peer_1_config.to_neighbor());
+
+        // set up stacker DBs for both peers
+        let idx_1 = add_stackerdb(&mut peer_1_config, Some(StackerDBConfig::template()));
+        let idx_2 = add_stackerdb(&mut peer_2_config, Some(StackerDBConfig::template()));
+
+        let mut peer_1 = TestPeer::new(peer_1_config);
+        let mut peer_2 = TestPeer::new(peer_2_config);
+
+        // peer 1 gets the DB
+        setup_stackerdb(&mut peer_1, idx_1, true, 1);
+        setup_stackerdb(&mut peer_2, idx_2, false, 1);
+
+        // verify that peer 1 got the data
+        let peer_1_db_chunks = load_stackerdb(&peer_1, idx_1);
+        assert_eq!(peer_1_db_chunks.len(), 1);
+        assert_eq!(peer_1_db_chunks[0].0.slot_id, 0);
+        assert_eq!(peer_1_db_chunks[0].0.slot_version, 1);
+        assert!(peer_1_db_chunks[0].1.len() > 0);
+
+        // verify that peer 2 did NOT get the data
+        let peer_2_db_chunks = load_stackerdb(&peer_2, idx_2);
+        assert_eq!(peer_2_db_chunks.len(), 1);
+        assert_eq!(peer_2_db_chunks[0].0.slot_id, 0);
+        assert_eq!(peer_2_db_chunks[0].0.slot_version, 0);
+        assert!(peer_2_db_chunks[0].1.len() == 0);
+
+        let peer_1_db_configs = peer_1.config.get_stacker_db_configs();
+        let peer_2_db_configs = peer_2.config.get_stacker_db_configs();
+
+        // force peer 2 to have a stale view
+        let (old_tip_ch, old_tip_bh) = {
+            let sortdb = peer_1.sortdb();
+            let (tip_bh, tip_ch) =
+                SortitionDB::get_canonical_stacks_chain_tip_hash(sortdb.conn()).unwrap();
+            SortitionDB::set_canonical_stacks_chain_tip(
+                sortdb.conn(),
+                &ConsensusHash([0x22; 20]),
+                &BlockHeaderHash([0x33; 32]),
+                45,
+            )
+            .unwrap();
+            (tip_bh, tip_ch)
+        };
+
+        let mut i = 0;
+        let mut peer_1_stale = false;
+        let mut peer_2_stale = false;
+        loop {
+            // run peer network state-machines
+            peer_1.network.stacker_db_configs = peer_1_db_configs.clone();
+            peer_2.network.stacker_db_configs = peer_2_db_configs.clone();
+
+            let res_1 = peer_1.step_with_ibd(false);
+            let res_2 = peer_2.step_with_ibd(false);
+
+            if let Ok(mut res) = res_1 {
+                for sync_res in res.stacker_db_sync_results.iter() {
+                    assert_eq!(sync_res.chunks_to_store.len(), 0);
+                    if sync_res.stale.len() > 0 {
+                        peer_1_stale = true;
+                    }
+                }
+                Relayer::process_stacker_db_chunks(
+                    &mut peer_1.network.stackerdbs,
+                    &peer_1_db_configs,
+                    res.stacker_db_sync_results,
+                    None,
+                )
+                .unwrap();
+                Relayer::process_pushed_stacker_db_chunks(
+                    &mut peer_1.network.stackerdbs,
+                    &peer_1_db_configs,
+                    &mut res.unhandled_messages,
+                    None,
+                )
+                .unwrap();
+            }
+
+            if let Ok(mut res) = res_2 {
+                for sync_res in res.stacker_db_sync_results.iter() {
+                    assert_eq!(sync_res.chunks_to_store.len(), 0);
+                    if sync_res.stale.len() > 0 {
+                        peer_2_stale = true;
+                    }
+                }
+                Relayer::process_stacker_db_chunks(
+                    &mut peer_2.network.stackerdbs,
+                    &peer_2_db_configs,
+                    res.stacker_db_sync_results,
+                    None,
+                )
+                .unwrap();
+                Relayer::process_pushed_stacker_db_chunks(
+                    &mut peer_2.network.stackerdbs,
+                    &peer_2_db_configs,
+                    &mut res.unhandled_messages,
+                    None,
+                )
+                .unwrap();
+            }
+
+            if peer_1_stale && peer_2_stale {
+                break;
+            }
+
+            i += 1;
+        }
+
+        debug!("Completed stacker DB stale detection in {} step(s)", i);
+
+        // fix and re-run
+        {
+            let sortdb = peer_1.sortdb();
+            SortitionDB::set_canonical_stacks_chain_tip(sortdb.conn(), &old_tip_ch, &old_tip_bh, 0)
+                .unwrap();
+
+            // force chain view refresh
+            peer_1.network.num_state_machine_passes = 0;
+        }
+
+        let mut i = 0;
+        loop {
+            // run peer network state-machines
+            peer_1.network.stacker_db_configs = peer_1_db_configs.clone();
+            peer_2.network.stacker_db_configs = peer_2_db_configs.clone();
+
+            let res_1 = peer_1.step_with_ibd(false);
+            let res_2 = peer_2.step_with_ibd(false);
+
+            if let Ok(mut res) = res_1 {
+                Relayer::process_stacker_db_chunks(
+                    &mut peer_1.network.stackerdbs,
+                    &peer_1_db_configs,
+                    res.stacker_db_sync_results,
+                    None,
+                )
+                .unwrap();
+                Relayer::process_pushed_stacker_db_chunks(
+                    &mut peer_1.network.stackerdbs,
+                    &peer_1_db_configs,
+                    &mut res.unhandled_messages,
+                    None,
+                )
+                .unwrap();
+            }
+
+            if let Ok(mut res) = res_2 {
+                Relayer::process_stacker_db_chunks(
+                    &mut peer_2.network.stackerdbs,
+                    &peer_2_db_configs,
+                    res.stacker_db_sync_results,
+                    None,
+                )
+                .unwrap();
+                Relayer::process_pushed_stacker_db_chunks(
+                    &mut peer_2.network.stackerdbs,
+                    &peer_2_db_configs,
+                    &mut res.unhandled_messages,
+                    None,
+                )
+                .unwrap();
+            }
+
+            let db1 = load_stackerdb(&peer_1, idx_1);
+            let db2 = load_stackerdb(&peer_2, idx_2);
+
+            if db1 == db2 {
+                break;
+            }
+            i += 1;
+        }
+
+        debug!("Completed stacker DB sync in {} step(s)", i);
+    })
+}
+
 #[test]
 #[ignore]
 fn test_stackerdb_replica_2_neighbors_10_chunks() {

From 98d9129418c73f98d7b31984f5f5f3f49876154a Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Thu, 1 Feb 2024 13:17:37 -0600
Subject: [PATCH 0677/1166] feat: trigger stackerdb refresh when .signers is
 written

---
 stackslib/src/chainstate/coordinator/comm.rs  | 18 ++++++++++++++-
 stackslib/src/chainstate/coordinator/mod.rs   | 11 ++++++++++
 .../chainstate/nakamoto/coordinator/mod.rs    |  6 +++++
 stackslib/src/chainstate/nakamoto/mod.rs      |  2 ++
 stackslib/src/chainstate/stacks/db/blocks.rs  |  2 ++
 stackslib/src/chainstate/stacks/db/mod.rs     |  2 ++
 stackslib/src/net/p2p.rs                      | 22 ++++++++++++++-----
 testnet/stacks-node/src/nakamoto_node/peer.rs | 17 ++++++++++++++
 8 files changed, 73 insertions(+), 7 deletions(-)

diff --git a/stackslib/src/chainstate/coordinator/comm.rs b/stackslib/src/chainstate/coordinator/comm.rs
index d89afef1e3..374ab72996 100644
--- a/stackslib/src/chainstate/coordinator/comm.rs
+++ b/stackslib/src/chainstate/coordinator/comm.rs
@@ -14,7 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
 use std::sync::{Arc, Condvar, LockResult, Mutex, MutexGuard, RwLock, TryLockResult};
 use std::time::{Duration, Instant};
 use std::{process, thread};
@@ -58,6 +58,8 @@ pub struct CoordinatorChannels {
     stacks_blocks_processed: Arc<AtomicU64>,
     /// how many sortitions have been processed by this Coordinator thread since startup?
     sortitions_processed: Arc<AtomicU64>,
+    /// Does the StackerDB need to be refreshed?
+    refresh_stacker_db: Arc<AtomicBool>,
 }
 
 /// Notification struct for communicating to
@@ -81,6 +83,8 @@ pub struct CoordinatorReceivers {
     signal_wakeup: Arc<Condvar>,
     pub stacks_blocks_processed: Arc<AtomicU64>,
     pub sortitions_processed: Arc<AtomicU64>,
+    /// Does the StackerDB need to be refreshed?
+    pub refresh_stacker_db: Arc<AtomicBool>,
 }
 
 /// Static struct used to hold all the static methods
@@ -154,6 +158,15 @@ impl CoordinatorChannels {
         false
     }
 
+    pub fn need_stackerdb_update(&self) -> bool {
+        self.refresh_stacker_db.load(Ordering::SeqCst)
+    }
+
+    pub fn set_stackerdb_update(&self, needs_update: bool) {
+        self.refresh_stacker_db
+            .store(needs_update, Ordering::SeqCst)
+    }
+
     pub fn is_stopped(&self) -> bool {
         let bools = self.signal_bools.lock().unwrap();
         bools.stop.clone()
@@ -222,6 +235,7 @@ impl CoordinatorCommunication {
 
         let stacks_blocks_processed = Arc::new(AtomicU64::new(0));
         let sortitions_processed = Arc::new(AtomicU64::new(0));
+        let refresh_stacker_db = Arc::new(AtomicBool::new(false));
 
         let senders = CoordinatorChannels {
             signal_bools: signal_bools.clone(),
@@ -229,6 +243,7 @@ impl CoordinatorCommunication {
             stacks_blocks_processed: stacks_blocks_processed.clone(),
 
             sortitions_processed: sortitions_processed.clone(),
+            refresh_stacker_db: refresh_stacker_db.clone(),
         };
 
         let rcvrs = CoordinatorReceivers {
@@ -236,6 +251,7 @@ impl CoordinatorCommunication {
             signal_wakeup: signal_wakeup,
             stacks_blocks_processed,
             sortitions_processed,
+            refresh_stacker_db,
         };
 
         (rcvrs, senders)
diff --git a/stackslib/src/chainstate/coordinator/mod.rs b/stackslib/src/chainstate/coordinator/mod.rs
index beb29b5661..0bd51741b7 100644
--- a/stackslib/src/chainstate/coordinator/mod.rs
+++ b/stackslib/src/chainstate/coordinator/mod.rs
@@ -17,6 +17,7 @@
 use std::collections::{BTreeMap, HashMap, HashSet, VecDeque};
 use std::convert::{TryFrom, TryInto};
 use std::path::PathBuf;
+use std::sync::atomic::AtomicBool;
 use std::sync::mpsc::SyncSender;
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
@@ -240,6 +241,9 @@ pub struct ChainsCoordinator<
     pub atlas_config: AtlasConfig,
     config: ChainsCoordinatorConfig,
     burnchain_indexer: B,
+    /// Used to tell the P2P thread that the stackerdb
+    ///  needs to be refreshed.
+    pub refresh_stacker_db: Arc<AtomicBool>,
 }
 
 #[derive(Debug)]
@@ -546,6 +550,7 @@ impl<
             atlas_db: Some(atlas_db),
             config,
             burnchain_indexer,
+            refresh_stacker_db: comms.refresh_stacker_db.clone(),
         };
 
         let mut nakamoto_available = false;
@@ -3214,6 +3219,12 @@ impl<
                 )?;
 
                 if in_sortition_set {
+                    // if .signers was updated, notify the p2p thread
+                    if block_receipt.signers_updated {
+                        self.refresh_stacker_db
+                            .store(true, std::sync::atomic::Ordering::SeqCst);
+                    }
+
                     let new_canonical_block_snapshot = SortitionDB::get_block_snapshot(
                         self.sortition_db.conn(),
                         &canonical_sortition_tip,
diff --git a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
index 15973cd291..d4c1e3e2b6 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
@@ -578,6 +578,12 @@ impl<
                 break;
             };
 
+            if block_receipt.signers_updated {
+                // notify p2p thread via globals
+                self.refresh_stacker_db
+                    .store(true, std::sync::atomic::Ordering::SeqCst);
+            }
+
             let block_hash = block_receipt.header.anchored_header.block_hash();
             let (
                 canonical_stacks_block_id,
diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index 638bbb48d0..629bd16a72 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -3106,6 +3106,7 @@ impl NakamotoChainState {
         // store the reward set calculated during this block if it happened
         // NOTE: miner and proposal evaluation should not invoke this because
         //  it depends on knowing the StacksBlockId.
+        let signers_updated = signer_set_calc.is_some();
         if let Some(signer_calculation) = signer_set_calc {
             Self::write_reward_set(chainstate_tx, &new_block_id, &signer_calculation.reward_set)?
         }
@@ -3146,6 +3147,7 @@ impl NakamotoChainState {
             parent_burn_block_timestamp,
             evaluated_epoch,
             epoch_transition: applied_epoch_transition,
+            signers_updated,
         };
 
         NakamotoChainState::set_block_processed(&chainstate_tx, &new_block_id)?;
diff --git a/stackslib/src/chainstate/stacks/db/blocks.rs b/stackslib/src/chainstate/stacks/db/blocks.rs
index fc3920902d..bbe4ef0be7 100644
--- a/stackslib/src/chainstate/stacks/db/blocks.rs
+++ b/stackslib/src/chainstate/stacks/db/blocks.rs
@@ -5686,6 +5686,7 @@ impl StacksChainState {
         // store the reward set calculated during this block if it happened
         // NOTE: miner and proposal evaluation should not invoke this because
         //  it depends on knowing the StacksBlockId.
+        let signers_updated = signer_set_calc.is_some();
         if let Some(signer_calculation) = signer_set_calc {
             let new_block_id = new_tip.index_block_hash();
             NakamotoChainState::write_reward_set(
@@ -5712,6 +5713,7 @@ impl StacksChainState {
             parent_burn_block_timestamp,
             evaluated_epoch,
             epoch_transition: applied_epoch_transition,
+            signers_updated,
         };
 
         Ok((epoch_receipt, clarity_commit))
diff --git a/stackslib/src/chainstate/stacks/db/mod.rs b/stackslib/src/chainstate/stacks/db/mod.rs
index 25d80950f1..1311b29b63 100644
--- a/stackslib/src/chainstate/stacks/db/mod.rs
+++ b/stackslib/src/chainstate/stacks/db/mod.rs
@@ -220,6 +220,8 @@ pub struct StacksEpochReceipt {
     /// in.
     pub evaluated_epoch: StacksEpochId,
     pub epoch_transition: bool,
+    /// Was .signers updated during this block?
+    pub signers_updated: bool,
 }
 
 /// Headers we serve over the network
diff --git a/stackslib/src/net/p2p.rs b/stackslib/src/net/p2p.rs
index fe2102ffe2..f8c51b939a 100644
--- a/stackslib/src/net/p2p.rs
+++ b/stackslib/src/net/p2p.rs
@@ -5212,6 +5212,21 @@ impl PeerNetwork {
         &self.stacker_db_configs
     }
 
+    /// Reload StackerDB configs from chainstate
+    pub fn refresh_stacker_db_configs(
+        &mut self,
+        sortdb: &SortitionDB,
+        chainstate: &mut StacksChainState,
+    ) -> Result<(), net_error> {
+        let stacker_db_configs = mem::replace(&mut self.stacker_db_configs, HashMap::new());
+        self.stacker_db_configs = self.stackerdbs.create_or_reconfigure_stackerdbs(
+            chainstate,
+            sortdb,
+            stacker_db_configs,
+        )?;
+        Ok(())
+    }
+
     /// Refresh view of burnchain, if needed.
     /// If the burnchain view changes, then take the following additional steps:
     /// * hint to the inventory sync state-machine to restart, since we potentially have a new
@@ -5309,12 +5324,7 @@ impl PeerNetwork {
                 .unwrap_or(Txid([0x00; 32]));
 
             // refresh stackerdb configs
-            let stacker_db_configs = mem::replace(&mut self.stacker_db_configs, HashMap::new());
-            self.stacker_db_configs = self.stackerdbs.create_or_reconfigure_stackerdbs(
-                chainstate,
-                sortdb,
-                stacker_db_configs,
-            )?;
+            self.refresh_stacker_db_configs(sortdb, chainstate)?;
         }
 
         if sn.canonical_stacks_tip_hash != self.burnchain_tip.canonical_stacks_tip_hash
diff --git a/testnet/stacks-node/src/nakamoto_node/peer.rs b/testnet/stacks-node/src/nakamoto_node/peer.rs
index 376c437723..1e0f212ab7 100644
--- a/testnet/stacks-node/src/nakamoto_node/peer.rs
+++ b/testnet/stacks-node/src/nakamoto_node/peer.rs
@@ -202,6 +202,21 @@ impl PeerThread {
         }
     }
 
+    fn check_stackerdb_reload(&mut self) {
+        if !self.globals.coord_comms.need_stackerdb_update() {
+            return;
+        }
+
+        if let Err(e) = self
+            .net
+            .refresh_stacker_db_configs(&self.sortdb, &mut self.chainstate)
+        {
+            warn!("Failed to update StackerDB configs: {e}");
+        }
+
+        self.globals.coord_comms.set_stackerdb_update(false);
+    }
+
     /// Run one pass of the p2p/http state machine
     /// Return true if we should continue running passes; false if not
     pub(crate) fn run_one_pass<B: BurnchainHeaderReader>(
@@ -228,6 +243,8 @@ impl PeerThread {
             self.poll_timeout
         };
 
+        self.check_stackerdb_reload();
+
         // do one pass
         let p2p_res = {
             // NOTE: handler_args must be created such that it outlives the inner net.run() call and

From 645a9310fedf1c1efecb9c40c35d2f59709a22bc Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Thu, 1 Feb 2024 13:42:18 -0600
Subject: [PATCH 0678/1166] fix test build, rename check fn to refresh

---
 stackslib/src/chainstate/coordinator/mod.rs   | 1 +
 stackslib/src/cost_estimates/tests/common.rs  | 1 +
 testnet/stacks-node/src/nakamoto_node/peer.rs | 7 +++++--
 3 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/stackslib/src/chainstate/coordinator/mod.rs b/stackslib/src/chainstate/coordinator/mod.rs
index 0bd51741b7..8690ce97ed 100644
--- a/stackslib/src/chainstate/coordinator/mod.rs
+++ b/stackslib/src/chainstate/coordinator/mod.rs
@@ -711,6 +711,7 @@ impl<'a, T: BlockEventDispatcher, U: RewardSetProvider, B: BurnchainHeaderReader
             atlas_db: Some(atlas_db),
             config: ChainsCoordinatorConfig::new(),
             burnchain_indexer,
+            refresh_stacker_db: Arc::new(AtomicBool::new(false)),
         }
     }
 }
diff --git a/stackslib/src/cost_estimates/tests/common.rs b/stackslib/src/cost_estimates/tests/common.rs
index 62cb8b363c..6fd21b0676 100644
--- a/stackslib/src/cost_estimates/tests/common.rs
+++ b/stackslib/src/cost_estimates/tests/common.rs
@@ -50,5 +50,6 @@ pub fn make_block_receipt(tx_receipts: Vec<StacksTransactionReceipt>) -> StacksE
         parent_burn_block_timestamp: 1,
         evaluated_epoch: StacksEpochId::Epoch20,
         epoch_transition: false,
+        signers_updated: false,
     }
 }
diff --git a/testnet/stacks-node/src/nakamoto_node/peer.rs b/testnet/stacks-node/src/nakamoto_node/peer.rs
index 1e0f212ab7..bb11b6c22e 100644
--- a/testnet/stacks-node/src/nakamoto_node/peer.rs
+++ b/testnet/stacks-node/src/nakamoto_node/peer.rs
@@ -202,7 +202,10 @@ impl PeerThread {
         }
     }
 
-    fn check_stackerdb_reload(&mut self) {
+    /// Check if the StackerDB config needs to be updated (by looking
+    ///  at the signal in `self.globals`), and if so, refresh the
+    ///  StackerDB config
+    fn refresh_stackerdb(&mut self) {
         if !self.globals.coord_comms.need_stackerdb_update() {
             return;
         }
@@ -243,7 +246,7 @@ impl PeerThread {
             self.poll_timeout
         };
 
-        self.check_stackerdb_reload();
+        self.refresh_stackerdb();
 
         // do one pass
         let p2p_res = {

From e97b2441efd395216902decc0e28eef2d08bd2be Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 6 Feb 2024 15:17:05 -0500
Subject: [PATCH 0679/1166] fix: instantiate burnchain DB earlier in the test
 framework, since the p2p network needs it to exist

---
 testnet/stacks-node/src/node.rs | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/testnet/stacks-node/src/node.rs b/testnet/stacks-node/src/node.rs
index b63b4ddbc1..fd049ee5cc 100644
--- a/testnet/stacks-node/src/node.rs
+++ b/testnet/stacks-node/src/node.rs
@@ -346,6 +346,15 @@ impl Node {
         }
 
         let burnchain_config = config.get_burnchain();
+
+        // instantiate DBs
+        let _burnchain_db = BurnchainDB::connect(
+            &burnchain_config.get_burnchaindb_path(),
+            &burnchain_config,
+            true,
+        )
+        .expect("FATAL: failed to connect to burnchain DB");
+
         run_loop::announce_boot_receipts(
             &mut event_dispatcher,
             &chain_state,
@@ -526,6 +535,7 @@ impl Node {
         let consensus_hash = burnchain_tip.block_snapshot.consensus_hash;
 
         let burnchain = self.config.get_burnchain();
+
         let sortdb = SortitionDB::open(
             &self.config.get_burn_db_file_path(),
             true,

From 6d89e29ce02b59d167875eecbd8f828a3495a985 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Tue, 6 Feb 2024 13:33:57 -0800
Subject: [PATCH 0680/1166] fix: typo in getting reward cycle

---
 stackslib/src/net/tests/mod.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/stackslib/src/net/tests/mod.rs b/stackslib/src/net/tests/mod.rs
index 531fc56fff..859f0b57cf 100644
--- a/stackslib/src/net/tests/mod.rs
+++ b/stackslib/src/net/tests/mod.rs
@@ -312,7 +312,8 @@ impl NakamotoBootPlan {
         let reward_cycle = peer
             .config
             .burnchain
-            .reward_cycle_to_block_height(sortition_height);
+            .block_height_to_reward_cycle(sortition_height.into())
+            .unwrap();
 
         // Make all the test Stackers stack
         let stack_txs: Vec<_> = peer

From 743386419744099c3a31e895d69592a69e96bdab Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Wed, 31 Jan 2024 13:48:25 -0800
Subject: [PATCH 0681/1166] feat: add signer CLI function to generate signature

---
 stacks-signer/src/cli.rs                      | 135 +++++++++++++++++-
 stacks-signer/src/main.rs                     |  83 ++++++++++-
 .../src/util_lib/signed_structured_data.rs    |   2 +
 3 files changed, 216 insertions(+), 4 deletions(-)

diff --git a/stacks-signer/src/cli.rs b/stacks-signer/src/cli.rs
index d5b549fd1a..7261fe3fe2 100644
--- a/stacks-signer/src/cli.rs
+++ b/stacks-signer/src/cli.rs
@@ -17,7 +17,9 @@ use std::io::{self, Read};
 use std::net::SocketAddr;
 use std::path::PathBuf;
 
-use clap::Parser;
+use blockstack_lib::chainstate::stacks::address::PoxAddress;
+use blockstack_lib::util_lib::signed_structured_data::pox4::Pox4SignatureTopic;
+use clap::{Parser, ValueEnum};
 use clarity::vm::types::QualifiedContractIdentifier;
 use stacks_common::address::b58;
 use stacks_common::types::chainstate::StacksPrivateKey;
@@ -56,6 +58,8 @@ pub enum Command {
     Run(RunDkgArgs),
     /// Generate necessary files for running a collection of signers
     GenerateFiles(GenerateFilesArgs),
+    /// Generate a signature for Stacking transactions
+    GenerateStackingSignature(GenerateStackingSignatureArgs),
 }
 
 /// Basic arguments for all cyrptographic and stacker-db functionality
@@ -170,11 +174,83 @@ pub struct GenerateFilesArgs {
     pub timeout: Option<u64>,
 }
 
+#[derive(Clone, Debug)]
+/// Wrapper around `Pox4SignatureTopic` to implement `ValueEnum`
+pub struct StackingSignatureMethod(Pox4SignatureTopic);
+
+impl StackingSignatureMethod {
+    /// Get the inner `Pox4SignatureTopic`
+    pub fn topic(&self) -> &Pox4SignatureTopic {
+        &self.0
+    }
+}
+
+impl From<Pox4SignatureTopic> for StackingSignatureMethod {
+    fn from(topic: Pox4SignatureTopic) -> Self {
+        StackingSignatureMethod(topic)
+    }
+}
+
+impl ValueEnum for StackingSignatureMethod {
+    fn to_possible_value(&self) -> Option<clap::builder::PossibleValue> {
+        Some(clap::builder::PossibleValue::new(self.0.as_str()))
+    }
+
+    fn value_variants<'a>() -> &'a [Self] {
+        &[
+            StackingSignatureMethod(Pox4SignatureTopic::StackStx),
+            StackingSignatureMethod(Pox4SignatureTopic::StackExtend),
+            StackingSignatureMethod(Pox4SignatureTopic::AggregationCommit),
+        ]
+    }
+
+    fn from_str(input: &str, _ignore_case: bool) -> Result<Self, String> {
+        let topic = match input {
+            "stack-stx" => Pox4SignatureTopic::StackStx,
+            "stack-extend" => Pox4SignatureTopic::StackExtend,
+            "aggregation-commit" => Pox4SignatureTopic::AggregationCommit,
+            "agg-commit" => Pox4SignatureTopic::AggregationCommit,
+            _ => return Err(format!("Invalid topic: {}", input)),
+        };
+        Ok(topic.into())
+    }
+}
+
+#[derive(Parser, Debug, Clone)]
+/// Arguments for the generate-stacking-signature command
+pub struct GenerateStackingSignatureArgs {
+    /// BTC address used to receive rewards
+    #[arg(short, long, value_parser = parse_pox_addr)]
+    pub pox_address: PoxAddress,
+    /// The reward cycle to be used in the signature's message hash
+    #[arg(short, long)]
+    pub reward_cycle: u64,
+    /// Path to config file
+    #[arg(long, value_name = "FILE")]
+    pub config: PathBuf,
+    /// Topic for signature
+    #[arg(long)]
+    pub method: StackingSignatureMethod,
+    /// Number of cycles used as a lock period.
+    /// Use `1` for stack-aggregation-commit
+    #[arg(long)]
+    pub period: u64,
+}
+
 /// Parse the contract ID
 fn parse_contract(contract: &str) -> Result<QualifiedContractIdentifier, String> {
     QualifiedContractIdentifier::parse(contract).map_err(|e| format!("Invalid contract: {}", e))
 }
 
+/// Parse a BTC address argument and return a `PoxAddress`
+pub fn parse_pox_addr(pox_address_literal: &str) -> Result<PoxAddress, String> {
+    if let Some(pox_address) = PoxAddress::from_b58(pox_address_literal) {
+        Ok(pox_address)
+    } else {
+        Err(format!("Invalid pox address: {}", pox_address_literal))
+    }
+}
+
 /// Parse the hexadecimal Stacks private key
 fn parse_private_key(private_key: &str) -> Result<StacksPrivateKey, String> {
     StacksPrivateKey::from_hex(private_key).map_err(|e| format!("Invalid private key: {}", e))
@@ -209,3 +285,60 @@ fn parse_network(network: &str) -> Result<Network, String> {
         }
     })
 }
+
+#[cfg(test)]
+mod tests {
+    use blockstack_lib::chainstate::stacks::address::{PoxAddressType20, PoxAddressType32};
+
+    use super::*;
+
+    #[test]
+    fn test_parse_pox_addr() {
+        let tr = "bc1p8vg588hldsnv4a558apet4e9ff3pr4awhqj2hy8gy6x2yxzjpmqsvvpta4";
+        let pox_addr = parse_pox_addr(tr).expect("Failed to parse segwit address");
+        match pox_addr {
+            PoxAddress::Addr32(_, addr_type, _) => {
+                assert_eq!(addr_type, PoxAddressType32::P2TR);
+            }
+            _ => panic!("Invalid parsed address"),
+        }
+
+        let legacy = "1N8GMS991YDY1E696e9SB9EsYY5ckSU7hZ";
+        let pox_addr = parse_pox_addr(legacy).expect("Failed to parse legacy address");
+        match pox_addr {
+            PoxAddress::Standard(stacks_addr, hash_mode) => {
+                assert_eq!(stacks_addr.version, 22);
+                assert!(hash_mode.is_none());
+            }
+            _ => panic!("Invalid parsed address"),
+        }
+
+        let p2sh = "33JNgVMNMC9Xm6mJG9oTVf5zWbmt5xi1Mv";
+        let pox_addr = parse_pox_addr(p2sh).expect("Failed to parse legacy address");
+        match pox_addr {
+            PoxAddress::Standard(stacks_addr, hash_mode) => {
+                assert_eq!(stacks_addr.version, 20);
+                assert!(hash_mode.is_none());
+            }
+            _ => panic!("Invalid parsed address"),
+        }
+
+        let wsh = "bc1qvnpcphdctvmql5gdw6chtwvvsl6ra9gwa2nehc99np7f24juc4vqrx29cs";
+        let pox_addr = parse_pox_addr(wsh).expect("Failed to parse segwit address");
+        match pox_addr {
+            PoxAddress::Addr32(_, addr_type, _) => {
+                assert_eq!(addr_type, PoxAddressType32::P2WSH);
+            }
+            _ => panic!("Invalid parsed address"),
+        }
+
+        let wpkh = "BC1QW508D6QEJXTDG4Y5R3ZARVARY0C5XW7KV8F3T4";
+        let pox_addr = parse_pox_addr(wpkh).expect("Failed to parse segwit address");
+        match pox_addr {
+            PoxAddress::Addr20(_, addr_type, _) => {
+                assert_eq!(addr_type, PoxAddressType20::P2WPKH);
+            }
+            _ => panic!("Invalid parsed address"),
+        }
+    }
+}
diff --git a/stacks-signer/src/main.rs b/stacks-signer/src/main.rs
index 934d599f51..578abe0c9c 100644
--- a/stacks-signer/src/main.rs
+++ b/stacks-signer/src/main.rs
@@ -34,6 +34,7 @@ use std::sync::mpsc::{channel, Receiver, Sender};
 use std::time::Duration;
 
 use blockstack_lib::chainstate::nakamoto::NakamotoBlock;
+use blockstack_lib::util_lib::signed_structured_data::pox4::make_pox_4_signer_key_signature;
 use clap::Parser;
 use clarity::vm::types::QualifiedContractIdentifier;
 use libsigner::{
@@ -44,10 +45,12 @@ use libstackerdb::StackerDBChunkData;
 use slog::{slog_debug, slog_error};
 use stacks_common::codec::read_next;
 use stacks_common::types::chainstate::{StacksAddress, StacksPrivateKey};
+use stacks_common::util::hash::to_hex;
+use stacks_common::util::secp256k1::{MessageSignature, Secp256k1PublicKey};
 use stacks_common::{debug, error};
 use stacks_signer::cli::{
-    Cli, Command, GenerateFilesArgs, GetChunkArgs, GetLatestChunkArgs, PutChunkArgs, RunDkgArgs,
-    SignArgs, StackerDBArgs,
+    Cli, Command, GenerateFilesArgs, GenerateStackingSignatureArgs, GetChunkArgs,
+    GetLatestChunkArgs, PutChunkArgs, RunDkgArgs, SignArgs, StackerDBArgs,
 };
 use stacks_signer::config::Config;
 use stacks_signer::runloop::{RunLoop, RunLoopCommand};
@@ -307,6 +310,36 @@ fn handle_generate_files(args: GenerateFilesArgs) {
     }
 }
 
+fn handle_generate_stacking_signature(
+    args: GenerateStackingSignatureArgs,
+    do_print: bool,
+) -> MessageSignature {
+    let config = Config::try_from(&args.config).unwrap();
+
+    let private_key = config.stacks_private_key;
+    let public_key = Secp256k1PublicKey::from_private(&private_key);
+
+    let signature = make_pox_4_signer_key_signature(
+        &args.pox_address,
+        &private_key, //
+        args.reward_cycle.into(),
+        &args.method.topic(),
+        config.network.to_chain_id(),
+        args.period.into(),
+    )
+    .expect("Failed to generate signature");
+
+    if do_print {
+        println!(
+            "\nSigner Public Key: 0x{}\nSigner Key Signature: 0x{}\n\n",
+            to_hex(&public_key.to_bytes_compressed()),
+            to_hex(signature.to_rsv().as_slice()) // RSV is needed for Clarity
+        );
+    }
+
+    signature
+}
+
 /// Helper function for writing the given contents to filename in the given directory
 fn write_file(dir: &Path, filename: &str, contents: &str) {
     let file_path = dir.join(filename);
@@ -352,8 +385,52 @@ fn main() {
         Command::GenerateFiles(args) => {
             handle_generate_files(args);
         }
+        Command::GenerateStackingSignature(args) => {
+            handle_generate_stacking_signature(args, true);
+        }
     }
 }
 
 #[cfg(test)]
-pub mod tests;
+pub mod tests {
+
+    use blockstack_lib::util_lib::signed_structured_data::pox4::{
+        make_pox_4_signer_key_message_hash, Pox4SignatureTopic,
+    };
+    use stacks_common::{
+        consts::CHAIN_ID_TESTNET, types::PublicKey, util::secp256k1::Secp256k1PublicKey,
+    };
+    use stacks_signer::cli::parse_pox_addr;
+
+    use super::handle_generate_stacking_signature;
+    use crate::{Config, GenerateStackingSignatureArgs};
+
+    #[test]
+    fn test_generate_stacking_signature() {
+        let config = Config::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
+        let btc_address = "bc1p8vg588hldsnv4a558apet4e9ff3pr4awhqj2hy8gy6x2yxzjpmqsvvpta4";
+        let args = GenerateStackingSignatureArgs {
+            config: "./src/tests/conf/signer-0.toml".into(),
+            pox_address: parse_pox_addr(btc_address).unwrap(),
+            reward_cycle: 6,
+            method: Pox4SignatureTopic::StackStx.into(),
+            period: 12,
+        };
+
+        let signature = handle_generate_stacking_signature(args.clone(), false);
+
+        let public_key = Secp256k1PublicKey::from_private(&config.stacks_private_key);
+
+        let message_hash = make_pox_4_signer_key_message_hash(
+            &args.pox_address,
+            args.reward_cycle.into(),
+            &Pox4SignatureTopic::StackStx,
+            CHAIN_ID_TESTNET,
+            args.period.into(),
+        );
+
+        let verify_result = public_key.verify(&message_hash.0, &signature);
+        assert!(verify_result.is_ok());
+        assert!(verify_result.unwrap());
+    }
+}
diff --git a/stackslib/src/util_lib/signed_structured_data.rs b/stackslib/src/util_lib/signed_structured_data.rs
index dbfb030590..9d33a18a6d 100644
--- a/stackslib/src/util_lib/signed_structured_data.rs
+++ b/stackslib/src/util_lib/signed_structured_data.rs
@@ -82,6 +82,8 @@ pub mod pox4 {
         make_structured_data_domain, structured_data_message_hash, MessageSignature, PoxAddress,
         PrivateKey, Sha256Sum, StacksPrivateKey, TupleData, Value,
     };
+
+    #[derive(Clone, Debug)]
     pub enum Pox4SignatureTopic {
         StackStx,
         AggregationCommit,

From 216ec38de3bd3b7dd7de04f880ac51ce73b6fca5 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 6 Feb 2024 17:18:49 -0500
Subject: [PATCH 0682/1166] feat: new error types for not-connected or
 invalid-key

---
 stacks-signer/src/client/mod.rs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/stacks-signer/src/client/mod.rs b/stacks-signer/src/client/mod.rs
index 7342df7d0d..4e23be7aff 100644
--- a/stacks-signer/src/client/mod.rs
+++ b/stacks-signer/src/client/mod.rs
@@ -79,6 +79,12 @@ pub enum ClientError {
     /// Backoff retry timeout
     #[error("Backoff retry timeout occurred. Stacks node may be down.")]
     RetryTimeout,
+    /// Not connected
+    #[error("Not connected")]
+    NotConnected,
+    /// Invalid signing key
+    #[error("Signing key not represented in the list of signers")]
+    InvalidSigningKey,
     /// Clarity interpreter error
     #[error("Clarity interpreter error: {0}")]
     ClarityError(ClarityError),

From 21feeb495fadc964e8f96d11ed4cf5cb4e9df7e4 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 6 Feb 2024 17:19:15 -0500
Subject: [PATCH 0683/1166] fix: get stackerdb client to use all stackerdb
 instances

---
 stacks-signer/src/client/stackerdb.rs | 50 ++++++++++++++++++++-------
 1 file changed, 37 insertions(+), 13 deletions(-)

diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index ae9a32b0ef..26aadeba26 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -25,7 +25,7 @@ use libstackerdb::{StackerDBChunkAckData, StackerDBChunkData};
 use slog::{slog_debug, slog_warn};
 use stacks_common::codec::{read_next, StacksMessageCodec};
 use stacks_common::consts::SIGNER_SLOTS_PER_USER;
-use stacks_common::types::chainstate::StacksPrivateKey;
+use stacks_common::types::chainstate::{StacksAddress, StacksPrivateKey, StacksPublicKey};
 use stacks_common::{debug, warn};
 
 use super::ClientError;
@@ -44,8 +44,8 @@ pub struct StackerDB {
     stacks_private_key: StacksPrivateKey,
     /// A map of a (signer-set, message ID) to last chunk version for each session
     slot_versions: HashMap<(u32, u32), HashMap<u32, u32>>,
-    /// The signer ID
-    signer_id: u32,
+    /// The signer ID -- the index into the signer list for this signer daemon's signing key.
+    signer_slot_id: u32,
     /// Which signer set to use (0 or 1).
     /// Depends on whether or not we're signing in an even or odd reward cycle
     signer_set: u32,
@@ -76,7 +76,7 @@ impl From<&Config> for StackerDB {
             signers_message_stackerdb_sessions,
             stacks_private_key: config.stacks_private_key,
             slot_versions: HashMap::new(),
-            signer_id: config.signer_id,
+            signer_slot_id: config.signer_id,
             signer_set: 0,
         }
     }
@@ -110,7 +110,7 @@ impl StackerDB {
             signers_message_stackerdb_sessions,
             stacks_private_key,
             slot_versions: HashMap::new(),
-            signer_id,
+            signer_slot_id: signer_id,
             signer_set: 0,
         }
     }
@@ -123,7 +123,7 @@ impl StackerDB {
         let message_bytes = message.serialize_to_vec();
         let msg_id = message.msg_id();
         let signer_set = self.signer_set;
-        let slot_id = self.signer_id;
+        let slot_id = self.signer_slot_id;
         loop {
             let slot_version =
                 if let Some(versions) = self.slot_versions.get_mut(&(signer_set, msg_id)) {
@@ -161,7 +161,9 @@ impl StackerDB {
 
             if let Some(versions) = self.slot_versions.get_mut(&(signer_set, msg_id)) {
                 // NOTE: per the above, this is always executed
-                versions.insert(slot_id, slot_version);
+                versions.insert(slot_id, slot_version.saturating_add(1));
+            } else {
+                return Err(ClientError::NotConnected);
             }
 
             if chunk_ack.accepted {
@@ -175,6 +177,12 @@ impl StackerDB {
                 // See: https://github.com/stacks-network/stacks-blockchain/issues/3917
                 if reason.contains("Data for this slot and version already exist") {
                     warn!("Failed to send message to stackerdb due to wrong version number {}. Incrementing and retrying...", slot_version);
+                    if let Some(versions) = self.slot_versions.get_mut(&(signer_set, msg_id)) {
+                        // NOTE: per the above, this is always executed
+                        versions.insert(slot_id, slot_version.saturating_add(1));
+                    } else {
+                        return Err(ClientError::NotConnected);
+                    }
                 } else {
                     warn!("Failed to send message to stackerdb: {}", reason);
                     return Err(ClientError::PutChunkRejected(reason));
@@ -188,17 +196,20 @@ impl StackerDB {
         &mut self,
         signer_ids: &[u32],
     ) -> Result<Vec<StacksTransaction>, ClientError> {
-        let slot_ids: Vec<_> = signer_ids
-            .iter()
-            .map(|id| id * SIGNER_SLOTS_PER_USER + TRANSACTIONS_SLOT_ID)
-            .collect();
         debug!(
             "Getting latest chunks from stackerdb for the following signers: {:?}",
             signer_ids
         );
+        let Some(transactions_session) = self
+            .signers_message_stackerdb_sessions
+            .get_mut(&(self.signer_set, TRANSACTIONS_SLOT_ID))
+        else {
+            return Err(ClientError::NotConnected);
+        };
+
         let send_request = || {
-            self.signers_stackerdb_session
-                .get_latest_chunks(&slot_ids)
+            transactions_session
+                .get_latest_chunks(signer_ids)
                 .map_err(backoff::Error::transient)
         };
         let chunk_ack = retry_with_exponential_backoff(send_request)?;
@@ -243,6 +254,19 @@ impl StackerDB {
     pub fn set_signer_set(&mut self, set: u32) {
         self.signer_set = set
     }
+
+    /// Set the signer slot ID
+    pub fn set_signer_slot_id(&mut self, slot_id: u32) {
+        self.signer_slot_id = slot_id;
+    }
+
+    /// Get our signer address
+    pub fn get_signer_address(&self, mainnet: bool) -> StacksAddress {
+        StacksAddress::p2pkh(
+            mainnet,
+            &StacksPublicKey::from_private(&self.stacks_private_key),
+        )
+    }
 }
 
 #[cfg(test)]

From d3b946ab2045d55a9d47d90e6db11cc29373b44b Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 6 Feb 2024 17:19:34 -0500
Subject: [PATCH 0684/1166] chore: get runloop to auto-configure itself based
 on .signers data

---
 stacks-signer/src/runloop.rs | 82 ++++++++++++++++++++++++++----------
 1 file changed, 60 insertions(+), 22 deletions(-)

diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index ee890b877f..30f33336d6 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -140,6 +140,8 @@ pub struct RunLoop<C> {
     pub signer_id: u32,
     /// The signer set for this runloop
     pub signer_set: Option<u32>,
+    /// The index into the signers list of this signer's key (may be different from signer_id)
+    pub signer_slot_id: Option<u32>,
     /// The IDs of all signers partipating in the current reward cycle
     pub signer_ids: Vec<u32>,
     /// The stacks addresses of the signers participating in the current reward cycle
@@ -149,22 +151,71 @@ pub struct RunLoop<C> {
 impl<C: Coordinator> RunLoop<C> {
     /// Get and store the signer set assignment for this runloop.
     /// This assigns the runloop to the _next_ reward cycle, not the current one.
-    fn get_or_set_signer_set(&mut self) -> Result<u32, ClientError> {
-        if let Some(signer_set) = self.signer_set.as_ref() {
-            return Ok(*signer_set);
+    /// Returns (signer-set, signer-slot-id)
+    fn get_or_set_signer_info(&mut self) -> Result<(u32, u32), ClientError> {
+        match (self.signer_set.as_ref(), self.signer_slot_id.as_ref()) {
+            (Some(signer_set), Some(signer_slot_id)) => {
+                return Ok((*signer_set, *signer_slot_id));
+            }
+            (_, _) => {}
+        }
+
+        let signer_set = if let Some(signer_set) = self.signer_set.as_ref() {
+            *signer_set
         } else {
             let rc = u32::try_from(self.stacks_client.get_current_reward_cycle()?)
                 .expect("FATAL: reward cycle exceeds u32::MAX")
                 + 1;
             debug!("Next reward cycle is {}", rc);
-            self.signer_set = Some(rc % 2);
-            self.stackerdb.set_signer_set(rc % 2);
-            Ok(rc % 2)
-        }
+            let signer_set = rc % 2;
+            self.signer_set = Some(signer_set);
+            self.stackerdb.set_signer_set(signer_set);
+            signer_set
+        };
+
+        // Get the signer writers from the stacker-db to verify transactions against
+        self.signer_addresses = self
+            .stacks_client
+            .get_stackerdb_signer_slots(
+                self.stackerdb.signers_contract_id(),
+                self.stackerdb.get_signer_set(),
+            )?
+            .into_iter()
+            .map(|(address, _)| address)
+            .collect();
+
+        let signer_slot_id = if let Some(signer_slot_id) = self.signer_slot_id.as_ref() {
+            *signer_slot_id
+        } else {
+            let addr = self.stackerdb.get_signer_address(self.mainnet);
+            self.signer_slot_id = self
+                .signer_addresses
+                .iter()
+                .position(|signer_addr| signer_addr == &addr)
+                .map(|pos| u32::try_from(pos).expect("FATAL: position exceeds u32::MAX"));
+
+            let Some(signer_slot_id) = self.signer_slot_id.as_ref() else {
+                return Err(ClientError::InvalidSigningKey);
+            };
+            self.stackerdb.set_signer_slot_id(*signer_slot_id);
+            *signer_slot_id
+        };
+
+        Ok((signer_set, signer_slot_id))
     }
 
     /// Initialize the signer, reading the stacker-db state and setting the aggregate public key
     fn initialize(&mut self) -> Result<(), ClientError> {
+        // determine what signer set we're using, so we use the right stackerdb replicas
+        let (signer_set, signer_slot_id) = self.get_or_set_signer_info()?;
+        debug!(
+            "signer #{}: Self-assigning to signer set {} slot {} address {}",
+            self.signer_id,
+            signer_set,
+            signer_slot_id,
+            self.stackerdb.get_signer_address(self.mainnet)
+        );
+
         // Check if the aggregate key is set in the pox contract
         if let Some(key) = self.stacks_client.get_aggregate_public_key()? {
             debug!("Aggregate public key is set: {:?}", key);
@@ -181,20 +232,6 @@ impl<C: Coordinator> RunLoop<C> {
             }
         }
 
-        // determine what signer set we're using, so we use the right stackerdb replicas
-        let signer_set = self.get_or_set_signer_set()?;
-        debug!("Self-assigning to signer set {}", signer_set);
-
-        // Get the signer writers from the stacker-db to verify transactions against
-        self.signer_addresses = self
-            .stacks_client
-            .get_stackerdb_signer_slots(
-                self.stackerdb.signers_contract_id(),
-                self.stackerdb.get_signer_set(),
-            )?
-            .into_iter()
-            .map(|(address, _)| address)
-            .collect();
         self.state = State::Idle;
         Ok(())
     }
@@ -898,7 +935,8 @@ impl From<&Config> for RunLoop<FireCoordinator<v2::Aggregator>> {
             transactions: Vec::new(),
             signer_ids: config.signer_ids.clone(),
             signer_id: config.signer_id,
-            signer_set: None, // will be updated on .initialize()
+            signer_slot_id: None, // will be updated on .initialize()
+            signer_set: None,     // will be updated on .initialize()
             signer_addresses: vec![],
         }
     }

From c1fd04c41e4485b4794cf1bbf7950c9c0ae39b60 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Wed, 7 Feb 2024 01:32:15 -0500
Subject: [PATCH 0685/1166] chore: clean up imports

---
 libsigner/src/libsigner.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/libsigner/src/libsigner.rs b/libsigner/src/libsigner.rs
index c934d7afd2..e48f4014e1 100644
--- a/libsigner/src/libsigner.rs
+++ b/libsigner/src/libsigner.rs
@@ -48,8 +48,7 @@ pub use crate::events::{
     EventReceiver, EventStopSignaler, SignerEvent, SignerEventReceiver, SignerStopSignaler,
 };
 pub use crate::messages::{
-    BlockRejection, BlockResponse, RejectCode, SignerMessage, BLOCK_SLOT_ID, SIGNER_SLOTS_PER_USER,
-    TRANSACTIONS_SLOT_ID,
+    BlockRejection, BlockResponse, RejectCode, SignerMessage, BLOCK_MSG_ID, TRANSACTIONS_MSG_ID,
 };
 pub use crate::runloop::{RunningSigner, Signer, SignerRunLoop};
 pub use crate::session::{SignerSession, StackerDBSession};

From 1f0e8c6ad0c94a038b410efc88c241c12820d2de Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Wed, 7 Feb 2024 01:32:28 -0500
Subject: [PATCH 0686/1166] chore: we only care about message ID now, not slot
 ID

---
 libsigner/src/messages.rs | 54 ++++++++++++++++++---------------------
 1 file changed, 25 insertions(+), 29 deletions(-)

diff --git a/libsigner/src/messages.rs b/libsigner/src/messages.rs
index 658264919d..54519b9ecc 100644
--- a/libsigner/src/messages.rs
+++ b/libsigner/src/messages.rs
@@ -35,6 +35,7 @@ use stacks_common::codec::{
     read_next, read_next_at_most, read_next_exact, write_next, Error as CodecError,
     StacksMessageCodec,
 };
+use stacks_common::consts::SIGNER_SLOTS_PER_USER;
 use stacks_common::util::hash::Sha512Trunc256Sum;
 use tiny_http::{
     Method as HttpMethod, Request as HttpRequest, Response as HttpResponse, Server as HttpServer,
@@ -52,26 +53,21 @@ use wsts::state_machine::signer;
 use crate::http::{decode_http_body, decode_http_request};
 use crate::EventError;
 
-/// Temporary placeholder for the number of slots allocated to a stacker-db writer. This will be retrieved from the stacker-db instance in the future
-/// See: https://github.com/stacks-network/stacks-blockchain/issues/3921
-/// Is equal to the number of message types
-pub const SIGNER_SLOTS_PER_USER: u32 = 12;
-
 // The slot IDS for each message type
-const DKG_BEGIN_SLOT_ID: u32 = 0;
-const DKG_PRIVATE_BEGIN_SLOT_ID: u32 = 1;
-const DKG_END_BEGIN_SLOT_ID: u32 = 2;
-const DKG_END_SLOT_ID: u32 = 3;
-const DKG_PUBLIC_SHARES_SLOT_ID: u32 = 4;
-const DKG_PRIVATE_SHARES_SLOT_ID: u32 = 5;
-const NONCE_REQUEST_SLOT_ID: u32 = 6;
-const NONCE_RESPONSE_SLOT_ID: u32 = 7;
-const SIGNATURE_SHARE_REQUEST_SLOT_ID: u32 = 8;
-const SIGNATURE_SHARE_RESPONSE_SLOT_ID: u32 = 9;
+const DKG_BEGIN_MSG_ID: u32 = 0;
+const DKG_PRIVATE_BEGIN_MSG_ID: u32 = 1;
+const DKG_END_BEGIN_MSG_ID: u32 = 2;
+const DKG_END_MSG_ID: u32 = 3;
+const DKG_PUBLIC_SHARES_MSG_ID: u32 = 4;
+const DKG_PRIVATE_SHARES_MSG_ID: u32 = 5;
+const NONCE_REQUEST_MSG_ID: u32 = 6;
+const NONCE_RESPONSE_MSG_ID: u32 = 7;
+const SIGNATURE_SHARE_REQUEST_MSG_ID: u32 = 8;
+const SIGNATURE_SHARE_RESPONSE_MSG_ID: u32 = 9;
 /// The slot ID for the block response for miners to observe
-pub const BLOCK_SLOT_ID: u32 = 10;
+pub const BLOCK_MSG_ID: u32 = 10;
 /// The slot ID for the transactions list for miners and signers to observe
-pub const TRANSACTIONS_SLOT_ID: u32 = 11;
+pub const TRANSACTIONS_MSG_ID: u32 = 11;
 
 define_u8_enum!(SignerMessageTypePrefix {
     BlockResponse = 0,
@@ -182,19 +178,19 @@ impl SignerMessage {
     pub fn msg_id(&self) -> u32 {
         let msg_id = match self {
             Self::Packet(packet) => match packet.msg {
-                Message::DkgBegin(_) => DKG_BEGIN_SLOT_ID,
-                Message::DkgPrivateBegin(_) => DKG_PRIVATE_BEGIN_SLOT_ID,
-                Message::DkgEndBegin(_) => DKG_END_BEGIN_SLOT_ID,
-                Message::DkgEnd(_) => DKG_END_SLOT_ID,
-                Message::DkgPublicShares(_) => DKG_PUBLIC_SHARES_SLOT_ID,
-                Message::DkgPrivateShares(_) => DKG_PRIVATE_SHARES_SLOT_ID,
-                Message::NonceRequest(_) => NONCE_REQUEST_SLOT_ID,
-                Message::NonceResponse(_) => NONCE_RESPONSE_SLOT_ID,
-                Message::SignatureShareRequest(_) => SIGNATURE_SHARE_REQUEST_SLOT_ID,
-                Message::SignatureShareResponse(_) => SIGNATURE_SHARE_RESPONSE_SLOT_ID,
+                Message::DkgBegin(_) => DKG_BEGIN_MSG_ID,
+                Message::DkgPrivateBegin(_) => DKG_PRIVATE_BEGIN_MSG_ID,
+                Message::DkgEndBegin(_) => DKG_END_BEGIN_MSG_ID,
+                Message::DkgEnd(_) => DKG_END_MSG_ID,
+                Message::DkgPublicShares(_) => DKG_PUBLIC_SHARES_MSG_ID,
+                Message::DkgPrivateShares(_) => DKG_PRIVATE_SHARES_MSG_ID,
+                Message::NonceRequest(_) => NONCE_REQUEST_MSG_ID,
+                Message::NonceResponse(_) => NONCE_RESPONSE_MSG_ID,
+                Message::SignatureShareRequest(_) => SIGNATURE_SHARE_REQUEST_MSG_ID,
+                Message::SignatureShareResponse(_) => SIGNATURE_SHARE_RESPONSE_MSG_ID,
             },
-            Self::BlockResponse(_) => BLOCK_SLOT_ID,
-            Self::Transactions(_) => TRANSACTIONS_SLOT_ID,
+            Self::BlockResponse(_) => BLOCK_MSG_ID,
+            Self::Transactions(_) => TRANSACTIONS_MSG_ID,
         };
         msg_id
     }

From 8519efa14609858895d68b3dd07f17afc647bf6b Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Wed, 7 Feb 2024 01:32:52 -0500
Subject: [PATCH 0687/1166] chore: debug-log data we fail to decode

---
 stacks-signer/src/client/stackerdb.rs | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index 26aadeba26..6657e47b21 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -20,7 +20,7 @@ use blockstack_lib::chainstate::stacks::StacksTransaction;
 use clarity::vm::types::QualifiedContractIdentifier;
 use clarity::vm::ContractName;
 use hashbrown::HashMap;
-use libsigner::{SignerMessage, SignerSession, StackerDBSession, TRANSACTIONS_SLOT_ID};
+use libsigner::{SignerMessage, SignerSession, StackerDBSession, TRANSACTIONS_MSG_ID};
 use libstackerdb::{StackerDBChunkAckData, StackerDBChunkData};
 use slog::{slog_debug, slog_warn};
 use stacks_common::codec::{read_next, StacksMessageCodec};
@@ -202,7 +202,7 @@ impl StackerDB {
         );
         let Some(transactions_session) = self
             .signers_message_stackerdb_sessions
-            .get_mut(&(self.signer_set, TRANSACTIONS_SLOT_ID))
+            .get_mut(&(self.signer_set, TRANSACTIONS_MSG_ID))
         else {
             return Err(ClientError::NotConnected);
         };
@@ -222,7 +222,15 @@ impl StackerDB {
                 continue;
             };
             let Ok(message) = read_next::<SignerMessage, _>(&mut &data[..]) else {
-                warn!("Failed to deserialize chunk data into a SignerMessage");
+                if data.len() > 0 {
+                    warn!("Failed to deserialize chunk data into a SignerMessage");
+                    debug!(
+                        "signer #{}: Failed chunk ({}): {:?}",
+                        signer_id,
+                        &data.len(),
+                        &data[..]
+                    );
+                }
                 continue;
             };
 

From e1c60a5e72a1a32b92e0fd5c64660d49a4208d58 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Wed, 7 Feb 2024 01:33:09 -0500
Subject: [PATCH 0688/1166] chore: log signer ID in debug logs

---
 stacks-signer/src/runloop.rs | 246 ++++++++++++++++++++++++++---------
 1 file changed, 182 insertions(+), 64 deletions(-)

diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 30f33336d6..10e60ab876 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -209,7 +209,7 @@ impl<C: Coordinator> RunLoop<C> {
         // determine what signer set we're using, so we use the right stackerdb replicas
         let (signer_set, signer_slot_id) = self.get_or_set_signer_info()?;
         debug!(
-            "signer #{}: Self-assigning to signer set {} slot {} address {}",
+            "Signer #{}: Self-assigning to signer set {} slot {} address {}",
             self.signer_id,
             signer_set,
             signer_slot_id,
@@ -218,10 +218,16 @@ impl<C: Coordinator> RunLoop<C> {
 
         // Check if the aggregate key is set in the pox contract
         if let Some(key) = self.stacks_client.get_aggregate_public_key()? {
-            debug!("Aggregate public key is set: {:?}", key);
+            debug!(
+                "Signer #{}: Aggregate public key is set: {:?}",
+                self.signer_id, key
+            );
             self.coordinator.set_aggregate_public_key(Some(key));
         } else {
-            debug!("Aggregate public key is not set. Coordinator must trigger DKG...");
+            debug!(
+                "Signer #{}: Aggregate public key is not set. Coordinator must trigger DKG...",
+                self.signer_id
+            );
             // Update the state to IDLE so we don't needlessy requeue the DKG command.
             let (coordinator_id, _) =
                 calculate_coordinator(&self.signing_round.public_keys, &self.stacks_client);
@@ -241,11 +247,11 @@ impl<C: Coordinator> RunLoop<C> {
     fn execute_command(&mut self, command: &RunLoopCommand) -> bool {
         match command {
             RunLoopCommand::Dkg => {
-                info!("Starting DKG");
+                info!("Signer #{}: Starting DKG", self.signer_id);
                 match self.coordinator.start_dkg_round() {
                     Ok(msg) => {
                         let ack = self.stackerdb.send_message_with_retry(msg.into());
-                        debug!("ACK: {:?}", ack);
+                        debug!("Signer #{}: ACK: {:?}", self.signer_id, ack);
                         self.state = State::Dkg;
                         true
                     }
@@ -268,10 +274,10 @@ impl<C: Coordinator> RunLoop<C> {
                     .entry(signer_signature_hash)
                     .or_insert_with(|| BlockInfo::new(block.clone()));
                 if block_info.signed_over {
-                    debug!("Received a sign command for a block we are already signing over. Ignore it.");
+                    debug!("Signer #{}: Received a sign command for a block we are already signing over. Ignore it.", self.signer_id);
                     return false;
                 }
-                info!("Signing block: {:?}", block);
+                info!("Signer #{}: Signing block: {:?}", self.signer_id, block);
                 match self.coordinator.start_signing_round(
                     &block.serialize_to_vec(),
                     *is_taproot,
@@ -279,14 +285,20 @@ impl<C: Coordinator> RunLoop<C> {
                 ) {
                     Ok(msg) => {
                         let ack = self.stackerdb.send_message_with_retry(msg.into());
-                        debug!("ACK: {:?}", ack);
+                        debug!("Signer #{}: ACK: {:?}", self.signer_id, ack);
                         self.state = State::Sign;
                         block_info.signed_over = true;
                         true
                     }
                     Err(e) => {
-                        error!("Failed to start signing message: {:?}", e);
-                        warn!("Resetting coordinator's internal state.");
+                        error!(
+                            "Signer #{}: Failed to start signing message: {:?}",
+                            self.signer_id, e
+                        );
+                        warn!(
+                            "Signer #{}: Resetting coordinator's internal state.",
+                            self.signer_id
+                        );
                         self.coordinator.reset();
                         false
                     }
@@ -300,22 +312,31 @@ impl<C: Coordinator> RunLoop<C> {
         match self.state {
             State::Uninitialized => {
                 debug!(
-                    "Signer is uninitialized. Waiting for aggregate public key from stacks node..."
+                    "Signer #{}: uninitialized. Waiting for aggregate public key from stacks node...", self.signer_id
                 );
             }
             State::Idle => {
                 if let Some(command) = self.commands.pop_front() {
                     while !self.execute_command(&command) {
-                        warn!("Failed to execute command. Retrying...");
+                        warn!(
+                            "Signer #{}: Failed to execute command. Retrying...",
+                            self.signer_id
+                        );
                     }
                 } else {
-                    debug!("Nothing to process. Waiting for command...");
+                    debug!(
+                        "Signer #{}: Nothing to process. Waiting for command...",
+                        self.signer_id
+                    );
                 }
             }
             State::Dkg | State::Sign => {
                 // We cannot execute the next command until the current one is finished...
                 // Do nothing...
-                debug!("Waiting for {:?} operation to finish", self.state);
+                debug!(
+                    "Signer #{}: Waiting for {:?} operation to finish",
+                    self.signer_id, self.state
+                );
             }
         }
     }
@@ -337,6 +358,12 @@ impl<C: Coordinator> RunLoop<C> {
                 };
                 let is_valid = self.verify_transactions(&block_info.block);
                 block_info.valid = Some(is_valid);
+                info!(
+                    "Signer #{}: Treating block validation for block {} as valid: {:?}",
+                    self.signer_id,
+                    &block_info.block.block_id(),
+                    block_info.valid
+                );
                 // Add the block info back to the map
                 self.blocks
                     .entry(signer_signature_hash)
@@ -346,27 +373,30 @@ impl<C: Coordinator> RunLoop<C> {
                 let signer_signature_hash = block_validate_reject.signer_signature_hash;
                 let Some(block_info) = self.blocks.get_mut(&signer_signature_hash) else {
                     // We have not seen this block before. Why are we getting a response for it?
-                    debug!("Received a block validate response for a block we have not seen before. Ignoring...");
+                    debug!("Signer #{}: Received a block validate response for a block we have not seen before. Ignoring...", self.signer_id);
                     return;
                 };
                 block_info.valid = Some(false);
                 // Submit a rejection response to the .signers contract for miners
                 // to observe so they know to send another block and to prove signers are doing work);
-                warn!("Broadcasting a block rejection due to stacks node validation failure...");
+                warn!("Signer #{}: Broadcasting a block rejection due to stacks node validation failure...", self.signer_id);
                 if let Err(e) = self
                     .stackerdb
                     .send_message_with_retry(block_validate_reject.into())
                 {
-                    warn!("Failed to send block rejection to stacker-db: {:?}", e);
+                    warn!(
+                        "Signer #{}: Failed to send block rejection to stacker-db: {:?}",
+                        self.signer_id, e
+                    );
                 }
                 block_info
             }
         };
 
         if let Some(mut nonce_request) = block_info.nonce_request.take() {
-            debug!("Received a block validate response from the stacks node for a block we already received a nonce request for. Responding to the nonce request...");
+            debug!("Signer #{}: Received a block validate response from the stacks node for a block we already received a nonce request for. Responding to the nonce request...", self.signer_id);
             // We have received validation from the stacks node. Determine our vote and update the request message
-            Self::determine_vote(block_info, &mut nonce_request);
+            Self::determine_vote(self.signer_id, block_info, &mut nonce_request);
             // Send the nonce request through with our vote
             let packet = Packet {
                 msg: Message::NonceRequest(nonce_request),
@@ -410,8 +440,12 @@ impl<C: Coordinator> RunLoop<C> {
         res: Sender<Vec<OperationResult>>,
         messages: Vec<SignerMessage>,
     ) {
-        let (_coordinator_id, coordinator_public_key) =
+        let (coordinator_id, coordinator_public_key) =
             calculate_coordinator(&self.signing_round.public_keys, &self.stacks_client);
+        debug!(
+            "Signer #{}: coordinator is signer #{} public key {}",
+            self.signer_id, coordinator_id, &coordinator_public_key
+        );
         let packets: Vec<Packet> = messages
             .into_iter()
             .filter_map(|msg| match msg {
@@ -486,18 +520,22 @@ impl<C: Coordinator> RunLoop<C> {
             &request.message
         } else {
             // We will only sign across block hashes or block hashes + b'n' byte
-            debug!("Received a signature share request for an unknown message stream. Reject it.");
+            debug!("Signer #{}: Received a signature share request for an unknown message stream. Reject it.", self.signer_id);
             return false;
         };
 
         let Some(hash) = Sha512Trunc256Sum::from_bytes(hash_bytes) else {
             // We will only sign across valid block hashes
-            debug!("Received a signature share request for an invalid block hash. Reject it.");
+            debug!("Signer #{}: Received a signature share request for an invalid block hash. Reject it.", self.signer_id);
             return false;
         };
         match self.blocks.get(&hash).map(|block_info| &block_info.vote) {
             Some(Some(vote)) => {
                 // Overwrite with our agreed upon value in case another message won majority or the coordinator is trying to cheat...
+                debug!(
+                    "Signer #{}: set vote for {} to {:?}",
+                    self.signer_id, &hash, &vote
+                );
                 request.message = vote.clone();
                 true
             }
@@ -505,14 +543,14 @@ impl<C: Coordinator> RunLoop<C> {
                 // We never agreed to sign this block. Reject it.
                 // This can happen if the coordinator received enough votes to sign yes
                 // or no on a block before we received validation from the stacks node.
-                debug!("Received a signature share request for a block we never agreed to sign. Ignore it.");
+                debug!("Signer #{}: Received a signature share request for a block we never agreed to sign. Ignore it.", self.signer_id);
                 false
             }
             None => {
                 // We will only sign across block hashes or block hashes + b'n' byte for
                 // blocks we have seen a Nonce Request for (and subsequent validation)
                 // We are missing the context here necessary to make a decision. Reject the block
-                debug!("Received a signature share request from an unknown block. Reject it.");
+                debug!("Signer #{}: Received a signature share request from an unknown block. Reject it.", self.signer_id);
                 false
             }
         }
@@ -526,13 +564,16 @@ impl<C: Coordinator> RunLoop<C> {
         let Some(block) = read_next::<NakamotoBlock, _>(&mut &nonce_request.message[..]).ok()
         else {
             // We currently reject anything that is not a block
-            debug!("Received a nonce request for an unknown message stream. Reject it.");
+            debug!(
+                "Signer #{}: Received a nonce request for an unknown message stream. Reject it.",
+                self.signer_id
+            );
             return false;
         };
         let signer_signature_hash = block.header.signer_signature_hash();
         let Some(block_info) = self.blocks.get_mut(&signer_signature_hash) else {
             // We have not seen this block before. Cache it. Send a RPC to the stacks node to validate it.
-            debug!("We have received a block sign request for a block we have not seen before. Cache the nonce request and submit the block for validation...");
+            debug!("Signer #{}: We have received a block sign request for a block we have not seen before. Cache the nonce request and submit the block for validation...", self.signer_id);
             // Store the block in our cache
             self.blocks.insert(
                 signer_signature_hash,
@@ -541,19 +582,22 @@ impl<C: Coordinator> RunLoop<C> {
             self.stacks_client
                 .submit_block_for_validation(block)
                 .unwrap_or_else(|e| {
-                    warn!("Failed to submit block for validation: {:?}", e);
+                    warn!(
+                        "Signer #{}: Failed to submit block for validation: {:?}",
+                        self.signer_id, e
+                    );
                 });
             return false;
         };
 
         if block_info.valid.is_none() {
             // We have not yet received validation from the stacks node. Cache the request and wait for validation
-            debug!("We have yet to receive validation from the stacks node for a nonce request. Cache the nonce request and wait for block validation...");
+            debug!("Signer #{}: We have yet to receive validation from the stacks node for a nonce request. Cache the nonce request and wait for block validation...", self.signer_id);
             block_info.nonce_request = Some(nonce_request.clone());
             return false;
         }
 
-        Self::determine_vote(block_info, nonce_request);
+        Self::determine_vote(self.signer_id, block_info, nonce_request);
         true
     }
 
@@ -567,15 +611,25 @@ impl<C: Coordinator> RunLoop<C> {
                 .into_iter()
                 .filter_map(|tx| {
                     if !block_tx_hashset.contains(&tx.txid()) {
+                        debug!(
+                            "Signer #{}: expected txid {} is in the block",
+                            self.signer_id,
+                            &tx.txid()
+                        );
                         Some(tx)
                     } else {
+                        debug!(
+                            "Signer #{}: missing expected txid {}",
+                            self.signer_id,
+                            &tx.txid()
+                        );
                         None
                     }
                 })
                 .collect::<Vec<_>>();
             let is_valid = missing_transactions.is_empty();
             if !is_valid {
-                debug!("Broadcasting a block rejection due to missing expected transactions...");
+                debug!("Signer #{}: Broadcasting a block rejection due to missing expected transactions...", self.signer_id);
                 let block_rejection = BlockRejection::new(
                     block.header.signer_signature_hash(),
                     RejectCode::MissingTransactions(missing_transactions),
@@ -591,7 +645,10 @@ impl<C: Coordinator> RunLoop<C> {
             is_valid
         } else {
             // Failed to connect to the stacks node to get transactions. Cannot validate the block. Reject it.
-            debug!("Broadcasting a block rejection due to signer connectivity issues...");
+            debug!(
+                "Signer #{}: Broadcasting a block rejection due to signer connectivity issues...",
+                self.signer_id
+            );
             let block_rejection = BlockRejection::new(
                 block.header.signer_signature_hash(),
                 RejectCode::ConnectivityIssues,
@@ -601,7 +658,10 @@ impl<C: Coordinator> RunLoop<C> {
                 .stackerdb
                 .send_message_with_retry(block_rejection.into())
             {
-                warn!("Failed to send block submission to stacker-db: {:?}", e);
+                warn!(
+                    "Signer #{}: Failed to send block submission to stacker-db: {:?}",
+                    self.signer_id, e
+                );
             }
             false
         }
@@ -624,28 +684,36 @@ impl<C: Coordinator> RunLoop<C> {
                 let origin_address = transaction.origin_address();
                 let origin_nonce = transaction.get_origin_nonce();
                 let Ok(account_nonce) = self.stacks_client.get_account_nonce(&origin_address) else {
-                    warn!("Unable to get account for address: {origin_address}. Ignoring it for this block...");
+                    warn!("Signer #{}: Unable to get account for address: {origin_address}. Ignoring it for this block...", self.signer_id);
                     return None;
                 };
                 if !self.signer_addresses.contains(&origin_address) || origin_nonce < account_nonce {
-                    debug!("Received a transaction for signer id that is either not valid or has already been confirmed. Ignoring it.");
+                    debug!("Signer #{}: Received a transaction for signer id ({}) that is either not valid or has already been confirmed (origin={}, account={}). Ignoring it.", self.signer_id, &origin_address, origin_nonce, account_nonce);
                     return None;
                 }
+                debug!("Signer #{}: Expect transaction {} ({:?})", self.signer_id, transaction.txid(), &transaction);
                 Some(transaction)
             }).collect();
         Ok(transactions)
     }
 
     /// Determine the vote for a block and update the block info and nonce request accordingly
-    fn determine_vote(block_info: &mut BlockInfo, nonce_request: &mut NonceRequest) {
+    fn determine_vote(
+        signer_id: u32,
+        block_info: &mut BlockInfo,
+        nonce_request: &mut NonceRequest,
+    ) {
         let mut vote_bytes = block_info.block.header.signer_signature_hash().0.to_vec();
         // Validate the block contents
         if !block_info.valid.unwrap_or(false) {
             // We don't like this block. Update the request to be across its hash with a byte indicating a vote no.
-            debug!("Updating the request with a block hash with a vote no.");
+            debug!(
+                "Signer #{}: Updating the request with a block hash with a vote no.",
+                signer_id
+            );
             vote_bytes.push(b'n');
         } else {
-            debug!("The block passed validation. Update the request with the signature hash.");
+            debug!("Signer #{}: The block passed validation. Update the request with the signature hash.", signer_id);
         }
 
         // Cache our vote
@@ -682,7 +750,10 @@ impl<C: Coordinator> RunLoop<C> {
             }
             Some(packet)
         } else {
-            debug!("Failed to verify wsts packet: {:?}", &packet);
+            debug!(
+                "Signer #{}: Failed to verify wsts packet with {}: {:?}",
+                self.signer_id, coordinator_public_key, &packet
+            );
             None
         }
     }
@@ -694,10 +765,11 @@ impl<C: Coordinator> RunLoop<C> {
             // Signers only every trigger non-taproot signing rounds over blocks. Ignore SignTaproot results
             match operation_result {
                 OperationResult::Sign(signature) => {
+                    debug!("Signer #{}: Received signature result", self.signer_id);
                     self.process_signature(signature);
                 }
                 OperationResult::SignTaproot(_) => {
-                    debug!("Received a signature result for a taproot signature. Nothing to broadcast as we currently sign blocks with a FROST signature.");
+                    debug!("Signer #{}: Received a signature result for a taproot signature. Nothing to broadcast as we currently sign blocks with a FROST signature.", self.signer_id);
                 }
                 OperationResult::Dkg(_point) => {
                     // TODO: cast the aggregate public key for the latest round here
@@ -708,18 +780,21 @@ impl<C: Coordinator> RunLoop<C> {
                         .unwrap_or(EpochId::UnsupportedEpoch);
                     match epoch {
                         EpochId::UnsupportedEpoch => {
-                            debug!("Received a DKG result, but are in an unsupported epoch. Do not broadcast the result.");
+                            debug!("Signer #{}: Received a DKG result, but are in an unsupported epoch. Do not broadcast the result.", self.signer_id);
                         }
                         EpochId::Epoch25 => {
-                            debug!("Received a DKG result, but are in epoch 2.5. Broadcast the transaction to the mempool.");
+                            debug!("Signer #{}: Received a DKG result, but are in epoch 2.5. Broadcast the transaction to the mempool.", self.signer_id);
                             //TODO: Cast the aggregate public key vote here
                         }
                         EpochId::Epoch30 => {
-                            debug!("Received a DKG result, but are in epoch 3. Broadcast the transaction to stackerDB.");
+                            debug!("Signer #{}: Received a DKG result, but are in epoch 3. Broadcast the transaction to stackerDB.", self.signer_id);
                             let signer_message =
                                 SignerMessage::Transactions(self.transactions.clone());
                             if let Err(e) = self.stackerdb.send_message_with_retry(signer_message) {
-                                warn!("Failed to update transactions in stacker-db: {:?}", e);
+                                warn!(
+                                    "Signer #{}: Failed to update transactions in stacker-db: {:?}",
+                                    self.signer_id, e
+                                );
                             }
                         }
                     }
@@ -728,7 +803,7 @@ impl<C: Coordinator> RunLoop<C> {
                     self.process_sign_error(e);
                 }
                 OperationResult::DkgError(e) => {
-                    warn!("Received a DKG error: {:?}", e);
+                    warn!("Signer #{}: Received a DKG error: {:?}", self.signer_id, e);
                 }
             }
         }
@@ -739,7 +814,10 @@ impl<C: Coordinator> RunLoop<C> {
     fn process_signature(&mut self, signature: &Signature) {
         // Deserialize the signature result and broadcast an appropriate Reject or Approval message to stackerdb
         let Some(aggregate_public_key) = &self.coordinator.get_aggregate_public_key() else {
-            debug!("No aggregate public key set. Cannot validate signature...");
+            debug!(
+                "Signer #{}: No aggregate public key set. Cannot validate signature...",
+                self.signer_id
+            );
             return;
         };
         let message = self.coordinator.get_message();
@@ -752,7 +830,7 @@ impl<C: Coordinator> RunLoop<C> {
         let Some(signer_signature_hash) =
             Sha512Trunc256Sum::from_bytes(signer_signature_hash_bytes)
         else {
-            debug!("Received a signature result for a signature over a non-block. Nothing to broadcast.");
+            debug!("Signer #{}: Received a signature result for a signature over a non-block. Nothing to broadcast.", self.signer_id);
             return;
         };
 
@@ -761,7 +839,7 @@ impl<C: Coordinator> RunLoop<C> {
 
         // This signature is no longer valid. Do not broadcast it.
         if !signature.verify(aggregate_public_key, &message) {
-            warn!("Received an invalid signature result across the block. Do not broadcast it.");
+            warn!("Signer #{}: Received an invalid signature result across the block. Do not broadcast it.", self.signer_id);
             // TODO: should we reinsert it and trigger a sign round across the block again?
             return;
         }
@@ -775,8 +853,15 @@ impl<C: Coordinator> RunLoop<C> {
         };
 
         // Submit signature result to miners to observe
+        debug!(
+            "Signer #{}: submit block response {:?}",
+            self.signer_id, &block_submission
+        );
         if let Err(e) = self.stackerdb.send_message_with_retry(block_submission) {
-            warn!("Failed to send block submission to stacker-db: {:?}", e);
+            warn!(
+                "Signer #{}: Failed to send block submission to stacker-db: {:?}",
+                self.signer_id, e
+            );
         }
     }
 
@@ -786,9 +871,10 @@ impl<C: Coordinator> RunLoop<C> {
         match e {
             SignError::NonceTimeout(_valid_signers, _malicious_signers) => {
                 //TODO: report these malicious signers
-                debug!("Received a nonce timeout.");
+                debug!("Signer #{}: Received a nonce timeout.", self.signer_id);
             }
             SignError::InsufficientSigners(malicious_signers) => {
+                debug!("Signer #{}: Insufficient signers.", self.signer_id);
                 let message = self.coordinator.get_message();
                 let block = read_next::<NakamotoBlock, _>(&mut &message[..]).ok().unwrap_or({
                     // This is not a block so maybe its across its hash
@@ -799,11 +885,11 @@ impl<C: Coordinator> RunLoop<C> {
                         &message
                     };
                     let Some(signer_signature_hash) = Sha512Trunc256Sum::from_bytes(signer_signature_hash_bytes) else {
-                        debug!("Received a signature result for a signature over a non-block. Nothing to broadcast.");
+                        debug!("Signer #{}: Received a signature result for a signature over a non-block. Nothing to broadcast.", self.signer_id);
                         return;
                     };
                     let Some(block_info) = self.blocks.remove(&signer_signature_hash) else {
-                        debug!("Received a signature result for a block we have not seen before. Ignoring...");
+                        debug!("Signer #{}: Received a signature result for a block we have not seen before. Ignoring...", self.signer_id);
                         return;
                     };
                     block_info.block
@@ -813,16 +899,27 @@ impl<C: Coordinator> RunLoop<C> {
                     block.header.signer_signature_hash(),
                     RejectCode::InsufficientSigners(malicious_signers.clone()),
                 );
+                debug!(
+                    "Signer #{}: Insufficient signers for block; send rejection {:?}",
+                    self.signer_id, &block_rejection
+                );
+
                 // Submit signature result to miners to observe
                 if let Err(e) = self
                     .stackerdb
                     .send_message_with_retry(block_rejection.into())
                 {
-                    warn!("Failed to send block submission to stacker-db: {:?}", e);
+                    warn!(
+                        "Signer #{}: Failed to send block submission to stacker-db: {:?}",
+                        self.signer_id, e
+                    );
                 }
             }
             SignError::Aggregator(e) => {
-                warn!("Received an aggregator error: {:?}", e);
+                warn!(
+                    "Signer #{}: Received an aggregator error: {:?}",
+                    self.signer_id, e
+                );
             }
         }
         // TODO: should reattempt to sign the block here or should we just broadcast a rejection or do nothing and wait for the signers to propose a new block?
@@ -837,10 +934,16 @@ impl<C: Coordinator> RunLoop<C> {
         let nmb_results = operation_results.len();
         match res.send(operation_results) {
             Ok(_) => {
-                debug!("Successfully sent {} operation result(s)", nmb_results)
+                debug!(
+                    "Signer #{}: Successfully sent {} operation result(s)",
+                    self.signer_id, nmb_results
+                )
             }
             Err(e) => {
-                warn!("Failed to send operation results: {:?}", e);
+                warn!(
+                    "Signer #{}: Failed to send {} operation results: {:?}",
+                    self.signer_id, nmb_results, e
+                );
             }
         }
     }
@@ -848,15 +951,19 @@ impl<C: Coordinator> RunLoop<C> {
     /// Sending all provided packets through stackerdb with a retry
     fn send_outbound_messages(&mut self, outbound_messages: Vec<Packet>) {
         debug!(
-            "Sending {} messages to other stacker-db instances.",
+            "Signer #{}: Sending {} messages to other stacker-db instances.",
+            self.signer_id,
             outbound_messages.len()
         );
         for msg in outbound_messages {
             let ack = self.stackerdb.send_message_with_retry(msg.into());
             if let Ok(ack) = ack {
-                debug!("ACK: {:?}", ack);
+                debug!("Signer #{}: send outbound ACK: {:?}", self.signer_id, ack);
             } else {
-                warn!("Failed to send message to stacker-db instance: {:?}", ack);
+                warn!(
+                    "Signer #{}: Failed to send message to stacker-db instance: {:?}",
+                    self.signer_id, ack
+                );
             }
         }
     }
@@ -972,26 +1079,37 @@ impl<C: Coordinator> SignerRunLoop<Vec<OperationResult>, RunLoopCommand> for Run
                 .expect("Failed to connect to initialize due to timeout. Stacks node may be down.");
         }
         // Process any arrived events
-        debug!("Processing event: {:?}", event);
+        debug!("Signer #{}: Processing event: {:?}", self.signer_id, event);
         match event {
             Some(SignerEvent::BlockValidationResponse(block_validate_response)) => {
-                debug!("Received a block proposal result from the stacks node...");
+                debug!(
+                    "Signer #{}: Received a block proposal result from the stacks node...",
+                    self.signer_id
+                );
                 self.handle_block_validate_response(block_validate_response, res)
             }
             Some(SignerEvent::SignerMessages(messages)) => {
-                debug!("Received messages from the other signers...");
+                debug!(
+                    "Signer #{}: Received {} messages from the other signers...",
+                    self.signer_id,
+                    messages.len()
+                );
                 self.handle_signer_messages(res, messages);
             }
             Some(SignerEvent::ProposedBlocks(blocks)) => {
-                debug!("Received block proposals from the miners...");
+                debug!(
+                    "Signer #{}: Received {} block proposals from the miners...",
+                    self.signer_id,
+                    blocks.len()
+                );
                 self.handle_proposed_blocks(blocks);
             }
             Some(SignerEvent::StatusCheck) => {
-                debug!("Received a status check event.")
+                debug!("Signer #{}: Received a status check event.", self.signer_id)
             }
             None => {
                 // No event. Do nothing.
-                debug!("No event received")
+                debug!("Signer #{}: No event received", self.signer_id)
             }
         }
 

From 91106d4986bfe7f1c23354d6dd60cc119f79200e Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Wed, 7 Feb 2024 01:33:30 -0500
Subject: [PATCH 0689/1166] chore: use the right .signers-(0|1)-xxx contract to
 look for signer-written data

---
 .../stacks-node/src/nakamoto_node/miner.rs    | 23 ++++++++++++++-----
 1 file changed, 17 insertions(+), 6 deletions(-)

diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index bd78df0491..e809154f6a 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -22,15 +22,14 @@ use clarity::boot_util::boot_code_id;
 use clarity::vm::types::PrincipalData;
 use hashbrown::HashSet;
 use libsigner::{
-    BlockResponse, RejectCode, SignerMessage, SignerSession, StackerDBSession, BLOCK_SLOT_ID,
-    SIGNER_SLOTS_PER_USER,
+    BlockResponse, RejectCode, SignerMessage, SignerSession, StackerDBSession, BLOCK_MSG_ID,
 };
 use stacks::burnchains::{Burnchain, BurnchainParameters};
 use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::burn::{BlockSnapshot, ConsensusHash};
 use stacks::chainstate::nakamoto::miner::{NakamotoBlockBuilder, NakamotoTenureInfo};
 use stacks::chainstate::nakamoto::{NakamotoBlock, NakamotoChainState};
-use stacks::chainstate::stacks::boot::{MINERS_NAME, SIGNERS_NAME};
+use stacks::chainstate::stacks::boot::{make_signers_db_name, MINERS_NAME};
 use stacks::chainstate::stacks::db::{StacksChainState, StacksHeaderInfo};
 use stacks::chainstate::stacks::{
     CoinbasePayload, Error as ChainstateError, StacksTransaction, StacksTransactionSigner,
@@ -265,8 +264,17 @@ impl BlockMinerThread {
         let stackerdb_contracts = stackerdbs
             .get_stackerdb_contract_ids()
             .expect("FATAL: could not get the stacker DB contract ids");
-        // TODO: get this directly instead of this jankiness when .signers is a boot contract
-        let signers_contract_id = boot_code_id(SIGNERS_NAME, self.config.is_mainnet());
+
+        let reward_cycle = u32::try_from(
+            self.burnchain
+                .block_height_to_reward_cycle(self.burn_block.block_height)
+                .expect("FATAL: no reward cycle for burn block"),
+        )
+        .expect("FATAL: too many reward cycles");
+        let signers_contract_id = boot_code_id(
+            &make_signers_db_name(reward_cycle % 2, BLOCK_MSG_ID),
+            self.config.is_mainnet(),
+        );
         if !stackerdb_contracts.contains(&signers_contract_id) {
             return Err(NakamotoNodeError::SignerSignatureError(
                 "No signers contract found, cannot wait for signers",
@@ -278,8 +286,11 @@ impl BlockMinerThread {
             .expect("FATAL: could not get signers from stacker DB")
             .iter()
             .enumerate()
-            .map(|(id, _)| id as u32 * SIGNER_SLOTS_PER_USER + BLOCK_SLOT_ID)
+            .map(|(id, _)| {
+                u32::try_from(id).expect("FATAL: too many signers to fit into u32 range")
+            })
             .collect::<Vec<u32>>();
+
         // If more than a threshold percentage of the signers reject the block, we should not wait any further
         let rejection_threshold = slot_ids.len() / 10 * 7;
         let mut rejections = HashSet::new();

From 153fb4b01b61cab511f1a82ddceee59459e9d54a Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Wed, 7 Feb 2024 01:33:52 -0500
Subject: [PATCH 0690/1166] chore: fix failing signer tests

---
 testnet/stacks-node/src/tests/signer.rs | 91 ++++++++++++++++++-------
 1 file changed, 66 insertions(+), 25 deletions(-)

diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index 6e6bf02cee..881fd931c7 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -7,10 +7,9 @@ use std::time::{Duration, Instant};
 use std::{env, thread};
 
 use clarity::boot_util::boot_code_id;
-use clarity::vm::types::QualifiedContractIdentifier;
 use libsigner::{
     BlockResponse, RejectCode, RunningSigner, Signer, SignerEventReceiver, SignerMessage,
-    BLOCK_SLOT_ID,
+    BLOCK_MSG_ID, TRANSACTIONS_MSG_ID,
 };
 use stacks::chainstate::coordinator::comm::CoordinatorChannels;
 use stacks::chainstate::nakamoto::{NakamotoBlock, NakamotoBlockHeader};
@@ -47,7 +46,7 @@ use crate::run_loop::boot_nakamoto;
 use crate::tests::bitcoin_regtest::BitcoinCoreController;
 use crate::tests::nakamoto_integrations::{
     boot_to_epoch_3, naka_neon_integration_conf, next_block_and, next_block_and_mine_commit,
-    setup_stacker, POX_4_DEFAULT_STACKER_BALANCE,
+    POX_4_DEFAULT_STACKER_BALANCE,
 };
 use crate::tests::neon_integrations::{next_block_and_wait, test_observer, wait_for_runloop};
 use crate::tests::to_addr;
@@ -82,6 +81,8 @@ struct SignerTest {
     pub running_signers: HashMap<u32, RunningSigner<SignerEventReceiver, Vec<OperationResult>>>,
     // the private keys of the signers
     pub signer_stacks_private_keys: Vec<StacksPrivateKey>,
+    // link to the stacks node
+    pub stacks_client: StacksClient,
 }
 
 impl SignerTest {
@@ -156,6 +157,7 @@ impl SignerTest {
             running_coordinator,
             running_signers,
             signer_stacks_private_keys,
+            stacks_client,
         }
     }
 
@@ -645,12 +647,16 @@ fn stackerdb_block_proposal() {
 
         let nakamoto_blocks = test_observer::get_stackerdb_chunks();
         for event in nakamoto_blocks {
-            // Only care about the miners block slot
-            for slot in event.modified_slots {
-                if slot.slot_id == BLOCK_SLOT_ID {
+            if event.contract_id.name == format!("signers-1-{}", BLOCK_MSG_ID).as_str().into()
+                || event.contract_id.name == format!("signers-0-{}", BLOCK_MSG_ID).as_str().into()
+            {
+                for slot in event.modified_slots {
                     chunk = Some(slot.data);
                     break;
                 }
+                if chunk.is_some() {
+                    break;
+                }
             }
             if chunk.is_some() {
                 break;
@@ -712,27 +718,53 @@ fn stackerdb_block_proposal_missing_transactions() {
         .unwrap()
         .next()
         .unwrap();
-    let signer_stacker_db = signer_test
+    let signer_stacker_db_1 = signer_test
         .running_nodes
         .conf
         .node
         .stacker_dbs
         .iter()
-        .find(|id| id.name.to_string() == SIGNERS_NAME)
+        .find(|id| id.name.to_string() == make_signers_db_name(1, TRANSACTIONS_MSG_ID))
         .unwrap()
         .clone();
+
     let signer_id = 0;
-    let signer_private_key = signer_test
+
+    let signer_addresses_1: Vec<_> = signer_test
+        .stacks_client
+        .get_stackerdb_signer_slots(&boot_code_id(SIGNERS_NAME, false), 1)
+        .unwrap()
+        .into_iter()
+        .map(|(address, _)| address)
+        .collect();
+
+    let signer_address_1 = signer_addresses_1.get(signer_id).cloned().unwrap();
+
+    let signer_private_key_1 = signer_test
         .signer_stacks_private_keys
-        .get(signer_id)
-        .expect("Cannot find signer private key for signer id 0")
-        .clone();
-    let mut stackerdb = StackerDB::new(host, signer_stacker_db, signer_private_key, 0);
+        .iter()
+        .find(|pk| {
+            let addr = StacksAddress::p2pkh(false, &StacksPublicKey::from_private(pk));
+            addr == signer_address_1
+        })
+        .cloned()
+        .expect("Cannot find signer private key for signer id 1");
+
+    let mut stackerdb_1 = StackerDB::new(host, signer_stacker_db_1, signer_private_key_1, 0);
+
+    stackerdb_1.set_signer_set(1);
+
+    debug!("Signer address is {}", &signer_address_1);
+    assert_eq!(
+        signer_address_1,
+        StacksAddress::p2pkh(false, &StacksPublicKey::from_private(&signer_private_key_1))
+    );
+
     // Create a valid transaction signed by the signer private key coresponding to the slot into which it is being inserted (signer id 0)
     let mut valid_tx = StacksTransaction {
         version: TransactionVersion::Testnet,
-        chain_id: 0,
-        auth: TransactionAuth::from_p2pkh(&signer_private_key).unwrap(),
+        chain_id: 0x80000000,
+        auth: TransactionAuth::from_p2pkh(&signer_private_key_1).unwrap(),
         anchor_mode: TransactionAnchorMode::Any,
         post_condition_mode: TransactionPostConditionMode::Allow,
         post_conditions: vec![],
@@ -744,11 +776,18 @@ fn stackerdb_block_proposal_missing_transactions() {
             None,
         ),
     };
-    valid_tx.set_origin_nonce(0);
+    valid_tx.set_origin_nonce(2);
 
     // Create a transaction signed by a different private key
     // This transaction will be invalid as it is signed by a non signer private key
     let invalid_signer_private_key = StacksPrivateKey::new();
+    debug!(
+        "Invalid address is {}",
+        &StacksAddress::p2pkh(
+            false,
+            &StacksPublicKey::from_private(&invalid_signer_private_key)
+        )
+    );
     let mut invalid_tx = StacksTransaction {
         version: TransactionVersion::Testnet,
         chain_id: 0,
@@ -793,12 +832,12 @@ fn stackerdb_block_proposal_missing_transactions() {
     }
 
     // Following stacker DKG, submit transactions to stackerdb for the signers to pick up during block verification
-    stackerdb
+    stackerdb_1
         .send_message_with_retry(SignerMessage::Transactions(vec![
             valid_tx.clone(),
-            invalid_tx,
+            invalid_tx.clone(),
         ]))
-        .expect("Failed to write expected transactions to stackerdb");
+        .expect("Failed to write expected transactions to stackerdb_1");
 
     let (vrfs_submitted, commits_submitted) = (
         signer_test.running_nodes.vrfs_submitted.clone(),
@@ -852,14 +891,16 @@ fn stackerdb_block_proposal_missing_transactions() {
         let nakamoto_blocks = test_observer::get_stackerdb_chunks();
         for event in nakamoto_blocks {
             // Only care about the miners block slot
-            for slot in event.modified_slots {
-                if slot.slot_id == BLOCK_SLOT_ID {
+            if event.contract_id.name == format!("signers-1-{}", BLOCK_MSG_ID).as_str().into()
+                || event.contract_id.name == format!("signers-0-{}", BLOCK_MSG_ID).as_str().into()
+            {
+                for slot in event.modified_slots {
                     chunk = Some(slot.data);
                     break;
                 }
-            }
-            if chunk.is_some() {
-                break;
+                if chunk.is_some() {
+                    break;
+                }
             }
         }
         thread::sleep(Duration::from_secs(1));
@@ -874,7 +915,7 @@ fn stackerdb_block_proposal_missing_transactions() {
             panic!("Received unexpected rejection reason");
         }
     } else {
-        panic!("Received unexpected message");
+        panic!("Received unexpected message: {:?}", &signer_message);
     }
     signer_test.shutdown();
 }

From ba09ebbbb90dc39ba4beb78d53d034c25c095e69 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Wed, 7 Feb 2024 11:40:51 -0500
Subject: [PATCH 0691/1166] chore: fix CI build issue

---
 stacks-signer/src/client/stacks_client.rs | 3 +--
 stacks-signer/src/main.rs                 | 6 ++----
 stacks-signer/src/runloop.rs              | 2 +-
 3 files changed, 4 insertions(+), 7 deletions(-)

diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index 77a0c5bae1..0ac7f67d7a 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -488,8 +488,7 @@ mod tests {
     use std::io::{BufWriter, Write};
     use std::thread::spawn;
 
-    use libsigner::SIGNER_SLOTS_PER_USER;
-    use stacks_common::consts::CHAIN_ID_TESTNET;
+    use stacks_common::consts::{CHAIN_ID_TESTNET, SIGNER_SLOTS_PER_USER};
     use wsts::curve::scalar::Scalar;
 
     use super::*;
diff --git a/stacks-signer/src/main.rs b/stacks-signer/src/main.rs
index 934d599f51..d437fa1104 100644
--- a/stacks-signer/src/main.rs
+++ b/stacks-signer/src/main.rs
@@ -36,13 +36,11 @@ use std::time::Duration;
 use blockstack_lib::chainstate::nakamoto::NakamotoBlock;
 use clap::Parser;
 use clarity::vm::types::QualifiedContractIdentifier;
-use libsigner::{
-    RunningSigner, Signer, SignerEventReceiver, SignerSession, StackerDBSession,
-    SIGNER_SLOTS_PER_USER,
-};
+use libsigner::{RunningSigner, Signer, SignerEventReceiver, SignerSession, StackerDBSession};
 use libstackerdb::StackerDBChunkData;
 use slog::{slog_debug, slog_error};
 use stacks_common::codec::read_next;
+use stacks_common::consts::SIGNER_SLOTS_PER_USER;
 use stacks_common::types::chainstate::{StacksAddress, StacksPrivateKey};
 use stacks_common::{debug, error};
 use stacks_signer::cli::{
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 10e60ab876..7d4a3e9a93 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -1175,11 +1175,11 @@ mod tests {
     use blockstack_lib::util_lib::boot::boot_code_addr;
     use clarity::vm::types::{ResponseData, TupleData};
     use clarity::vm::{ClarityName, Value as ClarityValue};
-    use libsigner::SIGNER_SLOTS_PER_USER;
     use rand::distributions::Standard;
     use rand::Rng;
     use serial_test::serial;
     use stacks_common::bitvec::BitVec;
+    use stacks_common::consts::SIGNER_SLOTS_PER_USER;
     use stacks_common::types::chainstate::{
         ConsensusHash, StacksBlockId, StacksPrivateKey, TrieHash,
     };

From 4435e0b16734fde656b7c8b12ee6fbc2d164246c Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Wed, 7 Feb 2024 12:48:06 -0500
Subject: [PATCH 0692/1166] chore: fix failing api tests

---
 stackslib/src/net/api/tests/mod.rs    | 24 ++++++++++--------------
 stackslib/src/net/stackerdb/config.rs | 10 ++++------
 stackslib/src/net/stackerdb/mod.rs    |  1 -
 3 files changed, 14 insertions(+), 21 deletions(-)

diff --git a/stackslib/src/net/api/tests/mod.rs b/stackslib/src/net/api/tests/mod.rs
index 2aa2d8dfcb..e58c56562e 100644
--- a/stackslib/src/net/api/tests/mod.rs
+++ b/stackslib/src/net/api/tests/mod.rs
@@ -110,21 +110,17 @@ const TEST_CONTRACT: &'static str = "
 
     (define-public (do-test) (ok u0))
 
-    (define-read-only (stackerdb-get-page-count) (ok u1))
-
     ;; stacker DB
-    (define-read-only (stackerdb-get-signer-slots (page uint))
-        (if (is-eq page u0)
-            (ok (list
-              {
-                signer: 'ST2DS4MSWSGJ3W9FBC6BVT0Y92S345HY8N3T6AV7R,
-                num-slots: u3
-              }
-              {
-                signer: 'STVN97YYA10MY5F6KQJHKNYJNM24C4A1AT39WRW,
-                num-slots: u3
-              }))
-            (err u1)))
+    (define-read-only (stackerdb-get-signer-slots)
+        (ok (list
+          {
+            signer: 'ST2DS4MSWSGJ3W9FBC6BVT0Y92S345HY8N3T6AV7R,
+            num-slots: u3
+          }
+          {
+            signer: 'STVN97YYA10MY5F6KQJHKNYJNM24C4A1AT39WRW,
+            num-slots: u3
+          })))
 
     (define-read-only (stackerdb-get-config)
         (ok {
diff --git a/stackslib/src/net/stackerdb/config.rs b/stackslib/src/net/stackerdb/config.rs
index cd730878b1..0495284317 100644
--- a/stackslib/src/net/stackerdb/config.rs
+++ b/stackslib/src/net/stackerdb/config.rs
@@ -54,10 +54,7 @@ use stacks_common::types::net::PeerAddress;
 use stacks_common::types::StacksEpochId;
 use stacks_common::util::hash::Hash160;
 
-use super::{
-    STACKERDB_MAX_PAGE_COUNT, STACKERDB_PAGE_COUNT_FUNCTION, STACKERDB_PAGE_LIST_MAX,
-    STACKERDB_SLOTS_FUNCTION,
-};
+use super::{STACKERDB_MAX_PAGE_COUNT, STACKERDB_PAGE_LIST_MAX, STACKERDB_SLOTS_FUNCTION};
 use crate::chainstate::burn::db::sortdb::SortitionDB;
 use crate::chainstate::nakamoto::NakamotoChainState;
 use crate::chainstate::stacks::db::StacksChainState;
@@ -146,8 +143,9 @@ impl StackerDBConfig {
 
             if func.args.len() != expected_args.len() {
                 let reason = format!(
-                    "Function '{name}' has an invalid signature: it must have {} args",
-                    expected_args.len()
+                    "Function '{name}' has an invalid signature: it must have {} args (got {})",
+                    expected_args.len(),
+                    func.args.len(),
                 );
                 return Err(reason);
             }
diff --git a/stackslib/src/net/stackerdb/mod.rs b/stackslib/src/net/stackerdb/mod.rs
index 89d5d422a7..726e5eff3e 100644
--- a/stackslib/src/net/stackerdb/mod.rs
+++ b/stackslib/src/net/stackerdb/mod.rs
@@ -149,7 +149,6 @@ pub const STACKERDB_PAGE_LIST_MAX: u32 = 4096;
 /// maximum number of pages that can be used in a StackerDB contract
 pub const STACKERDB_MAX_PAGE_COUNT: u32 = 2;
 
-pub const STACKERDB_PAGE_COUNT_FUNCTION: &str = "stackerdb-get-page-count";
 pub const STACKERDB_SLOTS_FUNCTION: &str = "stackerdb-get-signer-slots";
 pub const STACKERDB_CONFIG_FUNCTION: &str = "stackerdb-get-config";
 

From 60abb0434fbb07f7cca2f20abbcb33fb49f991d6 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Wed, 7 Feb 2024 13:52:17 -0500
Subject: [PATCH 0693/1166] chore: address PR feedback

---
 stacks-signer/src/runloop.rs                     |  9 +++++----
 stackslib/src/chainstate/nakamoto/signer_set.rs  |  2 +-
 .../src/chainstate/stacks/boot/signers.clar      |  2 +-
 testnet/stacks-node/src/nakamoto_node/miner.rs   | 16 +++++++++-------
 testnet/stacks-node/src/tests/signer.rs          |  2 +-
 5 files changed, 17 insertions(+), 14 deletions(-)

diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 7d4a3e9a93..757f6b63c1 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -163,11 +163,12 @@ impl<C: Coordinator> RunLoop<C> {
         let signer_set = if let Some(signer_set) = self.signer_set.as_ref() {
             *signer_set
         } else {
-            let rc = u32::try_from(self.stacks_client.get_current_reward_cycle()?)
-                .expect("FATAL: reward cycle exceeds u32::MAX")
-                + 1;
+            let rc = self
+                .stacks_client
+                .get_current_reward_cycle()?
+                .saturating_add(1);
             debug!("Next reward cycle is {}", rc);
-            let signer_set = rc % 2;
+            let signer_set = u32::try_from(rc % 2).expect("FATAL: infallible");
             self.signer_set = Some(signer_set);
             self.stackerdb.set_signer_set(signer_set);
             signer_set
diff --git a/stackslib/src/chainstate/nakamoto/signer_set.rs b/stackslib/src/chainstate/nakamoto/signer_set.rs
index 0cf70f391f..b23b607f00 100644
--- a/stackslib/src/chainstate/nakamoto/signer_set.rs
+++ b/stackslib/src/chainstate/nakamoto/signer_set.rs
@@ -317,7 +317,7 @@ impl NakamotoSigners {
                         )?;
                         env.execute_contract_allow_private(
                             &signers_contract,
-                            "stackerdb-set-signers",
+                            "set-signers",
                             &set_signers_args,
                             false,
                         )
diff --git a/stackslib/src/chainstate/stacks/boot/signers.clar b/stackslib/src/chainstate/stacks/boot/signers.clar
index 14f8edaa7d..098ab417ad 100644
--- a/stackslib/src/chainstate/stacks/boot/signers.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers.clar
@@ -24,7 +24,7 @@
 
 ;; Called internally by te Stacks node.
 ;; Sets the list of signers and weights for a given reward cycle.
-(define-private (stackerdb-set-signers
+(define-private (set-signers
                  (reward-cycle uint)
                  (signers (list 4000 { signer: principal, weight: uint })))
      (begin
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index e809154f6a..e4a12c3c76 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -265,14 +265,16 @@ impl BlockMinerThread {
             .get_stackerdb_contract_ids()
             .expect("FATAL: could not get the stacker DB contract ids");
 
-        let reward_cycle = u32::try_from(
-            self.burnchain
-                .block_height_to_reward_cycle(self.burn_block.block_height)
-                .expect("FATAL: no reward cycle for burn block"),
-        )
-        .expect("FATAL: too many reward cycles");
+        let reward_cycle = self
+            .burnchain
+            .block_height_to_reward_cycle(self.burn_block.block_height)
+            .expect("FATAL: no reward cycle for burn block");
+
         let signers_contract_id = boot_code_id(
-            &make_signers_db_name(reward_cycle % 2, BLOCK_MSG_ID),
+            &make_signers_db_name(
+                u32::try_from(reward_cycle % 2).expect("FATAL: infallible"),
+                BLOCK_MSG_ID,
+            ),
             self.config.is_mainnet(),
         );
         if !stackerdb_contracts.contains(&signers_contract_id) {
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index 881fd931c7..e00e360c6b 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -93,7 +93,7 @@ impl SignerTest {
             .collect::<Vec<StacksPrivateKey>>();
 
         // Build the stackerdb signers contract
-        let signers_stacker_db_contract_id = boot_code_id("signers".into(), false);
+        let signers_stacker_db_contract_id = boot_code_id(SIGNERS_NAME.into(), false);
 
         let (naka_conf, _miner_account) = naka_neon_integration_conf(None);
 

From 195ab342e4558c1da94ccc00c32a8b56f265ddce Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Wed, 7 Feb 2024 14:49:25 -0500
Subject: [PATCH 0694/1166] chore: fix failing tests

---
 stackslib/src/chainstate/nakamoto/mod.rs      |  3 +-
 .../chainstate/stacks/boot/signers_tests.rs   |  4 +--
 stackslib/src/net/stackerdb/mod.rs            |  2 +-
 stackslib/src/net/stackerdb/tests/config.rs   | 30 ++-----------------
 4 files changed, 7 insertions(+), 32 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index 8169aefd34..4d197e11cb 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -2511,7 +2511,8 @@ impl NakamotoChainState {
                 Self::calculate_matured_miner_rewards(
                     &mut clarity_tx,
                     sortition_dbconn.sqlite_conn(),
-                    coinbase_height + 1,
+                    // coinbase_height + 1,
+                    coinbase_height,
                     matured_rewards_schedule,
                 )
             })
diff --git a/stackslib/src/chainstate/stacks/boot/signers_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_tests.rs
index f0ba773f64..9ca8fb0565 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_tests.rs
@@ -184,7 +184,7 @@ fn signers_get_config() {
             TupleData::from_data(vec![
                 ("chunk-size".into(), Value::UInt(2 * 1024 * 1024)),
                 ("write-freq".into(), Value::UInt(0)),
-                ("max-writes".into(), Value::UInt(u128::MAX)),
+                ("max-writes".into(), Value::UInt(u32::MAX.into())),
                 ("max-neighbors".into(), Value::UInt(32)),
                 (
                     "hint-replicas".into(),
@@ -212,7 +212,7 @@ fn signers_get_config() {
                     TupleData::from_data(vec![
                         ("chunk-size".into(), Value::UInt(2 * 1024 * 1024)),
                         ("write-freq".into(), Value::UInt(0)),
-                        ("max-writes".into(), Value::UInt(u128::MAX)),
+                        ("max-writes".into(), Value::UInt(u32::MAX.into())),
                         ("max-neighbors".into(), Value::UInt(32)),
                         (
                             "hint-replicas".into(),
diff --git a/stackslib/src/net/stackerdb/mod.rs b/stackslib/src/net/stackerdb/mod.rs
index 726e5eff3e..8d54c0dee0 100644
--- a/stackslib/src/net/stackerdb/mod.rs
+++ b/stackslib/src/net/stackerdb/mod.rs
@@ -143,7 +143,7 @@ use crate::util_lib::boot::boot_code_id;
 use crate::util_lib::db::{DBConn, DBTx, Error as db_error};
 
 /// maximum chunk inventory size
-pub const STACKERDB_INV_MAX: u32 = 2 * 4000 * SIGNER_SLOTS_PER_USER;
+pub const STACKERDB_INV_MAX: u32 = 4096;
 /// maximum length of an inventory page's Clarity list
 pub const STACKERDB_PAGE_LIST_MAX: u32 = 4096;
 /// maximum number of pages that can be used in a StackerDB contract
diff --git a/stackslib/src/net/stackerdb/tests/config.rs b/stackslib/src/net/stackerdb/tests/config.rs
index aea894c057..9600ed79a8 100644
--- a/stackslib/src/net/stackerdb/tests/config.rs
+++ b/stackslib/src/net/stackerdb/tests/config.rs
@@ -122,11 +122,9 @@ fn test_valid_and_invalid_stackerdb_configs() {
         (
             // valid
             r#"
-            (define-public (stackerdb-get-signer-slots (page uint))
+            (define-public (stackerdb-get-signer-slots)
                 (ok (list { signer: 'ST2TFVBMRPS5SSNP98DQKQ5JNB2B6NZM91C4K3P7B, num-slots: u3 })))
 
-            (define-public (stackerdb-get-page-count) (ok u1))
-
             (define-public (stackerdb-get-config)
                 (ok {
                     chunk-size: u123,
@@ -165,11 +163,9 @@ fn test_valid_and_invalid_stackerdb_configs() {
         (
             // valid
             r#"
-            (define-read-only (stackerdb-get-signer-slots (page uint))
+            (define-read-only (stackerdb-get-signer-slots)
                 (ok (list { signer: 'ST2TFVBMRPS5SSNP98DQKQ5JNB2B6NZM91C4K3P7B, num-slots: u3 })))
 
-            (define-public (stackerdb-get-page-count) (ok u1))
-
             (define-read-only (stackerdb-get-config)
                 (ok {
                     chunk-size: u123,
@@ -205,28 +201,6 @@ fn test_valid_and_invalid_stackerdb_configs() {
                 max_neighbors: 7,
             }),
         ),
-        (
-            // valid
-            r#"
-            (define-read-only (stackerdb-get-signer-slots (page uint))
-                (ok (list { signer: 'ST2TFVBMRPS5SSNP98DQKQ5JNB2B6NZM91C4K3P7B, num-slots: u3 })))
-
-            (define-read-only (stackerdb-get-config)
-                (ok {
-                    chunk-size: u123,
-                    write-freq: u4,
-                    max-writes: u56,
-                    max-neighbors: u7,
-                    hint-replicas: (list
-                        {
-                            addr: (list u0 u0 u0 u0 u0 u0 u0 u0 u0 u0 u255 u255 u127 u0 u0 u1),
-                            port: u8901,
-                            public-key-hash: 0x0123456789abcdef0123456789abcdef01234567
-                        })
-                }))
-            "#,
-            None,
-        ),
         (
             // invalid -- missing function
             r#"

From fb4971b0192a180e7ebc5fa8f176ba8b3ae8e865 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Wed, 7 Feb 2024 16:15:17 -0500
Subject: [PATCH 0695/1166] chore: get additional unit tests to pass in the
 signer due to a new mocked initialization

---
 stacks-signer/src/client/stacks_client.rs     |  2 +-
 stacks-signer/src/runloop.rs                  | 12 ++++++---
 .../tests/contracts/signers-stackerdb.clar    | 27 ++++++++++++++++++-
 3 files changed, 36 insertions(+), 5 deletions(-)

diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index 0ac7f67d7a..f954b67293 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -282,7 +282,7 @@ impl StacksClient {
         &self,
         value: ClarityValue,
     ) -> Result<Vec<(StacksAddress, u128)>, ClientError> {
-        debug!("Parsing signer slots...");
+        debug!("Parsing signer slots from {:?}", &value);
         // Due to .signers definition, the  signer slots is always an OK result of a list of tuples of signer addresses and the number of slots they have
         // If this fails, we have bigger problems than the signer crashing...
         let value = value.clone().expect_result_ok()?;
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 757f6b63c1..eef7caa907 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -1362,10 +1362,16 @@ mod tests {
             current_reward_cycle_response.as_bytes(),
         );
         let test_config = TestConfig::from_config(config.clone());
-        write_response(test_config.mock_server, aggregate_key_response.as_bytes());
-
-        let test_config = TestConfig::from_config(config);
         write_response(test_config.mock_server, signer_slots_response.as_bytes());
+
+        let test_config = TestConfig::from_config(config.clone());
+        write_response(
+            test_config.mock_server,
+            current_reward_cycle_response.as_bytes(),
+        );
+
+        let test_config = TestConfig::from_config(config.clone());
+        write_response(test_config.mock_server, aggregate_key_response.as_bytes());
     }
 
     fn simulate_nonce_response(config: &Config, num_transactions: usize) {
diff --git a/stacks-signer/src/tests/contracts/signers-stackerdb.clar b/stacks-signer/src/tests/contracts/signers-stackerdb.clar
index 8149328487..9f113eaf8a 100644
--- a/stacks-signer/src/tests/contracts/signers-stackerdb.clar
+++ b/stacks-signer/src/tests/contracts/signers-stackerdb.clar
@@ -1,3 +1,28 @@
+        ;; stacker DB
+        (define-read-only (stackerdb-get-signer-slots-page (page-id uint))
+            (ok (list
+                {
+                    signer: 'ST24GDPTR7D9G3GFRR233JMWSD9HA296EXXG5XVGA,
+                    num-slots: u10
+                }
+                {
+                    signer: 'ST1MR26HR7MMDE847BE2QC1CTNQY4WKN9XDKNPEP3,
+                    num-slots: u10
+                }
+                {
+                    signer: 'ST110M4DRDXX2RF3W8EY1HCRQ25CS24PGY22DZ004,
+                    num-slots: u10
+                }
+                {
+                    signer: 'ST69990VH3BVCV39QWT6CJAVVA9QPB1715HTSN75,
+                    num-slots: u10
+                }
+                {
+                    signer: 'STCZSBZJK6C3MMAAW9N9RHSDKRKB9AKGJ2JMVDKN,
+                    num-slots: u10
+                }
+                )))
+        
         ;; stacker DB
         (define-read-only (stackerdb-get-signer-slots)
             (ok (list
@@ -31,4 +56,4 @@
                 max-neighbors: u32,
                 hint-replicas: (list )
             }))
-    
\ No newline at end of file
+    

From 2d4d9bdaa3860f03906f8458c5786ff7595fa86a Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Fri, 2 Feb 2024 14:38:50 -0500
Subject: [PATCH 0696/1166] chore: Remove unused variables found by
 `clippy::collection_is_never_read`

---
 stackslib/src/burnchains/burnchain.rs              | 2 --
 stackslib/src/chainstate/stacks/db/transactions.rs | 4 ++--
 stackslib/src/main.rs                              | 6 ------
 stackslib/src/net/inv/epoch2x.rs                   | 3 ---
 4 files changed, 2 insertions(+), 13 deletions(-)

diff --git a/stackslib/src/burnchains/burnchain.rs b/stackslib/src/burnchains/burnchain.rs
index d4d936b332..5b5fd5a889 100644
--- a/stackslib/src/burnchains/burnchain.rs
+++ b/stackslib/src/burnchains/burnchain.rs
@@ -103,7 +103,6 @@ impl BurnchainStateTransition {
     ) -> Result<BurnchainStateTransition, burnchain_error> {
         // block commits and support burns discovered in this block.
         let mut block_commits: Vec<LeaderBlockCommitOp> = vec![];
-        let mut user_burns: Vec<UserBurnSupportOp> = vec![];
         let mut accepted_ops = Vec::with_capacity(block_ops.len());
 
         assert!(Burnchain::ops_are_sorted(block_ops));
@@ -141,7 +140,6 @@ impl BurnchainStateTransition {
                     // we don't know yet which user burns are going to be accepted until we have
                     // the burn distribution, so just account for them for now.
                     all_user_burns.insert(op.txid.clone(), op.clone());
-                    user_burns.push(op.clone());
                 }
             };
         }
diff --git a/stackslib/src/chainstate/stacks/db/transactions.rs b/stackslib/src/chainstate/stacks/db/transactions.rs
index 78a5ccea39..0c13137444 100644
--- a/stackslib/src/chainstate/stacks/db/transactions.rs
+++ b/stackslib/src/chainstate/stacks/db/transactions.rs
@@ -88,8 +88,8 @@ impl StacksTransactionReceipt {
         cost: ExecutionCost,
     ) -> StacksTransactionReceipt {
         StacksTransactionReceipt {
-            events: events,
-            result: result,
+            events,
+            result,
             stx_burned: 0,
             post_condition_aborted: false,
             contract_analysis: None,
diff --git a/stackslib/src/main.rs b/stackslib/src/main.rs
index bd060579c6..ff5413fb14 100644
--- a/stackslib/src/main.rs
+++ b/stackslib/src/main.rs
@@ -1212,7 +1212,6 @@ simulating a miner.
             }
 
             // process all new blocks
-            let mut epoch_receipts = vec![];
             loop {
                 let sortition_tip =
                     SortitionDB::get_canonical_burn_chain_tip(new_sortition_db.conn())
@@ -1231,11 +1230,6 @@ simulating a miner.
                 if receipts.len() == 0 {
                     break;
                 }
-                for (epoch_receipt_opt, _) in receipts.into_iter() {
-                    if let Some(epoch_receipt) = epoch_receipt_opt {
-                        epoch_receipts.push(epoch_receipt);
-                    }
-                }
             }
         }
 
diff --git a/stackslib/src/net/inv/epoch2x.rs b/stackslib/src/net/inv/epoch2x.rs
index 27147f36a5..ff51874279 100644
--- a/stackslib/src/net/inv/epoch2x.rs
+++ b/stackslib/src/net/inv/epoch2x.rs
@@ -2250,7 +2250,6 @@ impl PeerNetwork {
             );
 
             let mut all_done = true;
-            let mut fully_synced_peers = HashSet::new();
             let mut ibd_diverged_height: Option<u64> = None;
 
             let bootstrap_peers: HashSet<_> =
@@ -2352,8 +2351,6 @@ impl PeerNetwork {
                             network.pox_id.num_inventory_reward_cycles(),
                             &nk
                         );
-
-                        fully_synced_peers.insert(nk.clone());
                     }
                 }
             }

From 456f7092c77248764522c6bb0c69d4104b46c7ba Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Thu, 8 Feb 2024 11:49:03 -0500
Subject: [PATCH 0697/1166] fix: fix #4351

---
 stackslib/src/net/api/getinfo.rs              |  9 ++----
 stackslib/src/net/p2p.rs                      | 31 ++++++++++++-------
 .../src/tests/nakamoto_integrations.rs        | 18 +++++++++--
 3 files changed, 38 insertions(+), 20 deletions(-)

diff --git a/stackslib/src/net/api/getinfo.rs b/stackslib/src/net/api/getinfo.rs
index f83173a44d..ed915db50f 100644
--- a/stackslib/src/net/api/getinfo.rs
+++ b/stackslib/src/net/api/getinfo.rs
@@ -140,12 +140,9 @@ impl RPCPeerInfoData {
             server_version,
             network_id: network.local_peer.network_id,
             parent_network_id: network.local_peer.parent_network_id,
-            stacks_tip_height: network.burnchain_tip.canonical_stacks_tip_height,
-            stacks_tip: network.burnchain_tip.canonical_stacks_tip_hash.clone(),
-            stacks_tip_consensus_hash: network
-                .burnchain_tip
-                .canonical_stacks_tip_consensus_hash
-                .clone(),
+            stacks_tip_height: network.stacks_tip.2,
+            stacks_tip: network.stacks_tip.1.clone(),
+            stacks_tip_consensus_hash: network.stacks_tip.0.clone(),
             unanchored_tip: unconfirmed_tip,
             unanchored_seq: unconfirmed_seq,
             exit_at_block_height: exit_at_block_height,
diff --git a/stackslib/src/net/p2p.rs b/stackslib/src/net/p2p.rs
index f8c51b939a..69a5410874 100644
--- a/stackslib/src/net/p2p.rs
+++ b/stackslib/src/net/p2p.rs
@@ -218,6 +218,7 @@ pub struct PeerNetwork {
     // refreshed whenever the burnchain advances
     pub chain_view: BurnchainView,
     pub burnchain_tip: BlockSnapshot,
+    pub stacks_tip: (ConsensusHash, BlockHeaderHash, u64),
     pub chain_view_stable_consensus_hash: ConsensusHash,
     pub ast_rules: ASTRules,
 
@@ -421,6 +422,7 @@ impl PeerNetwork {
                 &first_burn_header_hash,
                 first_burn_header_ts as u64,
             ),
+            stacks_tip: (ConsensusHash([0x00; 20]), BlockHeaderHash([0x00; 32]), 0),
 
             peerdb: peerdb,
             atlasdb: atlasdb,
@@ -5242,9 +5244,16 @@ impl PeerNetwork {
         ibd: bool,
     ) -> Result<HashMap<NeighborKey, Vec<StacksMessage>>, net_error> {
         // update burnchain snapshot if we need to (careful -- it's expensive)
-        let sn = SortitionDB::get_canonical_burn_chain_tip(&sortdb.conn())?;
+        let sn = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn())?;
+        let stacks_tip =
+            SortitionDB::get_canonical_stacks_chain_tip_hash_and_height(sortdb.conn())?;
+
+        let burnchain_tip_changed = sn.block_height != self.chain_view.burn_block_height;
+        let stacks_tip_changed = self.stacks_tip != stacks_tip;
         let mut ret: HashMap<NeighborKey, Vec<StacksMessage>> = HashMap::new();
-        if sn.block_height != self.chain_view.burn_block_height {
+
+        if burnchain_tip_changed || stacks_tip_changed {
+            // only do the needful depending on what changed
             debug!(
                 "{:?}: load chain view for burn block {}",
                 &self.local_peer, sn.block_height
@@ -5263,6 +5272,12 @@ impl PeerNetwork {
                 ancestor_sn.consensus_hash
             };
 
+            // update cached burnchain view for /v2/info
+            self.chain_view = new_chain_view;
+            self.chain_view_stable_consensus_hash = new_chain_view_stable_consensus_hash;
+        }
+
+        if burnchain_tip_changed {
             // wake up the inv-sync and downloader -- we have potentially more sortitions
             self.hint_sync_invs(self.chain_view.burn_stable_block_height);
             self.hint_download_rescan(
@@ -5278,10 +5293,6 @@ impl PeerNetwork {
             self.antientropy_start_reward_cycle =
                 self.pox_id.num_inventory_reward_cycles().saturating_sub(1) as u64;
 
-            // update cached burnchain view for /v2/info
-            self.chain_view = new_chain_view;
-            self.chain_view_stable_consensus_hash = new_chain_view_stable_consensus_hash;
-
             // update tx validation information
             self.ast_rules = SortitionDB::get_ast_rules(sortdb.conn(), sn.block_height)?;
 
@@ -5327,10 +5338,7 @@ impl PeerNetwork {
             self.refresh_stacker_db_configs(sortdb, chainstate)?;
         }
 
-        if sn.canonical_stacks_tip_hash != self.burnchain_tip.canonical_stacks_tip_hash
-            || sn.canonical_stacks_tip_consensus_hash
-                != self.burnchain_tip.canonical_stacks_tip_consensus_hash
-        {
+        if stacks_tip_changed {
             // update stacks tip affirmation map view
             let burnchain_db = self.burnchain.open_burnchain_db(false)?;
             self.stacks_tip_affirmation_map = static_get_stacks_tip_affirmation_map(
@@ -5347,7 +5355,7 @@ impl PeerNetwork {
 
         // can't fail after this point
 
-        if sn.burn_header_hash != self.burnchain_tip.burn_header_hash {
+        if burnchain_tip_changed {
             // try processing previously-buffered messages (best-effort)
             let buffered_messages = mem::replace(&mut self.pending_messages, HashMap::new());
             ret =
@@ -5356,6 +5364,7 @@ impl PeerNetwork {
 
         // update cached stacks chain view for /v2/info
         self.burnchain_tip = sn;
+        self.stacks_tip = stacks_tip;
         Ok(ret)
     }
 
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index c4656febf3..aa14972461 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -46,7 +46,9 @@ use stacks::util_lib::boot::boot_code_id;
 use stacks_common::address::AddressHashMode;
 use stacks_common::codec::StacksMessageCodec;
 use stacks_common::consts::STACKS_EPOCH_MAX;
-use stacks_common::types::chainstate::{StacksAddress, StacksPrivateKey, StacksPublicKey};
+use stacks_common::types::chainstate::{
+    BlockHeaderHash, StacksAddress, StacksPrivateKey, StacksPublicKey,
+};
 use stacks_common::types::PrivateKey;
 use stacks_common::util::hash::{to_hex, Sha512Sum};
 use stacks_common::util::secp256k1::{MessageSignature, Secp256k1PrivateKey};
@@ -57,8 +59,8 @@ use crate::mockamoto::signer::SelfSigner;
 use crate::neon::{Counters, RunLoopCounter};
 use crate::run_loop::boot_nakamoto;
 use crate::tests::neon_integrations::{
-    get_account, get_pox_info, next_block_and_wait, run_until_burnchain_height, submit_tx,
-    test_observer, wait_for_runloop,
+    get_account, get_chain_info_result, get_pox_info, next_block_and_wait,
+    run_until_burnchain_height, submit_tx, test_observer, wait_for_runloop,
 };
 use crate::tests::{make_stacks_transfer, to_addr};
 use crate::{tests, BitcoinRegtestController, BurnchainController, Config, ConfigFile, Keychain};
@@ -729,6 +731,9 @@ fn mine_multiple_per_tenure_integration() {
         next_block_and_process_new_stacks_block(&mut btc_regtest_controller, 60, &coord_channel)
             .unwrap();
 
+        let mut last_tip = BlockHeaderHash([0x00; 32]);
+        let mut last_tip_height = 0;
+
         // mine the interim blocks
         for interim_block_ix in 0..inter_blocks_per_tenure {
             let blocks_processed_before = coord_channel
@@ -751,6 +756,13 @@ fn mine_multiple_per_tenure_integration() {
                 }
                 thread::sleep(Duration::from_millis(100));
             }
+
+            let info = get_chain_info_result(&naka_conf).unwrap();
+            assert_ne!(info.stacks_tip, last_tip);
+            assert_ne!(info.stacks_tip_height, last_tip_height);
+
+            last_tip = info.stacks_tip;
+            last_tip_height = info.stacks_tip_height;
         }
 
         let start_time = Instant::now();

From 2e7d682f62803251a27e2db13c8ecbda3867bbc7 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Thu, 8 Feb 2024 09:18:41 -0800
Subject: [PATCH 0698/1166] fix: use `define_named_enum!` for pox-4 topic

---
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 16 ++++++++--------
 .../src/util_lib/signed_structured_data.rs    | 19 +++++++------------
 2 files changed, 15 insertions(+), 20 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index adad61bb39..99a3db0b72 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -1455,7 +1455,7 @@ fn verify_signer_key_sig(
     latest_block: &StacksBlockId,
     reward_cycle: u128,
     period: u128,
-    topic: &str,
+    topic: &Pox4SignatureTopic,
 ) -> Value {
     let result: Value = with_sortdb(peer, |ref mut chainstate, ref mut sortdb| {
         chainstate
@@ -1473,7 +1473,7 @@ fn verify_signer_key_sig(
                                 "(verify-signer-key-sig {} u{} \"{}\" u{} 0x{} 0x{})",
                                 Value::Tuple(pox_addr.clone().as_clarity_tuple().unwrap()),
                                 reward_cycle,
-                                topic,
+                                topic.get_name_str(),
                                 period,
                                 to_hex(&signature),
                                 signing_key.to_hex(),
@@ -1555,7 +1555,7 @@ fn verify_signer_key_signatures() {
         &latest_block,
         reward_cycle,
         period,
-        topic.as_str(),
+        &topic,
     );
     assert_eq!(result, expected_error);
 
@@ -1571,7 +1571,7 @@ fn verify_signer_key_signatures() {
         &latest_block,
         reward_cycle,
         period,
-        topic.as_str(),
+        &topic,
     );
 
     assert_eq!(result, expected_error);
@@ -1588,7 +1588,7 @@ fn verify_signer_key_signatures() {
         &latest_block,
         reward_cycle,
         period,
-        topic.as_str(),
+        &topic,
     );
 
     assert_eq!(result, expected_error);
@@ -1609,7 +1609,7 @@ fn verify_signer_key_signatures() {
         &latest_block,
         reward_cycle,
         period,
-        Pox4SignatureTopic::StackExtend.as_str(), // different
+        &Pox4SignatureTopic::StackExtend, // different
     );
 
     assert_eq!(result, expected_error);
@@ -1624,7 +1624,7 @@ fn verify_signer_key_signatures() {
         &latest_block,
         reward_cycle,
         period + 1, // different
-        topic.as_str(),
+        &topic,
     );
 
     assert_eq!(result, expected_error);
@@ -1641,7 +1641,7 @@ fn verify_signer_key_signatures() {
         &latest_block,
         reward_cycle,
         period,
-        topic.as_str(),
+        &topic,
     );
 
     assert_eq!(result, Value::okay_true());
diff --git a/stackslib/src/util_lib/signed_structured_data.rs b/stackslib/src/util_lib/signed_structured_data.rs
index dbfb030590..843d684e36 100644
--- a/stackslib/src/util_lib/signed_structured_data.rs
+++ b/stackslib/src/util_lib/signed_structured_data.rs
@@ -82,22 +82,17 @@ pub mod pox4 {
         make_structured_data_domain, structured_data_message_hash, MessageSignature, PoxAddress,
         PrivateKey, Sha256Sum, StacksPrivateKey, TupleData, Value,
     };
-    pub enum Pox4SignatureTopic {
+    define_named_enum!(Pox4SignatureTopic {
+        StackStx("stack-stx"),
+        AggregationCommit("agg-commit"),
+        StackExtend("stack-extend"),
+    });
+    pub enum Pox4SignatureTopicOld {
         StackStx,
         AggregationCommit,
         StackExtend,
     }
 
-    impl Pox4SignatureTopic {
-        pub fn as_str(&self) -> &'static str {
-            match self {
-                Pox4SignatureTopic::StackStx => "stack-stx",
-                Pox4SignatureTopic::AggregationCommit => "agg-commit",
-                Pox4SignatureTopic::StackExtend => "stack-extend",
-            }
-        }
-    }
-
     pub fn make_pox_4_signed_data_domain(chain_id: u32) -> Value {
         make_structured_data_domain("pox-4-signer", "1.0.0", chain_id)
     }
@@ -120,7 +115,7 @@ pub mod pox4 {
                 ("period".into(), Value::UInt(period)),
                 (
                     "topic".into(),
-                    Value::string_ascii_from_bytes(topic.as_str().into()).unwrap(),
+                    Value::string_ascii_from_bytes(topic.get_name_str().into()).unwrap(),
                 ),
             ])
             .unwrap(),

From dbacfd06c2c19f91ed531aeac0723cdb02aec248 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Thu, 8 Feb 2024 09:19:05 -0800
Subject: [PATCH 0699/1166] feat: add unit test for generating pox-4 message
 hash

---
 .../src/util_lib/signed_structured_data.rs    | 177 ++++++++++++++++++
 1 file changed, 177 insertions(+)

diff --git a/stackslib/src/util_lib/signed_structured_data.rs b/stackslib/src/util_lib/signed_structured_data.rs
index 843d684e36..ff6706d4ba 100644
--- a/stackslib/src/util_lib/signed_structured_data.rs
+++ b/stackslib/src/util_lib/signed_structured_data.rs
@@ -146,6 +146,183 @@ pub mod pox4 {
             make_pox_4_signer_key_message_hash(pox_addr, reward_cycle, topic, chain_id, period);
         signer_key.sign(msg_hash.as_bytes())
     }
+
+    #[cfg(test)]
+    mod tests {
+        use clarity::vm::{
+            ast::ASTRules,
+            clarity::{ClarityConnection, TransactionConnection},
+            costs::LimitedCostTracker,
+            types::{PrincipalData, StandardPrincipalData},
+            ClarityVersion,
+        };
+        use stacks_common::{
+            address::AddressHashMode, consts::CHAIN_ID_TESTNET, types::chainstate::StacksAddress,
+            util::secp256k1::Secp256k1PublicKey,
+        };
+
+        use crate::{
+            chainstate::stacks::boot::{contract_tests::ClarityTestSim, POX_4_CODE, POX_4_NAME},
+            util_lib::boot::boot_code_id,
+        };
+
+        use super::*;
+
+        fn call_get_signer_message_hash(
+            sim: &mut ClarityTestSim,
+            pox_addr: &PoxAddress,
+            reward_cycle: u128,
+            topic: &Pox4SignatureTopic,
+            lock_period: u128,
+            sender: &PrincipalData,
+        ) -> Vec<u8> {
+            let pox_contract_id = boot_code_id(POX_4_NAME, false);
+            sim.execute_next_block_as_conn(|conn| {
+                let result = conn.with_readonly_clarity_env(
+                    false,
+                    CHAIN_ID_TESTNET,
+                    ClarityVersion::Clarity2,
+                    sender.clone(),
+                    None,
+                    LimitedCostTracker::new_free(),
+                    |env| {
+                        let program = format!(
+                            "(get-signer-key-message-hash {} u{} \"{}\" u{})",
+                            Value::Tuple(pox_addr.clone().as_clarity_tuple().unwrap()), //p
+                            reward_cycle,
+                            topic.get_name_str(),
+                            lock_period
+                        );
+                        env.eval_read_only(&pox_contract_id, &program)
+                    },
+                );
+                result
+                    .expect("FATAL: failed to execute contract call")
+                    .expect_buff(32 as usize)
+                    .expect("FATAL: expected buff result")
+            })
+        }
+
+        #[test]
+        fn test_make_pox_4_message_hash() {
+            let mut sim = ClarityTestSim::new();
+            sim.epoch_bounds = vec![0, 1, 2];
+
+            // Test setup
+            sim.execute_next_block(|_env| {});
+            sim.execute_next_block(|_env| {});
+            sim.execute_next_block(|_env| {});
+
+            let body = &*POX_4_CODE;
+            let pox_contract_id = boot_code_id(POX_4_NAME, false);
+
+            sim.execute_next_block_as_conn(|conn| {
+                conn.as_transaction(|clarity_db| {
+                    let clarity_version = ClarityVersion::Clarity2;
+                    let (ast, analysis) = clarity_db
+                        .analyze_smart_contract(
+                            &pox_contract_id,
+                            clarity_version,
+                            &body,
+                            ASTRules::PrecheckSize,
+                        )
+                        .unwrap();
+                    clarity_db
+                        .initialize_smart_contract(
+                            &pox_contract_id,
+                            clarity_version,
+                            &ast,
+                            &body,
+                            None,
+                            |_, _| false,
+                        )
+                        .unwrap();
+                    clarity_db
+                        .save_analysis(&pox_contract_id, &analysis)
+                        .expect("FATAL: failed to store contract analysis");
+                });
+            });
+
+            let pubkey = Secp256k1PublicKey::new();
+            let stacks_addr = StacksAddress::p2pkh(false, &pubkey);
+            let pubkey = Secp256k1PublicKey::new();
+            let principal = PrincipalData::from(stacks_addr.clone());
+            let pox_addr =
+                PoxAddress::from_legacy(AddressHashMode::SerializeP2PKH, stacks_addr.bytes.clone());
+            let reward_cycle: u128 = 1;
+            let topic = Pox4SignatureTopic::StackStx;
+            let lock_period = 12;
+
+            let expected_hash_vec = make_pox_4_signer_key_message_hash(
+                &pox_addr,
+                reward_cycle,
+                &Pox4SignatureTopic::StackStx,
+                CHAIN_ID_TESTNET,
+                lock_period,
+            );
+            let expected_hash = expected_hash_vec.as_bytes();
+
+            // Test 1: valid result
+
+            let result = call_get_signer_message_hash(
+                &mut sim,
+                &pox_addr,
+                reward_cycle,
+                &topic,
+                lock_period,
+                &principal,
+            );
+            assert_eq!(expected_hash.clone(), result.as_slice());
+
+            // Test 2: invalid pox address
+            let other_pox_address = PoxAddress::from_legacy(
+                AddressHashMode::SerializeP2PKH,
+                StacksAddress::p2pkh(false, &Secp256k1PublicKey::new()).bytes,
+            );
+            let result = call_get_signer_message_hash(
+                &mut sim,
+                &other_pox_address,
+                reward_cycle,
+                &topic,
+                lock_period,
+                &principal,
+            );
+            assert_ne!(expected_hash.clone(), result.as_slice());
+
+            // Test 3: invalid reward cycle
+            let result = call_get_signer_message_hash(
+                &mut sim,
+                &pox_addr,
+                0,
+                &topic,
+                lock_period,
+                &principal,
+            );
+            assert_ne!(expected_hash.clone(), result.as_slice());
+
+            // Test 4: invalid topic
+            let result = call_get_signer_message_hash(
+                &mut sim,
+                &pox_addr,
+                reward_cycle,
+                &Pox4SignatureTopic::AggregationCommit,
+                lock_period,
+                &principal,
+            );
+            assert_ne!(expected_hash.clone(), result.as_slice());
+
+            // Test 5: invalid lock period
+            let result = call_get_signer_message_hash(
+                &mut sim,
+                &pox_addr,
+                reward_cycle,
+                &topic,
+                0,
+                &principal,
+            );
+            assert_ne!(expected_hash.clone(), result.as_slice());
+        }
+    }
 }
 
 #[cfg(test)]

From 2c742be4939e26aceeb4541dc58bb07b8d34cb2d Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Thu, 8 Feb 2024 09:30:11 -0800
Subject: [PATCH 0700/1166] fix: cleaned up formatting/style in pox-4

---
 .../src/chainstate/stacks/boot/pox-4.clar     | 37 +++++++------------
 1 file changed, 13 insertions(+), 24 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index aa93b5b8dc..d8655250dd 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -688,24 +688,17 @@
                                                (reward-cycle uint)
                                                (topic (string-ascii 12))
                                                (period uint))
-  (let
-    (
-      (domain { name: "pox-4-signer", version: "1.0.0", chain-id: chain-id })
-      (data-hash (sha256 (unwrap-panic
+  (sha256 (concat
+    SIP018_MSG_PREFIX
+    (concat 
+      (sha256 (unwrap-panic (to-consensus-buff? { name: "pox-4-signer", version: "1.0.0", chain-id: chain-id })))
+      (sha256 (unwrap-panic
         (to-consensus-buff? { 
           pox-addr: pox-addr, 
           reward-cycle: reward-cycle,
           topic: topic,
           period: period,
-        }))))
-      (domain-hash (sha256 (unwrap-panic (to-consensus-buff? domain))))
-    )
-    (sha256 (concat
-      SIP018_MSG_PREFIX
-      (concat domain-hash
-      data-hash)))
-  )
-)
+        })))))))
 
 ;; Verify a signature from the signing key for this specific stacker.
 ;; See `get-signer-key-message-hash` for details on the message hash.
@@ -719,17 +712,13 @@
                                          (period uint)
                                          (signer-sig (buff 65))
                                          (signer-key (buff 33)))
-  (begin
-    (asserts! 
-      (is-eq 
-        (unwrap! (secp256k1-recover? 
-          (get-signer-key-message-hash pox-addr reward-cycle topic period) 
-          signer-sig) (err ERR_INVALID_SIGNATURE_RECOVER)) 
-        signer-key) 
-      (err ERR_INVALID_SIGNATURE_PUBKEY))
-    (ok true)
-  )
-)
+  (ok (asserts! 
+    (is-eq 
+      (unwrap! (secp256k1-recover? 
+        (get-signer-key-message-hash pox-addr reward-cycle topic period) 
+        signer-sig) (err ERR_INVALID_SIGNATURE_RECOVER)) 
+      signer-key) 
+    (err ERR_INVALID_SIGNATURE_PUBKEY))))
 
 ;; Commit partially stacked STX and allocate a new PoX reward address slot.
 ;;   This allows a stacker/delegate to lock fewer STX than the minimal threshold in multiple transactions,

From c0050da75d30baee4b0ab9219f7680952428b3a0 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Thu, 8 Feb 2024 13:21:12 -0500
Subject: [PATCH 0701/1166] chore: Fix `clippy::redundant_clone` again after
 merge

---
 stacks-signer/src/client/stackerdb.rs     | 2 +-
 stacks-signer/src/client/stacks_client.rs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index 73e30d67e2..25da9f515b 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -248,7 +248,7 @@ mod tests {
             ),
         };
 
-        let signer_message = SignerMessage::Transactions(vec![tx.clone()]);
+        let signer_message = SignerMessage::Transactions(vec![tx]);
         let ack = StackerDBChunkAckData {
             accepted: true,
             reason: None,
diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index cb9573d830..b35cdc4522 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -284,7 +284,7 @@ impl StacksClient {
         debug!("Parsing signer slots...");
         // Due to .signers definition, the  signer slots is always an OK result of a list of tuples of signer addresses and the number of slots they have
         // If this fails, we have bigger problems than the signer crashing...
-        let value = value.clone().expect_result_ok()?;
+        let value = value.expect_result_ok()?;
         let values = value.expect_list()?;
         let mut signer_slots = Vec::with_capacity(values.len());
         for value in values {

From 2080d0ce169b9b1805141d018b13eccaf631f36b Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Thu, 8 Feb 2024 13:47:31 -0500
Subject: [PATCH 0702/1166] chore: Fix `clippy::expect_fun_call` again in
 `./stackslib`

---
 stackslib/src/chainstate/nakamoto/signer_set.rs | 12 +++++++-----
 stackslib/src/net/inv/nakamoto.rs               |  2 +-
 2 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/signer_set.rs b/stackslib/src/chainstate/nakamoto/signer_set.rs
index c0bfbfe078..d4d5fbde2a 100644
--- a/stackslib/src/chainstate/nakamoto/signer_set.rs
+++ b/stackslib/src/chainstate/nakamoto/signer_set.rs
@@ -107,7 +107,7 @@ impl RawRewardSetEntry {
             .expect("FATAL: no `pox-addr` in return value from (get-reward-set-pox-address)");
 
         let reward_address = PoxAddress::try_from_pox_tuple(is_mainnet, &pox_addr_tuple)
-            .expect(&format!("FATAL: not a valid PoX address: {pox_addr_tuple}"));
+            .unwrap_or_else(|| panic!("FATAL: not a valid PoX address: {pox_addr_tuple}"));
 
         let total_ustx = tuple_data
             .remove("total-ustx")
@@ -192,10 +192,12 @@ impl NakamotoSigners {
                     ],
                 )?
                 .expect_optional()?
-                .expect(&format!(
-                    "FATAL: missing PoX address in slot {} out of {} in reward cycle {}",
-                    index, list_length, reward_cycle
-                ))
+                .unwrap_or_else(|| {
+                    panic!(
+                        "FATAL: missing PoX address in slot {} out of {} in reward cycle {}",
+                        index, list_length, reward_cycle
+                    )
+                })
                 .expect_tuple()?;
 
             let entry = RawRewardSetEntry::from_pox_4_tuple(is_mainnet, tuple)?;
diff --git a/stackslib/src/net/inv/nakamoto.rs b/stackslib/src/net/inv/nakamoto.rs
index cb31d4faba..4d314a7c3d 100644
--- a/stackslib/src/net/inv/nakamoto.rs
+++ b/stackslib/src/net/inv/nakamoto.rs
@@ -194,7 +194,7 @@ impl InvGenerator {
                     .insert(cur_consensus_hash.clone(), loaded_info);
                 self.sortitions
                     .get(&cur_consensus_hash)
-                    .expect("infallible: just inserted this data".into())
+                    .expect("infallible: just inserted this data")
             };
             let parent_sortition_consensus_hash = cur_sortition_info.parent_consensus_hash.clone();
 

From ef1c917c5b69eea43f18cfd95413a69c5e556841 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Thu, 8 Feb 2024 11:03:02 -0800
Subject: [PATCH 0703/1166] fix: remove unused enum

---
 stackslib/src/util_lib/signed_structured_data.rs | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/stackslib/src/util_lib/signed_structured_data.rs b/stackslib/src/util_lib/signed_structured_data.rs
index ff6706d4ba..7aa215d743 100644
--- a/stackslib/src/util_lib/signed_structured_data.rs
+++ b/stackslib/src/util_lib/signed_structured_data.rs
@@ -87,11 +87,6 @@ pub mod pox4 {
         AggregationCommit("agg-commit"),
         StackExtend("stack-extend"),
     });
-    pub enum Pox4SignatureTopicOld {
-        StackStx,
-        AggregationCommit,
-        StackExtend,
-    }
 
     pub fn make_pox_4_signed_data_domain(chain_id: u32) -> Value {
         make_structured_data_domain("pox-4-signer", "1.0.0", chain_id)

From ef0aaba2905a6f01df4de1b3d9d34fb062c69a21 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Thu, 8 Feb 2024 11:03:25 -0800
Subject: [PATCH 0704/1166] chore: changelog entry for signer-sig param

---
 CHANGELOG.md | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index ffba4b176f..bc88952147 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -12,6 +12,9 @@ and this project adheres to the versioning scheme outlined in the [README.md](RE
 - New RPC endpoint `/v2/stacker_set/{cycle_number}` to fetch stacker sets in PoX-4
 - New `/new_pox_anchor` endpoint for broadcasting PoX anchor block processing.
 - Stacker bitvec in NakamotoBlock
+- New [`pox-4` contract](./stackslib/src/chainstate/stacks/boot/pox-4.clar) that reflects changes in how Stackers are signers in Nakamoto:
+  - `stack-stx`, `stack-extend`, and `stack-aggregation-commit` now include a `signer-key` parameter, which represents the public key used by the Signer. This key is used for determining the signer set in Nakamoto.
+  - Functions that include a `signer-key` parameter also include a `signer-sig` parameter to demonstrate that the owner of `signer-key` is approving that particular Stacking operation. For more details, refer to the `verify-signer-key-sig` method in the `pox-4` contract.
 
 ### Modified
 

From b3da7019826b425b20411317d1f72cc2c49b82c9 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Thu, 8 Feb 2024 15:38:40 -0500
Subject: [PATCH 0705/1166] chore: use parse_slot_entry(); update voting
 contract to remove needless slot data

---
 .../stacks/boot/signers-voting.clar           | 13 -------
 stackslib/src/net/stackerdb/config.rs         | 36 ++++---------------
 2 files changed, 7 insertions(+), 42 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers-voting.clar b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
index 4b780a0712..9b30c137a3 100644
--- a/stackslib/src/chainstate/stacks/boot/signers-voting.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
@@ -24,19 +24,6 @@
 ;; maps reward-cycle ids to last round
 (define-map rounds uint uint)
 
-(define-data-var state-1 {reward-cycle: uint, round: uint, aggregate-public-key: (optional (buff 33)),
-    total-votes: uint}  {reward-cycle: u0, round: u0, aggregate-public-key: none, total-votes: u0})
-(define-data-var state-2 {reward-cycle: uint, round: uint, aggregate-public-key: (optional (buff 33)),
-    total-votes: uint}  {reward-cycle: u0, round: u0, aggregate-public-key: none, total-votes: u0})
-
-;; get voting info by burn block height
-(define-read-only (get-info (height uint))
-    (ok (at-block (unwrap! (get-block-info? id-header-hash height) err-invalid-burn-block-height) (get-current-info))))
-
-;; get current voting info
-(define-read-only (get-current-info)
-    (var-get state-1))
-
 (define-read-only (burn-height-to-reward-cycle (height uint))
     (/ (- height (get first-burnchain-block-height pox-info)) (get reward-cycle-length pox-info)))
 
diff --git a/stackslib/src/net/stackerdb/config.rs b/stackslib/src/net/stackerdb/config.rs
index 0495284317..351c75765a 100644
--- a/stackslib/src/net/stackerdb/config.rs
+++ b/stackslib/src/net/stackerdb/config.rs
@@ -242,19 +242,13 @@ impl StackerDBConfig {
         let mut total_num_slots = 0u32;
         let mut ret = vec![];
         for slot_value in slot_list.into_iter() {
-            let slot_data = slot_value.expect_tuple()?;
-            let signer_principal = slot_data
-                .get("signer")
-                .expect("FATAL: no 'signer'")
-                .clone()
-                .expect_principal()?;
-            let num_slots_uint = slot_data
-                .get("num-slots")
-                .expect("FATAL: no 'num-slots'")
-                .clone()
-                .expect_u128()?;
+            let (addr, num_slots) =
+                Self::parse_slot_entry(slot_value, contract_id).map_err(|e| {
+                    warn!("Failed to parse StackerDB slot entry: {}", &e);
+                    NetError::InvalidStackerDBContract(contract_id.clone(), e)
+                })?;
 
-            if num_slots_uint > (STACKERDB_INV_MAX as u128) {
+            if num_slots > STACKERDB_INV_MAX {
                 let reason = format!(
                     "Contract {} stipulated more than maximum number of slots for one signer ({})",
                     contract_id, STACKERDB_INV_MAX
@@ -265,7 +259,7 @@ impl StackerDBConfig {
                     reason,
                 ));
             }
-            let num_slots = num_slots_uint as u32;
+
             total_num_slots =
                 total_num_slots
                     .checked_add(num_slots)
@@ -286,22 +280,6 @@ impl StackerDBConfig {
                 ));
             }
 
-            // standard principals only
-            let addr = match signer_principal {
-                PrincipalData::Contract(..) => {
-                    let reason = format!("Contract {} stipulated a contract principal as a writer, which is not supported", contract_id);
-                    warn!("{}", &reason);
-                    return Err(NetError::InvalidStackerDBContract(
-                        contract_id.clone(),
-                        reason,
-                    ));
-                }
-                PrincipalData::Standard(StandardPrincipalData(version, bytes)) => StacksAddress {
-                    version,
-                    bytes: Hash160(bytes),
-                },
-            };
-
             ret.push((addr, num_slots));
         }
         Ok(ret)

From 57e7fb895c9fa8ce11c6f471af11844110641644 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Thu, 8 Feb 2024 16:09:16 -0500
Subject: [PATCH 0706/1166] chore: address PR feedback

---
 stacks-signer/src/client/stackerdb.rs         | 21 ++++++++++++-------
 .../src/chainstate/nakamoto/signer_set.rs     | 21 +++++++++++++++++--
 stackslib/src/chainstate/stacks/boot/mod.rs   |  4 ----
 stackslib/src/clarity_vm/clarity.rs           | 17 ++++++++-------
 stackslib/src/net/stackerdb/config.rs         |  2 +-
 testnet/stacks-node/src/config.rs             |  8 ++++---
 .../stacks-node/src/nakamoto_node/miner.rs    | 11 +++++-----
 testnet/stacks-node/src/tests/signer.rs       | 11 ++++++----
 8 files changed, 59 insertions(+), 36 deletions(-)

diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index 6657e47b21..f1d82e8204 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -1,7 +1,3 @@
-use std::net::SocketAddr;
-
-use blockstack_lib::chainstate::stacks::boot::make_signers_db_name;
-use blockstack_lib::chainstate::stacks::StacksTransaction;
 // Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
 // Copyright (C) 2020-2024 Stacks Open Internet Foundation
 //
@@ -17,6 +13,11 @@ use blockstack_lib::chainstate::stacks::StacksTransaction;
 //
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
+//
+use std::net::SocketAddr;
+
+use blockstack_lib::chainstate::nakamoto::signer_set::NakamotoSigners;
+use blockstack_lib::chainstate::stacks::StacksTransaction;
 use clarity::vm::types::QualifiedContractIdentifier;
 use clarity::vm::ContractName;
 use hashbrown::HashMap;
@@ -57,12 +58,14 @@ impl From<&Config> for StackerDB {
         for signer_set in 0..2 {
             for msg_id in 0..SIGNER_SLOTS_PER_USER {
                 signers_message_stackerdb_sessions.insert(
-                    (signer_set, msg_id),
+                    (signer_set as u32, msg_id),
                     StackerDBSession::new(
                         config.node_host.clone(),
                         QualifiedContractIdentifier::new(
                             config.stackerdb_contract_id.issuer.clone(),
-                            ContractName::from(make_signers_db_name(signer_set, msg_id).as_str()),
+                            ContractName::from(
+                                NakamotoSigners::make_signers_db_name(signer_set, msg_id).as_str(),
+                            ),
                         ),
                     ),
                 );
@@ -94,12 +97,14 @@ impl StackerDB {
         for signer_set in 0..2 {
             for msg_id in 0..SIGNER_SLOTS_PER_USER {
                 signers_message_stackerdb_sessions.insert(
-                    (signer_set, msg_id),
+                    (signer_set as u32, msg_id),
                     StackerDBSession::new(
                         host.clone(),
                         QualifiedContractIdentifier::new(
                             stackerdb_contract_id.issuer.clone(),
-                            ContractName::from(make_signers_db_name(signer_set, msg_id).as_str()),
+                            ContractName::from(
+                                NakamotoSigners::make_signers_db_name(signer_set, msg_id).as_str(),
+                            ),
                         ),
                     ),
                 );
diff --git a/stackslib/src/chainstate/nakamoto/signer_set.rs b/stackslib/src/chainstate/nakamoto/signer_set.rs
index b23b607f00..bf444acc61 100644
--- a/stackslib/src/chainstate/nakamoto/signer_set.rs
+++ b/stackslib/src/chainstate/nakamoto/signer_set.rs
@@ -20,8 +20,10 @@ use clarity::vm::ast::ASTRules;
 use clarity::vm::costs::{ExecutionCost, LimitedCostTracker};
 use clarity::vm::database::{BurnStateDB, ClarityDatabase};
 use clarity::vm::events::StacksTransactionEvent;
-use clarity::vm::types::{PrincipalData, StacksAddressExtensions, TupleData};
-use clarity::vm::{ClarityVersion, SymbolicExpression, Value};
+use clarity::vm::types::{
+    PrincipalData, QualifiedContractIdentifier, StacksAddressExtensions, TupleData,
+};
+use clarity::vm::{ClarityVersion, ContractName, SymbolicExpression, Value};
 use lazy_static::{__Deref, lazy_static};
 use rusqlite::types::{FromSql, FromSqlError};
 use rusqlite::{params, Connection, OptionalExtension, ToSql, NO_PARAMS};
@@ -426,4 +428,19 @@ impl NakamotoSigners {
             })
             .map(|calculation| Some(calculation))
     }
+
+    /// Make the contract name for a signers DB contract
+    pub fn make_signers_db_name(reward_cycle: u64, message_id: u32) -> String {
+        format!("{}-{}-{}", &SIGNERS_NAME, reward_cycle % 2, message_id)
+    }
+
+    /// Make the contract ID for a signers DB contract
+    pub fn make_signers_db_contract_id(
+        reward_cycle: u64,
+        message_id: u32,
+        mainnet: bool,
+    ) -> QualifiedContractIdentifier {
+        let name = Self::make_signers_db_name(reward_cycle, message_id);
+        boot_code_id(&name, mainnet)
+    }
 }
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index cef755ecec..4b5ad62dde 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -162,10 +162,6 @@ pub fn make_contract_id(addr: &StacksAddress, name: &str) -> QualifiedContractId
     )
 }
 
-pub fn make_signers_db_name(signer_set: u32, message_id: u32) -> String {
-    format!("{}-{}-{}", &SIGNERS_NAME, signer_set, message_id)
-}
-
 #[derive(Clone, Debug)]
 pub struct RawRewardSetEntry {
     pub reward_address: PoxAddress,
diff --git a/stackslib/src/clarity_vm/clarity.rs b/stackslib/src/clarity_vm/clarity.rs
index 32e0b842ce..d6bf134a2f 100644
--- a/stackslib/src/clarity_vm/clarity.rs
+++ b/stackslib/src/clarity_vm/clarity.rs
@@ -43,13 +43,14 @@ use stacks_common::types::chainstate::{
 use stacks_common::util::secp256k1::MessageSignature;
 
 use crate::burnchains::{Burnchain, PoxConstants};
+use crate::chainstate::nakamoto::signer_set::NakamotoSigners;
 use crate::chainstate::stacks::boot::{
-    make_signers_db_name, BOOT_CODE_COSTS, BOOT_CODE_COSTS_2, BOOT_CODE_COSTS_2_TESTNET,
-    BOOT_CODE_COSTS_3, BOOT_CODE_COST_VOTING_TESTNET as BOOT_CODE_COST_VOTING,
-    BOOT_CODE_POX_TESTNET, BOOT_TEST_POX_4_AGG_KEY_CONTRACT, BOOT_TEST_POX_4_AGG_KEY_FNAME,
-    COSTS_2_NAME, COSTS_3_NAME, MINERS_NAME, POX_2_MAINNET_CODE, POX_2_NAME, POX_2_TESTNET_CODE,
-    POX_3_MAINNET_CODE, POX_3_NAME, POX_3_TESTNET_CODE, POX_4_CODE, POX_4_NAME, SIGNERS_BODY,
-    SIGNERS_DB_0_BODY, SIGNERS_DB_1_BODY, SIGNERS_NAME, SIGNERS_VOTING_NAME, SIGNER_VOTING_CODE,
+    BOOT_CODE_COSTS, BOOT_CODE_COSTS_2, BOOT_CODE_COSTS_2_TESTNET, BOOT_CODE_COSTS_3,
+    BOOT_CODE_COST_VOTING_TESTNET as BOOT_CODE_COST_VOTING, BOOT_CODE_POX_TESTNET,
+    BOOT_TEST_POX_4_AGG_KEY_CONTRACT, BOOT_TEST_POX_4_AGG_KEY_FNAME, COSTS_2_NAME, COSTS_3_NAME,
+    MINERS_NAME, POX_2_MAINNET_CODE, POX_2_NAME, POX_2_TESTNET_CODE, POX_3_MAINNET_CODE,
+    POX_3_NAME, POX_3_TESTNET_CODE, POX_4_CODE, POX_4_NAME, SIGNERS_BODY, SIGNERS_DB_0_BODY,
+    SIGNERS_DB_1_BODY, SIGNERS_NAME, SIGNERS_VOTING_NAME, SIGNER_VOTING_CODE,
 };
 use crate::chainstate::stacks::db::{StacksAccount, StacksChainState};
 use crate::chainstate::stacks::events::{StacksTransactionEvent, StacksTransactionReceipt};
@@ -1487,8 +1488,8 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
             // stackerdb contracts for each message type
             for signer_set in 0..2 {
                 for message_id in 0..SIGNER_SLOTS_PER_USER {
-                    let signers_name = make_signers_db_name(signer_set, message_id);
-                    let signers_contract_id = boot_code_id(&signers_name, mainnet);
+                    let signers_name =
+                        NakamotoSigners::make_signers_db_name(signer_set, message_id);
                     let body = if signer_set == 0 {
                         SIGNERS_DB_0_BODY
                     } else {
diff --git a/stackslib/src/net/stackerdb/config.rs b/stackslib/src/net/stackerdb/config.rs
index 351c75765a..f2d8521ae4 100644
--- a/stackslib/src/net/stackerdb/config.rs
+++ b/stackslib/src/net/stackerdb/config.rs
@@ -219,7 +219,7 @@ impl StackerDBConfig {
             burn_dbconn,
             tip,
             contract_id,
-            "(stackerdb-get-signer-slots)",
+            &format!("({STACKERDB_SLOTS_FUNCTION})"),
         )?;
 
         let result = value.expect_result()?;
diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index 5f22d63f5a..4a775399d6 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -12,7 +12,8 @@ use lazy_static::lazy_static;
 use rand::RngCore;
 use stacks::burnchains::bitcoin::BitcoinNetworkType;
 use stacks::burnchains::{Burnchain, MagicBytes, BLOCKSTACK_MAGIC_MAINNET};
-use stacks::chainstate::stacks::boot::{make_signers_db_name, MINERS_NAME};
+use stacks::chainstate::nakamoto::signer_set::NakamotoSigners;
+use stacks::chainstate::stacks::boot::MINERS_NAME;
 use stacks::chainstate::stacks::index::marf::MARFOpenOpts;
 use stacks::chainstate::stacks::index::storage::TrieHashCalculationMode;
 use stacks::chainstate::stacks::miner::{BlockBuilderSettings, MinerStatus};
@@ -973,8 +974,9 @@ impl Config {
         if (node.stacker || node.miner) && burnchain.mode == "nakamoto-neon" {
             for signer_set in 0..2 {
                 for message_id in 0..SIGNER_SLOTS_PER_USER {
-                    let contract_name = make_signers_db_name(signer_set, message_id);
-                    let contract_id = boot_code_id(contract_name.as_str(), is_mainnet);
+                    let contract_id = NakamotoSigners::make_signers_db_contract_id(
+                        signer_set, message_id, is_mainnet,
+                    );
                     if !node.stacker_dbs.contains(&contract_id) {
                         debug!("A miner/stacker must subscribe to the {contract_id} stacker db contract. Forcibly subscribing...");
                         node.stacker_dbs.push(contract_id);
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index e4a12c3c76..074db03095 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -28,8 +28,9 @@ use stacks::burnchains::{Burnchain, BurnchainParameters};
 use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::burn::{BlockSnapshot, ConsensusHash};
 use stacks::chainstate::nakamoto::miner::{NakamotoBlockBuilder, NakamotoTenureInfo};
+use stacks::chainstate::nakamoto::signer_set::NakamotoSigners;
 use stacks::chainstate::nakamoto::{NakamotoBlock, NakamotoChainState};
-use stacks::chainstate::stacks::boot::{make_signers_db_name, MINERS_NAME};
+use stacks::chainstate::stacks::boot::MINERS_NAME;
 use stacks::chainstate::stacks::db::{StacksChainState, StacksHeaderInfo};
 use stacks::chainstate::stacks::{
     CoinbasePayload, Error as ChainstateError, StacksTransaction, StacksTransactionSigner,
@@ -270,11 +271,9 @@ impl BlockMinerThread {
             .block_height_to_reward_cycle(self.burn_block.block_height)
             .expect("FATAL: no reward cycle for burn block");
 
-        let signers_contract_id = boot_code_id(
-            &make_signers_db_name(
-                u32::try_from(reward_cycle % 2).expect("FATAL: infallible"),
-                BLOCK_MSG_ID,
-            ),
+        let signers_contract_id = NakamotoSigners::make_signers_db_contract_id(
+            reward_cycle,
+            BLOCK_MSG_ID,
             self.config.is_mainnet(),
         );
         if !stackerdb_contracts.contains(&signers_contract_id) {
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index e00e360c6b..76277a4188 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -12,8 +12,9 @@ use libsigner::{
     BLOCK_MSG_ID, TRANSACTIONS_MSG_ID,
 };
 use stacks::chainstate::coordinator::comm::CoordinatorChannels;
+use stacks::chainstate::nakamoto::signer_set::NakamotoSigners;
 use stacks::chainstate::nakamoto::{NakamotoBlock, NakamotoBlockHeader};
-use stacks::chainstate::stacks::boot::{make_signers_db_name, SIGNERS_NAME};
+use stacks::chainstate::stacks::boot::SIGNERS_NAME;
 use stacks::chainstate::stacks::{
     StacksPrivateKey, StacksTransaction, ThresholdSignature, TransactionAnchorMode,
     TransactionAuth, TransactionPayload, TransactionPostConditionMode, TransactionSmartContract,
@@ -251,8 +252,8 @@ fn setup_stx_btc_node(
 
     for signer_set in 0..2 {
         for message_id in 0..SIGNER_SLOTS_PER_USER {
-            let contract_name = make_signers_db_name(signer_set, message_id);
-            let contract_id = boot_code_id(contract_name.as_str(), false);
+            let contract_id =
+                NakamotoSigners::make_signers_db_contract_id(signer_set, message_id, false);
             if !naka_conf.node.stacker_dbs.contains(&contract_id) {
                 debug!("A miner/stacker must subscribe to the {contract_id} stacker db contract. Forcibly subscribing...");
                 naka_conf.node.stacker_dbs.push(contract_id);
@@ -724,7 +725,9 @@ fn stackerdb_block_proposal_missing_transactions() {
         .node
         .stacker_dbs
         .iter()
-        .find(|id| id.name.to_string() == make_signers_db_name(1, TRANSACTIONS_MSG_ID))
+        .find(|id| {
+            id.name.to_string() == NakamotoSigners::make_signers_db_name(1, TRANSACTIONS_MSG_ID)
+        })
         .unwrap()
         .clone();
 

From 22e33de2ce7ee08d26f4ae27f754c49a13a2caee Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Thu, 8 Feb 2024 13:25:12 -0800
Subject: [PATCH 0707/1166] fix: compiler error from merge

---
 stacks-signer/src/cli.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stacks-signer/src/cli.rs b/stacks-signer/src/cli.rs
index 7261fe3fe2..48cd9a87fe 100644
--- a/stacks-signer/src/cli.rs
+++ b/stacks-signer/src/cli.rs
@@ -193,7 +193,7 @@ impl From<Pox4SignatureTopic> for StackingSignatureMethod {
 
 impl ValueEnum for StackingSignatureMethod {
     fn to_possible_value(&self) -> Option<clap::builder::PossibleValue> {
-        Some(clap::builder::PossibleValue::new(self.0.as_str()))
+        Some(clap::builder::PossibleValue::new(self.0.get_name_str()))
     }
 
     fn value_variants<'a>() -> &'a [Self] {

From 20d0ddbef99fcbe9c0311de511a9348f1f08e364 Mon Sep 17 00:00:00 2001
From: Joey Yandle <xoloki@gmail.com>
Date: Thu, 1 Feb 2024 10:49:50 -0500
Subject: [PATCH 0708/1166] rev wsts dep to get malicious dkg private handling;
 pass signer public keys in Point format to coordinator config

fmt fixes

implement StacksMessageCodecExtensions for DkgFailure and friends

flesh out skeleton StacksMessageCodecExtensions for DkgFailure

fix test to use proper DkgFailure enum not string
---
 Cargo.lock                   |   8 +--
 Cargo.toml                   |   2 +-
 libsigner/src/messages.rs    | 130 ++++++++++++++++++++++++++++++++---
 stacks-signer/src/runloop.rs |  13 ++++
 4 files changed, 139 insertions(+), 14 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 53868a05a0..8d857db6b6 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2372,9 +2372,9 @@ checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39"
 
 [[package]]
 name = "p256k1"
-version = "6.0.0"
+version = "7.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5afcf536d20c074ef45371ee9a654dcfc46fb2dde18ecc54ec30c936eb850fa2"
+checksum = "3a64d160b891178fb9d43d1a58ddcafb6502daeb54d810e5e92a7c3c9bfacc07"
 dependencies = [
  "bindgen",
  "bitvec",
@@ -4791,9 +4791,9 @@ dependencies = [
 
 [[package]]
 name = "wsts"
-version = "7.0.0"
+version = "8.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c398736468f3322a43b6419be5315e68ae035e6565628603503c2a62ad726f36"
+checksum = "06eee6f3bb38f8c8dca03053572130be2e5006a31dc7e5d8c62e375952b2ff38"
 dependencies = [
  "aes-gcm 0.10.2",
  "bs58 0.5.0",
diff --git a/Cargo.toml b/Cargo.toml
index 4564ee800c..e9af4f43dc 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -14,7 +14,7 @@ members = [
 
 # Dependencies we want to keep the same between workspace members
 [workspace.dependencies]  
-wsts = "7.0"
+wsts = "8.0"
 rand_core = "0.6"
 rand = "0.8"
 
diff --git a/libsigner/src/messages.rs b/libsigner/src/messages.rs
index 477712b224..aa2e10e178 100644
--- a/libsigner/src/messages.rs
+++ b/libsigner/src/messages.rs
@@ -30,7 +30,7 @@ use blockstack_lib::net::api::postblock_proposal::{
 use blockstack_lib::util_lib::boot::boot_code_id;
 use clarity::vm::types::serialization::SerializationError;
 use clarity::vm::types::QualifiedContractIdentifier;
-use hashbrown::HashMap;
+use hashbrown::{HashMap, HashSet};
 use serde::{Deserialize, Serialize};
 use stacks_common::codec::{
     read_next, read_next_at_most, read_next_exact, write_next, Error as CodecError,
@@ -40,12 +40,13 @@ use stacks_common::util::hash::Sha512Trunc256Sum;
 use tiny_http::{
     Method as HttpMethod, Request as HttpRequest, Response as HttpResponse, Server as HttpServer,
 };
-use wsts::common::{PolyCommitment, PublicNonce, Signature, SignatureShare};
+use wsts::common::{PolyCommitment, PublicNonce, Signature, SignatureShare, TupleProof};
 use wsts::curve::point::{Compressed, Point};
 use wsts::curve::scalar::Scalar;
 use wsts::net::{
-    DkgBegin, DkgEnd, DkgEndBegin, DkgPrivateBegin, DkgPrivateShares, DkgPublicShares, DkgStatus,
-    Message, NonceRequest, NonceResponse, Packet, SignatureShareRequest, SignatureShareResponse,
+    BadPrivateShare, DkgBegin, DkgEnd, DkgEndBegin, DkgFailure, DkgPrivateBegin, DkgPrivateShares,
+    DkgPublicShares, DkgStatus, Message, NonceRequest, NonceResponse, Packet,
+    SignatureShareRequest, SignatureShareResponse,
 };
 use wsts::schnorr::ID;
 use wsts::state_machine::signer;
@@ -247,6 +248,119 @@ impl StacksMessageCodecExtensions for Point {
     }
 }
 
+#[allow(non_snake_case)]
+impl StacksMessageCodecExtensions for TupleProof {
+    fn inner_consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), CodecError> {
+        self.R.inner_consensus_serialize(fd)?;
+        self.rB.inner_consensus_serialize(fd)?;
+        self.z.inner_consensus_serialize(fd)
+    }
+    fn inner_consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, CodecError> {
+        let R = Point::inner_consensus_deserialize(fd)?;
+        let rB = Point::inner_consensus_deserialize(fd)?;
+        let z = Scalar::inner_consensus_deserialize(fd)?;
+        Ok(Self { R, rB, z })
+    }
+}
+
+impl StacksMessageCodecExtensions for BadPrivateShare {
+    fn inner_consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), CodecError> {
+        self.shared_key.inner_consensus_serialize(fd)?;
+        self.tuple_proof.inner_consensus_serialize(fd)
+    }
+    fn inner_consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, CodecError> {
+        let shared_key = Point::inner_consensus_deserialize(fd)?;
+        let tuple_proof = TupleProof::inner_consensus_deserialize(fd)?;
+        Ok(Self {
+            shared_key,
+            tuple_proof,
+        })
+    }
+}
+
+impl StacksMessageCodecExtensions for HashSet<u32> {
+    fn inner_consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), CodecError> {
+        write_next(fd, &(self.len() as u32))?;
+        for i in self {
+            write_next(fd, i)?;
+        }
+        Ok(())
+    }
+    fn inner_consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, CodecError> {
+        let mut set = Self::new();
+        let len = read_next::<u32, _>(fd)?;
+        for _ in 0..len {
+            let i = read_next::<u32, _>(fd)?;
+            set.insert(i);
+        }
+        Ok(set)
+    }
+}
+
+impl StacksMessageCodecExtensions for DkgFailure {
+    fn inner_consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), CodecError> {
+        match self {
+            DkgFailure::BadState => write_next(fd, &0u8),
+            DkgFailure::MissingPublicShares(shares) => {
+                write_next(fd, &1u8)?;
+                shares.inner_consensus_serialize(fd)
+            }
+            DkgFailure::BadPublicShares(shares) => {
+                write_next(fd, &2u8)?;
+                shares.inner_consensus_serialize(fd)
+            }
+            DkgFailure::MissingPrivateShares(shares) => {
+                write_next(fd, &3u8)?;
+                shares.inner_consensus_serialize(fd)
+            }
+            DkgFailure::BadPrivateShares(shares) => {
+                write_next(fd, &4u8)?;
+                write_next(fd, &(shares.len() as u32))?;
+                for (id, share) in shares {
+                    write_next(fd, id)?;
+                    share.inner_consensus_serialize(fd)?;
+                }
+                Ok(())
+            }
+        }
+    }
+    fn inner_consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, CodecError> {
+        let failure_type_prefix = read_next::<u8, _>(fd)?;
+        let failure_type = match failure_type_prefix {
+            0 => DkgFailure::BadState,
+            1 => {
+                let set = HashSet::<u32>::inner_consensus_deserialize(fd)?;
+                DkgFailure::MissingPublicShares(set)
+            }
+            2 => {
+                let set = HashSet::<u32>::inner_consensus_deserialize(fd)?;
+                DkgFailure::BadPublicShares(set)
+            }
+            3 => {
+                let set = HashSet::<u32>::inner_consensus_deserialize(fd)?;
+                DkgFailure::MissingPrivateShares(set)
+            }
+            4 => {
+                let mut map = HashMap::new();
+                let len = read_next::<u32, _>(fd)?;
+                for _ in 0..len {
+                    let i = read_next::<u32, _>(fd)?;
+                    let bad_share = BadPrivateShare::inner_consensus_deserialize(fd)?;
+                    map.insert(i, bad_share);
+                }
+                DkgFailure::BadPrivateShares(map)
+            }
+            _ => {
+                return Err(CodecError::DeserializeError(format!(
+                    "Unknown DkgFailure type prefix: {}",
+                    failure_type_prefix
+                )))
+            }
+        };
+        Ok(failure_type)
+    }
+}
+
 impl StacksMessageCodecExtensions for DkgBegin {
     fn inner_consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), CodecError> {
         write_next(fd, &self.dkg_id)
@@ -301,7 +415,7 @@ impl StacksMessageCodecExtensions for DkgEnd {
             DkgStatus::Success => write_next(fd, &0u8),
             DkgStatus::Failure(failure) => {
                 write_next(fd, &1u8)?;
-                write_next(fd, &failure.as_bytes().to_vec())
+                failure.inner_consensus_serialize(fd)
             }
         }
     }
@@ -312,9 +426,7 @@ impl StacksMessageCodecExtensions for DkgEnd {
         let status = match status_type_prefix {
             0 => DkgStatus::Success,
             1 => {
-                let failure_bytes: Vec<u8> = read_next(fd)?;
-                let failure = String::from_utf8(failure_bytes)
-                    .map_err(|e| CodecError::DeserializeError(e.to_string()))?;
+                let failure = DkgFailure::inner_consensus_deserialize(fd)?;
                 DkgStatus::Failure(failure)
             }
             _ => {
@@ -1122,7 +1234,7 @@ mod test {
         test_fixture_packet(Message::DkgEnd(DkgEnd {
             dkg_id,
             signer_id,
-            status: DkgStatus::Failure("failure".to_string()),
+            status: DkgStatus::Failure(DkgFailure::BadState),
         }));
 
         // Test DKG public shares Packet
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 96a1e897ff..cfa502d4ef 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -32,6 +32,7 @@ use stacks_common::{debug, error, info, warn};
 use wsts::common::{MerkleRoot, Signature};
 use wsts::curve::ecdsa;
 use wsts::curve::keys::PublicKey;
+use wsts::curve::point::{Compressed, Point};
 use wsts::net::{Message, NonceRequest, Packet, SignatureShareRequest};
 use wsts::state_machine::coordinator::fire::Coordinator as FireCoordinator;
 use wsts::state_machine::coordinator::{Config as CoordinatorConfig, Coordinator};
@@ -833,6 +834,17 @@ impl From<&Config> for RunLoop<FireCoordinator<v2::Aggregator>> {
             .iter()
             .map(|(i, ids)| (*i, ids.iter().copied().collect::<HashSet<u32>>()))
             .collect::<HashMap<u32, HashSet<u32>>>();
+        let signer_public_keys = config
+            .signer_ids_public_keys
+            .signers
+            .iter()
+            .map(|(i, ecdsa_key)| {
+                (
+                    *i,
+                    Point::try_from(&Compressed::from(ecdsa_key.to_bytes())).unwrap(),
+                )
+            })
+            .collect::<HashMap<u32, Point>>();
 
         let coordinator_config = CoordinatorConfig {
             threshold,
@@ -846,6 +858,7 @@ impl From<&Config> for RunLoop<FireCoordinator<v2::Aggregator>> {
             nonce_timeout: config.nonce_timeout,
             sign_timeout: config.sign_timeout,
             signer_key_ids,
+            signer_public_keys,
         };
         let coordinator = FireCoordinator::new(coordinator_config);
         let signing_round = Signer::new(

From 325c19f312c9947e6355ac3c2b2459610fd6939b Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Thu, 8 Feb 2024 17:18:36 -0500
Subject: [PATCH 0709/1166] feat: Add `--prefix` and `--last` flags to
 `replay-block`

---
 stackslib/src/main.rs | 95 +++++++++++++++++++++----------------------
 1 file changed, 46 insertions(+), 49 deletions(-)

diff --git a/stackslib/src/main.rs b/stackslib/src/main.rs
index 23d7a6281e..28b4f35a65 100644
--- a/stackslib/src/main.rs
+++ b/stackslib/src/main.rs
@@ -861,25 +861,34 @@ simulating a miner.
     }
 
     if argv[1] == "replay-block" {
-        if argv.len() < 3 {
+        if argv.len() < 2 {
             eprintln!(
-                "Usage: {} chainstate_path index-block-hash-prefix",
+                "Usage: {} <chainstate_path> [--prefix <index-block-hash-prefix>] [--last <block_count>]",
                 &argv[0]
             );
             process::exit(1);
         }
         let stacks_path = &argv[2];
-        let index_block_hash_prefix = &argv[3];
-        let staging_blocks_db_path = format!("{}/mainnet/chainstate/vm/index.sqlite", stacks_path);
+        let mode = argv.get(3).map(String::as_str);
+        let staging_blocks_db_path = format!("{stacks_path}/mainnet/chainstate/vm/index.sqlite");
         let conn =
             Connection::open_with_flags(&staging_blocks_db_path, OpenFlags::SQLITE_OPEN_READ_ONLY)
                 .unwrap();
-        let mut stmt = conn
-            .prepare(&format!(
+
+        let query = match mode {
+            Some("--prefix") => format!(
                 "SELECT index_block_hash FROM staging_blocks WHERE index_block_hash LIKE \"{}%\"",
-                index_block_hash_prefix
-            ))
-            .unwrap();
+                argv[4]
+            ),
+            Some("--last") => format!(
+                "SELECT index_block_hash FROM staging_blocks ORDER BY height DESC LIMIT {}",
+                argv[4]
+            ),
+            // Default to ALL blocks
+            _ => "SELECT index_block_hash FROM staging_blocks".into(),
+        };
+
+        let mut stmt = conn.prepare(&query).unwrap();
         let mut hashes_set = stmt.query(rusqlite::NO_PARAMS).unwrap();
 
         let mut index_block_hashes: Vec<String> = vec![];
@@ -888,13 +897,11 @@ simulating a miner.
         }
 
         let total = index_block_hashes.len();
-        let mut i = 1;
-        println!("Will check {} blocks.", total);
-        for index_block_hash in index_block_hashes.iter() {
+        println!("Will check {total} blocks");
+        for (i, index_block_hash) in index_block_hashes.iter().enumerate() {
             if i % 100 == 0 {
-                println!("Checked {}...", i);
+                println!("Checked {i}...");
             }
-            i += 1;
             replay_block(stacks_path, index_block_hash);
         }
         println!("Finished!");
@@ -1561,19 +1568,14 @@ fn replay_block(stacks_path: &str, index_block_hash_hex: &str) {
         &next_staging_block.anchored_block_hash,
     )
     .unwrap()
-    .unwrap_or(vec![]);
+    .unwrap_or_default();
 
-    let next_microblocks = match StacksChainState::find_parent_microblock_stream(
-        &chainstate_tx.tx,
-        &next_staging_block,
-    )
-    .unwrap()
-    {
-        Some(x) => x,
-        None => {
-            println!("No microblock stream found for {}", index_block_hash_hex);
-            return;
-        }
+    let Some(next_microblocks) =
+        StacksChainState::find_parent_microblock_stream(&chainstate_tx.tx, &next_staging_block)
+            .unwrap()
+    else {
+        println!("No microblock stream found for {index_block_hash_hex}");
+        return;
     };
 
     let (burn_header_hash, burn_header_height, burn_header_timestamp, _winning_block_txid) =
@@ -1607,33 +1609,30 @@ fn replay_block(stacks_path: &str, index_block_hash_hex: &str) {
         &next_staging_block.parent_microblock_hash,
     );
 
-    let parent_header_info =
-        match StacksChainState::get_parent_header_info(&mut chainstate_tx, &next_staging_block)
-            .unwrap()
-        {
-            Some(hinfo) => hinfo,
-            None => {
-                println!(
-                    "Failed to load parent head info for block: {}",
-                    index_block_hash_hex
-                );
-                return;
-            }
-        };
+    let Some(parent_header_info) =
+        StacksChainState::get_parent_header_info(&mut chainstate_tx, &next_staging_block).unwrap()
+    else {
+        println!("Failed to load parent head info for block: {index_block_hash_hex}");
+        return;
+    };
 
     let block = StacksChainState::extract_stacks_block(&next_staging_block).unwrap();
     let block_size = next_staging_block.block_data.len() as u64;
 
-    if !StacksChainState::check_block_attachment(&parent_header_info.anchored_header, &block.header)
-    {
+    let parent_block_header = match &parent_header_info.anchored_header {
+        StacksBlockHeaderTypes::Epoch2(bh) => bh,
+        StacksBlockHeaderTypes::Nakamoto(_) => panic!("Nakamoto blocks not supported yet"),
+    };
+
+    if !StacksChainState::check_block_attachment(&parent_block_header, &block.header) {
         let msg = format!(
             "Invalid stacks block {}/{} -- does not attach to parent {}/{}",
             &next_staging_block.consensus_hash,
             block.block_hash(),
-            parent_header_info.anchored_header.block_hash(),
+            parent_block_header.block_hash(),
             &parent_header_info.consensus_hash
         );
-        println!("{}", &msg);
+        println!("{msg}");
         return;
     }
 
@@ -1678,7 +1677,7 @@ fn replay_block(stacks_path: &str, index_block_hash_hex: &str) {
 
     let pox_constants = sort_tx.context.pox_constants.clone();
 
-    let epoch_receipt = match StacksChainState::append_block(
+    match StacksChainState::append_block(
         &mut chainstate_tx,
         clarity_instance,
         &mut sort_tx,
@@ -1698,13 +1697,11 @@ fn replay_block(stacks_path: &str, index_block_hash_hex: &str) {
         true,
     ) {
         Ok((_receipt, _)) => {
-            info!("Block processed successfully! block = {}", index_block_hash);
+            info!("Block processed successfully! block = {index_block_hash}");
         }
         Err(e) => {
-            println!(
-                "Failed processing block! block = {}, error = {:?}",
-                index_block_hash, e
-            );
+            println!("Failed processing block! block = {index_block_hash}, error = {e:?}");
+            process::exit(1);
         }
     };
 }

From 65833953a18fed2f77717710f3b35ceb2ee00980 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Thu, 8 Feb 2024 15:04:13 -0800
Subject: [PATCH 0710/1166] feat: test cli-generated signature against PoX code

---
 stacks-signer/Cargo.toml  |   3 +-
 stacks-signer/src/main.rs | 100 ++++++++++++++++++++++++++++++++++++--
 2 files changed, 99 insertions(+), 4 deletions(-)

diff --git a/stacks-signer/Cargo.toml b/stacks-signer/Cargo.toml
index 77d747fe78..c7900c20e4 100644
--- a/stacks-signer/Cargo.toml
+++ b/stacks-signer/Cargo.toml
@@ -35,7 +35,7 @@ slog = { version = "2.5.2", features = [ "max_level_trace" ] }
 slog-json = { version = "2.3.0", optional = true }
 slog-term = "2.6.0"
 stacks-common = { path = "../stacks-common" }
-stackslib = { path = "../stackslib"}
+stackslib = { path = "../stackslib" }
 thiserror = "1.0"
 toml = "0.5.6"
 tracing = "0.1.37"
@@ -45,6 +45,7 @@ rand = { workspace = true }
 
 [dev-dependencies]
 serial_test = "3.0.0"
+clarity = { path = "../clarity", features = ["testing"] }
 
 [dependencies.serde_json]
 version = "1.0"
diff --git a/stacks-signer/src/main.rs b/stacks-signer/src/main.rs
index 578abe0c9c..a929e79ac0 100644
--- a/stacks-signer/src/main.rs
+++ b/stacks-signer/src/main.rs
@@ -393,9 +393,12 @@ fn main() {
 
 #[cfg(test)]
 pub mod tests {
-
-    use blockstack_lib::util_lib::signed_structured_data::pox4::{
-        make_pox_4_signer_key_message_hash, Pox4SignatureTopic,
+    use blockstack_lib::{
+        chainstate::stacks::address::PoxAddress,
+        chainstate::stacks::boot::POX_4_CODE,
+        util_lib::signed_structured_data::pox4::{
+            make_pox_4_signer_key_message_hash, Pox4SignatureTopic,
+        },
     };
     use stacks_common::{
         consts::CHAIN_ID_TESTNET, types::PublicKey, util::secp256k1::Secp256k1PublicKey,
@@ -404,6 +407,97 @@ pub mod tests {
 
     use super::handle_generate_stacking_signature;
     use crate::{Config, GenerateStackingSignatureArgs};
+    use clarity::vm::{execute_v2, Value};
+
+    use super::*;
+
+    fn _get_signer_message_sig_function_str() -> String {
+        let start = 687 - 1;
+        let end = 701;
+        let func = &*POX_4_CODE
+            .lines()
+            .skip(start)
+            .take(end - start + 1)
+            .collect::<String>();
+        func.to_string()
+    }
+
+    fn call_verify_signer_sig(
+        // sim: &mut ClarityTestSim,
+        pox_addr: &PoxAddress,
+        reward_cycle: u128,
+        topic: &Pox4SignatureTopic,
+        lock_period: u128,
+        public_key: &Secp256k1PublicKey,
+        signature: Vec<u8>,
+    ) -> bool {
+        // let func_body = get_signer_message_sig_function_str();
+        let program = format!(
+            r#"
+            {}
+            (verify-signer-key-sig {} u{} "{}" u{} 0x{} 0x{})
+        "#,
+            &*POX_4_CODE,                                               //s
+            Value::Tuple(pox_addr.clone().as_clarity_tuple().unwrap()), //p
+            reward_cycle,
+            topic.get_name_str(),
+            lock_period,
+            to_hex(signature.as_slice()),
+            to_hex(public_key.to_bytes_compressed().as_slice()),
+        );
+        let result = execute_v2(&program)
+            .expect("FATAL: could not execute program")
+            .expect("Expected result")
+            .expect_result_ok()
+            .expect("Expected ok result")
+            .expect_bool()
+            .expect("Expected buff");
+        result
+    }
+
+    #[test]
+    fn test_stacking_signature_with_pox_code() {
+        let config = Config::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
+        let btc_address = "bc1p8vg588hldsnv4a558apet4e9ff3pr4awhqj2hy8gy6x2yxzjpmqsvvpta4";
+        let mut args = GenerateStackingSignatureArgs {
+            config: "./src/tests/conf/signer-0.toml".into(),
+            pox_address: parse_pox_addr(btc_address).unwrap(),
+            reward_cycle: 6,
+            method: Pox4SignatureTopic::StackStx.into(),
+            period: 12,
+        };
+
+        let signature = handle_generate_stacking_signature(args.clone(), false);
+        let public_key = Secp256k1PublicKey::from_private(&config.stacks_private_key);
+
+        let valid = call_verify_signer_sig(
+            &args.pox_address,
+            args.reward_cycle.into(),
+            &Pox4SignatureTopic::StackStx,
+            args.period.into(),
+            &public_key,
+            signature.to_rsv(),
+        );
+        assert!(valid);
+
+        // change up some args
+        args.period = 6;
+        args.method = Pox4SignatureTopic::AggregationCommit.into();
+        args.reward_cycle = 7;
+
+        let signature = handle_generate_stacking_signature(args.clone(), false);
+        let public_key = Secp256k1PublicKey::from_private(&config.stacks_private_key);
+
+        let valid = call_verify_signer_sig(
+            &args.pox_address,
+            args.reward_cycle.into(),
+            &Pox4SignatureTopic::AggregationCommit,
+            args.period.into(),
+            &public_key,
+            signature.to_rsv(),
+        );
+        assert!(valid);
+    }
 
     #[test]
     fn test_generate_stacking_signature() {

From e067c18f57ec395bec6e5ba6dce4c86645061f47 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Thu, 8 Feb 2024 16:17:43 -0800
Subject: [PATCH 0711/1166] feat: test fixture for pox-4 sig hash

---
 stacks-signer/src/main.rs                     | 13 ------
 .../src/util_lib/signed_structured_data.rs    | 44 ++++++++++++++++---
 2 files changed, 39 insertions(+), 18 deletions(-)

diff --git a/stacks-signer/src/main.rs b/stacks-signer/src/main.rs
index a929e79ac0..a804cad60d 100644
--- a/stacks-signer/src/main.rs
+++ b/stacks-signer/src/main.rs
@@ -411,19 +411,7 @@ pub mod tests {
 
     use super::*;
 
-    fn _get_signer_message_sig_function_str() -> String {
-        let start = 687 - 1;
-        let end = 701;
-        let func = &*POX_4_CODE
-            .lines()
-            .skip(start)
-            .take(end - start + 1)
-            .collect::<String>();
-        func.to_string()
-    }
-
     fn call_verify_signer_sig(
-        // sim: &mut ClarityTestSim,
         pox_addr: &PoxAddress,
         reward_cycle: u128,
         topic: &Pox4SignatureTopic,
@@ -431,7 +419,6 @@ pub mod tests {
         public_key: &Secp256k1PublicKey,
         signature: Vec<u8>,
     ) -> bool {
-        // let func_body = get_signer_message_sig_function_str();
         let program = format!(
             r#"
             {}
diff --git a/stackslib/src/util_lib/signed_structured_data.rs b/stackslib/src/util_lib/signed_structured_data.rs
index 7aa215d743..623766739f 100644
--- a/stackslib/src/util_lib/signed_structured_data.rs
+++ b/stackslib/src/util_lib/signed_structured_data.rs
@@ -152,12 +152,17 @@ pub mod pox4 {
             ClarityVersion,
         };
         use stacks_common::{
-            address::AddressHashMode, consts::CHAIN_ID_TESTNET, types::chainstate::StacksAddress,
-            util::secp256k1::Secp256k1PublicKey,
+            address::AddressHashMode,
+            consts::CHAIN_ID_TESTNET,
+            types::chainstate::StacksAddress,
+            util::{hash::to_hex, secp256k1::Secp256k1PublicKey},
         };
 
         use crate::{
-            chainstate::stacks::boot::{contract_tests::ClarityTestSim, POX_4_CODE, POX_4_NAME},
+            chainstate::stacks::{
+                address::pox_addr_b58_serialize,
+                boot::{contract_tests::ClarityTestSim, POX_4_CODE, POX_4_NAME},
+            },
             util_lib::boot::boot_code_id,
         };
 
@@ -242,8 +247,7 @@ pub mod pox4 {
             let stacks_addr = StacksAddress::p2pkh(false, &pubkey);
             let pubkey = Secp256k1PublicKey::new();
             let principal = PrincipalData::from(stacks_addr.clone());
-            let pox_addr =
-                PoxAddress::from_legacy(AddressHashMode::SerializeP2PKH, stacks_addr.bytes.clone());
+            let pox_addr = PoxAddress::standard_burn_address(false);
             let reward_cycle: u128 = 1;
             let topic = Pox4SignatureTopic::StackStx;
             let lock_period = 12;
@@ -255,6 +259,15 @@ pub mod pox4 {
                 CHAIN_ID_TESTNET,
                 lock_period,
             );
+            println!(
+                "Hash: 0x{}",
+                to_hex(expected_hash_vec.as_bytes().as_slice())
+            );
+            println!(
+                "Pubkey: {}",
+                to_hex(pubkey.to_bytes_compressed().as_slice())
+            );
+            // println!("PoxAddr: {}", pox_addr_b58_serialize(&pox_addr).unwrap());
             let expected_hash = expected_hash_vec.as_bytes();
 
             // Test 1: valid result
@@ -317,6 +330,27 @@ pub mod pox4 {
             );
             assert_ne!(expected_hash.clone(), result.as_slice());
         }
+
+        #[test]
+        /// Fixture message hash to test against in other libraries
+        fn test_sig_hash_fixture() {
+            let fixture = "3dd864afd98609df3911a7ab6f0338ace129e56ad394d85866d298a7eda3ad98";
+            let pox_addr = PoxAddress::standard_burn_address(false);
+            let pubkey_hex = "0206952cd8813a64f7b97144c984015490a8f9c5778e8f928fbc8aa6cbf02f48e6";
+            let pubkey = Secp256k1PublicKey::from_hex(pubkey_hex).unwrap();
+            let reward_cycle: u128 = 1;
+            let lock_period = 12;
+
+            let message_hash = make_pox_4_signer_key_message_hash(
+                &pox_addr,
+                reward_cycle,
+                &Pox4SignatureTopic::StackStx,
+                CHAIN_ID_TESTNET,
+                lock_period,
+            );
+
+            assert_eq!(to_hex(message_hash.as_bytes()), fixture);
+        }
     }
 }
 

From 163bb081099ec95d3c6e7be99e54f276dfc5f969 Mon Sep 17 00:00:00 2001
From: Matthew Little <zone117x@gmail.com>
Date: Fri, 9 Feb 2024 16:29:57 +0100
Subject: [PATCH 0712/1166] fix: buids on various archs/platforms

---
 Cargo.lock               | 297 ++-------------------------------------
 Cargo.toml               |   2 +-
 stacks-signer/Cargo.toml |   2 +-
 3 files changed, 15 insertions(+), 286 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 8d857db6b6..41c2c8e924 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -441,40 +441,12 @@ version = "0.21.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a4a4ddaa51a5bc52a6948f74c06d20aaaddb71924eab79b8c97a8c556e942d6a"
 
-[[package]]
-name = "bindgen"
-version = "0.64.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4243e6031260db77ede97ad86c27e501d646a27ab57b59a574f725d98ab1fb4"
-dependencies = [
- "bitflags 1.3.2",
- "cexpr",
- "clang-sys",
- "lazy_static",
- "lazycell",
- "log",
- "peeking_take_while",
- "proc-macro2",
- "quote",
- "regex",
- "rustc-hash",
- "shlex",
- "syn 1.0.109",
- "which",
-]
-
 [[package]]
 name = "bitflags"
 version = "1.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
-[[package]]
-name = "bitflags"
-version = "2.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4682ae6287fcf752ecaabbfcc7b6f9b72aa33933dc23a554d853aea8eea8635"
-
 [[package]]
 name = "bitvec"
 version = "1.0.1"
@@ -597,15 +569,6 @@ version = "1.0.79"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "50d30906286121d95be3d479533b458f87493b30a4b5f79a607db8f5d11aa91f"
 
-[[package]]
-name = "cexpr"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6fac387a98bb7c37292057cffc56d62ecb629900026402633ae9160df93a8766"
-dependencies = [
- "nom",
-]
-
 [[package]]
 name = "cfg-if"
 version = "0.1.10"
@@ -658,24 +621,13 @@ dependencies = [
  "inout",
 ]
 
-[[package]]
-name = "clang-sys"
-version = "1.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c688fc74432808e3eb684cae8830a86be1d66a2bd58e1f248ed0960a590baf6f"
-dependencies = [
- "glob",
- "libc",
- "libloading",
-]
-
 [[package]]
 name = "clap"
 version = "2.34.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a0610544180c38b88101fecf2dd634b174a62eef6946f84dfc6a7127512b381c"
 dependencies = [
- "bitflags 1.3.2",
+ "bitflags",
  "textwrap",
  "unicode-width",
 ]
@@ -1240,21 +1192,6 @@ version = "1.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
 
-[[package]]
-name = "foreign-types"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
-dependencies = [
- "foreign-types-shared",
-]
-
-[[package]]
-name = "foreign-types-shared"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
-
 [[package]]
 name = "form_urlencoded"
 version = "1.1.0"
@@ -1270,7 +1207,7 @@ version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2e9763c69ebaae630ba35f74888db465e49e259ba1bc0eda7d06f4a067615d82"
 dependencies = [
- "bitflags 1.3.2",
+ "bitflags",
  "fuchsia-zircon-sys",
 ]
 
@@ -1463,12 +1400,6 @@ version = "0.27.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ad0a93d233ebf96623465aad4046a8d3aa4da22d4f4beba5388838c8a434bbb4"
 
-[[package]]
-name = "glob"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b"
-
 [[package]]
 name = "gloo-timers"
 version = "0.2.6"
@@ -1548,7 +1479,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f3e372db8e5c0d213e0cd0b9be18be2aca3d44cf2fe30a9d46a65581cd454584"
 dependencies = [
  "base64 0.13.1",
- "bitflags 1.3.2",
+ "bitflags",
  "bytes",
  "headers-core",
  "http",
@@ -1725,19 +1656,6 @@ dependencies = [
  "tokio-rustls",
 ]
 
-[[package]]
-name = "hyper-tls"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d6183ddfa99b85da61a140bea0efc93fdf56ceaa041b37d553518030827f9905"
-dependencies = [
- "bytes",
- "hyper",
- "native-tls",
- "tokio",
- "tokio-native-tls",
-]
-
 [[package]]
 name = "iana-time-zone"
 version = "0.1.53"
@@ -1929,12 +1847,6 @@ version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
 
-[[package]]
-name = "lazycell"
-version = "1.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
-
 [[package]]
 name = "libc"
 version = "0.2.151"
@@ -1961,16 +1873,6 @@ dependencies = [
  "rle-decode-fast",
 ]
 
-[[package]]
-name = "libloading"
-version = "0.7.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b67380fd3b2fbe7527a606e18729d21c6f3951633d0500574c4dc22d2d638b9f"
-dependencies = [
- "cfg-if 1.0.0",
- "winapi 0.3.9",
-]
-
 [[package]]
 name = "libsigner"
 version = "0.0.1"
@@ -2036,12 +1938,6 @@ version = "0.3.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ef53942eb7bf7ff43a617b3e2c1c4a5ecf5944a7c1bc12d7ee39bbb15e5c1519"
 
-[[package]]
-name = "linux-raw-sys"
-version = "0.4.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4cd1a83af159aa67994778be9070f0ae1bd732942279cabb14f86f986a21456"
-
 [[package]]
 name = "lock_api"
 version = "0.4.11"
@@ -2111,12 +2007,6 @@ dependencies = [
  "unicase",
 ]
 
-[[package]]
-name = "minimal-lexical"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
-
 [[package]]
 name = "miniz_oxide"
 version = "0.6.2"
@@ -2187,24 +2077,6 @@ dependencies = [
  "version_check",
 ]
 
-[[package]]
-name = "native-tls"
-version = "0.2.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07226173c32f2926027b63cce4bcd8076c3552846cbe7925f3aaffeac0a3b92e"
-dependencies = [
- "lazy_static",
- "libc",
- "log",
- "openssl",
- "openssl-probe",
- "openssl-sys",
- "schannel",
- "security-framework",
- "security-framework-sys",
- "tempfile",
-]
-
 [[package]]
 name = "net2"
 version = "0.2.38"
@@ -2222,23 +2094,13 @@ version = "0.23.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8f3790c00a0150112de0f4cd161e3d7fc4b2d8a5542ffc35f099a2562aecb35c"
 dependencies = [
- "bitflags 1.3.2",
+ "bitflags",
  "cc",
  "cfg-if 1.0.0",
  "libc",
  "memoffset 0.6.5",
 ]
 
-[[package]]
-name = "nom"
-version = "7.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
-dependencies = [
- "memchr",
- "minimal-lexical",
-]
-
 [[package]]
 name = "nu-ansi-term"
 version = "0.46.0"
@@ -2320,50 +2182,6 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "624a8340c38c1b80fd549087862da4ba43e08858af025b236e509b6649fc13d5"
 
-[[package]]
-name = "openssl"
-version = "0.10.57"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bac25ee399abb46215765b1cb35bc0212377e58a061560d8b29b024fd0430e7c"
-dependencies = [
- "bitflags 2.4.0",
- "cfg-if 1.0.0",
- "foreign-types",
- "libc",
- "once_cell",
- "openssl-macros",
- "openssl-sys",
-]
-
-[[package]]
-name = "openssl-macros"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.29",
-]
-
-[[package]]
-name = "openssl-probe"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf"
-
-[[package]]
-name = "openssl-sys"
-version = "0.9.93"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db4d56a4c0478783083cfafcc42493dd4a981d41669da64b4572a2a089b51b1d"
-dependencies = [
- "cc",
- "libc",
- "pkg-config",
- "vcpkg",
-]
-
 [[package]]
 name = "overload"
 version = "0.1.1"
@@ -2376,7 +2194,6 @@ version = "7.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3a64d160b891178fb9d43d1a58ddcafb6502daeb54d810e5e92a7c3c9bfacc07"
 dependencies = [
- "bindgen",
  "bitvec",
  "bs58 0.4.0",
  "cc",
@@ -2448,12 +2265,6 @@ dependencies = [
  "windows-targets 0.48.5",
 ]
 
-[[package]]
-name = "peeking_take_while"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "19b17cddbe7ec3f8bc800887bab5e717348c95ea2ca0b1bf0837fb964dc67099"
-
 [[package]]
 name = "percent-encoding"
 version = "2.2.0"
@@ -2549,7 +2360,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7e1f879b2998099c2d69ab9605d145d5b661195627eccc680002c4918a7fb6fa"
 dependencies = [
  "autocfg",
- "bitflags 1.3.2",
+ "bitflags",
  "cfg-if 1.0.0",
  "concurrent-queue",
  "libc",
@@ -2809,7 +2620,7 @@ version = "0.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fb5a58c1855b4b6819d59012155603f0b22ad30cad752600aadfcb695265519a"
 dependencies = [
- "bitflags 1.3.2",
+ "bitflags",
 ]
 
 [[package]]
@@ -2818,7 +2629,7 @@ version = "0.3.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "567664f262709473930a4bf9e51bf2ebf3348f2e748ccc50dea20646858f8f29"
 dependencies = [
- "bitflags 1.3.2",
+ "bitflags",
 ]
 
 [[package]]
@@ -2827,7 +2638,7 @@ version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa"
 dependencies = [
- "bitflags 1.3.2",
+ "bitflags",
 ]
 
 [[package]]
@@ -2887,12 +2698,10 @@ dependencies = [
  "http-body",
  "hyper",
  "hyper-rustls",
- "hyper-tls",
  "ipnet",
  "js-sys",
  "log",
  "mime",
- "native-tls",
  "once_cell",
  "percent-encoding",
  "pin-project-lite",
@@ -2903,7 +2712,6 @@ dependencies = [
  "serde_urlencoded",
  "system-configuration",
  "tokio",
- "tokio-native-tls",
  "tokio-rustls",
  "tower-service",
  "url",
@@ -3012,7 +2820,7 @@ version = "0.24.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d5f38ee71cbab2c827ec0ac24e76f82eca723cee92c509a65f67dee393c25112"
 dependencies = [
- "bitflags 1.3.2",
+ "bitflags",
  "byteorder",
  "fallible-iterator",
  "fallible-streaming-iterator",
@@ -3029,12 +2837,6 @@ version = "0.1.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7ef03e0a2b150c7a90d01faf6254c9c48a41e95fb2a8c2ac1c6f0d2b9aefc342"
 
-[[package]]
-name = "rustc-hash"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
-
 [[package]]
 name = "rustc-hex"
 version = "2.1.0"
@@ -3087,27 +2889,14 @@ version = "0.37.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2aae838e49b3d63e9274e1c01833cc8139d3fec468c3b84688c628f44b1ae11d"
 dependencies = [
- "bitflags 1.3.2",
+ "bitflags",
  "errno",
  "io-lifetimes",
  "libc",
- "linux-raw-sys 0.3.8",
+ "linux-raw-sys",
  "windows-sys 0.45.0",
 ]
 
-[[package]]
-name = "rustix"
-version = "0.38.21"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b426b0506e5d50a7d8dafcf2e81471400deb602392c7dd110815afb4eaf02a3"
-dependencies = [
- "bitflags 2.4.0",
- "errno",
- "libc",
- "linux-raw-sys 0.4.12",
- "windows-sys 0.48.0",
-]
-
 [[package]]
 name = "rustls"
 version = "0.21.7"
@@ -3160,15 +2949,6 @@ dependencies = [
  "winapi-util",
 ]
 
-[[package]]
-name = "schannel"
-version = "0.1.22"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c3733bf4cf7ea0880754e19cb5a462007c4a8c1914bff372ccc95b464f1df88"
-dependencies = [
- "windows-sys 0.48.0",
-]
-
 [[package]]
 name = "scoped-tls"
 version = "1.0.1"
@@ -3216,29 +2996,6 @@ dependencies = [
  "cc",
 ]
 
-[[package]]
-name = "security-framework"
-version = "2.9.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05b64fb303737d99b81884b2c63433e9ae28abebe5eb5045dcdd175dc2ecf4de"
-dependencies = [
- "bitflags 1.3.2",
- "core-foundation",
- "core-foundation-sys",
- "libc",
- "security-framework-sys",
-]
-
-[[package]]
-name = "security-framework-sys"
-version = "2.9.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e932934257d3b408ed8f30db49d85ea163bfe74961f017f405b025af298f0c7a"
-dependencies = [
- "core-foundation-sys",
- "libc",
-]
-
 [[package]]
 name = "semver"
 version = "0.9.0"
@@ -3477,12 +3234,6 @@ dependencies = [
  "lazy_static",
 ]
 
-[[package]]
-name = "shlex"
-version = "1.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a7cee0529a6d40f580e7a5e6c495c8fbfe21b7b52795ed4bb5e62cdf92bc6380"
-
 [[package]]
 name = "simple-mutex"
 version = "1.1.5"
@@ -3847,7 +3598,7 @@ version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ba3a3adc5c275d719af8cb4272ea1c4a6d668a777f37e115f6d11ddbc1c8e0e7"
 dependencies = [
- "bitflags 1.3.2",
+ "bitflags",
  "core-foundation",
  "system-configuration-sys",
 ]
@@ -3877,7 +3628,7 @@ dependencies = [
  "cfg-if 1.0.0",
  "fastrand",
  "redox_syscall 0.3.5",
- "rustix 0.37.7",
+ "rustix",
  "windows-sys 0.45.0",
 ]
 
@@ -4072,16 +3823,6 @@ dependencies = [
  "windows-sys 0.45.0",
 ]
 
-[[package]]
-name = "tokio-native-tls"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbae76ab933c85776efabc971569dd6119c580d8f5d448769dec1764bf796ef2"
-dependencies = [
- "native-tls",
- "tokio",
-]
-
 [[package]]
 name = "tokio-rustls"
 version = "0.24.1"
@@ -4558,18 +4299,6 @@ version = "0.25.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "14247bb57be4f377dfb94c72830b8ce8fc6beac03cf4bf7b9732eadd414123fc"
 
-[[package]]
-name = "which"
-version = "4.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87ba24419a2078cd2b0f2ede2691b6c66d8e47836da3b6db8265ebad47afbfc7"
-dependencies = [
- "either",
- "home",
- "once_cell",
- "rustix 0.38.21",
-]
-
 [[package]]
 name = "winapi"
 version = "0.2.8"
diff --git a/Cargo.toml b/Cargo.toml
index e9af4f43dc..265dc3cee5 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -14,7 +14,7 @@ members = [
 
 # Dependencies we want to keep the same between workspace members
 [workspace.dependencies]  
-wsts = "8.0"
+wsts = { version = "8.0", default-features = false }
 rand_core = "0.6"
 rand = "0.8"
 
diff --git a/stacks-signer/Cargo.toml b/stacks-signer/Cargo.toml
index c7900c20e4..899725fb89 100644
--- a/stacks-signer/Cargo.toml
+++ b/stacks-signer/Cargo.toml
@@ -27,7 +27,7 @@ hashbrown = "0.14"
 libsigner = { path = "../libsigner" }
 libstackerdb = { path = "../libstackerdb" }
 rand_core = "0.6"
-reqwest = { version = "0.11.22", features = ["blocking", "json"] }
+reqwest = { version = "0.11.22", default-features = false, features = ["blocking", "json", "rustls-tls"] }
 serde = "1"
 serde_derive = "1"
 serde_stacker = "0.1"

From cafa35e2b4f68cb4c9c83588d9e79a3d9ea5cc41 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Fri, 9 Feb 2024 14:11:24 -0500
Subject: [PATCH 0713/1166] chore: fix broken boot_to_epoch_3()

---
 .../src/tests/nakamoto_integrations.rs        | 21 +++++++++++--------
 testnet/stacks-node/src/tests/signer.rs       |  7 +------
 2 files changed, 13 insertions(+), 15 deletions(-)

diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 7eb02b76cb..38c2a74415 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -357,11 +357,11 @@ pub fn setup_stacker(naka_conf: &mut Config) -> Secp256k1PrivateKey {
 pub fn boot_to_epoch_3(
     naka_conf: &Config,
     blocks_processed: &RunLoopCounter,
-    stacker_sks: &[Secp256k1PrivateKey],
-    signer_pks: &[StacksPublicKey],
+    stacker_sks: &[StacksPrivateKey],
+    signer_sks: &[StacksPrivateKey],
     btc_regtest_controller: &mut BitcoinRegtestController,
 ) {
-    assert_eq!(stacker_sks.len(), signer_pks.len());
+    assert_eq!(stacker_sks.len(), signer_sks.len());
 
     let epochs = naka_conf.burnchain.epochs.clone().unwrap();
     let epoch_3 = &epochs[StacksEpoch::find_epoch_by_id(&epochs, StacksEpochId::Epoch30).unwrap()];
@@ -384,7 +384,7 @@ pub fn boot_to_epoch_3(
         .block_height_to_reward_cycle(block_height)
         .unwrap();
 
-    for (stacker_sk, signer_pk) in stacker_sks.iter().zip(signer_pks.iter()) {
+    for (stacker_sk, signer_sk) in stacker_sks.iter().zip(signer_sks.iter()) {
         let pox_addr = PoxAddress::from_legacy(
             AddressHashMode::SerializeP2PKH,
             tests::to_addr(&stacker_sk).bytes,
@@ -393,7 +393,7 @@ pub fn boot_to_epoch_3(
             pox_addr.clone().as_clarity_tuple().unwrap().into();
         let signature = make_pox_4_signer_key_signature(
             &pox_addr,
-            stacker_sk,
+            &signer_sk,
             reward_cycle.into(),
             &Pox4SignatureTopic::StackStx,
             CHAIN_ID_TESTNET,
@@ -401,6 +401,9 @@ pub fn boot_to_epoch_3(
         )
         .unwrap()
         .to_rsv();
+
+        let signer_pk = StacksPublicKey::from_private(signer_sk);
+
         let stacking_tx = tests::make_contract_call(
             &stacker_sk,
             0,
@@ -493,7 +496,7 @@ fn simple_neon_integration() {
         &naka_conf,
         &blocks_processed,
         &[stacker_sk],
-        &[StacksPublicKey::from_private(&sender_signer_sk)],
+        &[sender_signer_sk],
         &mut btc_regtest_controller,
     );
 
@@ -713,7 +716,7 @@ fn mine_multiple_per_tenure_integration() {
         &naka_conf,
         &blocks_processed,
         &[stacker_sk],
-        &[StacksPublicKey::from_private(&sender_signer_key)],
+        &[sender_signer_key],
         &mut btc_regtest_controller,
     );
 
@@ -1146,7 +1149,7 @@ fn block_proposal_api_endpoint() {
         &conf,
         &blocks_processed,
         &[stacker_sk],
-        &[StacksPublicKey::default()],
+        &[StacksPrivateKey::default()],
         &mut btc_regtest_controller,
     );
 
@@ -1489,7 +1492,7 @@ fn miner_writes_proposed_block_to_stackerdb() {
         &naka_conf,
         &blocks_processed,
         &[stacker_sk],
-        &[StacksPublicKey::default()],
+        &[StacksPrivateKey::default()],
         &mut btc_regtest_controller,
     );
 
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index 76277a4188..6c151cf196 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -223,11 +223,6 @@ fn setup_stx_btc_node(
         });
     }
 
-    let signer_stacks_pubks: Vec<_> = signer_stacks_private_keys
-        .iter()
-        .map(|pk| StacksPublicKey::from_private(pk))
-        .collect();
-
     // Spawn a test observer for verification purposes
     test_observer::spawn();
     let observer_port = test_observer::EVENT_OBSERVER_PORT;
@@ -309,7 +304,7 @@ fn setup_stx_btc_node(
         &naka_conf,
         &blocks_processed,
         signer_stacks_private_keys,
-        &signer_stacks_pubks,
+        &[StacksPrivateKey::default()],
         &mut btc_regtest_controller,
     );
 

From 0772e75bac1dbaf22ef8f74157811690fdd60bd6 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Fri, 9 Feb 2024 15:06:47 -0500
Subject: [PATCH 0714/1166] chore: fix integration test to use the expected
 signer keys

---
 stacks-signer/src/runloop.rs            | 7 ++++++-
 stackslib/src/clarity_vm/clarity.rs     | 2 +-
 testnet/stacks-node/src/tests/signer.rs | 2 +-
 3 files changed, 8 insertions(+), 3 deletions(-)

diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index c2fc5a1768..ccce59aeaf 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -1088,7 +1088,12 @@ impl<C: Coordinator> SignerRunLoop<Vec<OperationResult>, RunLoopCommand> for Run
         // TODO: This should be called every time as DKG can change at any time...but until we have the node
         // set up to receive cast votes...just do on initialization.
         if self.state == State::Uninitialized {
-            let request_fn = || self.initialize().map_err(backoff::Error::transient);
+            let request_fn = || {
+                self.initialize().map_err(|e| {
+                    warn!("Failed to initialize: {:?}", &e);
+                    backoff::Error::transient(e)
+                })
+            };
             retry_with_exponential_backoff(request_fn)
                 .expect("Failed to connect to initialize due to timeout. Stacks node may be down.");
         }
diff --git a/stackslib/src/clarity_vm/clarity.rs b/stackslib/src/clarity_vm/clarity.rs
index d6bf134a2f..a8059bd0ed 100644
--- a/stackslib/src/clarity_vm/clarity.rs
+++ b/stackslib/src/clarity_vm/clarity.rs
@@ -1510,7 +1510,7 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
 
                     let signers_db_receipt = self.as_transaction(|tx_conn| {
                         // initialize with a synthetic transaction
-                        debug!("Instantiate {} contract", &signers_contract_id);
+                        debug!("Instantiate .{} contract", &signers_name);
                         let receipt = StacksChainState::process_transaction_payload(
                             tx_conn,
                             &signers_contract_tx,
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index 6c151cf196..e2cf03b247 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -304,7 +304,7 @@ fn setup_stx_btc_node(
         &naka_conf,
         &blocks_processed,
         signer_stacks_private_keys,
-        &[StacksPrivateKey::default()],
+        signer_stacks_private_keys,
         &mut btc_regtest_controller,
     );
 

From 7f7707ca504c91a99f6edf3114474fdeb009b0ff Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Fri, 9 Feb 2024 22:11:14 -0500
Subject: [PATCH 0715/1166] fix: .expect_result() returns Result<Result<..>,
 ..>, so `try!` to remove that outer error before acting on a blanket `Ok(_)`
 / `Err(_)` match

---
 clarity/src/vm/contexts.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/clarity/src/vm/contexts.rs b/clarity/src/vm/contexts.rs
index e90e5bc9b9..e27d5a129d 100644
--- a/clarity/src/vm/contexts.rs
+++ b/clarity/src/vm/contexts.rs
@@ -1359,7 +1359,7 @@ impl<'a, 'b, 'hooks> Environment<'a, 'b, 'hooks> {
         self.global_context.begin();
         let result = stx_transfer_consolidated(self, from, to, amount, memo);
         match result {
-            Ok(value) => match value.clone().expect_result() {
+            Ok(value) => match value.clone().expect_result()? {
                 Ok(_) => {
                     self.global_context.commit()?;
                     Ok(value)

From 4b101a41c000dcae058d21e977e336ceff9ec850 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Fri, 9 Feb 2024 14:01:59 -0500
Subject: [PATCH 0716/1166] feat: Add `--first` flag to `replay-block`

---
 stackslib/src/main.rs | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/stackslib/src/main.rs b/stackslib/src/main.rs
index 28b4f35a65..7c88ea7092 100644
--- a/stackslib/src/main.rs
+++ b/stackslib/src/main.rs
@@ -863,7 +863,7 @@ simulating a miner.
     if argv[1] == "replay-block" {
         if argv.len() < 2 {
             eprintln!(
-                "Usage: {} <chainstate_path> [--prefix <index-block-hash-prefix>] [--last <block_count>]",
+                "Usage: {} <chainstate_path> [--prefix <index-block-hash-prefix>] [<--last|--first> <block_count>]",
                 &argv[0]
             );
             process::exit(1);
@@ -880,6 +880,10 @@ simulating a miner.
                 "SELECT index_block_hash FROM staging_blocks WHERE index_block_hash LIKE \"{}%\"",
                 argv[4]
             ),
+            Some("--first") => format!(
+                "SELECT index_block_hash FROM staging_blocks ORDER BY height ASC LIMIT {}",
+                argv[4]
+            ),
             Some("--last") => format!(
                 "SELECT index_block_hash FROM staging_blocks ORDER BY height DESC LIMIT {}",
                 argv[4]
@@ -1533,9 +1537,9 @@ simulating a miner.
 
 fn replay_block(stacks_path: &str, index_block_hash_hex: &str) {
     let index_block_hash = StacksBlockId::from_hex(index_block_hash_hex).unwrap();
-    let chain_state_path = format!("{}/mainnet/chainstate/", stacks_path);
-    let sort_db_path = format!("{}/mainnet/burnchain/sortition", stacks_path);
-    let burn_db_path = format!("{}/mainnet/burnchain/burnchain.sqlite", stacks_path);
+    let chain_state_path = format!("{stacks_path}/mainnet/chainstate/");
+    let sort_db_path = format!("{stacks_path}/mainnet/burnchain/sortition");
+    let burn_db_path = format!("{stacks_path}/mainnet/burnchain/burnchain.sqlite");
     let burnchain_blocks_db = BurnchainDB::open(&burn_db_path, false).unwrap();
 
     let (mut chainstate, _) =

From 6b87b776cc7f0cd9e1b75bbd6cec8a946df6901e Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Thu, 8 Feb 2024 07:33:22 -0500
Subject: [PATCH 0717/1166] updated error message format to match pox-4
 messages

---
 .../stacks/boot/signers-voting.clar           | 30 +++++++++----------
 .../stacks/boot/signers_voting_tests.rs       |  4 +--
 2 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers-voting.clar b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
index 9b30c137a3..5192386ba1 100644
--- a/stackslib/src/chainstate/stacks/boot/signers-voting.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
@@ -9,14 +9,14 @@
 ;; maps aggregate public keys to rewards cycles and rounds
 (define-map used-aggregate-public-keys (buff 33) {reward-cycle: uint, round: uint})
 
-(define-constant err-signer-index-mismatch (err u10000))
-(define-constant err-invalid-signer-index (err u10001))
-(define-constant err-out-of-voting-window (err u10002))
-(define-constant err-old-round (err u10003))
-(define-constant err-ill-formed-aggregate-public-key (err u10004))
-(define-constant err-duplicate-aggregate-public-key (err u10005))
-(define-constant err-duplicate-vote (err u10006))
-(define-constant err-invalid-burn-block-height (err u10007))
+(define-constant ERR_SIGNER_INDEX_MISMATCH 1)
+(define-constant ERR_INVALID_SIGNER_INDEX 2)
+(define-constant ERR_OUT_OF_VOTING_WINDOW 3)
+(define-constant ERR_OLD_ROUND 4)
+(define-constant ERR_ILL_FORMED_AGGREGATE_PUBLIC_KEY 5)
+(define-constant ERR_DUPLICATE_AGGREGATE_PUBLIC_KEY 6)
+(define-constant ERR_DUPLICATE_VOTE 7)
+(define-constant ERR_INVALID_BURN_BLOCK_HEIGHT 8)
 
 (define-constant pox-info
     (unwrap-panic (contract-call? .pox-4 get-pox-info)))
@@ -47,8 +47,8 @@
       (get-signer-slots signer-index cycle)))
 
 (define-read-only (get-signer-slots (signer-index uint) (reward-cycle uint))
-    (let ((details (unwrap! (try! (contract-call? .signers get-signer-by-index reward-cycle signer-index)) err-invalid-signer-index)))
-        (asserts! (is-eq (get signer details) tx-sender) err-signer-index-mismatch)
+    (let ((details (unwrap! (try! (contract-call? .signers get-signer-by-index reward-cycle signer-index)) (err (to-uint ERR_INVALID_SIGNER_INDEX)))))
+        (asserts! (is-eq (get signer details) tx-sender) (err (to-uint ERR_SIGNER_INDEX_MISMATCH)))
         (ok (get weight details))))
 
 ;; aggregate public key must be unique and can be used only in a single cycle-round pair
@@ -73,11 +73,11 @@
             ;; one slot, one vote
             (num-slots (try! (get-current-signer-slots signer-index)))
             (new-total (+ num-slots (default-to u0 (map-get? tally tally-key)))))
-        (asserts! (is-in-voting-window burn-block-height reward-cycle) err-out-of-voting-window)
-        (asserts! (>= round (default-to u0 (map-get? rounds reward-cycle))) err-old-round)
-        (asserts! (is-eq (len key) u33) err-ill-formed-aggregate-public-key)
-        (asserts! (is-valid-aggregated-public-key key {reward-cycle: reward-cycle, round: round}) err-duplicate-aggregate-public-key)
-        (asserts! (map-insert votes {reward-cycle: reward-cycle, round: round, signer: tx-sender} {aggregate-public-key: key, reward-slots: num-slots}) err-duplicate-vote)
+        (asserts! (is-in-voting-window burn-block-height reward-cycle) (err (to-uint ERR_OUT_OF_VOTING_WINDOW)))
+        (asserts! (>= round (default-to u0 (map-get? rounds reward-cycle))) (err (to-uint ERR_OLD_ROUND)))
+        (asserts! (is-eq (len key) u33) (err (to-uint ERR_ILL_FORMED_AGGREGATE_PUBLIC_KEY)))
+        (asserts! (is-valid-aggregated-public-key key {reward-cycle: reward-cycle, round: round}) (err (to-uint ERR_DUPLICATE_AGGREGATE_PUBLIC_KEY)))
+        (asserts! (map-insert votes {reward-cycle: reward-cycle, round: round, signer: tx-sender} {aggregate-public-key: key, reward-slots: num-slots}) (err (to-uint ERR_DUPLICATE_VOTE)))
         (map-set tally tally-key new-total)
         (map-set used-aggregate-public-keys key {reward-cycle: reward-cycle, round: round})
         (update-last-round reward-cycle round)
diff --git a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
index 9fff91e6b7..8766dfc342 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
@@ -213,7 +213,7 @@ fn vote_for_aggregate_public_key_in_first_block() {
         tx2.result,
         Value::Response(ResponseData {
             committed: false,
-            data: Box::new(Value::UInt(10006)) // err-duplicate-vote
+            data: Box::new(Value::UInt(7)) // err-duplicate-vote
         })
     );
 }
@@ -352,7 +352,7 @@ fn vote_for_aggregate_public_key_in_last_block() {
         tx2.result,
         Value::Response(ResponseData {
             committed: false,
-            data: Box::new(Value::UInt(10006)) // err-duplicate-vote
+            data: Box::new(Value::UInt(7)) // err-duplicate-vote
         })
     );
 

From b5e765c2990c9818b7fcc9fa19f19ffbed76a145 Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Thu, 8 Feb 2024 08:36:43 -0500
Subject: [PATCH 0718/1166] updated funcs name to reflect weight instead of
 slots

---
 stackslib/src/chainstate/stacks/boot/signers-voting.clar | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers-voting.clar b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
index 5192386ba1..221264af15 100644
--- a/stackslib/src/chainstate/stacks/boot/signers-voting.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
@@ -42,11 +42,11 @@
 (define-read-only (get-tally (reward-cycle uint) (round uint) (aggregate-public-key (buff 33)))
     (map-get? tally {reward-cycle: reward-cycle, round: round, aggregate-public-key: aggregate-public-key}))
 
-(define-read-only (get-current-signer-slots (signer-index uint))
+(define-read-only (get-current-signer-weight (signer-index uint))
     (let ((cycle (+ u1 (burn-height-to-reward-cycle burn-block-height))))
-      (get-signer-slots signer-index cycle)))
+      (get-signer-weight signer-index cycle)))
 
-(define-read-only (get-signer-slots (signer-index uint) (reward-cycle uint))
+(define-read-only (get-signer-weight (signer-index uint) (reward-cycle uint))
     (let ((details (unwrap! (try! (contract-call? .signers get-signer-by-index reward-cycle signer-index)) (err (to-uint ERR_INVALID_SIGNER_INDEX)))))
         (asserts! (is-eq (get signer details) tx-sender) (err (to-uint ERR_SIGNER_INDEX_MISMATCH)))
         (ok (get weight details))))
@@ -71,7 +71,7 @@
     (let ((reward-cycle (+ u1 (burn-height-to-reward-cycle burn-block-height)))
             (tally-key {reward-cycle: reward-cycle, round: round, aggregate-public-key: key})
             ;; one slot, one vote
-            (num-slots (try! (get-current-signer-slots signer-index)))
+            (num-slots (try! (get-current-signer-weight signer-index)))
             (new-total (+ num-slots (default-to u0 (map-get? tally tally-key)))))
         (asserts! (is-in-voting-window burn-block-height reward-cycle) (err (to-uint ERR_OUT_OF_VOTING_WINDOW)))
         (asserts! (>= round (default-to u0 (map-get? rounds reward-cycle))) (err (to-uint ERR_OLD_ROUND)))

From fa27b97adbf201eef03ecde3360cf00e93d9a3db Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Thu, 8 Feb 2024 09:35:28 -0500
Subject: [PATCH 0719/1166] added vote func comments

---
 .../stacks/boot/signers-voting.clar           | 20 +++++++++++++++----
 .../stacks/boot/signers_voting_tests.rs       |  7 +++----
 2 files changed, 19 insertions(+), 8 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers-voting.clar b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
index 221264af15..2c4d84af5a 100644
--- a/stackslib/src/chainstate/stacks/boot/signers-voting.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
@@ -67,18 +67,30 @@
         (and (is-eq last-cycle reward-cycle)
             (is-in-prepare-phase height))))
 
+;; Signer vote for the aggregate public key of the next reward cycle
+;;  The vote happens in the prepare phase of the current reward cycle but may be ran more than
+;;  once resulting in different 'rounds.' Each signer vote is based on the weight of stacked
+;;  stx tokens & fetched from the .signers contract. The vote is ran until the consensus 
+;;  threshold of 70% for a specific aggregate public key is reached. 
 (define-public (vote-for-aggregate-public-key (signer-index uint) (key (buff 33)) (round uint))
     (let ((reward-cycle (+ u1 (burn-height-to-reward-cycle burn-block-height)))
             (tally-key {reward-cycle: reward-cycle, round: round, aggregate-public-key: key})
-            ;; one slot, one vote
-            (num-slots (try! (get-current-signer-weight signer-index)))
-            (new-total (+ num-slots (default-to u0 (map-get? tally tally-key)))))
+            ;; vote by signer weight
+            (num-weight (try! (get-current-signer-weight signer-index)))
+            (new-total (+ num-weight (default-to u0 (map-get? tally tally-key)))))
+        ;; Check we're in the prepare phase
         (asserts! (is-in-voting-window burn-block-height reward-cycle) (err (to-uint ERR_OUT_OF_VOTING_WINDOW)))
+        ;; Check that vote is for latest round in reward cycle
         (asserts! (>= round (default-to u0 (map-get? rounds reward-cycle))) (err (to-uint ERR_OLD_ROUND)))
+        ;; Check that the aggregate public key is correct length
         (asserts! (is-eq (len key) u33) (err (to-uint ERR_ILL_FORMED_AGGREGATE_PUBLIC_KEY)))
+        ;; Check that aggregate public key has not been used before
         (asserts! (is-valid-aggregated-public-key key {reward-cycle: reward-cycle, round: round}) (err (to-uint ERR_DUPLICATE_AGGREGATE_PUBLIC_KEY)))
-        (asserts! (map-insert votes {reward-cycle: reward-cycle, round: round, signer: tx-sender} {aggregate-public-key: key, reward-slots: num-slots}) (err (to-uint ERR_DUPLICATE_VOTE)))
+        ;; Check that signer hasn't voted in reward-cycle & round
+        (asserts! (map-insert votes {reward-cycle: reward-cycle, round: round, signer: tx-sender} {aggregate-public-key: key, reward-slots: num-weight}) (err (to-uint ERR_DUPLICATE_VOTE)))
+        ;; Update tally aggregate public key candidate
         (map-set tally tally-key new-total)
+        ;; Update used aggregate public keys
         (map-set used-aggregate-public-keys key {reward-cycle: reward-cycle, round: round})
         (update-last-round reward-cycle round)
         (print { 
diff --git a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
index 8766dfc342..8a0d95b4d1 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
@@ -155,7 +155,6 @@ fn vote_for_aggregate_public_key_in_first_block() {
     );
 
     // create vote txs
-
     let signer_nonce = 0;
     let signer_key = &stacker_1.signer_private_key;
     let signer_address = key_to_stacks_addr(signer_key);
@@ -213,7 +212,7 @@ fn vote_for_aggregate_public_key_in_first_block() {
         tx2.result,
         Value::Response(ResponseData {
             committed: false,
-            data: Box::new(Value::UInt(7)) // err-duplicate-vote
+            data: Box::new(Value::UInt(7)) // ERR_DUPLICATE_VOTE
         })
     );
 }
@@ -352,7 +351,7 @@ fn vote_for_aggregate_public_key_in_last_block() {
         tx2.result,
         Value::Response(ResponseData {
             committed: false,
-            data: Box::new(Value::UInt(7)) // err-duplicate-vote
+            data: Box::new(Value::UInt(7)) // ERR_DUPLICATE_VOTE
         })
     );
 
@@ -368,7 +367,7 @@ fn vote_for_aggregate_public_key_in_last_block() {
         tx1.result,
         Value::Response(ResponseData {
             committed: false,
-            data: Box::new(Value::UInt(2)) // err-out-of-voting-window
+            data: Box::new(Value::UInt(2)) // ERR_INVALID_SIGNER_INDEX
         })
     );
 }

From b600a33532749d50451a47c4ab92420460a2de95 Mon Sep 17 00:00:00 2001
From: friedger <mail@friedger.de>
Date: Thu, 1 Feb 2024 16:53:09 +0100
Subject: [PATCH 0720/1166] fix: accept votes for out of round

---
 .../tests/pox-4/signers-voting.test.ts        | 22 ++--------
 .../stacks/boot/signers-voting.clar           |  3 --
 .../stacks/boot/signers_voting_tests.rs       | 40 ++++++++++++++-----
 3 files changed, 34 insertions(+), 31 deletions(-)

diff --git a/contrib/core-contract-tests/tests/pox-4/signers-voting.test.ts b/contrib/core-contract-tests/tests/pox-4/signers-voting.test.ts
index 96b45d426c..a5271900d5 100644
--- a/contrib/core-contract-tests/tests/pox-4/signers-voting.test.ts
+++ b/contrib/core-contract-tests/tests/pox-4/signers-voting.test.ts
@@ -1,34 +1,20 @@
 import { Cl } from "@stacks/transactions";
-import { beforeEach, describe, expect, it } from "vitest";
+import { describe, expect, it } from "vitest";
 
 const accounts = simnet.getAccounts();
 const alice = accounts.get("wallet_1")!;
-const bob = accounts.get("wallet_2")!;
-const charlie = accounts.get("wallet_3")!;
-
-const ERR_SIGNER_INDEX_MISMATCH = 10000;
-const ERR_INVALID_SIGNER_INDEX = 10001;
-const ERR_OUT_OF_VOTING_WINDOW = 10002
-const ERR_OLD_ROUND = 10003;
-const ERR_ILL_FORMED_AGGREGATE_PUBLIC_KEY = 10004;
-const ERR_DUPLICATE_AGGREGATE_PUBLIC_KEY = 10005;
-const ERR_DUPLICATE_VOTE = 10006;
-const ERR_INVALID_BURN_BLOCK_HEIGHT = 10007
-
-const KEY_1 = "123456789a123456789a123456789a123456789a123456789a123456789a010203";
-const KEY_2 = "123456789a123456789a123456789a123456789a123456789a123456789ab0b1b2";
 const SIGNERS_VOTING = "signers-voting";
 
 describe("test signers-voting contract voting rounds", () => {
     describe("test pox-info", () => {
         it("should return correct burn-height", () => {
-            const { result:result1 } = simnet.callReadOnlyFn(SIGNERS_VOTING,
+            const { result: result1 } = simnet.callReadOnlyFn(SIGNERS_VOTING,
                 "reward-cycle-to-burn-height",
                 [Cl.uint(1)],
                 alice)
             expect(result1).toEqual(Cl.uint(1050))
 
-            const { result:result2 } = simnet.callReadOnlyFn(SIGNERS_VOTING,
+            const { result: result2 } = simnet.callReadOnlyFn(SIGNERS_VOTING,
                 "reward-cycle-to-burn-height",
                 [Cl.uint(2)],
                 alice)
@@ -50,7 +36,7 @@ describe("test signers-voting contract voting rounds", () => {
         })
 
         it("should return true if in prepare phase", () => {
-            const { result:result999 } = simnet.callReadOnlyFn(SIGNERS_VOTING,
+            const { result: result999 } = simnet.callReadOnlyFn(SIGNERS_VOTING,
                 "is-in-prepare-phase",
                 [Cl.uint(999)],
                 alice)
diff --git a/stackslib/src/chainstate/stacks/boot/signers-voting.clar b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
index 2c4d84af5a..000d7edb9d 100644
--- a/stackslib/src/chainstate/stacks/boot/signers-voting.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
@@ -12,7 +12,6 @@
 (define-constant ERR_SIGNER_INDEX_MISMATCH 1)
 (define-constant ERR_INVALID_SIGNER_INDEX 2)
 (define-constant ERR_OUT_OF_VOTING_WINDOW 3)
-(define-constant ERR_OLD_ROUND 4)
 (define-constant ERR_ILL_FORMED_AGGREGATE_PUBLIC_KEY 5)
 (define-constant ERR_DUPLICATE_AGGREGATE_PUBLIC_KEY 6)
 (define-constant ERR_DUPLICATE_VOTE 7)
@@ -80,8 +79,6 @@
             (new-total (+ num-weight (default-to u0 (map-get? tally tally-key)))))
         ;; Check we're in the prepare phase
         (asserts! (is-in-voting-window burn-block-height reward-cycle) (err (to-uint ERR_OUT_OF_VOTING_WINDOW)))
-        ;; Check that vote is for latest round in reward cycle
-        (asserts! (>= round (default-to u0 (map-get? rounds reward-cycle))) (err (to-uint ERR_OLD_ROUND)))
         ;; Check that the aggregate public key is correct length
         (asserts! (is-eq (len key) u33) (err (to-uint ERR_ILL_FORMED_AGGREGATE_PUBLIC_KEY)))
         ;; Check that aggregate public key has not been used before
diff --git a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
index 8a0d95b4d1..1c5ce4ead5 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
@@ -17,6 +17,7 @@
 use std::collections::{HashMap, HashSet, VecDeque};
 use std::convert::{TryFrom, TryInto};
 
+use ::secp256k1::Scalar;
 use clarity::boot_util::boot_code_addr;
 use clarity::vm::clarity::ClarityConnection;
 use clarity::vm::contexts::OwnedEnvironment;
@@ -255,7 +256,8 @@ fn vote_for_aggregate_public_key_in_last_block() {
     );
 
     let cycle_id: u128 = current_reward_cycle;
-    let aggregated_public_key: Point = Point::new();
+    let aggregate_public_key: Point = Point::new();
+    let aggregate_public_key_1: Point = Point::G();
 
     // create vote txs for alice
     let signer_1_nonce = 0;
@@ -270,15 +272,23 @@ fn vote_for_aggregate_public_key_in_last_block() {
             signer_1_key,
             signer_1_nonce,
             signer_1_index,
-            &aggregated_public_key,
-            0,
+            &aggregate_public_key,
+            1,
         ),
         // cast the vote twice
         make_signers_vote_for_aggregate_public_key(
             signer_1_key,
             signer_1_nonce + 1,
             signer_1_index,
-            &aggregated_public_key,
+            &aggregate_public_key,
+            1,
+        ),
+        // cast a vote for old round
+        make_signers_vote_for_aggregate_public_key(
+            signer_1_key,
+            signer_1_nonce + 2,
+            signer_1_index,
+            &aggregate_public_key_1,
             0,
         ),
     ];
@@ -296,7 +306,7 @@ fn vote_for_aggregate_public_key_in_last_block() {
             signer_2_key,
             signer_2_nonce,
             signer_2_index,
-            &aggregated_public_key,
+            &aggregate_public_key,
             0,
         ),
     ];
@@ -333,10 +343,10 @@ fn vote_for_aggregate_public_key_in_last_block() {
     // alice's block
     let block = &blocks[blocks.len() - 2].clone();
     let receipts = &block.receipts;
-    assert_eq!(receipts.len(), 4);
+    assert_eq!(receipts.len(), 5);
 
     // first vote should succeed
-    let tx1 = &receipts[receipts.len() - 2];
+    let tx1 = &receipts[receipts.len() - 3];
     assert_eq!(
         tx1.result,
         Value::Response(ResponseData {
@@ -346,7 +356,7 @@ fn vote_for_aggregate_public_key_in_last_block() {
     );
 
     // second vote should fail with duplicate vote error
-    let tx2 = &receipts[receipts.len() - 1];
+    let tx2 = &receipts[receipts.len() - 2];
     assert_eq!(
         tx2.result,
         Value::Response(ResponseData {
@@ -355,6 +365,16 @@ fn vote_for_aggregate_public_key_in_last_block() {
         })
     );
 
+    // third vote should succeed even though it is on an old round
+    let tx3 = &receipts[receipts.len() - 1];
+    assert_eq!(
+        tx3.result,
+        Value::Response(ResponseData {
+            committed: true,
+            data: Box::new(Value::Bool(true))
+        })
+    );
+
     // bob's block
     let block = blocks.last().unwrap().clone();
     let receipts = block.receipts.as_slice();
@@ -362,9 +382,9 @@ fn vote_for_aggregate_public_key_in_last_block() {
 
     // vote fails because the reward cycle has changed
     //  and the signer set hasn't been set yet.
-    let tx1 = &receipts[receipts.len() - 1];
+    let tx1_bob = &receipts[receipts.len() - 1];
     assert_eq!(
-        tx1.result,
+        tx1_bob.result,
         Value::Response(ResponseData {
             committed: false,
             data: Box::new(Value::UInt(2)) // ERR_INVALID_SIGNER_INDEX

From 4053af9a3ea3707cbc4d2601076cde9019a14a50 Mon Sep 17 00:00:00 2001
From: friedger <mail@friedger.de>
Date: Sat, 3 Feb 2024 00:01:40 +0100
Subject: [PATCH 0721/1166] chore: better public keys, fix typos

---
 stackslib/src/chainstate/stacks/boot/mod.rs              | 9 ++++-----
 stackslib/src/chainstate/stacks/boot/signers-voting.clar | 4 ++--
 .../src/chainstate/stacks/boot/signers_voting_tests.rs   | 7 ++++---
 3 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 41843f9327..cc49cdfb97 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -1333,9 +1333,8 @@ pub mod test {
     use clarity::vm::contracts::Contract;
     use clarity::vm::tests::symbols_from_values;
     use clarity::vm::types::*;
-    use stacks_common::types::PrivateKey;
-    use stacks_common::util::hash::Sha256Sum;
-    use stacks_common::util::secp256k1::{Secp256k1PrivateKey, Secp256k1PublicKey};
+    use stacks_common::util::hash::to_hex;
+    use stacks_common::util::secp256k1::Secp256k1PublicKey;
     use stacks_common::util::*;
 
     use super::*;
@@ -1922,10 +1921,10 @@ pub mod test {
         key: &StacksPrivateKey,
         nonce: u64,
         signer_index: u128,
-        aggregate_public_key: &Point,
+        aggregate_public_key: &Secp256k1PublicKey,
         round: u128,
     ) -> StacksTransaction {
-        let aggregate_public_key = Value::buff_from(aggregate_public_key.compress().data.to_vec())
+        let aggregate_public_key = Value::buff_from(aggregate_public_key.to_bytes_compressed())
             .expect("Failed to serialize aggregate public key");
         let payload = TransactionPayload::new_contract_call(
             boot_code_test_addr(),
diff --git a/stackslib/src/chainstate/stacks/boot/signers-voting.clar b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
index 000d7edb9d..dddef618dd 100644
--- a/stackslib/src/chainstate/stacks/boot/signers-voting.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
@@ -51,7 +51,7 @@
         (ok (get weight details))))
 
 ;; aggregate public key must be unique and can be used only in a single cycle-round pair
-(define-read-only (is-valid-aggregated-public-key (key (buff 33)) (dkg-id {reward-cycle: uint, round: uint}))
+(define-read-only (is-valid-aggregate-public-key (key (buff 33)) (dkg-id {reward-cycle: uint, round: uint}))
     (is-eq (default-to dkg-id (map-get? used-aggregate-public-keys key)) dkg-id))
 
 (define-read-only (is-in-prepare-phase (height uint))
@@ -82,7 +82,7 @@
         ;; Check that the aggregate public key is correct length
         (asserts! (is-eq (len key) u33) (err (to-uint ERR_ILL_FORMED_AGGREGATE_PUBLIC_KEY)))
         ;; Check that aggregate public key has not been used before
-        (asserts! (is-valid-aggregated-public-key key {reward-cycle: reward-cycle, round: round}) (err (to-uint ERR_DUPLICATE_AGGREGATE_PUBLIC_KEY)))
+        (asserts! (is-valid-aggregate-public-key key {reward-cycle: reward-cycle, round: round}) (err (to-uint ERR_DUPLICATE_AGGREGATE_PUBLIC_KEY)))
         ;; Check that signer hasn't voted in reward-cycle & round
         (asserts! (map-insert votes {reward-cycle: reward-cycle, round: round, signer: tx-sender} {aggregate-public-key: key, reward-slots: num-weight}) (err (to-uint ERR_DUPLICATE_VOTE)))
         ;; Update tally aggregate public key candidate
diff --git a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
index 1c5ce4ead5..5297168aac 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
@@ -44,7 +44,6 @@ use stacks_common::types::chainstate::{
 use stacks_common::types::Address;
 use stacks_common::util::hash::{hex_bytes, to_hex, Sha256Sum, Sha512Trunc256Sum};
 use stacks_common::util::secp256k1::Secp256k1PrivateKey;
-use wsts::curve::point::{Compressed, Point};
 
 use super::test::*;
 use super::RawRewardSetEntry;
@@ -256,8 +255,10 @@ fn vote_for_aggregate_public_key_in_last_block() {
     );
 
     let cycle_id: u128 = current_reward_cycle;
-    let aggregate_public_key: Point = Point::new();
-    let aggregate_public_key_1: Point = Point::G();
+    let private_key = StacksPrivateKey::from_seed(&[3]);
+    let aggregate_public_key = StacksPublicKey::from_private(&private_key);
+    let private_key_1 = StacksPrivateKey::from_seed(&[4]);
+    let aggregate_public_key_1 = StacksPublicKey::from_private(&private_key_1);
 
     // create vote txs for alice
     let signer_1_nonce = 0;

From 8f42eba7bc0c2c6a18a22cdc5a4cba26e64b53b7 Mon Sep 17 00:00:00 2001
From: friedger <mail@friedger.de>
Date: Tue, 6 Feb 2024 11:25:36 +0100
Subject: [PATCH 0722/1166] fix: use Point for aggregate public key

---
 stackslib/src/chainstate/stacks/boot/mod.rs    |  4 ++--
 .../stacks/boot/signers_voting_tests.rs        | 18 ++++++++----------
 2 files changed, 10 insertions(+), 12 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index cc49cdfb97..869d0559db 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -1921,10 +1921,10 @@ pub mod test {
         key: &StacksPrivateKey,
         nonce: u64,
         signer_index: u128,
-        aggregate_public_key: &Secp256k1PublicKey,
+        aggregate_public_key: &Point,
         round: u128,
     ) -> StacksTransaction {
-        let aggregate_public_key = Value::buff_from(aggregate_public_key.to_bytes_compressed())
+        let aggregate_public_key = Value::buff_from(aggregate_public_key.compress().data.to_vec())
             .expect("Failed to serialize aggregate public key");
         let payload = TransactionPayload::new_contract_call(
             boot_code_test_addr(),
diff --git a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
index 5297168aac..180004a7dc 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
@@ -17,7 +17,6 @@
 use std::collections::{HashMap, HashSet, VecDeque};
 use std::convert::{TryFrom, TryInto};
 
-use ::secp256k1::Scalar;
 use clarity::boot_util::boot_code_addr;
 use clarity::vm::clarity::ClarityConnection;
 use clarity::vm::contexts::OwnedEnvironment;
@@ -41,9 +40,10 @@ use stacks_common::address::AddressHashMode;
 use stacks_common::types::chainstate::{
     BlockHeaderHash, BurnchainHeaderHash, StacksAddress, StacksBlockId, VRFSeed,
 };
-use stacks_common::types::Address;
+use stacks_common::types::{Address, PrivateKey};
 use stacks_common::util::hash::{hex_bytes, to_hex, Sha256Sum, Sha512Trunc256Sum};
 use stacks_common::util::secp256k1::Secp256k1PrivateKey;
+use wsts::curve::{point::Point, scalar::Scalar};
 
 use super::test::*;
 use super::RawRewardSetEntry;
@@ -255,10 +255,8 @@ fn vote_for_aggregate_public_key_in_last_block() {
     );
 
     let cycle_id: u128 = current_reward_cycle;
-    let private_key = StacksPrivateKey::from_seed(&[3]);
-    let aggregate_public_key = StacksPublicKey::from_private(&private_key);
-    let private_key_1 = StacksPrivateKey::from_seed(&[4]);
-    let aggregate_public_key_1 = StacksPublicKey::from_private(&private_key_1);
+    let aggregate_public_key_1 = Point::from(Scalar::from(1));
+    let aggregate_public_key_2 = Point::from(Scalar::from(2));
 
     // create vote txs for alice
     let signer_1_nonce = 0;
@@ -273,7 +271,7 @@ fn vote_for_aggregate_public_key_in_last_block() {
             signer_1_key,
             signer_1_nonce,
             signer_1_index,
-            &aggregate_public_key,
+            &aggregate_public_key_1,
             1,
         ),
         // cast the vote twice
@@ -281,7 +279,7 @@ fn vote_for_aggregate_public_key_in_last_block() {
             signer_1_key,
             signer_1_nonce + 1,
             signer_1_index,
-            &aggregate_public_key,
+            &aggregate_public_key_1,
             1,
         ),
         // cast a vote for old round
@@ -289,7 +287,7 @@ fn vote_for_aggregate_public_key_in_last_block() {
             signer_1_key,
             signer_1_nonce + 2,
             signer_1_index,
-            &aggregate_public_key_1,
+            &aggregate_public_key_2,
             0,
         ),
     ];
@@ -307,7 +305,7 @@ fn vote_for_aggregate_public_key_in_last_block() {
             signer_2_key,
             signer_2_nonce,
             signer_2_index,
-            &aggregate_public_key,
+            &aggregate_public_key_1,
             0,
         ),
     ];

From 8f7238b0a0a38037e2a4277bb6e257d2913e9287 Mon Sep 17 00:00:00 2001
From: friedger <mail@friedger.de>
Date: Thu, 8 Feb 2024 16:11:44 +0100
Subject: [PATCH 0723/1166] chore: improve naming and comments

---
 .../stacks/boot/signers_voting_tests.rs       | 62 +++++--------------
 1 file changed, 17 insertions(+), 45 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
index 180004a7dc..af258fd233 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
@@ -30,7 +30,6 @@ use clarity::vm::eval;
 use clarity::vm::events::StacksTransactionEvent;
 use clarity::vm::representations::SymbolicExpression;
 use clarity::vm::tests::{execute, is_committed, is_err_code, symbols_from_values};
-use clarity::vm::types::Value::Response;
 use clarity::vm::types::{
     BuffData, OptionalData, PrincipalData, QualifiedContractIdentifier, ResponseData, SequenceData,
     StacksAddressExtensions, StandardPrincipalData, TupleData, TupleTypeSignature, TypeSignature,
@@ -197,23 +196,14 @@ fn vote_for_aggregate_public_key_in_first_block() {
     // ignore tenure coinbase tx
 
     // first vote should succeed
-    let tx1 = &receipts[receipts.len() - 2];
-    assert_eq!(
-        tx1.result,
-        Value::Response(ResponseData {
-            committed: true,
-            data: Box::new(Value::Bool(true))
-        })
-    );
+    let alice_first_vote_tx = &receipts[2];
+    assert_eq!(alice_first_vote_tx.result, Value::okay_true());
 
     // second vote should fail with duplicate vote error
-    let tx2 = &receipts[receipts.len() - 1];
+    let alice_second_vote_tx = &receipts[3];
     assert_eq!(
-        tx2.result,
-        Value::Response(ResponseData {
-            committed: false,
-            data: Box::new(Value::UInt(7)) // ERR_DUPLICATE_VOTE
-        })
+        alice_second_vote_tx.result,
+        Value::err_uint(7) // err-duplicate-vote
     );
 }
 
@@ -265,7 +255,7 @@ fn vote_for_aggregate_public_key_in_last_block() {
     let signer_1_principal = PrincipalData::from(signer_1_address);
     let signer_1_index = get_signer_index(&mut peer, latest_block_id, signer_1_address, cycle_id);
 
-    let txs_1 = vec![
+    let txs_block_1 = vec![
         // cast a vote for the aggregate public key
         make_signers_vote_for_aggregate_public_key(
             signer_1_key,
@@ -299,7 +289,7 @@ fn vote_for_aggregate_public_key_in_last_block() {
     let signer_2_principal = PrincipalData::from(signer_2_address);
     let signer_2_index = get_signer_index(&mut peer, latest_block_id, signer_2_address, cycle_id);
 
-    let txs_2 = vec![
+    let txs_block_2 = vec![
         // cast a vote for the aggregate public key
         make_signers_vote_for_aggregate_public_key(
             signer_2_key,
@@ -333,7 +323,7 @@ fn vote_for_aggregate_public_key_in_last_block() {
     let blocks_and_sizes = nakamoto_tenure(
         &mut peer,
         &mut test_signers,
-        vec![txs_1, txs_2],
+        vec![txs_block_1, txs_block_2],
         signer_1_key,
     );
 
@@ -345,34 +335,19 @@ fn vote_for_aggregate_public_key_in_last_block() {
     assert_eq!(receipts.len(), 5);
 
     // first vote should succeed
-    let tx1 = &receipts[receipts.len() - 3];
-    assert_eq!(
-        tx1.result,
-        Value::Response(ResponseData {
-            committed: true,
-            data: Box::new(Value::Bool(true))
-        })
-    );
+    let alice_first_vote_tx = &receipts[2];
+    assert_eq!(alice_first_vote_tx.result, Value::okay_true());
 
     // second vote should fail with duplicate vote error
-    let tx2 = &receipts[receipts.len() - 2];
+    let alice_second_vote_tx = &receipts[3];
     assert_eq!(
-        tx2.result,
-        Value::Response(ResponseData {
-            committed: false,
-            data: Box::new(Value::UInt(7)) // ERR_DUPLICATE_VOTE
-        })
+        alice_second_vote_tx.result,
+        Value::err_uint(7) // err-duplicate-vote
     );
 
     // third vote should succeed even though it is on an old round
-    let tx3 = &receipts[receipts.len() - 1];
-    assert_eq!(
-        tx3.result,
-        Value::Response(ResponseData {
-            committed: true,
-            data: Box::new(Value::Bool(true))
-        })
-    );
+    let alice_third_vote_tx = &receipts[4];
+    assert_eq!(alice_third_vote_tx.result, Value::okay_true());
 
     // bob's block
     let block = blocks.last().unwrap().clone();
@@ -381,13 +356,10 @@ fn vote_for_aggregate_public_key_in_last_block() {
 
     // vote fails because the reward cycle has changed
     //  and the signer set hasn't been set yet.
-    let tx1_bob = &receipts[receipts.len() - 1];
+    let tx1_bob = &receipts[0];
     assert_eq!(
         tx1_bob.result,
-        Value::Response(ResponseData {
-            committed: false,
-            data: Box::new(Value::UInt(2)) // ERR_INVALID_SIGNER_INDEX
-        })
+        Value::err_uint(2) // err-out-of-voting-window
     );
 }
 

From 74b40f5508ddce84318a6c8bc55b682de0721de6 Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Fri, 9 Feb 2024 07:16:00 -0500
Subject: [PATCH 0724/1166] feat: set aggregate public key once threshold is
 reached

Once the 70% voting threshold is reached, save the key for the current
cycle to a map and emit an event:

```
{
  event: "approved-aggregate-public-key",
  reward-cycle: reward-cycle,
  key: key,
}
```
---
 .../stacks/boot/signers-voting.clar           | 77 ++++++++++++++++---
 .../src/chainstate/stacks/boot/signers.clar   |  3 +-
 2 files changed, 68 insertions(+), 12 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers-voting.clar b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
index dddef618dd..0a3b168f2b 100644
--- a/stackslib/src/chainstate/stacks/boot/signers-voting.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
@@ -3,7 +3,7 @@
 ;;
 
 ;; maps dkg round and signer to proposed aggregate public key
-(define-map votes {reward-cycle: uint, round: uint, signer: principal} {aggregate-public-key: (buff 33), reward-slots: uint})
+(define-map votes {reward-cycle: uint, round: uint, signer: principal} {aggregate-public-key: (buff 33), signer-weight: uint})
 ;; maps dkg round and aggregate public key to weights of signers supporting this key so far
 (define-map tally {reward-cycle: uint, round: uint, aggregate-public-key: (buff 33)} uint)
 ;; maps aggregate public keys to rewards cycles and rounds
@@ -16,13 +16,25 @@
 (define-constant ERR_DUPLICATE_AGGREGATE_PUBLIC_KEY 6)
 (define-constant ERR_DUPLICATE_VOTE 7)
 (define-constant ERR_INVALID_BURN_BLOCK_HEIGHT 8)
+(define-constant ERR_FAILED_TO_RETRIEVE_SIGNERS 9)
 
 (define-constant pox-info
     (unwrap-panic (contract-call? .pox-4 get-pox-info)))
 
+;; Threshold consensus (in 3 digit %)
+(define-constant threshold-consensus u700)
+
 ;; maps reward-cycle ids to last round
 (define-map rounds uint uint)
 
+;; Maps reward-cycle ids to aggregate public key.
+(define-map aggregate-public-keys uint (buff 33))
+
+;; Maps reward-cycle id to the total weight of signers. This map is used to
+;; cache the total weight of signers for a given reward cycle, so it is not
+;; necessary to recalculate it on every vote.
+(define-map cycle-total-weight uint uint)
+
 (define-read-only (burn-height-to-reward-cycle (height uint))
     (/ (- height (get first-burnchain-block-height pox-info)) (get reward-cycle-length pox-info)))
 
@@ -61,11 +73,33 @@
             )
         (get prepare-cycle-length pox-info)))
 
+;; get the aggregate public key for the given reward cycle (or none)
+(define-read-only (get-approved-aggregate-key (reward-cycle uint))
+    (map-get? aggregate-public-keys reward-cycle)
+)
+
 (define-private (is-in-voting-window (height uint) (reward-cycle uint))
     (let ((last-cycle (unwrap-panic (contract-call? .signers get-last-set-cycle))))
         (and (is-eq last-cycle reward-cycle)
             (is-in-prepare-phase height))))
 
+(define-private (sum-weights (signer { signer: principal, weight: uint }) (acc uint))
+    (+ acc (get weight signer))
+)
+
+(define-private (get-total-weight (reward-cycle uint))
+    (match (map-get? cycle-total-weight reward-cycle)
+        total (ok total)
+        (let (
+                (signers (unwrap! (contract-call? .signers get-signers reward-cycle) (err (to-uint ERR_FAILED_TO_RETRIEVE_SIGNERS))))
+                (total (fold sum-weights signers u0))
+            )
+            (map-set cycle-total-weight reward-cycle total)
+            (ok total)
+        )
+    )
+)
+
 ;; Signer vote for the aggregate public key of the next reward cycle
 ;;  The vote happens in the prepare phase of the current reward cycle but may be ran more than
 ;;  once resulting in different 'rounds.' Each signer vote is based on the weight of stacked
@@ -75,8 +109,9 @@
     (let ((reward-cycle (+ u1 (burn-height-to-reward-cycle burn-block-height)))
             (tally-key {reward-cycle: reward-cycle, round: round, aggregate-public-key: key})
             ;; vote by signer weight
-            (num-weight (try! (get-current-signer-weight signer-index)))
-            (new-total (+ num-weight (default-to u0 (map-get? tally tally-key)))))
+            (signer-weight (try! (get-current-signer-weight signer-index)))
+            (new-total (+ signer-weight (default-to u0 (map-get? tally tally-key))))
+            (total-weight (try! (get-total-weight reward-cycle))))
         ;; Check we're in the prepare phase
         (asserts! (is-in-voting-window burn-block-height reward-cycle) (err (to-uint ERR_OUT_OF_VOTING_WINDOW)))
         ;; Check that the aggregate public key is correct length
@@ -84,19 +119,39 @@
         ;; Check that aggregate public key has not been used before
         (asserts! (is-valid-aggregate-public-key key {reward-cycle: reward-cycle, round: round}) (err (to-uint ERR_DUPLICATE_AGGREGATE_PUBLIC_KEY)))
         ;; Check that signer hasn't voted in reward-cycle & round
-        (asserts! (map-insert votes {reward-cycle: reward-cycle, round: round, signer: tx-sender} {aggregate-public-key: key, reward-slots: num-weight}) (err (to-uint ERR_DUPLICATE_VOTE)))
+        (asserts! (map-insert votes {reward-cycle: reward-cycle, round: round, signer: tx-sender} {aggregate-public-key: key, signer-weight: signer-weight}) (err (to-uint ERR_DUPLICATE_VOTE)))
         ;; Update tally aggregate public key candidate
         (map-set tally tally-key new-total)
         ;; Update used aggregate public keys
         (map-set used-aggregate-public-keys key {reward-cycle: reward-cycle, round: round})
         (update-last-round reward-cycle round)
-        (print { 
-            event: "voted", 
-            signer: tx-sender, 
-            reward-cycle: reward-cycle, 
-            round: round, 
-            key: key, 
-            new-total: new-total })
+        (print {
+            event: "voted",
+            signer: tx-sender,
+            reward-cycle: reward-cycle,
+            round: round,
+            key: key,
+            new-total: new-total,
+        })
+        ;; Check if consensus has been reached
+        (and
+            ;; If we already have consensus, skip this
+            (is-none (map-get? aggregate-public-keys reward-cycle))
+            ;; If the new total weight is greater than or equal to the threshold consensus
+            (>= (/ (* new-total u1000) total-weight) threshold-consensus)
+            ;; Save this approved aggregate public key for this reward cycle
+            (map-set aggregate-public-keys reward-cycle key)
+            ;; Create an event for the approved aggregate public key
+            (begin
+                (print {
+                    event: "approved-aggregate-public-key",
+                    reward-cycle: reward-cycle,
+                    key: key,
+                })
+                true
+            )
+        )
+
         (ok true)))
 
 (define-private (update-last-round (reward-cycle uint) (round uint))
diff --git a/stackslib/src/chainstate/stacks/boot/signers.clar b/stackslib/src/chainstate/stacks/boot/signers.clar
index 098ab417ad..8db52b96ff 100644
--- a/stackslib/src/chainstate/stacks/boot/signers.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers.clar
@@ -6,6 +6,7 @@
 (define-constant CHUNK_SIZE (* u2 u1024 u1024))
 (define-constant ERR_NO_SUCH_PAGE u1)
 (define-constant ERR_CYCLE_NOT_SET u2)
+
 (define-map cycle-signer-set uint (list 4000 { signer: principal, weight: uint }))
 
 ;; Called internally by the Stacks node.
@@ -22,7 +23,7 @@
             (ok (var-set stackerdb-signer-slots-0 signer-slots))
             (ok (var-set stackerdb-signer-slots-1 signer-slots)))))
 
-;; Called internally by te Stacks node.
+;; Called internally by the Stacks node.
 ;; Sets the list of signers and weights for a given reward cycle.
 (define-private (set-signers
                  (reward-cycle uint)

From 00bc9835ad5cbcc59f89f756f67a2d6ded15563c Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Fri, 9 Feb 2024 07:31:28 -0500
Subject: [PATCH 0725/1166] chore: use uints for errors in signers-voting
 contract

---
 .../stacks/boot/signers-voting.clar           | 30 +++++++++----------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers-voting.clar b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
index 0a3b168f2b..c20c85da21 100644
--- a/stackslib/src/chainstate/stacks/boot/signers-voting.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
@@ -9,14 +9,14 @@
 ;; maps aggregate public keys to rewards cycles and rounds
 (define-map used-aggregate-public-keys (buff 33) {reward-cycle: uint, round: uint})
 
-(define-constant ERR_SIGNER_INDEX_MISMATCH 1)
-(define-constant ERR_INVALID_SIGNER_INDEX 2)
-(define-constant ERR_OUT_OF_VOTING_WINDOW 3)
-(define-constant ERR_ILL_FORMED_AGGREGATE_PUBLIC_KEY 5)
-(define-constant ERR_DUPLICATE_AGGREGATE_PUBLIC_KEY 6)
-(define-constant ERR_DUPLICATE_VOTE 7)
-(define-constant ERR_INVALID_BURN_BLOCK_HEIGHT 8)
-(define-constant ERR_FAILED_TO_RETRIEVE_SIGNERS 9)
+(define-constant ERR_SIGNER_INDEX_MISMATCH u1)
+(define-constant ERR_INVALID_SIGNER_INDEX u2)
+(define-constant ERR_OUT_OF_VOTING_WINDOW u3)
+(define-constant ERR_ILL_FORMED_AGGREGATE_PUBLIC_KEY u5)
+(define-constant ERR_DUPLICATE_AGGREGATE_PUBLIC_KEY u6)
+(define-constant ERR_DUPLICATE_VOTE u7)
+(define-constant ERR_INVALID_BURN_BLOCK_HEIGHT u8)
+(define-constant ERR_FAILED_TO_RETRIEVE_SIGNERS u9)
 
 (define-constant pox-info
     (unwrap-panic (contract-call? .pox-4 get-pox-info)))
@@ -58,8 +58,8 @@
       (get-signer-weight signer-index cycle)))
 
 (define-read-only (get-signer-weight (signer-index uint) (reward-cycle uint))
-    (let ((details (unwrap! (try! (contract-call? .signers get-signer-by-index reward-cycle signer-index)) (err (to-uint ERR_INVALID_SIGNER_INDEX)))))
-        (asserts! (is-eq (get signer details) tx-sender) (err (to-uint ERR_SIGNER_INDEX_MISMATCH)))
+    (let ((details (unwrap! (try! (contract-call? .signers get-signer-by-index reward-cycle signer-index)) (err ERR_INVALID_SIGNER_INDEX))))
+        (asserts! (is-eq (get signer details) tx-sender) (err ERR_SIGNER_INDEX_MISMATCH))
         (ok (get weight details))))
 
 ;; aggregate public key must be unique and can be used only in a single cycle-round pair
@@ -91,7 +91,7 @@
     (match (map-get? cycle-total-weight reward-cycle)
         total (ok total)
         (let (
-                (signers (unwrap! (contract-call? .signers get-signers reward-cycle) (err (to-uint ERR_FAILED_TO_RETRIEVE_SIGNERS))))
+                (signers (unwrap! (contract-call? .signers get-signers reward-cycle) (err ERR_FAILED_TO_RETRIEVE_SIGNERS)))
                 (total (fold sum-weights signers u0))
             )
             (map-set cycle-total-weight reward-cycle total)
@@ -113,13 +113,13 @@
             (new-total (+ signer-weight (default-to u0 (map-get? tally tally-key))))
             (total-weight (try! (get-total-weight reward-cycle))))
         ;; Check we're in the prepare phase
-        (asserts! (is-in-voting-window burn-block-height reward-cycle) (err (to-uint ERR_OUT_OF_VOTING_WINDOW)))
+        (asserts! (is-in-voting-window burn-block-height reward-cycle) (err ERR_OUT_OF_VOTING_WINDOW))
         ;; Check that the aggregate public key is correct length
-        (asserts! (is-eq (len key) u33) (err (to-uint ERR_ILL_FORMED_AGGREGATE_PUBLIC_KEY)))
+        (asserts! (is-eq (len key) u33) (err ERR_ILL_FORMED_AGGREGATE_PUBLIC_KEY))
         ;; Check that aggregate public key has not been used before
-        (asserts! (is-valid-aggregate-public-key key {reward-cycle: reward-cycle, round: round}) (err (to-uint ERR_DUPLICATE_AGGREGATE_PUBLIC_KEY)))
+        (asserts! (is-valid-aggregate-public-key key {reward-cycle: reward-cycle, round: round}) (err ERR_DUPLICATE_AGGREGATE_PUBLIC_KEY))
         ;; Check that signer hasn't voted in reward-cycle & round
-        (asserts! (map-insert votes {reward-cycle: reward-cycle, round: round, signer: tx-sender} {aggregate-public-key: key, signer-weight: signer-weight}) (err (to-uint ERR_DUPLICATE_VOTE)))
+        (asserts! (map-insert votes {reward-cycle: reward-cycle, round: round, signer: tx-sender} {aggregate-public-key: key, signer-weight: signer-weight}) (err ERR_DUPLICATE_VOTE))
         ;; Update tally aggregate public key candidate
         (map-set tally tally-key new-total)
         ;; Update used aggregate public keys

From b2413c1dfbf41cafa683780ee841501cc03d6928 Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Fri, 9 Feb 2024 09:05:13 -0500
Subject: [PATCH 0726/1166] test: check for aggregate key approval event

---
 .../stacks/boot/signers_voting_tests.rs       | 172 ++++++++++++++++--
 1 file changed, 152 insertions(+), 20 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
index af258fd233..7a5fa79aed 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
@@ -135,6 +135,153 @@ pub fn prepare_pox4_test<'a>(
     )
 }
 
+/// In this test case, Alice and Bob both successfully vote for the same key
+/// and the key is accepted.
+#[test]
+fn vote_for_aggregate_public_key_success() {
+    let alice = TestStacker::from_seed(&[3, 4]);
+    let bob = TestStacker::from_seed(&[5, 6]);
+    let observer = TestEventObserver::new();
+
+    let alice_nonce = 0;
+    let alice_key = &alice.signer_private_key;
+    let alice_address = key_to_stacks_addr(alice_key);
+    let alice_principal = PrincipalData::from(alice_address);
+
+    let bob_nonce = 0;
+    let bob_key = &bob.signer_private_key;
+    let bob_address = key_to_stacks_addr(bob_key);
+    let bob_principal = PrincipalData::from(bob_address);
+
+    let (mut peer, mut test_signers, latest_block_id, current_reward_cycle) = prepare_signers_test(
+        function_name!(),
+        vec![
+            (alice_principal.clone(), 1000),
+            (bob_principal.clone(), 1000),
+        ],
+        &[alice.clone(), bob.clone()],
+        Some(&observer),
+    );
+
+    let cycle_id = current_reward_cycle;
+
+    // create vote txs
+    let alice_index = get_signer_index(&mut peer, latest_block_id, alice_address, cycle_id);
+    let bob_index = get_signer_index(&mut peer, latest_block_id, bob_address, cycle_id);
+
+    let aggregate_public_key: Point = Point::new();
+    let aggregate_public_key_value =
+        Value::buff_from(aggregate_public_key.compress().data.to_vec())
+            .expect("Failed to serialize aggregate public key");
+
+    let txs = vec![
+        // Alice casts a vote for the aggregate public key
+        make_signers_vote_for_aggregate_public_key(
+            alice_key,
+            alice_nonce,
+            alice_index,
+            &aggregate_public_key,
+            0,
+        ),
+        // Bob casts a vote for the aggregate public key
+        make_signers_vote_for_aggregate_public_key(
+            bob_key,
+            bob_nonce,
+            bob_index,
+            &aggregate_public_key,
+            0,
+        ),
+    ];
+
+    //
+    // vote in the first burn block of prepare phase
+    //
+    let blocks_and_sizes = nakamoto_tenure(&mut peer, &mut test_signers, vec![txs]);
+
+    // check the last two txs in the last block
+    let block = observer.get_blocks().last().unwrap().clone();
+    let receipts = block.receipts.as_slice();
+    assert_eq!(receipts.len(), 4);
+    // ignore tenure change tx
+    // ignore tenure coinbase tx
+
+    // first vote should succeed
+    let alice_vote_tx = &receipts[2];
+    assert_eq!(alice_vote_tx.result, Value::okay_true());
+    assert_eq!(alice_vote_tx.events.len(), 1);
+    let alice_vote_event = &alice_vote_tx.events[0];
+    if let StacksTransactionEvent::SmartContractEvent(contract_event) = alice_vote_event {
+        assert_eq!(
+            contract_event.value,
+            TupleData::from_data(vec![
+                (
+                    "event".into(),
+                    Value::string_ascii_from_bytes("voted".as_bytes().to_vec())
+                        .expect("Failed to create string")
+                ),
+                ("key".into(), aggregate_public_key_value.clone()),
+                ("new-total".into(), Value::UInt(2)),
+                ("reward-cycle".into(), Value::UInt(cycle_id + 1)),
+                ("round".into(), Value::UInt(0)),
+                ("signer".into(), Value::Principal(alice_principal.clone())),
+            ])
+            .expect("Failed to create tuple")
+            .into()
+        );
+    } else {
+        panic!("Expected SmartContractEvent, got {:?}", alice_vote_event);
+    }
+
+    // second vote should fail with duplicate vote error
+    let bob_vote_tx = &receipts[3];
+    assert_eq!(bob_vote_tx.result, Value::okay_true());
+    assert_eq!(bob_vote_tx.events.len(), 2);
+    let bob_vote_event = &bob_vote_tx.events[0];
+    if let StacksTransactionEvent::SmartContractEvent(contract_event) = bob_vote_event {
+        assert_eq!(
+            contract_event.value,
+            TupleData::from_data(vec![
+                (
+                    "event".into(),
+                    Value::string_ascii_from_bytes("voted".as_bytes().to_vec())
+                        .expect("Failed to create string")
+                ),
+                ("key".into(), aggregate_public_key_value.clone()),
+                ("new-total".into(), Value::UInt(4)),
+                ("reward-cycle".into(), Value::UInt(cycle_id + 1)),
+                ("round".into(), Value::UInt(0)),
+                ("signer".into(), Value::Principal(bob_principal.clone())),
+            ])
+            .expect("Failed to create tuple")
+            .into()
+        );
+    } else {
+        panic!("Expected SmartContractEvent, got {:?}", bob_vote_event);
+    }
+
+    let approve_event = &bob_vote_tx.events[1];
+    if let StacksTransactionEvent::SmartContractEvent(contract_event) = approve_event {
+        assert_eq!(
+            contract_event.value,
+            TupleData::from_data(vec![
+                (
+                    "event".into(),
+                    Value::string_ascii_from_bytes(
+                        "approved-aggregate-public-key".as_bytes().to_vec()
+                    )
+                    .expect("Failed to create string")
+                ),
+                ("key".into(), aggregate_public_key_value.clone()),
+                ("reward-cycle".into(), Value::UInt(cycle_id + 1)),
+            ])
+            .expect("Failed to create tuple")
+            .into()
+        );
+    } else {
+        panic!("Expected SmartContractEvent, got {:?}", approve_event);
+    }
+}
+
 /// In this test case, Alice votes in the first block of the first tenure of the prepare phase.
 /// Alice can vote successfully.
 /// A second vote on the same key and round fails with "duplicate vote" error
@@ -186,7 +333,7 @@ fn vote_for_aggregate_public_key_in_first_block() {
     //
     // vote in the first burn block of prepare phase
     //
-    let blocks_and_sizes = nakamoto_tenure(&mut peer, &mut test_signers, vec![txs], signer_key);
+    let blocks_and_sizes = nakamoto_tenure(&mut peer, &mut test_signers, vec![txs]);
 
     // check the last two txs in the last block
     let block = observer.get_blocks().last().unwrap().clone();
@@ -304,28 +451,14 @@ fn vote_for_aggregate_public_key_in_last_block() {
     // vote in the last burn block of prepare phase
     //
 
-    nakamoto_tenure(
-        &mut peer,
-        &mut test_signers,
-        vec![vec![dummy_tx_1]],
-        signer_1_key,
-    );
+    nakamoto_tenure(&mut peer, &mut test_signers, vec![vec![dummy_tx_1]]);
 
-    nakamoto_tenure(
-        &mut peer,
-        &mut test_signers,
-        vec![vec![dummy_tx_2]],
-        signer_1_key,
-    );
+    nakamoto_tenure(&mut peer, &mut test_signers, vec![vec![dummy_tx_2]]);
 
     // alice votes in first block of tenure
     // bob votes in second block of tenure
-    let blocks_and_sizes = nakamoto_tenure(
-        &mut peer,
-        &mut test_signers,
-        vec![txs_block_1, txs_block_2],
-        signer_1_key,
-    );
+    let blocks_and_sizes =
+        nakamoto_tenure(&mut peer, &mut test_signers, vec![txs_block_1, txs_block_2]);
 
     // check alice's and bob's txs
     let blocks = observer.get_blocks();
@@ -367,7 +500,6 @@ fn nakamoto_tenure(
     peer: &mut TestPeer,
     test_signers: &mut TestSigners,
     txs_of_blocks: Vec<Vec<StacksTransaction>>,
-    stacker_private_key: &StacksPrivateKey,
 ) -> Vec<(NakamotoBlock, u64, ExecutionCost)> {
     let current_height = peer.get_burnchain_view().unwrap().burn_block_height;
 

From 85b0ea26323f87db7d34cd1476afc4ea5cb4fefc Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Fri, 9 Feb 2024 16:02:50 -0500
Subject: [PATCH 0727/1166] fix: use weight in signer set (not number of slots)

---
 stackslib/src/chainstate/nakamoto/signer_set.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stackslib/src/chainstate/nakamoto/signer_set.rs b/stackslib/src/chainstate/nakamoto/signer_set.rs
index bf444acc61..1471dcc2ba 100644
--- a/stackslib/src/chainstate/nakamoto/signer_set.rs
+++ b/stackslib/src/chainstate/nakamoto/signer_set.rs
@@ -274,7 +274,7 @@ impl NakamotoSigners {
                                 "signer".into(),
                                 Value::Principal(PrincipalData::from(signing_address)),
                             ),
-                            ("weight".into(), Value::UInt(signer.slots.into())),
+                            ("weight".into(), Value::UInt(signer.stacked_amt.into())),
                         ])
                             .expect(
                                 "BUG: Failed to construct `{ signer: principal, num-slots: u64 }` tuple",

From d98b6a765d6cd0895c99b5c19f91401bc151b708 Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Fri, 9 Feb 2024 17:45:35 -0500
Subject: [PATCH 0728/1166] fixed prepare-phase check & added cycle parameter
 to voting func

---
 stackslib/src/chainstate/stacks/boot/mod.rs              | 2 ++
 stackslib/src/chainstate/stacks/boot/signers-voting.clar | 9 ++++-----
 .../src/chainstate/stacks/boot/signers_voting_tests.rs   | 8 ++++++++
 3 files changed, 14 insertions(+), 5 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 869d0559db..d7f0f810f3 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -1923,6 +1923,7 @@ pub mod test {
         signer_index: u128,
         aggregate_public_key: &Point,
         round: u128,
+        cycle: u128
     ) -> StacksTransaction {
         let aggregate_public_key = Value::buff_from(aggregate_public_key.compress().data.to_vec())
             .expect("Failed to serialize aggregate public key");
@@ -1934,6 +1935,7 @@ pub mod test {
                 Value::UInt(signer_index),
                 aggregate_public_key,
                 Value::UInt(round),
+                Value::UInt(cycle)
             ],
         )
         .unwrap();
diff --git a/stackslib/src/chainstate/stacks/boot/signers-voting.clar b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
index c20c85da21..ba27f1d8b7 100644
--- a/stackslib/src/chainstate/stacks/boot/signers-voting.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
@@ -105,15 +105,14 @@
 ;;  once resulting in different 'rounds.' Each signer vote is based on the weight of stacked
 ;;  stx tokens & fetched from the .signers contract. The vote is ran until the consensus 
 ;;  threshold of 70% for a specific aggregate public key is reached. 
-(define-public (vote-for-aggregate-public-key (signer-index uint) (key (buff 33)) (round uint))
-    (let ((reward-cycle (+ u1 (burn-height-to-reward-cycle burn-block-height)))
-            (tally-key {reward-cycle: reward-cycle, round: round, aggregate-public-key: key})
+(define-public (vote-for-aggregate-public-key (signer-index uint) (key (buff 33)) (round uint) (reward-cycle uint))
+    (let ((tally-key {reward-cycle: reward-cycle, round: round, aggregate-public-key: key})
             ;; vote by signer weight
             (signer-weight (try! (get-current-signer-weight signer-index)))
             (new-total (+ signer-weight (default-to u0 (map-get? tally tally-key))))
             (total-weight (try! (get-total-weight reward-cycle))))
-        ;; Check we're in the prepare phase
-        (asserts! (is-in-voting-window burn-block-height reward-cycle) (err ERR_OUT_OF_VOTING_WINDOW))
+        ;; Check that key isn't already set
+        (asserts! (is-none (map-get? aggregate-public-keys reward-cycle)) (err ERR_OUT_OF_VOTING_WINDOW))
         ;; Check that the aggregate public key is correct length
         (asserts! (is-eq (len key) u33) (err ERR_ILL_FORMED_AGGREGATE_PUBLIC_KEY))
         ;; Check that aggregate public key has not been used before
diff --git a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
index 7a5fa79aed..2766febf8b 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
@@ -182,6 +182,7 @@ fn vote_for_aggregate_public_key_success() {
             alice_index,
             &aggregate_public_key,
             0,
+            cycle_id
         ),
         // Bob casts a vote for the aggregate public key
         make_signers_vote_for_aggregate_public_key(
@@ -190,6 +191,7 @@ fn vote_for_aggregate_public_key_success() {
             bob_index,
             &aggregate_public_key,
             0,
+            cycle_id
         ),
     ];
 
@@ -319,6 +321,7 @@ fn vote_for_aggregate_public_key_in_first_block() {
             signer_index,
             &aggregate_public_key,
             0,
+            cycle_id
         ),
         // cast the vote twice
         make_signers_vote_for_aggregate_public_key(
@@ -327,6 +330,7 @@ fn vote_for_aggregate_public_key_in_first_block() {
             signer_index,
             &aggregate_public_key,
             0,
+            cycle_id
         ),
     ];
 
@@ -410,6 +414,7 @@ fn vote_for_aggregate_public_key_in_last_block() {
             signer_1_index,
             &aggregate_public_key_1,
             1,
+            cycle_id
         ),
         // cast the vote twice
         make_signers_vote_for_aggregate_public_key(
@@ -418,6 +423,7 @@ fn vote_for_aggregate_public_key_in_last_block() {
             signer_1_index,
             &aggregate_public_key_1,
             1,
+            cycle_id
         ),
         // cast a vote for old round
         make_signers_vote_for_aggregate_public_key(
@@ -426,6 +432,7 @@ fn vote_for_aggregate_public_key_in_last_block() {
             signer_1_index,
             &aggregate_public_key_2,
             0,
+            cycle_id
         ),
     ];
 
@@ -444,6 +451,7 @@ fn vote_for_aggregate_public_key_in_last_block() {
             signer_2_index,
             &aggregate_public_key_1,
             0,
+            cycle_id
         ),
     ];
 

From 270bb36a66a9557b9558db24c5f14e938e7581a2 Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Fri, 9 Feb 2024 20:19:07 -0500
Subject: [PATCH 0729/1166] updated broken tests

---
 .../src/chainstate/stacks/boot/signers_voting_tests.rs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
index 2766febf8b..9b0c6540c3 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
@@ -222,8 +222,8 @@ fn vote_for_aggregate_public_key_success() {
                         .expect("Failed to create string")
                 ),
                 ("key".into(), aggregate_public_key_value.clone()),
-                ("new-total".into(), Value::UInt(2)),
-                ("reward-cycle".into(), Value::UInt(cycle_id + 1)),
+                ("new-total".into(), Value::UInt(1000000000000000000)),
+                ("reward-cycle".into(), Value::UInt(cycle_id)),
                 ("round".into(), Value::UInt(0)),
                 ("signer".into(), Value::Principal(alice_principal.clone())),
             ])
@@ -249,8 +249,8 @@ fn vote_for_aggregate_public_key_success() {
                         .expect("Failed to create string")
                 ),
                 ("key".into(), aggregate_public_key_value.clone()),
-                ("new-total".into(), Value::UInt(4)),
-                ("reward-cycle".into(), Value::UInt(cycle_id + 1)),
+                ("new-total".into(), Value::UInt(2000000000000000000)),
+                ("reward-cycle".into(), Value::UInt(cycle_id)),
                 ("round".into(), Value::UInt(0)),
                 ("signer".into(), Value::Principal(bob_principal.clone())),
             ])
@@ -274,7 +274,7 @@ fn vote_for_aggregate_public_key_success() {
                     .expect("Failed to create string")
                 ),
                 ("key".into(), aggregate_public_key_value.clone()),
-                ("reward-cycle".into(), Value::UInt(cycle_id + 1)),
+                ("reward-cycle".into(), Value::UInt(cycle_id)),
             ])
             .expect("Failed to create tuple")
             .into()

From cf6ece74ae07d5c97b544ae2f686cc72068180a2 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Sat, 10 Feb 2024 15:37:16 -0500
Subject: [PATCH 0730/1166] feat: Add `range` mode to `replay-block`

---
 stackslib/src/main.rs | 33 ++++++++++++++++++++++++---------
 1 file changed, 24 insertions(+), 9 deletions(-)

diff --git a/stackslib/src/main.rs b/stackslib/src/main.rs
index 7c88ea7092..d7c9fcd356 100644
--- a/stackslib/src/main.rs
+++ b/stackslib/src/main.rs
@@ -861,12 +861,17 @@ simulating a miner.
     }
 
     if argv[1] == "replay-block" {
-        if argv.len() < 2 {
-            eprintln!(
-                "Usage: {} <chainstate_path> [--prefix <index-block-hash-prefix>] [<--last|--first> <block_count>]",
-                &argv[0]
-            );
+        let print_help_and_exit = || -> ! {
+            let n = &argv[0];
+            eprintln!("Usage:");
+            eprintln!("  {n} <chainstate_path>");
+            eprintln!("  {n} <chainstate_path> prefix <index-block-hash-prefix>");
+            eprintln!("  {n} <chainstate_path> range <start_block> <end_block>");
+            eprintln!("  {n} <chainstate_path> <first|last> <block_count>");
             process::exit(1);
+        };
+        if argv.len() < 2 {
+            print_help_and_exit();
         }
         let stacks_path = &argv[2];
         let mode = argv.get(3).map(String::as_str);
@@ -876,20 +881,30 @@ simulating a miner.
                 .unwrap();
 
         let query = match mode {
-            Some("--prefix") => format!(
+            Some("prefix") => format!(
                 "SELECT index_block_hash FROM staging_blocks WHERE index_block_hash LIKE \"{}%\"",
                 argv[4]
             ),
-            Some("--first") => format!(
+            Some("first") => format!(
                 "SELECT index_block_hash FROM staging_blocks ORDER BY height ASC LIMIT {}",
                 argv[4]
             ),
-            Some("--last") => format!(
+            Some("range") => {
+                let arg4 = argv[4]
+                    .parse::<u64>()
+                    .expect("<start_block> not a valid u64");
+                let arg5 = argv[5].parse::<u64>().expect("<end_block> not a valid u64");
+                let start = arg4.saturating_sub(1);
+                let blocks = arg5.saturating_sub(arg4);
+                format!("SELECT index_block_hash FROM staging_blocks ORDER BY height ASC LIMIT {start}, {blocks}")
+            }
+            Some("last") => format!(
                 "SELECT index_block_hash FROM staging_blocks ORDER BY height DESC LIMIT {}",
                 argv[4]
             ),
+            Some(_) => print_help_and_exit(),
             // Default to ALL blocks
-            _ => "SELECT index_block_hash FROM staging_blocks".into(),
+            None => "SELECT index_block_hash FROM staging_blocks".into(),
         };
 
         let mut stmt = conn.prepare(&query).unwrap();

From 59bb4aa3f0cd229bb38a9cc3f53cfb5f6f74985b Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Sat, 10 Feb 2024 22:40:02 -0500
Subject: [PATCH 0731/1166] feat: setup signers correctly when booting into
 Nakamoto

---
 .../chainstate/nakamoto/coordinator/tests.rs  |  35 +++++-
 stackslib/src/chainstate/nakamoto/mod.rs      | 112 +-----------------
 stackslib/src/chainstate/stacks/boot/mod.rs   |  33 ++----
 .../src/chainstate/stacks/boot/pox-4.clar     |  14 ---
 .../stacks/boot/signers-voting.clar           |   2 +-
 .../stacks/boot/signers_voting_tests.rs       |  34 +++---
 stackslib/src/clarity_vm/clarity.rs           |  41 -------
 stackslib/src/net/tests/mod.rs                |   2 +-
 8 files changed, 68 insertions(+), 205 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index 395caacc92..ccae3812f1 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -36,7 +36,8 @@ use crate::chainstate::nakamoto::tests::node::{TestSigners, TestStacker};
 use crate::chainstate::nakamoto::{NakamotoBlock, NakamotoChainState};
 use crate::chainstate::stacks::address::PoxAddress;
 use crate::chainstate::stacks::boot::test::{
-    key_to_stacks_addr, make_pox_4_aggregate_key, make_pox_4_lockup, make_signer_key_signature,
+    key_to_stacks_addr, make_pox_4_lockup, make_signer_key_signature,
+    make_signers_vote_for_aggregate_public_key,
 };
 use crate::chainstate::stacks::boot::MINERS_NAME;
 use crate::chainstate::stacks::db::{MinerPaymentTxFees, StacksAccount, StacksChainState};
@@ -101,6 +102,23 @@ fn advance_to_nakamoto(
                     )
                 })
                 .collect()
+        } else if sortition_height == 7 {
+            // Vote for the aggregate key
+            test_stackers
+                .iter()
+                .enumerate()
+                .map(|(index, test_stacker)| {
+                    info!("Vote for aggregate key: {}", index);
+                    make_signers_vote_for_aggregate_public_key(
+                        &test_stacker.signer_private_key,
+                        0,
+                        index as u128,
+                        &test_signers.aggregate_public_key,
+                        0,
+                        7,
+                    )
+                })
+                .collect()
         } else {
             vec![]
         };
@@ -111,7 +129,8 @@ fn advance_to_nakamoto(
 }
 
 /// Make a peer and transition it into the Nakamoto epoch.
-/// The node needs to be stacking; otherwise, Nakamoto won't activate.
+/// The node needs to be stacking and it needs to vote for an aggregate key;
+/// otherwise, Nakamoto can't activate.
 pub fn boot_nakamoto<'a>(
     test_name: &str,
     mut initial_balances: Vec<(PrincipalData, u64)>,
@@ -152,7 +171,19 @@ pub fn boot_nakamoto<'a>(
         })
         .collect();
 
+    // Create some balances for test Signers
+    let mut signer_balances = test_stackers
+        .iter()
+        .map(|stacker| {
+            (
+                PrincipalData::from(p2pkh_from(&stacker.signer_private_key)),
+                1000,
+            )
+        })
+        .collect();
+
     peer_config.initial_balances.append(&mut stacker_balances);
+    peer_config.initial_balances.append(&mut signer_balances);
     peer_config.initial_balances.append(&mut initial_balances);
     peer_config.burnchain.pox_constants.v2_unlock_height = 21;
     peer_config.burnchain.pox_constants.pox_3_activation_height = 26;
diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index 4d197e11cb..806786cb24 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -1796,7 +1796,7 @@ impl NakamotoChainState {
         Ok(true)
     }
 
-    /// Get the aggregate public key for the given block from the pox-4 contract
+    /// Get the aggregate public key for the given block from the signers-voting contract
     fn load_aggregate_public_key<SH: SortitionHandle>(
         sortdb: &SortitionDB,
         sort_handle: &SH,
@@ -1818,7 +1818,10 @@ impl NakamotoChainState {
             return Err(ChainstateError::InvalidStacksBlock(msg));
         };
 
-        debug!("get-aggregate-public-key {} {}", at_block_id, rc);
+        debug!(
+            "get-approved-aggregate-key at block {}, cycle {}",
+            at_block_id, rc
+        );
         match chainstate.get_aggregate_public_key_pox_4(sortdb, at_block_id, rc)? {
             Some(key) => Ok(key),
             None => {
@@ -2602,15 +2605,6 @@ impl NakamotoChainState {
             );
         }
 
-        if !clarity_tx.config.mainnet {
-            Self::set_aggregate_public_key(
-                &mut clarity_tx,
-                first_block_height,
-                pox_constants,
-                burn_header_height.into(),
-            );
-        }
-
         // Handle signer stackerdb updates
         let signer_set_calc;
         if evaluated_epoch >= StacksEpochId::Epoch25 {
@@ -2675,102 +2669,6 @@ impl NakamotoChainState {
         Ok(lockup_events)
     }
 
-    /// Set the aggregate public key for verifying stacker signatures.
-    /// TODO: rely on signer voting instead
-    /// DO NOT USE IN MAINNET
-    pub(crate) fn set_aggregate_public_key(
-        clarity_tx: &mut ClarityTx,
-        first_block_height: u64,
-        pox_constants: &PoxConstants,
-        burn_header_height: u64,
-    ) {
-        let mainnet = clarity_tx.config.mainnet;
-        let chain_id = clarity_tx.config.chain_id;
-        assert!(!mainnet);
-
-        let my_reward_cycle = pox_constants
-            .block_height_to_reward_cycle(
-                first_block_height,
-                burn_header_height
-                    .try_into()
-                    .expect("Burn block height exceeded u32"),
-            )
-            .expect("FATAL: block height occurs before first block height");
-
-        let parent_reward_cycle = my_reward_cycle.saturating_sub(1);
-        debug!(
-            "Try setting aggregate public key in reward cycle {}, parent {}",
-            my_reward_cycle, parent_reward_cycle
-        );
-
-        // execute `set-aggregate-public-key` using `clarity-tx`
-        let Some(aggregate_public_key) = clarity_tx
-            .connection()
-            .with_readonly_clarity_env(
-                mainnet,
-                chain_id,
-                ClarityVersion::Clarity2,
-                StacksAddress::burn_address(mainnet).into(),
-                None,
-                LimitedCostTracker::Free,
-                |vm_env| {
-                    vm_env.execute_contract_allow_private(
-                        &boot_code_id(POX_4_NAME, mainnet),
-                        "get-aggregate-public-key",
-                        &vec![SymbolicExpression::atom_value(Value::UInt(u128::from(
-                            parent_reward_cycle,
-                        )))],
-                        true,
-                    )
-                },
-            )
-            .ok()
-            .map(|agg_key_value| {
-                let agg_key_opt = agg_key_value
-                    .expect_optional()
-                    .expect("FATAL: not an optional")
-                    .map(|agg_key_buff| {
-                        Value::buff_from(agg_key_buff.expect_buff(33).expect("FATAL: not a buff"))
-                            .expect("failed to reconstruct buffer")
-                    });
-                agg_key_opt
-            })
-            .flatten()
-        else {
-            panic!(
-                "No aggregate public key in parent cycle {}",
-                parent_reward_cycle
-            );
-        };
-
-        clarity_tx.connection().as_transaction(|tx| {
-            tx.with_abort_callback(
-                |vm_env| {
-                    vm_env.execute_in_env(
-                        StacksAddress::burn_address(mainnet).into(),
-                        None,
-                        None,
-                        |vm_env| {
-                            vm_env.execute_contract_allow_private(
-                                &boot_code_id(POX_4_NAME, mainnet),
-                                "set-aggregate-public-key",
-                                &vec![
-                                    SymbolicExpression::atom_value(Value::UInt(u128::from(
-                                        my_reward_cycle,
-                                    ))),
-                                    SymbolicExpression::atom_value(aggregate_public_key),
-                                ],
-                                false,
-                            )
-                        },
-                    )
-                },
-                |_, _| false,
-            )
-            .expect("FATAL: failed to set aggregate public key")
-        });
-    }
-
     /// Append a Nakamoto Stacks block to the Stacks chain state.
     pub fn append_block<'a>(
         chainstate_tx: &mut ChainstateTx,
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index d7f0f810f3..48578c604e 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -1291,16 +1291,21 @@ impl StacksChainState {
             .eval_boot_code_read_only(
                 sortdb,
                 block_id,
-                POX_4_NAME,
-                &format!("(get-aggregate-public-key u{})", reward_cycle),
+                SIGNERS_VOTING_NAME,
+                &format!("(get-approved-aggregate-key u{})", reward_cycle),
             )?
             .expect_optional()?;
+        debug!(
+            "Aggregate public key for reward cycle {} is {:?}",
+            reward_cycle, aggregate_public_key_opt
+        );
 
         let aggregate_public_key = match aggregate_public_key_opt {
             Some(value) => {
                 // A point should have 33 bytes exactly.
                 let data = value.expect_buff(33)?;
-                let msg = "Pox-4 get-aggregate-public-key returned a corrupted value.";
+                let msg =
+                    "Pox-4 signers-voting get-approved-aggregate-key returned a corrupted value.";
                 let compressed_data = Compressed::try_from(data.as_slice()).expect(msg);
                 Some(Point::try_from(&compressed_data).expect(msg))
             }
@@ -1899,31 +1904,13 @@ pub mod test {
         make_tx(key, nonce, 0, payload)
     }
 
-    pub fn make_pox_4_aggregate_key(
-        key: &StacksPrivateKey,
-        nonce: u64,
-        reward_cycle: u64,
-        aggregate_public_key: &Point,
-    ) -> StacksTransaction {
-        let aggregate_public_key = Value::buff_from(aggregate_public_key.compress().data.to_vec())
-            .expect("Failed to serialize aggregate public key");
-        let payload = TransactionPayload::new_contract_call(
-            boot_code_test_addr(),
-            POX_4_NAME,
-            "set-aggregate-public-key",
-            vec![Value::UInt(reward_cycle as u128), aggregate_public_key],
-        )
-        .unwrap();
-        make_tx(key, nonce, 0, payload)
-    }
-
     pub fn make_signers_vote_for_aggregate_public_key(
         key: &StacksPrivateKey,
         nonce: u64,
         signer_index: u128,
         aggregate_public_key: &Point,
         round: u128,
-        cycle: u128
+        cycle: u128,
     ) -> StacksTransaction {
         let aggregate_public_key = Value::buff_from(aggregate_public_key.compress().data.to_vec())
             .expect("Failed to serialize aggregate public key");
@@ -1935,7 +1922,7 @@ pub mod test {
                 Value::UInt(signer_index),
                 aggregate_public_key,
                 Value::UInt(round),
-                Value::UInt(cycle)
+                Value::UInt(cycle),
             ],
         )
         .unwrap();
diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index d8655250dd..c375a5fe1f 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -1331,17 +1331,3 @@
 (define-read-only (get-partial-stacked-by-cycle (pox-addr { version: (buff 1), hashbytes: (buff 32) }) (reward-cycle uint) (sender principal))
     (map-get? partial-stacked-by-cycle { pox-addr: pox-addr, reward-cycle: reward-cycle, sender: sender })
 )
-
-;; What is the given reward cycle's stackers' aggregate public key?
-;; *New in Stacks 3.0*
-(define-read-only (get-aggregate-public-key (reward-cycle uint))
-    (map-get? aggregate-public-keys reward-cycle)
-)
-
-;; Set the aggregate public key to the provided value
-;; *New in Stacks 3.0*
-(define-private (set-aggregate-public-key (reward-cycle uint) (aggregate-public-key (buff 33)))
-    (begin
-        (ok (map-set aggregate-public-keys reward-cycle aggregate-public-key))
-    )
-)
diff --git a/stackslib/src/chainstate/stacks/boot/signers-voting.clar b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
index ba27f1d8b7..b8375d3431 100644
--- a/stackslib/src/chainstate/stacks/boot/signers-voting.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
@@ -104,7 +104,7 @@
 ;;  The vote happens in the prepare phase of the current reward cycle but may be ran more than
 ;;  once resulting in different 'rounds.' Each signer vote is based on the weight of stacked
 ;;  stx tokens & fetched from the .signers contract. The vote is ran until the consensus 
-;;  threshold of 70% for a specific aggregate public key is reached. 
+;;  threshold of 70% for a specific aggregate public key is reached.
 (define-public (vote-for-aggregate-public-key (signer-index uint) (key (buff 33)) (round uint) (reward-cycle uint))
     (let ((tally-key {reward-cycle: reward-cycle, round: round, aggregate-public-key: key})
             ;; vote by signer weight
diff --git a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
index 9b0c6540c3..89370b228e 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
@@ -143,12 +143,10 @@ fn vote_for_aggregate_public_key_success() {
     let bob = TestStacker::from_seed(&[5, 6]);
     let observer = TestEventObserver::new();
 
-    let alice_nonce = 0;
     let alice_key = &alice.signer_private_key;
     let alice_address = key_to_stacks_addr(alice_key);
     let alice_principal = PrincipalData::from(alice_address);
 
-    let bob_nonce = 0;
     let bob_key = &bob.signer_private_key;
     let bob_address = key_to_stacks_addr(bob_key);
     let bob_principal = PrincipalData::from(bob_address);
@@ -163,6 +161,10 @@ fn vote_for_aggregate_public_key_success() {
         Some(&observer),
     );
 
+    // Alice and Bob will each have voted once while booting to Nakamoto
+    let alice_nonce = 1;
+    let bob_nonce = 1;
+
     let cycle_id = current_reward_cycle;
 
     // create vote txs
@@ -182,7 +184,7 @@ fn vote_for_aggregate_public_key_success() {
             alice_index,
             &aggregate_public_key,
             0,
-            cycle_id
+            cycle_id + 1,
         ),
         // Bob casts a vote for the aggregate public key
         make_signers_vote_for_aggregate_public_key(
@@ -191,7 +193,7 @@ fn vote_for_aggregate_public_key_success() {
             bob_index,
             &aggregate_public_key,
             0,
-            cycle_id
+            cycle_id + 1,
         ),
     ];
 
@@ -223,7 +225,7 @@ fn vote_for_aggregate_public_key_success() {
                 ),
                 ("key".into(), aggregate_public_key_value.clone()),
                 ("new-total".into(), Value::UInt(1000000000000000000)),
-                ("reward-cycle".into(), Value::UInt(cycle_id)),
+                ("reward-cycle".into(), Value::UInt(cycle_id + 1)),
                 ("round".into(), Value::UInt(0)),
                 ("signer".into(), Value::Principal(alice_principal.clone())),
             ])
@@ -250,7 +252,7 @@ fn vote_for_aggregate_public_key_success() {
                 ),
                 ("key".into(), aggregate_public_key_value.clone()),
                 ("new-total".into(), Value::UInt(2000000000000000000)),
-                ("reward-cycle".into(), Value::UInt(cycle_id)),
+                ("reward-cycle".into(), Value::UInt(cycle_id + 1)),
                 ("round".into(), Value::UInt(0)),
                 ("signer".into(), Value::Principal(bob_principal.clone())),
             ])
@@ -274,7 +276,7 @@ fn vote_for_aggregate_public_key_success() {
                     .expect("Failed to create string")
                 ),
                 ("key".into(), aggregate_public_key_value.clone()),
-                ("reward-cycle".into(), Value::UInt(cycle_id)),
+                ("reward-cycle".into(), Value::UInt(cycle_id + 1)),
             ])
             .expect("Failed to create tuple")
             .into()
@@ -303,7 +305,7 @@ fn vote_for_aggregate_public_key_in_first_block() {
     );
 
     // create vote txs
-    let signer_nonce = 0;
+    let signer_nonce = 1; // Start at 1 because the signer has already voted once
     let signer_key = &stacker_1.signer_private_key;
     let signer_address = key_to_stacks_addr(signer_key);
     let signer_principal = PrincipalData::from(signer_address);
@@ -321,7 +323,7 @@ fn vote_for_aggregate_public_key_in_first_block() {
             signer_index,
             &aggregate_public_key,
             0,
-            cycle_id
+            cycle_id + 1,
         ),
         // cast the vote twice
         make_signers_vote_for_aggregate_public_key(
@@ -330,7 +332,7 @@ fn vote_for_aggregate_public_key_in_first_block() {
             signer_index,
             &aggregate_public_key,
             0,
-            cycle_id
+            cycle_id + 1,
         ),
     ];
 
@@ -400,7 +402,7 @@ fn vote_for_aggregate_public_key_in_last_block() {
     let aggregate_public_key_2 = Point::from(Scalar::from(2));
 
     // create vote txs for alice
-    let signer_1_nonce = 0;
+    let signer_1_nonce = 1; // Start at 1 because the signer has already voted once
     let signer_1_key = &stacker_1.signer_private_key;
     let signer_1_address = key_to_stacks_addr(signer_1_key);
     let signer_1_principal = PrincipalData::from(signer_1_address);
@@ -414,7 +416,7 @@ fn vote_for_aggregate_public_key_in_last_block() {
             signer_1_index,
             &aggregate_public_key_1,
             1,
-            cycle_id
+            cycle_id + 1,
         ),
         // cast the vote twice
         make_signers_vote_for_aggregate_public_key(
@@ -423,7 +425,7 @@ fn vote_for_aggregate_public_key_in_last_block() {
             signer_1_index,
             &aggregate_public_key_1,
             1,
-            cycle_id
+            cycle_id + 1,
         ),
         // cast a vote for old round
         make_signers_vote_for_aggregate_public_key(
@@ -432,12 +434,12 @@ fn vote_for_aggregate_public_key_in_last_block() {
             signer_1_index,
             &aggregate_public_key_2,
             0,
-            cycle_id
+            cycle_id + 1,
         ),
     ];
 
     // create vote txs for bob
-    let signer_2_nonce = 0;
+    let signer_2_nonce = 1; // Start at 1 because the signer has already voted once
     let signer_2_key = &stacker_2.signer_private_key;
     let signer_2_address = key_to_stacks_addr(signer_2_key);
     let signer_2_principal = PrincipalData::from(signer_2_address);
@@ -451,7 +453,7 @@ fn vote_for_aggregate_public_key_in_last_block() {
             signer_2_index,
             &aggregate_public_key_1,
             0,
-            cycle_id
+            cycle_id + 1,
         ),
     ];
 
diff --git a/stackslib/src/clarity_vm/clarity.rs b/stackslib/src/clarity_vm/clarity.rs
index a8059bd0ed..0465bf9a15 100644
--- a/stackslib/src/clarity_vm/clarity.rs
+++ b/stackslib/src/clarity_vm/clarity.rs
@@ -1394,47 +1394,6 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
                     )
                     .expect("Failed to set burnchain parameters in PoX-3 contract");
 
-                // set the aggregate public key for all pre-pox-4 cycles, if in testnet, and can fetch a boot-setting
-                if !mainnet {
-                    if let Some(ref agg_pub_key) = initialized_agg_key {
-                        for set_in_reward_cycle in 0..=pox_4_first_cycle {
-                            info!(
-                                "Setting initial aggregate-public-key in PoX-4";
-                                "agg_pub_key" => %agg_pub_key,
-                                "reward_cycle" => set_in_reward_cycle,
-                                "pox_4_first_cycle" => pox_4_first_cycle,
-                            );
-                            tx_conn
-                                .with_abort_callback(
-                                    |vm_env| {
-                                        vm_env.execute_in_env(
-                                            StacksAddress::burn_address(false).into(),
-                                            None,
-                                            None,
-                                            |env| {
-                                                env.execute_contract_allow_private(
-                                                    &pox_4_contract_id,
-                                                    "set-aggregate-public-key",
-                                                    &[
-                                                        SymbolicExpression::atom_value(
-                                                            Value::UInt(set_in_reward_cycle.into()),
-                                                        ),
-                                                        SymbolicExpression::atom_value(
-                                                            agg_pub_key.clone(),
-                                                        ),
-                                                    ],
-                                                    false,
-                                                )
-                                            },
-                                        )
-                                    },
-                                    |_, _| false,
-                                )
-                                .unwrap();
-                        }
-                    }
-                }
-
                 receipt
             });
 
diff --git a/stackslib/src/net/tests/mod.rs b/stackslib/src/net/tests/mod.rs
index 859f0b57cf..7b61c10c2a 100644
--- a/stackslib/src/net/tests/mod.rs
+++ b/stackslib/src/net/tests/mod.rs
@@ -41,7 +41,7 @@ use crate::chainstate::nakamoto::tests::node::{TestSigners, TestStacker};
 use crate::chainstate::nakamoto::{NakamotoBlock, NakamotoChainState};
 use crate::chainstate::stacks::address::PoxAddress;
 use crate::chainstate::stacks::boot::test::{
-    key_to_stacks_addr, make_pox_4_aggregate_key, make_pox_4_lockup, make_signer_key_signature,
+    key_to_stacks_addr, make_pox_4_lockup, make_signer_key_signature,
 };
 use crate::chainstate::stacks::boot::MINERS_NAME;
 use crate::chainstate::stacks::db::{MinerPaymentTxFees, StacksAccount, StacksChainState};

From 4d93d7a9a307001e597dc0233a9dc84a2d3a60c6 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Sat, 10 Feb 2024 23:06:22 -0500
Subject: [PATCH 0732/1166] feat: nakamoto inventory state machine, and unit
 tests

---
 stackslib/src/net/inv/nakamoto.rs       | 341 ++++++++++++++++++++++++
 stackslib/src/net/tests/inv/nakamoto.rs |  70 +++++
 stackslib/src/net/tests/mod.rs          | 134 +++++++++-
 3 files changed, 531 insertions(+), 14 deletions(-)

diff --git a/stackslib/src/net/inv/nakamoto.rs b/stackslib/src/net/inv/nakamoto.rs
index cb31d4faba..b8cc41cf14 100644
--- a/stackslib/src/net/inv/nakamoto.rs
+++ b/stackslib/src/net/inv/nakamoto.rs
@@ -15,13 +15,21 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::collections::HashMap;
+use std::collections::BTreeMap;
 
+use crate::burnchains::PoxConstants;
 use crate::chainstate::burn::db::sortdb::SortitionDB;
 use crate::chainstate::burn::{BlockSnapshot, ConsensusHash};
 use crate::chainstate::nakamoto::NakamotoChainState;
 use crate::chainstate::stacks::db::StacksChainState;
 use crate::net::{Error as NetError, NakamotoInvData};
+use crate::net::NeighborComms;
 use crate::util_lib::db::Error as DBError;
+use crate::net::StacksMessageType;
+use crate::net::GetNakamotoInvData;
+use crate::net::NakamotoInvData;
+
+use stacks_common::util::get_epoch_time_secs();
 
 /// Cached data for a sortition in the sortition DB.
 /// Caching this allows us to avoid calls to `SortitionDB::get_block_snapshot_consensus()`.
@@ -233,3 +241,336 @@ impl InvGenerator {
         Ok(tenure_status)
     }
 }
+
+#[derive(Debug, PartialEq, Clone)]
+pub struct NakamotoTenureInv {
+    /// Bitmap of which tenures a peer has.
+    /// Maps reward cycle to bitmap.
+    pub tenures_inv: BTreeMap<u64, Vec<u8>>,
+    /// Highest sortition this peer has seen
+    pub highest_sortition: u64,
+    /// Time of last update, in seconds
+    pub last_updated_at: u64,
+    /// Burn block height of first sortition
+    pub first_block_height: u64,
+    /// Length of reward cycle
+    pub reward_cycle_len: u64,
+
+    /// The fields below are used for synchronizing this particular peer's inventories.
+    /// Currently tracked reward cycle
+    pub cur_reward_cycle: u64,
+    /// Status of this node.
+    /// True if we should keep talking to it; false if not
+    pub online: bool,
+    /// Last time we began talking to this peer
+    pub start_sync_time: u64,
+}
+
+impl NakamotoTenureInv {
+    pub fn new(first_block_height: u64, reward_cycle_len: u64) -> Self {
+        Self {
+            tenures_inv: vec![],
+            highest_sortition: 0,
+            last_updated_at: 0,
+            first_block_height,
+            reward_cycle_len,
+            cur_reward_cycle: 0,
+            online: true,
+            start_sync_time: 0,
+        }
+    }
+
+    /// Does this remote neighbor have the ith tenure data for the given (absolute) burn block height?
+    /// (note that block_height is the _absolute_ block height)
+    pub fn has_ith_tenure(&self, burn_block_height: u64) -> bool {
+        if burn_block_height < self.first_block_height {
+            return false;
+        }
+
+        let Some(reward_cycle) = PoxConstants::static_block_height_to_reward_cycle(burn_block_height, self.first_block_height, self.reward_cycle_len) else {
+            return false;
+        };
+
+        let rc_idx = usize::try_from(reward_cycle).expect("FATAL: reward cycle exceeds usize");
+        let Some(rc_tenures) = self.tenures_inv.get(rc_idx) else {
+            return false;
+        };
+
+        let sortition_height = burn_block_height - self.first_block_height;
+        let rc_height = sortition_height % self.reward_cycle_len;
+
+        let idx = usize::try_from(rc_height / 8).expect("FATAL: reward cycle length exceeds host usize");
+        let bit = rc_height % 8;
+
+        rc_tenures
+            .get(idx)
+            .map(|bits| bits & (1 << bit) != 0)
+            .unwrap_or(false)
+    }
+
+    /// How many reward cycles of data do we have for this peer?
+    pub fn num_reward_cycles(&self) -> u64 {
+        let Some((highest_rc, _)) = self.tenures_inv.last_key_value() else {
+            return 0;
+        };
+        *highest_rc
+    }
+
+    /// Add in a newly-discovered inventory.
+    /// NOTE: inventories are supposed to be aligned to the reward cycle
+    pub fn merge_tenure_inv(&mut self, tenure_inv: Vec<u8>, tenure_bitlen: u16, reward_cycle: u64) {
+        // populate the tenures bitmap to we can fit this tenures inv
+        let rc_idx = usize::try_from(reward_cycle).expect("FATAL: reward_cycle exceeds usize");
+
+        self.highest_sortition = self.num_reward_cycles() * self.reward_cycle_len + u64::from(tenure_bitlen);
+        self.tenures_inv[rc_idx] = tenure_inv;
+        self.last_updated_at = get_epoch_time_secs();
+    }
+
+    /// Adjust the next reward cycle to query.
+    /// Returns the reward cycle to query.
+    pub fn next_reward_cycle(&mut self) -> u64 {
+        let query_rc = self.cur_reward_cycle;
+        self.cur_reward_cycle += 1;
+        query_rc
+    }
+
+    /// Reset synchronization state for this peer.  Don't remove inventory data; just make it so we
+    /// can talk to the peer again
+    pub fn try_reset_comms(&mut self, inv_sync_interval: u64, start_rc: u64) {
+        let now = get_epoch_time_secs();
+        if self.start_sync_time + inv_sync_interval <= now {
+            self.online = true;
+            self.start_sync_time = now;
+            self.cur_reward_cycle = start_rc;
+        }
+    }
+
+    /// Get the reward cycle we're sync'ing for
+    pub fn reward_cycle(&self) -> u64 {
+        self.cur_reward_cycle
+    }
+
+    /// Get online status
+    pub fn is_online(&self) -> bool {
+        self.online
+    }
+
+    /// Set online status.  We don't talk to offline peers
+    pub fn set_online(&mut self, online: bool) {
+        self.online = online;
+    }
+}
+
+#[derive(Debug, PartialEq, Clone, Copy)]
+pub enum NakamotoInvState {
+    GetNakamotoInvBegin,
+    GetNakamotoInvFinish,
+    Done
+}
+
+/// Nakamoto inventory state machine
+pub struct NakamotoInvStateMachine<NC: NeighborComms> {
+    /// What state is the machine in?
+    pub(crate) state: NakamotoInvState,
+    /// Communications links 
+    pub(crate) comms: NC,
+    /// Nakamoto inventories we have
+    inventories: HashMap<NeighborAddress, NakamotoTenureInv>,
+    /// Reward cycle consensus hashes
+    reward_cycle_consensus_hashes: BTreeMap<u64, ConsensusHash>,
+    /// What reward cycle are we in?
+    cur_reward_cycle: u64,
+}
+
+impl<NC: NeighborComms> NakamotoInvStateMachine<NC> {
+    pub fn new(comms: NC) -> Self {
+        Self {
+            state: NakamotoInvstate::GetNakamotoInvBegin,
+            comms: NC,
+            inventories: HashMap::new(),
+            reward_cycle_consensus_hashes: BTreeMap::new(),
+            cur_reward_cycle: 0,
+        }
+    }
+
+    pub fn reset(&mut self) {
+        self.comms.reset();
+        self.inventories.clear();
+        self.state = NakamotoInvState::GetNakamotoInvBegin;
+    }
+
+    /// Get the consensus hash for the first sortition in the given reward cycle
+    fn load_consensus_hash_for_reward_cycle(sortdb: &SortitionDB, reward_cycle: u64) -> Result<Option<ConsensusHash>, NetError> {
+        let consensus_hash = {
+            let reward_cycle_start_height = sortdb
+                .pox_constants
+                .reward_cycle_to_block_height(sortdb.first_block_height, reward_cycle);
+            let sn = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn())?;
+            let ih = sortdb.index_handle(sn.sortition_id);
+            let Some(rc_start_sn) = ih
+                .get_block_snapshot_by_height(reward_cycle_start_height)?
+            else {
+                return None;
+            };
+            rc_start_sn.consensus_hash
+        };
+        Ok(Some(consensus_hash))
+    }
+
+    /// Populate the reward_cycle_consensus_hash mapping.  Idempotent.
+    /// Returns the current reward cycle.
+    fn update_reward_cycle_consensus_hashes(&mut self, sortdb: &SortitionDB) -> Result<u64, NetError> {
+        let highest_rc = if let Some((highest_rc, _)) = self.reward_cycle_consensus_hashes.last_key_value() {
+            *highest_rc
+        }
+        else {
+            0
+        };
+
+        let sn = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn())?;
+        let tip_rc = sortdb
+            .pox_constants
+            .reward_cycle_to_block_height(sortdb.first_block_height, sn.block_height);
+
+        for rc in highest_rc..=tip_rc {
+            if self.reward_cycle_consnsus_hashes.contains_key(&rc) {
+                continue;
+            }
+            let Some(ch) = Self::load_consensus_hash_for_reward_cycle(sortdb, rc)? else {
+                continue;
+            };
+            self.reward_cycle_consensus_hashes.insert(rc, ch);
+        }
+        Ok(tip_rc)
+    }
+
+    /// Make a getnakamotoinv message
+    fn make_getnakamotoinv(&self, reward_cycle: u64) -> Option<StacksMessageType> {
+        let Some(ch) = self.reward_cycle_consensus_hashes.get(&reward_cycle) else {
+            return None;
+        };
+        Some(StacksMessageType::GetNakamotoInv(GetNakamotoInvData {
+            consensus_hash: ch.clone()
+        }))
+    }
+
+    /// Proceed to ask neighbors for their nakamoto tenure inventories.
+    /// If we're in initial block download (ibd), then only ask our bootstrap peers.
+    /// Otherwise, ask everyone.
+    /// Returns Ok(true) if we completed this step of the state machine
+    /// Returns Ok(false) if not (currently this never happens)
+    /// Returns Err(..) on I/O errors
+    pub fn getnakamotoinv_begin(&mut self, network: &mut PeerNetwork, sortdb: &SortitionDB, ibd: bool) -> Result<bool, NetError> {
+        // make sure we know all consensus hashes for all reward cycles.
+        let current_reward_cycle = self.update_reward_cycle_consensus_hashes(sortdb)?;
+        self.cur_reward_cycle = current_reward_cycle;
+
+        // we're updating inventories, so preserve the state we have
+        let mut new_inventories = BTreeMap::new();
+        for event_id in network.peer_iter_event_ids() {
+            let Some(convo) = network.get_p2p_convo(*event_id) else {
+                continue;
+            };
+            if ibd {
+                // in IBD, only connect to initial peers
+                let is_initial = PeerDB::is_initial_peer(
+                    &network.peerdb_conn(),
+                    convo.peer_network_id,
+                    &convo.peer_addrbytes,
+                    convo.peer_port
+                ).unwrap_or(false);
+                if !is_initial {
+                    continue;
+                }
+            }
+
+            let naddr = convo.to_neighbor_address();
+
+            let mut inv = self.inventories
+                .get(&naddr)
+                .clone()
+                .unwrap_or(NakamotoTenureInv::new(
+                    network.get_burnchain().first_block_height,
+                    network.get_burnchain().pox_constants.reward_cycle_len,
+                ));
+
+            // possibly reset communications with this peer, if it's time to do so.
+            inv.try_reset_comms(network.get_connection_opts().inv_sync_interval, current_reward_cycle.saturating_sub(network.get_connection_opts().inv_reward_cycles));
+            if !inv.is_online() {
+                // don't talk to this peer
+                continue;
+            }
+
+            if inv.reward_cycle() > current_reward_cycle {
+                // we've fully sync'ed with this peer
+                continue;
+            }
+
+            // ask this neighbor for its inventory
+            if let Some(getnakamotoinv) = self.make_getnakamotoinv(inv.reward_cycle()) {
+                if let Err(e) = self.comms.neighbor_send(network, &naddr, getnakamotoinv) {
+                    warn!("{:?}: failed to send GetNakamotoInv", network.get_local_peer();
+                          "message" => ?getnakamotoinv,
+                          "peer" => ?naddr,
+                          "error" => ?e
+                    );
+                }
+                else {
+                    // keep this connection open
+                    self.comms.pin_connection(*event_id);
+                }
+            }
+
+            new_inventories.insert(naddr, inv);
+        }
+
+        self.inventories = new_inventories;
+        Ok(true);
+    }
+
+    /// Finish asking for inventories, and update inventory state.
+    pub fn getnakamotoinv_try_finish(&mut self, network: &mut PeerNetwork) -> Result<bool, NetError> {
+        let mut inv_replies = vec![];
+        let mut nack_replies = vec![];
+        for (naddr, reply) in self.comms.collect_replies(network) {
+            match reply {
+                StacksMessageType::NakamotoInv(inv_data) => {
+                    inv_replies.push((naddr, inv_data));
+                }
+                StacksMessageType::Nack(nack_data) => {
+                    nack_replies.push((naddr, nack_data));
+                }
+            }
+        }
+
+        // process NACKs
+        for (naddr, nack_data) in nack_replies.into_iter() {
+            info!("{:?}: remote peer NACKed our GetNakamotoInv", network.get_local_peer();
+                  "error_code" => nack_data.error_code);
+
+            let Some(inv) = self.inventories.get_mut(&naddr) else {
+                continue;
+            };
+
+            // stop talking to this peer
+            inv.set_online(false);
+        }
+
+        // process NakamotoInvs
+        for (naddr, inv_data) in inv_replies.into_iter() {
+            let Some(inv) = self.inventories.get_mut(&naddr) else {
+                info!("{:?}: Drop unsolicited NakamotoInv from {:?}", &network.get_local_peer(), &naddr);
+                continue;
+            };
+            inv.merge_tenure_inv(&inv_data.tenures, inv_data.bitlen, inv.reward_cycle());
+            inv.next_reward_cycle();
+        }
+
+        Ok(self.comms.count_inflight() == 0)
+    }
+
+    pub fn run(&mut self, network: &mut PeerNetwork) -> bool {
+        false
+    }
+}
diff --git a/stackslib/src/net/tests/inv/nakamoto.rs b/stackslib/src/net/tests/inv/nakamoto.rs
index e622fd728d..accc174e88 100644
--- a/stackslib/src/net/tests/inv/nakamoto.rs
+++ b/stackslib/src/net/tests/inv/nakamoto.rs
@@ -563,3 +563,73 @@ fn test_nakamoto_invs_different_anchor_blocks() {
     assert_eq!(reward_cycle_invs.len(), 12);
     check_inv_messages(bitvecs, 10, nakamoto_start, reward_cycle_invs);
 }
+
+#[test]
+fn test_nakamoto_tenure_inv() {
+    let mut nakamoto_inv = NakamotoTenureInv::new(100, 100);
+    assert!(!nakamoto_inv.has_ith_tenure(0));
+    assert!(!nakamoto_inv.has_ith_tenure(99));
+    assert!(!nakamoto_inv.has_ith_tenure(100));
+    assert_eq!(nakamoto_inv.num_reward_cycles(), 0);
+
+    let full_tenure = NakamotoInvData::bools_to_bitvec(vec![true; 100]);
+    nakamoto_inv.merge_tenure_inv(full_tenure, 100, 1);
+
+    for i in 100..200 {
+        assert!(nakamoto_inv.has_ith_tenure(i));
+    }
+    assert!(!nakamoto_inv.has_ith_tenure(99));
+    assert!(!nakamoto_inv.has_ith_tenure(200));
+    assert!(!nakamoto_inv.has_ith_tenure(201));
+    assert_eq!(nakamoto_inv.num_reward_cycles(), 1);
+
+    let mut partial_tenure_bools = vec![];
+    for i in 0..100 {
+        partial_tenure_bools.push(i % 2 == 0);
+    }
+
+    // has_ith_tenure() works (non-triial case)
+    let partial_tenure = NakamotoInvData::bools_to_bitvec(partial_tenure_bools);
+    nakamoto_inv.merge_tenure_inv(partial_tenure, 100, 2);
+
+    for i in 200..300 {
+        assert_eq!(nakamoto_inv.has_ith_tenure(i), i % 2 == 0);
+    }
+    assert!(!nakamoto_inv.has_ith_tenure(99));
+    assert!(!nakamoto_inv.has_ith_tenure(300));
+    assert!(!nakamoto_inv.has_ith_tenure(301));
+    assert_eq!(nakamoto_inv.num_reward_cycles(), 2);
+
+    // supports sparse updates
+    let full_tenure = NakamotoInvData::bools_to_bitvec(vec![true; 100]);
+    nakamoto_inv.merge_tenure_inv(full_tenure, 100, 4);
+    
+    for i in 300..400 {
+        assert_eq!(!nakamoto_inv.has_ith_tenure(i));
+    }
+    for i in 400..500 {
+        assert_eq!(!nakamoto_inv.has_ith_tenure(i));
+    }
+    assert_eq!(nakamoto_inv.num_reward_cycles(), 4);
+    
+    // can overwrite tenures
+    let full_tenure = NakamotoInvData::bools_to_bitvec(vec![true; 100]);
+    nakamoto_inv.merge_tenure_inv(partial_tenure, 100, 2);
+
+    for i in 200..300 {
+        assert!(nakamoto_inv.has_ith_tenure(i));
+    }
+
+    // state machine advances when we say so
+    assert_eq!(nakamoto_inv.reward_cycle(), 0);
+    assert!(nakamoto_inv.is_online());
+    nakamoto_inv.set_online(false);
+    assert!(!nakamoto_inv.is_online());
+
+    nakamoto_inv.next_reward_cycle();
+    assert_eq!(nakamoto_inv.reward_cycle(), 1);
+    
+    nakamoto_inv.try_reset_comms(0, 0);
+    assert_eq!(nakamoto_inv.reward_cycle(), 0);
+    assert!(nakamoto_inv.is_online());
+}
diff --git a/stackslib/src/net/tests/mod.rs b/stackslib/src/net/tests/mod.rs
index 5fd3d65e9a..0d2e8af027 100644
--- a/stackslib/src/net/tests/mod.rs
+++ b/stackslib/src/net/tests/mod.rs
@@ -79,6 +79,7 @@ pub struct NakamotoBootPlan {
     pub test_stackers: Option<Vec<TestStacker>>,
     pub test_signers: Option<TestSigners>,
     pub observer: Option<TestEventObserver>,
+    pub num_peers: usize,
 }
 
 impl NakamotoBootPlan {
@@ -91,6 +92,7 @@ impl NakamotoBootPlan {
             test_stackers: None,
             test_signers: None,
             observer: Some(TestEventObserver::new()),
+            num_peers: 0,
         }
     }
 
@@ -138,6 +140,11 @@ impl NakamotoBootPlan {
         self
     }
 
+    pub fn with_extra_peers(mut self, num_peers: usize) -> Self {
+        self.num_peers = num_peers;
+        self
+    }
+
     /// This is the first tenure in which nakamoto blocks will be built.
     /// However, it is also the last sortition for an epoch 2.x block.
     pub fn nakamoto_start_burn_height(pox_consts: &PoxConstants) -> u64 {
@@ -185,13 +192,53 @@ impl NakamotoBootPlan {
         );
     }
 
+    /// Apply burn ops and blocks to the peer replicas
+    fn apply_blocks_to_other_peers(
+        burn_ops: &[BlockstackOperationType],
+        blocks: &[NakamotoBlock],
+        other_peers: &mut [TestPeer],
+    ) {
+        for (i, peer) in other_peers.iter_mut().enumerate() {
+            peer.next_burnchain_block(burn_ops.to_vec());
+
+            let sortdb = peer.sortdb.take().unwrap();
+            let mut node = peer.stacks_node.take().unwrap();
+
+            let sort_tip = SortitionDB::get_canonical_sortition_tip(sortdb.conn()).unwrap();
+            let mut sort_handle = sortdb.index_handle(&sort_tip);
+
+            for block in blocks {
+                let block_id = block.block_id();
+                let accepted = Relayer::process_new_nakamoto_block(
+                    &sortdb,
+                    &mut sort_handle,
+                    &mut node.chainstate,
+                    block.clone(),
+                )
+                .unwrap();
+                if accepted {
+                    test_debug!("Accepted Nakamoto block {block_id} to other peer {}", i);
+                    peer.coord.handle_new_nakamoto_stacks_block().unwrap();
+                } else {
+                    panic!(
+                        "Did NOT accept Nakamoto block {block_id} to other peer {}",
+                        i
+                    );
+                }
+            }
+
+            peer.sortdb = Some(sortdb);
+            peer.stacks_node = Some(node);
+        }
+    }
+
     /// Make a peer and transition it into the Nakamoto epoch.
     /// The node needs to be stacking; otherwise, Nakamoto won't activate.
     fn boot_nakamoto<'a>(
         mut self,
         aggregate_public_key: Point,
         observer: Option<&'a TestEventObserver>,
-    ) -> TestPeer<'a> {
+    ) -> (TestPeer<'a>, Vec<TestPeer>) {
         let mut peer_config = TestPeerConfig::new(&self.test_name, 0, 0);
         peer_config.private_key = self.private_key.clone();
         let addr = StacksAddress::from_public_keys(
@@ -259,14 +306,29 @@ impl NakamotoBootPlan {
         peer_config.initial_balances.append(&mut stacker_balances);
         peer_config.test_stackers = Some(test_stackers.clone());
         peer_config.burnchain.pox_constants = self.pox_constants.clone();
-        let mut peer = TestPeer::new_with_observer(peer_config, observer);
-        self.advance_to_nakamoto(&mut peer);
-        peer
+        let mut peer = TestPeer::new_with_observer(peer_config.clone(), observer);
+
+        let mut other_peers = vec![];
+        for i in 0..self.num_peers {
+            let mut other_config = peer_config.clone();
+            other_config.test_name = format!("{}.follower", &peer.config.test_name);
+            other_config.server_port = 0;
+            other_config.http_port = 0;
+            other_config.test_stackers = peer.config.test_stackers.clone();
+            other_config.private_key = StacksPrivateKey::from_seed(&(i as u128).to_be_bytes());
+
+            other_config.add_neighbor(&peer.to_neighbor());
+            other_peers.push(TestPeer::new_with_observer(other_config, None));
+        }
+
+        self.advance_to_nakamoto(&mut peer, &mut other_peers);
+        (peer, other_peers)
     }
 
     /// Bring a TestPeer into the Nakamoto Epoch
-    fn advance_to_nakamoto(&self, peer: &mut TestPeer) {
+    fn advance_to_nakamoto(&self, peer: &mut TestPeer, other_peers: &mut [TestPeer]) {
         let mut peer_nonce = 0;
+        let mut other_peer_nonces = vec![0; other_peers.len()];
         let addr = StacksAddress::from_public_keys(
             C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
             &AddressHashMode::SerializeP2PKH,
@@ -297,6 +359,12 @@ impl NakamotoBootPlan {
                 .into()
         {
             peer.tenure_with_txs(&vec![], &mut peer_nonce);
+            for (other_peer, other_peer_nonce) in
+                other_peers.iter_mut().zip(other_peer_nonces.iter_mut())
+            {
+                other_peer.tenure_with_txs(&vec![], other_peer_nonce);
+            }
+
             let tip = {
                 let sort_db = peer.sortdb.as_mut().unwrap();
                 let tip = SortitionDB::get_canonical_burn_chain_tip(sort_db.conn()).unwrap();
@@ -330,6 +398,11 @@ impl NakamotoBootPlan {
             .collect();
 
         peer.tenure_with_txs(&stack_txs, &mut peer_nonce);
+        for (other_peer, other_peer_nonce) in
+            other_peers.iter_mut().zip(other_peer_nonces.iter_mut())
+        {
+            other_peer.tenure_with_txs(&stack_txs, other_peer_nonce);
+        }
 
         debug!("\n\n======================");
         debug!("Advance to Epoch 3.0");
@@ -340,6 +413,11 @@ impl NakamotoBootPlan {
             < Self::nakamoto_start_burn_height(&peer.config.burnchain.pox_constants)
         {
             peer.tenure_with_txs(&vec![], &mut peer_nonce);
+            for (other_peer, other_peer_nonce) in
+                other_peers.iter_mut().zip(other_peer_nonces.iter_mut())
+            {
+                other_peer.tenure_with_txs(&vec![], other_peer_nonce);
+            }
             let tip = {
                 let sort_db = peer.sortdb.as_mut().unwrap();
                 let tip = SortitionDB::get_canonical_burn_chain_tip(sort_db.conn()).unwrap();
@@ -353,16 +431,16 @@ impl NakamotoBootPlan {
         debug!("========================\n\n");
     }
 
-    pub fn boot_into_nakamoto_peer<'a>(
+    pub fn boot_into_nakamoto_peers<'a>(
         self,
         boot_plan: Vec<NakamotoBootTenure>,
         observer: Option<&'a TestEventObserver>,
-    ) -> TestPeer<'a> {
+    ) -> (TestPeer<'a>, Vec<TestPeer>) {
         let mut test_signers = self.test_signers.clone().unwrap_or(TestSigners::default());
-        let mut peer = self.boot_nakamoto(test_signers.aggregate_public_key.clone(), observer);
+        let (mut peer, mut other_peers) =
+            self.boot_nakamoto(test_signers.aggregate_public_key.clone(), observer);
 
         let mut all_blocks = vec![];
-        let mut rc_burn_ops = vec![];
         let mut consensus_hashes = vec![];
         let mut last_tenure_change: Option<TenureChangePayload> = None;
         let mut blocks_since_last_tenure = 0;
@@ -381,8 +459,6 @@ impl NakamotoBootPlan {
                         peer.begin_nakamoto_tenure(TenureChangeCause::Extended);
                     let (_, _, next_consensus_hash) = peer.next_burnchain_block(burn_ops.clone());
 
-                    rc_burn_ops.push(burn_ops);
-
                     let tenure_change = last_tenure_change.clone().unwrap();
                     let blocks: Vec<NakamotoBlock> = all_blocks.last().cloned().unwrap();
 
@@ -459,6 +535,7 @@ impl NakamotoBootPlan {
                         &boot_steps,
                         num_expected_transactions,
                     );
+                    Self::apply_blocks_to_other_peers(&burn_ops, &blocks, &mut other_peers);
                     all_blocks.push(blocks);
                 }
                 NakamotoBootTenure::Sortition(boot_steps) => {
@@ -543,6 +620,7 @@ impl NakamotoBootPlan {
                         &boot_steps,
                         num_expected_transactions,
                     );
+                    Self::apply_blocks_to_other_peers(&burn_ops, &blocks, &mut other_peers);
 
                     all_blocks.push(blocks);
                 }
@@ -620,7 +698,34 @@ impl NakamotoBootPlan {
                 }
             }
         }
-        peer
+
+        // verify that all other peers kept pace with this peer
+        for other_peer in other_peers.iter_mut() {
+            let (other_highest_tenure, other_sort_tip) = {
+                let chainstate = &mut other_peer.stacks_node.as_mut().unwrap().chainstate;
+                let sort_db = other_peer.sortdb.as_mut().unwrap();
+                let tip = SortitionDB::get_canonical_burn_chain_tip(sort_db.conn()).unwrap();
+                let tenure = NakamotoChainState::get_highest_nakamoto_tenure(
+                    chainstate.db(),
+                    sort_db.conn(),
+                )
+                .unwrap()
+                .unwrap();
+                (tenure, tip)
+            };
+
+            assert_eq!(other_highest_tenure, highest_tenure);
+            assert_eq!(other_sort_tip, sort_tip);
+        }
+        (peer, other_peers)
+    }
+
+    pub fn boot_into_nakamoto_peer<'a>(
+        self,
+        boot_plan: Vec<NakamotoBootTenure>,
+        observer: Option<&'a TestEventObserver>,
+    ) -> TestPeer<'a> {
+        self.boot_into_nakamoto_peers(boot_plan, observer).0
     }
 }
 
@@ -740,8 +845,9 @@ fn test_boot_nakamoto_peer() {
     let plan = NakamotoBootPlan::new(&function_name!())
         .with_private_key(private_key)
         .with_pox_constants(10, 3)
-        .with_initial_balances(vec![(addr.into(), 1_000_000)]);
+        .with_initial_balances(vec![(addr.into(), 1_000_000)])
+        .with_extra_peers(2);
 
     let observer = TestEventObserver::new();
-    let peer = plan.boot_into_nakamoto_peer(boot_tenures, Some(&observer));
+    let (peer, other_peers) = plan.boot_into_nakamoto_peers(boot_tenures, Some(&observer));
 }

From 29dcd4668b8981db9ed7d647eea1b3ddbe1f9df1 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Sat, 10 Feb 2024 23:06:54 -0500
Subject: [PATCH 0733/1166] chore: API sync

---
 stackslib/src/chainstate/nakamoto/coordinator/tests.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index 551348bffc..170afea434 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -172,7 +172,7 @@ pub fn boot_nakamoto<'a>(
 }
 
 /// Make a replay peer, used for replaying the blockchain
-fn make_replay_peer<'a>(peer: &mut TestPeer<'a>) -> TestPeer<'a> {
+pub fn make_replay_peer<'a>(peer: &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;

From 2d624a09b4f630cd5c21d1ca94f7c17d239a1262 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Sat, 10 Feb 2024 23:07:02 -0500
Subject: [PATCH 0734/1166] chore: add fault injection to force the network
 state machine to run the logic for the 2.x to nakamoto transition

---
 stackslib/src/net/connection.rs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/stackslib/src/net/connection.rs b/stackslib/src/net/connection.rs
index 88f3fff39b..d611c43791 100644
--- a/stackslib/src/net/connection.rs
+++ b/stackslib/src/net/connection.rs
@@ -411,13 +411,14 @@ pub struct ConnectionOptions {
     pub disable_inbound_handshakes: bool,
     pub disable_stackerdb_get_chunks: bool,
     pub force_disconnect_interval: Option<u64>,
+    pub force_nakamoto_epoch_transition: bool,
 }
 
 impl std::default::Default for ConnectionOptions {
     fn default() -> ConnectionOptions {
         ConnectionOptions {
-            inbox_maxlen: 5,
-            outbox_maxlen: 5,
+            inbox_maxlen: 1024,
+            outbox_maxlen: 1024,
             connect_timeout: 10, // how long a socket can be in a connecting state
             handshake_timeout: 30, // how long before a peer must send a handshake, after connecting
             timeout: 30,         // how long to wait for a reply to a request
@@ -503,6 +504,7 @@ impl std::default::Default for ConnectionOptions {
             disable_inbound_handshakes: false,
             disable_stackerdb_get_chunks: false,
             force_disconnect_interval: None,
+            force_nakamoto_epoch_transition: false,
         }
     }
 }

From adc053a987c97b29cde0eec3905ab0a0294d895e Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Sat, 10 Feb 2024 23:07:38 -0500
Subject: [PATCH 0735/1166] refactor: move epoch2x inv state machine logic out
 of src/net/p2p.rs and into src/net/inv/epoch2x.rs

---
 stackslib/src/net/inv/epoch2x.rs | 218 ++++++++++++++++++++++++++++++-
 1 file changed, 214 insertions(+), 4 deletions(-)

diff --git a/stackslib/src/net/inv/epoch2x.rs b/stackslib/src/net/inv/epoch2x.rs
index 27147f36a5..b2cdf96d73 100644
--- a/stackslib/src/net/inv/epoch2x.rs
+++ b/stackslib/src/net/inv/epoch2x.rs
@@ -40,7 +40,7 @@ use crate::net::codec::*;
 use crate::net::connection::{ConnectionOptions, ConnectionP2P, ReplyHandleP2P};
 use crate::net::db::{PeerDB, *};
 use crate::net::neighbors::MAX_NEIGHBOR_BLOCK_DELAY;
-use crate::net::p2p::PeerNetwork;
+use crate::net::p2p::{PeerNetwork, PeerNetworkWorkState};
 use crate::net::{
     Error as net_error, GetBlocksInv, Neighbor, NeighborKey, PeerAddress, StacksMessage, StacksP2P,
     *,
@@ -2171,7 +2171,7 @@ impl PeerNetwork {
     /// Call right after PeerNetwork::refresh_burnchain_view()
     pub fn refresh_sortition_view(&mut self, sortdb: &SortitionDB) -> Result<(), net_error> {
         if self.inv_state.is_none() {
-            self.init_inv_sync(sortdb);
+            self.init_inv_sync_epoch2x(sortdb);
         }
 
         let inv_state = self
@@ -2237,7 +2237,7 @@ impl PeerNetwork {
 
     /// Drive all state machines.
     /// returns (done?, throttled?, peers-to-disconnect, peers-that-are-dead)
-    pub fn sync_inventories(
+    pub fn sync_inventories_epoch2x(
         &mut self,
         sortdb: &SortitionDB,
         ibd: bool,
@@ -2532,7 +2532,7 @@ impl PeerNetwork {
     }
 
     /// Initialize inv state
-    pub fn init_inv_sync(&mut self, sortdb: &SortitionDB) -> () {
+    pub fn init_inv_sync_epoch2x(&mut self, sortdb: &SortitionDB) -> () {
         // find out who we'll be synchronizing with for the duration of this inv sync
         debug!(
             "{:?}: Initializing peer block inventory state",
@@ -2626,6 +2626,216 @@ impl PeerNetwork {
             }
         }
     }
+
+    /// Update the state of our neighbors' epoch 2.x block inventories.
+    /// Return (finished?, throttled?)
+    fn do_network_inv_sync_epoch2x(&mut self, sortdb: &SortitionDB, ibd: bool) -> (bool, bool) {
+        if cfg!(test) && self.connection_opts.disable_inv_sync {
+            test_debug!("{:?}: inv sync is disabled", &self.local_peer);
+            return (true, false);
+        }
+
+        debug!(
+            "{:?}: network inventory sync for epoch 2.x",
+            &self.local_peer
+        );
+
+        if self.inv_state.is_none() {
+            self.init_inv_sync_epoch2x(sortdb);
+        }
+
+        // synchronize peer block inventories
+        let (done, throttled, dead_neighbors, broken_neighbors) =
+            self.sync_inventories_epoch2x(sortdb, ibd);
+
+        // disconnect and ban broken peers
+        for broken in broken_neighbors.into_iter() {
+            self.deregister_and_ban_neighbor(&broken);
+        }
+
+        // disconnect from dead connections
+        for dead in dead_neighbors.into_iter() {
+            self.deregister_neighbor(&dead);
+        }
+
+        (done, throttled)
+    }
+
+    /// Check to see if an always-allowed peer has performed an epoch 2.x inventory sync
+    fn check_always_allowed_peer_inv_sync_epoch2x(&self) -> bool {
+        // only count an inv_sync as passing if there's an always-allowed node
+        // in our inv state
+        let always_allowed: HashSet<_> =
+            PeerDB::get_always_allowed_peers(&self.peerdb.conn(), self.local_peer.network_id)
+                .unwrap_or(vec![])
+                .into_iter()
+                .map(|neighbor| neighbor.addr)
+                .collect();
+
+        // have we finished a full pass of the inventory state machine on an
+        // always-allowed peer?
+        let mut finished_always_allowed_inv_sync = false;
+
+        if always_allowed.len() == 0 {
+            // vacuously, we have done so
+            finished_always_allowed_inv_sync = true;
+        } else {
+            // do we have an always-allowed peer that we have not fully synced
+            // with?
+            let mut have_unsynced = false;
+            if let Some(ref inv_state) = self.inv_state {
+                for (nk, stats) in inv_state.block_stats.iter() {
+                    if self.is_bound(&nk) {
+                        // this is the same address we're bound to
+                        continue;
+                    }
+                    if Some((nk.addrbytes.clone(), nk.port)) == self.local_peer.public_ip_address {
+                        // this is a peer at our address
+                        continue;
+                    }
+                    if !always_allowed.contains(&nk) {
+                        // this peer isn't in the always-allowed set
+                        continue;
+                    }
+
+                    if stats.inv.num_reward_cycles
+                        >= self.pox_id.num_inventory_reward_cycles() as u64
+                    {
+                        // we have fully sync'ed with an always-allowed peer
+                        debug!(
+                            "{:?}: Fully-sync'ed PoX inventory from {}",
+                            self.get_local_peer(),
+                            nk,
+                        );
+                        finished_always_allowed_inv_sync = true;
+                    } else {
+                        // there exists an always-allowed peer that we have not
+                        // fully sync'ed with
+                        debug!(
+                            "{:?}: Have not fully sync'ed with {}",
+                            self.get_local_peer(),
+                            nk,
+                        );
+                        have_unsynced = true;
+                    }
+                }
+            }
+
+            if !have_unsynced {
+                // There exists one or more always-allowed peers in
+                // the inv state machine (per the peer DB), but all such peers
+                // report either our bind address or our public IP address.
+                // If this is the case (i.e. a configuration error, a weird
+                // case where nodes share an IP, etc), then we declare this inv
+                // sync pass as finished.
+                finished_always_allowed_inv_sync = true;
+            }
+        }
+
+        finished_always_allowed_inv_sync
+    }
+
+    /// Do an inventory state machine pass for epoch 2.x.
+    /// Returns the new work state  
+    pub fn work_inv_sync_epoch2x(
+        &mut self,
+        sortdb: &SortitionDB,
+        download_backpressure: bool,
+        ibd: bool,
+    ) -> PeerNetworkWorkState {
+        let mut work_state = PeerNetworkWorkState::BlockInvSync;
+
+        // synchronize epcoh 2.x peer block inventories
+        let (inv_done, inv_throttled) = self.do_network_inv_sync_epoch2x(sortdb, ibd);
+        if inv_done {
+            if !download_backpressure {
+                // proceed to get blocks, if we're not backpressured
+                work_state = PeerNetworkWorkState::BlockDownload;
+            } else {
+                // skip downloads for now
+                work_state = PeerNetworkWorkState::Prune;
+            }
+
+            if !inv_throttled {
+                let finished_always_allowed_inv_sync =
+                    self.check_always_allowed_peer_inv_sync_epoch2x();
+                if finished_always_allowed_inv_sync {
+                    debug!(
+                        "{:?}: synchronized inventories with at least one always-allowed peer",
+                        &self.local_peer
+                    );
+                    self.num_inv_sync_passes += 1;
+                } else {
+                    debug!("{:?}: did NOT synchronize inventories with at least one always-allowed peer", &self.local_peer);
+                }
+                debug!(
+                    "{:?}: Finished full inventory state-machine pass ({})",
+                    self.get_local_peer(),
+                    self.num_inv_sync_passes
+                );
+
+                // hint to the downloader to start scanning at the sortition
+                // height we just synchronized
+                let start_download_sortition = if let Some(ref inv_state) = self.inv_state {
+                    let (consensus_hash, _) = SortitionDB::get_canonical_stacks_chain_tip_hash(
+                        sortdb.conn(),
+                    )
+                    .expect(
+                        "FATAL: failed to load canonical stacks chain tip hash from sortition DB",
+                    );
+                    let stacks_tip_sortition_height =
+                        SortitionDB::get_block_snapshot_consensus(sortdb.conn(), &consensus_hash)
+                            .expect("FATAL: failed to query sortition DB")
+                            .map(|sn| sn.block_height)
+                            .unwrap_or(self.burnchain.first_block_height)
+                            .saturating_sub(self.burnchain.first_block_height);
+
+                    let sortition_height_start =
+                        cmp::min(stacks_tip_sortition_height, inv_state.block_sortition_start);
+
+                    debug!(
+                        "{:?}: Begin downloader synchronization at sortition height {} min({},{})",
+                        &self.local_peer,
+                        sortition_height_start,
+                        inv_state.block_sortition_start,
+                        stacks_tip_sortition_height
+                    );
+
+                    sortition_height_start
+                } else {
+                    // really unreachable, but why tempt fate?
+                    warn!(
+                        "{:?}: Inventory state machine not yet initialized",
+                        &self.local_peer
+                    );
+                    0
+                };
+
+                if let Some(ref mut downloader) = self.block_downloader {
+                    debug!(
+                        "{:?}: wake up downloader at sortition height {}",
+                        &self.local_peer, start_download_sortition
+                    );
+                    downloader.hint_block_sortition_height_available(
+                        start_download_sortition,
+                        ibd,
+                        false,
+                    );
+                    downloader.hint_microblock_sortition_height_available(
+                        start_download_sortition,
+                        ibd,
+                        false,
+                    );
+                } else {
+                    warn!(
+                        "{:?}: Block downloader not yet initialized",
+                        &self.local_peer
+                    );
+                }
+            }
+        }
+        work_state
+    }
 }
 
 #[cfg(test)]

From 4c24f7882f904c803c9c54a257beb5b14ffbb962 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Sat, 10 Feb 2024 23:08:10 -0500
Subject: [PATCH 0736/1166] chore: finish nakamoto inventory state machine and
 its hook-up with the overall network work state machine

---
 stackslib/src/net/inv/nakamoto.rs | 472 ++++++++++++++++++++++--------
 1 file changed, 353 insertions(+), 119 deletions(-)

diff --git a/stackslib/src/net/inv/nakamoto.rs b/stackslib/src/net/inv/nakamoto.rs
index b8cc41cf14..292ecb7b24 100644
--- a/stackslib/src/net/inv/nakamoto.rs
+++ b/stackslib/src/net/inv/nakamoto.rs
@@ -14,22 +14,23 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::collections::HashMap;
-use std::collections::BTreeMap;
+use std::collections::{BTreeMap, HashMap};
+
+use stacks_common::util::get_epoch_time_secs;
 
 use crate::burnchains::PoxConstants;
 use crate::chainstate::burn::db::sortdb::SortitionDB;
 use crate::chainstate::burn::{BlockSnapshot, ConsensusHash};
 use crate::chainstate::nakamoto::NakamotoChainState;
 use crate::chainstate::stacks::db::StacksChainState;
-use crate::net::{Error as NetError, NakamotoInvData};
-use crate::net::NeighborComms;
+use crate::net::db::PeerDB;
+use crate::net::neighbors::comms::PeerNetworkComms;
+use crate::net::p2p::PeerNetwork;
+use crate::net::{
+    Error as NetError, GetNakamotoInvData, NakamotoInvData, NeighborAddress, NeighborComms,
+    NeighborKey, StacksMessage, StacksMessageType,
+};
 use crate::util_lib::db::Error as DBError;
-use crate::net::StacksMessageType;
-use crate::net::GetNakamotoInvData;
-use crate::net::NakamotoInvData;
-
-use stacks_common::util::get_epoch_time_secs();
 
 /// Cached data for a sortition in the sortition DB.
 /// Caching this allows us to avoid calls to `SortitionDB::get_block_snapshot_consensus()`.
@@ -244,6 +245,8 @@ impl InvGenerator {
 
 #[derive(Debug, PartialEq, Clone)]
 pub struct NakamotoTenureInv {
+    /// What state is the machine in?
+    pub state: NakamotoInvState,
     /// Bitmap of which tenures a peer has.
     /// Maps reward cycle to bitmap.
     pub tenures_inv: BTreeMap<u64, Vec<u8>>,
@@ -255,6 +258,8 @@ pub struct NakamotoTenureInv {
     pub first_block_height: u64,
     /// Length of reward cycle
     pub reward_cycle_len: u64,
+    /// Which neighbor is this for
+    pub neighbor_address: NeighborAddress,
 
     /// The fields below are used for synchronizing this particular peer's inventories.
     /// Currently tracked reward cycle
@@ -267,13 +272,19 @@ pub struct NakamotoTenureInv {
 }
 
 impl NakamotoTenureInv {
-    pub fn new(first_block_height: u64, reward_cycle_len: u64) -> Self {
+    pub fn new(
+        first_block_height: u64,
+        reward_cycle_len: u64,
+        neighbor_address: NeighborAddress,
+    ) -> Self {
         Self {
-            tenures_inv: vec![],
+            state: NakamotoInvState::GetNakamotoInvBegin,
+            tenures_inv: BTreeMap::new(),
             highest_sortition: 0,
             last_updated_at: 0,
             first_block_height,
             reward_cycle_len,
+            neighbor_address,
             cur_reward_cycle: 0,
             online: true,
             start_sync_time: 0,
@@ -287,19 +298,23 @@ impl NakamotoTenureInv {
             return false;
         }
 
-        let Some(reward_cycle) = PoxConstants::static_block_height_to_reward_cycle(burn_block_height, self.first_block_height, self.reward_cycle_len) else {
+        let Some(reward_cycle) = PoxConstants::static_block_height_to_reward_cycle(
+            burn_block_height,
+            self.first_block_height,
+            self.reward_cycle_len,
+        ) else {
             return false;
         };
 
-        let rc_idx = usize::try_from(reward_cycle).expect("FATAL: reward cycle exceeds usize");
-        let Some(rc_tenures) = self.tenures_inv.get(rc_idx) else {
+        let Some(rc_tenures) = self.tenures_inv.get(&reward_cycle) else {
             return false;
         };
 
         let sortition_height = burn_block_height - self.first_block_height;
         let rc_height = sortition_height % self.reward_cycle_len;
 
-        let idx = usize::try_from(rc_height / 8).expect("FATAL: reward cycle length exceeds host usize");
+        let idx =
+            usize::try_from(rc_height / 8).expect("FATAL: reward cycle length exceeds host usize");
         let bit = rc_height % 8;
 
         rc_tenures
@@ -309,7 +324,7 @@ impl NakamotoTenureInv {
     }
 
     /// How many reward cycles of data do we have for this peer?
-    pub fn num_reward_cycles(&self) -> u64 {
+    pub fn highest_reward_cycle(&self) -> u64 {
         let Some((highest_rc, _)) = self.tenures_inv.last_key_value() else {
             return 0;
         };
@@ -318,13 +333,26 @@ impl NakamotoTenureInv {
 
     /// Add in a newly-discovered inventory.
     /// NOTE: inventories are supposed to be aligned to the reward cycle
-    pub fn merge_tenure_inv(&mut self, tenure_inv: Vec<u8>, tenure_bitlen: u16, reward_cycle: u64) {
+    /// Returns true if we learned about at least one new tenure-start block
+    /// Returns false if not.
+    pub fn merge_tenure_inv(
+        &mut self,
+        tenure_inv: Vec<u8>,
+        tenure_bitlen: u16,
+        reward_cycle: u64,
+    ) -> bool {
         // populate the tenures bitmap to we can fit this tenures inv
-        let rc_idx = usize::try_from(reward_cycle).expect("FATAL: reward_cycle exceeds usize");
-
-        self.highest_sortition = self.num_reward_cycles() * self.reward_cycle_len + u64::from(tenure_bitlen);
-        self.tenures_inv[rc_idx] = tenure_inv;
+        self.highest_sortition =
+            self.highest_reward_cycle() * self.reward_cycle_len + u64::from(tenure_bitlen);
+        let learned = if let Some(cur_inv) = self.tenures_inv.get(&reward_cycle) {
+            cur_inv != &tenure_inv
+        } else {
+            // this inv is new
+            true
+        };
+        self.tenures_inv.insert(reward_cycle, tenure_inv);
         self.last_updated_at = get_epoch_time_secs();
+        learned
     }
 
     /// Adjust the next reward cycle to query.
@@ -337,9 +365,10 @@ impl NakamotoTenureInv {
 
     /// Reset synchronization state for this peer.  Don't remove inventory data; just make it so we
     /// can talk to the peer again
-    pub fn try_reset_comms(&mut self, inv_sync_interval: u64, start_rc: u64) {
+    pub fn try_reset_comms(&mut self, inv_sync_interval: u64, start_rc: u64, cur_rc: u64) {
         let now = get_epoch_time_secs();
-        if self.start_sync_time + inv_sync_interval <= now {
+        if self.start_sync_time + inv_sync_interval <= now && self.cur_reward_cycle > cur_rc {
+            self.state = NakamotoInvState::GetNakamotoInvBegin;
             self.online = true;
             self.start_sync_time = now;
             self.cur_reward_cycle = start_rc;
@@ -360,84 +389,178 @@ impl NakamotoTenureInv {
     pub fn set_online(&mut self, online: bool) {
         self.online = online;
     }
+
+    /// Proceed to ask this neighbor for its nakamoto tenure inventories.
+    /// Returns Ok(true) if we should proceed to ask for inventories
+    /// Returns Ok(false) if not
+    /// Returns Err(..) on I/O errors
+    pub fn getnakamotoinv_begin(
+        &mut self,
+        network: &mut PeerNetwork,
+        current_reward_cycle: u64,
+    ) -> bool {
+        debug!(
+            "{:?}: Begin Nakamoto inventory sync for {}",
+            network.get_local_peer(),
+            self.neighbor_address
+        );
+
+        // possibly reset communications with this peer, if it's time to do so.
+        self.try_reset_comms(
+            network.get_connection_opts().inv_sync_interval,
+            current_reward_cycle.saturating_sub(network.get_connection_opts().inv_reward_cycles),
+            current_reward_cycle,
+        );
+        if !self.is_online() {
+            // don't talk to this peer for now
+            debug!(
+                "{:?}: not online: {}",
+                network.get_local_peer(),
+                &self.neighbor_address
+            );
+            return false;
+        }
+
+        if self.reward_cycle() > current_reward_cycle {
+            // we've fully sync'ed with this peer
+            debug!(
+                "{:?}: fully sync'ed: {}",
+                network.get_local_peer(),
+                &self.neighbor_address
+            );
+            return false;
+        }
+
+        // ask this neighbor for its inventory
+        true
+    }
+
+    /// Finish asking for inventories, and update inventory state.
+    /// Return Ok(true) if we learned something new
+    /// Return Ok(false) if not.
+    /// Return Err(..) on I/O errors
+    pub fn getnakamotoinv_try_finish(
+        &mut self,
+        network: &mut PeerNetwork,
+        reply: StacksMessage,
+    ) -> Result<bool, NetError> {
+        match reply.payload {
+            StacksMessageType::NakamotoInv(inv_data) => {
+                debug!(
+                    "{:?}: got NakamotoInv: {:?}",
+                    network.get_local_peer(),
+                    &inv_data
+                );
+                let ret =
+                    self.merge_tenure_inv(inv_data.tenures, inv_data.bitlen, self.reward_cycle());
+                self.next_reward_cycle();
+                return Ok(ret);
+            }
+            StacksMessageType::Nack(nack_data) => {
+                info!("{:?}: remote peer NACKed our GetNakamotoInv", network.get_local_peer();
+                      "error_code" => nack_data.error_code);
+                self.set_online(false);
+                return Ok(false);
+            }
+            _ => {
+                info!(
+                    "{:?}: got unexpected message from {:?}: {:?}",
+                    network.get_local_peer(),
+                    &self.neighbor_address,
+                    &reply
+                );
+                self.set_online(false);
+                return Err(NetError::ConnectionBroken);
+            }
+        }
+    }
 }
 
 #[derive(Debug, PartialEq, Clone, Copy)]
 pub enum NakamotoInvState {
     GetNakamotoInvBegin,
     GetNakamotoInvFinish,
-    Done
+    Done,
 }
 
 /// Nakamoto inventory state machine
 pub struct NakamotoInvStateMachine<NC: NeighborComms> {
-    /// What state is the machine in?
-    pub(crate) state: NakamotoInvState,
-    /// Communications links 
+    /// Communications links
     pub(crate) comms: NC,
     /// Nakamoto inventories we have
-    inventories: HashMap<NeighborAddress, NakamotoTenureInv>,
+    pub(crate) inventories: HashMap<NeighborAddress, NakamotoTenureInv>,
     /// Reward cycle consensus hashes
     reward_cycle_consensus_hashes: BTreeMap<u64, ConsensusHash>,
-    /// What reward cycle are we in?
-    cur_reward_cycle: u64,
 }
 
 impl<NC: NeighborComms> NakamotoInvStateMachine<NC> {
     pub fn new(comms: NC) -> Self {
         Self {
-            state: NakamotoInvstate::GetNakamotoInvBegin,
-            comms: NC,
+            comms,
             inventories: HashMap::new(),
             reward_cycle_consensus_hashes: BTreeMap::new(),
-            cur_reward_cycle: 0,
         }
     }
 
     pub fn reset(&mut self) {
         self.comms.reset();
-        self.inventories.clear();
-        self.state = NakamotoInvState::GetNakamotoInvBegin;
+    }
+
+    /// Remove state for a particular neighbor
+    pub fn del_peer(&mut self, peer: &NeighborAddress) {
+        self.inventories.remove(peer);
+    }
+
+    /// Highest reward cycle learned
+    pub fn highest_reward_cycle(&self) -> u64 {
+        let mut highest_rc = 0;
+        for (_, inv) in self.inventories.iter() {
+            highest_rc = inv.highest_reward_cycle().max(highest_rc);
+        }
+        highest_rc
     }
 
     /// Get the consensus hash for the first sortition in the given reward cycle
-    fn load_consensus_hash_for_reward_cycle(sortdb: &SortitionDB, reward_cycle: u64) -> Result<Option<ConsensusHash>, NetError> {
-        let consensus_hash = {
-            let reward_cycle_start_height = sortdb
-                .pox_constants
-                .reward_cycle_to_block_height(sortdb.first_block_height, reward_cycle);
-            let sn = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn())?;
-            let ih = sortdb.index_handle(sn.sortition_id);
-            let Some(rc_start_sn) = ih
-                .get_block_snapshot_by_height(reward_cycle_start_height)?
-            else {
-                return None;
-            };
-            rc_start_sn.consensus_hash
+    fn load_consensus_hash_for_reward_cycle(
+        sortdb: &SortitionDB,
+        reward_cycle: u64,
+    ) -> Result<Option<ConsensusHash>, NetError> {
+        let reward_cycle_start_height = sortdb
+            .pox_constants
+            .reward_cycle_to_block_height(sortdb.first_block_height, reward_cycle);
+        let sn = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn())?;
+        let ih = sortdb.index_handle(&sn.sortition_id);
+        let Some(rc_start_sn) = ih.get_block_snapshot_by_height(reward_cycle_start_height)? else {
+            return Ok(None);
         };
-        Ok(Some(consensus_hash))
+        Ok(Some(rc_start_sn.consensus_hash))
     }
 
     /// Populate the reward_cycle_consensus_hash mapping.  Idempotent.
     /// Returns the current reward cycle.
-    fn update_reward_cycle_consensus_hashes(&mut self, sortdb: &SortitionDB) -> Result<u64, NetError> {
-        let highest_rc = if let Some((highest_rc, _)) = self.reward_cycle_consensus_hashes.last_key_value() {
-            *highest_rc
-        }
-        else {
-            0
-        };
+    fn update_reward_cycle_consensus_hashes(
+        &mut self,
+        sortdb: &SortitionDB,
+    ) -> Result<u64, NetError> {
+        let highest_rc =
+            if let Some((highest_rc, _)) = self.reward_cycle_consensus_hashes.last_key_value() {
+                *highest_rc
+            } else {
+                0
+            };
 
         let sn = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn())?;
         let tip_rc = sortdb
             .pox_constants
-            .reward_cycle_to_block_height(sortdb.first_block_height, sn.block_height);
+            .block_height_to_reward_cycle(sortdb.first_block_height, sn.block_height)
+            .expect("FATAL: snapshot occurred before system start");
 
         for rc in highest_rc..=tip_rc {
-            if self.reward_cycle_consnsus_hashes.contains_key(&rc) {
+            if self.reward_cycle_consensus_hashes.contains_key(&rc) {
                 continue;
             }
             let Some(ch) = Self::load_consensus_hash_for_reward_cycle(sortdb, rc)? else {
+                // NOTE: this should be unreachable, but don't panic
                 continue;
             };
             self.reward_cycle_consensus_hashes.insert(rc, ch);
@@ -451,35 +574,42 @@ impl<NC: NeighborComms> NakamotoInvStateMachine<NC> {
             return None;
         };
         Some(StacksMessageType::GetNakamotoInv(GetNakamotoInvData {
-            consensus_hash: ch.clone()
+            consensus_hash: ch.clone(),
         }))
     }
 
     /// Proceed to ask neighbors for their nakamoto tenure inventories.
     /// If we're in initial block download (ibd), then only ask our bootstrap peers.
     /// Otherwise, ask everyone.
-    /// Returns Ok(true) if we completed this step of the state machine
-    /// Returns Ok(false) if not (currently this never happens)
     /// Returns Err(..) on I/O errors
-    pub fn getnakamotoinv_begin(&mut self, network: &mut PeerNetwork, sortdb: &SortitionDB, ibd: bool) -> Result<bool, NetError> {
+    pub fn process_getnakamotoinv_begins(
+        &mut self,
+        network: &mut PeerNetwork,
+        sortdb: &SortitionDB,
+        ibd: bool,
+    ) -> Result<(), NetError> {
         // make sure we know all consensus hashes for all reward cycles.
         let current_reward_cycle = self.update_reward_cycle_consensus_hashes(sortdb)?;
-        self.cur_reward_cycle = current_reward_cycle;
 
         // we're updating inventories, so preserve the state we have
-        let mut new_inventories = BTreeMap::new();
-        for event_id in network.peer_iter_event_ids() {
-            let Some(convo) = network.get_p2p_convo(*event_id) else {
+        let mut new_inventories = HashMap::new();
+        let event_ids: Vec<usize> = network.iter_peer_event_ids().map(|e_id| *e_id).collect();
+        for event_id in event_ids.into_iter() {
+            let Some(convo) = network.get_p2p_convo(event_id) else {
                 continue;
             };
+            if !convo.is_outbound() || !convo.is_authenticated() {
+                continue;
+            }
             if ibd {
                 // in IBD, only connect to initial peers
                 let is_initial = PeerDB::is_initial_peer(
                     &network.peerdb_conn(),
                     convo.peer_network_id,
                     &convo.peer_addrbytes,
-                    convo.peer_port
-                ).unwrap_or(false);
+                    convo.peer_port,
+                )
+                .unwrap_or(false);
                 if !is_initial {
                     continue;
                 }
@@ -487,90 +617,194 @@ impl<NC: NeighborComms> NakamotoInvStateMachine<NC> {
 
             let naddr = convo.to_neighbor_address();
 
-            let mut inv = self.inventories
-                .get(&naddr)
-                .clone()
+            // NOTE: this naturally garabage-collects inventories for disconnected nodes, as
+            // desired
+            let mut inv = self
+                .inventories
+                .remove(&naddr)
                 .unwrap_or(NakamotoTenureInv::new(
                     network.get_burnchain().first_block_height,
-                    network.get_burnchain().pox_constants.reward_cycle_len,
+                    network
+                        .get_burnchain()
+                        .pox_constants
+                        .reward_cycle_length
+                        .into(),
+                    naddr.clone(),
                 ));
 
-            // possibly reset communications with this peer, if it's time to do so.
-            inv.try_reset_comms(network.get_connection_opts().inv_sync_interval, current_reward_cycle.saturating_sub(network.get_connection_opts().inv_reward_cycles));
-            if !inv.is_online() {
-                // don't talk to this peer
+            let proceed = inv.getnakamotoinv_begin(network, current_reward_cycle);
+            let inv_rc = inv.reward_cycle();
+            new_inventories.insert(naddr.clone(), inv);
+
+            if self.comms.has_inflight(&naddr) {
                 continue;
             }
 
-            if inv.reward_cycle() > current_reward_cycle {
-                // we've fully sync'ed with this peer
+            if !proceed {
                 continue;
             }
 
+            debug!(
+                "{:?}: send GetNakamotoInv for reward cycle {} to {}",
+                network.get_local_peer(),
+                inv_rc,
+                &naddr
+            );
+
             // ask this neighbor for its inventory
-            if let Some(getnakamotoinv) = self.make_getnakamotoinv(inv.reward_cycle()) {
+            if let Some(getnakamotoinv) = self.make_getnakamotoinv(inv_rc) {
                 if let Err(e) = self.comms.neighbor_send(network, &naddr, getnakamotoinv) {
                     warn!("{:?}: failed to send GetNakamotoInv", network.get_local_peer();
-                          "message" => ?getnakamotoinv,
                           "peer" => ?naddr,
                           "error" => ?e
                     );
                 }
-                else {
-                    // keep this connection open
-                    self.comms.pin_connection(*event_id);
-                }
             }
-
-            new_inventories.insert(naddr, inv);
         }
 
         self.inventories = new_inventories;
-        Ok(true);
+        Ok(())
     }
 
     /// Finish asking for inventories, and update inventory state.
-    pub fn getnakamotoinv_try_finish(&mut self, network: &mut PeerNetwork) -> Result<bool, NetError> {
-        let mut inv_replies = vec![];
-        let mut nack_replies = vec![];
-        for (naddr, reply) in self.comms.collect_replies(network) {
-            match reply {
-                StacksMessageType::NakamotoInv(inv_data) => {
-                    inv_replies.push((naddr, inv_data));
-                }
-                StacksMessageType::Nack(nack_data) => {
-                    nack_replies.push((naddr, nack_data));
-                }
-            }
-        }
-
-        // process NACKs
-        for (naddr, nack_data) in nack_replies.into_iter() {
-            info!("{:?}: remote peer NACKed our GetNakamotoInv", network.get_local_peer();
-                  "error_code" => nack_data.error_code);
-
+    /// Returns Ok(num-messages, true) if an inv state machine learned something.
+    /// Returns Ok(num-messages, false) if not
+    /// Returns Err(..) on I/O errors
+    pub fn process_getnakamotoinv_finishes(
+        &mut self,
+        network: &mut PeerNetwork,
+    ) -> Result<(usize, bool), NetError> {
+        let mut learned = false;
+        let replies = self.comms.collect_replies(network);
+        let num_msgs = replies.len();
+
+        for (naddr, reply) in replies.into_iter() {
+            test_debug!(
+                "{:?}: got reply from {}: {:?}",
+                network.get_local_peer(),
+                &naddr,
+                &reply
+            );
             let Some(inv) = self.inventories.get_mut(&naddr) else {
+                debug!(
+                    "{:?}: Got a reply for an untracked inventory peer {}: {:?}",
+                    network.get_local_peer(),
+                    &naddr,
+                    &reply
+                );
                 continue;
             };
 
-            // stop talking to this peer
-            inv.set_online(false);
-        }
-
-        // process NakamotoInvs
-        for (naddr, inv_data) in inv_replies.into_iter() {
-            let Some(inv) = self.inventories.get_mut(&naddr) else {
-                info!("{:?}: Drop unsolicited NakamotoInv from {:?}", &network.get_local_peer(), &naddr);
+            let Ok(inv_learned) = inv.getnakamotoinv_try_finish(network, reply).map_err(|e| {
+                warn!(
+                    "{:?}: Failed to finish inventory sync to {}: {:?}",
+                    network.get_local_peer(),
+                    &naddr,
+                    &e
+                );
+                self.comms.add_broken(network, &naddr);
+                e
+            }) else {
                 continue;
             };
-            inv.merge_tenure_inv(&inv_data.tenures, inv_data.bitlen, inv.reward_cycle());
-            inv.next_reward_cycle();
+
+            learned = learned || inv_learned;
         }
 
-        Ok(self.comms.count_inflight() == 0)
+        Ok((num_msgs, learned))
     }
 
-    pub fn run(&mut self, network: &mut PeerNetwork) -> bool {
-        false
+    pub fn run(&mut self, network: &mut PeerNetwork, sortdb: &SortitionDB, ibd: bool) -> bool {
+        if let Err(e) = self.process_getnakamotoinv_begins(network, sortdb, ibd) {
+            warn!(
+                "{:?}: Failed to begin Nakamoto tenure inventory sync: {:?}",
+                network.get_local_peer(),
+                &e
+            );
+        }
+        let Ok((_, learned)) = self.process_getnakamotoinv_finishes(network).map_err(|e| {
+            warn!(
+                "{:?}: Failed to finish Nakamoto tenure inventory sync: {:?}",
+                network.get_local_peer(),
+                &e
+            );
+            e
+        }) else {
+            return false;
+        };
+        learned
+    }
+}
+
+impl PeerNetwork {
+    /// Initialize inv state for nakamoto
+    pub fn init_inv_sync_nakamoto(&mut self) {
+        // find out who we'll be synchronizing with for the duration of this inv sync
+        debug!(
+            "{:?}: Initializing peer block inventory state for Nakamoto",
+            &self.local_peer,
+        );
+        self.inv_state_nakamoto = Some(NakamotoInvStateMachine::new(PeerNetworkComms::new()));
+    }
+
+    /// Drive Nakamoto inventory state machine
+    /// returns (learned-new-data?, did-full-pass?, peers-to-disconnect, peers-that-are-dead)
+    pub fn sync_inventories_nakamoto(
+        &mut self,
+        sortdb: &SortitionDB,
+        ibd: bool,
+    ) -> (bool, Vec<NeighborKey>, Vec<NeighborKey>) {
+        if self.inv_state_nakamoto.is_none() {
+            self.init_inv_sync_nakamoto();
+        }
+        let Some(mut nakamoto_inv) = self.inv_state_nakamoto.take() else {
+            return (false, vec![], vec![]);
+        };
+
+        let learned = nakamoto_inv.run(self, sortdb, ibd);
+        let dead = nakamoto_inv.comms.take_dead_neighbors();
+        let broken = nakamoto_inv.comms.take_broken_neighbors();
+
+        self.inv_state_nakamoto = Some(nakamoto_inv);
+
+        (
+            learned,
+            dead.into_iter().collect(),
+            broken.into_iter().collect(),
+        )
+    }
+
+    /// Update the state of our neighbors' Nakamoto tenure inventories
+    /// Return whether or not we learned something
+    pub fn do_network_inv_sync_nakamoto(&mut self, sortdb: &SortitionDB, ibd: bool) -> bool {
+        if cfg!(test) && self.connection_opts.disable_inv_sync {
+            test_debug!("{:?}: inv sync is disabled", &self.local_peer);
+            return false;
+        }
+
+        debug!(
+            "{:?}: network inventory sync for Nakamoto",
+            &self.local_peer
+        );
+
+        if self.inv_state_nakamoto.is_none() {
+            self.init_inv_sync_nakamoto();
+        }
+
+        // synchronize peer block inventories
+        let (learned, dead_neighbors, broken_neighbors) =
+            self.sync_inventories_nakamoto(sortdb, ibd);
+
+        // disconnect and ban broken peers
+        for broken in broken_neighbors.into_iter() {
+            self.deregister_and_ban_neighbor(&broken);
+        }
+
+        // disconnect from dead connections
+        for dead in dead_neighbors.into_iter() {
+            self.deregister_neighbor(&dead);
+        }
+
+        learned
     }
 }

From 86a6a5be030f1916133bb16c36e56fd648dbd867 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Sat, 10 Feb 2024 23:08:39 -0500
Subject: [PATCH 0737/1166] feat: add nakamoto-specific network work state
 machine, and preserve the epoch 2.x behavior for when we're processing 2.x
 state.  If we're in the Nakamoto epoch but Nakamoto hasn't activated, then
 run both state machines

---
 stackslib/src/net/p2p.rs | 415 +++++++++++++++++++--------------------
 1 file changed, 201 insertions(+), 214 deletions(-)

diff --git a/stackslib/src/net/p2p.rs b/stackslib/src/net/p2p.rs
index fe2102ffe2..16b5543d84 100644
--- a/stackslib/src/net/p2p.rs
+++ b/stackslib/src/net/p2p.rs
@@ -32,6 +32,7 @@ use rand::thread_rng;
 use stacks_common::consts::{FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH};
 use stacks_common::types::chainstate::{PoxId, SortitionId};
 use stacks_common::types::net::{PeerAddress, PeerHost};
+use stacks_common::types::StacksEpochId;
 use stacks_common::util::hash::to_hex;
 use stacks_common::util::secp256k1::Secp256k1PublicKey;
 use stacks_common::util::{get_epoch_time_ms, get_epoch_time_secs, log};
@@ -59,7 +60,7 @@ use crate::net::download::BlockDownloader;
 use crate::net::http::HttpRequestContents;
 use crate::net::httpcore::StacksHttpRequest;
 use crate::net::inv::inv2x::*;
-use crate::net::inv::nakamoto::InvGenerator;
+use crate::net::inv::nakamoto::{InvGenerator, NakamotoInvStateMachine};
 use crate::net::neighbors::*;
 use crate::net::poll::{NetworkPollState, NetworkState};
 use crate::net::prune::*;
@@ -260,6 +261,7 @@ pub struct PeerNetwork {
 
     // work state -- we can be walking, fetching block inventories, fetching blocks, pruning, etc.
     pub work_state: PeerNetworkWorkState,
+    pub nakamoto_work_state: PeerNetworkWorkState,
     have_data_to_download: bool,
 
     // neighbor walk state
@@ -273,8 +275,10 @@ pub struct PeerNetwork {
     pub walk_pingbacks: HashMap<NeighborAddress, NeighborPingback>, // inbound peers for us to try to ping back and add to our frontier, mapped to (peer_version, network_id, timeout, pubkey)
     pub walk_result: NeighborWalkResult, // last successful neighbor walk result
 
-    // peer block inventory state
+    /// Epoch 2.x inventory state
     pub inv_state: Option<InvState>,
+    /// Epoch 3.x inventory state
+    pub inv_state_nakamoto: Option<NakamotoInvStateMachine<PeerNetworkComms>>,
 
     // cached view of PoX database
     // (maintained by the inv state machine)
@@ -443,6 +447,7 @@ impl PeerNetwork {
             connection_opts: connection_opts,
 
             work_state: PeerNetworkWorkState::GetPublicIP,
+            nakamoto_work_state: PeerNetworkWorkState::GetPublicIP,
             have_data_to_download: false,
 
             walk: None,
@@ -456,6 +461,7 @@ impl PeerNetwork {
             walk_result: NeighborWalkResult::new(),
 
             inv_state: None,
+            inv_state_nakamoto: None,
             pox_id: PoxId::initial(),
             tip_sort_id: SortitionId([0x00; 32]),
             header_cache: BlockHeaderCache::new(),
@@ -539,7 +545,11 @@ impl PeerNetwork {
                 "BUG: block {} is not in a known epoch",
                 &self.chain_view.burn_block_height
             ));
-        let epoch = self.epochs[epoch_index].clone();
+        let epoch = self
+            .epochs
+            .get(epoch_index)
+            .expect("BUG: no epoch at found index")
+            .clone();
         epoch
     }
 
@@ -1729,27 +1739,36 @@ impl PeerNetwork {
     pub fn deregister_peer(&mut self, event_id: usize) -> () {
         debug!("{:?}: Disconnect event {}", &self.local_peer, event_id);
 
-        let mut nk_remove: Vec<NeighborKey> = vec![];
+        let mut nk_remove: Vec<(NeighborKey, Hash160)> = vec![];
         for (neighbor_key, ev_id) in self.events.iter() {
             if *ev_id == event_id {
-                nk_remove.push(neighbor_key.clone());
+                let pubkh = if let Some(convo) = self.get_p2p_convo(event_id) {
+                    convo.get_public_key_hash().unwrap_or(Hash160([0x00; 20]))
+                } else {
+                    Hash160([0x00; 20])
+                };
+                nk_remove.push((neighbor_key.clone(), pubkh));
             }
         }
 
-        for nk in nk_remove.into_iter() {
+        for (nk, pubkh) in nk_remove.into_iter() {
             // remove event state
             self.events.remove(&nk);
 
             // remove inventory state
-            match self.inv_state {
-                Some(ref mut inv_state) => {
-                    debug!(
-                        "{:?}: Remove inventory state for {:?}",
-                        &self.local_peer, &nk
-                    );
-                    inv_state.del_peer(&nk);
-                }
-                None => {}
+            if let Some(inv_state) = self.inv_state.as_mut() {
+                debug!(
+                    "{:?}: Remove inventory state for epoch 2.x {:?}",
+                    &self.local_peer, &nk
+                );
+                inv_state.del_peer(&nk);
+            }
+            if let Some(inv_state) = self.inv_state_nakamoto.as_mut() {
+                debug!(
+                    "{:?}: Remove inventory state for epoch 2.x {:?}",
+                    &self.local_peer, &nk
+                );
+                inv_state.del_peer(&NeighborAddress::from_neighbor_key(nk, pubkh));
             }
         }
 
@@ -2756,37 +2775,6 @@ impl PeerNetwork {
         true
     }
 
-    /// Update the state of our neighbors' block inventories.
-    /// Return true if we finish
-    fn do_network_inv_sync(&mut self, sortdb: &SortitionDB, ibd: bool) -> (bool, bool) {
-        if cfg!(test) && self.connection_opts.disable_inv_sync {
-            test_debug!("{:?}: inv sync is disabled", &self.local_peer);
-            return (true, false);
-        }
-
-        debug!("{:?}: network inventory sync", &self.local_peer);
-
-        if self.inv_state.is_none() {
-            self.init_inv_sync(sortdb);
-        }
-
-        // synchronize peer block inventories
-        let (done, throttled, broken_neighbors, dead_neighbors) =
-            self.sync_inventories(sortdb, ibd);
-
-        // disconnect and ban broken peers
-        for broken in broken_neighbors.into_iter() {
-            self.deregister_and_ban_neighbor(&broken);
-        }
-
-        // disconnect from dead connections
-        for dead in dead_neighbors.into_iter() {
-            self.deregister_neighbor(&dead);
-        }
-
-        (done, throttled)
-    }
-
     /// Download blocks, and add them to our network result.
     fn do_network_block_download(
         &mut self,
@@ -3073,7 +3061,9 @@ impl PeerNetwork {
     /// Push any blocks and microblock streams that we're holding onto out to our neighbors.
     /// Start with the most-recently-arrived data, since this node is likely to have already
     /// fetched older data via the block-downloader.
-    fn try_push_local_data(&mut self, sortdb: &SortitionDB, chainstate: &StacksChainState) {
+    ///
+    /// Only applicable to epoch 2.x state.
+    fn try_push_local_data_epoch2x(&mut self, sortdb: &SortitionDB, chainstate: &StacksChainState) {
         if self.antientropy_last_push_ts + self.connection_opts.antientropy_retry
             >= get_epoch_time_secs()
         {
@@ -3864,6 +3854,7 @@ impl PeerNetwork {
 
     /// Do the actual work in the state machine.
     /// Return true if we need to prune connections.
+    /// This will call the epoch-appropriate network worker
     fn do_network_work(
         &mut self,
         sortdb: &SortitionDB,
@@ -3872,6 +3863,145 @@ impl PeerNetwork {
         download_backpressure: bool,
         ibd: bool,
         network_result: &mut NetworkResult,
+    ) -> bool {
+        let cur_epoch = self.get_current_epoch();
+        let prune = if cur_epoch.epoch_id >= StacksEpochId::Epoch30 {
+            debug!("{:?}: run Nakamoto work loop", self.get_local_peer());
+
+            // in Nakamoto epoch, so do Nakamoto things
+            let prune = self.do_network_work_nakamoto(sortdb, ibd);
+
+            // in Nakamoto epoch, but we might still be doing epoch 2.x things since Nakamoto does
+            // not begin on a reawrd cycle boundary.
+            if self.burnchain_tip.block_height <= cur_epoch.start_height
+                || self.connection_opts.force_nakamoto_epoch_transition
+            {
+                debug!(
+                    "{:?}: run Epoch 2.x work loop in Nakamoto epoch",
+                    self.get_local_peer()
+                );
+                let epoch2_prune = self.do_network_work_epoch2x(
+                    sortdb,
+                    chainstate,
+                    dns_client_opt,
+                    download_backpressure,
+                    ibd,
+                    network_result,
+                );
+                debug!(
+                    "{:?}: ran Epoch 2.x work loop in Nakamoto epoch",
+                    self.get_local_peer()
+                );
+                prune || epoch2_prune
+            } else {
+                prune
+            }
+        } else {
+            // in epoch 2.x, so do epoch 2.x things
+            debug!("{:?}: run Epoch 2.x work loop", self.get_local_peer());
+            self.do_network_work_epoch2x(
+                sortdb,
+                chainstate,
+                dns_client_opt,
+                download_backpressure,
+                ibd,
+                network_result,
+            )
+        };
+        prune
+    }
+
+    /// Do the actual work in the state machine.
+    /// Return true if we need to prune connections.
+    /// Used only for nakamoto.
+    /// TODO: put this into a separate file for nakamoto p2p code paths
+    fn do_network_work_nakamoto(&mut self, sortdb: &SortitionDB, ibd: bool) -> bool {
+        // do some Actual Work(tm)
+        let mut do_prune = false;
+        let mut did_cycle = false;
+
+        while !did_cycle {
+            // always do an inv sync
+            let learned = self.do_network_inv_sync_nakamoto(sortdb, ibd);
+            if learned {
+                debug!("{:?}: learned about new blocks!", self.get_local_peer());
+            }
+
+            debug!(
+                "{:?}: network work state is {:?}",
+                self.get_local_peer(),
+                &self.nakamoto_work_state
+            );
+            let cur_state = self.nakamoto_work_state;
+            match self.nakamoto_work_state {
+                PeerNetworkWorkState::GetPublicIP => {
+                    if cfg!(test) && self.connection_opts.disable_natpunch {
+                        self.nakamoto_work_state = PeerNetworkWorkState::BlockDownload;
+                    } else {
+                        // (re)determine our public IP address
+                        let done = self.do_get_public_ip();
+                        if done {
+                            self.nakamoto_work_state = PeerNetworkWorkState::BlockDownload;
+                        }
+                    }
+                }
+                PeerNetworkWorkState::BlockInvSync => {
+                    // this state is useless in Nakamoto since we're always doing inv-syncs
+                    self.nakamoto_work_state = PeerNetworkWorkState::BlockDownload;
+                }
+                PeerNetworkWorkState::BlockDownload => {
+                    info!(
+                        "{:?}: Block download for Nakamoto is not yet implemented",
+                        self.get_local_peer()
+                    );
+                    self.nakamoto_work_state = PeerNetworkWorkState::AntiEntropy;
+                }
+                PeerNetworkWorkState::AntiEntropy => {
+                    info!(
+                        "{:?}: Block anti-entropy for Nakamoto is not yet implemented",
+                        self.get_local_peer()
+                    );
+                    self.nakamoto_work_state = PeerNetworkWorkState::Prune;
+                }
+                PeerNetworkWorkState::Prune => {
+                    // did one pass
+                    did_cycle = true;
+                    do_prune = true;
+
+                    // restart
+                    self.nakamoto_work_state = PeerNetworkWorkState::GetPublicIP;
+                }
+            }
+
+            if self.nakamoto_work_state == cur_state {
+                // only break early if we can't make progress
+                break;
+            }
+        }
+
+        if did_cycle {
+            self.num_state_machine_passes += 1;
+            debug!(
+                "{:?}: Finished full p2p state-machine pass for Nakamoto ({})",
+                &self.local_peer, self.num_state_machine_passes
+            );
+        }
+
+        do_prune
+    }
+
+    /// Do the actual work in the state machine.
+    /// Return true if we need to prune connections.
+    /// This is only used in epoch 2.x.
+    /// TODO: put into a separate file specific to epoch 2.x p2p code paths
+    fn do_network_work_epoch2x(
+        &mut self,
+        sortdb: &SortitionDB,
+        chainstate: &mut StacksChainState,
+        dns_client_opt: &mut Option<&mut DNSClient>,
+        download_backpressure: bool,
+        ibd: bool,
+        network_result: &mut NetworkResult,
     ) -> bool {
         // do some Actual Work(tm)
         let mut do_prune = false;
@@ -3905,168 +4035,8 @@ impl PeerNetwork {
                     }
                 }
                 PeerNetworkWorkState::BlockInvSync => {
-                    // synchronize peer block inventories
-                    let (inv_done, inv_throttled) = self.do_network_inv_sync(sortdb, ibd);
-                    if inv_done {
-                        if !download_backpressure {
-                            // proceed to get blocks, if we're not backpressured
-                            self.work_state = PeerNetworkWorkState::BlockDownload;
-                        } else {
-                            // skip downloads for now
-                            self.work_state = PeerNetworkWorkState::Prune;
-                        }
-
-                        if !inv_throttled {
-                            // only count an inv_sync as passing if there's an always-allowed node
-                            // in our inv state
-                            let always_allowed: HashSet<_> = PeerDB::get_always_allowed_peers(
-                                &self.peerdb.conn(),
-                                self.local_peer.network_id,
-                            )
-                            .unwrap_or(vec![])
-                            .into_iter()
-                            .map(|neighbor| neighbor.addr)
-                            .collect();
-
-                            // have we finished a full pass of the inventory state machine on an
-                            // always-allowed peer?
-                            let mut finished_always_allowed_inv_sync = false;
-
-                            if always_allowed.len() == 0 {
-                                // vacuously, we have done so
-                                finished_always_allowed_inv_sync = true;
-                            } else {
-                                // do we have an always-allowed peer that we have not fully synced
-                                // with?
-                                let mut have_unsynced = false;
-                                if let Some(ref inv_state) = self.inv_state {
-                                    for (nk, stats) in inv_state.block_stats.iter() {
-                                        if self.is_bound(&nk) {
-                                            // this is the same address we're bound to
-                                            continue;
-                                        }
-                                        if Some((nk.addrbytes.clone(), nk.port))
-                                            == self.local_peer.public_ip_address
-                                        {
-                                            // this is a peer at our address
-                                            continue;
-                                        }
-                                        if !always_allowed.contains(&nk) {
-                                            // this peer isn't in the always-allowed set
-                                            continue;
-                                        }
-
-                                        if stats.inv.num_reward_cycles
-                                            >= self.pox_id.num_inventory_reward_cycles() as u64
-                                        {
-                                            // we have fully sync'ed with an always-allowed peer
-                                            debug!(
-                                                "{:?}: Fully-sync'ed PoX inventory from {}",
-                                                &self.local_peer, nk
-                                            );
-                                            finished_always_allowed_inv_sync = true;
-                                        } else {
-                                            // there exists an always-allowed peer that we have not
-                                            // fully sync'ed with
-                                            debug!(
-                                                "{:?}: Have not fully sync'ed with {}",
-                                                &self.local_peer, &nk
-                                            );
-                                            have_unsynced = true;
-                                        }
-                                    }
-                                }
-
-                                if !have_unsynced {
-                                    // There exists one or more always-allowed peers in
-                                    // the inv state machine (per the peer DB), but all such peers
-                                    // report either our bind address or our public IP address.
-                                    // If this is the case (i.e. a configuration error, a weird
-                                    // case where nodes share an IP, etc), then we declare this inv
-                                    // sync pass as finished.
-                                    finished_always_allowed_inv_sync = true;
-                                }
-                            }
-
-                            if finished_always_allowed_inv_sync {
-                                debug!("{:?}: synchronized inventories with at least one always-allowed peer", &self.local_peer);
-                                self.num_inv_sync_passes += 1;
-                            } else {
-                                debug!("{:?}: did NOT synchronize inventories with at least one always-allowed peer", &self.local_peer);
-                            }
-                            debug!(
-                                "{:?}: Finished full inventory state-machine pass ({})",
-                                &self.local_peer, self.num_inv_sync_passes
-                            );
-
-                            // hint to the downloader to start scanning at the sortition
-                            // height we just synchronized
-                            // NOTE: this only works in Stacks 2.x.
-                            // Nakamoto uses a different state machine
-                            let start_download_sortition = if let Some(ref inv_state) =
-                                self.inv_state
-                            {
-                                let (consensus_hash, _) =
-                                    SortitionDB::get_canonical_stacks_chain_tip_hash(
-                                        sortdb.conn(),
-                                    )
-                                    .expect("FATAL: failed to load canonical stacks chain tip hash from sortition DB");
-                                let stacks_tip_sortition_height =
-                                    SortitionDB::get_block_snapshot_consensus(
-                                        sortdb.conn(),
-                                        &consensus_hash,
-                                    )
-                                    .expect("FATAL: failed to query sortition DB")
-                                    .map(|sn| sn.block_height)
-                                    .unwrap_or(self.burnchain.first_block_height)
-                                    .saturating_sub(self.burnchain.first_block_height);
-
-                                let sortition_height_start = cmp::min(
-                                    stacks_tip_sortition_height,
-                                    inv_state.block_sortition_start,
-                                );
-
-                                debug!(
-                                        "{:?}: Begin downloader synchronization at sortition height {} min({},{})",
-                                        &self.local_peer,
-                                        sortition_height_start,
-                                        inv_state.block_sortition_start,
-                                        stacks_tip_sortition_height
-                                    );
-
-                                sortition_height_start
-                            } else {
-                                // really unreachable, but why tempt fate?
-                                warn!(
-                                    "{:?}: Inventory state machine not yet initialized",
-                                    &self.local_peer
-                                );
-                                0
-                            };
-
-                            if let Some(ref mut downloader) = self.block_downloader {
-                                debug!(
-                                    "{:?}: wake up downloader at sortition height {}",
-                                    &self.local_peer, start_download_sortition
-                                );
-                                downloader.hint_block_sortition_height_available(
-                                    start_download_sortition,
-                                    ibd,
-                                    false,
-                                );
-                                downloader.hint_microblock_sortition_height_available(
-                                    start_download_sortition,
-                                    ibd,
-                                    false,
-                                );
-                            } else {
-                                warn!(
-                                    "{:?}: Block downloader not yet initialized",
-                                    &self.local_peer
-                                );
-                            }
-                        }
-                    }
+                    let new_state = self.work_inv_sync_epoch2x(sortdb, download_backpressure, ibd);
+                    self.work_state = new_state;
                 }
                 PeerNetworkWorkState::BlockDownload => {
                     // go fetch blocks
@@ -4101,7 +4071,7 @@ impl PeerNetwork {
                             &self.local_peer
                         );
                     } else {
-                        self.try_push_local_data(sortdb, chainstate);
+                        self.try_push_local_data_epoch2x(sortdb, chainstate);
                     }
                     self.work_state = PeerNetworkWorkState::Prune;
                 }
@@ -4307,7 +4277,8 @@ impl PeerNetwork {
 
     /// Update a peer's inventory state to indicate that the given block is available.
     /// If updated, return the sortition height of the bit in the inv that was set.
-    fn handle_unsolicited_inv_update(
+    /// Only valid for epoch 2.x
+    fn handle_unsolicited_inv_update_epoch2x(
         &mut self,
         sortdb: &SortitionDB,
         event_id: usize,
@@ -4315,6 +4286,22 @@ impl PeerNetwork {
         consensus_hash: &ConsensusHash,
         microblocks: bool,
     ) -> Result<Option<u64>, net_error> {
+        let epoch = self.get_current_epoch();
+        if epoch.epoch_id >= StacksEpochId::Epoch30 {
+            info!(
+                "{:?}: Ban peer event {} for sending an inv 2.x update for {} in epoch 3.x",
+                event_id,
+                self.get_local_peer(),
+                consensus_hash
+            );
+            self.bans.insert(event_id);
+
+            if let Some(outbound_event_id) = self.events.get(&outbound_neighbor_key) {
+                self.bans.insert(*outbound_event_id);
+            }
+            return Ok(None);
+        }
+
         let block_sortition_height = match self.inv_state {
             Some(ref mut inv) => {
                 let res = if microblocks {
@@ -4525,7 +4512,7 @@ impl PeerNetwork {
 
         let mut to_buffer = false;
         for (consensus_hash, block_hash) in new_blocks.available.iter() {
-            let block_sortition_height = match self.handle_unsolicited_inv_update(
+            let block_sortition_height = match self.handle_unsolicited_inv_update_epoch2x(
                 sortdb,
                 event_id,
                 &outbound_neighbor_key,
@@ -4626,7 +4613,7 @@ impl PeerNetwork {
 
         let mut to_buffer = false;
         for (consensus_hash, block_hash) in new_mblocks.available.iter() {
-            let mblock_sortition_height = match self.handle_unsolicited_inv_update(
+            let mblock_sortition_height = match self.handle_unsolicited_inv_update_epoch2x(
                 sortdb,
                 event_id,
                 &outbound_neighbor_key,
@@ -4806,7 +4793,7 @@ impl PeerNetwork {
             // only bother updating the inventory for this event's peer if we have an outbound
             // connection to it.
             if let Some(outbound_neighbor_key) = outbound_neighbor_key_opt.as_ref() {
-                let _ = self.handle_unsolicited_inv_update(
+                let _ = self.handle_unsolicited_inv_update_epoch2x(
                     sortdb,
                     event_id,
                     &outbound_neighbor_key,

From 71520b528cecec623bb2e76b5513ae22c0a232ec Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Sat, 10 Feb 2024 23:09:20 -0500
Subject: [PATCH 0738/1166] chore: expand test coverage to cover the state
 machine's behavior -- both the state machine itself and the nakamoto work
 state machine

---
 stackslib/src/net/tests/inv/epoch2x.rs  |   2 +-
 stackslib/src/net/tests/inv/nakamoto.rs | 445 ++++++++++++++++++++++--
 2 files changed, 408 insertions(+), 39 deletions(-)

diff --git a/stackslib/src/net/tests/inv/epoch2x.rs b/stackslib/src/net/tests/inv/epoch2x.rs
index 4f0072ba08..e378d0920b 100644
--- a/stackslib/src/net/tests/inv/epoch2x.rs
+++ b/stackslib/src/net/tests/inv/epoch2x.rs
@@ -633,7 +633,7 @@ fn test_sync_inv_set_blocks_microblocks_available() {
     let nk = peer_1.to_neighbor().addr;
 
     let sortdb = peer_1.sortdb.take().unwrap();
-    peer_1.network.init_inv_sync(&sortdb);
+    peer_1.network.init_inv_sync_epoch2x(&sortdb);
     match peer_1.network.inv_state {
         Some(ref mut inv) => {
             inv.add_peer(nk.clone(), true);
diff --git a/stackslib/src/net/tests/inv/nakamoto.rs b/stackslib/src/net/tests/inv/nakamoto.rs
index accc174e88..526e302c60 100644
--- a/stackslib/src/net/tests/inv/nakamoto.rs
+++ b/stackslib/src/net/tests/inv/nakamoto.rs
@@ -23,7 +23,9 @@ use std::thread::JoinHandle;
 use stacks_common::address::{AddressHashMode, C32_ADDRESS_VERSION_TESTNET_SINGLESIG};
 use stacks_common::codec::{read_next, StacksMessageCodec};
 use stacks_common::types::chainstate::{StacksAddress, StacksPrivateKey, StacksPublicKey};
+use stacks_common::types::net::PeerAddress;
 use stacks_common::types::StacksEpoch;
+use stacks_common::util::hash::Hash160;
 
 use crate::chainstate::burn::db::sortdb::SortitionDB;
 use crate::chainstate::burn::ConsensusHash;
@@ -40,12 +42,13 @@ use crate::chainstate::stacks::{
 };
 use crate::clarity::vm::types::StacksAddressExtensions;
 use crate::core::StacksEpochExtension;
-use crate::net::inv::nakamoto::InvGenerator;
+use crate::net::inv::nakamoto::{InvGenerator, NakamotoInvStateMachine, NakamotoTenureInv};
+use crate::net::neighbors::comms::NeighborComms;
 use crate::net::test::{TestEventObserver, TestPeer};
 use crate::net::tests::{NakamotoBootPlan, NakamotoBootStep, NakamotoBootTenure};
 use crate::net::{
-    Error as NetError, GetNakamotoInvData, HandshakeData, NakamotoInvData, StacksMessage,
-    StacksMessageType,
+    Error as NetError, GetNakamotoInvData, HandshakeData, NakamotoInvData, NeighborAddress,
+    PeerNetworkComms, StacksMessage, StacksMessageType,
 };
 use crate::stacks_common::types::Address;
 use crate::util_lib::db::Error as DBError;
@@ -311,13 +314,16 @@ fn test_nakamoto_inv_10_extended_tenures_10_sortitions() {
     }
 }
 
-fn make_nakamoto_peer_from_invs<'a>(
+/// NOTE: The second return value does _not_ need `<'a>`, since `observer` is never installed into
+/// the peers here.  However, it appears unavoidable to the borrow-checker.
+fn make_nakamoto_peers_from_invs<'a>(
     test_name: &str,
     observer: &'a TestEventObserver,
     rc_len: u32,
     prepare_len: u32,
     bitvecs: Vec<Vec<bool>>,
-) -> TestPeer<'a> {
+    num_peers: usize,
+) -> (TestPeer<'a>, Vec<TestPeer<'a>>) {
     for bitvec in bitvecs.iter() {
         assert_eq!(bitvec.len() as u32, rc_len);
     }
@@ -392,10 +398,21 @@ fn make_nakamoto_peer_from_invs<'a>(
     let plan = NakamotoBootPlan::new(test_name)
         .with_private_key(private_key)
         .with_pox_constants(rc_len, prepare_len)
-        .with_initial_balances(vec![(addr.into(), 1_000_000)]);
+        .with_initial_balances(vec![(addr.into(), 1_000_000)])
+        .with_extra_peers(num_peers);
 
-    let peer = plan.boot_into_nakamoto_peer(boot_tenures, Some(observer));
-    peer
+    let (peer, other_peers) = plan.boot_into_nakamoto_peers(boot_tenures, Some(observer));
+    (peer, other_peers)
+}
+
+fn make_nakamoto_peer_from_invs<'a>(
+    test_name: &str,
+    observer: &'a TestEventObserver,
+    rc_len: u32,
+    prepare_len: u32,
+    bitvecs: Vec<Vec<bool>>,
+) -> TestPeer<'a> {
+    make_nakamoto_peers_from_invs(test_name, observer, rc_len, prepare_len, bitvecs, 0).0
 }
 
 fn check_inv_messages(
@@ -434,6 +451,50 @@ fn check_inv_messages(
     }
 }
 
+fn check_inv_state(
+    bitvecs: Vec<Vec<bool>>,
+    rc_len: u32,
+    nakamoto_start_burn_height: u64,
+    inv_state: &NakamotoTenureInv,
+) {
+    for (i, (tenure_rc, tenure_inv)) in inv_state.tenures_inv.iter().enumerate() {
+        for bit in 0..(rc_len as usize) {
+            let msg_bit = if bit / 8 >= tenure_inv.len() {
+                // only allowed at the end
+                debug!(
+                    "bit = {}, tenure_rc = {}, tenure_inv = {:?}",
+                    bit, tenure_rc, &tenure_inv
+                );
+                assert_eq!(i, inv_state.tenures_inv.len() - 1);
+                false
+            } else {
+                tenure_inv[bit / 8] & (1 << (bit % 8)) != 0
+            };
+
+            let burn_block_height = (*tenure_rc as u64) * u64::from(rc_len) + (bit as u64);
+            if burn_block_height < nakamoto_start_burn_height {
+                // inv doesn't cover epoch 2
+                assert!(
+                    !msg_bit,
+                    "Bit {} in tenure {} is set but is before nakamoto-start height {} ({})",
+                    bit, tenure_rc, nakamoto_start_burn_height, burn_block_height
+                );
+                continue;
+            }
+
+            let inv_offset: u64 = burn_block_height - nakamoto_start_burn_height;
+            let bitvec_idx = (inv_offset / u64::from(rc_len)) as usize;
+            let expected_bit = if bitvec_idx >= bitvecs.len() {
+                false
+            } else {
+                bitvecs[bitvec_idx][(inv_offset % u64::from(rc_len)) as usize]
+            };
+            assert_eq!(msg_bit, expected_bit, "Bit {} in tenure {} is {}, but expected {}. burn_block_height = {}, inv_offset = {}, bitvec_idx = {}, nakamoto_start_burn_height = {}",
+                       bit, tenure_rc, msg_bit, expected_bit, burn_block_height, inv_offset, bitvec_idx, nakamoto_start_burn_height);
+        }
+    }
+}
+
 #[test]
 fn test_nakamoto_invs_full() {
     let observer = TestEventObserver::new();
@@ -566,22 +627,39 @@ fn test_nakamoto_invs_different_anchor_blocks() {
 
 #[test]
 fn test_nakamoto_tenure_inv() {
-    let mut nakamoto_inv = NakamotoTenureInv::new(100, 100);
+    let na = NeighborAddress {
+        addrbytes: PeerAddress([
+            0xff, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d,
+            0x0e, 0x0f,
+        ]),
+        port: 65535,
+        public_key_hash: Hash160([0x11; 20]),
+    };
+    let mut nakamoto_inv = NakamotoTenureInv::new(100, 100, na);
     assert!(!nakamoto_inv.has_ith_tenure(0));
     assert!(!nakamoto_inv.has_ith_tenure(99));
     assert!(!nakamoto_inv.has_ith_tenure(100));
-    assert_eq!(nakamoto_inv.num_reward_cycles(), 0);
+    assert_eq!(nakamoto_inv.highest_reward_cycle(), 0);
 
-    let full_tenure = NakamotoInvData::bools_to_bitvec(vec![true; 100]);
-    nakamoto_inv.merge_tenure_inv(full_tenure, 100, 1);
+    let full_tenure = NakamotoInvData::bools_to_bitvec(&[true; 100]);
+    let learned = nakamoto_inv.merge_tenure_inv(full_tenure.clone(), 100, 1);
+    assert!(learned);
 
-    for i in 100..200 {
+    let learned = nakamoto_inv.merge_tenure_inv(full_tenure, 100, 1);
+    assert!(!learned);
+
+    debug!("nakamoto_inv = {:?}", &nakamoto_inv);
+    for i in 0..200 {
+        assert!(!nakamoto_inv.has_ith_tenure(i));
+    }
+    for i in 200..300 {
         assert!(nakamoto_inv.has_ith_tenure(i));
     }
-    assert!(!nakamoto_inv.has_ith_tenure(99));
-    assert!(!nakamoto_inv.has_ith_tenure(200));
-    assert!(!nakamoto_inv.has_ith_tenure(201));
-    assert_eq!(nakamoto_inv.num_reward_cycles(), 1);
+    assert!(!nakamoto_inv.has_ith_tenure(199));
+    assert!(nakamoto_inv.has_ith_tenure(200));
+    assert!(!nakamoto_inv.has_ith_tenure(300));
+    assert!(!nakamoto_inv.has_ith_tenure(301));
+    assert_eq!(nakamoto_inv.highest_reward_cycle(), 1);
 
     let mut partial_tenure_bools = vec![];
     for i in 0..100 {
@@ -589,34 +667,43 @@ fn test_nakamoto_tenure_inv() {
     }
 
     // has_ith_tenure() works (non-triial case)
-    let partial_tenure = NakamotoInvData::bools_to_bitvec(partial_tenure_bools);
-    nakamoto_inv.merge_tenure_inv(partial_tenure, 100, 2);
+    let partial_tenure = NakamotoInvData::bools_to_bitvec(&partial_tenure_bools);
+    let learned = nakamoto_inv.merge_tenure_inv(partial_tenure.clone(), 100, 2);
+    assert!(learned);
 
-    for i in 200..300 {
+    for i in 300..400 {
         assert_eq!(nakamoto_inv.has_ith_tenure(i), i % 2 == 0);
     }
-    assert!(!nakamoto_inv.has_ith_tenure(99));
-    assert!(!nakamoto_inv.has_ith_tenure(300));
-    assert!(!nakamoto_inv.has_ith_tenure(301));
-    assert_eq!(nakamoto_inv.num_reward_cycles(), 2);
+    assert!(!nakamoto_inv.has_ith_tenure(199));
+    assert!(nakamoto_inv.has_ith_tenure(299));
+    assert!(nakamoto_inv.has_ith_tenure(300));
+    assert!(nakamoto_inv.has_ith_tenure(398));
+    assert!(!nakamoto_inv.has_ith_tenure(399));
+    assert!(!nakamoto_inv.has_ith_tenure(400));
+    assert_eq!(nakamoto_inv.highest_reward_cycle(), 2);
 
     // supports sparse updates
-    let full_tenure = NakamotoInvData::bools_to_bitvec(vec![true; 100]);
-    nakamoto_inv.merge_tenure_inv(full_tenure, 100, 4);
-    
-    for i in 300..400 {
-        assert_eq!(!nakamoto_inv.has_ith_tenure(i));
-    }
+    let full_tenure = NakamotoInvData::bools_to_bitvec(&[true; 100]);
+    let learned = nakamoto_inv.merge_tenure_inv(full_tenure, 100, 4);
+    assert!(learned);
+
     for i in 400..500 {
-        assert_eq!(!nakamoto_inv.has_ith_tenure(i));
+        assert!(!nakamoto_inv.has_ith_tenure(i));
+    }
+    for i in 500..600 {
+        assert!(nakamoto_inv.has_ith_tenure(i));
     }
-    assert_eq!(nakamoto_inv.num_reward_cycles(), 4);
-    
+    assert_eq!(nakamoto_inv.highest_reward_cycle(), 4);
+
     // can overwrite tenures
-    let full_tenure = NakamotoInvData::bools_to_bitvec(vec![true; 100]);
-    nakamoto_inv.merge_tenure_inv(partial_tenure, 100, 2);
+    let full_tenure = NakamotoInvData::bools_to_bitvec(&[true; 100]);
+    let learned = nakamoto_inv.merge_tenure_inv(full_tenure.clone(), 100, 2);
+    assert!(learned);
 
-    for i in 200..300 {
+    let learned = nakamoto_inv.merge_tenure_inv(full_tenure.clone(), 100, 2);
+    assert!(!learned);
+
+    for i in 300..400 {
         assert!(nakamoto_inv.has_ith_tenure(i));
     }
 
@@ -628,8 +715,290 @@ fn test_nakamoto_tenure_inv() {
 
     nakamoto_inv.next_reward_cycle();
     assert_eq!(nakamoto_inv.reward_cycle(), 1);
-    
-    nakamoto_inv.try_reset_comms(0, 0);
+
+    nakamoto_inv.try_reset_comms(0, 0, 0);
     assert_eq!(nakamoto_inv.reward_cycle(), 0);
     assert!(nakamoto_inv.is_online());
 }
+
+#[test]
+fn test_nakamoto_inv_sync_state_machine() {
+    let observer = TestEventObserver::new();
+    let bitvecs = vec![
+        // full rc
+        vec![true, true, true, true, true, true, true, true, true, true],
+        // sparse rc
+        vec![
+            true, false, false, false, false, false, false, true, true, true,
+        ],
+        // atlernating rc
+        vec![
+            false, true, false, true, false, true, false, true, true, true,
+        ],
+        // sparse rc
+        vec![
+            false, false, false, false, false, false, true, true, true, true,
+        ],
+        // full rc
+        vec![true, true, true, true, true, true, true, true, true, true],
+    ];
+
+    // boot two peers, and cannibalize the second one for its network and sortdb so we can use them
+    // to directly drive a state machine.
+    let (mut peer, mut other_peers) =
+        make_nakamoto_peers_from_invs(function_name!(), &observer, 10, 3, bitvecs.clone(), 1);
+    let mut other_peer = other_peers.pop().unwrap();
+
+    let nakamoto_start =
+        NakamotoBootPlan::nakamoto_first_tenure_height(&peer.config.burnchain.pox_constants);
+
+    let tip = {
+        let sort_db = peer.sortdb.as_mut().unwrap();
+        SortitionDB::get_canonical_burn_chain_tip(sort_db.conn()).unwrap()
+    };
+    let total_rcs = peer
+        .config
+        .burnchain
+        .block_height_to_reward_cycle(tip.block_height)
+        .unwrap()
+        + 1;
+
+    // run peer and other_peer until they connect
+    loop {
+        let _ = peer.step_with_ibd(false);
+        let _ = other_peer.step_with_ibd(false);
+
+        let event_ids: Vec<usize> = peer
+            .network
+            .iter_peer_event_ids()
+            .map(|e_id| *e_id)
+            .collect();
+        let other_event_ids: Vec<usize> = other_peer
+            .network
+            .iter_peer_event_ids()
+            .map(|e_id| *e_id)
+            .collect();
+
+        if event_ids.len() > 0 && other_event_ids.len() > 0 {
+            break;
+        }
+    }
+
+    debug!("Peers are connected");
+    let peer_addr = NeighborAddress::from_neighbor(&peer.to_neighbor());
+
+    let (sx, rx) = sync_channel(1);
+    let mut inv_machine = NakamotoInvStateMachine::new(PeerNetworkComms::new());
+
+    // ::scope is necessary because Rust is forced to think that `other_peers` has the same lifetime
+    // as `observer`, which prohibits running a bare thread in which `other_peers` outlives
+    // `observer`
+    std::thread::scope(|s| {
+        s.spawn(|| {
+            let sortdb = other_peer.sortdb.take().unwrap();
+            inv_machine
+                .process_getnakamotoinv_begins(&mut other_peer.network, &sortdb, false)
+                .unwrap();
+            other_peer.sortdb = Some(sortdb);
+
+            let mut last_learned_rc = 0;
+            loop {
+                let _ = other_peer.step_with_ibd(false);
+                let ev_ids: Vec<_> = other_peer.network.iter_peer_event_ids().collect();
+                if ev_ids.len() == 0 {
+                    // disconnected
+                    panic!("Disconnected");
+                }
+
+                let (num_msgs, learned) = inv_machine
+                    .process_getnakamotoinv_finishes(&mut other_peer.network)
+                    .unwrap();
+
+                for (_, inv) in inv_machine.inventories.iter() {
+                    debug!(
+                        "inv is at rc {}, last learned rc is {}, total rcs = {}",
+                        inv.reward_cycle(),
+                        last_learned_rc,
+                        total_rcs
+                    );
+                    last_learned_rc = last_learned_rc.max(inv.reward_cycle());
+                }
+
+                if last_learned_rc >= total_rcs {
+                    break;
+                }
+
+                let sortdb = other_peer.sortdb.take().unwrap();
+                inv_machine
+                    .process_getnakamotoinv_begins(&mut other_peer.network, &sortdb, false)
+                    .unwrap();
+                other_peer.sortdb = Some(sortdb);
+            }
+
+            sx.send(true).unwrap();
+        });
+
+        loop {
+            let _ = peer.step_with_ibd(false);
+            if rx.try_recv().is_ok() {
+                break;
+            }
+        }
+    });
+
+    // inv_machine learned everything
+    for (_, inv) in inv_machine.inventories.iter() {
+        debug!("Check inv state: {:?}", inv);
+        check_inv_state(bitvecs.clone(), 10, nakamoto_start, inv);
+    }
+}
+
+#[test]
+fn test_nakamoto_inv_sync_across_epoch_change() {
+    let observer = TestEventObserver::new();
+    let bitvecs = vec![
+        // full rc
+        vec![true, true, true, true, true, true, true, true, true, true],
+        // sparse rc
+        vec![
+            true, false, false, false, false, false, false, true, true, true,
+        ],
+        // atlernating rc
+        vec![
+            false, true, false, true, false, true, false, true, true, true,
+        ],
+        // sparse rc
+        vec![
+            false, false, false, false, false, false, true, true, true, true,
+        ],
+        // full rc
+        vec![true, true, true, true, true, true, true, true, true, true],
+    ];
+
+    // boot two peers, and cannibalize the second one for its network and sortdb so we can use them
+    // to directly drive a state machine.
+    let (mut peer, mut other_peers) =
+        make_nakamoto_peers_from_invs(function_name!(), &observer, 10, 3, bitvecs.clone(), 1);
+    let mut other_peer = other_peers.pop().unwrap();
+
+    let nakamoto_start =
+        NakamotoBootPlan::nakamoto_first_tenure_height(&peer.config.burnchain.pox_constants);
+
+    let tip = {
+        let sort_db = peer.sortdb.as_mut().unwrap();
+        SortitionDB::get_canonical_burn_chain_tip(sort_db.conn()).unwrap()
+    };
+    let total_rcs = peer
+        .config
+        .burnchain
+        .block_height_to_reward_cycle(tip.block_height)
+        .unwrap();
+
+    // run peer and other_peer until they connect
+    loop {
+        let _ = peer.step_with_ibd(false);
+        let _ = other_peer.step_with_ibd(false);
+
+        let event_ids: Vec<usize> = peer
+            .network
+            .iter_peer_event_ids()
+            .map(|e_id| *e_id)
+            .collect();
+        let other_event_ids: Vec<usize> = other_peer
+            .network
+            .iter_peer_event_ids()
+            .map(|e_id| *e_id)
+            .collect();
+
+        if event_ids.len() > 0 && other_event_ids.len() > 0 {
+            break;
+        }
+    }
+
+    debug!("Peers are connected");
+
+    // force peers to sync their epoch 2.x inventories
+    let old_burn_chain_tip = peer.network.burnchain_tip.block_height;
+    let num_epoch2_blocks = nakamoto_start - 26; // TestPeer starts making blocks at sortition 26
+
+    // check epoch 2.x state machine
+    let mut round = 0;
+    let mut inv_1_count = 0;
+    let mut inv_2_count = 0;
+    let mut highest_rc_1 = 0;
+    let mut highest_rc_2 = 0;
+
+    let burn_tip_start = peer.network.get_current_epoch().start_height;
+
+    while inv_1_count < num_epoch2_blocks
+        || inv_2_count < num_epoch2_blocks
+        || highest_rc_1 < total_rcs
+        || highest_rc_2 < total_rcs
+    {
+        // trick the work loop into thinking that the current chain view is this
+        peer.network.connection_opts.force_nakamoto_epoch_transition = true;
+        other_peer
+            .network
+            .connection_opts
+            .force_nakamoto_epoch_transition = true;
+
+        let _ = peer.step_with_ibd(false);
+        let _ = other_peer.step_with_ibd(false);
+
+        inv_1_count = peer
+            .network
+            .inv_state
+            .as_ref()
+            .map(|inv| inv.get_inv_num_blocks(&other_peer.to_neighbor().addr))
+            .unwrap_or(0);
+        inv_2_count = other_peer
+            .network
+            .inv_state
+            .as_ref()
+            .map(|inv| inv.get_inv_num_blocks(&peer.to_neighbor().addr))
+            .unwrap_or(0);
+
+        highest_rc_1 = peer
+            .network
+            .inv_state_nakamoto
+            .as_ref()
+            .map(|inv| inv.highest_reward_cycle())
+            .unwrap_or(0);
+        highest_rc_2 = other_peer
+            .network
+            .inv_state_nakamoto
+            .as_ref()
+            .map(|inv| inv.highest_reward_cycle())
+            .unwrap_or(0);
+
+        // nothing should break
+        match peer.network.inv_state {
+            Some(ref inv) => {
+                assert_eq!(inv.get_broken_peers().len(), 0);
+                assert_eq!(inv.get_dead_peers().len(), 0);
+                assert_eq!(inv.get_diverged_peers().len(), 0);
+            }
+            None => {}
+        }
+
+        match other_peer.network.inv_state {
+            Some(ref inv) => {
+                assert_eq!(inv.get_broken_peers().len(), 0);
+                assert_eq!(inv.get_dead_peers().len(), 0);
+                assert_eq!(inv.get_diverged_peers().len(), 0);
+            }
+            None => {}
+        }
+
+        round += 1;
+
+        info!(
+            "Epoch 2.x state machine: Peer 1: {}, Peer 2: {} (total {})",
+            inv_1_count, inv_2_count, num_epoch2_blocks
+        );
+        info!(
+            "Nakamoto state machine: Peer 1: {}, Peer 2: {} (total {})",
+            highest_rc_1, highest_rc_2, total_rcs
+        );
+    }
+}

From 970399fac045a46675e113ab182e0ec20f390981 Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Sun, 11 Feb 2024 14:35:25 -0500
Subject: [PATCH 0739/1166] new get-candidate-info getter

---
 stackslib/src/chainstate/stacks/boot/signers-voting.clar | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/stackslib/src/chainstate/stacks/boot/signers-voting.clar b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
index b8375d3431..ce5062eb39 100644
--- a/stackslib/src/chainstate/stacks/boot/signers-voting.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
@@ -50,6 +50,10 @@
 (define-read-only (get-vote (reward-cycle uint) (round uint) (signer principal))
     (map-get? votes {reward-cycle: reward-cycle, round: round, signer: signer}))
 
+(define-read-only (get-candidate-info (reward-cycle uint) (round uint) (candidate (buff 33)))
+    {candidate-weight: (default-to u0 (map-get? tally reward-cycle round candidate))
+    total-weight: (map-get? cycle-total-weight reward-cycle)})
+
 (define-read-only (get-tally (reward-cycle uint) (round uint) (aggregate-public-key (buff 33)))
     (map-get? tally {reward-cycle: reward-cycle, round: round, aggregate-public-key: aggregate-public-key}))
 

From d8c8cfafd09cc3864eb2a61cd6f22f28bf3a51ce Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Mon, 12 Feb 2024 11:40:14 -0500
Subject: [PATCH 0740/1166] chore: fix style suggestions from PR review

---
 .../stacks/boot/signers-voting.clar           | 27 +++++++------------
 1 file changed, 10 insertions(+), 17 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers-voting.clar b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
index ce5062eb39..b270a5234b 100644
--- a/stackslib/src/chainstate/stacks/boot/signers-voting.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
@@ -24,7 +24,7 @@
 ;; Threshold consensus (in 3 digit %)
 (define-constant threshold-consensus u700)
 
-;; maps reward-cycle ids to last round
+;; Maps reward-cycle ids to last round
 (define-map rounds uint uint)
 
 ;; Maps reward-cycle ids to aggregate public key.
@@ -79,8 +79,7 @@
 
 ;; get the aggregate public key for the given reward cycle (or none)
 (define-read-only (get-approved-aggregate-key (reward-cycle uint))
-    (map-get? aggregate-public-keys reward-cycle)
-)
+    (map-get? aggregate-public-keys reward-cycle))
 
 (define-private (is-in-voting-window (height uint) (reward-cycle uint))
     (let ((last-cycle (unwrap-panic (contract-call? .signers get-last-set-cycle))))
@@ -88,21 +87,15 @@
             (is-in-prepare-phase height))))
 
 (define-private (sum-weights (signer { signer: principal, weight: uint }) (acc uint))
-    (+ acc (get weight signer))
-)
+    (+ acc (get weight signer)))
 
 (define-private (get-total-weight (reward-cycle uint))
     (match (map-get? cycle-total-weight reward-cycle)
         total (ok total)
-        (let (
-                (signers (unwrap! (contract-call? .signers get-signers reward-cycle) (err ERR_FAILED_TO_RETRIEVE_SIGNERS)))
-                (total (fold sum-weights signers u0))
-            )
+        (let ((signers (unwrap! (contract-call? .signers get-signers reward-cycle) (err ERR_FAILED_TO_RETRIEVE_SIGNERS)))
+                (total (fold sum-weights signers u0)))
             (map-set cycle-total-weight reward-cycle total)
-            (ok total)
-        )
-    )
-)
+            (ok total))))
 
 ;; Signer vote for the aggregate public key of the next reward cycle
 ;;  The vote happens in the prepare phase of the current reward cycle but may be ran more than
@@ -138,12 +131,12 @@
         })
         ;; Check if consensus has been reached
         (and
-            ;; If we already have consensus, skip this
-            (is-none (map-get? aggregate-public-keys reward-cycle))
             ;; If the new total weight is greater than or equal to the threshold consensus
             (>= (/ (* new-total u1000) total-weight) threshold-consensus)
-            ;; Save this approved aggregate public key for this reward cycle
-            (map-set aggregate-public-keys reward-cycle key)
+            ;; Save this approved aggregate public key for this reward cycle.
+            ;; If there is already a key for this cycle, this will return false
+            ;; there will be no duplicate event.
+            (map-insert aggregate-public-keys reward-cycle key)
             ;; Create an event for the approved aggregate public key
             (begin
                 (print {

From fe928d70b748e6af444714b23ac6ad5dd171a1b1 Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Mon, 12 Feb 2024 11:42:48 -0500
Subject: [PATCH 0741/1166] fix: fix issues in `get-candidate-info`

---
 stackslib/src/chainstate/stacks/boot/signers-voting.clar | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers-voting.clar b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
index b270a5234b..962e8e1abf 100644
--- a/stackslib/src/chainstate/stacks/boot/signers-voting.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
@@ -51,7 +51,7 @@
     (map-get? votes {reward-cycle: reward-cycle, round: round, signer: signer}))
 
 (define-read-only (get-candidate-info (reward-cycle uint) (round uint) (candidate (buff 33)))
-    {candidate-weight: (default-to u0 (map-get? tally reward-cycle round candidate))
+    {candidate-weight: (default-to u0 (map-get? tally {reward-cycle: reward-cycle, round: round, aggregate-public-key: candidate})),
     total-weight: (map-get? cycle-total-weight reward-cycle)})
 
 (define-read-only (get-tally (reward-cycle uint) (round uint) (aggregate-public-key (buff 33)))

From 98c7737dd960cdd6f51cbbeeffa700c32bcef6d4 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Mon, 12 Feb 2024 13:25:21 -0500
Subject: [PATCH 0742/1166] chore: fix intermittent failing integration test

---
 .../src/burnchains/bitcoin_regtest_controller.rs       |  4 ++--
 testnet/stacks-node/src/tests/neon_integrations.rs     | 10 ++++++----
 2 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs b/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
index 2c71b9a1f5..f40a1042a0 100644
--- a/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
+++ b/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
@@ -1677,11 +1677,11 @@ impl BitcoinRegtestController {
     /// Send a serialized tx to the Bitcoin node.  Return Some(txid) on successful send; None on
     /// failure.
     pub fn send_transaction(&self, transaction: SerializedTx) -> Option<Txid> {
-        test_debug!("Send raw transaction: {}", transaction.to_hex());
+        debug!("Send raw transaction: {}", transaction.to_hex());
         let result = BitcoinRPCRequest::send_raw_transaction(&self.config, transaction.to_hex());
         match result {
             Ok(_) => {
-                test_debug!("Sent transaction {}", &transaction.txid);
+                debug!("Sent transaction {}", &transaction.txid);
                 Some(transaction.txid())
             }
             Err(e) => {
diff --git a/testnet/stacks-node/src/tests/neon_integrations.rs b/testnet/stacks-node/src/tests/neon_integrations.rs
index afc1c0982d..b1a2496a9b 100644
--- a/testnet/stacks-node/src/tests/neon_integrations.rs
+++ b/testnet/stacks-node/src/tests/neon_integrations.rs
@@ -573,7 +573,7 @@ pub fn next_block_and_wait_with_timeout(
     timeout: u64,
 ) -> bool {
     let current = blocks_processed.load(Ordering::SeqCst);
-    eprintln!(
+    info!(
         "Issuing block at {}, waiting for bump ({})",
         get_epoch_time_secs(),
         current
@@ -587,7 +587,7 @@ pub fn next_block_and_wait_with_timeout(
         }
         thread::sleep(Duration::from_millis(100));
     }
-    eprintln!(
+    info!(
         "Block bumped at {} ({})",
         get_epoch_time_secs(),
         blocks_processed.load(Ordering::SeqCst)
@@ -9504,8 +9504,10 @@ fn test_problematic_blocks_are_not_relayed_or_stored() {
 
     let tip_info = get_chain_info(&conf);
 
-    // all blocks were processed
-    assert!(tip_info.stacks_tip_height >= old_tip_info.stacks_tip_height + 5);
+    // at least one block was mined (hard to say how many due to the raciness between the burnchain
+    // downloader and this thread).
+    assert!(tip_info.stacks_tip_height > old_tip_info.stacks_tip_height);
+
     // one was problematic -- i.e. the one that included tx_high
     assert_eq!(all_new_files.len(), 1);
 

From afb43de86f5cb9ec3944715983e1fba845a5797b Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Tue, 13 Feb 2024 09:36:56 -0500
Subject: [PATCH 0743/1166] fix: properly retrieve signers in
 `advance_to_nakamoto`

---
 .../chainstate/nakamoto/coordinator/tests.rs  | 64 +++++++++++++++----
 stackslib/src/chainstate/stacks/boot/mod.rs   |  2 +-
 .../chainstate/stacks/boot/signers_tests.rs   |  2 +-
 3 files changed, 55 insertions(+), 13 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index ccae3812f1..a71a043b83 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -14,8 +14,11 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+use std::collections::{HashMap, HashSet};
+
 use clarity::vm::clarity::ClarityConnection;
 use clarity::vm::types::PrincipalData;
+use clarity::vm::Value;
 use rand::prelude::SliceRandom;
 use rand::{thread_rng, Rng, RngCore};
 use stacks_common::address::{AddressHashMode, C32_ADDRESS_VERSION_TESTNET_SINGLESIG};
@@ -35,11 +38,12 @@ use crate::chainstate::nakamoto::tests::get_account;
 use crate::chainstate::nakamoto::tests::node::{TestSigners, TestStacker};
 use crate::chainstate::nakamoto::{NakamotoBlock, NakamotoChainState};
 use crate::chainstate::stacks::address::PoxAddress;
+use crate::chainstate::stacks::boot::signers_tests::readonly_call;
 use crate::chainstate::stacks::boot::test::{
     key_to_stacks_addr, make_pox_4_lockup, make_signer_key_signature,
     make_signers_vote_for_aggregate_public_key,
 };
-use crate::chainstate::stacks::boot::MINERS_NAME;
+use crate::chainstate::stacks::boot::{MINERS_NAME, SIGNERS_NAME};
 use crate::chainstate::stacks::db::{MinerPaymentTxFees, StacksAccount, StacksChainState};
 use crate::chainstate::stacks::{
     CoinbasePayload, StacksTransaction, StacksTransactionSigner, TenureChangeCause,
@@ -70,6 +74,7 @@ fn advance_to_nakamoto(
     )
     .unwrap();
 
+    let mut tip = None;
     for sortition_height in 0..11 {
         // stack to pox-3 in cycle 7
         let txs = if sortition_height == 6 {
@@ -102,17 +107,54 @@ fn advance_to_nakamoto(
                     )
                 })
                 .collect()
-        } else if sortition_height == 7 {
-            // Vote for the aggregate key
-            test_stackers
-                .iter()
-                .enumerate()
-                .map(|(index, test_stacker)| {
-                    info!("Vote for aggregate key: {}", index);
+        } else if sortition_height == 8 {
+            // Retrieve the signers from the contract
+            let signers_res = readonly_call(
+                peer,
+                &tip.unwrap(),
+                SIGNERS_NAME.into(),
+                "get-signers".into(),
+                vec![Value::UInt(7)],
+            );
+            let signer_vec = signers_res
+                .expect_optional()
+                .unwrap()
+                .unwrap()
+                .expect_list()
+                .unwrap();
+            let mut signers_to_index = HashMap::new();
+            for (index, value) in signer_vec.into_iter().enumerate() {
+                let tuple = value.expect_tuple().unwrap();
+                let signer = tuple
+                    .get_owned("signer")
+                    .unwrap()
+                    .expect_principal()
+                    .unwrap();
+                signers_to_index.insert(signer, index);
+            }
+
+            // Build a map of the signers, their private keys, and their index
+            let mut signers = HashMap::new();
+            for test_stacker in test_stackers {
+                let addr = key_to_stacks_addr(&test_stacker.signer_private_key);
+                let principal = PrincipalData::from(addr);
+                signers.insert(
+                    addr,
+                    (
+                        test_stacker.signer_private_key,
+                        signers_to_index[&principal],
+                    ),
+                );
+            }
+
+            // Vote for the aggregate key for each signer
+            signers
+                .values()
+                .map(|(signer_key, index)| {
                     make_signers_vote_for_aggregate_public_key(
-                        &test_stacker.signer_private_key,
+                        signer_key,
                         0,
-                        index as u128,
+                        *index as u128,
                         &test_signers.aggregate_public_key,
                         0,
                         7,
@@ -123,7 +165,7 @@ fn advance_to_nakamoto(
             vec![]
         };
 
-        peer.tenure_with_txs(&txs, &mut peer_nonce);
+        tip = Some(peer.tenure_with_txs(&txs, &mut peer_nonce));
     }
     // peer is at the start of cycle 8
 }
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 48578c604e..e63ba90712 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -1324,7 +1324,7 @@ pub mod pox_3_tests;
 #[cfg(test)]
 pub mod pox_4_tests;
 #[cfg(test)]
-mod signers_tests;
+pub mod signers_tests;
 #[cfg(test)]
 pub mod signers_voting_tests;
 
diff --git a/stackslib/src/chainstate/stacks/boot/signers_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_tests.rs
index 9ca8fb0565..1097ce92a1 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_tests.rs
@@ -461,7 +461,7 @@ fn advance_blocks(
     latest_block_id
 }
 
-fn readonly_call(
+pub fn readonly_call(
     peer: &mut TestPeer,
     tip: &StacksBlockId,
     boot_contract: ContractName,

From 28f6333ceb9f9dd84ee05649a13d87713a80f31e Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Tue, 13 Feb 2024 10:40:16 -0500
Subject: [PATCH 0744/1166] fix: add test signers into peer config

This allows the replay peer to get the same signers.
---
 stackslib/src/chainstate/nakamoto/coordinator/tests.rs | 8 +++-----
 stackslib/src/net/mod.rs                               | 2 ++
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index a71a043b83..4457b9014d 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -232,6 +232,7 @@ pub fn boot_nakamoto<'a>(
     peer_config.burnchain.pox_constants.v3_unlock_height = 27;
     peer_config.burnchain.pox_constants.pox_4_activation_height = 31;
     peer_config.test_stackers = Some(test_stackers.to_vec());
+    peer_config.test_signers = Some(test_signers.clone());
     let mut peer = TestPeer::new_with_observer(peer_config, observer);
 
     advance_to_nakamoto(&mut peer, &test_signers, test_stackers);
@@ -248,13 +249,10 @@ fn make_replay_peer<'a>(peer: &mut TestPeer<'a>) -> TestPeer<'a> {
     replay_config.test_stackers = peer.config.test_stackers.clone();
 
     let test_stackers = replay_config.test_stackers.clone().unwrap_or(vec![]);
+    let test_signers = replay_config.test_signers.clone().unwrap();
     let mut replay_peer = TestPeer::new(replay_config);
     let observer = TestEventObserver::new();
-    advance_to_nakamoto(
-        &mut replay_peer,
-        &TestSigners::default(),
-        test_stackers.as_slice(),
-    );
+    advance_to_nakamoto(&mut replay_peer, &test_signers, test_stackers.as_slice());
 
     // sanity check
     let replay_tip = {
diff --git a/stackslib/src/net/mod.rs b/stackslib/src/net/mod.rs
index e5bfaefe3a..235259c082 100644
--- a/stackslib/src/net/mod.rs
+++ b/stackslib/src/net/mod.rs
@@ -1972,6 +1972,7 @@ pub mod test {
         /// aggregate public key to use
         pub aggregate_public_key: Option<Point>,
         pub test_stackers: Option<Vec<TestStacker>>,
+        pub test_signers: Option<TestSigners>,
     }
 
     impl TestPeerConfig {
@@ -2037,6 +2038,7 @@ pub mod test {
                     | (ServiceFlags::STACKERDB as u16),
                 aggregate_public_key: None,
                 test_stackers: None,
+                test_signers: None,
             }
         }
 

From 6f0936a69f55918bd93a87e132d743a36902ea95 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Tue, 13 Feb 2024 12:55:53 -0600
Subject: [PATCH 0745/1166] fix: event synthesis in epochs <= 2.5 must remain
 the same. make synthesis free post-2.5

---
 pox-locking/src/events.rs    |  49 ++++
 pox-locking/src/events_24.rs | 441 +++++++++++++++++++++++++++++++++++
 pox-locking/src/lib.rs       |   1 +
 3 files changed, 491 insertions(+)
 create mode 100644 pox-locking/src/events_24.rs

diff --git a/pox-locking/src/events.rs b/pox-locking/src/events.rs
index 6460455ba0..e61ee916dc 100644
--- a/pox-locking/src/events.rs
+++ b/pox-locking/src/events.rs
@@ -16,6 +16,7 @@
 
 use clarity::vm::ast::ASTRules;
 use clarity::vm::contexts::GlobalContext;
+use clarity::vm::costs::LimitedCostTracker;
 use clarity::vm::errors::Error as ClarityError;
 use clarity::vm::types::{PrincipalData, QualifiedContractIdentifier, ResponseData, TupleData};
 use clarity::vm::Value;
@@ -24,8 +25,11 @@ use slog::slog_debug;
 use slog::slog_error;
 #[cfg(test)]
 use stacks_common::debug;
+use stacks_common::types::StacksEpochId;
 use stacks_common::{error, test_debug};
 
+use crate::events_24;
+
 /// Determine who the stacker is for a given function.
 /// - for non-delegate stacking functions, it's tx-sender
 /// - for delegate stacking functions, it's the first argument
@@ -419,6 +423,51 @@ pub fn synthesize_pox_event_info(
     function_name: &str,
     args: &[Value],
     response: &ResponseData,
+) -> Result<Option<Value>, ClarityError> {
+    // the first thing we do is check the current epoch. In Epochs <= 2.4,
+    //  synthesizing PoX events was an assessed cost, so event generation
+    //  must remain identical.
+    if global_context.epoch_id <= StacksEpochId::Epoch24 {
+        return events_24::synthesize_pox_2_or_3_event_info(
+            global_context,
+            contract_id,
+            sender_opt,
+            function_name,
+            args,
+        );
+    }
+    // Now, we want to set the cost tracker to free
+    //
+    // IMPORTANT: This function SHOULD NOT early return without
+    // replacing the cost tracker. This code snippet is kept short to
+    // ensure that there is only one possible control flow here.  DO
+    // NOT alter these lines unless you know what you are doing here.
+    let original_tracker = std::mem::replace(
+        &mut global_context.cost_track,
+        LimitedCostTracker::new_free(),
+    );
+    let result = inner_synthesize_pox_event_info(
+        global_context,
+        contract_id,
+        sender_opt,
+        function_name,
+        args,
+        response,
+    );
+    // Restore the cost tracker
+    global_context.cost_track = original_tracker;
+    result
+}
+
+/// The actual implementation of Post-2.4 event construction.
+/// We use an inner function to simplify the free cost tracking.
+fn inner_synthesize_pox_event_info(
+    global_context: &mut GlobalContext,
+    contract_id: &QualifiedContractIdentifier,
+    sender_opt: Option<&PrincipalData>,
+    function_name: &str,
+    args: &[Value],
+    response: &ResponseData,
 ) -> Result<Option<Value>, ClarityError> {
     let sender = match sender_opt {
         Some(sender) => sender,
diff --git a/pox-locking/src/events_24.rs b/pox-locking/src/events_24.rs
new file mode 100644
index 0000000000..49ca9c38cd
--- /dev/null
+++ b/pox-locking/src/events_24.rs
@@ -0,0 +1,441 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020-2023 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+use clarity::vm::ast::ASTRules;
+use clarity::vm::contexts::GlobalContext;
+use clarity::vm::errors::Error as ClarityError;
+use clarity::vm::types::{PrincipalData, QualifiedContractIdentifier, TupleData};
+use clarity::vm::Value;
+#[cfg(test)]
+use slog::slog_debug;
+use slog::slog_error;
+#[cfg(test)]
+use stacks_common::debug;
+use stacks_common::{error, test_debug};
+
+/// Determine who the stacker is for a given function.
+/// - for non-delegate stacking functions, it's tx-sender
+/// - for delegate stacking functions, it's the first argument
+fn get_stacker(sender: &PrincipalData, function_name: &str, args: &[Value]) -> Value {
+    match function_name {
+        "stack-stx" | "stack-increase" | "stack-extend" | "delegate-stx" => {
+            Value::Principal(sender.clone())
+        }
+        _ => args[0].clone(),
+    }
+}
+
+/// Craft the code snippet to evaluate an event-info for a stack-* function,
+/// a delegate-stack-* function, or for delegate-stx
+fn create_event_info_stack_or_delegate_code(
+    sender: &PrincipalData,
+    function_name: &str,
+    args: &[Value],
+) -> String {
+    format!(
+        r#"
+        (let (
+            (stacker '{stacker})
+            (func-name "{func_name}")
+            (stacker-info (stx-account stacker))
+            (total-balance (stx-get-balance stacker))
+        )
+            {{
+                ;; Function name
+                name: func-name,
+                ;; The principal of the stacker
+                stacker: stacker,
+                ;; The current available balance
+                balance: total-balance,
+                ;; The amount of locked STX
+                locked: (get locked stacker-info),
+                ;; The burnchain block height of when the tokens unlock. Zero if no tokens are locked.
+                burnchain-unlock-height: (get unlock-height stacker-info),
+            }}
+        )
+        "#,
+        stacker = get_stacker(sender, function_name, args),
+        func_name = function_name
+    )
+}
+
+/// Craft the code snippet to evaluate a stack-aggregation-* function
+fn create_event_info_aggregation_code(function_name: &str) -> String {
+    format!(
+        r#"
+        (let (
+            (stacker-info (stx-account tx-sender))
+        )
+            {{
+                ;; Function name
+                name: "{func_name}",
+                ;; who called this
+                ;; NOTE: these fields are required by downstream clients.
+                ;; Even though tx-sender is *not* a stacker, the field is
+                ;; called "stacker" and these clients know to treat it as
+                ;; the delegator.
+                stacker: tx-sender,
+                balance: (stx-get-balance tx-sender),
+                locked: (get locked stacker-info),
+                burnchain-unlock-height: (get unlock-height stacker-info),
+
+            }}
+        )
+        "#,
+        func_name = function_name
+    )
+}
+
+/// Craft the code snippet to generate the method-specific `data` payload
+fn create_event_info_data_code(function_name: &str, args: &[Value]) -> String {
+    match function_name {
+        "stack-stx" => {
+            format!(
+                r#"
+                {{
+                    data: {{
+                        ;; amount of ustx to lock.
+                        ;; equal to args[0]
+                        lock-amount: {lock_amount},
+                        ;; burnchain height when the unlock finishes.
+                        ;; derived from args[3]
+                        unlock-burn-height: (reward-cycle-to-burn-height (+ (current-pox-reward-cycle) u1 {lock_period})),
+                        ;; PoX address tuple.
+                        ;; equal to args[1].
+                        pox-addr: {pox_addr},
+                        ;; start of lock-up.
+                        ;; equal to args[2]
+                        start-burn-height: {start_burn_height},
+                        ;; how long to lock, in burn blocks
+                        ;; equal to args[3]
+                        lock-period: {lock_period}
+                    }}
+                }}
+                "#,
+                lock_amount = &args[0],
+                lock_period = &args[3],
+                pox_addr = &args[1],
+                start_burn_height = &args[2],
+            )
+        }
+        "delegate-stack-stx" => {
+            format!(
+                r#"
+                {{
+                    data: {{
+                        ;; amount of ustx to lock.
+                        ;; equal to args[1]
+                        lock-amount: {lock_amount},
+                        ;; burnchain height when the unlock finishes.
+                        ;; derived from args[4]
+                        unlock-burn-height: (reward-cycle-to-burn-height (+ (current-pox-reward-cycle) u1 {lock_period})),
+                        ;; PoX address tuple.
+                        ;; equal to args[2]
+                        pox-addr: {pox_addr},
+                        ;; start of lock-up
+                        ;; equal to args[3]
+                        start-burn-height: {start_burn_height},
+                        ;; how long to lock, in burn blocks
+                        ;; equal to args[3]
+                        lock-period: {lock_period},
+                        ;; delegator
+                        delegator: tx-sender,
+                        ;; stacker
+                        ;; equal to args[0]
+                        stacker: '{stacker}
+                    }}
+                }}
+                "#,
+                stacker = &args[0],
+                lock_amount = &args[1],
+                pox_addr = &args[2],
+                start_burn_height = &args[3],
+                lock_period = &args[4],
+            )
+        }
+        "stack-increase" => {
+            format!(
+                r#"
+                {{
+                    data: {{
+                        ;; amount to increase by
+                        ;; equal to args[0]
+                        increase-by: {increase_by},
+                        ;; new amount locked
+                        ;; NOTE: the lock has not yet been applied!
+                        ;; derived from args[0]
+                        total-locked: (+ {increase_by} (get locked (stx-account tx-sender))),
+                        ;; pox addr increased
+                        pox-addr: (get pox-addr (unwrap-panic (map-get? stacking-state {{ stacker: tx-sender }})))
+                    }}
+                }}
+                "#,
+                increase_by = &args[0]
+            )
+        }
+        "delegate-stack-increase" => {
+            format!(
+                r#"
+                {{
+                    data: {{
+                        ;; pox addr
+                        ;; equal to args[1]
+                        pox-addr: {pox_addr},
+                        ;; amount to increase by
+                        ;; equal to args[2]
+                        increase-by: {increase_by},
+                        ;; total amount locked now
+                        ;; NOTE: the lock itself has not yet been applied!
+                        ;; this is for the stacker, so args[0]
+                        total-locked: (+ {increase_by} (get locked (stx-account '{stacker}))),
+                        ;; delegator
+                        delegator: tx-sender,
+                        ;; stacker
+                        ;; equal to args[0]
+                        stacker: '{stacker}
+                    }}
+                }}
+                "#,
+                stacker = &args[0],
+                pox_addr = &args[1],
+                increase_by = &args[2],
+            )
+        }
+        "stack-extend" => {
+            format!(
+                r#"
+                (let (
+                    ;; variable declarations derived from pox-2
+                    (cur-cycle (current-pox-reward-cycle))
+                    (unlock-height (get unlock-height (stx-account tx-sender)))
+                    (unlock-in-cycle (burn-height-to-reward-cycle unlock-height))
+                    (first-extend-cycle
+                        (if (> (+ cur-cycle u1) unlock-in-cycle)
+                            (+ cur-cycle u1)
+                            unlock-in-cycle))
+                    (last-extend-cycle  (- (+ first-extend-cycle {extend_count}) u1))
+                    (new-unlock-ht (reward-cycle-to-burn-height (+ u1 last-extend-cycle)))
+                )
+                {{
+                    data: {{
+                        ;; pox addr extended
+                        ;; equal to args[1]
+                        pox-addr: {pox_addr},
+                        ;; number of cycles extended
+                        ;; equal to args[0]
+                        extend-count: {extend_count},
+                        ;; new unlock burnchain block height
+                        unlock-burn-height: new-unlock-ht
+                    }}
+                }})
+                "#,
+                extend_count = &args[0],
+                pox_addr = &args[1],
+            )
+        }
+        "delegate-stack-extend" => {
+            format!(
+                r#"
+                (let (
+                    (unlock-height (get unlock-height (stx-account '{stacker})))
+                    (unlock-in-cycle (burn-height-to-reward-cycle unlock-height))
+                    (cur-cycle (current-pox-reward-cycle))
+                    (first-extend-cycle
+                        (if (> (+ cur-cycle u1) unlock-in-cycle)
+                            (+ cur-cycle u1)
+                            unlock-in-cycle))
+                    (last-extend-cycle  (- (+ first-extend-cycle {extend_count}) u1))
+                    (new-unlock-ht (reward-cycle-to-burn-height (+ u1 last-extend-cycle)))
+                )
+                {{
+                    data: {{
+                        ;; pox addr extended
+                        ;; equal to args[1]
+                        pox-addr: {pox_addr},
+                        ;; number of cycles extended
+                        ;; equal to args[2]
+                        extend-count: {extend_count},
+                        ;; new unlock burnchain block height
+                        unlock-burn-height: new-unlock-ht,
+                        ;; delegator locking this up
+                        delegator: tx-sender,
+                        ;; stacker
+                        ;; equal to args[0]
+                        stacker: '{stacker}
+                    }}
+                }})
+                "#,
+                stacker = &args[0],
+                pox_addr = &args[1],
+                extend_count = &args[2]
+            )
+        }
+        "stack-aggregation-commit"
+        | "stack-aggregation-commit-indexed"
+        | "stack-aggregation-increase" => {
+            format!(
+                r#"
+                {{
+                    data: {{
+                        ;; pox addr locked up
+                        ;; equal to args[0] in all methods
+                        pox-addr: {pox_addr},
+                        ;; reward cycle locked up
+                        ;; equal to args[1] in all methods
+                        reward-cycle: {reward_cycle},
+                        ;; amount locked behind this PoX address by this method
+                        amount-ustx: (get stacked-amount
+                                        (unwrap-panic (map-get? logged-partial-stacked-by-cycle
+                                            {{ pox-addr: {pox_addr}, sender: tx-sender, reward-cycle: {reward_cycle} }}))),
+                        ;; delegator (this is the caller)
+                        delegator: tx-sender
+                    }}
+                }}
+                "#,
+                pox_addr = &args[0],
+                reward_cycle = &args[1]
+            )
+        }
+        "delegate-stx" => {
+            format!(
+                r#"
+                {{
+                    data: {{
+                        ;; amount of ustx to delegate.
+                        ;; equal to args[0]
+                        amount-ustx: {amount_ustx},
+                        ;; address of delegatee.
+                        ;; equal to args[1]
+                        delegate-to: '{delegate_to},
+                        ;; optional burnchain height when the delegation finishes.
+                        ;; derived from args[2]
+                        unlock-burn-height: {until_burn_height},
+                        ;; optional PoX address tuple.
+                        ;; equal to args[3].
+                        pox-addr: {pox_addr}
+                    }}
+                }}
+                "#,
+                amount_ustx = &args[0],
+                delegate_to = &args[1],
+                until_burn_height = &args[2],
+                pox_addr = &args[3],
+            )
+        }
+        _ => "{{ data: {{ unimplemented: true }} }}".into(),
+    }
+}
+
+/// Synthesize an events data tuple to return on the successful execution of a pox-2 or pox-3 stacking
+/// function.  It runs a series of Clarity queries against the PoX contract's data space (including
+/// calling PoX functions).
+pub fn synthesize_pox_2_or_3_event_info(
+    global_context: &mut GlobalContext,
+    contract_id: &QualifiedContractIdentifier,
+    sender_opt: Option<&PrincipalData>,
+    function_name: &str,
+    args: &[Value],
+) -> Result<Option<Value>, ClarityError> {
+    let sender = match sender_opt {
+        Some(sender) => sender,
+        None => {
+            return Ok(None);
+        }
+    };
+    let code_snippet_template_opt = match function_name {
+        "stack-stx"
+        | "delegate-stack-stx"
+        | "stack-extend"
+        | "delegate-stack-extend"
+        | "stack-increase"
+        | "delegate-stack-increase"
+        | "delegate-stx" => Some(create_event_info_stack_or_delegate_code(
+            sender,
+            function_name,
+            args,
+        )),
+        "stack-aggregation-commit"
+        | "stack-aggregation-commit-indexed"
+        | "stack-aggregation-increase" => Some(create_event_info_aggregation_code(function_name)),
+        _ => None,
+    };
+    let code_snippet = match code_snippet_template_opt {
+        Some(x) => x,
+        None => return Ok(None),
+    };
+
+    let data_snippet = create_event_info_data_code(function_name, args);
+
+    test_debug!("Evaluate snippet:\n{}", &code_snippet);
+    test_debug!("Evaluate data code:\n{}", &data_snippet);
+
+    let pox_2_contract = global_context.database.get_contract(contract_id)?;
+
+    let event_info = global_context
+        .special_cc_handler_execute_read_only(
+            sender.clone(),
+            None,
+            pox_2_contract.contract_context,
+            |env| {
+                let base_event_info = env
+                    .eval_read_only_with_rules(contract_id, &code_snippet, ASTRules::PrecheckSize)
+                    .map_err(|e| {
+                        error!(
+                            "Failed to run event-info code snippet for '{}': {:?}",
+                            function_name, &e
+                        );
+                        e
+                    })?;
+
+                let data_event_info = env
+                    .eval_read_only_with_rules(contract_id, &data_snippet, ASTRules::PrecheckSize)
+                    .map_err(|e| {
+                        error!(
+                            "Failed to run data-info code snippet for '{}': {:?}",
+                            function_name, &e
+                        );
+                        e
+                    })?;
+
+                // merge them
+                let base_event_tuple = base_event_info
+                    .expect_tuple()
+                    .expect("FATAL: unexpected clarity value");
+                let data_tuple = data_event_info
+                    .expect_tuple()
+                    .expect("FATAL: unexpected clarity value");
+                let event_tuple =
+                    TupleData::shallow_merge(base_event_tuple, data_tuple).map_err(|e| {
+                        error!("Failed to merge data-info and event-info: {:?}", &e);
+                        e
+                    })?;
+
+                Ok(Value::Tuple(event_tuple))
+            },
+        )
+        .map_err(|e: ClarityError| {
+            error!("Failed to synthesize PoX event: {:?}", &e);
+            e
+        })?;
+
+    test_debug!(
+        "Synthesized PoX event info for '{}''s call to '{}': {:?}",
+        sender,
+        function_name,
+        &event_info
+    );
+    Ok(Some(event_info))
+}
diff --git a/pox-locking/src/lib.rs b/pox-locking/src/lib.rs
index 90f625f3ab..63380212dc 100644
--- a/pox-locking/src/lib.rs
+++ b/pox-locking/src/lib.rs
@@ -35,6 +35,7 @@ use stacks_common::types::StacksEpochId;
 use stacks_common::warn;
 
 mod events;
+mod events_24;
 mod pox_1;
 mod pox_2;
 mod pox_3;

From 999fe9bd29cde5a3b248e2ece1b2511bcfaa1731 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Tue, 13 Feb 2024 12:57:11 -0600
Subject: [PATCH 0746/1166] fix: pox-3 to pox-4 auto-unlock height should be
 epoch 2.5 *not* 2.4

---
 clarity/src/vm/database/clarity_db.rs | 2 +-
 stackslib/src/core/mod.rs             | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/clarity/src/vm/database/clarity_db.rs b/clarity/src/vm/database/clarity_db.rs
index fcacaf0002..3d6cf40ae6 100644
--- a/clarity/src/vm/database/clarity_db.rs
+++ b/clarity/src/vm/database/clarity_db.rs
@@ -916,7 +916,7 @@ impl<'a> ClarityDatabase<'a> {
     /// Return the height for PoX v3 -> v4 auto unlocks
     ///   from the burn state db
     pub fn get_v3_unlock_height(&mut self) -> Result<u32> {
-        if self.get_clarity_epoch_version()? >= StacksEpochId::Epoch24 {
+        if self.get_clarity_epoch_version()? >= StacksEpochId::Epoch25 {
             Ok(self.burn_state_db.get_v3_unlock_height())
         } else {
             Ok(u32::MAX)
diff --git a/stackslib/src/core/mod.rs b/stackslib/src/core/mod.rs
index 38f383194e..2280fe6d71 100644
--- a/stackslib/src/core/mod.rs
+++ b/stackslib/src/core/mod.rs
@@ -188,9 +188,9 @@ pub const POX_V2_TESTNET_EARLY_UNLOCK_HEIGHT: u32 =
     (BITCOIN_TESTNET_STACKS_22_BURN_HEIGHT as u32) + 1;
 
 pub const POX_V3_MAINNET_EARLY_UNLOCK_HEIGHT: u32 =
-    (BITCOIN_MAINNET_STACKS_24_BURN_HEIGHT as u32) + 1;
+    (BITCOIN_MAINNET_STACKS_25_BURN_HEIGHT as u32) + 1;
 pub const POX_V3_TESTNET_EARLY_UNLOCK_HEIGHT: u32 =
-    (BITCOIN_TESTNET_STACKS_24_BURN_HEIGHT as u32) + 1;
+    (BITCOIN_TESTNET_STACKS_25_BURN_HEIGHT as u32) + 1;
 
 /// Burn block height at which the ASTRules::PrecheckSize becomes the default behavior on mainnet
 pub const AST_RULES_PRECHECK_SIZE: u64 = 752000; // on or about Aug 30 2022

From 5415e388804d0877ce50a242cf3660c82b130b89 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 13 Feb 2024 14:59:19 -0500
Subject: [PATCH 0747/1166] feat: more efficient query to see that a sortiiton
 with a given consensus hash was processed

---
 stackslib/src/chainstate/burn/db/sortdb.rs | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/stackslib/src/chainstate/burn/db/sortdb.rs b/stackslib/src/chainstate/burn/db/sortdb.rs
index 0be1c77487..7479461e6c 100644
--- a/stackslib/src/chainstate/burn/db/sortdb.rs
+++ b/stackslib/src/chainstate/burn/db/sortdb.rs
@@ -4556,6 +4556,22 @@ impl SortitionDB {
         })
     }
 
+    /// Determine if a burnchain block has been processed
+    pub fn has_block_snapshot_consensus(
+        conn: &Connection,
+        consensus_hash: &ConsensusHash,
+    ) -> Result<bool, db_error> {
+        let qry = "SELECT 1 FROM snapshots WHERE consensus_hash = ?1";
+        let args = [&consensus_hash];
+        let res: Option<i64> = query_row_panic(conn, qry, &args, || {
+            format!(
+                "FATAL: multiple block snapshots for the same block with consensus hash {}",
+                consensus_hash
+            )
+        })?;
+        Ok(res.is_some())
+    }
+
     /// Get a snapshot for an processed sortition.
     /// The snapshot may not be valid
     pub fn get_block_snapshot(

From 7087fff3d4d38f16e62cd62ae6c6176d166ec138 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 13 Feb 2024 14:59:49 -0500
Subject: [PATCH 0748/1166] feat: separate out staging blocks DB from headers
 DB, so we can write to one without blocking writes to the other. This
 required some changes in how we handle processed blocks, but as long as
 there's a single thread responsible for finding and processing blocks, we
 should be fine

---
 stackslib/src/chainstate/nakamoto/mod.rs | 601 ++++++++++++++++++-----
 1 file changed, 465 insertions(+), 136 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index 4d197e11cb..41d0fcb907 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -15,7 +15,9 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::collections::{BTreeMap, HashMap, HashSet};
-use std::ops::DerefMut;
+use std::fs;
+use std::ops::{Deref, DerefMut};
+use std::path::PathBuf;
 
 use clarity::vm::ast::ASTRules;
 use clarity::vm::costs::{ExecutionCost, LimitedCostTracker};
@@ -25,7 +27,7 @@ use clarity::vm::types::{PrincipalData, StacksAddressExtensions, TupleData};
 use clarity::vm::{ClarityVersion, SymbolicExpression, Value};
 use lazy_static::{__Deref, lazy_static};
 use rusqlite::types::{FromSql, FromSqlError};
-use rusqlite::{params, Connection, OptionalExtension, ToSql, NO_PARAMS};
+use rusqlite::{params, Connection, OpenFlags, OptionalExtension, ToSql, NO_PARAMS};
 use sha2::{Digest as Sha2Digest, Sha512_256};
 use stacks_common::bitvec::BitVec;
 use stacks_common::codec::{
@@ -40,11 +42,11 @@ use stacks_common::types::chainstate::{
     StacksPrivateKey, StacksPublicKey, TrieHash, VRFSeed,
 };
 use stacks_common::types::{PrivateKey, StacksEpochId};
-use stacks_common::util::get_epoch_time_secs;
 use stacks_common::util::hash::{to_hex, Hash160, MerkleHashFunc, MerkleTree, Sha512Trunc256Sum};
 use stacks_common::util::retry::BoundReader;
 use stacks_common::util::secp256k1::MessageSignature;
 use stacks_common::util::vrf::{VRFProof, VRFPublicKey, VRF};
+use stacks_common::util::{get_epoch_time_secs, sleep_ms};
 use wsts::curve::point::Point;
 
 use self::signer_set::SignerCalculation;
@@ -92,8 +94,8 @@ use crate::net::Error as net_error;
 use crate::util_lib::boot;
 use crate::util_lib::boot::boot_code_id;
 use crate::util_lib::db::{
-    query_int, query_row, query_row_panic, query_rows, u64_to_sql, DBConn, Error as DBError,
-    FromRow,
+    query_int, query_row, query_row_panic, query_rows, sqlite_open, tx_begin_immediate, u64_to_sql,
+    DBConn, Error as DBError, FromRow,
 };
 use crate::{chainstate, monitoring};
 
@@ -127,10 +129,9 @@ impl FromSql for HeaderTypeNames {
 lazy_static! {
     pub static ref FIRST_STACKS_BLOCK_ID: StacksBlockId = StacksBlockId::new(&FIRST_BURNCHAIN_CONSENSUS_HASH, &FIRST_STACKS_BLOCK_HASH);
 
-    pub static ref NAKAMOTO_CHAINSTATE_SCHEMA_1: Vec<String> = vec![
-    r#"
+    pub static ref NAKAMOTO_STAGING_DB_SCHEMA_1: Vec<String> = vec![
+      r#"
       -- Table for staging nakamoto blocks
-      -- TODO: this goes into its own DB at some point
       CREATE TABLE nakamoto_staging_blocks (
                      -- SHA512/256 hash of this block
                      block_hash TEXT NOT NULL,
@@ -141,12 +142,10 @@ lazy_static! {
 
                      -- has the burnchain block with this block's `consensus_hash` been processed?
                      burn_attachable INT NOT NULL,
-                     -- has the parent Stacks block been processed?
-                     stacks_attachable INT NOT NULL,
-                     -- set to 1 if this block can never be attached
-                     orphaned INT NOT NULL,
                      -- has this block been processed?
                      processed INT NOT NULL,
+                     -- set to 1 if this block can never be attached
+                     orphaned INT NOT NULL,
 
                      height INT NOT NULL,
 
@@ -163,7 +162,12 @@ lazy_static! {
                      data BLOB NOT NULL,
                     
                      PRIMARY KEY(block_hash,consensus_hash)
-    );"#.into(),
+        );"#
+        .into(),
+        r#"CREATE INDEX by_index_block_hash ON nakamoto_staging_blocks(index_block_hash);"#.into()
+    ];
+
+    pub static ref NAKAMOTO_CHAINSTATE_SCHEMA_1: Vec<String> = vec![
     r#"
     -- Table for storing calculated reward sets. This must be in the Chainstate DB because calculation occurs
     --   during block processing.
@@ -1176,14 +1180,134 @@ impl NakamotoBlock {
     }
 }
 
+pub struct NakamotoStagingBlocksConn(rusqlite::Connection);
+
+impl Deref for NakamotoStagingBlocksConn {
+    type Target = rusqlite::Connection;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for NakamotoStagingBlocksConn {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl NakamotoStagingBlocksConn {
+    pub fn conn(&self) -> NakamotoStagingBlocksConnRef {
+        NakamotoStagingBlocksConnRef(&self.0)
+    }
+}
+
+pub struct NakamotoStagingBlocksConnRef<'a>(&'a rusqlite::Connection);
+
+impl<'a> NakamotoStagingBlocksConnRef<'a> {
+    pub fn conn(&self) -> NakamotoStagingBlocksConnRef<'a> {
+        NakamotoStagingBlocksConnRef(self.0)
+    }
+}
+
+impl Deref for NakamotoStagingBlocksConnRef<'_> {
+    type Target = rusqlite::Connection;
+    fn deref(&self) -> &Self::Target {
+        self.0
+    }
+}
+
+pub struct NakamotoStagingBlocksTx<'a>(rusqlite::Transaction<'a>);
+
+impl<'a> NakamotoStagingBlocksTx<'a> {
+    pub fn commit(self) -> Result<(), rusqlite::Error> {
+        self.0.commit()
+    }
+
+    pub fn conn(&self) -> NakamotoStagingBlocksConnRef {
+        NakamotoStagingBlocksConnRef(self.0.deref())
+    }
+}
+
+impl<'a> Deref for NakamotoStagingBlocksTx<'a> {
+    type Target = rusqlite::Transaction<'a>;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl<'a> DerefMut for NakamotoStagingBlocksTx<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
 impl StacksChainState {
     /// Begin a transaction against the staging blocks DB.
     /// Note that this DB is (or will eventually be) in a separate database from the headers.
     pub fn staging_db_tx_begin<'a>(
         &'a mut self,
-    ) -> Result<rusqlite::Transaction<'a>, ChainstateError> {
-        // TODO: this should be against a separate DB!
-        self.db_tx_begin()
+    ) -> Result<NakamotoStagingBlocksTx<'a>, ChainstateError> {
+        let tx = tx_begin_immediate(&mut self.nakamoto_staging_blocks_conn)?;
+        Ok(NakamotoStagingBlocksTx(tx))
+    }
+
+    /// Begin a tx to both the headers DB and the staging DB
+    pub fn headers_and_staging_tx_begin<'a>(
+        &'a mut self,
+    ) -> Result<(rusqlite::Transaction<'a>, NakamotoStagingBlocksTx<'a>), ChainstateError> {
+        let header_tx = self
+            .state_index
+            .storage_tx()
+            .map_err(ChainstateError::DBError)?;
+        let staging_tx = tx_begin_immediate(&mut self.nakamoto_staging_blocks_conn)?;
+        Ok((header_tx, NakamotoStagingBlocksTx(staging_tx)))
+    }
+
+    /// Get a ref to the nakamoto staging blocks connection
+    pub fn nakamoto_blocks_db(&self) -> NakamotoStagingBlocksConnRef {
+        NakamotoStagingBlocksConnRef(&self.nakamoto_staging_blocks_conn)
+    }
+
+    /// Get the path to the Nakamoto staging blocks DB.
+    /// It's separate from the headers DB in order to avoid DB contention between downloading
+    /// blocks and processing them.
+    pub fn get_nakamoto_staging_blocks_path(root_path: PathBuf) -> Result<String, ChainstateError> {
+        let mut nakamoto_blocks_path = Self::blocks_path(root_path);
+        nakamoto_blocks_path.push("nakamoto.sqlite");
+        Ok(nakamoto_blocks_path
+            .to_str()
+            .ok_or(ChainstateError::DBError(DBError::ParseError))?
+            .to_string())
+    }
+
+    /// Open and set up a DB for nakamoto staging blocks.
+    /// If it doesn't exist, then instantiate it if `readwrite` is true.
+    pub fn open_nakamoto_staging_blocks(
+        path: &str,
+        readwrite: bool,
+    ) -> Result<NakamotoStagingBlocksConn, ChainstateError> {
+        let exists = fs::metadata(&path).is_ok();
+        let flags = if !exists {
+            // try to instantiate
+            if readwrite {
+                OpenFlags::SQLITE_OPEN_READ_WRITE | OpenFlags::SQLITE_OPEN_CREATE
+            } else {
+                return Err(DBError::NotFoundError.into());
+            }
+        } else {
+            if readwrite {
+                OpenFlags::SQLITE_OPEN_READ_WRITE
+            } else {
+                OpenFlags::SQLITE_OPEN_READ_ONLY
+            }
+        };
+        let conn = sqlite_open(path, flags, false)?;
+        if !exists {
+            for cmd in NAKAMOTO_STAGING_DB_SCHEMA_1.iter() {
+                conn.execute(cmd, NO_PARAMS)?;
+            }
+        }
+        Ok(NakamotoStagingBlocksConn(conn))
     }
 }
 
@@ -1192,13 +1316,9 @@ impl NakamotoChainState {
     /// This will update the attachable status for children blocks, as well as marking the stacks
     ///  block itself as processed.
     pub fn set_block_processed(
-        staging_db_tx: &rusqlite::Transaction,
+        staging_db_tx: &NakamotoStagingBlocksTx,
         block: &StacksBlockId,
     ) -> Result<(), ChainstateError> {
-        let update_dependents = "UPDATE nakamoto_staging_blocks SET stacks_attachable = 1
-                                 WHERE parent_block_id = ?";
-        staging_db_tx.execute(&update_dependents, &[&block])?;
-
         let clear_staged_block =
             "UPDATE nakamoto_staging_blocks SET processed = 1, processed_time = ?2
                                   WHERE index_block_hash = ?1";
@@ -1212,14 +1332,14 @@ impl NakamotoChainState {
 
     /// Modify the staging database that a given stacks block can never be processed.
     /// This will update the attachable status for children blocks, as well as marking the stacks
-    ///  block itself as orphaned.
+    /// block itself as orphaned.
     pub fn set_block_orphaned(
-        staging_db_tx: &rusqlite::Transaction,
+        staging_db_tx: &NakamotoStagingBlocksTx,
         block: &StacksBlockId,
     ) -> Result<(), ChainstateError> {
-        let update_dependents =
-            "UPDATE nakamoto_staging_blocks SET stacks_attachable = 0, orphaned = 1
+        let update_dependents = "UPDATE nakamoto_staging_blocks SET orphaned = 1
                                  WHERE parent_block_id = ?";
+
         staging_db_tx.execute(&update_dependents, &[&block])?;
 
         let clear_staged_block =
@@ -1236,7 +1356,7 @@ impl NakamotoChainState {
     /// Notify the staging database that a given burn block has been processed.
     /// This is required for staged blocks to be eligible for processing.
     pub fn set_burn_block_processed(
-        staging_db_tx: &rusqlite::Transaction,
+        staging_db_tx: &NakamotoStagingBlocksTx,
         consensus_hash: &ConsensusHash,
     ) -> Result<(), ChainstateError> {
         let update_dependents = "UPDATE nakamoto_staging_blocks SET burn_attachable = 1
@@ -1246,17 +1366,78 @@ impl NakamotoChainState {
         Ok(())
     }
 
+    /// Check to see if a block with a given consensus hash is burn-attachable
+    pub fn is_burn_attachable(
+        staging_db_conn: NakamotoStagingBlocksConnRef,
+        consensus_hash: &ConsensusHash,
+    ) -> Result<bool, ChainstateError> {
+        let sql = "SELECT 1 FROM nakamoto_staging_blocks WHERE burn_attachable = 1 AND consensus_hash = ?1";
+        let args: &[&dyn ToSql] = &[consensus_hash];
+        let res: Option<i64> = query_row(&staging_db_conn, sql, args)?;
+        Ok(res.is_some())
+    }
+
+    /// Determine whether or not we have processed a Nakamoto block.
+    /// NOTE: the relevant field queried from `nakamoto_staging_blocks` is updated by a separate
+    /// tx from block-processing, so it's imperative that the thread that calls this function is
+    /// the *same* thread as the one that processes blocks.
+    /// Returns Ok(true) if at least one block in `nakamoto_staging_blocks` has `processed = 1`
+    /// Returns Ok(false) if not
+    /// Returns Err(..) on DB error
+    fn has_processed_nakamoto_block(
+        staging_db_conn: NakamotoStagingBlocksConnRef,
+    ) -> Result<bool, ChainstateError> {
+        let qry = "SELECT 1 FROM nakamoto_staging_blocks WHERE processed = 1 LIMIT 1";
+        let res: Option<i64> = query_row(&staging_db_conn, qry, NO_PARAMS)?;
+        Ok(res.is_some())
+    }
+
+    /// Get a Nakamoto block by index block hash, as well as its size.
+    /// Verifies its integrity.
+    /// Returns Ok(Some(block, size)) if the block was present
+    /// Returns Ok(None) if there were no such rows.
+    /// Returns Err(..) on DB error, including block corruption
+    pub fn get_nakamoto_block(
+        staging_db_conn: NakamotoStagingBlocksConnRef,
+        index_block_hash: &StacksBlockId,
+    ) -> Result<Option<(NakamotoBlock, u64)>, ChainstateError> {
+        let qry = "SELECT data FROM nakamoto_staging_blocks WHERE index_block_hash = ?1";
+        let args: &[&dyn ToSql] = &[index_block_hash];
+        let res: Option<Vec<u8>> = query_row(&staging_db_conn, qry, args)?;
+        let Some(block_bytes) = res else {
+            return Ok(None);
+        };
+        let block = NakamotoBlock::consensus_deserialize(&mut block_bytes.as_slice())?;
+        if &block.header.block_id() != index_block_hash {
+            error!(
+                "Staging DB corruption: expected {}, got {}",
+                index_block_hash,
+                &block.header.block_id()
+            );
+            return Err(DBError::Corruption.into());
+        }
+        Ok(Some((
+            block,
+            u64::try_from(block_bytes.len()).expect("FATAL: block is greater than a u64"),
+        )))
+    }
+
     /// Find the next ready-to-process Nakamoto block, given a connection to the staging blocks DB.
+    /// NOTE: the relevant field queried from `nakamoto_staging_blocks` are updated by a separate
+    /// tx from block-processing, so it's imperative that the thread that calls this function is
+    /// the *same* thread that goes to process blocks.
     /// Returns (the block, the size of the block)
-    pub fn next_ready_nakamoto_block(
-        staging_db_conn: &Connection,
+    pub(crate) fn next_ready_nakamoto_block(
+        staging_db_conn: NakamotoStagingBlocksConnRef,
+        header_conn: &Connection,
     ) -> Result<Option<(NakamotoBlock, u64)>, ChainstateError> {
-        let query = "SELECT data FROM nakamoto_staging_blocks
-                     WHERE burn_attachable = 1
-                       AND stacks_attachable = 1
-                       AND orphaned = 0
-                       AND processed = 0
-                     ORDER BY height ASC";
+        let query = "SELECT child.data FROM nakamoto_staging_blocks child JOIN nakamoto_staging_blocks parent
+                     ON child.parent_block_id = parent.index_block_hash
+                     WHERE child.burn_attachable = 1
+                       AND child.orphaned = 0
+                       AND child.processed = 0
+                       AND parent.processed = 1
+                     ORDER BY child.height ASC";
         staging_db_conn
             .query_row_and_then(query, NO_PARAMS, |row| {
                 let data: Vec<u8> = row.get("data")?;
@@ -1271,7 +1452,43 @@ impl NakamotoChainState {
                     rusqlite::Error::QueryReturnedNoRows,
                 )) = e
                 {
-                    Ok(None)
+                    // if at least one nakamoto block is processed, then the next ready block's
+                    // parent *must* be a Nakamoto block.  So if the below is true, then there are
+                    // no ready blocks.
+                    if Self::has_processed_nakamoto_block(staging_db_conn.conn())? {
+                        return Ok(None);
+                    }
+
+                    // no nakamoto blocks processed yet, so the parent *must* be an epoch2 block!
+                    // go find it.  Note that while this is expensive, it only has to be done
+                    // _once_, and it will only touch at most one reward cycle's worth of blocks.
+                    let sql = "SELECT index_block_hash,parent_block_id FROM nakamoto_staging_blocks WHERE processed = 0 AND orphaned = 0 AND burn_attachable = 1 ORDER BY height ASC";
+                    let mut stmt = staging_db_conn.deref().prepare(sql)?;
+                    let mut qry = stmt.query(NO_PARAMS)?;
+                    let mut next_nakamoto_block_id = None;
+                    while let Some(row) = qry.next()? {
+                        let index_block_hash : StacksBlockId = row.get(0)?;
+                        let parent_block_id : StacksBlockId = row.get(1)?;
+
+                        let Some(_parent_epoch2_block) = Self::get_block_header_epoch2(header_conn, &parent_block_id)? else {
+                            continue;
+                        };
+
+                        // epoch2 parent exists, so this Nakamoto block is processable!
+                        next_nakamoto_block_id = Some(index_block_hash);
+                        break;
+                    }
+                    let Some(next_nakamoto_block_id) = next_nakamoto_block_id else {
+                        // no stored nakamoto block had an epoch2 parent
+                        return Ok(None);
+                    };
+
+                    // need qry and stmt to stop borrowing staging_db_conn before we can use it
+                    // again
+                    drop(qry);
+                    drop(stmt);
+
+                    Self::get_nakamoto_block(staging_db_conn, &next_nakamoto_block_id)
                 } else {
                     Err(e)
                 }
@@ -1280,40 +1497,15 @@ impl NakamotoChainState {
 
     /// Extract and parse a nakamoto block from the DB, and verify its integrity.
     pub fn load_nakamoto_block(
-        staging_db_conn: &Connection,
+        staging_db_conn: NakamotoStagingBlocksConnRef,
         consensus_hash: &ConsensusHash,
         block_hash: &BlockHeaderHash,
     ) -> Result<Option<NakamotoBlock>, ChainstateError> {
-        let query = "SELECT data FROM nakamoto_staging_blocks WHERE consensus_hash = ?1 AND block_hash = ?2";
-        staging_db_conn
-            .query_row_and_then(
-                query,
-                rusqlite::params![consensus_hash, block_hash],
-                |row| {
-                    let data: Vec<u8> = row.get("data")?;
-                    let block = NakamotoBlock::consensus_deserialize(&mut data.as_slice())
-                        .map_err(|_| DBError::ParseError)?;
-                    if &block.header.block_hash() != block_hash {
-                        error!(
-                            "Staging DB corruption: expected {}, got {}",
-                            &block_hash,
-                            &block.header.block_hash()
-                        );
-                        return Err(DBError::Corruption.into());
-                    }
-                    Ok(Some(block))
-                },
-            )
-            .or_else(|e| {
-                if let ChainstateError::DBError(DBError::SqliteError(
-                    rusqlite::Error::QueryReturnedNoRows,
-                )) = e
-                {
-                    Ok(None)
-                } else {
-                    Err(e.into())
-                }
-            })
+        Self::get_nakamoto_block(
+            staging_db_conn,
+            &StacksBlockId::new(consensus_hash, block_hash),
+        )
+        .and_then(|block_size_opt| Ok(block_size_opt.map(|(block, _size)| block)))
     }
 
     /// Process the next ready block.
@@ -1327,9 +1519,10 @@ impl NakamotoChainState {
         sort_tx: &mut SortitionHandleTx,
         dispatcher_opt: Option<&'a T>,
     ) -> Result<Option<StacksEpochReceipt>, ChainstateError> {
-        let (mut chainstate_tx, clarity_instance) = stacks_chain_state.chainstate_tx_begin()?;
-        let Some((next_ready_block, block_size)) =
-            Self::next_ready_nakamoto_block(&chainstate_tx.tx)?
+        let Some((next_ready_block, block_size)) = Self::next_ready_nakamoto_block(
+            stacks_chain_state.nakamoto_blocks_db(),
+            stacks_chain_state.db(),
+        )?
         else {
             // no more blocks
             return Ok(None);
@@ -1354,6 +1547,8 @@ impl NakamotoChainState {
                "burn_block_hash" => %next_ready_block_snapshot.burn_header_hash
         );
 
+        let (mut chainstate_tx, clarity_instance) = stacks_chain_state.chainstate_tx_begin()?;
+
         // find parent header
         let Some(parent_header_info) =
             Self::get_block_header(&chainstate_tx.tx, &next_ready_block.header.parent_block_id)?
@@ -1373,13 +1568,16 @@ impl NakamotoChainState {
             &parent_header_info.anchored_header.block_hash(),
         );
         if parent_block_id != next_ready_block.header.parent_block_id {
+            drop(chainstate_tx);
+
             let msg = "Discontinuous Nakamoto Stacks block";
             warn!("{}", &msg;
                   "child parent_block_id" => %next_ready_block.header.parent_block_id,
                   "expected parent_block_id" => %parent_block_id
             );
-            let _ = Self::set_block_orphaned(&chainstate_tx.tx, &block_id);
-            chainstate_tx.commit()?;
+            let staging_block_tx = stacks_chain_state.staging_db_tx_begin()?;
+            let _ = Self::set_block_orphaned(&staging_block_tx, &block_id)?;
+            staging_block_tx.commit()?;
             return Err(ChainstateError::InvalidStacksBlock(msg.into()));
         }
 
@@ -1410,7 +1608,17 @@ impl NakamotoChainState {
 
         // attach the block to the chain state and calculate the next chain tip.
         let pox_constants = sort_tx.context.pox_constants.clone();
-        let (receipt, clarity_commit) = match NakamotoChainState::append_block(
+
+        // NOTE: because block status is updated in a separate transaction, we need `chainstate_tx`
+        // and `clarity_instance` to go out of scope before we can issue the it (since we need a
+        // mutable reference to `stacks_chain_state` to start it).  This means ensuring that, in the
+        // `Ok(..)` case, the `clarity_commit` gets dropped beforehand.  In order to do this, we first
+        // run `::append_block()` here, and capture both the Ok(..) and Err(..) results as
+        // Option<..>'s.  Then, if we errored, we can explicitly drop the `Ok(..)` option (even
+        // though it will always be None), which gets the borrow-checker to believe that it's safe
+        // to access `stacks_chain_state` again.  In the `Ok(..)` case, it's instead sufficient so
+        // simply commit the block before beginning the second transaction to mark it processed.
+        let (ok_opt, err_opt) = match NakamotoChainState::append_block(
             &mut chainstate_tx,
             clarity_instance,
             sort_tx,
@@ -1427,20 +1635,66 @@ impl NakamotoChainState {
             commit_burn,
             sortition_burn,
         ) {
-            Ok(next_chain_tip_info) => next_chain_tip_info,
-            Err(e) => {
-                test_debug!(
-                    "Failed to append {}/{}: {:?}",
-                    &next_ready_block.header.consensus_hash,
-                    &next_ready_block.header.block_hash(),
-                    &e
-                );
-                let _ = Self::set_block_orphaned(&chainstate_tx.tx, &block_id);
-                chainstate_tx.commit()?;
-                return Err(e);
+            Ok(next_chain_tip_info) => (Some(next_chain_tip_info), None),
+            Err(e) => (None, Some(e)),
+        };
+
+        if let Some(e) = err_opt {
+            // force rollback
+            drop(ok_opt);
+            drop(chainstate_tx);
+
+            warn!(
+                "Failed to append {}/{}: {:?}",
+                &next_ready_block.header.consensus_hash,
+                &next_ready_block.header.block_hash(),
+                &e
+            );
+
+            // as a separate transaction, mark this block as processed and orphaned.
+            // This is done separately so that the staging blocks DB, which receives writes
+            // from the network to store blocks, will be available for writes while a block is
+            // being processed. Therefore, it's *very important* that block-processing happens
+            // within the same, single thread.  Also, it's *very important* that this update
+            // succeeds, since *we have already processed* the block.
+
+            loop {
+                let Ok(staging_block_tx) = stacks_chain_state.staging_db_tx_begin().map_err(|e| {
+                    warn!("Failed to begin staging DB tx: {:?}", &e);
+                    e
+                }) else {
+                    sleep_ms(1000);
+                    continue;
+                };
+
+                let Ok(_) = NakamotoChainState::set_block_orphaned(&staging_block_tx, &block_id)
+                    .map_err(|e| {
+                        warn!("Failed to mark {} as orphaned: {:?}", &block_id, &e);
+                        e
+                    })
+                else {
+                    sleep_ms(1000);
+                    continue;
+                };
+
+                let Ok(_) = staging_block_tx.commit().map_err(|e| {
+                    warn!(
+                        "Failed to commit staging block tx for {}: {:?}",
+                        &block_id, &e
+                    );
+                    e
+                }) else {
+                    sleep_ms(1000);
+                    continue;
+                };
+
+                break;
             }
+            return Err(e);
         };
 
+        let (receipt, clarity_commit) = ok_opt.expect("FATAL: unreachable");
+
         assert_eq!(
             receipt.header.anchored_header.block_hash(),
             next_ready_block.header.block_hash()
@@ -1457,6 +1711,54 @@ impl NakamotoChainState {
             next_ready_block.header.chain_length,
         )?;
 
+        // this will panic if the Clarity commit fails.
+        clarity_commit.commit();
+        chainstate_tx.commit()
+            .unwrap_or_else(|e| {
+                error!("Failed to commit chainstate transaction after committing Clarity block. The chainstate database is now corrupted.";
+                       "error" => ?e);
+                panic!()
+            });
+
+        // as a separate transaction, mark this block as processed.
+        // This is done separately so that the staging blocks DB, which receives writes
+        // from the network to store blocks, will be available for writes while a block is
+        // being processed. Therefore, it's *very important* that block-processing happens
+        // within the same, single thread.  Also, it's *very important* that this update
+        // succeeds, since *we have already processed* the block.
+        loop {
+            let Ok(staging_block_tx) = stacks_chain_state.staging_db_tx_begin().map_err(|e| {
+                warn!("Failed to begin staging DB tx: {:?}", &e);
+                e
+            }) else {
+                sleep_ms(1000);
+                continue;
+            };
+
+            let Ok(_) = NakamotoChainState::set_block_processed(&staging_block_tx, &block_id)
+                .map_err(|e| {
+                    warn!("Failed to mark {} as processed: {:?}", &block_id, &e);
+                    e
+                })
+            else {
+                sleep_ms(1000);
+                continue;
+            };
+
+            let Ok(_) = staging_block_tx.commit().map_err(|e| {
+                warn!(
+                    "Failed to commit staging block tx for {}: {:?}",
+                    &block_id, &e
+                );
+                e
+            }) else {
+                sleep_ms(1000);
+                continue;
+            };
+
+            break;
+        }
+
         // announce the block, if we're connected to an event dispatcher
         if let Some(dispatcher) = dispatcher_opt {
             let block_event = (
@@ -1481,15 +1783,6 @@ impl NakamotoChainState {
             );
         }
 
-        // this will panic if the Clarity commit fails.
-        clarity_commit.commit();
-        chainstate_tx.commit()
-            .unwrap_or_else(|e| {
-                error!("Failed to commit chainstate transaction after committing Clarity block. The chainstate database is now corrupted.";
-                       "error" => ?e);
-                panic!()
-            });
-
         Ok(Some(receipt))
     }
 
@@ -1644,10 +1937,9 @@ impl NakamotoChainState {
 
     /// Insert a Nakamoto block into the staging blocks DB
     pub(crate) fn store_block(
-        staging_db_tx: &rusqlite::Transaction,
+        staging_db_tx: &NakamotoStagingBlocksTx,
         block: NakamotoBlock,
         burn_attachable: bool,
-        stacks_attachable: bool,
     ) -> Result<(), ChainstateError> {
         let block_id = block.block_id();
         staging_db_tx.execute(
@@ -1656,7 +1948,6 @@ impl NakamotoChainState {
                      consensus_hash,
                      parent_block_id,
                      burn_attachable,
-                     stacks_attachable,
                      orphaned,
                      processed,
 
@@ -1666,13 +1957,12 @@ impl NakamotoChainState {
                      arrival_time,
                      processed_time,
                      data
-            ) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13)",
+            ) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12)",
             params![
                 &block.header.block_hash(),
                 &block.header.consensus_hash,
                 &block.header.parent_block_id,
                 if burn_attachable { 1 } else { 0 },
-                if stacks_attachable { 1 } else { 0 },
                 0,
                 0,
                 u64_to_sql(block.header.chain_length)?,
@@ -1683,6 +1973,9 @@ impl NakamotoChainState {
                 block.serialize_to_vec(),
             ],
         )?;
+        if burn_attachable {
+            Self::set_burn_block_processed(staging_db_tx, &block.header.consensus_hash)?;
+        }
         Ok(())
     }
 
@@ -1698,8 +1991,7 @@ impl NakamotoChainState {
         config: &ChainstateConfig,
         block: NakamotoBlock,
         db_handle: &mut SortitionHandleConn,
-        // TODO: need a separate connection for the headers
-        staging_db_tx: &rusqlite::Transaction,
+        staging_db_tx: &NakamotoStagingBlocksTx,
         aggregate_public_key: &Point,
     ) -> Result<bool, ChainstateError> {
         test_debug!("Consider Nakamoto block {}", &block.block_id());
@@ -1764,34 +2056,11 @@ impl NakamotoChainState {
 
         // if the burnchain block of this Stacks block's tenure has been processed, then it
         // is ready to be processed from the perspective of the burnchain
-        let burn_attachable = db_handle.processed_block(&block.header.consensus_hash)?;
-
-        // check if the parent Stacks Block ID has been processed. if so, then this block is stacks_attachable
-        let stacks_attachable =
-            // block is the first-ever mined (test only)
-            block.is_first_mined()
-            // block attaches to a processed nakamoto block
-            || staging_db_tx.query_row(
-                "SELECT 1 FROM nakamoto_staging_blocks WHERE index_block_hash = ? AND processed = 1 AND orphaned = 0",
-                rusqlite::params![&block.header.parent_block_id],
-                |_row| Ok(())
-            ).optional()?.is_some()
-            // block attaches to a Stacks epoch 2.x block, and there are no nakamoto blocks at all
-            || (
-                staging_db_tx.query_row(
-                    "SELECT 1 FROM block_headers WHERE index_block_hash = ?",
-                    rusqlite::params![&block.header.parent_block_id],
-                    |_row| Ok(())
-                ).optional()?.is_some()
-                && staging_db_tx.query_row(
-                    "SELECT 1 FROM nakamoto_block_headers LIMIT 1",
-                    rusqlite::NO_PARAMS,
-                    |_row| Ok(())
-                ).optional()?.is_none()
-               );
+        let burn_attachable =
+            SortitionDB::has_block_snapshot_consensus(&db_handle, &block.header.consensus_hash)?;
 
         let _block_id = block.block_id();
-        Self::store_block(staging_db_tx, block, burn_attachable, stacks_attachable)?;
+        Self::store_block(staging_db_tx, block, burn_attachable)?;
         test_debug!("Stored Nakamoto block {}", &_block_id);
         Ok(true)
     }
@@ -1952,6 +2221,19 @@ impl NakamotoChainState {
         Ok(None)
     }
 
+    /// Load an epoch2 header
+    pub fn get_block_header_epoch2(
+        chainstate_conn: &Connection,
+        index_block_hash: &StacksBlockId,
+    ) -> Result<Option<StacksHeaderInfo>, ChainstateError> {
+        let sql = "SELECT * FROM block_headers WHERE index_block_hash = ?1";
+        let result = query_row_panic(chainstate_conn, sql, &[&index_block_hash], || {
+            "FATAL: multiple rows for the same block hash".to_string()
+        })?;
+
+        Ok(result)
+    }
+
     /// Load block header (either Epoch-2 rules or Nakamoto) by `index_block_hash`
     pub fn get_block_header(
         chainstate_conn: &Connection,
@@ -1965,12 +2247,37 @@ impl NakamotoChainState {
             return Ok(result);
         }
 
-        let sql = "SELECT * FROM block_headers WHERE index_block_hash = ?1";
-        let result = query_row_panic(chainstate_conn, sql, &[&index_block_hash], || {
-            "FATAL: multiple rows for the same block hash".to_string()
-        })?;
+        Self::get_block_header_epoch2(chainstate_conn, index_block_hash)
+    }
 
-        Ok(result)
+    /// Does a block header exist?
+    /// Works for both Nakamoto and epoch2 blocks, as long as check_epoch2 is true
+    pub fn has_block_header(
+        chainstate_conn: &Connection,
+        index_block_hash: &StacksBlockId,
+        check_epoch2: bool,
+    ) -> Result<bool, ChainstateError> {
+        let sql = "SELECT 1 FROM nakamoto_block_headers WHERE index_block_hash = ?1";
+        let result: Option<i64> =
+            query_row_panic(chainstate_conn, sql, &[&index_block_hash], || {
+                "FATAL: multiple rows for the same block hash".to_string()
+            })?;
+        if result.is_some() {
+            return Ok(true);
+        }
+
+        if !check_epoch2 {
+            return Ok(false);
+        }
+
+        // check epoch 2
+        let sql = "SELECT 1 FROM block_headers WHERE index_block_hash = ?1";
+        let result: Option<i64> =
+            query_row_panic(chainstate_conn, sql, &[&index_block_hash], || {
+                "FATAL: multiple rows for the same block hash".to_string()
+            })?;
+
+        Ok(result.is_some())
     }
 
     /// Load the canonical Stacks block header (either epoch-2 rules or Nakamoto)
@@ -2086,17 +2393,40 @@ impl NakamotoChainState {
     /// Returns None if there's no such block
     /// Returns Err on DBError
     pub fn get_nakamoto_block_status(
-        staging_blocks_conn: &Connection,
+        staging_blocks_conn: NakamotoStagingBlocksConnRef,
+        headers_conn: &Connection,
         consensus_hash: &ConsensusHash,
         block_hash: &BlockHeaderHash,
     ) -> Result<Option<(bool, bool)>, ChainstateError> {
         let sql = "SELECT processed, orphaned FROM nakamoto_staging_blocks WHERE consensus_hash = ?1 AND block_hash = ?2";
         let args: &[&dyn ToSql] = &[consensus_hash, block_hash];
-        Ok(query_row_panic(staging_blocks_conn, sql, args, || {
+        let Some((processed, orphaned)) = query_row_panic(&staging_blocks_conn, sql, args, || {
             "FATAL: multiple rows for the same consensus hash and block hash".to_string()
         })
         .map_err(ChainstateError::DBError)?
-        .map(|(processed, orphaned): (u32, u32)| (processed != 0, orphaned != 0)))
+        .map(|(processed, orphaned): (u32, u32)| (processed != 0, orphaned != 0)) else {
+            // not present
+            return Ok(None);
+        };
+
+        if processed || orphaned {
+            return Ok(Some((processed, orphaned)));
+        }
+
+        // this can report a false negative since we set the `processed` and `orphaned` flags in a
+        // separate transaction after processing a block, so handle that here
+        // look for the block
+        if Self::has_block_header(
+            headers_conn,
+            &StacksBlockId::new(consensus_hash, block_hash),
+            false,
+        )? {
+            // was processed, but the staging DB has not yet been updated.
+            return Ok(Some((true, false)));
+        } else {
+            // not processed yet, so return whatever was in the staging DB
+            return Ok(Some((processed, orphaned)));
+        }
     }
 
     /// Get the VRF proof for a Nakamoto block, if it exists.
@@ -2772,7 +3102,8 @@ impl NakamotoChainState {
     }
 
     /// Append a Nakamoto Stacks block to the Stacks chain state.
-    pub fn append_block<'a>(
+    /// NOTE: This does _not_ set the block as processed!  The caller must do this.
+    fn append_block<'a>(
         chainstate_tx: &mut ChainstateTx,
         clarity_instance: &'a mut ClarityInstance,
         burn_dbconn: &mut SortitionHandleTx,
@@ -3151,8 +3482,6 @@ impl NakamotoChainState {
             signers_updated,
         };
 
-        NakamotoChainState::set_block_processed(&chainstate_tx, &new_block_id)?;
-
         Ok((epoch_receipt, clarity_commit))
     }
 

From 33d7df037947e6f9ff160d7e1882d3c8072d4a28 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 13 Feb 2024 15:00:44 -0500
Subject: [PATCH 0749/1166] chore: sync nakamoto chainsate DB to new APIs

---
 .../src/chainstate/nakamoto/tests/mod.rs      | 145 ++++++++++++++----
 1 file changed, 118 insertions(+), 27 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/tests/mod.rs b/stackslib/src/chainstate/nakamoto/tests/mod.rs
index d2de8b67dc..8475ed9e9c 100644
--- a/stackslib/src/chainstate/nakamoto/tests/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/mod.rs
@@ -636,6 +636,14 @@ pub fn test_load_store_update_nakamoto_blocks() {
     stx_transfer_tx.chain_id = 0x80000000;
     stx_transfer_tx.anchor_mode = TransactionAnchorMode::OnChainOnly;
 
+    let mut stx_transfer_tx_3 = StacksTransaction::new(
+        TransactionVersion::Testnet,
+        TransactionAuth::from_p2pkh(&private_key).unwrap(),
+        TransactionPayload::TokenTransfer(recipient_addr.into(), 124, TokenTransferMemo([0u8; 34])),
+    );
+    stx_transfer_tx_3.chain_id = 0x80000000;
+    stx_transfer_tx_3.anchor_mode = TransactionAnchorMode::OnChainOnly;
+
     let nakamoto_txs = vec![tenure_change_tx.clone(), coinbase_tx.clone()];
     let nakamoto_tx_merkle_root = {
         let txid_vecs = nakamoto_txs
@@ -656,6 +664,16 @@ pub fn test_load_store_update_nakamoto_blocks() {
         MerkleTree::<Sha512Trunc256Sum>::new(&txid_vecs).root()
     };
 
+    let nakamoto_txs_3 = vec![stx_transfer_tx_3.clone()];
+    let nakamoto_tx_merkle_root_3 = {
+        let txid_vecs = nakamoto_txs_3
+            .iter()
+            .map(|tx| tx.txid().as_bytes().to_vec())
+            .collect();
+
+        MerkleTree::<Sha512Trunc256Sum>::new(&txid_vecs).root()
+    };
+
     let nakamoto_header = NakamotoBlockHeader {
         version: 1,
         chain_length: 457,
@@ -738,6 +756,37 @@ pub fn test_load_store_update_nakamoto_blocks() {
         runtime: 204,
     };
 
+    // third nakamoto block
+    let nakamoto_header_3 = NakamotoBlockHeader {
+        version: 1,
+        chain_length: 459,
+        burn_spent: 128,
+        consensus_hash: tenure_change_payload.tenure_consensus_hash.clone(),
+        parent_block_id: nakamoto_header_2.block_id(),
+        tx_merkle_root: nakamoto_tx_merkle_root_3,
+        state_index_root: TrieHash([0x07; 32]),
+        miner_signature: MessageSignature::empty(),
+        signer_signature: ThresholdSignature::empty(),
+        signer_bitvec: BitVec::zeros(1).unwrap(),
+    };
+
+    let nakamoto_header_info_3 = StacksHeaderInfo {
+        anchored_header: StacksBlockHeaderTypes::Nakamoto(nakamoto_header_3.clone()),
+        microblock_tail: None,
+        stacks_block_height: nakamoto_header_2.chain_length,
+        index_root: TrieHash([0x67; 32]),
+        consensus_hash: nakamoto_header_2.consensus_hash.clone(),
+        burn_header_hash: BurnchainHeaderHash([0x88; 32]),
+        burn_header_height: 200,
+        burn_header_timestamp: 1001,
+        anchored_block_size: 123,
+    };
+
+    let nakamoto_block_3 = NakamotoBlock {
+        header: nakamoto_header_3.clone(),
+        txs: nakamoto_txs_3,
+    };
+
     let mut total_nakamoto_execution_cost = nakamoto_execution_cost.clone();
     total_nakamoto_execution_cost
         .add(&nakamoto_execution_cost_2)
@@ -759,7 +808,8 @@ pub fn test_load_store_update_nakamoto_blocks() {
 
     // store epoch2 and nakamoto headers
     {
-        let tx = chainstate.db_tx_begin().unwrap();
+        let (tx, staging_tx) = chainstate.headers_and_staging_tx_begin().unwrap();
+
         StacksChainState::insert_stacks_block_header(
             &tx,
             &epoch2_parent_block_id,
@@ -846,7 +896,7 @@ pub fn test_load_store_update_nakamoto_blocks() {
             300,
         )
         .unwrap();
-        NakamotoChainState::store_block(&tx, nakamoto_block.clone(), false, false).unwrap();
+        NakamotoChainState::store_block(&staging_tx, nakamoto_block.clone(), false).unwrap();
 
         // tenure has one block
         assert_eq!(
@@ -879,7 +929,7 @@ pub fn test_load_store_update_nakamoto_blocks() {
         )
         .unwrap();
 
-        NakamotoChainState::store_block(&tx, nakamoto_block_2.clone(), false, false).unwrap();
+        NakamotoChainState::store_block(&staging_tx, nakamoto_block_2.clone(), false).unwrap();
 
         // tenure has two blocks
         assert_eq!(
@@ -898,13 +948,18 @@ pub fn test_load_store_update_nakamoto_blocks() {
                 .unwrap(),
             epoch2_header.total_work.work + 1
         );
+
+        // store, but do not process, a block
+        NakamotoChainState::store_block(&staging_tx, nakamoto_block_3.clone(), false).unwrap();
+
+        staging_tx.commit().unwrap();
         tx.commit().unwrap();
     }
 
     // can load Nakamoto block, but only the Nakamoto block
     assert_eq!(
         NakamotoChainState::load_nakamoto_block(
-            chainstate.db(),
+            chainstate.nakamoto_blocks_db(),
             &nakamoto_header.consensus_hash,
             &nakamoto_header.block_hash()
         )
@@ -914,7 +969,7 @@ pub fn test_load_store_update_nakamoto_blocks() {
     );
     assert_eq!(
         NakamotoChainState::load_nakamoto_block(
-            chainstate.db(),
+            chainstate.nakamoto_blocks_db(),
             &nakamoto_header_2.consensus_hash,
             &nakamoto_header_2.block_hash()
         )
@@ -924,7 +979,7 @@ pub fn test_load_store_update_nakamoto_blocks() {
     );
     assert_eq!(
         NakamotoChainState::load_nakamoto_block(
-            chainstate.db(),
+            chainstate.nakamoto_blocks_db(),
             &epoch2_header_info.consensus_hash,
             &epoch2_header.block_hash()
         )
@@ -932,29 +987,51 @@ pub fn test_load_store_update_nakamoto_blocks() {
         None
     );
 
-    // nakamoto block should not be processed yet
+    // nakamoto block should be treated as processed because even though the processed flag is not
+    // set, the header is present (meaning that we're in-between processing the block and marking
+    // it processed in the staging DB)
     assert_eq!(
         NakamotoChainState::get_nakamoto_block_status(
+            chainstate.nakamoto_blocks_db(),
             chainstate.db(),
             &nakamoto_header.consensus_hash,
             &nakamoto_header.block_hash()
         )
         .unwrap()
         .unwrap(),
-        (false, false)
+        (true, false)
     );
+
+    // same goes for block 2
     assert_eq!(
         NakamotoChainState::get_nakamoto_block_status(
+            chainstate.nakamoto_blocks_db(),
             chainstate.db(),
             &nakamoto_header_2.consensus_hash,
             &nakamoto_header_2.block_hash()
         )
         .unwrap()
         .unwrap(),
+        (true, false)
+    );
+
+    // block 3 has only been stored, but no header has been added
+    assert_eq!(
+        NakamotoChainState::get_nakamoto_block_status(
+            chainstate.nakamoto_blocks_db(),
+            chainstate.db(),
+            &nakamoto_header_3.consensus_hash,
+            &nakamoto_header_3.block_hash()
+        )
+        .unwrap()
+        .unwrap(),
         (false, false)
     );
+
+    // this method doesn't return data for epoch2
     assert_eq!(
         NakamotoChainState::get_nakamoto_block_status(
+            chainstate.nakamoto_blocks_db(),
             chainstate.db(),
             &epoch2_header_info.consensus_hash,
             &epoch2_header.block_hash()
@@ -965,13 +1042,15 @@ pub fn test_load_store_update_nakamoto_blocks() {
 
     // set nakamoto block processed
     {
-        let tx = chainstate.db_tx_begin().unwrap();
-        NakamotoChainState::set_block_processed(&tx, &nakamoto_header.block_id()).unwrap();
+        let (tx, staging_tx) = chainstate.headers_and_staging_tx_begin().unwrap();
+        NakamotoChainState::set_block_processed(&staging_tx, &nakamoto_header_3.block_id())
+            .unwrap();
         assert_eq!(
             NakamotoChainState::get_nakamoto_block_status(
+                staging_tx.conn(),
                 &tx,
-                &nakamoto_header.consensus_hash,
-                &nakamoto_header.block_hash()
+                &nakamoto_header_3.consensus_hash,
+                &nakamoto_header_3.block_hash()
             )
             .unwrap()
             .unwrap(),
@@ -980,10 +1059,11 @@ pub fn test_load_store_update_nakamoto_blocks() {
     }
     // set nakamoto block orphaned
     {
-        let tx = chainstate.db_tx_begin().unwrap();
-        NakamotoChainState::set_block_orphaned(&tx, &nakamoto_header.block_id()).unwrap();
+        let (tx, staging_tx) = chainstate.headers_and_staging_tx_begin().unwrap();
+        NakamotoChainState::set_block_orphaned(&staging_tx, &nakamoto_header.block_id()).unwrap();
         assert_eq!(
             NakamotoChainState::get_nakamoto_block_status(
+                staging_tx.conn(),
                 &tx,
                 &nakamoto_header.consensus_hash,
                 &nakamoto_header.block_hash()
@@ -995,10 +1075,12 @@ pub fn test_load_store_update_nakamoto_blocks() {
     }
     // orphan nakamoto block by parent
     {
-        let tx = chainstate.db_tx_begin().unwrap();
-        NakamotoChainState::set_block_orphaned(&tx, &nakamoto_header.parent_block_id).unwrap();
+        let (tx, staging_tx) = chainstate.headers_and_staging_tx_begin().unwrap();
+        NakamotoChainState::set_block_orphaned(&staging_tx, &nakamoto_header.parent_block_id)
+            .unwrap();
         assert_eq!(
             NakamotoChainState::get_nakamoto_block_status(
+                staging_tx.conn(),
                 &tx,
                 &nakamoto_header.consensus_hash,
                 &nakamoto_header.block_hash()
@@ -1181,26 +1263,32 @@ pub fn test_load_store_update_nakamoto_blocks() {
     // next ready nakamoto block is None unless both the burn block and stacks parent block have
     // been processed
     {
-        let tx = chainstate.db_tx_begin().unwrap();
+        let (tx, staging_tx) = chainstate.headers_and_staging_tx_begin().unwrap();
         assert_eq!(
-            NakamotoChainState::next_ready_nakamoto_block(&tx).unwrap(),
+            NakamotoChainState::next_ready_nakamoto_block(staging_tx.conn(), &tx).unwrap(),
             None
         );
 
-        // set burn processed, but this isn't enough
-        NakamotoChainState::set_burn_block_processed(&tx, &nakamoto_header.consensus_hash).unwrap();
+        // set parent epoch2 block processed
+        NakamotoChainState::set_block_processed(
+            &staging_tx,
+            &epoch2_header_info.index_block_hash(),
+        )
+        .unwrap();
+
+        // but it's not enough -- child's consensus hash needs to be burn_processable
         assert_eq!(
-            NakamotoChainState::next_ready_nakamoto_block(&tx).unwrap(),
+            NakamotoChainState::next_ready_nakamoto_block(staging_tx.conn(), &tx).unwrap(),
             None
         );
 
-        // set parent epoch2 block processed
-        NakamotoChainState::set_block_processed(&tx, &epoch2_header_info.index_block_hash())
+        // set burn processed
+        NakamotoChainState::set_burn_block_processed(&staging_tx, &nakamoto_header.consensus_hash)
             .unwrap();
 
         // this works now
         assert_eq!(
-            NakamotoChainState::next_ready_nakamoto_block(&tx)
+            NakamotoChainState::next_ready_nakamoto_block(staging_tx.conn(), &tx)
                 .unwrap()
                 .unwrap()
                 .0,
@@ -1208,12 +1296,15 @@ pub fn test_load_store_update_nakamoto_blocks() {
         );
 
         // set parent nakamoto block processed
-        NakamotoChainState::set_block_processed(&tx, &nakamoto_header_info.index_block_hash())
-            .unwrap();
+        NakamotoChainState::set_block_processed(
+            &staging_tx,
+            &nakamoto_header_info.index_block_hash(),
+        )
+        .unwrap();
 
         // next nakamoto block
         assert_eq!(
-            NakamotoChainState::next_ready_nakamoto_block(&tx)
+            NakamotoChainState::next_ready_nakamoto_block(staging_tx.conn(), &tx)
                 .unwrap()
                 .unwrap()
                 .0,

From f8a598a1b834eac663fbe7ef443ec0463f775b91 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 13 Feb 2024 15:01:02 -0500
Subject: [PATCH 0750/1166] chore: StacksChainState maintains a connection to
 the Nakamoto staging blocks DB

---
 stackslib/src/chainstate/stacks/db/mod.rs | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/stackslib/src/chainstate/stacks/db/mod.rs b/stackslib/src/chainstate/stacks/db/mod.rs
index 5c4a61fdb1..5c4ac4fba0 100644
--- a/stackslib/src/chainstate/stacks/db/mod.rs
+++ b/stackslib/src/chainstate/stacks/db/mod.rs
@@ -51,7 +51,7 @@ use crate::chainstate::burn::operations::{DelegateStxOp, StackStxOp, TransferStx
 use crate::chainstate::burn::{ConsensusHash, ConsensusHashExtensions};
 use crate::chainstate::nakamoto::{
     HeaderTypeNames, NakamotoBlock, NakamotoBlockHeader, NakamotoChainState,
-    NAKAMOTO_CHAINSTATE_SCHEMA_1,
+    NakamotoStagingBlocksConn, NAKAMOTO_CHAINSTATE_SCHEMA_1,
 };
 use crate::chainstate::stacks::address::StacksAddressExtensions;
 use crate::chainstate::stacks::boot::*;
@@ -115,6 +115,7 @@ pub struct StacksChainState {
     pub mainnet: bool,
     pub chain_id: u32,
     pub clarity_state: ClarityInstance,
+    pub nakamoto_staging_blocks_conn: NakamotoStagingBlocksConn,
     pub state_index: MARF<StacksBlockId>,
     pub blocks_path: String,
     pub clarity_state_index_path: String, // path to clarity MARF
@@ -1789,6 +1790,11 @@ impl StacksChainState {
             .ok_or_else(|| Error::DBError(db_error::ParseError))?
             .to_string();
 
+        let nakamoto_staging_blocks_path =
+            StacksChainState::get_nakamoto_staging_blocks_path(path.clone())?;
+        let nakamoto_staging_blocks_conn =
+            StacksChainState::open_nakamoto_staging_blocks(&nakamoto_staging_blocks_path, true)?;
+
         let init_required = match fs::metadata(&clarity_state_index_marf) {
             Ok(_) => false,
             Err(_) => true,
@@ -1812,6 +1818,7 @@ impl StacksChainState {
             mainnet: mainnet,
             chain_id: chain_id,
             clarity_state: clarity_state,
+            nakamoto_staging_blocks_conn,
             state_index: state_index,
             blocks_path: blocks_path_root,
             clarity_state_index_path: clarity_state_index_marf,

From 3ec7bdfa4a0bf70b261fa8639e15cbdf408a0ded Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 13 Feb 2024 15:01:24 -0500
Subject: [PATCH 0751/1166] fix: staging blocks TX for storing blocks

---
 stackslib/src/net/relay.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stackslib/src/net/relay.rs b/stackslib/src/net/relay.rs
index be01c260ba..e4ff1ef9ba 100644
--- a/stackslib/src/net/relay.rs
+++ b/stackslib/src/net/relay.rs
@@ -730,7 +730,7 @@ impl Relayer {
             );
             return Ok(false);
         };
-        let staging_db_tx = chainstate.db_tx_begin()?;
+        let staging_db_tx = chainstate.staging_db_tx_begin()?;
         let accepted = NakamotoChainState::accept_block(
             &config,
             block,

From b5e308c075ec3d6effe67b2c0b2207a476579203 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 13 Feb 2024 15:01:36 -0500
Subject: [PATCH 0752/1166] feat: FromRow for Vec<u8>, and replace get_unwrap()
 with get()

---
 stackslib/src/util_lib/db.rs | 41 +++++++++++++++++++++---------------
 1 file changed, 24 insertions(+), 17 deletions(-)

diff --git a/stackslib/src/util_lib/db.rs b/stackslib/src/util_lib/db.rs
index e10ca1b886..c5c7ea9ad7 100644
--- a/stackslib/src/util_lib/db.rs
+++ b/stackslib/src/util_lib/db.rs
@@ -158,7 +158,7 @@ pub trait FromColumn<T> {
 
 impl FromRow<u64> for u64 {
     fn from_row<'a>(row: &'a Row) -> Result<u64, Error> {
-        let x: i64 = row.get_unwrap(0);
+        let x: i64 = row.get(0)?;
         if x < 0 {
             return Err(Error::ParseError);
         }
@@ -168,21 +168,28 @@ impl FromRow<u64> for u64 {
 
 impl FromRow<u32> for u32 {
     fn from_row<'a>(row: &'a Row) -> Result<u32, Error> {
-        let x: u32 = row.get_unwrap(0);
+        let x: u32 = row.get(0)?;
         Ok(x)
     }
 }
 
 impl FromRow<String> for String {
     fn from_row<'a>(row: &'a Row) -> Result<String, Error> {
-        let x: String = row.get_unwrap(0);
+        let x: String = row.get(0)?;
+        Ok(x)
+    }
+}
+
+impl FromRow<Vec<u8>> for Vec<u8> {
+    fn from_row<'a>(row: &'a Row) -> Result<Vec<u8>, Error> {
+        let x: Vec<u8> = row.get(0)?;
         Ok(x)
     }
 }
 
 impl FromColumn<u64> for u64 {
     fn from_column<'a>(row: &'a Row, column_name: &str) -> Result<u64, Error> {
-        let x: i64 = row.get_unwrap(column_name);
+        let x: i64 = row.get(column_name)?;
         if x < 0 {
             return Err(Error::ParseError);
         }
@@ -192,7 +199,7 @@ impl FromColumn<u64> for u64 {
 
 impl FromRow<StacksAddress> for StacksAddress {
     fn from_row<'a>(row: &'a Row) -> Result<StacksAddress, Error> {
-        let addr_str: String = row.get_unwrap(0);
+        let addr_str: String = row.get(0)?;
         let addr = StacksAddress::from_string(&addr_str).ok_or(Error::ParseError)?;
         Ok(addr)
     }
@@ -200,7 +207,7 @@ impl FromRow<StacksAddress> for StacksAddress {
 
 impl FromColumn<Option<u64>> for u64 {
     fn from_column<'a>(row: &'a Row, column_name: &str) -> Result<Option<u64>, Error> {
-        let x: Option<i64> = row.get_unwrap(column_name);
+        let x: Option<i64> = row.get(column_name)?;
         match x {
             Some(x) => {
                 if x < 0 {
@@ -215,14 +222,14 @@ impl FromColumn<Option<u64>> for u64 {
 
 impl FromRow<i64> for i64 {
     fn from_row<'a>(row: &'a Row) -> Result<i64, Error> {
-        let x: i64 = row.get_unwrap(0);
+        let x: i64 = row.get(0)?;
         Ok(x)
     }
 }
 
 impl FromColumn<i64> for i64 {
     fn from_column<'a>(row: &'a Row, column_name: &str) -> Result<i64, Error> {
-        let x: i64 = row.get_unwrap(column_name);
+        let x: i64 = row.get(column_name)?;
         Ok(x)
     }
 }
@@ -232,14 +239,14 @@ impl FromColumn<QualifiedContractIdentifier> for QualifiedContractIdentifier {
         row: &'a Row,
         column_name: &str,
     ) -> Result<QualifiedContractIdentifier, Error> {
-        let value: String = row.get_unwrap(column_name);
+        let value: String = row.get(column_name)?;
         QualifiedContractIdentifier::parse(&value).map_err(|_| Error::ParseError)
     }
 }
 
 impl FromRow<bool> for bool {
     fn from_row<'a>(row: &'a Row) -> Result<bool, Error> {
-        let x: bool = row.get_unwrap(0);
+        let x: bool = row.get(0)?;
         Ok(x)
     }
 }
@@ -247,7 +254,7 @@ impl FromRow<bool> for bool {
 /// Make public keys loadable from a sqlite database
 impl FromColumn<Secp256k1PublicKey> for Secp256k1PublicKey {
     fn from_column<'a>(row: &'a Row, column_name: &str) -> Result<Secp256k1PublicKey, Error> {
-        let pubkey_hex: String = row.get_unwrap(column_name);
+        let pubkey_hex: String = row.get(column_name)?;
         let pubkey = Secp256k1PublicKey::from_hex(&pubkey_hex).map_err(|_e| Error::ParseError)?;
         Ok(pubkey)
     }
@@ -256,7 +263,7 @@ impl FromColumn<Secp256k1PublicKey> for Secp256k1PublicKey {
 /// Make private keys loadable from a sqlite database
 impl FromColumn<Secp256k1PrivateKey> for Secp256k1PrivateKey {
     fn from_column<'a>(row: &'a Row, column_name: &str) -> Result<Secp256k1PrivateKey, Error> {
-        let privkey_hex: String = row.get_unwrap(column_name);
+        let privkey_hex: String = row.get(column_name)?;
         let privkey =
             Secp256k1PrivateKey::from_hex(&privkey_hex).map_err(|_e| Error::ParseError)?;
         Ok(privkey)
@@ -289,7 +296,7 @@ macro_rules! impl_byte_array_from_column_only {
                 row: &rusqlite::Row,
                 column_name: &str,
             ) -> Result<Self, crate::util_lib::db::Error> {
-                Ok(row.get_unwrap::<_, Self>(column_name))
+                Ok(row.get::<_, Self>(column_name)?)
             }
         }
     };
@@ -318,7 +325,7 @@ macro_rules! impl_byte_array_from_column {
                 row: &rusqlite::Row,
                 column_name: &str,
             ) -> Result<Self, crate::util_lib::db::Error> {
-                Ok(row.get_unwrap::<_, Self>(column_name))
+                Ok(row.get::<_, Self>(column_name)?)
             }
         }
 
@@ -499,7 +506,7 @@ where
         if row_data.len() > 0 {
             return Err(Error::Overflow);
         }
-        let i: i64 = row.get_unwrap(0);
+        let i: i64 = row.get(0)?;
         row_data.push(i);
     }
 
@@ -759,8 +766,8 @@ fn load_indexed(conn: &DBConn, marf_value: &MARFValue) -> Result<Option<String>,
         .map_err(Error::SqliteError)?;
     let mut value = None;
 
-    while let Some(row) = rows.next().expect("FATAL: Failed to read row from Sqlite") {
-        let value_str: String = row.get_unwrap(0);
+    while let Some(row) = rows.next()? {
+        let value_str: String = row.get(0)?;
         if value.is_some() {
             // should be impossible
             panic!(

From 407d5fdc1ace2755b0983af4b1c1a2dfe41dcb5e Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Tue, 13 Feb 2024 14:51:38 -0600
Subject: [PATCH 0753/1166] fix: remove pox_4_activation spec -- it will
 activate at the same height as v3_unlock (as pox-2 did)

---
 stackslib/src/burnchains/mod.rs               |  32 ++-
 stackslib/src/burnchains/tests/affirmation.rs | 201 +++---------------
 stackslib/src/burnchains/tests/db.rs          |  68 ++----
 stackslib/src/chainstate/burn/db/sortdb.rs    |   1 -
 .../burn/operations/leader_block_commit.rs    |  61 ++----
 stackslib/src/chainstate/coordinator/tests.rs |  16 --
 .../src/chainstate/nakamoto/tests/mod.rs      |   2 +-
 stackslib/src/chainstate/stacks/boot/mod.rs   |   1 -
 stackslib/src/net/mod.rs                      |  16 +-
 stackslib/src/net/tests/inv/epoch2x.rs        |  32 +--
 stackslib/src/net/tests/mod.rs                |   2 -
 testnet/stacks-node/src/tests/epoch_21.rs     |  15 --
 testnet/stacks-node/src/tests/epoch_22.rs     |   3 -
 testnet/stacks-node/src/tests/epoch_23.rs     |   1 -
 testnet/stacks-node/src/tests/epoch_24.rs     |   2 -
 .../src/tests/neon_integrations.rs            |   3 -
 16 files changed, 93 insertions(+), 363 deletions(-)

diff --git a/stackslib/src/burnchains/mod.rs b/stackslib/src/burnchains/mod.rs
index f610382241..2f38262966 100644
--- a/stackslib/src/burnchains/mod.rs
+++ b/stackslib/src/burnchains/mod.rs
@@ -327,7 +327,6 @@ impl PoxConstants {
         v2_unlock_height: u32,
         v3_unlock_height: u32,
         pox_3_activation_height: u32,
-        pox_4_activation_height: u32,
     ) -> PoxConstants {
         assert!(anchor_threshold > (prepare_length / 2));
         assert!(prepare_length < reward_cycle_length);
@@ -335,7 +334,6 @@ impl PoxConstants {
         assert!(v2_unlock_height >= v1_unlock_height);
         assert!(v3_unlock_height >= v2_unlock_height);
         assert!(pox_3_activation_height >= v2_unlock_height);
-        assert!(pox_4_activation_height >= v3_unlock_height);
 
         PoxConstants {
             reward_cycle_length,
@@ -349,7 +347,7 @@ impl PoxConstants {
             v2_unlock_height,
             v3_unlock_height,
             pox_3_activation_height,
-            pox_4_activation_height,
+            pox_4_activation_height: v3_unlock_height,
             _shadow: PhantomData,
         }
     }
@@ -368,6 +366,25 @@ impl PoxConstants {
             u32::MAX,
             u32::MAX,
             u32::MAX,
+        )
+    }
+
+    #[cfg(test)]
+    /// Create a PoX constants used in tests with 5-block cycles,
+    ///  3-block prepare phases, a threshold of 3, rejection fraction of 25%,
+    ///  a participation threshold of 5% and no sunset or transition to pox-2 or beyond.
+    pub(crate) fn test_20_no_sunset() -> PoxConstants {
+        PoxConstants::new(
+            5,
+            3,
+            3,
+            25,
+            5,
+            u64::MAX,
+            u64::MAX,
+            u32::MAX,
+            u32::MAX,
+            u32::MAX,
             u32::MAX,
         )
     }
@@ -430,9 +447,6 @@ impl PoxConstants {
             BITCOIN_MAINNET_STACKS_24_BURN_HEIGHT
                 .try_into()
                 .expect("Epoch transition height must be <= u32::MAX"),
-            BITCOIN_MAINNET_STACKS_25_BURN_HEIGHT
-                .try_into()
-                .expect("Epoch transition height must be <= u32::MAX"),
         )
     }
 
@@ -451,9 +465,6 @@ impl PoxConstants {
             BITCOIN_TESTNET_STACKS_24_BURN_HEIGHT
                 .try_into()
                 .expect("Epoch transition height must be <= u32::MAX"),
-            BITCOIN_TESTNET_STACKS_25_BURN_HEIGHT
-                .try_into()
-                .expect("Epoch transition height must be <= u32::MAX"),
         ) // total liquid supply is 40000000000000000 µSTX
     }
 
@@ -468,9 +479,8 @@ impl PoxConstants {
             BITCOIN_REGTEST_FIRST_BLOCK_HEIGHT + POX_SUNSET_END,
             1_000_000,
             2_000_000,
-            3_000_000,
             4_000_000,
-            5_000_000,
+            3_000_000,
         )
     }
 
diff --git a/stackslib/src/burnchains/tests/affirmation.rs b/stackslib/src/burnchains/tests/affirmation.rs
index e95f020097..8876f3d1aa 100644
--- a/stackslib/src/burnchains/tests/affirmation.rs
+++ b/stackslib/src/burnchains/tests/affirmation.rs
@@ -51,6 +51,27 @@ use crate::core::*;
 use crate::monitoring::increment_stx_blocks_processed_counter;
 use crate::{chainstate, core};
 
+fn make_test_pox(
+    cycle_len: u32,
+    prepare_len: u32,
+    anchor_thresh: u32,
+    rejection_frac: u64,
+) -> PoxConstants {
+    PoxConstants::new(
+        cycle_len,
+        prepare_len,
+        anchor_thresh,
+        rejection_frac,
+        0,
+        u64::MAX - 1,
+        u64::MAX,
+        u32::MAX,
+        u32::MAX,
+        u32::MAX,
+        u32::MAX,
+    )
+}
+
 #[test]
 fn affirmation_map_encode_decode() {
     assert_eq!(AffirmationMap::decode(""), Some(AffirmationMap::empty()));
@@ -477,20 +498,7 @@ fn test_read_prepare_phase_commits() {
     let first_height = 0;
 
     let mut burnchain = Burnchain::regtest(":memory:");
-    burnchain.pox_constants = PoxConstants::new(
-        10,
-        5,
-        3,
-        3,
-        0,
-        u64::MAX - 1,
-        u64::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-    );
+    burnchain.pox_constants = make_test_pox(10, 5, 3, 3);
     burnchain.first_block_height = first_height;
     burnchain.first_block_hash = first_bhh.clone();
     burnchain.first_block_timestamp = first_timestamp;
@@ -556,20 +564,7 @@ fn test_parent_block_commits() {
     let first_height = 0;
 
     let mut burnchain = Burnchain::regtest(":memory:");
-    burnchain.pox_constants = PoxConstants::new(
-        10,
-        5,
-        3,
-        3,
-        0,
-        u64::MAX - 1,
-        u64::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-    );
+    burnchain.pox_constants = make_test_pox(10, 5, 3, 3);
     burnchain.first_block_height = first_height;
     burnchain.first_block_hash = first_bhh.clone();
     burnchain.first_block_timestamp = first_timestamp;
@@ -660,20 +655,7 @@ fn test_filter_orphan_block_commits() {
     let first_height = 0;
 
     let mut burnchain = Burnchain::regtest(":memory:");
-    burnchain.pox_constants = PoxConstants::new(
-        5,
-        3,
-        3,
-        3,
-        0,
-        u64::MAX - 1,
-        u64::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-    );
+    burnchain.pox_constants = make_test_pox(5, 3, 3, 3);
     burnchain.first_block_height = first_height;
     burnchain.first_block_hash = first_bhh.clone();
     burnchain.first_block_timestamp = first_timestamp;
@@ -733,20 +715,7 @@ fn test_filter_missed_block_commits() {
     let first_height = 0;
 
     let mut burnchain = Burnchain::regtest(":memory:");
-    burnchain.pox_constants = PoxConstants::new(
-        5,
-        3,
-        3,
-        3,
-        0,
-        u64::MAX - 1,
-        u64::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-    );
+    burnchain.pox_constants = make_test_pox(5, 3, 3, 3);
     burnchain.first_block_height = first_height;
     burnchain.first_block_hash = first_bhh.clone();
     burnchain.first_block_timestamp = first_timestamp;
@@ -806,20 +775,7 @@ fn test_find_heaviest_block_commit() {
     let first_height = 0;
 
     let mut burnchain = Burnchain::regtest(":memory:");
-    burnchain.pox_constants = PoxConstants::new(
-        5,
-        3,
-        2,
-        3,
-        0,
-        u64::MAX - 1,
-        u64::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-    );
+    burnchain.pox_constants = make_test_pox(5, 3, 2, 3);
     burnchain.first_block_height = first_height;
     burnchain.first_block_hash = first_bhh.clone();
     burnchain.first_block_timestamp = first_timestamp;
@@ -1031,20 +987,7 @@ fn test_find_heaviest_parent_commit_many_commits() {
     let first_height = 0;
 
     let mut burnchain = Burnchain::regtest(":memory:");
-    burnchain.pox_constants = PoxConstants::new(
-        5,
-        3,
-        2,
-        3,
-        0,
-        u64::MAX - 1,
-        u64::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-    );
+    burnchain.pox_constants = make_test_pox(5, 3, 2, 3);
     burnchain.first_block_height = first_height;
     burnchain.first_block_hash = first_bhh.clone();
     burnchain.first_block_timestamp = first_timestamp;
@@ -1296,20 +1239,7 @@ fn test_update_pox_affirmation_maps_3_forks() {
     let first_height = 0;
 
     let mut burnchain = Burnchain::regtest(":memory:");
-    burnchain.pox_constants = PoxConstants::new(
-        10,
-        5,
-        3,
-        3,
-        0,
-        u64::MAX - 1,
-        u64::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-    );
+    burnchain.pox_constants = make_test_pox(10, 5, 3, 3);
     burnchain.first_block_height = first_height;
     burnchain.first_block_hash = first_bhh.clone();
     burnchain.first_block_timestamp = first_timestamp;
@@ -1558,20 +1488,7 @@ fn test_update_pox_affirmation_maps_unique_anchor_block() {
     let first_height = 0;
 
     let mut burnchain = Burnchain::regtest(":memory:");
-    burnchain.pox_constants = PoxConstants::new(
-        10,
-        5,
-        3,
-        3,
-        0,
-        u64::MAX - 1,
-        u64::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-    );
+    burnchain.pox_constants = make_test_pox(10, 5, 3, 3);
     burnchain.first_block_height = first_height;
     burnchain.first_block_hash = first_bhh.clone();
     burnchain.first_block_timestamp = first_timestamp;
@@ -1763,20 +1680,7 @@ fn test_update_pox_affirmation_maps_absent() {
     let first_height = 0;
 
     let mut burnchain = Burnchain::regtest(":memory:");
-    burnchain.pox_constants = PoxConstants::new(
-        10,
-        5,
-        3,
-        3,
-        0,
-        u64::MAX - 1,
-        u64::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-    );
+    burnchain.pox_constants = make_test_pox(10, 5, 3, 3);
     burnchain.first_block_height = first_height;
     burnchain.first_block_hash = first_bhh.clone();
     burnchain.first_block_timestamp = first_timestamp;
@@ -2238,20 +2142,7 @@ fn test_update_pox_affirmation_maps_nothing() {
     let first_height = 0;
 
     let mut burnchain = Burnchain::regtest(":memory:");
-    burnchain.pox_constants = PoxConstants::new(
-        10,
-        5,
-        3,
-        3,
-        0,
-        u64::MAX - 1,
-        u64::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-    );
+    burnchain.pox_constants = make_test_pox(10, 5, 3, 3);
     burnchain.first_block_height = first_height;
     burnchain.first_block_hash = first_bhh.clone();
     burnchain.first_block_timestamp = first_timestamp;
@@ -2517,20 +2408,7 @@ fn test_update_pox_affirmation_fork_2_cycles() {
     let first_height = 0;
 
     let mut burnchain = Burnchain::regtest(":memory:");
-    burnchain.pox_constants = PoxConstants::new(
-        5,
-        2,
-        2,
-        25,
-        5,
-        u64::MAX - 1,
-        u64::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-    );
+    burnchain.pox_constants = make_test_pox(5, 2, 2, 25);
     burnchain.first_block_height = first_height;
     burnchain.first_block_hash = first_bhh.clone();
     burnchain.first_block_timestamp = first_timestamp;
@@ -2821,20 +2699,7 @@ fn test_update_pox_affirmation_fork_duel() {
     let first_height = 0;
 
     let mut burnchain = Burnchain::regtest(":memory:");
-    burnchain.pox_constants = PoxConstants::new(
-        5,
-        2,
-        2,
-        25,
-        5,
-        u64::MAX - 1,
-        u64::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-    );
+    burnchain.pox_constants = make_test_pox(5, 2, 2, 25);
     burnchain.first_block_height = first_height;
     burnchain.first_block_hash = first_bhh.clone();
     burnchain.first_block_timestamp = first_timestamp;
diff --git a/stackslib/src/burnchains/tests/db.rs b/stackslib/src/burnchains/tests/db.rs
index beaf99266c..13db19bcf7 100644
--- a/stackslib/src/burnchains/tests/db.rs
+++ b/stackslib/src/burnchains/tests/db.rs
@@ -499,14 +499,8 @@ pub fn make_simple_block_commit(
     new_op
 }
 
-#[test]
-fn test_get_commit_at() {
-    let first_bhh = BurnchainHeaderHash::from_hex(BITCOIN_REGTEST_FIRST_BLOCK_HASH).unwrap();
-    let first_timestamp = 0;
-    let first_height = 1;
-
-    let mut burnchain = Burnchain::regtest(":memory");
-    burnchain.pox_constants = PoxConstants::new(
+fn burn_db_test_pox() -> PoxConstants {
+    PoxConstants::new(
         5,
         3,
         2,
@@ -518,8 +512,17 @@ fn test_get_commit_at() {
         u32::MAX,
         u32::MAX,
         u32::MAX,
-        u32::MAX,
-    );
+    )
+}
+
+#[test]
+fn test_get_commit_at() {
+    let first_bhh = BurnchainHeaderHash::from_hex(BITCOIN_REGTEST_FIRST_BLOCK_HASH).unwrap();
+    let first_timestamp = 0;
+    let first_height = 1;
+
+    let mut burnchain = Burnchain::regtest(":memory");
+    burnchain.pox_constants = burn_db_test_pox();
     burnchain.first_block_height = first_height;
     burnchain.first_block_hash = first_bhh.clone();
     burnchain.first_block_timestamp = first_timestamp;
@@ -633,20 +636,7 @@ fn test_get_set_check_anchor_block() {
     let first_height = 1;
 
     let mut burnchain = Burnchain::regtest(":memory:");
-    burnchain.pox_constants = PoxConstants::new(
-        5,
-        3,
-        2,
-        3,
-        0,
-        u64::MAX - 1,
-        u64::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-    );
+    burnchain.pox_constants = burn_db_test_pox();
     burnchain.first_block_height = first_height;
     burnchain.first_block_hash = first_bhh.clone();
     burnchain.first_block_timestamp = first_timestamp;
@@ -730,20 +720,7 @@ fn test_update_block_descendancy() {
     let first_height = 1;
 
     let mut burnchain = Burnchain::regtest(":memory:");
-    burnchain.pox_constants = PoxConstants::new(
-        5,
-        3,
-        2,
-        3,
-        0,
-        u64::MAX - 1,
-        u64::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-    );
+    burnchain.pox_constants = burn_db_test_pox();
     burnchain.first_block_height = first_height;
     burnchain.first_block_hash = first_bhh.clone();
     burnchain.first_block_timestamp = first_timestamp;
@@ -861,20 +838,7 @@ fn test_update_block_descendancy_with_fork() {
     let first_height = 1;
 
     let mut burnchain = Burnchain::regtest(":memory:");
-    burnchain.pox_constants = PoxConstants::new(
-        5,
-        3,
-        2,
-        3,
-        0,
-        u64::MAX - 1,
-        u64::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-    );
+    burnchain.pox_constants = burn_db_test_pox();
     burnchain.first_block_height = first_height;
     burnchain.first_block_hash = first_bhh.clone();
     burnchain.first_block_timestamp = first_timestamp;
diff --git a/stackslib/src/chainstate/burn/db/sortdb.rs b/stackslib/src/chainstate/burn/db/sortdb.rs
index 0be1c77487..e67b21231a 100644
--- a/stackslib/src/chainstate/burn/db/sortdb.rs
+++ b/stackslib/src/chainstate/burn/db/sortdb.rs
@@ -10074,7 +10074,6 @@ pub mod tests {
             u32::MAX,
             u32::MAX,
             u32::MAX,
-            u32::MAX,
         );
 
         let mut burnchain = Burnchain::regtest(path_root);
diff --git a/stackslib/src/chainstate/burn/operations/leader_block_commit.rs b/stackslib/src/chainstate/burn/operations/leader_block_commit.rs
index 38c9fb1c2d..5f16b87d13 100644
--- a/stackslib/src/chainstate/burn/operations/leader_block_commit.rs
+++ b/stackslib/src/chainstate/burn/operations/leader_block_commit.rs
@@ -1746,6 +1746,22 @@ mod tests {
         }
     }
 
+    fn pox_constants() -> PoxConstants {
+        PoxConstants::new(
+            6,
+            2,
+            2,
+            25,
+            5,
+            5000,
+            10000,
+            u32::MAX,
+            u32::MAX,
+            u32::MAX,
+            u32::MAX,
+        )
+    }
+
     #[test]
     fn test_check_2_1() {
         let first_block_height = 121;
@@ -1784,20 +1800,7 @@ mod tests {
         ];
 
         let burnchain = Burnchain {
-            pox_constants: PoxConstants::new(
-                6,
-                2,
-                2,
-                25,
-                5,
-                5000,
-                10000,
-                u32::MAX,
-                u32::MAX,
-                u32::MAX,
-                u32::MAX,
-                u32::MAX,
-            ),
+            pox_constants: pox_constants(),
             peer_version: 0x012345678,
             network_id: 0x9abcdef0,
             chain_name: "bitcoin".to_string(),
@@ -2331,20 +2334,7 @@ mod tests {
         ];
 
         let burnchain = Burnchain {
-            pox_constants: PoxConstants::new(
-                6,
-                2,
-                2,
-                25,
-                5,
-                5000,
-                10000,
-                u32::MAX,
-                u32::MAX,
-                u32::MAX,
-                u32::MAX,
-                u32::MAX,
-            ),
+            pox_constants: pox_constants(),
             peer_version: 0x012345678,
             network_id: 0x9abcdef0,
             chain_name: "bitcoin".to_string(),
@@ -3034,20 +3024,7 @@ mod tests {
         .unwrap();
 
         let burnchain = Burnchain {
-            pox_constants: PoxConstants::new(
-                6,
-                2,
-                2,
-                25,
-                5,
-                5000,
-                10000,
-                u32::MAX,
-                u32::MAX,
-                u32::MAX,
-                u32::MAX,
-                u32::MAX,
-            ),
+            pox_constants: pox_constants(),
             peer_version: 0x012345678,
             network_id: 0x9abcdef0,
             chain_name: "bitcoin".to_string(),
diff --git a/stackslib/src/chainstate/coordinator/tests.rs b/stackslib/src/chainstate/coordinator/tests.rs
index 2882bd2cd0..600164e5f1 100644
--- a/stackslib/src/chainstate/coordinator/tests.rs
+++ b/stackslib/src/chainstate/coordinator/tests.rs
@@ -565,7 +565,6 @@ pub fn get_burnchain(path: &str, pox_consts: Option<PoxConstants>) -> Burnchain
             u32::MAX,
             u32::MAX,
             u32::MAX,
-            u32::MAX,
         )
     });
     b
@@ -1014,7 +1013,6 @@ fn missed_block_commits_2_05() {
         u32::MAX,
         u32::MAX,
         u32::MAX,
-        u32::MAX,
     ));
     let burnchain_conf = get_burnchain(path, pox_consts.clone());
 
@@ -1336,7 +1334,6 @@ fn missed_block_commits_2_1() {
         u32::MAX,
         u32::MAX,
         u32::MAX,
-        u32::MAX,
     ));
     let burnchain_conf = get_burnchain(path, pox_consts.clone());
 
@@ -1682,7 +1679,6 @@ fn late_block_commits_2_1() {
         u32::MAX,
         u32::MAX,
         u32::MAX,
-        u32::MAX,
     ));
     let burnchain_conf = get_burnchain(path, pox_consts.clone());
 
@@ -2753,7 +2749,6 @@ fn test_pox_btc_ops() {
         pox_v2_unlock_ht,
         pox_v3_unlock_ht,
         u32::MAX,
-        u32::MAX,
     ));
     let burnchain_conf = get_burnchain(path, pox_consts.clone());
 
@@ -3042,7 +3037,6 @@ fn test_stx_transfer_btc_ops() {
         pox_v2_unlock_ht,
         pox_v3_unlock_ht,
         u32::MAX,
-        u32::MAX,
     ));
     let burnchain_conf = get_burnchain(path, pox_consts.clone());
 
@@ -3473,7 +3467,6 @@ fn test_delegate_stx_btc_ops() {
         pox_v2_unlock_ht,
         u32::MAX,
         u32::MAX,
-        u32::MAX,
     ));
     let burnchain_conf = get_burnchain(path, pox_consts.clone());
 
@@ -3780,7 +3773,6 @@ fn test_initial_coinbase_reward_distributions() {
         u32::MAX,
         u32::MAX,
         u32::MAX,
-        u32::MAX,
     ));
     let burnchain_conf = get_burnchain(path, pox_consts.clone());
 
@@ -4021,7 +4013,6 @@ fn test_epoch_switch_cost_contract_instantiation() {
         u32::MAX,
         u32::MAX,
         u32::MAX,
-        u32::MAX,
     ));
     let burnchain_conf = get_burnchain(path, pox_consts.clone());
 
@@ -4224,7 +4215,6 @@ fn test_epoch_switch_pox_2_contract_instantiation() {
         u32::MAX,
         u32::MAX,
         u32::MAX,
-        u32::MAX,
     ));
     let burnchain_conf = get_burnchain(path, pox_consts.clone());
 
@@ -4430,7 +4420,6 @@ fn test_epoch_switch_pox_3_contract_instantiation() {
         14,
         u32::MAX,
         16,
-        u32::MAX,
     ));
     let burnchain_conf = get_burnchain(path, pox_consts.clone());
 
@@ -4636,7 +4625,6 @@ fn atlas_stop_start() {
         u32::MAX,
         u32::MAX,
         u32::MAX,
-        u32::MAX,
     ));
     let burnchain_conf = get_burnchain(path, pox_consts.clone());
 
@@ -4947,7 +4935,6 @@ fn test_epoch_verify_active_pox_contract() {
         pox_v2_unlock_ht,
         u32::MAX,
         u32::MAX,
-        u32::MAX,
     ));
     let burnchain_conf = get_burnchain(path, pox_consts.clone());
 
@@ -5240,7 +5227,6 @@ fn test_sortition_with_sunset() {
         u32::MAX,
         u32::MAX,
         u32::MAX,
-        u32::MAX,
     ));
     let burnchain_conf = get_burnchain(path, pox_consts.clone());
 
@@ -5551,7 +5537,6 @@ fn test_sortition_with_sunset_and_epoch_switch() {
         u32::MAX,
         u32::MAX,
         u32::MAX,
-        u32::MAX,
     ));
 
     let burnchain_conf = get_burnchain(path, pox_consts.clone());
@@ -5902,7 +5887,6 @@ fn test_pox_processable_block_in_different_pox_forks() {
         u32::MAX,
         u32::MAX,
         u32::MAX,
-        u32::MAX,
     ));
     let b = get_burnchain(path, pox_consts.clone());
     let b_blind = get_burnchain(path_blinded, pox_consts.clone());
diff --git a/stackslib/src/chainstate/nakamoto/tests/mod.rs b/stackslib/src/chainstate/nakamoto/tests/mod.rs
index d2de8b67dc..2450c1b65d 100644
--- a/stackslib/src/chainstate/nakamoto/tests/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/mod.rs
@@ -523,7 +523,7 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
 pub fn test_load_store_update_nakamoto_blocks() {
     let test_name = function_name!();
     let path = test_path(&test_name);
-    let pox_constants = PoxConstants::new(5, 3, 3, 25, 5, 0, 0, 0, 0, 0, 0, 0);
+    let pox_constants = PoxConstants::new(5, 3, 3, 25, 5, 0, 0, 0, 0, 0, 0);
     let epochs = StacksEpoch::unit_test_3_0_only(1);
     let _ = std::fs::remove_dir_all(&path);
     let burnchain_conf = get_burnchain(&path, Some(pox_constants.clone()));
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 41843f9327..f969558f93 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -1437,7 +1437,6 @@ pub mod test {
             u32::MAX,
             u32::MAX,
             u32::MAX,
-            u32::MAX,
         );
         // when the liquid amount = the threshold step,
         //   the threshold should always be the step size.
diff --git a/stackslib/src/net/mod.rs b/stackslib/src/net/mod.rs
index e5bfaefe3a..5feb4c5112 100644
--- a/stackslib/src/net/mod.rs
+++ b/stackslib/src/net/mod.rs
@@ -1983,21 +1983,7 @@ pub mod test {
                 &BurnchainHeaderHash::from_hex(BITCOIN_GENESIS_BLOCK_HASH_REGTEST).unwrap(),
             );
 
-            burnchain.pox_constants = PoxConstants::new(
-                5,
-                3,
-                3,
-                25,
-                5,
-                u64::MAX,
-                u64::MAX,
-                u32::MAX,
-                u32::MAX,
-                u32::MAX,
-                u32::MAX,
-                u32::MAX,
-            );
-
+            burnchain.pox_constants = PoxConstants::test_20_no_sunset();
             let mut spending_account = TestMinerFactory::new().next_miner(
                 &burnchain,
                 1,
diff --git a/stackslib/src/net/tests/inv/epoch2x.rs b/stackslib/src/net/tests/inv/epoch2x.rs
index 4f0072ba08..31028d3a51 100644
--- a/stackslib/src/net/tests/inv/epoch2x.rs
+++ b/stackslib/src/net/tests/inv/epoch2x.rs
@@ -447,21 +447,7 @@ fn test_inv_set_block_microblock_bits() {
 #[test]
 fn test_inv_merge_pox_inv() {
     let mut burnchain = Burnchain::regtest("unused");
-    burnchain.pox_constants = PoxConstants::new(
-        5,
-        3,
-        3,
-        25,
-        5,
-        u64::MAX,
-        u64::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-    );
-
+    burnchain.pox_constants = PoxConstants::test_20_no_sunset();
     let mut peer_inv = PeerBlocksInv::new(vec![0x01], vec![0x01], vec![0x01], 1, 1, 0);
     for i in 0..32 {
         let bit_flipped = peer_inv
@@ -478,21 +464,7 @@ fn test_inv_merge_pox_inv() {
 #[test]
 fn test_inv_truncate_pox_inv() {
     let mut burnchain = Burnchain::regtest("unused");
-    burnchain.pox_constants = PoxConstants::new(
-        5,
-        3,
-        3,
-        25,
-        5,
-        u64::MAX,
-        u64::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-        u32::MAX,
-    );
-
+    burnchain.pox_constants = PoxConstants::test_20_no_sunset();
     let mut peer_inv = PeerBlocksInv::new(vec![0x01], vec![0x01], vec![0x01], 1, 1, 0);
     for i in 0..5 {
         let bit_flipped_opt = peer_inv.merge_pox_inv(&burnchain, i + 1, 1, vec![0x00], false);
diff --git a/stackslib/src/net/tests/mod.rs b/stackslib/src/net/tests/mod.rs
index 859f0b57cf..44c19298e6 100644
--- a/stackslib/src/net/tests/mod.rs
+++ b/stackslib/src/net/tests/mod.rs
@@ -116,8 +116,6 @@ impl NakamotoBootPlan {
             3 * cycle_length + 1,
             // pox-3 activates at start of third cycle, just before v2 unlock
             2 * cycle_length + 1,
-            // pox-4 activates at start of fourth reward cycle, just before v3 unlock
-            3 * cycle_length + 1,
         );
         self.pox_constants = new_consts;
         self
diff --git a/testnet/stacks-node/src/tests/epoch_21.rs b/testnet/stacks-node/src/tests/epoch_21.rs
index 930e8f9098..e26468a254 100644
--- a/testnet/stacks-node/src/tests/epoch_21.rs
+++ b/testnet/stacks-node/src/tests/epoch_21.rs
@@ -103,7 +103,6 @@ fn advance_to_2_1(
         u32::MAX,
         u32::MAX,
         u32::MAX,
-        u32::MAX,
     ));
     burnchain_config.pox_constants = pox_constants.clone();
 
@@ -606,7 +605,6 @@ fn transition_fixes_bitcoin_rigidity() {
         u32::MAX,
         u32::MAX,
         u32::MAX,
-        u32::MAX,
     );
     burnchain_config.pox_constants = pox_constants.clone();
 
@@ -1052,7 +1050,6 @@ fn transition_adds_get_pox_addr_recipients() {
         u32::MAX,
         u32::MAX,
         u32::MAX,
-        u32::MAX,
     );
 
     let mut spender_sks = vec![];
@@ -1371,7 +1368,6 @@ fn transition_adds_mining_from_segwit() {
         u32::MAX,
         u32::MAX,
         u32::MAX,
-        u32::MAX,
     );
 
     let mut spender_sks = vec![];
@@ -1538,7 +1534,6 @@ fn transition_removes_pox_sunset() {
         u32::MAX,
         u32::MAX,
         u32::MAX,
-        u32::MAX,
     );
     burnchain_config.pox_constants = pox_constants.clone();
 
@@ -1822,7 +1817,6 @@ fn transition_empty_blocks() {
         u32::MAX,
         u32::MAX,
         u32::MAX,
-        u32::MAX,
     );
     burnchain_config.pox_constants = pox_constants.clone();
 
@@ -2182,7 +2176,6 @@ fn test_pox_reorgs_three_flaps() {
             u32::MAX,
             u32::MAX,
             u32::MAX,
-            u32::MAX,
         );
         burnchain_config.pox_constants = pox_constants.clone();
 
@@ -2720,7 +2713,6 @@ fn test_pox_reorg_one_flap() {
             u32::MAX,
             u32::MAX,
             u32::MAX,
-            u32::MAX,
         );
         burnchain_config.pox_constants = pox_constants.clone();
 
@@ -3146,7 +3138,6 @@ fn test_pox_reorg_flap_duel() {
             u32::MAX,
             u32::MAX,
             u32::MAX,
-            u32::MAX,
         );
         burnchain_config.pox_constants = pox_constants.clone();
 
@@ -3582,7 +3573,6 @@ fn test_pox_reorg_flap_reward_cycles() {
             u32::MAX,
             u32::MAX,
             u32::MAX,
-            u32::MAX,
         );
         burnchain_config.pox_constants = pox_constants.clone();
 
@@ -4012,7 +4002,6 @@ fn test_pox_missing_five_anchor_blocks() {
             u32::MAX,
             u32::MAX,
             u32::MAX,
-            u32::MAX,
         );
         burnchain_config.pox_constants = pox_constants.clone();
 
@@ -4414,7 +4403,6 @@ fn test_sortition_divergence_pre_21() {
             u32::MAX,
             u32::MAX,
             u32::MAX,
-            u32::MAX,
         );
         burnchain_config.pox_constants = pox_constants.clone();
 
@@ -4780,7 +4768,6 @@ fn trait_invocation_cross_epoch() {
         u32::MAX,
         u32::MAX,
         u32::MAX,
-        u32::MAX,
     );
     burnchain_config.pox_constants = pox_constants.clone();
 
@@ -5027,7 +5014,6 @@ fn test_v1_unlock_height_with_current_stackers() {
         u32::MAX,
         u32::MAX,
         u32::MAX,
-        u32::MAX,
     );
     burnchain_config.pox_constants = pox_constants.clone();
 
@@ -5293,7 +5279,6 @@ fn test_v1_unlock_height_with_delay_and_current_stackers() {
         u32::MAX,
         u32::MAX,
         u32::MAX,
-        u32::MAX,
     );
     burnchain_config.pox_constants = pox_constants.clone();
 
diff --git a/testnet/stacks-node/src/tests/epoch_22.rs b/testnet/stacks-node/src/tests/epoch_22.rs
index f3da65b853..5c58b26ded 100644
--- a/testnet/stacks-node/src/tests/epoch_22.rs
+++ b/testnet/stacks-node/src/tests/epoch_22.rs
@@ -166,7 +166,6 @@ fn disable_pox() {
         epoch_2_2 as u32 + 1,
         u32::MAX,
         u32::MAX,
-        u32::MAX,
     );
     burnchain_config.pox_constants = pox_constants.clone();
 
@@ -700,7 +699,6 @@ fn pox_2_unlock_all() {
         epoch_2_2 as u32 + 1,
         u32::MAX,
         u32::MAX,
-        u32::MAX,
     );
     burnchain_config.pox_constants = pox_constants.clone();
 
@@ -1397,7 +1395,6 @@ fn test_pox_reorg_one_flap() {
             v2_unlock_height.try_into().unwrap(),
             u32::MAX,
             u32::MAX,
-            u32::MAX,
         );
         burnchain_config.pox_constants = pox_constants.clone();
 
diff --git a/testnet/stacks-node/src/tests/epoch_23.rs b/testnet/stacks-node/src/tests/epoch_23.rs
index 1b0771d1ff..740785e182 100644
--- a/testnet/stacks-node/src/tests/epoch_23.rs
+++ b/testnet/stacks-node/src/tests/epoch_23.rs
@@ -134,7 +134,6 @@ fn trait_invocation_behavior() {
         epoch_2_2 as u32 + 1,
         u32::MAX,
         u32::MAX,
-        u32::MAX,
     );
     burnchain_config.pox_constants = pox_constants.clone();
 
diff --git a/testnet/stacks-node/src/tests/epoch_24.rs b/testnet/stacks-node/src/tests/epoch_24.rs
index 61af690e92..b88441838a 100644
--- a/testnet/stacks-node/src/tests/epoch_24.rs
+++ b/testnet/stacks-node/src/tests/epoch_24.rs
@@ -188,7 +188,6 @@ fn fix_to_pox_contract() {
         epoch_2_2 as u32 + 1,
         u32::MAX,
         pox_3_activation_height as u32,
-        u32::MAX,
     );
     burnchain_config.pox_constants = pox_constants.clone();
 
@@ -828,7 +827,6 @@ fn verify_auto_unlock_behavior() {
         epoch_2_2 as u32 + 1,
         u32::MAX,
         pox_3_activation_height as u32,
-        u32::MAX,
     );
     burnchain_config.pox_constants = pox_constants.clone();
 
diff --git a/testnet/stacks-node/src/tests/neon_integrations.rs b/testnet/stacks-node/src/tests/neon_integrations.rs
index afc1c0982d..67a264d930 100644
--- a/testnet/stacks-node/src/tests/neon_integrations.rs
+++ b/testnet/stacks-node/src/tests/neon_integrations.rs
@@ -2040,7 +2040,6 @@ fn stx_delegate_btc_integration_test() {
         u32::MAX,
         u32::MAX,
         u32::MAX,
-        u32::MAX,
     );
     burnchain_config.pox_constants = pox_constants.clone();
 
@@ -6072,7 +6071,6 @@ fn pox_integration_test() {
         u32::MAX,
         u32::MAX,
         u32::MAX,
-        u32::MAX,
     );
     burnchain_config.pox_constants = pox_constants.clone();
 
@@ -10782,7 +10780,6 @@ fn test_competing_miners_build_on_same_chain(
             u32::MAX,
             u32::MAX,
             u32::MAX,
-            u32::MAX,
         );
         burnchain_config.pox_constants = pox_constants.clone();
 

From 380f3673825a9c99be4d9ed8c360765201c30ca3 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 13 Feb 2024 16:26:43 -0500
Subject: [PATCH 0754/1166] fix: pass both headers connection and staging DB tx
 when storing a block

---
 stackslib/src/chainstate/nakamoto/mod.rs | 15 +++++++++++++--
 stackslib/src/net/relay.rs               |  3 ++-
 2 files changed, 15 insertions(+), 3 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index 41d0fcb907..a5042e1245 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -80,6 +80,7 @@ use crate::chainstate::nakamoto::tenure::NAKAMOTO_TENURES_SCHEMA;
 use crate::chainstate::stacks::address::PoxAddress;
 use crate::chainstate::stacks::boot::{POX_4_NAME, SIGNERS_UPDATE_STATE};
 use crate::chainstate::stacks::db::{DBConfig as ChainstateConfig, StacksChainState};
+use crate::chainstate::stacks::index::marf::MarfConnection;
 use crate::chainstate::stacks::{
     TenureChangeCause, MINER_BLOCK_CONSENSUS_HASH, MINER_BLOCK_HEADER_HASH,
 };
@@ -1263,6 +1264,15 @@ impl StacksChainState {
         Ok((header_tx, NakamotoStagingBlocksTx(staging_tx)))
     }
 
+    /// Open a connection to the headers DB, and open a tx to the staging DB
+    pub fn headers_conn_and_staging_tx_begin<'a>(
+        &'a mut self,
+    ) -> Result<(&'a rusqlite::Connection, NakamotoStagingBlocksTx<'a>), ChainstateError> {
+        let header_conn = self.state_index.sqlite_conn();
+        let staging_tx = tx_begin_immediate(&mut self.nakamoto_staging_blocks_conn)?;
+        Ok((header_conn, NakamotoStagingBlocksTx(staging_tx)))
+    }
+
     /// Get a ref to the nakamoto staging blocks connection
     pub fn nakamoto_blocks_db(&self) -> NakamotoStagingBlocksConnRef {
         NakamotoStagingBlocksConnRef(&self.nakamoto_staging_blocks_conn)
@@ -1992,11 +2002,12 @@ impl NakamotoChainState {
         block: NakamotoBlock,
         db_handle: &mut SortitionHandleConn,
         staging_db_tx: &NakamotoStagingBlocksTx,
+        headers_conn: &Connection,
         aggregate_public_key: &Point,
     ) -> Result<bool, ChainstateError> {
         test_debug!("Consider Nakamoto block {}", &block.block_id());
         // do nothing if we already have this block
-        if let Some(_) = Self::get_block_header(staging_db_tx, &block.header.block_id())? {
+        if let Some(_) = Self::get_block_header(headers_conn, &block.header.block_id())? {
             debug!("Already have block {}", &block.header.block_id());
             return Ok(false);
         }
@@ -2019,7 +2030,7 @@ impl NakamotoChainState {
             ChainstateError::InvalidStacksBlock("Not a well-formed tenure-extend block".into())
         })?;
 
-        let Ok(expected_burn) = Self::get_expected_burns(db_handle, staging_db_tx, &block) else {
+        let Ok(expected_burn) = Self::get_expected_burns(db_handle, headers_conn, &block) else {
             warn!("Unacceptable Nakamoto block: unable to find its paired sortition";
                   "block_id" => %block.block_id(),
             );
diff --git a/stackslib/src/net/relay.rs b/stackslib/src/net/relay.rs
index e4ff1ef9ba..27d59b3123 100644
--- a/stackslib/src/net/relay.rs
+++ b/stackslib/src/net/relay.rs
@@ -730,12 +730,13 @@ impl Relayer {
             );
             return Ok(false);
         };
-        let staging_db_tx = chainstate.staging_db_tx_begin()?;
+        let (headers_conn, staging_db_tx) = chainstate.headers_conn_and_staging_tx_begin()?;
         let accepted = NakamotoChainState::accept_block(
             &config,
             block,
             sort_handle,
             &staging_db_tx,
+            headers_conn,
             &aggregate_public_key,
         )?;
         staging_db_tx.commit()?;

From f3db98d478938563980f7466b432a008eb5b48b7 Mon Sep 17 00:00:00 2001
From: wileyj <2847772+wileyj@users.noreply.github.com>
Date: Tue, 13 Feb 2024 13:33:36 -0800
Subject: [PATCH 0755/1166] use latest commit for workflow generating archive
 checksums

---
 .github/workflows/github-release.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/github-release.yml b/.github/workflows/github-release.yml
index 14e7117a95..d91d42dc09 100644
--- a/.github/workflows/github-release.yml
+++ b/.github/workflows/github-release.yml
@@ -59,7 +59,7 @@ jobs:
       ## Generate a checksums file to be added to the release page
       - name: Generate Checksums
         id: generate_checksum
-        uses: jmgilman/actions-generate-checksum@24a35957fba81c6cbaefeb1e3d59ee56e3db5077 # v1.0.0
+        uses: jmgilman/actions-generate-checksum@3ea6dc9bf8eecf28e2ecc982fab683484a1a8561 # v1.0.1
         with:
           method: sha512
           output: CHECKSUMS.txt

From ccc20fcc0cfc0ca050bd8c32a8e68b516236f3e8 Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Tue, 13 Feb 2024 16:38:31 -0500
Subject: [PATCH 0756/1166] refactor: improve testing functions related to
 signing

---
 .../chainstate/nakamoto/coordinator/tests.rs  | 175 ++++++++++++------
 .../chainstate/stacks/boot/signers_tests.rs   |  18 +-
 2 files changed, 131 insertions(+), 62 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index 4457b9014d..828f0e224b 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -38,10 +38,10 @@ use crate::chainstate::nakamoto::tests::get_account;
 use crate::chainstate::nakamoto::tests::node::{TestSigners, TestStacker};
 use crate::chainstate::nakamoto::{NakamotoBlock, NakamotoChainState};
 use crate::chainstate::stacks::address::PoxAddress;
-use crate::chainstate::stacks::boot::signers_tests::readonly_call;
+use crate::chainstate::stacks::boot::signers_tests::{readonly_call, readonly_call_with_sortdb};
 use crate::chainstate::stacks::boot::test::{
     key_to_stacks_addr, make_pox_4_lockup, make_signer_key_signature,
-    make_signers_vote_for_aggregate_public_key,
+    make_signers_vote_for_aggregate_public_key, with_sortdb,
 };
 use crate::chainstate::stacks::boot::{MINERS_NAME, SIGNERS_NAME};
 use crate::chainstate::stacks::db::{MinerPaymentTxFees, StacksAccount, StacksChainState};
@@ -108,59 +108,16 @@ fn advance_to_nakamoto(
                 })
                 .collect()
         } else if sortition_height == 8 {
-            // Retrieve the signers from the contract
-            let signers_res = readonly_call(
-                peer,
-                &tip.unwrap(),
-                SIGNERS_NAME.into(),
-                "get-signers".into(),
-                vec![Value::UInt(7)],
-            );
-            let signer_vec = signers_res
-                .expect_optional()
-                .unwrap()
-                .unwrap()
-                .expect_list()
-                .unwrap();
-            let mut signers_to_index = HashMap::new();
-            for (index, value) in signer_vec.into_iter().enumerate() {
-                let tuple = value.expect_tuple().unwrap();
-                let signer = tuple
-                    .get_owned("signer")
-                    .unwrap()
-                    .expect_principal()
-                    .unwrap();
-                signers_to_index.insert(signer, index);
-            }
-
-            // Build a map of the signers, their private keys, and their index
-            let mut signers = HashMap::new();
-            for test_stacker in test_stackers {
-                let addr = key_to_stacks_addr(&test_stacker.signer_private_key);
-                let principal = PrincipalData::from(addr);
-                signers.insert(
-                    addr,
-                    (
-                        test_stacker.signer_private_key,
-                        signers_to_index[&principal],
-                    ),
-                );
-            }
-
-            // Vote for the aggregate key for each signer
-            signers
-                .values()
-                .map(|(signer_key, index)| {
-                    make_signers_vote_for_aggregate_public_key(
-                        signer_key,
-                        0,
-                        *index as u128,
-                        &test_signers.aggregate_public_key,
-                        0,
-                        7,
-                    )
-                })
-                .collect()
+            with_sortdb(peer, |chainstate, sortdb| {
+                make_all_signers_vote_for_aggregate_key(
+                    chainstate,
+                    sortdb,
+                    &tip.unwrap(),
+                    test_signers,
+                    test_stackers,
+                    7,
+                )
+            })
         } else {
             vec![]
         };
@@ -170,6 +127,79 @@ fn advance_to_nakamoto(
     // peer is at the start of cycle 8
 }
 
+pub fn make_all_signers_vote_for_aggregate_key(
+    chainstate: &mut StacksChainState,
+    sortdb: &SortitionDB,
+    tip: &StacksBlockId,
+    test_signers: &TestSigners,
+    test_stackers: &[TestStacker],
+    cycle_id: u128,
+) -> Vec<StacksTransaction> {
+    // Check if we already have an aggregate key for this cycle
+    if chainstate
+        .get_aggregate_public_key_pox_4(sortdb, tip, cycle_id as u64)
+        .unwrap()
+        .is_some()
+    {
+        return vec![];
+    }
+
+    let signers_res = readonly_call_with_sortdb(
+        chainstate,
+        sortdb,
+        tip,
+        SIGNERS_NAME.into(),
+        "get-signers".into(),
+        vec![Value::UInt(cycle_id)],
+    );
+    let signer_vec = signers_res
+        .expect_optional()
+        .unwrap()
+        .unwrap()
+        .expect_list()
+        .unwrap();
+    let mut signers_to_index = HashMap::new();
+    for (index, value) in signer_vec.into_iter().enumerate() {
+        let tuple = value.expect_tuple().unwrap();
+        let signer = tuple
+            .get_owned("signer")
+            .unwrap()
+            .expect_principal()
+            .unwrap();
+        signers_to_index.insert(signer, index);
+    }
+
+    // Build a map of the signers, their private keys, and their index
+    let mut signers = HashMap::new();
+    for test_stacker in test_stackers {
+        let addr = key_to_stacks_addr(&test_stacker.signer_private_key);
+        let principal = PrincipalData::from(addr);
+        signers.insert(
+            addr,
+            (
+                test_stacker.signer_private_key,
+                signers_to_index[&principal],
+            ),
+        );
+    }
+
+    // Vote for the aggregate key for each signer
+    signers
+        .iter()
+        .map(|(addr, (signer_key, index))| {
+            let account = get_account(chainstate, sortdb, &addr);
+            make_signers_vote_for_aggregate_public_key(
+                signer_key,
+                account.nonce,
+                *index as u128,
+                &test_signers.aggregate_public_key,
+                0,
+                cycle_id,
+            )
+        })
+        .collect()
+}
+
 /// Make a peer and transition it into the Nakamoto epoch.
 /// The node needs to be stacking and it needs to vote for an aggregate key;
 /// otherwise, Nakamoto can't activate.
@@ -1054,7 +1084,7 @@ pub fn simple_nakamoto_coordinator_10_tenures_10_sortitions<'a>() -> TestPeer<'a
         None,
     );
 
-    let mut all_blocks = vec![];
+    let mut all_blocks: Vec<NakamotoBlock> = vec![];
     let mut all_burn_ops = vec![];
     let mut rc_blocks = vec![];
     let mut rc_burn_ops = vec![];
@@ -1088,6 +1118,34 @@ pub fn simple_nakamoto_coordinator_10_tenures_10_sortitions<'a>() -> TestPeer<'a
 
         let num_blocks: usize = (thread_rng().gen::<usize>() % 10) + 1;
 
+        let block_height = peer
+            .config
+            .burnchain
+            .get_highest_burnchain_block()
+            .unwrap()
+            .unwrap()
+            .block_height;
+        let cycle_id = peer
+            .config
+            .burnchain
+            .block_height_to_reward_cycle(block_height)
+            .unwrap();
+
+        let txs = with_sortdb(&mut peer, |chainstate, sortdb| {
+            if let Some(tip) = all_blocks.last() {
+                make_all_signers_vote_for_aggregate_key(
+                    chainstate,
+                    sortdb,
+                    &tip.block_id(),
+                    &test_signers,
+                    &test_stackers,
+                    cycle_id as u128,
+                )
+            } else {
+                vec![]
+            }
+        });
+
         // do a stx transfer in each block to a given recipient
         let recipient_addr =
             StacksAddress::from_string("ST2YM3J4KQK09V670TD6ZZ1XYNYCNGCWCVTASN5VM").unwrap();
@@ -1110,10 +1168,9 @@ pub fn simple_nakamoto_coordinator_10_tenures_10_sortitions<'a>() -> TestPeer<'a
                         1,
                         &recipient_addr,
                     );
-                    vec![stx_transfer]
-                } else {
-                    vec![]
+                    txs_clone.push(stx_transfer);
                 }
+                txs_clone
             },
         );
 
diff --git a/stackslib/src/chainstate/stacks/boot/signers_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_tests.rs
index 1097ce92a1..0943f489cb 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_tests.rs
@@ -469,7 +469,20 @@ pub fn readonly_call(
     args: Vec<Value>,
 ) -> Value {
     with_sortdb(peer, |chainstate, sortdb| {
-        chainstate.with_read_only_clarity_tx(&sortdb.index_conn(), tip, |connection| {
+        readonly_call_with_sortdb(chainstate, sortdb, tip, boot_contract, function_name, args)
+    })
+}
+
+pub fn readonly_call_with_sortdb(
+    chainstate: &mut StacksChainState,
+    sortdb: &SortitionDB,
+    tip: &StacksBlockId,
+    boot_contract: ContractName,
+    function_name: ClarityName,
+    args: Vec<Value>,
+) -> Value {
+    chainstate
+        .with_read_only_clarity_tx(&sortdb.index_conn(), tip, |connection| {
             connection
                 .with_readonly_clarity_env(
                     false,
@@ -489,8 +502,7 @@ pub fn readonly_call(
                 )
                 .unwrap()
         })
-    })
-    .unwrap()
+        .unwrap()
 }
 
 pub fn get_signer_index(

From 0ae6bec53a0a53cc0d36d4a13d3352bd0489e4aa Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Tue, 13 Feb 2024 16:45:10 -0500
Subject: [PATCH 0757/1166] fix: use new accept_block() API

---
 testnet/stacks-node/src/mockamoto.rs           | 3 ++-
 testnet/stacks-node/src/nakamoto_node/miner.rs | 6 ++++--
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index 77a0993b8f..47c07e8fc9 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -1039,12 +1039,13 @@ impl MockamotoNode {
             aggregate_public_key
         };
         self.self_signer.sign_nakamoto_block(&mut block);
-        let staging_tx = self.chainstate.staging_db_tx_begin()?;
+        let (headers_conn, staging_tx) = self.chainstate.headers_conn_and_staging_tx_begin()?;
         NakamotoChainState::accept_block(
             &config,
             block,
             &mut sortition_handle,
             &staging_tx,
+            headers_conn,
             &aggregate_public_key,
         )?;
         staging_tx.commit()?;
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index 074db03095..f4de91273c 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -404,12 +404,13 @@ impl BlockMinerThread {
                 ChainstateError::InvalidStacksBlock(format!("Invalid Nakamoto block: {e:?}"))
             })?;
         block.header.signer_signature = signature;
-        let staging_tx = chain_state.staging_db_tx_begin()?;
+        let (headers_conn, staging_tx) = chain_state.headers_conn_and_staging_tx_begin()?;
         NakamotoChainState::accept_block(
             &chainstate_config,
             block,
             &mut sortition_handle,
             &staging_tx,
+            headers_conn,
             &aggregate_public_key,
         )?;
         staging_tx.commit()?;
@@ -444,12 +445,13 @@ impl BlockMinerThread {
             aggregate_public_key
         };
 
-        let staging_tx = chain_state.staging_db_tx_begin()?;
+        let (headers_conn, staging_tx) = chain_state.headers_conn_and_staging_tx_begin()?;
         NakamotoChainState::accept_block(
             &chainstate_config,
             block,
             &mut sortition_handle,
             &staging_tx,
+            headers_conn,
             &aggregate_public_key,
         )?;
         staging_tx.commit()?;

From 2970970facb8de524b0e85e479d8bf9569c54f28 Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Tue, 13 Feb 2024 17:08:58 -0500
Subject: [PATCH 0758/1166] chore: increase debug logging

---
 .../chainstate/nakamoto/coordinator/tests.rs   |  1 +
 .../src/chainstate/stacks/db/transactions.rs   | 18 ++++++++++++++++++
 2 files changed, 19 insertions(+)

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index 828f0e224b..40463fca52 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -1101,6 +1101,7 @@ pub fn simple_nakamoto_coordinator_10_tenures_10_sortitions<'a>() -> TestPeer<'a
     .unwrap();
 
     for i in 0..10 {
+        debug!("Tenure {}", i);
         let (burn_ops, mut tenure_change, miner_key) =
             peer.begin_nakamoto_tenure(TenureChangeCause::BlockFound);
         let (_, _, consensus_hash) = peer.next_burnchain_block(burn_ops.clone());
diff --git a/stackslib/src/chainstate/stacks/db/transactions.rs b/stackslib/src/chainstate/stacks/db/transactions.rs
index 0c13137444..b0822b817c 100644
--- a/stackslib/src/chainstate/stacks/db/transactions.rs
+++ b/stackslib/src/chainstate/stacks/db/transactions.rs
@@ -1043,6 +1043,9 @@ impl StacksChainState {
                 let (result, asset_map, events) = match contract_call_resp {
                     Ok((return_value, asset_map, events)) => {
                         info!("Contract-call successfully processed";
+                              "txid" => %tx.txid(),
+                              "origin" => %origin_account.principal,
+                              "origin_nonce" => %origin_account.nonce,
                               "contract_name" => %contract_id,
                               "function_name" => %contract_call.function_name,
                               "function_args" => %VecDisplay(&contract_call.function_args),
@@ -1053,6 +1056,9 @@ impl StacksChainState {
                     Err(e) => match handle_clarity_runtime_error(e) {
                         ClarityRuntimeTxError::Acceptable { error, err_type } => {
                             info!("Contract-call processed with {}", err_type;
+                                      "txid" => %tx.txid(),
+                                      "origin" => %origin_account.principal,
+                                      "origin_nonce" => %origin_account.nonce,
                                       "contract_name" => %contract_id,
                                       "function_name" => %contract_call.function_name,
                                       "function_args" => %VecDisplay(&contract_call.function_args),
@@ -1061,6 +1067,9 @@ impl StacksChainState {
                         }
                         ClarityRuntimeTxError::AbortedByCallback(value, assets, events) => {
                             info!("Contract-call aborted by post-condition";
+                                      "txid" => %tx.txid(),
+                                      "origin" => %origin_account.principal,
+                                      "origin_nonce" => %origin_account.nonce,
                                       "contract_name" => %contract_id,
                                       "function_name" => %contract_call.function_name,
                                       "function_args" => %VecDisplay(&contract_call.function_args));
@@ -1081,6 +1090,9 @@ impl StacksChainState {
                                 // in 2.1 and later, this is a permitted runtime error.  take the
                                 // fee from the payer and keep the tx.
                                 warn!("Contract-call encountered an analysis error at runtime";
+                                      "txid" => %tx.txid(),
+                                      "origin" => %origin_account.principal,
+                                      "origin_nonce" => %origin_account.nonce,
                                       "contract_name" => %contract_id,
                                       "function_name" => %contract_call.function_name,
                                       "function_args" => %VecDisplay(&contract_call.function_args),
@@ -1096,6 +1108,9 @@ impl StacksChainState {
                             } else {
                                 // prior to 2.1, this is not permitted in a block.
                                 warn!("Unexpected analysis error invalidating transaction: if included, this will invalidate a block";
+                                          "txid" => %tx.txid(),
+                                          "origin" => %origin_account.principal,
+                                          "origin_nonce" => %origin_account.nonce,
                                            "contract_name" => %contract_id,
                                            "function_name" => %contract_call.function_name,
                                            "function_args" => %VecDisplay(&contract_call.function_args),
@@ -1107,6 +1122,9 @@ impl StacksChainState {
                         }
                         ClarityRuntimeTxError::Rejectable(e) => {
                             error!("Unexpected error in validating transaction: if included, this will invalidate a block";
+                                       "txid" => %tx.txid(),
+                                       "origin" => %origin_account.principal,
+                                       "origin_nonce" => %origin_account.nonce,
                                        "contract_name" => %contract_id,
                                        "function_name" => %contract_call.function_name,
                                        "function_args" => %VecDisplay(&contract_call.function_args),

From 60f0e07b0693deb032b60b10e0cfa5625612af8a Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Tue, 13 Feb 2024 17:09:34 -0500
Subject: [PATCH 0759/1166] test: only vote in first nakamoto block of tenure

---
 .../src/chainstate/nakamoto/coordinator/tests.rs      | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index 40463fca52..571da71423 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -1155,6 +1155,13 @@ pub fn simple_nakamoto_coordinator_10_tenures_10_sortitions<'a>() -> TestPeer<'a
             coinbase_tx,
             &mut test_signers,
             |miner, chainstate, sortdb, blocks_so_far| {
+                // Include the aggregate key voting transactions in the first block.
+                let mut txs = if blocks_so_far.is_empty() {
+                    txs.clone()
+                } else {
+                    vec![]
+                };
+
                 if blocks_so_far.len() < num_blocks {
                     debug!("\n\nProduce block {}\n\n", all_blocks.len());
 
@@ -1169,9 +1176,9 @@ pub fn simple_nakamoto_coordinator_10_tenures_10_sortitions<'a>() -> TestPeer<'a
                         1,
                         &recipient_addr,
                     );
-                    txs_clone.push(stx_transfer);
+                    txs.push(stx_transfer);
                 }
-                txs_clone
+                txs
             },
         );
 

From 407f3be77d35934e1cef62488f2b7dd227dd413b Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Tue, 13 Feb 2024 20:46:26 -0500
Subject: [PATCH 0760/1166] Add generate_aggregate_key to TestSigners

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 .../src/chainstate/nakamoto/tests/node.rs     | 39 +++++++++++++++++++
 .../stacks/boot/signers_voting_tests.rs       |  3 +-
 2 files changed, 41 insertions(+), 1 deletion(-)

diff --git a/stackslib/src/chainstate/nakamoto/tests/node.rs b/stackslib/src/chainstate/nakamoto/tests/node.rs
index 1b4828c024..4ba2c5dbdc 100644
--- a/stackslib/src/chainstate/nakamoto/tests/node.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/node.rs
@@ -119,6 +119,8 @@ pub struct TestSigners {
     pub num_keys: u32,
     /// The number of vote shares required to sign a block
     pub threshold: u32,
+    /// The key ids distributed among signer_parties
+    pub party_key_ids: Vec<Vec<u32>>,
 }
 
 impl Default for TestSigners {
@@ -164,6 +166,7 @@ impl Default for TestSigners {
             poly_commitments,
             num_keys,
             threshold,
+            party_key_ids,
         }
     }
 }
@@ -184,6 +187,42 @@ impl TestSigners {
             .expect("aggregator sig failed");
         block.header.signer_signature = ThresholdSignature(signature);
     }
+
+    // Generate and assign a new aggregate public key
+    pub fn generate_aggregate_key(&mut self) -> Point {
+        let mut rng = rand_core::OsRng;
+        let num_parties = self.party_key_ids.len().try_into().unwrap();
+        // Create the parties
+        self.signer_parties = self
+            .party_key_ids
+            .iter()
+            .enumerate()
+            .map(|(pid, pkids)| {
+                wsts::v2::Party::new(
+                    pid.try_into().unwrap(),
+                    pkids,
+                    num_parties,
+                    self.num_keys,
+                    self.threshold,
+                    &mut rng,
+                )
+            })
+            .collect();
+        let poly_commitments = match wsts::v2::test_helpers::dkg(&mut self.signer_parties, &mut rng)
+        {
+            Ok(poly_commitments) => poly_commitments,
+            Err(secret_errors) => {
+                panic!("Got secret errors from DKG: {:?}", secret_errors);
+            }
+        };
+        let mut sig_aggregator = wsts::v2::Aggregator::new(self.num_keys, self.threshold);
+        sig_aggregator
+            .init(&poly_commitments)
+            .expect("aggregator init failed");
+        let aggregate_public_key = sig_aggregator.poly[0];
+        self.aggregate_public_key = aggregate_public_key;
+        self.aggregate_public_key.clone()
+    }
 }
 
 impl TestBurnchainBlock {
diff --git a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
index 89370b228e..d84d5157af 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
@@ -42,7 +42,8 @@ use stacks_common::types::chainstate::{
 use stacks_common::types::{Address, PrivateKey};
 use stacks_common::util::hash::{hex_bytes, to_hex, Sha256Sum, Sha512Trunc256Sum};
 use stacks_common::util::secp256k1::Secp256k1PrivateKey;
-use wsts::curve::{point::Point, scalar::Scalar};
+use wsts::curve::point::Point;
+use wsts::curve::scalar::Scalar;
 
 use super::test::*;
 use super::RawRewardSetEntry;

From 02bd070f2df50873083b8e39ecfdf9ff644977da Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Tue, 13 Feb 2024 21:02:30 -0500
Subject: [PATCH 0761/1166] test: use `generate_aggregate_key` between cycles

---
 .../chainstate/nakamoto/coordinator/tests.rs  | 33 +++++++++++--------
 .../src/chainstate/nakamoto/tests/mod.rs      |  8 ++---
 .../chainstate/stacks/boot/signers_tests.rs   |  2 +-
 3 files changed, 25 insertions(+), 18 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index 571da71423..19bf442cc7 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -61,7 +61,7 @@ use crate::util_lib::signed_structured_data::pox4::Pox4SignatureTopic;
 /// Bring a TestPeer into the Nakamoto Epoch
 fn advance_to_nakamoto(
     peer: &mut TestPeer,
-    test_signers: &TestSigners,
+    test_signers: &mut TestSigners,
     test_stackers: &[TestStacker],
 ) {
     let mut peer_nonce = 0;
@@ -131,7 +131,7 @@ pub fn make_all_signers_vote_for_aggregate_key(
     chainstate: &mut StacksChainState,
     sortdb: &SortitionDB,
     tip: &StacksBlockId,
-    test_signers: &TestSigners,
+    test_signers: &mut TestSigners,
     test_stackers: &[TestStacker],
     cycle_id: u128,
 ) -> Vec<StacksTransaction> {
@@ -144,6 +144,9 @@ pub fn make_all_signers_vote_for_aggregate_key(
         return vec![];
     }
 
+    // Generate a new aggregate key
+    test_signers.generate_aggregate_key();
+
     let signers_res = readonly_call_with_sortdb(
         chainstate,
         sortdb,
@@ -206,7 +209,7 @@ pub fn make_all_signers_vote_for_aggregate_key(
 pub fn boot_nakamoto<'a>(
     test_name: &str,
     mut initial_balances: Vec<(PrincipalData, u64)>,
-    test_signers: &TestSigners,
+    test_signers: &mut TestSigners,
     test_stackers: &[TestStacker],
     observer: Option<&'a TestEventObserver>,
 ) -> TestPeer<'a> {
@@ -265,7 +268,7 @@ pub fn boot_nakamoto<'a>(
     peer_config.test_signers = Some(test_signers.clone());
     let mut peer = TestPeer::new_with_observer(peer_config, observer);
 
-    advance_to_nakamoto(&mut peer, &test_signers, test_stackers);
+    advance_to_nakamoto(&mut peer, test_signers, test_stackers);
 
     peer
 }
@@ -279,10 +282,14 @@ fn make_replay_peer<'a>(peer: &mut TestPeer<'a>) -> TestPeer<'a> {
     replay_config.test_stackers = peer.config.test_stackers.clone();
 
     let test_stackers = replay_config.test_stackers.clone().unwrap_or(vec![]);
-    let test_signers = replay_config.test_signers.clone().unwrap();
+    let mut test_signers = replay_config.test_signers.clone().unwrap();
     let mut replay_peer = TestPeer::new(replay_config);
     let observer = TestEventObserver::new();
-    advance_to_nakamoto(&mut replay_peer, &test_signers, test_stackers.as_slice());
+    advance_to_nakamoto(
+        &mut replay_peer,
+        &mut test_signers,
+        test_stackers.as_slice(),
+    );
 
     // sanity check
     let replay_tip = {
@@ -401,7 +408,7 @@ fn test_simple_nakamoto_coordinator_bootup() {
     let mut peer = boot_nakamoto(
         function_name!(),
         vec![],
-        &test_signers,
+        &mut test_signers,
         &test_stackers,
         None,
     );
@@ -464,7 +471,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,
+        &mut test_signers,
         &test_stackers,
         None,
     );
@@ -588,7 +595,7 @@ fn test_nakamoto_chainstate_getters() {
     let mut peer = boot_nakamoto(
         function_name!(),
         vec![(addr.into(), 100_000_000)],
-        &test_signers,
+        &mut test_signers,
         &test_stackers,
         None,
     );
@@ -1079,7 +1086,7 @@ pub fn simple_nakamoto_coordinator_10_tenures_10_sortitions<'a>() -> TestPeer<'a
     let mut peer = boot_nakamoto(
         function_name!(),
         vec![(addr.into(), 100_000_000)],
-        &test_signers,
+        &mut test_signers,
         &test_stackers,
         None,
     );
@@ -1138,7 +1145,7 @@ pub fn simple_nakamoto_coordinator_10_tenures_10_sortitions<'a>() -> TestPeer<'a
                     chainstate,
                     sortdb,
                     &tip.block_id(),
-                    &test_signers,
+                    &mut test_signers,
                     &test_stackers,
                     cycle_id as u128,
                 )
@@ -1444,7 +1451,7 @@ pub fn simple_nakamoto_coordinator_2_tenures_3_sortitions<'a>() -> TestPeer<'a>
     let mut peer = boot_nakamoto(
         function_name!(),
         vec![(addr.into(), 100_000_000)],
-        &test_signers,
+        &mut test_signers,
         &test_stackers,
         None,
     );
@@ -1781,7 +1788,7 @@ pub fn simple_nakamoto_coordinator_10_extended_tenures_10_sortitions() -> TestPe
     let mut peer = boot_nakamoto(
         function_name!(),
         vec![(addr.into(), 100_000_000)],
-        &test_signers,
+        &mut test_signers,
         &test_stackers,
         None,
     );
diff --git a/stackslib/src/chainstate/nakamoto/tests/mod.rs b/stackslib/src/chainstate/nakamoto/tests/mod.rs
index d2de8b67dc..a9bc506ff9 100644
--- a/stackslib/src/chainstate/nakamoto/tests/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/mod.rs
@@ -1501,12 +1501,12 @@ fn make_fork_run_with_arrivals(
 /// Tests that getting the highest nakamoto tenure works in the presence of forks
 #[test]
 pub fn test_get_highest_nakamoto_tenure() {
-    let test_signers = TestSigners::default();
+    let mut test_signers = TestSigners::default();
     let test_stackers = TestStacker::common_signing_set(&test_signers);
     let mut peer = boot_nakamoto(
         function_name!(),
         vec![],
-        &test_signers,
+        &mut test_signers,
         &test_stackers,
         None,
     );
@@ -1650,12 +1650,12 @@ pub fn test_get_highest_nakamoto_tenure() {
 /// to have slot i in subsequent sortitions.
 #[test]
 fn test_make_miners_stackerdb_config() {
-    let test_signers = TestSigners::default();
+    let mut test_signers = TestSigners::default();
     let test_stackers = TestStacker::common_signing_set(&test_signers);
     let mut peer = boot_nakamoto(
         function_name!(),
         vec![],
-        &test_signers,
+        &mut test_signers,
         &test_stackers,
         None,
     );
diff --git a/stackslib/src/chainstate/stacks/boot/signers_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_tests.rs
index 0943f489cb..6a567e52c4 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_tests.rs
@@ -353,7 +353,7 @@ pub fn prepare_signers_test<'a>(
     let mut peer = boot_nakamoto(
         test_name,
         initial_balances,
-        &test_signers,
+        &mut test_signers,
         stackers,
         observer,
     );

From 00c5eba97f2de0e471a291b21b01b79d9c9788e5 Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Tue, 13 Feb 2024 21:13:30 -0500
Subject: [PATCH 0762/1166] fix: update `poly_commitments` in
 `generate_aggregate_key`

---
 .../src/chainstate/nakamoto/tests/node.rs     | 19 +++++++++----------
 1 file changed, 9 insertions(+), 10 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/tests/node.rs b/stackslib/src/chainstate/nakamoto/tests/node.rs
index 4ba2c5dbdc..d1d6f61605 100644
--- a/stackslib/src/chainstate/nakamoto/tests/node.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/node.rs
@@ -208,19 +208,18 @@ impl TestSigners {
                 )
             })
             .collect();
-        let poly_commitments = match wsts::v2::test_helpers::dkg(&mut self.signer_parties, &mut rng)
-        {
-            Ok(poly_commitments) => poly_commitments,
-            Err(secret_errors) => {
-                panic!("Got secret errors from DKG: {:?}", secret_errors);
-            }
-        };
+        self.poly_commitments =
+            match wsts::v2::test_helpers::dkg(&mut self.signer_parties, &mut rng) {
+                Ok(poly_commitments) => poly_commitments,
+                Err(secret_errors) => {
+                    panic!("Got secret errors from DKG: {:?}", secret_errors);
+                }
+            };
         let mut sig_aggregator = wsts::v2::Aggregator::new(self.num_keys, self.threshold);
         sig_aggregator
-            .init(&poly_commitments)
+            .init(&self.poly_commitments)
             .expect("aggregator init failed");
-        let aggregate_public_key = sig_aggregator.poly[0];
-        self.aggregate_public_key = aggregate_public_key;
+        self.aggregate_public_key = sig_aggregator.poly[0];
         self.aggregate_public_key.clone()
     }
 }

From 1592b5383e94702dccc658e5c6ace6a4649b378a Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Wed, 14 Feb 2024 10:44:42 -0500
Subject: [PATCH 0763/1166] test: vote for aggregate key of next cycle in
 prepare phase

---
 .../chainstate/nakamoto/coordinator/tests.rs  | 65 ++++++++++++-------
 stackslib/src/chainstate/stacks/boot/mod.rs   |  2 +
 2 files changed, 42 insertions(+), 25 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index 19bf442cc7..3eafc06dc1 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -135,12 +135,15 @@ pub fn make_all_signers_vote_for_aggregate_key(
     test_stackers: &[TestStacker],
     cycle_id: u128,
 ) -> Vec<StacksTransaction> {
+    debug!("Trigger signers vote for cycle {}", cycle_id);
+
     // Check if we already have an aggregate key for this cycle
     if chainstate
         .get_aggregate_public_key_pox_4(sortdb, tip, cycle_id as u64)
         .unwrap()
         .is_some()
     {
+        debug!("Aggregate key already set for cycle {}", cycle_id);
         return vec![];
     }
 
@@ -155,12 +158,16 @@ pub fn make_all_signers_vote_for_aggregate_key(
         "get-signers".into(),
         vec![Value::UInt(cycle_id)],
     );
-    let signer_vec = signers_res
-        .expect_optional()
-        .unwrap()
-        .unwrap()
-        .expect_list()
-        .unwrap();
+
+    // If the signers are not set yet, then we're not ready to vote yet.
+    let signer_vec = match signers_res.expect_optional().unwrap() {
+        Some(signer_vec) => signer_vec.expect_list().unwrap(),
+        None => {
+            debug!("No signers set for cycle {}", cycle_id);
+            return vec![];
+        }
+    };
+
     let mut signers_to_index = HashMap::new();
     for (index, value) in signer_vec.into_iter().enumerate() {
         let tuple = value.expect_tuple().unwrap();
@@ -187,6 +194,7 @@ pub fn make_all_signers_vote_for_aggregate_key(
     }
 
     // Vote for the aggregate key for each signer
+    debug!("Trigger votes for cycle {}", cycle_id);
     signers
         .iter()
         .map(|(addr, (signer_key, index))| {
@@ -1133,26 +1141,33 @@ pub fn simple_nakamoto_coordinator_10_tenures_10_sortitions<'a>() -> TestPeer<'a
             .unwrap()
             .unwrap()
             .block_height;
-        let cycle_id = peer
-            .config
-            .burnchain
-            .block_height_to_reward_cycle(block_height)
-            .unwrap();
+        // If we are in the prepare phase, check if we need to generate
+        // aggregate key votes
+        let txs = if peer.config.burnchain.is_in_prepare_phase(block_height) {
+            let cycle_id = peer
+                .config
+                .burnchain
+                .block_height_to_reward_cycle(block_height)
+                .unwrap();
+            let next_cycle_id = cycle_id as u128 + 1;
 
-        let txs = with_sortdb(&mut peer, |chainstate, sortdb| {
-            if let Some(tip) = all_blocks.last() {
-                make_all_signers_vote_for_aggregate_key(
-                    chainstate,
-                    sortdb,
-                    &tip.block_id(),
-                    &mut test_signers,
-                    &test_stackers,
-                    cycle_id as u128,
-                )
-            } else {
-                vec![]
-            }
-        });
+            with_sortdb(&mut peer, |chainstate, sortdb| {
+                if let Some(tip) = all_blocks.last() {
+                    make_all_signers_vote_for_aggregate_key(
+                        chainstate,
+                        sortdb,
+                        &tip.block_id(),
+                        &mut test_signers,
+                        &test_stackers,
+                        next_cycle_id,
+                    )
+                } else {
+                    vec![]
+                }
+            })
+        } else {
+            vec![]
+        };
 
         // do a stx transfer in each block to a given recipient
         let recipient_addr =
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index e63ba90712..735b594190 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -1912,6 +1912,8 @@ pub mod test {
         round: u128,
         cycle: u128,
     ) -> StacksTransaction {
+        debug!("Vote for aggregate key in cycle {}, round {}", cycle, round);
+
         let aggregate_public_key = Value::buff_from(aggregate_public_key.compress().data.to_vec())
             .expect("Failed to serialize aggregate public key");
         let payload = TransactionPayload::new_contract_call(

From 04f7a59381f0c49329ae0f6dc5b07a4b3a215fb6 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Wed, 14 Feb 2024 11:14:25 -0600
Subject: [PATCH 0764/1166] test: ignore stalling runloop test + fix flaky neon
 test

---
 stacks-signer/src/runloop.rs                       | 2 ++
 testnet/stacks-node/src/tests/neon_integrations.rs | 5 +++--
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index ccce59aeaf..a5a7f12bcc 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -1402,6 +1402,8 @@ mod tests {
 
     #[test]
     #[serial]
+    // TODO(CI): This test function stalls in CI. Ignoring for now, but this test needs to be fixed.
+    #[ignore]
     fn get_expected_transactions_should_filter_invalid_transactions() {
         // Create a runloop of a valid signer
         let config = Config::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
diff --git a/testnet/stacks-node/src/tests/neon_integrations.rs b/testnet/stacks-node/src/tests/neon_integrations.rs
index 67a264d930..04e74f0c19 100644
--- a/testnet/stacks-node/src/tests/neon_integrations.rs
+++ b/testnet/stacks-node/src/tests/neon_integrations.rs
@@ -9502,8 +9502,9 @@ fn test_problematic_blocks_are_not_relayed_or_stored() {
 
     let tip_info = get_chain_info(&conf);
 
-    // all blocks were processed
-    assert!(tip_info.stacks_tip_height >= old_tip_info.stacks_tip_height + 5);
+    // at least one block was mined (hard to say how many due to the raciness between the burnchain
+    // downloader and this thread).
+    assert!(tip_info.stacks_tip_height > old_tip_info.stacks_tip_height);
     // one was problematic -- i.e. the one that included tx_high
     assert_eq!(all_new_files.len(), 1);
 

From d8bf3ebf2266dd5d845a869a351011829413515d Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Tue, 13 Feb 2024 17:01:47 -0800
Subject: [PATCH 0765/1166] feat: allow signer-key allowances instead of
 signature

---
 stacks-signer/src/main.rs                     |  2 +-
 stackslib/src/chainstate/stacks/boot/mod.rs   |  6 +-
 .../src/chainstate/stacks/boot/pox-4.clar     | 72 +++++++++++++++----
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 14 ++--
 .../src/util_lib/signed_structured_data.rs    |  9 ---
 testnet/stacks-node/src/mockamoto.rs          |  4 +-
 .../src/tests/nakamoto_integrations.rs        |  6 +-
 7 files changed, 74 insertions(+), 39 deletions(-)

diff --git a/stacks-signer/src/main.rs b/stacks-signer/src/main.rs
index aa4498294b..7ba74b55ad 100644
--- a/stacks-signer/src/main.rs
+++ b/stacks-signer/src/main.rs
@@ -416,7 +416,7 @@ pub mod tests {
         let program = format!(
             r#"
             {}
-            (verify-signer-key-sig {} u{} "{}" u{} 0x{} 0x{})
+            (verify-signer-key-sig {} u{} "{}" u{} (some 0x{}) 0x{})
         "#,
             &*POX_4_CODE,                                               //s
             Value::Tuple(pox_addr.clone().as_clarity_tuple().unwrap()), //p
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index f969558f93..8431a99361 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -1860,7 +1860,7 @@ pub mod test {
                 addr_tuple,
                 Value::UInt(burn_ht as u128),
                 Value::UInt(lock_period),
-                Value::buff_from(signature).unwrap(),
+                Value::some(Value::buff_from(signature).unwrap()).unwrap(),
                 Value::buff_from(signer_key.to_bytes_compressed()).unwrap(),
             ],
         )
@@ -2009,7 +2009,7 @@ pub mod test {
             vec![
                 Value::UInt(lock_period),
                 addr_tuple,
-                Value::buff_from(signature).unwrap(),
+                Value::some(Value::buff_from(signature).unwrap()).unwrap(),
                 Value::buff_from(signer_key.to_bytes_compressed()).unwrap(),
             ],
         )
@@ -2114,7 +2114,7 @@ pub mod test {
             vec![
                 addr_tuple,
                 Value::UInt(reward_cycle),
-                Value::buff_from(signature).unwrap(),
+                Value::some(Value::buff_from(signature).unwrap()).unwrap(),
                 Value::buff_from(signer_key.to_bytes_compressed()).unwrap(),
             ],
         )
diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index d8655250dd..559d1cad66 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -211,6 +211,19 @@
 ;;   for the given reward cycle
 (define-map aggregate-public-keys uint (buff 33))
 
+;; State for setting allowances for signer keys to be used in
+;; certain stacking transactions
+(define-map signer-key-allowances 
+    {
+        signer-key: (buff 33),
+        reward-cycle: uint,
+        period: uint,
+        topic: (string-ascii 12),
+        pox-addr: { version: (buff 1), hashbytes: (buff 32) },
+    } 
+    bool
+)
+
 ;; What's the reward cycle number of the burnchain block height?
 ;; Will runtime-abort if height is less than the first burnchain block (this is intentional)
 (define-read-only (burn-height-to-reward-cycle (height uint))
@@ -576,7 +589,7 @@
                           (pox-addr (tuple (version (buff 1)) (hashbytes (buff 32))))
                           (start-burn-ht uint)
                           (lock-period uint)
-                          (signer-sig (buff 65))
+                          (signer-sig (optional (buff 65)))
                           (signer-key (buff 33)))
     ;; this stacker's first reward cycle is the _next_ reward cycle
     (let ((first-reward-cycle (+ u1 (current-pox-reward-cycle)))
@@ -704,21 +717,30 @@
 ;; See `get-signer-key-message-hash` for details on the message hash.
 ;;
 ;; Note that `reward-cycle` corresponds to the _current_ reward cycle,
-;; not the reward cycle at which the delegation will start.
-;; The public key is recovered from the signature and compared to `signer-key`.
+;; when used with `stack-stx` and `stack-extend`.
+;; When `signer-sig` is present, the public key is recovered from the signature 
+;; and compared to `signer-key`.
+;; If `signer-sig` is `none`, the function verifies that an allowance was previously
+;; added for this key.
 (define-read-only (verify-signer-key-sig (pox-addr { version: (buff 1), hashbytes: (buff 32) })
                                          (reward-cycle uint)
                                          (topic (string-ascii 12))
                                          (period uint)
-                                         (signer-sig (buff 65))
+                                         (signer-sig-opt (optional (buff 65)))
                                          (signer-key (buff 33)))
-  (ok (asserts! 
-    (is-eq 
-      (unwrap! (secp256k1-recover? 
-        (get-signer-key-message-hash pox-addr reward-cycle topic period) 
-        signer-sig) (err ERR_INVALID_SIGNATURE_RECOVER)) 
-      signer-key) 
-    (err ERR_INVALID_SIGNATURE_PUBKEY))))
+  (match signer-sig-opt
+    signer-sig (ok (asserts! 
+      (is-eq 
+        (unwrap! (secp256k1-recover? 
+          (get-signer-key-message-hash pox-addr reward-cycle topic period) 
+          signer-sig) (err ERR_INVALID_SIGNATURE_RECOVER)) 
+        signer-key) 
+      (err ERR_INVALID_SIGNATURE_PUBKEY)))
+    (begin
+      (ok (asserts! (default-to false (map-get? signer-key-allowances
+          { signer-key: signer-key, reward-cycle: reward-cycle, period: period, topic: topic, pox-addr: pox-addr }))
+        (err ERR_NOT_ALLOWED)))
+    )))
 
 ;; Commit partially stacked STX and allocate a new PoX reward address slot.
 ;;   This allows a stacker/delegate to lock fewer STX than the minimal threshold in multiple transactions,
@@ -734,7 +756,7 @@
 ;; *New in Stacks 2.1.*
 (define-private (inner-stack-aggregation-commit (pox-addr { version: (buff 1), hashbytes: (buff 32) })
                                                 (reward-cycle uint)
-                                                (signer-sig (buff 65))
+                                                (signer-sig (optional (buff 65)))
                                                 (signer-key (buff 33)))
   (let ((partial-stacked
          ;; fetch the partial commitments
@@ -777,7 +799,7 @@
 ;; Returns (err ...) on failure.
 (define-public (stack-aggregation-commit (pox-addr { version: (buff 1), hashbytes: (buff 32) })
                                          (reward-cycle uint)
-                                         (signer-sig (buff 65))
+                                         (signer-sig (optional (buff 65)))
                                          (signer-key (buff 33)))
     (match (inner-stack-aggregation-commit pox-addr reward-cycle signer-sig signer-key)
         pox-addr-index (ok true)
@@ -787,7 +809,7 @@
 ;; *New in Stacks 2.1.*
 (define-public (stack-aggregation-commit-indexed (pox-addr { version: (buff 1), hashbytes: (buff 32) })
                                                  (reward-cycle uint)
-                                                 (signer-sig (buff 65))
+                                                 (signer-sig (optional (buff 65)))
                                                  (signer-key (buff 33)))
     (inner-stack-aggregation-commit pox-addr reward-cycle signer-sig signer-key))
 
@@ -1036,7 +1058,7 @@
 ;;    used for signing. The `tx-sender` can thus decide to change the key when extending.
 (define-public (stack-extend (extend-count uint)
                              (pox-addr { version: (buff 1), hashbytes: (buff 32) })
-                             (signer-sig (buff 65))
+                             (signer-sig (optional (buff 65)))
                              (signer-key (buff 33)))
    (let ((stacker-info (stx-account tx-sender))
          ;; to extend, there must already be an etry in the stacking-state
@@ -1300,6 +1322,26 @@
       (ok { stacker: stacker,
             unlock-burn-height: new-unlock-ht }))))
 
+;; Add an allowance for a signer key.
+;; When an allowance is added, the `signer-sig` argument is not required
+;; in the functions that use it as an argument.
+;; The `allowed` flag can be used to either enable or disable the allowance.
+;; Only the Stacks principal associated with `signer-key` can call this function.
+;; *New in Stacks 3.0*
+(define-public (set-signer-key-allowance (pox-addr { version: (buff 1), hashbytes: (buff 32)})
+                                         (period uint)
+                                         (reward-cycle uint)
+                                         (topic (string-ascii 12))
+                                         (signer-key (buff 33))
+                                         (allowed bool))
+  (begin
+    ;; Validate that `tx-sender` has the same pubkey hash as `signer-key`
+    (asserts! (is-eq 
+      (unwrap! (principal-construct? (if is-in-mainnet 0x16 0x1a) (hash160 signer-key)) (err ERR_INVALID_SIGNER_KEY))
+      tx-sender) (err ERR_NOT_ALLOWED))
+    (map-set signer-key-allowances { pox-addr: pox-addr, period: period, reward-cycle: reward-cycle, topic: topic, signer-key: signer-key } allowed)
+    (ok true)))
+
 ;; Get the _current_ PoX stacking delegation information for a stacker.  If the information
 ;; is expired, or if there's never been such a stacker, then returns none.
 ;; *New in Stacks 2.1*
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 99a3db0b72..2148d9370f 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -1470,7 +1470,7 @@ fn verify_signer_key_sig(
                         LimitedCostTracker::new_free(),
                         |env| {
                             let program = format!(
-                                "(verify-signer-key-sig {} u{} \"{}\" u{} 0x{} 0x{})",
+                                "(verify-signer-key-sig {} u{} \"{}\" u{} (some 0x{}) 0x{})",
                                 Value::Tuple(pox_addr.clone().as_clarity_tuple().unwrap()),
                                 reward_cycle,
                                 topic.get_name_str(),
@@ -2268,7 +2268,7 @@ fn stack_stx_signer_key() {
             pox_addr_val.clone(),
             Value::UInt(block_height as u128),
             Value::UInt(2),
-            Value::buff_from(signature.clone()).unwrap(),
+            Value::some(Value::buff_from(signature.clone()).unwrap()).unwrap(),
             signer_key_val.clone(),
         ],
     )];
@@ -2384,7 +2384,7 @@ fn stack_extend_signer_key() {
         vec![
             Value::UInt(1),
             pox_addr_val.clone(),
-            Value::buff_from(signature.clone()).unwrap(),
+            Value::some(Value::buff_from(signature.clone()).unwrap()).unwrap(),
             signer_extend_key_val.clone(),
         ],
     )];
@@ -2492,7 +2492,7 @@ fn delegate_stack_stx_signer_key() {
             vec![
                 pox_addr_val.clone(),
                 Value::UInt(next_reward_cycle.into()),
-                Value::buff_from(signature).unwrap(),
+                Value::some(Value::buff_from(signature).unwrap()).unwrap(),
                 signer_key_val.clone(),
             ],
         ),
@@ -2661,7 +2661,7 @@ fn delegate_stack_stx_extend_signer_key() {
         vec![
             pox_addr.as_clarity_tuple().unwrap().into(),
             Value::UInt(next_reward_cycle.into()),
-            Value::buff_from(signature).unwrap(),
+            Value::some(Value::buff_from(signature).unwrap()).unwrap(),
             signer_key_val.clone(),
         ],
     );
@@ -2681,7 +2681,7 @@ fn delegate_stack_stx_extend_signer_key() {
         vec![
             pox_addr.as_clarity_tuple().unwrap().into(),
             Value::UInt(extend_cycle.into()),
-            Value::buff_from(extend_signature).unwrap(),
+            Value::some(Value::buff_from(extend_signature).unwrap()).unwrap(),
             signer_extend_key_val.clone(),
         ],
     );
@@ -2896,7 +2896,7 @@ fn delegate_stack_increase() {
         vec![
             pox_addr.as_clarity_tuple().unwrap().into(),
             Value::UInt(next_reward_cycle.into()),
-            Value::buff_from(signature).unwrap(),
+            (Value::some(Value::buff_from(signature).unwrap()).unwrap()),
             signer_key_val.clone(),
         ],
     );
diff --git a/stackslib/src/util_lib/signed_structured_data.rs b/stackslib/src/util_lib/signed_structured_data.rs
index 3405acf75e..019443842d 100644
--- a/stackslib/src/util_lib/signed_structured_data.rs
+++ b/stackslib/src/util_lib/signed_structured_data.rs
@@ -250,15 +250,6 @@ pub mod pox4 {
                 CHAIN_ID_TESTNET,
                 lock_period,
             );
-            println!(
-                "Hash: 0x{}",
-                to_hex(expected_hash_vec.as_bytes().as_slice())
-            );
-            println!(
-                "Pubkey: {}",
-                to_hex(pubkey.to_bytes_compressed().as_slice())
-            );
-            // println!("PoxAddr: {}", pox_addr_b58_serialize(&pox_addr).unwrap());
             let expected_hash = expected_hash_vec.as_bytes();
 
             // Test 1: valid result
diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index 77a0993b8f..037ff02250 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -865,7 +865,7 @@ impl MockamotoNode {
                     pox_address.as_clarity_tuple().unwrap().into(),
                     ClarityValue::UInt(u128::from(parent_burn_height)),
                     ClarityValue::UInt(12),
-                    ClarityValue::buff_from(signature).unwrap(),
+                    ClarityValue::some(ClarityValue::buff_from(signature).unwrap()).unwrap(),
                     ClarityValue::buff_from(signer_key).unwrap(),
                 ],
             })
@@ -889,7 +889,7 @@ impl MockamotoNode {
                 function_args: vec![
                     ClarityValue::UInt(5),
                     pox_address.as_clarity_tuple().unwrap().into(),
-                    ClarityValue::buff_from(signature).unwrap(),
+                    ClarityValue::some(ClarityValue::buff_from(signature).unwrap()).unwrap(),
                     ClarityValue::buff_from(signer_key).unwrap(),
                 ],
             })
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 38c2a74415..e82a9d284b 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -416,7 +416,8 @@ pub fn boot_to_epoch_3(
                 pox_addr_tuple.clone(),
                 clarity::vm::Value::UInt(205),
                 clarity::vm::Value::UInt(12),
-                clarity::vm::Value::buff_from(signature).unwrap(),
+                clarity::vm::Value::some(clarity::vm::Value::buff_from(signature).unwrap())
+                    .unwrap(),
                 clarity::vm::Value::buff_from(signer_pk.to_bytes_compressed()).unwrap(),
             ],
         );
@@ -988,7 +989,8 @@ fn correct_burn_outs() {
                     pox_addr_tuple,
                     clarity::vm::Value::UInt(pox_info.current_burnchain_block_height.into()),
                     clarity::vm::Value::UInt(1),
-                    clarity::vm::Value::buff_from(signature).unwrap(),
+                    clarity::vm::Value::some(clarity::vm::Value::buff_from(signature).unwrap())
+                        .unwrap(),
                     clarity::vm::Value::buff_from(pk_bytes).unwrap(),
                 ],
             );

From 8e1c8f5b9bce6895f16d0b92ed5210a147fb0c51 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Wed, 14 Feb 2024 12:29:02 -0800
Subject: [PATCH 0766/1166] feat: add tests for signer-key authorizations

---
 CHANGELOG.md                                  |  24 +-
 .../chainstate/nakamoto/coordinator/tests.rs  |   6 +-
 stackslib/src/chainstate/stacks/boot/mod.rs   |  70 ++-
 .../src/chainstate/stacks/boot/pox-4.clar     |  34 +-
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 578 ++++++++++++++++--
 stackslib/src/net/tests/mod.rs                |   6 +-
 6 files changed, 630 insertions(+), 88 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index bc88952147..96c8b8a17f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -15,6 +15,7 @@ and this project adheres to the versioning scheme outlined in the [README.md](RE
 - New [`pox-4` contract](./stackslib/src/chainstate/stacks/boot/pox-4.clar) that reflects changes in how Stackers are signers in Nakamoto:
   - `stack-stx`, `stack-extend`, and `stack-aggregation-commit` now include a `signer-key` parameter, which represents the public key used by the Signer. This key is used for determining the signer set in Nakamoto.
   - Functions that include a `signer-key` parameter also include a `signer-sig` parameter to demonstrate that the owner of `signer-key` is approving that particular Stacking operation. For more details, refer to the `verify-signer-key-sig` method in the `pox-4` contract.
+  - Signer key authorizations can be added via `set-signer-key-authorization` to omit the need for `signer-key` signatures
 
 ### Modified
 
@@ -43,23 +44,24 @@ and this project adheres to the versioning scheme outlined in the [README.md](RE
 - New RPC endpoint at /v2/block_proposal for miner to validate proposed block.
   Only accessible on local loopback interface
 
-In addition, this introduces a set of improvements to the Stacks miner behavior.  In
+In addition, this introduces a set of improvements to the Stacks miner behavior. In
 particular:
-* The VRF public key can be re-used across node restarts.
-* Settings that affect mining are hot-reloaded from the config file.  They take
+
+- The VRF public key can be re-used across node restarts.
+- Settings that affect mining are hot-reloaded from the config file. They take
   effect once the file is updated; there is no longer a need to restart the
-node.
-* The act of changing the miner settings in the config file automatically
+  node.
+- The act of changing the miner settings in the config file automatically
   triggers a subsequent block-build attempt, allowing the operator to force the
-miner to re-try building blocks.
-* This adds a new tip-selection algorithm that minimizes block orphans within a
+  miner to re-try building blocks.
+- This adds a new tip-selection algorithm that minimizes block orphans within a
   configurable window of time.
-* When configured, the node will automatically stop mining if it is not achieving a
+- When configured, the node will automatically stop mining if it is not achieving a
   targeted win rate over a configurable window of blocks.
-* When configured, the node will selectively mine transactions from only certain
+- When configured, the node will selectively mine transactions from only certain
   addresses, or only of certain types (STX-transfers, contract-publishes,
-contract-calls).
-* When configured, the node will optionally only RBF block-commits if it can
+  contract-calls).
+- When configured, the node will optionally only RBF block-commits if it can
   produce a block with strictly more transactions.
 
 ### Changed
diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index 395caacc92..b1d5af763b 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -93,11 +93,11 @@ fn advance_to_nakamoto(
                         &test_stacker.stacker_private_key,
                         0,
                         test_stacker.amount,
-                        pox_addr.clone(),
+                        &pox_addr,
                         12,
-                        signing_key,
+                        &signing_key,
                         34,
-                        signature,
+                        Some(signature),
                     )
                 })
                 .collect()
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 8431a99361..2c5ee5cc4d 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -1844,13 +1844,17 @@ pub mod test {
         key: &StacksPrivateKey,
         nonce: u64,
         amount: u128,
-        addr: PoxAddress,
+        addr: &PoxAddress,
         lock_period: u128,
-        signer_key: StacksPublicKey,
+        signer_key: &StacksPublicKey,
         burn_ht: u64,
-        signature: Vec<u8>,
+        signature_opt: Option<Vec<u8>>,
     ) -> StacksTransaction {
         let addr_tuple = Value::Tuple(addr.as_clarity_tuple().unwrap());
+        let signature = match signature_opt {
+            Some(sig) => Value::some(Value::buff_from(sig).unwrap()).unwrap(),
+            None => Value::none(),
+        };
         let payload = TransactionPayload::new_contract_call(
             boot_code_test_addr(),
             "pox-4",
@@ -1860,7 +1864,7 @@ pub mod test {
                 addr_tuple,
                 Value::UInt(burn_ht as u128),
                 Value::UInt(lock_period),
-                Value::some(Value::buff_from(signature).unwrap()).unwrap(),
+                signature,
                 Value::buff_from(signer_key.to_bytes_compressed()).unwrap(),
             ],
         )
@@ -1993,15 +1997,30 @@ pub mod test {
         make_tx(key, nonce, 0, payload)
     }
 
-    pub fn make_pox_4_extend(
+    pub fn make_pox_4_extend_delete_this(
         key: &StacksPrivateKey,
         nonce: u64,
         addr: PoxAddress,
         lock_period: u128,
         signer_key: StacksPublicKey,
         signature: Vec<u8>,
+    ) -> StacksTransaction {
+        make_pox_4_extend(key, nonce, addr, lock_period, signer_key, Some(signature))
+    }
+
+    pub fn make_pox_4_extend(
+        key: &StacksPrivateKey,
+        nonce: u64,
+        addr: PoxAddress,
+        lock_period: u128,
+        signer_key: StacksPublicKey,
+        signature_opt: Option<Vec<u8>>,
     ) -> StacksTransaction {
         let addr_tuple = Value::Tuple(addr.as_clarity_tuple().unwrap());
+        let signature = match signature_opt {
+            Some(sig) => Value::some(Value::buff_from(sig).unwrap()).unwrap(),
+            None => Value::none(),
+        };
         let payload = TransactionPayload::new_contract_call(
             boot_code_test_addr(),
             POX_4_NAME,
@@ -2009,7 +2028,7 @@ pub mod test {
             vec![
                 Value::UInt(lock_period),
                 addr_tuple,
-                Value::some(Value::buff_from(signature).unwrap()).unwrap(),
+                signature,
                 Value::buff_from(signer_key.to_bytes_compressed()).unwrap(),
             ],
         )
@@ -2103,10 +2122,14 @@ pub mod test {
         nonce: u64,
         pox_addr: &PoxAddress,
         reward_cycle: u128,
-        signature: Vec<u8>,
+        signature_opt: Option<Vec<u8>>,
         signer_key: &Secp256k1PublicKey,
     ) -> StacksTransaction {
         let addr_tuple = Value::Tuple(pox_addr.as_clarity_tuple().unwrap());
+        let signature = match signature_opt {
+            Some(sig) => Value::some(Value::buff_from(sig).unwrap()).unwrap(),
+            None => Value::none(),
+        };
         let payload = TransactionPayload::new_contract_call(
             boot_code_test_addr(),
             POX_4_NAME,
@@ -2114,7 +2137,7 @@ pub mod test {
             vec![
                 addr_tuple,
                 Value::UInt(reward_cycle),
-                Value::some(Value::buff_from(signature).unwrap()).unwrap(),
+                signature,
                 Value::buff_from(signer_key.to_bytes_compressed()).unwrap(),
             ],
         )
@@ -2193,6 +2216,37 @@ pub mod test {
         signature.to_rsv()
     }
 
+    pub fn make_pox_4_set_signer_key_auth(
+        pox_addr: &PoxAddress,
+        signer_key: &StacksPrivateKey,
+        reward_cycle: u128,
+        topic: &Pox4SignatureTopic,
+        period: u128,
+        enabled: bool,
+        nonce: u64,
+        sender_key: Option<&StacksPrivateKey>,
+    ) -> StacksTransaction {
+        let signer_pubkey = StacksPublicKey::from_private(signer_key);
+        let payload = TransactionPayload::new_contract_call(
+            boot_code_test_addr(),
+            POX_4_NAME,
+            "set-signer-key-authorization",
+            vec![
+                Value::Tuple(pox_addr.as_clarity_tuple().unwrap()),
+                Value::UInt(period),
+                Value::UInt(reward_cycle),
+                Value::string_ascii_from_bytes(topic.get_name_str().into()).unwrap(),
+                Value::buff_from(signer_pubkey.to_bytes_compressed()).unwrap(),
+                Value::Bool(enabled),
+            ],
+        )
+        .unwrap();
+
+        let sender_key = sender_key.unwrap_or(signer_key);
+
+        make_tx(sender_key, nonce, 0, payload)
+    }
+
     fn make_tx(
         key: &StacksPrivateKey,
         nonce: u64,
diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index 559d1cad66..f04ee6f1a6 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -213,7 +213,7 @@
 
 ;; State for setting allowances for signer keys to be used in
 ;; certain stacking transactions
-(define-map signer-key-allowances 
+(define-map signer-key-authorizations 
     {
         signer-key: (buff 33),
         reward-cycle: uint,
@@ -720,7 +720,8 @@
 ;; when used with `stack-stx` and `stack-extend`.
 ;; When `signer-sig` is present, the public key is recovered from the signature 
 ;; and compared to `signer-key`.
-;; If `signer-sig` is `none`, the function verifies that an allowance was previously
+;; 
+;; If `signer-sig` is `none`, the function verifies that an authorization was previously
 ;; added for this key.
 (define-read-only (verify-signer-key-sig (pox-addr { version: (buff 1), hashbytes: (buff 32) })
                                          (reward-cycle uint)
@@ -729,6 +730,7 @@
                                          (signer-sig-opt (optional (buff 65)))
                                          (signer-key (buff 33)))
   (match signer-sig-opt
+    ;; `signer-sig` is present, verify the signature
     signer-sig (ok (asserts! 
       (is-eq 
         (unwrap! (secp256k1-recover? 
@@ -736,11 +738,11 @@
           signer-sig) (err ERR_INVALID_SIGNATURE_RECOVER)) 
         signer-key) 
       (err ERR_INVALID_SIGNATURE_PUBKEY)))
-    (begin
-      (ok (asserts! (default-to false (map-get? signer-key-allowances
+    ;; `signer-sig` is not present, verify that an authorization was previously added for this key
+    (ok (asserts! (default-to false (map-get? signer-key-authorizations
           { signer-key: signer-key, reward-cycle: reward-cycle, period: period, topic: topic, pox-addr: pox-addr }))
         (err ERR_NOT_ALLOWED)))
-    )))
+    ))
 
 ;; Commit partially stacked STX and allocate a new PoX reward address slot.
 ;;   This allows a stacker/delegate to lock fewer STX than the minimal threshold in multiple transactions,
@@ -1322,25 +1324,25 @@
       (ok { stacker: stacker,
             unlock-burn-height: new-unlock-ht }))))
 
-;; Add an allowance for a signer key.
-;; When an allowance is added, the `signer-sig` argument is not required
+;; Add an authorization for a signer key.
+;; When an authorization is added, the `signer-sig` argument is not required
 ;; in the functions that use it as an argument.
-;; The `allowed` flag can be used to either enable or disable the allowance.
+;; The `allowed` flag can be used to either enable or disable the authorization.
 ;; Only the Stacks principal associated with `signer-key` can call this function.
 ;; *New in Stacks 3.0*
-(define-public (set-signer-key-allowance (pox-addr { version: (buff 1), hashbytes: (buff 32)})
-                                         (period uint)
-                                         (reward-cycle uint)
-                                         (topic (string-ascii 12))
-                                         (signer-key (buff 33))
-                                         (allowed bool))
+(define-public (set-signer-key-authorization (pox-addr { version: (buff 1), hashbytes: (buff 32)})
+                                             (period uint)
+                                             (reward-cycle uint)
+                                             (topic (string-ascii 12))
+                                             (signer-key (buff 33))
+                                             (allowed bool))
   (begin
     ;; Validate that `tx-sender` has the same pubkey hash as `signer-key`
     (asserts! (is-eq 
       (unwrap! (principal-construct? (if is-in-mainnet 0x16 0x1a) (hash160 signer-key)) (err ERR_INVALID_SIGNER_KEY))
       tx-sender) (err ERR_NOT_ALLOWED))
-    (map-set signer-key-allowances { pox-addr: pox-addr, period: period, reward-cycle: reward-cycle, topic: topic, signer-key: signer-key } allowed)
-    (ok true)))
+    (map-set signer-key-authorizations { pox-addr: pox-addr, period: period, reward-cycle: reward-cycle, topic: topic, signer-key: signer-key } allowed)
+    (ok allowed)))
 
 ;; Get the _current_ PoX stacking delegation information for a stacker.  If the information
 ;; is expired, or if there's never been such a stacker, then returns none.
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 2148d9370f..00e82feafe 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -504,14 +504,14 @@ fn pox_extend_transition() {
         &alice,
         2,
         ALICE_LOCKUP,
-        PoxAddress::from_legacy(
+        &PoxAddress::from_legacy(
             AddressHashMode::SerializeP2PKH,
             key_to_stacks_addr(&alice).bytes,
         ),
         4,
-        alice_signer_key,
+        &alice_signer_key,
         tip.block_height,
-        alice_signature,
+        Some(alice_signature),
     );
     let alice_pox_4_lock_nonce = 2;
     let alice_first_pox_4_unlock_height =
@@ -577,11 +577,11 @@ fn pox_extend_transition() {
         &bob,
         2,
         BOB_LOCKUP,
-        bob_pox_addr.clone(),
+        &bob_pox_addr,
         3,
-        StacksPublicKey::from_private(&bob_signer_private),
+        &StacksPublicKey::from_private(&bob_signer_private),
         tip.block_height,
-        bob_signature,
+        Some(bob_signature),
     );
 
     // new signing key needed
@@ -603,7 +603,7 @@ fn pox_extend_transition() {
         alice_pox_addr.clone(),
         6,
         alice_signer_key,
-        alice_signature,
+        Some(alice_signature),
     );
 
     let alice_pox_4_extend_nonce = 3;
@@ -870,11 +870,11 @@ fn pox_lock_unlock() {
                 key,
                 0,
                 1024 * POX_THRESHOLD_STEPS_USTX,
-                pox_addr.clone(),
+                &pox_addr,
                 lock_period,
-                StacksPublicKey::from_private(&signer_key),
+                &StacksPublicKey::from_private(&signer_key),
                 tip_height,
-                signature,
+                Some(signature),
             ));
             pox_addr
         })
@@ -1688,11 +1688,11 @@ fn stack_stx_verify_signer_sig() {
         &stacker_key,
         stacker_nonce,
         min_ustx,
-        pox_addr.clone(),
+        &pox_addr,
         lock_period,
-        signer_public_key.clone(),
+        &signer_public_key,
         block_height,
-        signature,
+        Some(signature),
     );
 
     // test 2: invalid pox addr
@@ -1709,11 +1709,11 @@ fn stack_stx_verify_signer_sig() {
         &stacker_key,
         stacker_nonce,
         min_ustx,
-        pox_addr.clone(),
+        &pox_addr,
         lock_period,
-        signer_public_key.clone(),
+        &signer_public_key,
         block_height,
-        signature,
+        Some(signature),
     );
 
     // Test 3: invalid key used to sign
@@ -1730,11 +1730,11 @@ fn stack_stx_verify_signer_sig() {
         &stacker_key,
         stacker_nonce,
         min_ustx,
-        pox_addr.clone(),
+        &pox_addr,
         lock_period,
-        signer_public_key.clone(),
+        &signer_public_key,
         block_height,
-        signature,
+        Some(signature),
     );
 
     // Test 4: invalid topic
@@ -1751,11 +1751,11 @@ fn stack_stx_verify_signer_sig() {
         &stacker_key,
         stacker_nonce,
         min_ustx,
-        pox_addr.clone(),
+        &pox_addr,
         lock_period,
-        signer_public_key.clone(),
+        &signer_public_key,
         block_height,
-        signature,
+        Some(signature),
     );
 
     // Test 5: invalid period
@@ -1772,11 +1772,11 @@ fn stack_stx_verify_signer_sig() {
         &stacker_key,
         stacker_nonce,
         min_ustx,
-        pox_addr.clone(),
+        &pox_addr,
         lock_period,
-        signer_public_key.clone(),
+        &signer_public_key,
         block_height,
-        signature,
+        Some(signature),
     );
 
     // Test 6: valid signature
@@ -1788,11 +1788,11 @@ fn stack_stx_verify_signer_sig() {
         &stacker_key,
         stacker_nonce,
         min_ustx,
-        pox_addr,
+        &pox_addr,
         lock_period,
-        signer_public_key.clone(),
+        &signer_public_key,
         block_height,
-        signature,
+        Some(signature),
     );
 
     let txs = vec![
@@ -1857,11 +1857,11 @@ fn stack_extend_verify_sig() {
         &stacker_key,
         stacker_nonce,
         min_ustx,
-        pox_addr.clone(),
+        &pox_addr,
         lock_period,
-        signer_public_key.clone(),
+        &signer_public_key,
         block_height,
-        signature,
+        Some(signature),
     );
 
     // We need a new signer-key for the extend tx
@@ -1884,7 +1884,7 @@ fn stack_extend_verify_sig() {
         pox_addr.clone(),
         lock_period,
         signer_public_key.clone(),
-        signature,
+        Some(signature),
     );
 
     // Test 2: invalid pox-addr
@@ -1904,7 +1904,7 @@ fn stack_extend_verify_sig() {
         pox_addr.clone(),
         lock_period,
         signer_public_key.clone(),
-        signature,
+        Some(signature),
     );
 
     // Test 3: invalid key used to sign
@@ -1919,7 +1919,7 @@ fn stack_extend_verify_sig() {
         pox_addr.clone(),
         lock_period,
         signer_public_key.clone(),
-        signature,
+        Some(signature),
     );
 
     // Test 4: valid stack-extend
@@ -1933,7 +1933,7 @@ fn stack_extend_verify_sig() {
         pox_addr,
         lock_period,
         signer_public_key.clone(),
-        signature,
+        Some(signature),
     );
 
     peer.tenure_with_txs(
@@ -2034,7 +2034,7 @@ fn stack_agg_commit_verify_sig() {
         delegate_nonce,
         &pox_addr,
         next_reward_cycle,
-        signature,
+        Some(signature),
         &signer_pk,
     );
 
@@ -2054,7 +2054,7 @@ fn stack_agg_commit_verify_sig() {
         delegate_nonce,
         &pox_addr,
         next_reward_cycle,
-        signature,
+        Some(signature),
         &signer_pk,
     );
 
@@ -2068,7 +2068,7 @@ fn stack_agg_commit_verify_sig() {
         delegate_nonce,
         &pox_addr,
         next_reward_cycle,
-        signature,
+        Some(signature),
         &signer_pk,
     );
 
@@ -2087,7 +2087,7 @@ fn stack_agg_commit_verify_sig() {
         delegate_nonce,
         &pox_addr,
         next_reward_cycle,
-        signature,
+        Some(signature),
         &signer_pk,
     );
 
@@ -2106,7 +2106,7 @@ fn stack_agg_commit_verify_sig() {
         delegate_nonce,
         &pox_addr,
         next_reward_cycle,
-        signature,
+        Some(signature),
         &signer_pk,
     );
 
@@ -2120,7 +2120,7 @@ fn stack_agg_commit_verify_sig() {
         delegate_nonce,
         &pox_addr,
         next_reward_cycle,
-        signature,
+        Some(signature),
         &signer_pk,
     );
 
@@ -2314,6 +2314,444 @@ fn stack_stx_signer_key() {
     );
 }
 
+#[test]
+/// Test `stack-stx` using signer key authorization
+fn stack_stx_signer_auth() {
+    let observer = TestEventObserver::new();
+    let (burnchain, mut peer, keys, latest_block, block_height, mut coinbase_nonce) =
+        prepare_pox4_test(function_name!(), Some(&observer));
+
+    let mut stacker_nonce = 0;
+    let stacker_key = &keys[0];
+    let min_ustx = get_stacking_minimum(&mut peer, &latest_block);
+    let signer_nonce = 0;
+    let signer_key = &keys[1];
+    let signer_public_key = StacksPublicKey::from_private(signer_key);
+    let signer_key_val = Value::buff_from(signer_public_key.to_bytes_compressed()).unwrap();
+
+    let reward_cycle = get_current_reward_cycle(&peer, &burnchain);
+
+    let pox_addr = pox_addr_from(&stacker_key);
+    let pox_addr_val = Value::Tuple(pox_addr.clone().as_clarity_tuple().unwrap());
+    let lock_period = 6;
+
+    let topic = Pox4SignatureTopic::StackStx;
+
+    let failed_stack_nonce = stacker_nonce;
+    let failed_stack_tx = make_pox_4_lockup(
+        &stacker_key,
+        stacker_nonce,
+        min_ustx,
+        &pox_addr,
+        lock_period,
+        &signer_public_key,
+        block_height,
+        None,
+    );
+
+    let enable_auth_nonce = signer_nonce;
+    let enable_auth_tx = make_pox_4_set_signer_key_auth(
+        &pox_addr,
+        &signer_key,
+        reward_cycle,
+        &topic,
+        lock_period,
+        true,
+        signer_nonce,
+        None,
+    );
+
+    // Ensure that stack-stx succeeds with auth
+    stacker_nonce += 1;
+    let successful_stack_nonce = stacker_nonce;
+    let valid_stack_tx = make_pox_4_lockup(
+        &stacker_key,
+        stacker_nonce,
+        min_ustx,
+        &pox_addr,
+        lock_period,
+        &signer_public_key,
+        block_height,
+        None,
+    );
+
+    let txs = vec![failed_stack_tx, enable_auth_tx, valid_stack_tx];
+
+    let latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
+    let stacking_state = get_stacking_state_pox_4(
+        &mut peer,
+        &latest_block,
+        &key_to_stacks_addr(stacker_key).to_account_principal(),
+    )
+    .expect("No stacking state, stack-stx failed")
+    .expect_tuple();
+
+    let stacker_txs =
+        get_last_block_sender_transactions(&observer, key_to_stacks_addr(&stacker_key));
+
+    let expected_error = Value::error(Value::Int(19)).unwrap();
+
+    assert_eq!(stacker_txs.len(), (stacker_nonce + 1) as usize);
+    let stacker_tx_result =
+        |nonce: u64| -> Value { stacker_txs.get(nonce as usize).unwrap().result.clone() };
+
+    // First stack-stx failed
+    assert_eq!(stacker_tx_result(failed_stack_nonce), expected_error);
+
+    let successful_stack_result = stacker_tx_result(successful_stack_nonce);
+    // second stack-stx worked
+    successful_stack_result
+        .expect_result_ok()
+        .expect("Expected ok result from stack-stx tx");
+
+    let signer_txs = get_last_block_sender_transactions(&observer, key_to_stacks_addr(&signer_key));
+
+    // enable auth worked
+    let enable_tx_result = signer_txs
+        .get(enable_auth_nonce as usize)
+        .unwrap()
+        .result
+        .clone();
+    assert_eq!(enable_tx_result, Value::okay_true());
+}
+
+#[test]
+/// Test `stack-aggregation-commit` using signer key authorization
+fn stack_agg_commit_signer_auth() {
+    let lock_period = 2;
+    let observer = TestEventObserver::new();
+    let (burnchain, mut peer, keys, latest_block, block_height, coinbase_nonce) =
+        prepare_pox4_test(function_name!(), Some(&observer));
+
+    let mut coinbase_nonce = coinbase_nonce;
+
+    let mut delegate_nonce = 0;
+    let stacker_nonce = 0;
+    let min_ustx = get_stacking_minimum(&mut peer, &latest_block);
+
+    let stacker_key = &keys[0];
+    let stacker_addr = PrincipalData::from(key_to_stacks_addr(&stacker_key));
+
+    let signer_sk = &keys[1];
+    let signer_pk = StacksPublicKey::from_private(signer_sk);
+
+    let delegate_key = &keys[2];
+    let delegate_addr = key_to_stacks_addr(&delegate_key);
+
+    let pox_addr = pox_addr_from(&delegate_key);
+
+    let reward_cycle = burnchain
+        .block_height_to_reward_cycle(block_height)
+        .unwrap() as u128;
+    let next_reward_cycle = reward_cycle + 1;
+
+    // Setup: delegate-stx and delegate-stack-stx
+
+    let delegate_tx = make_pox_4_delegate_stx(
+        &stacker_key,
+        stacker_nonce,
+        min_ustx,
+        delegate_addr.clone().into(),
+        None,
+        None,
+    );
+
+    let delegate_stack_stx_nonce = delegate_nonce;
+    let delegate_stack_stx_tx = make_pox_4_delegate_stack_stx(
+        &delegate_key,
+        delegate_nonce,
+        stacker_addr,
+        min_ustx,
+        pox_addr.clone(),
+        block_height.into(),
+        lock_period,
+    );
+
+    let topic = Pox4SignatureTopic::AggregationCommit;
+
+    // Stack agg failes without auth
+    delegate_nonce += 1;
+    let invalid_agg_nonce = delegate_nonce;
+    let invalid_agg_tx = make_pox_4_aggregation_commit_indexed(
+        &delegate_key,
+        delegate_nonce,
+        &pox_addr,
+        next_reward_cycle,
+        None,
+        &signer_pk,
+    );
+
+    // Signer enables auth
+    let enable_auth_nonce = 0;
+    let enable_auth_tx = make_pox_4_set_signer_key_auth(
+        &pox_addr,
+        &signer_sk,
+        next_reward_cycle,
+        &topic,
+        1,
+        true,
+        enable_auth_nonce,
+        None,
+    );
+
+    // Stack agg works with auth
+    delegate_nonce += 1;
+    let valid_agg_nonce = delegate_nonce;
+    let valid_agg_tx = make_pox_4_aggregation_commit_indexed(
+        &delegate_key,
+        delegate_nonce,
+        &pox_addr,
+        next_reward_cycle,
+        None,
+        &signer_pk,
+    );
+
+    let txs = vec![
+        delegate_tx,
+        delegate_stack_stx_tx,
+        invalid_agg_tx,
+        enable_auth_tx,
+        valid_agg_tx,
+    ];
+
+    let latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
+
+    let delegate_txs = get_last_block_sender_transactions(&observer, delegate_addr);
+
+    let tx_result =
+        |nonce: u64| -> Value { delegate_txs.get(nonce as usize).unwrap().result.clone() };
+
+    let expected_error = Value::error(Value::Int(19)).unwrap();
+    assert_eq!(tx_result(invalid_agg_nonce), expected_error);
+    let successful_agg_result = tx_result(valid_agg_nonce);
+    successful_agg_result
+        .expect_result_ok()
+        .expect("Expected ok result from stack-agg-commit tx");
+}
+
+#[test]
+/// Test `stack-extend` using signer key authorization
+/// instead of signatures
+fn stack_extend_signer_auth() {
+    let lock_period = 2;
+    let observer = TestEventObserver::new();
+    let (burnchain, mut peer, keys, latest_block, block_height, coinbase_nonce) =
+        prepare_pox4_test(function_name!(), Some(&observer));
+
+    let mut coinbase_nonce = coinbase_nonce;
+
+    let mut stacker_nonce = 0;
+    let stacker_key = &keys[0];
+    let min_ustx = get_stacking_minimum(&mut peer, &latest_block);
+    let stacker_addr = key_to_stacks_addr(&stacker_key);
+    let signer_key = &keys[1];
+    let signer_public_key = StacksPublicKey::from_private(signer_key);
+    let pox_addr = pox_addr_from(&signer_key);
+
+    let reward_cycle = get_current_reward_cycle(&peer, &burnchain);
+    let topic = Pox4SignatureTopic::StackExtend;
+
+    // Setup: stack-stx
+    let signature = make_signer_key_signature(
+        &pox_addr,
+        &signer_key,
+        reward_cycle,
+        &Pox4SignatureTopic::StackStx,
+        lock_period,
+    );
+    let stack_nonce = stacker_nonce;
+    let stack_tx = make_pox_4_lockup(
+        &stacker_key,
+        stacker_nonce,
+        min_ustx,
+        &pox_addr,
+        lock_period,
+        &signer_public_key,
+        block_height,
+        Some(signature),
+    );
+
+    // Stack-extend should fail without auth
+    stacker_nonce += 1;
+    let invalid_extend_nonce = stacker_nonce;
+    let invalid_cycle_tx = make_pox_4_extend(
+        &stacker_key,
+        stacker_nonce,
+        pox_addr.clone(),
+        lock_period,
+        signer_public_key.clone(),
+        None,
+    );
+
+    // Enable authorization
+    let enable_auth_nonce = 0;
+    let enable_auth_tx = make_pox_4_set_signer_key_auth(
+        &pox_addr,
+        &signer_key,
+        reward_cycle,
+        &topic,
+        lock_period,
+        true,
+        enable_auth_nonce,
+        None,
+    );
+
+    // Stack-extend should work with auth
+    stacker_nonce += 1;
+    let valid_extend_nonce = stacker_nonce;
+    let valid_tx = make_pox_4_extend(
+        &stacker_key,
+        stacker_nonce,
+        pox_addr,
+        lock_period,
+        signer_public_key.clone(),
+        None,
+    );
+
+    let txs = vec![stack_tx, invalid_cycle_tx, enable_auth_tx, valid_tx];
+
+    let latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
+
+    let stacker_txs = get_last_block_sender_transactions(&observer, stacker_addr);
+
+    let tx_result =
+        |nonce: u64| -> Value { stacker_txs.get(nonce as usize).unwrap().result.clone() };
+
+    let expected_error = Value::error(Value::Int(19)).unwrap();
+    assert_eq!(tx_result(invalid_extend_nonce), expected_error);
+
+    let valid_extend_tx_result = tx_result(valid_extend_nonce);
+    valid_extend_tx_result
+        .expect_result_ok()
+        .expect("Expected ok result from stack-extend tx");
+}
+
+#[test]
+/// Test `set-signer-key-authorization` function
+fn test_set_signer_key_auth() {
+    let lock_period = 2;
+    let observer = TestEventObserver::new();
+    let (burnchain, mut peer, keys, latest_block, block_height, coinbase_nonce) =
+        prepare_pox4_test(function_name!(), Some(&observer));
+
+    let mut coinbase_nonce = coinbase_nonce;
+
+    let alice_nonce = 0;
+    let alice_key = &keys[0];
+    let min_ustx = get_stacking_minimum(&mut peer, &latest_block);
+    let alice_addr = key_to_stacks_addr(&alice_key);
+    let mut signer_nonce = 0;
+    let signer_key = &keys[1];
+    let signer_public_key = StacksPublicKey::from_private(signer_key);
+    let pox_addr = pox_addr_from(&signer_key);
+
+    // Only the address associated with `signer-key` can enable auth for that key
+    let invalid_enable_nonce = alice_nonce;
+    let invalid_enable_tx = make_pox_4_set_signer_key_auth(
+        &pox_addr,
+        &signer_key,
+        1,
+        &Pox4SignatureTopic::StackStx,
+        lock_period,
+        true,
+        invalid_enable_nonce,
+        Some(&alice_key),
+    );
+
+    // Disable auth for `signer-key`
+    let disable_auth_nonce = signer_nonce;
+    let disable_auth_tx: StacksTransaction = make_pox_4_set_signer_key_auth(
+        &pox_addr,
+        &signer_key,
+        1,
+        &Pox4SignatureTopic::StackStx,
+        lock_period,
+        false,
+        disable_auth_nonce,
+        None,
+    );
+
+    let latest_block =
+        peer.tenure_with_txs(&[invalid_enable_tx, disable_auth_tx], &mut coinbase_nonce);
+
+    let alice_txs = get_last_block_sender_transactions(&observer, alice_addr);
+    let invalid_enable_tx_result = alice_txs
+        .get(invalid_enable_nonce as usize)
+        .unwrap()
+        .result
+        .clone();
+    let expected_error = Value::error(Value::Int(19)).unwrap();
+    assert_eq!(invalid_enable_tx_result, expected_error);
+
+    let signer_key_enabled = get_signer_key_authorization_pox_4(
+        &mut peer,
+        &latest_block,
+        &pox_addr,
+        1,
+        &Pox4SignatureTopic::StackStx,
+        lock_period.try_into().unwrap(),
+        &signer_public_key,
+    );
+
+    assert_eq!(signer_key_enabled.unwrap(), false);
+
+    // Next block, enable the key
+    signer_nonce += 1;
+    let enable_auth_nonce = signer_nonce;
+    let enable_auth_tx = make_pox_4_set_signer_key_auth(
+        &pox_addr,
+        &signer_key,
+        1,
+        &Pox4SignatureTopic::StackStx,
+        lock_period,
+        true,
+        enable_auth_nonce,
+        None,
+    );
+
+    let latest_block = peer.tenure_with_txs(&[enable_auth_tx], &mut coinbase_nonce);
+
+    let signer_key_enabled = get_signer_key_authorization_pox_4(
+        &mut peer,
+        &latest_block,
+        &pox_addr,
+        1,
+        &Pox4SignatureTopic::StackStx,
+        lock_period.try_into().unwrap(),
+        &signer_public_key,
+    );
+
+    assert_eq!(signer_key_enabled.unwrap(), true);
+
+    // Next block, re-disable the key authorization
+    signer_nonce += 1;
+    let disable_auth_nonce = signer_nonce;
+    let disable_auth_tx = make_pox_4_set_signer_key_auth(
+        &pox_addr,
+        &signer_key,
+        1,
+        &Pox4SignatureTopic::StackStx,
+        lock_period,
+        false,
+        disable_auth_nonce,
+        None,
+    );
+
+    let latest_block = peer.tenure_with_txs(&[disable_auth_tx], &mut coinbase_nonce);
+
+    let signer_key_enabled = get_signer_key_authorization_pox_4(
+        &mut peer,
+        &latest_block,
+        &pox_addr,
+        1,
+        &Pox4SignatureTopic::StackStx,
+        lock_period.try_into().unwrap(),
+        &signer_public_key,
+    );
+
+    assert_eq!(signer_key_enabled.unwrap(), false);
+}
+
 #[test]
 fn stack_extend_signer_key() {
     let lock_period = 2;
@@ -2355,11 +2793,11 @@ fn stack_extend_signer_key() {
         &stacker_key,
         stacker_nonce,
         min_ustx,
-        pox_addr.clone(),
+        &pox_addr,
         lock_period,
-        signer_key,
+        &signer_key,
         block_height,
-        signature,
+        Some(signature),
     )];
 
     stacker_nonce += 1;
@@ -2754,11 +3192,11 @@ fn stack_increase() {
         alice_stacking_private_key,
         alice_nonce,
         min_ustx,
-        pox_addr.clone(),
+        &pox_addr,
         lock_period,
-        signing_pk,
+        &signing_pk,
         block_height as u64,
-        signature,
+        Some(signature),
     );
 
     // Initial tx arr includes a stack_stx pox_4 helper found in mod.rs
@@ -2959,6 +3397,52 @@ pub fn get_stacking_state_pox_4(
     })
 }
 
+pub fn get_signer_key_authorization_pox_4(
+    peer: &mut TestPeer,
+    tip: &StacksBlockId,
+    pox_addr: &PoxAddress,
+    reward_cycle: u64,
+    topic: &Pox4SignatureTopic,
+    period: u128,
+    signer_key: &StacksPublicKey,
+) -> Option<bool> {
+    with_clarity_db_ro(peer, tip, |db| {
+        let lookup_tuple = TupleData::from_data(vec![
+            (
+                "pox-addr".into(),
+                pox_addr.as_clarity_tuple().unwrap().into(),
+            ),
+            ("reward-cycle".into(), Value::UInt(reward_cycle.into())),
+            (
+                "topic".into(),
+                Value::string_ascii_from_bytes(topic.get_name_str().into()).unwrap(),
+            ),
+            ("period".into(), Value::UInt(period.into())),
+            (
+                "signer-key".into(),
+                Value::buff_from(signer_key.to_bytes_compressed()).unwrap(),
+            ),
+        ])
+        .unwrap()
+        .into();
+        let epoch = db.get_clarity_epoch_version().unwrap();
+        let map_entry = db
+            .fetch_entry_unknown_descriptor(
+                &boot_code_id(boot::POX_4_NAME, false),
+                "signer-key-authorizations",
+                &lookup_tuple,
+                &epoch,
+            )
+            .unwrap()
+            .expect_optional()
+            .unwrap();
+        match map_entry {
+            Some(v) => Some(v.expect_bool().unwrap()),
+            None => None,
+        }
+    })
+}
+
 pub fn get_partially_stacked_state_pox_4(
     peer: &mut TestPeer,
     tip: &StacksBlockId,
diff --git a/stackslib/src/net/tests/mod.rs b/stackslib/src/net/tests/mod.rs
index 44c19298e6..db731d3c2b 100644
--- a/stackslib/src/net/tests/mod.rs
+++ b/stackslib/src/net/tests/mod.rs
@@ -334,11 +334,11 @@ impl NakamotoBootPlan {
                     &test_stacker.stacker_private_key,
                     0,
                     test_stacker.amount,
-                    pox_addr,
+                    &pox_addr,
                     12,
-                    StacksPublicKey::from_private(&test_stacker.signer_private_key),
+                    &StacksPublicKey::from_private(&test_stacker.signer_private_key),
                     34,
-                    signature,
+                    Some(signature),
                 )
             })
             .collect();

From c4be109ff1a4489e6a8068f609ffc30cba968c8b Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Wed, 14 Feb 2024 17:09:00 -0500
Subject: [PATCH 0767/1166] chore: update comment to match code

---
 stackslib/src/chainstate/nakamoto/signer_set.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/signer_set.rs b/stackslib/src/chainstate/nakamoto/signer_set.rs
index 1471dcc2ba..3d6de9e902 100644
--- a/stackslib/src/chainstate/nakamoto/signer_set.rs
+++ b/stackslib/src/chainstate/nakamoto/signer_set.rs
@@ -276,9 +276,9 @@ impl NakamotoSigners {
                             ),
                             ("weight".into(), Value::UInt(signer.stacked_amt.into())),
                         ])
-                            .expect(
-                                "BUG: Failed to construct `{ signer: principal, num-slots: u64 }` tuple",
-                            ),
+                        .expect(
+                            "BUG: Failed to construct `{ signer: principal, weight: uint }` tuple",
+                        ),
                     )
                 })
                 .collect()
@@ -303,7 +303,7 @@ impl NakamotoSigners {
         let set_signers_args = [
             SymbolicExpression::atom_value(Value::UInt(reward_cycle.into())),
             SymbolicExpression::atom_value(Value::cons_list_unsanitized(signers_list).expect(
-                "BUG: Failed to construct `(list 4000 { signer: principal, weight: u64 })` list",
+                "BUG: Failed to construct `(list 4000 { signer: principal, weight: uint })` list",
             )),
         ];
 

From eed2368c40390e7619d83236324fbfc9eb31ad78 Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Wed, 14 Feb 2024 17:15:25 -0500
Subject: [PATCH 0768/1166] wip: try to merge `TestSigners` and `SelfSigner`

---
 Cargo.lock                                    | 1688 +++++++++--------
 stackslib/Cargo.toml                          |    6 +-
 stackslib/src/burnchains/bitcoin/network.rs   |    4 +-
 stackslib/src/burnchains/tests/burnchain.rs   |    5 +-
 stackslib/src/chainstate/burn/mod.rs          |    7 +-
 .../chainstate/nakamoto/coordinator/tests.rs  |    2 +-
 .../src/chainstate/nakamoto/tests/node.rs     |    7 +-
 stackslib/src/net/neighbors/neighbor.rs       |    2 +-
 stackslib/src/net/neighbors/walk.rs           |    2 +-
 stackslib/src/net/prune.rs                    |    2 +-
 testnet/stacks-node/src/config.rs             |    8 +-
 testnet/stacks-node/src/mockamoto.rs          |    6 +-
 .../stacks-node/src/nakamoto_node/miner.rs    |    4 +-
 .../src/tests/nakamoto_integrations.rs        |    4 +-
 14 files changed, 926 insertions(+), 821 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 41c2c8e924..e746299a7e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4,9 +4,9 @@ version = 3
 
 [[package]]
 name = "addr2line"
-version = "0.19.0"
+version = "0.21.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a76fd60b23679b7d19bd066031410fb7e458ccc5e958eb5c325888ce4baedc97"
+checksum = "8a30b2e23b9e17a9f90641c7ab1549cd9b44f296d3ccbf309d2863cfe398a0cb"
 dependencies = [
  "gimli",
 ]
@@ -29,7 +29,7 @@ version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7fc95d1bdb8e6666b2b217308eeeb09f2d6728d104be3e31916cc74d15420331"
 dependencies = [
- "generic-array 0.14.6",
+ "generic-array 0.14.7",
 ]
 
 [[package]]
@@ -39,7 +39,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d122413f284cf2d62fb1b7db97e02edb8cda96d769b16e443a4f6195e35662b0"
 dependencies = [
  "crypto-common",
- "generic-array 0.14.6",
+ "generic-array 0.14.7",
 ]
 
 [[package]]
@@ -55,9 +55,9 @@ dependencies = [
 
 [[package]]
 name = "aes"
-version = "0.8.3"
+version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac1f845298e95f983ff1944b728ae08b8cebab80d684f0a832ed0fc74dfa27e2"
+checksum = "b169f7a6d4742236a0a00c541b845991d0ac43e546831af1249753ab4c3aa3a0"
 dependencies = [
  "cfg-if 1.0.0",
  "cipher 0.4.4",
@@ -80,12 +80,12 @@ dependencies = [
 
 [[package]]
 name = "aes-gcm"
-version = "0.10.2"
+version = "0.10.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "209b47e8954a928e1d72e86eca7000ebb6655fe1436d33eefc2201cad027e237"
+checksum = "831010a0f742e1209b3bcea8fab6a8e149051ba6099432c8cb2cc117dec3ead1"
 dependencies = [
  "aead 0.5.2",
- "aes 0.8.3",
+ "aes 0.8.4",
  "cipher 0.4.4",
  "ctr 0.9.2",
  "ghash 0.5.0",
@@ -114,26 +114,27 @@ dependencies = [
 
 [[package]]
 name = "ahash"
-version = "0.4.7"
+version = "0.4.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "739f4a8db6605981345c5654f3a85b056ce52f37a39d34da03f25bf2151ea16e"
+checksum = "0453232ace82dee0dd0b4c87a59bd90f7b53b314f3e0f61fe2ee7c8a16482289"
 
 [[package]]
 name = "ahash"
-version = "0.8.3"
+version = "0.8.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c99f64d1e06488f620f932677e24bc6e2897582980441ae90a671415bd7ec2f"
+checksum = "42cd52102d3df161c77a887b608d7a4897d7cc112886a9537b738a887a03aaff"
 dependencies = [
  "cfg-if 1.0.0",
  "once_cell",
  "version_check",
+ "zerocopy",
 ]
 
 [[package]]
 name = "aho-corasick"
-version = "0.7.20"
+version = "1.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cc936419f96fa211c1b9166887b38e5e40b19958e5b895be7c1f93adec7071ac"
+checksum = "b2969dcb958b36655471fc61f7e416fa76033bdd4bfed0678d8fee1e2d07a1f0"
 dependencies = [
  "memchr",
 ]
@@ -144,6 +145,12 @@ version = "0.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0942ffc6dcaadf03badf6e6a2d0228460359d5e34b57ccdc720b7382dfbd5ec5"
 
+[[package]]
+name = "android-tzdata"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e999941b234f3131b00bc13c22d06e8c5ff726d1b6318ac7eb276997bbb4fef0"
+
 [[package]]
 name = "android_system_properties"
 version = "0.1.5"
@@ -155,9 +162,9 @@ dependencies = [
 
 [[package]]
 name = "anstream"
-version = "0.5.0"
+version = "0.6.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1f58811cfac344940f1a400b6e6231ce35171f614f26439e80f8c1465c5cc0c"
+checksum = "6e2e1ebcb11de5c03c67de28a7df593d32191b44939c482e97702baaaa6ab6a5"
 dependencies = [
  "anstyle",
  "anstyle-parse",
@@ -169,43 +176,43 @@ dependencies = [
 
 [[package]]
 name = "anstyle"
-version = "1.0.2"
+version = "1.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "15c4c2c83f81532e5845a733998b6971faca23490340a418e9b72a3ec9de12ea"
+checksum = "8901269c6307e8d93993578286ac0edf7f195079ffff5ebdeea6a59ffb7e36bc"
 
 [[package]]
 name = "anstyle-parse"
-version = "0.2.1"
+version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "938874ff5980b03a87c5524b3ae5b59cf99b1d6bc836848df7bc5ada9643c333"
+checksum = "c75ac65da39e5fe5ab759307499ddad880d724eed2f6ce5b5e8a26f4f387928c"
 dependencies = [
  "utf8parse",
 ]
 
 [[package]]
 name = "anstyle-query"
-version = "1.0.0"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ca11d4be1bab0c8bc8734a9aa7bf4ee8316d462a08c6ac5052f888fef5b494b"
+checksum = "e28923312444cdd728e4738b3f9c9cac739500909bb3d3c94b43551b16517648"
 dependencies = [
- "windows-sys 0.48.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
 name = "anstyle-wincon"
-version = "2.1.0"
+version = "3.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "58f54d10c6dfa51283a066ceab3ec1ab78d13fae00aa49243a45e4571fb79dfd"
+checksum = "1cd54b81ec8d6180e24654d0b371ad22fc3dd083b6ff8ba325b72e00c87660a7"
 dependencies = [
  "anstyle",
- "windows-sys 0.48.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
 name = "anyhow"
-version = "1.0.69"
+version = "1.0.79"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "224afbd727c3d6e4b90103ece64b8d1b67fbb1973b1046c2281eed3f3803f800"
+checksum = "080e9890a082662b09c1ad45f567faeeb47f22b5fb23895fbe1e651e718e25ca"
 
 [[package]]
 name = "arrayvec"
@@ -242,64 +249,78 @@ dependencies = [
 
 [[package]]
 name = "async-channel"
-version = "1.8.0"
+version = "1.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "81953c529336010edd6d8e358f886d9581267795c61b19475b71314bffa46d35"
+dependencies = [
+ "concurrent-queue",
+ "event-listener 2.5.3",
+ "futures-core",
+]
+
+[[package]]
+name = "async-channel"
+version = "2.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf46fee83e5ccffc220104713af3292ff9bc7c64c7de289f66dae8e38d826833"
+checksum = "f28243a43d821d11341ab73c80bed182dc015c514b951616cf79bd4af39af0c3"
 dependencies = [
  "concurrent-queue",
- "event-listener",
+ "event-listener 5.0.0",
+ "event-listener-strategy 0.5.0",
  "futures-core",
+ "pin-project-lite",
 ]
 
 [[package]]
 name = "async-dup"
-version = "1.2.2"
+version = "1.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7427a12b8dc09291528cfb1da2447059adb4a257388c2acd6497a79d55cf6f7c"
+checksum = "7c2886ab563af5038f79ec016dd7b87947ed138b794e8dd64992962c9cca0411"
 dependencies = [
+ "async-lock 3.3.0",
  "futures-io",
- "simple-mutex",
 ]
 
 [[package]]
 name = "async-executor"
-version = "1.5.0"
+version = "1.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "17adb73da160dfb475c183343c8cccd80721ea5a605d3eb57125f0a7b7a92d0b"
+checksum = "17ae5ebefcc48e7452b4987947920dac9450be1110cadf34d1b8c116bdbaf97c"
 dependencies = [
- "async-lock",
+ "async-lock 3.3.0",
  "async-task",
  "concurrent-queue",
- "fastrand",
- "futures-lite",
+ "fastrand 2.0.1",
+ "futures-lite 2.2.0",
  "slab",
 ]
 
 [[package]]
 name = "async-global-executor"
-version = "2.3.1"
+version = "2.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1b6f5d7df27bd294849f8eec66ecfc63d11814df7a4f5d74168a2394467b776"
+checksum = "05b1b633a2115cd122d73b955eadd9916c18c8f510ec9cd1686404c60ad1c29c"
 dependencies = [
- "async-channel",
+ "async-channel 2.2.0",
  "async-executor",
- "async-io",
- "async-lock",
+ "async-io 2.3.1",
+ "async-lock 3.3.0",
  "blocking",
- "futures-lite",
+ "futures-lite 2.2.0",
  "once_cell",
 ]
 
 [[package]]
 name = "async-h1"
-version = "2.3.3"
+version = "2.3.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8101020758a4fc3a7c326cb42aa99e9fa77cbfb76987c128ad956406fe1f70a7"
+checksum = "5d1d1dae8cb2c4258a79d6ed088b7fb9b4763bf4e9b22d040779761e046a2971"
 dependencies = [
- "async-channel",
+ "async-channel 1.9.0",
  "async-dup",
- "async-std",
- "futures-core",
+ "async-global-executor",
+ "async-io 1.13.0",
+ "futures-lite 1.13.0",
  "http-types",
  "httparse",
  "log",
@@ -308,31 +329,61 @@ dependencies = [
 
 [[package]]
 name = "async-io"
-version = "1.12.0"
+version = "1.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c374dda1ed3e7d8f0d9ba58715f924862c63eae6849c92d3a18e7fbde9e2794"
+checksum = "0fc5b45d93ef0529756f812ca52e44c221b35341892d3dcc34132ac02f3dd2af"
 dependencies = [
- "async-lock",
+ "async-lock 2.8.0",
  "autocfg",
+ "cfg-if 1.0.0",
  "concurrent-queue",
- "futures-lite",
- "libc",
+ "futures-lite 1.13.0",
  "log",
  "parking",
- "polling",
+ "polling 2.8.0",
+ "rustix 0.37.27",
  "slab",
- "socket2",
+ "socket2 0.4.10",
  "waker-fn",
- "windows-sys 0.42.0",
+]
+
+[[package]]
+name = "async-io"
+version = "2.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f97ab0c5b00a7cdbe5a371b9a782ee7be1316095885c8a4ea1daf490eb0ef65"
+dependencies = [
+ "async-lock 3.3.0",
+ "cfg-if 1.0.0",
+ "concurrent-queue",
+ "futures-io",
+ "futures-lite 2.2.0",
+ "parking",
+ "polling 3.4.0",
+ "rustix 0.38.31",
+ "slab",
+ "tracing",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
 name = "async-lock"
-version = "2.7.0"
+version = "2.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa24f727524730b077666307f2734b4a1a1c57acb79193127dcc8914d5242dd7"
+checksum = "287272293e9d8c41773cec55e365490fe034813a2f172f502d6ddcf75b2f582b"
 dependencies = [
- "event-listener",
+ "event-listener 2.5.3",
+]
+
+[[package]]
+name = "async-lock"
+version = "3.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d034b430882f8381900d3fe6f0aaa3ad94f2cb4ac519b429692a1bc2dda4ae7b"
+dependencies = [
+ "event-listener 4.0.3",
+ "event-listener-strategy 0.4.0",
+ "pin-project-lite",
 ]
 
 [[package]]
@@ -342,15 +393,15 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "62565bb4402e926b29953c785397c6dc0391b7b446e45008b0049eb43cec6f5d"
 dependencies = [
  "async-attributes",
- "async-channel",
+ "async-channel 1.9.0",
  "async-global-executor",
- "async-io",
- "async-lock",
+ "async-io 1.13.0",
+ "async-lock 2.8.0",
  "crossbeam-utils",
  "futures-channel",
  "futures-core",
  "futures-io",
- "futures-lite",
+ "futures-lite 1.13.0",
  "gloo-timers",
  "kv-log-macro",
  "log",
@@ -364,15 +415,15 @@ dependencies = [
 
 [[package]]
 name = "async-task"
-version = "4.3.0"
+version = "4.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a40729d2133846d9ed0ea60a8b9541bccddab49cd30f0715a1da672fe9a2524"
+checksum = "fbb36e985947064623dbd357f727af08ffd077f93d696782f3c56365fa2e2799"
 
 [[package]]
 name = "atomic-waker"
-version = "1.1.0"
+version = "1.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "debc29dde2e69f9e47506b525f639ed42300fc014a3e007832592448fa8e4599"
+checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0"
 
 [[package]]
 name = "atty"
@@ -397,16 +448,16 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b62ddb9cb1ec0a098ad4bbf9344d0713fa193ae1a80af55febcff2627b6a00c1"
 dependencies = [
- "getrandom 0.2.8",
+ "getrandom 0.2.12",
  "instant",
  "rand 0.8.5",
 ]
 
 [[package]]
 name = "backtrace"
-version = "0.3.67"
+version = "0.3.69"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "233d376d6d185f2a3093e58f283f60f880315b6c60075b01f36b3b85154564ca"
+checksum = "2089b7e3f35b9dd2d0ed921ead4f6d318c27680d4a5bd167b3ee120edb105837"
 dependencies = [
  "addr2line",
  "cc",
@@ -437,9 +488,9 @@ checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8"
 
 [[package]]
 name = "base64"
-version = "0.21.0"
+version = "0.21.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4a4ddaa51a5bc52a6948f74c06d20aaaddb71924eab79b8c97a8c556e942d6a"
+checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567"
 
 [[package]]
 name = "bitflags"
@@ -447,6 +498,12 @@ version = "1.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
+[[package]]
+name = "bitflags"
+version = "2.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed570934406eb16438a4e976b1b4500774099c13b8cb96eec99f620f05090ddf"
+
 [[package]]
 name = "bitvec"
 version = "1.0.1"
@@ -477,7 +534,7 @@ version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4152116fd6e9dadb291ae18fc1ec3575ed6d84c29642d97890f4b4a3417297e4"
 dependencies = [
- "generic-array 0.14.6",
+ "generic-array 0.14.7",
 ]
 
 [[package]]
@@ -486,7 +543,7 @@ version = "0.10.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
 dependencies = [
- "generic-array 0.14.6",
+ "generic-array 0.14.7",
 ]
 
 [[package]]
@@ -500,16 +557,18 @@ dependencies = [
 
 [[package]]
 name = "blocking"
-version = "1.3.0"
+version = "1.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c67b173a56acffd6d2326fb7ab938ba0b00a71480e14902b2591c87bc5741e8"
+checksum = "6a37913e8dc4ddcc604f0c6d3bf2887c995153af3611de9e23c352b44c1b9118"
 dependencies = [
- "async-channel",
- "async-lock",
+ "async-channel 2.2.0",
+ "async-lock 3.3.0",
  "async-task",
- "atomic-waker",
- "fastrand",
- "futures-lite",
+ "fastrand 2.0.1",
+ "futures-io",
+ "futures-lite 2.2.0",
+ "piper",
+ "tracing",
 ]
 
 [[package]]
@@ -529,9 +588,9 @@ dependencies = [
 
 [[package]]
 name = "bumpalo"
-version = "3.12.0"
+version = "3.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d261e256854913907f67ed06efbc3338dfe6179796deefc1ff763fc1aee5535"
+checksum = "7f30e7476521f6f8af1a1c4c0b8cc94f0bee37d91763d0ca2665f299b6cd8aec"
 
 [[package]]
 name = "byte-slice-cast"
@@ -547,15 +606,15 @@ checksum = "e3b5ca7a04898ad4bcd41c90c5285445ff5b791899bb1b0abdd2a2aa791211d7"
 
 [[package]]
 name = "byteorder"
-version = "1.4.3"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
 
 [[package]]
 name = "bytes"
-version = "1.4.0"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "89b2fd2a0dcf38d7971e2194b6b6eebab45ae01067456a7fd93d5547a61b70be"
+checksum = "a2bd12c1caf447e69cd4528f47f94d203fd2582878ecb9e9465484c4148a8223"
 
 [[package]]
 name = "cast"
@@ -565,9 +624,12 @@ checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
 [[package]]
 name = "cc"
-version = "1.0.79"
+version = "1.0.83"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50d30906286121d95be3d479533b458f87493b30a4b5f79a607db8f5d11aa91f"
+checksum = "f1174fb0b6ec23863f8b971027804a42614e347eafb0a95bf0b12cdae21fc4d0"
+dependencies = [
+ "libc",
+]
 
 [[package]]
 name = "cfg-if"
@@ -583,24 +645,23 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
 [[package]]
 name = "chrono"
-version = "0.4.24"
+version = "0.4.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e3c5919066adf22df73762e50cffcde3a758f2a848b113b586d1f86728b673b"
+checksum = "5bc015644b92d5890fab7489e49d21f879d5c990186827d42ec511919404f38b"
 dependencies = [
+ "android-tzdata",
  "iana-time-zone",
  "js-sys",
- "num-integer",
  "num-traits",
- "time 0.1.45",
  "wasm-bindgen",
- "winapi 0.3.9",
+ "windows-targets 0.52.0",
 ]
 
 [[package]]
 name = "chunked_transfer"
-version = "1.4.1"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cca491388666e04d7248af3f60f0c40cfb0991c72205595d7c396e3510207d1a"
+checksum = "6e4de3bc4ea267985becf712dc6d9eed8b04c953b3fcfb339ebc87acd9804901"
 
 [[package]]
 name = "cipher"
@@ -608,7 +669,7 @@ version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "12f8e7987cbd042a63249497f41aed09f8e65add917ea6566effbc56578d6801"
 dependencies = [
- "generic-array 0.14.6",
+ "generic-array 0.14.7",
 ]
 
 [[package]]
@@ -627,27 +688,26 @@ version = "2.34.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a0610544180c38b88101fecf2dd634b174a62eef6946f84dfc6a7127512b381c"
 dependencies = [
- "bitflags",
+ "bitflags 1.3.2",
  "textwrap",
  "unicode-width",
 ]
 
 [[package]]
 name = "clap"
-version = "4.4.1"
+version = "4.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7c8d502cbaec4595d2e7d5f61e318f05417bd2b66fdc3809498f0d3fdf0bea27"
+checksum = "80c21025abd42669a92efc996ef13cfb2c5c627858421ea58d5c3b331a6c134f"
 dependencies = [
  "clap_builder",
  "clap_derive",
- "once_cell",
 ]
 
 [[package]]
 name = "clap_builder"
-version = "4.4.1"
+version = "4.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5891c7bc0edb3e1c2204fc5e94009affabeb1821c9e5fdc3959536c5c0bb984d"
+checksum = "458bf1f341769dfcf849846f65dffdf9146daa56bcd2a47cb4e1de9915567c99"
 dependencies = [
  "anstream",
  "anstyle",
@@ -657,21 +717,21 @@ dependencies = [
 
 [[package]]
 name = "clap_derive"
-version = "4.4.0"
+version = "4.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c9fd1a5729c4548118d7d70ff234a44868d00489a4b6597b0b020918a0e91a1a"
+checksum = "307bc0538d5f0f83b8248db3087aa92fe504e4691294d0c96c0eabc33f47ba47"
 dependencies = [
  "heck",
  "proc-macro2",
  "quote",
- "syn 2.0.29",
+ "syn 2.0.48",
 ]
 
 [[package]]
 name = "clap_lex"
-version = "0.5.1"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd7cc57abe963c6d3b9d8be5b06ba7c8957a930305ca90304f24ef040aa6f961"
+checksum = "98cc8fbded0c607b7ba9dd60cd98df59af97e84d24e49c8557331cfc26d301ce"
 
 [[package]]
 name = "clarity"
@@ -705,16 +765,6 @@ dependencies = [
  "cc",
 ]
 
-[[package]]
-name = "codespan-reporting"
-version = "0.11.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3538270d33cc669650c4b093848450d380def10c331d38c768e34cac80576e6e"
-dependencies = [
- "termcolor",
- "unicode-width",
-]
-
 [[package]]
 name = "colorchoice"
 version = "1.0.0"
@@ -723,9 +773,9 @@ checksum = "acbf1af155f9b9ef647e42cdc158db4b64a1b61f743629225fde6f3e0be2a7c7"
 
 [[package]]
 name = "concurrent-queue"
-version = "2.1.0"
+version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c278839b831783b70278b14df4d45e1beb1aad306c07bb796637de9a0e323e8e"
+checksum = "d16048cd947b08fa32c24458a22f5dc5e835264f689f4f5653210c69fd107363"
 dependencies = [
  "crossbeam-utils",
 ]
@@ -755,9 +805,9 @@ dependencies = [
 
 [[package]]
 name = "core-foundation"
-version = "0.9.3"
+version = "0.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "194a7a9e6de53fa55116934067c844d9d749312f75c6f6d0980e8c252f8c2146"
+checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f"
 dependencies = [
  "core-foundation-sys",
  "libc",
@@ -765,15 +815,15 @@ dependencies = [
 
 [[package]]
 name = "core-foundation-sys"
-version = "0.8.3"
+version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5827cebf4670468b8772dd191856768aedcb1b0278a04f989f7766351917b9dc"
+checksum = "06ea2b9bc92be3c2baa9334a323ebca2d6f074ff852cd1d7b11064035cd3868f"
 
 [[package]]
 name = "cpufeatures"
-version = "0.2.5"
+version = "0.2.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28d997bd5e24a5928dd43e46dc529867e207907fe0b239c3477d924f7f2ca320"
+checksum = "53fe5e26ff1b7aef8bca9c6080520cfb8d9333c7568e1829cef191a9723e5504"
 dependencies = [
  "libc",
 ]
@@ -786,9 +836,9 @@ checksum = "dcb25d077389e53838a8158c8e99174c5a9d902dee4904320db714f3c653ffba"
 
 [[package]]
 name = "crc32fast"
-version = "1.3.2"
+version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b540bd8bc810d3885c6ea91e2018302f68baba2129ab3e88f32389ee9370880d"
+checksum = "b3855a8a784b474f333699ef2bbca9db2c4a1f6d9088a90a2d25b1eb53111eaa"
 dependencies = [
  "cfg-if 1.0.0",
 ]
@@ -829,48 +879,30 @@ dependencies = [
  "itertools",
 ]
 
-[[package]]
-name = "crossbeam-channel"
-version = "0.5.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf2b3e8478797446514c91ef04bafcb59faba183e621ad488df88983cc14128c"
-dependencies = [
- "cfg-if 1.0.0",
- "crossbeam-utils",
-]
-
 [[package]]
 name = "crossbeam-deque"
-version = "0.8.3"
+version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ce6fd6f855243022dcecf8702fef0c297d4338e226845fe067f6341ad9fa0cef"
+checksum = "613f8cc01fe9cf1a3eb3d7f488fd2fa8388403e97039e2f73692932e291a770d"
 dependencies = [
- "cfg-if 1.0.0",
  "crossbeam-epoch",
  "crossbeam-utils",
 ]
 
 [[package]]
 name = "crossbeam-epoch"
-version = "0.9.14"
+version = "0.9.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46bd5f3f85273295a9d14aedfb86f6aadbff6d8f5295c4a9edb08e819dcf5695"
+checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
 dependencies = [
- "autocfg",
- "cfg-if 1.0.0",
  "crossbeam-utils",
- "memoffset 0.8.0",
- "scopeguard",
 ]
 
 [[package]]
 name = "crossbeam-utils"
-version = "0.8.15"
+version = "0.8.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c063cd8cc95f5c377ed0d4b49a4b21f632396ff690e8470c29b3359b346984b"
-dependencies = [
- "cfg-if 1.0.0",
-]
+checksum = "248e3bacc7dc6baa3b21e405ee045c3047101a49145e7e9eca583ab4c2ca5345"
 
 [[package]]
 name = "crunchy"
@@ -884,26 +916,26 @@ version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
 dependencies = [
- "generic-array 0.14.6",
+ "generic-array 0.14.7",
  "rand_core 0.6.4",
  "typenum",
 ]
 
 [[package]]
 name = "crypto-mac"
-version = "0.10.1"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bff07008ec701e8028e2ceb8f83f0e4274ee62bd2dbdc4fefff2e9a91824081a"
+checksum = "4857fd85a0c34b3c3297875b747c1e02e06b6a0ea32dd892d8192b9ce0813ea6"
 dependencies = [
- "generic-array 0.14.6",
+ "generic-array 0.14.7",
  "subtle",
 ]
 
 [[package]]
 name = "csv"
-version = "1.2.1"
+version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b015497079b9a9d69c02ad25de6c0a6edef051ea6360a327d0bd05802ef64ad"
+checksum = "ac574ff4d437a7b5ad237ef331c17ccca63c46479e5b5453eb8e10bb99a759fe"
 dependencies = [
  "csv-core",
  "itoa",
@@ -913,23 +945,13 @@ dependencies = [
 
 [[package]]
 name = "csv-core"
-version = "0.1.10"
+version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b2466559f260f48ad25fe6317b3c8dac77b5bdb5763ac7d9d6103530663bc90"
+checksum = "5efa2b3d7902f4b634a20cae3c9c4e6209dc4779feb6863329607560143efa70"
 dependencies = [
  "memchr",
 ]
 
-[[package]]
-name = "ctor"
-version = "0.1.26"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d2301688392eb071b0bf1a37be05c469d3cc4dbbd95df672fe28ab021e6a096"
-dependencies = [
- "quote",
- "syn 1.0.109",
-]
-
 [[package]]
 name = "ctr"
 version = "0.6.0"
@@ -963,60 +985,31 @@ dependencies = [
 ]
 
 [[package]]
-name = "cxx"
-version = "1.0.92"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a140f260e6f3f79013b8bfc65e7ce630c9ab4388c6a89c71e07226f49487b72"
-dependencies = [
- "cc",
- "cxxbridge-flags",
- "cxxbridge-macro",
- "link-cplusplus",
-]
-
-[[package]]
-name = "cxx-build"
-version = "1.0.92"
+name = "dashmap"
+version = "5.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da6383f459341ea689374bf0a42979739dc421874f112ff26f829b8040b8e613"
+checksum = "978747c1d849a7d2ee5e8adc0159961c48fb7e5db2f06af6723b80123bb53856"
 dependencies = [
- "cc",
- "codespan-reporting",
+ "cfg-if 1.0.0",
+ "hashbrown 0.14.3",
+ "lock_api",
  "once_cell",
- "proc-macro2",
- "quote",
- "scratch",
- "syn 1.0.109",
+ "parking_lot_core",
 ]
 
 [[package]]
-name = "cxxbridge-flags"
-version = "1.0.92"
+name = "data-encoding"
+version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90201c1a650e95ccff1c8c0bb5a343213bdd317c6e600a93075bca2eff54ec97"
+checksum = "7e962a19be5cfc3f3bf6dd8f61eb50107f356ad6270fbb3ed41476571db78be5"
 
 [[package]]
-name = "cxxbridge-macro"
-version = "1.0.92"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b75aed41bb2e6367cae39e6326ef817a851db13c13e4f3263714ca3cfb8de56"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.109",
-]
-
-[[package]]
-name = "dashmap"
-version = "5.4.0"
+name = "deranged"
+version = "0.3.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "907076dfda823b0b36d2a1bb5f90c96660a5bbcd7729e10727f07858f22c4edc"
+checksum = "b42b6fa04a440b495c8b04d0e71b707c585f83cb9cb28cf8cd0d976c315e31b4"
 dependencies = [
- "cfg-if 1.0.0",
- "hashbrown 0.12.3",
- "lock_api",
- "once_cell",
- "parking_lot_core",
+ "powerfmt",
 ]
 
 [[package]]
@@ -1034,14 +1027,14 @@ version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d3dd60d1080a57a05ab032377049e0591415d2b31afd7028356dbf3cc6dcb066"
 dependencies = [
- "generic-array 0.14.6",
+ "generic-array 0.14.7",
 ]
 
 [[package]]
 name = "digest"
-version = "0.10.6"
+version = "0.10.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8168378f4e5023e7218c89c891c0fd8ecdb5e5e4f18cb78f38cf245dd021e76f"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
 dependencies = [
  "block-buffer 0.10.4",
  "crypto-common",
@@ -1089,15 +1082,15 @@ dependencies = [
 
 [[package]]
 name = "either"
-version = "1.8.1"
+version = "1.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fcaabb2fef8c910e7f4c7ce9f67a1283a1715879a7c230ca9d6d1ae31f16d91"
+checksum = "11157ac094ffbdde99aa67b23417ebdd801842852b500e395a45a9c0aac03e4a"
 
 [[package]]
 name = "encoding_rs"
-version = "0.8.32"
+version = "0.8.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "071a31f4ee85403370b58aca746f01041ede6f0da2730960ad001edc2b71b394"
+checksum = "7268b386296a025e474d5140678f75d6de9493ae55a5d709eeb9dd08149945e1"
 dependencies = [
  "cfg-if 1.0.0",
 ]
@@ -1110,30 +1103,61 @@ checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
 
 [[package]]
 name = "errno"
-version = "0.3.3"
+version = "0.3.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "136526188508e25c6fef639d7927dfb3e0e3084488bf202267829cf7fc23dbdd"
+checksum = "a258e46cdc063eb8519c00b9fc845fc47bcfca4130e2f08e88665ceda8474245"
 dependencies = [
- "errno-dragonfly",
  "libc",
- "windows-sys 0.48.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
-name = "errno-dragonfly"
-version = "0.1.2"
+name = "event-listener"
+version = "2.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0206175f82b8d6bf6652ff7d71a1e27fd2e4efde587fd368662814d6ec1d9ce0"
+
+[[package]]
+name = "event-listener"
+version = "4.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aa68f1b12764fab894d2755d2518754e71b4fd80ecfb822714a1206c2aab39bf"
+checksum = "67b215c49b2b248c855fb73579eb1f4f26c38ffdc12973e20e07b91d78d5646e"
 dependencies = [
- "cc",
- "libc",
+ "concurrent-queue",
+ "parking",
+ "pin-project-lite",
 ]
 
 [[package]]
 name = "event-listener"
-version = "2.5.3"
+version = "5.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0206175f82b8d6bf6652ff7d71a1e27fd2e4efde587fd368662814d6ec1d9ce0"
+checksum = "b72557800024fabbaa2449dd4bf24e37b93702d457a4d4f2b0dd1f0f039f20c1"
+dependencies = [
+ "concurrent-queue",
+ "parking",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "event-listener-strategy"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "958e4d70b6d5e81971bebec42271ec641e7ff4e170a6fa605f2b8a8b65cb97d3"
+dependencies = [
+ "event-listener 4.0.3",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "event-listener-strategy"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "feedafcaa9b749175d5ac357452a9d41ea2911da598fde46ce1fe02c37751291"
+dependencies = [
+ "event-listener 5.0.0",
+ "pin-project-lite",
+]
 
 [[package]]
 name = "extend"
@@ -1174,6 +1198,12 @@ dependencies = [
  "instant",
 ]
 
+[[package]]
+name = "fastrand"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "25cbce373ec4653f1a01a31e8a5e5ec0c622dc27ff9c4e6606eefef5cbbed4a5"
+
 [[package]]
 name = "fixed-hash"
 version = "0.8.0"
@@ -1194,9 +1224,9 @@ checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
 
 [[package]]
 name = "form_urlencoded"
-version = "1.1.0"
+version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a9c384f161156f5260c24a097c56119f9be8c798586aecc13afbcbe7b7e26bf8"
+checksum = "e13624c2627564efccf4934284bdd98cbaa14e79b0b5a141218e507b3a823456"
 dependencies = [
  "percent-encoding",
 ]
@@ -1207,7 +1237,7 @@ version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2e9763c69ebaae630ba35f74888db465e49e259ba1bc0eda7d06f4a067615d82"
 dependencies = [
- "bitflags",
+ "bitflags 1.3.2",
  "fuchsia-zircon-sys",
 ]
 
@@ -1225,9 +1255,9 @@ checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
 
 [[package]]
 name = "futures"
-version = "0.3.28"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "23342abe12aba583913b2e62f22225ff9c950774065e4bfb61a19cd9770fec40"
+checksum = "645c6916888f6cb6350d2550b80fb63e734897a8498abe35cfb732b6487804b0"
 dependencies = [
  "futures-channel",
  "futures-core",
@@ -1240,9 +1270,9 @@ dependencies = [
 
 [[package]]
 name = "futures-channel"
-version = "0.3.28"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "955518d47e09b25bbebc7a18df10b81f0c766eaf4c4f1cccef2fca5f2a4fb5f2"
+checksum = "eac8f7d7865dcb88bd4373ab671c8cf4508703796caa2b1985a9ca867b3fcb78"
 dependencies = [
  "futures-core",
  "futures-sink",
@@ -1250,15 +1280,15 @@ dependencies = [
 
 [[package]]
 name = "futures-core"
-version = "0.3.28"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4bca583b7e26f571124fe5b7561d49cb2868d79116cfa0eefce955557c6fee8c"
+checksum = "dfc6580bb841c5a68e9ef15c77ccc837b40a7504914d52e47b8b0e9bbda25a1d"
 
 [[package]]
 name = "futures-executor"
-version = "0.3.28"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ccecee823288125bd88b4d7f565c9e58e41858e47ab72e8ea2d64e93624386e0"
+checksum = "a576fc72ae164fca6b9db127eaa9a9dda0d61316034f33a0a0d4eda41f02b01d"
 dependencies = [
  "futures-core",
  "futures-task",
@@ -1267,17 +1297,17 @@ dependencies = [
 
 [[package]]
 name = "futures-io"
-version = "0.3.28"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4fff74096e71ed47f8e023204cfd0aa1289cd54ae5430a9523be060cdb849964"
+checksum = "a44623e20b9681a318efdd71c299b6b222ed6f231972bfe2f224ebad6311f0c1"
 
 [[package]]
 name = "futures-lite"
-version = "1.12.0"
+version = "1.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7694489acd39452c77daa48516b894c153f192c3578d5a839b62c58099fcbf48"
+checksum = "49a9d51ce47660b1e808d3c990b4709f2f415d928835a17dfd16991515c46bce"
 dependencies = [
- "fastrand",
+ "fastrand 1.9.0",
  "futures-core",
  "futures-io",
  "memchr",
@@ -1286,28 +1316,41 @@ dependencies = [
  "waker-fn",
 ]
 
+[[package]]
+name = "futures-lite"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "445ba825b27408685aaecefd65178908c36c6e96aaf6d8599419d46e624192ba"
+dependencies = [
+ "fastrand 2.0.1",
+ "futures-core",
+ "futures-io",
+ "parking",
+ "pin-project-lite",
+]
+
 [[package]]
 name = "futures-macro"
-version = "0.3.28"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "89ca545a94061b6365f2c7355b4b32bd20df3ff95f02da9329b34ccc3bd6ee72"
+checksum = "87750cf4b7a4c0625b1529e4c543c2182106e4dedc60a2a6455e00d212c489ac"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.29",
+ "syn 2.0.48",
 ]
 
 [[package]]
 name = "futures-sink"
-version = "0.3.28"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f43be4fe21a13b9781a69afa4985b0f6ee0e1afab2c6f454a8cf30e2b2237b6e"
+checksum = "9fb8e00e87438d937621c1c6269e53f536c14d3fbd6a042bb24879e57d474fb5"
 
 [[package]]
 name = "futures-task"
-version = "0.3.28"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76d3d132be6c0e6aa1534069c705a74a5997a356c0dc2f86a47765e5617c5b65"
+checksum = "38d84fa142264698cdce1a9f9172cf383a0c82de1bddcf3092901442c4097004"
 
 [[package]]
 name = "futures-timer"
@@ -1317,9 +1360,9 @@ checksum = "e64b03909df88034c26dc1547e8970b91f98bdb65165d6a4e9110d94263dbb2c"
 
 [[package]]
 name = "futures-util"
-version = "0.3.28"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26b01e40b772d54cf6c6d721c1d1abd0647a0106a12ecaa1c186273392a69533"
+checksum = "3d6401deb83407ab3da39eba7e33987a73c3df0c82b4bb5813ee871c19c41d48"
 dependencies = [
  "futures-channel",
  "futures-core",
@@ -1344,9 +1387,9 @@ dependencies = [
 
 [[package]]
 name = "generic-array"
-version = "0.14.6"
+version = "0.14.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bff49e947297f3312447abdca79f45f4738097cc82b06e72054d2223f601f1b9"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
 dependencies = [
  "typenum",
  "version_check",
@@ -1365,9 +1408,9 @@ dependencies = [
 
 [[package]]
 name = "getrandom"
-version = "0.2.8"
+version = "0.2.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c05aeb6a22b8f62540c194aac980f2115af067bfe15a0734d7277a768d396b31"
+checksum = "190092ea657667030ac6a35e305e62fc4dd69fd98ac98631e5d3a2b1575a12b5"
 dependencies = [
  "cfg-if 1.0.0",
  "libc",
@@ -1396,9 +1439,9 @@ dependencies = [
 
 [[package]]
 name = "gimli"
-version = "0.27.2"
+version = "0.28.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad0a93d233ebf96623465aad4046a8d3aa4da22d4f4beba5388838c8a434bbb4"
+checksum = "4271d37baee1b8c7e4b708028c57d816cf9d2434acb33a549475f78c181f6253"
 
 [[package]]
 name = "gloo-timers"
@@ -1414,9 +1457,9 @@ dependencies = [
 
 [[package]]
 name = "h2"
-version = "0.3.16"
+version = "0.3.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5be7b54589b581f624f566bf5d8eb2bab1db736c51528720b6bd36b96b55924d"
+checksum = "bb2c4422095b67ee78da96fbb51a4cc413b3b25883c7717ff7ca1ab31022c9c9"
 dependencies = [
  "bytes",
  "fnv",
@@ -1424,7 +1467,7 @@ dependencies = [
  "futures-sink",
  "futures-util",
  "http",
- "indexmap 1.9.2",
+ "indexmap",
  "slab",
  "tokio",
  "tokio-util",
@@ -1443,22 +1486,16 @@ version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d7afe4a420e3fe79967a00898cc1f4db7c8a49a9333a29f8a4bd76a253d5cd04"
 dependencies = [
- "ahash 0.4.7",
+ "ahash 0.4.8",
 ]
 
 [[package]]
 name = "hashbrown"
-version = "0.12.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
-
-[[package]]
-name = "hashbrown"
-version = "0.14.0"
+version = "0.14.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c6201b9ff9fd90a5a3bac2e56a830d0caa509576f0e503818ee82c181b3437a"
+checksum = "290f1a1d9242c78d09ce40a5e87e7554ee637af1351968159f4952f028f75604"
 dependencies = [
- "ahash 0.8.3",
+ "ahash 0.8.8",
  "allocator-api2",
  "serde",
 ]
@@ -1474,18 +1511,17 @@ dependencies = [
 
 [[package]]
 name = "headers"
-version = "0.3.8"
+version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3e372db8e5c0d213e0cd0b9be18be2aca3d44cf2fe30a9d46a65581cd454584"
+checksum = "06683b93020a07e3dbcf5f8c0f6d40080d725bea7936fc01ad345c01b97dc270"
 dependencies = [
- "base64 0.13.1",
- "bitflags",
+ "base64 0.21.7",
  "bytes",
  "headers-core",
  "http",
  "httpdate",
  "mime",
- "sha1 0.10.5",
+ "sha1 0.10.6",
 ]
 
 [[package]]
@@ -1514,18 +1550,9 @@ dependencies = [
 
 [[package]]
 name = "hermit-abi"
-version = "0.2.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee512640fe35acbfb4bb779db6f0d80704c2cacfa2e39b601ef3e3f47d1ae4c7"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "hermit-abi"
-version = "0.3.2"
+version = "0.3.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "443144c8cdadd93ebf52ddb4056d257f5b52c04d3c804e657d19eb73fc33668b"
+checksum = "bd5256b483761cd23699d0da46cc6fd2ee3be420bbe6d020ae4a091e70b7e9fd"
 
 [[package]]
 name = "hex"
@@ -1555,18 +1582,18 @@ dependencies = [
 
 [[package]]
 name = "home"
-version = "0.5.5"
+version = "0.5.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5444c27eef6923071f7ebcc33e3444508466a76f7a2b93da00ed6e19f30c1ddb"
+checksum = "e3d1354bf6b7235cb4a0576c2619fd4ed18183f689b12b006a0ee7329eeff9a5"
 dependencies = [
- "windows-sys 0.48.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
 name = "http"
-version = "0.2.9"
+version = "0.2.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd6effc99afb63425aff9b05836f029929e345a6148a14b7ecd5ab67af944482"
+checksum = "8947b1a6fad4393052c7ba1f4cd97bed3e953a95c79c92ad9b051a04611d9fbb"
 dependencies = [
  "bytes",
  "fnv",
@@ -1575,9 +1602,9 @@ dependencies = [
 
 [[package]]
 name = "http-body"
-version = "0.4.5"
+version = "0.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d5f38f16d184e36f2408a55281cd658ecbd3ca05cce6d6510a176eca393e26d1"
+checksum = "7ceab25649e9960c0311ea418d17bee82c0dcec1bd053b5f9a66e265a693bed2"
 dependencies = [
  "bytes",
  "http",
@@ -1591,11 +1618,11 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6e9b187a72d63adbfba487f48095306ac823049cb504ee195541e91c7775f5ad"
 dependencies = [
  "anyhow",
- "async-channel",
+ "async-channel 1.9.0",
  "async-std",
  "base64 0.13.1",
  "cookie",
- "futures-lite",
+ "futures-lite 1.13.0",
  "infer",
  "pin-project-lite",
  "rand 0.7.3",
@@ -1614,15 +1641,15 @@ checksum = "d897f394bad6a705d5f4104762e116a75639e470d80901eed05a860a95cb1904"
 
 [[package]]
 name = "httpdate"
-version = "1.0.2"
+version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4a1e36c821dbe04574f602848a19f742f4fb3c98d40449f11bcad18d6b17421"
+checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
 
 [[package]]
 name = "hyper"
-version = "0.14.25"
+version = "0.14.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cc5e554ff619822309ffd57d8734d77cd5ce6238bc956f037ea06c58238c9899"
+checksum = "bf96e135eb83a2a8ddf766e426a841d8ddd7449d5f00d34ea02b41d2f19eef80"
 dependencies = [
  "bytes",
  "futures-channel",
@@ -1635,7 +1662,7 @@ dependencies = [
  "httpdate",
  "itoa",
  "pin-project-lite",
- "socket2",
+ "socket2 0.5.5",
  "tokio",
  "tower-service",
  "tracing",
@@ -1644,9 +1671,9 @@ dependencies = [
 
 [[package]]
 name = "hyper-rustls"
-version = "0.24.1"
+version = "0.24.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8d78e1e73ec14cf7375674f74d7dde185c8206fd9dea6fb6295e8a98098aaa97"
+checksum = "ec3efd23720e2049821a693cbc7e65ea87c72f1c58ff2f9522ff332b1491e590"
 dependencies = [
  "futures-util",
  "http",
@@ -1658,33 +1685,32 @@ dependencies = [
 
 [[package]]
 name = "iana-time-zone"
-version = "0.1.53"
+version = "0.1.60"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64c122667b287044802d6ce17ee2ddf13207ed924c712de9a66a5814d5b64765"
+checksum = "e7ffbb5a1b541ea2561f8c41c087286cc091e21e556a4f09a8f6cbf17b69b141"
 dependencies = [
  "android_system_properties",
  "core-foundation-sys",
  "iana-time-zone-haiku",
  "js-sys",
  "wasm-bindgen",
- "winapi 0.3.9",
+ "windows-core",
 ]
 
 [[package]]
 name = "iana-time-zone-haiku"
-version = "0.1.1"
+version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0703ae284fc167426161c2e3f1da3ea71d94b21bedbcc9494e92b28e334e3dca"
+checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
 dependencies = [
- "cxx",
- "cxx-build",
+ "cc",
 ]
 
 [[package]]
 name = "idna"
-version = "0.3.0"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e14ddfc70884202db2244c223200c204c2bda1bc6e0998d11b5e024d657209e6"
+checksum = "634d9b1461af396cad843f47fdba5597a4f9e6ddd4bfb6ff5d85028c25cb12f6"
 dependencies = [
  "unicode-bidi",
  "unicode-normalization",
@@ -1712,22 +1738,12 @@ dependencies = [
 
 [[package]]
 name = "indexmap"
-version = "1.9.2"
+version = "2.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1885e79c1fc4b10f0e172c475f458b7f7b93061064d98c3293e98c5ba0c8b399"
-dependencies = [
- "autocfg",
- "hashbrown 0.12.3",
-]
-
-[[package]]
-name = "indexmap"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d5477fe2230a79769d8dc68e0eabf5437907c0457a5614a9e8dddb67f65eb65d"
+checksum = "233cf39063f058ea2caae4091bf4a3ef70a653afbc026f5c4a4135d114e3c177"
 dependencies = [
  "equivalent",
- "hashbrown 0.14.0",
+ "hashbrown 0.14.3",
 ]
 
 [[package]]
@@ -1742,7 +1758,7 @@ version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a0c10553d664a4d0bcff9f4215d0aac67a639cc68ef660840afe309b807bc9f5"
 dependencies = [
- "generic-array 0.14.6",
+ "generic-array 0.14.7",
 ]
 
 [[package]]
@@ -1769,7 +1785,7 @@ version = "1.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "eae7b9aee968036d54dce06cebaefd919e4472e753296daccd6d344e3e2df0c2"
 dependencies = [
- "hermit-abi 0.3.2",
+ "hermit-abi 0.3.6",
  "libc",
  "windows-sys 0.48.0",
 ]
@@ -1785,9 +1801,9 @@ dependencies = [
 
 [[package]]
 name = "ipnet"
-version = "2.7.1"
+version = "2.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "30e22bd8629359895450b59ea7a776c850561b96a3b1d31321c1949d9e6c9146"
+checksum = "8f518f335dce6725a761382244631d86cf0ccb2863413590b31338feb467f9c3"
 
 [[package]]
 name = "itertools"
@@ -1800,24 +1816,24 @@ dependencies = [
 
 [[package]]
 name = "itoa"
-version = "1.0.6"
+version = "1.0.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "453ad9f582a441959e5f0d088b02ce04cfe8d51a8eaf077f12ac6d3e94164ca6"
+checksum = "b1a46d1a171d865aa5f83f92695765caa047a9b4cbae2cbf37dbd613a793fd4c"
 
 [[package]]
 name = "js-sys"
-version = "0.3.61"
+version = "0.3.68"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "445dde2150c55e483f3d8416706b97ec8e8237c307e5b7b4b8dd15e6af2a0730"
+checksum = "406cda4b368d531c842222cf9d2600a9a4acce8d29423695379c6868a143a9ee"
 dependencies = [
  "wasm-bindgen",
 ]
 
 [[package]]
 name = "keccak"
-version = "0.1.3"
+version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3afef3b6eff9ce9d8ff9b3601125eec7f0c8cbac7abd14f355d053fa56c98768"
+checksum = "ecc2af9a1119c51f12a14607e783cb977bde58bc069ff0c3da1095e635d70654"
 dependencies = [
  "cpufeatures",
 ]
@@ -1849,15 +1865,15 @@ checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
 
 [[package]]
 name = "libc"
-version = "0.2.151"
+version = "0.2.153"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "302d7ab3130588088d277783b1e2d2e10c9e9e4a16dd9050e6ec93fb3e7048f4"
+checksum = "9c198f91728a82281a64e1f4f9eeb25d82cb32a5de251c6bd1b5154d63a8e7bd"
 
 [[package]]
 name = "libflate"
-version = "1.3.0"
+version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97822bf791bd4d5b403713886a5fbe8bf49520fe78e323b0dc480ca1a03e50b0"
+checksum = "5ff4ae71b685bbad2f2f391fe74f6b7659a34871c08b210fdc039e43bee07d18"
 dependencies = [
  "adler32",
  "crc32fast",
@@ -1873,12 +1889,23 @@ dependencies = [
  "rle-decode-fast",
 ]
 
+[[package]]
+name = "libredox"
+version = "0.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85c833ca1e66078851dba29046874e38f08b2c883700aa29a03ddd3b23814ee8"
+dependencies = [
+ "bitflags 2.4.2",
+ "libc",
+ "redox_syscall",
+]
+
 [[package]]
 name = "libsigner"
 version = "0.0.1"
 dependencies = [
  "clarity",
- "hashbrown 0.14.0",
+ "hashbrown 0.14.3",
  "libc",
  "libstackerdb",
  "rand 0.8.5",
@@ -1888,7 +1915,7 @@ dependencies = [
  "serde_derive",
  "serde_json",
  "serde_stacker",
- "sha2 0.10.6",
+ "sha2 0.10.8",
  "slog",
  "slog-json",
  "slog-term",
@@ -1919,24 +1946,21 @@ dependencies = [
  "serde",
  "serde_derive",
  "serde_stacker",
- "sha2 0.10.6",
+ "sha2 0.10.8",
  "stacks-common",
 ]
 
 [[package]]
-name = "link-cplusplus"
-version = "1.0.8"
+name = "linux-raw-sys"
+version = "0.3.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ecd207c9c713c34f95a097a5b029ac2ce6010530c7b49d7fea24d977dede04f5"
-dependencies = [
- "cc",
-]
+checksum = "ef53942eb7bf7ff43a617b3e2c1c4a5ecf5944a7c1bc12d7ee39bbb15e5c1519"
 
 [[package]]
 name = "linux-raw-sys"
-version = "0.3.8"
+version = "0.4.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ef53942eb7bf7ff43a617b3e2c1c4a5ecf5944a7c1bc12d7ee39bbb15e5c1519"
+checksum = "01cda141df6706de531b6c46c3a33ecca755538219bd484262fa09410c13539c"
 
 [[package]]
 name = "lock_api"
@@ -1950,11 +1974,10 @@ dependencies = [
 
 [[package]]
 name = "log"
-version = "0.4.17"
+version = "0.4.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "abb12e687cfb44aa40f41fc3978ef76448f9b6038cad6aef4259d3c095a2382e"
+checksum = "b5e6163cb8c49088c2c36f57875e58ccd8c87c7427f7fbd50ea6710b2f3f2e8f"
 dependencies = [
- "cfg-if 1.0.0",
  "value-bag",
 ]
 
@@ -1964,14 +1987,14 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8263075bb86c5a1b1427b5ae862e8889656f126e9f77c484496e8b47cf5c5558"
 dependencies = [
- "regex-automata",
+ "regex-automata 0.1.10",
 ]
 
 [[package]]
 name = "memchr"
-version = "2.5.0"
+version = "2.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
+checksum = "523dc4f511e55ab87b694dc30d0f820d60906ef06413f93d4d7a1385599cc149"
 
 [[package]]
 name = "memoffset"
@@ -1982,20 +2005,11 @@ dependencies = [
  "autocfg",
 ]
 
-[[package]]
-name = "memoffset"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d61c719bcfbcf5d62b3a09efa6088de8c54bc0bfcd3ea7ae39fcc186108b8de1"
-dependencies = [
- "autocfg",
-]
-
 [[package]]
 name = "mime"
-version = "0.3.16"
+version = "0.3.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a60c7ce501c71e03a9c9c0d35b861413ae925bd979cc7a4e30d060069aaac8d"
+checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
 
 [[package]]
 name = "mime_guess"
@@ -2009,9 +2023,9 @@ dependencies = [
 
 [[package]]
 name = "miniz_oxide"
-version = "0.6.2"
+version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b275950c28b37e794e8c55d88aeb5e139d0ce23fdbbeda68f8d7174abdf9e8fa"
+checksum = "9d811f3e15f28568be3407c8e7fdb6514c1cda3cb30683f15b6a1a1dc4ea14a7"
 dependencies = [
  "adler",
 ]
@@ -2037,14 +2051,13 @@ dependencies = [
 
 [[package]]
 name = "mio"
-version = "0.8.6"
+version = "0.8.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b9d9a46eff5b4ff64b45a9e316a6d1e0bc719ef429cbec4dc630684212bfdf9"
+checksum = "8f3d0b296e374a4e6f3c7b0a1f5a51d748a0d34c85e7dc48fc3fa9a87657fe09"
 dependencies = [
  "libc",
- "log",
  "wasi 0.11.0+wasi-snapshot-preview1",
- "windows-sys 0.45.0",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
@@ -2079,9 +2092,9 @@ dependencies = [
 
 [[package]]
 name = "net2"
-version = "0.2.38"
+version = "0.2.39"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "74d0df99cfcd2530b2e694f6e17e7f37b8e26bb23983ac530c0c97408837c631"
+checksum = "b13b648036a2339d06de780866fbdfda0dde886de7b3af2ddeba8b14f4ee34ac"
 dependencies = [
  "cfg-if 0.1.10",
  "libc",
@@ -2094,11 +2107,11 @@ version = "0.23.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8f3790c00a0150112de0f4cd161e3d7fc4b2d8a5542ffc35f099a2562aecb35c"
 dependencies = [
- "bitflags",
+ "bitflags 1.3.2",
  "cc",
  "cfg-if 1.0.0",
  "libc",
- "memoffset 0.6.5",
+ "memoffset",
 ]
 
 [[package]]
@@ -2112,31 +2125,27 @@ dependencies = [
 ]
 
 [[package]]
-name = "num-integer"
-version = "0.1.45"
+name = "num-conv"
+version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "225d3389fb3509a24c93f5c29eb6bde2586b98d9f016636dff58d7c6f7569cd9"
-dependencies = [
- "autocfg",
- "num-traits",
-]
+checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9"
 
 [[package]]
 name = "num-traits"
-version = "0.2.15"
+version = "0.2.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd"
+checksum = "da0df0e5185db44f69b44f26786fe401b6c293d1907744beaa7fa62b2e5a517a"
 dependencies = [
  "autocfg",
 ]
 
 [[package]]
 name = "num_cpus"
-version = "1.15.0"
+version = "1.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fac9e2da13b5eb447a6ce3d392f23a29d8694bff781bf03a16cd9ac8697593b"
+checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43"
 dependencies = [
- "hermit-abi 0.2.6",
+ "hermit-abi 0.3.6",
  "libc",
 ]
 
@@ -2151,18 +2160,18 @@ dependencies = [
 
 [[package]]
 name = "object"
-version = "0.30.3"
+version = "0.32.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ea86265d3d3dcb6a27fc51bd29a4bf387fae9d2986b823079d4986af253eb439"
+checksum = "a6a622008b6e321afc04970976f62ee297fdbaa6f95318ca343e3eebb9648441"
 dependencies = [
  "memchr",
 ]
 
 [[package]]
 name = "once_cell"
-version = "1.17.1"
+version = "1.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b7e5500299e16ebb147ae15a00a942af264cf3688f47923b8fc2cd5858f23ad3"
+checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
 
 [[package]]
 name = "oorandom"
@@ -2206,15 +2215,15 @@ dependencies = [
  "rand_core 0.6.4",
  "rustfmt-wrapper",
  "serde",
- "sha2 0.10.6",
- "syn 2.0.29",
+ "sha2 0.10.8",
+ "syn 2.0.48",
 ]
 
 [[package]]
 name = "parity-scale-codec"
-version = "3.5.0"
+version = "3.6.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ddb756ca205bd108aee3c62c6d3c994e1df84a59b9d6d4a5ea42ee1fd5a9a28"
+checksum = "881331e34fa842a2fb61cc2db9643a8fedc615e47cfcc52597d1af0db9a7e8fe"
 dependencies = [
  "arrayvec",
  "bitvec",
@@ -2226,9 +2235,9 @@ dependencies = [
 
 [[package]]
 name = "parity-scale-codec-derive"
-version = "3.1.4"
+version = "3.6.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86b26a931f824dd4eca30b3e43bb4f31cd5f0d3a403c5f5ff27106b805bfde7b"
+checksum = "be30eaf4b0a9fba5336683b38de57bb86d179a35862ba6bfcf57625d006bde5b"
 dependencies = [
  "proc-macro-crate",
  "proc-macro2",
@@ -2238,9 +2247,9 @@ dependencies = [
 
 [[package]]
 name = "parking"
-version = "2.0.0"
+version = "2.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "427c3892f9e783d91cc128285287e70a59e206ca452770ece88a76f7a3eddd72"
+checksum = "bb813b8af86854136c6922af0598d719255ecb2179515e6e7730d468f05c9cae"
 
 [[package]]
 name = "parking_lot"
@@ -2260,23 +2269,24 @@ checksum = "4c42a9226546d68acdd9c0a280d17ce19bfe27a46bf68784e4066115788d008e"
 dependencies = [
  "cfg-if 1.0.0",
  "libc",
- "redox_syscall 0.4.1",
+ "redox_syscall",
  "smallvec",
  "windows-targets 0.48.5",
 ]
 
 [[package]]
 name = "percent-encoding"
-version = "2.2.0"
+version = "2.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "478c572c3d73181ff3c2539045f6eb99e5491218eae919370993b890cdbdd98e"
+checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e"
 
 [[package]]
 name = "pest"
-version = "2.5.6"
+version = "2.7.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8cbd939b234e95d72bc393d51788aec68aeeb5d51e748ca08ff3aad58cb722f7"
+checksum = "219c0dcc30b6a27553f9cc242972b67f75b60eb0db71f0b5462f38b058c41546"
 dependencies = [
+ "memchr",
  "thiserror",
  "ucd-trie",
 ]
@@ -2289,29 +2299,29 @@ checksum = "5be167a7af36ee22fe3115051bc51f6e6c7054c9348e28deb4f49bd6f705a315"
 
 [[package]]
 name = "pin-project"
-version = "1.0.12"
+version = "1.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad29a609b6bcd67fee905812e544992d216af9d755757c05ed2d0e15a74c6ecc"
+checksum = "0302c4a0442c456bd56f841aee5c3bfd17967563f6fadc9ceb9f9c23cf3807e0"
 dependencies = [
  "pin-project-internal",
 ]
 
 [[package]]
 name = "pin-project-internal"
-version = "1.0.12"
+version = "1.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "069bdb1e05adc7a8990dce9cc75370895fbe4e3d58b9b73bf1aee56359344a55"
+checksum = "266c042b60c9c76b8d53061e52b2e0d1116abc57cefc8c5cd671619a56ac3690"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.48",
 ]
 
 [[package]]
 name = "pin-project-lite"
-version = "0.2.9"
+version = "0.2.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0a7ae3ac2f1173085d398531c705756c94a4c56843785df85a60c1a0afac116"
+checksum = "8afb450f006bf6385ca15ef45d71d2288452bc3683ce2e2cacc0d18e4be60b58"
 
 [[package]]
 name = "pin-utils"
@@ -2319,17 +2329,28 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
 
+[[package]]
+name = "piper"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "668d31b1c4eba19242f2088b2bf3316b82ca31082a8335764db4e083db7485d4"
+dependencies = [
+ "atomic-waker",
+ "fastrand 2.0.1",
+ "futures-io",
+]
+
 [[package]]
 name = "pkg-config"
-version = "0.3.26"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ac9a59f73473f1b8d852421e59e64809f025994837ef743615c6d0c5b305160"
+checksum = "d231b230927b5e4ad203db57bbcbee2802f6bce620b1e4a9024a07d94e2907ec"
 
 [[package]]
 name = "plotters"
-version = "0.3.4"
+version = "0.3.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2538b639e642295546c50fcd545198c9d64ee2a38620a628724a3b266d5fbf97"
+checksum = "d2c224ba00d7cadd4d5c660deaf2098e5e80e07846537c51f9cfa4be50c1fd45"
 dependencies = [
  "num-traits",
  "plotters-backend",
@@ -2340,40 +2361,54 @@ dependencies = [
 
 [[package]]
 name = "plotters-backend"
-version = "0.3.4"
+version = "0.3.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "193228616381fecdc1224c62e96946dfbc73ff4384fba576e052ff8c1bea8142"
+checksum = "9e76628b4d3a7581389a35d5b6e2139607ad7c75b17aed325f210aa91f4a9609"
 
 [[package]]
 name = "plotters-svg"
-version = "0.3.3"
+version = "0.3.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f9a81d2759aae1dae668f783c308bc5c8ebd191ff4184aaa1b37f65a6ae5a56f"
+checksum = "38f6d39893cca0701371e3c27294f09797214b86f1fb951b89ade8ec04e2abab"
 dependencies = [
  "plotters-backend",
 ]
 
 [[package]]
 name = "polling"
-version = "2.6.0"
+version = "2.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e1f879b2998099c2d69ab9605d145d5b661195627eccc680002c4918a7fb6fa"
+checksum = "4b2d323e8ca7996b3e23126511a523f7e62924d93ecd5ae73b333815b0eb3dce"
 dependencies = [
  "autocfg",
- "bitflags",
+ "bitflags 1.3.2",
  "cfg-if 1.0.0",
  "concurrent-queue",
  "libc",
  "log",
  "pin-project-lite",
- "windows-sys 0.45.0",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "polling"
+version = "3.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "30054e72317ab98eddd8561db0f6524df3367636884b7b21b703e4b280a84a14"
+dependencies = [
+ "cfg-if 1.0.0",
+ "concurrent-queue",
+ "pin-project-lite",
+ "rustix 0.38.31",
+ "tracing",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
 name = "polynomial"
-version = "0.2.5"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a461f75483c9faefe81bdc7257732be9afe9953765e406f8ede2581185d66635"
+checksum = "27abb6e4638dcecc65a92b50d7f1d87dd6dea987ba71db987b6bf881f4877e9d"
 dependencies = [
  "num-traits",
  "serde",
@@ -2387,7 +2422,7 @@ checksum = "eebcc4aa140b9abd2bc40d9c3f7ccec842679cd79045ac3a7ac698c1a064b7cd"
 dependencies = [
  "cpuid-bool",
  "opaque-debug 0.3.0",
- "universal-hash 0.4.1",
+ "universal-hash 0.4.0",
 ]
 
 [[package]]
@@ -2402,6 +2437,12 @@ dependencies = [
  "universal-hash 0.5.1",
 ]
 
+[[package]]
+name = "powerfmt"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
+
 [[package]]
 name = "pox-locking"
 version = "2.4.0"
@@ -2419,9 +2460,9 @@ checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
 
 [[package]]
 name = "primitive-types"
-version = "0.12.1"
+version = "0.12.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f3486ccba82358b11a77516035647c34ba167dfa53312630de83b12bd4f3d66"
+checksum = "0b34d9fd68ae0b74a41b21c03c2f62847aa0ffea044eee893b4c140b37e244e2"
 dependencies = [
  "fixed-hash",
  "impl-codec",
@@ -2430,12 +2471,11 @@ dependencies = [
 
 [[package]]
 name = "proc-macro-crate"
-version = "1.3.1"
+version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f4c021e1093a56626774e81216a4ce732a735e5bad4868a03f3ed65ca0c3919"
+checksum = "7e8366a6159044a37876a2b9817124296703c586a5c92e2c53751fa06d8d43e8"
 dependencies = [
- "once_cell",
- "toml_edit",
+ "toml_edit 0.20.7",
 ]
 
 [[package]]
@@ -2470,9 +2510,9 @@ checksum = "dc375e1527247fe1a97d8b7156678dfe7c1af2fc075c9a4db3690ecd2a148068"
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.67"
+version = "1.0.78"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d433d9f1a3e8c1263d9456598b16fec66f4acc9a74dacffd35c7bb09b3a1328"
+checksum = "e2422ad645d89c99f8f3e6b88a9fdeca7fabeac836b1002371c4367c8f984aae"
 dependencies = [
  "unicode-ident",
 ]
@@ -2508,9 +2548,9 @@ dependencies = [
 
 [[package]]
 name = "quote"
-version = "1.0.33"
+version = "1.0.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5267fca4496028628a95160fc423a33e8b2e6af8a5302579e322e4b520293cae"
+checksum = "291ec9ab5efd934aaf503a6466c5d5251535d108ee747472c3977cc5acc868ef"
 dependencies = [
  "proc-macro2",
 ]
@@ -2580,7 +2620,7 @@ version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
 dependencies = [
- "getrandom 0.2.8",
+ "getrandom 0.2.12",
 ]
 
 [[package]]
@@ -2589,47 +2629,27 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ca3129af7b92a17112d59ad498c6f81eaf463253766b90396d39ea7a39d6613c"
 dependencies = [
- "rand_core 0.5.1",
-]
-
-[[package]]
-name = "rayon"
-version = "1.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d2df5196e37bcc87abebc0053e20787d73847bb33134a69841207dd0a47f03b"
-dependencies = [
- "either",
- "rayon-core",
-]
-
-[[package]]
-name = "rayon-core"
-version = "1.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b8f95bd6966f5c87776639160a66bd8ab9895d9d4ab01ddba9fc60661aebe8d"
-dependencies = [
- "crossbeam-channel",
- "crossbeam-deque",
- "crossbeam-utils",
- "num_cpus",
+ "rand_core 0.5.1",
 ]
 
 [[package]]
-name = "redox_syscall"
-version = "0.2.16"
+name = "rayon"
+version = "1.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fb5a58c1855b4b6819d59012155603f0b22ad30cad752600aadfcb695265519a"
+checksum = "fa7237101a77a10773db45d62004a272517633fbcc3df19d96455ede1122e051"
 dependencies = [
- "bitflags",
+ "either",
+ "rayon-core",
 ]
 
 [[package]]
-name = "redox_syscall"
-version = "0.3.5"
+name = "rayon-core"
+version = "1.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "567664f262709473930a4bf9e51bf2ebf3348f2e748ccc50dea20646858f8f29"
+checksum = "1465873a3dfdaa8ae7cb14b4383657caab0b3e8a0aa9ae8e04b044854c8dfce2"
 dependencies = [
- "bitflags",
+ "crossbeam-deque",
+ "crossbeam-utils",
 ]
 
 [[package]]
@@ -2638,29 +2658,30 @@ version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa"
 dependencies = [
- "bitflags",
+ "bitflags 1.3.2",
 ]
 
 [[package]]
 name = "redox_users"
-version = "0.4.3"
+version = "0.4.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b033d837a7cf162d7993aded9304e30a83213c648b6e389db233191f891e5c2b"
+checksum = "a18479200779601e498ada4e8c1e1f50e3ee19deb0259c25825a98b5603b2cb4"
 dependencies = [
- "getrandom 0.2.8",
- "redox_syscall 0.2.16",
+ "getrandom 0.2.12",
+ "libredox",
  "thiserror",
 ]
 
 [[package]]
 name = "regex"
-version = "1.7.1"
+version = "1.10.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48aaa5748ba571fb95cd2c85c09f629215d3a6ece942baa100950af03a34f733"
+checksum = "b62dbe01f0b06f9d8dc7d49e05a0785f153b00b2c227856282f671e0318c9b15"
 dependencies = [
  "aho-corasick",
  "memchr",
- "regex-syntax",
+ "regex-automata 0.4.5",
+ "regex-syntax 0.8.2",
 ]
 
 [[package]]
@@ -2669,14 +2690,31 @@ version = "0.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132"
 dependencies = [
- "regex-syntax",
+ "regex-syntax 0.6.29",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5bb987efffd3c6d0d8f5f89510bb458559eab11e4f869acb20bf845e016259cd"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax 0.8.2",
 ]
 
 [[package]]
 name = "regex-syntax"
-version = "0.6.28"
+version = "0.6.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1"
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "456c603be3e8d448b072f410900c09faf164fbce2d480456f50eea6e25f9c848"
+checksum = "c08c74e62047bb2de4ff487b251e4a92e24f48745648451635cec7d591162d9f"
 
 [[package]]
 name = "relay-server"
@@ -2684,11 +2722,11 @@ version = "0.0.1"
 
 [[package]]
 name = "reqwest"
-version = "0.11.22"
+version = "0.11.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "046cd98826c46c2ac8ddecae268eb5c2e58628688a5fc7a2643704a73faba95b"
+checksum = "c6920094eb85afde5e4a138be3f2de8bbdf28000f0029e72c45025a56b042251"
 dependencies = [
- "base64 0.21.0",
+ "base64 0.21.7",
  "bytes",
  "encoding_rs",
  "futures-core",
@@ -2710,6 +2748,7 @@ dependencies = [
  "serde",
  "serde_json",
  "serde_urlencoded",
+ "sync_wrapper",
  "system-configuration",
  "tokio",
  "tokio-rustls",
@@ -2732,18 +2771,32 @@ dependencies = [
  "libc",
  "once_cell",
  "spin 0.5.2",
- "untrusted",
+ "untrusted 0.7.1",
  "web-sys",
  "winapi 0.3.9",
 ]
 
+[[package]]
+name = "ring"
+version = "0.17.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "688c63d65483050968b2a8937f7995f443e27041a0f7700aa59b0822aedebb74"
+dependencies = [
+ "cc",
+ "getrandom 0.2.12",
+ "libc",
+ "spin 0.9.8",
+ "untrusted 0.9.0",
+ "windows-sys 0.48.0",
+]
+
 [[package]]
 name = "ripemd"
 version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bd124222d17ad93a644ed9d011a40f4fb64aa54275c08cc216524a9ea82fb09f"
 dependencies = [
- "digest 0.10.6",
+ "digest 0.10.7",
 ]
 
 [[package]]
@@ -2820,7 +2873,7 @@ version = "0.24.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d5f38ee71cbab2c827ec0ac24e76f82eca723cee92c509a65f67dee393c25112"
 dependencies = [
- "bitflags",
+ "bitflags 1.3.2",
  "byteorder",
  "fallible-iterator",
  "fallible-streaming-iterator",
@@ -2833,9 +2886,9 @@ dependencies = [
 
 [[package]]
 name = "rustc-demangle"
-version = "0.1.21"
+version = "0.1.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ef03e0a2b150c7a90d01faf6254c9c48a41e95fb2a8c2ac1c6f0d2b9aefc342"
+checksum = "d626bb9dae77e28219937af045c257c28bfd3f69333c512553507f5f9798cb76"
 
 [[package]]
 name = "rustc-hex"
@@ -2867,78 +2920,91 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366"
 dependencies = [
- "semver 1.0.17",
+ "semver 1.0.21",
 ]
 
 [[package]]
 name = "rustfmt-wrapper"
-version = "0.2.0"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed729e3bee08ec2befd593c27e90ca9fdd25efdc83c94c3b82eaef16e4f7406e"
+checksum = "f1adc9dfed5cc999077978cc7163b9282c5751c8d39827c4ea8c8c220ca5a440"
 dependencies = [
  "serde",
  "tempfile",
  "thiserror",
- "toml",
+ "toml 0.8.10",
  "toolchain_find",
 ]
 
 [[package]]
 name = "rustix"
-version = "0.37.7"
+version = "0.37.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2aae838e49b3d63e9274e1c01833cc8139d3fec468c3b84688c628f44b1ae11d"
+checksum = "fea8ca367a3a01fe35e6943c400addf443c0f57670e6ec51196f71a4b8762dd2"
 dependencies = [
- "bitflags",
+ "bitflags 1.3.2",
  "errno",
  "io-lifetimes",
  "libc",
- "linux-raw-sys",
- "windows-sys 0.45.0",
+ "linux-raw-sys 0.3.8",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "rustix"
+version = "0.38.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ea3e1a662af26cd7a3ba09c0297a31af215563ecf42817c98df621387f4e949"
+dependencies = [
+ "bitflags 2.4.2",
+ "errno",
+ "libc",
+ "linux-raw-sys 0.4.13",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
 name = "rustls"
-version = "0.21.7"
+version = "0.21.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd8d6c9f025a446bc4d18ad9632e69aec8f287aa84499ee335599fabd20c3fd8"
+checksum = "f9d5a6813c0759e4609cd494e8e725babae6a2ca7b62a5536a13daaec6fcb7ba"
 dependencies = [
  "log",
- "ring",
+ "ring 0.17.7",
  "rustls-webpki",
  "sct",
 ]
 
 [[package]]
 name = "rustls-pemfile"
-version = "1.0.2"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d194b56d58803a43635bdc398cd17e383d6f71f9182b9a192c127ca42494a59b"
+checksum = "1c74cae0a4cf6ccbbf5f359f08efdf8ee7e1dc532573bf0db71968cb56b1448c"
 dependencies = [
- "base64 0.21.0",
+ "base64 0.21.7",
 ]
 
 [[package]]
 name = "rustls-webpki"
-version = "0.101.4"
+version = "0.101.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d93931baf2d282fff8d3a532bbfd7653f734643161b87e3e01e59a04439bf0d"
+checksum = "8b6275d1ee7a1cd780b64aca7726599a1dbc893b1e64144529e55c3c2f745765"
 dependencies = [
- "ring",
- "untrusted",
+ "ring 0.17.7",
+ "untrusted 0.9.0",
 ]
 
 [[package]]
 name = "rustversion"
-version = "1.0.12"
+version = "1.0.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4f3208ce4d8448b3f3e7d168a73f5e0c43a61e32930de3bceeccedb388b6bf06"
+checksum = "7ffc183a10b4478d04cbbbfc96d0873219d962dd5accaff2ffbd4ceb7df837f4"
 
 [[package]]
 name = "ryu"
-version = "1.0.13"
+version = "1.0.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f91339c0467de62360649f8d3e185ca8de4224ff281f66000de5eb2a77a79041"
+checksum = "f98d2aa92eebf49b69786be48e4477826b256916e84a57ff2a4f21923b48eb4c"
 
 [[package]]
 name = "same-file"
@@ -2957,24 +3023,18 @@ checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294"
 
 [[package]]
 name = "scopeguard"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
-
-[[package]]
-name = "scratch"
-version = "1.0.5"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1792db035ce95be60c3f8853017b3999209281c24e2ba5bc8e59bf97a0c590c1"
+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
 
 [[package]]
 name = "sct"
-version = "0.7.0"
+version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d53dcdb7c9f8158937a7981b48accfd39a43af418591a5d008c7b22b5e1b7ca4"
+checksum = "da046153aa2352493d6cb7da4b6e5c0c057d8a1d0a9aa8560baffdd945acd414"
 dependencies = [
- "ring",
- "untrusted",
+ "ring 0.17.7",
+ "untrusted 0.9.0",
 ]
 
 [[package]]
@@ -3016,9 +3076,9 @@ dependencies = [
 
 [[package]]
 name = "semver"
-version = "1.0.17"
+version = "1.0.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bebd363326d05ec3e2f532ab7660680f3b02130d780c299bca73469d521bc0ed"
+checksum = "b97ed7a9823b74f99c7742f5336af7be5ecd3eeafcb1507d1fa93347b1d589b0"
 
 [[package]]
 name = "semver-parser"
@@ -3037,9 +3097,9 @@ dependencies = [
 
 [[package]]
 name = "serde"
-version = "1.0.156"
+version = "1.0.196"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "314b5b092c0ade17c00142951e50ced110ec27cea304b1037c6969246c2469a4"
+checksum = "870026e60fa08c69f064aa766c10f10b1d62db9ccd4d0abb206472bee0ce3b32"
 dependencies = [
  "serde_derive",
 ]
@@ -3056,20 +3116,20 @@ dependencies = [
 
 [[package]]
 name = "serde_derive"
-version = "1.0.156"
+version = "1.0.196"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7e29c4601e36bcec74a223228dce795f4cd3616341a4af93520ca1a837c087d"
+checksum = "33c85360c95e7d137454dc81d9a4ed2b8efd8fbe19cee57357b32b9771fccb67"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.48",
 ]
 
 [[package]]
 name = "serde_json"
-version = "1.0.94"
+version = "1.0.113"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c533a59c9d8a93a09c6ab31f0fd5e5f4dd1b8fc9434804029839884765d04ea"
+checksum = "69801b70b1c3dac963ecb03a364ba0ceda9cf60c71cfe475e99864759c8b8a79"
 dependencies = [
  "itoa",
  "ryu",
@@ -3087,11 +3147,20 @@ dependencies = [
  "thiserror",
 ]
 
+[[package]]
+name = "serde_spanned"
+version = "0.6.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eb3622f419d1296904700073ea6cc23ad690adbd66f13ea683df73298736f0c1"
+dependencies = [
+ "serde",
+]
+
 [[package]]
 name = "serde_stacker"
-version = "0.1.8"
+version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f5557f4c1103cecd0e639a17ab22d670b89912d8a506589ee627bf738a15a5d"
+checksum = "babfccff5773ff80657f0ecf553c7c516bdc2eb16389c0918b36b73e7015276e"
 dependencies = [
  "serde",
  "stacker",
@@ -3131,7 +3200,7 @@ checksum = "b93fb4adc70021ac1b47f7d45e8cc4169baaa7ea58483bc5b721d19a26202212"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.29",
+ "syn 2.0.48",
 ]
 
 [[package]]
@@ -3145,13 +3214,13 @@ dependencies = [
 
 [[package]]
 name = "sha1"
-version = "0.10.5"
+version = "0.10.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f04293dc80c3993519f2d7f6f511707ee7094fe0c6d3406feb330cdb3540eba3"
+checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba"
 dependencies = [
  "cfg-if 1.0.0",
  "cpufeatures",
- "digest 0.10.6",
+ "digest 0.10.7",
 ]
 
 [[package]]
@@ -3187,14 +3256,14 @@ dependencies = [
 
 [[package]]
 name = "sha2"
-version = "0.10.6"
+version = "0.10.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "82e6b795fe2e3b1e845bafcb27aa35405c4d47cdfc92af5fc8d3002f76cebdc0"
+checksum = "793db75ad2bcafc3ffa7c68b215fee268f537982cd901d132f89c6343f3a3dc8"
 dependencies = [
  "cfg-if 1.0.0",
  "cpufeatures",
- "digest 0.10.6",
- "sha2-asm 0.6.2",
+ "digest 0.10.7",
+ "sha2-asm 0.6.3",
 ]
 
 [[package]]
@@ -3208,52 +3277,43 @@ dependencies = [
 
 [[package]]
 name = "sha2-asm"
-version = "0.6.2"
+version = "0.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf27176fb5d15398e3a479c652c20459d9dac830dedd1fa55b42a77dbcdbfcea"
+checksum = "f27ba7066011e3fb30d808b51affff34f0a66d3a03a58edd787c6e420e40e44e"
 dependencies = [
  "cc",
 ]
 
 [[package]]
 name = "sha3"
-version = "0.10.6"
+version = "0.10.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bdf0c33fae925bdc080598b84bc15c55e7b9a4a43b3c704da051f977469691c9"
+checksum = "75872d278a8f37ef87fa0ddbda7802605cb18344497949862c0d4dcb291eba60"
 dependencies = [
- "digest 0.10.6",
+ "digest 0.10.7",
  "keccak",
 ]
 
 [[package]]
 name = "sharded-slab"
-version = "0.1.6"
+version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1b21f559e07218024e7e9f90f96f601825397de0e25420135f7f952453fed0b"
+checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6"
 dependencies = [
  "lazy_static",
 ]
 
-[[package]]
-name = "simple-mutex"
-version = "1.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38aabbeafa6f6dead8cebf246fe9fae1f9215c8d29b3a69f93bd62a9e4a3dcd6"
-dependencies = [
- "event-listener",
-]
-
 [[package]]
 name = "siphasher"
-version = "0.3.10"
+version = "0.3.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7bd3e3206899af3f8b12af284fafc038cc1dc2b41d1b89dd17297221c5d225de"
+checksum = "38b58827f4464d87d377d175e90bf58eb00fd8716ff0a62f80356b5e61555d0d"
 
 [[package]]
 name = "slab"
-version = "0.4.8"
+version = "0.4.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6528351c9bc8ab22353f9d776db39a20288e8d6c37ef8cfe3317cf875eecfc2d"
+checksum = "8f92a496fb766b417c996b9c5e57daf2f7ad3b0bebe1ccfca4856390e3d3bb67"
 dependencies = [
  "autocfg",
 ]
@@ -3273,7 +3333,7 @@ dependencies = [
  "serde",
  "serde_json",
  "slog",
- "time 0.3.20",
+ "time 0.3.34",
 ]
 
 [[package]]
@@ -3286,25 +3346,35 @@ dependencies = [
  "slog",
  "term",
  "thread_local",
- "time 0.3.20",
+ "time 0.3.34",
 ]
 
 [[package]]
 name = "smallvec"
-version = "1.10.0"
+version = "1.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a507befe795404456341dfab10cef66ead4c041f62b8b11bbb92bffe5d0953e0"
+checksum = "e6ecd384b10a64542d77071bd64bd7b231f4ed5940fba55e98c3de13824cf3d7"
 
 [[package]]
 name = "socket2"
-version = "0.4.9"
+version = "0.4.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64a4a911eed85daf18834cfaa86a79b7d266ff93ff5ba14005426219480ed662"
+checksum = "9f7916fc008ca5542385b89a3d3ce689953c143e9304a9bf8beec1de48994c0d"
 dependencies = [
  "libc",
  "winapi 0.3.9",
 ]
 
+[[package]]
+name = "socket2"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b5fac59a5cb5dd637972e5fca70daf0523c9067fcdc4842f053dae04a18f8e9"
+dependencies = [
+ "libc",
+ "windows-sys 0.48.0",
+]
+
 [[package]]
 name = "spin"
 version = "0.5.2"
@@ -3353,7 +3423,7 @@ dependencies = [
  "serde_derive",
  "serde_json",
  "serde_stacker",
- "sha2 0.10.6",
+ "sha2 0.10.8",
  "sha3",
  "slog",
  "slog-json",
@@ -3373,7 +3443,7 @@ dependencies = [
  "base64 0.12.3",
  "chrono",
  "clarity",
- "hashbrown 0.14.0",
+ "hashbrown 0.14.3",
  "http-types",
  "lazy_static",
  "libc",
@@ -3383,7 +3453,7 @@ dependencies = [
  "rand_core 0.6.4",
  "regex",
  "reqwest",
- "ring",
+ "ring 0.16.20",
  "rusqlite",
  "serde",
  "serde_derive",
@@ -3394,7 +3464,7 @@ dependencies = [
  "stackslib",
  "stx-genesis",
  "tokio",
- "toml",
+ "toml 0.5.11",
  "tracing",
  "tracing-subscriber",
  "warp",
@@ -3406,9 +3476,9 @@ name = "stacks-signer"
 version = "0.0.1"
 dependencies = [
  "backoff",
- "clap 4.4.1",
+ "clap 4.5.0",
  "clarity",
- "hashbrown 0.14.0",
+ "hashbrown 0.14.3",
  "libsigner",
  "libstackerdb",
  "rand 0.8.5",
@@ -3426,7 +3496,7 @@ dependencies = [
  "stacks-common",
  "stackslib",
  "thiserror",
- "toml",
+ "toml 0.5.11",
  "tracing",
  "tracing-subscriber",
  "wsts",
@@ -3442,7 +3512,7 @@ dependencies = [
  "criterion",
  "curve25519-dalek",
  "ed25519-dalek",
- "hashbrown 0.14.0",
+ "hashbrown 0.14.3",
  "integer-sqrt",
  "lazy_static",
  "libc",
@@ -3452,8 +3522,8 @@ dependencies = [
  "percent-encoding",
  "pox-locking",
  "prometheus",
- "rand 0.7.3",
- "rand_chacha 0.2.2",
+ "rand 0.8.5",
+ "rand_chacha 0.3.1",
  "rand_core 0.6.4",
  "regex",
  "ripemd",
@@ -3465,7 +3535,7 @@ dependencies = [
  "serde_derive",
  "serde_json",
  "serde_stacker",
- "sha2 0.10.6",
+ "sha2 0.10.8",
  "sha3",
  "siphasher",
  "slog",
@@ -3497,9 +3567,9 @@ checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 
 [[package]]
 name = "stdext"
-version = "0.3.1"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f3b6b32ae82412fb897ef134867d53a294f57ba5b758f06d71e865352c3e207"
+checksum = "6012f6ef4d674ce7021a8b0f5093f7e339f54d4ba04fc1f9c901659459b4f35b"
 
 [[package]]
 name = "stdweb"
@@ -3552,23 +3622,23 @@ checksum = "213701ba3370744dcd1a12960caa4843b3d68b4d1c0a5d575e0d65b2ee9d16c0"
 
 [[package]]
 name = "strsim"
-version = "0.10.0"
+version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
+checksum = "5ee073c9e4cd00e28217186dbe12796d692868f432bf2e97ee73bed0c56dfa01"
 
 [[package]]
 name = "stx-genesis"
 version = "0.1.0"
 dependencies = [
  "libflate",
- "sha2 0.10.6",
+ "sha2 0.10.8",
 ]
 
 [[package]]
 name = "subtle"
-version = "2.4.1"
+version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6bdef32e8150c2a081110b42772ffe7d7c9032b606bc226c8260fd97e0976601"
+checksum = "81cdd64d312baedb58e21336b31bc043b77e01cc99033ce76ef539f78e965ebc"
 
 [[package]]
 name = "syn"
@@ -3583,22 +3653,28 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.29"
+version = "2.0.48"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c324c494eba9d92503e6f1ef2e6df781e78f6a7705a0202d9801b198807d518a"
+checksum = "0f3531638e407dfc0814761abb7c00a5b54992b849452a0646b7f65c9f770f3f"
 dependencies = [
  "proc-macro2",
  "quote",
  "unicode-ident",
 ]
 
+[[package]]
+name = "sync_wrapper"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2047c6ded9c721764247e62cd3b03c09ffc529b2ba5b10ec482ae507a4a70160"
+
 [[package]]
 name = "system-configuration"
 version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ba3a3adc5c275d719af8cb4272ea1c4a6d668a777f37e115f6d11ddbc1c8e0e7"
 dependencies = [
- "bitflags",
+ "bitflags 1.3.2",
  "core-foundation",
  "system-configuration-sys",
 ]
@@ -3621,15 +3697,14 @@ checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
 
 [[package]]
 name = "tempfile"
-version = "3.5.0"
+version = "3.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b9fbec84f381d5795b08656e4912bec604d162bff9291d6189a78f4c8ab87998"
+checksum = "a365e8cd18e44762ef95d87f284f4b5cd04107fec2ff3052bd6a3e6069669e67"
 dependencies = [
  "cfg-if 1.0.0",
- "fastrand",
- "redox_syscall 0.3.5",
- "rustix",
- "windows-sys 0.45.0",
+ "fastrand 2.0.1",
+ "rustix 0.38.31",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -3643,15 +3718,6 @@ dependencies = [
  "winapi 0.3.9",
 ]
 
-[[package]]
-name = "termcolor"
-version = "1.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "be55cf8942feac5c765c2c993422806843c9a9a45d4d5c407ad6dd2ea95eb9b6"
-dependencies = [
- "winapi-util",
-]
-
 [[package]]
 name = "textwrap"
 version = "0.11.0"
@@ -3663,22 +3729,22 @@ dependencies = [
 
 [[package]]
 name = "thiserror"
-version = "1.0.39"
+version = "1.0.57"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5ab016db510546d856297882807df8da66a16fb8c4101cb8b30054b0d5b2d9c"
+checksum = "1e45bcbe8ed29775f228095caf2cd67af7a4ccf756ebff23a306bf3e8b47b24b"
 dependencies = [
  "thiserror-impl",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "1.0.39"
+version = "1.0.57"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5420d42e90af0c38c3290abcca25b9b3bdf379fc9f55c528f53a269d9c9a267e"
+checksum = "a953cb265bef375dae3de6663da4d3804eee9682ea80d8e2542529b73c531c81"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.48",
 ]
 
 [[package]]
@@ -3691,17 +3757,6 @@ dependencies = [
  "once_cell",
 ]
 
-[[package]]
-name = "time"
-version = "0.1.45"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b797afad3f312d1c66a56d11d0316f916356d11bd158fbc6ca6389ff6bf805a"
-dependencies = [
- "libc",
- "wasi 0.10.0+wasi-snapshot-preview1",
- "winapi 0.3.9",
-]
-
 [[package]]
 name = "time"
 version = "0.2.27"
@@ -3719,23 +3774,26 @@ dependencies = [
 
 [[package]]
 name = "time"
-version = "0.3.20"
+version = "0.3.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd0cbfecb4d19b5ea75bb31ad904eb5b9fa13f21079c3b92017ebdf4999a5890"
+checksum = "c8248b6521bb14bc45b4067159b9b6ad792e2d6d754d6c41fb50e29fefe38749"
 dependencies = [
+ "deranged",
  "itoa",
  "libc",
+ "num-conv",
  "num_threads",
+ "powerfmt",
  "serde",
  "time-core",
- "time-macros 0.2.8",
+ "time-macros 0.2.17",
 ]
 
 [[package]]
 name = "time-core"
-version = "0.1.0"
+version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2e153e1f1acaef8acc537e68b44906d2db6436e2b35ac2c6b42640fff91f00fd"
+checksum = "ef927ca75afb808a4d64dd374f00a2adf8d0fcff8e7b184af886c3c87ec4a3f3"
 
 [[package]]
 name = "time-macros"
@@ -3749,10 +3807,11 @@ dependencies = [
 
 [[package]]
 name = "time-macros"
-version = "0.2.8"
+version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fd80a657e71da814b8e5d60d3374fc6d35045062245d80224748ae522dd76f36"
+checksum = "7ba3a3ef41e6672a2f0f001392bb5dcd3ff0a9992d618ca761a11c3121547774"
 dependencies = [
+ "num-conv",
  "time-core",
 ]
 
@@ -3808,19 +3867,18 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
 
 [[package]]
 name = "tokio"
-version = "1.26.0"
+version = "1.36.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "03201d01c3c27a29c8a5cee5b55a93ddae1ccf6f08f65365c2c918f8c1b76f64"
+checksum = "61285f6515fa018fb2d1e46eb21223fff441ee8db5d0f1435e8ab4f5cdb80931"
 dependencies = [
- "autocfg",
+ "backtrace",
  "bytes",
  "libc",
- "memchr",
- "mio 0.8.6",
+ "mio 0.8.10",
  "num_cpus",
  "pin-project-lite",
- "socket2",
- "windows-sys 0.45.0",
+ "socket2 0.5.5",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
@@ -3835,9 +3893,9 @@ dependencies = [
 
 [[package]]
 name = "tokio-stream"
-version = "0.1.12"
+version = "0.1.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8fb52b74f05dbf495a8fba459fdc331812b96aa086d9eb78101fa0d4569c3313"
+checksum = "397c988d37662c7dda6d2208364a706264bf3d6138b11d436cbac0ad38832842"
 dependencies = [
  "futures-core",
  "pin-project-lite",
@@ -3846,9 +3904,9 @@ dependencies = [
 
 [[package]]
 name = "tokio-tungstenite"
-version = "0.18.0"
+version = "0.20.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "54319c93411147bced34cb5609a80e0a8e44c5999c93903a81cd866630ec0bfd"
+checksum = "212d5dcb2a1ce06d81107c3d0ffa3121fe974b73f068c8282cb1c32328113b6c"
 dependencies = [
  "futures-util",
  "log",
@@ -3858,9 +3916,9 @@ dependencies = [
 
 [[package]]
 name = "tokio-util"
-version = "0.7.7"
+version = "0.7.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5427d89453009325de0d8f342c9490009f76e999cb7672d77e46267448f7e6b2"
+checksum = "5419f34732d9eb6ee4c3578b7989078579b7f039cbbb9ca2c4da015749371e15"
 dependencies = [
  "bytes",
  "futures-core",
@@ -3879,33 +3937,61 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "toml"
+version = "0.8.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a9aad4a3066010876e8dcf5a8a06e70a558751117a145c6ce2b82c2e2054290"
+dependencies = [
+ "serde",
+ "serde_spanned",
+ "toml_datetime",
+ "toml_edit 0.22.5",
+]
+
 [[package]]
 name = "toml_datetime"
-version = "0.6.3"
+version = "0.6.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7cda73e2f1397b1262d6dfdcef8aafae14d1de7748d66822d3bfeeb6d03e5e4b"
+checksum = "3550f4e9685620ac18a50ed434eb3aec30db8ba93b0287467bca5826ea25baf1"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "toml_edit"
+version = "0.20.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70f427fce4d84c72b5b732388bf4a9f4531b53f74e2887e3ecb2481f68f66d81"
+dependencies = [
+ "indexmap",
+ "toml_datetime",
+ "winnow 0.5.40",
+]
 
 [[package]]
 name = "toml_edit"
-version = "0.19.14"
+version = "0.22.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8123f27e969974a3dfba720fdb560be359f57b44302d280ba72e76a74480e8a"
+checksum = "99e68c159e8f5ba8a28c4eb7b0c0c190d77bb479047ca713270048145a9ad28a"
 dependencies = [
- "indexmap 2.0.0",
+ "indexmap",
+ "serde",
+ "serde_spanned",
  "toml_datetime",
- "winnow",
+ "winnow 0.6.1",
 ]
 
 [[package]]
 name = "toolchain_find"
-version = "0.2.0"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e85654a10e7a07a47c6f19d93818f3f343e22927f2fa280c84f7c8042743413"
+checksum = "ebc8c9a7f0a2966e1acdaf0461023d0b01471eeead645370cf4c3f5cff153f2a"
 dependencies = [
  "home",
- "lazy_static",
+ "once_cell",
  "regex",
- "semver 0.11.0",
+ "semver 1.0.21",
  "walkdir",
 ]
 
@@ -3917,11 +4003,10 @@ checksum = "b6bc1c9ce2b5135ac7f93c72918fc37feb872bdc6a5533a8b85eb4b86bfdae52"
 
 [[package]]
 name = "tracing"
-version = "0.1.37"
+version = "0.1.40"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ce8c33a8d48bd45d624a6e523445fd21ec13d3653cd51f681abf67418f54eb8"
+checksum = "c3523ab5a71916ccf420eebdf5521fcef02141234bbc0b8a49f2fdc4544364ef"
 dependencies = [
- "cfg-if 1.0.0",
  "log",
  "pin-project-lite",
  "tracing-attributes",
@@ -3930,20 +4015,20 @@ dependencies = [
 
 [[package]]
 name = "tracing-attributes"
-version = "0.1.26"
+version = "0.1.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f4f31f56159e98206da9efd823404b79b6ef3143b4a7ab76e67b1751b25a4ab"
+checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.29",
+ "syn 2.0.48",
 ]
 
 [[package]]
 name = "tracing-core"
-version = "0.1.30"
+version = "0.1.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24eb03ba0eab1fd845050058ce5e616558e8f8d8fca633e6b163fe25c797213a"
+checksum = "c06d3da6113f116aaee68e4d601191614c9053067f9ab7f6edbcb161237daa54"
 dependencies = [
  "once_cell",
  "valuable",
@@ -3951,20 +4036,20 @@ dependencies = [
 
 [[package]]
 name = "tracing-log"
-version = "0.1.3"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78ddad33d2d10b1ed7eb9d1f518a5674713876e97e5bb9b7345a7984fbb4f922"
+checksum = "ee855f1f400bd0e5c02d150ae5de3840039a3f54b025156404e34c23c03f47c3"
 dependencies = [
- "lazy_static",
  "log",
+ "once_cell",
  "tracing-core",
 ]
 
 [[package]]
 name = "tracing-subscriber"
-version = "0.3.17"
+version = "0.3.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "30a651bc37f915e81f087d86e62a18eec5f79550c7faff886f7090b4ea757c77"
+checksum = "ad0f048c97dbd9faa9b7df56362b8ebcaa52adb06b498c050d2f4e32f90a7a8b"
 dependencies = [
  "matchers",
  "nu-ansi-term",
@@ -3980,24 +4065,24 @@ dependencies = [
 
 [[package]]
 name = "try-lock"
-version = "0.2.4"
+version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3528ecfd12c466c6f163363caf2d02a71161dd5e1cc6ae7b34207ea2d42d81ed"
+checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
 
 [[package]]
 name = "tungstenite"
-version = "0.18.0"
+version = "0.20.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "30ee6ab729cd4cf0fd55218530c4522ed30b7b6081752839b68fcec8d0960788"
+checksum = "9e3dac10fd62eaf6617d3a904ae222845979aec67c615d1c842b4002c7666fb9"
 dependencies = [
- "base64 0.13.1",
  "byteorder",
  "bytes",
+ "data-encoding",
  "http",
  "httparse",
  "log",
  "rand 0.8.5",
- "sha1 0.10.5",
+ "sha1 0.10.6",
  "thiserror",
  "url",
  "utf-8",
@@ -4005,15 +4090,15 @@ dependencies = [
 
 [[package]]
 name = "typenum"
-version = "1.16.0"
+version = "1.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "497961ef93d974e23eb6f433eb5fe1b7930b659f06d12dec6fc44a8f554c0bba"
+checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"
 
 [[package]]
 name = "ucd-trie"
-version = "0.1.5"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e79c4d996edb816c91e4308506774452e55e95c3c9de07b6729e17e15a5ef81"
+checksum = "ed646292ffc8188ef8ea4d1e0e0150fb15a5c2e12ad9b8fc191ae7a8a7f3c4b9"
 
 [[package]]
 name = "uint"
@@ -4029,24 +4114,24 @@ dependencies = [
 
 [[package]]
 name = "unicase"
-version = "2.6.0"
+version = "2.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50f37be617794602aabbeee0be4f259dc1778fabe05e2d67ee8f79326d5cb4f6"
+checksum = "f7d2d4dafb69621809a81864c9c1b864479e1235c0dd4e199924b9742439ed89"
 dependencies = [
  "version_check",
 ]
 
 [[package]]
 name = "unicode-bidi"
-version = "0.3.11"
+version = "0.3.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "524b68aca1d05e03fdf03fcdce2c6c94b6daf6d16861ddaa7e4f2b6638a9052c"
+checksum = "08f95100a766bf4f8f28f90d77e0a5461bbdb219042e7679bebe79004fed8d75"
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.8"
+version = "1.0.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5464a87b239f13a63a501f2701565754bae92d243d4bb7eb12f6d57d2269bf4"
+checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
 
 [[package]]
 name = "unicode-normalization"
@@ -4059,17 +4144,17 @@ dependencies = [
 
 [[package]]
 name = "unicode-width"
-version = "0.1.10"
+version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0edd1e5b14653f783770bce4a4dabb4a5108a5370a5f5d8cfe8710c361f6c8b"
+checksum = "e51733f11c9c4f72aa0c160008246859e340b00807569a0da0e7a1079b27ba85"
 
 [[package]]
 name = "universal-hash"
-version = "0.4.1"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f214e8f697e925001e66ec2c6e37a4ef93f0f78c2eed7814394e10c62025b05"
+checksum = "8326b2c654932e3e4f9196e69d08fdf7cfd718e1dc6f66b347e6024a0c961402"
 dependencies = [
- "generic-array 0.14.6",
+ "generic-array 0.14.7",
  "subtle",
 ]
 
@@ -4089,11 +4174,17 @@ version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a"
 
+[[package]]
+name = "untrusted"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
+
 [[package]]
 name = "url"
-version = "2.3.1"
+version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d68c799ae75762b8c3fe375feb6600ef5602c883c5d21eb51c09f22b83c4643"
+checksum = "31e6302e3bb753d46e83516cae55ae196fc0c309407cf11ab35cc51a4c2a4633"
 dependencies = [
  "form_urlencoded",
  "idna",
@@ -4121,13 +4212,9 @@ checksum = "830b7e5d4d90034032940e4ace0d9a9a057e7a45cd94e6c007832e39edb82f6d"
 
 [[package]]
 name = "value-bag"
-version = "1.0.0-alpha.9"
+version = "1.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2209b78d1249f7e6f3293657c9779fe31ced465df091bbd433a1cf88e916ec55"
-dependencies = [
- "ctor",
- "version_check",
-]
+checksum = "126e423afe2dd9ac52142e7e9d5ce4135d7e13776c529d27fd6bc49f19e3280b"
 
 [[package]]
 name = "vcpkg"
@@ -4143,36 +4230,34 @@ checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
 
 [[package]]
 name = "waker-fn"
-version = "1.1.0"
+version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9d5b2c62b4012a3e1eca5a7e077d13b3bf498c4073e33ccd58626607748ceeca"
+checksum = "f3c4517f54858c779bbcbf228f4fca63d121bf85fbecb2dc578cdf4a39395690"
 
 [[package]]
 name = "walkdir"
-version = "2.3.2"
+version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "808cf2735cd4b6866113f648b791c6adc5714537bc222d9347bb203386ffda56"
+checksum = "d71d857dc86794ca4c280d616f7da00d2dbfd8cd788846559a6813e6aa4b54ee"
 dependencies = [
  "same-file",
- "winapi 0.3.9",
  "winapi-util",
 ]
 
 [[package]]
 name = "want"
-version = "0.3.0"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ce8a968cb1cd110d136ff8b819a556d6fb6d919363c61534f6860c7eb172ba0"
+checksum = "bfa7760aed19e106de2c7c0b581b509f2f25d3dacaf737cb82ac61bc6d760b0e"
 dependencies = [
- "log",
  "try-lock",
 ]
 
 [[package]]
 name = "warp"
-version = "0.3.5"
+version = "0.3.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba431ef570df1287f7f8b07e376491ad54f84d26ac473489427231e1718e1f69"
+checksum = "c1e92e22e03ff1230c03a1a8ee37d2f89cd489e2e541b7550d6afad96faed169"
 dependencies = [
  "bytes",
  "futures-channel",
@@ -4205,12 +4290,6 @@ version = "0.9.0+wasi-snapshot-preview1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519"
 
-[[package]]
-name = "wasi"
-version = "0.10.0+wasi-snapshot-preview1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a143597ca7c7793eff794def352d41792a93c481eb1042423ff7ff72ba2c31f"
-
 [[package]]
 name = "wasi"
 version = "0.11.0+wasi-snapshot-preview1"
@@ -4219,9 +4298,9 @@ checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.84"
+version = "0.2.91"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "31f8dcbc21f30d9b8f2ea926ecb58f6b91192c17e9d33594b3df58b2007ca53b"
+checksum = "c1e124130aee3fb58c5bdd6b639a0509486b0338acaaae0c84a5124b0f588b7f"
 dependencies = [
  "cfg-if 1.0.0",
  "wasm-bindgen-macro",
@@ -4229,24 +4308,24 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-backend"
-version = "0.2.84"
+version = "0.2.91"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95ce90fd5bcc06af55a641a86428ee4229e44e07033963a2290a8e241607ccb9"
+checksum = "c9e7e1900c352b609c8488ad12639a311045f40a35491fb69ba8c12f758af70b"
 dependencies = [
  "bumpalo",
  "log",
  "once_cell",
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.48",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-futures"
-version = "0.4.34"
+version = "0.4.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f219e0d211ba40266969f6dbdd90636da12f75bee4fc9d6c23d1260dadb51454"
+checksum = "877b9c3f61ceea0e56331985743b13f3d25c406a7098d45180fb5f09bc19ed97"
 dependencies = [
  "cfg-if 1.0.0",
  "js-sys",
@@ -4256,9 +4335,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.84"
+version = "0.2.91"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c21f77c0bedc37fd5dc21f897894a5ca01e7bb159884559461862ae90c0b4c5"
+checksum = "b30af9e2d358182b5c7449424f017eba305ed32a7010509ede96cdc4696c46ed"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -4266,28 +4345,28 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.84"
+version = "0.2.91"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2aff81306fcac3c7515ad4e177f521b5c9a15f2b08f4e32d823066102f35a5f6"
+checksum = "642f325be6301eb8107a83d12a8ac6c1e1c54345a7ef1a9261962dfefda09e66"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.48",
  "wasm-bindgen-backend",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.84"
+version = "0.2.91"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0046fef7e28c3804e5e38bfa31ea2a0f73905319b677e57ebe37e49358989b5d"
+checksum = "4f186bd2dcf04330886ce82d6f33dd75a7bfcf69ecf5763b89fcde53b6ac9838"
 
 [[package]]
 name = "web-sys"
-version = "0.3.61"
+version = "0.3.68"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e33b99f4b23ba3eec1a53ac264e35a755f00e966e0065077d6027c0f575b0b97"
+checksum = "96565907687f7aceb35bc5fc03770a8a0471d82e479f25832f54a0e3f4b28446"
 dependencies = [
  "js-sys",
  "wasm-bindgen",
@@ -4295,9 +4374,9 @@ dependencies = [
 
 [[package]]
 name = "webpki-roots"
-version = "0.25.2"
+version = "0.25.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14247bb57be4f377dfb94c72830b8ce8fc6beac03cf4bf7b9732eadd414123fc"
+checksum = "5f20c57d8d7db6d3b86154206ae5d8fba62dd39573114de97c2cb0578251f8e1"
 
 [[package]]
 name = "winapi"
@@ -4329,9 +4408,9 @@ checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
 
 [[package]]
 name = "winapi-util"
-version = "0.1.5"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
+checksum = "f29e6f9198ba0d26b4c9f07dbe6f9ed633e1f3d5b8b414090084349e46a52596"
 dependencies = [
  "winapi 0.3.9",
 ]
@@ -4343,27 +4422,12 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
 [[package]]
-name = "windows-sys"
-version = "0.42.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a3e1820f08b8513f676f7ab6c1f99ff312fb97b553d30ff4dd86f9f15728aa7"
-dependencies = [
- "windows_aarch64_gnullvm 0.42.2",
- "windows_aarch64_msvc 0.42.2",
- "windows_i686_gnu 0.42.2",
- "windows_i686_msvc 0.42.2",
- "windows_x86_64_gnu 0.42.2",
- "windows_x86_64_gnullvm 0.42.2",
- "windows_x86_64_msvc 0.42.2",
-]
-
-[[package]]
-name = "windows-sys"
-version = "0.45.0"
+name = "windows-core"
+version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0"
+checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9"
 dependencies = [
- "windows-targets 0.42.2",
+ "windows-targets 0.52.0",
 ]
 
 [[package]]
@@ -4376,18 +4440,12 @@ dependencies = [
 ]
 
 [[package]]
-name = "windows-targets"
-version = "0.42.2"
+name = "windows-sys"
+version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071"
+checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
 dependencies = [
- "windows_aarch64_gnullvm 0.42.2",
- "windows_aarch64_msvc 0.42.2",
- "windows_i686_gnu 0.42.2",
- "windows_i686_msvc 0.42.2",
- "windows_x86_64_gnu 0.42.2",
- "windows_x86_64_gnullvm 0.42.2",
- "windows_x86_64_msvc 0.42.2",
+ "windows-targets 0.52.0",
 ]
 
 [[package]]
@@ -4406,10 +4464,19 @@ dependencies = [
 ]
 
 [[package]]
-name = "windows_aarch64_gnullvm"
-version = "0.42.2"
+name = "windows-targets"
+version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8"
+checksum = "8a18201040b24831fbb9e4eb208f8892e1f50a37feb53cc7ff887feb8f50e7cd"
+dependencies = [
+ "windows_aarch64_gnullvm 0.52.0",
+ "windows_aarch64_msvc 0.52.0",
+ "windows_i686_gnu 0.52.0",
+ "windows_i686_msvc 0.52.0",
+ "windows_x86_64_gnu 0.52.0",
+ "windows_x86_64_gnullvm 0.52.0",
+ "windows_x86_64_msvc 0.52.0",
+]
 
 [[package]]
 name = "windows_aarch64_gnullvm"
@@ -4418,10 +4485,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
 
 [[package]]
-name = "windows_aarch64_msvc"
-version = "0.42.2"
+name = "windows_aarch64_gnullvm"
+version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43"
+checksum = "cb7764e35d4db8a7921e09562a0304bf2f93e0a51bfccee0bd0bb0b666b015ea"
 
 [[package]]
 name = "windows_aarch64_msvc"
@@ -4430,10 +4497,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
 
 [[package]]
-name = "windows_i686_gnu"
-version = "0.42.2"
+name = "windows_aarch64_msvc"
+version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f"
+checksum = "bbaa0368d4f1d2aaefc55b6fcfee13f41544ddf36801e793edbbfd7d7df075ef"
 
 [[package]]
 name = "windows_i686_gnu"
@@ -4442,10 +4509,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
 
 [[package]]
-name = "windows_i686_msvc"
-version = "0.42.2"
+name = "windows_i686_gnu"
+version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060"
+checksum = "a28637cb1fa3560a16915793afb20081aba2c92ee8af57b4d5f28e4b3e7df313"
 
 [[package]]
 name = "windows_i686_msvc"
@@ -4454,10 +4521,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
 
 [[package]]
-name = "windows_x86_64_gnu"
-version = "0.42.2"
+name = "windows_i686_msvc"
+version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36"
+checksum = "ffe5e8e31046ce6230cc7215707b816e339ff4d4d67c65dffa206fd0f7aa7b9a"
 
 [[package]]
 name = "windows_x86_64_gnu"
@@ -4466,10 +4533,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
 
 [[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.42.2"
+name = "windows_x86_64_gnu"
+version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3"
+checksum = "3d6fa32db2bc4a2f5abeacf2b69f7992cd09dca97498da74a151a3132c26befd"
 
 [[package]]
 name = "windows_x86_64_gnullvm"
@@ -4478,10 +4545,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
 
 [[package]]
-name = "windows_x86_64_msvc"
-version = "0.42.2"
+name = "windows_x86_64_gnullvm"
+version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0"
+checksum = "1a657e1e9d3f514745a572a6846d3c7aa7dbe1658c056ed9c3344c4109a6949e"
 
 [[package]]
 name = "windows_x86_64_msvc"
@@ -4489,11 +4556,26 @@ version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
 
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dff9641d1cd4be8d1a070daf9e3773c5f67e78b4d9d42263020c057706765c04"
+
+[[package]]
+name = "winnow"
+version = "0.5.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f593a95398737aeed53e489c785df13f3618e41dbcd6718c6addbf1395aa6876"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "winnow"
-version = "0.5.15"
+version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7c2e3184b9c4e92ad5167ca73039d0c42476302ab603e2fec4487511f38ccefc"
+checksum = "d90f4e0f530c4c69f62b80d839e9ef3855edc9cba471a160c4d692deed62b401"
 dependencies = [
  "memchr",
 ]
@@ -4524,9 +4606,9 @@ version = "8.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "06eee6f3bb38f8c8dca03053572130be2e5006a31dc7e5d8c62e375952b2ff38"
 dependencies = [
- "aes-gcm 0.10.2",
+ "aes-gcm 0.10.3",
  "bs58 0.5.0",
- "hashbrown 0.14.0",
+ "hashbrown 0.14.3",
  "hex",
  "num-traits",
  "p256k1",
@@ -4534,7 +4616,7 @@ dependencies = [
  "primitive-types",
  "rand_core 0.6.4",
  "serde",
- "sha2 0.10.6",
+ "sha2 0.10.8",
  "thiserror",
  "tracing",
  "tracing-subscriber",
@@ -4549,8 +4631,28 @@ dependencies = [
  "tap",
 ]
 
+[[package]]
+name = "zerocopy"
+version = "0.7.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "74d4d3961e53fa4c9a25a8637fc2bfaf2595b3d3ae34875568a5cf64787716be"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.7.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ce1b18ccd8e73a9321186f97e46f9f04b778851177567b1975109d26a08d2a6"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.48",
+]
+
 [[package]]
 name = "zeroize"
-version = "1.5.7"
+version = "1.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c394b5bd0c6f669e7275d9c20aa90ae064cb22e75a1cad54e1b34088034b149f"
+checksum = "525b4ec142c6b68a2d10f01f7bbf6755599ca3f81ea53b8431b7dd348f5fdb2d"
diff --git a/stackslib/Cargo.toml b/stackslib/Cargo.toml
index c5411353e2..cf62a80217 100644
--- a/stackslib/Cargo.toml
+++ b/stackslib/Cargo.toml
@@ -31,8 +31,9 @@ name = "blockstack-cli"
 path = "src/blockstack_cli.rs"
 
 [dependencies]
-rand = "0.7.3"
-rand_chacha = "=0.2.2"
+rand = { workspace = true }
+rand_core = { workspace = true }
+rand_chacha = "0.3.1"
 serde = "1"
 serde_derive = "1"
 serde_stacker = "0.1"
@@ -56,7 +57,6 @@ pox-locking = { path = "../pox-locking" }
 libstackerdb = { path = "../libstackerdb" }
 siphasher = "0.3.7"
 wsts = {workspace = true}
-rand_core = {workspace = true}
 hashbrown = "0.14"
 
 [target.'cfg(unix)'.dependencies]
diff --git a/stackslib/src/burnchains/bitcoin/network.rs b/stackslib/src/burnchains/bitcoin/network.rs
index d29c7b2aaf..3e8bf9340c 100644
--- a/stackslib/src/burnchains/bitcoin/network.rs
+++ b/stackslib/src/burnchains/bitcoin/network.rs
@@ -187,7 +187,7 @@ impl BitcoinIndexer {
                         }
                         Err(btc_error::ConnectionBroken) => {
                             // need to try again
-                            backoff = 2.0 * backoff + (backoff * rng.gen_range(0.0, 1.0));
+                            backoff = 2.0 * backoff + (backoff * rng.gen_range(0.0..1.0));
                         }
                         Err(e) => {
                             // propagate other network error
@@ -204,7 +204,7 @@ impl BitcoinIndexer {
                         "Failed to connect to peer {}:{}: {}",
                         &self.config.peer_host, self.config.peer_port, err_msg
                     );
-                    backoff = 2.0 * backoff + (backoff * rng.gen_range(0.0, 1.0));
+                    backoff = 2.0 * backoff + (backoff * rng.gen_range(0.0..1.0));
                 }
             }
 
diff --git a/stackslib/src/burnchains/tests/burnchain.rs b/stackslib/src/burnchains/tests/burnchain.rs
index d30f5aa2d2..38f95a17a3 100644
--- a/stackslib/src/burnchains/tests/burnchain.rs
+++ b/stackslib/src/burnchains/tests/burnchain.rs
@@ -16,7 +16,8 @@
 
 use ed25519_dalek::Keypair as VRFKeypair;
 use rand::rngs::ThreadRng;
-use rand::thread_rng;
+use rand_chacha::ChaChaRng;
+use rand_core::SeedableRng;
 use serde::Serialize;
 use sha2::Sha512;
 use stacks_common::address::AddressHashMode;
@@ -866,7 +867,7 @@ fn test_burn_snapshot_sequence() {
     let mut leader_bitcoin_addresses = vec![];
 
     for i in 0..32 {
-        let mut csprng: ThreadRng = thread_rng();
+        let mut csprng = ChaChaRng::from_seed(Default::default());
         let keypair: VRFKeypair = VRFKeypair::generate(&mut csprng);
 
         let privkey_hex = to_hex(&keypair.secret.to_bytes());
diff --git a/stackslib/src/chainstate/burn/mod.rs b/stackslib/src/chainstate/burn/mod.rs
index 4fc937afee..74a57292e7 100644
--- a/stackslib/src/chainstate/burn/mod.rs
+++ b/stackslib/src/chainstate/burn/mod.rs
@@ -19,7 +19,8 @@ use std::fmt;
 use std::io::Write;
 
 use rand::seq::index::sample;
-use rand::{Rng, SeedableRng};
+use rand::Rng;
+use rand_chacha::rand_core::SeedableRng;
 use rand_chacha::ChaCha20Rng;
 use ripemd::Ripemd160;
 use rusqlite::{Connection, Transaction};
@@ -150,8 +151,8 @@ impl SortitionHash {
         if max < 2 {
             return (0..max).collect();
         }
-        let first = rng.gen_range(0, max);
-        let try_second = rng.gen_range(0, max - 1);
+        let first = rng.gen_range(0..max);
+        let try_second = rng.gen_range(0..(max - 1));
         let second = if first == try_second {
             // "swap" try_second with max
             max - 1
diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index 3eafc06dc1..216687cd73 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -148,7 +148,7 @@ pub fn make_all_signers_vote_for_aggregate_key(
     }
 
     // Generate a new aggregate key
-    test_signers.generate_aggregate_key();
+    test_signers.generate_aggregate_key(cycle_id as u64);
 
     let signers_res = readonly_call_with_sortdb(
         chainstate,
diff --git a/stackslib/src/chainstate/nakamoto/tests/node.rs b/stackslib/src/chainstate/nakamoto/tests/node.rs
index d1d6f61605..7b88792498 100644
--- a/stackslib/src/chainstate/nakamoto/tests/node.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/node.rs
@@ -24,7 +24,8 @@ use clarity::vm::costs::{ExecutionCost, LimitedCostTracker};
 use clarity::vm::types::*;
 use hashbrown::HashMap;
 use rand::seq::SliceRandom;
-use rand::{thread_rng, Rng};
+use rand::{CryptoRng, RngCore, SeedableRng};
+use rand_chacha::ChaCha20Rng;
 use stacks_common::address::*;
 use stacks_common::consts::{FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH};
 use stacks_common::types::chainstate::{BlockHeaderHash, SortitionId, StacksBlockId, VRFSeed};
@@ -189,8 +190,8 @@ impl TestSigners {
     }
 
     // Generate and assign a new aggregate public key
-    pub fn generate_aggregate_key(&mut self) -> Point {
-        let mut rng = rand_core::OsRng;
+    pub fn generate_aggregate_key(&mut self, seed: u64) -> Point {
+        let mut rng = ChaCha20Rng::seed_from_u64(seed);
         let num_parties = self.party_key_ids.len().try_into().unwrap();
         // Create the parties
         self.signer_parties = self
diff --git a/stackslib/src/net/neighbors/neighbor.rs b/stackslib/src/net/neighbors/neighbor.rs
index a1d513daa2..617860063e 100644
--- a/stackslib/src/net/neighbors/neighbor.rs
+++ b/stackslib/src/net/neighbors/neighbor.rs
@@ -134,7 +134,7 @@ impl Neighbor {
         let mut rng = thread_rng();
         let min = cmp::min(self.in_degree, self.out_degree);
         let max = cmp::max(self.in_degree, self.out_degree);
-        let res = rng.gen_range(min, max + 1) as u64;
+        let res = rng.gen_range(min..(max + 1)) as u64;
         if res == 0 {
             1
         } else {
diff --git a/stackslib/src/net/neighbors/walk.rs b/stackslib/src/net/neighbors/walk.rs
index 642195a589..9248140629 100644
--- a/stackslib/src/net/neighbors/walk.rs
+++ b/stackslib/src/net/neighbors/walk.rs
@@ -1375,7 +1375,7 @@ impl<DB: NeighborWalkDB, NC: NeighborComms> NeighborWalk<DB, NC> {
         }
         // select a random neighbor index, if exclude is set, and matches this
         //  neighbor, then use the next index (modulo the frontier length).
-        let mut neighbor_index = rnd.gen_range(0, frontier.len());
+        let mut neighbor_index = rnd.gen_range(0..frontier.len());
         for _ in 0..2 {
             // two attempts, in case our first attempt lands on `exclude`
             for (cnt, (nk, n)) in frontier.iter().enumerate() {
diff --git a/stackslib/src/net/prune.rs b/stackslib/src/net/prune.rs
index b2b7ff6c32..1d86aa834d 100644
--- a/stackslib/src/net/prune.rs
+++ b/stackslib/src/net/prune.rs
@@ -153,7 +153,7 @@ impl PeerNetwork {
             total += count;
         }
 
-        let sample = rng.gen_range(0, total);
+        let sample = rng.gen_range(0..total);
         let mut offset = 0;
         for (org, count) in org_weights.iter() {
             if *count == 0 {
diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index 4a775399d6..b5699a4e40 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -13,6 +13,7 @@ use rand::RngCore;
 use stacks::burnchains::bitcoin::BitcoinNetworkType;
 use stacks::burnchains::{Burnchain, MagicBytes, BLOCKSTACK_MAGIC_MAINNET};
 use stacks::chainstate::nakamoto::signer_set::NakamotoSigners;
+use stacks::chainstate::nakamoto::tests::node::TestSigners;
 use stacks::chainstate::stacks::boot::MINERS_NAME;
 use stacks::chainstate::stacks::index::marf::MARFOpenOpts;
 use stacks::chainstate::stacks::index::storage::TrieHashCalculationMode;
@@ -43,7 +44,6 @@ use stacks_common::util::hash::hex_bytes;
 use stacks_common::util::secp256k1::{Secp256k1PrivateKey, Secp256k1PublicKey};
 
 use crate::chain_data::MinerStats;
-use crate::mockamoto::signer::SelfSigner;
 
 pub const DEFAULT_SATS_PER_VB: u64 = 50;
 const DEFAULT_MAX_RBF_RATE: u64 = 150; // 1.5x
@@ -506,7 +506,7 @@ lazy_static! {
 }
 
 impl Config {
-    pub fn self_signing(&self) -> Option<SelfSigner> {
+    pub fn self_signing(&self) -> Option<TestSigners> {
         if !(self.burnchain.mode == "nakamoto-neon" || self.burnchain.mode == "mockamoto") {
             return None;
         }
@@ -1986,7 +1986,7 @@ pub struct MinerConfig {
     pub candidate_retry_cache_size: u64,
     pub unprocessed_block_deadline_secs: u64,
     pub mining_key: Option<Secp256k1PrivateKey>,
-    pub self_signing_key: Option<SelfSigner>,
+    pub self_signing_key: Option<TestSigners>,
     /// Amount of time while mining in nakamoto to wait in between mining interim blocks
     pub wait_on_interim_blocks: Duration,
     /// minimum number of transactions that must be in a block if we're going to replace a pending
@@ -2422,7 +2422,7 @@ impl MinerConfigFile {
             self_signing_key: self
                 .self_signing_seed
                 .as_ref()
-                .map(|x| SelfSigner::from_seed(*x))
+                .map(|x| TestSigners::from_seed(*x))
                 .or(miner_default_config.self_signing_key),
             wait_on_interim_blocks: self
                 .wait_on_interim_blocks_ms
diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index 77a0993b8f..3d1691c263 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -44,6 +44,7 @@ use stacks::chainstate::coordinator::comm::CoordinatorReceivers;
 use stacks::chainstate::coordinator::{
     ChainsCoordinator, ChainsCoordinatorConfig, CoordinatorCommunication,
 };
+use stacks::chainstate::nakamoto::tests::node::TestSigners;
 use stacks::chainstate::nakamoto::{
     NakamotoBlock, NakamotoBlockHeader, NakamotoChainState, SetupBlockResult,
 };
@@ -87,7 +88,6 @@ use stacks_common::util::hash::{to_hex, Hash160, MerkleTree, Sha512Trunc256Sum};
 use stacks_common::util::secp256k1::{MessageSignature, Secp256k1PrivateKey, Secp256k1PublicKey};
 use stacks_common::util::vrf::{VRFPrivateKey, VRFProof, VRFPublicKey, VRF};
 
-use self::signer::SelfSigner;
 use crate::globals::{NeonGlobals as Globals, RelayerDirective};
 use crate::neon::Counters;
 use crate::neon_node::{PeerThread, StacksNode, BLOCK_PROCESSOR_STACK_SIZE};
@@ -276,7 +276,7 @@ pub struct MockamotoNode {
     sortdb: SortitionDB,
     mempool: MemPoolDB,
     chainstate: StacksChainState,
-    self_signer: SelfSigner,
+    self_signer: TestSigners,
     miner_key: StacksPrivateKey,
     vrf_key: VRFPrivateKey,
     relay_rcv: Option<Receiver<RelayerDirective>>,
@@ -424,7 +424,7 @@ impl MockamotoNode {
         initial_balances.push((stacker.into(), 100_000_000_000_000));
 
         // Create a boot contract to initialize the aggregate public key prior to Pox-4 activation
-        let self_signer = SelfSigner::single_signer();
+        let self_signer = TestSigners::single_signer();
         let agg_pub_key = self_signer.aggregate_public_key.clone();
         info!("Mockamoto node setting agg public key"; "agg_pub_key" => %to_hex(&self_signer.aggregate_public_key.compress().data));
         let callback = move |clarity_tx: &mut ClarityTx| {
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index 074db03095..8d14921a23 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -29,6 +29,7 @@ use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::burn::{BlockSnapshot, ConsensusHash};
 use stacks::chainstate::nakamoto::miner::{NakamotoBlockBuilder, NakamotoTenureInfo};
 use stacks::chainstate::nakamoto::signer_set::NakamotoSigners;
+use stacks::chainstate::nakamoto::tests::node::TestSigners;
 use stacks::chainstate::nakamoto::{NakamotoBlock, NakamotoChainState};
 use stacks::chainstate::stacks::boot::MINERS_NAME;
 use stacks::chainstate::stacks::db::{StacksChainState, StacksHeaderInfo};
@@ -48,7 +49,6 @@ use wsts::curve::point::Point;
 
 use super::relayer::RelayerThread;
 use super::{Config, Error as NakamotoNodeError, EventDispatcher, Keychain};
-use crate::mockamoto::signer::SelfSigner;
 use crate::nakamoto_node::VRF_MOCK_MINER_KEY;
 use crate::run_loop::nakamoto::Globals;
 use crate::run_loop::RegisteredKey;
@@ -418,7 +418,7 @@ impl BlockMinerThread {
 
     fn self_sign_and_broadcast(
         &self,
-        mut signer: SelfSigner,
+        mut signer: TestSigners,
         mut block: NakamotoBlock,
     ) -> Result<(), ChainstateError> {
         signer.sign_nakamoto_block(&mut block);
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 38c2a74415..8af6cc219e 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -27,6 +27,7 @@ use stacks::burnchains::MagicBytes;
 use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::coordinator::comm::CoordinatorChannels;
 use stacks::chainstate::nakamoto::miner::NakamotoBlockBuilder;
+use stacks::chainstate::nakamoto::tests::node::TestSigners;
 use stacks::chainstate::nakamoto::{NakamotoBlock, NakamotoChainState};
 use stacks::chainstate::stacks::address::PoxAddress;
 use stacks::chainstate::stacks::boot::MINERS_NAME;
@@ -59,7 +60,6 @@ use stacks_common::util::secp256k1::{MessageSignature, Secp256k1PrivateKey};
 
 use super::bitcoin_regtest::BitcoinCoreController;
 use crate::config::{EventKeyType, EventObserverConfig, InitialBalance};
-use crate::mockamoto::signer::SelfSigner;
 use crate::neon::{Counters, RunLoopCounter};
 use crate::run_loop::boot_nakamoto;
 use crate::tests::neon_integrations::{
@@ -189,7 +189,7 @@ pub fn naka_neon_integration_conf(seed: Option<&[u8]>) -> (Config, StacksAddress
 
     let mining_key = Secp256k1PrivateKey::from_seed(&[1]);
     conf.miner.mining_key = Some(mining_key);
-    conf.miner.self_signing_key = Some(SelfSigner::from_seed(7));
+    conf.miner.self_signing_key = Some(TestSigners::from_seed(7));
 
     conf.node.miner = true;
     conf.node.wait_time_for_microblocks = 500;

From 357d41ab7c73574964a425bb8cd16e819a00b63e Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Wed, 14 Feb 2024 17:17:24 -0500
Subject: [PATCH 0769/1166] chore: address PR feedback

---
 stacks-common/src/bitvec.rs             |   7 +
 stackslib/src/net/chat.rs               |  18 +-
 stackslib/src/net/codec.rs              | 148 +++++++-------
 stackslib/src/net/connection.rs         |   3 +
 stackslib/src/net/inv/epoch2x.rs        | 260 ++++++++++++------------
 stackslib/src/net/inv/nakamoto.rs       | 125 ++++++------
 stackslib/src/net/mod.rs                |   9 +-
 stackslib/src/net/p2p.rs                |  23 +--
 stackslib/src/net/tests/inv/nakamoto.rs |  57 ++++--
 9 files changed, 337 insertions(+), 313 deletions(-)

diff --git a/stacks-common/src/bitvec.rs b/stacks-common/src/bitvec.rs
index 00d1c18b69..0150346068 100644
--- a/stacks-common/src/bitvec.rs
+++ b/stacks-common/src/bitvec.rs
@@ -162,6 +162,13 @@ impl<const MAX_SIZE: u16> BitVec<MAX_SIZE> {
         }
         Ok(())
     }
+
+    /// Set all bits to zero
+    pub fn clear(&mut self) {
+        for i in 0..self.data.len() {
+            self.data[i] = 0;
+        }
+    }
 }
 
 #[cfg(test)]
diff --git a/stackslib/src/net/chat.rs b/stackslib/src/net/chat.rs
index 25d2355a7a..c432e9c07c 100644
--- a/stackslib/src/net/chat.rs
+++ b/stackslib/src/net/chat.rs
@@ -1721,7 +1721,13 @@ impl ConversationP2P {
             chainstate,
             reward_cycle,
         )?;
-        let nakamoto_inv = NakamotoInvData::new(&bitvec_bools);
+        let nakamoto_inv = NakamotoInvData::try_from(&bitvec_bools).map_err(|e| {
+            warn!(
+                "Failed to create a NakamotoInv response to {:?}: {:?}",
+                get_nakamoto_inv, &e
+            );
+            e
+        })?;
 
         Ok(StacksMessageType::NakamotoInv(nakamoto_inv))
     }
@@ -1759,9 +1765,7 @@ impl ConversationP2P {
                     "{:?}: Disable inv chat -- pretend like we have nothing",
                     network.get_local_peer()
                 );
-                for i in 0..tenure_inv_data.tenures.len() {
-                    tenure_inv_data.tenures[i] = 0;
-                }
+                tenure_inv_data.tenures.clear();
             }
         }
 
@@ -5619,11 +5623,13 @@ mod test {
             // convo 2 returned a tenure-inv for all tenures
             match reply_1.payload {
                 StacksMessageType::NakamotoInv(ref data) => {
-                    assert_eq!(data.bitlen, 10);
+                    assert_eq!(data.tenures.len(), 10);
                     test_debug!("data: {:?}", data);
 
                     // all burn blocks had sortitions, but we have no tenures :(
-                    assert_eq!(data.tenures, vec![0, 0]);
+                    for i in 0..10 {
+                        assert_eq!(data.tenures.get(i).unwrap(), false);
+                    }
                 }
                 x => {
                     error!("received invalid payload: {:?}", &x);
diff --git a/stackslib/src/net/codec.rs b/stackslib/src/net/codec.rs
index 2bedb36495..e4ba530f2e 100644
--- a/stackslib/src/net/codec.rs
+++ b/stackslib/src/net/codec.rs
@@ -25,6 +25,7 @@ use clarity::vm::ContractName;
 use rand;
 use rand::Rng;
 use sha2::{Digest, Sha512_256};
+use stacks_common::bitvec::BitVec;
 use stacks_common::codec::{
     read_next, read_next_at_most, read_next_exact, write_next, Error as codec_error,
     StacksMessageCodec, MAX_MESSAGE_LEN, MAX_RELAYERS_LEN, PREAMBLE_ENCODED_SIZE,
@@ -276,7 +277,17 @@ impl BlocksInvData {
     }
 
     pub fn compress_bools(bits: &Vec<bool>) -> Vec<u8> {
-        NakamotoInvData::bools_to_bitvec(bits)
+        let bvl: u16 = bits
+            .len()
+            .try_into()
+            .expect("FATAL: tried to compress more than u16::MAX bools");
+        let mut bitvec = vec![0u8; bitvec_len(bvl) as usize];
+        for (i, bit) in bits.iter().enumerate() {
+            if *bit {
+                bitvec[i / 8] |= 1u8 << (i % 8);
+            }
+        }
+        bitvec
     }
 
     pub fn has_ith_block(&self, block_index: u16) -> bool {
@@ -314,64 +325,32 @@ impl StacksMessageCodec for GetNakamotoInvData {
 
 impl StacksMessageCodec for NakamotoInvData {
     fn consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), codec_error> {
-        write_next(fd, &self.bitlen)?;
         write_next(fd, &self.tenures)?;
         Ok(())
     }
 
     fn consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, codec_error> {
-        let bitlen: u16 = read_next(fd)?;
-        if bitlen == 0 {
-            return Err(codec_error::DeserializeError(
-                "BlocksInv must contain at least one block/microblock bit".to_string(),
-            ));
-        }
-
-        let tenures: Vec<u8> = read_next_exact::<_, u8>(fd, bitvec_len(bitlen).into())?;
-        Ok(Self { bitlen, tenures })
+        Ok(Self {
+            tenures: read_next(fd)?,
+        })
     }
 }
 
 impl NakamotoInvData {
-    pub fn empty() -> Self {
-        Self {
-            bitlen: 0,
-            tenures: vec![],
-        }
-    }
-
-    pub fn new(bits: &[bool]) -> Self {
-        let bvl: u16 = bits
-            .len()
-            .try_into()
-            .expect("FATAL: tried to compress more than u16::MAX bools");
-        Self {
-            bitlen: bvl,
-            tenures: Self::bools_to_bitvec(bits),
-        }
-    }
-
-    pub fn bools_to_bitvec(bits: &[bool]) -> Vec<u8> {
-        let bvl: u16 = bits
-            .len()
-            .try_into()
-            .expect("FATAL: tried to compress more than u16::MAX bools");
-        let mut bitvec = vec![0u8; bitvec_len(bvl) as usize];
-        for (i, bit) in bits.iter().enumerate() {
-            if *bit {
-                bitvec[i / 8] |= 1u8 << (i % 8);
-            }
-        }
-        bitvec
+    pub fn try_from(bits: &[bool]) -> Result<Self, codec_error> {
+        Ok(Self {
+            tenures: BitVec::<2100>::try_from(bits).map_err(|e| {
+                codec_error::SerializeError(format!(
+                    "Could not serialize vec of {} bools: {}",
+                    bits.len(),
+                    e
+                ))
+            })?,
+        })
     }
 
     pub fn has_ith_tenure(&self, tenure_index: u16) -> bool {
-        if tenure_index >= self.bitlen {
-            return false;
-        }
-        let idx =
-            usize::try_from(tenure_index).expect("can't get usize from u16 on this architecture");
-        self.tenures[idx / 8] & (1 << (tenure_index % 8)) != 0
+        self.tenures.get(tenure_index).unwrap_or(false)
     }
 }
 
@@ -1091,7 +1070,7 @@ impl StacksMessageType {
                 format!("GetNakamotoInv({})", &m.consensus_hash,)
             }
             StacksMessageType::NakamotoInv(ref m) => {
-                format!("NakamotoInv({},{:?})", m.bitlen, &m.tenures)
+                format!("NakamotoInv({:?})", &m.tenures)
             }
         }
     }
@@ -1575,6 +1554,7 @@ impl ProtocolFamily for StacksP2P {
 
 #[cfg(test)]
 pub mod test {
+    use stacks_common::bitvec::BitVec;
     use stacks_common::codec::NEIGHBOR_ADDRESS_ENCODED_SIZE;
     use stacks_common::util::hash::hex_bytes;
     use stacks_common::util::secp256k1::*;
@@ -2406,45 +2386,51 @@ pub mod test {
     #[test]
     fn codec_NakamotoInv() {
         let nakamoto_inv = NakamotoInvData {
-            tenures: vec![0xdd, 0xee, 0xaa, 0xdd, 0xbb, 0xee, 0xee, 0xff],
-            bitlen: 64,
+            tenures: BitVec::<2100>::try_from(
+                // 0xdd
+                vec![
+                    true, false, true, true, true, false, true, true, // 0xee
+                    false, true, true, true, false, true, true, true, // 0xaa
+                    false, true, false, true, false, true, false, true, // 0xdd
+                    true, false, true, true, true, false, true, true, // 0xbb
+                    true, true, false, true, true, true, false, true, // 0xee
+                    false, true, true, true, false, true, true, true, // 0xee
+                    false, true, true, true, false, true, true, true, // 0xff
+                    true, true, true, true, true, true, true, true,
+                ]
+                .as_slice(),
+            )
+            .unwrap(),
         };
 
         let nakamoto_inv_bytes = vec![
             // bitlen
-            0x00, 0x40, // tenures.len()
-            0x00, 0x00, 0x00, 0x08, // tenures
+            0x00, 0x40, // vec len
+            0x00, 0x00, 0x00, 0x08, // bits
             0xdd, 0xee, 0xaa, 0xdd, 0xbb, 0xee, 0xee, 0xff,
         ];
 
         check_codec_and_corruption::<NakamotoInvData>(&nakamoto_inv, &nakamoto_inv_bytes);
 
-        // test that read_next_exact() works for the tenures bitvec
-        let long_bitlen = NakamotoInvData {
-            bitlen: 1,
-            tenures: vec![0xff, 0x01],
-        };
-        assert!(check_deserialize_failure::<NakamotoInvData>(&long_bitlen));
-
-        let short_bitlen = NakamotoInvData {
-            bitlen: 9,
-            tenures: vec![0xff],
-        };
-        assert!(check_deserialize_failure::<NakamotoInvData>(&short_bitlen));
+        // should fail
+        let nakamoto_inv_bytes = vec![
+            // bitlen
+            0x00, 0x20, // vec len
+            0x00, 0x00, 0x00, 0x05, // bits
+            0x00, 0x00, 0x00, 0x00,
+        ];
 
-        // works for empty ones
-        let nakamoto_inv = NakamotoInvData {
-            tenures: vec![],
-            bitlen: 0,
-        };
+        let _ = NakamotoInvData::consensus_deserialize(&mut &nakamoto_inv_bytes[..]).unwrap_err();
 
+        // should fail
         let nakamoto_inv_bytes = vec![
             // bitlen
-            0x00, 0x00, // tenures.len()
+            0x00, 0x21, // vec len
+            0x00, 0x00, 0x00, 0x04, // bits
             0x00, 0x00, 0x00, 0x00,
         ];
 
-        assert!(check_deserialize_failure::<NakamotoInvData>(&nakamoto_inv));
+        let _ = NakamotoInvData::consensus_deserialize(&mut &nakamoto_inv_bytes[..]).unwrap_err();
     }
 
     #[test]
@@ -2624,8 +2610,24 @@ pub mod test {
                 consensus_hash: ConsensusHash([0x01; 20]),
             }),
             StacksMessageType::NakamotoInv(NakamotoInvData {
-                tenures: vec![0xdd, 0xee, 0xaa, 0xdd, 0xbb, 0xee, 0xee, 0xff],
-                bitlen: 64
+                tenures: BitVec::<2100>::try_from(
+                    // 0xdd
+                    vec![true, true, false, true, true, true, false, true,
+                    // 0xee
+                    true, true, true, false, true, true, true, false,
+                    // 0xaa
+                    true, false, true, false, true, false, true, false,
+                    // 0xdd
+                    true, true, false, true, true, true, false, true,
+                    // 0xbb
+                    true, false, true, true, true, false, true, true,
+                    // 0xee
+                    true, true, true, false, true, true, true, false,
+                    // 0xee
+                    true, true, true, false, true, true, true, false,
+                    // 0xff
+                    true, true, true, true, true, true, true, true].as_slice()
+                ).unwrap()
             }),
         ];
 
diff --git a/stackslib/src/net/connection.rs b/stackslib/src/net/connection.rs
index d611c43791..026fd744ea 100644
--- a/stackslib/src/net/connection.rs
+++ b/stackslib/src/net/connection.rs
@@ -411,6 +411,9 @@ pub struct ConnectionOptions {
     pub disable_inbound_handshakes: bool,
     pub disable_stackerdb_get_chunks: bool,
     pub force_disconnect_interval: Option<u64>,
+    /// If set to true, this forces the p2p state machine to believe that it is running in
+    /// the reward cycle in which Nakamoto activates, and thus needs to run both the epoch
+    /// 2.x and Nakamoto state machines.
     pub force_nakamoto_epoch_transition: bool,
 }
 
diff --git a/stackslib/src/net/inv/epoch2x.rs b/stackslib/src/net/inv/epoch2x.rs
index c41b537915..21f5c5f7e7 100644
--- a/stackslib/src/net/inv/epoch2x.rs
+++ b/stackslib/src/net/inv/epoch2x.rs
@@ -2674,61 +2674,61 @@ impl PeerNetwork {
         let mut finished_always_allowed_inv_sync = false;
 
         if always_allowed.len() == 0 {
-            // vacuously, we have done so
-            finished_always_allowed_inv_sync = true;
-        } else {
-            // do we have an always-allowed peer that we have not fully synced
-            // with?
-            let mut have_unsynced = false;
-            if let Some(ref inv_state) = self.inv_state {
-                for (nk, stats) in inv_state.block_stats.iter() {
-                    if self.is_bound(&nk) {
-                        // this is the same address we're bound to
-                        continue;
-                    }
-                    if Some((nk.addrbytes.clone(), nk.port)) == self.local_peer.public_ip_address {
-                        // this is a peer at our address
-                        continue;
-                    }
-                    if !always_allowed.contains(&nk) {
-                        // this peer isn't in the always-allowed set
-                        continue;
-                    }
+            // vacuously, we are done so we can return
+            return true;
+        }
 
-                    if stats.inv.num_reward_cycles
-                        >= self.pox_id.num_inventory_reward_cycles() as u64
-                    {
-                        // we have fully sync'ed with an always-allowed peer
-                        debug!(
-                            "{:?}: Fully-sync'ed PoX inventory from {}",
-                            self.get_local_peer(),
-                            nk,
-                        );
-                        finished_always_allowed_inv_sync = true;
-                    } else {
-                        // there exists an always-allowed peer that we have not
-                        // fully sync'ed with
-                        debug!(
-                            "{:?}: Have not fully sync'ed with {}",
-                            self.get_local_peer(),
-                            nk,
-                        );
-                        have_unsynced = true;
-                    }
-                }
+        // do we have an always-allowed peer that we have not fully synced
+        // with?
+        let mut have_unsynced = false;
+        let Some(ref inv_state) = self.inv_state else {
+            return true;
+        };
+
+        for (nk, stats) in inv_state.block_stats.iter() {
+            if self.is_bound(&nk) {
+                // this is the same address we're bound to
+                continue;
+            }
+            if Some((nk.addrbytes.clone(), nk.port)) == self.local_peer.public_ip_address {
+                // this is a peer at our address
+                continue;
+            }
+            if !always_allowed.contains(&nk) {
+                // this peer isn't in the always-allowed set
+                continue;
             }
 
-            if !have_unsynced {
-                // There exists one or more always-allowed peers in
-                // the inv state machine (per the peer DB), but all such peers
-                // report either our bind address or our public IP address.
-                // If this is the case (i.e. a configuration error, a weird
-                // case where nodes share an IP, etc), then we declare this inv
-                // sync pass as finished.
+            if stats.inv.num_reward_cycles >= self.pox_id.num_inventory_reward_cycles() as u64 {
+                // we have fully sync'ed with an always-allowed peer
+                debug!(
+                    "{:?}: Fully-sync'ed PoX inventory from {}",
+                    self.get_local_peer(),
+                    nk,
+                );
                 finished_always_allowed_inv_sync = true;
+            } else {
+                // there exists an always-allowed peer that we have not
+                // fully sync'ed with
+                debug!(
+                    "{:?}: Have not fully sync'ed with {}",
+                    self.get_local_peer(),
+                    nk,
+                );
+                have_unsynced = true;
             }
         }
 
+        if !have_unsynced {
+            // There exists one or more always-allowed peers in
+            // the inv state machine (per the peer DB), but all such peers
+            // report either our bind address or our public IP address.
+            // If this is the case (i.e. a configuration error, a weird
+            // case where nodes share an IP, etc), then we declare this inv
+            // sync pass as finished.
+            finished_always_allowed_inv_sync = true;
+        }
+
         finished_always_allowed_inv_sync
     }
 
@@ -2740,96 +2740,96 @@ impl PeerNetwork {
         download_backpressure: bool,
         ibd: bool,
     ) -> PeerNetworkWorkState {
-        let mut work_state = PeerNetworkWorkState::BlockInvSync;
-
         // synchronize epcoh 2.x peer block inventories
         let (inv_done, inv_throttled) = self.do_network_inv_sync_epoch2x(sortdb, ibd);
-        if inv_done {
-            if !download_backpressure {
-                // proceed to get blocks, if we're not backpressured
-                work_state = PeerNetworkWorkState::BlockDownload;
-            } else {
-                // skip downloads for now
-                work_state = PeerNetworkWorkState::Prune;
-            }
+        if !inv_done {
+            // inventory sync isn't finished, so don't change work state
+            return PeerNetworkWorkState::BlockInvSync;
+        }
 
-            if !inv_throttled {
-                let finished_always_allowed_inv_sync =
-                    self.check_always_allowed_peer_inv_sync_epoch2x();
-                if finished_always_allowed_inv_sync {
-                    debug!(
-                        "{:?}: synchronized inventories with at least one always-allowed peer",
-                        &self.local_peer
-                    );
-                    self.num_inv_sync_passes += 1;
-                } else {
-                    debug!("{:?}: did NOT synchronize inventories with at least one always-allowed peer", &self.local_peer);
-                }
-                debug!(
-                    "{:?}: Finished full inventory state-machine pass ({})",
-                    self.get_local_peer(),
-                    self.num_inv_sync_passes
-                );
+        let work_state = if !download_backpressure {
+            // proceed to get blocks, if we're not backpressured
+            PeerNetworkWorkState::BlockDownload
+        } else {
+            // skip downloads for now
+            PeerNetworkWorkState::Prune
+        };
 
-                // hint to the downloader to start scanning at the sortition
-                // height we just synchronized
-                let start_download_sortition = if let Some(ref inv_state) = self.inv_state {
-                    let (consensus_hash, _) = SortitionDB::get_canonical_stacks_chain_tip_hash(
-                        sortdb.conn(),
-                    )
-                    .expect(
-                        "FATAL: failed to load canonical stacks chain tip hash from sortition DB",
-                    );
-                    let stacks_tip_sortition_height =
-                        SortitionDB::get_block_snapshot_consensus(sortdb.conn(), &consensus_hash)
-                            .expect("FATAL: failed to query sortition DB")
-                            .map(|sn| sn.block_height)
-                            .unwrap_or(self.burnchain.first_block_height)
-                            .saturating_sub(self.burnchain.first_block_height);
+        if inv_throttled {
+            // nothing to do
+            return work_state;
+        }
 
-                    let sortition_height_start =
-                        cmp::min(stacks_tip_sortition_height, inv_state.block_sortition_start);
+        let finished_always_allowed_inv_sync = self.check_always_allowed_peer_inv_sync_epoch2x();
+        if finished_always_allowed_inv_sync {
+            debug!(
+                "{:?}: synchronized inventories with at least one always-allowed peer",
+                &self.local_peer
+            );
+            self.num_inv_sync_passes += 1;
+        } else {
+            debug!(
+                "{:?}: did NOT synchronize inventories with at least one always-allowed peer",
+                &self.local_peer
+            );
+        }
+        debug!(
+            "{:?}: Finished full inventory state-machine pass ({})",
+            self.get_local_peer(),
+            self.num_inv_sync_passes
+        );
 
-                    debug!(
-                        "{:?}: Begin downloader synchronization at sortition height {} min({},{})",
-                        &self.local_peer,
-                        sortition_height_start,
-                        inv_state.block_sortition_start,
-                        stacks_tip_sortition_height
-                    );
+        // hint to the downloader to start scanning at the sortition
+        // height we just synchronized
+        let start_download_sortition = if let Some(ref inv_state) = self.inv_state {
+            let (consensus_hash, _) = SortitionDB::get_canonical_stacks_chain_tip_hash(
+                sortdb.conn(),
+            )
+            .expect("FATAL: failed to load canonical stacks chain tip hash from sortition DB");
+            let stacks_tip_sortition_height =
+                SortitionDB::get_block_snapshot_consensus(sortdb.conn(), &consensus_hash)
+                    .expect("FATAL: failed to query sortition DB")
+                    .map(|sn| sn.block_height)
+                    .unwrap_or(self.burnchain.first_block_height)
+                    .saturating_sub(self.burnchain.first_block_height);
 
-                    sortition_height_start
-                } else {
-                    // really unreachable, but why tempt fate?
-                    warn!(
-                        "{:?}: Inventory state machine not yet initialized",
-                        &self.local_peer
-                    );
-                    0
-                };
+            let sortition_height_start =
+                cmp::min(stacks_tip_sortition_height, inv_state.block_sortition_start);
 
-                if let Some(ref mut downloader) = self.block_downloader {
-                    debug!(
-                        "{:?}: wake up downloader at sortition height {}",
-                        &self.local_peer, start_download_sortition
-                    );
-                    downloader.hint_block_sortition_height_available(
-                        start_download_sortition,
-                        ibd,
-                        false,
-                    );
-                    downloader.hint_microblock_sortition_height_available(
-                        start_download_sortition,
-                        ibd,
-                        false,
-                    );
-                } else {
-                    warn!(
-                        "{:?}: Block downloader not yet initialized",
-                        &self.local_peer
-                    );
-                }
-            }
+            debug!(
+                "{:?}: Begin downloader synchronization at sortition height {} min({},{})",
+                &self.local_peer,
+                sortition_height_start,
+                inv_state.block_sortition_start,
+                stacks_tip_sortition_height
+            );
+
+            sortition_height_start
+        } else {
+            // really unreachable, but why tempt fate?
+            warn!(
+                "{:?}: Inventory state machine not yet initialized",
+                &self.local_peer
+            );
+            0
+        };
+
+        if let Some(ref mut downloader) = self.block_downloader {
+            debug!(
+                "{:?}: wake up downloader at sortition height {}",
+                &self.local_peer, start_download_sortition
+            );
+            downloader.hint_block_sortition_height_available(start_download_sortition, ibd, false);
+            downloader.hint_microblock_sortition_height_available(
+                start_download_sortition,
+                ibd,
+                false,
+            );
+        } else {
+            warn!(
+                "{:?}: Block downloader not yet initialized",
+                &self.local_peer
+            );
         }
         work_state
     }
diff --git a/stackslib/src/net/inv/nakamoto.rs b/stackslib/src/net/inv/nakamoto.rs
index 292ecb7b24..7dea03652a 100644
--- a/stackslib/src/net/inv/nakamoto.rs
+++ b/stackslib/src/net/inv/nakamoto.rs
@@ -16,6 +16,7 @@
 
 use std::collections::{BTreeMap, HashMap};
 
+use stacks_common::bitvec::BitVec;
 use stacks_common::util::get_epoch_time_secs;
 
 use crate::burnchains::PoxConstants;
@@ -249,9 +250,7 @@ pub struct NakamotoTenureInv {
     pub state: NakamotoInvState,
     /// Bitmap of which tenures a peer has.
     /// Maps reward cycle to bitmap.
-    pub tenures_inv: BTreeMap<u64, Vec<u8>>,
-    /// Highest sortition this peer has seen
-    pub highest_sortition: u64,
+    pub tenures_inv: BTreeMap<u64, BitVec<2100>>,
     /// Time of last update, in seconds
     pub last_updated_at: u64,
     /// Burn block height of first sortition
@@ -280,7 +279,6 @@ impl NakamotoTenureInv {
         Self {
             state: NakamotoInvState::GetNakamotoInvBegin,
             tenures_inv: BTreeMap::new(),
-            highest_sortition: 0,
             last_updated_at: 0,
             first_block_height,
             reward_cycle_len,
@@ -311,45 +309,40 @@ impl NakamotoTenureInv {
         };
 
         let sortition_height = burn_block_height - self.first_block_height;
-        let rc_height = sortition_height % self.reward_cycle_len;
-
-        let idx =
-            usize::try_from(rc_height / 8).expect("FATAL: reward cycle length exceeds host usize");
-        let bit = rc_height % 8;
-
-        rc_tenures
-            .get(idx)
-            .map(|bits| bits & (1 << bit) != 0)
-            .unwrap_or(false)
+        let rc_height = u16::try_from(sortition_height % self.reward_cycle_len)
+            .expect("FATAL: reward cycle length exceeds u16::MAX");
+        rc_tenures.get(rc_height).unwrap_or(false)
     }
 
     /// How many reward cycles of data do we have for this peer?
     pub fn highest_reward_cycle(&self) -> u64 {
-        let Some((highest_rc, _)) = self.tenures_inv.last_key_value() else {
-            return 0;
-        };
-        *highest_rc
+        self.tenures_inv
+            .last_key_value()
+            .map(|(highest_rc, _)| *highest_rc)
+            .unwrap_or(0)
+    }
+
+    /// How many blocks are represented in this inv?
+    fn num_blocks_represented(&self) -> u64 {
+        let mut total = 0;
+        for (_, inv) in self.tenures_inv.iter() {
+            total += u64::from(inv.len());
+        }
+        total
     }
 
     /// Add in a newly-discovered inventory.
     /// NOTE: inventories are supposed to be aligned to the reward cycle
     /// Returns true if we learned about at least one new tenure-start block
     /// Returns false if not.
-    pub fn merge_tenure_inv(
-        &mut self,
-        tenure_inv: Vec<u8>,
-        tenure_bitlen: u16,
-        reward_cycle: u64,
-    ) -> bool {
+    pub fn merge_tenure_inv(&mut self, tenure_inv: BitVec<2100>, reward_cycle: u64) -> bool {
         // populate the tenures bitmap to we can fit this tenures inv
-        self.highest_sortition =
-            self.highest_reward_cycle() * self.reward_cycle_len + u64::from(tenure_bitlen);
-        let learned = if let Some(cur_inv) = self.tenures_inv.get(&reward_cycle) {
-            cur_inv != &tenure_inv
-        } else {
-            // this inv is new
-            true
-        };
+        let learned = self
+            .tenures_inv
+            .get(&reward_cycle)
+            .map(|cur_inv| cur_inv != &tenure_inv)
+            .unwrap_or(true);
+
         self.tenures_inv.insert(reward_cycle, tenure_inv);
         self.last_updated_at = get_epoch_time_secs();
         learned
@@ -391,9 +384,8 @@ impl NakamotoTenureInv {
     }
 
     /// Proceed to ask this neighbor for its nakamoto tenure inventories.
-    /// Returns Ok(true) if we should proceed to ask for inventories
-    /// Returns Ok(false) if not
-    /// Returns Err(..) on I/O errors
+    /// Returns true if we should proceed to ask for inventories
+    /// Returns false if not
     pub fn getnakamotoinv_begin(
         &mut self,
         network: &mut PeerNetwork,
@@ -451,8 +443,7 @@ impl NakamotoTenureInv {
                     network.get_local_peer(),
                     &inv_data
                 );
-                let ret =
-                    self.merge_tenure_inv(inv_data.tenures, inv_data.bitlen, self.reward_cycle());
+                let ret = self.merge_tenure_inv(inv_data.tenures, self.reward_cycle());
                 self.next_reward_cycle();
                 return Ok(ret);
             }
@@ -513,11 +504,11 @@ impl<NC: NeighborComms> NakamotoInvStateMachine<NC> {
 
     /// Highest reward cycle learned
     pub fn highest_reward_cycle(&self) -> u64 {
-        let mut highest_rc = 0;
-        for (_, inv) in self.inventories.iter() {
-            highest_rc = inv.highest_reward_cycle().max(highest_rc);
-        }
-        highest_rc
+        self.inventories
+            .iter()
+            .map(|(_, inv)| inv.highest_reward_cycle())
+            .max()
+            .unwrap_or(0)
     }
 
     /// Get the consensus hash for the first sortition in the given reward cycle
@@ -530,10 +521,10 @@ impl<NC: NeighborComms> NakamotoInvStateMachine<NC> {
             .reward_cycle_to_block_height(sortdb.first_block_height, reward_cycle);
         let sn = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn())?;
         let ih = sortdb.index_handle(&sn.sortition_id);
-        let Some(rc_start_sn) = ih.get_block_snapshot_by_height(reward_cycle_start_height)? else {
-            return Ok(None);
-        };
-        Ok(Some(rc_start_sn.consensus_hash))
+        let ch_opt = ih
+            .get_block_snapshot_by_height(reward_cycle_start_height)?
+            .map(|sn| sn.consensus_hash);
+        Ok(ch_opt)
     }
 
     /// Populate the reward_cycle_consensus_hash mapping.  Idempotent.
@@ -542,12 +533,11 @@ impl<NC: NeighborComms> NakamotoInvStateMachine<NC> {
         &mut self,
         sortdb: &SortitionDB,
     ) -> Result<u64, NetError> {
-        let highest_rc =
-            if let Some((highest_rc, _)) = self.reward_cycle_consensus_hashes.last_key_value() {
-                *highest_rc
-            } else {
-                0
-            };
+        let highest_rc = self
+            .reward_cycle_consensus_hashes
+            .last_key_value()
+            .map(|(highest_rc, _)| *highest_rc)
+            .unwrap_or(0);
 
         let sn = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn())?;
         let tip_rc = sortdb
@@ -561,7 +551,7 @@ impl<NC: NeighborComms> NakamotoInvStateMachine<NC> {
             }
             let Some(ch) = Self::load_consensus_hash_for_reward_cycle(sortdb, rc)? else {
                 // NOTE: this should be unreachable, but don't panic
-                continue;
+                return Err(DBError::NotFoundError.into());
             };
             self.reward_cycle_consensus_hashes.insert(rc, ch);
         }
@@ -619,10 +609,8 @@ impl<NC: NeighborComms> NakamotoInvStateMachine<NC> {
 
             // NOTE: this naturally garabage-collects inventories for disconnected nodes, as
             // desired
-            let mut inv = self
-                .inventories
-                .remove(&naddr)
-                .unwrap_or(NakamotoTenureInv::new(
+            let mut inv = self.inventories.remove(&naddr).unwrap_or_else(|| {
+                NakamotoTenureInv::new(
                     network.get_burnchain().first_block_height,
                     network
                         .get_burnchain()
@@ -630,7 +618,8 @@ impl<NC: NeighborComms> NakamotoInvStateMachine<NC> {
                         .reward_cycle_length
                         .into(),
                     naddr.clone(),
-                ));
+                )
+            });
 
             let proceed = inv.getnakamotoinv_begin(network, current_reward_cycle);
             let inv_rc = inv.reward_cycle();
@@ -644,6 +633,11 @@ impl<NC: NeighborComms> NakamotoInvStateMachine<NC> {
                 continue;
             }
 
+            // ask this neighbor for its inventory
+            let Some(getnakamotoinv) = self.make_getnakamotoinv(inv_rc) else {
+                continue;
+            };
+
             debug!(
                 "{:?}: send GetNakamotoInv for reward cycle {} to {}",
                 network.get_local_peer(),
@@ -651,14 +645,11 @@ impl<NC: NeighborComms> NakamotoInvStateMachine<NC> {
                 &naddr
             );
 
-            // ask this neighbor for its inventory
-            if let Some(getnakamotoinv) = self.make_getnakamotoinv(inv_rc) {
-                if let Err(e) = self.comms.neighbor_send(network, &naddr, getnakamotoinv) {
-                    warn!("{:?}: failed to send GetNakamotoInv", network.get_local_peer();
-                          "peer" => ?naddr,
-                          "error" => ?e
-                    );
-                }
+            if let Err(e) = self.comms.neighbor_send(network, &naddr, getnakamotoinv) {
+                warn!("{:?}: failed to send GetNakamotoInv", network.get_local_peer();
+                      "peer" => ?naddr,
+                      "error" => ?e
+                );
             }
         }
 
@@ -748,7 +739,7 @@ impl PeerNetwork {
     }
 
     /// Drive Nakamoto inventory state machine
-    /// returns (learned-new-data?, did-full-pass?, peers-to-disconnect, peers-that-are-dead)
+    /// returns (learned-new-data?, peers-to-disconnect, peers-that-are-dead)
     pub fn sync_inventories_nakamoto(
         &mut self,
         sortdb: &SortitionDB,
diff --git a/stackslib/src/net/mod.rs b/stackslib/src/net/mod.rs
index e5bfaefe3a..94cb32af7b 100644
--- a/stackslib/src/net/mod.rs
+++ b/stackslib/src/net/mod.rs
@@ -43,6 +43,7 @@ use rusqlite::ToSql;
 use serde::de::Error as de_Error;
 use serde::ser::Error as ser_Error;
 use serde::{Deserialize, Serialize};
+use stacks_common::bitvec::BitVec;
 use stacks_common::codec::{
     read_next, write_next, Error as codec_error, StacksMessageCodec,
     BURNCHAIN_HEADER_HASH_ENCODED_SIZE,
@@ -881,11 +882,11 @@ pub struct GetNakamotoInvData {
 /// (2) the remote node not only has the tenure blocks, but has processed them.
 #[derive(Debug, Clone, PartialEq)]
 pub struct NakamotoInvData {
-    /// Number of bits this tenure bit vector has (not to exceed the reward cycle length).
-    pub bitlen: u16,
     /// The tenure bitvector.  tenures[i] & (1 << j) != 0 means that this peer has all the blocks
-    /// for the tenure which began in sortition 8*i + j.
-    pub tenures: Vec<u8>,
+    /// for the tenure which began in sortition 8*i + j.  There will never be more than 1 reward
+    /// cycle's worth of bits here, and since the largest supported reward cycle is 2100 blocks
+    /// long (i.e. mainnet),
+    pub tenures: BitVec<2100>,
 }
 
 /// Request for a PoX bitvector range.
diff --git a/stackslib/src/net/p2p.rs b/stackslib/src/net/p2p.rs
index 560da8901b..695898d86b 100644
--- a/stackslib/src/net/p2p.rs
+++ b/stackslib/src/net/p2p.rs
@@ -1744,11 +1744,10 @@ impl PeerNetwork {
         let mut nk_remove: Vec<(NeighborKey, Hash160)> = vec![];
         for (neighbor_key, ev_id) in self.events.iter() {
             if *ev_id == event_id {
-                let pubkh = if let Some(convo) = self.get_p2p_convo(event_id) {
-                    convo.get_public_key_hash().unwrap_or(Hash160([0x00; 20]))
-                } else {
-                    Hash160([0x00; 20])
-                };
+                let pubkh = self
+                    .get_p2p_convo(event_id)
+                    .and_then(|convo| convo.get_public_key_hash())
+                    .unwrap_or(Hash160([0x00; 20]));
                 nk_remove.push((neighbor_key.clone(), pubkh));
             }
         }
@@ -3874,9 +3873,10 @@ impl PeerNetwork {
             let prune = self.do_network_work_nakamoto(sortdb, ibd);
 
             // in Nakamoto epoch, but we might still be doing epoch 2.x things since Nakamoto does
-            // not begin on a reawrd cycle boundary.
-            if self.burnchain_tip.block_height <= cur_epoch.start_height
-                || self.connection_opts.force_nakamoto_epoch_transition
+            // not begin on a reward cycle boundary.
+            if cur_epoch.epoch_id == StacksEpochId::Epoch30
+                && (self.burnchain_tip.block_height <= cur_epoch.start_height
+                    || self.connection_opts.force_nakamoto_epoch_transition)
             {
                 debug!(
                     "{:?}: run Epoch 2.x work loop in Nakamoto epoch",
@@ -3925,14 +3925,11 @@ impl PeerNetwork {
         while !did_cycle {
             // always do an inv sync
             let learned = self.do_network_inv_sync_nakamoto(sortdb, ibd);
-            if learned {
-                debug!("{:?}: learned about new blocks!", self.get_local_peer());
-            }
-
             debug!(
                 "{:?}: network work state is {:?}",
                 self.get_local_peer(),
-                &self.nakamoto_work_state
+                &self.nakamoto_work_state;
+                "learned_new_blocks?" => learned
             );
             let cur_state = self.nakamoto_work_state;
             match self.nakamoto_work_state {
diff --git a/stackslib/src/net/tests/inv/nakamoto.rs b/stackslib/src/net/tests/inv/nakamoto.rs
index 526e302c60..93213a0e66 100644
--- a/stackslib/src/net/tests/inv/nakamoto.rs
+++ b/stackslib/src/net/tests/inv/nakamoto.rs
@@ -207,8 +207,11 @@ fn test_nakamoto_inv_10_tenures_10_sortitions() {
         let StacksMessageType::NakamotoInv(inv) = inv else {
             panic!("Did not receive an inv for reward cycle {}", rc);
         };
-        assert_eq!(NakamotoInvData::bools_to_bitvec(&bitvec), inv.tenures);
-        assert_eq!(bitvec.len() as u16, inv.bitlen);
+        assert_eq!(
+            NakamotoInvData::try_from(&bitvec).unwrap().tenures,
+            inv.tenures
+        );
+        assert_eq!(bitvec.len() as u16, inv.tenures.len());
     }
 }
 
@@ -256,8 +259,11 @@ fn test_nakamoto_inv_2_tenures_3_sortitions() {
         let StacksMessageType::NakamotoInv(inv) = inv else {
             panic!("Did not receive an inv for reward cycle {}", rc);
         };
-        assert_eq!(NakamotoInvData::bools_to_bitvec(&bitvec), inv.tenures);
-        assert_eq!(bitvec.len() as u16, inv.bitlen);
+        assert_eq!(
+            NakamotoInvData::try_from(&bitvec).unwrap().tenures,
+            inv.tenures
+        );
+        assert_eq!(bitvec.len() as u16, inv.tenures.len());
     }
 }
 
@@ -309,8 +315,11 @@ fn test_nakamoto_inv_10_extended_tenures_10_sortitions() {
         let StacksMessageType::NakamotoInv(inv) = inv else {
             panic!("Did not receive an inv for reward cycle {}", rc);
         };
-        assert_eq!(NakamotoInvData::bools_to_bitvec(&bitvec), inv.tenures);
-        assert_eq!(bitvec.len() as u16, inv.bitlen);
+        assert_eq!(
+            NakamotoInvData::try_from(&bitvec).unwrap().tenures,
+            inv.tenures
+        );
+        assert_eq!(bitvec.len() as u16, inv.tenures.len());
     }
 }
 
@@ -425,9 +434,9 @@ fn check_inv_messages(
         let StacksMessageType::NakamotoInv(inv) = msg else {
             panic!("Did not receive an inv for reward cycle {}", msg_idx);
         };
-        for bit in 0..(inv.bitlen as usize) {
+        for bit in 0..(inv.tenures.len() as usize) {
             let burn_block_height = (msg_idx as u64) * u64::from(rc_len) + (bit as u64);
-            let msg_bit = inv.tenures[bit / 8] & (1 << (bit % 8)) != 0;
+            let msg_bit = inv.tenures.get(bit as u16).unwrap_or(false);
             if burn_block_height < nakamoto_start_burn_height {
                 // inv doesn't cover epoch 2
                 assert!(
@@ -459,7 +468,7 @@ fn check_inv_state(
 ) {
     for (i, (tenure_rc, tenure_inv)) in inv_state.tenures_inv.iter().enumerate() {
         for bit in 0..(rc_len as usize) {
-            let msg_bit = if bit / 8 >= tenure_inv.len() {
+            let msg_bit = if bit / 8 >= tenure_inv.len().into() {
                 // only allowed at the end
                 debug!(
                     "bit = {}, tenure_rc = {}, tenure_inv = {:?}",
@@ -468,7 +477,7 @@ fn check_inv_state(
                 assert_eq!(i, inv_state.tenures_inv.len() - 1);
                 false
             } else {
-                tenure_inv[bit / 8] & (1 << (bit % 8)) != 0
+                tenure_inv.get(bit.try_into().unwrap()).unwrap_or(false)
             };
 
             let burn_block_height = (*tenure_rc as u64) * u64::from(rc_len) + (bit as u64);
@@ -641,11 +650,11 @@ fn test_nakamoto_tenure_inv() {
     assert!(!nakamoto_inv.has_ith_tenure(100));
     assert_eq!(nakamoto_inv.highest_reward_cycle(), 0);
 
-    let full_tenure = NakamotoInvData::bools_to_bitvec(&[true; 100]);
-    let learned = nakamoto_inv.merge_tenure_inv(full_tenure.clone(), 100, 1);
+    let full_tenure = NakamotoInvData::try_from(&[true; 100]).unwrap();
+    let learned = nakamoto_inv.merge_tenure_inv(full_tenure.clone().tenures, 1);
     assert!(learned);
 
-    let learned = nakamoto_inv.merge_tenure_inv(full_tenure, 100, 1);
+    let learned = nakamoto_inv.merge_tenure_inv(full_tenure.tenures, 1);
     assert!(!learned);
 
     debug!("nakamoto_inv = {:?}", &nakamoto_inv);
@@ -667,8 +676,8 @@ fn test_nakamoto_tenure_inv() {
     }
 
     // has_ith_tenure() works (non-triial case)
-    let partial_tenure = NakamotoInvData::bools_to_bitvec(&partial_tenure_bools);
-    let learned = nakamoto_inv.merge_tenure_inv(partial_tenure.clone(), 100, 2);
+    let partial_tenure = NakamotoInvData::try_from(&partial_tenure_bools).unwrap();
+    let learned = nakamoto_inv.merge_tenure_inv(partial_tenure.clone().tenures, 2);
     assert!(learned);
 
     for i in 300..400 {
@@ -683,8 +692,8 @@ fn test_nakamoto_tenure_inv() {
     assert_eq!(nakamoto_inv.highest_reward_cycle(), 2);
 
     // supports sparse updates
-    let full_tenure = NakamotoInvData::bools_to_bitvec(&[true; 100]);
-    let learned = nakamoto_inv.merge_tenure_inv(full_tenure, 100, 4);
+    let full_tenure = NakamotoInvData::try_from(&[true; 100]).unwrap();
+    let learned = nakamoto_inv.merge_tenure_inv(full_tenure.tenures, 4);
     assert!(learned);
 
     for i in 400..500 {
@@ -696,17 +705,25 @@ fn test_nakamoto_tenure_inv() {
     assert_eq!(nakamoto_inv.highest_reward_cycle(), 4);
 
     // can overwrite tenures
-    let full_tenure = NakamotoInvData::bools_to_bitvec(&[true; 100]);
-    let learned = nakamoto_inv.merge_tenure_inv(full_tenure.clone(), 100, 2);
+    let full_tenure = NakamotoInvData::try_from(&[true; 100]).unwrap();
+    let learned = nakamoto_inv.merge_tenure_inv(full_tenure.clone().tenures, 2);
     assert!(learned);
+    assert_eq!(nakamoto_inv.highest_reward_cycle(), 4);
 
-    let learned = nakamoto_inv.merge_tenure_inv(full_tenure.clone(), 100, 2);
+    let learned = nakamoto_inv.merge_tenure_inv(full_tenure.clone().tenures, 2);
     assert!(!learned);
+    assert_eq!(nakamoto_inv.highest_reward_cycle(), 4);
 
     for i in 300..400 {
         assert!(nakamoto_inv.has_ith_tenure(i));
     }
 
+    // partial data
+    let partial_tenure = NakamotoInvData::try_from(&[true; 50]).unwrap();
+    let learned = nakamoto_inv.merge_tenure_inv(full_tenure.clone().tenures, 5);
+    assert!(learned);
+    assert_eq!(nakamoto_inv.highest_reward_cycle(), 5);
+
     // state machine advances when we say so
     assert_eq!(nakamoto_inv.reward_cycle(), 0);
     assert!(nakamoto_inv.is_online());

From b3196e83b62f3a3c60eb30338a002841e614d2d3 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Wed, 14 Feb 2024 17:19:38 -0500
Subject: [PATCH 0770/1166] chore: cargo fmt

---
 testnet/stacks-node/src/tests/neon_integrations.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/testnet/stacks-node/src/tests/neon_integrations.rs b/testnet/stacks-node/src/tests/neon_integrations.rs
index 845ab5958d..2b2cb14ced 100644
--- a/testnet/stacks-node/src/tests/neon_integrations.rs
+++ b/testnet/stacks-node/src/tests/neon_integrations.rs
@@ -9505,7 +9505,7 @@ fn test_problematic_blocks_are_not_relayed_or_stored() {
     // at least one block was mined (hard to say how many due to the raciness between the burnchain
     // downloader and this thread).
     assert!(tip_info.stacks_tip_height > old_tip_info.stacks_tip_height);
-    
+
     // one was problematic -- i.e. the one that included tx_high
     assert_eq!(all_new_files.len(), 1);
 

From 86ed48c1c03afee0e45bac1500171179db57d556 Mon Sep 17 00:00:00 2001
From: ASuciuX <asuciu@hiro.so>
Date: Thu, 15 Feb 2024 00:29:22 +0200
Subject: [PATCH 0771/1166] feat: update workflow to include optimisations

1. split big packages into `stackslib` and `stacks-node`
2. update cargo mutants to use specific version from github in order to include a timeout multiplier feature
3. add a specific run case for `stacks-signer`
---
 .github/workflows/pr-differences-mutants.yml | 106 +++++++++++++++----
 1 file changed, 88 insertions(+), 18 deletions(-)

diff --git a/.github/workflows/pr-differences-mutants.yml b/.github/workflows/pr-differences-mutants.yml
index 041db97591..a795917229 100644
--- a/.github/workflows/pr-differences-mutants.yml
+++ b/.github/workflows/pr-differences-mutants.yml
@@ -23,10 +23,13 @@ jobs:
     runs-on: ubuntu-latest
 
     outputs:
-      run_big_packages: ${{ steps.check_packages_and_shards.outputs.run_big_packages }}
-      big_packages_with_shards: ${{ steps.check_packages_and_shards.outputs.big_packages_with_shards }}
+      run_stackslib: ${{ steps.check_packages_and_shards.outputs.run_stackslib }}
+      stackslib_with_shards: ${{ steps.check_packages_and_shards.outputs.stackslib_with_shards }}
+      run_stacks_node: ${{ steps.check_packages_and_shards.outputs.run_stacks_node }}
+      stacks_node_with_shards: ${{ steps.check_packages_and_shards.outputs.stacks_node_with_shards }}
       run_small_packages: ${{ steps.check_packages_and_shards.outputs.run_small_packages }}
       small_packages_with_shards: ${{ steps.check_packages_and_shards.outputs.small_packages_with_shards }}
+      run_stacks_signer: ${{ steps.check_packages_and_shards.outputs.run_stacks_signer }}
 
     steps:
       - id: check_packages_and_shards
@@ -46,7 +49,7 @@ jobs:
       - name: Run mutants on diffs
         uses: stacks-network/actions/stacks-core/mutation-testing/pr-differences@main
         with:
-          package-dimension: "small"
+          package: "small"
 
   # Mutation testing - Execute on PR on small packages that have functions modified (run with strategy matrix shards)
   pr-differences-mutants-small-shards:
@@ -68,15 +71,15 @@ jobs:
         uses: stacks-network/actions/stacks-core/mutation-testing/pr-differences@main
         with:
           shard: ${{ matrix.shard }}
-          package-dimension: "small"
+          package: "small"
 
-  # Mutation testing - Execute on PR on big packages that have functions modified (normal run, no shards)
-  pr-differences-mutants-big-normal:
-    name: Mutation Testing - Normal, Big
+  # Mutation testing - Execute on PR on stackslib package (normal run, no shards)
+  pr-differences-mutants-stackslib-normal:
+    name: Mutation Testing - Normal, Stackslib
 
     needs: check-big-packages-and-shards
 
-    if: ${{ needs.check-big-packages-and-shards.outputs.run_big_packages == 'true' && needs.check-big-packages-and-shards.outputs.big_packages_with_shards == 'false' }}
+    if: ${{ needs.check-big-packages-and-shards.outputs.run_stackslib == 'true' && needs.check-big-packages-and-shards.outputs.stackslib_with_shards == 'false' }}
 
     runs-on: ubuntu-latest
 
@@ -87,15 +90,15 @@ jobs:
           RUST_BACKTRACE: full
         uses: stacks-network/actions/stacks-core/mutation-testing/pr-differences@main
         with:
-          package-dimension: "big"
+          package: "stackslib"
 
-  # Mutation testing - Execute on PR on big packages that have functions modified (run with strategy matrix shards)
-  pr-differences-mutants-big-shards:
-    name: Mutation Testing - Shards, Big
+  # Mutation testing - Execute on PR on stackslib package (run with strategy matrix shards)
+  pr-differences-mutants-stackslib-shards:
+    name: Mutation Testing - Shards, Stackslib
 
     needs: check-big-packages-and-shards
 
-    if: ${{ needs.check-big-packages-and-shards.outputs.run_big_packages == 'true' && needs.check-big-packages-and-shards.outputs.big_packages_with_shards == 'true' }}
+    if: ${{ needs.check-big-packages-and-shards.outputs.run_stackslib == 'true' && needs.check-big-packages-and-shards.outputs.stackslib_with_shards == 'true' }}
 
     runs-on: ubuntu-latest
 
@@ -112,7 +115,67 @@ jobs:
         uses: stacks-network/actions/stacks-core/mutation-testing/pr-differences@main
         with:
           shard: ${{ matrix.shard }}
-          package-dimension: "big"
+          package: "stackslib"
+
+  # Mutation testing - Execute on PR on stacks-node package (normal run, no shards)
+  pr-differences-mutants-stacks-node-normal:
+    name: Mutation Testing - Normal, Stacks Node
+
+    needs: check-big-packages-and-shards
+
+    if: ${{ needs.check-big-packages-and-shards.outputs.run_stacks_node == 'true' && needs.check-big-packages-and-shards.outputs.stacks_node_with_shards == 'false' }}
+
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Run Run mutants on diffs
+        env:
+          BITCOIND_TEST: 1
+          RUST_BACKTRACE: full
+        uses: stacks-network/actions/stacks-core/mutation-testing/pr-differences@main
+        with:
+          package: "stacks-node"
+
+  # Mutation testing - Execute on PR on stacks-node package (run with strategy matrix shards)
+  pr-differences-mutants-stacks-node-shards:
+    name: Mutation Testing - Shards, Stacks Node
+
+    needs: check-big-packages-and-shards
+
+    if: ${{ needs.check-big-packages-and-shards.outputs.run_stacks_node == 'true' && needs.check-big-packages-and-shards.outputs.stacks_node_with_shards == 'true' }}
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      fail-fast: false
+      matrix:
+        shard: [0, 1, 2, 3]
+
+    steps:
+      - name: Run mutants on diffs
+        env:
+          BITCOIND_TEST: 1
+          RUST_BACKTRACE: full
+        uses: stacks-network/actions/stacks-core/mutation-testing/pr-differences@main
+        with:
+          shard: ${{ matrix.shard }}
+          package: "stacks-node"
+
+  # Mutation testing - Execute on PR on stacks-signer package (normal run, no shards)
+  pr-differences-mutants-stacks-signer-normal:
+    name: Mutation Testing - Normal, Stacks Signer
+
+    needs: check-big-packages-and-shards
+
+    if: ${{ needs.check-big-packages-and-shards.outputs.run_stacks_signer == 'true' }}
+
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Run Run mutants on diffs
+        uses: stacks-network/actions/stacks-core/mutation-testing/pr-differences@main
+        with:
+          package: "stacks-signer"
 
   # Output the mutants and fail the workflow if there are missed/timeout/unviable mutants
   output-mutants:
@@ -120,20 +183,27 @@ jobs:
 
     runs-on: ubuntu-latest
 
+    if: always()
     needs:
       [
         check-big-packages-and-shards,
         pr-differences-mutants-small-normal,
         pr-differences-mutants-small-shards,
-        pr-differences-mutants-big-normal,
-        pr-differences-mutants-big-shards,
+        pr-differences-mutants-stackslib-normal,
+        pr-differences-mutants-stackslib-shards,
+        pr-differences-mutants-stacks-node-normal,
+        pr-differences-mutants-stacks-node-shards,
+        pr-differences-mutants-stacks-signer-normal,
       ]
 
     steps:
       - name: Output Mutants
         uses: stacks-network/actions/stacks-core/mutation-testing/output-pr-mutants@main
         with:
-          big_packages: ${{ needs.check-big-packages-and-shards.outputs.run_big_packages }}
-          shards_for_big_packages: ${{ needs.check-big-packages-and-shards.outputs.big_packages_with_shards }}
+          stackslib_package: ${{ needs.check-big-packages-and-shards.outputs.run_stackslib }}
+          shards_for_stackslib_package: ${{ needs.check-big-packages-and-shards.outputs.stackslib_with_shards }}
+          stacks_node_package: ${{ needs.check-big-packages-and-shards.outputs.run_stacks_node }}
+          shards_for_stacks_node_package: ${{ needs.check-big-packages-and-shards.outputs.stacks_node_with_shards }}
           small_packages: ${{ needs.check-big-packages-and-shards.outputs.run_small_packages }}
           shards_for_small_packages: ${{ needs.check-big-packages-and-shards.outputs.small_packages_with_shards }}
+          stacks_signer: ${{ needs.check-big-packages-and-shards.outputs.run_stacks_signer }}

From 699a1dac40a62d9aae04a2f56d27cd07947fd665 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Thu, 15 Feb 2024 10:23:23 -0600
Subject: [PATCH 0772/1166] chore: update ed25519-dalek and rand libraries, use
 workspace versioning

---
 Cargo.lock                                  | 200 ++++++++++++--------
 Cargo.toml                                  |   2 +
 clarity/Cargo.toml                          |   4 +-
 stacks-common/Cargo.toml                    |   7 +-
 stacks-common/src/address/c32.rs            |   2 +-
 stacks-common/src/util/vrf.rs               | 139 +++++---------
 stackslib/Cargo.toml                        |   5 +-
 stackslib/src/burnchains/tests/burnchain.rs |   8 +-
 8 files changed, 186 insertions(+), 181 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index e746299a7e..1784c93f59 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -99,7 +99,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "be14c7498ea50828a38d0e24a765ed2effe92a705885b57d029cd67d45744072"
 dependencies = [
  "cipher 0.2.5",
- "opaque-debug 0.3.0",
+ "opaque-debug",
 ]
 
 [[package]]
@@ -109,7 +109,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ea2e11f5e94c2f7d386164cc2aa1f97823fed6f259e486940a71c174dd01b0ce"
 dependencies = [
  "cipher 0.2.5",
- "opaque-debug 0.3.0",
+ "opaque-debug",
 ]
 
 [[package]]
@@ -492,6 +492,12 @@ version = "0.21.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567"
 
+[[package]]
+name = "base64ct"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b"
+
 [[package]]
 name = "bitflags"
 version = "1.3.2"
@@ -516,18 +522,6 @@ dependencies = [
  "wyz",
 ]
 
-[[package]]
-name = "block-buffer"
-version = "0.7.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0940dc441f31689269e10ac70eb1002a3a1d3ad1390e030043662eb7fe4688b"
-dependencies = [
- "block-padding",
- "byte-tools",
- "byteorder",
- "generic-array 0.12.4",
-]
-
 [[package]]
 name = "block-buffer"
 version = "0.9.0"
@@ -546,15 +540,6 @@ dependencies = [
  "generic-array 0.14.7",
 ]
 
-[[package]]
-name = "block-padding"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa79dedbb091f449f1f39e53edf88d5dbe95f895dae6135a8d7b881fb5af73f5"
-dependencies = [
- "byte-tools",
-]
-
 [[package]]
 name = "blocking"
 version = "1.5.1"
@@ -598,12 +583,6 @@ version = "1.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c3ac9f8b63eca6fd385229b3675f6cc0dc5c8a5c8a54a59d4f52ffd670d87b0c"
 
-[[package]]
-name = "byte-tools"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3b5ca7a04898ad4bcd41c90c5285445ff5b791899bb1b0abdd2a2aa791211d7"
-
 [[package]]
 name = "byteorder"
 version = "1.5.0"
@@ -740,8 +719,8 @@ dependencies = [
  "assert-json-diff",
  "integer-sqrt",
  "lazy_static",
- "rand 0.7.3",
- "rand_chacha 0.2.2",
+ "rand 0.8.5",
+ "rand_chacha 0.3.1",
  "regex",
  "rstest 0.17.0",
  "rstest_reuse 0.5.0",
@@ -756,15 +735,6 @@ dependencies = [
  "time 0.2.27",
 ]
 
-[[package]]
-name = "clear_on_drop"
-version = "0.2.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38508a63f4979f0048febc9966fadbd48e5dab31fd0ec6a3f151bbf4a74f7423"
-dependencies = [
- "cc",
-]
-
 [[package]]
 name = "colorchoice"
 version = "1.0.0"
@@ -780,6 +750,12 @@ dependencies = [
  "crossbeam-utils",
 ]
 
+[[package]]
+name = "const-oid"
+version = "0.9.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
+
 [[package]]
 name = "const_fn"
 version = "0.4.9"
@@ -984,6 +960,34 @@ dependencies = [
  "zeroize",
 ]
 
+[[package]]
+name = "curve25519-dalek"
+version = "4.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0a677b8922c94e01bdbb12126b0bc852f00447528dee1782229af9c720c3f348"
+dependencies = [
+ "cfg-if 1.0.0",
+ "cpufeatures",
+ "curve25519-dalek-derive",
+ "digest 0.10.7",
+ "fiat-crypto",
+ "platforms",
+ "rustc_version 0.4.0",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "curve25519-dalek-derive"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f46882e17999c6cc590af592290432be3bce0428cb0d5f8b6715e4dc7b383eb3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.48",
+]
+
 [[package]]
 name = "dashmap"
 version = "5.5.3"
@@ -1003,6 +1007,16 @@ version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7e962a19be5cfc3f3bf6dd8f61eb50107f356ad6270fbb3ed41476571db78be5"
 
+[[package]]
+name = "der"
+version = "0.7.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fffa369a668c8af7dbf8b5e56c9f744fbd399949ed171606040001947de40b1c"
+dependencies = [
+ "const-oid",
+ "zeroize",
+]
+
 [[package]]
 name = "deranged"
 version = "0.3.11"
@@ -1067,17 +1081,30 @@ version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "212d0f5754cb6769937f4501cc0e67f4f4483c8d2c3e1e922ee9edbe4ab4c7c0"
 
+[[package]]
+name = "ed25519"
+version = "2.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "115531babc129696a58c64a4fef0a8bf9e9698629fb97e9e40767d235cfbcd53"
+dependencies = [
+ "pkcs8",
+ "serde",
+ "signature",
+]
+
 [[package]]
 name = "ed25519-dalek"
-version = "1.0.0-pre.3"
+version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "978710b352437433c97b2bff193f2fb1dfd58a093f863dd95e225a19baa599a2"
+checksum = "4a3daa8e81a3963a60642bcc1f90a670680bd4a77535faa384e9d1c79d620871"
 dependencies = [
- "clear_on_drop",
- "curve25519-dalek",
- "rand 0.7.3",
+ "curve25519-dalek 4.1.2",
+ "ed25519",
+ "rand_core 0.6.4",
  "serde",
- "sha2 0.8.2",
+ "sha2 0.10.8",
+ "subtle",
+ "zeroize",
 ]
 
 [[package]]
@@ -1171,12 +1198,6 @@ dependencies = [
  "syn 1.0.109",
 ]
 
-[[package]]
-name = "fake-simd"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e88a8acf291dafb59c2d96e8f59828f3838bb1a70398823ade51a84de6a6deed"
-
 [[package]]
 name = "fallible-iterator"
 version = "0.2.0"
@@ -1204,6 +1225,12 @@ version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "25cbce373ec4653f1a01a31e8a5e5ec0c622dc27ff9c4e6606eefef5cbbed4a5"
 
+[[package]]
+name = "fiat-crypto"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1676f435fc1dadde4d03e43f5d62b259e1ce5f40bd4ffb21db2b42ebe59c1382"
+
 [[package]]
 name = "fixed-hash"
 version = "0.8.0"
@@ -1423,7 +1450,7 @@ version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "97304e4cd182c3846f7575ced3890c53012ce534ad9114046b0a9e00bb30a375"
 dependencies = [
- "opaque-debug 0.3.0",
+ "opaque-debug",
  "polyval 0.4.5",
 ]
 
@@ -1433,7 +1460,7 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d930750de5717d2dd0b8c0d42c076c0e884c81a73e6cab859bbd2339c71e3e40"
 dependencies = [
- "opaque-debug 0.3.0",
+ "opaque-debug",
  "polyval 0.6.1",
 ]
 
@@ -2179,12 +2206,6 @@ version = "11.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0ab1bc2a289d34bd04a330323ac98a1b4bc82c9d9fcb1e66b63caa84da26b575"
 
-[[package]]
-name = "opaque-debug"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2839e79665f131bdb5782e51f2c6c9599c133c6098982a54c794358bf432529c"
-
 [[package]]
 name = "opaque-debug"
 version = "0.3.0"
@@ -2340,12 +2361,28 @@ dependencies = [
  "futures-io",
 ]
 
+[[package]]
+name = "pkcs8"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7"
+dependencies = [
+ "der",
+ "spki",
+]
+
 [[package]]
 name = "pkg-config"
 version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d231b230927b5e4ad203db57bbcbee2802f6bce620b1e4a9024a07d94e2907ec"
 
+[[package]]
+name = "platforms"
+version = "3.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "626dec3cac7cc0e1577a2ec3fc496277ec2baa084bebad95bb6fdbfae235f84c"
+
 [[package]]
 name = "plotters"
 version = "0.3.5"
@@ -2421,7 +2458,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "eebcc4aa140b9abd2bc40d9c3f7ccec842679cd79045ac3a7ac698c1a064b7cd"
 dependencies = [
  "cpuid-bool",
- "opaque-debug 0.3.0",
+ "opaque-debug",
  "universal-hash 0.4.0",
 ]
 
@@ -2433,7 +2470,7 @@ checksum = "d52cff9d1d4dee5fe6d03729099f4a310a41179e0a10dbf542039873f2e826fb"
 dependencies = [
  "cfg-if 1.0.0",
  "cpufeatures",
- "opaque-debug 0.3.0",
+ "opaque-debug",
  "universal-hash 0.5.1",
 ]
 
@@ -3229,18 +3266,6 @@ version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ae1a47186c03a32177042e55dbc5fd5aee900b8e0069a8d70fba96a9375cd012"
 
-[[package]]
-name = "sha2"
-version = "0.8.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a256f46ea78a0c0d9ff00077504903ac881a1dafdc20da66545699e7776b3e69"
-dependencies = [
- "block-buffer 0.7.3",
- "digest 0.8.1",
- "fake-simd",
- "opaque-debug 0.2.3",
-]
-
 [[package]]
 name = "sha2"
 version = "0.9.9"
@@ -3251,7 +3276,7 @@ dependencies = [
  "cfg-if 1.0.0",
  "cpufeatures",
  "digest 0.9.0",
- "opaque-debug 0.3.0",
+ "opaque-debug",
 ]
 
 [[package]]
@@ -3303,6 +3328,15 @@ dependencies = [
  "lazy_static",
 ]
 
+[[package]]
+name = "signature"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de"
+dependencies = [
+ "rand_core 0.6.4",
+]
+
 [[package]]
 name = "siphasher"
 version = "0.3.11"
@@ -3387,6 +3421,16 @@ version = "0.9.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67"
 
+[[package]]
+name = "spki"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d"
+dependencies = [
+ "base64ct",
+ "der",
+]
+
 [[package]]
 name = "stacker"
 version = "0.1.15"
@@ -3406,13 +3450,13 @@ version = "0.0.1"
 dependencies = [
  "assert-json-diff",
  "chrono",
- "curve25519-dalek",
+ "curve25519-dalek 2.0.0",
  "ed25519-dalek",
  "lazy_static",
  "libc",
  "nix",
  "percent-encoding",
- "rand 0.7.3",
+ "rand 0.8.5",
  "rand_core 0.6.4",
  "ripemd",
  "rstest 0.11.0",
@@ -3510,7 +3554,7 @@ dependencies = [
  "chrono",
  "clarity",
  "criterion",
- "curve25519-dalek",
+ "curve25519-dalek 2.0.0",
  "ed25519-dalek",
  "hashbrown 0.14.3",
  "integer-sqrt",
diff --git a/Cargo.toml b/Cargo.toml
index 265dc3cee5..e7dea22299 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -15,8 +15,10 @@ members = [
 # Dependencies we want to keep the same between workspace members
 [workspace.dependencies]  
 wsts = { version = "8.0", default-features = false }
+ed25519-dalek = { version = "2.1.1", features = ["serde", "rand_core"] } 
 rand_core = "0.6"
 rand = "0.8"
+rand_chacha = "0.3.1"
 
 # Use a bit more than default optimization for
 #  dev builds to speed up test execution
diff --git a/clarity/Cargo.toml b/clarity/Cargo.toml
index 86089991dc..eb8bcad388 100644
--- a/clarity/Cargo.toml
+++ b/clarity/Cargo.toml
@@ -18,8 +18,8 @@ name = "clarity"
 path = "./src/libclarity.rs"
 
 [dependencies]
-rand = "0.7.3"
-rand_chacha = "=0.2.2"
+rand = { workspace = true }
+rand_chacha = { workspace = true }
 serde = "1"
 serde_derive = "1"
 serde_stacker = "0.1"
diff --git a/stacks-common/Cargo.toml b/stacks-common/Cargo.toml
index 1916572cf4..0896442d7a 100644
--- a/stacks-common/Cargo.toml
+++ b/stacks-common/Cargo.toml
@@ -18,7 +18,7 @@ name = "stacks_common"
 path = "./src/libcommon.rs"
 
 [dependencies]
-rand = "0.7.3"
+rand = { workspace = true }
 serde = "1"
 serde_derive = "1"
 serde_stacker = "0.1"
@@ -55,8 +55,7 @@ version = "=0.24.2"
 features = ["blob", "serde_json", "i128_blob", "bundled", "trace"]
 
 [dependencies.ed25519-dalek]
-version = "=1.0.0-pre.3"
-features = ["serde"]
+workspace = true
 
 [dependencies.curve25519-dalek]
 version = "=2.0.0"
@@ -70,7 +69,7 @@ features = ["std"]
 rstest = "0.11.0"
 rstest_reuse = "0.1.3"
 assert-json-diff = "1.0.0"
-rand_core = "0.6"
+rand_core = { workspace = true }
 
 [features]
 default = ["developer-mode"]
diff --git a/stacks-common/src/address/c32.rs b/stacks-common/src/address/c32.rs
index 60fa7e6552..3b0141847a 100644
--- a/stacks-common/src/address/c32.rs
+++ b/stacks-common/src/address/c32.rs
@@ -381,7 +381,7 @@ mod test {
     fn old_c32_validation() {
         for n in 0..5000 {
             // random version
-            let random_version: u8 = rand::thread_rng().gen_range(0, 31);
+            let random_version: u8 = rand::thread_rng().gen_range(0..31);
 
             // random 20 bytes
             let random_bytes = rand::thread_rng().gen::<[u8; 20]>();
diff --git a/stacks-common/src/util/vrf.rs b/stacks-common/src/util/vrf.rs
index 3553275414..410c4a07e2 100644
--- a/stacks-common/src/util/vrf.rs
+++ b/stacks-common/src/util/vrf.rs
@@ -31,7 +31,7 @@ use curve25519_dalek::constants::ED25519_BASEPOINT_POINT;
 use curve25519_dalek::edwards::{CompressedEdwardsY, EdwardsPoint};
 use curve25519_dalek::scalar::Scalar as ed25519_Scalar;
 use ed25519_dalek::{
-    Keypair as VRFKeypair, PublicKey as ed25519_PublicKey, SecretKey as ed25519_PrivateKey,
+    SecretKey as EdDalekSecretKeyBytes, SigningKey as EdPrivateKey, VerifyingKey as EdPublicKey,
 };
 use rand;
 use sha2::{Digest, Sha512};
@@ -39,9 +39,10 @@ use sha2::{Digest, Sha512};
 use crate::util::hash::{hex_bytes, to_hex};
 
 #[derive(Clone)]
-pub struct VRFPublicKey(pub ed25519_PublicKey);
+pub struct VRFPublicKey(pub ed25519_dalek::VerifyingKey);
 
-pub struct VRFPrivateKey(pub ed25519_PrivateKey);
+#[derive(Clone)]
+pub struct VRFPrivateKey(pub ed25519_dalek::SigningKey);
 
 impl serde::Serialize for VRFPublicKey {
     fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
@@ -58,29 +59,6 @@ impl<'de> serde::Deserialize<'de> for VRFPublicKey {
     }
 }
 
-// have to do Clone separately since ed25519_PrivateKey doesn't implement Clone
-impl Clone for VRFPrivateKey {
-    fn clone(&self) -> VRFPrivateKey {
-        let bytes = self.to_bytes();
-        let pk = ed25519_PrivateKey::from_bytes(&bytes)
-            .expect("FATAL: could not do VRFPrivateKey round-trip");
-        VRFPrivateKey(pk)
-    }
-}
-
-impl Deref for VRFPublicKey {
-    type Target = ed25519_PublicKey;
-    fn deref(&self) -> &ed25519_PublicKey {
-        &self.0
-    }
-}
-
-impl DerefMut for VRFPublicKey {
-    fn deref_mut(&mut self) -> &mut ed25519_PublicKey {
-        &mut self.0
-    }
-}
-
 impl Debug for VRFPublicKey {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{}", &self.to_hex())
@@ -113,19 +91,6 @@ impl Hash for VRFPublicKey {
     }
 }
 
-impl Deref for VRFPrivateKey {
-    type Target = ed25519_PrivateKey;
-    fn deref(&self) -> &ed25519_PrivateKey {
-        &self.0
-    }
-}
-
-impl DerefMut for VRFPrivateKey {
-    fn deref_mut(&mut self) -> &mut ed25519_PrivateKey {
-        &mut self.0
-    }
-}
-
 impl Debug for VRFPrivateKey {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{}", &self.to_hex())
@@ -149,71 +114,76 @@ impl Default for VRFPrivateKey {
 impl VRFPrivateKey {
     pub fn new() -> VRFPrivateKey {
         let mut rng = rand::thread_rng();
-        let keypair: VRFKeypair = VRFKeypair::generate(&mut rng);
-        VRFPrivateKey(keypair.secret)
+        let signing_key = ed25519_dalek::SigningKey::generate(&mut rng);
+        VRFPrivateKey(signing_key)
     }
 
     pub fn from_hex(h: &str) -> Option<VRFPrivateKey> {
-        match hex_bytes(h) {
-            Ok(b) => match ed25519_PrivateKey::from_bytes(&b[..]) {
-                Ok(pk) => Some(VRFPrivateKey(pk)),
-                Err(_) => None,
-            },
-            Err(_) => None,
-        }
+        let bytes = hex_bytes(h).ok()?;
+        Self::from_bytes(bytes.as_slice())
     }
 
     pub fn from_bytes(b: &[u8]) -> Option<VRFPrivateKey> {
-        match ed25519_PrivateKey::from_bytes(b) {
-            Ok(pk) => Some(VRFPrivateKey(pk)),
-            Err(_) => None,
-        }
+        let signing_key = ed25519_dalek::SigningKey::try_from(b).ok()?;
+        Some(VRFPrivateKey(signing_key))
     }
 
     pub fn to_hex(&self) -> String {
         to_hex(self.as_bytes())
     }
+
+    pub fn as_bytes(&self) -> &[u8] {
+        self.0.as_bytes()
+    }
+
+    pub fn to_bytes(&self) -> [u8; 32] {
+        self.0.to_bytes()
+    }
 }
 
 impl VRFPublicKey {
-    pub fn from_private(pk: &VRFPrivateKey) -> VRFPublicKey {
-        VRFPublicKey(ed25519_PublicKey::from(&pk.0))
+    pub fn from_private(sk: &VRFPrivateKey) -> VRFPublicKey {
+        VRFPublicKey(sk.0.verifying_key())
     }
 
+    /// Verify that a given byte string is a well-formed EdDSA public
+    /// key (i.e. it's a compressed Edwards point that is valid), and return
+    /// a VRFPublicKey if so
     pub fn from_bytes(pubkey_bytes: &[u8]) -> Option<VRFPublicKey> {
-        match pubkey_bytes.len() {
-            32 => {
-                let mut pubkey_slice = [0; 32];
-                pubkey_slice.copy_from_slice(&pubkey_bytes[0..32]);
-
-                let checked_pubkey = CompressedEdwardsY(pubkey_slice);
-                match checked_pubkey.decompress() {
-                    Some(_) => {}
-                    None => {
-                        // invalid
-                        return None;
-                    }
-                }
-
-                match ed25519_PublicKey::from_bytes(&pubkey_slice) {
-                    Ok(key) => Some(VRFPublicKey(key)),
-                    Err(_) => None,
-                }
-            }
-            _ => None,
+        let pubkey_slice = pubkey_bytes.try_into().ok()?;
+
+        // NOTE: `ed25519_dalek::VerifyingKey::from_bytes` docs say
+        //  that this check must be performed by the caller, but as of
+        //  latest, it actually performs the check as well. However,
+        //  we do this check out of an abundance of caution because
+        //  that's what the docs say to do!
+
+        let checked_pubkey = CompressedEdwardsY(pubkey_slice);
+        if checked_pubkey.decompress().is_none() {
+            // invalid
+            return None;
         }
+
+        let key = ed25519_dalek::VerifyingKey::from_bytes(&pubkey_slice).ok()?;
+        Some(VRFPublicKey(key))
     }
 
     pub fn from_hex(h: &str) -> Option<VRFPublicKey> {
-        match hex_bytes(h) {
-            Ok(b) => VRF::check_public_key(&b),
-            Err(_) => None,
-        }
+        let bytes = hex_bytes(h).ok()?;
+        Self::from_bytes(bytes.as_slice())
     }
 
     pub fn to_hex(&self) -> String {
         to_hex(self.as_bytes())
     }
+
+    pub fn as_bytes(&self) -> &[u8] {
+        self.0.as_bytes()
+    }
+
+    pub fn to_bytes(&self) -> [u8; 32] {
+        self.0.to_bytes()
+    }
 }
 
 #[derive(Debug)]
@@ -565,15 +535,6 @@ impl VRF {
         // NOTE: this leverages constant-time comparison inherited from the Scalar impl
         Ok(c_prime == *(proof.c()))
     }
-
-    /// Verify that a given byte string is a well-formed EdDSA public key (i.e. it's a compressed
-    /// Edwards point that is valid).
-    pub fn check_public_key(pubkey_bytes: &Vec<u8>) -> Option<VRFPublicKey> {
-        match pubkey_bytes.len() {
-            32 => VRFPublicKey::from_bytes(&pubkey_bytes[..]),
-            _ => None,
-        }
-    }
 }
 
 #[cfg(test)]
@@ -714,14 +675,14 @@ mod tests {
 
     #[test]
     fn check_valid_public_key() {
-        let res1 = VRF::check_public_key(
+        let res1 = VRFPublicKey::from_bytes(
             &hex_bytes("a366b51292bef4edd64063d9145c617fec373bceb0758e98cd72becd84d54c7a")
                 .unwrap()
                 .to_vec(),
         );
         assert!(res1.is_some());
 
-        let res2 = VRF::check_public_key(
+        let res2 = VRFPublicKey::from_bytes(
             &hex_bytes("a366b51292bef4edd64063d9145c617fec373bceb0758e98cd72becd84d54c7b")
                 .unwrap()
                 .to_vec(),
diff --git a/stackslib/Cargo.toml b/stackslib/Cargo.toml
index cf62a80217..d1da07b0b8 100644
--- a/stackslib/Cargo.toml
+++ b/stackslib/Cargo.toml
@@ -33,7 +33,7 @@ path = "src/blockstack_cli.rs"
 [dependencies]
 rand = { workspace = true }
 rand_core = { workspace = true }
-rand_chacha = "0.3.1"
+rand_chacha = { workspace = true }
 serde = "1"
 serde_derive = "1"
 serde_stacker = "0.1"
@@ -81,8 +81,7 @@ version = "=0.24.2"
 features = ["blob", "serde_json", "i128_blob", "bundled", "trace"]
 
 [dependencies.ed25519-dalek]
-version = "=1.0.0-pre.3"
-features = ["serde"]
+workspace = true
 
 [dependencies.curve25519-dalek]
 version = "=2.0.0"
diff --git a/stackslib/src/burnchains/tests/burnchain.rs b/stackslib/src/burnchains/tests/burnchain.rs
index 38f95a17a3..1b2b7ded9f 100644
--- a/stackslib/src/burnchains/tests/burnchain.rs
+++ b/stackslib/src/burnchains/tests/burnchain.rs
@@ -14,7 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use ed25519_dalek::Keypair as VRFKeypair;
 use rand::rngs::ThreadRng;
 use rand_chacha::ChaChaRng;
 use rand_core::SeedableRng;
@@ -868,12 +867,13 @@ fn test_burn_snapshot_sequence() {
 
     for i in 0..32 {
         let mut csprng = ChaChaRng::from_seed(Default::default());
-        let keypair: VRFKeypair = VRFKeypair::generate(&mut csprng);
+        let vrf_privkey = VRFPrivateKey(ed25519_dalek::SigningKey::generate(&mut csprng));
+        let vrf_pubkey = VRFPublicKey::from_private(&vrf_privkey);
 
-        let privkey_hex = to_hex(&keypair.secret.to_bytes());
+        let privkey_hex = vrf_privkey.to_hex();
         leader_private_keys.push(privkey_hex);
 
-        let pubkey_hex = to_hex(&keypair.public.to_bytes());
+        let pubkey_hex = vrf_pubkey.to_hex();
         leader_public_keys.push(pubkey_hex);
 
         let bitcoin_privkey = Secp256k1PrivateKey::new();

From 881993c5a9c669f45cdfb2afdc7b1db87924aa23 Mon Sep 17 00:00:00 2001
From: ASuciuX <asuciu@hiro.so>
Date: Thu, 15 Feb 2024 18:44:11 +0200
Subject: [PATCH 0773/1166] feat: skip mutants on functions that previously
 timed out

---
 Cargo.lock                                    |   7 +
 mutants.out.old/caught.txt                    |   0
 mutants.out.old/lock.json                     |   6 +
 mutants.out.old/missed.txt                    |   0
 mutants.out.old/mutants.json                  | 212 ++++++++++++++++++
 mutants.out.old/timeout.txt                   |   0
 mutants.out.old/unviable.txt                  |   0
 mutants.out/caught.txt                        |   0
 mutants.out/lock.json                         |   6 +
 mutants.out/missed.txt                        |   0
 mutants.out/mutants.json                      |   1 +
 mutants.out/timeout.txt                       |   0
 mutants.out/unviable.txt                      |   0
 stackslib/Cargo.toml                          |   1 +
 stackslib/src/burnchains/affirmation.rs       |   1 +
 stackslib/src/chainstate/burn/db/sortdb.rs    |   7 +
 .../burn/operations/leader_block_commit.rs    |   1 +
 stackslib/src/chainstate/coordinator/mod.rs   |   3 +
 stackslib/src/chainstate/stacks/mod.rs        |   3 +
 stackslib/src/core/mempool.rs                 |   8 +
 stackslib/src/net/api/getblock.rs             |   1 +
 stackslib/src/net/api/getheaders.rs           |   1 +
 .../src/net/api/getmicroblocks_indexed.rs     |   1 +
 stackslib/src/net/api/postmempoolquery.rs     |   2 +
 stackslib/src/net/api/poststackerdbchunk.rs   |   1 +
 stackslib/src/net/chat.rs                     |   1 +
 stackslib/src/net/connection.rs               |   5 +
 stackslib/src/net/db.rs                       |   5 +
 stackslib/src/net/http/response.rs            |   1 +
 stackslib/src/net/http/stream.rs              |   1 +
 stackslib/src/net/httpcore.rs                 |   1 +
 stackslib/src/net/inv/epoch2x.rs              |   4 +
 stackslib/src/net/neighbors/comms.rs          |   2 +
 stackslib/src/net/p2p.rs                      |  11 +
 stackslib/src/net/poll.rs                     |   1 +
 stackslib/src/net/rpc.rs                      |   3 +
 stackslib/src/net/server.rs                   |   8 +
 stackslib/src/net/stackerdb/mod.rs            |   1 +
 38 files changed, 306 insertions(+)
 create mode 100644 mutants.out.old/caught.txt
 create mode 100644 mutants.out.old/lock.json
 create mode 100644 mutants.out.old/missed.txt
 create mode 100644 mutants.out.old/mutants.json
 create mode 100644 mutants.out.old/timeout.txt
 create mode 100644 mutants.out.old/unviable.txt
 create mode 100644 mutants.out/caught.txt
 create mode 100644 mutants.out/lock.json
 create mode 100644 mutants.out/missed.txt
 create mode 100644 mutants.out/mutants.json
 create mode 100644 mutants.out/timeout.txt
 create mode 100644 mutants.out/unviable.txt

diff --git a/Cargo.lock b/Cargo.lock
index 41c2c8e924..310598ff21 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2077,6 +2077,12 @@ dependencies = [
  "version_check",
 ]
 
+[[package]]
+name = "mutants"
+version = "0.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc0287524726960e07b119cebd01678f852f147742ae0d925e6a520dca956126"
+
 [[package]]
 name = "net2"
 version = "0.2.38"
@@ -3448,6 +3454,7 @@ dependencies = [
  "libc",
  "libstackerdb",
  "mio 0.6.23",
+ "mutants",
  "nix",
  "percent-encoding",
  "pox-locking",
diff --git a/mutants.out.old/caught.txt b/mutants.out.old/caught.txt
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/mutants.out.old/lock.json b/mutants.out.old/lock.json
new file mode 100644
index 0000000000..d8d9a04b19
--- /dev/null
+++ b/mutants.out.old/lock.json
@@ -0,0 +1,6 @@
+{
+  "cargo_mutants_version": "24.2.0",
+  "start_time": "2024-02-15T16:19:43.977743Z",
+  "hostname": "alin-suciu-xy7ww74xhv.local",
+  "username": "asuciu"
+}
\ No newline at end of file
diff --git a/mutants.out.old/missed.txt b/mutants.out.old/missed.txt
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/mutants.out.old/mutants.json b/mutants.out.old/mutants.json
new file mode 100644
index 0000000000..545bda3d6f
--- /dev/null
+++ b/mutants.out.old/mutants.json
@@ -0,0 +1,212 @@
+[
+  {
+    "package": "stackslib",
+    "file": "stackslib/src/net/chat.rs",
+    "function": {
+      "function_name": "ConversationP2P::supports_mempool_query",
+      "return_type": "-> bool",
+      "span": {
+        "start": {
+          "line": 669,
+          "column": 5
+        },
+        "end": {
+          "line": 675,
+          "column": 6
+        }
+      }
+    },
+    "span": {
+      "start": {
+        "line": 673,
+        "column": 58
+      },
+      "end": {
+        "line": 673,
+        "column": 59
+      }
+    },
+    "replacement": "&",
+    "genre": "BinaryOperator"
+  },
+  {
+    "package": "stackslib",
+    "file": "stackslib/src/net/chat.rs",
+    "function": {
+      "function_name": "ConversationP2P::supports_mempool_query",
+      "return_type": "-> bool",
+      "span": {
+        "start": {
+          "line": 669,
+          "column": 5
+        },
+        "end": {
+          "line": 675,
+          "column": 6
+        }
+      }
+    },
+    "span": {
+      "start": {
+        "line": 674,
+        "column": 24
+      },
+      "end": {
+        "line": 674,
+        "column": 25
+      }
+    },
+    "replacement": "^",
+    "genre": "BinaryOperator"
+  },
+  {
+    "package": "stackslib",
+    "file": "stackslib/src/net/chat.rs",
+    "function": {
+      "function_name": "ConversationP2P::supports_mempool_query",
+      "return_type": "-> bool",
+      "span": {
+        "start": {
+          "line": 669,
+          "column": 5
+        },
+        "end": {
+          "line": 675,
+          "column": 6
+        }
+      }
+    },
+    "span": {
+      "start": {
+        "line": 673,
+        "column": 9
+      },
+      "end": {
+        "line": 674,
+        "column": 57
+      }
+    },
+    "replacement": "false",
+    "genre": "FnValue"
+  },
+  {
+    "package": "stackslib",
+    "file": "stackslib/src/net/chat.rs",
+    "function": {
+      "function_name": "ConversationP2P::supports_mempool_query",
+      "return_type": "-> bool",
+      "span": {
+        "start": {
+          "line": 669,
+          "column": 5
+        },
+        "end": {
+          "line": 675,
+          "column": 6
+        }
+      }
+    },
+    "span": {
+      "start": {
+        "line": 673,
+        "column": 58
+      },
+      "end": {
+        "line": 673,
+        "column": 59
+      }
+    },
+    "replacement": "^",
+    "genre": "BinaryOperator"
+  },
+  {
+    "package": "stackslib",
+    "file": "stackslib/src/net/chat.rs",
+    "function": {
+      "function_name": "ConversationP2P::supports_mempool_query",
+      "return_type": "-> bool",
+      "span": {
+        "start": {
+          "line": 669,
+          "column": 5
+        },
+        "end": {
+          "line": 675,
+          "column": 6
+        }
+      }
+    },
+    "span": {
+      "start": {
+        "line": 674,
+        "column": 41
+      },
+      "end": {
+        "line": 674,
+        "column": 43
+      }
+    },
+    "replacement": "!=",
+    "genre": "BinaryOperator"
+  },
+  {
+    "package": "stackslib",
+    "file": "stackslib/src/net/chat.rs",
+    "function": {
+      "function_name": "ConversationP2P::supports_mempool_query",
+      "return_type": "-> bool",
+      "span": {
+        "start": {
+          "line": 669,
+          "column": 5
+        },
+        "end": {
+          "line": 675,
+          "column": 6
+        }
+      }
+    },
+    "span": {
+      "start": {
+        "line": 674,
+        "column": 24
+      },
+      "end": {
+        "line": 674,
+        "column": 25
+      }
+    },
+    "replacement": "|",
+    "genre": "BinaryOperator"
+  },
+  {
+    "package": "stackslib",
+    "file": "stackslib/src/net/chat.rs",
+    "function": {
+      "function_name": "ConversationP2P::supports_mempool_query",
+      "return_type": "-> bool",
+      "span": {
+        "start": {
+          "line": 669,
+          "column": 5
+        },
+        "end": {
+          "line": 675,
+          "column": 6
+        }
+      }
+    },
+    "span": {
+      "start": {
+        "line": 673,
+        "column": 9
+      },
+      "end": {
+        "line": 674,
+        "column": 57
+      }
+    },
+    "replacement": "true",
+    "genre": "FnValue"
+  }
+]
\ No newline at end of file
diff --git a/mutants.out.old/timeout.txt b/mutants.out.old/timeout.txt
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/mutants.out.old/unviable.txt b/mutants.out.old/unviable.txt
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/mutants.out/caught.txt b/mutants.out/caught.txt
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/mutants.out/lock.json b/mutants.out/lock.json
new file mode 100644
index 0000000000..49e607ccff
--- /dev/null
+++ b/mutants.out/lock.json
@@ -0,0 +1,6 @@
+{
+  "cargo_mutants_version": "24.2.0",
+  "start_time": "2024-02-15T16:19:43.980203Z",
+  "hostname": "alin-suciu-xy7ww74xhv.local",
+  "username": "asuciu"
+}
\ No newline at end of file
diff --git a/mutants.out/missed.txt b/mutants.out/missed.txt
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/mutants.out/mutants.json b/mutants.out/mutants.json
new file mode 100644
index 0000000000..0637a088a0
--- /dev/null
+++ b/mutants.out/mutants.json
@@ -0,0 +1 @@
+[]
\ No newline at end of file
diff --git a/mutants.out/timeout.txt b/mutants.out/timeout.txt
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/mutants.out/unviable.txt b/mutants.out/unviable.txt
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/stackslib/Cargo.toml b/stackslib/Cargo.toml
index c5411353e2..ae26c77ba4 100644
--- a/stackslib/Cargo.toml
+++ b/stackslib/Cargo.toml
@@ -101,6 +101,7 @@ clarity = { features = ["default", "testing"], path = "../clarity" }
 stacks-common = { features = ["default", "testing"], path = "../stacks-common" }
 rstest = "0.17.0"
 rstest_reuse = "0.5.0"
+mutants = "0.0.3"
 
 [features]
 default = []
diff --git a/stackslib/src/burnchains/affirmation.rs b/stackslib/src/burnchains/affirmation.rs
index b7a83f2f1b..f83c0eabf5 100644
--- a/stackslib/src/burnchains/affirmation.rs
+++ b/stackslib/src/burnchains/affirmation.rs
@@ -370,6 +370,7 @@ impl AffirmationMap {
         self.affirmations.push(entry)
     }
 
+    #[cfg_attr(test, mutants::skip)]
     pub fn pop(&mut self) -> Option<AffirmationMapEntry> {
         self.affirmations.pop()
     }
diff --git a/stackslib/src/chainstate/burn/db/sortdb.rs b/stackslib/src/chainstate/burn/db/sortdb.rs
index e67b21231a..7696cbcfac 100644
--- a/stackslib/src/chainstate/burn/db/sortdb.rs
+++ b/stackslib/src/chainstate/burn/db/sortdb.rs
@@ -3080,6 +3080,7 @@ impl SortitionDB {
     }
 
     /// Get the height of a consensus hash, even if it's not on the canonical PoX fork.
+    #[cfg_attr(test, mutants::skip)]
     pub fn get_consensus_hash_height(&self, ch: &ConsensusHash) -> Result<Option<u64>, db_error> {
         let qry = "SELECT block_height FROM snapshots WHERE consensus_hash = ?1";
         let mut heights: Vec<u64> = query_rows(self.conn(), qry, &[ch])?;
@@ -3263,6 +3264,7 @@ impl SortitionDB {
         Ok(())
     }
 
+    #[cfg_attr(test, mutants::skip)]
     fn apply_schema_5(tx: &DBTx, epochs: &[StacksEpoch]) -> Result<(), db_error> {
         // the schema 5 changes simply **replace** the contents of the epochs table
         //  by dropping all the current rows and then revalidating and inserting
@@ -3281,6 +3283,7 @@ impl SortitionDB {
         Ok(())
     }
 
+    #[cfg_attr(test, mutants::skip)]
     fn apply_schema_6(tx: &DBTx, epochs: &[StacksEpoch]) -> Result<(), db_error> {
         for sql_exec in SORTITION_DB_SCHEMA_6 {
             tx.execute_batch(sql_exec)?;
@@ -3296,6 +3299,7 @@ impl SortitionDB {
         Ok(())
     }
 
+    #[cfg_attr(test, mutants::skip)]
     fn apply_schema_7(tx: &DBTx, epochs: &[StacksEpoch]) -> Result<(), db_error> {
         for sql_exec in SORTITION_DB_SCHEMA_7 {
             tx.execute_batch(sql_exec)?;
@@ -3677,6 +3681,7 @@ impl<'a> SortitionDBConn<'a> {
         Ok(Some(parent_block_snapshot))
     }
 
+    #[cfg_attr(test, mutants::skip)]
     pub fn get_reward_set_size_at(&mut self, sortition_id: &SortitionId) -> Result<u16, db_error> {
         self.get_indexed(sortition_id, &db_keys::pox_reward_set_size())
             .map(|x| {
@@ -3785,6 +3790,7 @@ impl SortitionDB {
 
     /// Mark a Stacks block snapshot as valid again, but update its memoized canonical Stacks tip
     /// height and block-accepted flag.
+    #[cfg_attr(test, mutants::skip)]
     pub fn revalidate_snapshot_with_block(
         tx: &DBTx,
         sortition_id: &SortitionId,
@@ -4154,6 +4160,7 @@ impl SortitionDB {
         Ok(result.is_some())
     }
 
+    #[cfg_attr(test, mutants::skip)]
     pub fn latest_stacks_blocks_processed(
         &self,
         sortition_id: &SortitionId,
diff --git a/stackslib/src/chainstate/burn/operations/leader_block_commit.rs b/stackslib/src/chainstate/burn/operations/leader_block_commit.rs
index 5f16b87d13..ed50fb2d57 100644
--- a/stackslib/src/chainstate/burn/operations/leader_block_commit.rs
+++ b/stackslib/src/chainstate/burn/operations/leader_block_commit.rs
@@ -238,6 +238,7 @@ impl LeaderBlockCommitOp {
         )
     }
 
+    #[cfg_attr(test, mutants::skip)]
     pub fn is_parent_genesis(&self) -> bool {
         self.parent_block_ptr == 0 && self.parent_vtxindex == 0
     }
diff --git a/stackslib/src/chainstate/coordinator/mod.rs b/stackslib/src/chainstate/coordinator/mod.rs
index 8690ce97ed..a59df5185e 100644
--- a/stackslib/src/chainstate/coordinator/mod.rs
+++ b/stackslib/src/chainstate/coordinator/mod.rs
@@ -3022,6 +3022,7 @@ impl<
 
     /// Try and replay a newly-discovered (or re-affirmed) sortition's associated Stacks block, if
     /// we have it.
+    #[cfg_attr(test, mutants::skip)]
     fn try_replay_stacks_block(
         &mut self,
         canonical_snapshot: &BlockSnapshot,
@@ -3124,6 +3125,7 @@ impl<
     /// block."
     ///
     /// Returning None means "we can keep processing Stacks blocks"
+    #[cfg_attr(test, mutants::skip)]
     fn consider_pox_anchor(
         &self,
         pox_anchor: &BlockHeaderHash,
@@ -3453,6 +3455,7 @@ pub fn check_chainstate_db_versions(
 
 /// Migrate all databases to their latest schemas.
 /// Verifies that this is possible as well
+#[cfg_attr(test, mutants::skip)]
 pub fn migrate_chainstate_dbs(
     epochs: &[StacksEpoch],
     sortdb_path: &str,
diff --git a/stackslib/src/chainstate/stacks/mod.rs b/stackslib/src/chainstate/stacks/mod.rs
index 0224631dbd..d3c304a615 100644
--- a/stackslib/src/chainstate/stacks/mod.rs
+++ b/stackslib/src/chainstate/stacks/mod.rs
@@ -226,6 +226,7 @@ impl fmt::Display for Error {
 }
 
 impl error::Error for Error {
+    #[cfg_attr(test, mutants::skip)]
     fn cause(&self) -> Option<&dyn error::Error> {
         match *self {
             Error::InvalidFee => None,
@@ -268,6 +269,7 @@ impl error::Error for Error {
 }
 
 impl Error {
+    #[cfg_attr(test, mutants::skip)]
     fn name(&self) -> &'static str {
         match self {
             Error::InvalidFee => "InvalidFee",
@@ -308,6 +310,7 @@ impl Error {
         }
     }
 
+    #[cfg_attr(test, mutants::skip)]
     pub fn into_json(&self) -> serde_json::Value {
         let reason_code = self.name();
         let reason_data = format!("{:?}", &self);
diff --git a/stackslib/src/core/mempool.rs b/stackslib/src/core/mempool.rs
index c29d3a686e..a1135989a4 100644
--- a/stackslib/src/core/mempool.rs
+++ b/stackslib/src/core/mempool.rs
@@ -1197,6 +1197,7 @@ impl CandidateCache {
     }
 
     /// Total length of the cache.
+    #[cfg_attr(test, mutants::skip)]
     fn len(&self) -> usize {
         self.cache.len() + self.next.len()
     }
@@ -1301,6 +1302,7 @@ impl MemPoolDB {
     }
 
     /// Add indexes
+    #[cfg_attr(test, mutants::skip)]
     fn add_indexes(tx: &mut DBTx) -> Result<(), db_error> {
         for cmd in MEMPOOL_INDEXES {
             tx.execute_batch(cmd).map_err(db_error::SqliteError)?;
@@ -1309,6 +1311,7 @@ impl MemPoolDB {
     }
 
     /// Instantiate the on-disk counting bloom filter
+    #[cfg_attr(test, mutants::skip)]
     fn instantiate_bloom_state(tx: &mut DBTx) -> Result<(), db_error> {
         let node_hasher = BloomNodeHasher::new_random();
         let _ = BloomCounter::new(
@@ -1326,6 +1329,7 @@ impl MemPoolDB {
     }
 
     /// Instantiate the cost estimator schema
+    #[cfg_attr(test, mutants::skip)]
     fn instantiate_cost_estimator(tx: &DBTx) -> Result<(), db_error> {
         for sql_exec in MEMPOOL_SCHEMA_2_COST_ESTIMATOR {
             tx.execute_batch(sql_exec)?;
@@ -1344,6 +1348,7 @@ impl MemPoolDB {
     }
 
     /// Instantiate the tx blacklist schema
+    #[cfg_attr(test, mutants::skip)]
     fn instantiate_tx_blacklist(tx: &DBTx) -> Result<(), db_error> {
         for sql_exec in MEMPOOL_SCHEMA_4_BLACKLIST {
             tx.execute_batch(sql_exec)?;
@@ -1353,6 +1358,7 @@ impl MemPoolDB {
     }
 
     /// Add the nonce table
+    #[cfg_attr(test, mutants::skip)]
     fn instantiate_nonces(tx: &DBTx) -> Result<(), db_error> {
         for sql_exec in MEMPOOL_SCHEMA_6_NONCES {
             tx.execute_batch(sql_exec)?;
@@ -1361,6 +1367,7 @@ impl MemPoolDB {
         Ok(())
     }
 
+    #[cfg_attr(test, mutants::skip)]
     pub fn db_path(chainstate_root_path: &str) -> Result<String, db_error> {
         let mut path = PathBuf::from(chainstate_root_path);
 
@@ -1468,6 +1475,7 @@ impl MemPoolDB {
         MemPoolDB::open_db(&db_path, cost_estimator, metric)
     }
 
+    #[cfg_attr(test, mutants::skip)]
     pub fn reset_nonce_cache(&mut self) -> Result<(), db_error> {
         debug!("reset nonce cache");
         let sql = "DELETE FROM nonces";
diff --git a/stackslib/src/net/api/getblock.rs b/stackslib/src/net/api/getblock.rs
index 924c165de7..9596fbe9f2 100644
--- a/stackslib/src/net/api/getblock.rs
+++ b/stackslib/src/net/api/getblock.rs
@@ -206,6 +206,7 @@ impl HttpChunkGenerator for StacksBlockStream {
         4096
     }
 
+    #[cfg_attr(test, mutants::skip)]
     fn generate_next_chunk(&mut self) -> Result<Vec<u8>, String> {
         let block_path =
             StacksChainState::get_index_block_path(&self.blocks_path, &self.index_block_hash)
diff --git a/stackslib/src/net/api/getheaders.rs b/stackslib/src/net/api/getheaders.rs
index b2a3e4dc96..95558e3002 100644
--- a/stackslib/src/net/api/getheaders.rs
+++ b/stackslib/src/net/api/getheaders.rs
@@ -231,6 +231,7 @@ impl HttpChunkGenerator for StacksHeaderStream {
         4096
     }
 
+    #[cfg_attr(test, mutants::skip)]
     fn generate_next_chunk(&mut self) -> Result<Vec<u8>, String> {
         if self.total_bytes == 0 {
             // headers are a JSON array.  Start by writing '[', then write each header, and
diff --git a/stackslib/src/net/api/getmicroblocks_indexed.rs b/stackslib/src/net/api/getmicroblocks_indexed.rs
index 8f5eb7bc59..5481cb3cfb 100644
--- a/stackslib/src/net/api/getmicroblocks_indexed.rs
+++ b/stackslib/src/net/api/getmicroblocks_indexed.rs
@@ -223,6 +223,7 @@ impl HttpChunkGenerator for StacksIndexedMicroblockStream {
     /// Stream back microblock chunks.
     /// The first chunk is a 4-byte length prefix
     /// Subsequent chunks are microblocks
+    #[cfg_attr(test, mutants::skip)]
     fn generate_next_chunk(&mut self) -> Result<Vec<u8>, String> {
         if self.num_items_ptr == 0 {
             // send length prefix
diff --git a/stackslib/src/net/api/postmempoolquery.rs b/stackslib/src/net/api/postmempoolquery.rs
index d1e8ce990d..7c9cecec56 100644
--- a/stackslib/src/net/api/postmempoolquery.rs
+++ b/stackslib/src/net/api/postmempoolquery.rs
@@ -127,10 +127,12 @@ impl StacksMemPoolStream {
 }
 
 impl HttpChunkGenerator for StacksMemPoolStream {
+    #[cfg_attr(test, mutants::skip)]
     fn hint_chunk_size(&self) -> usize {
         4096
     }
 
+    #[cfg_attr(test, mutants::skip)]
     fn generate_next_chunk(&mut self) -> Result<Vec<u8>, String> {
         if self.corked {
             test_debug!(
diff --git a/stackslib/src/net/api/poststackerdbchunk.rs b/stackslib/src/net/api/poststackerdbchunk.rs
index 0caae735dd..d7901534e0 100644
--- a/stackslib/src/net/api/poststackerdbchunk.rs
+++ b/stackslib/src/net/api/poststackerdbchunk.rs
@@ -129,6 +129,7 @@ impl StackerDBErrorCodes {
         }
     }
 
+    #[cfg_attr(test, mutants::skip)]
     pub fn reason(&self) -> &'static str {
         match self {
             Self::DataAlreadyExists => "Data for this slot and version already exist",
diff --git a/stackslib/src/net/chat.rs b/stackslib/src/net/chat.rs
index 25d2355a7a..ddf48273ba 100644
--- a/stackslib/src/net/chat.rs
+++ b/stackslib/src/net/chat.rs
@@ -668,6 +668,7 @@ impl ConversationP2P {
 
     /// Does the given services bitfield mempool query interface?  It will if it has both
     /// RELAY and RPC bits set.
+    #[cfg_attr(test, mutants::skip)]
     pub fn supports_mempool_query(peer_services: u16) -> bool {
         let expected_bits = (ServiceFlags::RELAY as u16) | (ServiceFlags::RPC as u16);
         (peer_services & expected_bits) == expected_bits
diff --git a/stackslib/src/net/connection.rs b/stackslib/src/net/connection.rs
index 88f3fff39b..20afd89646 100644
--- a/stackslib/src/net/connection.rs
+++ b/stackslib/src/net/connection.rs
@@ -280,6 +280,7 @@ impl<P: ProtocolFamily> Write for NetworkReplyHandle<P> {
         }
     }
 
+    #[cfg_attr(test, mutants::skip)]
     fn flush(&mut self) -> io::Result<()> {
         self.pipe_flush()
     }
@@ -560,6 +561,7 @@ impl<P: ProtocolFamily> ConnectionInbox<P> {
 
     /// try to consume buffered data to form a message preamble.
     /// returns an option of the preamble consumed and the number of bytes used from the bytes slice
+    #[cfg_attr(test, mutants::skip)]
     fn consume_preamble(
         &mut self,
         protocol: &mut P,
@@ -621,6 +623,7 @@ impl<P: ProtocolFamily> ConnectionInbox<P> {
     }
 
     /// buffer up bytes for a message
+    #[cfg_attr(test, mutants::skip)]
     fn buffer_message_bytes(&mut self, bytes: &[u8], message_len_opt: Option<usize>) -> usize {
         let message_len = message_len_opt.unwrap_or(MAX_MESSAGE_LEN as usize);
         let buffered_so_far = self.buf[self.message_ptr..].len();
@@ -1196,6 +1199,7 @@ impl<P: ProtocolFamily> ConnectionOutbox<P> {
     }
 
     /// How many queued messsages do we have?
+    #[cfg_attr(test, mutants::skip)]
     pub fn num_messages(&self) -> usize {
         self.outbox.len()
     }
@@ -1356,6 +1360,7 @@ impl<P: ProtocolFamily + Clone> NetworkConnection<P> {
     }
 
     /// Receive data
+    #[cfg_attr(test, mutants::skip)]
     pub fn recv_data<R: Read>(&mut self, fd: &mut R) -> Result<usize, net_error> {
         self.inbox.recv_bytes(&mut self.protocol, fd)
     }
diff --git a/stackslib/src/net/db.rs b/stackslib/src/net/db.rs
index 246210bb28..d721604402 100644
--- a/stackslib/src/net/db.rs
+++ b/stackslib/src/net/db.rs
@@ -518,6 +518,7 @@ impl PeerDB {
         Ok(version)
     }
 
+    #[cfg_attr(test, mutants::skip)]
     fn apply_schema_2(tx: &Transaction) -> Result<(), db_error> {
         test_debug!("Apply schema 2 to peer DB");
         for row_text in PEERDB_SCHEMA_2 {
@@ -1698,6 +1699,7 @@ impl PeerDB {
 
     /// Get a randomized set of peers for walking the peer graph.
     /// -- selects peers at random even if not allowed
+    #[cfg_attr(test, mutants::skip)]
     pub fn get_random_walk_neighbors(
         conn: &DBConn,
         network_id: u32,
@@ -1755,6 +1757,7 @@ impl PeerDB {
     }
 
     /// Classify an IP address to its AS number
+    #[cfg_attr(test, mutants::skip)]
     pub fn asn_lookup(conn: &DBConn, addrbits: &PeerAddress) -> Result<Option<u32>, db_error> {
         if addrbits.is_ipv4() {
             PeerDB::asn4_lookup(conn, addrbits)
@@ -1765,6 +1768,7 @@ impl PeerDB {
     }
 
     /// Count the number of nodes in a given AS
+    #[cfg_attr(test, mutants::skip)]
     pub fn asn_count(conn: &DBConn, asn: u32) -> Result<u64, db_error> {
         let qry = "SELECT COUNT(*) FROM frontier WHERE asn = ?1";
         let args = [&asn as &dyn ToSql];
@@ -1772,6 +1776,7 @@ impl PeerDB {
         Ok(count as u64)
     }
 
+    #[cfg_attr(test, mutants::skip)]
     pub fn get_frontier_size(conn: &DBConn) -> Result<u64, db_error> {
         let qry = "SELECT COUNT(*) FROM frontier";
         let count = query_count(conn, &qry, NO_PARAMS)?;
diff --git a/stackslib/src/net/http/response.rs b/stackslib/src/net/http/response.rs
index 6c2a610663..f6f1776211 100644
--- a/stackslib/src/net/http/response.rs
+++ b/stackslib/src/net/http/response.rs
@@ -114,6 +114,7 @@ impl HttpResponseContents {
     /// Write data for this to a pipe writer, which buffers it up.
     /// Return Ok(Some(..)) if there is mroe data to send.
     /// Once all data is sent, return Ok(None)
+    #[cfg_attr(test, mutants::skip)]
     pub fn pipe_out(&mut self, fd: &mut PipeWrite) -> Result<u64, Error> {
         match self {
             HttpResponseContents::Stream(ref mut inner_stream) => {
diff --git a/stackslib/src/net/http/stream.rs b/stackslib/src/net/http/stream.rs
index 4f5d9f55cd..a14fcb74a5 100644
--- a/stackslib/src/net/http/stream.rs
+++ b/stackslib/src/net/http/stream.rs
@@ -40,6 +40,7 @@ pub trait HttpChunkGenerator: Send {
     /// Returns Ok(num-bytes > 0) if there are more chunks (i.e. the caller should call this again)
     /// Returns Ok(0) if there are no more chunks (i.e. the caller should not call this again)
     /// Returns Err(..) on irrecoverable I/O error
+    #[cfg_attr(test, mutants::skip)]
     fn stream_to(
         &mut self,
         encoder_state: &mut HttpChunkedTransferWriterState,
diff --git a/stackslib/src/net/httpcore.rs b/stackslib/src/net/httpcore.rs
index 3ea90efe69..074605bcd9 100644
--- a/stackslib/src/net/httpcore.rs
+++ b/stackslib/src/net/httpcore.rs
@@ -1568,6 +1568,7 @@ impl ProtocolFamily for StacksHttp {
 impl PeerNetwork {
     /// Send a (non-blocking) HTTP request to a remote peer.
     /// Returns the event ID on success.
+    #[cfg_attr(test, mutants::skip)]
     pub fn connect_or_send_http_request(
         &mut self,
         data_url: UrlString,
diff --git a/stackslib/src/net/inv/epoch2x.rs b/stackslib/src/net/inv/epoch2x.rs
index ff51874279..22611e0b5f 100644
--- a/stackslib/src/net/inv/epoch2x.rs
+++ b/stackslib/src/net/inv/epoch2x.rs
@@ -147,6 +147,7 @@ impl PeerBlocksInv {
     }
 
     /// Does this remote neighbor have certainty about the ith PoX anchor block?
+    #[cfg_attr(test, mutants::skip)]
     pub fn has_ith_anchor_block(&self, reward_cycle: u64) -> bool {
         if self.num_reward_cycles <= reward_cycle {
             return false;
@@ -282,6 +283,7 @@ impl PeerBlocksInv {
 
     /// Invalidate PoX inventories as a result of learning a new reward cycle's status
     /// Returns how many bits were dropped
+    #[cfg_attr(test, mutants::skip)]
     pub fn truncate_pox_inventory(&mut self, burnchain: &Burnchain, reward_cycle: u64) -> u64 {
         let highest_agreed_block_height = burnchain.reward_cycle_to_block_height(reward_cycle);
 
@@ -385,6 +387,7 @@ impl PeerBlocksInv {
     }
 
     /// Clear a block bit
+    #[cfg_attr(test, mutants::skip)]
     pub fn clear_block_bit(&mut self, block_height: u64) {
         self.merge_blocks_inv(block_height, 1, vec![0x01], vec![0x00], true);
     }
@@ -580,6 +583,7 @@ impl NeighborBlockStats {
         );
     }
 
+    #[cfg_attr(test, mutants::skip)]
     pub fn reset_block_scan(&mut self, block_reward_cycle: u64) {
         self.block_reward_cycle = block_reward_cycle;
         self.request = None;
diff --git a/stackslib/src/net/neighbors/comms.rs b/stackslib/src/net/neighbors/comms.rs
index 38c59461fc..157c79e9d4 100644
--- a/stackslib/src/net/neighbors/comms.rs
+++ b/stackslib/src/net/neighbors/comms.rs
@@ -493,6 +493,7 @@ impl NeighborComms for PeerNetworkComms {
         self.events.contains(&event_id)
     }
 
+    #[cfg_attr(test, mutants::skip)]
     fn add_batch_request(&mut self, naddr: NeighborAddress, rh: ReplyHandleP2P) {
         if let Some(ref mut batch) = self.ongoing_batch_request.as_mut() {
             batch.add(naddr, rh);
@@ -679,6 +680,7 @@ impl NeighborCommsRequest {
     }
 
     /// How many inflight requests remaining?
+    #[cfg_attr(test, mutants::skip)]
     pub fn count_inflight(&self) -> usize {
         self.state.len()
     }
diff --git a/stackslib/src/net/p2p.rs b/stackslib/src/net/p2p.rs
index 69a5410874..8de7c30883 100644
--- a/stackslib/src/net/p2p.rs
+++ b/stackslib/src/net/p2p.rs
@@ -562,6 +562,7 @@ impl PeerNetwork {
     }
 
     /// start serving.
+    #[cfg_attr(test, mutants::skip)]
     pub fn bind(&mut self, my_addr: &SocketAddr, http_addr: &SocketAddr) -> Result<(), net_error> {
         let mut net = NetworkState::new(self.connection_opts.max_sockets)?;
 
@@ -2437,6 +2438,7 @@ impl PeerNetwork {
     }
 
     /// Do a mempool sync. Return any transactions we might receive.
+    #[cfg_attr(test, mutants::skip)]
     fn do_network_mempool_sync(
         &mut self,
         dns_client_opt: &mut Option<&mut DNSClient>,
@@ -2487,6 +2489,7 @@ impl PeerNetwork {
     /// Begin the process of learning this peer's public IP address.
     /// Return Ok(finished with this step)
     /// Return Err(..) on failure
+    #[cfg_attr(test, mutants::skip)]
     fn begin_learn_public_ip(&mut self) -> Result<bool, net_error> {
         if self.peers.len() == 0 {
             return Err(net_error::NoSuchNeighbor);
@@ -3452,6 +3455,7 @@ impl PeerNetwork {
     /// Returns Ok(Some(..)) if we're not done, and can proceed
     /// Returns the new sync state -- either ResolveURL if we need to resolve a data URL,
     /// or SendQuery if we got the IP address and can just issue the query.
+    #[cfg_attr(test, mutants::skip)]
     fn mempool_sync_pick_outbound_peer(
         &mut self,
         dns_client_opt: &mut Option<&mut DNSClient>,
@@ -3511,6 +3515,7 @@ impl PeerNetwork {
     /// Returns Ok(Some(..)) if we're not done, and can proceed
     /// Returns the new sync state -- either ResolveURL if we need to resolve a data URL,
     /// or SendQuery if we got the IP address and can just issue the query.
+    #[cfg_attr(test, mutants::skip)]
     fn mempool_sync_begin_resolve_data_url(
         &self,
         url_str: UrlString,
@@ -3567,6 +3572,7 @@ impl PeerNetwork {
     /// Returns Ok(true, ..) if we're done syncing the mempool.
     /// Returns Ok(false, ..) if there's more to do
     /// Returns the socket addr if we ever succeed in resolving it.
+    #[cfg_attr(test, mutants::skip)]
     fn mempool_sync_resolve_data_url(
         &mut self,
         url_str: &UrlString,
@@ -3614,6 +3620,7 @@ impl PeerNetwork {
     /// Returns Ok((true, ..)) if we're done mempool syncing
     /// Returns Ok((false, ..)) if there's more to do
     /// Returns the event ID on success
+    #[cfg_attr(test, mutants::skip)]
     fn mempool_sync_send_query(
         &mut self,
         url: &UrlString,
@@ -3639,6 +3646,7 @@ impl PeerNetwork {
     /// Return Ok(true, ..) if we're done with the mempool sync.
     /// Return Ok(false, ..) if we have more work to do.
     /// Returns the page ID of the next request to make, and the list of transactions we got
+    #[cfg_attr(test, mutants::skip)]
     fn mempool_sync_recv_response(
         &mut self,
         event_id: usize,
@@ -3690,6 +3698,7 @@ impl PeerNetwork {
     /// Do a mempool sync
     /// Return true if we're done and can advance to the next state.
     /// Returns the transactions as well if the sync ran to completion.
+    #[cfg_attr(test, mutants::skip)]
     fn do_mempool_sync(
         &mut self,
         dns_client_opt: &mut Option<&mut DNSClient>,
@@ -5532,6 +5541,7 @@ impl PeerNetwork {
     /// Store a single transaction
     /// Return true if stored; false if it was a dup or if it's temporarily blacklisted.
     /// Has to be done here, since only the p2p network has the unconfirmed state.
+    #[cfg_attr(test, mutants::skip)]
     fn store_transaction(
         mempool: &mut MemPoolDB,
         sortdb: &SortitionDB,
@@ -5581,6 +5591,7 @@ impl PeerNetwork {
 
     /// Store all inbound transactions, and return the ones that we actually stored so they can be
     /// relayed.
+    #[cfg_attr(test, mutants::skip)]
     pub fn store_transactions(
         mempool: &mut MemPoolDB,
         chainstate: &mut StacksChainState,
diff --git a/stackslib/src/net/poll.rs b/stackslib/src/net/poll.rs
index 5941741bc1..83aa107eda 100644
--- a/stackslib/src/net/poll.rs
+++ b/stackslib/src/net/poll.rs
@@ -83,6 +83,7 @@ impl NetworkState {
         })
     }
 
+    #[cfg_attr(test, mutants::skip)]
     pub fn num_events(&self) -> usize {
         self.event_map.len()
     }
diff --git a/stackslib/src/net/rpc.rs b/stackslib/src/net/rpc.rs
index 879769f66f..d6d75cff17 100644
--- a/stackslib/src/net/rpc.rs
+++ b/stackslib/src/net/rpc.rs
@@ -512,6 +512,7 @@ impl ConversationHttp {
     }
 
     /// When was this converation conencted?
+    #[cfg_attr(test, mutants::skip)]
     pub fn get_connection_time(&self) -> u64 {
         self.connection_time
     }
@@ -597,6 +598,7 @@ impl ConversationHttp {
     }
 
     /// Remove all timed-out messages, and ding the remote peer as unhealthy
+    #[cfg_attr(test, mutants::skip)]
     pub fn clear_timeouts(&mut self) -> () {
         self.connection.drain_timeouts();
     }
@@ -625,6 +627,7 @@ impl ConversationHttp {
     }
 
     /// Write data out of our HTTP connection.  Write as much as we can
+    #[cfg_attr(test, mutants::skip)]
     pub fn send<W: Write>(&mut self, w: &mut W) -> Result<usize, net_error> {
         let mut total_sz = 0;
         loop {
diff --git a/stackslib/src/net/server.rs b/stackslib/src/net/server.rs
index e93819e34e..c920a3ceff 100644
--- a/stackslib/src/net/server.rs
+++ b/stackslib/src/net/server.rs
@@ -87,6 +87,7 @@ impl HttpPeer {
     }
 
     /// Is there a HTTP conversation open to this data_url that is not in progress?
+    #[cfg_attr(test, mutants::skip)]
     pub fn find_free_conversation(&self, data_url: &UrlString) -> Option<usize> {
         for (event_id, convo) in self.peers.iter() {
             if let Some(ref url) = convo.get_url() {
@@ -99,6 +100,7 @@ impl HttpPeer {
     }
 
     /// Get a mut ref to a conversation
+    #[cfg_attr(test, mutants::skip)]
     pub fn get_conversation(&mut self, event_id: usize) -> Option<&mut ConversationHttp> {
         self.peers.get_mut(&event_id)
     }
@@ -167,6 +169,7 @@ impl HttpPeer {
     }
 
     /// Can we register this socket?
+    #[cfg_attr(test, mutants::skip)]
     fn can_register_http(
         &self,
         peer_addr: &SocketAddr,
@@ -208,6 +211,7 @@ impl HttpPeer {
     /// Low-level method to register a socket/event pair on the p2p network interface.
     /// Call only once the socket is connected (called once the socket triggers ready).
     /// Will destroy the socket if we can't register for whatever reason.
+    #[cfg_attr(test, mutants::skip)]
     fn register_http(
         &mut self,
         network_state: &mut NetworkState,
@@ -281,6 +285,7 @@ impl HttpPeer {
     }
 
     /// Deregister a socket/event pair
+    #[cfg_attr(test, mutants::skip)]
     pub fn deregister_http(&mut self, network_state: &mut NetworkState, event_id: usize) -> () {
         self.peers.remove(&event_id);
 
@@ -544,6 +549,7 @@ impl HttpPeer {
     /// Advance the state of all such conversations with remote peers.
     /// Return the list of events that correspond to failed conversations, as well as the list of
     /// peer network messages we'll need to forward
+    #[cfg_attr(test, mutants::skip)]
     fn process_ready_sockets(
         &mut self,
         poll_state: &mut NetworkPollState,
@@ -601,6 +607,7 @@ impl HttpPeer {
     /// Flush outgoing replies, but don't block.
     /// Drop broken handles.
     /// Return the list of conversation event IDs to close (i.e. they're broken, or the request is done)
+    #[cfg_attr(test, mutants::skip)]
     fn flush_conversations(&mut self) -> Vec<usize> {
         let mut close = vec![];
 
@@ -626,6 +633,7 @@ impl HttpPeer {
     /// -- receive data on ready sockets
     /// -- clear out timed-out requests
     /// Returns the list of messages to forward along to the peer network.
+    #[cfg_attr(test, mutants::skip)]
     pub fn run(
         &mut self,
         network_state: &mut NetworkState,
diff --git a/stackslib/src/net/stackerdb/mod.rs b/stackslib/src/net/stackerdb/mod.rs
index 8d54c0dee0..0213c0f96c 100644
--- a/stackslib/src/net/stackerdb/mod.rs
+++ b/stackslib/src/net/stackerdb/mod.rs
@@ -197,6 +197,7 @@ impl StackerDBConfig {
     }
 
     /// How many slots are in this DB total?
+    #[cfg_attr(test, mutants::skip)]
     pub fn num_slots(&self) -> u32 {
         self.signers.iter().fold(0, |acc, s| acc + s.1)
     }

From fbc13c5bd29878e2b4902ffd02de9b22eb64f43a Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Sat, 10 Feb 2024 22:08:48 -0500
Subject: [PATCH 0774/1166] chore: Enable "fat" link-time optimizations for
 release builds

---
 Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Cargo.toml b/Cargo.toml
index 265dc3cee5..3b16fa6db6 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -31,4 +31,4 @@ opt-level = 3
 
 [profile.release]
 debug = true
-
+lto = "fat"

From f66d120a4f4cce8ce11c3b24716f904ccb30b857 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Wed, 14 Feb 2024 11:52:44 -0500
Subject: [PATCH 0775/1166] chore: Add `codegen-units = 1` for even better
 link-time optimization

---
 Cargo.toml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Cargo.toml b/Cargo.toml
index 3b16fa6db6..693970fb68 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -31,4 +31,5 @@ opt-level = 3
 
 [profile.release]
 debug = true
+codegen-units = 1
 lto = "fat"

From 41df072c8de9dcb6199d79279d8c2aff7f786f00 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Thu, 15 Feb 2024 10:23:23 -0600
Subject: [PATCH 0776/1166] chore: update ed25519-dalek and rand libraries, use
 workspace versioning

---
 Cargo.lock                                    | 1842 +++++++++--------
 Cargo.toml                                    |    2 +
 clarity/Cargo.toml                            |    4 +-
 stacks-common/Cargo.toml                      |    7 +-
 stacks-common/src/address/c32.rs              |    2 +-
 stacks-common/src/util/vrf.rs                 |  139 +-
 stackslib/Cargo.toml                          |    9 +-
 stackslib/src/burnchains/bitcoin/network.rs   |    4 +-
 stackslib/src/burnchains/tests/burnchain.rs   |    8 +-
 stackslib/src/chainstate/burn/mod.rs          |    4 +-
 .../cost_estimates/tests/fee_rate_fuzzer.rs   |   20 +-
 stackslib/src/net/neighbors/neighbor.rs       |    2 +-
 stackslib/src/net/neighbors/walk.rs           |    2 +-
 stackslib/src/net/prune.rs                    |    2 +-
 14 files changed, 1077 insertions(+), 970 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 41c2c8e924..1784c93f59 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4,9 +4,9 @@ version = 3
 
 [[package]]
 name = "addr2line"
-version = "0.19.0"
+version = "0.21.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a76fd60b23679b7d19bd066031410fb7e458ccc5e958eb5c325888ce4baedc97"
+checksum = "8a30b2e23b9e17a9f90641c7ab1549cd9b44f296d3ccbf309d2863cfe398a0cb"
 dependencies = [
  "gimli",
 ]
@@ -29,7 +29,7 @@ version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7fc95d1bdb8e6666b2b217308eeeb09f2d6728d104be3e31916cc74d15420331"
 dependencies = [
- "generic-array 0.14.6",
+ "generic-array 0.14.7",
 ]
 
 [[package]]
@@ -39,7 +39,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d122413f284cf2d62fb1b7db97e02edb8cda96d769b16e443a4f6195e35662b0"
 dependencies = [
  "crypto-common",
- "generic-array 0.14.6",
+ "generic-array 0.14.7",
 ]
 
 [[package]]
@@ -55,9 +55,9 @@ dependencies = [
 
 [[package]]
 name = "aes"
-version = "0.8.3"
+version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac1f845298e95f983ff1944b728ae08b8cebab80d684f0a832ed0fc74dfa27e2"
+checksum = "b169f7a6d4742236a0a00c541b845991d0ac43e546831af1249753ab4c3aa3a0"
 dependencies = [
  "cfg-if 1.0.0",
  "cipher 0.4.4",
@@ -80,12 +80,12 @@ dependencies = [
 
 [[package]]
 name = "aes-gcm"
-version = "0.10.2"
+version = "0.10.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "209b47e8954a928e1d72e86eca7000ebb6655fe1436d33eefc2201cad027e237"
+checksum = "831010a0f742e1209b3bcea8fab6a8e149051ba6099432c8cb2cc117dec3ead1"
 dependencies = [
  "aead 0.5.2",
- "aes 0.8.3",
+ "aes 0.8.4",
  "cipher 0.4.4",
  "ctr 0.9.2",
  "ghash 0.5.0",
@@ -99,7 +99,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "be14c7498ea50828a38d0e24a765ed2effe92a705885b57d029cd67d45744072"
 dependencies = [
  "cipher 0.2.5",
- "opaque-debug 0.3.0",
+ "opaque-debug",
 ]
 
 [[package]]
@@ -109,31 +109,32 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ea2e11f5e94c2f7d386164cc2aa1f97823fed6f259e486940a71c174dd01b0ce"
 dependencies = [
  "cipher 0.2.5",
- "opaque-debug 0.3.0",
+ "opaque-debug",
 ]
 
 [[package]]
 name = "ahash"
-version = "0.4.7"
+version = "0.4.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "739f4a8db6605981345c5654f3a85b056ce52f37a39d34da03f25bf2151ea16e"
+checksum = "0453232ace82dee0dd0b4c87a59bd90f7b53b314f3e0f61fe2ee7c8a16482289"
 
 [[package]]
 name = "ahash"
-version = "0.8.3"
+version = "0.8.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c99f64d1e06488f620f932677e24bc6e2897582980441ae90a671415bd7ec2f"
+checksum = "42cd52102d3df161c77a887b608d7a4897d7cc112886a9537b738a887a03aaff"
 dependencies = [
  "cfg-if 1.0.0",
  "once_cell",
  "version_check",
+ "zerocopy",
 ]
 
 [[package]]
 name = "aho-corasick"
-version = "0.7.20"
+version = "1.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cc936419f96fa211c1b9166887b38e5e40b19958e5b895be7c1f93adec7071ac"
+checksum = "b2969dcb958b36655471fc61f7e416fa76033bdd4bfed0678d8fee1e2d07a1f0"
 dependencies = [
  "memchr",
 ]
@@ -144,6 +145,12 @@ version = "0.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0942ffc6dcaadf03badf6e6a2d0228460359d5e34b57ccdc720b7382dfbd5ec5"
 
+[[package]]
+name = "android-tzdata"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e999941b234f3131b00bc13c22d06e8c5ff726d1b6318ac7eb276997bbb4fef0"
+
 [[package]]
 name = "android_system_properties"
 version = "0.1.5"
@@ -155,9 +162,9 @@ dependencies = [
 
 [[package]]
 name = "anstream"
-version = "0.5.0"
+version = "0.6.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1f58811cfac344940f1a400b6e6231ce35171f614f26439e80f8c1465c5cc0c"
+checksum = "6e2e1ebcb11de5c03c67de28a7df593d32191b44939c482e97702baaaa6ab6a5"
 dependencies = [
  "anstyle",
  "anstyle-parse",
@@ -169,43 +176,43 @@ dependencies = [
 
 [[package]]
 name = "anstyle"
-version = "1.0.2"
+version = "1.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "15c4c2c83f81532e5845a733998b6971faca23490340a418e9b72a3ec9de12ea"
+checksum = "8901269c6307e8d93993578286ac0edf7f195079ffff5ebdeea6a59ffb7e36bc"
 
 [[package]]
 name = "anstyle-parse"
-version = "0.2.1"
+version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "938874ff5980b03a87c5524b3ae5b59cf99b1d6bc836848df7bc5ada9643c333"
+checksum = "c75ac65da39e5fe5ab759307499ddad880d724eed2f6ce5b5e8a26f4f387928c"
 dependencies = [
  "utf8parse",
 ]
 
 [[package]]
 name = "anstyle-query"
-version = "1.0.0"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ca11d4be1bab0c8bc8734a9aa7bf4ee8316d462a08c6ac5052f888fef5b494b"
+checksum = "e28923312444cdd728e4738b3f9c9cac739500909bb3d3c94b43551b16517648"
 dependencies = [
- "windows-sys 0.48.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
 name = "anstyle-wincon"
-version = "2.1.0"
+version = "3.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "58f54d10c6dfa51283a066ceab3ec1ab78d13fae00aa49243a45e4571fb79dfd"
+checksum = "1cd54b81ec8d6180e24654d0b371ad22fc3dd083b6ff8ba325b72e00c87660a7"
 dependencies = [
  "anstyle",
- "windows-sys 0.48.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
 name = "anyhow"
-version = "1.0.69"
+version = "1.0.79"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "224afbd727c3d6e4b90103ece64b8d1b67fbb1973b1046c2281eed3f3803f800"
+checksum = "080e9890a082662b09c1ad45f567faeeb47f22b5fb23895fbe1e651e718e25ca"
 
 [[package]]
 name = "arrayvec"
@@ -242,64 +249,78 @@ dependencies = [
 
 [[package]]
 name = "async-channel"
-version = "1.8.0"
+version = "1.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf46fee83e5ccffc220104713af3292ff9bc7c64c7de289f66dae8e38d826833"
+checksum = "81953c529336010edd6d8e358f886d9581267795c61b19475b71314bffa46d35"
 dependencies = [
  "concurrent-queue",
- "event-listener",
+ "event-listener 2.5.3",
  "futures-core",
 ]
 
+[[package]]
+name = "async-channel"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f28243a43d821d11341ab73c80bed182dc015c514b951616cf79bd4af39af0c3"
+dependencies = [
+ "concurrent-queue",
+ "event-listener 5.0.0",
+ "event-listener-strategy 0.5.0",
+ "futures-core",
+ "pin-project-lite",
+]
+
 [[package]]
 name = "async-dup"
-version = "1.2.2"
+version = "1.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7427a12b8dc09291528cfb1da2447059adb4a257388c2acd6497a79d55cf6f7c"
+checksum = "7c2886ab563af5038f79ec016dd7b87947ed138b794e8dd64992962c9cca0411"
 dependencies = [
+ "async-lock 3.3.0",
  "futures-io",
- "simple-mutex",
 ]
 
 [[package]]
 name = "async-executor"
-version = "1.5.0"
+version = "1.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "17adb73da160dfb475c183343c8cccd80721ea5a605d3eb57125f0a7b7a92d0b"
+checksum = "17ae5ebefcc48e7452b4987947920dac9450be1110cadf34d1b8c116bdbaf97c"
 dependencies = [
- "async-lock",
+ "async-lock 3.3.0",
  "async-task",
  "concurrent-queue",
- "fastrand",
- "futures-lite",
+ "fastrand 2.0.1",
+ "futures-lite 2.2.0",
  "slab",
 ]
 
 [[package]]
 name = "async-global-executor"
-version = "2.3.1"
+version = "2.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1b6f5d7df27bd294849f8eec66ecfc63d11814df7a4f5d74168a2394467b776"
+checksum = "05b1b633a2115cd122d73b955eadd9916c18c8f510ec9cd1686404c60ad1c29c"
 dependencies = [
- "async-channel",
+ "async-channel 2.2.0",
  "async-executor",
- "async-io",
- "async-lock",
+ "async-io 2.3.1",
+ "async-lock 3.3.0",
  "blocking",
- "futures-lite",
+ "futures-lite 2.2.0",
  "once_cell",
 ]
 
 [[package]]
 name = "async-h1"
-version = "2.3.3"
+version = "2.3.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8101020758a4fc3a7c326cb42aa99e9fa77cbfb76987c128ad956406fe1f70a7"
+checksum = "5d1d1dae8cb2c4258a79d6ed088b7fb9b4763bf4e9b22d040779761e046a2971"
 dependencies = [
- "async-channel",
+ "async-channel 1.9.0",
  "async-dup",
- "async-std",
- "futures-core",
+ "async-global-executor",
+ "async-io 1.13.0",
+ "futures-lite 1.13.0",
  "http-types",
  "httparse",
  "log",
@@ -308,31 +329,61 @@ dependencies = [
 
 [[package]]
 name = "async-io"
-version = "1.12.0"
+version = "1.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c374dda1ed3e7d8f0d9ba58715f924862c63eae6849c92d3a18e7fbde9e2794"
+checksum = "0fc5b45d93ef0529756f812ca52e44c221b35341892d3dcc34132ac02f3dd2af"
 dependencies = [
- "async-lock",
+ "async-lock 2.8.0",
  "autocfg",
+ "cfg-if 1.0.0",
  "concurrent-queue",
- "futures-lite",
- "libc",
+ "futures-lite 1.13.0",
  "log",
  "parking",
- "polling",
+ "polling 2.8.0",
+ "rustix 0.37.27",
  "slab",
- "socket2",
+ "socket2 0.4.10",
  "waker-fn",
- "windows-sys 0.42.0",
+]
+
+[[package]]
+name = "async-io"
+version = "2.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f97ab0c5b00a7cdbe5a371b9a782ee7be1316095885c8a4ea1daf490eb0ef65"
+dependencies = [
+ "async-lock 3.3.0",
+ "cfg-if 1.0.0",
+ "concurrent-queue",
+ "futures-io",
+ "futures-lite 2.2.0",
+ "parking",
+ "polling 3.4.0",
+ "rustix 0.38.31",
+ "slab",
+ "tracing",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
 name = "async-lock"
-version = "2.7.0"
+version = "2.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "287272293e9d8c41773cec55e365490fe034813a2f172f502d6ddcf75b2f582b"
+dependencies = [
+ "event-listener 2.5.3",
+]
+
+[[package]]
+name = "async-lock"
+version = "3.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa24f727524730b077666307f2734b4a1a1c57acb79193127dcc8914d5242dd7"
+checksum = "d034b430882f8381900d3fe6f0aaa3ad94f2cb4ac519b429692a1bc2dda4ae7b"
 dependencies = [
- "event-listener",
+ "event-listener 4.0.3",
+ "event-listener-strategy 0.4.0",
+ "pin-project-lite",
 ]
 
 [[package]]
@@ -342,15 +393,15 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "62565bb4402e926b29953c785397c6dc0391b7b446e45008b0049eb43cec6f5d"
 dependencies = [
  "async-attributes",
- "async-channel",
+ "async-channel 1.9.0",
  "async-global-executor",
- "async-io",
- "async-lock",
+ "async-io 1.13.0",
+ "async-lock 2.8.0",
  "crossbeam-utils",
  "futures-channel",
  "futures-core",
  "futures-io",
- "futures-lite",
+ "futures-lite 1.13.0",
  "gloo-timers",
  "kv-log-macro",
  "log",
@@ -364,15 +415,15 @@ dependencies = [
 
 [[package]]
 name = "async-task"
-version = "4.3.0"
+version = "4.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a40729d2133846d9ed0ea60a8b9541bccddab49cd30f0715a1da672fe9a2524"
+checksum = "fbb36e985947064623dbd357f727af08ffd077f93d696782f3c56365fa2e2799"
 
 [[package]]
 name = "atomic-waker"
-version = "1.1.0"
+version = "1.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "debc29dde2e69f9e47506b525f639ed42300fc014a3e007832592448fa8e4599"
+checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0"
 
 [[package]]
 name = "atty"
@@ -397,16 +448,16 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b62ddb9cb1ec0a098ad4bbf9344d0713fa193ae1a80af55febcff2627b6a00c1"
 dependencies = [
- "getrandom 0.2.8",
+ "getrandom 0.2.12",
  "instant",
  "rand 0.8.5",
 ]
 
 [[package]]
 name = "backtrace"
-version = "0.3.67"
+version = "0.3.69"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "233d376d6d185f2a3093e58f283f60f880315b6c60075b01f36b3b85154564ca"
+checksum = "2089b7e3f35b9dd2d0ed921ead4f6d318c27680d4a5bd167b3ee120edb105837"
 dependencies = [
  "addr2line",
  "cc",
@@ -437,9 +488,15 @@ checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8"
 
 [[package]]
 name = "base64"
-version = "0.21.0"
+version = "0.21.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4a4ddaa51a5bc52a6948f74c06d20aaaddb71924eab79b8c97a8c556e942d6a"
+checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567"
+
+[[package]]
+name = "base64ct"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b"
 
 [[package]]
 name = "bitflags"
@@ -447,6 +504,12 @@ version = "1.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
+[[package]]
+name = "bitflags"
+version = "2.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed570934406eb16438a4e976b1b4500774099c13b8cb96eec99f620f05090ddf"
+
 [[package]]
 name = "bitvec"
 version = "1.0.1"
@@ -459,25 +522,13 @@ dependencies = [
  "wyz",
 ]
 
-[[package]]
-name = "block-buffer"
-version = "0.7.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0940dc441f31689269e10ac70eb1002a3a1d3ad1390e030043662eb7fe4688b"
-dependencies = [
- "block-padding",
- "byte-tools",
- "byteorder",
- "generic-array 0.12.4",
-]
-
 [[package]]
 name = "block-buffer"
 version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4152116fd6e9dadb291ae18fc1ec3575ed6d84c29642d97890f4b4a3417297e4"
 dependencies = [
- "generic-array 0.14.6",
+ "generic-array 0.14.7",
 ]
 
 [[package]]
@@ -486,30 +537,23 @@ version = "0.10.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
 dependencies = [
- "generic-array 0.14.6",
-]
-
-[[package]]
-name = "block-padding"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa79dedbb091f449f1f39e53edf88d5dbe95f895dae6135a8d7b881fb5af73f5"
-dependencies = [
- "byte-tools",
+ "generic-array 0.14.7",
 ]
 
 [[package]]
 name = "blocking"
-version = "1.3.0"
+version = "1.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c67b173a56acffd6d2326fb7ab938ba0b00a71480e14902b2591c87bc5741e8"
+checksum = "6a37913e8dc4ddcc604f0c6d3bf2887c995153af3611de9e23c352b44c1b9118"
 dependencies = [
- "async-channel",
- "async-lock",
+ "async-channel 2.2.0",
+ "async-lock 3.3.0",
  "async-task",
- "atomic-waker",
- "fastrand",
- "futures-lite",
+ "fastrand 2.0.1",
+ "futures-io",
+ "futures-lite 2.2.0",
+ "piper",
+ "tracing",
 ]
 
 [[package]]
@@ -529,9 +573,9 @@ dependencies = [
 
 [[package]]
 name = "bumpalo"
-version = "3.12.0"
+version = "3.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d261e256854913907f67ed06efbc3338dfe6179796deefc1ff763fc1aee5535"
+checksum = "7f30e7476521f6f8af1a1c4c0b8cc94f0bee37d91763d0ca2665f299b6cd8aec"
 
 [[package]]
 name = "byte-slice-cast"
@@ -539,23 +583,17 @@ version = "1.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c3ac9f8b63eca6fd385229b3675f6cc0dc5c8a5c8a54a59d4f52ffd670d87b0c"
 
-[[package]]
-name = "byte-tools"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3b5ca7a04898ad4bcd41c90c5285445ff5b791899bb1b0abdd2a2aa791211d7"
-
 [[package]]
 name = "byteorder"
-version = "1.4.3"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
 
 [[package]]
 name = "bytes"
-version = "1.4.0"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "89b2fd2a0dcf38d7971e2194b6b6eebab45ae01067456a7fd93d5547a61b70be"
+checksum = "a2bd12c1caf447e69cd4528f47f94d203fd2582878ecb9e9465484c4148a8223"
 
 [[package]]
 name = "cast"
@@ -565,9 +603,12 @@ checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
 [[package]]
 name = "cc"
-version = "1.0.79"
+version = "1.0.83"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50d30906286121d95be3d479533b458f87493b30a4b5f79a607db8f5d11aa91f"
+checksum = "f1174fb0b6ec23863f8b971027804a42614e347eafb0a95bf0b12cdae21fc4d0"
+dependencies = [
+ "libc",
+]
 
 [[package]]
 name = "cfg-if"
@@ -583,24 +624,23 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
 [[package]]
 name = "chrono"
-version = "0.4.24"
+version = "0.4.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e3c5919066adf22df73762e50cffcde3a758f2a848b113b586d1f86728b673b"
+checksum = "5bc015644b92d5890fab7489e49d21f879d5c990186827d42ec511919404f38b"
 dependencies = [
+ "android-tzdata",
  "iana-time-zone",
  "js-sys",
- "num-integer",
  "num-traits",
- "time 0.1.45",
  "wasm-bindgen",
- "winapi 0.3.9",
+ "windows-targets 0.52.0",
 ]
 
 [[package]]
 name = "chunked_transfer"
-version = "1.4.1"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cca491388666e04d7248af3f60f0c40cfb0991c72205595d7c396e3510207d1a"
+checksum = "6e4de3bc4ea267985becf712dc6d9eed8b04c953b3fcfb339ebc87acd9804901"
 
 [[package]]
 name = "cipher"
@@ -608,7 +648,7 @@ version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "12f8e7987cbd042a63249497f41aed09f8e65add917ea6566effbc56578d6801"
 dependencies = [
- "generic-array 0.14.6",
+ "generic-array 0.14.7",
 ]
 
 [[package]]
@@ -627,27 +667,26 @@ version = "2.34.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a0610544180c38b88101fecf2dd634b174a62eef6946f84dfc6a7127512b381c"
 dependencies = [
- "bitflags",
+ "bitflags 1.3.2",
  "textwrap",
  "unicode-width",
 ]
 
 [[package]]
 name = "clap"
-version = "4.4.1"
+version = "4.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7c8d502cbaec4595d2e7d5f61e318f05417bd2b66fdc3809498f0d3fdf0bea27"
+checksum = "80c21025abd42669a92efc996ef13cfb2c5c627858421ea58d5c3b331a6c134f"
 dependencies = [
  "clap_builder",
  "clap_derive",
- "once_cell",
 ]
 
 [[package]]
 name = "clap_builder"
-version = "4.4.1"
+version = "4.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5891c7bc0edb3e1c2204fc5e94009affabeb1821c9e5fdc3959536c5c0bb984d"
+checksum = "458bf1f341769dfcf849846f65dffdf9146daa56bcd2a47cb4e1de9915567c99"
 dependencies = [
  "anstream",
  "anstyle",
@@ -657,21 +696,21 @@ dependencies = [
 
 [[package]]
 name = "clap_derive"
-version = "4.4.0"
+version = "4.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c9fd1a5729c4548118d7d70ff234a44868d00489a4b6597b0b020918a0e91a1a"
+checksum = "307bc0538d5f0f83b8248db3087aa92fe504e4691294d0c96c0eabc33f47ba47"
 dependencies = [
  "heck",
  "proc-macro2",
  "quote",
- "syn 2.0.29",
+ "syn 2.0.48",
 ]
 
 [[package]]
 name = "clap_lex"
-version = "0.5.1"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd7cc57abe963c6d3b9d8be5b06ba7c8957a930305ca90304f24ef040aa6f961"
+checksum = "98cc8fbded0c607b7ba9dd60cd98df59af97e84d24e49c8557331cfc26d301ce"
 
 [[package]]
 name = "clarity"
@@ -680,8 +719,8 @@ dependencies = [
  "assert-json-diff",
  "integer-sqrt",
  "lazy_static",
- "rand 0.7.3",
- "rand_chacha 0.2.2",
+ "rand 0.8.5",
+ "rand_chacha 0.3.1",
  "regex",
  "rstest 0.17.0",
  "rstest_reuse 0.5.0",
@@ -696,25 +735,6 @@ dependencies = [
  "time 0.2.27",
 ]
 
-[[package]]
-name = "clear_on_drop"
-version = "0.2.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38508a63f4979f0048febc9966fadbd48e5dab31fd0ec6a3f151bbf4a74f7423"
-dependencies = [
- "cc",
-]
-
-[[package]]
-name = "codespan-reporting"
-version = "0.11.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3538270d33cc669650c4b093848450d380def10c331d38c768e34cac80576e6e"
-dependencies = [
- "termcolor",
- "unicode-width",
-]
-
 [[package]]
 name = "colorchoice"
 version = "1.0.0"
@@ -723,13 +743,19 @@ checksum = "acbf1af155f9b9ef647e42cdc158db4b64a1b61f743629225fde6f3e0be2a7c7"
 
 [[package]]
 name = "concurrent-queue"
-version = "2.1.0"
+version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c278839b831783b70278b14df4d45e1beb1aad306c07bb796637de9a0e323e8e"
+checksum = "d16048cd947b08fa32c24458a22f5dc5e835264f689f4f5653210c69fd107363"
 dependencies = [
  "crossbeam-utils",
 ]
 
+[[package]]
+name = "const-oid"
+version = "0.9.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8"
+
 [[package]]
 name = "const_fn"
 version = "0.4.9"
@@ -755,9 +781,9 @@ dependencies = [
 
 [[package]]
 name = "core-foundation"
-version = "0.9.3"
+version = "0.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "194a7a9e6de53fa55116934067c844d9d749312f75c6f6d0980e8c252f8c2146"
+checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f"
 dependencies = [
  "core-foundation-sys",
  "libc",
@@ -765,15 +791,15 @@ dependencies = [
 
 [[package]]
 name = "core-foundation-sys"
-version = "0.8.3"
+version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5827cebf4670468b8772dd191856768aedcb1b0278a04f989f7766351917b9dc"
+checksum = "06ea2b9bc92be3c2baa9334a323ebca2d6f074ff852cd1d7b11064035cd3868f"
 
 [[package]]
 name = "cpufeatures"
-version = "0.2.5"
+version = "0.2.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28d997bd5e24a5928dd43e46dc529867e207907fe0b239c3477d924f7f2ca320"
+checksum = "53fe5e26ff1b7aef8bca9c6080520cfb8d9333c7568e1829cef191a9723e5504"
 dependencies = [
  "libc",
 ]
@@ -786,9 +812,9 @@ checksum = "dcb25d077389e53838a8158c8e99174c5a9d902dee4904320db714f3c653ffba"
 
 [[package]]
 name = "crc32fast"
-version = "1.3.2"
+version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b540bd8bc810d3885c6ea91e2018302f68baba2129ab3e88f32389ee9370880d"
+checksum = "b3855a8a784b474f333699ef2bbca9db2c4a1f6d9088a90a2d25b1eb53111eaa"
 dependencies = [
  "cfg-if 1.0.0",
 ]
@@ -829,48 +855,30 @@ dependencies = [
  "itertools",
 ]
 
-[[package]]
-name = "crossbeam-channel"
-version = "0.5.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf2b3e8478797446514c91ef04bafcb59faba183e621ad488df88983cc14128c"
-dependencies = [
- "cfg-if 1.0.0",
- "crossbeam-utils",
-]
-
 [[package]]
 name = "crossbeam-deque"
-version = "0.8.3"
+version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ce6fd6f855243022dcecf8702fef0c297d4338e226845fe067f6341ad9fa0cef"
+checksum = "613f8cc01fe9cf1a3eb3d7f488fd2fa8388403e97039e2f73692932e291a770d"
 dependencies = [
- "cfg-if 1.0.0",
  "crossbeam-epoch",
  "crossbeam-utils",
 ]
 
 [[package]]
 name = "crossbeam-epoch"
-version = "0.9.14"
+version = "0.9.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46bd5f3f85273295a9d14aedfb86f6aadbff6d8f5295c4a9edb08e819dcf5695"
+checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
 dependencies = [
- "autocfg",
- "cfg-if 1.0.0",
  "crossbeam-utils",
- "memoffset 0.8.0",
- "scopeguard",
 ]
 
 [[package]]
 name = "crossbeam-utils"
-version = "0.8.15"
+version = "0.8.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c063cd8cc95f5c377ed0d4b49a4b21f632396ff690e8470c29b3359b346984b"
-dependencies = [
- "cfg-if 1.0.0",
-]
+checksum = "248e3bacc7dc6baa3b21e405ee045c3047101a49145e7e9eca583ab4c2ca5345"
 
 [[package]]
 name = "crunchy"
@@ -884,26 +892,26 @@ version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
 dependencies = [
- "generic-array 0.14.6",
+ "generic-array 0.14.7",
  "rand_core 0.6.4",
  "typenum",
 ]
 
 [[package]]
 name = "crypto-mac"
-version = "0.10.1"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bff07008ec701e8028e2ceb8f83f0e4274ee62bd2dbdc4fefff2e9a91824081a"
+checksum = "4857fd85a0c34b3c3297875b747c1e02e06b6a0ea32dd892d8192b9ce0813ea6"
 dependencies = [
- "generic-array 0.14.6",
+ "generic-array 0.14.7",
  "subtle",
 ]
 
 [[package]]
 name = "csv"
-version = "1.2.1"
+version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b015497079b9a9d69c02ad25de6c0a6edef051ea6360a327d0bd05802ef64ad"
+checksum = "ac574ff4d437a7b5ad237ef331c17ccca63c46479e5b5453eb8e10bb99a759fe"
 dependencies = [
  "csv-core",
  "itoa",
@@ -913,23 +921,13 @@ dependencies = [
 
 [[package]]
 name = "csv-core"
-version = "0.1.10"
+version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b2466559f260f48ad25fe6317b3c8dac77b5bdb5763ac7d9d6103530663bc90"
+checksum = "5efa2b3d7902f4b634a20cae3c9c4e6209dc4779feb6863329607560143efa70"
 dependencies = [
  "memchr",
 ]
 
-[[package]]
-name = "ctor"
-version = "0.1.26"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d2301688392eb071b0bf1a37be05c469d3cc4dbbd95df672fe28ab021e6a096"
-dependencies = [
- "quote",
- "syn 1.0.109",
-]
-
 [[package]]
 name = "ctr"
 version = "0.6.0"
@@ -963,60 +961,69 @@ dependencies = [
 ]
 
 [[package]]
-name = "cxx"
-version = "1.0.92"
+name = "curve25519-dalek"
+version = "4.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a140f260e6f3f79013b8bfc65e7ce630c9ab4388c6a89c71e07226f49487b72"
+checksum = "0a677b8922c94e01bdbb12126b0bc852f00447528dee1782229af9c720c3f348"
 dependencies = [
- "cc",
- "cxxbridge-flags",
- "cxxbridge-macro",
- "link-cplusplus",
+ "cfg-if 1.0.0",
+ "cpufeatures",
+ "curve25519-dalek-derive",
+ "digest 0.10.7",
+ "fiat-crypto",
+ "platforms",
+ "rustc_version 0.4.0",
+ "subtle",
+ "zeroize",
 ]
 
 [[package]]
-name = "cxx-build"
-version = "1.0.92"
+name = "curve25519-dalek-derive"
+version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da6383f459341ea689374bf0a42979739dc421874f112ff26f829b8040b8e613"
+checksum = "f46882e17999c6cc590af592290432be3bce0428cb0d5f8b6715e4dc7b383eb3"
 dependencies = [
- "cc",
- "codespan-reporting",
- "once_cell",
  "proc-macro2",
  "quote",
- "scratch",
- "syn 1.0.109",
+ "syn 2.0.48",
 ]
 
 [[package]]
-name = "cxxbridge-flags"
-version = "1.0.92"
+name = "dashmap"
+version = "5.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90201c1a650e95ccff1c8c0bb5a343213bdd317c6e600a93075bca2eff54ec97"
+checksum = "978747c1d849a7d2ee5e8adc0159961c48fb7e5db2f06af6723b80123bb53856"
+dependencies = [
+ "cfg-if 1.0.0",
+ "hashbrown 0.14.3",
+ "lock_api",
+ "once_cell",
+ "parking_lot_core",
+]
 
 [[package]]
-name = "cxxbridge-macro"
-version = "1.0.92"
+name = "data-encoding"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e962a19be5cfc3f3bf6dd8f61eb50107f356ad6270fbb3ed41476571db78be5"
+
+[[package]]
+name = "der"
+version = "0.7.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b75aed41bb2e6367cae39e6326ef817a851db13c13e4f3263714ca3cfb8de56"
+checksum = "fffa369a668c8af7dbf8b5e56c9f744fbd399949ed171606040001947de40b1c"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.109",
+ "const-oid",
+ "zeroize",
 ]
 
 [[package]]
-name = "dashmap"
-version = "5.4.0"
+name = "deranged"
+version = "0.3.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "907076dfda823b0b36d2a1bb5f90c96660a5bbcd7729e10727f07858f22c4edc"
+checksum = "b42b6fa04a440b495c8b04d0e71b707c585f83cb9cb28cf8cd0d976c315e31b4"
 dependencies = [
- "cfg-if 1.0.0",
- "hashbrown 0.12.3",
- "lock_api",
- "once_cell",
- "parking_lot_core",
+ "powerfmt",
 ]
 
 [[package]]
@@ -1034,14 +1041,14 @@ version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d3dd60d1080a57a05ab032377049e0591415d2b31afd7028356dbf3cc6dcb066"
 dependencies = [
- "generic-array 0.14.6",
+ "generic-array 0.14.7",
 ]
 
 [[package]]
 name = "digest"
-version = "0.10.6"
+version = "0.10.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8168378f4e5023e7218c89c891c0fd8ecdb5e5e4f18cb78f38cf245dd021e76f"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
 dependencies = [
  "block-buffer 0.10.4",
  "crypto-common",
@@ -1074,30 +1081,43 @@ version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "212d0f5754cb6769937f4501cc0e67f4f4483c8d2c3e1e922ee9edbe4ab4c7c0"
 
+[[package]]
+name = "ed25519"
+version = "2.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "115531babc129696a58c64a4fef0a8bf9e9698629fb97e9e40767d235cfbcd53"
+dependencies = [
+ "pkcs8",
+ "serde",
+ "signature",
+]
+
 [[package]]
 name = "ed25519-dalek"
-version = "1.0.0-pre.3"
+version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "978710b352437433c97b2bff193f2fb1dfd58a093f863dd95e225a19baa599a2"
+checksum = "4a3daa8e81a3963a60642bcc1f90a670680bd4a77535faa384e9d1c79d620871"
 dependencies = [
- "clear_on_drop",
- "curve25519-dalek",
- "rand 0.7.3",
+ "curve25519-dalek 4.1.2",
+ "ed25519",
+ "rand_core 0.6.4",
  "serde",
- "sha2 0.8.2",
+ "sha2 0.10.8",
+ "subtle",
+ "zeroize",
 ]
 
 [[package]]
 name = "either"
-version = "1.8.1"
+version = "1.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fcaabb2fef8c910e7f4c7ce9f67a1283a1715879a7c230ca9d6d1ae31f16d91"
+checksum = "11157ac094ffbdde99aa67b23417ebdd801842852b500e395a45a9c0aac03e4a"
 
 [[package]]
 name = "encoding_rs"
-version = "0.8.32"
+version = "0.8.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "071a31f4ee85403370b58aca746f01041ede6f0da2730960ad001edc2b71b394"
+checksum = "7268b386296a025e474d5140678f75d6de9493ae55a5d709eeb9dd08149945e1"
 dependencies = [
  "cfg-if 1.0.0",
 ]
@@ -1110,30 +1130,61 @@ checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
 
 [[package]]
 name = "errno"
-version = "0.3.3"
+version = "0.3.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "136526188508e25c6fef639d7927dfb3e0e3084488bf202267829cf7fc23dbdd"
+checksum = "a258e46cdc063eb8519c00b9fc845fc47bcfca4130e2f08e88665ceda8474245"
 dependencies = [
- "errno-dragonfly",
  "libc",
- "windows-sys 0.48.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
-name = "errno-dragonfly"
-version = "0.1.2"
+name = "event-listener"
+version = "2.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aa68f1b12764fab894d2755d2518754e71b4fd80ecfb822714a1206c2aab39bf"
+checksum = "0206175f82b8d6bf6652ff7d71a1e27fd2e4efde587fd368662814d6ec1d9ce0"
+
+[[package]]
+name = "event-listener"
+version = "4.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67b215c49b2b248c855fb73579eb1f4f26c38ffdc12973e20e07b91d78d5646e"
 dependencies = [
- "cc",
- "libc",
+ "concurrent-queue",
+ "parking",
+ "pin-project-lite",
 ]
 
 [[package]]
 name = "event-listener"
-version = "2.5.3"
+version = "5.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0206175f82b8d6bf6652ff7d71a1e27fd2e4efde587fd368662814d6ec1d9ce0"
+checksum = "b72557800024fabbaa2449dd4bf24e37b93702d457a4d4f2b0dd1f0f039f20c1"
+dependencies = [
+ "concurrent-queue",
+ "parking",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "event-listener-strategy"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "958e4d70b6d5e81971bebec42271ec641e7ff4e170a6fa605f2b8a8b65cb97d3"
+dependencies = [
+ "event-listener 4.0.3",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "event-listener-strategy"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "feedafcaa9b749175d5ac357452a9d41ea2911da598fde46ce1fe02c37751291"
+dependencies = [
+ "event-listener 5.0.0",
+ "pin-project-lite",
+]
 
 [[package]]
 name = "extend"
@@ -1147,12 +1198,6 @@ dependencies = [
  "syn 1.0.109",
 ]
 
-[[package]]
-name = "fake-simd"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e88a8acf291dafb59c2d96e8f59828f3838bb1a70398823ade51a84de6a6deed"
-
 [[package]]
 name = "fallible-iterator"
 version = "0.2.0"
@@ -1174,6 +1219,18 @@ dependencies = [
  "instant",
 ]
 
+[[package]]
+name = "fastrand"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "25cbce373ec4653f1a01a31e8a5e5ec0c622dc27ff9c4e6606eefef5cbbed4a5"
+
+[[package]]
+name = "fiat-crypto"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1676f435fc1dadde4d03e43f5d62b259e1ce5f40bd4ffb21db2b42ebe59c1382"
+
 [[package]]
 name = "fixed-hash"
 version = "0.8.0"
@@ -1194,9 +1251,9 @@ checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
 
 [[package]]
 name = "form_urlencoded"
-version = "1.1.0"
+version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a9c384f161156f5260c24a097c56119f9be8c798586aecc13afbcbe7b7e26bf8"
+checksum = "e13624c2627564efccf4934284bdd98cbaa14e79b0b5a141218e507b3a823456"
 dependencies = [
  "percent-encoding",
 ]
@@ -1207,7 +1264,7 @@ version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2e9763c69ebaae630ba35f74888db465e49e259ba1bc0eda7d06f4a067615d82"
 dependencies = [
- "bitflags",
+ "bitflags 1.3.2",
  "fuchsia-zircon-sys",
 ]
 
@@ -1225,9 +1282,9 @@ checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
 
 [[package]]
 name = "futures"
-version = "0.3.28"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "23342abe12aba583913b2e62f22225ff9c950774065e4bfb61a19cd9770fec40"
+checksum = "645c6916888f6cb6350d2550b80fb63e734897a8498abe35cfb732b6487804b0"
 dependencies = [
  "futures-channel",
  "futures-core",
@@ -1240,9 +1297,9 @@ dependencies = [
 
 [[package]]
 name = "futures-channel"
-version = "0.3.28"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "955518d47e09b25bbebc7a18df10b81f0c766eaf4c4f1cccef2fca5f2a4fb5f2"
+checksum = "eac8f7d7865dcb88bd4373ab671c8cf4508703796caa2b1985a9ca867b3fcb78"
 dependencies = [
  "futures-core",
  "futures-sink",
@@ -1250,15 +1307,15 @@ dependencies = [
 
 [[package]]
 name = "futures-core"
-version = "0.3.28"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4bca583b7e26f571124fe5b7561d49cb2868d79116cfa0eefce955557c6fee8c"
+checksum = "dfc6580bb841c5a68e9ef15c77ccc837b40a7504914d52e47b8b0e9bbda25a1d"
 
 [[package]]
 name = "futures-executor"
-version = "0.3.28"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ccecee823288125bd88b4d7f565c9e58e41858e47ab72e8ea2d64e93624386e0"
+checksum = "a576fc72ae164fca6b9db127eaa9a9dda0d61316034f33a0a0d4eda41f02b01d"
 dependencies = [
  "futures-core",
  "futures-task",
@@ -1267,17 +1324,17 @@ dependencies = [
 
 [[package]]
 name = "futures-io"
-version = "0.3.28"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4fff74096e71ed47f8e023204cfd0aa1289cd54ae5430a9523be060cdb849964"
+checksum = "a44623e20b9681a318efdd71c299b6b222ed6f231972bfe2f224ebad6311f0c1"
 
 [[package]]
 name = "futures-lite"
-version = "1.12.0"
+version = "1.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7694489acd39452c77daa48516b894c153f192c3578d5a839b62c58099fcbf48"
+checksum = "49a9d51ce47660b1e808d3c990b4709f2f415d928835a17dfd16991515c46bce"
 dependencies = [
- "fastrand",
+ "fastrand 1.9.0",
  "futures-core",
  "futures-io",
  "memchr",
@@ -1286,28 +1343,41 @@ dependencies = [
  "waker-fn",
 ]
 
+[[package]]
+name = "futures-lite"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "445ba825b27408685aaecefd65178908c36c6e96aaf6d8599419d46e624192ba"
+dependencies = [
+ "fastrand 2.0.1",
+ "futures-core",
+ "futures-io",
+ "parking",
+ "pin-project-lite",
+]
+
 [[package]]
 name = "futures-macro"
-version = "0.3.28"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "89ca545a94061b6365f2c7355b4b32bd20df3ff95f02da9329b34ccc3bd6ee72"
+checksum = "87750cf4b7a4c0625b1529e4c543c2182106e4dedc60a2a6455e00d212c489ac"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.29",
+ "syn 2.0.48",
 ]
 
 [[package]]
 name = "futures-sink"
-version = "0.3.28"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f43be4fe21a13b9781a69afa4985b0f6ee0e1afab2c6f454a8cf30e2b2237b6e"
+checksum = "9fb8e00e87438d937621c1c6269e53f536c14d3fbd6a042bb24879e57d474fb5"
 
 [[package]]
 name = "futures-task"
-version = "0.3.28"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76d3d132be6c0e6aa1534069c705a74a5997a356c0dc2f86a47765e5617c5b65"
+checksum = "38d84fa142264698cdce1a9f9172cf383a0c82de1bddcf3092901442c4097004"
 
 [[package]]
 name = "futures-timer"
@@ -1317,9 +1387,9 @@ checksum = "e64b03909df88034c26dc1547e8970b91f98bdb65165d6a4e9110d94263dbb2c"
 
 [[package]]
 name = "futures-util"
-version = "0.3.28"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26b01e40b772d54cf6c6d721c1d1abd0647a0106a12ecaa1c186273392a69533"
+checksum = "3d6401deb83407ab3da39eba7e33987a73c3df0c82b4bb5813ee871c19c41d48"
 dependencies = [
  "futures-channel",
  "futures-core",
@@ -1344,9 +1414,9 @@ dependencies = [
 
 [[package]]
 name = "generic-array"
-version = "0.14.6"
+version = "0.14.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bff49e947297f3312447abdca79f45f4738097cc82b06e72054d2223f601f1b9"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
 dependencies = [
  "typenum",
  "version_check",
@@ -1365,9 +1435,9 @@ dependencies = [
 
 [[package]]
 name = "getrandom"
-version = "0.2.8"
+version = "0.2.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c05aeb6a22b8f62540c194aac980f2115af067bfe15a0734d7277a768d396b31"
+checksum = "190092ea657667030ac6a35e305e62fc4dd69fd98ac98631e5d3a2b1575a12b5"
 dependencies = [
  "cfg-if 1.0.0",
  "libc",
@@ -1380,7 +1450,7 @@ version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "97304e4cd182c3846f7575ced3890c53012ce534ad9114046b0a9e00bb30a375"
 dependencies = [
- "opaque-debug 0.3.0",
+ "opaque-debug",
  "polyval 0.4.5",
 ]
 
@@ -1390,15 +1460,15 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d930750de5717d2dd0b8c0d42c076c0e884c81a73e6cab859bbd2339c71e3e40"
 dependencies = [
- "opaque-debug 0.3.0",
+ "opaque-debug",
  "polyval 0.6.1",
 ]
 
 [[package]]
 name = "gimli"
-version = "0.27.2"
+version = "0.28.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad0a93d233ebf96623465aad4046a8d3aa4da22d4f4beba5388838c8a434bbb4"
+checksum = "4271d37baee1b8c7e4b708028c57d816cf9d2434acb33a549475f78c181f6253"
 
 [[package]]
 name = "gloo-timers"
@@ -1414,9 +1484,9 @@ dependencies = [
 
 [[package]]
 name = "h2"
-version = "0.3.16"
+version = "0.3.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5be7b54589b581f624f566bf5d8eb2bab1db736c51528720b6bd36b96b55924d"
+checksum = "bb2c4422095b67ee78da96fbb51a4cc413b3b25883c7717ff7ca1ab31022c9c9"
 dependencies = [
  "bytes",
  "fnv",
@@ -1424,7 +1494,7 @@ dependencies = [
  "futures-sink",
  "futures-util",
  "http",
- "indexmap 1.9.2",
+ "indexmap",
  "slab",
  "tokio",
  "tokio-util",
@@ -1443,22 +1513,16 @@ version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d7afe4a420e3fe79967a00898cc1f4db7c8a49a9333a29f8a4bd76a253d5cd04"
 dependencies = [
- "ahash 0.4.7",
+ "ahash 0.4.8",
 ]
 
 [[package]]
 name = "hashbrown"
-version = "0.12.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
-
-[[package]]
-name = "hashbrown"
-version = "0.14.0"
+version = "0.14.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c6201b9ff9fd90a5a3bac2e56a830d0caa509576f0e503818ee82c181b3437a"
+checksum = "290f1a1d9242c78d09ce40a5e87e7554ee637af1351968159f4952f028f75604"
 dependencies = [
- "ahash 0.8.3",
+ "ahash 0.8.8",
  "allocator-api2",
  "serde",
 ]
@@ -1474,18 +1538,17 @@ dependencies = [
 
 [[package]]
 name = "headers"
-version = "0.3.8"
+version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3e372db8e5c0d213e0cd0b9be18be2aca3d44cf2fe30a9d46a65581cd454584"
+checksum = "06683b93020a07e3dbcf5f8c0f6d40080d725bea7936fc01ad345c01b97dc270"
 dependencies = [
- "base64 0.13.1",
- "bitflags",
+ "base64 0.21.7",
  "bytes",
  "headers-core",
  "http",
  "httpdate",
  "mime",
- "sha1 0.10.5",
+ "sha1 0.10.6",
 ]
 
 [[package]]
@@ -1514,18 +1577,9 @@ dependencies = [
 
 [[package]]
 name = "hermit-abi"
-version = "0.2.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee512640fe35acbfb4bb779db6f0d80704c2cacfa2e39b601ef3e3f47d1ae4c7"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "hermit-abi"
-version = "0.3.2"
+version = "0.3.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "443144c8cdadd93ebf52ddb4056d257f5b52c04d3c804e657d19eb73fc33668b"
+checksum = "bd5256b483761cd23699d0da46cc6fd2ee3be420bbe6d020ae4a091e70b7e9fd"
 
 [[package]]
 name = "hex"
@@ -1555,18 +1609,18 @@ dependencies = [
 
 [[package]]
 name = "home"
-version = "0.5.5"
+version = "0.5.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5444c27eef6923071f7ebcc33e3444508466a76f7a2b93da00ed6e19f30c1ddb"
+checksum = "e3d1354bf6b7235cb4a0576c2619fd4ed18183f689b12b006a0ee7329eeff9a5"
 dependencies = [
- "windows-sys 0.48.0",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
 name = "http"
-version = "0.2.9"
+version = "0.2.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd6effc99afb63425aff9b05836f029929e345a6148a14b7ecd5ab67af944482"
+checksum = "8947b1a6fad4393052c7ba1f4cd97bed3e953a95c79c92ad9b051a04611d9fbb"
 dependencies = [
  "bytes",
  "fnv",
@@ -1575,9 +1629,9 @@ dependencies = [
 
 [[package]]
 name = "http-body"
-version = "0.4.5"
+version = "0.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d5f38f16d184e36f2408a55281cd658ecbd3ca05cce6d6510a176eca393e26d1"
+checksum = "7ceab25649e9960c0311ea418d17bee82c0dcec1bd053b5f9a66e265a693bed2"
 dependencies = [
  "bytes",
  "http",
@@ -1591,11 +1645,11 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6e9b187a72d63adbfba487f48095306ac823049cb504ee195541e91c7775f5ad"
 dependencies = [
  "anyhow",
- "async-channel",
+ "async-channel 1.9.0",
  "async-std",
  "base64 0.13.1",
  "cookie",
- "futures-lite",
+ "futures-lite 1.13.0",
  "infer",
  "pin-project-lite",
  "rand 0.7.3",
@@ -1614,15 +1668,15 @@ checksum = "d897f394bad6a705d5f4104762e116a75639e470d80901eed05a860a95cb1904"
 
 [[package]]
 name = "httpdate"
-version = "1.0.2"
+version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4a1e36c821dbe04574f602848a19f742f4fb3c98d40449f11bcad18d6b17421"
+checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
 
 [[package]]
 name = "hyper"
-version = "0.14.25"
+version = "0.14.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cc5e554ff619822309ffd57d8734d77cd5ce6238bc956f037ea06c58238c9899"
+checksum = "bf96e135eb83a2a8ddf766e426a841d8ddd7449d5f00d34ea02b41d2f19eef80"
 dependencies = [
  "bytes",
  "futures-channel",
@@ -1635,7 +1689,7 @@ dependencies = [
  "httpdate",
  "itoa",
  "pin-project-lite",
- "socket2",
+ "socket2 0.5.5",
  "tokio",
  "tower-service",
  "tracing",
@@ -1644,9 +1698,9 @@ dependencies = [
 
 [[package]]
 name = "hyper-rustls"
-version = "0.24.1"
+version = "0.24.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8d78e1e73ec14cf7375674f74d7dde185c8206fd9dea6fb6295e8a98098aaa97"
+checksum = "ec3efd23720e2049821a693cbc7e65ea87c72f1c58ff2f9522ff332b1491e590"
 dependencies = [
  "futures-util",
  "http",
@@ -1658,33 +1712,32 @@ dependencies = [
 
 [[package]]
 name = "iana-time-zone"
-version = "0.1.53"
+version = "0.1.60"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64c122667b287044802d6ce17ee2ddf13207ed924c712de9a66a5814d5b64765"
+checksum = "e7ffbb5a1b541ea2561f8c41c087286cc091e21e556a4f09a8f6cbf17b69b141"
 dependencies = [
  "android_system_properties",
  "core-foundation-sys",
  "iana-time-zone-haiku",
  "js-sys",
  "wasm-bindgen",
- "winapi 0.3.9",
+ "windows-core",
 ]
 
 [[package]]
 name = "iana-time-zone-haiku"
-version = "0.1.1"
+version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0703ae284fc167426161c2e3f1da3ea71d94b21bedbcc9494e92b28e334e3dca"
+checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
 dependencies = [
- "cxx",
- "cxx-build",
+ "cc",
 ]
 
 [[package]]
 name = "idna"
-version = "0.3.0"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e14ddfc70884202db2244c223200c204c2bda1bc6e0998d11b5e024d657209e6"
+checksum = "634d9b1461af396cad843f47fdba5597a4f9e6ddd4bfb6ff5d85028c25cb12f6"
 dependencies = [
  "unicode-bidi",
  "unicode-normalization",
@@ -1712,22 +1765,12 @@ dependencies = [
 
 [[package]]
 name = "indexmap"
-version = "1.9.2"
+version = "2.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1885e79c1fc4b10f0e172c475f458b7f7b93061064d98c3293e98c5ba0c8b399"
-dependencies = [
- "autocfg",
- "hashbrown 0.12.3",
-]
-
-[[package]]
-name = "indexmap"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d5477fe2230a79769d8dc68e0eabf5437907c0457a5614a9e8dddb67f65eb65d"
+checksum = "233cf39063f058ea2caae4091bf4a3ef70a653afbc026f5c4a4135d114e3c177"
 dependencies = [
  "equivalent",
- "hashbrown 0.14.0",
+ "hashbrown 0.14.3",
 ]
 
 [[package]]
@@ -1742,7 +1785,7 @@ version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a0c10553d664a4d0bcff9f4215d0aac67a639cc68ef660840afe309b807bc9f5"
 dependencies = [
- "generic-array 0.14.6",
+ "generic-array 0.14.7",
 ]
 
 [[package]]
@@ -1769,7 +1812,7 @@ version = "1.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "eae7b9aee968036d54dce06cebaefd919e4472e753296daccd6d344e3e2df0c2"
 dependencies = [
- "hermit-abi 0.3.2",
+ "hermit-abi 0.3.6",
  "libc",
  "windows-sys 0.48.0",
 ]
@@ -1785,9 +1828,9 @@ dependencies = [
 
 [[package]]
 name = "ipnet"
-version = "2.7.1"
+version = "2.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "30e22bd8629359895450b59ea7a776c850561b96a3b1d31321c1949d9e6c9146"
+checksum = "8f518f335dce6725a761382244631d86cf0ccb2863413590b31338feb467f9c3"
 
 [[package]]
 name = "itertools"
@@ -1800,24 +1843,24 @@ dependencies = [
 
 [[package]]
 name = "itoa"
-version = "1.0.6"
+version = "1.0.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "453ad9f582a441959e5f0d088b02ce04cfe8d51a8eaf077f12ac6d3e94164ca6"
+checksum = "b1a46d1a171d865aa5f83f92695765caa047a9b4cbae2cbf37dbd613a793fd4c"
 
 [[package]]
 name = "js-sys"
-version = "0.3.61"
+version = "0.3.68"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "445dde2150c55e483f3d8416706b97ec8e8237c307e5b7b4b8dd15e6af2a0730"
+checksum = "406cda4b368d531c842222cf9d2600a9a4acce8d29423695379c6868a143a9ee"
 dependencies = [
  "wasm-bindgen",
 ]
 
 [[package]]
 name = "keccak"
-version = "0.1.3"
+version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3afef3b6eff9ce9d8ff9b3601125eec7f0c8cbac7abd14f355d053fa56c98768"
+checksum = "ecc2af9a1119c51f12a14607e783cb977bde58bc069ff0c3da1095e635d70654"
 dependencies = [
  "cpufeatures",
 ]
@@ -1849,15 +1892,15 @@ checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
 
 [[package]]
 name = "libc"
-version = "0.2.151"
+version = "0.2.153"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "302d7ab3130588088d277783b1e2d2e10c9e9e4a16dd9050e6ec93fb3e7048f4"
+checksum = "9c198f91728a82281a64e1f4f9eeb25d82cb32a5de251c6bd1b5154d63a8e7bd"
 
 [[package]]
 name = "libflate"
-version = "1.3.0"
+version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97822bf791bd4d5b403713886a5fbe8bf49520fe78e323b0dc480ca1a03e50b0"
+checksum = "5ff4ae71b685bbad2f2f391fe74f6b7659a34871c08b210fdc039e43bee07d18"
 dependencies = [
  "adler32",
  "crc32fast",
@@ -1873,12 +1916,23 @@ dependencies = [
  "rle-decode-fast",
 ]
 
+[[package]]
+name = "libredox"
+version = "0.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85c833ca1e66078851dba29046874e38f08b2c883700aa29a03ddd3b23814ee8"
+dependencies = [
+ "bitflags 2.4.2",
+ "libc",
+ "redox_syscall",
+]
+
 [[package]]
 name = "libsigner"
 version = "0.0.1"
 dependencies = [
  "clarity",
- "hashbrown 0.14.0",
+ "hashbrown 0.14.3",
  "libc",
  "libstackerdb",
  "rand 0.8.5",
@@ -1888,7 +1942,7 @@ dependencies = [
  "serde_derive",
  "serde_json",
  "serde_stacker",
- "sha2 0.10.6",
+ "sha2 0.10.8",
  "slog",
  "slog-json",
  "slog-term",
@@ -1919,24 +1973,21 @@ dependencies = [
  "serde",
  "serde_derive",
  "serde_stacker",
- "sha2 0.10.6",
+ "sha2 0.10.8",
  "stacks-common",
 ]
 
 [[package]]
-name = "link-cplusplus"
-version = "1.0.8"
+name = "linux-raw-sys"
+version = "0.3.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ecd207c9c713c34f95a097a5b029ac2ce6010530c7b49d7fea24d977dede04f5"
-dependencies = [
- "cc",
-]
+checksum = "ef53942eb7bf7ff43a617b3e2c1c4a5ecf5944a7c1bc12d7ee39bbb15e5c1519"
 
 [[package]]
 name = "linux-raw-sys"
-version = "0.3.8"
+version = "0.4.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ef53942eb7bf7ff43a617b3e2c1c4a5ecf5944a7c1bc12d7ee39bbb15e5c1519"
+checksum = "01cda141df6706de531b6c46c3a33ecca755538219bd484262fa09410c13539c"
 
 [[package]]
 name = "lock_api"
@@ -1950,11 +2001,10 @@ dependencies = [
 
 [[package]]
 name = "log"
-version = "0.4.17"
+version = "0.4.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "abb12e687cfb44aa40f41fc3978ef76448f9b6038cad6aef4259d3c095a2382e"
+checksum = "b5e6163cb8c49088c2c36f57875e58ccd8c87c7427f7fbd50ea6710b2f3f2e8f"
 dependencies = [
- "cfg-if 1.0.0",
  "value-bag",
 ]
 
@@ -1964,14 +2014,14 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8263075bb86c5a1b1427b5ae862e8889656f126e9f77c484496e8b47cf5c5558"
 dependencies = [
- "regex-automata",
+ "regex-automata 0.1.10",
 ]
 
 [[package]]
 name = "memchr"
-version = "2.5.0"
+version = "2.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
+checksum = "523dc4f511e55ab87b694dc30d0f820d60906ef06413f93d4d7a1385599cc149"
 
 [[package]]
 name = "memoffset"
@@ -1982,20 +2032,11 @@ dependencies = [
  "autocfg",
 ]
 
-[[package]]
-name = "memoffset"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d61c719bcfbcf5d62b3a09efa6088de8c54bc0bfcd3ea7ae39fcc186108b8de1"
-dependencies = [
- "autocfg",
-]
-
 [[package]]
 name = "mime"
-version = "0.3.16"
+version = "0.3.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a60c7ce501c71e03a9c9c0d35b861413ae925bd979cc7a4e30d060069aaac8d"
+checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
 
 [[package]]
 name = "mime_guess"
@@ -2009,9 +2050,9 @@ dependencies = [
 
 [[package]]
 name = "miniz_oxide"
-version = "0.6.2"
+version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b275950c28b37e794e8c55d88aeb5e139d0ce23fdbbeda68f8d7174abdf9e8fa"
+checksum = "9d811f3e15f28568be3407c8e7fdb6514c1cda3cb30683f15b6a1a1dc4ea14a7"
 dependencies = [
  "adler",
 ]
@@ -2037,14 +2078,13 @@ dependencies = [
 
 [[package]]
 name = "mio"
-version = "0.8.6"
+version = "0.8.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b9d9a46eff5b4ff64b45a9e316a6d1e0bc719ef429cbec4dc630684212bfdf9"
+checksum = "8f3d0b296e374a4e6f3c7b0a1f5a51d748a0d34c85e7dc48fc3fa9a87657fe09"
 dependencies = [
  "libc",
- "log",
  "wasi 0.11.0+wasi-snapshot-preview1",
- "windows-sys 0.45.0",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
@@ -2079,9 +2119,9 @@ dependencies = [
 
 [[package]]
 name = "net2"
-version = "0.2.38"
+version = "0.2.39"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "74d0df99cfcd2530b2e694f6e17e7f37b8e26bb23983ac530c0c97408837c631"
+checksum = "b13b648036a2339d06de780866fbdfda0dde886de7b3af2ddeba8b14f4ee34ac"
 dependencies = [
  "cfg-if 0.1.10",
  "libc",
@@ -2094,11 +2134,11 @@ version = "0.23.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8f3790c00a0150112de0f4cd161e3d7fc4b2d8a5542ffc35f099a2562aecb35c"
 dependencies = [
- "bitflags",
+ "bitflags 1.3.2",
  "cc",
  "cfg-if 1.0.0",
  "libc",
- "memoffset 0.6.5",
+ "memoffset",
 ]
 
 [[package]]
@@ -2112,31 +2152,27 @@ dependencies = [
 ]
 
 [[package]]
-name = "num-integer"
-version = "0.1.45"
+name = "num-conv"
+version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "225d3389fb3509a24c93f5c29eb6bde2586b98d9f016636dff58d7c6f7569cd9"
-dependencies = [
- "autocfg",
- "num-traits",
-]
+checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9"
 
 [[package]]
 name = "num-traits"
-version = "0.2.15"
+version = "0.2.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd"
+checksum = "da0df0e5185db44f69b44f26786fe401b6c293d1907744beaa7fa62b2e5a517a"
 dependencies = [
  "autocfg",
 ]
 
 [[package]]
 name = "num_cpus"
-version = "1.15.0"
+version = "1.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fac9e2da13b5eb447a6ce3d392f23a29d8694bff781bf03a16cd9ac8697593b"
+checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43"
 dependencies = [
- "hermit-abi 0.2.6",
+ "hermit-abi 0.3.6",
  "libc",
 ]
 
@@ -2151,18 +2187,18 @@ dependencies = [
 
 [[package]]
 name = "object"
-version = "0.30.3"
+version = "0.32.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ea86265d3d3dcb6a27fc51bd29a4bf387fae9d2986b823079d4986af253eb439"
+checksum = "a6a622008b6e321afc04970976f62ee297fdbaa6f95318ca343e3eebb9648441"
 dependencies = [
  "memchr",
 ]
 
 [[package]]
 name = "once_cell"
-version = "1.17.1"
+version = "1.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b7e5500299e16ebb147ae15a00a942af264cf3688f47923b8fc2cd5858f23ad3"
+checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
 
 [[package]]
 name = "oorandom"
@@ -2170,12 +2206,6 @@ version = "11.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0ab1bc2a289d34bd04a330323ac98a1b4bc82c9d9fcb1e66b63caa84da26b575"
 
-[[package]]
-name = "opaque-debug"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2839e79665f131bdb5782e51f2c6c9599c133c6098982a54c794358bf432529c"
-
 [[package]]
 name = "opaque-debug"
 version = "0.3.0"
@@ -2206,15 +2236,15 @@ dependencies = [
  "rand_core 0.6.4",
  "rustfmt-wrapper",
  "serde",
- "sha2 0.10.6",
- "syn 2.0.29",
+ "sha2 0.10.8",
+ "syn 2.0.48",
 ]
 
 [[package]]
 name = "parity-scale-codec"
-version = "3.5.0"
+version = "3.6.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ddb756ca205bd108aee3c62c6d3c994e1df84a59b9d6d4a5ea42ee1fd5a9a28"
+checksum = "881331e34fa842a2fb61cc2db9643a8fedc615e47cfcc52597d1af0db9a7e8fe"
 dependencies = [
  "arrayvec",
  "bitvec",
@@ -2226,9 +2256,9 @@ dependencies = [
 
 [[package]]
 name = "parity-scale-codec-derive"
-version = "3.1.4"
+version = "3.6.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86b26a931f824dd4eca30b3e43bb4f31cd5f0d3a403c5f5ff27106b805bfde7b"
+checksum = "be30eaf4b0a9fba5336683b38de57bb86d179a35862ba6bfcf57625d006bde5b"
 dependencies = [
  "proc-macro-crate",
  "proc-macro2",
@@ -2238,9 +2268,9 @@ dependencies = [
 
 [[package]]
 name = "parking"
-version = "2.0.0"
+version = "2.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "427c3892f9e783d91cc128285287e70a59e206ca452770ece88a76f7a3eddd72"
+checksum = "bb813b8af86854136c6922af0598d719255ecb2179515e6e7730d468f05c9cae"
 
 [[package]]
 name = "parking_lot"
@@ -2260,23 +2290,24 @@ checksum = "4c42a9226546d68acdd9c0a280d17ce19bfe27a46bf68784e4066115788d008e"
 dependencies = [
  "cfg-if 1.0.0",
  "libc",
- "redox_syscall 0.4.1",
+ "redox_syscall",
  "smallvec",
  "windows-targets 0.48.5",
 ]
 
 [[package]]
 name = "percent-encoding"
-version = "2.2.0"
+version = "2.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "478c572c3d73181ff3c2539045f6eb99e5491218eae919370993b890cdbdd98e"
+checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e"
 
 [[package]]
 name = "pest"
-version = "2.5.6"
+version = "2.7.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8cbd939b234e95d72bc393d51788aec68aeeb5d51e748ca08ff3aad58cb722f7"
+checksum = "219c0dcc30b6a27553f9cc242972b67f75b60eb0db71f0b5462f38b058c41546"
 dependencies = [
+ "memchr",
  "thiserror",
  "ucd-trie",
 ]
@@ -2289,29 +2320,29 @@ checksum = "5be167a7af36ee22fe3115051bc51f6e6c7054c9348e28deb4f49bd6f705a315"
 
 [[package]]
 name = "pin-project"
-version = "1.0.12"
+version = "1.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad29a609b6bcd67fee905812e544992d216af9d755757c05ed2d0e15a74c6ecc"
+checksum = "0302c4a0442c456bd56f841aee5c3bfd17967563f6fadc9ceb9f9c23cf3807e0"
 dependencies = [
  "pin-project-internal",
 ]
 
 [[package]]
 name = "pin-project-internal"
-version = "1.0.12"
+version = "1.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "069bdb1e05adc7a8990dce9cc75370895fbe4e3d58b9b73bf1aee56359344a55"
+checksum = "266c042b60c9c76b8d53061e52b2e0d1116abc57cefc8c5cd671619a56ac3690"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.48",
 ]
 
 [[package]]
 name = "pin-project-lite"
-version = "0.2.9"
+version = "0.2.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0a7ae3ac2f1173085d398531c705756c94a4c56843785df85a60c1a0afac116"
+checksum = "8afb450f006bf6385ca15ef45d71d2288452bc3683ce2e2cacc0d18e4be60b58"
 
 [[package]]
 name = "pin-utils"
@@ -2319,17 +2350,44 @@ version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
 
+[[package]]
+name = "piper"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "668d31b1c4eba19242f2088b2bf3316b82ca31082a8335764db4e083db7485d4"
+dependencies = [
+ "atomic-waker",
+ "fastrand 2.0.1",
+ "futures-io",
+]
+
+[[package]]
+name = "pkcs8"
+version = "0.10.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7"
+dependencies = [
+ "der",
+ "spki",
+]
+
 [[package]]
 name = "pkg-config"
-version = "0.3.26"
+version = "0.3.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ac9a59f73473f1b8d852421e59e64809f025994837ef743615c6d0c5b305160"
+checksum = "d231b230927b5e4ad203db57bbcbee2802f6bce620b1e4a9024a07d94e2907ec"
+
+[[package]]
+name = "platforms"
+version = "3.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "626dec3cac7cc0e1577a2ec3fc496277ec2baa084bebad95bb6fdbfae235f84c"
 
 [[package]]
 name = "plotters"
-version = "0.3.4"
+version = "0.3.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2538b639e642295546c50fcd545198c9d64ee2a38620a628724a3b266d5fbf97"
+checksum = "d2c224ba00d7cadd4d5c660deaf2098e5e80e07846537c51f9cfa4be50c1fd45"
 dependencies = [
  "num-traits",
  "plotters-backend",
@@ -2340,40 +2398,54 @@ dependencies = [
 
 [[package]]
 name = "plotters-backend"
-version = "0.3.4"
+version = "0.3.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "193228616381fecdc1224c62e96946dfbc73ff4384fba576e052ff8c1bea8142"
+checksum = "9e76628b4d3a7581389a35d5b6e2139607ad7c75b17aed325f210aa91f4a9609"
 
 [[package]]
 name = "plotters-svg"
-version = "0.3.3"
+version = "0.3.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f9a81d2759aae1dae668f783c308bc5c8ebd191ff4184aaa1b37f65a6ae5a56f"
+checksum = "38f6d39893cca0701371e3c27294f09797214b86f1fb951b89ade8ec04e2abab"
 dependencies = [
  "plotters-backend",
 ]
 
 [[package]]
 name = "polling"
-version = "2.6.0"
+version = "2.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e1f879b2998099c2d69ab9605d145d5b661195627eccc680002c4918a7fb6fa"
+checksum = "4b2d323e8ca7996b3e23126511a523f7e62924d93ecd5ae73b333815b0eb3dce"
 dependencies = [
  "autocfg",
- "bitflags",
+ "bitflags 1.3.2",
  "cfg-if 1.0.0",
  "concurrent-queue",
  "libc",
  "log",
  "pin-project-lite",
- "windows-sys 0.45.0",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "polling"
+version = "3.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "30054e72317ab98eddd8561db0f6524df3367636884b7b21b703e4b280a84a14"
+dependencies = [
+ "cfg-if 1.0.0",
+ "concurrent-queue",
+ "pin-project-lite",
+ "rustix 0.38.31",
+ "tracing",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
 name = "polynomial"
-version = "0.2.5"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a461f75483c9faefe81bdc7257732be9afe9953765e406f8ede2581185d66635"
+checksum = "27abb6e4638dcecc65a92b50d7f1d87dd6dea987ba71db987b6bf881f4877e9d"
 dependencies = [
  "num-traits",
  "serde",
@@ -2386,8 +2458,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "eebcc4aa140b9abd2bc40d9c3f7ccec842679cd79045ac3a7ac698c1a064b7cd"
 dependencies = [
  "cpuid-bool",
- "opaque-debug 0.3.0",
- "universal-hash 0.4.1",
+ "opaque-debug",
+ "universal-hash 0.4.0",
 ]
 
 [[package]]
@@ -2398,10 +2470,16 @@ checksum = "d52cff9d1d4dee5fe6d03729099f4a310a41179e0a10dbf542039873f2e826fb"
 dependencies = [
  "cfg-if 1.0.0",
  "cpufeatures",
- "opaque-debug 0.3.0",
+ "opaque-debug",
  "universal-hash 0.5.1",
 ]
 
+[[package]]
+name = "powerfmt"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
+
 [[package]]
 name = "pox-locking"
 version = "2.4.0"
@@ -2419,9 +2497,9 @@ checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
 
 [[package]]
 name = "primitive-types"
-version = "0.12.1"
+version = "0.12.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f3486ccba82358b11a77516035647c34ba167dfa53312630de83b12bd4f3d66"
+checksum = "0b34d9fd68ae0b74a41b21c03c2f62847aa0ffea044eee893b4c140b37e244e2"
 dependencies = [
  "fixed-hash",
  "impl-codec",
@@ -2430,12 +2508,11 @@ dependencies = [
 
 [[package]]
 name = "proc-macro-crate"
-version = "1.3.1"
+version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f4c021e1093a56626774e81216a4ce732a735e5bad4868a03f3ed65ca0c3919"
+checksum = "7e8366a6159044a37876a2b9817124296703c586a5c92e2c53751fa06d8d43e8"
 dependencies = [
- "once_cell",
- "toml_edit",
+ "toml_edit 0.20.7",
 ]
 
 [[package]]
@@ -2470,9 +2547,9 @@ checksum = "dc375e1527247fe1a97d8b7156678dfe7c1af2fc075c9a4db3690ecd2a148068"
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.67"
+version = "1.0.78"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d433d9f1a3e8c1263d9456598b16fec66f4acc9a74dacffd35c7bb09b3a1328"
+checksum = "e2422ad645d89c99f8f3e6b88a9fdeca7fabeac836b1002371c4367c8f984aae"
 dependencies = [
  "unicode-ident",
 ]
@@ -2508,9 +2585,9 @@ dependencies = [
 
 [[package]]
 name = "quote"
-version = "1.0.33"
+version = "1.0.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5267fca4496028628a95160fc423a33e8b2e6af8a5302579e322e4b520293cae"
+checksum = "291ec9ab5efd934aaf503a6466c5d5251535d108ee747472c3977cc5acc868ef"
 dependencies = [
  "proc-macro2",
 ]
@@ -2580,7 +2657,7 @@ version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
 dependencies = [
- "getrandom 0.2.8",
+ "getrandom 0.2.12",
 ]
 
 [[package]]
@@ -2594,9 +2671,9 @@ dependencies = [
 
 [[package]]
 name = "rayon"
-version = "1.7.0"
+version = "1.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d2df5196e37bcc87abebc0053e20787d73847bb33134a69841207dd0a47f03b"
+checksum = "fa7237101a77a10773db45d62004a272517633fbcc3df19d96455ede1122e051"
 dependencies = [
  "either",
  "rayon-core",
@@ -2604,32 +2681,12 @@ dependencies = [
 
 [[package]]
 name = "rayon-core"
-version = "1.11.0"
+version = "1.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b8f95bd6966f5c87776639160a66bd8ab9895d9d4ab01ddba9fc60661aebe8d"
+checksum = "1465873a3dfdaa8ae7cb14b4383657caab0b3e8a0aa9ae8e04b044854c8dfce2"
 dependencies = [
- "crossbeam-channel",
  "crossbeam-deque",
  "crossbeam-utils",
- "num_cpus",
-]
-
-[[package]]
-name = "redox_syscall"
-version = "0.2.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fb5a58c1855b4b6819d59012155603f0b22ad30cad752600aadfcb695265519a"
-dependencies = [
- "bitflags",
-]
-
-[[package]]
-name = "redox_syscall"
-version = "0.3.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "567664f262709473930a4bf9e51bf2ebf3348f2e748ccc50dea20646858f8f29"
-dependencies = [
- "bitflags",
 ]
 
 [[package]]
@@ -2638,29 +2695,30 @@ version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa"
 dependencies = [
- "bitflags",
+ "bitflags 1.3.2",
 ]
 
 [[package]]
 name = "redox_users"
-version = "0.4.3"
+version = "0.4.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b033d837a7cf162d7993aded9304e30a83213c648b6e389db233191f891e5c2b"
+checksum = "a18479200779601e498ada4e8c1e1f50e3ee19deb0259c25825a98b5603b2cb4"
 dependencies = [
- "getrandom 0.2.8",
- "redox_syscall 0.2.16",
+ "getrandom 0.2.12",
+ "libredox",
  "thiserror",
 ]
 
 [[package]]
 name = "regex"
-version = "1.7.1"
+version = "1.10.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48aaa5748ba571fb95cd2c85c09f629215d3a6ece942baa100950af03a34f733"
+checksum = "b62dbe01f0b06f9d8dc7d49e05a0785f153b00b2c227856282f671e0318c9b15"
 dependencies = [
  "aho-corasick",
  "memchr",
- "regex-syntax",
+ "regex-automata 0.4.5",
+ "regex-syntax 0.8.2",
 ]
 
 [[package]]
@@ -2669,14 +2727,31 @@ version = "0.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132"
 dependencies = [
- "regex-syntax",
+ "regex-syntax 0.6.29",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5bb987efffd3c6d0d8f5f89510bb458559eab11e4f869acb20bf845e016259cd"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax 0.8.2",
 ]
 
 [[package]]
 name = "regex-syntax"
-version = "0.6.28"
+version = "0.6.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1"
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "456c603be3e8d448b072f410900c09faf164fbce2d480456f50eea6e25f9c848"
+checksum = "c08c74e62047bb2de4ff487b251e4a92e24f48745648451635cec7d591162d9f"
 
 [[package]]
 name = "relay-server"
@@ -2684,11 +2759,11 @@ version = "0.0.1"
 
 [[package]]
 name = "reqwest"
-version = "0.11.22"
+version = "0.11.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "046cd98826c46c2ac8ddecae268eb5c2e58628688a5fc7a2643704a73faba95b"
+checksum = "c6920094eb85afde5e4a138be3f2de8bbdf28000f0029e72c45025a56b042251"
 dependencies = [
- "base64 0.21.0",
+ "base64 0.21.7",
  "bytes",
  "encoding_rs",
  "futures-core",
@@ -2710,6 +2785,7 @@ dependencies = [
  "serde",
  "serde_json",
  "serde_urlencoded",
+ "sync_wrapper",
  "system-configuration",
  "tokio",
  "tokio-rustls",
@@ -2732,18 +2808,32 @@ dependencies = [
  "libc",
  "once_cell",
  "spin 0.5.2",
- "untrusted",
+ "untrusted 0.7.1",
  "web-sys",
  "winapi 0.3.9",
 ]
 
+[[package]]
+name = "ring"
+version = "0.17.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "688c63d65483050968b2a8937f7995f443e27041a0f7700aa59b0822aedebb74"
+dependencies = [
+ "cc",
+ "getrandom 0.2.12",
+ "libc",
+ "spin 0.9.8",
+ "untrusted 0.9.0",
+ "windows-sys 0.48.0",
+]
+
 [[package]]
 name = "ripemd"
 version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bd124222d17ad93a644ed9d011a40f4fb64aa54275c08cc216524a9ea82fb09f"
 dependencies = [
- "digest 0.10.6",
+ "digest 0.10.7",
 ]
 
 [[package]]
@@ -2820,7 +2910,7 @@ version = "0.24.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d5f38ee71cbab2c827ec0ac24e76f82eca723cee92c509a65f67dee393c25112"
 dependencies = [
- "bitflags",
+ "bitflags 1.3.2",
  "byteorder",
  "fallible-iterator",
  "fallible-streaming-iterator",
@@ -2833,9 +2923,9 @@ dependencies = [
 
 [[package]]
 name = "rustc-demangle"
-version = "0.1.21"
+version = "0.1.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ef03e0a2b150c7a90d01faf6254c9c48a41e95fb2a8c2ac1c6f0d2b9aefc342"
+checksum = "d626bb9dae77e28219937af045c257c28bfd3f69333c512553507f5f9798cb76"
 
 [[package]]
 name = "rustc-hex"
@@ -2867,78 +2957,91 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366"
 dependencies = [
- "semver 1.0.17",
+ "semver 1.0.21",
 ]
 
 [[package]]
 name = "rustfmt-wrapper"
-version = "0.2.0"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed729e3bee08ec2befd593c27e90ca9fdd25efdc83c94c3b82eaef16e4f7406e"
+checksum = "f1adc9dfed5cc999077978cc7163b9282c5751c8d39827c4ea8c8c220ca5a440"
 dependencies = [
  "serde",
  "tempfile",
  "thiserror",
- "toml",
+ "toml 0.8.10",
  "toolchain_find",
 ]
 
 [[package]]
 name = "rustix"
-version = "0.37.7"
+version = "0.37.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2aae838e49b3d63e9274e1c01833cc8139d3fec468c3b84688c628f44b1ae11d"
+checksum = "fea8ca367a3a01fe35e6943c400addf443c0f57670e6ec51196f71a4b8762dd2"
 dependencies = [
- "bitflags",
+ "bitflags 1.3.2",
  "errno",
  "io-lifetimes",
  "libc",
- "linux-raw-sys",
- "windows-sys 0.45.0",
+ "linux-raw-sys 0.3.8",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "rustix"
+version = "0.38.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ea3e1a662af26cd7a3ba09c0297a31af215563ecf42817c98df621387f4e949"
+dependencies = [
+ "bitflags 2.4.2",
+ "errno",
+ "libc",
+ "linux-raw-sys 0.4.13",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
 name = "rustls"
-version = "0.21.7"
+version = "0.21.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd8d6c9f025a446bc4d18ad9632e69aec8f287aa84499ee335599fabd20c3fd8"
+checksum = "f9d5a6813c0759e4609cd494e8e725babae6a2ca7b62a5536a13daaec6fcb7ba"
 dependencies = [
  "log",
- "ring",
+ "ring 0.17.7",
  "rustls-webpki",
  "sct",
 ]
 
 [[package]]
 name = "rustls-pemfile"
-version = "1.0.2"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d194b56d58803a43635bdc398cd17e383d6f71f9182b9a192c127ca42494a59b"
+checksum = "1c74cae0a4cf6ccbbf5f359f08efdf8ee7e1dc532573bf0db71968cb56b1448c"
 dependencies = [
- "base64 0.21.0",
+ "base64 0.21.7",
 ]
 
 [[package]]
 name = "rustls-webpki"
-version = "0.101.4"
+version = "0.101.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d93931baf2d282fff8d3a532bbfd7653f734643161b87e3e01e59a04439bf0d"
+checksum = "8b6275d1ee7a1cd780b64aca7726599a1dbc893b1e64144529e55c3c2f745765"
 dependencies = [
- "ring",
- "untrusted",
+ "ring 0.17.7",
+ "untrusted 0.9.0",
 ]
 
 [[package]]
 name = "rustversion"
-version = "1.0.12"
+version = "1.0.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4f3208ce4d8448b3f3e7d168a73f5e0c43a61e32930de3bceeccedb388b6bf06"
+checksum = "7ffc183a10b4478d04cbbbfc96d0873219d962dd5accaff2ffbd4ceb7df837f4"
 
 [[package]]
 name = "ryu"
-version = "1.0.13"
+version = "1.0.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f91339c0467de62360649f8d3e185ca8de4224ff281f66000de5eb2a77a79041"
+checksum = "f98d2aa92eebf49b69786be48e4477826b256916e84a57ff2a4f21923b48eb4c"
 
 [[package]]
 name = "same-file"
@@ -2957,24 +3060,18 @@ checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294"
 
 [[package]]
 name = "scopeguard"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
-
-[[package]]
-name = "scratch"
-version = "1.0.5"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1792db035ce95be60c3f8853017b3999209281c24e2ba5bc8e59bf97a0c590c1"
+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
 
 [[package]]
 name = "sct"
-version = "0.7.0"
+version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d53dcdb7c9f8158937a7981b48accfd39a43af418591a5d008c7b22b5e1b7ca4"
+checksum = "da046153aa2352493d6cb7da4b6e5c0c057d8a1d0a9aa8560baffdd945acd414"
 dependencies = [
- "ring",
- "untrusted",
+ "ring 0.17.7",
+ "untrusted 0.9.0",
 ]
 
 [[package]]
@@ -3016,9 +3113,9 @@ dependencies = [
 
 [[package]]
 name = "semver"
-version = "1.0.17"
+version = "1.0.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bebd363326d05ec3e2f532ab7660680f3b02130d780c299bca73469d521bc0ed"
+checksum = "b97ed7a9823b74f99c7742f5336af7be5ecd3eeafcb1507d1fa93347b1d589b0"
 
 [[package]]
 name = "semver-parser"
@@ -3037,9 +3134,9 @@ dependencies = [
 
 [[package]]
 name = "serde"
-version = "1.0.156"
+version = "1.0.196"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "314b5b092c0ade17c00142951e50ced110ec27cea304b1037c6969246c2469a4"
+checksum = "870026e60fa08c69f064aa766c10f10b1d62db9ccd4d0abb206472bee0ce3b32"
 dependencies = [
  "serde_derive",
 ]
@@ -3056,20 +3153,20 @@ dependencies = [
 
 [[package]]
 name = "serde_derive"
-version = "1.0.156"
+version = "1.0.196"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7e29c4601e36bcec74a223228dce795f4cd3616341a4af93520ca1a837c087d"
+checksum = "33c85360c95e7d137454dc81d9a4ed2b8efd8fbe19cee57357b32b9771fccb67"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.48",
 ]
 
 [[package]]
 name = "serde_json"
-version = "1.0.94"
+version = "1.0.113"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c533a59c9d8a93a09c6ab31f0fd5e5f4dd1b8fc9434804029839884765d04ea"
+checksum = "69801b70b1c3dac963ecb03a364ba0ceda9cf60c71cfe475e99864759c8b8a79"
 dependencies = [
  "itoa",
  "ryu",
@@ -3087,11 +3184,20 @@ dependencies = [
  "thiserror",
 ]
 
+[[package]]
+name = "serde_spanned"
+version = "0.6.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eb3622f419d1296904700073ea6cc23ad690adbd66f13ea683df73298736f0c1"
+dependencies = [
+ "serde",
+]
+
 [[package]]
 name = "serde_stacker"
-version = "0.1.8"
+version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f5557f4c1103cecd0e639a17ab22d670b89912d8a506589ee627bf738a15a5d"
+checksum = "babfccff5773ff80657f0ecf553c7c516bdc2eb16389c0918b36b73e7015276e"
 dependencies = [
  "serde",
  "stacker",
@@ -3131,7 +3237,7 @@ checksum = "b93fb4adc70021ac1b47f7d45e8cc4169baaa7ea58483bc5b721d19a26202212"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.29",
+ "syn 2.0.48",
 ]
 
 [[package]]
@@ -3145,13 +3251,13 @@ dependencies = [
 
 [[package]]
 name = "sha1"
-version = "0.10.5"
+version = "0.10.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f04293dc80c3993519f2d7f6f511707ee7094fe0c6d3406feb330cdb3540eba3"
+checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba"
 dependencies = [
  "cfg-if 1.0.0",
  "cpufeatures",
- "digest 0.10.6",
+ "digest 0.10.7",
 ]
 
 [[package]]
@@ -3160,18 +3266,6 @@ version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ae1a47186c03a32177042e55dbc5fd5aee900b8e0069a8d70fba96a9375cd012"
 
-[[package]]
-name = "sha2"
-version = "0.8.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a256f46ea78a0c0d9ff00077504903ac881a1dafdc20da66545699e7776b3e69"
-dependencies = [
- "block-buffer 0.7.3",
- "digest 0.8.1",
- "fake-simd",
- "opaque-debug 0.2.3",
-]
-
 [[package]]
 name = "sha2"
 version = "0.9.9"
@@ -3182,19 +3276,19 @@ dependencies = [
  "cfg-if 1.0.0",
  "cpufeatures",
  "digest 0.9.0",
- "opaque-debug 0.3.0",
+ "opaque-debug",
 ]
 
 [[package]]
 name = "sha2"
-version = "0.10.6"
+version = "0.10.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "82e6b795fe2e3b1e845bafcb27aa35405c4d47cdfc92af5fc8d3002f76cebdc0"
+checksum = "793db75ad2bcafc3ffa7c68b215fee268f537982cd901d132f89c6343f3a3dc8"
 dependencies = [
  "cfg-if 1.0.0",
  "cpufeatures",
- "digest 0.10.6",
- "sha2-asm 0.6.2",
+ "digest 0.10.7",
+ "sha2-asm 0.6.3",
 ]
 
 [[package]]
@@ -3208,52 +3302,52 @@ dependencies = [
 
 [[package]]
 name = "sha2-asm"
-version = "0.6.2"
+version = "0.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf27176fb5d15398e3a479c652c20459d9dac830dedd1fa55b42a77dbcdbfcea"
+checksum = "f27ba7066011e3fb30d808b51affff34f0a66d3a03a58edd787c6e420e40e44e"
 dependencies = [
  "cc",
 ]
 
 [[package]]
 name = "sha3"
-version = "0.10.6"
+version = "0.10.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bdf0c33fae925bdc080598b84bc15c55e7b9a4a43b3c704da051f977469691c9"
+checksum = "75872d278a8f37ef87fa0ddbda7802605cb18344497949862c0d4dcb291eba60"
 dependencies = [
- "digest 0.10.6",
+ "digest 0.10.7",
  "keccak",
 ]
 
 [[package]]
 name = "sharded-slab"
-version = "0.1.6"
+version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1b21f559e07218024e7e9f90f96f601825397de0e25420135f7f952453fed0b"
+checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6"
 dependencies = [
  "lazy_static",
 ]
 
 [[package]]
-name = "simple-mutex"
-version = "1.1.5"
+name = "signature"
+version = "2.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38aabbeafa6f6dead8cebf246fe9fae1f9215c8d29b3a69f93bd62a9e4a3dcd6"
+checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de"
 dependencies = [
- "event-listener",
+ "rand_core 0.6.4",
 ]
 
 [[package]]
 name = "siphasher"
-version = "0.3.10"
+version = "0.3.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7bd3e3206899af3f8b12af284fafc038cc1dc2b41d1b89dd17297221c5d225de"
+checksum = "38b58827f4464d87d377d175e90bf58eb00fd8716ff0a62f80356b5e61555d0d"
 
 [[package]]
 name = "slab"
-version = "0.4.8"
+version = "0.4.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6528351c9bc8ab22353f9d776db39a20288e8d6c37ef8cfe3317cf875eecfc2d"
+checksum = "8f92a496fb766b417c996b9c5e57daf2f7ad3b0bebe1ccfca4856390e3d3bb67"
 dependencies = [
  "autocfg",
 ]
@@ -3273,7 +3367,7 @@ dependencies = [
  "serde",
  "serde_json",
  "slog",
- "time 0.3.20",
+ "time 0.3.34",
 ]
 
 [[package]]
@@ -3286,25 +3380,35 @@ dependencies = [
  "slog",
  "term",
  "thread_local",
- "time 0.3.20",
+ "time 0.3.34",
 ]
 
 [[package]]
 name = "smallvec"
-version = "1.10.0"
+version = "1.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a507befe795404456341dfab10cef66ead4c041f62b8b11bbb92bffe5d0953e0"
+checksum = "e6ecd384b10a64542d77071bd64bd7b231f4ed5940fba55e98c3de13824cf3d7"
 
 [[package]]
 name = "socket2"
-version = "0.4.9"
+version = "0.4.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64a4a911eed85daf18834cfaa86a79b7d266ff93ff5ba14005426219480ed662"
+checksum = "9f7916fc008ca5542385b89a3d3ce689953c143e9304a9bf8beec1de48994c0d"
 dependencies = [
  "libc",
  "winapi 0.3.9",
 ]
 
+[[package]]
+name = "socket2"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b5fac59a5cb5dd637972e5fca70daf0523c9067fcdc4842f053dae04a18f8e9"
+dependencies = [
+ "libc",
+ "windows-sys 0.48.0",
+]
+
 [[package]]
 name = "spin"
 version = "0.5.2"
@@ -3317,6 +3421,16 @@ version = "0.9.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67"
 
+[[package]]
+name = "spki"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d"
+dependencies = [
+ "base64ct",
+ "der",
+]
+
 [[package]]
 name = "stacker"
 version = "0.1.15"
@@ -3336,13 +3450,13 @@ version = "0.0.1"
 dependencies = [
  "assert-json-diff",
  "chrono",
- "curve25519-dalek",
+ "curve25519-dalek 2.0.0",
  "ed25519-dalek",
  "lazy_static",
  "libc",
  "nix",
  "percent-encoding",
- "rand 0.7.3",
+ "rand 0.8.5",
  "rand_core 0.6.4",
  "ripemd",
  "rstest 0.11.0",
@@ -3353,7 +3467,7 @@ dependencies = [
  "serde_derive",
  "serde_json",
  "serde_stacker",
- "sha2 0.10.6",
+ "sha2 0.10.8",
  "sha3",
  "slog",
  "slog-json",
@@ -3373,7 +3487,7 @@ dependencies = [
  "base64 0.12.3",
  "chrono",
  "clarity",
- "hashbrown 0.14.0",
+ "hashbrown 0.14.3",
  "http-types",
  "lazy_static",
  "libc",
@@ -3383,7 +3497,7 @@ dependencies = [
  "rand_core 0.6.4",
  "regex",
  "reqwest",
- "ring",
+ "ring 0.16.20",
  "rusqlite",
  "serde",
  "serde_derive",
@@ -3394,7 +3508,7 @@ dependencies = [
  "stackslib",
  "stx-genesis",
  "tokio",
- "toml",
+ "toml 0.5.11",
  "tracing",
  "tracing-subscriber",
  "warp",
@@ -3406,9 +3520,9 @@ name = "stacks-signer"
 version = "0.0.1"
 dependencies = [
  "backoff",
- "clap 4.4.1",
+ "clap 4.5.0",
  "clarity",
- "hashbrown 0.14.0",
+ "hashbrown 0.14.3",
  "libsigner",
  "libstackerdb",
  "rand 0.8.5",
@@ -3426,7 +3540,7 @@ dependencies = [
  "stacks-common",
  "stackslib",
  "thiserror",
- "toml",
+ "toml 0.5.11",
  "tracing",
  "tracing-subscriber",
  "wsts",
@@ -3440,9 +3554,9 @@ dependencies = [
  "chrono",
  "clarity",
  "criterion",
- "curve25519-dalek",
+ "curve25519-dalek 2.0.0",
  "ed25519-dalek",
- "hashbrown 0.14.0",
+ "hashbrown 0.14.3",
  "integer-sqrt",
  "lazy_static",
  "libc",
@@ -3452,8 +3566,8 @@ dependencies = [
  "percent-encoding",
  "pox-locking",
  "prometheus",
- "rand 0.7.3",
- "rand_chacha 0.2.2",
+ "rand 0.8.5",
+ "rand_chacha 0.3.1",
  "rand_core 0.6.4",
  "regex",
  "ripemd",
@@ -3465,7 +3579,7 @@ dependencies = [
  "serde_derive",
  "serde_json",
  "serde_stacker",
- "sha2 0.10.6",
+ "sha2 0.10.8",
  "sha3",
  "siphasher",
  "slog",
@@ -3497,9 +3611,9 @@ checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 
 [[package]]
 name = "stdext"
-version = "0.3.1"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f3b6b32ae82412fb897ef134867d53a294f57ba5b758f06d71e865352c3e207"
+checksum = "6012f6ef4d674ce7021a8b0f5093f7e339f54d4ba04fc1f9c901659459b4f35b"
 
 [[package]]
 name = "stdweb"
@@ -3552,23 +3666,23 @@ checksum = "213701ba3370744dcd1a12960caa4843b3d68b4d1c0a5d575e0d65b2ee9d16c0"
 
 [[package]]
 name = "strsim"
-version = "0.10.0"
+version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
+checksum = "5ee073c9e4cd00e28217186dbe12796d692868f432bf2e97ee73bed0c56dfa01"
 
 [[package]]
 name = "stx-genesis"
 version = "0.1.0"
 dependencies = [
  "libflate",
- "sha2 0.10.6",
+ "sha2 0.10.8",
 ]
 
 [[package]]
 name = "subtle"
-version = "2.4.1"
+version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6bdef32e8150c2a081110b42772ffe7d7c9032b606bc226c8260fd97e0976601"
+checksum = "81cdd64d312baedb58e21336b31bc043b77e01cc99033ce76ef539f78e965ebc"
 
 [[package]]
 name = "syn"
@@ -3583,22 +3697,28 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.29"
+version = "2.0.48"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c324c494eba9d92503e6f1ef2e6df781e78f6a7705a0202d9801b198807d518a"
+checksum = "0f3531638e407dfc0814761abb7c00a5b54992b849452a0646b7f65c9f770f3f"
 dependencies = [
  "proc-macro2",
  "quote",
  "unicode-ident",
 ]
 
+[[package]]
+name = "sync_wrapper"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2047c6ded9c721764247e62cd3b03c09ffc529b2ba5b10ec482ae507a4a70160"
+
 [[package]]
 name = "system-configuration"
 version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ba3a3adc5c275d719af8cb4272ea1c4a6d668a777f37e115f6d11ddbc1c8e0e7"
 dependencies = [
- "bitflags",
+ "bitflags 1.3.2",
  "core-foundation",
  "system-configuration-sys",
 ]
@@ -3621,15 +3741,14 @@ checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
 
 [[package]]
 name = "tempfile"
-version = "3.5.0"
+version = "3.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b9fbec84f381d5795b08656e4912bec604d162bff9291d6189a78f4c8ab87998"
+checksum = "a365e8cd18e44762ef95d87f284f4b5cd04107fec2ff3052bd6a3e6069669e67"
 dependencies = [
  "cfg-if 1.0.0",
- "fastrand",
- "redox_syscall 0.3.5",
- "rustix",
- "windows-sys 0.45.0",
+ "fastrand 2.0.1",
+ "rustix 0.38.31",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
@@ -3643,15 +3762,6 @@ dependencies = [
  "winapi 0.3.9",
 ]
 
-[[package]]
-name = "termcolor"
-version = "1.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "be55cf8942feac5c765c2c993422806843c9a9a45d4d5c407ad6dd2ea95eb9b6"
-dependencies = [
- "winapi-util",
-]
-
 [[package]]
 name = "textwrap"
 version = "0.11.0"
@@ -3663,22 +3773,22 @@ dependencies = [
 
 [[package]]
 name = "thiserror"
-version = "1.0.39"
+version = "1.0.57"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5ab016db510546d856297882807df8da66a16fb8c4101cb8b30054b0d5b2d9c"
+checksum = "1e45bcbe8ed29775f228095caf2cd67af7a4ccf756ebff23a306bf3e8b47b24b"
 dependencies = [
  "thiserror-impl",
 ]
 
 [[package]]
 name = "thiserror-impl"
-version = "1.0.39"
+version = "1.0.57"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5420d42e90af0c38c3290abcca25b9b3bdf379fc9f55c528f53a269d9c9a267e"
+checksum = "a953cb265bef375dae3de6663da4d3804eee9682ea80d8e2542529b73c531c81"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.48",
 ]
 
 [[package]]
@@ -3691,17 +3801,6 @@ dependencies = [
  "once_cell",
 ]
 
-[[package]]
-name = "time"
-version = "0.1.45"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b797afad3f312d1c66a56d11d0316f916356d11bd158fbc6ca6389ff6bf805a"
-dependencies = [
- "libc",
- "wasi 0.10.0+wasi-snapshot-preview1",
- "winapi 0.3.9",
-]
-
 [[package]]
 name = "time"
 version = "0.2.27"
@@ -3719,23 +3818,26 @@ dependencies = [
 
 [[package]]
 name = "time"
-version = "0.3.20"
+version = "0.3.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd0cbfecb4d19b5ea75bb31ad904eb5b9fa13f21079c3b92017ebdf4999a5890"
+checksum = "c8248b6521bb14bc45b4067159b9b6ad792e2d6d754d6c41fb50e29fefe38749"
 dependencies = [
+ "deranged",
  "itoa",
  "libc",
+ "num-conv",
  "num_threads",
+ "powerfmt",
  "serde",
  "time-core",
- "time-macros 0.2.8",
+ "time-macros 0.2.17",
 ]
 
 [[package]]
 name = "time-core"
-version = "0.1.0"
+version = "0.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2e153e1f1acaef8acc537e68b44906d2db6436e2b35ac2c6b42640fff91f00fd"
+checksum = "ef927ca75afb808a4d64dd374f00a2adf8d0fcff8e7b184af886c3c87ec4a3f3"
 
 [[package]]
 name = "time-macros"
@@ -3749,10 +3851,11 @@ dependencies = [
 
 [[package]]
 name = "time-macros"
-version = "0.2.8"
+version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fd80a657e71da814b8e5d60d3374fc6d35045062245d80224748ae522dd76f36"
+checksum = "7ba3a3ef41e6672a2f0f001392bb5dcd3ff0a9992d618ca761a11c3121547774"
 dependencies = [
+ "num-conv",
  "time-core",
 ]
 
@@ -3808,19 +3911,18 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
 
 [[package]]
 name = "tokio"
-version = "1.26.0"
+version = "1.36.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "03201d01c3c27a29c8a5cee5b55a93ddae1ccf6f08f65365c2c918f8c1b76f64"
+checksum = "61285f6515fa018fb2d1e46eb21223fff441ee8db5d0f1435e8ab4f5cdb80931"
 dependencies = [
- "autocfg",
+ "backtrace",
  "bytes",
  "libc",
- "memchr",
- "mio 0.8.6",
+ "mio 0.8.10",
  "num_cpus",
  "pin-project-lite",
- "socket2",
- "windows-sys 0.45.0",
+ "socket2 0.5.5",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
@@ -3835,9 +3937,9 @@ dependencies = [
 
 [[package]]
 name = "tokio-stream"
-version = "0.1.12"
+version = "0.1.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8fb52b74f05dbf495a8fba459fdc331812b96aa086d9eb78101fa0d4569c3313"
+checksum = "397c988d37662c7dda6d2208364a706264bf3d6138b11d436cbac0ad38832842"
 dependencies = [
  "futures-core",
  "pin-project-lite",
@@ -3846,9 +3948,9 @@ dependencies = [
 
 [[package]]
 name = "tokio-tungstenite"
-version = "0.18.0"
+version = "0.20.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "54319c93411147bced34cb5609a80e0a8e44c5999c93903a81cd866630ec0bfd"
+checksum = "212d5dcb2a1ce06d81107c3d0ffa3121fe974b73f068c8282cb1c32328113b6c"
 dependencies = [
  "futures-util",
  "log",
@@ -3858,9 +3960,9 @@ dependencies = [
 
 [[package]]
 name = "tokio-util"
-version = "0.7.7"
+version = "0.7.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5427d89453009325de0d8f342c9490009f76e999cb7672d77e46267448f7e6b2"
+checksum = "5419f34732d9eb6ee4c3578b7989078579b7f039cbbb9ca2c4da015749371e15"
 dependencies = [
  "bytes",
  "futures-core",
@@ -3879,33 +3981,61 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "toml"
+version = "0.8.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a9aad4a3066010876e8dcf5a8a06e70a558751117a145c6ce2b82c2e2054290"
+dependencies = [
+ "serde",
+ "serde_spanned",
+ "toml_datetime",
+ "toml_edit 0.22.5",
+]
+
 [[package]]
 name = "toml_datetime"
-version = "0.6.3"
+version = "0.6.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7cda73e2f1397b1262d6dfdcef8aafae14d1de7748d66822d3bfeeb6d03e5e4b"
+checksum = "3550f4e9685620ac18a50ed434eb3aec30db8ba93b0287467bca5826ea25baf1"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "toml_edit"
+version = "0.20.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70f427fce4d84c72b5b732388bf4a9f4531b53f74e2887e3ecb2481f68f66d81"
+dependencies = [
+ "indexmap",
+ "toml_datetime",
+ "winnow 0.5.40",
+]
 
 [[package]]
 name = "toml_edit"
-version = "0.19.14"
+version = "0.22.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8123f27e969974a3dfba720fdb560be359f57b44302d280ba72e76a74480e8a"
+checksum = "99e68c159e8f5ba8a28c4eb7b0c0c190d77bb479047ca713270048145a9ad28a"
 dependencies = [
- "indexmap 2.0.0",
+ "indexmap",
+ "serde",
+ "serde_spanned",
  "toml_datetime",
- "winnow",
+ "winnow 0.6.1",
 ]
 
 [[package]]
 name = "toolchain_find"
-version = "0.2.0"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e85654a10e7a07a47c6f19d93818f3f343e22927f2fa280c84f7c8042743413"
+checksum = "ebc8c9a7f0a2966e1acdaf0461023d0b01471eeead645370cf4c3f5cff153f2a"
 dependencies = [
  "home",
- "lazy_static",
+ "once_cell",
  "regex",
- "semver 0.11.0",
+ "semver 1.0.21",
  "walkdir",
 ]
 
@@ -3917,11 +4047,10 @@ checksum = "b6bc1c9ce2b5135ac7f93c72918fc37feb872bdc6a5533a8b85eb4b86bfdae52"
 
 [[package]]
 name = "tracing"
-version = "0.1.37"
+version = "0.1.40"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ce8c33a8d48bd45d624a6e523445fd21ec13d3653cd51f681abf67418f54eb8"
+checksum = "c3523ab5a71916ccf420eebdf5521fcef02141234bbc0b8a49f2fdc4544364ef"
 dependencies = [
- "cfg-if 1.0.0",
  "log",
  "pin-project-lite",
  "tracing-attributes",
@@ -3930,20 +4059,20 @@ dependencies = [
 
 [[package]]
 name = "tracing-attributes"
-version = "0.1.26"
+version = "0.1.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f4f31f56159e98206da9efd823404b79b6ef3143b4a7ab76e67b1751b25a4ab"
+checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.29",
+ "syn 2.0.48",
 ]
 
 [[package]]
 name = "tracing-core"
-version = "0.1.30"
+version = "0.1.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24eb03ba0eab1fd845050058ce5e616558e8f8d8fca633e6b163fe25c797213a"
+checksum = "c06d3da6113f116aaee68e4d601191614c9053067f9ab7f6edbcb161237daa54"
 dependencies = [
  "once_cell",
  "valuable",
@@ -3951,20 +4080,20 @@ dependencies = [
 
 [[package]]
 name = "tracing-log"
-version = "0.1.3"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78ddad33d2d10b1ed7eb9d1f518a5674713876e97e5bb9b7345a7984fbb4f922"
+checksum = "ee855f1f400bd0e5c02d150ae5de3840039a3f54b025156404e34c23c03f47c3"
 dependencies = [
- "lazy_static",
  "log",
+ "once_cell",
  "tracing-core",
 ]
 
 [[package]]
 name = "tracing-subscriber"
-version = "0.3.17"
+version = "0.3.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "30a651bc37f915e81f087d86e62a18eec5f79550c7faff886f7090b4ea757c77"
+checksum = "ad0f048c97dbd9faa9b7df56362b8ebcaa52adb06b498c050d2f4e32f90a7a8b"
 dependencies = [
  "matchers",
  "nu-ansi-term",
@@ -3980,24 +4109,24 @@ dependencies = [
 
 [[package]]
 name = "try-lock"
-version = "0.2.4"
+version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3528ecfd12c466c6f163363caf2d02a71161dd5e1cc6ae7b34207ea2d42d81ed"
+checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
 
 [[package]]
 name = "tungstenite"
-version = "0.18.0"
+version = "0.20.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "30ee6ab729cd4cf0fd55218530c4522ed30b7b6081752839b68fcec8d0960788"
+checksum = "9e3dac10fd62eaf6617d3a904ae222845979aec67c615d1c842b4002c7666fb9"
 dependencies = [
- "base64 0.13.1",
  "byteorder",
  "bytes",
+ "data-encoding",
  "http",
  "httparse",
  "log",
  "rand 0.8.5",
- "sha1 0.10.5",
+ "sha1 0.10.6",
  "thiserror",
  "url",
  "utf-8",
@@ -4005,15 +4134,15 @@ dependencies = [
 
 [[package]]
 name = "typenum"
-version = "1.16.0"
+version = "1.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "497961ef93d974e23eb6f433eb5fe1b7930b659f06d12dec6fc44a8f554c0bba"
+checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"
 
 [[package]]
 name = "ucd-trie"
-version = "0.1.5"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e79c4d996edb816c91e4308506774452e55e95c3c9de07b6729e17e15a5ef81"
+checksum = "ed646292ffc8188ef8ea4d1e0e0150fb15a5c2e12ad9b8fc191ae7a8a7f3c4b9"
 
 [[package]]
 name = "uint"
@@ -4029,24 +4158,24 @@ dependencies = [
 
 [[package]]
 name = "unicase"
-version = "2.6.0"
+version = "2.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50f37be617794602aabbeee0be4f259dc1778fabe05e2d67ee8f79326d5cb4f6"
+checksum = "f7d2d4dafb69621809a81864c9c1b864479e1235c0dd4e199924b9742439ed89"
 dependencies = [
  "version_check",
 ]
 
 [[package]]
 name = "unicode-bidi"
-version = "0.3.11"
+version = "0.3.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "524b68aca1d05e03fdf03fcdce2c6c94b6daf6d16861ddaa7e4f2b6638a9052c"
+checksum = "08f95100a766bf4f8f28f90d77e0a5461bbdb219042e7679bebe79004fed8d75"
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.8"
+version = "1.0.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5464a87b239f13a63a501f2701565754bae92d243d4bb7eb12f6d57d2269bf4"
+checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
 
 [[package]]
 name = "unicode-normalization"
@@ -4059,17 +4188,17 @@ dependencies = [
 
 [[package]]
 name = "unicode-width"
-version = "0.1.10"
+version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0edd1e5b14653f783770bce4a4dabb4a5108a5370a5f5d8cfe8710c361f6c8b"
+checksum = "e51733f11c9c4f72aa0c160008246859e340b00807569a0da0e7a1079b27ba85"
 
 [[package]]
 name = "universal-hash"
-version = "0.4.1"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f214e8f697e925001e66ec2c6e37a4ef93f0f78c2eed7814394e10c62025b05"
+checksum = "8326b2c654932e3e4f9196e69d08fdf7cfd718e1dc6f66b347e6024a0c961402"
 dependencies = [
- "generic-array 0.14.6",
+ "generic-array 0.14.7",
  "subtle",
 ]
 
@@ -4089,11 +4218,17 @@ version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a"
 
+[[package]]
+name = "untrusted"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
+
 [[package]]
 name = "url"
-version = "2.3.1"
+version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d68c799ae75762b8c3fe375feb6600ef5602c883c5d21eb51c09f22b83c4643"
+checksum = "31e6302e3bb753d46e83516cae55ae196fc0c309407cf11ab35cc51a4c2a4633"
 dependencies = [
  "form_urlencoded",
  "idna",
@@ -4121,13 +4256,9 @@ checksum = "830b7e5d4d90034032940e4ace0d9a9a057e7a45cd94e6c007832e39edb82f6d"
 
 [[package]]
 name = "value-bag"
-version = "1.0.0-alpha.9"
+version = "1.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2209b78d1249f7e6f3293657c9779fe31ced465df091bbd433a1cf88e916ec55"
-dependencies = [
- "ctor",
- "version_check",
-]
+checksum = "126e423afe2dd9ac52142e7e9d5ce4135d7e13776c529d27fd6bc49f19e3280b"
 
 [[package]]
 name = "vcpkg"
@@ -4143,36 +4274,34 @@ checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
 
 [[package]]
 name = "waker-fn"
-version = "1.1.0"
+version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9d5b2c62b4012a3e1eca5a7e077d13b3bf498c4073e33ccd58626607748ceeca"
+checksum = "f3c4517f54858c779bbcbf228f4fca63d121bf85fbecb2dc578cdf4a39395690"
 
 [[package]]
 name = "walkdir"
-version = "2.3.2"
+version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "808cf2735cd4b6866113f648b791c6adc5714537bc222d9347bb203386ffda56"
+checksum = "d71d857dc86794ca4c280d616f7da00d2dbfd8cd788846559a6813e6aa4b54ee"
 dependencies = [
  "same-file",
- "winapi 0.3.9",
  "winapi-util",
 ]
 
 [[package]]
 name = "want"
-version = "0.3.0"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ce8a968cb1cd110d136ff8b819a556d6fb6d919363c61534f6860c7eb172ba0"
+checksum = "bfa7760aed19e106de2c7c0b581b509f2f25d3dacaf737cb82ac61bc6d760b0e"
 dependencies = [
- "log",
  "try-lock",
 ]
 
 [[package]]
 name = "warp"
-version = "0.3.5"
+version = "0.3.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba431ef570df1287f7f8b07e376491ad54f84d26ac473489427231e1718e1f69"
+checksum = "c1e92e22e03ff1230c03a1a8ee37d2f89cd489e2e541b7550d6afad96faed169"
 dependencies = [
  "bytes",
  "futures-channel",
@@ -4205,12 +4334,6 @@ version = "0.9.0+wasi-snapshot-preview1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519"
 
-[[package]]
-name = "wasi"
-version = "0.10.0+wasi-snapshot-preview1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a143597ca7c7793eff794def352d41792a93c481eb1042423ff7ff72ba2c31f"
-
 [[package]]
 name = "wasi"
 version = "0.11.0+wasi-snapshot-preview1"
@@ -4219,9 +4342,9 @@ checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.84"
+version = "0.2.91"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "31f8dcbc21f30d9b8f2ea926ecb58f6b91192c17e9d33594b3df58b2007ca53b"
+checksum = "c1e124130aee3fb58c5bdd6b639a0509486b0338acaaae0c84a5124b0f588b7f"
 dependencies = [
  "cfg-if 1.0.0",
  "wasm-bindgen-macro",
@@ -4229,24 +4352,24 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-backend"
-version = "0.2.84"
+version = "0.2.91"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95ce90fd5bcc06af55a641a86428ee4229e44e07033963a2290a8e241607ccb9"
+checksum = "c9e7e1900c352b609c8488ad12639a311045f40a35491fb69ba8c12f758af70b"
 dependencies = [
  "bumpalo",
  "log",
  "once_cell",
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.48",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-futures"
-version = "0.4.34"
+version = "0.4.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f219e0d211ba40266969f6dbdd90636da12f75bee4fc9d6c23d1260dadb51454"
+checksum = "877b9c3f61ceea0e56331985743b13f3d25c406a7098d45180fb5f09bc19ed97"
 dependencies = [
  "cfg-if 1.0.0",
  "js-sys",
@@ -4256,9 +4379,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.84"
+version = "0.2.91"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c21f77c0bedc37fd5dc21f897894a5ca01e7bb159884559461862ae90c0b4c5"
+checksum = "b30af9e2d358182b5c7449424f017eba305ed32a7010509ede96cdc4696c46ed"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -4266,28 +4389,28 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.84"
+version = "0.2.91"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2aff81306fcac3c7515ad4e177f521b5c9a15f2b08f4e32d823066102f35a5f6"
+checksum = "642f325be6301eb8107a83d12a8ac6c1e1c54345a7ef1a9261962dfefda09e66"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn 2.0.48",
  "wasm-bindgen-backend",
  "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.84"
+version = "0.2.91"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0046fef7e28c3804e5e38bfa31ea2a0f73905319b677e57ebe37e49358989b5d"
+checksum = "4f186bd2dcf04330886ce82d6f33dd75a7bfcf69ecf5763b89fcde53b6ac9838"
 
 [[package]]
 name = "web-sys"
-version = "0.3.61"
+version = "0.3.68"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e33b99f4b23ba3eec1a53ac264e35a755f00e966e0065077d6027c0f575b0b97"
+checksum = "96565907687f7aceb35bc5fc03770a8a0471d82e479f25832f54a0e3f4b28446"
 dependencies = [
  "js-sys",
  "wasm-bindgen",
@@ -4295,9 +4418,9 @@ dependencies = [
 
 [[package]]
 name = "webpki-roots"
-version = "0.25.2"
+version = "0.25.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14247bb57be4f377dfb94c72830b8ce8fc6beac03cf4bf7b9732eadd414123fc"
+checksum = "5f20c57d8d7db6d3b86154206ae5d8fba62dd39573114de97c2cb0578251f8e1"
 
 [[package]]
 name = "winapi"
@@ -4329,9 +4452,9 @@ checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
 
 [[package]]
 name = "winapi-util"
-version = "0.1.5"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
+checksum = "f29e6f9198ba0d26b4c9f07dbe6f9ed633e1f3d5b8b414090084349e46a52596"
 dependencies = [
  "winapi 0.3.9",
 ]
@@ -4343,27 +4466,12 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
 [[package]]
-name = "windows-sys"
-version = "0.42.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a3e1820f08b8513f676f7ab6c1f99ff312fb97b553d30ff4dd86f9f15728aa7"
-dependencies = [
- "windows_aarch64_gnullvm 0.42.2",
- "windows_aarch64_msvc 0.42.2",
- "windows_i686_gnu 0.42.2",
- "windows_i686_msvc 0.42.2",
- "windows_x86_64_gnu 0.42.2",
- "windows_x86_64_gnullvm 0.42.2",
- "windows_x86_64_msvc 0.42.2",
-]
-
-[[package]]
-name = "windows-sys"
-version = "0.45.0"
+name = "windows-core"
+version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0"
+checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9"
 dependencies = [
- "windows-targets 0.42.2",
+ "windows-targets 0.52.0",
 ]
 
 [[package]]
@@ -4376,18 +4484,12 @@ dependencies = [
 ]
 
 [[package]]
-name = "windows-targets"
-version = "0.42.2"
+name = "windows-sys"
+version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071"
+checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
 dependencies = [
- "windows_aarch64_gnullvm 0.42.2",
- "windows_aarch64_msvc 0.42.2",
- "windows_i686_gnu 0.42.2",
- "windows_i686_msvc 0.42.2",
- "windows_x86_64_gnu 0.42.2",
- "windows_x86_64_gnullvm 0.42.2",
- "windows_x86_64_msvc 0.42.2",
+ "windows-targets 0.52.0",
 ]
 
 [[package]]
@@ -4406,10 +4508,19 @@ dependencies = [
 ]
 
 [[package]]
-name = "windows_aarch64_gnullvm"
-version = "0.42.2"
+name = "windows-targets"
+version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8"
+checksum = "8a18201040b24831fbb9e4eb208f8892e1f50a37feb53cc7ff887feb8f50e7cd"
+dependencies = [
+ "windows_aarch64_gnullvm 0.52.0",
+ "windows_aarch64_msvc 0.52.0",
+ "windows_i686_gnu 0.52.0",
+ "windows_i686_msvc 0.52.0",
+ "windows_x86_64_gnu 0.52.0",
+ "windows_x86_64_gnullvm 0.52.0",
+ "windows_x86_64_msvc 0.52.0",
+]
 
 [[package]]
 name = "windows_aarch64_gnullvm"
@@ -4418,10 +4529,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
 
 [[package]]
-name = "windows_aarch64_msvc"
-version = "0.42.2"
+name = "windows_aarch64_gnullvm"
+version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43"
+checksum = "cb7764e35d4db8a7921e09562a0304bf2f93e0a51bfccee0bd0bb0b666b015ea"
 
 [[package]]
 name = "windows_aarch64_msvc"
@@ -4430,10 +4541,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
 
 [[package]]
-name = "windows_i686_gnu"
-version = "0.42.2"
+name = "windows_aarch64_msvc"
+version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f"
+checksum = "bbaa0368d4f1d2aaefc55b6fcfee13f41544ddf36801e793edbbfd7d7df075ef"
 
 [[package]]
 name = "windows_i686_gnu"
@@ -4442,10 +4553,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
 
 [[package]]
-name = "windows_i686_msvc"
-version = "0.42.2"
+name = "windows_i686_gnu"
+version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060"
+checksum = "a28637cb1fa3560a16915793afb20081aba2c92ee8af57b4d5f28e4b3e7df313"
 
 [[package]]
 name = "windows_i686_msvc"
@@ -4454,10 +4565,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
 
 [[package]]
-name = "windows_x86_64_gnu"
-version = "0.42.2"
+name = "windows_i686_msvc"
+version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36"
+checksum = "ffe5e8e31046ce6230cc7215707b816e339ff4d4d67c65dffa206fd0f7aa7b9a"
 
 [[package]]
 name = "windows_x86_64_gnu"
@@ -4466,10 +4577,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
 
 [[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.42.2"
+name = "windows_x86_64_gnu"
+version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3"
+checksum = "3d6fa32db2bc4a2f5abeacf2b69f7992cd09dca97498da74a151a3132c26befd"
 
 [[package]]
 name = "windows_x86_64_gnullvm"
@@ -4478,10 +4589,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
 
 [[package]]
-name = "windows_x86_64_msvc"
-version = "0.42.2"
+name = "windows_x86_64_gnullvm"
+version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0"
+checksum = "1a657e1e9d3f514745a572a6846d3c7aa7dbe1658c056ed9c3344c4109a6949e"
 
 [[package]]
 name = "windows_x86_64_msvc"
@@ -4489,11 +4600,26 @@ version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
 
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dff9641d1cd4be8d1a070daf9e3773c5f67e78b4d9d42263020c057706765c04"
+
+[[package]]
+name = "winnow"
+version = "0.5.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f593a95398737aeed53e489c785df13f3618e41dbcd6718c6addbf1395aa6876"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "winnow"
-version = "0.5.15"
+version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7c2e3184b9c4e92ad5167ca73039d0c42476302ab603e2fec4487511f38ccefc"
+checksum = "d90f4e0f530c4c69f62b80d839e9ef3855edc9cba471a160c4d692deed62b401"
 dependencies = [
  "memchr",
 ]
@@ -4524,9 +4650,9 @@ version = "8.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "06eee6f3bb38f8c8dca03053572130be2e5006a31dc7e5d8c62e375952b2ff38"
 dependencies = [
- "aes-gcm 0.10.2",
+ "aes-gcm 0.10.3",
  "bs58 0.5.0",
- "hashbrown 0.14.0",
+ "hashbrown 0.14.3",
  "hex",
  "num-traits",
  "p256k1",
@@ -4534,7 +4660,7 @@ dependencies = [
  "primitive-types",
  "rand_core 0.6.4",
  "serde",
- "sha2 0.10.6",
+ "sha2 0.10.8",
  "thiserror",
  "tracing",
  "tracing-subscriber",
@@ -4549,8 +4675,28 @@ dependencies = [
  "tap",
 ]
 
+[[package]]
+name = "zerocopy"
+version = "0.7.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "74d4d3961e53fa4c9a25a8637fc2bfaf2595b3d3ae34875568a5cf64787716be"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.7.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ce1b18ccd8e73a9321186f97e46f9f04b778851177567b1975109d26a08d2a6"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.48",
+]
+
 [[package]]
 name = "zeroize"
-version = "1.5.7"
+version = "1.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c394b5bd0c6f669e7275d9c20aa90ae064cb22e75a1cad54e1b34088034b149f"
+checksum = "525b4ec142c6b68a2d10f01f7bbf6755599ca3f81ea53b8431b7dd348f5fdb2d"
diff --git a/Cargo.toml b/Cargo.toml
index 693970fb68..3f0924c183 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -15,8 +15,10 @@ members = [
 # Dependencies we want to keep the same between workspace members
 [workspace.dependencies]  
 wsts = { version = "8.0", default-features = false }
+ed25519-dalek = { version = "2.1.1", features = ["serde", "rand_core"] } 
 rand_core = "0.6"
 rand = "0.8"
+rand_chacha = "0.3.1"
 
 # Use a bit more than default optimization for
 #  dev builds to speed up test execution
diff --git a/clarity/Cargo.toml b/clarity/Cargo.toml
index 86089991dc..eb8bcad388 100644
--- a/clarity/Cargo.toml
+++ b/clarity/Cargo.toml
@@ -18,8 +18,8 @@ name = "clarity"
 path = "./src/libclarity.rs"
 
 [dependencies]
-rand = "0.7.3"
-rand_chacha = "=0.2.2"
+rand = { workspace = true }
+rand_chacha = { workspace = true }
 serde = "1"
 serde_derive = "1"
 serde_stacker = "0.1"
diff --git a/stacks-common/Cargo.toml b/stacks-common/Cargo.toml
index 1916572cf4..0896442d7a 100644
--- a/stacks-common/Cargo.toml
+++ b/stacks-common/Cargo.toml
@@ -18,7 +18,7 @@ name = "stacks_common"
 path = "./src/libcommon.rs"
 
 [dependencies]
-rand = "0.7.3"
+rand = { workspace = true }
 serde = "1"
 serde_derive = "1"
 serde_stacker = "0.1"
@@ -55,8 +55,7 @@ version = "=0.24.2"
 features = ["blob", "serde_json", "i128_blob", "bundled", "trace"]
 
 [dependencies.ed25519-dalek]
-version = "=1.0.0-pre.3"
-features = ["serde"]
+workspace = true
 
 [dependencies.curve25519-dalek]
 version = "=2.0.0"
@@ -70,7 +69,7 @@ features = ["std"]
 rstest = "0.11.0"
 rstest_reuse = "0.1.3"
 assert-json-diff = "1.0.0"
-rand_core = "0.6"
+rand_core = { workspace = true }
 
 [features]
 default = ["developer-mode"]
diff --git a/stacks-common/src/address/c32.rs b/stacks-common/src/address/c32.rs
index 60fa7e6552..3b0141847a 100644
--- a/stacks-common/src/address/c32.rs
+++ b/stacks-common/src/address/c32.rs
@@ -381,7 +381,7 @@ mod test {
     fn old_c32_validation() {
         for n in 0..5000 {
             // random version
-            let random_version: u8 = rand::thread_rng().gen_range(0, 31);
+            let random_version: u8 = rand::thread_rng().gen_range(0..31);
 
             // random 20 bytes
             let random_bytes = rand::thread_rng().gen::<[u8; 20]>();
diff --git a/stacks-common/src/util/vrf.rs b/stacks-common/src/util/vrf.rs
index 3553275414..410c4a07e2 100644
--- a/stacks-common/src/util/vrf.rs
+++ b/stacks-common/src/util/vrf.rs
@@ -31,7 +31,7 @@ use curve25519_dalek::constants::ED25519_BASEPOINT_POINT;
 use curve25519_dalek::edwards::{CompressedEdwardsY, EdwardsPoint};
 use curve25519_dalek::scalar::Scalar as ed25519_Scalar;
 use ed25519_dalek::{
-    Keypair as VRFKeypair, PublicKey as ed25519_PublicKey, SecretKey as ed25519_PrivateKey,
+    SecretKey as EdDalekSecretKeyBytes, SigningKey as EdPrivateKey, VerifyingKey as EdPublicKey,
 };
 use rand;
 use sha2::{Digest, Sha512};
@@ -39,9 +39,10 @@ use sha2::{Digest, Sha512};
 use crate::util::hash::{hex_bytes, to_hex};
 
 #[derive(Clone)]
-pub struct VRFPublicKey(pub ed25519_PublicKey);
+pub struct VRFPublicKey(pub ed25519_dalek::VerifyingKey);
 
-pub struct VRFPrivateKey(pub ed25519_PrivateKey);
+#[derive(Clone)]
+pub struct VRFPrivateKey(pub ed25519_dalek::SigningKey);
 
 impl serde::Serialize for VRFPublicKey {
     fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
@@ -58,29 +59,6 @@ impl<'de> serde::Deserialize<'de> for VRFPublicKey {
     }
 }
 
-// have to do Clone separately since ed25519_PrivateKey doesn't implement Clone
-impl Clone for VRFPrivateKey {
-    fn clone(&self) -> VRFPrivateKey {
-        let bytes = self.to_bytes();
-        let pk = ed25519_PrivateKey::from_bytes(&bytes)
-            .expect("FATAL: could not do VRFPrivateKey round-trip");
-        VRFPrivateKey(pk)
-    }
-}
-
-impl Deref for VRFPublicKey {
-    type Target = ed25519_PublicKey;
-    fn deref(&self) -> &ed25519_PublicKey {
-        &self.0
-    }
-}
-
-impl DerefMut for VRFPublicKey {
-    fn deref_mut(&mut self) -> &mut ed25519_PublicKey {
-        &mut self.0
-    }
-}
-
 impl Debug for VRFPublicKey {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{}", &self.to_hex())
@@ -113,19 +91,6 @@ impl Hash for VRFPublicKey {
     }
 }
 
-impl Deref for VRFPrivateKey {
-    type Target = ed25519_PrivateKey;
-    fn deref(&self) -> &ed25519_PrivateKey {
-        &self.0
-    }
-}
-
-impl DerefMut for VRFPrivateKey {
-    fn deref_mut(&mut self) -> &mut ed25519_PrivateKey {
-        &mut self.0
-    }
-}
-
 impl Debug for VRFPrivateKey {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{}", &self.to_hex())
@@ -149,71 +114,76 @@ impl Default for VRFPrivateKey {
 impl VRFPrivateKey {
     pub fn new() -> VRFPrivateKey {
         let mut rng = rand::thread_rng();
-        let keypair: VRFKeypair = VRFKeypair::generate(&mut rng);
-        VRFPrivateKey(keypair.secret)
+        let signing_key = ed25519_dalek::SigningKey::generate(&mut rng);
+        VRFPrivateKey(signing_key)
     }
 
     pub fn from_hex(h: &str) -> Option<VRFPrivateKey> {
-        match hex_bytes(h) {
-            Ok(b) => match ed25519_PrivateKey::from_bytes(&b[..]) {
-                Ok(pk) => Some(VRFPrivateKey(pk)),
-                Err(_) => None,
-            },
-            Err(_) => None,
-        }
+        let bytes = hex_bytes(h).ok()?;
+        Self::from_bytes(bytes.as_slice())
     }
 
     pub fn from_bytes(b: &[u8]) -> Option<VRFPrivateKey> {
-        match ed25519_PrivateKey::from_bytes(b) {
-            Ok(pk) => Some(VRFPrivateKey(pk)),
-            Err(_) => None,
-        }
+        let signing_key = ed25519_dalek::SigningKey::try_from(b).ok()?;
+        Some(VRFPrivateKey(signing_key))
     }
 
     pub fn to_hex(&self) -> String {
         to_hex(self.as_bytes())
     }
+
+    pub fn as_bytes(&self) -> &[u8] {
+        self.0.as_bytes()
+    }
+
+    pub fn to_bytes(&self) -> [u8; 32] {
+        self.0.to_bytes()
+    }
 }
 
 impl VRFPublicKey {
-    pub fn from_private(pk: &VRFPrivateKey) -> VRFPublicKey {
-        VRFPublicKey(ed25519_PublicKey::from(&pk.0))
+    pub fn from_private(sk: &VRFPrivateKey) -> VRFPublicKey {
+        VRFPublicKey(sk.0.verifying_key())
     }
 
+    /// Verify that a given byte string is a well-formed EdDSA public
+    /// key (i.e. it's a compressed Edwards point that is valid), and return
+    /// a VRFPublicKey if so
     pub fn from_bytes(pubkey_bytes: &[u8]) -> Option<VRFPublicKey> {
-        match pubkey_bytes.len() {
-            32 => {
-                let mut pubkey_slice = [0; 32];
-                pubkey_slice.copy_from_slice(&pubkey_bytes[0..32]);
-
-                let checked_pubkey = CompressedEdwardsY(pubkey_slice);
-                match checked_pubkey.decompress() {
-                    Some(_) => {}
-                    None => {
-                        // invalid
-                        return None;
-                    }
-                }
-
-                match ed25519_PublicKey::from_bytes(&pubkey_slice) {
-                    Ok(key) => Some(VRFPublicKey(key)),
-                    Err(_) => None,
-                }
-            }
-            _ => None,
+        let pubkey_slice = pubkey_bytes.try_into().ok()?;
+
+        // NOTE: `ed25519_dalek::VerifyingKey::from_bytes` docs say
+        //  that this check must be performed by the caller, but as of
+        //  latest, it actually performs the check as well. However,
+        //  we do this check out of an abundance of caution because
+        //  that's what the docs say to do!
+
+        let checked_pubkey = CompressedEdwardsY(pubkey_slice);
+        if checked_pubkey.decompress().is_none() {
+            // invalid
+            return None;
         }
+
+        let key = ed25519_dalek::VerifyingKey::from_bytes(&pubkey_slice).ok()?;
+        Some(VRFPublicKey(key))
     }
 
     pub fn from_hex(h: &str) -> Option<VRFPublicKey> {
-        match hex_bytes(h) {
-            Ok(b) => VRF::check_public_key(&b),
-            Err(_) => None,
-        }
+        let bytes = hex_bytes(h).ok()?;
+        Self::from_bytes(bytes.as_slice())
     }
 
     pub fn to_hex(&self) -> String {
         to_hex(self.as_bytes())
     }
+
+    pub fn as_bytes(&self) -> &[u8] {
+        self.0.as_bytes()
+    }
+
+    pub fn to_bytes(&self) -> [u8; 32] {
+        self.0.to_bytes()
+    }
 }
 
 #[derive(Debug)]
@@ -565,15 +535,6 @@ impl VRF {
         // NOTE: this leverages constant-time comparison inherited from the Scalar impl
         Ok(c_prime == *(proof.c()))
     }
-
-    /// Verify that a given byte string is a well-formed EdDSA public key (i.e. it's a compressed
-    /// Edwards point that is valid).
-    pub fn check_public_key(pubkey_bytes: &Vec<u8>) -> Option<VRFPublicKey> {
-        match pubkey_bytes.len() {
-            32 => VRFPublicKey::from_bytes(&pubkey_bytes[..]),
-            _ => None,
-        }
-    }
 }
 
 #[cfg(test)]
@@ -714,14 +675,14 @@ mod tests {
 
     #[test]
     fn check_valid_public_key() {
-        let res1 = VRF::check_public_key(
+        let res1 = VRFPublicKey::from_bytes(
             &hex_bytes("a366b51292bef4edd64063d9145c617fec373bceb0758e98cd72becd84d54c7a")
                 .unwrap()
                 .to_vec(),
         );
         assert!(res1.is_some());
 
-        let res2 = VRF::check_public_key(
+        let res2 = VRFPublicKey::from_bytes(
             &hex_bytes("a366b51292bef4edd64063d9145c617fec373bceb0758e98cd72becd84d54c7b")
                 .unwrap()
                 .to_vec(),
diff --git a/stackslib/Cargo.toml b/stackslib/Cargo.toml
index c5411353e2..d1da07b0b8 100644
--- a/stackslib/Cargo.toml
+++ b/stackslib/Cargo.toml
@@ -31,8 +31,9 @@ name = "blockstack-cli"
 path = "src/blockstack_cli.rs"
 
 [dependencies]
-rand = "0.7.3"
-rand_chacha = "=0.2.2"
+rand = { workspace = true }
+rand_core = { workspace = true }
+rand_chacha = { workspace = true }
 serde = "1"
 serde_derive = "1"
 serde_stacker = "0.1"
@@ -56,7 +57,6 @@ pox-locking = { path = "../pox-locking" }
 libstackerdb = { path = "../libstackerdb" }
 siphasher = "0.3.7"
 wsts = {workspace = true}
-rand_core = {workspace = true}
 hashbrown = "0.14"
 
 [target.'cfg(unix)'.dependencies]
@@ -81,8 +81,7 @@ version = "=0.24.2"
 features = ["blob", "serde_json", "i128_blob", "bundled", "trace"]
 
 [dependencies.ed25519-dalek]
-version = "=1.0.0-pre.3"
-features = ["serde"]
+workspace = true
 
 [dependencies.curve25519-dalek]
 version = "=2.0.0"
diff --git a/stackslib/src/burnchains/bitcoin/network.rs b/stackslib/src/burnchains/bitcoin/network.rs
index d29c7b2aaf..3e8bf9340c 100644
--- a/stackslib/src/burnchains/bitcoin/network.rs
+++ b/stackslib/src/burnchains/bitcoin/network.rs
@@ -187,7 +187,7 @@ impl BitcoinIndexer {
                         }
                         Err(btc_error::ConnectionBroken) => {
                             // need to try again
-                            backoff = 2.0 * backoff + (backoff * rng.gen_range(0.0, 1.0));
+                            backoff = 2.0 * backoff + (backoff * rng.gen_range(0.0..1.0));
                         }
                         Err(e) => {
                             // propagate other network error
@@ -204,7 +204,7 @@ impl BitcoinIndexer {
                         "Failed to connect to peer {}:{}: {}",
                         &self.config.peer_host, self.config.peer_port, err_msg
                     );
-                    backoff = 2.0 * backoff + (backoff * rng.gen_range(0.0, 1.0));
+                    backoff = 2.0 * backoff + (backoff * rng.gen_range(0.0..1.0));
                 }
             }
 
diff --git a/stackslib/src/burnchains/tests/burnchain.rs b/stackslib/src/burnchains/tests/burnchain.rs
index d30f5aa2d2..d59d8916b3 100644
--- a/stackslib/src/burnchains/tests/burnchain.rs
+++ b/stackslib/src/burnchains/tests/burnchain.rs
@@ -14,7 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use ed25519_dalek::Keypair as VRFKeypair;
 use rand::rngs::ThreadRng;
 use rand::thread_rng;
 use serde::Serialize;
@@ -867,12 +866,13 @@ fn test_burn_snapshot_sequence() {
 
     for i in 0..32 {
         let mut csprng: ThreadRng = thread_rng();
-        let keypair: VRFKeypair = VRFKeypair::generate(&mut csprng);
+        let vrf_privkey = VRFPrivateKey(ed25519_dalek::SigningKey::generate(&mut csprng));
+        let vrf_pubkey = VRFPublicKey::from_private(&vrf_privkey);
 
-        let privkey_hex = to_hex(&keypair.secret.to_bytes());
+        let privkey_hex = vrf_privkey.to_hex();
         leader_private_keys.push(privkey_hex);
 
-        let pubkey_hex = to_hex(&keypair.public.to_bytes());
+        let pubkey_hex = vrf_pubkey.to_hex();
         leader_public_keys.push(pubkey_hex);
 
         let bitcoin_privkey = Secp256k1PrivateKey::new();
diff --git a/stackslib/src/chainstate/burn/mod.rs b/stackslib/src/chainstate/burn/mod.rs
index 4fc937afee..42dafd6044 100644
--- a/stackslib/src/chainstate/burn/mod.rs
+++ b/stackslib/src/chainstate/burn/mod.rs
@@ -150,8 +150,8 @@ impl SortitionHash {
         if max < 2 {
             return (0..max).collect();
         }
-        let first = rng.gen_range(0, max);
-        let try_second = rng.gen_range(0, max - 1);
+        let first = rng.gen_range(0..max);
+        let try_second = rng.gen_range(0..(max - 1));
         let second = if first == try_second {
             // "swap" try_second with max
             max - 1
diff --git a/stackslib/src/cost_estimates/tests/fee_rate_fuzzer.rs b/stackslib/src/cost_estimates/tests/fee_rate_fuzzer.rs
index 1a1d953b25..8fe0622dc8 100644
--- a/stackslib/src/cost_estimates/tests/fee_rate_fuzzer.rs
+++ b/stackslib/src/cost_estimates/tests/fee_rate_fuzzer.rs
@@ -53,9 +53,9 @@ fn test_fuzzing_seed1() {
             .get_rate_estimates()
             .expect("Estimate should exist."),
         FeeRateEstimate {
-            high: 96.20545857700169f64,
-            middle: 50.63445188263247f64,
-            low: 5.0634451882632465f64
+            high: 91.73244187536466f64,
+            middle: 48.28023256598139f64,
+            low: 4.82802325659814f64
         }
     );
 }
@@ -77,9 +77,9 @@ fn test_fuzzing_seed2() {
             .get_rate_estimates()
             .expect("Estimate should exist."),
         FeeRateEstimate {
-            high: 100.08112623179122f64,
-            middle: 52.67427696410064f64,
-            low: 5.267427696410064f64
+            high: 88.82921297592677f64,
+            middle: 46.75221735575093f64,
+            low: 4.675221735575093f64
         }
     );
 }
@@ -136,9 +136,9 @@ fn test_notify_pass_through() {
             .get_rate_estimates()
             .expect("Estimate should exist."),
         FeeRateEstimate {
-            high: 2.1069710785640257f64,
-            middle: 2.1069710785640257f64,
-            low: 2.1069710785640257f64
-        },
+            high: 1.8700886942300372f64,
+            middle: 1.8700886942300372f64,
+            low: 1.8700886942300372f64
+        }
     );
 }
diff --git a/stackslib/src/net/neighbors/neighbor.rs b/stackslib/src/net/neighbors/neighbor.rs
index a1d513daa2..617860063e 100644
--- a/stackslib/src/net/neighbors/neighbor.rs
+++ b/stackslib/src/net/neighbors/neighbor.rs
@@ -134,7 +134,7 @@ impl Neighbor {
         let mut rng = thread_rng();
         let min = cmp::min(self.in_degree, self.out_degree);
         let max = cmp::max(self.in_degree, self.out_degree);
-        let res = rng.gen_range(min, max + 1) as u64;
+        let res = rng.gen_range(min..(max + 1)) as u64;
         if res == 0 {
             1
         } else {
diff --git a/stackslib/src/net/neighbors/walk.rs b/stackslib/src/net/neighbors/walk.rs
index 642195a589..9248140629 100644
--- a/stackslib/src/net/neighbors/walk.rs
+++ b/stackslib/src/net/neighbors/walk.rs
@@ -1375,7 +1375,7 @@ impl<DB: NeighborWalkDB, NC: NeighborComms> NeighborWalk<DB, NC> {
         }
         // select a random neighbor index, if exclude is set, and matches this
         //  neighbor, then use the next index (modulo the frontier length).
-        let mut neighbor_index = rnd.gen_range(0, frontier.len());
+        let mut neighbor_index = rnd.gen_range(0..frontier.len());
         for _ in 0..2 {
             // two attempts, in case our first attempt lands on `exclude`
             for (cnt, (nk, n)) in frontier.iter().enumerate() {
diff --git a/stackslib/src/net/prune.rs b/stackslib/src/net/prune.rs
index b2b7ff6c32..1d86aa834d 100644
--- a/stackslib/src/net/prune.rs
+++ b/stackslib/src/net/prune.rs
@@ -153,7 +153,7 @@ impl PeerNetwork {
             total += count;
         }
 
-        let sample = rng.gen_range(0, total);
+        let sample = rng.gen_range(0..total);
         let mut offset = 0;
         for (org, count) in org_weights.iter() {
             if *count == 0 {

From 0fe91eb4bb51f96f5536ca3ccf521cf3c6360141 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Thu, 15 Feb 2024 16:04:44 -0500
Subject: [PATCH 0777/1166] chore: address PR feedback

---
 stackslib/src/chainstate/burn/db/sortdb.rs    |  72 ++-
 .../chainstate/nakamoto/coordinator/mod.rs    |   2 +-
 stackslib/src/chainstate/nakamoto/mod.rs      | 516 +++---------------
 .../src/chainstate/nakamoto/staging_blocks.rs | 401 ++++++++++++++
 .../src/chainstate/nakamoto/tests/mod.rs      | 125 +++--
 5 files changed, 626 insertions(+), 490 deletions(-)
 create mode 100644 stackslib/src/chainstate/nakamoto/staging_blocks.rs

diff --git a/stackslib/src/chainstate/burn/db/sortdb.rs b/stackslib/src/chainstate/burn/db/sortdb.rs
index 5fb6966a15..c085ea96fe 100644
--- a/stackslib/src/chainstate/burn/db/sortdb.rs
+++ b/stackslib/src/chainstate/burn/db/sortdb.rs
@@ -1011,6 +1011,16 @@ pub trait SortitionHandle {
     /// Get a ref to the PoX constants
     fn pox_constants(&self) -> &PoxConstants;
 
+    /// Get the sortition ID of the sortition history tip this handle represents
+    fn tip(&self) -> SortitionId;
+
+    /// Get the highest-processed Nakamoto block on this sortition history.
+    /// Returns Ok(Some(nakamoto-tip-ch, nakamoto-tip-bhh, nakamoto-tip-height))) on success, if
+    /// there was a tip found
+    /// Returns Ok(None) if no Nakamoto blocks are present on this sortition history
+    /// Returns Err(..) on DB errors
+    fn get_nakamoto_tip(&self) -> Result<Option<(ConsensusHash, BlockHeaderHash, u64)>, db_error>;
+
     /// 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
@@ -1414,6 +1424,16 @@ impl SortitionHandle for SortitionHandleTx<'_> {
     fn sqlite(&self) -> &Connection {
         self.tx()
     }
+
+    fn tip(&self) -> SortitionId {
+        self.context.chain_tip.clone()
+    }
+
+    fn get_nakamoto_tip(&self) -> Result<Option<(ConsensusHash, BlockHeaderHash, u64)>, db_error> {
+        let sn = SortitionDB::get_block_snapshot(self.sqlite(), &self.context.chain_tip)?
+            .ok_or(db_error::NotFoundError)?;
+        SortitionDB::get_canonical_nakamoto_tip_hash_and_height(self.sqlite(), &sn)
+    }
 }
 
 impl SortitionHandle for SortitionHandleConn<'_> {
@@ -1435,6 +1455,16 @@ impl SortitionHandle for SortitionHandleConn<'_> {
     fn sqlite(&self) -> &Connection {
         self.conn()
     }
+
+    fn tip(&self) -> SortitionId {
+        self.context.chain_tip.clone()
+    }
+
+    fn get_nakamoto_tip(&self) -> Result<Option<(ConsensusHash, BlockHeaderHash, u64)>, db_error> {
+        let sn = SortitionDB::get_block_snapshot(self.sqlite(), &self.context.chain_tip)?
+            .ok_or(db_error::NotFoundError)?;
+        SortitionDB::get_canonical_nakamoto_tip_hash_and_height(self.sqlite(), &sn)
+    }
 }
 
 impl<'a> SortitionHandleTx<'a> {
@@ -4441,6 +4471,33 @@ impl SortitionDB {
         self.tx_handle_begin(&sortition_id).unwrap()
     }
 
+    /// Given a starting sortition ID, go and find the canonical Nakamoto tip
+    /// Returns Ok(Some(tip info)) on success
+    /// Returns Ok(None) if there are no Nakamoto blocks in this tip
+    /// Returns Err(..) on other DB error
+    pub fn get_canonical_nakamoto_tip_hash_and_height(
+        conn: &Connection,
+        tip: &BlockSnapshot,
+    ) -> Result<Option<(ConsensusHash, BlockHeaderHash, u64)>, db_error> {
+        let mut cursor = tip.clone();
+        loop {
+            let result_at_tip : Option<(ConsensusHash, BlockHeaderHash, u64)> = conn.query_row_and_then(
+                "SELECT consensus_hash,block_hash,block_height FROM stacks_chain_tips WHERE sortition_id = ?",
+                &[&cursor.sortition_id],
+                |row| Ok((row.get_unwrap(0), row.get_unwrap(1), (u64::try_from(row.get_unwrap::<_, i64>(2)).expect("FATAL: block height too high"))))
+            ).optional()?;
+            if let Some(stacks_tip) = result_at_tip {
+                return Ok(Some(stacks_tip));
+            }
+            let Some(next_cursor) =
+                SortitionDB::get_block_snapshot(conn, &cursor.parent_sortition_id)?
+            else {
+                return Ok(None);
+            };
+            cursor = next_cursor
+        }
+    }
+
     /// Get the canonical Stacks chain tip -- this gets memoized on the canonical burn chain tip.
     pub fn get_canonical_stacks_chain_tip_hash_and_height(
         conn: &Connection,
@@ -4454,19 +4511,8 @@ impl SortitionDB {
         if cur_epoch.epoch_id >= StacksEpochId::Epoch30 {
             // nakamoto behavior -- look to the stacks_chain_tip table
             //  if the chain tip of the current sortition hasn't been set, have to iterate to parent
-            let mut cursor = sn;
-            loop {
-                let result_at_tip = conn.query_row_and_then(
-                    "SELECT consensus_hash,block_hash,block_height FROM stacks_chain_tips WHERE sortition_id = ?",
-                    &[&cursor.sortition_id],
-                    |row| Ok((row.get_unwrap(0), row.get_unwrap(1), (u64::try_from(row.get_unwrap::<_, i64>(2)).expect("FATAL: block height too high"))))
-                ).optional()?;
-                if let Some(stacks_tip) = result_at_tip {
-                    return Ok(stacks_tip);
-                }
-                cursor = SortitionDB::get_block_snapshot(conn, &cursor.parent_sortition_id)?
-                    .ok_or_else(|| db_error::NotFoundError)?;
-            }
+            return Self::get_canonical_nakamoto_tip_hash_and_height(conn, &sn)?
+                .ok_or(db_error::NotFoundError);
         }
 
         // epoch 2.x behavior -- look at the snapshot itself
diff --git a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
index fefa824916..50b576689d 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/mod.rs
@@ -887,7 +887,7 @@ impl<
 
             // mark this burn block as processed in the nakamoto chainstate
             let tx = self.chain_state_db.staging_db_tx_begin()?;
-            NakamotoChainState::set_burn_block_processed(&tx, &next_snapshot.consensus_hash)?;
+            tx.set_burn_block_processed(&next_snapshot.consensus_hash)?;
             tx.commit().map_err(DBError::SqliteError)?;
 
             let sortition_id = next_snapshot.sortition_id;
diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index a5042e1245..24dde0e1f8 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -1,5 +1,5 @@
 // Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
-// Copyright (C) 2020-2023 Stacks Open Internet Foundation
+// Copyright (C) 2020-2024 Stacks Open Internet Foundation
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -102,12 +102,16 @@ use crate::{chainstate, monitoring};
 
 pub mod coordinator;
 pub mod miner;
-pub mod tenure;
-
 pub mod signer_set;
+pub mod staging_blocks;
+pub mod tenure;
 #[cfg(test)]
 pub mod tests;
 
+pub use self::staging_blocks::{
+    NakamotoStagingBlocksConn, NakamotoStagingBlocksConnRef, NakamotoStagingBlocksTx,
+};
+
 pub const NAKAMOTO_BLOCK_VERSION: u8 = 0;
 
 define_named_enum!(HeaderTypeNames {
@@ -130,44 +134,6 @@ impl FromSql for HeaderTypeNames {
 lazy_static! {
     pub static ref FIRST_STACKS_BLOCK_ID: StacksBlockId = StacksBlockId::new(&FIRST_BURNCHAIN_CONSENSUS_HASH, &FIRST_STACKS_BLOCK_HASH);
 
-    pub static ref NAKAMOTO_STAGING_DB_SCHEMA_1: Vec<String> = vec![
-      r#"
-      -- Table for staging nakamoto blocks
-      CREATE TABLE nakamoto_staging_blocks (
-                     -- SHA512/256 hash of this block
-                     block_hash TEXT NOT NULL,
-                     -- the consensus hash of the burnchain block that selected this block's miner's block-commit
-                     consensus_hash TEXT NOT NULL,
-                     -- the parent index_block_hash
-                     parent_block_id TEXT NOT NULL,
-
-                     -- has the burnchain block with this block's `consensus_hash` been processed?
-                     burn_attachable INT NOT NULL,
-                     -- has this block been processed?
-                     processed INT NOT NULL,
-                     -- set to 1 if this block can never be attached
-                     orphaned INT NOT NULL,
-
-                     height INT NOT NULL,
-
-                     -- used internally -- this is the StacksBlockId of this block's consensus hash and block hash
-                     index_block_hash TEXT NOT NULL,
-                     -- how long the block was in-flight
-                     download_time INT NOT NULL,
-                     -- when this block was stored
-                     arrival_time INT NOT NULL,
-                     -- when this block was processed
-                     processed_time INT NOT NULL,
-
-                     -- block data
-                     data BLOB NOT NULL,
-                    
-                     PRIMARY KEY(block_hash,consensus_hash)
-        );"#
-        .into(),
-        r#"CREATE INDEX by_index_block_hash ON nakamoto_staging_blocks(index_block_hash);"#.into()
-    ];
-
     pub static ref NAKAMOTO_CHAINSTATE_SCHEMA_1: Vec<String> = vec![
     r#"
     -- Table for storing calculated reward sets. This must be in the Chainstate DB because calculation occurs
@@ -1181,341 +1147,81 @@ impl NakamotoBlock {
     }
 }
 
-pub struct NakamotoStagingBlocksConn(rusqlite::Connection);
-
-impl Deref for NakamotoStagingBlocksConn {
-    type Target = rusqlite::Connection;
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl DerefMut for NakamotoStagingBlocksConn {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.0
-    }
-}
-
-impl NakamotoStagingBlocksConn {
-    pub fn conn(&self) -> NakamotoStagingBlocksConnRef {
-        NakamotoStagingBlocksConnRef(&self.0)
-    }
-}
-
-pub struct NakamotoStagingBlocksConnRef<'a>(&'a rusqlite::Connection);
-
-impl<'a> NakamotoStagingBlocksConnRef<'a> {
-    pub fn conn(&self) -> NakamotoStagingBlocksConnRef<'a> {
-        NakamotoStagingBlocksConnRef(self.0)
-    }
-}
-
-impl Deref for NakamotoStagingBlocksConnRef<'_> {
-    type Target = rusqlite::Connection;
-    fn deref(&self) -> &Self::Target {
-        self.0
-    }
-}
-
-pub struct NakamotoStagingBlocksTx<'a>(rusqlite::Transaction<'a>);
-
-impl<'a> NakamotoStagingBlocksTx<'a> {
-    pub fn commit(self) -> Result<(), rusqlite::Error> {
-        self.0.commit()
-    }
-
-    pub fn conn(&self) -> NakamotoStagingBlocksConnRef {
-        NakamotoStagingBlocksConnRef(self.0.deref())
-    }
-}
+impl NakamotoChainState {
+    /// Infallibly set a block as processed.
+    /// Does not return until it succeeds.
+    fn infallible_set_block_processed(
+        stacks_chain_state: &mut StacksChainState,
+        block_id: &StacksBlockId,
+    ) {
+        loop {
+            let Ok(staging_block_tx) = stacks_chain_state.staging_db_tx_begin().map_err(|e| {
+                warn!("Failed to begin staging DB tx: {:?}", &e);
+                e
+            }) else {
+                sleep_ms(1000);
+                continue;
+            };
 
-impl<'a> Deref for NakamotoStagingBlocksTx<'a> {
-    type Target = rusqlite::Transaction<'a>;
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
+            let Ok(_) = staging_block_tx.set_block_processed(block_id).map_err(|e| {
+                warn!("Failed to mark {} as processed: {:?}", block_id, &e);
+                e
+            }) else {
+                sleep_ms(1000);
+                continue;
+            };
 
-impl<'a> DerefMut for NakamotoStagingBlocksTx<'a> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.0
-    }
-}
+            let Ok(_) = staging_block_tx.commit().map_err(|e| {
+                warn!(
+                    "Failed to commit staging block tx for {}: {:?}",
+                    block_id, &e
+                );
+                e
+            }) else {
+                sleep_ms(1000);
+                continue;
+            };
 
-impl StacksChainState {
-    /// Begin a transaction against the staging blocks DB.
-    /// Note that this DB is (or will eventually be) in a separate database from the headers.
-    pub fn staging_db_tx_begin<'a>(
-        &'a mut self,
-    ) -> Result<NakamotoStagingBlocksTx<'a>, ChainstateError> {
-        let tx = tx_begin_immediate(&mut self.nakamoto_staging_blocks_conn)?;
-        Ok(NakamotoStagingBlocksTx(tx))
-    }
-
-    /// Begin a tx to both the headers DB and the staging DB
-    pub fn headers_and_staging_tx_begin<'a>(
-        &'a mut self,
-    ) -> Result<(rusqlite::Transaction<'a>, NakamotoStagingBlocksTx<'a>), ChainstateError> {
-        let header_tx = self
-            .state_index
-            .storage_tx()
-            .map_err(ChainstateError::DBError)?;
-        let staging_tx = tx_begin_immediate(&mut self.nakamoto_staging_blocks_conn)?;
-        Ok((header_tx, NakamotoStagingBlocksTx(staging_tx)))
-    }
-
-    /// Open a connection to the headers DB, and open a tx to the staging DB
-    pub fn headers_conn_and_staging_tx_begin<'a>(
-        &'a mut self,
-    ) -> Result<(&'a rusqlite::Connection, NakamotoStagingBlocksTx<'a>), ChainstateError> {
-        let header_conn = self.state_index.sqlite_conn();
-        let staging_tx = tx_begin_immediate(&mut self.nakamoto_staging_blocks_conn)?;
-        Ok((header_conn, NakamotoStagingBlocksTx(staging_tx)))
-    }
-
-    /// Get a ref to the nakamoto staging blocks connection
-    pub fn nakamoto_blocks_db(&self) -> NakamotoStagingBlocksConnRef {
-        NakamotoStagingBlocksConnRef(&self.nakamoto_staging_blocks_conn)
-    }
-
-    /// Get the path to the Nakamoto staging blocks DB.
-    /// It's separate from the headers DB in order to avoid DB contention between downloading
-    /// blocks and processing them.
-    pub fn get_nakamoto_staging_blocks_path(root_path: PathBuf) -> Result<String, ChainstateError> {
-        let mut nakamoto_blocks_path = Self::blocks_path(root_path);
-        nakamoto_blocks_path.push("nakamoto.sqlite");
-        Ok(nakamoto_blocks_path
-            .to_str()
-            .ok_or(ChainstateError::DBError(DBError::ParseError))?
-            .to_string())
-    }
-
-    /// Open and set up a DB for nakamoto staging blocks.
-    /// If it doesn't exist, then instantiate it if `readwrite` is true.
-    pub fn open_nakamoto_staging_blocks(
-        path: &str,
-        readwrite: bool,
-    ) -> Result<NakamotoStagingBlocksConn, ChainstateError> {
-        let exists = fs::metadata(&path).is_ok();
-        let flags = if !exists {
-            // try to instantiate
-            if readwrite {
-                OpenFlags::SQLITE_OPEN_READ_WRITE | OpenFlags::SQLITE_OPEN_CREATE
-            } else {
-                return Err(DBError::NotFoundError.into());
-            }
-        } else {
-            if readwrite {
-                OpenFlags::SQLITE_OPEN_READ_WRITE
-            } else {
-                OpenFlags::SQLITE_OPEN_READ_ONLY
-            }
-        };
-        let conn = sqlite_open(path, flags, false)?;
-        if !exists {
-            for cmd in NAKAMOTO_STAGING_DB_SCHEMA_1.iter() {
-                conn.execute(cmd, NO_PARAMS)?;
-            }
+            break;
         }
-        Ok(NakamotoStagingBlocksConn(conn))
-    }
-}
-
-impl NakamotoChainState {
-    /// Notify the staging database that a given stacks block has been processed.
-    /// This will update the attachable status for children blocks, as well as marking the stacks
-    ///  block itself as processed.
-    pub fn set_block_processed(
-        staging_db_tx: &NakamotoStagingBlocksTx,
-        block: &StacksBlockId,
-    ) -> Result<(), ChainstateError> {
-        let clear_staged_block =
-            "UPDATE nakamoto_staging_blocks SET processed = 1, processed_time = ?2
-                                  WHERE index_block_hash = ?1";
-        staging_db_tx.execute(
-            &clear_staged_block,
-            params![&block, &u64_to_sql(get_epoch_time_secs())?],
-        )?;
-
-        Ok(())
     }
 
-    /// Modify the staging database that a given stacks block can never be processed.
-    /// This will update the attachable status for children blocks, as well as marking the stacks
-    /// block itself as orphaned.
-    pub fn set_block_orphaned(
-        staging_db_tx: &NakamotoStagingBlocksTx,
-        block: &StacksBlockId,
-    ) -> Result<(), ChainstateError> {
-        let update_dependents = "UPDATE nakamoto_staging_blocks SET orphaned = 1
-                                 WHERE parent_block_id = ?";
-
-        staging_db_tx.execute(&update_dependents, &[&block])?;
-
-        let clear_staged_block =
-            "UPDATE nakamoto_staging_blocks SET processed = 1, processed_time = ?2, orphaned = 1
-                                  WHERE index_block_hash = ?1";
-        staging_db_tx.execute(
-            &clear_staged_block,
-            params![&block, &u64_to_sql(get_epoch_time_secs())?],
-        )?;
-
-        Ok(())
-    }
+    /// Infallibly set a block as orphaned.
+    /// Does not return until it succeeds.
+    fn infallible_set_block_orphaned(
+        stacks_chain_state: &mut StacksChainState,
+        block_id: &StacksBlockId,
+    ) {
+        loop {
+            let Ok(staging_block_tx) = stacks_chain_state.staging_db_tx_begin().map_err(|e| {
+                warn!("Failed to begin staging DB tx: {:?}", &e);
+                e
+            }) else {
+                sleep_ms(1000);
+                continue;
+            };
 
-    /// Notify the staging database that a given burn block has been processed.
-    /// This is required for staged blocks to be eligible for processing.
-    pub fn set_burn_block_processed(
-        staging_db_tx: &NakamotoStagingBlocksTx,
-        consensus_hash: &ConsensusHash,
-    ) -> Result<(), ChainstateError> {
-        let update_dependents = "UPDATE nakamoto_staging_blocks SET burn_attachable = 1
-                                 WHERE consensus_hash = ?";
-        staging_db_tx.execute(&update_dependents, &[consensus_hash])?;
+            let Ok(_) = staging_block_tx.set_block_orphaned(&block_id).map_err(|e| {
+                warn!("Failed to mark {} as orphaned: {:?}", &block_id, &e);
+                e
+            }) else {
+                sleep_ms(1000);
+                continue;
+            };
 
-        Ok(())
-    }
+            let Ok(_) = staging_block_tx.commit().map_err(|e| {
+                warn!(
+                    "Failed to commit staging block tx for {}: {:?}",
+                    &block_id, &e
+                );
+                e
+            }) else {
+                sleep_ms(1000);
+                continue;
+            };
 
-    /// Check to see if a block with a given consensus hash is burn-attachable
-    pub fn is_burn_attachable(
-        staging_db_conn: NakamotoStagingBlocksConnRef,
-        consensus_hash: &ConsensusHash,
-    ) -> Result<bool, ChainstateError> {
-        let sql = "SELECT 1 FROM nakamoto_staging_blocks WHERE burn_attachable = 1 AND consensus_hash = ?1";
-        let args: &[&dyn ToSql] = &[consensus_hash];
-        let res: Option<i64> = query_row(&staging_db_conn, sql, args)?;
-        Ok(res.is_some())
-    }
-
-    /// Determine whether or not we have processed a Nakamoto block.
-    /// NOTE: the relevant field queried from `nakamoto_staging_blocks` is updated by a separate
-    /// tx from block-processing, so it's imperative that the thread that calls this function is
-    /// the *same* thread as the one that processes blocks.
-    /// Returns Ok(true) if at least one block in `nakamoto_staging_blocks` has `processed = 1`
-    /// Returns Ok(false) if not
-    /// Returns Err(..) on DB error
-    fn has_processed_nakamoto_block(
-        staging_db_conn: NakamotoStagingBlocksConnRef,
-    ) -> Result<bool, ChainstateError> {
-        let qry = "SELECT 1 FROM nakamoto_staging_blocks WHERE processed = 1 LIMIT 1";
-        let res: Option<i64> = query_row(&staging_db_conn, qry, NO_PARAMS)?;
-        Ok(res.is_some())
-    }
-
-    /// Get a Nakamoto block by index block hash, as well as its size.
-    /// Verifies its integrity.
-    /// Returns Ok(Some(block, size)) if the block was present
-    /// Returns Ok(None) if there were no such rows.
-    /// Returns Err(..) on DB error, including block corruption
-    pub fn get_nakamoto_block(
-        staging_db_conn: NakamotoStagingBlocksConnRef,
-        index_block_hash: &StacksBlockId,
-    ) -> Result<Option<(NakamotoBlock, u64)>, ChainstateError> {
-        let qry = "SELECT data FROM nakamoto_staging_blocks WHERE index_block_hash = ?1";
-        let args: &[&dyn ToSql] = &[index_block_hash];
-        let res: Option<Vec<u8>> = query_row(&staging_db_conn, qry, args)?;
-        let Some(block_bytes) = res else {
-            return Ok(None);
-        };
-        let block = NakamotoBlock::consensus_deserialize(&mut block_bytes.as_slice())?;
-        if &block.header.block_id() != index_block_hash {
-            error!(
-                "Staging DB corruption: expected {}, got {}",
-                index_block_hash,
-                &block.header.block_id()
-            );
-            return Err(DBError::Corruption.into());
+            break;
         }
-        Ok(Some((
-            block,
-            u64::try_from(block_bytes.len()).expect("FATAL: block is greater than a u64"),
-        )))
-    }
-
-    /// Find the next ready-to-process Nakamoto block, given a connection to the staging blocks DB.
-    /// NOTE: the relevant field queried from `nakamoto_staging_blocks` are updated by a separate
-    /// tx from block-processing, so it's imperative that the thread that calls this function is
-    /// the *same* thread that goes to process blocks.
-    /// Returns (the block, the size of the block)
-    pub(crate) fn next_ready_nakamoto_block(
-        staging_db_conn: NakamotoStagingBlocksConnRef,
-        header_conn: &Connection,
-    ) -> Result<Option<(NakamotoBlock, u64)>, ChainstateError> {
-        let query = "SELECT child.data FROM nakamoto_staging_blocks child JOIN nakamoto_staging_blocks parent
-                     ON child.parent_block_id = parent.index_block_hash
-                     WHERE child.burn_attachable = 1
-                       AND child.orphaned = 0
-                       AND child.processed = 0
-                       AND parent.processed = 1
-                     ORDER BY child.height ASC";
-        staging_db_conn
-            .query_row_and_then(query, NO_PARAMS, |row| {
-                let data: Vec<u8> = row.get("data")?;
-                let block = NakamotoBlock::consensus_deserialize(&mut data.as_slice())?;
-                Ok(Some((
-                    block,
-                    u64::try_from(data.len()).expect("FATAL: block is bigger than a u64"),
-                )))
-            })
-            .or_else(|e| {
-                if let ChainstateError::DBError(DBError::SqliteError(
-                    rusqlite::Error::QueryReturnedNoRows,
-                )) = e
-                {
-                    // if at least one nakamoto block is processed, then the next ready block's
-                    // parent *must* be a Nakamoto block.  So if the below is true, then there are
-                    // no ready blocks.
-                    if Self::has_processed_nakamoto_block(staging_db_conn.conn())? {
-                        return Ok(None);
-                    }
-
-                    // no nakamoto blocks processed yet, so the parent *must* be an epoch2 block!
-                    // go find it.  Note that while this is expensive, it only has to be done
-                    // _once_, and it will only touch at most one reward cycle's worth of blocks.
-                    let sql = "SELECT index_block_hash,parent_block_id FROM nakamoto_staging_blocks WHERE processed = 0 AND orphaned = 0 AND burn_attachable = 1 ORDER BY height ASC";
-                    let mut stmt = staging_db_conn.deref().prepare(sql)?;
-                    let mut qry = stmt.query(NO_PARAMS)?;
-                    let mut next_nakamoto_block_id = None;
-                    while let Some(row) = qry.next()? {
-                        let index_block_hash : StacksBlockId = row.get(0)?;
-                        let parent_block_id : StacksBlockId = row.get(1)?;
-
-                        let Some(_parent_epoch2_block) = Self::get_block_header_epoch2(header_conn, &parent_block_id)? else {
-                            continue;
-                        };
-
-                        // epoch2 parent exists, so this Nakamoto block is processable!
-                        next_nakamoto_block_id = Some(index_block_hash);
-                        break;
-                    }
-                    let Some(next_nakamoto_block_id) = next_nakamoto_block_id else {
-                        // no stored nakamoto block had an epoch2 parent
-                        return Ok(None);
-                    };
-
-                    // need qry and stmt to stop borrowing staging_db_conn before we can use it
-                    // again
-                    drop(qry);
-                    drop(stmt);
-
-                    Self::get_nakamoto_block(staging_db_conn, &next_nakamoto_block_id)
-                } else {
-                    Err(e)
-                }
-            })
-    }
-
-    /// Extract and parse a nakamoto block from the DB, and verify its integrity.
-    pub fn load_nakamoto_block(
-        staging_db_conn: NakamotoStagingBlocksConnRef,
-        consensus_hash: &ConsensusHash,
-        block_hash: &BlockHeaderHash,
-    ) -> Result<Option<NakamotoBlock>, ChainstateError> {
-        Self::get_nakamoto_block(
-            staging_db_conn,
-            &StacksBlockId::new(consensus_hash, block_hash),
-        )
-        .and_then(|block_size_opt| Ok(block_size_opt.map(|(block, _size)| block)))
     }
 
     /// Process the next ready block.
@@ -1529,10 +1235,9 @@ impl NakamotoChainState {
         sort_tx: &mut SortitionHandleTx,
         dispatcher_opt: Option<&'a T>,
     ) -> Result<Option<StacksEpochReceipt>, ChainstateError> {
-        let Some((next_ready_block, block_size)) = Self::next_ready_nakamoto_block(
-            stacks_chain_state.nakamoto_blocks_db(),
-            stacks_chain_state.db(),
-        )?
+        let nakamoto_blocks_db = stacks_chain_state.nakamoto_blocks_db();
+        let Some((next_ready_block, block_size)) =
+            nakamoto_blocks_db.next_ready_nakamoto_block(stacks_chain_state.db(), sort_tx)?
         else {
             // no more blocks
             return Ok(None);
@@ -1586,7 +1291,7 @@ impl NakamotoChainState {
                   "expected parent_block_id" => %parent_block_id
             );
             let staging_block_tx = stacks_chain_state.staging_db_tx_begin()?;
-            let _ = Self::set_block_orphaned(&staging_block_tx, &block_id)?;
+            staging_block_tx.set_block_orphaned(&block_id)?;
             staging_block_tx.commit()?;
             return Err(ChainstateError::InvalidStacksBlock(msg.into()));
         }
@@ -1667,39 +1372,7 @@ impl NakamotoChainState {
             // being processed. Therefore, it's *very important* that block-processing happens
             // within the same, single thread.  Also, it's *very important* that this update
             // succeeds, since *we have already processed* the block.
-
-            loop {
-                let Ok(staging_block_tx) = stacks_chain_state.staging_db_tx_begin().map_err(|e| {
-                    warn!("Failed to begin staging DB tx: {:?}", &e);
-                    e
-                }) else {
-                    sleep_ms(1000);
-                    continue;
-                };
-
-                let Ok(_) = NakamotoChainState::set_block_orphaned(&staging_block_tx, &block_id)
-                    .map_err(|e| {
-                        warn!("Failed to mark {} as orphaned: {:?}", &block_id, &e);
-                        e
-                    })
-                else {
-                    sleep_ms(1000);
-                    continue;
-                };
-
-                let Ok(_) = staging_block_tx.commit().map_err(|e| {
-                    warn!(
-                        "Failed to commit staging block tx for {}: {:?}",
-                        &block_id, &e
-                    );
-                    e
-                }) else {
-                    sleep_ms(1000);
-                    continue;
-                };
-
-                break;
-            }
+            Self::infallible_set_block_orphaned(stacks_chain_state, &block_id);
             return Err(e);
         };
 
@@ -1736,38 +1409,7 @@ impl NakamotoChainState {
         // being processed. Therefore, it's *very important* that block-processing happens
         // within the same, single thread.  Also, it's *very important* that this update
         // succeeds, since *we have already processed* the block.
-        loop {
-            let Ok(staging_block_tx) = stacks_chain_state.staging_db_tx_begin().map_err(|e| {
-                warn!("Failed to begin staging DB tx: {:?}", &e);
-                e
-            }) else {
-                sleep_ms(1000);
-                continue;
-            };
-
-            let Ok(_) = NakamotoChainState::set_block_processed(&staging_block_tx, &block_id)
-                .map_err(|e| {
-                    warn!("Failed to mark {} as processed: {:?}", &block_id, &e);
-                    e
-                })
-            else {
-                sleep_ms(1000);
-                continue;
-            };
-
-            let Ok(_) = staging_block_tx.commit().map_err(|e| {
-                warn!(
-                    "Failed to commit staging block tx for {}: {:?}",
-                    &block_id, &e
-                );
-                e
-            }) else {
-                sleep_ms(1000);
-                continue;
-            };
-
-            break;
-        }
+        Self::infallible_set_block_processed(stacks_chain_state, &block_id);
 
         // announce the block, if we're connected to an event dispatcher
         if let Some(dispatcher) = dispatcher_opt {
@@ -1984,7 +1626,7 @@ impl NakamotoChainState {
             ],
         )?;
         if burn_attachable {
-            Self::set_burn_block_processed(staging_db_tx, &block.header.consensus_hash)?;
+            staging_db_tx.set_burn_block_processed(&block.header.consensus_hash)?;
         }
         Ok(())
     }
diff --git a/stackslib/src/chainstate/nakamoto/staging_blocks.rs b/stackslib/src/chainstate/nakamoto/staging_blocks.rs
new file mode 100644
index 0000000000..e026c89744
--- /dev/null
+++ b/stackslib/src/chainstate/nakamoto/staging_blocks.rs
@@ -0,0 +1,401 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020-2024 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+use std::fs;
+use std::ops::{Deref, DerefMut};
+use std::path::PathBuf;
+
+use lazy_static::lazy_static;
+use rusqlite::types::{FromSql, FromSqlError};
+use rusqlite::{params, Connection, OpenFlags, OptionalExtension, ToSql, NO_PARAMS};
+use stacks_common::types::chainstate::{ConsensusHash, StacksBlockId};
+use stacks_common::util::{get_epoch_time_secs, sleep_ms};
+
+use crate::chainstate::burn::db::sortdb::{SortitionDB, SortitionHandle};
+use crate::chainstate::burn::BlockSnapshot;
+use crate::chainstate::nakamoto::{NakamotoBlock, NakamotoChainState};
+use crate::chainstate::stacks::db::StacksChainState;
+use crate::chainstate::stacks::index::marf::MarfConnection;
+use crate::chainstate::stacks::{Error as ChainstateError, StacksBlock, StacksBlockHeader};
+use crate::stacks_common::codec::StacksMessageCodec;
+use crate::util_lib::db::{
+    query_int, query_row, query_row_panic, query_rows, sqlite_open, tx_begin_immediate, u64_to_sql,
+    DBConn, Error as DBError, FromRow,
+};
+
+lazy_static! {
+    pub static ref NAKAMOTO_STAGING_DB_SCHEMA_1: Vec<String> = vec![
+      r#"
+      -- Table for staging nakamoto blocks
+      CREATE TABLE nakamoto_staging_blocks (
+                     -- SHA512/256 hash of this block
+                     block_hash TEXT NOT NULL,
+                     -- the consensus hash of the burnchain block that selected this block's miner's block-commit
+                     consensus_hash TEXT NOT NULL,
+                     -- the parent index_block_hash
+                     parent_block_id TEXT NOT NULL,
+
+                     -- has the burnchain block with this block's `consensus_hash` been processed?
+                     burn_attachable INT NOT NULL,
+                     -- has this block been processed?
+                     processed INT NOT NULL,
+                     -- set to 1 if this block can never be attached
+                     orphaned INT NOT NULL,
+
+                     height INT NOT NULL,
+
+                     -- used internally -- this is the StacksBlockId of this block's consensus hash and block hash
+                     index_block_hash TEXT NOT NULL,
+                     -- how long the block was in-flight
+                     download_time INT NOT NULL,
+                     -- when this block was stored
+                     arrival_time INT NOT NULL,
+                     -- when this block was processed
+                     processed_time INT NOT NULL,
+
+                     -- block data
+                     data BLOB NOT NULL,
+                    
+                     PRIMARY KEY(block_hash,consensus_hash)
+        );"#
+        .into(),
+        r#"CREATE INDEX by_index_block_hash ON nakamoto_staging_blocks(index_block_hash);"#.into()
+    ];
+}
+
+pub struct NakamotoStagingBlocksConn(rusqlite::Connection);
+
+impl Deref for NakamotoStagingBlocksConn {
+    type Target = rusqlite::Connection;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for NakamotoStagingBlocksConn {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl NakamotoStagingBlocksConn {
+    pub fn conn(&self) -> NakamotoStagingBlocksConnRef {
+        NakamotoStagingBlocksConnRef(&self.0)
+    }
+}
+
+pub struct NakamotoStagingBlocksConnRef<'a>(&'a rusqlite::Connection);
+
+impl<'a> NakamotoStagingBlocksConnRef<'a> {
+    pub fn conn(&self) -> NakamotoStagingBlocksConnRef<'a> {
+        NakamotoStagingBlocksConnRef(self.0)
+    }
+}
+
+impl Deref for NakamotoStagingBlocksConnRef<'_> {
+    type Target = rusqlite::Connection;
+    fn deref(&self) -> &Self::Target {
+        self.0
+    }
+}
+
+pub struct NakamotoStagingBlocksTx<'a>(rusqlite::Transaction<'a>);
+
+impl<'a> NakamotoStagingBlocksTx<'a> {
+    pub fn commit(self) -> Result<(), rusqlite::Error> {
+        self.0.commit()
+    }
+
+    pub fn conn(&self) -> NakamotoStagingBlocksConnRef {
+        NakamotoStagingBlocksConnRef(self.0.deref())
+    }
+}
+
+impl<'a> Deref for NakamotoStagingBlocksTx<'a> {
+    type Target = rusqlite::Transaction<'a>;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl<'a> DerefMut for NakamotoStagingBlocksTx<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl<'a> NakamotoStagingBlocksConnRef<'a> {
+    /// Determine whether or not we have processed at least one Nakamoto block in this sortition history.
+    /// NOTE: the relevant field queried from `nakamoto_staging_blocks` is updated by a separate
+    /// tx from block-processing, so it's imperative that the thread that calls this function is
+    /// the *same* thread as the one that processes blocks.
+    /// Returns Ok(true) if at least one block in `nakamoto_staging_blocks` has `processed = 1`
+    /// Returns Ok(false) if not
+    /// Returns Err(..) on DB error
+    fn has_processed_nakamoto_block<SH: SortitionHandle>(
+        &self,
+        sortition_handle: &SH,
+    ) -> Result<bool, ChainstateError> {
+        let Some((ch, bhh, _height)) = sortition_handle.get_nakamoto_tip()? else {
+            return Ok(false);
+        };
+
+        // this block must be a processed Nakamoto block
+        let ibh = StacksBlockId::new(&ch, &bhh);
+        let qry = "SELECT 1 FROM nakamoto_staging_blocks WHERE processed = 1 AND index_block_hash = ?1 LIMIT 1";
+        let args: &[&dyn ToSql] = &[&ibh];
+        let res: Option<i64> = query_row(self, qry, args)?;
+        Ok(res.is_some())
+    }
+
+    /// Get a Nakamoto block by index block hash, as well as its size.
+    /// Verifies its integrity.
+    /// Returns Ok(Some(block, size)) if the block was present
+    /// Returns Ok(None) if there were no such rows.
+    /// Returns Err(..) on DB error, including block corruption
+    pub fn get_nakamoto_block(
+        &self,
+        index_block_hash: &StacksBlockId,
+    ) -> Result<Option<(NakamotoBlock, u64)>, ChainstateError> {
+        let qry = "SELECT data FROM nakamoto_staging_blocks WHERE index_block_hash = ?1";
+        let args: &[&dyn ToSql] = &[index_block_hash];
+        let res: Option<Vec<u8>> = query_row(self, qry, args)?;
+        let Some(block_bytes) = res else {
+            return Ok(None);
+        };
+        let block = NakamotoBlock::consensus_deserialize(&mut block_bytes.as_slice())?;
+        if &block.header.block_id() != index_block_hash {
+            error!(
+                "Staging DB corruption: expected {}, got {}",
+                index_block_hash,
+                &block.header.block_id()
+            );
+            return Err(DBError::Corruption.into());
+        }
+        Ok(Some((
+            block,
+            u64::try_from(block_bytes.len()).expect("FATAL: block is greater than a u64"),
+        )))
+    }
+
+    /// Find the next ready-to-process Nakamoto block, given a connection to the staging blocks DB.
+    /// NOTE: the relevant field queried from `nakamoto_staging_blocks` are updated by a separate
+    /// tx from block-processing, so it's imperative that the thread that calls this function is
+    /// the *same* thread that goes to process blocks.
+    /// Returns (the block, the size of the block)
+    pub(crate) fn next_ready_nakamoto_block<SH: SortitionHandle>(
+        &self,
+        header_conn: &Connection,
+        sortition_handle: &SH,
+    ) -> Result<Option<(NakamotoBlock, u64)>, ChainstateError> {
+        let query = "SELECT child.data FROM nakamoto_staging_blocks child JOIN nakamoto_staging_blocks parent
+                     ON child.parent_block_id = parent.index_block_hash
+                     WHERE child.burn_attachable = 1
+                       AND child.orphaned = 0
+                       AND child.processed = 0
+                       AND parent.processed = 1
+                     ORDER BY child.height ASC";
+        self
+            .query_row_and_then(query, NO_PARAMS, |row| {
+                let data: Vec<u8> = row.get("data")?;
+                let block = NakamotoBlock::consensus_deserialize(&mut data.as_slice())?;
+                Ok(Some((
+                    block,
+                    u64::try_from(data.len()).expect("FATAL: block is bigger than a u64"),
+                )))
+            })
+            .or_else(|e| {
+                if let ChainstateError::DBError(DBError::SqliteError(
+                    rusqlite::Error::QueryReturnedNoRows,
+                )) = e
+                {
+                    // This query can fail if the parent of `child` is not a Nakamoto block, which
+                    // is allowed -- a Nakamoto block can descend from an epoch2 block (but since
+                    // Nakamoto does not fork without a Bitcoin fork, it'll be the only such child
+                    // within that Bitcoin forok).
+                    //
+                    // So, if at least one Nakamoto block is processed in this Bitcoin fork,
+                    // then the next ready block's parent *must* be a Nakamoto block.  So
+                    // if the below is true, then there are no ready blocks.
+                    if self.has_processed_nakamoto_block(sortition_handle)? {
+                        return Ok(None);
+                    }
+
+                    // no nakamoto blocks processed yet, so the parent *must* be an epoch2 block!
+                    // go find it.  Note that while this is expensive, it only has to be done
+                    // _once_, and it will only touch at most one reward cycle's worth of blocks.
+                    let sql = "SELECT index_block_hash,parent_block_id FROM nakamoto_staging_blocks WHERE processed = 0 AND orphaned = 0 AND burn_attachable = 1 ORDER BY height ASC";
+                    let mut stmt = self.deref().prepare(sql)?;
+                    let mut qry = stmt.query(NO_PARAMS)?;
+                    let mut next_nakamoto_block_id = None;
+                    while let Some(row) = qry.next()? {
+                        let index_block_hash : StacksBlockId = row.get(0)?;
+                        let parent_block_id : StacksBlockId = row.get(1)?;
+
+                        let Some(_parent_epoch2_block) = NakamotoChainState::get_block_header_epoch2(header_conn, &parent_block_id)? else {
+                            continue;
+                        };
+
+                        // epoch2 parent exists, so this Nakamoto block is processable!
+                        next_nakamoto_block_id = Some(index_block_hash);
+                        break;
+                    }
+                    let Some(next_nakamoto_block_id) = next_nakamoto_block_id else {
+                        // no stored nakamoto block had an epoch2 parent
+                        return Ok(None);
+                    };
+
+                    // need qry and stmt to stop borrowing self before we can use it
+                    // again
+                    // drop(qry);
+                    // drop(stmt);
+
+                    self.get_nakamoto_block(&next_nakamoto_block_id)
+                } else {
+                    Err(e)
+                }
+            })
+    }
+}
+
+impl<'a> NakamotoStagingBlocksTx<'a> {
+    /// Notify the staging database that a given stacks block has been processed.
+    /// This will update the attachable status for children blocks, as well as marking the stacks
+    ///  block itself as processed.
+    pub fn set_block_processed(&self, block: &StacksBlockId) -> Result<(), ChainstateError> {
+        let clear_staged_block =
+            "UPDATE nakamoto_staging_blocks SET processed = 1, processed_time = ?2
+                                  WHERE index_block_hash = ?1";
+        self.execute(
+            &clear_staged_block,
+            params![&block, &u64_to_sql(get_epoch_time_secs())?],
+        )?;
+
+        Ok(())
+    }
+
+    /// Modify the staging database that a given stacks block can never be processed.
+    /// This will update the attachable status for children blocks, as well as marking the stacks
+    /// block itself as orphaned.
+    pub fn set_block_orphaned(&self, block: &StacksBlockId) -> Result<(), ChainstateError> {
+        let update_dependents = "UPDATE nakamoto_staging_blocks SET orphaned = 1
+                                 WHERE parent_block_id = ?";
+
+        self.execute(&update_dependents, &[&block])?;
+
+        let clear_staged_block =
+            "UPDATE nakamoto_staging_blocks SET processed = 1, processed_time = ?2, orphaned = 1
+                                  WHERE index_block_hash = ?1";
+        self.execute(
+            &clear_staged_block,
+            params![&block, &u64_to_sql(get_epoch_time_secs())?],
+        )?;
+
+        Ok(())
+    }
+
+    /// Notify the staging database that a given burn block has been processed.
+    /// This is required for staged blocks to be eligible for processing.
+    pub fn set_burn_block_processed(
+        &self,
+        consensus_hash: &ConsensusHash,
+    ) -> Result<(), ChainstateError> {
+        let update_dependents = "UPDATE nakamoto_staging_blocks SET burn_attachable = 1
+                                 WHERE consensus_hash = ?";
+        self.execute(&update_dependents, &[consensus_hash])?;
+
+        Ok(())
+    }
+}
+
+impl StacksChainState {
+    /// Begin a transaction against the staging blocks DB.
+    /// Note that this DB is (or will eventually be) in a separate database from the headers.
+    pub fn staging_db_tx_begin<'a>(
+        &'a mut self,
+    ) -> Result<NakamotoStagingBlocksTx<'a>, ChainstateError> {
+        let tx = tx_begin_immediate(&mut self.nakamoto_staging_blocks_conn)?;
+        Ok(NakamotoStagingBlocksTx(tx))
+    }
+
+    /// Begin a tx to both the headers DB and the staging DB
+    pub fn headers_and_staging_tx_begin<'a>(
+        &'a mut self,
+    ) -> Result<(rusqlite::Transaction<'a>, NakamotoStagingBlocksTx<'a>), ChainstateError> {
+        let header_tx = self
+            .state_index
+            .storage_tx()
+            .map_err(ChainstateError::DBError)?;
+        let staging_tx = tx_begin_immediate(&mut self.nakamoto_staging_blocks_conn)?;
+        Ok((header_tx, NakamotoStagingBlocksTx(staging_tx)))
+    }
+
+    /// Open a connection to the headers DB, and open a tx to the staging DB
+    pub fn headers_conn_and_staging_tx_begin<'a>(
+        &'a mut self,
+    ) -> Result<(&'a rusqlite::Connection, NakamotoStagingBlocksTx<'a>), ChainstateError> {
+        let header_conn = self.state_index.sqlite_conn();
+        let staging_tx = tx_begin_immediate(&mut self.nakamoto_staging_blocks_conn)?;
+        Ok((header_conn, NakamotoStagingBlocksTx(staging_tx)))
+    }
+
+    /// Get a ref to the nakamoto staging blocks connection
+    pub fn nakamoto_blocks_db(&self) -> NakamotoStagingBlocksConnRef {
+        NakamotoStagingBlocksConnRef(&self.nakamoto_staging_blocks_conn)
+    }
+
+    /// Get the path to the Nakamoto staging blocks DB.
+    /// It's separate from the headers DB in order to avoid DB contention between downloading
+    /// blocks and processing them.
+    pub fn get_nakamoto_staging_blocks_path(root_path: PathBuf) -> Result<String, ChainstateError> {
+        let mut nakamoto_blocks_path = Self::blocks_path(root_path);
+        nakamoto_blocks_path.push("nakamoto.sqlite");
+        Ok(nakamoto_blocks_path
+            .to_str()
+            .ok_or(ChainstateError::DBError(DBError::ParseError))?
+            .to_string())
+    }
+
+    /// Open and set up a DB for nakamoto staging blocks.
+    /// If it doesn't exist, then instantiate it if `readwrite` is true.
+    pub fn open_nakamoto_staging_blocks(
+        path: &str,
+        readwrite: bool,
+    ) -> Result<NakamotoStagingBlocksConn, ChainstateError> {
+        let exists = fs::metadata(&path).is_ok();
+        let flags = if !exists {
+            // try to instantiate
+            if readwrite {
+                OpenFlags::SQLITE_OPEN_READ_WRITE | OpenFlags::SQLITE_OPEN_CREATE
+            } else {
+                return Err(DBError::NotFoundError.into());
+            }
+        } else {
+            if readwrite {
+                OpenFlags::SQLITE_OPEN_READ_WRITE
+            } else {
+                OpenFlags::SQLITE_OPEN_READ_ONLY
+            }
+        };
+        let conn = sqlite_open(path, flags, false)?;
+        if !exists {
+            for cmd in NAKAMOTO_STAGING_DB_SCHEMA_1.iter() {
+                conn.execute(cmd, NO_PARAMS)?;
+            }
+        }
+        Ok(NakamotoStagingBlocksConn(conn))
+    }
+}
diff --git a/stackslib/src/chainstate/nakamoto/tests/mod.rs b/stackslib/src/chainstate/nakamoto/tests/mod.rs
index d6b5618f57..d6862de2a3 100644
--- a/stackslib/src/chainstate/nakamoto/tests/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/mod.rs
@@ -21,6 +21,7 @@ use clarity::types::chainstate::{PoxId, SortitionId, StacksBlockId};
 use clarity::vm::clarity::ClarityConnection;
 use clarity::vm::costs::ExecutionCost;
 use clarity::vm::types::StacksAddressExtensions;
+use rusqlite::Connection;
 use stacks_common::address::AddressHashMode;
 use stacks_common::bitvec::BitVec;
 use stacks_common::codec::StacksMessageCodec;
@@ -54,7 +55,7 @@ use crate::chainstate::nakamoto::miner::NakamotoBlockBuilder;
 use crate::chainstate::nakamoto::tenure::NakamotoTenure;
 use crate::chainstate::nakamoto::tests::node::{TestSigners, TestStacker};
 use crate::chainstate::nakamoto::{
-    NakamotoBlock, NakamotoBlockHeader, NakamotoChainState, FIRST_STACKS_BLOCK_ID,
+    NakamotoBlock, NakamotoBlockHeader, NakamotoChainState, SortitionHandle, FIRST_STACKS_BLOCK_ID,
 };
 use crate::chainstate::stacks::boot::MINERS_NAME;
 use crate::chainstate::stacks::db::{
@@ -71,6 +72,7 @@ use crate::core;
 use crate::core::{StacksEpochExtension, STACKS_EPOCH_3_0_MARKER};
 use crate::net::codec::test::check_codec_and_corruption;
 use crate::util_lib::boot::boot_code_id;
+use crate::util_lib::db::Error as db_error;
 
 /// Get an address's account
 pub fn get_account(
@@ -519,6 +521,47 @@ pub fn test_nakamoto_first_tenure_block_syntactic_validation() {
     );
 }
 
+struct MockSortitionHandle {
+    nakamoto_tip: (ConsensusHash, BlockHeaderHash, u64),
+}
+
+impl MockSortitionHandle {
+    pub fn new(consensus_hash: ConsensusHash, bhh: BlockHeaderHash, height: u64) -> Self {
+        Self {
+            nakamoto_tip: (consensus_hash, bhh, height),
+        }
+    }
+}
+
+impl SortitionHandle for MockSortitionHandle {
+    fn get_block_snapshot_by_height(
+        &mut self,
+        block_height: u64,
+    ) -> Result<Option<BlockSnapshot>, db_error> {
+        unimplemented!()
+    }
+
+    fn first_burn_block_height(&self) -> u64 {
+        unimplemented!()
+    }
+
+    fn pox_constants(&self) -> &PoxConstants {
+        unimplemented!()
+    }
+
+    fn sqlite(&self) -> &Connection {
+        unimplemented!()
+    }
+
+    fn tip(&self) -> SortitionId {
+        unimplemented!()
+    }
+
+    fn get_nakamoto_tip(&self) -> Result<Option<(ConsensusHash, BlockHeaderHash, u64)>, db_error> {
+        Ok(Some(self.nakamoto_tip.clone()))
+    }
+}
+
 #[test]
 pub fn test_load_store_update_nakamoto_blocks() {
     let test_name = function_name!();
@@ -957,33 +1000,27 @@ pub fn test_load_store_update_nakamoto_blocks() {
     }
 
     // can load Nakamoto block, but only the Nakamoto block
+    let nakamoto_blocks_db = chainstate.nakamoto_blocks_db();
     assert_eq!(
-        NakamotoChainState::load_nakamoto_block(
-            chainstate.nakamoto_blocks_db(),
-            &nakamoto_header.consensus_hash,
-            &nakamoto_header.block_hash()
-        )
-        .unwrap()
-        .unwrap(),
+        nakamoto_blocks_db
+            .get_nakamoto_block(&nakamoto_header.block_id())
+            .unwrap()
+            .unwrap()
+            .0,
         nakamoto_block
     );
     assert_eq!(
-        NakamotoChainState::load_nakamoto_block(
-            chainstate.nakamoto_blocks_db(),
-            &nakamoto_header_2.consensus_hash,
-            &nakamoto_header_2.block_hash()
-        )
-        .unwrap()
-        .unwrap(),
+        nakamoto_blocks_db
+            .get_nakamoto_block(&nakamoto_header_2.block_id())
+            .unwrap()
+            .unwrap()
+            .0,
         nakamoto_block_2
     );
     assert_eq!(
-        NakamotoChainState::load_nakamoto_block(
-            chainstate.nakamoto_blocks_db(),
-            &epoch2_header_info.consensus_hash,
-            &epoch2_header.block_hash()
-        )
-        .unwrap(),
+        nakamoto_blocks_db
+            .get_nakamoto_block(&epoch2_header_info.index_block_hash())
+            .unwrap(),
         None
     );
 
@@ -1043,7 +1080,8 @@ pub fn test_load_store_update_nakamoto_blocks() {
     // set nakamoto block processed
     {
         let (tx, staging_tx) = chainstate.headers_and_staging_tx_begin().unwrap();
-        NakamotoChainState::set_block_processed(&staging_tx, &nakamoto_header_3.block_id())
+        staging_tx
+            .set_block_processed(&nakamoto_header_3.block_id())
             .unwrap();
         assert_eq!(
             NakamotoChainState::get_nakamoto_block_status(
@@ -1060,7 +1098,9 @@ pub fn test_load_store_update_nakamoto_blocks() {
     // set nakamoto block orphaned
     {
         let (tx, staging_tx) = chainstate.headers_and_staging_tx_begin().unwrap();
-        NakamotoChainState::set_block_orphaned(&staging_tx, &nakamoto_header.block_id()).unwrap();
+        staging_tx
+            .set_block_orphaned(&nakamoto_header.block_id())
+            .unwrap();
         assert_eq!(
             NakamotoChainState::get_nakamoto_block_status(
                 staging_tx.conn(),
@@ -1076,7 +1116,8 @@ pub fn test_load_store_update_nakamoto_blocks() {
     // orphan nakamoto block by parent
     {
         let (tx, staging_tx) = chainstate.headers_and_staging_tx_begin().unwrap();
-        NakamotoChainState::set_block_orphaned(&staging_tx, &nakamoto_header.parent_block_id)
+        staging_tx
+            .set_block_orphaned(&nakamoto_header.parent_block_id)
             .unwrap();
         assert_eq!(
             NakamotoChainState::get_nakamoto_block_status(
@@ -1264,31 +1305,38 @@ pub fn test_load_store_update_nakamoto_blocks() {
     // been processed
     {
         let (tx, staging_tx) = chainstate.headers_and_staging_tx_begin().unwrap();
+        let staging_conn = staging_tx.conn();
+        let sh = MockSortitionHandle::new(
+            nakamoto_block_2.header.consensus_hash.clone(),
+            nakamoto_block_2.header.block_hash(),
+            nakamoto_block_2.header.chain_length,
+        );
+
         assert_eq!(
-            NakamotoChainState::next_ready_nakamoto_block(staging_tx.conn(), &tx).unwrap(),
+            staging_conn.next_ready_nakamoto_block(&tx, &sh).unwrap(),
             None
         );
 
         // set parent epoch2 block processed
-        NakamotoChainState::set_block_processed(
-            &staging_tx,
-            &epoch2_header_info.index_block_hash(),
-        )
-        .unwrap();
+        staging_tx
+            .set_block_processed(&epoch2_header_info.index_block_hash())
+            .unwrap();
 
         // but it's not enough -- child's consensus hash needs to be burn_processable
         assert_eq!(
-            NakamotoChainState::next_ready_nakamoto_block(staging_tx.conn(), &tx).unwrap(),
+            staging_conn.next_ready_nakamoto_block(&tx, &sh).unwrap(),
             None
         );
 
         // set burn processed
-        NakamotoChainState::set_burn_block_processed(&staging_tx, &nakamoto_header.consensus_hash)
+        staging_tx
+            .set_burn_block_processed(&nakamoto_header.consensus_hash)
             .unwrap();
 
         // this works now
         assert_eq!(
-            NakamotoChainState::next_ready_nakamoto_block(staging_tx.conn(), &tx)
+            staging_conn
+                .next_ready_nakamoto_block(&tx, &sh)
                 .unwrap()
                 .unwrap()
                 .0,
@@ -1296,15 +1344,14 @@ pub fn test_load_store_update_nakamoto_blocks() {
         );
 
         // set parent nakamoto block processed
-        NakamotoChainState::set_block_processed(
-            &staging_tx,
-            &nakamoto_header_info.index_block_hash(),
-        )
-        .unwrap();
+        staging_tx
+            .set_block_processed(&nakamoto_header_info.index_block_hash())
+            .unwrap();
 
         // next nakamoto block
         assert_eq!(
-            NakamotoChainState::next_ready_nakamoto_block(staging_tx.conn(), &tx)
+            staging_conn
+                .next_ready_nakamoto_block(&tx, &sh)
                 .unwrap()
                 .unwrap()
                 .0,

From bcf0df0f4f27ed5c301eed2149791f3eccc4b768 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Thu, 15 Feb 2024 16:05:51 -0500
Subject: [PATCH 0778/1166] chore: remove commented-out code

---
 stackslib/src/chainstate/nakamoto/staging_blocks.rs | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/staging_blocks.rs b/stackslib/src/chainstate/nakamoto/staging_blocks.rs
index e026c89744..c7bcfeb127 100644
--- a/stackslib/src/chainstate/nakamoto/staging_blocks.rs
+++ b/stackslib/src/chainstate/nakamoto/staging_blocks.rs
@@ -258,11 +258,6 @@ impl<'a> NakamotoStagingBlocksConnRef<'a> {
                         return Ok(None);
                     };
 
-                    // need qry and stmt to stop borrowing self before we can use it
-                    // again
-                    // drop(qry);
-                    // drop(stmt);
-
                     self.get_nakamoto_block(&next_nakamoto_block_id)
                 } else {
                     Err(e)

From 7b42ff155c73b03f7e58be425f1801a15ce53650 Mon Sep 17 00:00:00 2001
From: Joey Yandle <xoloki@gmail.com>
Date: Thu, 15 Feb 2024 11:59:47 -0500
Subject: [PATCH 0779/1166] update wsts workspace dependency to v8.1

---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 1784c93f59..f1d69dc5b0 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4646,9 +4646,9 @@ dependencies = [
 
 [[package]]
 name = "wsts"
-version = "8.0.0"
+version = "8.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06eee6f3bb38f8c8dca03053572130be2e5006a31dc7e5d8c62e375952b2ff38"
+checksum = "467aa8e40ed0277d19922fd0e7357c16552cb900e5138f61a48ac23c4b7878e0"
 dependencies = [
  "aes-gcm 0.10.3",
  "bs58 0.5.0",
diff --git a/Cargo.toml b/Cargo.toml
index 3f0924c183..1d447d00c5 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -14,7 +14,7 @@ members = [
 
 # Dependencies we want to keep the same between workspace members
 [workspace.dependencies]  
-wsts = { version = "8.0", default-features = false }
+wsts = { version = "8.1", default-features = false }
 ed25519-dalek = { version = "2.1.1", features = ["serde", "rand_core"] } 
 rand_core = "0.6"
 rand = "0.8"

From ea30db99f9e082f1b54249d8d9411139810fa955 Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Thu, 15 Feb 2024 16:26:02 -0500
Subject: [PATCH 0780/1166] chore: address PR feedback

---
 stackslib/src/net/inv/nakamoto.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stackslib/src/net/inv/nakamoto.rs b/stackslib/src/net/inv/nakamoto.rs
index 7dea03652a..c0a02d9819 100644
--- a/stackslib/src/net/inv/nakamoto.rs
+++ b/stackslib/src/net/inv/nakamoto.rs
@@ -352,7 +352,7 @@ impl NakamotoTenureInv {
     /// Returns the reward cycle to query.
     pub fn next_reward_cycle(&mut self) -> u64 {
         let query_rc = self.cur_reward_cycle;
-        self.cur_reward_cycle += 1;
+        self.cur_reward_cycle = self.cur_reward_cycle.saturating_add(1);
         query_rc
     }
 

From 30c4c529329edf0e3b1f2c9fdce5437306eb3333 Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Thu, 15 Feb 2024 19:19:45 -0500
Subject: [PATCH 0781/1166] test: update signers key in tests

---
 .../chainstate/nakamoto/coordinator/tests.rs  | 39 +++++++++++++++++--
 .../src/chainstate/nakamoto/tests/node.rs     | 31 +++++++++++++--
 testnet/stacks-node/src/mockamoto.rs          |  8 +++-
 .../stacks-node/src/nakamoto_node/miner.rs    | 11 +++++-
 .../src/tests/nakamoto_integrations.rs        |  8 +++-
 5 files changed, 87 insertions(+), 10 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index 216687cd73..b2414ae280 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -1204,8 +1204,19 @@ pub fn simple_nakamoto_coordinator_10_tenures_10_sortitions<'a>() -> TestPeer<'a
             },
         );
 
+        let fees = blocks_and_sizes
+            .iter()
+            .map(|(block, _, _)| {
+                block
+                    .txs
+                    .iter()
+                    .map(|tx| tx.get_tx_fee() as u128)
+                    .sum::<u128>()
+            })
+            .sum::<u128>();
+
         consensus_hashes.push(consensus_hash);
-        fee_counts.push(num_blocks as u128);
+        fee_counts.push(fees);
         total_blocks += num_blocks;
 
         let mut blocks: Vec<NakamotoBlock> = blocks_and_sizes
@@ -1353,7 +1364,18 @@ pub fn simple_nakamoto_coordinator_10_tenures_10_sortitions<'a>() -> TestPeer<'a
             assert_eq!(matured_reward.parent_miner.coinbase, 1000_000_000);
         }
 
-        if i < 11 {
+        if i == 8 {
+            // epoch2
+            assert_eq!(
+                matured_reward.parent_miner.tx_fees,
+                MinerPaymentTxFees::Epoch2 {
+                    // The signers voting transaction is paying a fee of 1 uSTX
+                    // currently, but this may change to pay 0.
+                    anchored: 1,
+                    streamed: 0,
+                }
+            );
+        } else if i < 11 {
             // epoch2
             assert_eq!(
                 matured_reward.parent_miner.tx_fees,
@@ -1387,7 +1409,18 @@ pub fn simple_nakamoto_coordinator_10_tenures_10_sortitions<'a>() -> TestPeer<'a
         } else {
             assert_eq!(miner_reward.coinbase, 1000_000_000);
         }
-        if i < 10 {
+        if i == 7 {
+            // epoch2
+            assert_eq!(
+                miner_reward.tx_fees,
+                MinerPaymentTxFees::Epoch2 {
+                    // The signers voting transaction is paying a fee of 1 uSTX
+                    // currently, but this may change to pay 0.
+                    anchored: 1,
+                    streamed: 0,
+                }
+            );
+        } else if i < 10 {
             // epoch2
             assert_eq!(
                 miner_reward.tx_fees,
diff --git a/stackslib/src/chainstate/nakamoto/tests/node.rs b/stackslib/src/chainstate/nakamoto/tests/node.rs
index 7b88792498..32ab12f653 100644
--- a/stackslib/src/chainstate/nakamoto/tests/node.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/node.rs
@@ -122,6 +122,8 @@ pub struct TestSigners {
     pub threshold: u32,
     /// The key ids distributed among signer_parties
     pub party_key_ids: Vec<Vec<u32>>,
+    /// The cycle for which the signers are valid
+    pub cycle: u64,
 }
 
 impl Default for TestSigners {
@@ -168,12 +170,18 @@ impl Default for TestSigners {
             num_keys,
             threshold,
             party_key_ids,
+            cycle: 0,
         }
     }
 }
 
 impl TestSigners {
-    pub fn sign_nakamoto_block(&mut self, block: &mut NakamotoBlock) {
+    pub fn sign_nakamoto_block(&mut self, block: &mut NakamotoBlock, cycle: u64) {
+        // Update the aggregate public key if the cycle has changed
+        if self.cycle != cycle {
+            self.generate_aggregate_key(cycle);
+        }
+
         let mut rng = rand_core::OsRng;
         let msg = block.header.signer_signature_hash().0;
         let (nonces, sig_shares, key_ids) =
@@ -190,8 +198,15 @@ impl TestSigners {
     }
 
     // Generate and assign a new aggregate public key
-    pub fn generate_aggregate_key(&mut self, seed: u64) -> Point {
-        let mut rng = ChaCha20Rng::seed_from_u64(seed);
+    pub fn generate_aggregate_key(&mut self, cycle: u64) -> Point {
+        // If the key is already generated for this cycle, return it
+        if cycle == self.cycle {
+            debug!("Returning cached aggregate key for cycle {}", cycle);
+            return self.aggregate_public_key.clone();
+        }
+
+        debug!("Generating aggregate key for cycle {}", cycle);
+        let mut rng = ChaCha20Rng::seed_from_u64(cycle);
         let num_parties = self.party_key_ids.len().try_into().unwrap();
         // Create the parties
         self.signer_parties = self
@@ -221,6 +236,7 @@ impl TestSigners {
             .init(&self.poly_commitments)
             .expect("aggregator init failed");
         self.aggregate_public_key = sig_aggregator.poly[0];
+        self.cycle = cycle;
         self.aggregate_public_key.clone()
     }
 }
@@ -679,7 +695,11 @@ impl TestStacksNode {
                 Self::make_nakamoto_block_from_txs(builder, chainstate, &sortdb.index_conn(), txs)
                     .unwrap();
             miner.sign_nakamoto_block(&mut nakamoto_block);
-            signers.sign_nakamoto_block(&mut nakamoto_block);
+            let cycle = miner
+                .burnchain
+                .block_height_to_reward_cycle(burn_tip.block_height)
+                .expect("FATAL: failed to get reward cycle");
+            signers.sign_nakamoto_block(&mut nakamoto_block, cycle);
 
             let block_id = nakamoto_block.block_id();
             debug!(
@@ -1095,6 +1115,9 @@ impl<'a> TestPeer<'a> {
         let mut stacks_node = self.stacks_node.take().unwrap();
         let sortdb = self.sortdb.take().unwrap();
 
+        // Ensure the signers are setup for the current cycle
+        // signers.generate_aggregate_key(cycle);
+
         let blocks = TestStacksNode::make_nakamoto_tenure_blocks(
             &mut stacks_node.chainstate,
             &sortdb,
diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index 3d1691c263..32844394f5 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -1038,7 +1038,13 @@ impl MockamotoNode {
             )?;
             aggregate_public_key
         };
-        self.self_signer.sign_nakamoto_block(&mut block);
+        let burn_tip = SortitionDB::get_canonical_burn_chain_tip(&self.sortdb.conn())?;
+        let cycle = self
+            .sortdb
+            .pox_constants
+            .block_height_to_reward_cycle(self.sortdb.first_block_height, burn_tip.block_height)
+            .unwrap();
+        self.self_signer.sign_nakamoto_block(&mut block, cycle);
         let staging_tx = self.chainstate.staging_db_tx_begin()?;
         NakamotoChainState::accept_block(
             &config,
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index 8d14921a23..bac073e953 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -421,7 +421,6 @@ impl BlockMinerThread {
         mut signer: TestSigners,
         mut block: NakamotoBlock,
     ) -> Result<(), ChainstateError> {
-        signer.sign_nakamoto_block(&mut block);
         let mut chain_state = neon_node::open_chainstate_with_faults(&self.config)
             .expect("FATAL: could not open chainstate DB");
         let chainstate_config = chain_state.config();
@@ -431,6 +430,16 @@ impl BlockMinerThread {
             self.burnchain.pox_constants.clone(),
         )
         .expect("FATAL: could not open sortition DB");
+
+        // Check if we need to update the signer key. This key needs to change
+        // on each tenure change or it will not match the public key that is
+        // retrieved from the signers contract.
+        let cycle = self
+            .burnchain
+            .block_height_to_reward_cycle(block.header.chain_length)
+            .expect("FATAL: no reward cycle for burn block");
+        signer.sign_nakamoto_block(&mut block, cycle);
+
         let mut sortition_handle = sort_db.index_handle_at_tip();
         let aggregate_public_key = if block.header.chain_length <= 1 {
             signer.aggregate_public_key.clone()
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 8af6cc219e..cd8145afa5 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -1238,7 +1238,13 @@ fn block_proposal_api_endpoint() {
             .header
             .sign_miner(&privk)
             .expect("Miner failed to sign");
-        signer.sign_nakamoto_block(&mut p.block);
+        let burn_height = burnchain
+            .get_highest_burnchain_block()
+            .unwrap()
+            .unwrap()
+            .block_height;
+        let cycle = burnchain.block_height_to_reward_cycle(burn_height).unwrap();
+        signer.sign_nakamoto_block(&mut p.block, cycle);
         p
     };
 

From d52b67e2ca6b3fb85781fba4f460500840de3e0d Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Thu, 15 Feb 2024 19:46:54 -0500
Subject: [PATCH 0782/1166] fix: call `generate_aggregate_key` in
 `make_nakamoto_tenure`

---
 stackslib/src/chainstate/nakamoto/tests/node.rs | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/stackslib/src/chainstate/nakamoto/tests/node.rs b/stackslib/src/chainstate/nakamoto/tests/node.rs
index 32ab12f653..5c18797ff0 100644
--- a/stackslib/src/chainstate/nakamoto/tests/node.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/node.rs
@@ -1115,8 +1115,21 @@ impl<'a> TestPeer<'a> {
         let mut stacks_node = self.stacks_node.take().unwrap();
         let sortdb = self.sortdb.take().unwrap();
 
+        let burn_height = self
+            .coord
+            .burnchain
+            .get_highest_burnchain_block()
+            .unwrap()
+            .unwrap()
+            .block_height;
+        let cycle = self
+            .miner
+            .burnchain
+            .block_height_to_reward_cycle(burn_height)
+            .expect("FATAL: failed to get reward cycle");
+
         // Ensure the signers are setup for the current cycle
-        // signers.generate_aggregate_key(cycle);
+        signers.generate_aggregate_key(cycle);
 
         let blocks = TestStacksNode::make_nakamoto_tenure_blocks(
             &mut stacks_node.chainstate,

From 43acc8c7b5bbec9937f6984f73e9814432d45ae3 Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Thu, 15 Feb 2024 20:05:38 -0500
Subject: [PATCH 0783/1166] chore: remove `SelfSigner` which has been replaced
 with `TestSigners`

---
 testnet/stacks-node/src/mockamoto/signer.rs | 82 ---------------------
 1 file changed, 82 deletions(-)
 delete mode 100644 testnet/stacks-node/src/mockamoto/signer.rs

diff --git a/testnet/stacks-node/src/mockamoto/signer.rs b/testnet/stacks-node/src/mockamoto/signer.rs
deleted file mode 100644
index 60bf2afbbf..0000000000
--- a/testnet/stacks-node/src/mockamoto/signer.rs
+++ /dev/null
@@ -1,82 +0,0 @@
-use hashbrown::HashMap;
-use rand::{CryptoRng, RngCore, SeedableRng};
-use stacks::chainstate::nakamoto::NakamotoBlock;
-use stacks::chainstate::stacks::ThresholdSignature;
-use wsts::curve::point::Point;
-use wsts::traits::Aggregator;
-
-/// This struct encapsulates a FROST signer that is capable of
-///  signing its own aggregate public key.
-/// This is used in `mockamoto` and `nakamoto-neon` operation
-///  by the miner in order to self-sign blocks.
-#[derive(Debug, Clone, PartialEq)]
-pub struct SelfSigner {
-    /// The parties that will sign the blocks
-    pub signer_parties: Vec<wsts::v2::Party>,
-    /// The commitments to the polynomials for the aggregate public key
-    pub poly_commitments: HashMap<u32, wsts::common::PolyCommitment>,
-    /// The aggregate public key
-    pub aggregate_public_key: Point,
-    /// The total number of key ids distributed among signer_parties
-    pub num_keys: u32,
-    /// The number of vote shares required to sign a block
-    pub threshold: u32,
-}
-
-impl SelfSigner {
-    pub fn from_seed(seed: u64) -> Self {
-        let rng = rand::rngs::StdRng::seed_from_u64(seed);
-        Self::from_rng::<rand::rngs::StdRng>(rng)
-    }
-
-    pub fn single_signer() -> Self {
-        let rng = rand::rngs::OsRng::default();
-        Self::from_rng::<rand::rngs::OsRng>(rng)
-    }
-
-    fn from_rng<RNG: RngCore + CryptoRng>(mut rng: RNG) -> Self {
-        // Create the parties
-        let mut signer_parties = [wsts::v2::Party::new(0, &[1], 1, 1, 1, &mut rng)];
-
-        // Generate an aggregate public key
-        let poly_commitments = match wsts::v2::test_helpers::dkg(&mut signer_parties, &mut rng) {
-            Ok(poly_commitments) => poly_commitments,
-            Err(secret_errors) => {
-                panic!("Got secret errors from DKG: {:?}", secret_errors);
-            }
-        };
-
-        assert_eq!(poly_commitments.len(), 1);
-        assert_eq!(signer_parties.len(), 1);
-
-        let mut sig_aggregator = wsts::v2::Aggregator::new(1, 1);
-        sig_aggregator
-            .init(&poly_commitments)
-            .expect("aggregator init failed");
-
-        let aggregate_public_key = sig_aggregator.poly[0];
-        Self {
-            signer_parties: signer_parties.to_vec(),
-            aggregate_public_key,
-            poly_commitments,
-            num_keys: 1,
-            threshold: 1,
-        }
-    }
-
-    pub fn sign_nakamoto_block(&mut self, block: &mut NakamotoBlock) {
-        let mut rng = rand::rngs::OsRng::default();
-        let msg = block.header.signer_signature_hash().0;
-        let (nonces, sig_shares, key_ids) =
-            wsts::v2::test_helpers::sign(msg.as_slice(), &mut self.signer_parties, &mut rng);
-
-        let mut sig_aggregator = wsts::v2::Aggregator::new(self.num_keys, self.threshold);
-        sig_aggregator
-            .init(&self.poly_commitments)
-            .expect("aggregator init failed");
-        let signature = sig_aggregator
-            .sign(msg.as_slice(), &nonces, &sig_shares, &key_ids)
-            .expect("aggregator sig failed");
-        block.header.signer_signature = ThresholdSignature(signature);
-    }
-}

From 69013f49a8bd16d12a3aaa1cbbf56d98faba2e73 Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Thu, 15 Feb 2024 20:44:14 -0500
Subject: [PATCH 0784/1166] test: update
 `test_nakamoto_coordinator_10_tenures_and_extensions_10_blocks`

---
 .../chainstate/nakamoto/coordinator/tests.rs  | 76 +++++++++++++++++--
 .../src/chainstate/nakamoto/tests/node.rs     | 16 ++++
 2 files changed, 86 insertions(+), 6 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index b2414ae280..d343697843 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -1841,11 +1841,12 @@ pub fn simple_nakamoto_coordinator_10_extended_tenures_10_sortitions() -> TestPe
         None,
     );
 
-    let mut all_blocks = vec![];
+    let mut all_blocks: Vec<NakamotoBlock> = vec![];
     let mut all_burn_ops = vec![];
     let mut rc_blocks = vec![];
     let mut rc_burn_ops = vec![];
     let mut consensus_hashes = vec![];
+    let mut fee_counts = vec![];
     let stx_miner_key = peer.miner.nakamoto_miner_key();
 
     for i in 0..10 {
@@ -1864,6 +1865,41 @@ pub fn simple_nakamoto_coordinator_10_extended_tenures_10_sortitions() -> TestPe
 
         debug!("Next burnchain block: {}", &consensus_hash);
 
+        let block_height = peer
+            .config
+            .burnchain
+            .get_highest_burnchain_block()
+            .unwrap()
+            .unwrap()
+            .block_height;
+        // If we are in the prepare phase, check if we need to generate
+        // aggregate key votes
+        let txs = if peer.config.burnchain.is_in_prepare_phase(block_height) {
+            let cycle_id = peer
+                .config
+                .burnchain
+                .block_height_to_reward_cycle(block_height)
+                .unwrap();
+            let next_cycle_id = cycle_id as u128 + 1;
+
+            with_sortdb(&mut peer, |chainstate, sortdb| {
+                if let Some(tip) = all_blocks.last() {
+                    make_all_signers_vote_for_aggregate_key(
+                        chainstate,
+                        sortdb,
+                        &tip.block_id(),
+                        &mut test_signers,
+                        &test_stackers,
+                        next_cycle_id,
+                    )
+                } else {
+                    vec![]
+                }
+            })
+        } else {
+            vec![]
+        };
+
         // do a stx transfer in each block to a given recipient
         let recipient_addr =
             StacksAddress::from_string("ST2YM3J4KQK09V670TD6ZZ1XYNYCNGCWCVTASN5VM").unwrap();
@@ -1873,6 +1909,13 @@ pub fn simple_nakamoto_coordinator_10_extended_tenures_10_sortitions() -> TestPe
             &mut test_signers,
             |miner, chainstate, sortdb, blocks_so_far| {
                 if blocks_so_far.len() < 10 {
+                    // Include the aggregate key voting transactions in the first block.
+                    let mut txs = if blocks_so_far.is_empty() {
+                        txs.clone()
+                    } else {
+                        vec![]
+                    };
+
                     debug!("\n\nProduce block {}\n\n", blocks_so_far.len());
 
                     let account = get_account(chainstate, sortdb, &addr);
@@ -1886,13 +1929,14 @@ pub fn simple_nakamoto_coordinator_10_extended_tenures_10_sortitions() -> TestPe
                         1,
                         &recipient_addr,
                     );
+                    txs.push(stx_transfer);
 
                     let last_block_opt = blocks_so_far
                         .last()
                         .as_ref()
                         .map(|(block, _size, _cost)| block.header.block_id());
 
-                    let mut txs = vec![];
+                    let mut final_txs = vec![];
                     if let Some(last_block) = last_block_opt.as_ref() {
                         let tenure_extension = tenure_change.extend(
                             consensus_hash.clone(),
@@ -1901,16 +1945,29 @@ pub fn simple_nakamoto_coordinator_10_extended_tenures_10_sortitions() -> TestPe
                         );
                         let tenure_extension_tx =
                             miner.make_nakamoto_tenure_change(tenure_extension.clone());
-                        txs.push(tenure_extension_tx);
+                        final_txs.push(tenure_extension_tx);
                     }
-                    txs.append(&mut vec![stx_transfer]);
-                    txs
+                    final_txs.append(&mut txs);
+                    final_txs
                 } else {
                     vec![]
                 }
             },
         );
+
+        let fees = blocks_and_sizes
+            .iter()
+            .map(|(block, _, _)| {
+                block
+                    .txs
+                    .iter()
+                    .map(|tx| tx.get_tx_fee() as u128)
+                    .sum::<u128>()
+            })
+            .sum::<u128>();
+
         consensus_hashes.push(consensus_hash);
+        fee_counts.push(fees);
         let mut blocks: Vec<NakamotoBlock> = blocks_and_sizes
             .into_iter()
             .map(|(block, _, _)| block)
@@ -1987,6 +2044,7 @@ pub fn simple_nakamoto_coordinator_10_extended_tenures_10_sortitions() -> TestPe
     //            first 10          block    unmatured rewards
     //            blocks             11
     let mut expected_coinbase_rewards: u128 = 28800000000;
+    let mut fees_so_far: u128 = 0;
     for (i, ch) in consensus_hashes.into_iter().enumerate() {
         let sn = SortitionDB::get_block_snapshot_consensus(sort_db.conn(), &ch)
             .unwrap()
@@ -2006,8 +2064,14 @@ pub fn simple_nakamoto_coordinator_10_extended_tenures_10_sortitions() -> TestPe
             .unwrap();
 
         // it's 1 * 10 because it's 1 uSTX per token-transfer, and 10 per tenure
-        let expected_total_tx_fees = 1 * 10 * (i as u128).saturating_sub(3);
+        let block_fee = if i > 3 {
+            fee_counts[i.saturating_sub(4)]
+        } else {
+            0
+        };
+        let expected_total_tx_fees = fees_so_far + block_fee;
         let expected_total_coinbase = expected_coinbase_rewards;
+        fees_so_far += block_fee;
 
         if i == 0 {
             // first tenure awards the last of the initial mining bonus
diff --git a/stackslib/src/chainstate/nakamoto/tests/node.rs b/stackslib/src/chainstate/nakamoto/tests/node.rs
index 5c18797ff0..7c82f4e358 100644
--- a/stackslib/src/chainstate/nakamoto/tests/node.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/node.rs
@@ -1182,6 +1182,22 @@ impl<'a> TestPeer<'a> {
         let mut stacks_node = self.stacks_node.take().unwrap();
         let sortdb = self.sortdb.take().unwrap();
 
+        let burn_height = self
+            .coord
+            .burnchain
+            .get_highest_burnchain_block()
+            .unwrap()
+            .unwrap()
+            .block_height;
+        let cycle = self
+            .miner
+            .burnchain
+            .block_height_to_reward_cycle(burn_height)
+            .expect("FATAL: failed to get reward cycle");
+
+        // Ensure the signers are setup for the current cycle
+        signers.generate_aggregate_key(cycle);
+
         let blocks = TestStacksNode::make_nakamoto_tenure_blocks(
             &mut stacks_node.chainstate,
             &sortdb,

From 9cc1fd8dc6555329e524bb193573f08014311731 Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Fri, 16 Feb 2024 07:45:40 -0500
Subject: [PATCH 0785/1166] fix: Aaron's fix to the replay peer test failures

---
 stackslib/src/chainstate/nakamoto/mod.rs | 23 ++++++++---------------
 testnet/stacks-node/src/mockamoto.rs     | 17 +++++++++--------
 2 files changed, 17 insertions(+), 23 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index 806786cb24..8c6e5aedfd 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -1825,21 +1825,14 @@ impl NakamotoChainState {
         match chainstate.get_aggregate_public_key_pox_4(sortdb, at_block_id, rc)? {
             Some(key) => Ok(key),
             None => {
-                // if this is the first block in its reward cycle, it'll contain the effects of
-                // setting the aggregate public key for `rc`, but there will currently be no key
-                // for `rc`.  So, check `rc - 1`
-                chainstate
-                    .get_aggregate_public_key_pox_4(sortdb, at_block_id, rc.saturating_sub(1))?
-                    .ok_or_else(|| {
-                        warn!(
-                            "Failed to get aggregate public key";
-                            "block_id" => %at_block_id,
-                            "reward_cycle" => rc,
-                        );
-                        ChainstateError::InvalidStacksBlock(
-                            "Failed to get aggregate public key".into(),
-                        )
-                    })
+                warn!(
+                    "Failed to get aggregate public key";
+                    "block_id" => %at_block_id,
+                    "reward_cycle" => rc,
+                );
+                Err(ChainstateError::InvalidStacksBlock(
+                    "Failed to get aggregate public key".into(),
+                ))
             }
         }
     }
diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index 32844394f5..aecc8c3724 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -1027,6 +1027,15 @@ impl MockamotoNode {
         let config = self.chainstate.config();
         let chain_length = block.header.chain_length;
         let mut sortition_handle = self.sortdb.index_handle_at_tip();
+        let burn_tip = SortitionDB::get_canonical_burn_chain_tip(&self.sortdb.conn())?;
+        let cycle = self
+            .sortdb
+            .pox_constants
+            .block_height_to_reward_cycle(self.sortdb.first_block_height, burn_tip.block_height)
+            .unwrap();
+        self.self_signer.sign_nakamoto_block(&mut block, cycle);
+        let staging_tx = self.chainstate.staging_db_tx_begin()?;
+
         let aggregate_public_key = if chain_length <= 1 {
             self.self_signer.aggregate_public_key
         } else {
@@ -1038,14 +1047,6 @@ impl MockamotoNode {
             )?;
             aggregate_public_key
         };
-        let burn_tip = SortitionDB::get_canonical_burn_chain_tip(&self.sortdb.conn())?;
-        let cycle = self
-            .sortdb
-            .pox_constants
-            .block_height_to_reward_cycle(self.sortdb.first_block_height, burn_tip.block_height)
-            .unwrap();
-        self.self_signer.sign_nakamoto_block(&mut block, cycle);
-        let staging_tx = self.chainstate.staging_db_tx_begin()?;
         NakamotoChainState::accept_block(
             &config,
             block,

From d652d79dc6765f736b50ab5e1a5d4c4d4d83aed5 Mon Sep 17 00:00:00 2001
From: ASuciuX <151519329+ASuciuX@users.noreply.github.com>
Date: Fri, 16 Feb 2024 15:32:34 +0200
Subject: [PATCH 0786/1166] feat: remove locally tested mutant files

---
 mutants.out.old/caught.txt   |   0
 mutants.out.old/lock.json    |   6 -
 mutants.out.old/missed.txt   |   0
 mutants.out.old/mutants.json | 212 -----------------------------------
 mutants.out.old/timeout.txt  |   0
 mutants.out.old/unviable.txt |   0
 mutants.out/caught.txt       |   0
 mutants.out/lock.json        |   6 -
 mutants.out/missed.txt       |   0
 mutants.out/mutants.json     |   1 -
 mutants.out/timeout.txt      |   0
 mutants.out/unviable.txt     |   0
 12 files changed, 225 deletions(-)
 delete mode 100644 mutants.out.old/caught.txt
 delete mode 100644 mutants.out.old/lock.json
 delete mode 100644 mutants.out.old/missed.txt
 delete mode 100644 mutants.out.old/mutants.json
 delete mode 100644 mutants.out.old/timeout.txt
 delete mode 100644 mutants.out.old/unviable.txt
 delete mode 100644 mutants.out/caught.txt
 delete mode 100644 mutants.out/lock.json
 delete mode 100644 mutants.out/missed.txt
 delete mode 100644 mutants.out/mutants.json
 delete mode 100644 mutants.out/timeout.txt
 delete mode 100644 mutants.out/unviable.txt

diff --git a/mutants.out.old/caught.txt b/mutants.out.old/caught.txt
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/mutants.out.old/lock.json b/mutants.out.old/lock.json
deleted file mode 100644
index d8d9a04b19..0000000000
--- a/mutants.out.old/lock.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-  "cargo_mutants_version": "24.2.0",
-  "start_time": "2024-02-15T16:19:43.977743Z",
-  "hostname": "alin-suciu-xy7ww74xhv.local",
-  "username": "asuciu"
-}
\ No newline at end of file
diff --git a/mutants.out.old/missed.txt b/mutants.out.old/missed.txt
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/mutants.out.old/mutants.json b/mutants.out.old/mutants.json
deleted file mode 100644
index 545bda3d6f..0000000000
--- a/mutants.out.old/mutants.json
+++ /dev/null
@@ -1,212 +0,0 @@
-[
-  {
-    "package": "stackslib",
-    "file": "stackslib/src/net/chat.rs",
-    "function": {
-      "function_name": "ConversationP2P::supports_mempool_query",
-      "return_type": "-> bool",
-      "span": {
-        "start": {
-          "line": 669,
-          "column": 5
-        },
-        "end": {
-          "line": 675,
-          "column": 6
-        }
-      }
-    },
-    "span": {
-      "start": {
-        "line": 673,
-        "column": 58
-      },
-      "end": {
-        "line": 673,
-        "column": 59
-      }
-    },
-    "replacement": "&",
-    "genre": "BinaryOperator"
-  },
-  {
-    "package": "stackslib",
-    "file": "stackslib/src/net/chat.rs",
-    "function": {
-      "function_name": "ConversationP2P::supports_mempool_query",
-      "return_type": "-> bool",
-      "span": {
-        "start": {
-          "line": 669,
-          "column": 5
-        },
-        "end": {
-          "line": 675,
-          "column": 6
-        }
-      }
-    },
-    "span": {
-      "start": {
-        "line": 674,
-        "column": 24
-      },
-      "end": {
-        "line": 674,
-        "column": 25
-      }
-    },
-    "replacement": "^",
-    "genre": "BinaryOperator"
-  },
-  {
-    "package": "stackslib",
-    "file": "stackslib/src/net/chat.rs",
-    "function": {
-      "function_name": "ConversationP2P::supports_mempool_query",
-      "return_type": "-> bool",
-      "span": {
-        "start": {
-          "line": 669,
-          "column": 5
-        },
-        "end": {
-          "line": 675,
-          "column": 6
-        }
-      }
-    },
-    "span": {
-      "start": {
-        "line": 673,
-        "column": 9
-      },
-      "end": {
-        "line": 674,
-        "column": 57
-      }
-    },
-    "replacement": "false",
-    "genre": "FnValue"
-  },
-  {
-    "package": "stackslib",
-    "file": "stackslib/src/net/chat.rs",
-    "function": {
-      "function_name": "ConversationP2P::supports_mempool_query",
-      "return_type": "-> bool",
-      "span": {
-        "start": {
-          "line": 669,
-          "column": 5
-        },
-        "end": {
-          "line": 675,
-          "column": 6
-        }
-      }
-    },
-    "span": {
-      "start": {
-        "line": 673,
-        "column": 58
-      },
-      "end": {
-        "line": 673,
-        "column": 59
-      }
-    },
-    "replacement": "^",
-    "genre": "BinaryOperator"
-  },
-  {
-    "package": "stackslib",
-    "file": "stackslib/src/net/chat.rs",
-    "function": {
-      "function_name": "ConversationP2P::supports_mempool_query",
-      "return_type": "-> bool",
-      "span": {
-        "start": {
-          "line": 669,
-          "column": 5
-        },
-        "end": {
-          "line": 675,
-          "column": 6
-        }
-      }
-    },
-    "span": {
-      "start": {
-        "line": 674,
-        "column": 41
-      },
-      "end": {
-        "line": 674,
-        "column": 43
-      }
-    },
-    "replacement": "!=",
-    "genre": "BinaryOperator"
-  },
-  {
-    "package": "stackslib",
-    "file": "stackslib/src/net/chat.rs",
-    "function": {
-      "function_name": "ConversationP2P::supports_mempool_query",
-      "return_type": "-> bool",
-      "span": {
-        "start": {
-          "line": 669,
-          "column": 5
-        },
-        "end": {
-          "line": 675,
-          "column": 6
-        }
-      }
-    },
-    "span": {
-      "start": {
-        "line": 674,
-        "column": 24
-      },
-      "end": {
-        "line": 674,
-        "column": 25
-      }
-    },
-    "replacement": "|",
-    "genre": "BinaryOperator"
-  },
-  {
-    "package": "stackslib",
-    "file": "stackslib/src/net/chat.rs",
-    "function": {
-      "function_name": "ConversationP2P::supports_mempool_query",
-      "return_type": "-> bool",
-      "span": {
-        "start": {
-          "line": 669,
-          "column": 5
-        },
-        "end": {
-          "line": 675,
-          "column": 6
-        }
-      }
-    },
-    "span": {
-      "start": {
-        "line": 673,
-        "column": 9
-      },
-      "end": {
-        "line": 674,
-        "column": 57
-      }
-    },
-    "replacement": "true",
-    "genre": "FnValue"
-  }
-]
\ No newline at end of file
diff --git a/mutants.out.old/timeout.txt b/mutants.out.old/timeout.txt
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/mutants.out.old/unviable.txt b/mutants.out.old/unviable.txt
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/mutants.out/caught.txt b/mutants.out/caught.txt
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/mutants.out/lock.json b/mutants.out/lock.json
deleted file mode 100644
index 49e607ccff..0000000000
--- a/mutants.out/lock.json
+++ /dev/null
@@ -1,6 +0,0 @@
-{
-  "cargo_mutants_version": "24.2.0",
-  "start_time": "2024-02-15T16:19:43.980203Z",
-  "hostname": "alin-suciu-xy7ww74xhv.local",
-  "username": "asuciu"
-}
\ No newline at end of file
diff --git a/mutants.out/missed.txt b/mutants.out/missed.txt
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/mutants.out/mutants.json b/mutants.out/mutants.json
deleted file mode 100644
index 0637a088a0..0000000000
--- a/mutants.out/mutants.json
+++ /dev/null
@@ -1 +0,0 @@
-[]
\ No newline at end of file
diff --git a/mutants.out/timeout.txt b/mutants.out/timeout.txt
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/mutants.out/unviable.txt b/mutants.out/unviable.txt
deleted file mode 100644
index e69de29bb2..0000000000

From 4f7fa91ab815436532833a33f4030e99276f9820 Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Fri, 16 Feb 2024 11:26:56 -0500
Subject: [PATCH 0787/1166] refactor: update uses of `TestSigners`

---
 stackslib/src/chainstate/nakamoto/mod.rs      |   1 +
 .../src/chainstate/nakamoto/test_signers.rs   | 195 ++++++++++++++++++
 .../src/chainstate/nakamoto/tests/node.rs     | 134 +-----------
 .../chainstate/stacks/boot/signers_tests.rs   |   3 +-
 .../stacks/boot/signers_voting_tests.rs       |   7 +-
 stackslib/src/clarity_vm/clarity.rs           |  32 ---
 testnet/stacks-node/src/config.rs             |  15 +-
 testnet/stacks-node/src/mockamoto.rs          |   8 +-
 .../stacks-node/src/nakamoto_node/miner.rs    |   2 +-
 .../src/tests/nakamoto_integrations.rs        |   4 +-
 10 files changed, 218 insertions(+), 183 deletions(-)
 create mode 100644 stackslib/src/chainstate/nakamoto/test_signers.rs

diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index 8c6e5aedfd..b9b8827b06 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -102,6 +102,7 @@ pub mod miner;
 pub mod tenure;
 
 pub mod signer_set;
+pub mod test_signers;
 #[cfg(test)]
 pub mod tests;
 
diff --git a/stackslib/src/chainstate/nakamoto/test_signers.rs b/stackslib/src/chainstate/nakamoto/test_signers.rs
new file mode 100644
index 0000000000..02b38136d3
--- /dev/null
+++ b/stackslib/src/chainstate/nakamoto/test_signers.rs
@@ -0,0 +1,195 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020-2024 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+use std::cell::RefCell;
+use std::collections::{HashSet, VecDeque};
+use std::path::{Path, PathBuf};
+use std::{fs, io};
+
+use clarity::vm::clarity::ClarityConnection;
+use clarity::vm::costs::{ExecutionCost, LimitedCostTracker};
+use clarity::vm::types::*;
+use hashbrown::HashMap;
+use rand::seq::SliceRandom;
+use rand::{CryptoRng, RngCore, SeedableRng};
+use rand_chacha::ChaCha20Rng;
+use stacks_common::address::*;
+use stacks_common::consts::{FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH};
+use stacks_common::types::chainstate::{BlockHeaderHash, SortitionId, StacksBlockId, VRFSeed};
+use stacks_common::util::hash::Hash160;
+use stacks_common::util::sleep_ms;
+use stacks_common::util::vrf::{VRFProof, VRFPublicKey};
+use wsts::curve::point::Point;
+use wsts::traits::Aggregator;
+
+use crate::burnchains::bitcoin::indexer::BitcoinIndexer;
+use crate::burnchains::*;
+use crate::chainstate::burn::db::sortdb::*;
+use crate::chainstate::burn::operations::{
+    BlockstackOperationType, LeaderBlockCommitOp, LeaderKeyRegisterOp, UserBurnSupportOp,
+};
+use crate::chainstate::burn::*;
+use crate::chainstate::coordinator::{
+    ChainsCoordinator, Error as CoordinatorError, OnChainRewardSetProvider,
+};
+use crate::chainstate::nakamoto::coordinator::get_nakamoto_next_recipients;
+use crate::chainstate::nakamoto::miner::NakamotoBlockBuilder;
+use crate::chainstate::nakamoto::{NakamotoBlock, NakamotoBlockHeader, NakamotoChainState};
+use crate::chainstate::stacks::address::PoxAddress;
+use crate::chainstate::stacks::db::*;
+use crate::chainstate::stacks::miner::*;
+use crate::chainstate::stacks::{
+    Error as ChainstateError, StacksBlock, C32_ADDRESS_VERSION_TESTNET_SINGLESIG, *,
+};
+use crate::core::{BOOT_BLOCK_HASH, STACKS_EPOCH_3_0_MARKER};
+use crate::cost_estimates::metrics::UnitMetric;
+use crate::cost_estimates::UnitEstimator;
+use crate::net::relay::Relayer;
+use crate::util_lib::boot::boot_code_addr;
+use crate::util_lib::db::Error as db_error;
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct TestSigners {
+    /// The parties that will sign the blocks
+    pub signer_parties: Vec<wsts::v2::Party>,
+    /// The commitments to the polynomials for the aggregate public key
+    pub poly_commitments: HashMap<u32, wsts::common::PolyCommitment>,
+    /// The aggregate public key
+    pub aggregate_public_key: Point,
+    /// The total number of key ids distributed among signer_parties
+    pub num_keys: u32,
+    /// The number of vote shares required to sign a block
+    pub threshold: u32,
+    /// The key ids distributed among signer_parties
+    pub party_key_ids: Vec<Vec<u32>>,
+    /// The cycle for which the signers are valid
+    pub cycle: u64,
+}
+
+impl Default for TestSigners {
+    fn default() -> Self {
+        let mut rng = rand_core::OsRng::default();
+        let num_keys = 10;
+        let threshold = 7;
+        let party_key_ids: Vec<Vec<u32>> =
+            vec![vec![1, 2, 3], vec![4, 5], vec![6, 7, 8], vec![9, 10]];
+        let num_parties = party_key_ids.len().try_into().unwrap();
+
+        // Create the parties
+        let mut signer_parties: Vec<wsts::v2::Party> = party_key_ids
+            .iter()
+            .enumerate()
+            .map(|(pid, pkids)| {
+                wsts::v2::Party::new(
+                    pid.try_into().unwrap(),
+                    pkids,
+                    num_parties,
+                    num_keys,
+                    threshold,
+                    &mut rng,
+                )
+            })
+            .collect();
+
+        // Generate an aggregate public key
+        let poly_commitments = match wsts::v2::test_helpers::dkg(&mut signer_parties, &mut rng) {
+            Ok(poly_commitments) => poly_commitments,
+            Err(secret_errors) => {
+                panic!("Got secret errors from DKG: {:?}", secret_errors);
+            }
+        };
+        let mut sig_aggregator = wsts::v2::Aggregator::new(num_keys, threshold);
+        sig_aggregator
+            .init(&poly_commitments)
+            .expect("aggregator init failed");
+        let aggregate_public_key = sig_aggregator.poly[0];
+        Self {
+            signer_parties,
+            aggregate_public_key,
+            poly_commitments,
+            num_keys,
+            threshold,
+            party_key_ids,
+            cycle: 0,
+        }
+    }
+}
+
+impl TestSigners {
+    pub fn sign_nakamoto_block(&mut self, block: &mut NakamotoBlock, cycle: u64) {
+        // Update the aggregate public key if the cycle has changed
+        if self.cycle != cycle {
+            self.generate_aggregate_key(cycle);
+        }
+
+        let mut rng = rand_core::OsRng;
+        let msg = block.header.signer_signature_hash().0;
+        let (nonces, sig_shares, key_ids) =
+            wsts::v2::test_helpers::sign(msg.as_slice(), &mut self.signer_parties, &mut rng);
+
+        let mut sig_aggregator = wsts::v2::Aggregator::new(self.num_keys, self.threshold);
+        sig_aggregator
+            .init(&self.poly_commitments)
+            .expect("aggregator init failed");
+        let signature = sig_aggregator
+            .sign(msg.as_slice(), &nonces, &sig_shares, &key_ids)
+            .expect("aggregator sig failed");
+        block.header.signer_signature = ThresholdSignature(signature);
+    }
+
+    // Generate and assign a new aggregate public key
+    pub fn generate_aggregate_key(&mut self, cycle: u64) -> Point {
+        // If the key is already generated for this cycle, return it
+        if cycle == self.cycle {
+            debug!("Returning cached aggregate key for cycle {}", cycle);
+            return self.aggregate_public_key.clone();
+        }
+
+        debug!("Generating aggregate key for cycle {}", cycle);
+        let mut rng = ChaCha20Rng::seed_from_u64(cycle);
+        let num_parties = self.party_key_ids.len().try_into().unwrap();
+        // Create the parties
+        self.signer_parties = self
+            .party_key_ids
+            .iter()
+            .enumerate()
+            .map(|(pid, pkids)| {
+                wsts::v2::Party::new(
+                    pid.try_into().unwrap(),
+                    pkids,
+                    num_parties,
+                    self.num_keys,
+                    self.threshold,
+                    &mut rng,
+                )
+            })
+            .collect();
+        self.poly_commitments =
+            match wsts::v2::test_helpers::dkg(&mut self.signer_parties, &mut rng) {
+                Ok(poly_commitments) => poly_commitments,
+                Err(secret_errors) => {
+                    panic!("Got secret errors from DKG: {:?}", secret_errors);
+                }
+            };
+        let mut sig_aggregator = wsts::v2::Aggregator::new(self.num_keys, self.threshold);
+        sig_aggregator
+            .init(&self.poly_commitments)
+            .expect("aggregator init failed");
+        self.aggregate_public_key = sig_aggregator.poly[0];
+        self.cycle = cycle;
+        self.aggregate_public_key.clone()
+    }
+}
diff --git a/stackslib/src/chainstate/nakamoto/tests/node.rs b/stackslib/src/chainstate/nakamoto/tests/node.rs
index 7c82f4e358..8f658393d3 100644
--- a/stackslib/src/chainstate/nakamoto/tests/node.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/node.rs
@@ -48,6 +48,7 @@ use crate::chainstate::coordinator::{
 };
 use crate::chainstate::nakamoto::coordinator::get_nakamoto_next_recipients;
 use crate::chainstate::nakamoto::miner::NakamotoBlockBuilder;
+use crate::chainstate::nakamoto::test_signers::TestSigners;
 use crate::chainstate::nakamoto::tests::get_account;
 use crate::chainstate::nakamoto::{NakamotoBlock, NakamotoBlockHeader, NakamotoChainState};
 use crate::chainstate::stacks::address::PoxAddress;
@@ -108,139 +109,6 @@ impl TestStacker {
     }
 }
 
-#[derive(Debug, Clone)]
-pub struct TestSigners {
-    /// The parties that will sign the blocks
-    pub signer_parties: Vec<wsts::v2::Party>,
-    /// The commitments to the polynomials for the aggregate public key
-    pub poly_commitments: HashMap<u32, wsts::common::PolyCommitment>,
-    /// The aggregate public key
-    pub aggregate_public_key: Point,
-    /// The total number of key ids distributed among signer_parties
-    pub num_keys: u32,
-    /// The number of vote shares required to sign a block
-    pub threshold: u32,
-    /// The key ids distributed among signer_parties
-    pub party_key_ids: Vec<Vec<u32>>,
-    /// The cycle for which the signers are valid
-    pub cycle: u64,
-}
-
-impl Default for TestSigners {
-    fn default() -> Self {
-        let mut rng = rand_core::OsRng::default();
-        let num_keys = 10;
-        let threshold = 7;
-        let party_key_ids: Vec<Vec<u32>> =
-            vec![vec![1, 2, 3], vec![4, 5], vec![6, 7, 8], vec![9, 10]];
-        let num_parties = party_key_ids.len().try_into().unwrap();
-
-        // Create the parties
-        let mut signer_parties: Vec<wsts::v2::Party> = party_key_ids
-            .iter()
-            .enumerate()
-            .map(|(pid, pkids)| {
-                wsts::v2::Party::new(
-                    pid.try_into().unwrap(),
-                    pkids,
-                    num_parties,
-                    num_keys,
-                    threshold,
-                    &mut rng,
-                )
-            })
-            .collect();
-
-        // Generate an aggregate public key
-        let poly_commitments = match wsts::v2::test_helpers::dkg(&mut signer_parties, &mut rng) {
-            Ok(poly_commitments) => poly_commitments,
-            Err(secret_errors) => {
-                panic!("Got secret errors from DKG: {:?}", secret_errors);
-            }
-        };
-        let mut sig_aggregator = wsts::v2::Aggregator::new(num_keys, threshold);
-        sig_aggregator
-            .init(&poly_commitments)
-            .expect("aggregator init failed");
-        let aggregate_public_key = sig_aggregator.poly[0];
-        Self {
-            signer_parties,
-            aggregate_public_key,
-            poly_commitments,
-            num_keys,
-            threshold,
-            party_key_ids,
-            cycle: 0,
-        }
-    }
-}
-
-impl TestSigners {
-    pub fn sign_nakamoto_block(&mut self, block: &mut NakamotoBlock, cycle: u64) {
-        // Update the aggregate public key if the cycle has changed
-        if self.cycle != cycle {
-            self.generate_aggregate_key(cycle);
-        }
-
-        let mut rng = rand_core::OsRng;
-        let msg = block.header.signer_signature_hash().0;
-        let (nonces, sig_shares, key_ids) =
-            wsts::v2::test_helpers::sign(msg.as_slice(), &mut self.signer_parties, &mut rng);
-
-        let mut sig_aggregator = wsts::v2::Aggregator::new(self.num_keys, self.threshold);
-        sig_aggregator
-            .init(&self.poly_commitments)
-            .expect("aggregator init failed");
-        let signature = sig_aggregator
-            .sign(msg.as_slice(), &nonces, &sig_shares, &key_ids)
-            .expect("aggregator sig failed");
-        block.header.signer_signature = ThresholdSignature(signature);
-    }
-
-    // Generate and assign a new aggregate public key
-    pub fn generate_aggregate_key(&mut self, cycle: u64) -> Point {
-        // If the key is already generated for this cycle, return it
-        if cycle == self.cycle {
-            debug!("Returning cached aggregate key for cycle {}", cycle);
-            return self.aggregate_public_key.clone();
-        }
-
-        debug!("Generating aggregate key for cycle {}", cycle);
-        let mut rng = ChaCha20Rng::seed_from_u64(cycle);
-        let num_parties = self.party_key_ids.len().try_into().unwrap();
-        // Create the parties
-        self.signer_parties = self
-            .party_key_ids
-            .iter()
-            .enumerate()
-            .map(|(pid, pkids)| {
-                wsts::v2::Party::new(
-                    pid.try_into().unwrap(),
-                    pkids,
-                    num_parties,
-                    self.num_keys,
-                    self.threshold,
-                    &mut rng,
-                )
-            })
-            .collect();
-        self.poly_commitments =
-            match wsts::v2::test_helpers::dkg(&mut self.signer_parties, &mut rng) {
-                Ok(poly_commitments) => poly_commitments,
-                Err(secret_errors) => {
-                    panic!("Got secret errors from DKG: {:?}", secret_errors);
-                }
-            };
-        let mut sig_aggregator = wsts::v2::Aggregator::new(self.num_keys, self.threshold);
-        sig_aggregator
-            .init(&self.poly_commitments)
-            .expect("aggregator init failed");
-        self.aggregate_public_key = sig_aggregator.poly[0];
-        self.cycle = cycle;
-        self.aggregate_public_key.clone()
-    }
-}
-
 impl TestBurnchainBlock {
     pub fn add_nakamoto_tenure_commit(
         &mut self,
diff --git a/stackslib/src/chainstate/stacks/boot/signers_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_tests.rs
index 6a567e52c4..01948c4922 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_tests.rs
@@ -37,8 +37,9 @@ use crate::burnchains::Burnchain;
 use crate::chainstate::burn::db::sortdb::SortitionDB;
 use crate::chainstate::burn::BlockSnapshot;
 use crate::chainstate::nakamoto::coordinator::tests::{boot_nakamoto, make_token_transfer};
+use crate::chainstate::nakamoto::test_signers::TestSigners;
 use crate::chainstate::nakamoto::tests::get_account;
-use crate::chainstate::nakamoto::tests::node::{TestSigners, TestStacker};
+use crate::chainstate::nakamoto::tests::node::TestStacker;
 use crate::chainstate::stacks::address::PoxAddress;
 use crate::chainstate::stacks::boot::pox_2_tests::with_clarity_db_ro;
 use crate::chainstate::stacks::boot::pox_4_tests::{
diff --git a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
index d84d5157af..3dc4771d04 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
@@ -52,8 +52,9 @@ use crate::chainstate::burn::db::sortdb::{self, SortitionDB};
 use crate::chainstate::burn::operations::*;
 use crate::chainstate::burn::{BlockSnapshot, ConsensusHash};
 use crate::chainstate::nakamoto::coordinator::tests::make_token_transfer;
+use crate::chainstate::nakamoto::test_signers::TestSigners;
 use crate::chainstate::nakamoto::tests::get_account;
-use crate::chainstate::nakamoto::tests::node::{TestSigners, TestStacker};
+use crate::chainstate::nakamoto::tests::node::TestStacker;
 use crate::chainstate::nakamoto::NakamotoBlock;
 use crate::chainstate::stacks::address::{PoxAddress, PoxAddressType20, PoxAddressType32};
 use crate::chainstate::stacks::boot::pox_2_tests::{
@@ -210,7 +211,7 @@ fn vote_for_aggregate_public_key_success() {
     // ignore tenure change tx
     // ignore tenure coinbase tx
 
-    // first vote should succeed
+    // Alice's vote should succeed
     let alice_vote_tx = &receipts[2];
     assert_eq!(alice_vote_tx.result, Value::okay_true());
     assert_eq!(alice_vote_tx.events.len(), 1);
@@ -237,7 +238,7 @@ fn vote_for_aggregate_public_key_success() {
         panic!("Expected SmartContractEvent, got {:?}", alice_vote_event);
     }
 
-    // second vote should fail with duplicate vote error
+    // Bob's vote should succeed
     let bob_vote_tx = &receipts[3];
     assert_eq!(bob_vote_tx.result, Value::okay_true());
     assert_eq!(bob_vote_tx.events.len(), 2);
diff --git a/stackslib/src/clarity_vm/clarity.rs b/stackslib/src/clarity_vm/clarity.rs
index 0465bf9a15..4a14f075da 100644
--- a/stackslib/src/clarity_vm/clarity.rs
+++ b/stackslib/src/clarity_vm/clarity.rs
@@ -1331,38 +1331,6 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
             let pox_4_contract_tx =
                 StacksTransaction::new(tx_version.clone(), boot_code_auth.clone(), payload);
 
-            let initialized_agg_key = if !mainnet {
-                let agg_key_value_opt = self
-                    .with_readonly_clarity_env(
-                        false,
-                        self.chain_id,
-                        ClarityVersion::Clarity2,
-                        StacksAddress::burn_address(false).into(),
-                        None,
-                        LimitedCostTracker::Free,
-                        |vm_env| {
-                            vm_env.execute_contract_allow_private(
-                                &boot_code_id(BOOT_TEST_POX_4_AGG_KEY_CONTRACT, false),
-                                BOOT_TEST_POX_4_AGG_KEY_FNAME,
-                                &[],
-                                true,
-                            )
-                        },
-                    )
-                    .map(|agg_key_value| {
-                        Ok::<_, InterpreterError>(
-                            Value::buff_from(agg_key_value.expect_buff(33)?)
-                                .expect("failed to reconstruct buffer"),
-                        )
-                    })
-                    .ok()
-                    .transpose()
-                    .expect("FATAL: failed to load aggregate public key");
-                agg_key_value_opt
-            } else {
-                None
-            };
-
             let pox_4_initialization_receipt = self.as_transaction(|tx_conn| {
                 // initialize with a synthetic transaction
                 debug!("Instantiate {} contract", &pox_4_contract_id);
diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index b5699a4e40..049e0622ec 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -13,7 +13,7 @@ use rand::RngCore;
 use stacks::burnchains::bitcoin::BitcoinNetworkType;
 use stacks::burnchains::{Burnchain, MagicBytes, BLOCKSTACK_MAGIC_MAINNET};
 use stacks::chainstate::nakamoto::signer_set::NakamotoSigners;
-use stacks::chainstate::nakamoto::tests::node::TestSigners;
+use stacks::chainstate::nakamoto::test_signers::TestSigners;
 use stacks::chainstate::stacks::boot::MINERS_NAME;
 use stacks::chainstate::stacks::index::marf::MARFOpenOpts;
 use stacks::chainstate::stacks::index::storage::TrieHashCalculationMode;
@@ -506,6 +506,7 @@ lazy_static! {
 }
 
 impl Config {
+    #[cfg(any(test, feature = "testing"))]
     pub fn self_signing(&self) -> Option<TestSigners> {
         if !(self.burnchain.mode == "nakamoto-neon" || self.burnchain.mode == "mockamoto") {
             return None;
@@ -513,6 +514,11 @@ impl Config {
         self.miner.self_signing_key.clone()
     }
 
+    #[cfg(not(any(test, feature = "testing")))]
+    pub fn self_signing(&self) -> Option<TestSigners> {
+        return None;
+    }
+
     /// get the up-to-date burnchain options from the config.
     /// If the config file can't be loaded, then return the existing config
     pub fn get_burnchain_config(&self) -> BurnchainConfig {
@@ -2363,7 +2369,6 @@ pub struct MinerConfigFile {
     pub candidate_retry_cache_size: Option<u64>,
     pub unprocessed_block_deadline_secs: Option<u64>,
     pub mining_key: Option<String>,
-    pub self_signing_seed: Option<u64>,
     pub wait_on_interim_blocks_ms: Option<u64>,
     pub min_tx_count: Option<u64>,
     pub only_increase_tx_count: Option<bool>,
@@ -2419,11 +2424,7 @@ impl MinerConfigFile {
                 .as_ref()
                 .map(|x| Secp256k1PrivateKey::from_hex(x))
                 .transpose()?,
-            self_signing_key: self
-                .self_signing_seed
-                .as_ref()
-                .map(|x| TestSigners::from_seed(*x))
-                .or(miner_default_config.self_signing_key),
+            self_signing_key: Some(TestSigners::default()),
             wait_on_interim_blocks: self
                 .wait_on_interim_blocks_ms
                 .map(Duration::from_millis)
diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index aecc8c3724..40228c9776 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -44,7 +44,7 @@ use stacks::chainstate::coordinator::comm::CoordinatorReceivers;
 use stacks::chainstate::coordinator::{
     ChainsCoordinator, ChainsCoordinatorConfig, CoordinatorCommunication,
 };
-use stacks::chainstate::nakamoto::tests::node::TestSigners;
+use stacks::chainstate::nakamoto::test_signers::TestSigners;
 use stacks::chainstate::nakamoto::{
     NakamotoBlock, NakamotoBlockHeader, NakamotoChainState, SetupBlockResult,
 };
@@ -94,7 +94,6 @@ use crate::neon_node::{PeerThread, StacksNode, BLOCK_PROCESSOR_STACK_SIZE};
 use crate::syncctl::PoxSyncWatchdogComms;
 use crate::{Config, EventDispatcher};
 
-pub mod signer;
 #[cfg(test)]
 mod tests;
 
@@ -424,7 +423,7 @@ impl MockamotoNode {
         initial_balances.push((stacker.into(), 100_000_000_000_000));
 
         // Create a boot contract to initialize the aggregate public key prior to Pox-4 activation
-        let self_signer = TestSigners::single_signer();
+        let self_signer = TestSigners::default();
         let agg_pub_key = self_signer.aggregate_public_key.clone();
         info!("Mockamoto node setting agg public key"; "agg_pub_key" => %to_hex(&self_signer.aggregate_public_key.compress().data));
         let callback = move |clarity_tx: &mut ClarityTx| {
@@ -1034,7 +1033,6 @@ impl MockamotoNode {
             .block_height_to_reward_cycle(self.sortdb.first_block_height, burn_tip.block_height)
             .unwrap();
         self.self_signer.sign_nakamoto_block(&mut block, cycle);
-        let staging_tx = self.chainstate.staging_db_tx_begin()?;
 
         let aggregate_public_key = if chain_length <= 1 {
             self.self_signer.aggregate_public_key
@@ -1047,6 +1045,8 @@ impl MockamotoNode {
             )?;
             aggregate_public_key
         };
+        let staging_tx = self.chainstate.staging_db_tx_begin()?;
+
         NakamotoChainState::accept_block(
             &config,
             block,
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index bac073e953..be8188b75c 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -29,7 +29,7 @@ use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::burn::{BlockSnapshot, ConsensusHash};
 use stacks::chainstate::nakamoto::miner::{NakamotoBlockBuilder, NakamotoTenureInfo};
 use stacks::chainstate::nakamoto::signer_set::NakamotoSigners;
-use stacks::chainstate::nakamoto::tests::node::TestSigners;
+use stacks::chainstate::nakamoto::test_signers::TestSigners;
 use stacks::chainstate::nakamoto::{NakamotoBlock, NakamotoChainState};
 use stacks::chainstate::stacks::boot::MINERS_NAME;
 use stacks::chainstate::stacks::db::{StacksChainState, StacksHeaderInfo};
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index cd8145afa5..42f2d70e92 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -27,7 +27,7 @@ use stacks::burnchains::MagicBytes;
 use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::coordinator::comm::CoordinatorChannels;
 use stacks::chainstate::nakamoto::miner::NakamotoBlockBuilder;
-use stacks::chainstate::nakamoto::tests::node::TestSigners;
+use stacks::chainstate::nakamoto::test_signers::TestSigners;
 use stacks::chainstate::nakamoto::{NakamotoBlock, NakamotoChainState};
 use stacks::chainstate::stacks::address::PoxAddress;
 use stacks::chainstate::stacks::boot::MINERS_NAME;
@@ -189,7 +189,7 @@ pub fn naka_neon_integration_conf(seed: Option<&[u8]>) -> (Config, StacksAddress
 
     let mining_key = Secp256k1PrivateKey::from_seed(&[1]);
     conf.miner.mining_key = Some(mining_key);
-    conf.miner.self_signing_key = Some(TestSigners::from_seed(7));
+    conf.miner.self_signing_key = Some(TestSigners::default());
 
     conf.node.miner = true;
     conf.node.wait_time_for_microblocks = 500;

From 82df1f2f9084f70b7ae0c2e71fd08efef64c79f9 Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Fri, 16 Feb 2024 12:42:59 -0500
Subject: [PATCH 0788/1166] fix: fix TestSigners imports

---
 stackslib/src/chainstate/nakamoto/coordinator/tests.rs | 3 ++-
 stackslib/src/chainstate/nakamoto/tests/mod.rs         | 3 ++-
 stackslib/src/net/mod.rs                               | 3 ++-
 stackslib/src/net/tests/mod.rs                         | 3 ++-
 4 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index d343697843..d543947374 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -34,8 +34,9 @@ use wsts::curve::point::Point;
 use crate::chainstate::burn::db::sortdb::{SortitionDB, SortitionHandle};
 use crate::chainstate::burn::operations::BlockstackOperationType;
 use crate::chainstate::coordinator::tests::{p2pkh_from, pox_addr_from};
+use crate::chainstate::nakamoto::test_signers::TestSigners;
 use crate::chainstate::nakamoto::tests::get_account;
-use crate::chainstate::nakamoto::tests::node::{TestSigners, TestStacker};
+use crate::chainstate::nakamoto::tests::node::TestStacker;
 use crate::chainstate::nakamoto::{NakamotoBlock, NakamotoChainState};
 use crate::chainstate::stacks::address::PoxAddress;
 use crate::chainstate::stacks::boot::signers_tests::{readonly_call, readonly_call_with_sortdb};
diff --git a/stackslib/src/chainstate/nakamoto/tests/mod.rs b/stackslib/src/chainstate/nakamoto/tests/mod.rs
index a2cdf1213d..6634f21572 100644
--- a/stackslib/src/chainstate/nakamoto/tests/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/mod.rs
@@ -52,7 +52,8 @@ use crate::chainstate::coordinator::tests::{
 use crate::chainstate::nakamoto::coordinator::tests::boot_nakamoto;
 use crate::chainstate::nakamoto::miner::NakamotoBlockBuilder;
 use crate::chainstate::nakamoto::tenure::NakamotoTenure;
-use crate::chainstate::nakamoto::tests::node::{TestSigners, TestStacker};
+use crate::chainstate::nakamoto::test_signers::TestSigners;
+use crate::chainstate::nakamoto::tests::node::TestStacker;
 use crate::chainstate::nakamoto::{
     NakamotoBlock, NakamotoBlockHeader, NakamotoChainState, FIRST_STACKS_BLOCK_ID,
 };
diff --git a/stackslib/src/net/mod.rs b/stackslib/src/net/mod.rs
index ac1e1996f8..862a4d628d 100644
--- a/stackslib/src/net/mod.rs
+++ b/stackslib/src/net/mod.rs
@@ -1621,6 +1621,7 @@ pub mod test {
     use wsts::curve::point::Point;
     use {mio, rand};
 
+    use self::nakamoto::test_signers::TestSigners;
     use super::*;
     use crate::burnchains::bitcoin::address::*;
     use crate::burnchains::bitcoin::indexer::BitcoinIndexer;
@@ -1637,7 +1638,7 @@ pub mod test {
     use crate::chainstate::burn::*;
     use crate::chainstate::coordinator::tests::*;
     use crate::chainstate::coordinator::*;
-    use crate::chainstate::nakamoto::tests::node::{TestSigners, TestStacker};
+    use crate::chainstate::nakamoto::tests::node::TestStacker;
     use crate::chainstate::stacks::address::PoxAddress;
     use crate::chainstate::stacks::boot::test::get_parent_tip;
     use crate::chainstate::stacks::boot::*;
diff --git a/stackslib/src/net/tests/mod.rs b/stackslib/src/net/tests/mod.rs
index 6d3478bf66..521f26ff2c 100644
--- a/stackslib/src/net/tests/mod.rs
+++ b/stackslib/src/net/tests/mod.rs
@@ -36,8 +36,9 @@ use crate::chainstate::burn::db::sortdb::{SortitionDB, SortitionHandle};
 use crate::chainstate::burn::operations::BlockstackOperationType;
 use crate::chainstate::coordinator::tests::p2pkh_from;
 use crate::chainstate::nakamoto::coordinator::tests::boot_nakamoto;
+use crate::chainstate::nakamoto::test_signers::TestSigners;
 use crate::chainstate::nakamoto::tests::get_account;
-use crate::chainstate::nakamoto::tests::node::{TestSigners, TestStacker};
+use crate::chainstate::nakamoto::tests::node::TestStacker;
 use crate::chainstate::nakamoto::{NakamotoBlock, NakamotoChainState};
 use crate::chainstate::stacks::address::PoxAddress;
 use crate::chainstate::stacks::boot::test::{

From 4e0180e44d80bb02c65fe7d5ee1f728cbafa2581 Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Fri, 16 Feb 2024 13:12:34 -0500
Subject: [PATCH 0789/1166] fix: allow duplicate keys in different voting round
 for the same cycle

---
 .../src/chainstate/stacks/boot/signers-voting.clar   | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers-voting.clar b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
index 962e8e1abf..fbe1053c2d 100644
--- a/stackslib/src/chainstate/stacks/boot/signers-voting.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
@@ -6,8 +6,8 @@
 (define-map votes {reward-cycle: uint, round: uint, signer: principal} {aggregate-public-key: (buff 33), signer-weight: uint})
 ;; maps dkg round and aggregate public key to weights of signers supporting this key so far
 (define-map tally {reward-cycle: uint, round: uint, aggregate-public-key: (buff 33)} uint)
-;; maps aggregate public keys to rewards cycles and rounds
-(define-map used-aggregate-public-keys (buff 33) {reward-cycle: uint, round: uint})
+;; maps aggregate public keys to rewards cycles
+(define-map used-aggregate-public-keys (buff 33) uint)
 
 (define-constant ERR_SIGNER_INDEX_MISMATCH u1)
 (define-constant ERR_INVALID_SIGNER_INDEX u2)
@@ -67,8 +67,8 @@
         (ok (get weight details))))
 
 ;; aggregate public key must be unique and can be used only in a single cycle-round pair
-(define-read-only (is-valid-aggregate-public-key (key (buff 33)) (dkg-id {reward-cycle: uint, round: uint}))
-    (is-eq (default-to dkg-id (map-get? used-aggregate-public-keys key)) dkg-id))
+(define-read-only (is-valid-aggregate-public-key (key (buff 33)) (reward-cycle uint))
+    (is-eq (default-to reward-cycle (map-get? used-aggregate-public-keys key)) reward-cycle))
 
 (define-read-only (is-in-prepare-phase (height uint))
     (< (mod (+ (- height (get first-burnchain-block-height pox-info))
@@ -113,13 +113,13 @@
         ;; Check that the aggregate public key is correct length
         (asserts! (is-eq (len key) u33) (err ERR_ILL_FORMED_AGGREGATE_PUBLIC_KEY))
         ;; Check that aggregate public key has not been used before
-        (asserts! (is-valid-aggregate-public-key key {reward-cycle: reward-cycle, round: round}) (err ERR_DUPLICATE_AGGREGATE_PUBLIC_KEY))
+        (asserts! (is-valid-aggregate-public-key key reward-cycle) (err ERR_DUPLICATE_AGGREGATE_PUBLIC_KEY))
         ;; Check that signer hasn't voted in reward-cycle & round
         (asserts! (map-insert votes {reward-cycle: reward-cycle, round: round, signer: tx-sender} {aggregate-public-key: key, signer-weight: signer-weight}) (err ERR_DUPLICATE_VOTE))
         ;; Update tally aggregate public key candidate
         (map-set tally tally-key new-total)
         ;; Update used aggregate public keys
-        (map-set used-aggregate-public-keys key {reward-cycle: reward-cycle, round: round})
+        (map-set used-aggregate-public-keys key reward-cycle)
         (update-last-round reward-cycle round)
         (print {
             event: "voted",

From 175d37e068087fc06abc8b522bfff43f03531b27 Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Fri, 16 Feb 2024 13:13:39 -0500
Subject: [PATCH 0790/1166] fix: fix signers-voting tests

---
 .../chainstate/stacks/boot/signers_voting_tests.rs | 14 ++++----------
 1 file changed, 4 insertions(+), 10 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
index 3dc4771d04..06bd275769 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
@@ -364,8 +364,7 @@ fn vote_for_aggregate_public_key_in_first_block() {
 
 /// In this test case, Alice votes in the first block of the last tenure of the prepare phase.
 /// Bob votes in the second block of that tenure.
-/// Alice can vote successfully.
-/// Bob is out of the voting window.
+/// Both can vote successfully.
 #[test]
 fn vote_for_aggregate_public_key_in_last_block() {
     let stacker_1 = TestStacker::from_seed(&[3, 4]);
@@ -465,8 +464,6 @@ fn vote_for_aggregate_public_key_in_last_block() {
 
     nakamoto_tenure(&mut peer, &mut test_signers, vec![vec![dummy_tx_1]]);
 
-    nakamoto_tenure(&mut peer, &mut test_signers, vec![vec![dummy_tx_2]]);
-
     // alice votes in first block of tenure
     // bob votes in second block of tenure
     let blocks_and_sizes =
@@ -474,6 +471,7 @@ fn vote_for_aggregate_public_key_in_last_block() {
 
     // check alice's and bob's txs
     let blocks = observer.get_blocks();
+
     // alice's block
     let block = &blocks[blocks.len() - 2].clone();
     let receipts = &block.receipts;
@@ -499,13 +497,9 @@ fn vote_for_aggregate_public_key_in_last_block() {
     let receipts = block.receipts.as_slice();
     assert_eq!(receipts.len(), 1);
 
-    // vote fails because the reward cycle has changed
-    //  and the signer set hasn't been set yet.
+    // bob's vote should succeed
     let tx1_bob = &receipts[0];
-    assert_eq!(
-        tx1_bob.result,
-        Value::err_uint(2) // err-out-of-voting-window
-    );
+    assert_eq!(tx1_bob.result, Value::okay_true());
 }
 
 fn nakamoto_tenure(

From e4c1e9cfe0a027a05c5b290e82cf21de9ac72427 Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Fri, 16 Feb 2024 13:44:05 -0500
Subject: [PATCH 0791/1166] chore: switch back to using weight instead of
 amount stacked

Also renamed some things from `slot` to `weight` to avoid confusion
between reward slots and stacker DB slots.
---
 stackslib/src/chainstate/nakamoto/signer_set.rs           | 2 +-
 stackslib/src/chainstate/stacks/boot/mod.rs               | 8 ++++----
 stackslib/src/chainstate/stacks/boot/signers_tests.rs     | 6 +++---
 .../src/chainstate/stacks/boot/signers_voting_tests.rs    | 4 ++--
 4 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/signer_set.rs b/stackslib/src/chainstate/nakamoto/signer_set.rs
index 3d6de9e902..7dc5085683 100644
--- a/stackslib/src/chainstate/nakamoto/signer_set.rs
+++ b/stackslib/src/chainstate/nakamoto/signer_set.rs
@@ -274,7 +274,7 @@ impl NakamotoSigners {
                                 "signer".into(),
                                 Value::Principal(PrincipalData::from(signing_address)),
                             ),
-                            ("weight".into(), Value::UInt(signer.stacked_amt.into())),
+                            ("weight".into(), Value::UInt(signer.weight.into())),
                         ])
                         .expect(
                             "BUG: Failed to construct `{ signer: principal, weight: uint }` tuple",
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 03ec944764..52fd8e3236 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -220,7 +220,7 @@ pub struct NakamotoSignerEntry {
     #[serde(serialize_with = "hex_serialize", deserialize_with = "hex_deserialize")]
     pub signing_key: [u8; 33],
     pub stacked_amt: u128,
-    pub slots: u32,
+    pub weight: u32,
 }
 
 #[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
@@ -708,15 +708,15 @@ impl StacksChainState {
         let mut signer_set: Vec<_> = signer_set
             .into_iter()
             .filter_map(|(signing_key, stacked_amt)| {
-                let slots = u32::try_from(stacked_amt / threshold)
+                let weight = u32::try_from(stacked_amt / threshold)
                     .expect("CORRUPTION: Stacker claimed > u32::max() reward slots");
-                if slots == 0 {
+                if weight == 0 {
                     return None;
                 }
                 Some(NakamotoSignerEntry {
                     signing_key,
                     stacked_amt,
-                    slots,
+                    weight,
                 })
             })
             .collect();
diff --git a/stackslib/src/chainstate/stacks/boot/signers_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_tests.rs
index 01948c4922..a97a0c1e09 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_tests.rs
@@ -76,13 +76,13 @@ fn make_signer_units() {
             amount_stacked: amount,
         }
     }
-    fn stub_out(signer: u64, amount: u128, slots: u32) -> NakamotoSignerEntry {
+    fn stub_out(signer: u64, amount: u128, weight: u32) -> NakamotoSignerEntry {
         let mut signer_bytes = [0; SIGNERS_PK_LEN];
         signer_bytes[0..8].copy_from_slice(&signer.to_be_bytes());
         NakamotoSignerEntry {
             signing_key: signer_bytes,
             stacked_amt: amount,
-            slots,
+            weight,
         }
     }
 
@@ -93,7 +93,7 @@ fn make_signer_units() {
             .collect();
         let expected: Vec<_> = expected
             .iter()
-            .map(|(signer, amount, slots)| stub_out(*signer, *amount, *slots))
+            .map(|(signer, amount, weight)| stub_out(*signer, *amount, *weight))
             .collect();
         assert_eq!(
             StacksChainState::make_signer_set(threshold, &in_entries),
diff --git a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
index 06bd275769..a8553e99fc 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
@@ -226,7 +226,7 @@ fn vote_for_aggregate_public_key_success() {
                         .expect("Failed to create string")
                 ),
                 ("key".into(), aggregate_public_key_value.clone()),
-                ("new-total".into(), Value::UInt(1000000000000000000)),
+                ("new-total".into(), Value::UInt(2)),
                 ("reward-cycle".into(), Value::UInt(cycle_id + 1)),
                 ("round".into(), Value::UInt(0)),
                 ("signer".into(), Value::Principal(alice_principal.clone())),
@@ -253,7 +253,7 @@ fn vote_for_aggregate_public_key_success() {
                         .expect("Failed to create string")
                 ),
                 ("key".into(), aggregate_public_key_value.clone()),
-                ("new-total".into(), Value::UInt(2000000000000000000)),
+                ("new-total".into(), Value::UInt(4)),
                 ("reward-cycle".into(), Value::UInt(cycle_id + 1)),
                 ("round".into(), Value::UInt(0)),
                 ("signer".into(), Value::Principal(bob_principal.clone())),

From a7c384c9635f924b68343db31e095515672165a5 Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Fri, 16 Feb 2024 14:14:43 -0500
Subject: [PATCH 0792/1166] fix: update for `slots` -> `weight` field naming
 change

---
 testnet/stacks-node/src/tests/nakamoto_integrations.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 42f2d70e92..7b0c0c21ab 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -1096,7 +1096,7 @@ fn correct_burn_outs() {
         assert_eq!(reward_set.rewarded_addresses.len(), 1);
         assert_eq!(signers.len(), 1);
         // the signer should have 1 "slot", because they stacked the minimum stacking amount
-        assert_eq!(signers[0].slots, 1);
+        assert_eq!(signers[0].weight, 1);
     }
 
     run_loop_thread.join().unwrap();

From 818dd7466316a63ba1d822464b35a5348bdf587a Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Fri, 16 Feb 2024 16:57:56 -0500
Subject: [PATCH 0793/1166] chore: remove lazy_static

---
 .../src/chainstate/nakamoto/staging_blocks.rs | 75 +++++++++----------
 1 file changed, 36 insertions(+), 39 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/staging_blocks.rs b/stackslib/src/chainstate/nakamoto/staging_blocks.rs
index c7bcfeb127..c0d9177783 100644
--- a/stackslib/src/chainstate/nakamoto/staging_blocks.rs
+++ b/stackslib/src/chainstate/nakamoto/staging_blocks.rs
@@ -36,45 +36,42 @@ use crate::util_lib::db::{
     DBConn, Error as DBError, FromRow,
 };
 
-lazy_static! {
-    pub static ref NAKAMOTO_STAGING_DB_SCHEMA_1: Vec<String> = vec![
-      r#"
-      -- Table for staging nakamoto blocks
-      CREATE TABLE nakamoto_staging_blocks (
-                     -- SHA512/256 hash of this block
-                     block_hash TEXT NOT NULL,
-                     -- the consensus hash of the burnchain block that selected this block's miner's block-commit
-                     consensus_hash TEXT NOT NULL,
-                     -- the parent index_block_hash
-                     parent_block_id TEXT NOT NULL,
-
-                     -- has the burnchain block with this block's `consensus_hash` been processed?
-                     burn_attachable INT NOT NULL,
-                     -- has this block been processed?
-                     processed INT NOT NULL,
-                     -- set to 1 if this block can never be attached
-                     orphaned INT NOT NULL,
-
-                     height INT NOT NULL,
-
-                     -- used internally -- this is the StacksBlockId of this block's consensus hash and block hash
-                     index_block_hash TEXT NOT NULL,
-                     -- how long the block was in-flight
-                     download_time INT NOT NULL,
-                     -- when this block was stored
-                     arrival_time INT NOT NULL,
-                     -- when this block was processed
-                     processed_time INT NOT NULL,
-
-                     -- block data
-                     data BLOB NOT NULL,
-                    
-                     PRIMARY KEY(block_hash,consensus_hash)
-        );"#
-        .into(),
-        r#"CREATE INDEX by_index_block_hash ON nakamoto_staging_blocks(index_block_hash);"#.into()
-    ];
-}
+pub const NAKAMOTO_STAGING_DB_SCHEMA_1: &'static [&'static str] = &[
+    r#"
+  -- Table for staging nakamoto blocks
+  CREATE TABLE nakamoto_staging_blocks (
+                 -- SHA512/256 hash of this block
+                 block_hash TEXT NOT NULL,
+                 -- the consensus hash of the burnchain block that selected this block's miner's block-commit
+                 consensus_hash TEXT NOT NULL,
+                 -- the parent index_block_hash
+                 parent_block_id TEXT NOT NULL,
+
+                 -- has the burnchain block with this block's `consensus_hash` been processed?
+                 burn_attachable INT NOT NULL,
+                 -- has this block been processed?
+                 processed INT NOT NULL,
+                 -- set to 1 if this block can never be attached
+                 orphaned INT NOT NULL,
+
+                 height INT NOT NULL,
+
+                 -- used internally -- this is the StacksBlockId of this block's consensus hash and block hash
+                 index_block_hash TEXT NOT NULL,
+                 -- how long the block was in-flight
+                 download_time INT NOT NULL,
+                 -- when this block was stored
+                 arrival_time INT NOT NULL,
+                 -- when this block was processed
+                 processed_time INT NOT NULL,
+
+                 -- block data
+                 data BLOB NOT NULL,
+                
+                 PRIMARY KEY(block_hash,consensus_hash)
+    );"#,
+    r#"CREATE INDEX by_index_block_hash ON nakamoto_staging_blocks(index_block_hash);"#,
+];
 
 pub struct NakamotoStagingBlocksConn(rusqlite::Connection);
 

From ffef7ee183839c5ad29b8070ef28559d2fc4d398 Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Fri, 16 Feb 2024 17:38:56 -0500
Subject: [PATCH 0794/1166] fix: WIP fix the net tests after signer changes

---
 stackslib/src/net/tests/inv/nakamoto.rs |   2 +-
 stackslib/src/net/tests/mod.rs          | 105 ++++++++++++++----------
 2 files changed, 64 insertions(+), 43 deletions(-)

diff --git a/stackslib/src/net/tests/inv/nakamoto.rs b/stackslib/src/net/tests/inv/nakamoto.rs
index e622fd728d..fe85be0832 100644
--- a/stackslib/src/net/tests/inv/nakamoto.rs
+++ b/stackslib/src/net/tests/inv/nakamoto.rs
@@ -389,7 +389,7 @@ fn make_nakamoto_peer_from_invs<'a>(
         }
     }
 
-    let plan = NakamotoBootPlan::new(test_name)
+    let mut plan = NakamotoBootPlan::new(test_name)
         .with_private_key(private_key)
         .with_pox_constants(rc_len, prepare_len)
         .with_initial_balances(vec![(addr.into(), 1_000_000)]);
diff --git a/stackslib/src/net/tests/mod.rs b/stackslib/src/net/tests/mod.rs
index 521f26ff2c..06bf9cf510 100644
--- a/stackslib/src/net/tests/mod.rs
+++ b/stackslib/src/net/tests/mod.rs
@@ -35,14 +35,16 @@ use crate::burnchains::PoxConstants;
 use crate::chainstate::burn::db::sortdb::{SortitionDB, SortitionHandle};
 use crate::chainstate::burn::operations::BlockstackOperationType;
 use crate::chainstate::coordinator::tests::p2pkh_from;
-use crate::chainstate::nakamoto::coordinator::tests::boot_nakamoto;
+use crate::chainstate::nakamoto::coordinator::tests::{
+    boot_nakamoto, make_all_signers_vote_for_aggregate_key,
+};
 use crate::chainstate::nakamoto::test_signers::TestSigners;
 use crate::chainstate::nakamoto::tests::get_account;
 use crate::chainstate::nakamoto::tests::node::TestStacker;
 use crate::chainstate::nakamoto::{NakamotoBlock, NakamotoChainState};
 use crate::chainstate::stacks::address::PoxAddress;
 use crate::chainstate::stacks::boot::test::{
-    key_to_stacks_addr, make_pox_4_lockup, make_signer_key_signature,
+    key_to_stacks_addr, make_pox_4_lockup, make_signer_key_signature, with_sortdb,
 };
 use crate::chainstate::stacks::boot::MINERS_NAME;
 use crate::chainstate::stacks::db::{MinerPaymentTxFees, StacksAccount, StacksChainState};
@@ -77,20 +79,21 @@ pub struct NakamotoBootPlan {
     pub pox_constants: PoxConstants,
     pub private_key: StacksPrivateKey,
     pub initial_balances: Vec<(PrincipalData, u64)>,
-    pub test_stackers: Option<Vec<TestStacker>>,
-    pub test_signers: Option<TestSigners>,
+    pub test_stackers: Vec<TestStacker>,
+    pub test_signers: TestSigners,
     pub observer: Option<TestEventObserver>,
 }
 
 impl NakamotoBootPlan {
     pub fn new(test_name: &str) -> Self {
+        let test_signers = TestSigners::default();
         Self {
             test_name: test_name.to_string(),
             pox_constants: TestPeerConfig::default().burnchain.pox_constants,
             private_key: StacksPrivateKey::from_seed(&[2]),
             initial_balances: vec![],
-            test_stackers: None,
-            test_signers: None,
+            test_stackers: TestStacker::common_signing_set(&test_signers),
+            test_signers,
             observer: Some(TestEventObserver::new()),
         }
     }
@@ -128,12 +131,12 @@ impl NakamotoBootPlan {
     }
 
     pub fn with_test_stackers(mut self, test_stackers: Vec<TestStacker>) -> Self {
-        self.test_stackers = Some(test_stackers);
+        self.test_stackers = test_stackers;
         self
     }
 
     pub fn with_test_signers(mut self, test_signers: TestSigners) -> Self {
-        self.test_signers = Some(test_signers);
+        self.test_signers = test_signers;
         self
     }
 
@@ -187,7 +190,7 @@ impl NakamotoBootPlan {
     /// Make a peer and transition it into the Nakamoto epoch.
     /// The node needs to be stacking; otherwise, Nakamoto won't activate.
     fn boot_nakamoto<'a>(
-        mut self,
+        &mut self,
         aggregate_public_key: Point,
         observer: Option<&'a TestEventObserver>,
     ) -> TestPeer<'a> {
@@ -221,31 +224,9 @@ impl NakamotoBootPlan {
             .initial_balances
             .append(&mut self.initial_balances.clone());
 
-        let test_stackers: Vec<TestStacker> = if let Some(stackers) = self.test_stackers.take() {
-            stackers.into_iter().collect()
-        } else {
-            // Create a list of test Stackers and their signer keys
-            let num_keys = self
-                .test_signers
-                .as_ref()
-                .unwrap_or(&TestSigners::default())
-                .num_keys;
-            (0..num_keys)
-                .map(|index| {
-                    let stacker_private_key = StacksPrivateKey::from_seed(&index.to_be_bytes());
-                    let signer_private_key =
-                        StacksPrivateKey::from_seed(&(index + 1000).to_be_bytes());
-                    TestStacker {
-                        stacker_private_key,
-                        signer_private_key,
-                        amount: 1_000_000_000_000_000_000,
-                    }
-                })
-                .collect()
-        };
-
         // Create some balances for test Stackers
-        let mut stacker_balances = test_stackers
+        let mut stacker_balances = self
+            .test_stackers
             .iter()
             .map(|test_stacker| {
                 (
@@ -256,7 +237,8 @@ impl NakamotoBootPlan {
             .collect();
 
         peer_config.initial_balances.append(&mut stacker_balances);
-        peer_config.test_stackers = Some(test_stackers.clone());
+        peer_config.test_signers = Some(self.test_signers.clone());
+        peer_config.test_stackers = Some(self.test_stackers.clone());
         peer_config.burnchain.pox_constants = self.pox_constants.clone();
         let mut peer = TestPeer::new_with_observer(peer_config, observer);
         self.advance_to_nakamoto(&mut peer);
@@ -264,7 +246,7 @@ impl NakamotoBootPlan {
     }
 
     /// Bring a TestPeer into the Nakamoto Epoch
-    fn advance_to_nakamoto(&self, peer: &mut TestPeer) {
+    fn advance_to_nakamoto(&mut self, peer: &mut TestPeer) {
         let mut peer_nonce = 0;
         let addr = StacksAddress::from_public_keys(
             C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
@@ -344,7 +326,47 @@ impl NakamotoBootPlan {
             })
             .collect();
 
-        peer.tenure_with_txs(&stack_txs, &mut peer_nonce);
+        let mut stacks_block = peer.tenure_with_txs(&stack_txs, &mut peer_nonce);
+
+        debug!("\n\n======================");
+        debug!("Advance to the Prepare Phase");
+        debug!("========================\n\n");
+        while !peer
+            .config
+            .burnchain
+            .is_in_prepare_phase(sortition_height.into())
+        {
+            stacks_block = peer.tenure_with_txs(&vec![], &mut peer_nonce);
+            let tip = {
+                let sort_db = peer.sortdb.as_mut().unwrap();
+                let tip = SortitionDB::get_canonical_burn_chain_tip(sort_db.conn()).unwrap();
+                tip
+            };
+            sortition_height = tip.block_height;
+        }
+
+        debug!("\n\n======================");
+        debug!("Vote for the Aggregate Key");
+        debug!("========================\n\n");
+
+        let target_cycle = peer
+            .config
+            .burnchain
+            .block_height_to_reward_cycle(sortition_height.into())
+            .expect("Failed to get reward cycle")
+            + 1;
+        let vote_txs = with_sortdb(peer, |chainstate, sortdb| {
+            make_all_signers_vote_for_aggregate_key(
+                chainstate,
+                sortdb,
+                &stacks_block,
+                &mut self.test_signers,
+                &self.test_stackers,
+                target_cycle.into(),
+            )
+        });
+
+        peer.tenure_with_txs(&vote_txs, &mut peer_nonce);
 
         debug!("\n\n======================");
         debug!("Advance to Epoch 3.0");
@@ -369,12 +391,11 @@ impl NakamotoBootPlan {
     }
 
     pub fn boot_into_nakamoto_peer<'a>(
-        self,
+        &mut self,
         boot_plan: Vec<NakamotoBootTenure>,
         observer: Option<&'a TestEventObserver>,
     ) -> TestPeer<'a> {
-        let mut test_signers = self.test_signers.clone().unwrap_or(TestSigners::default());
-        let mut peer = self.boot_nakamoto(test_signers.aggregate_public_key.clone(), observer);
+        let mut peer = self.boot_nakamoto(self.test_signers.aggregate_public_key.clone(), observer);
 
         let mut all_blocks = vec![];
         let mut rc_burn_ops = vec![];
@@ -418,7 +439,7 @@ impl NakamotoBootPlan {
 
                     let blocks_and_sizes = peer.make_nakamoto_tenure_extension(
                         tenure_change_tx,
-                        &mut test_signers,
+                        &mut self.test_signers,
                         |miner, chainstate, sortdb, blocks_so_far| {
                             if i >= boot_steps.len() {
                                 return vec![];
@@ -503,7 +524,7 @@ impl NakamotoBootPlan {
                     let blocks_and_sizes = peer.make_nakamoto_tenure(
                         tenure_change_tx,
                         coinbase_tx,
-                        &mut test_signers,
+                        &mut self.test_signers,
                         |miner, chainstate, sortdb, blocks_so_far| {
                             if i >= boot_steps.len() {
                                 return vec![];
@@ -752,7 +773,7 @@ fn test_boot_nakamoto_peer() {
         NakamotoBootTenure::Sortition(vec![NakamotoBootStep::Block(vec![next_stx_transfer()])]),
     ];
 
-    let plan = NakamotoBootPlan::new(&function_name!())
+    let mut plan = NakamotoBootPlan::new(&function_name!())
         .with_private_key(private_key)
         .with_pox_constants(10, 3)
         .with_initial_balances(vec![(addr.into(), 1_000_000)]);

From 7c09d09483fd811a71136ae6bb2eead0dc0c87a7 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Sat, 17 Feb 2024 14:07:11 -0600
Subject: [PATCH 0795/1166] fix: TestPeer submits aggregate key votes
 automatically, inv tests **must** have sortitions during prepare phase!

---
 stackslib/src/burnchains/mod.rs               |   3 +
 .../chainstate/nakamoto/coordinator/tests.rs  |   4 +-
 stackslib/src/chainstate/stacks/miner.rs      |   6 +-
 stackslib/src/net/tests/inv/nakamoto.rs       |  36 +++---
 stackslib/src/net/tests/mod.rs                | 114 +++++++++++++-----
 5 files changed, 110 insertions(+), 53 deletions(-)

diff --git a/stackslib/src/burnchains/mod.rs b/stackslib/src/burnchains/mod.rs
index 2f38262966..8734d605d8 100644
--- a/stackslib/src/burnchains/mod.rs
+++ b/stackslib/src/burnchains/mod.rs
@@ -595,6 +595,9 @@ impl PoxConstants {
 
             // NOTE: first block in reward cycle is mod 1, so mod 0 is the last block in the
             // prepare phase.
+            // TODO: I *think* the logic of `== 0` here requires some further digging.
+            //  `mod 0` may not have any rewards, but it does not behave like "prepare phase" blocks:
+            //  is it already a member of reward cycle "N" where N = block_height / reward_cycle_len
             reward_index == 0 || reward_index > u64::from(reward_cycle_length - prepare_length)
         }
     }
diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index d543947374..6d1f1f2141 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -136,7 +136,7 @@ pub fn make_all_signers_vote_for_aggregate_key(
     test_stackers: &[TestStacker],
     cycle_id: u128,
 ) -> Vec<StacksTransaction> {
-    debug!("Trigger signers vote for cycle {}", cycle_id);
+    info!("Trigger signers vote for cycle {}", cycle_id);
 
     // Check if we already have an aggregate key for this cycle
     if chainstate
@@ -195,7 +195,7 @@ pub fn make_all_signers_vote_for_aggregate_key(
     }
 
     // Vote for the aggregate key for each signer
-    debug!("Trigger votes for cycle {}", cycle_id);
+    info!("Trigger votes for cycle {}", cycle_id);
     signers
         .iter()
         .map(|(addr, (signer_key, index))| {
diff --git a/stackslib/src/chainstate/stacks/miner.rs b/stackslib/src/chainstate/stacks/miner.rs
index b7eb827ef6..48e1856374 100644
--- a/stackslib/src/chainstate/stacks/miner.rs
+++ b/stackslib/src/chainstate/stacks/miner.rs
@@ -586,7 +586,11 @@ impl TransactionResult {
                 // which code paths were hit, the user should really have attached an appropriate
                 // tx fee in the first place.  In Stacks 2.1, the code will debit the fee first, so
                 // this will no longer be an issue.
-                info!("Problematic transaction caused InvalidFee"; "txid" => %tx.txid());
+                info!("Problematic transaction caused InvalidFee";
+                      "txid" => %tx.txid(),
+                      "origin" => %tx.get_origin().get_address(false),
+                      "payload" => ?tx.payload,
+                );
                 return (true, Error::InvalidFee);
             }
             e => e,
diff --git a/stackslib/src/net/tests/inv/nakamoto.rs b/stackslib/src/net/tests/inv/nakamoto.rs
index fe85be0832..e2f2c909ce 100644
--- a/stackslib/src/net/tests/inv/nakamoto.rs
+++ b/stackslib/src/net/tests/inv/nakamoto.rs
@@ -461,17 +461,15 @@ fn test_nakamoto_invs_full() {
 fn test_nakamoto_invs_alternating() {
     let observer = TestEventObserver::new();
     let bitvecs = vec![
+        vec![true, false, true, false, true, true, true, true, true, true],
         vec![
-            true, false, true, false, true, false, true, true, true, true,
-        ],
-        vec![
-            false, true, false, true, false, true, false, true, true, true,
+            false, true, false, true, false, true, true, true, true, true,
         ],
         vec![
             true, false, true, false, true, false, true, true, true, true,
         ],
         vec![
-            false, true, false, true, false, true, false, true, true, true,
+            false, true, false, true, false, true, true, true, true, true,
         ],
         vec![
             true, false, true, false, true, false, true, true, true, true,
@@ -495,22 +493,22 @@ fn test_nakamoto_invs_sparse() {
     let observer = TestEventObserver::new();
     let bitvecs = vec![
         vec![
-            true, false, false, false, false, false, false, true, true, true,
+            true, false, false, false, false, false, true, true, true, true,
         ],
         vec![
-            false, true, false, false, false, false, false, true, true, true,
+            false, true, false, false, false, false, true, true, true, true,
         ],
         vec![
-            false, false, true, false, false, false, false, true, true, true,
+            false, false, true, false, false, false, true, true, true, true,
         ],
         vec![
-            false, false, false, true, false, false, false, true, true, true,
+            false, false, false, true, false, false, true, true, true, true,
         ],
         vec![
-            false, false, false, false, true, false, false, true, true, true,
+            false, false, false, false, true, false, true, true, true, true,
         ],
         vec![
-            false, false, false, false, false, true, false, true, true, true,
+            false, false, false, false, false, true, true, true, true, true,
         ],
         vec![
             false, false, false, false, false, false, true, true, true, true,
@@ -533,22 +531,20 @@ fn test_nakamoto_invs_sparse() {
 fn test_nakamoto_invs_different_anchor_blocks() {
     let observer = TestEventObserver::new();
     let bitvecs = vec![
-        vec![true, true, true, true, true, true, false, true, true, true],
-        vec![true, true, true, true, true, false, false, true, true, true],
-        vec![
-            true, true, true, true, false, false, false, true, true, true,
-        ],
+        vec![true, true, true, true, true, true, true, true, true, true],
+        vec![true, true, true, true, true, false, true, true, true, true],
+        vec![true, true, true, true, false, false, true, true, true, true],
         vec![
-            true, true, true, false, false, false, false, true, true, true,
+            true, true, true, false, false, false, true, true, true, true,
         ],
         vec![
-            true, true, false, false, false, false, false, true, true, true,
+            true, true, false, false, false, false, true, true, true, true,
         ],
         vec![
-            true, false, false, false, false, false, false, true, true, true,
+            true, false, false, false, false, false, true, true, true, true,
         ],
         vec![
-            false, false, false, false, false, false, false, true, true, true,
+            false, false, false, false, false, false, true, true, true, true,
         ],
     ];
 
diff --git a/stackslib/src/net/tests/mod.rs b/stackslib/src/net/tests/mod.rs
index 06bf9cf510..f93675d92a 100644
--- a/stackslib/src/net/tests/mod.rs
+++ b/stackslib/src/net/tests/mod.rs
@@ -52,7 +52,7 @@ use crate::chainstate::stacks::events::TransactionOrigin;
 use crate::chainstate::stacks::{
     CoinbasePayload, StacksTransaction, StacksTransactionSigner, TenureChangeCause,
     TenureChangePayload, TokenTransferMemo, TransactionAnchorMode, TransactionAuth,
-    TransactionPayload, TransactionVersion,
+    TransactionContractCall, TransactionPayload, TransactionVersion,
 };
 use crate::clarity::vm::types::StacksAddressExtensions;
 use crate::core::{StacksEpoch, StacksEpochExtension};
@@ -165,17 +165,31 @@ impl NakamotoBootPlan {
                 NakamotoBootStep::TenureExtend(txs) => txs.clone(),
                 NakamotoBootStep::Block(txs) => txs.clone(),
             };
-            let mut planned_txs = vec![];
-            for tx in block.txs.iter() {
-                match tx.payload {
+            let planned_txs: Vec<_> = block
+                .txs
+                .iter()
+                .filter(|tx| match &tx.payload {
                     TransactionPayload::Coinbase(..) | TransactionPayload::TenureChange(..) => {
-                        continue;
+                        false
                     }
-                    _ => {
-                        planned_txs.push(tx.clone());
+                    TransactionPayload::ContractCall(TransactionContractCall {
+                        contract_name,
+                        address,
+                        function_name,
+                        ..
+                    }) => {
+                        if contract_name.as_str() == "signers-voting"
+                            && address.is_burn()
+                            && function_name.as_str() == "vote-for-aggregate-public-key"
+                        {
+                            false
+                        } else {
+                            true
+                        }
                     }
-                }
-            }
+                    _ => true,
+                })
+                .collect();
             assert_eq!(planned_txs.len(), boot_step_txs.len());
             for (block_tx, boot_step_tx) in planned_txs.iter().zip(boot_step_txs.iter()) {
                 assert_eq!(block_tx.txid(), boot_step_tx.txid());
@@ -225,18 +239,23 @@ impl NakamotoBootPlan {
             .append(&mut self.initial_balances.clone());
 
         // Create some balances for test Stackers
-        let mut stacker_balances = self
-            .test_stackers
-            .iter()
-            .map(|test_stacker| {
-                (
-                    PrincipalData::from(key_to_stacks_addr(&test_stacker.stacker_private_key)),
-                    u64::try_from(test_stacker.amount).expect("Stacking amount too large"),
-                )
-            })
-            .collect();
+        // They need their stacking amount + enough to pay fees
+        let fee_payment_balance = 10_000;
+        let stacker_balances = self.test_stackers.iter().map(|test_stacker| {
+            (
+                PrincipalData::from(key_to_stacks_addr(&test_stacker.stacker_private_key)),
+                u64::try_from(test_stacker.amount).expect("Stacking amount too large"),
+            )
+        });
+        let signer_balances = self.test_stackers.iter().map(|test_stacker| {
+            (
+                PrincipalData::from(key_to_stacks_addr(&test_stacker.signer_private_key)),
+                fee_payment_balance,
+            )
+        });
 
-        peer_config.initial_balances.append(&mut stacker_balances);
+        peer_config.initial_balances.extend(stacker_balances);
+        peer_config.initial_balances.extend(signer_balances);
         peer_config.test_signers = Some(self.test_signers.clone());
         peer_config.test_stackers = Some(self.test_stackers.clone());
         peer_config.burnchain.pox_constants = self.pox_constants.clone();
@@ -248,13 +267,7 @@ impl NakamotoBootPlan {
     /// Bring a TestPeer into the Nakamoto Epoch
     fn advance_to_nakamoto(&mut self, peer: &mut TestPeer) {
         let mut peer_nonce = 0;
-        let addr = StacksAddress::from_public_keys(
-            C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
-            &AddressHashMode::SerializeP2PKH,
-            1,
-            &vec![StacksPublicKey::from_private(&self.private_key)],
-        )
-        .unwrap();
+        let addr = StacksAddress::p2pkh(false, &StacksPublicKey::from_private(&self.private_key));
 
         let tip = {
             let sort_db = peer.sortdb.as_mut().unwrap();
@@ -501,7 +514,7 @@ impl NakamotoBootPlan {
                     assert!(boot_steps.len() > 0);
                     let (burn_ops, mut tenure_change, miner_key) =
                         peer.begin_nakamoto_tenure(TenureChangeCause::BlockFound);
-                    let (_, _, consensus_hash) = peer.next_burnchain_block(burn_ops.clone());
+                    let (burn_ht, _, consensus_hash) = peer.next_burnchain_block(burn_ops.clone());
                     let vrf_proof = peer.make_nakamoto_vrf_proof(miner_key);
 
                     tenure_change.tenure_consensus_hash = consensus_hash.clone();
@@ -521,6 +534,43 @@ impl NakamotoBootPlan {
                     let mut num_expected_transactions = 2; // tenure-change and coinbase
                     blocks_since_last_tenure = 0;
 
+                    let first_burn_ht = peer.sortdb().first_block_height;
+                    let voting_txs = if self
+                        .pox_constants
+                        .is_in_prepare_phase(first_burn_ht, burn_ht)
+                    {
+                        let tip = peer
+                            .with_db_state(|sortdb, chainst, _, _| {
+                                Ok(NakamotoChainState::get_canonical_block_header(
+                                    chainst.db(),
+                                    sortdb,
+                                )
+                                .unwrap()
+                                .unwrap())
+                            })
+                            .unwrap();
+                        let cycle_id = self
+                            .pox_constants
+                            .block_height_to_reward_cycle(first_burn_ht, burn_ht)
+                            .unwrap();
+
+                        peer.with_db_state(|sortdb, chainstate, _, _| {
+                            Ok(make_all_signers_vote_for_aggregate_key(
+                                chainstate,
+                                sortdb,
+                                &tip.index_block_hash(),
+                                &mut self.test_signers,
+                                &self.test_stackers,
+                                u128::from(cycle_id + 1),
+                            ))
+                        })
+                        .unwrap()
+                    } else {
+                        vec![]
+                    };
+
+                    num_expected_transactions += voting_txs.len();
+
                     let blocks_and_sizes = peer.make_nakamoto_tenure(
                         tenure_change_tx,
                         coinbase_tx,
@@ -532,7 +582,11 @@ impl NakamotoBootPlan {
                             let next_step = &boot_steps[i];
                             i += 1;
 
-                            let mut txs = vec![];
+                            let mut txs = if blocks_so_far.len() == 0 {
+                                voting_txs.clone()
+                            } else {
+                                vec![]
+                            };
                             let last_block_opt = blocks_so_far
                                 .last()
                                 .as_ref()
@@ -725,13 +779,13 @@ fn test_boot_nakamoto_peer() {
             NakamotoBootStep::Block(vec![next_stx_transfer()]),
             NakamotoBootStep::TenureExtend(vec![next_stx_transfer()]),
         ]),
-        NakamotoBootTenure::NoSortition(vec![NakamotoBootStep::Block(vec![next_stx_transfer()])]),
         // prepare phase for 2
         NakamotoBootTenure::NoSortition(vec![NakamotoBootStep::Block(vec![next_stx_transfer()])]),
         NakamotoBootTenure::Sortition(vec![NakamotoBootStep::Block(vec![next_stx_transfer()])]),
         NakamotoBootTenure::Sortition(vec![NakamotoBootStep::Block(vec![next_stx_transfer()])]),
         // reward cycle 2
         NakamotoBootTenure::Sortition(vec![NakamotoBootStep::Block(vec![next_stx_transfer()])]),
+        NakamotoBootTenure::Sortition(vec![NakamotoBootStep::Block(vec![next_stx_transfer()])]),
         NakamotoBootTenure::NoSortition(vec![NakamotoBootStep::Block(vec![next_stx_transfer()])]),
         NakamotoBootTenure::NoSortition(vec![NakamotoBootStep::Block(vec![next_stx_transfer()])]),
         NakamotoBootTenure::NoSortition(vec![NakamotoBootStep::Block(vec![next_stx_transfer()])]),

From 52c7a590adf72a0af5180c506867aa4183eb5831 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Sat, 17 Feb 2024 20:39:03 -0600
Subject: [PATCH 0796/1166] test: alter NakamotoBootPlan to issue signer votes
 whenever possible (even in the middle of a tenure)

---
 stackslib/src/net/tests/inv/nakamoto.rs | 36 +++++++------
 stackslib/src/net/tests/mod.rs          | 71 +++++++++++--------------
 2 files changed, 52 insertions(+), 55 deletions(-)

diff --git a/stackslib/src/net/tests/inv/nakamoto.rs b/stackslib/src/net/tests/inv/nakamoto.rs
index e2f2c909ce..fe85be0832 100644
--- a/stackslib/src/net/tests/inv/nakamoto.rs
+++ b/stackslib/src/net/tests/inv/nakamoto.rs
@@ -461,15 +461,17 @@ fn test_nakamoto_invs_full() {
 fn test_nakamoto_invs_alternating() {
     let observer = TestEventObserver::new();
     let bitvecs = vec![
-        vec![true, false, true, false, true, true, true, true, true, true],
         vec![
-            false, true, false, true, false, true, true, true, true, true,
+            true, false, true, false, true, false, true, true, true, true,
+        ],
+        vec![
+            false, true, false, true, false, true, false, true, true, true,
         ],
         vec![
             true, false, true, false, true, false, true, true, true, true,
         ],
         vec![
-            false, true, false, true, false, true, true, true, true, true,
+            false, true, false, true, false, true, false, true, true, true,
         ],
         vec![
             true, false, true, false, true, false, true, true, true, true,
@@ -493,22 +495,22 @@ fn test_nakamoto_invs_sparse() {
     let observer = TestEventObserver::new();
     let bitvecs = vec![
         vec![
-            true, false, false, false, false, false, true, true, true, true,
+            true, false, false, false, false, false, false, true, true, true,
         ],
         vec![
-            false, true, false, false, false, false, true, true, true, true,
+            false, true, false, false, false, false, false, true, true, true,
         ],
         vec![
-            false, false, true, false, false, false, true, true, true, true,
+            false, false, true, false, false, false, false, true, true, true,
         ],
         vec![
-            false, false, false, true, false, false, true, true, true, true,
+            false, false, false, true, false, false, false, true, true, true,
         ],
         vec![
-            false, false, false, false, true, false, true, true, true, true,
+            false, false, false, false, true, false, false, true, true, true,
         ],
         vec![
-            false, false, false, false, false, true, true, true, true, true,
+            false, false, false, false, false, true, false, true, true, true,
         ],
         vec![
             false, false, false, false, false, false, true, true, true, true,
@@ -531,20 +533,22 @@ fn test_nakamoto_invs_sparse() {
 fn test_nakamoto_invs_different_anchor_blocks() {
     let observer = TestEventObserver::new();
     let bitvecs = vec![
-        vec![true, true, true, true, true, true, true, true, true, true],
-        vec![true, true, true, true, true, false, true, true, true, true],
-        vec![true, true, true, true, false, false, true, true, true, true],
+        vec![true, true, true, true, true, true, false, true, true, true],
+        vec![true, true, true, true, true, false, false, true, true, true],
         vec![
-            true, true, true, false, false, false, true, true, true, true,
+            true, true, true, true, false, false, false, true, true, true,
         ],
         vec![
-            true, true, false, false, false, false, true, true, true, true,
+            true, true, true, false, false, false, false, true, true, true,
         ],
         vec![
-            true, false, false, false, false, false, true, true, true, true,
+            true, true, false, false, false, false, false, true, true, true,
         ],
         vec![
-            false, false, false, false, false, false, true, true, true, true,
+            true, false, false, false, false, false, false, true, true, true,
+        ],
+        vec![
+            false, false, false, false, false, false, false, true, true, true,
         ],
     ];
 
diff --git a/stackslib/src/net/tests/mod.rs b/stackslib/src/net/tests/mod.rs
index f93675d92a..c86f4b6d82 100644
--- a/stackslib/src/net/tests/mod.rs
+++ b/stackslib/src/net/tests/mod.rs
@@ -535,41 +535,9 @@ impl NakamotoBootPlan {
                     blocks_since_last_tenure = 0;
 
                     let first_burn_ht = peer.sortdb().first_block_height;
-                    let voting_txs = if self
-                        .pox_constants
-                        .is_in_prepare_phase(first_burn_ht, burn_ht)
-                    {
-                        let tip = peer
-                            .with_db_state(|sortdb, chainst, _, _| {
-                                Ok(NakamotoChainState::get_canonical_block_header(
-                                    chainst.db(),
-                                    sortdb,
-                                )
-                                .unwrap()
-                                .unwrap())
-                            })
-                            .unwrap();
-                        let cycle_id = self
-                            .pox_constants
-                            .block_height_to_reward_cycle(first_burn_ht, burn_ht)
-                            .unwrap();
-
-                        peer.with_db_state(|sortdb, chainstate, _, _| {
-                            Ok(make_all_signers_vote_for_aggregate_key(
-                                chainstate,
-                                sortdb,
-                                &tip.index_block_hash(),
-                                &mut self.test_signers,
-                                &self.test_stackers,
-                                u128::from(cycle_id + 1),
-                            ))
-                        })
-                        .unwrap()
-                    } else {
-                        vec![]
-                    };
-
-                    num_expected_transactions += voting_txs.len();
+                    let pox_constants = self.pox_constants.clone();
+                    let mut test_signers = self.test_signers.clone();
+                    let test_stackers = self.test_stackers.clone();
 
                     let blocks_and_sizes = peer.make_nakamoto_tenure(
                         tenure_change_tx,
@@ -582,11 +550,30 @@ impl NakamotoBootPlan {
                             let next_step = &boot_steps[i];
                             i += 1;
 
-                            let mut txs = if blocks_so_far.len() == 0 {
-                                voting_txs.clone()
+                            let mut txs = vec![];
+                            // check if the stacker/signers need to vote for an aggregate key. if so, append those transactions
+                            //  to the end of the block.
+                            // NOTE: this will only work the block after .signers is updated, because `make_all_signers_vote...`
+                            //  checks the chainstate as of `tip` to obtain the signer vector. this means that some tests may
+                            //  need to produce an extra block in a tenure in order to get the signer votes in place.
+                            //  The alternative to doing this would be to either manually build the signer vector or to refactor
+                            //  the testpeer such that a callback is provided during the actual mining of the block with a
+                            //  `ClarityBlockConnection`.
+                            let mut voting_txs = if self.pox_constants.is_in_prepare_phase(first_burn_ht, burn_ht) {
+                                let tip = NakamotoChainState::get_canonical_block_header(chainstate.db(), sortdb).unwrap().unwrap();
+                                let cycle_id = 1 + self.pox_constants.block_height_to_reward_cycle(first_burn_ht, burn_ht).unwrap();
+                                make_all_signers_vote_for_aggregate_key(
+                                    chainstate,
+                                    sortdb,
+                                    &tip.index_block_hash(),
+                                    &mut test_signers,
+                                    &test_stackers,
+                                    u128::from(cycle_id),
+                                )
                             } else {
                                 vec![]
                             };
+
                             let last_block_opt = blocks_so_far
                                 .last()
                                 .as_ref()
@@ -618,6 +605,9 @@ impl NakamotoBootPlan {
                                 }
                             }
 
+                            num_expected_transactions += voting_txs.len();
+                            txs.append(&mut voting_txs);
+
                             blocks_since_last_tenure += 1;
                             txs
                         });
@@ -779,13 +769,16 @@ fn test_boot_nakamoto_peer() {
             NakamotoBootStep::Block(vec![next_stx_transfer()]),
             NakamotoBootStep::TenureExtend(vec![next_stx_transfer()]),
         ]),
+        NakamotoBootTenure::NoSortition(vec![NakamotoBootStep::Block(vec![next_stx_transfer()])]),
         // prepare phase for 2
         NakamotoBootTenure::NoSortition(vec![NakamotoBootStep::Block(vec![next_stx_transfer()])]),
-        NakamotoBootTenure::Sortition(vec![NakamotoBootStep::Block(vec![next_stx_transfer()])]),
+        NakamotoBootTenure::Sortition(vec![
+            NakamotoBootStep::Block(vec![next_stx_transfer()]),
+            NakamotoBootStep::Block(vec![next_stx_transfer()]),
+        ]),
         NakamotoBootTenure::Sortition(vec![NakamotoBootStep::Block(vec![next_stx_transfer()])]),
         // reward cycle 2
         NakamotoBootTenure::Sortition(vec![NakamotoBootStep::Block(vec![next_stx_transfer()])]),
-        NakamotoBootTenure::Sortition(vec![NakamotoBootStep::Block(vec![next_stx_transfer()])]),
         NakamotoBootTenure::NoSortition(vec![NakamotoBootStep::Block(vec![next_stx_transfer()])]),
         NakamotoBootTenure::NoSortition(vec![NakamotoBootStep::Block(vec![next_stx_transfer()])]),
         NakamotoBootTenure::NoSortition(vec![NakamotoBootStep::Block(vec![next_stx_transfer()])]),

From 746ea8b62979af942623df9101a8ea0d7ba19d81 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Sun, 18 Feb 2024 08:01:25 -0600
Subject: [PATCH 0797/1166] test: fix merge of tests with other_peers

---
 stackslib/src/chainstate/nakamoto/mod.rs | 2 +-
 stackslib/src/net/tests/mod.rs           | 9 ++++++++-
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index d1251b1c71..70ff96f899 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -103,9 +103,9 @@ use crate::{chainstate, monitoring};
 pub mod coordinator;
 pub mod miner;
 pub mod signer_set;
-pub mod test_signers;
 pub mod staging_blocks;
 pub mod tenure;
+pub mod test_signers;
 #[cfg(test)]
 pub mod tests;
 
diff --git a/stackslib/src/net/tests/mod.rs b/stackslib/src/net/tests/mod.rs
index 987c09b3ee..41a338fc06 100644
--- a/stackslib/src/net/tests/mod.rs
+++ b/stackslib/src/net/tests/mod.rs
@@ -214,6 +214,7 @@ impl NakamotoBootPlan {
         blocks: &[NakamotoBlock],
         other_peers: &mut [TestPeer],
     ) {
+        info!("Applying block to other peers"; "block_height" => ?burn_ops.first().map(|op| op.block_height()));
         for (i, peer) in other_peers.iter_mut().enumerate() {
             peer.next_burnchain_block(burn_ops.to_vec());
 
@@ -422,7 +423,13 @@ impl NakamotoBootPlan {
             .burnchain
             .is_in_prepare_phase(sortition_height.into())
         {
-            stacks_block = peer.tenure_with_txs(&vec![], &mut peer_nonce);
+            stacks_block = peer.tenure_with_txs(&[], &mut peer_nonce);
+            other_peers
+                .iter_mut()
+                .zip(other_peer_nonces.iter_mut())
+                .for_each(|(peer, nonce)| {
+                    peer.tenure_with_txs(&[], nonce);
+                });
             let tip = {
                 let sort_db = peer.sortdb.as_mut().unwrap();
                 let tip = SortitionDB::get_canonical_burn_chain_tip(sort_db.conn()).unwrap();

From 6015cabb59ef9e4ec5ad014377a7e68f570d9b32 Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Sun, 18 Feb 2024 10:12:13 -0500
Subject: [PATCH 0798/1166] chore: fix warnings

---
 stackslib/src/net/tests/inv/nakamoto.rs | 2 +-
 stackslib/src/net/tests/mod.rs          | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/stackslib/src/net/tests/inv/nakamoto.rs b/stackslib/src/net/tests/inv/nakamoto.rs
index 0b5afcd46c..93213a0e66 100644
--- a/stackslib/src/net/tests/inv/nakamoto.rs
+++ b/stackslib/src/net/tests/inv/nakamoto.rs
@@ -404,7 +404,7 @@ fn make_nakamoto_peers_from_invs<'a>(
         }
     }
 
-    let mut plan = NakamotoBootPlan::new(test_name)
+    let plan = NakamotoBootPlan::new(test_name)
         .with_private_key(private_key)
         .with_pox_constants(rc_len, prepare_len)
         .with_initial_balances(vec![(addr.into(), 1_000_000)])
diff --git a/stackslib/src/net/tests/mod.rs b/stackslib/src/net/tests/mod.rs
index 41a338fc06..52f85f4749 100644
--- a/stackslib/src/net/tests/mod.rs
+++ b/stackslib/src/net/tests/mod.rs
@@ -938,7 +938,7 @@ fn test_boot_nakamoto_peer() {
         NakamotoBootTenure::Sortition(vec![NakamotoBootStep::Block(vec![next_stx_transfer()])]),
     ];
 
-    let mut plan = NakamotoBootPlan::new(&function_name!())
+    let plan = NakamotoBootPlan::new(&function_name!())
         .with_private_key(private_key)
         .with_pox_constants(10, 3)
         .with_initial_balances(vec![(addr.into(), 1_000_000)])

From a8514f244dda5a98314d982a1b7b4a0631aff156 Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Sun, 18 Feb 2024 13:33:52 -0500
Subject: [PATCH 0799/1166] fix: attempt to add voting to the mockamoto tests

---
 testnet/stacks-node/src/mockamoto.rs | 54 +++++++++++++++++++++++++++-
 1 file changed, 53 insertions(+), 1 deletion(-)

diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index b3d22f7926..ce6efdd997 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -49,6 +49,7 @@ use stacks::chainstate::nakamoto::{
     NakamotoBlock, NakamotoBlockHeader, NakamotoChainState, SetupBlockResult,
 };
 use stacks::chainstate::stacks::address::PoxAddress;
+use stacks::chainstate::stacks::boot::SIGNERS_VOTING_NAME;
 use stacks::chainstate::stacks::db::{ChainStateBootData, ClarityTx, StacksChainState};
 use stacks::chainstate::stacks::miner::{
     BlockBuilder, BlockBuilderSettings, BlockLimitFunction, MinerStatus, TransactionResult,
@@ -69,6 +70,7 @@ use stacks::core::{
 use stacks::net::atlas::{AtlasConfig, AtlasDB};
 use stacks::net::relay::Relayer;
 use stacks::net::stackerdb::StackerDBs;
+use stacks::util_lib::boot::boot_code_addr;
 use stacks::util_lib::db::Error as DBError;
 use stacks::util_lib::signed_structured_data::pox4::{
     make_pox_4_signer_key_signature, Pox4SignatureTopic,
@@ -836,6 +838,14 @@ impl MockamotoNode {
 
         let signer_sk = Secp256k1PrivateKey::from_seed(&miner_nonce.to_be_bytes());
         let signer_key = Secp256k1PublicKey::from_private(&signer_sk).to_bytes_compressed();
+        let signer_addr = StacksAddress::from_public_keys(
+            C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
+            &AddressHashMode::SerializeP2PKH,
+            1,
+            &vec![Secp256k1PublicKey::from_private(&signer_sk)],
+        )
+        .unwrap()
+        .into();
 
         let block_height = sortition_tip.block_height;
         let reward_cycle = self
@@ -904,6 +914,48 @@ impl MockamotoNode {
         stack_stx_tx_signer.sign_origin(&self.miner_key).unwrap();
         let stacks_stx_tx = stack_stx_tx_signer.get_tx().unwrap();
 
+        let signer_nonce = if is_genesis {
+            0
+        } else {
+            let sortdb_conn = self.sortdb.index_conn();
+            let mut clarity_conn = clarity_instance.read_only_connection_checked(
+                &parent_block_id,
+                &chainstate_tx,
+                &sortdb_conn,
+            )?;
+            StacksChainState::get_nonce(&mut clarity_conn, &signer_addr)
+        };
+        let aggregate_public_key_val = ClarityValue::buff_from(
+            self.self_signer
+                .aggregate_public_key
+                .compress()
+                .data
+                .to_vec(),
+        )
+        .expect("Failed to serialize aggregate public key");
+        let vote_payload = TransactionPayload::new_contract_call(
+            boot_code_addr(false),
+            SIGNERS_VOTING_NAME,
+            "vote-for-aggregate-public-key",
+            vec![
+                ClarityValue::UInt(0),
+                aggregate_public_key_val,
+                ClarityValue::UInt(0),
+                ClarityValue::UInt((reward_cycle + 1).into()),
+            ],
+        )
+        .unwrap();
+        let mut vote_tx = StacksTransaction::new(
+            TransactionVersion::Testnet,
+            TransactionAuth::from_p2pkh(&signer_sk).unwrap(),
+            vote_payload,
+        );
+        vote_tx.chain_id = chain_id;
+        vote_tx.set_origin_nonce(signer_nonce);
+        let mut vote_tx_signer = StacksTransactionSigner::new(&vote_tx);
+        vote_tx_signer.sign_origin(&signer_sk).unwrap();
+        let vote_tx = vote_tx_signer.get_tx().unwrap();
+
         let sortdb_handle = self.sortdb.index_conn();
         let SetupBlockResult {
             mut clarity_tx,
@@ -928,7 +980,7 @@ impl MockamotoNode {
             false,
         )?;
 
-        let txs = vec![tenure_tx, coinbase_tx, stacks_stx_tx];
+        let txs = vec![tenure_tx, coinbase_tx, stacks_stx_tx, vote_tx];
 
         let _ = match StacksChainState::process_block_transactions(
             &mut clarity_tx,

From 25699347bca37df4a836b008c7561767d33aa8bf Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Sun, 18 Feb 2024 16:28:32 -0600
Subject: [PATCH 0800/1166] use initial aggregate key boot contract for
 mockamoto, fix mockamoto tests

---
 stackslib/src/chainstate/nakamoto/mod.rs   |  2 +-
 stackslib/src/clarity_vm/clarity.rs        | 51 +++++++++++++++++++++-
 stackslib/src/net/p2p.rs                   |  4 +-
 testnet/stacks-node/src/mockamoto.rs       | 15 +++----
 testnet/stacks-node/src/mockamoto/tests.rs | 16 +++++--
 5 files changed, 70 insertions(+), 18 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index 70ff96f899..e889f0deb0 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -1704,7 +1704,7 @@ impl NakamotoChainState {
             aggregate_public_key,
         )? {
             let msg = format!("Received block, but the stacker signature does not match the active stacking cycle");
-            warn!("{}", msg);
+            warn!("{}", msg; "aggregate_key" => %aggregate_public_key);
             return Err(ChainstateError::InvalidStacksBlock(msg));
         }
 
diff --git a/stackslib/src/clarity_vm/clarity.rs b/stackslib/src/clarity_vm/clarity.rs
index 4a14f075da..58732eb9c0 100644
--- a/stackslib/src/clarity_vm/clarity.rs
+++ b/stackslib/src/clarity_vm/clarity.rs
@@ -40,6 +40,7 @@ use stacks_common::consts::{CHAIN_ID_TESTNET, SIGNER_SLOTS_PER_USER};
 use stacks_common::types::chainstate::{
     BlockHeaderHash, BurnchainHeaderHash, SortitionId, StacksAddress, StacksBlockId, TrieHash,
 };
+use stacks_common::util::hash::to_hex;
 use stacks_common::util::secp256k1::MessageSignature;
 
 use crate::burnchains::{Burnchain, PoxConstants};
@@ -1461,13 +1462,59 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
                 }
             }
 
-            let signers_voting_code = &*SIGNER_VOTING_CODE;
+            let initialized_agg_key = if !mainnet {
+                let agg_key_value_opt = self
+                    .with_readonly_clarity_env(
+                        false,
+                        self.chain_id,
+                        ClarityVersion::Clarity2,
+                        StacksAddress::burn_address(false).into(),
+                        None,
+                        LimitedCostTracker::Free,
+                        |vm_env| {
+                            vm_env.execute_contract_allow_private(
+                                &boot_code_id(BOOT_TEST_POX_4_AGG_KEY_CONTRACT, false),
+                                BOOT_TEST_POX_4_AGG_KEY_FNAME,
+                                &[],
+                                true,
+                            )
+                        },
+                    )
+                    .map(|agg_key_value| {
+                        agg_key_value
+                            .expect_buff(33)
+                            .expect("FATAL: test aggregate pub key must be a buffer")
+                    })
+                    .ok();
+                agg_key_value_opt
+            } else {
+                None
+            };
+
+            let mut signers_voting_code = SIGNER_VOTING_CODE.clone();
+            if !mainnet {
+                if let Some(ref agg_pub_key) = initialized_agg_key {
+                    let hex_agg_pub_key = to_hex(agg_pub_key);
+                    for set_in_reward_cycle in 0..pox_4_first_cycle {
+                        info!(
+                            "Setting initial aggregate-public-key in PoX-4";
+                            "agg_pub_key" => &hex_agg_pub_key,
+                            "reward_cycle" => set_in_reward_cycle,
+                            "pox_4_first_cycle" => pox_4_first_cycle,
+                        );
+                        let set_str = format!("(map-set aggregate-public-keys u{set_in_reward_cycle} 0x{hex_agg_pub_key})");
+                        signers_voting_code.push_str("\n");
+                        signers_voting_code.push_str(&set_str);
+                    }
+                }
+            }
+
             let signers_voting_contract_id = boot_code_id(SIGNERS_VOTING_NAME, mainnet);
             let payload = TransactionPayload::SmartContract(
                 TransactionSmartContract {
                     name: ContractName::try_from(SIGNERS_VOTING_NAME)
                         .expect("FATAL: invalid boot-code contract name"),
-                    code_body: StacksString::from_str(signers_voting_code)
+                    code_body: StacksString::from_str(&signers_voting_code)
                         .expect("FATAL: invalid boot code body"),
                 },
                 Some(ClarityVersion::Clarity2),
diff --git a/stackslib/src/net/p2p.rs b/stackslib/src/net/p2p.rs
index 695898d86b..15d54c8382 100644
--- a/stackslib/src/net/p2p.rs
+++ b/stackslib/src/net/p2p.rs
@@ -3949,14 +3949,14 @@ impl PeerNetwork {
                     self.nakamoto_work_state = PeerNetworkWorkState::BlockDownload;
                 }
                 PeerNetworkWorkState::BlockDownload => {
-                    info!(
+                    debug!(
                         "{:?}: Block download for Nakamoto is not yet implemented",
                         self.get_local_peer()
                     );
                     self.nakamoto_work_state = PeerNetworkWorkState::AntiEntropy;
                 }
                 PeerNetworkWorkState::AntiEntropy => {
-                    info!(
+                    debug!(
                         "{:?}: Block anti-entropy for Nakamoto is not yet implemented",
                         self.get_local_peer()
                     );
diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index ce6efdd997..e89d066f29 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -836,7 +836,7 @@ impl MockamotoNode {
             Some(AddressHashMode::SerializeP2PKH),
         );
 
-        let signer_sk = Secp256k1PrivateKey::from_seed(&miner_nonce.to_be_bytes());
+        let signer_sk = Secp256k1PrivateKey::from_seed(&[1, 2, 3, 4]);
         let signer_key = Secp256k1PublicKey::from_private(&signer_sk).to_bytes_compressed();
         let signer_addr = StacksAddress::from_public_keys(
             C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
@@ -925,14 +925,11 @@ impl MockamotoNode {
             )?;
             StacksChainState::get_nonce(&mut clarity_conn, &signer_addr)
         };
-        let aggregate_public_key_val = ClarityValue::buff_from(
-            self.self_signer
-                .aggregate_public_key
-                .compress()
-                .data
-                .to_vec(),
-        )
-        .expect("Failed to serialize aggregate public key");
+        let mut next_signer = self.self_signer.clone();
+        let next_agg_key = next_signer.generate_aggregate_key(reward_cycle + 1);
+        let aggregate_public_key_val =
+            ClarityValue::buff_from(next_agg_key.compress().data.to_vec())
+                .expect("Failed to serialize aggregate public key");
         let vote_payload = TransactionPayload::new_contract_call(
             boot_code_addr(false),
             SIGNERS_VOTING_NAME,
diff --git a/testnet/stacks-node/src/mockamoto/tests.rs b/testnet/stacks-node/src/mockamoto/tests.rs
index f1020cf35f..58df8f6ead 100644
--- a/testnet/stacks-node/src/mockamoto/tests.rs
+++ b/testnet/stacks-node/src/mockamoto/tests.rs
@@ -6,6 +6,7 @@ use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::nakamoto::NakamotoChainState;
 use stacks::chainstate::stacks::db::StacksChainState;
 use stacks_common::types::chainstate::{StacksAddress, StacksPrivateKey};
+use stacks_common::types::net::PeerAddress;
 use stacks_common::types::StacksEpochId;
 use stacks_common::util::get_epoch_time_secs;
 use stacks_common::util::hash::to_hex;
@@ -26,6 +27,7 @@ fn observe_100_blocks() {
     );
     conf.node.rpc_bind = "127.0.0.1:19343".into();
     conf.node.p2p_bind = "127.0.0.1:19344".into();
+    conf.connection_options.public_ip_address = Some((PeerAddress::from_ipv4(127, 0, 0, 1), 20443));
     conf.node.mockamoto_time_ms = 10;
 
     let submitter_sk = StacksPrivateKey::from_seed(&[1]);
@@ -236,6 +238,9 @@ fn mempool_rpc_submit() {
 fn observe_set_aggregate_key() {
     let mut conf = Config::from_config_file(ConfigFile::mockamoto()).unwrap();
     conf.node.mockamoto_time_ms = 10;
+    conf.node.p2p_bind = "127.0.0.1:20443".into();
+    conf.node.rpc_bind = "127.0.0.1:20444".into();
+    conf.connection_options.public_ip_address = Some((PeerAddress::from_ipv4(127, 0, 0, 1), 20443));
 
     let submitter_sk = StacksPrivateKey::from_seed(&[1]);
     let submitter_addr = to_addr(&submitter_sk);
@@ -249,8 +254,7 @@ fn observe_set_aggregate_key() {
     });
 
     let mut mockamoto = MockamotoNode::new(&conf).unwrap();
-    // Get the aggregate public key of the original reward cycle to compare against
-    let orig_key = mockamoto.self_signer.aggregate_public_key;
+    let mut signer = mockamoto.self_signer.clone();
 
     let globals = mockamoto.globals.clone();
 
@@ -280,6 +284,10 @@ fn observe_set_aggregate_key() {
             .as_str(),
         );
 
+    // Get the aggregate public key of the original reward cycle to compare against
+    let expected_cur_key = signer.generate_aggregate_key(reward_cycle);
+    let expected_next_key = signer.generate_aggregate_key(reward_cycle + 1);
+
     let node_thread = thread::Builder::new()
         .name("mockamoto-main".into())
         .spawn(move || {
@@ -342,8 +350,8 @@ fn observe_set_aggregate_key() {
     );
 
     // Did we set and retrieve the aggregate key correctly?
-    assert_eq!(orig_aggregate_key.unwrap(), orig_key);
-    assert_eq!(new_aggregate_key.unwrap(), orig_key);
+    assert_eq!(orig_aggregate_key.unwrap(), expected_cur_key);
+    assert_eq!(new_aggregate_key.unwrap(), expected_next_key);
 }
 
 #[test]

From 018ea78975069829b87896143efd08dfe2cdc03e Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Sun, 18 Feb 2024 23:47:21 -0500
Subject: [PATCH 0801/1166] fix: handle signer voting in nakamoto integration
 tests (WIP)

---
 .../stacks-node/src/nakamoto_node/miner.rs    |   6 +-
 .../src/tests/nakamoto_integrations.rs        | 138 +++++++++++++++++-
 2 files changed, 134 insertions(+), 10 deletions(-)

diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index 73abc879fc..2481463de9 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -432,12 +432,10 @@ impl BlockMinerThread {
         )
         .expect("FATAL: could not open sortition DB");
 
-        // Check if we need to update the signer key. This key needs to change
-        // on each tenure change or it will not match the public key that is
-        // retrieved from the signers contract.
+        let burn_height = self.burn_block.block_height;
         let cycle = self
             .burnchain
-            .block_height_to_reward_cycle(block.header.chain_length)
+            .block_height_to_reward_cycle(burn_height)
             .expect("FATAL: no reward cycle for burn block");
         signer.sign_nakamoto_block(&mut block, cycle);
 
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 7b0c0c21ab..d9deff84b6 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -30,7 +30,7 @@ use stacks::chainstate::nakamoto::miner::NakamotoBlockBuilder;
 use stacks::chainstate::nakamoto::test_signers::TestSigners;
 use stacks::chainstate::nakamoto::{NakamotoBlock, NakamotoChainState};
 use stacks::chainstate::stacks::address::PoxAddress;
-use stacks::chainstate::stacks::boot::MINERS_NAME;
+use stacks::chainstate::stacks::boot::{MINERS_NAME, SIGNERS_VOTING_NAME};
 use stacks::chainstate::stacks::db::StacksChainState;
 use stacks::chainstate::stacks::miner::{BlockBuilder, BlockLimitFunction, TransactionResult};
 use stacks::chainstate::stacks::{StacksTransaction, ThresholdSignature, TransactionPayload};
@@ -423,6 +423,50 @@ pub fn boot_to_epoch_3(
         submit_tx(&http_origin, &stacking_tx);
     }
 
+    let prepare_phase_start = btc_regtest_controller
+        .get_burnchain()
+        .pox_constants
+        .prepare_phase_start(
+            btc_regtest_controller.get_burnchain().first_block_height,
+            reward_cycle,
+        );
+
+    // Run until the prepare phase
+    run_until_burnchain_height(
+        btc_regtest_controller,
+        &blocks_processed,
+        prepare_phase_start,
+        &naka_conf,
+    );
+
+    // If we are self-signing, then we need to vote on the aggregate public key
+    if let Some(mut signers) = naka_conf.self_signing() {
+        // Get the aggregate key
+        let aggregate_key = signers.generate_aggregate_key(reward_cycle + 1);
+        let aggregate_public_key =
+            clarity::vm::Value::buff_from(aggregate_key.compress().data.to_vec())
+                .expect("Failed to serialize aggregate public key");
+
+        // Vote on the aggregate public key
+        for (i, signer_sk) in signer_sks.iter().enumerate() {
+            let voting_tx = tests::make_contract_call(
+                &signer_sk,
+                0,
+                300,
+                &StacksAddress::burn_address(false),
+                SIGNERS_VOTING_NAME,
+                "vote-for-aggregate-public-key",
+                &[
+                    clarity::vm::Value::UInt(i as u128),
+                    aggregate_public_key.clone(),
+                    clarity::vm::Value::UInt(0),
+                    clarity::vm::Value::UInt(reward_cycle as u128 + 1),
+                ],
+            );
+            submit_tx(&http_origin, &voting_tx);
+        }
+    }
+
     run_until_burnchain_height(
         btc_regtest_controller,
         &blocks_processed,
@@ -433,6 +477,61 @@ pub fn boot_to_epoch_3(
     info!("Bootstrapped to Epoch-3.0 boundary, Epoch2x miner should stop");
 }
 
+fn signer_vote_if_needed(
+    btc_regtest_controller: &BitcoinRegtestController,
+    naka_conf: &Config,
+    signer_sks: &[StacksPrivateKey], // TODO: Is there some way to get this from the TestSigners?
+) {
+    if let Some(mut signers) = naka_conf.self_signing() {
+        // When we reach the next prepare phase, submit new voting transactions
+        let block_height = btc_regtest_controller.get_headers_height();
+        let reward_cycle = btc_regtest_controller
+            .get_burnchain()
+            .block_height_to_reward_cycle(block_height)
+            .unwrap();
+        let prepare_phase_start = btc_regtest_controller
+            .get_burnchain()
+            .pox_constants
+            .prepare_phase_start(
+                btc_regtest_controller.get_burnchain().first_block_height,
+                reward_cycle,
+            );
+
+        // TODO: Check if the vote has already happened
+        if block_height >= prepare_phase_start {
+            // If we are self-signing, then we need to vote on the aggregate public key
+            let http_origin = format!("http://{}", &naka_conf.node.rpc_bind);
+
+            // Get the aggregate key
+            let aggregate_key = signers.generate_aggregate_key(reward_cycle + 1);
+            let aggregate_public_key =
+                clarity::vm::Value::buff_from(aggregate_key.compress().data.to_vec())
+                    .expect("Failed to serialize aggregate public key");
+
+            for (i, signer_sk) in signer_sks.iter().enumerate() {
+                let signer_nonce = get_account(&http_origin, &to_addr(signer_sk)).nonce;
+
+                // Vote on the aggregate public key
+                let voting_tx = tests::make_contract_call(
+                    &signer_sk,
+                    signer_nonce,
+                    300,
+                    &StacksAddress::burn_address(false),
+                    SIGNERS_VOTING_NAME,
+                    "vote-for-aggregate-public-key",
+                    &[
+                        clarity::vm::Value::UInt(i as u128),
+                        aggregate_public_key.clone(),
+                        clarity::vm::Value::UInt(0),
+                        clarity::vm::Value::UInt(reward_cycle as u128 + 1),
+                    ],
+                );
+                submit_tx(&http_origin, &voting_tx);
+            }
+        }
+    }
+}
+
 #[test]
 #[ignore]
 /// This test spins up a nakamoto-neon node.
@@ -455,13 +554,18 @@ fn simple_neon_integration() {
     let sender_sk = Secp256k1PrivateKey::new();
     // setup sender + recipient for a test stx transfer
     let sender_addr = tests::to_addr(&sender_sk);
-    let sender_signer_sk = Secp256k1PrivateKey::new();
     let send_amt = 1000;
     let send_fee = 100;
     naka_conf.add_initial_balance(
         PrincipalData::from(sender_addr.clone()).to_string(),
         send_amt + send_fee,
     );
+    let sender_signer_sk = Secp256k1PrivateKey::new();
+    let sender_signer_addr = tests::to_addr(&sender_signer_sk);
+    naka_conf.add_initial_balance(
+        PrincipalData::from(sender_signer_addr.clone()).to_string(),
+        100000,
+    );
     let recipient = PrincipalData::from(StacksAddress::burn_address(false));
     let stacker_sk = setup_stacker(&mut naka_conf);
 
@@ -557,6 +661,8 @@ fn simple_neon_integration() {
             &commits_submitted,
         )
         .unwrap();
+
+        signer_vote_if_needed(&btc_regtest_controller, &naka_conf, &[sender_signer_sk]);
     }
 
     // Submit a TX
@@ -592,6 +698,8 @@ fn simple_neon_integration() {
             &commits_submitted,
         )
         .unwrap();
+
+        signer_vote_if_needed(&btc_regtest_controller, &naka_conf, &[sender_signer_sk]);
     }
 
     // load the chain tip, and assert that it is a nakamoto block and at least 30 blocks have advanced in epoch 3
@@ -667,7 +775,8 @@ fn mine_multiple_per_tenure_integration() {
     let http_origin = format!("http://{}", &naka_conf.node.rpc_bind);
     naka_conf.miner.wait_on_interim_blocks = Duration::from_secs(1);
     let sender_sk = Secp256k1PrivateKey::new();
-    let sender_signer_key = Secp256k1PrivateKey::new();
+    let sender_signer_sk = Secp256k1PrivateKey::new();
+    let sender_signer_addr = tests::to_addr(&sender_signer_sk);
     let tenure_count = 5;
     let inter_blocks_per_tenure = 9;
     // setup sender + recipient for some test stx transfers
@@ -679,6 +788,10 @@ fn mine_multiple_per_tenure_integration() {
         PrincipalData::from(sender_addr.clone()).to_string(),
         (send_amt + send_fee) * tenure_count * inter_blocks_per_tenure,
     );
+    naka_conf.add_initial_balance(
+        PrincipalData::from(sender_signer_addr.clone()).to_string(),
+        100000,
+    );
     let recipient = PrincipalData::from(StacksAddress::burn_address(false));
     let stacker_sk = setup_stacker(&mut naka_conf);
 
@@ -716,7 +829,7 @@ fn mine_multiple_per_tenure_integration() {
         &naka_conf,
         &blocks_processed,
         &[stacker_sk],
-        &[sender_signer_key],
+        &[sender_signer_sk],
         &mut btc_regtest_controller,
     );
 
@@ -1116,6 +1229,12 @@ fn block_proposal_api_endpoint() {
     let (mut conf, _miner_account) = naka_neon_integration_conf(None);
     let account_keys = add_initial_balances(&mut conf, 10, 1_000_000);
     let stacker_sk = setup_stacker(&mut conf);
+    let sender_signer_sk = Secp256k1PrivateKey::new();
+    let sender_signer_addr = tests::to_addr(&sender_signer_sk);
+    conf.add_initial_balance(
+        PrincipalData::from(sender_signer_addr.clone()).to_string(),
+        100000,
+    );
 
     // only subscribe to the block proposal events
     test_observer::spawn();
@@ -1149,7 +1268,7 @@ fn block_proposal_api_endpoint() {
         &conf,
         &blocks_processed,
         &[stacker_sk],
-        &[StacksPrivateKey::default()],
+        &[sender_signer_sk],
         &mut btc_regtest_controller,
     );
 
@@ -1467,6 +1586,13 @@ fn miner_writes_proposed_block_to_stackerdb() {
     );
     let stacker_sk = setup_stacker(&mut naka_conf);
 
+    let sender_signer_sk = Secp256k1PrivateKey::new();
+    let sender_signer_addr = tests::to_addr(&sender_signer_sk);
+    naka_conf.add_initial_balance(
+        PrincipalData::from(sender_signer_addr.clone()).to_string(),
+        100000,
+    );
+
     test_observer::spawn();
     let observer_port = test_observer::EVENT_OBSERVER_PORT;
     naka_conf.events_observers.insert(EventObserverConfig {
@@ -1498,7 +1624,7 @@ fn miner_writes_proposed_block_to_stackerdb() {
         &naka_conf,
         &blocks_processed,
         &[stacker_sk],
-        &[StacksPrivateKey::default()],
+        &[sender_signer_sk],
         &mut btc_regtest_controller,
     );
 

From 024cd712b47818f4f4726b38678165fe754b1ffb Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Mon, 19 Feb 2024 10:30:11 -0500
Subject: [PATCH 0802/1166] fix: update `correct_burn_outs` for new signer
 voting support

---
 .../src/tests/nakamoto_integrations.rs        | 46 +++++++++++++++----
 1 file changed, 36 insertions(+), 10 deletions(-)

diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index d9deff84b6..bf573772d7 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -54,8 +54,7 @@ use stacks_common::consts::{CHAIN_ID_TESTNET, STACKS_EPOCH_MAX};
 use stacks_common::types::chainstate::{
     BlockHeaderHash, StacksAddress, StacksPrivateKey, StacksPublicKey,
 };
-use stacks_common::types::PrivateKey;
-use stacks_common::util::hash::{to_hex, Sha512Sum};
+use stacks_common::util::hash::to_hex;
 use stacks_common::util::secp256k1::{MessageSignature, Secp256k1PrivateKey};
 
 use super::bitcoin_regtest::BitcoinCoreController;
@@ -977,6 +976,12 @@ fn correct_burn_outs() {
     }
 
     let stacker_accounts = accounts[0..3].to_vec();
+    let sender_signer_sk = Secp256k1PrivateKey::new();
+    let sender_signer_addr = tests::to_addr(&sender_signer_sk);
+    naka_conf.add_initial_balance(
+        PrincipalData::from(sender_signer_addr.clone()).to_string(),
+        100000,
+    );
 
     test_observer::spawn();
     let observer_port = test_observer::EVENT_OBSERVER_PORT;
@@ -1030,6 +1035,7 @@ fn correct_burn_outs() {
     next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
 
     let http_origin = format!("http://{}", &naka_conf.node.rpc_bind);
+    let stacker_accounts_copy = stacker_accounts.clone();
     let _stacker_thread = thread::Builder::new()
         .name("stacker".into())
         .spawn(move || loop {
@@ -1053,7 +1059,7 @@ fn correct_burn_outs() {
                 );
                 continue;
             }
-            let Some(account) = stacker_accounts.iter().find_map(|(sk, addr)| {
+            let Some(account) = stacker_accounts_copy.iter().find_map(|(sk, addr)| {
                 let account = get_account(&http_origin, &addr);
                 if account.locked == 0 {
                     Some((sk, addr, account))
@@ -1070,17 +1076,12 @@ fn correct_burn_outs() {
             );
             let pox_addr_tuple: clarity::vm::Value =
                 pox_addr.clone().as_clarity_tuple().unwrap().into();
-            // create a new SK, mixing in the nonce, because signing keys cannot (currently)
-            //  be reused.
-            let mut seed_inputs = account.0.to_bytes();
-            seed_inputs.extend_from_slice(&account.2.nonce.to_be_bytes());
-            let new_sk = StacksPrivateKey::from_seed(Sha512Sum::from_data(&seed_inputs).as_bytes());
-            let pk_bytes = StacksPublicKey::from_private(&new_sk).to_bytes_compressed();
+            let pk_bytes = StacksPublicKey::from_private(&sender_signer_sk).to_bytes_compressed();
 
             let reward_cycle = pox_info.current_cycle.id;
             let signature = make_pox_4_signer_key_signature(
                 &pox_addr,
-                &new_sk,
+                &sender_signer_sk,
                 reward_cycle.into(),
                 &Pox4SignatureTopic::StackStx,
                 CHAIN_ID_TESTNET,
@@ -1111,6 +1112,29 @@ fn correct_burn_outs() {
         })
         .unwrap();
 
+    let block_height = btc_regtest_controller.get_headers_height();
+    let reward_cycle = btc_regtest_controller
+        .get_burnchain()
+        .block_height_to_reward_cycle(block_height)
+        .unwrap();
+    let prepare_phase_start = btc_regtest_controller
+        .get_burnchain()
+        .pox_constants
+        .prepare_phase_start(
+            btc_regtest_controller.get_burnchain().first_block_height,
+            reward_cycle,
+        );
+
+    // Run until the prepare phase
+    run_until_burnchain_height(
+        &mut btc_regtest_controller,
+        &blocks_processed,
+        prepare_phase_start,
+        &naka_conf,
+    );
+
+    signer_vote_if_needed(&btc_regtest_controller, &naka_conf, &[sender_signer_sk]);
+
     run_until_burnchain_height(
         &mut btc_regtest_controller,
         &blocks_processed,
@@ -1179,6 +1203,8 @@ fn correct_burn_outs() {
             tip_sn.block_height > prior_tip,
             "The new burnchain tip must have been processed"
         );
+
+        signer_vote_if_needed(&btc_regtest_controller, &naka_conf, &[sender_signer_sk]);
     }
 
     coord_channel

From e22aa760b5391853a51e1b0230d53372b3b2a5a8 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Mon, 19 Feb 2024 07:51:15 -0800
Subject: [PATCH 0803/1166] fix: remove unused function left from refactoring

---
 stackslib/src/chainstate/stacks/boot/mod.rs | 11 -----------
 1 file changed, 11 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 2c5ee5cc4d..5e3b026914 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -1997,17 +1997,6 @@ pub mod test {
         make_tx(key, nonce, 0, payload)
     }
 
-    pub fn make_pox_4_extend_delete_this(
-        key: &StacksPrivateKey,
-        nonce: u64,
-        addr: PoxAddress,
-        lock_period: u128,
-        signer_key: StacksPublicKey,
-        signature: Vec<u8>,
-    ) -> StacksTransaction {
-        make_pox_4_extend(key, nonce, addr, lock_period, signer_key, Some(signature))
-    }
-
     pub fn make_pox_4_extend(
         key: &StacksPrivateKey,
         nonce: u64,

From 99c576569667abf268a70645d3ee9183b5d2b35c Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Mon, 19 Feb 2024 08:11:33 -0800
Subject: [PATCH 0804/1166] feat: comment and use constants in
 `set-signer-key-authorization`

---
 .../src/chainstate/stacks/boot/pox-4.clar     | 25 ++++++++++++++++---
 1 file changed, 21 insertions(+), 4 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index f04ee6f1a6..c0d89be9a4 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -44,6 +44,11 @@
 (define-constant ADDRESS_VERSION_NATIVE_P2WPKH 0x04)
 (define-constant ADDRESS_VERSION_NATIVE_P2WSH 0x05)
 (define-constant ADDRESS_VERSION_NATIVE_P2TR 0x06)
+
+;; Values for stacks address versions
+(define-constant STACKS_ADDR_VERSION_MAINNET 0x16)
+(define-constant STACKS_ADDR_VERSION_TESTNET 0x1a)
+
 ;; Keep these constants in lock-step with the address version buffs above
 ;; Maximum value of an address version as a uint
 (define-constant MAX_ADDRESS_VERSION u6)
@@ -211,17 +216,29 @@
 ;;   for the given reward cycle
 (define-map aggregate-public-keys uint (buff 33))
 
-;; State for setting allowances for signer keys to be used in
-;; certain stacking transactions
+;; State for setting authorizations for signer keys to be used in
+;; certain stacking transactions. These fields match the fields used
+;; in the message hash for signature-based signer key authorizations.
+;; Values in this map are set in `set-signer-key-authorization`.
 (define-map signer-key-authorizations 
     {
+        ;; The signer key being authorized
         signer-key: (buff 33),
+        ;; The reward cycle for which the authorization is valid.
+        ;; For `stack-stx` and `stack-extend`, this refers to the reward
+        ;; cycle where the transaction is confirmed. For `stack-aggregation-commit`,
+        ;; this refers to the reward cycle argument in that function.
         reward-cycle: uint,
+        ;; For `stack-stx`, this refers to `lock-period`. For `stack-extend`,
+        ;; this refers to `extend-count`. For `stack-aggregation-commit`, this is `u1`.
         period: uint,
+        ;; A string representing the function where this authorization is valid. Either
+        ;; `stack-stx`, `stack-extend`, or `agg-commit`.
         topic: (string-ascii 12),
+        ;; The PoX address that can be used with this signer key
         pox-addr: { version: (buff 1), hashbytes: (buff 32) },
     } 
-    bool
+    bool ;; Whether the authorization can be used or not
 )
 
 ;; What's the reward cycle number of the burnchain block height?
@@ -1339,7 +1356,7 @@
   (begin
     ;; Validate that `tx-sender` has the same pubkey hash as `signer-key`
     (asserts! (is-eq 
-      (unwrap! (principal-construct? (if is-in-mainnet 0x16 0x1a) (hash160 signer-key)) (err ERR_INVALID_SIGNER_KEY))
+      (unwrap! (principal-construct? (if is-in-mainnet STACKS_ADDR_VERSION_MAINNET STACKS_ADDR_VERSION_TESTNET) (hash160 signer-key)) (err ERR_INVALID_SIGNER_KEY))
       tx-sender) (err ERR_NOT_ALLOWED))
     (map-set signer-key-authorizations { pox-addr: pox-addr, period: period, reward-cycle: reward-cycle, topic: topic, signer-key: signer-key } allowed)
     (ok allowed)))

From bd5ccec6871786f66f8301868be42ce6de161be8 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Sat, 10 Feb 2024 17:04:33 -0500
Subject: [PATCH 0805/1166] chore: Drop support for old (pre-`x86-64-v3`) CPUs

---
 .cargo/config | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/.cargo/config b/.cargo/config
index f208bb1d2d..efc2ce886d 100644
--- a/.cargo/config
+++ b/.cargo/config
@@ -2,7 +2,12 @@
 stacks-node = "run --package stacks-node --"
 fmt-stacks = "fmt -- --config group_imports=StdExternalCrate,imports_granularity=Module"
 
+# Build for modern x86_64 CPUs to take advantage of newer instructions
+[target.'cfg(all(target_arch = "x86_64"))']
+rustflags = ["-Ctarget-cpu=x86-64-v3"]
+
 # Needed by perf to generate flamegraphs.
 #[target.x86_64-unknown-linux-gnu]
 #linker = "/usr/bin/clang"
 #rustflags = ["-Clink-arg=-fuse-ld=lld", "-Clink-arg=-Wl,--no-rosegment"]
+

From 5b6d32847a1aa28bb52ecc537103c3e6707bb81c Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Wed, 14 Feb 2024 19:57:41 -0500
Subject: [PATCH 0806/1166] chore: For x86_64 arch, default to
 `--target-cpu=native` for local builds, and use `x86-64` and x86-64-v3` for
 releases

---
 .cargo/config                                 |  6 +-
 .../workflows/create-source-binary-x64.yml    | 78 +++++++++++++++++++
 .github/workflows/create-source-binary.yml    |  2 +-
 .github/workflows/github-release.yml          | 17 ++++
 build-scripts/Dockerfile.linux-glibc-x64      |  5 +-
 build-scripts/Dockerfile.linux-musl-x64       |  5 +-
 build-scripts/Dockerfile.macos-x64            |  4 +-
 build-scripts/Dockerfile.windows-x64          |  2 +
 8 files changed, 113 insertions(+), 6 deletions(-)
 create mode 100644 .github/workflows/create-source-binary-x64.yml

diff --git a/.cargo/config b/.cargo/config
index efc2ce886d..38785b2bf0 100644
--- a/.cargo/config
+++ b/.cargo/config
@@ -2,9 +2,11 @@
 stacks-node = "run --package stacks-node --"
 fmt-stacks = "fmt -- --config group_imports=StdExternalCrate,imports_granularity=Module"
 
-# Build for modern x86_64 CPUs to take advantage of newer instructions
+# For x86_64 CPUs, default to `native` and override in CI for release builds
+# This makes it slightly faster for users running locally built binaries
+# TODO: Same for other targets?
 [target.'cfg(all(target_arch = "x86_64"))']
-rustflags = ["-Ctarget-cpu=x86-64-v3"]
+rustflags = ["-Ctarget-cpu=native"]
 
 # Needed by perf to generate flamegraphs.
 #[target.x86_64-unknown-linux-gnu]
diff --git a/.github/workflows/create-source-binary-x64.yml b/.github/workflows/create-source-binary-x64.yml
new file mode 100644
index 0000000000..a1b435aa5f
--- /dev/null
+++ b/.github/workflows/create-source-binary-x64.yml
@@ -0,0 +1,78 @@
+## Github workflow to create multiarch binaries from source
+
+name: Create Binaries for x86_64
+
+on:
+  workflow_call:
+    inputs:
+      tag:
+        description: "Tag name of this release (x.y.z)"
+        required: true
+        type: string
+      arch:
+        description: "Stringified JSON object listing of platform matrix"
+        required: false
+        type: string
+        default: >-
+          ["linux-glibc-x64", "linux-musl-x64", "macos-x64", "windows-x64"]
+      cpu:
+        description: "Stringified JSON object listing of target CPU matrix"
+        required: false
+        type: string
+        default: >-
+          ["x86-64", "x86-64-v3"]
+
+## change the display name to the tag being built
+run-name: ${{ inputs.tag }}
+
+concurrency:
+  group: create-binary-${{ github.head_ref || github.ref || github.run_id}}
+  ## Only cancel in progress if this is for a PR
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
+jobs:
+  ## Runs when the following is true:
+  ##  - tag is provided
+  ##  - workflow is building default branch (master)
+  artifact:
+    if: |
+      inputs.tag != '' && 
+      github.ref == format('refs/heads/{0}', github.event.repository.default_branch)
+    name: Build Binaries
+    runs-on: ubuntu-latest
+    strategy:
+      ## Run a maximum of 10 builds concurrently, using the matrix defined in inputs.arch
+      max-parallel: 10
+      matrix:
+        platform: ${{ fromJson(inputs.arch) }}
+        cpu: ${{ fromJson(inputs.cpu) }}
+    steps:
+      ## Setup Docker for the builds
+      - name: Docker setup
+        uses: stacks-network/actions/docker@main
+
+      ## Build the binaries using defined dockerfiles
+      - name: Build Binary (${{ matrix.platform }}_${{ matrix.cpu }})
+        id: build_binaries
+        uses: docker/build-push-action@0565240e2d4ab88bba5387d719585280857ece09 # 5.0.0
+        with:
+          file: build-scripts/Dockerfile.${{ matrix.platform }}
+          outputs: type=local,dest=./release/${{ matrix.platform }}
+          build-args: |
+            STACKS_NODE_VERSION=${{ inputs.tag || env.GITHUB_SHA_SHORT }}
+            OS_ARCH=${{ matrix.platform }}
+            TARGET_CPU=${{ matrix.cpu }}
+            GIT_BRANCH=${{ env.GITHUB_REF_SHORT }}
+            GIT_COMMIT=${{ env.GITHUB_SHA_SHORT }}
+
+      ## Compress the binary artifact
+      - name: Compress artifact
+        id: compress_artifact
+        run: zip --junk-paths ${{ matrix.platform }}_${{ matrix.cpu }} ./release/${{ matrix.platform }}/*
+
+      ## Upload the binary artifact to the github action (used in `github-release.yml` to create a release)
+      - name: Upload artifact
+        id: upload_artifact
+        uses: actions/upload-artifact@a8a3f3ad30e3422c9c7b888a15615d19a852ae32 # v3.1.3
+        with:
+          path: ${{ matrix.platform }}_${{ matrix.cpu }}.zip
diff --git a/.github/workflows/create-source-binary.yml b/.github/workflows/create-source-binary.yml
index 8e32893f78..068170efc5 100644
--- a/.github/workflows/create-source-binary.yml
+++ b/.github/workflows/create-source-binary.yml
@@ -14,7 +14,7 @@ on:
         required: false
         type: string
         default: >-
-          ["linux-glibc-x64", "linux-musl-x64", "linux-glibc-arm64", "linux-glibc-armv7", "linux-musl-arm64", "linux-musl-armv7", "macos-x64", "macos-arm64", "windows-x64"]
+          ["linux-glibc-arm64", "linux-glibc-armv7", "linux-musl-arm64", "linux-musl-armv7"]
 
 ## change the display name to the tag being built
 run-name: ${{ inputs.tag }}
diff --git a/.github/workflows/github-release.yml b/.github/workflows/github-release.yml
index 14e7117a95..17d75b2d0e 100644
--- a/.github/workflows/github-release.yml
+++ b/.github/workflows/github-release.yml
@@ -36,6 +36,21 @@ jobs:
       tag: ${{ inputs.tag }}
     secrets: inherit
 
+  ## Build x86_64 binaries from source
+  ##
+  ## Runs when the following is true:
+  ##  - tag is provided
+  ##  - workflow is building default branch (master)
+  build-binaries-x64:
+    if: |
+      inputs.tag != '' && 
+      github.ref == format('refs/heads/{0}', github.event.repository.default_branch)
+    name: Build Binaries (x64_64)
+    uses: ./.github/workflows/create-source-binary-x64.yml
+    with:
+      tag: ${{ inputs.tag }}
+    secrets: inherit
+
   ## Runs when the following is true:
   ##  - tag is provided
   ##  - workflow is building default branch (master)
@@ -47,6 +62,7 @@ jobs:
     runs-on: ubuntu-latest
     needs:
       - build-binaries
+      - build-binaries-x64
     steps:
       ## Downloads the artifacts built in `create-source-binary.yml`
       - name: Download Artifacts
@@ -95,6 +111,7 @@ jobs:
     uses: ./.github/workflows/image-build-binary.yml
     needs:
       - build-binaries
+      - build-binaries-x64
       - create-release
     with:
       tag: ${{ inputs.tag }}
diff --git a/build-scripts/Dockerfile.linux-glibc-x64 b/build-scripts/Dockerfile.linux-glibc-x64
index 7d0591023d..0e2bbdd9be 100644
--- a/build-scripts/Dockerfile.linux-glibc-x64
+++ b/build-scripts/Dockerfile.linux-glibc-x64
@@ -5,6 +5,8 @@ ARG GIT_BRANCH='No Branch Info'
 ARG GIT_COMMIT='No Commit Info'
 ARG BUILD_DIR=/build
 ARG TARGET=x86_64-unknown-linux-gnu
+# Allow us to override the default `--target-cpu` for the given target triplet
+ARG TARGET_CPU
 WORKDIR /src
 
 COPY . .
@@ -15,7 +17,8 @@ RUN apt-get update && apt-get install -y git
 RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
     && cd ${BUILD_DIR} \
     && rustup target add ${TARGET} \
-    && cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli \
+    ${TARGET_CPU:+RUSTFLAGS="$RUSTFLAGS $TARGET_CPU"} \
+    cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli \
     && mkdir -p /out \
     && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
 
diff --git a/build-scripts/Dockerfile.linux-musl-x64 b/build-scripts/Dockerfile.linux-musl-x64
index e34c629d62..d954708a0a 100644
--- a/build-scripts/Dockerfile.linux-musl-x64
+++ b/build-scripts/Dockerfile.linux-musl-x64
@@ -5,6 +5,8 @@ ARG GIT_BRANCH='No Branch Info'
 ARG GIT_COMMIT='No Commit Info'
 ARG BUILD_DIR=/build
 ARG TARGET=x86_64-unknown-linux-musl
+# Allow us to override the default `--target-cpu` for the given target triplet
+ARG TARGET_CPU
 WORKDIR /src
 
 COPY . .
@@ -15,7 +17,8 @@ RUN apk update && apk add git musl-dev
 RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
     && cd ${BUILD_DIR} \
     && rustup target add ${TARGET} \
-    && cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli \
+    ${TARGET_CPU:+RUSTFLAGS="$RUSTFLAGS $TARGET_CPU"} \
+    cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli \
     && mkdir -p /out \
     && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
 
diff --git a/build-scripts/Dockerfile.macos-x64 b/build-scripts/Dockerfile.macos-x64
index d73aa35f98..f61d0574e9 100644
--- a/build-scripts/Dockerfile.macos-x64
+++ b/build-scripts/Dockerfile.macos-x64
@@ -6,6 +6,7 @@ ARG GIT_COMMIT='No Commit Info'
 ARG BUILD_DIR=/build
 ARG OSXCROSS="https://github.com/hirosystems/docker-osxcross-rust/releases/download/MacOSX12.0.sdk/osxcross-d904031_MacOSX12.0.sdk.tar.zst"
 ARG TARGET=x86_64-apple-darwin
+ARG TARGET_CPU
 WORKDIR /src
 
 COPY . .
@@ -21,7 +22,8 @@ RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
     && cd ${BUILD_DIR} \
     && rustup target add ${TARGET} \
     && . /opt/osxcross/env-macos-x86_64 \
-    && cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli \
+    ${TARGET_CPU:+RUSTFLAGS="$RUSTFLAGS $TARGET_CPU"} \
+    cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli \
     && mkdir -p /out \
     && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
 
diff --git a/build-scripts/Dockerfile.windows-x64 b/build-scripts/Dockerfile.windows-x64
index c1f1e87a7e..3265c05b5c 100644
--- a/build-scripts/Dockerfile.windows-x64
+++ b/build-scripts/Dockerfile.windows-x64
@@ -5,6 +5,7 @@ ARG GIT_BRANCH='No Branch Info'
 ARG GIT_COMMIT='No Commit Info'
 ARG BUILD_DIR=/build
 ARG TARGET=x86_64-pc-windows-gnu
+ARG TARGET_CPU
 WORKDIR /src
 
 COPY . .
@@ -17,6 +18,7 @@ RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
     && rustup target add ${TARGET} \
     && CC_x86_64_pc_windows_gnu=x86_64-w64-mingw32-gcc \
     CARGO_TARGET_X86_64_PC_WINDOWS_GNU_LINKER=x86_64-w64-mingw32-gcc \
+    ${TARGET_CPU:+RUSTFLAGS="$RUSTFLAGS $TARGET_CPU"} \
     cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli \
     && mkdir -p /out \
     && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out

From 8bbffeb8512e8d99d5540f7c19799cfff442f287 Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Mon, 19 Feb 2024 12:42:01 -0500
Subject: [PATCH 0807/1166] chore: remove hard-coded block height in
 `boot_to_epoch_3`

---
 testnet/stacks-node/src/tests/nakamoto_integrations.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index bf573772d7..e197d16b9b 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -413,7 +413,7 @@ pub fn boot_to_epoch_3(
             &[
                 clarity::vm::Value::UInt(POX_4_DEFAULT_STACKER_STX_AMT),
                 pox_addr_tuple.clone(),
-                clarity::vm::Value::UInt(205),
+                clarity::vm::Value::UInt(block_height as u128),
                 clarity::vm::Value::UInt(12),
                 clarity::vm::Value::buff_from(signature).unwrap(),
                 clarity::vm::Value::buff_from(signer_pk.to_bytes_compressed()).unwrap(),

From 9229511485ebd0d753255f3456d11c7d7c5e5d36 Mon Sep 17 00:00:00 2001
From: ASuciuX <151519329+ASuciuX@users.noreply.github.com>
Date: Mon, 19 Feb 2024 19:45:52 +0200
Subject: [PATCH 0808/1166] feat: add function headers for timeout functions in
 'stacks-node'

---
 Cargo.lock                           | 1 +
 testnet/stacks-node/Cargo.toml       | 1 +
 testnet/stacks-node/src/config.rs    | 1 +
 testnet/stacks-node/src/globals.rs   | 2 ++
 testnet/stacks-node/src/mockamoto.rs | 2 ++
 5 files changed, 7 insertions(+)

diff --git a/Cargo.lock b/Cargo.lock
index 310598ff21..896fa2ae95 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3384,6 +3384,7 @@ dependencies = [
  "lazy_static",
  "libc",
  "libsigner",
+ "mutants",
  "pico-args",
  "rand 0.8.5",
  "rand_core 0.6.4",
diff --git a/testnet/stacks-node/Cargo.toml b/testnet/stacks-node/Cargo.toml
index ae53315a7f..0a5ebf36b7 100644
--- a/testnet/stacks-node/Cargo.toml
+++ b/testnet/stacks-node/Cargo.toml
@@ -44,6 +44,7 @@ stacks-signer = { path = "../../stacks-signer" }
 tracing = "0.1.37"
 tracing-subscriber = { version = "0.3.17", features = ["env-filter"] }
 wsts = {workspace = true}
+mutants = "0.0.3"
 
 [dependencies.rusqlite]
 version = "=0.24.2"
diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index 4a775399d6..97265b1722 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -544,6 +544,7 @@ impl Config {
     }
 
     /// Apply any test settings to this burnchain config struct
+    #[cfg_attr(test, mutants::skip)]
     fn apply_test_settings(&self, burnchain: &mut Burnchain) {
         if self.burnchain.get_bitcoin_network().1 == BitcoinNetworkType::Mainnet {
             return;
diff --git a/testnet/stacks-node/src/globals.rs b/testnet/stacks-node/src/globals.rs
index 5e126c2714..a6a2fdad3c 100644
--- a/testnet/stacks-node/src/globals.rs
+++ b/testnet/stacks-node/src/globals.rs
@@ -205,11 +205,13 @@ impl<T> Globals<T> {
     }
 
     /// Signal system-wide stop
+    #[cfg_attr(test, mutants::skip)]
     pub fn signal_stop(&self) {
         self.should_keep_running.store(false, Ordering::SeqCst);
     }
 
     /// Should we keep running?
+    #[cfg_attr(test, mutants::skip)]
     pub fn keep_running(&self) -> bool {
         self.should_keep_running.load(Ordering::SeqCst)
     }
diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index 77a0993b8f..239ebd4389 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -615,6 +615,7 @@ impl MockamotoNode {
         }
     }
 
+    #[cfg_attr(test, mutants::skip)]
     fn wait_for_stacks_block(&mut self, expected_length: u64) -> Result<(), ChainstateError> {
         while self.globals.keep_running() {
             let chain_length = match NakamotoChainState::get_canonical_block_header(
@@ -1022,6 +1023,7 @@ impl MockamotoNode {
         Ok(block)
     }
 
+    #[cfg_attr(test, mutants::skip)]
     fn mine_and_stage_block(&mut self) -> Result<u64, ChainstateError> {
         let mut block = self.mine_stacks_block()?;
         let config = self.chainstate.config();

From 6288b292e0c713105d83ec411c03aa5033f6503b Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Mon, 19 Feb 2024 17:08:09 -0500
Subject: [PATCH 0809/1166] feat: add check for new round numbers

For the first vote in a new round, only accept a round number that is
the last round + 1. This will help prevent bad actors trying to cause
problems with voting rounds.
---
 .../stacks/boot/signers-voting.clar           | 52 +++++++++++++------
 1 file changed, 35 insertions(+), 17 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers-voting.clar b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
index fbe1053c2d..8fd829ba95 100644
--- a/stackslib/src/chainstate/stacks/boot/signers-voting.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
@@ -17,11 +17,13 @@
 (define-constant ERR_DUPLICATE_VOTE u7)
 (define-constant ERR_INVALID_BURN_BLOCK_HEIGHT u8)
 (define-constant ERR_FAILED_TO_RETRIEVE_SIGNERS u9)
+(define-constant ERR_INVALID_ROUND u10)
 
 (define-constant pox-info
     (unwrap-panic (contract-call? .pox-4 get-pox-info)))
 
-;; Threshold consensus (in 3 digit %)
+;; Threshold consensus, expressed as parts-per-thousand to allow for integer
+;; division with higher precision (e.g. 700 for 70%).
 (define-constant threshold-consensus u700)
 
 ;; Maps reward-cycle ids to last round
@@ -97,30 +99,52 @@
             (map-set cycle-total-weight reward-cycle total)
             (ok total))))
 
+(define-private (update-last-round (reward-cycle uint) (round uint))
+    (ok (match (map-get? rounds reward-cycle)
+        last-round (begin
+            (asserts! (<= round (+ last-round u1)) (err ERR_INVALID_ROUND))
+            (and (> round last-round) (map-set rounds reward-cycle round)))
+        (map-set rounds reward-cycle round))))
+
 ;; Signer vote for the aggregate public key of the next reward cycle
-;;  The vote happens in the prepare phase of the current reward cycle but may be ran more than
-;;  once resulting in different 'rounds.' Each signer vote is based on the weight of stacked
-;;  stx tokens & fetched from the .signers contract. The vote is ran until the consensus 
-;;  threshold of 70% for a specific aggregate public key is reached.
+;;  Each signer votes for the aggregate public key for the next reward cycle.
+;;  This vote must happen after the list of signers has been set by the node,
+;;  which occurs in the first block of the prepare phase. The vote is concluded
+;;  when the threshold of `threshold-consensus / 1000` is reached for a
+;;  specific aggregate public key. The vote is weighted by the amount of
+;;  reward slots that the signer controls in the next reward cycle. The vote
+;;  may require multiple rounds to reach consensus, but once consensus is
+;;  reached, later rounds will be ignored.
+;;
+;;  Arguments:
+;;   * signer-index: the index of the calling signer in the signer set (from
+;;     `get-signers` in the .signers contract)
+;;   * key: the aggregate public key that this vote is in support of
+;;   * round: the voting round for which this vote is intended
+;;   * reward-cycle: the reward cycle for which this vote is intended
+;;  Returns:
+;;   * `(ok true)` if the vote was successful
+;;   * `(err <code>)` if the vote was not successful (see errors above)
 (define-public (vote-for-aggregate-public-key (signer-index uint) (key (buff 33)) (round uint) (reward-cycle uint))
     (let ((tally-key {reward-cycle: reward-cycle, round: round, aggregate-public-key: key})
             ;; vote by signer weight
             (signer-weight (try! (get-current-signer-weight signer-index)))
             (new-total (+ signer-weight (default-to u0 (map-get? tally tally-key))))
             (total-weight (try! (get-total-weight reward-cycle))))
-        ;; Check that key isn't already set
+        ;; Check that the key has not yet been set for this reward cycle
         (asserts! (is-none (map-get? aggregate-public-keys reward-cycle)) (err ERR_OUT_OF_VOTING_WINDOW))
-        ;; Check that the aggregate public key is correct length
+        ;; Check that the aggregate public key is the correct length
         (asserts! (is-eq (len key) u33) (err ERR_ILL_FORMED_AGGREGATE_PUBLIC_KEY))
-        ;; Check that aggregate public key has not been used before
+        ;; Check that aggregate public key has not been used in a previous reward cycle
         (asserts! (is-valid-aggregate-public-key key reward-cycle) (err ERR_DUPLICATE_AGGREGATE_PUBLIC_KEY))
-        ;; Check that signer hasn't voted in reward-cycle & round
+        ;; Check that signer hasn't voted in this reward-cycle & round
         (asserts! (map-insert votes {reward-cycle: reward-cycle, round: round, signer: tx-sender} {aggregate-public-key: key, signer-weight: signer-weight}) (err ERR_DUPLICATE_VOTE))
-        ;; Update tally aggregate public key candidate
+        ;; Check that the round is incremented by at most 1
+        (try! (update-last-round reward-cycle round))
+        ;; Update the tally for this aggregate public key candidate
         (map-set tally tally-key new-total)
         ;; Update used aggregate public keys
         (map-set used-aggregate-public-keys key reward-cycle)
-        (update-last-round reward-cycle round)
         (print {
             event: "voted",
             signer: tx-sender,
@@ -147,10 +171,4 @@
                 true
             )
         )
-
         (ok true)))
-
-(define-private (update-last-round (reward-cycle uint) (round uint))
-    (match (map-get? rounds reward-cycle)
-        last-round (and (> round last-round) (map-set rounds reward-cycle round))
-        (map-set rounds reward-cycle round)))

From 192fdd5abeba9620bf56bf703974c68417f9683b Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Sat, 17 Feb 2024 17:55:35 -0500
Subject: [PATCH 0810/1166] first error message check

---
 .../stacks/boot/signers_voting_tests.rs       | 28 +++++++++++++++++--
 1 file changed, 26 insertions(+), 2 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
index a8553e99fc..a5917b4f26 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
@@ -188,6 +188,15 @@ fn vote_for_aggregate_public_key_success() {
             0,
             cycle_id + 1,
         ),
+        // Alice casts vote twice
+        make_signers_vote_for_aggregate_public_key(
+            alice_key,
+            alice_nonce+1,
+            alice_index,
+            &aggregate_public_key,
+            0,
+            cycle_id + 1,
+        ),
         // Bob casts a vote for the aggregate public key
         make_signers_vote_for_aggregate_public_key(
             bob_key,
@@ -207,15 +216,17 @@ fn vote_for_aggregate_public_key_success() {
     // check the last two txs in the last block
     let block = observer.get_blocks().last().unwrap().clone();
     let receipts = block.receipts.as_slice();
-    assert_eq!(receipts.len(), 4);
+    assert_eq!(receipts.len(), 5);
     // ignore tenure change tx
     // ignore tenure coinbase tx
 
     // Alice's vote should succeed
     let alice_vote_tx = &receipts[2];
+    println!("alice_vote_tx: {:?}", alice_vote_tx);
     assert_eq!(alice_vote_tx.result, Value::okay_true());
     assert_eq!(alice_vote_tx.events.len(), 1);
     let alice_vote_event = &alice_vote_tx.events[0];
+    println!("alice_vote_event: {:?}", alice_vote_event);
     if let StacksTransactionEvent::SmartContractEvent(contract_event) = alice_vote_event {
         assert_eq!(
             contract_event.value,
@@ -239,10 +250,12 @@ fn vote_for_aggregate_public_key_success() {
     }
 
     // Bob's vote should succeed
-    let bob_vote_tx = &receipts[3];
+    let bob_vote_tx = &receipts[4];
+    println!("bob_vote_tx: {:?}", bob_vote_tx);
     assert_eq!(bob_vote_tx.result, Value::okay_true());
     assert_eq!(bob_vote_tx.events.len(), 2);
     let bob_vote_event = &bob_vote_tx.events[0];
+    println!("bob_vote_event: {:?}", bob_vote_event);
     if let StacksTransactionEvent::SmartContractEvent(contract_event) = bob_vote_event {
         assert_eq!(
             contract_event.value,
@@ -265,7 +278,18 @@ fn vote_for_aggregate_public_key_success() {
         panic!("Expected SmartContractEvent, got {:?}", bob_vote_event);
     }
 
+    // Bob vote should fail (duplicate vote)
+    let bob_vote_duplicate_tx = &receipts[3];
+    println!("bob_vote_duplicate_tx: {:?}", bob_vote_duplicate_tx);
+    let bob_vote_duplicate_tx_result = bob_vote_duplicate_tx.result.clone();
+    println!("bob_vote_duplicate_tx_result: {:?}", bob_vote_duplicate_tx_result);
+    assert_eq!(
+        bob_vote_duplicate_tx_result,
+        Value::err_uint(7) // err-duplicate-vote
+    );
+
     let approve_event = &bob_vote_tx.events[1];
+    println!("approve_event: {:?}", approve_event);
     if let StacksTransactionEvent::SmartContractEvent(contract_event) = approve_event {
         assert_eq!(
             contract_event.value,

From 2230776a9d1b073d64b63516e956b32f269c1272 Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Sun, 18 Feb 2024 08:42:53 -0500
Subject: [PATCH 0811/1166] refactored helper
 make_signers_vote_for_aggregate_public_key & effected funcs

---
 .../chainstate/nakamoto/coordinator/tests.rs  |   2 +-
 stackslib/src/chainstate/stacks/boot/mod.rs   |   6 +-
 .../stacks/boot/signers_voting_tests.rs       | 297 +++++++++++-------
 3 files changed, 190 insertions(+), 115 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index 4b468db8b9..53fd60e133 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -204,7 +204,7 @@ pub fn make_all_signers_vote_for_aggregate_key(
                 signer_key,
                 account.nonce,
                 *index as u128,
-                &test_signers.aggregate_public_key,
+                Value::buff_from(test_signers.aggregate_public_key.compress().data.to_vec()).expect("Failed to serialize aggregate public key"),
                 0,
                 cycle_id,
             )
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 52fd8e3236..f798220a0f 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -1907,14 +1907,14 @@ pub mod test {
         key: &StacksPrivateKey,
         nonce: u64,
         signer_index: u128,
-        aggregate_public_key: &Point,
+        aggregate_public_key: Value,
         round: u128,
         cycle: u128,
     ) -> StacksTransaction {
         debug!("Vote for aggregate key in cycle {}, round {}", cycle, round);
 
-        let aggregate_public_key = Value::buff_from(aggregate_public_key.compress().data.to_vec())
-            .expect("Failed to serialize aggregate public key");
+        // let aggregate_public_key = Value::buff_from(aggregate_public_key.compress().data.to_vec())
+        //     .expect("Failed to serialize aggregate public key");
         let payload = TransactionPayload::new_contract_call(
             boot_code_test_addr(),
             SIGNERS_VOTING_NAME,
diff --git a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
index a5917b4f26..74c3c462d5 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
@@ -141,18 +141,27 @@ pub fn prepare_pox4_test<'a>(
 /// and the key is accepted.
 #[test]
 fn vote_for_aggregate_public_key_success() {
+    // Test setup
     let alice = TestStacker::from_seed(&[3, 4]);
     let bob = TestStacker::from_seed(&[5, 6]);
+    let charlie = TestStacker::from_seed(&[7, 8]);
     let observer = TestEventObserver::new();
 
+    // Alice - Signer 1
     let alice_key = &alice.signer_private_key;
     let alice_address = key_to_stacks_addr(alice_key);
     let alice_principal = PrincipalData::from(alice_address);
 
+    // Bob - Signer 2
     let bob_key = &bob.signer_private_key;
     let bob_address = key_to_stacks_addr(bob_key);
     let bob_principal = PrincipalData::from(bob_address);
 
+    // Charlie - Doesn't register, throws invalid signer index
+    let charlie_key = &charlie.signer_private_key;
+    let charlie_address = key_to_stacks_addr(charlie_key);
+    let charlie_principal = PrincipalData::from(charlie_address);
+
     let (mut peer, mut test_signers, latest_block_id, current_reward_cycle) = prepare_signers_test(
         function_name!(),
         vec![
@@ -166,46 +175,78 @@ fn vote_for_aggregate_public_key_success() {
     // Alice and Bob will each have voted once while booting to Nakamoto
     let alice_nonce = 1;
     let bob_nonce = 1;
+    let charlie_nonce = 1;
 
     let cycle_id = current_reward_cycle;
 
     // create vote txs
     let alice_index = get_signer_index(&mut peer, latest_block_id, alice_address, cycle_id);
     let bob_index = get_signer_index(&mut peer, latest_block_id, bob_address, cycle_id);
+    println!("Alice index: {}", alice_index);
+    println!("Bob index: {}", bob_index);
+    let aggregate_public_key_point: Point = Point::new();
+    let aggregate_public_key = Value::buff_from(aggregate_public_key_point.compress().data.to_vec()).expect("Failed to serialize aggregate public key");
+    // let aggregate_public_key_value =
+    //     Value::buff_from(aggregate_public_key.compress().data.to_vec())
+    //         .expect("Failed to serialize aggregate public key");
 
-    let aggregate_public_key: Point = Point::new();
-    let aggregate_public_key_value =
-        Value::buff_from(aggregate_public_key.compress().data.to_vec())
-            .expect("Failed to serialize aggregate public key");
+    let aggregate_public_key_ill_formed = Value::buff_from_byte(0x00);
 
     let txs = vec![
-        // Alice casts a vote for the aggregate public key
+        // Alice casts a vote with a non-existant index - should return signer index mismatch error
         make_signers_vote_for_aggregate_public_key(
             alice_key,
             alice_nonce,
-            alice_index,
-            &aggregate_public_key,
+            bob_index,
+            aggregate_public_key.clone(),
             0,
             cycle_id + 1,
         ),
-        // Alice casts vote twice
+        // Alice casts a vote with Bobs index - should return invalid signer index error
         make_signers_vote_for_aggregate_public_key(
             alice_key,
             alice_nonce+1,
-            alice_index,
-            &aggregate_public_key,
+            2,
+            aggregate_public_key.clone(),
             0,
             cycle_id + 1,
         ),
-        // Bob casts a vote for the aggregate public key
-        make_signers_vote_for_aggregate_public_key(
-            bob_key,
-            bob_nonce,
-            bob_index,
-            &aggregate_public_key,
+         // Alice casts a vote with an invalid public key - should return ill-formed public key error
+         make_signers_vote_for_aggregate_public_key(
+            alice_key,
+            alice_nonce+2,
+            alice_index,
+            aggregate_public_key_ill_formed,
             0,
             cycle_id + 1,
         ),
+        // Alice casts vote twice - should return duplicate vote error
+        // make_signers_vote_for_aggregate_public_key(
+        //     alice_key,
+        //     alice_nonce+1,
+        //     alice_index,
+        //     &aggregate_public_key,
+        //     0,
+        //     cycle_id + 1,
+        // ),
+        // Charlie casts a vote for the aggregate public key - should return invalid signer index error
+        // make_signers_vote_for_aggregate_public_key(
+        //     charlie_key,
+        //     charlie_nonce,
+        //     2,
+        //     &aggregate_public_key,
+        //     0,
+        //     cycle_id + 1,
+        // ),
+        // Bob casts a vote with a non-existant index - should return signer index mismatch error
+        // make_signers_vote_for_aggregate_public_key(
+        //     bob_key,
+        //     bob_nonce,
+        //     2,
+        //     &aggregate_public_key,
+        //     0,
+        //     cycle_id + 1,
+        // ),
     ];
 
     //
@@ -220,96 +261,127 @@ fn vote_for_aggregate_public_key_success() {
     // ignore tenure change tx
     // ignore tenure coinbase tx
 
-    // Alice's vote should succeed
-    let alice_vote_tx = &receipts[2];
-    println!("alice_vote_tx: {:?}", alice_vote_tx);
-    assert_eq!(alice_vote_tx.result, Value::okay_true());
-    assert_eq!(alice_vote_tx.events.len(), 1);
-    let alice_vote_event = &alice_vote_tx.events[0];
-    println!("alice_vote_event: {:?}", alice_vote_event);
-    if let StacksTransactionEvent::SmartContractEvent(contract_event) = alice_vote_event {
-        assert_eq!(
-            contract_event.value,
-            TupleData::from_data(vec![
-                (
-                    "event".into(),
-                    Value::string_ascii_from_bytes("voted".as_bytes().to_vec())
-                        .expect("Failed to create string")
-                ),
-                ("key".into(), aggregate_public_key_value.clone()),
-                ("new-total".into(), Value::UInt(2)),
-                ("reward-cycle".into(), Value::UInt(cycle_id + 1)),
-                ("round".into(), Value::UInt(0)),
-                ("signer".into(), Value::Principal(alice_principal.clone())),
-            ])
-            .expect("Failed to create tuple")
-            .into()
-        );
-    } else {
-        panic!("Expected SmartContractEvent, got {:?}", alice_vote_event);
-    }
-
-    // Bob's vote should succeed
-    let bob_vote_tx = &receipts[4];
-    println!("bob_vote_tx: {:?}", bob_vote_tx);
-    assert_eq!(bob_vote_tx.result, Value::okay_true());
-    assert_eq!(bob_vote_tx.events.len(), 2);
-    let bob_vote_event = &bob_vote_tx.events[0];
-    println!("bob_vote_event: {:?}", bob_vote_event);
-    if let StacksTransactionEvent::SmartContractEvent(contract_event) = bob_vote_event {
-        assert_eq!(
-            contract_event.value,
-            TupleData::from_data(vec![
-                (
-                    "event".into(),
-                    Value::string_ascii_from_bytes("voted".as_bytes().to_vec())
-                        .expect("Failed to create string")
-                ),
-                ("key".into(), aggregate_public_key_value.clone()),
-                ("new-total".into(), Value::UInt(4)),
-                ("reward-cycle".into(), Value::UInt(cycle_id + 1)),
-                ("round".into(), Value::UInt(0)),
-                ("signer".into(), Value::Principal(bob_principal.clone())),
-            ])
-            .expect("Failed to create tuple")
-            .into()
-        );
-    } else {
-        panic!("Expected SmartContractEvent, got {:?}", bob_vote_event);
-    }
+     // Alice's first vote should fail (signer mismatch)
+     let alice_first_vote_tx = &receipts[2];
+     println!("alice_first_vote_tx: {:?}", alice_first_vote_tx);
+     let alice_first_vote_tx_result = alice_first_vote_tx.result.clone();
+     println!("alice_first_vote_tx_result: {:?}", alice_first_vote_tx_result);
+     assert_eq!(
+        alice_first_vote_tx_result,
+         Value::err_uint(1) // ERR_SIGNER_INDEX_MISMATCH
+     );
+
+    // Alice's second vote should fail (invalid signer)
+    let alice_second_vote_tx = &receipts[3];
+    println!("alice_second_vote_tx: {:?}", alice_second_vote_tx);
+    let alice_second_vote_tx_result = alice_second_vote_tx.result.clone();
+    println!("alice_second_vote_tx_result: {:?}", alice_second_vote_tx_result);
+    assert_eq!(
+        alice_second_vote_tx_result,
+        Value::err_uint(2) // ERR_INVALID_SIGNER_INDEX
+    );
 
-    // Bob vote should fail (duplicate vote)
-    let bob_vote_duplicate_tx = &receipts[3];
-    println!("bob_vote_duplicate_tx: {:?}", bob_vote_duplicate_tx);
-    let bob_vote_duplicate_tx_result = bob_vote_duplicate_tx.result.clone();
-    println!("bob_vote_duplicate_tx_result: {:?}", bob_vote_duplicate_tx_result);
+    // Alice's third vote should fail (ill formed aggregate public key)
+    let alice_third_vote_tx = &receipts[4];
+    println!("alice_third_vote_tx: {:?}", alice_third_vote_tx);
+    let alice_third_vote_tx_result = alice_third_vote_tx.result.clone();
+    println!("alice_third_vote_tx_result: {:?}", alice_third_vote_tx_result);
     assert_eq!(
-        bob_vote_duplicate_tx_result,
-        Value::err_uint(7) // err-duplicate-vote
+        alice_third_vote_tx_result,
+        Value::err_uint(5) // ERR_ILL_FORMED_AGGREGATE_PUBLIC_KEY
     );
 
-    let approve_event = &bob_vote_tx.events[1];
-    println!("approve_event: {:?}", approve_event);
-    if let StacksTransactionEvent::SmartContractEvent(contract_event) = approve_event {
-        assert_eq!(
-            contract_event.value,
-            TupleData::from_data(vec![
-                (
-                    "event".into(),
-                    Value::string_ascii_from_bytes(
-                        "approved-aggregate-public-key".as_bytes().to_vec()
-                    )
-                    .expect("Failed to create string")
-                ),
-                ("key".into(), aggregate_public_key_value.clone()),
-                ("reward-cycle".into(), Value::UInt(cycle_id + 1)),
-            ])
-            .expect("Failed to create tuple")
-            .into()
-        );
-    } else {
-        panic!("Expected SmartContractEvent, got {:?}", approve_event);
-    }
+    // Alice's first vote should succeed
+    // let alice_vote_tx = &receipts[2];
+    // println!("alice_vote_tx: {:?}", alice_vote_tx);
+    // assert_eq!(alice_vote_tx.result, Value::okay_true());
+    // assert_eq!(alice_vote_tx.events.len(), 1);
+    // let alice_vote_event = &alice_vote_tx.events[0];
+    // println!("alice_vote_event: {:?}", alice_vote_event);
+    // if let StacksTransactionEvent::SmartContractEvent(contract_event) = alice_vote_event {
+    //     assert_eq!(
+    //         contract_event.value,
+    //         TupleData::from_data(vec![
+    //             (
+    //                 "event".into(),
+    //                 Value::string_ascii_from_bytes("voted".as_bytes().to_vec())
+    //                     .expect("Failed to create string")
+    //             ),
+    //             ("key".into(), aggregate_public_key_value.clone()),
+    //             ("new-total".into(), Value::UInt(2)),
+    //             ("reward-cycle".into(), Value::UInt(cycle_id + 1)),
+    //             ("round".into(), Value::UInt(0)),
+    //             ("signer".into(), Value::Principal(alice_principal.clone())),
+    //         ])
+    //         .expect("Failed to create tuple")
+    //         .into()
+    //     );
+    // } else {
+    //     panic!("Expected SmartContractEvent, got {:?}", alice_vote_event);
+    // }
+
+    // Alice second vote should fail (duplicate vote)
+    // let alice_vote_duplicate_tx = &receipts[3];
+    // println!("alice_vote_duplicate_tx: {:?}", alice_vote_duplicate_tx);
+    // let alice_vote_duplicate_tx_result = alice_vote_duplicate_tx.result.clone();
+    // println!("alice_vote_duplicate_tx_result: {:?}", alice_vote_duplicate_tx_result);
+    // assert_eq!(
+    //     alice_vote_duplicate_tx_result,
+    //     Value::err_uint(1) // err-duplicate-vote
+    // );
+
+    // let approve_event = &alice_vote_duplicate_tx.events[0];
+    // println!("approve_event: {:?}", approve_event);
+    // if let StacksTransactionEvent::SmartContractEvent(contract_event) = approve_event {
+    //     assert_eq!(
+    //         contract_event.value,
+    //         TupleData::from_data(vec![
+    //             (
+    //                 "event".into(),
+    //                 Value::string_ascii_from_bytes(
+    //                     "approved-aggregate-public-key".as_bytes().to_vec()
+    //                 )
+    //                 .expect("Failed to create string")
+    //             ),
+    //             ("key".into(), aggregate_public_key_value.clone()),
+    //             ("reward-cycle".into(), Value::UInt(cycle_id + 1)),
+    //         ])
+    //         .expect("Failed to create tuple")
+    //         .into()
+    //     );
+    // } else {
+    //     panic!("Expected SmartContractEvent, got {:?}", approve_event);
+    // }
+
+    // Bob's vote should succeed
+    // let bob_vote_tx = &receipts[4];
+    // println!("bob_vote_tx: {:?}", bob_vote_tx);
+    // assert_eq!(bob_vote_tx.result, Value::okay_true());
+    // assert_eq!(bob_vote_tx.events.len(), 2);
+    // let bob_vote_event = &bob_vote_tx.events[0];
+    // println!("bob_vote_event: {:?}", bob_vote_event);
+    // if let StacksTransactionEvent::SmartContractEvent(contract_event) = bob_vote_event {
+    //     assert_eq!(
+    //         contract_event.value,
+    //         TupleData::from_data(vec![
+    //             (
+    //                 "event".into(),
+    //                 Value::string_ascii_from_bytes("voted".as_bytes().to_vec())
+    //                     .expect("Failed to create string")
+    //             ),
+    //             ("key".into(), aggregate_public_key_value.clone()),
+    //             ("new-total".into(), Value::UInt(4)),
+    //             ("reward-cycle".into(), Value::UInt(cycle_id + 1)),
+    //             ("round".into(), Value::UInt(0)),
+    //             ("signer".into(), Value::Principal(bob_principal.clone())),
+    //         ])
+    //         .expect("Failed to create tuple")
+    //         .into()
+    //     );
+    // } else {
+    //     panic!("Expected SmartContractEvent, got {:?}", bob_vote_event);
+    // }
+
 }
 
 /// In this test case, Alice votes in the first block of the first tenure of the prepare phase.
@@ -339,7 +411,8 @@ fn vote_for_aggregate_public_key_in_first_block() {
 
     let signer_index = get_signer_index(&mut peer, latest_block_id, signer_address, cycle_id);
 
-    let aggregate_public_key: Point = Point::new();
+    let aggregate_public_key_point: Point = Point::new();
+    let aggregate_public_key = Value::buff_from(aggregate_public_key_point.compress().data.to_vec()).expect("Failed to serialize aggregate public key");
 
     let txs = vec![
         // cast a vote for the aggregate public key
@@ -347,7 +420,7 @@ fn vote_for_aggregate_public_key_in_first_block() {
             signer_key,
             signer_nonce,
             signer_index,
-            &aggregate_public_key,
+            aggregate_public_key.clone(),
             0,
             cycle_id + 1,
         ),
@@ -356,7 +429,7 @@ fn vote_for_aggregate_public_key_in_first_block() {
             signer_key,
             signer_nonce + 1,
             signer_index,
-            &aggregate_public_key,
+            aggregate_public_key.clone(),
             0,
             cycle_id + 1,
         ),
@@ -423,8 +496,10 @@ fn vote_for_aggregate_public_key_in_last_block() {
     );
 
     let cycle_id: u128 = current_reward_cycle;
-    let aggregate_public_key_1 = Point::from(Scalar::from(1));
-    let aggregate_public_key_2 = Point::from(Scalar::from(2));
+    let aggregate_public_key_1_point = Point::from(Scalar::from(1));
+    let aggregate_public_key_1 = Value::buff_from(aggregate_public_key_1_point.compress().data.to_vec()).expect("Failed to serialize aggregate public key");
+    let aggregate_public_key_2_point = Point::from(Scalar::from(2));
+    let aggregate_public_key_2 = Value::buff_from(aggregate_public_key_2_point.compress().data.to_vec()).expect("Failed to serialize aggregate public key");
 
     // create vote txs for alice
     let signer_1_nonce = 1; // Start at 1 because the signer has already voted once
@@ -439,7 +514,7 @@ fn vote_for_aggregate_public_key_in_last_block() {
             signer_1_key,
             signer_1_nonce,
             signer_1_index,
-            &aggregate_public_key_1,
+            aggregate_public_key_1.clone(),
             1,
             cycle_id + 1,
         ),
@@ -448,7 +523,7 @@ fn vote_for_aggregate_public_key_in_last_block() {
             signer_1_key,
             signer_1_nonce + 1,
             signer_1_index,
-            &aggregate_public_key_1,
+            aggregate_public_key_1.clone(),
             1,
             cycle_id + 1,
         ),
@@ -457,7 +532,7 @@ fn vote_for_aggregate_public_key_in_last_block() {
             signer_1_key,
             signer_1_nonce + 2,
             signer_1_index,
-            &aggregate_public_key_2,
+            aggregate_public_key_2,
             0,
             cycle_id + 1,
         ),
@@ -476,7 +551,7 @@ fn vote_for_aggregate_public_key_in_last_block() {
             signer_2_key,
             signer_2_nonce,
             signer_2_index,
-            &aggregate_public_key_1,
+            aggregate_public_key_1.clone(),
             0,
             cycle_id + 1,
         ),

From ff950437495624a1ad7fbd67529c3588091ba570 Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Sun, 18 Feb 2024 08:45:15 -0500
Subject: [PATCH 0812/1166] removed unused err

---
 stackslib/src/chainstate/stacks/boot/mod.rs              | 2 --
 stackslib/src/chainstate/stacks/boot/signers-voting.clar | 5 ++---
 2 files changed, 2 insertions(+), 5 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index f798220a0f..464733958e 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -1913,8 +1913,6 @@ pub mod test {
     ) -> StacksTransaction {
         debug!("Vote for aggregate key in cycle {}, round {}", cycle, round);
 
-        // let aggregate_public_key = Value::buff_from(aggregate_public_key.compress().data.to_vec())
-        //     .expect("Failed to serialize aggregate public key");
         let payload = TransactionPayload::new_contract_call(
             boot_code_test_addr(),
             SIGNERS_VOTING_NAME,
diff --git a/stackslib/src/chainstate/stacks/boot/signers-voting.clar b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
index 8fd829ba95..091754d1be 100644
--- a/stackslib/src/chainstate/stacks/boot/signers-voting.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
@@ -15,9 +15,8 @@
 (define-constant ERR_ILL_FORMED_AGGREGATE_PUBLIC_KEY u5)
 (define-constant ERR_DUPLICATE_AGGREGATE_PUBLIC_KEY u6)
 (define-constant ERR_DUPLICATE_VOTE u7)
-(define-constant ERR_INVALID_BURN_BLOCK_HEIGHT u8)
-(define-constant ERR_FAILED_TO_RETRIEVE_SIGNERS u9)
-(define-constant ERR_INVALID_ROUND u10)
+(define-constant ERR_FAILED_TO_RETRIEVE_SIGNERS u8)
+(define-constant ERR_INVALID_ROUND u9)
 
 (define-constant pox-info
     (unwrap-panic (contract-call? .pox-4 get-pox-info)))

From ddad05b30d28db80e44682c6c9b44eb0c022571c Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Sun, 18 Feb 2024 08:57:45 -0500
Subject: [PATCH 0813/1166] catching all tenure-agnostic errs

---
 .../stacks/boot/signers_voting_tests.rs       | 112 ++++++++++++------
 1 file changed, 75 insertions(+), 37 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
index 74c3c462d5..030811f3a0 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
@@ -220,15 +220,33 @@ fn vote_for_aggregate_public_key_success() {
             0,
             cycle_id + 1,
         ),
+        // Alice casts a vote with an incorrect reward cycle - should return failed to retrieve signers error
+        make_signers_vote_for_aggregate_public_key(
+            alice_key,
+            alice_nonce+3,
+            alice_index,
+            aggregate_public_key.clone(),
+            0,
+            cycle_id + 2,
+        ),
+        // Alice casts vote correctly
+        make_signers_vote_for_aggregate_public_key(
+            alice_key,
+            alice_nonce+4,
+            alice_index,
+            aggregate_public_key.clone(),
+            0,
+            cycle_id + 1,
+        ),
         // Alice casts vote twice - should return duplicate vote error
-        // make_signers_vote_for_aggregate_public_key(
-        //     alice_key,
-        //     alice_nonce+1,
-        //     alice_index,
-        //     &aggregate_public_key,
-        //     0,
-        //     cycle_id + 1,
-        // ),
+        make_signers_vote_for_aggregate_public_key(
+            alice_key,
+            alice_nonce+5,
+            alice_index,
+            aggregate_public_key.clone(),
+            0,
+            cycle_id + 1,
+        ),
         // Charlie casts a vote for the aggregate public key - should return invalid signer index error
         // make_signers_vote_for_aggregate_public_key(
         //     charlie_key,
@@ -257,7 +275,7 @@ fn vote_for_aggregate_public_key_success() {
     // check the last two txs in the last block
     let block = observer.get_blocks().last().unwrap().clone();
     let receipts = block.receipts.as_slice();
-    assert_eq!(receipts.len(), 5);
+    assert_eq!(receipts.len(), 8);
     // ignore tenure change tx
     // ignore tenure coinbase tx
 
@@ -291,34 +309,54 @@ fn vote_for_aggregate_public_key_success() {
         Value::err_uint(5) // ERR_ILL_FORMED_AGGREGATE_PUBLIC_KEY
     );
 
-    // Alice's first vote should succeed
-    // let alice_vote_tx = &receipts[2];
-    // println!("alice_vote_tx: {:?}", alice_vote_tx);
-    // assert_eq!(alice_vote_tx.result, Value::okay_true());
-    // assert_eq!(alice_vote_tx.events.len(), 1);
-    // let alice_vote_event = &alice_vote_tx.events[0];
-    // println!("alice_vote_event: {:?}", alice_vote_event);
-    // if let StacksTransactionEvent::SmartContractEvent(contract_event) = alice_vote_event {
-    //     assert_eq!(
-    //         contract_event.value,
-    //         TupleData::from_data(vec![
-    //             (
-    //                 "event".into(),
-    //                 Value::string_ascii_from_bytes("voted".as_bytes().to_vec())
-    //                     .expect("Failed to create string")
-    //             ),
-    //             ("key".into(), aggregate_public_key_value.clone()),
-    //             ("new-total".into(), Value::UInt(2)),
-    //             ("reward-cycle".into(), Value::UInt(cycle_id + 1)),
-    //             ("round".into(), Value::UInt(0)),
-    //             ("signer".into(), Value::Principal(alice_principal.clone())),
-    //         ])
-    //         .expect("Failed to create tuple")
-    //         .into()
-    //     );
-    // } else {
-    //     panic!("Expected SmartContractEvent, got {:?}", alice_vote_event);
-    // }
+    // Alice's fourth vote should fail (failed to retrieve signers)
+    let alice_fourth_vote_tx = &receipts[5];
+    println!("alice_fourth_vote_tx: {:?}", alice_fourth_vote_tx);
+    let alice_fourth_vote_tx_result = alice_fourth_vote_tx.result.clone();
+    println!("alice_fourth_vote_tx_result: {:?}", alice_fourth_vote_tx_result);
+    assert_eq!(
+        alice_fourth_vote_tx_result,
+        Value::err_uint(8) // ERR_FAILED_TO_RETRIEVE_SIGNERS
+    );
+
+    // Alice's fifth  vote, correct vote should succeed
+    let alice_fifth_vote_tx = &receipts[6];
+    println!("alice_fifth_vote_tx: {:?}", alice_fifth_vote_tx);
+    assert_eq!(alice_fifth_vote_tx.result, Value::okay_true());
+    assert_eq!(alice_fifth_vote_tx.events.len(), 1);
+    let alice_vote_event = &alice_fifth_vote_tx.events[0];
+    println!("alice_vote_event: {:?}", alice_vote_event);
+    if let StacksTransactionEvent::SmartContractEvent(contract_event) = alice_vote_event {
+        assert_eq!(
+            contract_event.value,
+            TupleData::from_data(vec![
+                (
+                    "event".into(),
+                    Value::string_ascii_from_bytes("voted".as_bytes().to_vec())
+                        .expect("Failed to create string")
+                ),
+                ("key".into(), aggregate_public_key.clone()),
+                ("new-total".into(), Value::UInt(2)),
+                ("reward-cycle".into(), Value::UInt(cycle_id + 1)),
+                ("round".into(), Value::UInt(0)),
+                ("signer".into(), Value::Principal(alice_principal.clone())),
+            ])
+            .expect("Failed to create tuple")
+            .into()
+        );
+    } else {
+        panic!("Expected SmartContractEvent, got {:?}", alice_vote_event);
+    }
+
+    // Alice's sixth vote should fail (duplicate vote)
+    let alice_sixth_vote_tx = &receipts[7];
+    println!("alice_sixth_vote_tx: {:?}", alice_sixth_vote_tx);
+    let alice_sixth_vote_tx_result = alice_sixth_vote_tx.result.clone();
+    println!("alice_sixth_vote_tx_result: {:?}", alice_sixth_vote_tx_result);
+    assert_eq!(
+        alice_sixth_vote_tx_result,
+        Value::err_uint(7) // ERR_DUPLICATE_VOTE
+    );
 
     // Alice second vote should fail (duplicate vote)
     // let alice_vote_duplicate_tx = &receipts[3];

From d8cde7f49972745b7ee6b8557f6b122d259e0adf Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Sun, 18 Feb 2024 09:10:08 -0500
Subject: [PATCH 0814/1166] removed print statements & comment

---
 .../stacks/boot/signers-voting.clar           |  10 +-
 .../stacks/boot/signers_voting_tests.rs       | 146 +++++-------------
 2 files changed, 44 insertions(+), 112 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers-voting.clar b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
index 091754d1be..8e3207a332 100644
--- a/stackslib/src/chainstate/stacks/boot/signers-voting.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
@@ -12,11 +12,11 @@
 (define-constant ERR_SIGNER_INDEX_MISMATCH u1)
 (define-constant ERR_INVALID_SIGNER_INDEX u2)
 (define-constant ERR_OUT_OF_VOTING_WINDOW u3)
-(define-constant ERR_ILL_FORMED_AGGREGATE_PUBLIC_KEY u5)
-(define-constant ERR_DUPLICATE_AGGREGATE_PUBLIC_KEY u6)
-(define-constant ERR_DUPLICATE_VOTE u7)
-(define-constant ERR_FAILED_TO_RETRIEVE_SIGNERS u8)
-(define-constant ERR_INVALID_ROUND u9)
+(define-constant ERR_ILL_FORMED_AGGREGATE_PUBLIC_KEY u4)
+(define-constant ERR_DUPLICATE_AGGREGATE_PUBLIC_KEY u5)
+(define-constant ERR_DUPLICATE_VOTE u6)
+(define-constant ERR_FAILED_TO_RETRIEVE_SIGNERS u7)
+(define-constant ERR_INVALID_ROUND u8)
 
 (define-constant pox-info
     (unwrap-panic (contract-call? .pox-4 get-pox-info)))
diff --git a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
index 030811f3a0..1f9237ebf2 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
@@ -144,7 +144,6 @@ fn vote_for_aggregate_public_key_success() {
     // Test setup
     let alice = TestStacker::from_seed(&[3, 4]);
     let bob = TestStacker::from_seed(&[5, 6]);
-    let charlie = TestStacker::from_seed(&[7, 8]);
     let observer = TestEventObserver::new();
 
     // Alice - Signer 1
@@ -157,11 +156,6 @@ fn vote_for_aggregate_public_key_success() {
     let bob_address = key_to_stacks_addr(bob_key);
     let bob_principal = PrincipalData::from(bob_address);
 
-    // Charlie - Doesn't register, throws invalid signer index
-    let charlie_key = &charlie.signer_private_key;
-    let charlie_address = key_to_stacks_addr(charlie_key);
-    let charlie_principal = PrincipalData::from(charlie_address);
-
     let (mut peer, mut test_signers, latest_block_id, current_reward_cycle) = prepare_signers_test(
         function_name!(),
         vec![
@@ -175,20 +169,15 @@ fn vote_for_aggregate_public_key_success() {
     // Alice and Bob will each have voted once while booting to Nakamoto
     let alice_nonce = 1;
     let bob_nonce = 1;
-    let charlie_nonce = 1;
 
     let cycle_id = current_reward_cycle;
 
     // create vote txs
     let alice_index = get_signer_index(&mut peer, latest_block_id, alice_address, cycle_id);
     let bob_index = get_signer_index(&mut peer, latest_block_id, bob_address, cycle_id);
-    println!("Alice index: {}", alice_index);
-    println!("Bob index: {}", bob_index);
+
     let aggregate_public_key_point: Point = Point::new();
     let aggregate_public_key = Value::buff_from(aggregate_public_key_point.compress().data.to_vec()).expect("Failed to serialize aggregate public key");
-    // let aggregate_public_key_value =
-    //     Value::buff_from(aggregate_public_key.compress().data.to_vec())
-    //         .expect("Failed to serialize aggregate public key");
 
     let aggregate_public_key_ill_formed = Value::buff_from_byte(0x00);
 
@@ -247,24 +236,15 @@ fn vote_for_aggregate_public_key_success() {
             0,
             cycle_id + 1,
         ),
-        // Charlie casts a vote for the aggregate public key - should return invalid signer index error
-        // make_signers_vote_for_aggregate_public_key(
-        //     charlie_key,
-        //     charlie_nonce,
-        //     2,
-        //     &aggregate_public_key,
-        //     0,
-        //     cycle_id + 1,
-        // ),
-        // Bob casts a vote with a non-existant index - should return signer index mismatch error
-        // make_signers_vote_for_aggregate_public_key(
-        //     bob_key,
-        //     bob_nonce,
-        //     2,
-        //     &aggregate_public_key,
-        //     0,
-        //     cycle_id + 1,
-        // ),
+        // Bob casts a vote correctly
+        make_signers_vote_for_aggregate_public_key(
+            bob_key,
+            bob_nonce,
+            bob_index,
+            aggregate_public_key.clone(),
+            0,
+            cycle_id + 1,
+        ),
     ];
 
     //
@@ -275,15 +255,13 @@ fn vote_for_aggregate_public_key_success() {
     // check the last two txs in the last block
     let block = observer.get_blocks().last().unwrap().clone();
     let receipts = block.receipts.as_slice();
-    assert_eq!(receipts.len(), 8);
+    assert_eq!(receipts.len(), 9);
     // ignore tenure change tx
     // ignore tenure coinbase tx
 
      // Alice's first vote should fail (signer mismatch)
      let alice_first_vote_tx = &receipts[2];
-     println!("alice_first_vote_tx: {:?}", alice_first_vote_tx);
      let alice_first_vote_tx_result = alice_first_vote_tx.result.clone();
-     println!("alice_first_vote_tx_result: {:?}", alice_first_vote_tx_result);
      assert_eq!(
         alice_first_vote_tx_result,
          Value::err_uint(1) // ERR_SIGNER_INDEX_MISMATCH
@@ -291,9 +269,7 @@ fn vote_for_aggregate_public_key_success() {
 
     // Alice's second vote should fail (invalid signer)
     let alice_second_vote_tx = &receipts[3];
-    println!("alice_second_vote_tx: {:?}", alice_second_vote_tx);
     let alice_second_vote_tx_result = alice_second_vote_tx.result.clone();
-    println!("alice_second_vote_tx_result: {:?}", alice_second_vote_tx_result);
     assert_eq!(
         alice_second_vote_tx_result,
         Value::err_uint(2) // ERR_INVALID_SIGNER_INDEX
@@ -301,31 +277,25 @@ fn vote_for_aggregate_public_key_success() {
 
     // Alice's third vote should fail (ill formed aggregate public key)
     let alice_third_vote_tx = &receipts[4];
-    println!("alice_third_vote_tx: {:?}", alice_third_vote_tx);
     let alice_third_vote_tx_result = alice_third_vote_tx.result.clone();
-    println!("alice_third_vote_tx_result: {:?}", alice_third_vote_tx_result);
     assert_eq!(
         alice_third_vote_tx_result,
-        Value::err_uint(5) // ERR_ILL_FORMED_AGGREGATE_PUBLIC_KEY
+        Value::err_uint(4) // ERR_ILL_FORMED_AGGREGATE_PUBLIC_KEY
     );
 
     // Alice's fourth vote should fail (failed to retrieve signers)
     let alice_fourth_vote_tx = &receipts[5];
-    println!("alice_fourth_vote_tx: {:?}", alice_fourth_vote_tx);
     let alice_fourth_vote_tx_result = alice_fourth_vote_tx.result.clone();
-    println!("alice_fourth_vote_tx_result: {:?}", alice_fourth_vote_tx_result);
     assert_eq!(
         alice_fourth_vote_tx_result,
-        Value::err_uint(8) // ERR_FAILED_TO_RETRIEVE_SIGNERS
+        Value::err_uint(7) // ERR_FAILED_TO_RETRIEVE_SIGNERS
     );
 
     // Alice's fifth  vote, correct vote should succeed
     let alice_fifth_vote_tx = &receipts[6];
-    println!("alice_fifth_vote_tx: {:?}", alice_fifth_vote_tx);
     assert_eq!(alice_fifth_vote_tx.result, Value::okay_true());
     assert_eq!(alice_fifth_vote_tx.events.len(), 1);
     let alice_vote_event = &alice_fifth_vote_tx.events[0];
-    println!("alice_vote_event: {:?}", alice_vote_event);
     if let StacksTransactionEvent::SmartContractEvent(contract_event) = alice_vote_event {
         assert_eq!(
             contract_event.value,
@@ -350,75 +320,37 @@ fn vote_for_aggregate_public_key_success() {
 
     // Alice's sixth vote should fail (duplicate vote)
     let alice_sixth_vote_tx = &receipts[7];
-    println!("alice_sixth_vote_tx: {:?}", alice_sixth_vote_tx);
     let alice_sixth_vote_tx_result = alice_sixth_vote_tx.result.clone();
-    println!("alice_sixth_vote_tx_result: {:?}", alice_sixth_vote_tx_result);
     assert_eq!(
         alice_sixth_vote_tx_result,
-        Value::err_uint(7) // ERR_DUPLICATE_VOTE
+        Value::err_uint(6) // ERR_DUPLICATE_VOTE
     );
 
-    // Alice second vote should fail (duplicate vote)
-    // let alice_vote_duplicate_tx = &receipts[3];
-    // println!("alice_vote_duplicate_tx: {:?}", alice_vote_duplicate_tx);
-    // let alice_vote_duplicate_tx_result = alice_vote_duplicate_tx.result.clone();
-    // println!("alice_vote_duplicate_tx_result: {:?}", alice_vote_duplicate_tx_result);
-    // assert_eq!(
-    //     alice_vote_duplicate_tx_result,
-    //     Value::err_uint(1) // err-duplicate-vote
-    // );
-
-    // let approve_event = &alice_vote_duplicate_tx.events[0];
-    // println!("approve_event: {:?}", approve_event);
-    // if let StacksTransactionEvent::SmartContractEvent(contract_event) = approve_event {
-    //     assert_eq!(
-    //         contract_event.value,
-    //         TupleData::from_data(vec![
-    //             (
-    //                 "event".into(),
-    //                 Value::string_ascii_from_bytes(
-    //                     "approved-aggregate-public-key".as_bytes().to_vec()
-    //                 )
-    //                 .expect("Failed to create string")
-    //             ),
-    //             ("key".into(), aggregate_public_key_value.clone()),
-    //             ("reward-cycle".into(), Value::UInt(cycle_id + 1)),
-    //         ])
-    //         .expect("Failed to create tuple")
-    //         .into()
-    //     );
-    // } else {
-    //     panic!("Expected SmartContractEvent, got {:?}", approve_event);
-    // }
-
-    // Bob's vote should succeed
-    // let bob_vote_tx = &receipts[4];
-    // println!("bob_vote_tx: {:?}", bob_vote_tx);
-    // assert_eq!(bob_vote_tx.result, Value::okay_true());
-    // assert_eq!(bob_vote_tx.events.len(), 2);
-    // let bob_vote_event = &bob_vote_tx.events[0];
-    // println!("bob_vote_event: {:?}", bob_vote_event);
-    // if let StacksTransactionEvent::SmartContractEvent(contract_event) = bob_vote_event {
-    //     assert_eq!(
-    //         contract_event.value,
-    //         TupleData::from_data(vec![
-    //             (
-    //                 "event".into(),
-    //                 Value::string_ascii_from_bytes("voted".as_bytes().to_vec())
-    //                     .expect("Failed to create string")
-    //             ),
-    //             ("key".into(), aggregate_public_key_value.clone()),
-    //             ("new-total".into(), Value::UInt(4)),
-    //             ("reward-cycle".into(), Value::UInt(cycle_id + 1)),
-    //             ("round".into(), Value::UInt(0)),
-    //             ("signer".into(), Value::Principal(bob_principal.clone())),
-    //         ])
-    //         .expect("Failed to create tuple")
-    //         .into()
-    //     );
-    // } else {
-    //     panic!("Expected SmartContractEvent, got {:?}", bob_vote_event);
-    // }
+    // Bob's first vote, correct vote should succeed in setting the aggregate public key
+    let bob_first_vote_tx = &receipts[8];
+    assert_eq!(bob_first_vote_tx.result, Value::okay_true());
+    assert_eq!(bob_first_vote_tx.events.len(), 2);
+    let approve_event = &bob_first_vote_tx.events[1];
+    if let StacksTransactionEvent::SmartContractEvent(contract_event) = approve_event {
+        assert_eq!(
+            contract_event.value,
+            TupleData::from_data(vec![
+                (
+                    "event".into(),
+                    Value::string_ascii_from_bytes(
+                        "approved-aggregate-public-key".as_bytes().to_vec()
+                    )
+                    .expect("Failed to create string")
+                ),
+                ("key".into(), aggregate_public_key.clone()),
+                ("reward-cycle".into(), Value::UInt(cycle_id + 1)),
+            ])
+            .expect("Failed to create tuple")
+            .into()
+        );
+    } else {
+        panic!("Expected SmartContractEvent, got {:?}", approve_event);
+    }
 
 }
 

From ad1f014fdd9e6524b7c8f239ae92ac12a388ebc7 Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Sun, 18 Feb 2024 09:10:42 -0500
Subject: [PATCH 0815/1166] formatted correctly

---
 .../chainstate/nakamoto/coordinator/tests.rs  |  3 +-
 .../stacks/boot/signers_voting_tests.rs       | 43 +++++++++++--------
 2 files changed, 27 insertions(+), 19 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index 53fd60e133..21f6490e52 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -204,7 +204,8 @@ pub fn make_all_signers_vote_for_aggregate_key(
                 signer_key,
                 account.nonce,
                 *index as u128,
-                Value::buff_from(test_signers.aggregate_public_key.compress().data.to_vec()).expect("Failed to serialize aggregate public key"),
+                Value::buff_from(test_signers.aggregate_public_key.compress().data.to_vec())
+                    .expect("Failed to serialize aggregate public key"),
                 0,
                 cycle_id,
             )
diff --git a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
index 1f9237ebf2..e586aaca05 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
@@ -177,7 +177,9 @@ fn vote_for_aggregate_public_key_success() {
     let bob_index = get_signer_index(&mut peer, latest_block_id, bob_address, cycle_id);
 
     let aggregate_public_key_point: Point = Point::new();
-    let aggregate_public_key = Value::buff_from(aggregate_public_key_point.compress().data.to_vec()).expect("Failed to serialize aggregate public key");
+    let aggregate_public_key =
+        Value::buff_from(aggregate_public_key_point.compress().data.to_vec())
+            .expect("Failed to serialize aggregate public key");
 
     let aggregate_public_key_ill_formed = Value::buff_from_byte(0x00);
 
@@ -194,16 +196,16 @@ fn vote_for_aggregate_public_key_success() {
         // Alice casts a vote with Bobs index - should return invalid signer index error
         make_signers_vote_for_aggregate_public_key(
             alice_key,
-            alice_nonce+1,
+            alice_nonce + 1,
             2,
             aggregate_public_key.clone(),
             0,
             cycle_id + 1,
         ),
-         // Alice casts a vote with an invalid public key - should return ill-formed public key error
-         make_signers_vote_for_aggregate_public_key(
+        // Alice casts a vote with an invalid public key - should return ill-formed public key error
+        make_signers_vote_for_aggregate_public_key(
             alice_key,
-            alice_nonce+2,
+            alice_nonce + 2,
             alice_index,
             aggregate_public_key_ill_formed,
             0,
@@ -212,7 +214,7 @@ fn vote_for_aggregate_public_key_success() {
         // Alice casts a vote with an incorrect reward cycle - should return failed to retrieve signers error
         make_signers_vote_for_aggregate_public_key(
             alice_key,
-            alice_nonce+3,
+            alice_nonce + 3,
             alice_index,
             aggregate_public_key.clone(),
             0,
@@ -221,7 +223,7 @@ fn vote_for_aggregate_public_key_success() {
         // Alice casts vote correctly
         make_signers_vote_for_aggregate_public_key(
             alice_key,
-            alice_nonce+4,
+            alice_nonce + 4,
             alice_index,
             aggregate_public_key.clone(),
             0,
@@ -230,7 +232,7 @@ fn vote_for_aggregate_public_key_success() {
         // Alice casts vote twice - should return duplicate vote error
         make_signers_vote_for_aggregate_public_key(
             alice_key,
-            alice_nonce+5,
+            alice_nonce + 5,
             alice_index,
             aggregate_public_key.clone(),
             0,
@@ -259,13 +261,13 @@ fn vote_for_aggregate_public_key_success() {
     // ignore tenure change tx
     // ignore tenure coinbase tx
 
-     // Alice's first vote should fail (signer mismatch)
-     let alice_first_vote_tx = &receipts[2];
-     let alice_first_vote_tx_result = alice_first_vote_tx.result.clone();
-     assert_eq!(
+    // Alice's first vote should fail (signer mismatch)
+    let alice_first_vote_tx = &receipts[2];
+    let alice_first_vote_tx_result = alice_first_vote_tx.result.clone();
+    assert_eq!(
         alice_first_vote_tx_result,
-         Value::err_uint(1) // ERR_SIGNER_INDEX_MISMATCH
-     );
+        Value::err_uint(1) // ERR_SIGNER_INDEX_MISMATCH
+    );
 
     // Alice's second vote should fail (invalid signer)
     let alice_second_vote_tx = &receipts[3];
@@ -351,7 +353,6 @@ fn vote_for_aggregate_public_key_success() {
     } else {
         panic!("Expected SmartContractEvent, got {:?}", approve_event);
     }
-
 }
 
 /// In this test case, Alice votes in the first block of the first tenure of the prepare phase.
@@ -382,7 +383,9 @@ fn vote_for_aggregate_public_key_in_first_block() {
     let signer_index = get_signer_index(&mut peer, latest_block_id, signer_address, cycle_id);
 
     let aggregate_public_key_point: Point = Point::new();
-    let aggregate_public_key = Value::buff_from(aggregate_public_key_point.compress().data.to_vec()).expect("Failed to serialize aggregate public key");
+    let aggregate_public_key =
+        Value::buff_from(aggregate_public_key_point.compress().data.to_vec())
+            .expect("Failed to serialize aggregate public key");
 
     let txs = vec![
         // cast a vote for the aggregate public key
@@ -467,9 +470,13 @@ fn vote_for_aggregate_public_key_in_last_block() {
 
     let cycle_id: u128 = current_reward_cycle;
     let aggregate_public_key_1_point = Point::from(Scalar::from(1));
-    let aggregate_public_key_1 = Value::buff_from(aggregate_public_key_1_point.compress().data.to_vec()).expect("Failed to serialize aggregate public key");
+    let aggregate_public_key_1 =
+        Value::buff_from(aggregate_public_key_1_point.compress().data.to_vec())
+            .expect("Failed to serialize aggregate public key");
     let aggregate_public_key_2_point = Point::from(Scalar::from(2));
-    let aggregate_public_key_2 = Value::buff_from(aggregate_public_key_2_point.compress().data.to_vec()).expect("Failed to serialize aggregate public key");
+    let aggregate_public_key_2 =
+        Value::buff_from(aggregate_public_key_2_point.compress().data.to_vec())
+            .expect("Failed to serialize aggregate public key");
 
     // create vote txs for alice
     let signer_1_nonce = 1; // Start at 1 because the signer has already voted once

From 862e347735c585374943af658c38a3b3cdc24b13 Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Sun, 18 Feb 2024 10:11:33 -0500
Subject: [PATCH 0816/1166] minor update

---
 stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
index e586aaca05..c2a473d459 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
@@ -137,8 +137,9 @@ pub fn prepare_pox4_test<'a>(
     )
 }
 
-/// In this test case, Alice and Bob both successfully vote for the same key
-/// and the key is accepted.
+/// In this test case, Alice & Bob both successfully vote for the same key
+/// Alice votes first, casting one correct vote & four incorrect votes
+/// that hit all tenure-agnostic errors. Bob votes once, successfully.
 #[test]
 fn vote_for_aggregate_public_key_success() {
     // Test setup

From 1ca5d86e58a6d7c1ce741795d5ea4a521a695ce0 Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Mon, 19 Feb 2024 17:37:17 -0500
Subject: [PATCH 0817/1166] test: separate out simple success test

Other miner refactoring in the tests.
---
 .../chainstate/nakamoto/coordinator/tests.rs  |   5 +-
 stackslib/src/chainstate/stacks/boot/mod.rs   |  21 ++
 .../stacks/boot/signers_voting_tests.rs       | 203 +++++++++++++++---
 3 files changed, 199 insertions(+), 30 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index 21f6490e52..bbd5ff4406 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -42,7 +42,8 @@ use crate::chainstate::stacks::address::PoxAddress;
 use crate::chainstate::stacks::boot::signers_tests::{readonly_call, readonly_call_with_sortdb};
 use crate::chainstate::stacks::boot::test::{
     key_to_stacks_addr, make_pox_4_lockup, make_signer_key_signature,
-    make_signers_vote_for_aggregate_public_key, with_sortdb,
+    make_signers_vote_for_aggregate_public_key, make_signers_vote_for_aggregate_public_key_value,
+    with_sortdb,
 };
 use crate::chainstate::stacks::boot::{MINERS_NAME, SIGNERS_NAME};
 use crate::chainstate::stacks::db::{MinerPaymentTxFees, StacksAccount, StacksChainState};
@@ -200,7 +201,7 @@ pub fn make_all_signers_vote_for_aggregate_key(
         .iter()
         .map(|(addr, (signer_key, index))| {
             let account = get_account(chainstate, sortdb, &addr);
-            make_signers_vote_for_aggregate_public_key(
+            make_signers_vote_for_aggregate_public_key_value(
                 signer_key,
                 account.nonce,
                 *index as u128,
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 464733958e..338161bfc8 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -1904,6 +1904,27 @@ pub mod test {
     }
 
     pub fn make_signers_vote_for_aggregate_public_key(
+        key: &StacksPrivateKey,
+        nonce: u64,
+        signer_index: u128,
+        aggregate_public_key: &Point,
+        round: u128,
+        cycle: u128,
+    ) -> StacksTransaction {
+        let aggregate_public_key_val =
+            Value::buff_from(aggregate_public_key.compress().data.to_vec())
+                .expect("Failed to serialize aggregate public key");
+        make_signers_vote_for_aggregate_public_key_value(
+            key,
+            nonce,
+            signer_index,
+            aggregate_public_key_val,
+            round,
+            cycle,
+        )
+    }
+
+    pub fn make_signers_vote_for_aggregate_public_key_value(
         key: &StacksPrivateKey,
         nonce: u64,
         signer_index: u128,
diff --git a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
index c2a473d459..bb771e36fc 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
@@ -137,11 +137,167 @@ pub fn prepare_pox4_test<'a>(
     )
 }
 
+/// In this test case, Alice & Bob both successfully vote for the same key.
+/// Alice votes successfully, then Bob votes successfully, reaching the
+/// threshold and setting the aggregate public key.
+#[test]
+fn vote_for_aggregate_public_key_success() {
+    // Test setup
+    let alice = TestStacker::from_seed(&[3, 4]);
+    let bob = TestStacker::from_seed(&[5, 6]);
+    let observer = TestEventObserver::new();
+
+    // Alice - Signer 1
+    let alice_key = &alice.signer_private_key;
+    let alice_address = key_to_stacks_addr(alice_key);
+    let alice_principal = PrincipalData::from(alice_address);
+
+    // Bob - Signer 2
+    let bob_key = &bob.signer_private_key;
+    let bob_address = key_to_stacks_addr(bob_key);
+    let bob_principal = PrincipalData::from(bob_address);
+
+    let (mut peer, mut test_signers, latest_block_id, current_reward_cycle) = prepare_signers_test(
+        function_name!(),
+        vec![
+            (alice_principal.clone(), 1000),
+            (bob_principal.clone(), 1000),
+        ],
+        &[alice.clone(), bob.clone()],
+        Some(&observer),
+    );
+
+    // Alice and Bob will each have voted once while booting to Nakamoto
+    let alice_nonce = 1;
+    let bob_nonce = 1;
+
+    let cycle_id = current_reward_cycle;
+
+    // create vote txs
+    let alice_index = get_signer_index(&mut peer, latest_block_id, alice_address, cycle_id);
+    let bob_index = get_signer_index(&mut peer, latest_block_id, bob_address, cycle_id);
+
+    let aggregate_public_key_point: Point = Point::new();
+    let aggregate_public_key =
+        Value::buff_from(aggregate_public_key_point.compress().data.to_vec())
+            .expect("Failed to serialize aggregate public key");
+
+    let aggregate_public_key_ill_formed = Value::buff_from_byte(0x00);
+
+    let txs = vec![
+        // Alice casts vote correctly
+        make_signers_vote_for_aggregate_public_key_value(
+            alice_key,
+            alice_nonce,
+            alice_index,
+            aggregate_public_key.clone(),
+            0,
+            cycle_id + 1,
+        ),
+        // Bob casts a vote correctly
+        make_signers_vote_for_aggregate_public_key_value(
+            bob_key,
+            bob_nonce,
+            bob_index,
+            aggregate_public_key.clone(),
+            0,
+            cycle_id + 1,
+        ),
+    ];
+
+    //
+    // vote in the first burn block of prepare phase
+    //
+    let blocks_and_sizes = nakamoto_tenure(&mut peer, &mut test_signers, vec![txs]);
+
+    // check the last two txs in the last block
+    let block = observer.get_blocks().last().unwrap().clone();
+    let receipts = block.receipts.as_slice();
+    assert_eq!(receipts.len(), 4);
+    // ignore tenure change tx
+    // ignore tenure coinbase tx
+
+    // Alice's vote should succeed
+    let alice_vote_tx = &receipts[2];
+    assert_eq!(alice_vote_tx.result, Value::okay_true());
+    assert_eq!(alice_vote_tx.events.len(), 1);
+    let alice_vote_event = &alice_vote_tx.events[0];
+    if let StacksTransactionEvent::SmartContractEvent(contract_event) = alice_vote_event {
+        assert_eq!(
+            contract_event.value,
+            TupleData::from_data(vec![
+                (
+                    "event".into(),
+                    Value::string_ascii_from_bytes("voted".as_bytes().to_vec())
+                        .expect("Failed to create string")
+                ),
+                ("key".into(), aggregate_public_key.clone()),
+                ("new-total".into(), Value::UInt(2)),
+                ("reward-cycle".into(), Value::UInt(cycle_id + 1)),
+                ("round".into(), Value::UInt(0)),
+                ("signer".into(), Value::Principal(alice_principal.clone())),
+            ])
+            .expect("Failed to create tuple")
+            .into()
+        );
+    } else {
+        panic!("Expected SmartContractEvent, got {:?}", alice_vote_event);
+    }
+
+    // Bob's vote should succeed and reach the threshold, setting the aggregate public key
+    let bob_vote_tx = &receipts[3];
+    assert_eq!(bob_vote_tx.result, Value::okay_true());
+    assert_eq!(bob_vote_tx.events.len(), 2);
+    let bob_vote_event = &bob_vote_tx.events[0];
+    if let StacksTransactionEvent::SmartContractEvent(contract_event) = bob_vote_event {
+        assert_eq!(
+            contract_event.value,
+            TupleData::from_data(vec![
+                (
+                    "event".into(),
+                    Value::string_ascii_from_bytes("voted".as_bytes().to_vec())
+                        .expect("Failed to create string")
+                ),
+                ("key".into(), aggregate_public_key.clone()),
+                ("new-total".into(), Value::UInt(4)),
+                ("reward-cycle".into(), Value::UInt(cycle_id + 1)),
+                ("round".into(), Value::UInt(0)),
+                ("signer".into(), Value::Principal(bob_principal.clone())),
+            ])
+            .expect("Failed to create tuple")
+            .into()
+        );
+    } else {
+        panic!("Expected SmartContractEvent, got {:?}", alice_vote_event);
+    }
+    let approve_event = &bob_vote_tx.events[1];
+    if let StacksTransactionEvent::SmartContractEvent(contract_event) = approve_event {
+        assert_eq!(
+            contract_event.value,
+            TupleData::from_data(vec![
+                (
+                    "event".into(),
+                    Value::string_ascii_from_bytes(
+                        "approved-aggregate-public-key".as_bytes().to_vec()
+                    )
+                    .expect("Failed to create string")
+                ),
+                ("key".into(), aggregate_public_key.clone()),
+                ("reward-cycle".into(), Value::UInt(cycle_id + 1)),
+            ])
+            .expect("Failed to create tuple")
+            .into()
+        );
+    } else {
+        panic!("Expected SmartContractEvent, got {:?}", approve_event);
+    }
+}
+
 /// In this test case, Alice & Bob both successfully vote for the same key
 /// Alice votes first, casting one correct vote & four incorrect votes
 /// that hit all tenure-agnostic errors. Bob votes once, successfully.
 #[test]
-fn vote_for_aggregate_public_key_success() {
+fn vote_for_aggregate_public_key_with_errors() {
     // Test setup
     let alice = TestStacker::from_seed(&[3, 4]);
     let bob = TestStacker::from_seed(&[5, 6]);
@@ -186,7 +342,7 @@ fn vote_for_aggregate_public_key_success() {
 
     let txs = vec![
         // Alice casts a vote with a non-existant index - should return signer index mismatch error
-        make_signers_vote_for_aggregate_public_key(
+        make_signers_vote_for_aggregate_public_key_value(
             alice_key,
             alice_nonce,
             bob_index,
@@ -195,7 +351,7 @@ fn vote_for_aggregate_public_key_success() {
             cycle_id + 1,
         ),
         // Alice casts a vote with Bobs index - should return invalid signer index error
-        make_signers_vote_for_aggregate_public_key(
+        make_signers_vote_for_aggregate_public_key_value(
             alice_key,
             alice_nonce + 1,
             2,
@@ -204,7 +360,7 @@ fn vote_for_aggregate_public_key_success() {
             cycle_id + 1,
         ),
         // Alice casts a vote with an invalid public key - should return ill-formed public key error
-        make_signers_vote_for_aggregate_public_key(
+        make_signers_vote_for_aggregate_public_key_value(
             alice_key,
             alice_nonce + 2,
             alice_index,
@@ -213,7 +369,7 @@ fn vote_for_aggregate_public_key_success() {
             cycle_id + 1,
         ),
         // Alice casts a vote with an incorrect reward cycle - should return failed to retrieve signers error
-        make_signers_vote_for_aggregate_public_key(
+        make_signers_vote_for_aggregate_public_key_value(
             alice_key,
             alice_nonce + 3,
             alice_index,
@@ -222,7 +378,7 @@ fn vote_for_aggregate_public_key_success() {
             cycle_id + 2,
         ),
         // Alice casts vote correctly
-        make_signers_vote_for_aggregate_public_key(
+        make_signers_vote_for_aggregate_public_key_value(
             alice_key,
             alice_nonce + 4,
             alice_index,
@@ -231,7 +387,7 @@ fn vote_for_aggregate_public_key_success() {
             cycle_id + 1,
         ),
         // Alice casts vote twice - should return duplicate vote error
-        make_signers_vote_for_aggregate_public_key(
+        make_signers_vote_for_aggregate_public_key_value(
             alice_key,
             alice_nonce + 5,
             alice_index,
@@ -240,7 +396,7 @@ fn vote_for_aggregate_public_key_success() {
             cycle_id + 1,
         ),
         // Bob casts a vote correctly
-        make_signers_vote_for_aggregate_public_key(
+        make_signers_vote_for_aggregate_public_key_value(
             bob_key,
             bob_nonce,
             bob_index,
@@ -383,10 +539,7 @@ fn vote_for_aggregate_public_key_in_first_block() {
 
     let signer_index = get_signer_index(&mut peer, latest_block_id, signer_address, cycle_id);
 
-    let aggregate_public_key_point: Point = Point::new();
-    let aggregate_public_key =
-        Value::buff_from(aggregate_public_key_point.compress().data.to_vec())
-            .expect("Failed to serialize aggregate public key");
+    let aggregate_public_key: Point = Point::new();
 
     let txs = vec![
         // cast a vote for the aggregate public key
@@ -394,7 +547,7 @@ fn vote_for_aggregate_public_key_in_first_block() {
             signer_key,
             signer_nonce,
             signer_index,
-            aggregate_public_key.clone(),
+            &aggregate_public_key,
             0,
             cycle_id + 1,
         ),
@@ -403,7 +556,7 @@ fn vote_for_aggregate_public_key_in_first_block() {
             signer_key,
             signer_nonce + 1,
             signer_index,
-            aggregate_public_key.clone(),
+            &aggregate_public_key,
             0,
             cycle_id + 1,
         ),
@@ -429,7 +582,7 @@ fn vote_for_aggregate_public_key_in_first_block() {
     let alice_second_vote_tx = &receipts[3];
     assert_eq!(
         alice_second_vote_tx.result,
-        Value::err_uint(7) // err-duplicate-vote
+        Value::err_uint(6) // ERR_DUPLICATE_VOTE
     );
 }
 
@@ -470,14 +623,8 @@ fn vote_for_aggregate_public_key_in_last_block() {
     );
 
     let cycle_id: u128 = current_reward_cycle;
-    let aggregate_public_key_1_point = Point::from(Scalar::from(1));
-    let aggregate_public_key_1 =
-        Value::buff_from(aggregate_public_key_1_point.compress().data.to_vec())
-            .expect("Failed to serialize aggregate public key");
-    let aggregate_public_key_2_point = Point::from(Scalar::from(2));
-    let aggregate_public_key_2 =
-        Value::buff_from(aggregate_public_key_2_point.compress().data.to_vec())
-            .expect("Failed to serialize aggregate public key");
+    let aggregate_public_key_1 = Point::from(Scalar::from(1));
+    let aggregate_public_key_2 = Point::from(Scalar::from(2));
 
     // create vote txs for alice
     let signer_1_nonce = 1; // Start at 1 because the signer has already voted once
@@ -492,7 +639,7 @@ fn vote_for_aggregate_public_key_in_last_block() {
             signer_1_key,
             signer_1_nonce,
             signer_1_index,
-            aggregate_public_key_1.clone(),
+            &aggregate_public_key_1,
             1,
             cycle_id + 1,
         ),
@@ -501,7 +648,7 @@ fn vote_for_aggregate_public_key_in_last_block() {
             signer_1_key,
             signer_1_nonce + 1,
             signer_1_index,
-            aggregate_public_key_1.clone(),
+            &aggregate_public_key_1,
             1,
             cycle_id + 1,
         ),
@@ -510,7 +657,7 @@ fn vote_for_aggregate_public_key_in_last_block() {
             signer_1_key,
             signer_1_nonce + 2,
             signer_1_index,
-            aggregate_public_key_2,
+            &aggregate_public_key_2,
             0,
             cycle_id + 1,
         ),
@@ -529,7 +676,7 @@ fn vote_for_aggregate_public_key_in_last_block() {
             signer_2_key,
             signer_2_nonce,
             signer_2_index,
-            aggregate_public_key_1.clone(),
+            &aggregate_public_key_1,
             0,
             cycle_id + 1,
         ),
@@ -562,7 +709,7 @@ fn vote_for_aggregate_public_key_in_last_block() {
     let alice_second_vote_tx = &receipts[3];
     assert_eq!(
         alice_second_vote_tx.result,
-        Value::err_uint(7) // err-duplicate-vote
+        Value::err_uint(6) // ERR_DUPLICATE_VOTE
     );
 
     // third vote should succeed even though it is on an old round

From cd4a91dff95278760ebd5b8ae6bb5302a1672943 Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Mon, 19 Feb 2024 17:44:33 -0500
Subject: [PATCH 0818/1166] test: add test for `ERR_INVALID_ROUND`

---
 .../stacks/boot/signers_voting_tests.rs       | 51 ++++++++++++++++---
 1 file changed, 45 insertions(+), 6 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
index bb771e36fc..58f216faf2 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
@@ -395,12 +395,21 @@ fn vote_for_aggregate_public_key_with_errors() {
             0,
             cycle_id + 1,
         ),
-        // Bob casts a vote correctly
+        // Bob casts a vote with the wrong round - should return an invalid round error
         make_signers_vote_for_aggregate_public_key_value(
             bob_key,
             bob_nonce,
             bob_index,
             aggregate_public_key.clone(),
+            2,
+            cycle_id + 1,
+        ),
+        // Bob casts a vote correctly
+        make_signers_vote_for_aggregate_public_key_value(
+            bob_key,
+            bob_nonce + 1,
+            bob_index,
+            aggregate_public_key.clone(),
             0,
             cycle_id + 1,
         ),
@@ -414,7 +423,7 @@ fn vote_for_aggregate_public_key_with_errors() {
     // check the last two txs in the last block
     let block = observer.get_blocks().last().unwrap().clone();
     let receipts = block.receipts.as_slice();
-    assert_eq!(receipts.len(), 9);
+    assert_eq!(receipts.len(), 10);
     // ignore tenure change tx
     // ignore tenure coinbase tx
 
@@ -485,11 +494,41 @@ fn vote_for_aggregate_public_key_with_errors() {
         Value::err_uint(6) // ERR_DUPLICATE_VOTE
     );
 
-    // Bob's first vote, correct vote should succeed in setting the aggregate public key
+    // Bob's first vote should fail (invalid round)
     let bob_first_vote_tx = &receipts[8];
-    assert_eq!(bob_first_vote_tx.result, Value::okay_true());
-    assert_eq!(bob_first_vote_tx.events.len(), 2);
-    let approve_event = &bob_first_vote_tx.events[1];
+    let bob_first_vote_tx_result = bob_first_vote_tx.result.clone();
+    assert_eq!(
+        bob_first_vote_tx_result,
+        Value::err_uint(8) // ERR_INVALID_ROUND
+    );
+
+    // Bob's second vote should succeed and reach the threshold, setting the aggregate public key
+    let bob_second_vote_tx = &receipts[9];
+    assert_eq!(bob_second_vote_tx.result, Value::okay_true());
+    assert_eq!(bob_second_vote_tx.events.len(), 2);
+    let bob_vote_event = &bob_second_vote_tx.events[0];
+    if let StacksTransactionEvent::SmartContractEvent(contract_event) = bob_vote_event {
+        assert_eq!(
+            contract_event.value,
+            TupleData::from_data(vec![
+                (
+                    "event".into(),
+                    Value::string_ascii_from_bytes("voted".as_bytes().to_vec())
+                        .expect("Failed to create string")
+                ),
+                ("key".into(), aggregate_public_key.clone()),
+                ("new-total".into(), Value::UInt(4)),
+                ("reward-cycle".into(), Value::UInt(cycle_id + 1)),
+                ("round".into(), Value::UInt(0)),
+                ("signer".into(), Value::Principal(bob_principal.clone())),
+            ])
+            .expect("Failed to create tuple")
+            .into()
+        );
+    } else {
+        panic!("Expected SmartContractEvent, got {:?}", alice_vote_event);
+    }
+    let approve_event = &bob_second_vote_tx.events[1];
     if let StacksTransactionEvent::SmartContractEvent(contract_event) = approve_event {
         assert_eq!(
             contract_event.value,

From 955ac33cf7db7ef9b0675b607244ab90855f5ec8 Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Mon, 19 Feb 2024 17:52:29 -0500
Subject: [PATCH 0819/1166] chore: update error codes to avoid overlap with
 .signers

---
 .../stacks/boot/signers-voting.clar           | 19 +++++++++++--------
 .../stacks/boot/signers_voting_tests.rs       | 16 ++++++++--------
 2 files changed, 19 insertions(+), 16 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers-voting.clar b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
index 8e3207a332..68545b6cac 100644
--- a/stackslib/src/chainstate/stacks/boot/signers-voting.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
@@ -9,14 +9,17 @@
 ;; maps aggregate public keys to rewards cycles
 (define-map used-aggregate-public-keys (buff 33) uint)
 
-(define-constant ERR_SIGNER_INDEX_MISMATCH u1)
-(define-constant ERR_INVALID_SIGNER_INDEX u2)
-(define-constant ERR_OUT_OF_VOTING_WINDOW u3)
-(define-constant ERR_ILL_FORMED_AGGREGATE_PUBLIC_KEY u4)
-(define-constant ERR_DUPLICATE_AGGREGATE_PUBLIC_KEY u5)
-(define-constant ERR_DUPLICATE_VOTE u6)
-(define-constant ERR_FAILED_TO_RETRIEVE_SIGNERS u7)
-(define-constant ERR_INVALID_ROUND u8)
+;; Error codes
+;; 1 - 9 are reserved for use in the .signers contract, which can be returned
+;; through this contract)
+(define-constant ERR_SIGNER_INDEX_MISMATCH u10)
+(define-constant ERR_INVALID_SIGNER_INDEX u11)
+(define-constant ERR_OUT_OF_VOTING_WINDOW u12)
+(define-constant ERR_ILL_FORMED_AGGREGATE_PUBLIC_KEY u13)
+(define-constant ERR_DUPLICATE_AGGREGATE_PUBLIC_KEY u14)
+(define-constant ERR_DUPLICATE_VOTE u15)
+(define-constant ERR_FAILED_TO_RETRIEVE_SIGNERS u16)
+(define-constant ERR_INVALID_ROUND u17)
 
 (define-constant pox-info
     (unwrap-panic (contract-call? .pox-4 get-pox-info)))
diff --git a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
index 58f216faf2..6719cf8e95 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
@@ -432,7 +432,7 @@ fn vote_for_aggregate_public_key_with_errors() {
     let alice_first_vote_tx_result = alice_first_vote_tx.result.clone();
     assert_eq!(
         alice_first_vote_tx_result,
-        Value::err_uint(1) // ERR_SIGNER_INDEX_MISMATCH
+        Value::err_uint(10) // ERR_SIGNER_INDEX_MISMATCH
     );
 
     // Alice's second vote should fail (invalid signer)
@@ -440,7 +440,7 @@ fn vote_for_aggregate_public_key_with_errors() {
     let alice_second_vote_tx_result = alice_second_vote_tx.result.clone();
     assert_eq!(
         alice_second_vote_tx_result,
-        Value::err_uint(2) // ERR_INVALID_SIGNER_INDEX
+        Value::err_uint(11) // ERR_INVALID_SIGNER_INDEX
     );
 
     // Alice's third vote should fail (ill formed aggregate public key)
@@ -448,7 +448,7 @@ fn vote_for_aggregate_public_key_with_errors() {
     let alice_third_vote_tx_result = alice_third_vote_tx.result.clone();
     assert_eq!(
         alice_third_vote_tx_result,
-        Value::err_uint(4) // ERR_ILL_FORMED_AGGREGATE_PUBLIC_KEY
+        Value::err_uint(13) // ERR_ILL_FORMED_AGGREGATE_PUBLIC_KEY
     );
 
     // Alice's fourth vote should fail (failed to retrieve signers)
@@ -456,7 +456,7 @@ fn vote_for_aggregate_public_key_with_errors() {
     let alice_fourth_vote_tx_result = alice_fourth_vote_tx.result.clone();
     assert_eq!(
         alice_fourth_vote_tx_result,
-        Value::err_uint(7) // ERR_FAILED_TO_RETRIEVE_SIGNERS
+        Value::err_uint(16) // ERR_FAILED_TO_RETRIEVE_SIGNERS
     );
 
     // Alice's fifth  vote, correct vote should succeed
@@ -491,7 +491,7 @@ fn vote_for_aggregate_public_key_with_errors() {
     let alice_sixth_vote_tx_result = alice_sixth_vote_tx.result.clone();
     assert_eq!(
         alice_sixth_vote_tx_result,
-        Value::err_uint(6) // ERR_DUPLICATE_VOTE
+        Value::err_uint(15) // ERR_DUPLICATE_VOTE
     );
 
     // Bob's first vote should fail (invalid round)
@@ -499,7 +499,7 @@ fn vote_for_aggregate_public_key_with_errors() {
     let bob_first_vote_tx_result = bob_first_vote_tx.result.clone();
     assert_eq!(
         bob_first_vote_tx_result,
-        Value::err_uint(8) // ERR_INVALID_ROUND
+        Value::err_uint(17) // ERR_INVALID_ROUND
     );
 
     // Bob's second vote should succeed and reach the threshold, setting the aggregate public key
@@ -621,7 +621,7 @@ fn vote_for_aggregate_public_key_in_first_block() {
     let alice_second_vote_tx = &receipts[3];
     assert_eq!(
         alice_second_vote_tx.result,
-        Value::err_uint(6) // ERR_DUPLICATE_VOTE
+        Value::err_uint(15) // ERR_DUPLICATE_VOTE
     );
 }
 
@@ -748,7 +748,7 @@ fn vote_for_aggregate_public_key_in_last_block() {
     let alice_second_vote_tx = &receipts[3];
     assert_eq!(
         alice_second_vote_tx.result,
-        Value::err_uint(6) // ERR_DUPLICATE_VOTE
+        Value::err_uint(15) // ERR_DUPLICATE_VOTE
     );
 
     // third vote should succeed even though it is on an old round

From 51066ee69ae08546444fac38edb131c4ffe7ceb0 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Tue, 20 Feb 2024 06:21:09 -0800
Subject: [PATCH 0820/1166] feat: improve documentation for signer key
 authorizations

---
 .../src/chainstate/stacks/boot/pox-4.clar     | 50 ++++++++++++-------
 .../src/chainstate/stacks/boot/pox_4_tests.rs |  2 +-
 2 files changed, 33 insertions(+), 19 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index c0d89be9a4..781709b299 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -220,7 +220,7 @@
 ;; certain stacking transactions. These fields match the fields used
 ;; in the message hash for signature-based signer key authorizations.
 ;; Values in this map are set in `set-signer-key-authorization`.
-(define-map signer-key-authorizations 
+(define-map signer-key-authorizations
     {
         ;; The signer key being authorized
         signer-key: (buff 33),
@@ -237,7 +237,7 @@
         topic: (string-ascii 12),
         ;; The PoX address that can be used with this signer key
         pox-addr: { version: (buff 1), hashbytes: (buff 32) },
-    } 
+    }
     bool ;; Whether the authorization can be used or not
 )
 
@@ -714,17 +714,17 @@
 ;; The message hash follows SIP018 for signing structured data. The structured data
 ;; is the tuple `{ pox-addr: { version, hashbytes }, reward-cycle }`. The domain is
 ;; `{ name: "pox-4-signer", version: "1.0.0", chain-id: chain-id }`.
-(define-read-only (get-signer-key-message-hash (pox-addr { version: (buff 1), hashbytes: (buff 32) }) 
+(define-read-only (get-signer-key-message-hash (pox-addr { version: (buff 1), hashbytes: (buff 32) })
                                                (reward-cycle uint)
                                                (topic (string-ascii 12))
                                                (period uint))
   (sha256 (concat
     SIP018_MSG_PREFIX
-    (concat 
+    (concat
       (sha256 (unwrap-panic (to-consensus-buff? { name: "pox-4-signer", version: "1.0.0", chain-id: chain-id })))
       (sha256 (unwrap-panic
-        (to-consensus-buff? { 
-          pox-addr: pox-addr, 
+        (to-consensus-buff? {
+          pox-addr: pox-addr,
           reward-cycle: reward-cycle,
           topic: topic,
           period: period,
@@ -734,11 +734,17 @@
 ;; See `get-signer-key-message-hash` for details on the message hash.
 ;;
 ;; Note that `reward-cycle` corresponds to the _current_ reward cycle,
-;; when used with `stack-stx` and `stack-extend`.
-;; When `signer-sig` is present, the public key is recovered from the signature 
-;; and compared to `signer-key`.
-;; 
-;; If `signer-sig` is `none`, the function verifies that an authorization was previously
+;; when used with `stack-stx` and `stack-extend`. Both the reward cycle and
+;; the lock period are inflexible, which means that the stacker must confirm their transaction
+;; during the exact reward cycle and with the exact period that the signature or authorization was
+;; generated for.
+;;
+;; This function does not verify the payload of the authorization. The caller of
+;; this function must ensure that the payload (reward cycle, period, topic, and pox-addr)
+;; are valid according to the caller function's requirements.
+;;
+;; When `signer-sig` is present, the public key is recovered from the signature
+;; and compared to `signer-key`. If `signer-sig` is `none`, the function verifies that an authorization was previously
 ;; added for this key.
 (define-read-only (verify-signer-key-sig (pox-addr { version: (buff 1), hashbytes: (buff 32) })
                                          (reward-cycle uint)
@@ -748,12 +754,12 @@
                                          (signer-key (buff 33)))
   (match signer-sig-opt
     ;; `signer-sig` is present, verify the signature
-    signer-sig (ok (asserts! 
-      (is-eq 
-        (unwrap! (secp256k1-recover? 
-          (get-signer-key-message-hash pox-addr reward-cycle topic period) 
-          signer-sig) (err ERR_INVALID_SIGNATURE_RECOVER)) 
-        signer-key) 
+    signer-sig (ok (asserts!
+      (is-eq
+        (unwrap! (secp256k1-recover?
+          (get-signer-key-message-hash pox-addr reward-cycle topic period)
+          signer-sig) (err ERR_INVALID_SIGNATURE_RECOVER))
+        signer-key)
       (err ERR_INVALID_SIGNATURE_PUBKEY)))
     ;; `signer-sig` is not present, verify that an authorization was previously added for this key
     (ok (asserts! (default-to false (map-get? signer-key-authorizations
@@ -1346,6 +1352,14 @@
 ;; in the functions that use it as an argument.
 ;; The `allowed` flag can be used to either enable or disable the authorization.
 ;; Only the Stacks principal associated with `signer-key` can call this function.
+;;
+;; Refer to the documentation for `verify-signer-key-sig` for more information
+;; regarding the parameters used in an authorization. When the authorization is used
+;; in `stack-stx` and `stack-extend`, the `reward-cycle` refers to the reward cycle
+;; where the transaction is confirmed, **not** the reward cycle where stacking begins.
+;; The `period` parameter must match the exact lock period (or extend count) used
+;; in the stacking transaction.
+;;
 ;; *New in Stacks 3.0*
 (define-public (set-signer-key-authorization (pox-addr { version: (buff 1), hashbytes: (buff 32)})
                                              (period uint)
@@ -1355,7 +1369,7 @@
                                              (allowed bool))
   (begin
     ;; Validate that `tx-sender` has the same pubkey hash as `signer-key`
-    (asserts! (is-eq 
+    (asserts! (is-eq
       (unwrap! (principal-construct? (if is-in-mainnet STACKS_ADDR_VERSION_MAINNET STACKS_ADDR_VERSION_TESTNET) (hash160 signer-key)) (err ERR_INVALID_SIGNER_KEY))
       tx-sender) (err ERR_NOT_ALLOWED))
     (map-set signer-key-authorizations { pox-addr: pox-addr, period: period, reward-cycle: reward-cycle, topic: topic, signer-key: signer-key } allowed)
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 00e82feafe..d9857c55d6 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -2469,7 +2469,7 @@ fn stack_agg_commit_signer_auth() {
 
     let topic = Pox4SignatureTopic::AggregationCommit;
 
-    // Stack agg failes without auth
+    // Stack agg fails without auth
     delegate_nonce += 1;
     let invalid_agg_nonce = delegate_nonce;
     let invalid_agg_tx = make_pox_4_aggregation_commit_indexed(

From 76fec5b6cba160adc77c5a7da5dbe41fdad61740 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Tue, 20 Feb 2024 10:49:56 -0500
Subject: [PATCH 0821/1166] chore: Address Aaron's PR comments

---
 clarity/src/vm/database/clarity_db.rs | 11 +++++++++--
 clarity/src/vm/functions/assets.rs    | 15 ++++++++++++---
 stacks-common/src/util/hash.rs        |  2 +-
 3 files changed, 22 insertions(+), 6 deletions(-)

diff --git a/clarity/src/vm/database/clarity_db.rs b/clarity/src/vm/database/clarity_db.rs
index dc00502bd0..3d6cf40ae6 100644
--- a/clarity/src/vm/database/clarity_db.rs
+++ b/clarity/src/vm/database/clarity_db.rs
@@ -1178,10 +1178,17 @@ impl<'a> ClarityDatabase<'a> {
         let value = Value::Tuple(
             TupleData::from_data(vec![
                 (
-                    ClarityName::from("reporter"),
+                    ClarityName::try_from("reporter").map_err(|_| {
+                        InterpreterError::Expect("BUG: valid string representation".into())
+                    })?,
                     Value::Principal(PrincipalData::Standard(reporter.clone())),
                 ),
-                (ClarityName::from("sequence"), Value::UInt(seq as u128)),
+                (
+                    ClarityName::try_from("sequence").map_err(|_| {
+                        InterpreterError::Expect("BUG: valid string representation".into())
+                    })?,
+                    Value::UInt(seq as u128),
+                ),
             ])
             .map_err(|_| InterpreterError::Expect("BUG: valid tuple representation".into()))?,
         );
diff --git a/clarity/src/vm/functions/assets.rs b/clarity/src/vm/functions/assets.rs
index 1e0e798c89..3e926f2cc7 100644
--- a/clarity/src/vm/functions/assets.rs
+++ b/clarity/src/vm/functions/assets.rs
@@ -239,12 +239,21 @@ pub fn special_stx_account(
 
     TupleData::from_data(vec![
         (
-            "unlocked".into(),
+            "unlocked"
+                .try_into()
+                .map_err(|_| InterpreterError::Expect("Bad special tuple name".into()))?,
             Value::UInt(stx_balance.amount_unlocked()),
         ),
-        ("locked".into(), Value::UInt(stx_balance.amount_locked())),
         (
-            "unlock-height".into(),
+            "locked"
+                .try_into()
+                .map_err(|_| InterpreterError::Expect("Bad special tuple name".into()))?,
+            Value::UInt(stx_balance.amount_locked()),
+        ),
+        (
+            "unlock-height"
+                .try_into()
+                .map_err(|_| InterpreterError::Expect("Bad special tuple name".into()))?,
             Value::UInt(u128::from(stx_balance.effective_unlock_height(
                 v1_unlock_ht,
                 v2_unlock_ht,
diff --git a/stacks-common/src/util/hash.rs b/stacks-common/src/util/hash.rs
index dcf76c1839..c1d538f35b 100644
--- a/stacks-common/src/util/hash.rs
+++ b/stacks-common/src/util/hash.rs
@@ -419,7 +419,7 @@ where
         loop {
             // next row
             let i = nodes.len() - 1;
-            let capacity = (nodes[i].len() + 1) / 2;
+            let capacity = nodes[i].len().saturating_add(1) / 2;
             let mut row_hashes = Vec::with_capacity(capacity);
 
             for j in 0..(nodes[i].len() / 2) {

From f8c676073450d25e55924ae57f9901d2b65a8447 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Fri, 16 Feb 2024 16:11:53 -0500
Subject: [PATCH 0822/1166] chore: Replace `HashMap` and `HashSet` with
 Hashbrown versions (skip `./stackslib` and `./testnet/stacks-node`)

---
 Cargo.lock                                                 | 5 +++++
 Cargo.toml                                                 | 3 ++-
 clarity/Cargo.toml                                         | 1 +
 clarity/src/vm/analysis/analysis_db.rs                     | 2 +-
 clarity/src/vm/analysis/arithmetic_checker/mod.rs          | 2 +-
 clarity/src/vm/analysis/read_only_checker/mod.rs           | 3 +--
 clarity/src/vm/analysis/trait_checker/mod.rs               | 3 +--
 clarity/src/vm/analysis/type_checker/contexts.rs           | 3 +--
 clarity/src/vm/analysis/type_checker/v2_05/contexts.rs     | 4 +++-
 clarity/src/vm/analysis/type_checker/v2_05/mod.rs          | 3 ++-
 clarity/src/vm/analysis/type_checker/v2_1/contexts.rs      | 4 +++-
 clarity/src/vm/analysis/type_checker/v2_1/mod.rs           | 3 ++-
 clarity/src/vm/analysis/types.rs                           | 3 ++-
 clarity/src/vm/ast/definition_sorter/mod.rs                | 3 ++-
 clarity/src/vm/ast/mod.rs                                  | 3 +--
 clarity/src/vm/ast/sugar_expander/mod.rs                   | 3 ++-
 clarity/src/vm/ast/traits_resolver/mod.rs                  | 2 +-
 clarity/src/vm/ast/types.rs                                | 3 ++-
 clarity/src/vm/callables.rs                                | 2 +-
 clarity/src/vm/contexts.rs                                 | 7 ++++---
 clarity/src/vm/costs/mod.rs                                | 5 +++--
 clarity/src/vm/coverage.rs                                 | 3 ++-
 clarity/src/vm/database/clarity_db.rs                      | 1 -
 clarity/src/vm/database/key_value_wrapper.rs               | 2 +-
 clarity/src/vm/database/mod.rs                             | 2 +-
 clarity/src/vm/docs/contracts.rs                           | 3 ++-
 clarity/src/vm/functions/define.rs                         | 2 +-
 clarity/src/vm/mod.rs                                      | 3 +--
 clarity/src/vm/tests/assets.rs                             | 2 +-
 clarity/src/vm/tests/principals.rs                         | 3 +--
 clarity/src/vm/types/serialization.rs                      | 2 +-
 clarity/src/vm/types/signatures.rs                         | 5 +++--
 contrib/tools/relay-server/Cargo.toml                      | 1 +
 contrib/tools/relay-server/src/http.rs                     | 3 ++-
 contrib/tools/relay-server/src/state.rs                    | 2 +-
 contrib/tools/relay-server/src/url.rs                      | 2 +-
 libsigner/Cargo.toml                                       | 2 +-
 libsigner/src/http.rs                                      | 2 +-
 libsigner/src/tests/http.rs                                | 2 +-
 stacks-common/Cargo.toml                                   | 1 +
 stacks-common/src/deps_common/bitcoin/network/encodable.rs | 3 ++-
 stacks-signer/Cargo.toml                                   | 2 +-
 stackslib/Cargo.toml                                       | 4 ++--
 stackslib/src/chainstate/stacks/boot/docs.rs               | 2 +-
 testnet/stacks-node/Cargo.toml                             | 2 +-
 45 files changed, 71 insertions(+), 52 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index f1d69dc5b0..4ea7bc8652 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -717,6 +717,7 @@ name = "clarity"
 version = "0.0.1"
 dependencies = [
  "assert-json-diff",
+ "hashbrown 0.14.3",
  "integer-sqrt",
  "lazy_static",
  "rand 0.8.5",
@@ -2756,6 +2757,9 @@ checksum = "c08c74e62047bb2de4ff487b251e4a92e24f48745648451635cec7d591162d9f"
 [[package]]
 name = "relay-server"
 version = "0.0.1"
+dependencies = [
+ "hashbrown 0.14.3",
+]
 
 [[package]]
 name = "reqwest"
@@ -3452,6 +3456,7 @@ dependencies = [
  "chrono",
  "curve25519-dalek 2.0.0",
  "ed25519-dalek",
+ "hashbrown 0.14.3",
  "lazy_static",
  "libc",
  "nix",
diff --git a/Cargo.toml b/Cargo.toml
index 1d447d00c5..b6606497c4 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -14,11 +14,12 @@ members = [
 
 # Dependencies we want to keep the same between workspace members
 [workspace.dependencies]  
-wsts = { version = "8.1", default-features = false }
 ed25519-dalek = { version = "2.1.1", features = ["serde", "rand_core"] } 
+hashbrown = "0.14.3"
 rand_core = "0.6"
 rand = "0.8"
 rand_chacha = "0.3.1"
+wsts = { version = "8.1", default-features = false }
 
 # Use a bit more than default optimization for
 #  dev builds to speed up test execution
diff --git a/clarity/Cargo.toml b/clarity/Cargo.toml
index eb8bcad388..c0b82a7fd1 100644
--- a/clarity/Cargo.toml
+++ b/clarity/Cargo.toml
@@ -30,6 +30,7 @@ slog = { version = "2.5.2", features = [ "max_level_trace" ] }
 stacks_common = { package = "stacks-common", path = "../stacks-common" }
 rstest = "0.17.0"
 rstest_reuse = "0.5.0"
+hashbrown = { workspace = true }
 
 [dependencies.serde_json]
 version = "1.0"
diff --git a/clarity/src/vm/analysis/analysis_db.rs b/clarity/src/vm/analysis/analysis_db.rs
index 0fe0a83d54..1bef2834a8 100644
--- a/clarity/src/vm/analysis/analysis_db.rs
+++ b/clarity/src/vm/analysis/analysis_db.rs
@@ -14,7 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::collections::{BTreeMap, BTreeSet, HashMap};
+use std::collections::{BTreeMap, BTreeSet};
 
 use stacks_common::types::StacksEpochId;
 
diff --git a/clarity/src/vm/analysis/arithmetic_checker/mod.rs b/clarity/src/vm/analysis/arithmetic_checker/mod.rs
index c38451c747..5595905a48 100644
--- a/clarity/src/vm/analysis/arithmetic_checker/mod.rs
+++ b/clarity/src/vm/analysis/arithmetic_checker/mod.rs
@@ -14,7 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::collections::HashMap;
+use hashbrown::HashMap;
 
 pub use super::errors::{
     check_argument_count, check_arguments_at_least, CheckError, CheckErrors, CheckResult,
diff --git a/clarity/src/vm/analysis/read_only_checker/mod.rs b/clarity/src/vm/analysis/read_only_checker/mod.rs
index 8261eb8eec..c34692d55b 100644
--- a/clarity/src/vm/analysis/read_only_checker/mod.rs
+++ b/clarity/src/vm/analysis/read_only_checker/mod.rs
@@ -14,8 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::collections::HashMap;
-
+use hashbrown::HashMap;
 use stacks_common::types::StacksEpochId;
 
 pub use super::errors::{
diff --git a/clarity/src/vm/analysis/trait_checker/mod.rs b/clarity/src/vm/analysis/trait_checker/mod.rs
index 811d436a1f..8357496717 100644
--- a/clarity/src/vm/analysis/trait_checker/mod.rs
+++ b/clarity/src/vm/analysis/trait_checker/mod.rs
@@ -14,8 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::collections::HashMap;
-
+use hashbrown::HashMap;
 use stacks_common::types::StacksEpochId;
 
 use crate::vm::analysis::errors::{CheckError, CheckErrors, CheckResult};
diff --git a/clarity/src/vm/analysis/type_checker/contexts.rs b/clarity/src/vm/analysis/type_checker/contexts.rs
index 03968a186c..b56214807a 100644
--- a/clarity/src/vm/analysis/type_checker/contexts.rs
+++ b/clarity/src/vm/analysis/type_checker/contexts.rs
@@ -14,8 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::collections::HashMap;
-
+use hashbrown::HashMap;
 use stacks_common::types::StacksEpochId;
 
 use crate::vm::analysis::errors::{CheckError, CheckErrors, CheckResult};
diff --git a/clarity/src/vm/analysis/type_checker/v2_05/contexts.rs b/clarity/src/vm/analysis/type_checker/v2_05/contexts.rs
index 8e23dd0824..2a11f6839f 100644
--- a/clarity/src/vm/analysis/type_checker/v2_05/contexts.rs
+++ b/clarity/src/vm/analysis/type_checker/v2_05/contexts.rs
@@ -14,7 +14,9 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::collections::{BTreeMap, HashMap, HashSet};
+use std::collections::BTreeMap;
+
+use hashbrown::{HashMap, HashSet};
 
 use crate::vm::analysis::errors::{CheckError, CheckErrors, CheckResult};
 use crate::vm::analysis::types::ContractAnalysis;
diff --git a/clarity/src/vm/analysis/type_checker/v2_05/mod.rs b/clarity/src/vm/analysis/type_checker/v2_05/mod.rs
index 9ea729d475..27d32ee311 100644
--- a/clarity/src/vm/analysis/type_checker/v2_05/mod.rs
+++ b/clarity/src/vm/analysis/type_checker/v2_05/mod.rs
@@ -18,9 +18,10 @@ pub mod contexts;
 //mod maps;
 pub mod natives;
 
-use std::collections::{BTreeMap, HashMap};
+use std::collections::BTreeMap;
 use std::convert::TryInto;
 
+use hashbrown::HashMap;
 use stacks_common::types::StacksEpochId;
 
 use self::contexts::ContractContext;
diff --git a/clarity/src/vm/analysis/type_checker/v2_1/contexts.rs b/clarity/src/vm/analysis/type_checker/v2_1/contexts.rs
index 95b856b88b..8cbed1a416 100644
--- a/clarity/src/vm/analysis/type_checker/v2_1/contexts.rs
+++ b/clarity/src/vm/analysis/type_checker/v2_1/contexts.rs
@@ -14,7 +14,9 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::collections::{BTreeMap, HashMap, HashSet};
+use std::collections::BTreeMap;
+
+use hashbrown::{HashMap, HashSet};
 
 use crate::vm::analysis::errors::{CheckError, CheckErrors, CheckResult};
 use crate::vm::analysis::types::ContractAnalysis;
diff --git a/clarity/src/vm/analysis/type_checker/v2_1/mod.rs b/clarity/src/vm/analysis/type_checker/v2_1/mod.rs
index e87db175aa..993f9f73c1 100644
--- a/clarity/src/vm/analysis/type_checker/v2_1/mod.rs
+++ b/clarity/src/vm/analysis/type_checker/v2_1/mod.rs
@@ -17,9 +17,10 @@
 pub mod contexts;
 pub mod natives;
 
-use std::collections::{BTreeMap, HashMap};
+use std::collections::BTreeMap;
 use std::convert::TryInto;
 
+use hashbrown::HashMap;
 use stacks_common::types::StacksEpochId;
 
 use self::contexts::ContractContext;
diff --git a/clarity/src/vm/analysis/types.rs b/clarity/src/vm/analysis/types.rs
index 2471919b54..f2723289f9 100644
--- a/clarity/src/vm/analysis/types.rs
+++ b/clarity/src/vm/analysis/types.rs
@@ -14,8 +14,9 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::collections::{BTreeMap, BTreeSet, HashMap};
+use std::collections::{BTreeMap, BTreeSet};
 
+use hashbrown::HashMap;
 use stacks_common::types::StacksEpochId;
 
 use crate::vm::analysis::analysis_db::AnalysisDatabase;
diff --git a/clarity/src/vm/ast/definition_sorter/mod.rs b/clarity/src/vm/ast/definition_sorter/mod.rs
index 73bba88ab0..19dcf12547 100644
--- a/clarity/src/vm/ast/definition_sorter/mod.rs
+++ b/clarity/src/vm/ast/definition_sorter/mod.rs
@@ -14,9 +14,10 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::collections::{HashMap, HashSet};
 use std::iter::FromIterator;
 
+use hashbrown::{HashMap, HashSet};
+
 use crate::vm::ast::errors::{ParseError, ParseErrors, ParseResult};
 use crate::vm::ast::types::{BuildASTPass, ContractAST};
 use crate::vm::costs::cost_functions::ClarityCostFunction;
diff --git a/clarity/src/vm/ast/mod.rs b/clarity/src/vm/ast/mod.rs
index d1c21b507b..1cff959695 100644
--- a/clarity/src/vm/ast/mod.rs
+++ b/clarity/src/vm/ast/mod.rs
@@ -319,8 +319,7 @@ pub fn build_ast<T: CostTracker>(
 
 #[cfg(test)]
 mod test {
-    use std::collections::HashMap;
-
+    use hashbrown::HashMap;
     use stacks_common::types::StacksEpochId;
 
     use crate::vm::ast::errors::ParseErrors;
diff --git a/clarity/src/vm/ast/sugar_expander/mod.rs b/clarity/src/vm/ast/sugar_expander/mod.rs
index 9ec552b34e..481e1039dd 100644
--- a/clarity/src/vm/ast/sugar_expander/mod.rs
+++ b/clarity/src/vm/ast/sugar_expander/mod.rs
@@ -14,9 +14,10 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::collections::{HashMap, HashSet};
 use std::convert::TryInto;
 
+use hashbrown::{HashMap, HashSet};
+
 use crate::vm::ast::errors::{ParseError, ParseErrors, ParseResult};
 use crate::vm::ast::types::{BuildASTPass, ContractAST, PreExpressionsDrain};
 use crate::vm::functions::define::{DefineFunctions, DefineFunctionsParsed};
diff --git a/clarity/src/vm/ast/traits_resolver/mod.rs b/clarity/src/vm/ast/traits_resolver/mod.rs
index 2fcb271d5b..7c4cdbf959 100644
--- a/clarity/src/vm/ast/traits_resolver/mod.rs
+++ b/clarity/src/vm/ast/traits_resolver/mod.rs
@@ -14,7 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::collections::{HashMap, HashSet};
+use hashbrown::{HashMap, HashSet};
 
 use crate::vm::analysis::AnalysisDatabase;
 use crate::vm::ast::errors::{ParseError, ParseErrors, ParseResult};
diff --git a/clarity/src/vm/ast/types.rs b/clarity/src/vm/ast/types.rs
index 79c5513b36..e8183220af 100644
--- a/clarity/src/vm/ast/types.rs
+++ b/clarity/src/vm/ast/types.rs
@@ -14,9 +14,10 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::collections::{HashMap, HashSet};
 use std::vec::Drain;
 
+use hashbrown::{HashMap, HashSet};
+
 use crate::vm::ast::errors::ParseResult;
 use crate::vm::representations::{PreSymbolicExpression, SymbolicExpression, TraitDefinition};
 use crate::vm::types::signatures::FunctionSignature;
diff --git a/clarity/src/vm/callables.rs b/clarity/src/vm/callables.rs
index 764c1479bb..077a440872 100644
--- a/clarity/src/vm/callables.rs
+++ b/clarity/src/vm/callables.rs
@@ -14,7 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::collections::{BTreeMap, HashMap};
+use std::collections::BTreeMap;
 use std::convert::TryInto;
 use std::fmt;
 use std::iter::FromIterator;
diff --git a/clarity/src/vm/contexts.rs b/clarity/src/vm/contexts.rs
index c007ee2559..3276c61b6e 100644
--- a/clarity/src/vm/contexts.rs
+++ b/clarity/src/vm/contexts.rs
@@ -14,11 +14,12 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
+use std::collections::{BTreeMap, BTreeSet};
 use std::convert::TryInto;
 use std::fmt;
 use std::mem::replace;
 
+use hashbrown::{HashMap, HashSet};
 use serde::Serialize;
 use serde_json::json;
 use stacks_common::consts::CHAIN_ID_TESTNET;
@@ -277,7 +278,7 @@ impl AssetMap {
         amount: u128,
     ) -> Result<u128> {
         let current_amount = match self.token_map.get(principal) {
-            Some(principal_map) => *principal_map.get(&asset).unwrap_or(&0),
+            Some(principal_map) => *principal_map.get(asset).unwrap_or(&0),
             None => 0,
         };
 
@@ -1948,7 +1949,7 @@ impl CallStack {
                 )
                 .into());
             }
-            if tracked && !self.set.remove(&function) {
+            if tracked && !self.set.remove(function) {
                 return Err(InterpreterError::InterpreterError(
                     "Tried to remove tracked function from call stack, but could not find in current context.".into()
                 )
diff --git a/clarity/src/vm/costs/mod.rs b/clarity/src/vm/costs/mod.rs
index 96a501809a..2222aa4c12 100644
--- a/clarity/src/vm/costs/mod.rs
+++ b/clarity/src/vm/costs/mod.rs
@@ -14,10 +14,11 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::collections::{BTreeMap, HashMap};
+use std::collections::BTreeMap;
 use std::convert::{TryFrom, TryInto};
 use std::{cmp, fmt};
 
+use hashbrown::HashMap;
 use lazy_static::lazy_static;
 use rusqlite::types::{FromSql, FromSqlResult, ToSql, ToSqlOutput, ValueRef};
 use serde::{Deserialize, Serialize};
@@ -814,7 +815,7 @@ impl TrackerData {
         let mut cost_contracts = HashMap::new();
         let mut m = HashMap::new();
         for f in ClarityCostFunction::ALL.iter() {
-            let cost_function_ref = cost_function_references.remove(&f).unwrap_or_else(|| {
+            let cost_function_ref = cost_function_references.remove(f).unwrap_or_else(|| {
                 ClarityCostFunctionReference::new(boot_costs_id.clone(), f.get_name())
             });
             if !cost_contracts.contains_key(&cost_function_ref.contract_id) {
diff --git a/clarity/src/vm/coverage.rs b/clarity/src/vm/coverage.rs
index bfb01e89c1..6f2de9f5c6 100644
--- a/clarity/src/vm/coverage.rs
+++ b/clarity/src/vm/coverage.rs
@@ -1,7 +1,8 @@
-use std::collections::{BTreeMap, HashMap, HashSet};
+use std::collections::BTreeMap;
 use std::fs::File;
 use std::io::Write;
 
+use hashbrown::{HashMap, HashSet};
 use serde_json::Value as JsonValue;
 
 use super::functions::define::DefineFunctionsParsed;
diff --git a/clarity/src/vm/database/clarity_db.rs b/clarity/src/vm/database/clarity_db.rs
index 3d6cf40ae6..5ef6c458d2 100644
--- a/clarity/src/vm/database/clarity_db.rs
+++ b/clarity/src/vm/database/clarity_db.rs
@@ -14,7 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::collections::{HashMap, VecDeque};
 use std::convert::{TryFrom, TryInto};
 
 use serde_json;
diff --git a/clarity/src/vm/database/key_value_wrapper.rs b/clarity/src/vm/database/key_value_wrapper.rs
index 74b2c724fc..bc4b85a9b0 100644
--- a/clarity/src/vm/database/key_value_wrapper.rs
+++ b/clarity/src/vm/database/key_value_wrapper.rs
@@ -16,9 +16,9 @@
 
 use std::clone::Clone;
 use std::cmp::Eq;
-use std::collections::HashMap;
 use std::hash::Hash;
 
+use hashbrown::HashMap;
 use stacks_common::types::chainstate::StacksBlockId;
 use stacks_common::types::StacksEpochId;
 use stacks_common::util::hash::Sha512Trunc256Sum;
diff --git a/clarity/src/vm/database/mod.rs b/clarity/src/vm/database/mod.rs
index e02aee5c33..1092992982 100644
--- a/clarity/src/vm/database/mod.rs
+++ b/clarity/src/vm/database/mod.rs
@@ -14,7 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::collections::HashMap;
+use hashbrown::HashMap;
 
 pub use self::clarity_db::{
     BurnStateDB, ClarityDatabase, HeadersDB, StoreType, NULL_BURN_STATE_DB, NULL_HEADER_DB,
diff --git a/clarity/src/vm/docs/contracts.rs b/clarity/src/vm/docs/contracts.rs
index ff864b26db..b9f95d39d5 100644
--- a/clarity/src/vm/docs/contracts.rs
+++ b/clarity/src/vm/docs/contracts.rs
@@ -1,6 +1,7 @@
-use std::collections::{BTreeMap, HashMap, HashSet};
+use std::collections::BTreeMap;
 use std::iter::FromIterator;
 
+use hashbrown::{HashMap, HashSet};
 use stacks_common::consts::CHAIN_ID_TESTNET;
 use stacks_common::types::StacksEpochId;
 
diff --git a/clarity/src/vm/functions/define.rs b/clarity/src/vm/functions/define.rs
index 9451f17ff9..c9489c4320 100644
--- a/clarity/src/vm/functions/define.rs
+++ b/clarity/src/vm/functions/define.rs
@@ -14,7 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::collections::{BTreeMap, HashMap};
+use std::collections::BTreeMap;
 
 use crate::vm::callables::{DefineType, DefinedFunction};
 use crate::vm::contexts::{ContractContext, Environment, LocalContext};
diff --git a/clarity/src/vm/mod.rs b/clarity/src/vm/mod.rs
index 9f7c565599..7231ad584d 100644
--- a/clarity/src/vm/mod.rs
+++ b/clarity/src/vm/mod.rs
@@ -587,8 +587,7 @@ pub fn execute_v2(program: &str) -> Result<Option<Value>> {
 
 #[cfg(test)]
 mod test {
-    use std::collections::HashMap;
-
+    use hashbrown::HashMap;
     use stacks_common::consts::CHAIN_ID_TESTNET;
     use stacks_common::types::StacksEpochId;
 
diff --git a/clarity/src/vm/tests/assets.rs b/clarity/src/vm/tests/assets.rs
index 0f6551c366..883a8a6999 100644
--- a/clarity/src/vm/tests/assets.rs
+++ b/clarity/src/vm/tests/assets.rs
@@ -440,7 +440,7 @@ fn test_native_stx_ops(epoch: StacksEpochId, mut env_factory: TopLevelMemoryEnvi
 
     let table = asset_map.to_table();
 
-    let contract_principal = token_contract_id.clone().into();
+    let contract_principal = PrincipalData::from(token_contract_id.clone());
 
     assert_eq!(
         table[&contract_principal][&AssetIdentifier::STX()],
diff --git a/clarity/src/vm/tests/principals.rs b/clarity/src/vm/tests/principals.rs
index bc136638f9..78fcf17659 100644
--- a/clarity/src/vm/tests/principals.rs
+++ b/clarity/src/vm/tests/principals.rs
@@ -1,5 +1,4 @@
-use std::collections::HashMap;
-
+use hashbrown::HashMap;
 use stacks_common::types::StacksEpochId;
 use stacks_common::util::hash::hex_bytes;
 
diff --git a/clarity/src/vm/types/serialization.rs b/clarity/src/vm/types/serialization.rs
index efb616cdb4..fae9a00b0b 100644
--- a/clarity/src/vm/types/serialization.rs
+++ b/clarity/src/vm/types/serialization.rs
@@ -15,11 +15,11 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::borrow::Borrow;
-use std::collections::HashMap;
 use std::convert::{TryFrom, TryInto};
 use std::io::{Read, Write};
 use std::{cmp, error, fmt, str};
 
+use hashbrown::HashMap;
 use lazy_static::lazy_static;
 use serde_json::Value as JSONValue;
 use stacks_common::codec::{Error as codec_error, StacksMessageCodec};
diff --git a/clarity/src/vm/types/signatures.rs b/clarity/src/vm/types/signatures.rs
index 246191f288..2c0f47f334 100644
--- a/clarity/src/vm/types/signatures.rs
+++ b/clarity/src/vm/types/signatures.rs
@@ -15,12 +15,13 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::collections::btree_map::Entry;
-// TypeSignatures
-use std::collections::{BTreeMap, HashMap, HashSet};
+use std::collections::BTreeMap;
 use std::convert::{TryFrom, TryInto};
 use std::hash::{Hash, Hasher};
 use std::{cmp, fmt};
 
+// TypeSignatures
+use hashbrown::HashSet;
 use lazy_static::lazy_static;
 use stacks_common::address::c32;
 use stacks_common::types::StacksEpochId;
diff --git a/contrib/tools/relay-server/Cargo.toml b/contrib/tools/relay-server/Cargo.toml
index 756a5603bc..3736469065 100644
--- a/contrib/tools/relay-server/Cargo.toml
+++ b/contrib/tools/relay-server/Cargo.toml
@@ -8,3 +8,4 @@ name = "relay-server"
 path = "src/main.rs"
 
 [dependencies]
+hashbrown = { workspace = true }
diff --git a/contrib/tools/relay-server/src/http.rs b/contrib/tools/relay-server/src/http.rs
index e2f84815a2..c84f833bee 100644
--- a/contrib/tools/relay-server/src/http.rs
+++ b/contrib/tools/relay-server/src/http.rs
@@ -1,6 +1,7 @@
-use std::collections::HashMap;
 use std::io::{Error, Read};
 
+use hashbrown::HashMap;
+
 use crate::to_io_result::ToIoResult;
 
 #[derive(Debug)]
diff --git a/contrib/tools/relay-server/src/state.rs b/contrib/tools/relay-server/src/state.rs
index caaea7984d..084779c8d4 100644
--- a/contrib/tools/relay-server/src/state.rs
+++ b/contrib/tools/relay-server/src/state.rs
@@ -1,4 +1,4 @@
-use std::collections::HashMap;
+use hashbrown::HashMap;
 
 #[derive(Default)]
 pub struct State {
diff --git a/contrib/tools/relay-server/src/url.rs b/contrib/tools/relay-server/src/url.rs
index 8c562c8ef1..aedc5711d8 100644
--- a/contrib/tools/relay-server/src/url.rs
+++ b/contrib/tools/relay-server/src/url.rs
@@ -1,4 +1,4 @@
-use std::collections::HashMap;
+use hashbrown::HashMap;
 
 pub trait QueryEx {
     fn url_query(&self) -> HashMap<&str, &str>;
diff --git a/libsigner/Cargo.toml b/libsigner/Cargo.toml
index 1d935d6257..4b1f21eef7 100644
--- a/libsigner/Cargo.toml
+++ b/libsigner/Cargo.toml
@@ -17,7 +17,7 @@ path = "./src/libsigner.rs"
 
 [dependencies]
 clarity = { path = "../clarity" }
-hashbrown = "0.14"
+hashbrown = { workspace = true }
 libc = "0.2"
 libstackerdb = { path = "../libstackerdb" }
 serde = "1"
diff --git a/libsigner/src/http.rs b/libsigner/src/http.rs
index 78ae50a2b5..f5ba9bb2bf 100644
--- a/libsigner/src/http.rs
+++ b/libsigner/src/http.rs
@@ -14,11 +14,11 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::collections::HashMap;
 use std::io;
 use std::io::{Read, Write};
 use std::net::SocketAddr;
 
+use hashbrown::HashMap;
 use stacks_common::codec::MAX_MESSAGE_LEN;
 use stacks_common::deps_common::httparse;
 use stacks_common::util::chunked_encoding::*;
diff --git a/libsigner/src/tests/http.rs b/libsigner/src/tests/http.rs
index 4582b07160..3fac7c337c 100644
--- a/libsigner/src/tests/http.rs
+++ b/libsigner/src/tests/http.rs
@@ -14,10 +14,10 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::collections::HashMap;
 use std::io::{Read, Write};
 use std::{io, str};
 
+use hashbrown::HashMap;
 use stacks_common::util::chunked_encoding::*;
 
 use crate::error::{EventError, RPCError};
diff --git a/stacks-common/Cargo.toml b/stacks-common/Cargo.toml
index 0896442d7a..50eadfb85d 100644
--- a/stacks-common/Cargo.toml
+++ b/stacks-common/Cargo.toml
@@ -32,6 +32,7 @@ slog-json = { version = "2.3.0", optional = true }
 chrono = "0.4.19"
 libc = "0.2.82"
 wsts = { workspace = true }
+hashbrown = { workspace = true }
 
 [target.'cfg(unix)'.dependencies]
 nix = "0.23"
diff --git a/stacks-common/src/deps_common/bitcoin/network/encodable.rs b/stacks-common/src/deps_common/bitcoin/network/encodable.rs
index 1054e28463..f14ee1fb85 100644
--- a/stacks-common/src/deps_common/bitcoin/network/encodable.rs
+++ b/stacks-common/src/deps_common/bitcoin/network/encodable.rs
@@ -29,10 +29,11 @@
 //! big-endian decimals, etc.)
 //!
 
-use std::collections::HashMap;
 use std::hash::Hash;
 use std::{mem, u32};
 
+use hashbrown::HashMap;
+
 use crate::deps_common::bitcoin::network::serialize::{self, SimpleDecoder, SimpleEncoder};
 use crate::deps_common::bitcoin::util::hash::Sha256dHash;
 
diff --git a/stacks-signer/Cargo.toml b/stacks-signer/Cargo.toml
index 899725fb89..8944c10342 100644
--- a/stacks-signer/Cargo.toml
+++ b/stacks-signer/Cargo.toml
@@ -23,7 +23,7 @@ path = "src/main.rs"
 backoff = "0.4"
 clarity = { path = "../clarity" }
 clap = { version = "4.1.1", features = ["derive", "env"] }
-hashbrown = "0.14"
+hashbrown = { workspace = true }
 libsigner = { path = "../libsigner" }
 libstackerdb = { path = "../libstackerdb" }
 rand_core = "0.6"
diff --git a/stackslib/Cargo.toml b/stackslib/Cargo.toml
index d1da07b0b8..40ddd8e847 100644
--- a/stackslib/Cargo.toml
+++ b/stackslib/Cargo.toml
@@ -56,8 +56,8 @@ stacks-common = { path = "../stacks-common" }
 pox-locking = { path = "../pox-locking" }
 libstackerdb = { path = "../libstackerdb" }
 siphasher = "0.3.7"
-wsts = {workspace = true}
-hashbrown = "0.14"
+wsts = { workspace = true }
+hashbrown = { workspace = true }
 
 [target.'cfg(unix)'.dependencies]
 nix = "0.23"
diff --git a/stackslib/src/chainstate/stacks/boot/docs.rs b/stackslib/src/chainstate/stacks/boot/docs.rs
index 3bf3f3cae4..08a203122a 100644
--- a/stackslib/src/chainstate/stacks/boot/docs.rs
+++ b/stackslib/src/chainstate/stacks/boot/docs.rs
@@ -1,7 +1,7 @@
-use std::collections::{HashMap, HashSet};
 use std::iter::FromIterator;
 
 use clarity::vm::docs::contracts::{produce_docs_refs, ContractSupportDocs};
+use hashbrown::{HashMap, HashSet};
 
 use super::STACKS_BOOT_CODE_MAINNET;
 
diff --git a/testnet/stacks-node/Cargo.toml b/testnet/stacks-node/Cargo.toml
index ae53315a7f..e4739e0c0b 100644
--- a/testnet/stacks-node/Cargo.toml
+++ b/testnet/stacks-node/Cargo.toml
@@ -30,7 +30,7 @@ libsigner = { path = "../../libsigner" }
 wsts = { workspace = true }
 rand = { workspace = true }
 rand_core = { workspace = true }
-hashbrown = "0.14"
+hashbrown = { workspace = true }
 
 [dev-dependencies]
 ring = "0.16.19"

From e8322edf2db8406bb730041a43b04637c51004eb Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Tue, 20 Feb 2024 14:56:56 -0500
Subject: [PATCH 0823/1166] chore: Address Jude's PR comments

---
 stackslib/src/net/prune.rs | 20 ++++++--------------
 1 file changed, 6 insertions(+), 14 deletions(-)

diff --git a/stackslib/src/net/prune.rs b/stackslib/src/net/prune.rs
index 3c0e5c2a14..d7991a67c3 100644
--- a/stackslib/src/net/prune.rs
+++ b/stackslib/src/net/prune.rs
@@ -71,12 +71,10 @@ impl PeerNetwork {
                         Some(peer) => {
                             let stats = convo.stats.clone();
                             let org = peer.org;
-                            if let std::collections::hash_map::Entry::Vacant(e) =
-                                org_neighbor.entry(org)
-                            {
-                                e.insert(vec![(nk, stats)]);
+                            if let Some(stats_list) = org_neighbor.get_mut(&org) {
+                                stats_list.push((nk, stats));
                             } else {
-                                org_neighbor.get_mut(&org).unwrap().push((nk, stats));
+                                org_neighbor.insert(org, vec![(nk, stats)]);
                             }
                         }
                     };
@@ -328,16 +326,10 @@ impl PeerNetwork {
                 Some(ref convo) => {
                     if !convo.stats.outbound {
                         let stats = convo.stats.clone();
-                        if let std::collections::hash_map::Entry::Vacant(e) =
-                            ip_neighbor.entry(nk.addrbytes)
-                        {
-                            e.insert(vec![(*event_id, nk.clone(), stats)]);
+                        if let Some(entry) = ip_neighbor.get_mut(&nk.addrbytes) {
+                            entry.push((*event_id, nk.clone(), stats));
                         } else {
-                            ip_neighbor.get_mut(&nk.addrbytes).unwrap().push((
-                                *event_id,
-                                nk.clone(),
-                                stats,
-                            ));
+                            ip_neighbor.insert(nk.addrbytes, vec![(*event_id, nk.clone(), stats)]);
                         }
                     }
                 }

From a92dbdb83b069ceb500f0e61ecf71739619f4d6c Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Tue, 20 Feb 2024 15:37:06 -0500
Subject: [PATCH 0824/1166] refactor: delete `aggregate-public-keys` from pox-4

This map is now in the signers-voting contract.
---
 stackslib/src/chainstate/stacks/boot/pox-4.clar | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index c375a5fe1f..b50c4014b3 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -207,10 +207,6 @@
     { stacked-amount: uint }
 )
 
-;; The stackers' aggregate public key
-;;   for the given reward cycle
-(define-map aggregate-public-keys uint (buff 33))
-
 ;; What's the reward cycle number of the burnchain block height?
 ;; Will runtime-abort if height is less than the first burnchain block (this is intentional)
 (define-read-only (burn-height-to-reward-cycle (height uint))

From f596c0bf5b0c463859b2a25d0322f40a6efd8c0d Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Tue, 20 Feb 2024 15:39:26 -0500
Subject: [PATCH 0825/1166] fix: use `reward-cycle` parameter to get signer
 weight

---
 stackslib/src/chainstate/stacks/boot/signers-voting.clar | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers-voting.clar b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
index 68545b6cac..0c0b4aa096 100644
--- a/stackslib/src/chainstate/stacks/boot/signers-voting.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
@@ -61,10 +61,6 @@
 (define-read-only (get-tally (reward-cycle uint) (round uint) (aggregate-public-key (buff 33)))
     (map-get? tally {reward-cycle: reward-cycle, round: round, aggregate-public-key: aggregate-public-key}))
 
-(define-read-only (get-current-signer-weight (signer-index uint))
-    (let ((cycle (+ u1 (burn-height-to-reward-cycle burn-block-height))))
-      (get-signer-weight signer-index cycle)))
-
 (define-read-only (get-signer-weight (signer-index uint) (reward-cycle uint))
     (let ((details (unwrap! (try! (contract-call? .signers get-signer-by-index reward-cycle signer-index)) (err ERR_INVALID_SIGNER_INDEX))))
         (asserts! (is-eq (get signer details) tx-sender) (err ERR_SIGNER_INDEX_MISMATCH))
@@ -130,7 +126,7 @@
 (define-public (vote-for-aggregate-public-key (signer-index uint) (key (buff 33)) (round uint) (reward-cycle uint))
     (let ((tally-key {reward-cycle: reward-cycle, round: round, aggregate-public-key: key})
             ;; vote by signer weight
-            (signer-weight (try! (get-current-signer-weight signer-index)))
+            (signer-weight (try! (get-signer-weight signer-index reward-cycle)))
             (new-total (+ signer-weight (default-to u0 (map-get? tally tally-key))))
             (total-weight (try! (get-total-weight reward-cycle))))
         ;; Check that the key has not yet been set for this reward cycle

From c8654f952ef01fdbe1f2af70d4884c1697fc84f8 Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Tue, 20 Feb 2024 15:57:26 -0500
Subject: [PATCH 0826/1166] fix: update expected error after cycle fix in
 previous commit

---
 .../src/chainstate/stacks/boot/signers_voting_tests.rs      | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
index 6719cf8e95..e6fca17f91 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
@@ -368,7 +368,7 @@ fn vote_for_aggregate_public_key_with_errors() {
             0,
             cycle_id + 1,
         ),
-        // Alice casts a vote with an incorrect reward cycle - should return failed to retrieve signers error
+        // Alice casts a vote with an incorrect reward cycle - should return cycle not set error
         make_signers_vote_for_aggregate_public_key_value(
             alice_key,
             alice_nonce + 3,
@@ -451,12 +451,12 @@ fn vote_for_aggregate_public_key_with_errors() {
         Value::err_uint(13) // ERR_ILL_FORMED_AGGREGATE_PUBLIC_KEY
     );
 
-    // Alice's fourth vote should fail (failed to retrieve signers)
+    // Alice's fourth vote should fail (cycle not set)
     let alice_fourth_vote_tx = &receipts[5];
     let alice_fourth_vote_tx_result = alice_fourth_vote_tx.result.clone();
     assert_eq!(
         alice_fourth_vote_tx_result,
-        Value::err_uint(16) // ERR_FAILED_TO_RETRIEVE_SIGNERS
+        Value::err_uint(2) // ERR_CYCLE_NOT_SET
     );
 
     // Alice's fifth  vote, correct vote should succeed

From 51f0c9142abfa1ba139234c7743f059d48c0ecfa Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Tue, 20 Feb 2024 16:02:42 -0500
Subject: [PATCH 0827/1166] chore: assert that signers are not repeated in
 tests

---
 stackslib/src/chainstate/nakamoto/coordinator/tests.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index bbd5ff4406..6ec545c357 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -178,7 +178,8 @@ pub fn make_all_signers_vote_for_aggregate_key(
             .unwrap()
             .expect_principal()
             .unwrap();
-        signers_to_index.insert(signer, index);
+        let insert_res = signers_to_index.insert(signer, index);
+        assert!(insert_res.is_none(), "Duplicate signer in signers list");
     }
 
     // Build a map of the signers, their private keys, and their index

From 0fdaf62fb6350b6062b4a9819227860f0d7a814d Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Tue, 20 Feb 2024 16:35:31 -0500
Subject: [PATCH 0828/1166] refactor: refactoring suggestions from review

---
 .../chainstate/nakamoto/coordinator/tests.rs  | 16 ++---------
 .../src/chainstate/nakamoto/tests/node.rs     | 28 ++-----------------
 stackslib/src/net/mod.rs                      | 19 +++++++++++++
 3 files changed, 23 insertions(+), 40 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index 6ec545c357..59d73748b5 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -1138,13 +1138,7 @@ pub fn simple_nakamoto_coordinator_10_tenures_10_sortitions<'a>() -> TestPeer<'a
 
         let num_blocks: usize = (thread_rng().gen::<usize>() % 10) + 1;
 
-        let block_height = peer
-            .config
-            .burnchain
-            .get_highest_burnchain_block()
-            .unwrap()
-            .unwrap()
-            .block_height;
+        let block_height = peer.get_burn_block_height();
         // If we are in the prepare phase, check if we need to generate
         // aggregate key votes
         let txs = if peer.config.burnchain.is_in_prepare_phase(block_height) {
@@ -1869,13 +1863,7 @@ pub fn simple_nakamoto_coordinator_10_extended_tenures_10_sortitions() -> TestPe
 
         debug!("Next burnchain block: {}", &consensus_hash);
 
-        let block_height = peer
-            .config
-            .burnchain
-            .get_highest_burnchain_block()
-            .unwrap()
-            .unwrap()
-            .block_height;
+        let block_height = peer.get_burn_block_height();
         // If we are in the prepare phase, check if we need to generate
         // aggregate key votes
         let txs = if peer.config.burnchain.is_in_prepare_phase(block_height) {
diff --git a/stackslib/src/chainstate/nakamoto/tests/node.rs b/stackslib/src/chainstate/nakamoto/tests/node.rs
index 8f658393d3..b34cd130cc 100644
--- a/stackslib/src/chainstate/nakamoto/tests/node.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/node.rs
@@ -980,22 +980,10 @@ impl<'a> TestPeer<'a> {
             &[(NakamotoBlock, u64, ExecutionCost)],
         ) -> Vec<StacksTransaction>,
     {
+        let cycle = self.get_reward_cycle();
         let mut stacks_node = self.stacks_node.take().unwrap();
         let sortdb = self.sortdb.take().unwrap();
 
-        let burn_height = self
-            .coord
-            .burnchain
-            .get_highest_burnchain_block()
-            .unwrap()
-            .unwrap()
-            .block_height;
-        let cycle = self
-            .miner
-            .burnchain
-            .block_height_to_reward_cycle(burn_height)
-            .expect("FATAL: failed to get reward cycle");
-
         // Ensure the signers are setup for the current cycle
         signers.generate_aggregate_key(cycle);
 
@@ -1047,22 +1035,10 @@ impl<'a> TestPeer<'a> {
             &[(NakamotoBlock, u64, ExecutionCost)],
         ) -> Vec<StacksTransaction>,
     {
+        let cycle = self.get_reward_cycle();
         let mut stacks_node = self.stacks_node.take().unwrap();
         let sortdb = self.sortdb.take().unwrap();
 
-        let burn_height = self
-            .coord
-            .burnchain
-            .get_highest_burnchain_block()
-            .unwrap()
-            .unwrap()
-            .block_height;
-        let cycle = self
-            .miner
-            .burnchain
-            .block_height_to_reward_cycle(burn_height)
-            .expect("FATAL: failed to get reward cycle");
-
         // Ensure the signers are setup for the current cycle
         signers.generate_aggregate_key(cycle);
 
diff --git a/stackslib/src/net/mod.rs b/stackslib/src/net/mod.rs
index 974faa710b..0c1725d6b9 100644
--- a/stackslib/src/net/mod.rs
+++ b/stackslib/src/net/mod.rs
@@ -3623,6 +3623,25 @@ pub mod test {
                 vec![],
             )
         }
+
+        pub fn get_burn_block_height(&self) -> u64 {
+            SortitionDB::get_canonical_burn_chain_tip(
+                &self.sortdb.as_ref().expect("Failed to get sortdb").conn(),
+            )
+            .expect("Failed to get canonical burn chain tip")
+            .block_height
+        }
+
+        pub fn get_reward_cycle(&self) -> u64 {
+            let block_height = self.get_burn_block_height();
+            self.config
+                .burnchain
+                .block_height_to_reward_cycle(block_height)
+                .expect(&format!(
+                    "Failed to get reward cycle for block height {}",
+                    block_height
+                ))
+        }
     }
 
     pub fn to_addr(sk: &StacksPrivateKey) -> StacksAddress {

From 059ae88deae783081abdf159debcd2bd8d62e200 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Sun, 11 Feb 2024 16:24:49 -0500
Subject: [PATCH 0829/1166] chore: Use `jemalloc` global allocator on supported
 platforms

---
 Cargo.lock                      | 22 ++++++++++++++++++++++
 Cargo.toml                      |  1 +
 stackslib/Cargo.toml            |  3 +++
 stackslib/src/main.rs           |  7 +++++++
 testnet/stacks-node/Cargo.toml  |  3 +++
 testnet/stacks-node/src/main.rs |  7 +++++++
 6 files changed, 43 insertions(+)

diff --git a/Cargo.lock b/Cargo.lock
index 4ea7bc8652..74c4a5efc7 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3512,6 +3512,7 @@ dependencies = [
  "stacks-signer",
  "stackslib",
  "stx-genesis",
+ "tikv-jemallocator",
  "tokio",
  "toml 0.5.11",
  "tracing",
@@ -3593,6 +3594,7 @@ dependencies = [
  "stacks-common",
  "stdext",
  "stx-genesis",
+ "tikv-jemallocator",
  "time 0.2.27",
  "url",
  "winapi 0.3.9",
@@ -3806,6 +3808,26 @@ dependencies = [
  "once_cell",
 ]
 
+[[package]]
+name = "tikv-jemalloc-sys"
+version = "0.5.4+5.3.0-patched"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9402443cb8fd499b6f327e40565234ff34dbda27460c5b47db0db77443dd85d1"
+dependencies = [
+ "cc",
+ "libc",
+]
+
+[[package]]
+name = "tikv-jemallocator"
+version = "0.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "965fe0c26be5c56c94e38ba547249074803efd52adfb66de62107d95aab3eaca"
+dependencies = [
+ "libc",
+ "tikv-jemalloc-sys",
+]
+
 [[package]]
 name = "time"
 version = "0.2.27"
diff --git a/Cargo.toml b/Cargo.toml
index b6606497c4..66791df99c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -19,6 +19,7 @@ hashbrown = "0.14.3"
 rand_core = "0.6"
 rand = "0.8"
 rand_chacha = "0.3.1"
+tikv-jemallocator = "0.5.4"
 wsts = { version = "8.1", default-features = false }
 
 # Use a bit more than default optimization for
diff --git a/stackslib/Cargo.toml b/stackslib/Cargo.toml
index 40ddd8e847..ba67b5c1fe 100644
--- a/stackslib/Cargo.toml
+++ b/stackslib/Cargo.toml
@@ -59,6 +59,9 @@ siphasher = "0.3.7"
 wsts = { workspace = true }
 hashbrown = { workspace = true }
 
+[target.'cfg(not(target_env = "msvc"))'.dependencies]
+tikv-jemallocator = {workspace = true}
+
 [target.'cfg(unix)'.dependencies]
 nix = "0.23"
 
diff --git a/stackslib/src/main.rs b/stackslib/src/main.rs
index d7c9fcd356..f6a901e5ec 100644
--- a/stackslib/src/main.rs
+++ b/stackslib/src/main.rs
@@ -26,6 +26,13 @@ extern crate stacks_common;
 #[macro_use(o, slog_log, slog_trace, slog_debug, slog_info, slog_warn, slog_error)]
 extern crate slog;
 
+#[cfg(not(target_env = "msvc"))]
+use tikv_jemallocator::Jemalloc;
+
+#[cfg(not(target_env = "msvc"))]
+#[global_allocator]
+static GLOBAL: Jemalloc = Jemalloc;
+
 use std::collections::{HashMap, HashSet};
 use std::convert::TryFrom;
 use std::fs::{File, OpenOptions};
diff --git a/testnet/stacks-node/Cargo.toml b/testnet/stacks-node/Cargo.toml
index e4739e0c0b..5d9d964a1f 100644
--- a/testnet/stacks-node/Cargo.toml
+++ b/testnet/stacks-node/Cargo.toml
@@ -32,6 +32,9 @@ rand = { workspace = true }
 rand_core = { workspace = true }
 hashbrown = { workspace = true }
 
+[target.'cfg(not(target_env = "msvc"))'.dependencies]
+tikv-jemallocator = {workspace = true}
+
 [dev-dependencies]
 ring = "0.16.19"
 warp = "0.3.5"
diff --git a/testnet/stacks-node/src/main.rs b/testnet/stacks-node/src/main.rs
index 3418ed9726..08da97dd53 100644
--- a/testnet/stacks-node/src/main.rs
+++ b/testnet/stacks-node/src/main.rs
@@ -58,6 +58,13 @@ use crate::mockamoto::MockamotoNode;
 use crate::neon_node::{BlockMinerThread, TipCandidate};
 use crate::run_loop::boot_nakamoto;
 
+#[cfg(not(target_env = "msvc"))]
+use tikv_jemallocator::Jemalloc;
+
+#[cfg(not(target_env = "msvc"))]
+#[global_allocator]
+static GLOBAL: Jemalloc = Jemalloc;
+
 /// Implmentation of `pick_best_tip` CLI option
 fn cli_pick_best_tip(config_path: &str, at_stacks_height: Option<u64>) -> TipCandidate {
     info!("Loading config at path {}", config_path);

From 252a98cc906bf7c7fe6f6b1b73eb9a0e29ca3ea6 Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Tue, 20 Feb 2024 23:34:22 -0500
Subject: [PATCH 0830/1166] refactor: various refactoring suggestions from
 review

---
 .../stacks/boot/signers-voting.clar           | 48 +++++++++++--------
 1 file changed, 27 insertions(+), 21 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers-voting.clar b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
index 0c0b4aa096..91062366e1 100644
--- a/stackslib/src/chainstate/stacks/boot/signers-voting.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
@@ -66,8 +66,8 @@
         (asserts! (is-eq (get signer details) tx-sender) (err ERR_SIGNER_INDEX_MISMATCH))
         (ok (get weight details))))
 
-;; aggregate public key must be unique and can be used only in a single cycle-round pair
-(define-read-only (is-valid-aggregate-public-key (key (buff 33)) (reward-cycle uint))
+;; aggregate public key must be unique and can be used only in a single cycle
+(define-read-only (is-novel-aggregate-public-key (key (buff 33)) (reward-cycle uint))
     (is-eq (default-to reward-cycle (map-get? used-aggregate-public-keys key)) reward-cycle))
 
 (define-read-only (is-in-prepare-phase (height uint))
@@ -89,7 +89,7 @@
 (define-private (sum-weights (signer { signer: principal, weight: uint }) (acc uint))
     (+ acc (get weight signer)))
 
-(define-private (get-total-weight (reward-cycle uint))
+(define-private (get-and-cache-total-weight (reward-cycle uint))
     (match (map-get? cycle-total-weight reward-cycle)
         total (ok total)
         (let ((signers (unwrap! (contract-call? .signers get-signers reward-cycle) (err ERR_FAILED_TO_RETRIEVE_SIGNERS)))
@@ -97,11 +97,17 @@
             (map-set cycle-total-weight reward-cycle total)
             (ok total))))
 
+;; If the round is not set, or the new round is greater than the last round,
+;; update the last round.
+;; Returns:
+;;  * `(ok true)` if this is the first round for the reward cycle
+;;  * `(ok false)` if this is a new last round for the reward cycle
+;;  * `(err ERR_INVALID_ROUND)` if the round is incremented by more than 1
 (define-private (update-last-round (reward-cycle uint) (round uint))
     (ok (match (map-get? rounds reward-cycle)
         last-round (begin
             (asserts! (<= round (+ last-round u1)) (err ERR_INVALID_ROUND))
-            (and (> round last-round) (map-set rounds reward-cycle round)))
+            (if (> round last-round) (map-set rounds reward-cycle round) false))
         (map-set rounds reward-cycle round))))
 
 ;; Signer vote for the aggregate public key of the next reward cycle
@@ -128,13 +134,13 @@
             ;; vote by signer weight
             (signer-weight (try! (get-signer-weight signer-index reward-cycle)))
             (new-total (+ signer-weight (default-to u0 (map-get? tally tally-key))))
-            (total-weight (try! (get-total-weight reward-cycle))))
+            (total-weight (try! (get-and-cache-total-weight reward-cycle))))
         ;; Check that the key has not yet been set for this reward cycle
         (asserts! (is-none (map-get? aggregate-public-keys reward-cycle)) (err ERR_OUT_OF_VOTING_WINDOW))
         ;; Check that the aggregate public key is the correct length
         (asserts! (is-eq (len key) u33) (err ERR_ILL_FORMED_AGGREGATE_PUBLIC_KEY))
         ;; Check that aggregate public key has not been used in a previous reward cycle
-        (asserts! (is-valid-aggregate-public-key key reward-cycle) (err ERR_DUPLICATE_AGGREGATE_PUBLIC_KEY))
+        (asserts! (is-novel-aggregate-public-key key reward-cycle) (err ERR_DUPLICATE_AGGREGATE_PUBLIC_KEY))
         ;; Check that signer hasn't voted in this reward-cycle & round
         (asserts! (map-insert votes {reward-cycle: reward-cycle, round: round, signer: tx-sender} {aggregate-public-key: key, signer-weight: signer-weight}) (err ERR_DUPLICATE_VOTE))
         ;; Check that the round is incremented by at most 1
@@ -151,22 +157,22 @@
             key: key,
             new-total: new-total,
         })
-        ;; Check if consensus has been reached
-        (and
-            ;; If the new total weight is greater than or equal to the threshold consensus
-            (>= (/ (* new-total u1000) total-weight) threshold-consensus)
+        ;; If the new total weight is greater than or equal to the threshold consensus
+        (if (>= (/ (* new-total u1000) total-weight) threshold-consensus)
             ;; Save this approved aggregate public key for this reward cycle.
-            ;; If there is already a key for this cycle, this will return false
-            ;; there will be no duplicate event.
-            (map-insert aggregate-public-keys reward-cycle key)
-            ;; Create an event for the approved aggregate public key
-            (begin
-                (print {
-                    event: "approved-aggregate-public-key",
-                    reward-cycle: reward-cycle,
-                    key: key,
-                })
-                true
+            ;; If there is not already a key for this cycle, the insert will
+            ;; return true and an event will be created.
+            (if (map-insert aggregate-public-keys reward-cycle key)
+                (begin
+                    ;; Create an event for the approved aggregate public key
+                    (print {
+                        event: "approved-aggregate-public-key",
+                        reward-cycle: reward-cycle,
+                        key: key,
+                    })
+                    true)
+                false
             )
+            false
         )
         (ok true)))

From e793b737773555acc79c1cd1a78ad8b55e63f15c Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Mon, 19 Feb 2024 22:25:34 -0500
Subject: [PATCH 0831/1166] test: add test for out of window error

---
 .../stacks/boot/signers_voting_tests.rs       | 244 +++++++++++++++++-
 1 file changed, 240 insertions(+), 4 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
index e6fca17f91..9834531ef8 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
@@ -293,9 +293,8 @@ fn vote_for_aggregate_public_key_success() {
     }
 }
 
-/// In this test case, Alice & Bob both successfully vote for the same key
-/// Alice votes first, casting one correct vote & four incorrect votes
-/// that hit all tenure-agnostic errors. Bob votes once, successfully.
+/// In this test case, Alice & Bob both successfully vote for the same key,
+/// but also trigger all tenure-agnostic errors.
 #[test]
 fn vote_for_aggregate_public_key_with_errors() {
     // Test setup
@@ -420,7 +419,7 @@ fn vote_for_aggregate_public_key_with_errors() {
     //
     let blocks_and_sizes = nakamoto_tenure(&mut peer, &mut test_signers, vec![txs]);
 
-    // check the last two txs in the last block
+    // check the last eight txs in the last block
     let block = observer.get_blocks().last().unwrap().clone();
     let receipts = block.receipts.as_slice();
     assert_eq!(receipts.len(), 10);
@@ -551,6 +550,243 @@ fn vote_for_aggregate_public_key_with_errors() {
     }
 }
 
+/// 4 stackers vote for the same aggregate public key. The threshold is reached
+/// after the 3rd vote, so the 4th gets an "out of voting window" error.
+#[test]
+fn vote_for_aggregate_public_key_out_of_window() {
+    // Test setup
+    let stacker1 = TestStacker::from_seed(&[3, 4]);
+    let stacker2 = TestStacker::from_seed(&[5, 6]);
+    let stacker3 = TestStacker::from_seed(&[7, 8]);
+    let stacker4 = TestStacker::from_seed(&[9, 10]);
+    let observer = TestEventObserver::new();
+
+    // Signer 1
+    let stacker1_key = &stacker1.signer_private_key;
+    let stacker1_address = key_to_stacks_addr(stacker1_key);
+    let stacker1_principal = PrincipalData::from(stacker1_address);
+
+    // Signer 2
+    let stacker2_key = &stacker2.signer_private_key;
+    let stacker2_address = key_to_stacks_addr(stacker2_key);
+    let stacker2_principal = PrincipalData::from(stacker2_address);
+
+    // Signer 3
+    let stacker3_key = &stacker3.signer_private_key;
+    let stacker3_address = key_to_stacks_addr(stacker3_key);
+    let stacker3_principal = PrincipalData::from(stacker3_address);
+
+    // Signer 4
+    let stacker4_key = &stacker4.signer_private_key;
+    let stacker4_address = key_to_stacks_addr(stacker4_key);
+    let stacker4_principal = PrincipalData::from(stacker4_address);
+
+    let (mut peer, mut test_signers, latest_block_id, current_reward_cycle) = prepare_signers_test(
+        function_name!(),
+        vec![
+            (stacker1_principal.clone(), 1000),
+            (stacker2_principal.clone(), 1000),
+            (stacker3_principal.clone(), 1000),
+            (stacker4_principal.clone(), 1000),
+        ],
+        &[
+            stacker1.clone(),
+            stacker2.clone(),
+            stacker3.clone(),
+            stacker4.clone(),
+        ],
+        Some(&observer),
+    );
+
+    // Stackers will each have voted once while booting to Nakamoto
+    let stacker1_nonce = 1;
+    let stacker2_nonce = 1;
+    let stacker3_nonce = 1;
+    let stacker4_nonce = 1;
+
+    let cycle_id = current_reward_cycle;
+
+    // create vote txs
+    let stacker1_index = get_signer_index(&mut peer, latest_block_id, stacker1_address, cycle_id);
+    let stacker2_index = get_signer_index(&mut peer, latest_block_id, stacker2_address, cycle_id);
+    let stacker3_index = get_signer_index(&mut peer, latest_block_id, stacker3_address, cycle_id);
+    let stacker4_index = get_signer_index(&mut peer, latest_block_id, stacker4_address, cycle_id);
+
+    let aggregate_public_key_point: Point = Point::new();
+    let aggregate_public_key =
+        Value::buff_from(aggregate_public_key_point.compress().data.to_vec())
+            .expect("Failed to serialize aggregate public key");
+
+    let txs = vec![
+        // stacker1 casts vote correctly
+        make_signers_vote_for_aggregate_public_key_value(
+            stacker1_key,
+            stacker1_nonce,
+            stacker1_index,
+            aggregate_public_key.clone(),
+            0,
+            cycle_id + 1,
+        ),
+        // stacker2 casts vote correctly
+        make_signers_vote_for_aggregate_public_key_value(
+            stacker2_key,
+            stacker2_nonce,
+            stacker2_index,
+            aggregate_public_key.clone(),
+            0,
+            cycle_id + 1,
+        ),
+        // stacker3 casts vote correctly
+        make_signers_vote_for_aggregate_public_key_value(
+            stacker3_key,
+            stacker3_nonce,
+            stacker3_index,
+            aggregate_public_key.clone(),
+            0,
+            cycle_id + 1,
+        ),
+        // stacker4 casts vote correctly, but it will return an out of voting window error
+        make_signers_vote_for_aggregate_public_key_value(
+            stacker4_key,
+            stacker4_nonce,
+            stacker4_index,
+            aggregate_public_key.clone(),
+            0,
+            cycle_id + 1,
+        ),
+    ];
+
+    //
+    // vote in the first burn block of prepare phase
+    //
+    let blocks_and_sizes = nakamoto_tenure(&mut peer, &mut test_signers, vec![txs]);
+
+    // check the last two txs in the last block
+    let block = observer.get_blocks().last().unwrap().clone();
+    let receipts = block.receipts.as_slice();
+    assert_eq!(receipts.len(), 6);
+    // ignore tenure change tx
+    // ignore tenure coinbase tx
+
+    // stacker1's vote should succeed
+    let stacker1_vote_tx = &receipts[2];
+    assert_eq!(stacker1_vote_tx.result, Value::okay_true());
+    assert_eq!(stacker1_vote_tx.events.len(), 1);
+    let stacker1_vote_event = &stacker1_vote_tx.events[0];
+    if let StacksTransactionEvent::SmartContractEvent(contract_event) = stacker1_vote_event {
+        assert_eq!(
+            contract_event.value,
+            TupleData::from_data(vec![
+                (
+                    "event".into(),
+                    Value::string_ascii_from_bytes("voted".as_bytes().to_vec())
+                        .expect("Failed to create string")
+                ),
+                ("key".into(), aggregate_public_key.clone()),
+                ("new-total".into(), Value::UInt(1)),
+                ("reward-cycle".into(), Value::UInt(cycle_id + 1)),
+                ("round".into(), Value::UInt(0)),
+                (
+                    "signer".into(),
+                    Value::Principal(stacker1_principal.clone())
+                ),
+            ])
+            .expect("Failed to create tuple")
+            .into()
+        );
+    } else {
+        panic!("Expected SmartContractEvent, got {:?}", stacker1_vote_event);
+    }
+
+    // stacker2's vote should succeed
+    let stacker2_vote_tx = &receipts[3];
+    assert_eq!(stacker2_vote_tx.result, Value::okay_true());
+    assert_eq!(stacker2_vote_tx.events.len(), 1);
+    let stacker2_vote_event = &stacker2_vote_tx.events[0];
+    if let StacksTransactionEvent::SmartContractEvent(contract_event) = stacker2_vote_event {
+        assert_eq!(
+            contract_event.value,
+            TupleData::from_data(vec![
+                (
+                    "event".into(),
+                    Value::string_ascii_from_bytes("voted".as_bytes().to_vec())
+                        .expect("Failed to create string")
+                ),
+                ("key".into(), aggregate_public_key.clone()),
+                ("new-total".into(), Value::UInt(2)),
+                ("reward-cycle".into(), Value::UInt(cycle_id + 1)),
+                ("round".into(), Value::UInt(0)),
+                (
+                    "signer".into(),
+                    Value::Principal(stacker2_principal.clone())
+                ),
+            ])
+            .expect("Failed to create tuple")
+            .into()
+        );
+    } else {
+        panic!("Expected SmartContractEvent, got {:?}", stacker2_vote_event);
+    }
+
+    // stacker3's vote should succeed
+    let stacker3_vote_tx = &receipts[4];
+    assert_eq!(stacker3_vote_tx.result, Value::okay_true());
+    assert_eq!(stacker3_vote_tx.events.len(), 2);
+    let stacker3_vote_event = &stacker3_vote_tx.events[0];
+    if let StacksTransactionEvent::SmartContractEvent(contract_event) = stacker3_vote_event {
+        assert_eq!(
+            contract_event.value,
+            TupleData::from_data(vec![
+                (
+                    "event".into(),
+                    Value::string_ascii_from_bytes("voted".as_bytes().to_vec())
+                        .expect("Failed to create string")
+                ),
+                ("key".into(), aggregate_public_key.clone()),
+                ("new-total".into(), Value::UInt(3)),
+                ("reward-cycle".into(), Value::UInt(cycle_id + 1)),
+                ("round".into(), Value::UInt(0)),
+                (
+                    "signer".into(),
+                    Value::Principal(stacker3_principal.clone())
+                ),
+            ])
+            .expect("Failed to create tuple")
+            .into()
+        );
+    } else {
+        panic!("Expected SmartContractEvent, got {:?}", stacker3_vote_event);
+    }
+    let approve_event = &stacker3_vote_tx.events[1];
+    if let StacksTransactionEvent::SmartContractEvent(contract_event) = approve_event {
+        assert_eq!(
+            contract_event.value,
+            TupleData::from_data(vec![
+                (
+                    "event".into(),
+                    Value::string_ascii_from_bytes(
+                        "approved-aggregate-public-key".as_bytes().to_vec()
+                    )
+                    .expect("Failed to create string")
+                ),
+                ("key".into(), aggregate_public_key.clone()),
+                ("reward-cycle".into(), Value::UInt(cycle_id + 1)),
+            ])
+            .expect("Failed to create tuple")
+            .into()
+        );
+    } else {
+        panic!("Expected SmartContractEvent, got {:?}", approve_event);
+    }
+
+    // stacker4's vote should get an out of voting window error
+    let stacker4_vote_tx = &receipts[5];
+    assert_eq!(
+        stacker4_vote_tx.result,
+        Value::err_uint(12) // ERR_OUT_OF_VOTING_WINDOW
+    );
+}
+
 /// In this test case, Alice votes in the first block of the first tenure of the prepare phase.
 /// Alice can vote successfully.
 /// A second vote on the same key and round fails with "duplicate vote" error

From 70eb622fec20ea1db2f4f4ab100627f880e2b39b Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Tue, 20 Feb 2024 13:27:11 -0500
Subject: [PATCH 0832/1166] test: check for duplicate aggregate public key
 error

---
 .../stacks/boot/signers_voting_tests.rs       | 178 ++++++++++++++++--
 1 file changed, 163 insertions(+), 15 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
index 9834531ef8..f2a6767b9e 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
@@ -177,10 +177,10 @@ fn vote_for_aggregate_public_key_success() {
     let alice_index = get_signer_index(&mut peer, latest_block_id, alice_address, cycle_id);
     let bob_index = get_signer_index(&mut peer, latest_block_id, bob_address, cycle_id);
 
-    let aggregate_public_key_point: Point = Point::new();
-    let aggregate_public_key =
-        Value::buff_from(aggregate_public_key_point.compress().data.to_vec())
-            .expect("Failed to serialize aggregate public key");
+    let mut signers = TestSigners::default();
+    let aggregate_key = signers.generate_aggregate_key(cycle_id as u64 + 1);
+    let aggregate_public_key = Value::buff_from(aggregate_key.compress().data.to_vec())
+        .expect("Failed to serialize aggregate public key");
 
     let aggregate_public_key_ill_formed = Value::buff_from_byte(0x00);
 
@@ -332,10 +332,10 @@ fn vote_for_aggregate_public_key_with_errors() {
     let alice_index = get_signer_index(&mut peer, latest_block_id, alice_address, cycle_id);
     let bob_index = get_signer_index(&mut peer, latest_block_id, bob_address, cycle_id);
 
-    let aggregate_public_key_point: Point = Point::new();
-    let aggregate_public_key =
-        Value::buff_from(aggregate_public_key_point.compress().data.to_vec())
-            .expect("Failed to serialize aggregate public key");
+    let mut signers = TestSigners::default();
+    let aggregate_key = signers.generate_aggregate_key(cycle_id as u64 + 1);
+    let aggregate_public_key = Value::buff_from(aggregate_key.compress().data.to_vec())
+        .expect("Failed to serialize aggregate public key");
 
     let aggregate_public_key_ill_formed = Value::buff_from_byte(0x00);
 
@@ -612,10 +612,10 @@ fn vote_for_aggregate_public_key_out_of_window() {
     let stacker3_index = get_signer_index(&mut peer, latest_block_id, stacker3_address, cycle_id);
     let stacker4_index = get_signer_index(&mut peer, latest_block_id, stacker4_address, cycle_id);
 
-    let aggregate_public_key_point: Point = Point::new();
-    let aggregate_public_key =
-        Value::buff_from(aggregate_public_key_point.compress().data.to_vec())
-            .expect("Failed to serialize aggregate public key");
+    let mut signers = TestSigners::default();
+    let aggregate_key = signers.generate_aggregate_key(cycle_id as u64 + 1);
+    let aggregate_public_key = Value::buff_from(aggregate_key.compress().data.to_vec())
+        .expect("Failed to serialize aggregate public key");
 
     let txs = vec![
         // stacker1 casts vote correctly
@@ -814,7 +814,8 @@ fn vote_for_aggregate_public_key_in_first_block() {
 
     let signer_index = get_signer_index(&mut peer, latest_block_id, signer_address, cycle_id);
 
-    let aggregate_public_key: Point = Point::new();
+    let mut signers = TestSigners::default();
+    let aggregate_public_key = signers.generate_aggregate_key(cycle_id as u64 + 1);
 
     let txs = vec![
         // cast a vote for the aggregate public key
@@ -898,8 +899,9 @@ fn vote_for_aggregate_public_key_in_last_block() {
     );
 
     let cycle_id: u128 = current_reward_cycle;
-    let aggregate_public_key_1 = Point::from(Scalar::from(1));
-    let aggregate_public_key_2 = Point::from(Scalar::from(2));
+    let mut signers = TestSigners::default();
+    let aggregate_public_key_1 = signers.generate_aggregate_key(cycle_id as u64 + 1);
+    let aggregate_public_key_2 = signers.generate_aggregate_key(cycle_id as u64 + 2);
 
     // create vote txs for alice
     let signer_1_nonce = 1; // Start at 1 because the signer has already voted once
@@ -1001,6 +1003,152 @@ fn vote_for_aggregate_public_key_in_last_block() {
     assert_eq!(tx1_bob.result, Value::okay_true());
 }
 
+/// In this test case, Alice & Bob both successfully vote in cycle N, then
+/// Alice tries to vote for the same signature in cycle N+1, but fails with
+/// "duplicate aggregate public key" error.
+#[test]
+fn vote_for_duplicate_aggregate_public_key() {
+    // Test setup
+    let alice = TestStacker::from_seed(&[3, 4]);
+    let bob = TestStacker::from_seed(&[5, 6]);
+    let observer = TestEventObserver::new();
+
+    // Alice - Signer 1
+    let alice_key = &alice.signer_private_key;
+    let alice_address = key_to_stacks_addr(alice_key);
+    let alice_principal = PrincipalData::from(alice_address);
+
+    // Bob - Signer 2
+    let bob_key = &bob.signer_private_key;
+    let bob_address = key_to_stacks_addr(bob_key);
+    let bob_principal = PrincipalData::from(bob_address);
+
+    let (mut peer, mut test_signers, latest_block_id, current_reward_cycle) = prepare_signers_test(
+        function_name!(),
+        vec![
+            (alice_principal.clone(), 1000),
+            (bob_principal.clone(), 1000),
+        ],
+        &[alice.clone(), bob.clone()],
+        Some(&observer),
+    );
+
+    // Alice and Bob will each have voted once while booting to Nakamoto
+    let alice_nonce = 1;
+    let bob_nonce = 1;
+
+    let cycle_id = current_reward_cycle;
+
+    // create vote txs
+    let alice_index = get_signer_index(&mut peer, latest_block_id, alice_address, cycle_id);
+    let bob_index = get_signer_index(&mut peer, latest_block_id, bob_address, cycle_id);
+
+    let mut signers = TestSigners::default();
+    let aggregate_public_key_point = signers.generate_aggregate_key(cycle_id as u64 + 1);
+    let aggregate_public_key =
+        Value::buff_from(aggregate_public_key_point.compress().data.to_vec())
+            .expect("Failed to serialize aggregate public key");
+
+    let txs = vec![
+        // Alice casts vote correctly
+        make_signers_vote_for_aggregate_public_key_value(
+            alice_key,
+            alice_nonce,
+            alice_index,
+            aggregate_public_key.clone(),
+            0,
+            cycle_id + 1,
+        ),
+        // Bob casts a vote correctly
+        make_signers_vote_for_aggregate_public_key_value(
+            bob_key,
+            bob_nonce,
+            bob_index,
+            aggregate_public_key.clone(),
+            0,
+            cycle_id + 1,
+        ),
+    ];
+
+    // vote in the first burn block of prepare phase
+    let blocks_and_sizes = nakamoto_tenure(&mut peer, &mut test_signers, vec![txs]);
+
+    // check the last two txs in the last block
+    let block = observer.get_blocks().last().unwrap().clone();
+    let receipts = block.receipts.as_slice();
+    assert_eq!(receipts.len(), 4);
+    // ignore tenure change tx
+    // ignore tenure coinbase tx
+
+    // Both votes should succeed
+    let alice_vote_tx = &receipts[2];
+    assert_eq!(alice_vote_tx.result, Value::okay_true());
+    let bob_vote_tx = &receipts[3];
+    assert_eq!(bob_vote_tx.result, Value::okay_true());
+
+    // Proceed to the next prepare phase
+    let _ = nakamoto_tenure(&mut peer, &mut test_signers, Vec::new());
+    let _ = nakamoto_tenure(&mut peer, &mut test_signers, Vec::new());
+    let _ = nakamoto_tenure(&mut peer, &mut test_signers, Vec::new());
+    let _ = nakamoto_tenure(&mut peer, &mut test_signers, Vec::new());
+
+    let aggregate_public_key_point = signers.generate_aggregate_key(cycle_id as u64 + 2);
+    let aggregate_public_key_2 =
+        Value::buff_from(aggregate_public_key_point.compress().data.to_vec())
+            .expect("Failed to serialize aggregate public key");
+
+    let txs = vec![
+        // Alice casts vote for the same key as the last cycle
+        make_signers_vote_for_aggregate_public_key_value(
+            alice_key,
+            alice_nonce + 1,
+            alice_index,
+            aggregate_public_key.clone(),
+            0,
+            cycle_id + 2,
+        ),
+        // Alice casts vote for a new key
+        make_signers_vote_for_aggregate_public_key_value(
+            alice_key,
+            alice_nonce + 2,
+            alice_index,
+            aggregate_public_key_2.clone(),
+            0,
+            cycle_id + 2,
+        ),
+        // Bob casts vote for the same key
+        make_signers_vote_for_aggregate_public_key_value(
+            bob_key,
+            bob_nonce + 1,
+            bob_index,
+            aggregate_public_key_2.clone(),
+            0,
+            cycle_id + 2,
+        ),
+    ];
+
+    // Submit the vote in a new block
+    nakamoto_tenure(&mut peer, &mut test_signers, vec![txs]);
+
+    // Check the last 3 tx in the last block
+    let block = observer.get_blocks().last().unwrap().clone();
+    let receipts = block.receipts.as_slice();
+    assert_eq!(receipts.len(), 5);
+
+    // Alice's vote should fail with duplicate aggregate public key error
+    let alice_vote_tx = &receipts[2];
+    assert_eq!(
+        alice_vote_tx.result,
+        Value::err_uint(14) // ERR_DUPLICATE_AGGREGATE_PUBLIC_KEY
+    );
+
+    // Both remaining votes should succeed
+    let alice_vote_tx = &receipts[3];
+    assert_eq!(alice_vote_tx.result, Value::okay_true());
+    let bob_vote_tx = &receipts[4];
+    assert_eq!(bob_vote_tx.result, Value::okay_true());
+}
+
 fn nakamoto_tenure(
     peer: &mut TestPeer,
     test_signers: &mut TestSigners,

From 3c0f8585a1f37a452fa73fd507de1f3bd8cc4e44 Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Tue, 20 Feb 2024 14:32:49 -0500
Subject: [PATCH 0833/1166] test: test voting over multiple rounds

---
 .../stacks/boot/signers_voting_tests.rs       | 438 ++++++++++++++++++
 1 file changed, 438 insertions(+)

diff --git a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
index f2a6767b9e..93e5fec683 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
@@ -1149,6 +1149,444 @@ fn vote_for_duplicate_aggregate_public_key() {
     assert_eq!(bob_vote_tx.result, Value::okay_true());
 }
 
+/// In this test case, Alice & Bob both successfully vote in cycle N, but for
+/// different keys. Then in round 1, they both vote for the same key and
+/// key selection is successful. In the first cycle, these two rounds happen
+/// in the same tenure. In the second cycle, the first round happens in the
+/// first tenure of the prepare phase, and the second round happens in the
+/// second tenure of the prepare phase.
+#[test]
+fn vote_for_aggregate_public_key_two_rounds() {
+    // Test setup
+    let alice = TestStacker::from_seed(&[3, 4]);
+    let bob = TestStacker::from_seed(&[5, 6]);
+    let observer = TestEventObserver::new();
+
+    // Alice - Signer 1
+    let alice_key = &alice.signer_private_key;
+    let alice_address = key_to_stacks_addr(alice_key);
+    let alice_principal = PrincipalData::from(alice_address);
+
+    // Bob - Signer 2
+    let bob_key = &bob.signer_private_key;
+    let bob_address = key_to_stacks_addr(bob_key);
+    let bob_principal = PrincipalData::from(bob_address);
+
+    let (mut peer, mut test_signers, latest_block_id, current_reward_cycle) = prepare_signers_test(
+        function_name!(),
+        vec![
+            (alice_principal.clone(), 1000),
+            (bob_principal.clone(), 1000),
+        ],
+        &[alice.clone(), bob.clone()],
+        Some(&observer),
+    );
+
+    // Alice and Bob will each have voted once while booting to Nakamoto
+    let alice_nonce = 1;
+    let bob_nonce = 1;
+
+    let cycle_id = current_reward_cycle;
+
+    // create vote txs
+    let alice_index = get_signer_index(&mut peer, latest_block_id, alice_address, cycle_id);
+    let bob_index = get_signer_index(&mut peer, latest_block_id, bob_address, cycle_id);
+
+    let mut signers = TestSigners::default();
+    let aggregate_public_key_0_point = signers.generate_aggregate_key(0);
+    let aggregate_public_key_0 =
+        Value::buff_from(aggregate_public_key_0_point.compress().data.to_vec())
+            .expect("Failed to serialize aggregate public key");
+    let aggregate_public_key_1_point = signers.generate_aggregate_key(cycle_id as u64 + 1);
+    let aggregate_public_key_1 =
+        Value::buff_from(aggregate_public_key_1_point.compress().data.to_vec())
+            .expect("Failed to serialize aggregate public key");
+
+    let txs = vec![
+        // Alice casts vote for key 0 in round 0
+        make_signers_vote_for_aggregate_public_key_value(
+            alice_key,
+            alice_nonce,
+            alice_index,
+            aggregate_public_key_0.clone(),
+            0,
+            cycle_id + 1,
+        ),
+        // Bob casts a vote for key 1 in round 0
+        make_signers_vote_for_aggregate_public_key_value(
+            bob_key,
+            bob_nonce,
+            bob_index,
+            aggregate_public_key_1.clone(),
+            0,
+            cycle_id + 1,
+        ),
+        // Alice casts vote for key 1 in round 1
+        make_signers_vote_for_aggregate_public_key_value(
+            alice_key,
+            alice_nonce + 1,
+            alice_index,
+            aggregate_public_key_1.clone(),
+            1,
+            cycle_id + 1,
+        ),
+        // Bob casts a vote for key 1 in round 1
+        make_signers_vote_for_aggregate_public_key_value(
+            bob_key,
+            bob_nonce + 1,
+            bob_index,
+            aggregate_public_key_1.clone(),
+            1,
+            cycle_id + 1,
+        ),
+    ];
+
+    // vote in the first burn block of prepare phase
+    let blocks_and_sizes = nakamoto_tenure(&mut peer, &mut test_signers, vec![txs]);
+
+    // check the last four txs in the last block
+    let block = observer.get_blocks().last().unwrap().clone();
+    let receipts = block.receipts.as_slice();
+    assert_eq!(receipts.len(), 6);
+    // ignore tenure change tx
+    // ignore tenure coinbase tx
+
+    // All votes should succeed
+    let alice_vote_tx = &receipts[2];
+    assert_eq!(alice_vote_tx.result, Value::okay_true());
+    assert_eq!(alice_vote_tx.events.len(), 1);
+    let alice_vote_event = &alice_vote_tx.events[0];
+    if let StacksTransactionEvent::SmartContractEvent(contract_event) = alice_vote_event {
+        assert_eq!(
+            contract_event.value,
+            TupleData::from_data(vec![
+                (
+                    "event".into(),
+                    Value::string_ascii_from_bytes("voted".as_bytes().to_vec())
+                        .expect("Failed to create string")
+                ),
+                ("key".into(), aggregate_public_key_0.clone()),
+                ("new-total".into(), Value::UInt(2)),
+                ("reward-cycle".into(), Value::UInt(cycle_id + 1)),
+                ("round".into(), Value::UInt(0)),
+                ("signer".into(), Value::Principal(alice_principal.clone())),
+            ])
+            .expect("Failed to create tuple")
+            .into()
+        );
+    } else {
+        panic!("Expected SmartContractEvent, got {:?}", alice_vote_event);
+    }
+
+    let bob_vote_tx = &receipts[3];
+    assert_eq!(bob_vote_tx.result, Value::okay_true());
+    assert_eq!(bob_vote_tx.events.len(), 1);
+    let bob_vote_event = &bob_vote_tx.events[0];
+    if let StacksTransactionEvent::SmartContractEvent(contract_event) = bob_vote_event {
+        assert_eq!(
+            contract_event.value,
+            TupleData::from_data(vec![
+                (
+                    "event".into(),
+                    Value::string_ascii_from_bytes("voted".as_bytes().to_vec())
+                        .expect("Failed to create string")
+                ),
+                ("key".into(), aggregate_public_key_1.clone()),
+                ("new-total".into(), Value::UInt(2)),
+                ("reward-cycle".into(), Value::UInt(cycle_id + 1)),
+                ("round".into(), Value::UInt(0)),
+                ("signer".into(), Value::Principal(bob_principal.clone())),
+            ])
+            .expect("Failed to create tuple")
+            .into()
+        );
+    } else {
+        panic!("Expected SmartContractEvent, got {:?}", bob_vote_event);
+    }
+
+    let alice_vote_tx = &receipts[4];
+    assert_eq!(alice_vote_tx.result, Value::okay_true());
+    assert_eq!(alice_vote_tx.events.len(), 1);
+    let alice_vote_event = &alice_vote_tx.events[0];
+    if let StacksTransactionEvent::SmartContractEvent(contract_event) = alice_vote_event {
+        assert_eq!(
+            contract_event.value,
+            TupleData::from_data(vec![
+                (
+                    "event".into(),
+                    Value::string_ascii_from_bytes("voted".as_bytes().to_vec())
+                        .expect("Failed to create string")
+                ),
+                ("key".into(), aggregate_public_key_1.clone()),
+                ("new-total".into(), Value::UInt(2)),
+                ("reward-cycle".into(), Value::UInt(cycle_id + 1)),
+                ("round".into(), Value::UInt(1)),
+                ("signer".into(), Value::Principal(alice_principal.clone())),
+            ])
+            .expect("Failed to create tuple")
+            .into()
+        );
+    } else {
+        panic!("Expected SmartContractEvent, got {:?}", alice_vote_event);
+    }
+
+    let bob_vote_tx = &receipts[5];
+    assert_eq!(bob_vote_tx.result, Value::okay_true());
+    assert_eq!(bob_vote_tx.events.len(), 2);
+    let bob_vote_event = &bob_vote_tx.events[0];
+    if let StacksTransactionEvent::SmartContractEvent(contract_event) = bob_vote_event {
+        assert_eq!(
+            contract_event.value,
+            TupleData::from_data(vec![
+                (
+                    "event".into(),
+                    Value::string_ascii_from_bytes("voted".as_bytes().to_vec())
+                        .expect("Failed to create string")
+                ),
+                ("key".into(), aggregate_public_key_1.clone()),
+                ("new-total".into(), Value::UInt(4)),
+                ("reward-cycle".into(), Value::UInt(cycle_id + 1)),
+                ("round".into(), Value::UInt(1)),
+                ("signer".into(), Value::Principal(bob_principal.clone())),
+            ])
+            .expect("Failed to create tuple")
+            .into()
+        );
+    } else {
+        panic!("Expected SmartContractEvent, got {:?}", bob_vote_event);
+    }
+
+    // The aggregate key is approved in round 1
+    let approve_event = &bob_vote_tx.events[1];
+    if let StacksTransactionEvent::SmartContractEvent(contract_event) = approve_event {
+        assert_eq!(
+            contract_event.value,
+            TupleData::from_data(vec![
+                (
+                    "event".into(),
+                    Value::string_ascii_from_bytes(
+                        "approved-aggregate-public-key".as_bytes().to_vec()
+                    )
+                    .expect("Failed to create string")
+                ),
+                ("key".into(), aggregate_public_key_1.clone()),
+                ("reward-cycle".into(), Value::UInt(cycle_id + 1)),
+            ])
+            .expect("Failed to create tuple")
+            .into()
+        );
+    } else {
+        panic!("Expected SmartContractEvent, got {:?}", approve_event);
+    }
+
+    // Proceed to the next prepare phase
+    let _ = nakamoto_tenure(&mut peer, &mut test_signers, Vec::new());
+    let _ = nakamoto_tenure(&mut peer, &mut test_signers, Vec::new());
+    let _ = nakamoto_tenure(&mut peer, &mut test_signers, Vec::new());
+    let _ = nakamoto_tenure(&mut peer, &mut test_signers, Vec::new());
+
+    // In this cycle, the two rounds are in separate tenures.
+
+    let aggregate_public_key_0_point = signers.generate_aggregate_key(1);
+    let aggregate_public_key_0 =
+        Value::buff_from(aggregate_public_key_0_point.compress().data.to_vec())
+            .expect("Failed to serialize aggregate public key");
+    let aggregate_public_key_1_point = signers.generate_aggregate_key(cycle_id as u64 + 2);
+    let aggregate_public_key_1 =
+        Value::buff_from(aggregate_public_key_1_point.compress().data.to_vec())
+            .expect("Failed to serialize aggregate public key");
+
+    let txs = vec![
+        // Alice casts vote for key 0 in round 0
+        make_signers_vote_for_aggregate_public_key_value(
+            alice_key,
+            alice_nonce + 2,
+            alice_index,
+            aggregate_public_key_0.clone(),
+            0,
+            cycle_id + 2,
+        ),
+        // Bob casts a vote for key 1 in round 0
+        make_signers_vote_for_aggregate_public_key_value(
+            bob_key,
+            bob_nonce + 2,
+            bob_index,
+            aggregate_public_key_1.clone(),
+            0,
+            cycle_id + 2,
+        ),
+    ];
+
+    // vote in the first burn block of prepare phase
+    let blocks_and_sizes = nakamoto_tenure(&mut peer, &mut test_signers, vec![txs]);
+
+    // check the last two txs in the last block
+    let block = observer.get_blocks().last().unwrap().clone();
+    let receipts = block.receipts.as_slice();
+    assert_eq!(receipts.len(), 4);
+    // ignore tenure change tx
+    // ignore tenure coinbase tx
+
+    // Both votes should succeed, but the aggregate key is not approved yet
+    let alice_vote_tx = &receipts[2];
+    assert_eq!(alice_vote_tx.result, Value::okay_true());
+    assert_eq!(alice_vote_tx.events.len(), 1);
+    let alice_vote_event = &alice_vote_tx.events[0];
+    if let StacksTransactionEvent::SmartContractEvent(contract_event) = alice_vote_event {
+        assert_eq!(
+            contract_event.value,
+            TupleData::from_data(vec![
+                (
+                    "event".into(),
+                    Value::string_ascii_from_bytes("voted".as_bytes().to_vec())
+                        .expect("Failed to create string")
+                ),
+                ("key".into(), aggregate_public_key_0.clone()),
+                ("new-total".into(), Value::UInt(2)),
+                ("reward-cycle".into(), Value::UInt(cycle_id + 2)),
+                ("round".into(), Value::UInt(0)),
+                ("signer".into(), Value::Principal(alice_principal.clone())),
+            ])
+            .expect("Failed to create tuple")
+            .into()
+        );
+    } else {
+        panic!("Expected SmartContractEvent, got {:?}", alice_vote_event);
+    }
+
+    let bob_vote_tx = &receipts[3];
+    assert_eq!(bob_vote_tx.result, Value::okay_true());
+    assert_eq!(bob_vote_tx.events.len(), 1);
+    let bob_vote_event = &bob_vote_tx.events[0];
+    if let StacksTransactionEvent::SmartContractEvent(contract_event) = bob_vote_event {
+        assert_eq!(
+            contract_event.value,
+            TupleData::from_data(vec![
+                (
+                    "event".into(),
+                    Value::string_ascii_from_bytes("voted".as_bytes().to_vec())
+                        .expect("Failed to create string")
+                ),
+                ("key".into(), aggregate_public_key_1.clone()),
+                ("new-total".into(), Value::UInt(2)),
+                ("reward-cycle".into(), Value::UInt(cycle_id + 2)),
+                ("round".into(), Value::UInt(0)),
+                ("signer".into(), Value::Principal(bob_principal.clone())),
+            ])
+            .expect("Failed to create tuple")
+            .into()
+        );
+    } else {
+        panic!("Expected SmartContractEvent, got {:?}", bob_vote_event);
+    }
+
+    let txs = vec![
+        // Alice casts vote for key 1 in round 1
+        make_signers_vote_for_aggregate_public_key_value(
+            alice_key,
+            alice_nonce + 3,
+            alice_index,
+            aggregate_public_key_1.clone(),
+            1,
+            cycle_id + 2,
+        ),
+        // Bob casts a vote for key 1 in round 1
+        make_signers_vote_for_aggregate_public_key_value(
+            bob_key,
+            bob_nonce + 3,
+            bob_index,
+            aggregate_public_key_1.clone(),
+            1,
+            cycle_id + 2,
+        ),
+    ];
+
+    // vote again in the next burn block
+    let blocks_and_sizes = nakamoto_tenure(&mut peer, &mut test_signers, vec![txs]);
+
+    // check the last two txs in the last block
+    let block = observer.get_blocks().last().unwrap().clone();
+    let receipts = block.receipts.as_slice();
+    assert_eq!(receipts.len(), 4);
+    // ignore tenure change tx
+    // ignore tenure coinbase tx
+
+    let alice_vote_tx = &receipts[2];
+    assert_eq!(alice_vote_tx.result, Value::okay_true());
+    assert_eq!(alice_vote_tx.events.len(), 1);
+    let alice_vote_event = &alice_vote_tx.events[0];
+    if let StacksTransactionEvent::SmartContractEvent(contract_event) = alice_vote_event {
+        assert_eq!(
+            contract_event.value,
+            TupleData::from_data(vec![
+                (
+                    "event".into(),
+                    Value::string_ascii_from_bytes("voted".as_bytes().to_vec())
+                        .expect("Failed to create string")
+                ),
+                ("key".into(), aggregate_public_key_1.clone()),
+                ("new-total".into(), Value::UInt(2)),
+                ("reward-cycle".into(), Value::UInt(cycle_id + 2)),
+                ("round".into(), Value::UInt(1)),
+                ("signer".into(), Value::Principal(alice_principal.clone())),
+            ])
+            .expect("Failed to create tuple")
+            .into()
+        );
+    } else {
+        panic!("Expected SmartContractEvent, got {:?}", alice_vote_event);
+    }
+
+    let bob_vote_tx = &receipts[3];
+    assert_eq!(bob_vote_tx.result, Value::okay_true());
+    assert_eq!(bob_vote_tx.events.len(), 2);
+    let bob_vote_event = &bob_vote_tx.events[0];
+    if let StacksTransactionEvent::SmartContractEvent(contract_event) = bob_vote_event {
+        assert_eq!(
+            contract_event.value,
+            TupleData::from_data(vec![
+                (
+                    "event".into(),
+                    Value::string_ascii_from_bytes("voted".as_bytes().to_vec())
+                        .expect("Failed to create string")
+                ),
+                ("key".into(), aggregate_public_key_1.clone()),
+                ("new-total".into(), Value::UInt(4)),
+                ("reward-cycle".into(), Value::UInt(cycle_id + 2)),
+                ("round".into(), Value::UInt(1)),
+                ("signer".into(), Value::Principal(bob_principal.clone())),
+            ])
+            .expect("Failed to create tuple")
+            .into()
+        );
+    } else {
+        panic!("Expected SmartContractEvent, got {:?}", bob_vote_event);
+    }
+
+    // The aggregate key is approved in round 1
+    let approve_event = &bob_vote_tx.events[1];
+    if let StacksTransactionEvent::SmartContractEvent(contract_event) = approve_event {
+        assert_eq!(
+            contract_event.value,
+            TupleData::from_data(vec![
+                (
+                    "event".into(),
+                    Value::string_ascii_from_bytes(
+                        "approved-aggregate-public-key".as_bytes().to_vec()
+                    )
+                    .expect("Failed to create string")
+                ),
+                ("key".into(), aggregate_public_key_1.clone()),
+                ("reward-cycle".into(), Value::UInt(cycle_id + 2)),
+            ])
+            .expect("Failed to create tuple")
+            .into()
+        );
+    } else {
+        panic!("Expected SmartContractEvent, got {:?}", approve_event);
+    }
+}
+
 fn nakamoto_tenure(
     peer: &mut TestPeer,
     test_signers: &mut TestSigners,

From 911e5cd504c0c30f477c3d3d817c4e554ed0883c Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Tue, 20 Feb 2024 14:53:29 -0500
Subject: [PATCH 0834/1166] test: try to vote early, before the prepare phase

---
 .../stacks/boot/signers_voting_tests.rs       | 227 ++++++++++++++++++
 1 file changed, 227 insertions(+)

diff --git a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
index 93e5fec683..86c670018c 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
@@ -1587,6 +1587,233 @@ fn vote_for_aggregate_public_key_two_rounds() {
     }
 }
 
+/// In this test case, Alice & Bob both successfully vote for the same key in
+/// cycle N, then in cycle N + 1, Alice tries to vote before the prepare phase,
+/// but fails with a "cycle not set" error.
+#[test]
+fn vote_for_aggregate_public_key_early() {
+    // Test setup
+    let alice = TestStacker::from_seed(&[3, 4]);
+    let bob = TestStacker::from_seed(&[5, 6]);
+    let observer = TestEventObserver::new();
+
+    // Alice - Signer 1
+    let alice_key = &alice.signer_private_key;
+    let alice_address = key_to_stacks_addr(alice_key);
+    let alice_principal = PrincipalData::from(alice_address);
+
+    // Bob - Signer 2
+    let bob_key = &bob.signer_private_key;
+    let bob_address = key_to_stacks_addr(bob_key);
+    let bob_principal = PrincipalData::from(bob_address);
+
+    let (mut peer, mut test_signers, latest_block_id, current_reward_cycle) = prepare_signers_test(
+        function_name!(),
+        vec![
+            (alice_principal.clone(), 1000),
+            (bob_principal.clone(), 1000),
+        ],
+        &[alice.clone(), bob.clone()],
+        Some(&observer),
+    );
+
+    // Alice and Bob will each have voted once while booting to Nakamoto
+    let alice_nonce = 1;
+    let bob_nonce = 1;
+
+    let cycle_id = current_reward_cycle;
+
+    // create vote txs
+    let alice_index = get_signer_index(&mut peer, latest_block_id, alice_address, cycle_id);
+    let bob_index = get_signer_index(&mut peer, latest_block_id, bob_address, cycle_id);
+
+    let mut signers = TestSigners::default();
+    let aggregate_key = signers.generate_aggregate_key(cycle_id as u64 + 1);
+    let aggregate_public_key = Value::buff_from(aggregate_key.compress().data.to_vec())
+        .expect("Failed to serialize aggregate public key");
+
+    let aggregate_public_key_ill_formed = Value::buff_from_byte(0x00);
+
+    let txs = vec![
+        // Alice casts vote correctly
+        make_signers_vote_for_aggregate_public_key_value(
+            alice_key,
+            alice_nonce,
+            alice_index,
+            aggregate_public_key.clone(),
+            0,
+            cycle_id + 1,
+        ),
+        // Bob casts a vote correctly
+        make_signers_vote_for_aggregate_public_key_value(
+            bob_key,
+            bob_nonce,
+            bob_index,
+            aggregate_public_key.clone(),
+            0,
+            cycle_id + 1,
+        ),
+    ];
+    let blocks_and_sizes = nakamoto_tenure(&mut peer, &mut test_signers, vec![txs]);
+    let block = observer.get_blocks().last().unwrap().clone();
+    let receipts = block.receipts.as_slice();
+    assert_eq!(receipts.len(), 4);
+
+    // Both votes should succeed
+    let alice_vote_tx = &receipts[2];
+    assert_eq!(alice_vote_tx.result, Value::okay_true());
+    assert_eq!(alice_vote_tx.events.len(), 1);
+    let bob_vote_tx = &receipts[3];
+    assert_eq!(bob_vote_tx.result, Value::okay_true());
+    assert_eq!(bob_vote_tx.events.len(), 2);
+
+    // Proceed to the reward phase
+    let _ = nakamoto_tenure(&mut peer, &mut test_signers, Vec::new());
+    let _ = nakamoto_tenure(&mut peer, &mut test_signers, Vec::new());
+
+    // In this tenure, signers have not been set yet, so the vote should fail
+    let aggregate_public_key_point = signers.generate_aggregate_key(cycle_id as u64 + 2);
+    let aggregate_public_key =
+        Value::buff_from(aggregate_public_key_point.compress().data.to_vec())
+            .expect("Failed to serialize aggregate public key");
+
+    let txs = vec![
+        // Alice casts vote for key 0 in round 0
+        make_signers_vote_for_aggregate_public_key_value(
+            alice_key,
+            alice_nonce + 1,
+            alice_index,
+            aggregate_public_key.clone(),
+            0,
+            cycle_id + 2,
+        ),
+    ];
+
+    // vote before the prepare phase
+    let blocks_and_sizes = nakamoto_tenure(&mut peer, &mut test_signers, vec![txs]);
+
+    // check the last two txs in the last block
+    let block = observer.get_blocks().last().unwrap().clone();
+    let receipts = block.receipts.as_slice();
+    assert_eq!(receipts.len(), 3);
+    // ignore tenure change tx
+    // ignore tenure coinbase tx
+
+    // Alice's vote should fail with a "cycle not set" error
+    let alice_vote_tx = &receipts[2];
+    assert_eq!(
+        alice_vote_tx.result,
+        Value::err_uint(2) // ERR_CYCLE_NOT_SET
+    );
+
+    // Proceed to the prepare phase
+    let _ = nakamoto_tenure(&mut peer, &mut test_signers, Vec::new());
+    let _ = nakamoto_tenure(&mut peer, &mut test_signers, Vec::new());
+
+    let txs = vec![
+        // Alice casts vote correctly
+        make_signers_vote_for_aggregate_public_key_value(
+            alice_key,
+            alice_nonce + 2,
+            alice_index,
+            aggregate_public_key.clone(),
+            0,
+            cycle_id + 2,
+        ),
+        // Bob casts a vote correctly
+        make_signers_vote_for_aggregate_public_key_value(
+            bob_key,
+            bob_nonce + 1,
+            bob_index,
+            aggregate_public_key.clone(),
+            0,
+            cycle_id + 2,
+        ),
+    ];
+    let blocks_and_sizes = nakamoto_tenure(&mut peer, &mut test_signers, vec![txs]);
+    let block = observer.get_blocks().last().unwrap().clone();
+    let receipts = block.receipts.as_slice();
+    assert_eq!(receipts.len(), 4);
+    // ignore tenure change tx
+    // ignore tenure coinbase tx
+
+    // This time, the votes should succeed and the key should be approved
+    let alice_vote_tx = &receipts[2];
+    assert_eq!(alice_vote_tx.result, Value::okay_true());
+    assert_eq!(alice_vote_tx.events.len(), 1);
+    let alice_vote_event = &alice_vote_tx.events[0];
+    if let StacksTransactionEvent::SmartContractEvent(contract_event) = alice_vote_event {
+        assert_eq!(
+            contract_event.value,
+            TupleData::from_data(vec![
+                (
+                    "event".into(),
+                    Value::string_ascii_from_bytes("voted".as_bytes().to_vec())
+                        .expect("Failed to create string")
+                ),
+                ("key".into(), aggregate_public_key.clone()),
+                ("new-total".into(), Value::UInt(2)),
+                ("reward-cycle".into(), Value::UInt(cycle_id + 2)),
+                ("round".into(), Value::UInt(0)),
+                ("signer".into(), Value::Principal(alice_principal.clone())),
+            ])
+            .expect("Failed to create tuple")
+            .into()
+        );
+    } else {
+        panic!("Expected SmartContractEvent, got {:?}", alice_vote_event);
+    }
+
+    let bob_vote_tx = &receipts[3];
+    assert_eq!(bob_vote_tx.result, Value::okay_true());
+    assert_eq!(bob_vote_tx.events.len(), 2);
+    let bob_vote_event = &bob_vote_tx.events[0];
+    if let StacksTransactionEvent::SmartContractEvent(contract_event) = bob_vote_event {
+        assert_eq!(
+            contract_event.value,
+            TupleData::from_data(vec![
+                (
+                    "event".into(),
+                    Value::string_ascii_from_bytes("voted".as_bytes().to_vec())
+                        .expect("Failed to create string")
+                ),
+                ("key".into(), aggregate_public_key.clone()),
+                ("new-total".into(), Value::UInt(4)),
+                ("reward-cycle".into(), Value::UInt(cycle_id + 2)),
+                ("round".into(), Value::UInt(0)),
+                ("signer".into(), Value::Principal(bob_principal.clone())),
+            ])
+            .expect("Failed to create tuple")
+            .into()
+        );
+    } else {
+        panic!("Expected SmartContractEvent, got {:?}", bob_vote_event);
+    }
+
+    // The aggregate key is approved in round 1
+    let approve_event = &bob_vote_tx.events[1];
+    if let StacksTransactionEvent::SmartContractEvent(contract_event) = approve_event {
+        assert_eq!(
+            contract_event.value,
+            TupleData::from_data(vec![
+                (
+                    "event".into(),
+                    Value::string_ascii_from_bytes(
+                        "approved-aggregate-public-key".as_bytes().to_vec()
+                    )
+                    .expect("Failed to create string")
+                ),
+                ("key".into(), aggregate_public_key.clone()),
+                ("reward-cycle".into(), Value::UInt(cycle_id + 2)),
+            ])
+            .expect("Failed to create tuple")
+            .into()
+        );
+    } else {
+        panic!("Expected SmartContractEvent, got {:?}", approve_event);
+    }
+}
+
 fn nakamoto_tenure(
     peer: &mut TestPeer,
     test_signers: &mut TestSigners,

From 712c77e05d02e66c18d1bfbda30e03cefe14ec82 Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Wed, 21 Feb 2024 08:35:58 -0500
Subject: [PATCH 0835/1166] test: verify that an old round can succeed after a
 new round has started

Also add checks to ensure that no events are generated when a vote
fails.
---
 .../stacks/boot/signers_voting_tests.rs       | 228 ++++++++++++++++++
 1 file changed, 228 insertions(+)

diff --git a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
index 86c670018c..4b14fb2161 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
@@ -433,6 +433,7 @@ fn vote_for_aggregate_public_key_with_errors() {
         alice_first_vote_tx_result,
         Value::err_uint(10) // ERR_SIGNER_INDEX_MISMATCH
     );
+    assert_eq!(alice_first_vote_tx.events.len(), 0);
 
     // Alice's second vote should fail (invalid signer)
     let alice_second_vote_tx = &receipts[3];
@@ -441,6 +442,7 @@ fn vote_for_aggregate_public_key_with_errors() {
         alice_second_vote_tx_result,
         Value::err_uint(11) // ERR_INVALID_SIGNER_INDEX
     );
+    assert_eq!(alice_second_vote_tx.events.len(), 0);
 
     // Alice's third vote should fail (ill formed aggregate public key)
     let alice_third_vote_tx = &receipts[4];
@@ -449,6 +451,7 @@ fn vote_for_aggregate_public_key_with_errors() {
         alice_third_vote_tx_result,
         Value::err_uint(13) // ERR_ILL_FORMED_AGGREGATE_PUBLIC_KEY
     );
+    assert_eq!(alice_third_vote_tx.events.len(), 0);
 
     // Alice's fourth vote should fail (cycle not set)
     let alice_fourth_vote_tx = &receipts[5];
@@ -457,6 +460,7 @@ fn vote_for_aggregate_public_key_with_errors() {
         alice_fourth_vote_tx_result,
         Value::err_uint(2) // ERR_CYCLE_NOT_SET
     );
+    assert_eq!(alice_fourth_vote_tx.events.len(), 0);
 
     // Alice's fifth  vote, correct vote should succeed
     let alice_fifth_vote_tx = &receipts[6];
@@ -492,6 +496,7 @@ fn vote_for_aggregate_public_key_with_errors() {
         alice_sixth_vote_tx_result,
         Value::err_uint(15) // ERR_DUPLICATE_VOTE
     );
+    assert_eq!(alice_sixth_vote_tx.events.len(), 0);
 
     // Bob's first vote should fail (invalid round)
     let bob_first_vote_tx = &receipts[8];
@@ -500,6 +505,7 @@ fn vote_for_aggregate_public_key_with_errors() {
         bob_first_vote_tx_result,
         Value::err_uint(17) // ERR_INVALID_ROUND
     );
+    assert_eq!(bob_first_vote_tx.events.len(), 0);
 
     // Bob's second vote should succeed and reach the threshold, setting the aggregate public key
     let bob_second_vote_tx = &receipts[9];
@@ -785,6 +791,7 @@ fn vote_for_aggregate_public_key_out_of_window() {
         stacker4_vote_tx.result,
         Value::err_uint(12) // ERR_OUT_OF_VOTING_WINDOW
     );
+    assert_eq!(stacker4_vote_tx.events.len(), 0);
 }
 
 /// In this test case, Alice votes in the first block of the first tenure of the prepare phase.
@@ -860,6 +867,7 @@ fn vote_for_aggregate_public_key_in_first_block() {
         alice_second_vote_tx.result,
         Value::err_uint(15) // ERR_DUPLICATE_VOTE
     );
+    assert_eq!(alice_second_vote_tx.events.len(), 0);
 }
 
 /// In this test case, Alice votes in the first block of the last tenure of the prepare phase.
@@ -988,6 +996,7 @@ fn vote_for_aggregate_public_key_in_last_block() {
         alice_second_vote_tx.result,
         Value::err_uint(15) // ERR_DUPLICATE_VOTE
     );
+    assert_eq!(alice_second_vote_tx.events.len(), 0);
 
     // third vote should succeed even though it is on an old round
     let alice_third_vote_tx = &receipts[4];
@@ -1141,6 +1150,7 @@ fn vote_for_duplicate_aggregate_public_key() {
         alice_vote_tx.result,
         Value::err_uint(14) // ERR_DUPLICATE_AGGREGATE_PUBLIC_KEY
     );
+    assert_eq!(alice_vote_tx.events.len(), 0);
 
     // Both remaining votes should succeed
     let alice_vote_tx = &receipts[3];
@@ -1705,6 +1715,7 @@ fn vote_for_aggregate_public_key_early() {
         alice_vote_tx.result,
         Value::err_uint(2) // ERR_CYCLE_NOT_SET
     );
+    assert_eq!(alice_vote_tx.events.len(), 0);
 
     // Proceed to the prepare phase
     let _ = nakamoto_tenure(&mut peer, &mut test_signers, Vec::new());
@@ -1814,6 +1825,223 @@ fn vote_for_aggregate_public_key_early() {
     }
 }
 
+/// In this test case, Alice votes in round 0 and Bob votes in round 1.
+/// Although they both voted for the same key, the key is not approved. In the
+/// next tenure, Bob votes in round 0, and the key is approved.
+#[test]
+fn vote_for_aggregate_public_key_mixed_rounds() {
+    // Test setup
+    let alice = TestStacker::from_seed(&[3, 4]);
+    let bob = TestStacker::from_seed(&[5, 6]);
+    let observer = TestEventObserver::new();
+
+    // Alice - Signer 1
+    let alice_key = &alice.signer_private_key;
+    let alice_address = key_to_stacks_addr(alice_key);
+    let alice_principal = PrincipalData::from(alice_address);
+
+    // Bob - Signer 2
+    let bob_key = &bob.signer_private_key;
+    let bob_address = key_to_stacks_addr(bob_key);
+    let bob_principal = PrincipalData::from(bob_address);
+
+    let (mut peer, mut test_signers, latest_block_id, current_reward_cycle) = prepare_signers_test(
+        function_name!(),
+        vec![
+            (alice_principal.clone(), 1000),
+            (bob_principal.clone(), 1000),
+        ],
+        &[alice.clone(), bob.clone()],
+        Some(&observer),
+    );
+
+    // Alice and Bob will each have voted once while booting to Nakamoto
+    let alice_nonce = 1;
+    let bob_nonce = 1;
+
+    let cycle_id = current_reward_cycle;
+
+    // create vote txs
+    let alice_index = get_signer_index(&mut peer, latest_block_id, alice_address, cycle_id);
+    let bob_index = get_signer_index(&mut peer, latest_block_id, bob_address, cycle_id);
+
+    let mut signers = TestSigners::default();
+    let aggregate_public_key_point = signers.generate_aggregate_key(0);
+    let aggregate_public_key =
+        Value::buff_from(aggregate_public_key_point.compress().data.to_vec())
+            .expect("Failed to serialize aggregate public key");
+
+    let txs = vec![
+        // Alice casts vote for key 0 in round 0
+        make_signers_vote_for_aggregate_public_key_value(
+            alice_key,
+            alice_nonce,
+            alice_index,
+            aggregate_public_key.clone(),
+            0,
+            cycle_id + 1,
+        ),
+        // Bob casts a vote for key 0 in round 1
+        make_signers_vote_for_aggregate_public_key_value(
+            bob_key,
+            bob_nonce,
+            bob_index,
+            aggregate_public_key.clone(),
+            1,
+            cycle_id + 1,
+        ),
+    ];
+
+    // vote in the first burn block of prepare phase
+    let blocks_and_sizes = nakamoto_tenure(&mut peer, &mut test_signers, vec![txs]);
+
+    // check the last four txs in the last block
+    let block = observer.get_blocks().last().unwrap().clone();
+    let receipts = block.receipts.as_slice();
+    assert_eq!(receipts.len(), 4);
+    // ignore tenure change tx
+    // ignore tenure coinbase tx
+
+    // All votes should succeed
+    let alice_vote_tx = &receipts[2];
+    assert_eq!(alice_vote_tx.result, Value::okay_true());
+    assert_eq!(alice_vote_tx.events.len(), 1);
+    let alice_vote_event = &alice_vote_tx.events[0];
+    if let StacksTransactionEvent::SmartContractEvent(contract_event) = alice_vote_event {
+        assert_eq!(
+            contract_event.value,
+            TupleData::from_data(vec![
+                (
+                    "event".into(),
+                    Value::string_ascii_from_bytes("voted".as_bytes().to_vec())
+                        .expect("Failed to create string")
+                ),
+                ("key".into(), aggregate_public_key.clone()),
+                ("new-total".into(), Value::UInt(2)),
+                ("reward-cycle".into(), Value::UInt(cycle_id + 1)),
+                ("round".into(), Value::UInt(0)),
+                ("signer".into(), Value::Principal(alice_principal.clone())),
+            ])
+            .expect("Failed to create tuple")
+            .into()
+        );
+    } else {
+        panic!("Expected SmartContractEvent, got {:?}", alice_vote_event);
+    }
+
+    let bob_vote_tx = &receipts[3];
+    assert_eq!(bob_vote_tx.result, Value::okay_true());
+    assert_eq!(bob_vote_tx.events.len(), 1);
+    let bob_vote_event = &bob_vote_tx.events[0];
+    if let StacksTransactionEvent::SmartContractEvent(contract_event) = bob_vote_event {
+        assert_eq!(
+            contract_event.value,
+            TupleData::from_data(vec![
+                (
+                    "event".into(),
+                    Value::string_ascii_from_bytes("voted".as_bytes().to_vec())
+                        .expect("Failed to create string")
+                ),
+                ("key".into(), aggregate_public_key.clone()),
+                ("new-total".into(), Value::UInt(2)),
+                ("reward-cycle".into(), Value::UInt(cycle_id + 1)),
+                ("round".into(), Value::UInt(1)),
+                ("signer".into(), Value::Principal(bob_principal.clone())),
+            ])
+            .expect("Failed to create tuple")
+            .into()
+        );
+    } else {
+        panic!("Expected SmartContractEvent, got {:?}", bob_vote_event);
+    }
+
+    let txs = vec![
+        // Bob casts a vote for key 0 in round 0
+        make_signers_vote_for_aggregate_public_key_value(
+            bob_key,
+            bob_nonce + 1,
+            bob_index,
+            aggregate_public_key.clone(),
+            0,
+            cycle_id + 1,
+        ),
+        // Alice casts vote for key 0 in round 1
+        make_signers_vote_for_aggregate_public_key_value(
+            alice_key,
+            alice_nonce + 1,
+            alice_index,
+            aggregate_public_key.clone(),
+            1,
+            cycle_id + 1,
+        ),
+    ];
+
+    // vote again in the next block of prepare phase
+    let blocks_and_sizes = nakamoto_tenure(&mut peer, &mut test_signers, vec![txs]);
+
+    // check the last four txs in the last block
+    let block = observer.get_blocks().last().unwrap().clone();
+    let receipts = block.receipts.as_slice();
+    assert_eq!(receipts.len(), 4);
+    // ignore tenure change tx
+    // ignore tenure coinbase tx
+
+    let bob_vote_tx = &receipts[2];
+    assert_eq!(bob_vote_tx.result, Value::okay_true());
+    assert_eq!(bob_vote_tx.events.len(), 2);
+    let bob_vote_event = &bob_vote_tx.events[0];
+    if let StacksTransactionEvent::SmartContractEvent(contract_event) = bob_vote_event {
+        assert_eq!(
+            contract_event.value,
+            TupleData::from_data(vec![
+                (
+                    "event".into(),
+                    Value::string_ascii_from_bytes("voted".as_bytes().to_vec())
+                        .expect("Failed to create string")
+                ),
+                ("key".into(), aggregate_public_key.clone()),
+                ("new-total".into(), Value::UInt(4)),
+                ("reward-cycle".into(), Value::UInt(cycle_id + 1)),
+                ("round".into(), Value::UInt(0)),
+                ("signer".into(), Value::Principal(bob_principal.clone())),
+            ])
+            .expect("Failed to create tuple")
+            .into()
+        );
+    } else {
+        panic!("Expected SmartContractEvent, got {:?}", bob_vote_event);
+    }
+
+    // The aggregate key is approved in round 0
+    let approve_event = &bob_vote_tx.events[1];
+    if let StacksTransactionEvent::SmartContractEvent(contract_event) = approve_event {
+        assert_eq!(
+            contract_event.value,
+            TupleData::from_data(vec![
+                (
+                    "event".into(),
+                    Value::string_ascii_from_bytes(
+                        "approved-aggregate-public-key".as_bytes().to_vec()
+                    )
+                    .expect("Failed to create string")
+                ),
+                ("key".into(), aggregate_public_key.clone()),
+                ("reward-cycle".into(), Value::UInt(cycle_id + 1)),
+            ])
+            .expect("Failed to create tuple")
+            .into()
+        );
+    } else {
+        panic!("Expected SmartContractEvent, got {:?}", approve_event);
+    }
+
+    // Alice's vote should fail with an "out of voting window" error, since the
+    // key is already set
+    let alice_vote_tx = &receipts[3];
+    assert_eq!(alice_vote_tx.result, Value::err_uint(12)); // ERR_OUT_OF_VOTING_WINDOW
+    assert_eq!(alice_vote_tx.events.len(), 0);
+}
+
 fn nakamoto_tenure(
     peer: &mut TestPeer,
     test_signers: &mut TestSigners,

From ac80a889abe32678d4a2815d7163f1fe40ebecee Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Wed, 21 Feb 2024 08:40:11 -0500
Subject: [PATCH 0836/1166] feat: add round to `approved-aggregate-public-key`
 event

---
 stackslib/src/chainstate/stacks/boot/signers-voting.clar   | 1 +
 .../src/chainstate/stacks/boot/signers_voting_tests.rs     | 7 +++++++
 2 files changed, 8 insertions(+)

diff --git a/stackslib/src/chainstate/stacks/boot/signers-voting.clar b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
index 91062366e1..a5ca200304 100644
--- a/stackslib/src/chainstate/stacks/boot/signers-voting.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
@@ -168,6 +168,7 @@
                     (print {
                         event: "approved-aggregate-public-key",
                         reward-cycle: reward-cycle,
+                        round: round,
                         key: key,
                     })
                     true)
diff --git a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
index 4b14fb2161..cc7226e6ef 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
@@ -284,6 +284,7 @@ fn vote_for_aggregate_public_key_success() {
                 ),
                 ("key".into(), aggregate_public_key.clone()),
                 ("reward-cycle".into(), Value::UInt(cycle_id + 1)),
+                ("round".into(), Value::UInt(0)),
             ])
             .expect("Failed to create tuple")
             .into()
@@ -547,6 +548,7 @@ fn vote_for_aggregate_public_key_with_errors() {
                 ),
                 ("key".into(), aggregate_public_key.clone()),
                 ("reward-cycle".into(), Value::UInt(cycle_id + 1)),
+                ("round".into(), Value::UInt(0)),
             ])
             .expect("Failed to create tuple")
             .into()
@@ -777,6 +779,7 @@ fn vote_for_aggregate_public_key_out_of_window() {
                 ),
                 ("key".into(), aggregate_public_key.clone()),
                 ("reward-cycle".into(), Value::UInt(cycle_id + 1)),
+                ("round".into(), Value::UInt(0)),
             ])
             .expect("Failed to create tuple")
             .into()
@@ -1381,6 +1384,7 @@ fn vote_for_aggregate_public_key_two_rounds() {
                 ),
                 ("key".into(), aggregate_public_key_1.clone()),
                 ("reward-cycle".into(), Value::UInt(cycle_id + 1)),
+                ("round".into(), Value::UInt(1)),
             ])
             .expect("Failed to create tuple")
             .into()
@@ -1588,6 +1592,7 @@ fn vote_for_aggregate_public_key_two_rounds() {
                 ),
                 ("key".into(), aggregate_public_key_1.clone()),
                 ("reward-cycle".into(), Value::UInt(cycle_id + 2)),
+                ("round".into(), Value::UInt(1)),
             ])
             .expect("Failed to create tuple")
             .into()
@@ -1816,6 +1821,7 @@ fn vote_for_aggregate_public_key_early() {
                 ),
                 ("key".into(), aggregate_public_key.clone()),
                 ("reward-cycle".into(), Value::UInt(cycle_id + 2)),
+                ("round".into(), Value::UInt(0)),
             ])
             .expect("Failed to create tuple")
             .into()
@@ -2027,6 +2033,7 @@ fn vote_for_aggregate_public_key_mixed_rounds() {
                 ),
                 ("key".into(), aggregate_public_key.clone()),
                 ("reward-cycle".into(), Value::UInt(cycle_id + 1)),
+                ("round".into(), Value::UInt(0)),
             ])
             .expect("Failed to create tuple")
             .into()

From d5ef455b4025071f95b04d6553cbcb6688385173 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Wed, 21 Feb 2024 07:01:56 -0800
Subject: [PATCH 0837/1166] fix: ignore timing out runloop test

---
 stacks-signer/src/runloop.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index a5a7f12bcc..1804466cb3 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -1511,6 +1511,7 @@ mod tests {
 
     #[test]
     #[serial]
+    #[ignore]
     fn verify_transactions_valid() {
         let config = Config::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
         let mut runloop: RunLoop<FireCoordinator<v2::Aggregator>> = RunLoop::from(&config);

From 5444cc4f06adc424047b28989a0b44020cdad0a7 Mon Sep 17 00:00:00 2001
From: ASuciuX <asuciu@hiro.so>
Date: Wed, 21 Feb 2024 17:36:14 +0200
Subject: [PATCH 0838/1166] feat: multi-line 'if' statements for readability

---
 .github/workflows/pr-differences-mutants.yml | 27 +++++++++++++++-----
 1 file changed, 20 insertions(+), 7 deletions(-)

diff --git a/.github/workflows/pr-differences-mutants.yml b/.github/workflows/pr-differences-mutants.yml
index a795917229..7e02c7e13d 100644
--- a/.github/workflows/pr-differences-mutants.yml
+++ b/.github/workflows/pr-differences-mutants.yml
@@ -41,7 +41,9 @@ jobs:
 
     needs: check-big-packages-and-shards
 
-    if: ${{ needs.check-big-packages-and-shards.outputs.run_small_packages == 'true' && needs.check-big-packages-and-shards.outputs.small_packages_with_shards == 'false' }}
+    if: |
+      ${{ needs.check-big-packages-and-shards.outputs.run_small_packages == 'true' &&
+      needs.check-big-packages-and-shards.outputs.small_packages_with_shards == 'false' }}
 
     runs-on: ubuntu-latest
 
@@ -57,7 +59,9 @@ jobs:
 
     needs: check-big-packages-and-shards
 
-    if: ${{ needs.check-big-packages-and-shards.outputs.run_small_packages == 'true' && needs.check-big-packages-and-shards.outputs.small_packages_with_shards == 'true' }}
+    if: |
+      ${{ needs.check-big-packages-and-shards.outputs.run_small_packages == 'true' && 
+      needs.check-big-packages-and-shards.outputs.small_packages_with_shards == 'true' }}
 
     runs-on: ubuntu-latest
 
@@ -79,7 +83,9 @@ jobs:
 
     needs: check-big-packages-and-shards
 
-    if: ${{ needs.check-big-packages-and-shards.outputs.run_stackslib == 'true' && needs.check-big-packages-and-shards.outputs.stackslib_with_shards == 'false' }}
+    if: |
+      ${{ needs.check-big-packages-and-shards.outputs.run_stackslib == 'true' && 
+      needs.check-big-packages-and-shards.outputs.stackslib_with_shards == 'false' }}
 
     runs-on: ubuntu-latest
 
@@ -98,7 +104,9 @@ jobs:
 
     needs: check-big-packages-and-shards
 
-    if: ${{ needs.check-big-packages-and-shards.outputs.run_stackslib == 'true' && needs.check-big-packages-and-shards.outputs.stackslib_with_shards == 'true' }}
+    if: |
+      ${{ needs.check-big-packages-and-shards.outputs.run_stackslib == 'true' && 
+      needs.check-big-packages-and-shards.outputs.stackslib_with_shards == 'true' }}
 
     runs-on: ubuntu-latest
 
@@ -123,7 +131,9 @@ jobs:
 
     needs: check-big-packages-and-shards
 
-    if: ${{ needs.check-big-packages-and-shards.outputs.run_stacks_node == 'true' && needs.check-big-packages-and-shards.outputs.stacks_node_with_shards == 'false' }}
+    if: |
+      ${{ needs.check-big-packages-and-shards.outputs.run_stacks_node == 'true' && 
+      needs.check-big-packages-and-shards.outputs.stacks_node_with_shards == 'false' }}
 
     runs-on: ubuntu-latest
 
@@ -142,7 +152,9 @@ jobs:
 
     needs: check-big-packages-and-shards
 
-    if: ${{ needs.check-big-packages-and-shards.outputs.run_stacks_node == 'true' && needs.check-big-packages-and-shards.outputs.stacks_node_with_shards == 'true' }}
+    if: |
+      ${{ needs.check-big-packages-and-shards.outputs.run_stacks_node == 'true' && 
+      needs.check-big-packages-and-shards.outputs.stacks_node_with_shards == 'true' }}
 
     runs-on: ubuntu-latest
 
@@ -167,7 +179,8 @@ jobs:
 
     needs: check-big-packages-and-shards
 
-    if: ${{ needs.check-big-packages-and-shards.outputs.run_stacks_signer == 'true' }}
+    if: |
+      ${{ needs.check-big-packages-and-shards.outputs.run_stacks_signer == 'true' }}
 
     runs-on: ubuntu-latest
 

From 91a1fd95e842b1e2569ff2a794d2cd634d8d2100 Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Wed, 21 Feb 2024 11:42:03 -0500
Subject: [PATCH 0839/1166] feat: add check for existing key in
 `signer_vote_if_needed`

---
 .../src/tests/nakamoto_integrations.rs        | 49 ++++++++++++++++++-
 1 file changed, 48 insertions(+), 1 deletion(-)

diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index e197d16b9b..14dd7620a8 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -40,6 +40,7 @@ use stacks::core::{
     PEER_VERSION_EPOCH_2_1, PEER_VERSION_EPOCH_2_2, PEER_VERSION_EPOCH_2_3, PEER_VERSION_EPOCH_2_4,
     PEER_VERSION_EPOCH_2_5, PEER_VERSION_EPOCH_3_0,
 };
+use stacks::net::api::callreadonly::CallReadOnlyRequestBody;
 use stacks::net::api::getstackers::GetStackersResponse;
 use stacks::net::api::postblock_proposal::{
     BlockValidateReject, BlockValidateResponse, NakamotoBlockProposal, ValidateRejectCode,
@@ -476,6 +477,42 @@ pub fn boot_to_epoch_3(
     info!("Bootstrapped to Epoch-3.0 boundary, Epoch2x miner should stop");
 }
 
+fn is_key_set_for_cycle(
+    reward_cycle: u64,
+    is_mainnet: bool,
+    http_origin: &str,
+) -> Result<bool, String> {
+    let client = reqwest::blocking::Client::new();
+    let boot_address = StacksAddress::burn_address(is_mainnet);
+    let path = format!("http://{http_origin}/v2/contracts/call-read/{boot_address}/signers-voting/get-approved-aggregate-key");
+    let body = CallReadOnlyRequestBody {
+        sender: boot_address.to_string(),
+        sponsor: None,
+        arguments: vec![clarity::vm::Value::UInt(reward_cycle as u128)
+            .serialize_to_hex()
+            .map_err(|_| "Failed to serialize reward cycle")?],
+    };
+    let res = client
+        .post(&path)
+        .json(&body)
+        .send()
+        .map_err(|_| "Failed to send request")?
+        .json::<serde_json::Value>()
+        .map_err(|_| "Failed to extract json Value")?;
+    let result_value = clarity::vm::Value::try_deserialize_hex_untyped(
+        &res.get("result")
+            .ok_or("No result in response")?
+            .as_str()
+            .ok_or("Result is not a string")?[2..],
+    )
+    .map_err(|_| "Failed to deserialize Clarity value")?;
+
+    result_value
+        .expect_optional()
+        .map(|v| v.is_some())
+        .map_err(|_| "Response is not optional".to_string())
+}
+
 fn signer_vote_if_needed(
     btc_regtest_controller: &BitcoinRegtestController,
     naka_conf: &Config,
@@ -496,8 +533,18 @@ fn signer_vote_if_needed(
                 reward_cycle,
             );
 
-        // TODO: Check if the vote has already happened
         if block_height >= prepare_phase_start {
+            // If the key is already set, do nothing.
+            if is_key_set_for_cycle(
+                reward_cycle + 1,
+                naka_conf.is_mainnet(),
+                &naka_conf.node.rpc_bind,
+            )
+            .unwrap_or(false)
+            {
+                return;
+            }
+
             // If we are self-signing, then we need to vote on the aggregate public key
             let http_origin = format!("http://{}", &naka_conf.node.rpc_bind);
 

From a3e49c810a37e18addcfecc94388f1ecb6f27519 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Tue, 13 Feb 2024 17:57:04 -0800
Subject: [PATCH 0840/1166] feat: burn op definition and storage for
 vote-for-agg-key

---
 stackslib/src/burnchains/burnchain.rs         |   3 +
 .../src/chainstate/burn/db/processing.rs      |   7 +
 stackslib/src/chainstate/burn/db/sortdb.rs    | 116 +++++++++++-
 stackslib/src/chainstate/burn/mod.rs          |   4 +
 .../src/chainstate/burn/operations/mod.rs     |  31 ++++
 .../burn/operations/vote_for_aggregate_key.rs | 173 ++++++++++++++++++
 stackslib/src/chainstate/nakamoto/mod.rs      |   3 +-
 stackslib/src/chainstate/stacks/db/blocks.rs  |  64 ++++++-
 stackslib/src/net/mod.rs                      |   1 +
 .../burnchains/bitcoin_regtest_controller.rs  |   3 +
 .../src/burnchains/mocknet_controller.rs      |   9 +-
 11 files changed, 401 insertions(+), 13 deletions(-)
 create mode 100644 stackslib/src/chainstate/burn/operations/vote_for_aggregate_key.rs

diff --git a/stackslib/src/burnchains/burnchain.rs b/stackslib/src/burnchains/burnchain.rs
index 532a6842c3..166016d925 100644
--- a/stackslib/src/burnchains/burnchain.rs
+++ b/stackslib/src/burnchains/burnchain.rs
@@ -141,6 +141,9 @@ impl BurnchainStateTransition {
                     // the burn distribution, so just account for them for now.
                     all_user_burns.insert(op.txid.clone(), op.clone());
                 }
+                BlockstackOperationType::VoteForAggregateKey(_) => {
+                    accepted_ops.push(block_ops[i].clone());
+                }
             };
         }
 
diff --git a/stackslib/src/chainstate/burn/db/processing.rs b/stackslib/src/chainstate/burn/db/processing.rs
index 0c899770d4..e017f2a74a 100644
--- a/stackslib/src/chainstate/burn/db/processing.rs
+++ b/stackslib/src/chainstate/burn/db/processing.rs
@@ -102,6 +102,13 @@ impl<'a> SortitionHandleTx<'a> {
                 );
                 BurnchainError::OpError(e)
             }),
+            BlockstackOperationType::VoteForAggregateKey(ref op) => op.check().map_err(|e| {
+                warn!(
+                    "REJECTED({}) vote for aggregate key op {} at {},{}: {:?}",
+                    op.block_height, &op.txid, op.block_height, op.vtxindex, &e
+                );
+                BurnchainError::OpError(e)
+            }),
         }
     }
 
diff --git a/stackslib/src/chainstate/burn/db/sortdb.rs b/stackslib/src/chainstate/burn/db/sortdb.rs
index f03a7b9ad9..7722af3813 100644
--- a/stackslib/src/chainstate/burn/db/sortdb.rs
+++ b/stackslib/src/chainstate/burn/db/sortdb.rs
@@ -39,6 +39,7 @@ use stacks_common::types::chainstate::{
     BlockHeaderHash, BurnchainHeaderHash, PoxId, SortitionId, StacksAddress, StacksBlockId,
     TrieHash, VRFSeed,
 };
+use stacks_common::types::StacksPublicKeyBuffer;
 use stacks_common::util::hash::{hex_bytes, to_hex, Hash160, Sha512Trunc256Sum};
 use stacks_common::util::secp256k1::{MessageSignature, Secp256k1PublicKey};
 use stacks_common::util::vrf::*;
@@ -59,7 +60,7 @@ use crate::chainstate::burn::operations::leader_block_commit::{
 };
 use crate::chainstate::burn::operations::{
     BlockstackOperationType, DelegateStxOp, LeaderBlockCommitOp, LeaderKeyRegisterOp, PreStxOp,
-    StackStxOp, TransferStxOp, UserBurnSupportOp,
+    StackStxOp, TransferStxOp, UserBurnSupportOp, VoteForAggregateKeyOp,
 };
 use crate::chainstate::burn::{
     BlockSnapshot, ConsensusHash, ConsensusHashExtensions, Opcodes, OpsHash, SortitionHash,
@@ -431,6 +432,39 @@ impl FromRow<TransferStxOp> for TransferStxOp {
     }
 }
 
+impl FromRow<VoteForAggregateKeyOp> for VoteForAggregateKeyOp {
+    fn from_row<'a>(row: &'a Row) -> Result<VoteForAggregateKeyOp, db_error> {
+        let txid = Txid::from_column(row, "txid")?;
+        let vtxindex: u32 = row.get_unwrap("vtxindex");
+        let block_height = u64::from_column(row, "block_height")?;
+        let burn_header_hash = BurnchainHeaderHash::from_column(row, "burn_header_hash")?;
+
+        let sender = StacksAddress::from_column(row, "sender_addr")?;
+        let aggregate_key_str: String = row.get_unwrap("aggregate_key");
+        let aggregate_key: StacksPublicKeyBuffer = serde_json::from_str(&aggregate_key_str)
+            .expect("CORRUPTION: DB stored bad transition ops");
+        let round: u32 = row.get_unwrap("round");
+        let reward_cycle = u64::from_column(row, "reward_cycle")?;
+        let signer_index: u16 = row.get_unwrap("signer_index");
+        let signer_key_str: String = row.get_unwrap("signer_key");
+        let signer_key: StacksPublicKeyBuffer = serde_json::from_str(&signer_key_str)
+            .expect("CORRUPTION: DB stored bad transition ops");
+
+        Ok(VoteForAggregateKeyOp {
+            txid,
+            vtxindex,
+            block_height,
+            burn_header_hash,
+            sender,
+            aggregate_key,
+            round,
+            reward_cycle,
+            signer_index,
+            signer_key,
+        })
+    }
+}
+
 impl FromColumn<ASTRules> for ASTRules {
     fn from_column<'a>(row: &'a Row, column_name: &str) -> Result<ASTRules, db_error> {
         let x: u8 = row.get_unwrap(column_name);
@@ -497,7 +531,7 @@ impl FromRow<StacksEpoch> for StacksEpoch {
     }
 }
 
-pub const SORTITION_DB_VERSION: &'static str = "8";
+pub const SORTITION_DB_VERSION: &'static str = "9";
 
 const SORTITION_DB_INITIAL_SCHEMA: &'static [&'static str] = &[
     r#"
@@ -729,6 +763,23 @@ const SORTITION_DB_SCHEMA_8: &'static [&'static str] = &[
     );"#,
 ];
 
+const SORTITION_DB_SCHEMA_9: &'static [&'static str] = &[r#"
+    CREATE TABLE vote_for_aggregate_key (
+        txid TEXT NOT NULL,
+        vtxindex INTEGER NOT NULL,
+        block_height INTEGER NOT NULL,
+        burn_header_hash TEXT NOT NULL,
+
+        sender_addr TEXT NOT NULL,
+        aggregate_key TEXT NOT NULL,
+        round INTEGER NOT NULL,
+        reward_cycle INTEGER NOT NULL,
+        signer_index INTEGER NOT NULL,
+        signer_key TEXT NOT NULL,
+
+        PRIMARY KEY(txid,burn_header_Hash)
+    );"#];
+
 const SORTITION_DB_INDEXES: &'static [&'static str] = &[
     "CREATE INDEX IF NOT EXISTS snapshots_block_hashes ON snapshots(block_height,index_root,winning_stacks_block_hash);",
     "CREATE INDEX IF NOT EXISTS snapshots_block_stacks_hashes ON snapshots(num_sortitions,index_root,winning_stacks_block_hash);",
@@ -2944,6 +2995,7 @@ impl SortitionDB {
         SortitionDB::apply_schema_6(&db_tx, epochs_ref)?;
         SortitionDB::apply_schema_7(&db_tx, epochs_ref)?;
         SortitionDB::apply_schema_8(&db_tx)?;
+        SortitionDB::apply_schema_9(&db_tx)?;
 
         db_tx.instantiate_index()?;
 
@@ -3362,6 +3414,18 @@ impl SortitionDB {
         Ok(())
     }
 
+    fn apply_schema_9(tx: &DBTx) -> Result<(), db_error> {
+        for sql_exec in SORTITION_DB_SCHEMA_9 {
+            tx.execute_batch(sql_exec)?;
+        }
+
+        tx.execute(
+            "INSERT OR REPLACE INTO db_config (version) VALUES (?1)",
+            &["9"],
+        )?;
+        Ok(())
+    }
+
     fn check_schema_version_or_error(&mut self) -> Result<(), db_error> {
         match SortitionDB::get_schema_version(self.conn()) {
             Ok(Some(version)) => {
@@ -3416,6 +3480,10 @@ impl SortitionDB {
                         let tx = self.tx_begin()?;
                         SortitionDB::apply_schema_8(&tx.deref())?;
                         tx.commit()?;
+                    } else if version == "8" {
+                        let tx = self.tx_begin()?;
+                        SortitionDB::apply_schema_9(&tx.deref())?;
+                        tx.commit()?;
                     } else if version == expected_version {
                         return Ok(());
                     } else {
@@ -4400,6 +4468,20 @@ impl SortitionDB {
         )
     }
 
+    /// Get the list of `vote-for-aggregate-key` operations processed in a given burnchain block.
+    /// This will be the same list in each PoX fork; it's up to the Stacks block-processing logic
+    /// to reject them.
+    pub fn get_vote_for_aggregate_key_ops(
+        conn: &Connection,
+        burn_header_hash: &BurnchainHeaderHash,
+    ) -> Result<Vec<VoteForAggregateKeyOp>, db_error> {
+        query_rows(
+            conn,
+            "SELECT * FROM vote_for_aggregate_key WHERE burn_header_hash = ? ORDER BY vtxindex",
+            &[burn_header_hash],
+        )
+    }
+
     /// Get the list of Transfer-STX operations processed in a given burnchain block.
     /// This will be the same list in each PoX fork; it's up to the Stacks block-processing logic
     /// to reject them.
@@ -5406,6 +5488,13 @@ impl<'a> SortitionHandleTx<'a> {
                 );
                 self.insert_delegate_stx(op)
             }
+            BlockstackOperationType::VoteForAggregateKey(ref op) => {
+                info!(
+                    "ACCEPTED({}) vote for aggregate key {} at {},{}",
+                    op.block_height, &op.txid, op.block_height, op.vtxindex
+                );
+                self.insert_vote_for_aggregate_key(op)
+            }
         }
     }
 
@@ -5473,6 +5562,29 @@ impl<'a> SortitionHandleTx<'a> {
         Ok(())
     }
 
+    /// Insert a vote-for-aggregate-key op
+    fn insert_vote_for_aggregate_key(
+        &mut self,
+        op: &VoteForAggregateKeyOp,
+    ) -> Result<(), db_error> {
+        let args: &[&dyn ToSql] = &[
+            &op.txid,
+            &op.vtxindex,
+            &u64_to_sql(op.block_height)?,
+            &op.burn_header_hash,
+            &op.sender.to_string(),
+            &serde_json::to_string(&op.aggregate_key).unwrap(),
+            &op.round,
+            &u64_to_sql(op.reward_cycle)?,
+            &op.signer_index,
+            &serde_json::to_string(&op.signer_key).unwrap(),
+        ];
+
+        self.execute("REPLACE INTO vote_for_aggregate_key (txid, vtxindex, block_height, burn_header_hash, sender_addr, aggregate_key, round, reward_cycle, signer_index, signer_key) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10)", args)?;
+
+        Ok(())
+    }
+
     /// Insert a transfer-stx op
     fn insert_transfer_stx(&mut self, op: &TransferStxOp) -> Result<(), db_error> {
         let args: &[&dyn ToSql] = &[
diff --git a/stackslib/src/chainstate/burn/mod.rs b/stackslib/src/chainstate/burn/mod.rs
index 4010ba2fc3..c99ce7269d 100644
--- a/stackslib/src/chainstate/burn/mod.rs
+++ b/stackslib/src/chainstate/burn/mod.rs
@@ -69,6 +69,7 @@ pub enum Opcodes {
     PreStx = 'p' as u8,
     TransferStx = '$' as u8,
     DelegateStx = '#' as u8,
+    VoteForAggregateKey = 'v' as u8,
 }
 
 // a burnchain block snapshot
@@ -193,6 +194,7 @@ impl Opcodes {
     const HTTP_PEG_IN: &'static str = "peg_in";
     const HTTP_PEG_OUT_REQUEST: &'static str = "peg_out_request";
     const HTTP_PEG_OUT_FULFILL: &'static str = "peg_out_fulfill";
+    const HTTP_VOTE_FOR_AGGREGATE_KEY: &'static str = "vote_for_aggregate_key";
 
     pub fn to_http_str(&self) -> &'static str {
         match self {
@@ -203,6 +205,7 @@ impl Opcodes {
             Opcodes::PreStx => Self::HTTP_PRE_STX,
             Opcodes::TransferStx => Self::HTTP_TRANSFER_STX,
             Opcodes::DelegateStx => Self::HTTP_DELEGATE_STX,
+            Opcodes::VoteForAggregateKey => Self::HTTP_VOTE_FOR_AGGREGATE_KEY,
         }
     }
 
@@ -215,6 +218,7 @@ impl Opcodes {
             Self::HTTP_PRE_STX => Opcodes::PreStx,
             Self::HTTP_TRANSFER_STX => Opcodes::TransferStx,
             Self::HTTP_DELEGATE_STX => Opcodes::DelegateStx,
+            Self::HTTP_VOTE_FOR_AGGREGATE_KEY => Opcodes::VoteForAggregateKey,
             _ => return None,
         };
 
diff --git a/stackslib/src/chainstate/burn/operations/mod.rs b/stackslib/src/chainstate/burn/operations/mod.rs
index 189acab16c..35ae3ebbc0 100644
--- a/stackslib/src/chainstate/burn/operations/mod.rs
+++ b/stackslib/src/chainstate/burn/operations/mod.rs
@@ -23,6 +23,7 @@ use serde_json::json;
 use stacks_common::types::chainstate::{
     BlockHeaderHash, BurnchainHeaderHash, StacksAddress, StacksBlockId, TrieHash, VRFSeed,
 };
+use stacks_common::types::StacksPublicKeyBuffer;
 use stacks_common::util::hash::{hex_bytes, to_hex, Hash160, Sha512Trunc256Sum};
 use stacks_common::util::secp256k1::MessageSignature;
 use stacks_common::util::vrf::VRFPublicKey;
@@ -46,6 +47,7 @@ pub mod leader_key_register;
 pub mod stack_stx;
 pub mod transfer_stx;
 pub mod user_burn_support;
+pub mod vote_for_aggregate_key;
 
 #[cfg(test)]
 mod test;
@@ -305,6 +307,22 @@ pub struct DelegateStxOp {
     pub burn_header_hash: BurnchainHeaderHash, // hash of the burn chain block header
 }
 
+#[derive(Debug, PartialEq, Clone, Eq, Serialize, Deserialize)]
+pub struct VoteForAggregateKeyOp {
+    pub sender: StacksAddress,
+    pub aggregate_key: StacksPublicKeyBuffer,
+    pub round: u32,
+    pub reward_cycle: u64,
+    pub signer_index: u16,
+    pub signer_key: StacksPublicKeyBuffer,
+
+    // common to all transactions
+    pub txid: Txid,                            // transaction ID
+    pub vtxindex: u32,                         // index in the block where this tx occurs
+    pub block_height: u64,                     // block height at which this tx occurs
+    pub burn_header_hash: BurnchainHeaderHash, // hash of the burn chain block header
+}
+
 fn hex_ser_memo<S: serde::Serializer>(bytes: &[u8], s: S) -> Result<S::Ok, S::Error> {
     let inst = to_hex(bytes);
     s.serialize_str(inst.as_str())
@@ -348,6 +366,7 @@ pub enum BlockstackOperationType {
     StackStx(StackStxOp),
     TransferStx(TransferStxOp),
     DelegateStx(DelegateStxOp),
+    VoteForAggregateKey(VoteForAggregateKeyOp),
 }
 
 // serialization helpers for blockstack_op_to_json function
@@ -375,6 +394,7 @@ impl BlockstackOperationType {
             BlockstackOperationType::PreStx(_) => Opcodes::PreStx,
             BlockstackOperationType::TransferStx(_) => Opcodes::TransferStx,
             BlockstackOperationType::DelegateStx(_) => Opcodes::DelegateStx,
+            BlockstackOperationType::VoteForAggregateKey(_) => Opcodes::VoteForAggregateKey,
         }
     }
 
@@ -391,6 +411,7 @@ impl BlockstackOperationType {
             BlockstackOperationType::PreStx(ref data) => &data.txid,
             BlockstackOperationType::TransferStx(ref data) => &data.txid,
             BlockstackOperationType::DelegateStx(ref data) => &data.txid,
+            BlockstackOperationType::VoteForAggregateKey(ref data) => &data.txid,
         }
     }
 
@@ -403,6 +424,7 @@ impl BlockstackOperationType {
             BlockstackOperationType::PreStx(ref data) => data.vtxindex,
             BlockstackOperationType::TransferStx(ref data) => data.vtxindex,
             BlockstackOperationType::DelegateStx(ref data) => data.vtxindex,
+            BlockstackOperationType::VoteForAggregateKey(ref data) => data.vtxindex,
         }
     }
 
@@ -415,6 +437,7 @@ impl BlockstackOperationType {
             BlockstackOperationType::PreStx(ref data) => data.block_height,
             BlockstackOperationType::TransferStx(ref data) => data.block_height,
             BlockstackOperationType::DelegateStx(ref data) => data.block_height,
+            BlockstackOperationType::VoteForAggregateKey(ref data) => data.block_height,
         }
     }
 
@@ -427,6 +450,7 @@ impl BlockstackOperationType {
             BlockstackOperationType::PreStx(ref data) => data.burn_header_hash.clone(),
             BlockstackOperationType::TransferStx(ref data) => data.burn_header_hash.clone(),
             BlockstackOperationType::DelegateStx(ref data) => data.burn_header_hash.clone(),
+            BlockstackOperationType::VoteForAggregateKey(ref data) => data.burn_header_hash.clone(),
         }
     }
 
@@ -442,6 +466,9 @@ impl BlockstackOperationType {
             BlockstackOperationType::PreStx(ref mut data) => data.block_height = height,
             BlockstackOperationType::TransferStx(ref mut data) => data.block_height = height,
             BlockstackOperationType::DelegateStx(ref mut data) => data.block_height = height,
+            BlockstackOperationType::VoteForAggregateKey(ref mut data) => {
+                data.block_height = height
+            }
         };
     }
 
@@ -459,6 +486,9 @@ impl BlockstackOperationType {
             BlockstackOperationType::PreStx(ref mut data) => data.burn_header_hash = hash,
             BlockstackOperationType::TransferStx(ref mut data) => data.burn_header_hash = hash,
             BlockstackOperationType::DelegateStx(ref mut data) => data.burn_header_hash = hash,
+            BlockstackOperationType::VoteForAggregateKey(ref mut data) => {
+                data.burn_header_hash = hash
+            }
         };
     }
 
@@ -550,6 +580,7 @@ impl fmt::Display for BlockstackOperationType {
             BlockstackOperationType::UserBurnSupport(ref op) => write!(f, "{:?}", op),
             BlockstackOperationType::TransferStx(ref op) => write!(f, "{:?}", op),
             BlockstackOperationType::DelegateStx(ref op) => write!(f, "{:?}", op),
+            BlockstackOperationType::VoteForAggregateKey(ref op) => write!(f, "{:?}", op),
         }
     }
 }
diff --git a/stackslib/src/chainstate/burn/operations/vote_for_aggregate_key.rs b/stackslib/src/chainstate/burn/operations/vote_for_aggregate_key.rs
new file mode 100644
index 0000000000..afc4108663
--- /dev/null
+++ b/stackslib/src/chainstate/burn/operations/vote_for_aggregate_key.rs
@@ -0,0 +1,173 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+use std::io::{Read, Write};
+
+use stacks_common::codec::{write_next, Error as codec_error, StacksMessageCodec};
+use stacks_common::types::chainstate::{BurnchainHeaderHash, StacksAddress};
+use stacks_common::types::StacksPublicKeyBuffer;
+use stacks_common::util::secp256k1::Secp256k1PublicKey;
+
+use crate::burnchains::bitcoin::BitcoinTxInput;
+use crate::burnchains::{BurnchainBlockHeader, BurnchainTransaction, Txid};
+use crate::chainstate::burn::operations::{
+    parse_u128_from_be, parse_u16_from_be, parse_u32_from_be, parse_u64_from_be,
+    BlockstackOperationType, Error as op_error, PreStxOp, VoteForAggregateKeyOp,
+};
+use crate::chainstate::burn::Opcodes;
+use crate::chainstate::stacks::address::PoxAddress;
+
+struct ParsedData {
+    signer_index: u16,
+    aggregate_key: StacksPublicKeyBuffer,
+    round: u32,
+    reward_cycle: u64,
+}
+
+impl VoteForAggregateKeyOp {
+    pub fn from_tx(
+        block_header: &BurnchainBlockHeader,
+        tx: &BurnchainTransaction,
+        sender: &StacksAddress,
+    ) -> Result<VoteForAggregateKeyOp, op_error> {
+        VoteForAggregateKeyOp::parse_from_tx(
+            block_header.block_height,
+            &block_header.block_hash,
+            tx,
+            sender,
+        )
+    }
+
+    fn parse_data(data: &Vec<u8>) -> Option<ParsedData> {
+        /*
+           Wire format:
+
+           0     2    3           5              38     42           50
+           |-----|----|-----------|--------------|------|------------|
+           magic  op  signer_index aggregate_key  round  reward_cycle
+
+           Note that `data` is missing the first 3 bytes -- the magic and op have been stripped
+        */
+
+        if data.len() != 47 {
+            warn!(
+                "Vote for aggregate key operation data has an invalid length ({} bytes)",
+                data.len()
+            );
+            return None;
+        }
+
+        let signer_index = parse_u16_from_be(&data[0..2]).unwrap();
+        let aggregate_key = StacksPublicKeyBuffer::from(&data[2..35]);
+
+        let round = parse_u32_from_be(&data[35..39]).unwrap();
+        let reward_cycle = parse_u64_from_be(&data[39..47]).unwrap();
+
+        Some(ParsedData {
+            signer_index,
+            aggregate_key,
+            round,
+            reward_cycle,
+        })
+    }
+
+    pub fn get_sender_txid(tx: &BurnchainTransaction) -> Result<&Txid, op_error> {
+        match tx.get_input_tx_ref(0) {
+            Some((ref txid, vout)) => {
+                if *vout != 1 {
+                    warn!("Invalid tx: DelegateStxOp must spend the second output of the PreStxOp");
+                    Err(op_error::InvalidInput)
+                } else {
+                    Ok(txid)
+                }
+            }
+            None => {
+                warn!("Invalid tx: DelegateStxOp must have at least one input");
+                Err(op_error::InvalidInput)
+            }
+        }
+    }
+
+    pub fn get_sender_pubkey(tx: &BurnchainTransaction) -> Result<&Secp256k1PublicKey, op_error> {
+        match tx {
+            BurnchainTransaction::Bitcoin(ref btc) => match btc.inputs.get(0) {
+                Some(BitcoinTxInput::Raw(_)) => Err(op_error::InvalidInput),
+                Some(BitcoinTxInput::Structured(input)) => {
+                    input.keys.get(0).ok_or(op_error::InvalidInput)
+                }
+                _ => Err(op_error::InvalidInput),
+            },
+        }
+    }
+
+    pub fn parse_from_tx(
+        block_height: u64,
+        block_hash: &BurnchainHeaderHash,
+        tx: &BurnchainTransaction,
+        sender: &StacksAddress,
+    ) -> Result<VoteForAggregateKeyOp, op_error> {
+        let outputs = tx.get_recipients();
+
+        if tx.num_signers() == 0 {
+            warn!(
+                "Invalid tx: inputs: {}, outputs: {}",
+                tx.num_signers(),
+                outputs.len()
+            );
+            return Err(op_error::InvalidInput);
+        }
+
+        if outputs.len() == 0 {
+            warn!(
+                "Invalid tx: inputs: {}, outputs: {}",
+                tx.num_signers(),
+                outputs.len()
+            );
+            return Err(op_error::InvalidInput);
+        }
+
+        if tx.opcode() != Opcodes::VoteForAggregateKey as u8 {
+            warn!("Invalid tx: invalid opcode {}", tx.opcode());
+            return Err(op_error::InvalidInput);
+        };
+
+        let data = VoteForAggregateKeyOp::parse_data(&tx.data()).ok_or_else(|| {
+            warn!("Invalid tx data");
+            op_error::ParseError
+        })?;
+
+        let signer_key = VoteForAggregateKeyOp::get_sender_pubkey(tx)?;
+
+        Ok(VoteForAggregateKeyOp {
+            sender: sender.clone(),
+            signer_index: data.signer_index,
+            aggregate_key: data.aggregate_key,
+            round: data.round,
+            reward_cycle: data.reward_cycle,
+            signer_key: signer_key.to_bytes_compressed().as_slice().into(),
+            txid: tx.txid(),
+            vtxindex: tx.vtxindex(),
+            block_height,
+            burn_header_hash: block_hash.clone(),
+        })
+    }
+
+    pub fn check(&self) -> Result<(), op_error> {
+        // TODO
+
+        Ok(())
+    }
+}
diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index 13b08b8db0..cb8256d397 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -2464,7 +2464,7 @@ impl NakamotoChainState {
         };
 
         // TODO: only need to do this if this is a tenure-start block
-        let (stacking_burn_ops, transfer_burn_ops, delegate_burn_ops) =
+        let (stacking_burn_ops, transfer_burn_ops, delegate_burn_ops, _vote_for_agg_key_ops) =
             StacksChainState::get_stacking_and_transfer_and_delegate_burn_ops(
                 chainstate_tx,
                 &parent_index_hash,
@@ -2591,6 +2591,7 @@ impl NakamotoChainState {
                 burn_header_height.into(),
                 coinbase_height,
             )?;
+            // TODO: handle vote-for-aggregate-key ops
         } else {
             signer_set_calc = None;
         }
diff --git a/stackslib/src/chainstate/stacks/db/blocks.rs b/stackslib/src/chainstate/stacks/db/blocks.rs
index ba190d9811..c88aafd027 100644
--- a/stackslib/src/chainstate/stacks/db/blocks.rs
+++ b/stackslib/src/chainstate/stacks/db/blocks.rs
@@ -169,6 +169,7 @@ pub struct SetupBlockResult<'a, 'b> {
     pub burn_transfer_stx_ops: Vec<TransferStxOp>,
     pub auto_unlock_events: Vec<StacksTransactionEvent>,
     pub burn_delegate_stx_ops: Vec<DelegateStxOp>,
+    pub burn_vote_for_aggregate_key_ops: Vec<VoteForAggregateKeyOp>,
     /// Result of a signer set calculation if one occurred
     pub signer_set_calc: Option<SignerCalculation>,
 }
@@ -4687,7 +4688,15 @@ impl StacksChainState {
         burn_tip: &BurnchainHeaderHash,
         burn_tip_height: u64,
         epoch_start_height: u64,
-    ) -> Result<(Vec<StackStxOp>, Vec<TransferStxOp>, Vec<DelegateStxOp>), Error> {
+    ) -> Result<
+        (
+            Vec<StackStxOp>,
+            Vec<TransferStxOp>,
+            Vec<DelegateStxOp>,
+            Vec<VoteForAggregateKeyOp>,
+        ),
+        Error,
+    > {
         // only consider transactions in Stacks 2.1
         let search_window: u8 =
             if epoch_start_height + u64::from(BURNCHAIN_TX_SEARCH_WINDOW) > burn_tip_height {
@@ -4726,12 +4735,15 @@ impl StacksChainState {
         let mut all_stacking_burn_ops = vec![];
         let mut all_transfer_burn_ops = vec![];
         let mut all_delegate_burn_ops = vec![];
+        let mut all_vote_for_aggregate_key_ops = vec![];
 
         // go from oldest burn header hash to newest
         for ancestor_bhh in ancestor_burnchain_header_hashes.iter().rev() {
             let stacking_ops = SortitionDB::get_stack_stx_ops(sortdb_conn, ancestor_bhh)?;
             let transfer_ops = SortitionDB::get_transfer_stx_ops(sortdb_conn, ancestor_bhh)?;
             let delegate_ops = SortitionDB::get_delegate_stx_ops(sortdb_conn, ancestor_bhh)?;
+            let vote_for_aggregate_key_ops =
+                SortitionDB::get_vote_for_aggregate_key_ops(sortdb_conn, ancestor_bhh)?;
 
             for stacking_op in stacking_ops.into_iter() {
                 if !processed_burnchain_txids.contains(&stacking_op.txid) {
@@ -4750,11 +4762,18 @@ impl StacksChainState {
                     all_delegate_burn_ops.push(delegate_op);
                 }
             }
+
+            for vote_op in vote_for_aggregate_key_ops.into_iter() {
+                if !processed_burnchain_txids.contains(&vote_op.txid) {
+                    all_vote_for_aggregate_key_ops.push(vote_op);
+                }
+            }
         }
         Ok((
             all_stacking_burn_ops,
             all_transfer_burn_ops,
             all_delegate_burn_ops,
+            all_vote_for_aggregate_key_ops,
         ))
     }
 
@@ -4782,13 +4801,23 @@ impl StacksChainState {
     /// The change in Stacks 2.1+ makes it so that it's overwhelmingly likely to work
     /// the first time -- the choice of K is significantly bigger than the length of short-lived
     /// forks or periods of time with no sortition than have been observed in practice.
+    ///
+    /// In epoch 2.5+, the vote-for-aggregate-key op is included
     pub fn get_stacking_and_transfer_and_delegate_burn_ops(
         chainstate_tx: &mut ChainstateTx,
         parent_index_hash: &StacksBlockId,
         sortdb_conn: &Connection,
         burn_tip: &BurnchainHeaderHash,
         burn_tip_height: u64,
-    ) -> Result<(Vec<StackStxOp>, Vec<TransferStxOp>, Vec<DelegateStxOp>), Error> {
+    ) -> Result<
+        (
+            Vec<StackStxOp>,
+            Vec<TransferStxOp>,
+            Vec<DelegateStxOp>,
+            Vec<VoteForAggregateKeyOp>,
+        ),
+        Error,
+    > {
         let cur_epoch = SortitionDB::get_stacks_epoch(sortdb_conn, burn_tip_height)?
             .expect("FATAL: no epoch defined for current burnchain tip height");
 
@@ -4803,14 +4832,24 @@ impl StacksChainState {
                         burn_tip,
                     )?;
                 // The DelegateStx bitcoin wire format does not exist before Epoch 2.1.
-                Ok((stack_ops, transfer_ops, vec![]))
+                Ok((stack_ops, transfer_ops, vec![], vec![]))
             }
             StacksEpochId::Epoch21
             | StacksEpochId::Epoch22
             | StacksEpochId::Epoch23
-            | StacksEpochId::Epoch24
-            | StacksEpochId::Epoch25
-            | StacksEpochId::Epoch30 => {
+            | StacksEpochId::Epoch24 => {
+                let (stack_ops, transfer_ops, delegate_ops, _) =
+                    StacksChainState::get_stacking_and_transfer_and_delegate_burn_ops_v210(
+                        chainstate_tx,
+                        parent_index_hash,
+                        sortdb_conn,
+                        burn_tip,
+                        burn_tip_height,
+                        cur_epoch.start_height,
+                    )?;
+                Ok((stack_ops, transfer_ops, delegate_ops, vec![]))
+            }
+            StacksEpochId::Epoch25 | StacksEpochId::Epoch30 => {
                 // TODO: sbtc ops in epoch 3.0
                 StacksChainState::get_stacking_and_transfer_and_delegate_burn_ops_v210(
                     chainstate_tx,
@@ -4969,7 +5008,7 @@ impl StacksChainState {
             (latest_miners, parent_miner)
         };
 
-        let (stacking_burn_ops, transfer_burn_ops, delegate_burn_ops) =
+        let (stacking_burn_ops, transfer_burn_ops, delegate_burn_ops, vote_for_agg_key_burn_ops) =
             StacksChainState::get_stacking_and_transfer_and_delegate_burn_ops(
                 chainstate_tx,
                 &parent_index_hash,
@@ -5174,6 +5213,10 @@ impl StacksChainState {
                 &chain_tip.anchored_header.block_hash()
             );
         }
+        // Vote for aggregate pubkey ops are allowed from epoch 2.4 onward
+        if evaluated_epoch >= StacksEpochId::Epoch25 {
+            // TODO: implement
+        }
 
         debug!(
             "Setup block: ready to go for {}/{}",
@@ -5194,6 +5237,7 @@ impl StacksChainState {
             burn_transfer_stx_ops: transfer_burn_ops,
             auto_unlock_events,
             burn_delegate_stx_ops: delegate_burn_ops,
+            burn_vote_for_aggregate_key_ops: vote_for_agg_key_burn_ops,
             signer_set_calc,
         })
     }
@@ -5392,6 +5436,7 @@ impl StacksChainState {
             mut auto_unlock_events,
             burn_delegate_stx_ops,
             signer_set_calc,
+            burn_vote_for_aggregate_key_ops: _,
         } = StacksChainState::setup_block(
             chainstate_tx,
             clarity_instance,
@@ -5705,6 +5750,7 @@ impl StacksChainState {
             burn_stack_stx_ops,
             burn_transfer_stx_ops,
             burn_delegate_stx_ops,
+            // TODO: vote for agg key ops
             affirmation_weight,
         )
         .expect("FATAL: failed to advance chain tip");
@@ -11017,7 +11063,7 @@ pub mod test {
                 let chainstate = peer.chainstate();
                 let (mut chainstate_tx, clarity_instance) =
                     chainstate.chainstate_tx_begin().unwrap();
-                let (stack_stx_ops, transfer_stx_ops, delegate_stx_ops) =
+                let (stack_stx_ops, transfer_stx_ops, delegate_stx_ops, vote_for_aggregate_key_ops) =
                     StacksChainState::get_stacking_and_transfer_and_delegate_burn_ops_v210(
                         &mut chainstate_tx,
                         &last_block_id,
@@ -11698,7 +11744,7 @@ pub mod test {
                 let chainstate = peer.chainstate();
                 let (mut chainstate_tx, clarity_instance) =
                     chainstate.chainstate_tx_begin().unwrap();
-                let (stack_stx_ops, transfer_stx_ops, delegate_stx_ops) =
+                let (stack_stx_ops, transfer_stx_ops, delegate_stx_ops, _) =
                     StacksChainState::get_stacking_and_transfer_and_delegate_burn_ops_v210(
                         &mut chainstate_tx,
                         &last_block_id,
diff --git a/stackslib/src/net/mod.rs b/stackslib/src/net/mod.rs
index 0c1725d6b9..98857a4e58 100644
--- a/stackslib/src/net/mod.rs
+++ b/stackslib/src/net/mod.rs
@@ -1676,6 +1676,7 @@ pub mod test {
                 BlockstackOperationType::TransferStx(_)
                 | BlockstackOperationType::DelegateStx(_)
                 | BlockstackOperationType::PreStx(_)
+                | BlockstackOperationType::VoteForAggregateKey(_)
                 | BlockstackOperationType::StackStx(_) => Ok(()),
             }
         }
diff --git a/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs b/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
index bb04fc4b90..f4dfaec065 100644
--- a/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
+++ b/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
@@ -901,6 +901,7 @@ impl BitcoinRegtestController {
             | BlockstackOperationType::LeaderKeyRegister(_)
             | BlockstackOperationType::StackStx(_)
             | BlockstackOperationType::DelegateStx(_)
+            | BlockstackOperationType::VoteForAggregateKey(_)
             | BlockstackOperationType::UserBurnSupport(_) => {
                 unimplemented!();
             }
@@ -1843,6 +1844,8 @@ impl BitcoinRegtestController {
             BlockstackOperationType::DelegateStx(payload) => {
                 self.build_delegate_stacks_tx(epoch_id, payload, op_signer, None)
             }
+            // TODO
+            BlockstackOperationType::VoteForAggregateKey(_payload) => unimplemented!(),
         };
 
         transaction.map(|tx| SerializedTx::new(tx))
diff --git a/testnet/stacks-node/src/burnchains/mocknet_controller.rs b/testnet/stacks-node/src/burnchains/mocknet_controller.rs
index 0c1ae9c84e..a52c1ab0bb 100644
--- a/testnet/stacks-node/src/burnchains/mocknet_controller.rs
+++ b/testnet/stacks-node/src/burnchains/mocknet_controller.rs
@@ -10,7 +10,7 @@ use stacks::chainstate::burn::db::sortdb::{SortitionDB, SortitionHandleTx};
 use stacks::chainstate::burn::operations::leader_block_commit::BURN_BLOCK_MINED_AT_MODULUS;
 use stacks::chainstate::burn::operations::{
     BlockstackOperationType, DelegateStxOp, LeaderBlockCommitOp, LeaderKeyRegisterOp, PreStxOp,
-    StackStxOp, TransferStxOp, UserBurnSupportOp,
+    StackStxOp, TransferStxOp, UserBurnSupportOp, VoteForAggregateKeyOp,
 };
 use stacks::chainstate::burn::BlockSnapshot;
 use stacks::core::{
@@ -264,6 +264,13 @@ impl BurnchainController for MocknetController {
                         ..payload
                     })
                 }
+                BlockstackOperationType::VoteForAggregateKey(payload) => {
+                    BlockstackOperationType::VoteForAggregateKey(VoteForAggregateKeyOp {
+                        block_height: next_block_header.block_height,
+                        burn_header_hash: next_block_header.block_hash,
+                        ..payload
+                    })
+                }
             };
             ops.push(op);
         }

From 233a91d238d617fd81993ffd23f6179b286fe7a5 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Tue, 20 Feb 2024 18:05:06 -0800
Subject: [PATCH 0841/1166] wip: process vote-for-aggregate-key burn ops

---
 stackslib/src/burnchains/bitcoin/bits.rs      |   2 +-
 stackslib/src/burnchains/burnchain.rs         |  31 +-
 stackslib/src/chainstate/burn/db/sortdb.rs    |  48 +++
 .../src/chainstate/burn/operations/mod.rs     |  22 +-
 .../burn/operations/test/serialization.rs     |  47 ++-
 .../burn/operations/vote_for_aggregate_key.rs | 262 ++++++++++++-
 stackslib/src/chainstate/nakamoto/mod.rs      |  16 +-
 .../src/chainstate/stacks/db/accounts.rs      |   1 +
 stackslib/src/chainstate/stacks/db/blocks.rs  | 109 +++++-
 stackslib/src/chainstate/stacks/db/mod.rs     |  17 +-
 .../burnchains/bitcoin_regtest_controller.rs  |  92 ++++-
 .../src/tests/nakamoto_integrations.rs        | 253 ++++++++++++-
 .../src/tests/neon_integrations.rs            | 346 +++++++++++++++++-
 13 files changed, 1209 insertions(+), 37 deletions(-)

diff --git a/stackslib/src/burnchains/bitcoin/bits.rs b/stackslib/src/burnchains/bitcoin/bits.rs
index 2fb1f8a493..afeaefc0dc 100644
--- a/stackslib/src/burnchains/bitcoin/bits.rs
+++ b/stackslib/src/burnchains/bitcoin/bits.rs
@@ -47,7 +47,7 @@ pub fn parse_script<'a>(script: &'a Script) -> Vec<Instruction<'a>> {
 
 impl BitcoinTxInputStructured {
     /// Parse a script instruction stream encoding a p2pkh scritpsig into a BitcoinTxInput
-    fn from_bitcoin_p2pkh_script_sig(
+    pub fn from_bitcoin_p2pkh_script_sig(
         instructions: &Vec<Instruction>,
         input_txid: (Txid, u32),
     ) -> Option<BitcoinTxInputStructured> {
diff --git a/stackslib/src/burnchains/burnchain.rs b/stackslib/src/burnchains/burnchain.rs
index 166016d925..d447c40014 100644
--- a/stackslib/src/burnchains/burnchain.rs
+++ b/stackslib/src/burnchains/burnchain.rs
@@ -55,7 +55,7 @@ use crate::chainstate::burn::distribution::BurnSamplePoint;
 use crate::chainstate::burn::operations::leader_block_commit::MissedBlockCommit;
 use crate::chainstate::burn::operations::{
     BlockstackOperationType, DelegateStxOp, LeaderBlockCommitOp, LeaderKeyRegisterOp, PreStxOp,
-    StackStxOp, TransferStxOp, UserBurnSupportOp,
+    StackStxOp, TransferStxOp, UserBurnSupportOp, VoteForAggregateKeyOp,
 };
 use crate::chainstate::burn::{BlockSnapshot, Opcodes};
 use crate::chainstate::coordinator::comm::CoordinatorChannels;
@@ -888,6 +888,35 @@ impl Burnchain {
                     None
                 }
             }
+            x if x == Opcodes::VoteForAggregateKey as u8 => {
+                let pre_stx_txid = VoteForAggregateKeyOp::get_sender_txid(burn_tx).ok()?;
+                let pre_stx_tx = match pre_stx_op_map.get(&pre_stx_txid) {
+                    Some(tx_ref) => Some(BlockstackOperationType::PreStx(tx_ref.clone())),
+                    None => burnchain_db.find_burnchain_op(indexer, pre_stx_txid),
+                };
+                if let Some(BlockstackOperationType::PreStx(pre_stx)) = pre_stx_tx {
+                    let sender = &pre_stx.output;
+                    match VoteForAggregateKeyOp::from_tx(block_header, burn_tx, sender) {
+                        Ok(op) => Some(BlockstackOperationType::VoteForAggregateKey(op)),
+                        Err(e) => {
+                            warn!(
+                                "Failed to parse vote-for-aggregate-key tx";
+                                "txid" => %burn_tx.txid(),
+                                "data" => %to_hex(&burn_tx.data()),
+                                "error" => ?e,
+                            );
+                            None
+                        }
+                    }
+                } else {
+                    warn!(
+                        "Failed to find corresponding input to VoteForAggregateKeyOp";
+                        "txid" => %burn_tx.txid().to_string(),
+                        "pre_stx_txid" => %pre_stx_txid.to_string()
+                    );
+                    None
+                }
+            }
 
             _ => None,
         }
diff --git a/stackslib/src/chainstate/burn/db/sortdb.rs b/stackslib/src/chainstate/burn/db/sortdb.rs
index 7722af3813..2cee5f261c 100644
--- a/stackslib/src/chainstate/burn/db/sortdb.rs
+++ b/stackslib/src/chainstate/burn/db/sortdb.rs
@@ -803,6 +803,7 @@ const SORTITION_DB_INDEXES: &'static [&'static str] = &[
     "CREATE INDEX IF NOT EXISTS index_pox_payouts ON snapshots(pox_payouts);",
     "CREATE INDEX IF NOT EXISTS index_burn_header_hash_pox_valid ON snapshots(burn_header_hash,pox_valid);",
     "CREATE INDEX IF NOT EXISTS index_delegate_stx_burn_header_hash ON delegate_stx(burn_header_hash);",
+    "CREATE INDEX IF NOT EXISTS index_vote_for_aggregate_key_burn_header_hash ON vote_for_aggregate_key(burn_header_hash);",
 ];
 
 pub struct SortitionDB {
@@ -10423,6 +10424,19 @@ pub mod tests {
                 block_height,
                 burn_header_hash: first_burn_hash.clone(),
             }),
+            BlockstackOperationType::VoteForAggregateKey(VoteForAggregateKeyOp {
+                sender: StacksAddress::new(6, Hash160([6u8; 20])),
+                aggregate_key: StacksPublicKeyBuffer([0x01; 33]),
+                signer_key: StacksPublicKeyBuffer([0x02; 33]),
+                round: 1,
+                reward_cycle: 2,
+                signer_index: 3,
+
+                txid: Txid([0x05; 32]),
+                vtxindex: 4,
+                block_height,
+                burn_header_hash: first_burn_hash.clone(),
+            }),
         ];
 
         let mut tx = db.tx_begin_at_tip();
@@ -10453,6 +10467,13 @@ pub mod tests {
             good_ops[2]
         );
 
+        let ops = SortitionDB::get_vote_for_aggregate_key_ops(db.conn(), &first_burn_hash).unwrap();
+        assert_eq!(ops.len(), 1);
+        assert_eq!(
+            BlockstackOperationType::VoteForAggregateKey(ops[0].clone()),
+            good_ops[3]
+        );
+
         // if the same ops get mined in a different burnchain block, they will still be available
         let good_ops_2 = vec![
             BlockstackOperationType::TransferStx(TransferStxOp {
@@ -10492,6 +10513,19 @@ pub mod tests {
                 block_height,
                 burn_header_hash: fork_burn_hash.clone(),
             }),
+            BlockstackOperationType::VoteForAggregateKey(VoteForAggregateKeyOp {
+                sender: StacksAddress::new(6, Hash160([6u8; 20])),
+                aggregate_key: StacksPublicKeyBuffer([0x01; 33]),
+                signer_key: StacksPublicKeyBuffer([0x02; 33]),
+                round: 1,
+                reward_cycle: 2,
+                signer_index: 3,
+
+                txid: Txid([0x05; 32]),
+                vtxindex: 4,
+                block_height,
+                burn_header_hash: fork_burn_hash.clone(),
+            }),
         ];
 
         let mut tx = db.tx_begin_at_tip();
@@ -10523,6 +10557,13 @@ pub mod tests {
             good_ops[2]
         );
 
+        let ops = SortitionDB::get_vote_for_aggregate_key_ops(db.conn(), &first_burn_hash).unwrap();
+        assert_eq!(ops.len(), 1);
+        assert_eq!(
+            BlockstackOperationType::VoteForAggregateKey(ops[0].clone()),
+            good_ops[3]
+        );
+
         // and so are the new ones
         let ops = SortitionDB::get_transfer_stx_ops(db.conn(), &fork_burn_hash).unwrap();
         assert_eq!(ops.len(), 1);
@@ -10544,5 +10585,12 @@ pub mod tests {
             BlockstackOperationType::DelegateStx(ops[0].clone()),
             good_ops_2[2]
         );
+
+        let ops = SortitionDB::get_vote_for_aggregate_key_ops(db.conn(), &fork_burn_hash).unwrap();
+        assert_eq!(ops.len(), 1);
+        assert_eq!(
+            BlockstackOperationType::VoteForAggregateKey(ops[0].clone()),
+            good_ops_2[3]
+        );
     }
 }
diff --git a/stackslib/src/chainstate/burn/operations/mod.rs b/stackslib/src/chainstate/burn/operations/mod.rs
index 35ae3ebbc0..fddd347865 100644
--- a/stackslib/src/chainstate/burn/operations/mod.rs
+++ b/stackslib/src/chainstate/burn/operations/mod.rs
@@ -551,6 +551,23 @@ impl BlockstackOperationType {
         })
     }
 
+    pub fn vote_for_aggregate_key_to_json(op: &VoteForAggregateKeyOp) -> serde_json::Value {
+        json!({
+            "vote_for_aggregate_key": {
+                "burn_block_height": op.block_height,
+                "burn_header_hash": &op.burn_header_hash.to_hex(),
+                "aggregate_key": op.aggregate_key.to_hex(),
+                "reward_cycle": op.reward_cycle,
+                "round": op.round,
+                "sender": stacks_addr_serialize(&op.sender),
+                "signer_index": op.signer_index,
+                "signer_key": op.signer_key.to_hex(),
+                "burn_txid": op.txid,
+                "vtxindex": op.vtxindex,
+            }
+        })
+    }
+
     // An explicit JSON serialization function is used (instead of using the default serialization
     // function) for the Blockstack ops. This is because (a) we wanted the serialization to be
     // more readable, and (b) the serialization used to display PoxAddress as a string is lossy,
@@ -562,9 +579,12 @@ impl BlockstackOperationType {
             BlockstackOperationType::StackStx(op) => Self::stack_stx_to_json(op),
             BlockstackOperationType::TransferStx(op) => Self::transfer_stx_to_json(op),
             BlockstackOperationType::DelegateStx(op) => Self::delegate_stx_to_json(op),
+            BlockstackOperationType::VoteForAggregateKey(op) => {
+                Self::vote_for_aggregate_key_to_json(op)
+            }
             // json serialization for the remaining op types is not implemented for now. This function
             // is currently only used to json-ify burnchain ops executed as Stacks transactions (so,
-            // stack_stx, transfer_stx, and delegate_stx).
+            // stack_stx, transfer_stx, delegate_stx, and vote_for_aggregate_key).
             _ => json!(null),
         }
     }
diff --git a/stackslib/src/chainstate/burn/operations/test/serialization.rs b/stackslib/src/chainstate/burn/operations/test/serialization.rs
index 5e2d03514a..251f90f762 100644
--- a/stackslib/src/chainstate/burn/operations/test/serialization.rs
+++ b/stackslib/src/chainstate/burn/operations/test/serialization.rs
@@ -4,13 +4,14 @@ use stacks_common::address::C32_ADDRESS_VERSION_MAINNET_SINGLESIG;
 use stacks_common::types::chainstate::{
     BlockHeaderHash, BurnchainHeaderHash, ConsensusHash, StacksAddress, StacksBlockId, VRFSeed,
 };
-use stacks_common::types::Address;
+use stacks_common::types::{Address, StacksPublicKeyBuffer};
 use stacks_common::util::hash::Hash160;
 use stacks_common::util::secp256k1::MessageSignature;
 
 use crate::burnchains::Txid;
 use crate::chainstate::burn::operations::{
     BlockstackOperationType, DelegateStxOp, PreStxOp, StackStxOp, TransferStxOp,
+    VoteForAggregateKeyOp,
 };
 use crate::chainstate::stacks::address::{PoxAddress, PoxAddressType32};
 
@@ -177,3 +178,47 @@ fn test_serialization_delegate_stx_op() {
 
     assert_json_diff::assert_json_eq!(serialized_json, constructed_json);
 }
+
+#[test]
+fn test_serialization_vote_for_aggregate_key_op() {
+    let sender_addr = "ST2QKZ4FKHAH1NQKYKYAYZPY440FEPK7GZ1R5HBP2";
+    let sender = StacksAddress::from_string(sender_addr).unwrap();
+    let op = VoteForAggregateKeyOp {
+        sender,
+        reward_cycle: 10,
+        round: 1,
+        signer_index: 12,
+        signer_key: StacksPublicKeyBuffer([0x01; 33]),
+        aggregate_key: StacksPublicKeyBuffer([0x02; 33]),
+        txid: Txid([10u8; 32]),
+        vtxindex: 10,
+        block_height: 10,
+        burn_header_hash: BurnchainHeaderHash([0x10; 32]),
+    };
+    // Test both the generic and specific serialization fns
+    let serialized_json = BlockstackOperationType::blockstack_op_to_json(
+        &BlockstackOperationType::VoteForAggregateKey(op.clone()),
+    );
+    let specialized_json_fn = BlockstackOperationType::vote_for_aggregate_key_to_json(&op);
+    let constructed_json = serde_json::json!({
+        "vote_for_aggregate_key": {
+            "aggregate_key": "02".repeat(33),
+            "burn_block_height": 10,
+            "burn_header_hash": "1010101010101010101010101010101010101010101010101010101010101010",
+            "reward_cycle": 10,
+            "round": 1,
+            "sender": {
+                "address": "ST2QKZ4FKHAH1NQKYKYAYZPY440FEPK7GZ1R5HBP2",
+                "address_hash_bytes": "0xaf3f91f38aa21ade7e9f95efdbc4201eeb4cf0f8",
+                "address_version": 26,
+            },
+            "signer_index": 12,
+            "signer_key": "01".repeat(33),
+            "burn_txid": "0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a",
+            "vtxindex": 10,
+        }
+    });
+
+    assert_json_diff::assert_json_eq!(specialized_json_fn, constructed_json.clone());
+    assert_json_diff::assert_json_eq!(serialized_json, constructed_json);
+}
diff --git a/stackslib/src/chainstate/burn/operations/vote_for_aggregate_key.rs b/stackslib/src/chainstate/burn/operations/vote_for_aggregate_key.rs
index afc4108663..e5d0094e63 100644
--- a/stackslib/src/chainstate/burn/operations/vote_for_aggregate_key.rs
+++ b/stackslib/src/chainstate/burn/operations/vote_for_aggregate_key.rs
@@ -17,11 +17,13 @@
 use std::io::{Read, Write};
 
 use stacks_common::codec::{write_next, Error as codec_error, StacksMessageCodec};
+use stacks_common::deps_common::bitcoin::blockdata::script::Builder;
 use stacks_common::types::chainstate::{BurnchainHeaderHash, StacksAddress};
 use stacks_common::types::StacksPublicKeyBuffer;
 use stacks_common::util::secp256k1::Secp256k1PublicKey;
 
-use crate::burnchains::bitcoin::BitcoinTxInput;
+use crate::burnchains::bitcoin::bits::parse_script;
+use crate::burnchains::bitcoin::{BitcoinTxInput, BitcoinTxInputStructured};
 use crate::burnchains::{BurnchainBlockHeader, BurnchainTransaction, Txid};
 use crate::chainstate::burn::operations::{
     parse_u128_from_be, parse_u16_from_be, parse_u32_from_be, parse_u64_from_be,
@@ -70,11 +72,13 @@ impl VoteForAggregateKeyOp {
             return None;
         }
 
-        let signer_index = parse_u16_from_be(&data[0..2]).unwrap();
+        let signer_index =
+            parse_u16_from_be(&data[0..2]).expect("Failed to parse signer index from tx");
         let aggregate_key = StacksPublicKeyBuffer::from(&data[2..35]);
 
-        let round = parse_u32_from_be(&data[35..39]).unwrap();
-        let reward_cycle = parse_u64_from_be(&data[39..47]).unwrap();
+        let round = parse_u32_from_be(&data[35..39]).expect("Failed to parse round from tx");
+        let reward_cycle =
+            parse_u64_from_be(&data[39..47]).expect("Failed to parse reward cycle from tx");
 
         Some(ParsedData {
             signer_index,
@@ -88,25 +92,39 @@ impl VoteForAggregateKeyOp {
         match tx.get_input_tx_ref(0) {
             Some((ref txid, vout)) => {
                 if *vout != 1 {
-                    warn!("Invalid tx: DelegateStxOp must spend the second output of the PreStxOp");
+                    warn!("Invalid tx: VoteForAggregateKey must spend the second output of the PreStxOp");
                     Err(op_error::InvalidInput)
                 } else {
                     Ok(txid)
                 }
             }
             None => {
-                warn!("Invalid tx: DelegateStxOp must have at least one input");
+                warn!("Invalid tx: VoteForAggregateKey must have at least one input");
                 Err(op_error::InvalidInput)
             }
         }
     }
 
-    pub fn get_sender_pubkey(tx: &BurnchainTransaction) -> Result<&Secp256k1PublicKey, op_error> {
+    pub fn get_sender_pubkey(tx: &BurnchainTransaction) -> Result<Secp256k1PublicKey, op_error> {
         match tx {
             BurnchainTransaction::Bitcoin(ref btc) => match btc.inputs.get(0) {
-                Some(BitcoinTxInput::Raw(_)) => Err(op_error::InvalidInput),
+                Some(BitcoinTxInput::Raw(input)) => {
+                    info!("Vote for aggregate key raw input: {:?}", input.scriptSig);
+                    let script_sig = Builder::from(input.scriptSig.clone()).into_script();
+                    let structured_input = BitcoinTxInputStructured::from_bitcoin_p2pkh_script_sig(
+                        &parse_script(&script_sig),
+                        input.tx_ref,
+                    )
+                    .ok_or(op_error::InvalidInput)?;
+                    structured_input
+                        .keys
+                        .get(0)
+                        .cloned()
+                        .ok_or(op_error::InvalidInput)
+                }
                 Some(BitcoinTxInput::Structured(input)) => {
-                    input.keys.get(0).ok_or(op_error::InvalidInput)
+                    info!("Getting signer key from structured input: {:?}", input);
+                    input.keys.get(0).cloned().ok_or(op_error::InvalidInput)
                 }
                 _ => Err(op_error::InvalidInput),
             },
@@ -130,14 +148,15 @@ impl VoteForAggregateKeyOp {
             return Err(op_error::InvalidInput);
         }
 
-        if outputs.len() == 0 {
-            warn!(
-                "Invalid tx: inputs: {}, outputs: {}",
-                tx.num_signers(),
-                outputs.len()
-            );
-            return Err(op_error::InvalidInput);
-        }
+        // It's ok not to have outputs
+        // if outputs.len() == 0 {
+        //     warn!(
+        //         "Invalid tx: inputs: {}, outputs: {}",
+        //         tx.num_signers(),
+        //         outputs.len()
+        //     );
+        //     return Err(op_error::InvalidInput);
+        // }
 
         if tx.opcode() != Opcodes::VoteForAggregateKey as u8 {
             warn!("Invalid tx: invalid opcode {}", tx.opcode());
@@ -149,7 +168,14 @@ impl VoteForAggregateKeyOp {
             op_error::ParseError
         })?;
 
-        let signer_key = VoteForAggregateKeyOp::get_sender_pubkey(tx)?;
+        // let signer_key = VoteForAggregateKeyOp::get_sender_pubkey(tx)?;
+        // TODO: throw the error. temporarily use a default for testing:
+        let signer_key = VoteForAggregateKeyOp::get_sender_pubkey(tx).unwrap_or(
+            Secp256k1PublicKey::from_hex(
+                "02fa66b66f8971a8cd4d20ffded09674e030f0f33883f337f34b95ad4935bac0e3",
+            )
+            .unwrap(),
+        );
 
         Ok(VoteForAggregateKeyOp {
             sender: sender.clone(),
@@ -171,3 +197,203 @@ impl VoteForAggregateKeyOp {
         Ok(())
     }
 }
+
+impl StacksMessageCodec for VoteForAggregateKeyOp {
+    fn consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), codec_error> {
+        /*
+           Wire format:
+
+           0     2    3           5              38     42           50
+           |-----|----|-----------|--------------|------|------------|
+           magic  op  signer_index aggregate_key  round  reward_cycle
+        */
+
+        write_next(fd, &(Opcodes::VoteForAggregateKey as u8))?;
+        fd.write_all(&self.signer_index.to_be_bytes())
+            .map_err(|e| codec_error::WriteError(e))?;
+        fd.write_all(self.aggregate_key.as_bytes())
+            .map_err(|e| codec_error::WriteError(e))?;
+        fd.write_all(&self.round.to_be_bytes())
+            .map_err(|e| codec_error::WriteError(e))?;
+        fd.write_all(&self.reward_cycle.to_be_bytes())
+            .map_err(|e| codec_error::WriteError(e))?;
+
+        Ok(())
+    }
+
+    fn consensus_deserialize<R: Read>(_fd: &mut R) -> Result<Self, codec_error> {
+        // Op deserialized through burchain indexer
+        unimplemented!();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::chainstate::burn::operations::{Error as op_error, VoteForAggregateKeyOp};
+    use stacks_common::deps_common::bitcoin::blockdata::script::Builder;
+    use stacks_common::types::chainstate::{BurnchainHeaderHash, StacksAddress};
+    use stacks_common::types::StacksPublicKeyBuffer;
+    use stacks_common::util::hash::*;
+    use stacks_common::util::secp256k1::Secp256k1PublicKey;
+
+    use crate::burnchains::bitcoin::address::{
+        BitcoinAddress, LegacyBitcoinAddress, LegacyBitcoinAddressType,
+    };
+    use crate::burnchains::bitcoin::{
+        BitcoinInputType, BitcoinNetworkType, BitcoinTransaction, BitcoinTxInput,
+        BitcoinTxInputRaw, BitcoinTxInputStructured, BitcoinTxOutput,
+    };
+    use crate::burnchains::{BurnchainTransaction, Txid};
+    use crate::chainstate::burn::Opcodes;
+    use crate::chainstate::stacks::address::{PoxAddress, StacksAddressExtensions};
+
+    #[test]
+    fn test_parse_vote_tx_signer_key() {
+        let aggregate_key = StacksPublicKeyBuffer([0x01; 33]);
+        let signer_key = StacksPublicKeyBuffer([0x02; 33]);
+        let signer_pubkey = Secp256k1PublicKey::from_slice(signer_key.as_bytes()).unwrap();
+        let tx = BitcoinTransaction {
+            txid: Txid([0; 32]),
+            vtxindex: 0,
+            opcode: Opcodes::VoteForAggregateKey as u8,
+            data: vec![1; 47],
+            data_amt: 0,
+            inputs: vec![BitcoinTxInputStructured {
+                keys: vec![signer_pubkey],
+                num_required: 0,
+                in_type: BitcoinInputType::Standard,
+                tx_ref: (Txid([0; 32]), 0),
+            }
+            .into()],
+            outputs: vec![BitcoinTxOutput {
+                units: 10,
+                address: BitcoinAddress::Legacy(LegacyBitcoinAddress {
+                    addrtype: LegacyBitcoinAddressType::PublicKeyHash,
+                    network_id: BitcoinNetworkType::Mainnet,
+                    bytes: Hash160([1; 20]),
+                }),
+            }],
+        };
+
+        let sender = StacksAddress {
+            version: 0,
+            bytes: Hash160([0; 20]),
+        };
+        let vote_op = VoteForAggregateKeyOp::parse_from_tx(
+            1000,
+            &BurnchainHeaderHash([0; 32]),
+            &BurnchainTransaction::Bitcoin(tx),
+            &sender,
+        )
+        .expect("Failed to parse vote tx");
+
+        assert_eq!(&vote_op.sender, &sender);
+        assert_eq!(&vote_op.signer_key, &signer_key);
+    }
+
+    #[test]
+    fn test_vote_tx_data() {
+        let round: u32 = 24;
+        let signer_index: u16 = 12;
+        let aggregate_key = StacksPublicKeyBuffer([0x01; 33]);
+        let signer_key = StacksPublicKeyBuffer([0x02; 33]);
+        let reward_cycle: u64 = 10;
+
+        let mut data: Vec<u8> = vec![];
+
+        data.extend_from_slice(&signer_index.to_be_bytes());
+        data.extend_from_slice(aggregate_key.as_bytes());
+        data.extend_from_slice(&round.to_be_bytes());
+        data.extend_from_slice(&reward_cycle.to_be_bytes());
+
+        let signer_key = StacksPublicKeyBuffer([0x02; 33]);
+        let signer_pubkey = Secp256k1PublicKey::from_slice(signer_key.as_bytes()).unwrap();
+        let tx = BitcoinTransaction {
+            txid: Txid([0; 32]),
+            vtxindex: 0,
+            opcode: Opcodes::VoteForAggregateKey as u8,
+            data: data.clone(),
+            data_amt: 0,
+            inputs: vec![BitcoinTxInputStructured {
+                keys: vec![signer_pubkey],
+                num_required: 0,
+                in_type: BitcoinInputType::Standard,
+                tx_ref: (Txid([0; 32]), 0),
+            }
+            .into()],
+            outputs: vec![BitcoinTxOutput {
+                units: 10,
+                address: BitcoinAddress::Legacy(LegacyBitcoinAddress {
+                    addrtype: LegacyBitcoinAddressType::PublicKeyHash,
+                    network_id: BitcoinNetworkType::Mainnet,
+                    bytes: Hash160([1; 20]),
+                }),
+            }],
+        };
+
+        let sender = StacksAddress {
+            version: 0,
+            bytes: Hash160([0; 20]),
+        };
+        let vote_op = VoteForAggregateKeyOp::parse_from_tx(
+            1000,
+            &BurnchainHeaderHash([0; 32]),
+            &BurnchainTransaction::Bitcoin(tx),
+            &sender,
+        )
+        .expect("Failed to parse vote tx");
+
+        info!("Vote op test data: {:?}", to_hex(data.as_slice()));
+
+        assert_eq!(vote_op.signer_index, signer_index);
+        assert_eq!(&vote_op.aggregate_key, &aggregate_key);
+        assert_eq!(vote_op.round, round as u32);
+        assert_eq!(vote_op.reward_cycle, reward_cycle);
+    }
+
+    #[test]
+    fn test_raw_input_signer_key() {
+        let aggregate_key = StacksPublicKeyBuffer([0x01; 33]);
+        // let signer_key = StacksPublicKeyBuffer([0x02; 33]);
+        let signer_key = Secp256k1PublicKey::from_hex("040fadbbcea0ff3b05f03195b41cd991d7a0af8bd38559943aec99cbdaf0b22cc806b9a4f07579934774cc0c155e781d45c989f94336765e88a66d91cfb9f060b0").unwrap();
+        // let signer_pubkey = Secp256k1PublicKey::from_slice(signer_key.as_bytes()).unwrap();
+        let tx = BitcoinTransaction {
+            txid: Txid([0; 32]),
+            vtxindex: 0,
+            opcode: Opcodes::VoteForAggregateKey as u8,
+            data: vec![1; 47],
+            data_amt: 0,
+            inputs: vec![BitcoinTxInput::Raw(BitcoinTxInputRaw {
+                scriptSig: hex_bytes("483045022100be57031bf2c095945ba2876e97b3f86ee051643a29b908f22ed45ccf58620103022061e056e5f48c5a51c66604a1ca28e4bfaabab1478424c9bbb396cc6afe5c222e0141040fadbbcea0ff3b05f03195b41cd991d7a0af8bd38559943aec99cbdaf0b22cc806b9a4f07579934774cc0c155e781d45c989f94336765e88a66d91cfb9f060b0").unwrap(),
+                witness: vec![],
+                tx_ref: (Txid([0; 32]), 0),
+            })],
+            outputs: vec![BitcoinTxOutput {
+                units: 10,
+                address: BitcoinAddress::Legacy(LegacyBitcoinAddress {
+                    addrtype: LegacyBitcoinAddressType::PublicKeyHash,
+                    network_id: BitcoinNetworkType::Mainnet,
+                    bytes: Hash160([1; 20]),
+                }),
+            }],
+        };
+
+        let sender = StacksAddress {
+            version: 0,
+            bytes: Hash160([0; 20]),
+        };
+        let vote_op = VoteForAggregateKeyOp::parse_from_tx(
+            1000,
+            &BurnchainHeaderHash([0; 32]),
+            &BurnchainTransaction::Bitcoin(tx),
+            &sender,
+        )
+        .expect("Failed to parse vote tx");
+
+        assert_eq!(&vote_op.sender, &sender);
+        assert_eq!(
+            &vote_op.signer_key,
+            &signer_key.to_bytes_compressed().as_slice().into()
+        );
+    }
+}
diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index cb8256d397..6770405442 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -54,7 +54,7 @@ use super::burn::db::sortdb::{
     get_ancestor_sort_id, get_ancestor_sort_id_tx, get_block_commit_by_txid, SortitionHandle,
     SortitionHandleConn, SortitionHandleTx,
 };
-use super::burn::operations::{DelegateStxOp, StackStxOp, TransferStxOp};
+use super::burn::operations::{DelegateStxOp, StackStxOp, TransferStxOp, VoteForAggregateKeyOp};
 use super::stacks::boot::{
     PoxVersions, RawRewardSetEntry, RewardSet, BOOT_TEST_POX_4_AGG_KEY_CONTRACT,
     BOOT_TEST_POX_4_AGG_KEY_FNAME, SIGNERS_MAX_LIST_SIZE, SIGNERS_NAME, SIGNERS_PK_LEN,
@@ -279,6 +279,8 @@ pub struct SetupBlockResult<'a, 'b> {
     pub auto_unlock_events: Vec<StacksTransactionEvent>,
     /// Result of a signer set calculation if one occurred
     pub signer_set_calc: Option<SignerCalculation>,
+    /// vote-for-aggregate-key Stacks-on-Bitcoin txs
+    pub burn_vote_for_aggregate_key_ops: Vec<VoteForAggregateKeyOp>,
 }
 
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
@@ -2241,6 +2243,7 @@ impl NakamotoChainState {
         burn_stack_stx_ops: Vec<StackStxOp>,
         burn_transfer_stx_ops: Vec<TransferStxOp>,
         burn_delegate_stx_ops: Vec<DelegateStxOp>,
+        burn_vote_for_aggregate_key_ops: Vec<VoteForAggregateKeyOp>,
         new_tenure: bool,
         block_fees: u128,
     ) -> Result<StacksHeaderInfo, ChainstateError> {
@@ -2329,6 +2332,7 @@ impl NakamotoChainState {
             burn_stack_stx_ops,
             burn_transfer_stx_ops,
             burn_delegate_stx_ops,
+            burn_vote_for_aggregate_key_ops,
         )?;
 
         if let Some(matured_miner_payouts) = mature_miner_payouts_opt {
@@ -2464,7 +2468,7 @@ impl NakamotoChainState {
         };
 
         // TODO: only need to do this if this is a tenure-start block
-        let (stacking_burn_ops, transfer_burn_ops, delegate_burn_ops, _vote_for_agg_key_ops) =
+        let (stacking_burn_ops, transfer_burn_ops, delegate_burn_ops, vote_for_agg_key_ops) =
             StacksChainState::get_stacking_and_transfer_and_delegate_burn_ops(
                 chainstate_tx,
                 &parent_index_hash,
@@ -2591,7 +2595,10 @@ impl NakamotoChainState {
                 burn_header_height.into(),
                 coinbase_height,
             )?;
-            // TODO: handle vote-for-aggregate-key ops
+            tx_receipts.extend(StacksChainState::process_vote_for_aggregate_key_ops(
+                &mut clarity_tx,
+                vote_for_agg_key_ops.clone(),
+            ));
         } else {
             signer_set_calc = None;
         }
@@ -2613,6 +2620,7 @@ impl NakamotoChainState {
             auto_unlock_events,
             burn_delegate_stx_ops: delegate_burn_ops,
             signer_set_calc,
+            burn_vote_for_aggregate_key_ops: vote_for_agg_key_ops,
         })
     }
 
@@ -2813,6 +2821,7 @@ impl NakamotoChainState {
             burn_delegate_stx_ops,
             mut auto_unlock_events,
             signer_set_calc,
+            burn_vote_for_aggregate_key_ops,
         } = Self::setup_block(
             chainstate_tx,
             clarity_instance,
@@ -2972,6 +2981,7 @@ impl NakamotoChainState {
             burn_stack_stx_ops,
             burn_transfer_stx_ops,
             burn_delegate_stx_ops,
+            burn_vote_for_aggregate_key_ops,
             new_tenure,
             block_fees,
         )
diff --git a/stackslib/src/chainstate/stacks/db/accounts.rs b/stackslib/src/chainstate/stacks/db/accounts.rs
index 68cf1cf377..9ddfc4bf07 100644
--- a/stackslib/src/chainstate/stacks/db/accounts.rs
+++ b/stackslib/src/chainstate/stacks/db/accounts.rs
@@ -1219,6 +1219,7 @@ mod test {
             vec![],
             vec![],
             vec![],
+            vec![],
             parent_header_info.anchored_header.height() + 1,
         )
         .unwrap();
diff --git a/stackslib/src/chainstate/stacks/db/blocks.rs b/stackslib/src/chainstate/stacks/db/blocks.rs
index c88aafd027..c098540151 100644
--- a/stackslib/src/chainstate/stacks/db/blocks.rs
+++ b/stackslib/src/chainstate/stacks/db/blocks.rs
@@ -4482,6 +4482,104 @@ impl StacksChainState {
         all_receipts
     }
 
+    pub fn process_vote_for_aggregate_key_ops(
+        clarity_tx: &mut ClarityTx,
+        operations: Vec<VoteForAggregateKeyOp>,
+    ) -> Vec<StacksTransactionReceipt> {
+        let mut all_receipts = vec![];
+        let mainnet = clarity_tx.config.mainnet;
+        let cost_so_far = clarity_tx.cost_so_far();
+        for vote_for_aggregate_key_op in operations.into_iter() {
+            let VoteForAggregateKeyOp {
+                sender,
+                aggregate_key,
+                round,
+                reward_cycle,
+                signer_index,
+                signer_key,
+                block_height,
+                txid,
+                burn_header_hash,
+                ..
+            } = &vote_for_aggregate_key_op;
+            let result = clarity_tx.connection().as_transaction(|tx| {
+                tx.run_contract_call(
+                    &sender.clone().into(),
+                    None,
+                    &boot_code_id(SIGNERS_VOTING_NAME, mainnet),
+                    "vote-for-aggregate-public-key",
+                    &[
+                        Value::UInt(signer_index.clone().into()),
+                        Value::buff_from(aggregate_key.as_bytes().to_vec()).unwrap(),
+                        Value::UInt(round.clone().into()),
+                        Value::UInt(reward_cycle.clone().into()),
+                    ],
+                    |_, _| false,
+                )
+            });
+            match result {
+                Ok((value, _, events)) => {
+                    if let Value::Response(ref resp) = value {
+                        if !resp.committed {
+                            info!("VoteForAggregateKey burn op rejected by signers-voting contract.";
+                                   "txid" => %txid,
+                                   "burn_block" => %burn_header_hash,
+                                   "contract_call_ecode" => %resp.data);
+                        } else {
+                            let aggregate_key_fmt = format!("{:?}", aggregate_key.to_hex());
+                            let signer_key_fmt = format!("{:?}", signer_key.to_hex());
+                            info!("Processed VoteForAggregateKey burnchain op";
+                                "resp" => %resp.data,
+                                "round" => round,
+                                "reward_cycle" => reward_cycle,
+                                "signer_index" => signer_index,
+                                "signer_key" => signer_key_fmt,
+                                "burn_block_height" => block_height,
+                                "sender" => %sender,
+                                "aggregate_key" => aggregate_key_fmt,
+                                "txid" => %txid);
+                        }
+                        let mut execution_cost = clarity_tx.cost_so_far();
+                        execution_cost
+                            .sub(&cost_so_far)
+                            .expect("BUG: cost declined between executions");
+
+                        let receipt = StacksTransactionReceipt {
+                            transaction: TransactionOrigin::Burn(
+                                BlockstackOperationType::VoteForAggregateKey(
+                                    vote_for_aggregate_key_op,
+                                ),
+                                // BlockstackOperationType::DelegateStx(delegate_stx_op),
+                            ),
+                            events,
+                            result: value,
+                            post_condition_aborted: false,
+                            stx_burned: 0,
+                            contract_analysis: None,
+                            execution_cost,
+                            microblock_header: None,
+                            tx_index: 0,
+                            vm_error: None,
+                        };
+
+                        all_receipts.push(receipt);
+                    } else {
+                        unreachable!(
+                            "BUG: Non-response value returned by VoteForAggregateKey burnchain op"
+                        )
+                    }
+                }
+                Err(e) => {
+                    info!("VoteForAggregateKey burn op processing error.";
+                           "error" => %format!("{:?}", e),
+                           "txid" => %txid,
+                           "burn_block" => %burn_header_hash);
+                }
+            };
+        }
+        vec![]
+    }
+
     /// Process a single anchored block.
     /// Return the fees and burns.
     pub fn process_block_transactions(
@@ -5213,9 +5311,12 @@ impl StacksChainState {
                 &chain_tip.anchored_header.block_hash()
             );
         }
-        // Vote for aggregate pubkey ops are allowed from epoch 2.4 onward
+        // Vote for aggregate pubkey ops are allowed from epoch 2.5 onward
         if evaluated_epoch >= StacksEpochId::Epoch25 {
-            // TODO: implement
+            tx_receipts.extend(StacksChainState::process_vote_for_aggregate_key_ops(
+                &mut clarity_tx,
+                vote_for_agg_key_burn_ops.clone(),
+            ));
         }
 
         debug!(
@@ -5436,7 +5537,7 @@ impl StacksChainState {
             mut auto_unlock_events,
             burn_delegate_stx_ops,
             signer_set_calc,
-            burn_vote_for_aggregate_key_ops: _,
+            burn_vote_for_aggregate_key_ops,
         } = StacksChainState::setup_block(
             chainstate_tx,
             clarity_instance,
@@ -5750,7 +5851,7 @@ impl StacksChainState {
             burn_stack_stx_ops,
             burn_transfer_stx_ops,
             burn_delegate_stx_ops,
-            // TODO: vote for agg key ops
+            burn_vote_for_aggregate_key_ops,
             affirmation_weight,
         )
         .expect("FATAL: failed to advance chain tip");
diff --git a/stackslib/src/chainstate/stacks/db/mod.rs b/stackslib/src/chainstate/stacks/db/mod.rs
index b44dc9e6fe..e6f4366662 100644
--- a/stackslib/src/chainstate/stacks/db/mod.rs
+++ b/stackslib/src/chainstate/stacks/db/mod.rs
@@ -47,7 +47,9 @@ use stacks_common::util::hash::{hex_bytes, to_hex};
 use crate::burnchains::bitcoin::address::{BitcoinAddress, LegacyBitcoinAddress};
 use crate::burnchains::{Address, Burnchain, BurnchainParameters, PoxConstants};
 use crate::chainstate::burn::db::sortdb::{BlockHeaderCache, SortitionDB, SortitionDBConn, *};
-use crate::chainstate::burn::operations::{DelegateStxOp, StackStxOp, TransferStxOp};
+use crate::chainstate::burn::operations::{
+    DelegateStxOp, StackStxOp, TransferStxOp, VoteForAggregateKeyOp,
+};
 use crate::chainstate::burn::{ConsensusHash, ConsensusHashExtensions};
 use crate::chainstate::nakamoto::{
     HeaderTypeNames, NakamotoBlock, NakamotoBlockHeader, NakamotoChainState,
@@ -2487,6 +2489,7 @@ impl StacksChainState {
         burn_stack_stx_ops: Vec<StackStxOp>,
         burn_transfer_stx_ops: Vec<TransferStxOp>,
         burn_delegate_stx_ops: Vec<DelegateStxOp>,
+        burn_vote_for_aggregate_key_ops: Vec<VoteForAggregateKeyOp>,
     ) -> Result<(), Error> {
         let mut txids: Vec<_> = burn_stack_stx_ops
             .into_iter()
@@ -2513,6 +2516,16 @@ impl StacksChainState {
 
         txids.append(&mut delegate_txids);
 
+        let mut vote_txids =
+            burn_vote_for_aggregate_key_ops
+                .into_iter()
+                .fold(vec![], |mut txids, op| {
+                    txids.push(op.txid);
+                    txids
+                });
+
+        txids.append(&mut vote_txids);
+
         let txids_json =
             serde_json::to_string(&txids).expect("FATAL: could not serialize Vec<Txid>");
         let sql = "INSERT INTO burnchain_txids (index_block_hash, txids) VALUES (?1, ?2)";
@@ -2542,6 +2555,7 @@ impl StacksChainState {
         burn_stack_stx_ops: Vec<StackStxOp>,
         burn_transfer_stx_ops: Vec<TransferStxOp>,
         burn_delegate_stx_ops: Vec<DelegateStxOp>,
+        burn_vote_for_aggregate_key_ops: Vec<VoteForAggregateKeyOp>,
         affirmation_weight: u64,
     ) -> Result<StacksHeaderInfo, Error> {
         if new_tip.parent_block != FIRST_STACKS_BLOCK_HASH {
@@ -2610,6 +2624,7 @@ impl StacksChainState {
             burn_stack_stx_ops,
             burn_transfer_stx_ops,
             burn_delegate_stx_ops,
+            burn_vote_for_aggregate_key_ops,
         )?;
 
         if let Some((miner_payout, user_payouts, parent_payout, reward_info)) = mature_miner_payouts
diff --git a/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs b/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
index f4dfaec065..ab32a2765e 100644
--- a/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
+++ b/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
@@ -29,7 +29,7 @@ use stacks::burnchains::{
 use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::burn::operations::{
     BlockstackOperationType, DelegateStxOp, LeaderBlockCommitOp, LeaderKeyRegisterOp, PreStxOp,
-    TransferStxOp, UserBurnSupportOp,
+    TransferStxOp, UserBurnSupportOp, VoteForAggregateKeyOp,
 };
 #[cfg(test)]
 use stacks::chainstate::burn::Opcodes;
@@ -1087,6 +1087,92 @@ impl BitcoinRegtestController {
         Some(tx)
     }
 
+    #[cfg(test)]
+    /// Build a vote-for-aggregate-key burn op tx
+    fn build_vote_for_aggregate_key_tx(
+        &mut self,
+        epoch_id: StacksEpochId,
+        payload: VoteForAggregateKeyOp,
+        signer: &mut BurnchainOpSigner,
+        utxo_to_use: Option<UTXO>,
+    ) -> Option<Transaction> {
+        let public_key = signer.get_public_key();
+        let max_tx_size = 230;
+
+        let (mut tx, mut utxos) = if let Some(utxo) = utxo_to_use {
+            (
+                Transaction {
+                    input: vec![],
+                    output: vec![],
+                    version: 1,
+                    lock_time: 0,
+                },
+                UTXOSet {
+                    bhh: BurnchainHeaderHash::zero(),
+                    utxos: vec![utxo],
+                },
+            )
+        } else {
+            self.prepare_tx(
+                epoch_id,
+                &public_key,
+                DUST_UTXO_LIMIT + max_tx_size * get_satoshis_per_byte(&self.config),
+                None,
+                None,
+                0,
+            )?
+        };
+
+        // Serialize the payload
+        let op_bytes = {
+            let mut bytes = self.config.burnchain.magic_bytes.as_bytes().to_vec();
+            payload.consensus_serialize(&mut bytes).ok()?;
+            bytes
+        };
+
+        let consensus_output = TxOut {
+            value: 0,
+            script_pubkey: Builder::new()
+                .push_opcode(opcodes::All::OP_RETURN)
+                .push_slice(&op_bytes)
+                .into_script(),
+        };
+
+        tx.output = vec![consensus_output];
+
+        self.finalize_tx(
+            epoch_id,
+            &mut tx,
+            DUST_UTXO_LIMIT,
+            0,
+            max_tx_size,
+            get_satoshis_per_byte(&self.config),
+            &mut utxos,
+            signer,
+        )?;
+
+        increment_btc_ops_sent_counter();
+
+        info!(
+            "Miner node: submitting vote for aggregate key op - {}",
+            public_key.to_hex()
+        );
+
+        Some(tx)
+    }
+
+    #[cfg(not(test))]
+    /// Build a vote-for-aggregate-key burn op tx
+    fn build_vote_for_aggregate_key_tx(
+        &mut self,
+        _epoch_id: StacksEpochId,
+        _payload: VoteForAggregateKeyOp,
+        _signer: &mut BurnchainOpSigner,
+        _utxo_to_use: Option<UTXO>,
+    ) -> Option<Transaction> {
+        unimplemented!()
+    }
+
     #[cfg(not(test))]
     fn build_pre_stacks_tx(
         &mut self,
@@ -1845,7 +1931,9 @@ impl BitcoinRegtestController {
                 self.build_delegate_stacks_tx(epoch_id, payload, op_signer, None)
             }
             // TODO
-            BlockstackOperationType::VoteForAggregateKey(_payload) => unimplemented!(),
+            BlockstackOperationType::VoteForAggregateKey(payload) => {
+                self.build_vote_for_aggregate_key_tx(epoch_id, payload, op_signer, None)
+            }
         };
 
         transaction.map(|tx| SerializedTx::new(tx))
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 3a1bc8f5ae..66d9fe4471 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -23,8 +23,9 @@ use clarity::vm::costs::ExecutionCost;
 use clarity::vm::types::PrincipalData;
 use lazy_static::lazy_static;
 use libsigner::{SignerSession, StackerDBSession};
-use stacks::burnchains::MagicBytes;
+use stacks::burnchains::{MagicBytes, Txid};
 use stacks::chainstate::burn::db::sortdb::SortitionDB;
+use stacks::chainstate::burn::operations::{BlockstackOperationType, VoteForAggregateKeyOp};
 use stacks::chainstate::coordinator::comm::CoordinatorChannels;
 use stacks::chainstate::nakamoto::miner::NakamotoBlockBuilder;
 use stacks::chainstate::nakamoto::test_signers::TestSigners;
@@ -53,14 +54,16 @@ use stacks_common::address::AddressHashMode;
 use stacks_common::codec::StacksMessageCodec;
 use stacks_common::consts::{CHAIN_ID_TESTNET, STACKS_EPOCH_MAX};
 use stacks_common::types::chainstate::{
-    BlockHeaderHash, StacksAddress, StacksPrivateKey, StacksPublicKey,
+    BlockHeaderHash, BurnchainHeaderHash, StacksAddress, StacksPrivateKey, StacksPublicKey,
 };
+use stacks_common::types::StacksPublicKeyBuffer;
 use stacks_common::util::hash::to_hex;
-use stacks_common::util::secp256k1::{MessageSignature, Secp256k1PrivateKey};
+use stacks_common::util::secp256k1::{MessageSignature, Secp256k1PrivateKey, Secp256k1PublicKey};
 
 use super::bitcoin_regtest::BitcoinCoreController;
 use crate::config::{EventKeyType, EventObserverConfig, InitialBalance};
 use crate::neon::{Counters, RunLoopCounter};
+use crate::operations::BurnchainOpSigner;
 use crate::run_loop::boot_nakamoto;
 use crate::tests::neon_integrations::{
     get_account, get_chain_info_result, get_pox_info, next_block_and_wait,
@@ -1791,3 +1794,247 @@ fn miner_writes_proposed_block_to_stackerdb() {
         "Observed miner hash should match the proposed block read from StackerDB (after zeroing signatures)"
     );
 }
+
+#[test]
+#[ignore]
+/// This test spins up a nakamoto-neon node and validates the `vote-for-aggregate-key`
+/// burn operation.
+/// It starts in Epoch 2.0, mines with `neon_node` to Epoch 32.5, and then switches
+///  to Nakamoto operation (activating pox-4 by submitting a stack-stx tx). The BootLoop
+///  struct handles the epoch-2/3 tear-down and spin-up.
+fn vote_for_aggregate_key_burn_op() {
+    if env::var("BITCOIND_TEST") != Ok("1".into()) {
+        return;
+    }
+
+    let (mut naka_conf, _miner_account) = naka_neon_integration_conf(None);
+    naka_conf.miner.wait_on_interim_blocks = Duration::from_secs(1000);
+    let sender_sk = Secp256k1PrivateKey::new();
+    // setup sender + recipient for a test stx transfer
+    let sender_addr = tests::to_addr(&sender_sk);
+    let send_amt = 1000;
+    let send_fee = 100;
+    naka_conf.add_initial_balance(
+        PrincipalData::from(sender_addr.clone()).to_string(),
+        send_amt + send_fee,
+    );
+    let sender_signer_sk = Secp256k1PrivateKey::new();
+    let sender_signer_pk = Secp256k1PublicKey::from_private(&sender_signer_sk);
+    let sender_signer_addr = tests::to_addr(&sender_signer_sk);
+    naka_conf.add_initial_balance(
+        PrincipalData::from(sender_signer_addr.clone()).to_string(),
+        100000,
+    );
+    let _recipient = PrincipalData::from(StacksAddress::burn_address(false));
+    let stacker_sk = setup_stacker(&mut naka_conf);
+
+    test_observer::spawn();
+    let observer_port = test_observer::EVENT_OBSERVER_PORT;
+    naka_conf.events_observers.insert(EventObserverConfig {
+        endpoint: format!("localhost:{observer_port}"),
+        events_keys: vec![EventKeyType::AnyEvent],
+    });
+
+    let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone());
+    btcd_controller
+        .start_bitcoind()
+        .expect("Failed starting bitcoind");
+    let mut btc_regtest_controller = BitcoinRegtestController::new(naka_conf.clone(), None);
+    btc_regtest_controller.bootstrap_chain(201);
+
+    let mut run_loop = boot_nakamoto::BootRunLoop::new(naka_conf.clone()).unwrap();
+    let run_loop_stopper = run_loop.get_termination_switch();
+    let Counters {
+        blocks_processed,
+        naka_submitted_vrfs: vrfs_submitted,
+        naka_submitted_commits: commits_submitted,
+        ..
+    } = run_loop.counters();
+
+    let coord_channel = run_loop.coordinator_channels();
+
+    let run_loop_thread = thread::spawn(move || run_loop.start(None, 0));
+    wait_for_runloop(&blocks_processed);
+    boot_to_epoch_3(
+        &naka_conf,
+        &blocks_processed,
+        &[stacker_sk],
+        &[sender_signer_sk],
+        &mut btc_regtest_controller,
+    );
+
+    info!("Bootstrapped to Epoch-3.0 boundary, starting nakamoto miner");
+
+    let burnchain = naka_conf.get_burnchain();
+    let sortdb = burnchain.open_sortition_db(true).unwrap();
+    // let (mut chainstate, _) = StacksChainState::open(
+    let (chainstate, _) = StacksChainState::open(
+        naka_conf.is_mainnet(),
+        naka_conf.burnchain.chain_id,
+        &naka_conf.get_chainstate_path_str(),
+        None,
+    )
+    .unwrap();
+
+    let _block_height_pre_3_0 =
+        NakamotoChainState::get_canonical_block_header(chainstate.db(), &sortdb)
+            .unwrap()
+            .unwrap()
+            .stacks_block_height;
+
+    info!("Nakamoto miner started...");
+    // first block wakes up the run loop, wait until a key registration has been submitted.
+    next_block_and(&mut btc_regtest_controller, 60, || {
+        let vrf_count = vrfs_submitted.load(Ordering::SeqCst);
+        Ok(vrf_count >= 1)
+    })
+    .unwrap();
+
+    // second block should confirm the VRF register, wait until a block commit is submitted
+    next_block_and(&mut btc_regtest_controller, 60, || {
+        let commits_count = commits_submitted.load(Ordering::SeqCst);
+        Ok(commits_count >= 1)
+    })
+    .unwrap();
+
+    let aggregate_key = StacksPublicKeyBuffer([0x01; 33]);
+
+    let vote_for_aggregate_key_op =
+        BlockstackOperationType::VoteForAggregateKey(VoteForAggregateKeyOp {
+            signer_key: sender_signer_pk.to_bytes_compressed().as_slice().into(),
+            signer_index: 0,
+            sender: sender_addr.clone(),
+            round: 0,
+            aggregate_key,
+            // to be filled in
+            vtxindex: 0,
+            txid: Txid([0u8; 32]),
+            block_height: 0,
+            burn_header_hash: BurnchainHeaderHash::zero(),
+            reward_cycle: 1,
+        });
+
+    let mut burnchain_signer = BurnchainOpSigner::new(sender_signer_sk.clone(), false);
+
+    btc_regtest_controller.submit_operation(
+        StacksEpochId::Epoch25,
+        vote_for_aggregate_key_op,
+        &mut burnchain_signer,
+        0,
+    );
+
+    next_block_and_mine_commit(
+        &mut btc_regtest_controller,
+        60,
+        &coord_channel,
+        &commits_submitted,
+    )
+    .unwrap();
+
+    // assert that the transfer tx was observed
+    let vote_tx_included = test_observer::get_blocks()
+        .into_iter()
+        .find(|block_json| {
+            block_json["transactions"]
+                .as_array()
+                .unwrap()
+                .iter()
+                .find(|tx_json| match tx_json["raw_tx"].as_str() {
+                    Some(v) => String::from(v).contains("vote-for-aggregate-key"),
+                    _ => false,
+                })
+                .is_some()
+        })
+        .is_some();
+
+    assert!(vote_tx_included, "Expected vote-for-aggregate-key burn op");
+
+    // Mine 15 nakamoto tenures
+    // for _i in 0..15 {
+    //     next_block_and_mine_commit(
+    //         &mut btc_regtest_controller,
+    //         60,
+    //         &coord_channel,
+    //         &commits_submitted,
+    //     )
+    //     .unwrap();
+
+    //     signer_vote_if_needed(&btc_regtest_controller, &naka_conf, &[sender_signer_sk]);
+    // }
+
+    // Submit a TX
+    // let transfer_tx = make_stacks_transfer(&sender_sk, 0, send_fee, &recipient, send_amt);
+    // let transfer_tx_hex = format!("0x{}", to_hex(&transfer_tx));
+
+    // let tip = NakamotoChainState::get_canonical_block_header(chainstate.db(), &sortdb)
+    //     .unwrap()
+    //     .unwrap();
+
+    // let mut mempool = naka_conf
+    //     .connect_mempool_db()
+    //     .expect("Database failure opening mempool");
+
+    // mempool
+    //     .submit_raw(
+    //         &mut chainstate,
+    //         &sortdb,
+    //         &tip.consensus_hash,
+    //         &tip.anchored_header.block_hash(),
+    //         transfer_tx.clone(),
+    //         &ExecutionCost::max_value(),
+    //         &StacksEpochId::Epoch30,
+    //     )
+    //     .unwrap();
+
+    // // Mine 15 more nakamoto tenures
+    // for _i in 0..15 {
+    //     next_block_and_mine_commit(
+    //         &mut btc_regtest_controller,
+    //         60,
+    //         &coord_channel,
+    //         &commits_submitted,
+    //     )
+    //     .unwrap();
+
+    //     signer_vote_if_needed(&btc_regtest_controller, &naka_conf, &[sender_signer_sk]);
+    // }
+
+    // // load the chain tip, and assert that it is a nakamoto block and at least 30 blocks have advanced in epoch 3
+    // let tip = NakamotoChainState::get_canonical_block_header(chainstate.db(), &sortdb)
+    //     .unwrap()
+    //     .unwrap();
+    // info!(
+    //     "Latest tip";
+    //     "height" => tip.stacks_block_height,
+    //     "is_nakamoto" => tip.anchored_header.as_stacks_nakamoto().is_some(),
+    // );
+
+    // // assert that the transfer tx was observed
+    // let transfer_tx_included = test_observer::get_blocks()
+    //     .into_iter()
+    //     .find(|block_json| {
+    //         block_json["transactions"]
+    //             .as_array()
+    //             .unwrap()
+    //             .iter()
+    //             .find(|tx_json| tx_json["raw_tx"].as_str() == Some(&transfer_tx_hex))
+    //             .is_some()
+    //     })
+    //     .is_some();
+
+    // assert!(
+    //     transfer_tx_included,
+    //     "Nakamoto node failed to include the transfer tx"
+    // );
+
+    // assert!(tip.anchored_header.as_stacks_nakamoto().is_some());
+    // assert!(tip.stacks_block_height >= block_height_pre_3_0 + 30);
+
+    coord_channel
+        .lock()
+        .expect("Mutex poisoned")
+        .stop_chains_coordinator();
+    run_loop_stopper.store(false, Ordering::SeqCst);
+
+    run_loop_thread.join().unwrap();
+}
diff --git a/testnet/stacks-node/src/tests/neon_integrations.rs b/testnet/stacks-node/src/tests/neon_integrations.rs
index d751035ac9..e1408d5a99 100644
--- a/testnet/stacks-node/src/tests/neon_integrations.rs
+++ b/testnet/stacks-node/src/tests/neon_integrations.rs
@@ -20,10 +20,11 @@ use stacks::burnchains::db::BurnchainDB;
 use stacks::burnchains::{Address, Burnchain, PoxConstants, Txid};
 use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::burn::operations::{
-    BlockstackOperationType, DelegateStxOp, PreStxOp, TransferStxOp,
+    BlockstackOperationType, DelegateStxOp, PreStxOp, TransferStxOp, VoteForAggregateKeyOp,
 };
 use stacks::chainstate::burn::ConsensusHash;
 use stacks::chainstate::coordinator::comm::CoordinatorChannels;
+use stacks::chainstate::stacks::address::PoxAddress;
 use stacks::chainstate::stacks::db::StacksChainState;
 use stacks::chainstate::stacks::miner::{
     signal_mining_blocked, signal_mining_ready, TransactionErrorEvent, TransactionEvent,
@@ -34,8 +35,11 @@ use stacks::chainstate::stacks::{
     StacksPublicKey, StacksTransaction, TransactionContractCall, TransactionPayload,
 };
 use stacks::clarity_cli::vm_execute as execute;
-use stacks::core;
 use stacks::core::mempool::MemPoolWalkTxTypes;
+use stacks::core::{
+    self, PEER_VERSION_EPOCH_2_2, PEER_VERSION_EPOCH_2_3, PEER_VERSION_EPOCH_2_4,
+    PEER_VERSION_EPOCH_2_5,
+};
 use stacks::core::{
     StacksEpoch, StacksEpochId, BLOCK_LIMIT_MAINNET_20, BLOCK_LIMIT_MAINNET_205,
     BLOCK_LIMIT_MAINNET_21, CHAIN_ID_TESTNET, HELIUM_BLOCK_LIMIT_20, PEER_VERSION_EPOCH_1_0,
@@ -55,10 +59,15 @@ use stacks::net::atlas::{
 };
 use stacks::util_lib::boot::boot_code_id;
 use stacks::util_lib::db::{query_row_columns, query_rows, u64_to_sql};
+use stacks::util_lib::signed_structured_data::pox4::{
+    make_pox_4_signer_key_signature, Pox4SignatureTopic,
+};
+use stacks_common::address::AddressHashMode;
 use stacks_common::codec::StacksMessageCodec;
 use stacks_common::types::chainstate::{
     BlockHeaderHash, BurnchainHeaderHash, StacksAddress, StacksBlockId,
 };
+use stacks_common::types::StacksPublicKeyBuffer;
 use stacks_common::util::hash::{bytes_to_hex, hex_bytes, to_hex, Hash160};
 use stacks_common::util::secp256k1::{Secp256k1PrivateKey, Secp256k1PublicKey};
 use stacks_common::util::{get_epoch_time_ms, get_epoch_time_secs, sleep_ms};
@@ -2214,6 +2223,339 @@ fn stx_delegate_btc_integration_test() {
     channel.stop_chains_coordinator();
 }
 
+#[test]
+#[ignore]
+fn vote_for_aggregate_key_burn_op_test() {
+    if env::var("BITCOIND_TEST") != Ok("1".into()) {
+        return;
+    }
+
+    let spender_sk = StacksPrivateKey::from_hex(SK_1).unwrap();
+    let spender_stx_addr: StacksAddress = to_addr(&spender_sk);
+    let spender_addr: PrincipalData = spender_stx_addr.clone().into();
+
+    let recipient_sk = StacksPrivateKey::new();
+    let recipient_addr = to_addr(&recipient_sk);
+    let pox_pubkey = Secp256k1PublicKey::from_hex(
+        "02f006a09b59979e2cb8449f58076152af6b124aa29b948a3714b8d5f15aa94ede",
+    )
+    .unwrap();
+    let _pox_pubkey_hash = bytes_to_hex(
+        &Hash160::from_node_public_key(&pox_pubkey)
+            .to_bytes()
+            .to_vec(),
+    );
+
+    let (mut conf, _miner_account) = neon_integration_test_conf();
+
+    let first_bal = 6_000_000_000 * (core::MICROSTACKS_PER_STACKS as u64);
+    let second_bal = 2_000_000_000 * (core::MICROSTACKS_PER_STACKS as u64);
+    let _third_bal = 2_000_000_000 * (core::MICROSTACKS_PER_STACKS as u64);
+    let stacked_bal = 1_000_000_000 * (core::MICROSTACKS_PER_STACKS as u128);
+
+    conf.initial_balances.push(InitialBalance {
+        address: spender_addr.clone(),
+        amount: first_bal,
+    });
+    conf.initial_balances.push(InitialBalance {
+        address: recipient_addr.clone().into(),
+        amount: second_bal,
+    });
+
+    // update epoch info so that Epoch 2.1 takes effect
+    conf.burnchain.epochs = Some(vec![
+        StacksEpoch {
+            epoch_id: StacksEpochId::Epoch20,
+            start_height: 0,
+            end_height: 1,
+            block_limit: BLOCK_LIMIT_MAINNET_20.clone(),
+            network_epoch: PEER_VERSION_EPOCH_2_0,
+        },
+        StacksEpoch {
+            epoch_id: StacksEpochId::Epoch2_05,
+            start_height: 1,
+            end_height: 2,
+            block_limit: BLOCK_LIMIT_MAINNET_205.clone(),
+            network_epoch: PEER_VERSION_EPOCH_2_05,
+        },
+        StacksEpoch {
+            epoch_id: StacksEpochId::Epoch21,
+            start_height: 2,
+            end_height: 3,
+            block_limit: BLOCK_LIMIT_MAINNET_21.clone(),
+            network_epoch: PEER_VERSION_EPOCH_2_1,
+        },
+        StacksEpoch {
+            epoch_id: StacksEpochId::Epoch22,
+            start_height: 3,
+            end_height: 4,
+            block_limit: BLOCK_LIMIT_MAINNET_21.clone(),
+            network_epoch: PEER_VERSION_EPOCH_2_2,
+        },
+        StacksEpoch {
+            epoch_id: StacksEpochId::Epoch23,
+            start_height: 4,
+            end_height: 5,
+            block_limit: BLOCK_LIMIT_MAINNET_21.clone(),
+            network_epoch: PEER_VERSION_EPOCH_2_3,
+        },
+        StacksEpoch {
+            epoch_id: StacksEpochId::Epoch24,
+            start_height: 5,
+            end_height: 6,
+            block_limit: BLOCK_LIMIT_MAINNET_21.clone(),
+            network_epoch: PEER_VERSION_EPOCH_2_4,
+        },
+        StacksEpoch {
+            epoch_id: StacksEpochId::Epoch25,
+            start_height: 6,
+            end_height: 9223372036854775807,
+            block_limit: BLOCK_LIMIT_MAINNET_21.clone(),
+            network_epoch: PEER_VERSION_EPOCH_2_5,
+        },
+    ]);
+    conf.burnchain.pox_2_activation = Some(3);
+
+    test_observer::spawn();
+    conf.events_observers.insert(EventObserverConfig {
+        endpoint: format!("localhost:{}", test_observer::EVENT_OBSERVER_PORT),
+        events_keys: vec![EventKeyType::AnyEvent],
+    });
+
+    let mut btcd_controller = BitcoinCoreController::new(conf.clone());
+    btcd_controller
+        .start_bitcoind()
+        .map_err(|_e| ())
+        .expect("Failed starting bitcoind");
+
+    let mut burnchain_config = Burnchain::regtest(&conf.get_burn_db_path());
+
+    // reward cycle length = 5, so 3 reward cycle slots + 2 prepare-phase burns
+    let reward_cycle_len = 5;
+    let prepare_phase_len = 2;
+    let pox_constants = PoxConstants::new(
+        reward_cycle_len,
+        prepare_phase_len,
+        2,
+        5,
+        15,
+        (16 * reward_cycle_len - 1).into(),
+        (17 * reward_cycle_len).into(),
+        u32::MAX,
+        u32::MAX,
+        u32::MAX,
+        u32::MAX,
+    );
+    burnchain_config.pox_constants = pox_constants.clone();
+
+    let mut btc_regtest_controller = BitcoinRegtestController::with_burnchain(
+        conf.clone(),
+        None,
+        Some(burnchain_config.clone()),
+        None,
+    );
+    let http_origin = format!("http://{}", &conf.node.rpc_bind);
+
+    btc_regtest_controller.bootstrap_chain(201);
+
+    eprintln!("Chain bootstrapped...");
+
+    let mut run_loop = neon::RunLoop::new(conf.clone());
+    let blocks_processed = run_loop.get_blocks_processed_arc();
+
+    let channel = run_loop.get_coordinator_channel().unwrap();
+
+    thread::spawn(move || run_loop.start(None, 0));
+
+    // give the run loop some time to start up!
+    wait_for_runloop(&blocks_processed);
+
+    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+    // next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+
+    test_observer::clear();
+
+    // Mine a few more blocks so that Epoch 2.5 can take effect.
+    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+    // next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+    // next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+    // next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+    // next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+
+    info!("Bootstrapped to 2.5, submitting stack-stx and pre-stx op...");
+
+    // setup stack-stx tx
+
+    let signer_sk = spender_sk.clone();
+    let signer_pk = StacksPublicKey::from_private(&signer_sk);
+
+    let pox_addr = PoxAddress::Standard(spender_stx_addr, Some(AddressHashMode::SerializeP2PKH));
+
+    let mut block_height = channel.get_sortitions_processed();
+
+    let reward_cycle = burnchain_config
+        .block_height_to_reward_cycle(block_height)
+        .unwrap();
+
+    let signature = make_pox_4_signer_key_signature(
+        &pox_addr,
+        &signer_sk,
+        reward_cycle.into(),
+        &Pox4SignatureTopic::StackStx,
+        CHAIN_ID_TESTNET,
+        12,
+    )
+    .unwrap();
+
+    let stacking_tx = make_contract_call(
+        &spender_sk,
+        0,
+        500,
+        &StacksAddress::from_string("ST000000000000000000002AMW42H").unwrap(),
+        "pox-4",
+        "stack-stx",
+        &[
+            Value::UInt(stacked_bal),
+            Value::Tuple(pox_addr.as_clarity_tuple().unwrap()),
+            Value::UInt(block_height.into()),
+            Value::UInt(12),
+            Value::buff_from(signature.to_rsv()).unwrap(),
+            Value::buff_from(signer_pk.to_bytes_compressed()).unwrap(),
+        ],
+    );
+
+    let mut miner_signer = Keychain::default(conf.node.seed.clone()).generate_op_signer();
+    let pre_stx_op = PreStxOp {
+        output: spender_stx_addr.clone(),
+        // to be filled in
+        txid: Txid([0u8; 32]),
+        vtxindex: 0,
+        block_height: 0,
+        burn_header_hash: BurnchainHeaderHash([0u8; 32]),
+    };
+
+    assert!(
+        btc_regtest_controller
+            .submit_operation(
+                StacksEpochId::Epoch25,
+                BlockstackOperationType::PreStx(pre_stx_op),
+                &mut miner_signer,
+                1
+            )
+            .is_some(),
+        "Pre-stx operation should submit successfully"
+    );
+
+    // push the stacking transaction
+    submit_tx(&http_origin, &stacking_tx);
+
+    info!("Submitted stack-stx and pre-stx op at block {block_height}, mining a few blocks...");
+
+    // Wait a few blocks to be registered
+    for _i in 0..2 {
+        next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+        block_height = channel.get_sortitions_processed();
+    }
+
+    let reward_cycle = burnchain_config
+        .block_height_to_reward_cycle(block_height)
+        .unwrap();
+
+    let signer_key: StacksPublicKeyBuffer = signer_pk.to_bytes_compressed().as_slice().into();
+
+    let aggregate_key = StacksPublicKeyBuffer([0x99; 33]);
+
+    info!(
+        "Submitting vote for aggregate key op at block {block_height} in cycle {reward_cycle}..."
+    );
+
+    let vote_for_aggregate_key_op =
+        BlockstackOperationType::VoteForAggregateKey(VoteForAggregateKeyOp {
+            signer_key,
+            signer_index: 0,
+            sender: spender_stx_addr.clone(),
+            round: 0,
+            reward_cycle,
+            aggregate_key,
+            // to be filled in
+            vtxindex: 0,
+            txid: Txid([0u8; 32]),
+            block_height: 0,
+            burn_header_hash: BurnchainHeaderHash::zero(),
+        });
+
+    let mut spender_signer = BurnchainOpSigner::new(signer_sk.clone(), false);
+    assert!(
+        btc_regtest_controller
+            .submit_operation(
+                StacksEpochId::Epoch25,
+                vote_for_aggregate_key_op,
+                &mut spender_signer,
+                1
+            )
+            .is_some(),
+        "Vote for aggregate key operation should submit successfully"
+    );
+
+    info!("Submitted vote for aggregate key op at height {block_height}, mining a few blocks...");
+
+    // the second block should process the vote, after which the balaces should be unchanged
+    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+
+    // let sortdb = btc_regtest_controller.sortdb_ref();
+    // // let burn_hash = sortdb.
+    // let burnchain_db = BurnchainDB::open(
+    //     &btc_regtest_controller
+    //         .get_burnchain()
+    //         .get_burnchaindb_path(),
+    //     false,
+    // )
+    // .unwrap();
+
+    // let burn_tip = burnchain_db.get_canonical_chain_tip().unwrap();
+    // let _last_burn_block =
+    //     BurnchainDB::get_burnchain_block(burnchain_db.conn(), &burn_tip.block_hash).unwrap();
+
+    // let vote_ops =
+    //     SortitionDB::get_vote_for_aggregate_key_ops(&sortdb.conn(), &burn_tip.block_hash);
+
+    // info!("Vote for aggregate key ops found: {:?}", vote_ops);
+    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+
+    // // let's mine until the next reward cycle starts ...
+    // next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+    // next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+    // next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+    // next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+    // next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+
+    let mut vote_for_aggregate_key_found = false;
+    let blocks = test_observer::get_blocks();
+    for block in blocks.iter() {
+        let transactions = block.get("transactions").unwrap().as_array().unwrap();
+        for tx in transactions.iter() {
+            let raw_tx = tx.get("raw_tx").unwrap().as_str().unwrap();
+            if raw_tx == "0x00" {
+                println!("Found a burn op: {:?}", tx);
+                let burnchain_op = tx.get("burnchain_op").unwrap().as_object().unwrap();
+                if !burnchain_op.contains_key("vote_for_aggregate_key") {
+                    warn!("Got unexpected burnchain op: {:?}", burnchain_op);
+                    panic!("unexpected btc transaction type");
+                }
+                vote_for_aggregate_key_found = true;
+            }
+        }
+    }
+    assert!(
+        vote_for_aggregate_key_found,
+        "Expected vote for aggregate key op"
+    );
+
+    test_observer::clear();
+    channel.stop_chains_coordinator();
+}
+
 #[test]
 #[ignore]
 fn bitcoind_resubmission_test() {

From 96c27a71dd49e30f8a2e917379d3979fb83ec9ad Mon Sep 17 00:00:00 2001
From: wileyj <2847772+wileyj@users.noreply.github.com>
Date: Wed, 21 Feb 2024 13:39:00 -0800
Subject: [PATCH 0842/1166] delay codecov status until after ci has completed

---
 codecov.yml | 20 ++++++++++++++++++--
 1 file changed, 18 insertions(+), 2 deletions(-)

diff --git a/codecov.yml b/codecov.yml
index 9848264b99..d6abb6dd38 100644
--- a/codecov.yml
+++ b/codecov.yml
@@ -1,6 +1,22 @@
+# https://docs.codecov.com/docs/codecovyml-reference
+codecov:
+  require_ci_to_pass: false
+  notify:
+    wait_for_ci: true
 coverage:
+  range: 60..79
+  round: down
+  precision: 2
   status:
-    patch: off
-
+    changes: false
+    patch: false
+    project:
+      default:
+        target: 80%
+        threshold: 1%
+comment:
+  layout: "condensed_header, diff, files, footer"
+  hide_project_coverage: false
+  after_n_builds: 35
 github_checks:
   annotations: false

From 11e5170bf0f6e8a3dd17549d893c0c7a827d3330 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Wed, 21 Feb 2024 15:24:02 -0800
Subject: [PATCH 0843/1166] feat: integration tests for vote-for-agg-key burn
 op

---
 stackslib/src/chainstate/burn/db/sortdb.rs    |  10 +-
 .../burn/operations/vote_for_aggregate_key.rs |   4 +-
 stackslib/src/chainstate/stacks/db/blocks.rs  |  13 +-
 .../burnchains/bitcoin_regtest_controller.rs  |   1 -
 .../src/tests/nakamoto_integrations.rs        | 293 +++++++++---------
 .../src/tests/neon_integrations.rs            |  78 +++--
 6 files changed, 198 insertions(+), 201 deletions(-)

diff --git a/stackslib/src/chainstate/burn/db/sortdb.rs b/stackslib/src/chainstate/burn/db/sortdb.rs
index 2cee5f261c..f594efee25 100644
--- a/stackslib/src/chainstate/burn/db/sortdb.rs
+++ b/stackslib/src/chainstate/burn/db/sortdb.rs
@@ -743,7 +743,7 @@ const SORTITION_DB_SCHEMA_6: &'static [&'static str] = &[r#"
 const SORTITION_DB_SCHEMA_7: &'static [&'static str] = &[r#"
      DELETE FROM epochs;"#];
 
-const LAST_SORTITION_DB_INDEX: &'static str = "index_delegate_stx_burn_header_hash";
+const LAST_SORTITION_DB_INDEX: &'static str = "index_vote_for_aggregate_key_burn_header_hash";
 const SORTITION_DB_SCHEMA_8: &'static [&'static str] = &[
     r#"ALTER TABLE snapshots ADD miner_pk_hash TEXT DEFAULT NULL"#,
     r#"
@@ -3228,6 +3228,7 @@ impl SortitionDB {
                     || version == "6"
                     || version == "7"
                     || version == "8"
+                    || version == "9"
             }
             StacksEpochId::Epoch2_05 => {
                 version == "2"
@@ -3237,6 +3238,7 @@ impl SortitionDB {
                     || version == "6"
                     || version == "7"
                     || version == "8"
+                    || version == "9"
             }
             StacksEpochId::Epoch21 => {
                 version == "3"
@@ -3245,6 +3247,7 @@ impl SortitionDB {
                     || version == "6"
                     || version == "7"
                     || version == "8"
+                    || version == "9"
             }
             StacksEpochId::Epoch22 => {
                 version == "3"
@@ -3253,6 +3256,7 @@ impl SortitionDB {
                     || version == "6"
                     || version == "7"
                     || version == "8"
+                    || version == "9"
             }
             StacksEpochId::Epoch23 => {
                 version == "3"
@@ -3261,6 +3265,7 @@ impl SortitionDB {
                     || version == "6"
                     || version == "7"
                     || version == "8"
+                    || version == "9"
             }
             StacksEpochId::Epoch24 => {
                 version == "3"
@@ -3269,6 +3274,7 @@ impl SortitionDB {
                     || version == "6"
                     || version == "7"
                     || version == "8"
+                    || version == "9"
             }
             StacksEpochId::Epoch25 => {
                 version == "3"
@@ -3278,6 +3284,7 @@ impl SortitionDB {
                     || version == "7"
                     // TODO: This should move to Epoch 30 once it is added
                     || version == "8"
+                    || version == "9"
             }
             StacksEpochId::Epoch30 => {
                 version == "3"
@@ -3286,6 +3293,7 @@ impl SortitionDB {
                     || version == "6"
                     || version == "7"
                     || version == "8"
+                    || version == "9"
             }
         }
     }
diff --git a/stackslib/src/chainstate/burn/operations/vote_for_aggregate_key.rs b/stackslib/src/chainstate/burn/operations/vote_for_aggregate_key.rs
index e5d0094e63..dd4d5a8cec 100644
--- a/stackslib/src/chainstate/burn/operations/vote_for_aggregate_key.rs
+++ b/stackslib/src/chainstate/burn/operations/vote_for_aggregate_key.rs
@@ -109,7 +109,6 @@ impl VoteForAggregateKeyOp {
         match tx {
             BurnchainTransaction::Bitcoin(ref btc) => match btc.inputs.get(0) {
                 Some(BitcoinTxInput::Raw(input)) => {
-                    info!("Vote for aggregate key raw input: {:?}", input.scriptSig);
                     let script_sig = Builder::from(input.scriptSig.clone()).into_script();
                     let structured_input = BitcoinTxInputStructured::from_bitcoin_p2pkh_script_sig(
                         &parse_script(&script_sig),
@@ -123,7 +122,6 @@ impl VoteForAggregateKeyOp {
                         .ok_or(op_error::InvalidInput)
                 }
                 Some(BitcoinTxInput::Structured(input)) => {
-                    info!("Getting signer key from structured input: {:?}", input);
                     input.keys.get(0).cloned().ok_or(op_error::InvalidInput)
                 }
                 _ => Err(op_error::InvalidInput),
@@ -343,7 +341,7 @@ mod tests {
         )
         .expect("Failed to parse vote tx");
 
-        info!("Vote op test data: {:?}", to_hex(data.as_slice()));
+        debug!("Vote op test data: {:?}", to_hex(data.as_slice()));
 
         assert_eq!(vote_op.signer_index, signer_index);
         assert_eq!(&vote_op.aggregate_key, &aggregate_key);
diff --git a/stackslib/src/chainstate/stacks/db/blocks.rs b/stackslib/src/chainstate/stacks/db/blocks.rs
index c098540151..e081b3fcba 100644
--- a/stackslib/src/chainstate/stacks/db/blocks.rs
+++ b/stackslib/src/chainstate/stacks/db/blocks.rs
@@ -4502,6 +4502,16 @@ impl StacksChainState {
                 burn_header_hash,
                 ..
             } = &vote_for_aggregate_key_op;
+            debug!("Processing VoteForAggregateKey burn op";
+                "round" => round,
+                "reward_cycle" => reward_cycle,
+                "signer_index" => signer_index,
+                "signer_key" => signer_key.to_hex(),
+                "burn_block_height" => block_height,
+                "sender" => %sender,
+                "aggregate_key" => aggregate_key.to_hex(),
+                "txid" => %txid
+            );
             let result = clarity_tx.connection().as_transaction(|tx| {
                 tx.run_contract_call(
                     &sender.clone().into(),
@@ -4549,7 +4559,6 @@ impl StacksChainState {
                                 BlockstackOperationType::VoteForAggregateKey(
                                     vote_for_aggregate_key_op,
                                 ),
-                                // BlockstackOperationType::DelegateStx(delegate_stx_op),
                             ),
                             events,
                             result: value,
@@ -4577,7 +4586,7 @@ impl StacksChainState {
                 }
             };
         }
-        vec![]
+        all_receipts
     }
 
     /// Process a single anchored block.
diff --git a/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs b/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
index ab32a2765e..22f48ff261 100644
--- a/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
+++ b/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
@@ -1930,7 +1930,6 @@ impl BitcoinRegtestController {
             BlockstackOperationType::DelegateStx(payload) => {
                 self.build_delegate_stacks_tx(epoch_id, payload, op_signer, None)
             }
-            // TODO
             BlockstackOperationType::VoteForAggregateKey(payload) => {
                 self.build_vote_for_aggregate_key_tx(epoch_id, payload, op_signer, None)
             }
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 66d9fe4471..c70b52e970 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -25,7 +25,9 @@ use lazy_static::lazy_static;
 use libsigner::{SignerSession, StackerDBSession};
 use stacks::burnchains::{MagicBytes, Txid};
 use stacks::chainstate::burn::db::sortdb::SortitionDB;
-use stacks::chainstate::burn::operations::{BlockstackOperationType, VoteForAggregateKeyOp};
+use stacks::chainstate::burn::operations::{
+    BlockstackOperationType, PreStxOp, VoteForAggregateKeyOp,
+};
 use stacks::chainstate::coordinator::comm::CoordinatorChannels;
 use stacks::chainstate::nakamoto::miner::NakamotoBlockBuilder;
 use stacks::chainstate::nakamoto::test_signers::TestSigners;
@@ -58,7 +60,7 @@ use stacks_common::types::chainstate::{
 };
 use stacks_common::types::StacksPublicKeyBuffer;
 use stacks_common::util::hash::to_hex;
-use stacks_common::util::secp256k1::{MessageSignature, Secp256k1PrivateKey, Secp256k1PublicKey};
+use stacks_common::util::secp256k1::{MessageSignature, Secp256k1PrivateKey};
 
 use super::bitcoin_regtest::BitcoinCoreController;
 use crate::config::{EventKeyType, EventObserverConfig, InitialBalance};
@@ -1797,35 +1799,18 @@ fn miner_writes_proposed_block_to_stackerdb() {
 
 #[test]
 #[ignore]
-/// This test spins up a nakamoto-neon node and validates the `vote-for-aggregate-key`
-/// burn operation.
-/// It starts in Epoch 2.0, mines with `neon_node` to Epoch 32.5, and then switches
-///  to Nakamoto operation (activating pox-4 by submitting a stack-stx tx). The BootLoop
-///  struct handles the epoch-2/3 tear-down and spin-up.
 fn vote_for_aggregate_key_burn_op() {
     if env::var("BITCOIND_TEST") != Ok("1".into()) {
         return;
     }
 
     let (mut naka_conf, _miner_account) = naka_neon_integration_conf(None);
-    naka_conf.miner.wait_on_interim_blocks = Duration::from_secs(1000);
-    let sender_sk = Secp256k1PrivateKey::new();
-    // setup sender + recipient for a test stx transfer
-    let sender_addr = tests::to_addr(&sender_sk);
-    let send_amt = 1000;
-    let send_fee = 100;
-    naka_conf.add_initial_balance(
-        PrincipalData::from(sender_addr.clone()).to_string(),
-        send_amt + send_fee,
-    );
-    let sender_signer_sk = Secp256k1PrivateKey::new();
-    let sender_signer_pk = Secp256k1PublicKey::from_private(&sender_signer_sk);
-    let sender_signer_addr = tests::to_addr(&sender_signer_sk);
-    naka_conf.add_initial_balance(
-        PrincipalData::from(sender_signer_addr.clone()).to_string(),
-        100000,
-    );
-    let _recipient = PrincipalData::from(StacksAddress::burn_address(false));
+    let _http_origin = format!("http://{}", &naka_conf.node.rpc_bind);
+    naka_conf.miner.wait_on_interim_blocks = Duration::from_secs(1);
+    let signer_sk = Secp256k1PrivateKey::new();
+    let signer_addr = tests::to_addr(&signer_sk);
+
+    naka_conf.add_initial_balance(PrincipalData::from(signer_addr.clone()).to_string(), 100000);
     let stacker_sk = setup_stacker(&mut naka_conf);
 
     test_observer::spawn();
@@ -1853,22 +1838,24 @@ fn vote_for_aggregate_key_burn_op() {
 
     let coord_channel = run_loop.coordinator_channels();
 
-    let run_loop_thread = thread::spawn(move || run_loop.start(None, 0));
+    let run_loop_thread = thread::Builder::new()
+        .name("run_loop".into())
+        .spawn(move || run_loop.start(None, 0))
+        .unwrap();
     wait_for_runloop(&blocks_processed);
     boot_to_epoch_3(
         &naka_conf,
         &blocks_processed,
         &[stacker_sk],
-        &[sender_signer_sk],
+        &[signer_sk],
         &mut btc_regtest_controller,
     );
 
     info!("Bootstrapped to Epoch-3.0 boundary, starting nakamoto miner");
 
     let burnchain = naka_conf.get_burnchain();
-    let sortdb = burnchain.open_sortition_db(true).unwrap();
-    // let (mut chainstate, _) = StacksChainState::open(
-    let (chainstate, _) = StacksChainState::open(
+    let _sortdb = burnchain.open_sortition_db(true).unwrap();
+    let (_chainstate, _) = StacksChainState::open(
         naka_conf.is_mainnet(),
         naka_conf.burnchain.chain_id,
         &naka_conf.get_chainstate_path_str(),
@@ -1876,12 +1863,6 @@ fn vote_for_aggregate_key_burn_op() {
     )
     .unwrap();
 
-    let _block_height_pre_3_0 =
-        NakamotoChainState::get_canonical_block_header(chainstate.db(), &sortdb)
-            .unwrap()
-            .unwrap()
-            .stacks_block_height;
-
     info!("Nakamoto miner started...");
     // first block wakes up the run loop, wait until a key registration has been submitted.
     next_block_and(&mut btc_regtest_controller, 60, || {
@@ -1897,138 +1878,148 @@ fn vote_for_aggregate_key_burn_op() {
     })
     .unwrap();
 
+    // submit a pre-stx op
+    let mut miner_signer = Keychain::default(naka_conf.node.seed.clone()).generate_op_signer();
+    info!("Submitting pre-stx op");
+    let pre_stx_op = PreStxOp {
+        output: signer_addr.clone(),
+        // to be filled in
+        txid: Txid([0u8; 32]),
+        vtxindex: 0,
+        block_height: 0,
+        burn_header_hash: BurnchainHeaderHash([0u8; 32]),
+    };
+
+    assert!(
+        btc_regtest_controller
+            .submit_operation(
+                StacksEpochId::Epoch30,
+                BlockstackOperationType::PreStx(pre_stx_op),
+                &mut miner_signer,
+                1
+            )
+            .is_some(),
+        "Pre-stx operation should submit successfully"
+    );
+
+    // Mine until the next prepare phase
+    let block_height = btc_regtest_controller.get_headers_height();
+    let reward_cycle = btc_regtest_controller
+        .get_burnchain()
+        .block_height_to_reward_cycle(block_height)
+        .unwrap();
+    let prepare_phase_start = btc_regtest_controller
+        .get_burnchain()
+        .pox_constants
+        .prepare_phase_start(
+            btc_regtest_controller.get_burnchain().first_block_height,
+            reward_cycle,
+        );
+
+    let blocks_until_prepare = prepare_phase_start + 1 - block_height;
+
+    info!(
+        "Mining until prepare phase start.";
+        "prepare_phase_start" => prepare_phase_start,
+        "block_height" => block_height,
+        "blocks_until_prepare" => blocks_until_prepare,
+    );
+
+    for _i in 0..(blocks_until_prepare) {
+        next_block_and_mine_commit(
+            &mut btc_regtest_controller,
+            60,
+            &coord_channel,
+            &commits_submitted,
+        )
+        .unwrap();
+    }
+
+    let reward_cycle = reward_cycle + 1;
+
+    let signer_index = 0;
+
+    info!(
+        "Submitting vote for aggregate key op";
+        "block_height" => block_height,
+        "reward_cycle" => reward_cycle,
+        "signer_index" => %signer_index,
+    );
+
+    let stacker_pk = StacksPublicKey::from_private(&stacker_sk);
+    let signer_key: StacksPublicKeyBuffer = stacker_pk.to_bytes_compressed().as_slice().into();
     let aggregate_key = StacksPublicKeyBuffer([0x01; 33]);
 
     let vote_for_aggregate_key_op =
         BlockstackOperationType::VoteForAggregateKey(VoteForAggregateKeyOp {
-            signer_key: sender_signer_pk.to_bytes_compressed().as_slice().into(),
-            signer_index: 0,
-            sender: sender_addr.clone(),
+            signer_key,
+            signer_index,
+            sender: signer_addr.clone(),
             round: 0,
+            reward_cycle,
             aggregate_key,
             // to be filled in
             vtxindex: 0,
             txid: Txid([0u8; 32]),
             block_height: 0,
             burn_header_hash: BurnchainHeaderHash::zero(),
-            reward_cycle: 1,
         });
 
-    let mut burnchain_signer = BurnchainOpSigner::new(sender_signer_sk.clone(), false);
-
-    btc_regtest_controller.submit_operation(
-        StacksEpochId::Epoch25,
-        vote_for_aggregate_key_op,
-        &mut burnchain_signer,
-        0,
+    let mut signer_burnop_signer = BurnchainOpSigner::new(signer_sk.clone(), false);
+    assert!(
+        btc_regtest_controller
+            .submit_operation(
+                StacksEpochId::Epoch30,
+                vote_for_aggregate_key_op,
+                &mut signer_burnop_signer,
+                1
+            )
+            .is_some(),
+        "Vote for aggregate key operation should submit successfully"
     );
 
-    next_block_and_mine_commit(
-        &mut btc_regtest_controller,
-        60,
-        &coord_channel,
-        &commits_submitted,
-    )
-    .unwrap();
+    info!("Submitted vote for aggregate key op at height {block_height}, mining a few blocks...");
 
-    // assert that the transfer tx was observed
-    let vote_tx_included = test_observer::get_blocks()
-        .into_iter()
-        .find(|block_json| {
-            block_json["transactions"]
-                .as_array()
-                .unwrap()
-                .iter()
-                .find(|tx_json| match tx_json["raw_tx"].as_str() {
-                    Some(v) => String::from(v).contains("vote-for-aggregate-key"),
-                    _ => false,
-                })
-                .is_some()
-        })
-        .is_some();
-
-    assert!(vote_tx_included, "Expected vote-for-aggregate-key burn op");
-
-    // Mine 15 nakamoto tenures
-    // for _i in 0..15 {
-    //     next_block_and_mine_commit(
-    //         &mut btc_regtest_controller,
-    //         60,
-    //         &coord_channel,
-    //         &commits_submitted,
-    //     )
-    //     .unwrap();
-
-    //     signer_vote_if_needed(&btc_regtest_controller, &naka_conf, &[sender_signer_sk]);
-    // }
+    // the second block should process the vote, after which the balaces should be unchanged
+    for _i in 0..2 {
+        next_block_and_mine_commit(
+            &mut btc_regtest_controller,
+            60,
+            &coord_channel,
+            &commits_submitted,
+        )
+        .unwrap();
+    }
 
-    // Submit a TX
-    // let transfer_tx = make_stacks_transfer(&sender_sk, 0, send_fee, &recipient, send_amt);
-    // let transfer_tx_hex = format!("0x{}", to_hex(&transfer_tx));
-
-    // let tip = NakamotoChainState::get_canonical_block_header(chainstate.db(), &sortdb)
-    //     .unwrap()
-    //     .unwrap();
-
-    // let mut mempool = naka_conf
-    //     .connect_mempool_db()
-    //     .expect("Database failure opening mempool");
-
-    // mempool
-    //     .submit_raw(
-    //         &mut chainstate,
-    //         &sortdb,
-    //         &tip.consensus_hash,
-    //         &tip.anchored_header.block_hash(),
-    //         transfer_tx.clone(),
-    //         &ExecutionCost::max_value(),
-    //         &StacksEpochId::Epoch30,
-    //     )
-    //     .unwrap();
-
-    // // Mine 15 more nakamoto tenures
-    // for _i in 0..15 {
-    //     next_block_and_mine_commit(
-    //         &mut btc_regtest_controller,
-    //         60,
-    //         &coord_channel,
-    //         &commits_submitted,
-    //     )
-    //     .unwrap();
-
-    //     signer_vote_if_needed(&btc_regtest_controller, &naka_conf, &[sender_signer_sk]);
-    // }
-
-    // // load the chain tip, and assert that it is a nakamoto block and at least 30 blocks have advanced in epoch 3
-    // let tip = NakamotoChainState::get_canonical_block_header(chainstate.db(), &sortdb)
-    //     .unwrap()
-    //     .unwrap();
-    // info!(
-    //     "Latest tip";
-    //     "height" => tip.stacks_block_height,
-    //     "is_nakamoto" => tip.anchored_header.as_stacks_nakamoto().is_some(),
-    // );
-
-    // // assert that the transfer tx was observed
-    // let transfer_tx_included = test_observer::get_blocks()
-    //     .into_iter()
-    //     .find(|block_json| {
-    //         block_json["transactions"]
-    //             .as_array()
-    //             .unwrap()
-    //             .iter()
-    //             .find(|tx_json| tx_json["raw_tx"].as_str() == Some(&transfer_tx_hex))
-    //             .is_some()
-    //     })
-    //     .is_some();
-
-    // assert!(
-    //     transfer_tx_included,
-    //     "Nakamoto node failed to include the transfer tx"
-    // );
-
-    // assert!(tip.anchored_header.as_stacks_nakamoto().is_some());
-    // assert!(tip.stacks_block_height >= block_height_pre_3_0 + 30);
+    let mut vote_for_aggregate_key_found = false;
+    let blocks = test_observer::get_blocks();
+    for block in blocks.iter() {
+        let transactions = block.get("transactions").unwrap().as_array().unwrap();
+        for tx in transactions.iter() {
+            let raw_tx = tx.get("raw_tx").unwrap().as_str().unwrap();
+            if raw_tx == "0x00" {
+                info!("Found a burn op: {:?}", tx);
+                let burnchain_op = tx.get("burnchain_op").unwrap().as_object().unwrap();
+                if !burnchain_op.contains_key("vote_for_aggregate_key") {
+                    warn!("Got unexpected burnchain op: {:?}", burnchain_op);
+                    panic!("unexpected btc transaction type");
+                }
+                let vote_obj = burnchain_op.get("vote_for_aggregate_key").unwrap();
+                let agg_key = vote_obj
+                    .get("aggregate_key")
+                    .expect("Expected aggregate_key key in burn op")
+                    .as_str()
+                    .unwrap();
+                assert_eq!(agg_key, aggregate_key.to_hex());
+
+                vote_for_aggregate_key_found = true;
+            }
+        }
+    }
+    assert!(
+        vote_for_aggregate_key_found,
+        "Expected vote for aggregate key op"
+    );
 
     coord_channel
         .lock()
diff --git a/testnet/stacks-node/src/tests/neon_integrations.rs b/testnet/stacks-node/src/tests/neon_integrations.rs
index e1408d5a99..c3eaf15e3c 100644
--- a/testnet/stacks-node/src/tests/neon_integrations.rs
+++ b/testnet/stacks-node/src/tests/neon_integrations.rs
@@ -49,6 +49,7 @@ use stacks::net::api::getaccount::AccountEntryResponse;
 use stacks::net::api::getcontractsrc::ContractSrcResponse;
 use stacks::net::api::getinfo::RPCPeerInfoData;
 use stacks::net::api::getpoxinfo::RPCPoxInfoData;
+use stacks::net::api::getstackers::GetStackersResponse;
 use stacks::net::api::gettransaction_unconfirmed::UnconfirmedTransactionResponse;
 use stacks::net::api::postblock::StacksBlockAcceptedData;
 use stacks::net::api::postfeerate::RPCFeeEstimateResponse;
@@ -1297,6 +1298,16 @@ pub fn get_contract_src(
     }
 }
 
+pub fn get_stacker_set(http_origin: &str, reward_cycle: u64) -> GetStackersResponse {
+    let client = reqwest::blocking::Client::new();
+    let path = format!("{}/v2/stacker_set/{}", http_origin, reward_cycle);
+    let res = client.get(&path).send().unwrap();
+
+    info!("Got stacker_set response {:?}", &res);
+    let res = res.json::<GetStackersResponse>().unwrap();
+    res
+}
+
 #[test]
 #[ignore]
 fn deep_contract() {
@@ -2250,7 +2261,6 @@ fn vote_for_aggregate_key_burn_op_test() {
 
     let first_bal = 6_000_000_000 * (core::MICROSTACKS_PER_STACKS as u64);
     let second_bal = 2_000_000_000 * (core::MICROSTACKS_PER_STACKS as u64);
-    let _third_bal = 2_000_000_000 * (core::MICROSTACKS_PER_STACKS as u64);
     let stacked_bal = 1_000_000_000 * (core::MICROSTACKS_PER_STACKS as u128);
 
     conf.initial_balances.push(InitialBalance {
@@ -2370,18 +2380,11 @@ fn vote_for_aggregate_key_burn_op_test() {
     // give the run loop some time to start up!
     wait_for_runloop(&blocks_processed);
 
-    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
-    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
-    // next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
-
     test_observer::clear();
 
-    // Mine a few more blocks so that Epoch 2.5 can take effect.
     next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
-    // next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
-    // next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
-    // next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
-    // next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
+    next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
 
     info!("Bootstrapped to 2.5, submitting stack-stx and pre-stx op...");
 
@@ -2408,6 +2411,8 @@ fn vote_for_aggregate_key_burn_op_test() {
     )
     .unwrap();
 
+    let signer_pk_bytes = signer_pk.to_bytes_compressed();
+
     let stacking_tx = make_contract_call(
         &spender_sk,
         0,
@@ -2420,8 +2425,8 @@ fn vote_for_aggregate_key_burn_op_test() {
             Value::Tuple(pox_addr.as_clarity_tuple().unwrap()),
             Value::UInt(block_height.into()),
             Value::UInt(12),
-            Value::buff_from(signature.to_rsv()).unwrap(),
-            Value::buff_from(signer_pk.to_bytes_compressed()).unwrap(),
+            Value::some(Value::buff_from(signature.to_rsv()).unwrap()).unwrap(),
+            Value::buff_from(signer_pk_bytes.clone()).unwrap(),
         ],
     );
 
@@ -2453,7 +2458,7 @@ fn vote_for_aggregate_key_burn_op_test() {
     info!("Submitted stack-stx and pre-stx op at block {block_height}, mining a few blocks...");
 
     // Wait a few blocks to be registered
-    for _i in 0..2 {
+    for _i in 0..5 {
         next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
         block_height = channel.get_sortitions_processed();
     }
@@ -2462,18 +2467,23 @@ fn vote_for_aggregate_key_burn_op_test() {
         .block_height_to_reward_cycle(block_height)
         .unwrap();
 
-    let signer_key: StacksPublicKeyBuffer = signer_pk.to_bytes_compressed().as_slice().into();
+    let signer_key: StacksPublicKeyBuffer = signer_pk_bytes.clone().as_slice().into();
 
     let aggregate_key = StacksPublicKeyBuffer([0x99; 33]);
 
+    let signer_index = 0;
+
     info!(
-        "Submitting vote for aggregate key op at block {block_height} in cycle {reward_cycle}..."
+        "Submitting vote for aggregate key op";
+        "block_height" => block_height,
+        "reward_cycle" => reward_cycle,
+        "signer_index" => %signer_index,
     );
 
     let vote_for_aggregate_key_op =
         BlockstackOperationType::VoteForAggregateKey(VoteForAggregateKeyOp {
             signer_key,
-            signer_index: 0,
+            signer_index,
             sender: spender_stx_addr.clone(),
             round: 0,
             reward_cycle,
@@ -2502,34 +2512,8 @@ fn vote_for_aggregate_key_burn_op_test() {
 
     // the second block should process the vote, after which the balaces should be unchanged
     next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
-
-    // let sortdb = btc_regtest_controller.sortdb_ref();
-    // // let burn_hash = sortdb.
-    // let burnchain_db = BurnchainDB::open(
-    //     &btc_regtest_controller
-    //         .get_burnchain()
-    //         .get_burnchaindb_path(),
-    //     false,
-    // )
-    // .unwrap();
-
-    // let burn_tip = burnchain_db.get_canonical_chain_tip().unwrap();
-    // let _last_burn_block =
-    //     BurnchainDB::get_burnchain_block(burnchain_db.conn(), &burn_tip.block_hash).unwrap();
-
-    // let vote_ops =
-    //     SortitionDB::get_vote_for_aggregate_key_ops(&sortdb.conn(), &burn_tip.block_hash);
-
-    // info!("Vote for aggregate key ops found: {:?}", vote_ops);
     next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
 
-    // // let's mine until the next reward cycle starts ...
-    // next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
-    // next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
-    // next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
-    // next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
-    // next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
-
     let mut vote_for_aggregate_key_found = false;
     let blocks = test_observer::get_blocks();
     for block in blocks.iter() {
@@ -2537,12 +2521,20 @@ fn vote_for_aggregate_key_burn_op_test() {
         for tx in transactions.iter() {
             let raw_tx = tx.get("raw_tx").unwrap().as_str().unwrap();
             if raw_tx == "0x00" {
-                println!("Found a burn op: {:?}", tx);
+                debug!("Found a burn op: {:?}", tx);
                 let burnchain_op = tx.get("burnchain_op").unwrap().as_object().unwrap();
                 if !burnchain_op.contains_key("vote_for_aggregate_key") {
                     warn!("Got unexpected burnchain op: {:?}", burnchain_op);
                     panic!("unexpected btc transaction type");
                 }
+                let vote_obj = burnchain_op.get("vote_for_aggregate_key").unwrap();
+                let agg_key = vote_obj
+                    .get("aggregate_key")
+                    .expect("Expected aggregate_key key in burn op")
+                    .as_str()
+                    .unwrap();
+                assert_eq!(agg_key, aggregate_key.to_hex());
+
                 vote_for_aggregate_key_found = true;
             }
         }

From ea58fc72b30fe188c15b6153a4abc98a8414bc35 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Wed, 21 Feb 2024 15:53:54 -0800
Subject: [PATCH 0844/1166] feat: validate keys used in burn op

---
 .github/workflows/bitcoin-tests.yml           |  6 ++--
 stackslib/src/chainstate/burn/db/sortdb.rs    |  9 ++++--
 .../src/chainstate/burn/operations/mod.rs     |  6 ++++
 .../burn/operations/vote_for_aggregate_key.rs | 29 +++++--------------
 .../src/tests/nakamoto_integrations.rs        |  2 +-
 .../src/tests/neon_integrations.rs            |  5 +++-
 6 files changed, 30 insertions(+), 27 deletions(-)

diff --git a/.github/workflows/bitcoin-tests.yml b/.github/workflows/bitcoin-tests.yml
index ae465bbd44..c24a687e39 100644
--- a/.github/workflows/bitcoin-tests.yml
+++ b/.github/workflows/bitcoin-tests.yml
@@ -31,7 +31,7 @@ jobs:
         test-name:
           - tests::bitcoin_regtest::bitcoind_integration_test
           - tests::integrations::integration_test_get_info
-          - tests::neon_integrations::antientropy_integration_test 
+          - tests::neon_integrations::antientropy_integration_test
           - tests::neon_integrations::bad_microblock_pubkey
           - tests::neon_integrations::bitcoind_forking_test
           - tests::neon_integrations::bitcoind_integration_test
@@ -70,12 +70,14 @@ jobs:
           - tests::neon_integrations::use_latest_tip_integration_test
           - tests::neon_integrations::confirm_unparsed_ongoing_ops
           - tests::neon_integrations::min_txs
+          - tests::neon_integrations::vote_for_aggregate_key_burn_op_test
           - tests::should_succeed_handling_malformed_and_valid_txs
           - tests::nakamoto_integrations::simple_neon_integration
           - tests::nakamoto_integrations::mine_multiple_per_tenure_integration
           - tests::nakamoto_integrations::block_proposal_api_endpoint
           - tests::nakamoto_integrations::miner_writes_proposed_block_to_stackerdb
           - tests::nakamoto_integrations::correct_burn_outs
+          - tests::nakamoto_integrations::vote_for_aggregate_key_burn_op
           - tests::signer::stackerdb_dkg_sign
           - tests::signer::stackerdb_block_proposal
     steps:
@@ -85,7 +87,7 @@ jobs:
         uses: stacks-network/actions/stacks-core/testenv@main
         with:
           btc-version: "25.0"
-          
+
       ## Run test matrix using restored cache of archive file
       ##   - Test will timeout after env.TEST_TIMEOUT minutes
       - name: Run Tests
diff --git a/stackslib/src/chainstate/burn/db/sortdb.rs b/stackslib/src/chainstate/burn/db/sortdb.rs
index f594efee25..1d8ae746f4 100644
--- a/stackslib/src/chainstate/burn/db/sortdb.rs
+++ b/stackslib/src/chainstate/burn/db/sortdb.rs
@@ -10390,6 +10390,11 @@ pub mod tests {
         )
         .unwrap();
         let mut db = SortitionDB::connect_test(block_height, &first_burn_hash).unwrap();
+        let vote_pubkey = StacksPublicKey::from_hex(
+            "02d8015134d9db8178ac93acbc43170a2f20febba5087a5b0437058765ad5133d0",
+        )
+        .unwrap();
+        let vote_key: StacksPublicKeyBuffer = vote_pubkey.to_bytes_compressed().as_slice().into();
 
         let good_ops = vec![
             BlockstackOperationType::TransferStx(TransferStxOp {
@@ -10434,8 +10439,8 @@ pub mod tests {
             }),
             BlockstackOperationType::VoteForAggregateKey(VoteForAggregateKeyOp {
                 sender: StacksAddress::new(6, Hash160([6u8; 20])),
-                aggregate_key: StacksPublicKeyBuffer([0x01; 33]),
-                signer_key: StacksPublicKeyBuffer([0x02; 33]),
+                aggregate_key: vote_key,
+                signer_key: vote_key,
                 round: 1,
                 reward_cycle: 2,
                 signer_index: 3,
diff --git a/stackslib/src/chainstate/burn/operations/mod.rs b/stackslib/src/chainstate/burn/operations/mod.rs
index fddd347865..5ce1caf745 100644
--- a/stackslib/src/chainstate/burn/operations/mod.rs
+++ b/stackslib/src/chainstate/burn/operations/mod.rs
@@ -95,6 +95,9 @@ pub enum Error {
 
     // sBTC errors
     AmountMustBePositive,
+
+    // vote-for-aggregate-public-key errors
+    VoteForAggregateKeyInvalidKey,
 }
 
 impl fmt::Display for Error {
@@ -157,6 +160,9 @@ impl fmt::Display for Error {
                 "Stack STX must set num cycles between 1 and max num cycles"
             ),
             Error::DelegateStxMustBePositive => write!(f, "Delegate STX must be positive amount"),
+            Error::VoteForAggregateKeyInvalidKey => {
+                write!(f, "Aggregate key is invalid")
+            }
             Self::AmountMustBePositive => write!(f, "Peg in amount must be positive"),
         }
     }
diff --git a/stackslib/src/chainstate/burn/operations/vote_for_aggregate_key.rs b/stackslib/src/chainstate/burn/operations/vote_for_aggregate_key.rs
index dd4d5a8cec..51c582cd4d 100644
--- a/stackslib/src/chainstate/burn/operations/vote_for_aggregate_key.rs
+++ b/stackslib/src/chainstate/burn/operations/vote_for_aggregate_key.rs
@@ -146,16 +146,6 @@ impl VoteForAggregateKeyOp {
             return Err(op_error::InvalidInput);
         }
 
-        // It's ok not to have outputs
-        // if outputs.len() == 0 {
-        //     warn!(
-        //         "Invalid tx: inputs: {}, outputs: {}",
-        //         tx.num_signers(),
-        //         outputs.len()
-        //     );
-        //     return Err(op_error::InvalidInput);
-        // }
-
         if tx.opcode() != Opcodes::VoteForAggregateKey as u8 {
             warn!("Invalid tx: invalid opcode {}", tx.opcode());
             return Err(op_error::InvalidInput);
@@ -166,14 +156,7 @@ impl VoteForAggregateKeyOp {
             op_error::ParseError
         })?;
 
-        // let signer_key = VoteForAggregateKeyOp::get_sender_pubkey(tx)?;
-        // TODO: throw the error. temporarily use a default for testing:
-        let signer_key = VoteForAggregateKeyOp::get_sender_pubkey(tx).unwrap_or(
-            Secp256k1PublicKey::from_hex(
-                "02fa66b66f8971a8cd4d20ffded09674e030f0f33883f337f34b95ad4935bac0e3",
-            )
-            .unwrap(),
-        );
+        let signer_key = VoteForAggregateKeyOp::get_sender_pubkey(tx)?;
 
         Ok(VoteForAggregateKeyOp {
             sender: sender.clone(),
@@ -190,7 +173,13 @@ impl VoteForAggregateKeyOp {
     }
 
     pub fn check(&self) -> Result<(), op_error> {
-        // TODO
+        // Check to see if the aggregate key is valid
+        Secp256k1PublicKey::from_slice(self.aggregate_key.as_bytes())
+            .map_err(|_| op_error::VoteForAggregateKeyInvalidKey)?;
+
+        // Check to see if the signer key is valid
+        Secp256k1PublicKey::from_slice(self.signer_key.as_bytes())
+            .map_err(|_| op_error::VoteForAggregateKeyInvalidKey)?;
 
         Ok(())
     }
@@ -352,9 +341,7 @@ mod tests {
     #[test]
     fn test_raw_input_signer_key() {
         let aggregate_key = StacksPublicKeyBuffer([0x01; 33]);
-        // let signer_key = StacksPublicKeyBuffer([0x02; 33]);
         let signer_key = Secp256k1PublicKey::from_hex("040fadbbcea0ff3b05f03195b41cd991d7a0af8bd38559943aec99cbdaf0b22cc806b9a4f07579934774cc0c155e781d45c989f94336765e88a66d91cfb9f060b0").unwrap();
-        // let signer_pubkey = Secp256k1PublicKey::from_slice(signer_key.as_bytes()).unwrap();
         let tx = BitcoinTransaction {
             txid: Txid([0; 32]),
             vtxindex: 0,
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index c70b52e970..f02b97e23b 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -1948,7 +1948,7 @@ fn vote_for_aggregate_key_burn_op() {
 
     let stacker_pk = StacksPublicKey::from_private(&stacker_sk);
     let signer_key: StacksPublicKeyBuffer = stacker_pk.to_bytes_compressed().as_slice().into();
-    let aggregate_key = StacksPublicKeyBuffer([0x01; 33]);
+    let aggregate_key = signer_key.clone();
 
     let vote_for_aggregate_key_op =
         BlockstackOperationType::VoteForAggregateKey(VoteForAggregateKeyOp {
diff --git a/testnet/stacks-node/src/tests/neon_integrations.rs b/testnet/stacks-node/src/tests/neon_integrations.rs
index c3eaf15e3c..746b17cebc 100644
--- a/testnet/stacks-node/src/tests/neon_integrations.rs
+++ b/testnet/stacks-node/src/tests/neon_integrations.rs
@@ -2469,7 +2469,8 @@ fn vote_for_aggregate_key_burn_op_test() {
 
     let signer_key: StacksPublicKeyBuffer = signer_pk_bytes.clone().as_slice().into();
 
-    let aggregate_key = StacksPublicKeyBuffer([0x99; 33]);
+    let aggregate_pk = Secp256k1PublicKey::new();
+    let aggregate_key: StacksPublicKeyBuffer = aggregate_pk.to_bytes_compressed().as_slice().into();
 
     let signer_index = 0;
 
@@ -2534,6 +2535,8 @@ fn vote_for_aggregate_key_burn_op_test() {
                     .as_str()
                     .unwrap();
                 assert_eq!(agg_key, aggregate_key.to_hex());
+                let signer_key = vote_obj.get("signer_key").unwrap().as_str().unwrap();
+                assert_eq!(to_hex(&signer_pk_bytes), signer_key);
 
                 vote_for_aggregate_key_found = true;
             }

From 8a4c59dd2c7e8fa69658fd53316bd5bac298d6a9 Mon Sep 17 00:00:00 2001
From: ASuciuX <asuciu@hiro.so>
Date: Thu, 22 Feb 2024 20:17:22 +0200
Subject: [PATCH 0845/1166] feat: format yml code

---
 .github/workflows/pr-differences-mutants.yml | 42 ++++++++++----------
 1 file changed, 21 insertions(+), 21 deletions(-)

diff --git a/.github/workflows/pr-differences-mutants.yml b/.github/workflows/pr-differences-mutants.yml
index 7e02c7e13d..0e76c1c15a 100644
--- a/.github/workflows/pr-differences-mutants.yml
+++ b/.github/workflows/pr-differences-mutants.yml
@@ -8,7 +8,7 @@ on:
       - synchronize
       - ready_for_review
     paths:
-      - "**.rs"
+      - '**.rs'
 
 concurrency:
   group: pr-differences-${{ github.head_ref || github.ref || github.run_id }}
@@ -42,8 +42,8 @@ jobs:
     needs: check-big-packages-and-shards
 
     if: |
-      ${{ needs.check-big-packages-and-shards.outputs.run_small_packages == 'true' &&
-      needs.check-big-packages-and-shards.outputs.small_packages_with_shards == 'false' }}
+      needs.check-big-packages-and-shards.outputs.run_small_packages == 'true' &&
+      needs.check-big-packages-and-shards.outputs.small_packages_with_shards == 'false'
 
     runs-on: ubuntu-latest
 
@@ -51,7 +51,7 @@ jobs:
       - name: Run mutants on diffs
         uses: stacks-network/actions/stacks-core/mutation-testing/pr-differences@main
         with:
-          package: "small"
+          package: 'small'
 
   # Mutation testing - Execute on PR on small packages that have functions modified (run with strategy matrix shards)
   pr-differences-mutants-small-shards:
@@ -60,8 +60,8 @@ jobs:
     needs: check-big-packages-and-shards
 
     if: |
-      ${{ needs.check-big-packages-and-shards.outputs.run_small_packages == 'true' && 
-      needs.check-big-packages-and-shards.outputs.small_packages_with_shards == 'true' }}
+      needs.check-big-packages-and-shards.outputs.run_small_packages == 'true' && 
+      needs.check-big-packages-and-shards.outputs.small_packages_with_shards == 'true'
 
     runs-on: ubuntu-latest
 
@@ -75,7 +75,7 @@ jobs:
         uses: stacks-network/actions/stacks-core/mutation-testing/pr-differences@main
         with:
           shard: ${{ matrix.shard }}
-          package: "small"
+          package: 'small'
 
   # Mutation testing - Execute on PR on stackslib package (normal run, no shards)
   pr-differences-mutants-stackslib-normal:
@@ -84,8 +84,8 @@ jobs:
     needs: check-big-packages-and-shards
 
     if: |
-      ${{ needs.check-big-packages-and-shards.outputs.run_stackslib == 'true' && 
-      needs.check-big-packages-and-shards.outputs.stackslib_with_shards == 'false' }}
+      needs.check-big-packages-and-shards.outputs.run_stackslib == 'true' && 
+      needs.check-big-packages-and-shards.outputs.stackslib_with_shards == 'false'
 
     runs-on: ubuntu-latest
 
@@ -96,7 +96,7 @@ jobs:
           RUST_BACKTRACE: full
         uses: stacks-network/actions/stacks-core/mutation-testing/pr-differences@main
         with:
-          package: "stackslib"
+          package: 'stackslib'
 
   # Mutation testing - Execute on PR on stackslib package (run with strategy matrix shards)
   pr-differences-mutants-stackslib-shards:
@@ -105,8 +105,8 @@ jobs:
     needs: check-big-packages-and-shards
 
     if: |
-      ${{ needs.check-big-packages-and-shards.outputs.run_stackslib == 'true' && 
-      needs.check-big-packages-and-shards.outputs.stackslib_with_shards == 'true' }}
+      needs.check-big-packages-and-shards.outputs.run_stackslib == 'true' && 
+      needs.check-big-packages-and-shards.outputs.stackslib_with_shards == 'true'
 
     runs-on: ubuntu-latest
 
@@ -123,7 +123,7 @@ jobs:
         uses: stacks-network/actions/stacks-core/mutation-testing/pr-differences@main
         with:
           shard: ${{ matrix.shard }}
-          package: "stackslib"
+          package: 'stackslib'
 
   # Mutation testing - Execute on PR on stacks-node package (normal run, no shards)
   pr-differences-mutants-stacks-node-normal:
@@ -132,8 +132,8 @@ jobs:
     needs: check-big-packages-and-shards
 
     if: |
-      ${{ needs.check-big-packages-and-shards.outputs.run_stacks_node == 'true' && 
-      needs.check-big-packages-and-shards.outputs.stacks_node_with_shards == 'false' }}
+      needs.check-big-packages-and-shards.outputs.run_stacks_node == 'true' && 
+      needs.check-big-packages-and-shards.outputs.stacks_node_with_shards == 'false'
 
     runs-on: ubuntu-latest
 
@@ -144,7 +144,7 @@ jobs:
           RUST_BACKTRACE: full
         uses: stacks-network/actions/stacks-core/mutation-testing/pr-differences@main
         with:
-          package: "stacks-node"
+          package: 'stacks-node'
 
   # Mutation testing - Execute on PR on stacks-node package (run with strategy matrix shards)
   pr-differences-mutants-stacks-node-shards:
@@ -153,8 +153,8 @@ jobs:
     needs: check-big-packages-and-shards
 
     if: |
-      ${{ needs.check-big-packages-and-shards.outputs.run_stacks_node == 'true' && 
-      needs.check-big-packages-and-shards.outputs.stacks_node_with_shards == 'true' }}
+      needs.check-big-packages-and-shards.outputs.run_stacks_node == 'true' && 
+      needs.check-big-packages-and-shards.outputs.stacks_node_with_shards == 'true'
 
     runs-on: ubuntu-latest
 
@@ -171,7 +171,7 @@ jobs:
         uses: stacks-network/actions/stacks-core/mutation-testing/pr-differences@main
         with:
           shard: ${{ matrix.shard }}
-          package: "stacks-node"
+          package: 'stacks-node'
 
   # Mutation testing - Execute on PR on stacks-signer package (normal run, no shards)
   pr-differences-mutants-stacks-signer-normal:
@@ -180,7 +180,7 @@ jobs:
     needs: check-big-packages-and-shards
 
     if: |
-      ${{ needs.check-big-packages-and-shards.outputs.run_stacks_signer == 'true' }}
+      needs.check-big-packages-and-shards.outputs.run_stacks_signer == 'true'
 
     runs-on: ubuntu-latest
 
@@ -188,7 +188,7 @@ jobs:
       - name: Run Run mutants on diffs
         uses: stacks-network/actions/stacks-core/mutation-testing/pr-differences@main
         with:
-          package: "stacks-signer"
+          package: 'stacks-signer'
 
   # Output the mutants and fail the workflow if there are missed/timeout/unviable mutants
   output-mutants:

From 807352fc2f2d73d0e8af170bc3fe281766b34878 Mon Sep 17 00:00:00 2001
From: wileyj <2847772+wileyj@users.noreply.github.com>
Date: Thu, 22 Feb 2024 12:07:08 -0800
Subject: [PATCH 0846/1166] trigger ci workflow when merge queue requests it

---
 .github/workflows/ci.yml | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index aadda50df2..bb010862f9 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -2,6 +2,9 @@
 name: CI
 
 on:
+  merge_group:
+    types:
+      - checks_requested
   push:
     branches:
       - master

From da36a44fac3ba807544b93502ef6da95abb7f442 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@blockstack.com>
Date: Sat, 6 May 2023 15:40:03 -0500
Subject: [PATCH 0847/1166] add replay-block stacks-inspect method

---
 stackslib/src/main.rs | 156 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 156 insertions(+)

diff --git a/stackslib/src/main.rs b/stackslib/src/main.rs
index e964637b60..e0eddad5f5 100644
--- a/stackslib/src/main.rs
+++ b/stackslib/src/main.rs
@@ -1016,6 +1016,162 @@ simulating a miner.
         process::exit(0);
     }
 
+    if argv[1] == "replay-block" {
+        let index_block_hash = &argv[3];
+        let index_block_hash = StacksBlockId::from_hex(&index_block_hash).unwrap();
+        let chain_state_path = format!("{}/mainnet/chainstate/", &argv[2]);
+        let sort_db_path = format!("{}/mainnet/burnchain/sortition", &argv[2]);
+        let burn_db_path = format!("{}/mainnet/burnchain/burnchain.sqlite", &argv[2]);
+        let burnchain_blocks_db = BurnchainDB::open(&burn_db_path, false).unwrap();
+
+        let (mut chainstate, _) =
+            StacksChainState::open(true, CHAIN_ID_MAINNET, &chain_state_path, None).unwrap();
+
+        let mut sortdb =
+            SortitionDB::open(&sort_db_path, true, PoxConstants::mainnet_default()).unwrap();
+        let mut sort_tx = sortdb.tx_begin_at_tip();
+
+        let (mut chainstate_tx, clarity_instance) = chainstate
+            .chainstate_tx_begin()
+            .expect("Failed to start chainstate tx");
+        let next_staging_block =
+            StacksChainState::load_staging_block_info(&chainstate_tx.tx, &index_block_hash)
+                .expect("Failed to load staging block data")
+                .expect("No such index block hash in block database");
+        let next_microblocks =
+            StacksChainState::find_parent_microblock_stream(&chainstate_tx.tx, &next_staging_block)
+                .unwrap()
+                .unwrap();
+
+        let (burn_header_hash, burn_header_height, burn_header_timestamp, winning_block_txid) =
+            match SortitionDB::get_block_snapshot_consensus(
+                &sort_tx,
+                &next_staging_block.consensus_hash,
+            )
+            .unwrap()
+            {
+                Some(sn) => (
+                    sn.burn_header_hash,
+                    sn.block_height as u32,
+                    sn.burn_header_timestamp,
+                    sn.winning_block_txid,
+                ),
+                None => {
+                    // shouldn't happen
+                    panic!(
+                        "CORRUPTION: staging block {}/{} does not correspond to a burn block",
+                        &next_staging_block.consensus_hash, &next_staging_block.anchored_block_hash
+                    );
+                }
+            };
+
+        info!(
+            "Process block {}/{} = {} in burn block {}, parent microblock {}",
+            next_staging_block.consensus_hash,
+            next_staging_block.anchored_block_hash,
+            &index_block_hash,
+            &burn_header_hash,
+            &next_staging_block.parent_microblock_hash,
+        );
+
+        let parent_header_info =
+            match StacksChainState::get_parent_header_info(&mut chainstate_tx, &next_staging_block)
+                .unwrap()
+            {
+                Some(hinfo) => hinfo,
+                None => panic!("Failed to load parent head info for block"),
+            };
+
+        let block = StacksChainState::extract_stacks_block(&next_staging_block).unwrap();
+        let block_size = next_staging_block.block_data.len() as u64;
+
+        let parent_block_header = match &parent_header_info.anchored_header {
+            StacksBlockHeaderTypes::Epoch2(bh) => bh,
+            StacksBlockHeaderTypes::Nakamoto(_) => panic!("Nakamoto blocks not supported yet"),
+        };
+
+        if !StacksChainState::check_block_attachment(&parent_block_header, &block.header) {
+            let msg = format!(
+                "Invalid stacks block {}/{} -- does not attach to parent {}/{}",
+                &next_staging_block.consensus_hash,
+                block.block_hash(),
+                parent_header_info.anchored_header.block_hash(),
+                &parent_header_info.consensus_hash
+            );
+            warn!("{}", &msg);
+            process::exit(1);
+        }
+
+        // validation check -- validate parent microblocks and find the ones that connect the
+        // block's parent to this block.
+        let next_microblocks = StacksChainState::extract_connecting_microblocks(
+            &parent_header_info,
+            &next_staging_block,
+            &block,
+            next_microblocks,
+        )
+        .unwrap();
+        let (last_microblock_hash, last_microblock_seq) = match next_microblocks.len() {
+            0 => (EMPTY_MICROBLOCK_PARENT_HASH.clone(), 0),
+            _ => {
+                let l = next_microblocks.len();
+                (
+                    next_microblocks[l - 1].block_hash(),
+                    next_microblocks[l - 1].header.sequence,
+                )
+            }
+        };
+        assert_eq!(
+            next_staging_block.parent_microblock_hash,
+            last_microblock_hash
+        );
+        assert_eq!(
+            next_staging_block.parent_microblock_seq,
+            last_microblock_seq
+        );
+
+        // user supports were never activated
+        let user_supports = vec![];
+
+        let block_am = StacksChainState::find_stacks_tip_affirmation_map(
+            &burnchain_blocks_db,
+            sort_tx.tx(),
+            &next_staging_block.consensus_hash,
+            &next_staging_block.anchored_block_hash,
+        )
+        .unwrap();
+
+        let pox_constants = sort_tx.context.pox_constants.clone();
+
+        let epoch_receipt = match StacksChainState::append_block(
+            &mut chainstate_tx,
+            clarity_instance,
+            &mut sort_tx,
+            &pox_constants,
+            &parent_header_info,
+            &next_staging_block.consensus_hash,
+            &burn_header_hash,
+            burn_header_height,
+            burn_header_timestamp,
+            &block,
+            block_size,
+            &next_microblocks,
+            next_staging_block.commit_burn,
+            next_staging_block.sortition_burn,
+            &user_supports,
+            block_am.weight(),
+        ) {
+            Ok((receipt, _)) => {
+                info!("Block processed successfully!");
+                receipt
+            }
+            Err(e) => {
+                error!("Failed processing block"; "error" => ?e);
+                process::exit(1)
+            }
+        };
+    }
+
     if argv[1] == "replay-chainstate" {
         if argv.len() < 7 {
             eprintln!("Usage: {} OLD_CHAINSTATE_PATH OLD_SORTITION_DB_PATH OLD_BURNCHAIN_DB_PATH NEW_CHAINSTATE_PATH NEW_BURNCHAIN_DB_PATH", &argv[0]);

From 96edfb40028220aa833b484a7e115d1b23e67d44 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Wed, 10 May 2023 10:12:02 -0500
Subject: [PATCH 0848/1166] working replay-block command

---
 stackslib/src/main.rs | 25 ++++++++++++++++++++++---
 1 file changed, 22 insertions(+), 3 deletions(-)

diff --git a/stackslib/src/main.rs b/stackslib/src/main.rs
index e0eddad5f5..9dbe02c0e5 100644
--- a/stackslib/src/main.rs
+++ b/stackslib/src/main.rs
@@ -1027,17 +1027,35 @@ simulating a miner.
         let (mut chainstate, _) =
             StacksChainState::open(true, CHAIN_ID_MAINNET, &chain_state_path, None).unwrap();
 
-        let mut sortdb =
-            SortitionDB::open(&sort_db_path, true, PoxConstants::mainnet_default()).unwrap();
+        let mut sortdb = SortitionDB::connect(
+            &sort_db_path,
+            BITCOIN_MAINNET_FIRST_BLOCK_HEIGHT,
+            &BurnchainHeaderHash::from_hex(BITCOIN_MAINNET_FIRST_BLOCK_HASH).unwrap(),
+            BITCOIN_MAINNET_FIRST_BLOCK_TIMESTAMP.into(),
+            STACKS_EPOCHS_MAINNET.as_ref(),
+            PoxConstants::mainnet_default(),
+            true,
+        )
+        .unwrap();
         let mut sort_tx = sortdb.tx_begin_at_tip();
 
+        let blocks_path = chainstate.blocks_path.clone();
         let (mut chainstate_tx, clarity_instance) = chainstate
             .chainstate_tx_begin()
             .expect("Failed to start chainstate tx");
-        let next_staging_block =
+        let mut next_staging_block =
             StacksChainState::load_staging_block_info(&chainstate_tx.tx, &index_block_hash)
                 .expect("Failed to load staging block data")
                 .expect("No such index block hash in block database");
+
+        next_staging_block.block_data = StacksChainState::load_block_bytes(
+            &blocks_path,
+            &next_staging_block.consensus_hash,
+            &next_staging_block.anchored_block_hash,
+        )
+        .unwrap()
+        .unwrap_or(vec![]);
+
         let next_microblocks =
             StacksChainState::find_parent_microblock_stream(&chainstate_tx.tx, &next_staging_block)
                 .unwrap()
@@ -1160,6 +1178,7 @@ simulating a miner.
             next_staging_block.sortition_burn,
             &user_supports,
             block_am.weight(),
+            true,
         ) {
             Ok((receipt, _)) => {
                 info!("Block processed successfully!");

From 9c430dc12ca0891498b7ea5d1b578a3b4bf4855f Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Wed, 10 May 2023 16:26:19 -0500
Subject: [PATCH 0849/1166] allow replay-block to use a block prefix

---
 stackslib/src/main.rs | 95 ++++++++++++-------------------------------
 1 file changed, 27 insertions(+), 68 deletions(-)

diff --git a/stackslib/src/main.rs b/stackslib/src/main.rs
index 9dbe02c0e5..842416f375 100644
--- a/stackslib/src/main.rs
+++ b/stackslib/src/main.rs
@@ -1116,79 +1116,38 @@ simulating a miner.
                 parent_header_info.anchored_header.block_hash(),
                 &parent_header_info.consensus_hash
             );
-            warn!("{}", &msg);
             process::exit(1);
         }
+        let stacks_path = &argv[2];
+        let index_block_hash_prefix = &argv[3];
+        let staging_blocks_db_path = format!("{}/mainnet/chainstate/vm/index.sqlite", stacks_path);
+        let conn =
+            Connection::open_with_flags(&staging_blocks_db_path, OpenFlags::SQLITE_OPEN_READ_ONLY)
+                .unwrap();
+        let mut stmt = conn
+            .prepare(&format!(
+                "SELECT index_block_hash FROM staging_blocks WHERE index_block_hash LIKE \"{}%\"",
+                index_block_hash_prefix
+            ))
+            .unwrap();
+        let mut hashes_set = stmt.query(rusqlite::NO_PARAMS).unwrap();
 
-        // validation check -- validate parent microblocks and find the ones that connect the
-        // block's parent to this block.
-        let next_microblocks = StacksChainState::extract_connecting_microblocks(
-            &parent_header_info,
-            &next_staging_block,
-            &block,
-            next_microblocks,
-        )
-        .unwrap();
-        let (last_microblock_hash, last_microblock_seq) = match next_microblocks.len() {
-            0 => (EMPTY_MICROBLOCK_PARENT_HASH.clone(), 0),
-            _ => {
-                let l = next_microblocks.len();
-                (
-                    next_microblocks[l - 1].block_hash(),
-                    next_microblocks[l - 1].header.sequence,
-                )
-            }
-        };
-        assert_eq!(
-            next_staging_block.parent_microblock_hash,
-            last_microblock_hash
-        );
-        assert_eq!(
-            next_staging_block.parent_microblock_seq,
-            last_microblock_seq
-        );
-
-        // user supports were never activated
-        let user_supports = vec![];
-
-        let block_am = StacksChainState::find_stacks_tip_affirmation_map(
-            &burnchain_blocks_db,
-            sort_tx.tx(),
-            &next_staging_block.consensus_hash,
-            &next_staging_block.anchored_block_hash,
-        )
-        .unwrap();
-
-        let pox_constants = sort_tx.context.pox_constants.clone();
+        let mut index_block_hashes: Vec<String> = vec![];
+        while let Ok(Some(row)) = hashes_set.next() {
+            index_block_hashes.push(row.get(0).unwrap());
+        }
 
-        let epoch_receipt = match StacksChainState::append_block(
-            &mut chainstate_tx,
-            clarity_instance,
-            &mut sort_tx,
-            &pox_constants,
-            &parent_header_info,
-            &next_staging_block.consensus_hash,
-            &burn_header_hash,
-            burn_header_height,
-            burn_header_timestamp,
-            &block,
-            block_size,
-            &next_microblocks,
-            next_staging_block.commit_burn,
-            next_staging_block.sortition_burn,
-            &user_supports,
-            block_am.weight(),
-            true,
-        ) {
-            Ok((receipt, _)) => {
-                info!("Block processed successfully!");
-                receipt
-            }
-            Err(e) => {
-                error!("Failed processing block"; "error" => ?e);
-                process::exit(1)
+        let total = index_block_hashes.len();
+        let mut i = 1;
+        println!("Will check {} blocks.", total);
+        for index_block_hash in index_block_hashes.iter() {
+            if i % 100 == 0 {
+                println!("Checked {}...", i);
             }
-        };
+            i += 1;
+            replay_block(stacks_path, index_block_hash);
+        }
+        process::exit(0);
     }
 
     if argv[1] == "replay-chainstate" {

From e265679cbcc97bc6220953293554df4f7c1f1ff6 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Fri, 12 May 2023 13:48:40 -0500
Subject: [PATCH 0850/1166] skip blocks without microblock data or parent
 header info

---
 stackslib/src/main.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/stackslib/src/main.rs b/stackslib/src/main.rs
index 842416f375..4756958ea6 100644
--- a/stackslib/src/main.rs
+++ b/stackslib/src/main.rs
@@ -1147,6 +1147,7 @@ simulating a miner.
             i += 1;
             replay_block(stacks_path, index_block_hash);
         }
+        println!("Finished!");
         process::exit(0);
     }
 

From 3b8e97a58ad12845d857cca5b34ee9024bcb1cd1 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Thu, 8 Feb 2024 17:18:36 -0500
Subject: [PATCH 0851/1166] feat: Add `--prefix` and `--last` flags to
 `replay-block`

---
 stackslib/src/main.rs | 135 ------------------------------------------
 1 file changed, 135 deletions(-)

diff --git a/stackslib/src/main.rs b/stackslib/src/main.rs
index 4756958ea6..e964637b60 100644
--- a/stackslib/src/main.rs
+++ b/stackslib/src/main.rs
@@ -1016,141 +1016,6 @@ simulating a miner.
         process::exit(0);
     }
 
-    if argv[1] == "replay-block" {
-        let index_block_hash = &argv[3];
-        let index_block_hash = StacksBlockId::from_hex(&index_block_hash).unwrap();
-        let chain_state_path = format!("{}/mainnet/chainstate/", &argv[2]);
-        let sort_db_path = format!("{}/mainnet/burnchain/sortition", &argv[2]);
-        let burn_db_path = format!("{}/mainnet/burnchain/burnchain.sqlite", &argv[2]);
-        let burnchain_blocks_db = BurnchainDB::open(&burn_db_path, false).unwrap();
-
-        let (mut chainstate, _) =
-            StacksChainState::open(true, CHAIN_ID_MAINNET, &chain_state_path, None).unwrap();
-
-        let mut sortdb = SortitionDB::connect(
-            &sort_db_path,
-            BITCOIN_MAINNET_FIRST_BLOCK_HEIGHT,
-            &BurnchainHeaderHash::from_hex(BITCOIN_MAINNET_FIRST_BLOCK_HASH).unwrap(),
-            BITCOIN_MAINNET_FIRST_BLOCK_TIMESTAMP.into(),
-            STACKS_EPOCHS_MAINNET.as_ref(),
-            PoxConstants::mainnet_default(),
-            true,
-        )
-        .unwrap();
-        let mut sort_tx = sortdb.tx_begin_at_tip();
-
-        let blocks_path = chainstate.blocks_path.clone();
-        let (mut chainstate_tx, clarity_instance) = chainstate
-            .chainstate_tx_begin()
-            .expect("Failed to start chainstate tx");
-        let mut next_staging_block =
-            StacksChainState::load_staging_block_info(&chainstate_tx.tx, &index_block_hash)
-                .expect("Failed to load staging block data")
-                .expect("No such index block hash in block database");
-
-        next_staging_block.block_data = StacksChainState::load_block_bytes(
-            &blocks_path,
-            &next_staging_block.consensus_hash,
-            &next_staging_block.anchored_block_hash,
-        )
-        .unwrap()
-        .unwrap_or(vec![]);
-
-        let next_microblocks =
-            StacksChainState::find_parent_microblock_stream(&chainstate_tx.tx, &next_staging_block)
-                .unwrap()
-                .unwrap();
-
-        let (burn_header_hash, burn_header_height, burn_header_timestamp, winning_block_txid) =
-            match SortitionDB::get_block_snapshot_consensus(
-                &sort_tx,
-                &next_staging_block.consensus_hash,
-            )
-            .unwrap()
-            {
-                Some(sn) => (
-                    sn.burn_header_hash,
-                    sn.block_height as u32,
-                    sn.burn_header_timestamp,
-                    sn.winning_block_txid,
-                ),
-                None => {
-                    // shouldn't happen
-                    panic!(
-                        "CORRUPTION: staging block {}/{} does not correspond to a burn block",
-                        &next_staging_block.consensus_hash, &next_staging_block.anchored_block_hash
-                    );
-                }
-            };
-
-        info!(
-            "Process block {}/{} = {} in burn block {}, parent microblock {}",
-            next_staging_block.consensus_hash,
-            next_staging_block.anchored_block_hash,
-            &index_block_hash,
-            &burn_header_hash,
-            &next_staging_block.parent_microblock_hash,
-        );
-
-        let parent_header_info =
-            match StacksChainState::get_parent_header_info(&mut chainstate_tx, &next_staging_block)
-                .unwrap()
-            {
-                Some(hinfo) => hinfo,
-                None => panic!("Failed to load parent head info for block"),
-            };
-
-        let block = StacksChainState::extract_stacks_block(&next_staging_block).unwrap();
-        let block_size = next_staging_block.block_data.len() as u64;
-
-        let parent_block_header = match &parent_header_info.anchored_header {
-            StacksBlockHeaderTypes::Epoch2(bh) => bh,
-            StacksBlockHeaderTypes::Nakamoto(_) => panic!("Nakamoto blocks not supported yet"),
-        };
-
-        if !StacksChainState::check_block_attachment(&parent_block_header, &block.header) {
-            let msg = format!(
-                "Invalid stacks block {}/{} -- does not attach to parent {}/{}",
-                &next_staging_block.consensus_hash,
-                block.block_hash(),
-                parent_header_info.anchored_header.block_hash(),
-                &parent_header_info.consensus_hash
-            );
-            process::exit(1);
-        }
-        let stacks_path = &argv[2];
-        let index_block_hash_prefix = &argv[3];
-        let staging_blocks_db_path = format!("{}/mainnet/chainstate/vm/index.sqlite", stacks_path);
-        let conn =
-            Connection::open_with_flags(&staging_blocks_db_path, OpenFlags::SQLITE_OPEN_READ_ONLY)
-                .unwrap();
-        let mut stmt = conn
-            .prepare(&format!(
-                "SELECT index_block_hash FROM staging_blocks WHERE index_block_hash LIKE \"{}%\"",
-                index_block_hash_prefix
-            ))
-            .unwrap();
-        let mut hashes_set = stmt.query(rusqlite::NO_PARAMS).unwrap();
-
-        let mut index_block_hashes: Vec<String> = vec![];
-        while let Ok(Some(row)) = hashes_set.next() {
-            index_block_hashes.push(row.get(0).unwrap());
-        }
-
-        let total = index_block_hashes.len();
-        let mut i = 1;
-        println!("Will check {} blocks.", total);
-        for index_block_hash in index_block_hashes.iter() {
-            if i % 100 == 0 {
-                println!("Checked {}...", i);
-            }
-            i += 1;
-            replay_block(stacks_path, index_block_hash);
-        }
-        println!("Finished!");
-        process::exit(0);
-    }
-
     if argv[1] == "replay-chainstate" {
         if argv.len() < 7 {
             eprintln!("Usage: {} OLD_CHAINSTATE_PATH OLD_SORTITION_DB_PATH OLD_BURNCHAIN_DB_PATH NEW_CHAINSTATE_PATH NEW_BURNCHAIN_DB_PATH", &argv[0]);

From 04f1a211e747837cba62f0eac66c3765cb4568ca Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Thu, 25 Jan 2024 13:51:51 -0800
Subject: [PATCH 0852/1166] WIP: Add cast_aggregate_public_key_vote function to
 stacks_client

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/mod.rs           | 10 +--
 stacks-signer/src/client/stacks_client.rs | 98 +++++++++++++++--------
 stacks-signer/src/config.rs               |  8 ++
 stacks-signer/src/runloop.rs              | 52 +++++++++---
 4 files changed, 117 insertions(+), 51 deletions(-)

diff --git a/stacks-signer/src/client/mod.rs b/stacks-signer/src/client/mod.rs
index 4e23be7aff..5604000829 100644
--- a/stacks-signer/src/client/mod.rs
+++ b/stacks-signer/src/client/mod.rs
@@ -71,7 +71,7 @@ pub enum ClientError {
     #[error("Failed to serialize Clarity value: {0}")]
     ClaritySerializationError(#[from] SerializationError),
     /// Failed to parse a Clarity value
-    #[error("Recieved a malformed clarity value: {0}")]
+    #[error("Received a malformed clarity value: {0}")]
     MalformedClarityValue(ClarityValue),
     /// Invalid Clarity Name
     #[error("Invalid Clarity Name: {0}")]
@@ -87,13 +87,7 @@ pub enum ClientError {
     InvalidSigningKey,
     /// Clarity interpreter error
     #[error("Clarity interpreter error: {0}")]
-    ClarityError(ClarityError),
-}
-
-impl From<ClarityError> for ClientError {
-    fn from(e: ClarityError) -> ClientError {
-        ClientError::ClarityError(e)
-    }
+    ClarityError(#[from] ClarityError),
 }
 
 /// Retry a function F with an exponential backoff and notification on transient failure
diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index d1d1049348..7f06f35b15 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -30,7 +30,7 @@ use blockstack_lib::net::api::getaccount::AccountEntryResponse;
 use blockstack_lib::net::api::getinfo::RPCPeerInfoData;
 use blockstack_lib::net::api::getpoxinfo::RPCPoxInfoData;
 use blockstack_lib::net::api::postblock_proposal::NakamotoBlockProposal;
-use blockstack_lib::util_lib::boot::boot_code_id;
+use blockstack_lib::util_lib::boot::{boot_code_addr, boot_code_id};
 use clarity::vm::types::{PrincipalData, QualifiedContractIdentifier};
 use clarity::vm::{ClarityName, ContractName, Value as ClarityValue, Value};
 use serde_json::json;
@@ -60,6 +60,8 @@ pub struct StacksClient {
     chain_id: u32,
     /// The Client used to make HTTP connects
     stacks_node_client: reqwest::blocking::Client,
+    /// The stx transaction fee to use in microstacks
+    tx_fee: u64,
 }
 
 /// The supported epoch IDs
@@ -82,6 +84,7 @@ impl From<&Config> for StacksClient {
             tx_version: config.network.to_transaction_version(),
             chain_id: config.network.to_chain_id(),
             stacks_node_client: reqwest::blocking::Client::new(),
+            tx_fee: config.tx_fee,
         }
     }
 }
@@ -226,13 +229,6 @@ impl StacksClient {
         Ok(pox_data.reward_cycle_id)
     }
 
-    /// Helper function to retrieve the next possible nonce for the signer from the stacks node
-    #[allow(dead_code)]
-    fn get_next_possible_nonce(&self) -> Result<u64, ClientError> {
-        //FIXME: use updated RPC call to get mempool nonces. Depends on https://github.com/stacks-network/stacks-blockchain/issues/4000
-        todo!("Get the next possible nonce from the stacks node");
-    }
-
     /// Helper function to retrieve the account info from the stacks node for a specific address
     fn get_account_entry(
         &self,
@@ -303,29 +299,68 @@ impl StacksClient {
     }
 
     /// Sends a transaction to the stacks node for a modifying contract call
-    #[allow(dead_code)]
-    fn transaction_contract_call(
+    pub fn cast_vote_for_aggregate_public_key(
         &self,
-        contract_addr: &StacksAddress,
-        contract_name: ContractName,
-        function_name: ClarityName,
-        function_args: &[ClarityValue],
+        point: Point,
+        round: u64,
     ) -> Result<Txid, ClientError> {
-        debug!("Making a contract call to {contract_addr}.{contract_name}...");
+        debug!("Casting vote for aggregate public key to the mempool...");
+        let signed_tx = self.build_vote_for_aggregate_public_key(point, round)?;
+        self.submit_tx(&signed_tx)
+    }
+
+    /// Helper function to create a stacks transaction for a modifying contract call
+    pub fn build_vote_for_aggregate_public_key(
+        &self,
+        point: Point,
+        round: u64,
+    ) -> Result<StacksTransaction, ClientError> {
+        debug!("Building vote-for-aggregate-public-key transaction...");
+        let signer_index = 0; // TODO retreieve the index from the stacks node
         let nonce = self.get_account_nonce(&self.stacks_address)?;
-        // TODO: make tx_fee configurable
-        let signed_tx = Self::build_signed_contract_call_transaction(
-            contract_addr,
+        let contract_address = boot_code_addr(self.chain_id == CHAIN_ID_MAINNET);
+        let contract_name = ContractName::from(POX_4_NAME); //TODO update this to POX_4_VOTE_NAME when the contract is deployed
+        let function_name = ClarityName::from("vote-for-aggregate-public-key");
+        let function_args = &[
+            ClarityValue::UInt(signer_index as u128),
+            ClarityValue::UInt(round as u128),
+            ClarityValue::buff_from(point.compress().as_bytes().to_vec())?,
+        ];
+
+        let tx_payload = TransactionPayload::ContractCall(TransactionContractCall {
+            address: contract_address,
             contract_name,
             function_name,
-            function_args,
-            &self.stacks_private_key,
-            self.tx_version,
-            self.chain_id,
-            nonce,
-            10_000,
-        )?;
-        self.submit_tx(&signed_tx)
+            function_args: function_args.to_vec(),
+        });
+        let public_key = StacksPublicKey::from_private(&self.stacks_private_key);
+        let tx_auth = TransactionAuth::Standard(
+            TransactionSpendingCondition::new_singlesig_p2pkh(public_key).ok_or(
+                ClientError::TransactionGenerationFailure(format!(
+                    "Failed to create spending condition from public key: {}",
+                    public_key.to_hex()
+                )),
+            )?,
+        );
+
+        let mut unsigned_tx = StacksTransaction::new(self.tx_version, tx_auth, tx_payload);
+        unsigned_tx.set_tx_fee(self.tx_fee);
+        unsigned_tx.set_origin_nonce(nonce);
+
+        unsigned_tx.anchor_mode = TransactionAnchorMode::Any;
+        unsigned_tx.post_condition_mode = TransactionPostConditionMode::Allow;
+        unsigned_tx.chain_id = self.chain_id;
+
+        let mut tx_signer = StacksTransactionSigner::new(&unsigned_tx);
+        tx_signer
+            .sign_origin(&self.stacks_private_key)
+            .map_err(|e| ClientError::TransactionGenerationFailure(e.to_string()))?;
+
+        tx_signer
+            .get_tx()
+            .ok_or(ClientError::TransactionGenerationFailure(
+                "Failed to generate transaction from a transaction signer".to_string(),
+            ))
     }
 
     /// Helper function to submit a transaction to the Stacks node
@@ -759,13 +794,12 @@ mod tests {
     #[test]
     fn transaction_contract_call_should_succeed() {
         let config = TestConfig::new();
+        let point = Point::from(Scalar::random(&mut rand::thread_rng()));
+        let round = 10;
         let h = spawn(move || {
-            config.client.transaction_contract_call(
-                &config.client.stacks_address,
-                ContractName::from("contract-name"),
-                ClarityName::from("function-name"),
-                &[],
-            )
+            config
+                .client
+                .cast_vote_for_aggregate_public_key(point, round)
         });
         write_response(
             config.mock_server,
diff --git a/stacks-signer/src/config.rs b/stacks-signer/src/config.rs
index 2be974b4ff..f038cc6fed 100644
--- a/stacks-signer/src/config.rs
+++ b/stacks-signer/src/config.rs
@@ -39,6 +39,8 @@ use wsts::state_machine::PublicKeys;
 pub type SignerKeyIds = HashMap<u32, Vec<u32>>;
 
 const EVENT_TIMEOUT_MS: u64 = 5000;
+//TODO: make this zero once special cased transactions are allowed in the stacks node
+const TX_FEE_MS: u64 = 10_000;
 
 #[derive(thiserror::Error, Debug)]
 /// An error occurred parsing the provided configuration
@@ -151,6 +153,8 @@ pub struct Config {
     pub nonce_timeout: Option<Duration>,
     /// timeout to gather signature shares
     pub sign_timeout: Option<Duration>,
+    /// the STX tx fee to use in uSTX
+    pub tx_fee: u64,
 }
 
 /// Internal struct for loading up the config file signer data
@@ -192,6 +196,8 @@ struct RawConfigFile {
     pub nonce_timeout_ms: Option<u64>,
     /// timeout in (millisecs) to gather signature shares
     pub sign_timeout_ms: Option<u64>,
+    /// the STX tx fee to use in uSTX
+    pub tx_fee_ms: Option<u64>,
 }
 
 impl RawConfigFile {
@@ -324,6 +330,7 @@ impl TryFrom<RawConfigFile> for Config {
             dkg_private_timeout,
             nonce_timeout,
             sign_timeout,
+            tx_fee: raw_data.tx_fee_ms.unwrap_or(TX_FEE_MS),
         })
     }
 }
@@ -372,6 +379,7 @@ mod tests {
             dkg_private_timeout_ms: None,
             nonce_timeout_ms: None,
             sign_timeout_ms: None,
+            tx_fee_ms: None,
         };
         overrides(&mut config);
         config
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 1804466cb3..16b254cc8f 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -17,6 +17,7 @@ use std::collections::VecDeque;
 use std::sync::mpsc::Sender;
 use std::time::Duration;
 
+use blockstack_lib::burnchains::Txid;
 use blockstack_lib::chainstate::nakamoto::NakamotoBlock;
 use blockstack_lib::chainstate::stacks::StacksTransaction;
 use blockstack_lib::net::api::postblock_proposal::BlockValidateResponse;
@@ -136,7 +137,7 @@ pub struct RunLoop<C> {
     pub blocks: HashMap<Sha512Trunc256Sum, BlockInfo>,
     /// Transactions that we expect to see in the next block
     // TODO: fill this in and do proper garbage collection
-    pub transactions: Vec<StacksTransaction>,
+    pub transactions: Vec<Txid>,
     /// This signer's ID
     pub signer_id: u32,
     /// The signer set for this runloop
@@ -773,7 +774,7 @@ impl<C: Coordinator> RunLoop<C> {
                 OperationResult::SignTaproot(_) => {
                     debug!("Signer #{}: Received a signature result for a taproot signature. Nothing to broadcast as we currently sign blocks with a FROST signature.", self.signer_id);
                 }
-                OperationResult::Dkg(_point) => {
+                OperationResult::Dkg(point) => {
                     // TODO: cast the aggregate public key for the latest round here
                     // Broadcast via traditional methods to the stacks node if we are pre nakamoto or we cannot determine our Epoch
                     let epoch = self
@@ -786,17 +787,46 @@ impl<C: Coordinator> RunLoop<C> {
                         }
                         EpochId::Epoch25 => {
                             debug!("Signer #{}: Received a DKG result, but are in epoch 2.5. Broadcast the transaction to the mempool.", self.signer_id);
-                            //TODO: Cast the aggregate public key vote here
+                            match self
+                                .stacks_client
+                                .cast_vote_for_aggregate_public_key(point.clone(), 0)
+                            {
+                                Ok(txid) => {
+                                    self.transactions.push(txid);
+                                    println!(
+                                        "Successfully cast aggregate public key vote: {:?}",
+                                        txid
+                                    )
+                                }
+                                Err(e) => {
+                                    warn!("Failed to cast aggregate public key vote: {:?}", e);
+                                }
+                            }
                         }
                         EpochId::Epoch30 => {
-                            debug!("Signer #{}: Received a DKG result, but are in epoch 3. Broadcast the transaction to stackerDB.", self.signer_id);
-                            let signer_message =
-                                SignerMessage::Transactions(self.transactions.clone());
-                            if let Err(e) = self.stackerdb.send_message_with_retry(signer_message) {
-                                warn!(
-                                    "Signer #{}: Failed to update transactions in stacker-db: {:?}",
-                                    self.signer_id, e
-                                );
+                            // TODO: get the latest round
+                            match self
+                                .stacks_client
+                                .build_vote_for_aggregate_public_key(point.clone(), 0)
+                            {
+                                Ok(transaction) => {
+                                    // TODO retreive transactions from stackerdb, append to it, and send back
+                                    debug!("Signer #{}: Received a DKG result, but are in epoch 3. Broadcast the transaction to stackerDB.", self.signer_id);
+                                    let signer_message =
+                                        SignerMessage::Transactions(vec![transaction]);
+                                    if let Err(e) =
+                                        self.stackerdb.send_message_with_retry(signer_message)
+                                    {
+                                        warn!(
+                                            "Signer #{}: Failed to update transactions in stacker-db: {:?}",
+                                            self.signer_id, e
+                                        );
+                                    }
+                                }
+                                Err(e) => {
+                                    warn!("Signer #{}: Failed to build a vote transaction for the aggregate public key: {:?}", self.signer_id, e);
+                                    continue;
+                                }
                             }
                         }
                     }

From 32f407a0159c391343be7e88261c9214ebd493bd Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 7 Feb 2024 12:06:22 -0800
Subject: [PATCH 0853/1166] Add Signer struct to handle multiple reward cycles

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 libsigner/src/events.rs                       |   15 +-
 libsigner/src/tests/mod.rs                    |    9 +-
 stacks-signer/src/cli.rs                      |   13 +-
 stacks-signer/src/client/mod.rs               |  223 ++-
 stacks-signer/src/client/stackerdb.rs         |  168 +-
 stacks-signer/src/client/stacks_client.rs     |  544 ++++--
 stacks-signer/src/config.rs                   |  148 +-
 stacks-signer/src/lib.rs                      |    4 +-
 stacks-signer/src/main.rs                     |   73 +-
 stacks-signer/src/runloop.rs                  | 1642 +++--------------
 stacks-signer/src/signer.rs                   | 1463 +++++++++++++++
 stacks-signer/src/tests/conf/signer-0.toml    |    9 -
 stacks-signer/src/tests/conf/signer-1.toml    |    9 -
 stacks-signer/src/tests/conf/signer-2.toml    |    9 -
 stacks-signer/src/tests/conf/signer-3.toml    |    9 -
 stacks-signer/src/tests/conf/signer-4.toml    |    9 -
 stacks-signer/src/tests/config.rs             |    1 -
 .../tests/contracts/signers-stackerdb.clar    |   59 -
 stacks-signer/src/tests/mod.rs                |   17 -
 stacks-signer/src/utils.rs                    |  149 --
 .../chainstate/nakamoto/coordinator/tests.rs  |   12 +-
 .../src/tests/nakamoto_integrations.rs        |    9 +-
 testnet/stacks-node/src/tests/signer.rs       |   96 +-
 23 files changed, 2573 insertions(+), 2117 deletions(-)
 create mode 100644 stacks-signer/src/signer.rs
 delete mode 100644 stacks-signer/src/tests/config.rs
 delete mode 100644 stacks-signer/src/tests/contracts/signers-stackerdb.clar
 delete mode 100644 stacks-signer/src/tests/mod.rs
 delete mode 100644 stacks-signer/src/utils.rs

diff --git a/libsigner/src/events.rs b/libsigner/src/events.rs
index 588d025838..849bb92902 100644
--- a/libsigner/src/events.rs
+++ b/libsigner/src/events.rs
@@ -56,7 +56,7 @@ pub enum SignerEvent {
     /// The miner proposed blocks for signers to observe and sign
     ProposedBlocks(Vec<NakamotoBlock>),
     /// The signer messages for other signers and miners to observe
-    SignerMessages(Vec<SignerMessage>),
+    SignerMessages(u32, Vec<SignerMessage>),
     /// A new block proposal validation response from the node
     BlockValidationResponse(BlockValidateResponse),
     /// Status endpoint request
@@ -126,8 +126,6 @@ pub trait EventReceiver {
 
 /// Event receiver for Signer events
 pub struct SignerEventReceiver {
-    /// stacker db contracts we're listening for
-    pub stackerdb_contract_ids: Vec<QualifiedContractIdentifier>,
     /// Address we bind to
     local_addr: Option<SocketAddr>,
     /// server socket that listens for HTTP POSTs from the node
@@ -143,12 +141,8 @@ pub struct SignerEventReceiver {
 impl SignerEventReceiver {
     /// Make a new Signer event receiver, and return both the receiver and the read end of a
     /// channel into which node-received data can be obtained.
-    pub fn new(
-        contract_ids: Vec<QualifiedContractIdentifier>,
-        is_mainnet: bool,
-    ) -> SignerEventReceiver {
+    pub fn new(is_mainnet: bool) -> SignerEventReceiver {
         SignerEventReceiver {
-            stackerdb_contract_ids: contract_ids,
             http_server: None,
             local_addr: None,
             out_channels: vec![],
@@ -349,13 +343,16 @@ fn process_stackerdb_event(
     } else if event.contract_id.name.to_string().starts_with(SIGNERS_NAME)
         && event.contract_id.issuer.1 == [0u8; 20]
     {
+        // TODO: check contract id first u8 to determine if its even or odd reward cycle
+        let reward_cycle_modulus = 0;
         // signer-XXX-YYY boot contract
         let signer_messages: Vec<SignerMessage> = event
             .modified_slots
             .iter()
             .filter_map(|chunk| read_next::<SignerMessage, _>(&mut &chunk.data[..]).ok())
             .collect();
-        SignerEvent::SignerMessages(signer_messages)
+        //
+        SignerEvent::SignerMessages(reward_cycle_modulus, signer_messages)
     } else {
         info!(
             "[{:?}] next_event got event from an unexpected contract id {}, return OK so other side doesn't keep sending this",
diff --git a/libsigner/src/tests/mod.rs b/libsigner/src/tests/mod.rs
index 970cc3a5c2..d3840122c1 100644
--- a/libsigner/src/tests/mod.rs
+++ b/libsigner/src/tests/mod.rs
@@ -96,7 +96,7 @@ impl SignerRunLoop<Vec<SignerEvent>, Command> for SimpleRunLoop {
 #[test]
 fn test_simple_signer() {
     let contract_id = boot_code_id(SIGNERS_NAME, false);
-    let ev = SignerEventReceiver::new(vec![contract_id.clone()], false);
+    let ev = SignerEventReceiver::new(false);
     let (_cmd_send, cmd_recv) = channel();
     let (res_send, _res_recv) = channel();
     let max_events = 5;
@@ -160,7 +160,7 @@ fn test_simple_signer() {
         .map(|chunk| {
             let msg = chunk.modified_slots[0].data.clone();
             let signer_message = read_next::<SignerMessage, _>(&mut &msg[..]).unwrap();
-            SignerEvent::SignerMessages(vec![signer_message])
+            SignerEvent::SignerMessages(0, vec![signer_message])
         })
         .collect();
 
@@ -170,10 +170,7 @@ fn test_simple_signer() {
 
 #[test]
 fn test_status_endpoint() {
-    let contract_id =
-        QualifiedContractIdentifier::parse("ST2DS4MSWSGJ3W9FBC6BVT0Y92S345HY8N3T6AV7R.signers")
-            .unwrap(); // TODO: change to boot_code_id(SIGNERS_NAME, false) when .signers is deployed
-    let ev = SignerEventReceiver::new(vec![contract_id], false);
+    let ev = SignerEventReceiver::new(false);
     let (_cmd_send, cmd_recv) = channel();
     let (res_send, _res_recv) = channel();
     let max_events = 1;
diff --git a/stacks-signer/src/cli.rs b/stacks-signer/src/cli.rs
index 48cd9a87fe..639b57f3a2 100644
--- a/stacks-signer/src/cli.rs
+++ b/stacks-signer/src/cli.rs
@@ -126,6 +126,10 @@ pub struct SignArgs {
     /// Path to config file
     #[arg(long, value_name = "FILE")]
     pub config: PathBuf,
+    /// The reward cycle the signer is registered for and wants to sign for
+    /// Note: this must be the current reward cycle of the node
+    #[arg(long, short)]
+    pub reward_cycle: u64,
     /// The data to sign
     #[arg(required = false, value_parser = parse_data)]
     // Note this weirdness is due to https://github.com/clap-rs/clap/discussions/4695
@@ -139,6 +143,9 @@ pub struct RunDkgArgs {
     /// Path to config file
     #[arg(long, value_name = "FILE")]
     pub config: PathBuf,
+    /// The reward cycle the signer is registered for and wants to peform DKG for
+    #[arg(long, short)]
+    pub reward_cycle: u64,
 }
 
 #[derive(Parser, Debug, Clone)]
@@ -147,9 +154,6 @@ pub struct GenerateFilesArgs {
     /// The Stacks node to connect to
     #[arg(long)]
     pub host: SocketAddr,
-    /// The signers stacker-db contract to use. Must be in the format of "STACKS_ADDRESS.CONTRACT_NAME"
-    #[arg(short, long, value_parser = parse_contract)]
-    pub signers_contract: QualifiedContractIdentifier,
     #[arg(
         long,
         required_unless_present = "private_keys",
@@ -160,9 +164,6 @@ pub struct GenerateFilesArgs {
     #[clap(long, value_name = "FILE")]
     /// A path to a file containing a list of hexadecimal Stacks private keys of the signers
     pub private_keys: Option<PathBuf>,
-    #[arg(long)]
-    /// The total number of key ids to distribute among the signers
-    pub num_keys: u32,
     #[arg(long, value_parser = parse_network)]
     /// The network to use. One of "mainnet", "testnet", or "mocknet".
     pub network: Network,
diff --git a/stacks-signer/src/client/mod.rs b/stacks-signer/src/client/mod.rs
index 5604000829..c1e1ea492c 100644
--- a/stacks-signer/src/client/mod.rs
+++ b/stacks-signer/src/client/mod.rs
@@ -23,7 +23,6 @@ use std::time::Duration;
 
 use clarity::vm::errors::Error as ClarityError;
 use clarity::vm::types::serialization::SerializationError;
-use clarity::vm::Value as ClarityValue;
 use libsigner::RPCError;
 use libstackerdb::Error as StackerDBError;
 use slog::slog_debug;
@@ -72,7 +71,7 @@ pub enum ClientError {
     ClaritySerializationError(#[from] SerializationError),
     /// Failed to parse a Clarity value
     #[error("Received a malformed clarity value: {0}")]
-    MalformedClarityValue(ClarityValue),
+    MalformedClarityValue(String),
     /// Invalid Clarity Name
     #[error("Invalid Clarity Name: {0}")]
     InvalidClarityName(String),
@@ -88,6 +87,21 @@ pub enum ClientError {
     /// Clarity interpreter error
     #[error("Clarity interpreter error: {0}")]
     ClarityError(#[from] ClarityError),
+    /// Our stacks address does not belong to a registered signer
+    #[error("Our stacks address does not belong to a registered signer")]
+    NotRegistered,
+    /// Reward set not yet calculated for the given reward cycle
+    #[error("Reward set not yet calculated for reward cycle: {0}")]
+    RewardSetNotYetCalculated(u64),
+    /// Malformed reward set
+    #[error("Malformed contract data: {0}")]
+    MalformedContractData(String),
+    /// No reward set exists for the given reward cycle
+    #[error("No reward set exists for reward cycle {0}")]
+    NoRewardSet(u64),
+    /// Reward set contained corrupted data
+    #[error("{0}")]
+    CorruptedRewardSet(String),
 }
 
 /// Retry a function F with an exponential backoff and notification on transient failure
@@ -97,7 +111,7 @@ where
 {
     let notify = |_err, dur| {
         debug!(
-            "Failed to connect to stacks-node. Next attempt in {:?}",
+            "Failed to connect to stacks node and/or deserialize its response. Next attempt in {:?}",
             dur
         );
     };
@@ -115,18 +129,29 @@ pub(crate) mod tests {
     use std::io::{Read, Write};
     use std::net::{SocketAddr, TcpListener};
 
+    use clarity::vm::types::{ResponseData, TupleData};
+    use clarity::vm::{ClarityName, Value as ClarityValue};
+    use hashbrown::{HashMap, HashSet};
+    use rand_core::OsRng;
+    use stacks_common::types::chainstate::{StacksAddress, StacksPublicKey};
+    use wsts::curve::ecdsa;
+    use wsts::curve::point::{Compressed, Point};
+    use wsts::curve::scalar::Scalar;
+    use wsts::state_machine::PublicKeys;
+
     use super::*;
     use crate::config::Config;
 
-    pub(crate) struct TestConfig {
-        pub(crate) mock_server: TcpListener,
-        pub(crate) client: StacksClient,
-        pub(crate) stackerdb: StackerDB,
-        pub(crate) config: Config,
+    pub struct TestConfig {
+        pub mock_server: TcpListener,
+        pub client: StacksClient,
+        pub stackerdb: StackerDB,
+        pub config: Config,
     }
 
     impl TestConfig {
-        pub(crate) fn new() -> Self {
+        /// Construct a new TestConfig which will spin up a stacker db, stacks client, and a mock tcp server
+        pub fn new() -> Self {
             let mut config = Config::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
 
             let mut mock_server_addr = SocketAddr::from(([127, 0, 0, 1], 0));
@@ -138,7 +163,7 @@ pub(crate) mod tests {
             config.node_host = mock_server_addr;
 
             let client = StacksClient::from(&config);
-            let stackerdb = StackerDB::from(&config);
+            let stackerdb = StackerDB::new_with_config(&config, 0);
             Self {
                 mock_server,
                 client,
@@ -147,11 +172,12 @@ pub(crate) mod tests {
             }
         }
 
-        pub(crate) fn from_config(config: Config) -> Self {
+        /// Construct a new TestConfig from the provided Config. This will spin up a stacker db, stacks client, and a mock tcp server
+        pub fn from_config(config: Config) -> Self {
             let mock_server = TcpListener::bind(config.node_host).unwrap();
 
             let client = StacksClient::from(&config);
-            let stackerdb = StackerDB::from(&config);
+            let stackerdb = StackerDB::new_with_config(&config, 0);
             Self {
                 mock_server,
                 client,
@@ -161,7 +187,8 @@ pub(crate) mod tests {
         }
     }
 
-    pub(crate) fn write_response(mock_server: TcpListener, bytes: &[u8]) -> [u8; 1024] {
+    /// Write a response to the mock server and return the request bytes
+    pub fn write_response(mock_server: TcpListener, bytes: &[u8]) -> [u8; 1024] {
         debug!("Writing a response...");
         let mut request_bytes = [0u8; 1024];
         {
@@ -171,4 +198,174 @@ pub(crate) mod tests {
         }
         request_bytes
     }
+
+    /// Build a response for the get_signers request
+    /// TODO: fix this
+    pub fn build_get_signers_response(config: &Config) -> (String, Vec<StacksAddress>) {
+        let (_generated_public_keys, _signer_key_ids, stacks_addresses, _) = generate_public_keys(
+            10,
+            4000,
+            Some(
+                ecdsa::PublicKey::new(&config.ecdsa_private_key)
+                    .expect("Failed to create public key."),
+            ),
+        );
+        let mut list_data = vec![];
+        for stacks_address in stacks_addresses.clone() {
+            let tuple_data = vec![
+                (
+                    ClarityName::from("signer"),
+                    ClarityValue::Principal(stacks_address.into()),
+                ),
+                (ClarityName::from("weight"), ClarityValue::UInt(1 as u128)),
+            ];
+            let tuple = ClarityValue::Tuple(
+                TupleData::from_data(tuple_data).expect("Failed to create tuple data"),
+            );
+            list_data.push(tuple);
+        }
+
+        let result_data =
+            ClarityValue::cons_list_unsanitized(list_data).expect("Failed to construct list data");
+        let response_clarity = ClarityValue::Response(ResponseData {
+            committed: true,
+            data: Box::new(result_data),
+        });
+        let hex = response_clarity
+            .serialize_to_hex()
+            .expect("Failed to serialize clarity value");
+        (
+            format!("HTTP/1.1 200 OK\n\n{{\"okay\":true,\"result\":\"{hex}\"}}"),
+            stacks_addresses,
+        )
+    }
+
+    /// Build a response for the get_last_round request
+    pub fn build_get_last_round_response(round: u64) -> String {
+        let response = ClarityValue::okay(ClarityValue::UInt(round as u128))
+            .expect("Failed to create response");
+        let hex = response
+            .serialize_to_hex()
+            .expect("Failed to serialize hex value");
+        format!("HTTP/1.1 200 OK\n\n{{\"okay\":true,\"result\":\"{hex}\"}}",)
+    }
+
+    /// Build a response for the get_account_nonce request
+    pub fn build_account_nonce_response(nonce: u64) -> String {
+        format!("HTTP/1.1 200 OK\n\n{{\"nonce\":{nonce},\"balance\":\"0x00000000000000000000000000000000\",\"locked\":\"0x00000000000000000000000000000000\",\"unlock_height\":0}}")
+    }
+
+    /// Build a response to get_pox_data where it returns a specific reward cycle id and block height
+    pub fn build_get_pox_data_response(
+        reward_cycle: u64,
+        prepare_phase_start_block_height: u64,
+    ) -> String {
+        format!("HTTP/1.1 200 Ok\n\n{{\"contract_id\":\"ST000000000000000000002AMW42H.pox-3\",\"pox_activation_threshold_ustx\":829371801288885,\"first_burnchain_block_height\":2000000,\"current_burnchain_block_height\":2572192,\"prepare_phase_block_length\":50,\"reward_phase_block_length\":1000,\"reward_slots\":2000,\"rejection_fraction\":12,\"total_liquid_supply_ustx\":41468590064444294,\"current_cycle\":{{\"id\":544,\"min_threshold_ustx\":5190000000000,\"stacked_ustx\":853258144644000,\"is_pox_active\":true}},\"next_cycle\":{{\"id\":545,\"min_threshold_ustx\":5190000000000,\"min_increment_ustx\":5183573758055,\"stacked_ustx\":847278759574000,\"prepare_phase_start_block_height\":{prepare_phase_start_block_height},\"blocks_until_prepare_phase\":8,\"reward_phase_start_block_height\":2572250,\"blocks_until_reward_phase\":58,\"ustx_until_pox_rejection\":4976230807733304}},\"min_amount_ustx\":5190000000000,\"prepare_cycle_length\":50,\"reward_cycle_id\":{reward_cycle},\"reward_cycle_length\":1050,\"rejection_votes_left_required\":4976230807733304,\"next_reward_cycle_in\":58,\"contract_versions\":[{{\"contract_id\":\"ST000000000000000000002AMW42H.pox\",\"activation_burnchain_block_height\":2000000,\"first_reward_cycle_id\":0}},{{\"contract_id\":\"ST000000000000000000002AMW42H.pox-2\",\"activation_burnchain_block_height\":2422102,\"first_reward_cycle_id\":403}},{{\"contract_id\":\"ST000000000000000000002AMW42H.pox-3\",\"activation_burnchain_block_height\":2432545,\"first_reward_cycle_id\":412}}]}}")
+    }
+
+    /// Build a response for the get_aggregate_public_key request
+    pub fn build_get_aggregate_public_key_response(point: Point) -> String {
+        let clarity_value = ClarityValue::some(
+            ClarityValue::buff_from(point.compress().as_bytes().to_vec())
+                .expect("BUG: Failed to create clarity value from point"),
+        )
+        .expect("BUG: Failed to create clarity value from point");
+        let hex = clarity_value
+            .serialize_to_hex()
+            .expect("Failed to serialize clarity value");
+        format!("HTTP/1.1 200 OK\n\n{{\"okay\":true,\"result\":\"{hex}\"}}")
+    }
+
+    /// Build a response for the get_peer_info request with a specific stacks tip height and consensus hash
+    pub fn build_get_peer_info_response(stacks_tip_height: u64, consensus_hash: String) -> String {
+        format!(
+            "HTTP/1.1 200 OK\n\n{{\"stacks_tip_height\":{stacks_tip_height},\"stacks_tip_consensus_hash\":\"{consensus_hash}\",\"peer_version\":4207599113,\"pox_consensus\":\"64c8c3049ff6b939c65828e3168210e6bb32d880\",\"burn_block_height\":2575799,\"stable_pox_consensus\":\"72277bf9a3b115e13c0942825480d6cee0e9a0e8\",\"stable_burn_block_height\":2575792,\"server_version\":\"stacks-node d657bdd (feat/epoch-2.4:d657bdd, release build, linux [x86_64])\",\"network_id\":2147483648,\"parent_network_id\":118034699,\"stacks_tip\":\"77219884fe434c0fa270d65592b4f082ab3e5d9922ac2bdaac34310aedc3d298\",\"genesis_chainstate_hash\":\"74237aa39aa50a83de11a4f53e9d3bb7d43461d1de9873f402e5453ae60bc59b\",\"unanchored_tip\":\"dde44222b6e6d81583b6b9c55db83e8716943ae9d0dc332fc39448ddd9b99dc2\",\"unanchored_seq\":0,\"exit_at_block_height\":null,\"node_public_key\":\"023c940136d5795d9dd82c0e87f4dd6a2a1db245444e7d70e34bb9605c3c3917b0\",\"node_public_key_hash\":\"e26cce8f6abe06b9fc81c3b11bcc821d2f1b8fd0\"}}",
+        )
+    }
+
+    /// Generate some random public keys given a num of signers and a num of key ids
+    /// Optionally include a signer pubilc key to set as the first signer id
+    pub fn generate_public_keys(
+        num_signers: u32,
+        num_keys: u32,
+        signer_key: Option<ecdsa::PublicKey>,
+    ) -> (
+        PublicKeys,
+        HashMap<u32, HashSet<u32>>,
+        Vec<StacksAddress>,
+        HashMap<u32, Point>,
+    ) {
+        assert!(
+            num_signers > 0,
+            "Cannot generate 0 signers...Specify at least 1 signer."
+        );
+        assert!(
+            num_keys > 0,
+            "Cannot generate 0 keys for the provided signers...Specify at least 1 key."
+        );
+        let mut public_keys = PublicKeys {
+            signers: HashMap::new(),
+            key_ids: HashMap::new(),
+        };
+        let rng = &mut OsRng;
+        let num_keys = num_keys / num_signers;
+        let remaining_keys = num_keys % num_signers;
+        let mut signer_key_ids = HashMap::new();
+        let mut addresses = vec![];
+        let mut start_key_id = 1u32;
+        let mut end_key_id = start_key_id;
+        let mut signer_public_keys = HashMap::new();
+        // Key ids start from 1 hence the wrapping adds everywhere
+        for signer_id in 0..num_signers {
+            end_key_id = if signer_id.wrapping_add(1) == num_signers {
+                end_key_id.wrapping_add(remaining_keys)
+            } else {
+                end_key_id.wrapping_add(num_keys)
+            };
+            if signer_id == 0 {
+                if let Some(signer_key) = signer_key {
+                    let address = StacksAddress::p2pkh(
+                        false,
+                        &StacksPublicKey::from_slice(signer_key.to_bytes().as_slice())
+                            .expect("Failed to create stacks public key"),
+                    );
+                    addresses.push(address);
+                    let signer_public_key =
+                        Point::try_from(&Compressed::from(signer_key.to_bytes())).unwrap();
+                    signer_public_keys.insert(signer_id, signer_public_key);
+                    public_keys.signers.insert(signer_id, signer_key.clone());
+                    for k in start_key_id..end_key_id {
+                        public_keys.key_ids.insert(k, signer_key.clone());
+                        signer_key_ids
+                            .entry(signer_id)
+                            .or_insert(HashSet::new())
+                            .insert(k);
+                    }
+                    start_key_id = end_key_id;
+                    continue;
+                }
+            }
+            let private_key = Scalar::random(rng);
+            let public_key = ecdsa::PublicKey::new(&private_key).unwrap();
+            let signer_public_key =
+                Point::try_from(&Compressed::from(public_key.to_bytes())).unwrap();
+            signer_public_keys.insert(signer_id, signer_public_key);
+            public_keys.signers.insert(signer_id, public_key.clone());
+            for k in start_key_id..end_key_id {
+                public_keys.key_ids.insert(k, public_key.clone());
+                signer_key_ids
+                    .entry(signer_id)
+                    .or_insert(HashSet::new())
+                    .insert(k);
+            }
+            let address = StacksAddress::p2pkh(
+                false,
+                &StacksPublicKey::from_slice(public_key.to_bytes().as_slice())
+                    .expect("Failed to create stacks public key"),
+            );
+            addresses.push(address);
+            start_key_id = end_key_id;
+        }
+        (public_keys, signer_key_ids, addresses, signer_public_keys)
+    }
 }
diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index 0889b9fa87..856db34de1 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -18,6 +18,7 @@ use std::net::SocketAddr;
 
 use blockstack_lib::chainstate::nakamoto::signer_set::NakamotoSigners;
 use blockstack_lib::chainstate::stacks::StacksTransaction;
+use blockstack_lib::util_lib::boot::boot_code_addr;
 use clarity::vm::types::QualifiedContractIdentifier;
 use clarity::vm::ContractName;
 use hashbrown::HashMap;
@@ -26,97 +27,92 @@ use libstackerdb::{StackerDBChunkAckData, StackerDBChunkData};
 use slog::{slog_debug, slog_warn};
 use stacks_common::codec::{read_next, StacksMessageCodec};
 use stacks_common::consts::SIGNER_SLOTS_PER_USER;
-use stacks_common::types::chainstate::{StacksAddress, StacksPrivateKey, StacksPublicKey};
+use stacks_common::types::chainstate::StacksPrivateKey;
 use stacks_common::{debug, warn};
 
 use super::ClientError;
 use crate::client::retry_with_exponential_backoff;
 use crate::config::Config;
+use crate::signer::StacksNodeInfo;
 
 /// The StackerDB client for communicating with the .signers contract
 pub struct StackerDB {
-    /// The stacker-db session for the signer StackerDB.  Used for querying signer addresses and
-    /// other system metadata.
-    signers_stackerdb_session: StackerDBSession,
     /// The stacker-db sessions for each signer set and message type.
-    /// Maps (signer-set, message ID) to the DB session.
-    signers_message_stackerdb_sessions: HashMap<(u32, u32), StackerDBSession>,
+    /// Maps message ID to the DB session.
+    signers_message_stackerdb_sessions: HashMap<u32, StackerDBSession>,
     /// The private key used in all stacks node communications
     stacks_private_key: StacksPrivateKey,
     /// A map of a (signer-set, message ID) to last chunk version for each session
-    slot_versions: HashMap<(u32, u32), HashMap<u32, u32>>,
-    /// The signer ID -- the index into the signer list for this signer daemon's signing key.
+    slot_versions: HashMap<u32, HashMap<u32, u32>>,
+    /// The signer slot ID -- the index into the signer list for this signer daemon's signing key.
     signer_slot_id: u32,
-    /// Which signer set to use (0 or 1).
     /// Depends on whether or not we're signing in an even or odd reward cycle
     signer_set: u32,
 }
 
-impl From<&Config> for StackerDB {
-    fn from(config: &Config) -> Self {
+impl StackerDB {
+    /// Create a new StackerDB client
+    pub fn new(
+        host: SocketAddr,
+        stacks_private_key: StacksPrivateKey,
+        is_mainnet: bool,
+        signer_set: u32,
+        signer_slot_id: u32,
+    ) -> Self {
         let mut signers_message_stackerdb_sessions = HashMap::new();
-        for signer_set in 0..2 {
-            for msg_id in 0..SIGNER_SLOTS_PER_USER {
-                signers_message_stackerdb_sessions.insert(
-                    (signer_set as u32, msg_id),
-                    StackerDBSession::new(
-                        config.node_host.clone(),
-                        QualifiedContractIdentifier::new(
-                            config.stackerdb_contract_id.issuer.clone(),
-                            ContractName::from(
-                                NakamotoSigners::make_signers_db_name(signer_set, msg_id).as_str(),
-                            ),
+        let stackerdb_issuer = boot_code_addr(is_mainnet);
+        for msg_id in 0..SIGNER_SLOTS_PER_USER {
+            signers_message_stackerdb_sessions.insert(
+                msg_id,
+                StackerDBSession::new(
+                    host.clone(),
+                    QualifiedContractIdentifier::new(
+                        stackerdb_issuer.into(),
+                        ContractName::from(
+                            NakamotoSigners::make_signers_db_name(signer_set as u64, msg_id)
+                                .as_str(),
                         ),
                     ),
-                );
-            }
+                ),
+            );
         }
         Self {
-            signers_stackerdb_session: StackerDBSession::new(
-                config.node_host,
-                config.stackerdb_contract_id.clone(),
-            ),
             signers_message_stackerdb_sessions,
-            stacks_private_key: config.stacks_private_key,
+            stacks_private_key,
             slot_versions: HashMap::new(),
-            signer_slot_id: config.signer_id,
-            signer_set: 0,
+            signer_slot_id,
+            signer_set,
         }
     }
-}
 
-impl StackerDB {
-    /// Create a new StackerDB client
-    pub fn new(
-        host: SocketAddr,
-        stackerdb_contract_id: QualifiedContractIdentifier,
-        stacks_private_key: StacksPrivateKey,
-        signer_id: u32,
-    ) -> Self {
+    /// Create a new StackerDB client from the provided configuration info
+    pub fn new_with_config(config: &Config, stacks_node_info: &StacksNodeInfo) -> Self {
         let mut signers_message_stackerdb_sessions = HashMap::new();
-        for signer_set in 0..2 {
-            for msg_id in 0..SIGNER_SLOTS_PER_USER {
-                signers_message_stackerdb_sessions.insert(
-                    (signer_set as u32, msg_id),
-                    StackerDBSession::new(
-                        host.clone(),
-                        QualifiedContractIdentifier::new(
-                            stackerdb_contract_id.issuer.clone(),
-                            ContractName::from(
-                                NakamotoSigners::make_signers_db_name(signer_set, msg_id).as_str(),
-                            ),
+        let stackerdb_issuer = boot_code_addr(config.network.is_mainnet());
+        for msg_id in 0..SIGNER_SLOTS_PER_USER {
+            signers_message_stackerdb_sessions.insert(
+                msg_id,
+                StackerDBSession::new(
+                    config.node_host.clone(),
+                    QualifiedContractIdentifier::new(
+                        stackerdb_issuer.into(),
+                        ContractName::from(
+                            NakamotoSigners::make_signers_db_name(
+                                stacks_node_info.signer_set as u64,
+                                msg_id,
+                            )
+                            .as_str(),
                         ),
                     ),
-                );
-            }
+                ),
+            );
         }
         Self {
-            signers_stackerdb_session: StackerDBSession::new(host, stackerdb_contract_id),
             signers_message_stackerdb_sessions,
-            stacks_private_key,
+            stacks_private_key: config.stacks_private_key,
             slot_versions: HashMap::new(),
-            signer_slot_id: signer_id,
-            signer_set: 0,
+            signer_slot_id: stacks_node_info.signer_slot_id,
+            signer_set: stacks_node_info.signer_set,
         }
     }
 
@@ -127,31 +123,26 @@ impl StackerDB {
     ) -> Result<StackerDBChunkAckData, ClientError> {
         let message_bytes = message.serialize_to_vec();
         let msg_id = message.msg_id();
-        let signer_set = self.signer_set;
         let slot_id = self.signer_slot_id;
         loop {
-            let slot_version =
-                if let Some(versions) = self.slot_versions.get_mut(&(signer_set, msg_id)) {
-                    if let Some(version) = versions.get(&slot_id) {
-                        *version
-                    } else {
-                        versions.insert(slot_id, 0);
-                        1
-                    }
+            let slot_version = if let Some(versions) = self.slot_versions.get_mut(&msg_id) {
+                if let Some(version) = versions.get(&slot_id) {
+                    *version
                 } else {
-                    let mut versions = HashMap::new();
                     versions.insert(slot_id, 0);
-                    self.slot_versions.insert((signer_set, msg_id), versions);
                     1
-                };
+                }
+            } else {
+                let mut versions = HashMap::new();
+                versions.insert(slot_id, 0);
+                self.slot_versions.insert(msg_id, versions);
+                1
+            };
 
             let mut chunk = StackerDBChunkData::new(slot_id, slot_version, message_bytes.clone());
             chunk.sign(&self.stacks_private_key)?;
 
-            let Some(session) = self
-                .signers_message_stackerdb_sessions
-                .get_mut(&(signer_set, msg_id))
-            else {
+            let Some(session) = self.signers_message_stackerdb_sessions.get_mut(&msg_id) else {
                 panic!("FATAL: would loop forever trying to send a message with ID {}, for which we don't have a session", msg_id);
             };
 
@@ -164,7 +155,7 @@ impl StackerDB {
             let send_request = || session.put_chunk(&chunk).map_err(backoff::Error::transient);
             let chunk_ack: StackerDBChunkAckData = retry_with_exponential_backoff(send_request)?;
 
-            if let Some(versions) = self.slot_versions.get_mut(&(signer_set, msg_id)) {
+            if let Some(versions) = self.slot_versions.get_mut(&msg_id) {
                 // NOTE: per the above, this is always executed
                 versions.insert(slot_id, slot_version.saturating_add(1));
             } else {
@@ -182,7 +173,7 @@ impl StackerDB {
                 // See: https://github.com/stacks-network/stacks-blockchain/issues/3917
                 if reason.contains("Data for this slot and version already exist") {
                     warn!("Failed to send message to stackerdb due to wrong version number {}. Incrementing and retrying...", slot_version);
-                    if let Some(versions) = self.slot_versions.get_mut(&(signer_set, msg_id)) {
+                    if let Some(versions) = self.slot_versions.get_mut(&msg_id) {
                         // NOTE: per the above, this is always executed
                         versions.insert(slot_id, slot_version.saturating_add(1));
                     } else {
@@ -207,7 +198,7 @@ impl StackerDB {
         );
         let Some(transactions_session) = self
             .signers_message_stackerdb_sessions
-            .get_mut(&(self.signer_set, TRANSACTIONS_MSG_ID))
+            .get_mut(&TRANSACTIONS_MSG_ID)
         else {
             return Err(ClientError::NotConnected);
         };
@@ -253,32 +244,14 @@ impl StackerDB {
         Ok(transactions)
     }
 
-    /// Retrieve the signer contract id
-    pub fn signers_contract_id(&self) -> &QualifiedContractIdentifier {
-        &self.signers_stackerdb_session.stackerdb_contract_id
-    }
-
     /// Retrieve the signer set this stackerdb client is attached to
     pub fn get_signer_set(&self) -> u32 {
         self.signer_set
     }
 
-    /// Set the signer set from a reward cycle
-    pub fn set_signer_set(&mut self, set: u32) {
-        self.signer_set = set
-    }
-
-    /// Set the signer slot ID
-    pub fn set_signer_slot_id(&mut self, slot_id: u32) {
-        self.signer_slot_id = slot_id;
-    }
-
-    /// Get our signer address
-    pub fn get_signer_address(&self, mainnet: bool) -> StacksAddress {
-        StacksAddress::p2pkh(
-            mainnet,
-            &StacksPublicKey::from_private(&self.stacks_private_key),
-        )
+    /// Retrieve the signer slot ID
+    pub fn get_signer_slot_id(&mut self) -> u32 {
+        self.signer_slot_id
     }
 }
 
@@ -345,6 +318,7 @@ mod tests {
     #[serial]
     fn send_signer_message_with_retry_should_succeed() {
         let mut config = TestConfig::new();
+
         let sk = StacksPrivateKey::new();
         let tx = StacksTransaction {
             version: TransactionVersion::Testnet,
diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index 7f06f35b15..7d282a538e 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -15,7 +15,7 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 use blockstack_lib::burnchains::Txid;
 use blockstack_lib::chainstate::nakamoto::NakamotoBlock;
-use blockstack_lib::chainstate::stacks::boot::POX_4_NAME;
+use blockstack_lib::chainstate::stacks::boot::{RewardSet, POX_4_NAME, SIGNERS_VOTING_NAME};
 use blockstack_lib::chainstate::stacks::{
     StacksTransaction, StacksTransactionSigner, TransactionAnchorMode, TransactionAuth,
     TransactionContractCall, TransactionPayload, TransactionPostConditionMode,
@@ -46,7 +46,11 @@ use wsts::curve::point::{Compressed, Point};
 use crate::client::{retry_with_exponential_backoff, ClientError};
 use crate::config::Config;
 
+/// The name of the function for casting a DKG result to signer vote contract
+pub const VOTE_FUNCTION_NAME: &'static str = "vote-for-aggregate-public-key";
+
 /// The Stacks signer client used to communicate with the stacks node
+#[derive(Clone, Debug)]
 pub struct StacksClient {
     /// The stacks address of the signer
     stacks_address: StacksAddress,
@@ -90,6 +94,11 @@ impl From<&Config> for StacksClient {
 }
 
 impl StacksClient {
+    /// Get our signer address
+    pub fn get_signer_address(&self) -> &StacksAddress {
+        &self.stacks_address
+    }
+
     /// Retrieve the signer slots stored within the stackerdb contract
     pub fn get_stackerdb_signer_slots(
         &self,
@@ -99,7 +108,7 @@ impl StacksClient {
         let function_name_str = "stackerdb-get-signer-slots-page";
         let function_name = ClarityName::from(function_name_str);
         let function_args = &[Value::UInt(page.into())];
-        let value = self.read_only_contract_call_with_retry(
+        let value = self.read_only_contract_call(
             &stackerdb_contract.issuer.clone().into(),
             &stackerdb_contract.name,
             &function_name,
@@ -107,6 +116,32 @@ impl StacksClient {
         )?;
         self.parse_signer_slots(value)
     }
+
+    /// Helper function  that attempts to deserialize a clarity hext string as a list of signer slots and their associated number of signer slots
+    fn parse_signer_slots(
+        &self,
+        value: ClarityValue,
+    ) -> Result<Vec<(StacksAddress, u128)>, ClientError> {
+        debug!("Parsing signer slots...");
+        // Due to .signers definition, the  signer slots is always an OK result of a list of tuples of signer addresses and the number of slots they have
+        // If this fails, we have bigger problems than the signer crashing...
+        let value = value.clone().expect_result_ok()?;
+        let values = value.expect_list()?;
+        let mut signer_slots = Vec::with_capacity(values.len());
+        for value in values {
+            let tuple_data = value.expect_tuple()?;
+            let principal_data = tuple_data.get("signer")?.clone().expect_principal()?;
+            let signer = if let PrincipalData::Standard(signer) = principal_data {
+                signer.into()
+            } else {
+                panic!("BUG: Signers stackerdb contract is corrupted");
+            };
+            let num_slots = tuple_data.get("num-slots")?.clone().expect_u128()?;
+            signer_slots.push((signer, num_slots));
+        }
+        Ok(signer_slots)
+    }
+
     /// Retrieve the stacks tip consensus hash from the stacks node
     pub fn get_stacks_tip_consensus_hash(&self) -> Result<ConsensusHash, ClientError> {
         let peer_info = self.get_peer_info()?;
@@ -161,14 +196,15 @@ impl StacksClient {
         Ok(())
     }
 
-    /// Retrieve the current DKG aggregate public key
-    pub fn get_aggregate_public_key(&self) -> Result<Option<Point>, ClientError> {
-        let reward_cycle = self.get_current_reward_cycle()?;
-        let function_name_str = "get-aggregate-public-key";
-        let function_name = ClarityName::from(function_name_str);
+    /// Retrieve the DKG aggregate public key for the given reward cycle
+    pub fn get_aggregate_public_key(
+        &self,
+        reward_cycle: u64,
+    ) -> Result<Option<Point>, ClientError> {
+        let function_name = ClarityName::from("get-aggregate-public-key");
         let pox_contract_id = boot_code_id(POX_4_NAME, self.chain_id == CHAIN_ID_MAINNET);
         let function_args = &[ClarityValue::UInt(reward_cycle as u128)];
-        let value = self.read_only_contract_call_with_retry(
+        let value = self.read_only_contract_call(
             &pox_contract_id.issuer.into(),
             &pox_contract_id.name,
             &function_name,
@@ -200,6 +236,97 @@ impl StacksClient {
         Ok(peer_info_data)
     }
 
+    /// Retrieve the last DKG vote round number for the current reward cycle
+    pub fn get_last_round(&self, reward_cycle: u64) -> Result<u64, ClientError> {
+        debug!("Getting the last DKG vote round of reward cycle {reward_cycle}...");
+        let contract_addr = boot_code_addr(self.chain_id == CHAIN_ID_MAINNET);
+        let contract_name = ContractName::from(SIGNERS_VOTING_NAME);
+        let function_name = ClarityName::from("get-last-round");
+        let function_args = &[ClarityValue::UInt(reward_cycle as u128)];
+        let last_round = u64::try_from(
+            self.read_only_contract_call(
+                &contract_addr,
+                &contract_name,
+                &function_name,
+                function_args,
+            )?
+            .expect_result_ok()?
+            .expect_u128()?,
+        )
+        .map_err(|e| {
+            ClientError::MalformedContractData(format!("Failed to convert vote round to u64: {e}"))
+        })?;
+        Ok(last_round)
+    }
+
+    /// Retrieve the vote of the signer for the given round
+    pub fn get_signer_vote(&self, round: u128) -> Result<Option<Point>, ClientError> {
+        let reward_cycle = ClarityValue::UInt(self.get_current_reward_cycle()? as u128);
+        let round = ClarityValue::UInt(round);
+        let signer = ClarityValue::Principal(self.stacks_address.into());
+        let contract_addr = boot_code_addr(self.chain_id == CHAIN_ID_MAINNET);
+        let contract_name = ContractName::from(SIGNERS_VOTING_NAME);
+        let function = ClarityName::from("get-vote");
+        let function_args = &[reward_cycle, round, signer];
+        let value =
+            self.read_only_contract_call(&contract_addr, &contract_name, &function, function_args)?;
+        self.parse_aggregate_public_key(value)
+    }
+
+    /// Get whether the reward set has been determined for the provided reward cycle.
+    /// i.e the node has passed the first block of the new reward cycle's prepare phase
+    pub fn reward_set_calculated(&self, reward_cycle: u64) -> Result<bool, ClientError> {
+        let pox_info = self.get_pox_data()?;
+        let current_reward_cycle = pox_info.reward_cycle_id;
+        if current_reward_cycle >= reward_cycle {
+            // We have already entered into this reward cycle or beyond
+            // therefore the reward set has already been calculated
+            return Ok(true);
+        }
+        if current_reward_cycle.wrapping_add(1) != reward_cycle {
+            // We are not in the prepare phase of the reward cycle as the upcoming cycle nor are we in the current reward cycle...
+            return Ok(false);
+        }
+        let peer_info = self.get_peer_info()?;
+        let stacks_tip_height = peer_info.stacks_tip_height;
+        // Have we passed the first block of the new reward cycle's prepare phase?
+        Ok(pox_info.next_cycle.prepare_phase_start_block_height < stacks_tip_height)
+    }
+
+    /// Check whether the given reward cycle is in the prepare phase
+    pub fn reward_cycle_in_vote_window(&self, reward_cycle: u64) -> Result<bool, ClientError> {
+        let pox_info = self.get_pox_data()?;
+        if reward_cycle == pox_info.reward_cycle_id.wrapping_add(1) {
+            let peer_info = self.get_peer_info()?;
+            let stacks_tip_height = peer_info.stacks_tip_height;
+            // The vote window starts at the second block of the prepare phase hence the + 1.
+            let vote_window_start = pox_info
+                .next_cycle
+                .prepare_phase_start_block_height
+                .wrapping_add(1);
+            Ok(stacks_tip_height >= vote_window_start)
+        } else {
+            // We are not in the prepare phase of the reward cycle as the upcoming cycle does not match
+            Ok(false)
+        }
+    }
+    /// Get the reward set from the stacks node for the given reward cycle
+    pub fn get_reward_set(&self, reward_cycle: u64) -> Result<RewardSet, ClientError> {
+        debug!("Getting reward set for {reward_cycle}...");
+        let send_request = || {
+            self.stacks_node_client
+                .get(self.reward_set_path(reward_cycle))
+                .send()
+                .map_err(backoff::Error::transient)
+        };
+        let response = retry_with_exponential_backoff(send_request)?;
+        if !response.status().is_success() {
+            return Err(ClientError::RequestFailure(response.status()));
+        }
+        let reward_set = response.json::<RewardSet>()?;
+        Ok(reward_set)
+    }
+
     // Helper function to retrieve the pox data from the stacks node
     fn get_pox_data(&self) -> Result<RPCPoxInfoData, ClientError> {
         debug!("Getting pox data...");
@@ -223,7 +350,7 @@ impl StacksClient {
         Ok(peer_info.burn_block_height)
     }
 
-    /// Helper function to retrieve the current reward cycle number from the stacks node
+    /// Get the current reward cycle from the stacks node
     pub fn get_current_reward_cycle(&self) -> Result<u64, ClientError> {
         let pox_data = self.get_pox_data()?;
         Ok(pox_data.reward_cycle_id)
@@ -255,72 +382,56 @@ impl StacksClient {
         value: ClarityValue,
     ) -> Result<Option<Point>, ClientError> {
         debug!("Parsing aggregate public key...");
-        // Due to pox 4 definition, the aggregate public key is always an optional clarity value hence the use of expect
+        // Due to pox 4 definition, the aggregate public key is always an optional clarity value of 33 bytes hence the use of expect
         // If this fails, we have bigger problems than the signer crashing...
-        let value_opt = value.expect_optional()?;
-        let Some(value) = value_opt else {
+        let opt = value.clone().expect_optional()?;
+        let Some(inner_data) = opt else {
             return Ok(None);
         };
-        // A point should have 33 bytes exactly due to the pox 4 definition hence the use of expect
-        // If this fails, we have bigger problems than the signer crashing...
-        let data = value.clone().expect_buff(33)?;
+        let data = inner_data.expect_buff(33)?;
         // It is possible that the point was invalid though when voted upon and this cannot be prevented by pox 4 definitions...
         // Pass up this error if the conversions fail.
-        let compressed_data = Compressed::try_from(data.as_slice())
-            .map_err(|_e| ClientError::MalformedClarityValue(value.clone()))?;
-        let point = Point::try_from(&compressed_data)
-            .map_err(|_e| ClientError::MalformedClarityValue(value))?;
+        let compressed_data = Compressed::try_from(data.as_slice()).map_err(|e| {
+            ClientError::MalformedClarityValue(format!(
+                "Failed to convert aggregate public key to compressed data: {e}"
+            ))
+        })?;
+        let point = Point::try_from(&compressed_data).map_err(|e| {
+            ClientError::MalformedClarityValue(format!(
+                "Failed to convert aggregate public key to a point: {e}"
+            ))
+        })?;
         Ok(Some(point))
     }
 
-    /// Helper function  that attempts to deserialize a clarity hext string as a list of signer slots and their associated number of signer slots
-    fn parse_signer_slots(
-        &self,
-        value: ClarityValue,
-    ) -> Result<Vec<(StacksAddress, u128)>, ClientError> {
-        debug!("Parsing signer slots from {:?}", &value);
-        // Due to .signers definition, the  signer slots is always an OK result of a list of tuples of signer addresses and the number of slots they have
-        // If this fails, we have bigger problems than the signer crashing...
-        let value = value.expect_result_ok()?;
-        let values = value.expect_list()?;
-        let mut signer_slots = Vec::with_capacity(values.len());
-        for value in values {
-            let tuple_data = value.expect_tuple()?;
-            let principal_data = tuple_data.get("signer")?.clone().expect_principal()?;
-            let signer = if let PrincipalData::Standard(signer) = principal_data {
-                signer.into()
-            } else {
-                panic!("BUG: Signers stackerdb contract is corrupted");
-            };
-            let num_slots = tuple_data.get("num-slots")?.clone().expect_u128()?;
-            signer_slots.push((signer, num_slots));
-        }
-        Ok(signer_slots)
-    }
-
-    /// Sends a transaction to the stacks node for a modifying contract call
+    /// Cast a vote for the given aggregate public key by broadcasting it to the mempool
     pub fn cast_vote_for_aggregate_public_key(
         &self,
+        reward_cycle: u64,
+        signer_index: u32,
         point: Point,
-        round: u64,
-    ) -> Result<Txid, ClientError> {
+    ) -> Result<StacksTransaction, ClientError> {
         debug!("Casting vote for aggregate public key to the mempool...");
-        let signed_tx = self.build_vote_for_aggregate_public_key(point, round)?;
-        self.submit_tx(&signed_tx)
+        let signed_tx =
+            self.build_vote_for_aggregate_public_key(reward_cycle, signer_index, point)?;
+        self.submit_tx(&signed_tx)?;
+        Ok(signed_tx)
     }
 
     /// Helper function to create a stacks transaction for a modifying contract call
     pub fn build_vote_for_aggregate_public_key(
         &self,
+        reward_cycle: u64,
+        signer_index: u32,
         point: Point,
-        round: u64,
     ) -> Result<StacksTransaction, ClientError> {
-        debug!("Building vote-for-aggregate-public-key transaction...");
-        let signer_index = 0; // TODO retreieve the index from the stacks node
+        debug!("Building {VOTE_FUNCTION_NAME} transaction...");
+        let round = self.get_last_round(reward_cycle)?;
+        // TODO: this nonce should be calculated on the side as we may have pending transactions that are not yet confirmed...
         let nonce = self.get_account_nonce(&self.stacks_address)?;
         let contract_address = boot_code_addr(self.chain_id == CHAIN_ID_MAINNET);
         let contract_name = ContractName::from(POX_4_NAME); //TODO update this to POX_4_VOTE_NAME when the contract is deployed
-        let function_name = ClarityName::from("vote-for-aggregate-public-key");
+        let function_name = ClarityName::from(VOTE_FUNCTION_NAME);
         let function_args = &[
             ClarityValue::UInt(signer_index as u128),
             ClarityValue::UInt(round as u128),
@@ -383,7 +494,7 @@ impl StacksClient {
     }
 
     /// Makes a read only contract call to a stacks contract
-    pub fn read_only_contract_call_with_retry(
+    pub fn read_only_contract_call(
         &self,
         contract_addr: &StacksAddress,
         contract_name: &ContractName,
@@ -407,15 +518,12 @@ impl StacksClient {
         let body =
             json!({"sender": self.stacks_address.to_string(), "arguments": args}).to_string();
         let path = self.read_only_path(contract_addr, contract_name, function_name);
-        let send_request = || {
-            self.stacks_node_client
-                .post(path.clone())
-                .header("Content-Type", "application/json")
-                .body(body.clone())
-                .send()
-                .map_err(backoff::Error::transient)
-        };
-        let response = retry_with_exponential_backoff(send_request)?;
+        let response = self
+            .stacks_node_client
+            .post(path.clone())
+            .header("Content-Type", "application/json")
+            .body(body.clone())
+            .send()?;
         if !response.status().is_success() {
             return Err(ClientError::RequestFailure(response.status()));
         }
@@ -465,6 +573,10 @@ impl StacksClient {
         format!("{}/v2/accounts/{stacks_address}?proof=0", self.http_origin)
     }
 
+    fn reward_set_path(&self, reward_cycle: u64) -> String {
+        format!("/v2/stacker_set/{reward_cycle}")
+    }
+
     /// Helper function to create a stacks transaction for a modifying contract call
     pub fn build_signed_contract_call_transaction(
         contract_addr: &StacksAddress,
@@ -495,9 +607,6 @@ impl StacksClient {
 
         let mut unsigned_tx = StacksTransaction::new(tx_version, tx_auth, tx_payload);
 
-        // FIXME: Because signers are given priority, we can put down a tx fee of 0
-        // https://github.com/stacks-network/stacks-blockchain/issues/4006
-        // Note: if set to 0 now, will cause a failure (MemPoolRejection::FeeTooLow)
         unsigned_tx.set_tx_fee(tx_fee);
         unsigned_tx.set_origin_nonce(nonce);
 
@@ -523,11 +632,25 @@ mod tests {
     use std::io::{BufWriter, Write};
     use std::thread::spawn;
 
+    use blockstack_lib::chainstate::nakamoto::NakamotoBlockHeader;
+    use blockstack_lib::chainstate::stacks::ThresholdSignature;
+    use rand::thread_rng;
+    use rand_core::RngCore;
+    use serial_test::serial;
+    use stacks_common::bitvec::BitVec;
     use stacks_common::consts::{CHAIN_ID_TESTNET, SIGNER_SLOTS_PER_USER};
+    use stacks_common::types::chainstate::{BlockHeaderHash, StacksBlockId, TrieHash};
+    use stacks_common::types::StacksPublicKeyBuffer;
+    use stacks_common::util::hash::{Hash160, Sha256Sum, Sha512Trunc256Sum};
+    use stacks_common::util::secp256k1::MessageSignature;
     use wsts::curve::scalar::Scalar;
 
     use super::*;
-    use crate::client::tests::{write_response, TestConfig};
+    use crate::client::tests::{
+        build_account_nonce_response, build_get_aggregate_public_key_response,
+        build_get_last_round_response, build_get_peer_info_response, build_get_pox_data_response,
+        write_response, TestConfig,
+    };
 
     #[test]
     fn read_only_contract_call_200_success() {
@@ -538,7 +661,7 @@ mod tests {
             .expect("Failed to serialize hex value");
         let response_bytes = format!("HTTP/1.1 200 OK\n\n{{\"okay\":true,\"result\":\"{hex}\"}}",);
         let h = spawn(move || {
-            config.client.read_only_contract_call_with_retry(
+            config.client.read_only_contract_call(
                 &config.client.stacks_address,
                 &ContractName::from("contract-name"),
                 &ClarityName::from("function-name"),
@@ -559,7 +682,7 @@ mod tests {
             .expect("Failed to serialize hex value");
         let response_bytes = format!("HTTP/1.1 200 OK\n\n{{\"okay\":true,\"result\":\"{hex}\"}}",);
         let h = spawn(move || {
-            config.client.read_only_contract_call_with_retry(
+            config.client.read_only_contract_call(
                 &config.client.stacks_address,
                 &ContractName::from("contract-name"),
                 &ClarityName::from("function-name"),
@@ -575,7 +698,7 @@ mod tests {
     fn read_only_contract_call_200_failure() {
         let config = TestConfig::new();
         let h = spawn(move || {
-            config.client.read_only_contract_call_with_retry(
+            config.client.read_only_contract_call(
                 &config.client.stacks_address,
                 &ContractName::from("contract-name"),
                 &ClarityName::from("function-name"),
@@ -595,7 +718,7 @@ mod tests {
         let config = TestConfig::new();
         // Simulate a 400 Bad Request response
         let h = spawn(move || {
-            config.client.read_only_contract_call_with_retry(
+            config.client.read_only_contract_call(
                 &config.client.stacks_address,
                 &ContractName::from("contract-name"),
                 &ClarityName::from("function-name"),
@@ -617,7 +740,7 @@ mod tests {
         let config = TestConfig::new();
         // Simulate a 400 Bad Request response
         let h = spawn(move || {
-            config.client.read_only_contract_call_with_retry(
+            config.client.read_only_contract_call(
                 &config.client.stacks_address,
                 &ContractName::from("contract-name"),
                 &ClarityName::from("function-name"),
@@ -635,13 +758,14 @@ mod tests {
     #[test]
     fn valid_reward_cycle_should_succeed() {
         let config = TestConfig::new();
+        let reward_cycle = thread_rng().next_u64();
+        let prepare_phase_start_block_height = thread_rng().next_u64();
+        let pox_data_response =
+            build_get_pox_data_response(reward_cycle, prepare_phase_start_block_height);
         let h = spawn(move || config.client.get_current_reward_cycle());
-        write_response(
-            config.mock_server,
-            b"HTTP/1.1 200 Ok\n\n{\"contract_id\":\"ST000000000000000000002AMW42H.pox-3\",\"pox_activation_threshold_ustx\":829371801288885,\"first_burnchain_block_height\":2000000,\"current_burnchain_block_height\":2572192,\"prepare_phase_block_length\":50,\"reward_phase_block_length\":1000,\"reward_slots\":2000,\"rejection_fraction\":12,\"total_liquid_supply_ustx\":41468590064444294,\"current_cycle\":{\"id\":544,\"min_threshold_ustx\":5190000000000,\"stacked_ustx\":853258144644000,\"is_pox_active\":true},\"next_cycle\":{\"id\":545,\"min_threshold_ustx\":5190000000000,\"min_increment_ustx\":5183573758055,\"stacked_ustx\":847278759574000,\"prepare_phase_start_block_height\":2572200,\"blocks_until_prepare_phase\":8,\"reward_phase_start_block_height\":2572250,\"blocks_until_reward_phase\":58,\"ustx_until_pox_rejection\":4976230807733304},\"min_amount_ustx\":5190000000000,\"prepare_cycle_length\":50,\"reward_cycle_id\":544,\"reward_cycle_length\":1050,\"rejection_votes_left_required\":4976230807733304,\"next_reward_cycle_in\":58,\"contract_versions\":[{\"contract_id\":\"ST000000000000000000002AMW42H.pox\",\"activation_burnchain_block_height\":2000000,\"first_reward_cycle_id\":0},{\"contract_id\":\"ST000000000000000000002AMW42H.pox-2\",\"activation_burnchain_block_height\":2422102,\"first_reward_cycle_id\":403},{\"contract_id\":\"ST000000000000000000002AMW42H.pox-3\",\"activation_burnchain_block_height\":2432545,\"first_reward_cycle_id\":412}]}",
-        );
+        write_response(config.mock_server, pox_data_response.as_bytes());
         let current_cycle_id = h.join().unwrap().unwrap();
-        assert_eq!(544, current_cycle_id);
+        assert_eq!(reward_cycle, current_cycle_id);
     }
 
     #[test]
@@ -670,24 +794,11 @@ mod tests {
 
     #[test]
     fn get_aggregate_public_key_should_succeed() {
-        let current_reward_cycle_response = b"HTTP/1.1 200 Ok\n\n{\"contract_id\":\"ST000000000000000000002AMW42H.pox-3\",\"pox_activation_threshold_ustx\":829371801288885,\"first_burnchain_block_height\":2000000,\"current_burnchain_block_height\":2572192,\"prepare_phase_block_length\":50,\"reward_phase_block_length\":1000,\"reward_slots\":2000,\"rejection_fraction\":12,\"total_liquid_supply_ustx\":41468590064444294,\"current_cycle\":{\"id\":544,\"min_threshold_ustx\":5190000000000,\"stacked_ustx\":853258144644000,\"is_pox_active\":true},\"next_cycle\":{\"id\":545,\"min_threshold_ustx\":5190000000000,\"min_increment_ustx\":5183573758055,\"stacked_ustx\":847278759574000,\"prepare_phase_start_block_height\":2572200,\"blocks_until_prepare_phase\":8,\"reward_phase_start_block_height\":2572250,\"blocks_until_reward_phase\":58,\"ustx_until_pox_rejection\":4976230807733304},\"min_amount_ustx\":5190000000000,\"prepare_cycle_length\":50,\"reward_cycle_id\":544,\"reward_cycle_length\":1050,\"rejection_votes_left_required\":4976230807733304,\"next_reward_cycle_in\":58,\"contract_versions\":[{\"contract_id\":\"ST000000000000000000002AMW42H.pox\",\"activation_burnchain_block_height\":2000000,\"first_reward_cycle_id\":0},{\"contract_id\":\"ST000000000000000000002AMW42H.pox-2\",\"activation_burnchain_block_height\":2422102,\"first_reward_cycle_id\":403},{\"contract_id\":\"ST000000000000000000002AMW42H.pox-3\",\"activation_burnchain_block_height\":2432545,\"first_reward_cycle_id\":412}]}";
         let orig_point = Point::from(Scalar::random(&mut rand::thread_rng()));
-        let clarity_value = ClarityValue::some(
-            ClarityValue::buff_from(orig_point.compress().as_bytes().to_vec())
-                .expect("BUG: Failed to create clarity value from point"),
-        )
-        .expect("BUG: Failed to create clarity value from point");
-        let hex = clarity_value
-            .serialize_to_hex()
-            .expect("Failed to serialize clarity value");
-        let response = format!("HTTP/1.1 200 OK\n\n{{\"okay\":true,\"result\":\"{hex}\"}}");
+        let response = build_get_aggregate_public_key_response(orig_point);
 
         let test_config = TestConfig::new();
-        let config = test_config.config;
-        let h = spawn(move || test_config.client.get_aggregate_public_key());
-        write_response(test_config.mock_server, current_reward_cycle_response);
-
-        let test_config = TestConfig::from_config(config);
+        let h = spawn(move || test_config.client.get_aggregate_public_key(0));
         write_response(test_config.mock_server, response.as_bytes());
         let res = h.join().unwrap().unwrap();
         assert_eq!(res, Some(orig_point));
@@ -698,12 +809,8 @@ mod tests {
             .expect("Failed to serialize clarity value");
         let response = format!("HTTP/1.1 200 OK\n\n{{\"okay\":true,\"result\":\"{hex}\"}}");
 
-        let test_config = TestConfig::new();
-        let config = test_config.config;
-        let h = spawn(move || test_config.client.get_aggregate_public_key());
-        write_response(test_config.mock_server, current_reward_cycle_response);
-
-        let test_config = TestConfig::from_config(config);
+        let test_config = TestConfig::from_config(test_config.config);
+        let h = spawn(move || test_config.client.get_aggregate_public_key(0));
         write_response(test_config.mock_server, response.as_bytes());
 
         let res = h.join().unwrap().unwrap();
@@ -792,15 +899,46 @@ mod tests {
 
     #[ignore]
     #[test]
-    fn transaction_contract_call_should_succeed() {
+    #[serial]
+    fn build_vote_for_aggregate_public_key_should_succeed() {
+        let config = TestConfig::new();
+        let point = Point::from(Scalar::random(&mut rand::thread_rng()));
+        let round = rand::thread_rng().next_u64();
+        let round_response = build_get_last_round_response(round);
+        let nonce = thread_rng().next_u64();
+        let account_nonce_response = build_account_nonce_response(nonce);
+
+        let h = spawn(move || {
+            config
+                .client
+                .build_vote_for_aggregate_public_key(0, 0, point)
+        });
+        write_response(config.mock_server, round_response.as_bytes());
+        let config = TestConfig::from_config(config.config);
+        write_response(config.mock_server, account_nonce_response.as_bytes());
+        assert!(h.join().unwrap().is_ok());
+    }
+
+    #[ignore]
+    #[test]
+    #[serial]
+    fn cast_vote_for_aggregate_public_key_should_succeed() {
         let config = TestConfig::new();
         let point = Point::from(Scalar::random(&mut rand::thread_rng()));
-        let round = 10;
+        let round = rand::thread_rng().next_u64();
+        let round_response = build_get_last_round_response(round);
+        let nonce = thread_rng().next_u64();
+        let account_nonce_response = build_account_nonce_response(nonce);
+
         let h = spawn(move || {
             config
                 .client
-                .cast_vote_for_aggregate_public_key(point, round)
+                .cast_vote_for_aggregate_public_key(0, 0, point)
         });
+        write_response(config.mock_server, round_response.as_bytes());
+        let config = TestConfig::from_config(config.config);
+        write_response(config.mock_server, account_nonce_response.as_bytes());
+        let config = TestConfig::from_config(config.config);
         write_response(
             config.mock_server,
             b"HTTP/1.1 200 OK\n\n4e99f99bc4a05437abb8c7d0c306618f45b203196498e2ebe287f10497124958",
@@ -862,12 +1000,13 @@ mod tests {
         let config = TestConfig::new();
         let address = config.client.stacks_address;
         let h = spawn(move || config.client.get_account_nonce(&address));
+        let nonce = thread_rng().next_u64();
         write_response(
             config.mock_server,
-            b"HTTP/1.1 200 OK\n\n{\"nonce\":0,\"balance\":\"0x00000000000000000000000000000000\",\"locked\":\"0x00000000000000000000000000000000\",\"unlock_height\":0}"
+            build_account_nonce_response(nonce).as_bytes(),
         );
-        let nonce = h.join().unwrap().expect("Failed to deserialize response");
-        assert_eq!(nonce, 0);
+        let returned_nonce = h.join().unwrap().expect("Failed to deserialize response");
+        assert_eq!(returned_nonce, nonce);
     }
 
     #[test]
@@ -934,4 +1073,201 @@ mod tests {
         );
         assert!(h.join().unwrap().is_err());
     }
+
+    #[test]
+    fn submit_block_for_validation_should_succeed() {
+        let config = TestConfig::new();
+        let header = NakamotoBlockHeader {
+            version: 1,
+            chain_length: 2,
+            burn_spent: 3,
+            consensus_hash: ConsensusHash([0x04; 20]),
+            parent_block_id: StacksBlockId([0x05; 32]),
+            tx_merkle_root: Sha512Trunc256Sum([0x06; 32]),
+            state_index_root: TrieHash([0x07; 32]),
+            miner_signature: MessageSignature::empty(),
+            signer_signature: ThresholdSignature::empty(),
+            signer_bitvec: BitVec::zeros(1).unwrap(),
+        };
+        let block = NakamotoBlock {
+            header,
+            txs: vec![],
+        };
+        let h = spawn(move || config.client.submit_block_for_validation(block));
+        write_response(config.mock_server, b"HTTP/1.1 200 OK\n\n");
+        assert!(h.join().unwrap().is_ok());
+    }
+
+    #[test]
+    fn submit_block_for_validation_should_fail() {
+        let config = TestConfig::new();
+        let header = NakamotoBlockHeader {
+            version: 1,
+            chain_length: 2,
+            burn_spent: 3,
+            consensus_hash: ConsensusHash([0x04; 20]),
+            parent_block_id: StacksBlockId([0x05; 32]),
+            tx_merkle_root: Sha512Trunc256Sum([0x06; 32]),
+            state_index_root: TrieHash([0x07; 32]),
+            miner_signature: MessageSignature::empty(),
+            signer_signature: ThresholdSignature::empty(),
+            signer_bitvec: BitVec::zeros(1).unwrap(),
+        };
+        let block = NakamotoBlock {
+            header,
+            txs: vec![],
+        };
+        let h = spawn(move || config.client.submit_block_for_validation(block));
+        write_response(config.mock_server, b"HTTP/1.1 404 Not Found\n\n");
+        assert!(h.join().unwrap().is_err());
+    }
+
+    #[test]
+    fn get_peer_info_should_succeed() {
+        let config = TestConfig::new();
+        let private_key = StacksPrivateKey::new();
+        let public_key = StacksPublicKey::from_private(&private_key);
+        let public_key_buf = StacksPublicKeyBuffer::from_public_key(&public_key);
+        let public_key_hash = Hash160::from_node_public_key(&public_key);
+        let stackerdb_contract_ids = vec![boot_code_id("fake", false)];
+
+        let peer_info = RPCPeerInfoData {
+            peer_version: 1,
+            pox_consensus: ConsensusHash([0x04; 20]),
+            burn_block_height: 200,
+            stable_pox_consensus: ConsensusHash([0x05; 20]),
+            stable_burn_block_height: 2,
+            server_version: "fake version".to_string(),
+            network_id: 0,
+            parent_network_id: 1,
+            stacks_tip_height: 20,
+            stacks_tip: BlockHeaderHash([0x06; 32]),
+            stacks_tip_consensus_hash: ConsensusHash([0x07; 20]),
+            unanchored_tip: None,
+            unanchored_seq: Some(1),
+            exit_at_block_height: None,
+            genesis_chainstate_hash: Sha256Sum::zero(),
+            node_public_key: Some(public_key_buf),
+            node_public_key_hash: Some(public_key_hash),
+            affirmations: None,
+            last_pox_anchor: None,
+            stackerdbs: Some(
+                stackerdb_contract_ids
+                    .into_iter()
+                    .map(|cid| format!("{}", cid))
+                    .collect(),
+            ),
+        };
+        let peer_info_json =
+            serde_json::to_string(&peer_info).expect("Failed to serialize peer info");
+        let response = format!("HTTP/1.1 200 OK\n\n{peer_info_json}");
+        let h = spawn(move || config.client.get_peer_info());
+        write_response(config.mock_server, response.as_bytes());
+        assert_eq!(h.join().unwrap().unwrap(), peer_info);
+    }
+
+    #[test]
+    fn get_last_round_should_succeed() {
+        let config = TestConfig::new();
+        let round = rand::thread_rng().next_u64();
+        let response = build_get_last_round_response(round);
+        let h = spawn(move || config.client.get_last_round(0));
+
+        write_response(config.mock_server, response.as_bytes());
+        assert_eq!(h.join().unwrap().unwrap(), round);
+    }
+
+    #[test]
+    #[serial]
+    fn get_reward_set_calculated() {
+        let consensus_hash = "64c8c3049ff6b939c65828e3168210e6bb32d880".to_string();
+
+        // Should return TRUE as the passed in reward cycle is older than the current reward cycle of the node
+        let config = TestConfig::new();
+        let pox_response = build_get_pox_data_response(2, 10);
+        let h = spawn(move || config.client.reward_set_calculated(0));
+        write_response(config.mock_server, pox_response.as_bytes());
+        assert!(h.join().unwrap().unwrap());
+
+        // Should return TRUE as the passed in reward cycle is the same as the current reward cycle
+        let config = TestConfig::from_config(config.config);
+        let pox_response = build_get_pox_data_response(2, 10);
+        let h = spawn(move || config.client.reward_set_calculated(2));
+        write_response(config.mock_server, pox_response.as_bytes());
+        assert!(h.join().unwrap().unwrap());
+
+        // Should return TRUE as the passed in reward cycle is the NEXT reward cycle AND the prepare phase is in its SECOND block
+        let config = TestConfig::from_config(config.config);
+        let pox_response = build_get_pox_data_response(2, 10);
+        let peer_response = build_get_peer_info_response(11, consensus_hash.clone());
+        let h = spawn(move || config.client.reward_set_calculated(3));
+        write_response(config.mock_server, pox_response.as_bytes());
+        let config = TestConfig::from_config(config.config);
+        write_response(config.mock_server, peer_response.as_bytes());
+        assert!(h.join().unwrap().unwrap());
+
+        // Should return FALSE as the passed in reward cycle is NEWER than the NEXT reward cycle of the node
+        let config = TestConfig::from_config(config.config);
+        let pox_response = build_get_pox_data_response(2, 10);
+        let h = spawn(move || config.client.reward_set_calculated(4));
+        write_response(config.mock_server, pox_response.as_bytes());
+        assert!(!h.join().unwrap().unwrap());
+
+        // Should return FALSE as the passed in reward cycle is the NEXT reward cycle BUT the prepare phase is in its FIRST block
+        let config = TestConfig::from_config(config.config);
+        let pox_response = build_get_pox_data_response(2, 11);
+        let peer_response = build_get_peer_info_response(11, consensus_hash);
+        let h = spawn(move || config.client.reward_set_calculated(3));
+        write_response(config.mock_server, pox_response.as_bytes());
+        let config = TestConfig::from_config(config.config);
+        write_response(config.mock_server, peer_response.as_bytes());
+        assert!(!h.join().unwrap().unwrap());
+    }
+
+    #[test]
+    #[serial]
+    fn reward_cycle_in_vote_window() {
+        let consensus_hash = "64c8c3049ff6b939c65828e3168210e6bb32d880".to_string();
+
+        // Should return FALSE as the passed in reward cycle is old
+        let config = TestConfig::new();
+        let pox_response = build_get_pox_data_response(2, 10);
+        let h = spawn(move || config.client.reward_cycle_in_vote_window(0));
+        write_response(config.mock_server, pox_response.as_bytes());
+        assert!(!h.join().unwrap().unwrap());
+
+        // Should return FALSE as the passed in reward cycle is NEWER than the NEXT reward cycle of the node
+        let config = TestConfig::from_config(config.config);
+        let pox_response = build_get_pox_data_response(2, 10);
+        let h = spawn(move || config.client.reward_cycle_in_vote_window(4));
+        write_response(config.mock_server, pox_response.as_bytes());
+        assert!(!h.join().unwrap().unwrap());
+
+        // Should return FALSE as the passed in reward cycle is the same as the current reward cycle
+        let config = TestConfig::from_config(config.config);
+        let pox_response = build_get_pox_data_response(2, 10);
+        let h = spawn(move || config.client.reward_cycle_in_vote_window(2));
+        write_response(config.mock_server, pox_response.as_bytes());
+        assert!(!h.join().unwrap().unwrap());
+
+        // Should return FALSE as the passed in reward cycle is the NEXT reward cycle BUT the prepare phase is in its FIRST block
+        let config = TestConfig::from_config(config.config);
+        let pox_response = build_get_pox_data_response(2, 11);
+        let peer_response = build_get_peer_info_response(11, consensus_hash.clone());
+        let h = spawn(move || config.client.reward_cycle_in_vote_window(3));
+        write_response(config.mock_server, pox_response.as_bytes());
+        let config = TestConfig::from_config(config.config);
+        write_response(config.mock_server, peer_response.as_bytes());
+        assert!(!h.join().unwrap().unwrap());
+
+        // Should return TRUE as the passed in reward cycle is the NEXT reward cycle AND the prepare phase is in its SECOND block
+        let config = TestConfig::from_config(config.config);
+        let pox_response = build_get_pox_data_response(2, 10);
+        let peer_response = build_get_peer_info_response(11, consensus_hash.clone());
+        let h = spawn(move || config.client.reward_cycle_in_vote_window(3));
+        write_response(config.mock_server, pox_response.as_bytes());
+        let config = TestConfig::from_config(config.config);
+        write_response(config.mock_server, peer_response.as_bytes());
+        assert!(h.join().unwrap().unwrap());
+    }
 }
diff --git a/stacks-signer/src/config.rs b/stacks-signer/src/config.rs
index f038cc6fed..91146946ec 100644
--- a/stacks-signer/src/config.rs
+++ b/stacks-signer/src/config.rs
@@ -21,8 +21,6 @@ use std::path::PathBuf;
 use std::time::Duration;
 
 use blockstack_lib::chainstate::stacks::TransactionVersion;
-use blockstack_lib::util_lib::boot::boot_code_id;
-use clarity::vm::types::QualifiedContractIdentifier;
 use hashbrown::HashMap;
 use serde::Deserialize;
 use stacks_common::address::{
@@ -31,9 +29,7 @@ use stacks_common::address::{
 use stacks_common::consts::{CHAIN_ID_MAINNET, CHAIN_ID_TESTNET};
 use stacks_common::types::chainstate::{StacksAddress, StacksPrivateKey, StacksPublicKey};
 use stacks_common::types::PrivateKey;
-use wsts::curve::ecdsa;
 use wsts::curve::scalar::Scalar;
-use wsts::state_machine::PublicKeys;
 
 /// List of key_ids for each signer_id
 pub type SignerKeyIds = HashMap<u32, Vec<u32>>;
@@ -73,12 +69,11 @@ pub enum Network {
 
 impl std::fmt::Display for Network {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let network = match self {
-            Self::Mainnet => "mainnet",
-            Self::Testnet => "testnet",
-            Self::Mocknet => "mocknet",
-        };
-        write!(f, "{}", network)
+        match self {
+            Self::Mainnet => write!(f, "mainnet"),
+            Self::Testnet => write!(f, "testnet"),
+            Self::Mocknet => write!(f, "mocknet"),
+        }
     }
 }
 
@@ -123,8 +118,6 @@ pub struct Config {
     pub node_host: SocketAddr,
     /// endpoint to the event receiver
     pub endpoint: SocketAddr,
-    /// smart contract that controls the target signers' stackerdb
-    pub stackerdb_contract_id: QualifiedContractIdentifier,
     /// The Scalar representation of the private key for signer communication
     pub ecdsa_private_key: Scalar,
     /// The signer's Stacks private key
@@ -133,14 +126,6 @@ pub struct Config {
     pub stacks_address: StacksAddress,
     /// The network to use. One of "mainnet" or "testnet".
     pub network: Network,
-    /// The signer ID and key ids mapped to a public key
-    pub signer_ids_public_keys: PublicKeys,
-    /// The signer IDs mapped to their Key IDs
-    pub signer_key_ids: SignerKeyIds,
-    /// This signer's ID
-    pub signer_id: u32,
-    /// All signer IDs participating in the current reward cycle
-    pub signer_ids: Vec<u32>,
     /// The time to wait for a response from the stacker-db instance
     pub event_timeout: Duration,
     /// timeout to gather DkgPublicShares messages
@@ -157,13 +142,6 @@ pub struct Config {
     pub tx_fee: u64,
 }
 
-/// Internal struct for loading up the config file signer data
-#[derive(Clone, Deserialize, Default, Debug)]
-struct RawSigners {
-    pub public_key: String,
-    pub key_ids: Vec<u32>,
-}
-
 /// Internal struct for loading up the config file
 #[derive(Deserialize, Debug)]
 struct RawConfigFile {
@@ -171,19 +149,11 @@ struct RawConfigFile {
     pub node_host: String,
     /// endpoint to event receiver
     pub endpoint: String,
-    /// Signers' Stacker db contract identifier
-    pub stackerdb_contract_id: Option<String>,
     /// The hex representation of the signer's Stacks private key used for communicating
     /// with the Stacks Node, including writing to the Stacker DB instance.
     pub stacks_private_key: String,
     /// The network to use. One of "mainnet" or "testnet".
     pub network: Network,
-    // TODO: Optionally retrieve the signers from the pox contract
-    // See: https://github.com/stacks-network/stacks-blockchain/issues/3912
-    /// The signers, IDs, and their private keys
-    pub signers: Vec<RawSigners>,
-    /// The signer ID
-    pub signer_id: u32,
     /// The time to wait (in millisecs) for a response from the stacker-db instance
     pub event_timeout_ms: Option<u64>,
     /// timeout in (millisecs) to gather DkgPublicShares messages
@@ -252,13 +222,6 @@ impl TryFrom<RawConfigFile> for Config {
                 raw_data.endpoint.clone(),
             ))?;
 
-        let stackerdb_contract_id = match raw_data.stackerdb_contract_id {
-            Some(id) => QualifiedContractIdentifier::parse(&id).map_err(|_| {
-                ConfigError::BadField("stackerdb_contract_id".to_string(), id.clone())
-            })?,
-            None => boot_code_id("signers", raw_data.network == Network::Mainnet),
-        };
-
         let stacks_private_key =
             StacksPrivateKey::from_hex(&raw_data.stacks_private_key).map_err(|_| {
                 ConfigError::BadField(
@@ -282,29 +245,6 @@ impl TryFrom<RawConfigFile> for Config {
             &vec![stacks_public_key],
         )
         .ok_or(ConfigError::UnsupportedAddressVersion)?;
-        let mut signer_ids = vec![];
-        let mut public_keys = PublicKeys::default();
-        let mut signer_key_ids = SignerKeyIds::default();
-        for (i, s) in raw_data.signers.iter().enumerate() {
-            let signer_public_key =
-                ecdsa::PublicKey::try_from(s.public_key.as_str()).map_err(|_| {
-                    ConfigError::BadField("signers.public_key".to_string(), s.public_key.clone())
-                })?;
-            for key_id in &s.key_ids {
-                //We do not allow a key id of 0.
-                if *key_id == 0 {
-                    return Err(ConfigError::BadField(
-                        "signers.key_ids".to_string(),
-                        key_id.to_string(),
-                    ));
-                }
-                public_keys.key_ids.insert(*key_id, signer_public_key);
-            }
-            let signer_id = u32::try_from(i).unwrap();
-            public_keys.signers.insert(signer_id, signer_public_key);
-            signer_key_ids.insert(signer_id, s.key_ids.clone());
-            signer_ids.push(signer_id);
-        }
         let event_timeout =
             Duration::from_millis(raw_data.event_timeout_ms.unwrap_or(EVENT_TIMEOUT_MS));
         let dkg_end_timeout = raw_data.dkg_end_timeout_ms.map(Duration::from_millis);
@@ -315,15 +255,10 @@ impl TryFrom<RawConfigFile> for Config {
         Ok(Self {
             node_host,
             endpoint,
-            stackerdb_contract_id,
-            ecdsa_private_key,
             stacks_private_key,
+            ecdsa_private_key,
             stacks_address,
             network: raw_data.network,
-            signer_ids_public_keys: public_keys,
-            signer_id: raw_data.signer_id,
-            signer_ids,
-            signer_key_ids,
             event_timeout,
             dkg_end_timeout,
             dkg_public_timeout,
@@ -357,44 +292,41 @@ impl Config {
     }
 }
 
-#[cfg(test)]
-mod tests {
-    use blockstack_lib::util_lib::boot::boot_code_id;
-
-    use super::{Config, Network, RawConfigFile};
+/// Helper function for building a signer config for each provided signer private key
+pub fn build_signer_config_tomls(
+    stacks_private_keys: &[StacksPrivateKey],
+    node_host: &str,
+    timeout: Option<Duration>,
+    network: &Network,
+) -> Vec<String> {
+    let mut signer_config_tomls = vec![];
+
+    let mut port = 30000;
+    for stacks_private_key in stacks_private_keys {
+        let endpoint = format!("localhost:{}", port);
+        port += 1;
+        let stacks_private_key = stacks_private_key.to_hex();
+        let mut signer_config_toml = format!(
+            r#"
+stacks_private_key = "{stacks_private_key}"
+node_host = "{node_host}"
+endpoint = "{endpoint}"
+network = "{network}"
+"#
+        );
+
+        if let Some(timeout) = timeout {
+            let event_timeout_ms = timeout.as_millis();
+            signer_config_toml = format!(
+                r#"
+{signer_config_toml}
+event_timeout = {event_timeout_ms}   
+"#
+            )
+        }
 
-    fn create_raw_config(overrides: impl FnOnce(&mut RawConfigFile)) -> RawConfigFile {
-        let mut config = RawConfigFile {
-            node_host: "127.0.0.1:20443".to_string(),
-            endpoint: "127.0.0.1:30000".to_string(),
-            stackerdb_contract_id: None,
-            stacks_private_key:
-                "69be0e68947fa7128702761151dc8d9b39ee1401e547781bb2ec3e5b4eb1b36f01".to_string(),
-            network: Network::Testnet,
-            signers: vec![],
-            signer_id: 0,
-            event_timeout_ms: None,
-            dkg_end_timeout_ms: None,
-            dkg_public_timeout_ms: None,
-            dkg_private_timeout_ms: None,
-            nonce_timeout_ms: None,
-            sign_timeout_ms: None,
-            tx_fee_ms: None,
-        };
-        overrides(&mut config);
-        config
+        signer_config_tomls.push(signer_config_toml);
     }
 
-    #[test]
-    fn test_config_default_signerdb() {
-        let testnet_config = create_raw_config(|_| {});
-
-        let config = Config::try_from(testnet_config).expect("Failed to parse config");
-        assert_eq!(config.stackerdb_contract_id, boot_code_id("signers", false));
-
-        let mainnet_config = create_raw_config(|c| c.network = Network::Mainnet);
-
-        let config = Config::try_from(mainnet_config).expect("Failed to parse config");
-        assert_eq!(config.stackerdb_contract_id, boot_code_id("signers", true));
-    }
+    signer_config_tomls
 }
diff --git a/stacks-signer/src/lib.rs b/stacks-signer/src/lib.rs
index cadb72c8a4..e9e41e5a70 100644
--- a/stacks-signer/src/lib.rs
+++ b/stacks-signer/src/lib.rs
@@ -28,5 +28,5 @@ pub mod client;
 pub mod config;
 /// The primary runloop for the signer
 pub mod runloop;
-/// Util functions
-pub mod utils;
+/// The signer module for processing events
+pub mod signer;
diff --git a/stacks-signer/src/main.rs b/stacks-signer/src/main.rs
index 7ba74b55ad..640dcf2e24 100644
--- a/stacks-signer/src/main.rs
+++ b/stacks-signer/src/main.rs
@@ -41,8 +41,7 @@ use libsigner::{RunningSigner, Signer, SignerEventReceiver, SignerSession, Stack
 use libstackerdb::StackerDBChunkData;
 use slog::{slog_debug, slog_error};
 use stacks_common::codec::read_next;
-use stacks_common::consts::SIGNER_SLOTS_PER_USER;
-use stacks_common::types::chainstate::{StacksAddress, StacksPrivateKey};
+use stacks_common::types::chainstate::StacksPrivateKey;
 use stacks_common::util::hash::to_hex;
 use stacks_common::util::secp256k1::{MessageSignature, Secp256k1PublicKey};
 use stacks_common::{debug, error};
@@ -50,14 +49,12 @@ use stacks_signer::cli::{
     Cli, Command, GenerateFilesArgs, GenerateStackingSignatureArgs, GetChunkArgs,
     GetLatestChunkArgs, PutChunkArgs, RunDkgArgs, SignArgs, StackerDBArgs,
 };
-use stacks_signer::config::Config;
+use stacks_signer::config::{build_signer_config_tomls, Config};
 use stacks_signer::runloop::{RunLoop, RunLoopCommand};
-use stacks_signer::utils::{build_signer_config_tomls, build_stackerdb_contract, to_addr};
+use stacks_signer::signer::Command as SignerCommand;
 use tracing_subscriber::prelude::*;
 use tracing_subscriber::{fmt, EnvFilter};
-use wsts::state_machine::coordinator::fire::Coordinator as FireCoordinator;
 use wsts::state_machine::OperationResult;
-use wsts::v2;
 
 struct SpawnedSigner {
     running_signer: RunningSigner<SignerEventReceiver, Vec<OperationResult>>,
@@ -88,20 +85,14 @@ fn write_chunk_to_stdout(chunk_opt: Option<Vec<u8>>) {
 // Spawn a running signer and return its handle, command sender, and result receiver
 fn spawn_running_signer(path: &PathBuf) -> SpawnedSigner {
     let config = Config::try_from(path).unwrap();
+    let endpoint = config.endpoint.clone();
     let (cmd_send, cmd_recv) = channel();
     let (res_send, res_recv) = channel();
-    let ev = SignerEventReceiver::new(
-        vec![config.stackerdb_contract_id.clone()],
-        config.network.is_mainnet(),
-    );
-    let runloop: RunLoop<FireCoordinator<v2::Aggregator>> = RunLoop::from(&config);
-    let mut signer: Signer<
-        RunLoopCommand,
-        Vec<OperationResult>,
-        RunLoop<FireCoordinator<v2::Aggregator>>,
-        SignerEventReceiver,
-    > = Signer::new(runloop, ev, cmd_recv, res_send);
-    let running_signer = signer.spawn(config.endpoint).unwrap();
+    let ev = SignerEventReceiver::new(config.network.is_mainnet());
+    let runloop = RunLoop::from(config);
+    let mut signer: Signer<RunLoopCommand, Vec<OperationResult>, RunLoop, SignerEventReceiver> =
+        Signer::new(runloop, ev, cmd_recv, res_send);
+    let running_signer = signer.spawn(endpoint).unwrap();
     SpawnedSigner {
         running_signer,
         cmd_send,
@@ -200,7 +191,11 @@ fn handle_put_chunk(args: PutChunkArgs) {
 fn handle_dkg(args: RunDkgArgs) {
     debug!("Running DKG...");
     let spawned_signer = spawn_running_signer(&args.config);
-    spawned_signer.cmd_send.send(RunLoopCommand::Dkg).unwrap();
+    let dkg_command = RunLoopCommand {
+        reward_cycle: args.reward_cycle,
+        command: SignerCommand::Dkg,
+    };
+    spawned_signer.cmd_send.send(dkg_command).unwrap();
     let dkg_res = spawned_signer.res_recv.recv().unwrap();
     process_dkg_result(&dkg_res);
     spawned_signer.running_signer.stop();
@@ -214,14 +209,15 @@ fn handle_sign(args: SignArgs) {
         spawned_signer.running_signer.stop();
         return;
     };
-    spawned_signer
-        .cmd_send
-        .send(RunLoopCommand::Sign {
+    let sign_command = RunLoopCommand {
+        reward_cycle: args.reward_cycle,
+        command: SignerCommand::Sign {
             block,
             is_taproot: false,
             merkle_root: None,
-        })
-        .unwrap();
+        },
+    };
+    spawned_signer.cmd_send.send(sign_command).unwrap();
     let sign_res = spawned_signer.res_recv.recv().unwrap();
     process_sign_result(&sign_res);
     spawned_signer.running_signer.stop();
@@ -235,16 +231,21 @@ fn handle_dkg_sign(args: SignArgs) {
         spawned_signer.running_signer.stop();
         return;
     };
-    // First execute DKG, then sign
-    spawned_signer.cmd_send.send(RunLoopCommand::Dkg).unwrap();
-    spawned_signer
-        .cmd_send
-        .send(RunLoopCommand::Sign {
+    let dkg_command = RunLoopCommand {
+        reward_cycle: args.reward_cycle,
+        command: SignerCommand::Dkg,
+    };
+    let sign_command = RunLoopCommand {
+        reward_cycle: args.reward_cycle,
+        command: SignerCommand::Sign {
             block,
             is_taproot: false,
             merkle_root: None,
-        })
-        .unwrap();
+        },
+    };
+    // First execute DKG, then sign
+    spawned_signer.cmd_send.send(dkg_command).unwrap();
+    spawned_signer.cmd_send.send(sign_command).unwrap();
     let dkg_res = spawned_signer.res_recv.recv().unwrap();
     process_dkg_result(&dkg_res);
     let sign_res = spawned_signer.res_recv.recv().unwrap();
@@ -285,20 +286,10 @@ fn handle_generate_files(args: GenerateFilesArgs) {
             .map(|_| StacksPrivateKey::new())
             .collect::<Vec<StacksPrivateKey>>()
     };
-    let signer_stacks_addresses = signer_stacks_private_keys
-        .iter()
-        .map(|key| to_addr(key, &args.network))
-        .collect::<Vec<StacksAddress>>();
-    // Build the signer and miner stackerdb contract
-    let signer_stackerdb_contract =
-        build_stackerdb_contract(&signer_stacks_addresses, SIGNER_SLOTS_PER_USER);
-    write_file(&args.dir, "signers.clar", &signer_stackerdb_contract);
 
     let signer_config_tomls = build_signer_config_tomls(
         &signer_stacks_private_keys,
-        args.num_keys,
         &args.host.to_string(),
-        &args.signers_contract.to_string(),
         args.timeout.map(Duration::from_millis),
         &args.network,
     );
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 16b254cc8f..03d20403f4 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -13,1093 +13,259 @@
 //
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
-use std::collections::VecDeque;
 use std::sync::mpsc::Sender;
 use std::time::Duration;
 
-use blockstack_lib::burnchains::Txid;
-use blockstack_lib::chainstate::nakamoto::NakamotoBlock;
-use blockstack_lib::chainstate::stacks::StacksTransaction;
-use blockstack_lib::net::api::postblock_proposal::BlockValidateResponse;
+use blockstack_lib::chainstate::stacks::boot::SIGNERS_NAME;
+use blockstack_lib::util_lib::boot::boot_code_id;
 use hashbrown::{HashMap, HashSet};
-use libsigner::{
-    BlockRejection, BlockResponse, RejectCode, SignerEvent, SignerMessage, SignerRunLoop,
-};
+use libsigner::{SignerEvent, SignerRunLoop};
 use slog::{slog_debug, slog_error, slog_info, slog_warn};
-use stacks_common::codec::{read_next, StacksMessageCodec};
-use stacks_common::types::chainstate::StacksAddress;
-use stacks_common::util::hash::{Sha256Sum, Sha512Trunc256Sum};
+use stacks_common::types::chainstate::{StacksAddress, StacksPublicKey};
+use stacks_common::util::hash::Sha256Sum;
 use stacks_common::{debug, error, info, warn};
-use wsts::common::{MerkleRoot, Signature};
 use wsts::curve::ecdsa;
-use wsts::curve::keys::PublicKey;
 use wsts::curve::point::{Compressed, Point};
-use wsts::net::{Message, NonceRequest, Packet, SignatureShareRequest};
-use wsts::state_machine::coordinator::fire::Coordinator as FireCoordinator;
-use wsts::state_machine::coordinator::{Config as CoordinatorConfig, Coordinator};
-use wsts::state_machine::signer::Signer;
-use wsts::state_machine::{OperationResult, PublicKeys, SignError};
-use wsts::v2;
+use wsts::state_machine::{OperationResult, PublicKeys};
 
-use crate::client::{
-    retry_with_exponential_backoff, ClientError, EpochId, StackerDB, StacksClient,
-};
-use crate::config::{Config, Network};
+use crate::client::{retry_with_exponential_backoff, ClientError, StacksClient};
+use crate::config::Config;
+use crate::signer::{Command as SignerCommand, Signer, StacksNodeInfo, State as SignerState};
 
 /// Which operation to perform
-#[derive(PartialEq, Clone)]
-pub enum RunLoopCommand {
-    /// Generate a DKG aggregate public key
-    Dkg,
-    /// Sign a message
-    Sign {
-        /// The block to sign over
-        block: NakamotoBlock,
-        /// Whether to make a taproot signature
-        is_taproot: bool,
-        /// Taproot merkle root
-        merkle_root: Option<MerkleRoot>,
-    },
+#[derive(PartialEq, Clone, Debug)]
+pub struct RunLoopCommand {
+    /// Which signer operation to perform
+    pub command: SignerCommand,
+    /// The reward cycle we are performing the operation for
+    pub reward_cycle: u64,
 }
 
-/// The RunLoop state
+/// The runloop state
 #[derive(PartialEq, Debug)]
 pub enum State {
-    // TODO: Uninitialized should indicate we need to replay events/configure the signer
-    /// The runloop signer is uninitialized
+    /// The runloop is uninitialized
     Uninitialized,
-    /// The runloop is idle
-    Idle,
-    /// The runloop is executing a DKG round
-    Dkg,
-    /// The runloop is executing a signing round
-    Sign,
-}
-
-/// Additional Info about a proposed block
-pub struct BlockInfo {
-    /// The block we are considering
-    block: NakamotoBlock,
-    /// Our vote on the block if we have one yet
-    vote: Option<Vec<u8>>,
-    /// Whether the block contents are valid
-    valid: Option<bool>,
-    /// The associated packet nonce request if we have one
-    nonce_request: Option<NonceRequest>,
-    /// Whether this block is already being signed over
-    signed_over: bool,
-}
-
-impl BlockInfo {
-    /// Create a new BlockInfo
-    pub fn new(block: NakamotoBlock) -> Self {
-        Self {
-            block,
-            vote: None,
-            valid: None,
-            nonce_request: None,
-            signed_over: false,
-        }
-    }
-
-    /// Create a new BlockInfo with an associated nonce request packet
-    pub fn new_with_request(block: NakamotoBlock, nonce_request: NonceRequest) -> Self {
-        Self {
-            block,
-            vote: None,
-            valid: None,
-            nonce_request: Some(nonce_request),
-            signed_over: true,
-        }
-    }
+    /// The runloop is initialized
+    Initialized,
 }
 
 /// The runloop for the stacks signer
-pub struct RunLoop<C> {
-    /// The timeout for events
-    pub event_timeout: Duration,
-    /// The coordinator for inbound messages
-    pub coordinator: C,
-    /// The signing round used to sign messages
-    pub signing_round: Signer<v2::Signer>,
+pub struct RunLoop {
+    /// Configuration info
+    pub config: Config,
     /// The stacks node client
     pub stacks_client: StacksClient,
-    /// The stacker db client
-    pub stackerdb: StackerDB,
-    /// Received Commands that need to be processed
-    pub commands: VecDeque<RunLoopCommand>,
-    /// The current state
+    /// The internal signer for an odd or even reward cycle
+    /// Keyed by reward cycle % 2
+    pub stacks_signers: HashMap<u64, Signer>,
+    /// The state of the runloop
     pub state: State,
-    /// Wether mainnet or not
-    pub mainnet: bool,
-    /// Observed blocks that we have seen so far
-    // TODO: cleanup storage and garbage collect this stuff
-    pub blocks: HashMap<Sha512Trunc256Sum, BlockInfo>,
-    /// Transactions that we expect to see in the next block
-    // TODO: fill this in and do proper garbage collection
-    pub transactions: Vec<Txid>,
-    /// This signer's ID
-    pub signer_id: u32,
-    /// The signer set for this runloop
-    pub signer_set: Option<u32>,
-    /// The index into the signers list of this signer's key (may be different from signer_id)
-    pub signer_slot_id: Option<u32>,
-    /// The IDs of all signers partipating in the current reward cycle
-    pub signer_ids: Vec<u32>,
-    /// The stacks addresses of the signers participating in the current reward cycle
-    pub signer_addresses: Vec<StacksAddress>,
 }
 
-impl<C: Coordinator> RunLoop<C> {
-    /// Get and store the signer set assignment for this runloop.
-    /// This assigns the runloop to the _next_ reward cycle, not the current one.
-    /// Returns (signer-set, signer-slot-id)
-    fn get_or_set_signer_info(&mut self) -> Result<(u32, u32), ClientError> {
-        match (self.signer_set.as_ref(), self.signer_slot_id.as_ref()) {
-            (Some(signer_set), Some(signer_slot_id)) => {
-                return Ok((*signer_set, *signer_slot_id));
-            }
-            (_, _) => {}
-        }
-
-        let signer_set = if let Some(signer_set) = self.signer_set.as_ref() {
-            *signer_set
-        } else {
-            let rc = self
-                .stacks_client
-                .get_current_reward_cycle()?
-                .saturating_add(1);
-            debug!("Next reward cycle is {}", rc);
-            let signer_set = u32::try_from(rc % 2).expect("FATAL: infallible");
-            self.signer_set = Some(signer_set);
-            self.stackerdb.set_signer_set(signer_set);
-            signer_set
-        };
-
-        // Get the signer writers from the stacker-db to verify transactions against
-        self.signer_addresses = self
-            .stacks_client
-            .get_stackerdb_signer_slots(
-                self.stackerdb.signers_contract_id(),
-                self.stackerdb.get_signer_set(),
-            )?
-            .into_iter()
-            .map(|(address, _)| address)
-            .collect();
-
-        let signer_slot_id = if let Some(signer_slot_id) = self.signer_slot_id.as_ref() {
-            *signer_slot_id
-        } else {
-            let addr = self.stackerdb.get_signer_address(self.mainnet);
-            self.signer_slot_id = self
-                .signer_addresses
-                .iter()
-                .position(|signer_addr| signer_addr == &addr)
-                .map(|pos| u32::try_from(pos).expect("FATAL: position exceeds u32::MAX"));
-
-            let Some(signer_slot_id) = self.signer_slot_id.as_ref() else {
-                return Err(ClientError::InvalidSigningKey);
-            };
-            self.stackerdb.set_signer_slot_id(*signer_slot_id);
-            *signer_slot_id
-        };
-
-        Ok((signer_set, signer_slot_id))
-    }
-
-    /// Initialize the signer, reading the stacker-db state and setting the aggregate public key
-    fn initialize(&mut self) -> Result<(), ClientError> {
-        // determine what signer set we're using, so we use the right stackerdb replicas
-        let (signer_set, signer_slot_id) = self.get_or_set_signer_info()?;
-        debug!(
-            "Signer #{}: Self-assigning to signer set {} slot {} address {}",
-            self.signer_id,
-            signer_set,
-            signer_slot_id,
-            self.stackerdb.get_signer_address(self.mainnet)
-        );
-
-        // Check if the aggregate key is set in the pox contract
-        if let Some(key) = self.stacks_client.get_aggregate_public_key()? {
-            debug!(
-                "Signer #{}: Aggregate public key is set: {:?}",
-                self.signer_id, key
-            );
-            self.coordinator.set_aggregate_public_key(Some(key));
-        } else {
-            debug!(
-                "Signer #{}: Aggregate public key is not set. Coordinator must trigger DKG...",
-                self.signer_id
-            );
-            // Update the state to IDLE so we don't needlessy requeue the DKG command.
-            let (coordinator_id, _) =
-                calculate_coordinator(&self.signing_round.public_keys, &self.stacks_client);
-            if coordinator_id == self.signer_id
-                && self.commands.front() != Some(&RunLoopCommand::Dkg)
-            {
-                self.commands.push_front(RunLoopCommand::Dkg);
-            }
-        }
-
-        self.state = State::Idle;
-        Ok(())
-    }
-
-    /// Execute the given command and update state accordingly
-    /// Returns true when it is successfully executed, else false
-    fn execute_command(&mut self, command: &RunLoopCommand) -> bool {
-        match command {
-            RunLoopCommand::Dkg => {
-                info!("Signer #{}: Starting DKG", self.signer_id);
-                match self.coordinator.start_dkg_round() {
-                    Ok(msg) => {
-                        let ack = self.stackerdb.send_message_with_retry(msg.into());
-                        debug!("Signer #{}: ACK: {:?}", self.signer_id, ack);
-                        self.state = State::Dkg;
-                        true
-                    }
-                    Err(e) => {
-                        error!("Failed to start DKG: {:?}", e);
-                        warn!("Resetting coordinator's internal state.");
-                        self.coordinator.reset();
-                        false
-                    }
-                }
-            }
-            RunLoopCommand::Sign {
-                block,
-                is_taproot,
-                merkle_root,
-            } => {
-                let signer_signature_hash = block.header.signer_signature_hash();
-                let block_info = self
-                    .blocks
-                    .entry(signer_signature_hash)
-                    .or_insert_with(|| BlockInfo::new(block.clone()));
-                if block_info.signed_over {
-                    debug!("Signer #{}: Received a sign command for a block we are already signing over. Ignore it.", self.signer_id);
-                    return false;
-                }
-                info!("Signer #{}: Signing block: {:?}", self.signer_id, block);
-                match self.coordinator.start_signing_round(
-                    &block.serialize_to_vec(),
-                    *is_taproot,
-                    *merkle_root,
-                ) {
-                    Ok(msg) => {
-                        let ack = self.stackerdb.send_message_with_retry(msg.into());
-                        debug!("Signer #{}: ACK: {:?}", self.signer_id, ack);
-                        self.state = State::Sign;
-                        block_info.signed_over = true;
-                        true
-                    }
-                    Err(e) => {
-                        error!(
-                            "Signer #{}: Failed to start signing message: {:?}",
-                            self.signer_id, e
-                        );
-                        warn!(
-                            "Signer #{}: Resetting coordinator's internal state.",
-                            self.signer_id
-                        );
-                        self.coordinator.reset();
-                        false
-                    }
-                }
-            }
-        }
-    }
-
-    /// Attempt to process the next command in the queue, and update state accordingly
-    fn process_next_command(&mut self) {
-        match self.state {
-            State::Uninitialized => {
-                debug!(
-                    "Signer #{}: uninitialized. Waiting for aggregate public key from stacks node...", self.signer_id
-                );
-            }
-            State::Idle => {
-                if let Some(command) = self.commands.pop_front() {
-                    while !self.execute_command(&command) {
-                        warn!(
-                            "Signer #{}: Failed to execute command. Retrying...",
-                            self.signer_id
-                        );
-                    }
-                } else {
-                    debug!(
-                        "Signer #{}: Nothing to process. Waiting for command...",
-                        self.signer_id
-                    );
-                }
-            }
-            State::Dkg | State::Sign => {
-                // We cannot execute the next command until the current one is finished...
-                // Do nothing...
-                debug!(
-                    "Signer #{}: Waiting for {:?} operation to finish",
-                    self.signer_id, self.state
-                );
-            }
+impl From<Config> for RunLoop {
+    /// Creates new runloop from a config
+    fn from(config: Config) -> Self {
+        let stacks_client = StacksClient::from(&config);
+        RunLoop {
+            config,
+            stacks_client,
+            stacks_signers: HashMap::with_capacity(2),
+            state: State::Uninitialized,
         }
     }
+}
 
-    /// Handle the block validate response returned from our prior calls to submit a block for validation
-    fn handle_block_validate_response(
+impl RunLoop {
+    /// Get a signer configruation for a specific reward cycle from the stacks node
+    fn get_stacks_node_info(
         &mut self,
-        block_validate_response: BlockValidateResponse,
-        res: Sender<Vec<OperationResult>>,
-    ) {
-        let block_info = match block_validate_response {
-            BlockValidateResponse::Ok(block_validate_ok) => {
-                let signer_signature_hash = block_validate_ok.signer_signature_hash;
-                // For mutability reasons, we need to take the block_info out of the map and add it back after processing
-                let Some(mut block_info) = self.blocks.remove(&signer_signature_hash) else {
-                    // We have not seen this block before. Why are we getting a response for it?
-                    debug!("Received a block validate response for a block we have not seen before. Ignoring...");
-                    return;
-                };
-                let is_valid = self.verify_transactions(&block_info.block);
-                block_info.valid = Some(is_valid);
-                info!(
-                    "Signer #{}: Treating block validation for block {} as valid: {:?}",
-                    self.signer_id,
-                    &block_info.block.block_id(),
-                    block_info.valid
-                );
-                // Add the block info back to the map
-                self.blocks
-                    .entry(signer_signature_hash)
-                    .or_insert(block_info)
-            }
-            BlockValidateResponse::Reject(block_validate_reject) => {
-                let signer_signature_hash = block_validate_reject.signer_signature_hash;
-                let Some(block_info) = self.blocks.get_mut(&signer_signature_hash) else {
-                    // We have not seen this block before. Why are we getting a response for it?
-                    debug!("Signer #{}: Received a block validate response for a block we have not seen before. Ignoring...", self.signer_id);
-                    return;
-                };
-                block_info.valid = Some(false);
-                // Submit a rejection response to the .signers contract for miners
-                // to observe so they know to send another block and to prove signers are doing work);
-                warn!("Signer #{}: Broadcasting a block rejection due to stacks node validation failure...", self.signer_id);
-                if let Err(e) = self
-                    .stackerdb
-                    .send_message_with_retry(block_validate_reject.into())
-                {
-                    warn!(
-                        "Signer #{}: Failed to send block rejection to stacker-db: {:?}",
-                        self.signer_id, e
-                    );
-                }
-                block_info
-            }
-        };
-
-        if let Some(mut nonce_request) = block_info.nonce_request.take() {
-            debug!("Signer #{}: Received a block validate response from the stacks node for a block we already received a nonce request for. Responding to the nonce request...", self.signer_id);
-            // We have received validation from the stacks node. Determine our vote and update the request message
-            Self::determine_vote(self.signer_id, block_info, &mut nonce_request);
-            // Send the nonce request through with our vote
-            let packet = Packet {
-                msg: Message::NonceRequest(nonce_request),
-                sig: vec![],
-            };
-            self.handle_packets(res, &[packet]);
-        } else {
-            let (coordinator_id, _) =
-                calculate_coordinator(&self.signing_round.public_keys, &self.stacks_client);
-            if block_info.valid.unwrap_or(false)
-                && !block_info.signed_over
-                && coordinator_id == self.signer_id
-            {
-                // We are the coordinator. Trigger a signing round for this block
-                debug!(
-                    "Signer triggering a signing round over the block.";
-                    "block_hash" => block_info.block.header.block_hash(),
-                    "signer_id" => self.signer_id,
-                );
-                self.commands.push_back(RunLoopCommand::Sign {
-                    block: block_info.block.clone(),
-                    is_taproot: false,
-                    merkle_root: None,
-                });
-            } else {
-                debug!(
-                    "Signer ignoring block.";
-                    "block_hash" => block_info.block.header.block_hash(),
-                    "valid" => block_info.valid,
-                    "signed_over" => block_info.signed_over,
-                    "coordinator_id" => coordinator_id,
-                    "signer_id" => self.signer_id,
-                );
-            }
+        reward_cycle: u64,
+    ) -> Result<Option<StacksNodeInfo>, backoff::Error<ClientError>> {
+        let reward_set_calculated = self
+            .stacks_client
+            .reward_set_calculated(reward_cycle)
+            .map_err(backoff::Error::transient)?;
+        if !reward_set_calculated {
+            // Must weight for the reward set calculation to complete
+            // Accounts for Pre nakamoto by simply using the second block of a prepare phase as the criteria
+            return Err(backoff::Error::transient(
+                ClientError::RewardSetNotYetCalculated(reward_cycle),
+            ));
         }
-    }
-
-    /// Handle signer messages submitted to signers stackerdb
-    fn handle_signer_messages(
-        &mut self,
-        res: Sender<Vec<OperationResult>>,
-        messages: Vec<SignerMessage>,
-    ) {
-        let (coordinator_id, coordinator_public_key) =
-            calculate_coordinator(&self.signing_round.public_keys, &self.stacks_client);
-        debug!(
-            "Signer #{}: coordinator is signer #{} public key {}",
-            self.signer_id, coordinator_id, &coordinator_public_key
-        );
-        let packets: Vec<Packet> = messages
-            .into_iter()
-            .filter_map(|msg| match msg {
-                SignerMessage::BlockResponse(_) | SignerMessage::Transactions(_) => None,
-                SignerMessage::Packet(packet) => {
-                    self.verify_packet(packet, &coordinator_public_key)
-                }
-            })
-            .collect();
-        self.handle_packets(res, &packets);
-    }
-
-    /// Handle proposed blocks submitted by the miners to stackerdb
-    fn handle_proposed_blocks(&mut self, blocks: Vec<NakamotoBlock>) {
-        for block in blocks {
-            // Store the block in our cache
-            self.blocks.insert(
-                block.header.signer_signature_hash(),
-                BlockInfo::new(block.clone()),
+        let current_addr = self.stacks_client.get_signer_address();
+        let mut current_signer_id = None;
+
+        let signer_set =
+            u32::try_from(reward_cycle % 2).expect("FATAL: reward_cycle % 2 exceeds u32::MAX");
+        let signer_stackerdb_contract_id =
+            boot_code_id(SIGNERS_NAME, self.config.network.is_mainnet());
+        // Get the signer writers from the stacker-db to find the signer slot id
+        let Some(signer_slot_id) = self
+            .stacks_client
+            .get_stackerdb_signer_slots(&signer_stackerdb_contract_id, signer_set)
+            .map_err(backoff::Error::transient)?
+            .iter()
+            .position(|(address, _)| address == current_addr)
+            .map(|pos| u32::try_from(pos).expect("FATAL: number of signers exceeds u32::MAX"))
+        else {
+            warn!(
+                "Signer {current_addr} was not found in stacker db. Must not be registered for this reward cycle {reward_cycle}."
             );
-            // Submit the block for validation
-            self.stacks_client
-                .submit_block_for_validation(block)
-                .unwrap_or_else(|e| {
-                    warn!("Failed to submit block for validation: {:?}", e);
-                });
-        }
-    }
-
-    /// Process inbound packets as both a signer and a coordinator
-    /// Will send outbound packets and operation results as appropriate
-    fn handle_packets(&mut self, res: Sender<Vec<OperationResult>>, packets: &[Packet]) {
-        let signer_outbound_messages = self
-            .signing_round
-            .process_inbound_messages(packets)
-            .unwrap_or_else(|e| {
-                error!("Failed to process inbound messages as a signer: {e}");
-                vec![]
-            });
-
-        // Next process the message as the coordinator
-        let (coordinator_outbound_messages, operation_results) = self
-            .coordinator
-            .process_inbound_messages(packets)
-            .unwrap_or_else(|e| {
-                error!("Failed to process inbound messages as a coordinator: {e}");
-                (vec![], vec![])
-            });
-
-        if !operation_results.is_empty() {
-            // We have finished a signing or DKG round, either successfully or due to error.
-            // Regardless of the why, update our state to Idle as we should not expect the operation to continue.
-            self.state = State::Idle;
-            self.process_operation_results(&operation_results);
-            self.send_operation_results(res, operation_results);
-        }
-        self.send_outbound_messages(signer_outbound_messages);
-        self.send_outbound_messages(coordinator_outbound_messages);
-    }
-
-    /// Validate a signature share request, updating its message where appropriate.
-    /// If the request is for a block it has already agreed to sign, it will overwrite the message with the agreed upon value
-    /// Returns whether the request is valid or not.
-    fn validate_signature_share_request(&self, request: &mut SignatureShareRequest) -> bool {
-        let message_len = request.message.len();
-        // Note that the message must always be either 32 bytes (the block hash) or 33 bytes (block hash + b'n')
-        let hash_bytes = if message_len == 33 && request.message[32] == b'n' {
-            // Pop off the 'n' byte from the block hash
-            &request.message[..32]
-        } else if message_len == 32 {
-            // This is the block hash
-            &request.message
-        } else {
-            // We will only sign across block hashes or block hashes + b'n' byte
-            debug!("Signer #{}: Received a signature share request for an unknown message stream. Reject it.", self.signer_id);
-            return false;
+            return Ok(None);
         };
 
-        let Some(hash) = Sha512Trunc256Sum::from_bytes(hash_bytes) else {
-            // We will only sign across valid block hashes
-            debug!("Signer #{}: Received a signature share request for an invalid block hash. Reject it.", self.signer_id);
-            return false;
-        };
-        match self.blocks.get(&hash).map(|block_info| &block_info.vote) {
-            Some(Some(vote)) => {
-                // Overwrite with our agreed upon value in case another message won majority or the coordinator is trying to cheat...
-                debug!(
-                    "Signer #{}: set vote for {} to {:?}",
-                    self.signer_id, &hash, &vote
-                );
-                request.message = vote.clone();
-                true
-            }
-            Some(None) => {
-                // We never agreed to sign this block. Reject it.
-                // This can happen if the coordinator received enough votes to sign yes
-                // or no on a block before we received validation from the stacks node.
-                debug!("Signer #{}: Received a signature share request for a block we never agreed to sign. Ignore it.", self.signer_id);
-                false
-            }
-            None => {
-                // We will only sign across block hashes or block hashes + b'n' byte for
-                // blocks we have seen a Nonce Request for (and subsequent validation)
-                // We are missing the context here necessary to make a decision. Reject the block
-                debug!("Signer #{}: Received a signature share request from an unknown block. Reject it.", self.signer_id);
-                false
-            }
-        }
-    }
-
-    /// Validate a nonce request, updating its message appropriately.
-    /// If the request is for a block, we will update the request message
-    /// as either a hash indicating a vote no or the signature hash indicating a vote yes
-    /// Returns whether the request is valid or not
-    fn validate_nonce_request(&mut self, nonce_request: &mut NonceRequest) -> bool {
-        let Some(block) = read_next::<NakamotoBlock, _>(&mut &nonce_request.message[..]).ok()
+        // We can only register for a reward cycle if a reward set exists. We know that it should exist due to our earlier check for reward_set_calculated
+        let Some(reward_set_signers) = self.stacks_client.get_reward_set(reward_cycle)?.signers
         else {
-            // We currently reject anything that is not a block
-            debug!(
-                "Signer #{}: Received a nonce request for an unknown message stream. Reject it.",
-                self.signer_id
+            warn!(
+                "No reward set found for reward cycle {reward_cycle}. Must not be a valid Nakamoto reward cycle."
             );
-            return false;
+            return Ok(None);
         };
-        let signer_signature_hash = block.header.signer_signature_hash();
-        let Some(block_info) = self.blocks.get_mut(&signer_signature_hash) else {
-            // We have not seen this block before. Cache it. Send a RPC to the stacks node to validate it.
-            debug!("Signer #{}: We have received a block sign request for a block we have not seen before. Cache the nonce request and submit the block for validation...", self.signer_id);
-            // Store the block in our cache
-            self.blocks.insert(
-                signer_signature_hash,
-                BlockInfo::new_with_request(block.clone(), nonce_request.clone()),
-            );
-            self.stacks_client
-                .submit_block_for_validation(block)
-                .unwrap_or_else(|e| {
-                    warn!(
-                        "Signer #{}: Failed to submit block for validation: {:?}",
-                        self.signer_id, e
-                    );
-                });
-            return false;
-        };
-
-        if block_info.valid.is_none() {
-            // We have not yet received validation from the stacks node. Cache the request and wait for validation
-            debug!("Signer #{}: We have yet to receive validation from the stacks node for a nonce request. Cache the nonce request and wait for block validation...", self.signer_id);
-            block_info.nonce_request = Some(nonce_request.clone());
-            return false;
-        }
-
-        Self::determine_vote(self.signer_id, block_info, nonce_request);
-        true
-    }
 
-    /// Verify the transactions in a block are as expected
-    fn verify_transactions(&mut self, block: &NakamotoBlock) -> bool {
-        if let Ok(expected_transactions) = self.get_expected_transactions() {
-            //It might be worth building a hashset of the blocks' txids and checking that against the expected transaction's txid.
-            let block_tx_hashset = block.txs.iter().map(|tx| tx.txid()).collect::<HashSet<_>>();
-            // Ensure the block contains the transactions we expect
-            let missing_transactions = expected_transactions
-                .into_iter()
-                .filter_map(|tx| {
-                    if !block_tx_hashset.contains(&tx.txid()) {
-                        debug!(
-                            "Signer #{}: expected txid {} is in the block",
-                            self.signer_id,
-                            &tx.txid()
-                        );
-                        Some(tx)
-                    } else {
-                        debug!(
-                            "Signer #{}: missing expected txid {}",
-                            self.signer_id,
-                            &tx.txid()
-                        );
-                        None
-                    }
-                })
-                .collect::<Vec<_>>();
-            let is_valid = missing_transactions.is_empty();
-            if !is_valid {
-                debug!("Signer #{}: Broadcasting a block rejection due to missing expected transactions...", self.signer_id);
-                let block_rejection = BlockRejection::new(
-                    block.header.signer_signature_hash(),
-                    RejectCode::MissingTransactions(missing_transactions),
-                );
-                // Submit signature result to miners to observe
-                if let Err(e) = self
-                    .stackerdb
-                    .send_message_with_retry(block_rejection.into())
-                {
-                    warn!("Failed to send block submission to stacker-db: {:?}", e);
-                }
+        let mut weight_end = 1;
+        let mut signer_key_ids = HashMap::with_capacity(4000);
+        let mut signer_addresses = HashSet::with_capacity(reward_set_signers.len());
+        let mut public_keys = PublicKeys {
+            signers: HashMap::with_capacity(reward_set_signers.len()),
+            key_ids: HashMap::with_capacity(4000),
+        };
+        let mut signer_public_keys = HashMap::with_capacity(reward_set_signers.len());
+        for (i, entry) in reward_set_signers.iter().enumerate() {
+            let signer_id = u32::try_from(i).expect("FATAL: number of signers exceeds u32::MAX");
+            let ecdsa_public_key = ecdsa::PublicKey::try_from(entry.signing_key.as_slice()).map_err(|e| {
+                backoff::Error::transient(ClientError::CorruptedRewardSet(format!(
+                        "Reward cycle {reward_cycle} failed to convert signing key to ecdsa::PublicKey: {e}"
+                    )))
+                })?;
+            let signer_public_key = Point::try_from(&Compressed::from(ecdsa_public_key.to_bytes()))
+                .map_err(|e| {
+                    backoff::Error::transient(ClientError::CorruptedRewardSet(format!(
+                        "Reward cycle {reward_cycle} failed to convert signing key to Point: {e}"
+                    )))
+                })?;
+            let stacks_public_key = StacksPublicKey::from_slice(entry.signing_key.as_slice()).map_err(|e| {
+                    backoff::Error::transient(ClientError::CorruptedRewardSet(format!(
+                        "Reward cycle {reward_cycle} failed to convert signing key to StacksPublicKey: {e}"
+                    )))
+                })?;
+
+            let stacks_address =
+                StacksAddress::p2pkh(self.config.network.is_mainnet(), &stacks_public_key);
+            if &stacks_address == current_addr {
+                current_signer_id = Some(signer_id);
             }
-            is_valid
-        } else {
-            // Failed to connect to the stacks node to get transactions. Cannot validate the block. Reject it.
-            debug!(
-                "Signer #{}: Broadcasting a block rejection due to signer connectivity issues...",
-                self.signer_id
-            );
-            let block_rejection = BlockRejection::new(
-                block.header.signer_signature_hash(),
-                RejectCode::ConnectivityIssues,
-            );
-            // Submit signature result to miners to observe
-            if let Err(e) = self
-                .stackerdb
-                .send_message_with_retry(block_rejection.into())
-            {
-                warn!(
-                    "Signer #{}: Failed to send block submission to stacker-db: {:?}",
-                    self.signer_id, e
-                );
+            signer_addresses.insert(stacks_address);
+            signer_public_keys.insert(signer_id, signer_public_key);
+            let weight_start = weight_end;
+            weight_end = weight_start + entry.slots;
+            for key_id in weight_start..weight_end {
+                public_keys.key_ids.insert(key_id, ecdsa_public_key.clone());
+                signer_key_ids
+                    .entry(signer_id)
+                    .or_insert(HashSet::with_capacity(entry.slots as usize))
+                    .insert(key_id);
             }
-            false
-        }
-    }
-
-    /// Get the transactions we expect to see in the next block
-    fn get_expected_transactions(&mut self) -> Result<Vec<StacksTransaction>, ClientError> {
-        let signer_ids = self
-            .signing_round
-            .public_keys
-            .signers
-            .keys()
-            .cloned()
-            .collect::<Vec<_>>();
-        let transactions = self
-            .stackerdb
-            .get_signer_transactions_with_retry(&signer_ids)?.into_iter().filter_map(|transaction| {
-                // TODO: Filter out transactions that are not special cased transactions (cast votes, etc.)
-                // Filter out transactions that have already been confirmed (can happen if a signer did not update stacker db since the last block was processed)
-                let origin_address = transaction.origin_address();
-                let origin_nonce = transaction.get_origin_nonce();
-                let Ok(account_nonce) = self.stacks_client.get_account_nonce(&origin_address) else {
-                    warn!("Signer #{}: Unable to get account for address: {origin_address}. Ignoring it for this block...", self.signer_id);
-                    return None;
-                };
-                if !self.signer_addresses.contains(&origin_address) || origin_nonce < account_nonce {
-                    debug!("Signer #{}: Received a transaction for signer id ({}) that is either not valid or has already been confirmed (origin={}, account={}). Ignoring it.", self.signer_id, &origin_address, origin_nonce, account_nonce);
-                    return None;
-                }
-                debug!("Signer #{}: Expect transaction {} ({:?})", self.signer_id, transaction.txid(), &transaction);
-                Some(transaction)
-            }).collect();
-        Ok(transactions)
-    }
-
-    /// Determine the vote for a block and update the block info and nonce request accordingly
-    fn determine_vote(
-        signer_id: u32,
-        block_info: &mut BlockInfo,
-        nonce_request: &mut NonceRequest,
-    ) {
-        let mut vote_bytes = block_info.block.header.signer_signature_hash().0.to_vec();
-        // Validate the block contents
-        if !block_info.valid.unwrap_or(false) {
-            // We don't like this block. Update the request to be across its hash with a byte indicating a vote no.
-            debug!(
-                "Signer #{}: Updating the request with a block hash with a vote no.",
-                signer_id
-            );
-            vote_bytes.push(b'n');
-        } else {
-            debug!("Signer #{}: The block passed validation. Update the request with the signature hash.", signer_id);
         }
-
-        // Cache our vote
-        block_info.vote = Some(vote_bytes.clone());
-        nonce_request.message = vote_bytes;
+        let Some(signer_id) = current_signer_id else {
+            warn!("Signer {current_addr} was found in stacker db but not the reward set for reward cycle {reward_cycle}.");
+            return Ok(None);
+        };
+        Ok(Some(StacksNodeInfo {
+            reward_cycle,
+            signer_id,
+            signer_slot_id,
+            signer_set,
+            signer_addresses,
+            signer_key_ids,
+            public_keys,
+            signer_public_keys,
+        }))
     }
 
-    /// Verify a chunk is a valid wsts packet. Returns the packet if it is valid, else None.
-    /// NOTE: The packet will be updated if the signer wishes to respond to NonceRequest
-    /// and SignatureShareRequests with a different message than what the coordinator originally sent.
-    /// This is done to prevent a malicious coordinator from sending a different message than what was
-    /// agreed upon and to support the case where the signer wishes to reject a block by voting no
-    fn verify_packet(
+    /// Refresh signer configuration for a specific reward cycle
+    fn refresh_signer_config(
         &mut self,
-        mut packet: Packet,
-        coordinator_public_key: &PublicKey,
-    ) -> Option<Packet> {
-        // We only care about verified wsts packets. Ignore anything else.
-        if packet.verify(&self.signing_round.public_keys, coordinator_public_key) {
-            match &mut packet.msg {
-                Message::SignatureShareRequest(request) => {
-                    if !self.validate_signature_share_request(request) {
-                        return None;
-                    }
-                }
-                Message::NonceRequest(request) => {
-                    if !self.validate_nonce_request(request) {
-                        return None;
-                    }
-                }
-                _ => {
-                    // Nothing to do for other message types
-                }
-            }
-            Some(packet)
-        } else {
-            debug!(
-                "Signer #{}: Failed to verify wsts packet with {}: {:?}",
-                self.signer_id, coordinator_public_key, &packet
-            );
-            None
-        }
-    }
-
-    /// Processes the operation results, broadcasting block acceptance or rejection messages
-    /// and DKG vote results accordingly
-    fn process_operation_results(&mut self, operation_results: &[OperationResult]) {
-        for operation_result in operation_results {
-            // Signers only every trigger non-taproot signing rounds over blocks. Ignore SignTaproot results
-            match operation_result {
-                OperationResult::Sign(signature) => {
-                    debug!("Signer #{}: Received signature result", self.signer_id);
-                    self.process_signature(signature);
-                }
-                OperationResult::SignTaproot(_) => {
-                    debug!("Signer #{}: Received a signature result for a taproot signature. Nothing to broadcast as we currently sign blocks with a FROST signature.", self.signer_id);
-                }
-                OperationResult::Dkg(point) => {
-                    // TODO: cast the aggregate public key for the latest round here
-                    // Broadcast via traditional methods to the stacks node if we are pre nakamoto or we cannot determine our Epoch
-                    let epoch = self
-                        .stacks_client
-                        .get_node_epoch()
-                        .unwrap_or(EpochId::UnsupportedEpoch);
-                    match epoch {
-                        EpochId::UnsupportedEpoch => {
-                            debug!("Signer #{}: Received a DKG result, but are in an unsupported epoch. Do not broadcast the result.", self.signer_id);
-                        }
-                        EpochId::Epoch25 => {
-                            debug!("Signer #{}: Received a DKG result, but are in epoch 2.5. Broadcast the transaction to the mempool.", self.signer_id);
-                            match self
-                                .stacks_client
-                                .cast_vote_for_aggregate_public_key(point.clone(), 0)
-                            {
-                                Ok(txid) => {
-                                    self.transactions.push(txid);
-                                    println!(
-                                        "Successfully cast aggregate public key vote: {:?}",
-                                        txid
-                                    )
-                                }
-                                Err(e) => {
-                                    warn!("Failed to cast aggregate public key vote: {:?}", e);
-                                }
-                            }
-                        }
-                        EpochId::Epoch30 => {
-                            // TODO: get the latest round
-                            match self
-                                .stacks_client
-                                .build_vote_for_aggregate_public_key(point.clone(), 0)
-                            {
-                                Ok(transaction) => {
-                                    // TODO retreive transactions from stackerdb, append to it, and send back
-                                    debug!("Signer #{}: Received a DKG result, but are in epoch 3. Broadcast the transaction to stackerDB.", self.signer_id);
-                                    let signer_message =
-                                        SignerMessage::Transactions(vec![transaction]);
-                                    if let Err(e) =
-                                        self.stackerdb.send_message_with_retry(signer_message)
-                                    {
-                                        warn!(
-                                            "Signer #{}: Failed to update transactions in stacker-db: {:?}",
-                                            self.signer_id, e
-                                        );
-                                    }
-                                }
-                                Err(e) => {
-                                    warn!("Signer #{}: Failed to build a vote transaction for the aggregate public key: {:?}", self.signer_id, e);
-                                    continue;
-                                }
-                            }
-                        }
-                    }
-                }
-                OperationResult::SignError(e) => {
-                    self.process_sign_error(e);
-                }
-                OperationResult::DkgError(e) => {
-                    warn!("Signer #{}: Received a DKG error: {:?}", self.signer_id, e);
-                }
+        reward_cycle: u64,
+    ) -> Result<(), backoff::Error<ClientError>> {
+        let reward_index = reward_cycle % 2;
+        let mut needs_refresh = false;
+        if let Some(stacks_signer) = self.stacks_signers.get_mut(&reward_index) {
+            let old_reward_cycle = stacks_signer.reward_cycle;
+            if old_reward_cycle == reward_cycle {
+                //If the signer is already registered for the reward cycle, we don't need to do anything further here
+                debug!("Signer is already configured for reward cycle {reward_cycle}. No need to update it's state machines.")
+            } else {
+                needs_refresh = true;
             }
-        }
-    }
-
-    /// Process a signature from a signing round by deserializing the signature and
-    /// broadcasting an appropriate Reject or Approval message to stackerdb
-    fn process_signature(&mut self, signature: &Signature) {
-        // Deserialize the signature result and broadcast an appropriate Reject or Approval message to stackerdb
-        let Some(aggregate_public_key) = &self.coordinator.get_aggregate_public_key() else {
-            debug!(
-                "Signer #{}: No aggregate public key set. Cannot validate signature...",
-                self.signer_id
-            );
-            return;
-        };
-        let message = self.coordinator.get_message();
-        // This jankiness is because a coordinator could have signed a rejection we need to find the underlying block hash
-        let signer_signature_hash_bytes = if message.len() > 32 {
-            &message[..32]
-        } else {
-            &message
-        };
-        let Some(signer_signature_hash) =
-            Sha512Trunc256Sum::from_bytes(signer_signature_hash_bytes)
-        else {
-            debug!("Signer #{}: Received a signature result for a signature over a non-block. Nothing to broadcast.", self.signer_id);
-            return;
-        };
-
-        // TODO: proper garbage collection...This is currently our only cleanup of blocks
-        self.blocks.remove(&signer_signature_hash);
-
-        // This signature is no longer valid. Do not broadcast it.
-        if !signature.verify(aggregate_public_key, &message) {
-            warn!("Signer #{}: Received an invalid signature result across the block. Do not broadcast it.", self.signer_id);
-            // TODO: should we reinsert it and trigger a sign round across the block again?
-            return;
-        }
-
-        let block_submission = if message == signer_signature_hash.0.to_vec() {
-            // we agreed to sign the block hash. Return an approval message
-            BlockResponse::accepted(signer_signature_hash, signature.clone()).into()
         } else {
-            // We signed a rejection message. Return a rejection message
-            BlockResponse::rejected(signer_signature_hash, signature.clone()).into()
+            needs_refresh = true;
         };
-
-        // Submit signature result to miners to observe
-        debug!(
-            "Signer #{}: submit block response {:?}",
-            self.signer_id, &block_submission
-        );
-        if let Err(e) = self.stackerdb.send_message_with_retry(block_submission) {
-            warn!(
-                "Signer #{}: Failed to send block submission to stacker-db: {:?}",
-                self.signer_id, e
-            );
-        }
-    }
-
-    /// Process a sign error from a signing round, broadcasting a rejection message to stackerdb accordingly
-    fn process_sign_error(&mut self, e: &SignError) {
-        warn!("Received a signature error: {:?}", e);
-        match e {
-            SignError::NonceTimeout(_valid_signers, _malicious_signers) => {
-                //TODO: report these malicious signers
-                debug!("Signer #{}: Received a nonce timeout.", self.signer_id);
-            }
-            SignError::InsufficientSigners(malicious_signers) => {
-                debug!("Signer #{}: Insufficient signers.", self.signer_id);
-                let message = self.coordinator.get_message();
-                let block = read_next::<NakamotoBlock, _>(&mut &message[..]).ok().unwrap_or({
-                    // This is not a block so maybe its across its hash
-                    // This jankiness is because a coordinator could have signed a rejection we need to find the underlying block hash
-                    let signer_signature_hash_bytes = if message.len() > 32 {
-                        &message[..32]
-                    } else {
-                        &message
-                    };
-                    let Some(signer_signature_hash) = Sha512Trunc256Sum::from_bytes(signer_signature_hash_bytes) else {
-                        debug!("Signer #{}: Received a signature result for a signature over a non-block. Nothing to broadcast.", self.signer_id);
-                        return;
-                    };
-                    let Some(block_info) = self.blocks.remove(&signer_signature_hash) else {
-                        debug!("Signer #{}: Received a signature result for a block we have not seen before. Ignoring...", self.signer_id);
-                        return;
-                    };
-                    block_info.block
-                });
-                // We don't have enough signers to sign the block. Broadcast a rejection
-                let block_rejection = BlockRejection::new(
-                    block.header.signer_signature_hash(),
-                    RejectCode::InsufficientSigners(malicious_signers.clone()),
-                );
-                debug!(
-                    "Signer #{}: Insufficient signers for block; send rejection {:?}",
-                    self.signer_id, &block_rejection
-                );
-
-                // Submit signature result to miners to observe
-                if let Err(e) = self
-                    .stackerdb
-                    .send_message_with_retry(block_rejection.into())
-                {
-                    warn!(
-                        "Signer #{}: Failed to send block submission to stacker-db: {:?}",
-                        self.signer_id, e
-                    );
-                }
-            }
-            SignError::Aggregator(e) => {
-                warn!(
-                    "Signer #{}: Received an aggregator error: {:?}",
-                    self.signer_id, e
-                );
+        if needs_refresh {
+            let new_config = self.get_stacks_node_info(reward_cycle)?;
+            if let Some(new_config) = new_config {
+                debug!("Signer is registered for reward cycle {reward_cycle}. Initializing signer state.");
+                self.stacks_signers
+                    .insert(reward_index, Signer::new(&self.config, new_config));
+            } else {
+                // Nothing to initialize. Signer is not registered for this reward cycle
+                debug!("Signer is not registered for reward cycle {reward_cycle}. Nothing to initialize.");
             }
         }
-        // TODO: should reattempt to sign the block here or should we just broadcast a rejection or do nothing and wait for the signers to propose a new block?
+        Ok(())
     }
 
-    /// Send any operation results across the provided channel
-    fn send_operation_results(
-        &mut self,
-        res: Sender<Vec<OperationResult>>,
-        operation_results: Vec<OperationResult>,
-    ) {
-        let nmb_results = operation_results.len();
-        match res.send(operation_results) {
-            Ok(_) => {
-                debug!(
-                    "Signer #{}: Successfully sent {} operation result(s)",
-                    self.signer_id, nmb_results
-                )
+    /// Refresh the signer configuration by retrieving the necessary information from the stacks node
+    /// Note: this will trigger DKG if required
+    fn refresh_signers_with_retry(&mut self) -> Result<(), ClientError> {
+        retry_with_exponential_backoff(|| {
+            let current_reward_cycle = self
+                .stacks_client
+                .get_current_reward_cycle()
+                .map_err(backoff::Error::transient)?;
+            let next_reward_cycle = current_reward_cycle.wrapping_add(1);
+            self.refresh_signer_config(current_reward_cycle)?;
+            self.refresh_signer_config(next_reward_cycle)?;
+            for stacks_signer in self.stacks_signers.values_mut() {
+                stacks_signer
+                    .update_dkg()
+                    .map_err(backoff::Error::transient)?;
             }
-            Err(e) => {
-                warn!(
-                    "Signer #{}: Failed to send {} operation results: {:?}",
-                    self.signer_id, nmb_results, e
-                );
+            if self.stacks_signers.is_empty() {
+                info!("Signer is not registered for the current or next reward cycle. Waiting for confirmed registration...");
+                return Err(backoff::Error::transient(ClientError::NotRegistered));
             }
-        }
+            self.state = State::Initialized;
+            Ok(())
+        })
     }
 
-    /// Sending all provided packets through stackerdb with a retry
-    fn send_outbound_messages(&mut self, outbound_messages: Vec<Packet>) {
-        debug!(
-            "Signer #{}: Sending {} messages to other stacker-db instances.",
-            self.signer_id,
-            outbound_messages.len()
-        );
-        for msg in outbound_messages {
-            let ack = self.stackerdb.send_message_with_retry(msg.into());
-            if let Ok(ack) = ack {
-                debug!("Signer #{}: send outbound ACK: {:?}", self.signer_id, ack);
-            } else {
-                warn!(
-                    "Signer #{}: Failed to send message to stacker-db instance: {:?}",
-                    self.signer_id, ack
+    /// Cleanup stale signers that have exceeded their tenure
+    fn cleanup_stale_signers(&mut self) {
+        let mut to_delete = Vec::with_capacity(self.stacks_signers.len());
+        for (index, stacks_signer) in self.stacks_signers.iter() {
+            if stacks_signer.state == SignerState::TenureExceeded {
+                debug!(
+                    "Deleting signer for stale reward cycle: {}.",
+                    stacks_signer.reward_cycle
                 );
+                to_delete.push(*index);
             }
         }
-    }
-}
-
-impl From<&Config> for RunLoop<FireCoordinator<v2::Aggregator>> {
-    /// Creates new runloop from a config
-    fn from(config: &Config) -> Self {
-        // TODO: this should be a config option
-        // See: https://github.com/stacks-network/stacks-blockchain/issues/3914
-        let threshold = ((config.signer_ids_public_keys.key_ids.len() * 7) / 10)
-            .try_into()
-            .unwrap();
-        let dkg_threshold = ((config.signer_ids_public_keys.key_ids.len() * 9) / 10)
-            .try_into()
-            .unwrap();
-        let total_signers = config
-            .signer_ids_public_keys
-            .signers
-            .len()
-            .try_into()
-            .unwrap();
-        let total_keys = config
-            .signer_ids_public_keys
-            .key_ids
-            .len()
-            .try_into()
-            .unwrap();
-        let key_ids = config
-            .signer_key_ids
-            .get(&config.signer_id)
-            .unwrap()
-            .clone();
-        // signer uses a Vec<u32> for its key_ids, but coordinator uses a HashSet for each signer since it needs to do lots of lookups
-        let signer_key_ids = config
-            .signer_key_ids
-            .iter()
-            .map(|(i, ids)| (*i, ids.iter().copied().collect::<HashSet<u32>>()))
-            .collect::<HashMap<u32, HashSet<u32>>>();
-        let signer_public_keys = config
-            .signer_ids_public_keys
-            .signers
-            .iter()
-            .map(|(i, ecdsa_key)| {
-                (
-                    *i,
-                    Point::try_from(&Compressed::from(ecdsa_key.to_bytes())).unwrap(),
-                )
-            })
-            .collect::<HashMap<u32, Point>>();
-
-        let coordinator_config = CoordinatorConfig {
-            threshold,
-            dkg_threshold,
-            num_signers: total_signers,
-            num_keys: total_keys,
-            message_private_key: config.ecdsa_private_key,
-            dkg_public_timeout: config.dkg_public_timeout,
-            dkg_private_timeout: config.dkg_private_timeout,
-            dkg_end_timeout: config.dkg_end_timeout,
-            nonce_timeout: config.nonce_timeout,
-            sign_timeout: config.sign_timeout,
-            signer_key_ids,
-            signer_public_keys,
-        };
-        let coordinator = FireCoordinator::new(coordinator_config);
-        let signing_round = Signer::new(
-            threshold,
-            total_signers,
-            total_keys,
-            config.signer_id,
-            key_ids,
-            config.ecdsa_private_key,
-            config.signer_ids_public_keys.clone(),
-        );
-        let stacks_client = StacksClient::from(config);
-        let stackerdb = StackerDB::from(config);
-        RunLoop {
-            event_timeout: config.event_timeout,
-            coordinator,
-            signing_round,
-            stacks_client,
-            stackerdb,
-            commands: VecDeque::new(),
-            state: State::Uninitialized,
-            mainnet: config.network == Network::Mainnet,
-            blocks: HashMap::new(),
-            transactions: Vec::new(),
-            signer_ids: config.signer_ids.clone(),
-            signer_id: config.signer_id,
-            signer_slot_id: None, // will be updated on .initialize()
-            signer_set: None,     // will be updated on .initialize()
-            signer_addresses: vec![],
+        for index in to_delete {
+            self.stacks_signers.remove(&index);
         }
     }
 }
 
-impl<C: Coordinator> SignerRunLoop<Vec<OperationResult>, RunLoopCommand> for RunLoop<C> {
+impl SignerRunLoop<Vec<OperationResult>, RunLoopCommand> for RunLoop {
     fn set_event_timeout(&mut self, timeout: Duration) {
-        self.event_timeout = timeout;
+        self.config.event_timeout = timeout;
     }
 
     fn get_event_timeout(&self) -> Duration {
-        self.event_timeout
+        self.config.event_timeout
     }
 
     fn run_one_pass(
@@ -1109,62 +275,47 @@ impl<C: Coordinator> SignerRunLoop<Vec<OperationResult>, RunLoopCommand> for Run
         res: Sender<Vec<OperationResult>>,
     ) -> Option<Vec<OperationResult>> {
         info!(
-            "Running one pass for signer ID# {}. Current state: {:?}",
-            self.signer_id, self.state
+            "Running one pass for the signer. Current state: {:?}",
+            self.state
         );
-        if let Some(command) = cmd {
-            self.commands.push_back(command);
-        }
-        // TODO: This should be called every time as DKG can change at any time...but until we have the node
-        // set up to receive cast votes...just do on initialization.
-        if self.state == State::Uninitialized {
-            let request_fn = || {
-                self.initialize().map_err(|e| {
-                    warn!("Failed to initialize: {:?}", &e);
-                    backoff::Error::transient(e)
-                })
-            };
-            retry_with_exponential_backoff(request_fn)
-                .expect("Failed to connect to initialize due to timeout. Stacks node may be down.");
-        }
-        // Process any arrived events
-        debug!("Signer #{}: Processing event: {:?}", self.signer_id, event);
-        match event {
-            Some(SignerEvent::BlockValidationResponse(block_validate_response)) => {
-                debug!(
-                    "Signer #{}: Received a block proposal result from the stacks node...",
-                    self.signer_id
-                );
-                self.handle_block_validate_response(block_validate_response, res)
+        if let Err(e) = self.refresh_signers_with_retry() {
+            if self.state == State::Uninitialized {
+                // If we were never actually initialized, we cannot process anything. Just return.
+                error!("Failed to initialize signers. Are you sure this signer is correctly registered for the current or next reward cycle?");
+                warn!("Ignoring event: {:?}", event);
+                return None;
+            } else {
+                error!("Failed to refresh signers: {e}. Signer may have an outdated view of the network. Attempting to process event anyway.");
             }
-            Some(SignerEvent::SignerMessages(messages)) => {
-                debug!(
-                    "Signer #{}: Received {} messages from the other signers...",
-                    self.signer_id,
-                    messages.len()
+        }
+        if let Some(command) = cmd {
+            let reward_cycle = command.reward_cycle;
+            if let Some(stacks_signer) = self.stacks_signers.get_mut(&(reward_cycle % 2)) {
+                if stacks_signer.reward_cycle != reward_cycle {
+                    warn!(
+                        "Signer is not registered for reward cycle {reward_cycle}. Ignoring command: {command:?}"
+                    );
+                } else {
+                    stacks_signer.commands.push_back(command.command);
+                }
+            } else {
+                warn!(
+                    "Signer is not registered for reward cycle {reward_cycle}. Ignoring command: {command:?}"
                 );
-                self.handle_signer_messages(res, messages);
             }
-            Some(SignerEvent::ProposedBlocks(blocks)) => {
-                debug!(
-                    "Signer #{}: Received {} block proposals from the miners...",
-                    self.signer_id,
-                    blocks.len()
+        }
+        for stacks_signer in self.stacks_signers.values_mut() {
+            if let Err(e) = stacks_signer.process_event(event.as_ref(), res.clone()) {
+                error!(
+                    "Signer #{} for reward cycle {} errored processing event: {e}",
+                    stacks_signer.signer_id, stacks_signer.reward_cycle
                 );
-                self.handle_proposed_blocks(blocks);
-            }
-            Some(SignerEvent::StatusCheck) => {
-                debug!("Signer #{}: Received a status check event.", self.signer_id)
-            }
-            None => {
-                // No event. Do nothing.
-                debug!("Signer #{}: No event received", self.signer_id)
             }
+            // After processing event, run the next command for each signer
+            stacks_signer.process_next_command();
         }
-
-        // The process the next command
-        // Must be called AFTER processing the event as the state may update to IDLE due to said event.
-        self.process_next_command();
+        // Cleanup any stale signers
+        self.cleanup_stale_signers();
         None
     }
 }
@@ -1218,27 +369,14 @@ mod tests {
     use std::net::TcpListener;
     use std::thread::{sleep, spawn};
 
-    use blockstack_lib::chainstate::nakamoto::NakamotoBlockHeader;
-    use blockstack_lib::chainstate::stacks::boot::SIGNERS_VOTING_NAME;
-    use blockstack_lib::chainstate::stacks::{ThresholdSignature, TransactionVersion};
-    use blockstack_lib::util_lib::boot::boot_code_addr;
-    use clarity::vm::types::{ResponseData, TupleData};
-    use clarity::vm::{ClarityName, Value as ClarityValue};
     use rand::distributions::Standard;
-    use rand::Rng;
-    use serial_test::serial;
-    use stacks_common::bitvec::BitVec;
-    use stacks_common::consts::SIGNER_SLOTS_PER_USER;
-    use stacks_common::types::chainstate::{
-        ConsensusHash, StacksBlockId, StacksPrivateKey, TrieHash,
-    };
-    use stacks_common::util::hash::{Hash160, MerkleTree};
-    use stacks_common::util::secp256k1::MessageSignature;
-    use wsts::curve::point::Point;
-    use wsts::curve::scalar::Scalar;
+    use rand::{thread_rng, Rng};
+    use rand_core::RngCore;
 
     use super::*;
-    use crate::client::tests::{write_response, TestConfig};
+    use crate::client::tests::{
+        build_get_peer_info_response, generate_public_keys, write_response, TestConfig,
+    };
 
     fn generate_random_consensus_hash() -> String {
         let rng = rand::thread_rng();
@@ -1257,10 +395,8 @@ mod tests {
         };
 
         println!("{}", consensus_hash);
-        let response = format!(
-            "HTTP/1.1 200 OK\n\n{{\"stacks_tip_consensus_hash\":\"{}\",\"peer_version\":4207599113,\"pox_consensus\":\"64c8c3049ff6b939c65828e3168210e6bb32d880\",\"burn_block_height\":2575799,\"stable_pox_consensus\":\"72277bf9a3b115e13c0942825480d6cee0e9a0e8\",\"stable_burn_block_height\":2575792,\"server_version\":\"stacks-node d657bdd (feat/epoch-2.4:d657bdd, release build, linux [x86_64])\",\"network_id\":2147483648,\"parent_network_id\":118034699,\"stacks_tip_height\":145152,\"stacks_tip\":\"77219884fe434c0fa270d65592b4f082ab3e5d9922ac2bdaac34310aedc3d298\",\"genesis_chainstate_hash\":\"74237aa39aa50a83de11a4f53e9d3bb7d43461d1de9873f402e5453ae60bc59b\",\"unanchored_tip\":\"dde44222b6e6d81583b6b9c55db83e8716943ae9d0dc332fc39448ddd9b99dc2\",\"unanchored_seq\":0,\"exit_at_block_height\":null,\"node_public_key\":\"023c940136d5795d9dd82c0e87f4dd6a2a1db245444e7d70e34bb9605c3c3917b0\",\"node_public_key_hash\":\"e26cce8f6abe06b9fc81c3b11bcc821d2f1b8fd0\"}}",
-            consensus_hash
-        );
+        let stacks_tip_height = thread_rng().next_u64();
+        let response = build_get_peer_info_response(stacks_tip_height, consensus_hash);
 
         spawn(move || {
             write_response(mock_server, response.as_bytes());
@@ -1270,9 +406,8 @@ mod tests {
 
     #[test]
     fn calculate_coordinator_should_produce_unique_results() {
-        let config = Config::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
         let number_of_tests = 5;
-
+        let generated_public_keys = generate_public_keys(10, 4000, None).0;
         let mut results = Vec::new();
 
         for _ in 0..number_of_tests {
@@ -1280,7 +415,7 @@ mod tests {
             mock_stacks_client_response(test_config.mock_server, true);
 
             let (coordinator_id, coordinator_public_key) =
-                calculate_coordinator(&config.signer_ids_public_keys, &test_config.client);
+                calculate_coordinator(&generated_public_keys, &test_config.client);
 
             results.push((coordinator_id, coordinator_public_key));
         }
@@ -1300,12 +435,11 @@ mod tests {
     }
     fn generate_test_results(random_consensus: bool, count: usize) -> Vec<(u32, ecdsa::PublicKey)> {
         let mut results = Vec::new();
-        let config = Config::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
-
+        let generated_public_keys = generate_public_keys(10, 4000, None).0;
         for _ in 0..count {
             let test_config = TestConfig::new();
             mock_stacks_client_response(test_config.mock_server, random_consensus);
-            let result = calculate_coordinator(&config.signer_ids_public_keys, &test_config.client);
+            let result = calculate_coordinator(&generated_public_keys, &test_config.client);
             results.push(result);
         }
         results
@@ -1339,312 +473,4 @@ mod tests {
             "All coordinator public keys should be the same"
         );
     }
-
-    fn build_get_signer_slots_response(config: &Config) -> String {
-        let mut signers_public_keys = config
-            .signer_ids_public_keys
-            .signers
-            .iter()
-            .map(|(signer_id, signer_public_key)| {
-                let bytes = signer_public_key.to_bytes();
-                let signer_hash = Hash160::from_data(&bytes);
-                let signing_address = StacksAddress::p2pkh_from_hash(false, signer_hash);
-                (signer_id, signing_address)
-            })
-            .collect::<Vec<_>>();
-        signers_public_keys.sort_by(|(a, _), (b, _)| a.cmp(b));
-
-        let mut list_data = vec![];
-        for (_, signers_public_key) in signers_public_keys {
-            let tuple_data = vec![
-                (
-                    ClarityName::from("signer"),
-                    ClarityValue::Principal(signers_public_key.into()),
-                ),
-                (
-                    ClarityName::from("num-slots"),
-                    ClarityValue::UInt(SIGNER_SLOTS_PER_USER as u128),
-                ),
-            ];
-            let tuple = ClarityValue::Tuple(
-                TupleData::from_data(tuple_data).expect("Failed to create tuple data"),
-            );
-            list_data.push(tuple);
-        }
-
-        let result_data =
-            ClarityValue::cons_list_unsanitized(list_data).expect("Failed to construct list data");
-        let response_clarity = ClarityValue::Response(ResponseData {
-            committed: true,
-            data: Box::new(result_data),
-        });
-        let hex = response_clarity
-            .serialize_to_hex()
-            .expect("Failed to serialize clarity value");
-        format!("HTTP/1.1 200 OK\n\n{{\"okay\":true,\"result\":\"{hex}\"}}")
-    }
-
-    fn build_get_aggregate_public_key_response_some() -> (String, String) {
-        let current_reward_cycle_response = "HTTP/1.1 200 Ok\n\n{\"contract_id\":\"ST000000000000000000002AMW42H.pox-3\",\"pox_activation_threshold_ustx\":829371801288885,\"first_burnchain_block_height\":2000000,\"current_burnchain_block_height\":2572192,\"prepare_phase_block_length\":50,\"reward_phase_block_length\":1000,\"reward_slots\":2000,\"rejection_fraction\":12,\"total_liquid_supply_ustx\":41468590064444294,\"current_cycle\":{\"id\":544,\"min_threshold_ustx\":5190000000000,\"stacked_ustx\":853258144644000,\"is_pox_active\":true},\"next_cycle\":{\"id\":545,\"min_threshold_ustx\":5190000000000,\"min_increment_ustx\":5183573758055,\"stacked_ustx\":847278759574000,\"prepare_phase_start_block_height\":2572200,\"blocks_until_prepare_phase\":8,\"reward_phase_start_block_height\":2572250,\"blocks_until_reward_phase\":58,\"ustx_until_pox_rejection\":4976230807733304},\"min_amount_ustx\":5190000000000,\"prepare_cycle_length\":50,\"reward_cycle_id\":544,\"reward_cycle_length\":1050,\"rejection_votes_left_required\":4976230807733304,\"next_reward_cycle_in\":58,\"contract_versions\":[{\"contract_id\":\"ST000000000000000000002AMW42H.pox\",\"activation_burnchain_block_height\":2000000,\"first_reward_cycle_id\":0},{\"contract_id\":\"ST000000000000000000002AMW42H.pox-2\",\"activation_burnchain_block_height\":2422102,\"first_reward_cycle_id\":403},{\"contract_id\":\"ST000000000000000000002AMW42H.pox-3\",\"activation_burnchain_block_height\":2432545,\"first_reward_cycle_id\":412}]}".to_string();
-        let orig_point = Point::from(Scalar::random(&mut rand::thread_rng()));
-        let clarity_value = ClarityValue::some(
-            ClarityValue::buff_from(orig_point.compress().as_bytes().to_vec())
-                .expect("BUG: Failed to create clarity value from point"),
-        )
-        .expect("BUG: Failed to create clarity value from point");
-        let hex = clarity_value
-            .serialize_to_hex()
-            .expect("Failed to serialize clarity value");
-        let point_response = format!("HTTP/1.1 200 OK\n\n{{\"okay\":true,\"result\":\"{hex}\"}}");
-
-        (current_reward_cycle_response, point_response)
-    }
-
-    fn simulate_initialize_response(config: Config) {
-        let (current_reward_cycle_response, aggregate_key_response) =
-            build_get_aggregate_public_key_response_some();
-        let signer_slots_response = build_get_signer_slots_response(&config);
-        let test_config = TestConfig::from_config(config.clone());
-        write_response(
-            test_config.mock_server,
-            current_reward_cycle_response.as_bytes(),
-        );
-        let test_config = TestConfig::from_config(config.clone());
-        write_response(test_config.mock_server, signer_slots_response.as_bytes());
-
-        let test_config = TestConfig::from_config(config.clone());
-        write_response(
-            test_config.mock_server,
-            current_reward_cycle_response.as_bytes(),
-        );
-
-        let test_config = TestConfig::from_config(config.clone());
-        write_response(test_config.mock_server, aggregate_key_response.as_bytes());
-    }
-
-    fn simulate_nonce_response(config: &Config, num_transactions: usize) {
-        for _ in 0..num_transactions {
-            let nonce_response = b"HTTP/1.1 200 OK\n\n{\"nonce\":1,\"balance\":\"0x00000000000000000000000000000000\",\"locked\":\"0x00000000000000000000000000000000\",\"unlock_height\":0}";
-            let test_config = TestConfig::from_config(config.clone());
-            write_response(test_config.mock_server, nonce_response);
-        }
-    }
-
-    #[test]
-    #[serial]
-    // TODO(CI): This test function stalls in CI. Ignoring for now, but this test needs to be fixed.
-    #[ignore]
-    fn get_expected_transactions_should_filter_invalid_transactions() {
-        // Create a runloop of a valid signer
-        let config = Config::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
-        let mut valid_signer_runloop: RunLoop<FireCoordinator<v2::Aggregator>> =
-            RunLoop::from(&config);
-
-        let signer_private_key = config.stacks_private_key;
-        let non_signer_private_key = StacksPrivateKey::new();
-        let signers_contract_addr = boot_code_addr(false);
-        // Create a valid transaction signed by the signer private key coresponding to the slot into which it is being inserted (signer id 0)
-        // TODO use cast_aggregate_vote_tx fn to create a valid transaction when it is implmented and update this test
-        let valid_tx = StacksClient::build_signed_contract_call_transaction(
-            &signers_contract_addr,
-            SIGNERS_VOTING_NAME.into(),
-            "fake-function".into(),
-            &[],
-            &signer_private_key,
-            TransactionVersion::Testnet,
-            config.network.to_chain_id(),
-            1,
-            10,
-        )
-        .unwrap();
-        let invalid_tx_bad_signer = StacksClient::build_signed_contract_call_transaction(
-            &signers_contract_addr,
-            SIGNERS_VOTING_NAME.into(),
-            "fake-function".into(),
-            &[],
-            &non_signer_private_key,
-            TransactionVersion::Testnet,
-            config.network.to_chain_id(),
-            0,
-            10,
-        )
-        .unwrap();
-        let invalid_tx_outdated_nonce = StacksClient::build_signed_contract_call_transaction(
-            &signers_contract_addr,
-            SIGNERS_VOTING_NAME.into(),
-            "fake-function".into(),
-            &[],
-            &signer_private_key,
-            TransactionVersion::Testnet,
-            config.network.to_chain_id(),
-            0,
-            5,
-        )
-        .unwrap();
-
-        let transactions = vec![
-            valid_tx.clone(),
-            invalid_tx_outdated_nonce,
-            invalid_tx_bad_signer,
-        ];
-        let num_transactions = transactions.len();
-
-        let h = spawn(move || {
-            valid_signer_runloop.initialize().unwrap();
-            valid_signer_runloop.get_expected_transactions().unwrap()
-        });
-
-        // Must initialize the signers before attempting to retrieve their transactions
-        simulate_initialize_response(config.clone());
-
-        // Simulate the response to the request for transactions
-        let signer_message = SignerMessage::Transactions(transactions);
-        let message = signer_message.serialize_to_vec();
-        let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
-        response_bytes.extend(message);
-        let test_config = TestConfig::from_config(config.clone());
-        write_response(test_config.mock_server, response_bytes.as_slice());
-
-        let signer_message = SignerMessage::Transactions(vec![]);
-        let message = signer_message.serialize_to_vec();
-        let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
-        response_bytes.extend(message);
-        let test_config = TestConfig::from_config(config.clone());
-        write_response(test_config.mock_server, response_bytes.as_slice());
-
-        let signer_message = SignerMessage::Transactions(vec![]);
-        let message = signer_message.serialize_to_vec();
-        let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
-        response_bytes.extend(message);
-        let test_config = TestConfig::from_config(config.clone());
-        write_response(test_config.mock_server, response_bytes.as_slice());
-
-        let signer_message = SignerMessage::Transactions(vec![]);
-        let message = signer_message.serialize_to_vec();
-        let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
-        response_bytes.extend(message);
-        let test_config = TestConfig::from_config(config.clone());
-        write_response(test_config.mock_server, response_bytes.as_slice());
-
-        let signer_message = SignerMessage::Transactions(vec![]);
-        let message = signer_message.serialize_to_vec();
-        let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
-        response_bytes.extend(message);
-        let test_config = TestConfig::from_config(config.clone());
-        write_response(test_config.mock_server, response_bytes.as_slice());
-
-        simulate_nonce_response(&config, num_transactions);
-
-        let filtered_txs = h.join().unwrap();
-        assert_eq!(filtered_txs, vec![valid_tx]);
-    }
-
-    #[test]
-    #[serial]
-    #[ignore]
-    fn verify_transactions_valid() {
-        let config = Config::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
-        let mut runloop: RunLoop<FireCoordinator<v2::Aggregator>> = RunLoop::from(&config);
-
-        let signer_private_key = config.stacks_private_key;
-        let signers_contract_addr = boot_code_addr(false);
-        // Create a valid transaction signed by the signer private key coresponding to the slot into which it is being inserted (signer id 0)
-        // TODO use cast_aggregate_vote_tx fn to create a valid transaction when it is implmented and update this test
-        let valid_tx = StacksClient::build_signed_contract_call_transaction(
-            &signers_contract_addr,
-            SIGNERS_VOTING_NAME.into(),
-            "fake-function".into(),
-            &[],
-            &signer_private_key,
-            TransactionVersion::Testnet,
-            config.network.to_chain_id(),
-            1,
-            10,
-        )
-        .unwrap();
-
-        // Create a block
-        let header = NakamotoBlockHeader {
-            version: 1,
-            chain_length: 2,
-            burn_spent: 3,
-            consensus_hash: ConsensusHash([0x04; 20]),
-            parent_block_id: StacksBlockId([0x05; 32]),
-            tx_merkle_root: Sha512Trunc256Sum([0x06; 32]),
-            state_index_root: TrieHash([0x07; 32]),
-            miner_signature: MessageSignature::empty(),
-            signer_signature: ThresholdSignature::empty(),
-            signer_bitvec: BitVec::zeros(1).unwrap(),
-        };
-        let mut block = NakamotoBlock {
-            header,
-            txs: vec![valid_tx.clone()],
-        };
-        let tx_merkle_root = {
-            let txid_vecs = block
-                .txs
-                .iter()
-                .map(|tx| tx.txid().as_bytes().to_vec())
-                .collect();
-
-            MerkleTree::<Sha512Trunc256Sum>::new(&txid_vecs).root()
-        };
-        block.header.tx_merkle_root = tx_merkle_root;
-
-        // Ensure this is a block the signer has seen already
-        runloop.blocks.insert(
-            block.header.signer_signature_hash(),
-            BlockInfo::new(block.clone()),
-        );
-
-        let h = spawn(move || {
-            runloop.initialize().unwrap();
-            runloop.verify_transactions(&block)
-        });
-
-        // Must initialize the signers before attempting to retrieve their transactions
-        simulate_initialize_response(config.clone());
-
-        // Simulate the response to the request for transactions with the expected transaction
-        let signer_message = SignerMessage::Transactions(vec![valid_tx]);
-        let message = signer_message.serialize_to_vec();
-        let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
-        response_bytes.extend(message);
-        let test_config = TestConfig::from_config(config.clone());
-        write_response(test_config.mock_server, response_bytes.as_slice());
-
-        let signer_message = SignerMessage::Transactions(vec![]);
-        let message = signer_message.serialize_to_vec();
-        let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
-        response_bytes.extend(message);
-        let test_config = TestConfig::from_config(config.clone());
-        write_response(test_config.mock_server, response_bytes.as_slice());
-
-        let signer_message = SignerMessage::Transactions(vec![]);
-        let message = signer_message.serialize_to_vec();
-        let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
-        response_bytes.extend(message);
-        let test_config = TestConfig::from_config(config.clone());
-        write_response(test_config.mock_server, response_bytes.as_slice());
-
-        let signer_message = SignerMessage::Transactions(vec![]);
-        let message = signer_message.serialize_to_vec();
-        let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
-        response_bytes.extend(message);
-        let test_config = TestConfig::from_config(config.clone());
-        write_response(test_config.mock_server, response_bytes.as_slice());
-
-        let signer_message = SignerMessage::Transactions(vec![]);
-        let message = signer_message.serialize_to_vec();
-        let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
-        response_bytes.extend(message);
-        let test_config = TestConfig::from_config(config.clone());
-        write_response(test_config.mock_server, response_bytes.as_slice());
-
-        simulate_nonce_response(&config, 1);
-        //simulate_send_message_with_retry_response(config.clone());
-
-        let valid = h.join().unwrap();
-        assert!(valid);
-    }
 }
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
new file mode 100644
index 0000000000..7d62c16f29
--- /dev/null
+++ b/stacks-signer/src/signer.rs
@@ -0,0 +1,1463 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020-2024 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+use std::collections::VecDeque;
+use std::sync::mpsc::Sender;
+
+use blockstack_lib::chainstate::nakamoto::NakamotoBlock;
+use blockstack_lib::chainstate::stacks::boot::SIGNERS_VOTING_NAME;
+use blockstack_lib::chainstate::stacks::{StacksTransaction, TransactionPayload};
+use blockstack_lib::net::api::postblock_proposal::BlockValidateResponse;
+use blockstack_lib::util_lib::boot::boot_code_id;
+use hashbrown::{HashMap, HashSet};
+use libsigner::{BlockRejection, BlockResponse, RejectCode, SignerEvent, SignerMessage};
+use slog::{slog_debug, slog_error, slog_info, slog_warn};
+use stacks_common::codec::{read_next, StacksMessageCodec};
+use stacks_common::types::chainstate::StacksAddress;
+use stacks_common::util::hash::Sha512Trunc256Sum;
+use stacks_common::{debug, error, info, warn};
+use wsts::common::{MerkleRoot, Signature};
+use wsts::curve::keys::PublicKey;
+use wsts::curve::point::Point;
+use wsts::net::{Message, NonceRequest, Packet, SignatureShareRequest};
+use wsts::state_machine::coordinator::fire::Coordinator as FireCoordinator;
+use wsts::state_machine::coordinator::{
+    Config as CoordinatorConfig, Coordinator, State as CoordinatorState,
+};
+use wsts::state_machine::signer::Signer as WSTSSigner;
+use wsts::state_machine::{OperationResult, PublicKeys, SignError};
+use wsts::v2;
+
+use crate::client::{
+    retry_with_exponential_backoff, ClientError, EpochId, StackerDB, StacksClient,
+    VOTE_FUNCTION_NAME,
+};
+use crate::config::Config;
+use crate::runloop::calculate_coordinator;
+
+/// The info needed from the stacks node to configure a signer
+#[derive(Debug, Clone)]
+pub struct StacksNodeInfo {
+    /// The signer set for this runloop
+    pub signer_set: u32,
+    /// The index into the signers list of this signer's key (may be different from signer_id)
+    pub signer_slot_id: u32,
+    /// The signer ID assigned to this signer
+    pub signer_id: u32,
+    /// The reward cycle of the configuration
+    pub reward_cycle: u64,
+    /// The signer ids to wsts pubilc keys mapping
+    pub signer_public_keys: HashMap<u32, Point>,
+    /// The signer to key ids mapping
+    pub signer_key_ids: HashMap<u32, HashSet<u32>>,
+    /// The signer addresses
+    pub signer_addresses: HashSet<StacksAddress>,
+    /// The public keys for the reward cycle
+    pub public_keys: PublicKeys,
+}
+
+/// Additional Info about a proposed block
+pub struct BlockInfo {
+    /// The block we are considering
+    block: NakamotoBlock,
+    /// Our vote on the block if we have one yet
+    vote: Option<Vec<u8>>,
+    /// Whether the block contents are valid
+    valid: Option<bool>,
+    /// The associated packet nonce request if we have one
+    nonce_request: Option<NonceRequest>,
+    /// Whether this block is already being signed over
+    signed_over: bool,
+}
+
+impl BlockInfo {
+    /// Create a new BlockInfo
+    pub fn new(block: NakamotoBlock) -> Self {
+        Self {
+            block,
+            vote: None,
+            valid: None,
+            nonce_request: None,
+            signed_over: false,
+        }
+    }
+
+    /// Create a new BlockInfo with an associated nonce request packet
+    pub fn new_with_request(block: NakamotoBlock, nonce_request: NonceRequest) -> Self {
+        Self {
+            block,
+            vote: None,
+            valid: None,
+            nonce_request: Some(nonce_request),
+            signed_over: true,
+        }
+    }
+}
+
+/// Which signer operation to perform
+#[derive(PartialEq, Clone, Debug)]
+pub enum Command {
+    /// Generate a DKG aggregate public key
+    Dkg,
+    /// Sign a message
+    Sign {
+        /// The block to sign over
+        block: NakamotoBlock,
+        /// Whether to make a taproot signature
+        is_taproot: bool,
+        /// Taproot merkle root
+        merkle_root: Option<MerkleRoot>,
+    },
+}
+
+/// The Signer state
+#[derive(PartialEq, Debug, Clone)]
+pub enum State {
+    /// The signer is idle, waiting for messages and commands
+    Idle,
+    /// The signer is executing a DKG round
+    Dkg,
+    /// The signer is executing a signing round
+    Sign,
+    /// The Signer has exceeded its tenure
+    TenureExceeded,
+}
+
+/// The stacks signer for the rewrad cycle
+pub struct Signer {
+    /// The coordinator for inbound messages for a specific reward cycle
+    pub coordinator: FireCoordinator<v2::Aggregator>,
+    /// The signing round used to sign messages for a specific reward cycle
+    pub signing_round: WSTSSigner<v2::Signer>,
+    /// the state of the signer
+    pub state: State,
+    /// Observed blocks that we have seen so far
+    // TODO: cleanup storage and garbage collect this stuff
+    pub blocks: HashMap<Sha512Trunc256Sum, BlockInfo>,
+    /// Received Commands that need to be processed
+    pub commands: VecDeque<Command>,
+    /// The stackerdb client
+    pub stackerdb: StackerDB,
+    /// The stacks client
+    pub stacks_client: StacksClient,
+    /// Whether the signer is a mainnet signer or not
+    pub is_mainnet: bool,
+    /// The signer id
+    pub signer_id: u32,
+    /// The addresses of other signers to compare our transactions against
+    pub signer_addresses: HashSet<StacksAddress>,
+    /// The reward cycle this signer belongs to
+    pub reward_cycle: u64,
+}
+
+impl Signer {
+    /// Create a new stacks signer
+    pub fn new(config: &Config, stacks_node_info: StacksNodeInfo) -> Self {
+        let stackerdb = StackerDB::new_with_config(config, &stacks_node_info);
+        let stacks_client = StacksClient::from(config);
+
+        let num_signers = u32::try_from(stacks_node_info.public_keys.signers.len())
+            .expect("FATAL: Too many registered signers to fit in a u32");
+        let num_keys = u32::try_from(stacks_node_info.public_keys.key_ids.len())
+            .expect("FATAL: Too many key ids to fit in a u32");
+        let threshold = num_keys * 7 / 10;
+        let dkg_threshold = num_keys * 9 / 10;
+        // signer uses a Vec<u32> for its key_ids, but coordinator uses a HashSet for each signer since it needs to do lots of lookups
+        let signer_key_ids: Vec<u32> = stacks_node_info
+            .public_keys
+            .key_ids
+            .keys()
+            .cloned()
+            .collect();
+
+        let coordinator_config = CoordinatorConfig {
+            threshold,
+            dkg_threshold,
+            num_signers,
+            num_keys,
+            message_private_key: config.ecdsa_private_key,
+            dkg_public_timeout: config.dkg_public_timeout,
+            dkg_private_timeout: config.dkg_private_timeout,
+            dkg_end_timeout: config.dkg_end_timeout,
+            nonce_timeout: config.nonce_timeout,
+            sign_timeout: config.sign_timeout,
+            signer_key_ids: stacks_node_info.signer_key_ids.clone(),
+            signer_public_keys: stacks_node_info.signer_public_keys.clone(),
+        };
+
+        let coordinator = FireCoordinator::new(coordinator_config);
+        let signing_round = WSTSSigner::new(
+            threshold,
+            num_signers,
+            num_keys,
+            stacks_node_info.signer_id,
+            signer_key_ids,
+            config.ecdsa_private_key,
+            stacks_node_info.public_keys,
+        );
+        Self {
+            coordinator,
+            signing_round,
+            state: State::Idle,
+            blocks: HashMap::new(),
+            commands: VecDeque::new(),
+            stackerdb,
+            stacks_client,
+            is_mainnet: config.network.is_mainnet(), // will be updated on .initialize()
+            signer_id: stacks_node_info.signer_id,
+            signer_addresses: stacks_node_info.signer_addresses,
+            reward_cycle: stacks_node_info.reward_cycle,
+        }
+    }
+
+    /// Execute the given command and update state accordingly
+    /// Returns true when it is successfully executed, else false
+    /// Execute the given command and update state accordingly
+    /// Returns true when it is successfully executed, else false
+    fn execute_command(&mut self, command: &Command) -> bool {
+        match command {
+            Command::Dkg => {
+                info!("Signer #{}: Starting DKG", self.signer_id);
+                match self.coordinator.start_dkg_round() {
+                    Ok(msg) => {
+                        let ack = self.stackerdb.send_message_with_retry(msg.into());
+                        debug!("Signer #{}: ACK: {:?}", self.signer_id, ack);
+                        self.state = State::Dkg;
+                        true
+                    }
+                    Err(e) => {
+                        error!("Failed to start DKG: {:?}", e);
+                        warn!("Resetting coordinator's internal state.");
+                        self.coordinator.reset();
+                        false
+                    }
+                }
+            }
+            Command::Sign {
+                block,
+                is_taproot,
+                merkle_root,
+            } => {
+                let signer_signature_hash = block.header.signer_signature_hash();
+                let block_info = self
+                    .blocks
+                    .entry(signer_signature_hash)
+                    .or_insert_with(|| BlockInfo::new(block.clone()));
+                if block_info.signed_over {
+                    debug!("Signer #{}: Received a sign command for a block we are already signing over. Ignore it.", self.signer_id);
+                    return false;
+                }
+                info!("Signer #{}: Signing block: {:?}", self.signer_id, block);
+                match self.coordinator.start_signing_round(
+                    &block.serialize_to_vec(),
+                    *is_taproot,
+                    *merkle_root,
+                ) {
+                    Ok(msg) => {
+                        let ack = self.stackerdb.send_message_with_retry(msg.into());
+                        debug!("Signer #{}: ACK: {:?}", self.signer_id, ack);
+                        self.state = State::Sign;
+                        block_info.signed_over = true;
+                        true
+                    }
+                    Err(e) => {
+                        error!(
+                            "Signer #{}: Failed to start signing message: {:?}",
+                            self.signer_id, e
+                        );
+                        warn!(
+                            "Signer #{}: Resetting coordinator's internal state.",
+                            self.signer_id
+                        );
+                        self.coordinator.reset();
+                        false
+                    }
+                }
+            }
+        }
+    }
+
+    /// Attempt to process the next command in the queue, and update state accordingly
+    pub fn process_next_command(&mut self) {
+        match self.state {
+            State::Idle => {
+                if let Some(command) = self.commands.pop_front() {
+                    while !self.execute_command(&command) {
+                        warn!(
+                            "Signer #{}: Failed to execute command. Retrying...",
+                            self.signer_id
+                        );
+                    }
+                } else {
+                    debug!(
+                        "Signer #{}: Nothing to process. Waiting for command...",
+                        self.signer_id
+                    );
+                }
+            }
+            State::Dkg | State::Sign => {
+                // We cannot execute the next command until the current one is finished...
+                // Do nothing...
+                debug!(
+                    "Signer #{}: Waiting for {:?} operation to finish",
+                    self.signer_id, self.state
+                );
+            }
+            State::TenureExceeded => {
+                // We have exceeded our tenure. Do nothing...
+                debug!(
+                    "Signer #{}: Waiting to clean up signer for reward cycle {}",
+                    self.signer_id, self.reward_cycle
+                );
+            }
+        }
+    }
+
+    /// Handle the block validate response returned from our prior calls to submit a block for validation
+    fn handle_block_validate_response(
+        &mut self,
+        block_validate_response: &BlockValidateResponse,
+        res: Sender<Vec<OperationResult>>,
+    ) {
+        let block_info = match block_validate_response {
+            BlockValidateResponse::Ok(block_validate_ok) => {
+                let signer_signature_hash = block_validate_ok.signer_signature_hash;
+                // For mutability reasons, we need to take the block_info out of the map and add it back after processing
+                let Some(mut block_info) = self.blocks.remove(&signer_signature_hash) else {
+                    // We have not seen this block before. Why are we getting a response for it?
+                    debug!("Received a block validate response for a block we have not seen before. Ignoring...");
+                    return;
+                };
+                let is_valid = self.verify_transactions(&block_info.block);
+                block_info.valid = Some(is_valid);
+                info!(
+                    "Signer #{}: Treating block validation for block {} as valid: {:?}",
+                    self.signer_id,
+                    &block_info.block.block_id(),
+                    block_info.valid
+                );
+                // Add the block info back to the map
+                self.blocks
+                    .entry(signer_signature_hash)
+                    .or_insert(block_info)
+            }
+            BlockValidateResponse::Reject(block_validate_reject) => {
+                let signer_signature_hash = block_validate_reject.signer_signature_hash;
+                let Some(block_info) = self.blocks.get_mut(&signer_signature_hash) else {
+                    // We have not seen this block before. Why are we getting a response for it?
+                    debug!("Signer #{}: Received a block validate response for a block we have not seen before. Ignoring...", self.signer_id);
+                    return;
+                };
+                block_info.valid = Some(false);
+                // Submit a rejection response to the .signers contract for miners
+                // to observe so they know to send another block and to prove signers are doing work);
+                warn!("Signer #{}: Broadcasting a block rejection due to stacks node validation failure...", self.signer_id);
+                if let Err(e) = self
+                    .stackerdb
+                    .send_message_with_retry(block_validate_reject.clone().into())
+                {
+                    warn!(
+                        "Signer #{}: Failed to send block rejection to stacker-db: {:?}",
+                        self.signer_id, e
+                    );
+                }
+                block_info
+            }
+        };
+
+        if let Some(mut nonce_request) = block_info.nonce_request.take() {
+            debug!("Received a block validate response from the stacks node for a block we already received a nonce request for. Responding to the nonce request...");
+            // We have received validation from the stacks node. Determine our vote and update the request message
+            Self::determine_vote(self.signer_id, block_info, &mut nonce_request);
+            // Send the nonce request through with our vote
+            let packet = Packet {
+                msg: Message::NonceRequest(nonce_request),
+                sig: vec![],
+            };
+            self.handle_packets(res, &[packet]);
+        } else {
+            let (coordinator_id, _) =
+                calculate_coordinator(&self.signing_round.public_keys, &self.stacks_client);
+            if block_info.valid.unwrap_or(false)
+                && !block_info.signed_over
+                && coordinator_id == self.signer_id
+            {
+                // We are the coordinator. Trigger a signing round for this block
+                debug!(
+                    "Signer #{}: triggering a signing round over the block {}",
+                    self.signer_id,
+                    block_info.block.header.block_hash()
+                );
+                self.commands.push_back(Command::Sign {
+                    block: block_info.block.clone(),
+                    is_taproot: false,
+                    merkle_root: None,
+                });
+            } else {
+                debug!(
+                    "Signer #{} ignoring block.", self.signer_id;
+                    "block_hash" => block_info.block.header.block_hash(),
+                    "valid" => block_info.valid,
+                    "signed_over" => block_info.signed_over,
+                    "coordinator_id" => coordinator_id,
+                );
+            }
+        }
+    }
+
+    /// Handle signer messages submitted to signers stackerdb
+    fn handle_signer_messages(
+        &mut self,
+        res: Sender<Vec<OperationResult>>,
+        messages: &[SignerMessage],
+    ) {
+        let (coordinator_id, coordinator_public_key) =
+            calculate_coordinator(&self.signing_round.public_keys, &self.stacks_client);
+        debug!(
+            "Signer #{}: coordinator is signer #{} public key {}",
+            self.signer_id, coordinator_id, &coordinator_public_key
+        );
+        let packets: Vec<Packet> = messages
+            .into_iter()
+            .filter_map(|msg| match msg {
+                SignerMessage::BlockResponse(_) | SignerMessage::Transactions(_) => None,
+                SignerMessage::Packet(packet) => {
+                    self.verify_packet(packet.clone(), &coordinator_public_key)
+                }
+            })
+            .collect();
+        self.handle_packets(res, &packets);
+    }
+
+    /// Handle proposed blocks submitted by the miners to stackerdb
+    fn handle_proposed_blocks(&mut self, blocks: &[NakamotoBlock]) {
+        for block in blocks {
+            // Store the block in our cache
+            self.blocks.insert(
+                block.header.signer_signature_hash(),
+                BlockInfo::new(block.clone()),
+            );
+            // Submit the block for validation
+            self.stacks_client
+                .submit_block_for_validation(block.clone())
+                .unwrap_or_else(|e| {
+                    warn!("Failed to submit block for validation: {:?}", e);
+                });
+        }
+    }
+
+    /// Process inbound packets as both a signer and a coordinator
+    /// Will send outbound packets and operation results as appropriate
+    fn handle_packets(&mut self, res: Sender<Vec<OperationResult>>, packets: &[Packet]) {
+        let signer_outbound_messages = self
+            .signing_round
+            .process_inbound_messages(packets)
+            .unwrap_or_else(|e| {
+                error!("Failed to process inbound messages as a signer: {e}");
+                vec![]
+            });
+
+        // Next process the message as the coordinator
+        let (coordinator_outbound_messages, operation_results) = self
+            .coordinator
+            .process_inbound_messages(packets)
+            .unwrap_or_else(|e| {
+                error!("Failed to process inbound messages as a coordinator: {e}");
+                (vec![], vec![])
+            });
+
+        if !operation_results.is_empty() {
+            // We have finished a signing or DKG round, either successfully or due to error.
+            // Regardless of the why, update our state to Idle as we should not expect the operation to continue.
+            self.state = State::Idle;
+            self.process_operation_results(&operation_results);
+            self.send_operation_results(res, operation_results);
+        }
+        self.send_outbound_messages(signer_outbound_messages);
+        self.send_outbound_messages(coordinator_outbound_messages);
+    }
+
+    /// Validate a signature share request, updating its message where appropriate.
+    /// If the request is for a block it has already agreed to sign, it will overwrite the message with the agreed upon value
+    /// Returns whether the request is valid or not.
+    fn validate_signature_share_request(&self, request: &mut SignatureShareRequest) -> bool {
+        let message_len = request.message.len();
+        // Note that the message must always be either 32 bytes (the block hash) or 33 bytes (block hash + b'n')
+        let hash_bytes = if message_len == 33 && request.message[32] == b'n' {
+            // Pop off the 'n' byte from the block hash
+            &request.message[..32]
+        } else if message_len == 32 {
+            // This is the block hash
+            &request.message
+        } else {
+            // We will only sign across block hashes or block hashes + b'n' byte
+            debug!("Signer #{}: Received a signature share request for an unknown message stream. Reject it.", self.signer_id);
+            return false;
+        };
+
+        let Some(hash) = Sha512Trunc256Sum::from_bytes(hash_bytes) else {
+            // We will only sign across valid block hashes
+            debug!("Signer #{}: Received a signature share request for an invalid block hash. Reject it.", self.signer_id);
+            return false;
+        };
+        match self.blocks.get(&hash).map(|block_info| &block_info.vote) {
+            Some(Some(vote)) => {
+                // Overwrite with our agreed upon value in case another message won majority or the coordinator is trying to cheat...
+                debug!(
+                    "Signer #{}: set vote for {} to {:?}",
+                    self.signer_id, &hash, &vote
+                );
+                request.message = vote.clone();
+                true
+            }
+            Some(None) => {
+                // We never agreed to sign this block. Reject it.
+                // This can happen if the coordinator received enough votes to sign yes
+                // or no on a block before we received validation from the stacks node.
+                debug!("Signer #{}: Received a signature share request for a block we never agreed to sign. Ignore it.", self.signer_id);
+                false
+            }
+            None => {
+                // We will only sign across block hashes or block hashes + b'n' byte for
+                // blocks we have seen a Nonce Request for (and subsequent validation)
+                // We are missing the context here necessary to make a decision. Reject the block
+                debug!("Signer #{}: Received a signature share request from an unknown block. Reject it.", self.signer_id);
+                false
+            }
+        }
+    }
+
+    /// Validate a nonce request, updating its message appropriately.
+    /// If the request is for a block, we will update the request message
+    /// as either a hash indicating a vote no or the signature hash indicating a vote yes
+    /// Returns whether the request is valid or not
+    fn validate_nonce_request(&mut self, nonce_request: &mut NonceRequest) -> bool {
+        let Some(block) = read_next::<NakamotoBlock, _>(&mut &nonce_request.message[..]).ok()
+        else {
+            // We currently reject anything that is not a block
+            debug!(
+                "Signer #{}: Received a nonce request for an unknown message stream. Reject it.",
+                self.signer_id
+            );
+            return false;
+        };
+        let signer_signature_hash = block.header.signer_signature_hash();
+        let Some(block_info) = self.blocks.get_mut(&signer_signature_hash) else {
+            // We have not seen this block before. Cache it. Send a RPC to the stacks node to validate it.
+            debug!("Signer #{}: We have received a block sign request for a block we have not seen before. Cache the nonce request and submit the block for validation...", self.signer_id);
+            // Store the block in our cache
+            self.blocks.insert(
+                signer_signature_hash,
+                BlockInfo::new_with_request(block.clone(), nonce_request.clone()),
+            );
+            self.stacks_client
+                .submit_block_for_validation(block)
+                .unwrap_or_else(|e| {
+                    warn!(
+                        "Signer #{}: Failed to submit block for validation: {:?}",
+                        self.signer_id, e
+                    );
+                });
+            return false;
+        };
+
+        if block_info.valid.is_none() {
+            // We have not yet received validation from the stacks node. Cache the request and wait for validation
+            debug!("Signer #{}: We have yet to receive validation from the stacks node for a nonce request. Cache the nonce request and wait for block validation...", self.signer_id);
+            block_info.nonce_request = Some(nonce_request.clone());
+            return false;
+        }
+
+        Self::determine_vote(self.signer_id, block_info, nonce_request);
+        true
+    }
+
+    /// Verify the transactions in a block are as expected
+    fn verify_transactions(&mut self, block: &NakamotoBlock) -> bool {
+        if let Ok(expected_transactions) = self.get_expected_transactions() {
+            //It might be worth building a hashset of the blocks' txids and checking that against the expected transaction's txid.
+            let block_tx_hashset = block.txs.iter().map(|tx| tx.txid()).collect::<HashSet<_>>();
+            // Ensure the block contains the transactions we expect
+            let missing_transactions = expected_transactions
+                .into_iter()
+                .filter_map(|tx| {
+                    if !block_tx_hashset.contains(&tx.txid()) {
+                        debug!(
+                            "Signer #{}: expected txid {} is in the block",
+                            self.signer_id,
+                            &tx.txid()
+                        );
+                        Some(tx)
+                    } else {
+                        debug!(
+                            "Signer #{}: missing expected txid {}",
+                            self.signer_id,
+                            &tx.txid()
+                        );
+                        None
+                    }
+                })
+                .collect::<Vec<_>>();
+            let is_valid = missing_transactions.is_empty();
+            if !is_valid {
+                debug!("Signer #{}: Broadcasting a block rejection due to missing expected transactions...", self.signer_id);
+                let block_rejection = BlockRejection::new(
+                    block.header.signer_signature_hash(),
+                    RejectCode::MissingTransactions(missing_transactions),
+                );
+                // Submit signature result to miners to observe
+                if let Err(e) = self
+                    .stackerdb
+                    .send_message_with_retry(block_rejection.into())
+                {
+                    warn!(
+                        "Signer #{}: Failed to send block rejection to stacker-db: {:?}",
+                        self.signer_id, e
+                    );
+                }
+            }
+            is_valid
+        } else {
+            // Failed to connect to the stacks node to get transactions. Cannot validate the block. Reject it.
+            debug!(
+                "Signer #{}: Broadcasting a block rejection due to signer connectivity issues...",
+                self.signer_id
+            );
+            let block_rejection = BlockRejection::new(
+                block.header.signer_signature_hash(),
+                RejectCode::ConnectivityIssues,
+            );
+            // Submit signature result to miners to observe
+            if let Err(e) = self
+                .stackerdb
+                .send_message_with_retry(block_rejection.into())
+            {
+                warn!(
+                    "Signer #{}: Failed to send block submission to stacker-db: {:?}",
+                    self.signer_id, e
+                );
+            }
+            false
+        }
+    }
+
+    /// Get the transactions we expect to see in the next block
+    fn get_expected_transactions(&mut self) -> Result<Vec<StacksTransaction>, ClientError> {
+        let signer_ids = self
+            .signing_round
+            .public_keys
+            .signers
+            .keys()
+            .cloned()
+            .collect::<Vec<_>>();
+        let transactions = self
+                .stackerdb
+                .get_signer_transactions_with_retry(&signer_ids)?.into_iter().filter_map(|transaction| {
+                    // Filter out transactions that have already been confirmed (can happen if a signer did not update stacker db since the last block was processed)
+                    let origin_address = transaction.origin_address();
+                    let origin_nonce = transaction.get_origin_nonce();
+                    let Ok(account_nonce) = self.stacks_client.get_account_nonce(&origin_address) else {
+                        warn!("Signer #{}: Unable to get account for address: {origin_address}. Ignoring it for this block...", self.signer_id);
+                        return None;
+                    };
+                    let vote_contract_id = boot_code_id(SIGNERS_VOTING_NAME, self.is_mainnet);
+                    match &transaction.payload {
+                        TransactionPayload::ContractCall(payload) => {
+                            if payload.contract_identifier() != vote_contract_id || payload.function_name != VOTE_FUNCTION_NAME.into() {
+                                // This is not a special cased transaction. We don't care if its in the next block
+                                debug!("Signer #{}: Received an unrecognized transaction. Ignoring it.", self.signer_id;
+                                    "origin_address" => origin_address.to_string(),
+                                    "orign_nonce" => origin_nonce,
+                                    "txid" => transaction.txid().to_string(),
+                                    "contract_id" => payload.contract_identifier().to_string(),
+                                    "function_name" => payload.function_name.to_string(),
+                                );
+                                return None;
+                            }
+                        }
+                        _ => {
+                            // This is not a special cased transaction.
+                            debug!("Signer #{}: Received an unrecognized transaction. Ignoring it.", self.signer_id;
+                            "origin_address" => origin_address.to_string(),
+                            "orign_nonce" => origin_nonce,
+                            "txid" => transaction.txid().to_string(),
+                            "payload" => format!("{:?}", transaction.payload),
+                        );
+                            return None;
+                        }
+                    }
+                    if !self.signer_addresses.contains(&origin_address) || origin_nonce < account_nonce {
+                        debug!("Signer #{}: Received a transaction from either an unrecognized address or with an invalid nonce. Ignoring it.", self.signer_id;
+                            "txid" => transaction.txid().to_string(),
+                            "origin_address" => origin_address.to_string(),
+                            "origin_nonce" => origin_nonce,
+                            "account_nonce" => account_nonce,
+                        );
+                        return None;
+                    }
+                    debug!("Signer #{}: Expect transaction {} ({:?})", self.signer_id, transaction.txid(), &transaction);
+                    Some(transaction)
+                }).collect();
+        Ok(transactions)
+    }
+
+    /// Determine the vote for a block and update the block info and nonce request accordingly
+    fn determine_vote(
+        signer_id: u32,
+        block_info: &mut BlockInfo,
+        nonce_request: &mut NonceRequest,
+    ) {
+        let mut vote_bytes = block_info.block.header.signer_signature_hash().0.to_vec();
+        // Validate the block contents
+        if !block_info.valid.unwrap_or(false) {
+            // We don't like this block. Update the request to be across its hash with a byte indicating a vote no.
+            debug!(
+                "Signer #{}: Updating the request with a block hash with a vote no.",
+                signer_id
+            );
+            vote_bytes.push(b'n');
+        } else {
+            debug!("Signer #{}: The block passed validation. Update the request with the signature hash.", signer_id);
+        }
+
+        // Cache our vote
+        block_info.vote = Some(vote_bytes.clone());
+        nonce_request.message = vote_bytes;
+    }
+
+    /// Verify a chunk is a valid wsts packet. Returns the packet if it is valid, else None.
+    /// NOTE: The packet will be updated if the signer wishes to respond to NonceRequest
+    /// and SignatureShareRequests with a different message than what the coordinator originally sent.
+    /// This is done to prevent a malicious coordinator from sending a different message than what was
+    /// agreed upon and to support the case where the signer wishes to reject a block by voting no
+    fn verify_packet(
+        &mut self,
+        mut packet: Packet,
+        coordinator_public_key: &PublicKey,
+    ) -> Option<Packet> {
+        // We only care about verified wsts packets. Ignore anything else.
+        if packet.verify(&self.signing_round.public_keys, coordinator_public_key) {
+            match &mut packet.msg {
+                Message::SignatureShareRequest(request) => {
+                    if !self.validate_signature_share_request(request) {
+                        return None;
+                    }
+                }
+                Message::NonceRequest(request) => {
+                    if !self.validate_nonce_request(request) {
+                        return None;
+                    }
+                }
+                _ => {
+                    // Nothing to do for other message types
+                }
+            }
+            Some(packet)
+        } else {
+            debug!(
+                "Signer #{}: Failed to verify wsts packet with {}: {:?}",
+                self.signer_id, coordinator_public_key, &packet
+            );
+            None
+        }
+    }
+
+    /// Processes the operation results, broadcasting block acceptance or rejection messages
+    /// and DKG vote results accordingly
+    fn process_operation_results(&mut self, operation_results: &[OperationResult]) {
+        for operation_result in operation_results {
+            // Signers only every trigger non-taproot signing rounds over blocks. Ignore SignTaproot results
+            match operation_result {
+                OperationResult::Sign(signature) => {
+                    debug!("Signer #{}: Received signature result", self.signer_id);
+                    self.process_signature(signature);
+                }
+                OperationResult::SignTaproot(_) => {
+                    debug!("Signer #{}: Received a signature result for a taproot signature. Nothing to broadcast as we currently sign blocks with a FROST signature.", self.signer_id);
+                }
+                OperationResult::Dkg(point) => {
+                    // Broadcast via traditional methods to the stacks node if we are pre nakamoto or we cannot determine our Epoch
+                    let epoch = self
+                        .stacks_client
+                        .get_node_epoch()
+                        .unwrap_or(EpochId::UnsupportedEpoch);
+                    let new_transaction = match epoch {
+                        EpochId::UnsupportedEpoch => {
+                            debug!("Signer #{}: Received a DKG result, but are in an unsupported epoch. Do not broadcast the result.", self.signer_id);
+                            continue;
+                        }
+                        EpochId::Epoch25 => {
+                            debug!("Signer #{}: Received a DKG result, but are in epoch 2.5. Broadcast the transaction to the mempool.", self.signer_id);
+                            match retry_with_exponential_backoff(|| {
+                                self.stacks_client
+                                    .cast_vote_for_aggregate_public_key(
+                                        self.reward_cycle,
+                                        self.stackerdb.get_signer_slot_id(),
+                                        point.clone(),
+                                    )
+                                    .map_err(backoff::Error::transient)
+                            }) {
+                                Ok(transaction) => {
+                                    debug!("Signer #{}: Successfully cast aggregate public key vote: {:?}",
+                                    self.signer_id,
+                                        transaction.txid()
+                                    );
+                                    transaction
+                                }
+                                Err(e) => {
+                                    warn!("Signer #{}: Failed to cast aggregate public key vote: {:?}", self.signer_id, e);
+                                    continue;
+                                }
+                            }
+                        }
+                        EpochId::Epoch30 => {
+                            debug!("Signer #{}: Received a DKG result, but are in epoch 3. Broadcast the transaction to stackerDB.", self.signer_id);
+                            match retry_with_exponential_backoff(|| {
+                                self.stacks_client
+                                    .build_vote_for_aggregate_public_key(
+                                        self.reward_cycle,
+                                        self.stackerdb.get_signer_slot_id(),
+                                        point.clone(),
+                                    )
+                                    .map_err(backoff::Error::transient)
+                            }) {
+                                Ok(transaction) => transaction,
+                                Err(e) => {
+                                    warn!("Signer #{}: Failed to build a cast aggregate public key vote transaction: {:?}", self.signer_id, e);
+                                    continue;
+                                }
+                            }
+                        }
+                    };
+                    let old_transactions = self
+                        .stackerdb
+                        .get_signer_transactions_with_retry(&vec![self.signer_id])
+                        .map_err(|e| {
+                            error!("Failed to get old transactions from stackerdb: {:?}", e);
+                        })
+                        .unwrap_or_default();
+                    // Filter out our old transactions that are no longer valid
+                    let mut new_transactions: Vec<_> = old_transactions.into_iter().filter_map(|transaction|  {
+                        let origin_address = transaction.origin_address();
+                        let origin_nonce = transaction.get_origin_nonce();
+                        let Ok(account_nonce) = retry_with_exponential_backoff(|| self.stacks_client.get_account_nonce(&origin_address).map_err(backoff::Error::transient)) else {
+                            warn!("Signer #{}: Unable to get account for address: {origin_address}. Removing {} from our stored transactions.", self.signer_id, transaction.txid());
+                            return None;
+                        };
+                        if origin_nonce < account_nonce {
+                            debug!("Signer #{}: Transaction {} has an invalid nonce. Removing if removing it from our stored transactions.", self.signer_id, transaction.txid());
+                            return None;
+                        }
+                        Some(transaction)
+                    }).collect();
+                    info!("Signer #{}: Writing DKG vote transaction {} to stackerdb for other signers and the miner to observe.", new_transaction.txid(), self.signer_id);
+                    new_transactions.push(new_transaction);
+                    let signer_message = SignerMessage::Transactions(new_transactions);
+                    if let Err(e) = self.stackerdb.send_message_with_retry(signer_message) {
+                        warn!(
+                            "Signer #{}: Failed to update transactions in stacker-db: {:?}",
+                            self.signer_id, e
+                        );
+                    }
+                }
+                OperationResult::SignError(e) => {
+                    self.process_sign_error(e);
+                }
+                OperationResult::DkgError(e) => {
+                    warn!("Signer #{}: Received a DKG error: {:?}", self.signer_id, e);
+                }
+            }
+        }
+    }
+
+    /// Process a signature from a signing round by deserializing the signature and
+    /// broadcasting an appropriate Reject or Approval message to stackerdb
+    fn process_signature(&mut self, signature: &Signature) {
+        // Deserialize the signature result and broadcast an appropriate Reject or Approval message to stackerdb
+        let Some(aggregate_public_key) = &self.coordinator.get_aggregate_public_key() else {
+            debug!(
+                "Signer #{}: No aggregate public key set. Cannot validate signature...",
+                self.signer_id
+            );
+            return;
+        };
+        let message = self.coordinator.get_message();
+        // This jankiness is because a coordinator could have signed a rejection we need to find the underlying block hash
+        let signer_signature_hash_bytes = if message.len() > 32 {
+            &message[..32]
+        } else {
+            &message
+        };
+        let Some(signer_signature_hash) =
+            Sha512Trunc256Sum::from_bytes(signer_signature_hash_bytes)
+        else {
+            debug!("Signer #{}: Received a signature result for a signature over a non-block. Nothing to broadcast.", self.signer_id);
+            return;
+        };
+
+        // TODO: proper garbage collection...This is currently our only cleanup of blocks
+        self.blocks.remove(&signer_signature_hash);
+
+        // This signature is no longer valid. Do not broadcast it.
+        if !signature.verify(aggregate_public_key, &message) {
+            warn!("Signer #{}: Received an invalid signature result across the block. Do not broadcast it.", self.signer_id);
+            // TODO: should we reinsert it and trigger a sign round across the block again?
+            return;
+        }
+
+        let block_submission = if message == signer_signature_hash.0.to_vec() {
+            // we agreed to sign the block hash. Return an approval message
+            BlockResponse::accepted(signer_signature_hash, signature.clone()).into()
+        } else {
+            // We signed a rejection message. Return a rejection message
+            BlockResponse::rejected(signer_signature_hash, signature.clone()).into()
+        };
+
+        // Submit signature result to miners to observe
+        debug!(
+            "Signer #{}: submit block response {:?}",
+            self.signer_id, &block_submission
+        );
+        if let Err(e) = self.stackerdb.send_message_with_retry(block_submission) {
+            warn!(
+                "Signer #{}: Failed to send block submission to stacker-db: {:?}",
+                self.signer_id, e
+            );
+        }
+    }
+
+    /// Process a sign error from a signing round, broadcasting a rejection message to stackerdb accordingly
+    fn process_sign_error(&mut self, e: &SignError) {
+        warn!(
+            "Signer #{}: Received a signature error: {:?}",
+            self.signer_id, e
+        );
+        match e {
+            SignError::NonceTimeout(_valid_signers, _malicious_signers) => {
+                //TODO: report these malicious signers
+                debug!(
+                    "Signer #{}: Received a nonce timeout error.",
+                    self.signer_id
+                );
+            }
+            SignError::InsufficientSigners(malicious_signers) => {
+                debug!(
+                    "Signer #{}: Received a insufficient signers error.",
+                    self.signer_id
+                );
+                let message = self.coordinator.get_message();
+                let block = read_next::<NakamotoBlock, _>(&mut &message[..]).ok().unwrap_or({
+                        // This is not a block so maybe its across its hash
+                        // This jankiness is because a coordinator could have signed a rejection we need to find the underlying block hash
+                        let signer_signature_hash_bytes = if message.len() > 32 {
+                            &message[..32]
+                        } else {
+                            &message
+                        };
+                        let Some(signer_signature_hash) = Sha512Trunc256Sum::from_bytes(signer_signature_hash_bytes) else {
+                            debug!("Signer #{}: Received a signature result for a signature over a non-block. Nothing to broadcast.", self.signer_id);
+                            return;
+                        };
+                        let Some(block_info) = self.blocks.remove(&signer_signature_hash) else {
+                            debug!("Signer #{}: Received a signature result for a block we have not seen before. Ignoring...", self.signer_id);
+                            return;
+                        };
+                        block_info.block
+                    });
+                // We don't have enough signers to sign the block. Broadcast a rejection
+                let block_rejection = BlockRejection::new(
+                    block.header.signer_signature_hash(),
+                    RejectCode::InsufficientSigners(malicious_signers.clone()),
+                );
+                debug!(
+                    "Signer #{}: Insufficient signers for block; send rejection {:?}",
+                    self.signer_id, &block_rejection
+                );
+                // Submit signature result to miners to observe
+                if let Err(e) = self
+                    .stackerdb
+                    .send_message_with_retry(block_rejection.into())
+                {
+                    warn!(
+                        "Signer #{}: Failed to send block submission to stacker-db: {:?}",
+                        self.signer_id, e
+                    );
+                }
+            }
+            SignError::Aggregator(e) => {
+                warn!(
+                    "Signer #{}: Received an aggregator error: {:?}",
+                    self.signer_id, e
+                );
+            }
+        }
+        // TODO: should reattempt to sign the block here or should we just broadcast a rejection or do nothing and wait for the signers to propose a new block?
+    }
+
+    /// Send any operation results across the provided channel
+    fn send_operation_results(
+        &mut self,
+        res: Sender<Vec<OperationResult>>,
+        operation_results: Vec<OperationResult>,
+    ) {
+        let nmb_results = operation_results.len();
+        match res.send(operation_results) {
+            Ok(_) => {
+                debug!(
+                    "Signer #{}: Successfully sent {} operation result(s)",
+                    self.signer_id, nmb_results
+                )
+            }
+            Err(e) => {
+                warn!(
+                    "Signer #{}: Failed to send {} operation results: {:?}",
+                    self.signer_id, nmb_results, e
+                );
+            }
+        }
+    }
+
+    /// Sending all provided packets through stackerdb with a retry
+    fn send_outbound_messages(&mut self, outbound_messages: Vec<Packet>) {
+        debug!(
+            "Signer #{}: Sending {} messages to other stacker-db instances.",
+            self.signer_id,
+            outbound_messages.len()
+        );
+        for msg in outbound_messages {
+            let ack = self.stackerdb.send_message_with_retry(msg.into());
+            if let Ok(ack) = ack {
+                debug!("Signer #{}: send outbound ACK: {:?}", self.signer_id, ack);
+            } else {
+                warn!(
+                    "Signer #{}: Failed to send message to stacker-db instance: {:?}",
+                    self.signer_id, ack
+                );
+            }
+        }
+    }
+
+    /// Update the DKG for the provided signer info, triggering it if required
+    pub fn update_dkg(&mut self) -> Result<(), ClientError> {
+        let reward_cycle = self.reward_cycle;
+        let aggregate_public_key = self.stacks_client.get_aggregate_public_key(reward_cycle)?;
+        let in_vote_window = self
+            .stacks_client
+            .reward_cycle_in_vote_window(reward_cycle)?;
+        self.coordinator
+            .set_aggregate_public_key(aggregate_public_key);
+        let coordinator_id =
+            calculate_coordinator(&self.signing_round.public_keys, &self.stacks_client).0;
+        // TODO: should we attempt to vote anyway if out of window? what if we didn't successfully run DKG in prepare phase?
+        if in_vote_window
+            && aggregate_public_key.is_none()
+            && self.signer_id == coordinator_id
+            && self.coordinator.state == CoordinatorState::Idle
+        {
+            info!("Signer is the coordinator and is in the prepare phase for reward cycle {reward_cycle}. Triggering a DKG round...");
+            self.commands.push_back(Command::Dkg);
+        } else {
+            debug!("Not updating dkg";
+                "in_vote_window" => in_vote_window,
+                "aggregate_public_key" => aggregate_public_key.is_some(),
+                "signer_id" => self.signer_id,
+                "coordinator_id" => coordinator_id,
+            );
+        }
+        Ok(())
+    }
+
+    /// Process the event
+    pub fn process_event(
+        &mut self,
+        event: Option<&SignerEvent>,
+        res: Sender<Vec<OperationResult>>,
+    ) -> Result<(), ClientError> {
+        let current_reward_cycle = retry_with_exponential_backoff(|| {
+            self.stacks_client
+                .get_current_reward_cycle()
+                .map_err(backoff::Error::transient)
+        })?;
+        if current_reward_cycle > self.reward_cycle {
+            // We have advanced past our tenure as a signer. Nothing to do.
+            info!(
+                "Signer #{}: Signer has passed its tenure. Ignoring event...",
+                self.signer_id
+            );
+            self.state = State::TenureExceeded;
+            return Ok(());
+        }
+        debug!("Signer #{}: Processing event: {:?}", self.signer_id, event);
+        match event {
+            Some(SignerEvent::BlockValidationResponse(block_validate_response)) => {
+                debug!(
+                    "Signer #{}: Received a block proposal result from the stacks node...",
+                    self.signer_id
+                );
+                self.handle_block_validate_response(block_validate_response, res)
+            }
+            Some(SignerEvent::SignerMessages(reward_index, messages)) => {
+                if *reward_index != self.stackerdb.get_signer_set() {
+                    debug!("Signer #{}: Received a signer message for a reward cycle that do not belong to this signer. Ignoring...", self.signer_id);
+                    return Ok(());
+                }
+                debug!(
+                    "Signer #{}: Received {} messages from the other signers...",
+                    self.signer_id,
+                    messages.len()
+                );
+                self.handle_signer_messages(res, messages);
+            }
+            Some(SignerEvent::ProposedBlocks(blocks)) => {
+                if current_reward_cycle != self.reward_cycle {
+                    // There is not point in processing blocks if we are not the current reward cycle (we can never actually contribute to signing these blocks)
+                    debug!("Signer #{}: Received a proposed block, but this signer's reward cycle ({}) is not the current one ({}). Ignoring...", self.signer_id, self.reward_cycle, current_reward_cycle);
+                    return Ok(());
+                }
+                debug!(
+                    "Signer #{}: Received {} block proposals from the miners...",
+                    self.signer_id,
+                    blocks.len()
+                );
+                self.handle_proposed_blocks(blocks);
+            }
+            Some(SignerEvent::StatusCheck) => {
+                debug!("Signer #{}: Received a status check event.", self.signer_id)
+            }
+            None => {
+                // No event. Do nothing.
+                debug!("Signer #{}: No event received", self.signer_id)
+            }
+        }
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::thread::spawn;
+
+    use blockstack_lib::chainstate::nakamoto::{NakamotoBlock, NakamotoBlockHeader};
+    use blockstack_lib::chainstate::stacks::boot::SIGNERS_VOTING_NAME;
+    use blockstack_lib::chainstate::stacks::{ThresholdSignature, TransactionVersion};
+    use blockstack_lib::util_lib::boot::{boot_code_addr, boot_code_id};
+    use libsigner::SignerMessage;
+    use serial_test::serial;
+    use stacks_common::bitvec::BitVec;
+    use stacks_common::codec::StacksMessageCodec;
+    use stacks_common::types::chainstate::{
+        ConsensusHash, StacksBlockId, StacksPrivateKey, TrieHash,
+    };
+    use stacks_common::util::hash::{MerkleTree, Sha512Trunc256Sum};
+    use stacks_common::util::secp256k1::MessageSignature;
+    use wsts::curve::ecdsa;
+
+    use crate::client::tests::{generate_public_keys, write_response, TestConfig};
+    use crate::client::{StacksClient, VOTE_FUNCTION_NAME};
+    use crate::config::Config;
+    use crate::signer::{BlockInfo, Signer, StacksNodeInfo};
+
+    #[test]
+    #[serial]
+    fn get_expected_transactions_should_filter_invalid_transactions() {
+        // Create a runloop of a valid signer
+        let config = Config::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
+        let (public_keys, signer_key_ids, stacks_addresses, signer_public_keys) =
+            generate_public_keys(
+                5,
+                20,
+                Some(
+                    ecdsa::PublicKey::new(&config.ecdsa_private_key)
+                        .expect("Failed to create public key."),
+                ),
+            );
+        let signer_addresses = stacks_addresses.into_iter().collect();
+        let stacks_node_info = StacksNodeInfo {
+            signer_id: 0,
+            reward_cycle: 2,
+            signer_set: 0,
+            signer_slot_id: 0,
+            signer_addresses,
+            public_keys,
+            signer_key_ids,
+            signer_public_keys,
+        };
+        let mut signer = Signer::new(&config, stacks_node_info);
+
+        let signer_private_key = config.stacks_private_key;
+        let non_signer_private_key = StacksPrivateKey::new();
+
+        let vote_contract_id = boot_code_id(SIGNERS_VOTING_NAME, signer.is_mainnet);
+        let contract_addr = vote_contract_id.issuer.into();
+        let contract_name = vote_contract_id.name.clone();
+        // Create a valid transaction signed by the signer private key coresponding to the slot into which it is being inserted (signer id 0)
+        let valid_tx = StacksClient::build_signed_contract_call_transaction(
+            &contract_addr,
+            contract_name.clone(),
+            VOTE_FUNCTION_NAME.into(),
+            &[],
+            &signer_private_key,
+            TransactionVersion::Testnet,
+            config.network.to_chain_id(),
+            1,
+            10,
+        )
+        .unwrap();
+        let invalid_tx_bad_signer = StacksClient::build_signed_contract_call_transaction(
+            &contract_addr,
+            contract_name.clone(),
+            VOTE_FUNCTION_NAME.into(),
+            &[],
+            &non_signer_private_key,
+            TransactionVersion::Testnet,
+            config.network.to_chain_id(),
+            0,
+            10,
+        )
+        .unwrap();
+        let invalid_tx_outdated_nonce = StacksClient::build_signed_contract_call_transaction(
+            &contract_addr,
+            contract_name.clone(),
+            VOTE_FUNCTION_NAME.into(),
+            &[],
+            &signer_private_key,
+            TransactionVersion::Testnet,
+            config.network.to_chain_id(),
+            0,
+            5,
+        )
+        .unwrap();
+        let bad_contract_addr = boot_code_addr(true);
+        let invalid_tx_bad_contract_addr = StacksClient::build_signed_contract_call_transaction(
+            &bad_contract_addr,
+            contract_name.clone(),
+            VOTE_FUNCTION_NAME.into(),
+            &[],
+            &signer_private_key,
+            TransactionVersion::Testnet,
+            config.network.to_chain_id(),
+            1,
+            5,
+        )
+        .unwrap();
+
+        let invalid_tx_bad_contract_name = StacksClient::build_signed_contract_call_transaction(
+            &contract_addr,
+            "wrong".into(),
+            VOTE_FUNCTION_NAME.into(),
+            &[],
+            &signer_private_key,
+            TransactionVersion::Testnet,
+            config.network.to_chain_id(),
+            1,
+            5,
+        )
+        .unwrap();
+
+        let invalid_tx_bad_function = StacksClient::build_signed_contract_call_transaction(
+            &contract_addr,
+            contract_name.clone(),
+            "fake-function".into(),
+            &[],
+            &signer_private_key,
+            TransactionVersion::Testnet,
+            config.network.to_chain_id(),
+            1,
+            5,
+        )
+        .unwrap();
+
+        let transactions = vec![
+            valid_tx.clone(),
+            invalid_tx_outdated_nonce,
+            invalid_tx_bad_signer,
+            invalid_tx_bad_contract_addr,
+            invalid_tx_bad_contract_name,
+            invalid_tx_bad_function,
+        ];
+        let num_transactions = transactions.len();
+
+        let h = spawn(move || signer.get_expected_transactions().unwrap());
+
+        // Simulate the response to the request for transactions
+        let signer_message = SignerMessage::Transactions(transactions);
+        let message = signer_message.serialize_to_vec();
+        let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
+        response_bytes.extend(message);
+        let test_config = TestConfig::from_config(config.clone());
+        write_response(test_config.mock_server, response_bytes.as_slice());
+
+        let signer_message = SignerMessage::Transactions(vec![]);
+        let message = signer_message.serialize_to_vec();
+        let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
+        response_bytes.extend(message);
+        let test_config = TestConfig::from_config(config.clone());
+        write_response(test_config.mock_server, response_bytes.as_slice());
+
+        let signer_message = SignerMessage::Transactions(vec![]);
+        let message = signer_message.serialize_to_vec();
+        let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
+        response_bytes.extend(message);
+        let test_config = TestConfig::from_config(config.clone());
+        write_response(test_config.mock_server, response_bytes.as_slice());
+
+        let signer_message = SignerMessage::Transactions(vec![]);
+        let message = signer_message.serialize_to_vec();
+        let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
+        response_bytes.extend(message);
+        let test_config = TestConfig::from_config(config.clone());
+        write_response(test_config.mock_server, response_bytes.as_slice());
+
+        let signer_message = SignerMessage::Transactions(vec![]);
+        let message = signer_message.serialize_to_vec();
+        let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
+        response_bytes.extend(message);
+        let test_config = TestConfig::from_config(config.clone());
+        write_response(test_config.mock_server, response_bytes.as_slice());
+
+        for _ in 0..num_transactions {
+            let nonce_response = b"HTTP/1.1 200 OK\n\n{\"nonce\":1,\"balance\":\"0x00000000000000000000000000000000\",\"locked\":\"0x00000000000000000000000000000000\",\"unlock_height\":0}";
+            let test_config = TestConfig::from_config(config.clone());
+            write_response(test_config.mock_server, nonce_response);
+        }
+
+        let filtered_txs = h.join().unwrap();
+        assert_eq!(filtered_txs, vec![valid_tx]);
+    }
+
+    #[test]
+    #[serial]
+    fn verify_transactions_valid() {
+        let config = Config::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
+        let (public_keys, signer_key_ids, stacks_addresses, signer_public_keys) =
+            generate_public_keys(
+                5,
+                20,
+                Some(
+                    ecdsa::PublicKey::new(&config.ecdsa_private_key)
+                        .expect("Failed to create public key."),
+                ),
+            );
+        let signer_addresses = stacks_addresses.into_iter().collect();
+        let stacks_node_info = StacksNodeInfo {
+            signer_id: 0,
+            reward_cycle: 2,
+            signer_set: 0,
+            signer_slot_id: 0,
+            signer_addresses,
+            public_keys,
+            signer_key_ids,
+            signer_public_keys,
+        };
+        let mut signer = Signer::new(&config, stacks_node_info);
+
+        let signer_private_key = config.stacks_private_key;
+        let vote_contract_id = boot_code_id(SIGNERS_VOTING_NAME, signer.is_mainnet);
+        let contract_addr = vote_contract_id.issuer.into();
+        let contract_name = vote_contract_id.name.clone();
+        // Create a valid transaction signed by the signer private key coresponding to the slot into which it is being inserted (signer id 0)
+        let valid_tx = StacksClient::build_signed_contract_call_transaction(
+            &contract_addr,
+            contract_name.clone(),
+            VOTE_FUNCTION_NAME.into(),
+            &[],
+            &signer_private_key,
+            TransactionVersion::Testnet,
+            config.network.to_chain_id(),
+            1,
+            10,
+        )
+        .unwrap();
+
+        // Create a block
+        let header = NakamotoBlockHeader {
+            version: 1,
+            chain_length: 2,
+            burn_spent: 3,
+            consensus_hash: ConsensusHash([0x04; 20]),
+            parent_block_id: StacksBlockId([0x05; 32]),
+            tx_merkle_root: Sha512Trunc256Sum([0x06; 32]),
+            state_index_root: TrieHash([0x07; 32]),
+            miner_signature: MessageSignature::empty(),
+            signer_signature: ThresholdSignature::empty(),
+            signer_bitvec: BitVec::zeros(1).unwrap(),
+        };
+        let mut block = NakamotoBlock {
+            header,
+            txs: vec![valid_tx.clone()],
+        };
+        let tx_merkle_root = {
+            let txid_vecs = block
+                .txs
+                .iter()
+                .map(|tx| tx.txid().as_bytes().to_vec())
+                .collect();
+
+            MerkleTree::<Sha512Trunc256Sum>::new(&txid_vecs).root()
+        };
+        block.header.tx_merkle_root = tx_merkle_root;
+
+        // Ensure this is a block the signer has seen already
+        signer.blocks.insert(
+            block.header.signer_signature_hash(),
+            BlockInfo::new(block.clone()),
+        );
+
+        let h = spawn(move || signer.verify_transactions(&block));
+
+        // Simulate the response to the request for transactions with the expected transaction
+        let signer_message = SignerMessage::Transactions(vec![valid_tx]);
+        let message = signer_message.serialize_to_vec();
+        let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
+        response_bytes.extend(message);
+        let test_config = TestConfig::from_config(config.clone());
+        write_response(test_config.mock_server, response_bytes.as_slice());
+
+        let signer_message = SignerMessage::Transactions(vec![]);
+        let message = signer_message.serialize_to_vec();
+        let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
+        response_bytes.extend(message);
+        let test_config = TestConfig::from_config(config.clone());
+        write_response(test_config.mock_server, response_bytes.as_slice());
+
+        let signer_message = SignerMessage::Transactions(vec![]);
+        let message = signer_message.serialize_to_vec();
+        let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
+        response_bytes.extend(message);
+        let test_config = TestConfig::from_config(config.clone());
+        write_response(test_config.mock_server, response_bytes.as_slice());
+
+        let signer_message = SignerMessage::Transactions(vec![]);
+        let message = signer_message.serialize_to_vec();
+        let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
+        response_bytes.extend(message);
+        let test_config = TestConfig::from_config(config.clone());
+        write_response(test_config.mock_server, response_bytes.as_slice());
+
+        let signer_message = SignerMessage::Transactions(vec![]);
+        let message = signer_message.serialize_to_vec();
+        let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
+        response_bytes.extend(message);
+        let test_config = TestConfig::from_config(config.clone());
+        write_response(test_config.mock_server, response_bytes.as_slice());
+
+        let nonce_response = b"HTTP/1.1 200 OK\n\n{\"nonce\":1,\"balance\":\"0x00000000000000000000000000000000\",\"locked\":\"0x00000000000000000000000000000000\",\"unlock_height\":0}";
+        let test_config = TestConfig::from_config(config.clone());
+        write_response(test_config.mock_server, nonce_response);
+
+        let valid = h.join().unwrap();
+        assert!(valid);
+    }
+}
diff --git a/stacks-signer/src/tests/conf/signer-0.toml b/stacks-signer/src/tests/conf/signer-0.toml
index 86d79c9490..42083c30a7 100644
--- a/stacks-signer/src/tests/conf/signer-0.toml
+++ b/stacks-signer/src/tests/conf/signer-0.toml
@@ -3,12 +3,3 @@ stacks_private_key = "6a1fc1a3183018c6d79a4e11e154d2bdad2d89ac8bc1b0a021de8b4d28
 node_host = "127.0.0.1:20443"
 endpoint = "localhost:30000"
 network = "testnet"
-stackerdb_contract_id = "ST11Z60137Y96MF89K1KKRTA3CR6B25WY1Y931668.signers-stackerdb"
-signer_id = 0
-signers = [
-    {public_key = "27MvzC7LYTFfjBQdZropBqzWSKQYgFVHWh3YXchYrh5Ug", key_ids = [1, 2, 3, 4]},
-    {public_key = "f1Y6JdedrZyaZLnScbXbc1A7DhdLMjCipKCxkKUA93YQ", key_ids = [5, 6, 7, 8]},
-    {public_key = "nKPew4JetMvV97EghsdikNMhgyYF37ZeNvmJNSJueyjQ", key_ids = [9, 10, 11, 12]},
-    {public_key = "x3LcNnYgKKFBUaf9fZTEGHghFCQQyd6F9XNWj7nRXLt7", key_ids = [13, 14, 15, 16]},
-    {public_key = "nUVH972kFxpKbD62muCb9L48nTKqNw11yp3vFM9VDzqw", key_ids = [17, 18, 19, 20]}
-]
diff --git a/stacks-signer/src/tests/conf/signer-1.toml b/stacks-signer/src/tests/conf/signer-1.toml
index 114c25ed23..38897ae48c 100644
--- a/stacks-signer/src/tests/conf/signer-1.toml
+++ b/stacks-signer/src/tests/conf/signer-1.toml
@@ -3,12 +3,3 @@ stacks_private_key = "126e916e77359ccf521e168feea1fcb9626c59dc375cae00c746430338
 node_host = "127.0.0.1:20443"
 endpoint = "localhost:30001"
 network = "testnet"
-stackerdb_contract_id = "ST11Z60137Y96MF89K1KKRTA3CR6B25WY1Y931668.signers-stackerdb"
-signer_id = 1
-signers = [
-    {public_key = "27MvzC7LYTFfjBQdZropBqzWSKQYgFVHWh3YXchYrh5Ug", key_ids = [1, 2, 3, 4]},
-    {public_key = "f1Y6JdedrZyaZLnScbXbc1A7DhdLMjCipKCxkKUA93YQ", key_ids = [5, 6, 7, 8]},
-    {public_key = "nKPew4JetMvV97EghsdikNMhgyYF37ZeNvmJNSJueyjQ", key_ids = [9, 10, 11, 12]},
-    {public_key = "x3LcNnYgKKFBUaf9fZTEGHghFCQQyd6F9XNWj7nRXLt7", key_ids = [13, 14, 15, 16]},
-    {public_key = "nUVH972kFxpKbD62muCb9L48nTKqNw11yp3vFM9VDzqw", key_ids = [17, 18, 19, 20]}
-]
diff --git a/stacks-signer/src/tests/conf/signer-2.toml b/stacks-signer/src/tests/conf/signer-2.toml
index d37072f4e9..9235b2e076 100644
--- a/stacks-signer/src/tests/conf/signer-2.toml
+++ b/stacks-signer/src/tests/conf/signer-2.toml
@@ -3,12 +3,3 @@ stacks_private_key = "b169d0d1408f66d16beb321857f525f9014dfc289f1aeedbcf96e78afe
 node_host = "127.0.0.1:20443"
 endpoint = "localhost:30002"
 network = "testnet"
-stackerdb_contract_id = "ST11Z60137Y96MF89K1KKRTA3CR6B25WY1Y931668.signers-stackerdb"
-signer_id = 2
-signers = [
-    {public_key = "27MvzC7LYTFfjBQdZropBqzWSKQYgFVHWh3YXchYrh5Ug", key_ids = [1, 2, 3, 4]},
-    {public_key = "f1Y6JdedrZyaZLnScbXbc1A7DhdLMjCipKCxkKUA93YQ", key_ids = [5, 6, 7, 8]},
-    {public_key = "nKPew4JetMvV97EghsdikNMhgyYF37ZeNvmJNSJueyjQ", key_ids = [9, 10, 11, 12]},
-    {public_key = "x3LcNnYgKKFBUaf9fZTEGHghFCQQyd6F9XNWj7nRXLt7", key_ids = [13, 14, 15, 16]},
-    {public_key = "nUVH972kFxpKbD62muCb9L48nTKqNw11yp3vFM9VDzqw", key_ids = [17, 18, 19, 20]}
-]
diff --git a/stacks-signer/src/tests/conf/signer-3.toml b/stacks-signer/src/tests/conf/signer-3.toml
index 4f6fb7ff25..b96eef0098 100644
--- a/stacks-signer/src/tests/conf/signer-3.toml
+++ b/stacks-signer/src/tests/conf/signer-3.toml
@@ -3,12 +3,3 @@ stacks_private_key = "63cef3cd8880969b7f2450ca13b9ca57fd3cd3f7ee57ec6ed7654a84d3
 node_host = "127.0.0.1:20443"
 endpoint = "localhost:30003"
 network = "testnet"
-stackerdb_contract_id = "ST11Z60137Y96MF89K1KKRTA3CR6B25WY1Y931668.signers-stackerdb"
-signer_id = 3
-signers = [
-    {public_key = "27MvzC7LYTFfjBQdZropBqzWSKQYgFVHWh3YXchYrh5Ug", key_ids = [1, 2, 3, 4]},
-    {public_key = "f1Y6JdedrZyaZLnScbXbc1A7DhdLMjCipKCxkKUA93YQ", key_ids = [5, 6, 7, 8]},
-    {public_key = "nKPew4JetMvV97EghsdikNMhgyYF37ZeNvmJNSJueyjQ", key_ids = [9, 10, 11, 12]},
-    {public_key = "x3LcNnYgKKFBUaf9fZTEGHghFCQQyd6F9XNWj7nRXLt7", key_ids = [13, 14, 15, 16]},
-    {public_key = "nUVH972kFxpKbD62muCb9L48nTKqNw11yp3vFM9VDzqw", key_ids = [17, 18, 19, 20]}
-]
diff --git a/stacks-signer/src/tests/conf/signer-4.toml b/stacks-signer/src/tests/conf/signer-4.toml
index fa15e83cfd..87cda83327 100644
--- a/stacks-signer/src/tests/conf/signer-4.toml
+++ b/stacks-signer/src/tests/conf/signer-4.toml
@@ -3,12 +3,3 @@ stacks_private_key = "e427196ae29197b1db6d5495ff26bf0675f48a4f07b200c0814b95734e
 node_host = "127.0.0.1:20443"
 endpoint = "localhost:30004"
 network = "testnet"
-stackerdb_contract_id = "ST11Z60137Y96MF89K1KKRTA3CR6B25WY1Y931668.signers-stackerdb"
-signer_id = 4
-signers = [
-    {public_key = "27MvzC7LYTFfjBQdZropBqzWSKQYgFVHWh3YXchYrh5Ug", key_ids = [1, 2, 3, 4]},
-    {public_key = "f1Y6JdedrZyaZLnScbXbc1A7DhdLMjCipKCxkKUA93YQ", key_ids = [5, 6, 7, 8]},
-    {public_key = "nKPew4JetMvV97EghsdikNMhgyYF37ZeNvmJNSJueyjQ", key_ids = [9, 10, 11, 12]},
-    {public_key = "x3LcNnYgKKFBUaf9fZTEGHghFCQQyd6F9XNWj7nRXLt7", key_ids = [13, 14, 15, 16]},
-    {public_key = "nUVH972kFxpKbD62muCb9L48nTKqNw11yp3vFM9VDzqw", key_ids = [17, 18, 19, 20]}
-]
diff --git a/stacks-signer/src/tests/config.rs b/stacks-signer/src/tests/config.rs
deleted file mode 100644
index 8b13789179..0000000000
--- a/stacks-signer/src/tests/config.rs
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/stacks-signer/src/tests/contracts/signers-stackerdb.clar b/stacks-signer/src/tests/contracts/signers-stackerdb.clar
deleted file mode 100644
index 9f113eaf8a..0000000000
--- a/stacks-signer/src/tests/contracts/signers-stackerdb.clar
+++ /dev/null
@@ -1,59 +0,0 @@
-        ;; stacker DB
-        (define-read-only (stackerdb-get-signer-slots-page (page-id uint))
-            (ok (list
-                {
-                    signer: 'ST24GDPTR7D9G3GFRR233JMWSD9HA296EXXG5XVGA,
-                    num-slots: u10
-                }
-                {
-                    signer: 'ST1MR26HR7MMDE847BE2QC1CTNQY4WKN9XDKNPEP3,
-                    num-slots: u10
-                }
-                {
-                    signer: 'ST110M4DRDXX2RF3W8EY1HCRQ25CS24PGY22DZ004,
-                    num-slots: u10
-                }
-                {
-                    signer: 'ST69990VH3BVCV39QWT6CJAVVA9QPB1715HTSN75,
-                    num-slots: u10
-                }
-                {
-                    signer: 'STCZSBZJK6C3MMAAW9N9RHSDKRKB9AKGJ2JMVDKN,
-                    num-slots: u10
-                }
-                )))
-        
-        ;; stacker DB
-        (define-read-only (stackerdb-get-signer-slots)
-            (ok (list
-                {
-                    signer: 'ST24GDPTR7D9G3GFRR233JMWSD9HA296EXXG5XVGA,
-                    num-slots: u10
-                }
-                {
-                    signer: 'ST1MR26HR7MMDE847BE2QC1CTNQY4WKN9XDKNPEP3,
-                    num-slots: u10
-                }
-                {
-                    signer: 'ST110M4DRDXX2RF3W8EY1HCRQ25CS24PGY22DZ004,
-                    num-slots: u10
-                }
-                {
-                    signer: 'ST69990VH3BVCV39QWT6CJAVVA9QPB1715HTSN75,
-                    num-slots: u10
-                }
-                {
-                    signer: 'STCZSBZJK6C3MMAAW9N9RHSDKRKB9AKGJ2JMVDKN,
-                    num-slots: u10
-                }
-                )))
-
-        (define-read-only (stackerdb-get-config)
-            (ok {
-                chunk-size: u4096,
-                write-freq: u0,
-                max-writes: u4096,
-                max-neighbors: u32,
-                hint-replicas: (list )
-            }))
-    
diff --git a/stacks-signer/src/tests/mod.rs b/stacks-signer/src/tests/mod.rs
deleted file mode 100644
index 9db1e142ea..0000000000
--- a/stacks-signer/src/tests/mod.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
-// Copyright (C) 2020-2023 Stacks Open Internet Foundation
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-pub mod config;
diff --git a/stacks-signer/src/utils.rs b/stacks-signer/src/utils.rs
deleted file mode 100644
index 1c934cd465..0000000000
--- a/stacks-signer/src/utils.rs
+++ /dev/null
@@ -1,149 +0,0 @@
-// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
-// Copyright (C) 2020-2024 Stacks Open Internet Foundation
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-use std::time::Duration;
-
-use slog::slog_debug;
-use stacks_common::debug;
-use stacks_common::types::chainstate::{StacksAddress, StacksPrivateKey, StacksPublicKey};
-use stacks_common::types::PrivateKey;
-use wsts::curve::ecdsa;
-use wsts::curve::scalar::Scalar;
-
-use crate::config::Network;
-
-/// Helper function for building a signer config for each provided signer private key
-pub fn build_signer_config_tomls(
-    stacks_private_keys: &[StacksPrivateKey],
-    num_keys: u32,
-    node_host: &str,
-    stackerdb_contract_id: &str,
-    timeout: Option<Duration>,
-    network: &Network,
-) -> Vec<String> {
-    let num_signers = stacks_private_keys.len() as u32;
-    let keys_per_signer = num_keys / num_signers;
-    let mut key_id: u32 = 1;
-    let mut key_ids = Vec::new();
-    for i in 0..num_signers {
-        let mut ids = Vec::new();
-        for _ in 0..keys_per_signer {
-            ids.push(format!("{key_id}"));
-            key_id += 1;
-        }
-        if i + 1 == num_signers {
-            for _ in 0..num_keys % num_signers {
-                // We have requested a number of keys that cannot fit evenly into the number of signers
-                // Append the remaining keys to the last signer
-                ids.push(format!("{key_id}"));
-                key_id += 1;
-                debug!("Appending extra key to last signer...");
-            }
-        }
-        key_ids.push(ids.join(", "));
-    }
-
-    let mut signer_config_tomls = vec![];
-    let mut signers_array = String::new();
-
-    signers_array += "signers = [";
-    for (i, stacks_private_key) in stacks_private_keys.iter().enumerate() {
-        let scalar = Scalar::try_from(&stacks_private_key.to_bytes()[..32])
-            .expect("BUG: failed to convert the StacksPrivateKey to a Scalar");
-        let ecdsa_public_key = ecdsa::PublicKey::new(&scalar)
-            .expect("BUG: failed to get a ecdsa::PublicKey from the provided Scalar")
-            .to_string();
-        let ids = key_ids[i].clone();
-        signers_array += &format!(
-            r#"
-    {{public_key = "{ecdsa_public_key}", key_ids = [{ids}]}}"#
-        );
-        if i != stacks_private_keys.len() - 1 {
-            signers_array += ",";
-        }
-    }
-    signers_array += "\n]";
-
-    let mut port = 30000;
-    for (i, stacks_private_key) in stacks_private_keys.iter().enumerate() {
-        let endpoint = format!("localhost:{}", port);
-        port += 1;
-        let id = i;
-        let stacks_private_key = stacks_private_key.to_hex();
-        let mut signer_config_toml = format!(
-            r#"
-stacks_private_key = "{stacks_private_key}"
-node_host = "{node_host}"
-endpoint = "{endpoint}"
-network = "{network}"
-stackerdb_contract_id = "{stackerdb_contract_id}"
-signer_id = {id}
-{signers_array}
-"#
-        );
-
-        if let Some(timeout) = timeout {
-            let event_timeout_ms = timeout.as_millis();
-            signer_config_toml = format!(
-                r#"
-{signer_config_toml}
-event_timeout = {event_timeout_ms}   
-"#
-            )
-        }
-
-        signer_config_tomls.push(signer_config_toml);
-    }
-
-    signer_config_tomls
-}
-
-/// Helper function for building a stackerdb contract from the provided signer stacks addresses
-pub fn build_stackerdb_contract(
-    signer_stacks_addresses: &[StacksAddress],
-    slots_per_user: u32,
-) -> String {
-    let stackers_list: Vec<String> = signer_stacks_addresses
-        .iter()
-        .map(|signer_addr| format!("{{ signer: '{signer_addr}, num-slots: u{slots_per_user}}}"))
-        .collect();
-    let stackers_joined = stackers_list.join(" ");
-
-    let stackerdb_contract = format!(
-        "
-        ;; stacker DB
-        (define-read-only (stackerdb-get-signer-slots (page uint))
-          (ok (list {stackers_joined})))
-        (define-read-only (stackerdb-get-page-count) (ok u1))
-        (define-read-only (stackerdb-get-config)
-          (ok {{
-                 chunk-size: u4096,
-                 write-freq: u0,
-                 max-writes: u4096,
-                 max-neighbors: u32,
-                 hint-replicas: (list )
-               }} ))
-    "
-    );
-    stackerdb_contract
-}
-
-/// Helper function to convert a private key to a Stacks address
-pub fn to_addr(stacks_private_key: &StacksPrivateKey, network: &Network) -> StacksAddress {
-    StacksAddress::p2pkh(
-        network.is_mainnet(),
-        &StacksPublicKey::from_private(stacks_private_key),
-    )
-}
diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index fdb271347a..0d5884b984 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -22,7 +22,9 @@ use clarity::vm::Value;
 use rand::prelude::SliceRandom;
 use rand::{thread_rng, Rng, RngCore};
 use stacks_common::address::{AddressHashMode, C32_ADDRESS_VERSION_TESTNET_SINGLESIG};
-use stacks_common::consts::{FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH};
+use stacks_common::consts::{
+    FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH, SIGNER_SLOTS_PER_USER,
+};
 use stacks_common::types::chainstate::{
     StacksAddress, StacksBlockId, StacksPrivateKey, StacksPublicKey,
 };
@@ -34,6 +36,7 @@ use wsts::curve::point::Point;
 use crate::chainstate::burn::db::sortdb::{SortitionDB, SortitionHandle};
 use crate::chainstate::burn::operations::BlockstackOperationType;
 use crate::chainstate::coordinator::tests::{p2pkh_from, pox_addr_from};
+use crate::chainstate::nakamoto::signer_set::NakamotoSigners;
 use crate::chainstate::nakamoto::test_signers::TestSigners;
 use crate::chainstate::nakamoto::tests::get_account;
 use crate::chainstate::nakamoto::tests::node::TestStacker;
@@ -244,6 +247,13 @@ pub fn boot_nakamoto<'a>(
     peer_config
         .stacker_dbs
         .push(boot_code_id(MINERS_NAME, false));
+    for signer_set in 0..2 {
+        for message_id in 0..SIGNER_SLOTS_PER_USER {
+            let contract_name = NakamotoSigners::make_signers_db_name(signer_set, message_id);
+            let contract_id = boot_code_id(contract_name.as_str(), false);
+            peer_config.stacker_dbs.push(contract_id);
+        }
+    }
     peer_config.epochs = Some(StacksEpoch::unit_test_3_0_only(37));
     peer_config.initial_balances = vec![(addr.to_account_principal(), 1_000_000_000_000_000_000)];
 
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 3a1bc8f5ae..7da10b6235 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -196,6 +196,9 @@ pub fn naka_neon_integration_conf(seed: Option<&[u8]>) -> (Config, StacksAddress
     conf.node
         .stacker_dbs
         .push(boot_code_id(MINERS_NAME, conf.is_mainnet()));
+    conf.node
+        .stacker_dbs
+        .push(boot_code_id(SIGNERS_NAME, conf.is_mainnet()));
     conf.burnchain.burn_fee_cap = 20000;
 
     conf.burnchain.username = Some("neon-tester".into());
@@ -354,6 +357,7 @@ pub fn setup_stacker(naka_conf: &mut Config) -> Secp256k1PrivateKey {
 ///
 /// * `stacker_sks` - must be a private key for sending a large `stack-stx` transaction in order
 ///   for pox-4 to activate
+/// * `signer_pks` - must be the same size as `stacker_sks`
 pub fn boot_to_epoch_3(
     naka_conf: &Config,
     blocks_processed: &RunLoopCounter,
@@ -366,9 +370,10 @@ pub fn boot_to_epoch_3(
     let epochs = naka_conf.burnchain.epochs.clone().unwrap();
     let epoch_3 = &epochs[StacksEpoch::find_epoch_by_id(&epochs, StacksEpochId::Epoch30).unwrap()];
 
+    let epoch_30_start_height = epoch_3.start_height - 1;
     info!(
         "Chain bootstrapped to bitcoin block 201, starting Epoch 2x miner";
-        "Epoch 3.0 Boundary" => (epoch_3.start_height - 1),
+        "Epoch 3.0 Boundary" => epoch_30_start_height,
     );
     let http_origin = format!("http://{}", &naka_conf.node.rpc_bind);
     next_block_and_wait(btc_regtest_controller, &blocks_processed);
@@ -471,7 +476,7 @@ pub fn boot_to_epoch_3(
     run_until_burnchain_height(
         btc_regtest_controller,
         &blocks_processed,
-        epoch_3.start_height - 1,
+        epoch_30_start_height,
         &naka_conf,
     );
 
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index e2cf03b247..309d177f0e 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -1,4 +1,3 @@
-use std::collections::HashMap;
 use std::net::ToSocketAddrs;
 use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
 use std::sync::mpsc::{channel, Receiver, Sender};
@@ -7,6 +6,7 @@ use std::time::{Duration, Instant};
 use std::{env, thread};
 
 use clarity::boot_util::boot_code_id;
+use hashbrown::HashMap;
 use libsigner::{
     BlockResponse, RejectCode, RunningSigner, Signer, SignerEventReceiver, SignerMessage,
     BLOCK_MSG_ID, TRANSACTIONS_MSG_ID,
@@ -31,15 +31,13 @@ use stacks_common::types::chainstate::{
 use stacks_common::util::hash::{MerkleTree, Sha512Trunc256Sum};
 use stacks_common::util::secp256k1::MessageSignature;
 use stacks_signer::client::{StackerDB, StacksClient};
-use stacks_signer::config::{Config as SignerConfig, Network};
+use stacks_signer::config::{build_signer_config_tomls, Config as SignerConfig, Network};
 use stacks_signer::runloop::{calculate_coordinator, RunLoopCommand};
-use stacks_signer::utils::build_signer_config_tomls;
+use stacks_signer::signer::Command as SignerCommand;
 use tracing_subscriber::prelude::*;
 use tracing_subscriber::{fmt, EnvFilter};
 use wsts::curve::point::Point;
-use wsts::state_machine::coordinator::fire::Coordinator as FireCoordinator;
-use wsts::state_machine::OperationResult;
-use wsts::v2;
+use wsts::state_machine::{OperationResult, PublicKeys};
 
 use crate::config::{Config as NeonConfig, EventKeyType, EventObserverConfig, InitialBalance};
 use crate::neon::Counters;
@@ -87,23 +85,18 @@ struct SignerTest {
 }
 
 impl SignerTest {
-    fn new(num_signers: u32, num_keys: u32) -> Self {
+    fn new(num_signers: u32, _num_keys: u32) -> Self {
         // Generate Signer Data
         let signer_stacks_private_keys = (0..num_signers)
             .map(|_| StacksPrivateKey::new())
             .collect::<Vec<StacksPrivateKey>>();
 
-        // Build the stackerdb signers contract
-        let signers_stacker_db_contract_id = boot_code_id(SIGNERS_NAME.into(), false);
-
         let (naka_conf, _miner_account) = naka_neon_integration_conf(None);
 
         // Setup the signer and coordinator configurations
         let signer_configs = build_signer_config_tomls(
             &signer_stacks_private_keys,
-            num_keys,
             &naka_conf.node.rpc_bind,
-            &signers_stacker_db_contract_id.to_string(),
             Some(Duration::from_millis(128)), // Timeout defaults to 5 seconds. Let's override it to 128 milliseconds.
             &Network::Testnet,
         );
@@ -135,8 +128,12 @@ impl SignerTest {
         // Calculate which signer will be selected as the coordinator
         let config = stacks_signer::config::Config::load_from_str(&signer_configs[0]).unwrap();
         let stacks_client = StacksClient::from(&config);
+        let public_key_ids = PublicKeys {
+            key_ids: HashMap::new(),
+            signers: HashMap::new(),
+        };
         let (coordinator_id, coordinator_pk) =
-            calculate_coordinator(&config.signer_ids_public_keys, &stacks_client);
+            calculate_coordinator(&public_key_ids, &stacks_client);
         info!(
             "Selected coordinator id: {:?} with pk: {:?}",
             &coordinator_id, &coordinator_pk
@@ -189,21 +186,16 @@ fn spawn_signer(
     sender: Sender<Vec<OperationResult>>,
 ) -> RunningSigner<SignerEventReceiver, Vec<OperationResult>> {
     let config = stacks_signer::config::Config::load_from_str(data).unwrap();
-    let is_mainnet = config.network.is_mainnet();
-    let ev = SignerEventReceiver::new(vec![config.stackerdb_contract_id.clone()], is_mainnet);
-    let runloop: stacks_signer::runloop::RunLoop<FireCoordinator<v2::Aggregator>> =
-        stacks_signer::runloop::RunLoop::from(&config);
+    let ev = SignerEventReceiver::new(config.network.is_mainnet());
+    let endpoint = config.endpoint;
+    let runloop: stacks_signer::runloop::RunLoop = stacks_signer::runloop::RunLoop::from(config);
     let mut signer: Signer<
         RunLoopCommand,
         Vec<OperationResult>,
-        stacks_signer::runloop::RunLoop<FireCoordinator<v2::Aggregator>>,
+        stacks_signer::runloop::RunLoop,
         SignerEventReceiver,
     > = Signer::new(runloop, ev, receiver, sender);
-    let endpoint = config.endpoint;
-    info!(
-        "Spawning signer {} on endpoint {}",
-        config.signer_id, endpoint
-    );
+    info!("Spawning signer on endpoint {}", endpoint);
     signer.spawn(endpoint).unwrap()
 }
 
@@ -308,7 +300,7 @@ fn setup_stx_btc_node(
         &mut btc_regtest_controller,
     );
 
-    info!("Pox 4 activated and ready for signers to perform DKG and sign!");
+    info!("Pox 4 activated and ready for signers to perform DKG and Sign!");
     RunningNodes {
         btcd_controller,
         btc_regtest_controller,
@@ -375,16 +367,20 @@ fn stackerdb_dkg_sign() {
     info!("------------------------- Test DKG -------------------------");
     info!("signer_runloop: spawn send commands to do dkg");
     let dkg_now = Instant::now();
+    let dkg_command = RunLoopCommand {
+        reward_cycle: 0,
+        command: SignerCommand::Dkg,
+    };
     signer_test
         .coordinator_cmd_sender
-        .send(RunLoopCommand::Dkg)
+        .send(dkg_command)
         .expect("failed to send Dkg command");
     let mut key = Point::default();
     for recv in signer_test.result_receivers.iter() {
         let mut aggregate_public_key = None;
         loop {
             let results = recv
-                .recv_timeout(Duration::from_secs(30))
+                .recv_timeout(Duration::from_secs(100))
                 .expect("failed to recv dkg results");
             for result in results {
                 match result {
@@ -417,21 +413,29 @@ fn stackerdb_dkg_sign() {
     info!("------------------------- Test Sign -------------------------");
     let sign_now = Instant::now();
     info!("signer_runloop: spawn send commands to do dkg and then sign");
-    signer_test
-        .coordinator_cmd_sender
-        .send(RunLoopCommand::Sign {
+    let sign_command = RunLoopCommand {
+        reward_cycle: 0,
+        command: SignerCommand::Sign {
             block: block.clone(),
             is_taproot: false,
             merkle_root: None,
-        })
+        },
+    };
+    let sign_taproot_command = RunLoopCommand {
+        reward_cycle: 0,
+        command: SignerCommand::Sign {
+            block: block.clone(),
+            is_taproot: true,
+            merkle_root: None,
+        },
+    };
+    signer_test
+        .coordinator_cmd_sender
+        .send(sign_command)
         .expect("failed to send non taproot Sign command");
     signer_test
         .coordinator_cmd_sender
-        .send(RunLoopCommand::Sign {
-            block,
-            is_taproot: true,
-            merkle_root: None,
-        })
+        .send(sign_taproot_command)
         .expect("failed to send taproot Sign command");
     for recv in signer_test.result_receivers.iter() {
         let mut frost_signature = None;
@@ -494,8 +498,7 @@ fn stackerdb_dkg_sign() {
 ///
 /// Test Setup:
 /// The test spins up five stacks signers, one miner Nakamoto node, and a corresponding bitcoind.
-/// The stacks node is advanced to epoch 3.0. and signers perform a DKG round (this should be removed
-/// once we have proper casting of the vote during epoch 2.5).
+/// The stacks node is advanced to epoch 3.0, triggering signers to perform DKG round.
 ///
 /// Test Execution:
 /// The node attempts to mine a Nakamoto tenure, sending a block to the observing signers via the
@@ -520,13 +523,6 @@ fn stackerdb_block_proposal() {
     info!("------------------------- Test Setup -------------------------");
     let mut signer_test = SignerTest::new(5, 5);
 
-    // First run DKG in order to sign the block that arrives from the miners following a nakamoto block production
-    // TODO: remove this forcibly running DKG once we have casting of the vote automagically happening during epoch 2.5
-    info!("signer_runloop: spawn send commands to do dkg");
-    signer_test
-        .coordinator_cmd_sender
-        .send(RunLoopCommand::Dkg)
-        .expect("failed to send Dkg command");
     let mut aggregate_public_key = None;
     let recv = signer_test
         .result_receivers
@@ -714,7 +710,7 @@ fn stackerdb_block_proposal_missing_transactions() {
         .unwrap()
         .next()
         .unwrap();
-    let signer_stacker_db_1 = signer_test
+    let _stx_genesissigner_stacker_db_1 = signer_test
         .running_nodes
         .conf
         .node
@@ -748,9 +744,7 @@ fn stackerdb_block_proposal_missing_transactions() {
         .cloned()
         .expect("Cannot find signer private key for signer id 1");
 
-    let mut stackerdb_1 = StackerDB::new(host, signer_stacker_db_1, signer_private_key_1, 0);
-
-    stackerdb_1.set_signer_set(1);
+    let mut stackerdb_1 = StackerDB::new(host, signer_private_key_1, false, 1, 0);
 
     debug!("Signer address is {}", &signer_address_1);
     assert_eq!(
@@ -806,9 +800,13 @@ fn stackerdb_block_proposal_missing_transactions() {
     // First run DKG in order to sign the block that arrives from the miners following a nakamoto block production
     // TODO: remove this forcibly running DKG once we have casting of the vote automagically happening during epoch 2.5
     info!("signer_runloop: spawn send commands to do dkg");
+    let dkg_command = RunLoopCommand {
+        reward_cycle: 0,
+        command: SignerCommand::Dkg,
+    };
     signer_test
         .coordinator_cmd_sender
-        .send(RunLoopCommand::Dkg)
+        .send(dkg_command)
         .expect("failed to send Dkg command");
     let recv = signer_test
         .result_receivers

From 395f84efdbbf364117ab8aba0ba72911b9919134 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 7 Feb 2024 13:09:52 -0800
Subject: [PATCH 0854/1166] Fix tests compilation

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/mod.rs           | 128 ++++------
 stacks-signer/src/client/stackerdb.rs     |  51 ++--
 stacks-signer/src/client/stacks_client.rs | 296 +++++++++++-----------
 stacks-signer/src/config.rs               |   2 -
 stacks-signer/src/main.rs                 |   2 +-
 stacks-signer/src/runloop.rs              |  20 +-
 stacks-signer/src/signer.rs               | 118 ++++-----
 7 files changed, 288 insertions(+), 329 deletions(-)

diff --git a/stacks-signer/src/client/mod.rs b/stacks-signer/src/client/mod.rs
index c1e1ea492c..1e84e1af7f 100644
--- a/stacks-signer/src/client/mod.rs
+++ b/stacks-signer/src/client/mod.rs
@@ -129,10 +129,10 @@ pub(crate) mod tests {
     use std::io::{Read, Write};
     use std::net::{SocketAddr, TcpListener};
 
-    use clarity::vm::types::{ResponseData, TupleData};
-    use clarity::vm::{ClarityName, Value as ClarityValue};
+    use clarity::vm::Value as ClarityValue;
     use hashbrown::{HashMap, HashSet};
-    use rand_core::OsRng;
+    use rand::thread_rng;
+    use rand_core::{OsRng, RngCore};
     use stacks_common::types::chainstate::{StacksAddress, StacksPublicKey};
     use wsts::curve::ecdsa;
     use wsts::curve::point::{Compressed, Point};
@@ -141,52 +141,56 @@ pub(crate) mod tests {
 
     use super::*;
     use crate::config::Config;
+    use crate::signer::StacksNodeInfo;
 
-    pub struct TestConfig {
-        pub mock_server: TcpListener,
+    pub struct MockServerClient {
+        pub server: TcpListener,
         pub client: StacksClient,
-        pub stackerdb: StackerDB,
         pub config: Config,
     }
 
-    impl TestConfig {
-        /// Construct a new TestConfig which will spin up a stacker db, stacks client, and a mock tcp server
+    impl MockServerClient {
+        /// Construct a new MockServerClient on a random port
         pub fn new() -> Self {
             let mut config = Config::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
-
-            let mut mock_server_addr = SocketAddr::from(([127, 0, 0, 1], 0));
-            // Ask the OS to assign a random port to listen on by passing 0
-            let mock_server = TcpListener::bind(mock_server_addr).unwrap();
-
-            // Update the config to use this port
-            mock_server_addr.set_port(mock_server.local_addr().unwrap().port());
+            let (server, mock_server_addr) = mock_server_random();
             config.node_host = mock_server_addr;
 
             let client = StacksClient::from(&config);
-            let stackerdb = StackerDB::new_with_config(&config, 0);
             Self {
-                mock_server,
+                server,
                 client,
-                stackerdb,
                 config,
             }
         }
 
-        /// Construct a new TestConfig from the provided Config. This will spin up a stacker db, stacks client, and a mock tcp server
+        /// Construct a new MockServerClient on the port specified in the config
         pub fn from_config(config: Config) -> Self {
-            let mock_server = TcpListener::bind(config.node_host).unwrap();
-
+            let server = mock_server_from_config(&config);
             let client = StacksClient::from(&config);
-            let stackerdb = StackerDB::new_with_config(&config, 0);
             Self {
-                mock_server,
+                server,
                 client,
-                stackerdb,
                 config,
             }
         }
     }
 
+    /// Create a mock server on a random port and return the socket addr
+    pub fn mock_server_random() -> (TcpListener, SocketAddr) {
+        let mut mock_server_addr = SocketAddr::from(([127, 0, 0, 1], 0));
+        // Ask the OS to assign a random port to listen on by passing 0
+        let server = TcpListener::bind(mock_server_addr).unwrap();
+
+        mock_server_addr.set_port(server.local_addr().unwrap().port());
+        (server, mock_server_addr)
+    }
+
+    /// Create a mock server on a same port as in the config
+    pub fn mock_server_from_config(config: &Config) -> TcpListener {
+        TcpListener::bind(config.node_host).unwrap()
+    }
+
     /// Write a response to the mock server and return the request bytes
     pub fn write_response(mock_server: TcpListener, bytes: &[u8]) -> [u8; 1024] {
         debug!("Writing a response...");
@@ -199,47 +203,6 @@ pub(crate) mod tests {
         request_bytes
     }
 
-    /// Build a response for the get_signers request
-    /// TODO: fix this
-    pub fn build_get_signers_response(config: &Config) -> (String, Vec<StacksAddress>) {
-        let (_generated_public_keys, _signer_key_ids, stacks_addresses, _) = generate_public_keys(
-            10,
-            4000,
-            Some(
-                ecdsa::PublicKey::new(&config.ecdsa_private_key)
-                    .expect("Failed to create public key."),
-            ),
-        );
-        let mut list_data = vec![];
-        for stacks_address in stacks_addresses.clone() {
-            let tuple_data = vec![
-                (
-                    ClarityName::from("signer"),
-                    ClarityValue::Principal(stacks_address.into()),
-                ),
-                (ClarityName::from("weight"), ClarityValue::UInt(1 as u128)),
-            ];
-            let tuple = ClarityValue::Tuple(
-                TupleData::from_data(tuple_data).expect("Failed to create tuple data"),
-            );
-            list_data.push(tuple);
-        }
-
-        let result_data =
-            ClarityValue::cons_list_unsanitized(list_data).expect("Failed to construct list data");
-        let response_clarity = ClarityValue::Response(ResponseData {
-            committed: true,
-            data: Box::new(result_data),
-        });
-        let hex = response_clarity
-            .serialize_to_hex()
-            .expect("Failed to serialize clarity value");
-        (
-            format!("HTTP/1.1 200 OK\n\n{{\"okay\":true,\"result\":\"{hex}\"}}"),
-            stacks_addresses,
-        )
-    }
-
     /// Build a response for the get_last_round request
     pub fn build_get_last_round_response(round: u64) -> String {
         let response = ClarityValue::okay(ClarityValue::UInt(round as u128))
@@ -283,18 +246,13 @@ pub(crate) mod tests {
         )
     }
 
-    /// Generate some random public keys given a num of signers and a num of key ids
-    /// Optionally include a signer pubilc key to set as the first signer id
-    pub fn generate_public_keys(
+    /// Generate a random stacks node info
+    /// Optionally include a signer pubilc key to set as the first signer id with signer id 0 and signer slot id 0
+    pub fn generate_stacks_node_info(
         num_signers: u32,
         num_keys: u32,
         signer_key: Option<ecdsa::PublicKey>,
-    ) -> (
-        PublicKeys,
-        HashMap<u32, HashSet<u32>>,
-        Vec<StacksAddress>,
-        HashMap<u32, Point>,
-    ) {
+    ) -> (StacksNodeInfo, Vec<StacksAddress>) {
         assert!(
             num_signers > 0,
             "Cannot generate 0 signers...Specify at least 1 signer."
@@ -307,6 +265,9 @@ pub(crate) mod tests {
             signers: HashMap::new(),
             key_ids: HashMap::new(),
         };
+        let reward_cycle = thread_rng().next_u64();
+        let signer_set = u32::try_from(reward_cycle % 2)
+            .expect("Failed to convert reward cycle signer set to u32");
         let rng = &mut OsRng;
         let num_keys = num_keys / num_signers;
         let remaining_keys = num_keys % num_signers;
@@ -330,12 +291,13 @@ pub(crate) mod tests {
                             .expect("Failed to create stacks public key"),
                     );
                     addresses.push(address);
+                    public_keys.signers.insert(signer_id, signer_key);
                     let signer_public_key =
                         Point::try_from(&Compressed::from(signer_key.to_bytes())).unwrap();
                     signer_public_keys.insert(signer_id, signer_public_key);
                     public_keys.signers.insert(signer_id, signer_key.clone());
                     for k in start_key_id..end_key_id {
-                        public_keys.key_ids.insert(k, signer_key.clone());
+                        public_keys.key_ids.insert(k, signer_key);
                         signer_key_ids
                             .entry(signer_id)
                             .or_insert(HashSet::new())
@@ -352,7 +314,7 @@ pub(crate) mod tests {
             signer_public_keys.insert(signer_id, signer_public_key);
             public_keys.signers.insert(signer_id, public_key.clone());
             for k in start_key_id..end_key_id {
-                public_keys.key_ids.insert(k, public_key.clone());
+                public_keys.key_ids.insert(k, public_key);
                 signer_key_ids
                     .entry(signer_id)
                     .or_insert(HashSet::new())
@@ -366,6 +328,18 @@ pub(crate) mod tests {
             addresses.push(address);
             start_key_id = end_key_id;
         }
-        (public_keys, signer_key_ids, addresses, signer_public_keys)
+        (
+            StacksNodeInfo {
+                public_keys,
+                signer_key_ids,
+                signer_slot_id: 0,
+                signer_id: 0,
+                signer_set,
+                reward_cycle,
+                signer_addresses: addresses.iter().cloned().collect(),
+                signer_public_keys,
+            },
+            addresses,
+        )
     }
 }
diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index 856db34de1..c17296bcf9 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -65,7 +65,7 @@ impl StackerDB {
             signers_message_stackerdb_sessions.insert(
                 msg_id,
                 StackerDBSession::new(
-                    host.clone(),
+                    host,
                     QualifiedContractIdentifier::new(
                         stackerdb_issuer.into(),
                         ContractName::from(
@@ -93,7 +93,7 @@ impl StackerDB {
             signers_message_stackerdb_sessions.insert(
                 msg_id,
                 StackerDBSession::new(
-                    config.node_host.clone(),
+                    config.node_host,
                     QualifiedContractIdentifier::new(
                         stackerdb_issuer.into(),
                         ContractName::from(
@@ -218,7 +218,7 @@ impl StackerDB {
                 continue;
             };
             let Ok(message) = read_next::<SignerMessage, _>(&mut &data[..]) else {
-                if data.len() > 0 {
+                if !data.is_empty() {
                     warn!("Failed to deserialize chunk data into a SignerMessage");
                     debug!(
                         "signer #{}: Failed chunk ({}): {:?}",
@@ -265,14 +265,26 @@ mod tests {
     };
     use blockstack_lib::util_lib::strings::StacksString;
     use serial_test::serial;
+    use wsts::curve::ecdsa;
 
     use super::*;
-    use crate::client::tests::{write_response, TestConfig};
+    use crate::client::tests::{
+        generate_stacks_node_info, mock_server_from_config, write_response,
+    };
 
     #[test]
     #[serial]
     fn get_signer_transactions_with_retry_should_succeed() {
-        let mut config = TestConfig::new();
+        let config = Config::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
+        let (stacks_node_info, _ordered_addresses) = generate_stacks_node_info(
+            5,
+            20,
+            Some(
+                ecdsa::PublicKey::new(&config.ecdsa_private_key)
+                    .expect("Failed to create public key."),
+            ),
+        );
+        let mut stackerdb = StackerDB::new_with_config(&config, &stacks_node_info);
         let sk = StacksPrivateKey::new();
         let tx = StacksTransaction {
             version: TransactionVersion::Testnet,
@@ -294,21 +306,18 @@ mod tests {
         let message = signer_message.serialize_to_vec();
 
         let signer_ids = vec![0, 1];
-        let h = spawn(move || {
-            config
-                .stackerdb
-                .get_signer_transactions_with_retry(&signer_ids)
-        });
+        let h = spawn(move || stackerdb.get_signer_transactions_with_retry(&signer_ids));
         let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
         response_bytes.extend(message);
-        write_response(config.mock_server, response_bytes.as_slice());
+        let mock_server = mock_server_from_config(&config);
+        write_response(mock_server, response_bytes.as_slice());
 
         let signer_message = SignerMessage::Transactions(vec![]);
         let message = signer_message.serialize_to_vec();
-        let test_config = TestConfig::from_config(config.config);
         let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
         response_bytes.extend(message);
-        write_response(test_config.mock_server, response_bytes.as_slice());
+        let mock_server = mock_server_from_config(&config);
+        write_response(mock_server, response_bytes.as_slice());
 
         let transactions = h.join().unwrap().unwrap();
         assert_eq!(transactions, vec![tx]);
@@ -317,7 +326,16 @@ mod tests {
     #[test]
     #[serial]
     fn send_signer_message_with_retry_should_succeed() {
-        let mut config = TestConfig::new();
+        let config = Config::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
+        let (stacks_node_info, _ordered_addresses) = generate_stacks_node_info(
+            5,
+            20,
+            Some(
+                ecdsa::PublicKey::new(&config.ecdsa_private_key)
+                    .expect("Failed to create public key."),
+            ),
+        );
+        let mut stackerdb = StackerDB::new_with_config(&config, &stacks_node_info);
 
         let sk = StacksPrivateKey::new();
         let tx = StacksTransaction {
@@ -345,9 +363,10 @@ mod tests {
         let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
         let payload = serde_json::to_string(&ack).expect("Failed to serialize ack");
         response_bytes.extend(payload.as_bytes());
-        let h = spawn(move || config.stackerdb.send_message_with_retry(signer_message));
+        let h = spawn(move || stackerdb.send_message_with_retry(signer_message));
         std::thread::sleep(std::time::Duration::from_millis(100));
-        write_response(config.mock_server, response_bytes.as_slice());
+        let mock_server = mock_server_from_config(&config);
+        write_response(mock_server, response_bytes.as_slice());
         assert_eq!(ack, h.join().unwrap().unwrap());
     }
 }
diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index 7d282a538e..6192b68503 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -47,7 +47,7 @@ use crate::client::{retry_with_exponential_backoff, ClientError};
 use crate::config::Config;
 
 /// The name of the function for casting a DKG result to signer vote contract
-pub const VOTE_FUNCTION_NAME: &'static str = "vote-for-aggregate-public-key";
+pub const VOTE_FUNCTION_NAME: &str = "vote-for-aggregate-public-key";
 
 /// The Stacks signer client used to communicate with the stacks node
 #[derive(Clone, Debug)]
@@ -578,6 +578,7 @@ impl StacksClient {
     }
 
     /// Helper function to create a stacks transaction for a modifying contract call
+    #[allow(clippy::too_many_arguments)]
     pub fn build_signed_contract_call_transaction(
         contract_addr: &StacksAddress,
         contract_name: ContractName,
@@ -649,64 +650,64 @@ mod tests {
     use crate::client::tests::{
         build_account_nonce_response, build_get_aggregate_public_key_response,
         build_get_last_round_response, build_get_peer_info_response, build_get_pox_data_response,
-        write_response, TestConfig,
+        write_response, MockServerClient,
     };
 
     #[test]
     fn read_only_contract_call_200_success() {
-        let config = TestConfig::new();
+        let mock = MockServerClient::new();
         let value = ClarityValue::UInt(10_u128);
         let hex = value
             .serialize_to_hex()
             .expect("Failed to serialize hex value");
         let response_bytes = format!("HTTP/1.1 200 OK\n\n{{\"okay\":true,\"result\":\"{hex}\"}}",);
         let h = spawn(move || {
-            config.client.read_only_contract_call(
-                &config.client.stacks_address,
+            mock.client.read_only_contract_call(
+                &mock.client.stacks_address,
                 &ContractName::from("contract-name"),
                 &ClarityName::from("function-name"),
                 &[],
             )
         });
-        write_response(config.mock_server, response_bytes.as_bytes());
+        write_response(mock.server, response_bytes.as_bytes());
         let result = h.join().unwrap().unwrap();
         assert_eq!(result, value);
     }
 
     #[test]
     fn read_only_contract_call_with_function_args_200_success() {
-        let config = TestConfig::new();
+        let mock = MockServerClient::new();
         let value = ClarityValue::UInt(10_u128);
         let hex = value
             .serialize_to_hex()
             .expect("Failed to serialize hex value");
         let response_bytes = format!("HTTP/1.1 200 OK\n\n{{\"okay\":true,\"result\":\"{hex}\"}}",);
         let h = spawn(move || {
-            config.client.read_only_contract_call(
-                &config.client.stacks_address,
+            mock.client.read_only_contract_call(
+                &mock.client.stacks_address,
                 &ContractName::from("contract-name"),
                 &ClarityName::from("function-name"),
                 &[ClarityValue::UInt(10_u128)],
             )
         });
-        write_response(config.mock_server, response_bytes.as_bytes());
+        write_response(mock.server, response_bytes.as_bytes());
         let result = h.join().unwrap().unwrap();
         assert_eq!(result, value);
     }
 
     #[test]
     fn read_only_contract_call_200_failure() {
-        let config = TestConfig::new();
+        let mock = MockServerClient::new();
         let h = spawn(move || {
-            config.client.read_only_contract_call(
-                &config.client.stacks_address,
+            mock.client.read_only_contract_call(
+                &mock.client.stacks_address,
                 &ContractName::from("contract-name"),
                 &ClarityName::from("function-name"),
                 &[],
             )
         });
         write_response(
-            config.mock_server,
+            mock.server,
             b"HTTP/1.1 200 OK\n\n{\"okay\":false,\"cause\":\"Some reason\"}",
         );
         let result = h.join().unwrap();
@@ -715,17 +716,17 @@ mod tests {
 
     #[test]
     fn read_only_contract_call_400_failure() {
-        let config = TestConfig::new();
+        let mock = MockServerClient::new();
         // Simulate a 400 Bad Request response
         let h = spawn(move || {
-            config.client.read_only_contract_call(
-                &config.client.stacks_address,
+            mock.client.read_only_contract_call(
+                &mock.client.stacks_address,
                 &ContractName::from("contract-name"),
                 &ClarityName::from("function-name"),
                 &[],
             )
         });
-        write_response(config.mock_server, b"HTTP/1.1 400 Bad Request\n\n");
+        write_response(mock.server, b"HTTP/1.1 400 Bad Request\n\n");
         let result = h.join().unwrap();
         assert!(matches!(
             result,
@@ -737,17 +738,17 @@ mod tests {
 
     #[test]
     fn read_only_contract_call_404_failure() {
-        let config = TestConfig::new();
+        let mock = MockServerClient::new();
         // Simulate a 400 Bad Request response
         let h = spawn(move || {
-            config.client.read_only_contract_call(
-                &config.client.stacks_address,
+            mock.client.read_only_contract_call(
+                &mock.client.stacks_address,
                 &ContractName::from("contract-name"),
                 &ClarityName::from("function-name"),
                 &[],
             )
         });
-        write_response(config.mock_server, b"HTTP/1.1 404 Not Found\n\n");
+        write_response(mock.server, b"HTTP/1.1 404 Not Found\n\n");
         let result = h.join().unwrap();
         assert!(matches!(
             result,
@@ -757,23 +758,23 @@ mod tests {
 
     #[test]
     fn valid_reward_cycle_should_succeed() {
-        let config = TestConfig::new();
+        let mock = MockServerClient::new();
         let reward_cycle = thread_rng().next_u64();
         let prepare_phase_start_block_height = thread_rng().next_u64();
         let pox_data_response =
             build_get_pox_data_response(reward_cycle, prepare_phase_start_block_height);
-        let h = spawn(move || config.client.get_current_reward_cycle());
-        write_response(config.mock_server, pox_data_response.as_bytes());
+        let h = spawn(move || mock.client.get_current_reward_cycle());
+        write_response(mock.server, pox_data_response.as_bytes());
         let current_cycle_id = h.join().unwrap().unwrap();
         assert_eq!(reward_cycle, current_cycle_id);
     }
 
     #[test]
     fn invalid_reward_cycle_should_fail() {
-        let config = TestConfig::new();
-        let h = spawn(move || config.client.get_current_reward_cycle());
+        let mock = MockServerClient::new();
+        let h = spawn(move || mock.client.get_current_reward_cycle());
         write_response(
-            config.mock_server,
+            mock.server,
             b"HTTP/1.1 200 Ok\n\n{\"current_cycle\":{\"id\":\"fake id\", \"is_pox_active\":false}}",
         );
         let res = h.join().unwrap();
@@ -782,10 +783,10 @@ mod tests {
 
     #[test]
     fn missing_reward_cycle_should_fail() {
-        let config = TestConfig::new();
-        let h = spawn(move || config.client.get_current_reward_cycle());
+        let mock = MockServerClient::new();
+        let h = spawn(move || mock.client.get_current_reward_cycle());
         write_response(
-            config.mock_server,
+            mock.server,
             b"HTTP/1.1 200 Ok\n\n{\"current_cycle\":{\"is_pox_active\":false}}",
         );
         let res = h.join().unwrap();
@@ -797,9 +798,9 @@ mod tests {
         let orig_point = Point::from(Scalar::random(&mut rand::thread_rng()));
         let response = build_get_aggregate_public_key_response(orig_point);
 
-        let test_config = TestConfig::new();
-        let h = spawn(move || test_config.client.get_aggregate_public_key(0));
-        write_response(test_config.mock_server, response.as_bytes());
+        let mock = MockServerClient::new();
+        let h = spawn(move || mock.client.get_aggregate_public_key(0));
+        write_response(mock.server, response.as_bytes());
         let res = h.join().unwrap().unwrap();
         assert_eq!(res, Some(orig_point));
 
@@ -809,9 +810,9 @@ mod tests {
             .expect("Failed to serialize clarity value");
         let response = format!("HTTP/1.1 200 OK\n\n{{\"okay\":true,\"result\":\"{hex}\"}}");
 
-        let test_config = TestConfig::from_config(test_config.config);
-        let h = spawn(move || test_config.client.get_aggregate_public_key(0));
-        write_response(test_config.mock_server, response.as_bytes());
+        let mock = MockServerClient::from_config(mock.config);
+        let h = spawn(move || mock.client.get_aggregate_public_key(0));
+        write_response(mock.server, response.as_bytes());
 
         let res = h.join().unwrap().unwrap();
         assert!(res.is_none());
@@ -819,39 +820,39 @@ mod tests {
 
     #[test]
     fn parse_valid_aggregate_public_key_should_succeed() {
-        let config = TestConfig::new();
+        let mock = MockServerClient::new();
         let orig_point = Point::from(Scalar::random(&mut rand::thread_rng()));
         let clarity_value = ClarityValue::some(
             ClarityValue::buff_from(orig_point.compress().as_bytes().to_vec())
                 .expect("BUG: Failed to create clarity value from point"),
         )
         .expect("BUG: Failed to create clarity value from point");
-        let result = config
+        let result = mock
             .client
             .parse_aggregate_public_key(clarity_value)
             .unwrap();
         assert_eq!(result, Some(orig_point));
 
         let value = ClarityValue::none();
-        let result = config.client.parse_aggregate_public_key(value).unwrap();
+        let result = mock.client.parse_aggregate_public_key(value).unwrap();
         assert!(result.is_none());
     }
 
     #[test]
     fn parse_invalid_aggregate_public_key_should_fail() {
-        let config = TestConfig::new();
+        let mock = MockServerClient::new();
         let value = ClarityValue::UInt(10_u128);
-        let result = config.client.parse_aggregate_public_key(value);
+        let result = mock.client.parse_aggregate_public_key(value);
         assert!(result.is_err())
     }
 
     #[ignore]
     #[test]
     fn transaction_contract_call_should_send_bytes_to_node() {
-        let config = TestConfig::new();
+        let mock = MockServerClient::new();
         let private_key = StacksPrivateKey::new();
         let tx = StacksClient::build_signed_contract_call_transaction(
-            &config.client.stacks_address,
+            &mock.client.stacks_address,
             ContractName::from("contract-name"),
             ClarityName::from("function-name"),
             &[],
@@ -880,10 +881,10 @@ mod tests {
             + 1;
 
         let tx_clone = tx.clone();
-        let h = spawn(move || config.client.submit_tx(&tx_clone));
+        let h = spawn(move || mock.client.submit_tx(&tx_clone));
 
         let request_bytes = write_response(
-            config.mock_server,
+            mock.server,
             format!("HTTP/1.1 200 OK\n\n{}", tx.txid()).as_bytes(),
         );
         let returned_txid = h.join().unwrap().unwrap();
@@ -901,21 +902,17 @@ mod tests {
     #[test]
     #[serial]
     fn build_vote_for_aggregate_public_key_should_succeed() {
-        let config = TestConfig::new();
+        let mock = MockServerClient::new();
         let point = Point::from(Scalar::random(&mut rand::thread_rng()));
         let round = rand::thread_rng().next_u64();
         let round_response = build_get_last_round_response(round);
         let nonce = thread_rng().next_u64();
         let account_nonce_response = build_account_nonce_response(nonce);
 
-        let h = spawn(move || {
-            config
-                .client
-                .build_vote_for_aggregate_public_key(0, 0, point)
-        });
-        write_response(config.mock_server, round_response.as_bytes());
-        let config = TestConfig::from_config(config.config);
-        write_response(config.mock_server, account_nonce_response.as_bytes());
+        let h = spawn(move || mock.client.build_vote_for_aggregate_public_key(0, 0, point));
+        write_response(mock.server, round_response.as_bytes());
+        let mock = MockServerClient::from_config(mock.config);
+        write_response(mock.server, account_nonce_response.as_bytes());
         assert!(h.join().unwrap().is_ok());
     }
 
@@ -923,24 +920,20 @@ mod tests {
     #[test]
     #[serial]
     fn cast_vote_for_aggregate_public_key_should_succeed() {
-        let config = TestConfig::new();
+        let mock = MockServerClient::new();
         let point = Point::from(Scalar::random(&mut rand::thread_rng()));
         let round = rand::thread_rng().next_u64();
         let round_response = build_get_last_round_response(round);
         let nonce = thread_rng().next_u64();
         let account_nonce_response = build_account_nonce_response(nonce);
 
-        let h = spawn(move || {
-            config
-                .client
-                .cast_vote_for_aggregate_public_key(0, 0, point)
-        });
-        write_response(config.mock_server, round_response.as_bytes());
-        let config = TestConfig::from_config(config.config);
-        write_response(config.mock_server, account_nonce_response.as_bytes());
-        let config = TestConfig::from_config(config.config);
+        let h = spawn(move || mock.client.cast_vote_for_aggregate_public_key(0, 0, point));
+        write_response(mock.server, round_response.as_bytes());
+        let mock = MockServerClient::from_config(mock.config);
+        write_response(mock.server, account_nonce_response.as_bytes());
+        let mock = MockServerClient::from_config(mock.config);
         write_response(
-            config.mock_server,
+            mock.server,
             b"HTTP/1.1 200 OK\n\n4e99f99bc4a05437abb8c7d0c306618f45b203196498e2ebe287f10497124958",
         );
         assert!(h.join().unwrap().is_ok());
@@ -948,10 +941,10 @@ mod tests {
 
     #[test]
     fn core_info_call_for_consensus_hash_should_succeed() {
-        let config = TestConfig::new();
-        let h = spawn(move || config.client.get_stacks_tip_consensus_hash());
+        let mock = MockServerClient::new();
+        let h = spawn(move || mock.client.get_stacks_tip_consensus_hash());
         write_response(
-            config.mock_server,
+            mock.server,
             b"HTTP/1.1 200 OK\n\n{\"stacks_tip_consensus_hash\":\"64c8c3049ff6b939c65828e3168210e6bb32d880\",\"peer_version\":4207599113,\"pox_consensus\":\"64c8c3049ff6b939c65828e3168210e6bb32d880\",\"burn_block_height\":2575799,\"stable_pox_consensus\":\"72277bf9a3b115e13c0942825480d6cee0e9a0e8\",\"stable_burn_block_height\":2575792,\"server_version\":\"stacks-node d657bdd (feat/epoch-2.4:d657bdd, release build, linux [x86_64])\",\"network_id\":2147483648,\"parent_network_id\":118034699,\"stacks_tip_height\":145152,\"stacks_tip\":\"77219884fe434c0fa270d65592b4f082ab3e5d9922ac2bdaac34310aedc3d298\",\"genesis_chainstate_hash\":\"74237aa39aa50a83de11a4f53e9d3bb7d43461d1de9873f402e5453ae60bc59b\",\"unanchored_tip\":\"dde44222b6e6d81583b6b9c55db83e8716943ae9d0dc332fc39448ddd9b99dc2\",\"unanchored_seq\":0,\"exit_at_block_height\":null,\"node_public_key\":\"023c940136d5795d9dd82c0e87f4dd6a2a1db245444e7d70e34bb9605c3c3917b0\",\"node_public_key_hash\":\"e26cce8f6abe06b9fc81c3b11bcc821d2f1b8fd0\"}",
         );
         let consensus_hash = h.join().unwrap().expect("Failed to deserialize response");
@@ -963,10 +956,10 @@ mod tests {
 
     #[test]
     fn core_info_call_with_invalid_response_should_fail() {
-        let config = TestConfig::new();
-        let h = spawn(move || config.client.get_stacks_tip_consensus_hash());
+        let mock = MockServerClient::new();
+        let h = spawn(move || mock.client.get_stacks_tip_consensus_hash());
         write_response(
-            config.mock_server,
+            mock.server,
             b"HTTP/1.1 200 OK\n\n4e99f99bc4a05437abb8c7d0c306618f45b203196498e2ebe287f10497124958",
         );
         assert!(h.join().unwrap().is_err());
@@ -974,10 +967,10 @@ mod tests {
 
     #[test]
     fn core_info_call_for_burn_block_height_should_succeed() {
-        let config = TestConfig::new();
-        let h = spawn(move || config.client.get_burn_block_height());
+        let mock = MockServerClient::new();
+        let h = spawn(move || mock.client.get_burn_block_height());
         write_response(
-            config.mock_server,
+            mock.server,
             b"HTTP/1.1 200 OK\n\n{\"burn_block_height\":2575799,\"peer_version\":4207599113,\"pox_consensus\":\"64c8c3049ff6b939c65828e3168210e6bb32d880\",\"stable_pox_consensus\":\"72277bf9a3b115e13c0942825480d6cee0e9a0e8\",\"stable_burn_block_height\":2575792,\"server_version\":\"stacks-node d657bdd (feat/epoch-2.4:d657bdd, release build, linux [x86_64])\",\"network_id\":2147483648,\"parent_network_id\":118034699,\"stacks_tip_height\":145152,\"stacks_tip\":\"77219884fe434c0fa270d65592b4f082ab3e5d9922ac2bdaac34310aedc3d298\",\"stacks_tip_consensus_hash\":\"64c8c3049ff6b939c65828e3168210e6bb32d880\",\"genesis_chainstate_hash\":\"74237aa39aa50a83de11a4f53e9d3bb7d43461d1de9873f402e5453ae60bc59b\",\"unanchored_tip\":\"dde44222b6e6d81583b6b9c55db83e8716943ae9d0dc332fc39448ddd9b99dc2\",\"unanchored_seq\":0,\"exit_at_block_height\":null,\"node_public_key\":\"023c940136d5795d9dd82c0e87f4dd6a2a1db245444e7d70e34bb9605c3c3917b0\",\"node_public_key_hash\":\"e26cce8f6abe06b9fc81c3b11bcc821d2f1b8fd0\"}",
         );
         let burn_block_height = h.join().unwrap().expect("Failed to deserialize response");
@@ -986,10 +979,10 @@ mod tests {
 
     #[test]
     fn core_info_call_for_burn_block_height_should_fail() {
-        let config = TestConfig::new();
-        let h = spawn(move || config.client.get_burn_block_height());
+        let mock = MockServerClient::new();
+        let h = spawn(move || mock.client.get_burn_block_height());
         write_response(
-            config.mock_server,
+            mock.server,
             b"HTTP/1.1 200 OK\n\n4e99f99bc4a05437abb8c7d0c306618f45b203196498e2ebe287f10497124958",
         );
         assert!(h.join().unwrap().is_err());
@@ -997,25 +990,22 @@ mod tests {
 
     #[test]
     fn get_account_nonce_should_succeed() {
-        let config = TestConfig::new();
-        let address = config.client.stacks_address;
-        let h = spawn(move || config.client.get_account_nonce(&address));
+        let mock = MockServerClient::new();
+        let address = mock.client.stacks_address;
+        let h = spawn(move || mock.client.get_account_nonce(&address));
         let nonce = thread_rng().next_u64();
-        write_response(
-            config.mock_server,
-            build_account_nonce_response(nonce).as_bytes(),
-        );
+        write_response(mock.server, build_account_nonce_response(nonce).as_bytes());
         let returned_nonce = h.join().unwrap().expect("Failed to deserialize response");
         assert_eq!(returned_nonce, nonce);
     }
 
     #[test]
     fn get_account_nonce_should_fail() {
-        let config = TestConfig::new();
-        let address = config.client.stacks_address;
-        let h = spawn(move || config.client.get_account_nonce(&address));
+        let mock = MockServerClient::new();
+        let address = mock.client.stacks_address;
+        let h = spawn(move || mock.client.get_account_nonce(&address));
         write_response(
-            config.mock_server,
+            mock.server,
             b"HTTP/1.1 200 OK\n\n{\"nonce\":\"invalid nonce\",\"balance\":\"0x00000000000000000000000000000000\",\"locked\":\"0x00000000000000000000000000000000\",\"unlock_height\":0}"
         );
         assert!(h.join().unwrap().is_err());
@@ -1023,11 +1013,11 @@ mod tests {
 
     #[test]
     fn parse_valid_signer_slots_should_succeed() {
-        let config = TestConfig::new();
+        let mock = MockServerClient::new();
         let clarity_value_hex =
             "0x070b000000050c00000002096e756d2d736c6f7473010000000000000000000000000000000c067369676e6572051a8195196a9a7cf9c37cb13e1ed69a7bc047a84e050c00000002096e756d2d736c6f7473010000000000000000000000000000000c067369676e6572051a6505471146dcf722f0580911183f28bef30a8a890c00000002096e756d2d736c6f7473010000000000000000000000000000000c067369676e6572051a1d7f8e3936e5da5f32982cc47f31d7df9fb1b38a0c00000002096e756d2d736c6f7473010000000000000000000000000000000c067369676e6572051a126d1a814313c952e34c7840acec9211e1727fb80c00000002096e756d2d736c6f7473010000000000000000000000000000000c067369676e6572051a7374ea6bb39f2e8d3d334d62b9f302a977de339a";
         let value = ClarityValue::try_deserialize_hex_untyped(clarity_value_hex).unwrap();
-        let signer_slots = config.client.parse_signer_slots(value).unwrap();
+        let signer_slots = mock.client.parse_signer_slots(value).unwrap();
         assert_eq!(signer_slots.len(), 5);
         signer_slots
             .into_iter()
@@ -1036,39 +1026,39 @@ mod tests {
 
     #[test]
     fn get_node_epoch_should_succeed() {
-        let config = TestConfig::new();
-        let h = spawn(move || config.client.get_node_epoch());
+        let mock = MockServerClient::new();
+        let h = spawn(move || mock.client.get_node_epoch());
         write_response(
-            config.mock_server,
+            mock.server,
             b"HTTP/1.1 200 OK\n\n{\"burn_block_height\":2575799,\"peer_version\":4207599113,\"pox_consensus\":\"64c8c3049ff6b939c65828e3168210e6bb32d880\",\"stable_pox_consensus\":\"72277bf9a3b115e13c0942825480d6cee0e9a0e8\",\"stable_burn_block_height\":2575792,\"server_version\":\"stacks-node d657bdd (feat/epoch-2.4:d657bdd, release build, linux [x86_64])\",\"network_id\":2147483648,\"parent_network_id\":118034699,\"stacks_tip_height\":145152,\"stacks_tip\":\"77219884fe434c0fa270d65592b4f082ab3e5d9922ac2bdaac34310aedc3d298\",\"stacks_tip_consensus_hash\":\"64c8c3049ff6b939c65828e3168210e6bb32d880\",\"genesis_chainstate_hash\":\"74237aa39aa50a83de11a4f53e9d3bb7d43461d1de9873f402e5453ae60bc59b\",\"unanchored_tip\":\"dde44222b6e6d81583b6b9c55db83e8716943ae9d0dc332fc39448ddd9b99dc2\",\"unanchored_seq\":0,\"exit_at_block_height\":null,\"node_public_key\":\"023c940136d5795d9dd82c0e87f4dd6a2a1db245444e7d70e34bb9605c3c3917b0\",\"node_public_key_hash\":\"e26cce8f6abe06b9fc81c3b11bcc821d2f1b8fd0\"}",
         );
         let epoch = h.join().unwrap().expect("Failed to deserialize response");
         assert_eq!(epoch, EpochId::UnsupportedEpoch);
 
-        let config = TestConfig::new();
-        let h = spawn(move || config.client.get_node_epoch());
+        let mock = MockServerClient::new();
+        let h = spawn(move || mock.client.get_node_epoch());
         let height = BITCOIN_TESTNET_STACKS_25_BURN_HEIGHT;
         let response_bytes = format!("HTTP/1.1 200 OK\n\n{{\"burn_block_height\":{height},\"peer_version\":4207599113,\"pox_consensus\":\"64c8c3049ff6b939c65828e3168210e6bb32d880\",\"stable_pox_consensus\":\"72277bf9a3b115e13c0942825480d6cee0e9a0e8\",\"stable_burn_block_height\":2575792,\"server_version\":\"stacks-node d657bdd (feat/epoch-2.4:d657bdd, release build, linux [x86_64])\",\"network_id\":2147483648,\"parent_network_id\":118034699,\"stacks_tip_height\":145152,\"stacks_tip\":\"77219884fe434c0fa270d65592b4f082ab3e5d9922ac2bdaac34310aedc3d298\",\"stacks_tip_consensus_hash\":\"64c8c3049ff6b939c65828e3168210e6bb32d880\",\"genesis_chainstate_hash\":\"74237aa39aa50a83de11a4f53e9d3bb7d43461d1de9873f402e5453ae60bc59b\",\"unanchored_tip\":\"dde44222b6e6d81583b6b9c55db83e8716943ae9d0dc332fc39448ddd9b99dc2\",\"unanchored_seq\":0,\"exit_at_block_height\":null,\"node_public_key\":\"023c940136d5795d9dd82c0e87f4dd6a2a1db245444e7d70e34bb9605c3c3917b0\",\"node_public_key_hash\":\"e26cce8f6abe06b9fc81c3b11bcc821d2f1b8fd0\"}}");
 
-        write_response(config.mock_server, response_bytes.as_bytes());
+        write_response(mock.server, response_bytes.as_bytes());
         let epoch = h.join().unwrap().expect("Failed to deserialize response");
         assert_eq!(epoch, EpochId::Epoch25);
 
-        let config = TestConfig::new();
-        let h = spawn(move || config.client.get_node_epoch());
+        let mock = MockServerClient::new();
+        let h = spawn(move || mock.client.get_node_epoch());
         let height = BITCOIN_TESTNET_STACKS_30_BURN_HEIGHT;
         let response_bytes = format!("HTTP/1.1 200 OK\n\n{{\"burn_block_height\":{height},\"peer_version\":4207599113,\"pox_consensus\":\"64c8c3049ff6b939c65828e3168210e6bb32d880\",\"stable_pox_consensus\":\"72277bf9a3b115e13c0942825480d6cee0e9a0e8\",\"stable_burn_block_height\":2575792,\"server_version\":\"stacks-node d657bdd (feat/epoch-2.4:d657bdd, release build, linux [x86_64])\",\"network_id\":2147483648,\"parent_network_id\":118034699,\"stacks_tip_height\":145152,\"stacks_tip\":\"77219884fe434c0fa270d65592b4f082ab3e5d9922ac2bdaac34310aedc3d298\",\"stacks_tip_consensus_hash\":\"64c8c3049ff6b939c65828e3168210e6bb32d880\",\"genesis_chainstate_hash\":\"74237aa39aa50a83de11a4f53e9d3bb7d43461d1de9873f402e5453ae60bc59b\",\"unanchored_tip\":\"dde44222b6e6d81583b6b9c55db83e8716943ae9d0dc332fc39448ddd9b99dc2\",\"unanchored_seq\":0,\"exit_at_block_height\":null,\"node_public_key\":\"023c940136d5795d9dd82c0e87f4dd6a2a1db245444e7d70e34bb9605c3c3917b0\",\"node_public_key_hash\":\"e26cce8f6abe06b9fc81c3b11bcc821d2f1b8fd0\"}}");
-        write_response(config.mock_server, response_bytes.as_bytes());
+        write_response(mock.server, response_bytes.as_bytes());
         let epoch = h.join().unwrap().expect("Failed to deserialize response");
         assert_eq!(epoch, EpochId::Epoch30);
     }
 
     #[test]
     fn get_node_epoch_should_fail() {
-        let config = TestConfig::new();
-        let h = spawn(move || config.client.get_node_epoch());
+        let mock = MockServerClient::new();
+        let h = spawn(move || mock.client.get_node_epoch());
         write_response(
-            config.mock_server,
+            mock.server,
             b"HTTP/1.1 200 OK\n\n4e99f99bc4a05437abb8c7d0c306618f45b203196498e2ebe287f10497124958",
         );
         assert!(h.join().unwrap().is_err());
@@ -1076,7 +1066,7 @@ mod tests {
 
     #[test]
     fn submit_block_for_validation_should_succeed() {
-        let config = TestConfig::new();
+        let mock = MockServerClient::new();
         let header = NakamotoBlockHeader {
             version: 1,
             chain_length: 2,
@@ -1093,14 +1083,14 @@ mod tests {
             header,
             txs: vec![],
         };
-        let h = spawn(move || config.client.submit_block_for_validation(block));
-        write_response(config.mock_server, b"HTTP/1.1 200 OK\n\n");
+        let h = spawn(move || mock.client.submit_block_for_validation(block));
+        write_response(mock.server, b"HTTP/1.1 200 OK\n\n");
         assert!(h.join().unwrap().is_ok());
     }
 
     #[test]
     fn submit_block_for_validation_should_fail() {
-        let config = TestConfig::new();
+        let mock = MockServerClient::new();
         let header = NakamotoBlockHeader {
             version: 1,
             chain_length: 2,
@@ -1117,14 +1107,14 @@ mod tests {
             header,
             txs: vec![],
         };
-        let h = spawn(move || config.client.submit_block_for_validation(block));
-        write_response(config.mock_server, b"HTTP/1.1 404 Not Found\n\n");
+        let h = spawn(move || mock.client.submit_block_for_validation(block));
+        write_response(mock.server, b"HTTP/1.1 404 Not Found\n\n");
         assert!(h.join().unwrap().is_err());
     }
 
     #[test]
     fn get_peer_info_should_succeed() {
-        let config = TestConfig::new();
+        let mock = MockServerClient::new();
         let private_key = StacksPrivateKey::new();
         let public_key = StacksPublicKey::from_private(&private_key);
         let public_key_buf = StacksPublicKeyBuffer::from_public_key(&public_key);
@@ -1161,19 +1151,19 @@ mod tests {
         let peer_info_json =
             serde_json::to_string(&peer_info).expect("Failed to serialize peer info");
         let response = format!("HTTP/1.1 200 OK\n\n{peer_info_json}");
-        let h = spawn(move || config.client.get_peer_info());
-        write_response(config.mock_server, response.as_bytes());
+        let h = spawn(move || mock.client.get_peer_info());
+        write_response(mock.server, response.as_bytes());
         assert_eq!(h.join().unwrap().unwrap(), peer_info);
     }
 
     #[test]
     fn get_last_round_should_succeed() {
-        let config = TestConfig::new();
+        let mock = MockServerClient::new();
         let round = rand::thread_rng().next_u64();
         let response = build_get_last_round_response(round);
-        let h = spawn(move || config.client.get_last_round(0));
+        let h = spawn(move || mock.client.get_last_round(0));
 
-        write_response(config.mock_server, response.as_bytes());
+        write_response(mock.server, response.as_bytes());
         assert_eq!(h.join().unwrap().unwrap(), round);
     }
 
@@ -1183,44 +1173,44 @@ mod tests {
         let consensus_hash = "64c8c3049ff6b939c65828e3168210e6bb32d880".to_string();
 
         // Should return TRUE as the passed in reward cycle is older than the current reward cycle of the node
-        let config = TestConfig::new();
+        let mock = MockServerClient::new();
         let pox_response = build_get_pox_data_response(2, 10);
-        let h = spawn(move || config.client.reward_set_calculated(0));
-        write_response(config.mock_server, pox_response.as_bytes());
+        let h = spawn(move || mock.client.reward_set_calculated(0));
+        write_response(mock.server, pox_response.as_bytes());
         assert!(h.join().unwrap().unwrap());
 
         // Should return TRUE as the passed in reward cycle is the same as the current reward cycle
-        let config = TestConfig::from_config(config.config);
+        let mock = MockServerClient::from_config(mock.config);
         let pox_response = build_get_pox_data_response(2, 10);
-        let h = spawn(move || config.client.reward_set_calculated(2));
-        write_response(config.mock_server, pox_response.as_bytes());
+        let h = spawn(move || mock.client.reward_set_calculated(2));
+        write_response(mock.server, pox_response.as_bytes());
         assert!(h.join().unwrap().unwrap());
 
         // Should return TRUE as the passed in reward cycle is the NEXT reward cycle AND the prepare phase is in its SECOND block
-        let config = TestConfig::from_config(config.config);
+        let mock = MockServerClient::from_config(mock.config);
         let pox_response = build_get_pox_data_response(2, 10);
         let peer_response = build_get_peer_info_response(11, consensus_hash.clone());
-        let h = spawn(move || config.client.reward_set_calculated(3));
-        write_response(config.mock_server, pox_response.as_bytes());
-        let config = TestConfig::from_config(config.config);
-        write_response(config.mock_server, peer_response.as_bytes());
+        let h = spawn(move || mock.client.reward_set_calculated(3));
+        write_response(mock.server, pox_response.as_bytes());
+        let mock = MockServerClient::from_config(mock.config);
+        write_response(mock.server, peer_response.as_bytes());
         assert!(h.join().unwrap().unwrap());
 
         // Should return FALSE as the passed in reward cycle is NEWER than the NEXT reward cycle of the node
-        let config = TestConfig::from_config(config.config);
+        let mock = MockServerClient::from_config(mock.config);
         let pox_response = build_get_pox_data_response(2, 10);
-        let h = spawn(move || config.client.reward_set_calculated(4));
-        write_response(config.mock_server, pox_response.as_bytes());
+        let h = spawn(move || mock.client.reward_set_calculated(4));
+        write_response(mock.server, pox_response.as_bytes());
         assert!(!h.join().unwrap().unwrap());
 
         // Should return FALSE as the passed in reward cycle is the NEXT reward cycle BUT the prepare phase is in its FIRST block
-        let config = TestConfig::from_config(config.config);
+        let mock = MockServerClient::from_config(mock.config);
         let pox_response = build_get_pox_data_response(2, 11);
         let peer_response = build_get_peer_info_response(11, consensus_hash);
-        let h = spawn(move || config.client.reward_set_calculated(3));
-        write_response(config.mock_server, pox_response.as_bytes());
-        let config = TestConfig::from_config(config.config);
-        write_response(config.mock_server, peer_response.as_bytes());
+        let h = spawn(move || mock.client.reward_set_calculated(3));
+        write_response(mock.server, pox_response.as_bytes());
+        let mock = MockServerClient::from_config(mock.config);
+        write_response(mock.server, peer_response.as_bytes());
         assert!(!h.join().unwrap().unwrap());
     }
 
@@ -1230,44 +1220,44 @@ mod tests {
         let consensus_hash = "64c8c3049ff6b939c65828e3168210e6bb32d880".to_string();
 
         // Should return FALSE as the passed in reward cycle is old
-        let config = TestConfig::new();
+        let mock = MockServerClient::new();
         let pox_response = build_get_pox_data_response(2, 10);
-        let h = spawn(move || config.client.reward_cycle_in_vote_window(0));
-        write_response(config.mock_server, pox_response.as_bytes());
+        let h = spawn(move || mock.client.reward_cycle_in_vote_window(0));
+        write_response(mock.server, pox_response.as_bytes());
         assert!(!h.join().unwrap().unwrap());
 
         // Should return FALSE as the passed in reward cycle is NEWER than the NEXT reward cycle of the node
-        let config = TestConfig::from_config(config.config);
+        let mock = MockServerClient::new();
         let pox_response = build_get_pox_data_response(2, 10);
-        let h = spawn(move || config.client.reward_cycle_in_vote_window(4));
-        write_response(config.mock_server, pox_response.as_bytes());
+        let h = spawn(move || mock.client.reward_cycle_in_vote_window(4));
+        write_response(mock.server, pox_response.as_bytes());
         assert!(!h.join().unwrap().unwrap());
 
         // Should return FALSE as the passed in reward cycle is the same as the current reward cycle
-        let config = TestConfig::from_config(config.config);
+        let mock = MockServerClient::new();
         let pox_response = build_get_pox_data_response(2, 10);
-        let h = spawn(move || config.client.reward_cycle_in_vote_window(2));
-        write_response(config.mock_server, pox_response.as_bytes());
+        let h = spawn(move || mock.client.reward_cycle_in_vote_window(2));
+        write_response(mock.server, pox_response.as_bytes());
         assert!(!h.join().unwrap().unwrap());
 
         // Should return FALSE as the passed in reward cycle is the NEXT reward cycle BUT the prepare phase is in its FIRST block
-        let config = TestConfig::from_config(config.config);
+        let mock = MockServerClient::new();
         let pox_response = build_get_pox_data_response(2, 11);
         let peer_response = build_get_peer_info_response(11, consensus_hash.clone());
-        let h = spawn(move || config.client.reward_cycle_in_vote_window(3));
-        write_response(config.mock_server, pox_response.as_bytes());
-        let config = TestConfig::from_config(config.config);
-        write_response(config.mock_server, peer_response.as_bytes());
+        let h = spawn(move || mock.client.reward_cycle_in_vote_window(3));
+        write_response(mock.server, pox_response.as_bytes());
+        let mock = MockServerClient::from_config(mock.config);
+        write_response(mock.server, peer_response.as_bytes());
         assert!(!h.join().unwrap().unwrap());
 
         // Should return TRUE as the passed in reward cycle is the NEXT reward cycle AND the prepare phase is in its SECOND block
-        let config = TestConfig::from_config(config.config);
+        let mock = MockServerClient::new();
         let pox_response = build_get_pox_data_response(2, 10);
         let peer_response = build_get_peer_info_response(11, consensus_hash.clone());
-        let h = spawn(move || config.client.reward_cycle_in_vote_window(3));
-        write_response(config.mock_server, pox_response.as_bytes());
-        let config = TestConfig::from_config(config.config);
-        write_response(config.mock_server, peer_response.as_bytes());
+        let h = spawn(move || mock.client.reward_cycle_in_vote_window(3));
+        write_response(mock.server, pox_response.as_bytes());
+        let mock = MockServerClient::from_config(mock.config);
+        write_response(mock.server, peer_response.as_bytes());
         assert!(h.join().unwrap().unwrap());
     }
 }
diff --git a/stacks-signer/src/config.rs b/stacks-signer/src/config.rs
index 91146946ec..211807feee 100644
--- a/stacks-signer/src/config.rs
+++ b/stacks-signer/src/config.rs
@@ -280,13 +280,11 @@ impl TryFrom<&PathBuf> for Config {
 
 impl Config {
     /// load the config from a string and parse it
-    #[allow(dead_code)]
     pub fn load_from_str(data: &str) -> Result<Self, ConfigError> {
         RawConfigFile::load_from_str(data)?.try_into()
     }
 
     /// load the config from a file and parse it
-    #[allow(dead_code)]
     pub fn load_from_file(path: &str) -> Result<Self, ConfigError> {
         Self::try_from(&PathBuf::from(path))
     }
diff --git a/stacks-signer/src/main.rs b/stacks-signer/src/main.rs
index 640dcf2e24..17a88c9831 100644
--- a/stacks-signer/src/main.rs
+++ b/stacks-signer/src/main.rs
@@ -85,7 +85,7 @@ fn write_chunk_to_stdout(chunk_opt: Option<Vec<u8>>) {
 // Spawn a running signer and return its handle, command sender, and result receiver
 fn spawn_running_signer(path: &PathBuf) -> SpawnedSigner {
     let config = Config::try_from(path).unwrap();
-    let endpoint = config.endpoint.clone();
+    let endpoint = config.endpoint;
     let (cmd_send, cmd_recv) = channel();
     let (res_send, res_recv) = channel();
     let ev = SignerEventReceiver::new(config.network.is_mainnet());
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 03d20403f4..e128ffb3e5 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -161,7 +161,7 @@ impl RunLoop {
             let weight_start = weight_end;
             weight_end = weight_start + entry.slots;
             for key_id in weight_start..weight_end {
-                public_keys.key_ids.insert(key_id, ecdsa_public_key.clone());
+                public_keys.key_ids.insert(key_id, ecdsa_public_key);
                 signer_key_ids
                     .entry(signer_id)
                     .or_insert(HashSet::with_capacity(entry.slots as usize))
@@ -375,7 +375,7 @@ mod tests {
 
     use super::*;
     use crate::client::tests::{
-        build_get_peer_info_response, generate_public_keys, write_response, TestConfig,
+        build_get_peer_info_response, generate_stacks_node_info, write_response, MockServerClient,
     };
 
     fn generate_random_consensus_hash() -> String {
@@ -407,15 +407,15 @@ mod tests {
     #[test]
     fn calculate_coordinator_should_produce_unique_results() {
         let number_of_tests = 5;
-        let generated_public_keys = generate_public_keys(10, 4000, None).0;
+        let generated_public_keys = generate_stacks_node_info(10, 4000, None).0.public_keys;
         let mut results = Vec::new();
 
         for _ in 0..number_of_tests {
-            let test_config = TestConfig::new();
-            mock_stacks_client_response(test_config.mock_server, true);
+            let mock = MockServerClient::new();
+            mock_stacks_client_response(mock.server, true);
 
             let (coordinator_id, coordinator_public_key) =
-                calculate_coordinator(&generated_public_keys, &test_config.client);
+                calculate_coordinator(&generated_public_keys, &mock.client);
 
             results.push((coordinator_id, coordinator_public_key));
         }
@@ -435,11 +435,11 @@ mod tests {
     }
     fn generate_test_results(random_consensus: bool, count: usize) -> Vec<(u32, ecdsa::PublicKey)> {
         let mut results = Vec::new();
-        let generated_public_keys = generate_public_keys(10, 4000, None).0;
+        let generated_public_keys = generate_stacks_node_info(10, 4000, None).0.public_keys;
         for _ in 0..count {
-            let test_config = TestConfig::new();
-            mock_stacks_client_response(test_config.mock_server, random_consensus);
-            let result = calculate_coordinator(&generated_public_keys, &test_config.client);
+            let mock = MockServerClient::new();
+            mock_stacks_client_response(mock.server, random_consensus);
+            let result = calculate_coordinator(&generated_public_keys, &mock.client);
             results.push(result);
         }
         results
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index 7d62c16f29..5874c95e55 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -430,7 +430,7 @@ impl Signer {
             self.signer_id, coordinator_id, &coordinator_public_key
         );
         let packets: Vec<Packet> = messages
-            .into_iter()
+            .iter()
             .filter_map(|msg| match msg {
                 SignerMessage::BlockResponse(_) | SignerMessage::Transactions(_) => None,
                 SignerMessage::Packet(packet) => {
@@ -805,7 +805,7 @@ impl Signer {
                                     .cast_vote_for_aggregate_public_key(
                                         self.reward_cycle,
                                         self.stackerdb.get_signer_slot_id(),
-                                        point.clone(),
+                                        *point,
                                     )
                                     .map_err(backoff::Error::transient)
                             }) {
@@ -829,7 +829,7 @@ impl Signer {
                                     .build_vote_for_aggregate_public_key(
                                         self.reward_cycle,
                                         self.stackerdb.get_signer_slot_id(),
-                                        point.clone(),
+                                        *point,
                                     )
                                     .map_err(backoff::Error::transient)
                             }) {
@@ -843,7 +843,7 @@ impl Signer {
                     };
                     let old_transactions = self
                         .stackerdb
-                        .get_signer_transactions_with_retry(&vec![self.signer_id])
+                        .get_signer_transactions_with_retry(&[self.signer_id])
                         .map_err(|e| {
                             error!("Failed to get old transactions from stackerdb: {:?}", e);
                         })
@@ -1164,36 +1164,26 @@ mod tests {
     use stacks_common::util::secp256k1::MessageSignature;
     use wsts::curve::ecdsa;
 
-    use crate::client::tests::{generate_public_keys, write_response, TestConfig};
+    use crate::client::tests::{
+        generate_stacks_node_info, mock_server_from_config, write_response,
+    };
     use crate::client::{StacksClient, VOTE_FUNCTION_NAME};
     use crate::config::Config;
-    use crate::signer::{BlockInfo, Signer, StacksNodeInfo};
+    use crate::signer::{BlockInfo, Signer};
 
     #[test]
     #[serial]
     fn get_expected_transactions_should_filter_invalid_transactions() {
         // Create a runloop of a valid signer
         let config = Config::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
-        let (public_keys, signer_key_ids, stacks_addresses, signer_public_keys) =
-            generate_public_keys(
-                5,
-                20,
-                Some(
-                    ecdsa::PublicKey::new(&config.ecdsa_private_key)
-                        .expect("Failed to create public key."),
-                ),
-            );
-        let signer_addresses = stacks_addresses.into_iter().collect();
-        let stacks_node_info = StacksNodeInfo {
-            signer_id: 0,
-            reward_cycle: 2,
-            signer_set: 0,
-            signer_slot_id: 0,
-            signer_addresses,
-            public_keys,
-            signer_key_ids,
-            signer_public_keys,
-        };
+        let (stacks_node_info, _ordered_addresses) = generate_stacks_node_info(
+            5,
+            20,
+            Some(
+                ecdsa::PublicKey::new(&config.ecdsa_private_key)
+                    .expect("Failed to create public key."),
+            ),
+        );
         let mut signer = Signer::new(&config, stacks_node_info);
 
         let signer_private_key = config.stacks_private_key;
@@ -1296,41 +1286,41 @@ mod tests {
         let message = signer_message.serialize_to_vec();
         let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
         response_bytes.extend(message);
-        let test_config = TestConfig::from_config(config.clone());
-        write_response(test_config.mock_server, response_bytes.as_slice());
+        let mock_server = mock_server_from_config(&config);
+        write_response(mock_server, response_bytes.as_slice());
 
         let signer_message = SignerMessage::Transactions(vec![]);
         let message = signer_message.serialize_to_vec();
         let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
         response_bytes.extend(message);
-        let test_config = TestConfig::from_config(config.clone());
-        write_response(test_config.mock_server, response_bytes.as_slice());
+        let mock_server = mock_server_from_config(&config);
+        write_response(mock_server, response_bytes.as_slice());
 
         let signer_message = SignerMessage::Transactions(vec![]);
         let message = signer_message.serialize_to_vec();
         let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
         response_bytes.extend(message);
-        let test_config = TestConfig::from_config(config.clone());
-        write_response(test_config.mock_server, response_bytes.as_slice());
+        let mock_server = mock_server_from_config(&config);
+        write_response(mock_server, response_bytes.as_slice());
 
         let signer_message = SignerMessage::Transactions(vec![]);
         let message = signer_message.serialize_to_vec();
         let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
         response_bytes.extend(message);
-        let test_config = TestConfig::from_config(config.clone());
-        write_response(test_config.mock_server, response_bytes.as_slice());
+        let mock_server = mock_server_from_config(&config);
+        write_response(mock_server, response_bytes.as_slice());
 
         let signer_message = SignerMessage::Transactions(vec![]);
         let message = signer_message.serialize_to_vec();
         let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
         response_bytes.extend(message);
-        let test_config = TestConfig::from_config(config.clone());
-        write_response(test_config.mock_server, response_bytes.as_slice());
+        let mock_server = mock_server_from_config(&config);
+        write_response(mock_server, response_bytes.as_slice());
 
         for _ in 0..num_transactions {
             let nonce_response = b"HTTP/1.1 200 OK\n\n{\"nonce\":1,\"balance\":\"0x00000000000000000000000000000000\",\"locked\":\"0x00000000000000000000000000000000\",\"unlock_height\":0}";
-            let test_config = TestConfig::from_config(config.clone());
-            write_response(test_config.mock_server, nonce_response);
+            let mock_server = mock_server_from_config(&config);
+            write_response(mock_server, nonce_response);
         }
 
         let filtered_txs = h.join().unwrap();
@@ -1341,26 +1331,14 @@ mod tests {
     #[serial]
     fn verify_transactions_valid() {
         let config = Config::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
-        let (public_keys, signer_key_ids, stacks_addresses, signer_public_keys) =
-            generate_public_keys(
-                5,
-                20,
-                Some(
-                    ecdsa::PublicKey::new(&config.ecdsa_private_key)
-                        .expect("Failed to create public key."),
-                ),
-            );
-        let signer_addresses = stacks_addresses.into_iter().collect();
-        let stacks_node_info = StacksNodeInfo {
-            signer_id: 0,
-            reward_cycle: 2,
-            signer_set: 0,
-            signer_slot_id: 0,
-            signer_addresses,
-            public_keys,
-            signer_key_ids,
-            signer_public_keys,
-        };
+        let (stacks_node_info, _ordered_addresses) = generate_stacks_node_info(
+            5,
+            20,
+            Some(
+                ecdsa::PublicKey::new(&config.ecdsa_private_key)
+                    .expect("Failed to create public key."),
+            ),
+        );
         let mut signer = Signer::new(&config, stacks_node_info);
 
         let signer_private_key = config.stacks_private_key;
@@ -1422,40 +1400,40 @@ mod tests {
         let message = signer_message.serialize_to_vec();
         let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
         response_bytes.extend(message);
-        let test_config = TestConfig::from_config(config.clone());
-        write_response(test_config.mock_server, response_bytes.as_slice());
+        let mock_server = mock_server_from_config(&config);
+        write_response(mock_server, response_bytes.as_slice());
 
         let signer_message = SignerMessage::Transactions(vec![]);
         let message = signer_message.serialize_to_vec();
         let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
         response_bytes.extend(message);
-        let test_config = TestConfig::from_config(config.clone());
-        write_response(test_config.mock_server, response_bytes.as_slice());
+        let mock_server = mock_server_from_config(&config);
+        write_response(mock_server, response_bytes.as_slice());
 
         let signer_message = SignerMessage::Transactions(vec![]);
         let message = signer_message.serialize_to_vec();
         let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
         response_bytes.extend(message);
-        let test_config = TestConfig::from_config(config.clone());
-        write_response(test_config.mock_server, response_bytes.as_slice());
+        let mock_server = mock_server_from_config(&config);
+        write_response(mock_server, response_bytes.as_slice());
 
         let signer_message = SignerMessage::Transactions(vec![]);
         let message = signer_message.serialize_to_vec();
         let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
         response_bytes.extend(message);
-        let test_config = TestConfig::from_config(config.clone());
-        write_response(test_config.mock_server, response_bytes.as_slice());
+        let mock_server = mock_server_from_config(&config);
+        write_response(mock_server, response_bytes.as_slice());
 
         let signer_message = SignerMessage::Transactions(vec![]);
         let message = signer_message.serialize_to_vec();
         let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
         response_bytes.extend(message);
-        let test_config = TestConfig::from_config(config.clone());
-        write_response(test_config.mock_server, response_bytes.as_slice());
+        let mock_server = mock_server_from_config(&config);
+        write_response(mock_server, response_bytes.as_slice());
 
         let nonce_response = b"HTTP/1.1 200 OK\n\n{\"nonce\":1,\"balance\":\"0x00000000000000000000000000000000\",\"locked\":\"0x00000000000000000000000000000000\",\"unlock_height\":0}";
-        let test_config = TestConfig::from_config(config.clone());
-        write_response(test_config.mock_server, nonce_response);
+        let mock_server = mock_server_from_config(&config);
+        write_response(mock_server, nonce_response);
 
         let valid = h.join().unwrap();
         assert!(valid);

From 48d503fe55ebb58c708563b076c1f8e890fecfcb Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 7 Feb 2024 13:29:58 -0800
Subject: [PATCH 0855/1166] CRC: cleanup tests

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/mod.rs           | 20 +++++++++++---------
 stacks-signer/src/client/stackerdb.rs     |  1 -
 stacks-signer/src/client/stacks_client.rs | 21 ++++++---------------
 3 files changed, 17 insertions(+), 25 deletions(-)

diff --git a/stacks-signer/src/client/mod.rs b/stacks-signer/src/client/mod.rs
index 1e84e1af7f..10790f4378 100644
--- a/stacks-signer/src/client/mod.rs
+++ b/stacks-signer/src/client/mod.rs
@@ -205,12 +205,9 @@ pub(crate) mod tests {
 
     /// Build a response for the get_last_round request
     pub fn build_get_last_round_response(round: u64) -> String {
-        let response = ClarityValue::okay(ClarityValue::UInt(round as u128))
+        let value = ClarityValue::okay(ClarityValue::UInt(round as u128))
             .expect("Failed to create response");
-        let hex = response
-            .serialize_to_hex()
-            .expect("Failed to serialize hex value");
-        format!("HTTP/1.1 200 OK\n\n{{\"okay\":true,\"result\":\"{hex}\"}}",)
+        build_read_only_response(&value)
     }
 
     /// Build a response for the get_account_nonce request
@@ -233,10 +230,7 @@ pub(crate) mod tests {
                 .expect("BUG: Failed to create clarity value from point"),
         )
         .expect("BUG: Failed to create clarity value from point");
-        let hex = clarity_value
-            .serialize_to_hex()
-            .expect("Failed to serialize clarity value");
-        format!("HTTP/1.1 200 OK\n\n{{\"okay\":true,\"result\":\"{hex}\"}}")
+        build_read_only_response(&clarity_value)
     }
 
     /// Build a response for the get_peer_info request with a specific stacks tip height and consensus hash
@@ -246,6 +240,14 @@ pub(crate) mod tests {
         )
     }
 
+    /// Build a response to a read only clarity contract call
+    pub fn build_read_only_response(value: &ClarityValue) -> String {
+        let hex = value
+            .serialize_to_hex()
+            .expect("Failed to serialize hex value");
+        format!("HTTP/1.1 200 OK\n\n{{\"okay\":true,\"result\":\"{hex}\"}}")
+    }
+
     /// Generate a random stacks node info
     /// Optionally include a signer pubilc key to set as the first signer id with signer id 0 and signer slot id 0
     pub fn generate_stacks_node_info(
diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index c17296bcf9..06267730cb 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -364,7 +364,6 @@ mod tests {
         let payload = serde_json::to_string(&ack).expect("Failed to serialize ack");
         response_bytes.extend(payload.as_bytes());
         let h = spawn(move || stackerdb.send_message_with_retry(signer_message));
-        std::thread::sleep(std::time::Duration::from_millis(100));
         let mock_server = mock_server_from_config(&config);
         write_response(mock_server, response_bytes.as_slice());
         assert_eq!(ack, h.join().unwrap().unwrap());
diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index 6192b68503..1c0ffdaecb 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -650,17 +650,14 @@ mod tests {
     use crate::client::tests::{
         build_account_nonce_response, build_get_aggregate_public_key_response,
         build_get_last_round_response, build_get_peer_info_response, build_get_pox_data_response,
-        write_response, MockServerClient,
+        build_read_only_response, write_response, MockServerClient,
     };
 
     #[test]
     fn read_only_contract_call_200_success() {
         let mock = MockServerClient::new();
         let value = ClarityValue::UInt(10_u128);
-        let hex = value
-            .serialize_to_hex()
-            .expect("Failed to serialize hex value");
-        let response_bytes = format!("HTTP/1.1 200 OK\n\n{{\"okay\":true,\"result\":\"{hex}\"}}",);
+        let response = build_read_only_response(&value);
         let h = spawn(move || {
             mock.client.read_only_contract_call(
                 &mock.client.stacks_address,
@@ -669,7 +666,7 @@ mod tests {
                 &[],
             )
         });
-        write_response(mock.server, response_bytes.as_bytes());
+        write_response(mock.server, response.as_bytes());
         let result = h.join().unwrap().unwrap();
         assert_eq!(result, value);
     }
@@ -678,10 +675,7 @@ mod tests {
     fn read_only_contract_call_with_function_args_200_success() {
         let mock = MockServerClient::new();
         let value = ClarityValue::UInt(10_u128);
-        let hex = value
-            .serialize_to_hex()
-            .expect("Failed to serialize hex value");
-        let response_bytes = format!("HTTP/1.1 200 OK\n\n{{\"okay\":true,\"result\":\"{hex}\"}}",);
+        let response = build_read_only_response(&value);
         let h = spawn(move || {
             mock.client.read_only_contract_call(
                 &mock.client.stacks_address,
@@ -690,7 +684,7 @@ mod tests {
                 &[ClarityValue::UInt(10_u128)],
             )
         });
-        write_response(mock.server, response_bytes.as_bytes());
+        write_response(mock.server, response.as_bytes());
         let result = h.join().unwrap().unwrap();
         assert_eq!(result, value);
     }
@@ -805,10 +799,7 @@ mod tests {
         assert_eq!(res, Some(orig_point));
 
         let clarity_value = ClarityValue::none();
-        let hex = clarity_value
-            .serialize_to_hex()
-            .expect("Failed to serialize clarity value");
-        let response = format!("HTTP/1.1 200 OK\n\n{{\"okay\":true,\"result\":\"{hex}\"}}");
+        let response = build_read_only_response(&clarity_value);
 
         let mock = MockServerClient::from_config(mock.config);
         let h = spawn(move || mock.client.get_aggregate_public_key(0));

From 84d51795cc025c2a61a86aa544ece0698d898a84 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 7 Feb 2024 13:35:45 -0800
Subject: [PATCH 0856/1166] CRC: cleanup comments and var names

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/runloop.rs | 4 ++--
 stacks-signer/src/signer.rs  | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index e128ffb3e5..5ed6ceb640 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -204,10 +204,10 @@ impl RunLoop {
         };
         if needs_refresh {
             let new_config = self.get_stacks_node_info(reward_cycle)?;
-            if let Some(new_config) = new_config {
+            if let Some(new_node_info) = new_config {
                 debug!("Signer is registered for reward cycle {reward_cycle}. Initializing signer state.");
                 self.stacks_signers
-                    .insert(reward_index, Signer::new(&self.config, new_config));
+                    .insert(reward_index, Signer::new(&self.config, new_node_info));
             } else {
                 // Nothing to initialize. Signer is not registered for this reward cycle
                 debug!("Signer is not registered for reward cycle {reward_cycle}. Nothing to initialize.");
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index 5874c95e55..e6f6df204f 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -857,7 +857,7 @@ impl Signer {
                             return None;
                         };
                         if origin_nonce < account_nonce {
-                            debug!("Signer #{}: Transaction {} has an invalid nonce. Removing if removing it from our stored transactions.", self.signer_id, transaction.txid());
+                            debug!("Signer #{}: Transaction {} has an outdated nonce. Removing it from our stored transactions.", self.signer_id, transaction.txid());
                             return None;
                         }
                         Some(transaction)

From e15335d577b8b65d8c7046331197517f871fc2d4 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 7 Feb 2024 14:20:56 -0800
Subject: [PATCH 0857/1166] Do not process commands if you are not the
 coordinator

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/stackerdb.rs     |   2 +
 stacks-signer/src/client/stacks_client.rs | 153 ++++++++++++++++++++-
 stacks-signer/src/runloop.rs              | 156 ----------------------
 stacks-signer/src/signer.rs               |  29 ++--
 testnet/stacks-node/src/tests/signer.rs   |  72 ++++------
 5 files changed, 196 insertions(+), 216 deletions(-)

diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index 06267730cb..fce49d0b5e 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -258,6 +258,7 @@ impl StackerDB {
 #[cfg(test)]
 mod tests {
     use std::thread::spawn;
+    use std::time::Duration;
 
     use blockstack_lib::chainstate::stacks::{
         TransactionAnchorMode, TransactionAuth, TransactionPayload, TransactionPostConditionMode,
@@ -364,6 +365,7 @@ mod tests {
         let payload = serde_json::to_string(&ack).expect("Failed to serialize ack");
         response_bytes.extend(payload.as_bytes());
         let h = spawn(move || stackerdb.send_message_with_retry(signer_message));
+        std::thread::sleep(Duration::from_millis(100));
         let mock_server = mock_server_from_config(&config);
         write_response(mock_server, response_bytes.as_slice());
         assert_eq!(ack, h.join().unwrap().unwrap());
diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index 1c0ffdaecb..c27c5fe78c 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -41,7 +41,10 @@ use stacks_common::debug;
 use stacks_common::types::chainstate::{
     ConsensusHash, StacksAddress, StacksPrivateKey, StacksPublicKey,
 };
+use stacks_common::util::hash::Sha256Sum;
+use wsts::curve::ecdsa;
 use wsts::curve::point::{Compressed, Point};
+use wsts::state_machine::PublicKeys;
 
 use crate::client::{retry_with_exponential_backoff, ClientError};
 use crate::config::Config;
@@ -99,6 +102,55 @@ impl StacksClient {
         &self.stacks_address
     }
 
+    /// Calculate the coordinator address by comparing the provided public keys against the stacks tip consensus hash
+    pub fn calculate_coordinator(&self, public_keys: &PublicKeys) -> (u32, ecdsa::PublicKey) {
+        let stacks_tip_consensus_hash =
+            match retry_with_exponential_backoff(|| {
+                self.get_stacks_tip_consensus_hash()
+                    .map_err(backoff::Error::transient)
+            }) {
+                Ok(hash) => hash,
+                Err(e) => {
+                    debug!("Failed to get stacks tip consensus hash: {:?}", e);
+                    return (
+                        0,
+                        public_keys.signers.get(&0).cloned().expect(
+                            "FATAL: No public keys found. Signer was not properly registered",
+                        ),
+                    );
+                }
+            };
+        debug!(
+            "Using stacks_tip_consensus_hash {:?} for selecting coordinator",
+            &stacks_tip_consensus_hash
+        );
+
+        // Create combined hash of each signer's public key with stacks_tip_consensus_hash
+        let mut selection_ids = public_keys
+            .signers
+            .iter()
+            .map(|(&id, pk)| {
+                let pk_bytes = pk.to_bytes();
+                let mut buffer =
+                    Vec::with_capacity(pk_bytes.len() + stacks_tip_consensus_hash.as_bytes().len());
+                buffer.extend_from_slice(&pk_bytes[..]);
+                buffer.extend_from_slice(stacks_tip_consensus_hash.as_bytes());
+                let digest = Sha256Sum::from_data(&buffer).as_bytes().to_vec();
+                (digest, id)
+            })
+            .collect::<Vec<_>>();
+
+        // Sort the selection IDs based on the hash
+        selection_ids.sort_by_key(|(hash, _)| hash.clone());
+
+        // Get the first ID from the sorted list and retrieve its public key,
+        // or default to the first signer if none are found
+        selection_ids
+            .first()
+            .and_then(|(_, id)| public_keys.signers.get(id).map(|pk| (*id, *pk)))
+            .expect("FATAL: No public keys found. Signer was not properly registered")
+    }
+
     /// Retrieve the signer slots stored within the stackerdb contract
     pub fn get_stackerdb_signer_slots(
         &self,
@@ -630,12 +682,14 @@ impl StacksClient {
 
 #[cfg(test)]
 mod tests {
+    use std::fmt::Write as FmtWrite;
     use std::io::{BufWriter, Write};
     use std::thread::spawn;
 
     use blockstack_lib::chainstate::nakamoto::NakamotoBlockHeader;
     use blockstack_lib::chainstate::stacks::ThresholdSignature;
-    use rand::thread_rng;
+    use rand::distributions::Standard;
+    use rand::{thread_rng, Rng};
     use rand_core::RngCore;
     use serial_test::serial;
     use stacks_common::bitvec::BitVec;
@@ -650,7 +704,7 @@ mod tests {
     use crate::client::tests::{
         build_account_nonce_response, build_get_aggregate_public_key_response,
         build_get_last_round_response, build_get_peer_info_response, build_get_pox_data_response,
-        build_read_only_response, write_response, MockServerClient,
+        build_read_only_response, generate_stacks_node_info, write_response, MockServerClient,
     };
 
     #[test]
@@ -1251,4 +1305,99 @@ mod tests {
         write_response(mock.server, peer_response.as_bytes());
         assert!(h.join().unwrap().unwrap());
     }
+
+    fn generate_random_consensus_hash() -> String {
+        let rng = rand::thread_rng();
+        let bytes: Vec<u8> = rng.sample_iter(Standard).take(20).collect();
+        let hex_string = bytes.iter().fold(String::new(), |mut acc, &b| {
+            write!(&mut acc, "{:02x}", b).expect("Error writing to string");
+            acc
+        });
+        hex_string
+    }
+
+    fn build_get_stacks_tip_consensus_hash(random_consensus: bool) -> String {
+        let consensus_hash = match random_consensus {
+            true => generate_random_consensus_hash(),
+            false => "64c8c3049ff6b939c65828e3168210e6bb32d880".to_string(),
+        };
+
+        println!("{}", consensus_hash);
+        let stacks_tip_height = thread_rng().next_u64();
+        build_get_peer_info_response(stacks_tip_height, consensus_hash)
+    }
+
+    #[test]
+    fn calculate_coordinator_should_produce_unique_results() {
+        let number_of_tests = 5;
+        let generated_public_keys = generate_stacks_node_info(10, 4000, None).0.public_keys;
+        let mut results = Vec::new();
+
+        for _ in 0..number_of_tests {
+            let mock = MockServerClient::new();
+            let response = build_get_stacks_tip_consensus_hash(true);
+            let generated_public_keys = generated_public_keys.clone();
+            let h = spawn(move || mock.client.calculate_coordinator(&generated_public_keys));
+            write_response(mock.server, response.as_bytes());
+            let result = h.join().unwrap();
+            results.push(result);
+        }
+
+        // Check that not all coordinator IDs are the same
+        let all_ids_same = results.iter().all(|&(id, _)| id == results[0].0);
+        assert!(!all_ids_same, "Not all coordinator IDs should be the same");
+
+        // Check that not all coordinator public keys are the same
+        let all_keys_same = results
+            .iter()
+            .all(|&(_, key)| key.key.data == results[0].1.key.data);
+        assert!(
+            !all_keys_same,
+            "Not all coordinator public keys should be the same"
+        );
+    }
+
+    fn generate_test_results(random_consensus: bool, count: usize) -> Vec<(u32, ecdsa::PublicKey)> {
+        let mut results = Vec::new();
+        let generated_public_keys = generate_stacks_node_info(10, 4000, None).0.public_keys;
+        for _ in 0..count {
+            let mock = MockServerClient::new();
+            let generated_public_keys = generated_public_keys.clone();
+            let response = build_get_stacks_tip_consensus_hash(random_consensus);
+            let h = spawn(move || mock.client.calculate_coordinator(&generated_public_keys));
+            write_response(mock.server, response.as_bytes());
+            let result = h.join().unwrap();
+            results.push(result);
+        }
+        results
+    }
+
+    #[test]
+    fn calculate_coordinator_results_should_vary_or_match_based_on_hash() {
+        let results_with_random_hash = generate_test_results(true, 5);
+        let all_ids_same = results_with_random_hash
+            .iter()
+            .all(|&(id, _)| id == results_with_random_hash[0].0);
+        let all_keys_same = results_with_random_hash
+            .iter()
+            .all(|&(_, key)| key.key.data == results_with_random_hash[0].1.key.data);
+        assert!(!all_ids_same, "Not all coordinator IDs should be the same");
+        assert!(
+            !all_keys_same,
+            "Not all coordinator public keys should be the same"
+        );
+
+        let results_with_static_hash = generate_test_results(false, 5);
+        let all_ids_same = results_with_static_hash
+            .iter()
+            .all(|&(id, _)| id == results_with_static_hash[0].0);
+        let all_keys_same = results_with_static_hash
+            .iter()
+            .all(|&(_, key)| key.key.data == results_with_static_hash[0].1.key.data);
+        assert!(all_ids_same, "All coordinator IDs should be the same");
+        assert!(
+            all_keys_same,
+            "All coordinator public keys should be the same"
+        );
+    }
 }
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 5ed6ceb640..8fbb8296fc 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -22,7 +22,6 @@ use hashbrown::{HashMap, HashSet};
 use libsigner::{SignerEvent, SignerRunLoop};
 use slog::{slog_debug, slog_error, slog_info, slog_warn};
 use stacks_common::types::chainstate::{StacksAddress, StacksPublicKey};
-use stacks_common::util::hash::Sha256Sum;
 use stacks_common::{debug, error, info, warn};
 use wsts::curve::ecdsa;
 use wsts::curve::point::{Compressed, Point};
@@ -319,158 +318,3 @@ impl SignerRunLoop<Vec<OperationResult>, RunLoopCommand> for RunLoop {
         None
     }
 }
-
-/// Helper function for determining the coordinator public key given the the public keys
-pub fn calculate_coordinator(
-    public_keys: &PublicKeys,
-    stacks_client: &StacksClient,
-) -> (u32, ecdsa::PublicKey) {
-    let stacks_tip_consensus_hash = match stacks_client.get_stacks_tip_consensus_hash() {
-        Ok(hash) => hash,
-        Err(e) => {
-            error!("Error in fetching consensus hash: {:?}", e);
-            return (0, public_keys.signers.get(&0).cloned().unwrap());
-        }
-    };
-    debug!(
-        "Using stacks_tip_consensus_hash {:?} for selecting coordinator",
-        &stacks_tip_consensus_hash
-    );
-
-    // Create combined hash of each signer's public key with stacks_tip_consensus_hash
-    let mut selection_ids = public_keys
-        .signers
-        .iter()
-        .map(|(&id, pk)| {
-            let pk_bytes = pk.to_bytes();
-            let mut buffer =
-                Vec::with_capacity(pk_bytes.len() + stacks_tip_consensus_hash.as_bytes().len());
-            buffer.extend_from_slice(&pk_bytes[..]);
-            buffer.extend_from_slice(stacks_tip_consensus_hash.as_bytes());
-            let digest = Sha256Sum::from_data(&buffer).as_bytes().to_vec();
-            (digest, id)
-        })
-        .collect::<Vec<_>>();
-
-    // Sort the selection IDs based on the hash
-    selection_ids.sort_by_key(|(hash, _)| hash.clone());
-
-    // Get the first ID from the sorted list and retrieve its public key,
-    // or default to the first signer if none are found
-    selection_ids
-        .first()
-        .and_then(|(_, id)| public_keys.signers.get(id).map(|pk| (*id, *pk)))
-        .unwrap_or((0, public_keys.signers.get(&0).cloned().unwrap()))
-}
-
-#[cfg(test)]
-mod tests {
-    use std::fmt::Write;
-    use std::net::TcpListener;
-    use std::thread::{sleep, spawn};
-
-    use rand::distributions::Standard;
-    use rand::{thread_rng, Rng};
-    use rand_core::RngCore;
-
-    use super::*;
-    use crate::client::tests::{
-        build_get_peer_info_response, generate_stacks_node_info, write_response, MockServerClient,
-    };
-
-    fn generate_random_consensus_hash() -> String {
-        let rng = rand::thread_rng();
-        let bytes: Vec<u8> = rng.sample_iter(Standard).take(20).collect();
-        let hex_string = bytes.iter().fold(String::new(), |mut acc, &b| {
-            write!(&mut acc, "{:02x}", b).expect("Error writing to string");
-            acc
-        });
-        hex_string
-    }
-
-    fn mock_stacks_client_response(mock_server: TcpListener, random_consensus: bool) {
-        let consensus_hash = match random_consensus {
-            true => generate_random_consensus_hash(),
-            false => "64c8c3049ff6b939c65828e3168210e6bb32d880".to_string(),
-        };
-
-        println!("{}", consensus_hash);
-        let stacks_tip_height = thread_rng().next_u64();
-        let response = build_get_peer_info_response(stacks_tip_height, consensus_hash);
-
-        spawn(move || {
-            write_response(mock_server, response.as_bytes());
-        });
-        sleep(Duration::from_millis(100));
-    }
-
-    #[test]
-    fn calculate_coordinator_should_produce_unique_results() {
-        let number_of_tests = 5;
-        let generated_public_keys = generate_stacks_node_info(10, 4000, None).0.public_keys;
-        let mut results = Vec::new();
-
-        for _ in 0..number_of_tests {
-            let mock = MockServerClient::new();
-            mock_stacks_client_response(mock.server, true);
-
-            let (coordinator_id, coordinator_public_key) =
-                calculate_coordinator(&generated_public_keys, &mock.client);
-
-            results.push((coordinator_id, coordinator_public_key));
-        }
-
-        // Check that not all coordinator IDs are the same
-        let all_ids_same = results.iter().all(|&(id, _)| id == results[0].0);
-        assert!(!all_ids_same, "Not all coordinator IDs should be the same");
-
-        // Check that not all coordinator public keys are the same
-        let all_keys_same = results
-            .iter()
-            .all(|&(_, key)| key.key.data == results[0].1.key.data);
-        assert!(
-            !all_keys_same,
-            "Not all coordinator public keys should be the same"
-        );
-    }
-    fn generate_test_results(random_consensus: bool, count: usize) -> Vec<(u32, ecdsa::PublicKey)> {
-        let mut results = Vec::new();
-        let generated_public_keys = generate_stacks_node_info(10, 4000, None).0.public_keys;
-        for _ in 0..count {
-            let mock = MockServerClient::new();
-            mock_stacks_client_response(mock.server, random_consensus);
-            let result = calculate_coordinator(&generated_public_keys, &mock.client);
-            results.push(result);
-        }
-        results
-    }
-
-    #[test]
-    fn calculate_coordinator_results_should_vary_or_match_based_on_hash() {
-        let results_with_random_hash = generate_test_results(true, 5);
-        let all_ids_same = results_with_random_hash
-            .iter()
-            .all(|&(id, _)| id == results_with_random_hash[0].0);
-        let all_keys_same = results_with_random_hash
-            .iter()
-            .all(|&(_, key)| key.key.data == results_with_random_hash[0].1.key.data);
-        assert!(!all_ids_same, "Not all coordinator IDs should be the same");
-        assert!(
-            !all_keys_same,
-            "Not all coordinator public keys should be the same"
-        );
-
-        let results_with_static_hash = generate_test_results(false, 5);
-        let all_ids_same = results_with_static_hash
-            .iter()
-            .all(|&(id, _)| id == results_with_static_hash[0].0);
-        let all_keys_same = results_with_static_hash
-            .iter()
-            .all(|&(_, key)| key.key.data == results_with_static_hash[0].1.key.data);
-        assert!(all_ids_same, "All coordinator IDs should be the same");
-        assert!(
-            all_keys_same,
-            "All coordinator public keys should be the same"
-        );
-    }
-}
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index e6f6df204f..cf3aad17e0 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -45,7 +45,6 @@ use crate::client::{
     VOTE_FUNCTION_NAME,
 };
 use crate::config::Config;
-use crate::runloop::calculate_coordinator;
 
 /// The info needed from the stacks node to configure a signer
 #[derive(Debug, Clone)]
@@ -222,11 +221,19 @@ impl Signer {
         }
     }
 
-    /// Execute the given command and update state accordingly
-    /// Returns true when it is successfully executed, else false
     /// Execute the given command and update state accordingly
     /// Returns true when it is successfully executed, else false
     fn execute_command(&mut self, command: &Command) -> bool {
+        let (coordinator_id, _) = self
+            .stacks_client
+            .calculate_coordinator(&self.signing_round.public_keys);
+        if coordinator_id != self.signer_id {
+            warn!(
+                "Signer #{}: Not the coordinator. Ignoring command {:?}.",
+                self.signer_id, command,
+            );
+            return false;
+        }
         match command {
             Command::Dkg => {
                 info!("Signer #{}: Starting DKG", self.signer_id);
@@ -388,8 +395,9 @@ impl Signer {
             };
             self.handle_packets(res, &[packet]);
         } else {
-            let (coordinator_id, _) =
-                calculate_coordinator(&self.signing_round.public_keys, &self.stacks_client);
+            let (coordinator_id, _) = self
+                .stacks_client
+                .calculate_coordinator(&self.signing_round.public_keys);
             if block_info.valid.unwrap_or(false)
                 && !block_info.signed_over
                 && coordinator_id == self.signer_id
@@ -423,8 +431,9 @@ impl Signer {
         res: Sender<Vec<OperationResult>>,
         messages: &[SignerMessage],
     ) {
-        let (coordinator_id, coordinator_public_key) =
-            calculate_coordinator(&self.signing_round.public_keys, &self.stacks_client);
+        let (coordinator_id, coordinator_public_key) = self
+            .stacks_client
+            .calculate_coordinator(&self.signing_round.public_keys);
         debug!(
             "Signer #{}: coordinator is signer #{} public key {}",
             self.signer_id, coordinator_id, &coordinator_public_key
@@ -1058,8 +1067,10 @@ impl Signer {
             .reward_cycle_in_vote_window(reward_cycle)?;
         self.coordinator
             .set_aggregate_public_key(aggregate_public_key);
-        let coordinator_id =
-            calculate_coordinator(&self.signing_round.public_keys, &self.stacks_client).0;
+        let coordinator_id = self
+            .stacks_client
+            .calculate_coordinator(&self.signing_round.public_keys)
+            .0;
         // TODO: should we attempt to vote anyway if out of window? what if we didn't successfully run DKG in prepare phase?
         if in_vote_window
             && aggregate_public_key.is_none()
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index 309d177f0e..ed4abbd1a0 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -32,12 +32,12 @@ use stacks_common::util::hash::{MerkleTree, Sha512Trunc256Sum};
 use stacks_common::util::secp256k1::MessageSignature;
 use stacks_signer::client::{StackerDB, StacksClient};
 use stacks_signer::config::{build_signer_config_tomls, Config as SignerConfig, Network};
-use stacks_signer::runloop::{calculate_coordinator, RunLoopCommand};
+use stacks_signer::runloop::RunLoopCommand;
 use stacks_signer::signer::Command as SignerCommand;
 use tracing_subscriber::prelude::*;
 use tracing_subscriber::{fmt, EnvFilter};
 use wsts::curve::point::Point;
-use wsts::state_machine::{OperationResult, PublicKeys};
+use wsts::state_machine::OperationResult;
 
 use crate::config::{Config as NeonConfig, EventKeyType, EventObserverConfig, InitialBalance};
 use crate::neon::Counters;
@@ -68,14 +68,10 @@ struct RunningNodes {
 struct SignerTest {
     // The stx and bitcoin nodes and their run loops
     pub running_nodes: RunningNodes,
-    // The channel for sending commands to the coordinator
-    pub coordinator_cmd_sender: Sender<RunLoopCommand>,
     // The channels for sending commands to the signers
-    pub _signer_cmd_senders: HashMap<u32, Sender<RunLoopCommand>>,
-    // The channels for receiving results from both the coordinator and the signers
+    pub signer_cmd_senders: HashMap<u32, Sender<RunLoopCommand>>,
+    // The channels for receiving results from the signers
     pub result_receivers: Vec<Receiver<Vec<OperationResult>>>,
-    // The running coordinator and its threads
-    pub running_coordinator: RunningSigner<SignerEventReceiver, Vec<OperationResult>>,
     // The running signer and its threads
     pub running_signers: HashMap<u32, RunningSigner<SignerEventReceiver, Vec<OperationResult>>>,
     // the private keys of the signers
@@ -124,35 +120,13 @@ impl SignerTest {
             &signer_stacks_private_keys,
             &signer_configs,
         );
-
-        // Calculate which signer will be selected as the coordinator
         let config = stacks_signer::config::Config::load_from_str(&signer_configs[0]).unwrap();
         let stacks_client = StacksClient::from(&config);
-        let public_key_ids = PublicKeys {
-            key_ids: HashMap::new(),
-            signers: HashMap::new(),
-        };
-        let (coordinator_id, coordinator_pk) =
-            calculate_coordinator(&public_key_ids, &stacks_client);
-        info!(
-            "Selected coordinator id: {:?} with pk: {:?}",
-            &coordinator_id, &coordinator_pk
-        );
-
-        // Fetch the selected coordinator and its cmd_sender
-        let running_coordinator = running_signers
-            .remove(&coordinator_id)
-            .expect("Coordinator not found");
-        let coordinator_cmd_sender = signer_cmd_senders
-            .remove(&coordinator_id)
-            .expect("Command sender not found");
 
         Self {
             running_nodes: node,
             result_receivers,
-            _signer_cmd_senders: signer_cmd_senders,
-            coordinator_cmd_sender,
-            running_coordinator,
+            signer_cmd_senders,
             running_signers,
             signer_stacks_private_keys,
             stacks_client,
@@ -175,8 +149,6 @@ impl SignerTest {
         for (_id, signer) in self.running_signers {
             assert!(signer.stop().is_none());
         }
-        // Stop the coordinator
-        assert!(self.running_coordinator.stop().is_none());
     }
 }
 
@@ -371,10 +343,11 @@ fn stackerdb_dkg_sign() {
         reward_cycle: 0,
         command: SignerCommand::Dkg,
     };
-    signer_test
-        .coordinator_cmd_sender
-        .send(dkg_command)
-        .expect("failed to send Dkg command");
+    for cmd_sender in signer_test.signer_cmd_senders.values() {
+        cmd_sender
+            .send(dkg_command.clone())
+            .expect("failed to send Dkg command");
+    }
     let mut key = Point::default();
     for recv in signer_test.result_receivers.iter() {
         let mut aggregate_public_key = None;
@@ -429,14 +402,14 @@ fn stackerdb_dkg_sign() {
             merkle_root: None,
         },
     };
-    signer_test
-        .coordinator_cmd_sender
-        .send(sign_command)
-        .expect("failed to send non taproot Sign command");
-    signer_test
-        .coordinator_cmd_sender
-        .send(sign_taproot_command)
-        .expect("failed to send taproot Sign command");
+    for cmd_sender in signer_test.signer_cmd_senders.values() {
+        cmd_sender
+            .send(sign_command.clone())
+            .expect("failed to send non taproot Sign command");
+        cmd_sender
+            .send(sign_taproot_command.clone())
+            .expect("failed to send taproot Sign command");
+    }
     for recv in signer_test.result_receivers.iter() {
         let mut frost_signature = None;
         let mut schnorr_proof = None;
@@ -804,10 +777,11 @@ fn stackerdb_block_proposal_missing_transactions() {
         reward_cycle: 0,
         command: SignerCommand::Dkg,
     };
-    signer_test
-        .coordinator_cmd_sender
-        .send(dkg_command)
-        .expect("failed to send Dkg command");
+    for cmd_sender in signer_test.signer_cmd_senders.values() {
+        cmd_sender
+            .send(dkg_command.clone())
+            .expect("failed to send Dkg command");
+    }
     let recv = signer_test
         .result_receivers
         .last()

From f3c444efb7d44c45950e2c1b0ec0583fb04e884a Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 7 Feb 2024 14:35:09 -0800
Subject: [PATCH 0858/1166] CRC: rename Config to GlobalConfig and
 StacksNodeInfo to RewardCycleConfig

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/mod.rs           | 20 +++----
 stacks-signer/src/client/stackerdb.rs     | 25 +++++----
 stacks-signer/src/client/stacks_client.rs | 12 ++---
 stacks-signer/src/config.rs               | 33 ++++++++++--
 stacks-signer/src/main.rs                 | 12 ++---
 stacks-signer/src/runloop.rs              | 26 ++++-----
 stacks-signer/src/signer.rs               | 66 ++++++++---------------
 testnet/stacks-node/src/tests/signer.rs   |  6 +--
 8 files changed, 101 insertions(+), 99 deletions(-)

diff --git a/stacks-signer/src/client/mod.rs b/stacks-signer/src/client/mod.rs
index 10790f4378..59bc4b273b 100644
--- a/stacks-signer/src/client/mod.rs
+++ b/stacks-signer/src/client/mod.rs
@@ -140,19 +140,19 @@ pub(crate) mod tests {
     use wsts::state_machine::PublicKeys;
 
     use super::*;
-    use crate::config::Config;
-    use crate::signer::StacksNodeInfo;
+    use crate::config::{GlobalConfig, RewardCycleConfig};
 
     pub struct MockServerClient {
         pub server: TcpListener,
         pub client: StacksClient,
-        pub config: Config,
+        pub config: GlobalConfig,
     }
 
     impl MockServerClient {
         /// Construct a new MockServerClient on a random port
         pub fn new() -> Self {
-            let mut config = Config::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
+            let mut config =
+                GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
             let (server, mock_server_addr) = mock_server_random();
             config.node_host = mock_server_addr;
 
@@ -165,7 +165,7 @@ pub(crate) mod tests {
         }
 
         /// Construct a new MockServerClient on the port specified in the config
-        pub fn from_config(config: Config) -> Self {
+        pub fn from_config(config: GlobalConfig) -> Self {
             let server = mock_server_from_config(&config);
             let client = StacksClient::from(&config);
             Self {
@@ -187,7 +187,7 @@ pub(crate) mod tests {
     }
 
     /// Create a mock server on a same port as in the config
-    pub fn mock_server_from_config(config: &Config) -> TcpListener {
+    pub fn mock_server_from_config(config: &GlobalConfig) -> TcpListener {
         TcpListener::bind(config.node_host).unwrap()
     }
 
@@ -248,13 +248,13 @@ pub(crate) mod tests {
         format!("HTTP/1.1 200 OK\n\n{{\"okay\":true,\"result\":\"{hex}\"}}")
     }
 
-    /// Generate a random stacks node info
+    /// Generate a random reward cycle config
     /// Optionally include a signer pubilc key to set as the first signer id with signer id 0 and signer slot id 0
-    pub fn generate_stacks_node_info(
+    pub fn generate_reward_cycle_config(
         num_signers: u32,
         num_keys: u32,
         signer_key: Option<ecdsa::PublicKey>,
-    ) -> (StacksNodeInfo, Vec<StacksAddress>) {
+    ) -> (RewardCycleConfig, Vec<StacksAddress>) {
         assert!(
             num_signers > 0,
             "Cannot generate 0 signers...Specify at least 1 signer."
@@ -331,7 +331,7 @@ pub(crate) mod tests {
             start_key_id = end_key_id;
         }
         (
-            StacksNodeInfo {
+            RewardCycleConfig {
                 public_keys,
                 signer_key_ids,
                 signer_slot_id: 0,
diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index fce49d0b5e..c647dff9c1 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -32,8 +32,7 @@ use stacks_common::{debug, warn};
 
 use super::ClientError;
 use crate::client::retry_with_exponential_backoff;
-use crate::config::Config;
-use crate::signer::StacksNodeInfo;
+use crate::config::{GlobalConfig, RewardCycleConfig};
 
 /// The StackerDB client for communicating with the .signers contract
 pub struct StackerDB {
@@ -86,7 +85,7 @@ impl StackerDB {
     }
 
     /// Create a new StackerDB client from the provided configuration info
-    pub fn new_with_config(config: &Config, stacks_node_info: &StacksNodeInfo) -> Self {
+    pub fn from_configs(config: &GlobalConfig, reward_cycle_config: &RewardCycleConfig) -> Self {
         let mut signers_message_stackerdb_sessions = HashMap::new();
         let stackerdb_issuer = boot_code_addr(config.network.is_mainnet());
         for msg_id in 0..SIGNER_SLOTS_PER_USER {
@@ -98,7 +97,7 @@ impl StackerDB {
                         stackerdb_issuer.into(),
                         ContractName::from(
                             NakamotoSigners::make_signers_db_name(
-                                stacks_node_info.signer_set as u64,
+                                reward_cycle_config.signer_set as u64,
                                 msg_id,
                             )
                             .as_str(),
@@ -111,8 +110,8 @@ impl StackerDB {
             signers_message_stackerdb_sessions,
             stacks_private_key: config.stacks_private_key,
             slot_versions: HashMap::new(),
-            signer_slot_id: stacks_node_info.signer_slot_id,
-            signer_set: stacks_node_info.signer_set,
+            signer_slot_id: reward_cycle_config.signer_slot_id,
+            signer_set: reward_cycle_config.signer_set,
         }
     }
 
@@ -270,14 +269,14 @@ mod tests {
 
     use super::*;
     use crate::client::tests::{
-        generate_stacks_node_info, mock_server_from_config, write_response,
+        generate_reward_cycle_config, mock_server_from_config, write_response,
     };
 
     #[test]
     #[serial]
     fn get_signer_transactions_with_retry_should_succeed() {
-        let config = Config::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
-        let (stacks_node_info, _ordered_addresses) = generate_stacks_node_info(
+        let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
+        let (reward_cycle_config, _ordered_addresses) = generate_reward_cycle_config(
             5,
             20,
             Some(
@@ -285,7 +284,7 @@ mod tests {
                     .expect("Failed to create public key."),
             ),
         );
-        let mut stackerdb = StackerDB::new_with_config(&config, &stacks_node_info);
+        let mut stackerdb = StackerDB::from_configs(&config, &reward_cycle_config);
         let sk = StacksPrivateKey::new();
         let tx = StacksTransaction {
             version: TransactionVersion::Testnet,
@@ -327,8 +326,8 @@ mod tests {
     #[test]
     #[serial]
     fn send_signer_message_with_retry_should_succeed() {
-        let config = Config::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
-        let (stacks_node_info, _ordered_addresses) = generate_stacks_node_info(
+        let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
+        let (reward_cycle_info, _ordered_addresses) = generate_reward_cycle_config(
             5,
             20,
             Some(
@@ -336,7 +335,7 @@ mod tests {
                     .expect("Failed to create public key."),
             ),
         );
-        let mut stackerdb = StackerDB::new_with_config(&config, &stacks_node_info);
+        let mut stackerdb = StackerDB::from_configs(&config, &reward_cycle_info);
 
         let sk = StacksPrivateKey::new();
         let tx = StacksTransaction {
diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index c27c5fe78c..223548f954 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -47,7 +47,7 @@ use wsts::curve::point::{Compressed, Point};
 use wsts::state_machine::PublicKeys;
 
 use crate::client::{retry_with_exponential_backoff, ClientError};
-use crate::config::Config;
+use crate::config::GlobalConfig;
 
 /// The name of the function for casting a DKG result to signer vote contract
 pub const VOTE_FUNCTION_NAME: &str = "vote-for-aggregate-public-key";
@@ -82,8 +82,8 @@ pub enum EpochId {
     UnsupportedEpoch,
 }
 
-impl From<&Config> for StacksClient {
-    fn from(config: &Config) -> Self {
+impl From<&GlobalConfig> for StacksClient {
+    fn from(config: &GlobalConfig) -> Self {
         Self {
             stacks_private_key: config.stacks_private_key,
             stacks_address: config.stacks_address,
@@ -704,7 +704,7 @@ mod tests {
     use crate::client::tests::{
         build_account_nonce_response, build_get_aggregate_public_key_response,
         build_get_last_round_response, build_get_peer_info_response, build_get_pox_data_response,
-        build_read_only_response, generate_stacks_node_info, write_response, MockServerClient,
+        build_read_only_response, generate_reward_cycle_config, write_response, MockServerClient,
     };
 
     #[test]
@@ -1330,7 +1330,7 @@ mod tests {
     #[test]
     fn calculate_coordinator_should_produce_unique_results() {
         let number_of_tests = 5;
-        let generated_public_keys = generate_stacks_node_info(10, 4000, None).0.public_keys;
+        let generated_public_keys = generate_reward_cycle_config(10, 4000, None).0.public_keys;
         let mut results = Vec::new();
 
         for _ in 0..number_of_tests {
@@ -1359,7 +1359,7 @@ mod tests {
 
     fn generate_test_results(random_consensus: bool, count: usize) -> Vec<(u32, ecdsa::PublicKey)> {
         let mut results = Vec::new();
-        let generated_public_keys = generate_stacks_node_info(10, 4000, None).0.public_keys;
+        let generated_public_keys = generate_reward_cycle_config(10, 4000, None).0.public_keys;
         for _ in 0..count {
             let mock = MockServerClient::new();
             let generated_public_keys = generated_public_keys.clone();
diff --git a/stacks-signer/src/config.rs b/stacks-signer/src/config.rs
index 211807feee..57a955fffb 100644
--- a/stacks-signer/src/config.rs
+++ b/stacks-signer/src/config.rs
@@ -21,7 +21,7 @@ use std::path::PathBuf;
 use std::time::Duration;
 
 use blockstack_lib::chainstate::stacks::TransactionVersion;
-use hashbrown::HashMap;
+use hashbrown::{HashMap, HashSet};
 use serde::Deserialize;
 use stacks_common::address::{
     AddressHashMode, C32_ADDRESS_VERSION_MAINNET_SINGLESIG, C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
@@ -29,7 +29,9 @@ use stacks_common::address::{
 use stacks_common::consts::{CHAIN_ID_MAINNET, CHAIN_ID_TESTNET};
 use stacks_common::types::chainstate::{StacksAddress, StacksPrivateKey, StacksPublicKey};
 use stacks_common::types::PrivateKey;
+use wsts::curve::point::Point;
 use wsts::curve::scalar::Scalar;
+use wsts::state_machine::PublicKeys;
 
 /// List of key_ids for each signer_id
 pub type SignerKeyIds = HashMap<u32, Vec<u32>>;
@@ -111,9 +113,30 @@ impl Network {
     }
 }
 
+/// The Configuration info needed for an individual signer per reward cycle
+#[derive(Debug, Clone)]
+pub struct RewardCycleConfig {
+    /// The signer set for this runloop
+    pub signer_set: u32,
+    /// The index into the signers list of this signer's key (may be different from signer_id)
+    pub signer_slot_id: u32,
+    /// The signer ID assigned to this signer
+    pub signer_id: u32,
+    /// The reward cycle of the configuration
+    pub reward_cycle: u64,
+    /// The signer ids to wsts pubilc keys mapping
+    pub signer_public_keys: HashMap<u32, Point>,
+    /// The signer to key ids mapping
+    pub signer_key_ids: HashMap<u32, HashSet<u32>>,
+    /// The signer addresses
+    pub signer_addresses: HashSet<StacksAddress>,
+    /// The public keys for the reward cycle
+    pub public_keys: PublicKeys,
+}
+
 /// The parsed configuration for the signer
 #[derive(Clone, Debug)]
-pub struct Config {
+pub struct GlobalConfig {
     /// endpoint to the stacks node
     pub node_host: SocketAddr,
     /// endpoint to the event receiver
@@ -194,7 +217,7 @@ impl TryFrom<&PathBuf> for RawConfigFile {
     }
 }
 
-impl TryFrom<RawConfigFile> for Config {
+impl TryFrom<RawConfigFile> for GlobalConfig {
     type Error = ConfigError;
 
     /// Attempt to decode the raw config file's primitive types into our types.
@@ -270,7 +293,7 @@ impl TryFrom<RawConfigFile> for Config {
     }
 }
 
-impl TryFrom<&PathBuf> for Config {
+impl TryFrom<&PathBuf> for GlobalConfig {
     type Error = ConfigError;
     fn try_from(path: &PathBuf) -> Result<Self, ConfigError> {
         let config_file = RawConfigFile::try_from(path)?;
@@ -278,7 +301,7 @@ impl TryFrom<&PathBuf> for Config {
     }
 }
 
-impl Config {
+impl GlobalConfig {
     /// load the config from a string and parse it
     pub fn load_from_str(data: &str) -> Result<Self, ConfigError> {
         RawConfigFile::load_from_str(data)?.try_into()
diff --git a/stacks-signer/src/main.rs b/stacks-signer/src/main.rs
index 17a88c9831..0042b539d0 100644
--- a/stacks-signer/src/main.rs
+++ b/stacks-signer/src/main.rs
@@ -49,7 +49,7 @@ use stacks_signer::cli::{
     Cli, Command, GenerateFilesArgs, GenerateStackingSignatureArgs, GetChunkArgs,
     GetLatestChunkArgs, PutChunkArgs, RunDkgArgs, SignArgs, StackerDBArgs,
 };
-use stacks_signer::config::{build_signer_config_tomls, Config};
+use stacks_signer::config::{build_signer_config_tomls, GlobalConfig};
 use stacks_signer::runloop::{RunLoop, RunLoopCommand};
 use stacks_signer::signer::Command as SignerCommand;
 use tracing_subscriber::prelude::*;
@@ -84,7 +84,7 @@ fn write_chunk_to_stdout(chunk_opt: Option<Vec<u8>>) {
 
 // Spawn a running signer and return its handle, command sender, and result receiver
 fn spawn_running_signer(path: &PathBuf) -> SpawnedSigner {
-    let config = Config::try_from(path).unwrap();
+    let config = GlobalConfig::try_from(path).unwrap();
     let endpoint = config.endpoint;
     let (cmd_send, cmd_recv) = channel();
     let (res_send, res_recv) = channel();
@@ -303,7 +303,7 @@ fn handle_generate_stacking_signature(
     args: GenerateStackingSignatureArgs,
     do_print: bool,
 ) -> MessageSignature {
-    let config = Config::try_from(&args.config).unwrap();
+    let config = GlobalConfig::try_from(&args.config).unwrap();
 
     let private_key = config.stacks_private_key;
     let public_key = Secp256k1PublicKey::from_private(&private_key);
@@ -394,7 +394,7 @@ pub mod tests {
     use stacks_signer::cli::parse_pox_addr;
 
     use super::{handle_generate_stacking_signature, *};
-    use crate::{Config, GenerateStackingSignatureArgs};
+    use crate::{GenerateStackingSignatureArgs, GlobalConfig};
 
     fn call_verify_signer_sig(
         pox_addr: &PoxAddress,
@@ -429,7 +429,7 @@ pub mod tests {
 
     #[test]
     fn test_stacking_signature_with_pox_code() {
-        let config = Config::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
+        let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
         let btc_address = "bc1p8vg588hldsnv4a558apet4e9ff3pr4awhqj2hy8gy6x2yxzjpmqsvvpta4";
         let mut args = GenerateStackingSignatureArgs {
             config: "./src/tests/conf/signer-0.toml".into(),
@@ -473,7 +473,7 @@ pub mod tests {
 
     #[test]
     fn test_generate_stacking_signature() {
-        let config = Config::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
+        let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
         let btc_address = "bc1p8vg588hldsnv4a558apet4e9ff3pr4awhqj2hy8gy6x2yxzjpmqsvvpta4";
         let args = GenerateStackingSignatureArgs {
             config: "./src/tests/conf/signer-0.toml".into(),
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 8fbb8296fc..daf2c74463 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -28,8 +28,8 @@ use wsts::curve::point::{Compressed, Point};
 use wsts::state_machine::{OperationResult, PublicKeys};
 
 use crate::client::{retry_with_exponential_backoff, ClientError, StacksClient};
-use crate::config::Config;
-use crate::signer::{Command as SignerCommand, Signer, StacksNodeInfo, State as SignerState};
+use crate::config::{GlobalConfig, RewardCycleConfig};
+use crate::signer::{Command as SignerCommand, Signer, State as SignerState};
 
 /// Which operation to perform
 #[derive(PartialEq, Clone, Debug)]
@@ -52,7 +52,7 @@ pub enum State {
 /// The runloop for the stacks signer
 pub struct RunLoop {
     /// Configuration info
-    pub config: Config,
+    pub config: GlobalConfig,
     /// The stacks node client
     pub stacks_client: StacksClient,
     /// The internal signer for an odd or even reward cycle
@@ -62,9 +62,9 @@ pub struct RunLoop {
     pub state: State,
 }
 
-impl From<Config> for RunLoop {
+impl From<GlobalConfig> for RunLoop {
     /// Creates new runloop from a config
-    fn from(config: Config) -> Self {
+    fn from(config: GlobalConfig) -> Self {
         let stacks_client = StacksClient::from(&config);
         RunLoop {
             config,
@@ -77,10 +77,10 @@ impl From<Config> for RunLoop {
 
 impl RunLoop {
     /// Get a signer configruation for a specific reward cycle from the stacks node
-    fn get_stacks_node_info(
+    fn get_reward_cycle_config(
         &mut self,
         reward_cycle: u64,
-    ) -> Result<Option<StacksNodeInfo>, backoff::Error<ClientError>> {
+    ) -> Result<Option<RewardCycleConfig>, backoff::Error<ClientError>> {
         let reward_set_calculated = self
             .stacks_client
             .reward_set_calculated(reward_cycle)
@@ -171,7 +171,7 @@ impl RunLoop {
             warn!("Signer {current_addr} was found in stacker db but not the reward set for reward cycle {reward_cycle}.");
             return Ok(None);
         };
-        Ok(Some(StacksNodeInfo {
+        Ok(Some(RewardCycleConfig {
             reward_cycle,
             signer_id,
             signer_slot_id,
@@ -202,11 +202,13 @@ impl RunLoop {
             needs_refresh = true;
         };
         if needs_refresh {
-            let new_config = self.get_stacks_node_info(reward_cycle)?;
-            if let Some(new_node_info) = new_config {
+            let new_reward_cycle_config = self.get_reward_cycle_config(reward_cycle)?;
+            if let Some(new_reward_cycle_config) = new_reward_cycle_config {
                 debug!("Signer is registered for reward cycle {reward_cycle}. Initializing signer state.");
-                self.stacks_signers
-                    .insert(reward_index, Signer::new(&self.config, new_node_info));
+                self.stacks_signers.insert(
+                    reward_index,
+                    Signer::from_configs(&self.config, new_reward_cycle_config),
+                );
             } else {
                 // Nothing to initialize. Signer is not registered for this reward cycle
                 debug!("Signer is not registered for reward cycle {reward_cycle}. Nothing to initialize.");
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index cf3aad17e0..6bc813583a 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -30,42 +30,20 @@ use stacks_common::util::hash::Sha512Trunc256Sum;
 use stacks_common::{debug, error, info, warn};
 use wsts::common::{MerkleRoot, Signature};
 use wsts::curve::keys::PublicKey;
-use wsts::curve::point::Point;
 use wsts::net::{Message, NonceRequest, Packet, SignatureShareRequest};
 use wsts::state_machine::coordinator::fire::Coordinator as FireCoordinator;
 use wsts::state_machine::coordinator::{
     Config as CoordinatorConfig, Coordinator, State as CoordinatorState,
 };
 use wsts::state_machine::signer::Signer as WSTSSigner;
-use wsts::state_machine::{OperationResult, PublicKeys, SignError};
+use wsts::state_machine::{OperationResult, SignError};
 use wsts::v2;
 
 use crate::client::{
     retry_with_exponential_backoff, ClientError, EpochId, StackerDB, StacksClient,
     VOTE_FUNCTION_NAME,
 };
-use crate::config::Config;
-
-/// The info needed from the stacks node to configure a signer
-#[derive(Debug, Clone)]
-pub struct StacksNodeInfo {
-    /// The signer set for this runloop
-    pub signer_set: u32,
-    /// The index into the signers list of this signer's key (may be different from signer_id)
-    pub signer_slot_id: u32,
-    /// The signer ID assigned to this signer
-    pub signer_id: u32,
-    /// The reward cycle of the configuration
-    pub reward_cycle: u64,
-    /// The signer ids to wsts pubilc keys mapping
-    pub signer_public_keys: HashMap<u32, Point>,
-    /// The signer to key ids mapping
-    pub signer_key_ids: HashMap<u32, HashSet<u32>>,
-    /// The signer addresses
-    pub signer_addresses: HashSet<StacksAddress>,
-    /// The public keys for the reward cycle
-    pub public_keys: PublicKeys,
-}
+use crate::config::{GlobalConfig, RewardCycleConfig};
 
 /// Additional Info about a proposed block
 pub struct BlockInfo {
@@ -163,18 +141,18 @@ pub struct Signer {
 
 impl Signer {
     /// Create a new stacks signer
-    pub fn new(config: &Config, stacks_node_info: StacksNodeInfo) -> Self {
-        let stackerdb = StackerDB::new_with_config(config, &stacks_node_info);
+    pub fn from_configs(config: &GlobalConfig, reward_cycle_config: RewardCycleConfig) -> Self {
+        let stackerdb = StackerDB::from_configs(config, &reward_cycle_config);
         let stacks_client = StacksClient::from(config);
 
-        let num_signers = u32::try_from(stacks_node_info.public_keys.signers.len())
+        let num_signers = u32::try_from(reward_cycle_config.public_keys.signers.len())
             .expect("FATAL: Too many registered signers to fit in a u32");
-        let num_keys = u32::try_from(stacks_node_info.public_keys.key_ids.len())
+        let num_keys = u32::try_from(reward_cycle_config.public_keys.key_ids.len())
             .expect("FATAL: Too many key ids to fit in a u32");
         let threshold = num_keys * 7 / 10;
         let dkg_threshold = num_keys * 9 / 10;
         // signer uses a Vec<u32> for its key_ids, but coordinator uses a HashSet for each signer since it needs to do lots of lookups
-        let signer_key_ids: Vec<u32> = stacks_node_info
+        let signer_key_ids: Vec<u32> = reward_cycle_config
             .public_keys
             .key_ids
             .keys()
@@ -192,8 +170,8 @@ impl Signer {
             dkg_end_timeout: config.dkg_end_timeout,
             nonce_timeout: config.nonce_timeout,
             sign_timeout: config.sign_timeout,
-            signer_key_ids: stacks_node_info.signer_key_ids.clone(),
-            signer_public_keys: stacks_node_info.signer_public_keys.clone(),
+            signer_key_ids: reward_cycle_config.signer_key_ids.clone(),
+            signer_public_keys: reward_cycle_config.signer_public_keys.clone(),
         };
 
         let coordinator = FireCoordinator::new(coordinator_config);
@@ -201,10 +179,10 @@ impl Signer {
             threshold,
             num_signers,
             num_keys,
-            stacks_node_info.signer_id,
+            reward_cycle_config.signer_id,
             signer_key_ids,
             config.ecdsa_private_key,
-            stacks_node_info.public_keys,
+            reward_cycle_config.public_keys,
         );
         Self {
             coordinator,
@@ -215,9 +193,9 @@ impl Signer {
             stackerdb,
             stacks_client,
             is_mainnet: config.network.is_mainnet(), // will be updated on .initialize()
-            signer_id: stacks_node_info.signer_id,
-            signer_addresses: stacks_node_info.signer_addresses,
-            reward_cycle: stacks_node_info.reward_cycle,
+            signer_id: reward_cycle_config.signer_id,
+            signer_addresses: reward_cycle_config.signer_addresses,
+            reward_cycle: reward_cycle_config.reward_cycle,
         }
     }
 
@@ -1176,18 +1154,18 @@ mod tests {
     use wsts::curve::ecdsa;
 
     use crate::client::tests::{
-        generate_stacks_node_info, mock_server_from_config, write_response,
+        generate_reward_cycle_config, mock_server_from_config, write_response,
     };
     use crate::client::{StacksClient, VOTE_FUNCTION_NAME};
-    use crate::config::Config;
+    use crate::config::GlobalConfig;
     use crate::signer::{BlockInfo, Signer};
 
     #[test]
     #[serial]
     fn get_expected_transactions_should_filter_invalid_transactions() {
         // Create a runloop of a valid signer
-        let config = Config::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
-        let (stacks_node_info, _ordered_addresses) = generate_stacks_node_info(
+        let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
+        let (reward_cycle_info, _ordered_addresses) = generate_reward_cycle_config(
             5,
             20,
             Some(
@@ -1195,7 +1173,7 @@ mod tests {
                     .expect("Failed to create public key."),
             ),
         );
-        let mut signer = Signer::new(&config, stacks_node_info);
+        let mut signer = Signer::from_configs(&config, reward_cycle_info);
 
         let signer_private_key = config.stacks_private_key;
         let non_signer_private_key = StacksPrivateKey::new();
@@ -1341,8 +1319,8 @@ mod tests {
     #[test]
     #[serial]
     fn verify_transactions_valid() {
-        let config = Config::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
-        let (stacks_node_info, _ordered_addresses) = generate_stacks_node_info(
+        let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
+        let (reward_cycle_info, _ordered_addresses) = generate_reward_cycle_config(
             5,
             20,
             Some(
@@ -1350,7 +1328,7 @@ mod tests {
                     .expect("Failed to create public key."),
             ),
         );
-        let mut signer = Signer::new(&config, stacks_node_info);
+        let mut signer = Signer::from_configs(&config, reward_cycle_info);
 
         let signer_private_key = config.stacks_private_key;
         let vote_contract_id = boot_code_id(SIGNERS_VOTING_NAME, signer.is_mainnet);
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index ed4abbd1a0..83cd7116a8 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -31,7 +31,7 @@ use stacks_common::types::chainstate::{
 use stacks_common::util::hash::{MerkleTree, Sha512Trunc256Sum};
 use stacks_common::util::secp256k1::MessageSignature;
 use stacks_signer::client::{StackerDB, StacksClient};
-use stacks_signer::config::{build_signer_config_tomls, Config as SignerConfig, Network};
+use stacks_signer::config::{build_signer_config_tomls, GlobalConfig as SignerConfig, Network};
 use stacks_signer::runloop::RunLoopCommand;
 use stacks_signer::signer::Command as SignerCommand;
 use tracing_subscriber::prelude::*;
@@ -120,7 +120,7 @@ impl SignerTest {
             &signer_stacks_private_keys,
             &signer_configs,
         );
-        let config = stacks_signer::config::Config::load_from_str(&signer_configs[0]).unwrap();
+        let config = SignerConfig::load_from_str(&signer_configs[0]).unwrap();
         let stacks_client = StacksClient::from(&config);
 
         Self {
@@ -157,7 +157,7 @@ fn spawn_signer(
     receiver: Receiver<RunLoopCommand>,
     sender: Sender<Vec<OperationResult>>,
 ) -> RunningSigner<SignerEventReceiver, Vec<OperationResult>> {
-    let config = stacks_signer::config::Config::load_from_str(data).unwrap();
+    let config = SignerConfig::load_from_str(data).unwrap();
     let ev = SignerEventReceiver::new(config.network.is_mainnet());
     let endpoint = config.endpoint;
     let runloop: stacks_signer::runloop::RunLoop = stacks_signer::runloop::RunLoop::from(config);

From c4b5eceb29088a194a14201a72fecf38b7892a80 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 7 Feb 2024 14:45:15 -0800
Subject: [PATCH 0859/1166] Convert client error to transient where
 approproiate

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/runloop.rs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index daf2c74463..01cc348754 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -115,7 +115,11 @@ impl RunLoop {
         };
 
         // We can only register for a reward cycle if a reward set exists. We know that it should exist due to our earlier check for reward_set_calculated
-        let Some(reward_set_signers) = self.stacks_client.get_reward_set(reward_cycle)?.signers
+        let Some(reward_set_signers) = self
+            .stacks_client
+            .get_reward_set(reward_cycle)
+            .map_err(backoff::Error::transient)?
+            .signers
         else {
             warn!(
                 "No reward set found for reward cycle {reward_cycle}. Must not be a valid Nakamoto reward cycle."

From 7ce63b243c63fc3fecb7309bf9f0d56add890e6a Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 7 Feb 2024 15:11:10 -0800
Subject: [PATCH 0860/1166] Cleanup logging

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/mod.rs           |   6 +-
 stacks-signer/src/client/stackerdb.rs     |  18 ++--
 stacks-signer/src/client/stacks_client.rs |  10 +--
 stacks-signer/src/config.rs               |   4 +-
 stacks-signer/src/runloop.rs              |   5 +-
 stacks-signer/src/signer.rs               | 103 +++++++++++-----------
 6 files changed, 71 insertions(+), 75 deletions(-)

diff --git a/stacks-signer/src/client/mod.rs b/stacks-signer/src/client/mod.rs
index 59bc4b273b..e3f20ecf4e 100644
--- a/stacks-signer/src/client/mod.rs
+++ b/stacks-signer/src/client/mod.rs
@@ -108,11 +108,11 @@ pub enum ClientError {
 pub fn retry_with_exponential_backoff<F, E, T>(request_fn: F) -> Result<T, ClientError>
 where
     F: FnMut() -> Result<T, backoff::Error<E>>,
+    E: std::fmt::Debug,
 {
-    let notify = |_err, dur| {
+    let notify = |err, dur| {
         debug!(
-            "Failed to connect to stacks node and/or deserialize its response. Next attempt in {:?}",
-            dur
+            "Failed to connect to stacks node and/or deserialize its response: {err:?}. Next attempt in {dur:?}"
         );
     };
 
diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index c647dff9c1..65d0f3fbe6 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -146,9 +146,8 @@ impl StackerDB {
             };
 
             debug!(
-                "Sending a chunk to stackerdb slot ID {slot_id} with version {slot_version} to contract {:?}!\n{:?}",
-                &session.stackerdb_contract_id,
-                &chunk
+                "Sending a chunk to stackerdb slot ID {slot_id} with version {slot_version} to contract {:?}!\n{chunk:?}",
+                &session.stackerdb_contract_id
             );
 
             let send_request = || session.put_chunk(&chunk).map_err(backoff::Error::transient);
@@ -162,10 +161,10 @@ impl StackerDB {
             }
 
             if chunk_ack.accepted {
-                debug!("Chunk accepted by stackerdb: {:?}", chunk_ack);
+                debug!("Chunk accepted by stackerdb: {chunk_ack:?}");
                 return Ok(chunk_ack);
             } else {
-                warn!("Chunk rejected by stackerdb: {:?}", chunk_ack);
+                warn!("Chunk rejected by stackerdb: {chunk_ack:?}");
             }
             if let Some(reason) = chunk_ack.reason {
                 // TODO: fix this jankiness. Update stackerdb to use an error code mapping instead of just a string
@@ -191,10 +190,7 @@ impl StackerDB {
         &mut self,
         signer_ids: &[u32],
     ) -> Result<Vec<StacksTransaction>, ClientError> {
-        debug!(
-            "Getting latest chunks from stackerdb for the following signers: {:?}",
-            signer_ids
-        );
+        debug!("Getting latest chunks from stackerdb for the following signers: {signer_ids:?}",);
         let Some(transactions_session) = self
             .signers_message_stackerdb_sessions
             .get_mut(&TRANSACTIONS_MSG_ID)
@@ -220,10 +216,8 @@ impl StackerDB {
                 if !data.is_empty() {
                     warn!("Failed to deserialize chunk data into a SignerMessage");
                     debug!(
-                        "signer #{}: Failed chunk ({}): {:?}",
-                        signer_id,
+                        "signer #{signer_id}: Failed chunk ({}): {data:?}",
                         &data.len(),
-                        &data[..]
                     );
                 }
                 continue;
diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index 223548f954..5549c71a8e 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -111,7 +111,7 @@ impl StacksClient {
             }) {
                 Ok(hash) => hash,
                 Err(e) => {
-                    debug!("Failed to get stacks tip consensus hash: {:?}", e);
+                    debug!("Failed to get stacks tip consensus hash: {e:?}");
                     return (
                         0,
                         public_keys.signers.get(&0).cloned().expect(
@@ -121,8 +121,7 @@ impl StacksClient {
                 }
             };
         debug!(
-            "Using stacks_tip_consensus_hash {:?} for selecting coordinator",
-            &stacks_tip_consensus_hash
+            "Using stacks_tip_consensus_hash {stacks_tip_consensus_hash:?} for selecting coordinator"
         );
 
         // Create combined hash of each signer's public key with stacks_tip_consensus_hash
@@ -553,10 +552,7 @@ impl StacksClient {
         function_name: &ClarityName,
         function_args: &[ClarityValue],
     ) -> Result<ClarityValue, ClientError> {
-        debug!(
-            "Calling read-only function {function_name} with args {:?}...",
-            function_args
-        );
+        debug!("Calling read-only function {function_name} with args {function_args:?}...");
         let args = function_args
             .iter()
             .filter_map(|arg| arg.serialize_to_hex().ok())
diff --git a/stacks-signer/src/config.rs b/stacks-signer/src/config.rs
index 57a955fffb..9d72527385 100644
--- a/stacks-signer/src/config.rs
+++ b/stacks-signer/src/config.rs
@@ -197,7 +197,7 @@ impl RawConfigFile {
     /// load the config from a string
     pub fn load_from_str(data: &str) -> Result<Self, ConfigError> {
         let config: RawConfigFile =
-            toml::from_str(data).map_err(|e| ConfigError::ParseError(format!("{:?}", &e)))?;
+            toml::from_str(data).map_err(|e| ConfigError::ParseError(format!("{e:?}")))?;
         Ok(config)
     }
     /// load the config from a file and parse it
@@ -212,7 +212,7 @@ impl TryFrom<&PathBuf> for RawConfigFile {
 
     fn try_from(path: &PathBuf) -> Result<Self, Self::Error> {
         RawConfigFile::load_from_str(&fs::read_to_string(path).map_err(|e| {
-            ConfigError::InvalidConfig(format!("failed to read config file: {:?}", &e))
+            ConfigError::InvalidConfig(format!("failed to read config file: {e:?}"))
         })?)
     }
 }
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 01cc348754..1d33e7278e 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -175,6 +175,9 @@ impl RunLoop {
             warn!("Signer {current_addr} was found in stacker db but not the reward set for reward cycle {reward_cycle}.");
             return Ok(None);
         };
+        debug!(
+            "Signer #{signer_id} ({current_addr}) is registered for reward cycle {reward_cycle}."
+        );
         Ok(Some(RewardCycleConfig {
             reward_cycle,
             signer_id,
@@ -287,7 +290,7 @@ impl SignerRunLoop<Vec<OperationResult>, RunLoopCommand> for RunLoop {
             if self.state == State::Uninitialized {
                 // If we were never actually initialized, we cannot process anything. Just return.
                 error!("Failed to initialize signers. Are you sure this signer is correctly registered for the current or next reward cycle?");
-                warn!("Ignoring event: {:?}", event);
+                warn!("Ignoring event: {event:?}");
                 return None;
             } else {
                 error!("Failed to refresh signers: {e}. Signer may have an outdated view of the network. Attempting to process event anyway.");
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index 6bc813583a..e11b778f88 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -207,8 +207,8 @@ impl Signer {
             .calculate_coordinator(&self.signing_round.public_keys);
         if coordinator_id != self.signer_id {
             warn!(
-                "Signer #{}: Not the coordinator. Ignoring command {:?}.",
-                self.signer_id, command,
+                "Signer #{}: Not the coordinator. Ignoring command {command:?}.",
+                self.signer_id
             );
             return false;
         }
@@ -218,13 +218,16 @@ impl Signer {
                 match self.coordinator.start_dkg_round() {
                     Ok(msg) => {
                         let ack = self.stackerdb.send_message_with_retry(msg.into());
-                        debug!("Signer #{}: ACK: {:?}", self.signer_id, ack);
+                        debug!("Signer #{}: ACK: {ack:?}", self.signer_id);
                         self.state = State::Dkg;
                         true
                     }
                     Err(e) => {
-                        error!("Failed to start DKG: {:?}", e);
-                        warn!("Resetting coordinator's internal state.");
+                        error!("Signer #{}: Failed to start DKG: {e:?}", self.signer_id);
+                        warn!(
+                            "Signer #{}: Resetting coordinator's internal state.",
+                            self.signer_id
+                        );
                         self.coordinator.reset();
                         false
                     }
@@ -244,7 +247,7 @@ impl Signer {
                     debug!("Signer #{}: Received a sign command for a block we are already signing over. Ignore it.", self.signer_id);
                     return false;
                 }
-                info!("Signer #{}: Signing block: {:?}", self.signer_id, block);
+                info!("Signer #{}: Signing block: {block:?}", self.signer_id);
                 match self.coordinator.start_signing_round(
                     &block.serialize_to_vec(),
                     *is_taproot,
@@ -252,15 +255,15 @@ impl Signer {
                 ) {
                     Ok(msg) => {
                         let ack = self.stackerdb.send_message_with_retry(msg.into());
-                        debug!("Signer #{}: ACK: {:?}", self.signer_id, ack);
+                        debug!("Signer #{}: ACK: {ack:?}", self.signer_id);
                         self.state = State::Sign;
                         block_info.signed_over = true;
                         true
                     }
                     Err(e) => {
                         error!(
-                            "Signer #{}: Failed to start signing message: {:?}",
-                            self.signer_id, e
+                            "Signer #{}: Failed to start signing message: {e:?}",
+                            self.signer_id
                         );
                         warn!(
                             "Signer #{}: Resetting coordinator's internal state.",
@@ -354,8 +357,8 @@ impl Signer {
                     .send_message_with_retry(block_validate_reject.clone().into())
                 {
                     warn!(
-                        "Signer #{}: Failed to send block rejection to stacker-db: {:?}",
-                        self.signer_id, e
+                        "Signer #{}: Failed to send block rejection to stacker-db: {e:?}",
+                        self.signer_id
                     );
                 }
                 block_info
@@ -440,7 +443,7 @@ impl Signer {
             self.stacks_client
                 .submit_block_for_validation(block.clone())
                 .unwrap_or_else(|e| {
-                    warn!("Failed to submit block for validation: {:?}", e);
+                    warn!("Failed to submit block for validation: {e:?}");
                 });
         }
     }
@@ -452,7 +455,7 @@ impl Signer {
             .signing_round
             .process_inbound_messages(packets)
             .unwrap_or_else(|e| {
-                error!("Failed to process inbound messages as a signer: {e}");
+                error!("Failed to process inbound messages as a signer: {e:?}");
                 vec![]
             });
 
@@ -461,7 +464,7 @@ impl Signer {
             .coordinator
             .process_inbound_messages(packets)
             .unwrap_or_else(|e| {
-                error!("Failed to process inbound messages as a coordinator: {e}");
+                error!("Failed to process inbound messages as a coordinator: {e:?}");
                 (vec![], vec![])
             });
 
@@ -503,8 +506,8 @@ impl Signer {
             Some(Some(vote)) => {
                 // Overwrite with our agreed upon value in case another message won majority or the coordinator is trying to cheat...
                 debug!(
-                    "Signer #{}: set vote for {} to {:?}",
-                    self.signer_id, &hash, &vote
+                    "Signer #{}: set vote for {hash} to {vote:?}",
+                    self.signer_id
                 );
                 request.message = vote.clone();
                 true
@@ -553,8 +556,8 @@ impl Signer {
                 .submit_block_for_validation(block)
                 .unwrap_or_else(|e| {
                     warn!(
-                        "Signer #{}: Failed to submit block for validation: {:?}",
-                        self.signer_id, e
+                        "Signer #{}: Failed to submit block for validation: {e:?}",
+                        self.signer_id
                     );
                 });
             return false;
@@ -610,8 +613,8 @@ impl Signer {
                     .send_message_with_retry(block_rejection.into())
                 {
                     warn!(
-                        "Signer #{}: Failed to send block rejection to stacker-db: {:?}",
-                        self.signer_id, e
+                        "Signer #{}: Failed to send block rejection to stacker-db: {e:?}",
+                        self.signer_id
                     );
                 }
             }
@@ -632,8 +635,8 @@ impl Signer {
                 .send_message_with_retry(block_rejection.into())
             {
                 warn!(
-                    "Signer #{}: Failed to send block submission to stacker-db: {:?}",
-                    self.signer_id, e
+                    "Signer #{}: Failed to send block submission to stacker-db: {e:?}",
+                    self.signer_id
                 );
             }
             false
@@ -694,7 +697,7 @@ impl Signer {
                         );
                         return None;
                     }
-                    debug!("Signer #{}: Expect transaction {} ({:?})", self.signer_id, transaction.txid(), &transaction);
+                    debug!("Signer #{}: Expect transaction {} ({transaction:?})", self.signer_id, transaction.txid());
                     Some(transaction)
                 }).collect();
         Ok(transactions)
@@ -754,8 +757,8 @@ impl Signer {
             Some(packet)
         } else {
             debug!(
-                "Signer #{}: Failed to verify wsts packet with {}: {:?}",
-                self.signer_id, coordinator_public_key, &packet
+                "Signer #{}: Failed to verify wsts packet with {}: {packet:?}",
+                self.signer_id, coordinator_public_key
             );
             None
         }
@@ -798,13 +801,13 @@ impl Signer {
                             }) {
                                 Ok(transaction) => {
                                     debug!("Signer #{}: Successfully cast aggregate public key vote: {:?}",
-                                    self.signer_id,
+                                        self.signer_id,
                                         transaction.txid()
                                     );
                                     transaction
                                 }
                                 Err(e) => {
-                                    warn!("Signer #{}: Failed to cast aggregate public key vote: {:?}", self.signer_id, e);
+                                    warn!("Signer #{}: Failed to cast aggregate public key vote: {e:?}", self.signer_id);
                                     continue;
                                 }
                             }
@@ -822,7 +825,7 @@ impl Signer {
                             }) {
                                 Ok(transaction) => transaction,
                                 Err(e) => {
-                                    warn!("Signer #{}: Failed to build a cast aggregate public key vote transaction: {:?}", self.signer_id, e);
+                                    warn!("Signer #{}: Failed to build a cast aggregate public key vote transaction: {e:?}", self.signer_id);
                                     continue;
                                 }
                             }
@@ -832,7 +835,7 @@ impl Signer {
                         .stackerdb
                         .get_signer_transactions_with_retry(&[self.signer_id])
                         .map_err(|e| {
-                            error!("Failed to get old transactions from stackerdb: {:?}", e);
+                            error!("Failed to get old transactions from stackerdb: {e:?}");
                         })
                         .unwrap_or_default();
                     // Filter out our old transactions that are no longer valid
@@ -854,8 +857,8 @@ impl Signer {
                     let signer_message = SignerMessage::Transactions(new_transactions);
                     if let Err(e) = self.stackerdb.send_message_with_retry(signer_message) {
                         warn!(
-                            "Signer #{}: Failed to update transactions in stacker-db: {:?}",
-                            self.signer_id, e
+                            "Signer #{}: Failed to update transactions in stacker-db: {e:?}",
+                            self.signer_id
                         );
                     }
                 }
@@ -863,7 +866,7 @@ impl Signer {
                     self.process_sign_error(e);
                 }
                 OperationResult::DkgError(e) => {
-                    warn!("Signer #{}: Received a DKG error: {:?}", self.signer_id, e);
+                    warn!("Signer #{}: Received a DKG error: {e:?}", self.signer_id);
                 }
             }
         }
@@ -914,13 +917,13 @@ impl Signer {
 
         // Submit signature result to miners to observe
         debug!(
-            "Signer #{}: submit block response {:?}",
-            self.signer_id, &block_submission
+            "Signer #{}: submit block response {block_submission:?}",
+            self.signer_id
         );
         if let Err(e) = self.stackerdb.send_message_with_retry(block_submission) {
             warn!(
-                "Signer #{}: Failed to send block submission to stacker-db: {:?}",
-                self.signer_id, e
+                "Signer #{}: Failed to send block submission to stacker-db: {e:?}",
+                self.signer_id
             );
         }
     }
@@ -928,8 +931,8 @@ impl Signer {
     /// Process a sign error from a signing round, broadcasting a rejection message to stackerdb accordingly
     fn process_sign_error(&mut self, e: &SignError) {
         warn!(
-            "Signer #{}: Received a signature error: {:?}",
-            self.signer_id, e
+            "Signer #{}: Received a signature error: {e:?}",
+            self.signer_id
         );
         match e {
             SignError::NonceTimeout(_valid_signers, _malicious_signers) => {
@@ -969,8 +972,8 @@ impl Signer {
                     RejectCode::InsufficientSigners(malicious_signers.clone()),
                 );
                 debug!(
-                    "Signer #{}: Insufficient signers for block; send rejection {:?}",
-                    self.signer_id, &block_rejection
+                    "Signer #{}: Insufficient signers for block; send rejection {block_rejection:?}",
+                    self.signer_id
                 );
                 // Submit signature result to miners to observe
                 if let Err(e) = self
@@ -978,15 +981,15 @@ impl Signer {
                     .send_message_with_retry(block_rejection.into())
                 {
                     warn!(
-                        "Signer #{}: Failed to send block submission to stacker-db: {:?}",
-                        self.signer_id, e
+                        "Signer #{}: Failed to send block submission to stacker-db: {e:?}",
+                        self.signer_id
                     );
                 }
             }
             SignError::Aggregator(e) => {
                 warn!(
-                    "Signer #{}: Received an aggregator error: {:?}",
-                    self.signer_id, e
+                    "Signer #{}: Received an aggregator error: {e:?}",
+                    self.signer_id
                 );
             }
         }
@@ -1009,8 +1012,8 @@ impl Signer {
             }
             Err(e) => {
                 warn!(
-                    "Signer #{}: Failed to send {} operation results: {:?}",
-                    self.signer_id, nmb_results, e
+                    "Signer #{}: Failed to send {nmb_results} operation results: {e:?}",
+                    self.signer_id
                 );
             }
         }
@@ -1026,11 +1029,11 @@ impl Signer {
         for msg in outbound_messages {
             let ack = self.stackerdb.send_message_with_retry(msg.into());
             if let Ok(ack) = ack {
-                debug!("Signer #{}: send outbound ACK: {:?}", self.signer_id, ack);
+                debug!("Signer #{}: send outbound ACK: {ack:?}", self.signer_id);
             } else {
                 warn!(
-                    "Signer #{}: Failed to send message to stacker-db instance: {:?}",
-                    self.signer_id, ack
+                    "Signer #{}: Failed to send message to stacker-db instance: {ack:?}",
+                    self.signer_id
                 );
             }
         }
@@ -1088,7 +1091,7 @@ impl Signer {
             self.state = State::TenureExceeded;
             return Ok(());
         }
-        debug!("Signer #{}: Processing event: {:?}", self.signer_id, event);
+        debug!("Signer #{}: Processing event: {event:?}", self.signer_id);
         match event {
             Some(SignerEvent::BlockValidationResponse(block_validate_response)) => {
                 debug!(

From 6d352deecb1235fb3bb7da28e84b7627712282e2 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 7 Feb 2024 15:16:06 -0800
Subject: [PATCH 0861/1166] Fix relative path for reward set

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/stacks_client.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index 5549c71a8e..3447dfac5f 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -622,7 +622,7 @@ impl StacksClient {
     }
 
     fn reward_set_path(&self, reward_cycle: u64) -> String {
-        format!("/v2/stacker_set/{reward_cycle}")
+        format!("{}/v2/stacker_set/{reward_cycle}", self.http_origin)
     }
 
     /// Helper function to create a stacks transaction for a modifying contract call

From 42b7342f4968c4b053b2d29ee9576c07cbf3f686 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 7 Feb 2024 15:40:25 -0800
Subject: [PATCH 0862/1166] Fix get stackers response

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/stacks_client.rs | 38 +++++++++++++++++++++--
 1 file changed, 35 insertions(+), 3 deletions(-)

diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index 3447dfac5f..f84ed44d69 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -29,6 +29,7 @@ use blockstack_lib::net::api::callreadonly::CallReadOnlyResponse;
 use blockstack_lib::net::api::getaccount::AccountEntryResponse;
 use blockstack_lib::net::api::getinfo::RPCPeerInfoData;
 use blockstack_lib::net::api::getpoxinfo::RPCPoxInfoData;
+use blockstack_lib::net::api::getstackers::GetStackersResponse;
 use blockstack_lib::net::api::postblock_proposal::NakamotoBlockProposal;
 use blockstack_lib::util_lib::boot::{boot_code_addr, boot_code_id};
 use clarity::vm::types::{PrincipalData, QualifiedContractIdentifier};
@@ -363,7 +364,7 @@ impl StacksClient {
     }
     /// Get the reward set from the stacks node for the given reward cycle
     pub fn get_reward_set(&self, reward_cycle: u64) -> Result<RewardSet, ClientError> {
-        debug!("Getting reward set for {reward_cycle}...");
+        debug!("Getting reward set for reward cycle {reward_cycle}...");
         let send_request = || {
             self.stacks_node_client
                 .get(self.reward_set_path(reward_cycle))
@@ -374,8 +375,8 @@ impl StacksClient {
         if !response.status().is_success() {
             return Err(ClientError::RequestFailure(response.status()));
         }
-        let reward_set = response.json::<RewardSet>()?;
-        Ok(reward_set)
+        let stackers_response = response.json::<GetStackersResponse>()?;
+        Ok(stackers_response.stacker_set)
     }
 
     // Helper function to retrieve the pox data from the stacks node
@@ -683,6 +684,8 @@ mod tests {
     use std::thread::spawn;
 
     use blockstack_lib::chainstate::nakamoto::NakamotoBlockHeader;
+    use blockstack_lib::chainstate::stacks::address::PoxAddress;
+    use blockstack_lib::chainstate::stacks::boot::{NakamotoSignerEntry, PoxStartCycleInfo};
     use blockstack_lib::chainstate::stacks::ThresholdSignature;
     use rand::distributions::Standard;
     use rand::{thread_rng, Rng};
@@ -1208,6 +1211,35 @@ mod tests {
         assert_eq!(h.join().unwrap().unwrap(), round);
     }
 
+    #[test]
+    fn get_reward_set_should_succeed() {
+        let mock = MockServerClient::new();
+        let point = Point::from(Scalar::random(&mut rand::thread_rng())).compress();
+        let mut bytes = [0u8; 33];
+        bytes.copy_from_slice(point.as_bytes());
+        let stacker_set = RewardSet {
+            rewarded_addresses: vec![PoxAddress::standard_burn_address(false)],
+            start_cycle_state: PoxStartCycleInfo {
+                missed_reward_slots: vec![],
+            },
+            signers: Some(vec![NakamotoSignerEntry {
+                signing_key: bytes,
+                stacked_amt: rand::thread_rng().next_u64() as u128,
+                slots: 1,
+            }]),
+        };
+        let stackers_response = GetStackersResponse {
+            stacker_set: stacker_set.clone(),
+        };
+
+        let stackers_response_json = serde_json::to_string(&stackers_response)
+            .expect("Failed to serialize get stacker response");
+        let response = format!("HTTP/1.1 200 OK\n\n{stackers_response_json}");
+        let h = spawn(move || mock.client.get_reward_set(0));
+        write_response(mock.server, response.as_bytes());
+        assert_eq!(h.join().unwrap().unwrap(), stacker_set);
+    }
+
     #[test]
     #[serial]
     fn get_reward_set_calculated() {

From ce6be782138765faea6ae60c3edb12673dd4acf8 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 7 Feb 2024 15:55:05 -0800
Subject: [PATCH 0863/1166] Run DKG even if out of vote window

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/stacks_client.rs | 64 -----------------------
 stacks-signer/src/runloop.rs              |  2 +
 stacks-signer/src/signer.rs               | 15 ++----
 3 files changed, 7 insertions(+), 74 deletions(-)

diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index f84ed44d69..8639426555 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -345,23 +345,6 @@ impl StacksClient {
         Ok(pox_info.next_cycle.prepare_phase_start_block_height < stacks_tip_height)
     }
 
-    /// Check whether the given reward cycle is in the prepare phase
-    pub fn reward_cycle_in_vote_window(&self, reward_cycle: u64) -> Result<bool, ClientError> {
-        let pox_info = self.get_pox_data()?;
-        if reward_cycle == pox_info.reward_cycle_id.wrapping_add(1) {
-            let peer_info = self.get_peer_info()?;
-            let stacks_tip_height = peer_info.stacks_tip_height;
-            // The vote window starts at the second block of the prepare phase hence the + 1.
-            let vote_window_start = pox_info
-                .next_cycle
-                .prepare_phase_start_block_height
-                .wrapping_add(1);
-            Ok(stacks_tip_height >= vote_window_start)
-        } else {
-            // We are not in the prepare phase of the reward cycle as the upcoming cycle does not match
-            Ok(false)
-        }
-    }
     /// Get the reward set from the stacks node for the given reward cycle
     pub fn get_reward_set(&self, reward_cycle: u64) -> Result<RewardSet, ClientError> {
         debug!("Getting reward set for reward cycle {reward_cycle}...");
@@ -1287,53 +1270,6 @@ mod tests {
         assert!(!h.join().unwrap().unwrap());
     }
 
-    #[test]
-    #[serial]
-    fn reward_cycle_in_vote_window() {
-        let consensus_hash = "64c8c3049ff6b939c65828e3168210e6bb32d880".to_string();
-
-        // Should return FALSE as the passed in reward cycle is old
-        let mock = MockServerClient::new();
-        let pox_response = build_get_pox_data_response(2, 10);
-        let h = spawn(move || mock.client.reward_cycle_in_vote_window(0));
-        write_response(mock.server, pox_response.as_bytes());
-        assert!(!h.join().unwrap().unwrap());
-
-        // Should return FALSE as the passed in reward cycle is NEWER than the NEXT reward cycle of the node
-        let mock = MockServerClient::new();
-        let pox_response = build_get_pox_data_response(2, 10);
-        let h = spawn(move || mock.client.reward_cycle_in_vote_window(4));
-        write_response(mock.server, pox_response.as_bytes());
-        assert!(!h.join().unwrap().unwrap());
-
-        // Should return FALSE as the passed in reward cycle is the same as the current reward cycle
-        let mock = MockServerClient::new();
-        let pox_response = build_get_pox_data_response(2, 10);
-        let h = spawn(move || mock.client.reward_cycle_in_vote_window(2));
-        write_response(mock.server, pox_response.as_bytes());
-        assert!(!h.join().unwrap().unwrap());
-
-        // Should return FALSE as the passed in reward cycle is the NEXT reward cycle BUT the prepare phase is in its FIRST block
-        let mock = MockServerClient::new();
-        let pox_response = build_get_pox_data_response(2, 11);
-        let peer_response = build_get_peer_info_response(11, consensus_hash.clone());
-        let h = spawn(move || mock.client.reward_cycle_in_vote_window(3));
-        write_response(mock.server, pox_response.as_bytes());
-        let mock = MockServerClient::from_config(mock.config);
-        write_response(mock.server, peer_response.as_bytes());
-        assert!(!h.join().unwrap().unwrap());
-
-        // Should return TRUE as the passed in reward cycle is the NEXT reward cycle AND the prepare phase is in its SECOND block
-        let mock = MockServerClient::new();
-        let pox_response = build_get_pox_data_response(2, 10);
-        let peer_response = build_get_peer_info_response(11, consensus_hash.clone());
-        let h = spawn(move || mock.client.reward_cycle_in_vote_window(3));
-        write_response(mock.server, pox_response.as_bytes());
-        let mock = MockServerClient::from_config(mock.config);
-        write_response(mock.server, peer_response.as_bytes());
-        assert!(h.join().unwrap().unwrap());
-    }
-
     fn generate_random_consensus_hash() -> String {
         let rng = rand::thread_rng();
         let bytes: Vec<u8> = rng.sample_iter(Standard).take(20).collect();
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 1d33e7278e..c71c2723d1 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -243,6 +243,8 @@ impl RunLoop {
             if self.stacks_signers.is_empty() {
                 info!("Signer is not registered for the current or next reward cycle. Waiting for confirmed registration...");
                 return Err(backoff::Error::transient(ClientError::NotRegistered));
+            } else {
+                info!("Runloop successfully initialized!");
             }
             self.state = State::Initialized;
             Ok(())
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index e11b778f88..f688a7c94e 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -1041,31 +1041,26 @@ impl Signer {
 
     /// Update the DKG for the provided signer info, triggering it if required
     pub fn update_dkg(&mut self) -> Result<(), ClientError> {
+        debug!("Signer #{}: Checking DKG...", self.signer_id);
         let reward_cycle = self.reward_cycle;
         let aggregate_public_key = self.stacks_client.get_aggregate_public_key(reward_cycle)?;
-        let in_vote_window = self
-            .stacks_client
-            .reward_cycle_in_vote_window(reward_cycle)?;
         self.coordinator
             .set_aggregate_public_key(aggregate_public_key);
         let coordinator_id = self
             .stacks_client
             .calculate_coordinator(&self.signing_round.public_keys)
             .0;
-        // TODO: should we attempt to vote anyway if out of window? what if we didn't successfully run DKG in prepare phase?
-        if in_vote_window
-            && aggregate_public_key.is_none()
+        if aggregate_public_key.is_none()
             && self.signer_id == coordinator_id
             && self.coordinator.state == CoordinatorState::Idle
         {
-            info!("Signer is the coordinator and is in the prepare phase for reward cycle {reward_cycle}. Triggering a DKG round...");
+            info!("Signer #{}: Is the current coordinator for {reward_cycle}. Triggering a DKG round...", self.signer_id);
             self.commands.push_back(Command::Dkg);
         } else {
-            debug!("Not updating dkg";
-                "in_vote_window" => in_vote_window,
+            debug!("Signer #{}: Not triggering a DKG round.", self.signer_id;
                 "aggregate_public_key" => aggregate_public_key.is_some(),
-                "signer_id" => self.signer_id,
                 "coordinator_id" => coordinator_id,
+                "coordinator_idle" => self.coordinator.state == CoordinatorState::Idle,
             );
         }
         Ok(())

From f1a7a32c37a1c02db6c126629328239ca4cefbef Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 7 Feb 2024 16:07:24 -0800
Subject: [PATCH 0864/1166] Parse msg id and signer set out of the event
 conract id

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 libsigner/src/events.rs     | 42 ++++++++++++++++++++++++++++++++++---
 stacks-signer/src/signer.rs |  4 ++--
 2 files changed, 41 insertions(+), 5 deletions(-)

diff --git a/libsigner/src/events.rs b/libsigner/src/events.rs
index 849bb92902..dfc2557877 100644
--- a/libsigner/src/events.rs
+++ b/libsigner/src/events.rs
@@ -343,8 +343,11 @@ fn process_stackerdb_event(
     } else if event.contract_id.name.to_string().starts_with(SIGNERS_NAME)
         && event.contract_id.issuer.1 == [0u8; 20]
     {
-        // TODO: check contract id first u8 to determine if its even or odd reward cycle
-        let reward_cycle_modulus = 0;
+        let Some((signer_set, _)) =
+            get_signers_db_signer_set_message_id(event.contract_id.name.as_str())
+        else {
+            return Err(EventError::UnrecognizedStackerDBContract(event.contract_id));
+        };
         // signer-XXX-YYY boot contract
         let signer_messages: Vec<SignerMessage> = event
             .modified_slots
@@ -352,7 +355,7 @@ fn process_stackerdb_event(
             .filter_map(|chunk| read_next::<SignerMessage, _>(&mut &chunk.data[..]).ok())
             .collect();
         //
-        SignerEvent::SignerMessages(reward_cycle_modulus, signer_messages)
+        SignerEvent::SignerMessages(signer_set, signer_messages)
     } else {
         info!(
             "[{:?}] next_event got event from an unexpected contract id {}, return OK so other side doesn't keep sending this",
@@ -397,3 +400,36 @@ fn process_proposal_response(mut request: HttpRequest) -> Result<SignerEvent, Ev
 
     Ok(SignerEvent::BlockValidationResponse(event))
 }
+
+fn get_signers_db_signer_set_message_id(name: &str) -> Option<(u32, u32)> {
+    // Splitting the string by '-'
+    let parts: Vec<&str> = name.split('-').collect();
+    if parts.len() != 3 {
+        return None;
+    }
+    // Extracting message ID and slot ID
+    let signer_set = parts[1].parse::<u32>().ok()?;
+    let message_id = parts[2].parse::<u32>().ok()?;
+    Some((signer_set, message_id))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_get_signers_db_signer_set_message_id() {
+        let name = "signer-1-1";
+        let (signer_set, message_id) = get_signers_db_signer_set_message_id(name).unwrap();
+        assert_eq!(signer_set, 1);
+        assert_eq!(message_id, 1);
+
+        let name = "signer-0-2";
+        let (signer_set, message_id) = get_signers_db_signer_set_message_id(name).unwrap();
+        assert_eq!(signer_set, 0);
+        assert_eq!(message_id, 2);
+
+        let name = "signer--2";
+        assert!(get_signers_db_signer_set_message_id(name).is_none());
+    }
+}
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index f688a7c94e..8a63ec9d57 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -1095,8 +1095,8 @@ impl Signer {
                 );
                 self.handle_block_validate_response(block_validate_response, res)
             }
-            Some(SignerEvent::SignerMessages(reward_index, messages)) => {
-                if *reward_index != self.stackerdb.get_signer_set() {
+            Some(SignerEvent::SignerMessages(signer_set, messages)) => {
+                if *signer_set != self.stackerdb.get_signer_set() {
                     debug!("Signer #{}: Received a signer message for a reward cycle that do not belong to this signer. Ignoring...", self.signer_id);
                     return Ok(());
                 }

From 10e9bdc71d6d55f90d94b65296b90c8f25b3a564 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 7 Feb 2024 16:56:51 -0800
Subject: [PATCH 0865/1166] Pass a reference to stacks client to the sub
 signers

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/runloop.rs |  13 ++--
 stacks-signer/src/signer.rs  | 121 +++++++++++++++++++----------------
 2 files changed, 76 insertions(+), 58 deletions(-)

diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index c71c2723d1..baa5bcc9d5 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -211,11 +211,13 @@ impl RunLoop {
         if needs_refresh {
             let new_reward_cycle_config = self.get_reward_cycle_config(reward_cycle)?;
             if let Some(new_reward_cycle_config) = new_reward_cycle_config {
-                debug!("Signer is registered for reward cycle {reward_cycle}. Initializing signer state.");
+                let signer_id = new_reward_cycle_config.signer_id;
+                debug!("Signer is registered for reward cycle {reward_cycle} as signer #{signer_id}. Initializing signer state.");
                 self.stacks_signers.insert(
                     reward_index,
                     Signer::from_configs(&self.config, new_reward_cycle_config),
                 );
+                debug!("Signer #{signer_id} for reward cycle {reward_cycle} initialized. Initialized {} signers", self.stacks_signers.len());
             } else {
                 // Nothing to initialize. Signer is not registered for this reward cycle
                 debug!("Signer is not registered for reward cycle {reward_cycle}. Nothing to initialize.");
@@ -236,8 +238,9 @@ impl RunLoop {
             self.refresh_signer_config(current_reward_cycle)?;
             self.refresh_signer_config(next_reward_cycle)?;
             for stacks_signer in self.stacks_signers.values_mut() {
+                debug!("Signer #{}: Checking DKG...", stacks_signer.signer_id);
                 stacks_signer
-                    .update_dkg()
+                    .update_dkg(&self.stacks_client)
                     .map_err(backoff::Error::transient)?;
             }
             if self.stacks_signers.is_empty() {
@@ -315,14 +318,16 @@ impl SignerRunLoop<Vec<OperationResult>, RunLoopCommand> for RunLoop {
             }
         }
         for stacks_signer in self.stacks_signers.values_mut() {
-            if let Err(e) = stacks_signer.process_event(event.as_ref(), res.clone()) {
+            if let Err(e) =
+                stacks_signer.process_event(&self.stacks_client, event.as_ref(), res.clone())
+            {
                 error!(
                     "Signer #{} for reward cycle {} errored processing event: {e}",
                     stacks_signer.signer_id, stacks_signer.reward_cycle
                 );
             }
             // After processing event, run the next command for each signer
-            stacks_signer.process_next_command();
+            stacks_signer.process_next_command(&self.stacks_client);
         }
         // Cleanup any stale signers
         self.cleanup_stale_signers();
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index 8a63ec9d57..1c4ae38d8a 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -127,8 +127,6 @@ pub struct Signer {
     pub commands: VecDeque<Command>,
     /// The stackerdb client
     pub stackerdb: StackerDB,
-    /// The stacks client
-    pub stacks_client: StacksClient,
     /// Whether the signer is a mainnet signer or not
     pub is_mainnet: bool,
     /// The signer id
@@ -143,7 +141,6 @@ impl Signer {
     /// Create a new stacks signer
     pub fn from_configs(config: &GlobalConfig, reward_cycle_config: RewardCycleConfig) -> Self {
         let stackerdb = StackerDB::from_configs(config, &reward_cycle_config);
-        let stacks_client = StacksClient::from(config);
 
         let num_signers = u32::try_from(reward_cycle_config.public_keys.signers.len())
             .expect("FATAL: Too many registered signers to fit in a u32");
@@ -191,8 +188,7 @@ impl Signer {
             blocks: HashMap::new(),
             commands: VecDeque::new(),
             stackerdb,
-            stacks_client,
-            is_mainnet: config.network.is_mainnet(), // will be updated on .initialize()
+            is_mainnet: config.network.is_mainnet(),
             signer_id: reward_cycle_config.signer_id,
             signer_addresses: reward_cycle_config.signer_addresses,
             reward_cycle: reward_cycle_config.reward_cycle,
@@ -202,16 +198,6 @@ impl Signer {
     /// Execute the given command and update state accordingly
     /// Returns true when it is successfully executed, else false
     fn execute_command(&mut self, command: &Command) -> bool {
-        let (coordinator_id, _) = self
-            .stacks_client
-            .calculate_coordinator(&self.signing_round.public_keys);
-        if coordinator_id != self.signer_id {
-            warn!(
-                "Signer #{}: Not the coordinator. Ignoring command {command:?}.",
-                self.signer_id
-            );
-            return false;
-        }
         match command {
             Command::Dkg => {
                 info!("Signer #{}: Starting DKG", self.signer_id);
@@ -278,9 +264,19 @@ impl Signer {
     }
 
     /// Attempt to process the next command in the queue, and update state accordingly
-    pub fn process_next_command(&mut self) {
+    pub fn process_next_command(&mut self, stacks_client: &StacksClient) {
         match self.state {
             State::Idle => {
+                let (coordinator_id, _) =
+                    stacks_client.calculate_coordinator(&self.signing_round.public_keys);
+                if coordinator_id != self.signer_id {
+                    warn!(
+                        "Signer #{}: Not the coordinator. Will not process any commands...",
+                        self.signer_id
+                    );
+                    return;
+                }
+
                 if let Some(command) = self.commands.pop_front() {
                     while !self.execute_command(&command) {
                         warn!(
@@ -316,6 +312,7 @@ impl Signer {
     /// Handle the block validate response returned from our prior calls to submit a block for validation
     fn handle_block_validate_response(
         &mut self,
+        stacks_client: &StacksClient,
         block_validate_response: &BlockValidateResponse,
         res: Sender<Vec<OperationResult>>,
     ) {
@@ -328,7 +325,7 @@ impl Signer {
                     debug!("Received a block validate response for a block we have not seen before. Ignoring...");
                     return;
                 };
-                let is_valid = self.verify_transactions(&block_info.block);
+                let is_valid = self.verify_transactions(stacks_client, &block_info.block);
                 block_info.valid = Some(is_valid);
                 info!(
                     "Signer #{}: Treating block validation for block {} as valid: {:?}",
@@ -374,11 +371,10 @@ impl Signer {
                 msg: Message::NonceRequest(nonce_request),
                 sig: vec![],
             };
-            self.handle_packets(res, &[packet]);
+            self.handle_packets(stacks_client, res, &[packet]);
         } else {
-            let (coordinator_id, _) = self
-                .stacks_client
-                .calculate_coordinator(&self.signing_round.public_keys);
+            let (coordinator_id, _) =
+                stacks_client.calculate_coordinator(&self.signing_round.public_keys);
             if block_info.valid.unwrap_or(false)
                 && !block_info.signed_over
                 && coordinator_id == self.signer_id
@@ -409,12 +405,12 @@ impl Signer {
     /// Handle signer messages submitted to signers stackerdb
     fn handle_signer_messages(
         &mut self,
+        stacks_client: &StacksClient,
         res: Sender<Vec<OperationResult>>,
         messages: &[SignerMessage],
     ) {
-        let (coordinator_id, coordinator_public_key) = self
-            .stacks_client
-            .calculate_coordinator(&self.signing_round.public_keys);
+        let (coordinator_id, coordinator_public_key) =
+            stacks_client.calculate_coordinator(&self.signing_round.public_keys);
         debug!(
             "Signer #{}: coordinator is signer #{} public key {}",
             self.signer_id, coordinator_id, &coordinator_public_key
@@ -424,15 +420,15 @@ impl Signer {
             .filter_map(|msg| match msg {
                 SignerMessage::BlockResponse(_) | SignerMessage::Transactions(_) => None,
                 SignerMessage::Packet(packet) => {
-                    self.verify_packet(packet.clone(), &coordinator_public_key)
+                    self.verify_packet(stacks_client, packet.clone(), &coordinator_public_key)
                 }
             })
             .collect();
-        self.handle_packets(res, &packets);
+        self.handle_packets(stacks_client, res, &packets);
     }
 
     /// Handle proposed blocks submitted by the miners to stackerdb
-    fn handle_proposed_blocks(&mut self, blocks: &[NakamotoBlock]) {
+    fn handle_proposed_blocks(&mut self, stacks_client: &StacksClient, blocks: &[NakamotoBlock]) {
         for block in blocks {
             // Store the block in our cache
             self.blocks.insert(
@@ -440,7 +436,7 @@ impl Signer {
                 BlockInfo::new(block.clone()),
             );
             // Submit the block for validation
-            self.stacks_client
+            stacks_client
                 .submit_block_for_validation(block.clone())
                 .unwrap_or_else(|e| {
                     warn!("Failed to submit block for validation: {e:?}");
@@ -450,7 +446,12 @@ impl Signer {
 
     /// Process inbound packets as both a signer and a coordinator
     /// Will send outbound packets and operation results as appropriate
-    fn handle_packets(&mut self, res: Sender<Vec<OperationResult>>, packets: &[Packet]) {
+    fn handle_packets(
+        &mut self,
+        stacks_client: &StacksClient,
+        res: Sender<Vec<OperationResult>>,
+        packets: &[Packet],
+    ) {
         let signer_outbound_messages = self
             .signing_round
             .process_inbound_messages(packets)
@@ -472,7 +473,7 @@ impl Signer {
             // We have finished a signing or DKG round, either successfully or due to error.
             // Regardless of the why, update our state to Idle as we should not expect the operation to continue.
             self.state = State::Idle;
-            self.process_operation_results(&operation_results);
+            self.process_operation_results(stacks_client, &operation_results);
             self.send_operation_results(res, operation_results);
         }
         self.send_outbound_messages(signer_outbound_messages);
@@ -533,7 +534,11 @@ impl Signer {
     /// If the request is for a block, we will update the request message
     /// as either a hash indicating a vote no or the signature hash indicating a vote yes
     /// Returns whether the request is valid or not
-    fn validate_nonce_request(&mut self, nonce_request: &mut NonceRequest) -> bool {
+    fn validate_nonce_request(
+        &mut self,
+        stacks_client: &StacksClient,
+        nonce_request: &mut NonceRequest,
+    ) -> bool {
         let Some(block) = read_next::<NakamotoBlock, _>(&mut &nonce_request.message[..]).ok()
         else {
             // We currently reject anything that is not a block
@@ -552,7 +557,7 @@ impl Signer {
                 signer_signature_hash,
                 BlockInfo::new_with_request(block.clone(), nonce_request.clone()),
             );
-            self.stacks_client
+            stacks_client
                 .submit_block_for_validation(block)
                 .unwrap_or_else(|e| {
                     warn!(
@@ -575,8 +580,8 @@ impl Signer {
     }
 
     /// Verify the transactions in a block are as expected
-    fn verify_transactions(&mut self, block: &NakamotoBlock) -> bool {
-        if let Ok(expected_transactions) = self.get_expected_transactions() {
+    fn verify_transactions(&mut self, stacks_client: &StacksClient, block: &NakamotoBlock) -> bool {
+        if let Ok(expected_transactions) = self.get_expected_transactions(stacks_client) {
             //It might be worth building a hashset of the blocks' txids and checking that against the expected transaction's txid.
             let block_tx_hashset = block.txs.iter().map(|tx| tx.txid()).collect::<HashSet<_>>();
             // Ensure the block contains the transactions we expect
@@ -644,7 +649,10 @@ impl Signer {
     }
 
     /// Get the transactions we expect to see in the next block
-    fn get_expected_transactions(&mut self) -> Result<Vec<StacksTransaction>, ClientError> {
+    fn get_expected_transactions(
+        &mut self,
+        stacks_client: &StacksClient,
+    ) -> Result<Vec<StacksTransaction>, ClientError> {
         let signer_ids = self
             .signing_round
             .public_keys
@@ -658,7 +666,7 @@ impl Signer {
                     // Filter out transactions that have already been confirmed (can happen if a signer did not update stacker db since the last block was processed)
                     let origin_address = transaction.origin_address();
                     let origin_nonce = transaction.get_origin_nonce();
-                    let Ok(account_nonce) = self.stacks_client.get_account_nonce(&origin_address) else {
+                    let Ok(account_nonce) = stacks_client.get_account_nonce(&origin_address) else {
                         warn!("Signer #{}: Unable to get account for address: {origin_address}. Ignoring it for this block...", self.signer_id);
                         return None;
                     };
@@ -734,6 +742,7 @@ impl Signer {
     /// agreed upon and to support the case where the signer wishes to reject a block by voting no
     fn verify_packet(
         &mut self,
+        stacks_client: &StacksClient,
         mut packet: Packet,
         coordinator_public_key: &PublicKey,
     ) -> Option<Packet> {
@@ -746,7 +755,7 @@ impl Signer {
                     }
                 }
                 Message::NonceRequest(request) => {
-                    if !self.validate_nonce_request(request) {
+                    if !self.validate_nonce_request(stacks_client, request) {
                         return None;
                     }
                 }
@@ -766,7 +775,11 @@ impl Signer {
 
     /// Processes the operation results, broadcasting block acceptance or rejection messages
     /// and DKG vote results accordingly
-    fn process_operation_results(&mut self, operation_results: &[OperationResult]) {
+    fn process_operation_results(
+        &mut self,
+        stacks_client: &StacksClient,
+        operation_results: &[OperationResult],
+    ) {
         for operation_result in operation_results {
             // Signers only every trigger non-taproot signing rounds over blocks. Ignore SignTaproot results
             match operation_result {
@@ -779,8 +792,7 @@ impl Signer {
                 }
                 OperationResult::Dkg(point) => {
                     // Broadcast via traditional methods to the stacks node if we are pre nakamoto or we cannot determine our Epoch
-                    let epoch = self
-                        .stacks_client
+                    let epoch = stacks_client
                         .get_node_epoch()
                         .unwrap_or(EpochId::UnsupportedEpoch);
                     let new_transaction = match epoch {
@@ -791,7 +803,7 @@ impl Signer {
                         EpochId::Epoch25 => {
                             debug!("Signer #{}: Received a DKG result, but are in epoch 2.5. Broadcast the transaction to the mempool.", self.signer_id);
                             match retry_with_exponential_backoff(|| {
-                                self.stacks_client
+                                stacks_client
                                     .cast_vote_for_aggregate_public_key(
                                         self.reward_cycle,
                                         self.stackerdb.get_signer_slot_id(),
@@ -815,7 +827,7 @@ impl Signer {
                         EpochId::Epoch30 => {
                             debug!("Signer #{}: Received a DKG result, but are in epoch 3. Broadcast the transaction to stackerDB.", self.signer_id);
                             match retry_with_exponential_backoff(|| {
-                                self.stacks_client
+                                stacks_client
                                     .build_vote_for_aggregate_public_key(
                                         self.reward_cycle,
                                         self.stackerdb.get_signer_slot_id(),
@@ -842,7 +854,7 @@ impl Signer {
                     let mut new_transactions: Vec<_> = old_transactions.into_iter().filter_map(|transaction|  {
                         let origin_address = transaction.origin_address();
                         let origin_nonce = transaction.get_origin_nonce();
-                        let Ok(account_nonce) = retry_with_exponential_backoff(|| self.stacks_client.get_account_nonce(&origin_address).map_err(backoff::Error::transient)) else {
+                        let Ok(account_nonce) = retry_with_exponential_backoff(|| stacks_client.get_account_nonce(&origin_address).map_err(backoff::Error::transient)) else {
                             warn!("Signer #{}: Unable to get account for address: {origin_address}. Removing {} from our stored transactions.", self.signer_id, transaction.txid());
                             return None;
                         };
@@ -1040,14 +1052,12 @@ impl Signer {
     }
 
     /// Update the DKG for the provided signer info, triggering it if required
-    pub fn update_dkg(&mut self) -> Result<(), ClientError> {
-        debug!("Signer #{}: Checking DKG...", self.signer_id);
+    pub fn update_dkg(&mut self, stacks_client: &StacksClient) -> Result<(), ClientError> {
         let reward_cycle = self.reward_cycle;
-        let aggregate_public_key = self.stacks_client.get_aggregate_public_key(reward_cycle)?;
+        let aggregate_public_key = stacks_client.get_aggregate_public_key(reward_cycle)?;
         self.coordinator
             .set_aggregate_public_key(aggregate_public_key);
-        let coordinator_id = self
-            .stacks_client
+        let coordinator_id = stacks_client
             .calculate_coordinator(&self.signing_round.public_keys)
             .0;
         if aggregate_public_key.is_none()
@@ -1069,11 +1079,12 @@ impl Signer {
     /// Process the event
     pub fn process_event(
         &mut self,
+        stacks_client: &StacksClient,
         event: Option<&SignerEvent>,
         res: Sender<Vec<OperationResult>>,
     ) -> Result<(), ClientError> {
         let current_reward_cycle = retry_with_exponential_backoff(|| {
-            self.stacks_client
+            stacks_client
                 .get_current_reward_cycle()
                 .map_err(backoff::Error::transient)
         })?;
@@ -1093,7 +1104,7 @@ impl Signer {
                     "Signer #{}: Received a block proposal result from the stacks node...",
                     self.signer_id
                 );
-                self.handle_block_validate_response(block_validate_response, res)
+                self.handle_block_validate_response(stacks_client, block_validate_response, res)
             }
             Some(SignerEvent::SignerMessages(signer_set, messages)) => {
                 if *signer_set != self.stackerdb.get_signer_set() {
@@ -1105,7 +1116,7 @@ impl Signer {
                     self.signer_id,
                     messages.len()
                 );
-                self.handle_signer_messages(res, messages);
+                self.handle_signer_messages(stacks_client, res, messages);
             }
             Some(SignerEvent::ProposedBlocks(blocks)) => {
                 if current_reward_cycle != self.reward_cycle {
@@ -1118,7 +1129,7 @@ impl Signer {
                     self.signer_id,
                     blocks.len()
                 );
-                self.handle_proposed_blocks(blocks);
+                self.handle_proposed_blocks(stacks_client, blocks);
             }
             Some(SignerEvent::StatusCheck) => {
                 debug!("Signer #{}: Received a status check event.", self.signer_id)
@@ -1171,6 +1182,7 @@ mod tests {
                     .expect("Failed to create public key."),
             ),
         );
+        let stacks_client = StacksClient::from(&config);
         let mut signer = Signer::from_configs(&config, reward_cycle_info);
 
         let signer_private_key = config.stacks_private_key;
@@ -1266,7 +1278,7 @@ mod tests {
         ];
         let num_transactions = transactions.len();
 
-        let h = spawn(move || signer.get_expected_transactions().unwrap());
+        let h = spawn(move || signer.get_expected_transactions(&stacks_client).unwrap());
 
         // Simulate the response to the request for transactions
         let signer_message = SignerMessage::Transactions(transactions);
@@ -1326,6 +1338,7 @@ mod tests {
                     .expect("Failed to create public key."),
             ),
         );
+        let stacks_client = StacksClient::from(&config);
         let mut signer = Signer::from_configs(&config, reward_cycle_info);
 
         let signer_private_key = config.stacks_private_key;
@@ -1380,7 +1393,7 @@ mod tests {
             BlockInfo::new(block.clone()),
         );
 
-        let h = spawn(move || signer.verify_transactions(&block));
+        let h = spawn(move || signer.verify_transactions(&stacks_client, &block));
 
         // Simulate the response to the request for transactions with the expected transaction
         let signer_message = SignerMessage::Transactions(vec![valid_tx]);

From d2862ce22debd4fbab55e5bca2b951b0d748c572 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 7 Feb 2024 17:16:31 -0800
Subject: [PATCH 0866/1166] Fix infinite waiting for next reward cycle

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/runloop.rs | 69 ++++++++++++++++++++++--------------
 1 file changed, 43 insertions(+), 26 deletions(-)

diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index baa5bcc9d5..b6a4605370 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -80,17 +80,12 @@ impl RunLoop {
     fn get_reward_cycle_config(
         &mut self,
         reward_cycle: u64,
-    ) -> Result<Option<RewardCycleConfig>, backoff::Error<ClientError>> {
-        let reward_set_calculated = self
-            .stacks_client
-            .reward_set_calculated(reward_cycle)
-            .map_err(backoff::Error::transient)?;
+    ) -> Result<Option<RewardCycleConfig>, ClientError> {
+        let reward_set_calculated = self.stacks_client.reward_set_calculated(reward_cycle)?;
         if !reward_set_calculated {
             // Must weight for the reward set calculation to complete
             // Accounts for Pre nakamoto by simply using the second block of a prepare phase as the criteria
-            return Err(backoff::Error::transient(
-                ClientError::RewardSetNotYetCalculated(reward_cycle),
-            ));
+            return Err(ClientError::RewardSetNotYetCalculated(reward_cycle));
         }
         let current_addr = self.stacks_client.get_signer_address();
         let mut current_signer_id = None;
@@ -102,8 +97,7 @@ impl RunLoop {
         // Get the signer writers from the stacker-db to find the signer slot id
         let Some(signer_slot_id) = self
             .stacks_client
-            .get_stackerdb_signer_slots(&signer_stackerdb_contract_id, signer_set)
-            .map_err(backoff::Error::transient)?
+            .get_stackerdb_signer_slots(&signer_stackerdb_contract_id, signer_set)?
             .iter()
             .position(|(address, _)| address == current_addr)
             .map(|pos| u32::try_from(pos).expect("FATAL: number of signers exceeds u32::MAX"))
@@ -115,11 +109,7 @@ impl RunLoop {
         };
 
         // We can only register for a reward cycle if a reward set exists. We know that it should exist due to our earlier check for reward_set_calculated
-        let Some(reward_set_signers) = self
-            .stacks_client
-            .get_reward_set(reward_cycle)
-            .map_err(backoff::Error::transient)?
-            .signers
+        let Some(reward_set_signers) = self.stacks_client.get_reward_set(reward_cycle)?.signers
         else {
             warn!(
                 "No reward set found for reward cycle {reward_cycle}. Must not be a valid Nakamoto reward cycle."
@@ -138,9 +128,9 @@ impl RunLoop {
         for (i, entry) in reward_set_signers.iter().enumerate() {
             let signer_id = u32::try_from(i).expect("FATAL: number of signers exceeds u32::MAX");
             let ecdsa_public_key = ecdsa::PublicKey::try_from(entry.signing_key.as_slice()).map_err(|e| {
-                backoff::Error::transient(ClientError::CorruptedRewardSet(format!(
+                ClientError::CorruptedRewardSet(format!(
                         "Reward cycle {reward_cycle} failed to convert signing key to ecdsa::PublicKey: {e}"
-                    )))
+                    ))
                 })?;
             let signer_public_key = Point::try_from(&Compressed::from(ecdsa_public_key.to_bytes()))
                 .map_err(|e| {
@@ -149,9 +139,9 @@ impl RunLoop {
                     )))
                 })?;
             let stacks_public_key = StacksPublicKey::from_slice(entry.signing_key.as_slice()).map_err(|e| {
-                    backoff::Error::transient(ClientError::CorruptedRewardSet(format!(
+                    ClientError::CorruptedRewardSet(format!(
                         "Reward cycle {reward_cycle} failed to convert signing key to StacksPublicKey: {e}"
-                    )))
+                    ))
                 })?;
 
             let stacks_address =
@@ -191,10 +181,7 @@ impl RunLoop {
     }
 
     /// Refresh signer configuration for a specific reward cycle
-    fn refresh_signer_config(
-        &mut self,
-        reward_cycle: u64,
-    ) -> Result<(), backoff::Error<ClientError>> {
+    fn refresh_signer_config(&mut self, reward_cycle: u64) -> Result<(), ClientError> {
         let reward_index = reward_cycle % 2;
         let mut needs_refresh = false;
         if let Some(stacks_signer) = self.stacks_signers.get_mut(&reward_index) {
@@ -234,9 +221,39 @@ impl RunLoop {
                 .stacks_client
                 .get_current_reward_cycle()
                 .map_err(backoff::Error::transient)?;
-            let next_reward_cycle = current_reward_cycle.wrapping_add(1);
-            self.refresh_signer_config(current_reward_cycle)?;
-            self.refresh_signer_config(next_reward_cycle)?;
+            let next_reward_cycle = current_reward_cycle.saturating_add(1);
+            match self.refresh_signer_config(current_reward_cycle) {
+                Ok(_) => {
+                    debug!("Signer is registered for the current reward cycle {current_reward_cycle}. Checking next reward cycle...");
+                }
+                Err(e) => match e {
+                    ClientError::NotRegistered => {
+                        debug!("Signer is NOT registered for the current reward cycle {current_reward_cycle}.");
+                    }
+                    ClientError::RewardSetNotYetCalculated(_) => {
+                        debug!("Current reward cycle {current_reward_cycle} reward set is not yet calculated. Let's retry...");
+                        return Err(backoff::Error::transient(e));
+                    }
+                    e => return Err(backoff::Error::transient(e)),
+                },
+            }
+            let next_result = self.refresh_signer_config(next_reward_cycle);
+            match next_result {
+                Ok(_) => {
+                    debug!("Signer is registered for the next reward cycle {next_reward_cycle}");
+                }
+                Err(ClientError::RewardSetNotYetCalculated(_)) => {
+                    debug!(
+                        "Next reward cycle {next_reward_cycle} reward set is not yet calculated."
+                    );
+                }
+                Err(ClientError::NotRegistered) => {
+                    debug!(
+                        "Signer is NOT registered for the next reward cycle {next_reward_cycle}."
+                    );
+                }
+                Err(e) => Err(e)?,
+            }
             for stacks_signer in self.stacks_signers.values_mut() {
                 debug!("Signer #{}: Checking DKG...", stacks_signer.signer_id);
                 stacks_signer

From 93908eace1bfb14cf154ac3823f687922b76f065 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 7 Feb 2024 17:25:51 -0800
Subject: [PATCH 0867/1166] Fix get_reward_cycle_config by adding missing
 signers addition

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/runloop.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index b6a4605370..d06288251b 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -155,6 +155,7 @@ impl RunLoop {
             weight_end = weight_start + entry.slots;
             for key_id in weight_start..weight_end {
                 public_keys.key_ids.insert(key_id, ecdsa_public_key);
+                public_keys.signers.insert(signer_id, ecdsa_public_key);
                 signer_key_ids
                     .entry(signer_id)
                     .or_insert(HashSet::with_capacity(entry.slots as usize))

From 0867611c620f78e78a5b6893651691a39f6d829d Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 7 Feb 2024 17:57:41 -0800
Subject: [PATCH 0868/1166] Move signers key ids calc to
 get_reward_cycle_config

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/mod.rs | 10 +++++++---
 stacks-signer/src/config.rs     |  6 ++++--
 stacks-signer/src/runloop.rs    | 13 ++++++++-----
 stacks-signer/src/signer.rs     | 19 +++++++------------
 4 files changed, 26 insertions(+), 22 deletions(-)

diff --git a/stacks-signer/src/client/mod.rs b/stacks-signer/src/client/mod.rs
index e3f20ecf4e..b4a33c2a09 100644
--- a/stacks-signer/src/client/mod.rs
+++ b/stacks-signer/src/client/mod.rs
@@ -273,7 +273,8 @@ pub(crate) mod tests {
         let rng = &mut OsRng;
         let num_keys = num_keys / num_signers;
         let remaining_keys = num_keys % num_signers;
-        let mut signer_key_ids = HashMap::new();
+        let mut coordinator_key_ids = HashMap::new();
+        let mut signer_key_ids = vec![];
         let mut addresses = vec![];
         let mut start_key_id = 1u32;
         let mut end_key_id = start_key_id;
@@ -300,10 +301,11 @@ pub(crate) mod tests {
                     public_keys.signers.insert(signer_id, signer_key.clone());
                     for k in start_key_id..end_key_id {
                         public_keys.key_ids.insert(k, signer_key);
-                        signer_key_ids
+                        coordinator_key_ids
                             .entry(signer_id)
                             .or_insert(HashSet::new())
                             .insert(k);
+                        signer_key_ids.push(k);
                     }
                     start_key_id = end_key_id;
                     continue;
@@ -317,10 +319,11 @@ pub(crate) mod tests {
             public_keys.signers.insert(signer_id, public_key.clone());
             for k in start_key_id..end_key_id {
                 public_keys.key_ids.insert(k, public_key);
-                signer_key_ids
+                coordinator_key_ids
                     .entry(signer_id)
                     .or_insert(HashSet::new())
                     .insert(k);
+                signer_key_ids.push(k);
             }
             let address = StacksAddress::p2pkh(
                 false,
@@ -334,6 +337,7 @@ pub(crate) mod tests {
             RewardCycleConfig {
                 public_keys,
                 signer_key_ids,
+                coordinator_key_ids,
                 signer_slot_id: 0,
                 signer_id: 0,
                 signer_set,
diff --git a/stacks-signer/src/config.rs b/stacks-signer/src/config.rs
index 9d72527385..082c613d94 100644
--- a/stacks-signer/src/config.rs
+++ b/stacks-signer/src/config.rs
@@ -124,10 +124,12 @@ pub struct RewardCycleConfig {
     pub signer_id: u32,
     /// The reward cycle of the configuration
     pub reward_cycle: u64,
+    /// The signer to key ids mapping for the coordinator
+    pub coordinator_key_ids: HashMap<u32, HashSet<u32>>,
+    /// The signer to key ids mapping for the signers
+    pub signer_key_ids: Vec<u32>,
     /// The signer ids to wsts pubilc keys mapping
     pub signer_public_keys: HashMap<u32, Point>,
-    /// The signer to key ids mapping
-    pub signer_key_ids: HashMap<u32, HashSet<u32>>,
     /// The signer addresses
     pub signer_addresses: HashSet<StacksAddress>,
     /// The public keys for the reward cycle
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index d06288251b..da2968e65f 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -118,7 +118,9 @@ impl RunLoop {
         };
 
         let mut weight_end = 1;
-        let mut signer_key_ids = HashMap::with_capacity(4000);
+        // signer uses a Vec<u32> for its key_ids, but coordinator uses a HashSet for each signer since it needs to do lots of lookups
+        let mut coordinator_key_ids = HashMap::with_capacity(4000);
+        let mut signer_key_ids = Vec::with_capacity(4000);
         let mut signer_addresses = HashSet::with_capacity(reward_set_signers.len());
         let mut public_keys = PublicKeys {
             signers: HashMap::with_capacity(reward_set_signers.len()),
@@ -134,9 +136,9 @@ impl RunLoop {
                 })?;
             let signer_public_key = Point::try_from(&Compressed::from(ecdsa_public_key.to_bytes()))
                 .map_err(|e| {
-                    backoff::Error::transient(ClientError::CorruptedRewardSet(format!(
+                    ClientError::CorruptedRewardSet(format!(
                         "Reward cycle {reward_cycle} failed to convert signing key to Point: {e}"
-                    )))
+                    ))
                 })?;
             let stacks_public_key = StacksPublicKey::from_slice(entry.signing_key.as_slice()).map_err(|e| {
                     ClientError::CorruptedRewardSet(format!(
@@ -156,10 +158,11 @@ impl RunLoop {
             for key_id in weight_start..weight_end {
                 public_keys.key_ids.insert(key_id, ecdsa_public_key);
                 public_keys.signers.insert(signer_id, ecdsa_public_key);
-                signer_key_ids
+                coordinator_key_ids
                     .entry(signer_id)
                     .or_insert(HashSet::with_capacity(entry.slots as usize))
                     .insert(key_id);
+                signer_key_ids.push(key_id);
             }
         }
         let Some(signer_id) = current_signer_id else {
@@ -175,6 +178,7 @@ impl RunLoop {
             signer_slot_id,
             signer_set,
             signer_addresses,
+            coordinator_key_ids,
             signer_key_ids,
             public_keys,
             signer_public_keys,
@@ -256,7 +260,6 @@ impl RunLoop {
                 Err(e) => Err(e)?,
             }
             for stacks_signer in self.stacks_signers.values_mut() {
-                debug!("Signer #{}: Checking DKG...", stacks_signer.signer_id);
                 stacks_signer
                     .update_dkg(&self.stacks_client)
                     .map_err(backoff::Error::transient)?;
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index 1c4ae38d8a..94fe35ff69 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -148,13 +148,6 @@ impl Signer {
             .expect("FATAL: Too many key ids to fit in a u32");
         let threshold = num_keys * 7 / 10;
         let dkg_threshold = num_keys * 9 / 10;
-        // signer uses a Vec<u32> for its key_ids, but coordinator uses a HashSet for each signer since it needs to do lots of lookups
-        let signer_key_ids: Vec<u32> = reward_cycle_config
-            .public_keys
-            .key_ids
-            .keys()
-            .cloned()
-            .collect();
 
         let coordinator_config = CoordinatorConfig {
             threshold,
@@ -167,8 +160,8 @@ impl Signer {
             dkg_end_timeout: config.dkg_end_timeout,
             nonce_timeout: config.nonce_timeout,
             sign_timeout: config.sign_timeout,
-            signer_key_ids: reward_cycle_config.signer_key_ids.clone(),
-            signer_public_keys: reward_cycle_config.signer_public_keys.clone(),
+            signer_key_ids: reward_cycle_config.coordinator_key_ids,
+            signer_public_keys: reward_cycle_config.signer_public_keys,
         };
 
         let coordinator = FireCoordinator::new(coordinator_config);
@@ -177,7 +170,7 @@ impl Signer {
             num_signers,
             num_keys,
             reward_cycle_config.signer_id,
-            signer_key_ids,
+            reward_cycle_config.signer_key_ids,
             config.ecdsa_private_key,
             reward_cycle_config.public_keys,
         );
@@ -1064,8 +1057,10 @@ impl Signer {
             && self.signer_id == coordinator_id
             && self.coordinator.state == CoordinatorState::Idle
         {
-            info!("Signer #{}: Is the current coordinator for {reward_cycle}. Triggering a DKG round...", self.signer_id);
-            self.commands.push_back(Command::Dkg);
+            info!("Signer #{} is the current coordinator for {reward_cycle}. Triggering a DKG round...", self.signer_id);
+            if self.commands.back() != Some(&Command::Dkg) {
+                self.commands.push_back(Command::Dkg);
+            }
         } else {
             debug!("Signer #{}: Not triggering a DKG round.", self.signer_id;
                 "aggregate_public_key" => aggregate_public_key.is_some(),

From 7fcbd787969ab1242afcfab3724c426ab26831a3 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 7 Feb 2024 18:11:10 -0800
Subject: [PATCH 0869/1166] Fix get_reward_cycle_config to track the specific
 signer's key ids

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/mod.rs | 13 ++++++++++---
 stacks-signer/src/config.rs     |  7 +++----
 stacks-signer/src/runloop.rs    |  9 +++++++--
 stacks-signer/src/signer.rs     |  2 +-
 4 files changed, 21 insertions(+), 10 deletions(-)

diff --git a/stacks-signer/src/client/mod.rs b/stacks-signer/src/client/mod.rs
index b4a33c2a09..e163faaf19 100644
--- a/stacks-signer/src/client/mod.rs
+++ b/stacks-signer/src/client/mod.rs
@@ -274,7 +274,7 @@ pub(crate) mod tests {
         let num_keys = num_keys / num_signers;
         let remaining_keys = num_keys % num_signers;
         let mut coordinator_key_ids = HashMap::new();
-        let mut signer_key_ids = vec![];
+        let mut signer_key_ids = HashMap::new();
         let mut addresses = vec![];
         let mut start_key_id = 1u32;
         let mut end_key_id = start_key_id;
@@ -305,7 +305,10 @@ pub(crate) mod tests {
                             .entry(signer_id)
                             .or_insert(HashSet::new())
                             .insert(k);
-                        signer_key_ids.push(k);
+                        signer_key_ids
+                            .entry(signer_id)
+                            .or_insert(Vec::new())
+                            .push(k);
                     }
                     start_key_id = end_key_id;
                     continue;
@@ -323,7 +326,10 @@ pub(crate) mod tests {
                     .entry(signer_id)
                     .or_insert(HashSet::new())
                     .insert(k);
-                signer_key_ids.push(k);
+                signer_key_ids
+                    .entry(signer_id)
+                    .or_insert(Vec::new())
+                    .push(k);
             }
             let address = StacksAddress::p2pkh(
                 false,
@@ -336,6 +342,7 @@ pub(crate) mod tests {
         (
             RewardCycleConfig {
                 public_keys,
+                key_ids: signer_key_ids.get(&0).cloned().unwrap_or_default(),
                 signer_key_ids,
                 coordinator_key_ids,
                 signer_slot_id: 0,
diff --git a/stacks-signer/src/config.rs b/stacks-signer/src/config.rs
index 082c613d94..97ae6b5559 100644
--- a/stacks-signer/src/config.rs
+++ b/stacks-signer/src/config.rs
@@ -33,9 +33,6 @@ use wsts::curve::point::Point;
 use wsts::curve::scalar::Scalar;
 use wsts::state_machine::PublicKeys;
 
-/// List of key_ids for each signer_id
-pub type SignerKeyIds = HashMap<u32, Vec<u32>>;
-
 const EVENT_TIMEOUT_MS: u64 = 5000;
 //TODO: make this zero once special cased transactions are allowed in the stacks node
 const TX_FEE_MS: u64 = 10_000;
@@ -127,13 +124,15 @@ pub struct RewardCycleConfig {
     /// The signer to key ids mapping for the coordinator
     pub coordinator_key_ids: HashMap<u32, HashSet<u32>>,
     /// The signer to key ids mapping for the signers
-    pub signer_key_ids: Vec<u32>,
+    pub signer_key_ids: HashMap<u32, Vec<u32>>,
     /// The signer ids to wsts pubilc keys mapping
     pub signer_public_keys: HashMap<u32, Point>,
     /// The signer addresses
     pub signer_addresses: HashSet<StacksAddress>,
     /// The public keys for the reward cycle
     pub public_keys: PublicKeys,
+    /// This signer's key ids
+    pub key_ids: Vec<u32>,
 }
 
 /// The parsed configuration for the signer
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index da2968e65f..7042eed39e 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -120,7 +120,7 @@ impl RunLoop {
         let mut weight_end = 1;
         // signer uses a Vec<u32> for its key_ids, but coordinator uses a HashSet for each signer since it needs to do lots of lookups
         let mut coordinator_key_ids = HashMap::with_capacity(4000);
-        let mut signer_key_ids = Vec::with_capacity(4000);
+        let mut signer_key_ids = HashMap::with_capacity(reward_set_signers.len());
         let mut signer_addresses = HashSet::with_capacity(reward_set_signers.len());
         let mut public_keys = PublicKeys {
             signers: HashMap::with_capacity(reward_set_signers.len()),
@@ -162,7 +162,10 @@ impl RunLoop {
                     .entry(signer_id)
                     .or_insert(HashSet::with_capacity(entry.slots as usize))
                     .insert(key_id);
-                signer_key_ids.push(key_id);
+                signer_key_ids
+                    .entry(signer_id)
+                    .or_insert(Vec::with_capacity(entry.slots as usize))
+                    .push(key_id);
             }
         }
         let Some(signer_id) = current_signer_id else {
@@ -172,12 +175,14 @@ impl RunLoop {
         debug!(
             "Signer #{signer_id} ({current_addr}) is registered for reward cycle {reward_cycle}."
         );
+        let key_ids = signer_key_ids.get(&signer_id).cloned().unwrap_or_default();
         Ok(Some(RewardCycleConfig {
             reward_cycle,
             signer_id,
             signer_slot_id,
             signer_set,
             signer_addresses,
+            key_ids,
             coordinator_key_ids,
             signer_key_ids,
             public_keys,
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index 94fe35ff69..605cdc41d7 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -170,7 +170,7 @@ impl Signer {
             num_signers,
             num_keys,
             reward_cycle_config.signer_id,
-            reward_cycle_config.signer_key_ids,
+            reward_cycle_config.key_ids,
             config.ecdsa_private_key,
             reward_cycle_config.public_keys,
         );

From 2d92d54426a7728f6dc30945b1d32e2276f48dfc Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 7 Feb 2024 18:27:08 -0800
Subject: [PATCH 0870/1166] Rely on signers to run DKG

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 testnet/stacks-node/src/tests/signer.rs | 44 ++++++++++++-------------
 1 file changed, 22 insertions(+), 22 deletions(-)

diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index 83cd7116a8..fb85f7c7df 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -496,28 +496,6 @@ fn stackerdb_block_proposal() {
     info!("------------------------- Test Setup -------------------------");
     let mut signer_test = SignerTest::new(5, 5);
 
-    let mut aggregate_public_key = None;
-    let recv = signer_test
-        .result_receivers
-        .last()
-        .expect("Failed to get coordinator recv");
-    let results = recv
-        .recv_timeout(Duration::from_secs(30))
-        .expect("failed to recv dkg results");
-    for result in results {
-        match result {
-            OperationResult::Dkg(point) => {
-                info!("Received aggregate_group_key {point}");
-                aggregate_public_key = Some(point);
-                break;
-            }
-            _ => {
-                panic!("Received Unexpected result");
-            }
-        }
-    }
-    let aggregate_public_key = aggregate_public_key.expect("Failed to get aggregate public key");
-
     let (vrfs_submitted, commits_submitted) = (
         signer_test.running_nodes.vrfs_submitted.clone(),
         signer_test.running_nodes.commits_submitted.clone(),
@@ -556,6 +534,28 @@ fn stackerdb_block_proposal() {
     )
     .unwrap();
 
+    let mut aggregate_public_key = None;
+    let recv = signer_test
+        .result_receivers
+        .last()
+        .expect("Failed to get recv");
+    let results = recv
+        .recv_timeout(Duration::from_secs(30))
+        .expect("failed to recv dkg results");
+    for result in results {
+        match result {
+            OperationResult::Dkg(point) => {
+                info!("Received aggregate_group_key {point}");
+                aggregate_public_key = Some(point);
+                break;
+            }
+            _ => {
+                panic!("Received Unexpected result");
+            }
+        }
+    }
+    let aggregate_public_key = aggregate_public_key.expect("Failed to get aggregate public key");
+
     info!("------------------------- Test Block Processed -------------------------");
     let recv = signer_test
         .result_receivers

From a392e3a06870d2cf282cbbbe6967b0f805f4c3df Mon Sep 17 00:00:00 2001
From: Jude Nelson <judecn@gmail.com>
Date: Thu, 8 Feb 2024 10:07:45 -0500
Subject: [PATCH 0871/1166] chore: fix /v2/pox to report epochs and use
 StacksEpochId

---
 stacks-signer/src/client/mod.rs           |  3 ++
 stacks-signer/src/client/stacks_client.rs | 64 ++++++++++-------------
 stacks-signer/src/signer.rs               | 18 +++----
 stackslib/src/net/api/getpoxinfo.rs       | 31 ++++++++++-
 4 files changed, 69 insertions(+), 47 deletions(-)

diff --git a/stacks-signer/src/client/mod.rs b/stacks-signer/src/client/mod.rs
index e163faaf19..aa8736fe87 100644
--- a/stacks-signer/src/client/mod.rs
+++ b/stacks-signer/src/client/mod.rs
@@ -102,6 +102,9 @@ pub enum ClientError {
     /// Reward set contained corrupted data
     #[error("{0}")]
     CorruptedRewardSet(String),
+    /// Stacks node does not support a feature we need
+    #[error("Stacks node does not support a required feature: {0}")]
+    UnsupportedStacksFeature(String),
 }
 
 /// Retry a function F with an exponential backoff and notification on transient failure
diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index 8639426555..14d20bd76d 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -21,10 +21,6 @@ use blockstack_lib::chainstate::stacks::{
     TransactionContractCall, TransactionPayload, TransactionPostConditionMode,
     TransactionSpendingCondition, TransactionVersion,
 };
-use blockstack_lib::core::{
-    BITCOIN_MAINNET_STACKS_25_BURN_HEIGHT, BITCOIN_MAINNET_STACKS_30_BURN_HEIGHT,
-    BITCOIN_TESTNET_STACKS_25_BURN_HEIGHT, BITCOIN_TESTNET_STACKS_30_BURN_HEIGHT,
-};
 use blockstack_lib::net::api::callreadonly::CallReadOnlyResponse;
 use blockstack_lib::net::api::getaccount::AccountEntryResponse;
 use blockstack_lib::net::api::getinfo::RPCPeerInfoData;
@@ -42,6 +38,7 @@ use stacks_common::debug;
 use stacks_common::types::chainstate::{
     ConsensusHash, StacksAddress, StacksPrivateKey, StacksPublicKey,
 };
+use stacks_common::types::StacksEpochId;
 use stacks_common::util::hash::Sha256Sum;
 use wsts::curve::ecdsa;
 use wsts::curve::point::{Compressed, Point};
@@ -72,17 +69,6 @@ pub struct StacksClient {
     tx_fee: u64,
 }
 
-/// The supported epoch IDs
-#[derive(Debug, PartialEq)]
-pub enum EpochId {
-    /// The mainnet epoch ID
-    Epoch30,
-    /// The testnet epoch ID
-    Epoch25,
-    /// Unsuporrted epoch ID
-    UnsupportedEpoch,
-}
-
 impl From<&GlobalConfig> for StacksClient {
     fn from(config: &GlobalConfig) -> Self {
         Self {
@@ -201,28 +187,32 @@ impl StacksClient {
     }
 
     /// Determine the stacks node current epoch
-    pub fn get_node_epoch(&self) -> Result<EpochId, ClientError> {
-        let is_mainnet = self.chain_id == CHAIN_ID_MAINNET;
+    pub fn get_node_epoch(&self) -> Result<StacksEpochId, ClientError> {
+        let pox_info = self.get_pox_data()?;
         let burn_block_height = self.get_burn_block_height()?;
 
-        let (epoch25_activation_height, epoch_30_activation_height) = if is_mainnet {
-            (
-                BITCOIN_MAINNET_STACKS_25_BURN_HEIGHT,
-                BITCOIN_MAINNET_STACKS_30_BURN_HEIGHT,
-            )
-        } else {
-            (
-                BITCOIN_TESTNET_STACKS_25_BURN_HEIGHT,
-                BITCOIN_TESTNET_STACKS_30_BURN_HEIGHT,
-            )
-        };
+        let epoch_25 = pox_info
+            .epochs
+            .iter()
+            .find(|epoch| epoch.epoch_id == StacksEpochId::Epoch25)
+            .ok_or(ClientError::UnsupportedStacksFeature(
+                "/v2/pox must report epochs".into(),
+            ))?;
 
-        if burn_block_height < epoch25_activation_height {
-            Ok(EpochId::UnsupportedEpoch)
-        } else if burn_block_height < epoch_30_activation_height {
-            Ok(EpochId::Epoch25)
+        let epoch_30 = pox_info
+            .epochs
+            .iter()
+            .find(|epoch| epoch.epoch_id == StacksEpochId::Epoch30)
+            .ok_or(ClientError::UnsupportedStacksFeature(
+                "/v2/pox mut report epochs".into(),
+            ))?;
+
+        if burn_block_height < epoch_25.start_height {
+            Ok(StacksEpochId::Epoch24)
+        } else if burn_block_height < epoch_30.start_height {
+            Ok(StacksEpochId::Epoch25)
         } else {
-            Ok(EpochId::Epoch30)
+            Ok(StacksEpochId::Epoch30)
         }
     }
 
@@ -677,7 +667,7 @@ mod tests {
     use stacks_common::bitvec::BitVec;
     use stacks_common::consts::{CHAIN_ID_TESTNET, SIGNER_SLOTS_PER_USER};
     use stacks_common::types::chainstate::{BlockHeaderHash, StacksBlockId, TrieHash};
-    use stacks_common::types::StacksPublicKeyBuffer;
+    use stacks_common::types::{StacksEpochId, StacksPublicKeyBuffer};
     use stacks_common::util::hash::{Hash160, Sha256Sum, Sha512Trunc256Sum};
     use stacks_common::util::secp256k1::MessageSignature;
     use wsts::curve::scalar::Scalar;
@@ -1060,7 +1050,7 @@ mod tests {
             b"HTTP/1.1 200 OK\n\n{\"burn_block_height\":2575799,\"peer_version\":4207599113,\"pox_consensus\":\"64c8c3049ff6b939c65828e3168210e6bb32d880\",\"stable_pox_consensus\":\"72277bf9a3b115e13c0942825480d6cee0e9a0e8\",\"stable_burn_block_height\":2575792,\"server_version\":\"stacks-node d657bdd (feat/epoch-2.4:d657bdd, release build, linux [x86_64])\",\"network_id\":2147483648,\"parent_network_id\":118034699,\"stacks_tip_height\":145152,\"stacks_tip\":\"77219884fe434c0fa270d65592b4f082ab3e5d9922ac2bdaac34310aedc3d298\",\"stacks_tip_consensus_hash\":\"64c8c3049ff6b939c65828e3168210e6bb32d880\",\"genesis_chainstate_hash\":\"74237aa39aa50a83de11a4f53e9d3bb7d43461d1de9873f402e5453ae60bc59b\",\"unanchored_tip\":\"dde44222b6e6d81583b6b9c55db83e8716943ae9d0dc332fc39448ddd9b99dc2\",\"unanchored_seq\":0,\"exit_at_block_height\":null,\"node_public_key\":\"023c940136d5795d9dd82c0e87f4dd6a2a1db245444e7d70e34bb9605c3c3917b0\",\"node_public_key_hash\":\"e26cce8f6abe06b9fc81c3b11bcc821d2f1b8fd0\"}",
         );
         let epoch = h.join().unwrap().expect("Failed to deserialize response");
-        assert_eq!(epoch, EpochId::UnsupportedEpoch);
+        assert_eq!(epoch, StacksEpochId::Epoch24);
 
         let mock = MockServerClient::new();
         let h = spawn(move || mock.client.get_node_epoch());
@@ -1069,7 +1059,7 @@ mod tests {
 
         write_response(mock.server, response_bytes.as_bytes());
         let epoch = h.join().unwrap().expect("Failed to deserialize response");
-        assert_eq!(epoch, EpochId::Epoch25);
+        assert_eq!(epoch, StacksEpochId::Epoch25);
 
         let mock = MockServerClient::new();
         let h = spawn(move || mock.client.get_node_epoch());
@@ -1077,7 +1067,7 @@ mod tests {
         let response_bytes = format!("HTTP/1.1 200 OK\n\n{{\"burn_block_height\":{height},\"peer_version\":4207599113,\"pox_consensus\":\"64c8c3049ff6b939c65828e3168210e6bb32d880\",\"stable_pox_consensus\":\"72277bf9a3b115e13c0942825480d6cee0e9a0e8\",\"stable_burn_block_height\":2575792,\"server_version\":\"stacks-node d657bdd (feat/epoch-2.4:d657bdd, release build, linux [x86_64])\",\"network_id\":2147483648,\"parent_network_id\":118034699,\"stacks_tip_height\":145152,\"stacks_tip\":\"77219884fe434c0fa270d65592b4f082ab3e5d9922ac2bdaac34310aedc3d298\",\"stacks_tip_consensus_hash\":\"64c8c3049ff6b939c65828e3168210e6bb32d880\",\"genesis_chainstate_hash\":\"74237aa39aa50a83de11a4f53e9d3bb7d43461d1de9873f402e5453ae60bc59b\",\"unanchored_tip\":\"dde44222b6e6d81583b6b9c55db83e8716943ae9d0dc332fc39448ddd9b99dc2\",\"unanchored_seq\":0,\"exit_at_block_height\":null,\"node_public_key\":\"023c940136d5795d9dd82c0e87f4dd6a2a1db245444e7d70e34bb9605c3c3917b0\",\"node_public_key_hash\":\"e26cce8f6abe06b9fc81c3b11bcc821d2f1b8fd0\"}}");
         write_response(mock.server, response_bytes.as_bytes());
         let epoch = h.join().unwrap().expect("Failed to deserialize response");
-        assert_eq!(epoch, EpochId::Epoch30);
+        assert_eq!(epoch, StacksEpochId::Epoch30);
     }
 
     #[test]
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index 605cdc41d7..3e81988c97 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -26,6 +26,7 @@ use libsigner::{BlockRejection, BlockResponse, RejectCode, SignerEvent, SignerMe
 use slog::{slog_debug, slog_error, slog_info, slog_warn};
 use stacks_common::codec::{read_next, StacksMessageCodec};
 use stacks_common::types::chainstate::StacksAddress;
+use stacks_common::types::StacksEpochId;
 use stacks_common::util::hash::Sha512Trunc256Sum;
 use stacks_common::{debug, error, info, warn};
 use wsts::common::{MerkleRoot, Signature};
@@ -40,8 +41,7 @@ use wsts::state_machine::{OperationResult, SignError};
 use wsts::v2;
 
 use crate::client::{
-    retry_with_exponential_backoff, ClientError, EpochId, StackerDB, StacksClient,
-    VOTE_FUNCTION_NAME,
+    retry_with_exponential_backoff, ClientError, StackerDB, StacksClient, VOTE_FUNCTION_NAME,
 };
 use crate::config::{GlobalConfig, RewardCycleConfig};
 
@@ -787,13 +787,9 @@ impl Signer {
                     // Broadcast via traditional methods to the stacks node if we are pre nakamoto or we cannot determine our Epoch
                     let epoch = stacks_client
                         .get_node_epoch()
-                        .unwrap_or(EpochId::UnsupportedEpoch);
+                        .unwrap_or(StacksEpochId::Epoch24);
                     let new_transaction = match epoch {
-                        EpochId::UnsupportedEpoch => {
-                            debug!("Signer #{}: Received a DKG result, but are in an unsupported epoch. Do not broadcast the result.", self.signer_id);
-                            continue;
-                        }
-                        EpochId::Epoch25 => {
+                        StacksEpochId::Epoch25 => {
                             debug!("Signer #{}: Received a DKG result, but are in epoch 2.5. Broadcast the transaction to the mempool.", self.signer_id);
                             match retry_with_exponential_backoff(|| {
                                 stacks_client
@@ -817,7 +813,7 @@ impl Signer {
                                 }
                             }
                         }
-                        EpochId::Epoch30 => {
+                        StacksEpochId::Epoch30 => {
                             debug!("Signer #{}: Received a DKG result, but are in epoch 3. Broadcast the transaction to stackerDB.", self.signer_id);
                             match retry_with_exponential_backoff(|| {
                                 stacks_client
@@ -835,6 +831,10 @@ impl Signer {
                                 }
                             }
                         }
+                        _ => {
+                            debug!("Signer #{}: Received a DKG result, but are in an unsupported epoch. Do not broadcast the result.", self.signer_id);
+                            continue;
+                        }
                     };
                     let old_transactions = self
                         .stackerdb
diff --git a/stackslib/src/net/api/getpoxinfo.rs b/stackslib/src/net/api/getpoxinfo.rs
index 2d583da939..f7475c9cde 100644
--- a/stackslib/src/net/api/getpoxinfo.rs
+++ b/stackslib/src/net/api/getpoxinfo.rs
@@ -17,12 +17,13 @@
 use std::io::{Read, Write};
 
 use clarity::vm::clarity::ClarityConnection;
-use clarity::vm::costs::LimitedCostTracker;
+use clarity::vm::costs::{ExecutionCost, LimitedCostTracker};
 use clarity::vm::types::{PrincipalData, StandardPrincipalData};
 use clarity::vm::ClarityVersion;
 use regex::{Captures, Regex};
 use stacks_common::types::chainstate::StacksBlockId;
 use stacks_common::types::net::PeerHost;
+use stacks_common::types::StacksEpochId;
 use stacks_common::util::hash::Sha256Sum;
 
 use crate::burnchains::Burnchain;
@@ -31,6 +32,7 @@ use crate::chainstate::stacks::boot::{POX_1_NAME, POX_2_NAME, POX_3_NAME, POX_4_
 use crate::chainstate::stacks::db::StacksChainState;
 use crate::chainstate::stacks::Error as ChainError;
 use crate::core::mempool::MemPoolDB;
+use crate::core::StacksEpoch;
 use crate::net::http::{
     parse_json, Error, HttpNotFound, HttpRequest, HttpRequestContents, HttpRequestPreamble,
     HttpResponse, HttpResponseContents, HttpResponsePayload, HttpResponsePreamble, HttpServerError,
@@ -80,6 +82,27 @@ pub struct RPCPoxContractVersion {
     pub first_reward_cycle_id: u64,
 }
 
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct RPCPoxEpoch {
+    pub epoch_id: StacksEpochId,
+    pub start_height: u64,
+    pub end_height: u64,
+    pub block_limit: ExecutionCost,
+    pub network_epoch: u8,
+}
+
+impl From<StacksEpoch> for RPCPoxEpoch {
+    fn from(epoch: StacksEpoch) -> Self {
+        Self {
+            epoch_id: epoch.epoch_id,
+            start_height: epoch.start_height,
+            end_height: epoch.end_height,
+            block_limit: epoch.block_limit,
+            network_epoch: epoch.network_epoch,
+        }
+    }
+}
+
 /// The data we return on GET /v2/pox
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct RPCPoxInfoData {
@@ -94,6 +117,7 @@ pub struct RPCPoxInfoData {
     pub total_liquid_supply_ustx: u64,
     pub current_cycle: RPCPoxCurrentCycleInfo,
     pub next_cycle: RPCPoxNextCycleInfo,
+    pub epochs: Vec<RPCPoxEpoch>,
 
     // below are included for backwards-compatibility
     pub min_amount_ustx: u64,
@@ -331,6 +355,10 @@ impl RPCPoxInfoData {
             as u64;
 
         let cur_cycle_pox_active = sortdb.is_pox_active(burnchain, &burnchain_tip)?;
+        let epochs: Vec<_> = SortitionDB::get_stacks_epochs(sortdb.conn())?
+            .into_iter()
+            .map(|epoch| RPCPoxEpoch::from(epoch))
+            .collect();
 
         Ok(RPCPoxInfoData {
             contract_id: boot_code_id(cur_block_pox_contract, chainstate.mainnet).to_string(),
@@ -359,6 +387,7 @@ impl RPCPoxInfoData {
                 blocks_until_reward_phase: next_reward_cycle_in,
                 ustx_until_pox_rejection: rejection_votes_left_required,
             },
+            epochs,
             min_amount_ustx: next_threshold,
             prepare_cycle_length,
             reward_cycle_id,

From e8f6aa14f26d61d6ac33bba5fbf24a57debf4017 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Thu, 8 Feb 2024 11:18:41 -0800
Subject: [PATCH 0872/1166] Fix tests

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/mod.rs           | 165 +++++++++++++-
 stacks-signer/src/client/stacks_client.rs | 254 +++++++++++-----------
 2 files changed, 282 insertions(+), 137 deletions(-)

diff --git a/stacks-signer/src/client/mod.rs b/stacks-signer/src/client/mod.rs
index aa8736fe87..0f3fa80a7a 100644
--- a/stacks-signer/src/client/mod.rs
+++ b/stacks-signer/src/client/mod.rs
@@ -132,11 +132,24 @@ pub(crate) mod tests {
     use std::io::{Read, Write};
     use std::net::{SocketAddr, TcpListener};
 
+    use blockstack_lib::chainstate::stacks::boot::POX_4_NAME;
+    use blockstack_lib::net::api::getaccount::AccountEntryResponse;
+    use blockstack_lib::net::api::getinfo::RPCPeerInfoData;
+    use blockstack_lib::net::api::getpoxinfo::{
+        RPCPoxCurrentCycleInfo, RPCPoxEpoch, RPCPoxInfoData, RPCPoxNextCycleInfo,
+    };
+    use blockstack_lib::util_lib::boot::boot_code_id;
+    use clarity::vm::costs::ExecutionCost;
     use clarity::vm::Value as ClarityValue;
     use hashbrown::{HashMap, HashSet};
-    use rand::thread_rng;
+    use rand::distributions::Standard;
+    use rand::{thread_rng, Rng};
     use rand_core::{OsRng, RngCore};
-    use stacks_common::types::chainstate::{StacksAddress, StacksPublicKey};
+    use stacks_common::types::chainstate::{
+        BlockHeaderHash, ConsensusHash, StacksAddress, StacksPrivateKey, StacksPublicKey,
+    };
+    use stacks_common::types::{StacksEpochId, StacksPublicKeyBuffer};
+    use stacks_common::util::hash::{Hash160, Sha256Sum};
     use wsts::curve::ecdsa;
     use wsts::curve::point::{Compressed, Point};
     use wsts::curve::scalar::Scalar;
@@ -206,6 +219,14 @@ pub(crate) mod tests {
         request_bytes
     }
 
+    pub fn generate_random_consensus_hash() -> ConsensusHash {
+        let rng = rand::thread_rng();
+        let bytes: Vec<u8> = rng.sample_iter(Standard).take(20).collect();
+        let mut hash = [0u8; 20];
+        hash.copy_from_slice(&bytes);
+        ConsensusHash(hash)
+    }
+
     /// Build a response for the get_last_round request
     pub fn build_get_last_round_response(round: u64) -> String {
         let value = ClarityValue::okay(ClarityValue::UInt(round as u128))
@@ -215,15 +236,98 @@ pub(crate) mod tests {
 
     /// Build a response for the get_account_nonce request
     pub fn build_account_nonce_response(nonce: u64) -> String {
-        format!("HTTP/1.1 200 OK\n\n{{\"nonce\":{nonce},\"balance\":\"0x00000000000000000000000000000000\",\"locked\":\"0x00000000000000000000000000000000\",\"unlock_height\":0}}")
+        let account_nonce_entry = AccountEntryResponse {
+            nonce,
+            balance: "0x00000000000000000000000000000000".to_string(),
+            locked: "0x00000000000000000000000000000000".to_string(),
+            unlock_height: thread_rng().next_u64(),
+            balance_proof: None,
+            nonce_proof: None,
+        };
+        let account_nonce_entry_json = serde_json::to_string(&account_nonce_entry)
+            .expect("Failed to serialize account nonce entry");
+        format!("HTTP/1.1 200 OK\n\n{account_nonce_entry_json}")
     }
 
     /// Build a response to get_pox_data where it returns a specific reward cycle id and block height
     pub fn build_get_pox_data_response(
-        reward_cycle: u64,
-        prepare_phase_start_block_height: u64,
-    ) -> String {
-        format!("HTTP/1.1 200 Ok\n\n{{\"contract_id\":\"ST000000000000000000002AMW42H.pox-3\",\"pox_activation_threshold_ustx\":829371801288885,\"first_burnchain_block_height\":2000000,\"current_burnchain_block_height\":2572192,\"prepare_phase_block_length\":50,\"reward_phase_block_length\":1000,\"reward_slots\":2000,\"rejection_fraction\":12,\"total_liquid_supply_ustx\":41468590064444294,\"current_cycle\":{{\"id\":544,\"min_threshold_ustx\":5190000000000,\"stacked_ustx\":853258144644000,\"is_pox_active\":true}},\"next_cycle\":{{\"id\":545,\"min_threshold_ustx\":5190000000000,\"min_increment_ustx\":5183573758055,\"stacked_ustx\":847278759574000,\"prepare_phase_start_block_height\":{prepare_phase_start_block_height},\"blocks_until_prepare_phase\":8,\"reward_phase_start_block_height\":2572250,\"blocks_until_reward_phase\":58,\"ustx_until_pox_rejection\":4976230807733304}},\"min_amount_ustx\":5190000000000,\"prepare_cycle_length\":50,\"reward_cycle_id\":{reward_cycle},\"reward_cycle_length\":1050,\"rejection_votes_left_required\":4976230807733304,\"next_reward_cycle_in\":58,\"contract_versions\":[{{\"contract_id\":\"ST000000000000000000002AMW42H.pox\",\"activation_burnchain_block_height\":2000000,\"first_reward_cycle_id\":0}},{{\"contract_id\":\"ST000000000000000000002AMW42H.pox-2\",\"activation_burnchain_block_height\":2422102,\"first_reward_cycle_id\":403}},{{\"contract_id\":\"ST000000000000000000002AMW42H.pox-3\",\"activation_burnchain_block_height\":2432545,\"first_reward_cycle_id\":412}}]}}")
+        reward_cycle: Option<u64>,
+        prepare_phase_start_height: Option<u64>,
+        epoch_25_activation_height: Option<u64>,
+        epoch_30_activation_height: Option<u64>,
+    ) -> (String, RPCPoxInfoData) {
+        // Populate some random data!
+        let epoch_25_start = epoch_25_activation_height.unwrap_or(thread_rng().next_u64());
+        let epoch_30_start =
+            epoch_30_activation_height.unwrap_or(epoch_25_start.saturating_add(1000));
+        let current_id = reward_cycle.unwrap_or(thread_rng().next_u64());
+        let next_id = current_id.saturating_add(1);
+        let pox_info = RPCPoxInfoData {
+            contract_id: boot_code_id(POX_4_NAME, false).to_string(),
+            pox_activation_threshold_ustx: thread_rng().next_u64(),
+            first_burnchain_block_height: thread_rng().next_u64(),
+            current_burnchain_block_height: thread_rng().next_u64(),
+            prepare_phase_block_length: thread_rng().next_u64(),
+            reward_phase_block_length: thread_rng().next_u64(),
+            reward_slots: thread_rng().next_u64(),
+            rejection_fraction: None,
+            total_liquid_supply_ustx: thread_rng().next_u64(),
+            current_cycle: RPCPoxCurrentCycleInfo {
+                id: current_id,
+                min_threshold_ustx: thread_rng().next_u64(),
+                stacked_ustx: thread_rng().next_u64(),
+                is_pox_active: true,
+            },
+            next_cycle: RPCPoxNextCycleInfo {
+                id: next_id,
+                min_threshold_ustx: thread_rng().next_u64(),
+                min_increment_ustx: thread_rng().next_u64(),
+                stacked_ustx: thread_rng().next_u64(),
+                prepare_phase_start_block_height: prepare_phase_start_height
+                    .unwrap_or(thread_rng().next_u64()),
+                blocks_until_prepare_phase: thread_rng().next_u32() as i64,
+                reward_phase_start_block_height: thread_rng().next_u64(),
+                blocks_until_reward_phase: thread_rng().next_u64(),
+                ustx_until_pox_rejection: None,
+            },
+            min_amount_ustx: thread_rng().next_u64(),
+            prepare_cycle_length: thread_rng().next_u64(),
+            reward_cycle_id: current_id,
+            epochs: vec![
+                RPCPoxEpoch {
+                    start_height: epoch_25_start,
+                    end_height: epoch_30_start,
+                    block_limit: ExecutionCost {
+                        write_length: thread_rng().next_u64(),
+                        write_count: thread_rng().next_u64(),
+                        read_length: thread_rng().next_u64(),
+                        read_count: thread_rng().next_u64(),
+                        runtime: thread_rng().next_u64(),
+                    },
+                    epoch_id: StacksEpochId::Epoch25,
+                    network_epoch: 0,
+                },
+                RPCPoxEpoch {
+                    start_height: epoch_30_start,
+                    end_height: epoch_30_start.saturating_add(1000),
+                    block_limit: ExecutionCost {
+                        write_length: thread_rng().next_u64(),
+                        write_count: thread_rng().next_u64(),
+                        read_length: thread_rng().next_u64(),
+                        read_count: thread_rng().next_u64(),
+                        runtime: thread_rng().next_u64(),
+                    },
+                    epoch_id: StacksEpochId::Epoch30,
+                    network_epoch: 0,
+                },
+            ],
+            reward_cycle_length: thread_rng().next_u64(),
+            rejection_votes_left_required: None,
+            next_reward_cycle_in: thread_rng().next_u64(),
+            contract_versions: vec![],
+        };
+        let pox_info_json = serde_json::to_string(&pox_info).expect("Failed to serialize pox info");
+        (format!("HTTP/1.1 200 Ok\n\n{pox_info_json}"), pox_info)
     }
 
     /// Build a response for the get_aggregate_public_key request
@@ -237,10 +341,49 @@ pub(crate) mod tests {
     }
 
     /// Build a response for the get_peer_info request with a specific stacks tip height and consensus hash
-    pub fn build_get_peer_info_response(stacks_tip_height: u64, consensus_hash: String) -> String {
-        format!(
-            "HTTP/1.1 200 OK\n\n{{\"stacks_tip_height\":{stacks_tip_height},\"stacks_tip_consensus_hash\":\"{consensus_hash}\",\"peer_version\":4207599113,\"pox_consensus\":\"64c8c3049ff6b939c65828e3168210e6bb32d880\",\"burn_block_height\":2575799,\"stable_pox_consensus\":\"72277bf9a3b115e13c0942825480d6cee0e9a0e8\",\"stable_burn_block_height\":2575792,\"server_version\":\"stacks-node d657bdd (feat/epoch-2.4:d657bdd, release build, linux [x86_64])\",\"network_id\":2147483648,\"parent_network_id\":118034699,\"stacks_tip\":\"77219884fe434c0fa270d65592b4f082ab3e5d9922ac2bdaac34310aedc3d298\",\"genesis_chainstate_hash\":\"74237aa39aa50a83de11a4f53e9d3bb7d43461d1de9873f402e5453ae60bc59b\",\"unanchored_tip\":\"dde44222b6e6d81583b6b9c55db83e8716943ae9d0dc332fc39448ddd9b99dc2\",\"unanchored_seq\":0,\"exit_at_block_height\":null,\"node_public_key\":\"023c940136d5795d9dd82c0e87f4dd6a2a1db245444e7d70e34bb9605c3c3917b0\",\"node_public_key_hash\":\"e26cce8f6abe06b9fc81c3b11bcc821d2f1b8fd0\"}}",
-        )
+    pub fn build_get_peer_info_response(
+        stacks_tip_height: Option<u64>,
+        burn_block_height: Option<u64>,
+        stacks_tip_consensus_hash: Option<ConsensusHash>,
+    ) -> (String, RPCPeerInfoData) {
+        // Generate some random info
+        let private_key = StacksPrivateKey::new();
+        let public_key = StacksPublicKey::from_private(&private_key);
+        let public_key_buf = StacksPublicKeyBuffer::from_public_key(&public_key);
+        let public_key_hash = Hash160::from_node_public_key(&public_key);
+        let stackerdb_contract_ids =
+            vec![boot_code_id("fake", false), boot_code_id("fake_2", false)];
+        let peer_info = RPCPeerInfoData {
+            peer_version: thread_rng().next_u32(),
+            pox_consensus: generate_random_consensus_hash(),
+            burn_block_height: burn_block_height.unwrap_or(thread_rng().next_u64()),
+            stable_pox_consensus: generate_random_consensus_hash(),
+            stable_burn_block_height: 2,
+            server_version: "fake version".to_string(),
+            network_id: thread_rng().next_u32(),
+            parent_network_id: thread_rng().next_u32(),
+            stacks_tip_height: stacks_tip_height.unwrap_or(thread_rng().next_u64()),
+            stacks_tip: BlockHeaderHash([0x06; 32]),
+            stacks_tip_consensus_hash: stacks_tip_consensus_hash
+                .unwrap_or(generate_random_consensus_hash()),
+            unanchored_tip: None,
+            unanchored_seq: Some(0),
+            exit_at_block_height: None,
+            genesis_chainstate_hash: Sha256Sum::zero(),
+            node_public_key: Some(public_key_buf),
+            node_public_key_hash: Some(public_key_hash),
+            affirmations: None,
+            last_pox_anchor: None,
+            stackerdbs: Some(
+                stackerdb_contract_ids
+                    .into_iter()
+                    .map(|cid| format!("{}", cid))
+                    .collect(),
+            ),
+        };
+        let peer_info_json =
+            serde_json::to_string(&peer_info).expect("Failed to serialize peer info");
+        (format!("HTTP/1.1 200 OK\n\n{peer_info_json}"), peer_info)
     }
 
     /// Build a response to a read only clarity contract call
diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index 14d20bd76d..d37e33e39a 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -652,7 +652,6 @@ impl StacksClient {
 
 #[cfg(test)]
 mod tests {
-    use std::fmt::Write as FmtWrite;
     use std::io::{BufWriter, Write};
     use std::thread::spawn;
 
@@ -660,15 +659,14 @@ mod tests {
     use blockstack_lib::chainstate::stacks::address::PoxAddress;
     use blockstack_lib::chainstate::stacks::boot::{NakamotoSignerEntry, PoxStartCycleInfo};
     use blockstack_lib::chainstate::stacks::ThresholdSignature;
-    use rand::distributions::Standard;
-    use rand::{thread_rng, Rng};
+    use rand::thread_rng;
     use rand_core::RngCore;
     use serial_test::serial;
     use stacks_common::bitvec::BitVec;
     use stacks_common::consts::{CHAIN_ID_TESTNET, SIGNER_SLOTS_PER_USER};
-    use stacks_common::types::chainstate::{BlockHeaderHash, StacksBlockId, TrieHash};
-    use stacks_common::types::{StacksEpochId, StacksPublicKeyBuffer};
-    use stacks_common::util::hash::{Hash160, Sha256Sum, Sha512Trunc256Sum};
+    use stacks_common::types::chainstate::{StacksBlockId, TrieHash};
+    use stacks_common::types::StacksEpochId;
+    use stacks_common::util::hash::Sha512Trunc256Sum;
     use stacks_common::util::secp256k1::MessageSignature;
     use wsts::curve::scalar::Scalar;
 
@@ -676,7 +674,8 @@ mod tests {
     use crate::client::tests::{
         build_account_nonce_response, build_get_aggregate_public_key_response,
         build_get_last_round_response, build_get_peer_info_response, build_get_pox_data_response,
-        build_read_only_response, generate_reward_cycle_config, write_response, MockServerClient,
+        build_read_only_response, generate_random_consensus_hash, generate_reward_cycle_config,
+        write_response, MockServerClient,
     };
 
     #[test]
@@ -779,14 +778,11 @@ mod tests {
     #[test]
     fn valid_reward_cycle_should_succeed() {
         let mock = MockServerClient::new();
-        let reward_cycle = thread_rng().next_u64();
-        let prepare_phase_start_block_height = thread_rng().next_u64();
-        let pox_data_response =
-            build_get_pox_data_response(reward_cycle, prepare_phase_start_block_height);
+        let (pox_data_response, pox_data) = build_get_pox_data_response(None, None, None, None);
         let h = spawn(move || mock.client.get_current_reward_cycle());
         write_response(mock.server, pox_data_response.as_bytes());
         let current_cycle_id = h.join().unwrap().unwrap();
-        assert_eq!(reward_cycle, current_cycle_id);
+        assert_eq!(current_cycle_id, pox_data.reward_cycle_id);
     }
 
     #[test]
@@ -801,18 +797,6 @@ mod tests {
         assert!(matches!(res, Err(ClientError::ReqwestError(_))));
     }
 
-    #[test]
-    fn missing_reward_cycle_should_fail() {
-        let mock = MockServerClient::new();
-        let h = spawn(move || mock.client.get_current_reward_cycle());
-        write_response(
-            mock.server,
-            b"HTTP/1.1 200 Ok\n\n{\"current_cycle\":{\"is_pox_active\":false}}",
-        );
-        let res = h.join().unwrap();
-        assert!(matches!(res, Err(ClientError::ReqwestError(_))));
-    }
-
     #[test]
     fn get_aggregate_public_key_should_succeed() {
         let orig_point = Point::from(Scalar::random(&mut rand::thread_rng()));
@@ -960,15 +944,10 @@ mod tests {
     fn core_info_call_for_consensus_hash_should_succeed() {
         let mock = MockServerClient::new();
         let h = spawn(move || mock.client.get_stacks_tip_consensus_hash());
-        write_response(
-            mock.server,
-            b"HTTP/1.1 200 OK\n\n{\"stacks_tip_consensus_hash\":\"64c8c3049ff6b939c65828e3168210e6bb32d880\",\"peer_version\":4207599113,\"pox_consensus\":\"64c8c3049ff6b939c65828e3168210e6bb32d880\",\"burn_block_height\":2575799,\"stable_pox_consensus\":\"72277bf9a3b115e13c0942825480d6cee0e9a0e8\",\"stable_burn_block_height\":2575792,\"server_version\":\"stacks-node d657bdd (feat/epoch-2.4:d657bdd, release build, linux [x86_64])\",\"network_id\":2147483648,\"parent_network_id\":118034699,\"stacks_tip_height\":145152,\"stacks_tip\":\"77219884fe434c0fa270d65592b4f082ab3e5d9922ac2bdaac34310aedc3d298\",\"genesis_chainstate_hash\":\"74237aa39aa50a83de11a4f53e9d3bb7d43461d1de9873f402e5453ae60bc59b\",\"unanchored_tip\":\"dde44222b6e6d81583b6b9c55db83e8716943ae9d0dc332fc39448ddd9b99dc2\",\"unanchored_seq\":0,\"exit_at_block_height\":null,\"node_public_key\":\"023c940136d5795d9dd82c0e87f4dd6a2a1db245444e7d70e34bb9605c3c3917b0\",\"node_public_key_hash\":\"e26cce8f6abe06b9fc81c3b11bcc821d2f1b8fd0\"}",
-        );
+        let (response, peer_info) = build_get_peer_info_response(None, None, None);
+        write_response(mock.server, response.as_bytes());
         let consensus_hash = h.join().unwrap().expect("Failed to deserialize response");
-        assert_eq!(
-            consensus_hash.to_hex(),
-            "64c8c3049ff6b939c65828e3168210e6bb32d880"
-        );
+        assert_eq!(consensus_hash, peer_info.stacks_tip_consensus_hash);
     }
 
     #[test]
@@ -986,12 +965,10 @@ mod tests {
     fn core_info_call_for_burn_block_height_should_succeed() {
         let mock = MockServerClient::new();
         let h = spawn(move || mock.client.get_burn_block_height());
-        write_response(
-            mock.server,
-            b"HTTP/1.1 200 OK\n\n{\"burn_block_height\":2575799,\"peer_version\":4207599113,\"pox_consensus\":\"64c8c3049ff6b939c65828e3168210e6bb32d880\",\"stable_pox_consensus\":\"72277bf9a3b115e13c0942825480d6cee0e9a0e8\",\"stable_burn_block_height\":2575792,\"server_version\":\"stacks-node d657bdd (feat/epoch-2.4:d657bdd, release build, linux [x86_64])\",\"network_id\":2147483648,\"parent_network_id\":118034699,\"stacks_tip_height\":145152,\"stacks_tip\":\"77219884fe434c0fa270d65592b4f082ab3e5d9922ac2bdaac34310aedc3d298\",\"stacks_tip_consensus_hash\":\"64c8c3049ff6b939c65828e3168210e6bb32d880\",\"genesis_chainstate_hash\":\"74237aa39aa50a83de11a4f53e9d3bb7d43461d1de9873f402e5453ae60bc59b\",\"unanchored_tip\":\"dde44222b6e6d81583b6b9c55db83e8716943ae9d0dc332fc39448ddd9b99dc2\",\"unanchored_seq\":0,\"exit_at_block_height\":null,\"node_public_key\":\"023c940136d5795d9dd82c0e87f4dd6a2a1db245444e7d70e34bb9605c3c3917b0\",\"node_public_key_hash\":\"e26cce8f6abe06b9fc81c3b11bcc821d2f1b8fd0\"}",
-        );
+        let (response, peer_info) = build_get_peer_info_response(None, None, None);
+        write_response(mock.server, response.as_bytes());
         let burn_block_height = h.join().unwrap().expect("Failed to deserialize response");
-        assert_eq!(burn_block_height, 2575799);
+        assert_eq!(burn_block_height, peer_info.burn_block_height);
     }
 
     #[test]
@@ -1044,28 +1021,83 @@ mod tests {
     #[test]
     fn get_node_epoch_should_succeed() {
         let mock = MockServerClient::new();
+        // The burn block height is one BEHIND the activation height of 2.5, therefore is 2.4
+        let burn_block_height: u64 = 100;
+        let pox_response = build_get_pox_data_response(
+            None,
+            None,
+            Some(burn_block_height.saturating_add(1)),
+            None,
+        )
+        .0;
+        let peer_response = build_get_peer_info_response(None, Some(burn_block_height), None).0;
         let h = spawn(move || mock.client.get_node_epoch());
-        write_response(
-            mock.server,
-            b"HTTP/1.1 200 OK\n\n{\"burn_block_height\":2575799,\"peer_version\":4207599113,\"pox_consensus\":\"64c8c3049ff6b939c65828e3168210e6bb32d880\",\"stable_pox_consensus\":\"72277bf9a3b115e13c0942825480d6cee0e9a0e8\",\"stable_burn_block_height\":2575792,\"server_version\":\"stacks-node d657bdd (feat/epoch-2.4:d657bdd, release build, linux [x86_64])\",\"network_id\":2147483648,\"parent_network_id\":118034699,\"stacks_tip_height\":145152,\"stacks_tip\":\"77219884fe434c0fa270d65592b4f082ab3e5d9922ac2bdaac34310aedc3d298\",\"stacks_tip_consensus_hash\":\"64c8c3049ff6b939c65828e3168210e6bb32d880\",\"genesis_chainstate_hash\":\"74237aa39aa50a83de11a4f53e9d3bb7d43461d1de9873f402e5453ae60bc59b\",\"unanchored_tip\":\"dde44222b6e6d81583b6b9c55db83e8716943ae9d0dc332fc39448ddd9b99dc2\",\"unanchored_seq\":0,\"exit_at_block_height\":null,\"node_public_key\":\"023c940136d5795d9dd82c0e87f4dd6a2a1db245444e7d70e34bb9605c3c3917b0\",\"node_public_key_hash\":\"e26cce8f6abe06b9fc81c3b11bcc821d2f1b8fd0\"}",
-        );
+        write_response(mock.server, pox_response.as_bytes());
+        let mock = MockServerClient::from_config(mock.config);
+        write_response(mock.server, peer_response.as_bytes());
         let epoch = h.join().unwrap().expect("Failed to deserialize response");
         assert_eq!(epoch, StacksEpochId::Epoch24);
 
-        let mock = MockServerClient::new();
+        // The burn block height is the same as the activation height of 2.5, therefore is 2.5
+        let pox_response = build_get_pox_data_response(None, None, Some(burn_block_height), None).0;
+        let peer_response = build_get_peer_info_response(None, Some(burn_block_height), None).0;
+        let mock = MockServerClient::from_config(mock.config);
         let h = spawn(move || mock.client.get_node_epoch());
-        let height = BITCOIN_TESTNET_STACKS_25_BURN_HEIGHT;
-        let response_bytes = format!("HTTP/1.1 200 OK\n\n{{\"burn_block_height\":{height},\"peer_version\":4207599113,\"pox_consensus\":\"64c8c3049ff6b939c65828e3168210e6bb32d880\",\"stable_pox_consensus\":\"72277bf9a3b115e13c0942825480d6cee0e9a0e8\",\"stable_burn_block_height\":2575792,\"server_version\":\"stacks-node d657bdd (feat/epoch-2.4:d657bdd, release build, linux [x86_64])\",\"network_id\":2147483648,\"parent_network_id\":118034699,\"stacks_tip_height\":145152,\"stacks_tip\":\"77219884fe434c0fa270d65592b4f082ab3e5d9922ac2bdaac34310aedc3d298\",\"stacks_tip_consensus_hash\":\"64c8c3049ff6b939c65828e3168210e6bb32d880\",\"genesis_chainstate_hash\":\"74237aa39aa50a83de11a4f53e9d3bb7d43461d1de9873f402e5453ae60bc59b\",\"unanchored_tip\":\"dde44222b6e6d81583b6b9c55db83e8716943ae9d0dc332fc39448ddd9b99dc2\",\"unanchored_seq\":0,\"exit_at_block_height\":null,\"node_public_key\":\"023c940136d5795d9dd82c0e87f4dd6a2a1db245444e7d70e34bb9605c3c3917b0\",\"node_public_key_hash\":\"e26cce8f6abe06b9fc81c3b11bcc821d2f1b8fd0\"}}");
+        write_response(mock.server, pox_response.as_bytes());
+        let mock = MockServerClient::from_config(mock.config);
+        write_response(mock.server, peer_response.as_bytes());
+        let epoch = h.join().unwrap().expect("Failed to deserialize response");
+        assert_eq!(epoch, StacksEpochId::Epoch25);
 
-        write_response(mock.server, response_bytes.as_bytes());
+        // The burn block height is the AFTER as the activation height of 2.5 but BEFORE the activation height of 3.0, therefore is 2.5
+        let pox_response = build_get_pox_data_response(
+            None,
+            None,
+            Some(burn_block_height.saturating_sub(1)),
+            Some(burn_block_height.saturating_add(1)),
+        )
+        .0;
+        let peer_response = build_get_peer_info_response(None, Some(burn_block_height), None).0;
+        let mock = MockServerClient::from_config(mock.config);
+        let h = spawn(move || mock.client.get_node_epoch());
+        write_response(mock.server, pox_response.as_bytes());
+        let mock = MockServerClient::from_config(mock.config);
+        write_response(mock.server, peer_response.as_bytes());
         let epoch = h.join().unwrap().expect("Failed to deserialize response");
         assert_eq!(epoch, StacksEpochId::Epoch25);
 
-        let mock = MockServerClient::new();
+        // The burn block height is the AFTER as the activation height of 2.5 and the SAME as the activation height of 3.0, therefore is 3.0
+        let pox_response = build_get_pox_data_response(
+            None,
+            None,
+            Some(burn_block_height.saturating_sub(1)),
+            Some(burn_block_height),
+        )
+        .0;
+        let peer_response = build_get_peer_info_response(None, Some(burn_block_height), None).0;
+        let mock = MockServerClient::from_config(mock.config);
         let h = spawn(move || mock.client.get_node_epoch());
-        let height = BITCOIN_TESTNET_STACKS_30_BURN_HEIGHT;
-        let response_bytes = format!("HTTP/1.1 200 OK\n\n{{\"burn_block_height\":{height},\"peer_version\":4207599113,\"pox_consensus\":\"64c8c3049ff6b939c65828e3168210e6bb32d880\",\"stable_pox_consensus\":\"72277bf9a3b115e13c0942825480d6cee0e9a0e8\",\"stable_burn_block_height\":2575792,\"server_version\":\"stacks-node d657bdd (feat/epoch-2.4:d657bdd, release build, linux [x86_64])\",\"network_id\":2147483648,\"parent_network_id\":118034699,\"stacks_tip_height\":145152,\"stacks_tip\":\"77219884fe434c0fa270d65592b4f082ab3e5d9922ac2bdaac34310aedc3d298\",\"stacks_tip_consensus_hash\":\"64c8c3049ff6b939c65828e3168210e6bb32d880\",\"genesis_chainstate_hash\":\"74237aa39aa50a83de11a4f53e9d3bb7d43461d1de9873f402e5453ae60bc59b\",\"unanchored_tip\":\"dde44222b6e6d81583b6b9c55db83e8716943ae9d0dc332fc39448ddd9b99dc2\",\"unanchored_seq\":0,\"exit_at_block_height\":null,\"node_public_key\":\"023c940136d5795d9dd82c0e87f4dd6a2a1db245444e7d70e34bb9605c3c3917b0\",\"node_public_key_hash\":\"e26cce8f6abe06b9fc81c3b11bcc821d2f1b8fd0\"}}");
-        write_response(mock.server, response_bytes.as_bytes());
+        write_response(mock.server, pox_response.as_bytes());
+        let mock = MockServerClient::from_config(mock.config);
+        write_response(mock.server, peer_response.as_bytes());
+        let epoch = h.join().unwrap().expect("Failed to deserialize response");
+        assert_eq!(epoch, StacksEpochId::Epoch30);
+
+        // The burn block height is the AFTER as the activation height of 2.5 and AFTER the activation height of 3.0, therefore is 3.0
+        let pox_response = build_get_pox_data_response(
+            None,
+            None,
+            Some(burn_block_height.saturating_sub(1)),
+            Some(burn_block_height),
+        )
+        .0;
+        let peer_response =
+            build_get_peer_info_response(None, Some(burn_block_height.saturating_add(1)), None).0;
+        let mock = MockServerClient::from_config(mock.config);
+        let h = spawn(move || mock.client.get_node_epoch());
+        write_response(mock.server, pox_response.as_bytes());
+        let mock = MockServerClient::from_config(mock.config);
+        write_response(mock.server, peer_response.as_bytes());
         let epoch = h.join().unwrap().expect("Failed to deserialize response");
         assert_eq!(epoch, StacksEpochId::Epoch30);
     }
@@ -1132,42 +1164,7 @@ mod tests {
     #[test]
     fn get_peer_info_should_succeed() {
         let mock = MockServerClient::new();
-        let private_key = StacksPrivateKey::new();
-        let public_key = StacksPublicKey::from_private(&private_key);
-        let public_key_buf = StacksPublicKeyBuffer::from_public_key(&public_key);
-        let public_key_hash = Hash160::from_node_public_key(&public_key);
-        let stackerdb_contract_ids = vec![boot_code_id("fake", false)];
-
-        let peer_info = RPCPeerInfoData {
-            peer_version: 1,
-            pox_consensus: ConsensusHash([0x04; 20]),
-            burn_block_height: 200,
-            stable_pox_consensus: ConsensusHash([0x05; 20]),
-            stable_burn_block_height: 2,
-            server_version: "fake version".to_string(),
-            network_id: 0,
-            parent_network_id: 1,
-            stacks_tip_height: 20,
-            stacks_tip: BlockHeaderHash([0x06; 32]),
-            stacks_tip_consensus_hash: ConsensusHash([0x07; 20]),
-            unanchored_tip: None,
-            unanchored_seq: Some(1),
-            exit_at_block_height: None,
-            genesis_chainstate_hash: Sha256Sum::zero(),
-            node_public_key: Some(public_key_buf),
-            node_public_key_hash: Some(public_key_hash),
-            affirmations: None,
-            last_pox_anchor: None,
-            stackerdbs: Some(
-                stackerdb_contract_ids
-                    .into_iter()
-                    .map(|cid| format!("{}", cid))
-                    .collect(),
-            ),
-        };
-        let peer_info_json =
-            serde_json::to_string(&peer_info).expect("Failed to serialize peer info");
-        let response = format!("HTTP/1.1 200 OK\n\n{peer_info_json}");
+        let (response, peer_info) = build_get_peer_info_response(None, None, None);
         let h = spawn(move || mock.client.get_peer_info());
         write_response(mock.server, response.as_bytes());
         assert_eq!(h.join().unwrap().unwrap(), peer_info);
@@ -1216,27 +1213,36 @@ mod tests {
     #[test]
     #[serial]
     fn get_reward_set_calculated() {
-        let consensus_hash = "64c8c3049ff6b939c65828e3168210e6bb32d880".to_string();
-
         // Should return TRUE as the passed in reward cycle is older than the current reward cycle of the node
         let mock = MockServerClient::new();
-        let pox_response = build_get_pox_data_response(2, 10);
-        let h = spawn(move || mock.client.reward_set_calculated(0));
+        let reward_cycle = 10;
+        let pox_response = build_get_pox_data_response(Some(reward_cycle), None, None, None).0;
+        let h = spawn(move || {
+            mock.client
+                .reward_set_calculated(reward_cycle.saturating_sub(1))
+        });
         write_response(mock.server, pox_response.as_bytes());
         assert!(h.join().unwrap().unwrap());
 
         // Should return TRUE as the passed in reward cycle is the same as the current reward cycle
         let mock = MockServerClient::from_config(mock.config);
-        let pox_response = build_get_pox_data_response(2, 10);
-        let h = spawn(move || mock.client.reward_set_calculated(2));
+        let pox_response = build_get_pox_data_response(Some(reward_cycle), None, None, None).0;
+        let h = spawn(move || mock.client.reward_set_calculated(reward_cycle));
         write_response(mock.server, pox_response.as_bytes());
         assert!(h.join().unwrap().unwrap());
 
         // Should return TRUE as the passed in reward cycle is the NEXT reward cycle AND the prepare phase is in its SECOND block
         let mock = MockServerClient::from_config(mock.config);
-        let pox_response = build_get_pox_data_response(2, 10);
-        let peer_response = build_get_peer_info_response(11, consensus_hash.clone());
-        let h = spawn(move || mock.client.reward_set_calculated(3));
+        let prepare_phase_start = 10;
+        let pox_response =
+            build_get_pox_data_response(Some(reward_cycle), Some(prepare_phase_start), None, None)
+                .0;
+        let peer_response =
+            build_get_peer_info_response(Some(prepare_phase_start.saturating_add(1)), None, None).0;
+        let h = spawn(move || {
+            mock.client
+                .reward_set_calculated(reward_cycle.saturating_add(1))
+        });
         write_response(mock.server, pox_response.as_bytes());
         let mock = MockServerClient::from_config(mock.config);
         write_response(mock.server, peer_response.as_bytes());
@@ -1244,52 +1250,39 @@ mod tests {
 
         // Should return FALSE as the passed in reward cycle is NEWER than the NEXT reward cycle of the node
         let mock = MockServerClient::from_config(mock.config);
-        let pox_response = build_get_pox_data_response(2, 10);
-        let h = spawn(move || mock.client.reward_set_calculated(4));
+        let pox_response = build_get_pox_data_response(Some(reward_cycle), None, None, None).0;
+        let h = spawn(move || {
+            mock.client
+                .reward_set_calculated(reward_cycle.saturating_add(2))
+        });
         write_response(mock.server, pox_response.as_bytes());
         assert!(!h.join().unwrap().unwrap());
 
         // Should return FALSE as the passed in reward cycle is the NEXT reward cycle BUT the prepare phase is in its FIRST block
         let mock = MockServerClient::from_config(mock.config);
-        let pox_response = build_get_pox_data_response(2, 11);
-        let peer_response = build_get_peer_info_response(11, consensus_hash);
-        let h = spawn(move || mock.client.reward_set_calculated(3));
+        let pox_response =
+            build_get_pox_data_response(Some(reward_cycle), Some(prepare_phase_start), None, None)
+                .0;
+        let peer_response = build_get_peer_info_response(Some(prepare_phase_start), None, None).0;
+        let h = spawn(move || {
+            mock.client
+                .reward_set_calculated(reward_cycle.saturating_add(1))
+        });
         write_response(mock.server, pox_response.as_bytes());
         let mock = MockServerClient::from_config(mock.config);
         write_response(mock.server, peer_response.as_bytes());
         assert!(!h.join().unwrap().unwrap());
     }
 
-    fn generate_random_consensus_hash() -> String {
-        let rng = rand::thread_rng();
-        let bytes: Vec<u8> = rng.sample_iter(Standard).take(20).collect();
-        let hex_string = bytes.iter().fold(String::new(), |mut acc, &b| {
-            write!(&mut acc, "{:02x}", b).expect("Error writing to string");
-            acc
-        });
-        hex_string
-    }
-
-    fn build_get_stacks_tip_consensus_hash(random_consensus: bool) -> String {
-        let consensus_hash = match random_consensus {
-            true => generate_random_consensus_hash(),
-            false => "64c8c3049ff6b939c65828e3168210e6bb32d880".to_string(),
-        };
-
-        println!("{}", consensus_hash);
-        let stacks_tip_height = thread_rng().next_u64();
-        build_get_peer_info_response(stacks_tip_height, consensus_hash)
-    }
-
     #[test]
-    fn calculate_coordinator_should_produce_unique_results() {
+    fn calculate_coordinator_different_consensus_hashes_produces_unique_results() {
         let number_of_tests = 5;
         let generated_public_keys = generate_reward_cycle_config(10, 4000, None).0.public_keys;
         let mut results = Vec::new();
 
         for _ in 0..number_of_tests {
             let mock = MockServerClient::new();
-            let response = build_get_stacks_tip_consensus_hash(true);
+            let response = build_get_peer_info_response(None, None, None).0;
             let generated_public_keys = generated_public_keys.clone();
             let h = spawn(move || mock.client.calculate_coordinator(&generated_public_keys));
             write_response(mock.server, response.as_bytes());
@@ -1311,13 +1304,22 @@ mod tests {
         );
     }
 
-    fn generate_test_results(random_consensus: bool, count: usize) -> Vec<(u32, ecdsa::PublicKey)> {
+    fn generate_calculate_coordinator_test_results(
+        random_consensus: bool,
+        count: usize,
+    ) -> Vec<(u32, ecdsa::PublicKey)> {
         let mut results = Vec::new();
+        let same_hash = generate_random_consensus_hash();
+        let hash = if random_consensus {
+            None
+        } else {
+            Some(same_hash)
+        };
         let generated_public_keys = generate_reward_cycle_config(10, 4000, None).0.public_keys;
         for _ in 0..count {
             let mock = MockServerClient::new();
             let generated_public_keys = generated_public_keys.clone();
-            let response = build_get_stacks_tip_consensus_hash(random_consensus);
+            let response = build_get_peer_info_response(None, None, hash).0;
             let h = spawn(move || mock.client.calculate_coordinator(&generated_public_keys));
             write_response(mock.server, response.as_bytes());
             let result = h.join().unwrap();
@@ -1328,7 +1330,7 @@ mod tests {
 
     #[test]
     fn calculate_coordinator_results_should_vary_or_match_based_on_hash() {
-        let results_with_random_hash = generate_test_results(true, 5);
+        let results_with_random_hash = generate_calculate_coordinator_test_results(true, 5);
         let all_ids_same = results_with_random_hash
             .iter()
             .all(|&(id, _)| id == results_with_random_hash[0].0);
@@ -1341,7 +1343,7 @@ mod tests {
             "Not all coordinator public keys should be the same"
         );
 
-        let results_with_static_hash = generate_test_results(false, 5);
+        let results_with_static_hash = generate_calculate_coordinator_test_results(false, 5);
         let all_ids_same = results_with_static_hash
             .iter()
             .all(|&(id, _)| id == results_with_static_hash[0].0);

From 6ae69a8abedcab35ba5a23d9edaaddb1b5a8608c Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Thu, 8 Feb 2024 11:33:07 -0800
Subject: [PATCH 0873/1166] Do not overwrite aggregate key if none. May have
 delay between cast and contract setting of aggregate key

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/signer.rs | 20 +++++++++++++++-----
 1 file changed, 15 insertions(+), 5 deletions(-)

diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index 3e81988c97..6c29601ea0 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -1047,13 +1047,23 @@ impl Signer {
     /// Update the DKG for the provided signer info, triggering it if required
     pub fn update_dkg(&mut self, stacks_client: &StacksClient) -> Result<(), ClientError> {
         let reward_cycle = self.reward_cycle;
-        let aggregate_public_key = stacks_client.get_aggregate_public_key(reward_cycle)?;
-        self.coordinator
-            .set_aggregate_public_key(aggregate_public_key);
+        let new_aggregate_public_key = stacks_client.get_aggregate_public_key(reward_cycle)?;
+        let old_aggregate_public_key = self.coordinator.get_aggregate_public_key();
+        if new_aggregate_public_key.is_some()
+            && old_aggregate_public_key != new_aggregate_public_key
+        {
+            debug!(
+                "Signer #{}: Received a new aggregate public key ({new_aggregate_public_key:?}) for reward cycle {reward_cycle}. Overwriting its internal aggregate key ({old_aggregate_public_key:?})",
+                self.signer_id
+            );
+            self.coordinator
+                .set_aggregate_public_key(new_aggregate_public_key);
+        }
         let coordinator_id = stacks_client
             .calculate_coordinator(&self.signing_round.public_keys)
             .0;
-        if aggregate_public_key.is_none()
+        // TOOD: should check if we have an aggregate key before we trigger another round. may have a delay between us calculating a key, broadcasting to the contract, and it being confirmed by the miner.
+        if new_aggregate_public_key.is_none()
             && self.signer_id == coordinator_id
             && self.coordinator.state == CoordinatorState::Idle
         {
@@ -1063,7 +1073,7 @@ impl Signer {
             }
         } else {
             debug!("Signer #{}: Not triggering a DKG round.", self.signer_id;
-                "aggregate_public_key" => aggregate_public_key.is_some(),
+                "aggregate_public_key" => new_aggregate_public_key.is_some(),
                 "coordinator_id" => coordinator_id,
                 "coordinator_idle" => self.coordinator.state == CoordinatorState::Idle,
             );

From 84e25676e265c157544df91f95e3930a4cd78b1d Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Thu, 8 Feb 2024 14:18:54 -0800
Subject: [PATCH 0874/1166] Compare prepare phase start with burn block height

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/mod.rs           |  3 +--
 stacks-signer/src/client/stacks_client.rs | 29 +++++++++++------------
 2 files changed, 15 insertions(+), 17 deletions(-)

diff --git a/stacks-signer/src/client/mod.rs b/stacks-signer/src/client/mod.rs
index 0f3fa80a7a..7f36bbf745 100644
--- a/stacks-signer/src/client/mod.rs
+++ b/stacks-signer/src/client/mod.rs
@@ -342,7 +342,6 @@ pub(crate) mod tests {
 
     /// Build a response for the get_peer_info request with a specific stacks tip height and consensus hash
     pub fn build_get_peer_info_response(
-        stacks_tip_height: Option<u64>,
         burn_block_height: Option<u64>,
         stacks_tip_consensus_hash: Option<ConsensusHash>,
     ) -> (String, RPCPeerInfoData) {
@@ -362,7 +361,7 @@ pub(crate) mod tests {
             server_version: "fake version".to_string(),
             network_id: thread_rng().next_u32(),
             parent_network_id: thread_rng().next_u32(),
-            stacks_tip_height: stacks_tip_height.unwrap_or(thread_rng().next_u64()),
+            stacks_tip_height: thread_rng().next_u64(),
             stacks_tip: BlockHeaderHash([0x06; 32]),
             stacks_tip_consensus_hash: stacks_tip_consensus_hash
                 .unwrap_or(generate_random_consensus_hash()),
diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index d37e33e39a..23a520bbc5 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -329,10 +329,9 @@ impl StacksClient {
             // We are not in the prepare phase of the reward cycle as the upcoming cycle nor are we in the current reward cycle...
             return Ok(false);
         }
-        let peer_info = self.get_peer_info()?;
-        let stacks_tip_height = peer_info.stacks_tip_height;
+        let burn_block_height = self.get_burn_block_height()?;
         // Have we passed the first block of the new reward cycle's prepare phase?
-        Ok(pox_info.next_cycle.prepare_phase_start_block_height < stacks_tip_height)
+        Ok(pox_info.next_cycle.prepare_phase_start_block_height < burn_block_height)
     }
 
     /// Get the reward set from the stacks node for the given reward cycle
@@ -944,7 +943,7 @@ mod tests {
     fn core_info_call_for_consensus_hash_should_succeed() {
         let mock = MockServerClient::new();
         let h = spawn(move || mock.client.get_stacks_tip_consensus_hash());
-        let (response, peer_info) = build_get_peer_info_response(None, None, None);
+        let (response, peer_info) = build_get_peer_info_response(None, None);
         write_response(mock.server, response.as_bytes());
         let consensus_hash = h.join().unwrap().expect("Failed to deserialize response");
         assert_eq!(consensus_hash, peer_info.stacks_tip_consensus_hash);
@@ -965,7 +964,7 @@ mod tests {
     fn core_info_call_for_burn_block_height_should_succeed() {
         let mock = MockServerClient::new();
         let h = spawn(move || mock.client.get_burn_block_height());
-        let (response, peer_info) = build_get_peer_info_response(None, None, None);
+        let (response, peer_info) = build_get_peer_info_response(None, None);
         write_response(mock.server, response.as_bytes());
         let burn_block_height = h.join().unwrap().expect("Failed to deserialize response");
         assert_eq!(burn_block_height, peer_info.burn_block_height);
@@ -1030,7 +1029,7 @@ mod tests {
             None,
         )
         .0;
-        let peer_response = build_get_peer_info_response(None, Some(burn_block_height), None).0;
+        let peer_response = build_get_peer_info_response(Some(burn_block_height), None).0;
         let h = spawn(move || mock.client.get_node_epoch());
         write_response(mock.server, pox_response.as_bytes());
         let mock = MockServerClient::from_config(mock.config);
@@ -1040,7 +1039,7 @@ mod tests {
 
         // The burn block height is the same as the activation height of 2.5, therefore is 2.5
         let pox_response = build_get_pox_data_response(None, None, Some(burn_block_height), None).0;
-        let peer_response = build_get_peer_info_response(None, Some(burn_block_height), None).0;
+        let peer_response = build_get_peer_info_response(Some(burn_block_height), None).0;
         let mock = MockServerClient::from_config(mock.config);
         let h = spawn(move || mock.client.get_node_epoch());
         write_response(mock.server, pox_response.as_bytes());
@@ -1057,7 +1056,7 @@ mod tests {
             Some(burn_block_height.saturating_add(1)),
         )
         .0;
-        let peer_response = build_get_peer_info_response(None, Some(burn_block_height), None).0;
+        let peer_response = build_get_peer_info_response(Some(burn_block_height), None).0;
         let mock = MockServerClient::from_config(mock.config);
         let h = spawn(move || mock.client.get_node_epoch());
         write_response(mock.server, pox_response.as_bytes());
@@ -1074,7 +1073,7 @@ mod tests {
             Some(burn_block_height),
         )
         .0;
-        let peer_response = build_get_peer_info_response(None, Some(burn_block_height), None).0;
+        let peer_response = build_get_peer_info_response(Some(burn_block_height), None).0;
         let mock = MockServerClient::from_config(mock.config);
         let h = spawn(move || mock.client.get_node_epoch());
         write_response(mock.server, pox_response.as_bytes());
@@ -1092,7 +1091,7 @@ mod tests {
         )
         .0;
         let peer_response =
-            build_get_peer_info_response(None, Some(burn_block_height.saturating_add(1)), None).0;
+            build_get_peer_info_response(Some(burn_block_height.saturating_add(1)), None).0;
         let mock = MockServerClient::from_config(mock.config);
         let h = spawn(move || mock.client.get_node_epoch());
         write_response(mock.server, pox_response.as_bytes());
@@ -1164,7 +1163,7 @@ mod tests {
     #[test]
     fn get_peer_info_should_succeed() {
         let mock = MockServerClient::new();
-        let (response, peer_info) = build_get_peer_info_response(None, None, None);
+        let (response, peer_info) = build_get_peer_info_response(None, None);
         let h = spawn(move || mock.client.get_peer_info());
         write_response(mock.server, response.as_bytes());
         assert_eq!(h.join().unwrap().unwrap(), peer_info);
@@ -1238,7 +1237,7 @@ mod tests {
             build_get_pox_data_response(Some(reward_cycle), Some(prepare_phase_start), None, None)
                 .0;
         let peer_response =
-            build_get_peer_info_response(Some(prepare_phase_start.saturating_add(1)), None, None).0;
+            build_get_peer_info_response(Some(prepare_phase_start.saturating_add(1)), None).0;
         let h = spawn(move || {
             mock.client
                 .reward_set_calculated(reward_cycle.saturating_add(1))
@@ -1263,7 +1262,7 @@ mod tests {
         let pox_response =
             build_get_pox_data_response(Some(reward_cycle), Some(prepare_phase_start), None, None)
                 .0;
-        let peer_response = build_get_peer_info_response(Some(prepare_phase_start), None, None).0;
+        let peer_response = build_get_peer_info_response(Some(prepare_phase_start), None).0;
         let h = spawn(move || {
             mock.client
                 .reward_set_calculated(reward_cycle.saturating_add(1))
@@ -1282,7 +1281,7 @@ mod tests {
 
         for _ in 0..number_of_tests {
             let mock = MockServerClient::new();
-            let response = build_get_peer_info_response(None, None, None).0;
+            let response = build_get_peer_info_response(None, None).0;
             let generated_public_keys = generated_public_keys.clone();
             let h = spawn(move || mock.client.calculate_coordinator(&generated_public_keys));
             write_response(mock.server, response.as_bytes());
@@ -1319,7 +1318,7 @@ mod tests {
         for _ in 0..count {
             let mock = MockServerClient::new();
             let generated_public_keys = generated_public_keys.clone();
-            let response = build_get_peer_info_response(None, None, hash).0;
+            let response = build_get_peer_info_response(None, hash).0;
             let h = spawn(move || mock.client.calculate_coordinator(&generated_public_keys));
             write_response(mock.server, response.as_bytes());
             let result = h.join().unwrap();

From b9eef9478e48cd70ce935415c2a2f696370b5e48 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Thu, 8 Feb 2024 14:48:53 -0800
Subject: [PATCH 0875/1166] Fix cast aggregate public key vote transaction

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/mod.rs               |  2 +-
 stacks-signer/src/client/stacks_client.rs     | 55 +++++++--------
 stacks-signer/src/signer.rs                   | 45 +++++-------
 .../src/tests/nakamoto_integrations.rs        | 70 +++++++++++++++++--
 testnet/stacks-node/src/tests/signer.rs       | 10 +--
 5 files changed, 117 insertions(+), 65 deletions(-)

diff --git a/stacks-signer/src/client/mod.rs b/stacks-signer/src/client/mod.rs
index 7f36bbf745..c985c2a743 100644
--- a/stacks-signer/src/client/mod.rs
+++ b/stacks-signer/src/client/mod.rs
@@ -229,7 +229,7 @@ pub(crate) mod tests {
 
     /// Build a response for the get_last_round request
     pub fn build_get_last_round_response(round: u64) -> String {
-        let value = ClarityValue::okay(ClarityValue::UInt(round as u128))
+        let value = ClarityValue::some(ClarityValue::UInt(round as u128))
             .expect("Failed to create response");
         build_read_only_response(&value)
     }
diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index 23a520bbc5..69fadc0283 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -279,26 +279,30 @@ impl StacksClient {
     }
 
     /// Retrieve the last DKG vote round number for the current reward cycle
-    pub fn get_last_round(&self, reward_cycle: u64) -> Result<u64, ClientError> {
+    pub fn get_last_round(&self, reward_cycle: u64) -> Result<Option<u64>, ClientError> {
         debug!("Getting the last DKG vote round of reward cycle {reward_cycle}...");
         let contract_addr = boot_code_addr(self.chain_id == CHAIN_ID_MAINNET);
         let contract_name = ContractName::from(SIGNERS_VOTING_NAME);
         let function_name = ClarityName::from("get-last-round");
         let function_args = &[ClarityValue::UInt(reward_cycle as u128)];
-        let last_round = u64::try_from(
-            self.read_only_contract_call(
+        let opt_value = self
+            .read_only_contract_call(
                 &contract_addr,
                 &contract_name,
                 &function_name,
                 function_args,
             )?
-            .expect_result_ok()?
-            .expect_u128()?,
-        )
-        .map_err(|e| {
-            ClientError::MalformedContractData(format!("Failed to convert vote round to u64: {e}"))
-        })?;
-        Ok(last_round)
+            .expect_optional()?;
+        let round = if let Some(value) = opt_value {
+            Some(u64::try_from(value.expect_u128()?).map_err(|e| {
+                ClientError::MalformedContractData(format!(
+                    "Failed to convert vote round to u64: {e}"
+                ))
+            })?)
+        } else {
+            None
+        };
+        Ok(round)
     }
 
     /// Retrieve the vote of the signer for the given round
@@ -431,13 +435,12 @@ impl StacksClient {
     /// Cast a vote for the given aggregate public key by broadcasting it to the mempool
     pub fn cast_vote_for_aggregate_public_key(
         &self,
-        reward_cycle: u64,
         signer_index: u32,
+        round: u64,
         point: Point,
     ) -> Result<StacksTransaction, ClientError> {
+        let signed_tx = self.build_vote_for_aggregate_public_key(signer_index, round, point)?;
         debug!("Casting vote for aggregate public key to the mempool...");
-        let signed_tx =
-            self.build_vote_for_aggregate_public_key(reward_cycle, signer_index, point)?;
         self.submit_tx(&signed_tx)?;
         Ok(signed_tx)
     }
@@ -445,28 +448,27 @@ impl StacksClient {
     /// Helper function to create a stacks transaction for a modifying contract call
     pub fn build_vote_for_aggregate_public_key(
         &self,
-        reward_cycle: u64,
         signer_index: u32,
+        round: u64,
         point: Point,
     ) -> Result<StacksTransaction, ClientError> {
         debug!("Building {VOTE_FUNCTION_NAME} transaction...");
-        let round = self.get_last_round(reward_cycle)?;
         // TODO: this nonce should be calculated on the side as we may have pending transactions that are not yet confirmed...
         let nonce = self.get_account_nonce(&self.stacks_address)?;
         let contract_address = boot_code_addr(self.chain_id == CHAIN_ID_MAINNET);
-        let contract_name = ContractName::from(POX_4_NAME); //TODO update this to POX_4_VOTE_NAME when the contract is deployed
+        let contract_name = ContractName::from(SIGNERS_VOTING_NAME);
         let function_name = ClarityName::from(VOTE_FUNCTION_NAME);
-        let function_args = &[
+        let function_args = vec![
             ClarityValue::UInt(signer_index as u128),
+            ClarityValue::buff_from(point.compress().data.to_vec())?,
             ClarityValue::UInt(round as u128),
-            ClarityValue::buff_from(point.compress().as_bytes().to_vec())?,
         ];
 
         let tx_payload = TransactionPayload::ContractCall(TransactionContractCall {
             address: contract_address,
             contract_name,
             function_name,
-            function_args: function_args.to_vec(),
+            function_args,
         });
         let public_key = StacksPublicKey::from_private(&self.stacks_private_key);
         let tx_auth = TransactionAuth::Standard(
@@ -508,7 +510,10 @@ impl StacksClient {
                 .header("Content-Type", "application/octet-stream")
                 .body(tx.clone())
                 .send()
-                .map_err(backoff::Error::transient)
+                .map_err(|e| {
+                    debug!("Failed to submit transaction to the Stacks node: {e:?}");
+                    backoff::Error::transient(e)
+                })
         };
         let response = retry_with_exponential_backoff(send_request)?;
         if !response.status().is_success() {
@@ -904,14 +909,10 @@ mod tests {
     fn build_vote_for_aggregate_public_key_should_succeed() {
         let mock = MockServerClient::new();
         let point = Point::from(Scalar::random(&mut rand::thread_rng()));
-        let round = rand::thread_rng().next_u64();
-        let round_response = build_get_last_round_response(round);
         let nonce = thread_rng().next_u64();
         let account_nonce_response = build_account_nonce_response(nonce);
 
         let h = spawn(move || mock.client.build_vote_for_aggregate_public_key(0, 0, point));
-        write_response(mock.server, round_response.as_bytes());
-        let mock = MockServerClient::from_config(mock.config);
         write_response(mock.server, account_nonce_response.as_bytes());
         assert!(h.join().unwrap().is_ok());
     }
@@ -922,14 +923,10 @@ mod tests {
     fn cast_vote_for_aggregate_public_key_should_succeed() {
         let mock = MockServerClient::new();
         let point = Point::from(Scalar::random(&mut rand::thread_rng()));
-        let round = rand::thread_rng().next_u64();
-        let round_response = build_get_last_round_response(round);
         let nonce = thread_rng().next_u64();
         let account_nonce_response = build_account_nonce_response(nonce);
 
         let h = spawn(move || mock.client.cast_vote_for_aggregate_public_key(0, 0, point));
-        write_response(mock.server, round_response.as_bytes());
-        let mock = MockServerClient::from_config(mock.config);
         write_response(mock.server, account_nonce_response.as_bytes());
         let mock = MockServerClient::from_config(mock.config);
         write_response(
@@ -1177,7 +1174,7 @@ mod tests {
         let h = spawn(move || mock.client.get_last_round(0));
 
         write_response(mock.server, response.as_bytes());
-        assert_eq!(h.join().unwrap().unwrap(), round);
+        assert_eq!(h.join().unwrap().unwrap().unwrap(), round);
     }
 
     #[test]
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index 6c29601ea0..3db9fd119a 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -189,26 +189,30 @@ impl Signer {
     }
 
     /// Execute the given command and update state accordingly
-    /// Returns true when it is successfully executed, else false
-    fn execute_command(&mut self, command: &Command) -> bool {
+    fn execute_command(&mut self, stacks_client: &StacksClient, command: &Command) {
         match command {
             Command::Dkg => {
-                info!("Signer #{}: Starting DKG", self.signer_id);
+                let vote_round = match retry_with_exponential_backoff(|| {
+                    stacks_client
+                        .get_last_round(self.reward_cycle)
+                        .map_err(backoff::Error::transient)
+                }) {
+                    Ok(last_round) => last_round,
+                    Err(e) => {
+                        error!("Signer #{}: Unable to perform DKG. Failed to get last round from stacks node: {e:?}", self.signer_id);
+                        return;
+                    }
+                };
+                // The dkg id will increment internally following "start_dkg_round" so do not increment it here
+                self.coordinator.current_dkg_id = vote_round.unwrap_or(0);
                 match self.coordinator.start_dkg_round() {
                     Ok(msg) => {
                         let ack = self.stackerdb.send_message_with_retry(msg.into());
                         debug!("Signer #{}: ACK: {ack:?}", self.signer_id);
                         self.state = State::Dkg;
-                        true
                     }
                     Err(e) => {
                         error!("Signer #{}: Failed to start DKG: {e:?}", self.signer_id);
-                        warn!(
-                            "Signer #{}: Resetting coordinator's internal state.",
-                            self.signer_id
-                        );
-                        self.coordinator.reset();
-                        false
                     }
                 }
             }
@@ -224,7 +228,7 @@ impl Signer {
                     .or_insert_with(|| BlockInfo::new(block.clone()));
                 if block_info.signed_over {
                     debug!("Signer #{}: Received a sign command for a block we are already signing over. Ignore it.", self.signer_id);
-                    return false;
+                    return;
                 }
                 info!("Signer #{}: Signing block: {block:?}", self.signer_id);
                 match self.coordinator.start_signing_round(
@@ -237,19 +241,12 @@ impl Signer {
                         debug!("Signer #{}: ACK: {ack:?}", self.signer_id);
                         self.state = State::Sign;
                         block_info.signed_over = true;
-                        true
                     }
                     Err(e) => {
                         error!(
                             "Signer #{}: Failed to start signing message: {e:?}",
                             self.signer_id
                         );
-                        warn!(
-                            "Signer #{}: Resetting coordinator's internal state.",
-                            self.signer_id
-                        );
-                        self.coordinator.reset();
-                        false
                     }
                 }
             }
@@ -271,12 +268,7 @@ impl Signer {
                 }
 
                 if let Some(command) = self.commands.pop_front() {
-                    while !self.execute_command(&command) {
-                        warn!(
-                            "Signer #{}: Failed to execute command. Retrying...",
-                            self.signer_id
-                        );
-                    }
+                    self.execute_command(stacks_client, &command);
                 } else {
                     debug!(
                         "Signer #{}: Nothing to process. Waiting for command...",
@@ -794,8 +786,8 @@ impl Signer {
                             match retry_with_exponential_backoff(|| {
                                 stacks_client
                                     .cast_vote_for_aggregate_public_key(
-                                        self.reward_cycle,
                                         self.stackerdb.get_signer_slot_id(),
+                                        self.coordinator.current_dkg_id,
                                         *point,
                                     )
                                     .map_err(backoff::Error::transient)
@@ -818,8 +810,8 @@ impl Signer {
                             match retry_with_exponential_backoff(|| {
                                 stacks_client
                                     .build_vote_for_aggregate_public_key(
-                                        self.reward_cycle,
                                         self.stackerdb.get_signer_slot_id(),
+                                        self.coordinator.current_dkg_id,
                                         *point,
                                     )
                                     .map_err(backoff::Error::transient)
@@ -1066,6 +1058,7 @@ impl Signer {
         if new_aggregate_public_key.is_none()
             && self.signer_id == coordinator_id
             && self.coordinator.state == CoordinatorState::Idle
+        // Have I already voted and have a pending transaction? Check stackerdb for the same round number and reward cycle
         {
             info!("Signer #{} is the current coordinator for {reward_cycle}. Triggering a DKG round...", self.signer_id);
             if self.commands.back() != Some(&Command::Dkg) {
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 7da10b6235..d2e2277ea1 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -357,7 +357,6 @@ pub fn setup_stacker(naka_conf: &mut Config) -> Secp256k1PrivateKey {
 ///
 /// * `stacker_sks` - must be a private key for sending a large `stack-stx` transaction in order
 ///   for pox-4 to activate
-/// * `signer_pks` - must be the same size as `stacker_sks`
 pub fn boot_to_epoch_3(
     naka_conf: &Config,
     blocks_processed: &RunLoopCounter,
@@ -370,10 +369,9 @@ pub fn boot_to_epoch_3(
     let epochs = naka_conf.burnchain.epochs.clone().unwrap();
     let epoch_3 = &epochs[StacksEpoch::find_epoch_by_id(&epochs, StacksEpochId::Epoch30).unwrap()];
 
-    let epoch_30_start_height = epoch_3.start_height - 1;
     info!(
         "Chain bootstrapped to bitcoin block 201, starting Epoch 2x miner";
-        "Epoch 3.0 Boundary" => epoch_30_start_height,
+        "Epoch 3.0 Boundary" => (epoch_3.start_height - 1),
     );
     let http_origin = format!("http://{}", &naka_conf.node.rpc_bind);
     next_block_and_wait(btc_regtest_controller, &blocks_processed);
@@ -476,7 +474,7 @@ pub fn boot_to_epoch_3(
     run_until_burnchain_height(
         btc_regtest_controller,
         &blocks_processed,
-        epoch_30_start_height,
+        epoch_3.start_height - 1,
         &naka_conf,
     );
 
@@ -584,6 +582,70 @@ fn signer_vote_if_needed(
     }
 }
 
+///
+/// * `stacker_sks` - must be a private key for sending a large `stack-stx` transaction in order
+///   for pox-4 to activate
+/// * `signer_pks` - must be the same size as `stacker_sks`
+pub fn boot_to_epoch_3_reward_set(
+    naka_conf: &Config,
+    blocks_processed: &RunLoopCounter,
+    stacker_sks: &[Secp256k1PrivateKey],
+    signer_pks: &[StacksPublicKey],
+    btc_regtest_controller: &mut BitcoinRegtestController,
+) {
+    assert_eq!(stacker_sks.len(), signer_pks.len());
+
+    let epochs = naka_conf.burnchain.epochs.clone().unwrap();
+    let epoch_3 = &epochs[StacksEpoch::find_epoch_by_id(&epochs, StacksEpochId::Epoch30).unwrap()];
+    let prepare_phase_len = naka_conf.get_burnchain().pox_constants.prepare_length;
+    let epoch_30_reward_set_calculation = epoch_3.start_height - prepare_phase_len as u64;
+    info!(
+        "Chain bootstrapped to bitcoin block 201, starting Epoch 2x miner";
+        "Epoch 3.0 Reward Set Calculation Height" => epoch_30_reward_set_calculation,
+    );
+    let http_origin = format!("http://{}", &naka_conf.node.rpc_bind);
+    next_block_and_wait(btc_regtest_controller, &blocks_processed);
+    next_block_and_wait(btc_regtest_controller, &blocks_processed);
+    // first mined stacks block
+    next_block_and_wait(btc_regtest_controller, &blocks_processed);
+
+    // stack enough to activate pox-4
+    let pox_addr_tuple = clarity::vm::tests::execute(&format!(
+        "{{ hashbytes: 0x{}, version: 0x{:02x} }}",
+        to_hex(&[0; 20]),
+        AddressHashMode::SerializeP2PKH as u8,
+    ));
+
+    for (stacker_sk, signer_pk) in stacker_sks.iter().zip(signer_pks.iter()) {
+        let stacking_tx = tests::make_contract_call(
+            &stacker_sk,
+            0,
+            1000,
+            &StacksAddress::burn_address(false),
+            "pox-4",
+            "stack-stx",
+            &[
+                clarity::vm::Value::UInt(POX_4_DEFAULT_STACKER_STX_AMT),
+                pox_addr_tuple.clone(),
+                clarity::vm::Value::UInt(205),
+                clarity::vm::Value::UInt(12),
+                clarity::vm::Value::buff_from(signer_pk.to_bytes_compressed()).unwrap(),
+            ],
+        );
+
+        submit_tx(&http_origin, &stacking_tx);
+    }
+
+    run_until_burnchain_height(
+        btc_regtest_controller,
+        &blocks_processed,
+        epoch_30_reward_set_calculation,
+        &naka_conf,
+    );
+
+    info!("Bootstrapped to Epoch-3.0 reward set calculation height.");
+}
+
 #[test]
 #[ignore]
 /// This test spins up a nakamoto-neon node.
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index fb85f7c7df..3963ea6848 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -44,8 +44,8 @@ use crate::neon::Counters;
 use crate::run_loop::boot_nakamoto;
 use crate::tests::bitcoin_regtest::BitcoinCoreController;
 use crate::tests::nakamoto_integrations::{
-    boot_to_epoch_3, naka_neon_integration_conf, next_block_and, next_block_and_mine_commit,
-    POX_4_DEFAULT_STACKER_BALANCE,
+    boot_to_epoch_3_reward_set, naka_neon_integration_conf, next_block_and,
+    next_block_and_mine_commit, POX_4_DEFAULT_STACKER_BALANCE,
 };
 use crate::tests::neon_integrations::{next_block_and_wait, test_observer, wait_for_runloop};
 use crate::tests::to_addr;
@@ -263,8 +263,8 @@ fn setup_stx_btc_node(
     info!("Mine third block...");
     next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
 
-    info!("Boot to epoch 3.0 to activate pox-4...");
-    boot_to_epoch_3(
+    info!("Boot to epoch 2.5 to activate pox-4...");
+    boot_to_epoch_3_reward_set(
         &naka_conf,
         &blocks_processed,
         signer_stacks_private_keys,
@@ -272,7 +272,7 @@ fn setup_stx_btc_node(
         &mut btc_regtest_controller,
     );
 
-    info!("Pox 4 activated and ready for signers to perform DKG and Sign!");
+    info!("Pox 4 activated and Nakamoto's first reward set calculated! Ready for signers to perform DKG!");
     RunningNodes {
         btcd_controller,
         btc_regtest_controller,

From 2d412b8e64d484a3c0fb9a55459722b6a54bb8aa Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Thu, 8 Feb 2024 17:29:06 -0800
Subject: [PATCH 0876/1166] Cleanup

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/stacks_client.rs |  53 ++--
 stacks-signer/src/signer.rs               | 331 ++++++++++++++--------
 testnet/stacks-node/src/tests/signer.rs   | 165 ++++++-----
 3 files changed, 339 insertions(+), 210 deletions(-)

diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index 69fadc0283..6864a2f707 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -29,17 +29,17 @@ use blockstack_lib::net::api::getstackers::GetStackersResponse;
 use blockstack_lib::net::api::postblock_proposal::NakamotoBlockProposal;
 use blockstack_lib::util_lib::boot::{boot_code_addr, boot_code_id};
 use clarity::vm::types::{PrincipalData, QualifiedContractIdentifier};
-use clarity::vm::{ClarityName, ContractName, Value as ClarityValue, Value};
+use clarity::vm::{ClarityName, ContractName, Value as ClarityValue};
 use serde_json::json;
-use slog::slog_debug;
+use slog::{slog_debug, slog_warn};
 use stacks_common::codec::StacksMessageCodec;
 use stacks_common::consts::CHAIN_ID_MAINNET;
-use stacks_common::debug;
 use stacks_common::types::chainstate::{
     ConsensusHash, StacksAddress, StacksPrivateKey, StacksPublicKey,
 };
 use stacks_common::types::StacksEpochId;
 use stacks_common::util::hash::Sha256Sum;
+use stacks_common::{debug, warn};
 use wsts::curve::ecdsa;
 use wsts::curve::point::{Compressed, Point};
 use wsts::state_machine::PublicKeys;
@@ -145,7 +145,7 @@ impl StacksClient {
     ) -> Result<Vec<(StacksAddress, u128)>, ClientError> {
         let function_name_str = "stackerdb-get-signer-slots-page";
         let function_name = ClarityName::from(function_name_str);
-        let function_args = &[Value::UInt(page.into())];
+        let function_args = &[ClarityValue::UInt(page.into())];
         let value = self.read_only_contract_call(
             &stackerdb_contract.issuer.clone().into(),
             &stackerdb_contract.name,
@@ -186,8 +186,23 @@ impl StacksClient {
         Ok(peer_info.stacks_tip_consensus_hash)
     }
 
+    /// Retrieve the stacks node current epoch on a retry
+    /// Will default to Epoch 2.4 if the node does not support the Epoch endpoint
+    pub fn get_node_epoch_with_retry(&self) -> Result<StacksEpochId, ClientError> {
+        retry_with_exponential_backoff(|| match self.get_node_epoch() {
+            Ok(epoch) => Ok(epoch),
+            Err(e) => match e {
+                ClientError::UnsupportedStacksFeature(_) => {
+                    warn!("Stacks Node does not support Epoch endpoint");
+                    Err(backoff::Error::permanent(e))
+                }
+                e => Err(backoff::Error::transient(e)),
+            },
+        })
+    }
+
     /// Determine the stacks node current epoch
-    pub fn get_node_epoch(&self) -> Result<StacksEpochId, ClientError> {
+    fn get_node_epoch(&self) -> Result<StacksEpochId, ClientError> {
         let pox_info = self.get_pox_data()?;
         let burn_block_height = self.get_burn_block_height()?;
 
@@ -432,19 +447,6 @@ impl StacksClient {
         Ok(Some(point))
     }
 
-    /// Cast a vote for the given aggregate public key by broadcasting it to the mempool
-    pub fn cast_vote_for_aggregate_public_key(
-        &self,
-        signer_index: u32,
-        round: u64,
-        point: Point,
-    ) -> Result<StacksTransaction, ClientError> {
-        let signed_tx = self.build_vote_for_aggregate_public_key(signer_index, round, point)?;
-        debug!("Casting vote for aggregate public key to the mempool...");
-        self.submit_tx(&signed_tx)?;
-        Ok(signed_tx)
-    }
-
     /// Helper function to create a stacks transaction for a modifying contract call
     pub fn build_vote_for_aggregate_public_key(
         &self,
@@ -501,7 +503,7 @@ impl StacksClient {
     }
 
     /// Helper function to submit a transaction to the Stacks node
-    fn submit_tx(&self, tx: &StacksTransaction) -> Result<Txid, ClientError> {
+    pub fn broadcast_transaction(&self, tx: &StacksTransaction) -> Result<Txid, ClientError> {
         let txid = tx.txid();
         let tx = tx.serialize_to_vec();
         let send_request = || {
@@ -886,7 +888,7 @@ mod tests {
             + 1;
 
         let tx_clone = tx.clone();
-        let h = spawn(move || mock.client.submit_tx(&tx_clone));
+        let h = spawn(move || mock.client.broadcast_transaction(&tx_clone));
 
         let request_bytes = write_response(
             mock.server,
@@ -920,13 +922,20 @@ mod tests {
     #[ignore]
     #[test]
     #[serial]
-    fn cast_vote_for_aggregate_public_key_should_succeed() {
+    fn broadcast_vote_for_aggregate_public_key_should_succeed() {
         let mock = MockServerClient::new();
         let point = Point::from(Scalar::random(&mut rand::thread_rng()));
         let nonce = thread_rng().next_u64();
         let account_nonce_response = build_account_nonce_response(nonce);
 
-        let h = spawn(move || mock.client.cast_vote_for_aggregate_public_key(0, 0, point));
+        let h = spawn(move || {
+            let tx = mock
+                .client
+                .clone()
+                .build_vote_for_aggregate_public_key(0, 0, point)
+                .unwrap();
+            mock.client.broadcast_transaction(&tx)
+        });
         write_response(mock.server, account_nonce_response.as_bytes());
         let mock = MockServerClient::from_config(mock.config);
         write_response(
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index 3db9fd119a..22f64becf2 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -21,6 +21,7 @@ use blockstack_lib::chainstate::stacks::boot::SIGNERS_VOTING_NAME;
 use blockstack_lib::chainstate::stacks::{StacksTransaction, TransactionPayload};
 use blockstack_lib::net::api::postblock_proposal::BlockValidateResponse;
 use blockstack_lib::util_lib::boot::boot_code_id;
+use clarity::vm::Value as ClarityValue;
 use hashbrown::{HashMap, HashSet};
 use libsigner::{BlockRejection, BlockResponse, RejectCode, SignerEvent, SignerMessage};
 use slog::{slog_debug, slog_error, slog_info, slog_warn};
@@ -31,6 +32,7 @@ use stacks_common::util::hash::Sha512Trunc256Sum;
 use stacks_common::{debug, error, info, warn};
 use wsts::common::{MerkleRoot, Signature};
 use wsts::curve::keys::PublicKey;
+use wsts::curve::point::{Compressed, Point};
 use wsts::net::{Message, NonceRequest, Packet, SignatureShareRequest};
 use wsts::state_machine::coordinator::fire::Coordinator as FireCoordinator;
 use wsts::state_machine::coordinator::{
@@ -221,6 +223,13 @@ impl Signer {
                 is_taproot,
                 merkle_root,
             } => {
+                let epoch = stacks_client
+                    .get_node_epoch_with_retry()
+                    .unwrap_or(StacksEpochId::Epoch24);
+                if epoch != StacksEpochId::Epoch30 {
+                    debug!("Signer #{}: cannot sign blocks in pre Epoch 3.0. Ignoring the sign command.", self.signer_id);
+                    return;
+                };
                 let signer_signature_hash = block.header.signer_signature_hash();
                 let block_info = self
                     .blocks
@@ -651,10 +660,6 @@ impl Signer {
                     // Filter out transactions that have already been confirmed (can happen if a signer did not update stacker db since the last block was processed)
                     let origin_address = transaction.origin_address();
                     let origin_nonce = transaction.get_origin_nonce();
-                    let Ok(account_nonce) = stacks_client.get_account_nonce(&origin_address) else {
-                        warn!("Signer #{}: Unable to get account for address: {origin_address}. Ignoring it for this block...", self.signer_id);
-                        return None;
-                    };
                     let vote_contract_id = boot_code_id(SIGNERS_VOTING_NAME, self.is_mainnet);
                     match &transaction.payload {
                         TransactionPayload::ContractCall(payload) => {
@@ -662,10 +667,19 @@ impl Signer {
                                 // This is not a special cased transaction. We don't care if its in the next block
                                 debug!("Signer #{}: Received an unrecognized transaction. Ignoring it.", self.signer_id;
                                     "origin_address" => origin_address.to_string(),
-                                    "orign_nonce" => origin_nonce,
                                     "txid" => transaction.txid().to_string(),
                                     "contract_id" => payload.contract_identifier().to_string(),
                                     "function_name" => payload.function_name.to_string(),
+                                    "function_args" => format!("{:?}", payload.function_args),
+                                );
+                                return None;
+                            }
+                            if Self::parse_function_args(&payload.function_args).is_none() {
+                                // This is not a special cased transaction. We don't care if its in the next block
+                                debug!("Signer #{}: Received a transaction with invalid function arguments. Ignoring it.", self.signer_id;
+                                    "origin_address" => origin_address.to_string(),
+                                    "txid" => transaction.txid().to_string(),
+                                    "function_args" => format!("{:?}", payload.function_args),
                                 );
                                 return None;
                             }
@@ -674,20 +688,23 @@ impl Signer {
                             // This is not a special cased transaction.
                             debug!("Signer #{}: Received an unrecognized transaction. Ignoring it.", self.signer_id;
                             "origin_address" => origin_address.to_string(),
-                            "orign_nonce" => origin_nonce,
+                            "origin_nonce" => origin_nonce,
                             "txid" => transaction.txid().to_string(),
                             "payload" => format!("{:?}", transaction.payload),
                         );
                             return None;
                         }
                     }
-                    if !self.signer_addresses.contains(&origin_address) || origin_nonce < account_nonce {
-                        debug!("Signer #{}: Received a transaction from either an unrecognized address or with an invalid nonce. Ignoring it.", self.signer_id;
-                            "txid" => transaction.txid().to_string(),
-                            "origin_address" => origin_address.to_string(),
-                            "origin_nonce" => origin_nonce,
-                            "account_nonce" => account_nonce,
-                        );
+                    if !self.signer_addresses.contains(&origin_address) {
+                        debug!("Signer #{}: Received a transaction ({}) from an unrecognized address ({origin_address}). Ignoring it.", self.signer_id, transaction.txid());
+                        return None;
+                    }
+                    let Ok(account_nonce) = stacks_client.get_account_nonce(&origin_address) else {
+                        warn!("Signer #{}: Unable to get account for address: {origin_address}. Ignoring this transaction for this block...", self.signer_id);
+                        return None;
+                    };
+                    if origin_nonce < account_nonce {
+                        debug!("Signer #{}: Transaction {} has an outdated nonce ({account_nonce} < {origin_nonce}). Ignoring it for this block...", self.signer_id, transaction.txid());
                         return None;
                     }
                     debug!("Signer #{}: Expect transaction {} ({transaction:?})", self.signer_id, transaction.txid());
@@ -776,88 +793,7 @@ impl Signer {
                     debug!("Signer #{}: Received a signature result for a taproot signature. Nothing to broadcast as we currently sign blocks with a FROST signature.", self.signer_id);
                 }
                 OperationResult::Dkg(point) => {
-                    // Broadcast via traditional methods to the stacks node if we are pre nakamoto or we cannot determine our Epoch
-                    let epoch = stacks_client
-                        .get_node_epoch()
-                        .unwrap_or(StacksEpochId::Epoch24);
-                    let new_transaction = match epoch {
-                        StacksEpochId::Epoch25 => {
-                            debug!("Signer #{}: Received a DKG result, but are in epoch 2.5. Broadcast the transaction to the mempool.", self.signer_id);
-                            match retry_with_exponential_backoff(|| {
-                                stacks_client
-                                    .cast_vote_for_aggregate_public_key(
-                                        self.stackerdb.get_signer_slot_id(),
-                                        self.coordinator.current_dkg_id,
-                                        *point,
-                                    )
-                                    .map_err(backoff::Error::transient)
-                            }) {
-                                Ok(transaction) => {
-                                    debug!("Signer #{}: Successfully cast aggregate public key vote: {:?}",
-                                        self.signer_id,
-                                        transaction.txid()
-                                    );
-                                    transaction
-                                }
-                                Err(e) => {
-                                    warn!("Signer #{}: Failed to cast aggregate public key vote: {e:?}", self.signer_id);
-                                    continue;
-                                }
-                            }
-                        }
-                        StacksEpochId::Epoch30 => {
-                            debug!("Signer #{}: Received a DKG result, but are in epoch 3. Broadcast the transaction to stackerDB.", self.signer_id);
-                            match retry_with_exponential_backoff(|| {
-                                stacks_client
-                                    .build_vote_for_aggregate_public_key(
-                                        self.stackerdb.get_signer_slot_id(),
-                                        self.coordinator.current_dkg_id,
-                                        *point,
-                                    )
-                                    .map_err(backoff::Error::transient)
-                            }) {
-                                Ok(transaction) => transaction,
-                                Err(e) => {
-                                    warn!("Signer #{}: Failed to build a cast aggregate public key vote transaction: {e:?}", self.signer_id);
-                                    continue;
-                                }
-                            }
-                        }
-                        _ => {
-                            debug!("Signer #{}: Received a DKG result, but are in an unsupported epoch. Do not broadcast the result.", self.signer_id);
-                            continue;
-                        }
-                    };
-                    let old_transactions = self
-                        .stackerdb
-                        .get_signer_transactions_with_retry(&[self.signer_id])
-                        .map_err(|e| {
-                            error!("Failed to get old transactions from stackerdb: {e:?}");
-                        })
-                        .unwrap_or_default();
-                    // Filter out our old transactions that are no longer valid
-                    let mut new_transactions: Vec<_> = old_transactions.into_iter().filter_map(|transaction|  {
-                        let origin_address = transaction.origin_address();
-                        let origin_nonce = transaction.get_origin_nonce();
-                        let Ok(account_nonce) = retry_with_exponential_backoff(|| stacks_client.get_account_nonce(&origin_address).map_err(backoff::Error::transient)) else {
-                            warn!("Signer #{}: Unable to get account for address: {origin_address}. Removing {} from our stored transactions.", self.signer_id, transaction.txid());
-                            return None;
-                        };
-                        if origin_nonce < account_nonce {
-                            debug!("Signer #{}: Transaction {} has an outdated nonce. Removing it from our stored transactions.", self.signer_id, transaction.txid());
-                            return None;
-                        }
-                        Some(transaction)
-                    }).collect();
-                    info!("Signer #{}: Writing DKG vote transaction {} to stackerdb for other signers and the miner to observe.", new_transaction.txid(), self.signer_id);
-                    new_transactions.push(new_transaction);
-                    let signer_message = SignerMessage::Transactions(new_transactions);
-                    if let Err(e) = self.stackerdb.send_message_with_retry(signer_message) {
-                        warn!(
-                            "Signer #{}: Failed to update transactions in stacker-db: {e:?}",
-                            self.signer_id
-                        );
-                    }
+                    self.process_dkg(stacks_client, point);
                 }
                 OperationResult::SignError(e) => {
                     self.process_sign_error(e);
@@ -869,6 +805,82 @@ impl Signer {
         }
     }
 
+    /// Process a dkg result by broadcasting a vote to the stacks node
+    fn process_dkg(&mut self, stacks_client: &StacksClient, point: &Point) {
+        match retry_with_exponential_backoff(|| {
+            stacks_client
+                .build_vote_for_aggregate_public_key(
+                    self.stackerdb.get_signer_slot_id(),
+                    self.coordinator.current_dkg_id,
+                    *point,
+                )
+                .map_err(backoff::Error::transient)
+        }) {
+            Ok(transaction) => {
+                if let Err(e) = self.broadcast_dkg_vote(stacks_client, transaction) {
+                    warn!(
+                        "Signer #{}: Failed to broadcast DKG vote ({point:?}): {e:?}",
+                        self.signer_id
+                    );
+                }
+            }
+            Err(e) => {
+                warn!(
+                    "Signer #{}: Failed to build DKG vote ({point:?}) transaction: {e:?}.",
+                    self.signer_id
+                );
+            }
+        }
+    }
+
+    /// broadcast the dkg vote transaction according to the current epoch
+    fn broadcast_dkg_vote(
+        &mut self,
+        stacks_client: &StacksClient,
+        new_transaction: StacksTransaction,
+    ) -> Result<(), ClientError> {
+        let epoch = stacks_client
+            .get_node_epoch_with_retry()
+            .unwrap_or(StacksEpochId::Epoch24);
+        match epoch {
+            StacksEpochId::Epoch25 => {
+                debug!("Signer #{}: Received a DKG result, but are in epoch 2.5. Broadcast the transaction to the mempool.", self.signer_id);
+                stacks_client.broadcast_transaction(&new_transaction)?;
+            }
+            StacksEpochId::Epoch30 => {
+                debug!("Signer #{}: Received a DKG result, but are in epoch 3. Broadcast the transaction to stackerDB.", self.signer_id);
+                let old_transactions = self
+                    .stackerdb
+                    .get_signer_transactions_with_retry(&[self.signer_id])
+                    .map_err(|e| {
+                        warn!("Signer #{}: Failed to get old transactions from stackerdb: {e:?}. May overwrite pending transactions.", self.signer_id);
+                    })
+                    .unwrap_or_default();
+                // Filter out our old transactions that are no longer valid
+                let mut new_transactions: Vec<_> = old_transactions.into_iter().filter_map(|transaction|  {
+                    let origin_address = transaction.origin_address();
+                    let origin_nonce = transaction.get_origin_nonce();
+                    let Ok(account_nonce) = retry_with_exponential_backoff(|| stacks_client.get_account_nonce(&origin_address).map_err(backoff::Error::transient)) else {
+                        warn!("Signer #{}: Unable to get account for address: {origin_address}. Removing {} from our stored transactions.", self.signer_id, transaction.txid());
+                        return None;
+                    };
+                    if origin_nonce < account_nonce {
+                        debug!("Signer #{}: Transaction {} has an outdated nonce. Removing it from our stored transactions.", self.signer_id, transaction.txid());
+                        return None;
+                    }
+                    Some(transaction)
+                }).collect();
+                new_transactions.push(new_transaction);
+                let signer_message = SignerMessage::Transactions(new_transactions);
+                self.stackerdb.send_message_with_retry(signer_message)?;
+            }
+            _ => {
+                debug!("Signer #{}: Received a DKG result, but are in an unsupported epoch. Do not broadcast the result.", self.signer_id);
+            }
+        }
+        Ok(())
+    }
+
     /// Process a signature from a signing round by deserializing the signature and
     /// broadcasting an appropriate Reject or Approval message to stackerdb
     fn process_signature(&mut self, signature: &Signature) {
@@ -1054,12 +1066,46 @@ impl Signer {
         let coordinator_id = stacks_client
             .calculate_coordinator(&self.signing_round.public_keys)
             .0;
-        // TOOD: should check if we have an aggregate key before we trigger another round. may have a delay between us calculating a key, broadcasting to the contract, and it being confirmed by the miner.
         if new_aggregate_public_key.is_none()
             && self.signer_id == coordinator_id
             && self.coordinator.state == CoordinatorState::Idle
-        // Have I already voted and have a pending transaction? Check stackerdb for the same round number and reward cycle
         {
+            // Have I already voted and have a pending transaction? Check stackerdb for the same round number and reward cycle vote transaction
+            let old_transactions = self
+                .stackerdb
+                .get_signer_transactions_with_retry(&[self.signer_id])
+                .map_err(|e| {
+                    error!("Failed to get old transactions from stackerdb: {e:?}");
+                })
+                .unwrap_or_default();
+            // Check if we have an existing vote transaction for the same round and reward cycle
+            for transaction in old_transactions.iter() {
+                let origin_address = transaction.origin_address();
+                if &origin_address != stacks_client.get_signer_address() {
+                    continue;
+                }
+                let TransactionPayload::ContractCall(payload) = &transaction.payload else {
+                    error!("BUG: Signer #{}: Received an unrecognized transaction ({}) in an already filtered list: {transaction:?}", self.signer_id, transaction.txid());
+                    continue;
+                };
+                if payload.function_name == VOTE_FUNCTION_NAME.into() {
+                    let Some((_signer_index, point, round)) =
+                        Self::parse_function_args(&payload.function_args)
+                    else {
+                        error!("BUG: Signer #{}: Received an unrecognized transaction ({}) in an already filtered list: {transaction:?}", self.signer_id, transaction.txid());
+                        continue;
+                    };
+                    if Some(point) == self.coordinator.aggregate_public_key
+                        && round == self.coordinator.current_dkg_id as u128
+                    {
+                        debug!("Signer #{}: Not triggering a DKG round. Already have a pending vote transaction for aggregate public key {point:?} for round {round}...", self.signer_id);
+                        continue;
+                    }
+                } else {
+                    error!("BUG: Signer #{}: Received an unrecognized transaction ({}) in an already filtered list: {transaction:?}", self.signer_id, transaction.txid());
+                    continue;
+                }
+            }
             info!("Signer #{} is the current coordinator for {reward_cycle}. Triggering a DKG round...", self.signer_id);
             if self.commands.back() != Some(&Command::Dkg) {
                 self.commands.push_back(Command::Dkg);
@@ -1106,7 +1152,7 @@ impl Signer {
             }
             Some(SignerEvent::SignerMessages(signer_set, messages)) => {
                 if *signer_set != self.stackerdb.get_signer_set() {
-                    debug!("Signer #{}: Received a signer message for a reward cycle that do not belong to this signer. Ignoring...", self.signer_id);
+                    debug!("Signer #{}: Received a signer message for a reward cycle that does not belong to this signer. Ignoring...", self.signer_id);
                     return Ok(());
                 }
                 debug!(
@@ -1139,6 +1185,21 @@ impl Signer {
         }
         Ok(())
     }
+
+    fn parse_function_args(function_args: &[ClarityValue]) -> Option<(u128, Point, u128)> {
+        if function_args.len() != 3 {
+            return None;
+        }
+        let signer_index_value = function_args.first()?;
+        let signer_index = signer_index_value.clone().expect_u128().ok()?;
+        let point_value = function_args.get(1)?;
+        let point_bytes = point_value.clone().expect_buff(33).ok()?;
+        let compressed_data = Compressed::try_from(point_bytes.as_slice()).ok()?;
+        let point = Point::try_from(&compressed_data).ok()?;
+        let round_value = function_args.get(2)?;
+        let round = round_value.clone().expect_u128().ok()?;
+        Some((signer_index, point, round))
+    }
 }
 
 #[cfg(test)]
@@ -1149,7 +1210,10 @@ mod tests {
     use blockstack_lib::chainstate::stacks::boot::SIGNERS_VOTING_NAME;
     use blockstack_lib::chainstate::stacks::{ThresholdSignature, TransactionVersion};
     use blockstack_lib::util_lib::boot::{boot_code_addr, boot_code_id};
+    use clarity::vm::Value;
     use libsigner::SignerMessage;
+    use rand::thread_rng;
+    use rand_core::RngCore;
     use serial_test::serial;
     use stacks_common::bitvec::BitVec;
     use stacks_common::codec::StacksMessageCodec;
@@ -1159,6 +1223,8 @@ mod tests {
     use stacks_common::util::hash::{MerkleTree, Sha512Trunc256Sum};
     use stacks_common::util::secp256k1::MessageSignature;
     use wsts::curve::ecdsa;
+    use wsts::curve::point::Point;
+    use wsts::curve::scalar::Scalar;
 
     use crate::client::tests::{
         generate_reward_cycle_config, mock_server_from_config, write_response,
@@ -1189,12 +1255,21 @@ mod tests {
         let vote_contract_id = boot_code_id(SIGNERS_VOTING_NAME, signer.is_mainnet);
         let contract_addr = vote_contract_id.issuer.into();
         let contract_name = vote_contract_id.name.clone();
+        let index = thread_rng().next_u64() as u128;
+        let point = Point::from(Scalar::random(&mut thread_rng()));
+        let round = thread_rng().next_u64() as u128;
+        let valid_function_args = vec![
+            Value::UInt(index),
+            Value::buff_from(point.compress().data.to_vec()).expect("Failed to create buff"),
+            Value::UInt(round),
+        ];
+
         // Create a valid transaction signed by the signer private key coresponding to the slot into which it is being inserted (signer id 0)
         let valid_tx = StacksClient::build_signed_contract_call_transaction(
             &contract_addr,
             contract_name.clone(),
             VOTE_FUNCTION_NAME.into(),
-            &[],
+            &valid_function_args,
             &signer_private_key,
             TransactionVersion::Testnet,
             config.network.to_chain_id(),
@@ -1202,28 +1277,28 @@ mod tests {
             10,
         )
         .unwrap();
-        let invalid_tx_bad_signer = StacksClient::build_signed_contract_call_transaction(
+        let invalid_tx_outdated_nonce = StacksClient::build_signed_contract_call_transaction(
             &contract_addr,
             contract_name.clone(),
             VOTE_FUNCTION_NAME.into(),
-            &[],
-            &non_signer_private_key,
+            &valid_function_args,
+            &signer_private_key,
             TransactionVersion::Testnet,
             config.network.to_chain_id(),
             0,
-            10,
+            5,
         )
         .unwrap();
-        let invalid_tx_outdated_nonce = StacksClient::build_signed_contract_call_transaction(
+        let invalid_tx_bad_signer = StacksClient::build_signed_contract_call_transaction(
             &contract_addr,
             contract_name.clone(),
             VOTE_FUNCTION_NAME.into(),
-            &[],
-            &signer_private_key,
+            &valid_function_args,
+            &non_signer_private_key,
             TransactionVersion::Testnet,
             config.network.to_chain_id(),
             0,
-            5,
+            10,
         )
         .unwrap();
         let bad_contract_addr = boot_code_addr(true);
@@ -1231,7 +1306,7 @@ mod tests {
             &bad_contract_addr,
             contract_name.clone(),
             VOTE_FUNCTION_NAME.into(),
-            &[],
+            &valid_function_args,
             &signer_private_key,
             TransactionVersion::Testnet,
             config.network.to_chain_id(),
@@ -1244,7 +1319,7 @@ mod tests {
             &contract_addr,
             "wrong".into(),
             VOTE_FUNCTION_NAME.into(),
-            &[],
+            &valid_function_args,
             &signer_private_key,
             TransactionVersion::Testnet,
             config.network.to_chain_id(),
@@ -1257,6 +1332,19 @@ mod tests {
             &contract_addr,
             contract_name.clone(),
             "fake-function".into(),
+            &valid_function_args,
+            &signer_private_key,
+            TransactionVersion::Testnet,
+            config.network.to_chain_id(),
+            1,
+            5,
+        )
+        .unwrap();
+
+        let invalid_tx_bad_function_args = StacksClient::build_signed_contract_call_transaction(
+            &contract_addr,
+            contract_name.clone(),
+            VOTE_FUNCTION_NAME.into(),
             &[],
             &signer_private_key,
             TransactionVersion::Testnet,
@@ -1273,8 +1361,8 @@ mod tests {
             invalid_tx_bad_contract_addr,
             invalid_tx_bad_contract_name,
             invalid_tx_bad_function,
+            invalid_tx_bad_function_args,
         ];
-        let num_transactions = transactions.len();
 
         let h = spawn(move || signer.get_expected_transactions(&stacks_client).unwrap());
 
@@ -1314,11 +1402,14 @@ mod tests {
         let mock_server = mock_server_from_config(&config);
         write_response(mock_server, response_bytes.as_slice());
 
-        for _ in 0..num_transactions {
-            let nonce_response = b"HTTP/1.1 200 OK\n\n{\"nonce\":1,\"balance\":\"0x00000000000000000000000000000000\",\"locked\":\"0x00000000000000000000000000000000\",\"unlock_height\":0}";
-            let mock_server = mock_server_from_config(&config);
-            write_response(mock_server, nonce_response);
-        }
+        // Only the first two transactions need a nonce check
+        let nonce_response = b"HTTP/1.1 200 OK\n\n{\"nonce\":1,\"balance\":\"0x00000000000000000000000000000000\",\"locked\":\"0x00000000000000000000000000000000\",\"unlock_height\":0}";
+        let mock_server = mock_server_from_config(&config);
+        write_response(mock_server, nonce_response);
+
+        let nonce_response = b"HTTP/1.1 200 OK\n\n{\"nonce\":1,\"balance\":\"0x00000000000000000000000000000000\",\"locked\":\"0x00000000000000000000000000000000\",\"unlock_height\":0}";
+        let mock_server = mock_server_from_config(&config);
+        write_response(mock_server, nonce_response);
 
         let filtered_txs = h.join().unwrap();
         assert_eq!(filtered_txs, vec![valid_tx]);
@@ -1343,12 +1434,20 @@ mod tests {
         let vote_contract_id = boot_code_id(SIGNERS_VOTING_NAME, signer.is_mainnet);
         let contract_addr = vote_contract_id.issuer.into();
         let contract_name = vote_contract_id.name.clone();
+        let index = thread_rng().next_u64() as u128;
+        let point = Point::from(Scalar::random(&mut thread_rng()));
+        let round = thread_rng().next_u64() as u128;
+        let valid_function_args = vec![
+            Value::UInt(index),
+            Value::buff_from(point.compress().data.to_vec()).expect("Failed to create buff"),
+            Value::UInt(round),
+        ];
         // Create a valid transaction signed by the signer private key coresponding to the slot into which it is being inserted (signer id 0)
         let valid_tx = StacksClient::build_signed_contract_call_transaction(
             &contract_addr,
             contract_name.clone(),
             VOTE_FUNCTION_NAME.into(),
-            &[],
+            &valid_function_args,
             &signer_private_key,
             TransactionVersion::Testnet,
             config.network.to_chain_id(),
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index 3963ea6848..18ab3071a8 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -20,6 +20,7 @@ use stacks::chainstate::stacks::{
     TransactionAuth, TransactionPayload, TransactionPostConditionMode, TransactionSmartContract,
     TransactionVersion,
 };
+use stacks::core::StacksEpoch;
 use stacks::net::api::postblock_proposal::BlockValidateResponse;
 use stacks::util_lib::strings::StacksString;
 use stacks_common::bitvec::BitVec;
@@ -28,6 +29,7 @@ use stacks_common::consts::SIGNER_SLOTS_PER_USER;
 use stacks_common::types::chainstate::{
     ConsensusHash, StacksAddress, StacksBlockId, StacksPublicKey, TrieHash,
 };
+use stacks_common::types::StacksEpochId;
 use stacks_common::util::hash::{MerkleTree, Sha512Trunc256Sum};
 use stacks_common::util::secp256k1::MessageSignature;
 use stacks_signer::client::{StackerDB, StacksClient};
@@ -47,7 +49,9 @@ use crate::tests::nakamoto_integrations::{
     boot_to_epoch_3_reward_set, naka_neon_integration_conf, next_block_and,
     next_block_and_mine_commit, POX_4_DEFAULT_STACKER_BALANCE,
 };
-use crate::tests::neon_integrations::{next_block_and_wait, test_observer, wait_for_runloop};
+use crate::tests::neon_integrations::{
+    next_block_and_wait, run_until_burnchain_height, test_observer, wait_for_runloop,
+};
 use crate::tests::to_addr;
 use crate::{BitcoinRegtestController, BurnchainController};
 
@@ -339,22 +343,11 @@ fn stackerdb_dkg_sign() {
     info!("------------------------- Test DKG -------------------------");
     info!("signer_runloop: spawn send commands to do dkg");
     let dkg_now = Instant::now();
-    let dkg_command = RunLoopCommand {
-        reward_cycle: 0,
-        command: SignerCommand::Dkg,
-    };
-    for cmd_sender in signer_test.signer_cmd_senders.values() {
-        cmd_sender
-            .send(dkg_command.clone())
-            .expect("failed to send Dkg command");
-    }
     let mut key = Point::default();
     for recv in signer_test.result_receivers.iter() {
         let mut aggregate_public_key = None;
         loop {
-            let results = recv
-                .recv_timeout(Duration::from_secs(100))
-                .expect("failed to recv dkg results");
+            let results = recv.recv().expect("failed to recv dkg results");
             for result in results {
                 match result {
                     OperationResult::Sign(sig) => {
@@ -375,19 +368,20 @@ fn stackerdb_dkg_sign() {
                     }
                 }
             }
-            if aggregate_public_key.is_some() || dkg_now.elapsed() > Duration::from_secs(100) {
+            if aggregate_public_key.is_some() || dkg_now.elapsed() > Duration::from_secs(200) {
                 break;
             }
         }
-        key = aggregate_public_key.expect("Failed to get aggregate public key within 100 seconds");
+        key = aggregate_public_key.expect("Failed to get aggregate public key within 200 seconds");
     }
     let dkg_elapsed = dkg_now.elapsed();
 
+    // We can't sign a block
     info!("------------------------- Test Sign -------------------------");
     let sign_now = Instant::now();
     info!("signer_runloop: spawn send commands to do dkg and then sign");
     let sign_command = RunLoopCommand {
-        reward_cycle: 0,
+        reward_cycle: 11,
         command: SignerCommand::Sign {
             block: block.clone(),
             is_taproot: false,
@@ -395,7 +389,7 @@ fn stackerdb_dkg_sign() {
         },
     };
     let sign_taproot_command = RunLoopCommand {
-        reward_cycle: 0,
+        reward_cycle: 11,
         command: SignerCommand::Sign {
             block: block.clone(),
             is_taproot: true,
@@ -414,9 +408,7 @@ fn stackerdb_dkg_sign() {
         let mut frost_signature = None;
         let mut schnorr_proof = None;
         loop {
-            let results = recv
-                .recv_timeout(Duration::from_secs(30))
-                .expect("failed to recv signature results");
+            let results = recv.recv().expect("failed to recv signature results");
             for result in results {
                 match result {
                     OperationResult::Sign(sig) => {
@@ -439,7 +431,7 @@ fn stackerdb_dkg_sign() {
                 }
             }
             if (frost_signature.is_some() && schnorr_proof.is_some())
-                || sign_now.elapsed() > Duration::from_secs(100)
+                || sign_now.elapsed() > Duration::from_secs(200)
             {
                 break;
             }
@@ -496,34 +488,75 @@ fn stackerdb_block_proposal() {
     info!("------------------------- Test Setup -------------------------");
     let mut signer_test = SignerTest::new(5, 5);
 
-    let (vrfs_submitted, commits_submitted) = (
+    let (_vrfs_submitted, commits_submitted) = (
         signer_test.running_nodes.vrfs_submitted.clone(),
         signer_test.running_nodes.commits_submitted.clone(),
     );
+    info!("------------------------- Wait for DKG -------------------------");
+    info!("signer_runloop: spawn send commands to do dkg");
+    let dkg_now = Instant::now();
+    let mut key = Point::default();
+    for recv in signer_test.result_receivers.iter() {
+        let mut aggregate_public_key = None;
+        loop {
+            let results = recv
+                .recv_timeout(Duration::from_secs(60))
+                .expect("failed to recv dkg results");
+            for result in results {
+                match result {
+                    OperationResult::Sign(sig) => {
+                        panic!("Received Signature ({},{})", &sig.R, &sig.z);
+                    }
+                    OperationResult::SignTaproot(proof) => {
+                        panic!("Received SchnorrProof ({},{})", &proof.r, &proof.s);
+                    }
+                    OperationResult::DkgError(dkg_error) => {
+                        panic!("Received DkgError {:?}", dkg_error);
+                    }
+                    OperationResult::SignError(sign_error) => {
+                        panic!("Received SignError {}", sign_error);
+                    }
+                    OperationResult::Dkg(point) => {
+                        info!("Received aggregate_group_key {point}");
+                        aggregate_public_key = Some(point);
+                    }
+                }
+            }
+            if aggregate_public_key.is_some() || dkg_now.elapsed() > Duration::from_secs(200) {
+                break;
+            }
+        }
+        key = aggregate_public_key.expect("Failed to get aggregate public key within 200 seconds");
+    }
+    let dkg_elapsed = dkg_now.elapsed();
 
-    info!("Mining a Nakamoto tenure...");
+    let epochs = signer_test
+        .running_nodes
+        .conf
+        .burnchain
+        .epochs
+        .clone()
+        .unwrap();
+    let epoch_3 = &epochs[StacksEpoch::find_epoch_by_id(&epochs, StacksEpochId::Epoch30).unwrap()];
 
-    // first block wakes up the run loop, wait until a key registration has been submitted.
-    next_block_and(
-        &mut signer_test.running_nodes.btc_regtest_controller,
-        60,
-        || {
-            let vrf_count = vrfs_submitted.load(Ordering::SeqCst);
-            Ok(vrf_count >= 1)
-        },
-    )
-    .unwrap();
+    let epoch_30_boundary = epoch_3.start_height - 1;
+    info!(
+        "Advancing to Epoch 3.0 Boundary";
+        "Epoch 3.0 Boundary" => epoch_30_boundary,
+    );
 
-    // second block should confirm the VRF register, wait until a block commit is submitted
-    next_block_and(
+    // Advance to epoch 3.0
+    run_until_burnchain_height(
         &mut signer_test.running_nodes.btc_regtest_controller,
-        60,
-        || {
-            let commits_count = commits_submitted.load(Ordering::SeqCst);
-            Ok(commits_count >= 1)
-        },
-    )
-    .unwrap();
+        &signer_test.running_nodes.blocks_processed,
+        epoch_30_boundary,
+        &signer_test.running_nodes.conf,
+    );
+
+    info!("Avanced to Nakamoto! Ready to Sign Blocks!");
+
+    info!("------------------------- Test Block Processed -------------------------");
+    let sign_now = Instant::now();
 
     // Mine 1 nakamoto tenure
     next_block_and_mine_commit(
@@ -534,29 +567,6 @@ fn stackerdb_block_proposal() {
     )
     .unwrap();
 
-    let mut aggregate_public_key = None;
-    let recv = signer_test
-        .result_receivers
-        .last()
-        .expect("Failed to get recv");
-    let results = recv
-        .recv_timeout(Duration::from_secs(30))
-        .expect("failed to recv dkg results");
-    for result in results {
-        match result {
-            OperationResult::Dkg(point) => {
-                info!("Received aggregate_group_key {point}");
-                aggregate_public_key = Some(point);
-                break;
-            }
-            _ => {
-                panic!("Received Unexpected result");
-            }
-        }
-    }
-    let aggregate_public_key = aggregate_public_key.expect("Failed to get aggregate public key");
-
-    info!("------------------------- Test Block Processed -------------------------");
     let recv = signer_test
         .result_receivers
         .last()
@@ -572,11 +582,22 @@ fn stackerdb_block_proposal() {
                 signature = Some(sig);
                 break;
             }
-            _ => {
-                panic!("Unexpected operation result");
+            OperationResult::Dkg(point) => {
+                debug!("Received a dkg result {point:?}");
+                continue;
+            }
+            OperationResult::DkgError(dkg_error) => {
+                panic!("Received DkgError {:?}", dkg_error);
+            }
+            OperationResult::SignError(sign_error) => {
+                panic!("Received SignError {}", sign_error);
+            }
+            OperationResult::SignTaproot(proof) => {
+                panic!("Received SchnorrProof ({},{})", &proof.r, &proof.s);
             }
         }
     }
+    let sign_elapsed = sign_now.elapsed();
     let signature = signature.expect("Failed to get signature");
     // Wait for the block to show up in the test observer (Don't have to wait long as if we have received a signature,
     // we know that the signers have already received their block proposal events via their event observers)
@@ -595,10 +616,7 @@ fn stackerdb_block_proposal() {
             _ => panic!("Unexpected response"),
         };
     assert!(
-        signature.verify(
-            &aggregate_public_key,
-            proposed_signer_signature_hash.0.as_slice()
-        ),
+        signature.verify(&key, proposed_signer_signature_hash.0.as_slice()),
         "Signature verification failed"
     );
     // Verify that the signers broadcasted a signed NakamotoBlock back to the .signers contract
@@ -642,6 +660,9 @@ fn stackerdb_block_proposal() {
         panic!("Received unexpected message");
     }
     signer_test.shutdown();
+
+    info!("DKG Time Elapsed: {:.2?}", dkg_elapsed);
+    info!("Sign Time Elapsed: {:.2?}", sign_elapsed);
 }
 
 #[test]
@@ -774,7 +795,7 @@ fn stackerdb_block_proposal_missing_transactions() {
     // TODO: remove this forcibly running DKG once we have casting of the vote automagically happening during epoch 2.5
     info!("signer_runloop: spawn send commands to do dkg");
     let dkg_command = RunLoopCommand {
-        reward_cycle: 0,
+        reward_cycle: 11,
         command: SignerCommand::Dkg,
     };
     for cmd_sender in signer_test.signer_cmd_senders.values() {

From 4c996c38afa56f0f4e21ed2cc44f894ed0f99cd9 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Thu, 8 Feb 2024 18:30:14 -0800
Subject: [PATCH 0877/1166] Do not run dkg if already have a pending vote

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/signer.rs | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index 22f64becf2..c43b3eb12a 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -1099,7 +1099,7 @@ impl Signer {
                         && round == self.coordinator.current_dkg_id as u128
                     {
                         debug!("Signer #{}: Not triggering a DKG round. Already have a pending vote transaction for aggregate public key {point:?} for round {round}...", self.signer_id);
-                        continue;
+                        return Ok(());
                     }
                 } else {
                     error!("BUG: Signer #{}: Received an unrecognized transaction ({}) in an already filtered list: {transaction:?}", self.signer_id, transaction.txid());
@@ -1110,12 +1110,6 @@ impl Signer {
             if self.commands.back() != Some(&Command::Dkg) {
                 self.commands.push_back(Command::Dkg);
             }
-        } else {
-            debug!("Signer #{}: Not triggering a DKG round.", self.signer_id;
-                "aggregate_public_key" => new_aggregate_public_key.is_some(),
-                "coordinator_id" => coordinator_id,
-                "coordinator_idle" => self.coordinator.state == CoordinatorState::Idle,
-            );
         }
         Ok(())
     }

From 454ab73eb53b89670445744a33e5338669217b2a Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Thu, 8 Feb 2024 18:55:31 -0800
Subject: [PATCH 0878/1166] Check the front of commands not the back before
 adding another DKG command to the front

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/signer.rs             | 12 +++++++++---
 testnet/stacks-node/src/tests/signer.rs |  3 ++-
 2 files changed, 11 insertions(+), 4 deletions(-)

diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index c43b3eb12a..877f00d686 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -207,6 +207,12 @@ impl Signer {
                 };
                 // The dkg id will increment internally following "start_dkg_round" so do not increment it here
                 self.coordinator.current_dkg_id = vote_round.unwrap_or(0);
+                info!(
+                    "Signer #{}: Starting DKG vote round {}, for reward cycle {}",
+                    self.signer_id,
+                    self.coordinator.current_dkg_id.wrapping_add(1),
+                    self.reward_cycle
+                );
                 match self.coordinator.start_dkg_round() {
                     Ok(msg) => {
                         let ack = self.stackerdb.send_message_with_retry(msg.into());
@@ -1106,9 +1112,9 @@ impl Signer {
                     continue;
                 }
             }
-            info!("Signer #{} is the current coordinator for {reward_cycle}. Triggering a DKG round...", self.signer_id);
-            if self.commands.back() != Some(&Command::Dkg) {
-                self.commands.push_back(Command::Dkg);
+            if self.commands.front() != Some(&Command::Dkg) {
+                info!("Signer #{} is the current coordinator for {reward_cycle} and must trigger DKG. Queuing DKG command...", self.signer_id);
+                self.commands.push_front(Command::Dkg);
             }
         }
         Ok(())
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index 18ab3071a8..d06b72e990 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -91,7 +91,8 @@ impl SignerTest {
             .map(|_| StacksPrivateKey::new())
             .collect::<Vec<StacksPrivateKey>>();
 
-        let (naka_conf, _miner_account) = naka_neon_integration_conf(None);
+        let (mut naka_conf, _miner_account) = naka_neon_integration_conf(None);
+        naka_conf.miner.self_signing_key = None;
 
         // Setup the signer and coordinator configurations
         let signer_configs = build_signer_config_tomls(

From 089be910189b4d30c28a0167e260b8cf42883023 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Thu, 8 Feb 2024 18:55:49 -0800
Subject: [PATCH 0879/1166] WIP: Get miners to retrieve transactions from
 stackerdb

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stackslib/src/chainstate/nakamoto/miner.rs    |  6 +-
 .../stacks-node/src/nakamoto_node/miner.rs    | 69 ++++++++++++++++---
 2 files changed, 66 insertions(+), 9 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/miner.rs b/stackslib/src/chainstate/nakamoto/miner.rs
index ebcd0cbb99..5edeac4c63 100644
--- a/stackslib/src/chainstate/nakamoto/miner.rs
+++ b/stackslib/src/chainstate/nakamoto/miner.rs
@@ -405,6 +405,7 @@ impl NakamotoBlockBuilder {
         tenure_info: NakamotoTenureInfo,
         settings: BlockBuilderSettings,
         event_observer: Option<&dyn MemPoolEventDispatcher>,
+        signer_transactions: Vec<StacksTransaction>,
     ) -> Result<(NakamotoBlock, ExecutionCost, u64), Error> {
         let (tip_consensus_hash, tip_block_hash, tip_height) = (
             parent_stacks_header.consensus_hash.clone(),
@@ -437,13 +438,16 @@ impl NakamotoBlockBuilder {
             .block_limit()
             .expect("Failed to obtain block limit from miner's block connection");
 
-        let initial_txs: Vec<_> = [
+        let mut initial_txs: Vec<_> = [
             tenure_info.tenure_change_tx.clone(),
             tenure_info.coinbase_tx.clone(),
         ]
         .into_iter()
         .filter_map(|x| x)
         .collect();
+        initial_txs.extend(signer_transactions);
+
+        // TODO: update this mempool check to prioritize signer vote transactions over other transactions
         let (blocked, tx_events) = match StacksBlockBuilder::select_and_apply_transactions(
             &mut tenure_tx,
             &mut builder,
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index 1f4fb2326b..2f5e09fd0d 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -19,10 +19,11 @@ use std::thread::JoinHandle;
 use std::time::{Duration, Instant};
 
 use clarity::boot_util::boot_code_id;
-use clarity::vm::types::PrincipalData;
+use clarity::vm::types::{PrincipalData, QualifiedContractIdentifier};
 use hashbrown::HashSet;
 use libsigner::{
     BlockResponse, RejectCode, SignerMessage, SignerSession, StackerDBSession, BLOCK_MSG_ID,
+    TRANSACTIONS_MSG_ID,
 };
 use stacks::burnchains::{Burnchain, BurnchainParameters};
 use stacks::chainstate::burn::db::sortdb::SortitionDB;
@@ -160,7 +161,7 @@ impl BlockMinerThread {
         // now, actually run this tenure
         loop {
             let new_block = loop {
-                match self.mine_block() {
+                match self.mine_block(&stackerdbs) {
                     Ok(x) => break Some(x),
                     Err(NakamotoNodeError::MiningFailure(ChainstateError::MinerAborted)) => {
                         info!("Miner interrupted while mining, will try again");
@@ -256,12 +257,11 @@ impl BlockMinerThread {
         }
     }
 
-    fn wait_for_signer_signature(
+    fn get_stackerdb_contract_and_slots(
         &self,
         stackerdbs: &StackerDBs,
-        aggregate_public_key: &Point,
-        signer_signature_hash: &Sha512Trunc256Sum,
-    ) -> Result<ThresholdSignature, NakamotoNodeError> {
+        msg_id: u32,
+    ) -> Result<(QualifiedContractIdentifier, Vec<u32>), NakamotoNodeError> {
         let stackerdb_contracts = stackerdbs
             .get_stackerdb_contract_ids()
             .expect("FATAL: could not get the stacker DB contract ids");
@@ -273,7 +273,7 @@ impl BlockMinerThread {
 
         let signers_contract_id = NakamotoSigners::make_signers_db_contract_id(
             reward_cycle,
-            BLOCK_MSG_ID,
+            msg_id,
             self.config.is_mainnet(),
         );
         if !stackerdb_contracts.contains(&signers_contract_id) {
@@ -291,6 +291,55 @@ impl BlockMinerThread {
                 u32::try_from(id).expect("FATAL: too many signers to fit into u32 range")
             })
             .collect::<Vec<u32>>();
+        Ok((signers_contract_id, slot_ids))
+    }
+
+    fn get_signer_transactions(
+        &self,
+        stackerdbs: &StackerDBs,
+    ) -> Result<Vec<StacksTransaction>, NakamotoNodeError> {
+        let (signers_contract_id, slot_ids) =
+            self.get_stackerdb_contract_and_slots(stackerdbs, TRANSACTIONS_MSG_ID)?;
+        // Get the transactions from the signers for the next block
+        let signer_chunks = stackerdbs
+            .get_latest_chunks(&signers_contract_id, &slot_ids)
+            .expect("FATAL: could not get latest chunks from stacker DB");
+        let signer_messages: Vec<(u32, SignerMessage)> = slot_ids
+            .iter()
+            .zip(signer_chunks.into_iter())
+            .filter_map(|(slot_id, chunk)| {
+                chunk.and_then(|chunk| {
+                    read_next::<SignerMessage, _>(&mut &chunk[..])
+                        .ok()
+                        .map(|msg| (*slot_id, msg))
+                })
+            })
+            .collect();
+
+        // There may be more than signer messages, but odds are there is only one transacton per signer
+        let mut transactions_to_include = Vec::with_capacity(signer_messages.len());
+        for (_slot, signer_message) in signer_messages {
+            match signer_message {
+                SignerMessage::Transactions(transactions) => {
+                    // TODO: filter out transactons that are not valid and that do not come from the signers
+                    // TODO: move this filter function from stacks-signer and make it globally available perhaps?
+                    transactions_to_include.extend(transactions);
+                }
+                _ => {} // Any other message is ignored
+            }
+        }
+        debug!("MINER IS INCLUDING TRANSACTIONS FROM SIGNERS: {transactions_to_include:?}");
+        Ok(transactions_to_include)
+    }
+
+    fn wait_for_signer_signature(
+        &self,
+        stackerdbs: &StackerDBs,
+        aggregate_public_key: &Point,
+        signer_signature_hash: &Sha512Trunc256Sum,
+    ) -> Result<ThresholdSignature, NakamotoNodeError> {
+        let (signers_contract_id, slot_ids) =
+            self.get_stackerdb_contract_and_slots(stackerdbs, BLOCK_MSG_ID)?;
 
         // If more than a threshold percentage of the signers reject the block, we should not wait any further
         let rejection_threshold = slot_ids.len() / 10 * 7;
@@ -639,7 +688,7 @@ impl BlockMinerThread {
 
     /// Try to mine a Stacks block by assembling one from mempool transactions and sending a
     /// burnchain block-commit transaction.  If we succeed, then return the assembled block.
-    fn mine_block(&mut self) -> Result<NakamotoBlock, NakamotoNodeError> {
+    fn mine_block(&mut self, stackerdbs: &StackerDBs) -> Result<NakamotoBlock, NakamotoNodeError> {
         debug!("block miner thread ID is {:?}", thread::current().id());
 
         let burn_db_path = self.config.get_burn_db_file_path();
@@ -709,6 +758,9 @@ impl BlockMinerThread {
         let block_num = u64::try_from(self.mined_blocks.len())
             .map_err(|_| NakamotoNodeError::UnexpectedChainState)?
             .saturating_add(1);
+
+        let signer_transactions = self.get_signer_transactions(&stackerdbs)?;
+
         // build the block itself
         let (mut block, _, _) = NakamotoBlockBuilder::build_nakamoto_block(
             &chain_state,
@@ -724,6 +776,7 @@ impl BlockMinerThread {
                 self.globals.get_miner_status(),
             ),
             Some(&self.event_dispatcher),
+            signer_transactions,
         )
         .map_err(|e| {
             if !matches!(

From 4dc153deb6740c658010a4615b638af80dff8ba5 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Fri, 9 Feb 2024 07:13:55 -0600
Subject: [PATCH 0880/1166] fix: test nakamoto nodes should use the right
 .signers stackerdbs

---
 .../chainstate/nakamoto/coordinator/tests.rs  | 10 -----
 testnet/stacks-node/src/config.rs             | 42 +++++++++++--------
 .../src/tests/nakamoto_integrations.rs        |  8 +---
 3 files changed, 26 insertions(+), 34 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index 0d5884b984..cb07233f27 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -244,16 +244,6 @@ pub fn boot_nakamoto<'a>(
     // reward cycle 6 instantiates pox-3
     // we stack in reward cycle 7 so pox-3 is evaluated to find reward set participation
     peer_config.aggregate_public_key = Some(aggregate_public_key.clone());
-    peer_config
-        .stacker_dbs
-        .push(boot_code_id(MINERS_NAME, false));
-    for signer_set in 0..2 {
-        for message_id in 0..SIGNER_SLOTS_PER_USER {
-            let contract_name = NakamotoSigners::make_signers_db_name(signer_set, message_id);
-            let contract_id = boot_code_id(contract_name.as_str(), false);
-            peer_config.stacker_dbs.push(contract_id);
-        }
-    }
     peer_config.epochs = Some(StacksEpoch::unit_test_3_0_only(37));
     peer_config.initial_balances = vec![(addr.to_account_principal(), 1_000_000_000_000_000_000)];
 
diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index f7010ca49b..21cf238509 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -969,26 +969,11 @@ impl Config {
             node.require_affirmed_anchor_blocks = false;
         }
 
-        let miners_contract_id = boot_code_id(MINERS_NAME, is_mainnet);
-        if (node.stacker || node.miner)
-            && burnchain.mode == "nakamoto-neon"
-            && !node.stacker_dbs.contains(&miners_contract_id)
-        {
-            debug!("A miner/stacker must subscribe to the {miners_contract_id} stacker db contract. Forcibly subscribing...");
-            node.stacker_dbs.push(miners_contract_id);
+        if (node.stacker || node.miner) && burnchain.mode == "nakamoto-neon" {
+            node.add_miner_stackerdb(is_mainnet);
         }
         if (node.stacker || node.miner) && burnchain.mode == "nakamoto-neon" {
-            for signer_set in 0..2 {
-                for message_id in 0..SIGNER_SLOTS_PER_USER {
-                    let contract_id = NakamotoSigners::make_signers_db_contract_id(
-                        signer_set, message_id, is_mainnet,
-                    );
-                    if !node.stacker_dbs.contains(&contract_id) {
-                        debug!("A miner/stacker must subscribe to the {contract_id} stacker db contract. Forcibly subscribing...");
-                        node.stacker_dbs.push(contract_id);
-                    }
-                }
-            }
+            node.add_signers_stackerdbs(is_mainnet);
         }
 
         let miner = match config_file.miner {
@@ -1884,6 +1869,27 @@ impl Default for NodeConfig {
 }
 
 impl NodeConfig {
+    pub fn add_signers_stackerdbs(&mut self, is_mainnet: bool) {
+        for signer_set in 0..2 {
+            for message_id in 0..SIGNER_SLOTS_PER_USER {
+                let contract_name = NakamotoSigners::make_signers_db_name(signer_set, message_id);
+                let contract_id = boot_code_id(contract_name.as_str(), is_mainnet);
+                if !self.stacker_dbs.contains(&contract_id) {
+                    debug!("A miner/stacker must subscribe to the {contract_id} stacker db contract. Forcibly subscribing...");
+                    self.stacker_dbs.push(contract_id);
+                }
+            }
+        }
+    }
+
+    pub fn add_miner_stackerdb(&mut self, is_mainnet: bool) {
+        let miners_contract_id = boot_code_id(MINERS_NAME, is_mainnet);
+        if !self.stacker_dbs.contains(&miners_contract_id) {
+            debug!("A miner/stacker must subscribe to the {miners_contract_id} stacker db contract. Forcibly subscribing...");
+            self.stacker_dbs.push(miners_contract_id);
+        }
+    }
+
     fn default_neighbor(
         addr: SocketAddr,
         pubk: Secp256k1PublicKey,
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index d2e2277ea1..ec63ccfcc1 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -193,12 +193,6 @@ pub fn naka_neon_integration_conf(seed: Option<&[u8]>) -> (Config, StacksAddress
 
     conf.node.miner = true;
     conf.node.wait_time_for_microblocks = 500;
-    conf.node
-        .stacker_dbs
-        .push(boot_code_id(MINERS_NAME, conf.is_mainnet()));
-    conf.node
-        .stacker_dbs
-        .push(boot_code_id(SIGNERS_NAME, conf.is_mainnet()));
     conf.burnchain.burn_fee_cap = 20000;
 
     conf.burnchain.username = Some("neon-tester".into());
@@ -207,6 +201,8 @@ pub fn naka_neon_integration_conf(seed: Option<&[u8]>) -> (Config, StacksAddress
     conf.burnchain.local_mining_public_key =
         Some(keychain.generate_op_signer().get_public_key().to_hex());
     conf.burnchain.commit_anchor_block_within = 0;
+    conf.node.add_signers_stackerdbs(false);
+    conf.node.add_miner_stackerdb(false);
 
     // test to make sure config file parsing is correct
     let mut cfile = ConfigFile::xenon();

From c8c19bb75c48b931e2114c6044ff8dbc105720ea Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 9 Feb 2024 10:07:38 -0800
Subject: [PATCH 0881/1166] Fix nakamoto integration stacking in advance to
 epoch 3 reward set

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 .../src/tests/nakamoto_integrations.rs        | 28 +++++++++++++++----
 1 file changed, 22 insertions(+), 6 deletions(-)

diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index ec63ccfcc1..17a277663e 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -606,13 +606,28 @@ pub fn boot_to_epoch_3_reward_set(
     next_block_and_wait(btc_regtest_controller, &blocks_processed);
 
     // stack enough to activate pox-4
-    let pox_addr_tuple = clarity::vm::tests::execute(&format!(
-        "{{ hashbytes: 0x{}, version: 0x{:02x} }}",
-        to_hex(&[0; 20]),
-        AddressHashMode::SerializeP2PKH as u8,
-    ));
-
+    let block_height = btc_regtest_controller.get_headers_height();
+    let reward_cycle = btc_regtest_controller
+        .get_burnchain()
+        .block_height_to_reward_cycle(block_height)
+        .unwrap();
     for (stacker_sk, signer_pk) in stacker_sks.iter().zip(signer_pks.iter()) {
+        let pox_addr = PoxAddress::from_legacy(
+            AddressHashMode::SerializeP2PKH,
+            tests::to_addr(&stacker_sk).bytes,
+        );
+        let pox_addr_tuple: clarity::vm::Value =
+            pox_addr.clone().as_clarity_tuple().unwrap().into();
+        let signature = make_pox_4_signer_key_signature(
+            &pox_addr,
+            stacker_sk,
+            reward_cycle.into(),
+            &Pox4SignatureTopic::StackStx,
+            CHAIN_ID_TESTNET,
+            12_u128,
+        )
+        .unwrap()
+        .to_rsv();
         let stacking_tx = tests::make_contract_call(
             &stacker_sk,
             0,
@@ -625,6 +640,7 @@ pub fn boot_to_epoch_3_reward_set(
                 pox_addr_tuple.clone(),
                 clarity::vm::Value::UInt(205),
                 clarity::vm::Value::UInt(12),
+                clarity::vm::Value::buff_from(signature).unwrap(),
                 clarity::vm::Value::buff_from(signer_pk.to_bytes_compressed()).unwrap(),
             ],
         );

From c078c09fce3f50fb163c2ffb0c006c3ac23a8765 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 9 Feb 2024 11:19:35 -0800
Subject: [PATCH 0882/1166] Fix logging about reward registration

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/runloop.rs | 37 ++++++++++++++----------------------
 1 file changed, 14 insertions(+), 23 deletions(-)

diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 7042eed39e..1919bcb6e2 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -232,11 +232,8 @@ impl RunLoop {
                 .get_current_reward_cycle()
                 .map_err(backoff::Error::transient)?;
             let next_reward_cycle = current_reward_cycle.saturating_add(1);
-            match self.refresh_signer_config(current_reward_cycle) {
-                Ok(_) => {
-                    debug!("Signer is registered for the current reward cycle {current_reward_cycle}. Checking next reward cycle...");
-                }
-                Err(e) => match e {
+            if let Err(e) = self.refresh_signer_config(current_reward_cycle) {
+                match e {
                     ClientError::NotRegistered => {
                         debug!("Signer is NOT registered for the current reward cycle {current_reward_cycle}.");
                     }
@@ -244,25 +241,19 @@ impl RunLoop {
                         debug!("Current reward cycle {current_reward_cycle} reward set is not yet calculated. Let's retry...");
                         return Err(backoff::Error::transient(e));
                     }
-                    e => return Err(backoff::Error::transient(e)),
-                },
-            }
-            let next_result = self.refresh_signer_config(next_reward_cycle);
-            match next_result {
-                Ok(_) => {
-                    debug!("Signer is registered for the next reward cycle {next_reward_cycle}");
+                    _ => return Err(backoff::Error::transient(e)),
                 }
-                Err(ClientError::RewardSetNotYetCalculated(_)) => {
-                    debug!(
-                        "Next reward cycle {next_reward_cycle} reward set is not yet calculated."
-                    );
-                }
-                Err(ClientError::NotRegistered) => {
-                    debug!(
-                        "Signer is NOT registered for the next reward cycle {next_reward_cycle}."
-                    );
+            }
+            if let Err(e) = self.refresh_signer_config(next_reward_cycle) {
+                match e {
+                    ClientError::NotRegistered => {
+                        debug!("Signer is NOT registered for the next reward cycle {next_reward_cycle}.");
+                    }
+                    ClientError::RewardSetNotYetCalculated(_) => {
+                        debug!("Next reward cycle {next_reward_cycle} reward set is not yet calculated.");
+                    }
+                    _ => return Err(backoff::Error::transient(e)),
                 }
-                Err(e) => Err(e)?,
             }
             for stacks_signer in self.stacks_signers.values_mut() {
                 stacks_signer
@@ -270,7 +261,7 @@ impl RunLoop {
                     .map_err(backoff::Error::transient)?;
             }
             if self.stacks_signers.is_empty() {
-                info!("Signer is not registered for the current or next reward cycle. Waiting for confirmed registration...");
+                info!("Signer is not registered for the current {current_reward_cycle} or next {next_reward_cycle} reward cycles. Waiting for confirmed registration...");
                 return Err(backoff::Error::transient(ClientError::NotRegistered));
             } else {
                 info!("Runloop successfully initialized!");

From a10044ea20f7e3cffd6ef6d871a5ea6b85d447b0 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 9 Feb 2024 13:40:20 -0800
Subject: [PATCH 0883/1166] Fix epoch 3 reward set calculation block height

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 .../src/tests/nakamoto_integrations.rs        | 20 ++++++++++++-------
 1 file changed, 13 insertions(+), 7 deletions(-)

diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 17a277663e..048957d6dc 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -593,12 +593,18 @@ pub fn boot_to_epoch_3_reward_set(
 
     let epochs = naka_conf.burnchain.epochs.clone().unwrap();
     let epoch_3 = &epochs[StacksEpoch::find_epoch_by_id(&epochs, StacksEpochId::Epoch30).unwrap()];
-    let prepare_phase_len = naka_conf.get_burnchain().pox_constants.prepare_length;
-    let epoch_30_reward_set_calculation = epoch_3.start_height - prepare_phase_len as u64;
-    info!(
-        "Chain bootstrapped to bitcoin block 201, starting Epoch 2x miner";
-        "Epoch 3.0 Reward Set Calculation Height" => epoch_30_reward_set_calculation,
+    let reward_cycle_len = naka_conf.get_burnchain().pox_constants.reward_cycle_length as u64;
+    let prepare_phase_len = naka_conf.get_burnchain().pox_constants.prepare_length as u64;
+    assert!(
+        epoch_3.start_height > 0,
+        "Epoch 3 start height must be greater than 0"
     );
+    let epoch_3_reward_cycle_boundary = epoch_3.start_height;
+    let epoch_3_reward_cycle_boundary = epoch_3_reward_cycle_boundary
+        .saturating_sub(epoch_3_reward_cycle_boundary % reward_cycle_len);
+    let epoch_3_reward_set_calculation_boundary =
+        epoch_3_reward_cycle_boundary.saturating_sub(prepare_phase_len);
+    let epoch_3_reward_set_calculation = epoch_3_reward_set_calculation_boundary.wrapping_add(1);
     let http_origin = format!("http://{}", &naka_conf.node.rpc_bind);
     next_block_and_wait(btc_regtest_controller, &blocks_processed);
     next_block_and_wait(btc_regtest_controller, &blocks_processed);
@@ -651,11 +657,11 @@ pub fn boot_to_epoch_3_reward_set(
     run_until_burnchain_height(
         btc_regtest_controller,
         &blocks_processed,
-        epoch_30_reward_set_calculation,
+        epoch_3_reward_set_calculation,
         &naka_conf,
     );
 
-    info!("Bootstrapped to Epoch-3.0 reward set calculation height.");
+    info!("Bootstrapped to Epoch 3.0 reward set calculation height: {epoch_3_reward_set_calculation}.");
 }
 
 #[test]

From 676914dea1de5a6b78f15cee04d4fe404cfba30e Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 9 Feb 2024 17:19:27 -0800
Subject: [PATCH 0884/1166] WIP: add logic for preventing clogging the block
 space

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/mod.rs           |  20 +-
 stacks-signer/src/client/stacks_client.rs |  56 ++-
 stacks-signer/src/config.rs               |   4 +-
 stacks-signer/src/runloop.rs              |  17 +-
 stacks-signer/src/signer.rs               | 530 ++++++++++++++++------
 5 files changed, 453 insertions(+), 174 deletions(-)

diff --git a/stacks-signer/src/client/mod.rs b/stacks-signer/src/client/mod.rs
index c985c2a743..a03d98db03 100644
--- a/stacks-signer/src/client/mod.rs
+++ b/stacks-signer/src/client/mod.rs
@@ -331,12 +331,16 @@ pub(crate) mod tests {
     }
 
     /// Build a response for the get_aggregate_public_key request
-    pub fn build_get_aggregate_public_key_response(point: Point) -> String {
-        let clarity_value = ClarityValue::some(
-            ClarityValue::buff_from(point.compress().as_bytes().to_vec())
-                .expect("BUG: Failed to create clarity value from point"),
-        )
-        .expect("BUG: Failed to create clarity value from point");
+    pub fn build_get_aggregate_public_key_response(point: Option<Point>) -> String {
+        let clarity_value = if let Some(point) = point {
+            ClarityValue::some(
+                ClarityValue::buff_from(point.compress().as_bytes().to_vec())
+                    .expect("BUG: Failed to create clarity value from point"),
+            )
+            .expect("BUG: Failed to create clarity value from point")
+        } else {
+            ClarityValue::none()
+        };
         build_read_only_response(&clarity_value)
     }
 
@@ -421,6 +425,7 @@ pub(crate) mod tests {
         let mut coordinator_key_ids = HashMap::new();
         let mut signer_key_ids = HashMap::new();
         let mut addresses = vec![];
+        let mut signer_address_ids = HashMap::new();
         let mut start_key_id = 1u32;
         let mut end_key_id = start_key_id;
         let mut signer_public_keys = HashMap::new();
@@ -481,6 +486,7 @@ pub(crate) mod tests {
                 &StacksPublicKey::from_slice(public_key.to_bytes().as_slice())
                     .expect("Failed to create stacks public key"),
             );
+            signer_address_ids.insert(address.clone(), signer_id);
             addresses.push(address);
             start_key_id = end_key_id;
         }
@@ -494,7 +500,7 @@ pub(crate) mod tests {
                 signer_id: 0,
                 signer_set,
                 reward_cycle,
-                signer_addresses: addresses.iter().cloned().collect(),
+                signer_address_ids,
                 signer_public_keys,
             },
             addresses,
diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index 6864a2f707..c32b58b1c6 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -180,6 +180,28 @@ impl StacksClient {
         Ok(signer_slots)
     }
 
+    /// Get the vote for a given  round, reward cycle, and signer address
+    pub fn get_vote_for_aggregate_public_key(
+        &self,
+        round: u64,
+        reward_cycle: u64,
+        signer: StacksAddress,
+    ) -> Result<Option<Point>, ClientError> {
+        let function_name = ClarityName::from("get-vote");
+        let function_args = &[
+            ClarityValue::UInt(reward_cycle as u128),
+            ClarityValue::UInt(round as u128),
+            ClarityValue::Principal(signer.into()),
+        ];
+        let value = self.read_only_contract_call(
+            &boot_code_addr(self.chain_id == CHAIN_ID_MAINNET),
+            &ContractName::from(SIGNERS_VOTING_NAME),
+            &function_name,
+            function_args,
+        )?;
+        self.parse_aggregate_public_key(value)
+    }
+
     /// Retrieve the stacks tip consensus hash from the stacks node
     pub fn get_stacks_tip_consensus_hash(&self) -> Result<ConsensusHash, ClientError> {
         let peer_info = self.get_peer_info()?;
@@ -806,21 +828,17 @@ mod tests {
     #[test]
     fn get_aggregate_public_key_should_succeed() {
         let orig_point = Point::from(Scalar::random(&mut rand::thread_rng()));
-        let response = build_get_aggregate_public_key_response(orig_point);
-
+        let response = build_get_aggregate_public_key_response(Some(orig_point));
         let mock = MockServerClient::new();
         let h = spawn(move || mock.client.get_aggregate_public_key(0));
         write_response(mock.server, response.as_bytes());
         let res = h.join().unwrap().unwrap();
         assert_eq!(res, Some(orig_point));
 
-        let clarity_value = ClarityValue::none();
-        let response = build_read_only_response(&clarity_value);
-
-        let mock = MockServerClient::from_config(mock.config);
+        let response = build_get_aggregate_public_key_response(None);
+        let mock = MockServerClient::new();
         let h = spawn(move || mock.client.get_aggregate_public_key(0));
         write_response(mock.server, response.as_bytes());
-
         let res = h.join().unwrap().unwrap();
         assert!(res.is_none());
     }
@@ -1279,6 +1297,30 @@ mod tests {
         assert!(!h.join().unwrap().unwrap());
     }
 
+    #[test]
+    fn get_vote_for_aggregate_public_key_should_succeed() {
+        let mock = MockServerClient::new();
+        let point = Point::from(Scalar::random(&mut rand::thread_rng()));
+        let stacks_address = mock.client.stacks_address;
+        let key_response = build_get_aggregate_public_key_response(Some(point));
+        let h = spawn(move || {
+            mock.client
+                .get_vote_for_aggregate_public_key(0, 0, stacks_address)
+        });
+        write_response(mock.server, key_response.as_bytes());
+        assert_eq!(h.join().unwrap().unwrap(), Some(point));
+
+        let mock = MockServerClient::new();
+        let stacks_address = mock.client.stacks_address;
+        let key_response = build_get_aggregate_public_key_response(None);
+        let h = spawn(move || {
+            mock.client
+                .get_vote_for_aggregate_public_key(0, 0, stacks_address)
+        });
+        write_response(mock.server, key_response.as_bytes());
+        assert_eq!(h.join().unwrap().unwrap(), None);
+    }
+
     #[test]
     fn calculate_coordinator_different_consensus_hashes_produces_unique_results() {
         let number_of_tests = 5;
diff --git a/stacks-signer/src/config.rs b/stacks-signer/src/config.rs
index 97ae6b5559..ac7d2f29e7 100644
--- a/stacks-signer/src/config.rs
+++ b/stacks-signer/src/config.rs
@@ -127,8 +127,8 @@ pub struct RewardCycleConfig {
     pub signer_key_ids: HashMap<u32, Vec<u32>>,
     /// The signer ids to wsts pubilc keys mapping
     pub signer_public_keys: HashMap<u32, Point>,
-    /// The signer addresses
-    pub signer_addresses: HashSet<StacksAddress>,
+    /// The signer addresses mapped to their signer ids
+    pub signer_address_ids: HashMap<StacksAddress, u32>,
     /// The public keys for the reward cycle
     pub public_keys: PublicKeys,
     /// This signer's key ids
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 1919bcb6e2..a5a36bb786 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -88,7 +88,6 @@ impl RunLoop {
             return Err(ClientError::RewardSetNotYetCalculated(reward_cycle));
         }
         let current_addr = self.stacks_client.get_signer_address();
-        let mut current_signer_id = None;
 
         let signer_set =
             u32::try_from(reward_cycle % 2).expect("FATAL: reward_cycle % 2 exceeds u32::MAX");
@@ -121,7 +120,7 @@ impl RunLoop {
         // signer uses a Vec<u32> for its key_ids, but coordinator uses a HashSet for each signer since it needs to do lots of lookups
         let mut coordinator_key_ids = HashMap::with_capacity(4000);
         let mut signer_key_ids = HashMap::with_capacity(reward_set_signers.len());
-        let mut signer_addresses = HashSet::with_capacity(reward_set_signers.len());
+        let mut signer_address_ids = HashMap::with_capacity(reward_set_signers.len());
         let mut public_keys = PublicKeys {
             signers: HashMap::with_capacity(reward_set_signers.len()),
             key_ids: HashMap::with_capacity(4000),
@@ -148,10 +147,8 @@ impl RunLoop {
 
             let stacks_address =
                 StacksAddress::p2pkh(self.config.network.is_mainnet(), &stacks_public_key);
-            if &stacks_address == current_addr {
-                current_signer_id = Some(signer_id);
-            }
-            signer_addresses.insert(stacks_address);
+
+            signer_address_ids.insert(stacks_address, signer_id);
             signer_public_keys.insert(signer_id, signer_public_key);
             let weight_start = weight_end;
             weight_end = weight_start + entry.slots;
@@ -168,20 +165,20 @@ impl RunLoop {
                     .push(key_id);
             }
         }
-        let Some(signer_id) = current_signer_id else {
+        let Some(signer_id) = signer_address_ids.get(current_addr) else {
             warn!("Signer {current_addr} was found in stacker db but not the reward set for reward cycle {reward_cycle}.");
             return Ok(None);
         };
         debug!(
             "Signer #{signer_id} ({current_addr}) is registered for reward cycle {reward_cycle}."
         );
-        let key_ids = signer_key_ids.get(&signer_id).cloned().unwrap_or_default();
+        let key_ids = signer_key_ids.get(signer_id).cloned().unwrap_or_default();
         Ok(Some(RewardCycleConfig {
             reward_cycle,
-            signer_id,
+            signer_id: *signer_id,
             signer_slot_id,
             signer_set,
-            signer_addresses,
+            signer_address_ids,
             key_ids,
             coordinator_key_ids,
             signer_key_ids,
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index 877f00d686..2d2ecd1bfa 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -133,8 +133,8 @@ pub struct Signer {
     pub is_mainnet: bool,
     /// The signer id
     pub signer_id: u32,
-    /// The addresses of other signers to compare our transactions against
-    pub signer_addresses: HashSet<StacksAddress>,
+    /// The addresses of other signers mapped to their signer ID
+    pub signer_address_ids: HashMap<StacksAddress, u32>,
     /// The reward cycle this signer belongs to
     pub reward_cycle: u64,
 }
@@ -185,7 +185,7 @@ impl Signer {
             stackerdb,
             is_mainnet: config.network.is_mainnet(),
             signer_id: reward_cycle_config.signer_id,
-            signer_addresses: reward_cycle_config.signer_addresses,
+            signer_address_ids: reward_cycle_config.signer_address_ids,
             reward_cycle: reward_cycle_config.reward_cycle,
         }
     }
@@ -259,7 +259,7 @@ impl Signer {
                     }
                     Err(e) => {
                         error!(
-                            "Signer #{}: Failed to start signing message: {e:?}",
+                            "Signer #{}: Failed to start signing block: {e:?}",
                             self.signer_id
                         );
                     }
@@ -275,7 +275,7 @@ impl Signer {
                 let (coordinator_id, _) =
                     stacks_client.calculate_coordinator(&self.signing_round.public_keys);
                 if coordinator_id != self.signer_id {
-                    warn!(
+                    debug!(
                         "Signer #{}: Not the coordinator. Will not process any commands...",
                         self.signer_id
                     );
@@ -325,7 +325,7 @@ impl Signer {
                     debug!("Received a block validate response for a block we have not seen before. Ignoring...");
                     return;
                 };
-                let is_valid = self.verify_transactions(stacks_client, &block_info.block);
+                let is_valid = self.verify_block_transactions(stacks_client, &block_info.block);
                 block_info.valid = Some(is_valid);
                 info!(
                     "Signer #{}: Treating block validation for block {} as valid: {:?}",
@@ -580,8 +580,21 @@ impl Signer {
     }
 
     /// Verify the transactions in a block are as expected
-    fn verify_transactions(&mut self, stacks_client: &StacksClient, block: &NakamotoBlock) -> bool {
-        if let Ok(expected_transactions) = self.get_expected_transactions(stacks_client) {
+    fn verify_block_transactions(
+        &mut self,
+        stacks_client: &StacksClient,
+        block: &NakamotoBlock,
+    ) -> bool {
+        let signer_ids = self
+            .signing_round
+            .public_keys
+            .signers
+            .keys()
+            .cloned()
+            .collect::<Vec<_>>();
+        if let Ok(expected_transactions) =
+            self.get_filtered_transactions(stacks_client, &signer_ids)
+        {
             //It might be worth building a hashset of the blocks' txids and checking that against the expected transaction's txid.
             let block_tx_hashset = block.txs.iter().map(|tx| tx.txid()).collect::<HashSet<_>>();
             // Ensure the block contains the transactions we expect
@@ -648,74 +661,149 @@ impl Signer {
         }
     }
 
-    /// Get the transactions we expect to see in the next block
-    fn get_expected_transactions(
+    /// Verify the transaction is a valid transaction from expected signers
+    /// If it is unable to verify the contents, it wil automatically filter the transaction by default
+    fn verify_signer_transaction(
+        &self,
+        stacks_client: &StacksClient,
+        transaction: StacksTransaction,
+    ) -> Option<StacksTransaction> {
+        // Filter out transactions that have already been confirmed (can happen if a signer did not update stacker db since the last block was processed)
+        let origin_address = transaction.origin_address();
+        let origin_nonce = transaction.get_origin_nonce();
+        let Some(origin_signer_id) = self.signer_address_ids.get(&origin_address) else {
+            debug!(
+                "Signer #{}: Unrecognized origin address ({origin_address}). Filtering ({}).",
+                self.signer_id,
+                transaction.txid()
+            );
+            return None;
+        };
+        let Ok(account_nonce) = retry_with_exponential_backoff(|| {
+            stacks_client
+                .get_account_nonce(&origin_address)
+                .map_err(backoff::Error::transient)
+        }) else {
+            warn!(
+                "Signer #{}: Unable to get account for transaction origin address: {origin_address}. Filtering ({}).",
+                self.signer_id,
+                transaction.txid()
+            );
+            return None;
+        };
+        if origin_nonce < account_nonce {
+            debug!("Signer #{}: Received a transaction with an outdated nonce ({account_nonce} < {origin_nonce}). Filtering ({}).", self.signer_id, transaction.txid());
+            return None;
+        }
+        let Ok(valid) = retry_with_exponential_backoff(|| {
+            self.verify_payload(stacks_client, &transaction, *origin_signer_id)
+                .map_err(backoff::Error::transient)
+        }) else {
+            warn!(
+                "Signer #{}: Unable to validate transaction payload. Filtering ({}).",
+                self.signer_id,
+                transaction.txid()
+            );
+            return None;
+        };
+        if !valid {
+            debug!(
+                "Signer #{}: Received a transaction with an invalid payload. Filtering ({}).",
+                self.signer_id,
+                transaction.txid()
+            );
+            return None;
+        }
+        debug!(
+            "Signer #{}: Expect transaction {} ({transaction:?})",
+            self.signer_id,
+            transaction.txid()
+        );
+        Some(transaction)
+    }
+
+    ///Helper function to verify the payload contents of a transaction are as expected
+    fn verify_payload(
+        &self,
+        stacks_client: &StacksClient,
+        transaction: &StacksTransaction,
+        origin_signer_id: u32,
+    ) -> Result<bool, ClientError> {
+        let TransactionPayload::ContractCall(payload) = &transaction.payload else {
+            // Not a contract call so not a special cased vote for aggregate public key transaction
+            return Ok(false);
+        };
+
+        if payload.contract_identifier() != boot_code_id(SIGNERS_VOTING_NAME, self.is_mainnet)
+            || payload.function_name != VOTE_FUNCTION_NAME.into()
+        {
+            // This is not a special cased transaction.
+            return Ok(false);
+        }
+        let Some((index, _point, round, reward_cycle)) =
+            Self::parse_function_args(&payload.function_args)
+        else {
+            // The transactions arguments are invalid
+            return Ok(false);
+        };
+        if index != origin_signer_id as u64 {
+            // The signer is attempting to vote for another signer id than their own
+            return Ok(false);
+        }
+        let vote = stacks_client.get_vote_for_aggregate_public_key(
+            round,
+            reward_cycle,
+            transaction.origin_address(),
+        )?;
+        if vote.is_some() {
+            // The signer has already voted for this round and reward cycle
+            return Ok(false);
+        }
+        // TODO: uncomment when reward cycle properly retrieved from transaction. Depends on contract update.
+        // let current_reward_cycle = stacks_client.get_current_reward_cycle()?;
+        // let next_reward_cycle = current_reward_cycle.wrapping_add(1);
+        // if reward_cycle != current_reward_cycle && reward_cycle != next_reward_cycle {
+        //     // The signer is attempting to vote for a reward cycle that is not the current or next reward cycle
+        //     return Ok(false);
+        // }
+        // let reward_set_calculated = stacks_client.reward_set_calculated(next_reward_cycle)?;
+        // if !reward_set_calculated {
+        //     // The signer is attempting to vote for a reward cycle that has not yet had its reward set calculated
+        //     return Ok(false);
+        // }
+
+        let last_round = stacks_client.get_last_round(reward_cycle)?;
+        let aggregate_key = stacks_client.get_aggregate_public_key(reward_cycle)?;
+
+        if let Some(last_round) = last_round {
+            if aggregate_key.is_some() && round > last_round {
+                // The signer is attempting to vote for a round that is greater than the last round
+                // when the reward cycle has already confirmed an aggregate key
+                return Ok(false);
+            }
+        }
+        // TODO: should this be removed? I just am trying to prevent unecessary clogging of the block space
+        // TODO: should we impose a limit on the number of special cased transactions allowed for a single signer at any given time?? In theory only 1 would be required per dkg round i.e. per block
+        if last_round.unwrap_or(0).saturating_add(2) < round {
+            // Do not allow substantially future votes. This is to prevent signers sending a bazillion votes for a future round and clogging the block space
+            // The signer is attempting to vote for a round that is greater than two rounds after the last round
+            return Ok(false);
+        }
+        Ok(true)
+    }
+
+    /// Get the filtered transactions for the provided signer ids
+    fn get_filtered_transactions(
         &mut self,
         stacks_client: &StacksClient,
+        signer_ids: &[u32],
     ) -> Result<Vec<StacksTransaction>, ClientError> {
-        let signer_ids = self
-            .signing_round
-            .public_keys
-            .signers
-            .keys()
-            .cloned()
-            .collect::<Vec<_>>();
         let transactions = self
-                .stackerdb
-                .get_signer_transactions_with_retry(&signer_ids)?.into_iter().filter_map(|transaction| {
-                    // Filter out transactions that have already been confirmed (can happen if a signer did not update stacker db since the last block was processed)
-                    let origin_address = transaction.origin_address();
-                    let origin_nonce = transaction.get_origin_nonce();
-                    let vote_contract_id = boot_code_id(SIGNERS_VOTING_NAME, self.is_mainnet);
-                    match &transaction.payload {
-                        TransactionPayload::ContractCall(payload) => {
-                            if payload.contract_identifier() != vote_contract_id || payload.function_name != VOTE_FUNCTION_NAME.into() {
-                                // This is not a special cased transaction. We don't care if its in the next block
-                                debug!("Signer #{}: Received an unrecognized transaction. Ignoring it.", self.signer_id;
-                                    "origin_address" => origin_address.to_string(),
-                                    "txid" => transaction.txid().to_string(),
-                                    "contract_id" => payload.contract_identifier().to_string(),
-                                    "function_name" => payload.function_name.to_string(),
-                                    "function_args" => format!("{:?}", payload.function_args),
-                                );
-                                return None;
-                            }
-                            if Self::parse_function_args(&payload.function_args).is_none() {
-                                // This is not a special cased transaction. We don't care if its in the next block
-                                debug!("Signer #{}: Received a transaction with invalid function arguments. Ignoring it.", self.signer_id;
-                                    "origin_address" => origin_address.to_string(),
-                                    "txid" => transaction.txid().to_string(),
-                                    "function_args" => format!("{:?}", payload.function_args),
-                                );
-                                return None;
-                            }
-                        }
-                        _ => {
-                            // This is not a special cased transaction.
-                            debug!("Signer #{}: Received an unrecognized transaction. Ignoring it.", self.signer_id;
-                            "origin_address" => origin_address.to_string(),
-                            "origin_nonce" => origin_nonce,
-                            "txid" => transaction.txid().to_string(),
-                            "payload" => format!("{:?}", transaction.payload),
-                        );
-                            return None;
-                        }
-                    }
-                    if !self.signer_addresses.contains(&origin_address) {
-                        debug!("Signer #{}: Received a transaction ({}) from an unrecognized address ({origin_address}). Ignoring it.", self.signer_id, transaction.txid());
-                        return None;
-                    }
-                    let Ok(account_nonce) = stacks_client.get_account_nonce(&origin_address) else {
-                        warn!("Signer #{}: Unable to get account for address: {origin_address}. Ignoring this transaction for this block...", self.signer_id);
-                        return None;
-                    };
-                    if origin_nonce < account_nonce {
-                        debug!("Signer #{}: Transaction {} has an outdated nonce ({account_nonce} < {origin_nonce}). Ignoring it for this block...", self.signer_id, transaction.txid());
-                        return None;
-                    }
-                    debug!("Signer #{}: Expect transaction {} ({transaction:?})", self.signer_id, transaction.txid());
-                    Some(transaction)
-                }).collect();
+            .stackerdb
+            .get_signer_transactions_with_retry(signer_ids)?
+            .into_iter()
+            .filter_map(|transaction| self.verify_signer_transaction(stacks_client, transaction))
+            .collect();
         Ok(transactions)
     }
 
@@ -855,27 +943,9 @@ impl Signer {
             }
             StacksEpochId::Epoch30 => {
                 debug!("Signer #{}: Received a DKG result, but are in epoch 3. Broadcast the transaction to stackerDB.", self.signer_id);
-                let old_transactions = self
-                    .stackerdb
-                    .get_signer_transactions_with_retry(&[self.signer_id])
-                    .map_err(|e| {
-                        warn!("Signer #{}: Failed to get old transactions from stackerdb: {e:?}. May overwrite pending transactions.", self.signer_id);
-                    })
-                    .unwrap_or_default();
-                // Filter out our old transactions that are no longer valid
-                let mut new_transactions: Vec<_> = old_transactions.into_iter().filter_map(|transaction|  {
-                    let origin_address = transaction.origin_address();
-                    let origin_nonce = transaction.get_origin_nonce();
-                    let Ok(account_nonce) = retry_with_exponential_backoff(|| stacks_client.get_account_nonce(&origin_address).map_err(backoff::Error::transient)) else {
-                        warn!("Signer #{}: Unable to get account for address: {origin_address}. Removing {} from our stored transactions.", self.signer_id, transaction.txid());
-                        return None;
-                    };
-                    if origin_nonce < account_nonce {
-                        debug!("Signer #{}: Transaction {} has an outdated nonce. Removing it from our stored transactions.", self.signer_id, transaction.txid());
-                        return None;
-                    }
-                    Some(transaction)
-                }).collect();
+                let mut new_transactions = self.get_filtered_transactions(stacks_client, &[self.signer_id]).map_err(|e| {
+                    warn!("Signer #{}: Failed to get old transactions: {e:?}. Potentially overwriting our existing transactions", self.signer_id);
+                }).unwrap_or_default();
                 new_transactions.push(new_transaction);
                 let signer_message = SignerMessage::Transactions(new_transactions);
                 self.stackerdb.send_message_with_retry(signer_message)?;
@@ -1077,13 +1147,9 @@ impl Signer {
             && self.coordinator.state == CoordinatorState::Idle
         {
             // Have I already voted and have a pending transaction? Check stackerdb for the same round number and reward cycle vote transaction
-            let old_transactions = self
-                .stackerdb
-                .get_signer_transactions_with_retry(&[self.signer_id])
-                .map_err(|e| {
-                    error!("Failed to get old transactions from stackerdb: {e:?}");
-                })
-                .unwrap_or_default();
+            let old_transactions = self.get_filtered_transactions(stacks_client, &[self.signer_id]).map_err(|e| {
+                warn!("Signer #{}: Failed to get old transactions: {e:?}. Potentially overwriting our existing transactions", self.signer_id);
+            }).unwrap_or_default();
             // Check if we have an existing vote transaction for the same round and reward cycle
             for transaction in old_transactions.iter() {
                 let origin_address = transaction.origin_address();
@@ -1095,14 +1161,14 @@ impl Signer {
                     continue;
                 };
                 if payload.function_name == VOTE_FUNCTION_NAME.into() {
-                    let Some((_signer_index, point, round)) =
+                    let Some((_signer_index, point, round, _reward_cycle)) =
                         Self::parse_function_args(&payload.function_args)
                     else {
                         error!("BUG: Signer #{}: Received an unrecognized transaction ({}) in an already filtered list: {transaction:?}", self.signer_id, transaction.txid());
                         continue;
                     };
                     if Some(point) == self.coordinator.aggregate_public_key
-                        && round == self.coordinator.current_dkg_id as u128
+                        && round == self.coordinator.current_dkg_id as u64
                     {
                         debug!("Signer #{}: Not triggering a DKG round. Already have a pending vote transaction for aggregate public key {point:?} for round {round}...", self.signer_id);
                         return Ok(());
@@ -1112,6 +1178,19 @@ impl Signer {
                     continue;
                 }
             }
+            if stacks_client
+                .get_vote_for_aggregate_public_key(
+                    self.coordinator.current_dkg_id,
+                    self.reward_cycle,
+                    stacks_client.get_signer_address().clone(),
+                )?
+                .is_some()
+            {
+                // TODO Check if the vote failed and we need to retrigger the DKG round not just if we have already voted...
+                // TODO need logic to trigger another DKG round if a certain amount of time passes and we still have no confirmed DKG vote
+                debug!("Signer #{}: Not triggering a DKG round. Already voted and we may need to wait for more votes to arrive.", self.signer_id);
+                return Ok(());
+            }
             if self.commands.front() != Some(&Command::Dkg) {
                 info!("Signer #{} is the current coordinator for {reward_cycle} and must trigger DKG. Queuing DKG command...", self.signer_id);
                 self.commands.push_front(Command::Dkg);
@@ -1186,19 +1265,21 @@ impl Signer {
         Ok(())
     }
 
-    fn parse_function_args(function_args: &[ClarityValue]) -> Option<(u128, Point, u128)> {
+    fn parse_function_args(function_args: &[ClarityValue]) -> Option<(u64, Point, u64, u64)> {
+        // TODO: parse out the reward cycle
         if function_args.len() != 3 {
             return None;
         }
         let signer_index_value = function_args.first()?;
-        let signer_index = signer_index_value.clone().expect_u128().ok()?;
+        let signer_index = u64::try_from(signer_index_value.clone().expect_u128().ok()?).ok()?;
         let point_value = function_args.get(1)?;
         let point_bytes = point_value.clone().expect_buff(33).ok()?;
         let compressed_data = Compressed::try_from(point_bytes.as_slice()).ok()?;
         let point = Point::try_from(&compressed_data).ok()?;
         let round_value = function_args.get(2)?;
-        let round = round_value.clone().expect_u128().ok()?;
-        Some((signer_index, point, round))
+        let round = u64::try_from(round_value.clone().expect_u128().ok()?).ok()?;
+        let reward_cycle = 0;
+        Some((signer_index, point, round, reward_cycle))
     }
 }
 
@@ -1208,8 +1289,13 @@ mod tests {
 
     use blockstack_lib::chainstate::nakamoto::{NakamotoBlock, NakamotoBlockHeader};
     use blockstack_lib::chainstate::stacks::boot::SIGNERS_VOTING_NAME;
-    use blockstack_lib::chainstate::stacks::{ThresholdSignature, TransactionVersion};
+    use blockstack_lib::chainstate::stacks::{
+        StacksTransaction, ThresholdSignature, TransactionAnchorMode, TransactionAuth,
+        TransactionPayload, TransactionPostConditionMode, TransactionSmartContract,
+        TransactionVersion,
+    };
     use blockstack_lib::util_lib::boot::{boot_code_addr, boot_code_id};
+    use blockstack_lib::util_lib::strings::StacksString;
     use clarity::vm::Value;
     use libsigner::SignerMessage;
     use rand::thread_rng;
@@ -1217,6 +1303,7 @@ mod tests {
     use serial_test::serial;
     use stacks_common::bitvec::BitVec;
     use stacks_common::codec::StacksMessageCodec;
+    use stacks_common::consts::CHAIN_ID_TESTNET;
     use stacks_common::types::chainstate::{
         ConsensusHash, StacksBlockId, StacksPrivateKey, TrieHash,
     };
@@ -1227,6 +1314,7 @@ mod tests {
     use wsts::curve::scalar::Scalar;
 
     use crate::client::tests::{
+        build_get_aggregate_public_key_response, build_get_last_round_response,
         generate_reward_cycle_config, mock_server_from_config, write_response,
     };
     use crate::client::{StacksClient, VOTE_FUNCTION_NAME};
@@ -1235,7 +1323,8 @@ mod tests {
 
     #[test]
     #[serial]
-    fn get_expected_transactions_should_filter_invalid_transactions() {
+    #[ignore = "This test needs to be fixed based on reward set calculations"]
+    fn get_filtered_transaction_filters_out_invalid_transactions() {
         // Create a runloop of a valid signer
         let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
         let (reward_cycle_info, _ordered_addresses) = generate_reward_cycle_config(
@@ -1363,8 +1452,12 @@ mod tests {
             invalid_tx_bad_function,
             invalid_tx_bad_function_args,
         ];
-
-        let h = spawn(move || signer.get_expected_transactions(&stacks_client).unwrap());
+        let num_transactions = transactions.len();
+        let h = spawn(move || {
+            signer
+                .get_filtered_transactions(&stacks_client, &[0])
+                .unwrap()
+        });
 
         // Simulate the response to the request for transactions
         let signer_message = SignerMessage::Transactions(transactions);
@@ -1374,42 +1467,11 @@ mod tests {
         let mock_server = mock_server_from_config(&config);
         write_response(mock_server, response_bytes.as_slice());
 
-        let signer_message = SignerMessage::Transactions(vec![]);
-        let message = signer_message.serialize_to_vec();
-        let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
-        response_bytes.extend(message);
-        let mock_server = mock_server_from_config(&config);
-        write_response(mock_server, response_bytes.as_slice());
-
-        let signer_message = SignerMessage::Transactions(vec![]);
-        let message = signer_message.serialize_to_vec();
-        let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
-        response_bytes.extend(message);
-        let mock_server = mock_server_from_config(&config);
-        write_response(mock_server, response_bytes.as_slice());
-
-        let signer_message = SignerMessage::Transactions(vec![]);
-        let message = signer_message.serialize_to_vec();
-        let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
-        response_bytes.extend(message);
-        let mock_server = mock_server_from_config(&config);
-        write_response(mock_server, response_bytes.as_slice());
-
-        let signer_message = SignerMessage::Transactions(vec![]);
-        let message = signer_message.serialize_to_vec();
-        let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
-        response_bytes.extend(message);
-        let mock_server = mock_server_from_config(&config);
-        write_response(mock_server, response_bytes.as_slice());
-
-        // Only the first two transactions need a nonce check
-        let nonce_response = b"HTTP/1.1 200 OK\n\n{\"nonce\":1,\"balance\":\"0x00000000000000000000000000000000\",\"locked\":\"0x00000000000000000000000000000000\",\"unlock_height\":0}";
-        let mock_server = mock_server_from_config(&config);
-        write_response(mock_server, nonce_response);
-
-        let nonce_response = b"HTTP/1.1 200 OK\n\n{\"nonce\":1,\"balance\":\"0x00000000000000000000000000000000\",\"locked\":\"0x00000000000000000000000000000000\",\"unlock_height\":0}";
-        let mock_server = mock_server_from_config(&config);
-        write_response(mock_server, nonce_response);
+        for _ in 0..num_transactions {
+            let nonce_response = b"HTTP/1.1 200 OK\n\n{\"nonce\":1,\"balance\":\"0x00000000000000000000000000000000\",\"locked\":\"0x00000000000000000000000000000000\",\"unlock_height\":0}";
+            let mock_server = mock_server_from_config(&config);
+            write_response(mock_server, nonce_response);
+        }
 
         let filtered_txs = h.join().unwrap();
         assert_eq!(filtered_txs, vec![valid_tx]);
@@ -1417,7 +1479,8 @@ mod tests {
 
     #[test]
     #[serial]
-    fn verify_transactions_valid() {
+    #[ignore = "This test needs to be fixed based on reward set calculations"]
+    fn verify_block_transactions_valid() {
         let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
         let (reward_cycle_info, _ordered_addresses) = generate_reward_cycle_config(
             5,
@@ -1490,7 +1553,7 @@ mod tests {
             BlockInfo::new(block.clone()),
         );
 
-        let h = spawn(move || signer.verify_transactions(&stacks_client, &block));
+        let h = spawn(move || signer.verify_block_transactions(&stacks_client, &block));
 
         // Simulate the response to the request for transactions with the expected transaction
         let signer_message = SignerMessage::Transactions(vec![valid_tx]);
@@ -1535,4 +1598,175 @@ mod tests {
         let valid = h.join().unwrap();
         assert!(valid);
     }
+
+    #[test]
+    #[serial]
+    fn verify_transaction_payload_filters_invalid_payloads() {
+        // Create a runloop of a valid signer
+        let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
+        let (mut reward_cycle_info, _ordered_addresses) = generate_reward_cycle_config(
+            5,
+            20,
+            Some(
+                ecdsa::PublicKey::new(&config.ecdsa_private_key)
+                    .expect("Failed to create public key."),
+            ),
+        );
+        reward_cycle_info.reward_cycle = 1;
+        let signer = Signer::from_configs(&config, reward_cycle_info.clone());
+        let signer_private_key = config.stacks_private_key;
+        let vote_contract_id = boot_code_id(SIGNERS_VOTING_NAME, signer.is_mainnet);
+        let contract_addr = vote_contract_id.issuer.into();
+        let contract_name = vote_contract_id.name.clone();
+        let point = Point::from(Scalar::random(&mut thread_rng()));
+        let round = thread_rng().next_u64() as u128;
+        let valid_function_args = vec![
+            Value::UInt(signer.signer_id as u128),
+            Value::buff_from(point.compress().data.to_vec()).expect("Failed to create buff"),
+            Value::UInt(thread_rng().next_u64() as u128),
+        ];
+
+        // Create a invalid transaction that is not a contract call
+        let invalid_not_contract_call = StacksTransaction {
+            version: TransactionVersion::Testnet,
+            chain_id: CHAIN_ID_TESTNET,
+            auth: TransactionAuth::from_p2pkh(&signer_private_key).unwrap(),
+            anchor_mode: TransactionAnchorMode::Any,
+            post_condition_mode: TransactionPostConditionMode::Allow,
+            post_conditions: vec![],
+            payload: TransactionPayload::SmartContract(
+                TransactionSmartContract {
+                    name: "test-contract".into(),
+                    code_body: StacksString::from_str("(/ 1 0)").unwrap(),
+                },
+                None,
+            ),
+        };
+        let invalid_signers_contract_addr = StacksClient::build_signed_contract_call_transaction(
+            &config.stacks_address, // Not the signers contract address
+            contract_name.clone(),
+            VOTE_FUNCTION_NAME.into(),
+            &valid_function_args,
+            &signer_private_key,
+            TransactionVersion::Testnet,
+            config.network.to_chain_id(),
+            1,
+            10,
+        )
+        .unwrap();
+        let invalid_signers_contract_name = StacksClient::build_signed_contract_call_transaction(
+            &contract_addr,
+            "bad-signers-contract-name".into(),
+            VOTE_FUNCTION_NAME.into(),
+            &valid_function_args,
+            &signer_private_key,
+            TransactionVersion::Testnet,
+            config.network.to_chain_id(),
+            1,
+            10,
+        )
+        .unwrap();
+
+        let invalid_signers_vote_function = StacksClient::build_signed_contract_call_transaction(
+            &contract_addr,
+            contract_name.clone(),
+            "some-other-function".into(),
+            &valid_function_args,
+            &signer_private_key,
+            TransactionVersion::Testnet,
+            config.network.to_chain_id(),
+            1,
+            10,
+        )
+        .unwrap();
+        let invalid_signer_id_argument = StacksClient::build_signed_contract_call_transaction(
+            &contract_addr,
+            contract_name.clone(),
+            VOTE_FUNCTION_NAME.into(),
+            &[
+                Value::UInt(signer.signer_id.wrapping_add(1) as u128), // Not the signers id
+                Value::buff_from(point.compress().data.to_vec()).expect("Failed to create buff"),
+                Value::UInt(round),
+            ],
+            &signer_private_key,
+            TransactionVersion::Testnet,
+            config.network.to_chain_id(),
+            1,
+            10,
+        )
+        .unwrap();
+
+        let stacks_client = StacksClient::from(&config);
+        for tx in vec![
+            invalid_not_contract_call,
+            invalid_signers_contract_addr,
+            invalid_signers_contract_name,
+            invalid_signers_vote_function,
+            invalid_signer_id_argument,
+        ] {
+            let result = signer
+                .verify_payload(&stacks_client, &tx, signer.signer_id)
+                .unwrap();
+            assert!(!result);
+        }
+
+        let invalid_already_voted = StacksClient::build_signed_contract_call_transaction(
+            &contract_addr,
+            contract_name.clone(),
+            VOTE_FUNCTION_NAME.into(),
+            &valid_function_args,
+            &signer_private_key,
+            TransactionVersion::Testnet,
+            config.network.to_chain_id(),
+            1,
+            10,
+        )
+        .unwrap();
+
+        let h = spawn(move || {
+            assert!(!signer
+                .verify_payload(&stacks_client, &invalid_already_voted, signer.signer_id)
+                .unwrap())
+        });
+        let vote_response = build_get_aggregate_public_key_response(Some(point));
+        let mock_server = mock_server_from_config(&config);
+        write_response(mock_server, vote_response.as_bytes());
+        h.join().unwrap();
+
+        let signer = Signer::from_configs(&config, reward_cycle_info.clone());
+        let vote_response = build_get_aggregate_public_key_response(None);
+        let last_round_response = build_get_last_round_response(10);
+        let aggregate_public_key_response = build_get_aggregate_public_key_response(Some(point));
+
+        let invalid_round_number = StacksClient::build_signed_contract_call_transaction(
+            &contract_addr,
+            contract_name.clone(),
+            VOTE_FUNCTION_NAME.into(),
+            &[
+                Value::UInt(signer.signer_id as u128),
+                Value::buff_from(point.compress().data.to_vec()).expect("Failed to create buff"),
+                Value::UInt(round.wrapping_add(1)), // Voting for a future round than the last one seen AFTER dkg is set
+            ],
+            &signer_private_key,
+            TransactionVersion::Testnet,
+            config.network.to_chain_id(),
+            1,
+            10,
+        )
+        .unwrap();
+
+        let stacks_client = StacksClient::from(&config);
+        let h = spawn(move || {
+            assert!(!signer
+                .verify_payload(&stacks_client, &invalid_round_number, signer.signer_id)
+                .unwrap())
+        });
+        let mock_server = mock_server_from_config(&config);
+        write_response(mock_server, vote_response.as_bytes());
+        let mock_server = mock_server_from_config(&config);
+        write_response(mock_server, last_round_response.as_bytes());
+        let mock_server = mock_server_from_config(&config);
+        write_response(mock_server, aggregate_public_key_response.as_bytes());
+        h.join().unwrap();
+    }
 }

From 2c0e4bc2fc9cc880574df5310829f3a1470bbaba Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 9 Feb 2024 17:25:27 -0800
Subject: [PATCH 0885/1166] CRC: do not need to store signer_set

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/mod.rs       |  3 ---
 stacks-signer/src/client/stackerdb.rs | 17 ++++++++---------
 stacks-signer/src/config.rs           |  2 --
 stacks-signer/src/runloop.rs          |  1 -
 4 files changed, 8 insertions(+), 15 deletions(-)

diff --git a/stacks-signer/src/client/mod.rs b/stacks-signer/src/client/mod.rs
index a03d98db03..1c55986ab6 100644
--- a/stacks-signer/src/client/mod.rs
+++ b/stacks-signer/src/client/mod.rs
@@ -417,8 +417,6 @@ pub(crate) mod tests {
             key_ids: HashMap::new(),
         };
         let reward_cycle = thread_rng().next_u64();
-        let signer_set = u32::try_from(reward_cycle % 2)
-            .expect("Failed to convert reward cycle signer set to u32");
         let rng = &mut OsRng;
         let num_keys = num_keys / num_signers;
         let remaining_keys = num_keys % num_signers;
@@ -498,7 +496,6 @@ pub(crate) mod tests {
                 coordinator_key_ids,
                 signer_slot_id: 0,
                 signer_id: 0,
-                signer_set,
                 reward_cycle,
                 signer_address_ids,
                 signer_public_keys,
diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index 65d0f3fbe6..81a0306a0f 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -45,8 +45,8 @@ pub struct StackerDB {
     slot_versions: HashMap<u32, HashMap<u32, u32>>,
     /// The signer slot ID -- the index into the signer list for this signer daemon's signing key.
     signer_slot_id: u32,
-    /// Depends on whether or not we're signing in an even or odd reward cycle
-    signer_set: u32,
+    /// The reward cycle of the connecting signer
+    reward_cycle: u64,
 }
 
 impl StackerDB {
@@ -55,7 +55,7 @@ impl StackerDB {
         host: SocketAddr,
         stacks_private_key: StacksPrivateKey,
         is_mainnet: bool,
-        signer_set: u32,
+        reward_cycle: u64,
         signer_slot_id: u32,
     ) -> Self {
         let mut signers_message_stackerdb_sessions = HashMap::new();
@@ -68,8 +68,7 @@ impl StackerDB {
                     QualifiedContractIdentifier::new(
                         stackerdb_issuer.into(),
                         ContractName::from(
-                            NakamotoSigners::make_signers_db_name(signer_set as u64, msg_id)
-                                .as_str(),
+                            NakamotoSigners::make_signers_db_name(reward_cycle, msg_id).as_str(),
                         ),
                     ),
                 ),
@@ -80,7 +79,7 @@ impl StackerDB {
             stacks_private_key,
             slot_versions: HashMap::new(),
             signer_slot_id,
-            signer_set,
+            reward_cycle,
         }
     }
 
@@ -97,7 +96,7 @@ impl StackerDB {
                         stackerdb_issuer.into(),
                         ContractName::from(
                             NakamotoSigners::make_signers_db_name(
-                                reward_cycle_config.signer_set as u64,
+                                reward_cycle_config.reward_cycle,
                                 msg_id,
                             )
                             .as_str(),
@@ -111,7 +110,7 @@ impl StackerDB {
             stacks_private_key: config.stacks_private_key,
             slot_versions: HashMap::new(),
             signer_slot_id: reward_cycle_config.signer_slot_id,
-            signer_set: reward_cycle_config.signer_set,
+            reward_cycle: reward_cycle_config.reward_cycle,
         }
     }
 
@@ -239,7 +238,7 @@ impl StackerDB {
 
     /// Retrieve the signer set this stackerdb client is attached to
     pub fn get_signer_set(&self) -> u32 {
-        self.signer_set
+        u32::try_from(self.reward_cycle % 2).expect("FATAL: reward cycle % 2 exceeds u32::MAX")
     }
 
     /// Retrieve the signer slot ID
diff --git a/stacks-signer/src/config.rs b/stacks-signer/src/config.rs
index ac7d2f29e7..35a84d8b04 100644
--- a/stacks-signer/src/config.rs
+++ b/stacks-signer/src/config.rs
@@ -113,8 +113,6 @@ impl Network {
 /// The Configuration info needed for an individual signer per reward cycle
 #[derive(Debug, Clone)]
 pub struct RewardCycleConfig {
-    /// The signer set for this runloop
-    pub signer_set: u32,
     /// The index into the signers list of this signer's key (may be different from signer_id)
     pub signer_slot_id: u32,
     /// The signer ID assigned to this signer
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index a5a36bb786..97d2be4ee0 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -177,7 +177,6 @@ impl RunLoop {
             reward_cycle,
             signer_id: *signer_id,
             signer_slot_id,
-            signer_set,
             signer_address_ids,
             key_ids,
             coordinator_key_ids,

From 63cca9ca47fda65ed74dc3a80ad988bc0ca2a2ad Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Sat, 10 Feb 2024 06:47:31 -0800
Subject: [PATCH 0886/1166] Broadcast DKG result to stackerdb for all pox-4
 epochs. Do not have a fee for eppch 3 onwards

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/stacks_client.rs | 23 ++++----
 stacks-signer/src/config.rs               |  4 +-
 stacks-signer/src/signer.rs               | 70 +++++++++++++++--------
 3 files changed, 62 insertions(+), 35 deletions(-)

diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index c32b58b1c6..fd623184cc 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -65,8 +65,6 @@ pub struct StacksClient {
     chain_id: u32,
     /// The Client used to make HTTP connects
     stacks_node_client: reqwest::blocking::Client,
-    /// The stx transaction fee to use in microstacks
-    tx_fee: u64,
 }
 
 impl From<&GlobalConfig> for StacksClient {
@@ -78,7 +76,6 @@ impl From<&GlobalConfig> for StacksClient {
             tx_version: config.network.to_transaction_version(),
             chain_id: config.network.to_chain_id(),
             stacks_node_client: reqwest::blocking::Client::new(),
-            tx_fee: config.tx_fee,
         }
     }
 }
@@ -475,6 +472,7 @@ impl StacksClient {
         signer_index: u32,
         round: u64,
         point: Point,
+        tx_fee: Option<u64>,
     ) -> Result<StacksTransaction, ClientError> {
         debug!("Building {VOTE_FUNCTION_NAME} transaction...");
         // TODO: this nonce should be calculated on the side as we may have pending transactions that are not yet confirmed...
@@ -505,7 +503,9 @@ impl StacksClient {
         );
 
         let mut unsigned_tx = StacksTransaction::new(self.tx_version, tx_auth, tx_payload);
-        unsigned_tx.set_tx_fee(self.tx_fee);
+        if let Some(tx_fee) = tx_fee {
+            unsigned_tx.set_tx_fee(tx_fee);
+        }
         unsigned_tx.set_origin_nonce(nonce);
 
         unsigned_tx.anchor_mode = TransactionAnchorMode::Any;
@@ -524,8 +524,8 @@ impl StacksClient {
             ))
     }
 
-    /// Helper function to submit a transaction to the Stacks node
-    pub fn broadcast_transaction(&self, tx: &StacksTransaction) -> Result<Txid, ClientError> {
+    /// Helper function to submit a transaction to the Stacks mempool
+    pub fn submit_transaction(&self, tx: &StacksTransaction) -> Result<Txid, ClientError> {
         let txid = tx.txid();
         let tx = tx.serialize_to_vec();
         let send_request = || {
@@ -906,7 +906,7 @@ mod tests {
             + 1;
 
         let tx_clone = tx.clone();
-        let h = spawn(move || mock.client.broadcast_transaction(&tx_clone));
+        let h = spawn(move || mock.client.submit_transaction(&tx_clone));
 
         let request_bytes = write_response(
             mock.server,
@@ -932,7 +932,10 @@ mod tests {
         let nonce = thread_rng().next_u64();
         let account_nonce_response = build_account_nonce_response(nonce);
 
-        let h = spawn(move || mock.client.build_vote_for_aggregate_public_key(0, 0, point));
+        let h = spawn(move || {
+            mock.client
+                .build_vote_for_aggregate_public_key(0, 0, point, None)
+        });
         write_response(mock.server, account_nonce_response.as_bytes());
         assert!(h.join().unwrap().is_ok());
     }
@@ -950,9 +953,9 @@ mod tests {
             let tx = mock
                 .client
                 .clone()
-                .build_vote_for_aggregate_public_key(0, 0, point)
+                .build_vote_for_aggregate_public_key(0, 0, point, None)
                 .unwrap();
-            mock.client.broadcast_transaction(&tx)
+            mock.client.submit_transaction(&tx)
         });
         write_response(mock.server, account_nonce_response.as_bytes());
         let mock = MockServerClient::from_config(mock.config);
diff --git a/stacks-signer/src/config.rs b/stacks-signer/src/config.rs
index 35a84d8b04..82892fb224 100644
--- a/stacks-signer/src/config.rs
+++ b/stacks-signer/src/config.rs
@@ -161,7 +161,7 @@ pub struct GlobalConfig {
     /// timeout to gather signature shares
     pub sign_timeout: Option<Duration>,
     /// the STX tx fee to use in uSTX
-    pub tx_fee: u64,
+    pub tx_fee_ms: u64,
 }
 
 /// Internal struct for loading up the config file
@@ -287,7 +287,7 @@ impl TryFrom<RawConfigFile> for GlobalConfig {
             dkg_private_timeout,
             nonce_timeout,
             sign_timeout,
-            tx_fee: raw_data.tx_fee_ms.unwrap_or(TX_FEE_MS),
+            tx_fee_ms: raw_data.tx_fee_ms.unwrap_or(TX_FEE_MS),
         })
     }
 }
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index 2d2ecd1bfa..e53f045afe 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -137,6 +137,8 @@ pub struct Signer {
     pub signer_address_ids: HashMap<StacksAddress, u32>,
     /// The reward cycle this signer belongs to
     pub reward_cycle: u64,
+    /// The tx fee in uSTX to use if the epoch is pre Nakamoto (Epoch 3.0)
+    pub tx_fee_ms: u64,
 }
 
 impl Signer {
@@ -187,6 +189,7 @@ impl Signer {
             signer_id: reward_cycle_config.signer_id,
             signer_address_ids: reward_cycle_config.signer_address_ids,
             reward_cycle: reward_cycle_config.reward_cycle,
+            tx_fee_ms: config.tx_fee_ms,
         }
     }
 
@@ -418,6 +421,7 @@ impl Signer {
         let packets: Vec<Packet> = messages
             .iter()
             .filter_map(|msg| match msg {
+                // TODO: should we store the received transactions on the side and use them rather than directly querying the stacker db slots?
                 SignerMessage::BlockResponse(_) | SignerMessage::Transactions(_) => None,
                 SignerMessage::Packet(packet) => {
                     self.verify_packet(stacks_client, packet.clone(), &coordinator_public_key)
@@ -901,17 +905,26 @@ impl Signer {
 
     /// Process a dkg result by broadcasting a vote to the stacks node
     fn process_dkg(&mut self, stacks_client: &StacksClient, point: &Point) {
-        match retry_with_exponential_backoff(|| {
-            stacks_client
-                .build_vote_for_aggregate_public_key(
-                    self.stackerdb.get_signer_slot_id(),
-                    self.coordinator.current_dkg_id,
-                    *point,
-                )
-                .map_err(backoff::Error::transient)
-        }) {
+        let epoch = stacks_client
+            .get_node_epoch_with_retry()
+            .unwrap_or(StacksEpochId::Epoch24);
+        let tx_fee = if epoch != StacksEpochId::Epoch30 {
+            debug!(
+                "Signer #{}: in pre Epoch 3.0 cycles, must set a transaction fee for the DKG vote.",
+                self.signer_id
+            );
+            Some(self.tx_fee_ms)
+        } else {
+            None
+        };
+        match stacks_client.build_vote_for_aggregate_public_key(
+            self.stackerdb.get_signer_slot_id(),
+            self.coordinator.current_dkg_id,
+            *point,
+            tx_fee,
+        ) {
             Ok(transaction) => {
-                if let Err(e) = self.broadcast_dkg_vote(stacks_client, transaction) {
+                if let Err(e) = self.broadcast_dkg_vote(stacks_client, transaction, epoch) {
                     warn!(
                         "Signer #{}: Failed to broadcast DKG vote ({point:?}): {e:?}",
                         self.signer_id
@@ -932,28 +945,38 @@ impl Signer {
         &mut self,
         stacks_client: &StacksClient,
         new_transaction: StacksTransaction,
+        epoch: StacksEpochId,
     ) -> Result<(), ClientError> {
-        let epoch = stacks_client
-            .get_node_epoch_with_retry()
-            .unwrap_or(StacksEpochId::Epoch24);
+        let txid = new_transaction.txid();
         match epoch {
             StacksEpochId::Epoch25 => {
-                debug!("Signer #{}: Received a DKG result, but are in epoch 2.5. Broadcast the transaction to the mempool.", self.signer_id);
-                stacks_client.broadcast_transaction(&new_transaction)?;
+                debug!("Signer #{}: Received a DKG result while in epoch 2.5. Broadcast the transaction to the mempool.", self.signer_id);
+                stacks_client.submit_transaction(&new_transaction)?;
+                info!(
+                    "Signer #{}: Submitted DKG vote transaction ({txid:?}) to the mempool",
+                    self.signer_id
+                )
             }
             StacksEpochId::Epoch30 => {
-                debug!("Signer #{}: Received a DKG result, but are in epoch 3. Broadcast the transaction to stackerDB.", self.signer_id);
-                let mut new_transactions = self.get_filtered_transactions(stacks_client, &[self.signer_id]).map_err(|e| {
-                    warn!("Signer #{}: Failed to get old transactions: {e:?}. Potentially overwriting our existing transactions", self.signer_id);
-                }).unwrap_or_default();
-                new_transactions.push(new_transaction);
-                let signer_message = SignerMessage::Transactions(new_transactions);
-                self.stackerdb.send_message_with_retry(signer_message)?;
+                debug!("Signer #{}: Received a DKG result while in epoch 3.0. Broadcast the transaction only to stackerDB.", self.signer_id);
             }
             _ => {
-                debug!("Signer #{}: Received a DKG result, but are in an unsupported epoch. Do not broadcast the result.", self.signer_id);
+                debug!("Signer #{}: Received a DKG result, but are in an unsupported epoch. Do not broadcast the transaction ({}).", self.signer_id, new_transaction.txid());
+                return Ok(());
             }
         }
+        // For all Pox-4 epochs onwards, broadcast the results also to stackerDB for other signers/miners to observe
+        // TODO: if we store transactions on the side, should we use them rather than directly querying the stacker db slot?
+        let mut new_transactions = self.get_filtered_transactions(stacks_client, &[self.signer_id]).map_err(|e| {
+            warn!("Signer #{}: Failed to get old transactions: {e:?}. Potentially overwriting our existing stackerDB transactions", self.signer_id);
+        }).unwrap_or_default();
+        new_transactions.push(new_transaction);
+        let signer_message = SignerMessage::Transactions(new_transactions);
+        self.stackerdb.send_message_with_retry(signer_message)?;
+        info!(
+            "Signer #{}: Broadcasted DKG vote transaction ({txid:?}) to stackerDB",
+            self.signer_id
+        );
         Ok(())
     }
 
@@ -1147,6 +1170,7 @@ impl Signer {
             && self.coordinator.state == CoordinatorState::Idle
         {
             // Have I already voted and have a pending transaction? Check stackerdb for the same round number and reward cycle vote transaction
+            // TODO: might be better to store these transactions on the side to prevent having to query the stacker db for every signer (only do on initilaization of a new signer for example and then listen for stacker db updates after that)
             let old_transactions = self.get_filtered_transactions(stacks_client, &[self.signer_id]).map_err(|e| {
                 warn!("Signer #{}: Failed to get old transactions: {e:?}. Potentially overwriting our existing transactions", self.signer_id);
             }).unwrap_or_default();

From 89541b25cdc581dc2dd8df2ebd027596eb85aca4 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Sun, 11 Feb 2024 13:01:56 -0800
Subject: [PATCH 0887/1166] Fix dkg and sign test

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/mod.rs               |  24 +-
 stacks-signer/src/client/stacks_client.rs     | 114 ++++++-
 stacks-signer/src/config.rs                   |  23 +-
 stacks-signer/src/runloop.rs                  |  88 ++---
 stacks-signer/src/signer.rs                   |  61 ++--
 .../src/tests/nakamoto_integrations.rs        |  12 +-
 testnet/stacks-node/src/tests/signer.rs       | 302 +++++++++++-------
 7 files changed, 396 insertions(+), 228 deletions(-)

diff --git a/stacks-signer/src/client/mod.rs b/stacks-signer/src/client/mod.rs
index 1c55986ab6..33066eaee9 100644
--- a/stacks-signer/src/client/mod.rs
+++ b/stacks-signer/src/client/mod.rs
@@ -156,7 +156,7 @@ pub(crate) mod tests {
     use wsts::state_machine::PublicKeys;
 
     use super::*;
-    use crate::config::{GlobalConfig, RewardCycleConfig};
+    use crate::config::{GlobalConfig, RegisteredSignersInfo, RewardCycleConfig};
 
     pub struct MockServerClient {
         pub server: TcpListener,
@@ -397,8 +397,8 @@ pub(crate) mod tests {
         format!("HTTP/1.1 200 OK\n\n{{\"okay\":true,\"result\":\"{hex}\"}}")
     }
 
-    /// Generate a random reward cycle config
-    /// Optionally include a signer pubilc key to set as the first signer id with signer id 0 and signer slot id 0
+    /// Generate a random reward cycle config for signer with id 0 and slot id 0
+    /// Optionally include a signer pubilc key to use for the signer
     pub fn generate_reward_cycle_config(
         num_signers: u32,
         num_keys: u32,
@@ -490,15 +490,17 @@ pub(crate) mod tests {
         }
         (
             RewardCycleConfig {
-                public_keys,
-                key_ids: signer_key_ids.get(&0).cloned().unwrap_or_default(),
-                signer_key_ids,
-                coordinator_key_ids,
-                signer_slot_id: 0,
-                signer_id: 0,
                 reward_cycle,
-                signer_address_ids,
-                signer_public_keys,
+                signer_id: 0,
+                signer_slot_id: 0,
+                key_ids: signer_key_ids.get(&0).cloned().unwrap_or_default(),
+                registered_signers: RegisteredSignersInfo {
+                    public_keys,
+                    coordinator_key_ids,
+                    signer_key_ids,
+                    signer_address_ids,
+                    signer_public_keys,
+                },
             },
             addresses,
         )
diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index fd623184cc..6a1a83777c 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -1,3 +1,5 @@
+use std::net::SocketAddr;
+
 // Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
 // Copyright (C) 2020-2024 Stacks Open Internet Foundation
 //
@@ -30,10 +32,11 @@ use blockstack_lib::net::api::postblock_proposal::NakamotoBlockProposal;
 use blockstack_lib::util_lib::boot::{boot_code_addr, boot_code_id};
 use clarity::vm::types::{PrincipalData, QualifiedContractIdentifier};
 use clarity::vm::{ClarityName, ContractName, Value as ClarityValue};
+use hashbrown::{HashMap, HashSet};
 use serde_json::json;
 use slog::{slog_debug, slog_warn};
 use stacks_common::codec::StacksMessageCodec;
-use stacks_common::consts::CHAIN_ID_MAINNET;
+use stacks_common::consts::{CHAIN_ID_MAINNET, CHAIN_ID_TESTNET};
 use stacks_common::types::chainstate::{
     ConsensusHash, StacksAddress, StacksPrivateKey, StacksPublicKey,
 };
@@ -45,7 +48,7 @@ use wsts::curve::point::{Compressed, Point};
 use wsts::state_machine::PublicKeys;
 
 use crate::client::{retry_with_exponential_backoff, ClientError};
-use crate::config::GlobalConfig;
+use crate::config::{GlobalConfig, RegisteredSignersInfo};
 
 /// The name of the function for casting a DKG result to signer vote contract
 pub const VOTE_FUNCTION_NAME: &str = "vote-for-aggregate-public-key";
@@ -81,6 +84,30 @@ impl From<&GlobalConfig> for StacksClient {
 }
 
 impl StacksClient {
+    /// Create a new signer StacksClient with the provided private key, stacks node host endpoint, and version
+    pub fn new(stacks_private_key: StacksPrivateKey, node_host: SocketAddr, mainnet: bool) -> Self {
+        let pubkey = StacksPublicKey::from_private(&stacks_private_key);
+        let tx_version = if mainnet {
+            TransactionVersion::Mainnet
+        } else {
+            TransactionVersion::Testnet
+        };
+        let chain_id = if mainnet {
+            CHAIN_ID_MAINNET
+        } else {
+            CHAIN_ID_TESTNET
+        };
+        let stacks_address = StacksAddress::p2pkh(mainnet, &pubkey);
+        Self {
+            stacks_private_key,
+            stacks_address,
+            http_origin: format!("http://{}", node_host),
+            tx_version,
+            chain_id,
+            stacks_node_client: reqwest::blocking::Client::new(),
+        }
+    }
+
     /// Get our signer address
     pub fn get_signer_address(&self) -> &StacksAddress {
         &self.stacks_address
@@ -184,6 +211,7 @@ impl StacksClient {
         reward_cycle: u64,
         signer: StacksAddress,
     ) -> Result<Option<Point>, ClientError> {
+        debug!("Getting vote for aggregate public key...");
         let function_name = ClarityName::from("get-vote");
         let function_args = &[
             ClarityValue::UInt(reward_cycle as u128),
@@ -373,7 +401,7 @@ impl StacksClient {
     }
 
     /// Get the reward set from the stacks node for the given reward cycle
-    pub fn get_reward_set(&self, reward_cycle: u64) -> Result<RewardSet, ClientError> {
+    fn get_reward_set(&self, reward_cycle: u64) -> Result<RewardSet, ClientError> {
         debug!("Getting reward set for reward cycle {reward_cycle}...");
         let send_request = || {
             self.stacks_node_client
@@ -389,6 +417,76 @@ impl StacksClient {
         Ok(stackers_response.stacker_set)
     }
 
+    /// Get registered signers info for the given reward cycle
+    pub fn get_registered_signers_info(
+        &self,
+        reward_cycle: u64,
+    ) -> Result<Option<RegisteredSignersInfo>, ClientError> {
+        let reward_set = self.get_reward_set(reward_cycle)?;
+        let Some(reward_set_signers) = reward_set.signers else {
+            return Ok(None);
+        };
+
+        // signer uses a Vec<u32> for its key_ids, but coordinator uses a HashSet for each signer since it needs to do lots of lookups
+        let mut weight_end = 1;
+        let mut coordinator_key_ids = HashMap::with_capacity(4000);
+        let mut signer_key_ids = HashMap::with_capacity(reward_set_signers.len());
+        let mut signer_address_ids = HashMap::with_capacity(reward_set_signers.len());
+        let mut public_keys = PublicKeys {
+            signers: HashMap::with_capacity(reward_set_signers.len()),
+            key_ids: HashMap::with_capacity(4000),
+        };
+        let mut signer_public_keys = HashMap::with_capacity(reward_set_signers.len());
+        for (i, entry) in reward_set_signers.iter().enumerate() {
+            let signer_id = u32::try_from(i).expect("FATAL: number of signers exceeds u32::MAX");
+            let ecdsa_public_key = ecdsa::PublicKey::try_from(entry.signing_key.as_slice()).map_err(|e| {
+                        ClientError::CorruptedRewardSet(format!(
+                                "Reward cycle {reward_cycle} failed to convert signing key to ecdsa::PublicKey: {e}"
+                            ))
+                        })?;
+            let signer_public_key = Point::try_from(&Compressed::from(ecdsa_public_key.to_bytes()))
+                .map_err(|e| {
+                    ClientError::CorruptedRewardSet(format!(
+                        "Reward cycle {reward_cycle} failed to convert signing key to Point: {e}"
+                    ))
+                })?;
+            let stacks_public_key = StacksPublicKey::from_slice(entry.signing_key.as_slice()).map_err(|e| {
+                            ClientError::CorruptedRewardSet(format!(
+                                "Reward cycle {reward_cycle} failed to convert signing key to StacksPublicKey: {e}"
+                            ))
+                        })?;
+
+            let stacks_address = StacksAddress::p2pkh(
+                self.tx_version == TransactionVersion::Mainnet,
+                &stacks_public_key,
+            );
+
+            signer_address_ids.insert(stacks_address, signer_id);
+            signer_public_keys.insert(signer_id, signer_public_key);
+            let weight_start = weight_end;
+            weight_end = weight_start + entry.slots;
+            for key_id in weight_start..weight_end {
+                public_keys.key_ids.insert(key_id, ecdsa_public_key);
+                public_keys.signers.insert(signer_id, ecdsa_public_key);
+                coordinator_key_ids
+                    .entry(signer_id)
+                    .or_insert(HashSet::with_capacity(entry.slots as usize))
+                    .insert(key_id);
+                signer_key_ids
+                    .entry(signer_id)
+                    .or_insert(Vec::with_capacity(entry.slots as usize))
+                    .push(key_id);
+            }
+        }
+        Ok(Some(RegisteredSignersInfo {
+            public_keys,
+            signer_key_ids,
+            signer_address_ids,
+            signer_public_keys,
+            coordinator_key_ids,
+        }))
+    }
+
     // Helper function to retrieve the pox data from the stacks node
     fn get_pox_data(&self) -> Result<RPCPoxInfoData, ClientError> {
         debug!("Getting pox data...");
@@ -1327,7 +1425,10 @@ mod tests {
     #[test]
     fn calculate_coordinator_different_consensus_hashes_produces_unique_results() {
         let number_of_tests = 5;
-        let generated_public_keys = generate_reward_cycle_config(10, 4000, None).0.public_keys;
+        let generated_public_keys = generate_reward_cycle_config(10, 4000, None)
+            .0
+            .registered_signers
+            .public_keys;
         let mut results = Vec::new();
 
         for _ in 0..number_of_tests {
@@ -1365,7 +1466,10 @@ mod tests {
         } else {
             Some(same_hash)
         };
-        let generated_public_keys = generate_reward_cycle_config(10, 4000, None).0.public_keys;
+        let generated_public_keys = generate_reward_cycle_config(10, 4000, None)
+            .0
+            .registered_signers
+            .public_keys;
         for _ in 0..count {
             let mock = MockServerClient::new();
             let generated_public_keys = generated_public_keys.clone();
diff --git a/stacks-signer/src/config.rs b/stacks-signer/src/config.rs
index 82892fb224..b7fb2e3598 100644
--- a/stacks-signer/src/config.rs
+++ b/stacks-signer/src/config.rs
@@ -110,15 +110,9 @@ impl Network {
     }
 }
 
-/// The Configuration info needed for an individual signer per reward cycle
+/// The registered signer information for a specific reward cycle
 #[derive(Debug, Clone)]
-pub struct RewardCycleConfig {
-    /// The index into the signers list of this signer's key (may be different from signer_id)
-    pub signer_slot_id: u32,
-    /// The signer ID assigned to this signer
-    pub signer_id: u32,
-    /// The reward cycle of the configuration
-    pub reward_cycle: u64,
+pub struct RegisteredSignersInfo {
     /// The signer to key ids mapping for the coordinator
     pub coordinator_key_ids: HashMap<u32, HashSet<u32>>,
     /// The signer to key ids mapping for the signers
@@ -129,8 +123,21 @@ pub struct RewardCycleConfig {
     pub signer_address_ids: HashMap<StacksAddress, u32>,
     /// The public keys for the reward cycle
     pub public_keys: PublicKeys,
+}
+
+/// The Configuration info needed for an individual signer per reward cycle
+#[derive(Debug, Clone)]
+pub struct RewardCycleConfig {
+    /// The reward cycle of the configuration
+    pub reward_cycle: u64,
+    /// The signer ID assigned to this signer
+    pub signer_id: u32,
+    /// The index into the signers list of this signer's key (may be different from signer_id)
+    pub signer_slot_id: u32,
     /// This signer's key ids
     pub key_ids: Vec<u32>,
+    /// The registered signers for this reward cycle
+    pub registered_signers: RegisteredSignersInfo,
 }
 
 /// The parsed configuration for the signer
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 97d2be4ee0..b69c0e2e1d 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -18,14 +18,11 @@ use std::time::Duration;
 
 use blockstack_lib::chainstate::stacks::boot::SIGNERS_NAME;
 use blockstack_lib::util_lib::boot::boot_code_id;
-use hashbrown::{HashMap, HashSet};
+use hashbrown::HashMap;
 use libsigner::{SignerEvent, SignerRunLoop};
 use slog::{slog_debug, slog_error, slog_info, slog_warn};
-use stacks_common::types::chainstate::{StacksAddress, StacksPublicKey};
 use stacks_common::{debug, error, info, warn};
-use wsts::curve::ecdsa;
-use wsts::curve::point::{Compressed, Point};
-use wsts::state_machine::{OperationResult, PublicKeys};
+use wsts::state_machine::OperationResult;
 
 use crate::client::{retry_with_exponential_backoff, ClientError, StacksClient};
 use crate::config::{GlobalConfig, RewardCycleConfig};
@@ -108,81 +105,33 @@ impl RunLoop {
         };
 
         // We can only register for a reward cycle if a reward set exists. We know that it should exist due to our earlier check for reward_set_calculated
-        let Some(reward_set_signers) = self.stacks_client.get_reward_set(reward_cycle)?.signers
+        let Some(registered_signers) = self
+            .stacks_client
+            .get_registered_signers_info(reward_cycle)?
         else {
             warn!(
                 "No reward set found for reward cycle {reward_cycle}. Must not be a valid Nakamoto reward cycle."
             );
             return Ok(None);
         };
-
-        let mut weight_end = 1;
-        // signer uses a Vec<u32> for its key_ids, but coordinator uses a HashSet for each signer since it needs to do lots of lookups
-        let mut coordinator_key_ids = HashMap::with_capacity(4000);
-        let mut signer_key_ids = HashMap::with_capacity(reward_set_signers.len());
-        let mut signer_address_ids = HashMap::with_capacity(reward_set_signers.len());
-        let mut public_keys = PublicKeys {
-            signers: HashMap::with_capacity(reward_set_signers.len()),
-            key_ids: HashMap::with_capacity(4000),
-        };
-        let mut signer_public_keys = HashMap::with_capacity(reward_set_signers.len());
-        for (i, entry) in reward_set_signers.iter().enumerate() {
-            let signer_id = u32::try_from(i).expect("FATAL: number of signers exceeds u32::MAX");
-            let ecdsa_public_key = ecdsa::PublicKey::try_from(entry.signing_key.as_slice()).map_err(|e| {
-                ClientError::CorruptedRewardSet(format!(
-                        "Reward cycle {reward_cycle} failed to convert signing key to ecdsa::PublicKey: {e}"
-                    ))
-                })?;
-            let signer_public_key = Point::try_from(&Compressed::from(ecdsa_public_key.to_bytes()))
-                .map_err(|e| {
-                    ClientError::CorruptedRewardSet(format!(
-                        "Reward cycle {reward_cycle} failed to convert signing key to Point: {e}"
-                    ))
-                })?;
-            let stacks_public_key = StacksPublicKey::from_slice(entry.signing_key.as_slice()).map_err(|e| {
-                    ClientError::CorruptedRewardSet(format!(
-                        "Reward cycle {reward_cycle} failed to convert signing key to StacksPublicKey: {e}"
-                    ))
-                })?;
-
-            let stacks_address =
-                StacksAddress::p2pkh(self.config.network.is_mainnet(), &stacks_public_key);
-
-            signer_address_ids.insert(stacks_address, signer_id);
-            signer_public_keys.insert(signer_id, signer_public_key);
-            let weight_start = weight_end;
-            weight_end = weight_start + entry.slots;
-            for key_id in weight_start..weight_end {
-                public_keys.key_ids.insert(key_id, ecdsa_public_key);
-                public_keys.signers.insert(signer_id, ecdsa_public_key);
-                coordinator_key_ids
-                    .entry(signer_id)
-                    .or_insert(HashSet::with_capacity(entry.slots as usize))
-                    .insert(key_id);
-                signer_key_ids
-                    .entry(signer_id)
-                    .or_insert(Vec::with_capacity(entry.slots as usize))
-                    .push(key_id);
-            }
-        }
-        let Some(signer_id) = signer_address_ids.get(current_addr) else {
+        let Some(signer_id) = registered_signers.signer_address_ids.get(current_addr) else {
             warn!("Signer {current_addr} was found in stacker db but not the reward set for reward cycle {reward_cycle}.");
             return Ok(None);
         };
         debug!(
             "Signer #{signer_id} ({current_addr}) is registered for reward cycle {reward_cycle}."
         );
-        let key_ids = signer_key_ids.get(signer_id).cloned().unwrap_or_default();
+        let key_ids = registered_signers
+            .signer_key_ids
+            .get(signer_id)
+            .cloned()
+            .unwrap_or_default();
         Ok(Some(RewardCycleConfig {
             reward_cycle,
             signer_id: *signer_id,
             signer_slot_id,
-            signer_address_ids,
             key_ids,
-            coordinator_key_ids,
-            signer_key_ids,
-            public_keys,
-            signer_public_keys,
+            registered_signers,
         }))
     }
 
@@ -319,14 +268,23 @@ impl SignerRunLoop<Vec<OperationResult>, RunLoopCommand> for RunLoop {
             if let Some(stacks_signer) = self.stacks_signers.get_mut(&(reward_cycle % 2)) {
                 if stacks_signer.reward_cycle != reward_cycle {
                     warn!(
-                        "Signer is not registered for reward cycle {reward_cycle}. Ignoring command: {command:?}"
+                        "Signer #{}: not registered for reward cycle {reward_cycle}. Ignoring command: {command:?}", stacks_signer.signer_id
                     );
                 } else {
+                    info!(
+                        "Signer #{}: Queuing an external runloop command ({:?}): {command:?}",
+                        stacks_signer.signer_id,
+                        stacks_signer
+                            .signing_round
+                            .public_keys
+                            .signers
+                            .get(&stacks_signer.signer_id)
+                    );
                     stacks_signer.commands.push_back(command.command);
                 }
             } else {
                 warn!(
-                    "Signer is not registered for reward cycle {reward_cycle}. Ignoring command: {command:?}"
+                    "No signer registered for reward cycle {reward_cycle}. Ignoring command: {command:?}"
                 );
             }
         }
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index e53f045afe..43f701890a 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -106,10 +106,8 @@ pub enum Command {
 pub enum State {
     /// The signer is idle, waiting for messages and commands
     Idle,
-    /// The signer is executing a DKG round
-    Dkg,
-    /// The signer is executing a signing round
-    Sign,
+    /// The signer is executing a DKG or Sign round
+    OperationInProgress,
     /// The Signer has exceeded its tenure
     TenureExceeded,
 }
@@ -146,10 +144,22 @@ impl Signer {
     pub fn from_configs(config: &GlobalConfig, reward_cycle_config: RewardCycleConfig) -> Self {
         let stackerdb = StackerDB::from_configs(config, &reward_cycle_config);
 
-        let num_signers = u32::try_from(reward_cycle_config.public_keys.signers.len())
-            .expect("FATAL: Too many registered signers to fit in a u32");
-        let num_keys = u32::try_from(reward_cycle_config.public_keys.key_ids.len())
-            .expect("FATAL: Too many key ids to fit in a u32");
+        let num_signers = u32::try_from(
+            reward_cycle_config
+                .registered_signers
+                .public_keys
+                .signers
+                .len(),
+        )
+        .expect("FATAL: Too many registered signers to fit in a u32");
+        let num_keys = u32::try_from(
+            reward_cycle_config
+                .registered_signers
+                .public_keys
+                .key_ids
+                .len(),
+        )
+        .expect("FATAL: Too many key ids to fit in a u32");
         let threshold = num_keys * 7 / 10;
         let dkg_threshold = num_keys * 9 / 10;
 
@@ -164,8 +174,8 @@ impl Signer {
             dkg_end_timeout: config.dkg_end_timeout,
             nonce_timeout: config.nonce_timeout,
             sign_timeout: config.sign_timeout,
-            signer_key_ids: reward_cycle_config.coordinator_key_ids,
-            signer_public_keys: reward_cycle_config.signer_public_keys,
+            signer_key_ids: reward_cycle_config.registered_signers.coordinator_key_ids,
+            signer_public_keys: reward_cycle_config.registered_signers.signer_public_keys,
         };
 
         let coordinator = FireCoordinator::new(coordinator_config);
@@ -176,7 +186,7 @@ impl Signer {
             reward_cycle_config.signer_id,
             reward_cycle_config.key_ids,
             config.ecdsa_private_key,
-            reward_cycle_config.public_keys,
+            reward_cycle_config.registered_signers.public_keys,
         );
         Self {
             coordinator,
@@ -187,7 +197,7 @@ impl Signer {
             stackerdb,
             is_mainnet: config.network.is_mainnet(),
             signer_id: reward_cycle_config.signer_id,
-            signer_address_ids: reward_cycle_config.signer_address_ids,
+            signer_address_ids: reward_cycle_config.registered_signers.signer_address_ids,
             reward_cycle: reward_cycle_config.reward_cycle,
             tx_fee_ms: config.tx_fee_ms,
         }
@@ -220,7 +230,7 @@ impl Signer {
                     Ok(msg) => {
                         let ack = self.stackerdb.send_message_with_retry(msg.into());
                         debug!("Signer #{}: ACK: {ack:?}", self.signer_id);
-                        self.state = State::Dkg;
+                        self.state = State::OperationInProgress;
                     }
                     Err(e) => {
                         error!("Signer #{}: Failed to start DKG: {e:?}", self.signer_id);
@@ -232,13 +242,6 @@ impl Signer {
                 is_taproot,
                 merkle_root,
             } => {
-                let epoch = stacks_client
-                    .get_node_epoch_with_retry()
-                    .unwrap_or(StacksEpochId::Epoch24);
-                if epoch != StacksEpochId::Epoch30 {
-                    debug!("Signer #{}: cannot sign blocks in pre Epoch 3.0. Ignoring the sign command.", self.signer_id);
-                    return;
-                };
                 let signer_signature_hash = block.header.signer_signature_hash();
                 let block_info = self
                     .blocks
@@ -257,7 +260,7 @@ impl Signer {
                     Ok(msg) => {
                         let ack = self.stackerdb.send_message_with_retry(msg.into());
                         debug!("Signer #{}: ACK: {ack:?}", self.signer_id);
-                        self.state = State::Sign;
+                        self.state = State::OperationInProgress;
                         block_info.signed_over = true;
                     }
                     Err(e) => {
@@ -275,11 +278,11 @@ impl Signer {
     pub fn process_next_command(&mut self, stacks_client: &StacksClient) {
         match self.state {
             State::Idle => {
-                let (coordinator_id, _) =
+                let (coordinator_id, coordinator_pk) =
                     stacks_client.calculate_coordinator(&self.signing_round.public_keys);
                 if coordinator_id != self.signer_id {
                     debug!(
-                        "Signer #{}: Not the coordinator. Will not process any commands...",
+                        "Signer #{}: Not the coordinator. (Coordinator is {coordinator_id:?}, {coordinator_pk:?}). Will not process any commands...",
                         self.signer_id
                     );
                     return;
@@ -294,12 +297,12 @@ impl Signer {
                     );
                 }
             }
-            State::Dkg | State::Sign => {
+            State::OperationInProgress => {
                 // We cannot execute the next command until the current one is finished...
                 // Do nothing...
                 debug!(
-                    "Signer #{}: Waiting for {:?} operation to finish",
-                    self.signer_id, self.state
+                    "Signer #{}: Waiting for operation to finish",
+                    self.signer_id,
                 );
             }
             State::TenureExceeded => {
@@ -479,6 +482,8 @@ impl Signer {
             self.state = State::Idle;
             self.process_operation_results(stacks_client, &operation_results);
             self.send_operation_results(res, operation_results);
+        } else if self.coordinator.state != CoordinatorState::Idle {
+            self.state = State::OperationInProgress;
         }
         self.send_outbound_messages(signer_outbound_messages);
         self.send_outbound_messages(coordinator_outbound_messages);
@@ -1169,6 +1174,10 @@ impl Signer {
             && self.signer_id == coordinator_id
             && self.coordinator.state == CoordinatorState::Idle
         {
+            debug!(
+                "Signer #{}: Checking if old transactions exist",
+                self.signer_id
+            );
             // Have I already voted and have a pending transaction? Check stackerdb for the same round number and reward cycle vote transaction
             // TODO: might be better to store these transactions on the side to prevent having to query the stacker db for every signer (only do on initilaization of a new signer for example and then listen for stacker db updates after that)
             let old_transactions = self.get_filtered_transactions(stacks_client, &[self.signer_id]).map_err(|e| {
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 048957d6dc..f9c077b9e8 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -585,11 +585,11 @@ fn signer_vote_if_needed(
 pub fn boot_to_epoch_3_reward_set(
     naka_conf: &Config,
     blocks_processed: &RunLoopCounter,
-    stacker_sks: &[Secp256k1PrivateKey],
-    signer_pks: &[StacksPublicKey],
+    stacker_sks: &[StacksPrivateKey],
+    signer_sks: &[StacksPrivateKey],
     btc_regtest_controller: &mut BitcoinRegtestController,
 ) {
-    assert_eq!(stacker_sks.len(), signer_pks.len());
+    assert_eq!(stacker_sks.len(), signer_sks.len());
 
     let epochs = naka_conf.burnchain.epochs.clone().unwrap();
     let epoch_3 = &epochs[StacksEpoch::find_epoch_by_id(&epochs, StacksEpochId::Epoch30).unwrap()];
@@ -617,7 +617,7 @@ pub fn boot_to_epoch_3_reward_set(
         .get_burnchain()
         .block_height_to_reward_cycle(block_height)
         .unwrap();
-    for (stacker_sk, signer_pk) in stacker_sks.iter().zip(signer_pks.iter()) {
+    for (stacker_sk, signer_sk) in stacker_sks.iter().zip(signer_sks.iter()) {
         let pox_addr = PoxAddress::from_legacy(
             AddressHashMode::SerializeP2PKH,
             tests::to_addr(&stacker_sk).bytes,
@@ -626,7 +626,7 @@ pub fn boot_to_epoch_3_reward_set(
             pox_addr.clone().as_clarity_tuple().unwrap().into();
         let signature = make_pox_4_signer_key_signature(
             &pox_addr,
-            stacker_sk,
+            &signer_sk,
             reward_cycle.into(),
             &Pox4SignatureTopic::StackStx,
             CHAIN_ID_TESTNET,
@@ -634,6 +634,8 @@ pub fn boot_to_epoch_3_reward_set(
         )
         .unwrap()
         .to_rsv();
+
+        let signer_pk = StacksPublicKey::from_private(signer_sk);
         let stacking_tx = tests::make_contract_call(
             &stacker_sk,
             0,
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index d06b72e990..1326e36aa2 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -6,7 +6,6 @@ use std::time::{Duration, Instant};
 use std::{env, thread};
 
 use clarity::boot_util::boot_code_id;
-use hashbrown::HashMap;
 use libsigner::{
     BlockResponse, RejectCode, RunningSigner, Signer, SignerEventReceiver, SignerMessage,
     BLOCK_MSG_ID, TRANSACTIONS_MSG_ID,
@@ -26,9 +25,7 @@ use stacks::util_lib::strings::StacksString;
 use stacks_common::bitvec::BitVec;
 use stacks_common::codec::read_next;
 use stacks_common::consts::SIGNER_SLOTS_PER_USER;
-use stacks_common::types::chainstate::{
-    ConsensusHash, StacksAddress, StacksBlockId, StacksPublicKey, TrieHash,
-};
+use stacks_common::types::chainstate::{ConsensusHash, StacksBlockId, StacksPublicKey, TrieHash};
 use stacks_common::types::StacksEpochId;
 use stacks_common::util::hash::{MerkleTree, Sha512Trunc256Sum};
 use stacks_common::util::secp256k1::MessageSignature;
@@ -46,7 +43,7 @@ use crate::neon::Counters;
 use crate::run_loop::boot_nakamoto;
 use crate::tests::bitcoin_regtest::BitcoinCoreController;
 use crate::tests::nakamoto_integrations::{
-    boot_to_epoch_3_reward_set, naka_neon_integration_conf, next_block_and,
+    boot_to_epoch_3, boot_to_epoch_3_reward_set, naka_neon_integration_conf, next_block_and,
     next_block_and_mine_commit, POX_4_DEFAULT_STACKER_BALANCE,
 };
 use crate::tests::neon_integrations::{
@@ -73,11 +70,11 @@ struct SignerTest {
     // The stx and bitcoin nodes and their run loops
     pub running_nodes: RunningNodes,
     // The channels for sending commands to the signers
-    pub signer_cmd_senders: HashMap<u32, Sender<RunLoopCommand>>,
+    pub signer_cmd_senders: Vec<Sender<RunLoopCommand>>,
     // The channels for receiving results from the signers
     pub result_receivers: Vec<Receiver<Vec<OperationResult>>>,
     // The running signer and its threads
-    pub running_signers: HashMap<u32, RunningSigner<SignerEventReceiver, Vec<OperationResult>>>,
+    pub running_signers: Vec<RunningSigner<SignerEventReceiver, Vec<OperationResult>>>,
     // the private keys of the signers
     pub signer_stacks_private_keys: Vec<StacksPrivateKey>,
     // link to the stacks node
@@ -85,15 +82,16 @@ struct SignerTest {
 }
 
 impl SignerTest {
-    fn new(num_signers: u32, _num_keys: u32) -> Self {
+    fn new(num_signers: usize, disable_signing_key: bool) -> Self {
         // Generate Signer Data
         let signer_stacks_private_keys = (0..num_signers)
             .map(|_| StacksPrivateKey::new())
             .collect::<Vec<StacksPrivateKey>>();
 
         let (mut naka_conf, _miner_account) = naka_neon_integration_conf(None);
-        naka_conf.miner.self_signing_key = None;
-
+        if disable_signing_key {
+            naka_conf.miner.self_signing_key = None;
+        }
         // Setup the signer and coordinator configurations
         let signer_configs = build_signer_config_tomls(
             &signer_stacks_private_keys,
@@ -102,29 +100,24 @@ impl SignerTest {
             &Network::Testnet,
         );
 
-        let mut running_signers = HashMap::new();
-        let mut signer_cmd_senders = HashMap::new();
+        let mut running_signers = Vec::new();
+        let mut signer_cmd_senders = Vec::new();
         let mut result_receivers = Vec::new();
-        // Spawn all signers before the node to ensure their listening ports are open for the node event observer to bind to
-        for i in (0..num_signers).rev() {
+        for i in 0..num_signers {
             let (cmd_send, cmd_recv) = channel();
             let (res_send, res_recv) = channel();
             info!("spawn signer");
-            running_signers.insert(
-                i,
-                spawn_signer(&signer_configs[i as usize], cmd_recv, res_send),
-            );
-            signer_cmd_senders.insert(i, cmd_send);
+            running_signers.push(spawn_signer(
+                &signer_configs[i as usize],
+                cmd_recv,
+                res_send,
+            ));
+            signer_cmd_senders.push(cmd_send);
             result_receivers.push(res_recv);
         }
 
         // Setup the nodes and deploy the contract to it
-        let node = setup_stx_btc_node(
-            naka_conf,
-            num_signers,
-            &signer_stacks_private_keys,
-            &signer_configs,
-        );
+        let node = setup_stx_btc_node(naka_conf, &signer_stacks_private_keys, &signer_configs);
         let config = SignerConfig::load_from_str(&signer_configs[0]).unwrap();
         let stacks_client = StacksClient::from(&config);
 
@@ -138,6 +131,74 @@ impl SignerTest {
         }
     }
 
+    fn run_until_epoch_3_boundary(&mut self) {
+        let epochs = self.running_nodes.conf.burnchain.epochs.clone().unwrap();
+        let epoch_3 =
+            &epochs[StacksEpoch::find_epoch_by_id(&epochs, StacksEpochId::Epoch30).unwrap()];
+
+        let epoch_30_boundary = epoch_3.start_height - 1;
+        // advance to epoch 3.0 and trigger a sign round (cannot vote on blocks in pre epoch 3.0)
+        run_until_burnchain_height(
+            &mut self.running_nodes.btc_regtest_controller,
+            &self.running_nodes.blocks_processed,
+            epoch_30_boundary,
+            &self.running_nodes.conf,
+        );
+        info!("Avanced to Nakamoto! Ready to Sign Blocks!");
+    }
+
+    fn get_current_reward_cycle(&self) -> u64 {
+        let block_height = self
+            .running_nodes
+            .btc_regtest_controller
+            .get_headers_height();
+        self.running_nodes
+            .btc_regtest_controller
+            .get_burnchain()
+            .block_height_to_reward_cycle(block_height)
+            .unwrap()
+    }
+
+    // Will panic if called on a reward cycle that has not had its signers calculated yet
+    fn get_coordinator_sender(&self, reward_cycle: u64) -> &Sender<RunLoopCommand> {
+        debug!(
+            "Getting current coordinator for reward cycle {:?}",
+            reward_cycle
+        );
+        // Calculate which signer is the coordinator
+        let private_key = StacksPrivateKey::new();
+        let node_host = self
+            .running_nodes
+            .conf
+            .node
+            .rpc_bind
+            .to_socket_addrs()
+            .unwrap()
+            .next()
+            .unwrap();
+        // Use the stacks client to calculate the current registered signers and their coordinator
+        let stacks_client = StacksClient::new(private_key, node_host, false);
+        let (coordinator_id, coordinator_pk) = stacks_client.calculate_coordinator(
+            &stacks_client
+                .get_registered_signers_info(reward_cycle)
+                .unwrap()
+                .unwrap()
+                .public_keys,
+        );
+        let coordinator_index = self
+            .signer_stacks_private_keys
+            .iter()
+            .position(|sk| {
+                let pubkey = StacksPublicKey::from_private(sk);
+                let coordinator_pk_bytes = coordinator_pk.to_bytes();
+                let pubkey_bytes = pubkey.to_bytes_compressed();
+                coordinator_pk_bytes.as_slice() == pubkey_bytes.as_slice()
+            })
+            .unwrap();
+        debug!("Coordinator is {coordinator_id:?} ({coordinator_pk:?}). Command sender found at index: {coordinator_index:?}");
+        self.signer_cmd_senders.get(coordinator_index).unwrap()
+    }
+
     fn shutdown(self) {
         self.running_nodes
             .coord_channel
@@ -151,7 +212,7 @@ impl SignerTest {
 
         self.running_nodes.run_loop_thread.join().unwrap();
         // Stop the signers
-        for (_id, signer) in self.running_signers {
+        for signer in self.running_signers {
             assert!(signer.stop().is_none());
         }
     }
@@ -178,9 +239,8 @@ fn spawn_signer(
 
 fn setup_stx_btc_node(
     mut naka_conf: NeonConfig,
-    num_signers: u32,
     signer_stacks_private_keys: &[StacksPrivateKey],
-    signer_config_tomls: &Vec<String>,
+    signer_config_tomls: &[String],
 ) -> RunningNodes {
     // Spawn the endpoints for observing signers
     for toml in signer_config_tomls {
@@ -204,9 +264,9 @@ fn setup_stx_btc_node(
     let mut initial_balances = Vec::new();
 
     // TODO: separate keys for stacking and signing (because they'll be different in prod)
-    for i in 0..num_signers {
+    for key in signer_stacks_private_keys {
         initial_balances.push(InitialBalance {
-            address: to_addr(&signer_stacks_private_keys[i as usize]).into(),
+            address: to_addr(key).into(),
             amount: POX_4_DEFAULT_STACKER_BALANCE,
         });
     }
@@ -224,7 +284,6 @@ fn setup_stx_btc_node(
             }
         }
     }
-
     info!("Make new BitcoinCoreController");
     let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone());
     btcd_controller
@@ -268,16 +327,6 @@ fn setup_stx_btc_node(
     info!("Mine third block...");
     next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
 
-    info!("Boot to epoch 2.5 to activate pox-4...");
-    boot_to_epoch_3_reward_set(
-        &naka_conf,
-        &blocks_processed,
-        signer_stacks_private_keys,
-        signer_stacks_private_keys,
-        &mut btc_regtest_controller,
-    );
-
-    info!("Pox 4 activated and Nakamoto's first reward set calculated! Ready for signers to perform DKG!");
     RunningNodes {
         btcd_controller,
         btc_regtest_controller,
@@ -339,16 +388,43 @@ fn stackerdb_dkg_sign() {
     let mut msg = block.header.signer_signature_hash().0.to_vec();
     msg.push(b'n');
 
-    let signer_test = SignerTest::new(10, 400);
+    let timeout = Duration::from_secs(200);
+    let mut signer_test = SignerTest::new(10, false);
+
+    info!("Boot to epoch 3.0 reward calculation...");
+    boot_to_epoch_3_reward_set(
+        &signer_test.running_nodes.conf,
+        &signer_test.running_nodes.blocks_processed,
+        &signer_test.signer_stacks_private_keys,
+        &signer_test.signer_stacks_private_keys,
+        &mut signer_test.running_nodes.btc_regtest_controller,
+    );
+
+    info!("Pox 4 activated and at epoch 3.0 reward set calculation (2nd block of its prepare phase)! Ready for signers to perform DKG and Sign!");
+
+    // Determine the coordinator
+    // we have just calculated the reward set for the next reward cycle hence the + 1
+    let reward_cycle = signer_test.get_current_reward_cycle().wrapping_add(1);
+    let coordinator_sender = signer_test.get_coordinator_sender(reward_cycle);
 
     info!("------------------------- Test DKG -------------------------");
-    info!("signer_runloop: spawn send commands to do dkg");
+    info!("signer_runloop: spawn send commands to do DKG");
     let dkg_now = Instant::now();
     let mut key = Point::default();
+    let dkg_command = RunLoopCommand {
+        reward_cycle,
+        command: SignerCommand::Dkg,
+    };
+    coordinator_sender
+        .send(dkg_command)
+        .expect("failed to send DKG command");
+    info!("signer_runloop: waiting for DKG results");
     for recv in signer_test.result_receivers.iter() {
         let mut aggregate_public_key = None;
         loop {
-            let results = recv.recv().expect("failed to recv dkg results");
+            let results = recv
+                .recv_timeout(timeout)
+                .expect("failed to recv dkg results");
             for result in results {
                 match result {
                     OperationResult::Sign(sig) => {
@@ -369,20 +445,27 @@ fn stackerdb_dkg_sign() {
                     }
                 }
             }
-            if aggregate_public_key.is_some() || dkg_now.elapsed() > Duration::from_secs(200) {
+            if aggregate_public_key.is_some() || dkg_now.elapsed() > timeout {
                 break;
             }
         }
-        key = aggregate_public_key.expect("Failed to get aggregate public key within 200 seconds");
+        key = aggregate_public_key.expect(&format!(
+            "Failed to get aggregate public key within {timeout:?}"
+        ));
     }
     let dkg_elapsed = dkg_now.elapsed();
 
-    // We can't sign a block
+    signer_test.run_until_epoch_3_boundary();
+
     info!("------------------------- Test Sign -------------------------");
+    // Determine the coordinator of the current node height
+    let reward_cycle = signer_test.get_current_reward_cycle();
+    let coordinator_sender = signer_test.get_coordinator_sender(reward_cycle);
+
     let sign_now = Instant::now();
     info!("signer_runloop: spawn send commands to do dkg and then sign");
     let sign_command = RunLoopCommand {
-        reward_cycle: 11,
+        reward_cycle,
         command: SignerCommand::Sign {
             block: block.clone(),
             is_taproot: false,
@@ -390,26 +473,26 @@ fn stackerdb_dkg_sign() {
         },
     };
     let sign_taproot_command = RunLoopCommand {
-        reward_cycle: 11,
+        reward_cycle,
         command: SignerCommand::Sign {
             block: block.clone(),
             is_taproot: true,
             merkle_root: None,
         },
     };
-    for cmd_sender in signer_test.signer_cmd_senders.values() {
-        cmd_sender
-            .send(sign_command.clone())
-            .expect("failed to send non taproot Sign command");
-        cmd_sender
-            .send(sign_taproot_command.clone())
-            .expect("failed to send taproot Sign command");
-    }
+    coordinator_sender
+        .send(sign_command)
+        .expect("failed to send Sign command");
+    coordinator_sender
+        .send(sign_taproot_command)
+        .expect("failed to send Sign taproot command");
     for recv in signer_test.result_receivers.iter() {
         let mut frost_signature = None;
         let mut schnorr_proof = None;
         loop {
-            let results = recv.recv().expect("failed to recv signature results");
+            let results = recv
+                .recv_timeout(timeout)
+                .expect("failed to recv signature results");
             for result in results {
                 match result {
                     OperationResult::Sign(sig) => {
@@ -432,19 +515,20 @@ fn stackerdb_dkg_sign() {
                 }
             }
             if (frost_signature.is_some() && schnorr_proof.is_some())
-                || sign_now.elapsed() > Duration::from_secs(200)
+                || sign_now.elapsed() > timeout
             {
                 break;
             }
         }
         let frost_signature =
-            frost_signature.expect("Failed to get frost signature within 100 seconds");
+            frost_signature.expect(&format!("Failed to get frost signature within {timeout:?}"));
         assert!(
             frost_signature.verify(&key, msg.as_slice()),
             "Signature verification failed"
         );
-        let schnorr_proof =
-            schnorr_proof.expect("Failed to get schnorr proof signature within 100 seconds");
+        let schnorr_proof = schnorr_proof.expect(&format!(
+            "Failed to get schnorr proof signature within {timeout:?}"
+        ));
         let tweaked_key = wsts::compute::tweaked_public_key(&key, None);
         assert!(
             schnorr_proof.verify(&tweaked_key.x(), &msg.as_slice()),
@@ -464,7 +548,7 @@ fn stackerdb_dkg_sign() {
 ///
 /// Test Setup:
 /// The test spins up five stacks signers, one miner Nakamoto node, and a corresponding bitcoind.
-/// The stacks node is advanced to epoch 3.0, triggering signers to perform DKG round.
+/// The stacks node is advanced to epoch 3.0. DKG foricbly triggered to set the key correctly
 ///
 /// Test Execution:
 /// The node attempts to mine a Nakamoto tenure, sending a block to the observing signers via the
@@ -487,16 +571,36 @@ fn stackerdb_block_proposal() {
         .init();
 
     info!("------------------------- Test Setup -------------------------");
-    let mut signer_test = SignerTest::new(5, 5);
+    let mut signer_test = SignerTest::new(5, true);
 
     let (_vrfs_submitted, commits_submitted) = (
         signer_test.running_nodes.vrfs_submitted.clone(),
         signer_test.running_nodes.commits_submitted.clone(),
     );
+    boot_to_epoch_3(
+        &signer_test.running_nodes.conf,
+        &signer_test.running_nodes.blocks_processed,
+        &signer_test.signer_stacks_private_keys,
+        &signer_test.signer_stacks_private_keys,
+        &mut signer_test.running_nodes.btc_regtest_controller,
+    );
+
+    // Determine the coordinator
+    let reward_cycle = signer_test.get_current_reward_cycle();
+    let coordinator_sender = signer_test.get_coordinator_sender(reward_cycle);
+
+    // Forcibly run DKG to overwrite the self signing aggregate key in the contract
     info!("------------------------- Wait for DKG -------------------------");
     info!("signer_runloop: spawn send commands to do dkg");
     let dkg_now = Instant::now();
     let mut key = Point::default();
+    let dkg_command = RunLoopCommand {
+        reward_cycle,
+        command: SignerCommand::Dkg,
+    };
+    coordinator_sender
+        .send(dkg_command)
+        .expect("failed to send DKG command");
     for recv in signer_test.result_receivers.iter() {
         let mut aggregate_public_key = None;
         loop {
@@ -531,42 +635,16 @@ fn stackerdb_block_proposal() {
     }
     let dkg_elapsed = dkg_now.elapsed();
 
-    let epochs = signer_test
-        .running_nodes
-        .conf
-        .burnchain
-        .epochs
-        .clone()
-        .unwrap();
-    let epoch_3 = &epochs[StacksEpoch::find_epoch_by_id(&epochs, StacksEpochId::Epoch30).unwrap()];
-
-    let epoch_30_boundary = epoch_3.start_height - 1;
-    info!(
-        "Advancing to Epoch 3.0 Boundary";
-        "Epoch 3.0 Boundary" => epoch_30_boundary,
-    );
-
-    // Advance to epoch 3.0
-    run_until_burnchain_height(
-        &mut signer_test.running_nodes.btc_regtest_controller,
-        &signer_test.running_nodes.blocks_processed,
-        epoch_30_boundary,
-        &signer_test.running_nodes.conf,
-    );
-
-    info!("Avanced to Nakamoto! Ready to Sign Blocks!");
-
     info!("------------------------- Test Block Processed -------------------------");
     let sign_now = Instant::now();
 
     // Mine 1 nakamoto tenure
-    next_block_and_mine_commit(
+    let _ = next_block_and_mine_commit(
         &mut signer_test.running_nodes.btc_regtest_controller,
         60,
         &signer_test.running_nodes.coord_channel,
         &commits_submitted,
-    )
-    .unwrap();
+    );
 
     let recv = signer_test
         .result_receivers
@@ -694,7 +772,7 @@ fn stackerdb_block_proposal_missing_transactions() {
         .init();
 
     info!("------------------------- Test Setup -------------------------");
-    let mut signer_test = SignerTest::new(5, 5);
+    let mut signer_test = SignerTest::new(5, false);
 
     let host = signer_test
         .running_nodes
@@ -733,7 +811,7 @@ fn stackerdb_block_proposal_missing_transactions() {
         .signer_stacks_private_keys
         .iter()
         .find(|pk| {
-            let addr = StacksAddress::p2pkh(false, &StacksPublicKey::from_private(pk));
+            let addr = to_addr(pk);
             addr == signer_address_1
         })
         .cloned()
@@ -742,10 +820,7 @@ fn stackerdb_block_proposal_missing_transactions() {
     let mut stackerdb_1 = StackerDB::new(host, signer_private_key_1, false, 1, 0);
 
     debug!("Signer address is {}", &signer_address_1);
-    assert_eq!(
-        signer_address_1,
-        StacksAddress::p2pkh(false, &StacksPublicKey::from_private(&signer_private_key_1))
-    );
+    assert_eq!(signer_address_1, to_addr(&signer_private_key_1),);
 
     // Create a valid transaction signed by the signer private key coresponding to the slot into which it is being inserted (signer id 0)
     let mut valid_tx = StacksTransaction {
@@ -770,10 +845,7 @@ fn stackerdb_block_proposal_missing_transactions() {
     let invalid_signer_private_key = StacksPrivateKey::new();
     debug!(
         "Invalid address is {}",
-        &StacksAddress::p2pkh(
-            false,
-            &StacksPublicKey::from_private(&invalid_signer_private_key)
-        )
+        to_addr(&invalid_signer_private_key)
     );
     let mut invalid_tx = StacksTransaction {
         version: TransactionVersion::Testnet,
@@ -792,18 +864,32 @@ fn stackerdb_block_proposal_missing_transactions() {
     };
     invalid_tx.set_origin_nonce(0);
 
+    info!("Boot to epoch 3.0 reward calculation...");
+    boot_to_epoch_3_reward_set(
+        &signer_test.running_nodes.conf,
+        &signer_test.running_nodes.blocks_processed,
+        &signer_test.signer_stacks_private_keys,
+        &signer_test.signer_stacks_private_keys,
+        &mut signer_test.running_nodes.btc_regtest_controller,
+    );
+
+    info!("Pox 4 activated and at epoch 3.0 reward set calculation (2nd block of its prepare phase)! Ready for signers to perform DKG and Sign!");
+
+    // Determine the coordinator
+    // we have just calculated the reward set for the next reward cycle hence the + 1
+    let reward_cycle = signer_test.get_current_reward_cycle().wrapping_add(1);
+    let coordinator_sender = signer_test.get_coordinator_sender(reward_cycle);
+
     // First run DKG in order to sign the block that arrives from the miners following a nakamoto block production
     // TODO: remove this forcibly running DKG once we have casting of the vote automagically happening during epoch 2.5
     info!("signer_runloop: spawn send commands to do dkg");
     let dkg_command = RunLoopCommand {
-        reward_cycle: 11,
+        reward_cycle,
         command: SignerCommand::Dkg,
     };
-    for cmd_sender in signer_test.signer_cmd_senders.values() {
-        cmd_sender
-            .send(dkg_command.clone())
-            .expect("failed to send Dkg command");
-    }
+    coordinator_sender
+        .send(dkg_command)
+        .expect("failed to send DKG command");
     let recv = signer_test
         .result_receivers
         .last()

From 21c6fe0bf6ee115a143b347f395bad6e28206ad8 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Tue, 13 Feb 2024 09:37:14 -0500
Subject: [PATCH 0888/1166] Temp fix to prevent multipel coordinators squashing
 each other

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/stacks_client.rs |  2 +
 stacks-signer/src/signer.rs               | 77 +++++++++++++++++++----
 2 files changed, 66 insertions(+), 13 deletions(-)

diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index 6a1a83777c..72a65ea8b6 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -115,6 +115,8 @@ impl StacksClient {
 
     /// Calculate the coordinator address by comparing the provided public keys against the stacks tip consensus hash
     pub fn calculate_coordinator(&self, public_keys: &PublicKeys) -> (u32, ecdsa::PublicKey) {
+        // TODO: return the entire list. Might be at the same block height for a long time and need to move to the second item in the list
+        // Add logic throughout signer to track the current coordinator list and offset in the list
         let stacks_tip_consensus_hash =
             match retry_with_exponential_backoff(|| {
                 self.get_stacks_tip_consensus_hash()
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index 43f701890a..157d461b06 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -15,6 +15,7 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 use std::collections::VecDeque;
 use std::sync::mpsc::Sender;
+use std::time::Instant;
 
 use blockstack_lib::chainstate::nakamoto::NakamotoBlock;
 use blockstack_lib::chainstate::stacks::boot::SIGNERS_VOTING_NAME;
@@ -47,6 +48,8 @@ use crate::client::{
 };
 use crate::config::{GlobalConfig, RewardCycleConfig};
 
+/// TODO: test this value and adjust as necessary. Maybe make configurable?
+pub const COORDINATOR_OPERATION_TIMEOUT: u64 = 200;
 /// Additional Info about a proposed block
 pub struct BlockInfo {
     /// The block we are considering
@@ -101,13 +104,22 @@ pub enum Command {
     },
 }
 
+/// The coordinator info for a specific in progress operation
+#[derive(PartialEq, Clone, Debug)]
+pub struct CoordinatorInfo {
+    /// The coordinator id
+    pub coordinator_id: u32,
+    /// The last message received time
+    pub last_message_time: Instant,
+}
+
 /// The Signer state
 #[derive(PartialEq, Debug, Clone)]
 pub enum State {
     /// The signer is idle, waiting for messages and commands
     Idle,
     /// The signer is executing a DKG or Sign round
-    OperationInProgress,
+    OperationInProgress(CoordinatorInfo),
     /// The Signer has exceeded its tenure
     TenureExceeded,
 }
@@ -230,7 +242,10 @@ impl Signer {
                     Ok(msg) => {
                         let ack = self.stackerdb.send_message_with_retry(msg.into());
                         debug!("Signer #{}: ACK: {ack:?}", self.signer_id);
-                        self.state = State::OperationInProgress;
+                        self.state = State::OperationInProgress(CoordinatorInfo {
+                            coordinator_id: self.signer_id,
+                            last_message_time: Instant::now(),
+                        });
                     }
                     Err(e) => {
                         error!("Signer #{}: Failed to start DKG: {e:?}", self.signer_id);
@@ -260,7 +275,10 @@ impl Signer {
                     Ok(msg) => {
                         let ack = self.stackerdb.send_message_with_retry(msg.into());
                         debug!("Signer #{}: ACK: {ack:?}", self.signer_id);
-                        self.state = State::OperationInProgress;
+                        self.state = State::OperationInProgress(CoordinatorInfo {
+                            coordinator_id: self.signer_id,
+                            last_message_time: Instant::now(),
+                        });
                         block_info.signed_over = true;
                     }
                     Err(e) => {
@@ -276,7 +294,7 @@ impl Signer {
 
     /// Attempt to process the next command in the queue, and update state accordingly
     pub fn process_next_command(&mut self, stacks_client: &StacksClient) {
-        match self.state {
+        match &self.state {
             State::Idle => {
                 let (coordinator_id, coordinator_pk) =
                     stacks_client.calculate_coordinator(&self.signing_round.public_keys);
@@ -297,9 +315,22 @@ impl Signer {
                     );
                 }
             }
-            State::OperationInProgress => {
+            State::OperationInProgress(coordinator_info) => {
                 // We cannot execute the next command until the current one is finished...
                 // Do nothing...
+                if coordinator_info.last_message_time.elapsed().as_secs()
+                    > COORDINATOR_OPERATION_TIMEOUT
+                {
+                    debug!(
+                        "Signer #{}: Operation from coordinator {} timed out.",
+                        self.signer_id, coordinator_info.coordinator_id
+                    );
+                    // We have not received a message in a while. We should consider the operation finished and use a new coordinator id.
+                    self.coordinator.state = CoordinatorState::Idle;
+                    self.signing_round.state = wsts::state_machine::signer::State::Idle;
+                    self.state = State::Idle;
+                    self.process_next_command(stacks_client);
+                }
                 debug!(
                     "Signer #{}: Waiting for operation to finish",
                     self.signer_id,
@@ -415,23 +446,45 @@ impl Signer {
         res: Sender<Vec<OperationResult>>,
         messages: &[SignerMessage],
     ) {
-        let (coordinator_id, coordinator_public_key) =
+        let (mut coordinator_id, mut coordinator_pubkey) =
             stacks_client.calculate_coordinator(&self.signing_round.public_keys);
-        debug!(
-            "Signer #{}: coordinator is signer #{} public key {}",
-            self.signer_id, coordinator_id, &coordinator_public_key
-        );
+        // TODO return the list of coordinators in case we are stuck at a block for quite some time.
+        if let State::OperationInProgress(info) = &self.state {
+            if let Some(pubkey) = self
+                .signing_round
+                .public_keys
+                .signers
+                .get(&info.coordinator_id)
+            {
+                coordinator_pubkey = pubkey.clone();
+                coordinator_id = info.coordinator_id;
+                debug!(
+                        "Signer #{:?}: Operation in progress led by coordinator ID {coordinator_id:?} ({coordinator_pubkey:?})",
+                        self.signer_id
+                    );
+            }
+        }
         let packets: Vec<Packet> = messages
             .iter()
             .filter_map(|msg| match msg {
                 // TODO: should we store the received transactions on the side and use them rather than directly querying the stacker db slots?
                 SignerMessage::BlockResponse(_) | SignerMessage::Transactions(_) => None,
                 SignerMessage::Packet(packet) => {
-                    self.verify_packet(stacks_client, packet.clone(), &coordinator_public_key)
+                    self.verify_packet(stacks_client, packet.clone(), &coordinator_pubkey)
                 }
             })
             .collect();
         self.handle_packets(stacks_client, res, &packets);
+        if self.state == State::Idle
+            && self.coordinator.state != CoordinatorState::Idle
+            && !packets.is_empty()
+        {
+            // We are in the middle of a DKG or signing round. Update our state to reflect this.
+            self.state = State::OperationInProgress(CoordinatorInfo {
+                coordinator_id,
+                last_message_time: Instant::now(),
+            });
+        }
     }
 
     /// Handle proposed blocks submitted by the miners to stackerdb
@@ -482,8 +535,6 @@ impl Signer {
             self.state = State::Idle;
             self.process_operation_results(stacks_client, &operation_results);
             self.send_operation_results(res, operation_results);
-        } else if self.coordinator.state != CoordinatorState::Idle {
-            self.state = State::OperationInProgress;
         }
         self.send_outbound_messages(signer_outbound_messages);
         self.send_outbound_messages(coordinator_outbound_messages);

From a57e4318679e11d8764deb72aed17273af1dcb20 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Tue, 13 Feb 2024 13:38:21 -0500
Subject: [PATCH 0889/1166] Cleanup reward cycle config into signer config

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/mod.rs           |  76 +++--
 stacks-signer/src/client/stackerdb.rs     |  72 ++---
 stacks-signer/src/client/stacks_client.rs |  93 +++---
 stacks-signer/src/config.rs               |  24 +-
 stacks-signer/src/runloop.rs              |  34 ++-
 stacks-signer/src/signer.rs               | 339 ++++++++++++----------
 testnet/stacks-node/src/tests/signer.rs   |  50 ++--
 7 files changed, 357 insertions(+), 331 deletions(-)

diff --git a/stacks-signer/src/client/mod.rs b/stacks-signer/src/client/mod.rs
index 33066eaee9..3addb04d29 100644
--- a/stacks-signer/src/client/mod.rs
+++ b/stacks-signer/src/client/mod.rs
@@ -156,7 +156,7 @@ pub(crate) mod tests {
     use wsts::state_machine::PublicKeys;
 
     use super::*;
-    use crate::config::{GlobalConfig, RegisteredSignersInfo, RewardCycleConfig};
+    use crate::config::{GlobalConfig, RegisteredSignersInfo, SignerConfig};
 
     pub struct MockServerClient {
         pub server: TcpListener,
@@ -397,13 +397,13 @@ pub(crate) mod tests {
         format!("HTTP/1.1 200 OK\n\n{{\"okay\":true,\"result\":\"{hex}\"}}")
     }
 
-    /// Generate a random reward cycle config for signer with id 0 and slot id 0
-    /// Optionally include a signer pubilc key to use for the signer
-    pub fn generate_reward_cycle_config(
+    /// Generate a signer config with the given number of signers and keys where the first signer is
+    /// obtained from the provided global config
+    pub fn generate_signer_config(
+        config: &GlobalConfig,
         num_signers: u32,
         num_keys: u32,
-        signer_key: Option<ecdsa::PublicKey>,
-    ) -> (RewardCycleConfig, Vec<StacksAddress>) {
+    ) -> (SignerConfig, Vec<StacksAddress>) {
         assert!(
             num_signers > 0,
             "Cannot generate 0 signers...Specify at least 1 signer."
@@ -427,6 +427,11 @@ pub(crate) mod tests {
         let mut start_key_id = 1u32;
         let mut end_key_id = start_key_id;
         let mut signer_public_keys = HashMap::new();
+        let mut coordinator_ids = vec![];
+        let stacks_address = config.stacks_address;
+        let ecdsa_private_key = config.ecdsa_private_key;
+        let ecdsa_public_key =
+            ecdsa::PublicKey::new(&ecdsa_private_key).expect("Failed to create ecdsa public key");
         // Key ids start from 1 hence the wrapping adds everywhere
         for signer_id in 0..num_signers {
             end_key_id = if signer_id.wrapping_add(1) == num_signers {
@@ -435,32 +440,27 @@ pub(crate) mod tests {
                 end_key_id.wrapping_add(num_keys)
             };
             if signer_id == 0 {
-                if let Some(signer_key) = signer_key {
-                    let address = StacksAddress::p2pkh(
-                        false,
-                        &StacksPublicKey::from_slice(signer_key.to_bytes().as_slice())
-                            .expect("Failed to create stacks public key"),
-                    );
-                    addresses.push(address);
-                    public_keys.signers.insert(signer_id, signer_key);
-                    let signer_public_key =
-                        Point::try_from(&Compressed::from(signer_key.to_bytes())).unwrap();
-                    signer_public_keys.insert(signer_id, signer_public_key);
-                    public_keys.signers.insert(signer_id, signer_key.clone());
-                    for k in start_key_id..end_key_id {
-                        public_keys.key_ids.insert(k, signer_key);
-                        coordinator_key_ids
-                            .entry(signer_id)
-                            .or_insert(HashSet::new())
-                            .insert(k);
-                        signer_key_ids
-                            .entry(signer_id)
-                            .or_insert(Vec::new())
-                            .push(k);
-                    }
-                    start_key_id = end_key_id;
-                    continue;
+                addresses.push(stacks_address);
+                public_keys.signers.insert(signer_id, ecdsa_public_key);
+                let signer_public_key =
+                    Point::try_from(&Compressed::from(ecdsa_public_key.to_bytes())).unwrap();
+                signer_public_keys.insert(signer_id, signer_public_key);
+                public_keys
+                    .signers
+                    .insert(signer_id, ecdsa_public_key.clone());
+                for k in start_key_id..end_key_id {
+                    public_keys.key_ids.insert(k, ecdsa_public_key);
+                    coordinator_key_ids
+                        .entry(signer_id)
+                        .or_insert(HashSet::new())
+                        .insert(k);
+                    signer_key_ids
+                        .entry(signer_id)
+                        .or_insert(Vec::new())
+                        .push(k);
                 }
+                start_key_id = end_key_id;
+                continue;
             }
             let private_key = Scalar::random(rng);
             let public_key = ecdsa::PublicKey::new(&private_key).unwrap();
@@ -487,9 +487,10 @@ pub(crate) mod tests {
             signer_address_ids.insert(address.clone(), signer_id);
             addresses.push(address);
             start_key_id = end_key_id;
+            coordinator_ids.push(signer_id);
         }
         (
-            RewardCycleConfig {
+            SignerConfig {
                 reward_cycle,
                 signer_id: 0,
                 signer_slot_id: 0,
@@ -501,6 +502,17 @@ pub(crate) mod tests {
                     signer_address_ids,
                     signer_public_keys,
                 },
+                coordinator_ids,
+                ecdsa_private_key: config.ecdsa_private_key,
+                stacks_private_key: config.stacks_private_key,
+                node_host: config.node_host,
+                mainnet: config.network.is_mainnet(),
+                dkg_end_timeout: config.dkg_end_timeout,
+                dkg_private_timeout: config.dkg_private_timeout,
+                dkg_public_timeout: config.dkg_public_timeout,
+                nonce_timeout: config.nonce_timeout,
+                sign_timeout: config.sign_timeout,
+                tx_fee_ms: config.tx_fee_ms,
             },
             addresses,
         )
diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index 81a0306a0f..c7fa8494cc 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -32,7 +32,7 @@ use stacks_common::{debug, warn};
 
 use super::ClientError;
 use crate::client::retry_with_exponential_backoff;
-use crate::config::{GlobalConfig, RewardCycleConfig};
+use crate::config::SignerConfig;
 
 /// The StackerDB client for communicating with the .signers contract
 pub struct StackerDB {
@@ -49,6 +49,17 @@ pub struct StackerDB {
     reward_cycle: u64,
 }
 
+impl From<&SignerConfig> for StackerDB {
+    fn from(config: &SignerConfig) -> Self {
+        StackerDB::new(
+            config.node_host,
+            config.stacks_private_key.clone(),
+            config.mainnet,
+            config.reward_cycle,
+            config.signer_slot_id,
+        )
+    }
+}
 impl StackerDB {
     /// Create a new StackerDB client
     pub fn new(
@@ -83,37 +94,6 @@ impl StackerDB {
         }
     }
 
-    /// Create a new StackerDB client from the provided configuration info
-    pub fn from_configs(config: &GlobalConfig, reward_cycle_config: &RewardCycleConfig) -> Self {
-        let mut signers_message_stackerdb_sessions = HashMap::new();
-        let stackerdb_issuer = boot_code_addr(config.network.is_mainnet());
-        for msg_id in 0..SIGNER_SLOTS_PER_USER {
-            signers_message_stackerdb_sessions.insert(
-                msg_id,
-                StackerDBSession::new(
-                    config.node_host,
-                    QualifiedContractIdentifier::new(
-                        stackerdb_issuer.into(),
-                        ContractName::from(
-                            NakamotoSigners::make_signers_db_name(
-                                reward_cycle_config.reward_cycle,
-                                msg_id,
-                            )
-                            .as_str(),
-                        ),
-                    ),
-                ),
-            );
-        }
-        Self {
-            signers_message_stackerdb_sessions,
-            stacks_private_key: config.stacks_private_key,
-            slot_versions: HashMap::new(),
-            signer_slot_id: reward_cycle_config.signer_slot_id,
-            reward_cycle: reward_cycle_config.reward_cycle,
-        }
-    }
-
     /// Sends messages to the .signers stacker-db with an exponential backoff retry
     pub fn send_message_with_retry(
         &mut self,
@@ -258,26 +238,17 @@ mod tests {
     };
     use blockstack_lib::util_lib::strings::StacksString;
     use serial_test::serial;
-    use wsts::curve::ecdsa;
 
     use super::*;
-    use crate::client::tests::{
-        generate_reward_cycle_config, mock_server_from_config, write_response,
-    };
+    use crate::client::tests::{generate_signer_config, mock_server_from_config, write_response};
+    use crate::config::GlobalConfig;
 
     #[test]
     #[serial]
     fn get_signer_transactions_with_retry_should_succeed() {
         let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
-        let (reward_cycle_config, _ordered_addresses) = generate_reward_cycle_config(
-            5,
-            20,
-            Some(
-                ecdsa::PublicKey::new(&config.ecdsa_private_key)
-                    .expect("Failed to create public key."),
-            ),
-        );
-        let mut stackerdb = StackerDB::from_configs(&config, &reward_cycle_config);
+        let (signer_config, _ordered_addresses) = generate_signer_config(&config, 5, 20);
+        let mut stackerdb = StackerDB::from(&signer_config);
         let sk = StacksPrivateKey::new();
         let tx = StacksTransaction {
             version: TransactionVersion::Testnet,
@@ -320,15 +291,8 @@ mod tests {
     #[serial]
     fn send_signer_message_with_retry_should_succeed() {
         let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
-        let (reward_cycle_info, _ordered_addresses) = generate_reward_cycle_config(
-            5,
-            20,
-            Some(
-                ecdsa::PublicKey::new(&config.ecdsa_private_key)
-                    .expect("Failed to create public key."),
-            ),
-        );
-        let mut stackerdb = StackerDB::from_configs(&config, &reward_cycle_info);
+        let (signer_config, _ordered_addresses) = generate_signer_config(&config, 5, 20);
+        let mut stackerdb = StackerDB::from(&signer_config);
 
         let sk = StacksPrivateKey::new();
         let tx = StacksTransaction {
diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index 72a65ea8b6..e5fee0f3cd 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -114,25 +114,22 @@ impl StacksClient {
     }
 
     /// Calculate the coordinator address by comparing the provided public keys against the stacks tip consensus hash
-    pub fn calculate_coordinator(&self, public_keys: &PublicKeys) -> (u32, ecdsa::PublicKey) {
+    pub fn calculate_coordinator_ids(&self, public_keys: &PublicKeys) -> Vec<u32> {
         // TODO: return the entire list. Might be at the same block height for a long time and need to move to the second item in the list
         // Add logic throughout signer to track the current coordinator list and offset in the list
-        let stacks_tip_consensus_hash =
-            match retry_with_exponential_backoff(|| {
-                self.get_stacks_tip_consensus_hash()
-                    .map_err(backoff::Error::transient)
-            }) {
-                Ok(hash) => hash,
-                Err(e) => {
-                    debug!("Failed to get stacks tip consensus hash: {e:?}");
-                    return (
-                        0,
-                        public_keys.signers.get(&0).cloned().expect(
-                            "FATAL: No public keys found. Signer was not properly registered",
-                        ),
-                    );
-                }
-            };
+        let stacks_tip_consensus_hash = match retry_with_exponential_backoff(|| {
+            self.get_stacks_tip_consensus_hash()
+                .map_err(backoff::Error::transient)
+        }) {
+            Ok(hash) => hash,
+            Err(e) => {
+                debug!("Failed to get stacks tip consensus hash: {e:?}");
+                let mut default_coordinator_list: Vec<_> =
+                    public_keys.signers.keys().cloned().collect();
+                default_coordinator_list.sort();
+                return default_coordinator_list;
+            }
+        };
         debug!(
             "Using stacks_tip_consensus_hash {stacks_tip_consensus_hash:?} for selecting coordinator"
         );
@@ -148,19 +145,14 @@ impl StacksClient {
                 buffer.extend_from_slice(&pk_bytes[..]);
                 buffer.extend_from_slice(stacks_tip_consensus_hash.as_bytes());
                 let digest = Sha256Sum::from_data(&buffer).as_bytes().to_vec();
-                (digest, id)
+                (id, digest)
             })
             .collect::<Vec<_>>();
 
         // Sort the selection IDs based on the hash
-        selection_ids.sort_by_key(|(hash, _)| hash.clone());
-
-        // Get the first ID from the sorted list and retrieve its public key,
-        // or default to the first signer if none are found
-        selection_ids
-            .first()
-            .and_then(|(_, id)| public_keys.signers.get(id).map(|pk| (*id, *pk)))
-            .expect("FATAL: No public keys found. Signer was not properly registered")
+        selection_ids.sort_by_key(|(_, hash)| hash.clone());
+        // Return only the ids
+        selection_ids.iter().map(|(id, _)| *id).collect()
     }
 
     /// Retrieve the signer slots stored within the stackerdb contract
@@ -802,7 +794,7 @@ mod tests {
     use crate::client::tests::{
         build_account_nonce_response, build_get_aggregate_public_key_response,
         build_get_last_round_response, build_get_peer_info_response, build_get_pox_data_response,
-        build_read_only_response, generate_random_consensus_hash, generate_reward_cycle_config,
+        build_read_only_response, generate_random_consensus_hash, generate_signer_config,
         write_response, MockServerClient,
     };
 
@@ -1426,8 +1418,9 @@ mod tests {
 
     #[test]
     fn calculate_coordinator_different_consensus_hashes_produces_unique_results() {
+        let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
         let number_of_tests = 5;
-        let generated_public_keys = generate_reward_cycle_config(10, 4000, None)
+        let generated_public_keys = generate_signer_config(&config, 10, 4000)
             .0
             .registered_signers
             .public_keys;
@@ -1437,30 +1430,25 @@ mod tests {
             let mock = MockServerClient::new();
             let response = build_get_peer_info_response(None, None).0;
             let generated_public_keys = generated_public_keys.clone();
-            let h = spawn(move || mock.client.calculate_coordinator(&generated_public_keys));
+            let h = spawn(move || {
+                mock.client
+                    .calculate_coordinator_ids(&generated_public_keys)
+            });
             write_response(mock.server, response.as_bytes());
             let result = h.join().unwrap();
             results.push(result);
         }
 
         // Check that not all coordinator IDs are the same
-        let all_ids_same = results.iter().all(|&(id, _)| id == results[0].0);
+        let all_ids_same = results.iter().all(|ids| ids == &results[0]);
         assert!(!all_ids_same, "Not all coordinator IDs should be the same");
-
-        // Check that not all coordinator public keys are the same
-        let all_keys_same = results
-            .iter()
-            .all(|&(_, key)| key.key.data == results[0].1.key.data);
-        assert!(
-            !all_keys_same,
-            "Not all coordinator public keys should be the same"
-        );
     }
 
     fn generate_calculate_coordinator_test_results(
         random_consensus: bool,
         count: usize,
-    ) -> Vec<(u32, ecdsa::PublicKey)> {
+    ) -> Vec<Vec<u32>> {
+        let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
         let mut results = Vec::new();
         let same_hash = generate_random_consensus_hash();
         let hash = if random_consensus {
@@ -1468,7 +1456,7 @@ mod tests {
         } else {
             Some(same_hash)
         };
-        let generated_public_keys = generate_reward_cycle_config(10, 4000, None)
+        let generated_public_keys = generate_signer_config(&config, 10, 4000)
             .0
             .registered_signers
             .public_keys;
@@ -1476,7 +1464,10 @@ mod tests {
             let mock = MockServerClient::new();
             let generated_public_keys = generated_public_keys.clone();
             let response = build_get_peer_info_response(None, hash).0;
-            let h = spawn(move || mock.client.calculate_coordinator(&generated_public_keys));
+            let h = spawn(move || {
+                mock.client
+                    .calculate_coordinator_ids(&generated_public_keys)
+            });
             write_response(mock.server, response.as_bytes());
             let result = h.join().unwrap();
             results.push(result);
@@ -1489,27 +1480,13 @@ mod tests {
         let results_with_random_hash = generate_calculate_coordinator_test_results(true, 5);
         let all_ids_same = results_with_random_hash
             .iter()
-            .all(|&(id, _)| id == results_with_random_hash[0].0);
-        let all_keys_same = results_with_random_hash
-            .iter()
-            .all(|&(_, key)| key.key.data == results_with_random_hash[0].1.key.data);
+            .all(|ids| ids == &results_with_random_hash[0]);
         assert!(!all_ids_same, "Not all coordinator IDs should be the same");
-        assert!(
-            !all_keys_same,
-            "Not all coordinator public keys should be the same"
-        );
 
         let results_with_static_hash = generate_calculate_coordinator_test_results(false, 5);
         let all_ids_same = results_with_static_hash
             .iter()
-            .all(|&(id, _)| id == results_with_static_hash[0].0);
-        let all_keys_same = results_with_static_hash
-            .iter()
-            .all(|&(_, key)| key.key.data == results_with_static_hash[0].1.key.data);
+            .all(|ids| ids == &results_with_static_hash[0]);
         assert!(all_ids_same, "All coordinator IDs should be the same");
-        assert!(
-            all_keys_same,
-            "All coordinator public keys should be the same"
-        );
     }
 }
diff --git a/stacks-signer/src/config.rs b/stacks-signer/src/config.rs
index b7fb2e3598..9d8fce6b06 100644
--- a/stacks-signer/src/config.rs
+++ b/stacks-signer/src/config.rs
@@ -127,7 +127,7 @@ pub struct RegisteredSignersInfo {
 
 /// The Configuration info needed for an individual signer per reward cycle
 #[derive(Debug, Clone)]
-pub struct RewardCycleConfig {
+pub struct SignerConfig {
     /// The reward cycle of the configuration
     pub reward_cycle: u64,
     /// The signer ID assigned to this signer
@@ -138,6 +138,28 @@ pub struct RewardCycleConfig {
     pub key_ids: Vec<u32>,
     /// The registered signers for this reward cycle
     pub registered_signers: RegisteredSignersInfo,
+    /// The initial coordinator ids for the coordinator selector
+    pub coordinator_ids: Vec<u32>,
+    /// The Scalar representation of the private key for signer communication
+    pub ecdsa_private_key: Scalar,
+    /// The private key for this signer
+    pub stacks_private_key: StacksPrivateKey,
+    /// The node host for this signer
+    pub node_host: SocketAddr,
+    /// Whether this signer is running on mainnet or not
+    pub mainnet: bool,
+    /// timeout to gather DkgPublicShares messages
+    pub dkg_public_timeout: Option<Duration>,
+    /// timeout to gather DkgPrivateShares messages
+    pub dkg_private_timeout: Option<Duration>,
+    /// timeout to gather DkgEnd messages
+    pub dkg_end_timeout: Option<Duration>,
+    /// timeout to gather nonces
+    pub nonce_timeout: Option<Duration>,
+    /// timeout to gather signature shares
+    pub sign_timeout: Option<Duration>,
+    /// the STX tx fee to use in uSTX
+    pub tx_fee_ms: u64,
 }
 
 /// The parsed configuration for the signer
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index b69c0e2e1d..6bd2492dcf 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -25,7 +25,7 @@ use stacks_common::{debug, error, info, warn};
 use wsts::state_machine::OperationResult;
 
 use crate::client::{retry_with_exponential_backoff, ClientError, StacksClient};
-use crate::config::{GlobalConfig, RewardCycleConfig};
+use crate::config::{GlobalConfig, SignerConfig};
 use crate::signer::{Command as SignerCommand, Signer, State as SignerState};
 
 /// Which operation to perform
@@ -74,10 +74,10 @@ impl From<GlobalConfig> for RunLoop {
 
 impl RunLoop {
     /// Get a signer configruation for a specific reward cycle from the stacks node
-    fn get_reward_cycle_config(
+    fn get_signer_config(
         &mut self,
         reward_cycle: u64,
-    ) -> Result<Option<RewardCycleConfig>, ClientError> {
+    ) -> Result<Option<SignerConfig>, ClientError> {
         let reward_set_calculated = self.stacks_client.reward_set_calculated(reward_cycle)?;
         if !reward_set_calculated {
             // Must weight for the reward set calculation to complete
@@ -126,12 +126,26 @@ impl RunLoop {
             .get(signer_id)
             .cloned()
             .unwrap_or_default();
-        Ok(Some(RewardCycleConfig {
+        let coordinator_ids = self
+            .stacks_client
+            .calculate_coordinator_ids(&registered_signers.public_keys);
+        Ok(Some(SignerConfig {
             reward_cycle,
             signer_id: *signer_id,
             signer_slot_id,
             key_ids,
             registered_signers,
+            coordinator_ids,
+            ecdsa_private_key: self.config.ecdsa_private_key.clone(),
+            stacks_private_key: self.config.stacks_private_key.clone(),
+            node_host: self.config.node_host.clone(),
+            mainnet: self.config.network.is_mainnet(),
+            dkg_end_timeout: self.config.dkg_end_timeout,
+            dkg_private_timeout: self.config.dkg_private_timeout,
+            dkg_public_timeout: self.config.dkg_public_timeout,
+            nonce_timeout: self.config.nonce_timeout,
+            sign_timeout: self.config.sign_timeout,
+            tx_fee_ms: self.config.tx_fee_ms,
         }))
     }
 
@@ -151,14 +165,12 @@ impl RunLoop {
             needs_refresh = true;
         };
         if needs_refresh {
-            let new_reward_cycle_config = self.get_reward_cycle_config(reward_cycle)?;
-            if let Some(new_reward_cycle_config) = new_reward_cycle_config {
-                let signer_id = new_reward_cycle_config.signer_id;
+            let new_signer_config = self.get_signer_config(reward_cycle)?;
+            if let Some(new_signer_config) = new_signer_config {
+                let signer_id = new_signer_config.signer_id;
                 debug!("Signer is registered for reward cycle {reward_cycle} as signer #{signer_id}. Initializing signer state.");
-                self.stacks_signers.insert(
-                    reward_index,
-                    Signer::from_configs(&self.config, new_reward_cycle_config),
-                );
+                self.stacks_signers
+                    .insert(reward_index, Signer::from(new_signer_config));
                 debug!("Signer #{signer_id} for reward cycle {reward_cycle} initialized. Initialized {} signers", self.stacks_signers.len());
             } else {
                 // Nothing to initialize. Signer is not registered for this reward cycle
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index 157d461b06..c2c2facb1c 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -32,6 +32,7 @@ use stacks_common::types::StacksEpochId;
 use stacks_common::util::hash::Sha512Trunc256Sum;
 use stacks_common::{debug, error, info, warn};
 use wsts::common::{MerkleRoot, Signature};
+use wsts::curve::ecdsa;
 use wsts::curve::keys::PublicKey;
 use wsts::curve::point::{Compressed, Point};
 use wsts::net::{Message, NonceRequest, Packet, SignatureShareRequest};
@@ -40,16 +41,20 @@ use wsts::state_machine::coordinator::{
     Config as CoordinatorConfig, Coordinator, State as CoordinatorState,
 };
 use wsts::state_machine::signer::Signer as WSTSSigner;
-use wsts::state_machine::{OperationResult, SignError};
+use wsts::state_machine::{OperationResult, PublicKeys, SignError};
 use wsts::v2;
 
 use crate::client::{
     retry_with_exponential_backoff, ClientError, StackerDB, StacksClient, VOTE_FUNCTION_NAME,
 };
-use crate::config::{GlobalConfig, RewardCycleConfig};
+use crate::config::SignerConfig;
 
 /// TODO: test this value and adjust as necessary. Maybe make configurable?
-pub const COORDINATOR_OPERATION_TIMEOUT: u64 = 200;
+pub const COORDINATOR_OPERATION_TIMEOUT_SECS: u64 = 500;
+
+/// TODO: test this value and adjust as necessary. Maybe make configurable?
+pub const COORDINATOR_TENURE_TIMEOUT_SECS: u64 = 1000;
+
 /// Additional Info about a proposed block
 pub struct BlockInfo {
     /// The block we are considering
@@ -104,22 +109,121 @@ pub enum Command {
     },
 }
 
-/// The coordinator info for a specific in progress operation
-#[derive(PartialEq, Clone, Debug)]
-pub struct CoordinatorInfo {
-    /// The coordinator id
-    pub coordinator_id: u32,
-    /// The last message received time
-    pub last_message_time: Instant,
+/// The coordinator selector
+#[derive(Clone, Debug)]
+pub struct CoordinatorSelector {
+    /// The ordered list of potential coordinators for a specific consensus hash
+    coordinator_ids: Vec<u32>,
+    /// The current coordinator id
+    coordinator_id: u32,
+    /// The current coordinator index into the coordinator ids list
+    coordinator_index: usize,
+    /// The last message received time for the current coordinator
+    last_message_time: Option<Instant>,
+    /// The time the coordinator started its tenure
+    tenure_start: Instant,
+    /// The public keys of the coordinators
+    pub public_keys: PublicKeys,
+    /// Ongoing operation
+    pub ongoing_operation: bool,
 }
 
+impl CoordinatorSelector {
+    /// Create a new Coordinator selector from the given list of public keys and initial coordinator ids
+    pub fn new(coordinator_ids: Vec<u32>, public_keys: PublicKeys) -> Self {
+        let coordinator_id = *coordinator_ids
+            .first()
+            .expect("FATAL: No registered signers");
+        let coordinator_index = 0;
+        let last_message_time = None;
+        let tenure_start = Instant::now();
+        let ongoing_operation = false;
+        Self {
+            coordinator_ids,
+            coordinator_id,
+            coordinator_index,
+            last_message_time,
+            tenure_start,
+            public_keys,
+            ongoing_operation,
+        }
+    }
+
+    /// Update the coordinator id
+    fn update_coordinator(&mut self, new_coordinator_ids: Vec<u32>) {
+        self.ongoing_operation = false;
+        self.coordinator_index = if new_coordinator_ids != self.coordinator_ids {
+            // We have advanced our block height and should select from the new list
+            let mut new_index: usize = 0;
+            self.coordinator_ids = new_coordinator_ids;
+            let new_coordinator_id = *self
+                .coordinator_ids
+                .first()
+                .expect("FATAL: No registered signers");
+            if new_coordinator_id == self.coordinator_id {
+                // If the newly selected coordinator is the same as the current and we have more than one available, advance immediately to the next
+                if self.coordinator_ids.len() > 1 {
+                    new_index = new_index.saturating_add(1);
+                }
+            }
+            new_index
+        } else {
+            let mut new_index = self.coordinator_index.saturating_add(1);
+            if new_index == self.coordinator_ids.len() {
+                // We have exhausted all potential coordinators. Go back to the start
+                new_index = 0;
+            }
+            new_index
+        };
+        self.coordinator_id = *self
+            .coordinator_ids
+            .get(self.coordinator_index)
+            .expect("FATAL: Invalid number of registered signers");
+        self.tenure_start = Instant::now();
+        self.last_message_time = None;
+    }
+
+    /// Get the coordinator id and public key
+    pub fn get_coordinator(&mut self, stacks_client: &StacksClient) -> (u32, ecdsa::PublicKey) {
+        let new_coordinator_ids = stacks_client.calculate_coordinator_ids(&self.public_keys);
+        if self.tenure_start.elapsed().as_secs() > COORDINATOR_TENURE_TIMEOUT_SECS {
+            // We have exceeded our tenure. We should consider any operation finished and use a new coordinator id.
+            self.update_coordinator(new_coordinator_ids);
+        } else if self.ongoing_operation {
+            if let Some(time) = self.last_message_time {
+                if time.elapsed().as_secs() > COORDINATOR_OPERATION_TIMEOUT_SECS {
+                    // We have not received a message in a while from this coordinator.
+                    // We should consider the operation finished and use a new coordinator id.
+                    self.update_coordinator(new_coordinator_ids);
+                }
+            }
+        } else if new_coordinator_ids != self.coordinator_ids {
+            // We have advanced our block height and should select from the new list
+            self.update_coordinator(new_coordinator_ids);
+        }
+        (
+            self.coordinator_id,
+            self.public_keys
+                .signers
+                .get(&self.coordinator_id)
+                .expect("FATAL: missing public key for selected coordinator id")
+                .clone(),
+        )
+    }
+
+    /// Update the last message time
+    pub fn update_last_message_time(&mut self) {
+        self.last_message_time = Some(Instant::now());
+        self.ongoing_operation = true;
+    }
+}
 /// The Signer state
 #[derive(PartialEq, Debug, Clone)]
 pub enum State {
     /// The signer is idle, waiting for messages and commands
     Idle,
     /// The signer is executing a DKG or Sign round
-    OperationInProgress(CoordinatorInfo),
+    OperationInProgress,
     /// The Signer has exceeded its tenure
     TenureExceeded,
 }
@@ -140,7 +244,7 @@ pub struct Signer {
     /// The stackerdb client
     pub stackerdb: StackerDB,
     /// Whether the signer is a mainnet signer or not
-    pub is_mainnet: bool,
+    pub mainnet: bool,
     /// The signer id
     pub signer_id: u32,
     /// The addresses of other signers mapped to their signer ID
@@ -149,29 +253,18 @@ pub struct Signer {
     pub reward_cycle: u64,
     /// The tx fee in uSTX to use if the epoch is pre Nakamoto (Epoch 3.0)
     pub tx_fee_ms: u64,
+    /// The coordinator info for the signer
+    pub coordinator_selector: CoordinatorSelector,
 }
 
-impl Signer {
-    /// Create a new stacks signer
-    pub fn from_configs(config: &GlobalConfig, reward_cycle_config: RewardCycleConfig) -> Self {
-        let stackerdb = StackerDB::from_configs(config, &reward_cycle_config);
-
-        let num_signers = u32::try_from(
-            reward_cycle_config
-                .registered_signers
-                .public_keys
-                .signers
-                .len(),
-        )
-        .expect("FATAL: Too many registered signers to fit in a u32");
-        let num_keys = u32::try_from(
-            reward_cycle_config
-                .registered_signers
-                .public_keys
-                .key_ids
-                .len(),
-        )
-        .expect("FATAL: Too many key ids to fit in a u32");
+impl From<SignerConfig> for Signer {
+    fn from(signer_config: SignerConfig) -> Self {
+        let stackerdb = StackerDB::from(&signer_config);
+
+        let num_signers = u32::try_from(signer_config.registered_signers.public_keys.signers.len())
+            .expect("FATAL: Too many registered signers to fit in a u32");
+        let num_keys = u32::try_from(signer_config.registered_signers.public_keys.key_ids.len())
+            .expect("FATAL: Too many key ids to fit in a u32");
         let threshold = num_keys * 7 / 10;
         let dkg_threshold = num_keys * 9 / 10;
 
@@ -180,14 +273,14 @@ impl Signer {
             dkg_threshold,
             num_signers,
             num_keys,
-            message_private_key: config.ecdsa_private_key,
-            dkg_public_timeout: config.dkg_public_timeout,
-            dkg_private_timeout: config.dkg_private_timeout,
-            dkg_end_timeout: config.dkg_end_timeout,
-            nonce_timeout: config.nonce_timeout,
-            sign_timeout: config.sign_timeout,
-            signer_key_ids: reward_cycle_config.registered_signers.coordinator_key_ids,
-            signer_public_keys: reward_cycle_config.registered_signers.signer_public_keys,
+            message_private_key: signer_config.ecdsa_private_key,
+            dkg_public_timeout: signer_config.dkg_public_timeout,
+            dkg_private_timeout: signer_config.dkg_private_timeout,
+            dkg_end_timeout: signer_config.dkg_end_timeout,
+            nonce_timeout: signer_config.nonce_timeout,
+            sign_timeout: signer_config.sign_timeout,
+            signer_key_ids: signer_config.registered_signers.coordinator_key_ids,
+            signer_public_keys: signer_config.registered_signers.signer_public_keys,
         };
 
         let coordinator = FireCoordinator::new(coordinator_config);
@@ -195,10 +288,14 @@ impl Signer {
             threshold,
             num_signers,
             num_keys,
-            reward_cycle_config.signer_id,
-            reward_cycle_config.key_ids,
-            config.ecdsa_private_key,
-            reward_cycle_config.registered_signers.public_keys,
+            signer_config.signer_id,
+            signer_config.key_ids,
+            signer_config.ecdsa_private_key,
+            signer_config.registered_signers.public_keys.clone(),
+        );
+        let coordinator_selector = CoordinatorSelector::new(
+            signer_config.coordinator_ids,
+            signer_config.registered_signers.public_keys,
         );
         Self {
             coordinator,
@@ -207,14 +304,16 @@ impl Signer {
             blocks: HashMap::new(),
             commands: VecDeque::new(),
             stackerdb,
-            is_mainnet: config.network.is_mainnet(),
-            signer_id: reward_cycle_config.signer_id,
-            signer_address_ids: reward_cycle_config.registered_signers.signer_address_ids,
-            reward_cycle: reward_cycle_config.reward_cycle,
-            tx_fee_ms: config.tx_fee_ms,
+            mainnet: signer_config.mainnet,
+            signer_id: signer_config.signer_id,
+            signer_address_ids: signer_config.registered_signers.signer_address_ids,
+            reward_cycle: signer_config.reward_cycle,
+            tx_fee_ms: signer_config.tx_fee_ms,
+            coordinator_selector,
         }
     }
-
+}
+impl Signer {
     /// Execute the given command and update state accordingly
     fn execute_command(&mut self, stacks_client: &StacksClient, command: &Command) {
         match command {
@@ -242,10 +341,8 @@ impl Signer {
                     Ok(msg) => {
                         let ack = self.stackerdb.send_message_with_retry(msg.into());
                         debug!("Signer #{}: ACK: {ack:?}", self.signer_id);
-                        self.state = State::OperationInProgress(CoordinatorInfo {
-                            coordinator_id: self.signer_id,
-                            last_message_time: Instant::now(),
-                        });
+                        self.state = State::OperationInProgress;
+                        self.coordinator_selector.update_last_message_time();
                     }
                     Err(e) => {
                         error!("Signer #{}: Failed to start DKG: {e:?}", self.signer_id);
@@ -275,10 +372,8 @@ impl Signer {
                     Ok(msg) => {
                         let ack = self.stackerdb.send_message_with_retry(msg.into());
                         debug!("Signer #{}: ACK: {ack:?}", self.signer_id);
-                        self.state = State::OperationInProgress(CoordinatorInfo {
-                            coordinator_id: self.signer_id,
-                            last_message_time: Instant::now(),
-                        });
+                        self.state = State::OperationInProgress;
+                        self.coordinator_selector.update_last_message_time();
                         block_info.signed_over = true;
                     }
                     Err(e) => {
@@ -296,11 +391,10 @@ impl Signer {
     pub fn process_next_command(&mut self, stacks_client: &StacksClient) {
         match &self.state {
             State::Idle => {
-                let (coordinator_id, coordinator_pk) =
-                    stacks_client.calculate_coordinator(&self.signing_round.public_keys);
+                let coordinator_id = self.coordinator_selector.get_coordinator(&stacks_client).0;
                 if coordinator_id != self.signer_id {
                     debug!(
-                        "Signer #{}: Not the coordinator. (Coordinator is {coordinator_id:?}, {coordinator_pk:?}). Will not process any commands...",
+                        "Signer #{}: Coordinator is {coordinator_id:?}. Will not process any commands...",
                         self.signer_id
                     );
                     return;
@@ -315,26 +409,18 @@ impl Signer {
                     );
                 }
             }
-            State::OperationInProgress(coordinator_info) => {
+            State::OperationInProgress => {
                 // We cannot execute the next command until the current one is finished...
-                // Do nothing...
-                if coordinator_info.last_message_time.elapsed().as_secs()
-                    > COORDINATOR_OPERATION_TIMEOUT
-                {
+                let coordinator_id = self.coordinator_selector.get_coordinator(&stacks_client).0;
+                if !self.coordinator_selector.ongoing_operation {
+                    self.state = State::Idle;
+                    return self.process_next_command(stacks_client);
+                } else {
                     debug!(
-                        "Signer #{}: Operation from coordinator {} timed out.",
-                        self.signer_id, coordinator_info.coordinator_id
+                        "Signer #{}: Waiting for coordinator {coordinator_id:?} operation to finish...",
+                        self.signer_id,
                     );
-                    // We have not received a message in a while. We should consider the operation finished and use a new coordinator id.
-                    self.coordinator.state = CoordinatorState::Idle;
-                    self.signing_round.state = wsts::state_machine::signer::State::Idle;
-                    self.state = State::Idle;
-                    self.process_next_command(stacks_client);
                 }
-                debug!(
-                    "Signer #{}: Waiting for operation to finish",
-                    self.signer_id,
-                );
             }
             State::TenureExceeded => {
                 // We have exceeded our tenure. Do nothing...
@@ -410,8 +496,7 @@ impl Signer {
             };
             self.handle_packets(stacks_client, res, &[packet]);
         } else {
-            let (coordinator_id, _) =
-                stacks_client.calculate_coordinator(&self.signing_round.public_keys);
+            let coordinator_id = self.coordinator_selector.get_coordinator(&stacks_client).0;
             if block_info.valid.unwrap_or(false)
                 && !block_info.signed_over
                 && coordinator_id == self.signer_id
@@ -446,24 +531,8 @@ impl Signer {
         res: Sender<Vec<OperationResult>>,
         messages: &[SignerMessage],
     ) {
-        let (mut coordinator_id, mut coordinator_pubkey) =
-            stacks_client.calculate_coordinator(&self.signing_round.public_keys);
-        // TODO return the list of coordinators in case we are stuck at a block for quite some time.
-        if let State::OperationInProgress(info) = &self.state {
-            if let Some(pubkey) = self
-                .signing_round
-                .public_keys
-                .signers
-                .get(&info.coordinator_id)
-            {
-                coordinator_pubkey = pubkey.clone();
-                coordinator_id = info.coordinator_id;
-                debug!(
-                        "Signer #{:?}: Operation in progress led by coordinator ID {coordinator_id:?} ({coordinator_pubkey:?})",
-                        self.signer_id
-                    );
-            }
-        }
+        let (_coordinator_id, coordinator_pubkey) =
+            self.coordinator_selector.get_coordinator(&stacks_client);
         let packets: Vec<Packet> = messages
             .iter()
             .filter_map(|msg| match msg {
@@ -475,16 +544,6 @@ impl Signer {
             })
             .collect();
         self.handle_packets(stacks_client, res, &packets);
-        if self.state == State::Idle
-            && self.coordinator.state != CoordinatorState::Idle
-            && !packets.is_empty()
-        {
-            // We are in the middle of a DKG or signing round. Update our state to reflect this.
-            self.state = State::OperationInProgress(CoordinatorInfo {
-                coordinator_id,
-                last_message_time: Instant::now(),
-            });
-        }
     }
 
     /// Handle proposed blocks submitted by the miners to stackerdb
@@ -533,8 +592,13 @@ impl Signer {
             // We have finished a signing or DKG round, either successfully or due to error.
             // Regardless of the why, update our state to Idle as we should not expect the operation to continue.
             self.state = State::Idle;
+            self.coordinator_selector.ongoing_operation = false;
             self.process_operation_results(stacks_client, &operation_results);
             self.send_operation_results(res, operation_results);
+        } else if !packets.is_empty() && self.coordinator.state != CoordinatorState::Idle {
+            // We have received a message. Update the last message time for the coordinator
+            self.coordinator_selector.update_last_message_time();
+            self.state = State::OperationInProgress;
         }
         self.send_outbound_messages(signer_outbound_messages);
         self.send_outbound_messages(coordinator_outbound_messages);
@@ -794,7 +858,7 @@ impl Signer {
             return Ok(false);
         };
 
-        if payload.contract_identifier() != boot_code_id(SIGNERS_VOTING_NAME, self.is_mainnet)
+        if payload.contract_identifier() != boot_code_id(SIGNERS_VOTING_NAME, self.mainnet)
             || payload.function_name != VOTE_FUNCTION_NAME.into()
         {
             // This is not a special cased transaction.
@@ -1218,12 +1282,10 @@ impl Signer {
             self.coordinator
                 .set_aggregate_public_key(new_aggregate_public_key);
         }
-        let coordinator_id = stacks_client
-            .calculate_coordinator(&self.signing_round.public_keys)
-            .0;
+        let coordinator_id = self.coordinator_selector.get_coordinator(stacks_client).0;
         if new_aggregate_public_key.is_none()
             && self.signer_id == coordinator_id
-            && self.coordinator.state == CoordinatorState::Idle
+            && self.state == State::Idle
         {
             debug!(
                 "Signer #{}: Checking if old transactions exist",
@@ -1393,13 +1455,12 @@ mod tests {
     };
     use stacks_common::util::hash::{MerkleTree, Sha512Trunc256Sum};
     use stacks_common::util::secp256k1::MessageSignature;
-    use wsts::curve::ecdsa;
     use wsts::curve::point::Point;
     use wsts::curve::scalar::Scalar;
 
     use crate::client::tests::{
         build_get_aggregate_public_key_response, build_get_last_round_response,
-        generate_reward_cycle_config, mock_server_from_config, write_response,
+        generate_signer_config, mock_server_from_config, write_response,
     };
     use crate::client::{StacksClient, VOTE_FUNCTION_NAME};
     use crate::config::GlobalConfig;
@@ -1411,21 +1472,13 @@ mod tests {
     fn get_filtered_transaction_filters_out_invalid_transactions() {
         // Create a runloop of a valid signer
         let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
-        let (reward_cycle_info, _ordered_addresses) = generate_reward_cycle_config(
-            5,
-            20,
-            Some(
-                ecdsa::PublicKey::new(&config.ecdsa_private_key)
-                    .expect("Failed to create public key."),
-            ),
-        );
-        let stacks_client = StacksClient::from(&config);
-        let mut signer = Signer::from_configs(&config, reward_cycle_info);
+        let (signer_config, _ordered_addresses) = generate_signer_config(&config, 5, 20);
+        let mut signer = Signer::from(signer_config);
 
         let signer_private_key = config.stacks_private_key;
         let non_signer_private_key = StacksPrivateKey::new();
 
-        let vote_contract_id = boot_code_id(SIGNERS_VOTING_NAME, signer.is_mainnet);
+        let vote_contract_id = boot_code_id(SIGNERS_VOTING_NAME, signer.mainnet);
         let contract_addr = vote_contract_id.issuer.into();
         let contract_name = vote_contract_id.name.clone();
         let index = thread_rng().next_u64() as u128;
@@ -1537,6 +1590,7 @@ mod tests {
             invalid_tx_bad_function_args,
         ];
         let num_transactions = transactions.len();
+        let stacks_client = StacksClient::from(&config);
         let h = spawn(move || {
             signer
                 .get_filtered_transactions(&stacks_client, &[0])
@@ -1566,19 +1620,12 @@ mod tests {
     #[ignore = "This test needs to be fixed based on reward set calculations"]
     fn verify_block_transactions_valid() {
         let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
-        let (reward_cycle_info, _ordered_addresses) = generate_reward_cycle_config(
-            5,
-            20,
-            Some(
-                ecdsa::PublicKey::new(&config.ecdsa_private_key)
-                    .expect("Failed to create public key."),
-            ),
-        );
+        let (signer_config, _ordered_addresses) = generate_signer_config(&config, 5, 20);
         let stacks_client = StacksClient::from(&config);
-        let mut signer = Signer::from_configs(&config, reward_cycle_info);
+        let mut signer = Signer::from(signer_config);
 
         let signer_private_key = config.stacks_private_key;
-        let vote_contract_id = boot_code_id(SIGNERS_VOTING_NAME, signer.is_mainnet);
+        let vote_contract_id = boot_code_id(SIGNERS_VOTING_NAME, signer.mainnet);
         let contract_addr = vote_contract_id.issuer.into();
         let contract_name = vote_contract_id.name.clone();
         let index = thread_rng().next_u64() as u128;
@@ -1688,18 +1735,13 @@ mod tests {
     fn verify_transaction_payload_filters_invalid_payloads() {
         // Create a runloop of a valid signer
         let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
-        let (mut reward_cycle_info, _ordered_addresses) = generate_reward_cycle_config(
-            5,
-            20,
-            Some(
-                ecdsa::PublicKey::new(&config.ecdsa_private_key)
-                    .expect("Failed to create public key."),
-            ),
-        );
-        reward_cycle_info.reward_cycle = 1;
-        let signer = Signer::from_configs(&config, reward_cycle_info.clone());
+        let (mut signer_config, _ordered_addresses) = generate_signer_config(&config, 5, 20);
+        signer_config.reward_cycle = 1;
+
+        let signer = Signer::from(signer_config.clone());
+
         let signer_private_key = config.stacks_private_key;
-        let vote_contract_id = boot_code_id(SIGNERS_VOTING_NAME, signer.is_mainnet);
+        let vote_contract_id = boot_code_id(SIGNERS_VOTING_NAME, signer.mainnet);
         let contract_addr = vote_contract_id.issuer.into();
         let contract_name = vote_contract_id.name.clone();
         let point = Point::from(Scalar::random(&mut thread_rng()));
@@ -1817,7 +1859,8 @@ mod tests {
         write_response(mock_server, vote_response.as_bytes());
         h.join().unwrap();
 
-        let signer = Signer::from_configs(&config, reward_cycle_info.clone());
+        let signer = Signer::from(signer_config);
+
         let vote_response = build_get_aggregate_public_key_response(None);
         let last_round_response = build_get_last_round_response(10);
         let aggregate_public_key_response = build_get_aggregate_public_key_response(Some(point));
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index 1326e36aa2..f36f1e366f 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -43,7 +43,7 @@ use crate::neon::Counters;
 use crate::run_loop::boot_nakamoto;
 use crate::tests::bitcoin_regtest::BitcoinCoreController;
 use crate::tests::nakamoto_integrations::{
-    boot_to_epoch_3, boot_to_epoch_3_reward_set, naka_neon_integration_conf, next_block_and,
+    boot_to_epoch_3_reward_set, naka_neon_integration_conf, next_block_and,
     next_block_and_mine_commit, POX_4_DEFAULT_STACKER_BALANCE,
 };
 use crate::tests::neon_integrations::{
@@ -178,13 +178,19 @@ impl SignerTest {
             .unwrap();
         // Use the stacks client to calculate the current registered signers and their coordinator
         let stacks_client = StacksClient::new(private_key, node_host, false);
-        let (coordinator_id, coordinator_pk) = stacks_client.calculate_coordinator(
-            &stacks_client
-                .get_registered_signers_info(reward_cycle)
-                .unwrap()
-                .unwrap()
-                .public_keys,
-        );
+        let registered_signers_info = &stacks_client
+            .get_registered_signers_info(reward_cycle)
+            .unwrap()
+            .unwrap();
+        let coordinator_id = *stacks_client
+            .calculate_coordinator_ids(&registered_signers_info.public_keys)
+            .first()
+            .expect("No coordinator found");
+        let coordinator_pk = registered_signers_info
+            .public_keys
+            .signers
+            .get(&coordinator_id)
+            .expect("No coordinator found");
         let coordinator_index = self
             .signer_stacks_private_keys
             .iter()
@@ -572,12 +578,12 @@ fn stackerdb_block_proposal() {
 
     info!("------------------------- Test Setup -------------------------");
     let mut signer_test = SignerTest::new(5, true);
-
+    let timeout = Duration::from_secs(200);
     let (_vrfs_submitted, commits_submitted) = (
         signer_test.running_nodes.vrfs_submitted.clone(),
         signer_test.running_nodes.commits_submitted.clone(),
     );
-    boot_to_epoch_3(
+    boot_to_epoch_3_reward_set(
         &signer_test.running_nodes.conf,
         &signer_test.running_nodes.blocks_processed,
         &signer_test.signer_stacks_private_keys,
@@ -585,27 +591,15 @@ fn stackerdb_block_proposal() {
         &mut signer_test.running_nodes.btc_regtest_controller,
     );
 
-    // Determine the coordinator
-    let reward_cycle = signer_test.get_current_reward_cycle();
-    let coordinator_sender = signer_test.get_coordinator_sender(reward_cycle);
-
-    // Forcibly run DKG to overwrite the self signing aggregate key in the contract
     info!("------------------------- Wait for DKG -------------------------");
     info!("signer_runloop: spawn send commands to do dkg");
     let dkg_now = Instant::now();
     let mut key = Point::default();
-    let dkg_command = RunLoopCommand {
-        reward_cycle,
-        command: SignerCommand::Dkg,
-    };
-    coordinator_sender
-        .send(dkg_command)
-        .expect("failed to send DKG command");
     for recv in signer_test.result_receivers.iter() {
         let mut aggregate_public_key = None;
         loop {
             let results = recv
-                .recv_timeout(Duration::from_secs(60))
+                .recv_timeout(timeout)
                 .expect("failed to recv dkg results");
             for result in results {
                 match result {
@@ -627,11 +621,13 @@ fn stackerdb_block_proposal() {
                     }
                 }
             }
-            if aggregate_public_key.is_some() || dkg_now.elapsed() > Duration::from_secs(200) {
+            if aggregate_public_key.is_some() || dkg_now.elapsed() > timeout {
                 break;
             }
         }
-        key = aggregate_public_key.expect("Failed to get aggregate public key within 200 seconds");
+        key = aggregate_public_key.expect(&format!(
+            "Failed to get aggregate public key within {timeout:?}"
+        ));
     }
     let dkg_elapsed = dkg_now.elapsed();
 
@@ -641,7 +637,7 @@ fn stackerdb_block_proposal() {
     // Mine 1 nakamoto tenure
     let _ = next_block_and_mine_commit(
         &mut signer_test.running_nodes.btc_regtest_controller,
-        60,
+        10, // We know that it will never actually mine the block right now
         &signer_test.running_nodes.coord_channel,
         &commits_submitted,
     );
@@ -651,7 +647,7 @@ fn stackerdb_block_proposal() {
         .last()
         .expect("Failed to retreive coordinator recv");
     let results = recv
-        .recv_timeout(Duration::from_secs(30))
+        .recv_timeout(timeout)
         .expect("failed to recv signature results");
     let mut signature = None;
     for result in results {

From 784a0f35fca0eacf137fa065b848fc310faa3386 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Tue, 13 Feb 2024 13:53:29 -0500
Subject: [PATCH 0890/1166] CRC: add mainnet var and check transaction is on
 the correct network when filtering signer transactions

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/stacks_client.rs | 19 ++++++++++---------
 stacks-signer/src/signer.rs               |  8 ++++++++
 testnet/stacks-node/src/tests/signer.rs   |  2 ++
 3 files changed, 20 insertions(+), 9 deletions(-)

diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index e5fee0f3cd..98be2ff981 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -66,6 +66,8 @@ pub struct StacksClient {
     tx_version: TransactionVersion,
     /// The chain we are interacting with
     chain_id: u32,
+    /// Whether we are mainnet or not
+    mainnet: bool,
     /// The Client used to make HTTP connects
     stacks_node_client: reqwest::blocking::Client,
 }
@@ -79,6 +81,7 @@ impl From<&GlobalConfig> for StacksClient {
             tx_version: config.network.to_transaction_version(),
             chain_id: config.network.to_chain_id(),
             stacks_node_client: reqwest::blocking::Client::new(),
+            mainnet: config.network.is_mainnet(),
         }
     }
 }
@@ -105,6 +108,7 @@ impl StacksClient {
             tx_version,
             chain_id,
             stacks_node_client: reqwest::blocking::Client::new(),
+            mainnet,
         }
     }
 
@@ -213,7 +217,7 @@ impl StacksClient {
             ClarityValue::Principal(signer.into()),
         ];
         let value = self.read_only_contract_call(
-            &boot_code_addr(self.chain_id == CHAIN_ID_MAINNET),
+            &boot_code_addr(self.mainnet),
             &ContractName::from(SIGNERS_VOTING_NAME),
             &function_name,
             function_args,
@@ -300,7 +304,7 @@ impl StacksClient {
         reward_cycle: u64,
     ) -> Result<Option<Point>, ClientError> {
         let function_name = ClarityName::from("get-aggregate-public-key");
-        let pox_contract_id = boot_code_id(POX_4_NAME, self.chain_id == CHAIN_ID_MAINNET);
+        let pox_contract_id = boot_code_id(POX_4_NAME, self.mainnet);
         let function_args = &[ClarityValue::UInt(reward_cycle as u128)];
         let value = self.read_only_contract_call(
             &pox_contract_id.issuer.into(),
@@ -337,7 +341,7 @@ impl StacksClient {
     /// Retrieve the last DKG vote round number for the current reward cycle
     pub fn get_last_round(&self, reward_cycle: u64) -> Result<Option<u64>, ClientError> {
         debug!("Getting the last DKG vote round of reward cycle {reward_cycle}...");
-        let contract_addr = boot_code_addr(self.chain_id == CHAIN_ID_MAINNET);
+        let contract_addr = boot_code_addr(self.mainnet);
         let contract_name = ContractName::from(SIGNERS_VOTING_NAME);
         let function_name = ClarityName::from("get-last-round");
         let function_args = &[ClarityValue::UInt(reward_cycle as u128)];
@@ -366,7 +370,7 @@ impl StacksClient {
         let reward_cycle = ClarityValue::UInt(self.get_current_reward_cycle()? as u128);
         let round = ClarityValue::UInt(round);
         let signer = ClarityValue::Principal(self.stacks_address.into());
-        let contract_addr = boot_code_addr(self.chain_id == CHAIN_ID_MAINNET);
+        let contract_addr = boot_code_addr(self.mainnet);
         let contract_name = ContractName::from(SIGNERS_VOTING_NAME);
         let function = ClarityName::from("get-vote");
         let function_args = &[reward_cycle, round, signer];
@@ -450,10 +454,7 @@ impl StacksClient {
                             ))
                         })?;
 
-            let stacks_address = StacksAddress::p2pkh(
-                self.tx_version == TransactionVersion::Mainnet,
-                &stacks_public_key,
-            );
+            let stacks_address = StacksAddress::p2pkh(self.mainnet, &stacks_public_key);
 
             signer_address_ids.insert(stacks_address, signer_id);
             signer_public_keys.insert(signer_id, signer_public_key);
@@ -569,7 +570,7 @@ impl StacksClient {
         debug!("Building {VOTE_FUNCTION_NAME} transaction...");
         // TODO: this nonce should be calculated on the side as we may have pending transactions that are not yet confirmed...
         let nonce = self.get_account_nonce(&self.stacks_address)?;
-        let contract_address = boot_code_addr(self.chain_id == CHAIN_ID_MAINNET);
+        let contract_address = boot_code_addr(self.mainnet);
         let contract_name = ContractName::from(SIGNERS_VOTING_NAME);
         let function_name = ClarityName::from(VOTE_FUNCTION_NAME);
         let function_args = vec![
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index c2c2facb1c..e14fa5b038 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -819,6 +819,14 @@ impl Signer {
             debug!("Signer #{}: Received a transaction with an outdated nonce ({account_nonce} < {origin_nonce}). Filtering ({}).", self.signer_id, transaction.txid());
             return None;
         }
+        if transaction.is_mainnet() != self.mainnet {
+            debug!(
+                "Signer #{}: Received a transaction with an unexpected network. Filtering ({}).",
+                self.signer_id,
+                transaction.txid()
+            );
+            return None;
+        }
         let Ok(valid) = retry_with_exponential_backoff(|| {
             self.verify_payload(stacks_client, &transaction, *origin_signer_id)
                 .map_err(backoff::Error::transient)
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index f36f1e366f..ac894085e5 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -642,6 +642,8 @@ fn stackerdb_block_proposal() {
         &commits_submitted,
     );
 
+    // TODO: confirm that the contract has updated its DKG key to the resulting "key"
+
     let recv = signer_test
         .result_receivers
         .last()

From 2a4311bde34cb4340c3957e169430a62deadf9f8 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 14 Feb 2024 11:16:15 -0500
Subject: [PATCH 0891/1166] Cleanup coordinator selector

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/coordinator.rs | 127 +++++++++++++++++++++++
 stacks-signer/src/lib.rs         |   2 +
 stacks-signer/src/signer.rs      | 172 ++++++-------------------------
 3 files changed, 161 insertions(+), 140 deletions(-)
 create mode 100644 stacks-signer/src/coordinator.rs

diff --git a/stacks-signer/src/coordinator.rs b/stacks-signer/src/coordinator.rs
new file mode 100644
index 0000000000..12ee310305
--- /dev/null
+++ b/stacks-signer/src/coordinator.rs
@@ -0,0 +1,127 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020-2023 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+use std::time::Instant;
+
+use wsts::curve::ecdsa;
+use wsts::state_machine::PublicKeys;
+
+use crate::client::StacksClient;
+
+/// TODO: test this value and adjust as necessary. Maybe make configurable?
+pub const COORDINATOR_OPERATION_TIMEOUT_SECS: u64 = 500;
+
+/// TODO: test this value and adjust as necessary. Maybe make configurable?
+pub const COORDINATOR_TENURE_TIMEOUT_SECS: u64 = 1000;
+
+/// The coordinator selector
+#[derive(Clone, Debug)]
+pub struct Selector {
+    /// The ordered list of potential coordinators for a specific consensus hash
+    coordinator_ids: Vec<u32>,
+    /// The current coordinator id
+    coordinator_id: u32,
+    /// The current coordinator index into the coordinator ids list
+    coordinator_index: usize,
+    /// The last message received time for the current coordinator
+    pub last_message_time: Option<Instant>,
+    /// The time the coordinator started its tenure
+    tenure_start: Instant,
+    /// The public keys of the coordinators
+    public_keys: PublicKeys,
+}
+
+impl Selector {
+    /// Create a new Coordinator selector from the given list of public keys and initial coordinator ids
+    pub fn new(coordinator_ids: Vec<u32>, public_keys: PublicKeys) -> Self {
+        let coordinator_id = *coordinator_ids
+            .first()
+            .expect("FATAL: No registered signers");
+        let coordinator_index = 0;
+        let last_message_time = None;
+        let tenure_start = Instant::now();
+        Self {
+            coordinator_ids,
+            coordinator_id,
+            coordinator_index,
+            last_message_time,
+            tenure_start,
+            public_keys,
+        }
+    }
+
+    /// Update the coordinator id
+    fn update_coordinator(&mut self, new_coordinator_ids: Vec<u32>) {
+        self.last_message_time = None;
+        self.coordinator_index = if new_coordinator_ids != self.coordinator_ids {
+            // We have advanced our block height and should select from the new list
+            let mut new_index: usize = 0;
+            self.coordinator_ids = new_coordinator_ids;
+            let new_coordinator_id = *self
+                .coordinator_ids
+                .first()
+                .expect("FATAL: No registered signers");
+            if new_coordinator_id == self.coordinator_id {
+                // If the newly selected coordinator is the same as the current and we have more than one available, advance immediately to the next
+                if self.coordinator_ids.len() > 1 {
+                    new_index = new_index.saturating_add(1);
+                }
+            }
+            new_index
+        } else {
+            let mut new_index = self.coordinator_index.saturating_add(1);
+            if new_index == self.coordinator_ids.len() {
+                // We have exhausted all potential coordinators. Go back to the start
+                new_index = 0;
+            }
+            new_index
+        };
+        self.coordinator_id = *self
+            .coordinator_ids
+            .get(self.coordinator_index)
+            .expect("FATAL: Invalid number of registered signers");
+        self.tenure_start = Instant::now();
+        self.last_message_time = None;
+    }
+
+    /// Get the coordinator id and public key
+    pub fn get_coordinator(&mut self, stacks_client: &StacksClient) -> (u32, ecdsa::PublicKey) {
+        let new_coordinator_ids = stacks_client.calculate_coordinator_ids(&self.public_keys);
+        if self.tenure_start.elapsed().as_secs() > COORDINATOR_TENURE_TIMEOUT_SECS {
+            // We have exceeded our tenure. We should consider any operation finished and use a new coordinator id.
+            self.update_coordinator(new_coordinator_ids);
+        } else {
+            if let Some(time) = self.last_message_time {
+                if time.elapsed().as_secs() > COORDINATOR_OPERATION_TIMEOUT_SECS {
+                    // We have not received a message in a while from this coordinator.
+                    // We should consider the operation finished and use a new coordinator id.
+                    self.update_coordinator(new_coordinator_ids);
+                }
+            } else if new_coordinator_ids != self.coordinator_ids {
+                // We have advanced our block height and should select from the new list
+                self.update_coordinator(new_coordinator_ids);
+            }
+        }
+        (
+            self.coordinator_id,
+            self.public_keys
+                .signers
+                .get(&self.coordinator_id)
+                .expect("FATAL: missing public key for selected coordinator id")
+                .clone(),
+        )
+    }
+}
diff --git a/stacks-signer/src/lib.rs b/stacks-signer/src/lib.rs
index e9e41e5a70..f3438e8bbc 100644
--- a/stacks-signer/src/lib.rs
+++ b/stacks-signer/src/lib.rs
@@ -26,6 +26,8 @@ pub mod cli;
 pub mod client;
 /// The configuration module for the signer
 pub mod config;
+/// The coordinator selector for the signer
+pub mod coordinator;
 /// The primary runloop for the signer
 pub mod runloop;
 /// The signer module for processing events
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index e14fa5b038..55203a6fce 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -32,7 +32,6 @@ use stacks_common::types::StacksEpochId;
 use stacks_common::util::hash::Sha512Trunc256Sum;
 use stacks_common::{debug, error, info, warn};
 use wsts::common::{MerkleRoot, Signature};
-use wsts::curve::ecdsa;
 use wsts::curve::keys::PublicKey;
 use wsts::curve::point::{Compressed, Point};
 use wsts::net::{Message, NonceRequest, Packet, SignatureShareRequest};
@@ -41,19 +40,14 @@ use wsts::state_machine::coordinator::{
     Config as CoordinatorConfig, Coordinator, State as CoordinatorState,
 };
 use wsts::state_machine::signer::Signer as WSTSSigner;
-use wsts::state_machine::{OperationResult, PublicKeys, SignError};
+use wsts::state_machine::{OperationResult, SignError};
 use wsts::v2;
 
 use crate::client::{
     retry_with_exponential_backoff, ClientError, StackerDB, StacksClient, VOTE_FUNCTION_NAME,
 };
 use crate::config::SignerConfig;
-
-/// TODO: test this value and adjust as necessary. Maybe make configurable?
-pub const COORDINATOR_OPERATION_TIMEOUT_SECS: u64 = 500;
-
-/// TODO: test this value and adjust as necessary. Maybe make configurable?
-pub const COORDINATOR_TENURE_TIMEOUT_SECS: u64 = 1000;
+use crate::coordinator::Selector;
 
 /// Additional Info about a proposed block
 pub struct BlockInfo {
@@ -109,114 +103,6 @@ pub enum Command {
     },
 }
 
-/// The coordinator selector
-#[derive(Clone, Debug)]
-pub struct CoordinatorSelector {
-    /// The ordered list of potential coordinators for a specific consensus hash
-    coordinator_ids: Vec<u32>,
-    /// The current coordinator id
-    coordinator_id: u32,
-    /// The current coordinator index into the coordinator ids list
-    coordinator_index: usize,
-    /// The last message received time for the current coordinator
-    last_message_time: Option<Instant>,
-    /// The time the coordinator started its tenure
-    tenure_start: Instant,
-    /// The public keys of the coordinators
-    pub public_keys: PublicKeys,
-    /// Ongoing operation
-    pub ongoing_operation: bool,
-}
-
-impl CoordinatorSelector {
-    /// Create a new Coordinator selector from the given list of public keys and initial coordinator ids
-    pub fn new(coordinator_ids: Vec<u32>, public_keys: PublicKeys) -> Self {
-        let coordinator_id = *coordinator_ids
-            .first()
-            .expect("FATAL: No registered signers");
-        let coordinator_index = 0;
-        let last_message_time = None;
-        let tenure_start = Instant::now();
-        let ongoing_operation = false;
-        Self {
-            coordinator_ids,
-            coordinator_id,
-            coordinator_index,
-            last_message_time,
-            tenure_start,
-            public_keys,
-            ongoing_operation,
-        }
-    }
-
-    /// Update the coordinator id
-    fn update_coordinator(&mut self, new_coordinator_ids: Vec<u32>) {
-        self.ongoing_operation = false;
-        self.coordinator_index = if new_coordinator_ids != self.coordinator_ids {
-            // We have advanced our block height and should select from the new list
-            let mut new_index: usize = 0;
-            self.coordinator_ids = new_coordinator_ids;
-            let new_coordinator_id = *self
-                .coordinator_ids
-                .first()
-                .expect("FATAL: No registered signers");
-            if new_coordinator_id == self.coordinator_id {
-                // If the newly selected coordinator is the same as the current and we have more than one available, advance immediately to the next
-                if self.coordinator_ids.len() > 1 {
-                    new_index = new_index.saturating_add(1);
-                }
-            }
-            new_index
-        } else {
-            let mut new_index = self.coordinator_index.saturating_add(1);
-            if new_index == self.coordinator_ids.len() {
-                // We have exhausted all potential coordinators. Go back to the start
-                new_index = 0;
-            }
-            new_index
-        };
-        self.coordinator_id = *self
-            .coordinator_ids
-            .get(self.coordinator_index)
-            .expect("FATAL: Invalid number of registered signers");
-        self.tenure_start = Instant::now();
-        self.last_message_time = None;
-    }
-
-    /// Get the coordinator id and public key
-    pub fn get_coordinator(&mut self, stacks_client: &StacksClient) -> (u32, ecdsa::PublicKey) {
-        let new_coordinator_ids = stacks_client.calculate_coordinator_ids(&self.public_keys);
-        if self.tenure_start.elapsed().as_secs() > COORDINATOR_TENURE_TIMEOUT_SECS {
-            // We have exceeded our tenure. We should consider any operation finished and use a new coordinator id.
-            self.update_coordinator(new_coordinator_ids);
-        } else if self.ongoing_operation {
-            if let Some(time) = self.last_message_time {
-                if time.elapsed().as_secs() > COORDINATOR_OPERATION_TIMEOUT_SECS {
-                    // We have not received a message in a while from this coordinator.
-                    // We should consider the operation finished and use a new coordinator id.
-                    self.update_coordinator(new_coordinator_ids);
-                }
-            }
-        } else if new_coordinator_ids != self.coordinator_ids {
-            // We have advanced our block height and should select from the new list
-            self.update_coordinator(new_coordinator_ids);
-        }
-        (
-            self.coordinator_id,
-            self.public_keys
-                .signers
-                .get(&self.coordinator_id)
-                .expect("FATAL: missing public key for selected coordinator id")
-                .clone(),
-        )
-    }
-
-    /// Update the last message time
-    pub fn update_last_message_time(&mut self) {
-        self.last_message_time = Some(Instant::now());
-        self.ongoing_operation = true;
-    }
-}
 /// The Signer state
 #[derive(PartialEq, Debug, Clone)]
 pub enum State {
@@ -254,7 +140,7 @@ pub struct Signer {
     /// The tx fee in uSTX to use if the epoch is pre Nakamoto (Epoch 3.0)
     pub tx_fee_ms: u64,
     /// The coordinator info for the signer
-    pub coordinator_selector: CoordinatorSelector,
+    pub coordinator_selector: Selector,
 }
 
 impl From<SignerConfig> for Signer {
@@ -293,7 +179,7 @@ impl From<SignerConfig> for Signer {
             signer_config.ecdsa_private_key,
             signer_config.registered_signers.public_keys.clone(),
         );
-        let coordinator_selector = CoordinatorSelector::new(
+        let coordinator_selector = Selector::new(
             signer_config.coordinator_ids,
             signer_config.registered_signers.public_keys,
         );
@@ -313,7 +199,20 @@ impl From<SignerConfig> for Signer {
         }
     }
 }
+
 impl Signer {
+    /// Finish an operation and update the coordinator selector accordingly
+    fn finish_operation(&mut self) {
+        self.state = State::Idle;
+        self.coordinator_selector.last_message_time = None;
+    }
+
+    /// Update operation
+    fn update_operation(&mut self) {
+        self.state = State::OperationInProgress;
+        self.coordinator_selector.last_message_time = Some(Instant::now());
+    }
+
     /// Execute the given command and update state accordingly
     fn execute_command(&mut self, stacks_client: &StacksClient, command: &Command) {
         match command {
@@ -341,11 +240,10 @@ impl Signer {
                     Ok(msg) => {
                         let ack = self.stackerdb.send_message_with_retry(msg.into());
                         debug!("Signer #{}: ACK: {ack:?}", self.signer_id);
-                        self.state = State::OperationInProgress;
-                        self.coordinator_selector.update_last_message_time();
                     }
                     Err(e) => {
                         error!("Signer #{}: Failed to start DKG: {e:?}", self.signer_id);
+                        return;
                     }
                 }
             }
@@ -372,8 +270,6 @@ impl Signer {
                     Ok(msg) => {
                         let ack = self.stackerdb.send_message_with_retry(msg.into());
                         debug!("Signer #{}: ACK: {ack:?}", self.signer_id);
-                        self.state = State::OperationInProgress;
-                        self.coordinator_selector.update_last_message_time();
                         block_info.signed_over = true;
                     }
                     Err(e) => {
@@ -381,17 +277,23 @@ impl Signer {
                             "Signer #{}: Failed to start signing block: {e:?}",
                             self.signer_id
                         );
+                        return;
                     }
                 }
             }
         }
+        self.update_operation();
     }
 
     /// Attempt to process the next command in the queue, and update state accordingly
     pub fn process_next_command(&mut self, stacks_client: &StacksClient) {
+        let coordinator_id = self.coordinator_selector.get_coordinator(&stacks_client).0;
+        if self.coordinator_selector.last_message_time.is_none() {
+            self.state = State::Idle;
+            self.coordinator.state = CoordinatorState::Idle;
+        }
         match &self.state {
             State::Idle => {
-                let coordinator_id = self.coordinator_selector.get_coordinator(&stacks_client).0;
                 if coordinator_id != self.signer_id {
                     debug!(
                         "Signer #{}: Coordinator is {coordinator_id:?}. Will not process any commands...",
@@ -399,7 +301,6 @@ impl Signer {
                     );
                     return;
                 }
-
                 if let Some(command) = self.commands.pop_front() {
                     self.execute_command(stacks_client, &command);
                 } else {
@@ -411,16 +312,10 @@ impl Signer {
             }
             State::OperationInProgress => {
                 // We cannot execute the next command until the current one is finished...
-                let coordinator_id = self.coordinator_selector.get_coordinator(&stacks_client).0;
-                if !self.coordinator_selector.ongoing_operation {
-                    self.state = State::Idle;
-                    return self.process_next_command(stacks_client);
-                } else {
-                    debug!(
-                        "Signer #{}: Waiting for coordinator {coordinator_id:?} operation to finish...",
-                        self.signer_id,
-                    );
-                }
+                debug!(
+                    "Signer #{}: Waiting for coordinator {coordinator_id:?} operation to finish...",
+                    self.signer_id,
+                );
             }
             State::TenureExceeded => {
                 // We have exceeded our tenure. Do nothing...
@@ -484,7 +379,6 @@ impl Signer {
                 block_info
             }
         };
-
         if let Some(mut nonce_request) = block_info.nonce_request.take() {
             debug!("Received a block validate response from the stacks node for a block we already received a nonce request for. Responding to the nonce request...");
             // We have received validation from the stacks node. Determine our vote and update the request message
@@ -591,14 +485,12 @@ impl Signer {
         if !operation_results.is_empty() {
             // We have finished a signing or DKG round, either successfully or due to error.
             // Regardless of the why, update our state to Idle as we should not expect the operation to continue.
-            self.state = State::Idle;
-            self.coordinator_selector.ongoing_operation = false;
             self.process_operation_results(stacks_client, &operation_results);
             self.send_operation_results(res, operation_results);
+            self.finish_operation();
         } else if !packets.is_empty() && self.coordinator.state != CoordinatorState::Idle {
-            // We have received a message. Update the last message time for the coordinator
-            self.coordinator_selector.update_last_message_time();
-            self.state = State::OperationInProgress;
+            // We have received a message and are in the middle of an operation. Update our state accordingly
+            self.update_operation();
         }
         self.send_outbound_messages(signer_outbound_messages);
         self.send_outbound_messages(coordinator_outbound_messages);

From 7784cafdeee12a7c8adea0c27fd6f2039bec1aa3 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 14 Feb 2024 11:16:44 -0500
Subject: [PATCH 0892/1166] Update coordinator id only once per run loop

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/stacks_client.rs | 26 ++++++++--------
 stacks-signer/src/coordinator.rs          | 36 +++++++++++++----------
 stacks-signer/src/runloop.rs              | 12 ++++++++
 stacks-signer/src/signer.rs               | 13 +++-----
 testnet/stacks-node/src/tests/signer.rs   |  5 ++--
 5 files changed, 50 insertions(+), 42 deletions(-)

diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index 98be2ff981..3c1b83bf35 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -121,8 +121,8 @@ impl StacksClient {
     pub fn calculate_coordinator_ids(&self, public_keys: &PublicKeys) -> Vec<u32> {
         // TODO: return the entire list. Might be at the same block height for a long time and need to move to the second item in the list
         // Add logic throughout signer to track the current coordinator list and offset in the list
-        let stacks_tip_consensus_hash = match retry_with_exponential_backoff(|| {
-            self.get_stacks_tip_consensus_hash()
+        let pox_consensus_hash = match retry_with_exponential_backoff(|| {
+            self.get_pox_consenus_hash()
                 .map_err(backoff::Error::transient)
         }) {
             Ok(hash) => hash,
@@ -134,20 +134,18 @@ impl StacksClient {
                 return default_coordinator_list;
             }
         };
-        debug!(
-            "Using stacks_tip_consensus_hash {stacks_tip_consensus_hash:?} for selecting coordinator"
-        );
+        debug!("Using pox_consensus_hash {pox_consensus_hash:?} for selecting coordinator");
 
-        // Create combined hash of each signer's public key with stacks_tip_consensus_hash
+        // Create combined hash of each signer's public key with pox_consensus_hash
         let mut selection_ids = public_keys
             .signers
             .iter()
             .map(|(&id, pk)| {
                 let pk_bytes = pk.to_bytes();
                 let mut buffer =
-                    Vec::with_capacity(pk_bytes.len() + stacks_tip_consensus_hash.as_bytes().len());
+                    Vec::with_capacity(pk_bytes.len() + pox_consensus_hash.as_bytes().len());
                 buffer.extend_from_slice(&pk_bytes[..]);
-                buffer.extend_from_slice(stacks_tip_consensus_hash.as_bytes());
+                buffer.extend_from_slice(pox_consensus_hash.as_bytes());
                 let digest = Sha256Sum::from_data(&buffer).as_bytes().to_vec();
                 (id, digest)
             })
@@ -225,10 +223,10 @@ impl StacksClient {
         self.parse_aggregate_public_key(value)
     }
 
-    /// Retrieve the stacks tip consensus hash from the stacks node
-    pub fn get_stacks_tip_consensus_hash(&self) -> Result<ConsensusHash, ClientError> {
+    /// Retrieve the pox consensus hash from the stacks node
+    pub fn get_pox_consenus_hash(&self) -> Result<ConsensusHash, ClientError> {
         let peer_info = self.get_peer_info()?;
-        Ok(peer_info.stacks_tip_consensus_hash)
+        Ok(peer_info.pox_consensus)
     }
 
     /// Retrieve the stacks node current epoch on a retry
@@ -1062,17 +1060,17 @@ mod tests {
     #[test]
     fn core_info_call_for_consensus_hash_should_succeed() {
         let mock = MockServerClient::new();
-        let h = spawn(move || mock.client.get_stacks_tip_consensus_hash());
+        let h = spawn(move || mock.client.get_pox_consenus_hash());
         let (response, peer_info) = build_get_peer_info_response(None, None);
         write_response(mock.server, response.as_bytes());
         let consensus_hash = h.join().unwrap().expect("Failed to deserialize response");
-        assert_eq!(consensus_hash, peer_info.stacks_tip_consensus_hash);
+        assert_eq!(consensus_hash, peer_info.pox_consensus);
     }
 
     #[test]
     fn core_info_call_with_invalid_response_should_fail() {
         let mock = MockServerClient::new();
-        let h = spawn(move || mock.client.get_stacks_tip_consensus_hash());
+        let h = spawn(move || mock.client.get_pox_consenus_hash());
         write_response(
             mock.server,
             b"HTTP/1.1 200 OK\n\n4e99f99bc4a05437abb8c7d0c306618f45b203196498e2ebe287f10497124958",
diff --git a/stacks-signer/src/coordinator.rs b/stacks-signer/src/coordinator.rs
index 12ee310305..3943be3a2a 100644
--- a/stacks-signer/src/coordinator.rs
+++ b/stacks-signer/src/coordinator.rs
@@ -22,10 +22,10 @@ use wsts::state_machine::PublicKeys;
 use crate::client::StacksClient;
 
 /// TODO: test this value and adjust as necessary. Maybe make configurable?
-pub const COORDINATOR_OPERATION_TIMEOUT_SECS: u64 = 500;
+pub const COORDINATOR_OPERATION_TIMEOUT_SECS: u64 = 300;
 
 /// TODO: test this value and adjust as necessary. Maybe make configurable?
-pub const COORDINATOR_TENURE_TIMEOUT_SECS: u64 = 1000;
+pub const COORDINATOR_TENURE_TIMEOUT_SECS: u64 = 600;
 
 /// The coordinator selector
 #[derive(Clone, Debug)]
@@ -97,24 +97,28 @@ impl Selector {
         self.last_message_time = None;
     }
 
-    /// Get the coordinator id and public key
-    pub fn get_coordinator(&mut self, stacks_client: &StacksClient) -> (u32, ecdsa::PublicKey) {
+    /// Check the coordinator timeouts and update the selected coordinator accordingly
+    /// Returns true if the coordinator was updated, else false
+    pub fn refresh_coordinator(&mut self, stacks_client: &StacksClient) -> bool {
+        let old_coordinator_id = self.coordinator_id;
         let new_coordinator_ids = stacks_client.calculate_coordinator_ids(&self.public_keys);
-        if self.tenure_start.elapsed().as_secs() > COORDINATOR_TENURE_TIMEOUT_SECS {
-            // We have exceeded our tenure. We should consider any operation finished and use a new coordinator id.
-            self.update_coordinator(new_coordinator_ids);
-        } else {
-            if let Some(time) = self.last_message_time {
-                if time.elapsed().as_secs() > COORDINATOR_OPERATION_TIMEOUT_SECS {
-                    // We have not received a message in a while from this coordinator.
-                    // We should consider the operation finished and use a new coordinator id.
-                    self.update_coordinator(new_coordinator_ids);
-                }
-            } else if new_coordinator_ids != self.coordinator_ids {
-                // We have advanced our block height and should select from the new list
+        if let Some(time) = self.last_message_time {
+            if time.elapsed().as_secs() > COORDINATOR_OPERATION_TIMEOUT_SECS {
+                // We have not received a message in a while from this coordinator.
+                // We should consider the operation finished and use a new coordinator id.
                 self.update_coordinator(new_coordinator_ids);
             }
+        } else if self.tenure_start.elapsed().as_secs() > COORDINATOR_TENURE_TIMEOUT_SECS
+            || new_coordinator_ids != self.coordinator_ids
+        {
+            // Our tenure has been exceeded or we have advanced our block height and should select from the new list
+            self.update_coordinator(new_coordinator_ids);
         }
+        old_coordinator_id != self.coordinator_id
+    }
+
+    /// Get the current coordinator id and public key
+    pub fn get_coordinator(&self) -> (u32, ecdsa::PublicKey) {
         (
             self.coordinator_id,
             self.public_keys
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 6bd2492dcf..e9730b9cc1 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -22,6 +22,7 @@ use hashbrown::HashMap;
 use libsigner::{SignerEvent, SignerRunLoop};
 use slog::{slog_debug, slog_error, slog_info, slog_warn};
 use stacks_common::{debug, error, info, warn};
+use wsts::state_machine::coordinator::State as CoordinatorState;
 use wsts::state_machine::OperationResult;
 
 use crate::client::{retry_with_exponential_backoff, ClientError, StacksClient};
@@ -213,6 +214,17 @@ impl RunLoop {
                 }
             }
             for stacks_signer in self.stacks_signers.values_mut() {
+                let updated_coordinator = stacks_signer
+                    .coordinator_selector
+                    .refresh_coordinator(&self.stacks_client);
+                if updated_coordinator {
+                    debug!(
+                        "Signer #{}: Coordinator has been updated. Resetting state to Idle.",
+                        stacks_signer.signer_id
+                    );
+                    stacks_signer.coordinator.state = CoordinatorState::Idle;
+                    stacks_signer.state = SignerState::Idle;
+                }
                 stacks_signer
                     .update_dkg(&self.stacks_client)
                     .map_err(backoff::Error::transient)?;
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index 55203a6fce..5d774c17f0 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -287,11 +287,7 @@ impl Signer {
 
     /// Attempt to process the next command in the queue, and update state accordingly
     pub fn process_next_command(&mut self, stacks_client: &StacksClient) {
-        let coordinator_id = self.coordinator_selector.get_coordinator(&stacks_client).0;
-        if self.coordinator_selector.last_message_time.is_none() {
-            self.state = State::Idle;
-            self.coordinator.state = CoordinatorState::Idle;
-        }
+        let coordinator_id = self.coordinator_selector.get_coordinator().0;
         match &self.state {
             State::Idle => {
                 if coordinator_id != self.signer_id {
@@ -390,7 +386,7 @@ impl Signer {
             };
             self.handle_packets(stacks_client, res, &[packet]);
         } else {
-            let coordinator_id = self.coordinator_selector.get_coordinator(&stacks_client).0;
+            let coordinator_id = self.coordinator_selector.get_coordinator().0;
             if block_info.valid.unwrap_or(false)
                 && !block_info.signed_over
                 && coordinator_id == self.signer_id
@@ -425,8 +421,7 @@ impl Signer {
         res: Sender<Vec<OperationResult>>,
         messages: &[SignerMessage],
     ) {
-        let (_coordinator_id, coordinator_pubkey) =
-            self.coordinator_selector.get_coordinator(&stacks_client);
+        let coordinator_pubkey = self.coordinator_selector.get_coordinator().1;
         let packets: Vec<Packet> = messages
             .iter()
             .filter_map(|msg| match msg {
@@ -1182,7 +1177,7 @@ impl Signer {
             self.coordinator
                 .set_aggregate_public_key(new_aggregate_public_key);
         }
-        let coordinator_id = self.coordinator_selector.get_coordinator(stacks_client).0;
+        let coordinator_id = self.coordinator_selector.get_coordinator().0;
         if new_aggregate_public_key.is_none()
             && self.signer_id == coordinator_id
             && self.state == State::Idle
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index ac894085e5..3c2f77d74c 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -215,12 +215,11 @@ impl SignerTest {
         self.running_nodes
             .run_loop_stopper
             .store(false, Ordering::SeqCst);
-
-        self.running_nodes.run_loop_thread.join().unwrap();
-        // Stop the signers
+        // Stop the signers before the node to prevent hanging
         for signer in self.running_signers {
             assert!(signer.stop().is_none());
         }
+        self.running_nodes.run_loop_thread.join().unwrap();
     }
 }
 

From 406c44244c5fde973702611aeab97911f3d09df5 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 14 Feb 2024 12:35:50 -0500
Subject: [PATCH 0893/1166] Update contract calls and update signer state when
 a nonce request is stashed

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/mod.rs           |  4 +--
 stacks-signer/src/client/stacks_client.rs | 30 ++++++++--------
 stacks-signer/src/signer.rs               | 43 ++++++++++++-----------
 testnet/stacks-node/src/tests/signer.rs   | 21 ++++-------
 4 files changed, 47 insertions(+), 51 deletions(-)

diff --git a/stacks-signer/src/client/mod.rs b/stacks-signer/src/client/mod.rs
index 3addb04d29..625d420912 100644
--- a/stacks-signer/src/client/mod.rs
+++ b/stacks-signer/src/client/mod.rs
@@ -330,8 +330,8 @@ pub(crate) mod tests {
         (format!("HTTP/1.1 200 Ok\n\n{pox_info_json}"), pox_info)
     }
 
-    /// Build a response for the get_aggregate_public_key request
-    pub fn build_get_aggregate_public_key_response(point: Option<Point>) -> String {
+    /// Build a response for the get_approved_aggregate_key request
+    pub fn build_get_approved_aggregate_key_response(point: Option<Point>) -> String {
         let clarity_value = if let Some(point) = point {
             ClarityValue::some(
                 ClarityValue::buff_from(point.compress().as_bytes().to_vec())
diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index 3c1b83bf35..8d9f49d532 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -17,7 +17,7 @@ use std::net::SocketAddr;
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 use blockstack_lib::burnchains::Txid;
 use blockstack_lib::chainstate::nakamoto::NakamotoBlock;
-use blockstack_lib::chainstate::stacks::boot::{RewardSet, POX_4_NAME, SIGNERS_VOTING_NAME};
+use blockstack_lib::chainstate::stacks::boot::{RewardSet, SIGNERS_VOTING_NAME};
 use blockstack_lib::chainstate::stacks::{
     StacksTransaction, StacksTransactionSigner, TransactionAnchorMode, TransactionAuth,
     TransactionContractCall, TransactionPayload, TransactionPostConditionMode,
@@ -296,13 +296,13 @@ impl StacksClient {
         Ok(())
     }
 
-    /// Retrieve the DKG aggregate public key for the given reward cycle
-    pub fn get_aggregate_public_key(
+    /// Retrieve the approved DKG aggregate public key for the given reward cycle
+    pub fn get_approved_aggregate_key(
         &self,
         reward_cycle: u64,
     ) -> Result<Option<Point>, ClientError> {
-        let function_name = ClarityName::from("get-aggregate-public-key");
-        let pox_contract_id = boot_code_id(POX_4_NAME, self.mainnet);
+        let function_name = ClarityName::from("get-approved-aggregate-key");
+        let pox_contract_id = boot_code_id(SIGNERS_VOTING_NAME, self.mainnet);
         let function_args = &[ClarityValue::UInt(reward_cycle as u128)];
         let value = self.read_only_contract_call(
             &pox_contract_id.issuer.into(),
@@ -563,6 +563,7 @@ impl StacksClient {
         signer_index: u32,
         round: u64,
         point: Point,
+        reward_cycle: u64,
         tx_fee: Option<u64>,
     ) -> Result<StacksTransaction, ClientError> {
         debug!("Building {VOTE_FUNCTION_NAME} transaction...");
@@ -575,6 +576,7 @@ impl StacksClient {
             ClarityValue::UInt(signer_index as u128),
             ClarityValue::buff_from(point.compress().data.to_vec())?,
             ClarityValue::UInt(round as u128),
+            ClarityValue::UInt(reward_cycle as u128),
         ];
 
         let tx_payload = TransactionPayload::ContractCall(TransactionContractCall {
@@ -791,7 +793,7 @@ mod tests {
 
     use super::*;
     use crate::client::tests::{
-        build_account_nonce_response, build_get_aggregate_public_key_response,
+        build_account_nonce_response, build_get_approved_aggregate_key_response,
         build_get_last_round_response, build_get_peer_info_response, build_get_pox_data_response,
         build_read_only_response, generate_random_consensus_hash, generate_signer_config,
         write_response, MockServerClient,
@@ -919,16 +921,16 @@ mod tests {
     #[test]
     fn get_aggregate_public_key_should_succeed() {
         let orig_point = Point::from(Scalar::random(&mut rand::thread_rng()));
-        let response = build_get_aggregate_public_key_response(Some(orig_point));
+        let response = build_get_approved_aggregate_key_response(Some(orig_point));
         let mock = MockServerClient::new();
-        let h = spawn(move || mock.client.get_aggregate_public_key(0));
+        let h = spawn(move || mock.client.get_approved_aggregate_key(0));
         write_response(mock.server, response.as_bytes());
         let res = h.join().unwrap().unwrap();
         assert_eq!(res, Some(orig_point));
 
-        let response = build_get_aggregate_public_key_response(None);
+        let response = build_get_approved_aggregate_key_response(None);
         let mock = MockServerClient::new();
-        let h = spawn(move || mock.client.get_aggregate_public_key(0));
+        let h = spawn(move || mock.client.get_approved_aggregate_key(0));
         write_response(mock.server, response.as_bytes());
         let res = h.join().unwrap().unwrap();
         assert!(res.is_none());
@@ -1025,7 +1027,7 @@ mod tests {
 
         let h = spawn(move || {
             mock.client
-                .build_vote_for_aggregate_public_key(0, 0, point, None)
+                .build_vote_for_aggregate_public_key(0, 0, point, 0, None)
         });
         write_response(mock.server, account_nonce_response.as_bytes());
         assert!(h.join().unwrap().is_ok());
@@ -1044,7 +1046,7 @@ mod tests {
             let tx = mock
                 .client
                 .clone()
-                .build_vote_for_aggregate_public_key(0, 0, point, None)
+                .build_vote_for_aggregate_public_key(0, 0, point, 0, None)
                 .unwrap();
             mock.client.submit_transaction(&tx)
         });
@@ -1396,7 +1398,7 @@ mod tests {
         let mock = MockServerClient::new();
         let point = Point::from(Scalar::random(&mut rand::thread_rng()));
         let stacks_address = mock.client.stacks_address;
-        let key_response = build_get_aggregate_public_key_response(Some(point));
+        let key_response = build_get_approved_aggregate_key_response(Some(point));
         let h = spawn(move || {
             mock.client
                 .get_vote_for_aggregate_public_key(0, 0, stacks_address)
@@ -1406,7 +1408,7 @@ mod tests {
 
         let mock = MockServerClient::new();
         let stacks_address = mock.client.stacks_address;
-        let key_response = build_get_aggregate_public_key_response(None);
+        let key_response = build_get_approved_aggregate_key_response(None);
         let h = spawn(move || {
             mock.client
                 .get_vote_for_aggregate_public_key(0, 0, stacks_address)
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index 5d774c17f0..be1232592c 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -563,6 +563,8 @@ impl Signer {
         let Some(block_info) = self.blocks.get_mut(&signer_signature_hash) else {
             // We have not seen this block before. Cache it. Send a RPC to the stacks node to validate it.
             debug!("Signer #{}: We have received a block sign request for a block we have not seen before. Cache the nonce request and submit the block for validation...", self.signer_id);
+            // We need to update our state to OperationInProgress so we can respond to the nonce request from this signer once we get our validation back
+            self.update_operation();
             // Store the block in our cache
             self.blocks.insert(
                 signer_signature_hash,
@@ -778,21 +780,20 @@ impl Signer {
             // The signer has already voted for this round and reward cycle
             return Ok(false);
         }
-        // TODO: uncomment when reward cycle properly retrieved from transaction. Depends on contract update.
-        // let current_reward_cycle = stacks_client.get_current_reward_cycle()?;
-        // let next_reward_cycle = current_reward_cycle.wrapping_add(1);
-        // if reward_cycle != current_reward_cycle && reward_cycle != next_reward_cycle {
-        //     // The signer is attempting to vote for a reward cycle that is not the current or next reward cycle
-        //     return Ok(false);
-        // }
-        // let reward_set_calculated = stacks_client.reward_set_calculated(next_reward_cycle)?;
-        // if !reward_set_calculated {
-        //     // The signer is attempting to vote for a reward cycle that has not yet had its reward set calculated
-        //     return Ok(false);
-        // }
+        let current_reward_cycle = stacks_client.get_current_reward_cycle()?;
+        let next_reward_cycle = current_reward_cycle.wrapping_add(1);
+        if reward_cycle != current_reward_cycle && reward_cycle != next_reward_cycle {
+            // The signer is attempting to vote for a reward cycle that is not the current or next reward cycle
+            return Ok(false);
+        }
+        let reward_set_calculated = stacks_client.reward_set_calculated(next_reward_cycle)?;
+        if !reward_set_calculated {
+            // The signer is attempting to vote for a reward cycle that has not yet had its reward set calculated
+            return Ok(false);
+        }
 
         let last_round = stacks_client.get_last_round(reward_cycle)?;
-        let aggregate_key = stacks_client.get_aggregate_public_key(reward_cycle)?;
+        let aggregate_key = stacks_client.get_approved_aggregate_key(reward_cycle)?;
 
         if let Some(last_round) = last_round {
             if aggregate_key.is_some() && round > last_round {
@@ -936,6 +937,7 @@ impl Signer {
             self.stackerdb.get_signer_slot_id(),
             self.coordinator.current_dkg_id,
             *point,
+            self.reward_cycle,
             tx_fee,
         ) {
             Ok(transaction) => {
@@ -1165,7 +1167,7 @@ impl Signer {
     /// Update the DKG for the provided signer info, triggering it if required
     pub fn update_dkg(&mut self, stacks_client: &StacksClient) -> Result<(), ClientError> {
         let reward_cycle = self.reward_cycle;
-        let new_aggregate_public_key = stacks_client.get_aggregate_public_key(reward_cycle)?;
+        let new_aggregate_public_key = stacks_client.get_approved_aggregate_key(reward_cycle)?;
         let old_aggregate_public_key = self.coordinator.get_aggregate_public_key();
         if new_aggregate_public_key.is_some()
             && old_aggregate_public_key != new_aggregate_public_key
@@ -1307,8 +1309,7 @@ impl Signer {
     }
 
     fn parse_function_args(function_args: &[ClarityValue]) -> Option<(u64, Point, u64, u64)> {
-        // TODO: parse out the reward cycle
-        if function_args.len() != 3 {
+        if function_args.len() != 4 {
             return None;
         }
         let signer_index_value = function_args.first()?;
@@ -1319,7 +1320,7 @@ impl Signer {
         let point = Point::try_from(&compressed_data).ok()?;
         let round_value = function_args.get(2)?;
         let round = u64::try_from(round_value.clone().expect_u128().ok()?).ok()?;
-        let reward_cycle = 0;
+        let reward_cycle = u64::try_from(function_args.get(3)?.clone().expect_u128().ok()?).ok()?;
         Some((signer_index, point, round, reward_cycle))
     }
 }
@@ -1354,7 +1355,7 @@ mod tests {
     use wsts::curve::scalar::Scalar;
 
     use crate::client::tests::{
-        build_get_aggregate_public_key_response, build_get_last_round_response,
+        build_get_approved_aggregate_key_response, build_get_last_round_response,
         generate_signer_config, mock_server_from_config, write_response,
     };
     use crate::client::{StacksClient, VOTE_FUNCTION_NAME};
@@ -1749,16 +1750,16 @@ mod tests {
                 .verify_payload(&stacks_client, &invalid_already_voted, signer.signer_id)
                 .unwrap())
         });
-        let vote_response = build_get_aggregate_public_key_response(Some(point));
+        let vote_response = build_get_approved_aggregate_key_response(Some(point));
         let mock_server = mock_server_from_config(&config);
         write_response(mock_server, vote_response.as_bytes());
         h.join().unwrap();
 
         let signer = Signer::from(signer_config);
 
-        let vote_response = build_get_aggregate_public_key_response(None);
+        let vote_response = build_get_approved_aggregate_key_response(None);
         let last_round_response = build_get_last_round_response(10);
-        let aggregate_public_key_response = build_get_aggregate_public_key_response(Some(point));
+        let aggregate_public_key_response = build_get_approved_aggregate_key_response(Some(point));
 
         let invalid_round_number = StacksClient::build_signed_contract_call_transaction(
             &contract_addr,
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index 3c2f77d74c..6418baa776 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -407,23 +407,9 @@ fn stackerdb_dkg_sign() {
 
     info!("Pox 4 activated and at epoch 3.0 reward set calculation (2nd block of its prepare phase)! Ready for signers to perform DKG and Sign!");
 
-    // Determine the coordinator
-    // we have just calculated the reward set for the next reward cycle hence the + 1
-    let reward_cycle = signer_test.get_current_reward_cycle().wrapping_add(1);
-    let coordinator_sender = signer_test.get_coordinator_sender(reward_cycle);
-
     info!("------------------------- Test DKG -------------------------");
-    info!("signer_runloop: spawn send commands to do DKG");
     let dkg_now = Instant::now();
     let mut key = Point::default();
-    let dkg_command = RunLoopCommand {
-        reward_cycle,
-        command: SignerCommand::Dkg,
-    };
-    coordinator_sender
-        .send(dkg_command)
-        .expect("failed to send DKG command");
-    info!("signer_runloop: waiting for DKG results");
     for recv in signer_test.result_receivers.iter() {
         let mut aggregate_public_key = None;
         loop {
@@ -633,6 +619,13 @@ fn stackerdb_block_proposal() {
     info!("------------------------- Test Block Processed -------------------------");
     let sign_now = Instant::now();
 
+    signer_test.run_until_epoch_3_boundary();
+    let reward_cycle = signer_test.get_current_reward_cycle();
+    let set_dkg = signer_test
+        .stacks_client
+        .get_approved_aggregate_key(reward_cycle)
+        .expect("Failed to get approved aggregate key");
+    assert_eq!(set_dkg.unwrap(), key);
     // Mine 1 nakamoto tenure
     let _ = next_block_and_mine_commit(
         &mut signer_test.running_nodes.btc_regtest_controller,

From e49764f33cdd1731bf986b088ac88ce815aa4cb9 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 14 Feb 2024 16:45:25 -0500
Subject: [PATCH 0894/1166] Fix nonce retrieval and pox consensus tests

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/mod.rs           |   7 +-
 stacks-signer/src/client/stacks_client.rs |  32 +-
 stacks-signer/src/signer.rs               |  31 ++
 testnet/stacks-node/src/tests/signer.rs   | 376 ++++++++++++----------
 4 files changed, 263 insertions(+), 183 deletions(-)

diff --git a/stacks-signer/src/client/mod.rs b/stacks-signer/src/client/mod.rs
index 625d420912..aaf03e1caf 100644
--- a/stacks-signer/src/client/mod.rs
+++ b/stacks-signer/src/client/mod.rs
@@ -347,7 +347,7 @@ pub(crate) mod tests {
     /// Build a response for the get_peer_info request with a specific stacks tip height and consensus hash
     pub fn build_get_peer_info_response(
         burn_block_height: Option<u64>,
-        stacks_tip_consensus_hash: Option<ConsensusHash>,
+        pox_consensus_hash: Option<ConsensusHash>,
     ) -> (String, RPCPeerInfoData) {
         // Generate some random info
         let private_key = StacksPrivateKey::new();
@@ -358,7 +358,7 @@ pub(crate) mod tests {
             vec![boot_code_id("fake", false), boot_code_id("fake_2", false)];
         let peer_info = RPCPeerInfoData {
             peer_version: thread_rng().next_u32(),
-            pox_consensus: generate_random_consensus_hash(),
+            pox_consensus: pox_consensus_hash.unwrap_or(generate_random_consensus_hash()),
             burn_block_height: burn_block_height.unwrap_or(thread_rng().next_u64()),
             stable_pox_consensus: generate_random_consensus_hash(),
             stable_burn_block_height: 2,
@@ -367,8 +367,7 @@ pub(crate) mod tests {
             parent_network_id: thread_rng().next_u32(),
             stacks_tip_height: thread_rng().next_u64(),
             stacks_tip: BlockHeaderHash([0x06; 32]),
-            stacks_tip_consensus_hash: stacks_tip_consensus_hash
-                .unwrap_or(generate_random_consensus_hash()),
+            stacks_tip_consensus_hash: generate_random_consensus_hash(),
             unanchored_tip: None,
             unanchored_seq: Some(0),
             exit_at_block_height: None,
diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index 8d9f49d532..492c3f5dd4 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -565,10 +565,9 @@ impl StacksClient {
         point: Point,
         reward_cycle: u64,
         tx_fee: Option<u64>,
+        nonce: u64,
     ) -> Result<StacksTransaction, ClientError> {
         debug!("Building {VOTE_FUNCTION_NAME} transaction...");
-        // TODO: this nonce should be calculated on the side as we may have pending transactions that are not yet confirmed...
-        let nonce = self.get_account_nonce(&self.stacks_address)?;
         let contract_address = boot_code_addr(self.mainnet);
         let contract_name = ContractName::from(SIGNERS_VOTING_NAME);
         let function_name = ClarityName::from(VOTE_FUNCTION_NAME);
@@ -1023,13 +1022,20 @@ mod tests {
         let mock = MockServerClient::new();
         let point = Point::from(Scalar::random(&mut rand::thread_rng()));
         let nonce = thread_rng().next_u64();
-        let account_nonce_response = build_account_nonce_response(nonce);
+        let signer_index = thread_rng().next_u32();
+        let round = thread_rng().next_u64();
+        let reward_cycle = thread_rng().next_u64();
 
         let h = spawn(move || {
-            mock.client
-                .build_vote_for_aggregate_public_key(0, 0, point, 0, None)
+            mock.client.build_vote_for_aggregate_public_key(
+                signer_index,
+                round,
+                point,
+                reward_cycle,
+                None,
+                nonce,
+            )
         });
-        write_response(mock.server, account_nonce_response.as_bytes());
         assert!(h.join().unwrap().is_ok());
     }
 
@@ -1040,17 +1046,25 @@ mod tests {
         let mock = MockServerClient::new();
         let point = Point::from(Scalar::random(&mut rand::thread_rng()));
         let nonce = thread_rng().next_u64();
-        let account_nonce_response = build_account_nonce_response(nonce);
+        let signer_index = thread_rng().next_u32();
+        let round = thread_rng().next_u64();
+        let reward_cycle = thread_rng().next_u64();
 
         let h = spawn(move || {
             let tx = mock
                 .client
                 .clone()
-                .build_vote_for_aggregate_public_key(0, 0, point, 0, None)
+                .build_vote_for_aggregate_public_key(
+                    signer_index,
+                    round,
+                    point,
+                    reward_cycle,
+                    None,
+                    nonce,
+                )
                 .unwrap();
             mock.client.submit_transaction(&tx)
         });
-        write_response(mock.server, account_nonce_response.as_bytes());
         let mock = MockServerClient::from_config(mock.config);
         write_response(
             mock.server,
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index be1232592c..f784a3b787 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -933,12 +933,15 @@ impl Signer {
         } else {
             None
         };
+        // Get our current nonce from the stacks node and compare it against what we have sitting in the stackerdb instance
+        let nonce = self.get_next_nonce(stacks_client);
         match stacks_client.build_vote_for_aggregate_public_key(
             self.stackerdb.get_signer_slot_id(),
             self.coordinator.current_dkg_id,
             *point,
             self.reward_cycle,
             tx_fee,
+            nonce,
         ) {
             Ok(transaction) => {
                 if let Err(e) = self.broadcast_dkg_vote(stacks_client, transaction, epoch) {
@@ -957,6 +960,33 @@ impl Signer {
         }
     }
 
+    /// Get the next available nonce, taking into consideration the nonce we have sitting in stackerdb as well as the account nonce
+    fn get_next_nonce(&mut self, stacks_client: &StacksClient) -> u64 {
+        let signer_address = stacks_client.get_signer_address();
+        let mut next_nonce = stacks_client
+            .get_account_nonce(signer_address)
+            .map_err(|e| {
+                warn!(
+                    "Signer #{}: Failed to get account nonce for signer: {e:?}",
+                    self.signer_id
+                );
+            })
+            .unwrap_or(0);
+
+        let current_transactions = self.get_filtered_transactions(stacks_client, &[self.signer_id]).map_err(|e| {
+            warn!("Signer #{}: Failed to get old transactions: {e:?}. Defaulting to account nonce.", self.signer_id);
+        }).unwrap_or_default();
+
+        for transaction in current_transactions {
+            let origin_nonce = transaction.get_origin_nonce();
+            let origin_address = transaction.origin_address();
+            if origin_address == *signer_address && origin_nonce >= next_nonce {
+                next_nonce = origin_nonce.wrapping_add(1);
+            }
+        }
+        next_nonce
+    }
+
     /// broadcast the dkg vote transaction according to the current epoch
     fn broadcast_dkg_vote(
         &mut self,
@@ -1627,6 +1657,7 @@ mod tests {
     }
 
     #[test]
+    #[ignore]
     #[serial]
     fn verify_transaction_payload_filters_invalid_payloads() {
         // Create a runloop of a valid signer
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index 6418baa776..8d96e80eff 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -35,8 +35,11 @@ use stacks_signer::runloop::RunLoopCommand;
 use stacks_signer::signer::Command as SignerCommand;
 use tracing_subscriber::prelude::*;
 use tracing_subscriber::{fmt, EnvFilter};
+use wsts::common::Signature;
+use wsts::compute::tweaked_public_key;
 use wsts::curve::point::Point;
 use wsts::state_machine::OperationResult;
+use wsts::taproot::SchnorrProof;
 
 use crate::config::{Config as NeonConfig, EventKeyType, EventObserverConfig, InitialBalance};
 use crate::neon::Counters;
@@ -82,16 +85,15 @@ struct SignerTest {
 }
 
 impl SignerTest {
-    fn new(num_signers: usize, disable_signing_key: bool) -> Self {
+    fn new(num_signers: usize) -> Self {
         // Generate Signer Data
         let signer_stacks_private_keys = (0..num_signers)
             .map(|_| StacksPrivateKey::new())
             .collect::<Vec<StacksPrivateKey>>();
 
         let (mut naka_conf, _miner_account) = naka_neon_integration_conf(None);
-        if disable_signing_key {
-            naka_conf.miner.self_signing_key = None;
-        }
+        naka_conf.miner.self_signing_key = None;
+
         // Setup the signer and coordinator configurations
         let signer_configs = build_signer_config_tomls(
             &signer_stacks_private_keys,
@@ -131,6 +133,128 @@ impl SignerTest {
         }
     }
 
+    fn wait_for_dkg(&mut self, timeout: Duration) -> Point {
+        let mut key = Point::default();
+        let dkg_now = Instant::now();
+        for recv in self.result_receivers.iter() {
+            let mut aggregate_public_key = None;
+            loop {
+                let results = recv
+                    .recv_timeout(timeout)
+                    .expect("failed to recv dkg results");
+                for result in results {
+                    match result {
+                        OperationResult::Sign(sig) => {
+                            panic!("Received Signature ({},{})", &sig.R, &sig.z);
+                        }
+                        OperationResult::SignTaproot(proof) => {
+                            panic!("Received SchnorrProof ({},{})", &proof.r, &proof.s);
+                        }
+                        OperationResult::DkgError(dkg_error) => {
+                            panic!("Received DkgError {:?}", dkg_error);
+                        }
+                        OperationResult::SignError(sign_error) => {
+                            panic!("Received SignError {}", sign_error);
+                        }
+                        OperationResult::Dkg(point) => {
+                            info!("Received aggregate_group_key {point}");
+                            aggregate_public_key = Some(point);
+                        }
+                    }
+                }
+                if aggregate_public_key.is_some() || dkg_now.elapsed() > timeout {
+                    break;
+                }
+            }
+            key = aggregate_public_key.expect(&format!(
+                "Failed to get aggregate public key within {timeout:?}"
+            ));
+        }
+        key
+    }
+
+    fn wait_for_frost_signatures(&mut self, timeout: Duration) -> Vec<Signature> {
+        let mut results = Vec::new();
+        let sign_now = Instant::now();
+        for recv in self.result_receivers.iter() {
+            let mut frost_signature = None;
+            loop {
+                let results = recv
+                    .recv_timeout(timeout)
+                    .expect("failed to recv signature results");
+                for result in results {
+                    match result {
+                        OperationResult::Sign(sig) => {
+                            info!("Received Signature ({},{})", &sig.R, &sig.z);
+                            frost_signature = Some(sig);
+                        }
+                        OperationResult::SignTaproot(proof) => {
+                            panic!("Received SchnorrProof ({},{})", &proof.r, &proof.s);
+                        }
+                        OperationResult::DkgError(dkg_error) => {
+                            panic!("Received DkgError {:?}", dkg_error);
+                        }
+                        OperationResult::SignError(sign_error) => {
+                            panic!("Received SignError {}", sign_error);
+                        }
+                        OperationResult::Dkg(point) => {
+                            panic!("Received aggregate_group_key {point}");
+                        }
+                    }
+                }
+                if frost_signature.is_some() || sign_now.elapsed() > timeout {
+                    break;
+                }
+            }
+
+            let frost_signature = frost_signature
+                .expect(&format!("Failed to get frost signature within {timeout:?}"));
+            results.push(frost_signature);
+        }
+        results
+    }
+
+    fn wait_for_taproot_signatures(&mut self, timeout: Duration) -> Vec<SchnorrProof> {
+        let mut results = vec![];
+        let sign_now = Instant::now();
+        for recv in self.result_receivers.iter() {
+            let mut schnorr_proof = None;
+            loop {
+                let results = recv
+                    .recv_timeout(timeout)
+                    .expect("failed to recv signature results");
+                for result in results {
+                    match result {
+                        OperationResult::Sign(sig) => {
+                            panic!("Received Signature ({},{})", &sig.R, &sig.z);
+                        }
+                        OperationResult::SignTaproot(proof) => {
+                            info!("Received SchnorrProof ({},{})", &proof.r, &proof.s);
+                            schnorr_proof = Some(proof);
+                        }
+                        OperationResult::DkgError(dkg_error) => {
+                            panic!("Received DkgError {:?}", dkg_error);
+                        }
+                        OperationResult::SignError(sign_error) => {
+                            panic!("Received SignError {}", sign_error);
+                        }
+                        OperationResult::Dkg(point) => {
+                            panic!("Received aggregate_group_key {point}");
+                        }
+                    }
+                }
+                if schnorr_proof.is_some() || sign_now.elapsed() > timeout {
+                    break;
+                }
+            }
+            let schnorr_proof = schnorr_proof.expect(&format!(
+                "Failed to get schnorr proof signature within {timeout:?}"
+            ));
+            results.push(schnorr_proof);
+        }
+        results
+    }
+
     fn run_until_epoch_3_boundary(&mut self) {
         let epochs = self.running_nodes.conf.burnchain.epochs.clone().unwrap();
         let epoch_3 =
@@ -394,8 +518,7 @@ fn stackerdb_dkg_sign() {
     msg.push(b'n');
 
     let timeout = Duration::from_secs(200);
-    let mut signer_test = SignerTest::new(10, false);
-
+    let mut signer_test = SignerTest::new(10);
     info!("Boot to epoch 3.0 reward calculation...");
     boot_to_epoch_3_reward_set(
         &signer_test.running_nodes.conf,
@@ -407,50 +530,45 @@ fn stackerdb_dkg_sign() {
 
     info!("Pox 4 activated and at epoch 3.0 reward set calculation (2nd block of its prepare phase)! Ready for signers to perform DKG and Sign!");
 
+    // First wait for the automatically triggered DKG to complete
+    let key = signer_test.wait_for_dkg(timeout);
+
     info!("------------------------- Test DKG -------------------------");
+
+    // We are voting for the NEXT reward cycle hence the + 1;
+    let reward_cycle = signer_test.get_current_reward_cycle().saturating_add(1);
+    let coordinator_sender = signer_test.get_coordinator_sender(reward_cycle);
+
     let dkg_now = Instant::now();
-    let mut key = Point::default();
-    for recv in signer_test.result_receivers.iter() {
-        let mut aggregate_public_key = None;
-        loop {
-            let results = recv
-                .recv_timeout(timeout)
-                .expect("failed to recv dkg results");
-            for result in results {
-                match result {
-                    OperationResult::Sign(sig) => {
-                        panic!("Received Signature ({},{})", &sig.R, &sig.z);
-                    }
-                    OperationResult::SignTaproot(proof) => {
-                        panic!("Received SchnorrProof ({},{})", &proof.r, &proof.s);
-                    }
-                    OperationResult::DkgError(dkg_error) => {
-                        panic!("Received DkgError {:?}", dkg_error);
-                    }
-                    OperationResult::SignError(sign_error) => {
-                        panic!("Received SignError {}", sign_error);
-                    }
-                    OperationResult::Dkg(point) => {
-                        info!("Received aggregate_group_key {point}");
-                        aggregate_public_key = Some(point);
-                    }
-                }
-            }
-            if aggregate_public_key.is_some() || dkg_now.elapsed() > timeout {
-                break;
-            }
-        }
-        key = aggregate_public_key.expect(&format!(
-            "Failed to get aggregate public key within {timeout:?}"
-        ));
-    }
+    coordinator_sender
+        .send(RunLoopCommand {
+            reward_cycle,
+            command: SignerCommand::Dkg,
+        })
+        .expect("failed to send DKG command");
+    let new_key = signer_test.wait_for_dkg(timeout);
     let dkg_elapsed = dkg_now.elapsed();
+    assert_ne!(new_key, key);
+
+    // Verify that we haven't mined the DKG key yet
+    assert!(signer_test
+        .stacks_client
+        .get_approved_aggregate_key(reward_cycle)
+        .expect("Failed to get approved aggregate key")
+        .is_none());
 
+    // Advance and mine the DKG key block
     signer_test.run_until_epoch_3_boundary();
 
+    let set_key = signer_test
+        .stacks_client
+        .get_approved_aggregate_key(reward_cycle)
+        .expect("Failed to get approved aggregate key")
+        .expect("No approved aggregate key found");
+    assert_eq!(set_key, key);
+
     info!("------------------------- Test Sign -------------------------");
     // Determine the coordinator of the current node height
-    let reward_cycle = signer_test.get_current_reward_cycle();
     let coordinator_sender = signer_test.get_coordinator_sender(reward_cycle);
 
     let sign_now = Instant::now();
@@ -477,52 +595,15 @@ fn stackerdb_dkg_sign() {
     coordinator_sender
         .send(sign_taproot_command)
         .expect("failed to send Sign taproot command");
-    for recv in signer_test.result_receivers.iter() {
-        let mut frost_signature = None;
-        let mut schnorr_proof = None;
-        loop {
-            let results = recv
-                .recv_timeout(timeout)
-                .expect("failed to recv signature results");
-            for result in results {
-                match result {
-                    OperationResult::Sign(sig) => {
-                        info!("Received Signature ({},{})", &sig.R, &sig.z);
-                        frost_signature = Some(sig);
-                    }
-                    OperationResult::SignTaproot(proof) => {
-                        info!("Received SchnorrProof ({},{})", &proof.r, &proof.s);
-                        schnorr_proof = Some(proof);
-                    }
-                    OperationResult::DkgError(dkg_error) => {
-                        panic!("Received DkgError {:?}", dkg_error);
-                    }
-                    OperationResult::SignError(sign_error) => {
-                        panic!("Received SignError {}", sign_error);
-                    }
-                    OperationResult::Dkg(point) => {
-                        panic!("Received aggregate_group_key {point}");
-                    }
-                }
-            }
-            if (frost_signature.is_some() && schnorr_proof.is_some())
-                || sign_now.elapsed() > timeout
-            {
-                break;
-            }
-        }
-        let frost_signature =
-            frost_signature.expect(&format!("Failed to get frost signature within {timeout:?}"));
-        assert!(
-            frost_signature.verify(&key, msg.as_slice()),
-            "Signature verification failed"
-        );
-        let schnorr_proof = schnorr_proof.expect(&format!(
-            "Failed to get schnorr proof signature within {timeout:?}"
-        ));
-        let tweaked_key = wsts::compute::tweaked_public_key(&key, None);
+    let frost_signatures = signer_test.wait_for_frost_signatures(timeout);
+    let schnorr_proofs = signer_test.wait_for_taproot_signatures(timeout);
+    for forst_signature in frost_signatures {
+        assert!(forst_signature.verify(&set_key, &msg));
+    }
+    for schnorr_proof in schnorr_proofs {
+        let tweaked_key = tweaked_public_key(&set_key, None);
         assert!(
-            schnorr_proof.verify(&tweaked_key.x(), &msg.as_slice()),
+            schnorr_proof.verify(&tweaked_key.x(), &msg),
             "Schnorr proof verification failed"
         );
     }
@@ -562,7 +643,7 @@ fn stackerdb_block_proposal() {
         .init();
 
     info!("------------------------- Test Setup -------------------------");
-    let mut signer_test = SignerTest::new(5, true);
+    let mut signer_test = SignerTest::new(5);
     let timeout = Duration::from_secs(200);
     let (_vrfs_submitted, commits_submitted) = (
         signer_test.running_nodes.vrfs_submitted.clone(),
@@ -579,101 +660,39 @@ fn stackerdb_block_proposal() {
     info!("------------------------- Wait for DKG -------------------------");
     info!("signer_runloop: spawn send commands to do dkg");
     let dkg_now = Instant::now();
-    let mut key = Point::default();
-    for recv in signer_test.result_receivers.iter() {
-        let mut aggregate_public_key = None;
-        loop {
-            let results = recv
-                .recv_timeout(timeout)
-                .expect("failed to recv dkg results");
-            for result in results {
-                match result {
-                    OperationResult::Sign(sig) => {
-                        panic!("Received Signature ({},{})", &sig.R, &sig.z);
-                    }
-                    OperationResult::SignTaproot(proof) => {
-                        panic!("Received SchnorrProof ({},{})", &proof.r, &proof.s);
-                    }
-                    OperationResult::DkgError(dkg_error) => {
-                        panic!("Received DkgError {:?}", dkg_error);
-                    }
-                    OperationResult::SignError(sign_error) => {
-                        panic!("Received SignError {}", sign_error);
-                    }
-                    OperationResult::Dkg(point) => {
-                        info!("Received aggregate_group_key {point}");
-                        aggregate_public_key = Some(point);
-                    }
-                }
-            }
-            if aggregate_public_key.is_some() || dkg_now.elapsed() > timeout {
-                break;
-            }
-        }
-        key = aggregate_public_key.expect(&format!(
-            "Failed to get aggregate public key within {timeout:?}"
-        ));
-    }
+    let key = signer_test.wait_for_dkg(timeout);
     let dkg_elapsed = dkg_now.elapsed();
 
-    info!("------------------------- Test Block Processed -------------------------");
-    let sign_now = Instant::now();
-
+    info!("------------------------- Verify DKG -------------------------");
     signer_test.run_until_epoch_3_boundary();
+
     let reward_cycle = signer_test.get_current_reward_cycle();
     let set_dkg = signer_test
         .stacks_client
         .get_approved_aggregate_key(reward_cycle)
-        .expect("Failed to get approved aggregate key");
-    assert_eq!(set_dkg.unwrap(), key);
+        .expect("Failed to get approved aggregate key")
+        .expect("No approved aggregate key found");
+    assert_eq!(set_dkg, key);
+
+    info!("------------------------- Verify Nakamoto Block Proposed -------------------------");
+    let sign_now = Instant::now();
     // Mine 1 nakamoto tenure
     let _ = next_block_and_mine_commit(
         &mut signer_test.running_nodes.btc_regtest_controller,
-        10, // We know that it will never actually mine the block right now
+        60,
         &signer_test.running_nodes.coord_channel,
         &commits_submitted,
     );
-
-    // TODO: confirm that the contract has updated its DKG key to the resulting "key"
-
-    let recv = signer_test
-        .result_receivers
-        .last()
-        .expect("Failed to retreive coordinator recv");
-    let results = recv
-        .recv_timeout(timeout)
-        .expect("failed to recv signature results");
-    let mut signature = None;
-    for result in results {
-        match result {
-            OperationResult::Sign(sig) => {
-                info!("Received Signature ({},{})", &sig.R, &sig.z);
-                signature = Some(sig);
-                break;
-            }
-            OperationResult::Dkg(point) => {
-                debug!("Received a dkg result {point:?}");
-                continue;
-            }
-            OperationResult::DkgError(dkg_error) => {
-                panic!("Received DkgError {:?}", dkg_error);
-            }
-            OperationResult::SignError(sign_error) => {
-                panic!("Received SignError {}", sign_error);
-            }
-            OperationResult::SignTaproot(proof) => {
-                panic!("Received SchnorrProof ({},{})", &proof.r, &proof.s);
-            }
-        }
-    }
+    let frost_signatures = signer_test.wait_for_frost_signatures(timeout);
     let sign_elapsed = sign_now.elapsed();
-    let signature = signature.expect("Failed to get signature");
+
+    info!("------------------------- Verify Block Proposal Response -------------------------");
     // Wait for the block to show up in the test observer (Don't have to wait long as if we have received a signature,
     // we know that the signers have already received their block proposal events via their event observers)
     let t_start = Instant::now();
     while test_observer::get_proposal_responses().is_empty() {
         assert!(
-            t_start.elapsed() < Duration::from_secs(30),
+            t_start.elapsed() < timeout,
             "Timed out while waiting for block proposal event"
         );
         thread::sleep(Duration::from_secs(1));
@@ -684,10 +703,14 @@ fn stackerdb_block_proposal() {
             BlockValidateResponse::Ok(block_validated) => block_validated.signer_signature_hash,
             _ => panic!("Unexpected response"),
         };
-    assert!(
-        signature.verify(&key, proposed_signer_signature_hash.0.as_slice()),
-        "Signature verification failed"
-    );
+    for signature in &frost_signatures {
+        assert!(
+            signature.verify(&key, proposed_signer_signature_hash.0.as_slice()),
+            "Signature verification failed"
+        );
+    }
+
+    info!("------------------------- Verify Block Signature Returned to Miners -------------------------");
     // Verify that the signers broadcasted a signed NakamotoBlock back to the .signers contract
     let t_start = Instant::now();
     let mut chunk = None;
@@ -724,10 +747,23 @@ fn stackerdb_block_proposal() {
     ))) = signer_message
     {
         assert_eq!(block_signer_signature_hash, proposed_signer_signature_hash);
-        assert_eq!(block_signature, ThresholdSignature(signature));
+        assert_eq!(
+            block_signature,
+            ThresholdSignature(frost_signatures.first().expect("No signature").clone())
+        );
     } else {
         panic!("Received unexpected message");
     }
+
+    info!("------------------------- Verify Nakamoto Block Mined -------------------------");
+    while test_observer::get_mined_nakamoto_blocks().is_empty() {
+        assert!(
+            t_start.elapsed() < timeout,
+            "Timed out while waiting for mined nakamoto block event"
+        );
+        thread::sleep(Duration::from_secs(1));
+    }
+
     signer_test.shutdown();
 
     info!("DKG Time Elapsed: {:.2?}", dkg_elapsed);
@@ -762,7 +798,7 @@ fn stackerdb_block_proposal_missing_transactions() {
         .init();
 
     info!("------------------------- Test Setup -------------------------");
-    let mut signer_test = SignerTest::new(5, false);
+    let mut signer_test = SignerTest::new(5);
 
     let host = signer_test
         .running_nodes

From 5ad797514e1336758eccfdf6d8b3152202da5ce8 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 14 Feb 2024 18:40:26 -0500
Subject: [PATCH 0895/1166] Fix transaction logic and fix block proposal test

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stackslib/src/chainstate/stacks/boot/mod.rs   |  38 ++++++-
 .../stacks-node/src/nakamoto_node/miner.rs    | 100 ++++++++++++++----
 testnet/stacks-node/src/run_loop/neon.rs      |   2 +-
 testnet/stacks-node/src/tests/signer.rs       |  48 +++++++--
 4 files changed, 159 insertions(+), 29 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 3a1c77f97e..9e1f5d5922 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -16,7 +16,7 @@
 
 use std::boxed::Box;
 use std::cmp;
-use std::collections::BTreeMap;
+use std::collections::{BTreeMap, HashMap};
 use std::convert::{TryFrom, TryInto};
 
 use clarity::vm::analysis::CheckErrors;
@@ -1308,6 +1308,42 @@ impl StacksChainState {
         };
         Ok(aggregate_public_key)
     }
+
+    /// Get the signer addresses and corresponding weights for a given reward cycle
+    pub fn get_signers_weights(
+        &mut self,
+        sortdb: &SortitionDB,
+        block_id: &StacksBlockId,
+        reward_cycle: u64,
+    ) -> Result<HashMap<StacksAddress, u64>, Error> {
+        let signers_opt = self
+            .eval_boot_code_read_only(
+                sortdb,
+                block_id,
+                SIGNERS_NAME,
+                &format!("(get-signers u{})", reward_cycle),
+            )?
+            .expect_optional()?;
+        let mut signers = HashMap::new();
+        if let Some(signers_list) = signers_opt {
+            for signer in signers_list.expect_list()? {
+                let signer_tuple = signer.expect_tuple()?;
+                let principal_data = signer_tuple.get("signer")?.clone().expect_principal()?;
+                let signer_address = if let PrincipalData::Standard(signer) = principal_data {
+                    signer.into()
+                } else {
+                    panic!(
+                        "FATAL: Signer returned from get-signers is not a standard principal: {:?}",
+                        principal_data
+                    );
+                };
+                let weight = u64::try_from(signer_tuple.get("weight")?.to_owned().expect_u128()?)
+                    .expect("FATAL: Signer weight greater than a u64::MAX");
+                signers.insert(signer_address, weight);
+            }
+        }
+        Ok(signers)
+    }
 }
 
 #[cfg(test)]
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index 2f5e09fd0d..5afaf32f23 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -1,3 +1,4 @@
+use std::collections::HashMap;
 // Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
 // Copyright (C) 2020-2023 Stacks Open Internet Foundation
 //
@@ -19,6 +20,7 @@ use std::thread::JoinHandle;
 use std::time::{Duration, Instant};
 
 use clarity::boot_util::boot_code_id;
+use clarity::vm::clarity::ClarityConnection;
 use clarity::vm::types::{PrincipalData, QualifiedContractIdentifier};
 use hashbrown::HashSet;
 use libsigner::{
@@ -261,7 +263,7 @@ impl BlockMinerThread {
         &self,
         stackerdbs: &StackerDBs,
         msg_id: u32,
-    ) -> Result<(QualifiedContractIdentifier, Vec<u32>), NakamotoNodeError> {
+    ) -> Result<(QualifiedContractIdentifier, HashMap<u32, StacksAddress>), NakamotoNodeError> {
         let stackerdb_contracts = stackerdbs
             .get_stackerdb_contract_ids()
             .expect("FATAL: could not get the stacker DB contract ids");
@@ -281,25 +283,35 @@ impl BlockMinerThread {
                 "No signers contract found, cannot wait for signers",
             ));
         };
-        // Get the block slot for every signer
-        let slot_ids = stackerdbs
+        // Get the slots for every signer
+        let signers = stackerdbs
+            .get_signers(&signers_contract_id)
+            .expect("FATAL: could not get signers from stacker DB");
+        let mut slot_ids_addresses = HashMap::with_capacity(signers.len());
+        for (slot_id, address) in stackerdbs
             .get_signers(&signers_contract_id)
             .expect("FATAL: could not get signers from stacker DB")
-            .iter()
+            .into_iter()
             .enumerate()
-            .map(|(id, _)| {
-                u32::try_from(id).expect("FATAL: too many signers to fit into u32 range")
-            })
-            .collect::<Vec<u32>>();
-        Ok((signers_contract_id, slot_ids))
+        {
+            slot_ids_addresses.insert(
+                u32::try_from(slot_id).expect("FATAL: too many signers to fit into u32 range"),
+                address,
+            );
+        }
+        Ok((signers_contract_id, slot_ids_addresses))
     }
 
     fn get_signer_transactions(
         &self,
+        chainstate: &mut StacksChainState,
+        sortdb: &SortitionDB,
         stackerdbs: &StackerDBs,
     ) -> Result<Vec<StacksTransaction>, NakamotoNodeError> {
-        let (signers_contract_id, slot_ids) =
+        let (signers_contract_id, slot_ids_addresses) =
             self.get_stackerdb_contract_and_slots(stackerdbs, TRANSACTIONS_MSG_ID)?;
+        let slot_ids = slot_ids_addresses.keys().cloned().collect::<Vec<_>>();
+        let addresses = slot_ids_addresses.values().cloned().collect::<HashSet<_>>();
         // Get the transactions from the signers for the next block
         let signer_chunks = stackerdbs
             .get_latest_chunks(&signers_contract_id, &slot_ids)
@@ -321,14 +333,38 @@ impl BlockMinerThread {
         for (_slot, signer_message) in signer_messages {
             match signer_message {
                 SignerMessage::Transactions(transactions) => {
-                    // TODO: filter out transactons that are not valid and that do not come from the signers
-                    // TODO: move this filter function from stacks-signer and make it globally available perhaps?
-                    transactions_to_include.extend(transactions);
+                    for transaction in transactions {
+                        let address = transaction.origin_address();
+                        let nonce = transaction.get_origin_nonce();
+                        if !addresses.contains(&address) {
+                            test_debug!("Miner: ignoring transaction ({:?}) with nonce {nonce} from address {address}", transaction.txid());
+                            continue;
+                        }
+
+                        let cur_nonce = chainstate
+                            .with_read_only_clarity_tx(
+                                &sortdb.index_conn(),
+                                &self.parent_tenure_id,
+                                |clarity_tx| {
+                                    clarity_tx.with_clarity_db_readonly(|clarity_db| {
+                                        clarity_db.get_account_nonce(&address.into()).unwrap_or(0)
+                                    })
+                                },
+                            )
+                            .unwrap_or(0);
+
+                        if cur_nonce > nonce {
+                            test_debug!("Miner: ignoring transaction ({:?}) with nonce {nonce} from address {address}", transaction.txid());
+                            continue;
+                        }
+                        test_debug!("Miner: including transaction ({:?}) with nonce {nonce} from address {address}", transaction.txid());
+                        // TODO : filter out transactions that are not valid votes
+                        transactions_to_include.push(transaction);
+                    }
                 }
                 _ => {} // Any other message is ignored
             }
         }
-        debug!("MINER IS INCLUDING TRANSACTIONS FROM SIGNERS: {transactions_to_include:?}");
         Ok(transactions_to_include)
     }
 
@@ -337,13 +373,15 @@ impl BlockMinerThread {
         stackerdbs: &StackerDBs,
         aggregate_public_key: &Point,
         signer_signature_hash: &Sha512Trunc256Sum,
+        signer_weights: HashMap<StacksAddress, u64>,
     ) -> Result<ThresholdSignature, NakamotoNodeError> {
-        let (signers_contract_id, slot_ids) =
+        let (signers_contract_id, slot_ids_addresses) =
             self.get_stackerdb_contract_and_slots(stackerdbs, BLOCK_MSG_ID)?;
-
+        let slot_ids = slot_ids_addresses.keys().cloned().collect::<Vec<_>>();
         // If more than a threshold percentage of the signers reject the block, we should not wait any further
-        let rejection_threshold = slot_ids.len() / 10 * 7;
+        let rejection_threshold = 4000 / 10 * 7;
         let mut rejections = HashSet::new();
+        let mut rejections_weight: u64 = 0;
         let now = Instant::now();
         while now.elapsed() < self.config.miner.wait_on_signers {
             // Get the block responses from the signers for the block we just proposed
@@ -372,6 +410,7 @@ impl BlockMinerThread {
                         {
                             // The signature is valid across the signer signature hash of the original proposed block
                             // Immediately return and update the block with this new signature before appending it to the chain
+                            test_debug!("Miner: received a signature accross the proposed block's signer signature hash ({signer_signature_hash:?}): {signature:?}");
                             return Ok(signature);
                         }
                         // We received an accepted block for some unknown block hash...Useless! Ignore it.
@@ -397,10 +436,24 @@ impl BlockMinerThread {
                                 ));
                             }
                         } else {
+                            if rejections.contains(&signer_id) {
+                                // We have already received a rejection from this signer
+                                continue;
+                            }
+
                             // We received a rejection that is not signed. We will keep waiting for a threshold number of rejections.
                             // Ensure that we do not double count a rejection from the same signer.
                             rejections.insert(signer_id);
-                            if rejections.len() > rejection_threshold {
+                            rejections_weight = rejections_weight.saturating_add(
+                                *signer_weights
+                                    .get(
+                                        &slot_ids_addresses
+                                            .get(&signer_id)
+                                            .expect("FATAL: signer not found in slot ids"),
+                                    )
+                                    .expect("FATAL: signer not found in signer weights"),
+                            );
+                            if rejections_weight > rejection_threshold {
                                 // A threshold number of signers rejected the proposed block.
                                 // Miner will likely never get a signed block from the signers for this particular block
                                 // Return and attempt to mine a new block
@@ -443,11 +496,19 @@ impl BlockMinerThread {
             &sortition_handle,
             &block,
         )?;
+
+        let reward_cycle = self
+            .burnchain
+            .block_height_to_reward_cycle(self.burn_block.block_height)
+            .expect("FATAL: no reward cycle for burn block");
+        let signer_weights =
+            chain_state.get_signers_weights(&sort_db, &self.parent_tenure_id, reward_cycle)?;
         let signature = self
             .wait_for_signer_signature(
                 &stackerdbs,
                 &aggregate_public_key,
                 &block.header.signer_signature_hash(),
+                signer_weights,
             )
             .map_err(|e| {
                 ChainstateError::InvalidStacksBlock(format!("Invalid Nakamoto block: {e:?}"))
@@ -759,7 +820,8 @@ impl BlockMinerThread {
             .map_err(|_| NakamotoNodeError::UnexpectedChainState)?
             .saturating_add(1);
 
-        let signer_transactions = self.get_signer_transactions(&stackerdbs)?;
+        let signer_transactions =
+            self.get_signer_transactions(&mut chain_state, &burn_db, &stackerdbs)?;
 
         // build the block itself
         let (mut block, _, _) = NakamotoBlockBuilder::build_nakamoto_block(
diff --git a/testnet/stacks-node/src/run_loop/neon.rs b/testnet/stacks-node/src/run_loop/neon.rs
index 58910aef86..4c303618c6 100644
--- a/testnet/stacks-node/src/run_loop/neon.rs
+++ b/testnet/stacks-node/src/run_loop/neon.rs
@@ -490,7 +490,7 @@ impl RunLoop {
             }) as Box<dyn FnOnce(&mut ClarityTx)>;
             Some(callback)
         } else {
-            warn!("Self-signing is not supported yet");
+            warn!("Neon node booting with no aggregate public key. Must have signers available to sign blocks.");
             None
         };
 
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index 8d96e80eff..f150670885 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -268,7 +268,7 @@ impl SignerTest {
             epoch_30_boundary,
             &self.running_nodes.conf,
         );
-        info!("Avanced to Nakamoto! Ready to Sign Blocks!");
+        info!("Advanced to Nakamoto! Ready to Sign Blocks!");
     }
 
     fn get_current_reward_cycle(&self) -> u64 {
@@ -386,7 +386,11 @@ fn setup_stx_btc_node(
     let observer_port = test_observer::EVENT_OBSERVER_PORT;
     naka_conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{observer_port}"),
-        events_keys: vec![EventKeyType::StackerDBChunks, EventKeyType::BlockProposal],
+        events_keys: vec![
+            EventKeyType::StackerDBChunks,
+            EventKeyType::BlockProposal,
+            EventKeyType::MinedBlocks,
+        ],
     });
 
     // The signers need some initial balances in order to pay for epoch 2.5 transaction votes
@@ -620,18 +624,19 @@ fn stackerdb_dkg_sign() {
 ///
 /// Test Setup:
 /// The test spins up five stacks signers, one miner Nakamoto node, and a corresponding bitcoind.
-/// The stacks node is advanced to epoch 3.0. DKG foricbly triggered to set the key correctly
+/// The stacks node is advanced to epoch 2.5. forcibly triggering DKG to set the key correctly
+/// The stacks node is next advanced to epoch 3.0 boundary to allow block signing.
 ///
 /// Test Execution:
-/// The node attempts to mine a Nakamoto tenure, sending a block to the observing signers via the
+/// The node attempts to mine a Nakamoto block, sending a block to the observing signers via the
 /// .miners stacker db instance. The signers submit the block to the stacks node for verification.
 /// Upon receiving a Block Validation response approving the block, the signers perform a signing
-/// round across its signature hash.
+/// round across its signature hash and return it back to the miner.
 ///
 /// Test Assertion:
 /// Signers return an operation result containing a valid signature across the miner's Nakamoto block's signature hash.
 /// Signers broadcasted a signature across the miner's proposed block back to the respective .signers-XXX-YYY contract.
-/// TODO: update test to check miner received the signed block and appended it to the chain
+/// Miner appends the signature to the block and finishes mininig it.
 fn stackerdb_block_proposal() {
     if env::var("BITCOIND_TEST") != Ok("1".into()) {
         return;
@@ -645,7 +650,7 @@ fn stackerdb_block_proposal() {
     info!("------------------------- Test Setup -------------------------");
     let mut signer_test = SignerTest::new(5);
     let timeout = Duration::from_secs(200);
-    let (_vrfs_submitted, commits_submitted) = (
+    let (vrfs_submitted, commits_submitted) = (
         signer_test.running_nodes.vrfs_submitted.clone(),
         signer_test.running_nodes.commits_submitted.clone(),
     );
@@ -675,14 +680,41 @@ fn stackerdb_block_proposal() {
     assert_eq!(set_dkg, key);
 
     info!("------------------------- Verify Nakamoto Block Proposed -------------------------");
+
     let sign_now = Instant::now();
-    // Mine 1 nakamoto tenure
+
+    info!("Nakamoto miner started...");
+    // first block wakes up the run loop, wait until a key registration has been submitted.
+    next_block_and(
+        &mut signer_test.running_nodes.btc_regtest_controller,
+        60,
+        || {
+            let vrf_count = vrfs_submitted.load(Ordering::SeqCst);
+            Ok(vrf_count >= 1)
+        },
+    )
+    .unwrap();
+
+    info!("Successfully triggered first block to wake up the miner runloop.");
+    // second block should confirm the VRF register, wait until a block commit is submitted
+    next_block_and(
+        &mut signer_test.running_nodes.btc_regtest_controller,
+        60,
+        || {
+            let commits_count = commits_submitted.load(Ordering::SeqCst);
+            Ok(commits_count >= 1)
+        },
+    )
+    .unwrap();
+
+    info!("Mining first Nakamoto block");
     let _ = next_block_and_mine_commit(
         &mut signer_test.running_nodes.btc_regtest_controller,
         60,
         &signer_test.running_nodes.coord_channel,
         &commits_submitted,
     );
+
     let frost_signatures = signer_test.wait_for_frost_signatures(timeout);
     let sign_elapsed = sign_now.elapsed();
 

From 48a4e086914844eb06f22429a8c5b99d3b0283b5 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Thu, 15 Feb 2024 15:48:43 -0500
Subject: [PATCH 0896/1166] Fix missing transactions test and add TODOs for
 cleaning up logic

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/signer.rs                   |   6 +
 .../stacks-node/src/nakamoto_node/miner.rs    |   2 +-
 testnet/stacks-node/src/tests/signer.rs       | 574 +++++++++---------
 3 files changed, 285 insertions(+), 297 deletions(-)

diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index f784a3b787..e3c2c1886d 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -217,6 +217,8 @@ impl Signer {
     fn execute_command(&mut self, stacks_client: &StacksClient, command: &Command) {
         match command {
             Command::Dkg => {
+                //TODO: check if we already have an aggregate key stored in the contract.
+                // If we do, we should not start a new DKG
                 let vote_round = match retry_with_exponential_backoff(|| {
                     stacks_client
                         .get_last_round(self.reward_cycle)
@@ -427,6 +429,7 @@ impl Signer {
             .filter_map(|msg| match msg {
                 // TODO: should we store the received transactions on the side and use them rather than directly querying the stacker db slots?
                 SignerMessage::BlockResponse(_) | SignerMessage::Transactions(_) => None,
+                // TODO: if a signer tries to trigger DKG and we already have one set in the contract, ignore the request. Nack it.
                 SignerMessage::Packet(packet) => {
                     self.verify_packet(stacks_client, packet.clone(), &coordinator_pubkey)
                 }
@@ -704,6 +707,7 @@ impl Signer {
             );
             return None;
         };
+        // TODO: add a check that we don't have two conflicting transactions in the same block from the same signer. This is a potential attack vector (will result in an invalid block)
         if origin_nonce < account_nonce {
             debug!("Signer #{}: Received a transaction with an outdated nonce ({account_nonce} < {origin_nonce}). Filtering ({}).", self.signer_id, transaction.txid());
             return None;
@@ -1014,6 +1018,8 @@ impl Signer {
         }
         // For all Pox-4 epochs onwards, broadcast the results also to stackerDB for other signers/miners to observe
         // TODO: if we store transactions on the side, should we use them rather than directly querying the stacker db slot?
+        // TODO: Should we even store transactions if not in prepare phase? Should the miner just ignore all signer transactions if not in prepare phase?
+        // TODO: don't bother storing DKG votes if DKG is already set
         let mut new_transactions = self.get_filtered_transactions(stacks_client, &[self.signer_id]).map_err(|e| {
             warn!("Signer #{}: Failed to get old transactions: {e:?}. Potentially overwriting our existing stackerDB transactions", self.signer_id);
         }).unwrap_or_default();
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index 5afaf32f23..ef01b0ec6f 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -358,7 +358,7 @@ impl BlockMinerThread {
                             continue;
                         }
                         test_debug!("Miner: including transaction ({:?}) with nonce {nonce} from address {address}", transaction.txid());
-                        // TODO : filter out transactions that are not valid votes
+                        // TODO : filter out transactions that are not valid votes. Do not include transactions with invalid/duplicate nonces for the same address.
                         transactions_to_include.push(transaction);
                     }
                 }
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index f150670885..4b65637414 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -1,3 +1,4 @@
+use std::collections::HashSet;
 use std::net::ToSocketAddrs;
 use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
 use std::sync::mpsc::{channel, Receiver, Sender};
@@ -8,20 +9,17 @@ use std::{env, thread};
 use clarity::boot_util::boot_code_id;
 use libsigner::{
     BlockResponse, RejectCode, RunningSigner, Signer, SignerEventReceiver, SignerMessage,
-    BLOCK_MSG_ID, TRANSACTIONS_MSG_ID,
+    BLOCK_MSG_ID,
 };
+use stacks::burnchains::Txid;
 use stacks::chainstate::coordinator::comm::CoordinatorChannels;
 use stacks::chainstate::nakamoto::signer_set::NakamotoSigners;
 use stacks::chainstate::nakamoto::{NakamotoBlock, NakamotoBlockHeader};
 use stacks::chainstate::stacks::boot::SIGNERS_NAME;
-use stacks::chainstate::stacks::{
-    StacksPrivateKey, StacksTransaction, ThresholdSignature, TransactionAnchorMode,
-    TransactionAuth, TransactionPayload, TransactionPostConditionMode, TransactionSmartContract,
-    TransactionVersion,
-};
+use stacks::chainstate::stacks::miner::TransactionEvent;
+use stacks::chainstate::stacks::{StacksPrivateKey, StacksTransaction, ThresholdSignature};
 use stacks::core::StacksEpoch;
 use stacks::net::api::postblock_proposal::BlockValidateResponse;
-use stacks::util_lib::strings::StacksString;
 use stacks_common::bitvec::BitVec;
 use stacks_common::codec::read_next;
 use stacks_common::consts::SIGNER_SLOTS_PER_USER;
@@ -38,6 +36,7 @@ use tracing_subscriber::{fmt, EnvFilter};
 use wsts::common::Signature;
 use wsts::compute::tweaked_public_key;
 use wsts::curve::point::Point;
+use wsts::curve::scalar::Scalar;
 use wsts::state_machine::OperationResult;
 use wsts::taproot::SchnorrProof;
 
@@ -133,6 +132,75 @@ impl SignerTest {
         }
     }
 
+    fn boot_to_epoch_3(&mut self, timeout: Duration) -> Point {
+        boot_to_epoch_3_reward_set(
+            &self.running_nodes.conf,
+            &self.running_nodes.blocks_processed,
+            &self.signer_stacks_private_keys,
+            &self.signer_stacks_private_keys,
+            &mut self.running_nodes.btc_regtest_controller,
+        );
+        let dkg_vote = self.wait_for_dkg(timeout);
+
+        // Advance and mine the DKG key block
+        self.run_until_epoch_3_boundary();
+
+        let reward_cycle = self.get_current_reward_cycle();
+        let set_dkg = self
+            .stacks_client
+            .get_approved_aggregate_key(reward_cycle)
+            .expect("Failed to get approved aggregate key")
+            .expect("No approved aggregate key found");
+        assert_eq!(set_dkg, dkg_vote);
+        info!("Booted Test Signers to Epoch 3.0 boundary. DKG successfully approved. Ready to sign blocks.");
+        set_dkg
+    }
+
+    fn mine_nakamoto_block(&mut self, timeout: Duration) {
+        info!("Nakamoto miner started...");
+        let (vrfs_submitted, commits_submitted) = (
+            self.running_nodes.vrfs_submitted.clone(),
+            self.running_nodes.commits_submitted.clone(),
+        );
+        // first block wakes up the run loop, wait until a key registration has been submitted.
+        next_block_and(&mut self.running_nodes.btc_regtest_controller, 60, || {
+            let vrf_count = vrfs_submitted.load(Ordering::SeqCst);
+            Ok(vrf_count >= 1)
+        })
+        .unwrap();
+
+        info!("Successfully triggered first block to wake up the miner runloop.");
+        // second block should confirm the VRF register, wait until a block commit is submitted
+        next_block_and(&mut self.running_nodes.btc_regtest_controller, 60, || {
+            let commits_count = commits_submitted.load(Ordering::SeqCst);
+            Ok(commits_count >= 1)
+        })
+        .unwrap();
+
+        let mined_block_time = Instant::now();
+        info!("Mining first Nakamoto block");
+        let _ = next_block_and_mine_commit(
+            &mut self.running_nodes.btc_regtest_controller,
+            60,
+            &self.running_nodes.coord_channel,
+            &commits_submitted,
+        );
+
+        let t_start = Instant::now();
+        while test_observer::get_mined_nakamoto_blocks().is_empty() {
+            assert!(
+                t_start.elapsed() < timeout,
+                "Timed out while waiting for mined nakamoto block event"
+            );
+            thread::sleep(Duration::from_secs(1));
+        }
+        let mined_block_elapsed_time = mined_block_time.elapsed();
+        info!(
+            "Nakamoto block mine time elapsed: {:?}",
+            mined_block_elapsed_time
+        );
+    }
+
     fn wait_for_dkg(&mut self, timeout: Duration) -> Point {
         let mut key = Point::default();
         let dkg_now = Instant::now();
@@ -290,23 +358,13 @@ impl SignerTest {
             reward_cycle
         );
         // Calculate which signer is the coordinator
-        let private_key = StacksPrivateKey::new();
-        let node_host = self
-            .running_nodes
-            .conf
-            .node
-            .rpc_bind
-            .to_socket_addrs()
-            .unwrap()
-            .next()
-            .unwrap();
-        // Use the stacks client to calculate the current registered signers and their coordinator
-        let stacks_client = StacksClient::new(private_key, node_host, false);
-        let registered_signers_info = &stacks_client
+        let registered_signers_info = &self
+            .stacks_client
             .get_registered_signers_info(reward_cycle)
             .unwrap()
             .unwrap();
-        let coordinator_id = *stacks_client
+        let coordinator_id = *self
+            .stacks_client
             .calculate_coordinator_ids(&registered_signers_info.public_keys)
             .first()
             .expect("No coordinator found");
@@ -329,6 +387,94 @@ impl SignerTest {
         self.signer_cmd_senders.get(coordinator_index).unwrap()
     }
 
+    fn get_signer_index(&self) -> u32 {
+        let reward_cycle = self.get_current_reward_cycle();
+        let valid_signer_set =
+            u32::try_from(reward_cycle % 2).expect("FATAL: reward_cycle % 2 exceeds u32::MAX");
+        let signer_stackerdb_contract_id = boot_code_id(SIGNERS_NAME, false);
+
+        self.stacks_client
+            .get_stackerdb_signer_slots(&signer_stackerdb_contract_id, valid_signer_set)
+            .expect("FATAL: failed to get signer slots from stackerdb")
+            .iter()
+            .position(|(address, _)| address == self.stacks_client.get_signer_address())
+            .map(|pos| u32::try_from(pos).expect("FATAL: number of signers exceeds u32::MAX"))
+            .expect("FATAL: signer not registered")
+    }
+
+    fn generate_valid_transaction(&self) -> StacksTransaction {
+        // Get the signer indices
+        let reward_cycle = self.get_current_reward_cycle();
+        let valid_signer_index = self.get_signer_index();
+        let nonce = self
+            .stacks_client
+            .get_account_nonce(self.stacks_client.get_signer_address())
+            .expect("FATAL: failed to get nonce");
+        let round = self
+            .stacks_client
+            .get_last_round(reward_cycle)
+            .expect("FATAL: failed to get round")
+            .unwrap_or(0)
+            .wrapping_add(1);
+        let point = Point::from(Scalar::random(&mut rand::thread_rng()));
+        self.stacks_client
+            .build_vote_for_aggregate_public_key(
+                valid_signer_index,
+                round,
+                point,
+                reward_cycle,
+                None,
+                nonce,
+            )
+            .expect("FATAL: failed to build vote for aggregate public key")
+    }
+
+    fn generate_invalid_transactions(&self) -> Vec<StacksTransaction> {
+        let host = self
+            .running_nodes
+            .conf
+            .node
+            .rpc_bind
+            .to_socket_addrs()
+            .unwrap()
+            .next()
+            .unwrap();
+        // Get the signer indices
+        let reward_cycle = self.get_current_reward_cycle();
+        let valid_signer_index = self.get_signer_index();
+        let round = self
+            .stacks_client
+            .get_last_round(reward_cycle)
+            .expect("FATAL: failed to get round")
+            .unwrap_or(0)
+            .wrapping_add(1);
+        let point = Point::from(Scalar::random(&mut rand::thread_rng()));
+        let invalid_nonce_tx = self
+            .stacks_client
+            .build_vote_for_aggregate_public_key(
+                valid_signer_index,
+                round,
+                point,
+                reward_cycle,
+                None,
+                0, // Old nonce
+            )
+            .expect("FATAL: failed to build vote for aggregate public key");
+        let invalid_stacks_client = StacksClient::new(StacksPrivateKey::new(), host, false);
+        let invalid_signer_tx = invalid_stacks_client
+            .build_vote_for_aggregate_public_key(
+                valid_signer_index,
+                round,
+                point,
+                reward_cycle,
+                None,
+                0,
+            )
+            .expect("FATAL: failed to build vote for aggregate public key");
+        // TODO: add invalid contract calls (one with non cast-vote-aggregate-key function call and one with invalid function args)
+        vec![invalid_nonce_tx, invalid_signer_tx]
+    }
+
     fn shutdown(self) {
         self.running_nodes
             .coord_channel
@@ -554,28 +700,9 @@ fn stackerdb_dkg_sign() {
     let dkg_elapsed = dkg_now.elapsed();
     assert_ne!(new_key, key);
 
-    // Verify that we haven't mined the DKG key yet
-    assert!(signer_test
-        .stacks_client
-        .get_approved_aggregate_key(reward_cycle)
-        .expect("Failed to get approved aggregate key")
-        .is_none());
-
-    // Advance and mine the DKG key block
-    signer_test.run_until_epoch_3_boundary();
-
-    let set_key = signer_test
-        .stacks_client
-        .get_approved_aggregate_key(reward_cycle)
-        .expect("Failed to get approved aggregate key")
-        .expect("No approved aggregate key found");
-    assert_eq!(set_key, key);
-
     info!("------------------------- Test Sign -------------------------");
-    // Determine the coordinator of the current node height
-    let coordinator_sender = signer_test.get_coordinator_sender(reward_cycle);
 
-    let sign_now = Instant::now();
+    // Determine the coordinator of the current node height
     info!("signer_runloop: spawn send commands to do dkg and then sign");
     let sign_command = RunLoopCommand {
         reward_cycle,
@@ -593,6 +720,8 @@ fn stackerdb_dkg_sign() {
             merkle_root: None,
         },
     };
+    let coordinator_sender = signer_test.get_coordinator_sender(reward_cycle);
+    let sign_now = Instant::now();
     coordinator_sender
         .send(sign_command)
         .expect("failed to send Sign command");
@@ -601,11 +730,12 @@ fn stackerdb_dkg_sign() {
         .expect("failed to send Sign taproot command");
     let frost_signatures = signer_test.wait_for_frost_signatures(timeout);
     let schnorr_proofs = signer_test.wait_for_taproot_signatures(timeout);
-    for forst_signature in frost_signatures {
-        assert!(forst_signature.verify(&set_key, &msg));
+
+    for frost_signature in frost_signatures {
+        assert!(frost_signature.verify(&new_key, &msg));
     }
     for schnorr_proof in schnorr_proofs {
-        let tweaked_key = tweaked_public_key(&set_key, None);
+        let tweaked_key = tweaked_public_key(&new_key, None);
         assert!(
             schnorr_proof.verify(&tweaked_key.x(), &msg),
             "Schnorr proof verification failed"
@@ -613,6 +743,45 @@ fn stackerdb_dkg_sign() {
     }
     let sign_elapsed = sign_now.elapsed();
 
+    info!("------------------------- Test Block Accepted -------------------------");
+
+    // Verify the signers accepted the proposed block
+    let t_start = Instant::now();
+    let mut chunk = None;
+    while chunk.is_none() {
+        assert!(
+            t_start.elapsed() < Duration::from_secs(30),
+            "Timed out while waiting for signers block response stacker db event"
+        );
+
+        let nakamoto_blocks = test_observer::get_stackerdb_chunks();
+        for event in nakamoto_blocks {
+            // Only care about the miners block slot
+            if event.contract_id.name == format!("signers-1-{}", BLOCK_MSG_ID).as_str().into()
+                || event.contract_id.name == format!("signers-0-{}", BLOCK_MSG_ID).as_str().into()
+            {
+                for slot in event.modified_slots {
+                    chunk = Some(slot.data);
+                    break;
+                }
+                if chunk.is_some() {
+                    break;
+                }
+            }
+        }
+        thread::sleep(Duration::from_secs(1));
+    }
+    let chunk = chunk.unwrap();
+    let signer_message = read_next::<SignerMessage, _>(&mut &chunk[..]).unwrap();
+    if let SignerMessage::BlockResponse(BlockResponse::Rejected(rejection)) = signer_message {
+        assert!(matches!(
+            rejection.reason_code,
+            RejectCode::ValidationFailed(_)
+        ));
+    } else {
+        panic!("Received unexpected message: {:?}", &signer_message);
+    }
+
     info!("DKG Time Elapsed: {:.2?}", dkg_elapsed);
     info!("Sign Time Elapsed: {:.2?}", sign_elapsed);
     signer_test.shutdown();
@@ -650,81 +819,20 @@ fn stackerdb_block_proposal() {
     info!("------------------------- Test Setup -------------------------");
     let mut signer_test = SignerTest::new(5);
     let timeout = Duration::from_secs(200);
-    let (vrfs_submitted, commits_submitted) = (
-        signer_test.running_nodes.vrfs_submitted.clone(),
-        signer_test.running_nodes.commits_submitted.clone(),
-    );
-    boot_to_epoch_3_reward_set(
-        &signer_test.running_nodes.conf,
-        &signer_test.running_nodes.blocks_processed,
-        &signer_test.signer_stacks_private_keys,
-        &signer_test.signer_stacks_private_keys,
-        &mut signer_test.running_nodes.btc_regtest_controller,
-    );
-
-    info!("------------------------- Wait for DKG -------------------------");
-    info!("signer_runloop: spawn send commands to do dkg");
-    let dkg_now = Instant::now();
-    let key = signer_test.wait_for_dkg(timeout);
-    let dkg_elapsed = dkg_now.elapsed();
-
-    info!("------------------------- Verify DKG -------------------------");
-    signer_test.run_until_epoch_3_boundary();
-
-    let reward_cycle = signer_test.get_current_reward_cycle();
-    let set_dkg = signer_test
-        .stacks_client
-        .get_approved_aggregate_key(reward_cycle)
-        .expect("Failed to get approved aggregate key")
-        .expect("No approved aggregate key found");
-    assert_eq!(set_dkg, key);
-
-    info!("------------------------- Verify Nakamoto Block Proposed -------------------------");
-
-    let sign_now = Instant::now();
-
-    info!("Nakamoto miner started...");
-    // first block wakes up the run loop, wait until a key registration has been submitted.
-    next_block_and(
-        &mut signer_test.running_nodes.btc_regtest_controller,
-        60,
-        || {
-            let vrf_count = vrfs_submitted.load(Ordering::SeqCst);
-            Ok(vrf_count >= 1)
-        },
-    )
-    .unwrap();
-
-    info!("Successfully triggered first block to wake up the miner runloop.");
-    // second block should confirm the VRF register, wait until a block commit is submitted
-    next_block_and(
-        &mut signer_test.running_nodes.btc_regtest_controller,
-        60,
-        || {
-            let commits_count = commits_submitted.load(Ordering::SeqCst);
-            Ok(commits_count >= 1)
-        },
-    )
-    .unwrap();
-
-    info!("Mining first Nakamoto block");
-    let _ = next_block_and_mine_commit(
-        &mut signer_test.running_nodes.btc_regtest_controller,
-        60,
-        &signer_test.running_nodes.coord_channel,
-        &commits_submitted,
-    );
+    let key = signer_test.boot_to_epoch_3(timeout);
+    signer_test.mine_nakamoto_block(timeout);
 
-    let frost_signatures = signer_test.wait_for_frost_signatures(timeout);
-    let sign_elapsed = sign_now.elapsed();
+    info!("------------------------- Verify Sign Round -------------------------");
+    let short_timeout = Duration::from_secs(30);
+    let frost_signatures = signer_test.wait_for_frost_signatures(short_timeout);
 
     info!("------------------------- Verify Block Proposal Response -------------------------");
-    // Wait for the block to show up in the test observer (Don't have to wait long as if we have received a signature,
+    // Wait for the block to show up in the test observer (Don't have to wait long as if we have received a mined block already,
     // we know that the signers have already received their block proposal events via their event observers)
     let t_start = Instant::now();
     while test_observer::get_proposal_responses().is_empty() {
         assert!(
-            t_start.elapsed() < timeout,
+            t_start.elapsed() < short_timeout,
             "Timed out while waiting for block proposal event"
         );
         thread::sleep(Duration::from_secs(1));
@@ -748,7 +856,7 @@ fn stackerdb_block_proposal() {
     let mut chunk = None;
     while chunk.is_none() {
         assert!(
-            t_start.elapsed() < Duration::from_secs(30),
+            t_start.elapsed() < short_timeout,
             "Timed out while waiting for signers block response stacker db event"
         );
 
@@ -786,40 +894,30 @@ fn stackerdb_block_proposal() {
     } else {
         panic!("Received unexpected message");
     }
-
-    info!("------------------------- Verify Nakamoto Block Mined -------------------------");
-    while test_observer::get_mined_nakamoto_blocks().is_empty() {
-        assert!(
-            t_start.elapsed() < timeout,
-            "Timed out while waiting for mined nakamoto block event"
-        );
-        thread::sleep(Duration::from_secs(1));
-    }
-
     signer_test.shutdown();
-
-    info!("DKG Time Elapsed: {:.2?}", dkg_elapsed);
-    info!("Sign Time Elapsed: {:.2?}", sign_elapsed);
 }
 
 #[test]
 #[ignore]
-/// Test that signers will reject a miners block proposal if it is missing expected transactions
+/// Test that signers will accept a miners block proposal and sign it if it contains all expected transactions,
+/// filtering invalid transactions from the block requirements
 ///
 /// Test Setup:
 /// The test spins up five stacks signers, one miner Nakamoto node, and a corresponding bitcoind.
-/// The stacks node is advanced to epoch 3.0. and signers perform a DKG round (this should be removed
-/// once we have proper casting of the vote during epoch 2.5).
+/// The stacks node is advanced to epoch 2.5, triggering a DKG round. The stacks node is then advanced
+/// to Epoch 3.0 boundary to allow block signing.
 ///
 /// Test Execution:
 /// The node attempts to mine a Nakamoto tenure, sending a block to the observing signers via the
 /// .miners stacker db instance. The signers submit the block to the stacks node for verification.
 /// Upon receiving a Block Validation response approving the block, the signers verify that it contains
-/// all expected transactions. As it does not, the signers reject the block and do not sign it.
+/// all expected transactions, being sure to filter out any invalid transactions from stackerDB as well.
 ///
 /// Test Assertion:
-/// Signers broadcast rejections with the list of missing transactions back to the miners stackerdb instance
-fn stackerdb_block_proposal_missing_transactions() {
+/// Miner proposes a block to the signers containing all expected transactions.
+/// Signers broadcast block approval with a signature back to the waiting miner.
+/// Miner includes the signers' signature in the block and finishes mining it.
+fn stackerdb_block_proposal_filters_bad_transactions() {
     if env::var("BITCOIND_TEST") != Ok("1".into()) {
         return;
     }
@@ -831,6 +929,8 @@ fn stackerdb_block_proposal_missing_transactions() {
 
     info!("------------------------- Test Setup -------------------------");
     let mut signer_test = SignerTest::new(5);
+    let timeout = Duration::from_secs(200);
+    let set_dkg = signer_test.boot_to_epoch_3(timeout);
 
     let host = signer_test
         .running_nodes
@@ -841,181 +941,44 @@ fn stackerdb_block_proposal_missing_transactions() {
         .unwrap()
         .next()
         .unwrap();
-    let _stx_genesissigner_stacker_db_1 = signer_test
-        .running_nodes
-        .conf
-        .node
-        .stacker_dbs
-        .iter()
-        .find(|id| {
-            id.name.to_string() == NakamotoSigners::make_signers_db_name(1, TRANSACTIONS_MSG_ID)
-        })
-        .unwrap()
-        .clone();
-
-    let signer_id = 0;
-
-    let signer_addresses_1: Vec<_> = signer_test
-        .stacks_client
-        .get_stackerdb_signer_slots(&boot_code_id(SIGNERS_NAME, false), 1)
-        .unwrap()
-        .into_iter()
-        .map(|(address, _)| address)
-        .collect();
 
-    let signer_address_1 = signer_addresses_1.get(signer_id).cloned().unwrap();
-
-    let signer_private_key_1 = signer_test
+    let signer_private_key = signer_test
         .signer_stacks_private_keys
         .iter()
         .find(|pk| {
             let addr = to_addr(pk);
-            addr == signer_address_1
+            addr == *signer_test.stacks_client.get_signer_address()
         })
         .cloned()
         .expect("Cannot find signer private key for signer id 1");
+    let reward_cycle = signer_test.get_current_reward_cycle();
+    let signer_index = signer_test.get_signer_index();
+    let mut stackerdb = StackerDB::new(host, signer_private_key, false, reward_cycle, signer_index);
 
-    let mut stackerdb_1 = StackerDB::new(host, signer_private_key_1, false, 1, 0);
-
-    debug!("Signer address is {}", &signer_address_1);
-    assert_eq!(signer_address_1, to_addr(&signer_private_key_1),);
-
-    // Create a valid transaction signed by the signer private key coresponding to the slot into which it is being inserted (signer id 0)
-    let mut valid_tx = StacksTransaction {
-        version: TransactionVersion::Testnet,
-        chain_id: 0x80000000,
-        auth: TransactionAuth::from_p2pkh(&signer_private_key_1).unwrap(),
-        anchor_mode: TransactionAnchorMode::Any,
-        post_condition_mode: TransactionPostConditionMode::Allow,
-        post_conditions: vec![],
-        payload: TransactionPayload::SmartContract(
-            TransactionSmartContract {
-                name: "test-contract".into(),
-                code_body: StacksString::from_str("(/ 1 0)").unwrap(),
-            },
-            None,
-        ),
-    };
-    valid_tx.set_origin_nonce(2);
-
-    // Create a transaction signed by a different private key
-    // This transaction will be invalid as it is signed by a non signer private key
-    let invalid_signer_private_key = StacksPrivateKey::new();
     debug!(
-        "Invalid address is {}",
-        to_addr(&invalid_signer_private_key)
-    );
-    let mut invalid_tx = StacksTransaction {
-        version: TransactionVersion::Testnet,
-        chain_id: 0,
-        auth: TransactionAuth::from_p2pkh(&invalid_signer_private_key).unwrap(),
-        anchor_mode: TransactionAnchorMode::Any,
-        post_condition_mode: TransactionPostConditionMode::Allow,
-        post_conditions: vec![],
-        payload: TransactionPayload::SmartContract(
-            TransactionSmartContract {
-                name: "test-contract".into(),
-                code_body: StacksString::from_str("(/ 1 0)").unwrap(),
-            },
-            None,
-        ),
-    };
-    invalid_tx.set_origin_nonce(0);
-
-    info!("Boot to epoch 3.0 reward calculation...");
-    boot_to_epoch_3_reward_set(
-        &signer_test.running_nodes.conf,
-        &signer_test.running_nodes.blocks_processed,
-        &signer_test.signer_stacks_private_keys,
-        &signer_test.signer_stacks_private_keys,
-        &mut signer_test.running_nodes.btc_regtest_controller,
+        "Signer address is {}",
+        &signer_test.stacks_client.get_signer_address()
     );
 
-    info!("Pox 4 activated and at epoch 3.0 reward set calculation (2nd block of its prepare phase)! Ready for signers to perform DKG and Sign!");
-
-    // Determine the coordinator
-    // we have just calculated the reward set for the next reward cycle hence the + 1
-    let reward_cycle = signer_test.get_current_reward_cycle().wrapping_add(1);
-    let coordinator_sender = signer_test.get_coordinator_sender(reward_cycle);
-
-    // First run DKG in order to sign the block that arrives from the miners following a nakamoto block production
-    // TODO: remove this forcibly running DKG once we have casting of the vote automagically happening during epoch 2.5
-    info!("signer_runloop: spawn send commands to do dkg");
-    let dkg_command = RunLoopCommand {
-        reward_cycle,
-        command: SignerCommand::Dkg,
-    };
-    coordinator_sender
-        .send(dkg_command)
-        .expect("failed to send DKG command");
-    let recv = signer_test
-        .result_receivers
-        .last()
-        .expect("Failed to get coordinator recv");
-    let results = recv
-        .recv_timeout(Duration::from_secs(30))
-        .expect("failed to recv dkg results");
-    for result in results {
-        match result {
-            OperationResult::Dkg(point) => {
-                info!("Received aggregate_group_key {point}");
-                break;
-            }
-            _ => {
-                panic!("Received Unexpected result");
-            }
-        }
-    }
-
-    // Following stacker DKG, submit transactions to stackerdb for the signers to pick up during block verification
-    stackerdb_1
-        .send_message_with_retry(SignerMessage::Transactions(vec![
-            valid_tx.clone(),
-            invalid_tx.clone(),
-        ]))
-        .expect("Failed to write expected transactions to stackerdb_1");
-
-    let (vrfs_submitted, commits_submitted) = (
-        signer_test.running_nodes.vrfs_submitted.clone(),
-        signer_test.running_nodes.commits_submitted.clone(),
-    );
+    let valid_tx = signer_test.generate_valid_transaction();
+    let invalid_txs = signer_test.generate_invalid_transactions();
 
-    info!("------------------------- Test Block Rejected -------------------------");
+    let valid_txid = valid_tx.txid();
+    let invalid_txids: HashSet<Txid> = invalid_txs.iter().map(|tx| tx.txid()).collect();
 
-    info!("Mining a Nakamoto tenure...");
+    let mut txs = invalid_txs;
+    txs.push(valid_tx);
 
-    // first block wakes up the run loop, wait until a key registration has been submitted.
-    next_block_and(
-        &mut signer_test.running_nodes.btc_regtest_controller,
-        60,
-        || {
-            let vrf_count = vrfs_submitted.load(Ordering::SeqCst);
-            Ok(vrf_count >= 1)
-        },
-    )
-    .unwrap();
+    // Submit transactions to stackerdb for the signers and miners to pick up during block verification
+    stackerdb
+        .send_message_with_retry(SignerMessage::Transactions(txs))
+        .expect("Failed to write expected transactions to stackerdb");
 
-    // second block should confirm the VRF register, wait until a block commit is submitted
-    next_block_and(
-        &mut signer_test.running_nodes.btc_regtest_controller,
-        60,
-        || {
-            let commits_count = commits_submitted.load(Ordering::SeqCst);
-            Ok(commits_count >= 1)
-        },
-    )
-    .unwrap();
+    signer_test.mine_nakamoto_block(timeout);
 
-    // Mine 1 nakamoto tenure
-    next_block_and_mine_commit(
-        &mut signer_test.running_nodes.btc_regtest_controller,
-        60,
-        &signer_test.running_nodes.coord_channel,
-        &commits_submitted,
-    )
-    .unwrap();
+    info!("------------------------- Test Block Accepted -------------------------");
 
-    // Verify that the signers broadcasted a series of rejections with missing transactions back to the miner
+    // Verify the signers accepted the proposed block
     let t_start = Instant::now();
     let mut chunk = None;
     while chunk.is_none() {
@@ -1043,15 +1006,34 @@ fn stackerdb_block_proposal_missing_transactions() {
     }
     let chunk = chunk.unwrap();
     let signer_message = read_next::<SignerMessage, _>(&mut &chunk[..]).unwrap();
-    if let SignerMessage::BlockResponse(BlockResponse::Rejected(block_rejection)) = signer_message {
-        // Verify we are missing the valid tx that we expect to see in the block
-        if let RejectCode::MissingTransactions(missing_txs) = block_rejection.reason_code {
-            assert_eq!(missing_txs, vec![valid_tx]);
-        } else {
-            panic!("Received unexpected rejection reason");
-        }
+    if let SignerMessage::BlockResponse(BlockResponse::Accepted((hash, signature))) = signer_message
+    {
+        // Verify we accepted the block
+        assert!(signature.verify(&set_dkg, hash.0.as_slice()));
     } else {
         panic!("Received unexpected message: {:?}", &signer_message);
     }
+
+    info!("------------------------- Verify Nakamoto Block Mined -------------------------");
+    let mined_block_events = test_observer::get_mined_nakamoto_blocks();
+    let mined_block_event = mined_block_events.first().expect("No mined block");
+    let mut mined_valid_tx = false;
+    for tx_event in &mined_block_event.tx_events {
+        let TransactionEvent::Success(tx_success) = tx_event else {
+            panic!("Received unexpected transaction event");
+        };
+        // Since we never broadcast the "invalid" transaction to the mempool and the transaction did not come from a signer or had an invalid nonce
+        // the miner should never construct a block that contains them and signers should still approve it
+        assert!(
+            !invalid_txids.contains(&tx_success.txid),
+            "Miner included an invalid transaction in the block"
+        );
+        if tx_success.txid == valid_txid {
+            mined_valid_tx = true;
+        }
+    }
+    if !mined_valid_tx {
+        panic!("Signers did not enforce the miner to include the valid transaction in the block");
+    }
     signer_test.shutdown();
 }

From 5d129c8189cd45bfc2d3bc86af444fb119f9d84f Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 16 Feb 2024 09:33:40 -0500
Subject: [PATCH 0897/1166] Fix copyright and logging and add todos where
 missing

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/stacks_client.rs | 56 ++++++-----------------
 stacks-signer/src/config.rs               |  5 +-
 stacks-signer/src/coordinator.rs          |  2 +-
 stacks-signer/src/main.rs                 |  2 +-
 stacks-signer/src/signer.rs               | 22 +++++++--
 5 files changed, 35 insertions(+), 52 deletions(-)

diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index 492c3f5dd4..63d75b40fb 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -1,5 +1,3 @@
-use std::net::SocketAddr;
-
 // Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
 // Copyright (C) 2020-2024 Stacks Open Internet Foundation
 //
@@ -15,6 +13,8 @@ use std::net::SocketAddr;
 //
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
+use std::net::SocketAddr;
+
 use blockstack_lib::burnchains::Txid;
 use blockstack_lib::chainstate::nakamoto::NakamotoBlock;
 use blockstack_lib::chainstate::stacks::boot::{RewardSet, SIGNERS_VOTING_NAME};
@@ -117,10 +117,8 @@ impl StacksClient {
         &self.stacks_address
     }
 
-    /// Calculate the coordinator address by comparing the provided public keys against the stacks tip consensus hash
+    /// Calculate the ordered list of coordinator ids by comparing the provided public keys against the pox consensus hash
     pub fn calculate_coordinator_ids(&self, public_keys: &PublicKeys) -> Vec<u32> {
-        // TODO: return the entire list. Might be at the same block height for a long time and need to move to the second item in the list
-        // Add logic throughout signer to track the current coordinator list and offset in the list
         let pox_consensus_hash = match retry_with_exponential_backoff(|| {
             self.get_pox_consenus_hash()
                 .map_err(backoff::Error::transient)
@@ -181,8 +179,6 @@ impl StacksClient {
         value: ClarityValue,
     ) -> Result<Vec<(StacksAddress, u128)>, ClientError> {
         debug!("Parsing signer slots...");
-        // Due to .signers definition, the  signer slots is always an OK result of a list of tuples of signer addresses and the number of slots they have
-        // If this fails, we have bigger problems than the signer crashing...
         let value = value.clone().expect_result_ok()?;
         let values = value.expect_list()?;
         let mut signer_slots = Vec::with_capacity(values.len());
@@ -535,8 +531,6 @@ impl StacksClient {
         value: ClarityValue,
     ) -> Result<Option<Point>, ClientError> {
         debug!("Parsing aggregate public key...");
-        // Due to pox 4 definition, the aggregate public key is always an optional clarity value of 33 bytes hence the use of expect
-        // If this fails, we have bigger problems than the signer crashing...
         let opt = value.clone().expect_optional()?;
         let Some(inner_data) = opt else {
             return Ok(None);
@@ -577,43 +571,19 @@ impl StacksClient {
             ClarityValue::UInt(round as u128),
             ClarityValue::UInt(reward_cycle as u128),
         ];
+        let tx_fee = tx_fee.unwrap_or(0);
 
-        let tx_payload = TransactionPayload::ContractCall(TransactionContractCall {
-            address: contract_address,
+        Self::build_signed_contract_call_transaction(
+            &contract_address,
             contract_name,
             function_name,
-            function_args,
-        });
-        let public_key = StacksPublicKey::from_private(&self.stacks_private_key);
-        let tx_auth = TransactionAuth::Standard(
-            TransactionSpendingCondition::new_singlesig_p2pkh(public_key).ok_or(
-                ClientError::TransactionGenerationFailure(format!(
-                    "Failed to create spending condition from public key: {}",
-                    public_key.to_hex()
-                )),
-            )?,
-        );
-
-        let mut unsigned_tx = StacksTransaction::new(self.tx_version, tx_auth, tx_payload);
-        if let Some(tx_fee) = tx_fee {
-            unsigned_tx.set_tx_fee(tx_fee);
-        }
-        unsigned_tx.set_origin_nonce(nonce);
-
-        unsigned_tx.anchor_mode = TransactionAnchorMode::Any;
-        unsigned_tx.post_condition_mode = TransactionPostConditionMode::Allow;
-        unsigned_tx.chain_id = self.chain_id;
-
-        let mut tx_signer = StacksTransactionSigner::new(&unsigned_tx);
-        tx_signer
-            .sign_origin(&self.stacks_private_key)
-            .map_err(|e| ClientError::TransactionGenerationFailure(e.to_string()))?;
-
-        tx_signer
-            .get_tx()
-            .ok_or(ClientError::TransactionGenerationFailure(
-                "Failed to generate transaction from a transaction signer".to_string(),
-            ))
+            &function_args,
+            &self.stacks_private_key,
+            self.tx_version,
+            self.chain_id,
+            nonce,
+            tx_fee,
+        )
     }
 
     /// Helper function to submit a transaction to the Stacks mempool
diff --git a/stacks-signer/src/config.rs b/stacks-signer/src/config.rs
index 9d8fce6b06..a24f07b4f7 100644
--- a/stacks-signer/src/config.rs
+++ b/stacks-signer/src/config.rs
@@ -1,5 +1,5 @@
 // Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
-// Copyright (C) 2020-2023 Stacks Open Internet Foundation
+// Copyright (C) 2020-2024 Stacks Open Internet Foundation
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -34,7 +34,8 @@ use wsts::curve::scalar::Scalar;
 use wsts::state_machine::PublicKeys;
 
 const EVENT_TIMEOUT_MS: u64 = 5000;
-//TODO: make this zero once special cased transactions are allowed in the stacks node
+// Default transaction fee in microstacks (if unspecificed in the config file)
+// TODO: Use the fee estimation endpoint to get the default fee.
 const TX_FEE_MS: u64 = 10_000;
 
 #[derive(thiserror::Error, Debug)]
diff --git a/stacks-signer/src/coordinator.rs b/stacks-signer/src/coordinator.rs
index 3943be3a2a..817f8a5e9b 100644
--- a/stacks-signer/src/coordinator.rs
+++ b/stacks-signer/src/coordinator.rs
@@ -1,5 +1,5 @@
 // Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
-// Copyright (C) 2020-2023 Stacks Open Internet Foundation
+// Copyright (C) 2020-2024 Stacks Open Internet Foundation
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
diff --git a/stacks-signer/src/main.rs b/stacks-signer/src/main.rs
index 0042b539d0..1e988d1256 100644
--- a/stacks-signer/src/main.rs
+++ b/stacks-signer/src/main.rs
@@ -4,7 +4,7 @@
 //!
 //!
 // Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
-// Copyright (C) 2020-2023 Stacks Open Internet Foundation
+// Copyright (C) 2020-2024 Stacks Open Internet Foundation
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index e3c2c1886d..feec06bb25 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -338,7 +338,7 @@ impl Signer {
                 // For mutability reasons, we need to take the block_info out of the map and add it back after processing
                 let Some(mut block_info) = self.blocks.remove(&signer_signature_hash) else {
                     // We have not seen this block before. Why are we getting a response for it?
-                    debug!("Received a block validate response for a block we have not seen before. Ignoring...");
+                    debug!("Signer #{}: Received a block validate response for a block we have not seen before. Ignoring...", self.signer_id);
                     return;
                 };
                 let is_valid = self.verify_block_transactions(stacks_client, &block_info.block);
@@ -378,7 +378,7 @@ impl Signer {
             }
         };
         if let Some(mut nonce_request) = block_info.nonce_request.take() {
-            debug!("Received a block validate response from the stacks node for a block we already received a nonce request for. Responding to the nonce request...");
+            debug!("Signer #{}: Received a block validate response from the stacks node for a block we already received a nonce request for. Responding to the nonce request...", self.signer_id);
             // We have received validation from the stacks node. Determine our vote and update the request message
             Self::determine_vote(self.signer_id, block_info, &mut nonce_request);
             // Send the nonce request through with our vote
@@ -450,7 +450,10 @@ impl Signer {
             stacks_client
                 .submit_block_for_validation(block.clone())
                 .unwrap_or_else(|e| {
-                    warn!("Failed to submit block for validation: {e:?}");
+                    warn!(
+                        "Signer #{}: Failed to submit block for validation: {e:?}",
+                        self.signer_id
+                    );
                 });
         }
     }
@@ -467,7 +470,10 @@ impl Signer {
             .signing_round
             .process_inbound_messages(packets)
             .unwrap_or_else(|e| {
-                error!("Failed to process inbound messages as a signer: {e:?}");
+                error!(
+                    "Signer #{}: Failed to process inbound messages as a signer: {e:?}",
+                    self.signer_id
+                );
                 vec![]
             });
 
@@ -476,7 +482,10 @@ impl Signer {
             .coordinator
             .process_inbound_messages(packets)
             .unwrap_or_else(|e| {
-                error!("Failed to process inbound messages as a coordinator: {e:?}");
+                error!(
+                    "Signer #{}: Failed to process inbound messages as a coordinator: {e:?}",
+                    self.signer_id
+                );
                 (vec![], vec![])
             });
 
@@ -1208,6 +1217,9 @@ impl Signer {
         if new_aggregate_public_key.is_some()
             && old_aggregate_public_key != new_aggregate_public_key
         {
+            // TODO: this will never work as is. We need to have stored our party shares on the side etc for this particular aggregate key.
+            // Need to update state to store the necessary info, check against it to see if we have participated in the winning round and
+            // then overwrite our value accordingly. Otherwise, we will be locked out of the round and should not participate.
             debug!(
                 "Signer #{}: Received a new aggregate public key ({new_aggregate_public_key:?}) for reward cycle {reward_cycle}. Overwriting its internal aggregate key ({old_aggregate_public_key:?})",
                 self.signer_id

From e4f60289e58a72a13e8be925b12f57995e684d03 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 16 Feb 2024 10:16:53 -0500
Subject: [PATCH 0898/1166] Fix clippy warnings in stacks signer

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/mod.rs       | 8 +++-----
 stacks-signer/src/client/stackerdb.rs | 2 +-
 stacks-signer/src/coordinator.rs      | 6 +++---
 stacks-signer/src/main.rs             | 7 +++----
 stacks-signer/src/runloop.rs          | 6 +++---
 stacks-signer/src/signer.rs           | 4 ++--
 6 files changed, 15 insertions(+), 18 deletions(-)

diff --git a/stacks-signer/src/client/mod.rs b/stacks-signer/src/client/mod.rs
index aaf03e1caf..e819e66c3b 100644
--- a/stacks-signer/src/client/mod.rs
+++ b/stacks-signer/src/client/mod.rs
@@ -444,9 +444,7 @@ pub(crate) mod tests {
                 let signer_public_key =
                     Point::try_from(&Compressed::from(ecdsa_public_key.to_bytes())).unwrap();
                 signer_public_keys.insert(signer_id, signer_public_key);
-                public_keys
-                    .signers
-                    .insert(signer_id, ecdsa_public_key.clone());
+                public_keys.signers.insert(signer_id, ecdsa_public_key);
                 for k in start_key_id..end_key_id {
                     public_keys.key_ids.insert(k, ecdsa_public_key);
                     coordinator_key_ids
@@ -466,7 +464,7 @@ pub(crate) mod tests {
             let signer_public_key =
                 Point::try_from(&Compressed::from(public_key.to_bytes())).unwrap();
             signer_public_keys.insert(signer_id, signer_public_key);
-            public_keys.signers.insert(signer_id, public_key.clone());
+            public_keys.signers.insert(signer_id, public_key);
             for k in start_key_id..end_key_id {
                 public_keys.key_ids.insert(k, public_key);
                 coordinator_key_ids
@@ -483,7 +481,7 @@ pub(crate) mod tests {
                 &StacksPublicKey::from_slice(public_key.to_bytes().as_slice())
                     .expect("Failed to create stacks public key"),
             );
-            signer_address_ids.insert(address.clone(), signer_id);
+            signer_address_ids.insert(address, signer_id);
             addresses.push(address);
             start_key_id = end_key_id;
             coordinator_ids.push(signer_id);
diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index c7fa8494cc..c25384918e 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -53,7 +53,7 @@ impl From<&SignerConfig> for StackerDB {
     fn from(config: &SignerConfig) -> Self {
         StackerDB::new(
             config.node_host,
-            config.stacks_private_key.clone(),
+            config.stacks_private_key,
             config.mainnet,
             config.reward_cycle,
             config.signer_slot_id,
diff --git a/stacks-signer/src/coordinator.rs b/stacks-signer/src/coordinator.rs
index 817f8a5e9b..196ef4e64a 100644
--- a/stacks-signer/src/coordinator.rs
+++ b/stacks-signer/src/coordinator.rs
@@ -121,11 +121,11 @@ impl Selector {
     pub fn get_coordinator(&self) -> (u32, ecdsa::PublicKey) {
         (
             self.coordinator_id,
-            self.public_keys
+            *self
+                .public_keys
                 .signers
                 .get(&self.coordinator_id)
-                .expect("FATAL: missing public key for selected coordinator id")
-                .clone(),
+                .expect("FATAL: missing public key for selected coordinator id"),
         )
     }
 }
diff --git a/stacks-signer/src/main.rs b/stacks-signer/src/main.rs
index 1e988d1256..e59722dd53 100644
--- a/stacks-signer/src/main.rs
+++ b/stacks-signer/src/main.rs
@@ -312,7 +312,7 @@ fn handle_generate_stacking_signature(
         &args.pox_address,
         &private_key, //
         args.reward_cycle.into(),
-        &args.method.topic(),
+        args.method.topic(),
         config.network.to_chain_id(),
         args.period.into(),
     )
@@ -417,14 +417,13 @@ pub mod tests {
             to_hex(signature.as_slice()),
             to_hex(public_key.to_bytes_compressed().as_slice()),
         );
-        let result = execute_v2(&program)
+        execute_v2(&program)
             .expect("FATAL: could not execute program")
             .expect("Expected result")
             .expect_result_ok()
             .expect("Expected ok result")
             .expect_bool()
-            .expect("Expected buff");
-        result
+            .expect("Expected buff")
     }
 
     #[test]
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index e9730b9cc1..f21025f874 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -137,9 +137,9 @@ impl RunLoop {
             key_ids,
             registered_signers,
             coordinator_ids,
-            ecdsa_private_key: self.config.ecdsa_private_key.clone(),
-            stacks_private_key: self.config.stacks_private_key.clone(),
-            node_host: self.config.node_host.clone(),
+            ecdsa_private_key: self.config.ecdsa_private_key,
+            stacks_private_key: self.config.stacks_private_key,
+            node_host: self.config.node_host,
             mainnet: self.config.network.is_mainnet(),
             dkg_end_timeout: self.config.dkg_end_timeout,
             dkg_private_timeout: self.config.dkg_private_timeout,
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index feec06bb25..cec05c643f 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -1259,7 +1259,7 @@ impl Signer {
                         continue;
                     };
                     if Some(point) == self.coordinator.aggregate_public_key
-                        && round == self.coordinator.current_dkg_id as u64
+                        && round == self.coordinator.current_dkg_id
                     {
                         debug!("Signer #{}: Not triggering a DKG round. Already have a pending vote transaction for aggregate public key {point:?} for round {round}...", self.signer_id);
                         return Ok(());
@@ -1273,7 +1273,7 @@ impl Signer {
                 .get_vote_for_aggregate_public_key(
                     self.coordinator.current_dkg_id,
                     self.reward_cycle,
-                    stacks_client.get_signer_address().clone(),
+                    *stacks_client.get_signer_address(),
                 )?
                 .is_some()
             {

From 3fa40b738aa7864b04c5a72896542d96cfe413aa Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 16 Feb 2024 13:10:08 -0500
Subject: [PATCH 0899/1166] Fix verify payload test

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/signer.rs | 365 +++++++++++++++++++++++++++++++-----
 1 file changed, 317 insertions(+), 48 deletions(-)

diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index cec05c643f..7c91ed315d 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -610,6 +610,17 @@ impl Signer {
         stacks_client: &StacksClient,
         block: &NakamotoBlock,
     ) -> bool {
+        let aggregate_key = retry_with_exponential_backoff(|| {
+            stacks_client
+                .get_approved_aggregate_key(self.reward_cycle)
+                .map_err(backoff::Error::transient)
+        })
+        .unwrap_or(None);
+        if aggregate_key.is_some() {
+            // We do not enforce a block contain any transactions except the aggregate votes when it is NOT already set
+            debug!("Signer #{}: Already have an aggregate key for reward cycle {}. Skipping transaction verification...", self.signer_id, self.reward_cycle);
+            return true;
+        }
         let signer_ids = self
             .signing_round
             .public_keys
@@ -784,6 +795,17 @@ impl Signer {
             // The signer is attempting to vote for another signer id than their own
             return Ok(false);
         }
+        let next_reward_cycle = stacks_client.get_current_reward_cycle()?.wrapping_add(1);
+        if reward_cycle != next_reward_cycle {
+            // The signer is attempting to vote for a reward cycle that is not the next reward cycle
+            return Ok(false);
+        }
+        let reward_set_calculated = stacks_client.reward_set_calculated(next_reward_cycle)?;
+        if !reward_set_calculated {
+            // The signer is attempting to vote for a reward cycle that has not yet had its reward set calculated
+            return Ok(false);
+        }
+
         let vote = stacks_client.get_vote_for_aggregate_public_key(
             round,
             reward_cycle,
@@ -793,28 +815,8 @@ impl Signer {
             // The signer has already voted for this round and reward cycle
             return Ok(false);
         }
-        let current_reward_cycle = stacks_client.get_current_reward_cycle()?;
-        let next_reward_cycle = current_reward_cycle.wrapping_add(1);
-        if reward_cycle != current_reward_cycle && reward_cycle != next_reward_cycle {
-            // The signer is attempting to vote for a reward cycle that is not the current or next reward cycle
-            return Ok(false);
-        }
-        let reward_set_calculated = stacks_client.reward_set_calculated(next_reward_cycle)?;
-        if !reward_set_calculated {
-            // The signer is attempting to vote for a reward cycle that has not yet had its reward set calculated
-            return Ok(false);
-        }
 
         let last_round = stacks_client.get_last_round(reward_cycle)?;
-        let aggregate_key = stacks_client.get_approved_aggregate_key(reward_cycle)?;
-
-        if let Some(last_round) = last_round {
-            if aggregate_key.is_some() && round > last_round {
-                // The signer is attempting to vote for a round that is greater than the last round
-                // when the reward cycle has already confirmed an aggregate key
-                return Ok(false);
-            }
-        }
         // TODO: should this be removed? I just am trying to prevent unecessary clogging of the block space
         // TODO: should we impose a limit on the number of special cased transactions allowed for a single signer at any given time?? In theory only 1 would be required per dkg round i.e. per block
         if last_round.unwrap_or(0).saturating_add(2) < round {
@@ -1008,14 +1010,24 @@ impl Signer {
         epoch: StacksEpochId,
     ) -> Result<(), ClientError> {
         let txid = new_transaction.txid();
+        let aggregate_key = retry_with_exponential_backoff(|| {
+            stacks_client
+                .get_approved_aggregate_key(self.reward_cycle)
+                .map_err(backoff::Error::transient)
+        })
+        .unwrap_or(None);
         match epoch {
             StacksEpochId::Epoch25 => {
                 debug!("Signer #{}: Received a DKG result while in epoch 2.5. Broadcast the transaction to the mempool.", self.signer_id);
-                stacks_client.submit_transaction(&new_transaction)?;
-                info!(
-                    "Signer #{}: Submitted DKG vote transaction ({txid:?}) to the mempool",
-                    self.signer_id
-                )
+                if aggregate_key.is_none() {
+                    stacks_client.submit_transaction(&new_transaction)?;
+                    info!(
+                        "Signer #{}: Submitted DKG vote transaction ({txid:?}) to the mempool",
+                        self.signer_id
+                    )
+                } else {
+                    debug!("Signer #{}: Already have an aggregate key for reward cycle {}. Do not broadcast the transaction ({txid:?}).", self.signer_id, self.reward_cycle);
+                }
             }
             StacksEpochId::Epoch30 => {
                 debug!("Signer #{}: Received a DKG result while in epoch 3.0. Broadcast the transaction only to stackerDB.", self.signer_id);
@@ -1028,16 +1040,26 @@ impl Signer {
         // For all Pox-4 epochs onwards, broadcast the results also to stackerDB for other signers/miners to observe
         // TODO: if we store transactions on the side, should we use them rather than directly querying the stacker db slot?
         // TODO: Should we even store transactions if not in prepare phase? Should the miner just ignore all signer transactions if not in prepare phase?
-        // TODO: don't bother storing DKG votes if DKG is already set
-        let mut new_transactions = self.get_filtered_transactions(stacks_client, &[self.signer_id]).map_err(|e| {
+        let new_transactions = if aggregate_key.is_some() {
+            // We do not enforce a block contain any transactions except the aggregate votes when it is NOT already set
+            info!(
+                "Signer #{}: Already has an aggregate key for reward cycle {}. Do not broadcast the transaction ({txid:?}).",
+                self.signer_id, self.reward_cycle
+            );
+            vec![]
+        } else {
+            let mut new_transactions = self.get_filtered_transactions(stacks_client, &[self.signer_id]).map_err(|e| {
             warn!("Signer #{}: Failed to get old transactions: {e:?}. Potentially overwriting our existing stackerDB transactions", self.signer_id);
         }).unwrap_or_default();
-        new_transactions.push(new_transaction);
+            new_transactions.push(new_transaction);
+            new_transactions
+        };
+        let nmb_transactions = new_transactions.len();
         let signer_message = SignerMessage::Transactions(new_transactions);
         self.stackerdb.send_message_with_retry(signer_message)?;
         info!(
-            "Signer #{}: Broadcasted DKG vote transaction ({txid:?}) to stackerDB",
-            self.signer_id
+            "Signer #{}: Broadcasted {nmb_transactions} transaction(s) () to stackerDB",
+            self.signer_id,
         );
         Ok(())
     }
@@ -1404,7 +1426,8 @@ mod tests {
 
     use crate::client::tests::{
         build_get_approved_aggregate_key_response, build_get_last_round_response,
-        generate_signer_config, mock_server_from_config, write_response,
+        build_get_peer_info_response, build_get_pox_data_response, generate_signer_config,
+        mock_server_from_config, write_response,
     };
     use crate::client::{StacksClient, VOTE_FUNCTION_NAME};
     use crate::config::GlobalConfig;
@@ -1675,7 +1698,6 @@ mod tests {
     }
 
     #[test]
-    #[ignore]
     #[serial]
     fn verify_transaction_payload_filters_invalid_payloads() {
         // Create a runloop of a valid signer
@@ -1683,20 +1705,71 @@ mod tests {
         let (mut signer_config, _ordered_addresses) = generate_signer_config(&config, 5, 20);
         signer_config.reward_cycle = 1;
 
+        // valid transaction
         let signer = Signer::from(signer_config.clone());
+        let stacks_client = StacksClient::from(&config);
 
         let signer_private_key = config.stacks_private_key;
         let vote_contract_id = boot_code_id(SIGNERS_VOTING_NAME, signer.mainnet);
         let contract_addr = vote_contract_id.issuer.into();
         let contract_name = vote_contract_id.name.clone();
         let point = Point::from(Scalar::random(&mut thread_rng()));
-        let round = thread_rng().next_u64() as u128;
+        let round = thread_rng().next_u64();
         let valid_function_args = vec![
             Value::UInt(signer.signer_id as u128),
             Value::buff_from(point.compress().data.to_vec()).expect("Failed to create buff"),
-            Value::UInt(thread_rng().next_u64() as u128),
+            Value::UInt(round as u128),
+            Value::UInt(signer.reward_cycle as u128),
         ];
+        let valid_transaction = StacksClient::build_signed_contract_call_transaction(
+            &contract_addr,
+            contract_name.clone(),
+            VOTE_FUNCTION_NAME.into(),
+            &valid_function_args,
+            &signer_private_key,
+            TransactionVersion::Testnet,
+            config.network.to_chain_id(),
+            1,
+            10,
+        )
+        .unwrap();
 
+        let reward_cycle_response = build_get_pox_data_response(
+            Some(signer.reward_cycle.saturating_sub(1)),
+            None,
+            None,
+            None,
+        )
+        .0;
+        let pox_info_response = build_get_pox_data_response(
+            Some(signer.reward_cycle.saturating_sub(1)),
+            Some(0),
+            None,
+            None,
+        )
+        .0;
+        let peer_info = build_get_peer_info_response(Some(1), None).0;
+        let vote_response = build_get_approved_aggregate_key_response(None);
+        let last_round_response = build_get_last_round_response(round);
+
+        let h = spawn(move || {
+            assert!(signer
+                .verify_payload(&stacks_client, &valid_transaction, signer.signer_id)
+                .unwrap())
+        });
+        let mock_server = mock_server_from_config(&config);
+        write_response(mock_server, reward_cycle_response.as_bytes());
+        let mock_server = mock_server_from_config(&config);
+        write_response(mock_server, pox_info_response.as_bytes());
+        let mock_server = mock_server_from_config(&config);
+        write_response(mock_server, peer_info.as_bytes());
+        let mock_server = mock_server_from_config(&config);
+        write_response(mock_server, vote_response.as_bytes());
+        let mock_server = mock_server_from_config(&config);
+        write_response(mock_server, last_round_response.as_bytes());
+        h.join().unwrap();
+
+        let signer = Signer::from(signer_config.clone());
         // Create a invalid transaction that is not a contract call
         let invalid_not_contract_call = StacksTransaction {
             version: TransactionVersion::Testnet,
@@ -1757,7 +1830,80 @@ mod tests {
             &[
                 Value::UInt(signer.signer_id.wrapping_add(1) as u128), // Not the signers id
                 Value::buff_from(point.compress().data.to_vec()).expect("Failed to create buff"),
-                Value::UInt(round),
+                Value::UInt(round as u128),
+                Value::UInt(signer.reward_cycle as u128),
+            ],
+            &signer_private_key,
+            TransactionVersion::Testnet,
+            config.network.to_chain_id(),
+            1,
+            10,
+        )
+        .unwrap();
+
+        let invalid_function_arg_1 = StacksClient::build_signed_contract_call_transaction(
+            &contract_addr,
+            contract_name.clone(),
+            VOTE_FUNCTION_NAME.into(),
+            &[
+                Value::buff_from(point.compress().data.to_vec()).expect("Failed to create buff"),
+                Value::buff_from(point.compress().data.to_vec()).expect("Failed to create buff"),
+                Value::UInt(round as u128),
+                Value::UInt(signer.reward_cycle as u128),
+            ],
+            &signer_private_key,
+            TransactionVersion::Testnet,
+            config.network.to_chain_id(),
+            1,
+            10,
+        )
+        .unwrap();
+
+        let invalid_function_arg_2 = StacksClient::build_signed_contract_call_transaction(
+            &contract_addr,
+            contract_name.clone(),
+            VOTE_FUNCTION_NAME.into(),
+            &[
+                Value::UInt(signer.signer_id as u128),
+                Value::UInt(signer.signer_id as u128),
+                Value::UInt(round as u128),
+                Value::UInt(signer.reward_cycle as u128),
+            ],
+            &signer_private_key,
+            TransactionVersion::Testnet,
+            config.network.to_chain_id(),
+            1,
+            10,
+        )
+        .unwrap();
+
+        let invalid_function_arg_3 = StacksClient::build_signed_contract_call_transaction(
+            &contract_addr,
+            contract_name.clone(),
+            VOTE_FUNCTION_NAME.into(),
+            &[
+                Value::UInt(signer.signer_id as u128),
+                Value::buff_from(point.compress().data.to_vec()).expect("Failed to create buff"),
+                Value::buff_from(point.compress().data.to_vec()).expect("Failed to create buff"),
+                Value::UInt(signer.reward_cycle as u128),
+            ],
+            &signer_private_key,
+            TransactionVersion::Testnet,
+            config.network.to_chain_id(),
+            1,
+            10,
+        )
+        .unwrap();
+
+        let invalid_function_arg_4 = StacksClient::build_signed_contract_call_transaction(
+            &contract_addr,
+            contract_name.clone(),
+            VOTE_FUNCTION_NAME.into(),
+            &[
+                Value::UInt(signer.signer_id as u128),
+                Value::buff_from(point.compress().data.to_vec()).expect("Failed to create buff"),
+                Value::UInt(round as u128),
+                Value::buff_from(point.compress().data.to_vec()).expect("Failed to create buff"),
             ],
             &signer_private_key,
             TransactionVersion::Testnet,
@@ -1774,6 +1920,10 @@ mod tests {
             invalid_signers_contract_name,
             invalid_signers_vote_function,
             invalid_signer_id_argument,
+            invalid_function_arg_1,
+            invalid_function_arg_2,
+            invalid_function_arg_3,
+            invalid_function_arg_4,
         ] {
             let result = signer
                 .verify_payload(&stacks_client, &tx, signer.signer_id)
@@ -1781,6 +1931,81 @@ mod tests {
             assert!(!result);
         }
 
+        // Invalid reward cycle (voting for the current is not allowed. only the next)
+        let signer = Signer::from(signer_config.clone());
+        let invalid_reward_cycle = StacksClient::build_signed_contract_call_transaction(
+            &contract_addr,
+            contract_name.clone(),
+            VOTE_FUNCTION_NAME.into(),
+            &valid_function_args,
+            &signer_private_key,
+            TransactionVersion::Testnet,
+            config.network.to_chain_id(),
+            1,
+            10,
+        )
+        .unwrap();
+        let (reward_cycle_response, _) =
+            build_get_pox_data_response(Some(signer.reward_cycle), None, None, None);
+        let h = spawn(move || {
+            assert!(!signer
+                .verify_payload(&stacks_client, &invalid_reward_cycle, signer.signer_id)
+                .unwrap())
+        });
+        let mock_server = mock_server_from_config(&config);
+        write_response(mock_server, reward_cycle_response.as_bytes());
+        h.join().unwrap();
+
+        // Invalid block height to vote
+        let signer = Signer::from(signer_config.clone());
+        let stacks_client = StacksClient::from(&config);
+        let invalid_reward_set = StacksClient::build_signed_contract_call_transaction(
+            &contract_addr,
+            contract_name.clone(),
+            VOTE_FUNCTION_NAME.into(),
+            &valid_function_args,
+            &signer_private_key,
+            TransactionVersion::Testnet,
+            config.network.to_chain_id(),
+            1,
+            10,
+        )
+        .unwrap();
+
+        // Valid reward cycle vote
+        let reward_cycle_response = build_get_pox_data_response(
+            Some(signer.reward_cycle.saturating_sub(1)),
+            None,
+            None,
+            None,
+        )
+        .0;
+        // Invalid reward set not calculated (not in the second block onwards of the prepare phase)
+        let pox_info_response = build_get_pox_data_response(
+            Some(signer.reward_cycle.saturating_sub(1)),
+            Some(0),
+            None,
+            None,
+        )
+        .0;
+        let peer_info = build_get_peer_info_response(Some(0), None).0;
+
+        let h = spawn(move || {
+            assert!(!signer
+                .verify_payload(&stacks_client, &invalid_reward_set, signer.signer_id)
+                .unwrap())
+        });
+        let mock_server = mock_server_from_config(&config);
+        write_response(mock_server, reward_cycle_response.as_bytes());
+        let mock_server = mock_server_from_config(&config);
+        write_response(mock_server, pox_info_response.as_bytes());
+        let mock_server = mock_server_from_config(&config);
+        write_response(mock_server, peer_info.as_bytes());
+        h.join().unwrap();
+
+        // Already voted
+        let signer = Signer::from(signer_config.clone());
+        let stacks_client = StacksClient::from(&config);
         let invalid_already_voted = StacksClient::build_signed_contract_call_transaction(
             &contract_addr,
             contract_name.clone(),
@@ -1794,30 +2019,52 @@ mod tests {
         )
         .unwrap();
 
+        // Valid reward cycle vote
+        let reward_cycle_response = build_get_pox_data_response(
+            Some(signer.reward_cycle.saturating_sub(1)),
+            None,
+            None,
+            None,
+        )
+        .0;
+        let pox_info_response = build_get_pox_data_response(
+            Some(signer.reward_cycle.saturating_sub(1)),
+            Some(0),
+            None,
+            None,
+        )
+        .0;
+        let peer_info = build_get_peer_info_response(Some(1), None).0;
+        let vote_response = build_get_approved_aggregate_key_response(Some(point));
+
         let h = spawn(move || {
             assert!(!signer
                 .verify_payload(&stacks_client, &invalid_already_voted, signer.signer_id)
                 .unwrap())
         });
-        let vote_response = build_get_approved_aggregate_key_response(Some(point));
+        let mock_server = mock_server_from_config(&config);
+        write_response(mock_server, reward_cycle_response.as_bytes());
+        let mock_server = mock_server_from_config(&config);
+        write_response(mock_server, pox_info_response.as_bytes());
+        let mock_server = mock_server_from_config(&config);
+        write_response(mock_server, peer_info.as_bytes());
         let mock_server = mock_server_from_config(&config);
         write_response(mock_server, vote_response.as_bytes());
         h.join().unwrap();
 
-        let signer = Signer::from(signer_config);
-
-        let vote_response = build_get_approved_aggregate_key_response(None);
-        let last_round_response = build_get_last_round_response(10);
-        let aggregate_public_key_response = build_get_approved_aggregate_key_response(Some(point));
-
-        let invalid_round_number = StacksClient::build_signed_contract_call_transaction(
+        // Already voted
+        let signer = Signer::from(signer_config.clone());
+        let stacks_client = StacksClient::from(&config);
+        let round: u128 = 0;
+        let invalid_already_voted = StacksClient::build_signed_contract_call_transaction(
             &contract_addr,
             contract_name.clone(),
             VOTE_FUNCTION_NAME.into(),
             &[
                 Value::UInt(signer.signer_id as u128),
                 Value::buff_from(point.compress().data.to_vec()).expect("Failed to create buff"),
-                Value::UInt(round.wrapping_add(1)), // Voting for a future round than the last one seen AFTER dkg is set
+                Value::UInt(round.saturating_add(3)),
+                Value::UInt(signer.reward_cycle as u128),
             ],
             &signer_private_key,
             TransactionVersion::Testnet,
@@ -1827,18 +2074,40 @@ mod tests {
         )
         .unwrap();
 
-        let stacks_client = StacksClient::from(&config);
+        // invalid round number
+        let reward_cycle_response = build_get_pox_data_response(
+            Some(signer.reward_cycle.saturating_sub(1)),
+            None,
+            None,
+            None,
+        )
+        .0;
+        let pox_info_response = build_get_pox_data_response(
+            Some(signer.reward_cycle.saturating_sub(1)),
+            Some(0),
+            None,
+            None,
+        )
+        .0;
+        let peer_info = build_get_peer_info_response(Some(1), None).0;
+        let vote_response = build_get_approved_aggregate_key_response(None);
+        let last_round_response = build_get_last_round_response(0);
+
         let h = spawn(move || {
             assert!(!signer
-                .verify_payload(&stacks_client, &invalid_round_number, signer.signer_id)
+                .verify_payload(&stacks_client, &invalid_already_voted, signer.signer_id)
                 .unwrap())
         });
         let mock_server = mock_server_from_config(&config);
+        write_response(mock_server, reward_cycle_response.as_bytes());
+        let mock_server = mock_server_from_config(&config);
+        write_response(mock_server, pox_info_response.as_bytes());
+        let mock_server = mock_server_from_config(&config);
+        write_response(mock_server, peer_info.as_bytes());
+        let mock_server = mock_server_from_config(&config);
         write_response(mock_server, vote_response.as_bytes());
         let mock_server = mock_server_from_config(&config);
         write_response(mock_server, last_round_response.as_bytes());
-        let mock_server = mock_server_from_config(&config);
-        write_response(mock_server, aggregate_public_key_response.as_bytes());
         h.join().unwrap();
     }
 }

From efd6352b58bf02023cbd591a58d6ede3133c0018 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 16 Feb 2024 18:50:43 -0500
Subject: [PATCH 0900/1166] If no reward set is found for a reward cycle, do
 not check again

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/mod.rs           |   3 +
 stacks-signer/src/client/stacks_client.rs |  75 ++++--
 stacks-signer/src/config.rs               |   3 +
 stacks-signer/src/runloop.rs              | 166 ++++++-------
 stacks-signer/src/signer.rs               | 269 +++++++++++++---------
 5 files changed, 308 insertions(+), 208 deletions(-)

diff --git a/stacks-signer/src/client/mod.rs b/stacks-signer/src/client/mod.rs
index e819e66c3b..fb0c3c9bea 100644
--- a/stacks-signer/src/client/mod.rs
+++ b/stacks-signer/src/client/mod.rs
@@ -426,6 +426,7 @@ pub(crate) mod tests {
         let mut start_key_id = 1u32;
         let mut end_key_id = start_key_id;
         let mut signer_public_keys = HashMap::new();
+        let mut signer_slot_ids = HashMap::new();
         let mut coordinator_ids = vec![];
         let stacks_address = config.stacks_address;
         let ecdsa_private_key = config.ecdsa_private_key;
@@ -481,6 +482,7 @@ pub(crate) mod tests {
                 &StacksPublicKey::from_slice(public_key.to_bytes().as_slice())
                     .expect("Failed to create stacks public key"),
             );
+            signer_slot_ids.insert(address, signer_id); // Note in a real world situation, these would not always match
             signer_address_ids.insert(address, signer_id);
             addresses.push(address);
             start_key_id = end_key_id;
@@ -493,6 +495,7 @@ pub(crate) mod tests {
                 signer_slot_id: 0,
                 key_ids: signer_key_ids.get(&0).cloned().unwrap_or_default(),
                 registered_signers: RegisteredSignersInfo {
+                    signer_slot_ids,
                     public_keys,
                     coordinator_key_ids,
                     signer_key_ids,
diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index 63d75b40fb..82eb50c41a 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -17,7 +17,7 @@ use std::net::SocketAddr;
 
 use blockstack_lib::burnchains::Txid;
 use blockstack_lib::chainstate::nakamoto::NakamotoBlock;
-use blockstack_lib::chainstate::stacks::boot::{RewardSet, SIGNERS_VOTING_NAME};
+use blockstack_lib::chainstate::stacks::boot::{RewardSet, SIGNERS_NAME, SIGNERS_VOTING_NAME};
 use blockstack_lib::chainstate::stacks::{
     StacksTransaction, StacksTransactionSigner, TransactionAnchorMode, TransactionAuth,
     TransactionContractCall, TransactionPayload, TransactionPostConditionMode,
@@ -119,10 +119,7 @@ impl StacksClient {
 
     /// Calculate the ordered list of coordinator ids by comparing the provided public keys against the pox consensus hash
     pub fn calculate_coordinator_ids(&self, public_keys: &PublicKeys) -> Vec<u32> {
-        let pox_consensus_hash = match retry_with_exponential_backoff(|| {
-            self.get_pox_consenus_hash()
-                .map_err(backoff::Error::transient)
-        }) {
+        let pox_consensus_hash = match self.get_pox_consenus_hash() {
             Ok(hash) => hash,
             Err(e) => {
                 debug!("Failed to get stacks tip consensus hash: {e:?}");
@@ -360,8 +357,12 @@ impl StacksClient {
     }
 
     /// Retrieve the vote of the signer for the given round
-    pub fn get_signer_vote(&self, round: u128) -> Result<Option<Point>, ClientError> {
-        let reward_cycle = ClarityValue::UInt(self.get_current_reward_cycle()? as u128);
+    pub fn get_signer_vote(
+        &self,
+        reward_cycle: u64,
+        round: u128,
+    ) -> Result<Option<Point>, ClientError> {
+        let reward_cycle = ClarityValue::UInt(reward_cycle as u128);
         let round = ClarityValue::UInt(round);
         let signer = ClarityValue::Principal(self.stacks_address.into());
         let contract_addr = boot_code_addr(self.mainnet);
@@ -381,10 +382,12 @@ impl StacksClient {
         if current_reward_cycle >= reward_cycle {
             // We have already entered into this reward cycle or beyond
             // therefore the reward set has already been calculated
+            debug!("Reward set has already been calculated for reward cycle {reward_cycle}.");
             return Ok(true);
         }
         if current_reward_cycle.wrapping_add(1) != reward_cycle {
             // We are not in the prepare phase of the reward cycle as the upcoming cycle nor are we in the current reward cycle...
+            debug!("Reward set has not been calculated for reward cycle {reward_cycle}. We are not in the requested reward cycle yet.");
             return Ok(false);
         }
         let burn_block_height = self.get_burn_block_height()?;
@@ -393,7 +396,7 @@ impl StacksClient {
     }
 
     /// Get the reward set from the stacks node for the given reward cycle
-    fn get_reward_set(&self, reward_cycle: u64) -> Result<RewardSet, ClientError> {
+    pub fn get_reward_set(&self, reward_cycle: u64) -> Result<RewardSet, ClientError> {
         debug!("Getting reward set for reward cycle {reward_cycle}...");
         let send_request = || {
             self.stacks_node_client
@@ -409,16 +412,25 @@ impl StacksClient {
         Ok(stackers_response.stacker_set)
     }
 
-    /// Get registered signers info for the given reward cycle
+    /// Get the registered signers for a specific reward cycle
+    /// Returns None if no signers are registered or its not Nakamoto cycle
     pub fn get_registered_signers_info(
         &self,
         reward_cycle: u64,
     ) -> Result<Option<RegisteredSignersInfo>, ClientError> {
-        let reward_set = self.get_reward_set(reward_cycle)?;
+        debug!("Getting registered signers for reward cycle {reward_cycle}...");
+        let Ok(reward_set) = self.get_reward_set(reward_cycle) else {
+            warn!("No reward set found for reward cycle {reward_cycle}.");
+            return Ok(None);
+        };
         let Some(reward_set_signers) = reward_set.signers else {
+            warn!("No reward set signers found for reward cycle {reward_cycle}.");
             return Ok(None);
         };
-
+        if reward_set_signers.is_empty() {
+            warn!("No registered signers found for reward cycle {reward_cycle}.");
+            return Ok(None);
+        }
         // signer uses a Vec<u32> for its key_ids, but coordinator uses a HashSet for each signer since it needs to do lots of lookups
         let mut weight_end = 1;
         let mut coordinator_key_ids = HashMap::with_capacity(4000);
@@ -432,10 +444,10 @@ impl StacksClient {
         for (i, entry) in reward_set_signers.iter().enumerate() {
             let signer_id = u32::try_from(i).expect("FATAL: number of signers exceeds u32::MAX");
             let ecdsa_public_key = ecdsa::PublicKey::try_from(entry.signing_key.as_slice()).map_err(|e| {
-                        ClientError::CorruptedRewardSet(format!(
-                                "Reward cycle {reward_cycle} failed to convert signing key to ecdsa::PublicKey: {e}"
-                            ))
-                        })?;
+                ClientError::CorruptedRewardSet(format!(
+                        "Reward cycle {reward_cycle} failed to convert signing key to ecdsa::PublicKey: {e}"
+                    ))
+                })?;
             let signer_public_key = Point::try_from(&Compressed::from(ecdsa_public_key.to_bytes()))
                 .map_err(|e| {
                     ClientError::CorruptedRewardSet(format!(
@@ -443,10 +455,10 @@ impl StacksClient {
                     ))
                 })?;
             let stacks_public_key = StacksPublicKey::from_slice(entry.signing_key.as_slice()).map_err(|e| {
-                            ClientError::CorruptedRewardSet(format!(
-                                "Reward cycle {reward_cycle} failed to convert signing key to StacksPublicKey: {e}"
-                            ))
-                        })?;
+                    ClientError::CorruptedRewardSet(format!(
+                        "Reward cycle {reward_cycle} failed to convert signing key to StacksPublicKey: {e}"
+                    ))
+                })?;
 
             let stacks_address = StacksAddress::p2pkh(self.mainnet, &stacks_public_key);
 
@@ -467,12 +479,36 @@ impl StacksClient {
                     .push(key_id);
             }
         }
+
+        let signer_set =
+            u32::try_from(reward_cycle % 2).expect("FATAL: reward_cycle % 2 exceeds u32::MAX");
+        let signer_stackerdb_contract_id = boot_code_id(SIGNERS_NAME, self.mainnet);
+        // Get the signer writers from the stacker-db to find the signer slot id
+        let signer_slots_weights = self
+            .get_stackerdb_signer_slots(&signer_stackerdb_contract_id, signer_set)
+            .unwrap();
+        let mut signer_slot_ids = HashMap::with_capacity(signer_slots_weights.len());
+        for (index, (address, _)) in signer_slots_weights.into_iter().enumerate() {
+            signer_slot_ids.insert(
+                address,
+                u32::try_from(index).expect("FATAL: number of signers exceeds u32::MAX"),
+            );
+        }
+
+        for address in signer_address_ids.keys().into_iter() {
+            if !signer_slot_ids.contains_key(address) {
+                debug!("Signer {address} does not have a slot id in the stackerdb");
+                return Ok(None);
+            }
+        }
+
         Ok(Some(RegisteredSignersInfo {
             public_keys,
             signer_key_ids,
             signer_address_ids,
             signer_public_keys,
             coordinator_key_ids,
+            signer_slot_ids,
         }))
     }
 
@@ -502,6 +538,7 @@ impl StacksClient {
     /// Get the current reward cycle from the stacks node
     pub fn get_current_reward_cycle(&self) -> Result<u64, ClientError> {
         let pox_data = self.get_pox_data()?;
+        println!("GOT REWARD CYCLE: {}", pox_data.reward_cycle_id);
         Ok(pox_data.reward_cycle_id)
     }
 
diff --git a/stacks-signer/src/config.rs b/stacks-signer/src/config.rs
index a24f07b4f7..d06f3a5f8a 100644
--- a/stacks-signer/src/config.rs
+++ b/stacks-signer/src/config.rs
@@ -124,6 +124,9 @@ pub struct RegisteredSignersInfo {
     pub signer_address_ids: HashMap<StacksAddress, u32>,
     /// The public keys for the reward cycle
     pub public_keys: PublicKeys,
+    /// The signer slot id for a signer address registered in stackerdb
+    /// This corresponds to their unique index when voting in a reward cycle
+    pub signer_slot_ids: HashMap<StacksAddress, u32>,
 }
 
 /// The Configuration info needed for an individual signer per reward cycle
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index f21025f874..1aa3bf28f4 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -16,8 +16,6 @@
 use std::sync::mpsc::Sender;
 use std::time::Duration;
 
-use blockstack_lib::chainstate::stacks::boot::SIGNERS_NAME;
-use blockstack_lib::util_lib::boot::boot_code_id;
 use hashbrown::HashMap;
 use libsigner::{SignerEvent, SignerRunLoop};
 use slog::{slog_debug, slog_error, slog_info, slog_warn};
@@ -85,41 +83,32 @@ impl RunLoop {
             // Accounts for Pre nakamoto by simply using the second block of a prepare phase as the criteria
             return Err(ClientError::RewardSetNotYetCalculated(reward_cycle));
         }
-        let current_addr = self.stacks_client.get_signer_address();
-
-        let signer_set =
-            u32::try_from(reward_cycle % 2).expect("FATAL: reward_cycle % 2 exceeds u32::MAX");
-        let signer_stackerdb_contract_id =
-            boot_code_id(SIGNERS_NAME, self.config.network.is_mainnet());
-        // Get the signer writers from the stacker-db to find the signer slot id
-        let Some(signer_slot_id) = self
+        // We can only register for a reward cycle if a reward set exists. We know that it should exist due to our earlier check for reward_set_calculated
+        let Some(registered_signers) = self
             .stacks_client
-            .get_stackerdb_signer_slots(&signer_stackerdb_contract_id, signer_set)?
-            .iter()
-            .position(|(address, _)| address == current_addr)
-            .map(|pos| u32::try_from(pos).expect("FATAL: number of signers exceeds u32::MAX"))
+            .get_registered_signers_info(reward_cycle)?
         else {
             warn!(
-                "Signer {current_addr} was not found in stacker db. Must not be registered for this reward cycle {reward_cycle}."
+                "Failed to retrieve registered signers info for reward cycle {reward_cycle}. Must not be a valid Nakamoto reward cycle."
             );
             return Ok(None);
         };
 
-        // We can only register for a reward cycle if a reward set exists. We know that it should exist due to our earlier check for reward_set_calculated
-        let Some(registered_signers) = self
-            .stacks_client
-            .get_registered_signers_info(reward_cycle)?
-        else {
+        let current_addr = self.stacks_client.get_signer_address();
+
+        let Some(signer_slot_id) = registered_signers.signer_slot_ids.get(current_addr) else {
             warn!(
-                "No reward set found for reward cycle {reward_cycle}. Must not be a valid Nakamoto reward cycle."
-            );
+                    "Signer {current_addr} was not found in stacker db. Must not be registered for this reward cycle {reward_cycle}."
+                );
             return Ok(None);
         };
         let Some(signer_id) = registered_signers.signer_address_ids.get(current_addr) else {
-            warn!("Signer {current_addr} was found in stacker db but not the reward set for reward cycle {reward_cycle}.");
+            warn!(
+                "Signer {current_addr} was found in stacker db but not the reward set for reward cycle {reward_cycle}."
+            );
             return Ok(None);
         };
-        debug!(
+        info!(
             "Signer #{signer_id} ({current_addr}) is registered for reward cycle {reward_cycle}."
         );
         let key_ids = registered_signers
@@ -133,7 +122,7 @@ impl RunLoop {
         Ok(Some(SignerConfig {
             reward_cycle,
             signer_id: *signer_id,
-            signer_slot_id,
+            signer_slot_id: *signer_slot_id,
             key_ids,
             registered_signers,
             coordinator_ids,
@@ -155,7 +144,7 @@ impl RunLoop {
         let reward_index = reward_cycle % 2;
         let mut needs_refresh = false;
         if let Some(stacks_signer) = self.stacks_signers.get_mut(&reward_index) {
-            let old_reward_cycle = stacks_signer.reward_cycle;
+            let old_reward_cycle = stacks_signer.reward_cycle();
             if old_reward_cycle == reward_cycle {
                 //If the signer is already registered for the reward cycle, we don't need to do anything further here
                 debug!("Signer is already configured for reward cycle {reward_cycle}. No need to update it's state machines.")
@@ -176,6 +165,8 @@ impl RunLoop {
             } else {
                 // Nothing to initialize. Signer is not registered for this reward cycle
                 debug!("Signer is not registered for reward cycle {reward_cycle}. Nothing to initialize.");
+                self.stacks_signers
+                    .insert(reward_index, Signer::from(reward_cycle));
             }
         }
         Ok(())
@@ -183,13 +174,9 @@ impl RunLoop {
 
     /// Refresh the signer configuration by retrieving the necessary information from the stacks node
     /// Note: this will trigger DKG if required
-    fn refresh_signers_with_retry(&mut self) -> Result<(), ClientError> {
+    fn refresh_signers_with_retry(&mut self, current_reward_cycle: u64) -> Result<(), ClientError> {
+        let next_reward_cycle = current_reward_cycle.saturating_add(1);
         retry_with_exponential_backoff(|| {
-            let current_reward_cycle = self
-                .stacks_client
-                .get_current_reward_cycle()
-                .map_err(backoff::Error::transient)?;
-            let next_reward_cycle = current_reward_cycle.saturating_add(1);
             if let Err(e) = self.refresh_signer_config(current_reward_cycle) {
                 match e {
                     ClientError::NotRegistered => {
@@ -214,20 +201,22 @@ impl RunLoop {
                 }
             }
             for stacks_signer in self.stacks_signers.values_mut() {
-                let updated_coordinator = stacks_signer
-                    .coordinator_selector
-                    .refresh_coordinator(&self.stacks_client);
-                if updated_coordinator {
-                    debug!(
-                        "Signer #{}: Coordinator has been updated. Resetting state to Idle.",
-                        stacks_signer.signer_id
-                    );
-                    stacks_signer.coordinator.state = CoordinatorState::Idle;
-                    stacks_signer.state = SignerState::Idle;
+                if let Signer::Registered(signer) = stacks_signer {
+                    let updated_coordinator = signer
+                        .coordinator_selector
+                        .refresh_coordinator(&self.stacks_client);
+                    if updated_coordinator {
+                        debug!(
+                            "Signer #{}: Coordinator has been updated. Resetting state to Idle.",
+                            signer.signer_id
+                        );
+                        signer.coordinator.state = CoordinatorState::Idle;
+                        signer.state = SignerState::Idle;
+                    }
+                    signer
+                        .update_dkg(&self.stacks_client, current_reward_cycle)
+                        .map_err(backoff::Error::transient)?;
                 }
-                stacks_signer
-                    .update_dkg(&self.stacks_client)
-                    .map_err(backoff::Error::transient)?;
             }
             if self.stacks_signers.is_empty() {
                 info!("Signer is not registered for the current {current_reward_cycle} or next {next_reward_cycle} reward cycles. Waiting for confirmed registration...");
@@ -239,23 +228,6 @@ impl RunLoop {
             Ok(())
         })
     }
-
-    /// Cleanup stale signers that have exceeded their tenure
-    fn cleanup_stale_signers(&mut self) {
-        let mut to_delete = Vec::with_capacity(self.stacks_signers.len());
-        for (index, stacks_signer) in self.stacks_signers.iter() {
-            if stacks_signer.state == SignerState::TenureExceeded {
-                debug!(
-                    "Deleting signer for stale reward cycle: {}.",
-                    stacks_signer.reward_cycle
-                );
-                to_delete.push(*index);
-            }
-        }
-        for index in to_delete {
-            self.stacks_signers.remove(&index);
-        }
-    }
 }
 
 impl SignerRunLoop<Vec<OperationResult>, RunLoopCommand> for RunLoop {
@@ -277,7 +249,15 @@ impl SignerRunLoop<Vec<OperationResult>, RunLoopCommand> for RunLoop {
             "Running one pass for the signer. Current state: {:?}",
             self.state
         );
-        if let Err(e) = self.refresh_signers_with_retry() {
+        let Ok(current_reward_cycle) = retry_with_exponential_backoff(|| {
+            self.stacks_client
+                .get_current_reward_cycle()
+                .map_err(backoff::Error::transient)
+        }) else {
+            error!("Failed to retrieve current reward cycle. Ignoring event: {event:?}");
+            return None;
+        };
+        if let Err(e) = self.refresh_signers_with_retry(current_reward_cycle) {
             if self.state == State::Uninitialized {
                 // If we were never actually initialized, we cannot process anything. Just return.
                 error!("Failed to initialize signers. Are you sure this signer is correctly registered for the current or next reward cycle?");
@@ -290,21 +270,31 @@ impl SignerRunLoop<Vec<OperationResult>, RunLoopCommand> for RunLoop {
         if let Some(command) = cmd {
             let reward_cycle = command.reward_cycle;
             if let Some(stacks_signer) = self.stacks_signers.get_mut(&(reward_cycle % 2)) {
-                if stacks_signer.reward_cycle != reward_cycle {
-                    warn!(
-                        "Signer #{}: not registered for reward cycle {reward_cycle}. Ignoring command: {command:?}", stacks_signer.signer_id
+                match stacks_signer {
+                    Signer::Registered(signer) => {
+                        if signer.reward_cycle != reward_cycle {
+                            warn!(
+                        "Signer #{}: not registered for reward cycle {reward_cycle}. Ignoring command: {command:?}", signer.signer_id
                     );
-                } else {
-                    info!(
+                        } else {
+                            info!(
                         "Signer #{}: Queuing an external runloop command ({:?}): {command:?}",
-                        stacks_signer.signer_id,
-                        stacks_signer
+                        signer.signer_id,
+                        signer
                             .signing_round
                             .public_keys
                             .signers
-                            .get(&stacks_signer.signer_id)
+                            .get(&signer.signer_id)
                     );
-                    stacks_signer.commands.push_back(command.command);
+                            signer.commands.push_back(command.command);
+                        }
+                    }
+                    Signer::Unregistered(_) => {
+                        warn!(
+                            "Signer: not registered for reward cycle {reward_cycle}. Ignoring command: {command:?}"
+                        );
+                        return None;
+                    }
                 }
             } else {
                 warn!(
@@ -313,19 +303,29 @@ impl SignerRunLoop<Vec<OperationResult>, RunLoopCommand> for RunLoop {
             }
         }
         for stacks_signer in self.stacks_signers.values_mut() {
-            if let Err(e) =
-                stacks_signer.process_event(&self.stacks_client, event.as_ref(), res.clone())
-            {
-                error!(
-                    "Signer #{} for reward cycle {} errored processing event: {e}",
-                    stacks_signer.signer_id, stacks_signer.reward_cycle
-                );
+            match stacks_signer {
+                Signer::Registered(signer) => {
+                    if let Err(e) = signer.process_event(
+                        &self.stacks_client,
+                        event.as_ref(),
+                        res.clone(),
+                        current_reward_cycle,
+                    ) {
+                        error!(
+                            "Signer #{} for reward cycle {} errored processing event: {e}",
+                            signer.signer_id, signer.reward_cycle
+                        );
+                    }
+                    // After processing event, run the next command for each signer
+                    signer.process_next_command(&self.stacks_client);
+                }
+                Signer::Unregistered(_) => {
+                    warn!(
+                        "Signer is not registered for any reward cycle. Ignoring event: {event:?}"
+                    );
+                }
             }
-            // After processing event, run the next command for each signer
-            stacks_signer.process_next_command(&self.stacks_client);
         }
-        // Cleanup any stale signers
-        self.cleanup_stale_signers();
         None
     }
 }
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index 7c91ed315d..9ae809c0e7 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -110,12 +110,65 @@ pub enum State {
     Idle,
     /// The signer is executing a DKG or Sign round
     OperationInProgress,
-    /// The Signer has exceeded its tenure
-    TenureExceeded,
+}
+/// The stacks signer for a reward cycle
+pub enum Signer {
+    /// A registered signer
+    Registered(RegisteredSigner),
+    /// An unregistered signer
+    Unregistered(UnregisteredSigner),
+}
+
+impl Signer {
+    /// Get the reward cycle of the internal signer
+    pub fn reward_cycle(&self) -> u64 {
+        match self {
+            Self::Registered(signer) => signer.reward_cycle,
+            Self::Unregistered(signer) => signer.reward_cycle,
+        }
+    }
+
+    /// Get the state of the internal signer
+    pub fn state(&self) -> State {
+        match self {
+            Self::Registered(signer) => signer.state.clone(),
+            Self::Unregistered(signer) => signer.state.clone(),
+        }
+    }
+}
+
+/// The stacks signer unregistered for the reward cycle
+pub struct UnregisteredSigner {
+    /// The reward cycle this signer belongs to
+    pub reward_cycle: u64,
+    /// the state of the signer (Can only be Idle)
+    pub state: State,
 }
 
-/// The stacks signer for the rewrad cycle
-pub struct Signer {
+impl UnregisteredSigner {
+    /// Create a new signer which is not registered for the reward cycle
+    pub fn new(reward_cycle: u64) -> Self {
+        Self {
+            reward_cycle,
+            state: State::Idle,
+        }
+    }
+}
+
+impl From<SignerConfig> for Signer {
+    fn from(signer_config: SignerConfig) -> Self {
+        Self::Registered(RegisteredSigner::from(signer_config))
+    }
+}
+
+impl From<u64> for Signer {
+    fn from(reward_cycle: u64) -> Self {
+        Self::Unregistered(UnregisteredSigner::new(reward_cycle))
+    }
+}
+
+/// The stacks signer registered for the reward cycle
+pub struct RegisteredSigner {
     /// The coordinator for inbound messages for a specific reward cycle
     pub coordinator: FireCoordinator<v2::Aggregator>,
     /// The signing round used to sign messages for a specific reward cycle
@@ -143,7 +196,7 @@ pub struct Signer {
     pub coordinator_selector: Selector,
 }
 
-impl From<SignerConfig> for Signer {
+impl From<SignerConfig> for RegisteredSigner {
     fn from(signer_config: SignerConfig) -> Self {
         let stackerdb = StackerDB::from(&signer_config);
 
@@ -200,7 +253,7 @@ impl From<SignerConfig> for Signer {
     }
 }
 
-impl Signer {
+impl RegisteredSigner {
     /// Finish an operation and update the coordinator selector accordingly
     fn finish_operation(&mut self) {
         self.state = State::Idle;
@@ -315,13 +368,6 @@ impl Signer {
                     self.signer_id,
                 );
             }
-            State::TenureExceeded => {
-                // We have exceeded our tenure. Do nothing...
-                debug!(
-                    "Signer #{}: Waiting to clean up signer for reward cycle {}",
-                    self.signer_id, self.reward_cycle
-                );
-            }
         }
     }
 
@@ -331,6 +377,7 @@ impl Signer {
         stacks_client: &StacksClient,
         block_validate_response: &BlockValidateResponse,
         res: Sender<Vec<OperationResult>>,
+        current_reward_cycle: u64,
     ) {
         let block_info = match block_validate_response {
             BlockValidateResponse::Ok(block_validate_ok) => {
@@ -341,7 +388,11 @@ impl Signer {
                     debug!("Signer #{}: Received a block validate response for a block we have not seen before. Ignoring...", self.signer_id);
                     return;
                 };
-                let is_valid = self.verify_block_transactions(stacks_client, &block_info.block);
+                let is_valid = self.verify_block_transactions(
+                    stacks_client,
+                    &block_info.block,
+                    current_reward_cycle,
+                );
                 block_info.valid = Some(is_valid);
                 info!(
                     "Signer #{}: Treating block validation for block {} as valid: {:?}",
@@ -386,7 +437,7 @@ impl Signer {
                 msg: Message::NonceRequest(nonce_request),
                 sig: vec![],
             };
-            self.handle_packets(stacks_client, res, &[packet]);
+            self.handle_packets(stacks_client, res, &[packet], current_reward_cycle);
         } else {
             let coordinator_id = self.coordinator_selector.get_coordinator().0;
             if block_info.valid.unwrap_or(false)
@@ -422,6 +473,7 @@ impl Signer {
         stacks_client: &StacksClient,
         res: Sender<Vec<OperationResult>>,
         messages: &[SignerMessage],
+        current_reward_cycle: u64,
     ) {
         let coordinator_pubkey = self.coordinator_selector.get_coordinator().1;
         let packets: Vec<Packet> = messages
@@ -435,7 +487,7 @@ impl Signer {
                 }
             })
             .collect();
-        self.handle_packets(stacks_client, res, &packets);
+        self.handle_packets(stacks_client, res, &packets, current_reward_cycle);
     }
 
     /// Handle proposed blocks submitted by the miners to stackerdb
@@ -465,6 +517,7 @@ impl Signer {
         stacks_client: &StacksClient,
         res: Sender<Vec<OperationResult>>,
         packets: &[Packet],
+        current_reward_cycle: u64,
     ) {
         let signer_outbound_messages = self
             .signing_round
@@ -492,7 +545,7 @@ impl Signer {
         if !operation_results.is_empty() {
             // We have finished a signing or DKG round, either successfully or due to error.
             // Regardless of the why, update our state to Idle as we should not expect the operation to continue.
-            self.process_operation_results(stacks_client, &operation_results);
+            self.process_operation_results(stacks_client, &operation_results, current_reward_cycle);
             self.send_operation_results(res, operation_results);
             self.finish_operation();
         } else if !packets.is_empty() && self.coordinator.state != CoordinatorState::Idle {
@@ -609,6 +662,7 @@ impl Signer {
         &mut self,
         stacks_client: &StacksClient,
         block: &NakamotoBlock,
+        current_reward_cycle: u64,
     ) -> bool {
         let aggregate_key = retry_with_exponential_backoff(|| {
             stacks_client
@@ -629,7 +683,7 @@ impl Signer {
             .cloned()
             .collect::<Vec<_>>();
         if let Ok(expected_transactions) =
-            self.get_filtered_transactions(stacks_client, &signer_ids)
+            self.get_filtered_transactions(stacks_client, &signer_ids, current_reward_cycle)
         {
             //It might be worth building a hashset of the blocks' txids and checking that against the expected transaction's txid.
             let block_tx_hashset = block.txs.iter().map(|tx| tx.txid()).collect::<HashSet<_>>();
@@ -703,6 +757,7 @@ impl Signer {
         &self,
         stacks_client: &StacksClient,
         transaction: StacksTransaction,
+        current_reward_cycle: u64,
     ) -> Option<StacksTransaction> {
         // Filter out transactions that have already been confirmed (can happen if a signer did not update stacker db since the last block was processed)
         let origin_address = transaction.origin_address();
@@ -741,8 +796,13 @@ impl Signer {
             return None;
         }
         let Ok(valid) = retry_with_exponential_backoff(|| {
-            self.verify_payload(stacks_client, &transaction, *origin_signer_id)
-                .map_err(backoff::Error::transient)
+            self.verify_payload(
+                stacks_client,
+                &transaction,
+                *origin_signer_id,
+                current_reward_cycle,
+            )
+            .map_err(backoff::Error::transient)
         }) else {
             warn!(
                 "Signer #{}: Unable to validate transaction payload. Filtering ({}).",
@@ -773,6 +833,7 @@ impl Signer {
         stacks_client: &StacksClient,
         transaction: &StacksTransaction,
         origin_signer_id: u32,
+        current_reward_cycle: u64,
     ) -> Result<bool, ClientError> {
         let TransactionPayload::ContractCall(payload) = &transaction.payload else {
             // Not a contract call so not a special cased vote for aggregate public key transaction
@@ -795,7 +856,7 @@ impl Signer {
             // The signer is attempting to vote for another signer id than their own
             return Ok(false);
         }
-        let next_reward_cycle = stacks_client.get_current_reward_cycle()?.wrapping_add(1);
+        let next_reward_cycle = current_reward_cycle.wrapping_add(1);
         if reward_cycle != next_reward_cycle {
             // The signer is attempting to vote for a reward cycle that is not the next reward cycle
             return Ok(false);
@@ -832,12 +893,15 @@ impl Signer {
         &mut self,
         stacks_client: &StacksClient,
         signer_ids: &[u32],
+        current_reward_cycle: u64,
     ) -> Result<Vec<StacksTransaction>, ClientError> {
         let transactions = self
             .stackerdb
             .get_signer_transactions_with_retry(signer_ids)?
             .into_iter()
-            .filter_map(|transaction| self.verify_signer_transaction(stacks_client, transaction))
+            .filter_map(|transaction| {
+                self.verify_signer_transaction(stacks_client, transaction, current_reward_cycle)
+            })
             .collect();
         Ok(transactions)
     }
@@ -910,6 +974,7 @@ impl Signer {
         &mut self,
         stacks_client: &StacksClient,
         operation_results: &[OperationResult],
+        current_reward_cycle: u64,
     ) {
         for operation_result in operation_results {
             // Signers only every trigger non-taproot signing rounds over blocks. Ignore SignTaproot results
@@ -922,7 +987,7 @@ impl Signer {
                     debug!("Signer #{}: Received a signature result for a taproot signature. Nothing to broadcast as we currently sign blocks with a FROST signature.", self.signer_id);
                 }
                 OperationResult::Dkg(point) => {
-                    self.process_dkg(stacks_client, point);
+                    self.process_dkg(stacks_client, point, current_reward_cycle);
                 }
                 OperationResult::SignError(e) => {
                     self.process_sign_error(e);
@@ -935,7 +1000,12 @@ impl Signer {
     }
 
     /// Process a dkg result by broadcasting a vote to the stacks node
-    fn process_dkg(&mut self, stacks_client: &StacksClient, point: &Point) {
+    fn process_dkg(
+        &mut self,
+        stacks_client: &StacksClient,
+        point: &Point,
+        current_reward_cycle: u64,
+    ) {
         let epoch = stacks_client
             .get_node_epoch_with_retry()
             .unwrap_or(StacksEpochId::Epoch24);
@@ -949,7 +1019,7 @@ impl Signer {
             None
         };
         // Get our current nonce from the stacks node and compare it against what we have sitting in the stackerdb instance
-        let nonce = self.get_next_nonce(stacks_client);
+        let nonce = self.get_next_nonce(stacks_client, current_reward_cycle);
         match stacks_client.build_vote_for_aggregate_public_key(
             self.stackerdb.get_signer_slot_id(),
             self.coordinator.current_dkg_id,
@@ -959,7 +1029,9 @@ impl Signer {
             nonce,
         ) {
             Ok(transaction) => {
-                if let Err(e) = self.broadcast_dkg_vote(stacks_client, transaction, epoch) {
+                if let Err(e) =
+                    self.broadcast_dkg_vote(stacks_client, transaction, epoch, current_reward_cycle)
+                {
                     warn!(
                         "Signer #{}: Failed to broadcast DKG vote ({point:?}): {e:?}",
                         self.signer_id
@@ -976,7 +1048,7 @@ impl Signer {
     }
 
     /// Get the next available nonce, taking into consideration the nonce we have sitting in stackerdb as well as the account nonce
-    fn get_next_nonce(&mut self, stacks_client: &StacksClient) -> u64 {
+    fn get_next_nonce(&mut self, stacks_client: &StacksClient, current_reward_cycle: u64) -> u64 {
         let signer_address = stacks_client.get_signer_address();
         let mut next_nonce = stacks_client
             .get_account_nonce(signer_address)
@@ -988,7 +1060,7 @@ impl Signer {
             })
             .unwrap_or(0);
 
-        let current_transactions = self.get_filtered_transactions(stacks_client, &[self.signer_id]).map_err(|e| {
+        let current_transactions = self.get_filtered_transactions(stacks_client, &[self.signer_id], current_reward_cycle).map_err(|e| {
             warn!("Signer #{}: Failed to get old transactions: {e:?}. Defaulting to account nonce.", self.signer_id);
         }).unwrap_or_default();
 
@@ -1008,6 +1080,7 @@ impl Signer {
         stacks_client: &StacksClient,
         new_transaction: StacksTransaction,
         epoch: StacksEpochId,
+        current_reward_cycle: u64,
     ) -> Result<(), ClientError> {
         let txid = new_transaction.txid();
         let aggregate_key = retry_with_exponential_backoff(|| {
@@ -1048,7 +1121,7 @@ impl Signer {
             );
             vec![]
         } else {
-            let mut new_transactions = self.get_filtered_transactions(stacks_client, &[self.signer_id]).map_err(|e| {
+            let mut new_transactions = self.get_filtered_transactions(stacks_client, &[self.signer_id], current_reward_cycle).map_err(|e| {
             warn!("Signer #{}: Failed to get old transactions: {e:?}. Potentially overwriting our existing stackerDB transactions", self.signer_id);
         }).unwrap_or_default();
             new_transactions.push(new_transaction);
@@ -1232,7 +1305,11 @@ impl Signer {
     }
 
     /// Update the DKG for the provided signer info, triggering it if required
-    pub fn update_dkg(&mut self, stacks_client: &StacksClient) -> Result<(), ClientError> {
+    pub fn update_dkg(
+        &mut self,
+        stacks_client: &StacksClient,
+        current_reward_cycle: u64,
+    ) -> Result<(), ClientError> {
         let reward_cycle = self.reward_cycle;
         let new_aggregate_public_key = stacks_client.get_approved_aggregate_key(reward_cycle)?;
         let old_aggregate_public_key = self.coordinator.get_aggregate_public_key();
@@ -1260,7 +1337,7 @@ impl Signer {
             );
             // Have I already voted and have a pending transaction? Check stackerdb for the same round number and reward cycle vote transaction
             // TODO: might be better to store these transactions on the side to prevent having to query the stacker db for every signer (only do on initilaization of a new signer for example and then listen for stacker db updates after that)
-            let old_transactions = self.get_filtered_transactions(stacks_client, &[self.signer_id]).map_err(|e| {
+            let old_transactions = self.get_filtered_transactions(stacks_client, &[self.signer_id], current_reward_cycle).map_err(|e| {
                 warn!("Signer #{}: Failed to get old transactions: {e:?}. Potentially overwriting our existing transactions", self.signer_id);
             }).unwrap_or_default();
             // Check if we have an existing vote transaction for the same round and reward cycle
@@ -1318,21 +1395,8 @@ impl Signer {
         stacks_client: &StacksClient,
         event: Option<&SignerEvent>,
         res: Sender<Vec<OperationResult>>,
+        current_reward_cycle: u64,
     ) -> Result<(), ClientError> {
-        let current_reward_cycle = retry_with_exponential_backoff(|| {
-            stacks_client
-                .get_current_reward_cycle()
-                .map_err(backoff::Error::transient)
-        })?;
-        if current_reward_cycle > self.reward_cycle {
-            // We have advanced past our tenure as a signer. Nothing to do.
-            info!(
-                "Signer #{}: Signer has passed its tenure. Ignoring event...",
-                self.signer_id
-            );
-            self.state = State::TenureExceeded;
-            return Ok(());
-        }
         debug!("Signer #{}: Processing event: {event:?}", self.signer_id);
         match event {
             Some(SignerEvent::BlockValidationResponse(block_validate_response)) => {
@@ -1340,7 +1404,12 @@ impl Signer {
                     "Signer #{}: Received a block proposal result from the stacks node...",
                     self.signer_id
                 );
-                self.handle_block_validate_response(stacks_client, block_validate_response, res)
+                self.handle_block_validate_response(
+                    stacks_client,
+                    block_validate_response,
+                    res,
+                    current_reward_cycle,
+                )
             }
             Some(SignerEvent::SignerMessages(signer_set, messages)) => {
                 if *signer_set != self.stackerdb.get_signer_set() {
@@ -1352,7 +1421,7 @@ impl Signer {
                     self.signer_id,
                     messages.len()
                 );
-                self.handle_signer_messages(stacks_client, res, messages);
+                self.handle_signer_messages(stacks_client, res, messages, current_reward_cycle);
             }
             Some(SignerEvent::ProposedBlocks(blocks)) => {
                 if current_reward_cycle != self.reward_cycle {
@@ -1431,7 +1500,7 @@ mod tests {
     };
     use crate::client::{StacksClient, VOTE_FUNCTION_NAME};
     use crate::config::GlobalConfig;
-    use crate::signer::{BlockInfo, Signer};
+    use crate::signer::{BlockInfo, RegisteredSigner};
 
     #[test]
     #[serial]
@@ -1440,7 +1509,7 @@ mod tests {
         // Create a runloop of a valid signer
         let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
         let (signer_config, _ordered_addresses) = generate_signer_config(&config, 5, 20);
-        let mut signer = Signer::from(signer_config);
+        let mut signer = RegisteredSigner::from(signer_config);
 
         let signer_private_key = config.stacks_private_key;
         let non_signer_private_key = StacksPrivateKey::new();
@@ -1560,7 +1629,7 @@ mod tests {
         let stacks_client = StacksClient::from(&config);
         let h = spawn(move || {
             signer
-                .get_filtered_transactions(&stacks_client, &[0])
+                .get_filtered_transactions(&stacks_client, &[0], 0)
                 .unwrap()
         });
 
@@ -1589,7 +1658,7 @@ mod tests {
         let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
         let (signer_config, _ordered_addresses) = generate_signer_config(&config, 5, 20);
         let stacks_client = StacksClient::from(&config);
-        let mut signer = Signer::from(signer_config);
+        let mut signer = RegisteredSigner::from(signer_config);
 
         let signer_private_key = config.stacks_private_key;
         let vote_contract_id = boot_code_id(SIGNERS_VOTING_NAME, signer.mainnet);
@@ -1651,7 +1720,7 @@ mod tests {
             BlockInfo::new(block.clone()),
         );
 
-        let h = spawn(move || signer.verify_block_transactions(&stacks_client, &block));
+        let h = spawn(move || signer.verify_block_transactions(&stacks_client, &block, 0));
 
         // Simulate the response to the request for transactions with the expected transaction
         let signer_message = SignerMessage::Transactions(vec![valid_tx]);
@@ -1706,7 +1775,7 @@ mod tests {
         signer_config.reward_cycle = 1;
 
         // valid transaction
-        let signer = Signer::from(signer_config.clone());
+        let signer = RegisteredSigner::from(signer_config.clone());
         let stacks_client = StacksClient::from(&config);
 
         let signer_private_key = config.stacks_private_key;
@@ -1734,13 +1803,6 @@ mod tests {
         )
         .unwrap();
 
-        let reward_cycle_response = build_get_pox_data_response(
-            Some(signer.reward_cycle.saturating_sub(1)),
-            None,
-            None,
-            None,
-        )
-        .0;
         let pox_info_response = build_get_pox_data_response(
             Some(signer.reward_cycle.saturating_sub(1)),
             Some(0),
@@ -1754,12 +1816,15 @@ mod tests {
 
         let h = spawn(move || {
             assert!(signer
-                .verify_payload(&stacks_client, &valid_transaction, signer.signer_id)
+                .verify_payload(
+                    &stacks_client,
+                    &valid_transaction,
+                    signer.signer_id,
+                    signer.reward_cycle.saturating_sub(1)
+                )
                 .unwrap())
         });
         let mock_server = mock_server_from_config(&config);
-        write_response(mock_server, reward_cycle_response.as_bytes());
-        let mock_server = mock_server_from_config(&config);
         write_response(mock_server, pox_info_response.as_bytes());
         let mock_server = mock_server_from_config(&config);
         write_response(mock_server, peer_info.as_bytes());
@@ -1769,7 +1834,7 @@ mod tests {
         write_response(mock_server, last_round_response.as_bytes());
         h.join().unwrap();
 
-        let signer = Signer::from(signer_config.clone());
+        let signer = RegisteredSigner::from(signer_config.clone());
         // Create a invalid transaction that is not a contract call
         let invalid_not_contract_call = StacksTransaction {
             version: TransactionVersion::Testnet,
@@ -1926,13 +1991,18 @@ mod tests {
             invalid_function_arg_4,
         ] {
             let result = signer
-                .verify_payload(&stacks_client, &tx, signer.signer_id)
+                .verify_payload(
+                    &stacks_client,
+                    &tx,
+                    signer.signer_id,
+                    signer.reward_cycle.saturating_sub(1),
+                )
                 .unwrap();
             assert!(!result);
         }
 
         // Invalid reward cycle (voting for the current is not allowed. only the next)
-        let signer = Signer::from(signer_config.clone());
+        let signer = RegisteredSigner::from(signer_config.clone());
         let invalid_reward_cycle = StacksClient::build_signed_contract_call_transaction(
             &contract_addr,
             contract_name.clone(),
@@ -1945,19 +2015,20 @@ mod tests {
             10,
         )
         .unwrap();
-        let (reward_cycle_response, _) =
-            build_get_pox_data_response(Some(signer.reward_cycle), None, None, None);
         let h = spawn(move || {
             assert!(!signer
-                .verify_payload(&stacks_client, &invalid_reward_cycle, signer.signer_id)
+                .verify_payload(
+                    &stacks_client,
+                    &invalid_reward_cycle,
+                    signer.signer_id,
+                    signer.reward_cycle
+                )
                 .unwrap())
         });
-        let mock_server = mock_server_from_config(&config);
-        write_response(mock_server, reward_cycle_response.as_bytes());
         h.join().unwrap();
 
         // Invalid block height to vote
-        let signer = Signer::from(signer_config.clone());
+        let signer = RegisteredSigner::from(signer_config.clone());
         let stacks_client = StacksClient::from(&config);
         let invalid_reward_set = StacksClient::build_signed_contract_call_transaction(
             &contract_addr,
@@ -1972,14 +2043,6 @@ mod tests {
         )
         .unwrap();
 
-        // Valid reward cycle vote
-        let reward_cycle_response = build_get_pox_data_response(
-            Some(signer.reward_cycle.saturating_sub(1)),
-            None,
-            None,
-            None,
-        )
-        .0;
         // Invalid reward set not calculated (not in the second block onwards of the prepare phase)
         let pox_info_response = build_get_pox_data_response(
             Some(signer.reward_cycle.saturating_sub(1)),
@@ -1992,19 +2055,22 @@ mod tests {
 
         let h = spawn(move || {
             assert!(!signer
-                .verify_payload(&stacks_client, &invalid_reward_set, signer.signer_id)
+                .verify_payload(
+                    &stacks_client,
+                    &invalid_reward_set,
+                    signer.signer_id,
+                    signer.reward_cycle.saturating_sub(1)
+                )
                 .unwrap())
         });
         let mock_server = mock_server_from_config(&config);
-        write_response(mock_server, reward_cycle_response.as_bytes());
-        let mock_server = mock_server_from_config(&config);
         write_response(mock_server, pox_info_response.as_bytes());
         let mock_server = mock_server_from_config(&config);
         write_response(mock_server, peer_info.as_bytes());
         h.join().unwrap();
 
         // Already voted
-        let signer = Signer::from(signer_config.clone());
+        let signer = RegisteredSigner::from(signer_config.clone());
         let stacks_client = StacksClient::from(&config);
         let invalid_already_voted = StacksClient::build_signed_contract_call_transaction(
             &contract_addr,
@@ -2019,14 +2085,6 @@ mod tests {
         )
         .unwrap();
 
-        // Valid reward cycle vote
-        let reward_cycle_response = build_get_pox_data_response(
-            Some(signer.reward_cycle.saturating_sub(1)),
-            None,
-            None,
-            None,
-        )
-        .0;
         let pox_info_response = build_get_pox_data_response(
             Some(signer.reward_cycle.saturating_sub(1)),
             Some(0),
@@ -2039,12 +2097,15 @@ mod tests {
 
         let h = spawn(move || {
             assert!(!signer
-                .verify_payload(&stacks_client, &invalid_already_voted, signer.signer_id)
+                .verify_payload(
+                    &stacks_client,
+                    &invalid_already_voted,
+                    signer.signer_id,
+                    signer.reward_cycle.saturating_sub(1)
+                )
                 .unwrap())
         });
         let mock_server = mock_server_from_config(&config);
-        write_response(mock_server, reward_cycle_response.as_bytes());
-        let mock_server = mock_server_from_config(&config);
         write_response(mock_server, pox_info_response.as_bytes());
         let mock_server = mock_server_from_config(&config);
         write_response(mock_server, peer_info.as_bytes());
@@ -2053,7 +2114,7 @@ mod tests {
         h.join().unwrap();
 
         // Already voted
-        let signer = Signer::from(signer_config.clone());
+        let signer = RegisteredSigner::from(signer_config.clone());
         let stacks_client = StacksClient::from(&config);
         let round: u128 = 0;
         let invalid_already_voted = StacksClient::build_signed_contract_call_transaction(
@@ -2075,13 +2136,6 @@ mod tests {
         .unwrap();
 
         // invalid round number
-        let reward_cycle_response = build_get_pox_data_response(
-            Some(signer.reward_cycle.saturating_sub(1)),
-            None,
-            None,
-            None,
-        )
-        .0;
         let pox_info_response = build_get_pox_data_response(
             Some(signer.reward_cycle.saturating_sub(1)),
             Some(0),
@@ -2095,12 +2149,15 @@ mod tests {
 
         let h = spawn(move || {
             assert!(!signer
-                .verify_payload(&stacks_client, &invalid_already_voted, signer.signer_id)
+                .verify_payload(
+                    &stacks_client,
+                    &invalid_already_voted,
+                    signer.signer_id,
+                    signer.reward_cycle.saturating_sub(1)
+                )
                 .unwrap())
         });
         let mock_server = mock_server_from_config(&config);
-        write_response(mock_server, reward_cycle_response.as_bytes());
-        let mock_server = mock_server_from_config(&config);
         write_response(mock_server, pox_info_response.as_bytes());
         let mock_server = mock_server_from_config(&config);
         write_response(mock_server, peer_info.as_bytes());

From 0b08bf7d98837849027cae3bebd1bd23bcc1bbc0 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 16 Feb 2024 19:10:37 -0500
Subject: [PATCH 0901/1166] Fix signer slot id for index calculation in
 verify_payload

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/mod.rs           |  6 ++---
 stacks-signer/src/client/stacks_client.rs | 28 ++++-------------------
 stacks-signer/src/config.rs               |  6 ++---
 stacks-signer/src/runloop.rs              |  4 ++--
 stacks-signer/src/signer.rs               |  9 +++++---
 5 files changed, 19 insertions(+), 34 deletions(-)

diff --git a/stacks-signer/src/client/mod.rs b/stacks-signer/src/client/mod.rs
index fb0c3c9bea..3a7a9e2915 100644
--- a/stacks-signer/src/client/mod.rs
+++ b/stacks-signer/src/client/mod.rs
@@ -422,7 +422,7 @@ pub(crate) mod tests {
         let mut coordinator_key_ids = HashMap::new();
         let mut signer_key_ids = HashMap::new();
         let mut addresses = vec![];
-        let mut signer_address_ids = HashMap::new();
+        let mut signer_ids = HashMap::new();
         let mut start_key_id = 1u32;
         let mut end_key_id = start_key_id;
         let mut signer_public_keys = HashMap::new();
@@ -483,7 +483,7 @@ pub(crate) mod tests {
                     .expect("Failed to create stacks public key"),
             );
             signer_slot_ids.insert(address, signer_id); // Note in a real world situation, these would not always match
-            signer_address_ids.insert(address, signer_id);
+            signer_ids.insert(address, signer_id);
             addresses.push(address);
             start_key_id = end_key_id;
             coordinator_ids.push(signer_id);
@@ -499,7 +499,7 @@ pub(crate) mod tests {
                     public_keys,
                     coordinator_key_ids,
                     signer_key_ids,
-                    signer_address_ids,
+                    signer_ids,
                     signer_public_keys,
                 },
                 coordinator_ids,
diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index 82eb50c41a..29e9ceccc9 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -356,24 +356,6 @@ impl StacksClient {
         Ok(round)
     }
 
-    /// Retrieve the vote of the signer for the given round
-    pub fn get_signer_vote(
-        &self,
-        reward_cycle: u64,
-        round: u128,
-    ) -> Result<Option<Point>, ClientError> {
-        let reward_cycle = ClarityValue::UInt(reward_cycle as u128);
-        let round = ClarityValue::UInt(round);
-        let signer = ClarityValue::Principal(self.stacks_address.into());
-        let contract_addr = boot_code_addr(self.mainnet);
-        let contract_name = ContractName::from(SIGNERS_VOTING_NAME);
-        let function = ClarityName::from("get-vote");
-        let function_args = &[reward_cycle, round, signer];
-        let value =
-            self.read_only_contract_call(&contract_addr, &contract_name, &function, function_args)?;
-        self.parse_aggregate_public_key(value)
-    }
-
     /// Get whether the reward set has been determined for the provided reward cycle.
     /// i.e the node has passed the first block of the new reward cycle's prepare phase
     pub fn reward_set_calculated(&self, reward_cycle: u64) -> Result<bool, ClientError> {
@@ -435,7 +417,7 @@ impl StacksClient {
         let mut weight_end = 1;
         let mut coordinator_key_ids = HashMap::with_capacity(4000);
         let mut signer_key_ids = HashMap::with_capacity(reward_set_signers.len());
-        let mut signer_address_ids = HashMap::with_capacity(reward_set_signers.len());
+        let mut signer_ids = HashMap::with_capacity(reward_set_signers.len());
         let mut public_keys = PublicKeys {
             signers: HashMap::with_capacity(reward_set_signers.len()),
             key_ids: HashMap::with_capacity(4000),
@@ -462,7 +444,7 @@ impl StacksClient {
 
             let stacks_address = StacksAddress::p2pkh(self.mainnet, &stacks_public_key);
 
-            signer_address_ids.insert(stacks_address, signer_id);
+            signer_ids.insert(stacks_address, signer_id);
             signer_public_keys.insert(signer_id, signer_public_key);
             let weight_start = weight_end;
             weight_end = weight_start + entry.slots;
@@ -495,7 +477,7 @@ impl StacksClient {
             );
         }
 
-        for address in signer_address_ids.keys().into_iter() {
+        for address in signer_ids.keys().into_iter() {
             if !signer_slot_ids.contains_key(address) {
                 debug!("Signer {address} does not have a slot id in the stackerdb");
                 return Ok(None);
@@ -505,10 +487,10 @@ impl StacksClient {
         Ok(Some(RegisteredSignersInfo {
             public_keys,
             signer_key_ids,
-            signer_address_ids,
+            signer_ids,
+            signer_slot_ids,
             signer_public_keys,
             coordinator_key_ids,
-            signer_slot_ids,
         }))
     }
 
diff --git a/stacks-signer/src/config.rs b/stacks-signer/src/config.rs
index d06f3a5f8a..84a96b0800 100644
--- a/stacks-signer/src/config.rs
+++ b/stacks-signer/src/config.rs
@@ -121,12 +121,12 @@ pub struct RegisteredSignersInfo {
     /// The signer ids to wsts pubilc keys mapping
     pub signer_public_keys: HashMap<u32, Point>,
     /// The signer addresses mapped to their signer ids
-    pub signer_address_ids: HashMap<StacksAddress, u32>,
-    /// The public keys for the reward cycle
-    pub public_keys: PublicKeys,
+    pub signer_ids: HashMap<StacksAddress, u32>,
     /// The signer slot id for a signer address registered in stackerdb
     /// This corresponds to their unique index when voting in a reward cycle
     pub signer_slot_ids: HashMap<StacksAddress, u32>,
+    /// The public keys for the reward cycle
+    pub public_keys: PublicKeys,
 }
 
 /// The Configuration info needed for an individual signer per reward cycle
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 1aa3bf28f4..5d69da88ec 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -72,7 +72,7 @@ impl From<GlobalConfig> for RunLoop {
 }
 
 impl RunLoop {
-    /// Get a signer configruation for a specific reward cycle from the stacks node
+    /// Get a signer configuration for a specific reward cycle from the stacks node
     fn get_signer_config(
         &mut self,
         reward_cycle: u64,
@@ -102,7 +102,7 @@ impl RunLoop {
                 );
             return Ok(None);
         };
-        let Some(signer_id) = registered_signers.signer_address_ids.get(current_addr) else {
+        let Some(signer_id) = registered_signers.signer_ids.get(current_addr) else {
             warn!(
                 "Signer {current_addr} was found in stacker db but not the reward set for reward cycle {reward_cycle}."
             );
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index 9ae809c0e7..e15ac722aa 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -187,7 +187,9 @@ pub struct RegisteredSigner {
     /// The signer id
     pub signer_id: u32,
     /// The addresses of other signers mapped to their signer ID
-    pub signer_address_ids: HashMap<StacksAddress, u32>,
+    pub signer_ids: HashMap<StacksAddress, u32>,
+    /// The addresses of other signers mapped to their signer slot ID
+    pub signer_slot_ids: HashMap<StacksAddress, u32>,
     /// The reward cycle this signer belongs to
     pub reward_cycle: u64,
     /// The tx fee in uSTX to use if the epoch is pre Nakamoto (Epoch 3.0)
@@ -245,7 +247,8 @@ impl From<SignerConfig> for RegisteredSigner {
             stackerdb,
             mainnet: signer_config.mainnet,
             signer_id: signer_config.signer_id,
-            signer_address_ids: signer_config.registered_signers.signer_address_ids,
+            signer_ids: signer_config.registered_signers.signer_ids,
+            signer_slot_ids: signer_config.registered_signers.signer_slot_ids,
             reward_cycle: signer_config.reward_cycle,
             tx_fee_ms: signer_config.tx_fee_ms,
             coordinator_selector,
@@ -762,7 +765,7 @@ impl RegisteredSigner {
         // Filter out transactions that have already been confirmed (can happen if a signer did not update stacker db since the last block was processed)
         let origin_address = transaction.origin_address();
         let origin_nonce = transaction.get_origin_nonce();
-        let Some(origin_signer_id) = self.signer_address_ids.get(&origin_address) else {
+        let Some(origin_signer_id) = self.signer_slot_ids.get(&origin_address) else {
             debug!(
                 "Signer #{}: Unrecognized origin address ({origin_address}). Filtering ({}).",
                 self.signer_id,

From 14a15a682d0433d279490492a24e2a110dc7f277 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Mon, 19 Feb 2024 09:36:07 -0500
Subject: [PATCH 0902/1166] CRC: cleanup comments

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/mod.rs           |   9 +
 stacks-signer/src/client/stacks_client.rs |   2 +-
 stacks-signer/src/coordinator.rs          |  11 +-
 stacks-signer/src/runloop.rs              |   7 +-
 stacks-signer/src/signer.rs               | 197 ++++++++++------------
 testnet/stacks-node/src/tests/signer.rs   |   2 +-
 6 files changed, 111 insertions(+), 117 deletions(-)

diff --git a/stacks-signer/src/client/mod.rs b/stacks-signer/src/client/mod.rs
index 3a7a9e2915..42374168f3 100644
--- a/stacks-signer/src/client/mod.rs
+++ b/stacks-signer/src/client/mod.rs
@@ -207,6 +207,15 @@ pub(crate) mod tests {
         TcpListener::bind(config.node_host).unwrap()
     }
 
+    /// Create a mock server on the same port as the config and write a response to it
+    pub fn mock_server_from_config_and_write_response(
+        config: &GlobalConfig,
+        bytes: &[u8],
+    ) -> [u8; 1024] {
+        let mock_server = mock_server_from_config(config);
+        write_response(mock_server, bytes)
+    }
+
     /// Write a response to the mock server and return the request bytes
     pub fn write_response(mock_server: TcpListener, bytes: &[u8]) -> [u8; 1024] {
         debug!("Writing a response...");
diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index 29e9ceccc9..47bb735700 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -477,7 +477,7 @@ impl StacksClient {
             );
         }
 
-        for address in signer_ids.keys().into_iter() {
+        for address in signer_ids.keys() {
             if !signer_slot_ids.contains_key(address) {
                 debug!("Signer {address} does not have a slot id in the stackerdb");
                 return Ok(None);
diff --git a/stacks-signer/src/coordinator.rs b/stacks-signer/src/coordinator.rs
index 196ef4e64a..7e5f4877e3 100644
--- a/stacks-signer/src/coordinator.rs
+++ b/stacks-signer/src/coordinator.rs
@@ -29,7 +29,7 @@ pub const COORDINATOR_TENURE_TIMEOUT_SECS: u64 = 600;
 
 /// The coordinator selector
 #[derive(Clone, Debug)]
-pub struct Selector {
+pub struct CoordinatorSelector {
     /// The ordered list of potential coordinators for a specific consensus hash
     coordinator_ids: Vec<u32>,
     /// The current coordinator id
@@ -44,7 +44,7 @@ pub struct Selector {
     public_keys: PublicKeys,
 }
 
-impl Selector {
+impl CoordinatorSelector {
     /// Create a new Coordinator selector from the given list of public keys and initial coordinator ids
     pub fn new(coordinator_ids: Vec<u32>, public_keys: PublicKeys) -> Self {
         let coordinator_id = *coordinator_ids
@@ -98,9 +98,8 @@ impl Selector {
     }
 
     /// Check the coordinator timeouts and update the selected coordinator accordingly
-    /// Returns true if the coordinator was updated, else false
-    pub fn refresh_coordinator(&mut self, stacks_client: &StacksClient) -> bool {
-        let old_coordinator_id = self.coordinator_id;
+    /// Returns the resulting coordinator ID. (Note: it may be unchanged)
+    pub fn refresh_coordinator(&mut self, stacks_client: &StacksClient) -> u32 {
         let new_coordinator_ids = stacks_client.calculate_coordinator_ids(&self.public_keys);
         if let Some(time) = self.last_message_time {
             if time.elapsed().as_secs() > COORDINATOR_OPERATION_TIMEOUT_SECS {
@@ -114,7 +113,7 @@ impl Selector {
             // Our tenure has been exceeded or we have advanced our block height and should select from the new list
             self.update_coordinator(new_coordinator_ids);
         }
-        old_coordinator_id != self.coordinator_id
+        self.coordinator_id
     }
 
     /// Get the current coordinator id and public key
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 5d69da88ec..e0be3aef04 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -202,12 +202,13 @@ impl RunLoop {
             }
             for stacks_signer in self.stacks_signers.values_mut() {
                 if let Signer::Registered(signer) = stacks_signer {
-                    let updated_coordinator = signer
+                    let old_coordinator_id = signer.coordinator_selector.get_coordinator().0;
+                    let updated_coordinator_id = signer
                         .coordinator_selector
                         .refresh_coordinator(&self.stacks_client);
-                    if updated_coordinator {
+                    if old_coordinator_id != updated_coordinator_id {
                         debug!(
-                            "Signer #{}: Coordinator has been updated. Resetting state to Idle.",
+                            "Signer #{}: Coordinator has switched from {old_coordinator_id} to {updated_coordinator_id}. Resetting state to Idle.",
                             signer.signer_id
                         );
                         signer.coordinator.state = CoordinatorState::Idle;
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index e15ac722aa..81b1fb9aae 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -47,7 +47,7 @@ use crate::client::{
     retry_with_exponential_backoff, ClientError, StackerDB, StacksClient, VOTE_FUNCTION_NAME,
 };
 use crate::config::SignerConfig;
-use crate::coordinator::Selector;
+use crate::coordinator::CoordinatorSelector;
 
 /// Additional Info about a proposed block
 pub struct BlockInfo {
@@ -195,7 +195,7 @@ pub struct RegisteredSigner {
     /// The tx fee in uSTX to use if the epoch is pre Nakamoto (Epoch 3.0)
     pub tx_fee_ms: u64,
     /// The coordinator info for the signer
-    pub coordinator_selector: Selector,
+    pub coordinator_selector: CoordinatorSelector,
 }
 
 impl From<SignerConfig> for RegisteredSigner {
@@ -234,7 +234,7 @@ impl From<SignerConfig> for RegisteredSigner {
             signer_config.ecdsa_private_key,
             signer_config.registered_signers.public_keys.clone(),
         );
-        let coordinator_selector = Selector::new(
+        let coordinator_selector = CoordinatorSelector::new(
             signer_config.coordinator_ids,
             signer_config.registered_signers.public_keys,
         );
@@ -1497,9 +1497,9 @@ mod tests {
     use wsts::curve::scalar::Scalar;
 
     use crate::client::tests::{
-        build_get_approved_aggregate_key_response, build_get_last_round_response,
-        build_get_peer_info_response, build_get_pox_data_response, generate_signer_config,
-        mock_server_from_config, write_response,
+        build_account_nonce_response, build_get_approved_aggregate_key_response,
+        build_get_last_round_response, build_get_peer_info_response, build_get_pox_data_response,
+        generate_signer_config, mock_server_from_config_and_write_response,
     };
     use crate::client::{StacksClient, VOTE_FUNCTION_NAME};
     use crate::config::GlobalConfig;
@@ -1641,13 +1641,11 @@ mod tests {
         let message = signer_message.serialize_to_vec();
         let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
         response_bytes.extend(message);
-        let mock_server = mock_server_from_config(&config);
-        write_response(mock_server, response_bytes.as_slice());
+        mock_server_from_config_and_write_response(&config, response_bytes.as_slice());
 
         for _ in 0..num_transactions {
-            let nonce_response = b"HTTP/1.1 200 OK\n\n{\"nonce\":1,\"balance\":\"0x00000000000000000000000000000000\",\"locked\":\"0x00000000000000000000000000000000\",\"unlock_height\":0}";
-            let mock_server = mock_server_from_config(&config);
-            write_response(mock_server, nonce_response);
+            let response_bytes = build_account_nonce_response(1);
+            mock_server_from_config_and_write_response(&config, response_bytes.as_bytes());
         }
 
         let filtered_txs = h.join().unwrap();
@@ -1730,41 +1728,34 @@ mod tests {
         let message = signer_message.serialize_to_vec();
         let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
         response_bytes.extend(message);
-        let mock_server = mock_server_from_config(&config);
-        write_response(mock_server, response_bytes.as_slice());
+        mock_server_from_config_and_write_response(&config, response_bytes.as_slice());
 
         let signer_message = SignerMessage::Transactions(vec![]);
         let message = signer_message.serialize_to_vec();
         let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
         response_bytes.extend(message);
-        let mock_server = mock_server_from_config(&config);
-        write_response(mock_server, response_bytes.as_slice());
+        mock_server_from_config_and_write_response(&config, response_bytes.as_slice());
 
         let signer_message = SignerMessage::Transactions(vec![]);
         let message = signer_message.serialize_to_vec();
         let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
         response_bytes.extend(message);
-        let mock_server = mock_server_from_config(&config);
-        write_response(mock_server, response_bytes.as_slice());
+        mock_server_from_config_and_write_response(&config, response_bytes.as_slice());
 
         let signer_message = SignerMessage::Transactions(vec![]);
         let message = signer_message.serialize_to_vec();
         let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
         response_bytes.extend(message);
-        let mock_server = mock_server_from_config(&config);
-        write_response(mock_server, response_bytes.as_slice());
+        mock_server_from_config_and_write_response(&config, response_bytes.as_slice());
 
         let signer_message = SignerMessage::Transactions(vec![]);
         let message = signer_message.serialize_to_vec();
         let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
         response_bytes.extend(message);
-        let mock_server = mock_server_from_config(&config);
-        write_response(mock_server, response_bytes.as_slice());
-
-        let nonce_response = b"HTTP/1.1 200 OK\n\n{\"nonce\":1,\"balance\":\"0x00000000000000000000000000000000\",\"locked\":\"0x00000000000000000000000000000000\",\"unlock_height\":0}";
-        let mock_server = mock_server_from_config(&config);
-        write_response(mock_server, nonce_response);
+        mock_server_from_config_and_write_response(&config, response_bytes.as_slice());
 
+        let response_bytes = build_account_nonce_response(1);
+        mock_server_from_config_and_write_response(&config, response_bytes.as_bytes());
         let valid = h.join().unwrap();
         assert!(valid);
     }
@@ -1785,13 +1776,18 @@ mod tests {
         let vote_contract_id = boot_code_id(SIGNERS_VOTING_NAME, signer.mainnet);
         let contract_addr = vote_contract_id.issuer.into();
         let contract_name = vote_contract_id.name.clone();
+        let signer_index = Value::UInt(signer.signer_id as u128);
         let point = Point::from(Scalar::random(&mut thread_rng()));
+        let point_arg =
+            Value::buff_from(point.compress().data.to_vec()).expect("Failed to create buff");
         let round = thread_rng().next_u64();
+        let round_arg = Value::UInt(round as u128);
+        let reward_cycle_arg = Value::UInt(signer.reward_cycle as u128);
         let valid_function_args = vec![
-            Value::UInt(signer.signer_id as u128),
-            Value::buff_from(point.compress().data.to_vec()).expect("Failed to create buff"),
-            Value::UInt(round as u128),
-            Value::UInt(signer.reward_cycle as u128),
+            signer_index.clone(),
+            point_arg.clone(),
+            round_arg.clone(),
+            reward_cycle_arg.clone(),
         ];
         let valid_transaction = StacksClient::build_signed_contract_call_transaction(
             &contract_addr,
@@ -1827,14 +1823,10 @@ mod tests {
                 )
                 .unwrap())
         });
-        let mock_server = mock_server_from_config(&config);
-        write_response(mock_server, pox_info_response.as_bytes());
-        let mock_server = mock_server_from_config(&config);
-        write_response(mock_server, peer_info.as_bytes());
-        let mock_server = mock_server_from_config(&config);
-        write_response(mock_server, vote_response.as_bytes());
-        let mock_server = mock_server_from_config(&config);
-        write_response(mock_server, last_round_response.as_bytes());
+        mock_server_from_config_and_write_response(&config, pox_info_response.as_bytes());
+        mock_server_from_config_and_write_response(&config, peer_info.as_bytes());
+        mock_server_from_config_and_write_response(&config, vote_response.as_bytes());
+        mock_server_from_config_and_write_response(&config, last_round_response.as_bytes());
         h.join().unwrap();
 
         let signer = RegisteredSigner::from(signer_config.clone());
@@ -1897,9 +1889,9 @@ mod tests {
             VOTE_FUNCTION_NAME.into(),
             &[
                 Value::UInt(signer.signer_id.wrapping_add(1) as u128), // Not the signers id
-                Value::buff_from(point.compress().data.to_vec()).expect("Failed to create buff"),
-                Value::UInt(round as u128),
-                Value::UInt(signer.reward_cycle as u128),
+                point_arg.clone(),
+                round_arg.clone(),
+                reward_cycle_arg.clone(),
             ],
             &signer_private_key,
             TransactionVersion::Testnet,
@@ -1909,33 +1901,34 @@ mod tests {
         )
         .unwrap();
 
-        let invalid_function_arg_1 = StacksClient::build_signed_contract_call_transaction(
-            &contract_addr,
-            contract_name.clone(),
-            VOTE_FUNCTION_NAME.into(),
-            &[
-                Value::buff_from(point.compress().data.to_vec()).expect("Failed to create buff"),
-                Value::buff_from(point.compress().data.to_vec()).expect("Failed to create buff"),
-                Value::UInt(round as u128),
-                Value::UInt(signer.reward_cycle as u128),
-            ],
-            &signer_private_key,
-            TransactionVersion::Testnet,
-            config.network.to_chain_id(),
-            1,
-            10,
-        )
-        .unwrap();
+        let invalid_function_arg_signer_index =
+            StacksClient::build_signed_contract_call_transaction(
+                &contract_addr,
+                contract_name.clone(),
+                VOTE_FUNCTION_NAME.into(),
+                &[
+                    point_arg.clone(),
+                    point_arg.clone(),
+                    round_arg.clone(),
+                    reward_cycle_arg.clone(),
+                ],
+                &signer_private_key,
+                TransactionVersion::Testnet,
+                config.network.to_chain_id(),
+                1,
+                10,
+            )
+            .unwrap();
 
-        let invalid_function_arg_2 = StacksClient::build_signed_contract_call_transaction(
+        let invalid_function_arg_key = StacksClient::build_signed_contract_call_transaction(
             &contract_addr,
             contract_name.clone(),
             VOTE_FUNCTION_NAME.into(),
             &[
-                Value::UInt(signer.signer_id as u128),
-                Value::UInt(signer.signer_id as u128),
-                Value::UInt(round as u128),
-                Value::UInt(signer.reward_cycle as u128),
+                signer_index.clone(),
+                signer_index.clone(),
+                round_arg.clone(),
+                reward_cycle_arg.clone(),
             ],
             &signer_private_key,
             TransactionVersion::Testnet,
@@ -1945,15 +1938,15 @@ mod tests {
         )
         .unwrap();
 
-        let invalid_function_arg_3 = StacksClient::build_signed_contract_call_transaction(
+        let invalid_function_arg_round = StacksClient::build_signed_contract_call_transaction(
             &contract_addr,
             contract_name.clone(),
             VOTE_FUNCTION_NAME.into(),
             &[
-                Value::UInt(signer.signer_id as u128),
-                Value::buff_from(point.compress().data.to_vec()).expect("Failed to create buff"),
-                Value::buff_from(point.compress().data.to_vec()).expect("Failed to create buff"),
-                Value::UInt(signer.reward_cycle as u128),
+                signer_index.clone(),
+                point_arg.clone(),
+                point_arg.clone(),
+                reward_cycle_arg.clone(),
             ],
             &signer_private_key,
             TransactionVersion::Testnet,
@@ -1963,23 +1956,24 @@ mod tests {
         )
         .unwrap();
 
-        let invalid_function_arg_4 = StacksClient::build_signed_contract_call_transaction(
-            &contract_addr,
-            contract_name.clone(),
-            VOTE_FUNCTION_NAME.into(),
-            &[
-                Value::UInt(signer.signer_id as u128),
-                Value::buff_from(point.compress().data.to_vec()).expect("Failed to create buff"),
-                Value::UInt(round as u128),
-                Value::buff_from(point.compress().data.to_vec()).expect("Failed to create buff"),
-            ],
-            &signer_private_key,
-            TransactionVersion::Testnet,
-            config.network.to_chain_id(),
-            1,
-            10,
-        )
-        .unwrap();
+        let invalid_function_arg_reward_cycle =
+            StacksClient::build_signed_contract_call_transaction(
+                &contract_addr,
+                contract_name.clone(),
+                VOTE_FUNCTION_NAME.into(),
+                &[
+                    signer_index.clone(),
+                    point_arg.clone(),
+                    round_arg.clone(),
+                    point_arg.clone(),
+                ],
+                &signer_private_key,
+                TransactionVersion::Testnet,
+                config.network.to_chain_id(),
+                1,
+                10,
+            )
+            .unwrap();
 
         let stacks_client = StacksClient::from(&config);
         for tx in vec![
@@ -1988,10 +1982,10 @@ mod tests {
             invalid_signers_contract_name,
             invalid_signers_vote_function,
             invalid_signer_id_argument,
-            invalid_function_arg_1,
-            invalid_function_arg_2,
-            invalid_function_arg_3,
-            invalid_function_arg_4,
+            invalid_function_arg_signer_index,
+            invalid_function_arg_key,
+            invalid_function_arg_round,
+            invalid_function_arg_reward_cycle,
         ] {
             let result = signer
                 .verify_payload(
@@ -2066,10 +2060,8 @@ mod tests {
                 )
                 .unwrap())
         });
-        let mock_server = mock_server_from_config(&config);
-        write_response(mock_server, pox_info_response.as_bytes());
-        let mock_server = mock_server_from_config(&config);
-        write_response(mock_server, peer_info.as_bytes());
+        mock_server_from_config_and_write_response(&config, pox_info_response.as_bytes());
+        mock_server_from_config_and_write_response(&config, peer_info.as_bytes());
         h.join().unwrap();
 
         // Already voted
@@ -2108,12 +2100,9 @@ mod tests {
                 )
                 .unwrap())
         });
-        let mock_server = mock_server_from_config(&config);
-        write_response(mock_server, pox_info_response.as_bytes());
-        let mock_server = mock_server_from_config(&config);
-        write_response(mock_server, peer_info.as_bytes());
-        let mock_server = mock_server_from_config(&config);
-        write_response(mock_server, vote_response.as_bytes());
+        mock_server_from_config_and_write_response(&config, pox_info_response.as_bytes());
+        mock_server_from_config_and_write_response(&config, peer_info.as_bytes());
+        mock_server_from_config_and_write_response(&config, vote_response.as_bytes());
         h.join().unwrap();
 
         // Already voted
@@ -2160,14 +2149,10 @@ mod tests {
                 )
                 .unwrap())
         });
-        let mock_server = mock_server_from_config(&config);
-        write_response(mock_server, pox_info_response.as_bytes());
-        let mock_server = mock_server_from_config(&config);
-        write_response(mock_server, peer_info.as_bytes());
-        let mock_server = mock_server_from_config(&config);
-        write_response(mock_server, vote_response.as_bytes());
-        let mock_server = mock_server_from_config(&config);
-        write_response(mock_server, last_round_response.as_bytes());
+        mock_server_from_config_and_write_response(&config, pox_info_response.as_bytes());
+        mock_server_from_config_and_write_response(&config, peer_info.as_bytes());
+        mock_server_from_config_and_write_response(&config, vote_response.as_bytes());
+        mock_server_from_config_and_write_response(&config, last_round_response.as_bytes());
         h.join().unwrap();
     }
 }
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index 4b65637414..efa5348865 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -471,7 +471,7 @@ impl SignerTest {
                 0,
             )
             .expect("FATAL: failed to build vote for aggregate public key");
-        // TODO: add invalid contract calls (one with non cast-vote-aggregate-key function call and one with invalid function args)
+        // TODO: add invalid contract calls (one with non 'vote-for-aggregate-public-key' function call and one with invalid function args)
         vec![invalid_nonce_tx, invalid_signer_tx]
     }
 

From 62e2109259d1bb7584eedeaf49b2dce37d95ec4d Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Mon, 19 Feb 2024 09:45:06 -0500
Subject: [PATCH 0903/1166] CRC: use signer weights when calculating block
 rejection thresholds

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 testnet/stacks-node/src/nakamoto_node/miner.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index ef01b0ec6f..0f59111772 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -379,7 +379,8 @@ impl BlockMinerThread {
             self.get_stackerdb_contract_and_slots(stackerdbs, BLOCK_MSG_ID)?;
         let slot_ids = slot_ids_addresses.keys().cloned().collect::<Vec<_>>();
         // If more than a threshold percentage of the signers reject the block, we should not wait any further
-        let rejection_threshold = 4000 / 10 * 7;
+        let weights: u64 = signer_weights.values().sum();
+        let rejection_threshold = weights / 10 * 7;
         let mut rejections = HashSet::new();
         let mut rejections_weight: u64 = 0;
         let now = Instant::now();

From 435e6768fd10d7bb1fa8792a9c18632313ca59ee Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Mon, 19 Feb 2024 10:12:21 -0500
Subject: [PATCH 0904/1166] Fix rebase issue: rename of slots to weight

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/stacks_client.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index 47bb735700..8333d5d375 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -447,17 +447,17 @@ impl StacksClient {
             signer_ids.insert(stacks_address, signer_id);
             signer_public_keys.insert(signer_id, signer_public_key);
             let weight_start = weight_end;
-            weight_end = weight_start + entry.slots;
+            weight_end = weight_start + entry.weight;
             for key_id in weight_start..weight_end {
                 public_keys.key_ids.insert(key_id, ecdsa_public_key);
                 public_keys.signers.insert(signer_id, ecdsa_public_key);
                 coordinator_key_ids
                     .entry(signer_id)
-                    .or_insert(HashSet::with_capacity(entry.slots as usize))
+                    .or_insert(HashSet::with_capacity(entry.weight as usize))
                     .insert(key_id);
                 signer_key_ids
                     .entry(signer_id)
-                    .or_insert(Vec::with_capacity(entry.slots as usize))
+                    .or_insert(Vec::with_capacity(entry.weight as usize))
                     .push(key_id);
             }
         }
@@ -1317,7 +1317,7 @@ mod tests {
             signers: Some(vec![NakamotoSignerEntry {
                 signing_key: bytes,
                 stacked_amt: rand::thread_rng().next_u64() as u128,
-                slots: 1,
+                weight: 1,
             }]),
         };
         let stackers_response = GetStackersResponse {

From 9cce191a5b038b532b1591b2d29799c895d2db4f Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Mon, 19 Feb 2024 15:15:51 -0500
Subject: [PATCH 0905/1166] WIP: add test for post epoch 3 reward cycle
 transition

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 .../src/tests/nakamoto_integrations.rs        |  27 +-
 testnet/stacks-node/src/tests/signer.rs       | 289 +++++++++++++++---
 2 files changed, 258 insertions(+), 58 deletions(-)

diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index f9c077b9e8..b77a51fc96 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -595,13 +595,14 @@ pub fn boot_to_epoch_3_reward_set(
     let epoch_3 = &epochs[StacksEpoch::find_epoch_by_id(&epochs, StacksEpochId::Epoch30).unwrap()];
     let reward_cycle_len = naka_conf.get_burnchain().pox_constants.reward_cycle_length as u64;
     let prepare_phase_len = naka_conf.get_burnchain().pox_constants.prepare_length as u64;
+
+    let epoch_3_start_height = epoch_3.start_height;
     assert!(
-        epoch_3.start_height > 0,
-        "Epoch 3 start height must be greater than 0"
+        epoch_3_start_height > 0,
+        "Epoch 3.0 start height must be greater than 0"
     );
-    let epoch_3_reward_cycle_boundary = epoch_3.start_height;
-    let epoch_3_reward_cycle_boundary = epoch_3_reward_cycle_boundary
-        .saturating_sub(epoch_3_reward_cycle_boundary % reward_cycle_len);
+    let epoch_3_reward_cycle_boundary =
+        epoch_3_start_height.saturating_sub(epoch_3_start_height % reward_cycle_len);
     let epoch_3_reward_set_calculation_boundary =
         epoch_3_reward_cycle_boundary.saturating_sub(prepare_phase_len);
     let epoch_3_reward_set_calculation = epoch_3_reward_set_calculation_boundary.wrapping_add(1);
@@ -617,6 +618,16 @@ pub fn boot_to_epoch_3_reward_set(
         .get_burnchain()
         .block_height_to_reward_cycle(block_height)
         .unwrap();
+    let lock_period = 12;
+    debug!("Test Cycle Info";
+     "prepare_phase_len" => {prepare_phase_len},
+     "reward_cycle_len" => {reward_cycle_len},
+     "block_height" => {block_height},
+     "reward_cycle" => {reward_cycle},
+     "epoch_3_reward_cycle_boundary" => {epoch_3_reward_cycle_boundary},
+     "epoch_3_reward_set_calculation" => {epoch_3_reward_set_calculation},
+     "epoch_3_start_height" => {epoch_3_start_height},
+    );
     for (stacker_sk, signer_sk) in stacker_sks.iter().zip(signer_sks.iter()) {
         let pox_addr = PoxAddress::from_legacy(
             AddressHashMode::SerializeP2PKH,
@@ -630,7 +641,7 @@ pub fn boot_to_epoch_3_reward_set(
             reward_cycle.into(),
             &Pox4SignatureTopic::StackStx,
             CHAIN_ID_TESTNET,
-            12_u128,
+            lock_period,
         )
         .unwrap()
         .to_rsv();
@@ -646,8 +657,8 @@ pub fn boot_to_epoch_3_reward_set(
             &[
                 clarity::vm::Value::UInt(POX_4_DEFAULT_STACKER_STX_AMT),
                 pox_addr_tuple.clone(),
-                clarity::vm::Value::UInt(205),
-                clarity::vm::Value::UInt(12),
+                clarity::vm::Value::UInt(block_height as u128),
+                clarity::vm::Value::UInt(lock_period),
                 clarity::vm::Value::buff_from(signature).unwrap(),
                 clarity::vm::Value::buff_from(signer_pk.to_bytes_compressed()).unwrap(),
             ],
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index efa5348865..ca150f03f0 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -41,6 +41,7 @@ use wsts::state_machine::OperationResult;
 use wsts::taproot::SchnorrProof;
 
 use crate::config::{Config as NeonConfig, EventKeyType, EventObserverConfig, InitialBalance};
+use crate::event_dispatcher::MinedNakamotoBlockEvent;
 use crate::neon::Counters;
 use crate::run_loop::boot_nakamoto;
 use crate::tests::bitcoin_regtest::BitcoinCoreController;
@@ -156,35 +157,16 @@ impl SignerTest {
         set_dkg
     }
 
-    fn mine_nakamoto_block(&mut self, timeout: Duration) {
-        info!("Nakamoto miner started...");
-        let (vrfs_submitted, commits_submitted) = (
-            self.running_nodes.vrfs_submitted.clone(),
-            self.running_nodes.commits_submitted.clone(),
-        );
-        // first block wakes up the run loop, wait until a key registration has been submitted.
-        next_block_and(&mut self.running_nodes.btc_regtest_controller, 60, || {
-            let vrf_count = vrfs_submitted.load(Ordering::SeqCst);
-            Ok(vrf_count >= 1)
-        })
-        .unwrap();
-
-        info!("Successfully triggered first block to wake up the miner runloop.");
-        // second block should confirm the VRF register, wait until a block commit is submitted
-        next_block_and(&mut self.running_nodes.btc_regtest_controller, 60, || {
-            let commits_count = commits_submitted.load(Ordering::SeqCst);
-            Ok(commits_count >= 1)
-        })
-        .unwrap();
-
+    fn mine_nakamoto_block(&mut self, timeout: Duration) -> MinedNakamotoBlockEvent {
+        let commits_submitted = self.running_nodes.commits_submitted.clone();
         let mined_block_time = Instant::now();
-        info!("Mining first Nakamoto block");
-        let _ = next_block_and_mine_commit(
+        next_block_and_mine_commit(
             &mut self.running_nodes.btc_regtest_controller,
             60,
             &self.running_nodes.coord_channel,
             &commits_submitted,
-        );
+        )
+        .unwrap();
 
         let t_start = Instant::now();
         while test_observer::get_mined_nakamoto_blocks().is_empty() {
@@ -199,6 +181,25 @@ impl SignerTest {
             "Nakamoto block mine time elapsed: {:?}",
             mined_block_elapsed_time
         );
+        test_observer::get_mined_nakamoto_blocks().pop().unwrap()
+    }
+
+    fn wait_for_validate_ok_response(&mut self, timeout: Duration) -> Sha512Trunc256Sum {
+        // Wait for the block to show up in the test observer (Don't have to wait long as if we have received a mined block already,
+        // we know that the signers have already received their block proposal events via their event observers)
+        let t_start = Instant::now();
+        while test_observer::get_proposal_responses().is_empty() {
+            assert!(
+                t_start.elapsed() < timeout,
+                "Timed out while waiting for block proposal event"
+            );
+            thread::sleep(Duration::from_secs(1));
+        }
+        let validate_responses = test_observer::get_proposal_responses();
+        match validate_responses.first().expect("No block proposal") {
+            BlockValidateResponse::Ok(block_validated) => block_validated.signer_signature_hash,
+            _ => panic!("Unexpected response"),
+        }
     }
 
     fn wait_for_dkg(&mut self, timeout: Duration) -> Point {
@@ -336,7 +337,7 @@ impl SignerTest {
             epoch_30_boundary,
             &self.running_nodes.conf,
         );
-        info!("Advanced to Nakamoto! Ready to Sign Blocks!");
+        info!("Advanced to Nakamoto epoch 3.0 boundary {epoch_30_boundary}! Ready to Sign Blocks!");
     }
 
     fn get_current_reward_cycle(&self) -> u64 {
@@ -819,38 +820,52 @@ fn stackerdb_block_proposal() {
     info!("------------------------- Test Setup -------------------------");
     let mut signer_test = SignerTest::new(5);
     let timeout = Duration::from_secs(200);
+    let short_timeout = Duration::from_secs(30);
+
     let key = signer_test.boot_to_epoch_3(timeout);
+    let (vrfs_submitted, commits_submitted) = (
+        signer_test.running_nodes.vrfs_submitted.clone(),
+        signer_test.running_nodes.commits_submitted.clone(),
+    );
+    // first block wakes up the run loop, wait until a key registration has been submitted.
+    next_block_and(
+        &mut signer_test.running_nodes.btc_regtest_controller,
+        60,
+        || {
+            let vrf_count = vrfs_submitted.load(Ordering::SeqCst);
+            Ok(vrf_count >= 1)
+        },
+    )
+    .unwrap();
+
+    info!("Successfully triggered first block to wake up the miner runloop.");
+    // second block should confirm the VRF register, wait until a block commit is submitted
+    next_block_and(
+        &mut signer_test.running_nodes.btc_regtest_controller,
+        60,
+        || {
+            let commits_count = commits_submitted.load(Ordering::SeqCst);
+            Ok(commits_count >= 1)
+        },
+    )
+    .unwrap();
+
     signer_test.mine_nakamoto_block(timeout);
 
-    info!("------------------------- Verify Sign Round -------------------------");
-    let short_timeout = Duration::from_secs(30);
-    let frost_signatures = signer_test.wait_for_frost_signatures(short_timeout);
+    info!("------------------------- Test Block Proposal -------------------------");
+    // Verify that the signers accepted the proposed block, sending back a validate ok response
+    let proposed_signer_signature_hash = signer_test.wait_for_validate_ok_response(short_timeout);
 
-    info!("------------------------- Verify Block Proposal Response -------------------------");
-    // Wait for the block to show up in the test observer (Don't have to wait long as if we have received a mined block already,
-    // we know that the signers have already received their block proposal events via their event observers)
-    let t_start = Instant::now();
-    while test_observer::get_proposal_responses().is_empty() {
-        assert!(
-            t_start.elapsed() < short_timeout,
-            "Timed out while waiting for block proposal event"
-        );
-        thread::sleep(Duration::from_secs(1));
-    }
-    let validate_responses = test_observer::get_proposal_responses();
-    let proposed_signer_signature_hash =
-        match validate_responses.first().expect("No block proposal") {
-            BlockValidateResponse::Ok(block_validated) => block_validated.signer_signature_hash,
-            _ => panic!("Unexpected response"),
-        };
+    info!("------------------------- Test Block Signed -------------------------");
+    // Verify that the signers signed the proposed block
+    let frost_signatures = signer_test.wait_for_frost_signatures(short_timeout);
     for signature in &frost_signatures {
         assert!(
             signature.verify(&key, proposed_signer_signature_hash.0.as_slice()),
             "Signature verification failed"
         );
     }
-
-    info!("------------------------- Verify Block Signature Returned to Miners -------------------------");
+    info!("------------------------- Test Signers Broadcast Block -------------------------");
     // Verify that the signers broadcasted a signed NakamotoBlock back to the .signers contract
     let t_start = Instant::now();
     let mut chunk = None;
@@ -974,7 +989,34 @@ fn stackerdb_block_proposal_filters_bad_transactions() {
         .send_message_with_retry(SignerMessage::Transactions(txs))
         .expect("Failed to write expected transactions to stackerdb");
 
-    signer_test.mine_nakamoto_block(timeout);
+    let (vrfs_submitted, commits_submitted) = (
+        signer_test.running_nodes.vrfs_submitted.clone(),
+        signer_test.running_nodes.commits_submitted.clone(),
+    );
+    // first block wakes up the run loop, wait until a key registration has been submitted.
+    next_block_and(
+        &mut signer_test.running_nodes.btc_regtest_controller,
+        60,
+        || {
+            let vrf_count = vrfs_submitted.load(Ordering::SeqCst);
+            Ok(vrf_count >= 1)
+        },
+    )
+    .unwrap();
+
+    info!("Successfully triggered first block to wake up the miner runloop.");
+    // second block should confirm the VRF register, wait until a block commit is submitted
+    next_block_and(
+        &mut signer_test.running_nodes.btc_regtest_controller,
+        60,
+        || {
+            let commits_count = commits_submitted.load(Ordering::SeqCst);
+            Ok(commits_count >= 1)
+        },
+    )
+    .unwrap();
+
+    let mined_block_event = signer_test.mine_nakamoto_block(timeout);
 
     info!("------------------------- Test Block Accepted -------------------------");
 
@@ -1015,8 +1057,6 @@ fn stackerdb_block_proposal_filters_bad_transactions() {
     }
 
     info!("------------------------- Verify Nakamoto Block Mined -------------------------");
-    let mined_block_events = test_observer::get_mined_nakamoto_blocks();
-    let mined_block_event = mined_block_events.first().expect("No mined block");
     let mut mined_valid_tx = false;
     for tx_event in &mined_block_event.tx_events {
         let TransactionEvent::Success(tx_success) = tx_event else {
@@ -1037,3 +1077,152 @@ fn stackerdb_block_proposal_filters_bad_transactions() {
     }
     signer_test.shutdown();
 }
+
+#[test]
+#[ignore]
+/// Test that signers can handle a transition between Nakamoto reward cycles
+///
+/// Test Setup:
+/// The test spins up five stacks signers, one miner Nakamoto node, and a corresponding bitcoind.
+/// The stacks node is advanced to epoch 2.5, triggering a DKG round. The stacks node is then advanced
+/// to Epoch 3.0 boundary to allow block signing.
+///
+/// Test Execution:
+/// The node mines multiple Nakamoto reward cycles, sending blocks to observing signers to sign and return.
+///
+/// Test Assertion:
+/// Signers perform DKG for Nakamoto reward cycle N.
+/// Signers sign Nakamoto blocks for miners in reward cycle N.
+/// Miner successfully mine these signed blocks in reward cycle N.
+/// Signers perform DKG for the next Nakamoto reward cycle N + 1.
+/// Signers sign Nakamoto blocks for miners in reward cycle N + 1.
+/// Miner successfully mine these signed blocks in reward cycle N + 1.
+fn stackerdb_reward_cycle_transitions() {
+    if env::var("BITCOIND_TEST") != Ok("1".into()) {
+        return;
+    }
+
+    tracing_subscriber::registry()
+        .with(fmt::layer())
+        .with(EnvFilter::from_default_env())
+        .init();
+
+    info!("------------------------- Test Setup -------------------------");
+    let mut signer_test = SignerTest::new(5);
+    let timeout = Duration::from_secs(200);
+    let set_dkg_1 = signer_test.boot_to_epoch_3(timeout); // Boot to epoch 3.0 boundary
+    let (vrfs_submitted, commits_submitted) = (
+        signer_test.running_nodes.vrfs_submitted.clone(),
+        signer_test.running_nodes.commits_submitted.clone(),
+    );
+    // first block wakes up the run loop, wait until a key registration has been submitted.
+    next_block_and(
+        &mut signer_test.running_nodes.btc_regtest_controller,
+        60,
+        || {
+            let vrf_count = vrfs_submitted.load(Ordering::SeqCst);
+            Ok(vrf_count >= 1)
+        },
+    )
+    .unwrap();
+
+    info!("Successfully triggered first block to wake up the miner runloop.");
+    // second block should confirm the VRF register, wait until a block commit is submitted
+    next_block_and(
+        &mut signer_test.running_nodes.btc_regtest_controller,
+        60,
+        || {
+            let commits_count = commits_submitted.load(Ordering::SeqCst);
+            Ok(commits_count >= 1)
+        },
+    )
+    .unwrap();
+
+    let curr_reward_cycle = signer_test.get_current_reward_cycle();
+    let prepare_phase_len = signer_test
+        .running_nodes
+        .conf
+        .get_burnchain()
+        .pox_constants
+        .prepare_length as u64;
+    let current_block_height = signer_test
+        .running_nodes
+        .btc_regtest_controller
+        .get_headers_height();
+    let next_reward_cycle = curr_reward_cycle.saturating_add(1);
+    let next_reward_cycle_boundary = signer_test
+        .running_nodes
+        .btc_regtest_controller
+        .get_burnchain()
+        .reward_cycle_to_block_height(next_reward_cycle)
+        .saturating_sub(1);
+    let next_reward_cycle_reward_set_calculation =
+        next_reward_cycle_boundary.saturating_sub(prepare_phase_len);
+
+    info!("------------------------- Test Nakamoto Block Mining in Reward Cycle {curr_reward_cycle} -------------------------");
+
+    debug!("At block height {current_block_height} in reward cycle {curr_reward_cycle}");
+
+    let nmb_blocks_to_mine =
+        next_reward_cycle_reward_set_calculation.saturating_sub(current_block_height);
+    debug!(
+        "Mining {} Nakamoto blocks to reach next reward cycle reward set calculation at block height {next_reward_cycle_reward_set_calculation}",
+        nmb_blocks_to_mine
+    );
+    for _ in 0..=nmb_blocks_to_mine {
+        signer_test.mine_nakamoto_block(timeout);
+        signer_test.wait_for_validate_ok_response(timeout);
+        signer_test.wait_for_frost_signatures(timeout);
+    }
+
+    info!("------------------------- Test DKG for Next Reward Cycle {next_reward_cycle} -------------------------");
+    let current_block_height = signer_test
+        .running_nodes
+        .btc_regtest_controller
+        .get_headers_height();
+
+    debug!("At block height {current_block_height} in reward cycle {curr_reward_cycle}");
+    debug!("Wait for the next reward cycle {next_reward_cycle} dkg to be calculated by the new signers");
+
+    let set_dkg_2 = signer_test.wait_for_dkg(timeout);
+    assert_ne!(set_dkg_1, set_dkg_2);
+
+    debug!("DKG has been calculated for the next reward cycle {next_reward_cycle}");
+
+    let current_block_height = signer_test
+        .running_nodes
+        .btc_regtest_controller
+        .get_headers_height();
+
+    let nmb_blocks_to_mine = next_reward_cycle_boundary.saturating_sub(current_block_height);
+
+    debug!(
+        "Mining {} Nakamoto blocks to reach next reward cycle {next_reward_cycle} boundary block height {next_reward_cycle_boundary}",
+        nmb_blocks_to_mine
+    );
+    for _ in 0..nmb_blocks_to_mine {
+        signer_test.mine_nakamoto_block(timeout);
+        signer_test.wait_for_validate_ok_response(timeout);
+        signer_test.wait_for_frost_signatures(timeout);
+    }
+
+    info!("------------------------- Test Nakamoto Block Mining in Reward Cycle {next_reward_cycle} -------------------------");
+    let current_block_height = signer_test
+        .running_nodes
+        .btc_regtest_controller
+        .get_headers_height();
+
+    debug!("At block height {current_block_height} in reward cycle {next_reward_cycle}");
+    info!(
+        "Mining first Nakamoto block of reward cycle {}...",
+        next_reward_cycle
+    );
+    signer_test.mine_nakamoto_block(timeout);
+    let hash = signer_test.wait_for_validate_ok_response(timeout);
+    let signatures = signer_test.wait_for_frost_signatures(timeout);
+    // Verify the signers accepted the proposed block and are using the new DKG to sign it
+    for signature in &signatures {
+        assert!(signature.verify(&set_dkg_2, hash.0.as_slice()));
+    }
+    signer_test.shutdown();
+}

From 867198119d53577e41db9647bec3591f0537fdec Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Mon, 19 Feb 2024 17:33:05 -0500
Subject: [PATCH 0906/1166] CRC: cleanup logging

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/stacks_client.rs      |  1 -
 stacks-signer/src/signer.rs                    | 14 +++++++++-----
 testnet/stacks-node/src/nakamoto_node/miner.rs |  2 +-
 testnet/stacks-node/src/run_loop/neon.rs       |  2 +-
 4 files changed, 11 insertions(+), 8 deletions(-)

diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index 8333d5d375..46346745ab 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -520,7 +520,6 @@ impl StacksClient {
     /// Get the current reward cycle from the stacks node
     pub fn get_current_reward_cycle(&self) -> Result<u64, ClientError> {
         let pox_data = self.get_pox_data()?;
-        println!("GOT REWARD CYCLE: {}", pox_data.reward_cycle_id);
         Ok(pox_data.reward_cycle_id)
     }
 
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index 81b1fb9aae..3390e7d785 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -289,10 +289,10 @@ impl RegisteredSigner {
                 // The dkg id will increment internally following "start_dkg_round" so do not increment it here
                 self.coordinator.current_dkg_id = vote_round.unwrap_or(0);
                 info!(
-                    "Signer #{}: Starting DKG vote round {}, for reward cycle {}",
-                    self.signer_id,
-                    self.coordinator.current_dkg_id.wrapping_add(1),
-                    self.reward_cycle
+                    "Signer #{}: Starting DKG vote",
+                    self.signer_id;
+                    "round" => self.coordinator.current_dkg_id.wrapping_add(1),
+                    "cycle" => self.reward_cycle,
                 );
                 match self.coordinator.start_dkg_round() {
                     Ok(msg) => {
@@ -319,7 +319,11 @@ impl RegisteredSigner {
                     debug!("Signer #{}: Received a sign command for a block we are already signing over. Ignore it.", self.signer_id);
                     return;
                 }
-                info!("Signer #{}: Signing block: {block:?}", self.signer_id);
+                info!("Signer #{}: Signing block", self.signer_id;
+                         "block_consensus_hash" => %block.header.consensus_hash,
+                         "block_height" => block.header.chain_length,
+                         "pre_sign_block_id" => %block.block_id(),
+                );
                 match self.coordinator.start_signing_round(
                     &block.serialize_to_vec(),
                     *is_taproot,
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index 0f59111772..d011cc4410 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -411,7 +411,7 @@ impl BlockMinerThread {
                         {
                             // The signature is valid across the signer signature hash of the original proposed block
                             // Immediately return and update the block with this new signature before appending it to the chain
-                            test_debug!("Miner: received a signature accross the proposed block's signer signature hash ({signer_signature_hash:?}): {signature:?}");
+                            debug!("Miner: received a signature accross the proposed block's signer signature hash ({signer_signature_hash:?}): {signature:?}");
                             return Ok(signature);
                         }
                         // We received an accepted block for some unknown block hash...Useless! Ignore it.
diff --git a/testnet/stacks-node/src/run_loop/neon.rs b/testnet/stacks-node/src/run_loop/neon.rs
index 4c303618c6..3f5c04f4c2 100644
--- a/testnet/stacks-node/src/run_loop/neon.rs
+++ b/testnet/stacks-node/src/run_loop/neon.rs
@@ -490,7 +490,7 @@ impl RunLoop {
             }) as Box<dyn FnOnce(&mut ClarityTx)>;
             Some(callback)
         } else {
-            warn!("Neon node booting with no aggregate public key. Must have signers available to sign blocks.");
+            debug!("Neon node booting with no aggregate public key. Must have signers available to sign blocks.");
             None
         };
 

From 74ec4bca4fd0db9566bb47c3c3ec46009b14e6e0 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Mon, 19 Feb 2024 17:56:10 -0500
Subject: [PATCH 0907/1166] Fix prepare phase reward set calculation

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 testnet/stacks-node/src/tests/signer.rs | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index ca150f03f0..08234dd8f0 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -1156,8 +1156,9 @@ fn stackerdb_reward_cycle_transitions() {
         .get_burnchain()
         .reward_cycle_to_block_height(next_reward_cycle)
         .saturating_sub(1);
-    let next_reward_cycle_reward_set_calculation =
-        next_reward_cycle_boundary.saturating_sub(prepare_phase_len);
+    let next_reward_cycle_reward_set_calculation = next_reward_cycle_boundary
+        .saturating_sub(prepare_phase_len)
+        .saturating_add(1);
 
     info!("------------------------- Test Nakamoto Block Mining in Reward Cycle {curr_reward_cycle} -------------------------");
 
@@ -1169,7 +1170,7 @@ fn stackerdb_reward_cycle_transitions() {
         "Mining {} Nakamoto blocks to reach next reward cycle reward set calculation at block height {next_reward_cycle_reward_set_calculation}",
         nmb_blocks_to_mine
     );
-    for _ in 0..=nmb_blocks_to_mine {
+    for _ in 0..nmb_blocks_to_mine {
         signer_test.mine_nakamoto_block(timeout);
         signer_test.wait_for_validate_ok_response(timeout);
         signer_test.wait_for_frost_signatures(timeout);

From 33a8a807875dcd5f881268a26f486b3bd9516d8a Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Mon, 19 Feb 2024 18:44:53 -0500
Subject: [PATCH 0908/1166] Increase wait_for_signers timeout

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 testnet/stacks-node/src/config.rs              | 2 +-
 testnet/stacks-node/src/nakamoto_node/miner.rs | 1 +
 testnet/stacks-node/src/tests/signer.rs        | 2 +-
 3 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index 21cf238509..5970d0996d 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -2059,7 +2059,7 @@ impl Default for MinerConfig {
             filter_origins: HashSet::new(),
             max_reorg_depth: 3,
             // TODO: update to a sane value based on stackerdb benchmarking
-            wait_on_signers: Duration::from_millis(10_000),
+            wait_on_signers: Duration::from_secs(20),
         }
     }
 }
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index d011cc4410..7239a16213 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -471,6 +471,7 @@ impl BlockMinerThread {
             thread::sleep(Duration::from_millis(WAIT_FOR_SIGNERS_MS));
         }
         // We have waited for the signers for too long: stop waiting so we can propose a new block
+        debug!("Miner: exceeded signer signature timeout. Will propose a new block");
         Err(NakamotoNodeError::SignerSignatureError(
             "Timed out waiting for signers",
         ))
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index 08234dd8f0..93341037d4 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -1158,7 +1158,7 @@ fn stackerdb_reward_cycle_transitions() {
         .saturating_sub(1);
     let next_reward_cycle_reward_set_calculation = next_reward_cycle_boundary
         .saturating_sub(prepare_phase_len)
-        .saturating_add(1);
+        .saturating_add(1); // +1 since second block of the prepare phase is where the reward set is calculated
 
     info!("------------------------- Test Nakamoto Block Mining in Reward Cycle {curr_reward_cycle} -------------------------");
 

From c0a0d74a2631eb1f690d83591dfe2e64fbb150a6 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Tue, 20 Feb 2024 17:25:37 -0500
Subject: [PATCH 0909/1166] Fix reward set boundary calculation

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 testnet/stacks-node/src/tests/nakamoto_integrations.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index b77a51fc96..830ae6dcff 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -605,7 +605,7 @@ pub fn boot_to_epoch_3_reward_set(
         epoch_3_start_height.saturating_sub(epoch_3_start_height % reward_cycle_len);
     let epoch_3_reward_set_calculation_boundary =
         epoch_3_reward_cycle_boundary.saturating_sub(prepare_phase_len);
-    let epoch_3_reward_set_calculation = epoch_3_reward_set_calculation_boundary.wrapping_add(1);
+    let epoch_3_reward_set_calculation = epoch_3_reward_set_calculation_boundary.wrapping_add(2); // +2 to ensure we are at the second block of the prepare phase
     let http_origin = format!("http://{}", &naka_conf.node.rpc_bind);
     next_block_and_wait(btc_regtest_controller, &blocks_processed);
     next_block_and_wait(btc_regtest_controller, &blocks_processed);

From b0d4a34a1ab151e16e01cab16ab5eb3b8d010433 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Tue, 20 Feb 2024 17:26:12 -0500
Subject: [PATCH 0910/1166] Retreive the transactions from the NEXT signers in
 the miner

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 .../stacks-node/src/nakamoto_node/miner.rs    | 24 ++++++++++++-------
 1 file changed, 16 insertions(+), 8 deletions(-)

diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index 7239a16213..13ab1d41c2 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -263,16 +263,12 @@ impl BlockMinerThread {
         &self,
         stackerdbs: &StackerDBs,
         msg_id: u32,
+        reward_cycle: u64,
     ) -> Result<(QualifiedContractIdentifier, HashMap<u32, StacksAddress>), NakamotoNodeError> {
         let stackerdb_contracts = stackerdbs
             .get_stackerdb_contract_ids()
             .expect("FATAL: could not get the stacker DB contract ids");
 
-        let reward_cycle = self
-            .burnchain
-            .block_height_to_reward_cycle(self.burn_block.block_height)
-            .expect("FATAL: no reward cycle for burn block");
-
         let signers_contract_id = NakamotoSigners::make_signers_db_contract_id(
             reward_cycle,
             msg_id,
@@ -308,8 +304,16 @@ impl BlockMinerThread {
         sortdb: &SortitionDB,
         stackerdbs: &StackerDBs,
     ) -> Result<Vec<StacksTransaction>, NakamotoNodeError> {
-        let (signers_contract_id, slot_ids_addresses) =
-            self.get_stackerdb_contract_and_slots(stackerdbs, TRANSACTIONS_MSG_ID)?;
+        let next_reward_cycle = self
+            .burnchain
+            .block_height_to_reward_cycle(self.burn_block.block_height)
+            .expect("FATAL: no reward cycle for burn block")
+            .wrapping_add(1);
+        let (signers_contract_id, slot_ids_addresses) = self.get_stackerdb_contract_and_slots(
+            stackerdbs,
+            TRANSACTIONS_MSG_ID,
+            next_reward_cycle,
+        )?;
         let slot_ids = slot_ids_addresses.keys().cloned().collect::<Vec<_>>();
         let addresses = slot_ids_addresses.values().cloned().collect::<HashSet<_>>();
         // Get the transactions from the signers for the next block
@@ -375,8 +379,12 @@ impl BlockMinerThread {
         signer_signature_hash: &Sha512Trunc256Sum,
         signer_weights: HashMap<StacksAddress, u64>,
     ) -> Result<ThresholdSignature, NakamotoNodeError> {
+        let reward_cycle = self
+            .burnchain
+            .block_height_to_reward_cycle(self.burn_block.block_height)
+            .expect("FATAL: no reward cycle for burn block");
         let (signers_contract_id, slot_ids_addresses) =
-            self.get_stackerdb_contract_and_slots(stackerdbs, BLOCK_MSG_ID)?;
+            self.get_stackerdb_contract_and_slots(stackerdbs, BLOCK_MSG_ID, reward_cycle)?;
         let slot_ids = slot_ids_addresses.keys().cloned().collect::<Vec<_>>();
         // If more than a threshold percentage of the signers reject the block, we should not wait any further
         let weights: u64 = signer_weights.values().sum();

From 5149d6fcd363950c082841b9d0f7827a1c0ae29a Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Tue, 20 Feb 2024 17:27:05 -0500
Subject: [PATCH 0911/1166] Always refresh configs, temp set consenus has to 0
 in coordinator calculation, retrieve NEXT signers transactions in signer

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/mod.rs           |   3 -
 stacks-signer/src/client/stackerdb.rs     |  59 +++-
 stacks-signer/src/client/stacks_client.rs | 340 ++++++----------------
 stacks-signer/src/config.rs               |   2 -
 stacks-signer/src/coordinator.rs          | 116 +++++++-
 stacks-signer/src/runloop.rs              | 224 ++++++--------
 stacks-signer/src/signer.rs               | 208 ++++++-------
 testnet/stacks-node/src/tests/signer.rs   |  30 +-
 8 files changed, 448 insertions(+), 534 deletions(-)

diff --git a/stacks-signer/src/client/mod.rs b/stacks-signer/src/client/mod.rs
index 42374168f3..2aa062e03b 100644
--- a/stacks-signer/src/client/mod.rs
+++ b/stacks-signer/src/client/mod.rs
@@ -436,7 +436,6 @@ pub(crate) mod tests {
         let mut end_key_id = start_key_id;
         let mut signer_public_keys = HashMap::new();
         let mut signer_slot_ids = HashMap::new();
-        let mut coordinator_ids = vec![];
         let stacks_address = config.stacks_address;
         let ecdsa_private_key = config.ecdsa_private_key;
         let ecdsa_public_key =
@@ -495,7 +494,6 @@ pub(crate) mod tests {
             signer_ids.insert(address, signer_id);
             addresses.push(address);
             start_key_id = end_key_id;
-            coordinator_ids.push(signer_id);
         }
         (
             SignerConfig {
@@ -511,7 +509,6 @@ pub(crate) mod tests {
                     signer_ids,
                     signer_public_keys,
                 },
-                coordinator_ids,
                 ecdsa_private_key: config.ecdsa_private_key,
                 stacks_private_key: config.stacks_private_key,
                 node_host: config.node_host,
diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index c25384918e..2875cb5967 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -47,6 +47,8 @@ pub struct StackerDB {
     signer_slot_id: u32,
     /// The reward cycle of the connecting signer
     reward_cycle: u64,
+    /// The stacker-db transaction msg session for the NEXT reward cycle
+    next_transaction_session: StackerDBSession,
 }
 
 impl From<&SignerConfig> for StackerDB {
@@ -85,12 +87,27 @@ impl StackerDB {
                 ),
             );
         }
+        let next_transaction_session = StackerDBSession::new(
+            host,
+            QualifiedContractIdentifier::new(
+                stackerdb_issuer.into(),
+                ContractName::from(
+                    NakamotoSigners::make_signers_db_name(
+                        reward_cycle.wrapping_add(1),
+                        TRANSACTIONS_MSG_ID,
+                    )
+                    .as_str(),
+                ),
+            ),
+        );
+
         Self {
             signers_message_stackerdb_sessions,
             stacks_private_key,
             slot_versions: HashMap::new(),
             signer_slot_id,
             reward_cycle,
+            next_transaction_session,
         }
     }
 
@@ -164,19 +181,11 @@ impl StackerDB {
         }
     }
 
-    /// Get the latest signer transactions from signer ids
-    pub fn get_signer_transactions_with_retry(
-        &mut self,
+    /// Get the transactions from stackerdb for the signers
+    fn get_transactions(
+        transactions_session: &mut StackerDBSession,
         signer_ids: &[u32],
     ) -> Result<Vec<StacksTransaction>, ClientError> {
-        debug!("Getting latest chunks from stackerdb for the following signers: {signer_ids:?}",);
-        let Some(transactions_session) = self
-            .signers_message_stackerdb_sessions
-            .get_mut(&TRANSACTIONS_MSG_ID)
-        else {
-            return Err(ClientError::NotConnected);
-        };
-
         let send_request = || {
             transactions_session
                 .get_latest_chunks(signer_ids)
@@ -216,6 +225,30 @@ impl StackerDB {
         Ok(transactions)
     }
 
+    /// Get the latest signer transactions from signer ids for the current reward cycle
+    pub fn get_current_transactions_with_retry(
+        &mut self,
+        signer_id: u32,
+    ) -> Result<Vec<StacksTransaction>, ClientError> {
+        debug!("Signer #{signer_id}: Getting latest transactions from stacker db",);
+        let Some(transactions_session) = self
+            .signers_message_stackerdb_sessions
+            .get_mut(&TRANSACTIONS_MSG_ID)
+        else {
+            return Err(ClientError::NotConnected);
+        };
+        Self::get_transactions(transactions_session, &[signer_id])
+    }
+
+    /// Get the latest signer transactions from signer ids for the next reward cycle
+    pub fn get_next_transactions_with_retry(
+        &mut self,
+        signer_ids: &[u32],
+    ) -> Result<Vec<StacksTransaction>, ClientError> {
+        debug!("Getting latest chunks from stackerdb for the following signers: {signer_ids:?}",);
+        Self::get_transactions(&mut self.next_transaction_session, signer_ids)
+    }
+
     /// Retrieve the signer set this stackerdb client is attached to
     pub fn get_signer_set(&self) -> u32 {
         u32::try_from(self.reward_cycle % 2).expect("FATAL: reward cycle % 2 exceeds u32::MAX")
@@ -270,7 +303,7 @@ mod tests {
         let message = signer_message.serialize_to_vec();
 
         let signer_ids = vec![0, 1];
-        let h = spawn(move || stackerdb.get_signer_transactions_with_retry(&signer_ids));
+        let h = spawn(move || stackerdb.get_next_transactions_with_retry(&signer_ids));
         let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
         response_bytes.extend(message);
         let mock_server = mock_server_from_config(&config);
@@ -320,9 +353,9 @@ mod tests {
         let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
         let payload = serde_json::to_string(&ack).expect("Failed to serialize ack");
         response_bytes.extend(payload.as_bytes());
+        let mock_server = mock_server_from_config(&config);
         let h = spawn(move || stackerdb.send_message_with_retry(signer_message));
         std::thread::sleep(Duration::from_millis(100));
-        let mock_server = mock_server_from_config(&config);
         write_response(mock_server, response_bytes.as_slice());
         assert_eq!(ack, h.join().unwrap().unwrap());
     }
diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index 46346745ab..bd1c3703e9 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -37,11 +37,8 @@ use serde_json::json;
 use slog::{slog_debug, slog_warn};
 use stacks_common::codec::StacksMessageCodec;
 use stacks_common::consts::{CHAIN_ID_MAINNET, CHAIN_ID_TESTNET};
-use stacks_common::types::chainstate::{
-    ConsensusHash, StacksAddress, StacksPrivateKey, StacksPublicKey,
-};
+use stacks_common::types::chainstate::{StacksAddress, StacksPrivateKey, StacksPublicKey};
 use stacks_common::types::StacksEpochId;
-use stacks_common::util::hash::Sha256Sum;
 use stacks_common::{debug, warn};
 use wsts::curve::ecdsa;
 use wsts::curve::point::{Compressed, Point};
@@ -117,41 +114,6 @@ impl StacksClient {
         &self.stacks_address
     }
 
-    /// Calculate the ordered list of coordinator ids by comparing the provided public keys against the pox consensus hash
-    pub fn calculate_coordinator_ids(&self, public_keys: &PublicKeys) -> Vec<u32> {
-        let pox_consensus_hash = match self.get_pox_consenus_hash() {
-            Ok(hash) => hash,
-            Err(e) => {
-                debug!("Failed to get stacks tip consensus hash: {e:?}");
-                let mut default_coordinator_list: Vec<_> =
-                    public_keys.signers.keys().cloned().collect();
-                default_coordinator_list.sort();
-                return default_coordinator_list;
-            }
-        };
-        debug!("Using pox_consensus_hash {pox_consensus_hash:?} for selecting coordinator");
-
-        // Create combined hash of each signer's public key with pox_consensus_hash
-        let mut selection_ids = public_keys
-            .signers
-            .iter()
-            .map(|(&id, pk)| {
-                let pk_bytes = pk.to_bytes();
-                let mut buffer =
-                    Vec::with_capacity(pk_bytes.len() + pox_consensus_hash.as_bytes().len());
-                buffer.extend_from_slice(&pk_bytes[..]);
-                buffer.extend_from_slice(pox_consensus_hash.as_bytes());
-                let digest = Sha256Sum::from_data(&buffer).as_bytes().to_vec();
-                (id, digest)
-            })
-            .collect::<Vec<_>>();
-
-        // Sort the selection IDs based on the hash
-        selection_ids.sort_by_key(|(_, hash)| hash.clone());
-        // Return only the ids
-        selection_ids.iter().map(|(id, _)| *id).collect()
-    }
-
     /// Retrieve the signer slots stored within the stackerdb contract
     pub fn get_stackerdb_signer_slots(
         &self,
@@ -216,29 +178,8 @@ impl StacksClient {
         self.parse_aggregate_public_key(value)
     }
 
-    /// Retrieve the pox consensus hash from the stacks node
-    pub fn get_pox_consenus_hash(&self) -> Result<ConsensusHash, ClientError> {
-        let peer_info = self.get_peer_info()?;
-        Ok(peer_info.pox_consensus)
-    }
-
-    /// Retrieve the stacks node current epoch on a retry
-    /// Will default to Epoch 2.4 if the node does not support the Epoch endpoint
-    pub fn get_node_epoch_with_retry(&self) -> Result<StacksEpochId, ClientError> {
-        retry_with_exponential_backoff(|| match self.get_node_epoch() {
-            Ok(epoch) => Ok(epoch),
-            Err(e) => match e {
-                ClientError::UnsupportedStacksFeature(_) => {
-                    warn!("Stacks Node does not support Epoch endpoint");
-                    Err(backoff::Error::permanent(e))
-                }
-                e => Err(backoff::Error::transient(e)),
-            },
-        })
-    }
-
     /// Determine the stacks node current epoch
-    fn get_node_epoch(&self) -> Result<StacksEpochId, ClientError> {
+    pub fn get_node_epoch(&self) -> Result<StacksEpochId, ClientError> {
         let pox_info = self.get_pox_data()?;
         let burn_block_height = self.get_burn_block_height()?;
 
@@ -312,8 +253,8 @@ impl StacksClient {
         Ok(account_entry.nonce)
     }
 
-    // Helper function to retrieve the peer info data from the stacks node
-    fn get_peer_info(&self) -> Result<RPCPeerInfoData, ClientError> {
+    /// Get the current peer info data from the stacks node
+    pub fn get_peer_info(&self) -> Result<RPCPeerInfoData, ClientError> {
         debug!("Getting stacks node info...");
         let send_request = || {
             self.stacks_node_client
@@ -356,27 +297,6 @@ impl StacksClient {
         Ok(round)
     }
 
-    /// Get whether the reward set has been determined for the provided reward cycle.
-    /// i.e the node has passed the first block of the new reward cycle's prepare phase
-    pub fn reward_set_calculated(&self, reward_cycle: u64) -> Result<bool, ClientError> {
-        let pox_info = self.get_pox_data()?;
-        let current_reward_cycle = pox_info.reward_cycle_id;
-        if current_reward_cycle >= reward_cycle {
-            // We have already entered into this reward cycle or beyond
-            // therefore the reward set has already been calculated
-            debug!("Reward set has already been calculated for reward cycle {reward_cycle}.");
-            return Ok(true);
-        }
-        if current_reward_cycle.wrapping_add(1) != reward_cycle {
-            // We are not in the prepare phase of the reward cycle as the upcoming cycle nor are we in the current reward cycle...
-            debug!("Reward set has not been calculated for reward cycle {reward_cycle}. We are not in the requested reward cycle yet.");
-            return Ok(false);
-        }
-        let burn_block_height = self.get_burn_block_height()?;
-        // Have we passed the first block of the new reward cycle's prepare phase?
-        Ok(pox_info.next_cycle.prepare_phase_start_block_height < burn_block_height)
-    }
-
     /// Get the reward set from the stacks node for the given reward cycle
     pub fn get_reward_set(&self, reward_cycle: u64) -> Result<RewardSet, ClientError> {
         debug!("Getting reward set for reward cycle {reward_cycle}...");
@@ -401,10 +321,7 @@ impl StacksClient {
         reward_cycle: u64,
     ) -> Result<Option<RegisteredSignersInfo>, ClientError> {
         debug!("Getting registered signers for reward cycle {reward_cycle}...");
-        let Ok(reward_set) = self.get_reward_set(reward_cycle) else {
-            warn!("No reward set found for reward cycle {reward_cycle}.");
-            return Ok(None);
-        };
+        let reward_set = self.get_reward_set(reward_cycle)?;
         let Some(reward_set_signers) = reward_set.signers else {
             warn!("No reward set signers found for reward cycle {reward_cycle}.");
             return Ok(None);
@@ -494,8 +411,8 @@ impl StacksClient {
         }))
     }
 
-    // Helper function to retrieve the pox data from the stacks node
-    fn get_pox_data(&self) -> Result<RPCPoxInfoData, ClientError> {
+    /// Retreive the current pox data from the stacks node
+    pub fn get_pox_data(&self) -> Result<RPCPoxInfoData, ClientError> {
         debug!("Getting pox data...");
         let send_request = || {
             self.stacks_node_client
@@ -772,8 +689,7 @@ mod tests {
     use serial_test::serial;
     use stacks_common::bitvec::BitVec;
     use stacks_common::consts::{CHAIN_ID_TESTNET, SIGNER_SLOTS_PER_USER};
-    use stacks_common::types::chainstate::{StacksBlockId, TrieHash};
-    use stacks_common::types::StacksEpochId;
+    use stacks_common::types::chainstate::{ConsensusHash, StacksBlockId, TrieHash};
     use stacks_common::util::hash::Sha512Trunc256Sum;
     use stacks_common::util::secp256k1::MessageSignature;
     use wsts::curve::scalar::Scalar;
@@ -782,8 +698,7 @@ mod tests {
     use crate::client::tests::{
         build_account_nonce_response, build_get_approved_aggregate_key_response,
         build_get_last_round_response, build_get_peer_info_response, build_get_pox_data_response,
-        build_read_only_response, generate_random_consensus_hash, generate_signer_config,
-        write_response, MockServerClient,
+        build_read_only_response, write_response, MockServerClient,
     };
 
     #[test]
@@ -1061,27 +976,6 @@ mod tests {
         assert!(h.join().unwrap().is_ok());
     }
 
-    #[test]
-    fn core_info_call_for_consensus_hash_should_succeed() {
-        let mock = MockServerClient::new();
-        let h = spawn(move || mock.client.get_pox_consenus_hash());
-        let (response, peer_info) = build_get_peer_info_response(None, None);
-        write_response(mock.server, response.as_bytes());
-        let consensus_hash = h.join().unwrap().expect("Failed to deserialize response");
-        assert_eq!(consensus_hash, peer_info.pox_consensus);
-    }
-
-    #[test]
-    fn core_info_call_with_invalid_response_should_fail() {
-        let mock = MockServerClient::new();
-        let h = spawn(move || mock.client.get_pox_consenus_hash());
-        write_response(
-            mock.server,
-            b"HTTP/1.1 200 OK\n\n4e99f99bc4a05437abb8c7d0c306618f45b203196498e2ebe287f10497124958",
-        );
-        assert!(h.join().unwrap().is_err());
-    }
-
     #[test]
     fn core_info_call_for_burn_block_height_should_succeed() {
         let mock = MockServerClient::new();
@@ -1331,69 +1225,85 @@ mod tests {
         assert_eq!(h.join().unwrap().unwrap(), stacker_set);
     }
 
-    #[test]
-    #[serial]
-    fn get_reward_set_calculated() {
-        // Should return TRUE as the passed in reward cycle is older than the current reward cycle of the node
-        let mock = MockServerClient::new();
-        let reward_cycle = 10;
-        let pox_response = build_get_pox_data_response(Some(reward_cycle), None, None, None).0;
-        let h = spawn(move || {
-            mock.client
-                .reward_set_calculated(reward_cycle.saturating_sub(1))
-        });
-        write_response(mock.server, pox_response.as_bytes());
-        assert!(h.join().unwrap().unwrap());
-
-        // Should return TRUE as the passed in reward cycle is the same as the current reward cycle
-        let mock = MockServerClient::from_config(mock.config);
-        let pox_response = build_get_pox_data_response(Some(reward_cycle), None, None, None).0;
-        let h = spawn(move || mock.client.reward_set_calculated(reward_cycle));
-        write_response(mock.server, pox_response.as_bytes());
-        assert!(h.join().unwrap().unwrap());
-
-        // Should return TRUE as the passed in reward cycle is the NEXT reward cycle AND the prepare phase is in its SECOND block
-        let mock = MockServerClient::from_config(mock.config);
-        let prepare_phase_start = 10;
-        let pox_response =
-            build_get_pox_data_response(Some(reward_cycle), Some(prepare_phase_start), None, None)
-                .0;
-        let peer_response =
-            build_get_peer_info_response(Some(prepare_phase_start.saturating_add(1)), None).0;
-        let h = spawn(move || {
-            mock.client
-                .reward_set_calculated(reward_cycle.saturating_add(1))
-        });
-        write_response(mock.server, pox_response.as_bytes());
-        let mock = MockServerClient::from_config(mock.config);
-        write_response(mock.server, peer_response.as_bytes());
-        assert!(h.join().unwrap().unwrap());
-
-        // Should return FALSE as the passed in reward cycle is NEWER than the NEXT reward cycle of the node
-        let mock = MockServerClient::from_config(mock.config);
-        let pox_response = build_get_pox_data_response(Some(reward_cycle), None, None, None).0;
-        let h = spawn(move || {
-            mock.client
-                .reward_set_calculated(reward_cycle.saturating_add(2))
-        });
-        write_response(mock.server, pox_response.as_bytes());
-        assert!(!h.join().unwrap().unwrap());
-
-        // Should return FALSE as the passed in reward cycle is the NEXT reward cycle BUT the prepare phase is in its FIRST block
-        let mock = MockServerClient::from_config(mock.config);
-        let pox_response =
-            build_get_pox_data_response(Some(reward_cycle), Some(prepare_phase_start), None, None)
-                .0;
-        let peer_response = build_get_peer_info_response(Some(prepare_phase_start), None).0;
-        let h = spawn(move || {
-            mock.client
-                .reward_set_calculated(reward_cycle.saturating_add(1))
-        });
-        write_response(mock.server, pox_response.as_bytes());
-        let mock = MockServerClient::from_config(mock.config);
-        write_response(mock.server, peer_response.as_bytes());
-        assert!(!h.join().unwrap().unwrap());
-    }
+    // #[test]
+    // #[serial]
+    // fn get_reward_set_calculated() {
+    //     // Should return TRUE as the passed in reward cycle is older than the current reward cycle of the node
+    //     let mock = MockServerClient::new();
+    //     let reward_cycle = 10;
+    //     let pox_response = build_get_pox_data_response(Some(reward_cycle), None, None, None).0;
+    //     let h = spawn(move || {
+    //         mock.client
+    //             .reward_set_calculated(reward_cycle.saturating_sub(1))
+    //     });
+    //     write_response(mock.server, pox_response.as_bytes());
+    //     assert!(h.join().unwrap().unwrap());
+
+    //     // Should return TRUE as the passed in reward cycle is the same as the current reward cycle
+    //     let mock = MockServerClient::from_config(mock.config);
+    //     let pox_response = build_get_pox_data_response(Some(reward_cycle), None, None, None).0;
+    //     let h = spawn(move || mock.client.reward_set_calculated(reward_cycle));
+    //     write_response(mock.server, pox_response.as_bytes());
+    //     assert!(h.join().unwrap().unwrap());
+
+    //     // Should return TRUE as the passed in reward cycle is the NEXT reward cycle AND the prepare phase is in its SECOND block
+    //     let mock = MockServerClient::from_config(mock.config);
+    //     let prepare_phase_start = 10;
+    //     let pox_response =
+    //         build_get_pox_data_response(Some(reward_cycle), Some(prepare_phase_start), None, None)
+    //             .0;
+    //     let peer_response =
+    //         build_get_peer_info_response(Some(prepare_phase_start.saturating_add(2)), None).0;
+    //     let h = spawn(move || {
+    //         mock.client
+    //             .reward_set_calculated(reward_cycle.saturating_add(1))
+    //     });
+    //     write_response(mock.server, pox_response.as_bytes());
+    //     let mock = MockServerClient::from_config(mock.config);
+    //     write_response(mock.server, peer_response.as_bytes());
+    //     assert!(h.join().unwrap().unwrap());
+
+    //     // Should return FALSE as the passed in reward cycle is NEWER than the NEXT reward cycle of the node
+    //     let mock = MockServerClient::from_config(mock.config);
+    //     let pox_response = build_get_pox_data_response(Some(reward_cycle), None, None, None).0;
+    //     let h = spawn(move || {
+    //         mock.client
+    //             .reward_set_calculated(reward_cycle.saturating_add(2))
+    //     });
+    //     write_response(mock.server, pox_response.as_bytes());
+    //     assert!(!h.join().unwrap().unwrap());
+
+    //     // Should return FALSE as the passed in reward cycle is the NEXT reward cycle BUT in the prepare phase start block
+    //     let mock = MockServerClient::from_config(mock.config);
+    //     let pox_response =
+    //         build_get_pox_data_response(Some(reward_cycle), Some(prepare_phase_start), None, None)
+    //             .0;
+    //     let peer_response = build_get_peer_info_response(Some(prepare_phase_start), None).0;
+    //     let h = spawn(move || {
+    //         mock.client
+    //             .reward_set_calculated(reward_cycle.saturating_add(1))
+    //     });
+    //     write_response(mock.server, pox_response.as_bytes());
+    //     let mock = MockServerClient::from_config(mock.config);
+    //     write_response(mock.server, peer_response.as_bytes());
+    //     assert!(!h.join().unwrap().unwrap());
+
+    //     // Should return FALSE as the passed in reward cycle is the NEXT reward cycle BUT in the FIRST block of the prepare phase
+    //     let mock = MockServerClient::from_config(mock.config);
+    //     let pox_response =
+    //         build_get_pox_data_response(Some(reward_cycle), Some(prepare_phase_start), None, None)
+    //             .0;
+    //     let peer_response =
+    //         build_get_peer_info_response(Some(prepare_phase_start.saturating_add(1)), None).0;
+    //     let h = spawn(move || {
+    //         mock.client
+    //             .reward_set_calculated(reward_cycle.saturating_add(1))
+    //     });
+    //     write_response(mock.server, pox_response.as_bytes());
+    //     let mock = MockServerClient::from_config(mock.config);
+    //     write_response(mock.server, peer_response.as_bytes());
+    //     assert!(!h.join().unwrap().unwrap());
+    // }
 
     #[test]
     fn get_vote_for_aggregate_public_key_should_succeed() {
@@ -1418,78 +1328,4 @@ mod tests {
         write_response(mock.server, key_response.as_bytes());
         assert_eq!(h.join().unwrap().unwrap(), None);
     }
-
-    #[test]
-    fn calculate_coordinator_different_consensus_hashes_produces_unique_results() {
-        let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
-        let number_of_tests = 5;
-        let generated_public_keys = generate_signer_config(&config, 10, 4000)
-            .0
-            .registered_signers
-            .public_keys;
-        let mut results = Vec::new();
-
-        for _ in 0..number_of_tests {
-            let mock = MockServerClient::new();
-            let response = build_get_peer_info_response(None, None).0;
-            let generated_public_keys = generated_public_keys.clone();
-            let h = spawn(move || {
-                mock.client
-                    .calculate_coordinator_ids(&generated_public_keys)
-            });
-            write_response(mock.server, response.as_bytes());
-            let result = h.join().unwrap();
-            results.push(result);
-        }
-
-        // Check that not all coordinator IDs are the same
-        let all_ids_same = results.iter().all(|ids| ids == &results[0]);
-        assert!(!all_ids_same, "Not all coordinator IDs should be the same");
-    }
-
-    fn generate_calculate_coordinator_test_results(
-        random_consensus: bool,
-        count: usize,
-    ) -> Vec<Vec<u32>> {
-        let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
-        let mut results = Vec::new();
-        let same_hash = generate_random_consensus_hash();
-        let hash = if random_consensus {
-            None
-        } else {
-            Some(same_hash)
-        };
-        let generated_public_keys = generate_signer_config(&config, 10, 4000)
-            .0
-            .registered_signers
-            .public_keys;
-        for _ in 0..count {
-            let mock = MockServerClient::new();
-            let generated_public_keys = generated_public_keys.clone();
-            let response = build_get_peer_info_response(None, hash).0;
-            let h = spawn(move || {
-                mock.client
-                    .calculate_coordinator_ids(&generated_public_keys)
-            });
-            write_response(mock.server, response.as_bytes());
-            let result = h.join().unwrap();
-            results.push(result);
-        }
-        results
-    }
-
-    #[test]
-    fn calculate_coordinator_results_should_vary_or_match_based_on_hash() {
-        let results_with_random_hash = generate_calculate_coordinator_test_results(true, 5);
-        let all_ids_same = results_with_random_hash
-            .iter()
-            .all(|ids| ids == &results_with_random_hash[0]);
-        assert!(!all_ids_same, "Not all coordinator IDs should be the same");
-
-        let results_with_static_hash = generate_calculate_coordinator_test_results(false, 5);
-        let all_ids_same = results_with_static_hash
-            .iter()
-            .all(|ids| ids == &results_with_static_hash[0]);
-        assert!(all_ids_same, "All coordinator IDs should be the same");
-    }
 }
diff --git a/stacks-signer/src/config.rs b/stacks-signer/src/config.rs
index 84a96b0800..c85f72d932 100644
--- a/stacks-signer/src/config.rs
+++ b/stacks-signer/src/config.rs
@@ -142,8 +142,6 @@ pub struct SignerConfig {
     pub key_ids: Vec<u32>,
     /// The registered signers for this reward cycle
     pub registered_signers: RegisteredSignersInfo,
-    /// The initial coordinator ids for the coordinator selector
-    pub coordinator_ids: Vec<u32>,
     /// The Scalar representation of the private key for signer communication
     pub ecdsa_private_key: Scalar,
     /// The private key for this signer
diff --git a/stacks-signer/src/coordinator.rs b/stacks-signer/src/coordinator.rs
index 7e5f4877e3..5762b81915 100644
--- a/stacks-signer/src/coordinator.rs
+++ b/stacks-signer/src/coordinator.rs
@@ -16,11 +16,14 @@
 
 use std::time::Instant;
 
+use blockstack_lib::chainstate::burn::ConsensusHashExtensions;
+use slog::slog_debug;
+use stacks_common::debug;
+use stacks_common::types::chainstate::ConsensusHash;
+use stacks_common::util::hash::Sha256Sum;
 use wsts::curve::ecdsa;
 use wsts::state_machine::PublicKeys;
 
-use crate::client::StacksClient;
-
 /// TODO: test this value and adjust as necessary. Maybe make configurable?
 pub const COORDINATOR_OPERATION_TIMEOUT_SECS: u64 = 300;
 
@@ -44,9 +47,11 @@ pub struct CoordinatorSelector {
     public_keys: PublicKeys,
 }
 
-impl CoordinatorSelector {
-    /// Create a new Coordinator selector from the given list of public keys and initial coordinator ids
-    pub fn new(coordinator_ids: Vec<u32>, public_keys: PublicKeys) -> Self {
+impl From<PublicKeys> for CoordinatorSelector {
+    /// Create a new Coordinator selector from the given list of public keys
+    fn from(public_keys: PublicKeys) -> Self {
+        let coordinator_ids =
+            CoordinatorSelector::calculate_coordinator_ids(&public_keys, &ConsensusHash::empty());
         let coordinator_id = *coordinator_ids
             .first()
             .expect("FATAL: No registered signers");
@@ -62,7 +67,9 @@ impl CoordinatorSelector {
             public_keys,
         }
     }
+}
 
+impl CoordinatorSelector {
     /// Update the coordinator id
     fn update_coordinator(&mut self, new_coordinator_ids: Vec<u32>) {
         self.last_message_time = None;
@@ -99,8 +106,9 @@ impl CoordinatorSelector {
 
     /// Check the coordinator timeouts and update the selected coordinator accordingly
     /// Returns the resulting coordinator ID. (Note: it may be unchanged)
-    pub fn refresh_coordinator(&mut self, stacks_client: &StacksClient) -> u32 {
-        let new_coordinator_ids = stacks_client.calculate_coordinator_ids(&self.public_keys);
+    pub fn refresh_coordinator(&mut self, pox_consensus_hash: &ConsensusHash) -> u32 {
+        let new_coordinator_ids =
+            Self::calculate_coordinator_ids(&self.public_keys, pox_consensus_hash);
         if let Some(time) = self.last_message_time {
             if time.elapsed().as_secs() > COORDINATOR_OPERATION_TIMEOUT_SECS {
                 // We have not received a message in a while from this coordinator.
@@ -127,4 +135,98 @@ impl CoordinatorSelector {
                 .expect("FATAL: missing public key for selected coordinator id"),
         )
     }
+
+    /// Calculate the ordered list of coordinator ids by comparing the provided public keys against the pox consensus hash
+    pub fn calculate_coordinator_ids(
+        public_keys: &PublicKeys,
+        pox_consensus_hash: &ConsensusHash,
+    ) -> Vec<u32> {
+        debug!("Using pox_consensus_hash {pox_consensus_hash:?} for selecting coordinator");
+        // Create combined hash of each signer's public key with pox_consensus_hash
+        let mut selection_ids = public_keys
+            .signers
+            .iter()
+            .map(|(&id, pk)| {
+                let pk_bytes = pk.to_bytes();
+                let mut buffer =
+                    Vec::with_capacity(pk_bytes.len() + pox_consensus_hash.as_bytes().len());
+                buffer.extend_from_slice(&pk_bytes[..]);
+                buffer.extend_from_slice(pox_consensus_hash.as_bytes());
+                let digest = Sha256Sum::from_data(&buffer).as_bytes().to_vec();
+                (id, digest)
+            })
+            .collect::<Vec<_>>();
+
+        // Sort the selection IDs based on the hash
+        selection_ids.sort_by_key(|(_, hash)| hash.clone());
+        // Return only the ids
+        selection_ids.iter().map(|(id, _)| *id).collect()
+    }
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::client::tests::{generate_random_consensus_hash, generate_signer_config};
+    use crate::config::GlobalConfig;
+
+    #[test]
+    fn calculate_coordinator_different_consensus_hashes_produces_unique_results() {
+        let number_of_tests = 5;
+        let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
+        let public_keys = generate_signer_config(&config, 10, 4000)
+            .0
+            .registered_signers
+            .public_keys;
+        let mut results = Vec::new();
+
+        for _ in 0..number_of_tests {
+            let result = CoordinatorSelector::calculate_coordinator_ids(
+                &public_keys,
+                &generate_random_consensus_hash(),
+            );
+            results.push(result);
+        }
+
+        // Check that not all coordinator IDs are the same
+        let all_ids_same = results.iter().all(|ids| ids == &results[0]);
+        assert!(!all_ids_same, "Not all coordinator IDs should be the same");
+    }
+
+    fn generate_calculate_coordinator_test_results(
+        random_consensus: bool,
+        count: usize,
+    ) -> Vec<Vec<u32>> {
+        let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
+        let public_keys = generate_signer_config(&config, 10, 4000)
+            .0
+            .registered_signers
+            .public_keys;
+        let mut results = Vec::new();
+        let same_hash = generate_random_consensus_hash();
+        for _ in 0..count {
+            let hash = if random_consensus {
+                generate_random_consensus_hash()
+            } else {
+                same_hash
+            };
+            let result = CoordinatorSelector::calculate_coordinator_ids(&public_keys, &hash);
+            results.push(result);
+        }
+        results
+    }
+
+    #[test]
+    fn calculate_coordinator_results_should_vary_or_match_based_on_hash() {
+        let results_with_random_hash = generate_calculate_coordinator_test_results(true, 5);
+        let all_ids_same = results_with_random_hash
+            .iter()
+            .all(|ids| ids == &results_with_random_hash[0]);
+        assert!(!all_ids_same, "Not all coordinator IDs should be the same");
+
+        let results_with_static_hash = generate_calculate_coordinator_test_results(false, 5);
+        let all_ids_same = results_with_static_hash
+            .iter()
+            .all(|ids| ids == &results_with_static_hash[0]);
+        assert!(all_ids_same, "All coordinator IDs should be the same");
+    }
 }
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index e0be3aef04..84ae08a202 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -16,9 +16,11 @@
 use std::sync::mpsc::Sender;
 use std::time::Duration;
 
+use blockstack_lib::chainstate::burn::ConsensusHashExtensions;
 use hashbrown::HashMap;
 use libsigner::{SignerEvent, SignerRunLoop};
 use slog::{slog_debug, slog_error, slog_info, slog_warn};
+use stacks_common::types::chainstate::ConsensusHash;
 use stacks_common::{debug, error, info, warn};
 use wsts::state_machine::coordinator::State as CoordinatorState;
 use wsts::state_machine::OperationResult;
@@ -73,26 +75,16 @@ impl From<GlobalConfig> for RunLoop {
 
 impl RunLoop {
     /// Get a signer configuration for a specific reward cycle from the stacks node
-    fn get_signer_config(
-        &mut self,
-        reward_cycle: u64,
-    ) -> Result<Option<SignerConfig>, ClientError> {
-        let reward_set_calculated = self.stacks_client.reward_set_calculated(reward_cycle)?;
-        if !reward_set_calculated {
-            // Must weight for the reward set calculation to complete
-            // Accounts for Pre nakamoto by simply using the second block of a prepare phase as the criteria
-            return Err(ClientError::RewardSetNotYetCalculated(reward_cycle));
-        }
-        // We can only register for a reward cycle if a reward set exists. We know that it should exist due to our earlier check for reward_set_calculated
-        let Some(registered_signers) = self
+    fn get_signer_config(&mut self, reward_cycle: u64) -> Option<SignerConfig> {
+        // We can only register for a reward cycle if a reward set exists.
+        let registered_signers = self
             .stacks_client
-            .get_registered_signers_info(reward_cycle)?
-        else {
-            warn!(
-                "Failed to retrieve registered signers info for reward cycle {reward_cycle}. Must not be a valid Nakamoto reward cycle."
-            );
-            return Ok(None);
-        };
+            .get_registered_signers_info(reward_cycle).map_err(|e| {
+                error!(
+                    "Failed to retrieve registered signers info for reward cycle {reward_cycle}: {e}"
+                );
+                e
+            }).ok()??;
 
         let current_addr = self.stacks_client.get_signer_address();
 
@@ -100,13 +92,13 @@ impl RunLoop {
             warn!(
                     "Signer {current_addr} was not found in stacker db. Must not be registered for this reward cycle {reward_cycle}."
                 );
-            return Ok(None);
+            return None;
         };
         let Some(signer_id) = registered_signers.signer_ids.get(current_addr) else {
             warn!(
                 "Signer {current_addr} was found in stacker db but not the reward set for reward cycle {reward_cycle}."
             );
-            return Ok(None);
+            return None;
         };
         info!(
             "Signer #{signer_id} ({current_addr}) is registered for reward cycle {reward_cycle}."
@@ -116,16 +108,12 @@ impl RunLoop {
             .get(signer_id)
             .cloned()
             .unwrap_or_default();
-        let coordinator_ids = self
-            .stacks_client
-            .calculate_coordinator_ids(&registered_signers.public_keys);
-        Ok(Some(SignerConfig {
+        Some(SignerConfig {
             reward_cycle,
             signer_id: *signer_id,
             signer_slot_id: *signer_slot_id,
             key_ids,
             registered_signers,
-            coordinator_ids,
             ecdsa_private_key: self.config.ecdsa_private_key,
             stacks_private_key: self.config.stacks_private_key,
             node_host: self.config.node_host,
@@ -136,18 +124,18 @@ impl RunLoop {
             nonce_timeout: self.config.nonce_timeout,
             sign_timeout: self.config.sign_timeout,
             tx_fee_ms: self.config.tx_fee_ms,
-        }))
+        })
     }
 
     /// Refresh signer configuration for a specific reward cycle
-    fn refresh_signer_config(&mut self, reward_cycle: u64) -> Result<(), ClientError> {
+    fn refresh_signer_config(&mut self, reward_cycle: u64) {
         let reward_index = reward_cycle % 2;
         let mut needs_refresh = false;
-        if let Some(stacks_signer) = self.stacks_signers.get_mut(&reward_index) {
-            let old_reward_cycle = stacks_signer.reward_cycle();
+        if let Some(signer) = self.stacks_signers.get_mut(&reward_index) {
+            let old_reward_cycle = signer.reward_cycle;
             if old_reward_cycle == reward_cycle {
                 //If the signer is already registered for the reward cycle, we don't need to do anything further here
-                debug!("Signer is already configured for reward cycle {reward_cycle}. No need to update it's state machines.")
+                debug!("Signer is configured for reward cycle {reward_cycle}.")
             } else {
                 needs_refresh = true;
             }
@@ -155,79 +143,71 @@ impl RunLoop {
             needs_refresh = true;
         };
         if needs_refresh {
-            let new_signer_config = self.get_signer_config(reward_cycle)?;
-            if let Some(new_signer_config) = new_signer_config {
+            if let Some(new_signer_config) = self.get_signer_config(reward_cycle) {
                 let signer_id = new_signer_config.signer_id;
                 debug!("Signer is registered for reward cycle {reward_cycle} as signer #{signer_id}. Initializing signer state.");
+                let prior_reward_cycle = reward_cycle.saturating_sub(1);
+                let prior_reward_set = prior_reward_cycle % 2;
+                if let Some(signer) = self.stacks_signers.get_mut(&prior_reward_set) {
+                    if signer.reward_cycle == prior_reward_cycle {
+                        // The signers have been calculated for the next reward cycle. Update the current one
+                        debug!("Signer #{}: Reward cycle ({reward_cycle}) signer set calculated. Updating prior reward cycle ({prior_reward_cycle}) signer.", signer.signer_id);
+                        signer.next_signer_ids = new_signer_config
+                            .registered_signers
+                            .signer_ids
+                            .values()
+                            .copied()
+                            .collect();
+                        signer.next_signer_slot_ids =
+                            new_signer_config.registered_signers.signer_slot_ids.clone();
+                    }
+                }
                 self.stacks_signers
                     .insert(reward_index, Signer::from(new_signer_config));
                 debug!("Signer #{signer_id} for reward cycle {reward_cycle} initialized. Initialized {} signers", self.stacks_signers.len());
             } else {
-                // Nothing to initialize. Signer is not registered for this reward cycle
-                debug!("Signer is not registered for reward cycle {reward_cycle}. Nothing to initialize.");
-                self.stacks_signers
-                    .insert(reward_index, Signer::from(reward_cycle));
+                warn!("Signer is not registered for reward cycle {reward_cycle}. Waiting for confirmed registration...");
             }
         }
-        Ok(())
     }
 
     /// Refresh the signer configuration by retrieving the necessary information from the stacks node
     /// Note: this will trigger DKG if required
-    fn refresh_signers_with_retry(&mut self, current_reward_cycle: u64) -> Result<(), ClientError> {
+    fn refresh_signers(&mut self, current_reward_cycle: u64) -> Result<(), ClientError> {
         let next_reward_cycle = current_reward_cycle.saturating_add(1);
-        retry_with_exponential_backoff(|| {
-            if let Err(e) = self.refresh_signer_config(current_reward_cycle) {
-                match e {
-                    ClientError::NotRegistered => {
-                        debug!("Signer is NOT registered for the current reward cycle {current_reward_cycle}.");
-                    }
-                    ClientError::RewardSetNotYetCalculated(_) => {
-                        debug!("Current reward cycle {current_reward_cycle} reward set is not yet calculated. Let's retry...");
-                        return Err(backoff::Error::transient(e));
-                    }
-                    _ => return Err(backoff::Error::transient(e)),
-                }
-            }
-            if let Err(e) = self.refresh_signer_config(next_reward_cycle) {
-                match e {
-                    ClientError::NotRegistered => {
-                        debug!("Signer is NOT registered for the next reward cycle {next_reward_cycle}.");
-                    }
-                    ClientError::RewardSetNotYetCalculated(_) => {
-                        debug!("Next reward cycle {next_reward_cycle} reward set is not yet calculated.");
-                    }
-                    _ => return Err(backoff::Error::transient(e)),
-                }
-            }
-            for stacks_signer in self.stacks_signers.values_mut() {
-                if let Signer::Registered(signer) = stacks_signer {
-                    let old_coordinator_id = signer.coordinator_selector.get_coordinator().0;
-                    let updated_coordinator_id = signer
-                        .coordinator_selector
-                        .refresh_coordinator(&self.stacks_client);
-                    if old_coordinator_id != updated_coordinator_id {
-                        debug!(
-                            "Signer #{}: Coordinator has switched from {old_coordinator_id} to {updated_coordinator_id}. Resetting state to Idle.",
-                            signer.signer_id
-                        );
-                        signer.coordinator.state = CoordinatorState::Idle;
-                        signer.state = SignerState::Idle;
-                    }
-                    signer
-                        .update_dkg(&self.stacks_client, current_reward_cycle)
-                        .map_err(backoff::Error::transient)?;
-                }
-            }
-            if self.stacks_signers.is_empty() {
-                info!("Signer is not registered for the current {current_reward_cycle} or next {next_reward_cycle} reward cycles. Waiting for confirmed registration...");
-                return Err(backoff::Error::transient(ClientError::NotRegistered));
-            } else {
-                info!("Runloop successfully initialized!");
+        self.refresh_signer_config(current_reward_cycle);
+        self.refresh_signer_config(next_reward_cycle);
+        // TODO: do not use an empty consensus hash
+        let pox_consensus_hash = ConsensusHash::empty();
+        for signer in self.stacks_signers.values_mut() {
+            let old_coordinator_id = signer.coordinator_selector.get_coordinator().0;
+            let updated_coordinator_id = signer
+                .coordinator_selector
+                .refresh_coordinator(&pox_consensus_hash);
+            if old_coordinator_id != updated_coordinator_id {
+                debug!(
+                    "Signer #{}: Coordinator updated. Resetting state to Idle.", signer.signer_id;
+                    "old_coordinator_id" => {old_coordinator_id},
+                    "updated_coordinator_id" => {updated_coordinator_id},
+                    "pox_consensus_hash" => %pox_consensus_hash
+                );
+                signer.coordinator.state = CoordinatorState::Idle;
+                signer.state = SignerState::Idle;
             }
-            self.state = State::Initialized;
-            Ok(())
-        })
+            retry_with_exponential_backoff(|| {
+                signer
+                    .update_dkg(&self.stacks_client, current_reward_cycle)
+                    .map_err(backoff::Error::transient)
+            })?;
+        }
+        if self.stacks_signers.is_empty() {
+            info!("Signer is not registered for the current {current_reward_cycle} or next {next_reward_cycle} reward cycles. Waiting for confirmed registration...");
+            self.state = State::Uninitialized;
+            return Err(ClientError::NotRegistered);
+        }
+        self.state = State::Initialized;
+        info!("Runloop successfully initialized!");
+        Ok(())
     }
 }
 
@@ -258,27 +238,24 @@ impl SignerRunLoop<Vec<OperationResult>, RunLoopCommand> for RunLoop {
             error!("Failed to retrieve current reward cycle. Ignoring event: {event:?}");
             return None;
         };
-        if let Err(e) = self.refresh_signers_with_retry(current_reward_cycle) {
+        if let Err(e) = self.refresh_signers(current_reward_cycle) {
             if self.state == State::Uninitialized {
                 // If we were never actually initialized, we cannot process anything. Just return.
-                error!("Failed to initialize signers. Are you sure this signer is correctly registered for the current or next reward cycle?");
+                warn!("Failed to initialize signers. Are you sure this signer is correctly registered for the current or next reward cycle?");
                 warn!("Ignoring event: {event:?}");
                 return None;
-            } else {
-                error!("Failed to refresh signers: {e}. Signer may have an outdated view of the network. Attempting to process event anyway.");
             }
+            error!("Failed to refresh signers: {e}. Signer may have an outdated view of the network. Attempting to process event anyway.");
         }
         if let Some(command) = cmd {
             let reward_cycle = command.reward_cycle;
-            if let Some(stacks_signer) = self.stacks_signers.get_mut(&(reward_cycle % 2)) {
-                match stacks_signer {
-                    Signer::Registered(signer) => {
-                        if signer.reward_cycle != reward_cycle {
-                            warn!(
+            if let Some(signer) = self.stacks_signers.get_mut(&(reward_cycle % 2)) {
+                if signer.reward_cycle != reward_cycle {
+                    warn!(
                         "Signer #{}: not registered for reward cycle {reward_cycle}. Ignoring command: {command:?}", signer.signer_id
                     );
-                        } else {
-                            info!(
+                } else {
+                    info!(
                         "Signer #{}: Queuing an external runloop command ({:?}): {command:?}",
                         signer.signer_id,
                         signer
@@ -287,15 +264,7 @@ impl SignerRunLoop<Vec<OperationResult>, RunLoopCommand> for RunLoop {
                             .signers
                             .get(&signer.signer_id)
                     );
-                            signer.commands.push_back(command.command);
-                        }
-                    }
-                    Signer::Unregistered(_) => {
-                        warn!(
-                            "Signer: not registered for reward cycle {reward_cycle}. Ignoring command: {command:?}"
-                        );
-                        return None;
-                    }
+                    signer.commands.push_back(command.command);
                 }
             } else {
                 warn!(
@@ -303,29 +272,20 @@ impl SignerRunLoop<Vec<OperationResult>, RunLoopCommand> for RunLoop {
                 );
             }
         }
-        for stacks_signer in self.stacks_signers.values_mut() {
-            match stacks_signer {
-                Signer::Registered(signer) => {
-                    if let Err(e) = signer.process_event(
-                        &self.stacks_client,
-                        event.as_ref(),
-                        res.clone(),
-                        current_reward_cycle,
-                    ) {
-                        error!(
-                            "Signer #{} for reward cycle {} errored processing event: {e}",
-                            signer.signer_id, signer.reward_cycle
-                        );
-                    }
-                    // After processing event, run the next command for each signer
-                    signer.process_next_command(&self.stacks_client);
-                }
-                Signer::Unregistered(_) => {
-                    warn!(
-                        "Signer is not registered for any reward cycle. Ignoring event: {event:?}"
-                    );
-                }
+        for signer in self.stacks_signers.values_mut() {
+            if let Err(e) = signer.process_event(
+                &self.stacks_client,
+                event.as_ref(),
+                res.clone(),
+                current_reward_cycle,
+            ) {
+                error!(
+                    "Signer #{} for reward cycle {} errored processing event: {e}",
+                    signer.signer_id, signer.reward_cycle
+                );
             }
+            // After processing event, run the next command for each signer
+            signer.process_next_command(&self.stacks_client);
         }
         None
     }
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index 3390e7d785..aa916993fc 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -111,64 +111,9 @@ pub enum State {
     /// The signer is executing a DKG or Sign round
     OperationInProgress,
 }
-/// The stacks signer for a reward cycle
-pub enum Signer {
-    /// A registered signer
-    Registered(RegisteredSigner),
-    /// An unregistered signer
-    Unregistered(UnregisteredSigner),
-}
-
-impl Signer {
-    /// Get the reward cycle of the internal signer
-    pub fn reward_cycle(&self) -> u64 {
-        match self {
-            Self::Registered(signer) => signer.reward_cycle,
-            Self::Unregistered(signer) => signer.reward_cycle,
-        }
-    }
-
-    /// Get the state of the internal signer
-    pub fn state(&self) -> State {
-        match self {
-            Self::Registered(signer) => signer.state.clone(),
-            Self::Unregistered(signer) => signer.state.clone(),
-        }
-    }
-}
-
-/// The stacks signer unregistered for the reward cycle
-pub struct UnregisteredSigner {
-    /// The reward cycle this signer belongs to
-    pub reward_cycle: u64,
-    /// the state of the signer (Can only be Idle)
-    pub state: State,
-}
-
-impl UnregisteredSigner {
-    /// Create a new signer which is not registered for the reward cycle
-    pub fn new(reward_cycle: u64) -> Self {
-        Self {
-            reward_cycle,
-            state: State::Idle,
-        }
-    }
-}
-
-impl From<SignerConfig> for Signer {
-    fn from(signer_config: SignerConfig) -> Self {
-        Self::Registered(RegisteredSigner::from(signer_config))
-    }
-}
-
-impl From<u64> for Signer {
-    fn from(reward_cycle: u64) -> Self {
-        Self::Unregistered(UnregisteredSigner::new(reward_cycle))
-    }
-}
 
 /// The stacks signer registered for the reward cycle
-pub struct RegisteredSigner {
+pub struct Signer {
     /// The coordinator for inbound messages for a specific reward cycle
     pub coordinator: FireCoordinator<v2::Aggregator>,
     /// The signing round used to sign messages for a specific reward cycle
@@ -186,10 +131,14 @@ pub struct RegisteredSigner {
     pub mainnet: bool,
     /// The signer id
     pub signer_id: u32,
-    /// The addresses of other signers mapped to their signer ID
-    pub signer_ids: HashMap<StacksAddress, u32>,
+    /// The other signer ids for this signer's reward cycle
+    pub signer_ids: Vec<u32>,
     /// The addresses of other signers mapped to their signer slot ID
     pub signer_slot_ids: HashMap<StacksAddress, u32>,
+    /// The other signer ids for the NEXT reward cycle's signers
+    pub next_signer_ids: Vec<u32>,
+    /// The signer addresses mapped to slot ID for the NEXT reward cycle's signers
+    pub next_signer_slot_ids: HashMap<StacksAddress, u32>,
     /// The reward cycle this signer belongs to
     pub reward_cycle: u64,
     /// The tx fee in uSTX to use if the epoch is pre Nakamoto (Epoch 3.0)
@@ -198,7 +147,7 @@ pub struct RegisteredSigner {
     pub coordinator_selector: CoordinatorSelector,
 }
 
-impl From<SignerConfig> for RegisteredSigner {
+impl From<SignerConfig> for Signer {
     fn from(signer_config: SignerConfig) -> Self {
         let stackerdb = StackerDB::from(&signer_config);
 
@@ -234,10 +183,15 @@ impl From<SignerConfig> for RegisteredSigner {
             signer_config.ecdsa_private_key,
             signer_config.registered_signers.public_keys.clone(),
         );
-        let coordinator_selector = CoordinatorSelector::new(
-            signer_config.coordinator_ids,
-            signer_config.registered_signers.public_keys,
+        let coordinator_selector =
+            CoordinatorSelector::from(signer_config.registered_signers.public_keys);
+
+        debug!(
+            "Signer #{}: initial coordinator is signer {}",
+            signer_config.signer_id,
+            coordinator_selector.get_coordinator().0
         );
+
         Self {
             coordinator,
             signing_round,
@@ -247,8 +201,15 @@ impl From<SignerConfig> for RegisteredSigner {
             stackerdb,
             mainnet: signer_config.mainnet,
             signer_id: signer_config.signer_id,
-            signer_ids: signer_config.registered_signers.signer_ids,
+            signer_ids: signer_config
+                .registered_signers
+                .signer_ids
+                .values()
+                .copied()
+                .collect(),
             signer_slot_ids: signer_config.registered_signers.signer_slot_ids,
+            next_signer_ids: vec![],
+            next_signer_slot_ids: HashMap::new(),
             reward_cycle: signer_config.reward_cycle,
             tx_fee_ms: signer_config.tx_fee_ms,
             coordinator_selector,
@@ -256,7 +217,7 @@ impl From<SignerConfig> for RegisteredSigner {
     }
 }
 
-impl RegisteredSigner {
+impl Signer {
     /// Finish an operation and update the coordinator selector accordingly
     fn finish_operation(&mut self) {
         self.state = State::Idle;
@@ -682,15 +643,8 @@ impl RegisteredSigner {
             debug!("Signer #{}: Already have an aggregate key for reward cycle {}. Skipping transaction verification...", self.signer_id, self.reward_cycle);
             return true;
         }
-        let signer_ids = self
-            .signing_round
-            .public_keys
-            .signers
-            .keys()
-            .cloned()
-            .collect::<Vec<_>>();
         if let Ok(expected_transactions) =
-            self.get_filtered_transactions(stacks_client, &signer_ids, current_reward_cycle)
+            self.get_expected_transactions(stacks_client, current_reward_cycle)
         {
             //It might be worth building a hashset of the blocks' txids and checking that against the expected transaction's txid.
             let block_tx_hashset = block.txs.iter().map(|tx| tx.txid()).collect::<HashSet<_>>();
@@ -758,18 +712,19 @@ impl RegisteredSigner {
         }
     }
 
-    /// Verify the transaction is a valid transaction from expected signers
-    /// If it is unable to verify the contents, it wil automatically filter the transaction by default
-    fn verify_signer_transaction(
+    /// Filter out transactions from the stackerdb that are not valid
+    /// i.e. not valid vote-for-aggregate-public-key transactions from registered signers
+    fn filter_invalid_transactions(
         &self,
         stacks_client: &StacksClient,
-        transaction: StacksTransaction,
         current_reward_cycle: u64,
+        signer_slot_ids: &HashMap<StacksAddress, u32>,
+        transaction: StacksTransaction,
     ) -> Option<StacksTransaction> {
         // Filter out transactions that have already been confirmed (can happen if a signer did not update stacker db since the last block was processed)
         let origin_address = transaction.origin_address();
         let origin_nonce = transaction.get_origin_nonce();
-        let Some(origin_signer_id) = self.signer_slot_ids.get(&origin_address) else {
+        let Some(origin_signer_id) = signer_slot_ids.get(&origin_address) else {
             debug!(
                 "Signer #{}: Unrecognized origin address ({origin_address}). Filtering ({}).",
                 self.signer_id,
@@ -868,11 +823,6 @@ impl RegisteredSigner {
             // The signer is attempting to vote for a reward cycle that is not the next reward cycle
             return Ok(false);
         }
-        let reward_set_calculated = stacks_client.reward_set_calculated(next_reward_cycle)?;
-        if !reward_set_calculated {
-            // The signer is attempting to vote for a reward cycle that has not yet had its reward set calculated
-            return Ok(false);
-        }
 
         let vote = stacks_client.get_vote_for_aggregate_public_key(
             round,
@@ -885,29 +835,61 @@ impl RegisteredSigner {
         }
 
         let last_round = stacks_client.get_last_round(reward_cycle)?;
-        // TODO: should this be removed? I just am trying to prevent unecessary clogging of the block space
         // TODO: should we impose a limit on the number of special cased transactions allowed for a single signer at any given time?? In theory only 1 would be required per dkg round i.e. per block
-        if last_round.unwrap_or(0).saturating_add(2) < round {
-            // Do not allow substantially future votes. This is to prevent signers sending a bazillion votes for a future round and clogging the block space
-            // The signer is attempting to vote for a round that is greater than two rounds after the last round
+        if last_round.unwrap_or(0).saturating_add(1) < round {
+            // Do not allow future votes. This is to prevent signers sending a bazillion votes for a future round and clogging the block space
+            // The signer is attempting to vote for a round that is greater than one past the last round
             return Ok(false);
         }
         Ok(true)
     }
 
-    /// Get the filtered transactions for the provided signer ids
-    fn get_filtered_transactions(
+    /// Get this signer's transactions from stackerdb, filtering out any invalid transactions
+    fn get_signer_transactions(
         &mut self,
         stacks_client: &StacksClient,
-        signer_ids: &[u32],
         current_reward_cycle: u64,
     ) -> Result<Vec<StacksTransaction>, ClientError> {
-        let transactions = self
+        let transactions: Vec<_> = self
             .stackerdb
-            .get_signer_transactions_with_retry(signer_ids)?
+            .get_current_transactions_with_retry(self.signer_id)?
             .into_iter()
-            .filter_map(|transaction| {
-                self.verify_signer_transaction(stacks_client, transaction, current_reward_cycle)
+            .filter_map(|tx| {
+                self.filter_invalid_transactions(
+                    stacks_client,
+                    current_reward_cycle,
+                    &self.signer_slot_ids,
+                    tx,
+                )
+            })
+            .collect();
+        Ok(transactions)
+    }
+
+    /// Get the transactions that should be included in the block, filtering out any invalid transactions
+    fn get_expected_transactions(
+        &mut self,
+        stacks_client: &StacksClient,
+        current_reward_cycle: u64,
+    ) -> Result<Vec<StacksTransaction>, ClientError> {
+        if self.next_signer_ids.is_empty() {
+            debug!(
+                "Signer #{}: No next signers. Skipping transaction retrieval.",
+                self.signer_id
+            );
+            return Ok(vec![]);
+        }
+        let transactions: Vec<_> = self
+            .stackerdb
+            .get_next_transactions_with_retry(&self.next_signer_ids)?
+            .into_iter()
+            .filter_map(|tx| {
+                self.filter_invalid_transactions(
+                    stacks_client,
+                    current_reward_cycle,
+                    &self.next_signer_slot_ids,
+                    tx,
+                )
             })
             .collect();
         Ok(transactions)
@@ -1013,9 +995,12 @@ impl RegisteredSigner {
         point: &Point,
         current_reward_cycle: u64,
     ) {
-        let epoch = stacks_client
-            .get_node_epoch_with_retry()
-            .unwrap_or(StacksEpochId::Epoch24);
+        let epoch = retry_with_exponential_backoff(|| {
+            stacks_client
+                .get_node_epoch()
+                .map_err(backoff::Error::transient)
+        })
+        .unwrap_or(StacksEpochId::Epoch24);
         let tx_fee = if epoch != StacksEpochId::Epoch30 {
             debug!(
                 "Signer #{}: in pre Epoch 3.0 cycles, must set a transaction fee for the DKG vote.",
@@ -1067,7 +1052,7 @@ impl RegisteredSigner {
             })
             .unwrap_or(0);
 
-        let current_transactions = self.get_filtered_transactions(stacks_client, &[self.signer_id], current_reward_cycle).map_err(|e| {
+        let current_transactions = self.get_signer_transactions(stacks_client, current_reward_cycle).map_err(|e| {
             warn!("Signer #{}: Failed to get old transactions: {e:?}. Defaulting to account nonce.", self.signer_id);
         }).unwrap_or_default();
 
@@ -1128,7 +1113,7 @@ impl RegisteredSigner {
             );
             vec![]
         } else {
-            let mut new_transactions = self.get_filtered_transactions(stacks_client, &[self.signer_id], current_reward_cycle).map_err(|e| {
+            let mut new_transactions = self.get_signer_transactions(stacks_client, current_reward_cycle).map_err(|e| {
             warn!("Signer #{}: Failed to get old transactions: {e:?}. Potentially overwriting our existing stackerDB transactions", self.signer_id);
         }).unwrap_or_default();
             new_transactions.push(new_transaction);
@@ -1344,7 +1329,7 @@ impl RegisteredSigner {
             );
             // Have I already voted and have a pending transaction? Check stackerdb for the same round number and reward cycle vote transaction
             // TODO: might be better to store these transactions on the side to prevent having to query the stacker db for every signer (only do on initilaization of a new signer for example and then listen for stacker db updates after that)
-            let old_transactions = self.get_filtered_transactions(stacks_client, &[self.signer_id], current_reward_cycle).map_err(|e| {
+            let old_transactions = self.get_signer_transactions(stacks_client, current_reward_cycle).map_err(|e| {
                 warn!("Signer #{}: Failed to get old transactions: {e:?}. Potentially overwriting our existing transactions", self.signer_id);
             }).unwrap_or_default();
             // Check if we have an existing vote transaction for the same round and reward cycle
@@ -1507,7 +1492,7 @@ mod tests {
     };
     use crate::client::{StacksClient, VOTE_FUNCTION_NAME};
     use crate::config::GlobalConfig;
-    use crate::signer::{BlockInfo, RegisteredSigner};
+    use crate::signer::{BlockInfo, Signer};
 
     #[test]
     #[serial]
@@ -1516,7 +1501,7 @@ mod tests {
         // Create a runloop of a valid signer
         let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
         let (signer_config, _ordered_addresses) = generate_signer_config(&config, 5, 20);
-        let mut signer = RegisteredSigner::from(signer_config);
+        let mut signer = Signer::from(signer_config);
 
         let signer_private_key = config.stacks_private_key;
         let non_signer_private_key = StacksPrivateKey::new();
@@ -1634,11 +1619,7 @@ mod tests {
         ];
         let num_transactions = transactions.len();
         let stacks_client = StacksClient::from(&config);
-        let h = spawn(move || {
-            signer
-                .get_filtered_transactions(&stacks_client, &[0], 0)
-                .unwrap()
-        });
+        let h = spawn(move || signer.get_signer_transactions(&stacks_client, 0).unwrap());
 
         // Simulate the response to the request for transactions
         let signer_message = SignerMessage::Transactions(transactions);
@@ -1663,7 +1644,7 @@ mod tests {
         let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
         let (signer_config, _ordered_addresses) = generate_signer_config(&config, 5, 20);
         let stacks_client = StacksClient::from(&config);
-        let mut signer = RegisteredSigner::from(signer_config);
+        let mut signer = Signer::from(signer_config);
 
         let signer_private_key = config.stacks_private_key;
         let vote_contract_id = boot_code_id(SIGNERS_VOTING_NAME, signer.mainnet);
@@ -1766,6 +1747,7 @@ mod tests {
 
     #[test]
     #[serial]
+    #[ignore]
     fn verify_transaction_payload_filters_invalid_payloads() {
         // Create a runloop of a valid signer
         let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
@@ -1773,7 +1755,7 @@ mod tests {
         signer_config.reward_cycle = 1;
 
         // valid transaction
-        let signer = RegisteredSigner::from(signer_config.clone());
+        let signer = Signer::from(signer_config.clone());
         let stacks_client = StacksClient::from(&config);
 
         let signer_private_key = config.stacks_private_key;
@@ -1833,7 +1815,7 @@ mod tests {
         mock_server_from_config_and_write_response(&config, last_round_response.as_bytes());
         h.join().unwrap();
 
-        let signer = RegisteredSigner::from(signer_config.clone());
+        let signer = Signer::from(signer_config.clone());
         // Create a invalid transaction that is not a contract call
         let invalid_not_contract_call = StacksTransaction {
             version: TransactionVersion::Testnet,
@@ -2003,7 +1985,7 @@ mod tests {
         }
 
         // Invalid reward cycle (voting for the current is not allowed. only the next)
-        let signer = RegisteredSigner::from(signer_config.clone());
+        let signer = Signer::from(signer_config.clone());
         let invalid_reward_cycle = StacksClient::build_signed_contract_call_transaction(
             &contract_addr,
             contract_name.clone(),
@@ -2029,7 +2011,7 @@ mod tests {
         h.join().unwrap();
 
         // Invalid block height to vote
-        let signer = RegisteredSigner::from(signer_config.clone());
+        let signer = Signer::from(signer_config.clone());
         let stacks_client = StacksClient::from(&config);
         let invalid_reward_set = StacksClient::build_signed_contract_call_transaction(
             &contract_addr,
@@ -2069,7 +2051,7 @@ mod tests {
         h.join().unwrap();
 
         // Already voted
-        let signer = RegisteredSigner::from(signer_config.clone());
+        let signer = Signer::from(signer_config.clone());
         let stacks_client = StacksClient::from(&config);
         let invalid_already_voted = StacksClient::build_signed_contract_call_transaction(
             &contract_addr,
@@ -2110,7 +2092,7 @@ mod tests {
         h.join().unwrap();
 
         // Already voted
-        let signer = RegisteredSigner::from(signer_config.clone());
+        let signer = Signer::from(signer_config.clone());
         let stacks_client = StacksClient::from(&config);
         let round: u128 = 0;
         let invalid_already_voted = StacksClient::build_signed_contract_call_transaction(
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index 93341037d4..c70310ccf7 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -12,6 +12,7 @@ use libsigner::{
     BLOCK_MSG_ID,
 };
 use stacks::burnchains::Txid;
+use stacks::chainstate::burn::ConsensusHashExtensions;
 use stacks::chainstate::coordinator::comm::CoordinatorChannels;
 use stacks::chainstate::nakamoto::signer_set::NakamotoSigners;
 use stacks::chainstate::nakamoto::{NakamotoBlock, NakamotoBlockHeader};
@@ -29,6 +30,7 @@ use stacks_common::util::hash::{MerkleTree, Sha512Trunc256Sum};
 use stacks_common::util::secp256k1::MessageSignature;
 use stacks_signer::client::{StackerDB, StacksClient};
 use stacks_signer::config::{build_signer_config_tomls, GlobalConfig as SignerConfig, Network};
+use stacks_signer::coordinator::CoordinatorSelector;
 use stacks_signer::runloop::RunLoopCommand;
 use stacks_signer::signer::Command as SignerCommand;
 use tracing_subscriber::prelude::*;
@@ -364,11 +366,14 @@ impl SignerTest {
             .get_registered_signers_info(reward_cycle)
             .unwrap()
             .unwrap();
-        let coordinator_id = *self
-            .stacks_client
-            .calculate_coordinator_ids(&registered_signers_info.public_keys)
-            .first()
-            .expect("No coordinator found");
+
+        // TODO: do not use the zeroed consensus hash here
+        let coordinator_id = *CoordinatorSelector::calculate_coordinator_ids(
+            &registered_signers_info.public_keys,
+            &ConsensusHash::empty(),
+        )
+        .first()
+        .expect("No coordinator found");
         let coordinator_pk = registered_signers_info
             .public_keys
             .signers
@@ -914,6 +919,7 @@ fn stackerdb_block_proposal() {
 
 #[test]
 #[ignore]
+// TODO: FIX THIS TEST. IT SHOULD BE TESTING THAT THE MINER FILTERS OUT THE NEXT SIGNERS TRANSACTIONS
 /// Test that signers will accept a miners block proposal and sign it if it contains all expected transactions,
 /// filtering invalid transactions from the block requirements
 ///
@@ -1158,15 +1164,15 @@ fn stackerdb_reward_cycle_transitions() {
         .saturating_sub(1);
     let next_reward_cycle_reward_set_calculation = next_reward_cycle_boundary
         .saturating_sub(prepare_phase_len)
-        .saturating_add(1); // +1 since second block of the prepare phase is where the reward set is calculated
+        .saturating_add(2); // +2 since second block of the prepare phase is where the reward set is calculated
 
     info!("------------------------- Test Nakamoto Block Mining in Reward Cycle {curr_reward_cycle} -------------------------");
 
-    debug!("At block height {current_block_height} in reward cycle {curr_reward_cycle}");
+    info!("At block height {current_block_height} in reward cycle {curr_reward_cycle}");
 
     let nmb_blocks_to_mine =
         next_reward_cycle_reward_set_calculation.saturating_sub(current_block_height);
-    debug!(
+    info!(
         "Mining {} Nakamoto blocks to reach next reward cycle reward set calculation at block height {next_reward_cycle_reward_set_calculation}",
         nmb_blocks_to_mine
     );
@@ -1182,13 +1188,13 @@ fn stackerdb_reward_cycle_transitions() {
         .btc_regtest_controller
         .get_headers_height();
 
-    debug!("At block height {current_block_height} in reward cycle {curr_reward_cycle}");
-    debug!("Wait for the next reward cycle {next_reward_cycle} dkg to be calculated by the new signers");
+    info!("At block height {current_block_height} in reward cycle {curr_reward_cycle}");
+    info!("Wait for the next reward cycle {next_reward_cycle} dkg to be calculated by the new signers");
 
     let set_dkg_2 = signer_test.wait_for_dkg(timeout);
     assert_ne!(set_dkg_1, set_dkg_2);
 
-    debug!("DKG has been calculated for the next reward cycle {next_reward_cycle}");
+    info!("DKG has been calculated for the next reward cycle {next_reward_cycle}");
 
     let current_block_height = signer_test
         .running_nodes
@@ -1197,7 +1203,7 @@ fn stackerdb_reward_cycle_transitions() {
 
     let nmb_blocks_to_mine = next_reward_cycle_boundary.saturating_sub(current_block_height);
 
-    debug!(
+    info!(
         "Mining {} Nakamoto blocks to reach next reward cycle {next_reward_cycle} boundary block height {next_reward_cycle_boundary}",
         nmb_blocks_to_mine
     );

From e99d6d8ce28cc5feb7647a09b2c7b7a60dffbe59 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Tue, 20 Feb 2024 20:45:30 -0500
Subject: [PATCH 0912/1166] Cleanup reward cycle transitions test

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/stacks_client.rs     |  4 +-
 stacks-signer/src/runloop.rs                  |  2 +-
 stacks-signer/src/signer.rs                   |  4 +-
 stackslib/src/chainstate/nakamoto/mod.rs      |  4 +-
 testnet/stacks-node/src/config.rs             |  2 +-
 .../stacks-node/src/nakamoto_node/miner.rs    |  7 +++-
 testnet/stacks-node/src/tests/signer.rs       | 39 ++++++++++---------
 7 files changed, 35 insertions(+), 27 deletions(-)

diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index bd1c3703e9..0988dbd40c 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -437,7 +437,7 @@ impl StacksClient {
     /// Get the current reward cycle from the stacks node
     pub fn get_current_reward_cycle(&self) -> Result<u64, ClientError> {
         let pox_data = self.get_pox_data()?;
-        Ok(pox_data.reward_cycle_id)
+        Ok(pox_data.current_cycle.id)
     }
 
     /// Helper function to retrieve the account info from the stacks node for a specific address
@@ -805,7 +805,7 @@ mod tests {
         let h = spawn(move || mock.client.get_current_reward_cycle());
         write_response(mock.server, pox_data_response.as_bytes());
         let current_cycle_id = h.join().unwrap().unwrap();
-        assert_eq!(current_cycle_id, pox_data.reward_cycle_id);
+        assert_eq!(current_cycle_id, pox_data.current_cycle.id);
     }
 
     #[test]
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 84ae08a202..f5ab41913c 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -151,7 +151,7 @@ impl RunLoop {
                 if let Some(signer) = self.stacks_signers.get_mut(&prior_reward_set) {
                     if signer.reward_cycle == prior_reward_cycle {
                         // The signers have been calculated for the next reward cycle. Update the current one
-                        debug!("Signer #{}: Reward cycle ({reward_cycle}) signer set calculated. Updating prior reward cycle ({prior_reward_cycle}) signer.", signer.signer_id);
+                        debug!("Signer #{}: Next reward cycle ({reward_cycle}) signer set calculated. Updating current reward cycle ({prior_reward_cycle}) signer.", signer.signer_id);
                         signer.next_signer_ids = new_signer_config
                             .registered_signers
                             .signer_ids
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index aa916993fc..3f81fbf416 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -1105,6 +1105,7 @@ impl Signer {
         // For all Pox-4 epochs onwards, broadcast the results also to stackerDB for other signers/miners to observe
         // TODO: if we store transactions on the side, should we use them rather than directly querying the stacker db slot?
         // TODO: Should we even store transactions if not in prepare phase? Should the miner just ignore all signer transactions if not in prepare phase?
+        let txid = new_transaction.txid();
         let new_transactions = if aggregate_key.is_some() {
             // We do not enforce a block contain any transactions except the aggregate votes when it is NOT already set
             info!(
@@ -1119,11 +1120,10 @@ impl Signer {
             new_transactions.push(new_transaction);
             new_transactions
         };
-        let nmb_transactions = new_transactions.len();
         let signer_message = SignerMessage::Transactions(new_transactions);
         self.stackerdb.send_message_with_retry(signer_message)?;
         info!(
-            "Signer #{}: Broadcasted {nmb_transactions} transaction(s) () to stackerDB",
+            "Signer #{}: Broadcasted DKG vote transaction ({txid}) to stacker DB",
             self.signer_id,
         );
         Ok(())
diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index 13b08b8db0..e9c6789db6 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -1702,7 +1702,9 @@ impl NakamotoChainState {
             &block.header.signer_signature_hash().0,
             aggregate_public_key,
         )? {
-            let msg = format!("Received block, but the stacker signature does not match the active stacking cycle");
+            let msg = format!(
+                "Received block, but the signer signature does not match the active stacking cycle"
+            );
             warn!("{}", msg; "aggregate_key" => %aggregate_public_key);
             return Err(ChainstateError::InvalidStacksBlock(msg));
         }
diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index 5970d0996d..5598ffafcd 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -2059,7 +2059,7 @@ impl Default for MinerConfig {
             filter_origins: HashSet::new(),
             max_reorg_depth: 3,
             // TODO: update to a sane value based on stackerdb benchmarking
-            wait_on_signers: Duration::from_secs(20),
+            wait_on_signers: Duration::from_secs(200),
         }
     }
 }
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index 13ab1d41c2..13ec10dfab 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -361,7 +361,11 @@ impl BlockMinerThread {
                             test_debug!("Miner: ignoring transaction ({:?}) with nonce {nonce} from address {address}", transaction.txid());
                             continue;
                         }
-                        test_debug!("Miner: including transaction ({:?}) with nonce {nonce} from address {address}", transaction.txid());
+                        debug!("Miner: including signer transaction.";
+                            "nonce" => {nonce},
+                            "origin_address" => %address,
+                            "txid" => %transaction.txid()
+                        );
                         // TODO : filter out transactions that are not valid votes. Do not include transactions with invalid/duplicate nonces for the same address.
                         transactions_to_include.push(transaction);
                     }
@@ -392,6 +396,7 @@ impl BlockMinerThread {
         let mut rejections = HashSet::new();
         let mut rejections_weight: u64 = 0;
         let now = Instant::now();
+        debug!("Miner: waiting for block response from reward cycle {reward_cycle } signers...");
         while now.elapsed() < self.config.miner.wait_on_signers {
             // Get the block responses from the signers for the block we just proposed
             let signer_chunks = stackerdbs
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index c70310ccf7..3e9fd1e611 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -1156,15 +1156,14 @@ fn stackerdb_reward_cycle_transitions() {
         .btc_regtest_controller
         .get_headers_height();
     let next_reward_cycle = curr_reward_cycle.saturating_add(1);
-    let next_reward_cycle_boundary = signer_test
+    let next_reward_cycle_height = signer_test
         .running_nodes
         .btc_regtest_controller
         .get_burnchain()
-        .reward_cycle_to_block_height(next_reward_cycle)
-        .saturating_sub(1);
-    let next_reward_cycle_reward_set_calculation = next_reward_cycle_boundary
+        .reward_cycle_to_block_height(next_reward_cycle);
+    let next_reward_cycle_reward_set_calculation = next_reward_cycle_height
         .saturating_sub(prepare_phase_len)
-        .saturating_add(2); // +2 since second block of the prepare phase is where the reward set is calculated
+        .saturating_add(1); // +1 since second block of the prepare phase is where the reward set is calculated
 
     info!("------------------------- Test Nakamoto Block Mining in Reward Cycle {curr_reward_cycle} -------------------------");
 
@@ -1176,7 +1175,8 @@ fn stackerdb_reward_cycle_transitions() {
         "Mining {} Nakamoto blocks to reach next reward cycle reward set calculation at block height {next_reward_cycle_reward_set_calculation}",
         nmb_blocks_to_mine
     );
-    for _ in 0..nmb_blocks_to_mine {
+    for i in 1..=nmb_blocks_to_mine {
+        info!("Mining Nakamoto block #{i} of {nmb_blocks_to_mine}");
         signer_test.mine_nakamoto_block(timeout);
         signer_test.wait_for_validate_ok_response(timeout);
         signer_test.wait_for_frost_signatures(timeout);
@@ -1196,30 +1196,31 @@ fn stackerdb_reward_cycle_transitions() {
 
     info!("DKG has been calculated for the next reward cycle {next_reward_cycle}");
 
-    let current_block_height = signer_test
-        .running_nodes
-        .btc_regtest_controller
-        .get_headers_height();
-
-    let nmb_blocks_to_mine = next_reward_cycle_boundary.saturating_sub(current_block_height);
-
-    info!(
-        "Mining {} Nakamoto blocks to reach next reward cycle {next_reward_cycle} boundary block height {next_reward_cycle_boundary}",
-        nmb_blocks_to_mine
-    );
-    for _ in 0..nmb_blocks_to_mine {
+    info!("Mining Nakamoto blocks to reach next reward cycle {next_reward_cycle}.",);
+    let mut i = 1u32;
+    while signer_test.get_current_reward_cycle() != next_reward_cycle {
+        info!("Mining Nakamoto block #{i} to reach next reward cycle {next_reward_cycle}...");
         signer_test.mine_nakamoto_block(timeout);
         signer_test.wait_for_validate_ok_response(timeout);
         signer_test.wait_for_frost_signatures(timeout);
+        i = i.wrapping_add(1);
     }
 
     info!("------------------------- Test Nakamoto Block Mining in Reward Cycle {next_reward_cycle} -------------------------");
+    // First make sure that the aggregate key was actually mined.
+    let set_dkg = signer_test
+        .stacks_client
+        .get_approved_aggregate_key(next_reward_cycle)
+        .expect("Failed to get approved aggregate key")
+        .expect("No approved aggregate key found");
+    assert_eq!(set_dkg, set_dkg_2);
+
     let current_block_height = signer_test
         .running_nodes
         .btc_regtest_controller
         .get_headers_height();
 
-    debug!("At block height {current_block_height} in reward cycle {next_reward_cycle}");
+    debug!("At block height {current_block_height}");
     info!(
         "Mining first Nakamoto block of reward cycle {}...",
         next_reward_cycle

From 51809a009b0659124e2b73961398482879d95882 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 21 Feb 2024 11:38:39 -0500
Subject: [PATCH 0913/1166] Fix get_current_reward_cycle in stacks client

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/stacks_client.rs |  8 +++++++-
 testnet/stacks-node/src/tests/signer.rs   | 10 ++--------
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index 0988dbd40c..b318e3d41b 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -437,7 +437,13 @@ impl StacksClient {
     /// Get the current reward cycle from the stacks node
     pub fn get_current_reward_cycle(&self) -> Result<u64, ClientError> {
         let pox_data = self.get_pox_data()?;
-        Ok(pox_data.current_cycle.id)
+        let blocks_mined = pox_data
+            .current_burnchain_block_height
+            .saturating_sub(pox_data.first_burnchain_block_height);
+        let reward_cycle_length = pox_data
+            .reward_phase_block_length
+            .saturating_add(pox_data.prepare_phase_block_length);
+        Ok(blocks_mined / reward_cycle_length)
     }
 
     /// Helper function to retrieve the account info from the stacks node for a specific address
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index 3e9fd1e611..f892183191 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -197,8 +197,8 @@ impl SignerTest {
             );
             thread::sleep(Duration::from_secs(1));
         }
-        let validate_responses = test_observer::get_proposal_responses();
-        match validate_responses.first().expect("No block proposal") {
+        let validate_response = test_observer::get_proposal_responses().pop().expect("No block proposal");
+        match validate_response {
             BlockValidateResponse::Ok(block_validated) => block_validated.signer_signature_hash,
             _ => panic!("Unexpected response"),
         }
@@ -1215,12 +1215,6 @@ fn stackerdb_reward_cycle_transitions() {
         .expect("No approved aggregate key found");
     assert_eq!(set_dkg, set_dkg_2);
 
-    let current_block_height = signer_test
-        .running_nodes
-        .btc_regtest_controller
-        .get_headers_height();
-
-    debug!("At block height {current_block_height}");
     info!(
         "Mining first Nakamoto block of reward cycle {}...",
         next_reward_cycle

From 1c8d6118c4ff0c9d831e9d1b9c81b8dcae30f56e Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 21 Feb 2024 18:40:35 -0500
Subject: [PATCH 0914/1166] Fix reward cycle filter bad transactions test

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 .github/workflows/bitcoin-tests.yml           |   2 +
 stacks-signer/src/client/mod.rs               |  63 +-
 stacks-signer/src/client/stackerdb.rs         |  10 +-
 stacks-signer/src/client/stacks_client.rs     |  89 +--
 stacks-signer/src/coordinator.rs              |   2 -
 stacks-signer/src/signer.rs                   | 499 ++++++----------
 .../src/tests/nakamoto_integrations.rs        |   4 +-
 testnet/stacks-node/src/tests/signer.rs       | 554 +++++++++---------
 8 files changed, 490 insertions(+), 733 deletions(-)

diff --git a/.github/workflows/bitcoin-tests.yml b/.github/workflows/bitcoin-tests.yml
index ae465bbd44..c618172fd5 100644
--- a/.github/workflows/bitcoin-tests.yml
+++ b/.github/workflows/bitcoin-tests.yml
@@ -78,6 +78,8 @@ jobs:
           - tests::nakamoto_integrations::correct_burn_outs
           - tests::signer::stackerdb_dkg_sign
           - tests::signer::stackerdb_block_proposal
+          - tests::signer::stackerdb_reward_cycle_transitions
+          - tests::signer::stackerdb_filter_bad_transactions
     steps:
       ## Setup test environment
       - name: Setup Test Environment
diff --git a/stacks-signer/src/client/mod.rs b/stacks-signer/src/client/mod.rs
index 2aa062e03b..1e38bf0166 100644
--- a/stacks-signer/src/client/mod.rs
+++ b/stacks-signer/src/client/mod.rs
@@ -411,7 +411,7 @@ pub(crate) mod tests {
         config: &GlobalConfig,
         num_signers: u32,
         num_keys: u32,
-    ) -> (SignerConfig, Vec<StacksAddress>) {
+    ) -> SignerConfig {
         assert!(
             num_signers > 0,
             "Cannot generate 0 signers...Specify at least 1 signer."
@@ -430,13 +430,11 @@ pub(crate) mod tests {
         let remaining_keys = num_keys % num_signers;
         let mut coordinator_key_ids = HashMap::new();
         let mut signer_key_ids = HashMap::new();
-        let mut addresses = vec![];
         let mut signer_ids = HashMap::new();
         let mut start_key_id = 1u32;
         let mut end_key_id = start_key_id;
         let mut signer_public_keys = HashMap::new();
         let mut signer_slot_ids = HashMap::new();
-        let stacks_address = config.stacks_address;
         let ecdsa_private_key = config.ecdsa_private_key;
         let ecdsa_public_key =
             ecdsa::PublicKey::new(&ecdsa_private_key).expect("Failed to create ecdsa public key");
@@ -448,7 +446,6 @@ pub(crate) mod tests {
                 end_key_id.wrapping_add(num_keys)
             };
             if signer_id == 0 {
-                addresses.push(stacks_address);
                 public_keys.signers.insert(signer_id, ecdsa_public_key);
                 let signer_public_key =
                     Point::try_from(&Compressed::from(ecdsa_public_key.to_bytes())).unwrap();
@@ -466,6 +463,14 @@ pub(crate) mod tests {
                         .push(k);
                 }
                 start_key_id = end_key_id;
+                let address = StacksAddress::p2pkh(
+                    false,
+                    &StacksPublicKey::from_slice(ecdsa_public_key.to_bytes().as_slice())
+                        .expect("Failed to create stacks public key"),
+                );
+                signer_slot_ids.insert(address, signer_id); // Note in a real world situation, these would not always match
+                signer_ids.insert(address, signer_id);
+
                 continue;
             }
             let private_key = Scalar::random(rng);
@@ -492,35 +497,31 @@ pub(crate) mod tests {
             );
             signer_slot_ids.insert(address, signer_id); // Note in a real world situation, these would not always match
             signer_ids.insert(address, signer_id);
-            addresses.push(address);
             start_key_id = end_key_id;
         }
-        (
-            SignerConfig {
-                reward_cycle,
-                signer_id: 0,
-                signer_slot_id: 0,
-                key_ids: signer_key_ids.get(&0).cloned().unwrap_or_default(),
-                registered_signers: RegisteredSignersInfo {
-                    signer_slot_ids,
-                    public_keys,
-                    coordinator_key_ids,
-                    signer_key_ids,
-                    signer_ids,
-                    signer_public_keys,
-                },
-                ecdsa_private_key: config.ecdsa_private_key,
-                stacks_private_key: config.stacks_private_key,
-                node_host: config.node_host,
-                mainnet: config.network.is_mainnet(),
-                dkg_end_timeout: config.dkg_end_timeout,
-                dkg_private_timeout: config.dkg_private_timeout,
-                dkg_public_timeout: config.dkg_public_timeout,
-                nonce_timeout: config.nonce_timeout,
-                sign_timeout: config.sign_timeout,
-                tx_fee_ms: config.tx_fee_ms,
+        SignerConfig {
+            reward_cycle,
+            signer_id: 0,
+            signer_slot_id: 0,
+            key_ids: signer_key_ids.get(&0).cloned().unwrap_or_default(),
+            registered_signers: RegisteredSignersInfo {
+                signer_slot_ids,
+                public_keys,
+                coordinator_key_ids,
+                signer_key_ids,
+                signer_ids,
+                signer_public_keys,
             },
-            addresses,
-        )
+            ecdsa_private_key: config.ecdsa_private_key,
+            stacks_private_key: config.stacks_private_key,
+            node_host: config.node_host,
+            mainnet: config.network.is_mainnet(),
+            dkg_end_timeout: config.dkg_end_timeout,
+            dkg_private_timeout: config.dkg_private_timeout,
+            dkg_public_timeout: config.dkg_public_timeout,
+            nonce_timeout: config.nonce_timeout,
+            sign_timeout: config.sign_timeout,
+            tx_fee_ms: config.tx_fee_ms,
+        }
     }
 }
diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index 2875cb5967..fca5580d35 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -280,7 +280,7 @@ mod tests {
     #[serial]
     fn get_signer_transactions_with_retry_should_succeed() {
         let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
-        let (signer_config, _ordered_addresses) = generate_signer_config(&config, 5, 20);
+        let signer_config = generate_signer_config(&config, 5, 20);
         let mut stackerdb = StackerDB::from(&signer_config);
         let sk = StacksPrivateKey::new();
         let tx = StacksTransaction {
@@ -324,7 +324,7 @@ mod tests {
     #[serial]
     fn send_signer_message_with_retry_should_succeed() {
         let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
-        let (signer_config, _ordered_addresses) = generate_signer_config(&config, 5, 20);
+        let signer_config = generate_signer_config(&config, 5, 20);
         let mut stackerdb = StackerDB::from(&signer_config);
 
         let sk = StacksPrivateKey::new();
@@ -350,12 +350,12 @@ mod tests {
             reason: None,
             metadata: None,
         };
+        let mock_server = mock_server_from_config(&config);
+        let h = spawn(move || stackerdb.send_message_with_retry(signer_message));
         let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
         let payload = serde_json::to_string(&ack).expect("Failed to serialize ack");
         response_bytes.extend(payload.as_bytes());
-        let mock_server = mock_server_from_config(&config);
-        let h = spawn(move || stackerdb.send_message_with_retry(signer_message));
-        std::thread::sleep(Duration::from_millis(100));
+        std::thread::sleep(Duration::from_millis(500));
         write_response(mock_server, response_bytes.as_slice());
         assert_eq!(ack, h.join().unwrap().unwrap());
     }
diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index b318e3d41b..caa5c7018a 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -811,7 +811,14 @@ mod tests {
         let h = spawn(move || mock.client.get_current_reward_cycle());
         write_response(mock.server, pox_data_response.as_bytes());
         let current_cycle_id = h.join().unwrap().unwrap();
-        assert_eq!(current_cycle_id, pox_data.current_cycle.id);
+        let blocks_mined = pox_data
+            .current_burnchain_block_height
+            .saturating_sub(pox_data.first_burnchain_block_height);
+        let reward_cycle_length = pox_data
+            .reward_phase_block_length
+            .saturating_add(pox_data.prepare_phase_block_length);
+        let id = blocks_mined / reward_cycle_length;
+        assert_eq!(current_cycle_id, id);
     }
 
     #[test]
@@ -1231,86 +1238,6 @@ mod tests {
         assert_eq!(h.join().unwrap().unwrap(), stacker_set);
     }
 
-    // #[test]
-    // #[serial]
-    // fn get_reward_set_calculated() {
-    //     // Should return TRUE as the passed in reward cycle is older than the current reward cycle of the node
-    //     let mock = MockServerClient::new();
-    //     let reward_cycle = 10;
-    //     let pox_response = build_get_pox_data_response(Some(reward_cycle), None, None, None).0;
-    //     let h = spawn(move || {
-    //         mock.client
-    //             .reward_set_calculated(reward_cycle.saturating_sub(1))
-    //     });
-    //     write_response(mock.server, pox_response.as_bytes());
-    //     assert!(h.join().unwrap().unwrap());
-
-    //     // Should return TRUE as the passed in reward cycle is the same as the current reward cycle
-    //     let mock = MockServerClient::from_config(mock.config);
-    //     let pox_response = build_get_pox_data_response(Some(reward_cycle), None, None, None).0;
-    //     let h = spawn(move || mock.client.reward_set_calculated(reward_cycle));
-    //     write_response(mock.server, pox_response.as_bytes());
-    //     assert!(h.join().unwrap().unwrap());
-
-    //     // Should return TRUE as the passed in reward cycle is the NEXT reward cycle AND the prepare phase is in its SECOND block
-    //     let mock = MockServerClient::from_config(mock.config);
-    //     let prepare_phase_start = 10;
-    //     let pox_response =
-    //         build_get_pox_data_response(Some(reward_cycle), Some(prepare_phase_start), None, None)
-    //             .0;
-    //     let peer_response =
-    //         build_get_peer_info_response(Some(prepare_phase_start.saturating_add(2)), None).0;
-    //     let h = spawn(move || {
-    //         mock.client
-    //             .reward_set_calculated(reward_cycle.saturating_add(1))
-    //     });
-    //     write_response(mock.server, pox_response.as_bytes());
-    //     let mock = MockServerClient::from_config(mock.config);
-    //     write_response(mock.server, peer_response.as_bytes());
-    //     assert!(h.join().unwrap().unwrap());
-
-    //     // Should return FALSE as the passed in reward cycle is NEWER than the NEXT reward cycle of the node
-    //     let mock = MockServerClient::from_config(mock.config);
-    //     let pox_response = build_get_pox_data_response(Some(reward_cycle), None, None, None).0;
-    //     let h = spawn(move || {
-    //         mock.client
-    //             .reward_set_calculated(reward_cycle.saturating_add(2))
-    //     });
-    //     write_response(mock.server, pox_response.as_bytes());
-    //     assert!(!h.join().unwrap().unwrap());
-
-    //     // Should return FALSE as the passed in reward cycle is the NEXT reward cycle BUT in the prepare phase start block
-    //     let mock = MockServerClient::from_config(mock.config);
-    //     let pox_response =
-    //         build_get_pox_data_response(Some(reward_cycle), Some(prepare_phase_start), None, None)
-    //             .0;
-    //     let peer_response = build_get_peer_info_response(Some(prepare_phase_start), None).0;
-    //     let h = spawn(move || {
-    //         mock.client
-    //             .reward_set_calculated(reward_cycle.saturating_add(1))
-    //     });
-    //     write_response(mock.server, pox_response.as_bytes());
-    //     let mock = MockServerClient::from_config(mock.config);
-    //     write_response(mock.server, peer_response.as_bytes());
-    //     assert!(!h.join().unwrap().unwrap());
-
-    //     // Should return FALSE as the passed in reward cycle is the NEXT reward cycle BUT in the FIRST block of the prepare phase
-    //     let mock = MockServerClient::from_config(mock.config);
-    //     let pox_response =
-    //         build_get_pox_data_response(Some(reward_cycle), Some(prepare_phase_start), None, None)
-    //             .0;
-    //     let peer_response =
-    //         build_get_peer_info_response(Some(prepare_phase_start.saturating_add(1)), None).0;
-    //     let h = spawn(move || {
-    //         mock.client
-    //             .reward_set_calculated(reward_cycle.saturating_add(1))
-    //     });
-    //     write_response(mock.server, pox_response.as_bytes());
-    //     let mock = MockServerClient::from_config(mock.config);
-    //     write_response(mock.server, peer_response.as_bytes());
-    //     assert!(!h.join().unwrap().unwrap());
-    // }
-
     #[test]
     fn get_vote_for_aggregate_public_key_should_succeed() {
         let mock = MockServerClient::new();
diff --git a/stacks-signer/src/coordinator.rs b/stacks-signer/src/coordinator.rs
index 5762b81915..2c23fd0b32 100644
--- a/stacks-signer/src/coordinator.rs
+++ b/stacks-signer/src/coordinator.rs
@@ -174,7 +174,6 @@ mod tests {
         let number_of_tests = 5;
         let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
         let public_keys = generate_signer_config(&config, 10, 4000)
-            .0
             .registered_signers
             .public_keys;
         let mut results = Vec::new();
@@ -198,7 +197,6 @@ mod tests {
     ) -> Vec<Vec<u32>> {
         let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
         let public_keys = generate_signer_config(&config, 10, 4000)
-            .0
             .registered_signers
             .public_keys;
         let mut results = Vec::new();
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index 3f81fbf416..45ac6a49d3 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -1460,206 +1460,83 @@ impl Signer {
 mod tests {
     use std::thread::spawn;
 
-    use blockstack_lib::chainstate::nakamoto::{NakamotoBlock, NakamotoBlockHeader};
     use blockstack_lib::chainstate::stacks::boot::SIGNERS_VOTING_NAME;
     use blockstack_lib::chainstate::stacks::{
-        StacksTransaction, ThresholdSignature, TransactionAnchorMode, TransactionAuth,
-        TransactionPayload, TransactionPostConditionMode, TransactionSmartContract,
-        TransactionVersion,
+        StacksTransaction, TransactionAnchorMode, TransactionAuth, TransactionPayload,
+        TransactionPostConditionMode, TransactionSmartContract, TransactionVersion,
     };
-    use blockstack_lib::util_lib::boot::{boot_code_addr, boot_code_id};
+    use blockstack_lib::util_lib::boot::boot_code_id;
     use blockstack_lib::util_lib::strings::StacksString;
     use clarity::vm::Value;
-    use libsigner::SignerMessage;
     use rand::thread_rng;
     use rand_core::RngCore;
     use serial_test::serial;
-    use stacks_common::bitvec::BitVec;
-    use stacks_common::codec::StacksMessageCodec;
     use stacks_common::consts::CHAIN_ID_TESTNET;
-    use stacks_common::types::chainstate::{
-        ConsensusHash, StacksBlockId, StacksPrivateKey, TrieHash,
-    };
-    use stacks_common::util::hash::{MerkleTree, Sha512Trunc256Sum};
-    use stacks_common::util::secp256k1::MessageSignature;
+    use stacks_common::types::chainstate::StacksPrivateKey;
     use wsts::curve::point::Point;
     use wsts::curve::scalar::Scalar;
 
     use crate::client::tests::{
         build_account_nonce_response, build_get_approved_aggregate_key_response,
-        build_get_last_round_response, build_get_peer_info_response, build_get_pox_data_response,
-        generate_signer_config, mock_server_from_config_and_write_response,
+        build_get_last_round_response, generate_signer_config, mock_server_from_config,
+        mock_server_from_config_and_write_response, write_response,
     };
     use crate::client::{StacksClient, VOTE_FUNCTION_NAME};
     use crate::config::GlobalConfig;
-    use crate::signer::{BlockInfo, Signer};
+    use crate::signer::Signer;
 
     #[test]
-    #[serial]
-    #[ignore = "This test needs to be fixed based on reward set calculations"]
-    fn get_filtered_transaction_filters_out_invalid_transactions() {
-        // Create a runloop of a valid signer
+    fn filter_invalid_transaction_bad_origin_id() {
         let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
-        let (signer_config, _ordered_addresses) = generate_signer_config(&config, 5, 20);
-        let mut signer = Signer::from(signer_config);
-
-        let signer_private_key = config.stacks_private_key;
-        let non_signer_private_key = StacksPrivateKey::new();
-
-        let vote_contract_id = boot_code_id(SIGNERS_VOTING_NAME, signer.mainnet);
-        let contract_addr = vote_contract_id.issuer.into();
-        let contract_name = vote_contract_id.name.clone();
-        let index = thread_rng().next_u64() as u128;
-        let point = Point::from(Scalar::random(&mut thread_rng()));
-        let round = thread_rng().next_u64() as u128;
-        let valid_function_args = vec![
-            Value::UInt(index),
-            Value::buff_from(point.compress().data.to_vec()).expect("Failed to create buff"),
-            Value::UInt(round),
-        ];
-
-        // Create a valid transaction signed by the signer private key coresponding to the slot into which it is being inserted (signer id 0)
-        let valid_tx = StacksClient::build_signed_contract_call_transaction(
-            &contract_addr,
-            contract_name.clone(),
-            VOTE_FUNCTION_NAME.into(),
-            &valid_function_args,
-            &signer_private_key,
-            TransactionVersion::Testnet,
-            config.network.to_chain_id(),
-            1,
-            10,
-        )
-        .unwrap();
-        let invalid_tx_outdated_nonce = StacksClient::build_signed_contract_call_transaction(
-            &contract_addr,
-            contract_name.clone(),
-            VOTE_FUNCTION_NAME.into(),
-            &valid_function_args,
-            &signer_private_key,
-            TransactionVersion::Testnet,
-            config.network.to_chain_id(),
-            0,
-            5,
-        )
-        .unwrap();
-        let invalid_tx_bad_signer = StacksClient::build_signed_contract_call_transaction(
-            &contract_addr,
-            contract_name.clone(),
-            VOTE_FUNCTION_NAME.into(),
-            &valid_function_args,
-            &non_signer_private_key,
-            TransactionVersion::Testnet,
-            config.network.to_chain_id(),
-            0,
-            10,
-        )
-        .unwrap();
-        let bad_contract_addr = boot_code_addr(true);
-        let invalid_tx_bad_contract_addr = StacksClient::build_signed_contract_call_transaction(
-            &bad_contract_addr,
-            contract_name.clone(),
-            VOTE_FUNCTION_NAME.into(),
-            &valid_function_args,
-            &signer_private_key,
-            TransactionVersion::Testnet,
-            config.network.to_chain_id(),
-            1,
-            5,
-        )
-        .unwrap();
-
-        let invalid_tx_bad_contract_name = StacksClient::build_signed_contract_call_transaction(
-            &contract_addr,
-            "wrong".into(),
-            VOTE_FUNCTION_NAME.into(),
-            &valid_function_args,
-            &signer_private_key,
-            TransactionVersion::Testnet,
-            config.network.to_chain_id(),
-            1,
-            5,
-        )
-        .unwrap();
-
-        let invalid_tx_bad_function = StacksClient::build_signed_contract_call_transaction(
-            &contract_addr,
-            contract_name.clone(),
-            "fake-function".into(),
-            &valid_function_args,
-            &signer_private_key,
-            TransactionVersion::Testnet,
-            config.network.to_chain_id(),
-            1,
-            5,
-        )
-        .unwrap();
-
-        let invalid_tx_bad_function_args = StacksClient::build_signed_contract_call_transaction(
-            &contract_addr,
-            contract_name.clone(),
-            VOTE_FUNCTION_NAME.into(),
-            &[],
-            &signer_private_key,
-            TransactionVersion::Testnet,
-            config.network.to_chain_id(),
-            1,
-            5,
-        )
-        .unwrap();
-
-        let transactions = vec![
-            valid_tx.clone(),
-            invalid_tx_outdated_nonce,
-            invalid_tx_bad_signer,
-            invalid_tx_bad_contract_addr,
-            invalid_tx_bad_contract_name,
-            invalid_tx_bad_function,
-            invalid_tx_bad_function_args,
-        ];
-        let num_transactions = transactions.len();
+        let signer_config = generate_signer_config(&config, 2, 20);
+        let signer = Signer::from(signer_config.clone());
         let stacks_client = StacksClient::from(&config);
-        let h = spawn(move || signer.get_signer_transactions(&stacks_client, 0).unwrap());
-
-        // Simulate the response to the request for transactions
-        let signer_message = SignerMessage::Transactions(transactions);
-        let message = signer_message.serialize_to_vec();
-        let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
-        response_bytes.extend(message);
-        mock_server_from_config_and_write_response(&config, response_bytes.as_slice());
-
-        for _ in 0..num_transactions {
-            let response_bytes = build_account_nonce_response(1);
-            mock_server_from_config_and_write_response(&config, response_bytes.as_bytes());
-        }
-
-        let filtered_txs = h.join().unwrap();
-        assert_eq!(filtered_txs, vec![valid_tx]);
+        let signer_private_key = StacksPrivateKey::new();
+        let invalid_tx = StacksTransaction {
+            version: TransactionVersion::Testnet,
+            chain_id: CHAIN_ID_TESTNET,
+            auth: TransactionAuth::from_p2pkh(&signer_private_key).unwrap(),
+            anchor_mode: TransactionAnchorMode::Any,
+            post_condition_mode: TransactionPostConditionMode::Allow,
+            post_conditions: vec![],
+            payload: TransactionPayload::SmartContract(
+                TransactionSmartContract {
+                    name: "test-contract".into(),
+                    code_body: StacksString::from_str("(/ 1 0)").unwrap(),
+                },
+                None,
+            ),
+        };
+        assert!(signer
+            .filter_invalid_transactions(&stacks_client, 0, &signer.signer_slot_ids, invalid_tx)
+            .is_none());
     }
 
     #[test]
     #[serial]
-    #[ignore = "This test needs to be fixed based on reward set calculations"]
-    fn verify_block_transactions_valid() {
+    fn filter_invalid_transaction_bad_nonce() {
         let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
-        let (signer_config, _ordered_addresses) = generate_signer_config(&config, 5, 20);
+        let signer_config = generate_signer_config(&config, 2, 20);
+        let signer = Signer::from(signer_config.clone());
         let stacks_client = StacksClient::from(&config);
-        let mut signer = Signer::from(signer_config);
-
         let signer_private_key = config.stacks_private_key;
         let vote_contract_id = boot_code_id(SIGNERS_VOTING_NAME, signer.mainnet);
         let contract_addr = vote_contract_id.issuer.into();
         let contract_name = vote_contract_id.name.clone();
-        let index = thread_rng().next_u64() as u128;
+        let signer_index = Value::UInt(signer.signer_id as u128);
         let point = Point::from(Scalar::random(&mut thread_rng()));
-        let round = thread_rng().next_u64() as u128;
+        let point_arg =
+            Value::buff_from(point.compress().data.to_vec()).expect("Failed to create buff");
+        let round = thread_rng().next_u64();
+        let round_arg = Value::UInt(round as u128);
+        let reward_cycle_arg = Value::UInt(signer.reward_cycle as u128);
         let valid_function_args = vec![
-            Value::UInt(index),
-            Value::buff_from(point.compress().data.to_vec()).expect("Failed to create buff"),
-            Value::UInt(round),
+            signer_index.clone(),
+            point_arg.clone(),
+            round_arg.clone(),
+            reward_cycle_arg.clone(),
         ];
-        // Create a valid transaction signed by the signer private key coresponding to the slot into which it is being inserted (signer id 0)
-        let valid_tx = StacksClient::build_signed_contract_call_transaction(
+        let invalid_tx = StacksClient::build_signed_contract_call_transaction(
             &contract_addr,
             contract_name.clone(),
             VOTE_FUNCTION_NAME.into(),
@@ -1667,91 +1544,32 @@ mod tests {
             &signer_private_key,
             TransactionVersion::Testnet,
             config.network.to_chain_id(),
-            1,
+            0, // Old nonce
             10,
         )
         .unwrap();
 
-        // Create a block
-        let header = NakamotoBlockHeader {
-            version: 1,
-            chain_length: 2,
-            burn_spent: 3,
-            consensus_hash: ConsensusHash([0x04; 20]),
-            parent_block_id: StacksBlockId([0x05; 32]),
-            tx_merkle_root: Sha512Trunc256Sum([0x06; 32]),
-            state_index_root: TrieHash([0x07; 32]),
-            miner_signature: MessageSignature::empty(),
-            signer_signature: ThresholdSignature::empty(),
-            signer_bitvec: BitVec::zeros(1).unwrap(),
-        };
-        let mut block = NakamotoBlock {
-            header,
-            txs: vec![valid_tx.clone()],
-        };
-        let tx_merkle_root = {
-            let txid_vecs = block
-                .txs
-                .iter()
-                .map(|tx| tx.txid().as_bytes().to_vec())
-                .collect();
-
-            MerkleTree::<Sha512Trunc256Sum>::new(&txid_vecs).root()
-        };
-        block.header.tx_merkle_root = tx_merkle_root;
-
-        // Ensure this is a block the signer has seen already
-        signer.blocks.insert(
-            block.header.signer_signature_hash(),
-            BlockInfo::new(block.clone()),
-        );
+        let h = spawn(move || {
+            signer.filter_invalid_transactions(
+                &stacks_client,
+                0,
+                &signer.signer_slot_ids,
+                invalid_tx,
+            )
+        });
 
-        let h = spawn(move || signer.verify_block_transactions(&stacks_client, &block, 0));
-
-        // Simulate the response to the request for transactions with the expected transaction
-        let signer_message = SignerMessage::Transactions(vec![valid_tx]);
-        let message = signer_message.serialize_to_vec();
-        let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
-        response_bytes.extend(message);
-        mock_server_from_config_and_write_response(&config, response_bytes.as_slice());
-
-        let signer_message = SignerMessage::Transactions(vec![]);
-        let message = signer_message.serialize_to_vec();
-        let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
-        response_bytes.extend(message);
-        mock_server_from_config_and_write_response(&config, response_bytes.as_slice());
-
-        let signer_message = SignerMessage::Transactions(vec![]);
-        let message = signer_message.serialize_to_vec();
-        let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
-        response_bytes.extend(message);
-        mock_server_from_config_and_write_response(&config, response_bytes.as_slice());
-
-        let signer_message = SignerMessage::Transactions(vec![]);
-        let message = signer_message.serialize_to_vec();
-        let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
-        response_bytes.extend(message);
-        mock_server_from_config_and_write_response(&config, response_bytes.as_slice());
-
-        let signer_message = SignerMessage::Transactions(vec![]);
-        let message = signer_message.serialize_to_vec();
-        let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
-        response_bytes.extend(message);
-        mock_server_from_config_and_write_response(&config, response_bytes.as_slice());
-
-        let response_bytes = build_account_nonce_response(1);
-        mock_server_from_config_and_write_response(&config, response_bytes.as_bytes());
-        let valid = h.join().unwrap();
-        assert!(valid);
+        let response = build_account_nonce_response(1);
+        let mock_server = mock_server_from_config(&config);
+        write_response(mock_server, response.as_bytes());
+        assert!(h.join().unwrap().is_none());
     }
 
     #[test]
     #[serial]
-    #[ignore]
-    fn verify_transaction_payload_filters_invalid_payloads() {
+    fn verify_valid_transaction() {
         // Create a runloop of a valid signer
         let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
-        let (mut signer_config, _ordered_addresses) = generate_signer_config(&config, 5, 20);
+        let mut signer_config = generate_signer_config(&config, 5, 20);
         signer_config.reward_cycle = 1;
 
         // valid transaction
@@ -1788,14 +1606,6 @@ mod tests {
         )
         .unwrap();
 
-        let pox_info_response = build_get_pox_data_response(
-            Some(signer.reward_cycle.saturating_sub(1)),
-            Some(0),
-            None,
-            None,
-        )
-        .0;
-        let peer_info = build_get_peer_info_response(Some(1), None).0;
         let vote_response = build_get_approved_aggregate_key_response(None);
         let last_round_response = build_get_last_round_response(round);
 
@@ -1809,11 +1619,43 @@ mod tests {
                 )
                 .unwrap())
         });
-        mock_server_from_config_and_write_response(&config, pox_info_response.as_bytes());
-        mock_server_from_config_and_write_response(&config, peer_info.as_bytes());
-        mock_server_from_config_and_write_response(&config, vote_response.as_bytes());
-        mock_server_from_config_and_write_response(&config, last_round_response.as_bytes());
+
+        let mock_server = mock_server_from_config(&config);
+        write_response(mock_server, vote_response.as_bytes());
+
+        let mock_server = mock_server_from_config(&config);
+        write_response(mock_server, last_round_response.as_bytes());
+
         h.join().unwrap();
+    }
+
+    #[test]
+    #[serial]
+    fn verify_transaction_filters_malformed_contract_calls() {
+        // Create a runloop of a valid signer
+        let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
+        let mut signer_config = generate_signer_config(&config, 5, 20);
+        signer_config.reward_cycle = 1;
+
+        let signer = Signer::from(signer_config.clone());
+
+        let signer_private_key = config.stacks_private_key;
+        let vote_contract_id = boot_code_id(SIGNERS_VOTING_NAME, signer.mainnet);
+        let contract_addr = vote_contract_id.issuer.into();
+        let contract_name = vote_contract_id.name.clone();
+        let signer_index = Value::UInt(signer.signer_id as u128);
+        let point = Point::from(Scalar::random(&mut thread_rng()));
+        let point_arg =
+            Value::buff_from(point.compress().data.to_vec()).expect("Failed to create buff");
+        let round = thread_rng().next_u64();
+        let round_arg = Value::UInt(round as u128);
+        let reward_cycle_arg = Value::UInt(signer.reward_cycle as u128);
+        let valid_function_args = vec![
+            signer_index.clone(),
+            point_arg.clone(),
+            round_arg.clone(),
+            reward_cycle_arg.clone(),
+        ];
 
         let signer = Signer::from(signer_config.clone());
         // Create a invalid transaction that is not a contract call
@@ -1983,7 +1825,36 @@ mod tests {
                 .unwrap();
             assert!(!result);
         }
+    }
+
+    #[test]
+    #[serial]
+    fn verify_transaction_filters_invalid_reward_cycle() {
+        // Create a runloop of a valid signer
+        let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
+        let mut signer_config = generate_signer_config(&config, 5, 20);
+        signer_config.reward_cycle = 1;
 
+        let signer = Signer::from(signer_config.clone());
+
+        let stacks_client = StacksClient::from(&config);
+        let signer_private_key = config.stacks_private_key;
+        let vote_contract_id = boot_code_id(SIGNERS_VOTING_NAME, signer.mainnet);
+        let contract_addr = vote_contract_id.issuer.into();
+        let contract_name = vote_contract_id.name.clone();
+        let signer_index = Value::UInt(signer.signer_id as u128);
+        let point = Point::from(Scalar::random(&mut thread_rng()));
+        let point_arg =
+            Value::buff_from(point.compress().data.to_vec()).expect("Failed to create buff");
+        let round = thread_rng().next_u64();
+        let round_arg = Value::UInt(round as u128);
+        let reward_cycle_arg = Value::UInt(signer.reward_cycle as u128);
+        let valid_function_args = vec![
+            signer_index.clone(),
+            point_arg.clone(),
+            round_arg.clone(),
+            reward_cycle_arg.clone(),
+        ];
         // Invalid reward cycle (voting for the current is not allowed. only the next)
         let signer = Signer::from(signer_config.clone());
         let invalid_reward_cycle = StacksClient::build_signed_contract_call_transaction(
@@ -2009,46 +1880,35 @@ mod tests {
                 .unwrap())
         });
         h.join().unwrap();
+    }
 
-        // Invalid block height to vote
-        let signer = Signer::from(signer_config.clone());
-        let stacks_client = StacksClient::from(&config);
-        let invalid_reward_set = StacksClient::build_signed_contract_call_transaction(
-            &contract_addr,
-            contract_name.clone(),
-            VOTE_FUNCTION_NAME.into(),
-            &valid_function_args,
-            &signer_private_key,
-            TransactionVersion::Testnet,
-            config.network.to_chain_id(),
-            1,
-            10,
-        )
-        .unwrap();
+    #[test]
+    #[serial]
+    fn verify_transaction_filters_already_voted() {
+        // Create a runloop of a valid signer
+        let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
+        let mut signer_config = generate_signer_config(&config, 5, 20);
+        signer_config.reward_cycle = 1;
 
-        // Invalid reward set not calculated (not in the second block onwards of the prepare phase)
-        let pox_info_response = build_get_pox_data_response(
-            Some(signer.reward_cycle.saturating_sub(1)),
-            Some(0),
-            None,
-            None,
-        )
-        .0;
-        let peer_info = build_get_peer_info_response(Some(0), None).0;
+        let signer = Signer::from(signer_config.clone());
 
-        let h = spawn(move || {
-            assert!(!signer
-                .verify_payload(
-                    &stacks_client,
-                    &invalid_reward_set,
-                    signer.signer_id,
-                    signer.reward_cycle.saturating_sub(1)
-                )
-                .unwrap())
-        });
-        mock_server_from_config_and_write_response(&config, pox_info_response.as_bytes());
-        mock_server_from_config_and_write_response(&config, peer_info.as_bytes());
-        h.join().unwrap();
+        let signer_private_key = config.stacks_private_key;
+        let vote_contract_id = boot_code_id(SIGNERS_VOTING_NAME, signer.mainnet);
+        let contract_addr = vote_contract_id.issuer.into();
+        let contract_name = vote_contract_id.name.clone();
+        let signer_index = Value::UInt(signer.signer_id as u128);
+        let point = Point::from(Scalar::random(&mut thread_rng()));
+        let point_arg =
+            Value::buff_from(point.compress().data.to_vec()).expect("Failed to create buff");
+        let round = thread_rng().next_u64();
+        let round_arg = Value::UInt(round as u128);
+        let reward_cycle_arg = Value::UInt(signer.reward_cycle as u128);
+        let valid_function_args = vec![
+            signer_index.clone(),
+            point_arg.clone(),
+            round_arg.clone(),
+            reward_cycle_arg.clone(),
+        ];
 
         // Already voted
         let signer = Signer::from(signer_config.clone());
@@ -2066,14 +1926,6 @@ mod tests {
         )
         .unwrap();
 
-        let pox_info_response = build_get_pox_data_response(
-            Some(signer.reward_cycle.saturating_sub(1)),
-            Some(0),
-            None,
-            None,
-        )
-        .0;
-        let peer_info = build_get_peer_info_response(Some(1), None).0;
         let vote_response = build_get_approved_aggregate_key_response(Some(point));
 
         let h = spawn(move || {
@@ -2086,25 +1938,44 @@ mod tests {
                 )
                 .unwrap())
         });
-        mock_server_from_config_and_write_response(&config, pox_info_response.as_bytes());
-        mock_server_from_config_and_write_response(&config, peer_info.as_bytes());
         mock_server_from_config_and_write_response(&config, vote_response.as_bytes());
         h.join().unwrap();
+    }
 
-        // Already voted
+    #[test]
+    #[serial]
+    fn verify_transaction_filters_ivalid_round_number() {
+        // Create a runloop of a valid signer
+        let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
+        let mut signer_config = generate_signer_config(&config, 5, 20);
+        signer_config.reward_cycle = 1;
+
+        let signer = Signer::from(signer_config.clone());
+
+        let signer_private_key = config.stacks_private_key;
+        let vote_contract_id = boot_code_id(SIGNERS_VOTING_NAME, signer.mainnet);
+        let contract_addr = vote_contract_id.issuer.into();
+        let contract_name = vote_contract_id.name.clone();
+        let signer_index = Value::UInt(signer.signer_id as u128);
+        let point = Point::from(Scalar::random(&mut thread_rng()));
+        let point_arg =
+            Value::buff_from(point.compress().data.to_vec()).expect("Failed to create buff");
+        let round = thread_rng().next_u64();
+        let round_arg = Value::UInt(round as u128);
+        let reward_cycle_arg = Value::UInt(signer.reward_cycle as u128);
+        let valid_function_args = vec![
+            signer_index.clone(),
+            point_arg.clone(),
+            round_arg.clone(),
+            reward_cycle_arg.clone(),
+        ];
         let signer = Signer::from(signer_config.clone());
         let stacks_client = StacksClient::from(&config);
-        let round: u128 = 0;
-        let invalid_already_voted = StacksClient::build_signed_contract_call_transaction(
+        let invalid_round_number = StacksClient::build_signed_contract_call_transaction(
             &contract_addr,
             contract_name.clone(),
             VOTE_FUNCTION_NAME.into(),
-            &[
-                Value::UInt(signer.signer_id as u128),
-                Value::buff_from(point.compress().data.to_vec()).expect("Failed to create buff"),
-                Value::UInt(round.saturating_add(3)),
-                Value::UInt(signer.reward_cycle as u128),
-            ],
+            &valid_function_args,
             &signer_private_key,
             TransactionVersion::Testnet,
             config.network.to_chain_id(),
@@ -2114,14 +1985,6 @@ mod tests {
         .unwrap();
 
         // invalid round number
-        let pox_info_response = build_get_pox_data_response(
-            Some(signer.reward_cycle.saturating_sub(1)),
-            Some(0),
-            None,
-            None,
-        )
-        .0;
-        let peer_info = build_get_peer_info_response(Some(1), None).0;
         let vote_response = build_get_approved_aggregate_key_response(None);
         let last_round_response = build_get_last_round_response(0);
 
@@ -2129,14 +1992,12 @@ mod tests {
             assert!(!signer
                 .verify_payload(
                     &stacks_client,
-                    &invalid_already_voted,
+                    &invalid_round_number,
                     signer.signer_id,
                     signer.reward_cycle.saturating_sub(1)
                 )
                 .unwrap())
         });
-        mock_server_from_config_and_write_response(&config, pox_info_response.as_bytes());
-        mock_server_from_config_and_write_response(&config, peer_info.as_bytes());
         mock_server_from_config_and_write_response(&config, vote_response.as_bytes());
         mock_server_from_config_and_write_response(&config, last_round_response.as_bytes());
         h.join().unwrap();
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 830ae6dcff..e97aefd42a 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -659,11 +659,11 @@ pub fn boot_to_epoch_3_reward_set(
                 pox_addr_tuple.clone(),
                 clarity::vm::Value::UInt(block_height as u128),
                 clarity::vm::Value::UInt(lock_period),
-                clarity::vm::Value::buff_from(signature).unwrap(),
+                clarity::vm::Value::some(clarity::vm::Value::buff_from(signature).unwrap())
+                    .unwrap(),
                 clarity::vm::Value::buff_from(signer_pk.to_bytes_compressed()).unwrap(),
             ],
         );
-
         submit_tx(&http_origin, &stacking_tx);
     }
 
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index f892183191..aa1706e313 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -155,16 +155,174 @@ impl SignerTest {
             .expect("Failed to get approved aggregate key")
             .expect("No approved aggregate key found");
         assert_eq!(set_dkg, dkg_vote);
-        info!("Booted Test Signers to Epoch 3.0 boundary. DKG successfully approved. Ready to sign blocks.");
+
+        let (vrfs_submitted, commits_submitted) = (
+            self.running_nodes.vrfs_submitted.clone(),
+            self.running_nodes.commits_submitted.clone(),
+        );
+        // first block wakes up the run loop, wait until a key registration has been submitted.
+        next_block_and(&mut self.running_nodes.btc_regtest_controller, 60, || {
+            let vrf_count = vrfs_submitted.load(Ordering::SeqCst);
+            Ok(vrf_count >= 1)
+        })
+        .unwrap();
+
+        info!("Successfully triggered first block to wake up the miner runloop.");
+        // second block should confirm the VRF register, wait until a block commit is submitted
+        next_block_and(&mut self.running_nodes.btc_regtest_controller, 60, || {
+            let commits_count = commits_submitted.load(Ordering::SeqCst);
+            Ok(commits_count >= 1)
+        })
+        .unwrap();
+        info!("Ready to mine Nakamoto blocks!");
         set_dkg
     }
 
+    fn nmb_blocks_to_reward_set_calculation(&mut self) -> u64 {
+        let prepare_phase_len = self
+            .running_nodes
+            .conf
+            .get_burnchain()
+            .pox_constants
+            .prepare_length as u64;
+        let current_block_height = self
+            .running_nodes
+            .btc_regtest_controller
+            .get_headers_height();
+        let curr_reward_cycle = self.get_current_reward_cycle();
+        let next_reward_cycle = curr_reward_cycle.wrapping_add(1);
+        let next_reward_cycle_height = self
+            .running_nodes
+            .btc_regtest_controller
+            .get_burnchain()
+            .reward_cycle_to_block_height(next_reward_cycle);
+        let next_reward_cycle_reward_set_calculation = next_reward_cycle_height
+            .saturating_sub(prepare_phase_len)
+            .wrapping_add(1); // +1 as the reward calculation occurs in the SECOND block of the prepare phase
+        next_reward_cycle_reward_set_calculation.saturating_sub(current_block_height)
+    }
+
+    fn nmb_blocks_to_reward_cycle_boundary(&mut self, reward_cycle: u64) -> u64 {
+        let current_block_height = self
+            .running_nodes
+            .btc_regtest_controller
+            .get_headers_height();
+        let reward_cycle_height = self
+            .running_nodes
+            .btc_regtest_controller
+            .get_burnchain()
+            .reward_cycle_to_block_height(reward_cycle);
+        reward_cycle_height
+            .saturating_sub(current_block_height)
+            .saturating_sub(1)
+    }
+
+    // Only call after already past the epoch 3.0 boundary
+    fn run_to_dkg(&mut self, timeout: Duration) -> Option<Point> {
+        let curr_reward_cycle = self.get_current_reward_cycle();
+        let set_dkg = self
+            .stacks_client
+            .get_approved_aggregate_key(curr_reward_cycle)
+            .expect("Failed to get approved aggregate key")
+            .expect("No approved aggregate key found");
+        let nmb_blocks_to_mine_to_dkg = self.nmb_blocks_to_reward_set_calculation();
+        let end_block_height = self
+            .running_nodes
+            .btc_regtest_controller
+            .get_headers_height()
+            .wrapping_add(nmb_blocks_to_mine_to_dkg);
+        info!("Mining {nmb_blocks_to_mine_to_dkg} Nakamoto block(s) to reach DKG calculation at block height {end_block_height}");
+        for i in 1..=nmb_blocks_to_mine_to_dkg {
+            info!("Mining Nakamoto block #{i} of {nmb_blocks_to_mine_to_dkg}");
+            self.mine_nakamoto_block(timeout);
+            let hash = self.wait_for_validate_ok_response(timeout);
+            let signatures = self.wait_for_frost_signatures(timeout);
+            // Verify the signers accepted the proposed block and are using the new DKG to sign it
+            for signature in &signatures {
+                assert!(signature.verify(&set_dkg, hash.0.as_slice()));
+            }
+        }
+        if nmb_blocks_to_mine_to_dkg == 0 {
+            None
+        } else {
+            Some(self.wait_for_dkg(timeout))
+        }
+    }
+
+    // Only call after already past the epoch 3.0 boundary
+    fn run_until_burnchain_height_nakamoto(
+        &mut self,
+        timeout: Duration,
+        burnchain_height: u64,
+    ) -> Vec<Point> {
+        let mut points = vec![];
+        let current_block_height = self
+            .running_nodes
+            .btc_regtest_controller
+            .get_headers_height();
+        let mut total_nmb_blocks_to_mine = burnchain_height.saturating_sub(current_block_height);
+        debug!("Mining {total_nmb_blocks_to_mine} Nakamoto block(s) to reach burnchain height {burnchain_height}");
+        let mut nmb_blocks_to_reward_cycle = 0;
+        let mut blocks_to_dkg = self.nmb_blocks_to_reward_set_calculation();
+        while total_nmb_blocks_to_mine > 0 && blocks_to_dkg > 0 {
+            if blocks_to_dkg > 0 && total_nmb_blocks_to_mine >= blocks_to_dkg {
+                let dkg = self.run_to_dkg(timeout);
+                total_nmb_blocks_to_mine -= blocks_to_dkg;
+                if dkg.is_some() {
+                    points.push(dkg.unwrap());
+                }
+                blocks_to_dkg = 0;
+                nmb_blocks_to_reward_cycle = self.nmb_blocks_to_reward_cycle_boundary(
+                    self.get_current_reward_cycle().wrapping_add(1),
+                )
+            }
+            if total_nmb_blocks_to_mine >= nmb_blocks_to_reward_cycle {
+                debug!("Mining {nmb_blocks_to_reward_cycle} Nakamoto block(s) to reach the next reward cycle boundary.");
+                for i in 1..=nmb_blocks_to_reward_cycle {
+                    debug!("Mining Nakamoto block #{i} of {nmb_blocks_to_reward_cycle}");
+                    let curr_reward_cycle = self.get_current_reward_cycle();
+                    let set_dkg = self
+                        .stacks_client
+                        .get_approved_aggregate_key(curr_reward_cycle)
+                        .expect("Failed to get approved aggregate key")
+                        .expect("No approved aggregate key found");
+                    self.mine_nakamoto_block(timeout);
+                    let hash = self.wait_for_validate_ok_response(timeout);
+                    let signatures = self.wait_for_frost_signatures(timeout);
+                    // Verify the signers accepted the proposed block and are using the new DKG to sign it
+                    for signature in &signatures {
+                        assert!(signature.verify(&set_dkg, hash.0.as_slice()));
+                    }
+                }
+                total_nmb_blocks_to_mine -= nmb_blocks_to_reward_cycle;
+                nmb_blocks_to_reward_cycle = 0;
+                blocks_to_dkg = self.nmb_blocks_to_reward_set_calculation();
+            }
+        }
+        for _ in 1..=total_nmb_blocks_to_mine {
+            let curr_reward_cycle = self.get_current_reward_cycle();
+            let set_dkg = self
+                .stacks_client
+                .get_approved_aggregate_key(curr_reward_cycle)
+                .expect("Failed to get approved aggregate key")
+                .expect("No approved aggregate key found");
+            self.mine_nakamoto_block(timeout);
+            let hash = self.wait_for_validate_ok_response(timeout);
+            let signatures = self.wait_for_frost_signatures(timeout);
+            // Verify the signers accepted the proposed block and are using the new DKG to sign it
+            for signature in &signatures {
+                assert!(signature.verify(&set_dkg, hash.0.as_slice()));
+            }
+        }
+        points
+    }
+
     fn mine_nakamoto_block(&mut self, timeout: Duration) -> MinedNakamotoBlockEvent {
         let commits_submitted = self.running_nodes.commits_submitted.clone();
         let mined_block_time = Instant::now();
         next_block_and_mine_commit(
             &mut self.running_nodes.btc_regtest_controller,
-            60,
+            timeout.as_secs(),
             &self.running_nodes.coord_channel,
             &commits_submitted,
         )
@@ -197,7 +355,9 @@ impl SignerTest {
             );
             thread::sleep(Duration::from_secs(1));
         }
-        let validate_response = test_observer::get_proposal_responses().pop().expect("No block proposal");
+        let validate_response = test_observer::get_proposal_responses()
+            .pop()
+            .expect("No block proposal");
         match validate_response {
             BlockValidateResponse::Ok(block_validated) => block_validated.signer_signature_hash,
             _ => panic!("Unexpected response"),
@@ -393,8 +553,7 @@ impl SignerTest {
         self.signer_cmd_senders.get(coordinator_index).unwrap()
     }
 
-    fn get_signer_index(&self) -> u32 {
-        let reward_cycle = self.get_current_reward_cycle();
+    fn get_signer_index(&self, reward_cycle: u64) -> u32 {
         let valid_signer_set =
             u32::try_from(reward_cycle % 2).expect("FATAL: reward_cycle % 2 exceeds u32::MAX");
         let signer_stackerdb_contract_id = boot_code_id(SIGNERS_NAME, false);
@@ -408,33 +567,6 @@ impl SignerTest {
             .expect("FATAL: signer not registered")
     }
 
-    fn generate_valid_transaction(&self) -> StacksTransaction {
-        // Get the signer indices
-        let reward_cycle = self.get_current_reward_cycle();
-        let valid_signer_index = self.get_signer_index();
-        let nonce = self
-            .stacks_client
-            .get_account_nonce(self.stacks_client.get_signer_address())
-            .expect("FATAL: failed to get nonce");
-        let round = self
-            .stacks_client
-            .get_last_round(reward_cycle)
-            .expect("FATAL: failed to get round")
-            .unwrap_or(0)
-            .wrapping_add(1);
-        let point = Point::from(Scalar::random(&mut rand::thread_rng()));
-        self.stacks_client
-            .build_vote_for_aggregate_public_key(
-                valid_signer_index,
-                round,
-                point,
-                reward_cycle,
-                None,
-                nonce,
-            )
-            .expect("FATAL: failed to build vote for aggregate public key")
-    }
-
     fn generate_invalid_transactions(&self) -> Vec<StacksTransaction> {
         let host = self
             .running_nodes
@@ -447,7 +579,7 @@ impl SignerTest {
             .unwrap();
         // Get the signer indices
         let reward_cycle = self.get_current_reward_cycle();
-        let valid_signer_index = self.get_signer_index();
+        let valid_signer_index = self.get_signer_index(reward_cycle);
         let round = self
             .stacks_client
             .get_last_round(reward_cycle)
@@ -828,33 +960,6 @@ fn stackerdb_block_proposal() {
     let short_timeout = Duration::from_secs(30);
 
     let key = signer_test.boot_to_epoch_3(timeout);
-    let (vrfs_submitted, commits_submitted) = (
-        signer_test.running_nodes.vrfs_submitted.clone(),
-        signer_test.running_nodes.commits_submitted.clone(),
-    );
-    // first block wakes up the run loop, wait until a key registration has been submitted.
-    next_block_and(
-        &mut signer_test.running_nodes.btc_regtest_controller,
-        60,
-        || {
-            let vrf_count = vrfs_submitted.load(Ordering::SeqCst);
-            Ok(vrf_count >= 1)
-        },
-    )
-    .unwrap();
-
-    info!("Successfully triggered first block to wake up the miner runloop.");
-    // second block should confirm the VRF register, wait until a block commit is submitted
-    next_block_and(
-        &mut signer_test.running_nodes.btc_regtest_controller,
-        60,
-        || {
-            let commits_count = commits_submitted.load(Ordering::SeqCst);
-            Ok(commits_count >= 1)
-        },
-    )
-    .unwrap();
-
     signer_test.mine_nakamoto_block(timeout);
 
     info!("------------------------- Test Block Proposal -------------------------");
@@ -919,26 +1024,94 @@ fn stackerdb_block_proposal() {
 
 #[test]
 #[ignore]
-// TODO: FIX THIS TEST. IT SHOULD BE TESTING THAT THE MINER FILTERS OUT THE NEXT SIGNERS TRANSACTIONS
+/// Test that signers can handle a transition between Nakamoto reward cycles
+///
+/// Test Setup:
+/// The test spins up five stacks signers, one miner Nakamoto node, and a corresponding bitcoind.
+/// The stacks node is advanced to epoch 2.5, triggering a DKG round. The stacks node is then advanced
+/// to Epoch 3.0 boundary to allow block signing.
+///
+/// Test Execution:
+/// The node mines 2 full Nakamoto reward cycles, sending blocks to observing signers to sign and return.
+///
+/// Test Assertion:
+/// Signers can perform DKG and sign blocks across Nakamoto reward cycles.
+fn stackerdb_mine_2_nakamoto_reward_cycles() {
+    if env::var("BITCOIND_TEST") != Ok("1".into()) {
+        return;
+    }
+
+    tracing_subscriber::registry()
+        .with(fmt::layer())
+        .with(EnvFilter::from_default_env())
+        .init();
+
+    info!("------------------------- Test Setup -------------------------");
+    let nmb_reward_cycles = 2;
+    let mut signer_test = SignerTest::new(5);
+    let timeout = Duration::from_secs(200);
+    let first_dkg = signer_test.boot_to_epoch_3(timeout);
+    let curr_reward_cycle = signer_test.get_current_reward_cycle();
+    // Mine 2 full Nakamoto reward cycles (epoch 3 starts in the middle of one, hence the + 1)
+    let next_reward_cycle = curr_reward_cycle.saturating_add(1);
+    let final_reward_cycle = next_reward_cycle.saturating_add(nmb_reward_cycles);
+    let final_reward_cycle_height_boundary = signer_test
+        .running_nodes
+        .btc_regtest_controller
+        .get_burnchain()
+        .reward_cycle_to_block_height(final_reward_cycle)
+        .saturating_sub(1);
+
+    info!("------------------------- Test Mine 2 Nakamoto Reward Cycles -------------------------");
+    let dkgs = signer_test
+        .run_until_burnchain_height_nakamoto(timeout, final_reward_cycle_height_boundary);
+    assert_eq!(dkgs.len() as u64, nmb_reward_cycles.wrapping_add(1)); // We will have mined the DKG vote for the following reward cycle
+    let last_dkg = dkgs
+        .last()
+        .expect(&format!(
+            "Failed to reach DKG for reward cycle {final_reward_cycle_height_boundary}"
+        ))
+        .clone();
+    assert_ne!(first_dkg, last_dkg);
+
+    let set_dkg = signer_test
+        .stacks_client
+        .get_approved_aggregate_key(final_reward_cycle)
+        .expect("Failed to get approved aggregate key")
+        .expect("No approved aggregate key found");
+    assert_eq!(set_dkg, last_dkg);
+
+    let current_burnchain_height = signer_test
+        .running_nodes
+        .btc_regtest_controller
+        .get_headers_height();
+    assert_eq!(current_burnchain_height, final_reward_cycle_height_boundary);
+    signer_test.shutdown();
+}
+
+#[test]
+#[ignore]
 /// Test that signers will accept a miners block proposal and sign it if it contains all expected transactions,
 /// filtering invalid transactions from the block requirements
 ///
 /// Test Setup:
 /// The test spins up five stacks signers, one miner Nakamoto node, and a corresponding bitcoind.
 /// The stacks node is advanced to epoch 2.5, triggering a DKG round. The stacks node is then advanced
-/// to Epoch 3.0 boundary to allow block signing.
+/// to Epoch 3.0 boundary to allow block signing. It then advances to the prepare phase of the next reward cycle
+/// to enable Nakamoto signers to look at the next signer transactions to compare against a proposed block.
 ///
 /// Test Execution:
 /// The node attempts to mine a Nakamoto tenure, sending a block to the observing signers via the
 /// .miners stacker db instance. The signers submit the block to the stacks node for verification.
 /// Upon receiving a Block Validation response approving the block, the signers verify that it contains
-/// all expected transactions, being sure to filter out any invalid transactions from stackerDB as well.
+/// all of the NEXT signers' expected transactions, being sure to filter out any invalid transactions
+/// from stackerDB as well.
 ///
 /// Test Assertion:
 /// Miner proposes a block to the signers containing all expected transactions.
 /// Signers broadcast block approval with a signature back to the waiting miner.
 /// Miner includes the signers' signature in the block and finishes mining it.
-fn stackerdb_block_proposal_filters_bad_transactions() {
+fn stackerdb_filter_bad_transactions() {
     if env::var("BITCOIND_TEST") != Ok("1".into()) {
         return;
     }
@@ -949,10 +1122,16 @@ fn stackerdb_block_proposal_filters_bad_transactions() {
         .init();
 
     info!("------------------------- Test Setup -------------------------");
+    // Advance to the prepare phase of a post epoch 3.0 reward cycle to force signers to look at the next signer transactions to compare against a proposed block
     let mut signer_test = SignerTest::new(5);
     let timeout = Duration::from_secs(200);
-    let set_dkg = signer_test.boot_to_epoch_3(timeout);
+    let current_signers_dkg = signer_test.boot_to_epoch_3(timeout);
+    let next_signers_dkg = signer_test
+        .run_to_dkg(timeout)
+        .expect("Failed to run to DKG");
+    assert_ne!(current_signers_dkg, next_signers_dkg);
 
+    info!("------------------------- Submit Invalid Transactions -------------------------");
     let host = signer_test
         .running_nodes
         .conf
@@ -972,98 +1151,38 @@ fn stackerdb_block_proposal_filters_bad_transactions() {
         })
         .cloned()
         .expect("Cannot find signer private key for signer id 1");
-    let reward_cycle = signer_test.get_current_reward_cycle();
-    let signer_index = signer_test.get_signer_index();
-    let mut stackerdb = StackerDB::new(host, signer_private_key, false, reward_cycle, signer_index);
+    let next_reward_cycle = signer_test.get_current_reward_cycle().wrapping_add(1);
+    // Must submit to the NEXT reward cycle slots as they are the ones looked at by the CURRENT miners
+    let signer_index = signer_test.get_signer_index(next_reward_cycle);
+    let mut stackerdb = StackerDB::new(
+        host,
+        signer_private_key,
+        false,
+        next_reward_cycle,
+        signer_index,
+    );
 
     debug!(
         "Signer address is {}",
         &signer_test.stacks_client.get_signer_address()
     );
 
-    let valid_tx = signer_test.generate_valid_transaction();
     let invalid_txs = signer_test.generate_invalid_transactions();
-
-    let valid_txid = valid_tx.txid();
     let invalid_txids: HashSet<Txid> = invalid_txs.iter().map(|tx| tx.txid()).collect();
 
-    let mut txs = invalid_txs;
-    txs.push(valid_tx);
-
     // Submit transactions to stackerdb for the signers and miners to pick up during block verification
     stackerdb
-        .send_message_with_retry(SignerMessage::Transactions(txs))
+        .send_message_with_retry(SignerMessage::Transactions(invalid_txs))
         .expect("Failed to write expected transactions to stackerdb");
 
-    let (vrfs_submitted, commits_submitted) = (
-        signer_test.running_nodes.vrfs_submitted.clone(),
-        signer_test.running_nodes.commits_submitted.clone(),
-    );
-    // first block wakes up the run loop, wait until a key registration has been submitted.
-    next_block_and(
-        &mut signer_test.running_nodes.btc_regtest_controller,
-        60,
-        || {
-            let vrf_count = vrfs_submitted.load(Ordering::SeqCst);
-            Ok(vrf_count >= 1)
-        },
-    )
-    .unwrap();
-
-    info!("Successfully triggered first block to wake up the miner runloop.");
-    // second block should confirm the VRF register, wait until a block commit is submitted
-    next_block_and(
-        &mut signer_test.running_nodes.btc_regtest_controller,
-        60,
-        || {
-            let commits_count = commits_submitted.load(Ordering::SeqCst);
-            Ok(commits_count >= 1)
-        },
-    )
-    .unwrap();
-
+    info!("------------------------- Verify Nakamoto Block Mined -------------------------");
     let mined_block_event = signer_test.mine_nakamoto_block(timeout);
-
-    info!("------------------------- Test Block Accepted -------------------------");
-
-    // Verify the signers accepted the proposed block
-    let t_start = Instant::now();
-    let mut chunk = None;
-    while chunk.is_none() {
-        assert!(
-            t_start.elapsed() < Duration::from_secs(30),
-            "Timed out while waiting for signers block response stacker db event"
-        );
-
-        let nakamoto_blocks = test_observer::get_stackerdb_chunks();
-        for event in nakamoto_blocks {
-            // Only care about the miners block slot
-            if event.contract_id.name == format!("signers-1-{}", BLOCK_MSG_ID).as_str().into()
-                || event.contract_id.name == format!("signers-0-{}", BLOCK_MSG_ID).as_str().into()
-            {
-                for slot in event.modified_slots {
-                    chunk = Some(slot.data);
-                    break;
-                }
-                if chunk.is_some() {
-                    break;
-                }
-            }
-        }
-        thread::sleep(Duration::from_secs(1));
-    }
-    let chunk = chunk.unwrap();
-    let signer_message = read_next::<SignerMessage, _>(&mut &chunk[..]).unwrap();
-    if let SignerMessage::BlockResponse(BlockResponse::Accepted((hash, signature))) = signer_message
-    {
-        // Verify we accepted the block
-        assert!(signature.verify(&set_dkg, hash.0.as_slice()));
-    } else {
-        panic!("Received unexpected message: {:?}", &signer_message);
+    let hash = signer_test.wait_for_validate_ok_response(timeout);
+    let signatures = signer_test.wait_for_frost_signatures(timeout);
+    // Verify the signers accepted the proposed block and are using the previously determined dkg to sign it
+    for signature in &signatures {
+        assert!(signature.verify(&current_signers_dkg, hash.0.as_slice()));
     }
-
-    info!("------------------------- Verify Nakamoto Block Mined -------------------------");
-    let mut mined_valid_tx = false;
     for tx_event in &mined_block_event.tx_events {
         let TransactionEvent::Success(tx_success) = tx_event else {
             panic!("Received unexpected transaction event");
@@ -1074,157 +1193,6 @@ fn stackerdb_block_proposal_filters_bad_transactions() {
             !invalid_txids.contains(&tx_success.txid),
             "Miner included an invalid transaction in the block"
         );
-        if tx_success.txid == valid_txid {
-            mined_valid_tx = true;
-        }
-    }
-    if !mined_valid_tx {
-        panic!("Signers did not enforce the miner to include the valid transaction in the block");
-    }
-    signer_test.shutdown();
-}
-
-#[test]
-#[ignore]
-/// Test that signers can handle a transition between Nakamoto reward cycles
-///
-/// Test Setup:
-/// The test spins up five stacks signers, one miner Nakamoto node, and a corresponding bitcoind.
-/// The stacks node is advanced to epoch 2.5, triggering a DKG round. The stacks node is then advanced
-/// to Epoch 3.0 boundary to allow block signing.
-///
-/// Test Execution:
-/// The node mines multiple Nakamoto reward cycles, sending blocks to observing signers to sign and return.
-///
-/// Test Assertion:
-/// Signers perform DKG for Nakamoto reward cycle N.
-/// Signers sign Nakamoto blocks for miners in reward cycle N.
-/// Miner successfully mine these signed blocks in reward cycle N.
-/// Signers perform DKG for the next Nakamoto reward cycle N + 1.
-/// Signers sign Nakamoto blocks for miners in reward cycle N + 1.
-/// Miner successfully mine these signed blocks in reward cycle N + 1.
-fn stackerdb_reward_cycle_transitions() {
-    if env::var("BITCOIND_TEST") != Ok("1".into()) {
-        return;
-    }
-
-    tracing_subscriber::registry()
-        .with(fmt::layer())
-        .with(EnvFilter::from_default_env())
-        .init();
-
-    info!("------------------------- Test Setup -------------------------");
-    let mut signer_test = SignerTest::new(5);
-    let timeout = Duration::from_secs(200);
-    let set_dkg_1 = signer_test.boot_to_epoch_3(timeout); // Boot to epoch 3.0 boundary
-    let (vrfs_submitted, commits_submitted) = (
-        signer_test.running_nodes.vrfs_submitted.clone(),
-        signer_test.running_nodes.commits_submitted.clone(),
-    );
-    // first block wakes up the run loop, wait until a key registration has been submitted.
-    next_block_and(
-        &mut signer_test.running_nodes.btc_regtest_controller,
-        60,
-        || {
-            let vrf_count = vrfs_submitted.load(Ordering::SeqCst);
-            Ok(vrf_count >= 1)
-        },
-    )
-    .unwrap();
-
-    info!("Successfully triggered first block to wake up the miner runloop.");
-    // second block should confirm the VRF register, wait until a block commit is submitted
-    next_block_and(
-        &mut signer_test.running_nodes.btc_regtest_controller,
-        60,
-        || {
-            let commits_count = commits_submitted.load(Ordering::SeqCst);
-            Ok(commits_count >= 1)
-        },
-    )
-    .unwrap();
-
-    let curr_reward_cycle = signer_test.get_current_reward_cycle();
-    let prepare_phase_len = signer_test
-        .running_nodes
-        .conf
-        .get_burnchain()
-        .pox_constants
-        .prepare_length as u64;
-    let current_block_height = signer_test
-        .running_nodes
-        .btc_regtest_controller
-        .get_headers_height();
-    let next_reward_cycle = curr_reward_cycle.saturating_add(1);
-    let next_reward_cycle_height = signer_test
-        .running_nodes
-        .btc_regtest_controller
-        .get_burnchain()
-        .reward_cycle_to_block_height(next_reward_cycle);
-    let next_reward_cycle_reward_set_calculation = next_reward_cycle_height
-        .saturating_sub(prepare_phase_len)
-        .saturating_add(1); // +1 since second block of the prepare phase is where the reward set is calculated
-
-    info!("------------------------- Test Nakamoto Block Mining in Reward Cycle {curr_reward_cycle} -------------------------");
-
-    info!("At block height {current_block_height} in reward cycle {curr_reward_cycle}");
-
-    let nmb_blocks_to_mine =
-        next_reward_cycle_reward_set_calculation.saturating_sub(current_block_height);
-    info!(
-        "Mining {} Nakamoto blocks to reach next reward cycle reward set calculation at block height {next_reward_cycle_reward_set_calculation}",
-        nmb_blocks_to_mine
-    );
-    for i in 1..=nmb_blocks_to_mine {
-        info!("Mining Nakamoto block #{i} of {nmb_blocks_to_mine}");
-        signer_test.mine_nakamoto_block(timeout);
-        signer_test.wait_for_validate_ok_response(timeout);
-        signer_test.wait_for_frost_signatures(timeout);
-    }
-
-    info!("------------------------- Test DKG for Next Reward Cycle {next_reward_cycle} -------------------------");
-    let current_block_height = signer_test
-        .running_nodes
-        .btc_regtest_controller
-        .get_headers_height();
-
-    info!("At block height {current_block_height} in reward cycle {curr_reward_cycle}");
-    info!("Wait for the next reward cycle {next_reward_cycle} dkg to be calculated by the new signers");
-
-    let set_dkg_2 = signer_test.wait_for_dkg(timeout);
-    assert_ne!(set_dkg_1, set_dkg_2);
-
-    info!("DKG has been calculated for the next reward cycle {next_reward_cycle}");
-
-    info!("Mining Nakamoto blocks to reach next reward cycle {next_reward_cycle}.",);
-    let mut i = 1u32;
-    while signer_test.get_current_reward_cycle() != next_reward_cycle {
-        info!("Mining Nakamoto block #{i} to reach next reward cycle {next_reward_cycle}...");
-        signer_test.mine_nakamoto_block(timeout);
-        signer_test.wait_for_validate_ok_response(timeout);
-        signer_test.wait_for_frost_signatures(timeout);
-        i = i.wrapping_add(1);
-    }
-
-    info!("------------------------- Test Nakamoto Block Mining in Reward Cycle {next_reward_cycle} -------------------------");
-    // First make sure that the aggregate key was actually mined.
-    let set_dkg = signer_test
-        .stacks_client
-        .get_approved_aggregate_key(next_reward_cycle)
-        .expect("Failed to get approved aggregate key")
-        .expect("No approved aggregate key found");
-    assert_eq!(set_dkg, set_dkg_2);
-
-    info!(
-        "Mining first Nakamoto block of reward cycle {}...",
-        next_reward_cycle
-    );
-    signer_test.mine_nakamoto_block(timeout);
-    let hash = signer_test.wait_for_validate_ok_response(timeout);
-    let signatures = signer_test.wait_for_frost_signatures(timeout);
-    // Verify the signers accepted the proposed block and are using the new DKG to sign it
-    for signature in &signatures {
-        assert!(signature.verify(&set_dkg_2, hash.0.as_slice()));
     }
     signer_test.shutdown();
 }

From 838f06fda2872f8d714ecaa4fd7062349f2f122b Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Thu, 22 Feb 2024 09:07:16 -0500
Subject: [PATCH 0915/1166] Fix test simple signer test by fixing contract id

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 libsigner/src/tests/mod.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/libsigner/src/tests/mod.rs b/libsigner/src/tests/mod.rs
index d3840122c1..9f320b42fc 100644
--- a/libsigner/src/tests/mod.rs
+++ b/libsigner/src/tests/mod.rs
@@ -22,6 +22,7 @@ use std::sync::mpsc::{channel, Receiver, Sender};
 use std::time::Duration;
 use std::{mem, thread};
 
+use blockstack_lib::chainstate::nakamoto::signer_set::NakamotoSigners;
 use blockstack_lib::chainstate::stacks::boot::SIGNERS_NAME;
 use blockstack_lib::chainstate::stacks::events::StackerDBChunksEvent;
 use blockstack_lib::util_lib::boot::boot_code_id;
@@ -95,7 +96,7 @@ impl SignerRunLoop<Vec<SignerEvent>, Command> for SimpleRunLoop {
 /// and the signer runloop.
 #[test]
 fn test_simple_signer() {
-    let contract_id = boot_code_id(SIGNERS_NAME, false);
+    let contract_id = NakamotoSigners::make_signers_db_contract_id(0, 0, false);
     let ev = SignerEventReceiver::new(false);
     let (_cmd_send, cmd_recv) = channel();
     let (res_send, _res_recv) = channel();

From 0bc644220085b7c4abf5b362679effe975c21e46 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Thu, 22 Feb 2024 11:26:27 -0500
Subject: [PATCH 0916/1166] Fix test_make_miners_stackerdb_config by adding
 missing miners contract to peer config

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stackslib/src/chainstate/nakamoto/coordinator/tests.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index cb07233f27..721149789a 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -244,6 +244,9 @@ pub fn boot_nakamoto<'a>(
     // reward cycle 6 instantiates pox-3
     // we stack in reward cycle 7 so pox-3 is evaluated to find reward set participation
     peer_config.aggregate_public_key = Some(aggregate_public_key.clone());
+    peer_config
+        .stacker_dbs
+        .push(boot_code_id(MINERS_NAME, false));
     peer_config.epochs = Some(StacksEpoch::unit_test_3_0_only(37));
     peer_config.initial_balances = vec![(addr.to_account_principal(), 1_000_000_000_000_000_000)];
 

From 66c6862ecccc5805447e9b183a38fda0dafbdfcb Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Thu, 22 Feb 2024 11:46:59 -0500
Subject: [PATCH 0917/1166] Move get_signer_weights function to signer_set.rs

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 .../src/chainstate/nakamoto/signer_set.rs     | 36 +++++++++++++++++++
 stackslib/src/chainstate/stacks/boot/mod.rs   | 36 -------------------
 .../stacks-node/src/nakamoto_node/miner.rs    |  8 +++--
 3 files changed, 42 insertions(+), 38 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/signer_set.rs b/stackslib/src/chainstate/nakamoto/signer_set.rs
index 0eeae3d131..d9f3aafeaa 100644
--- a/stackslib/src/chainstate/nakamoto/signer_set.rs
+++ b/stackslib/src/chainstate/nakamoto/signer_set.rs
@@ -445,4 +445,40 @@ impl NakamotoSigners {
         let name = Self::make_signers_db_name(reward_cycle, message_id);
         boot_code_id(&name, mainnet)
     }
+
+    /// Get the signer addresses and corresponding weights for a given reward cycle
+    pub fn get_signers_weights(
+        chainstate: &mut StacksChainState,
+        sortdb: &SortitionDB,
+        block_id: &StacksBlockId,
+        reward_cycle: u64,
+    ) -> Result<HashMap<StacksAddress, u64>, ChainstateError> {
+        let signers_opt = chainstate
+            .eval_boot_code_read_only(
+                sortdb,
+                block_id,
+                SIGNERS_NAME,
+                &format!("(get-signers u{})", reward_cycle),
+            )?
+            .expect_optional()?;
+        let mut signers = HashMap::new();
+        if let Some(signers_list) = signers_opt {
+            for signer in signers_list.expect_list()? {
+                let signer_tuple = signer.expect_tuple()?;
+                let principal_data = signer_tuple.get("signer")?.clone().expect_principal()?;
+                let signer_address = if let PrincipalData::Standard(signer) = principal_data {
+                    signer.into()
+                } else {
+                    panic!(
+                        "FATAL: Signer returned from get-signers is not a standard principal: {:?}",
+                        principal_data
+                    );
+                };
+                let weight = u64::try_from(signer_tuple.get("weight")?.to_owned().expect_u128()?)
+                    .expect("FATAL: Signer weight greater than a u64::MAX");
+                signers.insert(signer_address, weight);
+            }
+        }
+        Ok(signers)
+    }
 }
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 9e1f5d5922..7d6d141e10 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -1308,42 +1308,6 @@ impl StacksChainState {
         };
         Ok(aggregate_public_key)
     }
-
-    /// Get the signer addresses and corresponding weights for a given reward cycle
-    pub fn get_signers_weights(
-        &mut self,
-        sortdb: &SortitionDB,
-        block_id: &StacksBlockId,
-        reward_cycle: u64,
-    ) -> Result<HashMap<StacksAddress, u64>, Error> {
-        let signers_opt = self
-            .eval_boot_code_read_only(
-                sortdb,
-                block_id,
-                SIGNERS_NAME,
-                &format!("(get-signers u{})", reward_cycle),
-            )?
-            .expect_optional()?;
-        let mut signers = HashMap::new();
-        if let Some(signers_list) = signers_opt {
-            for signer in signers_list.expect_list()? {
-                let signer_tuple = signer.expect_tuple()?;
-                let principal_data = signer_tuple.get("signer")?.clone().expect_principal()?;
-                let signer_address = if let PrincipalData::Standard(signer) = principal_data {
-                    signer.into()
-                } else {
-                    panic!(
-                        "FATAL: Signer returned from get-signers is not a standard principal: {:?}",
-                        principal_data
-                    );
-                };
-                let weight = u64::try_from(signer_tuple.get("weight")?.to_owned().expect_u128()?)
-                    .expect("FATAL: Signer weight greater than a u64::MAX");
-                signers.insert(signer_address, weight);
-            }
-        }
-        Ok(signers)
-    }
 }
 
 #[cfg(test)]
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index 13ec10dfab..5f39e43726 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -516,8 +516,12 @@ impl BlockMinerThread {
             .burnchain
             .block_height_to_reward_cycle(self.burn_block.block_height)
             .expect("FATAL: no reward cycle for burn block");
-        let signer_weights =
-            chain_state.get_signers_weights(&sort_db, &self.parent_tenure_id, reward_cycle)?;
+        let signer_weights = NakamotoSigners::get_signers_weights(
+            &mut chain_state,
+            &sort_db,
+            &self.parent_tenure_id,
+            reward_cycle,
+        )?;
         let signature = self
             .wait_for_signer_signature(
                 &stackerdbs,

From 69d25fb0dd3060acefdf34594b786eda20f2277f Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Thu, 22 Feb 2024 22:02:12 -0500
Subject: [PATCH 0918/1166] CRC: cleanup var names and add comment to
 SignerMessages

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 libsigner/src/events.rs         |  1 +
 stacks-signer/src/client/mod.rs |  2 +-
 stacks-signer/src/config.rs     | 10 +++++-----
 stacks-signer/src/runloop.rs    |  2 +-
 stacks-signer/src/signer.rs     |  6 +++---
 5 files changed, 11 insertions(+), 10 deletions(-)

diff --git a/libsigner/src/events.rs b/libsigner/src/events.rs
index dfc2557877..2c5ecdda13 100644
--- a/libsigner/src/events.rs
+++ b/libsigner/src/events.rs
@@ -56,6 +56,7 @@ pub enum SignerEvent {
     /// The miner proposed blocks for signers to observe and sign
     ProposedBlocks(Vec<NakamotoBlock>),
     /// The signer messages for other signers and miners to observe
+    /// The u32 is the signer set to which the message belongs (either 0 or 1)
     SignerMessages(u32, Vec<SignerMessage>),
     /// A new block proposal validation response from the node
     BlockValidationResponse(BlockValidateResponse),
diff --git a/stacks-signer/src/client/mod.rs b/stacks-signer/src/client/mod.rs
index 1e38bf0166..959ce56dbf 100644
--- a/stacks-signer/src/client/mod.rs
+++ b/stacks-signer/src/client/mod.rs
@@ -521,7 +521,7 @@ pub(crate) mod tests {
             dkg_public_timeout: config.dkg_public_timeout,
             nonce_timeout: config.nonce_timeout,
             sign_timeout: config.sign_timeout,
-            tx_fee_ms: config.tx_fee_ms,
+            tx_fee_ustx: config.tx_fee_ustx,
         }
     }
 }
diff --git a/stacks-signer/src/config.rs b/stacks-signer/src/config.rs
index c85f72d932..df9e2db404 100644
--- a/stacks-signer/src/config.rs
+++ b/stacks-signer/src/config.rs
@@ -36,7 +36,7 @@ use wsts::state_machine::PublicKeys;
 const EVENT_TIMEOUT_MS: u64 = 5000;
 // Default transaction fee in microstacks (if unspecificed in the config file)
 // TODO: Use the fee estimation endpoint to get the default fee.
-const TX_FEE_MS: u64 = 10_000;
+const TX_FEE_USTX: u64 = 10_000;
 
 #[derive(thiserror::Error, Debug)]
 /// An error occurred parsing the provided configuration
@@ -161,7 +161,7 @@ pub struct SignerConfig {
     /// timeout to gather signature shares
     pub sign_timeout: Option<Duration>,
     /// the STX tx fee to use in uSTX
-    pub tx_fee_ms: u64,
+    pub tx_fee_ustx: u64,
 }
 
 /// The parsed configuration for the signer
@@ -192,7 +192,7 @@ pub struct GlobalConfig {
     /// timeout to gather signature shares
     pub sign_timeout: Option<Duration>,
     /// the STX tx fee to use in uSTX
-    pub tx_fee_ms: u64,
+    pub tx_fee_ustx: u64,
 }
 
 /// Internal struct for loading up the config file
@@ -220,7 +220,7 @@ struct RawConfigFile {
     /// timeout in (millisecs) to gather signature shares
     pub sign_timeout_ms: Option<u64>,
     /// the STX tx fee to use in uSTX
-    pub tx_fee_ms: Option<u64>,
+    pub tx_fee_ustx: Option<u64>,
 }
 
 impl RawConfigFile {
@@ -318,7 +318,7 @@ impl TryFrom<RawConfigFile> for GlobalConfig {
             dkg_private_timeout,
             nonce_timeout,
             sign_timeout,
-            tx_fee_ms: raw_data.tx_fee_ms.unwrap_or(TX_FEE_MS),
+            tx_fee_ustx: raw_data.tx_fee_ustx.unwrap_or(TX_FEE_USTX),
         })
     }
 }
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index f5ab41913c..a2f710c60c 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -123,7 +123,7 @@ impl RunLoop {
             dkg_public_timeout: self.config.dkg_public_timeout,
             nonce_timeout: self.config.nonce_timeout,
             sign_timeout: self.config.sign_timeout,
-            tx_fee_ms: self.config.tx_fee_ms,
+            tx_fee_ustx: self.config.tx_fee_ustx,
         })
     }
 
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index 45ac6a49d3..3c2ecc0b0c 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -142,7 +142,7 @@ pub struct Signer {
     /// The reward cycle this signer belongs to
     pub reward_cycle: u64,
     /// The tx fee in uSTX to use if the epoch is pre Nakamoto (Epoch 3.0)
-    pub tx_fee_ms: u64,
+    pub tx_fee_ustx: u64,
     /// The coordinator info for the signer
     pub coordinator_selector: CoordinatorSelector,
 }
@@ -211,7 +211,7 @@ impl From<SignerConfig> for Signer {
             next_signer_ids: vec![],
             next_signer_slot_ids: HashMap::new(),
             reward_cycle: signer_config.reward_cycle,
-            tx_fee_ms: signer_config.tx_fee_ms,
+            tx_fee_ustx: signer_config.tx_fee_ustx,
             coordinator_selector,
         }
     }
@@ -1006,7 +1006,7 @@ impl Signer {
                 "Signer #{}: in pre Epoch 3.0 cycles, must set a transaction fee for the DKG vote.",
                 self.signer_id
             );
-            Some(self.tx_fee_ms)
+            Some(self.tx_fee_ustx)
         } else {
             None
         };

From 1de817b2f1300dcf3030278913accf122bfa0f1d Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 23 Feb 2024 10:25:39 -0500
Subject: [PATCH 0919/1166] Fix fee calculation and always broadcast Sign
 errors as block rejections

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 libsigner/src/messages.rs   |  69 ++++++++++++++++++--
 stacks-signer/src/signer.rs | 126 +++++++++++++++++-------------------
 2 files changed, 126 insertions(+), 69 deletions(-)

diff --git a/libsigner/src/messages.rs b/libsigner/src/messages.rs
index 7ac4b9e463..b911dba15d 100644
--- a/libsigner/src/messages.rs
+++ b/libsigner/src/messages.rs
@@ -139,7 +139,9 @@ define_u8_enum!(RejectCodeTypePrefix{
     SignedRejection = 1,
     InsufficientSigners = 2,
     MissingTransactions = 3,
-    ConnectivityIssues = 4
+    ConnectivityIssues = 4,
+    NonceTimeout = 5,
+    AggregatorError = 6
 });
 
 impl TryFrom<u8> for RejectCodeTypePrefix {
@@ -159,6 +161,8 @@ impl From<&RejectCode> for RejectCodeTypePrefix {
             RejectCode::InsufficientSigners(_) => RejectCodeTypePrefix::InsufficientSigners,
             RejectCode::MissingTransactions(_) => RejectCodeTypePrefix::MissingTransactions,
             RejectCode::ConnectivityIssues => RejectCodeTypePrefix::ConnectivityIssues,
+            RejectCode::NonceTimeout(_) => RejectCodeTypePrefix::NonceTimeout,
+            RejectCode::AggregatorError(_) => RejectCodeTypePrefix::AggregatorError,
         }
     }
 }
@@ -938,8 +942,12 @@ pub enum RejectCode {
     ValidationFailed(ValidateRejectCode),
     /// Signers signed a block rejection
     SignedRejection(ThresholdSignature),
+    /// Nonce timeout was reached
+    NonceTimeout(Vec<u32>),
     /// Insufficient signers agreed to sign the block
     InsufficientSigners(Vec<u32>),
+    /// An internal error occurred in the signer when aggregating the signaure
+    AggregatorError(String),
     /// Missing the following expected transactions
     MissingTransactions(Vec<StacksTransaction>),
     /// The block was rejected due to connectivity issues with the signer
@@ -952,12 +960,12 @@ impl StacksMessageCodec for RejectCode {
         match self {
             RejectCode::ValidationFailed(code) => write_next(fd, &(code.clone() as u8))?,
             RejectCode::SignedRejection(sig) => write_next(fd, sig)?,
-            RejectCode::InsufficientSigners(malicious_signers) => {
-                write_next(fd, malicious_signers)?
-            }
+            RejectCode::InsufficientSigners(malicious_signers)
+            | RejectCode::NonceTimeout(malicious_signers) => write_next(fd, malicious_signers)?,
             RejectCode::MissingTransactions(missing_transactions) => {
                 write_next(fd, missing_transactions)?
             }
+            RejectCode::AggregatorError(reason) => write_next(fd, &reason.as_bytes().to_vec())?,
             RejectCode::ConnectivityIssues => write_next(fd, &4u8)?,
         };
         Ok(())
@@ -984,7 +992,20 @@ impl StacksMessageCodec for RejectCode {
             RejectCodeTypePrefix::MissingTransactions => {
                 RejectCode::MissingTransactions(read_next::<Vec<StacksTransaction>, _>(fd)?)
             }
+            RejectCodeTypePrefix::NonceTimeout => {
+                RejectCode::NonceTimeout(read_next::<Vec<u32>, _>(fd)?)
+            }
             RejectCodeTypePrefix::ConnectivityIssues => RejectCode::ConnectivityIssues,
+            RejectCodeTypePrefix::AggregatorError => {
+                let reason_bytes = read_next::<Vec<u8>, _>(fd)?;
+                let reason = String::from_utf8(reason_bytes).map_err(|e| {
+                    CodecError::DeserializeError(format!(
+                        "Failed to decode reason string: {:?}",
+                        &e
+                    ))
+                })?;
+                RejectCode::AggregatorError(reason)
+            }
         };
         Ok(code)
     }
@@ -1002,6 +1023,11 @@ impl std::fmt::Display for RejectCode {
                 "Insufficient signers agreed to sign the block. The following signers are malicious: {:?}",
                 malicious_signers
             ),
+            RejectCode::NonceTimeout(malicious_signers) => write!(
+                f,
+                "Nonce timeout occurred signers. The following signers are malicious: {:?}",
+                malicious_signers
+            ),
             RejectCode::MissingTransactions(missing_transactions) => write!(
                 f,
                 "Missing the following expected transactions: {:?}",
@@ -1011,6 +1037,11 @@ impl std::fmt::Display for RejectCode {
                 f,
                 "The block was rejected due to connectivity issues with the signer."
             ),
+            RejectCode::AggregatorError(reason) => write!(
+                f,
+                "An internal error occurred in the signer when aggregating the signaure: {:?}",
+                reason
+            ),
         }
     }
 }
@@ -1074,6 +1105,18 @@ mod test {
             .expect("Failed to deserialize RejectCode");
         assert_eq!(code, deserialized_code);
 
+        let code = RejectCode::NonceTimeout(vec![0, 1, 2]);
+        let serialized_code = code.serialize_to_vec();
+        let deserialized_code = read_next::<RejectCode, _>(&mut &serialized_code[..])
+            .expect("Failed to deserialize RejectCode");
+        assert_eq!(code, deserialized_code);
+
+        let code = RejectCode::AggregatorError("Test Error".into());
+        let serialized_code = code.serialize_to_vec();
+        let deserialized_code = read_next::<RejectCode, _>(&mut &serialized_code[..])
+            .expect("Failed to deserialize RejectCode");
+        assert_eq!(code, deserialized_code);
+
         let sk = StacksPrivateKey::new();
         let tx = StacksTransaction {
             version: TransactionVersion::Testnet,
@@ -1131,6 +1174,24 @@ mod test {
         let deserialized_rejection = read_next::<BlockRejection, _>(&mut &serialized_rejection[..])
             .expect("Failed to deserialize BlockRejection");
         assert_eq!(rejection, deserialized_rejection);
+
+        let rejection = BlockRejection::new(
+            Sha512Trunc256Sum([2u8; 32]),
+            RejectCode::NonceTimeout(vec![0, 1, 2]),
+        );
+        let serialized_rejection = rejection.serialize_to_vec();
+        let deserialized_rejection = read_next::<BlockRejection, _>(&mut &serialized_rejection[..])
+            .expect("Failed to deserialize BlockRejection");
+        assert_eq!(rejection, deserialized_rejection);
+
+        let rejection = BlockRejection::new(
+            Sha512Trunc256Sum([2u8; 32]),
+            RejectCode::AggregatorError("Test Error".into()),
+        );
+        let serialized_rejection = rejection.serialize_to_vec();
+        let deserialized_rejection = read_next::<BlockRejection, _>(&mut &serialized_rejection[..])
+            .expect("Failed to deserialize BlockRejection");
+        assert_eq!(rejection, deserialized_rejection);
     }
 
     #[test]
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index 3c2ecc0b0c..3820c4788b 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -979,10 +979,12 @@ impl Signer {
                     self.process_dkg(stacks_client, point, current_reward_cycle);
                 }
                 OperationResult::SignError(e) => {
+                    warn!("Signer #{}: Received a Sign error: {e:?}", self.signer_id);
                     self.process_sign_error(e);
                 }
                 OperationResult::DkgError(e) => {
                     warn!("Signer #{}: Received a DKG error: {e:?}", self.signer_id);
+                    // TODO: process these errors and track malicious signers to report
                 }
             }
         }
@@ -1001,7 +1003,7 @@ impl Signer {
                 .map_err(backoff::Error::transient)
         })
         .unwrap_or(StacksEpochId::Epoch24);
-        let tx_fee = if epoch != StacksEpochId::Epoch30 {
+        let tx_fee = if epoch < StacksEpochId::Epoch30 {
             debug!(
                 "Signer #{}: in pre Epoch 3.0 cycles, must set a transaction fee for the DKG vote.",
                 self.signer_id
@@ -1081,29 +1083,20 @@ impl Signer {
                 .map_err(backoff::Error::transient)
         })
         .unwrap_or(None);
-        match epoch {
-            StacksEpochId::Epoch25 => {
-                debug!("Signer #{}: Received a DKG result while in epoch 2.5. Broadcast the transaction to the mempool.", self.signer_id);
-                if aggregate_key.is_none() {
-                    stacks_client.submit_transaction(&new_transaction)?;
-                    info!(
-                        "Signer #{}: Submitted DKG vote transaction ({txid:?}) to the mempool",
-                        self.signer_id
-                    )
-                } else {
-                    debug!("Signer #{}: Already have an aggregate key for reward cycle {}. Do not broadcast the transaction ({txid:?}).", self.signer_id, self.reward_cycle);
-                }
-            }
-            StacksEpochId::Epoch30 => {
-                debug!("Signer #{}: Received a DKG result while in epoch 3.0. Broadcast the transaction only to stackerDB.", self.signer_id);
-            }
-            _ => {
-                debug!("Signer #{}: Received a DKG result, but are in an unsupported epoch. Do not broadcast the transaction ({}).", self.signer_id, new_transaction.txid());
-                return Ok(());
-            }
+        if epoch > StacksEpochId::Epoch30 {
+            debug!("Signer #{}: Received a DKG result while in epoch 3.0. Broadcast the transaction only to stackerDB.", self.signer_id);
+        } else if epoch == StacksEpochId::Epoch25 {
+            debug!("Signer #{}: Received a DKG result while in epoch 3.0. Broadcast the transaction to the mempool.", self.signer_id);
+            stacks_client.submit_transaction(&new_transaction)?;
+            info!(
+                "Signer #{}: Submitted DKG vote transaction ({txid:?}) to the mempool",
+                self.signer_id
+            );
+        } else {
+            debug!("Signer #{}: Received a DKG result, but are in an unsupported epoch. Do not broadcast the transaction ({}).", self.signer_id, new_transaction.txid());
+            return Ok(());
         }
         // For all Pox-4 epochs onwards, broadcast the results also to stackerDB for other signers/miners to observe
-        // TODO: if we store transactions on the side, should we use them rather than directly querying the stacker db slot?
         // TODO: Should we even store transactions if not in prepare phase? Should the miner just ignore all signer transactions if not in prepare phase?
         let txid = new_transaction.txid();
         let new_transactions = if aggregate_key.is_some() {
@@ -1187,70 +1180,73 @@ impl Signer {
 
     /// Process a sign error from a signing round, broadcasting a rejection message to stackerdb accordingly
     fn process_sign_error(&mut self, e: &SignError) {
-        warn!(
-            "Signer #{}: Received a signature error: {e:?}",
-            self.signer_id
-        );
-        match e {
-            SignError::NonceTimeout(_valid_signers, _malicious_signers) => {
+        let message = self.coordinator.get_message();
+        let block = read_next::<NakamotoBlock, _>(&mut &message[..]).ok().unwrap_or({
+                // This is not a block so maybe its across its hash
+                // This jankiness is because a coordinator could have signed a rejection we need to find the underlying block hash
+                let signer_signature_hash_bytes = if message.len() > 32 {
+                    &message[..32]
+                } else {
+                    &message
+                };
+                let Some(signer_signature_hash) = Sha512Trunc256Sum::from_bytes(signer_signature_hash_bytes) else {
+                    debug!("Signer #{}: Received a signature result for a signature over a non-block. Nothing to broadcast.", self.signer_id);
+                    return;
+                };
+                let Some(block_info) = self.blocks.remove(&signer_signature_hash) else {
+                    debug!("Signer #{}: Received a signature result for a block we have not seen before. Ignoring...", self.signer_id);
+                    return;
+                };
+                block_info.block
+            });
+        // We don't have enough signers to sign the block. Broadcast a rejection
+        let block_rejection = match e {
+            SignError::NonceTimeout(_valid_signers, malicious_signers) => {
                 //TODO: report these malicious signers
                 debug!(
                     "Signer #{}: Received a nonce timeout error.",
                     self.signer_id
                 );
+                BlockRejection::new(
+                    block.header.signer_signature_hash(),
+                    RejectCode::NonceTimeout(malicious_signers.clone()),
+                )
             }
             SignError::InsufficientSigners(malicious_signers) => {
                 debug!(
                     "Signer #{}: Received a insufficient signers error.",
                     self.signer_id
                 );
-                let message = self.coordinator.get_message();
-                let block = read_next::<NakamotoBlock, _>(&mut &message[..]).ok().unwrap_or({
-                        // This is not a block so maybe its across its hash
-                        // This jankiness is because a coordinator could have signed a rejection we need to find the underlying block hash
-                        let signer_signature_hash_bytes = if message.len() > 32 {
-                            &message[..32]
-                        } else {
-                            &message
-                        };
-                        let Some(signer_signature_hash) = Sha512Trunc256Sum::from_bytes(signer_signature_hash_bytes) else {
-                            debug!("Signer #{}: Received a signature result for a signature over a non-block. Nothing to broadcast.", self.signer_id);
-                            return;
-                        };
-                        let Some(block_info) = self.blocks.remove(&signer_signature_hash) else {
-                            debug!("Signer #{}: Received a signature result for a block we have not seen before. Ignoring...", self.signer_id);
-                            return;
-                        };
-                        block_info.block
-                    });
-                // We don't have enough signers to sign the block. Broadcast a rejection
-                let block_rejection = BlockRejection::new(
+                BlockRejection::new(
                     block.header.signer_signature_hash(),
                     RejectCode::InsufficientSigners(malicious_signers.clone()),
-                );
-                debug!(
-                    "Signer #{}: Insufficient signers for block; send rejection {block_rejection:?}",
-                    self.signer_id
-                );
-                // Submit signature result to miners to observe
-                if let Err(e) = self
-                    .stackerdb
-                    .send_message_with_retry(block_rejection.into())
-                {
-                    warn!(
-                        "Signer #{}: Failed to send block submission to stacker-db: {e:?}",
-                        self.signer_id
-                    );
-                }
+                )
             }
             SignError::Aggregator(e) => {
                 warn!(
                     "Signer #{}: Received an aggregator error: {e:?}",
                     self.signer_id
                 );
+                BlockRejection::new(
+                    block.header.signer_signature_hash(),
+                    RejectCode::AggregatorError(e.to_string()),
+                )
             }
+        };
+        debug!(
+            "Signer #{}: Broadcasting block rejection: {block_rejection:?}",
+            self.signer_id
+        );
+        // Submit signature result to miners to observe
+        if let Err(e) = self
+            .stackerdb
+            .send_message_with_retry(block_rejection.into())
+        {
+            warn!(
+                "Signer #{}: Failed to send block rejection submission to stacker-db: {e:?}",
+                self.signer_id
+            );
         }
-        // TODO: should reattempt to sign the block here or should we just broadcast a rejection or do nothing and wait for the signers to propose a new block?
     }
 
     /// Send any operation results across the provided channel

From e24f223a9815ccf5a23c3ca0653b3949aa9831ea Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 23 Feb 2024 13:12:50 -0500
Subject: [PATCH 0920/1166] Fix signer vote calculations into a struct

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 libsigner/src/messages.rs                     |  28 ++-
 stacks-signer/src/signer.rs                   | 177 ++++++------------
 stackslib/src/chainstate/nakamoto/mod.rs      |  27 +++
 .../stacks-node/src/nakamoto_node/miner.rs    |  11 +-
 testnet/stacks-node/src/tests/signer.rs       |  13 +-
 5 files changed, 123 insertions(+), 133 deletions(-)

diff --git a/libsigner/src/messages.rs b/libsigner/src/messages.rs
index b911dba15d..6135312a87 100644
--- a/libsigner/src/messages.rs
+++ b/libsigner/src/messages.rs
@@ -49,7 +49,7 @@ use wsts::net::{
     SignatureShareRequest, SignatureShareResponse,
 };
 use wsts::schnorr::ID;
-use wsts::state_machine::signer;
+use wsts::state_machine::{signer, SignError};
 
 use crate::http::{decode_http_body, decode_http_request};
 use crate::EventError;
@@ -181,7 +181,7 @@ pub enum SignerMessage {
 impl SignerMessage {
     /// Helper function to determine the slot ID for the provided stacker-db writer id
     pub fn msg_id(&self) -> u32 {
-        let msg_id = match self {
+        match self {
             Self::Packet(packet) => match packet.msg {
                 Message::DkgBegin(_) => DKG_BEGIN_MSG_ID,
                 Message::DkgPrivateBegin(_) => DKG_PRIVATE_BEGIN_MSG_ID,
@@ -196,8 +196,7 @@ impl SignerMessage {
             },
             Self::BlockResponse(_) => BLOCK_MSG_ID,
             Self::Transactions(_) => TRANSACTIONS_MSG_ID,
-        };
-        msg_id
+        }
     }
 }
 
@@ -263,10 +262,7 @@ impl StacksMessageCodecExtensions for Point {
         let compressed_bytes: Vec<u8> = read_next(fd)?;
         let compressed = Compressed::try_from(compressed_bytes.as_slice())
             .map_err(|e| CodecError::DeserializeError(e.to_string()))?;
-        Ok(
-            Point::try_from(&compressed)
-                .map_err(|e| CodecError::DeserializeError(e.to_string()))?,
-        )
+        Point::try_from(&compressed).map_err(|e| CodecError::DeserializeError(e.to_string()))
     }
 }
 
@@ -954,11 +950,25 @@ pub enum RejectCode {
     ConnectivityIssues,
 }
 
+impl From<&SignError> for RejectCode {
+    fn from(err: &SignError) -> Self {
+        match err {
+            SignError::NonceTimeout(_valid_signers, malicious_signers) => {
+                Self::NonceTimeout(malicious_signers.clone())
+            }
+            SignError::InsufficientSigners(malicious_signers) => {
+                Self::InsufficientSigners(malicious_signers.clone())
+            }
+            SignError::Aggregator(e) => Self::AggregatorError(e.to_string()),
+        }
+    }
+}
+
 impl StacksMessageCodec for RejectCode {
     fn consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), CodecError> {
         write_next(fd, &(RejectCodeTypePrefix::from(self) as u8))?;
         match self {
-            RejectCode::ValidationFailed(code) => write_next(fd, &(code.clone() as u8))?,
+            RejectCode::ValidationFailed(code) => write_next(fd, &(*code as u8))?,
             RejectCode::SignedRejection(sig) => write_next(fd, sig)?,
             RejectCode::InsufficientSigners(malicious_signers)
             | RejectCode::NonceTimeout(malicious_signers) => write_next(fd, malicious_signers)?,
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index 3820c4788b..387d90c8e7 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -17,7 +17,7 @@ use std::collections::VecDeque;
 use std::sync::mpsc::Sender;
 use std::time::Instant;
 
-use blockstack_lib::chainstate::nakamoto::NakamotoBlock;
+use blockstack_lib::chainstate::nakamoto::{NakamotoBlock, NakamotoBlockVote};
 use blockstack_lib::chainstate::stacks::boot::SIGNERS_VOTING_NAME;
 use blockstack_lib::chainstate::stacks::{StacksTransaction, TransactionPayload};
 use blockstack_lib::net::api::postblock_proposal::BlockValidateResponse;
@@ -54,7 +54,7 @@ pub struct BlockInfo {
     /// The block we are considering
     block: NakamotoBlock,
     /// Our vote on the block if we have one yet
-    vote: Option<Vec<u8>>,
+    vote: Option<NakamotoBlockVote>,
     /// Whether the block contents are valid
     valid: Option<bool>,
     /// The associated packet nonce request if we have one
@@ -528,33 +528,27 @@ impl Signer {
     /// If the request is for a block it has already agreed to sign, it will overwrite the message with the agreed upon value
     /// Returns whether the request is valid or not.
     fn validate_signature_share_request(&self, request: &mut SignatureShareRequest) -> bool {
-        let message_len = request.message.len();
-        // Note that the message must always be either 32 bytes (the block hash) or 33 bytes (block hash + b'n')
-        let hash_bytes = if message_len == 33 && request.message[32] == b'n' {
-            // Pop off the 'n' byte from the block hash
-            &request.message[..32]
-        } else if message_len == 32 {
-            // This is the block hash
-            &request.message
-        } else {
-            // We will only sign across block hashes or block hashes + b'n' byte
-            debug!("Signer #{}: Received a signature share request for an unknown message stream. Reject it.", self.signer_id);
-            return false;
-        };
-
-        let Some(hash) = Sha512Trunc256Sum::from_bytes(hash_bytes) else {
-            // We will only sign across valid block hashes
-            debug!("Signer #{}: Received a signature share request for an invalid block hash. Reject it.", self.signer_id);
+        let Some(block_vote): Option<NakamotoBlockVote> = read_next(&mut &request.message[..]).ok()
+        else {
+            // We currently reject anything that is not a block vote
+            debug!(
+                "Signer #{}: Received a signature share request for an unknown message stream. Reject it.",
+                self.signer_id
+            );
             return false;
         };
-        match self.blocks.get(&hash).map(|block_info| &block_info.vote) {
+        match self
+            .blocks
+            .get(&block_vote.signer_signature_hash)
+            .map(|block_info| &block_info.vote)
+        {
             Some(Some(vote)) => {
                 // Overwrite with our agreed upon value in case another message won majority or the coordinator is trying to cheat...
                 debug!(
-                    "Signer #{}: set vote for {hash} to {vote:?}",
-                    self.signer_id
+                    "Signer #{}: set vote for {} to {vote:?}",
+                    self.signer_id, block_vote.rejected
                 );
-                request.message = vote.clone();
+                request.message = vote.serialize_to_vec();
                 true
             }
             Some(None) => {
@@ -583,7 +577,7 @@ impl Signer {
         stacks_client: &StacksClient,
         nonce_request: &mut NonceRequest,
     ) -> bool {
-        let Some(block) = read_next::<NakamotoBlock, _>(&mut &nonce_request.message[..]).ok()
+        let Some(block): Option<NakamotoBlock> = read_next(&mut &nonce_request.message[..]).ok()
         else {
             // We currently reject anything that is not a block
             debug!(
@@ -901,22 +895,28 @@ impl Signer {
         block_info: &mut BlockInfo,
         nonce_request: &mut NonceRequest,
     ) {
-        let mut vote_bytes = block_info.block.header.signer_signature_hash().0.to_vec();
-        // Validate the block contents
-        if !block_info.valid.unwrap_or(false) {
-            // We don't like this block. Update the request to be across its hash with a byte indicating a vote no.
+        let rejected = !block_info.valid.unwrap_or(false);
+        if rejected {
             debug!(
-                "Signer #{}: Updating the request with a block hash with a vote no.",
-                signer_id
+                "Signer #{}: Rejecting block {}",
+                signer_id,
+                block_info.block.block_id()
             );
-            vote_bytes.push(b'n');
         } else {
-            debug!("Signer #{}: The block passed validation. Update the request with the signature hash.", signer_id);
+            debug!(
+                "Signer #{}: Accepting block {}",
+                signer_id,
+                block_info.block.block_id()
+            );
         }
-
+        let block_vote = NakamotoBlockVote {
+            signer_signature_hash: block_info.block.header.signer_signature_hash(),
+            rejected: !block_info.valid.unwrap_or(false),
+        };
+        let block_vote_bytes = block_vote.serialize_to_vec();
         // Cache our vote
-        block_info.vote = Some(vote_bytes.clone());
-        nonce_request.message = vote_bytes;
+        block_info.vote = Some(block_vote);
+        nonce_request.message = block_vote_bytes;
     }
 
     /// Verify a chunk is a valid wsts packet. Returns the packet if it is valid, else None.
@@ -1126,43 +1126,24 @@ impl Signer {
     /// broadcasting an appropriate Reject or Approval message to stackerdb
     fn process_signature(&mut self, signature: &Signature) {
         // Deserialize the signature result and broadcast an appropriate Reject or Approval message to stackerdb
-        let Some(aggregate_public_key) = &self.coordinator.get_aggregate_public_key() else {
+        let message = self.coordinator.get_message();
+        let Some(block_vote): Option<NakamotoBlockVote> = read_next(&mut &message[..]).ok() else {
             debug!(
-                "Signer #{}: No aggregate public key set. Cannot validate signature...",
+                "Signer #{}: Received a signature result for a non-block. Nothing to broadcast.",
                 self.signer_id
             );
             return;
         };
-        let message = self.coordinator.get_message();
-        // This jankiness is because a coordinator could have signed a rejection we need to find the underlying block hash
-        let signer_signature_hash_bytes = if message.len() > 32 {
-            &message[..32]
-        } else {
-            &message
-        };
-        let Some(signer_signature_hash) =
-            Sha512Trunc256Sum::from_bytes(signer_signature_hash_bytes)
-        else {
-            debug!("Signer #{}: Received a signature result for a signature over a non-block. Nothing to broadcast.", self.signer_id);
-            return;
-        };
 
         // TODO: proper garbage collection...This is currently our only cleanup of blocks
-        self.blocks.remove(&signer_signature_hash);
-
-        // This signature is no longer valid. Do not broadcast it.
-        if !signature.verify(aggregate_public_key, &message) {
-            warn!("Signer #{}: Received an invalid signature result across the block. Do not broadcast it.", self.signer_id);
-            // TODO: should we reinsert it and trigger a sign round across the block again?
-            return;
-        }
+        self.blocks.remove(&block_vote.signer_signature_hash);
 
-        let block_submission = if message == signer_signature_hash.0.to_vec() {
-            // we agreed to sign the block hash. Return an approval message
-            BlockResponse::accepted(signer_signature_hash, signature.clone()).into()
-        } else {
+        let block_submission = if block_vote.rejected {
             // We signed a rejection message. Return a rejection message
-            BlockResponse::rejected(signer_signature_hash, signature.clone()).into()
+            BlockResponse::rejected(block_vote.signer_signature_hash, signature.clone()).into()
+        } else {
+            // we agreed to sign the block hash. Return an approval message
+            BlockResponse::accepted(block_vote.signer_signature_hash, signature.clone()).into()
         };
 
         // Submit signature result to miners to observe
@@ -1181,58 +1162,24 @@ impl Signer {
     /// Process a sign error from a signing round, broadcasting a rejection message to stackerdb accordingly
     fn process_sign_error(&mut self, e: &SignError) {
         let message = self.coordinator.get_message();
-        let block = read_next::<NakamotoBlock, _>(&mut &message[..]).ok().unwrap_or({
-                // This is not a block so maybe its across its hash
-                // This jankiness is because a coordinator could have signed a rejection we need to find the underlying block hash
-                let signer_signature_hash_bytes = if message.len() > 32 {
-                    &message[..32]
-                } else {
-                    &message
-                };
-                let Some(signer_signature_hash) = Sha512Trunc256Sum::from_bytes(signer_signature_hash_bytes) else {
-                    debug!("Signer #{}: Received a signature result for a signature over a non-block. Nothing to broadcast.", self.signer_id);
-                    return;
-                };
-                let Some(block_info) = self.blocks.remove(&signer_signature_hash) else {
-                    debug!("Signer #{}: Received a signature result for a block we have not seen before. Ignoring...", self.signer_id);
-                    return;
-                };
-                block_info.block
-            });
-        // We don't have enough signers to sign the block. Broadcast a rejection
-        let block_rejection = match e {
-            SignError::NonceTimeout(_valid_signers, malicious_signers) => {
-                //TODO: report these malicious signers
-                debug!(
-                    "Signer #{}: Received a nonce timeout error.",
-                    self.signer_id
-                );
-                BlockRejection::new(
-                    block.header.signer_signature_hash(),
-                    RejectCode::NonceTimeout(malicious_signers.clone()),
-                )
-            }
-            SignError::InsufficientSigners(malicious_signers) => {
-                debug!(
-                    "Signer #{}: Received a insufficient signers error.",
-                    self.signer_id
-                );
-                BlockRejection::new(
-                    block.header.signer_signature_hash(),
-                    RejectCode::InsufficientSigners(malicious_signers.clone()),
-                )
-            }
-            SignError::Aggregator(e) => {
-                warn!(
-                    "Signer #{}: Received an aggregator error: {e:?}",
-                    self.signer_id
-                );
-                BlockRejection::new(
-                    block.header.signer_signature_hash(),
-                    RejectCode::AggregatorError(e.to_string()),
-                )
-            }
-        };
+        // We do not sign across blocks, but across their hashes. however, the first sign request is always across the block
+        // so we must handle this case first
+
+        let block: NakamotoBlock = read_next(&mut &message[..]).ok().unwrap_or({
+            // This is not a block so maybe its across its hash
+            let Some(block_vote): Option<NakamotoBlockVote> = read_next(&mut &message[..]).ok() else {
+                // This is not a block vote either. We cannot process this error
+                debug!("Signer #{}: Received a signature error for a non-block. Nothing to broadcast.", self.signer_id);
+                return;
+            };
+            let Some(block_info) = self.blocks.remove(&block_vote.signer_signature_hash) else {
+                debug!("Signer #{}: Received a signature result for a block we have not seen before. Ignoring...", self.signer_id);
+                return;
+            };
+            block_info.block
+        });
+        let block_rejection =
+            BlockRejection::new(block.header.signer_signature_hash(), RejectCode::from(e));
         debug!(
             "Signer #{}: Broadcasting block rejection: {block_rejection:?}",
             self.signer_id
diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index e9c6789db6..94fc5855e7 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -342,6 +342,33 @@ impl FromRow<NakamotoBlockHeader> for NakamotoBlockHeader {
     }
 }
 
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+/// A vote across the signer set for a block
+pub struct NakamotoBlockVote {
+    pub signer_signature_hash: Sha512Trunc256Sum,
+    pub rejected: bool,
+}
+
+impl StacksMessageCodec for NakamotoBlockVote {
+    fn consensus_serialize<W: std::io::Write>(&self, fd: &mut W) -> Result<(), CodecError> {
+        write_next(fd, &self.signer_signature_hash)?;
+        if self.rejected {
+            write_next(fd, &1u8)?;
+        }
+        Ok(())
+    }
+
+    fn consensus_deserialize<R: std::io::Read>(fd: &mut R) -> Result<Self, CodecError> {
+        let signer_signature_hash = read_next(fd)?;
+        let rejected_byte: Option<u8> = read_next(fd).ok();
+        let rejected = rejected_byte.is_some();
+        Ok(Self {
+            signer_signature_hash,
+            rejected,
+        })
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct NakamotoBlock {
     pub header: NakamotoBlockHeader,
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index 5f39e43726..5e3c39c9e9 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -33,7 +33,7 @@ use stacks::chainstate::burn::{BlockSnapshot, ConsensusHash};
 use stacks::chainstate::nakamoto::miner::{NakamotoBlockBuilder, NakamotoTenureInfo};
 use stacks::chainstate::nakamoto::signer_set::NakamotoSigners;
 use stacks::chainstate::nakamoto::test_signers::TestSigners;
-use stacks::chainstate::nakamoto::{NakamotoBlock, NakamotoChainState};
+use stacks::chainstate::nakamoto::{NakamotoBlock, NakamotoBlockVote, NakamotoChainState};
 use stacks::chainstate::stacks::boot::MINERS_NAME;
 use stacks::chainstate::stacks::db::{StacksChainState, StacksHeaderInfo};
 use stacks::chainstate::stacks::{
@@ -43,7 +43,7 @@ use stacks::chainstate::stacks::{
 };
 use stacks::core::FIRST_BURNCHAIN_CONSENSUS_HASH;
 use stacks::net::stackerdb::StackerDBs;
-use stacks_common::codec::read_next;
+use stacks_common::codec::{read_next, StacksMessageCodec};
 use stacks_common::types::chainstate::{StacksAddress, StacksBlockId};
 use stacks_common::types::{PrivateKey, StacksEpochId};
 use stacks_common::util::hash::{Hash160, Sha512Trunc256Sum};
@@ -439,8 +439,11 @@ impl BlockMinerThread {
                         }
                         if let RejectCode::SignedRejection(signature) = block_rejection.reason_code
                         {
-                            let mut message = signer_signature_hash.0.to_vec();
-                            message.push(b'n');
+                            let block_vote = NakamotoBlockVote {
+                                signer_signature_hash: *signer_signature_hash,
+                                rejected: true,
+                            };
+                            let message = block_vote.serialize_to_vec();
                             if signature.0.verify(aggregate_public_key, &message) {
                                 // A threshold number of signers signed a denial of the proposed block
                                 // Miner will NEVER get a signed block from the signers for this particular block
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index aa1706e313..ae0064cd4b 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -15,14 +15,14 @@ use stacks::burnchains::Txid;
 use stacks::chainstate::burn::ConsensusHashExtensions;
 use stacks::chainstate::coordinator::comm::CoordinatorChannels;
 use stacks::chainstate::nakamoto::signer_set::NakamotoSigners;
-use stacks::chainstate::nakamoto::{NakamotoBlock, NakamotoBlockHeader};
+use stacks::chainstate::nakamoto::{NakamotoBlock, NakamotoBlockHeader, NakamotoBlockVote};
 use stacks::chainstate::stacks::boot::SIGNERS_NAME;
 use stacks::chainstate::stacks::miner::TransactionEvent;
 use stacks::chainstate::stacks::{StacksPrivateKey, StacksTransaction, ThresholdSignature};
 use stacks::core::StacksEpoch;
 use stacks::net::api::postblock_proposal::BlockValidateResponse;
 use stacks_common::bitvec::BitVec;
-use stacks_common::codec::read_next;
+use stacks_common::codec::{read_next, StacksMessageCodec};
 use stacks_common::consts::SIGNER_SLOTS_PER_USER;
 use stacks_common::types::chainstate::{ConsensusHash, StacksBlockId, StacksPublicKey, TrieHash};
 use stacks_common::types::StacksEpochId;
@@ -801,9 +801,12 @@ fn stackerdb_dkg_sign() {
     };
     block.header.tx_merkle_root = tx_merkle_root;
 
-    // The block is invalid so the signers should return a signature across its hash + b'n'
-    let mut msg = block.header.signer_signature_hash().0.to_vec();
-    msg.push(b'n');
+    // The block is invalid so the signers should return a signature across a rejection
+    let block_vote = NakamotoBlockVote {
+        signer_signature_hash: block.header.signer_signature_hash(),
+        rejected: true,
+    };
+    let msg = block_vote.serialize_to_vec();
 
     let timeout = Duration::from_secs(200);
     let mut signer_test = SignerTest::new(10);

From 6edec125ab0f4ae1379de9c4bf62991b7df25e2b Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 23 Feb 2024 13:33:11 -0500
Subject: [PATCH 0921/1166] CRC: cleanup parse_function_args

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/signer.rs             | 72 +++++++++++--------------
 testnet/stacks-node/src/tests/signer.rs | 15 +++---
 2 files changed, 40 insertions(+), 47 deletions(-)

diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index 387d90c8e7..6541bc05b5 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -22,7 +22,6 @@ use blockstack_lib::chainstate::stacks::boot::SIGNERS_VOTING_NAME;
 use blockstack_lib::chainstate::stacks::{StacksTransaction, TransactionPayload};
 use blockstack_lib::net::api::postblock_proposal::BlockValidateResponse;
 use blockstack_lib::util_lib::boot::boot_code_id;
-use clarity::vm::Value as ClarityValue;
 use hashbrown::{HashMap, HashSet};
 use libsigner::{BlockRejection, BlockResponse, RejectCode, SignerEvent, SignerMessage};
 use slog::{slog_debug, slog_error, slog_info, slog_warn};
@@ -447,9 +446,8 @@ impl Signer {
         let packets: Vec<Packet> = messages
             .iter()
             .filter_map(|msg| match msg {
-                // TODO: should we store the received transactions on the side and use them rather than directly querying the stacker db slots?
                 SignerMessage::BlockResponse(_) | SignerMessage::Transactions(_) => None,
-                // TODO: if a signer tries to trigger DKG and we already have one set in the contract, ignore the request. Nack it.
+                // TODO: if a signer tries to trigger DKG and we already have one set in the contract, ignore the request.
                 SignerMessage::Packet(packet) => {
                     self.verify_packet(stacks_client, packet.clone(), &coordinator_pubkey)
                 }
@@ -791,21 +789,10 @@ impl Signer {
         origin_signer_id: u32,
         current_reward_cycle: u64,
     ) -> Result<bool, ClientError> {
-        let TransactionPayload::ContractCall(payload) = &transaction.payload else {
-            // Not a contract call so not a special cased vote for aggregate public key transaction
-            return Ok(false);
-        };
-
-        if payload.contract_identifier() != boot_code_id(SIGNERS_VOTING_NAME, self.mainnet)
-            || payload.function_name != VOTE_FUNCTION_NAME.into()
-        {
-            // This is not a special cased transaction.
-            return Ok(false);
-        }
         let Some((index, _point, round, reward_cycle)) =
-            Self::parse_function_args(&payload.function_args)
+            Self::parse_vote_for_aggregate_public_key(transaction)
         else {
-            // The transactions arguments are invalid
+            // The transaction is not a valid vote-for-aggregate-public-key transaction
             return Ok(false);
         };
         if index != origin_signer_id as u64 {
@@ -1271,7 +1258,6 @@ impl Signer {
                 self.signer_id
             );
             // Have I already voted and have a pending transaction? Check stackerdb for the same round number and reward cycle vote transaction
-            // TODO: might be better to store these transactions on the side to prevent having to query the stacker db for every signer (only do on initilaization of a new signer for example and then listen for stacker db updates after that)
             let old_transactions = self.get_signer_transactions(stacks_client, current_reward_cycle).map_err(|e| {
                 warn!("Signer #{}: Failed to get old transactions: {e:?}. Potentially overwriting our existing transactions", self.signer_id);
             }).unwrap_or_default();
@@ -1281,26 +1267,18 @@ impl Signer {
                 if &origin_address != stacks_client.get_signer_address() {
                     continue;
                 }
-                let TransactionPayload::ContractCall(payload) = &transaction.payload else {
+                let Some((_index, point, round, _reward_cycle)) =
+                    Self::parse_vote_for_aggregate_public_key(transaction)
+                else {
+                    // The transaction is not a valid vote-for-aggregate-public-key transaction
                     error!("BUG: Signer #{}: Received an unrecognized transaction ({}) in an already filtered list: {transaction:?}", self.signer_id, transaction.txid());
                     continue;
                 };
-                if payload.function_name == VOTE_FUNCTION_NAME.into() {
-                    let Some((_signer_index, point, round, _reward_cycle)) =
-                        Self::parse_function_args(&payload.function_args)
-                    else {
-                        error!("BUG: Signer #{}: Received an unrecognized transaction ({}) in an already filtered list: {transaction:?}", self.signer_id, transaction.txid());
-                        continue;
-                    };
-                    if Some(point) == self.coordinator.aggregate_public_key
-                        && round == self.coordinator.current_dkg_id
-                    {
-                        debug!("Signer #{}: Not triggering a DKG round. Already have a pending vote transaction for aggregate public key {point:?} for round {round}...", self.signer_id);
-                        return Ok(());
-                    }
-                } else {
-                    error!("BUG: Signer #{}: Received an unrecognized transaction ({}) in an already filtered list: {transaction:?}", self.signer_id, transaction.txid());
-                    continue;
+                if Some(point) == self.coordinator.aggregate_public_key
+                    && round == self.coordinator.current_dkg_id
+                {
+                    debug!("Signer #{}: Not triggering a DKG round. Already have a pending vote transaction for aggregate public key {point:?} for round {round}...", self.signer_id);
+                    return Ok(());
                 }
             }
             if stacks_client
@@ -1382,19 +1360,33 @@ impl Signer {
         Ok(())
     }
 
-    fn parse_function_args(function_args: &[ClarityValue]) -> Option<(u64, Point, u64, u64)> {
-        if function_args.len() != 4 {
+    fn parse_vote_for_aggregate_public_key(
+        transaction: &StacksTransaction,
+    ) -> Option<(u64, Point, u64, u64)> {
+        let TransactionPayload::ContractCall(payload) = &transaction.payload else {
+            // Not a contract call so not a special cased vote for aggregate public key transaction
+            return None;
+        };
+        if payload.contract_identifier()
+            != boot_code_id(SIGNERS_VOTING_NAME, transaction.is_mainnet())
+            || payload.function_name != VOTE_FUNCTION_NAME.into()
+        {
+            // This is not a special cased transaction.
+            return None;
+        }
+        if payload.function_args.len() != 4 {
             return None;
         }
-        let signer_index_value = function_args.first()?;
+        let signer_index_value = payload.function_args.first()?;
         let signer_index = u64::try_from(signer_index_value.clone().expect_u128().ok()?).ok()?;
-        let point_value = function_args.get(1)?;
+        let point_value = payload.function_args.get(1)?;
         let point_bytes = point_value.clone().expect_buff(33).ok()?;
         let compressed_data = Compressed::try_from(point_bytes.as_slice()).ok()?;
         let point = Point::try_from(&compressed_data).ok()?;
-        let round_value = function_args.get(2)?;
+        let round_value = payload.function_args.get(2)?;
         let round = u64::try_from(round_value.clone().expect_u128().ok()?).ok()?;
-        let reward_cycle = u64::try_from(function_args.get(3)?.clone().expect_u128().ok()?).ok()?;
+        let reward_cycle =
+            u64::try_from(payload.function_args.get(3)?.clone().expect_u128().ok()?).ok()?;
         Some((signer_index, point, round, reward_cycle))
     }
 }
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index ae0064cd4b..8a3798eeac 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -190,7 +190,7 @@ impl SignerTest {
             .btc_regtest_controller
             .get_headers_height();
         let curr_reward_cycle = self.get_current_reward_cycle();
-        let next_reward_cycle = curr_reward_cycle.wrapping_add(1);
+        let next_reward_cycle = curr_reward_cycle.saturating_add(1);
         let next_reward_cycle_height = self
             .running_nodes
             .btc_regtest_controller
@@ -198,7 +198,8 @@ impl SignerTest {
             .reward_cycle_to_block_height(next_reward_cycle);
         let next_reward_cycle_reward_set_calculation = next_reward_cycle_height
             .saturating_sub(prepare_phase_len)
-            .wrapping_add(1); // +1 as the reward calculation occurs in the SECOND block of the prepare phase
+            .saturating_add(1); // +1 as the reward calculation occurs in the SECOND block of the prepare phase/
+
         next_reward_cycle_reward_set_calculation.saturating_sub(current_block_height)
     }
 
@@ -230,7 +231,7 @@ impl SignerTest {
             .running_nodes
             .btc_regtest_controller
             .get_headers_height()
-            .wrapping_add(nmb_blocks_to_mine_to_dkg);
+            .saturating_add(nmb_blocks_to_mine_to_dkg);
         info!("Mining {nmb_blocks_to_mine_to_dkg} Nakamoto block(s) to reach DKG calculation at block height {end_block_height}");
         for i in 1..=nmb_blocks_to_mine_to_dkg {
             info!("Mining Nakamoto block #{i} of {nmb_blocks_to_mine_to_dkg}");
@@ -273,7 +274,7 @@ impl SignerTest {
                 }
                 blocks_to_dkg = 0;
                 nmb_blocks_to_reward_cycle = self.nmb_blocks_to_reward_cycle_boundary(
-                    self.get_current_reward_cycle().wrapping_add(1),
+                    self.get_current_reward_cycle().saturating_add(1),
                 )
             }
             if total_nmb_blocks_to_mine >= nmb_blocks_to_reward_cycle {
@@ -585,7 +586,7 @@ impl SignerTest {
             .get_last_round(reward_cycle)
             .expect("FATAL: failed to get round")
             .unwrap_or(0)
-            .wrapping_add(1);
+            .saturating_add(1);
         let point = Point::from(Scalar::random(&mut rand::thread_rng()));
         let invalid_nonce_tx = self
             .stacks_client
@@ -1068,7 +1069,7 @@ fn stackerdb_mine_2_nakamoto_reward_cycles() {
     info!("------------------------- Test Mine 2 Nakamoto Reward Cycles -------------------------");
     let dkgs = signer_test
         .run_until_burnchain_height_nakamoto(timeout, final_reward_cycle_height_boundary);
-    assert_eq!(dkgs.len() as u64, nmb_reward_cycles.wrapping_add(1)); // We will have mined the DKG vote for the following reward cycle
+    assert_eq!(dkgs.len() as u64, nmb_reward_cycles.saturating_add(1)); // We will have mined the DKG vote for the following reward cycle
     let last_dkg = dkgs
         .last()
         .expect(&format!(
@@ -1154,7 +1155,7 @@ fn stackerdb_filter_bad_transactions() {
         })
         .cloned()
         .expect("Cannot find signer private key for signer id 1");
-    let next_reward_cycle = signer_test.get_current_reward_cycle().wrapping_add(1);
+    let next_reward_cycle = signer_test.get_current_reward_cycle().saturating_add(1);
     // Must submit to the NEXT reward cycle slots as they are the ones looked at by the CURRENT miners
     let signer_index = signer_test.get_signer_index(next_reward_cycle);
     let mut stackerdb = StackerDB::new(

From 05518ad42bc4d2254d5d799d9760a68723a0795e Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 23 Feb 2024 13:49:33 -0500
Subject: [PATCH 0922/1166] CRC: cleanup comments

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 libsigner/src/events.rs                         | 1 -
 stacks-signer/src/client/stackerdb.rs           | 2 +-
 stacks-signer/src/coordinator.rs                | 7 +------
 stackslib/src/chainstate/nakamoto/signer_set.rs | 7 +++++++
 stackslib/src/chainstate/stacks/mod.rs          | 6 ++++++
 5 files changed, 15 insertions(+), 8 deletions(-)

diff --git a/libsigner/src/events.rs b/libsigner/src/events.rs
index 2c5ecdda13..94bb17a85b 100644
--- a/libsigner/src/events.rs
+++ b/libsigner/src/events.rs
@@ -355,7 +355,6 @@ fn process_stackerdb_event(
             .iter()
             .filter_map(|chunk| read_next::<SignerMessage, _>(&mut &chunk.data[..]).ok())
             .collect();
-        //
         SignerEvent::SignerMessages(signer_set, signer_messages)
     } else {
         info!(
diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index fca5580d35..affd43ab2a 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -41,7 +41,7 @@ pub struct StackerDB {
     signers_message_stackerdb_sessions: HashMap<u32, StackerDBSession>,
     /// The private key used in all stacks node communications
     stacks_private_key: StacksPrivateKey,
-    /// A map of a (signer-set, message ID) to last chunk version for each session
+    /// A map of a message ID to last chunk version for each session
     slot_versions: HashMap<u32, HashMap<u32, u32>>,
     /// The signer slot ID -- the index into the signer list for this signer daemon's signing key.
     signer_slot_id: u32,
diff --git a/stacks-signer/src/coordinator.rs b/stacks-signer/src/coordinator.rs
index 2c23fd0b32..e0c6c0f7da 100644
--- a/stacks-signer/src/coordinator.rs
+++ b/stacks-signer/src/coordinator.rs
@@ -89,12 +89,7 @@ impl CoordinatorSelector {
             }
             new_index
         } else {
-            let mut new_index = self.coordinator_index.saturating_add(1);
-            if new_index == self.coordinator_ids.len() {
-                // We have exhausted all potential coordinators. Go back to the start
-                new_index = 0;
-            }
-            new_index
+            self.coordinator_index.saturating_add(1) % self.coordinator_ids.len()
         };
         self.coordinator_id = *self
             .coordinator_ids
diff --git a/stackslib/src/chainstate/nakamoto/signer_set.rs b/stackslib/src/chainstate/nakamoto/signer_set.rs
index d9f3aafeaa..f811ba4247 100644
--- a/stackslib/src/chainstate/nakamoto/signer_set.rs
+++ b/stackslib/src/chainstate/nakamoto/signer_set.rs
@@ -479,6 +479,13 @@ impl NakamotoSigners {
                 signers.insert(signer_address, weight);
             }
         }
+        if signers.is_empty() {
+            error!(
+                "No signers found for reward cycle";
+                "reward_cycle" => reward_cycle,
+            );
+            return Err(ChainstateError::NoRegisteredSigners(reward_cycle));
+        }
         Ok(signers)
     }
 }
diff --git a/stackslib/src/chainstate/stacks/mod.rs b/stackslib/src/chainstate/stacks/mod.rs
index 0224631dbd..af592c2db0 100644
--- a/stackslib/src/chainstate/stacks/mod.rs
+++ b/stackslib/src/chainstate/stacks/mod.rs
@@ -128,6 +128,7 @@ pub enum Error {
     ChannelClosed(String),
     /// This error indicates a Epoch2 block attempted to build off of a Nakamoto block.
     InvalidChildOfNakomotoBlock,
+    NoRegisteredSigners(u64),
 }
 
 impl From<marf_error> for Error {
@@ -221,6 +222,9 @@ impl fmt::Display for Error {
                 f,
                 "Block has a different tenure than parent, but no tenure change transaction"
             ),
+            Error::NoRegisteredSigners(reward_cycle) => {
+                write!(f, "No registered signers for reward cycle {reward_cycle}")
+            }
         }
     }
 }
@@ -263,6 +267,7 @@ impl error::Error for Error {
             Error::ChannelClosed(ref _s) => None,
             Error::InvalidChildOfNakomotoBlock => None,
             Error::ExpectedTenureChange => None,
+            Error::NoRegisteredSigners(_) => None,
         }
     }
 }
@@ -305,6 +310,7 @@ impl Error {
             Error::ChannelClosed(ref _s) => "ChannelClosed",
             Error::InvalidChildOfNakomotoBlock => "InvalidChildOfNakomotoBlock",
             Error::ExpectedTenureChange => "ExpectedTenureChange",
+            Error::NoRegisteredSigners(_) => "NoRegisteredSigners",
         }
     }
 

From 1384084dd152d0c72bab68f48c3f055aa05ab339 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 23 Feb 2024 15:07:13 -0500
Subject: [PATCH 0923/1166] Do not trigger DKG if we have an approved DKG key
 set in the contract

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 .github/workflows/bitcoin-tests.yml     |  4 +-
 stacks-signer/src/coordinator.rs        |  7 +-
 stacks-signer/src/runloop.rs            | 12 ++--
 stacks-signer/src/signer.rs             | 56 +++++++--------
 testnet/stacks-node/src/tests/signer.rs | 96 +++++++++++++++----------
 5 files changed, 100 insertions(+), 75 deletions(-)

diff --git a/.github/workflows/bitcoin-tests.yml b/.github/workflows/bitcoin-tests.yml
index c618172fd5..e2447a3606 100644
--- a/.github/workflows/bitcoin-tests.yml
+++ b/.github/workflows/bitcoin-tests.yml
@@ -76,9 +76,9 @@ jobs:
           - tests::nakamoto_integrations::block_proposal_api_endpoint
           - tests::nakamoto_integrations::miner_writes_proposed_block_to_stackerdb
           - tests::nakamoto_integrations::correct_burn_outs
-          - tests::signer::stackerdb_dkg_sign
+          - tests::signer::stackerdb_dkg
+          - tests::signer::stackerdb_sign
           - tests::signer::stackerdb_block_proposal
-          - tests::signer::stackerdb_reward_cycle_transitions
           - tests::signer::stackerdb_filter_bad_transactions
     steps:
       ## Setup test environment
diff --git a/stacks-signer/src/coordinator.rs b/stacks-signer/src/coordinator.rs
index e0c6c0f7da..2c23fd0b32 100644
--- a/stacks-signer/src/coordinator.rs
+++ b/stacks-signer/src/coordinator.rs
@@ -89,7 +89,12 @@ impl CoordinatorSelector {
             }
             new_index
         } else {
-            self.coordinator_index.saturating_add(1) % self.coordinator_ids.len()
+            let mut new_index = self.coordinator_index.saturating_add(1);
+            if new_index == self.coordinator_ids.len() {
+                // We have exhausted all potential coordinators. Go back to the start
+                new_index = 0;
+            }
+            new_index
         };
         self.coordinator_id = *self
             .coordinator_ids
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index a2f710c60c..8dab88d018 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -194,11 +194,13 @@ impl RunLoop {
                 signer.coordinator.state = CoordinatorState::Idle;
                 signer.state = SignerState::Idle;
             }
-            retry_with_exponential_backoff(|| {
-                signer
-                    .update_dkg(&self.stacks_client, current_reward_cycle)
-                    .map_err(backoff::Error::transient)
-            })?;
+            if signer.approved_aggregate_public_key.is_none() {
+                retry_with_exponential_backoff(|| {
+                    signer
+                        .update_dkg(&self.stacks_client, current_reward_cycle)
+                        .map_err(backoff::Error::transient)
+                })?;
+            }
         }
         if self.stacks_signers.is_empty() {
             info!("Signer is not registered for the current {current_reward_cycle} or next {next_reward_cycle} reward cycles. Waiting for confirmed registration...");
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index 6541bc05b5..6247f83a5d 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -144,6 +144,8 @@ pub struct Signer {
     pub tx_fee_ustx: u64,
     /// The coordinator info for the signer
     pub coordinator_selector: CoordinatorSelector,
+    /// The approved key registered to the contract
+    pub approved_aggregate_public_key: Option<Point>,
 }
 
 impl From<SignerConfig> for Signer {
@@ -212,6 +214,7 @@ impl From<SignerConfig> for Signer {
             reward_cycle: signer_config.reward_cycle,
             tx_fee_ustx: signer_config.tx_fee_ustx,
             coordinator_selector,
+            approved_aggregate_public_key: None,
         }
     }
 }
@@ -233,7 +236,11 @@ impl Signer {
     fn execute_command(&mut self, stacks_client: &StacksClient, command: &Command) {
         match command {
             Command::Dkg => {
-                //TODO: check if we already have an aggregate key stored in the contract.
+                if self.approved_aggregate_public_key.is_some() {
+                    // We do not enforce a block contain any transactions except the aggregate votes when it is NOT already set
+                    debug!("Signer #{}: Already have an aggregate key for reward cycle {}. Ignoring DKG command.", self.signer_id, self.reward_cycle);
+                    return;
+                }
                 // If we do, we should not start a new DKG
                 let vote_round = match retry_with_exponential_backoff(|| {
                     stacks_client
@@ -270,6 +277,11 @@ impl Signer {
                 is_taproot,
                 merkle_root,
             } => {
+                if self.approved_aggregate_public_key.is_none() {
+                    // We cannot sign a block if we do not have an approved aggregate public key
+                    debug!("Signer #{}: Cannot sign a block without an approved aggregate public key. Ignore it.", self.signer_id);
+                    return;
+                }
                 let signer_signature_hash = block.header.signer_signature_hash();
                 let block_info = self
                     .blocks
@@ -624,14 +636,9 @@ impl Signer {
         block: &NakamotoBlock,
         current_reward_cycle: u64,
     ) -> bool {
-        let aggregate_key = retry_with_exponential_backoff(|| {
-            stacks_client
-                .get_approved_aggregate_key(self.reward_cycle)
-                .map_err(backoff::Error::transient)
-        })
-        .unwrap_or(None);
-        if aggregate_key.is_some() {
+        if self.approved_aggregate_public_key.is_some() {
             // We do not enforce a block contain any transactions except the aggregate votes when it is NOT already set
+            // TODO: should be only allow special cased transactions during prepare phase before a key is set?
             debug!("Signer #{}: Already have an aggregate key for reward cycle {}. Skipping transaction verification...", self.signer_id, self.reward_cycle);
             return true;
         }
@@ -1064,12 +1071,6 @@ impl Signer {
         current_reward_cycle: u64,
     ) -> Result<(), ClientError> {
         let txid = new_transaction.txid();
-        let aggregate_key = retry_with_exponential_backoff(|| {
-            stacks_client
-                .get_approved_aggregate_key(self.reward_cycle)
-                .map_err(backoff::Error::transient)
-        })
-        .unwrap_or(None);
         if epoch > StacksEpochId::Epoch30 {
             debug!("Signer #{}: Received a DKG result while in epoch 3.0. Broadcast the transaction only to stackerDB.", self.signer_id);
         } else if epoch == StacksEpochId::Epoch25 {
@@ -1086,7 +1087,7 @@ impl Signer {
         // For all Pox-4 epochs onwards, broadcast the results also to stackerDB for other signers/miners to observe
         // TODO: Should we even store transactions if not in prepare phase? Should the miner just ignore all signer transactions if not in prepare phase?
         let txid = new_transaction.txid();
-        let new_transactions = if aggregate_key.is_some() {
+        let new_transactions = if self.approved_aggregate_public_key.is_some() {
             // We do not enforce a block contain any transactions except the aggregate votes when it is NOT already set
             info!(
                 "Signer #{}: Already has an aggregate key for reward cycle {}. Do not broadcast the transaction ({txid:?}).",
@@ -1233,26 +1234,23 @@ impl Signer {
         current_reward_cycle: u64,
     ) -> Result<(), ClientError> {
         let reward_cycle = self.reward_cycle;
-        let new_aggregate_public_key = stacks_client.get_approved_aggregate_key(reward_cycle)?;
-        let old_aggregate_public_key = self.coordinator.get_aggregate_public_key();
-        if new_aggregate_public_key.is_some()
-            && old_aggregate_public_key != new_aggregate_public_key
-        {
+        self.approved_aggregate_public_key =
+            stacks_client.get_approved_aggregate_key(reward_cycle)?;
+        if self.approved_aggregate_public_key.is_some() {
             // TODO: this will never work as is. We need to have stored our party shares on the side etc for this particular aggregate key.
             // Need to update state to store the necessary info, check against it to see if we have participated in the winning round and
             // then overwrite our value accordingly. Otherwise, we will be locked out of the round and should not participate.
+            self.coordinator
+                .set_aggregate_public_key(self.approved_aggregate_public_key);
+            // We have an approved aggregate public key. Do nothing further
             debug!(
-                "Signer #{}: Received a new aggregate public key ({new_aggregate_public_key:?}) for reward cycle {reward_cycle}. Overwriting its internal aggregate key ({old_aggregate_public_key:?})",
-                self.signer_id
+                "Signer #{}: Have updated DKG value to {:?}.",
+                self.signer_id, self.approved_aggregate_public_key
             );
-            self.coordinator
-                .set_aggregate_public_key(new_aggregate_public_key);
-        }
+            return Ok(());
+        };
         let coordinator_id = self.coordinator_selector.get_coordinator().0;
-        if new_aggregate_public_key.is_none()
-            && self.signer_id == coordinator_id
-            && self.state == State::Idle
-        {
+        if self.signer_id == coordinator_id && self.state == State::Idle {
             debug!(
                 "Signer #{}: Checking if old transactions exist",
                 self.signer_id
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index 8a3798eeac..bb58956d46 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -761,8 +761,59 @@ fn setup_stx_btc_node(
 #[test]
 #[ignore]
 /// Test the signer can respond to external commands to perform DKG
-/// and sign a block with both taproot and non-taproot signatures
-fn stackerdb_dkg_sign() {
+fn stackerdb_dkg() {
+    if env::var("BITCOIND_TEST") != Ok("1".into()) {
+        return;
+    }
+
+    tracing_subscriber::registry()
+        .with(fmt::layer())
+        .with(EnvFilter::from_default_env())
+        .init();
+
+    info!("------------------------- Test Setup -------------------------");
+    let timeout = Duration::from_secs(200);
+    let mut signer_test = SignerTest::new(10);
+    info!("Boot to epoch 3.0 reward calculation...");
+    boot_to_epoch_3_reward_set(
+        &signer_test.running_nodes.conf,
+        &signer_test.running_nodes.blocks_processed,
+        &signer_test.signer_stacks_private_keys,
+        &signer_test.signer_stacks_private_keys,
+        &mut signer_test.running_nodes.btc_regtest_controller,
+    );
+
+    info!("Pox 4 activated and at epoch 3.0 reward set calculation (2nd block of its prepare phase)! Ready for signers to perform DKG and Sign!");
+    // First wait for the automatically triggered DKG to complete
+    let key = signer_test.wait_for_dkg(timeout);
+
+    info!("------------------------- Test DKG -------------------------");
+    let reward_cycle = signer_test.get_current_reward_cycle().saturating_add(1);
+    let coordinator_sender = signer_test.get_coordinator_sender(reward_cycle);
+
+    // Determine the coordinator of the current node height
+    info!("signer_runloop: spawn send commands to do dkg");
+    let dkg_now = Instant::now();
+    coordinator_sender
+        .send(RunLoopCommand {
+            reward_cycle,
+            command: SignerCommand::Dkg,
+        })
+        .expect("failed to send DKG command");
+    let new_key = signer_test.wait_for_dkg(timeout);
+    let dkg_elapsed = dkg_now.elapsed();
+    assert_ne!(new_key, key);
+
+    info!("DKG Time Elapsed: {:.2?}", dkg_elapsed);
+    // TODO: look into this. Cannot get this to NOT hang unless I wait a bit...
+    std::thread::sleep(Duration::from_secs(1));
+    signer_test.shutdown();
+}
+
+#[test]
+#[ignore]
+/// Test the signer can respond to external commands to perform DKG
+fn stackerdb_sign() {
     if env::var("BITCOIND_TEST") != Ok("1".into()) {
         return;
     }
@@ -811,41 +862,12 @@ fn stackerdb_dkg_sign() {
 
     let timeout = Duration::from_secs(200);
     let mut signer_test = SignerTest::new(10);
-    info!("Boot to epoch 3.0 reward calculation...");
-    boot_to_epoch_3_reward_set(
-        &signer_test.running_nodes.conf,
-        &signer_test.running_nodes.blocks_processed,
-        &signer_test.signer_stacks_private_keys,
-        &signer_test.signer_stacks_private_keys,
-        &mut signer_test.running_nodes.btc_regtest_controller,
-    );
-
-    info!("Pox 4 activated and at epoch 3.0 reward set calculation (2nd block of its prepare phase)! Ready for signers to perform DKG and Sign!");
-
-    // First wait for the automatically triggered DKG to complete
-    let key = signer_test.wait_for_dkg(timeout);
-
-    info!("------------------------- Test DKG -------------------------");
-
-    // We are voting for the NEXT reward cycle hence the + 1;
-    let reward_cycle = signer_test.get_current_reward_cycle().saturating_add(1);
-    let coordinator_sender = signer_test.get_coordinator_sender(reward_cycle);
-
-    let dkg_now = Instant::now();
-    coordinator_sender
-        .send(RunLoopCommand {
-            reward_cycle,
-            command: SignerCommand::Dkg,
-        })
-        .expect("failed to send DKG command");
-    let new_key = signer_test.wait_for_dkg(timeout);
-    let dkg_elapsed = dkg_now.elapsed();
-    assert_ne!(new_key, key);
+    let key = signer_test.boot_to_epoch_3(timeout);
 
     info!("------------------------- Test Sign -------------------------");
-
+    let reward_cycle = signer_test.get_current_reward_cycle();
     // Determine the coordinator of the current node height
-    info!("signer_runloop: spawn send commands to do dkg and then sign");
+    info!("signer_runloop: spawn send commands to do sign");
     let sign_command = RunLoopCommand {
         reward_cycle,
         command: SignerCommand::Sign {
@@ -874,10 +896,10 @@ fn stackerdb_dkg_sign() {
     let schnorr_proofs = signer_test.wait_for_taproot_signatures(timeout);
 
     for frost_signature in frost_signatures {
-        assert!(frost_signature.verify(&new_key, &msg));
+        assert!(frost_signature.verify(&key, &msg));
     }
     for schnorr_proof in schnorr_proofs {
-        let tweaked_key = tweaked_public_key(&new_key, None);
+        let tweaked_key = tweaked_public_key(&key, None);
         assert!(
             schnorr_proof.verify(&tweaked_key.x(), &msg),
             "Schnorr proof verification failed"
@@ -923,8 +945,6 @@ fn stackerdb_dkg_sign() {
     } else {
         panic!("Received unexpected message: {:?}", &signer_message);
     }
-
-    info!("DKG Time Elapsed: {:.2?}", dkg_elapsed);
     info!("Sign Time Elapsed: {:.2?}", sign_elapsed);
     signer_test.shutdown();
 }

From 9ce4f97c9f58643bf627226b748b4acc9545b6e9 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 23 Feb 2024 22:02:01 -0500
Subject: [PATCH 0924/1166] Fix epoch check

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 .github/workflows/bitcoin-tests.yml | 1 +
 stacks-signer/src/signer.rs         | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/bitcoin-tests.yml b/.github/workflows/bitcoin-tests.yml
index e2447a3606..e1e4fff765 100644
--- a/.github/workflows/bitcoin-tests.yml
+++ b/.github/workflows/bitcoin-tests.yml
@@ -80,6 +80,7 @@ jobs:
           - tests::signer::stackerdb_sign
           - tests::signer::stackerdb_block_proposal
           - tests::signer::stackerdb_filter_bad_transactions
+          - tests::signer::stackerdb_mine_2_nakamoto_reward_cycles
     steps:
       ## Setup test environment
       - name: Setup Test Environment
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index 6247f83a5d..35e8ff57f6 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -1071,7 +1071,7 @@ impl Signer {
         current_reward_cycle: u64,
     ) -> Result<(), ClientError> {
         let txid = new_transaction.txid();
-        if epoch > StacksEpochId::Epoch30 {
+        if epoch >= StacksEpochId::Epoch30 {
             debug!("Signer #{}: Received a DKG result while in epoch 3.0. Broadcast the transaction only to stackerDB.", self.signer_id);
         } else if epoch == StacksEpochId::Epoch25 {
             debug!("Signer #{}: Received a DKG result while in epoch 3.0. Broadcast the transaction to the mempool.", self.signer_id);

From 0bd2ad621260417a389430b7ec269e51461aaf32 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Sat, 24 Feb 2024 16:49:38 -0500
Subject: [PATCH 0925/1166] Store commands to the side in case init fails

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/runloop.rs | 49 +++++++++++++++++++-----------------
 1 file changed, 26 insertions(+), 23 deletions(-)

diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 8dab88d018..0b6a0c05a3 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -1,3 +1,4 @@
+use std::collections::VecDeque;
 // Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
 // Copyright (C) 2020-2024 Stacks Open Internet Foundation
 //
@@ -58,6 +59,8 @@ pub struct RunLoop {
     pub stacks_signers: HashMap<u64, Signer>,
     /// The state of the runloop
     pub state: State,
+    /// The commands received thus far
+    pub commands: VecDeque<RunLoopCommand>,
 }
 
 impl From<GlobalConfig> for RunLoop {
@@ -69,6 +72,7 @@ impl From<GlobalConfig> for RunLoop {
             stacks_client,
             stacks_signers: HashMap::with_capacity(2),
             state: State::Uninitialized,
+            commands: VecDeque::new(),
         }
     }
 }
@@ -228,16 +232,21 @@ impl SignerRunLoop<Vec<OperationResult>, RunLoopCommand> for RunLoop {
         cmd: Option<RunLoopCommand>,
         res: Sender<Vec<OperationResult>>,
     ) -> Option<Vec<OperationResult>> {
-        info!(
-            "Running one pass for the signer. Current state: {:?}",
+        debug!(
+            "Running one pass for the signer. state={:?}, cmd={cmd:?}, event={event:?}",
             self.state
         );
+        if let Some(cmd) = cmd {
+            self.commands.push_back(cmd);
+        }
+        // TODO: queue events and process them potentially after initialization success (similar to commands)?
         let Ok(current_reward_cycle) = retry_with_exponential_backoff(|| {
             self.stacks_client
                 .get_current_reward_cycle()
                 .map_err(backoff::Error::transient)
         }) else {
-            error!("Failed to retrieve current reward cycle. Ignoring event: {event:?}");
+            error!("Failed to retrieve current reward cycle");
+            warn!("Ignoring event: {event:?}");
             return None;
         };
         if let Err(e) = self.refresh_signers(current_reward_cycle) {
@@ -249,9 +258,20 @@ impl SignerRunLoop<Vec<OperationResult>, RunLoopCommand> for RunLoop {
             }
             error!("Failed to refresh signers: {e}. Signer may have an outdated view of the network. Attempting to process event anyway.");
         }
-        if let Some(command) = cmd {
-            let reward_cycle = command.reward_cycle;
-            if let Some(signer) = self.stacks_signers.get_mut(&(reward_cycle % 2)) {
+        for signer in self.stacks_signers.values_mut() {
+            if let Err(e) = signer.process_event(
+                &self.stacks_client,
+                event.as_ref(),
+                res.clone(),
+                current_reward_cycle,
+            ) {
+                error!(
+                    "Signer #{} for reward cycle {} errored processing event: {e}",
+                    signer.signer_id, signer.reward_cycle
+                );
+            }
+            if let Some(command) = self.commands.pop_front() {
+                let reward_cycle = command.reward_cycle;
                 if signer.reward_cycle != reward_cycle {
                     warn!(
                         "Signer #{}: not registered for reward cycle {reward_cycle}. Ignoring command: {command:?}", signer.signer_id
@@ -268,23 +288,6 @@ impl SignerRunLoop<Vec<OperationResult>, RunLoopCommand> for RunLoop {
                     );
                     signer.commands.push_back(command.command);
                 }
-            } else {
-                warn!(
-                    "No signer registered for reward cycle {reward_cycle}. Ignoring command: {command:?}"
-                );
-            }
-        }
-        for signer in self.stacks_signers.values_mut() {
-            if let Err(e) = signer.process_event(
-                &self.stacks_client,
-                event.as_ref(),
-                res.clone(),
-                current_reward_cycle,
-            ) {
-                error!(
-                    "Signer #{} for reward cycle {} errored processing event: {e}",
-                    signer.signer_id, signer.reward_cycle
-                );
             }
             // After processing event, run the next command for each signer
             signer.process_next_command(&self.stacks_client);

From 7dfee14faac02803e67e909c6a1e7b740d847a19 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Sat, 24 Feb 2024 16:49:57 -0500
Subject: [PATCH 0926/1166] CRC: fix faulty comments

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/signer.rs | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index 35e8ff57f6..b92ed0e1de 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -237,11 +237,9 @@ impl Signer {
         match command {
             Command::Dkg => {
                 if self.approved_aggregate_public_key.is_some() {
-                    // We do not enforce a block contain any transactions except the aggregate votes when it is NOT already set
                     debug!("Signer #{}: Already have an aggregate key for reward cycle {}. Ignoring DKG command.", self.signer_id, self.reward_cycle);
                     return;
                 }
-                // If we do, we should not start a new DKG
                 let vote_round = match retry_with_exponential_backoff(|| {
                     stacks_client
                         .get_last_round(self.reward_cycle)
@@ -278,7 +276,6 @@ impl Signer {
                 merkle_root,
             } => {
                 if self.approved_aggregate_public_key.is_none() {
-                    // We cannot sign a block if we do not have an approved aggregate public key
                     debug!("Signer #{}: Cannot sign a block without an approved aggregate public key. Ignore it.", self.signer_id);
                     return;
                 }
@@ -1074,7 +1071,7 @@ impl Signer {
         if epoch >= StacksEpochId::Epoch30 {
             debug!("Signer #{}: Received a DKG result while in epoch 3.0. Broadcast the transaction only to stackerDB.", self.signer_id);
         } else if epoch == StacksEpochId::Epoch25 {
-            debug!("Signer #{}: Received a DKG result while in epoch 3.0. Broadcast the transaction to the mempool.", self.signer_id);
+            debug!("Signer #{}: Received a DKG result while in epoch 2.5. Broadcast the transaction to the mempool.", self.signer_id);
             stacks_client.submit_transaction(&new_transaction)?;
             info!(
                 "Signer #{}: Submitted DKG vote transaction ({txid:?}) to the mempool",

From e22871d6affeb417eb3b3452fa69831505738720 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Sat, 24 Feb 2024 16:50:24 -0500
Subject: [PATCH 0927/1166] Send DKG and sign to all senders and remove
 shutdown in hanging tests

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 testnet/stacks-node/src/tests/signer.rs | 87 +++++++------------------
 1 file changed, 25 insertions(+), 62 deletions(-)

diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index bb58956d46..d903f58c43 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -12,7 +12,6 @@ use libsigner::{
     BLOCK_MSG_ID,
 };
 use stacks::burnchains::Txid;
-use stacks::chainstate::burn::ConsensusHashExtensions;
 use stacks::chainstate::coordinator::comm::CoordinatorChannels;
 use stacks::chainstate::nakamoto::signer_set::NakamotoSigners;
 use stacks::chainstate::nakamoto::{NakamotoBlock, NakamotoBlockHeader, NakamotoBlockVote};
@@ -24,13 +23,12 @@ use stacks::net::api::postblock_proposal::BlockValidateResponse;
 use stacks_common::bitvec::BitVec;
 use stacks_common::codec::{read_next, StacksMessageCodec};
 use stacks_common::consts::SIGNER_SLOTS_PER_USER;
-use stacks_common::types::chainstate::{ConsensusHash, StacksBlockId, StacksPublicKey, TrieHash};
+use stacks_common::types::chainstate::{ConsensusHash, StacksBlockId, TrieHash};
 use stacks_common::types::StacksEpochId;
 use stacks_common::util::hash::{MerkleTree, Sha512Trunc256Sum};
 use stacks_common::util::secp256k1::MessageSignature;
 use stacks_signer::client::{StackerDB, StacksClient};
 use stacks_signer::config::{build_signer_config_tomls, GlobalConfig as SignerConfig, Network};
-use stacks_signer::coordinator::CoordinatorSelector;
 use stacks_signer::runloop::RunLoopCommand;
 use stacks_signer::signer::Command as SignerCommand;
 use tracing_subscriber::prelude::*;
@@ -366,6 +364,7 @@ impl SignerTest {
     }
 
     fn wait_for_dkg(&mut self, timeout: Duration) -> Point {
+        debug!("Waiting for DKG...");
         let mut key = Point::default();
         let dkg_now = Instant::now();
         for recv in self.result_receivers.iter() {
@@ -402,10 +401,12 @@ impl SignerTest {
                 "Failed to get aggregate public key within {timeout:?}"
             ));
         }
+        debug!("Finished waiting for DKG!");
         key
     }
 
     fn wait_for_frost_signatures(&mut self, timeout: Duration) -> Vec<Signature> {
+        debug!("Waiting for frost signatures...");
         let mut results = Vec::new();
         let sign_now = Instant::now();
         for recv in self.result_receivers.iter() {
@@ -443,10 +444,12 @@ impl SignerTest {
                 .expect(&format!("Failed to get frost signature within {timeout:?}"));
             results.push(frost_signature);
         }
+        debug!("Finished waiting for frost signatures!");
         results
     }
 
     fn wait_for_taproot_signatures(&mut self, timeout: Duration) -> Vec<SchnorrProof> {
+        debug!("Waiting for taproot signatures...");
         let mut results = vec![];
         let sign_now = Instant::now();
         for recv in self.result_receivers.iter() {
@@ -484,6 +487,7 @@ impl SignerTest {
             ));
             results.push(schnorr_proof);
         }
+        debug!("Finished waiting for taproot signatures!");
         results
     }
 
@@ -515,45 +519,6 @@ impl SignerTest {
             .unwrap()
     }
 
-    // Will panic if called on a reward cycle that has not had its signers calculated yet
-    fn get_coordinator_sender(&self, reward_cycle: u64) -> &Sender<RunLoopCommand> {
-        debug!(
-            "Getting current coordinator for reward cycle {:?}",
-            reward_cycle
-        );
-        // Calculate which signer is the coordinator
-        let registered_signers_info = &self
-            .stacks_client
-            .get_registered_signers_info(reward_cycle)
-            .unwrap()
-            .unwrap();
-
-        // TODO: do not use the zeroed consensus hash here
-        let coordinator_id = *CoordinatorSelector::calculate_coordinator_ids(
-            &registered_signers_info.public_keys,
-            &ConsensusHash::empty(),
-        )
-        .first()
-        .expect("No coordinator found");
-        let coordinator_pk = registered_signers_info
-            .public_keys
-            .signers
-            .get(&coordinator_id)
-            .expect("No coordinator found");
-        let coordinator_index = self
-            .signer_stacks_private_keys
-            .iter()
-            .position(|sk| {
-                let pubkey = StacksPublicKey::from_private(sk);
-                let coordinator_pk_bytes = coordinator_pk.to_bytes();
-                let pubkey_bytes = pubkey.to_bytes_compressed();
-                coordinator_pk_bytes.as_slice() == pubkey_bytes.as_slice()
-            })
-            .unwrap();
-        debug!("Coordinator is {coordinator_id:?} ({coordinator_pk:?}). Command sender found at index: {coordinator_index:?}");
-        self.signer_cmd_senders.get(coordinator_index).unwrap()
-    }
-
     fn get_signer_index(&self, reward_cycle: u64) -> u32 {
         let valid_signer_set =
             u32::try_from(reward_cycle % 2).expect("FATAL: reward_cycle % 2 exceeds u32::MAX");
@@ -789,25 +754,23 @@ fn stackerdb_dkg() {
 
     info!("------------------------- Test DKG -------------------------");
     let reward_cycle = signer_test.get_current_reward_cycle().saturating_add(1);
-    let coordinator_sender = signer_test.get_coordinator_sender(reward_cycle);
 
     // Determine the coordinator of the current node height
     info!("signer_runloop: spawn send commands to do dkg");
     let dkg_now = Instant::now();
-    coordinator_sender
-        .send(RunLoopCommand {
-            reward_cycle,
-            command: SignerCommand::Dkg,
-        })
-        .expect("failed to send DKG command");
+    for sender in signer_test.signer_cmd_senders.iter() {
+        sender
+            .send(RunLoopCommand {
+                reward_cycle,
+                command: SignerCommand::Dkg,
+            })
+            .expect("failed to send DKG command");
+    }
     let new_key = signer_test.wait_for_dkg(timeout);
     let dkg_elapsed = dkg_now.elapsed();
     assert_ne!(new_key, key);
 
     info!("DKG Time Elapsed: {:.2?}", dkg_elapsed);
-    // TODO: look into this. Cannot get this to NOT hang unless I wait a bit...
-    std::thread::sleep(Duration::from_secs(1));
-    signer_test.shutdown();
 }
 
 #[test]
@@ -868,6 +831,7 @@ fn stackerdb_sign() {
     let reward_cycle = signer_test.get_current_reward_cycle();
     // Determine the coordinator of the current node height
     info!("signer_runloop: spawn send commands to do sign");
+    let sign_now = Instant::now();
     let sign_command = RunLoopCommand {
         reward_cycle,
         command: SignerCommand::Sign {
@@ -884,14 +848,14 @@ fn stackerdb_sign() {
             merkle_root: None,
         },
     };
-    let coordinator_sender = signer_test.get_coordinator_sender(reward_cycle);
-    let sign_now = Instant::now();
-    coordinator_sender
-        .send(sign_command)
-        .expect("failed to send Sign command");
-    coordinator_sender
-        .send(sign_taproot_command)
-        .expect("failed to send Sign taproot command");
+    for sender in signer_test.signer_cmd_senders.iter() {
+        sender
+            .send(sign_command.clone())
+            .expect("failed to send sign command");
+        sender
+            .send(sign_taproot_command.clone())
+            .expect("failed to send sign taproot command");
+    }
     let frost_signatures = signer_test.wait_for_frost_signatures(timeout);
     let schnorr_proofs = signer_test.wait_for_taproot_signatures(timeout);
 
@@ -909,7 +873,7 @@ fn stackerdb_sign() {
 
     info!("------------------------- Test Block Accepted -------------------------");
 
-    // Verify the signers accepted the proposed block
+    // Verify the signers rejected the proposed block
     let t_start = Instant::now();
     let mut chunk = None;
     while chunk.is_none() {
@@ -946,7 +910,6 @@ fn stackerdb_sign() {
         panic!("Received unexpected message: {:?}", &signer_message);
     }
     info!("Sign Time Elapsed: {:.2?}", sign_elapsed);
-    signer_test.shutdown();
 }
 
 #[test]

From bd9663677edbe3ae9eff73120d1dc9520bd186f7 Mon Sep 17 00:00:00 2001
From: Marzi <marzi@trustmachines.co>
Date: Mon, 26 Feb 2024 20:55:28 -0500
Subject: [PATCH 0928/1166] Initial changes for including rewardSet in new
 block event

---
 stackslib/src/chainstate/coordinator/mod.rs   |   8 +-
 stackslib/src/chainstate/coordinator/tests.rs |   2 +
 stackslib/src/chainstate/nakamoto/mod.rs      |  32 +++-
 stackslib/src/chainstate/stacks/db/blocks.rs  | 162 ++++++++++--------
 stackslib/src/main.rs                         |   2 +-
 stackslib/src/net/mod.rs                      |   2 +
 testnet/stacks-node/src/event_dispatcher.rs   |  15 +-
 testnet/stacks-node/src/run_loop/mod.rs       |   2 +
 8 files changed, 148 insertions(+), 77 deletions(-)

diff --git a/stackslib/src/chainstate/coordinator/mod.rs b/stackslib/src/chainstate/coordinator/mod.rs
index 4e3a88c63a..100772dd22 100644
--- a/stackslib/src/chainstate/coordinator/mod.rs
+++ b/stackslib/src/chainstate/coordinator/mod.rs
@@ -177,6 +177,8 @@ pub trait BlockEventDispatcher {
         anchored_consumed: &ExecutionCost,
         mblock_confirmed_consumed: &ExecutionCost,
         pox_constants: &PoxConstants,
+        reward_set: &Option<RewardSet>,
+        cycle_number: &Option<u64>,
     );
 
     /// called whenever a burn block is about to be
@@ -363,9 +365,9 @@ impl<'a, T: BlockEventDispatcher> RewardSetProvider for OnChainRewardSetProvider
             }
         }
 
-        if let Some(dispatcher) = self.0 {
-            dispatcher.announce_reward_set(&reward_set, block_id, cycle);
-        }
+        // if let Some(dispatcher) = self.0 {
+        //     dispatcher.announce_reward_set(&reward_set, block_id, cycle);
+        // }
 
         Ok(reward_set)
     }
diff --git a/stackslib/src/chainstate/coordinator/tests.rs b/stackslib/src/chainstate/coordinator/tests.rs
index 600164e5f1..17ab3a6925 100644
--- a/stackslib/src/chainstate/coordinator/tests.rs
+++ b/stackslib/src/chainstate/coordinator/tests.rs
@@ -426,6 +426,8 @@ impl BlockEventDispatcher for NullEventDispatcher {
         _anchor_block_cost: &ExecutionCost,
         _confirmed_mblock_cost: &ExecutionCost,
         _pox_constants: &PoxConstants,
+        _reward_set: &Option<RewardSet>,
+        _cycle_number: &Option<u64>,
     ) {
         assert!(
             false,
diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index 13b08b8db0..a86ab82a66 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -1376,7 +1376,8 @@ impl NakamotoChainState {
             return Err(e);
         };
 
-        let (receipt, clarity_commit) = ok_opt.expect("FATAL: unreachable");
+        let (receipt, clarity_commit, reward_set, cycle_number) =
+            ok_opt.expect("FATAL: unreachable");
 
         assert_eq!(
             receipt.header.anchored_header.block_hash(),
@@ -1432,6 +1433,8 @@ impl NakamotoChainState {
                 &receipt.anchored_block_cost,
                 &receipt.parent_microblocks_cost,
                 &pox_constants,
+                &reward_set,
+                &cycle_number,
             );
         }
 
@@ -2660,7 +2663,15 @@ impl NakamotoChainState {
         block_size: u64,
         burnchain_commit_burn: u64,
         burnchain_sortition_burn: u64,
-    ) -> Result<(StacksEpochReceipt, PreCommitClarityBlock<'a>), ChainstateError> {
+    ) -> Result<
+        (
+            StacksEpochReceipt,
+            PreCommitClarityBlock<'a>,
+            Option<RewardSet>,
+            Option<u64>,
+        ),
+        ChainstateError,
+    > {
         debug!(
             "Process block {:?} with {} transactions",
             &block.header.block_hash().to_hex(),
@@ -2983,8 +2994,16 @@ impl NakamotoChainState {
         // NOTE: miner and proposal evaluation should not invoke this because
         //  it depends on knowing the StacksBlockId.
         let signers_updated = signer_set_calc.is_some();
+        let mut reward_set = None;
+        let mut cycle_of_prepare_phase = None;
         if let Some(signer_calculation) = signer_set_calc {
-            Self::write_reward_set(chainstate_tx, &new_block_id, &signer_calculation.reward_set)?
+            reward_set = Some(signer_calculation.reward_set.clone());
+            Self::write_reward_set(chainstate_tx, &new_block_id, &signer_calculation.reward_set)?;
+            let first_block_height = burn_dbconn.get_burn_start_height();
+            cycle_of_prepare_phase = pox_constants.reward_cycle_of_prepare_phase(
+                first_block_height.into(),
+                chain_tip_burn_header_height.into(),
+            );
         }
 
         monitoring::set_last_block_transaction_count(u64::try_from(block.txs.len()).unwrap());
@@ -3026,7 +3045,12 @@ impl NakamotoChainState {
             signers_updated,
         };
 
-        Ok((epoch_receipt, clarity_commit))
+        Ok((
+            epoch_receipt,
+            clarity_commit,
+            reward_set,
+            cycle_of_prepare_phase,
+        ))
     }
 
     /// Create a StackerDB config for the .miners contract.
diff --git a/stackslib/src/chainstate/stacks/db/blocks.rs b/stackslib/src/chainstate/stacks/db/blocks.rs
index ba190d9811..b4b6ed7ce3 100644
--- a/stackslib/src/chainstate/stacks/db/blocks.rs
+++ b/stackslib/src/chainstate/stacks/db/blocks.rs
@@ -191,6 +191,8 @@ impl BlockEventDispatcher for DummyEventDispatcher {
         _anchor_block_cost: &ExecutionCost,
         _confirmed_mblock_cost: &ExecutionCost,
         _pox_constants: &PoxConstants,
+        _reward_set: &Option<RewardSet>,
+        _cycle_number: &Option<u64>,
     ) {
         assert!(
             false,
@@ -5291,7 +5293,15 @@ impl StacksChainState {
         user_burns: &[StagingUserBurnSupport],
         affirmation_weight: u64,
         do_not_advance: bool,
-    ) -> Result<(StacksEpochReceipt, PreCommitClarityBlock<'a>), Error> {
+    ) -> Result<
+        (
+            StacksEpochReceipt,
+            PreCommitClarityBlock<'a>,
+            Option<RewardSet>,
+            Option<u64>,
+        ),
+        Error,
+    > {
         debug!(
             "Process block {:?} with {} transactions",
             &block.block_hash().to_hex(),
@@ -5678,7 +5688,7 @@ impl StacksChainState {
                 signers_updated: false,
             };
 
-            return Ok((epoch_receipt, clarity_commit));
+            return Ok((epoch_receipt, clarity_commit, None, None));
         }
 
         let parent_block_header = parent_chain_tip
@@ -5715,13 +5725,21 @@ impl StacksChainState {
         // NOTE: miner and proposal evaluation should not invoke this because
         //  it depends on knowing the StacksBlockId.
         let signers_updated = signer_set_calc.is_some();
+        let mut reward_set = None;
+        let mut cycle_of_prepare_phase = None;
         if let Some(signer_calculation) = signer_set_calc {
+            reward_set = Some(signer_calculation.reward_set.clone());
             let new_block_id = new_tip.index_block_hash();
             NakamotoChainState::write_reward_set(
                 chainstate_tx,
                 &new_block_id,
                 &signer_calculation.reward_set,
-            )?
+            )?;
+            let first_block_height = burn_dbconn.get_burn_start_height();
+            cycle_of_prepare_phase = pox_constants.reward_cycle_of_prepare_phase(
+                first_block_height.into(),
+                parent_burn_block_height.into(),
+            );
         }
 
         set_last_block_transaction_count(
@@ -5744,7 +5762,12 @@ impl StacksChainState {
             signers_updated,
         };
 
-        Ok((epoch_receipt, clarity_commit))
+        Ok((
+            epoch_receipt,
+            clarity_commit,
+            reward_set,
+            cycle_of_prepare_phase,
+        ))
     }
 
     /// Verify that a Stacks anchored block attaches to its parent anchored block.
@@ -6076,80 +6099,81 @@ impl StacksChainState {
         // Execute the confirmed microblocks' transactions against the chain state, and then
         // execute the anchored block's transactions against the chain state.
         let pox_constants = sort_tx.context.pox_constants.clone();
-        let (epoch_receipt, clarity_commit) = match StacksChainState::append_block(
-            &mut chainstate_tx,
-            clarity_instance,
-            sort_tx,
-            &pox_constants,
-            &parent_header_info,
-            &next_staging_block.consensus_hash,
-            &burn_header_hash,
-            burn_header_height,
-            burn_header_timestamp,
-            &block,
-            block_size,
-            &next_microblocks,
-            next_staging_block.commit_burn,
-            next_staging_block.sortition_burn,
-            &user_supports,
-            block_am.weight(),
-            false,
-        ) {
-            Ok(next_chain_tip_info) => next_chain_tip_info,
-            Err(e) => {
-                // something's wrong with this epoch -- either a microblock was invalid, or the
-                // anchored block was invalid.  Either way, the anchored block will _never be_
-                // valid, so we can drop it from the chunk store and orphan all of its descendants.
-                test_debug!(
-                    "Failed to append {}/{}",
-                    &next_staging_block.consensus_hash,
-                    &block.block_hash()
-                );
-                StacksChainState::set_block_processed(
-                    chainstate_tx.deref_mut(),
-                    None,
-                    &blocks_path,
-                    &next_staging_block.consensus_hash,
-                    &block.header.block_hash(),
-                    false,
-                )?;
-                StacksChainState::free_block_state(
-                    &blocks_path,
-                    &next_staging_block.consensus_hash,
-                    &block.header,
-                );
+        let (epoch_receipt, clarity_commit, reward_set, cycle_number) =
+            match StacksChainState::append_block(
+                &mut chainstate_tx,
+                clarity_instance,
+                sort_tx,
+                &pox_constants,
+                &parent_header_info,
+                &next_staging_block.consensus_hash,
+                &burn_header_hash,
+                burn_header_height,
+                burn_header_timestamp,
+                &block,
+                block_size,
+                &next_microblocks,
+                next_staging_block.commit_burn,
+                next_staging_block.sortition_burn,
+                &user_supports,
+                block_am.weight(),
+                false,
+            ) {
+                Ok(next_chain_tip_info) => next_chain_tip_info,
+                Err(e) => {
+                    // something's wrong with this epoch -- either a microblock was invalid, or the
+                    // anchored block was invalid.  Either way, the anchored block will _never be_
+                    // valid, so we can drop it from the chunk store and orphan all of its descendants.
+                    test_debug!(
+                        "Failed to append {}/{}",
+                        &next_staging_block.consensus_hash,
+                        &block.block_hash()
+                    );
+                    StacksChainState::set_block_processed(
+                        chainstate_tx.deref_mut(),
+                        None,
+                        &blocks_path,
+                        &next_staging_block.consensus_hash,
+                        &block.header.block_hash(),
+                        false,
+                    )?;
+                    StacksChainState::free_block_state(
+                        &blocks_path,
+                        &next_staging_block.consensus_hash,
+                        &block.header,
+                    );
 
-                match e {
-                    Error::InvalidStacksMicroblock(ref msg, ref header_hash) => {
-                        // specifically, an ancestor microblock was invalid.  Drop any descendant microblocks --
-                        // they're never going to be valid in _any_ fork, even if they have a clone
-                        // in a neighboring burnchain fork.
-                        error!(
+                    match e {
+                        Error::InvalidStacksMicroblock(ref msg, ref header_hash) => {
+                            // specifically, an ancestor microblock was invalid.  Drop any descendant microblocks --
+                            // they're never going to be valid in _any_ fork, even if they have a clone
+                            // in a neighboring burnchain fork.
+                            error!(
                             "Parent microblock stream from {}/{} is invalid at microblock {}: {}",
                             parent_header_info.consensus_hash,
                             parent_header_info.anchored_header.block_hash(),
                             header_hash,
                             msg
                         );
-                        StacksChainState::drop_staging_microblocks(
-                            chainstate_tx.deref_mut(),
-                            &parent_header_info.consensus_hash,
-                            &parent_header_info.anchored_header.block_hash(),
-                            header_hash,
-                        )?;
-                    }
-                    _ => {
-                        // block was invalid, but this means all the microblocks it confirmed are
-                        // still (potentially) valid.  However, they are not confirmed yet, so
-                        // leave them in the staging database.
+                            StacksChainState::drop_staging_microblocks(
+                                chainstate_tx.deref_mut(),
+                                &parent_header_info.consensus_hash,
+                                &parent_header_info.anchored_header.block_hash(),
+                                header_hash,
+                            )?;
+                        }
+                        _ => {
+                            // block was invalid, but this means all the microblocks it confirmed are
+                            // still (potentially) valid.  However, they are not confirmed yet, so
+                            // leave them in the staging database.
+                        }
                     }
-                }
 
-                chainstate_tx.commit().map_err(Error::DBError)?;
+                    chainstate_tx.commit().map_err(Error::DBError)?;
 
-                return Err(e);
-            }
-        };
+                    return Err(e);
+                }
+            };
 
         let receipt_anchored_header = epoch_receipt
             .header
@@ -6213,6 +6237,8 @@ impl StacksChainState {
                 &epoch_receipt.anchored_block_cost,
                 &epoch_receipt.parent_microblocks_cost,
                 &pox_constants,
+                &reward_set,
+                &cycle_number,
             );
         }
 
diff --git a/stackslib/src/main.rs b/stackslib/src/main.rs
index e964637b60..e441e3e5ab 100644
--- a/stackslib/src/main.rs
+++ b/stackslib/src/main.rs
@@ -1722,7 +1722,7 @@ fn replay_block(stacks_path: &str, index_block_hash_hex: &str) {
         block_am.weight(),
         true,
     ) {
-        Ok((_receipt, _)) => {
+        Ok((_receipt, _, _, _)) => {
             info!("Block processed successfully! block = {index_block_hash}");
         }
         Err(e) => {
diff --git a/stackslib/src/net/mod.rs b/stackslib/src/net/mod.rs
index 0c1725d6b9..97069f6934 100644
--- a/stackslib/src/net/mod.rs
+++ b/stackslib/src/net/mod.rs
@@ -1903,6 +1903,8 @@ pub mod test {
             _anchor_block_cost: &ExecutionCost,
             _confirmed_mblock_cost: &ExecutionCost,
             pox_constants: &PoxConstants,
+            reward_set: &Option<RewardSet>,
+            cycle_number: &Option<u64>,
         ) {
             self.blocks.lock().unwrap().push(TestEventObserverBlock {
                 block: block.clone(),
diff --git a/testnet/stacks-node/src/event_dispatcher.rs b/testnet/stacks-node/src/event_dispatcher.rs
index 90272bd0b8..45febe497a 100644
--- a/testnet/stacks-node/src/event_dispatcher.rs
+++ b/testnet/stacks-node/src/event_dispatcher.rs
@@ -589,6 +589,8 @@ impl BlockEventDispatcher for EventDispatcher {
         anchored_consumed: &ExecutionCost,
         mblock_confirmed_consumed: &ExecutionCost,
         pox_constants: &PoxConstants,
+        reward_set: &Option<RewardSet>,
+        cycle_number: &Option<u64>,
     ) {
         self.process_chain_tip(
             block,
@@ -604,7 +606,18 @@ impl BlockEventDispatcher for EventDispatcher {
             anchored_consumed,
             mblock_confirmed_consumed,
             pox_constants,
-        )
+        );
+
+        if let Some(reward_set) = reward_set {
+            debug!(
+                "reward_set in announce_block: {:?}, parent_block_id: {:?}, cycle_number: {:?}",
+                reward_set, parent, cycle_number
+            );
+            if let Some(cycle_num) = cycle_number {
+                //
+                self.process_stacker_set(reward_set, parent, *cycle_num)
+            }
+        }
     }
 
     fn announce_burn_block(
diff --git a/testnet/stacks-node/src/run_loop/mod.rs b/testnet/stacks-node/src/run_loop/mod.rs
index 19b41c6fa3..01f848c2e6 100644
--- a/testnet/stacks-node/src/run_loop/mod.rs
+++ b/testnet/stacks-node/src/run_loop/mod.rs
@@ -192,5 +192,7 @@ pub fn announce_boot_receipts(
         &ExecutionCost::zero(),
         &ExecutionCost::zero(),
         pox_constants,
+        &None,
+        &None,
     );
 }

From 50c1549a2171da19f867dfc6bc203a356de82e34 Mon Sep 17 00:00:00 2001
From: ASuciuX <151519329+ASuciuX@users.noreply.github.com>
Date: Tue, 27 Feb 2024 14:04:53 +0200
Subject: [PATCH 0929/1166] Update .github/workflows/pr-differences-mutants.yml

Co-authored-by: Jeff Bencin <jeff.bencin@gmail.com>
---
 .github/workflows/pr-differences-mutants.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/pr-differences-mutants.yml b/.github/workflows/pr-differences-mutants.yml
index 0e76c1c15a..fc4a725687 100644
--- a/.github/workflows/pr-differences-mutants.yml
+++ b/.github/workflows/pr-differences-mutants.yml
@@ -185,7 +185,7 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - name: Run Run mutants on diffs
+      - name: Run mutants on diffs
         uses: stacks-network/actions/stacks-core/mutation-testing/pr-differences@main
         with:
           package: 'stacks-signer'

From e7c6592b6bd7bd73f540159a067006196ee1086e Mon Sep 17 00:00:00 2001
From: MarvinJanssen <MarvinJanssen@users.noreply.github.com>
Date: Wed, 27 Dec 2023 15:50:34 +0100
Subject: [PATCH 0930/1166] feat: add clarunit with basic usage example

---
 contrib/core-contract-tests/Clarinet.toml     |    3 +
 contrib/core-contract-tests/package-lock.json | 2480 ++++++++++++++---
 contrib/core-contract-tests/package.json      |    3 +-
 .../core-contract-tests/tests/bns_test.clar   |    9 +
 .../tests/clarunit.test.ts                    |    2 +
 5 files changed, 2122 insertions(+), 375 deletions(-)
 create mode 100644 contrib/core-contract-tests/tests/bns_test.clar
 create mode 100644 contrib/core-contract-tests/tests/clarunit.test.ts

diff --git a/contrib/core-contract-tests/Clarinet.toml b/contrib/core-contract-tests/Clarinet.toml
index 7bd70e4745..f3e59d3161 100644
--- a/contrib/core-contract-tests/Clarinet.toml
+++ b/contrib/core-contract-tests/Clarinet.toml
@@ -27,3 +27,6 @@ path = "../../stackslib/src/chainstate/stacks/boot/signers-voting.clar"
 depends_on = []
 clarity = 2
 epoch = 2.4
+
+[contracts.bns_test]
+path = "./tests/bns_test.clar"
diff --git a/contrib/core-contract-tests/package-lock.json b/contrib/core-contract-tests/package-lock.json
index e5c3e22e18..b29bb4716d 100644
--- a/contrib/core-contract-tests/package-lock.json
+++ b/contrib/core-contract-tests/package-lock.json
@@ -12,12 +12,28 @@
         "@hirosystems/clarinet-sdk": "^1.1.0",
         "@stacks/transactions": "^6.9.0",
         "chokidar-cli": "^3.0.0",
+        "clarunit": "github:MarvinJanssen/clarunit#a5c042a",
         "typescript": "^5.2.2",
         "vite": "^4.4.9",
         "vitest": "^0.34.4",
         "vitest-environment-clarinet": "^1.0.0"
       }
     },
+    "node_modules/@esbuild/aix-ppc64": {
+      "version": "0.19.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.19.10.tgz",
+      "integrity": "sha512-Q+mk96KJ+FZ30h9fsJl+67IjNJm3x2eX+GBWGmocAKgzp27cowCOOqSdscX80s0SpdFXZnIv/+1xD1EctFx96Q==",
+      "cpu": [
+        "ppc64"
+      ],
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
     "node_modules/@esbuild/android-arm": {
       "version": "0.18.20",
       "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.18.20.tgz",
@@ -349,15 +365,15 @@
       }
     },
     "node_modules/@hirosystems/clarinet-sdk": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@hirosystems/clarinet-sdk/-/clarinet-sdk-1.1.0.tgz",
-      "integrity": "sha512-O4iP+eqc2jtbCJcndC22l12ODIi8GxwUcWhWaltvnPBn+PXqCLxDqNU78C6iDCfPp/Ro2fcJy9z27KNqnu+A9g==",
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/@hirosystems/clarinet-sdk/-/clarinet-sdk-1.2.0.tgz",
+      "integrity": "sha512-O0Gyh3pwwOVJTbLlxHG6vSB/KXr+U/nZzd2kpubQO4Qqxjn5/vo8l8J+/fwKOxhzM4QOa42M1sCaVZSB/PkTFg==",
       "dependencies": {
-        "@hirosystems/clarinet-sdk-wasm": "^1.1.0",
+        "@hirosystems/clarinet-sdk-wasm": "^1.2.0",
         "@stacks/transactions": "^6.9.0",
         "kolorist": "^1.8.0",
         "prompts": "^2.4.2",
-        "vitest": "^0.34.5",
+        "vitest": "^1.0.4",
         "yargs": "^17.7.2"
       },
       "bin": {
@@ -368,465 +384,1963 @@
       }
     },
     "node_modules/@hirosystems/clarinet-sdk-wasm": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@hirosystems/clarinet-sdk-wasm/-/clarinet-sdk-wasm-1.1.0.tgz",
-      "integrity": "sha512-hGf2Ib6qYVnhV2+idW1GuOsh1Fom4fhp+QYjxHmfGQvx9ptSb037/4YVlep+jbO4hKXHHF2uQJgKMRPwVrtN2g=="
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/@hirosystems/clarinet-sdk-wasm/-/clarinet-sdk-wasm-1.2.0.tgz",
+      "integrity": "sha512-TnJ243lEgIqHSIeMdEHi1hJceFBJ5mWfjfXv86GKaoyVOS6yX1vGL2a6ZuVO9FfWPNxsiSvaQV/FndVuansAVQ=="
     },
-    "node_modules/@jest/schemas": {
-      "version": "29.6.3",
-      "resolved": "https://registry.npmjs.org/@jest/schemas/-/schemas-29.6.3.tgz",
-      "integrity": "sha512-mo5j5X+jIZmJQveBKeS/clAueipV7KgiX1vMgCxam1RNYiqE1w62n0/tJJnHtjW8ZHcQco5gY85jA3mi0L+nSA==",
-      "dependencies": {
-        "@sinclair/typebox": "^0.27.8"
-      },
+    "node_modules/@hirosystems/clarinet-sdk/node_modules/@esbuild/android-arm": {
+      "version": "0.19.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.19.10.tgz",
+      "integrity": "sha512-7W0bK7qfkw1fc2viBfrtAEkDKHatYfHzr/jKAHNr9BvkYDXPcC6bodtm8AyLJNNuqClLNaeTLuwURt4PRT9d7w==",
+      "cpu": [
+        "arm"
+      ],
+      "optional": true,
+      "os": [
+        "android"
+      ],
       "engines": {
-        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
-      }
-    },
-    "node_modules/@jridgewell/sourcemap-codec": {
-      "version": "1.4.15",
-      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.15.tgz",
-      "integrity": "sha512-eF2rxCRulEKXHTRiDrDy6erMYWqNw4LPdQ8UQA4huuxaQsVeRPFl2oM8oDGxMFhJUWZf9McpLtJasDDZb/Bpeg=="
-    },
-    "node_modules/@noble/hashes": {
-      "version": "1.1.5",
-      "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-1.1.5.tgz",
-      "integrity": "sha512-LTMZiiLc+V4v1Yi16TD6aX2gmtKszNye0pQgbaLqkvhIqP7nVsSaJsWloGQjJfJ8offaoP5GtX3yY5swbcJxxQ==",
-      "funding": [
-        {
-          "type": "individual",
-          "url": "https://paulmillr.com/funding/"
-        }
-      ]
-    },
-    "node_modules/@noble/secp256k1": {
-      "version": "1.7.1",
-      "resolved": "https://registry.npmjs.org/@noble/secp256k1/-/secp256k1-1.7.1.tgz",
-      "integrity": "sha512-hOUk6AyBFmqVrv7k5WAw/LpszxVbj9gGN4JRkIX52fdFAj1UA61KXmZDvqVEm+pOyec3+fIeZB02LYa/pWOArw==",
-      "funding": [
-        {
-          "type": "individual",
-          "url": "https://paulmillr.com/funding/"
-        }
-      ]
-    },
-    "node_modules/@sinclair/typebox": {
-      "version": "0.27.8",
-      "resolved": "https://registry.npmjs.org/@sinclair/typebox/-/typebox-0.27.8.tgz",
-      "integrity": "sha512-+Fj43pSMwJs4KRrH/938Uf+uAELIgVBmQzg/q1YG10djyfA3TnrU8N8XzqCh/okZdszqBQTZf96idMfE5lnwTA=="
-    },
-    "node_modules/@stacks/common": {
-      "version": "6.8.1",
-      "resolved": "https://registry.npmjs.org/@stacks/common/-/common-6.8.1.tgz",
-      "integrity": "sha512-ewL9GLZNQYa5a/3K4xSHlHIgHkD4rwWW/QEaPId8zQIaL+1O9qCaF4LX9orNQeOmEk8kvG0x2xGV54fXKCZeWQ==",
-      "dependencies": {
-        "@types/bn.js": "^5.1.0",
-        "@types/node": "^18.0.4"
+        "node": ">=12"
       }
     },
-    "node_modules/@stacks/network": {
-      "version": "6.8.1",
-      "resolved": "https://registry.npmjs.org/@stacks/network/-/network-6.8.1.tgz",
-      "integrity": "sha512-n8M25pPbLqpSBctabtsLOTBlmPvm9EPQpTI//x7HLdt5lEjDXxauEQt0XGSvDUZwecrmztqt9xNxlciiGApRBw==",
-      "dependencies": {
-        "@stacks/common": "^6.8.1",
-        "cross-fetch": "^3.1.5"
+    "node_modules/@hirosystems/clarinet-sdk/node_modules/@esbuild/android-arm64": {
+      "version": "0.19.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.19.10.tgz",
+      "integrity": "sha512-1X4CClKhDgC3by7k8aOWZeBXQX8dHT5QAMCAQDArCLaYfkppoARvh0fit3X2Qs+MXDngKcHv6XXyQCpY0hkK1Q==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
       }
     },
-    "node_modules/@stacks/transactions": {
-      "version": "6.9.0",
-      "resolved": "https://registry.npmjs.org/@stacks/transactions/-/transactions-6.9.0.tgz",
-      "integrity": "sha512-hSs9+0Ew++GwMZMgPObOx0iVCQRxkiCqI+DHdPEikAmg2utpyLh2/txHOjfSIkQHvcBfJJ6O5KphmxDP4gUqiA==",
-      "dependencies": {
-        "@noble/hashes": "1.1.5",
-        "@noble/secp256k1": "1.7.1",
-        "@stacks/common": "^6.8.1",
-        "@stacks/network": "^6.8.1",
-        "c32check": "^2.0.0",
-        "lodash.clonedeep": "^4.5.0"
+    "node_modules/@hirosystems/clarinet-sdk/node_modules/@esbuild/android-x64": {
+      "version": "0.19.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.19.10.tgz",
+      "integrity": "sha512-O/nO/g+/7NlitUxETkUv/IvADKuZXyH4BHf/g/7laqKC4i/7whLpB0gvpPc2zpF0q9Q6FXS3TS75QHac9MvVWw==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
       }
     },
-    "node_modules/@types/bn.js": {
-      "version": "5.1.4",
-      "resolved": "https://registry.npmjs.org/@types/bn.js/-/bn.js-5.1.4.tgz",
-      "integrity": "sha512-ZtBd9L8hVtoBpPMSWfbwjC4dhQtJdlPS+e1A0Rydb7vg7bDcUwiRklPx24sMYtXcmAMST/k0Wze7JLbNU/5SkA==",
-      "dependencies": {
-        "@types/node": "*"
+    "node_modules/@hirosystems/clarinet-sdk/node_modules/@esbuild/darwin-arm64": {
+      "version": "0.19.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.19.10.tgz",
+      "integrity": "sha512-YSRRs2zOpwypck+6GL3wGXx2gNP7DXzetmo5pHXLrY/VIMsS59yKfjPizQ4lLt5vEI80M41gjm2BxrGZ5U+VMA==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=12"
       }
     },
-    "node_modules/@types/chai": {
-      "version": "4.3.9",
-      "resolved": "https://registry.npmjs.org/@types/chai/-/chai-4.3.9.tgz",
-      "integrity": "sha512-69TtiDzu0bcmKQv3yg1Zx409/Kd7r0b5F1PfpYJfSHzLGtB53547V4u+9iqKYsTu/O2ai6KTb0TInNpvuQ3qmg=="
-    },
-    "node_modules/@types/chai-subset": {
-      "version": "1.3.4",
-      "resolved": "https://registry.npmjs.org/@types/chai-subset/-/chai-subset-1.3.4.tgz",
-      "integrity": "sha512-CCWNXrJYSUIojZ1149ksLl3AN9cmZ5djf+yUoVVV+NuYrtydItQVlL2ZDqyC6M6O9LWRnVf8yYDxbXHO2TfQZg==",
-      "dependencies": {
-        "@types/chai": "*"
+    "node_modules/@hirosystems/clarinet-sdk/node_modules/@esbuild/darwin-x64": {
+      "version": "0.19.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.19.10.tgz",
+      "integrity": "sha512-alfGtT+IEICKtNE54hbvPg13xGBe4GkVxyGWtzr+yHO7HIiRJppPDhOKq3zstTcVf8msXb/t4eavW3jCDpMSmA==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=12"
       }
     },
-    "node_modules/@types/node": {
-      "version": "18.18.8",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-18.18.8.tgz",
-      "integrity": "sha512-OLGBaaK5V3VRBS1bAkMVP2/W9B+H8meUfl866OrMNQqt7wDgdpWPp5o6gmIc9pB+lIQHSq4ZL8ypeH1vPxcPaQ==",
-      "dependencies": {
-        "undici-types": "~5.26.4"
+    "node_modules/@hirosystems/clarinet-sdk/node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.19.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.19.10.tgz",
+      "integrity": "sha512-dMtk1wc7FSH8CCkE854GyGuNKCewlh+7heYP/sclpOG6Cectzk14qdUIY5CrKDbkA/OczXq9WesqnPl09mj5dg==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
       }
     },
-    "node_modules/@vitest/expect": {
-      "version": "0.34.6",
-      "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-0.34.6.tgz",
-      "integrity": "sha512-QUzKpUQRc1qC7qdGo7rMK3AkETI7w18gTCUrsNnyjjJKYiuUB9+TQK3QnR1unhCnWRC0AbKv2omLGQDF/mIjOw==",
-      "dependencies": {
-        "@vitest/spy": "0.34.6",
-        "@vitest/utils": "0.34.6",
-        "chai": "^4.3.10"
-      },
-      "funding": {
-        "url": "https://opencollective.com/vitest"
+    "node_modules/@hirosystems/clarinet-sdk/node_modules/@esbuild/freebsd-x64": {
+      "version": "0.19.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.19.10.tgz",
+      "integrity": "sha512-G5UPPspryHu1T3uX8WiOEUa6q6OlQh6gNl4CO4Iw5PS+Kg5bVggVFehzXBJY6X6RSOMS8iXDv2330VzaObm4Ag==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
       }
     },
-    "node_modules/@vitest/runner": {
-      "version": "0.34.6",
-      "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-0.34.6.tgz",
-      "integrity": "sha512-1CUQgtJSLF47NnhN+F9X2ycxUP0kLHQ/JWvNHbeBfwW8CzEGgeskzNnHDyv1ieKTltuR6sdIHV+nmR6kPxQqzQ==",
-      "dependencies": {
-        "@vitest/utils": "0.34.6",
-        "p-limit": "^4.0.0",
-        "pathe": "^1.1.1"
-      },
-      "funding": {
-        "url": "https://opencollective.com/vitest"
+    "node_modules/@hirosystems/clarinet-sdk/node_modules/@esbuild/linux-arm": {
+      "version": "0.19.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.19.10.tgz",
+      "integrity": "sha512-j6gUW5aAaPgD416Hk9FHxn27On28H4eVI9rJ4az7oCGTFW48+LcgNDBN+9f8rKZz7EEowo889CPKyeaD0iw9Kg==",
+      "cpu": [
+        "arm"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
       }
     },
-    "node_modules/@vitest/snapshot": {
-      "version": "0.34.6",
-      "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-0.34.6.tgz",
-      "integrity": "sha512-B3OZqYn6k4VaN011D+ve+AA4whM4QkcwcrwaKwAbyyvS/NB1hCWjFIBQxAQQSQir9/RtyAAGuq+4RJmbn2dH4w==",
-      "dependencies": {
-        "magic-string": "^0.30.1",
-        "pathe": "^1.1.1",
-        "pretty-format": "^29.5.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/vitest"
+    "node_modules/@hirosystems/clarinet-sdk/node_modules/@esbuild/linux-arm64": {
+      "version": "0.19.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.19.10.tgz",
+      "integrity": "sha512-QxaouHWZ+2KWEj7cGJmvTIHVALfhpGxo3WLmlYfJ+dA5fJB6lDEIg+oe/0//FuyVHuS3l79/wyBxbHr0NgtxJQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
       }
     },
-    "node_modules/@vitest/spy": {
-      "version": "0.34.6",
-      "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-0.34.6.tgz",
-      "integrity": "sha512-xaCvneSaeBw/cz8ySmF7ZwGvL0lBjfvqc1LpQ/vcdHEvpLn3Ff1vAvjw+CoGn0802l++5L/pxb7whwcWAw+DUQ==",
-      "dependencies": {
-        "tinyspy": "^2.1.1"
-      },
-      "funding": {
-        "url": "https://opencollective.com/vitest"
+    "node_modules/@hirosystems/clarinet-sdk/node_modules/@esbuild/linux-ia32": {
+      "version": "0.19.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.19.10.tgz",
+      "integrity": "sha512-4ub1YwXxYjj9h1UIZs2hYbnTZBtenPw5NfXCRgEkGb0b6OJ2gpkMvDqRDYIDRjRdWSe/TBiZltm3Y3Q8SN1xNg==",
+      "cpu": [
+        "ia32"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
       }
     },
-    "node_modules/@vitest/utils": {
-      "version": "0.34.6",
-      "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-0.34.6.tgz",
-      "integrity": "sha512-IG5aDD8S6zlvloDsnzHw0Ut5xczlF+kv2BOTo+iXfPr54Yhi5qbVOgGB1hZaVq4iJ4C/MZ2J0y15IlsV/ZcI0A==",
-      "dependencies": {
-        "diff-sequences": "^29.4.3",
-        "loupe": "^2.3.6",
-        "pretty-format": "^29.5.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/vitest"
+    "node_modules/@hirosystems/clarinet-sdk/node_modules/@esbuild/linux-loong64": {
+      "version": "0.19.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.19.10.tgz",
+      "integrity": "sha512-lo3I9k+mbEKoxtoIbM0yC/MZ1i2wM0cIeOejlVdZ3D86LAcFXFRdeuZmh91QJvUTW51bOK5W2BznGNIl4+mDaA==",
+      "cpu": [
+        "loong64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
       }
     },
-    "node_modules/acorn": {
-      "version": "8.11.2",
-      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.11.2.tgz",
-      "integrity": "sha512-nc0Axzp/0FILLEVsm4fNwLCwMttvhEI263QtVPQcbpfZZ3ts0hLsZGOpE6czNlid7CJ9MlyH8reXkpsf3YUY4w==",
-      "bin": {
-        "acorn": "bin/acorn"
-      },
+    "node_modules/@hirosystems/clarinet-sdk/node_modules/@esbuild/linux-mips64el": {
+      "version": "0.19.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.19.10.tgz",
+      "integrity": "sha512-J4gH3zhHNbdZN0Bcr1QUGVNkHTdpijgx5VMxeetSk6ntdt+vR1DqGmHxQYHRmNb77tP6GVvD+K0NyO4xjd7y4A==",
+      "cpu": [
+        "mips64el"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
       "engines": {
-        "node": ">=0.4.0"
+        "node": ">=12"
       }
     },
-    "node_modules/acorn-walk": {
-      "version": "8.3.0",
-      "resolved": "https://registry.npmjs.org/acorn-walk/-/acorn-walk-8.3.0.tgz",
-      "integrity": "sha512-FS7hV565M5l1R08MXqo8odwMTB02C2UqzB17RVgu9EyuYFBqJZ3/ZY97sQD5FewVu1UyDFc1yztUDrAwT0EypA==",
+    "node_modules/@hirosystems/clarinet-sdk/node_modules/@esbuild/linux-ppc64": {
+      "version": "0.19.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.19.10.tgz",
+      "integrity": "sha512-tgT/7u+QhV6ge8wFMzaklOY7KqiyitgT1AUHMApau32ZlvTB/+efeCtMk4eXS+uEymYK249JsoiklZN64xt6oQ==",
+      "cpu": [
+        "ppc64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
       "engines": {
-        "node": ">=0.4.0"
+        "node": ">=12"
       }
     },
-    "node_modules/ansi-regex": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
-      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+    "node_modules/@hirosystems/clarinet-sdk/node_modules/@esbuild/linux-riscv64": {
+      "version": "0.19.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.19.10.tgz",
+      "integrity": "sha512-0f/spw0PfBMZBNqtKe5FLzBDGo0SKZKvMl5PHYQr3+eiSscfJ96XEknCe+JoOayybWUFQbcJTrk946i3j9uYZA==",
+      "cpu": [
+        "riscv64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
       "engines": {
-        "node": ">=8"
+        "node": ">=12"
       }
     },
-    "node_modules/ansi-styles": {
-      "version": "5.2.0",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-5.2.0.tgz",
-      "integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==",
+    "node_modules/@hirosystems/clarinet-sdk/node_modules/@esbuild/linux-s390x": {
+      "version": "0.19.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.19.10.tgz",
+      "integrity": "sha512-pZFe0OeskMHzHa9U38g+z8Yx5FNCLFtUnJtQMpwhS+r4S566aK2ci3t4NCP4tjt6d5j5uo4h7tExZMjeKoehAA==",
+      "cpu": [
+        "s390x"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
       "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+        "node": ">=12"
       }
     },
-    "node_modules/anymatch": {
-      "version": "3.1.3",
-      "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz",
-      "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==",
-      "dependencies": {
-        "normalize-path": "^3.0.0",
-        "picomatch": "^2.0.4"
-      },
+    "node_modules/@hirosystems/clarinet-sdk/node_modules/@esbuild/linux-x64": {
+      "version": "0.19.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.19.10.tgz",
+      "integrity": "sha512-SpYNEqg/6pZYoc+1zLCjVOYvxfZVZj6w0KROZ3Fje/QrM3nfvT2llI+wmKSrWuX6wmZeTapbarvuNNK/qepSgA==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
       "engines": {
-        "node": ">= 8"
+        "node": ">=12"
       }
     },
-    "node_modules/assertion-error": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-1.1.0.tgz",
-      "integrity": "sha512-jgsaNduz+ndvGyFt3uSuWqvy4lCnIJiovtouQN5JZHOKCS2QuhEdbcQHFhVksz2N2U9hXJo8odG7ETyWlEeuDw==",
+    "node_modules/@hirosystems/clarinet-sdk/node_modules/@esbuild/netbsd-x64": {
+      "version": "0.19.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.19.10.tgz",
+      "integrity": "sha512-ACbZ0vXy9zksNArWlk2c38NdKg25+L9pr/mVaj9SUq6lHZu/35nx2xnQVRGLrC1KKQqJKRIB0q8GspiHI3J80Q==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
       "engines": {
-        "node": "*"
+        "node": ">=12"
       }
     },
-    "node_modules/base-x": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/base-x/-/base-x-4.0.0.tgz",
-      "integrity": "sha512-FuwxlW4H5kh37X/oW59pwTzzTKRzfrrQwhmyspRM7swOEZcHtDZSCt45U6oKgtuFE+WYPblePMVIPR4RZrh/hw=="
-    },
-    "node_modules/binary-extensions": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.2.0.tgz",
-      "integrity": "sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA==",
+    "node_modules/@hirosystems/clarinet-sdk/node_modules/@esbuild/openbsd-x64": {
+      "version": "0.19.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.19.10.tgz",
+      "integrity": "sha512-PxcgvjdSjtgPMiPQrM3pwSaG4kGphP+bLSb+cihuP0LYdZv1epbAIecHVl5sD3npkfYBZ0ZnOjR878I7MdJDFg==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
       "engines": {
-        "node": ">=8"
+        "node": ">=12"
       }
     },
-    "node_modules/braces": {
-      "version": "3.0.2",
-      "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz",
-      "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==",
-      "dependencies": {
-        "fill-range": "^7.0.1"
-      },
+    "node_modules/@hirosystems/clarinet-sdk/node_modules/@esbuild/sunos-x64": {
+      "version": "0.19.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.19.10.tgz",
+      "integrity": "sha512-ZkIOtrRL8SEJjr+VHjmW0znkPs+oJXhlJbNwfI37rvgeMtk3sxOQevXPXjmAPZPigVTncvFqLMd+uV0IBSEzqA==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
       "engines": {
-        "node": ">=8"
+        "node": ">=12"
       }
     },
-    "node_modules/c32check": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/c32check/-/c32check-2.0.0.tgz",
-      "integrity": "sha512-rpwfAcS/CMqo0oCqDf3r9eeLgScRE3l/xHDCXhM3UyrfvIn7PrLq63uHh7yYbv8NzaZn5MVsVhIRpQ+5GZ5HyA==",
-      "dependencies": {
-        "@noble/hashes": "^1.1.2",
-        "base-x": "^4.0.0"
-      },
+    "node_modules/@hirosystems/clarinet-sdk/node_modules/@esbuild/win32-arm64": {
+      "version": "0.19.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.19.10.tgz",
+      "integrity": "sha512-+Sa4oTDbpBfGpl3Hn3XiUe4f8TU2JF7aX8cOfqFYMMjXp6ma6NJDztl5FDG8Ezx0OjwGikIHw+iA54YLDNNVfw==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "win32"
+      ],
       "engines": {
-        "node": ">=8"
+        "node": ">=12"
       }
     },
-    "node_modules/cac": {
-      "version": "6.7.14",
-      "resolved": "https://registry.npmjs.org/cac/-/cac-6.7.14.tgz",
-      "integrity": "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==",
+    "node_modules/@hirosystems/clarinet-sdk/node_modules/@esbuild/win32-ia32": {
+      "version": "0.19.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.19.10.tgz",
+      "integrity": "sha512-EOGVLK1oWMBXgfttJdPHDTiivYSjX6jDNaATeNOaCOFEVcfMjtbx7WVQwPSE1eIfCp/CaSF2nSrDtzc4I9f8TQ==",
+      "cpu": [
+        "ia32"
+      ],
+      "optional": true,
+      "os": [
+        "win32"
+      ],
       "engines": {
-        "node": ">=8"
+        "node": ">=12"
       }
     },
-    "node_modules/camelcase": {
-      "version": "5.3.1",
-      "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-5.3.1.tgz",
-      "integrity": "sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==",
+    "node_modules/@hirosystems/clarinet-sdk/node_modules/@esbuild/win32-x64": {
+      "version": "0.19.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.19.10.tgz",
+      "integrity": "sha512-whqLG6Sc70AbU73fFYvuYzaE4MNMBIlR1Y/IrUeOXFrWHxBEjjbZaQ3IXIQS8wJdAzue2GwYZCjOrgrU1oUHoA==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "win32"
+      ],
       "engines": {
-        "node": ">=6"
+        "node": ">=12"
       }
     },
-    "node_modules/chai": {
-      "version": "4.3.10",
-      "resolved": "https://registry.npmjs.org/chai/-/chai-4.3.10.tgz",
-      "integrity": "sha512-0UXG04VuVbruMUYbJ6JctvH0YnC/4q3/AkT18q4NaITo91CUm0liMS9VqzT9vZhVQ/1eqPanMWjBM+Juhfb/9g==",
+    "node_modules/@hirosystems/clarinet-sdk/node_modules/@vitest/expect": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-1.1.0.tgz",
+      "integrity": "sha512-9IE2WWkcJo2BR9eqtY5MIo3TPmS50Pnwpm66A6neb2hvk/QSLfPXBz2qdiwUOQkwyFuuXEUj5380CbwfzW4+/w==",
       "dependencies": {
-        "assertion-error": "^1.1.0",
-        "check-error": "^1.0.3",
-        "deep-eql": "^4.1.3",
-        "get-func-name": "^2.0.2",
-        "loupe": "^2.3.6",
-        "pathval": "^1.1.1",
-        "type-detect": "^4.0.8"
+        "@vitest/spy": "1.1.0",
+        "@vitest/utils": "1.1.0",
+        "chai": "^4.3.10"
       },
-      "engines": {
-        "node": ">=4"
+      "funding": {
+        "url": "https://opencollective.com/vitest"
       }
     },
-    "node_modules/check-error": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/check-error/-/check-error-1.0.3.tgz",
-      "integrity": "sha512-iKEoDYaRmd1mxM90a2OEfWhjsjPpYPuQ+lMYsoxB126+t8fw7ySEO48nmDg5COTjxDI65/Y2OWpeEHk3ZOe8zg==",
+    "node_modules/@hirosystems/clarinet-sdk/node_modules/@vitest/runner": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-1.1.0.tgz",
+      "integrity": "sha512-zdNLJ00pm5z/uhbWF6aeIJCGMSyTyWImy3Fcp9piRGvueERFlQFbUwCpzVce79OLm2UHk9iwaMSOaU9jVHgNVw==",
       "dependencies": {
-        "get-func-name": "^2.0.2"
+        "@vitest/utils": "1.1.0",
+        "p-limit": "^5.0.0",
+        "pathe": "^1.1.1"
       },
-      "engines": {
-        "node": "*"
+      "funding": {
+        "url": "https://opencollective.com/vitest"
       }
     },
-    "node_modules/chokidar": {
-      "version": "3.5.3",
-      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.5.3.tgz",
-      "integrity": "sha512-Dr3sfKRP6oTcjf2JmUmFJfeVMvXBdegxB0iVQ5eb2V10uFJUCAS8OByZdVAyVb8xXNz3GjjTgj9kLWsZTqE6kw==",
-      "funding": [
-        {
-          "type": "individual",
-          "url": "https://paulmillr.com/funding/"
-        }
-      ],
+    "node_modules/@hirosystems/clarinet-sdk/node_modules/@vitest/snapshot": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-1.1.0.tgz",
+      "integrity": "sha512-5O/wyZg09V5qmNmAlUgCBqflvn2ylgsWJRRuPrnHEfDNT6tQpQ8O1isNGgo+VxofISHqz961SG3iVvt3SPK/QQ==",
       "dependencies": {
-        "anymatch": "~3.1.2",
-        "braces": "~3.0.2",
-        "glob-parent": "~5.1.2",
-        "is-binary-path": "~2.1.0",
-        "is-glob": "~4.0.1",
-        "normalize-path": "~3.0.0",
-        "readdirp": "~3.6.0"
+        "magic-string": "^0.30.5",
+        "pathe": "^1.1.1",
+        "pretty-format": "^29.7.0"
       },
-      "engines": {
-        "node": ">= 8.10.0"
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@hirosystems/clarinet-sdk/node_modules/@vitest/spy": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-1.1.0.tgz",
+      "integrity": "sha512-sNOVSU/GE+7+P76qYo+VXdXhXffzWZcYIPQfmkiRxaNCSPiLANvQx5Mx6ZURJ/ndtEkUJEpvKLXqAYTKEY+lTg==",
+      "dependencies": {
+        "tinyspy": "^2.2.0"
       },
-      "optionalDependencies": {
-        "fsevents": "~2.3.2"
+      "funding": {
+        "url": "https://opencollective.com/vitest"
       }
     },
-    "node_modules/chokidar-cli": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/chokidar-cli/-/chokidar-cli-3.0.0.tgz",
-      "integrity": "sha512-xVW+Qeh7z15uZRxHOkP93Ux8A0xbPzwK4GaqD8dQOYc34TlkqUhVSS59fK36DOp5WdJlrRzlYSy02Ht99FjZqQ==",
+    "node_modules/@hirosystems/clarinet-sdk/node_modules/@vitest/utils": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-1.1.0.tgz",
+      "integrity": "sha512-z+s510fKmYz4Y41XhNs3vcuFTFhcij2YF7F8VQfMEYAAUfqQh0Zfg7+w9xdgFGhPf3tX3TicAe+8BDITk6ampQ==",
       "dependencies": {
-        "chokidar": "^3.5.2",
-        "lodash.debounce": "^4.0.8",
-        "lodash.throttle": "^4.1.1",
-        "yargs": "^13.3.0"
+        "diff-sequences": "^29.6.3",
+        "loupe": "^2.3.7",
+        "pretty-format": "^29.7.0"
       },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@hirosystems/clarinet-sdk/node_modules/esbuild": {
+      "version": "0.19.10",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.19.10.tgz",
+      "integrity": "sha512-S1Y27QGt/snkNYrRcswgRFqZjaTG5a5xM3EQo97uNBnH505pdzSNe/HLBq1v0RO7iK/ngdbhJB6mDAp0OK+iUA==",
+      "hasInstallScript": true,
       "bin": {
-        "chokidar": "index.js"
+        "esbuild": "bin/esbuild"
       },
       "engines": {
-        "node": ">= 8.10.0"
-      }
-    },
-    "node_modules/chokidar-cli/node_modules/ansi-regex": {
-      "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-4.1.1.tgz",
-      "integrity": "sha512-ILlv4k/3f6vfQ4OoP2AGvirOktlQ98ZEL1k9FaQjxa3L1abBgbuTDAdPOpvbGncC0BTVQrl+OM8xZGK6tWXt7g==",
+        "node": ">=12"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.19.10",
+        "@esbuild/android-arm": "0.19.10",
+        "@esbuild/android-arm64": "0.19.10",
+        "@esbuild/android-x64": "0.19.10",
+        "@esbuild/darwin-arm64": "0.19.10",
+        "@esbuild/darwin-x64": "0.19.10",
+        "@esbuild/freebsd-arm64": "0.19.10",
+        "@esbuild/freebsd-x64": "0.19.10",
+        "@esbuild/linux-arm": "0.19.10",
+        "@esbuild/linux-arm64": "0.19.10",
+        "@esbuild/linux-ia32": "0.19.10",
+        "@esbuild/linux-loong64": "0.19.10",
+        "@esbuild/linux-mips64el": "0.19.10",
+        "@esbuild/linux-ppc64": "0.19.10",
+        "@esbuild/linux-riscv64": "0.19.10",
+        "@esbuild/linux-s390x": "0.19.10",
+        "@esbuild/linux-x64": "0.19.10",
+        "@esbuild/netbsd-x64": "0.19.10",
+        "@esbuild/openbsd-x64": "0.19.10",
+        "@esbuild/sunos-x64": "0.19.10",
+        "@esbuild/win32-arm64": "0.19.10",
+        "@esbuild/win32-ia32": "0.19.10",
+        "@esbuild/win32-x64": "0.19.10"
+      }
+    },
+    "node_modules/@hirosystems/clarinet-sdk/node_modules/local-pkg": {
+      "version": "0.5.0",
+      "resolved": "https://registry.npmjs.org/local-pkg/-/local-pkg-0.5.0.tgz",
+      "integrity": "sha512-ok6z3qlYyCDS4ZEU27HaU6x/xZa9Whf8jD4ptH5UZTQYZVYeb9bnZ3ojVhiJNLiXK1Hfc0GNbLXcmZ5plLDDBg==",
+      "dependencies": {
+        "mlly": "^1.4.2",
+        "pkg-types": "^1.0.3"
+      },
       "engines": {
-        "node": ">=6"
+        "node": ">=14"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/antfu"
       }
     },
-    "node_modules/chokidar-cli/node_modules/ansi-styles": {
-      "version": "3.2.1",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz",
-      "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==",
+    "node_modules/@hirosystems/clarinet-sdk/node_modules/p-limit": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-5.0.0.tgz",
+      "integrity": "sha512-/Eaoq+QyLSiXQ4lyYV23f14mZRQcXnxfHrN0vCai+ak9G0pp9iEQukIIZq5NccEvwRB8PUnZT0KsOoDCINS1qQ==",
       "dependencies": {
-        "color-convert": "^1.9.0"
+        "yocto-queue": "^1.0.0"
       },
       "engines": {
-        "node": ">=4"
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/chokidar-cli/node_modules/cliui": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/cliui/-/cliui-5.0.0.tgz",
-      "integrity": "sha512-PYeGSEmmHM6zvoef2w8TPzlrnNpXIjTipYK780YswmIP9vjxmd6Y2a3CB2Ks6/AU8NHjZugXvo8w3oWM2qnwXA==",
-      "dependencies": {
+    "node_modules/@hirosystems/clarinet-sdk/node_modules/rollup": {
+      "version": "4.9.1",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.9.1.tgz",
+      "integrity": "sha512-pgPO9DWzLoW/vIhlSoDByCzcpX92bKEorbgXuZrqxByte3JFk2xSW2JEeAcyLc9Ru9pqcNNW+Ob7ntsk2oT/Xw==",
+      "bin": {
+        "rollup": "dist/bin/rollup"
+      },
+      "engines": {
+        "node": ">=18.0.0",
+        "npm": ">=8.0.0"
+      },
+      "optionalDependencies": {
+        "@rollup/rollup-android-arm-eabi": "4.9.1",
+        "@rollup/rollup-android-arm64": "4.9.1",
+        "@rollup/rollup-darwin-arm64": "4.9.1",
+        "@rollup/rollup-darwin-x64": "4.9.1",
+        "@rollup/rollup-linux-arm-gnueabihf": "4.9.1",
+        "@rollup/rollup-linux-arm64-gnu": "4.9.1",
+        "@rollup/rollup-linux-arm64-musl": "4.9.1",
+        "@rollup/rollup-linux-riscv64-gnu": "4.9.1",
+        "@rollup/rollup-linux-x64-gnu": "4.9.1",
+        "@rollup/rollup-linux-x64-musl": "4.9.1",
+        "@rollup/rollup-win32-arm64-msvc": "4.9.1",
+        "@rollup/rollup-win32-ia32-msvc": "4.9.1",
+        "@rollup/rollup-win32-x64-msvc": "4.9.1",
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/@hirosystems/clarinet-sdk/node_modules/tinypool": {
+      "version": "0.8.1",
+      "resolved": "https://registry.npmjs.org/tinypool/-/tinypool-0.8.1.tgz",
+      "integrity": "sha512-zBTCK0cCgRROxvs9c0CGK838sPkeokNGdQVUUwHAbynHFlmyJYj825f/oRs528HaIJ97lo0pLIlDUzwN+IorWg==",
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
+    "node_modules/@hirosystems/clarinet-sdk/node_modules/vite": {
+      "version": "5.0.10",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-5.0.10.tgz",
+      "integrity": "sha512-2P8J7WWgmc355HUMlFrwofacvr98DAjoE52BfdbwQtyLH06XKwaL/FMnmKM2crF0iX4MpmMKoDlNCB1ok7zHCw==",
+      "dependencies": {
+        "esbuild": "^0.19.3",
+        "postcss": "^8.4.32",
+        "rollup": "^4.2.0"
+      },
+      "bin": {
+        "vite": "bin/vite.js"
+      },
+      "engines": {
+        "node": "^18.0.0 || >=20.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      },
+      "peerDependencies": {
+        "@types/node": "^18.0.0 || >=20.0.0",
+        "less": "*",
+        "lightningcss": "^1.21.0",
+        "sass": "*",
+        "stylus": "*",
+        "sugarss": "*",
+        "terser": "^5.4.0"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        },
+        "less": {
+          "optional": true
+        },
+        "lightningcss": {
+          "optional": true
+        },
+        "sass": {
+          "optional": true
+        },
+        "stylus": {
+          "optional": true
+        },
+        "sugarss": {
+          "optional": true
+        },
+        "terser": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@hirosystems/clarinet-sdk/node_modules/vite-node": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/vite-node/-/vite-node-1.1.0.tgz",
+      "integrity": "sha512-jV48DDUxGLEBdHCQvxL1mEh7+naVy+nhUUUaPAZLd3FJgXuxQiewHcfeZebbJ6onDqNGkP4r3MhQ342PRlG81Q==",
+      "dependencies": {
+        "cac": "^6.7.14",
+        "debug": "^4.3.4",
+        "pathe": "^1.1.1",
+        "picocolors": "^1.0.0",
+        "vite": "^5.0.0"
+      },
+      "bin": {
+        "vite-node": "vite-node.mjs"
+      },
+      "engines": {
+        "node": "^18.0.0 || >=20.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@hirosystems/clarinet-sdk/node_modules/vitest": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/vitest/-/vitest-1.1.0.tgz",
+      "integrity": "sha512-oDFiCrw7dd3Jf06HoMtSRARivvyjHJaTxikFxuqJjO76U436PqlVw1uLn7a8OSPrhSfMGVaRakKpA2lePdw79A==",
+      "dependencies": {
+        "@vitest/expect": "1.1.0",
+        "@vitest/runner": "1.1.0",
+        "@vitest/snapshot": "1.1.0",
+        "@vitest/spy": "1.1.0",
+        "@vitest/utils": "1.1.0",
+        "acorn-walk": "^8.3.0",
+        "cac": "^6.7.14",
+        "chai": "^4.3.10",
+        "debug": "^4.3.4",
+        "execa": "^8.0.1",
+        "local-pkg": "^0.5.0",
+        "magic-string": "^0.30.5",
+        "pathe": "^1.1.1",
+        "picocolors": "^1.0.0",
+        "std-env": "^3.5.0",
+        "strip-literal": "^1.3.0",
+        "tinybench": "^2.5.1",
+        "tinypool": "^0.8.1",
+        "vite": "^5.0.0",
+        "vite-node": "1.1.0",
+        "why-is-node-running": "^2.2.2"
+      },
+      "bin": {
+        "vitest": "vitest.mjs"
+      },
+      "engines": {
+        "node": "^18.0.0 || >=20.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      },
+      "peerDependencies": {
+        "@edge-runtime/vm": "*",
+        "@types/node": "^18.0.0 || >=20.0.0",
+        "@vitest/browser": "^1.0.0",
+        "@vitest/ui": "^1.0.0",
+        "happy-dom": "*",
+        "jsdom": "*"
+      },
+      "peerDependenciesMeta": {
+        "@edge-runtime/vm": {
+          "optional": true
+        },
+        "@types/node": {
+          "optional": true
+        },
+        "@vitest/browser": {
+          "optional": true
+        },
+        "@vitest/ui": {
+          "optional": true
+        },
+        "happy-dom": {
+          "optional": true
+        },
+        "jsdom": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@jest/schemas": {
+      "version": "29.6.3",
+      "resolved": "https://registry.npmjs.org/@jest/schemas/-/schemas-29.6.3.tgz",
+      "integrity": "sha512-mo5j5X+jIZmJQveBKeS/clAueipV7KgiX1vMgCxam1RNYiqE1w62n0/tJJnHtjW8ZHcQco5gY85jA3mi0L+nSA==",
+      "dependencies": {
+        "@sinclair/typebox": "^0.27.8"
+      },
+      "engines": {
+        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+      }
+    },
+    "node_modules/@jridgewell/sourcemap-codec": {
+      "version": "1.4.15",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.4.15.tgz",
+      "integrity": "sha512-eF2rxCRulEKXHTRiDrDy6erMYWqNw4LPdQ8UQA4huuxaQsVeRPFl2oM8oDGxMFhJUWZf9McpLtJasDDZb/Bpeg=="
+    },
+    "node_modules/@noble/hashes": {
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-1.1.5.tgz",
+      "integrity": "sha512-LTMZiiLc+V4v1Yi16TD6aX2gmtKszNye0pQgbaLqkvhIqP7nVsSaJsWloGQjJfJ8offaoP5GtX3yY5swbcJxxQ==",
+      "funding": [
+        {
+          "type": "individual",
+          "url": "https://paulmillr.com/funding/"
+        }
+      ]
+    },
+    "node_modules/@noble/secp256k1": {
+      "version": "1.7.1",
+      "resolved": "https://registry.npmjs.org/@noble/secp256k1/-/secp256k1-1.7.1.tgz",
+      "integrity": "sha512-hOUk6AyBFmqVrv7k5WAw/LpszxVbj9gGN4JRkIX52fdFAj1UA61KXmZDvqVEm+pOyec3+fIeZB02LYa/pWOArw==",
+      "funding": [
+        {
+          "type": "individual",
+          "url": "https://paulmillr.com/funding/"
+        }
+      ]
+    },
+    "node_modules/@rollup/rollup-android-arm-eabi": {
+      "version": "4.9.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.9.1.tgz",
+      "integrity": "sha512-6vMdBZqtq1dVQ4CWdhFwhKZL6E4L1dV6jUjuBvsavvNJSppzi6dLBbuV+3+IyUREaj9ZFvQefnQm28v4OCXlig==",
+      "cpu": [
+        "arm"
+      ],
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-android-arm64": {
+      "version": "4.9.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.9.1.tgz",
+      "integrity": "sha512-Jto9Fl3YQ9OLsTDWtLFPtaIMSL2kwGyGoVCmPC8Gxvym9TCZm4Sie+cVeblPO66YZsYH8MhBKDMGZ2NDxuk/XQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-arm64": {
+      "version": "4.9.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.9.1.tgz",
+      "integrity": "sha512-LtYcLNM+bhsaKAIGwVkh5IOWhaZhjTfNOkGzGqdHvhiCUVuJDalvDxEdSnhFzAn+g23wgsycmZk1vbnaibZwwA==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-x64": {
+      "version": "4.9.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.9.1.tgz",
+      "integrity": "sha512-KyP/byeXu9V+etKO6Lw3E4tW4QdcnzDG/ake031mg42lob5tN+5qfr+lkcT/SGZaH2PdW4Z1NX9GHEkZ8xV7og==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
+      "version": "4.9.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.9.1.tgz",
+      "integrity": "sha512-Yqz/Doumf3QTKplwGNrCHe/B2p9xqDghBZSlAY0/hU6ikuDVQuOUIpDP/YcmoT+447tsZTmirmjgG3znvSCR0Q==",
+      "cpu": [
+        "arm"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-gnu": {
+      "version": "4.9.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.9.1.tgz",
+      "integrity": "sha512-u3XkZVvxcvlAOlQJ3UsD1rFvLWqu4Ef/Ggl40WAVCuogf4S1nJPHh5RTgqYFpCOvuGJ7H5yGHabjFKEZGExk5Q==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-musl": {
+      "version": "4.9.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.9.1.tgz",
+      "integrity": "sha512-0XSYN/rfWShW+i+qjZ0phc6vZ7UWI8XWNz4E/l+6edFt+FxoEghrJHjX1EY/kcUGCnZzYYRCl31SNdfOi450Aw==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
+      "version": "4.9.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.9.1.tgz",
+      "integrity": "sha512-LmYIO65oZVfFt9t6cpYkbC4d5lKHLYv5B4CSHRpnANq0VZUQXGcCPXHzbCXCz4RQnx7jvlYB1ISVNCE/omz5cw==",
+      "cpu": [
+        "riscv64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-gnu": {
+      "version": "4.9.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.9.1.tgz",
+      "integrity": "sha512-kr8rEPQ6ns/Lmr/hiw8sEVj9aa07gh1/tQF2Y5HrNCCEPiCBGnBUt9tVusrcBBiJfIt1yNaXN6r1CCmpbFEDpg==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-musl": {
+      "version": "4.9.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.9.1.tgz",
+      "integrity": "sha512-t4QSR7gN+OEZLG0MiCgPqMWZGwmeHhsM4AkegJ0Kiy6TnJ9vZ8dEIwHw1LcZKhbHxTY32hp9eVCMdR3/I8MGRw==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-arm64-msvc": {
+      "version": "4.9.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.9.1.tgz",
+      "integrity": "sha512-7XI4ZCBN34cb+BH557FJPmh0kmNz2c25SCQeT9OiFWEgf8+dL6ZwJ8f9RnUIit+j01u07Yvrsuu1rZGxJCc51g==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-ia32-msvc": {
+      "version": "4.9.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.9.1.tgz",
+      "integrity": "sha512-yE5c2j1lSWOH5jp+Q0qNL3Mdhr8WuqCNVjc6BxbVfS5cAS6zRmdiw7ktb8GNpDCEUJphILY6KACoFoRtKoqNQg==",
+      "cpu": [
+        "ia32"
+      ],
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-msvc": {
+      "version": "4.9.1",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.9.1.tgz",
+      "integrity": "sha512-PyJsSsafjmIhVgaI1Zdj7m8BB8mMckFah/xbpplObyHfiXzKcI5UOUXRyOdHW7nz4DpMCuzLnF7v5IWHenCwYA==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@sinclair/typebox": {
+      "version": "0.27.8",
+      "resolved": "https://registry.npmjs.org/@sinclair/typebox/-/typebox-0.27.8.tgz",
+      "integrity": "sha512-+Fj43pSMwJs4KRrH/938Uf+uAELIgVBmQzg/q1YG10djyfA3TnrU8N8XzqCh/okZdszqBQTZf96idMfE5lnwTA=="
+    },
+    "node_modules/@stacks/common": {
+      "version": "6.10.0",
+      "resolved": "https://registry.npmjs.org/@stacks/common/-/common-6.10.0.tgz",
+      "integrity": "sha512-6x5Z7AKd9/kj3+DYE9xIDIkFLHihBH614i2wqrZIjN02WxVo063hWSjIlUxlx8P4gl6olVzlOy5LzhLJD9OP0A==",
+      "dependencies": {
+        "@types/bn.js": "^5.1.0",
+        "@types/node": "^18.0.4"
+      }
+    },
+    "node_modules/@stacks/network": {
+      "version": "6.10.0",
+      "resolved": "https://registry.npmjs.org/@stacks/network/-/network-6.10.0.tgz",
+      "integrity": "sha512-mbiZ8nlsyy77ndmBdaqhHXii22IFdK4ThRcOQs9j/O00DkAr04jCM4GV5Q+VLUnZ9OBoJq7yOV7Pf6jglh+0hw==",
+      "dependencies": {
+        "@stacks/common": "^6.10.0",
+        "cross-fetch": "^3.1.5"
+      }
+    },
+    "node_modules/@stacks/transactions": {
+      "version": "6.11.0",
+      "resolved": "https://registry.npmjs.org/@stacks/transactions/-/transactions-6.11.0.tgz",
+      "integrity": "sha512-+zIDqn9j4H/+o1ER8C9rFpig1fyrQcj2hVGNIrp+YbpPyja+cxv3fPk6kI/gePzwggzxRgUkIWhBc+mZAXuXyQ==",
+      "dependencies": {
+        "@noble/hashes": "1.1.5",
+        "@noble/secp256k1": "1.7.1",
+        "@stacks/common": "^6.10.0",
+        "@stacks/network": "^6.10.0",
+        "c32check": "^2.0.0",
+        "lodash.clonedeep": "^4.5.0"
+      }
+    },
+    "node_modules/@types/bn.js": {
+      "version": "5.1.5",
+      "resolved": "https://registry.npmjs.org/@types/bn.js/-/bn.js-5.1.5.tgz",
+      "integrity": "sha512-V46N0zwKRF5Q00AZ6hWtN0T8gGmDUaUzLWQvHFo5yThtVwK/VCenFY3wXVbOvNfajEpsTfQM4IN9k/d6gUVX3A==",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@types/chai": {
+      "version": "4.3.9",
+      "resolved": "https://registry.npmjs.org/@types/chai/-/chai-4.3.9.tgz",
+      "integrity": "sha512-69TtiDzu0bcmKQv3yg1Zx409/Kd7r0b5F1PfpYJfSHzLGtB53547V4u+9iqKYsTu/O2ai6KTb0TInNpvuQ3qmg=="
+    },
+    "node_modules/@types/chai-subset": {
+      "version": "1.3.4",
+      "resolved": "https://registry.npmjs.org/@types/chai-subset/-/chai-subset-1.3.4.tgz",
+      "integrity": "sha512-CCWNXrJYSUIojZ1149ksLl3AN9cmZ5djf+yUoVVV+NuYrtydItQVlL2ZDqyC6M6O9LWRnVf8yYDxbXHO2TfQZg==",
+      "dependencies": {
+        "@types/chai": "*"
+      }
+    },
+    "node_modules/@types/node": {
+      "version": "18.18.8",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-18.18.8.tgz",
+      "integrity": "sha512-OLGBaaK5V3VRBS1bAkMVP2/W9B+H8meUfl866OrMNQqt7wDgdpWPp5o6gmIc9pB+lIQHSq4ZL8ypeH1vPxcPaQ==",
+      "dependencies": {
+        "undici-types": "~5.26.4"
+      }
+    },
+    "node_modules/@vitest/expect": {
+      "version": "0.34.6",
+      "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-0.34.6.tgz",
+      "integrity": "sha512-QUzKpUQRc1qC7qdGo7rMK3AkETI7w18gTCUrsNnyjjJKYiuUB9+TQK3QnR1unhCnWRC0AbKv2omLGQDF/mIjOw==",
+      "dependencies": {
+        "@vitest/spy": "0.34.6",
+        "@vitest/utils": "0.34.6",
+        "chai": "^4.3.10"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/runner": {
+      "version": "0.34.6",
+      "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-0.34.6.tgz",
+      "integrity": "sha512-1CUQgtJSLF47NnhN+F9X2ycxUP0kLHQ/JWvNHbeBfwW8CzEGgeskzNnHDyv1ieKTltuR6sdIHV+nmR6kPxQqzQ==",
+      "dependencies": {
+        "@vitest/utils": "0.34.6",
+        "p-limit": "^4.0.0",
+        "pathe": "^1.1.1"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/snapshot": {
+      "version": "0.34.6",
+      "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-0.34.6.tgz",
+      "integrity": "sha512-B3OZqYn6k4VaN011D+ve+AA4whM4QkcwcrwaKwAbyyvS/NB1hCWjFIBQxAQQSQir9/RtyAAGuq+4RJmbn2dH4w==",
+      "dependencies": {
+        "magic-string": "^0.30.1",
+        "pathe": "^1.1.1",
+        "pretty-format": "^29.5.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/spy": {
+      "version": "0.34.6",
+      "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-0.34.6.tgz",
+      "integrity": "sha512-xaCvneSaeBw/cz8ySmF7ZwGvL0lBjfvqc1LpQ/vcdHEvpLn3Ff1vAvjw+CoGn0802l++5L/pxb7whwcWAw+DUQ==",
+      "dependencies": {
+        "tinyspy": "^2.1.1"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/utils": {
+      "version": "0.34.6",
+      "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-0.34.6.tgz",
+      "integrity": "sha512-IG5aDD8S6zlvloDsnzHw0Ut5xczlF+kv2BOTo+iXfPr54Yhi5qbVOgGB1hZaVq4iJ4C/MZ2J0y15IlsV/ZcI0A==",
+      "dependencies": {
+        "diff-sequences": "^29.4.3",
+        "loupe": "^2.3.6",
+        "pretty-format": "^29.5.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/acorn": {
+      "version": "8.11.2",
+      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.11.2.tgz",
+      "integrity": "sha512-nc0Axzp/0FILLEVsm4fNwLCwMttvhEI263QtVPQcbpfZZ3ts0hLsZGOpE6czNlid7CJ9MlyH8reXkpsf3YUY4w==",
+      "bin": {
+        "acorn": "bin/acorn"
+      },
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/acorn-walk": {
+      "version": "8.3.0",
+      "resolved": "https://registry.npmjs.org/acorn-walk/-/acorn-walk-8.3.0.tgz",
+      "integrity": "sha512-FS7hV565M5l1R08MXqo8odwMTB02C2UqzB17RVgu9EyuYFBqJZ3/ZY97sQD5FewVu1UyDFc1yztUDrAwT0EypA==",
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/ansi-regex": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/ansi-styles": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-5.2.0.tgz",
+      "integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/anymatch": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz",
+      "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==",
+      "dependencies": {
+        "normalize-path": "^3.0.0",
+        "picomatch": "^2.0.4"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/assertion-error": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-1.1.0.tgz",
+      "integrity": "sha512-jgsaNduz+ndvGyFt3uSuWqvy4lCnIJiovtouQN5JZHOKCS2QuhEdbcQHFhVksz2N2U9hXJo8odG7ETyWlEeuDw==",
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/base-x": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/base-x/-/base-x-4.0.0.tgz",
+      "integrity": "sha512-FuwxlW4H5kh37X/oW59pwTzzTKRzfrrQwhmyspRM7swOEZcHtDZSCt45U6oKgtuFE+WYPblePMVIPR4RZrh/hw=="
+    },
+    "node_modules/binary-extensions": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.2.0.tgz",
+      "integrity": "sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA==",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/braces": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz",
+      "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==",
+      "dependencies": {
+        "fill-range": "^7.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/c32check": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/c32check/-/c32check-2.0.0.tgz",
+      "integrity": "sha512-rpwfAcS/CMqo0oCqDf3r9eeLgScRE3l/xHDCXhM3UyrfvIn7PrLq63uHh7yYbv8NzaZn5MVsVhIRpQ+5GZ5HyA==",
+      "dependencies": {
+        "@noble/hashes": "^1.1.2",
+        "base-x": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/cac": {
+      "version": "6.7.14",
+      "resolved": "https://registry.npmjs.org/cac/-/cac-6.7.14.tgz",
+      "integrity": "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/camelcase": {
+      "version": "5.3.1",
+      "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-5.3.1.tgz",
+      "integrity": "sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/chai": {
+      "version": "4.3.10",
+      "resolved": "https://registry.npmjs.org/chai/-/chai-4.3.10.tgz",
+      "integrity": "sha512-0UXG04VuVbruMUYbJ6JctvH0YnC/4q3/AkT18q4NaITo91CUm0liMS9VqzT9vZhVQ/1eqPanMWjBM+Juhfb/9g==",
+      "dependencies": {
+        "assertion-error": "^1.1.0",
+        "check-error": "^1.0.3",
+        "deep-eql": "^4.1.3",
+        "get-func-name": "^2.0.2",
+        "loupe": "^2.3.6",
+        "pathval": "^1.1.1",
+        "type-detect": "^4.0.8"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/check-error": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/check-error/-/check-error-1.0.3.tgz",
+      "integrity": "sha512-iKEoDYaRmd1mxM90a2OEfWhjsjPpYPuQ+lMYsoxB126+t8fw7ySEO48nmDg5COTjxDI65/Y2OWpeEHk3ZOe8zg==",
+      "dependencies": {
+        "get-func-name": "^2.0.2"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/chokidar": {
+      "version": "3.5.3",
+      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.5.3.tgz",
+      "integrity": "sha512-Dr3sfKRP6oTcjf2JmUmFJfeVMvXBdegxB0iVQ5eb2V10uFJUCAS8OByZdVAyVb8xXNz3GjjTgj9kLWsZTqE6kw==",
+      "funding": [
+        {
+          "type": "individual",
+          "url": "https://paulmillr.com/funding/"
+        }
+      ],
+      "dependencies": {
+        "anymatch": "~3.1.2",
+        "braces": "~3.0.2",
+        "glob-parent": "~5.1.2",
+        "is-binary-path": "~2.1.0",
+        "is-glob": "~4.0.1",
+        "normalize-path": "~3.0.0",
+        "readdirp": "~3.6.0"
+      },
+      "engines": {
+        "node": ">= 8.10.0"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/chokidar-cli": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/chokidar-cli/-/chokidar-cli-3.0.0.tgz",
+      "integrity": "sha512-xVW+Qeh7z15uZRxHOkP93Ux8A0xbPzwK4GaqD8dQOYc34TlkqUhVSS59fK36DOp5WdJlrRzlYSy02Ht99FjZqQ==",
+      "dependencies": {
+        "chokidar": "^3.5.2",
+        "lodash.debounce": "^4.0.8",
+        "lodash.throttle": "^4.1.1",
+        "yargs": "^13.3.0"
+      },
+      "bin": {
+        "chokidar": "index.js"
+      },
+      "engines": {
+        "node": ">= 8.10.0"
+      }
+    },
+    "node_modules/chokidar-cli/node_modules/ansi-regex": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-4.1.1.tgz",
+      "integrity": "sha512-ILlv4k/3f6vfQ4OoP2AGvirOktlQ98ZEL1k9FaQjxa3L1abBgbuTDAdPOpvbGncC0BTVQrl+OM8xZGK6tWXt7g==",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/chokidar-cli/node_modules/ansi-styles": {
+      "version": "3.2.1",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz",
+      "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==",
+      "dependencies": {
+        "color-convert": "^1.9.0"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/chokidar-cli/node_modules/cliui": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/cliui/-/cliui-5.0.0.tgz",
+      "integrity": "sha512-PYeGSEmmHM6zvoef2w8TPzlrnNpXIjTipYK780YswmIP9vjxmd6Y2a3CB2Ks6/AU8NHjZugXvo8w3oWM2qnwXA==",
+      "dependencies": {
         "string-width": "^3.1.0",
         "strip-ansi": "^5.2.0",
         "wrap-ansi": "^5.1.0"
       }
     },
-    "node_modules/chokidar-cli/node_modules/emoji-regex": {
-      "version": "7.0.3",
-      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-7.0.3.tgz",
-      "integrity": "sha512-CwBLREIQ7LvYFB0WyRvwhq5N5qPhc6PMjD6bYggFlI5YyDgl+0vxq5VHbMOFqLg7hfWzmu8T5Z1QofhmTIhItA=="
+    "node_modules/chokidar-cli/node_modules/emoji-regex": {
+      "version": "7.0.3",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-7.0.3.tgz",
+      "integrity": "sha512-CwBLREIQ7LvYFB0WyRvwhq5N5qPhc6PMjD6bYggFlI5YyDgl+0vxq5VHbMOFqLg7hfWzmu8T5Z1QofhmTIhItA=="
+    },
+    "node_modules/chokidar-cli/node_modules/is-fullwidth-code-point": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz",
+      "integrity": "sha512-VHskAKYM8RfSFXwee5t5cbN5PZeq1Wrh6qd5bkyiXIf6UQcN6w/A0eXM9r6t8d+GYOh+o6ZhiEnb88LN/Y8m2w==",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/chokidar-cli/node_modules/string-width": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-3.1.0.tgz",
+      "integrity": "sha512-vafcv6KjVZKSgz06oM/H6GDBrAtz8vdhQakGjFIvNrHA6y3HCF1CInLy+QLq8dTJPQ1b+KDUqDFctkdRW44e1w==",
+      "dependencies": {
+        "emoji-regex": "^7.0.1",
+        "is-fullwidth-code-point": "^2.0.0",
+        "strip-ansi": "^5.1.0"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/chokidar-cli/node_modules/strip-ansi": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-5.2.0.tgz",
+      "integrity": "sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==",
+      "dependencies": {
+        "ansi-regex": "^4.1.0"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/chokidar-cli/node_modules/wrap-ansi": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-5.1.0.tgz",
+      "integrity": "sha512-QC1/iN/2/RPVJ5jYK8BGttj5z83LmSKmvbvrXPNCLZSEb32KKVDJDl/MOt2N01qU2H/FkzEa9PKto1BqDjtd7Q==",
+      "dependencies": {
+        "ansi-styles": "^3.2.0",
+        "string-width": "^3.0.0",
+        "strip-ansi": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/chokidar-cli/node_modules/y18n": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/y18n/-/y18n-4.0.3.tgz",
+      "integrity": "sha512-JKhqTOwSrqNA1NY5lSztJ1GrBiUodLMmIZuLiDaMRJ+itFd+ABVE8XBjOvIWL+rSqNDC74LCSFmlb/U4UZ4hJQ=="
+    },
+    "node_modules/chokidar-cli/node_modules/yargs": {
+      "version": "13.3.2",
+      "resolved": "https://registry.npmjs.org/yargs/-/yargs-13.3.2.tgz",
+      "integrity": "sha512-AX3Zw5iPruN5ie6xGRIDgqkT+ZhnRlZMLMHAs8tg7nRruy2Nb+i5o9bwghAogtM08q1dpr2LVoS8KSTMYpWXUw==",
+      "dependencies": {
+        "cliui": "^5.0.0",
+        "find-up": "^3.0.0",
+        "get-caller-file": "^2.0.1",
+        "require-directory": "^2.1.1",
+        "require-main-filename": "^2.0.0",
+        "set-blocking": "^2.0.0",
+        "string-width": "^3.0.0",
+        "which-module": "^2.0.0",
+        "y18n": "^4.0.0",
+        "yargs-parser": "^13.1.2"
+      }
+    },
+    "node_modules/chokidar-cli/node_modules/yargs-parser": {
+      "version": "13.1.2",
+      "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-13.1.2.tgz",
+      "integrity": "sha512-3lbsNRf/j+A4QuSZfDRA7HRSfWrzO0YjqTJd5kjAq37Zep1CEgaYmrH9Q3GwPiB9cHyd1Y1UwggGhJGoxipbzg==",
+      "dependencies": {
+        "camelcase": "^5.0.0",
+        "decamelize": "^1.2.0"
+      }
+    },
+    "node_modules/clarunit": {
+      "version": "0.0.1",
+      "resolved": "git+ssh://git@github.com/MarvinJanssen/clarunit.git#a5c042ab8428d989c8f7653e83073b3e8c88e076",
+      "license": "MIT",
+      "dependencies": {
+        "@hirosystems/clarinet-sdk": "^1.2.0",
+        "@stacks/transactions": "^6.11.0",
+        "chokidar-cli": "^3.0.0",
+        "path": "^0.12.7",
+        "typescript": "^5.2.2",
+        "vite": "^4.4.9",
+        "vitest": "^1.1.0",
+        "vitest-environment-clarinet": "^1.0.0"
+      },
+      "bin": {
+        "clarunit": "src/cli.ts"
+      }
+    },
+    "node_modules/clarunit/node_modules/@esbuild/android-arm": {
+      "version": "0.19.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.19.10.tgz",
+      "integrity": "sha512-7W0bK7qfkw1fc2viBfrtAEkDKHatYfHzr/jKAHNr9BvkYDXPcC6bodtm8AyLJNNuqClLNaeTLuwURt4PRT9d7w==",
+      "cpu": [
+        "arm"
+      ],
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/clarunit/node_modules/@esbuild/android-arm64": {
+      "version": "0.19.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.19.10.tgz",
+      "integrity": "sha512-1X4CClKhDgC3by7k8aOWZeBXQX8dHT5QAMCAQDArCLaYfkppoARvh0fit3X2Qs+MXDngKcHv6XXyQCpY0hkK1Q==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/clarunit/node_modules/@esbuild/android-x64": {
+      "version": "0.19.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.19.10.tgz",
+      "integrity": "sha512-O/nO/g+/7NlitUxETkUv/IvADKuZXyH4BHf/g/7laqKC4i/7whLpB0gvpPc2zpF0q9Q6FXS3TS75QHac9MvVWw==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/clarunit/node_modules/@esbuild/darwin-arm64": {
+      "version": "0.19.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.19.10.tgz",
+      "integrity": "sha512-YSRRs2zOpwypck+6GL3wGXx2gNP7DXzetmo5pHXLrY/VIMsS59yKfjPizQ4lLt5vEI80M41gjm2BxrGZ5U+VMA==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/clarunit/node_modules/@esbuild/darwin-x64": {
+      "version": "0.19.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.19.10.tgz",
+      "integrity": "sha512-alfGtT+IEICKtNE54hbvPg13xGBe4GkVxyGWtzr+yHO7HIiRJppPDhOKq3zstTcVf8msXb/t4eavW3jCDpMSmA==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/clarunit/node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.19.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.19.10.tgz",
+      "integrity": "sha512-dMtk1wc7FSH8CCkE854GyGuNKCewlh+7heYP/sclpOG6Cectzk14qdUIY5CrKDbkA/OczXq9WesqnPl09mj5dg==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/clarunit/node_modules/@esbuild/freebsd-x64": {
+      "version": "0.19.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.19.10.tgz",
+      "integrity": "sha512-G5UPPspryHu1T3uX8WiOEUa6q6OlQh6gNl4CO4Iw5PS+Kg5bVggVFehzXBJY6X6RSOMS8iXDv2330VzaObm4Ag==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/clarunit/node_modules/@esbuild/linux-arm": {
+      "version": "0.19.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.19.10.tgz",
+      "integrity": "sha512-j6gUW5aAaPgD416Hk9FHxn27On28H4eVI9rJ4az7oCGTFW48+LcgNDBN+9f8rKZz7EEowo889CPKyeaD0iw9Kg==",
+      "cpu": [
+        "arm"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/clarunit/node_modules/@esbuild/linux-arm64": {
+      "version": "0.19.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.19.10.tgz",
+      "integrity": "sha512-QxaouHWZ+2KWEj7cGJmvTIHVALfhpGxo3WLmlYfJ+dA5fJB6lDEIg+oe/0//FuyVHuS3l79/wyBxbHr0NgtxJQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/clarunit/node_modules/@esbuild/linux-ia32": {
+      "version": "0.19.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.19.10.tgz",
+      "integrity": "sha512-4ub1YwXxYjj9h1UIZs2hYbnTZBtenPw5NfXCRgEkGb0b6OJ2gpkMvDqRDYIDRjRdWSe/TBiZltm3Y3Q8SN1xNg==",
+      "cpu": [
+        "ia32"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/clarunit/node_modules/@esbuild/linux-loong64": {
+      "version": "0.19.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.19.10.tgz",
+      "integrity": "sha512-lo3I9k+mbEKoxtoIbM0yC/MZ1i2wM0cIeOejlVdZ3D86LAcFXFRdeuZmh91QJvUTW51bOK5W2BznGNIl4+mDaA==",
+      "cpu": [
+        "loong64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/clarunit/node_modules/@esbuild/linux-mips64el": {
+      "version": "0.19.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.19.10.tgz",
+      "integrity": "sha512-J4gH3zhHNbdZN0Bcr1QUGVNkHTdpijgx5VMxeetSk6ntdt+vR1DqGmHxQYHRmNb77tP6GVvD+K0NyO4xjd7y4A==",
+      "cpu": [
+        "mips64el"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/clarunit/node_modules/@esbuild/linux-ppc64": {
+      "version": "0.19.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.19.10.tgz",
+      "integrity": "sha512-tgT/7u+QhV6ge8wFMzaklOY7KqiyitgT1AUHMApau32ZlvTB/+efeCtMk4eXS+uEymYK249JsoiklZN64xt6oQ==",
+      "cpu": [
+        "ppc64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
     },
-    "node_modules/chokidar-cli/node_modules/is-fullwidth-code-point": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz",
-      "integrity": "sha512-VHskAKYM8RfSFXwee5t5cbN5PZeq1Wrh6qd5bkyiXIf6UQcN6w/A0eXM9r6t8d+GYOh+o6ZhiEnb88LN/Y8m2w==",
+    "node_modules/clarunit/node_modules/@esbuild/linux-riscv64": {
+      "version": "0.19.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.19.10.tgz",
+      "integrity": "sha512-0f/spw0PfBMZBNqtKe5FLzBDGo0SKZKvMl5PHYQr3+eiSscfJ96XEknCe+JoOayybWUFQbcJTrk946i3j9uYZA==",
+      "cpu": [
+        "riscv64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
       "engines": {
-        "node": ">=4"
+        "node": ">=12"
+      }
+    },
+    "node_modules/clarunit/node_modules/@esbuild/linux-s390x": {
+      "version": "0.19.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.19.10.tgz",
+      "integrity": "sha512-pZFe0OeskMHzHa9U38g+z8Yx5FNCLFtUnJtQMpwhS+r4S566aK2ci3t4NCP4tjt6d5j5uo4h7tExZMjeKoehAA==",
+      "cpu": [
+        "s390x"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/clarunit/node_modules/@esbuild/linux-x64": {
+      "version": "0.19.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.19.10.tgz",
+      "integrity": "sha512-SpYNEqg/6pZYoc+1zLCjVOYvxfZVZj6w0KROZ3Fje/QrM3nfvT2llI+wmKSrWuX6wmZeTapbarvuNNK/qepSgA==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/clarunit/node_modules/@esbuild/netbsd-x64": {
+      "version": "0.19.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.19.10.tgz",
+      "integrity": "sha512-ACbZ0vXy9zksNArWlk2c38NdKg25+L9pr/mVaj9SUq6lHZu/35nx2xnQVRGLrC1KKQqJKRIB0q8GspiHI3J80Q==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/clarunit/node_modules/@esbuild/openbsd-x64": {
+      "version": "0.19.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.19.10.tgz",
+      "integrity": "sha512-PxcgvjdSjtgPMiPQrM3pwSaG4kGphP+bLSb+cihuP0LYdZv1epbAIecHVl5sD3npkfYBZ0ZnOjR878I7MdJDFg==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/clarunit/node_modules/@esbuild/sunos-x64": {
+      "version": "0.19.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.19.10.tgz",
+      "integrity": "sha512-ZkIOtrRL8SEJjr+VHjmW0znkPs+oJXhlJbNwfI37rvgeMtk3sxOQevXPXjmAPZPigVTncvFqLMd+uV0IBSEzqA==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/clarunit/node_modules/@esbuild/win32-arm64": {
+      "version": "0.19.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.19.10.tgz",
+      "integrity": "sha512-+Sa4oTDbpBfGpl3Hn3XiUe4f8TU2JF7aX8cOfqFYMMjXp6ma6NJDztl5FDG8Ezx0OjwGikIHw+iA54YLDNNVfw==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/clarunit/node_modules/@esbuild/win32-ia32": {
+      "version": "0.19.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.19.10.tgz",
+      "integrity": "sha512-EOGVLK1oWMBXgfttJdPHDTiivYSjX6jDNaATeNOaCOFEVcfMjtbx7WVQwPSE1eIfCp/CaSF2nSrDtzc4I9f8TQ==",
+      "cpu": [
+        "ia32"
+      ],
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/clarunit/node_modules/@esbuild/win32-x64": {
+      "version": "0.19.10",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.19.10.tgz",
+      "integrity": "sha512-whqLG6Sc70AbU73fFYvuYzaE4MNMBIlR1Y/IrUeOXFrWHxBEjjbZaQ3IXIQS8wJdAzue2GwYZCjOrgrU1oUHoA==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/clarunit/node_modules/@vitest/expect": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-1.1.0.tgz",
+      "integrity": "sha512-9IE2WWkcJo2BR9eqtY5MIo3TPmS50Pnwpm66A6neb2hvk/QSLfPXBz2qdiwUOQkwyFuuXEUj5380CbwfzW4+/w==",
+      "dependencies": {
+        "@vitest/spy": "1.1.0",
+        "@vitest/utils": "1.1.0",
+        "chai": "^4.3.10"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/clarunit/node_modules/@vitest/runner": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-1.1.0.tgz",
+      "integrity": "sha512-zdNLJ00pm5z/uhbWF6aeIJCGMSyTyWImy3Fcp9piRGvueERFlQFbUwCpzVce79OLm2UHk9iwaMSOaU9jVHgNVw==",
+      "dependencies": {
+        "@vitest/utils": "1.1.0",
+        "p-limit": "^5.0.0",
+        "pathe": "^1.1.1"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/clarunit/node_modules/@vitest/snapshot": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-1.1.0.tgz",
+      "integrity": "sha512-5O/wyZg09V5qmNmAlUgCBqflvn2ylgsWJRRuPrnHEfDNT6tQpQ8O1isNGgo+VxofISHqz961SG3iVvt3SPK/QQ==",
+      "dependencies": {
+        "magic-string": "^0.30.5",
+        "pathe": "^1.1.1",
+        "pretty-format": "^29.7.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/clarunit/node_modules/@vitest/spy": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-1.1.0.tgz",
+      "integrity": "sha512-sNOVSU/GE+7+P76qYo+VXdXhXffzWZcYIPQfmkiRxaNCSPiLANvQx5Mx6ZURJ/ndtEkUJEpvKLXqAYTKEY+lTg==",
+      "dependencies": {
+        "tinyspy": "^2.2.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/clarunit/node_modules/@vitest/utils": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-1.1.0.tgz",
+      "integrity": "sha512-z+s510fKmYz4Y41XhNs3vcuFTFhcij2YF7F8VQfMEYAAUfqQh0Zfg7+w9xdgFGhPf3tX3TicAe+8BDITk6ampQ==",
+      "dependencies": {
+        "diff-sequences": "^29.6.3",
+        "loupe": "^2.3.7",
+        "pretty-format": "^29.7.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/clarunit/node_modules/esbuild": {
+      "version": "0.19.10",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.19.10.tgz",
+      "integrity": "sha512-S1Y27QGt/snkNYrRcswgRFqZjaTG5a5xM3EQo97uNBnH505pdzSNe/HLBq1v0RO7iK/ngdbhJB6mDAp0OK+iUA==",
+      "hasInstallScript": true,
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "optionalDependencies": {
+        "@esbuild/aix-ppc64": "0.19.10",
+        "@esbuild/android-arm": "0.19.10",
+        "@esbuild/android-arm64": "0.19.10",
+        "@esbuild/android-x64": "0.19.10",
+        "@esbuild/darwin-arm64": "0.19.10",
+        "@esbuild/darwin-x64": "0.19.10",
+        "@esbuild/freebsd-arm64": "0.19.10",
+        "@esbuild/freebsd-x64": "0.19.10",
+        "@esbuild/linux-arm": "0.19.10",
+        "@esbuild/linux-arm64": "0.19.10",
+        "@esbuild/linux-ia32": "0.19.10",
+        "@esbuild/linux-loong64": "0.19.10",
+        "@esbuild/linux-mips64el": "0.19.10",
+        "@esbuild/linux-ppc64": "0.19.10",
+        "@esbuild/linux-riscv64": "0.19.10",
+        "@esbuild/linux-s390x": "0.19.10",
+        "@esbuild/linux-x64": "0.19.10",
+        "@esbuild/netbsd-x64": "0.19.10",
+        "@esbuild/openbsd-x64": "0.19.10",
+        "@esbuild/sunos-x64": "0.19.10",
+        "@esbuild/win32-arm64": "0.19.10",
+        "@esbuild/win32-ia32": "0.19.10",
+        "@esbuild/win32-x64": "0.19.10"
+      }
+    },
+    "node_modules/clarunit/node_modules/local-pkg": {
+      "version": "0.5.0",
+      "resolved": "https://registry.npmjs.org/local-pkg/-/local-pkg-0.5.0.tgz",
+      "integrity": "sha512-ok6z3qlYyCDS4ZEU27HaU6x/xZa9Whf8jD4ptH5UZTQYZVYeb9bnZ3ojVhiJNLiXK1Hfc0GNbLXcmZ5plLDDBg==",
+      "dependencies": {
+        "mlly": "^1.4.2",
+        "pkg-types": "^1.0.3"
+      },
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/antfu"
+      }
+    },
+    "node_modules/clarunit/node_modules/p-limit": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-5.0.0.tgz",
+      "integrity": "sha512-/Eaoq+QyLSiXQ4lyYV23f14mZRQcXnxfHrN0vCai+ak9G0pp9iEQukIIZq5NccEvwRB8PUnZT0KsOoDCINS1qQ==",
+      "dependencies": {
+        "yocto-queue": "^1.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/clarunit/node_modules/rollup": {
+      "version": "4.9.1",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.9.1.tgz",
+      "integrity": "sha512-pgPO9DWzLoW/vIhlSoDByCzcpX92bKEorbgXuZrqxByte3JFk2xSW2JEeAcyLc9Ru9pqcNNW+Ob7ntsk2oT/Xw==",
+      "bin": {
+        "rollup": "dist/bin/rollup"
+      },
+      "engines": {
+        "node": ">=18.0.0",
+        "npm": ">=8.0.0"
+      },
+      "optionalDependencies": {
+        "@rollup/rollup-android-arm-eabi": "4.9.1",
+        "@rollup/rollup-android-arm64": "4.9.1",
+        "@rollup/rollup-darwin-arm64": "4.9.1",
+        "@rollup/rollup-darwin-x64": "4.9.1",
+        "@rollup/rollup-linux-arm-gnueabihf": "4.9.1",
+        "@rollup/rollup-linux-arm64-gnu": "4.9.1",
+        "@rollup/rollup-linux-arm64-musl": "4.9.1",
+        "@rollup/rollup-linux-riscv64-gnu": "4.9.1",
+        "@rollup/rollup-linux-x64-gnu": "4.9.1",
+        "@rollup/rollup-linux-x64-musl": "4.9.1",
+        "@rollup/rollup-win32-arm64-msvc": "4.9.1",
+        "@rollup/rollup-win32-ia32-msvc": "4.9.1",
+        "@rollup/rollup-win32-x64-msvc": "4.9.1",
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/clarunit/node_modules/tinypool": {
+      "version": "0.8.1",
+      "resolved": "https://registry.npmjs.org/tinypool/-/tinypool-0.8.1.tgz",
+      "integrity": "sha512-zBTCK0cCgRROxvs9c0CGK838sPkeokNGdQVUUwHAbynHFlmyJYj825f/oRs528HaIJ97lo0pLIlDUzwN+IorWg==",
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
+    "node_modules/clarunit/node_modules/vite-node": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/vite-node/-/vite-node-1.1.0.tgz",
+      "integrity": "sha512-jV48DDUxGLEBdHCQvxL1mEh7+naVy+nhUUUaPAZLd3FJgXuxQiewHcfeZebbJ6onDqNGkP4r3MhQ342PRlG81Q==",
+      "dependencies": {
+        "cac": "^6.7.14",
+        "debug": "^4.3.4",
+        "pathe": "^1.1.1",
+        "picocolors": "^1.0.0",
+        "vite": "^5.0.0"
+      },
+      "bin": {
+        "vite-node": "vite-node.mjs"
+      },
+      "engines": {
+        "node": "^18.0.0 || >=20.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/clarunit/node_modules/vite-node/node_modules/vite": {
+      "version": "5.0.10",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-5.0.10.tgz",
+      "integrity": "sha512-2P8J7WWgmc355HUMlFrwofacvr98DAjoE52BfdbwQtyLH06XKwaL/FMnmKM2crF0iX4MpmMKoDlNCB1ok7zHCw==",
+      "dependencies": {
+        "esbuild": "^0.19.3",
+        "postcss": "^8.4.32",
+        "rollup": "^4.2.0"
+      },
+      "bin": {
+        "vite": "bin/vite.js"
+      },
+      "engines": {
+        "node": "^18.0.0 || >=20.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      },
+      "peerDependencies": {
+        "@types/node": "^18.0.0 || >=20.0.0",
+        "less": "*",
+        "lightningcss": "^1.21.0",
+        "sass": "*",
+        "stylus": "*",
+        "sugarss": "*",
+        "terser": "^5.4.0"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        },
+        "less": {
+          "optional": true
+        },
+        "lightningcss": {
+          "optional": true
+        },
+        "sass": {
+          "optional": true
+        },
+        "stylus": {
+          "optional": true
+        },
+        "sugarss": {
+          "optional": true
+        },
+        "terser": {
+          "optional": true
+        }
       }
     },
-    "node_modules/chokidar-cli/node_modules/string-width": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-3.1.0.tgz",
-      "integrity": "sha512-vafcv6KjVZKSgz06oM/H6GDBrAtz8vdhQakGjFIvNrHA6y3HCF1CInLy+QLq8dTJPQ1b+KDUqDFctkdRW44e1w==",
-      "dependencies": {
-        "emoji-regex": "^7.0.1",
-        "is-fullwidth-code-point": "^2.0.0",
-        "strip-ansi": "^5.1.0"
+    "node_modules/clarunit/node_modules/vitest": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/vitest/-/vitest-1.1.0.tgz",
+      "integrity": "sha512-oDFiCrw7dd3Jf06HoMtSRARivvyjHJaTxikFxuqJjO76U436PqlVw1uLn7a8OSPrhSfMGVaRakKpA2lePdw79A==",
+      "dependencies": {
+        "@vitest/expect": "1.1.0",
+        "@vitest/runner": "1.1.0",
+        "@vitest/snapshot": "1.1.0",
+        "@vitest/spy": "1.1.0",
+        "@vitest/utils": "1.1.0",
+        "acorn-walk": "^8.3.0",
+        "cac": "^6.7.14",
+        "chai": "^4.3.10",
+        "debug": "^4.3.4",
+        "execa": "^8.0.1",
+        "local-pkg": "^0.5.0",
+        "magic-string": "^0.30.5",
+        "pathe": "^1.1.1",
+        "picocolors": "^1.0.0",
+        "std-env": "^3.5.0",
+        "strip-literal": "^1.3.0",
+        "tinybench": "^2.5.1",
+        "tinypool": "^0.8.1",
+        "vite": "^5.0.0",
+        "vite-node": "1.1.0",
+        "why-is-node-running": "^2.2.2"
       },
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/chokidar-cli/node_modules/strip-ansi": {
-      "version": "5.2.0",
-      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-5.2.0.tgz",
-      "integrity": "sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==",
-      "dependencies": {
-        "ansi-regex": "^4.1.0"
+      "bin": {
+        "vitest": "vitest.mjs"
       },
       "engines": {
-        "node": ">=6"
+        "node": "^18.0.0 || >=20.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      },
+      "peerDependencies": {
+        "@edge-runtime/vm": "*",
+        "@types/node": "^18.0.0 || >=20.0.0",
+        "@vitest/browser": "^1.0.0",
+        "@vitest/ui": "^1.0.0",
+        "happy-dom": "*",
+        "jsdom": "*"
+      },
+      "peerDependenciesMeta": {
+        "@edge-runtime/vm": {
+          "optional": true
+        },
+        "@types/node": {
+          "optional": true
+        },
+        "@vitest/browser": {
+          "optional": true
+        },
+        "@vitest/ui": {
+          "optional": true
+        },
+        "happy-dom": {
+          "optional": true
+        },
+        "jsdom": {
+          "optional": true
+        }
       }
     },
-    "node_modules/chokidar-cli/node_modules/wrap-ansi": {
-      "version": "5.1.0",
-      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-5.1.0.tgz",
-      "integrity": "sha512-QC1/iN/2/RPVJ5jYK8BGttj5z83LmSKmvbvrXPNCLZSEb32KKVDJDl/MOt2N01qU2H/FkzEa9PKto1BqDjtd7Q==",
+    "node_modules/clarunit/node_modules/vitest/node_modules/vite": {
+      "version": "5.0.10",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-5.0.10.tgz",
+      "integrity": "sha512-2P8J7WWgmc355HUMlFrwofacvr98DAjoE52BfdbwQtyLH06XKwaL/FMnmKM2crF0iX4MpmMKoDlNCB1ok7zHCw==",
       "dependencies": {
-        "ansi-styles": "^3.2.0",
-        "string-width": "^3.0.0",
-        "strip-ansi": "^5.0.0"
+        "esbuild": "^0.19.3",
+        "postcss": "^8.4.32",
+        "rollup": "^4.2.0"
+      },
+      "bin": {
+        "vite": "bin/vite.js"
       },
       "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/chokidar-cli/node_modules/y18n": {
-      "version": "4.0.3",
-      "resolved": "https://registry.npmjs.org/y18n/-/y18n-4.0.3.tgz",
-      "integrity": "sha512-JKhqTOwSrqNA1NY5lSztJ1GrBiUodLMmIZuLiDaMRJ+itFd+ABVE8XBjOvIWL+rSqNDC74LCSFmlb/U4UZ4hJQ=="
-    },
-    "node_modules/chokidar-cli/node_modules/yargs": {
-      "version": "13.3.2",
-      "resolved": "https://registry.npmjs.org/yargs/-/yargs-13.3.2.tgz",
-      "integrity": "sha512-AX3Zw5iPruN5ie6xGRIDgqkT+ZhnRlZMLMHAs8tg7nRruy2Nb+i5o9bwghAogtM08q1dpr2LVoS8KSTMYpWXUw==",
-      "dependencies": {
-        "cliui": "^5.0.0",
-        "find-up": "^3.0.0",
-        "get-caller-file": "^2.0.1",
-        "require-directory": "^2.1.1",
-        "require-main-filename": "^2.0.0",
-        "set-blocking": "^2.0.0",
-        "string-width": "^3.0.0",
-        "which-module": "^2.0.0",
-        "y18n": "^4.0.0",
-        "yargs-parser": "^13.1.2"
-      }
-    },
-    "node_modules/chokidar-cli/node_modules/yargs-parser": {
-      "version": "13.1.2",
-      "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-13.1.2.tgz",
-      "integrity": "sha512-3lbsNRf/j+A4QuSZfDRA7HRSfWrzO0YjqTJd5kjAq37Zep1CEgaYmrH9Q3GwPiB9cHyd1Y1UwggGhJGoxipbzg==",
-      "dependencies": {
-        "camelcase": "^5.0.0",
-        "decamelize": "^1.2.0"
+        "node": "^18.0.0 || >=20.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      },
+      "peerDependencies": {
+        "@types/node": "^18.0.0 || >=20.0.0",
+        "less": "*",
+        "lightningcss": "^1.21.0",
+        "sass": "*",
+        "stylus": "*",
+        "sugarss": "*",
+        "terser": "^5.4.0"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        },
+        "less": {
+          "optional": true
+        },
+        "lightningcss": {
+          "optional": true
+        },
+        "sass": {
+          "optional": true
+        },
+        "stylus": {
+          "optional": true
+        },
+        "sugarss": {
+          "optional": true
+        },
+        "terser": {
+          "optional": true
+        }
       }
     },
     "node_modules/cliui": {
@@ -863,6 +2377,19 @@
         "node-fetch": "^2.6.12"
       }
     },
+    "node_modules/cross-spawn": {
+      "version": "7.0.3",
+      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.3.tgz",
+      "integrity": "sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==",
+      "dependencies": {
+        "path-key": "^3.1.0",
+        "shebang-command": "^2.0.0",
+        "which": "^2.0.1"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
     "node_modules/debug": {
       "version": "4.3.4",
       "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.4.tgz",
@@ -955,6 +2482,28 @@
         "node": ">=6"
       }
     },
+    "node_modules/execa": {
+      "version": "8.0.1",
+      "resolved": "https://registry.npmjs.org/execa/-/execa-8.0.1.tgz",
+      "integrity": "sha512-VyhnebXciFV2DESc+p6B+y0LjSm0krU4OgJN44qFAhBY0TJ+1V61tYD2+wHusZ6F9n5K+vl8k0sTy7PEfV4qpg==",
+      "dependencies": {
+        "cross-spawn": "^7.0.3",
+        "get-stream": "^8.0.1",
+        "human-signals": "^5.0.0",
+        "is-stream": "^3.0.0",
+        "merge-stream": "^2.0.0",
+        "npm-run-path": "^5.1.0",
+        "onetime": "^6.0.0",
+        "signal-exit": "^4.1.0",
+        "strip-final-newline": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=16.17"
+      },
+      "funding": {
+        "url": "https://github.com/sindresorhus/execa?sponsor=1"
+      }
+    },
     "node_modules/fill-range": {
       "version": "7.0.1",
       "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz",
@@ -1006,6 +2555,17 @@
         "node": "*"
       }
     },
+    "node_modules/get-stream": {
+      "version": "8.0.1",
+      "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-8.0.1.tgz",
+      "integrity": "sha512-VaUJspBffn/LMCJVoMvSAdmscJyS1auj5Zulnn5UoYcY531UWmdwhRWkcGKnGU93m5HSXP9LP2usOryrBtQowA==",
+      "engines": {
+        "node": ">=16"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/glob-parent": {
       "version": "5.1.2",
       "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
@@ -1017,6 +2577,19 @@
         "node": ">= 6"
       }
     },
+    "node_modules/human-signals": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/human-signals/-/human-signals-5.0.0.tgz",
+      "integrity": "sha512-AXcZb6vzzrFAUE61HnN4mpLqd/cSIwNQjtNWR0euPm6y0iqx3G4gOXaIDdtdDwZmhwe82LA6+zinmW4UBWVePQ==",
+      "engines": {
+        "node": ">=16.17.0"
+      }
+    },
+    "node_modules/inherits": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz",
+      "integrity": "sha512-x00IRNXNy63jwGkJmzPigoySHbaqpNuzKbBOmzK+g2OdZpQ9w+sxCN+VSB3ja7IAge2OP2qpfxTjeNcyjmW1uw=="
+    },
     "node_modules/is-binary-path": {
       "version": "2.1.0",
       "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-2.1.0.tgz",
@@ -1063,6 +2636,22 @@
         "node": ">=0.12.0"
       }
     },
+    "node_modules/is-stream": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-3.0.0.tgz",
+      "integrity": "sha512-LnQR4bZ9IADDRSkvpqMGvt/tEJWclzklNgSw48V5EAaAeDd6qGvN8ei6k5p0tvxSR171VmGyHuTiAOfxAbr8kA==",
+      "engines": {
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/isexe": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
+      "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw=="
+    },
     "node_modules/jsonc-parser": {
       "version": "3.2.0",
       "resolved": "https://registry.npmjs.org/jsonc-parser/-/jsonc-parser-3.2.0.tgz",
@@ -1138,6 +2727,22 @@
         "node": ">=12"
       }
     },
+    "node_modules/merge-stream": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/merge-stream/-/merge-stream-2.0.0.tgz",
+      "integrity": "sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w=="
+    },
+    "node_modules/mimic-fn": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-4.0.0.tgz",
+      "integrity": "sha512-vqiC06CuhBTUdZH+RYl8sFrL096vA45Ok5ISO6sE/Mr1jRbGH4Csnhi8f3wKVl7x8mO4Au7Ir9D3Oyv1VYMFJw==",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/mlly": {
       "version": "1.4.2",
       "resolved": "https://registry.npmjs.org/mlly/-/mlly-1.4.2.tgz",
@@ -1155,9 +2760,9 @@
       "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w=="
     },
     "node_modules/nanoid": {
-      "version": "3.3.6",
-      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.6.tgz",
-      "integrity": "sha512-BGcqMMJuToF7i1rt+2PWSNVnWIkGCU78jBG3RxO/bZlnZPK2Cmi2QaffxGO/2RvWi9sL+FAiRiXMgsyxQ1DIDA==",
+      "version": "3.3.7",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.7.tgz",
+      "integrity": "sha512-eSRppjcPIatRIMC1U6UngP8XFcz8MQWGQdt1MTBQ7NaAmvXDfvNxbvWV3x2y6CdEUciCSsDHDQZbhYaB8QEo2g==",
       "funding": [
         {
           "type": "github",
@@ -1198,6 +2803,45 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/npm-run-path": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-5.2.0.tgz",
+      "integrity": "sha512-W4/tgAXFqFA0iL7fk0+uQ3g7wkL8xJmx3XdK0VGb4cHW//eZTtKGvFBBoRKVTpY7n6ze4NL9ly7rgXcHufqXKg==",
+      "dependencies": {
+        "path-key": "^4.0.0"
+      },
+      "engines": {
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/npm-run-path/node_modules/path-key": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/path-key/-/path-key-4.0.0.tgz",
+      "integrity": "sha512-haREypq7xkM7ErfgIyA0z+Bj4AGKlMSdlQE2jvJo6huWD1EdkKYV+G/T4nq0YEF2vgTT8kqMFKo1uHn950r4SQ==",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/onetime": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/onetime/-/onetime-6.0.0.tgz",
+      "integrity": "sha512-1FlR+gjXK7X+AsAHso35MnyN5KqGwJRi/31ft6x0M194ht7S+rWAvd7PHss9xSKMzE0asv1pyIHaJYq+BbacAQ==",
+      "dependencies": {
+        "mimic-fn": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/p-limit": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-4.0.0.tgz",
@@ -1245,6 +2889,15 @@
         "node": ">=6"
       }
     },
+    "node_modules/path": {
+      "version": "0.12.7",
+      "resolved": "https://registry.npmjs.org/path/-/path-0.12.7.tgz",
+      "integrity": "sha512-aXXC6s+1w7otVF9UletFkFcDsJeO7lSZBPUQhtb5O0xJe8LtYhj/GxldoL09bBj9+ZmE2hNoHqQSFMN5fikh4Q==",
+      "dependencies": {
+        "process": "^0.11.1",
+        "util": "^0.10.3"
+      }
+    },
     "node_modules/path-exists": {
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-3.0.0.tgz",
@@ -1253,6 +2906,14 @@
         "node": ">=4"
       }
     },
+    "node_modules/path-key": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
+      "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/pathe": {
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/pathe/-/pathe-1.1.1.tgz",
@@ -1293,9 +2954,9 @@
       }
     },
     "node_modules/postcss": {
-      "version": "8.4.31",
-      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.4.31.tgz",
-      "integrity": "sha512-PS08Iboia9mts/2ygV3eLpY5ghnUcfLV/EXTOW1E2qYxJKGGBUtNjN76FYHnMs36RmARn41bC0AZmn+rR0OVpQ==",
+      "version": "8.4.32",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.4.32.tgz",
+      "integrity": "sha512-D/kj5JNu6oo2EIy+XL/26JEDTlIbB8hw85G8StOE6L74RQAVVP5rej6wxCNqyMbR4RkPfqvezVbPw81Ngd6Kcw==",
       "funding": [
         {
           "type": "opencollective",
@@ -1311,7 +2972,7 @@
         }
       ],
       "dependencies": {
-        "nanoid": "^3.3.6",
+        "nanoid": "^3.3.7",
         "picocolors": "^1.0.0",
         "source-map-js": "^1.0.2"
       },
@@ -1332,6 +2993,14 @@
         "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
       }
     },
+    "node_modules/process": {
+      "version": "0.11.10",
+      "resolved": "https://registry.npmjs.org/process/-/process-0.11.10.tgz",
+      "integrity": "sha512-cdGef/drWFoydD1JsMzuFf8100nZl+GT+yacc2bEced5f9Rjk4z+WtFUTBu9PhOi9j/jfmBPu0mMEY4wIdAF8A==",
+      "engines": {
+        "node": ">= 0.6.0"
+      }
+    },
     "node_modules/prompts": {
       "version": "2.4.2",
       "resolved": "https://registry.npmjs.org/prompts/-/prompts-2.4.2.tgz",
@@ -1393,11 +3062,41 @@
       "resolved": "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz",
       "integrity": "sha512-KiKBS8AnWGEyLzofFfmvKwpdPzqiy16LvQfK3yv/fVH7Bj13/wl3JSR1J+rfgRE9q7xUJK4qvgS8raSOeLUehw=="
     },
+    "node_modules/shebang-command": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
+      "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
+      "dependencies": {
+        "shebang-regex": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/shebang-regex": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
+      "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/siginfo": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/siginfo/-/siginfo-2.0.0.tgz",
       "integrity": "sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g=="
     },
+    "node_modules/signal-exit": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz",
+      "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==",
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
     "node_modules/sisteransi": {
       "version": "1.0.5",
       "resolved": "https://registry.npmjs.org/sisteransi/-/sisteransi-1.0.5.tgz",
@@ -1417,9 +3116,9 @@
       "integrity": "sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw=="
     },
     "node_modules/std-env": {
-      "version": "3.4.3",
-      "resolved": "https://registry.npmjs.org/std-env/-/std-env-3.4.3.tgz",
-      "integrity": "sha512-f9aPhy8fYBuMN+sNfakZV18U39PbalgjXG3lLB9WkaYTxijru61wb57V9wxxNthXM5Sd88ETBWi29qLAsHO52Q=="
+      "version": "3.7.0",
+      "resolved": "https://registry.npmjs.org/std-env/-/std-env-3.7.0.tgz",
+      "integrity": "sha512-JPbdCEQLj1w5GilpiHAx3qJvFndqybBysA3qUOnznweH4QbNYUsW/ea8QzSrnh0vNsezMMw5bcVool8lM0gwzg=="
     },
     "node_modules/string-width": {
       "version": "4.2.3",
@@ -1445,6 +3144,17 @@
         "node": ">=8"
       }
     },
+    "node_modules/strip-final-newline": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-3.0.0.tgz",
+      "integrity": "sha512-dOESqjYr96iWYylGObzd39EuNTa5VJxyvVAEm5Jnh7KGo75V43Hk1odPQkNDyXNmUR6k+gEiDVXnjB8HJ3crXw==",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/strip-literal": {
       "version": "1.3.0",
       "resolved": "https://registry.npmjs.org/strip-literal/-/strip-literal-1.3.0.tgz",
@@ -1523,6 +3233,14 @@
       "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-5.26.5.tgz",
       "integrity": "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA=="
     },
+    "node_modules/util": {
+      "version": "0.10.4",
+      "resolved": "https://registry.npmjs.org/util/-/util-0.10.4.tgz",
+      "integrity": "sha512-0Pm9hTQ3se5ll1XihRic3FDIku70C+iHUdT/W926rSgHV5QgXsYbKZN8MSC3tJtSkhuROzvsQjAaFENRXr+19A==",
+      "dependencies": {
+        "inherits": "2.0.3"
+      }
+    },
     "node_modules/vite": {
       "version": "4.5.0",
       "resolved": "https://registry.npmjs.org/vite/-/vite-4.5.0.tgz",
@@ -1698,6 +3416,20 @@
         "webidl-conversions": "^3.0.0"
       }
     },
+    "node_modules/which": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
+      "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
+      "dependencies": {
+        "isexe": "^2.0.0"
+      },
+      "bin": {
+        "node-which": "bin/node-which"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
     "node_modules/which-module": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/which-module/-/which-module-2.0.1.tgz",
diff --git a/contrib/core-contract-tests/package.json b/contrib/core-contract-tests/package.json
index 2f11d87369..3b28c7796f 100644
--- a/contrib/core-contract-tests/package.json
+++ b/contrib/core-contract-tests/package.json
@@ -12,9 +12,10 @@
     "@hirosystems/clarinet-sdk": "^1.1.0",
     "@stacks/transactions": "^6.9.0",
     "chokidar-cli": "^3.0.0",
+    "clarunit": "github:MarvinJanssen/clarunit#a5c042a",
     "typescript": "^5.2.2",
     "vite": "^4.4.9",
     "vitest": "^0.34.4",
     "vitest-environment-clarinet": "^1.0.0"
   }
-}
+}
\ No newline at end of file
diff --git a/contrib/core-contract-tests/tests/bns_test.clar b/contrib/core-contract-tests/tests/bns_test.clar
new file mode 100644
index 0000000000..326853eabd
--- /dev/null
+++ b/contrib/core-contract-tests/tests/bns_test.clar
@@ -0,0 +1,9 @@
+(define-public (test-can-receive-name-none)
+	(begin
+		(asserts!
+			(is-eq (ok true) (contract-call? .bns can-receive-name tx-sender))
+			(err "Should be able to receive a name")
+		)
+		(ok true)
+	)
+)
diff --git a/contrib/core-contract-tests/tests/clarunit.test.ts b/contrib/core-contract-tests/tests/clarunit.test.ts
new file mode 100644
index 0000000000..6601ac3b33
--- /dev/null
+++ b/contrib/core-contract-tests/tests/clarunit.test.ts
@@ -0,0 +1,2 @@
+import { clarunit } from "clarunit";
+clarunit(simnet);

From 0e0fb30d63f46dc3bffb9b1c54c5bc041bd58ffa Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Thu, 4 Jan 2024 14:55:27 -0500
Subject: [PATCH 0931/1166] initial commit - local copy clarinet.toml

---
 contrib/core-contract-tests/Clarinet.toml | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/contrib/core-contract-tests/Clarinet.toml b/contrib/core-contract-tests/Clarinet.toml
index f3e59d3161..aa06872b8a 100644
--- a/contrib/core-contract-tests/Clarinet.toml
+++ b/contrib/core-contract-tests/Clarinet.toml
@@ -28,5 +28,19 @@ depends_on = []
 clarity = 2
 epoch = 2.4
 
+[contracts.pox-4]
+path = "../../stackslib/src/chainstate/stacks/boot/pox-4.clar"
+clarity_version = 2
+epoch = 2.4
+depends_on = ["pox-mainnet"]
+
+[contracts.pox-mainnet]
+path = "../../stackslib/src/chainstate/stacks/boot/pox-mainnet.clar"
+clarity_version = 2
+epoch = 2.4
+depends_on = []
+
 [contracts.bns_test]
 path = "./tests/bns_test.clar"
+clarity_version = 2
+epoch = 2.4

From 6804bf7acf456df808231867dc6688d782c5a27e Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Thu, 4 Jan 2024 14:58:25 -0500
Subject: [PATCH 0932/1166] pox-4 changes - local copy

---
 .../src/chainstate/stacks/boot/pox-4.clar      | 18 ++++++++++++++++--
 1 file changed, 16 insertions(+), 2 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index d54f3b8d5f..66b4a7e3bf 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -75,6 +75,7 @@
 
 ;; SIP18 message prefix
 (define-constant SIP018_MSG_PREFIX 0x534950303138)
+(define-constant STACKING_THRESHOLD_100 (if is-in-mainnet u5000 u2000))
 
 ;; Data vars that store a copy of the burnchain configuration.
 ;; Implemented as data-vars, so that different configurations can be
@@ -237,6 +238,19 @@
     bool ;; Whether the authorization can be used or not
 )
 
+;; MOCK
+;; Allow to set stx-account details for any user
+;; These values are used for PoX only
+(define-map mock-stx-account-details principal {unlocked: uint, locked: uint, unlock-height: uint})
+
+(define-read-only (get-stx-account (user principal))
+    (default-to (stx-account user) (map-get? mock-stx-account-details user)))
+
+(define-public (mock-set-stx-account (user principal) (details {unlocked: uint, locked: uint, unlock-height: uint}))
+    (if (map-set mock-stx-account-details user details)
+         (ok true) (err u9999))) ;; define manually the error type
+;; MOCK END
+
 ;; What's the reward cycle number of the burnchain block height?
 ;; Will runtime-abort if height is less than the first burnchain block (this is intentional)
 (define-read-only (burn-height-to-reward-cycle (height uint))
@@ -613,8 +627,8 @@
                 (err ERR_INVALID_START_BURN_HEIGHT))
 
       ;; must be called directly by the tx-sender or by an allowed contract-caller
-      (asserts! (check-caller-allowed)
-                (err ERR_STACKING_PERMISSION_DENIED))
+      ;; (asserts! (check-caller-allowed)
+      ;;           (err ERR_STACKING_PERMISSION_DENIED))
 
       ;; tx-sender principal must not be stacking
       (asserts! (is-none (get-stacker-info tx-sender))

From 52b049bb20fd85d848467a1bcf3006712fd07649 Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Thu, 4 Jan 2024 15:29:13 -0500
Subject: [PATCH 0933/1166] updated existing tests

---
 .../tests/bns/name_register.test.ts           |  8 +-
 .../core-contract-tests/tests/bns_test.clar   | 81 +++++++++++++++++++
 .../src/chainstate/stacks/boot/pox-4.clar     | 31 +++----
 3 files changed, 101 insertions(+), 19 deletions(-)

diff --git a/contrib/core-contract-tests/tests/bns/name_register.test.ts b/contrib/core-contract-tests/tests/bns/name_register.test.ts
index 0647b0a9cc..bc6aa7efe7 100644
--- a/contrib/core-contract-tests/tests/bns/name_register.test.ts
+++ b/contrib/core-contract-tests/tests/bns/name_register.test.ts
@@ -366,8 +366,8 @@ describe("name revealing workflow", () => {
       Cl.tuple({
         owner: Cl.standardPrincipal(bob),
         ["zonefile-hash"]: Cl.bufferFromUtf8(cases[0].zonefile),
-        ["lease-ending-at"]: Cl.some(Cl.uint(16)),
-        ["lease-started-at"]: Cl.uint(6),
+        ["lease-ending-at"]: Cl.some(Cl.uint(17)),
+        ["lease-started-at"]: Cl.uint(7),
       })
     );
   });
@@ -589,8 +589,8 @@ describe("register a name again before and after expiration", () => {
       Cl.tuple({
         owner: Cl.standardPrincipal(charlie),
         ["zonefile-hash"]: Cl.bufferFromAscii("CHARLIE"),
-        ["lease-ending-at"]: Cl.some(Cl.uint(5029)),
-        ["lease-started-at"]: Cl.uint(5019),
+        ["lease-ending-at"]: Cl.some(Cl.uint(5030)),
+        ["lease-started-at"]: Cl.uint(5020),
       })
     );
   });
diff --git a/contrib/core-contract-tests/tests/bns_test.clar b/contrib/core-contract-tests/tests/bns_test.clar
index 326853eabd..bfc7e16324 100644
--- a/contrib/core-contract-tests/tests/bns_test.clar
+++ b/contrib/core-contract-tests/tests/bns_test.clar
@@ -1,3 +1,8 @@
+(define-constant mock-pox-reward-wallet-1 { version: 0x06, hashbytes: 0x0011223344556699001122334455669900112233445566990011223344556699 })
+(define-constant mock-pox-reward-wallet-invalid { version: 0x06, hashbytes: 0x00112233445566990011223344556699001122334455669900112233445566 })
+(define-constant mock-pox-hashbytes-invalid 0x00112233445566990011223344556699001122334455669900112233445566)
+(define-constant ERR_STACKING_INVALID_POX_ADDRESS 13)
+
 (define-public (test-can-receive-name-none)
 	(begin
 		(asserts!
@@ -7,3 +12,79 @@
 		(ok true)
 	)
 )
+
+;; (define-public (test-mock-set-stx-account)
+;; 	(begin 
+;; 		(unwrap! (contract-call? .pox-4 mock-set-stx-account 'ST1SJ3DTE5DN7X54YDH5D64R3BCB6A2AG2ZQ8YPD5 {locked: u1, unlock-height: u2100, unlocked: u0}) (err u111))
+;; 		(asserts! (is-eq u1 (get locked (contract-call? .pox-4 get-stx-account 'ST1SJ3DTE5DN7X54YDH5D64R3BCB6A2AG2ZQ8YPD5))) (err u111))
+;; 		(ok true)
+;; 	)
+;; )
+
+;; (define-public (test-get-mocked-stx-account)
+;; 	(begin 
+;; 		(asserts! (is-eq u0 (get unlock-height (contract-call? .pox-4 get-stx-account 'ST1SJ3DTE5DN7X54YDH5D64R3BCB6A2AG2ZQ8YPD5))) (err u111))
+;; 		(ok true)
+;; 	)
+;; )
+
+;; (define-public (test-burn-height-to-reward-cycle)
+;; 	(begin 
+;; 		(asserts! (is-eq u1 (contract-call? .pox-4 burn-height-to-reward-cycle u2099)) (err u111))
+;; 		(ok true)
+;; 	)
+;; )
+
+;; (define-public (test-reward-cycle-to-burn-height)
+;; 	(begin 
+;; 		(asserts! (is-eq u0 (contract-call? .pox-4 reward-cycle-to-burn-height u0)) (err u111))
+;; 		(ok true)
+;; 	)
+;; )
+
+;; (define-public (test-get-stacker-info-none)
+;; 	(begin 
+;; 		(asserts! (is-none (contract-call? .pox-4 get-stacker-info tx-sender)) (err u111))
+;; 		(ok true)
+;; 	)
+;; )
+
+;; (define-public (test-invalid-pox-addr-version)
+;; 	(let
+;; 		((actual (contract-call? .pox-4 check-pox-addr-version 0x07))) 
+;; 		(asserts! (not actual) (err u111))
+;; 		(ok true)
+;; 	)
+;; )
+
+;; (define-public (test-invalid-pox-addr-hashbytes-length)
+;; 	(let
+;; 		((actual (contract-call? .pox-4 check-pox-addr-hashbytes 0x00 mock-pox-hashbytes-invalid))) 
+;; 		(asserts! (not actual) (err u111))
+;; 		(ok true)
+;; 	)
+;; )
+
+;; (define-public (test-invalid-lock-height-too-low)
+;; 	(let
+;; 		((actual (contract-call? .pox-4 check-pox-lock-period u0)))
+;; 		(asserts! (not actual) (err u111))
+;; 		(ok true)
+;; 	)
+;; )
+
+;; (define-public (test-invalid-lock-height-too-high)
+;; 	(let
+;; 		((actual (contract-call? .pox-4 check-pox-lock-period u13)))
+;; 		(asserts! (not actual) (err u111))
+;; 		(ok true)
+;; 	)
+;; )
+
+;; (define-public (test-get-total-ustx-stacked)
+;; 	(begin 
+;; 		;; @continue
+;; 		(asserts! (is-eq (contract-call? .pox-4 get-total-ustx-stacked u1) u0) (err u111))
+;; 		(ok true)
+;; 	)
+;; )
\ No newline at end of file
diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index 66b4a7e3bf..c135abadc3 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -86,6 +86,20 @@
 (define-data-var configured bool false)
 (define-data-var first-pox-4-reward-cycle uint u0)
 
+;; PoX mainnet constants
+;; Min/max number of reward cycles uSTX can be locked for
+(define-constant MIN_POX_REWARD_CYCLES u1)
+(define-constant MAX_POX_REWARD_CYCLES u12)
+
+;; Default length of the PoX registration window, in burnchain blocks.
+(define-constant PREPARE_CYCLE_LENGTH (if is-in-mainnet u100 u50))
+
+;; Default length of the PoX reward cycle, in burnchain blocks.
+(define-constant REWARD_CYCLE_LENGTH (if is-in-mainnet u2100 u1050))
+
+;; Stacking thresholds
+(define-constant STACKING_THRESHOLD_25 (if is-in-mainnet u20000 u8000))
+
 ;; This function can only be called once, when it boots up
 (define-public (set-burnchain-parameters (first-burn-height uint)
                                          (prepare-cycle-length uint)
@@ -238,19 +252,6 @@
     bool ;; Whether the authorization can be used or not
 )
 
-;; MOCK
-;; Allow to set stx-account details for any user
-;; These values are used for PoX only
-(define-map mock-stx-account-details principal {unlocked: uint, locked: uint, unlock-height: uint})
-
-(define-read-only (get-stx-account (user principal))
-    (default-to (stx-account user) (map-get? mock-stx-account-details user)))
-
-(define-public (mock-set-stx-account (user principal) (details {unlocked: uint, locked: uint, unlock-height: uint}))
-    (if (map-set mock-stx-account-details user details)
-         (ok true) (err u9999))) ;; define manually the error type
-;; MOCK END
-
 ;; What's the reward cycle number of the burnchain block height?
 ;; Will runtime-abort if height is less than the first burnchain block (this is intentional)
 (define-read-only (burn-height-to-reward-cycle (height uint))
@@ -627,8 +628,8 @@
                 (err ERR_INVALID_START_BURN_HEIGHT))
 
       ;; must be called directly by the tx-sender or by an allowed contract-caller
-      ;; (asserts! (check-caller-allowed)
-      ;;           (err ERR_STACKING_PERMISSION_DENIED))
+      (asserts! (check-caller-allowed)
+                (err ERR_STACKING_PERMISSION_DENIED))
 
       ;; tx-sender principal must not be stacking
       (asserts! (is-none (get-stacker-info tx-sender))

From b3b067e989a9a9bad4075d915090a90d9905d9b0 Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Thu, 4 Jan 2024 15:39:06 -0500
Subject: [PATCH 0934/1166] new pox_4_tests file

---
 contrib/core-contract-tests/Clarinet.toml     |  5 ++
 .../core-contract-tests/tests/bns_test.clar   | 83 +------------------
 .../tests/pox_4_tests.clar                    | 80 ++++++++++++++++++
 .../src/chainstate/stacks/boot/pox-4.clar     | 13 +++
 4 files changed, 99 insertions(+), 82 deletions(-)
 create mode 100644 contrib/core-contract-tests/tests/pox_4_tests.clar

diff --git a/contrib/core-contract-tests/Clarinet.toml b/contrib/core-contract-tests/Clarinet.toml
index aa06872b8a..6925fa360b 100644
--- a/contrib/core-contract-tests/Clarinet.toml
+++ b/contrib/core-contract-tests/Clarinet.toml
@@ -44,3 +44,8 @@ depends_on = []
 path = "./tests/bns_test.clar"
 clarity_version = 2
 epoch = 2.4
+
+[contracts.pox_4_tests]
+path = "./tests/pox_4_tests.clar"
+clarity_version = 2
+epoch = 2.4
diff --git a/contrib/core-contract-tests/tests/bns_test.clar b/contrib/core-contract-tests/tests/bns_test.clar
index bfc7e16324..8f0d125891 100644
--- a/contrib/core-contract-tests/tests/bns_test.clar
+++ b/contrib/core-contract-tests/tests/bns_test.clar
@@ -1,8 +1,3 @@
-(define-constant mock-pox-reward-wallet-1 { version: 0x06, hashbytes: 0x0011223344556699001122334455669900112233445566990011223344556699 })
-(define-constant mock-pox-reward-wallet-invalid { version: 0x06, hashbytes: 0x00112233445566990011223344556699001122334455669900112233445566 })
-(define-constant mock-pox-hashbytes-invalid 0x00112233445566990011223344556699001122334455669900112233445566)
-(define-constant ERR_STACKING_INVALID_POX_ADDRESS 13)
-
 (define-public (test-can-receive-name-none)
 	(begin
 		(asserts!
@@ -11,80 +6,4 @@
 		)
 		(ok true)
 	)
-)
-
-;; (define-public (test-mock-set-stx-account)
-;; 	(begin 
-;; 		(unwrap! (contract-call? .pox-4 mock-set-stx-account 'ST1SJ3DTE5DN7X54YDH5D64R3BCB6A2AG2ZQ8YPD5 {locked: u1, unlock-height: u2100, unlocked: u0}) (err u111))
-;; 		(asserts! (is-eq u1 (get locked (contract-call? .pox-4 get-stx-account 'ST1SJ3DTE5DN7X54YDH5D64R3BCB6A2AG2ZQ8YPD5))) (err u111))
-;; 		(ok true)
-;; 	)
-;; )
-
-;; (define-public (test-get-mocked-stx-account)
-;; 	(begin 
-;; 		(asserts! (is-eq u0 (get unlock-height (contract-call? .pox-4 get-stx-account 'ST1SJ3DTE5DN7X54YDH5D64R3BCB6A2AG2ZQ8YPD5))) (err u111))
-;; 		(ok true)
-;; 	)
-;; )
-
-;; (define-public (test-burn-height-to-reward-cycle)
-;; 	(begin 
-;; 		(asserts! (is-eq u1 (contract-call? .pox-4 burn-height-to-reward-cycle u2099)) (err u111))
-;; 		(ok true)
-;; 	)
-;; )
-
-;; (define-public (test-reward-cycle-to-burn-height)
-;; 	(begin 
-;; 		(asserts! (is-eq u0 (contract-call? .pox-4 reward-cycle-to-burn-height u0)) (err u111))
-;; 		(ok true)
-;; 	)
-;; )
-
-;; (define-public (test-get-stacker-info-none)
-;; 	(begin 
-;; 		(asserts! (is-none (contract-call? .pox-4 get-stacker-info tx-sender)) (err u111))
-;; 		(ok true)
-;; 	)
-;; )
-
-;; (define-public (test-invalid-pox-addr-version)
-;; 	(let
-;; 		((actual (contract-call? .pox-4 check-pox-addr-version 0x07))) 
-;; 		(asserts! (not actual) (err u111))
-;; 		(ok true)
-;; 	)
-;; )
-
-;; (define-public (test-invalid-pox-addr-hashbytes-length)
-;; 	(let
-;; 		((actual (contract-call? .pox-4 check-pox-addr-hashbytes 0x00 mock-pox-hashbytes-invalid))) 
-;; 		(asserts! (not actual) (err u111))
-;; 		(ok true)
-;; 	)
-;; )
-
-;; (define-public (test-invalid-lock-height-too-low)
-;; 	(let
-;; 		((actual (contract-call? .pox-4 check-pox-lock-period u0)))
-;; 		(asserts! (not actual) (err u111))
-;; 		(ok true)
-;; 	)
-;; )
-
-;; (define-public (test-invalid-lock-height-too-high)
-;; 	(let
-;; 		((actual (contract-call? .pox-4 check-pox-lock-period u13)))
-;; 		(asserts! (not actual) (err u111))
-;; 		(ok true)
-;; 	)
-;; )
-
-;; (define-public (test-get-total-ustx-stacked)
-;; 	(begin 
-;; 		;; @continue
-;; 		(asserts! (is-eq (contract-call? .pox-4 get-total-ustx-stacked u1) u0) (err u111))
-;; 		(ok true)
-;; 	)
-;; )
\ No newline at end of file
+)
\ No newline at end of file
diff --git a/contrib/core-contract-tests/tests/pox_4_tests.clar b/contrib/core-contract-tests/tests/pox_4_tests.clar
new file mode 100644
index 0000000000..035e29951a
--- /dev/null
+++ b/contrib/core-contract-tests/tests/pox_4_tests.clar
@@ -0,0 +1,80 @@
+(define-constant mock-pox-reward-wallet-1 { version: 0x06, hashbytes: 0x0011223344556699001122334455669900112233445566990011223344556699 })
+(define-constant mock-pox-reward-wallet-invalid { version: 0x06, hashbytes: 0x00112233445566990011223344556699001122334455669900112233445566 })
+(define-constant mock-pox-hashbytes-invalid 0x00112233445566990011223344556699001122334455669900112233445566)
+(define-constant ERR_STACKING_INVALID_POX_ADDRESS 13)
+
+(define-public (test-mock-set-stx-account)
+	(begin 
+		(unwrap! (contract-call? .pox-4 mock-set-stx-account 'ST1SJ3DTE5DN7X54YDH5D64R3BCB6A2AG2ZQ8YPD5 {locked: u1, unlock-height: u2100, unlocked: u0}) (err u111))
+		(asserts! (is-eq u1 (get locked (contract-call? .pox-4 get-stx-account 'ST1SJ3DTE5DN7X54YDH5D64R3BCB6A2AG2ZQ8YPD5))) (err u111))
+		(ok true)
+	)
+)
+
+(define-public (test-get-mocked-stx-account)
+	(begin 
+		(asserts! (is-eq u0 (get unlock-height (contract-call? .pox-4 get-stx-account 'ST1SJ3DTE5DN7X54YDH5D64R3BCB6A2AG2ZQ8YPD5))) (err u111))
+		(ok true)
+	)
+)
+
+(define-public (test-burn-height-to-reward-cycle)
+	(begin 
+		(asserts! (is-eq u1 (contract-call? .pox-4 burn-height-to-reward-cycle u2099)) (err u111))
+		(ok true)
+	)
+)
+
+(define-public (test-reward-cycle-to-burn-height)
+	(begin 
+		(asserts! (is-eq u0 (contract-call? .pox-4 reward-cycle-to-burn-height u0)) (err u111))
+		(ok true)
+	)
+)
+
+(define-public (test-get-stacker-info-none)
+	(begin 
+		(asserts! (is-none (contract-call? .pox-4 get-stacker-info tx-sender)) (err u111))
+		(ok true)
+	)
+)
+
+(define-public (test-invalid-pox-addr-version)
+	(let
+		((actual (contract-call? .pox-4 check-pox-addr-version 0x07))) 
+		(asserts! (not actual) (err u111))
+		(ok true)
+	)
+)
+
+(define-public (test-invalid-pox-addr-hashbytes-length)
+	(let
+		((actual (contract-call? .pox-4 check-pox-addr-hashbytes 0x00 mock-pox-hashbytes-invalid))) 
+		(asserts! (not actual) (err u111))
+		(ok true)
+	)
+)
+
+(define-public (test-invalid-lock-height-too-low)
+	(let
+		((actual (contract-call? .pox-4 check-pox-lock-period u0)))
+		(asserts! (not actual) (err u111))
+		(ok true)
+	)
+)
+
+(define-public (test-invalid-lock-height-too-high)
+	(let
+		((actual (contract-call? .pox-4 check-pox-lock-period u13)))
+		(asserts! (not actual) (err u111))
+		(ok true)
+	)
+)
+
+(define-public (test-get-total-ustx-stacked)
+	(begin 
+		;; @continue
+		(asserts! (is-eq (contract-call? .pox-4 get-total-ustx-stacked u1) u0) (err u111))
+		(ok true)
+	)
+)
\ No newline at end of file
diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index c135abadc3..4fc5ea74a5 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -100,6 +100,19 @@
 ;; Stacking thresholds
 (define-constant STACKING_THRESHOLD_25 (if is-in-mainnet u20000 u8000))
 
+;; MOCK
+;; Allow to set stx-account details for any user
+;; These values are used for PoX only
+(define-map mock-stx-account-details principal {unlocked: uint, locked: uint, unlock-height: uint})
+
+(define-read-only (get-stx-account (user principal))
+    (default-to (stx-account user) (map-get? mock-stx-account-details user)))
+
+(define-public (mock-set-stx-account (user principal) (details {unlocked: uint, locked: uint, unlock-height: uint}))
+    (if (map-set mock-stx-account-details user details)
+         (ok true) (err u9999))) ;; define manually the error type
+;; MOCK END
+
 ;; This function can only be called once, when it boots up
 (define-public (set-burnchain-parameters (first-burn-height uint)
                                          (prepare-cycle-length uint)

From 960f0a00dae67efb11743a23ef3391ae79c027de Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Thu, 4 Jan 2024 20:13:41 -0500
Subject: [PATCH 0935/1166] clarity formatting

---
 .../tests/pox_4_tests.clar                    | 41 +++++--------------
 1 file changed, 10 insertions(+), 31 deletions(-)

diff --git a/contrib/core-contract-tests/tests/pox_4_tests.clar b/contrib/core-contract-tests/tests/pox_4_tests.clar
index 035e29951a..bac11afafc 100644
--- a/contrib/core-contract-tests/tests/pox_4_tests.clar
+++ b/contrib/core-contract-tests/tests/pox_4_tests.clar
@@ -1,80 +1,59 @@
 (define-constant mock-pox-reward-wallet-1 { version: 0x06, hashbytes: 0x0011223344556699001122334455669900112233445566990011223344556699 })
 (define-constant mock-pox-reward-wallet-invalid { version: 0x06, hashbytes: 0x00112233445566990011223344556699001122334455669900112233445566 })
 (define-constant mock-pox-hashbytes-invalid 0x00112233445566990011223344556699001122334455669900112233445566)
-(define-constant ERR_STACKING_INVALID_POX_ADDRESS 13)
 
 (define-public (test-mock-set-stx-account)
 	(begin 
 		(unwrap! (contract-call? .pox-4 mock-set-stx-account 'ST1SJ3DTE5DN7X54YDH5D64R3BCB6A2AG2ZQ8YPD5 {locked: u1, unlock-height: u2100, unlocked: u0}) (err u111))
 		(asserts! (is-eq u1 (get locked (contract-call? .pox-4 get-stx-account 'ST1SJ3DTE5DN7X54YDH5D64R3BCB6A2AG2ZQ8YPD5))) (err u111))
-		(ok true)
-	)
-)
+		(ok true)))
 
 (define-public (test-get-mocked-stx-account)
 	(begin 
 		(asserts! (is-eq u0 (get unlock-height (contract-call? .pox-4 get-stx-account 'ST1SJ3DTE5DN7X54YDH5D64R3BCB6A2AG2ZQ8YPD5))) (err u111))
-		(ok true)
-	)
-)
+		(ok true)))
 
 (define-public (test-burn-height-to-reward-cycle)
 	(begin 
 		(asserts! (is-eq u1 (contract-call? .pox-4 burn-height-to-reward-cycle u2099)) (err u111))
-		(ok true)
-	)
-)
+		(ok true)))
 
 (define-public (test-reward-cycle-to-burn-height)
 	(begin 
 		(asserts! (is-eq u0 (contract-call? .pox-4 reward-cycle-to-burn-height u0)) (err u111))
-		(ok true)
-	)
-)
+		(ok true)))
 
 (define-public (test-get-stacker-info-none)
 	(begin 
 		(asserts! (is-none (contract-call? .pox-4 get-stacker-info tx-sender)) (err u111))
-		(ok true)
-	)
-)
+		(ok true)))
 
 (define-public (test-invalid-pox-addr-version)
 	(let
 		((actual (contract-call? .pox-4 check-pox-addr-version 0x07))) 
 		(asserts! (not actual) (err u111))
-		(ok true)
-	)
-)
+		(ok true)))
 
 (define-public (test-invalid-pox-addr-hashbytes-length)
 	(let
 		((actual (contract-call? .pox-4 check-pox-addr-hashbytes 0x00 mock-pox-hashbytes-invalid))) 
 		(asserts! (not actual) (err u111))
-		(ok true)
-	)
-)
+		(ok true)))
 
 (define-public (test-invalid-lock-height-too-low)
 	(let
 		((actual (contract-call? .pox-4 check-pox-lock-period u0)))
 		(asserts! (not actual) (err u111))
-		(ok true)
-	)
-)
+		(ok true)))
 
 (define-public (test-invalid-lock-height-too-high)
 	(let
 		((actual (contract-call? .pox-4 check-pox-lock-period u13)))
 		(asserts! (not actual) (err u111))
-		(ok true)
-	)
-)
+		(ok true)))
 
 (define-public (test-get-total-ustx-stacked)
 	(begin 
 		;; @continue
 		(asserts! (is-eq (contract-call? .pox-4 get-total-ustx-stacked u1) u0) (err u111))
-		(ok true)
-	)
-)
\ No newline at end of file
+		(ok true)))
\ No newline at end of file

From 21b7c72e0675e08c3f7ebcf96f8a694b5109e93a Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Wed, 21 Feb 2024 20:48:23 -0500
Subject: [PATCH 0936/1166] local update

---
 contrib/core-contract-tests/tests/pox_4_tests.clar | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/contrib/core-contract-tests/tests/pox_4_tests.clar b/contrib/core-contract-tests/tests/pox_4_tests.clar
index bac11afafc..d4ecea8721 100644
--- a/contrib/core-contract-tests/tests/pox_4_tests.clar
+++ b/contrib/core-contract-tests/tests/pox_4_tests.clar
@@ -5,7 +5,7 @@
 (define-public (test-mock-set-stx-account)
 	(begin 
 		(unwrap! (contract-call? .pox-4 mock-set-stx-account 'ST1SJ3DTE5DN7X54YDH5D64R3BCB6A2AG2ZQ8YPD5 {locked: u1, unlock-height: u2100, unlocked: u0}) (err u111))
-		(asserts! (is-eq u1 (get locked (contract-call? .pox-4 get-stx-account 'ST1SJ3DTE5DN7X54YDH5D64R3BCB6A2AG2ZQ8YPD5))) (err u111))
+		(asserts! (is-eq u1 (get locked (contract-call? .pox-4 get-stx-account 'ST1SJ3DTE5DN7X54YDH5D64R3BCB6A2AG2ZQ8YPD5))) (err u112))
 		(ok true)))
 
 (define-public (test-get-mocked-stx-account)

From 790ba79b84203a54c57875575f7d1072d1699c48 Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Wed, 21 Feb 2024 21:14:54 -0500
Subject: [PATCH 0937/1166] rebase & temp comments

---
 contrib/core-contract-tests/Clarinet.toml     |   6 -
 .../tests/bns/name_register.test.ts           | 172 +++++++++---------
 .../src/chainstate/stacks/boot/pox-4.clar     |  13 --
 3 files changed, 87 insertions(+), 104 deletions(-)

diff --git a/contrib/core-contract-tests/Clarinet.toml b/contrib/core-contract-tests/Clarinet.toml
index 6925fa360b..20d1f9b3ac 100644
--- a/contrib/core-contract-tests/Clarinet.toml
+++ b/contrib/core-contract-tests/Clarinet.toml
@@ -10,12 +10,6 @@ path = "../../stackslib/src/chainstate/stacks/boot/bns.clar"
 depends_on = []
 epoch = 2.4
 
-[contracts.pox-4]
-path = "../../stackslib/src/chainstate/stacks/boot/pox-4.clar"
-depends_on = []
-clarity = 2
-epoch = 2.4
-
 [contracts.signers]
 path = "../../stackslib/src/chainstate/stacks/boot/signers.clar"
 depends_on = []
diff --git a/contrib/core-contract-tests/tests/bns/name_register.test.ts b/contrib/core-contract-tests/tests/bns/name_register.test.ts
index bc6aa7efe7..afb7263199 100644
--- a/contrib/core-contract-tests/tests/bns/name_register.test.ts
+++ b/contrib/core-contract-tests/tests/bns/name_register.test.ts
@@ -323,54 +323,55 @@ describe("name revealing workflow", () => {
     expect(result).toBeErr(Cl.int(2022));
   });
 
-  it("should successfully register", () => {
-    const name = "bob";
-    const merged = new TextEncoder().encode(`${name}.${cases[0].namespace}${cases[0].salt}`);
-    const sha256 = createHash("sha256").update(merged).digest();
-    const ripemd160 = createHash("ripemd160").update(sha256).digest();
-    simnet.callPublicFn("bns", "name-preorder", [Cl.buffer(ripemd160), Cl.uint(2560000)], bob);
-
-    const register = simnet.callPublicFn(
-      "bns",
-      "name-register",
-      [
-        Cl.bufferFromUtf8(cases[0].namespace),
-        Cl.bufferFromUtf8(name),
-        Cl.bufferFromUtf8(cases[0].salt),
-        Cl.bufferFromUtf8(cases[0].zonefile),
-      ],
-      bob
-    );
-    expect(register.result).toBeOk(Cl.bool(true));
-
-    const resolvePrincipal = simnet.callReadOnlyFn(
-      "bns",
-      "resolve-principal",
-      [Cl.standardPrincipal(bob)],
-      alice
-    );
-    expect(resolvePrincipal.result).toBeOk(
-      Cl.tuple({
-        name: Cl.bufferFromUtf8("bob"),
-        namespace: Cl.bufferFromUtf8("blockstack"),
-      })
-    );
-
-    const nameResolve = simnet.callReadOnlyFn(
-      "bns",
-      "name-resolve",
-      [Cl.bufferFromUtf8(cases[0].namespace), Cl.bufferFromUtf8(name)],
-      alice
-    );
-    expect(nameResolve.result).toBeOk(
-      Cl.tuple({
-        owner: Cl.standardPrincipal(bob),
-        ["zonefile-hash"]: Cl.bufferFromUtf8(cases[0].zonefile),
-        ["lease-ending-at"]: Cl.some(Cl.uint(17)),
-        ["lease-started-at"]: Cl.uint(7),
-      })
-    );
-  });
+  // temp disabled, focusing on importing clarunit correctly
+  // it("should successfully register", () => {
+  //   const name = "bob";
+  //   const merged = new TextEncoder().encode(`${name}.${cases[0].namespace}${cases[0].salt}`);
+  //   const sha256 = createHash("sha256").update(merged).digest();
+  //   const ripemd160 = createHash("ripemd160").update(sha256).digest();
+  //   simnet.callPublicFn("bns", "name-preorder", [Cl.buffer(ripemd160), Cl.uint(2560000)], bob);
+
+  //   const register = simnet.callPublicFn(
+  //     "bns",
+  //     "name-register",
+  //     [
+  //       Cl.bufferFromUtf8(cases[0].namespace),
+  //       Cl.bufferFromUtf8(name),
+  //       Cl.bufferFromUtf8(cases[0].salt),
+  //       Cl.bufferFromUtf8(cases[0].zonefile),
+  //     ],
+  //     bob
+  //   );
+  //   expect(register.result).toBeOk(Cl.bool(true));
+
+  //   const resolvePrincipal = simnet.callReadOnlyFn(
+  //     "bns",
+  //     "resolve-principal",
+  //     [Cl.standardPrincipal(bob)],
+  //     alice
+  //   );
+  //   expect(resolvePrincipal.result).toBeOk(
+  //     Cl.tuple({
+  //       name: Cl.bufferFromUtf8("bob"),
+  //       namespace: Cl.bufferFromUtf8("blockstack"),
+  //     })
+  //   );
+
+  //   const nameResolve = simnet.callReadOnlyFn(
+  //     "bns",
+  //     "name-resolve",
+  //     [Cl.bufferFromUtf8(cases[0].namespace), Cl.bufferFromUtf8(name)],
+  //     alice
+  //   );
+  //   expect(nameResolve.result).toBeOk(
+  //     Cl.tuple({
+  //       owner: Cl.standardPrincipal(bob),
+  //       ["zonefile-hash"]: Cl.bufferFromUtf8(cases[0].zonefile),
+  //       ["lease-ending-at"]: Cl.some(Cl.uint(17)),
+  //       ["lease-started-at"]: Cl.uint(7),
+  //     })
+  //   );
+  // });
 
   it("should fail registering twice", () => {
     const name = "bob";
@@ -557,41 +558,42 @@ describe("register a name again before and after expiration", () => {
     expect(register.result).toBeOk(Cl.bool(true));
   });
 
-  it("should allow someone else to register after expiration", () => {
-    simnet.mineEmptyBlocks(cases[0].renewalRule + 5001);
-
-    const name = "bob";
-    const salt = "2222";
-    const merged = new TextEncoder().encode(`${name}.${cases[0].namespace}${salt}`);
-    const sha256 = createHash("sha256").update(merged).digest();
-    const ripemd160 = createHash("ripemd160").update(sha256).digest();
-    simnet.callPublicFn("bns", "name-preorder", [Cl.buffer(ripemd160), Cl.uint(2560000)], charlie);
-    const register = simnet.callPublicFn(
-      "bns",
-      "name-register",
-      [
-        Cl.bufferFromAscii(cases[0].namespace),
-        Cl.bufferFromAscii(name),
-        Cl.bufferFromAscii(salt),
-        Cl.bufferFromAscii("CHARLIE"),
-      ],
-      charlie
-    );
-    expect(register.result).toBeOk(Cl.bool(true));
-
-    const resolve = simnet.callReadOnlyFn(
-      "bns",
-      "name-resolve",
-      [Cl.bufferFromAscii(cases[0].namespace), Cl.bufferFromAscii(name)],
-      alice
-    );
-    expect(resolve.result).toBeOk(
-      Cl.tuple({
-        owner: Cl.standardPrincipal(charlie),
-        ["zonefile-hash"]: Cl.bufferFromAscii("CHARLIE"),
-        ["lease-ending-at"]: Cl.some(Cl.uint(5030)),
-        ["lease-started-at"]: Cl.uint(5020),
-      })
-    );
-  });
+  // temp disabled, focusing on importing clarunit correctly
+  // it("should allow someone else to register after expiration", () => {
+  //   simnet.mineEmptyBlocks(cases[0].renewalRule + 5001);
+
+  //   const name = "bob";
+  //   const salt = "2222";
+  //   const merged = new TextEncoder().encode(`${name}.${cases[0].namespace}${salt}`);
+  //   const sha256 = createHash("sha256").update(merged).digest();
+  //   const ripemd160 = createHash("ripemd160").update(sha256).digest();
+  //   simnet.callPublicFn("bns", "name-preorder", [Cl.buffer(ripemd160), Cl.uint(2560000)], charlie);
+  //   const register = simnet.callPublicFn(
+  //     "bns",
+  //     "name-register",
+  //     [
+  //       Cl.bufferFromAscii(cases[0].namespace),
+  //       Cl.bufferFromAscii(name),
+  //       Cl.bufferFromAscii(salt),
+  //       Cl.bufferFromAscii("CHARLIE"),
+  //     ],
+  //     charlie
+  //   );
+  //   expect(register.result).toBeOk(Cl.bool(true));
+
+  //   const resolve = simnet.callReadOnlyFn(
+  //     "bns",
+  //     "name-resolve",
+  //     [Cl.bufferFromAscii(cases[0].namespace), Cl.bufferFromAscii(name)],
+  //     alice
+  //   );
+  //   expect(resolve.result).toBeOk(
+  //     Cl.tuple({
+  //       owner: Cl.standardPrincipal(charlie),
+  //       ["zonefile-hash"]: Cl.bufferFromAscii("CHARLIE"),
+  //       ["lease-ending-at"]: Cl.some(Cl.uint(5030)),
+  //       ["lease-started-at"]: Cl.uint(5020),
+  //     })
+  //   );
+  // });
 });
diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index 4fc5ea74a5..53378fb9db 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -86,19 +86,6 @@
 (define-data-var configured bool false)
 (define-data-var first-pox-4-reward-cycle uint u0)
 
-;; PoX mainnet constants
-;; Min/max number of reward cycles uSTX can be locked for
-(define-constant MIN_POX_REWARD_CYCLES u1)
-(define-constant MAX_POX_REWARD_CYCLES u12)
-
-;; Default length of the PoX registration window, in burnchain blocks.
-(define-constant PREPARE_CYCLE_LENGTH (if is-in-mainnet u100 u50))
-
-;; Default length of the PoX reward cycle, in burnchain blocks.
-(define-constant REWARD_CYCLE_LENGTH (if is-in-mainnet u2100 u1050))
-
-;; Stacking thresholds
-(define-constant STACKING_THRESHOLD_25 (if is-in-mainnet u20000 u8000))
 
 ;; MOCK
 ;; Allow to set stx-account details for any user

From 8933c5bc381783b472c26cf55bf095a8d0c0d9ba Mon Sep 17 00:00:00 2001
From: MarvinJanssen <MarvinJanssen@users.noreply.github.com>
Date: Sun, 25 Feb 2024 22:56:06 +0100
Subject: [PATCH 0938/1166] Add clarunit and some basic tests

---
 contrib/core-contract-tests/.gitignore        |    3 +-
 contrib/core-contract-tests/Clarinet.toml     |    4 +-
 contrib/core-contract-tests/package-lock.json | 2798 ++++++++++++-----
 contrib/core-contract-tests/package.json      |    5 +-
 .../tests/clarunit.test.ts                    |    2 +-
 .../core-contract-tests/tests/pox_4_test.clar |  123 +
 .../tests/pox_4_tests.clar                    |   59 -
 .../src/chainstate/stacks/boot/pox-4.clar     |   15 -
 8 files changed, 2075 insertions(+), 934 deletions(-)
 create mode 100644 contrib/core-contract-tests/tests/pox_4_test.clar
 delete mode 100644 contrib/core-contract-tests/tests/pox_4_tests.clar

diff --git a/contrib/core-contract-tests/.gitignore b/contrib/core-contract-tests/.gitignore
index 39b70c2f7f..393158bd1c 100644
--- a/contrib/core-contract-tests/.gitignore
+++ b/contrib/core-contract-tests/.gitignore
@@ -4,4 +4,5 @@ npm-debug.log*
 coverage
 *.info
 costs-reports.json
-node_modules
\ No newline at end of file
+node_modules
+history.txt
diff --git a/contrib/core-contract-tests/Clarinet.toml b/contrib/core-contract-tests/Clarinet.toml
index 20d1f9b3ac..605ce3989f 100644
--- a/contrib/core-contract-tests/Clarinet.toml
+++ b/contrib/core-contract-tests/Clarinet.toml
@@ -39,7 +39,7 @@ path = "./tests/bns_test.clar"
 clarity_version = 2
 epoch = 2.4
 
-[contracts.pox_4_tests]
-path = "./tests/pox_4_tests.clar"
+[contracts.pox_4_test]
+path = "./tests/pox_4_test.clar"
 clarity_version = 2
 epoch = 2.4
diff --git a/contrib/core-contract-tests/package-lock.json b/contrib/core-contract-tests/package-lock.json
index b29bb4716d..c7bb20afc1 100644
--- a/contrib/core-contract-tests/package-lock.json
+++ b/contrib/core-contract-tests/package-lock.json
@@ -10,15 +10,23 @@
       "license": "ISC",
       "dependencies": {
         "@hirosystems/clarinet-sdk": "^1.1.0",
+        "@stacks/clarunit": "0.0.1",
         "@stacks/transactions": "^6.9.0",
         "chokidar-cli": "^3.0.0",
-        "clarunit": "github:MarvinJanssen/clarunit#a5c042a",
         "typescript": "^5.2.2",
         "vite": "^4.4.9",
         "vitest": "^0.34.4",
         "vitest-environment-clarinet": "^1.0.0"
       }
     },
+    "node_modules/@aashutoshrathi/word-wrap": {
+      "version": "1.2.6",
+      "resolved": "https://registry.npmjs.org/@aashutoshrathi/word-wrap/-/word-wrap-1.2.6.tgz",
+      "integrity": "sha512-1Yjs2SvM8TflER/OD3cOjhWWOZb58A2t7wpE2S9XfBYTiIl+XFhQG2bjy4Pu1I+EAlCNUzRDYDdFwFYUKvXcIA==",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
     "node_modules/@esbuild/aix-ppc64": {
       "version": "0.19.10",
       "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.19.10.tgz",
@@ -364,6 +372,58 @@
         "node": ">=12"
       }
     },
+    "node_modules/@eslint-community/eslint-utils": {
+      "version": "4.4.0",
+      "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.4.0.tgz",
+      "integrity": "sha512-1/sA4dwrzBAyeUoQ6oxahHKmrZvsnLCg4RfxW3ZFGGmQkSNQPFNLV9CUEFQP1x9EYXHTo5p6xdhZM1Ne9p/AfA==",
+      "dependencies": {
+        "eslint-visitor-keys": "^3.3.0"
+      },
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      },
+      "peerDependencies": {
+        "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0"
+      }
+    },
+    "node_modules/@eslint-community/regexpp": {
+      "version": "4.10.0",
+      "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.10.0.tgz",
+      "integrity": "sha512-Cu96Sd2By9mCNTx2iyKOmq10v22jUVQv0lQnlGNy16oE9589yE+QADPbrMGCkA51cKZSg3Pu/aTJVTGfL/qjUA==",
+      "engines": {
+        "node": "^12.0.0 || ^14.0.0 || >=16.0.0"
+      }
+    },
+    "node_modules/@eslint/eslintrc": {
+      "version": "2.1.4",
+      "resolved": "https://registry.npmjs.org/@eslint/eslintrc/-/eslintrc-2.1.4.tgz",
+      "integrity": "sha512-269Z39MS6wVJtsoUl10L60WdkhJVdPG24Q4eZTH3nnF6lpvSShEK3wQjDX9JRWAUPvPh7COouPpU9IrqaZFvtQ==",
+      "dependencies": {
+        "ajv": "^6.12.4",
+        "debug": "^4.3.2",
+        "espree": "^9.6.0",
+        "globals": "^13.19.0",
+        "ignore": "^5.2.0",
+        "import-fresh": "^3.2.1",
+        "js-yaml": "^4.1.0",
+        "minimatch": "^3.1.2",
+        "strip-json-comments": "^3.1.1"
+      },
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/@eslint/js": {
+      "version": "8.57.0",
+      "resolved": "https://registry.npmjs.org/@eslint/js/-/js-8.57.0.tgz",
+      "integrity": "sha512-Ys+3g2TaW7gADOJzPt83SJtCDhMjndcDMFVQ/Tj9iA1BfJzFKD9mAUXT3OenpuPHbI6P/myECxRJrofUsDx/5g==",
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      }
+    },
     "node_modules/@hirosystems/clarinet-sdk": {
       "version": "1.2.0",
       "resolved": "https://registry.npmjs.org/@hirosystems/clarinet-sdk/-/clarinet-sdk-1.2.0.tgz",
@@ -1023,6 +1083,36 @@
         }
       }
     },
+    "node_modules/@humanwhocodes/config-array": {
+      "version": "0.11.14",
+      "resolved": "https://registry.npmjs.org/@humanwhocodes/config-array/-/config-array-0.11.14.tgz",
+      "integrity": "sha512-3T8LkOmg45BV5FICb15QQMsyUSWrQ8AygVfC7ZG32zOalnqrilm018ZVCw0eapXux8FtA33q8PSRSstjee3jSg==",
+      "dependencies": {
+        "@humanwhocodes/object-schema": "^2.0.2",
+        "debug": "^4.3.1",
+        "minimatch": "^3.0.5"
+      },
+      "engines": {
+        "node": ">=10.10.0"
+      }
+    },
+    "node_modules/@humanwhocodes/module-importer": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@humanwhocodes/module-importer/-/module-importer-1.0.1.tgz",
+      "integrity": "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==",
+      "engines": {
+        "node": ">=12.22"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/nzakas"
+      }
+    },
+    "node_modules/@humanwhocodes/object-schema": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/@humanwhocodes/object-schema/-/object-schema-2.0.2.tgz",
+      "integrity": "sha512-6EwiSjwWYP7pTckG6I5eyFANjPhmPjUX9JRLUSfNPC7FX7zK9gyZAfUEaECL6ALTpGX5AjnBq3C9XmVWPitNpw=="
+    },
     "node_modules/@jest/schemas": {
       "version": "29.6.3",
       "resolved": "https://registry.npmjs.org/@jest/schemas/-/schemas-29.6.3.tgz",
@@ -1061,6 +1151,38 @@
         }
       ]
     },
+    "node_modules/@nodelib/fs.scandir": {
+      "version": "2.1.5",
+      "resolved": "https://registry.npmjs.org/@nodelib/fs.scandir/-/fs.scandir-2.1.5.tgz",
+      "integrity": "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==",
+      "dependencies": {
+        "@nodelib/fs.stat": "2.0.5",
+        "run-parallel": "^1.1.9"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/@nodelib/fs.stat": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/@nodelib/fs.stat/-/fs.stat-2.0.5.tgz",
+      "integrity": "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==",
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/@nodelib/fs.walk": {
+      "version": "1.2.8",
+      "resolved": "https://registry.npmjs.org/@nodelib/fs.walk/-/fs.walk-1.2.8.tgz",
+      "integrity": "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==",
+      "dependencies": {
+        "@nodelib/fs.scandir": "2.1.5",
+        "fastq": "^1.6.0"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
     "node_modules/@rollup/rollup-android-arm-eabi": {
       "version": "4.9.1",
       "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.9.1.tgz",
@@ -1222,787 +1344,545 @@
       "resolved": "https://registry.npmjs.org/@sinclair/typebox/-/typebox-0.27.8.tgz",
       "integrity": "sha512-+Fj43pSMwJs4KRrH/938Uf+uAELIgVBmQzg/q1YG10djyfA3TnrU8N8XzqCh/okZdszqBQTZf96idMfE5lnwTA=="
     },
-    "node_modules/@stacks/common": {
-      "version": "6.10.0",
-      "resolved": "https://registry.npmjs.org/@stacks/common/-/common-6.10.0.tgz",
-      "integrity": "sha512-6x5Z7AKd9/kj3+DYE9xIDIkFLHihBH614i2wqrZIjN02WxVo063hWSjIlUxlx8P4gl6olVzlOy5LzhLJD9OP0A==",
+    "node_modules/@stacks/clarunit": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/@stacks/clarunit/-/clarunit-0.0.1.tgz",
+      "integrity": "sha512-AKf14ycQJjyUWL6yfvXU+yMqvkCfUy2NarHbAmXx6tXfv/fyXueGkjTZTh8+0r20+XoxEvhJTnBfoAA74VLNtg==",
       "dependencies": {
-        "@types/bn.js": "^5.1.0",
-        "@types/node": "^18.0.4"
+        "@hirosystems/clarinet-sdk": "^1.2.0",
+        "@stacks/transactions": "^6.11.0",
+        "chokidar-cli": "^3.0.0",
+        "eslint": "^8.56.0",
+        "path": "^0.12.7",
+        "typescript": "^5.2.2",
+        "vite": "^4.4.9",
+        "vitest": "^1.1.0",
+        "vitest-environment-clarinet": "^1.0.0"
+      },
+      "bin": {
+        "clarunit": "src/cli.ts"
       }
     },
-    "node_modules/@stacks/network": {
-      "version": "6.10.0",
-      "resolved": "https://registry.npmjs.org/@stacks/network/-/network-6.10.0.tgz",
-      "integrity": "sha512-mbiZ8nlsyy77ndmBdaqhHXii22IFdK4ThRcOQs9j/O00DkAr04jCM4GV5Q+VLUnZ9OBoJq7yOV7Pf6jglh+0hw==",
-      "dependencies": {
-        "@stacks/common": "^6.10.0",
-        "cross-fetch": "^3.1.5"
+    "node_modules/@stacks/clarunit/node_modules/@esbuild/aix-ppc64": {
+      "version": "0.19.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.19.12.tgz",
+      "integrity": "sha512-bmoCYyWdEL3wDQIVbcyzRyeKLgk2WtWLTWz1ZIAZF/EGbNOwSA6ew3PftJ1PqMiOOGu0OyFMzG53L0zqIpPeNA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=12"
       }
     },
-    "node_modules/@stacks/transactions": {
-      "version": "6.11.0",
-      "resolved": "https://registry.npmjs.org/@stacks/transactions/-/transactions-6.11.0.tgz",
-      "integrity": "sha512-+zIDqn9j4H/+o1ER8C9rFpig1fyrQcj2hVGNIrp+YbpPyja+cxv3fPk6kI/gePzwggzxRgUkIWhBc+mZAXuXyQ==",
-      "dependencies": {
-        "@noble/hashes": "1.1.5",
-        "@noble/secp256k1": "1.7.1",
-        "@stacks/common": "^6.10.0",
-        "@stacks/network": "^6.10.0",
-        "c32check": "^2.0.0",
-        "lodash.clonedeep": "^4.5.0"
+    "node_modules/@stacks/clarunit/node_modules/@esbuild/android-arm": {
+      "version": "0.19.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.19.12.tgz",
+      "integrity": "sha512-qg/Lj1mu3CdQlDEEiWrlC4eaPZ1KztwGJ9B6J+/6G+/4ewxJg7gqj8eVYWvao1bXrqGiW2rsBZFSX3q2lcW05w==",
+      "cpu": [
+        "arm"
+      ],
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
       }
     },
-    "node_modules/@types/bn.js": {
-      "version": "5.1.5",
-      "resolved": "https://registry.npmjs.org/@types/bn.js/-/bn.js-5.1.5.tgz",
-      "integrity": "sha512-V46N0zwKRF5Q00AZ6hWtN0T8gGmDUaUzLWQvHFo5yThtVwK/VCenFY3wXVbOvNfajEpsTfQM4IN9k/d6gUVX3A==",
-      "dependencies": {
-        "@types/node": "*"
+    "node_modules/@stacks/clarunit/node_modules/@esbuild/android-arm64": {
+      "version": "0.19.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.19.12.tgz",
+      "integrity": "sha512-P0UVNGIienjZv3f5zq0DP3Nt2IE/3plFzuaS96vihvD0Hd6H/q4WXUGpCxD/E8YrSXfNyRPbpTq+T8ZQioSuPA==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
       }
     },
-    "node_modules/@types/chai": {
-      "version": "4.3.9",
-      "resolved": "https://registry.npmjs.org/@types/chai/-/chai-4.3.9.tgz",
-      "integrity": "sha512-69TtiDzu0bcmKQv3yg1Zx409/Kd7r0b5F1PfpYJfSHzLGtB53547V4u+9iqKYsTu/O2ai6KTb0TInNpvuQ3qmg=="
-    },
-    "node_modules/@types/chai-subset": {
-      "version": "1.3.4",
-      "resolved": "https://registry.npmjs.org/@types/chai-subset/-/chai-subset-1.3.4.tgz",
-      "integrity": "sha512-CCWNXrJYSUIojZ1149ksLl3AN9cmZ5djf+yUoVVV+NuYrtydItQVlL2ZDqyC6M6O9LWRnVf8yYDxbXHO2TfQZg==",
-      "dependencies": {
-        "@types/chai": "*"
+    "node_modules/@stacks/clarunit/node_modules/@esbuild/android-x64": {
+      "version": "0.19.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.19.12.tgz",
+      "integrity": "sha512-3k7ZoUW6Q6YqhdhIaq/WZ7HwBpnFBlW905Fa4s4qWJyiNOgT1dOqDiVAQFwBH7gBRZr17gLrlFCRzF6jFh7Kew==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
       }
     },
-    "node_modules/@types/node": {
-      "version": "18.18.8",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-18.18.8.tgz",
-      "integrity": "sha512-OLGBaaK5V3VRBS1bAkMVP2/W9B+H8meUfl866OrMNQqt7wDgdpWPp5o6gmIc9pB+lIQHSq4ZL8ypeH1vPxcPaQ==",
-      "dependencies": {
-        "undici-types": "~5.26.4"
+    "node_modules/@stacks/clarunit/node_modules/@esbuild/darwin-arm64": {
+      "version": "0.19.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.19.12.tgz",
+      "integrity": "sha512-B6IeSgZgtEzGC42jsI+YYu9Z3HKRxp8ZT3cqhvliEHovq8HSX2YX8lNocDn79gCKJXOSaEot9MVYky7AKjCs8g==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=12"
       }
     },
-    "node_modules/@vitest/expect": {
-      "version": "0.34.6",
-      "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-0.34.6.tgz",
-      "integrity": "sha512-QUzKpUQRc1qC7qdGo7rMK3AkETI7w18gTCUrsNnyjjJKYiuUB9+TQK3QnR1unhCnWRC0AbKv2omLGQDF/mIjOw==",
-      "dependencies": {
-        "@vitest/spy": "0.34.6",
-        "@vitest/utils": "0.34.6",
-        "chai": "^4.3.10"
-      },
-      "funding": {
-        "url": "https://opencollective.com/vitest"
+    "node_modules/@stacks/clarunit/node_modules/@esbuild/darwin-x64": {
+      "version": "0.19.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.19.12.tgz",
+      "integrity": "sha512-hKoVkKzFiToTgn+41qGhsUJXFlIjxI/jSYeZf3ugemDYZldIXIxhvwN6erJGlX4t5h417iFuheZ7l+YVn05N3A==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=12"
       }
     },
-    "node_modules/@vitest/runner": {
-      "version": "0.34.6",
-      "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-0.34.6.tgz",
-      "integrity": "sha512-1CUQgtJSLF47NnhN+F9X2ycxUP0kLHQ/JWvNHbeBfwW8CzEGgeskzNnHDyv1ieKTltuR6sdIHV+nmR6kPxQqzQ==",
-      "dependencies": {
-        "@vitest/utils": "0.34.6",
-        "p-limit": "^4.0.0",
-        "pathe": "^1.1.1"
-      },
-      "funding": {
-        "url": "https://opencollective.com/vitest"
+    "node_modules/@stacks/clarunit/node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.19.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.19.12.tgz",
+      "integrity": "sha512-4aRvFIXmwAcDBw9AueDQ2YnGmz5L6obe5kmPT8Vd+/+x/JMVKCgdcRwH6APrbpNXsPz+K653Qg8HB/oXvXVukA==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
       }
     },
-    "node_modules/@vitest/snapshot": {
-      "version": "0.34.6",
-      "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-0.34.6.tgz",
-      "integrity": "sha512-B3OZqYn6k4VaN011D+ve+AA4whM4QkcwcrwaKwAbyyvS/NB1hCWjFIBQxAQQSQir9/RtyAAGuq+4RJmbn2dH4w==",
-      "dependencies": {
-        "magic-string": "^0.30.1",
-        "pathe": "^1.1.1",
-        "pretty-format": "^29.5.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/vitest"
+    "node_modules/@stacks/clarunit/node_modules/@esbuild/freebsd-x64": {
+      "version": "0.19.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.19.12.tgz",
+      "integrity": "sha512-EYoXZ4d8xtBoVN7CEwWY2IN4ho76xjYXqSXMNccFSx2lgqOG/1TBPW0yPx1bJZk94qu3tX0fycJeeQsKovA8gg==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
       }
     },
-    "node_modules/@vitest/spy": {
-      "version": "0.34.6",
-      "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-0.34.6.tgz",
-      "integrity": "sha512-xaCvneSaeBw/cz8ySmF7ZwGvL0lBjfvqc1LpQ/vcdHEvpLn3Ff1vAvjw+CoGn0802l++5L/pxb7whwcWAw+DUQ==",
-      "dependencies": {
-        "tinyspy": "^2.1.1"
-      },
-      "funding": {
-        "url": "https://opencollective.com/vitest"
+    "node_modules/@stacks/clarunit/node_modules/@esbuild/linux-arm": {
+      "version": "0.19.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.19.12.tgz",
+      "integrity": "sha512-J5jPms//KhSNv+LO1S1TX1UWp1ucM6N6XuL6ITdKWElCu8wXP72l9MM0zDTzzeikVyqFE6U8YAV9/tFyj0ti+w==",
+      "cpu": [
+        "arm"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
       }
     },
-    "node_modules/@vitest/utils": {
-      "version": "0.34.6",
-      "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-0.34.6.tgz",
-      "integrity": "sha512-IG5aDD8S6zlvloDsnzHw0Ut5xczlF+kv2BOTo+iXfPr54Yhi5qbVOgGB1hZaVq4iJ4C/MZ2J0y15IlsV/ZcI0A==",
-      "dependencies": {
-        "diff-sequences": "^29.4.3",
-        "loupe": "^2.3.6",
-        "pretty-format": "^29.5.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/vitest"
+    "node_modules/@stacks/clarunit/node_modules/@esbuild/linux-arm64": {
+      "version": "0.19.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.19.12.tgz",
+      "integrity": "sha512-EoTjyYyLuVPfdPLsGVVVC8a0p1BFFvtpQDB/YLEhaXyf/5bczaGeN15QkR+O4S5LeJ92Tqotve7i1jn35qwvdA==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
       }
     },
-    "node_modules/acorn": {
-      "version": "8.11.2",
-      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.11.2.tgz",
-      "integrity": "sha512-nc0Axzp/0FILLEVsm4fNwLCwMttvhEI263QtVPQcbpfZZ3ts0hLsZGOpE6czNlid7CJ9MlyH8reXkpsf3YUY4w==",
-      "bin": {
-        "acorn": "bin/acorn"
-      },
+    "node_modules/@stacks/clarunit/node_modules/@esbuild/linux-ia32": {
+      "version": "0.19.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.19.12.tgz",
+      "integrity": "sha512-Thsa42rrP1+UIGaWz47uydHSBOgTUnwBwNq59khgIwktK6x60Hivfbux9iNR0eHCHzOLjLMLfUMLCypBkZXMHA==",
+      "cpu": [
+        "ia32"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
       "engines": {
-        "node": ">=0.4.0"
+        "node": ">=12"
       }
     },
-    "node_modules/acorn-walk": {
-      "version": "8.3.0",
-      "resolved": "https://registry.npmjs.org/acorn-walk/-/acorn-walk-8.3.0.tgz",
-      "integrity": "sha512-FS7hV565M5l1R08MXqo8odwMTB02C2UqzB17RVgu9EyuYFBqJZ3/ZY97sQD5FewVu1UyDFc1yztUDrAwT0EypA==",
+    "node_modules/@stacks/clarunit/node_modules/@esbuild/linux-loong64": {
+      "version": "0.19.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.19.12.tgz",
+      "integrity": "sha512-LiXdXA0s3IqRRjm6rV6XaWATScKAXjI4R4LoDlvO7+yQqFdlr1Bax62sRwkVvRIrwXxvtYEHHI4dm50jAXkuAA==",
+      "cpu": [
+        "loong64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
       "engines": {
-        "node": ">=0.4.0"
+        "node": ">=12"
       }
     },
-    "node_modules/ansi-regex": {
-      "version": "5.0.1",
-      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
-      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+    "node_modules/@stacks/clarunit/node_modules/@esbuild/linux-mips64el": {
+      "version": "0.19.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.19.12.tgz",
+      "integrity": "sha512-fEnAuj5VGTanfJ07ff0gOA6IPsvrVHLVb6Lyd1g2/ed67oU1eFzL0r9WL7ZzscD+/N6i3dWumGE1Un4f7Amf+w==",
+      "cpu": [
+        "mips64el"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
       "engines": {
-        "node": ">=8"
+        "node": ">=12"
       }
     },
-    "node_modules/ansi-styles": {
-      "version": "5.2.0",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-5.2.0.tgz",
-      "integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==",
+    "node_modules/@stacks/clarunit/node_modules/@esbuild/linux-ppc64": {
+      "version": "0.19.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.19.12.tgz",
+      "integrity": "sha512-nYJA2/QPimDQOh1rKWedNOe3Gfc8PabU7HT3iXWtNUbRzXS9+vgB0Fjaqr//XNbd82mCxHzik2qotuI89cfixg==",
+      "cpu": [
+        "ppc64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
       "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+        "node": ">=12"
       }
     },
-    "node_modules/anymatch": {
-      "version": "3.1.3",
-      "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz",
-      "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==",
-      "dependencies": {
-        "normalize-path": "^3.0.0",
-        "picomatch": "^2.0.4"
-      },
+    "node_modules/@stacks/clarunit/node_modules/@esbuild/linux-riscv64": {
+      "version": "0.19.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.19.12.tgz",
+      "integrity": "sha512-2MueBrlPQCw5dVJJpQdUYgeqIzDQgw3QtiAHUC4RBz9FXPrskyyU3VI1hw7C0BSKB9OduwSJ79FTCqtGMWqJHg==",
+      "cpu": [
+        "riscv64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
       "engines": {
-        "node": ">= 8"
+        "node": ">=12"
       }
     },
-    "node_modules/assertion-error": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-1.1.0.tgz",
-      "integrity": "sha512-jgsaNduz+ndvGyFt3uSuWqvy4lCnIJiovtouQN5JZHOKCS2QuhEdbcQHFhVksz2N2U9hXJo8odG7ETyWlEeuDw==",
+    "node_modules/@stacks/clarunit/node_modules/@esbuild/linux-s390x": {
+      "version": "0.19.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.19.12.tgz",
+      "integrity": "sha512-+Pil1Nv3Umes4m3AZKqA2anfhJiVmNCYkPchwFJNEJN5QxmTs1uzyy4TvmDrCRNT2ApwSari7ZIgrPeUx4UZDg==",
+      "cpu": [
+        "s390x"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
       "engines": {
-        "node": "*"
+        "node": ">=12"
       }
     },
-    "node_modules/base-x": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/base-x/-/base-x-4.0.0.tgz",
-      "integrity": "sha512-FuwxlW4H5kh37X/oW59pwTzzTKRzfrrQwhmyspRM7swOEZcHtDZSCt45U6oKgtuFE+WYPblePMVIPR4RZrh/hw=="
-    },
-    "node_modules/binary-extensions": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.2.0.tgz",
-      "integrity": "sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA==",
+    "node_modules/@stacks/clarunit/node_modules/@esbuild/linux-x64": {
+      "version": "0.19.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.19.12.tgz",
+      "integrity": "sha512-B71g1QpxfwBvNrfyJdVDexenDIt1CiDN1TIXLbhOw0KhJzE78KIFGX6OJ9MrtC0oOqMWf+0xop4qEU8JrJTwCg==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
       "engines": {
-        "node": ">=8"
+        "node": ">=12"
       }
     },
-    "node_modules/braces": {
-      "version": "3.0.2",
-      "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz",
-      "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==",
-      "dependencies": {
-        "fill-range": "^7.0.1"
-      },
+    "node_modules/@stacks/clarunit/node_modules/@esbuild/netbsd-x64": {
+      "version": "0.19.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.19.12.tgz",
+      "integrity": "sha512-3ltjQ7n1owJgFbuC61Oj++XhtzmymoCihNFgT84UAmJnxJfm4sYCiSLTXZtE00VWYpPMYc+ZQmB6xbSdVh0JWA==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
       "engines": {
-        "node": ">=8"
+        "node": ">=12"
       }
     },
-    "node_modules/c32check": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/c32check/-/c32check-2.0.0.tgz",
-      "integrity": "sha512-rpwfAcS/CMqo0oCqDf3r9eeLgScRE3l/xHDCXhM3UyrfvIn7PrLq63uHh7yYbv8NzaZn5MVsVhIRpQ+5GZ5HyA==",
-      "dependencies": {
-        "@noble/hashes": "^1.1.2",
-        "base-x": "^4.0.0"
-      },
+    "node_modules/@stacks/clarunit/node_modules/@esbuild/openbsd-x64": {
+      "version": "0.19.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.19.12.tgz",
+      "integrity": "sha512-RbrfTB9SWsr0kWmb9srfF+L933uMDdu9BIzdA7os2t0TXhCRjrQyCeOt6wVxr79CKD4c+p+YhCj31HBkYcXebw==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
       "engines": {
-        "node": ">=8"
+        "node": ">=12"
       }
     },
-    "node_modules/cac": {
-      "version": "6.7.14",
-      "resolved": "https://registry.npmjs.org/cac/-/cac-6.7.14.tgz",
-      "integrity": "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==",
+    "node_modules/@stacks/clarunit/node_modules/@esbuild/sunos-x64": {
+      "version": "0.19.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.19.12.tgz",
+      "integrity": "sha512-HKjJwRrW8uWtCQnQOz9qcU3mUZhTUQvi56Q8DPTLLB+DawoiQdjsYq+j+D3s9I8VFtDr+F9CjgXKKC4ss89IeA==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
       "engines": {
-        "node": ">=8"
+        "node": ">=12"
       }
     },
-    "node_modules/camelcase": {
-      "version": "5.3.1",
-      "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-5.3.1.tgz",
-      "integrity": "sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==",
+    "node_modules/@stacks/clarunit/node_modules/@esbuild/win32-arm64": {
+      "version": "0.19.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.19.12.tgz",
+      "integrity": "sha512-URgtR1dJnmGvX864pn1B2YUYNzjmXkuJOIqG2HdU62MVS4EHpU2946OZoTMnRUHklGtJdJZ33QfzdjGACXhn1A==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "win32"
+      ],
       "engines": {
-        "node": ">=6"
+        "node": ">=12"
       }
     },
-    "node_modules/chai": {
-      "version": "4.3.10",
-      "resolved": "https://registry.npmjs.org/chai/-/chai-4.3.10.tgz",
-      "integrity": "sha512-0UXG04VuVbruMUYbJ6JctvH0YnC/4q3/AkT18q4NaITo91CUm0liMS9VqzT9vZhVQ/1eqPanMWjBM+Juhfb/9g==",
-      "dependencies": {
-        "assertion-error": "^1.1.0",
-        "check-error": "^1.0.3",
-        "deep-eql": "^4.1.3",
-        "get-func-name": "^2.0.2",
-        "loupe": "^2.3.6",
-        "pathval": "^1.1.1",
-        "type-detect": "^4.0.8"
-      },
+    "node_modules/@stacks/clarunit/node_modules/@esbuild/win32-ia32": {
+      "version": "0.19.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.19.12.tgz",
+      "integrity": "sha512-+ZOE6pUkMOJfmxmBZElNOx72NKpIa/HFOMGzu8fqzQJ5kgf6aTGrcJaFsNiVMH4JKpMipyK+7k0n2UXN7a8YKQ==",
+      "cpu": [
+        "ia32"
+      ],
+      "optional": true,
+      "os": [
+        "win32"
+      ],
       "engines": {
-        "node": ">=4"
+        "node": ">=12"
       }
     },
-    "node_modules/check-error": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/check-error/-/check-error-1.0.3.tgz",
-      "integrity": "sha512-iKEoDYaRmd1mxM90a2OEfWhjsjPpYPuQ+lMYsoxB126+t8fw7ySEO48nmDg5COTjxDI65/Y2OWpeEHk3ZOe8zg==",
-      "dependencies": {
-        "get-func-name": "^2.0.2"
-      },
+    "node_modules/@stacks/clarunit/node_modules/@esbuild/win32-x64": {
+      "version": "0.19.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.19.12.tgz",
+      "integrity": "sha512-T1QyPSDCyMXaO3pzBkF96E8xMkiRYbUEZADd29SyPGabqxMViNoii+NcK7eWJAEoU6RZyEm5lVSIjTmcdoB9HA==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "win32"
+      ],
       "engines": {
-        "node": "*"
+        "node": ">=12"
       }
     },
-    "node_modules/chokidar": {
-      "version": "3.5.3",
-      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.5.3.tgz",
-      "integrity": "sha512-Dr3sfKRP6oTcjf2JmUmFJfeVMvXBdegxB0iVQ5eb2V10uFJUCAS8OByZdVAyVb8xXNz3GjjTgj9kLWsZTqE6kw==",
-      "funding": [
-        {
-          "type": "individual",
-          "url": "https://paulmillr.com/funding/"
-        }
+    "node_modules/@stacks/clarunit/node_modules/@rollup/rollup-android-arm-eabi": {
+      "version": "4.12.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.12.0.tgz",
+      "integrity": "sha512-+ac02NL/2TCKRrJu2wffk1kZ+RyqxVUlbjSagNgPm94frxtr+XDL12E5Ll1enWskLrtrZ2r8L3wED1orIibV/w==",
+      "cpu": [
+        "arm"
       ],
-      "dependencies": {
-        "anymatch": "~3.1.2",
-        "braces": "~3.0.2",
-        "glob-parent": "~5.1.2",
-        "is-binary-path": "~2.1.0",
-        "is-glob": "~4.0.1",
-        "normalize-path": "~3.0.0",
-        "readdirp": "~3.6.0"
-      },
-      "engines": {
-        "node": ">= 8.10.0"
-      },
-      "optionalDependencies": {
-        "fsevents": "~2.3.2"
-      }
+      "optional": true,
+      "os": [
+        "android"
+      ]
     },
-    "node_modules/chokidar-cli": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/chokidar-cli/-/chokidar-cli-3.0.0.tgz",
-      "integrity": "sha512-xVW+Qeh7z15uZRxHOkP93Ux8A0xbPzwK4GaqD8dQOYc34TlkqUhVSS59fK36DOp5WdJlrRzlYSy02Ht99FjZqQ==",
-      "dependencies": {
-        "chokidar": "^3.5.2",
-        "lodash.debounce": "^4.0.8",
-        "lodash.throttle": "^4.1.1",
-        "yargs": "^13.3.0"
-      },
-      "bin": {
-        "chokidar": "index.js"
-      },
-      "engines": {
-        "node": ">= 8.10.0"
-      }
+    "node_modules/@stacks/clarunit/node_modules/@rollup/rollup-android-arm64": {
+      "version": "4.12.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.12.0.tgz",
+      "integrity": "sha512-OBqcX2BMe6nvjQ0Nyp7cC90cnumt8PXmO7Dp3gfAju/6YwG0Tj74z1vKrfRz7qAv23nBcYM8BCbhrsWqO7PzQQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "android"
+      ]
     },
-    "node_modules/chokidar-cli/node_modules/ansi-regex": {
-      "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-4.1.1.tgz",
-      "integrity": "sha512-ILlv4k/3f6vfQ4OoP2AGvirOktlQ98ZEL1k9FaQjxa3L1abBgbuTDAdPOpvbGncC0BTVQrl+OM8xZGK6tWXt7g==",
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/chokidar-cli/node_modules/ansi-styles": {
-      "version": "3.2.1",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz",
-      "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==",
-      "dependencies": {
-        "color-convert": "^1.9.0"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/chokidar-cli/node_modules/cliui": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/cliui/-/cliui-5.0.0.tgz",
-      "integrity": "sha512-PYeGSEmmHM6zvoef2w8TPzlrnNpXIjTipYK780YswmIP9vjxmd6Y2a3CB2Ks6/AU8NHjZugXvo8w3oWM2qnwXA==",
-      "dependencies": {
-        "string-width": "^3.1.0",
-        "strip-ansi": "^5.2.0",
-        "wrap-ansi": "^5.1.0"
-      }
-    },
-    "node_modules/chokidar-cli/node_modules/emoji-regex": {
-      "version": "7.0.3",
-      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-7.0.3.tgz",
-      "integrity": "sha512-CwBLREIQ7LvYFB0WyRvwhq5N5qPhc6PMjD6bYggFlI5YyDgl+0vxq5VHbMOFqLg7hfWzmu8T5Z1QofhmTIhItA=="
-    },
-    "node_modules/chokidar-cli/node_modules/is-fullwidth-code-point": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz",
-      "integrity": "sha512-VHskAKYM8RfSFXwee5t5cbN5PZeq1Wrh6qd5bkyiXIf6UQcN6w/A0eXM9r6t8d+GYOh+o6ZhiEnb88LN/Y8m2w==",
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/chokidar-cli/node_modules/string-width": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-3.1.0.tgz",
-      "integrity": "sha512-vafcv6KjVZKSgz06oM/H6GDBrAtz8vdhQakGjFIvNrHA6y3HCF1CInLy+QLq8dTJPQ1b+KDUqDFctkdRW44e1w==",
-      "dependencies": {
-        "emoji-regex": "^7.0.1",
-        "is-fullwidth-code-point": "^2.0.0",
-        "strip-ansi": "^5.1.0"
-      },
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/chokidar-cli/node_modules/strip-ansi": {
-      "version": "5.2.0",
-      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-5.2.0.tgz",
-      "integrity": "sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==",
-      "dependencies": {
-        "ansi-regex": "^4.1.0"
-      },
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/chokidar-cli/node_modules/wrap-ansi": {
-      "version": "5.1.0",
-      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-5.1.0.tgz",
-      "integrity": "sha512-QC1/iN/2/RPVJ5jYK8BGttj5z83LmSKmvbvrXPNCLZSEb32KKVDJDl/MOt2N01qU2H/FkzEa9PKto1BqDjtd7Q==",
-      "dependencies": {
-        "ansi-styles": "^3.2.0",
-        "string-width": "^3.0.0",
-        "strip-ansi": "^5.0.0"
-      },
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/chokidar-cli/node_modules/y18n": {
-      "version": "4.0.3",
-      "resolved": "https://registry.npmjs.org/y18n/-/y18n-4.0.3.tgz",
-      "integrity": "sha512-JKhqTOwSrqNA1NY5lSztJ1GrBiUodLMmIZuLiDaMRJ+itFd+ABVE8XBjOvIWL+rSqNDC74LCSFmlb/U4UZ4hJQ=="
-    },
-    "node_modules/chokidar-cli/node_modules/yargs": {
-      "version": "13.3.2",
-      "resolved": "https://registry.npmjs.org/yargs/-/yargs-13.3.2.tgz",
-      "integrity": "sha512-AX3Zw5iPruN5ie6xGRIDgqkT+ZhnRlZMLMHAs8tg7nRruy2Nb+i5o9bwghAogtM08q1dpr2LVoS8KSTMYpWXUw==",
-      "dependencies": {
-        "cliui": "^5.0.0",
-        "find-up": "^3.0.0",
-        "get-caller-file": "^2.0.1",
-        "require-directory": "^2.1.1",
-        "require-main-filename": "^2.0.0",
-        "set-blocking": "^2.0.0",
-        "string-width": "^3.0.0",
-        "which-module": "^2.0.0",
-        "y18n": "^4.0.0",
-        "yargs-parser": "^13.1.2"
-      }
-    },
-    "node_modules/chokidar-cli/node_modules/yargs-parser": {
-      "version": "13.1.2",
-      "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-13.1.2.tgz",
-      "integrity": "sha512-3lbsNRf/j+A4QuSZfDRA7HRSfWrzO0YjqTJd5kjAq37Zep1CEgaYmrH9Q3GwPiB9cHyd1Y1UwggGhJGoxipbzg==",
-      "dependencies": {
-        "camelcase": "^5.0.0",
-        "decamelize": "^1.2.0"
-      }
-    },
-    "node_modules/clarunit": {
-      "version": "0.0.1",
-      "resolved": "git+ssh://git@github.com/MarvinJanssen/clarunit.git#a5c042ab8428d989c8f7653e83073b3e8c88e076",
-      "license": "MIT",
-      "dependencies": {
-        "@hirosystems/clarinet-sdk": "^1.2.0",
-        "@stacks/transactions": "^6.11.0",
-        "chokidar-cli": "^3.0.0",
-        "path": "^0.12.7",
-        "typescript": "^5.2.2",
-        "vite": "^4.4.9",
-        "vitest": "^1.1.0",
-        "vitest-environment-clarinet": "^1.0.0"
-      },
-      "bin": {
-        "clarunit": "src/cli.ts"
-      }
-    },
-    "node_modules/clarunit/node_modules/@esbuild/android-arm": {
-      "version": "0.19.10",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.19.10.tgz",
-      "integrity": "sha512-7W0bK7qfkw1fc2viBfrtAEkDKHatYfHzr/jKAHNr9BvkYDXPcC6bodtm8AyLJNNuqClLNaeTLuwURt4PRT9d7w==",
+    "node_modules/@stacks/clarunit/node_modules/@rollup/rollup-darwin-arm64": {
+      "version": "4.12.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.12.0.tgz",
+      "integrity": "sha512-X64tZd8dRE/QTrBIEs63kaOBG0b5GVEd3ccoLtyf6IdXtHdh8h+I56C2yC3PtC9Ucnv0CpNFJLqKFVgCYe0lOQ==",
       "cpu": [
-        "arm"
+        "arm64"
       ],
       "optional": true,
       "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
+        "darwin"
+      ]
     },
-    "node_modules/clarunit/node_modules/@esbuild/android-arm64": {
-      "version": "0.19.10",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.19.10.tgz",
-      "integrity": "sha512-1X4CClKhDgC3by7k8aOWZeBXQX8dHT5QAMCAQDArCLaYfkppoARvh0fit3X2Qs+MXDngKcHv6XXyQCpY0hkK1Q==",
+    "node_modules/@stacks/clarunit/node_modules/@rollup/rollup-darwin-x64": {
+      "version": "4.12.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.12.0.tgz",
+      "integrity": "sha512-cc71KUZoVbUJmGP2cOuiZ9HSOP14AzBAThn3OU+9LcA1+IUqswJyR1cAJj3Mg55HbjZP6OLAIscbQsQLrpgTOg==",
       "cpu": [
-        "arm64"
+        "x64"
       ],
       "optional": true,
       "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
+        "darwin"
+      ]
     },
-    "node_modules/clarunit/node_modules/@esbuild/android-x64": {
-      "version": "0.19.10",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.19.10.tgz",
-      "integrity": "sha512-O/nO/g+/7NlitUxETkUv/IvADKuZXyH4BHf/g/7laqKC4i/7whLpB0gvpPc2zpF0q9Q6FXS3TS75QHac9MvVWw==",
+    "node_modules/@stacks/clarunit/node_modules/@rollup/rollup-linux-arm-gnueabihf": {
+      "version": "4.12.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.12.0.tgz",
+      "integrity": "sha512-a6w/Y3hyyO6GlpKL2xJ4IOh/7d+APaqLYdMf86xnczU3nurFTaVN9s9jOXQg97BE4nYm/7Ga51rjec5nfRdrvA==",
       "cpu": [
-        "x64"
+        "arm"
       ],
       "optional": true,
       "os": [
-        "android"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
+        "linux"
+      ]
     },
-    "node_modules/clarunit/node_modules/@esbuild/darwin-arm64": {
-      "version": "0.19.10",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.19.10.tgz",
-      "integrity": "sha512-YSRRs2zOpwypck+6GL3wGXx2gNP7DXzetmo5pHXLrY/VIMsS59yKfjPizQ4lLt5vEI80M41gjm2BxrGZ5U+VMA==",
+    "node_modules/@stacks/clarunit/node_modules/@rollup/rollup-linux-arm64-gnu": {
+      "version": "4.12.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.12.0.tgz",
+      "integrity": "sha512-0fZBq27b+D7Ar5CQMofVN8sggOVhEtzFUwOwPppQt0k+VR+7UHMZZY4y+64WJ06XOhBTKXtQB/Sv0NwQMXyNAA==",
       "cpu": [
         "arm64"
       ],
       "optional": true,
       "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
+        "linux"
+      ]
     },
-    "node_modules/clarunit/node_modules/@esbuild/darwin-x64": {
-      "version": "0.19.10",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.19.10.tgz",
-      "integrity": "sha512-alfGtT+IEICKtNE54hbvPg13xGBe4GkVxyGWtzr+yHO7HIiRJppPDhOKq3zstTcVf8msXb/t4eavW3jCDpMSmA==",
+    "node_modules/@stacks/clarunit/node_modules/@rollup/rollup-linux-arm64-musl": {
+      "version": "4.12.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.12.0.tgz",
+      "integrity": "sha512-eTvzUS3hhhlgeAv6bfigekzWZjaEX9xP9HhxB0Dvrdbkk5w/b+1Sxct2ZuDxNJKzsRStSq1EaEkVSEe7A7ipgQ==",
       "cpu": [
-        "x64"
+        "arm64"
       ],
       "optional": true,
       "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
+        "linux"
+      ]
     },
-    "node_modules/clarunit/node_modules/@esbuild/freebsd-arm64": {
-      "version": "0.19.10",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.19.10.tgz",
-      "integrity": "sha512-dMtk1wc7FSH8CCkE854GyGuNKCewlh+7heYP/sclpOG6Cectzk14qdUIY5CrKDbkA/OczXq9WesqnPl09mj5dg==",
+    "node_modules/@stacks/clarunit/node_modules/@rollup/rollup-linux-riscv64-gnu": {
+      "version": "4.12.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.12.0.tgz",
+      "integrity": "sha512-ix+qAB9qmrCRiaO71VFfY8rkiAZJL8zQRXveS27HS+pKdjwUfEhqo2+YF2oI+H/22Xsiski+qqwIBxVewLK7sw==",
       "cpu": [
-        "arm64"
+        "riscv64"
       ],
       "optional": true,
       "os": [
-        "freebsd"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
+        "linux"
+      ]
     },
-    "node_modules/clarunit/node_modules/@esbuild/freebsd-x64": {
-      "version": "0.19.10",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.19.10.tgz",
-      "integrity": "sha512-G5UPPspryHu1T3uX8WiOEUa6q6OlQh6gNl4CO4Iw5PS+Kg5bVggVFehzXBJY6X6RSOMS8iXDv2330VzaObm4Ag==",
+    "node_modules/@stacks/clarunit/node_modules/@rollup/rollup-linux-x64-gnu": {
+      "version": "4.12.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.12.0.tgz",
+      "integrity": "sha512-TenQhZVOtw/3qKOPa7d+QgkeM6xY0LtwzR8OplmyL5LrgTWIXpTQg2Q2ycBf8jm+SFW2Wt/DTn1gf7nFp3ssVA==",
       "cpu": [
         "x64"
       ],
       "optional": true,
       "os": [
-        "freebsd"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
+        "linux"
+      ]
     },
-    "node_modules/clarunit/node_modules/@esbuild/linux-arm": {
-      "version": "0.19.10",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.19.10.tgz",
-      "integrity": "sha512-j6gUW5aAaPgD416Hk9FHxn27On28H4eVI9rJ4az7oCGTFW48+LcgNDBN+9f8rKZz7EEowo889CPKyeaD0iw9Kg==",
+    "node_modules/@stacks/clarunit/node_modules/@rollup/rollup-linux-x64-musl": {
+      "version": "4.12.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.12.0.tgz",
+      "integrity": "sha512-LfFdRhNnW0zdMvdCb5FNuWlls2WbbSridJvxOvYWgSBOYZtgBfW9UGNJG//rwMqTX1xQE9BAodvMH9tAusKDUw==",
       "cpu": [
-        "arm"
+        "x64"
       ],
       "optional": true,
       "os": [
         "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
+      ]
     },
-    "node_modules/clarunit/node_modules/@esbuild/linux-arm64": {
-      "version": "0.19.10",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.19.10.tgz",
-      "integrity": "sha512-QxaouHWZ+2KWEj7cGJmvTIHVALfhpGxo3WLmlYfJ+dA5fJB6lDEIg+oe/0//FuyVHuS3l79/wyBxbHr0NgtxJQ==",
+    "node_modules/@stacks/clarunit/node_modules/@rollup/rollup-win32-arm64-msvc": {
+      "version": "4.12.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.12.0.tgz",
+      "integrity": "sha512-JPDxovheWNp6d7AHCgsUlkuCKvtu3RB55iNEkaQcf0ttsDU/JZF+iQnYcQJSk/7PtT4mjjVG8N1kpwnI9SLYaw==",
       "cpu": [
         "arm64"
       ],
       "optional": true,
       "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
+        "win32"
+      ]
     },
-    "node_modules/clarunit/node_modules/@esbuild/linux-ia32": {
-      "version": "0.19.10",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.19.10.tgz",
-      "integrity": "sha512-4ub1YwXxYjj9h1UIZs2hYbnTZBtenPw5NfXCRgEkGb0b6OJ2gpkMvDqRDYIDRjRdWSe/TBiZltm3Y3Q8SN1xNg==",
+    "node_modules/@stacks/clarunit/node_modules/@rollup/rollup-win32-ia32-msvc": {
+      "version": "4.12.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.12.0.tgz",
+      "integrity": "sha512-fjtuvMWRGJn1oZacG8IPnzIV6GF2/XG+h71FKn76OYFqySXInJtseAqdprVTDTyqPxQOG9Exak5/E9Z3+EJ8ZA==",
       "cpu": [
         "ia32"
       ],
       "optional": true,
       "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
+        "win32"
+      ]
     },
-    "node_modules/clarunit/node_modules/@esbuild/linux-loong64": {
-      "version": "0.19.10",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.19.10.tgz",
-      "integrity": "sha512-lo3I9k+mbEKoxtoIbM0yC/MZ1i2wM0cIeOejlVdZ3D86LAcFXFRdeuZmh91QJvUTW51bOK5W2BznGNIl4+mDaA==",
+    "node_modules/@stacks/clarunit/node_modules/@rollup/rollup-win32-x64-msvc": {
+      "version": "4.12.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.12.0.tgz",
+      "integrity": "sha512-ZYmr5mS2wd4Dew/JjT0Fqi2NPB/ZhZ2VvPp7SmvPZb4Y1CG/LRcS6tcRo2cYU7zLK5A7cdbhWnnWmUjoI4qapg==",
       "cpu": [
-        "loong64"
+        "x64"
       ],
       "optional": true,
       "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
+        "win32"
+      ]
+    },
+    "node_modules/@stacks/clarunit/node_modules/@vitest/expect": {
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-1.3.1.tgz",
+      "integrity": "sha512-xofQFwIzfdmLLlHa6ag0dPV8YsnKOCP1KdAeVVh34vSjN2dcUiXYCD9htu/9eM7t8Xln4v03U9HLxLpPlsXdZw==",
+      "dependencies": {
+        "@vitest/spy": "1.3.1",
+        "@vitest/utils": "1.3.1",
+        "chai": "^4.3.10"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
       }
     },
-    "node_modules/clarunit/node_modules/@esbuild/linux-mips64el": {
-      "version": "0.19.10",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.19.10.tgz",
-      "integrity": "sha512-J4gH3zhHNbdZN0Bcr1QUGVNkHTdpijgx5VMxeetSk6ntdt+vR1DqGmHxQYHRmNb77tP6GVvD+K0NyO4xjd7y4A==",
-      "cpu": [
-        "mips64el"
-      ],
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/clarunit/node_modules/@esbuild/linux-ppc64": {
-      "version": "0.19.10",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.19.10.tgz",
-      "integrity": "sha512-tgT/7u+QhV6ge8wFMzaklOY7KqiyitgT1AUHMApau32ZlvTB/+efeCtMk4eXS+uEymYK249JsoiklZN64xt6oQ==",
-      "cpu": [
-        "ppc64"
-      ],
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/clarunit/node_modules/@esbuild/linux-riscv64": {
-      "version": "0.19.10",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.19.10.tgz",
-      "integrity": "sha512-0f/spw0PfBMZBNqtKe5FLzBDGo0SKZKvMl5PHYQr3+eiSscfJ96XEknCe+JoOayybWUFQbcJTrk946i3j9uYZA==",
-      "cpu": [
-        "riscv64"
-      ],
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/clarunit/node_modules/@esbuild/linux-s390x": {
-      "version": "0.19.10",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.19.10.tgz",
-      "integrity": "sha512-pZFe0OeskMHzHa9U38g+z8Yx5FNCLFtUnJtQMpwhS+r4S566aK2ci3t4NCP4tjt6d5j5uo4h7tExZMjeKoehAA==",
-      "cpu": [
-        "s390x"
-      ],
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/clarunit/node_modules/@esbuild/linux-x64": {
-      "version": "0.19.10",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.19.10.tgz",
-      "integrity": "sha512-SpYNEqg/6pZYoc+1zLCjVOYvxfZVZj6w0KROZ3Fje/QrM3nfvT2llI+wmKSrWuX6wmZeTapbarvuNNK/qepSgA==",
-      "cpu": [
-        "x64"
-      ],
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/clarunit/node_modules/@esbuild/netbsd-x64": {
-      "version": "0.19.10",
-      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.19.10.tgz",
-      "integrity": "sha512-ACbZ0vXy9zksNArWlk2c38NdKg25+L9pr/mVaj9SUq6lHZu/35nx2xnQVRGLrC1KKQqJKRIB0q8GspiHI3J80Q==",
-      "cpu": [
-        "x64"
-      ],
-      "optional": true,
-      "os": [
-        "netbsd"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/clarunit/node_modules/@esbuild/openbsd-x64": {
-      "version": "0.19.10",
-      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.19.10.tgz",
-      "integrity": "sha512-PxcgvjdSjtgPMiPQrM3pwSaG4kGphP+bLSb+cihuP0LYdZv1epbAIecHVl5sD3npkfYBZ0ZnOjR878I7MdJDFg==",
-      "cpu": [
-        "x64"
-      ],
-      "optional": true,
-      "os": [
-        "openbsd"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/clarunit/node_modules/@esbuild/sunos-x64": {
-      "version": "0.19.10",
-      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.19.10.tgz",
-      "integrity": "sha512-ZkIOtrRL8SEJjr+VHjmW0znkPs+oJXhlJbNwfI37rvgeMtk3sxOQevXPXjmAPZPigVTncvFqLMd+uV0IBSEzqA==",
-      "cpu": [
-        "x64"
-      ],
-      "optional": true,
-      "os": [
-        "sunos"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/clarunit/node_modules/@esbuild/win32-arm64": {
-      "version": "0.19.10",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.19.10.tgz",
-      "integrity": "sha512-+Sa4oTDbpBfGpl3Hn3XiUe4f8TU2JF7aX8cOfqFYMMjXp6ma6NJDztl5FDG8Ezx0OjwGikIHw+iA54YLDNNVfw==",
-      "cpu": [
-        "arm64"
-      ],
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/clarunit/node_modules/@esbuild/win32-ia32": {
-      "version": "0.19.10",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.19.10.tgz",
-      "integrity": "sha512-EOGVLK1oWMBXgfttJdPHDTiivYSjX6jDNaATeNOaCOFEVcfMjtbx7WVQwPSE1eIfCp/CaSF2nSrDtzc4I9f8TQ==",
-      "cpu": [
-        "ia32"
-      ],
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/clarunit/node_modules/@esbuild/win32-x64": {
-      "version": "0.19.10",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.19.10.tgz",
-      "integrity": "sha512-whqLG6Sc70AbU73fFYvuYzaE4MNMBIlR1Y/IrUeOXFrWHxBEjjbZaQ3IXIQS8wJdAzue2GwYZCjOrgrU1oUHoA==",
-      "cpu": [
-        "x64"
-      ],
-      "optional": true,
-      "os": [
-        "win32"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/clarunit/node_modules/@vitest/expect": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-1.1.0.tgz",
-      "integrity": "sha512-9IE2WWkcJo2BR9eqtY5MIo3TPmS50Pnwpm66A6neb2hvk/QSLfPXBz2qdiwUOQkwyFuuXEUj5380CbwfzW4+/w==",
-      "dependencies": {
-        "@vitest/spy": "1.1.0",
-        "@vitest/utils": "1.1.0",
-        "chai": "^4.3.10"
-      },
-      "funding": {
-        "url": "https://opencollective.com/vitest"
-      }
-    },
-    "node_modules/clarunit/node_modules/@vitest/runner": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-1.1.0.tgz",
-      "integrity": "sha512-zdNLJ00pm5z/uhbWF6aeIJCGMSyTyWImy3Fcp9piRGvueERFlQFbUwCpzVce79OLm2UHk9iwaMSOaU9jVHgNVw==",
+    "node_modules/@stacks/clarunit/node_modules/@vitest/runner": {
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-1.3.1.tgz",
+      "integrity": "sha512-5FzF9c3jG/z5bgCnjr8j9LNq/9OxV2uEBAITOXfoe3rdZJTdO7jzThth7FXv/6b+kdY65tpRQB7WaKhNZwX+Kg==",
       "dependencies": {
-        "@vitest/utils": "1.1.0",
+        "@vitest/utils": "1.3.1",
         "p-limit": "^5.0.0",
         "pathe": "^1.1.1"
       },
@@ -2010,10 +1890,10 @@
         "url": "https://opencollective.com/vitest"
       }
     },
-    "node_modules/clarunit/node_modules/@vitest/snapshot": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-1.1.0.tgz",
-      "integrity": "sha512-5O/wyZg09V5qmNmAlUgCBqflvn2ylgsWJRRuPrnHEfDNT6tQpQ8O1isNGgo+VxofISHqz961SG3iVvt3SPK/QQ==",
+    "node_modules/@stacks/clarunit/node_modules/@vitest/snapshot": {
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-1.3.1.tgz",
+      "integrity": "sha512-EF++BZbt6RZmOlE3SuTPu/NfwBF6q4ABS37HHXzs2LUVPBLx2QoY/K0fKpRChSo8eLiuxcbCVfqKgx/dplCDuQ==",
       "dependencies": {
         "magic-string": "^0.30.5",
         "pathe": "^1.1.1",
@@ -2023,10 +1903,10 @@
         "url": "https://opencollective.com/vitest"
       }
     },
-    "node_modules/clarunit/node_modules/@vitest/spy": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-1.1.0.tgz",
-      "integrity": "sha512-sNOVSU/GE+7+P76qYo+VXdXhXffzWZcYIPQfmkiRxaNCSPiLANvQx5Mx6ZURJ/ndtEkUJEpvKLXqAYTKEY+lTg==",
+    "node_modules/@stacks/clarunit/node_modules/@vitest/spy": {
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-1.3.1.tgz",
+      "integrity": "sha512-xAcW+S099ylC9VLU7eZfdT9myV67Nor9w9zhf0mGCYJSO+zM2839tOeROTdikOi/8Qeusffvxb/MyBSOja1Uig==",
       "dependencies": {
         "tinyspy": "^2.2.0"
       },
@@ -2034,12 +1914,13 @@
         "url": "https://opencollective.com/vitest"
       }
     },
-    "node_modules/clarunit/node_modules/@vitest/utils": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-1.1.0.tgz",
-      "integrity": "sha512-z+s510fKmYz4Y41XhNs3vcuFTFhcij2YF7F8VQfMEYAAUfqQh0Zfg7+w9xdgFGhPf3tX3TicAe+8BDITk6ampQ==",
+    "node_modules/@stacks/clarunit/node_modules/@vitest/utils": {
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-1.3.1.tgz",
+      "integrity": "sha512-d3Waie/299qqRyHTm2DjADeTaNdNSVsnwHPWrs20JMpjh6eiVq7ggggweO8rc4arhf6rRkWuHKwvxGvejUXZZQ==",
       "dependencies": {
         "diff-sequences": "^29.6.3",
+        "estree-walker": "^3.0.3",
         "loupe": "^2.3.7",
         "pretty-format": "^29.7.0"
       },
@@ -2047,10 +1928,10 @@
         "url": "https://opencollective.com/vitest"
       }
     },
-    "node_modules/clarunit/node_modules/esbuild": {
-      "version": "0.19.10",
-      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.19.10.tgz",
-      "integrity": "sha512-S1Y27QGt/snkNYrRcswgRFqZjaTG5a5xM3EQo97uNBnH505pdzSNe/HLBq1v0RO7iK/ngdbhJB6mDAp0OK+iUA==",
+    "node_modules/@stacks/clarunit/node_modules/esbuild": {
+      "version": "0.19.12",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.19.12.tgz",
+      "integrity": "sha512-aARqgq8roFBj054KvQr5f1sFu0D65G+miZRCuJyJ0G13Zwx7vRar5Zhn2tkQNzIXcBrNVsv/8stehpj+GAjgbg==",
       "hasInstallScript": true,
       "bin": {
         "esbuild": "bin/esbuild"
@@ -2059,32 +1940,32 @@
         "node": ">=12"
       },
       "optionalDependencies": {
-        "@esbuild/aix-ppc64": "0.19.10",
-        "@esbuild/android-arm": "0.19.10",
-        "@esbuild/android-arm64": "0.19.10",
-        "@esbuild/android-x64": "0.19.10",
-        "@esbuild/darwin-arm64": "0.19.10",
-        "@esbuild/darwin-x64": "0.19.10",
-        "@esbuild/freebsd-arm64": "0.19.10",
-        "@esbuild/freebsd-x64": "0.19.10",
-        "@esbuild/linux-arm": "0.19.10",
-        "@esbuild/linux-arm64": "0.19.10",
-        "@esbuild/linux-ia32": "0.19.10",
-        "@esbuild/linux-loong64": "0.19.10",
-        "@esbuild/linux-mips64el": "0.19.10",
-        "@esbuild/linux-ppc64": "0.19.10",
-        "@esbuild/linux-riscv64": "0.19.10",
-        "@esbuild/linux-s390x": "0.19.10",
-        "@esbuild/linux-x64": "0.19.10",
-        "@esbuild/netbsd-x64": "0.19.10",
-        "@esbuild/openbsd-x64": "0.19.10",
-        "@esbuild/sunos-x64": "0.19.10",
-        "@esbuild/win32-arm64": "0.19.10",
-        "@esbuild/win32-ia32": "0.19.10",
-        "@esbuild/win32-x64": "0.19.10"
-      }
-    },
-    "node_modules/clarunit/node_modules/local-pkg": {
+        "@esbuild/aix-ppc64": "0.19.12",
+        "@esbuild/android-arm": "0.19.12",
+        "@esbuild/android-arm64": "0.19.12",
+        "@esbuild/android-x64": "0.19.12",
+        "@esbuild/darwin-arm64": "0.19.12",
+        "@esbuild/darwin-x64": "0.19.12",
+        "@esbuild/freebsd-arm64": "0.19.12",
+        "@esbuild/freebsd-x64": "0.19.12",
+        "@esbuild/linux-arm": "0.19.12",
+        "@esbuild/linux-arm64": "0.19.12",
+        "@esbuild/linux-ia32": "0.19.12",
+        "@esbuild/linux-loong64": "0.19.12",
+        "@esbuild/linux-mips64el": "0.19.12",
+        "@esbuild/linux-ppc64": "0.19.12",
+        "@esbuild/linux-riscv64": "0.19.12",
+        "@esbuild/linux-s390x": "0.19.12",
+        "@esbuild/linux-x64": "0.19.12",
+        "@esbuild/netbsd-x64": "0.19.12",
+        "@esbuild/openbsd-x64": "0.19.12",
+        "@esbuild/sunos-x64": "0.19.12",
+        "@esbuild/win32-arm64": "0.19.12",
+        "@esbuild/win32-ia32": "0.19.12",
+        "@esbuild/win32-x64": "0.19.12"
+      }
+    },
+    "node_modules/@stacks/clarunit/node_modules/local-pkg": {
       "version": "0.5.0",
       "resolved": "https://registry.npmjs.org/local-pkg/-/local-pkg-0.5.0.tgz",
       "integrity": "sha512-ok6z3qlYyCDS4ZEU27HaU6x/xZa9Whf8jD4ptH5UZTQYZVYeb9bnZ3ojVhiJNLiXK1Hfc0GNbLXcmZ5plLDDBg==",
@@ -2099,7 +1980,7 @@
         "url": "https://github.com/sponsors/antfu"
       }
     },
-    "node_modules/clarunit/node_modules/p-limit": {
+    "node_modules/@stacks/clarunit/node_modules/p-limit": {
       "version": "5.0.0",
       "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-5.0.0.tgz",
       "integrity": "sha512-/Eaoq+QyLSiXQ4lyYV23f14mZRQcXnxfHrN0vCai+ak9G0pp9iEQukIIZq5NccEvwRB8PUnZT0KsOoDCINS1qQ==",
@@ -2113,10 +1994,13 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/clarunit/node_modules/rollup": {
-      "version": "4.9.1",
-      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.9.1.tgz",
-      "integrity": "sha512-pgPO9DWzLoW/vIhlSoDByCzcpX92bKEorbgXuZrqxByte3JFk2xSW2JEeAcyLc9Ru9pqcNNW+Ob7ntsk2oT/Xw==",
+    "node_modules/@stacks/clarunit/node_modules/rollup": {
+      "version": "4.12.0",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.12.0.tgz",
+      "integrity": "sha512-wz66wn4t1OHIJw3+XU7mJJQV/2NAfw5OAk6G6Hoo3zcvz/XOfQ52Vgi+AN4Uxoxi0KBBwk2g8zPrTDA4btSB/Q==",
+      "dependencies": {
+        "@types/estree": "1.0.5"
+      },
       "bin": {
         "rollup": "dist/bin/rollup"
       },
@@ -2125,34 +2009,45 @@
         "npm": ">=8.0.0"
       },
       "optionalDependencies": {
-        "@rollup/rollup-android-arm-eabi": "4.9.1",
-        "@rollup/rollup-android-arm64": "4.9.1",
-        "@rollup/rollup-darwin-arm64": "4.9.1",
-        "@rollup/rollup-darwin-x64": "4.9.1",
-        "@rollup/rollup-linux-arm-gnueabihf": "4.9.1",
-        "@rollup/rollup-linux-arm64-gnu": "4.9.1",
-        "@rollup/rollup-linux-arm64-musl": "4.9.1",
-        "@rollup/rollup-linux-riscv64-gnu": "4.9.1",
-        "@rollup/rollup-linux-x64-gnu": "4.9.1",
-        "@rollup/rollup-linux-x64-musl": "4.9.1",
-        "@rollup/rollup-win32-arm64-msvc": "4.9.1",
-        "@rollup/rollup-win32-ia32-msvc": "4.9.1",
-        "@rollup/rollup-win32-x64-msvc": "4.9.1",
+        "@rollup/rollup-android-arm-eabi": "4.12.0",
+        "@rollup/rollup-android-arm64": "4.12.0",
+        "@rollup/rollup-darwin-arm64": "4.12.0",
+        "@rollup/rollup-darwin-x64": "4.12.0",
+        "@rollup/rollup-linux-arm-gnueabihf": "4.12.0",
+        "@rollup/rollup-linux-arm64-gnu": "4.12.0",
+        "@rollup/rollup-linux-arm64-musl": "4.12.0",
+        "@rollup/rollup-linux-riscv64-gnu": "4.12.0",
+        "@rollup/rollup-linux-x64-gnu": "4.12.0",
+        "@rollup/rollup-linux-x64-musl": "4.12.0",
+        "@rollup/rollup-win32-arm64-msvc": "4.12.0",
+        "@rollup/rollup-win32-ia32-msvc": "4.12.0",
+        "@rollup/rollup-win32-x64-msvc": "4.12.0",
         "fsevents": "~2.3.2"
       }
     },
-    "node_modules/clarunit/node_modules/tinypool": {
-      "version": "0.8.1",
-      "resolved": "https://registry.npmjs.org/tinypool/-/tinypool-0.8.1.tgz",
-      "integrity": "sha512-zBTCK0cCgRROxvs9c0CGK838sPkeokNGdQVUUwHAbynHFlmyJYj825f/oRs528HaIJ97lo0pLIlDUzwN+IorWg==",
+    "node_modules/@stacks/clarunit/node_modules/strip-literal": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/strip-literal/-/strip-literal-2.0.0.tgz",
+      "integrity": "sha512-f9vHgsCWBq2ugHAkGMiiYY+AYG0D/cbloKKg0nhaaaSNsujdGIpVXCNsrJpCKr5M0f4aI31mr13UjY6GAuXCKA==",
+      "dependencies": {
+        "js-tokens": "^8.0.2"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/antfu"
+      }
+    },
+    "node_modules/@stacks/clarunit/node_modules/tinypool": {
+      "version": "0.8.2",
+      "resolved": "https://registry.npmjs.org/tinypool/-/tinypool-0.8.2.tgz",
+      "integrity": "sha512-SUszKYe5wgsxnNOVlBYO6IC+8VGWdVGZWAqUxp3UErNBtptZvWbwyUOyzNL59zigz2rCA92QiL3wvG+JDSdJdQ==",
       "engines": {
         "node": ">=14.0.0"
       }
     },
-    "node_modules/clarunit/node_modules/vite-node": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/vite-node/-/vite-node-1.1.0.tgz",
-      "integrity": "sha512-jV48DDUxGLEBdHCQvxL1mEh7+naVy+nhUUUaPAZLd3FJgXuxQiewHcfeZebbJ6onDqNGkP4r3MhQ342PRlG81Q==",
+    "node_modules/@stacks/clarunit/node_modules/vite-node": {
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/vite-node/-/vite-node-1.3.1.tgz",
+      "integrity": "sha512-azbRrqRxlWTJEVbzInZCTchx0X69M/XPTCz4H+TLvlTcR/xH/3hkRqhOakT41fMJCMzXTu4UvegkZiEoJAWvng==",
       "dependencies": {
         "cac": "^6.7.14",
         "debug": "^4.3.4",
@@ -2170,13 +2065,13 @@
         "url": "https://opencollective.com/vitest"
       }
     },
-    "node_modules/clarunit/node_modules/vite-node/node_modules/vite": {
-      "version": "5.0.10",
-      "resolved": "https://registry.npmjs.org/vite/-/vite-5.0.10.tgz",
-      "integrity": "sha512-2P8J7WWgmc355HUMlFrwofacvr98DAjoE52BfdbwQtyLH06XKwaL/FMnmKM2crF0iX4MpmMKoDlNCB1ok7zHCw==",
+    "node_modules/@stacks/clarunit/node_modules/vite-node/node_modules/vite": {
+      "version": "5.1.4",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-5.1.4.tgz",
+      "integrity": "sha512-n+MPqzq+d9nMVTKyewqw6kSt+R3CkvF9QAKY8obiQn8g1fwTscKxyfaYnC632HtBXAQGc1Yjomphwn1dtwGAHg==",
       "dependencies": {
         "esbuild": "^0.19.3",
-        "postcss": "^8.4.32",
+        "postcss": "^8.4.35",
         "rollup": "^4.2.0"
       },
       "bin": {
@@ -2224,18 +2119,17 @@
         }
       }
     },
-    "node_modules/clarunit/node_modules/vitest": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/vitest/-/vitest-1.1.0.tgz",
-      "integrity": "sha512-oDFiCrw7dd3Jf06HoMtSRARivvyjHJaTxikFxuqJjO76U436PqlVw1uLn7a8OSPrhSfMGVaRakKpA2lePdw79A==",
+    "node_modules/@stacks/clarunit/node_modules/vitest": {
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/vitest/-/vitest-1.3.1.tgz",
+      "integrity": "sha512-/1QJqXs8YbCrfv/GPQ05wAZf2eakUPLPa18vkJAKE7RXOKfVHqMZZ1WlTjiwl6Gcn65M5vpNUB6EFLnEdRdEXQ==",
       "dependencies": {
-        "@vitest/expect": "1.1.0",
-        "@vitest/runner": "1.1.0",
-        "@vitest/snapshot": "1.1.0",
-        "@vitest/spy": "1.1.0",
-        "@vitest/utils": "1.1.0",
-        "acorn-walk": "^8.3.0",
-        "cac": "^6.7.14",
+        "@vitest/expect": "1.3.1",
+        "@vitest/runner": "1.3.1",
+        "@vitest/snapshot": "1.3.1",
+        "@vitest/spy": "1.3.1",
+        "@vitest/utils": "1.3.1",
+        "acorn-walk": "^8.3.2",
         "chai": "^4.3.10",
         "debug": "^4.3.4",
         "execa": "^8.0.1",
@@ -2244,11 +2138,11 @@
         "pathe": "^1.1.1",
         "picocolors": "^1.0.0",
         "std-env": "^3.5.0",
-        "strip-literal": "^1.3.0",
+        "strip-literal": "^2.0.0",
         "tinybench": "^2.5.1",
-        "tinypool": "^0.8.1",
+        "tinypool": "^0.8.2",
         "vite": "^5.0.0",
-        "vite-node": "1.1.0",
+        "vite-node": "1.3.1",
         "why-is-node-running": "^2.2.2"
       },
       "bin": {
@@ -2263,8 +2157,8 @@
       "peerDependencies": {
         "@edge-runtime/vm": "*",
         "@types/node": "^18.0.0 || >=20.0.0",
-        "@vitest/browser": "^1.0.0",
-        "@vitest/ui": "^1.0.0",
+        "@vitest/browser": "1.3.1",
+        "@vitest/ui": "1.3.1",
         "happy-dom": "*",
         "jsdom": "*"
       },
@@ -2289,58 +2183,577 @@
         }
       }
     },
-    "node_modules/clarunit/node_modules/vitest/node_modules/vite": {
-      "version": "5.0.10",
-      "resolved": "https://registry.npmjs.org/vite/-/vite-5.0.10.tgz",
-      "integrity": "sha512-2P8J7WWgmc355HUMlFrwofacvr98DAjoE52BfdbwQtyLH06XKwaL/FMnmKM2crF0iX4MpmMKoDlNCB1ok7zHCw==",
+    "node_modules/@stacks/clarunit/node_modules/vitest/node_modules/vite": {
+      "version": "5.1.4",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-5.1.4.tgz",
+      "integrity": "sha512-n+MPqzq+d9nMVTKyewqw6kSt+R3CkvF9QAKY8obiQn8g1fwTscKxyfaYnC632HtBXAQGc1Yjomphwn1dtwGAHg==",
+      "dependencies": {
+        "esbuild": "^0.19.3",
+        "postcss": "^8.4.35",
+        "rollup": "^4.2.0"
+      },
+      "bin": {
+        "vite": "bin/vite.js"
+      },
+      "engines": {
+        "node": "^18.0.0 || >=20.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/vitejs/vite?sponsor=1"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.3"
+      },
+      "peerDependencies": {
+        "@types/node": "^18.0.0 || >=20.0.0",
+        "less": "*",
+        "lightningcss": "^1.21.0",
+        "sass": "*",
+        "stylus": "*",
+        "sugarss": "*",
+        "terser": "^5.4.0"
+      },
+      "peerDependenciesMeta": {
+        "@types/node": {
+          "optional": true
+        },
+        "less": {
+          "optional": true
+        },
+        "lightningcss": {
+          "optional": true
+        },
+        "sass": {
+          "optional": true
+        },
+        "stylus": {
+          "optional": true
+        },
+        "sugarss": {
+          "optional": true
+        },
+        "terser": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@stacks/common": {
+      "version": "6.10.0",
+      "resolved": "https://registry.npmjs.org/@stacks/common/-/common-6.10.0.tgz",
+      "integrity": "sha512-6x5Z7AKd9/kj3+DYE9xIDIkFLHihBH614i2wqrZIjN02WxVo063hWSjIlUxlx8P4gl6olVzlOy5LzhLJD9OP0A==",
+      "dependencies": {
+        "@types/bn.js": "^5.1.0",
+        "@types/node": "^18.0.4"
+      }
+    },
+    "node_modules/@stacks/network": {
+      "version": "6.10.0",
+      "resolved": "https://registry.npmjs.org/@stacks/network/-/network-6.10.0.tgz",
+      "integrity": "sha512-mbiZ8nlsyy77ndmBdaqhHXii22IFdK4ThRcOQs9j/O00DkAr04jCM4GV5Q+VLUnZ9OBoJq7yOV7Pf6jglh+0hw==",
+      "dependencies": {
+        "@stacks/common": "^6.10.0",
+        "cross-fetch": "^3.1.5"
+      }
+    },
+    "node_modules/@stacks/transactions": {
+      "version": "6.11.0",
+      "resolved": "https://registry.npmjs.org/@stacks/transactions/-/transactions-6.11.0.tgz",
+      "integrity": "sha512-+zIDqn9j4H/+o1ER8C9rFpig1fyrQcj2hVGNIrp+YbpPyja+cxv3fPk6kI/gePzwggzxRgUkIWhBc+mZAXuXyQ==",
+      "dependencies": {
+        "@noble/hashes": "1.1.5",
+        "@noble/secp256k1": "1.7.1",
+        "@stacks/common": "^6.10.0",
+        "@stacks/network": "^6.10.0",
+        "c32check": "^2.0.0",
+        "lodash.clonedeep": "^4.5.0"
+      }
+    },
+    "node_modules/@types/bn.js": {
+      "version": "5.1.5",
+      "resolved": "https://registry.npmjs.org/@types/bn.js/-/bn.js-5.1.5.tgz",
+      "integrity": "sha512-V46N0zwKRF5Q00AZ6hWtN0T8gGmDUaUzLWQvHFo5yThtVwK/VCenFY3wXVbOvNfajEpsTfQM4IN9k/d6gUVX3A==",
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@types/chai": {
+      "version": "4.3.9",
+      "resolved": "https://registry.npmjs.org/@types/chai/-/chai-4.3.9.tgz",
+      "integrity": "sha512-69TtiDzu0bcmKQv3yg1Zx409/Kd7r0b5F1PfpYJfSHzLGtB53547V4u+9iqKYsTu/O2ai6KTb0TInNpvuQ3qmg=="
+    },
+    "node_modules/@types/chai-subset": {
+      "version": "1.3.4",
+      "resolved": "https://registry.npmjs.org/@types/chai-subset/-/chai-subset-1.3.4.tgz",
+      "integrity": "sha512-CCWNXrJYSUIojZ1149ksLl3AN9cmZ5djf+yUoVVV+NuYrtydItQVlL2ZDqyC6M6O9LWRnVf8yYDxbXHO2TfQZg==",
+      "dependencies": {
+        "@types/chai": "*"
+      }
+    },
+    "node_modules/@types/estree": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.5.tgz",
+      "integrity": "sha512-/kYRxGDLWzHOB7q+wtSUQlFrtcdUccpfy+X+9iMBpHK8QLLhx2wIPYuS5DYtR9Wa/YlZAbIovy7qVdB1Aq6Lyw=="
+    },
+    "node_modules/@types/node": {
+      "version": "18.18.8",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-18.18.8.tgz",
+      "integrity": "sha512-OLGBaaK5V3VRBS1bAkMVP2/W9B+H8meUfl866OrMNQqt7wDgdpWPp5o6gmIc9pB+lIQHSq4ZL8ypeH1vPxcPaQ==",
+      "dependencies": {
+        "undici-types": "~5.26.4"
+      }
+    },
+    "node_modules/@ungap/structured-clone": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.2.0.tgz",
+      "integrity": "sha512-zuVdFrMJiuCDQUMCzQaD6KL28MjnqqN8XnAqiEq9PNm/hCPTSGfrXCOfwj1ow4LFb/tNymJPwsNbVePc1xFqrQ=="
+    },
+    "node_modules/@vitest/expect": {
+      "version": "0.34.6",
+      "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-0.34.6.tgz",
+      "integrity": "sha512-QUzKpUQRc1qC7qdGo7rMK3AkETI7w18gTCUrsNnyjjJKYiuUB9+TQK3QnR1unhCnWRC0AbKv2omLGQDF/mIjOw==",
+      "dependencies": {
+        "@vitest/spy": "0.34.6",
+        "@vitest/utils": "0.34.6",
+        "chai": "^4.3.10"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/runner": {
+      "version": "0.34.6",
+      "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-0.34.6.tgz",
+      "integrity": "sha512-1CUQgtJSLF47NnhN+F9X2ycxUP0kLHQ/JWvNHbeBfwW8CzEGgeskzNnHDyv1ieKTltuR6sdIHV+nmR6kPxQqzQ==",
+      "dependencies": {
+        "@vitest/utils": "0.34.6",
+        "p-limit": "^4.0.0",
+        "pathe": "^1.1.1"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/snapshot": {
+      "version": "0.34.6",
+      "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-0.34.6.tgz",
+      "integrity": "sha512-B3OZqYn6k4VaN011D+ve+AA4whM4QkcwcrwaKwAbyyvS/NB1hCWjFIBQxAQQSQir9/RtyAAGuq+4RJmbn2dH4w==",
+      "dependencies": {
+        "magic-string": "^0.30.1",
+        "pathe": "^1.1.1",
+        "pretty-format": "^29.5.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/spy": {
+      "version": "0.34.6",
+      "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-0.34.6.tgz",
+      "integrity": "sha512-xaCvneSaeBw/cz8ySmF7ZwGvL0lBjfvqc1LpQ/vcdHEvpLn3Ff1vAvjw+CoGn0802l++5L/pxb7whwcWAw+DUQ==",
+      "dependencies": {
+        "tinyspy": "^2.1.1"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/utils": {
+      "version": "0.34.6",
+      "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-0.34.6.tgz",
+      "integrity": "sha512-IG5aDD8S6zlvloDsnzHw0Ut5xczlF+kv2BOTo+iXfPr54Yhi5qbVOgGB1hZaVq4iJ4C/MZ2J0y15IlsV/ZcI0A==",
+      "dependencies": {
+        "diff-sequences": "^29.4.3",
+        "loupe": "^2.3.6",
+        "pretty-format": "^29.5.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/acorn": {
+      "version": "8.11.2",
+      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.11.2.tgz",
+      "integrity": "sha512-nc0Axzp/0FILLEVsm4fNwLCwMttvhEI263QtVPQcbpfZZ3ts0hLsZGOpE6czNlid7CJ9MlyH8reXkpsf3YUY4w==",
+      "bin": {
+        "acorn": "bin/acorn"
+      },
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/acorn-jsx": {
+      "version": "5.3.2",
+      "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-5.3.2.tgz",
+      "integrity": "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==",
+      "peerDependencies": {
+        "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0"
+      }
+    },
+    "node_modules/acorn-walk": {
+      "version": "8.3.2",
+      "resolved": "https://registry.npmjs.org/acorn-walk/-/acorn-walk-8.3.2.tgz",
+      "integrity": "sha512-cjkyv4OtNCIeqhHrfS81QWXoCBPExR/J62oyEqepVw8WaQeSqpW2uhuLPh1m9eWhDuOo/jUXVTlifvesOWp/4A==",
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/ajv": {
+      "version": "6.12.6",
+      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
+      "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",
+      "dependencies": {
+        "fast-deep-equal": "^3.1.1",
+        "fast-json-stable-stringify": "^2.0.0",
+        "json-schema-traverse": "^0.4.1",
+        "uri-js": "^4.2.2"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/epoberezkin"
+      }
+    },
+    "node_modules/ansi-regex": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/ansi-styles": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-5.2.0.tgz",
+      "integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/anymatch": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-3.1.3.tgz",
+      "integrity": "sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==",
+      "dependencies": {
+        "normalize-path": "^3.0.0",
+        "picomatch": "^2.0.4"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
+    "node_modules/argparse": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
+      "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q=="
+    },
+    "node_modules/assertion-error": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-1.1.0.tgz",
+      "integrity": "sha512-jgsaNduz+ndvGyFt3uSuWqvy4lCnIJiovtouQN5JZHOKCS2QuhEdbcQHFhVksz2N2U9hXJo8odG7ETyWlEeuDw==",
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/balanced-match": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="
+    },
+    "node_modules/base-x": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/base-x/-/base-x-4.0.0.tgz",
+      "integrity": "sha512-FuwxlW4H5kh37X/oW59pwTzzTKRzfrrQwhmyspRM7swOEZcHtDZSCt45U6oKgtuFE+WYPblePMVIPR4RZrh/hw=="
+    },
+    "node_modules/binary-extensions": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.2.0.tgz",
+      "integrity": "sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA==",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/brace-expansion": {
+      "version": "1.1.11",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
+      "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
+      "dependencies": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "node_modules/braces": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz",
+      "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==",
+      "dependencies": {
+        "fill-range": "^7.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/c32check": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/c32check/-/c32check-2.0.0.tgz",
+      "integrity": "sha512-rpwfAcS/CMqo0oCqDf3r9eeLgScRE3l/xHDCXhM3UyrfvIn7PrLq63uHh7yYbv8NzaZn5MVsVhIRpQ+5GZ5HyA==",
+      "dependencies": {
+        "@noble/hashes": "^1.1.2",
+        "base-x": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/cac": {
+      "version": "6.7.14",
+      "resolved": "https://registry.npmjs.org/cac/-/cac-6.7.14.tgz",
+      "integrity": "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/callsites": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
+      "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/camelcase": {
+      "version": "5.3.1",
+      "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-5.3.1.tgz",
+      "integrity": "sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/chai": {
+      "version": "4.3.10",
+      "resolved": "https://registry.npmjs.org/chai/-/chai-4.3.10.tgz",
+      "integrity": "sha512-0UXG04VuVbruMUYbJ6JctvH0YnC/4q3/AkT18q4NaITo91CUm0liMS9VqzT9vZhVQ/1eqPanMWjBM+Juhfb/9g==",
+      "dependencies": {
+        "assertion-error": "^1.1.0",
+        "check-error": "^1.0.3",
+        "deep-eql": "^4.1.3",
+        "get-func-name": "^2.0.2",
+        "loupe": "^2.3.6",
+        "pathval": "^1.1.1",
+        "type-detect": "^4.0.8"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/chalk": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
+      "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
+      "dependencies": {
+        "ansi-styles": "^4.1.0",
+        "supports-color": "^7.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/chalk?sponsor=1"
+      }
+    },
+    "node_modules/chalk/node_modules/ansi-styles": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+      "dependencies": {
+        "color-convert": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/chalk/node_modules/color-convert": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
+      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+      "dependencies": {
+        "color-name": "~1.1.4"
+      },
+      "engines": {
+        "node": ">=7.0.0"
+      }
+    },
+    "node_modules/chalk/node_modules/color-name": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
+      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA=="
+    },
+    "node_modules/check-error": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/check-error/-/check-error-1.0.3.tgz",
+      "integrity": "sha512-iKEoDYaRmd1mxM90a2OEfWhjsjPpYPuQ+lMYsoxB126+t8fw7ySEO48nmDg5COTjxDI65/Y2OWpeEHk3ZOe8zg==",
+      "dependencies": {
+        "get-func-name": "^2.0.2"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/chokidar": {
+      "version": "3.5.3",
+      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.5.3.tgz",
+      "integrity": "sha512-Dr3sfKRP6oTcjf2JmUmFJfeVMvXBdegxB0iVQ5eb2V10uFJUCAS8OByZdVAyVb8xXNz3GjjTgj9kLWsZTqE6kw==",
+      "funding": [
+        {
+          "type": "individual",
+          "url": "https://paulmillr.com/funding/"
+        }
+      ],
+      "dependencies": {
+        "anymatch": "~3.1.2",
+        "braces": "~3.0.2",
+        "glob-parent": "~5.1.2",
+        "is-binary-path": "~2.1.0",
+        "is-glob": "~4.0.1",
+        "normalize-path": "~3.0.0",
+        "readdirp": "~3.6.0"
+      },
+      "engines": {
+        "node": ">= 8.10.0"
+      },
+      "optionalDependencies": {
+        "fsevents": "~2.3.2"
+      }
+    },
+    "node_modules/chokidar-cli": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/chokidar-cli/-/chokidar-cli-3.0.0.tgz",
+      "integrity": "sha512-xVW+Qeh7z15uZRxHOkP93Ux8A0xbPzwK4GaqD8dQOYc34TlkqUhVSS59fK36DOp5WdJlrRzlYSy02Ht99FjZqQ==",
+      "dependencies": {
+        "chokidar": "^3.5.2",
+        "lodash.debounce": "^4.0.8",
+        "lodash.throttle": "^4.1.1",
+        "yargs": "^13.3.0"
+      },
+      "bin": {
+        "chokidar": "index.js"
+      },
+      "engines": {
+        "node": ">= 8.10.0"
+      }
+    },
+    "node_modules/chokidar-cli/node_modules/ansi-regex": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-4.1.1.tgz",
+      "integrity": "sha512-ILlv4k/3f6vfQ4OoP2AGvirOktlQ98ZEL1k9FaQjxa3L1abBgbuTDAdPOpvbGncC0BTVQrl+OM8xZGK6tWXt7g==",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/chokidar-cli/node_modules/ansi-styles": {
+      "version": "3.2.1",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz",
+      "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==",
+      "dependencies": {
+        "color-convert": "^1.9.0"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/chokidar-cli/node_modules/cliui": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/cliui/-/cliui-5.0.0.tgz",
+      "integrity": "sha512-PYeGSEmmHM6zvoef2w8TPzlrnNpXIjTipYK780YswmIP9vjxmd6Y2a3CB2Ks6/AU8NHjZugXvo8w3oWM2qnwXA==",
+      "dependencies": {
+        "string-width": "^3.1.0",
+        "strip-ansi": "^5.2.0",
+        "wrap-ansi": "^5.1.0"
+      }
+    },
+    "node_modules/chokidar-cli/node_modules/emoji-regex": {
+      "version": "7.0.3",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-7.0.3.tgz",
+      "integrity": "sha512-CwBLREIQ7LvYFB0WyRvwhq5N5qPhc6PMjD6bYggFlI5YyDgl+0vxq5VHbMOFqLg7hfWzmu8T5Z1QofhmTIhItA=="
+    },
+    "node_modules/chokidar-cli/node_modules/is-fullwidth-code-point": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz",
+      "integrity": "sha512-VHskAKYM8RfSFXwee5t5cbN5PZeq1Wrh6qd5bkyiXIf6UQcN6w/A0eXM9r6t8d+GYOh+o6ZhiEnb88LN/Y8m2w==",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/chokidar-cli/node_modules/string-width": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/string-width/-/string-width-3.1.0.tgz",
+      "integrity": "sha512-vafcv6KjVZKSgz06oM/H6GDBrAtz8vdhQakGjFIvNrHA6y3HCF1CInLy+QLq8dTJPQ1b+KDUqDFctkdRW44e1w==",
+      "dependencies": {
+        "emoji-regex": "^7.0.1",
+        "is-fullwidth-code-point": "^2.0.0",
+        "strip-ansi": "^5.1.0"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/chokidar-cli/node_modules/strip-ansi": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-5.2.0.tgz",
+      "integrity": "sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==",
+      "dependencies": {
+        "ansi-regex": "^4.1.0"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/chokidar-cli/node_modules/wrap-ansi": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-5.1.0.tgz",
+      "integrity": "sha512-QC1/iN/2/RPVJ5jYK8BGttj5z83LmSKmvbvrXPNCLZSEb32KKVDJDl/MOt2N01qU2H/FkzEa9PKto1BqDjtd7Q==",
+      "dependencies": {
+        "ansi-styles": "^3.2.0",
+        "string-width": "^3.0.0",
+        "strip-ansi": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/chokidar-cli/node_modules/y18n": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/y18n/-/y18n-4.0.3.tgz",
+      "integrity": "sha512-JKhqTOwSrqNA1NY5lSztJ1GrBiUodLMmIZuLiDaMRJ+itFd+ABVE8XBjOvIWL+rSqNDC74LCSFmlb/U4UZ4hJQ=="
+    },
+    "node_modules/chokidar-cli/node_modules/yargs": {
+      "version": "13.3.2",
+      "resolved": "https://registry.npmjs.org/yargs/-/yargs-13.3.2.tgz",
+      "integrity": "sha512-AX3Zw5iPruN5ie6xGRIDgqkT+ZhnRlZMLMHAs8tg7nRruy2Nb+i5o9bwghAogtM08q1dpr2LVoS8KSTMYpWXUw==",
       "dependencies": {
-        "esbuild": "^0.19.3",
-        "postcss": "^8.4.32",
-        "rollup": "^4.2.0"
-      },
-      "bin": {
-        "vite": "bin/vite.js"
-      },
-      "engines": {
-        "node": "^18.0.0 || >=20.0.0"
-      },
-      "funding": {
-        "url": "https://github.com/vitejs/vite?sponsor=1"
-      },
-      "optionalDependencies": {
-        "fsevents": "~2.3.3"
-      },
-      "peerDependencies": {
-        "@types/node": "^18.0.0 || >=20.0.0",
-        "less": "*",
-        "lightningcss": "^1.21.0",
-        "sass": "*",
-        "stylus": "*",
-        "sugarss": "*",
-        "terser": "^5.4.0"
-      },
-      "peerDependenciesMeta": {
-        "@types/node": {
-          "optional": true
-        },
-        "less": {
-          "optional": true
-        },
-        "lightningcss": {
-          "optional": true
-        },
-        "sass": {
-          "optional": true
-        },
-        "stylus": {
-          "optional": true
-        },
-        "sugarss": {
-          "optional": true
-        },
-        "terser": {
-          "optional": true
-        }
+        "cliui": "^5.0.0",
+        "find-up": "^3.0.0",
+        "get-caller-file": "^2.0.1",
+        "require-directory": "^2.1.1",
+        "require-main-filename": "^2.0.0",
+        "set-blocking": "^2.0.0",
+        "string-width": "^3.0.0",
+        "which-module": "^2.0.0",
+        "y18n": "^4.0.0",
+        "yargs-parser": "^13.1.2"
+      }
+    },
+    "node_modules/chokidar-cli/node_modules/yargs-parser": {
+      "version": "13.1.2",
+      "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-13.1.2.tgz",
+      "integrity": "sha512-3lbsNRf/j+A4QuSZfDRA7HRSfWrzO0YjqTJd5kjAq37Zep1CEgaYmrH9Q3GwPiB9cHyd1Y1UwggGhJGoxipbzg==",
+      "dependencies": {
+        "camelcase": "^5.0.0",
+        "decamelize": "^1.2.0"
       }
     },
     "node_modules/cliui": {
@@ -2369,6 +2782,11 @@
       "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz",
       "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw=="
     },
+    "node_modules/concat-map": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
+      "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg=="
+    },
     "node_modules/cross-fetch": {
       "version": "3.1.8",
       "resolved": "https://registry.npmjs.org/cross-fetch/-/cross-fetch-3.1.8.tgz",
@@ -2411,75 +2829,331 @@
       "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-1.2.0.tgz",
       "integrity": "sha512-z2S+W9X73hAUUki+N+9Za2lBlun89zigOyGrsax+KUQ6wKW4ZoWpEYBkGhQjwAjjDCkWxhY0VKEhk8wzY7F5cA==",
       "engines": {
-        "node": ">=0.10.0"
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/deep-eql": {
+      "version": "4.1.3",
+      "resolved": "https://registry.npmjs.org/deep-eql/-/deep-eql-4.1.3.tgz",
+      "integrity": "sha512-WaEtAOpRA1MQ0eohqZjpGD8zdI0Ovsm8mmFhaDN8dvDZzyoUMcYDnf5Y6iu7HTXxf8JDS23qWa4a+hKCDyOPzw==",
+      "dependencies": {
+        "type-detect": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/deep-is": {
+      "version": "0.1.4",
+      "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz",
+      "integrity": "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ=="
+    },
+    "node_modules/diff-sequences": {
+      "version": "29.6.3",
+      "resolved": "https://registry.npmjs.org/diff-sequences/-/diff-sequences-29.6.3.tgz",
+      "integrity": "sha512-EjePK1srD3P08o2j4f0ExnylqRs5B9tJjcp9t1krH2qRi8CCdsYfwe9JgSLurFBWwq4uOlipzfk5fHNvwFKr8Q==",
+      "engines": {
+        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+      }
+    },
+    "node_modules/doctrine": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/doctrine/-/doctrine-3.0.0.tgz",
+      "integrity": "sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==",
+      "dependencies": {
+        "esutils": "^2.0.2"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/emoji-regex": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="
+    },
+    "node_modules/esbuild": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.18.20.tgz",
+      "integrity": "sha512-ceqxoedUrcayh7Y7ZX6NdbbDzGROiyVBgC4PriJThBKSVPWnnFHZAkfI1lJT8QFkOwH4qOS2SJkS4wvpGl8BpA==",
+      "hasInstallScript": true,
+      "bin": {
+        "esbuild": "bin/esbuild"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "optionalDependencies": {
+        "@esbuild/android-arm": "0.18.20",
+        "@esbuild/android-arm64": "0.18.20",
+        "@esbuild/android-x64": "0.18.20",
+        "@esbuild/darwin-arm64": "0.18.20",
+        "@esbuild/darwin-x64": "0.18.20",
+        "@esbuild/freebsd-arm64": "0.18.20",
+        "@esbuild/freebsd-x64": "0.18.20",
+        "@esbuild/linux-arm": "0.18.20",
+        "@esbuild/linux-arm64": "0.18.20",
+        "@esbuild/linux-ia32": "0.18.20",
+        "@esbuild/linux-loong64": "0.18.20",
+        "@esbuild/linux-mips64el": "0.18.20",
+        "@esbuild/linux-ppc64": "0.18.20",
+        "@esbuild/linux-riscv64": "0.18.20",
+        "@esbuild/linux-s390x": "0.18.20",
+        "@esbuild/linux-x64": "0.18.20",
+        "@esbuild/netbsd-x64": "0.18.20",
+        "@esbuild/openbsd-x64": "0.18.20",
+        "@esbuild/sunos-x64": "0.18.20",
+        "@esbuild/win32-arm64": "0.18.20",
+        "@esbuild/win32-ia32": "0.18.20",
+        "@esbuild/win32-x64": "0.18.20"
+      }
+    },
+    "node_modules/escalade": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz",
+      "integrity": "sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/escape-string-regexp": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
+      "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/eslint": {
+      "version": "8.57.0",
+      "resolved": "https://registry.npmjs.org/eslint/-/eslint-8.57.0.tgz",
+      "integrity": "sha512-dZ6+mexnaTIbSBZWgou51U6OmzIhYM2VcNdtiTtI7qPNZm35Akpr0f6vtw3w1Kmn5PYo+tZVfh13WrhpS6oLqQ==",
+      "dependencies": {
+        "@eslint-community/eslint-utils": "^4.2.0",
+        "@eslint-community/regexpp": "^4.6.1",
+        "@eslint/eslintrc": "^2.1.4",
+        "@eslint/js": "8.57.0",
+        "@humanwhocodes/config-array": "^0.11.14",
+        "@humanwhocodes/module-importer": "^1.0.1",
+        "@nodelib/fs.walk": "^1.2.8",
+        "@ungap/structured-clone": "^1.2.0",
+        "ajv": "^6.12.4",
+        "chalk": "^4.0.0",
+        "cross-spawn": "^7.0.2",
+        "debug": "^4.3.2",
+        "doctrine": "^3.0.0",
+        "escape-string-regexp": "^4.0.0",
+        "eslint-scope": "^7.2.2",
+        "eslint-visitor-keys": "^3.4.3",
+        "espree": "^9.6.1",
+        "esquery": "^1.4.2",
+        "esutils": "^2.0.2",
+        "fast-deep-equal": "^3.1.3",
+        "file-entry-cache": "^6.0.1",
+        "find-up": "^5.0.0",
+        "glob-parent": "^6.0.2",
+        "globals": "^13.19.0",
+        "graphemer": "^1.4.0",
+        "ignore": "^5.2.0",
+        "imurmurhash": "^0.1.4",
+        "is-glob": "^4.0.0",
+        "is-path-inside": "^3.0.3",
+        "js-yaml": "^4.1.0",
+        "json-stable-stringify-without-jsonify": "^1.0.1",
+        "levn": "^0.4.1",
+        "lodash.merge": "^4.6.2",
+        "minimatch": "^3.1.2",
+        "natural-compare": "^1.4.0",
+        "optionator": "^0.9.3",
+        "strip-ansi": "^6.0.1",
+        "text-table": "^0.2.0"
+      },
+      "bin": {
+        "eslint": "bin/eslint.js"
+      },
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/eslint-scope": {
+      "version": "7.2.2",
+      "resolved": "https://registry.npmjs.org/eslint-scope/-/eslint-scope-7.2.2.tgz",
+      "integrity": "sha512-dOt21O7lTMhDM+X9mB4GX+DZrZtCUJPL/wlcTqxyrx5IvO0IYtILdtrQGQp+8n5S0gwSVmOf9NQrjMOgfQZlIg==",
+      "dependencies": {
+        "esrecurse": "^4.3.0",
+        "estraverse": "^5.2.0"
+      },
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/eslint-visitor-keys": {
+      "version": "3.4.3",
+      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz",
+      "integrity": "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==",
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/eslint/node_modules/find-up": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz",
+      "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==",
+      "dependencies": {
+        "locate-path": "^6.0.0",
+        "path-exists": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/eslint/node_modules/glob-parent": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz",
+      "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==",
+      "dependencies": {
+        "is-glob": "^4.0.3"
+      },
+      "engines": {
+        "node": ">=10.13.0"
+      }
+    },
+    "node_modules/eslint/node_modules/locate-path": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz",
+      "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==",
+      "dependencies": {
+        "p-locate": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/eslint/node_modules/p-limit": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz",
+      "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==",
+      "dependencies": {
+        "yocto-queue": "^0.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/eslint/node_modules/p-locate": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz",
+      "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==",
+      "dependencies": {
+        "p-limit": "^3.0.2"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/eslint/node_modules/path-exists": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
+      "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/eslint/node_modules/yocto-queue": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz",
+      "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/espree": {
+      "version": "9.6.1",
+      "resolved": "https://registry.npmjs.org/espree/-/espree-9.6.1.tgz",
+      "integrity": "sha512-oruZaFkjorTpF32kDSI5/75ViwGeZginGGy2NoOSg3Q9bnwlnmDm4HLnkl0RE3n+njDXR037aY1+x58Z/zFdwQ==",
+      "dependencies": {
+        "acorn": "^8.9.0",
+        "acorn-jsx": "^5.3.2",
+        "eslint-visitor-keys": "^3.4.1"
+      },
+      "engines": {
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      }
+    },
+    "node_modules/esquery": {
+      "version": "1.5.0",
+      "resolved": "https://registry.npmjs.org/esquery/-/esquery-1.5.0.tgz",
+      "integrity": "sha512-YQLXUplAwJgCydQ78IMJywZCceoqk1oH01OERdSAJc/7U2AylwjhSCLDEtqwg811idIS/9fIU5GjG73IgjKMVg==",
+      "dependencies": {
+        "estraverse": "^5.1.0"
+      },
+      "engines": {
+        "node": ">=0.10"
       }
     },
-    "node_modules/deep-eql": {
-      "version": "4.1.3",
-      "resolved": "https://registry.npmjs.org/deep-eql/-/deep-eql-4.1.3.tgz",
-      "integrity": "sha512-WaEtAOpRA1MQ0eohqZjpGD8zdI0Ovsm8mmFhaDN8dvDZzyoUMcYDnf5Y6iu7HTXxf8JDS23qWa4a+hKCDyOPzw==",
+    "node_modules/esrecurse": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz",
+      "integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==",
       "dependencies": {
-        "type-detect": "^4.0.0"
+        "estraverse": "^5.2.0"
       },
       "engines": {
-        "node": ">=6"
+        "node": ">=4.0"
       }
     },
-    "node_modules/diff-sequences": {
-      "version": "29.6.3",
-      "resolved": "https://registry.npmjs.org/diff-sequences/-/diff-sequences-29.6.3.tgz",
-      "integrity": "sha512-EjePK1srD3P08o2j4f0ExnylqRs5B9tJjcp9t1krH2qRi8CCdsYfwe9JgSLurFBWwq4uOlipzfk5fHNvwFKr8Q==",
+    "node_modules/estraverse": {
+      "version": "5.3.0",
+      "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz",
+      "integrity": "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==",
       "engines": {
-        "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
+        "node": ">=4.0"
       }
     },
-    "node_modules/emoji-regex": {
-      "version": "8.0.0",
-      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
-      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="
-    },
-    "node_modules/esbuild": {
-      "version": "0.18.20",
-      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.18.20.tgz",
-      "integrity": "sha512-ceqxoedUrcayh7Y7ZX6NdbbDzGROiyVBgC4PriJThBKSVPWnnFHZAkfI1lJT8QFkOwH4qOS2SJkS4wvpGl8BpA==",
-      "hasInstallScript": true,
-      "bin": {
-        "esbuild": "bin/esbuild"
-      },
-      "engines": {
-        "node": ">=12"
-      },
-      "optionalDependencies": {
-        "@esbuild/android-arm": "0.18.20",
-        "@esbuild/android-arm64": "0.18.20",
-        "@esbuild/android-x64": "0.18.20",
-        "@esbuild/darwin-arm64": "0.18.20",
-        "@esbuild/darwin-x64": "0.18.20",
-        "@esbuild/freebsd-arm64": "0.18.20",
-        "@esbuild/freebsd-x64": "0.18.20",
-        "@esbuild/linux-arm": "0.18.20",
-        "@esbuild/linux-arm64": "0.18.20",
-        "@esbuild/linux-ia32": "0.18.20",
-        "@esbuild/linux-loong64": "0.18.20",
-        "@esbuild/linux-mips64el": "0.18.20",
-        "@esbuild/linux-ppc64": "0.18.20",
-        "@esbuild/linux-riscv64": "0.18.20",
-        "@esbuild/linux-s390x": "0.18.20",
-        "@esbuild/linux-x64": "0.18.20",
-        "@esbuild/netbsd-x64": "0.18.20",
-        "@esbuild/openbsd-x64": "0.18.20",
-        "@esbuild/sunos-x64": "0.18.20",
-        "@esbuild/win32-arm64": "0.18.20",
-        "@esbuild/win32-ia32": "0.18.20",
-        "@esbuild/win32-x64": "0.18.20"
+    "node_modules/estree-walker": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-3.0.3.tgz",
+      "integrity": "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==",
+      "dependencies": {
+        "@types/estree": "^1.0.0"
       }
     },
-    "node_modules/escalade": {
-      "version": "3.1.1",
-      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz",
-      "integrity": "sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==",
+    "node_modules/esutils": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz",
+      "integrity": "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==",
       "engines": {
-        "node": ">=6"
+        "node": ">=0.10.0"
       }
     },
     "node_modules/execa": {
@@ -2504,6 +3178,40 @@
         "url": "https://github.com/sindresorhus/execa?sponsor=1"
       }
     },
+    "node_modules/fast-deep-equal": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
+      "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q=="
+    },
+    "node_modules/fast-json-stable-stringify": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.1.0.tgz",
+      "integrity": "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw=="
+    },
+    "node_modules/fast-levenshtein": {
+      "version": "2.0.6",
+      "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz",
+      "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw=="
+    },
+    "node_modules/fastq": {
+      "version": "1.17.1",
+      "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.17.1.tgz",
+      "integrity": "sha512-sRVD3lWVIXWg6By68ZN7vho9a1pQcN/WBFaAAsDDFzlJjvoGx0P8z7V1t72grFJfJhu3YPZBuu25f7Kaw2jN1w==",
+      "dependencies": {
+        "reusify": "^1.0.4"
+      }
+    },
+    "node_modules/file-entry-cache": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/file-entry-cache/-/file-entry-cache-6.0.1.tgz",
+      "integrity": "sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg==",
+      "dependencies": {
+        "flat-cache": "^3.0.4"
+      },
+      "engines": {
+        "node": "^10.12.0 || >=12.0.0"
+      }
+    },
     "node_modules/fill-range": {
       "version": "7.0.1",
       "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz",
@@ -2526,6 +3234,29 @@
         "node": ">=6"
       }
     },
+    "node_modules/flat-cache": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/flat-cache/-/flat-cache-3.2.0.tgz",
+      "integrity": "sha512-CYcENa+FtcUKLmhhqyctpclsq7QF38pKjZHsGNiSQF5r4FtoKDWabFDl3hzaEQMvT1LHEysw5twgLvpYYb4vbw==",
+      "dependencies": {
+        "flatted": "^3.2.9",
+        "keyv": "^4.5.3",
+        "rimraf": "^3.0.2"
+      },
+      "engines": {
+        "node": "^10.12.0 || >=12.0.0"
+      }
+    },
+    "node_modules/flatted": {
+      "version": "3.3.1",
+      "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.3.1.tgz",
+      "integrity": "sha512-X8cqMLLie7KsNUDSdzeN8FYK9rEt4Dt67OsG/DNGnYTSDBG4uFAJFBnUeiV+zCVAvwFy56IjM9sH51jVaEhNxw=="
+    },
+    "node_modules/fs.realpath": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
+      "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw=="
+    },
     "node_modules/fsevents": {
       "version": "2.3.3",
       "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
@@ -2566,6 +3297,25 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/glob": {
+      "version": "7.2.3",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz",
+      "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==",
+      "dependencies": {
+        "fs.realpath": "^1.0.0",
+        "inflight": "^1.0.4",
+        "inherits": "2",
+        "minimatch": "^3.1.1",
+        "once": "^1.3.0",
+        "path-is-absolute": "^1.0.0"
+      },
+      "engines": {
+        "node": "*"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
     "node_modules/glob-parent": {
       "version": "5.1.2",
       "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-5.1.2.tgz",
@@ -2577,6 +3327,33 @@
         "node": ">= 6"
       }
     },
+    "node_modules/globals": {
+      "version": "13.24.0",
+      "resolved": "https://registry.npmjs.org/globals/-/globals-13.24.0.tgz",
+      "integrity": "sha512-AhO5QUcj8llrbG09iWhPU2B204J1xnPeL8kQmVorSsy+Sjj1sk8gIyh6cUocGmH4L0UuhAJy+hJMRA4mgA4mFQ==",
+      "dependencies": {
+        "type-fest": "^0.20.2"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/graphemer": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/graphemer/-/graphemer-1.4.0.tgz",
+      "integrity": "sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag=="
+    },
+    "node_modules/has-flag": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
+      "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/human-signals": {
       "version": "5.0.0",
       "resolved": "https://registry.npmjs.org/human-signals/-/human-signals-5.0.0.tgz",
@@ -2585,6 +3362,46 @@
         "node": ">=16.17.0"
       }
     },
+    "node_modules/ignore": {
+      "version": "5.3.1",
+      "resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.1.tgz",
+      "integrity": "sha512-5Fytz/IraMjqpwfd34ke28PTVMjZjJG2MPn5t7OE4eUCUNf8BAa7b5WUS9/Qvr6mwOQS7Mk6vdsMno5he+T8Xw==",
+      "engines": {
+        "node": ">= 4"
+      }
+    },
+    "node_modules/import-fresh": {
+      "version": "3.3.0",
+      "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.0.tgz",
+      "integrity": "sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw==",
+      "dependencies": {
+        "parent-module": "^1.0.0",
+        "resolve-from": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/imurmurhash": {
+      "version": "0.1.4",
+      "resolved": "https://registry.npmjs.org/imurmurhash/-/imurmurhash-0.1.4.tgz",
+      "integrity": "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==",
+      "engines": {
+        "node": ">=0.8.19"
+      }
+    },
+    "node_modules/inflight": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
+      "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==",
+      "dependencies": {
+        "once": "^1.3.0",
+        "wrappy": "1"
+      }
+    },
     "node_modules/inherits": {
       "version": "2.0.3",
       "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz",
@@ -2636,6 +3453,14 @@
         "node": ">=0.12.0"
       }
     },
+    "node_modules/is-path-inside": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/is-path-inside/-/is-path-inside-3.0.3.tgz",
+      "integrity": "sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==",
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/is-stream": {
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-3.0.0.tgz",
@@ -2652,11 +3477,50 @@
       "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
       "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw=="
     },
+    "node_modules/js-tokens": {
+      "version": "8.0.3",
+      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-8.0.3.tgz",
+      "integrity": "sha512-UfJMcSJc+SEXEl9lH/VLHSZbThQyLpw1vLO1Lb+j4RWDvG3N2f7yj3PVQA3cmkTBNldJ9eFnM+xEXxHIXrYiJw=="
+    },
+    "node_modules/js-yaml": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz",
+      "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==",
+      "dependencies": {
+        "argparse": "^2.0.1"
+      },
+      "bin": {
+        "js-yaml": "bin/js-yaml.js"
+      }
+    },
+    "node_modules/json-buffer": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/json-buffer/-/json-buffer-3.0.1.tgz",
+      "integrity": "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ=="
+    },
+    "node_modules/json-schema-traverse": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
+      "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg=="
+    },
+    "node_modules/json-stable-stringify-without-jsonify": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/json-stable-stringify-without-jsonify/-/json-stable-stringify-without-jsonify-1.0.1.tgz",
+      "integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw=="
+    },
     "node_modules/jsonc-parser": {
       "version": "3.2.0",
       "resolved": "https://registry.npmjs.org/jsonc-parser/-/jsonc-parser-3.2.0.tgz",
       "integrity": "sha512-gfFQZrcTc8CnKXp6Y4/CBT3fTc0OVuDofpre4aEeEpSBPV5X5v4+Vmx+8snU7RLPrNHPKSgLxGo9YuQzz20o+w=="
     },
+    "node_modules/keyv": {
+      "version": "4.5.4",
+      "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz",
+      "integrity": "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw==",
+      "dependencies": {
+        "json-buffer": "3.0.1"
+      }
+    },
     "node_modules/kleur": {
       "version": "3.0.3",
       "resolved": "https://registry.npmjs.org/kleur/-/kleur-3.0.3.tgz",
@@ -2670,6 +3534,18 @@
       "resolved": "https://registry.npmjs.org/kolorist/-/kolorist-1.8.0.tgz",
       "integrity": "sha512-Y+60/zizpJ3HRH8DCss+q95yr6145JXZo46OTpFvDZWLfRCE4qChOyk1b26nMaNpfHHgxagk9dXT5OP0Tfe+dQ=="
     },
+    "node_modules/levn": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz",
+      "integrity": "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==",
+      "dependencies": {
+        "prelude-ls": "^1.2.1",
+        "type-check": "~0.4.0"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
     "node_modules/local-pkg": {
       "version": "0.4.3",
       "resolved": "https://registry.npmjs.org/local-pkg/-/local-pkg-0.4.3.tgz",
@@ -2703,6 +3579,11 @@
       "resolved": "https://registry.npmjs.org/lodash.debounce/-/lodash.debounce-4.0.8.tgz",
       "integrity": "sha512-FT1yDzDYEoYWhnSGnpE/4Kj1fLZkDFyqRb7fNt6FdYOSxlUWAtp42Eh6Wb0rGIv/m9Bgo7x4GhQbm5Ys4SG5ow=="
     },
+    "node_modules/lodash.merge": {
+      "version": "4.6.2",
+      "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz",
+      "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ=="
+    },
     "node_modules/lodash.throttle": {
       "version": "4.1.1",
       "resolved": "https://registry.npmjs.org/lodash.throttle/-/lodash.throttle-4.1.1.tgz",
@@ -2743,6 +3624,17 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/minimatch": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
+      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+      "dependencies": {
+        "brace-expansion": "^1.1.7"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
     "node_modules/mlly": {
       "version": "1.4.2",
       "resolved": "https://registry.npmjs.org/mlly/-/mlly-1.4.2.tgz",
@@ -2776,6 +3668,11 @@
         "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
       }
     },
+    "node_modules/natural-compare": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/natural-compare/-/natural-compare-1.4.0.tgz",
+      "integrity": "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw=="
+    },
     "node_modules/node-fetch": {
       "version": "2.7.0",
       "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.7.0.tgz",
@@ -2828,6 +3725,14 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/once": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
+      "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
+      "dependencies": {
+        "wrappy": "1"
+      }
+    },
     "node_modules/onetime": {
       "version": "6.0.0",
       "resolved": "https://registry.npmjs.org/onetime/-/onetime-6.0.0.tgz",
@@ -2842,6 +3747,22 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/optionator": {
+      "version": "0.9.3",
+      "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.3.tgz",
+      "integrity": "sha512-JjCoypp+jKn1ttEFExxhetCKeJt9zhAgAve5FXHixTvFDW/5aEktX9bufBKLRRMdU7bNtpLfcGu94B3cdEJgjg==",
+      "dependencies": {
+        "@aashutoshrathi/word-wrap": "^1.2.3",
+        "deep-is": "^0.1.3",
+        "fast-levenshtein": "^2.0.6",
+        "levn": "^0.4.1",
+        "prelude-ls": "^1.2.1",
+        "type-check": "^0.4.0"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
     "node_modules/p-limit": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-4.0.0.tgz",
@@ -2889,6 +3810,17 @@
         "node": ">=6"
       }
     },
+    "node_modules/parent-module": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz",
+      "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==",
+      "dependencies": {
+        "callsites": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
     "node_modules/path": {
       "version": "0.12.7",
       "resolved": "https://registry.npmjs.org/path/-/path-0.12.7.tgz",
@@ -2906,6 +3838,14 @@
         "node": ">=4"
       }
     },
+    "node_modules/path-is-absolute": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
+      "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
     "node_modules/path-key": {
       "version": "3.1.1",
       "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
@@ -2954,9 +3894,9 @@
       }
     },
     "node_modules/postcss": {
-      "version": "8.4.32",
-      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.4.32.tgz",
-      "integrity": "sha512-D/kj5JNu6oo2EIy+XL/26JEDTlIbB8hw85G8StOE6L74RQAVVP5rej6wxCNqyMbR4RkPfqvezVbPw81Ngd6Kcw==",
+      "version": "8.4.35",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.4.35.tgz",
+      "integrity": "sha512-u5U8qYpBCpN13BsiEB0CbR1Hhh4Gc0zLFuedrHJKMctHCHAGrMdG0PRM/KErzAL3CU6/eckEtmHNB3x6e3c0vA==",
       "funding": [
         {
           "type": "opencollective",
@@ -2980,6 +3920,14 @@
         "node": "^10 || ^12 || >=14"
       }
     },
+    "node_modules/prelude-ls": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz",
+      "integrity": "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==",
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
     "node_modules/pretty-format": {
       "version": "29.7.0",
       "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-29.7.0.tgz",
@@ -3013,6 +3961,33 @@
         "node": ">= 6"
       }
     },
+    "node_modules/punycode": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
+      "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/queue-microtask": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/queue-microtask/-/queue-microtask-1.2.3.tgz",
+      "integrity": "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ]
+    },
     "node_modules/react-is": {
       "version": "18.2.0",
       "resolved": "https://registry.npmjs.org/react-is/-/react-is-18.2.0.tgz",
@@ -3042,6 +4017,37 @@
       "resolved": "https://registry.npmjs.org/require-main-filename/-/require-main-filename-2.0.0.tgz",
       "integrity": "sha512-NKN5kMDylKuldxYLSUfrbo5Tuzh4hd+2E8NPPX02mZtn1VuREQToYe/ZdlJy+J3uCpfaiGF05e7B8W0iXbQHmg=="
     },
+    "node_modules/resolve-from": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz",
+      "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/reusify": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/reusify/-/reusify-1.0.4.tgz",
+      "integrity": "sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==",
+      "engines": {
+        "iojs": ">=1.0.0",
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/rimraf": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz",
+      "integrity": "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==",
+      "dependencies": {
+        "glob": "^7.1.3"
+      },
+      "bin": {
+        "rimraf": "bin.js"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
     "node_modules/rollup": {
       "version": "3.29.4",
       "resolved": "https://registry.npmjs.org/rollup/-/rollup-3.29.4.tgz",
@@ -3057,6 +4063,28 @@
         "fsevents": "~2.3.2"
       }
     },
+    "node_modules/run-parallel": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/run-parallel/-/run-parallel-1.2.0.tgz",
+      "integrity": "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "dependencies": {
+        "queue-microtask": "^1.2.2"
+      }
+    },
     "node_modules/set-blocking": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz",
@@ -3155,6 +4183,17 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/strip-json-comments": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz",
+      "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==",
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/strip-literal": {
       "version": "1.3.0",
       "resolved": "https://registry.npmjs.org/strip-literal/-/strip-literal-1.3.0.tgz",
@@ -3166,6 +4205,22 @@
         "url": "https://github.com/sponsors/antfu"
       }
     },
+    "node_modules/supports-color": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
+      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+      "dependencies": {
+        "has-flag": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/text-table": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/text-table/-/text-table-0.2.0.tgz",
+      "integrity": "sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw=="
+    },
     "node_modules/tinybench": {
       "version": "2.5.1",
       "resolved": "https://registry.npmjs.org/tinybench/-/tinybench-2.5.1.tgz",
@@ -3203,6 +4258,17 @@
       "resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz",
       "integrity": "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw=="
     },
+    "node_modules/type-check": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.4.0.tgz",
+      "integrity": "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==",
+      "dependencies": {
+        "prelude-ls": "^1.2.1"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
     "node_modules/type-detect": {
       "version": "4.0.8",
       "resolved": "https://registry.npmjs.org/type-detect/-/type-detect-4.0.8.tgz",
@@ -3211,6 +4277,17 @@
         "node": ">=4"
       }
     },
+    "node_modules/type-fest": {
+      "version": "0.20.2",
+      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz",
+      "integrity": "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/typescript": {
       "version": "5.2.2",
       "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.2.2.tgz",
@@ -3233,6 +4310,14 @@
       "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-5.26.5.tgz",
       "integrity": "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA=="
     },
+    "node_modules/uri-js": {
+      "version": "4.4.1",
+      "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz",
+      "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==",
+      "dependencies": {
+        "punycode": "^2.1.0"
+      }
+    },
     "node_modules/util": {
       "version": "0.10.4",
       "resolved": "https://registry.npmjs.org/util/-/util-0.10.4.tgz",
@@ -3496,6 +4581,11 @@
       "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
       "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA=="
     },
+    "node_modules/wrappy": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
+      "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ=="
+    },
     "node_modules/y18n": {
       "version": "5.0.8",
       "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz",
diff --git a/contrib/core-contract-tests/package.json b/contrib/core-contract-tests/package.json
index 3b28c7796f..644fa30e75 100644
--- a/contrib/core-contract-tests/package.json
+++ b/contrib/core-contract-tests/package.json
@@ -4,7 +4,8 @@
   "description": "Run unit tests on this project.",
   "private": true,
   "scripts": {
-    "test": "vitest run -- --coverage"
+    "test": "vitest run -- --coverage",
+    "genhtml": "genhtml lcov.info --branch-coverage -o coverage/"
   },
   "author": "",
   "license": "ISC",
@@ -12,7 +13,7 @@
     "@hirosystems/clarinet-sdk": "^1.1.0",
     "@stacks/transactions": "^6.9.0",
     "chokidar-cli": "^3.0.0",
-    "clarunit": "github:MarvinJanssen/clarunit#a5c042a",
+    "@stacks/clarunit": "0.0.1",
     "typescript": "^5.2.2",
     "vite": "^4.4.9",
     "vitest": "^0.34.4",
diff --git a/contrib/core-contract-tests/tests/clarunit.test.ts b/contrib/core-contract-tests/tests/clarunit.test.ts
index 6601ac3b33..5e4fa0da43 100644
--- a/contrib/core-contract-tests/tests/clarunit.test.ts
+++ b/contrib/core-contract-tests/tests/clarunit.test.ts
@@ -1,2 +1,2 @@
-import { clarunit } from "clarunit";
+import { clarunit } from "@stacks/clarunit";
 clarunit(simnet);
diff --git a/contrib/core-contract-tests/tests/pox_4_test.clar b/contrib/core-contract-tests/tests/pox_4_test.clar
new file mode 100644
index 0000000000..dedd0c5d97
--- /dev/null
+++ b/contrib/core-contract-tests/tests/pox_4_test.clar
@@ -0,0 +1,123 @@
+(define-public (test-burn-height-to-reward-cycle)
+	(begin 
+		(asserts! (is-eq u2 (contract-call? .pox-4 burn-height-to-reward-cycle u2100)) (err "Burn height 2100 should have been reward cycle 2"))
+		(ok true)))
+
+(define-public (test-reward-cycle-to-burn-height)
+	(begin 
+		(asserts! (is-eq u10500 (contract-call? .pox-4 reward-cycle-to-burn-height u10)) (err "Cycle 10 height should have been at burn height 10500"))
+		(ok true)))
+
+(define-public (test-get-stacker-info-none)
+	(begin 
+		(asserts! (is-none (contract-call? .pox-4 get-stacker-info tx-sender)) (err "By default, tx-sender should not have stacker info"))
+		(ok true)))
+
+
+(define-private (check-pox-addr-version-iter (input (buff 1)))
+	(contract-call? .pox-4 check-pox-addr-version input)
+)
+
+(define-public (test-check-pox-addr-version)
+	(begin
+		(asserts! (is-eq (map check-pox-addr-version-iter byte-list)
+			(list
+				true  true  true  true  true  true  true  false false false false false false false false false
+				false false false false false false false false false false false false false false false false
+				false false false false false false false false false false false false false false false false
+				false false false false false false false false false false false false false false false false
+				false false false false false false false false false false false false false false false false
+				false false false false false false false false false false false false false false false false
+				false false false false false false false false false false false false false false false false
+				false false false false false false false false false false false false false false false false
+				false false false false false false false false false false false false false false false false
+				false false false false false false false false false false false false false false false false
+				false false false false false false false false false false false false false false false false
+				false false false false false false false false false false false false false false false false
+				false false false false false false false false false false false false false false false false
+				false false false false false false false false false false false false false false false false
+				false false false false false false false false false false false false false false false false
+				false false false false false false false false false false false false false false false false
+			))
+			(err "Only the first 6 versions should be valid")
+		)
+		(ok true)
+	)
+)
+
+(define-private (check-pox-addr-hashbytes-iter (test-length uint) (version (buff 1)))
+	(contract-call? .pox-4 check-pox-addr-hashbytes version (unwrap-panic (as-max-len? (unwrap-panic (slice? byte-list u0 test-length)) u32)))
+)
+
+(define-public (test-invalid-pox-addr-hashbytes-length)
+	(let (
+		(test-lengths (list u0 u1 u2 u3 u4 u5 u6 u7 u8 u9 u10 u11 u12 u13 u14 u15 u16 u17 u18 u19 u20 u21 u22 u23 u24 u25 u26 u27 u28 u29 u30 u31 u32))
+		(length-20-valid (list
+			false false false false false false false false false false false false false false false false
+			false false false false true  false false false false false false false false false false false false
+			))
+		(length-32-valid (list
+			false false false false false false false false false false false false false false false false
+			false false false false false false false false false false false false false false false false true
+			))
+		(length-all-invalid (list
+			false false false false false false false false false false false false false false false false
+			false false false false false false false false false false false false false false false false false
+			))
+		)
+		(asserts! (is-eq (map check-pox-addr-hashbytes-iter test-lengths (buff-repeat 0x00 (len test-lengths))) length-20-valid)
+			(err "Only length 20 should be valid for version 0x00")
+		)
+		(asserts! (is-eq (map check-pox-addr-hashbytes-iter test-lengths (buff-repeat 0x01 (len test-lengths))) length-20-valid)
+			(err "Only length 20 should be valid for version 0x01")
+		)
+		(asserts! (is-eq (map check-pox-addr-hashbytes-iter test-lengths (buff-repeat 0x02 (len test-lengths))) length-20-valid)
+			(err "Only length 20 should be valid for version 0x02")
+		)
+		(asserts! (is-eq (map check-pox-addr-hashbytes-iter test-lengths (buff-repeat 0x03 (len test-lengths))) length-20-valid)
+			(err "Only length 20 should be valid for version 0x03")
+		)
+		(asserts! (is-eq (map check-pox-addr-hashbytes-iter test-lengths (buff-repeat 0x04 (len test-lengths))) length-20-valid)
+			(err "Only length 20 should be valid for version 0x04")
+		)
+		(asserts! (is-eq (map check-pox-addr-hashbytes-iter test-lengths (buff-repeat 0x05 (len test-lengths))) length-32-valid)
+			(err "Only length 20 should be valid for version 0x05")
+		)
+		(asserts! (is-eq (map check-pox-addr-hashbytes-iter test-lengths (buff-repeat 0x06 (len test-lengths))) length-32-valid)
+			(err "Only length 20 should be valid for version 0x06")
+		)
+		(asserts! (is-eq (map check-pox-addr-hashbytes-iter test-lengths (buff-repeat 0x07 (len test-lengths))) length-all-invalid)
+			(err "No length should be valid for version 0x07")
+		)
+		(ok true)
+	)
+)
+
+(define-public (test-invalid-lock-height-too-low)
+	(let
+		((actual (contract-call? .pox-4 check-pox-lock-period u0)))
+		(asserts! (not actual) (err u111))
+		(ok true)))
+
+(define-public (test-invalid-lock-height-too-high)
+	(let
+		((actual (contract-call? .pox-4 check-pox-lock-period u13)))
+		(asserts! (not actual) (err u111))
+		(ok true)))
+
+(define-public (test-get-total-ustx-stacked)
+	(begin 
+		;; @continue
+		(asserts! (is-eq (contract-call? .pox-4 get-total-ustx-stacked u1) u0) (err u111))
+		(ok true)))
+
+
+(define-private (repeat-iter (a (buff 1)) (repeat {i: (buff 1), o: (buff 33)}))
+	{i: (get i repeat), o: (unwrap-panic (as-max-len? (concat (get i repeat) (get o repeat)) u33))}
+)
+
+(define-read-only (buff-repeat (repeat (buff 1)) (times uint))
+	(get o (fold repeat-iter (unwrap-panic (slice? byte-list u0 times)) {i: repeat, o: 0x}))
+)
+
+(define-constant byte-list 0x000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435363738393a3b3c3d3e3f404142434445464748494a4b4c4d4e4f505152535455565758595a5b5c5d5e5f606162636465666768696a6b6c6d6e6f707172737475767778797a7b7c7d7e7f808182838485868788898a8b8c8d8e8f909192939495969798999a9b9c9d9e9fa0a1a2a3a4a5a6a7a8a9aaabacadaeafb0b1b2b3b4b5b6b7b8b9babbbcbdbebfc0c1c2c3c4c5c6c7c8c9cacbcccdcecfd0d1d2d3d4d5d6d7d8d9dadbdcdddedfe0e1e2e3e4e5e6e7e8e9eaebecedeeeff0f1f2f3f4f5f6f7f8f9fafbfcfdfeff)
\ No newline at end of file
diff --git a/contrib/core-contract-tests/tests/pox_4_tests.clar b/contrib/core-contract-tests/tests/pox_4_tests.clar
deleted file mode 100644
index d4ecea8721..0000000000
--- a/contrib/core-contract-tests/tests/pox_4_tests.clar
+++ /dev/null
@@ -1,59 +0,0 @@
-(define-constant mock-pox-reward-wallet-1 { version: 0x06, hashbytes: 0x0011223344556699001122334455669900112233445566990011223344556699 })
-(define-constant mock-pox-reward-wallet-invalid { version: 0x06, hashbytes: 0x00112233445566990011223344556699001122334455669900112233445566 })
-(define-constant mock-pox-hashbytes-invalid 0x00112233445566990011223344556699001122334455669900112233445566)
-
-(define-public (test-mock-set-stx-account)
-	(begin 
-		(unwrap! (contract-call? .pox-4 mock-set-stx-account 'ST1SJ3DTE5DN7X54YDH5D64R3BCB6A2AG2ZQ8YPD5 {locked: u1, unlock-height: u2100, unlocked: u0}) (err u111))
-		(asserts! (is-eq u1 (get locked (contract-call? .pox-4 get-stx-account 'ST1SJ3DTE5DN7X54YDH5D64R3BCB6A2AG2ZQ8YPD5))) (err u112))
-		(ok true)))
-
-(define-public (test-get-mocked-stx-account)
-	(begin 
-		(asserts! (is-eq u0 (get unlock-height (contract-call? .pox-4 get-stx-account 'ST1SJ3DTE5DN7X54YDH5D64R3BCB6A2AG2ZQ8YPD5))) (err u111))
-		(ok true)))
-
-(define-public (test-burn-height-to-reward-cycle)
-	(begin 
-		(asserts! (is-eq u1 (contract-call? .pox-4 burn-height-to-reward-cycle u2099)) (err u111))
-		(ok true)))
-
-(define-public (test-reward-cycle-to-burn-height)
-	(begin 
-		(asserts! (is-eq u0 (contract-call? .pox-4 reward-cycle-to-burn-height u0)) (err u111))
-		(ok true)))
-
-(define-public (test-get-stacker-info-none)
-	(begin 
-		(asserts! (is-none (contract-call? .pox-4 get-stacker-info tx-sender)) (err u111))
-		(ok true)))
-
-(define-public (test-invalid-pox-addr-version)
-	(let
-		((actual (contract-call? .pox-4 check-pox-addr-version 0x07))) 
-		(asserts! (not actual) (err u111))
-		(ok true)))
-
-(define-public (test-invalid-pox-addr-hashbytes-length)
-	(let
-		((actual (contract-call? .pox-4 check-pox-addr-hashbytes 0x00 mock-pox-hashbytes-invalid))) 
-		(asserts! (not actual) (err u111))
-		(ok true)))
-
-(define-public (test-invalid-lock-height-too-low)
-	(let
-		((actual (contract-call? .pox-4 check-pox-lock-period u0)))
-		(asserts! (not actual) (err u111))
-		(ok true)))
-
-(define-public (test-invalid-lock-height-too-high)
-	(let
-		((actual (contract-call? .pox-4 check-pox-lock-period u13)))
-		(asserts! (not actual) (err u111))
-		(ok true)))
-
-(define-public (test-get-total-ustx-stacked)
-	(begin 
-		;; @continue
-		(asserts! (is-eq (contract-call? .pox-4 get-total-ustx-stacked u1) u0) (err u111))
-		(ok true)))
\ No newline at end of file
diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index 53378fb9db..d54f3b8d5f 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -75,7 +75,6 @@
 
 ;; SIP18 message prefix
 (define-constant SIP018_MSG_PREFIX 0x534950303138)
-(define-constant STACKING_THRESHOLD_100 (if is-in-mainnet u5000 u2000))
 
 ;; Data vars that store a copy of the burnchain configuration.
 ;; Implemented as data-vars, so that different configurations can be
@@ -86,20 +85,6 @@
 (define-data-var configured bool false)
 (define-data-var first-pox-4-reward-cycle uint u0)
 
-
-;; MOCK
-;; Allow to set stx-account details for any user
-;; These values are used for PoX only
-(define-map mock-stx-account-details principal {unlocked: uint, locked: uint, unlock-height: uint})
-
-(define-read-only (get-stx-account (user principal))
-    (default-to (stx-account user) (map-get? mock-stx-account-details user)))
-
-(define-public (mock-set-stx-account (user principal) (details {unlocked: uint, locked: uint, unlock-height: uint}))
-    (if (map-set mock-stx-account-details user details)
-         (ok true) (err u9999))) ;; define manually the error type
-;; MOCK END
-
 ;; This function can only be called once, when it boots up
 (define-public (set-burnchain-parameters (first-burn-height uint)
                                          (prepare-cycle-length uint)

From f502020bea657c887b61cd436aeee8ebef12357b Mon Sep 17 00:00:00 2001
From: Marzi <marzi@trustmachines.co>
Date: Wed, 14 Feb 2024 14:54:49 -0500
Subject: [PATCH 0939/1166] Delete UserBurnSupportOp definition and usage

---
 stackslib/src/burnchains/burnchain.rs         |  44 +-
 stackslib/src/burnchains/tests/burnchain.rs   | 169 +---
 stackslib/src/burnchains/tests/mod.rs         |  23 +-
 .../src/chainstate/burn/db/processing.rs      |  10 -
 stackslib/src/chainstate/burn/db/sortdb.rs    | 315 +------
 stackslib/src/chainstate/burn/distribution.rs | 316 +------
 stackslib/src/chainstate/burn/mod.rs          |   3 -
 .../burn/operations/leader_block_commit.rs    |   2 +-
 .../burn/operations/leader_key_register.rs    |   3 +-
 .../src/chainstate/burn/operations/mod.rs     |  43 -
 .../burn/operations/user_burn_support.rs      | 789 ------------------
 stackslib/src/chainstate/burn/sortition.rs    |   3 +-
 .../src/chainstate/nakamoto/tests/node.rs     |   2 +-
 stackslib/src/chainstate/stacks/db/blocks.rs  |  39 -
 .../src/chainstate/stacks/tests/accounting.rs |   2 +-
 .../stacks/tests/block_construction.rs        |   2 +-
 .../stacks/tests/chain_histories.rs           |   2 +-
 stackslib/src/chainstate/stacks/tests/mod.rs  |   2 +-
 stackslib/src/net/mod.rs                      |   4 -
 .../burnchains/bitcoin_regtest_controller.rs  |  18 +-
 .../src/burnchains/mocknet_controller.rs      |  17 +-
 testnet/stacks-node/src/chain_data.rs         |   3 -
 22 files changed, 31 insertions(+), 1780 deletions(-)
 delete mode 100644 stackslib/src/chainstate/burn/operations/user_burn_support.rs

diff --git a/stackslib/src/burnchains/burnchain.rs b/stackslib/src/burnchains/burnchain.rs
index 532a6842c3..d5f33a5ea7 100644
--- a/stackslib/src/burnchains/burnchain.rs
+++ b/stackslib/src/burnchains/burnchain.rs
@@ -55,7 +55,7 @@ use crate::chainstate::burn::distribution::BurnSamplePoint;
 use crate::chainstate::burn::operations::leader_block_commit::MissedBlockCommit;
 use crate::chainstate::burn::operations::{
     BlockstackOperationType, DelegateStxOp, LeaderBlockCommitOp, LeaderKeyRegisterOp, PreStxOp,
-    StackStxOp, TransferStxOp, UserBurnSupportOp,
+    StackStxOp, TransferStxOp,
 };
 use crate::chainstate::burn::{BlockSnapshot, Opcodes};
 use crate::chainstate::coordinator::comm::CoordinatorChannels;
@@ -101,14 +101,13 @@ impl BurnchainStateTransition {
         block_ops: &Vec<BlockstackOperationType>,
         missed_commits: &[MissedBlockCommit],
     ) -> Result<BurnchainStateTransition, burnchain_error> {
-        // block commits and support burns discovered in this block.
+        // block commits discovered in this block.
         let mut block_commits: Vec<LeaderBlockCommitOp> = vec![];
         let mut accepted_ops = Vec::with_capacity(block_ops.len());
 
         assert!(Burnchain::ops_are_sorted(block_ops));
 
-        // identify which user burns and block commits are consumed and which are not
-        let mut all_user_burns: HashMap<Txid, UserBurnSupportOp> = HashMap::new();
+        // identify which block commits are consumed and which are not
         let mut all_block_commits: HashMap<Txid, LeaderBlockCommitOp> = HashMap::new();
 
         // accept all leader keys we found.
@@ -136,11 +135,6 @@ impl BurnchainStateTransition {
                     all_block_commits.insert(op.txid.clone(), op.clone());
                     block_commits.push(op.clone());
                 }
-                BlockstackOperationType::UserBurnSupport(ref op) => {
-                    // we don't know yet which user burns are going to be accepted until we have
-                    // the burn distribution, so just account for them for now.
-                    all_user_burns.insert(op.txid.clone(), op.clone());
-                }
             };
         }
 
@@ -254,7 +248,7 @@ impl BurnchainStateTransition {
         );
         BurnSamplePoint::prometheus_update_miner_commitments(&burn_dist);
 
-        // find out which user burns and block commits we're going to take
+        // find out which block commits we're going to take
         for i in 0..burn_dist.len() {
             let burn_point = &burn_dist[i];
 
@@ -263,18 +257,10 @@ impl BurnchainStateTransition {
                 burn_point.candidate.clone(),
             ));
             all_block_commits.remove(&burn_point.candidate.txid);
-
-            // taking each user burn in this sample point
-            for j in 0..burn_point.user_burns.len() {
-                accepted_ops.push(BlockstackOperationType::UserBurnSupport(
-                    burn_point.user_burns[j].clone(),
-                ));
-                all_user_burns.remove(&burn_point.user_burns[j].txid);
-            }
         }
 
-        // accepted_ops contains all accepted commits and user burns now.
-        // only rejected ones remain in all_user_burns and all_block_commits
+        // accepted_ops contains all accepted commits now.
+        // only rejected ones remain in all_block_commits
         for op in all_block_commits.values() {
             warn!(
                 "REJECTED({}) block commit {} at {},{}: Committed to an already-consumed VRF key",
@@ -282,10 +268,6 @@ impl BurnchainStateTransition {
             );
         }
 
-        for op in all_user_burns.values() {
-            warn!("REJECTED({}) user burn support {} at {},{}: No matching block commit in this block", op.block_height, &op.txid, op.block_height, op.vtxindex);
-        }
-
         accepted_ops.sort_by(|ref a, ref b| a.vtxindex().partial_cmp(&b.vtxindex()).unwrap());
 
         Ok(BurnchainStateTransition {
@@ -759,20 +741,6 @@ impl Burnchain {
                     }
                 }
             }
-            x if x == Opcodes::UserBurnSupport as u8 => {
-                match UserBurnSupportOp::from_tx(block_header, burn_tx) {
-                    Ok(op) => Some(BlockstackOperationType::UserBurnSupport(op)),
-                    Err(e) => {
-                        warn!(
-                            "Failed to parse user burn support tx";
-                            "txid" => %burn_tx.txid(),
-                            "data" => %to_hex(&burn_tx.data()),
-                            "error" => ?e,
-                        );
-                        None
-                    }
-                }
-            }
             x if x == Opcodes::PreStx as u8 => {
                 match PreStxOp::from_tx(
                     block_header,
diff --git a/stackslib/src/burnchains/tests/burnchain.rs b/stackslib/src/burnchains/tests/burnchain.rs
index 18b24413ec..c73543cb48 100644
--- a/stackslib/src/burnchains/tests/burnchain.rs
+++ b/stackslib/src/burnchains/tests/burnchain.rs
@@ -38,7 +38,7 @@ use crate::chainstate::burn::db::sortdb::{SortitionDB, SortitionHandleTx};
 use crate::chainstate::burn::distribution::BurnSamplePoint;
 use crate::chainstate::burn::operations::leader_block_commit::BURN_BLOCK_MINED_AT_MODULUS;
 use crate::chainstate::burn::operations::{
-    BlockstackOperationType, LeaderBlockCommitOp, LeaderKeyRegisterOp, UserBurnSupportOp,
+    BlockstackOperationType, LeaderBlockCommitOp, LeaderKeyRegisterOp,
 };
 use crate::chainstate::burn::{
     BlockSnapshot, ConsensusHash, ConsensusHashExtensions, OpsHash, SortitionHash,
@@ -151,170 +151,6 @@ fn test_process_block_ops() {
         burn_header_hash: block_121_hash.clone(),
     };
 
-    let user_burn_1 = UserBurnSupportOp {
-        address: StacksAddress::new(1, Hash160([1u8; 20])),
-        consensus_hash: ConsensusHash::from_bytes(
-            &hex_bytes("0000000000000000000000000000000000000000").unwrap(),
-        )
-        .unwrap(),
-        public_key: VRFPublicKey::from_bytes(
-            &hex_bytes("a366b51292bef4edd64063d9145c617fec373bceb0758e98cd72becd84d54c7a").unwrap(),
-        )
-        .unwrap(),
-        block_header_hash_160: Hash160::from_bytes(
-            &hex_bytes("7150f635054b87df566a970b21e07030d6444bf2").unwrap(),
-        )
-        .unwrap(), // 22222....2222
-        key_block_ptr: 123,
-        key_vtxindex: 456,
-        burn_fee: 10000,
-
-        txid: Txid::from_bytes(
-            &hex_bytes("1d5cbdd276495b07f0e0bf0181fa57c175b217bc35531b078d62fc20986c716b").unwrap(),
-        )
-        .unwrap(),
-        vtxindex: 13,
-        block_height: 124,
-        burn_header_hash: block_124_hash_initial.clone(),
-    };
-
-    let user_burn_1_2 = UserBurnSupportOp {
-        address: StacksAddress::new(2, Hash160([2u8; 20])),
-        consensus_hash: ConsensusHash::from_bytes(
-            &hex_bytes("0000000000000000000000000000000000000000").unwrap(),
-        )
-        .unwrap(),
-        public_key: VRFPublicKey::from_bytes(
-            &hex_bytes("a366b51292bef4edd64063d9145c617fec373bceb0758e98cd72becd84d54c7a").unwrap(),
-        )
-        .unwrap(),
-        block_header_hash_160: Hash160::from_bytes(
-            &hex_bytes("7150f635054b87df566a970b21e07030d6444bf2").unwrap(),
-        )
-        .unwrap(), // 22222....2222
-        key_block_ptr: 123,
-        key_vtxindex: 456,
-        burn_fee: 30000,
-
-        txid: Txid::from_bytes(
-            &hex_bytes("1d5cbdd276495b07f0e0bf0181fa57c175b217bc35531b078d62fc20986c716c").unwrap(),
-        )
-        .unwrap(),
-        vtxindex: 14,
-        block_height: 124,
-        burn_header_hash: block_124_hash_initial.clone(),
-    };
-
-    let user_burn_2 = UserBurnSupportOp {
-        address: StacksAddress::new(3, Hash160([3u8; 20])),
-        consensus_hash: ConsensusHash::from_bytes(
-            &hex_bytes("0000000000000000000000000000000000000000").unwrap(),
-        )
-        .unwrap(),
-        public_key: VRFPublicKey::from_bytes(
-            &hex_bytes("bb519494643f79f1dea0350e6fb9a1da88dfdb6137117fc2523824a8aa44fe1c").unwrap(),
-        )
-        .unwrap(),
-        block_header_hash_160: Hash160::from_bytes(
-            &hex_bytes("037a1e860899a4fa823c18b66f6264d20236ec58").unwrap(),
-        )
-        .unwrap(), // 22222....2223
-        key_block_ptr: 122,
-        key_vtxindex: 457,
-        burn_fee: 20000,
-
-        txid: Txid::from_bytes(
-            &hex_bytes("1d5cbdd276495b07f0e0bf0181fa57c175b217bc35531b078d62fc20986c716d").unwrap(),
-        )
-        .unwrap(),
-        vtxindex: 15,
-        block_height: 124,
-        burn_header_hash: block_124_hash_initial.clone(),
-    };
-
-    let user_burn_2_2 = UserBurnSupportOp {
-        address: StacksAddress::new(4, Hash160([4u8; 20])),
-        consensus_hash: ConsensusHash::from_bytes(
-            &hex_bytes("0000000000000000000000000000000000000000").unwrap(),
-        )
-        .unwrap(),
-        public_key: VRFPublicKey::from_bytes(
-            &hex_bytes("bb519494643f79f1dea0350e6fb9a1da88dfdb6137117fc2523824a8aa44fe1c").unwrap(),
-        )
-        .unwrap(),
-        block_header_hash_160: Hash160::from_bytes(
-            &hex_bytes("037a1e860899a4fa823c18b66f6264d20236ec58").unwrap(),
-        )
-        .unwrap(), // 22222....2223
-        key_block_ptr: 122,
-        key_vtxindex: 457,
-        burn_fee: 40000,
-
-        txid: Txid::from_bytes(
-            &hex_bytes("1d5cbdd276495b07f0e0bf0181fa57c175b217bc35531b078d62fc20986c716e").unwrap(),
-        )
-        .unwrap(),
-        vtxindex: 16,
-        block_height: 124,
-        burn_header_hash: block_124_hash_initial.clone(),
-    };
-
-    // should be rejected
-    let user_burn_noblock = UserBurnSupportOp {
-        address: StacksAddress::new(5, Hash160([5u8; 20])),
-        consensus_hash: ConsensusHash::from_bytes(
-            &hex_bytes("0000000000000000000000000000000000000000").unwrap(),
-        )
-        .unwrap(),
-        public_key: VRFPublicKey::from_bytes(
-            &hex_bytes("a366b51292bef4edd64063d9145c617fec373bceb0758e98cd72becd84d54c7a").unwrap(),
-        )
-        .unwrap(),
-        block_header_hash_160: Hash160::from_bytes(
-            &hex_bytes("3333333333333333333333333333333333333333").unwrap(),
-        )
-        .unwrap(),
-        key_block_ptr: 122,
-        key_vtxindex: 772,
-        burn_fee: 12345,
-
-        txid: Txid::from_bytes(
-            &hex_bytes("1d5cbdd276495b07f0e0bf0181fa57c175b217bc35531b078d62fc20986c716f").unwrap(),
-        )
-        .unwrap(),
-        vtxindex: 12,
-        block_height: 123,
-        burn_header_hash: block_123_hash.clone(),
-    };
-
-    // should be rejected
-    let user_burn_nokey = UserBurnSupportOp {
-        address: StacksAddress::new(6, Hash160([6u8; 20])),
-        consensus_hash: ConsensusHash::from_bytes(
-            &hex_bytes("0000000000000000000000000000000000000000").unwrap(),
-        )
-        .unwrap(),
-        public_key: VRFPublicKey::from_bytes(
-            &hex_bytes("3f3338db51f2b1f6ac0cf6177179a24ee130c04ef2f9849a64a216969ab60e70").unwrap(),
-        )
-        .unwrap(),
-        block_header_hash_160: Hash160::from_bytes(
-            &hex_bytes("037a1e860899a4fa823c18b66f6264d20236ec58").unwrap(),
-        )
-        .unwrap(),
-        key_block_ptr: 122,
-        key_vtxindex: 457,
-        burn_fee: 12345,
-
-        txid: Txid::from_bytes(
-            &hex_bytes("1d5cbdd276495b07f0e0bf0181fa57c175b217bc35531b078d62fc20986c7170").unwrap(),
-        )
-        .unwrap(),
-        vtxindex: 15,
-        block_height: 123,
-        burn_header_hash: block_123_hash.clone(),
-    };
-
     let block_commit_1 = LeaderBlockCommitOp {
         sunset_burn: 0,
         commit_outs: vec![],
@@ -525,8 +361,6 @@ fn test_process_block_ops() {
     };
 
     let block_ops_123 = vec![
-        BlockstackOperationType::UserBurnSupport(user_burn_noblock.clone()),
-        BlockstackOperationType::UserBurnSupport(user_burn_nokey.clone()),
         BlockstackOperationType::LeaderKeyRegister(leader_key_1.clone()),
     ];
     let block_opshash_123 = OpsHash::from_txids(&vec![
@@ -728,7 +562,6 @@ fn test_process_block_ops() {
         let burn_total = block_ops_124.iter().fold(0u64, |mut acc, op| {
             let bf = match op {
                 BlockstackOperationType::LeaderBlockCommit(ref op) => op.burn_fee,
-                BlockstackOperationType::UserBurnSupport(ref op) => 0,
                 _ => 0,
             };
             acc += bf;
diff --git a/stackslib/src/burnchains/tests/mod.rs b/stackslib/src/burnchains/tests/mod.rs
index b65501d129..a63e7a31d4 100644
--- a/stackslib/src/burnchains/tests/mod.rs
+++ b/stackslib/src/burnchains/tests/mod.rs
@@ -523,11 +523,6 @@ impl TestBurnchainBlock {
                     assert_eq!(data.block_height, self.block_height);
                     data.consensus_hash = parent_snapshot.consensus_hash.clone();
                 }
-
-                BlockstackOperationType::UserBurnSupport(ref mut data) => {
-                    assert_eq!(data.block_height, self.block_height);
-                    data.consensus_hash = parent_snapshot.consensus_hash.clone();
-                }
                 _ => {}
             }
         }
@@ -789,7 +784,6 @@ fn process_next_sortition(
     BlockSnapshot,
     Vec<LeaderKeyRegisterOp>,
     Vec<LeaderBlockCommitOp>,
-    Vec<UserBurnSupportOp>,
 ) {
     assert_eq!(miners.len(), block_hashes.len());
 
@@ -834,8 +828,7 @@ fn process_next_sortition(
     fork.append_block(block);
     let tip_snapshot = node.mine_fork(fork);
 
-    // TODO: user burn support
-    (tip_snapshot, next_prev_keys, next_commits, vec![])
+    (tip_snapshot, next_prev_keys, next_commits)
 }
 
 fn verify_keys_accepted(node: &mut TestBurnchainNode, prev_keys: &Vec<LeaderKeyRegisterOp>) -> () {
@@ -909,7 +902,7 @@ fn mine_10_stacks_blocks_1_fork() {
             next_block_hashes.push(hash);
         }
 
-        let (next_snapshot, mut next_prev_keys, next_block_commits, next_user_burns) =
+        let (next_snapshot, mut next_prev_keys, next_block_commits) =
             process_next_sortition(
                 &mut node,
                 &mut fork,
@@ -958,7 +951,7 @@ fn mine_10_stacks_blocks_2_forks_disjoint() {
             next_block_hashes.push(hash);
         }
 
-        let (next_snapshot, mut next_prev_keys, next_block_commits, next_user_burns) =
+        let (next_snapshot, mut next_prev_keys, next_block_commits) =
             process_next_sortition(
                 &mut node,
                 &mut fork_1,
@@ -1011,7 +1004,7 @@ fn mine_10_stacks_blocks_2_forks_disjoint() {
             next_block_hashes_2.push(hash);
         }
 
-        let (next_snapshot_1, mut next_prev_keys_1, next_block_commits_1, next_user_burns_1) =
+        let (next_snapshot_1, mut next_prev_keys_1, next_block_commits_1) =
             process_next_sortition(
                 &mut node,
                 &mut fork_1,
@@ -1019,7 +1012,7 @@ fn mine_10_stacks_blocks_2_forks_disjoint() {
                 &prev_keys_1,
                 &next_block_hashes_1,
             );
-        let (next_snapshot_2, mut next_prev_keys_2, next_block_commits_2, next_user_burns_2) =
+        let (next_snapshot_2, mut next_prev_keys_2, next_block_commits_2) =
             process_next_sortition(
                 &mut node,
                 &mut fork_2,
@@ -1076,7 +1069,7 @@ fn mine_10_stacks_blocks_2_forks_disjoint_same_blocks() {
             next_block_hashes.push(hash);
         }
 
-        let (snapshot, mut next_prev_keys, next_block_commits, next_user_burns) =
+        let (snapshot, mut next_prev_keys, next_block_commits) =
             process_next_sortition(
                 &mut node,
                 &mut fork_1,
@@ -1131,7 +1124,7 @@ fn mine_10_stacks_blocks_2_forks_disjoint_same_blocks() {
             next_block_hashes_2.push(hash);
         }
 
-        let (snapshot_1, mut next_prev_keys_1, next_block_commits_1, next_user_burns_1) =
+        let (snapshot_1, mut next_prev_keys_1, next_block_commits_1) =
             process_next_sortition(
                 &mut node,
                 &mut fork_1,
@@ -1139,7 +1132,7 @@ fn mine_10_stacks_blocks_2_forks_disjoint_same_blocks() {
                 &prev_keys_1,
                 &next_block_hashes_1,
             );
-        let (snapshot_2, mut next_prev_keys_2, next_block_commits_2, next_user_burns_2) =
+        let (snapshot_2, mut next_prev_keys_2, next_block_commits_2) =
             process_next_sortition(
                 &mut node,
                 &mut fork_2,
diff --git a/stackslib/src/chainstate/burn/db/processing.rs b/stackslib/src/chainstate/burn/db/processing.rs
index 0c899770d4..dadfcdba71 100644
--- a/stackslib/src/chainstate/burn/db/processing.rs
+++ b/stackslib/src/chainstate/burn/db/processing.rs
@@ -68,15 +68,6 @@ impl<'a> SortitionHandleTx<'a> {
                     BurnchainError::OpError(e)
                 })
             }
-            BlockstackOperationType::UserBurnSupport(ref op) => {
-                op.check(burnchain, self).map_err(|e| {
-                    warn!(
-                        "REJECTED({}) user burn support {} at {},{}: {:?}",
-                        op.block_height, &op.txid, op.block_height, op.vtxindex, &e
-                    );
-                    BurnchainError::OpError(e)
-                })
-            }
             BlockstackOperationType::StackStx(ref op) => op.check().map_err(|e| {
                 warn!(
                     "REJECTED({}) stack stx op {} at {},{}: {:?}",
@@ -138,7 +129,6 @@ impl<'a> SortitionHandleTx<'a> {
             .try_fold(0u64, |acc, op| {
                 let bf = match op {
                     BlockstackOperationType::LeaderBlockCommit(ref op) => op.burn_fee,
-                    BlockstackOperationType::UserBurnSupport(ref op) => op.burn_fee,
                     _ => 0,
                 };
                 acc.checked_add(bf)
diff --git a/stackslib/src/chainstate/burn/db/sortdb.rs b/stackslib/src/chainstate/burn/db/sortdb.rs
index f03a7b9ad9..7c009d2b55 100644
--- a/stackslib/src/chainstate/burn/db/sortdb.rs
+++ b/stackslib/src/chainstate/burn/db/sortdb.rs
@@ -59,7 +59,7 @@ use crate::chainstate::burn::operations::leader_block_commit::{
 };
 use crate::chainstate::burn::operations::{
     BlockstackOperationType, DelegateStxOp, LeaderBlockCommitOp, LeaderKeyRegisterOp, PreStxOp,
-    StackStxOp, TransferStxOp, UserBurnSupportOp,
+    StackStxOp, TransferStxOp,
 };
 use crate::chainstate::burn::{
     BlockSnapshot, ConsensusHash, ConsensusHashExtensions, Opcodes, OpsHash, SortitionHash,
@@ -306,44 +306,6 @@ impl FromRow<LeaderBlockCommitOp> for LeaderBlockCommitOp {
     }
 }
 
-impl FromRow<UserBurnSupportOp> for UserBurnSupportOp {
-    fn from_row<'a>(row: &'a Row) -> Result<UserBurnSupportOp, db_error> {
-        let txid = Txid::from_column(row, "txid")?;
-        let vtxindex: u32 = row.get_unwrap("vtxindex");
-        let block_height = u64::from_column(row, "block_height")?;
-        let burn_header_hash = BurnchainHeaderHash::from_column(row, "burn_header_hash")?;
-
-        let address = StacksAddress::from_column(row, "address")?;
-        let consensus_hash = ConsensusHash::from_column(row, "consensus_hash")?;
-        let public_key = VRFPublicKey::from_column(row, "public_key")?;
-        let key_block_ptr: u32 = row.get_unwrap("key_block_ptr");
-        let key_vtxindex: u16 = row.get_unwrap("key_vtxindex");
-        let block_header_hash_160 = Hash160::from_column(row, "block_header_hash_160")?;
-
-        let burn_fee_str: String = row.get_unwrap("burn_fee");
-
-        let burn_fee = burn_fee_str
-            .parse::<u64>()
-            .map_err(|_e| db_error::ParseError)?;
-
-        let user_burn = UserBurnSupportOp {
-            address: address,
-            consensus_hash: consensus_hash,
-            public_key: public_key,
-            key_block_ptr: key_block_ptr,
-            key_vtxindex: key_vtxindex,
-            block_header_hash_160: block_header_hash_160,
-            burn_fee: burn_fee,
-
-            txid: txid,
-            vtxindex: vtxindex,
-            block_height: block_height,
-            burn_header_hash: burn_header_hash,
-        };
-        Ok(user_burn)
-    }
-}
-
 impl FromRow<StackStxOp> for StackStxOp {
     fn from_row<'a>(row: &'a Row) -> Result<StackStxOp, db_error> {
         let txid = Txid::from_column(row, "txid")?;
@@ -590,26 +552,6 @@ const SORTITION_DB_INITIAL_SCHEMA: &'static [&'static str] = &[
         FOREIGN KEY(sortition_id) REFERENCES snapshots(sortition_id)
     );"#,
     r#"
-    CREATE TABLE user_burn_support(
-        txid TEXT NOT NULL,
-        vtxindex INTEGER NOT NULL,
-        block_height INTEGER NOT NULL,
-        burn_header_hash TEXT NOT NULL,
-        sortition_id TEXT NOT NULL,
-
-        address TEXT NOT NULL,
-        consensus_hash TEXT NOT NULL,
-        public_key TEXT NOT NULL,
-        key_block_ptr INTEGER NOT NULL,
-        key_vtxindex INTEGER NOT NULL,
-        block_header_hash_160 TEXT NOT NULL,
-
-        burn_fee TEXT NOT NULL,
-
-        PRIMARY KEY(txid,sortition_id),
-        FOREIGN KEY(sortition_id) REFERENCES snapshots(sortition_id)
-    );"#,
-    r#"
     CREATE TABLE stack_stx (
         txid TEXT NOT NULL,
         vtxindex INTEGER NOT NULL,
@@ -740,9 +682,6 @@ const SORTITION_DB_INDEXES: &'static [&'static str] = &[
     "CREATE INDEX IF NOT EXISTS index_leader_keys_sortition_id_block_height_vtxindex ON leader_keys(sortition_id,block_height,vtxindex);",
     "CREATE INDEX IF NOT EXISTS index_block_commits_sortition_id_vtxindex ON block_commits(sortition_id,vtxindex);",
     "CREATE INDEX IF NOT EXISTS index_block_commits_sortition_id_block_height_vtxindex ON block_commits(sortition_id,block_height,vtxindex);",
-    "CREATE INDEX IF NOT EXISTS index_user_burn_support_txid ON user_burn_support(txid);",
-    "CREATE INDEX IF NOT EXISTS index_user_burn_support_sortition_id_vtxindex ON user_burn_support(sortition_id,vtxindex);",
-    "CREATE INDEX IF NOT EXISTS index_user_burn_support_sortition_id_hash_160_key_vtxindex_key_block_ptr_vtxindex ON user_burn_support(sortition_id,block_header_hash_160,key_vtxindex,key_block_ptr,vtxindex ASC);",
     "CREATE INDEX IF NOT EXISTS index_stack_stx_burn_header_hash ON stack_stx(burn_header_hash);",
     "CREATE INDEX IF NOT EXISTS index_transfer_stx_burn_header_hash ON transfer_stx(burn_header_hash);",
     "CREATE INDEX IF NOT EXISTS index_missed_commits_intended_sortition_id ON missed_commits(intended_sortition_id);",
@@ -2081,64 +2020,6 @@ impl<'a> SortitionHandleConn<'a> {
         SortitionDB::get_ancestor_snapshot(self, block_height, &self.context.chain_tip)
     }
 
-    /// Get all user burns that burned for the winning block in the chain_tip sortition
-    /// Returns list of user burns in order by vtxindex.
-    pub fn get_winning_user_burns_by_block(&self) -> Result<Vec<UserBurnSupportOp>, db_error> {
-        let snapshot = match self.get_tip_snapshot()? {
-            Some(sn) => sn,
-            None => {
-                // no such snapshot, so no such users
-                return Ok(vec![]);
-            }
-        };
-
-        if !snapshot.sortition {
-            // no winner
-            return Ok(vec![]);
-        }
-        let qry = "SELECT * FROM block_commits WHERE sortition_id = ?1 AND txid = ?2";
-        let args: [&dyn ToSql; 2] = [&snapshot.sortition_id, &snapshot.winning_block_txid];
-        let winning_commit: LeaderBlockCommitOp = query_row(self, qry, &args)?
-            .expect("BUG: sortition exists, but winner cannot be found");
-
-        let winning_block_hash160 =
-            Hash160::from_sha256(snapshot.winning_stacks_block_hash.as_bytes());
-
-        let qry = "SELECT * FROM user_burn_support \
-                   WHERE sortition_id = ?1 AND block_header_hash_160 = ?2 AND key_vtxindex = ?3 AND key_block_ptr = ?4 \
-                   ORDER BY vtxindex ASC";
-        let args: [&dyn ToSql; 4] = [
-            &snapshot.sortition_id,
-            &winning_block_hash160,
-            &winning_commit.key_vtxindex,
-            &winning_commit.key_block_ptr,
-        ];
-
-        let mut winning_user_burns: Vec<UserBurnSupportOp> = query_rows(self, qry, &args)?;
-
-        // were there multiple miners with the same VRF key and block header hash? (i.e., are these user burns shared?)
-        let qry = "SELECT COUNT(*) FROM block_commits \
-                   WHERE sortition_id = ?1 AND block_header_hash = ?2 AND key_vtxindex = ?3 AND key_block_ptr = ?4";
-        let args: [&dyn ToSql; 4] = [
-            &snapshot.sortition_id,
-            &snapshot.winning_stacks_block_hash,
-            &winning_commit.key_vtxindex,
-            &winning_commit.key_block_ptr,
-        ];
-        let shared_miners = query_count(self, qry, &args)? as u64;
-
-        assert!(
-            shared_miners >= 1,
-            "BUG: Should be at least 1 matching miner for the winning block commit"
-        );
-
-        for winning_user_burn in winning_user_burns.iter_mut() {
-            winning_user_burn.burn_fee /= shared_miners;
-        }
-
-        Ok(winning_user_burns)
-    }
-
     /// Get the block snapshot of the parent stacks block of the given stacks block.
     /// The returned block-commit is for the given (consensus_hash, block_hash).
     /// The returned BlockSnapshot is for the parent of the block identified by (consensus_hash,
@@ -4727,16 +4608,10 @@ impl SortitionDB {
         conn: &Connection,
         block_snapshot: &BlockSnapshot,
     ) -> Result<u64, db_error> {
-        let user_burns = SortitionDB::get_user_burns_by_block(conn, &block_snapshot.sortition_id)?;
         let block_commits =
             SortitionDB::get_block_commits_by_block(conn, &block_snapshot.sortition_id)?;
         let mut burn_total: u64 = 0;
 
-        for i in 0..user_burns.len() {
-            burn_total = burn_total
-                .checked_add(user_burns[i].burn_fee)
-                .expect("Way too many tokens burned");
-        }
         for i in 0..block_commits.len() {
             burn_total = burn_total
                 .checked_add(block_commits[i].burn_fee)
@@ -4745,18 +4620,6 @@ impl SortitionDB {
         Ok(burn_total)
     }
 
-    /// Get all user burns registered in a block on is fork.
-    /// Returns list of user burns in order by vtxindex.
-    pub fn get_user_burns_by_block(
-        conn: &Connection,
-        sortition: &SortitionId,
-    ) -> Result<Vec<UserBurnSupportOp>, db_error> {
-        let qry = "SELECT * FROM user_burn_support WHERE sortition_id = ?1 ORDER BY vtxindex ASC";
-        let args: &[&dyn ToSql] = &[sortition];
-
-        query_rows(conn, qry, args)
-    }
-
     /// Get all block commitments registered in a block on the burn chain's history in this fork.
     /// Returns the list of block commits in order by vtxindex.
     pub fn get_block_commits_by_block(
@@ -5041,16 +4904,6 @@ impl SortitionDB {
             )));
         }
 
-        // user burn?
-        let user_burn_sql = "SELECT * FROM user_burn_support WHERE txid = ?1 LIMIT 1".to_string();
-
-        let user_burn_res = query_row_panic(conn, &user_burn_sql, &args, || {
-            "Multiple user burns with same txid".to_string()
-        })?;
-        if let Some(user_burn) = user_burn_res {
-            return Ok(Some(BlockstackOperationType::UserBurnSupport(user_burn)));
-        }
-
         Ok(None)
     }
 
@@ -5370,13 +5223,6 @@ impl<'a> SortitionHandleTx<'a> {
                 );
                 self.insert_block_commit(op, sort_id)
             }
-            BlockstackOperationType::UserBurnSupport(ref op) => {
-                info!(
-                    "ACCEPTED({}) user burn support {} at {},{}",
-                    op.block_height, &op.txid, op.block_height, op.vtxindex
-                );
-                self.insert_user_burn(op, sort_id)
-            }
             BlockstackOperationType::StackStx(ref op) => {
                 info!(
                     "ACCEPTED({}) stack stx opt {} at {},{}",
@@ -5570,42 +5416,6 @@ impl<'a> SortitionHandleTx<'a> {
         Ok(())
     }
 
-    /// Insert a user support burn.
-    /// No validity checking will be done, beyond what is encoded in the user_burn_support table
-    /// constraints.  That is, type mismatches and serialization errors will be caught, but nothing
-    /// else.
-    /// The corresponding snapshot must already be inserted
-    fn insert_user_burn(
-        &mut self,
-        user_burn: &UserBurnSupportOp,
-        sort_id: &SortitionId,
-    ) -> Result<(), db_error> {
-        assert!(user_burn.block_height < BLOCK_HEIGHT_MAX);
-
-        // represent burn fee as TEXT
-        let burn_fee_str = format!("{}", user_burn.burn_fee);
-
-        let args: &[&dyn ToSql] = &[
-            &user_burn.txid,
-            &user_burn.vtxindex,
-            &u64_to_sql(user_burn.block_height)?,
-            &user_burn.burn_header_hash,
-            &user_burn.address.to_string(),
-            &user_burn.consensus_hash,
-            &user_burn.public_key.to_hex(),
-            &user_burn.key_block_ptr,
-            &user_burn.key_vtxindex,
-            &user_burn.block_header_hash_160,
-            &burn_fee_str,
-            sort_id,
-        ];
-
-        self.execute("INSERT INTO user_burn_support (txid, vtxindex, block_height, burn_header_hash, address, consensus_hash, public_key, key_block_ptr, key_vtxindex, block_header_hash_160, burn_fee, sortition_id) \
-                      VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12)", args)?;
-
-        Ok(())
-    }
-
     /// Insert a missed block commit
     fn insert_missed_block_commit(&mut self, op: &MissedBlockCommit) -> Result<(), db_error> {
         // serialize tx input to JSON
@@ -6379,7 +6189,7 @@ pub mod tests {
     use crate::burnchains::*;
     use crate::chainstate::burn::operations::leader_block_commit::BURN_BLOCK_MINED_AT_MODULUS;
     use crate::chainstate::burn::operations::{
-        BlockstackOperationType, LeaderBlockCommitOp, LeaderKeyRegisterOp, UserBurnSupportOp,
+        BlockstackOperationType, LeaderBlockCommitOp, LeaderKeyRegisterOp,
     };
     use crate::chainstate::burn::ConsensusHash;
     use crate::chainstate::stacks::index::TrieHashExtension;
@@ -6807,95 +6617,6 @@ pub mod tests {
         }
     }
 
-    #[test]
-    fn test_insert_user_burn() {
-        let block_height = 123;
-        let vtxindex = 456;
-        let first_burn_hash = BurnchainHeaderHash::from_hex(
-            "0000000000000000000000000000000000000000000000000000000000000000",
-        )
-        .unwrap();
-
-        let leader_key = LeaderKeyRegisterOp {
-            consensus_hash: ConsensusHash::from_bytes(
-                &hex_bytes("2222222222222222222222222222222222222222").unwrap(),
-            )
-            .unwrap(),
-            public_key: VRFPublicKey::from_bytes(
-                &hex_bytes("a366b51292bef4edd64063d9145c617fec373bceb0758e98cd72becd84d54c7a")
-                    .unwrap(),
-            )
-            .unwrap(),
-            memo: vec![01, 02, 03, 04, 05],
-
-            txid: Txid::from_bytes_be(
-                &hex_bytes("1bfa831b5fc56c858198acb8e77e5863c1e9d8ac26d49ddb914e24d8d4083562")
-                    .unwrap(),
-            )
-            .unwrap(),
-            vtxindex: vtxindex,
-            block_height: block_height + 1,
-            burn_header_hash: BurnchainHeaderHash([0x01; 32]),
-        };
-
-        let user_burn = UserBurnSupportOp {
-            address: StacksAddress::new(1, Hash160([1u8; 20])),
-            consensus_hash: ConsensusHash::from_bytes(
-                &hex_bytes("2222222222222222222222222222222222222222").unwrap(),
-            )
-            .unwrap(),
-            public_key: VRFPublicKey::from_bytes(
-                &hex_bytes("a366b51292bef4edd64063d9145c617fec373bceb0758e98cd72becd84d54c7a")
-                    .unwrap(),
-            )
-            .unwrap(),
-            block_header_hash_160: Hash160::from_bytes(
-                &hex_bytes("3333333333333333333333333333333333333333").unwrap(),
-            )
-            .unwrap(),
-            key_block_ptr: (block_height + 1) as u32,
-            key_vtxindex: vtxindex as u16,
-            burn_fee: 12345,
-
-            txid: Txid::from_bytes_be(
-                &hex_bytes("1d5cbdd276495b07f0e0bf0181fa57c175b217bc35531b078d62fc20986c716c")
-                    .unwrap(),
-            )
-            .unwrap(),
-            vtxindex: vtxindex,
-            block_height: block_height + 2,
-            burn_header_hash: BurnchainHeaderHash([0x03; 32]),
-        };
-
-        let mut db = SortitionDB::connect_test(block_height, &first_burn_hash).unwrap();
-
-        let snapshot = test_append_snapshot(
-            &mut db,
-            BurnchainHeaderHash([0x01; 32]),
-            &vec![BlockstackOperationType::LeaderKeyRegister(
-                leader_key.clone(),
-            )],
-        );
-
-        let user_burn_snapshot = test_append_snapshot(
-            &mut db,
-            BurnchainHeaderHash([0x03; 32]),
-            &vec![BlockstackOperationType::UserBurnSupport(user_burn.clone())],
-        );
-
-        {
-            let res_user_burns =
-                SortitionDB::get_user_burns_by_block(db.conn(), &user_burn_snapshot.sortition_id)
-                    .unwrap();
-            assert_eq!(res_user_burns.len(), 1);
-            assert_eq!(res_user_burns[0], user_burn);
-
-            let no_user_burns =
-                SortitionDB::get_user_burns_by_block(db.conn(), &snapshot.sortition_id).unwrap();
-            assert_eq!(no_user_burns.len(), 0);
-        }
-    }
-
     #[test]
     fn has_VRF_public_key() {
         let public_key = VRFPublicKey::from_bytes(
@@ -7463,35 +7184,6 @@ pub mod tests {
             burn_header_hash: BurnchainHeaderHash([0x03; 32]),
         };
 
-        let user_burn = UserBurnSupportOp {
-            address: StacksAddress::new(2, Hash160([2u8; 20])),
-            consensus_hash: ConsensusHash::from_bytes(
-                &hex_bytes("2222222222222222222222222222222222222222").unwrap(),
-            )
-            .unwrap(),
-            public_key: VRFPublicKey::from_bytes(
-                &hex_bytes("a366b51292bef4edd64063d9145c617fec373bceb0758e98cd72becd84d54c7a")
-                    .unwrap(),
-            )
-            .unwrap(),
-            block_header_hash_160: Hash160::from_bytes(
-                &hex_bytes("3333333333333333333333333333333333333333").unwrap(),
-            )
-            .unwrap(),
-            key_block_ptr: (block_height + 1) as u32,
-            key_vtxindex: vtxindex as u16,
-            burn_fee: 12345,
-
-            txid: Txid::from_bytes_be(
-                &hex_bytes("1d5cbdd276495b07f0e0bf0181fa57c175b217bc35531b078d62fc20986c716c")
-                    .unwrap(),
-            )
-            .unwrap(),
-            vtxindex: vtxindex + 1,
-            block_height: block_height + 2,
-            burn_header_hash: BurnchainHeaderHash([0x03; 32]),
-        };
-
         let mut db = SortitionDB::connect_test(block_height, &first_burn_hash).unwrap();
 
         let key_snapshot = test_append_snapshot(
@@ -7507,13 +7199,12 @@ pub mod tests {
             BurnchainHeaderHash([0x03; 32]),
             &vec![
                 BlockstackOperationType::LeaderBlockCommit(block_commit.clone()),
-                BlockstackOperationType::UserBurnSupport(user_burn.clone()),
             ],
         );
 
         {
             let burn_amt = SortitionDB::get_block_burn_amount(db.conn(), &commit_snapshot).unwrap();
-            assert_eq!(burn_amt, block_commit.burn_fee + user_burn.burn_fee);
+            assert_eq!(burn_amt, block_commit.burn_fee);
 
             let no_burn_amt = SortitionDB::get_block_burn_amount(db.conn(), &key_snapshot).unwrap();
             assert_eq!(no_burn_amt, 0);
diff --git a/stackslib/src/chainstate/burn/distribution.rs b/stackslib/src/chainstate/burn/distribution.rs
index 213b2f00fe..b9685a9a99 100644
--- a/stackslib/src/chainstate/burn/distribution.rs
+++ b/stackslib/src/chainstate/burn/distribution.rs
@@ -29,7 +29,7 @@ use crate::burnchains::{
 };
 use crate::chainstate::burn::operations::leader_block_commit::MissedBlockCommit;
 use crate::chainstate::burn::operations::{
-    BlockstackOperationType, LeaderBlockCommitOp, LeaderKeyRegisterOp, UserBurnSupportOp,
+    BlockstackOperationType, LeaderBlockCommitOp, LeaderKeyRegisterOp,
 };
 use crate::chainstate::stacks::StacksPublicKey;
 use crate::core::MINING_COMMITMENT_WINDOW;
@@ -42,7 +42,6 @@ pub struct BurnSamplePoint {
     pub range_start: Uint256,
     pub range_end: Uint256,
     pub candidate: LeaderBlockCommitOp,
-    pub user_burns: Vec<UserBurnSupportOp>,
 }
 
 #[derive(Debug, Clone)]
@@ -291,7 +290,6 @@ impl BurnSamplePoint {
                     range_start: Uint256::zero(), // To be filled in
                     range_end: Uint256::zero(),   // To be filled in
                     candidate,
-                    user_burns: vec![],
                 }
             })
             .collect();
@@ -331,7 +329,6 @@ impl BurnSamplePoint {
     pub fn make_distribution(
         all_block_candidates: Vec<LeaderBlockCommitOp>,
         _consumed_leader_keys: Vec<LeaderKeyRegisterOp>,
-        user_burns: Vec<UserBurnSupportOp>,
     ) -> Vec<BurnSamplePoint> {
         Self::make_min_median_distribution(vec![all_block_candidates], vec![], vec![true])
     }
@@ -419,7 +416,7 @@ mod tests {
         MissedBlockCommit, BURN_BLOCK_MINED_AT_MODULUS,
     };
     use crate::chainstate::burn::operations::{
-        BlockstackOperationType, LeaderBlockCommitOp, LeaderKeyRegisterOp, UserBurnSupportOp,
+        BlockstackOperationType, LeaderBlockCommitOp, LeaderKeyRegisterOp,
     };
     use crate::chainstate::burn::ConsensusHash;
     use crate::chainstate::stacks::address::StacksAddressExtensions;
@@ -430,41 +427,9 @@ mod tests {
     struct BurnDistFixture {
         consumed_leader_keys: Vec<LeaderKeyRegisterOp>,
         block_commits: Vec<LeaderBlockCommitOp>,
-        user_burns: Vec<UserBurnSupportOp>,
         res: Vec<BurnSamplePoint>,
     }
 
-    fn make_user_burn(
-        burn_fee: u64,
-        vrf_ident: u32,
-        block_id: u64,
-        txid_id: u64,
-        block_height: u64,
-    ) -> UserBurnSupportOp {
-        let mut block_header_hash = [0; 32];
-        block_header_hash[0..8].copy_from_slice(&block_id.to_be_bytes());
-        let mut txid = [3; 32];
-        txid[0..8].copy_from_slice(&txid_id.to_be_bytes());
-        let txid = Txid(txid);
-
-        UserBurnSupportOp {
-            address: StacksAddress {
-                version: 0,
-                bytes: Hash160([0; 20]),
-            },
-            consensus_hash: ConsensusHash([0; 20]),
-            public_key: VRFPublicKey::from_private(&VRFPrivateKey::new()),
-            key_block_ptr: vrf_ident,
-            key_vtxindex: 0,
-            block_header_hash_160: Hash160::from_sha256(&block_header_hash),
-            burn_fee,
-            txid,
-            vtxindex: 0,  // index in the block where this tx occurs
-            block_height, // block height at which this tx occurs
-            burn_header_hash: BurnchainHeaderHash([0; 32]), // hash of burnchain block with this tx
-        }
-    }
-
     fn make_missed_commit(txid_id: u64, input_tx: u64) -> MissedBlockCommit {
         let mut txid = [0; 32];
         txid[0..8].copy_from_slice(&txid_id.to_be_bytes());
@@ -565,14 +530,6 @@ mod tests {
                 make_block_commit(3, 12, 12, 12, Some(10), 6),
             ],
         ];
-        let user_burns = vec![
-            vec![make_user_burn(1, 1, 1, 1, 1), make_user_burn(1, 2, 2, 2, 1)],
-            vec![make_user_burn(1, 4, 4, 4, 2)],
-            vec![make_user_burn(1, 6, 6, 6, 3)],
-            vec![make_user_burn(1, 8, 8, 8, 4)],
-            vec![make_user_burn(1, 10, 10, 10, 5)],
-            vec![make_user_burn(1, 12, 12, 12, 6)],
-        ];
 
         let mut result = BurnSamplePoint::make_min_median_distribution(
             commits.clone(),
@@ -592,9 +549,6 @@ mod tests {
         assert_eq!(result[0].candidate.txid, commits[5][0].txid);
         assert_eq!(result[1].candidate.txid, commits[5][1].txid);
 
-        assert_eq!(result[0].user_burns.len(), 0);
-        assert_eq!(result[1].user_burns.len(), 0);
-
         // now correct the back pointers so that they point
         //   at the correct UTXO position *post-sunset*
         for (ix, window_slice) in commits.iter_mut().enumerate() {
@@ -626,9 +580,6 @@ mod tests {
         // make sure that we're associating with the last commit in the window.
         assert_eq!(result[0].candidate.txid, commits[5][0].txid);
         assert_eq!(result[1].candidate.txid, commits[5][1].txid);
-
-        assert_eq!(result[0].user_burns.len(), 0);
-        assert_eq!(result[1].user_burns.len(), 0);
     }
 
     #[test]
@@ -672,14 +623,6 @@ mod tests {
                 make_block_commit(3, 12, 12, 12, Some(10), 6),
             ],
         ];
-        let user_burns = vec![
-            vec![make_user_burn(1, 1, 1, 1, 1), make_user_burn(1, 2, 2, 2, 1)],
-            vec![make_user_burn(1, 4, 4, 4, 2)],
-            vec![make_user_burn(1, 6, 6, 6, 3)],
-            vec![make_user_burn(1, 8, 8, 8, 4)],
-            vec![make_user_burn(1, 10, 10, 10, 5)],
-            vec![make_user_burn(1, 12, 12, 12, 6)],
-        ];
 
         let mut result = BurnSamplePoint::make_min_median_distribution(
             commits.clone(),
@@ -698,9 +641,6 @@ mod tests {
         assert_eq!(result[0].candidate.txid, commits[5][0].txid);
         assert_eq!(result[1].candidate.txid, commits[5][1].txid);
 
-        assert_eq!(result[0].user_burns.len(), 0);
-        assert_eq!(result[1].user_burns.len(), 0);
-
         // test case 2:
         //    miner 1:  4 4 5 4 5 3
         //    miner 2:  4 4 4 4 4 1
@@ -736,14 +676,6 @@ mod tests {
                 make_block_commit(1, 11, 11, 12, Some(10), 6),
             ],
         ];
-        let user_burns = vec![
-            vec![],
-            vec![],
-            vec![],
-            vec![],
-            vec![],
-            vec![make_user_burn(2, 11, 11, 1, 6)],
-        ];
 
         let mut result = BurnSamplePoint::make_min_median_distribution(
             commits.clone(),
@@ -761,9 +693,6 @@ mod tests {
         // make sure that we're associating with the last commit in the window.
         assert_eq!(result[0].candidate.txid, commits[5][0].txid);
         assert_eq!(result[1].candidate.txid, commits[5][1].txid);
-
-        assert_eq!(result[0].user_burns.len(), 0);
-        assert_eq!(result[1].user_burns.len(), 0);
     }
 
     #[test]
@@ -904,198 +833,6 @@ mod tests {
             .unwrap(),
         };
 
-        let user_burn_noblock = UserBurnSupportOp {
-            address: StacksAddress::new(1, Hash160([1u8; 20])),
-            consensus_hash: ConsensusHash::from_bytes(
-                &hex_bytes("4444444444444444444444444444444444444444").unwrap(),
-            )
-            .unwrap(),
-            public_key: VRFPublicKey::from_bytes(
-                &hex_bytes("a366b51292bef4edd64063d9145c617fec373bceb0758e98cd72becd84d54c7a")
-                    .unwrap(),
-            )
-            .unwrap(),
-            block_header_hash_160: Hash160::from_bytes(
-                &hex_bytes("3333333333333333333333333333333333333333").unwrap(),
-            )
-            .unwrap(),
-            key_block_ptr: 1,
-            key_vtxindex: 772,
-            burn_fee: 12345,
-
-            txid: Txid::from_bytes_be(
-                &hex_bytes("1d5cbdd276495b07f0e0bf0181fa57c175b217bc35531b078d62fc20986c716c")
-                    .unwrap(),
-            )
-            .unwrap(),
-            vtxindex: 12,
-            block_height: 124,
-            burn_header_hash: BurnchainHeaderHash::from_hex(
-                "0000000000000000000000000000000000000000000000000000000000000004",
-            )
-            .unwrap(),
-        };
-
-        let user_burn_1 = UserBurnSupportOp {
-            address: StacksAddress::new(2, Hash160([2u8; 20])),
-            consensus_hash: ConsensusHash::from_bytes(
-                &hex_bytes("4444444444444444444444444444444444444444").unwrap(),
-            )
-            .unwrap(),
-            public_key: VRFPublicKey::from_bytes(
-                &hex_bytes("a366b51292bef4edd64063d9145c617fec373bceb0758e98cd72becd84d54c7a")
-                    .unwrap(),
-            )
-            .unwrap(),
-            block_header_hash_160: Hash160::from_bytes(
-                &hex_bytes("7150f635054b87df566a970b21e07030d6444bf2").unwrap(),
-            )
-            .unwrap(), // 22222....2222
-            key_block_ptr: 123,
-            key_vtxindex: 456,
-            burn_fee: 10000,
-
-            txid: Txid::from_bytes_be(
-                &hex_bytes("1d5cbdd276495b07f0e0bf0181fa57c175b217bc35531b078d62fc20986c716c")
-                    .unwrap(),
-            )
-            .unwrap(),
-            vtxindex: 13,
-            block_height: 124,
-            burn_header_hash: BurnchainHeaderHash::from_hex(
-                "0000000000000000000000000000000000000000000000000000000000000004",
-            )
-            .unwrap(),
-        };
-
-        let user_burn_1_2 = UserBurnSupportOp {
-            address: StacksAddress::new(3, Hash160([3u8; 20])),
-            consensus_hash: ConsensusHash::from_bytes(
-                &hex_bytes("4444444444444444444444444444444444444444").unwrap(),
-            )
-            .unwrap(),
-            public_key: VRFPublicKey::from_bytes(
-                &hex_bytes("a366b51292bef4edd64063d9145c617fec373bceb0758e98cd72becd84d54c7a")
-                    .unwrap(),
-            )
-            .unwrap(),
-            block_header_hash_160: Hash160::from_bytes(
-                &hex_bytes("7150f635054b87df566a970b21e07030d6444bf2").unwrap(),
-            )
-            .unwrap(), // 22222....2222
-            key_block_ptr: 123,
-            key_vtxindex: 456,
-            burn_fee: 30000,
-
-            txid: Txid::from_bytes_be(
-                &hex_bytes("1d5cbdd276495b07f0e0bf0181fa57c175b217bc35531b078d62fc20986c716c")
-                    .unwrap(),
-            )
-            .unwrap(),
-            vtxindex: 14,
-            block_height: 124,
-            burn_header_hash: BurnchainHeaderHash::from_hex(
-                "0000000000000000000000000000000000000000000000000000000000000004",
-            )
-            .unwrap(),
-        };
-
-        let user_burn_2 = UserBurnSupportOp {
-            address: StacksAddress::new(4, Hash160([4u8; 20])),
-            consensus_hash: ConsensusHash::from_bytes(
-                &hex_bytes("4444444444444444444444444444444444444444").unwrap(),
-            )
-            .unwrap(),
-            public_key: VRFPublicKey::from_bytes(
-                &hex_bytes("bb519494643f79f1dea0350e6fb9a1da88dfdb6137117fc2523824a8aa44fe1c")
-                    .unwrap(),
-            )
-            .unwrap(),
-            block_header_hash_160: Hash160::from_bytes(
-                &hex_bytes("037a1e860899a4fa823c18b66f6264d20236ec58").unwrap(),
-            )
-            .unwrap(), // 22222....2223
-            key_block_ptr: 122,
-            key_vtxindex: 457,
-            burn_fee: 20000,
-
-            txid: Txid::from_bytes_be(
-                &hex_bytes("1d5cbdd276495b07f0e0bf0181fa57c175b217bc35531b078d62fc20986c716d")
-                    .unwrap(),
-            )
-            .unwrap(),
-            vtxindex: 15,
-            block_height: 124,
-            burn_header_hash: BurnchainHeaderHash::from_hex(
-                "0000000000000000000000000000000000000000000000000000000000000004",
-            )
-            .unwrap(),
-        };
-
-        let user_burn_2_2 = UserBurnSupportOp {
-            address: StacksAddress::new(5, Hash160([5u8; 20])),
-            consensus_hash: ConsensusHash::from_bytes(
-                &hex_bytes("4444444444444444444444444444444444444444").unwrap(),
-            )
-            .unwrap(),
-            public_key: VRFPublicKey::from_bytes(
-                &hex_bytes("bb519494643f79f1dea0350e6fb9a1da88dfdb6137117fc2523824a8aa44fe1c")
-                    .unwrap(),
-            )
-            .unwrap(),
-            block_header_hash_160: Hash160::from_bytes(
-                &hex_bytes("037a1e860899a4fa823c18b66f6264d20236ec58").unwrap(),
-            )
-            .unwrap(), // 22222....2223
-            key_block_ptr: 122,
-            key_vtxindex: 457,
-            burn_fee: 40000,
-
-            txid: Txid::from_bytes_be(
-                &hex_bytes("1d5cbdd276495b07f0e0bf0181fa57c175b217bc35531b078d62fc20986c716c")
-                    .unwrap(),
-            )
-            .unwrap(),
-            vtxindex: 16,
-            block_height: 124,
-            burn_header_hash: BurnchainHeaderHash::from_hex(
-                "0000000000000000000000000000000000000000000000000000000000000004",
-            )
-            .unwrap(),
-        };
-
-        let user_burn_nokey = UserBurnSupportOp {
-            address: StacksAddress::new(6, Hash160([6u8; 20])),
-            consensus_hash: ConsensusHash::from_bytes(
-                &hex_bytes("4444444444444444444444444444444444444444").unwrap(),
-            )
-            .unwrap(),
-            public_key: VRFPublicKey::from_bytes(
-                &hex_bytes("3f3338db51f2b1f6ac0cf6177179a24ee130c04ef2f9849a64a216969ab60e70")
-                    .unwrap(),
-            )
-            .unwrap(),
-            block_header_hash_160: Hash160::from_bytes(
-                &hex_bytes("037a1e860899a4fa823c18b66f6264d20236ec58").unwrap(),
-            )
-            .unwrap(),
-            key_block_ptr: 121,
-            key_vtxindex: 772,
-            burn_fee: 12345,
-
-            txid: Txid::from_bytes_be(
-                &hex_bytes("1d5cbdd276495b07f0e0bf0181fa57c175b217bc35531b078d62fc20986c716e")
-                    .unwrap(),
-            )
-            .unwrap(),
-            vtxindex: 17,
-            block_height: 124,
-            burn_header_hash: BurnchainHeaderHash::from_hex(
-                "0000000000000000000000000000000000000000000000000000000000000004",
-            )
-            .unwrap(),
-        };
-
         let block_commit_1 = LeaderBlockCommitOp {
             sunset_burn: 0,
             block_header_hash: BlockHeaderHash::from_bytes(
@@ -1252,26 +989,22 @@ mod tests {
             BurnDistFixture {
                 consumed_leader_keys: vec![],
                 block_commits: vec![],
-                user_burns: vec![],
                 res: vec![],
             },
             BurnDistFixture {
                 consumed_leader_keys: vec![leader_key_1.clone()],
                 block_commits: vec![block_commit_1.clone()],
-                user_burns: vec![],
                 res: vec![BurnSamplePoint {
                     burns: block_commit_1.burn_fee.into(),
                     median_burn: block_commit_1.burn_fee.into(),
                     range_start: Uint256::zero(),
                     range_end: Uint256::max(),
                     candidate: block_commit_1.clone(),
-                    user_burns: vec![],
                 }],
             },
             BurnDistFixture {
                 consumed_leader_keys: vec![leader_key_1.clone(), leader_key_2.clone()],
                 block_commits: vec![block_commit_1.clone(), block_commit_2.clone()],
-                user_burns: vec![],
                 res: vec![
                     BurnSamplePoint {
                         burns: block_commit_1.burn_fee.into(),
@@ -1285,7 +1018,6 @@ mod tests {
                             0x7fffffffffffffff,
                         ]),
                         candidate: block_commit_1.clone(),
-                        user_burns: vec![],
                     },
                     BurnSamplePoint {
                         burns: block_commit_2.burn_fee.into(),
@@ -1299,14 +1031,12 @@ mod tests {
                         ]),
                         range_end: Uint256::max(),
                         candidate: block_commit_2.clone(),
-                        user_burns: vec![],
                     },
                 ],
             },
             BurnDistFixture {
                 consumed_leader_keys: vec![leader_key_1.clone(), leader_key_2.clone()],
                 block_commits: vec![block_commit_1.clone(), block_commit_2.clone()],
-                user_burns: vec![user_burn_noblock.clone()],
                 res: vec![
                     BurnSamplePoint {
                         burns: block_commit_1.burn_fee.into(),
@@ -1320,7 +1050,6 @@ mod tests {
                             0x7fffffffffffffff,
                         ]),
                         candidate: block_commit_1.clone(),
-                        user_burns: vec![],
                     },
                     BurnSamplePoint {
                         burns: block_commit_2.burn_fee.into(),
@@ -1334,14 +1063,12 @@ mod tests {
                         ]),
                         range_end: Uint256::max(),
                         candidate: block_commit_2.clone(),
-                        user_burns: vec![],
                     },
                 ],
             },
             BurnDistFixture {
                 consumed_leader_keys: vec![leader_key_1.clone(), leader_key_2.clone()],
                 block_commits: vec![block_commit_1.clone(), block_commit_2.clone()],
-                user_burns: vec![user_burn_nokey.clone()],
                 res: vec![
                     BurnSamplePoint {
                         burns: block_commit_1.burn_fee.into(),
@@ -1355,7 +1082,6 @@ mod tests {
                             0x7fffffffffffffff,
                         ]),
                         candidate: block_commit_1.clone(),
-                        user_burns: vec![],
                     },
                     BurnSamplePoint {
                         burns: block_commit_2.burn_fee.into(),
@@ -1369,18 +1095,12 @@ mod tests {
                         ]),
                         range_end: Uint256::max(),
                         candidate: block_commit_2.clone(),
-                        user_burns: vec![],
                     },
                 ],
             },
             BurnDistFixture {
                 consumed_leader_keys: vec![leader_key_1.clone(), leader_key_2.clone()],
                 block_commits: vec![block_commit_1.clone(), block_commit_2.clone()],
-                user_burns: vec![
-                    user_burn_noblock.clone(),
-                    user_burn_1.clone(),
-                    user_burn_nokey.clone(),
-                ],
                 res: vec![
                     BurnSamplePoint {
                         burns: block_commit_1.burn_fee.into(),
@@ -1394,7 +1114,6 @@ mod tests {
                             0x7fffffffffffffff,
                         ]),
                         candidate: block_commit_1.clone(),
-                        user_burns: vec![],
                     },
                     BurnSamplePoint {
                         burns: block_commit_2.burn_fee.into(),
@@ -1408,19 +1127,12 @@ mod tests {
                         ]),
                         range_end: Uint256::max(),
                         candidate: block_commit_2.clone(),
-                        user_burns: vec![],
                     },
                 ],
             },
             BurnDistFixture {
                 consumed_leader_keys: vec![leader_key_1.clone(), leader_key_2.clone()],
                 block_commits: vec![block_commit_1.clone(), block_commit_2.clone()],
-                user_burns: vec![
-                    user_burn_noblock.clone(),
-                    user_burn_1.clone(),
-                    user_burn_2.clone(),
-                    user_burn_nokey.clone(),
-                ],
                 res: vec![
                     BurnSamplePoint {
                         burns: block_commit_1.burn_fee.into(),
@@ -1434,7 +1146,6 @@ mod tests {
                             0x7fffffffffffffff,
                         ]),
                         candidate: block_commit_1.clone(),
-                        user_burns: vec![],
                     },
                     BurnSamplePoint {
                         burns: block_commit_2.burn_fee.into(),
@@ -1448,21 +1159,12 @@ mod tests {
                         ]),
                         range_end: Uint256::max(),
                         candidate: block_commit_2.clone(),
-                        user_burns: vec![],
                     },
                 ],
             },
             BurnDistFixture {
                 consumed_leader_keys: vec![leader_key_1.clone(), leader_key_2.clone()],
                 block_commits: vec![block_commit_1.clone(), block_commit_2.clone()],
-                user_burns: vec![
-                    user_burn_noblock.clone(),
-                    user_burn_1.clone(),
-                    user_burn_1_2.clone(),
-                    user_burn_2.clone(),
-                    user_burn_2_2.clone(),
-                    user_burn_nokey.clone(),
-                ],
                 res: vec![
                     BurnSamplePoint {
                         burns: block_commit_1.burn_fee.into(),
@@ -1476,7 +1178,6 @@ mod tests {
                             0x7fffffffffffffff,
                         ]),
                         candidate: block_commit_1.clone(),
-                        user_burns: vec![],
                     },
                     BurnSamplePoint {
                         burns: block_commit_2.burn_fee.into(),
@@ -1490,7 +1191,6 @@ mod tests {
                         ]),
                         range_end: Uint256::max(),
                         candidate: block_commit_2.clone(),
-                        user_burns: vec![],
                     },
                 ],
             },
@@ -1505,14 +1205,6 @@ mod tests {
                     block_commit_2.clone(),
                     block_commit_3.clone(),
                 ],
-                user_burns: vec![
-                    user_burn_noblock.clone(),
-                    user_burn_1.clone(),
-                    user_burn_1_2.clone(),
-                    user_burn_2.clone(),
-                    user_burn_2_2.clone(),
-                    user_burn_nokey.clone(),
-                ],
                 res: vec![
                     BurnSamplePoint {
                         burns: block_commit_1.burn_fee.into(),
@@ -1525,7 +1217,6 @@ mod tests {
                             0x41a3ed94d3cb0a84,
                         ]),
                         candidate: block_commit_1.clone(),
-                        user_burns: vec![],
                     },
                     BurnSamplePoint {
                         burns: block_commit_2.burn_fee.into(),
@@ -1543,7 +1234,6 @@ mod tests {
                             0x8347db29a7961508,
                         ]),
                         candidate: block_commit_2.clone(),
-                        user_burns: vec![],
                     },
                     BurnSamplePoint {
                         burns: (block_commit_3.burn_fee).into(),
@@ -1556,7 +1246,6 @@ mod tests {
                         ]),
                         range_end: Uint256::max(),
                         candidate: block_commit_3.clone(),
-                        user_burns: vec![],
                     },
                 ],
             },
@@ -1568,7 +1257,6 @@ mod tests {
             let dist = BurnSamplePoint::make_distribution(
                 f.block_commits.iter().cloned().collect(),
                 f.consumed_leader_keys.iter().cloned().collect(),
-                f.user_burns.iter().cloned().collect(),
             );
             assert_eq!(dist, f.res);
         }
diff --git a/stackslib/src/chainstate/burn/mod.rs b/stackslib/src/chainstate/burn/mod.rs
index 4010ba2fc3..8031762355 100644
--- a/stackslib/src/chainstate/burn/mod.rs
+++ b/stackslib/src/chainstate/burn/mod.rs
@@ -64,7 +64,6 @@ impl_byte_array_newtype!(SortitionHash, u8, 32);
 pub enum Opcodes {
     LeaderBlockCommit = '[' as u8,
     LeaderKeyRegister = '^' as u8,
-    UserBurnSupport = '_' as u8,
     StackStx = 'x' as u8,
     PreStx = 'p' as u8,
     TransferStx = '$' as u8,
@@ -198,7 +197,6 @@ impl Opcodes {
         match self {
             Opcodes::LeaderBlockCommit => Self::HTTP_BLOCK_COMMIT,
             Opcodes::LeaderKeyRegister => Self::HTTP_KEY_REGISTER,
-            Opcodes::UserBurnSupport => Self::HTTP_BURN_SUPPORT,
             Opcodes::StackStx => Self::HTTP_STACK_STX,
             Opcodes::PreStx => Self::HTTP_PRE_STX,
             Opcodes::TransferStx => Self::HTTP_TRANSFER_STX,
@@ -210,7 +208,6 @@ impl Opcodes {
         let opcode = match input {
             Self::HTTP_BLOCK_COMMIT => Opcodes::LeaderBlockCommit,
             Self::HTTP_KEY_REGISTER => Opcodes::LeaderKeyRegister,
-            Self::HTTP_BURN_SUPPORT => Opcodes::UserBurnSupport,
             Self::HTTP_STACK_STX => Opcodes::StackStx,
             Self::HTTP_PRE_STX => Opcodes::PreStx,
             Self::HTTP_TRANSFER_STX => Opcodes::TransferStx,
diff --git a/stackslib/src/chainstate/burn/operations/leader_block_commit.rs b/stackslib/src/chainstate/burn/operations/leader_block_commit.rs
index 6d54bc7adc..eda436eeb6 100644
--- a/stackslib/src/chainstate/burn/operations/leader_block_commit.rs
+++ b/stackslib/src/chainstate/burn/operations/leader_block_commit.rs
@@ -33,7 +33,7 @@ use crate::burnchains::{
 use crate::chainstate::burn::db::sortdb::{SortitionDB, SortitionHandle, SortitionHandleTx};
 use crate::chainstate::burn::operations::{
     parse_u16_from_be, parse_u32_from_be, BlockstackOperationType, Error as op_error,
-    LeaderBlockCommitOp, LeaderKeyRegisterOp, UserBurnSupportOp,
+    LeaderBlockCommitOp, LeaderKeyRegisterOp,
 };
 use crate::chainstate::burn::{ConsensusHash, Opcodes, SortitionId};
 use crate::chainstate::stacks::address::PoxAddress;
diff --git a/stackslib/src/chainstate/burn/operations/leader_key_register.rs b/stackslib/src/chainstate/burn/operations/leader_key_register.rs
index 22c88df6d7..b892f7efd8 100644
--- a/stackslib/src/chainstate/burn/operations/leader_key_register.rs
+++ b/stackslib/src/chainstate/burn/operations/leader_key_register.rs
@@ -31,7 +31,6 @@ use crate::burnchains::{
 use crate::chainstate::burn::db::sortdb::SortitionHandleTx;
 use crate::chainstate::burn::operations::{
     BlockstackOperationType, Error as op_error, LeaderBlockCommitOp, LeaderKeyRegisterOp,
-    UserBurnSupportOp,
 };
 use crate::chainstate::burn::{ConsensusHash, Opcodes};
 use crate::chainstate::stacks::{StacksPrivateKey, StacksPublicKey};
@@ -260,7 +259,7 @@ pub mod tests {
     use crate::burnchains::*;
     use crate::chainstate::burn::db::sortdb::*;
     use crate::chainstate::burn::operations::{
-        BlockstackOperationType, LeaderBlockCommitOp, LeaderKeyRegisterOp, UserBurnSupportOp,
+        BlockstackOperationType, LeaderBlockCommitOp, LeaderKeyRegisterOp,
     };
     use crate::chainstate::burn::{BlockSnapshot, ConsensusHash, OpsHash, SortitionHash};
     use crate::chainstate::stacks::address::StacksAddressExtensions;
diff --git a/stackslib/src/chainstate/burn/operations/mod.rs b/stackslib/src/chainstate/burn/operations/mod.rs
index 189acab16c..e7c48cb1cb 100644
--- a/stackslib/src/chainstate/burn/operations/mod.rs
+++ b/stackslib/src/chainstate/burn/operations/mod.rs
@@ -45,7 +45,6 @@ pub mod leader_block_commit;
 pub mod leader_key_register;
 pub mod stack_stx;
 pub mod transfer_stx;
-pub mod user_burn_support;
 
 #[cfg(test)]
 mod test;
@@ -75,11 +74,6 @@ pub enum Error {
     // leader key register related errors
     LeaderKeyAlreadyRegistered,
 
-    // user burn supports related errors
-    UserBurnSupportBadConsensusHash,
-    UserBurnSupportNoLeaderKey,
-    UserBurnSupportNotSupported,
-
     // transfer stx related errors
     TransferStxMustBePositive,
     TransferStxSelfSend,
@@ -137,16 +131,6 @@ impl fmt::Display for Error {
             Error::LeaderKeyAlreadyRegistered => {
                 write!(f, "Leader key has already been registered")
             }
-            Error::UserBurnSupportBadConsensusHash => {
-                write!(f, "User burn support has an invalid consensus hash")
-            }
-            Error::UserBurnSupportNoLeaderKey => write!(
-                f,
-                "User burn support does not match a registered leader key"
-            ),
-            Error::UserBurnSupportNotSupported => {
-                write!(f, "User burn operations are not supported")
-            }
             Error::TransferStxMustBePositive => write!(f, "Transfer STX must be positive amount"),
             Error::TransferStxSelfSend => write!(f, "Transfer STX must not send to self"),
             Error::StackStxMustBePositive => write!(f, "Stack STX must be positive amount"),
@@ -268,24 +252,6 @@ pub struct LeaderKeyRegisterOp {
     pub burn_header_hash: BurnchainHeaderHash, // hash of burn chain block
 }
 
-/// NOTE: this struct is currently not used
-#[derive(Debug, PartialEq, Clone, Eq, Serialize, Deserialize)]
-pub struct UserBurnSupportOp {
-    pub address: StacksAddress,
-    pub consensus_hash: ConsensusHash,
-    pub public_key: VRFPublicKey,
-    pub key_block_ptr: u32,
-    pub key_vtxindex: u16,
-    pub block_header_hash_160: Hash160,
-    pub burn_fee: u64,
-
-    // common to all transactions
-    pub txid: Txid,                            // transaction ID
-    pub vtxindex: u32,                         // index in the block where this tx occurs
-    pub block_height: u64,                     // block height at which this tx occurs
-    pub burn_header_hash: BurnchainHeaderHash, // hash of burnchain block with this tx
-}
-
 #[derive(Debug, PartialEq, Clone, Eq, Serialize, Deserialize)]
 pub struct DelegateStxOp {
     pub sender: StacksAddress,
@@ -343,7 +309,6 @@ fn principal_deserialize<'de, D: serde::Deserializer<'de>>(
 pub enum BlockstackOperationType {
     LeaderKeyRegister(LeaderKeyRegisterOp),
     LeaderBlockCommit(LeaderBlockCommitOp),
-    UserBurnSupport(UserBurnSupportOp),
     PreStx(PreStxOp),
     StackStx(StackStxOp),
     TransferStx(TransferStxOp),
@@ -370,7 +335,6 @@ impl BlockstackOperationType {
         match *self {
             BlockstackOperationType::LeaderKeyRegister(_) => Opcodes::LeaderKeyRegister,
             BlockstackOperationType::LeaderBlockCommit(_) => Opcodes::LeaderBlockCommit,
-            BlockstackOperationType::UserBurnSupport(_) => Opcodes::UserBurnSupport,
             BlockstackOperationType::StackStx(_) => Opcodes::StackStx,
             BlockstackOperationType::PreStx(_) => Opcodes::PreStx,
             BlockstackOperationType::TransferStx(_) => Opcodes::TransferStx,
@@ -386,7 +350,6 @@ impl BlockstackOperationType {
         match *self {
             BlockstackOperationType::LeaderKeyRegister(ref data) => &data.txid,
             BlockstackOperationType::LeaderBlockCommit(ref data) => &data.txid,
-            BlockstackOperationType::UserBurnSupport(ref data) => &data.txid,
             BlockstackOperationType::StackStx(ref data) => &data.txid,
             BlockstackOperationType::PreStx(ref data) => &data.txid,
             BlockstackOperationType::TransferStx(ref data) => &data.txid,
@@ -398,7 +361,6 @@ impl BlockstackOperationType {
         match *self {
             BlockstackOperationType::LeaderKeyRegister(ref data) => data.vtxindex,
             BlockstackOperationType::LeaderBlockCommit(ref data) => data.vtxindex,
-            BlockstackOperationType::UserBurnSupport(ref data) => data.vtxindex,
             BlockstackOperationType::StackStx(ref data) => data.vtxindex,
             BlockstackOperationType::PreStx(ref data) => data.vtxindex,
             BlockstackOperationType::TransferStx(ref data) => data.vtxindex,
@@ -410,7 +372,6 @@ impl BlockstackOperationType {
         match *self {
             BlockstackOperationType::LeaderKeyRegister(ref data) => data.block_height,
             BlockstackOperationType::LeaderBlockCommit(ref data) => data.block_height,
-            BlockstackOperationType::UserBurnSupport(ref data) => data.block_height,
             BlockstackOperationType::StackStx(ref data) => data.block_height,
             BlockstackOperationType::PreStx(ref data) => data.block_height,
             BlockstackOperationType::TransferStx(ref data) => data.block_height,
@@ -422,7 +383,6 @@ impl BlockstackOperationType {
         match *self {
             BlockstackOperationType::LeaderKeyRegister(ref data) => data.burn_header_hash.clone(),
             BlockstackOperationType::LeaderBlockCommit(ref data) => data.burn_header_hash.clone(),
-            BlockstackOperationType::UserBurnSupport(ref data) => data.burn_header_hash.clone(),
             BlockstackOperationType::StackStx(ref data) => data.burn_header_hash.clone(),
             BlockstackOperationType::PreStx(ref data) => data.burn_header_hash.clone(),
             BlockstackOperationType::TransferStx(ref data) => data.burn_header_hash.clone(),
@@ -437,7 +397,6 @@ impl BlockstackOperationType {
             BlockstackOperationType::LeaderBlockCommit(ref mut data) => {
                 data.set_burn_height(height)
             }
-            BlockstackOperationType::UserBurnSupport(ref mut data) => data.block_height = height,
             BlockstackOperationType::StackStx(ref mut data) => data.block_height = height,
             BlockstackOperationType::PreStx(ref mut data) => data.block_height = height,
             BlockstackOperationType::TransferStx(ref mut data) => data.block_height = height,
@@ -454,7 +413,6 @@ impl BlockstackOperationType {
             BlockstackOperationType::LeaderBlockCommit(ref mut data) => {
                 data.burn_header_hash = hash
             }
-            BlockstackOperationType::UserBurnSupport(ref mut data) => data.burn_header_hash = hash,
             BlockstackOperationType::StackStx(ref mut data) => data.burn_header_hash = hash,
             BlockstackOperationType::PreStx(ref mut data) => data.burn_header_hash = hash,
             BlockstackOperationType::TransferStx(ref mut data) => data.burn_header_hash = hash,
@@ -547,7 +505,6 @@ impl fmt::Display for BlockstackOperationType {
             BlockstackOperationType::PreStx(ref op) => write!(f, "{:?}", op),
             BlockstackOperationType::StackStx(ref op) => write!(f, "{:?}", op),
             BlockstackOperationType::LeaderBlockCommit(ref op) => write!(f, "{:?}", op),
-            BlockstackOperationType::UserBurnSupport(ref op) => write!(f, "{:?}", op),
             BlockstackOperationType::TransferStx(ref op) => write!(f, "{:?}", op),
             BlockstackOperationType::DelegateStx(ref op) => write!(f, "{:?}", op),
         }
diff --git a/stackslib/src/chainstate/burn/operations/user_burn_support.rs b/stackslib/src/chainstate/burn/operations/user_burn_support.rs
deleted file mode 100644
index cd0ff1a4f5..0000000000
--- a/stackslib/src/chainstate/burn/operations/user_burn_support.rs
+++ /dev/null
@@ -1,789 +0,0 @@
-// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
-// Copyright (C) 2020 Stacks Open Internet Foundation
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-use std::io::{Read, Write};
-use std::marker::PhantomData;
-
-use stacks_common::codec::{write_next, Error as codec_error, StacksMessageCodec};
-use stacks_common::types::chainstate::{BlockHeaderHash, BurnchainHeaderHash, TrieHash};
-use stacks_common::util::hash::Hash160;
-use stacks_common::util::log;
-use stacks_common::util::vrf::{VRFPublicKey, VRF};
-
-use crate::burnchains::{
-    Address, Burnchain, BurnchainBlockHeader, BurnchainTransaction, PublicKey, Txid,
-};
-use crate::chainstate::burn::db::sortdb::SortitionHandleTx;
-use crate::chainstate::burn::operations::{
-    parse_u16_from_be, parse_u32_from_be, BlockstackOperationType, Error as op_error,
-    LeaderBlockCommitOp, LeaderKeyRegisterOp, UserBurnSupportOp,
-};
-use crate::chainstate::burn::{ConsensusHash, Opcodes};
-use crate::net::Error as net_error;
-use crate::util_lib::db::{DBConn, DBTx};
-
-// return type for parse_data (below)
-struct ParsedData {
-    pub consensus_hash: ConsensusHash,
-    pub public_key: VRFPublicKey,
-    pub key_block_ptr: u32,
-    pub key_vtxindex: u16,
-    pub block_header_hash_160: Hash160,
-}
-
-impl UserBurnSupportOp {
-    fn parse_data(data: &Vec<u8>) -> Option<ParsedData> {
-        /*
-            Wire format:
-
-            0      2  3              22                       54                 74       78        80
-            |------|--|---------------|-----------------------|------------------|--------|---------|
-             magic  op consensus hash    proving public key       block hash 160   key blk  key
-                       (truncated by 1)                                                     vtxindex
-
-
-             Note that `data` is missing the first 3 bytes -- the magic and op have been stripped
-        */
-        if data.len() < 77 {
-            warn!(
-                "USER_BURN_SUPPORT payload is malformed ({} bytes)",
-                data.len()
-            );
-            return None;
-        }
-
-        let mut consensus_hash_trunc = data[0..19].to_vec();
-        consensus_hash_trunc.push(0);
-
-        let consensus_hash = ConsensusHash::from_vec(&consensus_hash_trunc)
-            .expect("FATAL: invalid data slice for consensus hash");
-        let pubkey = match VRFPublicKey::from_bytes(&data[19..51]) {
-            Some(pubk) => pubk,
-            None => {
-                warn!("Invalid VRF public key");
-                return None;
-            }
-        };
-
-        let block_header_hash_160 = Hash160::from_vec(&data[51..71].to_vec())
-            .expect("FATAL: invalid data slice for block hash160");
-        let key_block_ptr = parse_u32_from_be(&data[71..75]).unwrap();
-        let key_vtxindex = parse_u16_from_be(&data[75..77]).unwrap();
-
-        Some(ParsedData {
-            consensus_hash,
-            public_key: pubkey,
-            block_header_hash_160,
-            key_block_ptr,
-            key_vtxindex,
-        })
-    }
-
-    fn parse_from_tx(
-        block_height: u64,
-        block_hash: &BurnchainHeaderHash,
-        tx: &BurnchainTransaction,
-    ) -> Result<UserBurnSupportOp, op_error> {
-        // can't be too careful...
-        let num_inputs = tx.num_signers();
-        let outputs = tx.get_recipients();
-
-        if num_inputs == 0 || outputs.len() == 0 {
-            test_debug!(
-                "Invalid tx: inputs: {}, outputs: {}",
-                num_inputs,
-                outputs.len()
-            );
-            return Err(op_error::InvalidInput);
-        }
-
-        if outputs.len() < 2 {
-            test_debug!(
-                "Invalid tx: inputs: {}, outputs: {}",
-                num_inputs,
-                outputs.len()
-            );
-            return Err(op_error::InvalidInput);
-        }
-
-        if tx.opcode() != Opcodes::UserBurnSupport as u8 {
-            test_debug!("Invalid tx: invalid opcode {}", tx.opcode());
-            return Err(op_error::InvalidInput);
-        }
-
-        let output_0 = outputs[0].clone().ok_or_else(|| {
-            warn!("Invalid tx: unrecognized output 0");
-            op_error::InvalidInput
-        })?;
-
-        // outputs[0] should be the burn output
-        if !output_0.address.is_burn() {
-            // wrong burn output
-            test_debug!("Invalid tx: burn output missing (got {:?})", outputs[0]);
-            return Err(op_error::ParseError);
-        }
-
-        let burn_fee = output_0.amount;
-
-        let data = match UserBurnSupportOp::parse_data(&tx.data()) {
-            None => {
-                test_debug!("Invalid tx data");
-                return Err(op_error::ParseError);
-            }
-            Some(d) => d,
-        };
-
-        // basic sanity checks
-        if data.key_block_ptr == 0 {
-            warn!("Invalid tx: key block pointer must be positive");
-            return Err(op_error::ParseError);
-        }
-
-        if data.key_block_ptr as u64 > block_height {
-            warn!(
-                "Invalid tx: key block back-pointer {} exceeds block height {}",
-                data.key_block_ptr, block_height
-            );
-            return Err(op_error::ParseError);
-        }
-
-        let output = outputs[1]
-            .as_ref()
-            .ok_or_else(|| {
-                warn!("Invalid tx: unrecognized output 1");
-                op_error::InvalidInput
-            })?
-            .address
-            .clone()
-            .try_into_stacks_address()
-            .ok_or_else(|| {
-                warn!("Invalid tx: output must be representable as a StacksAddress");
-                op_error::InvalidInput
-            })?;
-
-        Ok(UserBurnSupportOp {
-            address: output,
-            consensus_hash: data.consensus_hash,
-            public_key: data.public_key,
-            block_header_hash_160: data.block_header_hash_160,
-            key_block_ptr: data.key_block_ptr,
-            key_vtxindex: data.key_vtxindex,
-            burn_fee: burn_fee,
-
-            txid: tx.txid(),
-            vtxindex: tx.vtxindex(),
-            block_height: block_height,
-            burn_header_hash: block_hash.clone(),
-        })
-    }
-}
-
-impl StacksMessageCodec for UserBurnSupportOp {
-    /*
-        Wire format:
-
-        0      2  3              22                       54                 74       78        80
-        |------|--|---------------|-----------------------|------------------|--------|---------|
-         magic  op consensus hash   proving public key       block hash 160   key blk  key
-                (truncated by 1)                                                        vtxindex
-    */
-    fn consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), codec_error> {
-        write_next(fd, &(Opcodes::UserBurnSupport as u8))?;
-        let truncated_consensus = self.consensus_hash.to_bytes();
-        fd.write_all(&truncated_consensus[0..19])
-            .map_err(codec_error::WriteError)?;
-        fd.write_all(&self.public_key.as_bytes()[..])
-            .map_err(codec_error::WriteError)?;
-        write_next(fd, &self.block_header_hash_160)?;
-        write_next(fd, &self.key_block_ptr)?;
-        write_next(fd, &self.key_vtxindex)?;
-        Ok(())
-    }
-
-    fn consensus_deserialize<R: Read>(_fd: &mut R) -> Result<UserBurnSupportOp, codec_error> {
-        // Op deserialized through burchain indexer
-        unimplemented!();
-    }
-}
-
-impl UserBurnSupportOp {
-    pub fn from_tx(
-        _block_header: &BurnchainBlockHeader,
-        _tx: &BurnchainTransaction,
-    ) -> Result<UserBurnSupportOp, op_error> {
-        Err(op_error::UserBurnSupportNotSupported)
-    }
-
-    pub fn check(&self, burnchain: &Burnchain, tx: &mut SortitionHandleTx) -> Result<(), op_error> {
-        let leader_key_block_height = self.key_block_ptr as u64;
-
-        /////////////////////////////////////////////////////////////////
-        // Consensus hash must be recent and valid
-        /////////////////////////////////////////////////////////////////
-
-        // NOTE: we only care about the first 19 bytes
-        let is_fresh = tx.is_fresh_consensus_hash_check_19b(
-            burnchain.consensus_hash_lifetime.into(),
-            &self.consensus_hash,
-        )?;
-
-        if !is_fresh {
-            warn!(
-                "Invalid user burn: invalid consensus hash {}",
-                &self.consensus_hash
-            );
-            return Err(op_error::UserBurnSupportBadConsensusHash);
-        }
-
-        /////////////////////////////////////////////////////////////////////////////////////
-        // There must exist a previously-accepted LeaderKeyRegisterOp that matches this
-        // user support burn's VRF public key.
-        /////////////////////////////////////////////////////////////////////////////////////
-        if self.key_block_ptr == 0 {
-            warn!("Invalid tx: key block back-pointer must be positive");
-            return Err(op_error::ParseError);
-        }
-
-        if self.key_block_ptr as u64 > self.block_height {
-            warn!(
-                "Invalid tx: key block back-pointer {} exceeds block height {}",
-                self.key_block_ptr, self.block_height
-            );
-            return Err(op_error::ParseError);
-        }
-
-        let chain_tip = tx.context.chain_tip.clone();
-        let register_key_opt = tx.get_leader_key_at(
-            leader_key_block_height,
-            self.key_vtxindex.into(),
-            &chain_tip,
-        )?;
-
-        if register_key_opt.is_none() {
-            warn!(
-                "Invalid user burn: no such leader VRF key {}",
-                &self.public_key.to_hex()
-            );
-            return Err(op_error::UserBurnSupportNoLeaderKey);
-        }
-
-        /////////////////////////////////////////////////////////////////////////////////////
-        // The block hash can't be checked here -- the corresponding LeaderBlockCommitOp may
-        // not have been checked yet, so we don't know yet if it exists.  The sortition
-        // algorithm will carry out this check, and only consider user burns if they match
-        // a block commit and the commit's corresponding leader key.
-        /////////////////////////////////////////////////////////////////////////////////////
-
-        Ok(())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use stacks_common::deps_common::bitcoin::blockdata::transaction::Transaction;
-    use stacks_common::deps_common::bitcoin::network::serialize::deserialize;
-    use stacks_common::types::chainstate::{SortitionId, StacksAddress};
-    use stacks_common::util::hash::{hex_bytes, to_hex, Hash160};
-    use stacks_common::util::{get_epoch_time_secs, log};
-
-    use super::*;
-    use crate::burnchains::bitcoin::address::BitcoinAddress;
-    use crate::burnchains::bitcoin::blocks::BitcoinBlockParser;
-    use crate::burnchains::bitcoin::keys::BitcoinPublicKey;
-    use crate::burnchains::bitcoin::BitcoinNetworkType;
-    use crate::burnchains::*;
-    use crate::chainstate::burn::db::sortdb::*;
-    use crate::chainstate::burn::operations::{
-        BlockstackOperationType, LeaderBlockCommitOp, LeaderKeyRegisterOp, UserBurnSupportOp,
-    };
-    use crate::chainstate::burn::*;
-    use crate::chainstate::stacks::address::StacksAddressExtensions;
-    use crate::chainstate::stacks::index::TrieHashExtension;
-    use crate::core::StacksEpochId;
-
-    struct OpFixture {
-        txstr: String,
-        opstr: String,
-        result: Option<UserBurnSupportOp>,
-    }
-
-    struct CheckFixture {
-        op: UserBurnSupportOp,
-        res: Result<(), op_error>,
-    }
-
-    fn make_tx(hex_str: &str) -> Result<Transaction, &'static str> {
-        let tx_bin = hex_bytes(hex_str).map_err(|_e| "failed to decode hex string")?;
-        let tx = deserialize(&tx_bin.to_vec()).map_err(|_e| "failed to deserialize")?;
-        Ok(tx)
-    }
-
-    #[test]
-    fn test_parse() {
-        let vtxindex = 1;
-        let _block_height = 694;
-        let burn_header_hash = BurnchainHeaderHash::from_hex(
-            "0000000000000000000000000000000000000000000000000000000000000000",
-        )
-        .unwrap();
-
-        let tx_fixtures = vec![
-            OpFixture {
-                txstr: "01000000011111111111111111111111111111111111111111111111111111111111111111000000006a47304402204c51707ac34b6dcbfc518ba40c5fc4ef737bf69cc21a9f8a8e6f621f511f78e002200caca0f102d5df509c045c4fe229d957aa7ef833dc8103dc2fe4db15a22bab9e012102d8015134d9db8178ac93acbc43170a2f20febba5087a5b0437058765ad5133d000000000030000000000000000536a4c5069645f2222222222222222222222222222222222222222a366b51292bef4edd64063d9145c617fec373bceb0758e98cd72becd84d54c7a3333333333333333333333333333333333333333010203040539300000000000001976a914000000000000000000000000000000000000000088aca05b0000000000001976a9140be3e286a15ea85882761618e366586b5574100d88ac00000000".to_string(),
-                opstr: "69645f2222222222222222222222222222222222222222a366b51292bef4edd64063d9145c617fec373bceb0758e98cd72becd84d54c7a33333333333333333333333333333333333333330102030405".to_string(),
-                result: Some(UserBurnSupportOp {
-                    address: StacksAddress::from_legacy_bitcoin_address(&BitcoinAddress::from_string(&"mgbpit8FvkVJ9kuXY8QSM5P7eibnhcEMBk".to_string()).unwrap().expect_legacy()),
-                    consensus_hash: ConsensusHash::from_bytes(&hex_bytes("2222222222222222222222222222222222222200").unwrap()).unwrap(),
-                    public_key: VRFPublicKey::from_bytes(&hex_bytes("22a366b51292bef4edd64063d9145c617fec373bceb0758e98cd72becd84d54c").unwrap()).unwrap(),
-                    block_header_hash_160: Hash160::from_bytes(&hex_bytes("7a33333333333333333333333333333333333333").unwrap()).unwrap(),
-                    key_block_ptr: 0x33010203,
-                    key_vtxindex: 0x0405,
-                    burn_fee: 12345,
-
-                    txid: Txid::from_bytes_be(&hex_bytes("1d5cbdd276495b07f0e0bf0181fa57c175b217bc35531b078d62fc20986c716c").unwrap()).unwrap(),
-                    vtxindex: vtxindex,
-                    block_height: 0x33010203 + 1,
-                    burn_header_hash: burn_header_hash,
-                })
-            },
-            OpFixture {
-                // invalid -- no burn output
-                txstr: "01000000011111111111111111111111111111111111111111111111111111111111111111000000006a473044022073490a3958b9e6128d3b7a4a8c77203c56862b2da382e96551f7efae7029b0e1022046672d1e61bdfd3dca9cc199bffd0bfb9323e432f8431bb6749da3c5bd06e9ca012102d8015134d9db8178ac93acbc43170a2f20febba5087a5b0437058765ad5133d000000000020000000000000000536a4c5069645f2222222222222222222222222222222222222222a366b51292bef4edd64063d9145c617fec373bceb0758e98cd72becd84d54c7a33333333333333333333333333333333333333330102030405a05b0000000000001976a9140be3e286a15ea85882761618e366586b5574100d88ac00000000".to_string(),
-                opstr: "69645f2222222222222222222222222222222222222222a366b51292bef4edd64063d9145c617fec373bceb0758e98cd72becd84d54c7a33333333333333333333333333333333333333330102030405".to_string(),
-                result: None,
-            },
-            OpFixture {
-                // invalid -- bad public key
-                txstr: "01000000011111111111111111111111111111111111111111111111111111111111111111000000006a47304402202bf944fa4d1dbbdd4f53e915c85f07c8a5afbf917f7cc9169e9c7d3bbadff05a022064b33a1020dd9cdd0ac6de213ee1bd8f364c9c876e716ad289f324c2a4bbe48a012102d8015134d9db8178ac93acbc43170a2f20febba5087a5b0437058765ad5133d000000000030000000000000000536a4c5069645f2222222222222222222222222222222222222222a366b51292bef4edd64063d9145c617fec373bceb0758e98cd72becd84d54c7b3333333333333333333333333333333333333333010203040539300000000000001976a914000000000000000000000000000000000000000088aca05b0000000000001976a9140be3e286a15ea85882761618e366586b5574100d88ac00000000".to_string(),
-                opstr: "69645f2222222222222222222222222222222222222222a366b51292bef4edd64063d9145c617fec373bceb0758e98cd72becd84d54c7a33333333333333333333333333333333333333330102030405".to_string(),
-                result: None,
-            },
-            OpFixture {
-                // invalid -- too short 
-                txstr: "01000000011111111111111111111111111111111111111111111111111111111111111111000000006a473044022038534377d738ba91df50a4bc885bcd6328520438d42cc29636cc299a24dcb4c202202953e87b6c176697d01d66a742a27fd48b8d2167fb9db184d59a3be23a59992e012102d8015134d9db8178ac93acbc43170a2f20febba5087a5b0437058765ad5133d0000000000300000000000000004c6a4a69645f2222222222222222222222222222222222222222a366b51292bef4edd64063d9145c617fec373bceb0758e98cd72becd84d54c7a3333333333333333333333333333333333333339300000000000001976a914000000000000000000000000000000000000000088aca05b0000000000001976a9140be3e286a15ea85882761618e366586b5574100d88ac00000000".to_string(),
-                opstr: "69645f2222222222222222222222222222222222222222a366b51292bef4edd64063d9145c617fec373bceb0758e98cd72becd84d54c7a33333333333333333333333333333333333333330102030405".to_string(),
-                result: None,
-            },
-            OpFixture {
-                // invalid -- wrong opcode
-                txstr: "01000000011111111111111111111111111111111111111111111111111111111111111111000000006a47304402200e6dbb4ccefc44582135091678a49228716431583dab3d789b1211d5737d02e402205b523ad156cad4ae6bb29f046b144c8c82b7c85698616ee8f5d59ea40d594dd4012102d8015134d9db8178ac93acbc43170a2f20febba5087a5b0437058765ad5133d000000000030000000000000000536a4c5069645e2222222222222222222222222222222222222222a366b51292bef4edd64063d9145c617fec373bceb0758e98cd72becd84d54c7a3333333333333333333333333333333333333333010203040539300000000000001976a914000000000000000000000000000000000000000088aca05b0000000000001976a9140be3e286a15ea85882761618e366586b5574100d88ac00000000".to_string(),
-                opstr: "69645f2222222222222222222222222222222222222222a366b51292bef4edd64063d9145c617fec373bceb0758e98cd72becd84d54c7a33333333333333333333333333333333333333330102030405".to_string(),
-                result: None,
-            }
-        ];
-
-        let parser = BitcoinBlockParser::new(BitcoinNetworkType::Testnet, BLOCKSTACK_MAGIC_MAINNET);
-
-        for tx_fixture in tx_fixtures {
-            let tx = make_tx(&tx_fixture.txstr).unwrap();
-            let burnchain_tx = BurnchainTransaction::Bitcoin(
-                parser
-                    .parse_tx(&tx, vtxindex as usize, StacksEpochId::Epoch2_05)
-                    .unwrap(),
-            );
-
-            let header = match tx_fixture.result {
-                Some(ref op) => BurnchainBlockHeader {
-                    block_height: op.block_height,
-                    block_hash: op.burn_header_hash.clone(),
-                    parent_block_hash: op.burn_header_hash.clone(),
-                    num_txs: 1,
-                    timestamp: get_epoch_time_secs(),
-                },
-                None => BurnchainBlockHeader {
-                    block_height: 0,
-                    block_hash: BurnchainHeaderHash::zero(),
-                    parent_block_hash: BurnchainHeaderHash::zero(),
-                    num_txs: 0,
-                    timestamp: get_epoch_time_secs(),
-                },
-            };
-
-            let op = UserBurnSupportOp::parse_from_tx(
-                header.block_height,
-                &header.block_hash,
-                &burnchain_tx,
-            );
-
-            match (op, tx_fixture.result) {
-                (Ok(parsed_tx), Some(result)) => {
-                    let opstr = {
-                        let mut buffer = vec![];
-                        let mut magic_bytes = BLOCKSTACK_MAGIC_MAINNET.as_bytes().to_vec();
-                        buffer.append(&mut magic_bytes);
-                        parsed_tx
-                            .consensus_serialize(&mut buffer)
-                            .expect("FATAL: invalid operation");
-                        to_hex(&buffer)
-                    };
-
-                    assert_eq!(tx_fixture.opstr, opstr);
-                    assert_eq!(parsed_tx, result);
-                }
-                (Err(_e), None) => {}
-                (Ok(_parsed_tx), None) => {
-                    test_debug!("Parsed a tx when we should not have");
-                    assert!(false);
-                }
-                (Err(_e), Some(_result)) => {
-                    test_debug!("Did not parse a tx when we should have: {:?}", _result);
-                    assert!(false);
-                }
-            };
-        }
-    }
-
-    #[test]
-    fn test_check() {
-        let first_block_height = 121;
-        let first_burn_hash = BurnchainHeaderHash::from_hex(
-            "0000000000000000000000000000000000000000000000000000000000000123",
-        )
-        .unwrap();
-
-        let block_122_hash = BurnchainHeaderHash::from_hex(
-            "0000000000000000000000000000000000000000000000000000000000000002",
-        )
-        .unwrap();
-        let block_123_hash = BurnchainHeaderHash::from_hex(
-            "0000000000000000000000000000000000000000000000000000000000000003",
-        )
-        .unwrap();
-        let block_124_hash = BurnchainHeaderHash::from_hex(
-            "0000000000000000000000000000000000000000000000000000000000000004",
-        )
-        .unwrap();
-        let block_125_hash = BurnchainHeaderHash::from_hex(
-            "0000000000000000000000000000000000000000000000000000000000000005",
-        )
-        .unwrap();
-        let block_126_hash = BurnchainHeaderHash::from_hex(
-            "0000000000000000000000000000000000000000000000000000000000000006",
-        )
-        .unwrap();
-        let block_127_hash = BurnchainHeaderHash::from_hex(
-            "0000000000000000000000000000000000000000000000000000000000000007",
-        )
-        .unwrap();
-        let block_128_hash = BurnchainHeaderHash::from_hex(
-            "0000000000000000000000000000000000000000000000000000000000000008",
-        )
-        .unwrap();
-        let block_129_hash = BurnchainHeaderHash::from_hex(
-            "0000000000000000000000000000000000000000000000000000000000000009",
-        )
-        .unwrap();
-        let block_130_hash = BurnchainHeaderHash::from_hex(
-            "000000000000000000000000000000000000000000000000000000000000000a",
-        )
-        .unwrap();
-        let block_131_hash = BurnchainHeaderHash::from_hex(
-            "000000000000000000000000000000000000000000000000000000000000000b",
-        )
-        .unwrap();
-
-        let block_header_hashes = [
-            block_122_hash.clone(),
-            block_123_hash.clone(),
-            block_124_hash.clone(),
-            block_125_hash.clone(),
-            block_126_hash.clone(),
-            block_127_hash.clone(),
-            block_128_hash.clone(),
-            block_129_hash.clone(),
-            block_130_hash.clone(),
-            block_131_hash.clone(),
-        ];
-        let burnchain = Burnchain {
-            pox_constants: PoxConstants::test_default(),
-            peer_version: 0x012345678,
-            network_id: 0x9abcdef0,
-            chain_name: "bitcoin".to_string(),
-            network_name: "testnet".to_string(),
-            working_dir: "/nope".to_string(),
-            consensus_hash_lifetime: 24,
-            stable_confirmations: 7,
-            first_block_height,
-            initial_reward_start_block: first_block_height,
-            first_block_timestamp: 0,
-            first_block_hash: first_burn_hash.clone(),
-        };
-
-        let mut db = SortitionDB::connect_test(first_block_height, &first_burn_hash).unwrap();
-
-        let leader_key_1 = LeaderKeyRegisterOp {
-            consensus_hash: ConsensusHash::from_bytes(
-                &hex_bytes("0000000000000000000000000000000000000000").unwrap(),
-            )
-            .unwrap(),
-            public_key: VRFPublicKey::from_bytes(
-                &hex_bytes("a366b51292bef4edd64063d9145c617fec373bceb0758e98cd72becd84d54c7a")
-                    .unwrap(),
-            )
-            .unwrap(),
-            memo: vec![01, 02, 03, 04, 05],
-
-            txid: Txid::from_bytes_be(
-                &hex_bytes("1bfa831b5fc56c858198acb8e77e5863c1e9d8ac26d49ddb914e24d8d4083562")
-                    .unwrap(),
-            )
-            .unwrap(),
-            vtxindex: 456,
-            block_height: 123,
-            burn_header_hash: block_123_hash.clone(),
-        };
-
-        let block_ops = vec![
-            // 122
-            vec![],
-            // 123
-            vec![BlockstackOperationType::LeaderKeyRegister(
-                leader_key_1.clone(),
-            )],
-            // 124
-            vec![],
-            // 125
-            vec![],
-            // 126
-            vec![],
-            // 127
-            vec![],
-            // 128
-            vec![],
-            // 129
-            vec![],
-            // 130
-            vec![],
-            // 131
-            vec![],
-        ];
-
-        // populate consensus hashes
-        let tip_index_root = {
-            let mut prev_snapshot = SortitionDB::get_first_block_snapshot(db.conn()).unwrap();
-            for i in 0..10 {
-                let mut snapshot_row = BlockSnapshot {
-                    accumulated_coinbase_ustx: 0,
-                    pox_valid: true,
-                    block_height: i + 1 + first_block_height,
-                    burn_header_timestamp: get_epoch_time_secs(),
-                    burn_header_hash: block_header_hashes[i as usize].clone(),
-                    sortition_id: SortitionId(block_header_hashes[i as usize].0.clone()),
-                    parent_sortition_id: prev_snapshot.sortition_id.clone(),
-                    parent_burn_header_hash: prev_snapshot.burn_header_hash.clone(),
-                    consensus_hash: ConsensusHash::from_bytes(&[
-                        0,
-                        0,
-                        0,
-                        0,
-                        0,
-                        0,
-                        0,
-                        0,
-                        0,
-                        0,
-                        0,
-                        0,
-                        0,
-                        0,
-                        0,
-                        0,
-                        0,
-                        0,
-                        0,
-                        (i + 1) as u8,
-                    ])
-                    .unwrap(),
-                    ops_hash: OpsHash::from_bytes(&[
-                        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-                        0, 0, 0, 0, 0, 0, i as u8,
-                    ])
-                    .unwrap(),
-                    total_burn: i,
-                    sortition: true,
-                    sortition_hash: SortitionHash::initial(),
-                    winning_block_txid: Txid::from_hex(
-                        "0000000000000000000000000000000000000000000000000000000000000000",
-                    )
-                    .unwrap(),
-                    winning_stacks_block_hash: BlockHeaderHash::from_hex(
-                        "0000000000000000000000000000000000000000000000000000000000000000",
-                    )
-                    .unwrap(),
-                    index_root: TrieHash::from_empty_data(),
-                    num_sortitions: i + 1,
-                    stacks_block_accepted: false,
-                    stacks_block_height: 0,
-                    arrival_index: 0,
-                    canonical_stacks_tip_height: 0,
-                    canonical_stacks_tip_hash: BlockHeaderHash([0u8; 32]),
-                    canonical_stacks_tip_consensus_hash: ConsensusHash([0u8; 20]),
-                    ..BlockSnapshot::initial(0, &first_burn_hash, 0)
-                };
-                let mut tx =
-                    SortitionHandleTx::begin(&mut db, &prev_snapshot.sortition_id).unwrap();
-
-                let tip_index_root = tx
-                    .append_chain_tip_snapshot(
-                        &prev_snapshot,
-                        &snapshot_row,
-                        &block_ops[i as usize],
-                        &vec![],
-                        None,
-                        None,
-                        None,
-                    )
-                    .unwrap();
-                snapshot_row.index_root = tip_index_root;
-
-                tx.commit().unwrap();
-                prev_snapshot = snapshot_row;
-            }
-
-            prev_snapshot.index_root.clone()
-        };
-
-        let check_fixtures = vec![
-            CheckFixture {
-                // reject -- bad consensus hash
-                op: UserBurnSupportOp {
-                    address: StacksAddress::new(1, Hash160([1u8; 20])),
-                    consensus_hash: ConsensusHash::from_bytes(
-                        &hex_bytes("1000000000000000000000000000000000000000").unwrap(),
-                    )
-                    .unwrap(),
-                    public_key: VRFPublicKey::from_bytes(
-                        &hex_bytes(
-                            "a366b51292bef4edd64063d9145c617fec373bceb0758e98cd72becd84d54c7a",
-                        )
-                        .unwrap(),
-                    )
-                    .unwrap(),
-                    block_header_hash_160: Hash160::from_bytes(
-                        &hex_bytes("7150f635054b87df566a970b21e07030d6444bf2").unwrap(),
-                    )
-                    .unwrap(), // 22222....2222
-                    key_block_ptr: 123,
-                    key_vtxindex: 456,
-                    burn_fee: 10000,
-
-                    txid: Txid::from_bytes_be(
-                        &hex_bytes(
-                            "1d5cbdd276495b07f0e0bf0181fa57c175b217bc35531b078d62fc20986c716b",
-                        )
-                        .unwrap(),
-                    )
-                    .unwrap(),
-                    vtxindex: 13,
-                    block_height: 124,
-                    burn_header_hash: block_124_hash.clone(),
-                },
-                res: Err(op_error::UserBurnSupportBadConsensusHash),
-            },
-            CheckFixture {
-                // reject -- no leader key
-                op: UserBurnSupportOp {
-                    address: StacksAddress::new(1, Hash160([1u8; 20])),
-                    consensus_hash: ConsensusHash::from_bytes(
-                        &hex_bytes("0000000000000000000000000000000000000000").unwrap(),
-                    )
-                    .unwrap(),
-                    public_key: VRFPublicKey::from_bytes(
-                        &hex_bytes(
-                            "bb519494643f79f1dea0350e6fb9a1da88dfdb6137117fc2523824a8aa44fe1c",
-                        )
-                        .unwrap(),
-                    )
-                    .unwrap(),
-                    block_header_hash_160: Hash160::from_bytes(
-                        &hex_bytes("7150f635054b87df566a970b21e07030d6444bf2").unwrap(),
-                    )
-                    .unwrap(), // 22222....2222
-                    key_block_ptr: 123,
-                    key_vtxindex: 457,
-                    burn_fee: 10000,
-
-                    txid: Txid::from_bytes_be(
-                        &hex_bytes(
-                            "1d5cbdd276495b07f0e0bf0181fa57c175b217bc35531b078d62fc20986c716b",
-                        )
-                        .unwrap(),
-                    )
-                    .unwrap(),
-                    vtxindex: 13,
-                    block_height: 124,
-                    burn_header_hash: block_124_hash.clone(),
-                },
-                res: Err(op_error::UserBurnSupportNoLeaderKey),
-            },
-            CheckFixture {
-                // accept
-                op: UserBurnSupportOp {
-                    address: StacksAddress::new(1, Hash160([1u8; 20])),
-                    consensus_hash: ConsensusHash::from_bytes(
-                        &hex_bytes("0000000000000000000000000000000000000000").unwrap(),
-                    )
-                    .unwrap(),
-                    public_key: VRFPublicKey::from_bytes(
-                        &hex_bytes(
-                            "a366b51292bef4edd64063d9145c617fec373bceb0758e98cd72becd84d54c7a",
-                        )
-                        .unwrap(),
-                    )
-                    .unwrap(),
-                    block_header_hash_160: Hash160::from_bytes(
-                        &hex_bytes("7150f635054b87df566a970b21e07030d6444bf2").unwrap(),
-                    )
-                    .unwrap(), // 22222....2222
-                    key_block_ptr: 123,
-                    key_vtxindex: 456,
-                    burn_fee: 10000,
-
-                    txid: Txid::from_bytes_be(
-                        &hex_bytes(
-                            "1d5cbdd276495b07f0e0bf0181fa57c175b217bc35531b078d62fc20986c716b",
-                        )
-                        .unwrap(),
-                    )
-                    .unwrap(),
-                    vtxindex: 13,
-                    block_height: 124,
-                    burn_header_hash: block_124_hash.clone(),
-                },
-                res: Ok(()),
-            },
-        ];
-
-        for fixture in check_fixtures {
-            let header = BurnchainBlockHeader {
-                block_height: fixture.op.block_height,
-                block_hash: fixture.op.burn_header_hash.clone(),
-                parent_block_hash: fixture.op.burn_header_hash.clone(),
-                num_txs: 1,
-                timestamp: get_epoch_time_secs(),
-            };
-            let mut ic = SortitionHandleTx::begin(
-                &mut db,
-                &SortitionId::stubbed(&fixture.op.burn_header_hash),
-            )
-            .unwrap();
-            assert_eq!(
-                format!("{:?}", &fixture.res),
-                format!("{:?}", &fixture.op.check(&burnchain, &mut ic))
-            );
-        }
-    }
-}
diff --git a/stackslib/src/chainstate/burn/sortition.rs b/stackslib/src/chainstate/burn/sortition.rs
index 95990e1652..865b4f432d 100644
--- a/stackslib/src/chainstate/burn/sortition.rs
+++ b/stackslib/src/chainstate/burn/sortition.rs
@@ -31,7 +31,7 @@ use crate::burnchains::{
 use crate::chainstate::burn::db::sortdb::SortitionHandleTx;
 use crate::chainstate::burn::distribution::BurnSamplePoint;
 use crate::chainstate::burn::operations::{
-    BlockstackOperationType, LeaderBlockCommitOp, LeaderKeyRegisterOp, UserBurnSupportOp,
+    BlockstackOperationType, LeaderBlockCommitOp, LeaderKeyRegisterOp,
 };
 use crate::chainstate::burn::{
     BlockSnapshot, BurnchainHeaderHash, ConsensusHash, ConsensusHashExtensions, OpsHash,
@@ -578,7 +578,6 @@ mod test {
                     .unwrap(),
                 ),
             ),
-            user_burns: vec![],
         };
 
         let snapshot_no_burns = {
diff --git a/stackslib/src/chainstate/nakamoto/tests/node.rs b/stackslib/src/chainstate/nakamoto/tests/node.rs
index b34cd130cc..a9da6c5379 100644
--- a/stackslib/src/chainstate/nakamoto/tests/node.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/node.rs
@@ -40,7 +40,7 @@ use crate::burnchains::tests::*;
 use crate::burnchains::*;
 use crate::chainstate::burn::db::sortdb::*;
 use crate::chainstate::burn::operations::{
-    BlockstackOperationType, LeaderBlockCommitOp, LeaderKeyRegisterOp, UserBurnSupportOp,
+    BlockstackOperationType, LeaderBlockCommitOp, LeaderKeyRegisterOp,
 };
 use crate::chainstate::burn::*;
 use crate::chainstate::coordinator::{
diff --git a/stackslib/src/chainstate/stacks/db/blocks.rs b/stackslib/src/chainstate/stacks/db/blocks.rs
index ba190d9811..394b9681f8 100644
--- a/stackslib/src/chainstate/stacks/db/blocks.rs
+++ b/stackslib/src/chainstate/stacks/db/blocks.rs
@@ -1763,34 +1763,6 @@ impl StacksChainState {
         Ok(())
     }
 
-    /// Store users who burned in support of a block
-    fn store_staging_block_user_burn_supports<'a>(
-        tx: &mut DBTx<'a>,
-        consensus_hash: &ConsensusHash,
-        block_hash: &BlockHeaderHash,
-        burn_supports: &[UserBurnSupportOp],
-    ) -> Result<(), Error> {
-        for burn_support in burn_supports.iter() {
-            assert!(burn_support.burn_fee < u64::try_from(i64::MAX).expect("unreachable"));
-        }
-
-        for burn_support in burn_supports.iter() {
-            let sql = "INSERT OR REPLACE INTO staging_user_burn_support (anchored_block_hash, consensus_hash, address, burn_amount, vtxindex) VALUES (?1, ?2, ?3, ?4, ?5)";
-            let args: &[&dyn ToSql] = &[
-                &consensus_hash,
-                &block_hash,
-                &burn_support.address.to_string(),
-                &u64_to_sql(burn_support.burn_fee)?,
-                &burn_support.vtxindex,
-            ];
-
-            tx.execute(&sql, args)
-                .map_err(|e| Error::DBError(db_error::SqliteError(e)))?;
-        }
-
-        Ok(())
-    }
-
     /// Read all the i64 values from a query (possibly none).
     fn read_i64s(conn: &DBConn, query: &str, args: &[&dyn ToSql]) -> Result<Vec<i64>, Error> {
         let mut stmt = conn
@@ -3495,9 +3467,6 @@ impl StacksChainState {
             return Ok(false);
         }
 
-        // find all user burns that supported this block
-        let user_burns = sort_handle.get_winning_user_burns_by_block()?;
-
         // does this block match the burnchain state? skip if not
         let validation_res = StacksChainState::validate_anchored_block_burnchain(
             &block_tx,
@@ -3552,14 +3521,6 @@ impl StacksChainState {
             download_time,
         )?;
 
-        // store users who burned for this block so they'll get rewarded if we process it
-        StacksChainState::store_staging_block_user_burn_supports(
-            &mut block_tx,
-            consensus_hash,
-            &block.block_hash(),
-            &user_burns,
-        )?;
-
         block_tx.commit()?;
 
         debug!(
diff --git a/stackslib/src/chainstate/stacks/tests/accounting.rs b/stackslib/src/chainstate/stacks/tests/accounting.rs
index d1fc9a46fd..e11224ab62 100644
--- a/stackslib/src/chainstate/stacks/tests/accounting.rs
+++ b/stackslib/src/chainstate/stacks/tests/accounting.rs
@@ -37,7 +37,7 @@ use crate::burnchains::tests::*;
 use crate::burnchains::*;
 use crate::chainstate::burn::db::sortdb::*;
 use crate::chainstate::burn::operations::{
-    BlockstackOperationType, LeaderBlockCommitOp, LeaderKeyRegisterOp, UserBurnSupportOp,
+    BlockstackOperationType, LeaderBlockCommitOp, LeaderKeyRegisterOp,
 };
 use crate::chainstate::burn::*;
 use crate::chainstate::coordinator::Error as CoordinatorError;
diff --git a/stackslib/src/chainstate/stacks/tests/block_construction.rs b/stackslib/src/chainstate/stacks/tests/block_construction.rs
index 7ca20d3dbb..7e241bad48 100644
--- a/stackslib/src/chainstate/stacks/tests/block_construction.rs
+++ b/stackslib/src/chainstate/stacks/tests/block_construction.rs
@@ -43,7 +43,7 @@ use crate::burnchains::tests::*;
 use crate::burnchains::*;
 use crate::chainstate::burn::db::sortdb::*;
 use crate::chainstate::burn::operations::{
-    BlockstackOperationType, LeaderBlockCommitOp, LeaderKeyRegisterOp, UserBurnSupportOp,
+    BlockstackOperationType, LeaderBlockCommitOp, LeaderKeyRegisterOp,
 };
 use crate::chainstate::burn::*;
 use crate::chainstate::coordinator::Error as CoordinatorError;
diff --git a/stackslib/src/chainstate/stacks/tests/chain_histories.rs b/stackslib/src/chainstate/stacks/tests/chain_histories.rs
index 1ce598dbc9..fae7a66b42 100644
--- a/stackslib/src/chainstate/stacks/tests/chain_histories.rs
+++ b/stackslib/src/chainstate/stacks/tests/chain_histories.rs
@@ -42,7 +42,7 @@ use crate::burnchains::tests::*;
 use crate::burnchains::*;
 use crate::chainstate::burn::db::sortdb::*;
 use crate::chainstate::burn::operations::{
-    BlockstackOperationType, LeaderBlockCommitOp, LeaderKeyRegisterOp, UserBurnSupportOp,
+    BlockstackOperationType, LeaderBlockCommitOp, LeaderKeyRegisterOp,
 };
 use crate::chainstate::burn::*;
 use crate::chainstate::coordinator::Error as CoordinatorError;
diff --git a/stackslib/src/chainstate/stacks/tests/mod.rs b/stackslib/src/chainstate/stacks/tests/mod.rs
index e0b48f8d71..22a331b193 100644
--- a/stackslib/src/chainstate/stacks/tests/mod.rs
+++ b/stackslib/src/chainstate/stacks/tests/mod.rs
@@ -34,7 +34,7 @@ use crate::burnchains::tests::*;
 use crate::burnchains::*;
 use crate::chainstate::burn::db::sortdb::*;
 use crate::chainstate::burn::operations::{
-    BlockstackOperationType, LeaderBlockCommitOp, LeaderKeyRegisterOp, UserBurnSupportOp,
+    BlockstackOperationType, LeaderBlockCommitOp, LeaderKeyRegisterOp,
 };
 use crate::chainstate::burn::*;
 use crate::chainstate::coordinator::Error as CoordinatorError;
diff --git a/stackslib/src/net/mod.rs b/stackslib/src/net/mod.rs
index 0c1725d6b9..fbdc914fb7 100644
--- a/stackslib/src/net/mod.rs
+++ b/stackslib/src/net/mod.rs
@@ -1672,7 +1672,6 @@ pub mod test {
             match self {
                 BlockstackOperationType::LeaderKeyRegister(ref op) => op.consensus_serialize(fd),
                 BlockstackOperationType::LeaderBlockCommit(ref op) => op.consensus_serialize(fd),
-                BlockstackOperationType::UserBurnSupport(ref op) => op.consensus_serialize(fd),
                 BlockstackOperationType::TransferStx(_)
                 | BlockstackOperationType::DelegateStx(_)
                 | BlockstackOperationType::PreStx(_)
@@ -2743,9 +2742,6 @@ pub mod test {
                     BlockstackOperationType::LeaderKeyRegister(ref mut data) => {
                         data.consensus_hash = (*ch).clone();
                     }
-                    BlockstackOperationType::UserBurnSupport(ref mut data) => {
-                        data.consensus_hash = (*ch).clone();
-                    }
                     _ => {}
                 }
             }
diff --git a/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs b/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
index bb04fc4b90..f2e6f69542 100644
--- a/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
+++ b/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
@@ -29,7 +29,7 @@ use stacks::burnchains::{
 use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::burn::operations::{
     BlockstackOperationType, DelegateStxOp, LeaderBlockCommitOp, LeaderKeyRegisterOp, PreStxOp,
-    TransferStxOp, UserBurnSupportOp,
+    TransferStxOp,
 };
 #[cfg(test)]
 use stacks::chainstate::burn::Opcodes;
@@ -900,8 +900,7 @@ impl BitcoinRegtestController {
             BlockstackOperationType::LeaderBlockCommit(_)
             | BlockstackOperationType::LeaderKeyRegister(_)
             | BlockstackOperationType::StackStx(_)
-            | BlockstackOperationType::DelegateStx(_)
-            | BlockstackOperationType::UserBurnSupport(_) => {
+            | BlockstackOperationType::DelegateStx(_) => {
                 unimplemented!();
             }
             BlockstackOperationType::PreStx(payload) => {
@@ -1664,16 +1663,6 @@ impl BitcoinRegtestController {
         true
     }
 
-    fn build_user_burn_support_tx(
-        &mut self,
-        _epoch_id: StacksEpochId,
-        _payload: UserBurnSupportOp,
-        _signer: &mut BurnchainOpSigner,
-        _attempt: u64,
-    ) -> Option<Transaction> {
-        unimplemented!()
-    }
-
     /// Send a serialized tx to the Bitcoin node.  Return Some(txid) on successful send; None on
     /// failure.
     pub fn send_transaction(&self, transaction: SerializedTx) -> Option<Txid> {
@@ -1830,9 +1819,6 @@ impl BitcoinRegtestController {
             BlockstackOperationType::LeaderKeyRegister(payload) => {
                 self.build_leader_key_register_tx(epoch_id, payload, op_signer, attempt)
             }
-            BlockstackOperationType::UserBurnSupport(payload) => {
-                self.build_user_burn_support_tx(epoch_id, payload, op_signer, attempt)
-            }
             BlockstackOperationType::PreStx(payload) => {
                 self.build_pre_stacks_tx(epoch_id, payload, op_signer)
             }
diff --git a/testnet/stacks-node/src/burnchains/mocknet_controller.rs b/testnet/stacks-node/src/burnchains/mocknet_controller.rs
index 0c1ae9c84e..7b43ce1c8f 100644
--- a/testnet/stacks-node/src/burnchains/mocknet_controller.rs
+++ b/testnet/stacks-node/src/burnchains/mocknet_controller.rs
@@ -10,7 +10,7 @@ use stacks::chainstate::burn::db::sortdb::{SortitionDB, SortitionHandleTx};
 use stacks::chainstate::burn::operations::leader_block_commit::BURN_BLOCK_MINED_AT_MODULUS;
 use stacks::chainstate::burn::operations::{
     BlockstackOperationType, DelegateStxOp, LeaderBlockCommitOp, LeaderKeyRegisterOp, PreStxOp,
-    StackStxOp, TransferStxOp, UserBurnSupportOp,
+    StackStxOp, TransferStxOp,
 };
 use stacks::chainstate::burn::BlockSnapshot;
 use stacks::core::{
@@ -221,21 +221,6 @@ impl BurnchainController for MocknetController {
                         burn_header_hash: next_block_header.block_hash,
                     })
                 }
-                BlockstackOperationType::UserBurnSupport(payload) => {
-                    BlockstackOperationType::UserBurnSupport(UserBurnSupportOp {
-                        address: payload.address,
-                        consensus_hash: payload.consensus_hash,
-                        public_key: payload.public_key,
-                        key_block_ptr: payload.key_block_ptr,
-                        key_vtxindex: payload.key_vtxindex,
-                        block_header_hash_160: payload.block_header_hash_160,
-                        burn_fee: payload.burn_fee,
-                        txid: payload.txid,
-                        vtxindex: payload.vtxindex,
-                        block_height: next_block_header.block_height,
-                        burn_header_hash: next_block_header.block_hash,
-                    })
-                }
                 BlockstackOperationType::PreStx(payload) => {
                     BlockstackOperationType::PreStx(PreStxOp {
                         block_height: next_block_header.block_height,
diff --git a/testnet/stacks-node/src/chain_data.rs b/testnet/stacks-node/src/chain_data.rs
index ac1ff4199b..4170cf6f6d 100644
--- a/testnet/stacks-node/src/chain_data.rs
+++ b/testnet/stacks-node/src/chain_data.rs
@@ -657,7 +657,6 @@ pub mod tests {
                     0x41a3ed94d3cb0a84,
                 ]),
                 candidate: block_commit_1.clone(),
-                user_burns: vec![],
             },
             BurnSamplePoint {
                 burns: block_commit_2.burn_fee.into(),
@@ -675,7 +674,6 @@ pub mod tests {
                     0x8347db29a7961508,
                 ]),
                 candidate: block_commit_2.clone(),
-                user_burns: vec![],
             },
             BurnSamplePoint {
                 burns: (block_commit_3.burn_fee).into(),
@@ -688,7 +686,6 @@ pub mod tests {
                 ]),
                 range_end: Uint256::max(),
                 candidate: block_commit_3.clone(),
-                user_burns: vec![],
             },
         ];
 

From ef5169bec0fdb328dfdf28f1fae8d3c65cfd440c Mon Sep 17 00:00:00 2001
From: Marzi <marzi@trustmachines.co>
Date: Wed, 14 Feb 2024 15:05:00 -0500
Subject: [PATCH 0940/1166] Cargo Format

---
 stackslib/src/burnchains/tests/burnchain.rs |   6 +-
 stackslib/src/burnchains/tests/mod.rs       | 105 +++++++++-----------
 stackslib/src/chainstate/burn/db/sortdb.rs  |   6 +-
 3 files changed, 55 insertions(+), 62 deletions(-)

diff --git a/stackslib/src/burnchains/tests/burnchain.rs b/stackslib/src/burnchains/tests/burnchain.rs
index c73543cb48..97c9366fec 100644
--- a/stackslib/src/burnchains/tests/burnchain.rs
+++ b/stackslib/src/burnchains/tests/burnchain.rs
@@ -360,9 +360,9 @@ fn test_process_block_ops() {
         miner_pk_hash: None,
     };
 
-    let block_ops_123 = vec![
-        BlockstackOperationType::LeaderKeyRegister(leader_key_1.clone()),
-    ];
+    let block_ops_123 = vec![BlockstackOperationType::LeaderKeyRegister(
+        leader_key_1.clone(),
+    )];
     let block_opshash_123 = OpsHash::from_txids(&vec![
         // notably, the user burns here _wont_ be included in the consensus hash
         leader_key_1.txid.clone(),
diff --git a/stackslib/src/burnchains/tests/mod.rs b/stackslib/src/burnchains/tests/mod.rs
index a63e7a31d4..fc7f6993a8 100644
--- a/stackslib/src/burnchains/tests/mod.rs
+++ b/stackslib/src/burnchains/tests/mod.rs
@@ -902,14 +902,13 @@ fn mine_10_stacks_blocks_1_fork() {
             next_block_hashes.push(hash);
         }
 
-        let (next_snapshot, mut next_prev_keys, next_block_commits) =
-            process_next_sortition(
-                &mut node,
-                &mut fork,
-                &mut miners,
-                &prev_keys,
-                &next_block_hashes,
-            );
+        let (next_snapshot, mut next_prev_keys, next_block_commits) = process_next_sortition(
+            &mut node,
+            &mut fork,
+            &mut miners,
+            &prev_keys,
+            &next_block_hashes,
+        );
 
         verify_keys_accepted(&mut node, &prev_keys);
         verify_commits_accepted(&mut node, &next_block_commits);
@@ -951,14 +950,13 @@ fn mine_10_stacks_blocks_2_forks_disjoint() {
             next_block_hashes.push(hash);
         }
 
-        let (next_snapshot, mut next_prev_keys, next_block_commits) =
-            process_next_sortition(
-                &mut node,
-                &mut fork_1,
-                &mut miners,
-                &prev_keys_1,
-                &next_block_hashes,
-            );
+        let (next_snapshot, mut next_prev_keys, next_block_commits) = process_next_sortition(
+            &mut node,
+            &mut fork_1,
+            &mut miners,
+            &prev_keys_1,
+            &next_block_hashes,
+        );
 
         verify_keys_accepted(&mut node, &prev_keys_1);
         verify_commits_accepted(&mut node, &next_block_commits);
@@ -1004,22 +1002,20 @@ fn mine_10_stacks_blocks_2_forks_disjoint() {
             next_block_hashes_2.push(hash);
         }
 
-        let (next_snapshot_1, mut next_prev_keys_1, next_block_commits_1) =
-            process_next_sortition(
-                &mut node,
-                &mut fork_1,
-                &mut miners_1,
-                &prev_keys_1,
-                &next_block_hashes_1,
-            );
-        let (next_snapshot_2, mut next_prev_keys_2, next_block_commits_2) =
-            process_next_sortition(
-                &mut node,
-                &mut fork_2,
-                &mut miners_2,
-                &prev_keys_2,
-                &next_block_hashes_2,
-            );
+        let (next_snapshot_1, mut next_prev_keys_1, next_block_commits_1) = process_next_sortition(
+            &mut node,
+            &mut fork_1,
+            &mut miners_1,
+            &prev_keys_1,
+            &next_block_hashes_1,
+        );
+        let (next_snapshot_2, mut next_prev_keys_2, next_block_commits_2) = process_next_sortition(
+            &mut node,
+            &mut fork_2,
+            &mut miners_2,
+            &prev_keys_2,
+            &next_block_hashes_2,
+        );
 
         assert!(next_snapshot_1.burn_header_hash != next_snapshot_2.burn_header_hash);
 
@@ -1069,14 +1065,13 @@ fn mine_10_stacks_blocks_2_forks_disjoint_same_blocks() {
             next_block_hashes.push(hash);
         }
 
-        let (snapshot, mut next_prev_keys, next_block_commits) =
-            process_next_sortition(
-                &mut node,
-                &mut fork_1,
-                &mut miners,
-                &prev_keys_1,
-                &next_block_hashes,
-            );
+        let (snapshot, mut next_prev_keys, next_block_commits) = process_next_sortition(
+            &mut node,
+            &mut fork_1,
+            &mut miners,
+            &prev_keys_1,
+            &next_block_hashes,
+        );
 
         verify_keys_accepted(&mut node, &prev_keys_1);
         verify_commits_accepted(&mut node, &next_block_commits);
@@ -1124,22 +1119,20 @@ fn mine_10_stacks_blocks_2_forks_disjoint_same_blocks() {
             next_block_hashes_2.push(hash);
         }
 
-        let (snapshot_1, mut next_prev_keys_1, next_block_commits_1) =
-            process_next_sortition(
-                &mut node,
-                &mut fork_1,
-                &mut miners_1,
-                &prev_keys_1,
-                &next_block_hashes_1,
-            );
-        let (snapshot_2, mut next_prev_keys_2, next_block_commits_2) =
-            process_next_sortition(
-                &mut node,
-                &mut fork_2,
-                &mut miners_2,
-                &prev_keys_2,
-                &next_block_hashes_2,
-            );
+        let (snapshot_1, mut next_prev_keys_1, next_block_commits_1) = process_next_sortition(
+            &mut node,
+            &mut fork_1,
+            &mut miners_1,
+            &prev_keys_1,
+            &next_block_hashes_1,
+        );
+        let (snapshot_2, mut next_prev_keys_2, next_block_commits_2) = process_next_sortition(
+            &mut node,
+            &mut fork_2,
+            &mut miners_2,
+            &prev_keys_2,
+            &next_block_hashes_2,
+        );
 
         assert!(snapshot_1.burn_header_hash != snapshot_2.burn_header_hash);
         assert!(snapshot_1.consensus_hash != snapshot_2.consensus_hash);
diff --git a/stackslib/src/chainstate/burn/db/sortdb.rs b/stackslib/src/chainstate/burn/db/sortdb.rs
index 7c009d2b55..5e1f7231e7 100644
--- a/stackslib/src/chainstate/burn/db/sortdb.rs
+++ b/stackslib/src/chainstate/burn/db/sortdb.rs
@@ -7197,9 +7197,9 @@ pub mod tests {
         let commit_snapshot = test_append_snapshot(
             &mut db,
             BurnchainHeaderHash([0x03; 32]),
-            &vec![
-                BlockstackOperationType::LeaderBlockCommit(block_commit.clone()),
-            ],
+            &vec![BlockstackOperationType::LeaderBlockCommit(
+                block_commit.clone(),
+            )],
         );
 
         {

From 221ee486ae13f2f7ccaabe3814fcd1ca557b8602 Mon Sep 17 00:00:00 2001
From: Marzi <marzi@trustmachines.co>
Date: Mon, 26 Feb 2024 14:51:43 -0500
Subject: [PATCH 0941/1166] Re-apply deleting StagingUserBurnSupport definition
 and usage

---
 stackslib/src/chainstate/nakamoto/mod.rs      |  4 +-
 .../src/chainstate/nakamoto/signer_set.rs     |  1 -
 stackslib/src/chainstate/nakamoto/tenure.rs   |  1 -
 .../src/chainstate/nakamoto/test_signers.rs   |  2 +-
 .../src/chainstate/stacks/db/accounts.rs      | 95 +------------------
 stackslib/src/chainstate/stacks/db/blocks.rs  | 51 ----------
 stackslib/src/chainstate/stacks/db/mod.rs     | 16 +---
 stackslib/src/main.rs                         |  4 -
 8 files changed, 7 insertions(+), 167 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index 94fc5855e7..bc9ea29733 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -60,7 +60,6 @@ use super::stacks::boot::{
     BOOT_TEST_POX_4_AGG_KEY_FNAME, SIGNERS_MAX_LIST_SIZE, SIGNERS_NAME, SIGNERS_PK_LEN,
 };
 use super::stacks::db::accounts::MinerReward;
-use super::stacks::db::blocks::StagingUserBurnSupport;
 use super::stacks::db::{
     ChainstateTx, ClarityTx, MinerPaymentSchedule, MinerPaymentTxFees, MinerRewardInfo,
     StacksBlockHeaderTypes, StacksDBTx, StacksEpochReceipt, StacksHeaderInfo,
@@ -2348,8 +2347,7 @@ impl NakamotoChainState {
         if let Some(block_reward) = block_reward {
             StacksChainState::insert_miner_payment_schedule(
                 headers_tx.deref_mut(),
-                block_reward,
-                &[],
+                block_reward
             )?;
         }
         StacksChainState::store_burnchain_txids(
diff --git a/stackslib/src/chainstate/nakamoto/signer_set.rs b/stackslib/src/chainstate/nakamoto/signer_set.rs
index f811ba4247..c0d6b23717 100644
--- a/stackslib/src/chainstate/nakamoto/signer_set.rs
+++ b/stackslib/src/chainstate/nakamoto/signer_set.rs
@@ -65,7 +65,6 @@ use crate::chainstate::stacks::boot::{
     BOOT_TEST_POX_4_AGG_KEY_FNAME, POX_4_NAME, SIGNERS_MAX_LIST_SIZE, SIGNERS_NAME, SIGNERS_PK_LEN,
     SIGNERS_UPDATE_STATE,
 };
-use crate::chainstate::stacks::db::blocks::StagingUserBurnSupport;
 use crate::chainstate::stacks::db::{
     ChainstateTx, ClarityTx, DBConfig as ChainstateConfig, MinerPaymentSchedule,
     MinerPaymentTxFees, MinerRewardInfo, StacksBlockHeaderTypes, StacksChainState, StacksDBTx,
diff --git a/stackslib/src/chainstate/nakamoto/tenure.rs b/stackslib/src/chainstate/nakamoto/tenure.rs
index 914a2cf499..7f0fad030d 100644
--- a/stackslib/src/chainstate/nakamoto/tenure.rs
+++ b/stackslib/src/chainstate/nakamoto/tenure.rs
@@ -103,7 +103,6 @@ use crate::chainstate::nakamoto::{
     NakamotoChainState,
 };
 use crate::chainstate::stacks::db::accounts::MinerReward;
-use crate::chainstate::stacks::db::blocks::StagingUserBurnSupport;
 use crate::chainstate::stacks::db::{
     ChainstateTx, ClarityTx, DBConfig as ChainstateConfig, MinerPaymentSchedule,
     MinerPaymentTxFees, MinerRewardInfo, StacksBlockHeaderTypes, StacksChainState, StacksDBTx,
diff --git a/stackslib/src/chainstate/nakamoto/test_signers.rs b/stackslib/src/chainstate/nakamoto/test_signers.rs
index 02b38136d3..e797a66ba3 100644
--- a/stackslib/src/chainstate/nakamoto/test_signers.rs
+++ b/stackslib/src/chainstate/nakamoto/test_signers.rs
@@ -39,7 +39,7 @@ use crate::burnchains::bitcoin::indexer::BitcoinIndexer;
 use crate::burnchains::*;
 use crate::chainstate::burn::db::sortdb::*;
 use crate::chainstate::burn::operations::{
-    BlockstackOperationType, LeaderBlockCommitOp, LeaderKeyRegisterOp, UserBurnSupportOp,
+    BlockstackOperationType, LeaderBlockCommitOp, LeaderKeyRegisterOp,
 };
 use crate::chainstate::burn::*;
 use crate::chainstate::coordinator::{
diff --git a/stackslib/src/chainstate/stacks/db/accounts.rs b/stackslib/src/chainstate/stacks/db/accounts.rs
index 68cf1cf377..69dd14a1af 100644
--- a/stackslib/src/chainstate/stacks/db/accounts.rs
+++ b/stackslib/src/chainstate/stacks/db/accounts.rs
@@ -396,7 +396,6 @@ impl StacksChainState {
     pub fn insert_miner_payment_schedule(
         tx: &mut DBTx,
         block_reward: &MinerPaymentSchedule,
-        user_burns: &[StagingUserBurnSupport],
     ) -> Result<(), Error> {
         assert!(block_reward.burnchain_commit_burn < i64::MAX as u64);
         assert!(block_reward.burnchain_sortition_burn < i64::MAX as u64);
@@ -459,53 +458,6 @@ impl StacksChainState {
         )
         .map_err(|e| Error::DBError(db_error::SqliteError(e)))?;
 
-        for user_support in user_burns.iter() {
-            assert!(user_support.burn_amount < i64::MAX as u64);
-
-            let args: &[&dyn ToSql] = &[
-                &user_support.address.to_string(),
-                &user_support.address.to_string(),
-                &block_reward.block_hash,
-                &block_reward.consensus_hash,
-                &block_reward.parent_block_hash,
-                &block_reward.parent_consensus_hash,
-                &format!("{}", block_reward.coinbase),
-                &"0".to_string(),
-                &"0".to_string(),
-                &u64_to_sql(user_support.burn_amount)?,
-                &u64_to_sql(block_reward.burnchain_sortition_burn)?,
-                &u64_to_sql(block_reward.stacks_block_height)?,
-                &false,
-                &user_support.vtxindex,
-                &index_block_hash,
-                &"0".to_string(),
-            ];
-
-            tx.execute(
-                "INSERT INTO payments (
-                            address,
-                            recipient,
-                            block_hash,
-                            consensus_hash,
-                            parent_block_hash,
-                            parent_consensus_hash,
-                            coinbase,
-                            tx_fees_anchored,
-                            tx_fees_streamed,
-                            burnchain_commit_burn,
-                            burnchain_sortition_burn,
-                            stacks_block_height,
-                            miner,
-                            vtxindex,
-                            index_block_hash,
-                            stx_burns
-                        )
-                        VALUES (?1,?2,?3,?4,?5,?6,?7,?8,?9,?10,?11,?12,?13,?14,?15,?16)",
-                args,
-            )
-            .map_err(|e| Error::DBError(db_error::SqliteError(e)))?;
-        }
-
         Ok(())
     }
 
@@ -1147,23 +1099,10 @@ mod test {
         sched
     }
 
-    impl StagingUserBurnSupport {
-        pub fn from_miner_payment_schedule(user: &MinerPaymentSchedule) -> StagingUserBurnSupport {
-            StagingUserBurnSupport {
-                consensus_hash: user.consensus_hash.clone(),
-                anchored_block_hash: user.block_hash.clone(),
-                address: user.address.clone(),
-                burn_amount: user.burnchain_commit_burn,
-                vtxindex: user.vtxindex,
-            }
-        }
-    }
-
     fn advance_tip(
         chainstate: &mut StacksChainState,
         parent_header_info: &StacksHeaderInfo,
         block_reward: &mut MinerPaymentSchedule,
-        user_burns: &mut Vec<StagingUserBurnSupport>,
     ) -> StacksHeaderInfo {
         let mut new_tip = parent_header_info.clone();
 
@@ -1191,11 +1130,6 @@ mod test {
         block_reward.block_hash = new_tip.anchored_header.block_hash();
         block_reward.consensus_hash = new_tip.consensus_hash.clone();
 
-        for ref mut user_burn in user_burns.iter_mut() {
-            user_burn.anchored_block_hash = new_tip.anchored_header.block_hash();
-            user_burn.consensus_hash = new_tip.consensus_hash.clone();
-        }
-
         let mut tx = chainstate.index_tx_begin().unwrap();
         let tip = StacksChainState::advance_tip(
             &mut tx,
@@ -1211,7 +1145,6 @@ mod test {
             new_tip.burn_header_timestamp,
             new_tip.microblock_tail.clone(),
             &block_reward,
-            &user_burns,
             None,
             &ExecutionCost::zero(),
             123,
@@ -1251,9 +1184,6 @@ mod test {
             0,
         );
 
-        let user_support = StagingUserBurnSupport::from_miner_payment_schedule(&user_reward);
-        let mut user_supports = vec![user_support];
-
         {
             let mut tx = chainstate.index_tx_begin().unwrap();
             let ancestor_0 = StacksChainState::get_tip_ancestor(
@@ -1269,7 +1199,6 @@ mod test {
             &mut chainstate,
             &StacksHeaderInfo::regtest_genesis(),
             &mut miner_reward,
-            &mut user_supports,
         );
 
         {
@@ -1283,7 +1212,7 @@ mod test {
             assert_eq!(ancestor_1.unwrap().stacks_block_height, 1);
         }
 
-        let tip = advance_tip(&mut chainstate, &parent_tip, &mut tip_reward, &mut vec![]);
+        let tip = advance_tip(&mut chainstate, &parent_tip, &mut tip_reward);
 
         {
             let mut tx = chainstate.index_tx_begin().unwrap();
@@ -1306,23 +1235,15 @@ mod test {
         let miner_1 =
             StacksAddress::from_string(&"SP1A2K3ENNA6QQ7G8DVJXM24T6QMBDVS7D0TRTAR5".to_string())
                 .unwrap();
-        let user_1 =
-            StacksAddress::from_string(&"SP2837ZMC89J40K4YTS64B00M7065C6X46JX6ARG0".to_string())
-                .unwrap();
 
         let mut miner_reward = make_dummy_miner_payment_schedule(&miner_1, 500, 0, 0, 1000, 1000);
-        let user_reward = make_dummy_user_payment_schedule(&user_1, 500, 0, 0, 750, 1000, 1);
 
         let initial_tip = StacksHeaderInfo::regtest_genesis();
 
-        let user_support = StagingUserBurnSupport::from_miner_payment_schedule(&user_reward);
-        let mut user_supports = vec![user_support];
-
         let parent_tip = advance_tip(
             &mut chainstate,
             &StacksHeaderInfo::regtest_genesis(),
             &mut miner_reward,
-            &mut user_supports,
         );
 
         // dummy reward
@@ -1337,7 +1258,7 @@ mod test {
             0,
             0,
         );
-        let tip = advance_tip(&mut chainstate, &parent_tip, &mut tip_reward, &mut vec![]);
+        let tip = advance_tip(&mut chainstate, &parent_tip, &mut tip_reward);
 
         {
             let mut tx = chainstate.index_tx_begin().unwrap();
@@ -1351,15 +1272,8 @@ mod test {
                 StacksChainState::get_scheduled_block_rewards_in_fork_at_height(&mut tx, &tip, 2)
                     .unwrap();
 
-            let mut expected_user_support = user_reward.clone();
-            expected_user_support.consensus_hash = miner_reward.consensus_hash.clone();
-            expected_user_support.parent_consensus_hash =
-                miner_reward.parent_consensus_hash.clone();
-            expected_user_support.block_hash = miner_reward.block_hash.clone();
-            expected_user_support.parent_block_hash = miner_reward.parent_block_hash.clone();
-
             assert_eq!(payments_0, vec![]);
-            assert_eq!(payments_1, vec![miner_reward, expected_user_support]);
+            assert_eq!(payments_1, vec![miner_reward]);
             assert_eq!(payments_2, vec![tip_reward]);
         };
     }
@@ -1380,7 +1294,6 @@ mod test {
             &mut chainstate,
             &StacksHeaderInfo::regtest_genesis(),
             &mut miner_reward,
-            &mut vec![],
         );
 
         // dummy reward
@@ -1395,7 +1308,7 @@ mod test {
             0,
             0,
         );
-        let tip = advance_tip(&mut chainstate, &parent_tip, &mut tip_reward, &mut vec![]);
+        let tip = advance_tip(&mut chainstate, &parent_tip, &mut tip_reward);
 
         {
             let mut tx = chainstate.index_tx_begin().unwrap();
diff --git a/stackslib/src/chainstate/stacks/db/blocks.rs b/stackslib/src/chainstate/stacks/db/blocks.rs
index 394b9681f8..77fc754a65 100644
--- a/stackslib/src/chainstate/stacks/db/blocks.rs
+++ b/stackslib/src/chainstate/stacks/db/blocks.rs
@@ -110,15 +110,6 @@ pub struct StagingBlock {
     pub block_data: Vec<u8>,
 }
 
-#[derive(Debug, Clone, PartialEq)]
-pub struct StagingUserBurnSupport {
-    pub consensus_hash: ConsensusHash,
-    pub anchored_block_hash: BlockHeaderHash,
-    pub address: StacksAddress,
-    pub burn_amount: u64,
-    pub vtxindex: u32,
-}
-
 #[derive(Debug)]
 pub enum MemPoolRejection {
     SerializationFailure(codec_error),
@@ -427,25 +418,6 @@ impl FromRow<StagingBlock> for StagingBlock {
     }
 }
 
-impl FromRow<StagingUserBurnSupport> for StagingUserBurnSupport {
-    fn from_row<'a>(row: &'a Row) -> Result<StagingUserBurnSupport, db_error> {
-        let anchored_block_hash: BlockHeaderHash =
-            BlockHeaderHash::from_column(row, "anchored_block_hash")?;
-        let consensus_hash: ConsensusHash = ConsensusHash::from_column(row, "consensus_hash")?;
-        let address: StacksAddress = StacksAddress::from_column(row, "address")?;
-        let burn_amount = u64::from_column(row, "burn_amount")?;
-        let vtxindex: u32 = row.get_unwrap("vtxindex");
-
-        Ok(StagingUserBurnSupport {
-            anchored_block_hash,
-            consensus_hash,
-            address,
-            burn_amount,
-            vtxindex,
-        })
-    }
-}
-
 impl StagingMicroblock {
     #[cfg(test)]
     pub fn try_into_microblock(self) -> Result<StacksMicroblock, StagingMicroblock> {
@@ -1085,19 +1057,6 @@ impl StacksChainState {
         }
     }
 
-    /// Load up the list of users who burned for an unprocessed block.
-    fn load_staging_block_user_supports(
-        block_conn: &DBConn,
-        consensus_hash: &ConsensusHash,
-        block_hash: &BlockHeaderHash,
-    ) -> Result<Vec<StagingUserBurnSupport>, Error> {
-        let sql = "SELECT * FROM staging_user_burn_support WHERE anchored_block_hash = ?1 AND consensus_hash = ?2".to_string();
-        let args: &[&dyn ToSql] = &[&block_hash, &consensus_hash];
-        let rows = query_rows::<StagingUserBurnSupport, _>(block_conn, &sql, args)
-            .map_err(Error::DBError)?;
-        Ok(rows)
-    }
-
     /// Load up a queued block's queued pubkey hash
     fn load_staging_block_pubkey_hash(
         block_conn: &DBConn,
@@ -5249,7 +5208,6 @@ impl StacksChainState {
         microblocks: &Vec<StacksMicroblock>, // parent microblocks
         burnchain_commit_burn: u64,
         burnchain_sortition_burn: u64,
-        user_burns: &[StagingUserBurnSupport],
         affirmation_weight: u64,
         do_not_advance: bool,
     ) -> Result<(StacksEpochReceipt, PreCommitClarityBlock<'a>), Error> {
@@ -5658,7 +5616,6 @@ impl StacksChainState {
             chain_tip_burn_header_timestamp,
             microblock_tail_opt,
             &scheduled_miner_reward,
-            user_burns,
             miner_payouts_opt,
             &block_execution_cost,
             block_size,
@@ -6008,13 +5965,6 @@ impl StacksChainState {
             last_microblock_seq
         );
 
-        // find users that burned in support of this block, so we can calculate the miner reward
-        let user_supports = StacksChainState::load_staging_block_user_supports(
-            chainstate_tx.deref().deref(),
-            &next_staging_block.consensus_hash,
-            &next_staging_block.anchored_block_hash,
-        )?;
-
         test_debug!(
             "About to load affirmation map for {}/{}",
             &next_staging_block.consensus_hash,
@@ -6052,7 +6002,6 @@ impl StacksChainState {
             &next_microblocks,
             next_staging_block.commit_burn,
             next_staging_block.sortition_burn,
-            &user_supports,
             block_am.weight(),
             false,
         ) {
diff --git a/stackslib/src/chainstate/stacks/db/mod.rs b/stackslib/src/chainstate/stacks/db/mod.rs
index b44dc9e6fe..3e48a3f471 100644
--- a/stackslib/src/chainstate/stacks/db/mod.rs
+++ b/stackslib/src/chainstate/stacks/db/mod.rs
@@ -790,14 +790,6 @@ const CHAINSTATE_INITIAL_SCHEMA: &'static [&'static str] = &[
                                 PRIMARY KEY(anchored_block_hash,consensus_hash)
     );"#,
     r#"
-    -- users who burned in support of a block
-    CREATE TABLE staging_user_burn_support(anchored_block_hash TEXT NOT NULL,
-                                           consensus_hash TEXT NOT NULL,
-                                           address TEXT NOT NULL,
-                                           burn_amount INT NOT NULL,
-                                           vtxindex INT NOT NULL
-    );"#,
-    r#"
     CREATE TABLE transactions(
         id INTEGER PRIMARY KEY,
         txid TEXT NOT NULL,
@@ -890,7 +882,6 @@ const CHAINSTATE_INDEXES: &'static [&'static str] = &[
     "CREATE INDEX IF NOT EXISTS parent_consensus_hashes ON staging_blocks(parent_consensus_hash);",
     "CREATE INDEX IF NOT EXISTS index_block_hashes ON staging_blocks(index_block_hash);",
     "CREATE INDEX IF NOT EXISTS height_stacks_blocks ON staging_blocks(height);",
-    "CREATE INDEX IF NOT EXISTS index_staging_user_burn_support ON staging_user_burn_support(anchored_block_hash,consensus_hash);",
     "CREATE INDEX IF NOT EXISTS txid_tx_index ON transactions(txid);",
     "CREATE INDEX IF NOT EXISTS index_block_hash_tx_index ON transactions(index_block_hash);",
     "CREATE INDEX IF NOT EXISTS index_block_header_by_affirmation_weight ON block_headers(affirmation_weight);",
@@ -2534,7 +2525,6 @@ impl StacksChainState {
         new_burnchain_timestamp: u64,
         microblock_tail_opt: Option<StacksMicroblockHeader>,
         block_reward: &MinerPaymentSchedule,
-        user_burns: &[StagingUserBurnSupport],
         mature_miner_payouts: Option<(MinerReward, Vec<MinerReward>, MinerReward, MinerRewardInfo)>, // (miner, [users], parent, matured rewards)
         anchor_block_cost: &ExecutionCost,
         anchor_block_size: u64,
@@ -2599,11 +2589,7 @@ impl StacksChainState {
             anchor_block_cost,
             affirmation_weight,
         )?;
-        StacksChainState::insert_miner_payment_schedule(
-            headers_tx.deref_mut(),
-            block_reward,
-            user_burns,
-        )?;
+        StacksChainState::insert_miner_payment_schedule(headers_tx.deref_mut(), block_reward)?;
         StacksChainState::store_burnchain_txids(
             headers_tx.deref(),
             &index_block_hash,
diff --git a/stackslib/src/main.rs b/stackslib/src/main.rs
index e964637b60..652d9bf2dc 100644
--- a/stackslib/src/main.rs
+++ b/stackslib/src/main.rs
@@ -1690,9 +1690,6 @@ fn replay_block(stacks_path: &str, index_block_hash_hex: &str) {
         last_microblock_seq
     );
 
-    // user supports were never activated
-    let user_supports = vec![];
-
     let block_am = StacksChainState::find_stacks_tip_affirmation_map(
         &burnchain_blocks_db,
         sort_tx.tx(),
@@ -1718,7 +1715,6 @@ fn replay_block(stacks_path: &str, index_block_hash_hex: &str) {
         &next_microblocks,
         next_staging_block.commit_burn,
         next_staging_block.sortition_burn,
-        &user_supports,
         block_am.weight(),
         true,
     ) {

From 708a3fc8777ebb0694903e95dfa8d1581575e16a Mon Sep 17 00:00:00 2001
From: Marzi <marzi@trustmachines.co>
Date: Mon, 26 Feb 2024 14:54:36 -0500
Subject: [PATCH 0942/1166] Cargo Format

---
 stackslib/src/chainstate/nakamoto/mod.rs | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index bc9ea29733..d9a100d432 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -2345,10 +2345,7 @@ impl NakamotoChainState {
             tenure_fees,
         )?;
         if let Some(block_reward) = block_reward {
-            StacksChainState::insert_miner_payment_schedule(
-                headers_tx.deref_mut(),
-                block_reward
-            )?;
+            StacksChainState::insert_miner_payment_schedule(headers_tx.deref_mut(), block_reward)?;
         }
         StacksChainState::store_burnchain_txids(
             headers_tx.deref(),

From 3c0e7798b25b0f7edd2d72ab51190e1d3e6b80de Mon Sep 17 00:00:00 2001
From: wileyj <2847772+wileyj@users.noreply.github.com>
Date: Tue, 27 Feb 2024 11:29:41 -0800
Subject: [PATCH 0943/1166] Update ci trigger for merge queue

---
 .github/workflows/ci.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index bb010862f9..552196e4ce 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -148,6 +148,7 @@ jobs:
           ) ||
           github.event_name == 'workflow_dispatch' ||
           github.event_name == 'pull_request' ||
+          github.event_name == 'merge_group' ||
           (
             contains('
               refs/heads/master

From 21e22321567a198e8b519b0e8058b93cf7583279 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Tue, 20 Feb 2024 14:32:25 -0500
Subject: [PATCH 0944/1166] chore(clarity): Use `vec::with_capacity()` when
 possible to allocate vectors

---
 .../contract_interface_builder/mod.rs         | 11 +++++------
 .../src/vm/analysis/type_checker/v2_05/mod.rs |  2 +-
 .../type_checker/v2_05/natives/mod.rs         |  9 +++------
 .../type_checker/v2_05/natives/sequences.rs   |  2 +-
 .../src/vm/analysis/type_checker/v2_1/mod.rs  |  4 ++--
 .../analysis/type_checker/v2_1/natives/mod.rs |  2 +-
 .../type_checker/v2_1/natives/sequences.rs    |  2 +-
 clarity/src/vm/ast/definition_sorter/mod.rs   | 16 ++++++++--------
 clarity/src/vm/ast/parser/v2/mod.rs           | 14 ++++++++------
 clarity/src/vm/ast/sugar_expander/mod.rs      |  2 +-
 clarity/src/vm/ast/types.rs                   |  4 ++++
 clarity/src/vm/coverage.rs                    |  9 +++++----
 clarity/src/vm/database/structures.rs         |  3 ++-
 clarity/src/vm/docs/mod.rs                    | 14 ++++++--------
 clarity/src/vm/functions/database.rs          |  8 +++++---
 clarity/src/vm/functions/mod.rs               |  2 +-
 clarity/src/vm/mod.rs                         |  2 +-
 clarity/src/vm/types/mod.rs                   | 14 ++++++++------
 clarity/src/vm/types/serialization.rs         |  7 ++++---
 clarity/src/vm/types/signatures.rs            | 19 +++++++++++--------
 20 files changed, 78 insertions(+), 68 deletions(-)

diff --git a/clarity/src/vm/analysis/contract_interface_builder/mod.rs b/clarity/src/vm/analysis/contract_interface_builder/mod.rs
index c9bc3c71c1..63cf119933 100644
--- a/clarity/src/vm/analysis/contract_interface_builder/mod.rs
+++ b/clarity/src/vm/analysis/contract_interface_builder/mod.rs
@@ -237,14 +237,13 @@ pub struct ContractInterfaceFunctionArg {
 
 impl ContractInterfaceFunctionArg {
     pub fn from_function_args(fnArgs: &[FunctionArg]) -> Vec<ContractInterfaceFunctionArg> {
-        let mut args: Vec<ContractInterfaceFunctionArg> = Vec::new();
-        for fnArg in fnArgs.iter() {
-            args.push(ContractInterfaceFunctionArg {
+        fnArgs
+            .iter()
+            .map(|fnArg| ContractInterfaceFunctionArg {
                 name: fnArg.name.to_string(),
                 type_f: ContractInterfaceAtomType::from_type_signature(&fnArg.signature),
-            });
-        }
-        args
+            })
+            .collect()
     }
 }
 
diff --git a/clarity/src/vm/analysis/type_checker/v2_05/mod.rs b/clarity/src/vm/analysis/type_checker/v2_05/mod.rs
index cc6d7e9064..7c6b587556 100644
--- a/clarity/src/vm/analysis/type_checker/v2_05/mod.rs
+++ b/clarity/src/vm/analysis/type_checker/v2_05/mod.rs
@@ -526,7 +526,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> {
         args: &[SymbolicExpression],
         context: &TypingContext,
     ) -> CheckResult<Vec<TypeSignature>> {
-        let mut result = Vec::new();
+        let mut result = Vec::with_capacity(args.len());
         for arg in args.iter() {
             // don't use map here, since type_check has side-effects.
             result.push(self.type_check(arg, context)?)
diff --git a/clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs b/clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs
index 18663329f9..46830a8762 100644
--- a/clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs
+++ b/clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs
@@ -187,14 +187,11 @@ pub fn check_special_tuple_cons(
     context: &TypingContext,
 ) -> TypeResult {
     check_arguments_at_least(1, args)?;
+    let len = args.len();
 
-    let mut tuple_type_data = Vec::new();
+    runtime_cost(ClarityCostFunction::AnalysisCheckTupleCons, checker, len)?;
 
-    runtime_cost(
-        ClarityCostFunction::AnalysisCheckTupleCons,
-        checker,
-        args.len(),
-    )?;
+    let mut tuple_type_data = Vec::with_capacity(len);
 
     handle_binding_list(args, |var_name, var_sexp| {
         checker.type_check(var_sexp, context).and_then(|var_type| {
diff --git a/clarity/src/vm/analysis/type_checker/v2_05/natives/sequences.rs b/clarity/src/vm/analysis/type_checker/v2_05/natives/sequences.rs
index 49a29e8d38..df85af20b9 100644
--- a/clarity/src/vm/analysis/type_checker/v2_05/natives/sequences.rs
+++ b/clarity/src/vm/analysis/type_checker/v2_05/natives/sequences.rs
@@ -74,7 +74,7 @@ pub fn check_special_map(
         args.len(),
     )?;
 
-    let mut func_args = vec![];
+    let mut func_args = Vec::with_capacity(args.len());
     let mut min_args = u32::MAX;
     for arg in args[1..].iter() {
         let argument_type = checker.type_check(arg, context)?;
diff --git a/clarity/src/vm/analysis/type_checker/v2_1/mod.rs b/clarity/src/vm/analysis/type_checker/v2_1/mod.rs
index 38cf3c7679..44aab0b4f2 100644
--- a/clarity/src/vm/analysis/type_checker/v2_1/mod.rs
+++ b/clarity/src/vm/analysis/type_checker/v2_1/mod.rs
@@ -459,7 +459,7 @@ impl FunctionType {
                 }
             }
         } else {
-            let mut arg_types = Vec::new();
+            let mut arg_types = Vec::with_capacity(func_args.len());
             for arg in func_args {
                 arg_types.push(self.principal_to_callable_type(arg, 1, clarity_version)?);
             }
@@ -1028,7 +1028,7 @@ impl<'a, 'b> TypeChecker<'a, 'b> {
         args: &[SymbolicExpression],
         context: &TypingContext,
     ) -> CheckResult<Vec<TypeSignature>> {
-        let mut result = Vec::new();
+        let mut result = Vec::with_capacity(args.len());
         for arg in args.iter() {
             // don't use map here, since type_check has side-effects.
             result.push(self.type_check(arg, context)?)
diff --git a/clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs b/clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs
index fd1f456045..1c30eb7795 100644
--- a/clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs
+++ b/clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs
@@ -195,7 +195,7 @@ pub fn check_special_tuple_cons(
 ) -> TypeResult {
     check_arguments_at_least(1, args)?;
 
-    let mut tuple_type_data = Vec::new();
+    let mut tuple_type_data = Vec::with_capacity(args.len());
 
     runtime_cost(
         ClarityCostFunction::AnalysisCheckTupleCons,
diff --git a/clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs b/clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs
index 9eb2ae17c9..be38425c20 100644
--- a/clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs
+++ b/clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs
@@ -74,7 +74,7 @@ pub fn check_special_map(
         args.len(),
     )?;
 
-    let mut func_args = vec![];
+    let mut func_args = Vec::with_capacity(args.len());
     let mut min_args = u32::MAX;
     for arg in args[1..].iter() {
         let argument_type = checker.type_check(arg, context)?;
diff --git a/clarity/src/vm/ast/definition_sorter/mod.rs b/clarity/src/vm/ast/definition_sorter/mod.rs
index 36dfb21664..a48bfd0e34 100644
--- a/clarity/src/vm/ast/definition_sorter/mod.rs
+++ b/clarity/src/vm/ast/definition_sorter/mod.rs
@@ -91,14 +91,14 @@ impl DefinitionSorter {
         let sorted_indexes = walker.get_sorted_dependencies(&self.graph)?;
 
         if let Some(deps) = walker.get_cycling_dependencies(&self.graph, &sorted_indexes) {
-            let mut deps_props = vec![];
-            for i in deps.iter() {
-                let exp = &contract_ast.pre_expressions[*i];
-                if let Some(def) = self.find_expression_definition(exp) {
-                    deps_props.push(def);
-                }
-            }
-            let functions_names = deps_props.iter().map(|i| i.0.to_string()).collect();
+            let functions_names = deps
+                .into_iter()
+                .filter_map(|i| {
+                    let exp = &contract_ast.pre_expressions[i];
+                    self.find_expression_definition(exp)
+                })
+                .map(|i| i.0.to_string())
+                .collect::<Vec<_>>();
 
             let error = ParseError::new(ParseErrors::CircularReference(functions_names));
             return Err(error);
diff --git a/clarity/src/vm/ast/parser/v2/mod.rs b/clarity/src/vm/ast/parser/v2/mod.rs
index 75a622a7c0..6238af1383 100644
--- a/clarity/src/vm/ast/parser/v2/mod.rs
+++ b/clarity/src/vm/ast/parser/v2/mod.rs
@@ -894,12 +894,14 @@ impl<'a> Parser<'a> {
                             Some(expr)
                         }
                         Token::Utf8String(s) => {
-                            let mut data: Vec<Vec<u8>> = Vec::new();
-                            for ch in s.chars() {
-                                let mut bytes = vec![0; ch.len_utf8()];
-                                ch.encode_utf8(&mut bytes);
-                                data.push(bytes);
-                            }
+                            let data: Vec<Vec<u8>> = s
+                                .chars()
+                                .map(|ch| {
+                                    let mut bytes = vec![0; ch.len_utf8()];
+                                    ch.encode_utf8(&mut bytes);
+                                    bytes
+                                })
+                                .collect();
                             let val =
                                 Value::Sequence(SequenceData::String(CharType::UTF8(UTF8Data {
                                     data,
diff --git a/clarity/src/vm/ast/sugar_expander/mod.rs b/clarity/src/vm/ast/sugar_expander/mod.rs
index 481e1039dd..cf070548a8 100644
--- a/clarity/src/vm/ast/sugar_expander/mod.rs
+++ b/clarity/src/vm/ast/sugar_expander/mod.rs
@@ -65,7 +65,7 @@ impl SugarExpander {
         pre_exprs_iter: PreExpressionsDrain,
         contract_ast: &mut ContractAST,
     ) -> ParseResult<Vec<SymbolicExpression>> {
-        let mut expressions: Vec<SymbolicExpression> = Vec::new();
+        let mut expressions: Vec<SymbolicExpression> = Vec::with_capacity(pre_exprs_iter.len());
         #[cfg(feature = "developer-mode")]
         let mut comments = Vec::new();
 
diff --git a/clarity/src/vm/ast/types.rs b/clarity/src/vm/ast/types.rs
index e8183220af..87ab844b85 100644
--- a/clarity/src/vm/ast/types.rs
+++ b/clarity/src/vm/ast/types.rs
@@ -95,6 +95,10 @@ impl PreExpressionsDrain {
             index: 0,
         }
     }
+
+    pub fn len(&self) -> usize {
+        self.len
+    }
 }
 
 impl Iterator for PreExpressionsDrain {
diff --git a/clarity/src/vm/coverage.rs b/clarity/src/vm/coverage.rs
index 6f2de9f5c6..ea62981696 100644
--- a/clarity/src/vm/coverage.rs
+++ b/clarity/src/vm/coverage.rs
@@ -74,10 +74,11 @@ impl CoverageReporter {
         let f = File::create(filename)?;
         let mut coverage = HashMap::new();
         for (contract, execution_map) in self.executed_lines.iter() {
-            let mut executed_lines = vec![];
-            for (line, count) in execution_map.iter() {
-                executed_lines.push((*line, *count));
-            }
+            let mut executed_lines = execution_map
+                .iter()
+                .map(|(line, count)| (*line, *count))
+                .collect::<Vec<_>>();
+
             executed_lines.sort_by_key(|f| f.0);
 
             coverage.insert(contract.to_string(), executed_lines);
diff --git a/clarity/src/vm/database/structures.rs b/clarity/src/vm/database/structures.rs
index 53c7fbd681..effa4ac359 100644
--- a/clarity/src/vm/database/structures.rs
+++ b/clarity/src/vm/database/structures.rs
@@ -169,7 +169,8 @@ type Result<T> = std::result::Result<T, Error>;
 impl ClaritySerializable for STXBalance {
     #[allow(clippy::expect_used)]
     fn serialize(&self) -> String {
-        let mut buffer = Vec::new();
+        let size = std::mem::size_of::<Self>();
+        let mut buffer = Vec::with_capacity(size);
         match self {
             STXBalance::Unlocked { amount } => {
                 buffer
diff --git a/clarity/src/vm/docs/mod.rs b/clarity/src/vm/docs/mod.rs
index 50ca695e46..205fdc6170 100644
--- a/clarity/src/vm/docs/mod.rs
+++ b/clarity/src/vm/docs/mod.rs
@@ -2609,20 +2609,18 @@ pub fn make_define_reference(define_type: &DefineFunctions) -> FunctionAPI {
 fn make_all_api_reference() -> ReferenceAPIs {
     let mut functions: Vec<_> = NativeFunctions::ALL
         .iter()
-        .map(|x| make_api_reference(x))
+        .map(make_api_reference)
         .collect();
     for data_type in DefineFunctions::ALL.iter() {
         functions.push(make_define_reference(data_type))
     }
     functions.sort_by(|x, y| x.name.cmp(&y.name));
 
-    let mut keywords = Vec::new();
-    for variable in NativeVariables::ALL.iter() {
-        let output = make_keyword_reference(variable);
-        if let Some(api_ref) = output {
-            keywords.push(api_ref)
-        }
-    }
+    let mut keywords: Vec<_> = NativeVariables::ALL
+        .iter()
+        .filter_map(make_keyword_reference)
+        .collect();
+
     keywords.sort_by(|x, y| x.name.cmp(&y.name));
 
     ReferenceAPIs {
diff --git a/clarity/src/vm/functions/database.rs b/clarity/src/vm/functions/database.rs
index d036dd27c2..e52ac57b54 100644
--- a/clarity/src/vm/functions/database.rs
+++ b/clarity/src/vm/functions/database.rs
@@ -75,9 +75,11 @@ pub fn special_contract_call(
     runtime_cost(ClarityCostFunction::ContractCall, env, 0)?;
 
     let function_name = args[1].match_atom().ok_or(CheckErrors::ExpectedName)?;
-    let mut rest_args = vec![];
-    let mut rest_args_sizes = vec![];
-    for arg in args[2..].iter() {
+    let rest_args_slice = &args[2..];
+    let rest_args_len = rest_args_slice.len();
+    let mut rest_args = Vec::with_capacity(rest_args_len);
+    let mut rest_args_sizes = Vec::with_capacity(rest_args_len);
+    for arg in rest_args_slice.iter() {
         let evaluated_arg = eval(arg, env, context)?;
         rest_args_sizes.push(evaluated_arg.size()? as u64);
         rest_args.push(SymbolicExpression::atom_value(evaluated_arg));
diff --git a/clarity/src/vm/functions/mod.rs b/clarity/src/vm/functions/mod.rs
index a523db8643..7c3647c2f6 100644
--- a/clarity/src/vm/functions/mod.rs
+++ b/clarity/src/vm/functions/mod.rs
@@ -701,7 +701,7 @@ pub fn parse_eval_bindings(
     env: &mut Environment,
     context: &LocalContext,
 ) -> Result<Vec<(ClarityName, Value)>> {
-    let mut result = Vec::new();
+    let mut result = Vec::with_capacity(bindings.len());
     handle_binding_list(bindings, |var_name, var_sexp| {
         eval(var_sexp, env, context).map(|value| result.push((var_name.clone(), value)))
     })?;
diff --git a/clarity/src/vm/mod.rs b/clarity/src/vm/mod.rs
index 7231ad584d..45d71cf222 100644
--- a/clarity/src/vm/mod.rs
+++ b/clarity/src/vm/mod.rs
@@ -257,7 +257,7 @@ pub fn apply(
         resp
     } else {
         let mut used_memory = 0;
-        let mut evaluated_args = vec![];
+        let mut evaluated_args = Vec::with_capacity(args.len());
         env.call_stack.incr_apply_depth();
         for arg_x in args.iter() {
             let arg_value = match eval(arg_x, env, context) {
diff --git a/clarity/src/vm/types/mod.rs b/clarity/src/vm/types/mod.rs
index 06eea08966..64c10fd40b 100644
--- a/clarity/src/vm/types/mod.rs
+++ b/clarity/src/vm/types/mod.rs
@@ -1034,12 +1034,14 @@ impl Value {
             Ok(string) => string,
             _ => return Err(CheckErrors::InvalidCharactersDetected.into()),
         };
-        let mut data = vec![];
-        for char in validated_utf8_str.chars() {
-            let mut encoded_char: Vec<u8> = vec![0; char.len_utf8()];
-            char.encode_utf8(&mut encoded_char[..]);
-            data.push(encoded_char);
-        }
+        let data = validated_utf8_str
+            .chars()
+            .map(|char| {
+                let mut encoded_char = vec![0u8; char.len_utf8()];
+                char.encode_utf8(&mut encoded_char[..]);
+                encoded_char
+            })
+            .collect::<Vec<_>>();
         // check the string size
         StringUTF8Length::try_from(data.len())?;
 
diff --git a/clarity/src/vm/types/serialization.rs b/clarity/src/vm/types/serialization.rs
index 32cf9cf9f1..69a662e6b7 100644
--- a/clarity/src/vm/types/serialization.rs
+++ b/clarity/src/vm/types/serialization.rs
@@ -1249,7 +1249,7 @@ impl Value {
                 if l.len().ok()? > lt.get_max_len() {
                     return None;
                 }
-                let mut sanitized_items = vec![];
+                let mut sanitized_items = Vec::with_capacity(l.data.len());
                 let mut did_sanitize_children = false;
                 for item in l.data.into_iter() {
                     let (sanitized_item, did_sanitize) =
@@ -1266,11 +1266,12 @@ impl Value {
                     TypeSignature::TupleType(tt) => tt,
                     _ => return None,
                 };
-                let mut sanitized_tuple_entries = vec![];
+                let type_map = tt.get_type_map();
+                let mut sanitized_tuple_entries = Vec::with_capacity(type_map.len());
                 let original_tuple_len = tuple_data.len();
                 let mut tuple_data_map = tuple_data.data_map;
                 let mut did_sanitize_children = false;
-                for (key, expect_key_type) in tt.get_type_map().iter() {
+                for (key, expect_key_type) in type_map.iter() {
                     let field_data = tuple_data_map.remove(key)?;
                     let (sanitized_field, did_sanitize) =
                         Self::sanitize_value(epoch, expect_key_type, field_data)?;
diff --git a/clarity/src/vm/types/signatures.rs b/clarity/src/vm/types/signatures.rs
index f906ada188..c6838eb3fb 100644
--- a/clarity/src/vm/types/signatures.rs
+++ b/clarity/src/vm/types/signatures.rs
@@ -981,10 +981,12 @@ impl FunctionSignature {
     }
 
     pub fn canonicalize(&self, epoch: &StacksEpochId) -> FunctionSignature {
-        let mut canonicalized_args = vec![];
-        for arg in &self.args {
-            canonicalized_args.push(arg.canonicalize(epoch));
-        }
+        let canonicalized_args = self
+            .args
+            .iter()
+            .map(|arg| arg.canonicalize(epoch))
+            .collect();
+
         FunctionSignature {
             args: canonicalized_args,
             returns: self.returns.canonicalize(epoch),
@@ -1644,8 +1646,8 @@ impl TypeSignature {
             let fn_args_exprs = args[1]
                 .match_list()
                 .ok_or(CheckErrors::DefineTraitBadSignature)?;
-            let mut fn_args = vec![];
-            for arg_type in fn_args_exprs.iter() {
+            let mut fn_args = Vec::with_capacity(fn_args_exprs.len());
+            for arg_type in fn_args_exprs.into_iter() {
                 let arg_t = TypeSignature::parse_type_repr(epoch, arg_type, accounting)?;
                 fn_args.push(arg_t);
             }
@@ -2064,8 +2066,9 @@ mod test {
         //   set k = 4033
         let first_tuple = TypeSignature::from_string("(tuple (a0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 bool))", version, epoch);
 
-        let mut keys = vec![];
-        for i in 0..4033 {
+        let len = 4033;
+        let mut keys = Vec::with_capacity(len);
+        for i in 0..len {
             let key_name = ClarityName::try_from(format!("a{:0127}", i)).unwrap();
             let key_val = first_tuple.clone();
             keys.push((key_name, key_val));

From 9ff45c3b0fc70afac54f73a2e237ced815fbd819 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Tue, 27 Feb 2024 15:56:46 -0500
Subject: [PATCH 0945/1166] chore: Address Brice's PR comments

---
 .../src/vm/analysis/type_checker/v2_05/natives/sequences.rs  | 5 +++--
 .../src/vm/analysis/type_checker/v2_1/natives/sequences.rs   | 5 +++--
 clarity/src/vm/database/structures.rs                        | 3 +--
 clarity/src/vm/types/mod.rs                                  | 2 +-
 4 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/clarity/src/vm/analysis/type_checker/v2_05/natives/sequences.rs b/clarity/src/vm/analysis/type_checker/v2_05/natives/sequences.rs
index df85af20b9..81d52bb23d 100644
--- a/clarity/src/vm/analysis/type_checker/v2_05/natives/sequences.rs
+++ b/clarity/src/vm/analysis/type_checker/v2_05/natives/sequences.rs
@@ -74,9 +74,10 @@ pub fn check_special_map(
         args.len(),
     )?;
 
-    let mut func_args = Vec::with_capacity(args.len());
+    let iter = args[1..].iter();
+    let mut func_args = Vec::with_capacity(iter.len());
     let mut min_args = u32::MAX;
-    for arg in args[1..].iter() {
+    for arg in iter {
         let argument_type = checker.type_check(arg, context)?;
         let entry_type = match argument_type {
             TypeSignature::SequenceType(sequence) => {
diff --git a/clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs b/clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs
index be38425c20..52ceca66b6 100644
--- a/clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs
+++ b/clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs
@@ -74,9 +74,10 @@ pub fn check_special_map(
         args.len(),
     )?;
 
-    let mut func_args = Vec::with_capacity(args.len());
+    let iter = args[1..].iter();
+    let mut func_args = Vec::with_capacity(iter.len());
     let mut min_args = u32::MAX;
-    for arg in args[1..].iter() {
+    for arg in iter {
         let argument_type = checker.type_check(arg, context)?;
         let entry_type = match argument_type {
             TypeSignature::SequenceType(sequence) => {
diff --git a/clarity/src/vm/database/structures.rs b/clarity/src/vm/database/structures.rs
index effa4ac359..53c7fbd681 100644
--- a/clarity/src/vm/database/structures.rs
+++ b/clarity/src/vm/database/structures.rs
@@ -169,8 +169,7 @@ type Result<T> = std::result::Result<T, Error>;
 impl ClaritySerializable for STXBalance {
     #[allow(clippy::expect_used)]
     fn serialize(&self) -> String {
-        let size = std::mem::size_of::<Self>();
-        let mut buffer = Vec::with_capacity(size);
+        let mut buffer = Vec::new();
         match self {
             STXBalance::Unlocked { amount } => {
                 buffer
diff --git a/clarity/src/vm/types/mod.rs b/clarity/src/vm/types/mod.rs
index 64c10fd40b..cc3cbeeba0 100644
--- a/clarity/src/vm/types/mod.rs
+++ b/clarity/src/vm/types/mod.rs
@@ -1038,7 +1038,7 @@ impl Value {
             .chars()
             .map(|char| {
                 let mut encoded_char = vec![0u8; char.len_utf8()];
-                char.encode_utf8(&mut encoded_char[..]);
+                char.encode_utf8(&mut encoded_char);
                 encoded_char
             })
             .collect::<Vec<_>>();

From 04ddd831922acd0c67054199838ad4a9c72ba3c0 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Thu, 22 Feb 2024 18:37:54 -0500
Subject: [PATCH 0946/1166] chore(stacks-common): Use `vec::with_capacity()`
 when possible to allocate vectors

---
 stacks-common/src/address/c32.rs                 | 14 +++++++++-----
 stacks-common/src/deps_common/bech32/mod.rs      |  3 ++-
 .../src/deps_common/bitcoin/blockdata/script.rs  |  5 +++--
 .../deps_common/bitcoin/blockdata/transaction.rs | 16 ++++++++++------
 .../src/deps_common/bitcoin/util/hash.rs         |  5 +++--
 stacks-common/src/types/chainstate.rs            | 14 ++++++--------
 stacks-common/src/util/hash.rs                   |  8 +++++---
 7 files changed, 38 insertions(+), 27 deletions(-)

diff --git a/stacks-common/src/address/c32.rs b/stacks-common/src/address/c32.rs
index 20eb64e116..cf72ff8e99 100644
--- a/stacks-common/src/address/c32.rs
+++ b/stacks-common/src/address/c32.rs
@@ -180,7 +180,9 @@ const C32_CHARACTERS_MAP: [Option<u8>; 128] = [
 ];
 
 fn c32_encode(input_bytes: &[u8]) -> String {
-    let mut result = vec![];
+    // c32-encoded size is 160%  that of ASCII
+    let size = input_bytes.len().saturating_mul(8).div_ceil(5);
+    let mut result = Vec::with_capacity(size);
     let mut carry = 0;
     let mut carry_bits = 0;
 
@@ -234,10 +236,6 @@ fn c32_decode(input_str: &str) -> Result<Vec<u8>, Error> {
 }
 
 fn c32_decode_ascii(input_str: &str) -> Result<Vec<u8>, Error> {
-    let mut result = vec![];
-    let mut carry: u16 = 0;
-    let mut carry_bits = 0; // can be up to 5
-
     let mut iter_c32_digits = Vec::<u8>::with_capacity(input_str.len());
 
     for x in input_str.as_bytes().iter().rev() {
@@ -251,6 +249,12 @@ fn c32_decode_ascii(input_str: &str) -> Result<Vec<u8>, Error> {
         return Err(Error::InvalidCrockford32);
     }
 
+    // ASCII size is 62.5%  that of c32-encoded
+    let size = iter_c32_digits.len().saturating_mul(5).div_ceil(8);
+    let mut result = Vec::with_capacity(size);
+    let mut carry: u16 = 0;
+    let mut carry_bits = 0; // can be up to 5
+
     for current_5bit in &iter_c32_digits {
         carry += (*current_5bit as u16) << carry_bits;
         carry_bits += 5;
diff --git a/stacks-common/src/deps_common/bech32/mod.rs b/stacks-common/src/deps_common/bech32/mod.rs
index 5151267962..99f95e9cd6 100644
--- a/stacks-common/src/deps_common/bech32/mod.rs
+++ b/stacks-common/src/deps_common/bech32/mod.rs
@@ -599,7 +599,8 @@ fn verify_checksum(hrp: &[u8], data: &[u5]) -> Option<Variant> {
 }
 
 fn hrp_expand(hrp: &[u8]) -> Vec<u5> {
-    let mut v: Vec<u5> = Vec::new();
+    let size = (hrp.len() * 2) + 1;
+    let mut v: Vec<u5> = Vec::with_capacity(size);
     for b in hrp {
         v.push(u5::try_from_u8(*b >> 5).expect("can't be out of range, max. 7"));
     }
diff --git a/stacks-common/src/deps_common/bitcoin/blockdata/script.rs b/stacks-common/src/deps_common/bitcoin/blockdata/script.rs
index 748f9e2eec..2a7cc4f4dd 100644
--- a/stacks-common/src/deps_common/bitcoin/blockdata/script.rs
+++ b/stacks-common/src/deps_common/bitcoin/blockdata/script.rs
@@ -25,6 +25,7 @@
 //!
 
 use std::default::Default;
+use std::mem::size_of;
 use std::{error, fmt};
 
 use serde;
@@ -201,8 +202,8 @@ fn build_scriptint(n: i64) -> Vec<u8> {
 
     let neg = n < 0;
 
-    let mut abs = if neg { -n } else { n } as usize;
-    let mut v = vec![];
+    let mut abs = n.abs() as usize;
+    let mut v = Vec::with_capacity(size_of::<usize>() / 8);
     while abs > 0xFF {
         v.push((abs & 0xFF) as u8);
         abs >>= 8;
diff --git a/stacks-common/src/deps_common/bitcoin/blockdata/transaction.rs b/stacks-common/src/deps_common/bitcoin/blockdata/transaction.rs
index 87708334fc..1618ad9dd6 100644
--- a/stacks-common/src/deps_common/bitcoin/blockdata/transaction.rs
+++ b/stacks-common/src/deps_common/bitcoin/blockdata/transaction.rs
@@ -291,12 +291,16 @@ impl Transaction {
         } else {
             // sha256d of the concatenation of the previous outpoints, which are each the concatenation
             // of the previous txid and output index
-            let mut raw_vec = vec![];
-            for inp in self.input.iter() {
-                let mut prev_output_bytes = serialize(&inp.previous_output)
-                    .expect("FATAL: failed to encode previous output");
-                raw_vec.append(&mut prev_output_bytes);
-            }
+            let raw_vec = self
+                .input
+                .iter()
+                .flat_map(|inp| {
+                    serialize(&inp.previous_output)
+                        .expect("FATAL: failed to encode previous output")
+                        .into_iter()
+                })
+                .collect::<Vec<_>>();
+
             Sha256dHash::from_data(&raw_vec)
         }
     }
diff --git a/stacks-common/src/deps_common/bitcoin/util/hash.rs b/stacks-common/src/deps_common/bitcoin/util/hash.rs
index 2c64dca01e..364b5f609b 100644
--- a/stacks-common/src/deps_common/bitcoin/util/hash.rs
+++ b/stacks-common/src/deps_common/bitcoin/util/hash.rs
@@ -419,8 +419,9 @@ pub fn bitcoin_merkle_root(data: Vec<Sha256dHash>) -> Sha256dHash {
         return data[0];
     }
     // Recursion
-    let mut next = vec![];
-    for idx in 0..((data.len() + 1) / 2) {
+    let iterations = (data.len() + 1) / 2;
+    let mut next = Vec::with_capacity(iterations);
+    for idx in 0..iterations {
         let idx1 = 2 * idx;
         let idx2 = min(idx1 + 1, data.len() - 1);
         let mut encoder = RawEncoder::new(Cursor::new(vec![]));
diff --git a/stacks-common/src/types/chainstate.rs b/stacks-common/src/types/chainstate.rs
index ac6849dfc6..bd3452aedb 100644
--- a/stacks-common/src/types/chainstate.rs
+++ b/stacks-common/src/types/chainstate.rs
@@ -190,14 +190,12 @@ impl PoxId {
 impl FromStr for PoxId {
     type Err = &'static str;
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let mut result = vec![];
-        for i in s.chars() {
-            if i == '1' {
-                result.push(true);
-            } else if i == '0' {
-                result.push(false);
-            } else {
-                return Err("Unexpected character in PoX ID serialization");
+        let mut result = Vec::with_capacity(s.len());
+        for c in s.chars() {
+            match c {
+                '0' => result.push(false),
+                '1' => result.push(true),
+                _ => return Err("Unexpected character in PoX ID serialization"),
             }
         }
         Ok(PoxId::new(result))
diff --git a/stacks-common/src/util/hash.rs b/stacks-common/src/util/hash.rs
index c1d538f35b..6c15f75b91 100644
--- a/stacks-common/src/util/hash.rs
+++ b/stacks-common/src/util/hash.rs
@@ -451,9 +451,11 @@ where
 
     /// Get a non-leaf hash
     pub fn get_node_hash(left: &H, right: &H) -> H {
-        let mut buf = vec![];
-        buf.extend_from_slice(left.bits());
-        buf.extend_from_slice(right.bits());
+        let left_bits = left.bits();
+        let right_bits = right.bits();
+        let mut buf = Vec::with_capacity(left_bits.len() + right_bits.len());
+        buf.extend_from_slice(left_bits);
+        buf.extend_from_slice(right_bits);
         H::from_tagged_data(MERKLE_PATH_NODE_TAG, &buf[..])
     }
 

From 05c63dc3b2df8cfeca51dac033f8d2190b9f972a Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Fri, 23 Feb 2024 16:12:05 -0500
Subject: [PATCH 0947/1166] chore(stacks-common): Clean up `Vec` operations in
 transaction.rs

---
 .../bitcoin/blockdata/transaction.rs          | 61 ++++++++++---------
 1 file changed, 33 insertions(+), 28 deletions(-)

diff --git a/stacks-common/src/deps_common/bitcoin/blockdata/transaction.rs b/stacks-common/src/deps_common/bitcoin/blockdata/transaction.rs
index 1618ad9dd6..eaef8050fe 100644
--- a/stacks-common/src/deps_common/bitcoin/blockdata/transaction.rs
+++ b/stacks-common/src/deps_common/bitcoin/blockdata/transaction.rs
@@ -315,10 +315,11 @@ impl Transaction {
             Sha256dHash([0u8; 32])
         } else {
             // sha256d of the concatenation of the nSequences
-            let mut raw_vec = vec![];
-            for inp in self.input.iter() {
-                raw_vec.append(&mut inp.sequence.to_le_bytes().to_vec());
-            }
+            let raw_vec = self
+                .input
+                .iter()
+                .flat_map(|inp| inp.sequence.to_le_bytes())
+                .collect::<Vec<_>>();
             Sha256dHash::from_data(&raw_vec)
         }
     }
@@ -327,26 +328,27 @@ impl Transaction {
     /// does not work for codeseparator
     fn segwit_script_pubkey_bytes(&self, script: &Script) -> Vec<u8> {
         // bizarrely, if this is a p2wpkh, we have to convert it into a p2pkh
-        let script_bytes = script.clone().into_bytes();
+        let script_bytes = script.as_bytes();
         if script_bytes.len() == 22 && script_bytes[0..2] == [0x00, 0x14] {
             // p2wpkh --> length-prefixed p2pkh
-            let mut converted_script_bytes = vec![];
-            converted_script_bytes.append(&mut vec![0x19, 0x76, 0xa9, 0x14]);
-            converted_script_bytes.append(&mut script_bytes[2..22].to_vec());
-            converted_script_bytes.append(&mut vec![0x88, 0xac]);
+            let mut converted_script_bytes = Vec::with_capacity(26);
+            converted_script_bytes.extend_from_slice(&[0x19, 0x76, 0xa9, 0x14]);
+            converted_script_bytes.extend_from_slice(&script_bytes[2..22]);
+            converted_script_bytes.extend_from_slice(&[0x88, 0xac]);
             converted_script_bytes
         } else {
             // p2wsh or p2tr
             // codeseparator is not supported
             // prefix the script bytes with a varint length
-            let mut length_script = vec![];
-            let mut script_bytes = script.clone().into_bytes();
-            let script_len = VarInt(script_bytes.len() as u64);
+            let script_bytes_len = script_bytes.len();
+            let script_len = VarInt(script_bytes_len as u64);
+            let mut length_script =
+                Vec::with_capacity(script_len.encoded_length() as usize + script_bytes_len);
 
             let mut script_len_bytes =
                 serialize(&script_len).expect("FATAL: failed to encode varint");
             length_script.append(&mut script_len_bytes);
-            length_script.append(&mut script_bytes);
+            length_script.extend_from_slice(&script_bytes);
             length_script
         }
     }
@@ -357,28 +359,31 @@ impl Transaction {
             // hash of all output amounts and scriptpubkeys
             let mut raw_vec = vec![];
             for outp in self.output.iter() {
-                raw_vec.append(&mut outp.value.to_le_bytes().to_vec());
+                raw_vec.extend_from_slice(&outp.value.to_le_bytes());
 
-                let mut script_bytes = outp.script_pubkey.clone().into_bytes();
+                let script_bytes = outp.script_pubkey.as_bytes();
                 let script_len = VarInt(script_bytes.len() as u64);
 
                 let mut script_len_bytes =
                     serialize(&script_len).expect("FATAL: failed to encode varint");
                 raw_vec.append(&mut script_len_bytes);
-                raw_vec.append(&mut script_bytes);
+                raw_vec.extend_from_slice(&script_bytes);
             }
             Sha256dHash::from_data(&raw_vec)
         } else if sighash_type == SigHashType::Single && input_index < self.output.len() {
             // hash of just the output indexed by the input index
-            let mut raw_vec = vec![];
 
-            let mut script_bytes = self.output[input_index].script_pubkey.clone().into_bytes();
-            let script_len = VarInt(script_bytes.len() as u64);
+            let script_bytes = self.output[input_index].script_pubkey.as_bytes();
+            let script_bytes_len = script_bytes.len();
+            let script_len = VarInt(script_bytes_len as u64);
+
+            let mut raw_vec =
+                Vec::with_capacity(script_len.encoded_length() as usize + script_bytes_len);
 
             let mut script_len_bytes =
                 serialize(&script_len).expect("FATAL: failed to encode varint");
             raw_vec.append(&mut script_len_bytes);
-            raw_vec.append(&mut script_bytes);
+            raw_vec.extend_from_slice(script_bytes);
             Sha256dHash::from_data(&raw_vec)
         } else {
             Sha256dHash([0u8; 32])
@@ -410,15 +415,15 @@ impl Transaction {
             SigHashType::from_u32(sighash_u32).split_anyonecanpay_flag();
 
         // nVersion
-        raw_vec.append(&mut self.version.to_le_bytes().to_vec());
+        raw_vec.extend_from_slice(&self.version.to_le_bytes());
 
         // hashPrevouts
         let prevouts_hash = self.segwit_prevouts_hash(anyone_can_pay);
-        raw_vec.append(&mut prevouts_hash.as_bytes().to_vec());
+        raw_vec.extend_from_slice(prevouts_hash.as_bytes());
 
         // hashSequence
         let hash_sequence = self.segwit_sequence_hash(sighash, anyone_can_pay);
-        raw_vec.append(&mut hash_sequence.as_bytes().to_vec());
+        raw_vec.extend_from_slice(hash_sequence.as_bytes());
 
         // outpoint in question
         let mut outpoint_to_sign = serialize(&self.input[input_index].previous_output)
@@ -430,20 +435,20 @@ impl Transaction {
         raw_vec.append(&mut script_code);
 
         // value sent
-        raw_vec.append(&mut amount.to_le_bytes().to_vec());
+        raw_vec.extend_from_slice(&amount.to_le_bytes());
 
         // input sequence
-        raw_vec.append(&mut self.input[input_index].sequence.to_le_bytes().to_vec());
+        raw_vec.extend_from_slice(&self.input[input_index].sequence.to_le_bytes());
 
         // hashed outputs
         let outputs_hash = self.segwit_outputs_hash(input_index, sighash);
-        raw_vec.append(&mut outputs_hash.as_bytes().to_vec());
+        raw_vec.extend_from_slice(outputs_hash.as_bytes());
 
         // locktime
-        raw_vec.append(&mut self.lock_time.to_le_bytes().to_vec());
+        raw_vec.extend_from_slice(&self.lock_time.to_le_bytes());
 
         // sighash
-        raw_vec.append(&mut sighash_u32.to_le_bytes().to_vec());
+        raw_vec.extend_from_slice(&sighash_u32.to_le_bytes());
 
         Sha256dHash::from_data(&raw_vec)
     }

From 29cfdb8620769721ec936b0819a9ae52cf2b2b3a Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Sat, 24 Feb 2024 22:51:31 -0500
Subject: [PATCH 0948/1166] chore: Undo `flat_map()` changes because this seems
 to optimize significantly worse than a `for` loop

---
 .../bitcoin/blockdata/transaction.rs          | 25 ++++++++-----------
 1 file changed, 10 insertions(+), 15 deletions(-)

diff --git a/stacks-common/src/deps_common/bitcoin/blockdata/transaction.rs b/stacks-common/src/deps_common/bitcoin/blockdata/transaction.rs
index eaef8050fe..f92a11cd1b 100644
--- a/stacks-common/src/deps_common/bitcoin/blockdata/transaction.rs
+++ b/stacks-common/src/deps_common/bitcoin/blockdata/transaction.rs
@@ -291,16 +291,12 @@ impl Transaction {
         } else {
             // sha256d of the concatenation of the previous outpoints, which are each the concatenation
             // of the previous txid and output index
-            let raw_vec = self
-                .input
-                .iter()
-                .flat_map(|inp| {
-                    serialize(&inp.previous_output)
-                        .expect("FATAL: failed to encode previous output")
-                        .into_iter()
-                })
-                .collect::<Vec<_>>();
-
+            let mut raw_vec = vec![];
+            for inp in self.input.iter() {
+                let mut prev_output_bytes = serialize(&inp.previous_output)
+                    .expect("FATAL: failed to encode previous output");
+                raw_vec.append(&mut prev_output_bytes);
+            }
             Sha256dHash::from_data(&raw_vec)
         }
     }
@@ -315,11 +311,10 @@ impl Transaction {
             Sha256dHash([0u8; 32])
         } else {
             // sha256d of the concatenation of the nSequences
-            let raw_vec = self
-                .input
-                .iter()
-                .flat_map(|inp| inp.sequence.to_le_bytes())
-                .collect::<Vec<_>>();
+            let mut raw_vec = vec![];
+            for inp in self.input.iter() {
+                raw_vec.extend_from_slice(&inp.sequence.to_le_bytes());
+            }
             Sha256dHash::from_data(&raw_vec)
         }
     }

From a6e3bedb21f806979477c15ae72120d21a39e659 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Mon, 26 Feb 2024 12:44:42 -0500
Subject: [PATCH 0949/1166] chore: Minor performance tweaks

---
 stacks-common/src/types/chainstate.rs | 12 +++---------
 1 file changed, 3 insertions(+), 9 deletions(-)

diff --git a/stacks-common/src/types/chainstate.rs b/stacks-common/src/types/chainstate.rs
index bd3452aedb..d41e21225d 100644
--- a/stacks-common/src/types/chainstate.rs
+++ b/stacks-common/src/types/chainstate.rs
@@ -361,9 +361,7 @@ impl BlockHeaderHash {
 
     pub fn from_serialized_header(buf: &[u8]) -> BlockHeaderHash {
         let h = Sha512Trunc256Sum::from_data(buf);
-        let mut b = [0u8; 32];
-        b.copy_from_slice(h.as_bytes());
-        BlockHeaderHash(b)
+        BlockHeaderHash(h.to_bytes())
     }
 }
 
@@ -377,8 +375,7 @@ impl BurnchainHeaderHash {
     }
 
     pub fn to_bitcoin_hash(&self) -> Sha256dHash {
-        let mut bytes = self.0.to_vec();
-        bytes.reverse();
+        let bytes = self.0.iter().rev().copied().collect::<Vec<_>>();
         let mut buf = [0u8; 32];
         buf.copy_from_slice(&bytes[0..32]);
         Sha256dHash(buf)
@@ -399,10 +396,7 @@ impl BurnchainHeaderHash {
         bytes.extend_from_slice(index_root.as_bytes());
         bytes.extend_from_slice(&noise.to_be_bytes());
         let h = DoubleSha256::from_data(&bytes[..]);
-        let mut hb = [0u8; 32];
-        hb.copy_from_slice(h.as_bytes());
-
-        BurnchainHeaderHash(hb)
+        BurnchainHeaderHash(h.to_bytes())
     }
 }
 

From 5a3b6f689586bacc4e2f1ecccff4c054578329a2 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Tue, 27 Feb 2024 14:38:54 -0500
Subject: [PATCH 0950/1166] chore: Address Brice's PR comments

---
 stacks-common/src/address/c32.rs                       |  7 +++++--
 .../src/deps_common/bitcoin/blockdata/script.rs        |  2 +-
 stacks-common/src/util/hash.rs                         | 10 ++++------
 3 files changed, 10 insertions(+), 9 deletions(-)

diff --git a/stacks-common/src/address/c32.rs b/stacks-common/src/address/c32.rs
index cf72ff8e99..67a0504b33 100644
--- a/stacks-common/src/address/c32.rs
+++ b/stacks-common/src/address/c32.rs
@@ -180,7 +180,8 @@ const C32_CHARACTERS_MAP: [Option<u8>; 128] = [
 ];
 
 fn c32_encode(input_bytes: &[u8]) -> String {
-    // c32-encoded size is 160%  that of ASCII
+    // ASCII characters are 8-bits and c32-encoding encodes 5-bits per
+    // character, so the c32-encoded size should be ceil((ascii size) * 8 / 5)
     let size = input_bytes.len().saturating_mul(8).div_ceil(5);
     let mut result = Vec::with_capacity(size);
     let mut carry = 0;
@@ -249,7 +250,9 @@ fn c32_decode_ascii(input_str: &str) -> Result<Vec<u8>, Error> {
         return Err(Error::InvalidCrockford32);
     }
 
-    // ASCII size is 62.5%  that of c32-encoded
+    // c32-encoding encodes 5 bits into each character, while ASCII encodes
+    // 8-bits into each character. So, the ASCII-encoded size should be
+    // ceil((c32 size) * 5 / 8)
     let size = iter_c32_digits.len().saturating_mul(5).div_ceil(8);
     let mut result = Vec::with_capacity(size);
     let mut carry: u16 = 0;
diff --git a/stacks-common/src/deps_common/bitcoin/blockdata/script.rs b/stacks-common/src/deps_common/bitcoin/blockdata/script.rs
index 2a7cc4f4dd..30b559a638 100644
--- a/stacks-common/src/deps_common/bitcoin/blockdata/script.rs
+++ b/stacks-common/src/deps_common/bitcoin/blockdata/script.rs
@@ -203,7 +203,7 @@ fn build_scriptint(n: i64) -> Vec<u8> {
     let neg = n < 0;
 
     let mut abs = n.abs() as usize;
-    let mut v = Vec::with_capacity(size_of::<usize>() / 8);
+    let mut v = Vec::with_capacity(size_of::<usize>() + 2);
     while abs > 0xFF {
         v.push((abs & 0xFF) as u8);
         abs >>= 8;
diff --git a/stacks-common/src/util/hash.rs b/stacks-common/src/util/hash.rs
index 6c15f75b91..634cbf485b 100644
--- a/stacks-common/src/util/hash.rs
+++ b/stacks-common/src/util/hash.rs
@@ -451,12 +451,10 @@ where
 
     /// Get a non-leaf hash
     pub fn get_node_hash(left: &H, right: &H) -> H {
-        let left_bits = left.bits();
-        let right_bits = right.bits();
-        let mut buf = Vec::with_capacity(left_bits.len() + right_bits.len());
-        buf.extend_from_slice(left_bits);
-        buf.extend_from_slice(right_bits);
-        H::from_tagged_data(MERKLE_PATH_NODE_TAG, &buf[..])
+        let iter = left.bits().iter();
+        let iter = iter.chain(right.bits().iter());
+        let buf = iter.copied().collect::<Vec<_>>();
+        H::from_tagged_data(MERKLE_PATH_NODE_TAG, &buf)
     }
 
     /// Find a given hash in a merkle tree row

From 16bd17cd43b21b25d159d2f423451194366eea46 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Tue, 27 Feb 2024 16:17:04 -0500
Subject: [PATCH 0951/1166] chore: Address Brice's PR comment

---
 stacks-common/src/deps_common/bitcoin/blockdata/script.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stacks-common/src/deps_common/bitcoin/blockdata/script.rs b/stacks-common/src/deps_common/bitcoin/blockdata/script.rs
index 30b559a638..f055316f25 100644
--- a/stacks-common/src/deps_common/bitcoin/blockdata/script.rs
+++ b/stacks-common/src/deps_common/bitcoin/blockdata/script.rs
@@ -203,7 +203,7 @@ fn build_scriptint(n: i64) -> Vec<u8> {
     let neg = n < 0;
 
     let mut abs = n.abs() as usize;
-    let mut v = Vec::with_capacity(size_of::<usize>() + 2);
+    let mut v = Vec::with_capacity(size_of::<usize>() + 1);
     while abs > 0xFF {
         v.push((abs & 0xFF) as u8);
         abs >>= 8;

From 6266b0086d53db1a99b7e85b7f6fb152e06b146d Mon Sep 17 00:00:00 2001
From: Marzi <marzi@trustmachines.co>
Date: Tue, 27 Feb 2024 22:26:45 -0500
Subject: [PATCH 0952/1166] Include rewardSet data in block events. Update
 integ tests to assert based on block events

---
 stackslib/src/chainstate/coordinator/mod.rs   |   5 +-
 stackslib/src/chainstate/nakamoto/mod.rs      |  44 +++--
 stackslib/src/chainstate/stacks/boot/mod.rs   |  14 ++
 stackslib/src/chainstate/stacks/db/blocks.rs  | 172 +++++++++---------
 stackslib/src/main.rs                         |   2 +-
 testnet/stacks-node/src/event_dispatcher.rs   |  38 ++--
 testnet/stacks-node/src/run_loop/mod.rs       |   1 -
 .../src/tests/nakamoto_integrations.rs        |  73 ++++++--
 8 files changed, 209 insertions(+), 140 deletions(-)

diff --git a/stackslib/src/chainstate/coordinator/mod.rs b/stackslib/src/chainstate/coordinator/mod.rs
index 100772dd22..dbfa9f1255 100644
--- a/stackslib/src/chainstate/coordinator/mod.rs
+++ b/stackslib/src/chainstate/coordinator/mod.rs
@@ -33,7 +33,7 @@ use stacks_common::types::chainstate::{
 use stacks_common::util::get_epoch_time_secs;
 
 pub use self::comm::CoordinatorCommunication;
-use super::stacks::boot::RewardSet;
+use super::stacks::boot::{RewardSet, RewardSetData};
 use super::stacks::db::blocks::DummyEventDispatcher;
 use crate::burnchains::affirmation::{AffirmationMap, AffirmationMapEntry};
 use crate::burnchains::bitcoin::indexer::BitcoinIndexer;
@@ -177,8 +177,7 @@ pub trait BlockEventDispatcher {
         anchored_consumed: &ExecutionCost,
         mblock_confirmed_consumed: &ExecutionCost,
         pox_constants: &PoxConstants,
-        reward_set: &Option<RewardSet>,
-        cycle_number: &Option<u64>,
+        reward_set_data: &Option<RewardSetData>,
     );
 
     /// called whenever a burn block is about to be
diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index a86ab82a66..3236d4d424 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -56,7 +56,7 @@ use super::burn::db::sortdb::{
 };
 use super::burn::operations::{DelegateStxOp, StackStxOp, TransferStxOp};
 use super::stacks::boot::{
-    PoxVersions, RawRewardSetEntry, RewardSet, BOOT_TEST_POX_4_AGG_KEY_CONTRACT,
+    PoxVersions, RawRewardSetEntry, RewardSet, RewardSetData, BOOT_TEST_POX_4_AGG_KEY_CONTRACT,
     BOOT_TEST_POX_4_AGG_KEY_FNAME, SIGNERS_MAX_LIST_SIZE, SIGNERS_NAME, SIGNERS_PK_LEN,
 };
 use super::stacks::db::accounts::MinerReward;
@@ -1376,8 +1376,7 @@ impl NakamotoChainState {
             return Err(e);
         };
 
-        let (receipt, clarity_commit, reward_set, cycle_number) =
-            ok_opt.expect("FATAL: unreachable");
+        let (receipt, clarity_commit, reward_set_data) = ok_opt.expect("FATAL: unreachable");
 
         assert_eq!(
             receipt.header.anchored_header.block_hash(),
@@ -1433,8 +1432,7 @@ impl NakamotoChainState {
                 &receipt.anchored_block_cost,
                 &receipt.parent_microblocks_cost,
                 &pox_constants,
-                &reward_set,
-                &cycle_number,
+                &reward_set_data,
             );
         }
 
@@ -2667,8 +2665,7 @@ impl NakamotoChainState {
         (
             StacksEpochReceipt,
             PreCommitClarityBlock<'a>,
-            Option<RewardSet>,
-            Option<u64>,
+            Option<RewardSetData>,
         ),
         ChainstateError,
     > {
@@ -2994,16 +2991,30 @@ impl NakamotoChainState {
         // NOTE: miner and proposal evaluation should not invoke this because
         //  it depends on knowing the StacksBlockId.
         let signers_updated = signer_set_calc.is_some();
-        let mut reward_set = None;
-        let mut cycle_of_prepare_phase = None;
+        let mut reward_set_data = None;
         if let Some(signer_calculation) = signer_set_calc {
-            reward_set = Some(signer_calculation.reward_set.clone());
             Self::write_reward_set(chainstate_tx, &new_block_id, &signer_calculation.reward_set)?;
-            let first_block_height = burn_dbconn.get_burn_start_height();
-            cycle_of_prepare_phase = pox_constants.reward_cycle_of_prepare_phase(
+
+            let cycle_number = if let Some(cycle) = pox_constants.reward_cycle_of_prepare_phase(
                 first_block_height.into(),
                 chain_tip_burn_header_height.into(),
-            );
+            ) {
+                Some(cycle)
+            } else {
+                pox_constants
+                    .block_height_to_reward_cycle(
+                        first_block_height.into(),
+                        chain_tip_burn_header_height.into(),
+                    )
+                    .map(|cycle| cycle + 1)
+            };
+
+            if let Some(cycle) = cycle_number {
+                reward_set_data = Some(RewardSetData::new(
+                    signer_calculation.reward_set.clone(),
+                    cycle,
+                ));
+            }
         }
 
         monitoring::set_last_block_transaction_count(u64::try_from(block.txs.len()).unwrap());
@@ -3045,12 +3056,7 @@ impl NakamotoChainState {
             signers_updated,
         };
 
-        Ok((
-            epoch_receipt,
-            clarity_commit,
-            reward_set,
-            cycle_of_prepare_phase,
-        ))
+        Ok((epoch_receipt, clarity_commit, reward_set_data))
     }
 
     /// Create a StackerDB config for the .miners contract.
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 3a1c77f97e..c2970be7d2 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -232,6 +232,11 @@ pub struct RewardSet {
     pub signers: Option<Vec<NakamotoSignerEntry>>,
 }
 
+#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
+pub struct RewardSetData {
+    pub reward_set: RewardSet,
+    pub cycle_number: u64,
+}
 const POX_CYCLE_START_HANDLED_VALUE: &'static str = "1";
 
 impl PoxStartCycleInfo {
@@ -271,6 +276,15 @@ impl RewardSet {
     }
 }
 
+impl RewardSetData {
+    pub fn new(reward_set: RewardSet, cycle_number: u64) -> RewardSetData {
+        RewardSetData {
+            reward_set,
+            cycle_number,
+        }
+    }
+}
+
 impl StacksChainState {
     /// Return the MARF key used to store whether or not a given PoX
     ///  cycle's "start" has been handled by the Stacks fork yet. This
diff --git a/stackslib/src/chainstate/stacks/db/blocks.rs b/stackslib/src/chainstate/stacks/db/blocks.rs
index b4b6ed7ce3..fd0d44ed0e 100644
--- a/stackslib/src/chainstate/stacks/db/blocks.rs
+++ b/stackslib/src/chainstate/stacks/db/blocks.rs
@@ -191,8 +191,7 @@ impl BlockEventDispatcher for DummyEventDispatcher {
         _anchor_block_cost: &ExecutionCost,
         _confirmed_mblock_cost: &ExecutionCost,
         _pox_constants: &PoxConstants,
-        _reward_set: &Option<RewardSet>,
-        _cycle_number: &Option<u64>,
+        _reward_set_data: &Option<RewardSetData>,
     ) {
         assert!(
             false,
@@ -5297,8 +5296,7 @@ impl StacksChainState {
         (
             StacksEpochReceipt,
             PreCommitClarityBlock<'a>,
-            Option<RewardSet>,
-            Option<u64>,
+            Option<RewardSetData>,
         ),
         Error,
     > {
@@ -5688,7 +5686,7 @@ impl StacksChainState {
                 signers_updated: false,
             };
 
-            return Ok((epoch_receipt, clarity_commit, None, None));
+            return Ok((epoch_receipt, clarity_commit, None));
         }
 
         let parent_block_header = parent_chain_tip
@@ -5725,21 +5723,36 @@ impl StacksChainState {
         // NOTE: miner and proposal evaluation should not invoke this because
         //  it depends on knowing the StacksBlockId.
         let signers_updated = signer_set_calc.is_some();
-        let mut reward_set = None;
-        let mut cycle_of_prepare_phase = None;
+        let mut reward_set_data = None;
         if let Some(signer_calculation) = signer_set_calc {
-            reward_set = Some(signer_calculation.reward_set.clone());
             let new_block_id = new_tip.index_block_hash();
             NakamotoChainState::write_reward_set(
                 chainstate_tx,
                 &new_block_id,
                 &signer_calculation.reward_set,
             )?;
+
             let first_block_height = burn_dbconn.get_burn_start_height();
-            cycle_of_prepare_phase = pox_constants.reward_cycle_of_prepare_phase(
+            let cycle_number = if let Some(cycle) = pox_constants.reward_cycle_of_prepare_phase(
                 first_block_height.into(),
                 parent_burn_block_height.into(),
-            );
+            ) {
+                Some(cycle)
+            } else {
+                pox_constants
+                    .block_height_to_reward_cycle(
+                        first_block_height.into(),
+                        parent_burn_block_height.into(),
+                    )
+                    .map(|cycle| cycle + 1)
+            };
+
+            if let Some(cycle) = cycle_number {
+                reward_set_data = Some(RewardSetData::new(
+                    signer_calculation.reward_set.clone(),
+                    cycle,
+                ));
+            }
         }
 
         set_last_block_transaction_count(
@@ -5762,12 +5775,7 @@ impl StacksChainState {
             signers_updated,
         };
 
-        Ok((
-            epoch_receipt,
-            clarity_commit,
-            reward_set,
-            cycle_of_prepare_phase,
-        ))
+        Ok((epoch_receipt, clarity_commit, reward_set_data))
     }
 
     /// Verify that a Stacks anchored block attaches to its parent anchored block.
@@ -6099,81 +6107,80 @@ impl StacksChainState {
         // Execute the confirmed microblocks' transactions against the chain state, and then
         // execute the anchored block's transactions against the chain state.
         let pox_constants = sort_tx.context.pox_constants.clone();
-        let (epoch_receipt, clarity_commit, reward_set, cycle_number) =
-            match StacksChainState::append_block(
-                &mut chainstate_tx,
-                clarity_instance,
-                sort_tx,
-                &pox_constants,
-                &parent_header_info,
-                &next_staging_block.consensus_hash,
-                &burn_header_hash,
-                burn_header_height,
-                burn_header_timestamp,
-                &block,
-                block_size,
-                &next_microblocks,
-                next_staging_block.commit_burn,
-                next_staging_block.sortition_burn,
-                &user_supports,
-                block_am.weight(),
-                false,
-            ) {
-                Ok(next_chain_tip_info) => next_chain_tip_info,
-                Err(e) => {
-                    // something's wrong with this epoch -- either a microblock was invalid, or the
-                    // anchored block was invalid.  Either way, the anchored block will _never be_
-                    // valid, so we can drop it from the chunk store and orphan all of its descendants.
-                    test_debug!(
-                        "Failed to append {}/{}",
-                        &next_staging_block.consensus_hash,
-                        &block.block_hash()
-                    );
-                    StacksChainState::set_block_processed(
-                        chainstate_tx.deref_mut(),
-                        None,
-                        &blocks_path,
-                        &next_staging_block.consensus_hash,
-                        &block.header.block_hash(),
-                        false,
-                    )?;
-                    StacksChainState::free_block_state(
-                        &blocks_path,
-                        &next_staging_block.consensus_hash,
-                        &block.header,
-                    );
+        let (epoch_receipt, clarity_commit, reward_set_data) = match StacksChainState::append_block(
+            &mut chainstate_tx,
+            clarity_instance,
+            sort_tx,
+            &pox_constants,
+            &parent_header_info,
+            &next_staging_block.consensus_hash,
+            &burn_header_hash,
+            burn_header_height,
+            burn_header_timestamp,
+            &block,
+            block_size,
+            &next_microblocks,
+            next_staging_block.commit_burn,
+            next_staging_block.sortition_burn,
+            &user_supports,
+            block_am.weight(),
+            false,
+        ) {
+            Ok(next_chain_tip_info) => next_chain_tip_info,
+            Err(e) => {
+                // something's wrong with this epoch -- either a microblock was invalid, or the
+                // anchored block was invalid.  Either way, the anchored block will _never be_
+                // valid, so we can drop it from the chunk store and orphan all of its descendants.
+                test_debug!(
+                    "Failed to append {}/{}",
+                    &next_staging_block.consensus_hash,
+                    &block.block_hash()
+                );
+                StacksChainState::set_block_processed(
+                    chainstate_tx.deref_mut(),
+                    None,
+                    &blocks_path,
+                    &next_staging_block.consensus_hash,
+                    &block.header.block_hash(),
+                    false,
+                )?;
+                StacksChainState::free_block_state(
+                    &blocks_path,
+                    &next_staging_block.consensus_hash,
+                    &block.header,
+                );
 
-                    match e {
-                        Error::InvalidStacksMicroblock(ref msg, ref header_hash) => {
-                            // specifically, an ancestor microblock was invalid.  Drop any descendant microblocks --
-                            // they're never going to be valid in _any_ fork, even if they have a clone
-                            // in a neighboring burnchain fork.
-                            error!(
+                match e {
+                    Error::InvalidStacksMicroblock(ref msg, ref header_hash) => {
+                        // specifically, an ancestor microblock was invalid.  Drop any descendant microblocks --
+                        // they're never going to be valid in _any_ fork, even if they have a clone
+                        // in a neighboring burnchain fork.
+                        error!(
                             "Parent microblock stream from {}/{} is invalid at microblock {}: {}",
                             parent_header_info.consensus_hash,
                             parent_header_info.anchored_header.block_hash(),
                             header_hash,
                             msg
                         );
-                            StacksChainState::drop_staging_microblocks(
-                                chainstate_tx.deref_mut(),
-                                &parent_header_info.consensus_hash,
-                                &parent_header_info.anchored_header.block_hash(),
-                                header_hash,
-                            )?;
-                        }
-                        _ => {
-                            // block was invalid, but this means all the microblocks it confirmed are
-                            // still (potentially) valid.  However, they are not confirmed yet, so
-                            // leave them in the staging database.
-                        }
+                        StacksChainState::drop_staging_microblocks(
+                            chainstate_tx.deref_mut(),
+                            &parent_header_info.consensus_hash,
+                            &parent_header_info.anchored_header.block_hash(),
+                            header_hash,
+                        )?;
+                    }
+                    _ => {
+                        // block was invalid, but this means all the microblocks it confirmed are
+                        // still (potentially) valid.  However, they are not confirmed yet, so
+                        // leave them in the staging database.
                     }
+                }
 
-                    chainstate_tx.commit().map_err(Error::DBError)?;
+                chainstate_tx.commit().map_err(Error::DBError)?;
 
-                    return Err(e);
-                }
-            };
+                return Err(e);
+            }
+        };
 
         let receipt_anchored_header = epoch_receipt
             .header
@@ -6237,8 +6244,7 @@ impl StacksChainState {
                 &epoch_receipt.anchored_block_cost,
                 &epoch_receipt.parent_microblocks_cost,
                 &pox_constants,
-                &reward_set,
-                &cycle_number,
+                &reward_set_data,
             );
         }
 
diff --git a/stackslib/src/main.rs b/stackslib/src/main.rs
index e441e3e5ab..9468f28adc 100644
--- a/stackslib/src/main.rs
+++ b/stackslib/src/main.rs
@@ -1722,7 +1722,7 @@ fn replay_block(stacks_path: &str, index_block_hash_hex: &str) {
         block_am.weight(),
         true,
     ) {
-        Ok((_receipt, _, _, _)) => {
+        Ok((_receipt, _, _)) => {
             info!("Block processed successfully! block = {index_block_hash}");
         }
         Err(e) => {
diff --git a/testnet/stacks-node/src/event_dispatcher.rs b/testnet/stacks-node/src/event_dispatcher.rs
index 45febe497a..a1f1d86d76 100644
--- a/testnet/stacks-node/src/event_dispatcher.rs
+++ b/testnet/stacks-node/src/event_dispatcher.rs
@@ -17,7 +17,7 @@ use stacks::chainstate::burn::ConsensusHash;
 use stacks::chainstate::coordinator::BlockEventDispatcher;
 use stacks::chainstate::nakamoto::NakamotoBlock;
 use stacks::chainstate::stacks::address::PoxAddress;
-use stacks::chainstate::stacks::boot::RewardSet;
+use stacks::chainstate::stacks::boot::{RewardSet, RewardSetData};
 use stacks::chainstate::stacks::db::accounts::MinerReward;
 use stacks::chainstate::stacks::db::unconfirmed::ProcessedUnconfirmedState;
 use stacks::chainstate::stacks::db::{MinerRewardInfo, StacksHeaderInfo};
@@ -388,6 +388,7 @@ impl EventObserver {
         anchored_consumed: &ExecutionCost,
         mblock_confirmed_consumed: &ExecutionCost,
         pox_constants: &PoxConstants,
+        reward_set_data: &Option<RewardSetData>,
     ) -> serde_json::Value {
         // Serialize events to JSON
         let serialized_events: Vec<serde_json::Value> = filtered_events
@@ -408,7 +409,7 @@ impl EventObserver {
         }
 
         // Wrap events
-        json!({
+        let mut payload = json!({
             "block_hash": format!("0x{}", block.block_hash),
             "block_height": metadata.stacks_block_height,
             "burn_block_hash": format!("0x{}", metadata.burn_header_hash),
@@ -431,7 +432,20 @@ impl EventObserver {
             "pox_v1_unlock_height": pox_constants.v1_unlock_height,
             "pox_v2_unlock_height": pox_constants.v2_unlock_height,
             "pox_v3_unlock_height": pox_constants.v3_unlock_height,
-        })
+        });
+
+        if let Some(reward_set_data) = reward_set_data {
+            payload.as_object_mut().unwrap().insert(
+                "reward_set".to_string(),
+                serde_json::to_value(&reward_set_data.reward_set).unwrap_or_default(),
+            );
+            payload.as_object_mut().unwrap().insert(
+                "cycle_number".to_string(),
+                serde_json::to_value(reward_set_data.cycle_number).unwrap_or_default(),
+            );
+        }
+
+        payload
     }
 }
 
@@ -589,8 +603,7 @@ impl BlockEventDispatcher for EventDispatcher {
         anchored_consumed: &ExecutionCost,
         mblock_confirmed_consumed: &ExecutionCost,
         pox_constants: &PoxConstants,
-        reward_set: &Option<RewardSet>,
-        cycle_number: &Option<u64>,
+        reward_set_data: &Option<RewardSetData>,
     ) {
         self.process_chain_tip(
             block,
@@ -606,18 +619,8 @@ impl BlockEventDispatcher for EventDispatcher {
             anchored_consumed,
             mblock_confirmed_consumed,
             pox_constants,
+            reward_set_data,
         );
-
-        if let Some(reward_set) = reward_set {
-            debug!(
-                "reward_set in announce_block: {:?}, parent_block_id: {:?}, cycle_number: {:?}",
-                reward_set, parent, cycle_number
-            );
-            if let Some(cycle_num) = cycle_number {
-                //
-                self.process_stacker_set(reward_set, parent, *cycle_num)
-            }
-        }
     }
 
     fn announce_burn_block(
@@ -807,6 +810,7 @@ impl EventDispatcher {
         anchored_consumed: &ExecutionCost,
         mblock_confirmed_consumed: &ExecutionCost,
         pox_constants: &PoxConstants,
+        reward_set_data: &Option<RewardSetData>,
     ) {
         let all_receipts = receipts.to_owned();
         let (dispatch_matrix, events) = self.create_dispatch_matrix_and_event_vector(&all_receipts);
@@ -856,6 +860,7 @@ impl EventDispatcher {
                         anchored_consumed,
                         mblock_confirmed_consumed,
                         pox_constants,
+                        reward_set_data,
                     );
 
                 // Send payload
@@ -1266,6 +1271,7 @@ mod test {
             &anchored_consumed,
             &mblock_confirmed_consumed,
             &pox_constants,
+            &None,
         );
         assert_eq!(
             payload
diff --git a/testnet/stacks-node/src/run_loop/mod.rs b/testnet/stacks-node/src/run_loop/mod.rs
index 01f848c2e6..49cb4fb337 100644
--- a/testnet/stacks-node/src/run_loop/mod.rs
+++ b/testnet/stacks-node/src/run_loop/mod.rs
@@ -193,6 +193,5 @@ pub fn announce_boot_receipts(
         &ExecutionCost::zero(),
         pox_constants,
         &None,
-        &None,
     );
 }
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 3a1bc8f5ae..37c6ff5f53 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -1199,6 +1199,8 @@ fn correct_burn_outs() {
         .block_height_to_reward_cycle(epoch_3.start_height)
         .unwrap();
 
+    info!("first_epoch_3_cycle: {:?}", first_epoch_3_cycle);
+
     let http_origin = format!("http://{}", &naka_conf.node.rpc_bind);
     let stacker_response = get_stacker_set(&http_origin, first_epoch_3_cycle);
     assert!(stacker_response.stacker_set.signers.is_some());
@@ -1262,29 +1264,66 @@ fn correct_burn_outs() {
         .stop_chains_coordinator();
     run_loop_stopper.store(false, Ordering::SeqCst);
 
-    let stacker_sets = test_observer::get_stacker_sets();
-    info!("Stacker sets announced {:#?}", stacker_sets);
-    let mut sorted_stacker_sets = stacker_sets.clone();
-    sorted_stacker_sets.sort_by_key(|(_block_id, cycle_num, _reward_set)| *cycle_num);
+    let new_blocks_with_reward_set: Vec<serde_json::Value> = test_observer::get_blocks()
+        .into_iter()
+        .filter(|block| block.get("reward_set").is_some() && block.get("cycle_number").is_some())
+        .collect();
+    info!(
+        "Announced blocks that include reward sets: {:#?}",
+        new_blocks_with_reward_set
+    );
+
     assert_eq!(
-        sorted_stacker_sets, stacker_sets,
-        "Stacker set should be sorted by cycle number already"
+        new_blocks_with_reward_set.len(),
+        5,
+        "There should be exactly 5 blocks including reward cycles"
     );
 
-    for (_, cycle_number, reward_set) in stacker_sets.iter() {
-        if *cycle_number < first_epoch_3_cycle {
-            assert!(reward_set.signers.is_none());
-            // nothing else to check for < first_epoch_3_cycle
+    let cycle_numbers: Vec<u64> = new_blocks_with_reward_set
+        .iter()
+        .filter_map(|block| block.get("cycle_number").and_then(|cn| cn.as_u64()))
+        .collect();
+
+    let expected_cycles: Vec<u64> = (21..=25).collect();
+    assert_eq!(
+        cycle_numbers, expected_cycles,
+        "Cycle numbers should be 21 to 25 inclusive"
+    );
+
+    let mut sorted_new_blocks = new_blocks_with_reward_set.clone();
+    sorted_new_blocks.sort_by_key(|block| block["cycle_number"].as_u64().unwrap());
+    assert_eq!(
+        sorted_new_blocks, new_blocks_with_reward_set,
+        "Blocks should be sorted by cycle number already"
+    );
+
+    for block in new_blocks_with_reward_set.iter() {
+        let cycle_number = block["cycle_number"].as_u64().unwrap();
+        let reward_set = block["reward_set"].as_object().unwrap();
+
+        if cycle_number < first_epoch_3_cycle {
+            assert!(
+                reward_set.get("signers").is_none()
+                    || reward_set["signers"].as_array().unwrap().is_empty(),
+                "Signers should not be set before the first epoch 3 cycle"
+            );
             continue;
         }
-        let Some(signers) = reward_set.signers.clone() else {
-            panic!("Signers should be set in any epoch-3 cycles. First epoch-3 cycle: {first_epoch_3_cycle}. Checked cycle number: {cycle_number}");
-        };
-        // there should be 1 stacker signer, and 1 reward address
-        assert_eq!(reward_set.rewarded_addresses.len(), 1);
-        assert_eq!(signers.len(), 1);
+
+        // For cycles in or after first_epoch_3_cycle, ensure signers are present
+        let signers = reward_set["signers"].as_array().unwrap();
+        assert!(!signers.is_empty(), "Signers should be set in any epoch-3 cycles. First epoch-3 cycle: {first_epoch_3_cycle}. Checked cycle number: {cycle_number}");
+
+        assert_eq!(
+            reward_set["rewarded_addresses"].as_array().unwrap().len(),
+            1,
+            "There should be exactly 1 rewarded address"
+        );
+        assert_eq!(signers.len(), 1, "There should be exactly 1 signer");
+
         // the signer should have 1 "slot", because they stacked the minimum stacking amount
-        assert_eq!(signers[0].weight, 1);
+        let signer_weight = signers[0]["weight"].as_u64().unwrap();
+        assert_eq!(signer_weight, 1, "The signer should have a weight of 1, indicating they stacked the minimum stacking amount");
     }
 
     run_loop_thread.join().unwrap();

From ae05a62b3e3e4044be16bcc4b5255c0a35448329 Mon Sep 17 00:00:00 2001
From: Nikos Baxevanis <nikos.baxevanis@gmail.com>
Date: Wed, 21 Feb 2024 14:26:57 +0100
Subject: [PATCH 0953/1166] Add property-based tests for signers-voting
 contract functions

- reward-cycle-to-burn-height
- burn-height-to-reward-cycle
- is-in-prepare-phase

This effort, initially part of https://github.com/stacks-network/stacks-core/pull/4286,
is now in a separate commit and PR as it's autonomous with regards to PoX-4
property and fuzz testing. Additional property-based tests for the remaining
functions of the signers-voting contract are warranted and will be addressed
in separate commits/PRs.
---
 contrib/core-contract-tests/package-lock.json |  37 +++++
 contrib/core-contract-tests/package.json      |   1 +
 .../tests/pox-4/signers-voting.prop.test.ts   | 131 ++++++++++++++++++
 3 files changed, 169 insertions(+)
 create mode 100644 contrib/core-contract-tests/tests/pox-4/signers-voting.prop.test.ts

diff --git a/contrib/core-contract-tests/package-lock.json b/contrib/core-contract-tests/package-lock.json
index e5c3e22e18..d074caa541 100644
--- a/contrib/core-contract-tests/package-lock.json
+++ b/contrib/core-contract-tests/package-lock.json
@@ -12,6 +12,7 @@
         "@hirosystems/clarinet-sdk": "^1.1.0",
         "@stacks/transactions": "^6.9.0",
         "chokidar-cli": "^3.0.0",
+        "fast-check": "^3.15.1",
         "typescript": "^5.2.2",
         "vite": "^4.4.9",
         "vitest": "^0.34.4",
@@ -955,6 +956,27 @@
         "node": ">=6"
       }
     },
+    "node_modules/fast-check": {
+      "version": "3.15.1",
+      "resolved": "https://registry.npmjs.org/fast-check/-/fast-check-3.15.1.tgz",
+      "integrity": "sha512-GutOXZ+SCxGaFWfHe0Pbeq8PrkpGtPxA9/hdkI3s9YzqeMlrq5RdJ+QfYZ/S93jMX+tAyqgW0z5c9ppD+vkGUw==",
+      "funding": [
+        {
+          "type": "individual",
+          "url": "https://github.com/sponsors/dubzzz"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/fast-check"
+        }
+      ],
+      "dependencies": {
+        "pure-rand": "^6.0.0"
+      },
+      "engines": {
+        "node": ">=8.0.0"
+      }
+    },
     "node_modules/fill-range": {
       "version": "7.0.1",
       "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz",
@@ -1344,6 +1366,21 @@
         "node": ">= 6"
       }
     },
+    "node_modules/pure-rand": {
+      "version": "6.0.4",
+      "resolved": "https://registry.npmjs.org/pure-rand/-/pure-rand-6.0.4.tgz",
+      "integrity": "sha512-LA0Y9kxMYv47GIPJy6MI84fqTd2HmYZI83W/kM/SkKfDlajnZYfmXFTxkbY+xSBPkLJxltMa9hIkmdc29eguMA==",
+      "funding": [
+        {
+          "type": "individual",
+          "url": "https://github.com/sponsors/dubzzz"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/fast-check"
+        }
+      ]
+    },
     "node_modules/react-is": {
       "version": "18.2.0",
       "resolved": "https://registry.npmjs.org/react-is/-/react-is-18.2.0.tgz",
diff --git a/contrib/core-contract-tests/package.json b/contrib/core-contract-tests/package.json
index 2f11d87369..078afb67df 100644
--- a/contrib/core-contract-tests/package.json
+++ b/contrib/core-contract-tests/package.json
@@ -12,6 +12,7 @@
     "@hirosystems/clarinet-sdk": "^1.1.0",
     "@stacks/transactions": "^6.9.0",
     "chokidar-cli": "^3.0.0",
+    "fast-check": "^3.15.1",
     "typescript": "^5.2.2",
     "vite": "^4.4.9",
     "vitest": "^0.34.4",
diff --git a/contrib/core-contract-tests/tests/pox-4/signers-voting.prop.test.ts b/contrib/core-contract-tests/tests/pox-4/signers-voting.prop.test.ts
new file mode 100644
index 0000000000..b2f32efb30
--- /dev/null
+++ b/contrib/core-contract-tests/tests/pox-4/signers-voting.prop.test.ts
@@ -0,0 +1,131 @@
+import fc from "fast-check";
+import { expect, it } from "vitest";
+import { Cl } from "@stacks/transactions";
+
+it("should return correct reward-cycle-to-burn-height", () => {
+  fc.assert(
+    fc.property(
+      fc.constantFrom(...simnet.getAccounts().values()),
+      fc.nat(),
+      (account: string, reward_cycle: number) => {
+        // Arrange
+        const { result: pox_4_info } = simnet.callReadOnlyFn(
+          "pox-4",
+          "get-pox-info",
+          [],
+          account,
+        );
+        const first_burnchain_block_height =
+          // @ts-ignore
+          pox_4_info.value.data[
+            "first-burnchain-block-height"];
+        const reward_cycle_length =
+          // @ts-ignore
+          pox_4_info.value.data[
+            "reward-cycle-length"];
+
+        // Act
+        const { result: actual } = simnet.callReadOnlyFn(
+          "signers-voting",
+          "reward-cycle-to-burn-height",
+          [Cl.uint(reward_cycle)],
+          account,
+        );
+
+        // Assert
+        const expected = (reward_cycle * Number(reward_cycle_length.value)) +
+          Number(first_burnchain_block_height.value);
+        expect(actual).toBeUint(expected);
+      },
+    ),
+    { numRuns: 250 },
+  );
+});
+
+it("should return correct burn-height-to-reward-cycle", () => {
+  fc.assert(
+    fc.property(
+      fc.constantFrom(...simnet.getAccounts().values()),
+      fc.nat(),
+      (account: string, height: number) => {
+        // Arrange
+        const { result: pox_4_info } = simnet.callReadOnlyFn(
+          "pox-4",
+          "get-pox-info",
+          [],
+          account,
+        );
+        const first_burnchain_block_height =
+          // @ts-ignore
+          pox_4_info.value.data[
+            "first-burnchain-block-height"];
+        const reward_cycle_length =
+          // @ts-ignore
+          pox_4_info.value.data[
+            "reward-cycle-length"];
+
+        // Act
+        const { result: actual } = simnet.callReadOnlyFn(
+          "signers-voting",
+          "burn-height-to-reward-cycle",
+          [Cl.uint(height)],
+          account,
+        );
+
+        // Assert
+        const expected = Math.floor(
+          (height - Number(first_burnchain_block_height.value)) /
+            Number(reward_cycle_length.value),
+        );
+        expect(actual).toBeUint(expected);
+      },
+    ),
+    { numRuns: 250 },
+  );
+});
+
+it("should return correct is-in-prepare-phase", () => {
+  fc.assert(
+    fc.property(
+      fc.constantFrom(...simnet.getAccounts().values()),
+      fc.nat(),
+      (account: string, height: number) => {
+        // Arrange
+        const { result: pox_4_info } = simnet.callReadOnlyFn(
+          "pox-4",
+          "get-pox-info",
+          [],
+          account,
+        );
+        const first_burnchain_block_height =
+          // @ts-ignore
+          pox_4_info.value.data[
+            "first-burnchain-block-height"];
+        const prepare_cycle_length =
+          // @ts-ignore
+          pox_4_info.value.data[
+            "prepare-cycle-length"];
+        const reward_cycle_length =
+          // @ts-ignore
+          pox_4_info.value.data[
+            "reward-cycle-length"];
+
+        // Act
+        const { result: actual } = simnet.callReadOnlyFn(
+          "signers-voting",
+          "is-in-prepare-phase",
+          [Cl.uint(height)],
+          account,
+        );
+
+        // Assert
+        const expected = ((height - Number(first_burnchain_block_height.value) +
+          Number(prepare_cycle_length.value)) %
+          Number(reward_cycle_length.value)) <
+          Number(prepare_cycle_length.value);
+        expect(actual).toBeBool(expected);
+      },
+    ),
+    { numRuns: 250 },
+  );
+});

From 6e6090eb80f5613bacceb809f0858169c129c7af Mon Sep 17 00:00:00 2001
From: Nikos Baxevanis <nikos.baxevanis@gmail.com>
Date: Wed, 28 Feb 2024 13:25:34 +0100
Subject: [PATCH 0954/1166] Bump @stacks/transactions for `isClarityType`

- Bump @stacks/transactions from ^6.9.0 to ^6.12.0 for `isClarityType`.
- Use `assert` and `isClarityType` for stricter TypeScript type checks.
- Replace `// @ts-ignore` with precise assertions, improving tests.

Thanks to Hugo Caillard for his crucial help and guidance.
---
 contrib/core-contract-tests/package-lock.json | 32 ++++++-------
 contrib/core-contract-tests/package.json      |  2 +-
 .../tests/pox-4/signers-voting.prop.test.ts   | 45 +++++++++----------
 3 files changed, 39 insertions(+), 40 deletions(-)

diff --git a/contrib/core-contract-tests/package-lock.json b/contrib/core-contract-tests/package-lock.json
index d074caa541..1fcb7e7f72 100644
--- a/contrib/core-contract-tests/package-lock.json
+++ b/contrib/core-contract-tests/package-lock.json
@@ -10,7 +10,7 @@
       "license": "ISC",
       "dependencies": {
         "@hirosystems/clarinet-sdk": "^1.1.0",
-        "@stacks/transactions": "^6.9.0",
+        "@stacks/transactions": "^6.12.0",
         "chokidar-cli": "^3.0.0",
         "fast-check": "^3.15.1",
         "typescript": "^5.2.2",
@@ -417,40 +417,40 @@
       "integrity": "sha512-+Fj43pSMwJs4KRrH/938Uf+uAELIgVBmQzg/q1YG10djyfA3TnrU8N8XzqCh/okZdszqBQTZf96idMfE5lnwTA=="
     },
     "node_modules/@stacks/common": {
-      "version": "6.8.1",
-      "resolved": "https://registry.npmjs.org/@stacks/common/-/common-6.8.1.tgz",
-      "integrity": "sha512-ewL9GLZNQYa5a/3K4xSHlHIgHkD4rwWW/QEaPId8zQIaL+1O9qCaF4LX9orNQeOmEk8kvG0x2xGV54fXKCZeWQ==",
+      "version": "6.10.0",
+      "resolved": "https://registry.npmjs.org/@stacks/common/-/common-6.10.0.tgz",
+      "integrity": "sha512-6x5Z7AKd9/kj3+DYE9xIDIkFLHihBH614i2wqrZIjN02WxVo063hWSjIlUxlx8P4gl6olVzlOy5LzhLJD9OP0A==",
       "dependencies": {
         "@types/bn.js": "^5.1.0",
         "@types/node": "^18.0.4"
       }
     },
     "node_modules/@stacks/network": {
-      "version": "6.8.1",
-      "resolved": "https://registry.npmjs.org/@stacks/network/-/network-6.8.1.tgz",
-      "integrity": "sha512-n8M25pPbLqpSBctabtsLOTBlmPvm9EPQpTI//x7HLdt5lEjDXxauEQt0XGSvDUZwecrmztqt9xNxlciiGApRBw==",
+      "version": "6.11.3",
+      "resolved": "https://registry.npmjs.org/@stacks/network/-/network-6.11.3.tgz",
+      "integrity": "sha512-c4ClCU/QUwuu8NbHtDKPJNa0M5YxauLN3vYaR0+S4awbhVIKFQSxirm9Q9ckV1WBh7FtD6u2S0x+tDQGAODjNg==",
       "dependencies": {
-        "@stacks/common": "^6.8.1",
+        "@stacks/common": "^6.10.0",
         "cross-fetch": "^3.1.5"
       }
     },
     "node_modules/@stacks/transactions": {
-      "version": "6.9.0",
-      "resolved": "https://registry.npmjs.org/@stacks/transactions/-/transactions-6.9.0.tgz",
-      "integrity": "sha512-hSs9+0Ew++GwMZMgPObOx0iVCQRxkiCqI+DHdPEikAmg2utpyLh2/txHOjfSIkQHvcBfJJ6O5KphmxDP4gUqiA==",
+      "version": "6.12.0",
+      "resolved": "https://registry.npmjs.org/@stacks/transactions/-/transactions-6.12.0.tgz",
+      "integrity": "sha512-gRP3SfTaAIoTdjMvOiLrMZb/senqB8JQlT5Y4C3/CiHhiprYwTx7TbOCSa7WsNOU99H4aNfHvatmymuggXQVkA==",
       "dependencies": {
         "@noble/hashes": "1.1.5",
         "@noble/secp256k1": "1.7.1",
-        "@stacks/common": "^6.8.1",
-        "@stacks/network": "^6.8.1",
+        "@stacks/common": "^6.10.0",
+        "@stacks/network": "^6.11.3",
         "c32check": "^2.0.0",
         "lodash.clonedeep": "^4.5.0"
       }
     },
     "node_modules/@types/bn.js": {
-      "version": "5.1.4",
-      "resolved": "https://registry.npmjs.org/@types/bn.js/-/bn.js-5.1.4.tgz",
-      "integrity": "sha512-ZtBd9L8hVtoBpPMSWfbwjC4dhQtJdlPS+e1A0Rydb7vg7bDcUwiRklPx24sMYtXcmAMST/k0Wze7JLbNU/5SkA==",
+      "version": "5.1.5",
+      "resolved": "https://registry.npmjs.org/@types/bn.js/-/bn.js-5.1.5.tgz",
+      "integrity": "sha512-V46N0zwKRF5Q00AZ6hWtN0T8gGmDUaUzLWQvHFo5yThtVwK/VCenFY3wXVbOvNfajEpsTfQM4IN9k/d6gUVX3A==",
       "dependencies": {
         "@types/node": "*"
       }
diff --git a/contrib/core-contract-tests/package.json b/contrib/core-contract-tests/package.json
index 078afb67df..561c7ab2c6 100644
--- a/contrib/core-contract-tests/package.json
+++ b/contrib/core-contract-tests/package.json
@@ -10,7 +10,7 @@
   "license": "ISC",
   "dependencies": {
     "@hirosystems/clarinet-sdk": "^1.1.0",
-    "@stacks/transactions": "^6.9.0",
+    "@stacks/transactions": "^6.12.0",
     "chokidar-cli": "^3.0.0",
     "fast-check": "^3.15.1",
     "typescript": "^5.2.2",
diff --git a/contrib/core-contract-tests/tests/pox-4/signers-voting.prop.test.ts b/contrib/core-contract-tests/tests/pox-4/signers-voting.prop.test.ts
index b2f32efb30..0dc8ea2171 100644
--- a/contrib/core-contract-tests/tests/pox-4/signers-voting.prop.test.ts
+++ b/contrib/core-contract-tests/tests/pox-4/signers-voting.prop.test.ts
@@ -1,6 +1,6 @@
 import fc from "fast-check";
-import { expect, it } from "vitest";
-import { Cl } from "@stacks/transactions";
+import { assert, expect, it } from "vitest";
+import { Cl, ClarityType, isClarityType } from "@stacks/transactions";
 
 it("should return correct reward-cycle-to-burn-height", () => {
   fc.assert(
@@ -15,14 +15,12 @@ it("should return correct reward-cycle-to-burn-height", () => {
           [],
           account,
         );
+        assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+        assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
         const first_burnchain_block_height =
-          // @ts-ignore
-          pox_4_info.value.data[
-            "first-burnchain-block-height"];
+          pox_4_info.value.data["first-burnchain-block-height"];
         const reward_cycle_length =
-          // @ts-ignore
-          pox_4_info.value.data[
-            "reward-cycle-length"];
+          pox_4_info.value.data["reward-cycle-length"];
 
         // Act
         const { result: actual } = simnet.callReadOnlyFn(
@@ -33,6 +31,8 @@ it("should return correct reward-cycle-to-burn-height", () => {
         );
 
         // Assert
+        assert(isClarityType(reward_cycle_length, ClarityType.UInt));
+        assert(isClarityType(first_burnchain_block_height, ClarityType.UInt));
         const expected = (reward_cycle * Number(reward_cycle_length.value)) +
           Number(first_burnchain_block_height.value);
         expect(actual).toBeUint(expected);
@@ -55,14 +55,12 @@ it("should return correct burn-height-to-reward-cycle", () => {
           [],
           account,
         );
+        assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+        assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
         const first_burnchain_block_height =
-          // @ts-ignore
-          pox_4_info.value.data[
-            "first-burnchain-block-height"];
+          pox_4_info.value.data["first-burnchain-block-height"];
         const reward_cycle_length =
-          // @ts-ignore
-          pox_4_info.value.data[
-            "reward-cycle-length"];
+          pox_4_info.value.data["reward-cycle-length"];
 
         // Act
         const { result: actual } = simnet.callReadOnlyFn(
@@ -73,6 +71,8 @@ it("should return correct burn-height-to-reward-cycle", () => {
         );
 
         // Assert
+        assert(isClarityType(first_burnchain_block_height, ClarityType.UInt));
+        assert(isClarityType(reward_cycle_length, ClarityType.UInt));
         const expected = Math.floor(
           (height - Number(first_burnchain_block_height.value)) /
             Number(reward_cycle_length.value),
@@ -97,18 +97,14 @@ it("should return correct is-in-prepare-phase", () => {
           [],
           account,
         );
+        assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+        assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
         const first_burnchain_block_height =
-          // @ts-ignore
-          pox_4_info.value.data[
-            "first-burnchain-block-height"];
+          pox_4_info.value.data["first-burnchain-block-height"];
         const prepare_cycle_length =
-          // @ts-ignore
-          pox_4_info.value.data[
-            "prepare-cycle-length"];
+          pox_4_info.value.data["prepare-cycle-length"];
         const reward_cycle_length =
-          // @ts-ignore
-          pox_4_info.value.data[
-            "reward-cycle-length"];
+          pox_4_info.value.data["reward-cycle-length"];
 
         // Act
         const { result: actual } = simnet.callReadOnlyFn(
@@ -119,6 +115,9 @@ it("should return correct is-in-prepare-phase", () => {
         );
 
         // Assert
+        assert(isClarityType(first_burnchain_block_height, ClarityType.UInt));
+        assert(isClarityType(prepare_cycle_length, ClarityType.UInt));
+        assert(isClarityType(reward_cycle_length, ClarityType.UInt));
         const expected = ((height - Number(first_burnchain_block_height.value) +
           Number(prepare_cycle_length.value)) %
           Number(reward_cycle_length.value)) <

From b81fa922fc80cbad7363945ff239b3cc3c5309c3 Mon Sep 17 00:00:00 2001
From: Marzi <marzi@trustmachines.co>
Date: Wed, 28 Feb 2024 09:43:56 -0500
Subject: [PATCH 0955/1166] Fix build error

---
 stackslib/src/chainstate/coordinator/tests.rs | 3 +--
 stackslib/src/net/mod.rs                      | 3 +--
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/stackslib/src/chainstate/coordinator/tests.rs b/stackslib/src/chainstate/coordinator/tests.rs
index 17ab3a6925..4861e0af7a 100644
--- a/stackslib/src/chainstate/coordinator/tests.rs
+++ b/stackslib/src/chainstate/coordinator/tests.rs
@@ -426,8 +426,7 @@ impl BlockEventDispatcher for NullEventDispatcher {
         _anchor_block_cost: &ExecutionCost,
         _confirmed_mblock_cost: &ExecutionCost,
         _pox_constants: &PoxConstants,
-        _reward_set: &Option<RewardSet>,
-        _cycle_number: &Option<u64>,
+        _reward_set_data: &Option<RewardSetData>,
     ) {
         assert!(
             false,
diff --git a/stackslib/src/net/mod.rs b/stackslib/src/net/mod.rs
index 97069f6934..e21a1e91c3 100644
--- a/stackslib/src/net/mod.rs
+++ b/stackslib/src/net/mod.rs
@@ -1903,8 +1903,7 @@ pub mod test {
             _anchor_block_cost: &ExecutionCost,
             _confirmed_mblock_cost: &ExecutionCost,
             pox_constants: &PoxConstants,
-            reward_set: &Option<RewardSet>,
-            cycle_number: &Option<u64>,
+            reward_set_data: &Option<RewardSetData>,
         ) {
             self.blocks.lock().unwrap().push(TestEventObserverBlock {
                 block: block.clone(),

From 3c8d656b44890a92fb767e73ada3818dabc6db43 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Fri, 16 Feb 2024 21:46:07 -0500
Subject: [PATCH 0956/1166] chore: Remove imports already included by
 `std::prelude`

---
 clarity/src/libclarity.rs                                    | 1 -
 clarity/src/vm/analysis/type_checker/v2_05/mod.rs            | 1 -
 clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs    | 2 --
 .../src/vm/analysis/type_checker/v2_05/natives/sequences.rs  | 2 --
 clarity/src/vm/analysis/type_checker/v2_05/tests/assets.rs   | 2 --
 clarity/src/vm/analysis/type_checker/v2_05/tests/mod.rs      | 2 --
 clarity/src/vm/analysis/type_checker/v2_1/mod.rs             | 1 -
 clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs     | 2 --
 .../src/vm/analysis/type_checker/v2_1/natives/sequences.rs   | 2 --
 clarity/src/vm/analysis/type_checker/v2_1/tests/assets.rs    | 2 --
 clarity/src/vm/analysis/type_checker/v2_1/tests/contracts.rs | 1 -
 clarity/src/vm/analysis/type_checker/v2_1/tests/mod.rs       | 2 --
 clarity/src/vm/ast/definition_sorter/mod.rs                  | 2 --
 clarity/src/vm/ast/parser/v1.rs                              | 1 -
 clarity/src/vm/ast/parser/v2/mod.rs                          | 1 -
 clarity/src/vm/ast/sugar_expander/mod.rs                     | 2 --
 clarity/src/vm/callables.rs                                  | 2 --
 clarity/src/vm/contexts.rs                                   | 1 -
 clarity/src/vm/contracts.rs                                  | 2 --
 clarity/src/vm/costs/mod.rs                                  | 1 -
 clarity/src/vm/database/clarity_db.rs                        | 2 --
 clarity/src/vm/database/clarity_store.rs                     | 1 -
 clarity/src/vm/database/key_value_wrapper.rs                 | 2 --
 clarity/src/vm/database/structures.rs                        | 1 -
 clarity/src/vm/docs/contracts.rs                             | 1 -
 clarity/src/vm/functions/arithmetic.rs                       | 1 -
 clarity/src/vm/functions/assets.rs                           | 2 --
 clarity/src/vm/functions/conversions.rs                      | 2 --
 clarity/src/vm/functions/database.rs                         | 1 -
 clarity/src/vm/functions/principals.rs                       | 2 --
 clarity/src/vm/functions/sequences.rs                        | 1 -
 clarity/src/vm/mod.rs                                        | 1 -
 clarity/src/vm/representations.rs                            | 1 -
 clarity/src/vm/tests/conversions.rs                          | 4 +---
 clarity/src/vm/tests/datamaps.rs                             | 2 --
 clarity/src/vm/tests/sequences.rs                            | 2 --
 clarity/src/vm/tests/traits.rs                               | 2 --
 clarity/src/vm/types/mod.rs                                  | 1 -
 clarity/src/vm/types/serialization.rs                        | 2 --
 clarity/src/vm/types/signatures.rs                           | 1 -
 clarity/src/vm/variables.rs                                  | 1 -
 stacks-common/src/address/c32.rs                             | 2 --
 stacks-common/src/address/mod.rs                             | 1 -
 stacks-common/src/deps_common/bitcoin/blockdata/constants.rs | 3 ---
 stacks-common/src/deps_common/bitcoin/blockdata/script.rs    | 1 -
 .../src/deps_common/bitcoin/blockdata/transaction.rs         | 1 -
 .../src/deps_common/bitcoin/network/message_blockdata.rs     | 1 -
 stacks-common/src/deps_common/bitcoin/util/hash.rs           | 1 -
 stacks-common/src/types/mod.rs                               | 1 -
 stacks-common/src/util/hash.rs                               | 1 -
 stacks-common/src/util/vrf.rs                                | 3 +--
 stacks-signer/src/config.rs                                  | 1 -
 stackslib/src/blockstack_cli.rs                              | 1 -
 stackslib/src/burnchains/affirmation.rs                      | 1 -
 stackslib/src/burnchains/bitcoin/indexer.rs                  | 1 -
 stackslib/src/burnchains/burnchain.rs                        | 2 --
 stackslib/src/burnchains/mod.rs                              | 2 --
 stackslib/src/burnchains/tests/db.rs                         | 1 -
 stackslib/src/chainstate/burn/db/sortdb.rs                   | 3 +--
 stackslib/src/chainstate/burn/distribution.rs                | 1 -
 stackslib/src/chainstate/burn/mod.rs                         | 1 -
 stackslib/src/chainstate/burn/operations/mod.rs              | 1 -
 stackslib/src/chainstate/coordinator/mod.rs                  | 1 -
 stackslib/src/chainstate/stacks/address.rs                   | 2 +-
 stackslib/src/chainstate/stacks/boot/contract_tests.rs       | 1 -
 stackslib/src/chainstate/stacks/boot/docs.rs                 | 2 --
 stackslib/src/chainstate/stacks/boot/mod.rs                  | 5 +----
 stackslib/src/chainstate/stacks/boot/pox_2_tests.rs          | 1 -
 stackslib/src/chainstate/stacks/boot/pox_3_tests.rs          | 1 -
 stackslib/src/chainstate/stacks/boot/pox_4_tests.rs          | 1 -
 stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs | 1 -
 stackslib/src/chainstate/stacks/db/blocks.rs                 | 1 -
 stackslib/src/chainstate/stacks/db/transactions.rs           | 1 -
 stackslib/src/chainstate/stacks/index/cache.rs               | 2 --
 stackslib/src/chainstate/stacks/index/file.rs                | 2 --
 stackslib/src/chainstate/stacks/index/storage.rs             | 2 --
 stackslib/src/chainstate/stacks/index/trie_sql.rs            | 2 --
 stackslib/src/chainstate/stacks/miner.rs                     | 1 -
 stackslib/src/chainstate/stacks/mod.rs                       | 1 -
 stackslib/src/chainstate/stacks/transaction.rs               | 1 -
 stackslib/src/clarity_cli.rs                                 | 2 --
 stackslib/src/clarity_vm/clarity.rs                          | 1 -
 stackslib/src/core/mod.rs                                    | 4 +---
 stackslib/src/cost_estimates/fee_medians.rs                  | 2 --
 stackslib/src/cost_estimates/fee_scalar.rs                   | 2 --
 stackslib/src/cost_estimates/mod.rs                          | 1 -
 stackslib/src/cost_estimates/pessimistic.rs                  | 2 --
 stackslib/src/main.rs                                        | 1 -
 stackslib/src/monitoring/mod.rs                              | 1 -
 stackslib/src/net/api/mod.rs                                 | 2 --
 stackslib/src/net/atlas/db.rs                                | 1 -
 stackslib/src/net/atlas/mod.rs                               | 1 -
 stackslib/src/net/atlas/tests.rs                             | 1 -
 stackslib/src/net/chat.rs                                    | 1 -
 stackslib/src/net/codec.rs                                   | 1 -
 stackslib/src/net/connection.rs                              | 1 -
 stackslib/src/net/db.rs                                      | 1 -
 stackslib/src/net/download.rs                                | 2 --
 stackslib/src/net/http/request.rs                            | 1 -
 stackslib/src/net/inv/epoch2x.rs                             | 1 -
 stackslib/src/net/mod.rs                                     | 2 --
 stackslib/src/net/rpc.rs                                     | 1 -
 stackslib/src/util_lib/boot.rs                               | 2 --
 stackslib/src/util_lib/db.rs                                 | 1 -
 stackslib/src/util_lib/strings.rs                            | 1 -
 testnet/stacks-node/src/config.rs                            | 1 -
 testnet/stacks-node/src/main.rs                              | 1 -
 testnet/stacks-node/src/nakamoto_node/miner.rs               | 1 -
 testnet/stacks-node/src/nakamoto_node/peer.rs                | 1 -
 testnet/stacks-node/src/neon_node.rs                         | 2 --
 testnet/stacks-node/src/node.rs                              | 1 -
 testnet/stacks-node/src/tests/epoch_205.rs                   | 1 -
 testnet/stacks-node/src/tests/mempool.rs                     | 1 -
 testnet/stacks-node/src/tests/mod.rs                         | 1 -
 testnet/stacks-node/src/tests/neon_integrations.rs           | 1 -
 115 files changed, 6 insertions(+), 164 deletions(-)

diff --git a/clarity/src/libclarity.rs b/clarity/src/libclarity.rs
index 4540d15e8c..daae7dcfd7 100644
--- a/clarity/src/libclarity.rs
+++ b/clarity/src/libclarity.rs
@@ -51,7 +51,6 @@ pub use stacks_common::{
 pub mod vm;
 
 pub mod boot_util {
-    use std::convert::TryFrom;
 
     use stacks_common::types::chainstate::StacksAddress;
 
diff --git a/clarity/src/vm/analysis/type_checker/v2_05/mod.rs b/clarity/src/vm/analysis/type_checker/v2_05/mod.rs
index 7c6b587556..286e2e11fa 100644
--- a/clarity/src/vm/analysis/type_checker/v2_05/mod.rs
+++ b/clarity/src/vm/analysis/type_checker/v2_05/mod.rs
@@ -19,7 +19,6 @@ pub mod contexts;
 pub mod natives;
 
 use std::collections::BTreeMap;
-use std::convert::TryInto;
 
 use hashbrown::HashMap;
 use stacks_common::types::StacksEpochId;
diff --git a/clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs b/clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs
index 46830a8762..b38cfd0d11 100644
--- a/clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs
+++ b/clarity/src/vm/analysis/type_checker/v2_05/natives/mod.rs
@@ -14,8 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::convert::TryFrom;
-
 use stacks_common::types::StacksEpochId;
 
 use super::{
diff --git a/clarity/src/vm/analysis/type_checker/v2_05/natives/sequences.rs b/clarity/src/vm/analysis/type_checker/v2_05/natives/sequences.rs
index 81d52bb23d..bed885d147 100644
--- a/clarity/src/vm/analysis/type_checker/v2_05/natives/sequences.rs
+++ b/clarity/src/vm/analysis/type_checker/v2_05/natives/sequences.rs
@@ -14,8 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::convert::{TryFrom, TryInto};
-
 use stacks_common::types::StacksEpochId;
 
 use super::{SimpleNativeFunction, TypedNativeFunction};
diff --git a/clarity/src/vm/analysis/type_checker/v2_05/tests/assets.rs b/clarity/src/vm/analysis/type_checker/v2_05/tests/assets.rs
index 918e099671..df9c35ed0e 100644
--- a/clarity/src/vm/analysis/type_checker/v2_05/tests/assets.rs
+++ b/clarity/src/vm/analysis/type_checker/v2_05/tests/assets.rs
@@ -14,8 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::convert::TryInto;
-
 use stacks_common::types::StacksEpochId;
 
 use crate::vm::analysis::errors::CheckErrors;
diff --git a/clarity/src/vm/analysis/type_checker/v2_05/tests/mod.rs b/clarity/src/vm/analysis/type_checker/v2_05/tests/mod.rs
index 6529b859f5..1830caf7ce 100644
--- a/clarity/src/vm/analysis/type_checker/v2_05/tests/mod.rs
+++ b/clarity/src/vm/analysis/type_checker/v2_05/tests/mod.rs
@@ -14,8 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::convert::TryInto;
-
 use stacks_common::types::StacksEpochId;
 
 use crate::vm::analysis::errors::CheckErrors;
diff --git a/clarity/src/vm/analysis/type_checker/v2_1/mod.rs b/clarity/src/vm/analysis/type_checker/v2_1/mod.rs
index 44aab0b4f2..a0937e84c8 100644
--- a/clarity/src/vm/analysis/type_checker/v2_1/mod.rs
+++ b/clarity/src/vm/analysis/type_checker/v2_1/mod.rs
@@ -18,7 +18,6 @@ pub mod contexts;
 pub mod natives;
 
 use std::collections::BTreeMap;
-use std::convert::TryInto;
 
 use hashbrown::HashMap;
 use stacks_common::types::StacksEpochId;
diff --git a/clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs b/clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs
index 1c30eb7795..9fdc8c704c 100644
--- a/clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs
+++ b/clarity/src/vm/analysis/type_checker/v2_1/natives/mod.rs
@@ -14,8 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::convert::TryFrom;
-
 use stacks_common::types::StacksEpochId;
 
 use super::{
diff --git a/clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs b/clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs
index 52ceca66b6..090b259a26 100644
--- a/clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs
+++ b/clarity/src/vm/analysis/type_checker/v2_1/natives/sequences.rs
@@ -14,8 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::convert::{TryFrom, TryInto};
-
 use stacks_common::types::StacksEpochId;
 
 use super::{SimpleNativeFunction, TypedNativeFunction};
diff --git a/clarity/src/vm/analysis/type_checker/v2_1/tests/assets.rs b/clarity/src/vm/analysis/type_checker/v2_1/tests/assets.rs
index 8989fb295e..c870fdbab7 100644
--- a/clarity/src/vm/analysis/type_checker/v2_1/tests/assets.rs
+++ b/clarity/src/vm/analysis/type_checker/v2_1/tests/assets.rs
@@ -14,8 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::convert::TryInto;
-
 #[cfg(test)]
 use rstest::rstest;
 #[cfg(test)]
diff --git a/clarity/src/vm/analysis/type_checker/v2_1/tests/contracts.rs b/clarity/src/vm/analysis/type_checker/v2_1/tests/contracts.rs
index 25e0eb0548..2f023dcf4f 100644
--- a/clarity/src/vm/analysis/type_checker/v2_1/tests/contracts.rs
+++ b/clarity/src/vm/analysis/type_checker/v2_1/tests/contracts.rs
@@ -14,7 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::convert::TryFrom;
 use std::fs::read_to_string;
 
 use assert_json_diff::assert_json_eq;
diff --git a/clarity/src/vm/analysis/type_checker/v2_1/tests/mod.rs b/clarity/src/vm/analysis/type_checker/v2_1/tests/mod.rs
index d8733cfab8..85a6b39ea9 100644
--- a/clarity/src/vm/analysis/type_checker/v2_1/tests/mod.rs
+++ b/clarity/src/vm/analysis/type_checker/v2_1/tests/mod.rs
@@ -14,8 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::convert::{TryFrom, TryInto};
-
 #[cfg(test)]
 use rstest::rstest;
 #[cfg(test)]
diff --git a/clarity/src/vm/ast/definition_sorter/mod.rs b/clarity/src/vm/ast/definition_sorter/mod.rs
index a48bfd0e34..eee6625310 100644
--- a/clarity/src/vm/ast/definition_sorter/mod.rs
+++ b/clarity/src/vm/ast/definition_sorter/mod.rs
@@ -14,8 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::iter::FromIterator;
-
 use hashbrown::{HashMap, HashSet};
 
 use crate::vm::ast::errors::{ParseError, ParseErrors, ParseResult};
diff --git a/clarity/src/vm/ast/parser/v1.rs b/clarity/src/vm/ast/parser/v1.rs
index d4dbdcffc4..4cdea6e278 100644
--- a/clarity/src/vm/ast/parser/v1.rs
+++ b/clarity/src/vm/ast/parser/v1.rs
@@ -15,7 +15,6 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::cmp;
-use std::convert::TryInto;
 
 use lazy_static::lazy_static;
 use regex::{Captures, Regex};
diff --git a/clarity/src/vm/ast/parser/v2/mod.rs b/clarity/src/vm/ast/parser/v2/mod.rs
index 6238af1383..addbba1c59 100644
--- a/clarity/src/vm/ast/parser/v2/mod.rs
+++ b/clarity/src/vm/ast/parser/v2/mod.rs
@@ -1,6 +1,5 @@
 pub mod lexer;
 
-use std::convert::TryFrom;
 use std::num::ParseIntError;
 
 use stacks_common::util::hash::hex_bytes;
diff --git a/clarity/src/vm/ast/sugar_expander/mod.rs b/clarity/src/vm/ast/sugar_expander/mod.rs
index cf070548a8..7fc6064b85 100644
--- a/clarity/src/vm/ast/sugar_expander/mod.rs
+++ b/clarity/src/vm/ast/sugar_expander/mod.rs
@@ -14,8 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::convert::TryInto;
-
 use hashbrown::{HashMap, HashSet};
 
 use crate::vm::ast::errors::{ParseError, ParseErrors, ParseResult};
diff --git a/clarity/src/vm/callables.rs b/clarity/src/vm/callables.rs
index 597dbab358..32e7d05514 100644
--- a/clarity/src/vm/callables.rs
+++ b/clarity/src/vm/callables.rs
@@ -15,9 +15,7 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::collections::BTreeMap;
-use std::convert::TryInto;
 use std::fmt;
-use std::iter::FromIterator;
 
 use stacks_common::types::StacksEpochId;
 
diff --git a/clarity/src/vm/contexts.rs b/clarity/src/vm/contexts.rs
index 104adbab13..4b2d6c46d2 100644
--- a/clarity/src/vm/contexts.rs
+++ b/clarity/src/vm/contexts.rs
@@ -15,7 +15,6 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::collections::{BTreeMap, BTreeSet};
-use std::convert::TryInto;
 use std::fmt;
 use std::mem::replace;
 
diff --git a/clarity/src/vm/contracts.rs b/clarity/src/vm/contracts.rs
index 0019106ef1..1982665aee 100644
--- a/clarity/src/vm/contracts.rs
+++ b/clarity/src/vm/contracts.rs
@@ -14,8 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::convert::TryInto;
-
 use stacks_common::types::StacksEpochId;
 
 use crate::vm::ast::ContractAST;
diff --git a/clarity/src/vm/costs/mod.rs b/clarity/src/vm/costs/mod.rs
index 2222aa4c12..e0a664ac64 100644
--- a/clarity/src/vm/costs/mod.rs
+++ b/clarity/src/vm/costs/mod.rs
@@ -15,7 +15,6 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::collections::BTreeMap;
-use std::convert::{TryFrom, TryInto};
 use std::{cmp, fmt};
 
 use hashbrown::HashMap;
diff --git a/clarity/src/vm/database/clarity_db.rs b/clarity/src/vm/database/clarity_db.rs
index 5ef6c458d2..4388e88e58 100644
--- a/clarity/src/vm/database/clarity_db.rs
+++ b/clarity/src/vm/database/clarity_db.rs
@@ -14,8 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::convert::{TryFrom, TryInto};
-
 use serde_json;
 use stacks_common::address::AddressHashMode;
 use stacks_common::consts::{
diff --git a/clarity/src/vm/database/clarity_store.rs b/clarity/src/vm/database/clarity_store.rs
index f3d9d2bb09..f093c5a3c8 100644
--- a/clarity/src/vm/database/clarity_store.rs
+++ b/clarity/src/vm/database/clarity_store.rs
@@ -14,7 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::convert::TryInto;
 use std::path::PathBuf;
 
 use rusqlite::Connection;
diff --git a/clarity/src/vm/database/key_value_wrapper.rs b/clarity/src/vm/database/key_value_wrapper.rs
index bc4b85a9b0..65de1adce4 100644
--- a/clarity/src/vm/database/key_value_wrapper.rs
+++ b/clarity/src/vm/database/key_value_wrapper.rs
@@ -14,8 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::clone::Clone;
-use std::cmp::Eq;
 use std::hash::Hash;
 
 use hashbrown::HashMap;
diff --git a/clarity/src/vm/database/structures.rs b/clarity/src/vm/database/structures.rs
index 53c7fbd681..937eda2bdc 100644
--- a/clarity/src/vm/database/structures.rs
+++ b/clarity/src/vm/database/structures.rs
@@ -14,7 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::convert::TryInto;
 use std::io::Write;
 
 use serde::Deserialize;
diff --git a/clarity/src/vm/docs/contracts.rs b/clarity/src/vm/docs/contracts.rs
index 37d1452a1e..7426be7966 100644
--- a/clarity/src/vm/docs/contracts.rs
+++ b/clarity/src/vm/docs/contracts.rs
@@ -1,5 +1,4 @@
 use std::collections::BTreeMap;
-use std::iter::FromIterator;
 
 use hashbrown::{HashMap, HashSet};
 use stacks_common::consts::CHAIN_ID_TESTNET;
diff --git a/clarity/src/vm/functions/arithmetic.rs b/clarity/src/vm/functions/arithmetic.rs
index bd0edbf5eb..1d52ae4390 100644
--- a/clarity/src/vm/functions/arithmetic.rs
+++ b/clarity/src/vm/functions/arithmetic.rs
@@ -15,7 +15,6 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::cmp;
-use std::convert::TryFrom;
 
 use integer_sqrt::IntegerSquareRoot;
 
diff --git a/clarity/src/vm/functions/assets.rs b/clarity/src/vm/functions/assets.rs
index 3e926f2cc7..0d004a846a 100644
--- a/clarity/src/vm/functions/assets.rs
+++ b/clarity/src/vm/functions/assets.rs
@@ -14,8 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::convert::{TryFrom, TryInto};
-
 use stacks_common::types::StacksEpochId;
 
 use crate::vm::costs::cost_functions::ClarityCostFunction;
diff --git a/clarity/src/vm/functions/conversions.rs b/clarity/src/vm/functions/conversions.rs
index b788455f9c..090f0d2107 100644
--- a/clarity/src/vm/functions/conversions.rs
+++ b/clarity/src/vm/functions/conversions.rs
@@ -14,8 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::convert::TryFrom;
-
 use stacks_common::codec::StacksMessageCodec;
 use stacks_common::types::StacksEpochId;
 
diff --git a/clarity/src/vm/functions/database.rs b/clarity/src/vm/functions/database.rs
index e52ac57b54..b047faf682 100644
--- a/clarity/src/vm/functions/database.rs
+++ b/clarity/src/vm/functions/database.rs
@@ -15,7 +15,6 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::cmp;
-use std::convert::{TryFrom, TryInto};
 
 use stacks_common::types::chainstate::StacksBlockId;
 use stacks_common::types::StacksEpochId;
diff --git a/clarity/src/vm/functions/principals.rs b/clarity/src/vm/functions/principals.rs
index 426fa4f703..99246019da 100644
--- a/clarity/src/vm/functions/principals.rs
+++ b/clarity/src/vm/functions/principals.rs
@@ -1,5 +1,3 @@
-use std::convert::TryFrom;
-
 use stacks_common::address::{
     C32_ADDRESS_VERSION_MAINNET_MULTISIG, C32_ADDRESS_VERSION_MAINNET_SINGLESIG,
     C32_ADDRESS_VERSION_TESTNET_MULTISIG, C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
diff --git a/clarity/src/vm/functions/sequences.rs b/clarity/src/vm/functions/sequences.rs
index 029e62484a..60445f9632 100644
--- a/clarity/src/vm/functions/sequences.rs
+++ b/clarity/src/vm/functions/sequences.rs
@@ -15,7 +15,6 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::cmp;
-use std::convert::{TryFrom, TryInto};
 
 use stacks_common::types::StacksEpochId;
 
diff --git a/clarity/src/vm/mod.rs b/clarity/src/vm/mod.rs
index 45d71cf222..9d74fae5d7 100644
--- a/clarity/src/vm/mod.rs
+++ b/clarity/src/vm/mod.rs
@@ -50,7 +50,6 @@ pub mod test_util;
 pub mod clarity;
 
 use std::collections::BTreeMap;
-use std::convert::{TryFrom, TryInto};
 
 use serde_json;
 use stacks_common::types::StacksEpochId;
diff --git a/clarity/src/vm/representations.rs b/clarity/src/vm/representations.rs
index 580e9a51c2..15e674eb13 100644
--- a/clarity/src/vm/representations.rs
+++ b/clarity/src/vm/representations.rs
@@ -16,7 +16,6 @@
 
 use std::borrow::Borrow;
 use std::cmp::Ordering;
-use std::convert::TryFrom;
 use std::fmt;
 use std::io::{Read, Write};
 use std::ops::Deref;
diff --git a/clarity/src/vm/tests/conversions.rs b/clarity/src/vm/tests/conversions.rs
index 0d5e559758..dbe45eb724 100644
--- a/clarity/src/vm/tests/conversions.rs
+++ b/clarity/src/vm/tests/conversions.rs
@@ -15,15 +15,13 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 pub use crate::vm::analysis::errors::{CheckError, CheckErrors};
-use crate::vm::execute_v2;
 use crate::vm::types::SequenceSubtype::{BufferType, StringType};
 use crate::vm::types::StringSubtype::ASCII;
 use crate::vm::types::TypeSignature::SequenceType;
 use crate::vm::types::{
     ASCIIData, BuffData, BufferLength, CharType, SequenceData, TypeSignature, UTF8Data, Value,
 };
-use crate::vm::ClarityVersion;
-use std::convert::TryFrom;
+use crate::vm::{execute_v2, ClarityVersion};
 
 #[test]
 fn test_simple_buff_to_int_le() {
diff --git a/clarity/src/vm/tests/datamaps.rs b/clarity/src/vm/tests/datamaps.rs
index 87f5dbcf30..828de608e7 100644
--- a/clarity/src/vm/tests/datamaps.rs
+++ b/clarity/src/vm/tests/datamaps.rs
@@ -14,8 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::convert::{From, TryFrom};
-
 use crate::vm::errors::{CheckErrors, Error, ShortReturnType};
 use crate::vm::types::{
     ListData, SequenceData, TupleData, TupleTypeSignature, TypeSignature, Value,
diff --git a/clarity/src/vm/tests/sequences.rs b/clarity/src/vm/tests/sequences.rs
index 51de0e4023..e252f917ee 100644
--- a/clarity/src/vm/tests/sequences.rs
+++ b/clarity/src/vm/tests/sequences.rs
@@ -14,8 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::convert::{TryFrom, TryInto};
-
 use rstest::rstest;
 use rstest_reuse::{self, *};
 use stacks_common::types::StacksEpochId;
diff --git a/clarity/src/vm/tests/traits.rs b/clarity/src/vm/tests/traits.rs
index 250ebc3412..97c4292b0d 100644
--- a/clarity/src/vm/tests/traits.rs
+++ b/clarity/src/vm/tests/traits.rs
@@ -14,8 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::convert::TryInto;
-
 use stacks_common::types::StacksEpochId;
 
 use super::MemoryEnvironmentGenerator;
diff --git a/clarity/src/vm/types/mod.rs b/clarity/src/vm/types/mod.rs
index cc3cbeeba0..1c25e1c380 100644
--- a/clarity/src/vm/types/mod.rs
+++ b/clarity/src/vm/types/mod.rs
@@ -20,7 +20,6 @@ pub mod serialization;
 pub mod signatures;
 
 use std::collections::BTreeMap;
-use std::convert::{TryFrom, TryInto};
 use std::{char, cmp, fmt, str};
 
 use regex::Regex;
diff --git a/clarity/src/vm/types/serialization.rs b/clarity/src/vm/types/serialization.rs
index 69a662e6b7..c7a92203b4 100644
--- a/clarity/src/vm/types/serialization.rs
+++ b/clarity/src/vm/types/serialization.rs
@@ -14,8 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::borrow::Borrow;
-use std::convert::{TryFrom, TryInto};
 use std::io::{Read, Write};
 use std::{cmp, error, fmt, str};
 
diff --git a/clarity/src/vm/types/signatures.rs b/clarity/src/vm/types/signatures.rs
index c6838eb3fb..29445d2499 100644
--- a/clarity/src/vm/types/signatures.rs
+++ b/clarity/src/vm/types/signatures.rs
@@ -16,7 +16,6 @@
 
 use std::collections::btree_map::Entry;
 use std::collections::BTreeMap;
-use std::convert::{TryFrom, TryInto};
 use std::hash::{Hash, Hasher};
 use std::{cmp, fmt};
 
diff --git a/clarity/src/vm/variables.rs b/clarity/src/vm/variables.rs
index 66de0f3b6e..539e14c39e 100644
--- a/clarity/src/vm/variables.rs
+++ b/clarity/src/vm/variables.rs
@@ -13,7 +13,6 @@
 //
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
-use std::convert::TryFrom;
 
 use super::errors::InterpreterError;
 use crate::vm::contexts::{Environment, LocalContext};
diff --git a/stacks-common/src/address/c32.rs b/stacks-common/src/address/c32.rs
index 67a0504b33..a8c26632f8 100644
--- a/stacks-common/src/address/c32.rs
+++ b/stacks-common/src/address/c32.rs
@@ -14,8 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::convert::TryFrom;
-
 use sha2::{Digest, Sha256};
 
 use super::Error;
diff --git a/stacks-common/src/address/mod.rs b/stacks-common/src/address/mod.rs
index b4bcb936c9..381456f661 100644
--- a/stacks-common/src/address/mod.rs
+++ b/stacks-common/src/address/mod.rs
@@ -14,7 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::convert::TryFrom;
 use std::{error, fmt};
 
 use sha2::{Digest, Sha256};
diff --git a/stacks-common/src/deps_common/bitcoin/blockdata/constants.rs b/stacks-common/src/deps_common/bitcoin/blockdata/constants.rs
index 4a9cfddef7..7d3c7d1b4f 100644
--- a/stacks-common/src/deps_common/bitcoin/blockdata/constants.rs
+++ b/stacks-common/src/deps_common/bitcoin/blockdata/constants.rs
@@ -19,8 +19,6 @@
 //! single transaction
 //!
 
-use std::default::Default;
-
 use crate::deps_common::bitcoin::blockdata::block::{Block, BlockHeader};
 use crate::deps_common::bitcoin::blockdata::transaction::{OutPoint, Transaction, TxIn, TxOut};
 use crate::deps_common::bitcoin::blockdata::{opcodes, script};
@@ -139,7 +137,6 @@ pub fn genesis_block(network: Network) -> Block {
 
 #[cfg(test)]
 mod test {
-    use std::default::Default;
 
     use crate::deps_common::bitcoin::blockdata::constants::{
         bitcoin_genesis_tx, genesis_block, COIN_VALUE, MAX_SEQUENCE,
diff --git a/stacks-common/src/deps_common/bitcoin/blockdata/script.rs b/stacks-common/src/deps_common/bitcoin/blockdata/script.rs
index f055316f25..8b08ab998a 100644
--- a/stacks-common/src/deps_common/bitcoin/blockdata/script.rs
+++ b/stacks-common/src/deps_common/bitcoin/blockdata/script.rs
@@ -24,7 +24,6 @@
 //! This module provides the structures and functions needed to support scripts.
 //!
 
-use std::default::Default;
 use std::mem::size_of;
 use std::{error, fmt};
 
diff --git a/stacks-common/src/deps_common/bitcoin/blockdata/transaction.rs b/stacks-common/src/deps_common/bitcoin/blockdata/transaction.rs
index f92a11cd1b..1ece07c511 100644
--- a/stacks-common/src/deps_common/bitcoin/blockdata/transaction.rs
+++ b/stacks-common/src/deps_common/bitcoin/blockdata/transaction.rs
@@ -23,7 +23,6 @@
 //! This module provides the structures and functions needed to support transactions.
 //!
 
-use std::default::Default;
 use std::fmt;
 use std::io::Write;
 
diff --git a/stacks-common/src/deps_common/bitcoin/network/message_blockdata.rs b/stacks-common/src/deps_common/bitcoin/network/message_blockdata.rs
index 099acca559..419b405a17 100644
--- a/stacks-common/src/deps_common/bitcoin/network/message_blockdata.rs
+++ b/stacks-common/src/deps_common/bitcoin/network/message_blockdata.rs
@@ -135,7 +135,6 @@ impl<D: SimpleDecoder> ConsensusDecodable<D> for Inventory {
 
 #[cfg(test)]
 mod tests {
-    use std::default::Default;
 
     use super::{GetBlocksMessage, GetHeadersMessage};
     use crate::deps_common::bitcoin::network::serialize::{deserialize, serialize};
diff --git a/stacks-common/src/deps_common/bitcoin/util/hash.rs b/stacks-common/src/deps_common/bitcoin/util/hash.rs
index 364b5f609b..3e9186bd92 100644
--- a/stacks-common/src/deps_common/bitcoin/util/hash.rs
+++ b/stacks-common/src/deps_common/bitcoin/util/hash.rs
@@ -17,7 +17,6 @@
 
 use std::char::from_digit;
 use std::cmp::min;
-use std::default::Default;
 use std::io::{Cursor, Write};
 use std::{error, fmt, mem};
 
diff --git a/stacks-common/src/types/mod.rs b/stacks-common/src/types/mod.rs
index 998edda48e..cf5603dba9 100644
--- a/stacks-common/src/types/mod.rs
+++ b/stacks-common/src/types/mod.rs
@@ -1,5 +1,4 @@
 use std::cmp::Ordering;
-use std::convert::TryFrom;
 use std::fmt;
 
 use crate::address::c32::{c32_address, c32_address_decode};
diff --git a/stacks-common/src/util/hash.rs b/stacks-common/src/util/hash.rs
index 634cbf485b..a5e4341b60 100644
--- a/stacks-common/src/util/hash.rs
+++ b/stacks-common/src/util/hash.rs
@@ -15,7 +15,6 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::char::from_digit;
-use std::convert::TryInto;
 use std::fmt::Write;
 use std::{fmt, mem};
 
diff --git a/stacks-common/src/util/vrf.rs b/stacks-common/src/util/vrf.rs
index 410c4a07e2..ddfdedfaa8 100644
--- a/stacks-common/src/util/vrf.rs
+++ b/stacks-common/src/util/vrf.rs
@@ -17,8 +17,7 @@
 #![allow(non_camel_case_types)]
 #![allow(non_snake_case)]
 
-use std::clone::Clone;
-use std::cmp::{Eq, Ord, Ordering, PartialEq};
+use std::cmp::Ordering;
 use std::fmt::Debug;
 use std::hash::{Hash, Hasher};
 /// This codebase is based on routines defined in the IETF draft for verifiable random functions
diff --git a/stacks-signer/src/config.rs b/stacks-signer/src/config.rs
index df9e2db404..bb09d3262d 100644
--- a/stacks-signer/src/config.rs
+++ b/stacks-signer/src/config.rs
@@ -14,7 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::convert::TryFrom;
 use std::fs;
 use std::net::{SocketAddr, ToSocketAddrs};
 use std::path::PathBuf;
diff --git a/stackslib/src/blockstack_cli.rs b/stackslib/src/blockstack_cli.rs
index d708383f14..6fb9f45ed6 100644
--- a/stackslib/src/blockstack_cli.rs
+++ b/stackslib/src/blockstack_cli.rs
@@ -23,7 +23,6 @@ extern crate blockstack_lib;
 extern crate clarity;
 extern crate stacks_common;
 
-use std::convert::TryFrom;
 use std::io::prelude::*;
 use std::io::Read;
 use std::{env, fs, io};
diff --git a/stackslib/src/burnchains/affirmation.rs b/stackslib/src/burnchains/affirmation.rs
index bfe59ed274..1eb4874e42 100644
--- a/stackslib/src/burnchains/affirmation.rs
+++ b/stackslib/src/burnchains/affirmation.rs
@@ -232,7 +232,6 @@
 ///
 use std::cmp;
 use std::collections::{BTreeMap, HashMap, HashSet, VecDeque};
-use std::convert::{TryFrom, TryInto};
 use std::fmt;
 use std::fmt::Write;
 use std::sync::mpsc::SyncSender;
diff --git a/stackslib/src/burnchains/bitcoin/indexer.rs b/stackslib/src/burnchains/bitcoin/indexer.rs
index 2d3e981e27..51de78a53f 100644
--- a/stackslib/src/burnchains/bitcoin/indexer.rs
+++ b/stackslib/src/burnchains/bitcoin/indexer.rs
@@ -14,7 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::convert::TryFrom;
 use std::net::Shutdown;
 use std::ops::{Deref, DerefMut};
 use std::path::PathBuf;
diff --git a/stackslib/src/burnchains/burnchain.rs b/stackslib/src/burnchains/burnchain.rs
index d5f33a5ea7..e3947bd5a8 100644
--- a/stackslib/src/burnchains/burnchain.rs
+++ b/stackslib/src/burnchains/burnchain.rs
@@ -15,8 +15,6 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::collections::{HashMap, HashSet};
-use std::convert::TryFrom;
-use std::marker::Send;
 use std::path::PathBuf;
 use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
 use std::sync::mpsc::sync_channel;
diff --git a/stackslib/src/burnchains/mod.rs b/stackslib/src/burnchains/mod.rs
index 8734d605d8..c6e4204542 100644
--- a/stackslib/src/burnchains/mod.rs
+++ b/stackslib/src/burnchains/mod.rs
@@ -15,8 +15,6 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::collections::HashMap;
-use std::convert::TryFrom;
-use std::default::Default;
 use std::marker::PhantomData;
 use std::{error, fmt, io};
 
diff --git a/stackslib/src/burnchains/tests/db.rs b/stackslib/src/burnchains/tests/db.rs
index 13db19bcf7..7b2a87be4c 100644
--- a/stackslib/src/burnchains/tests/db.rs
+++ b/stackslib/src/burnchains/tests/db.rs
@@ -15,7 +15,6 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::cmp;
-use std::convert::TryInto;
 
 use stacks_common::address::AddressHashMode;
 use stacks_common::deps_common::bitcoin::blockdata::transaction::Transaction as BtcTx;
diff --git a/stackslib/src/chainstate/burn/db/sortdb.rs b/stackslib/src/chainstate/burn/db/sortdb.rs
index 86dffd5723..d027f6ffd9 100644
--- a/stackslib/src/chainstate/burn/db/sortdb.rs
+++ b/stackslib/src/chainstate/burn/db/sortdb.rs
@@ -14,9 +14,8 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::cmp::{Ord, Ordering};
+use std::cmp::Ordering;
 use std::collections::{HashMap, HashSet};
-use std::convert::{From, TryFrom, TryInto};
 use std::io::{ErrorKind, Write};
 use std::ops::{Deref, DerefMut};
 use std::str::FromStr;
diff --git a/stackslib/src/chainstate/burn/distribution.rs b/stackslib/src/chainstate/burn/distribution.rs
index b9685a9a99..2a16897100 100644
--- a/stackslib/src/chainstate/burn/distribution.rs
+++ b/stackslib/src/chainstate/burn/distribution.rs
@@ -16,7 +16,6 @@
 
 use std::cmp;
 use std::collections::{BTreeMap, HashMap};
-use std::convert::TryInto;
 
 use stacks_common::address::AddressHashMode;
 use stacks_common::util::hash::Hash160;
diff --git a/stackslib/src/chainstate/burn/mod.rs b/stackslib/src/chainstate/burn/mod.rs
index 8031762355..13f290d93b 100644
--- a/stackslib/src/chainstate/burn/mod.rs
+++ b/stackslib/src/chainstate/burn/mod.rs
@@ -14,7 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::convert::TryInto;
 use std::fmt;
 use std::io::Write;
 
diff --git a/stackslib/src/chainstate/burn/operations/mod.rs b/stackslib/src/chainstate/burn/operations/mod.rs
index e7c48cb1cb..e51a20f630 100644
--- a/stackslib/src/chainstate/burn/operations/mod.rs
+++ b/stackslib/src/chainstate/burn/operations/mod.rs
@@ -14,7 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::convert::{From, TryInto};
 use std::{error, fmt, fs, io};
 
 use clarity::vm::types::PrincipalData;
diff --git a/stackslib/src/chainstate/coordinator/mod.rs b/stackslib/src/chainstate/coordinator/mod.rs
index 6211c74d97..324d42f483 100644
--- a/stackslib/src/chainstate/coordinator/mod.rs
+++ b/stackslib/src/chainstate/coordinator/mod.rs
@@ -15,7 +15,6 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::collections::{BTreeMap, HashMap, HashSet, VecDeque};
-use std::convert::{TryFrom, TryInto};
 use std::path::PathBuf;
 use std::sync::atomic::AtomicBool;
 use std::sync::mpsc::SyncSender;
diff --git a/stackslib/src/chainstate/stacks/address.rs b/stackslib/src/chainstate/stacks/address.rs
index e11730bca2..c3706a2565 100644
--- a/stackslib/src/chainstate/stacks/address.rs
+++ b/stackslib/src/chainstate/stacks/address.rs
@@ -14,7 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::cmp::{Ord, Ordering};
+use std::cmp::Ordering;
 use std::io::prelude::*;
 use std::io::{Read, Write};
 use std::{fmt, io};
diff --git a/stackslib/src/chainstate/stacks/boot/contract_tests.rs b/stackslib/src/chainstate/stacks/boot/contract_tests.rs
index ce12011c73..23f2c92008 100644
--- a/stackslib/src/chainstate/stacks/boot/contract_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/contract_tests.rs
@@ -1,5 +1,4 @@
 use std::collections::{HashMap, VecDeque};
-use std::convert::{TryFrom, TryInto};
 
 use clarity::vm::analysis::arithmetic_checker::ArithmeticOnlyChecker;
 use clarity::vm::analysis::mem_type_check;
diff --git a/stackslib/src/chainstate/stacks/boot/docs.rs b/stackslib/src/chainstate/stacks/boot/docs.rs
index 08a203122a..62580f384a 100644
--- a/stackslib/src/chainstate/stacks/boot/docs.rs
+++ b/stackslib/src/chainstate/stacks/boot/docs.rs
@@ -1,5 +1,3 @@
-use std::iter::FromIterator;
-
 use clarity::vm::docs::contracts::{produce_docs_refs, ContractSupportDocs};
 use hashbrown::{HashMap, HashSet};
 
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 7d6d141e10..abba9be6c7 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -14,10 +14,8 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::boxed::Box;
 use std::cmp;
-use std::collections::{BTreeMap, HashMap};
-use std::convert::{TryFrom, TryInto};
+use std::collections::BTreeMap;
 
 use clarity::vm::analysis::CheckErrors;
 use clarity::vm::ast::ASTRules;
@@ -1326,7 +1324,6 @@ pub mod signers_voting_tests;
 #[cfg(test)]
 pub mod test {
     use std::collections::{HashMap, HashSet};
-    use std::convert::From;
     use std::fs;
 
     use clarity::boot_util::boot_code_addr;
diff --git a/stackslib/src/chainstate/stacks/boot/pox_2_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_2_tests.rs
index 119d4e4186..07d34a04cc 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_2_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_2_tests.rs
@@ -15,7 +15,6 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::collections::{HashMap, HashSet, VecDeque};
-use std::convert::{TryFrom, TryInto};
 
 use clarity::vm::clarity::ClarityConnection;
 use clarity::vm::contexts::OwnedEnvironment;
diff --git a/stackslib/src/chainstate/stacks/boot/pox_3_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_3_tests.rs
index 65aedb1302..f0c7a9ef75 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_3_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_3_tests.rs
@@ -15,7 +15,6 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::collections::{HashMap, HashSet, VecDeque};
-use std::convert::{TryFrom, TryInto};
 
 use clarity::vm::clarity::ClarityConnection;
 use clarity::vm::contexts::OwnedEnvironment;
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index d9857c55d6..ebb8c5f078 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -15,7 +15,6 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::collections::{HashMap, HashSet, VecDeque};
-use std::convert::{TryFrom, TryInto};
 
 use clarity::vm::clarity::ClarityConnection;
 use clarity::vm::contexts::OwnedEnvironment;
diff --git a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
index cc7226e6ef..5ac7d461c2 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
@@ -15,7 +15,6 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::collections::{HashMap, HashSet, VecDeque};
-use std::convert::{TryFrom, TryInto};
 
 use clarity::boot_util::boot_code_addr;
 use clarity::vm::clarity::ClarityConnection;
diff --git a/stackslib/src/chainstate/stacks/db/blocks.rs b/stackslib/src/chainstate/stacks/db/blocks.rs
index 77fc754a65..708f3a6a0d 100644
--- a/stackslib/src/chainstate/stacks/db/blocks.rs
+++ b/stackslib/src/chainstate/stacks/db/blocks.rs
@@ -15,7 +15,6 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::collections::{HashMap, HashSet};
-use std::convert::From;
 use std::io::prelude::*;
 use std::io::{Read, Seek, SeekFrom, Write};
 use std::path::{Path, PathBuf};
diff --git a/stackslib/src/chainstate/stacks/db/transactions.rs b/stackslib/src/chainstate/stacks/db/transactions.rs
index b0822b817c..9297252d15 100644
--- a/stackslib/src/chainstate/stacks/db/transactions.rs
+++ b/stackslib/src/chainstate/stacks/db/transactions.rs
@@ -15,7 +15,6 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::collections::{HashMap, HashSet};
-use std::convert::{TryFrom, TryInto};
 use std::io::prelude::*;
 use std::io::{Read, Write};
 use std::path::{Path, PathBuf};
diff --git a/stackslib/src/chainstate/stacks/index/cache.rs b/stackslib/src/chainstate/stacks/index/cache.rs
index 3763f15c6b..a711603447 100644
--- a/stackslib/src/chainstate/stacks/index/cache.rs
+++ b/stackslib/src/chainstate/stacks/index/cache.rs
@@ -16,10 +16,8 @@
 
 use std::char::from_digit;
 use std::collections::{HashMap, HashSet, VecDeque};
-use std::convert::{TryFrom, TryInto};
 use std::hash::{Hash, Hasher};
 use std::io::{BufWriter, Cursor, Read, Seek, SeekFrom, Write};
-use std::iter::FromIterator;
 use std::marker::PhantomData;
 use std::ops::{Deref, DerefMut};
 use std::path::{Path, PathBuf};
diff --git a/stackslib/src/chainstate/stacks/index/file.rs b/stackslib/src/chainstate/stacks/index/file.rs
index 99df760167..1477f9a7dd 100644
--- a/stackslib/src/chainstate/stacks/index/file.rs
+++ b/stackslib/src/chainstate/stacks/index/file.rs
@@ -16,11 +16,9 @@
 
 use std::char::from_digit;
 use std::collections::{HashMap, HashSet, VecDeque};
-use std::convert::{TryFrom, TryInto};
 use std::fs::OpenOptions;
 use std::hash::{Hash, Hasher};
 use std::io::{BufWriter, Cursor, Read, Seek, SeekFrom, Write};
-use std::iter::FromIterator;
 use std::marker::PhantomData;
 use std::ops::{Deref, DerefMut};
 use std::path::{Path, PathBuf};
diff --git a/stackslib/src/chainstate/stacks/index/storage.rs b/stackslib/src/chainstate/stacks/index/storage.rs
index c39976419e..97f7ca999a 100644
--- a/stackslib/src/chainstate/stacks/index/storage.rs
+++ b/stackslib/src/chainstate/stacks/index/storage.rs
@@ -16,10 +16,8 @@
 
 use std::char::from_digit;
 use std::collections::{HashMap, HashSet, VecDeque};
-use std::convert::{TryFrom, TryInto};
 use std::hash::{Hash, Hasher};
 use std::io::{BufWriter, Cursor, Read, Seek, SeekFrom, Write};
-use std::iter::FromIterator;
 use std::marker::PhantomData;
 use std::ops::{Deref, DerefMut};
 use std::path::{Path, PathBuf};
diff --git a/stackslib/src/chainstate/stacks/index/trie_sql.rs b/stackslib/src/chainstate/stacks/index/trie_sql.rs
index d538ed7e50..be1ae91c21 100644
--- a/stackslib/src/chainstate/stacks/index/trie_sql.rs
+++ b/stackslib/src/chainstate/stacks/index/trie_sql.rs
@@ -19,9 +19,7 @@
 
 use std::char::from_digit;
 use std::collections::{HashMap, HashSet, VecDeque};
-use std::convert::{TryFrom, TryInto};
 use std::io::{BufWriter, Cursor, Read, Seek, SeekFrom, Write};
-use std::iter::FromIterator;
 use std::marker::PhantomData;
 use std::ops::{Deref, DerefMut};
 use std::path::{Path, PathBuf};
diff --git a/stackslib/src/chainstate/stacks/miner.rs b/stackslib/src/chainstate/stacks/miner.rs
index b4dbcc5541..c04b03dcda 100644
--- a/stackslib/src/chainstate/stacks/miner.rs
+++ b/stackslib/src/chainstate/stacks/miner.rs
@@ -15,7 +15,6 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::collections::{HashMap, HashSet};
-use std::convert::From;
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Mutex};
 use std::thread::ThreadId;
diff --git a/stackslib/src/chainstate/stacks/mod.rs b/stackslib/src/chainstate/stacks/mod.rs
index bb68fb90bc..7247a28f7e 100644
--- a/stackslib/src/chainstate/stacks/mod.rs
+++ b/stackslib/src/chainstate/stacks/mod.rs
@@ -14,7 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::convert::{From, TryFrom};
 use std::io::prelude::*;
 use std::io::{Read, Write};
 use std::ops::{Deref, DerefMut};
diff --git a/stackslib/src/chainstate/stacks/transaction.rs b/stackslib/src/chainstate/stacks/transaction.rs
index 0c764ec83b..4ede285e41 100644
--- a/stackslib/src/chainstate/stacks/transaction.rs
+++ b/stackslib/src/chainstate/stacks/transaction.rs
@@ -14,7 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::convert::TryFrom;
 use std::io;
 use std::io::prelude::*;
 use std::io::{Read, Write};
diff --git a/stackslib/src/clarity_cli.rs b/stackslib/src/clarity_cli.rs
index 426b45bc8a..00a067408e 100644
--- a/stackslib/src/clarity_cli.rs
+++ b/stackslib/src/clarity_cli.rs
@@ -14,10 +14,8 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::convert::{TryFrom, TryInto};
 use std::ffi::OsStr;
 use std::io::{Read, Write};
-use std::iter::Iterator;
 use std::path::PathBuf;
 use std::str::FromStr;
 use std::{env, fs, io, process};
diff --git a/stackslib/src/clarity_vm/clarity.rs b/stackslib/src/clarity_vm/clarity.rs
index 8351412119..81a421cdef 100644
--- a/stackslib/src/clarity_vm/clarity.rs
+++ b/stackslib/src/clarity_vm/clarity.rs
@@ -14,7 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::convert::TryFrom;
 use std::{error, fmt, thread};
 
 use clarity::vm::analysis::errors::{CheckError, CheckErrors};
diff --git a/stackslib/src/core/mod.rs b/stackslib/src/core/mod.rs
index 2280fe6d71..45556adf7a 100644
--- a/stackslib/src/core/mod.rs
+++ b/stackslib/src/core/mod.rs
@@ -15,7 +15,6 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::collections::HashSet;
-use std::convert::TryFrom;
 
 use clarity::vm::costs::ExecutionCost;
 use lazy_static::lazy_static;
@@ -34,8 +33,7 @@ pub mod mempool;
 #[cfg(test)]
 pub mod tests;
 
-use std::cmp::{Ord, Ordering, PartialOrd};
-
+use std::cmp::Ordering;
 pub type StacksEpoch = GenericStacksEpoch<ExecutionCost>;
 
 // fork set identifier -- to be mixed with the consensus hash (encodes the version)
diff --git a/stackslib/src/cost_estimates/fee_medians.rs b/stackslib/src/cost_estimates/fee_medians.rs
index f3a7282a17..88ab0e9c2a 100644
--- a/stackslib/src/cost_estimates/fee_medians.rs
+++ b/stackslib/src/cost_estimates/fee_medians.rs
@@ -1,7 +1,5 @@
 use std::cmp;
 use std::cmp::Ordering;
-use std::convert::TryFrom;
-use std::iter::FromIterator;
 use std::path::Path;
 
 use clarity::vm::costs::ExecutionCost;
diff --git a/stackslib/src/cost_estimates/fee_scalar.rs b/stackslib/src/cost_estimates/fee_scalar.rs
index 895d47ed8f..1c0349e42b 100644
--- a/stackslib/src/cost_estimates/fee_scalar.rs
+++ b/stackslib/src/cost_estimates/fee_scalar.rs
@@ -1,6 +1,4 @@
 use std::cmp;
-use std::convert::TryFrom;
-use std::iter::FromIterator;
 use std::path::Path;
 
 use clarity::vm::costs::ExecutionCost;
diff --git a/stackslib/src/cost_estimates/mod.rs b/stackslib/src/cost_estimates/mod.rs
index 1d799607c1..fc4aa5b1b2 100644
--- a/stackslib/src/cost_estimates/mod.rs
+++ b/stackslib/src/cost_estimates/mod.rs
@@ -2,7 +2,6 @@ use std::cmp;
 use std::collections::HashMap;
 use std::error::Error;
 use std::fmt::Display;
-use std::iter::FromIterator;
 use std::ops::{Add, Div, Mul, Rem, Sub};
 use std::path::Path;
 
diff --git a/stackslib/src/cost_estimates/pessimistic.rs b/stackslib/src/cost_estimates/pessimistic.rs
index 7e222f5de6..b986d54dc7 100644
--- a/stackslib/src/cost_estimates/pessimistic.rs
+++ b/stackslib/src/cost_estimates/pessimistic.rs
@@ -1,6 +1,4 @@
 use std::cmp;
-use std::convert::TryFrom;
-use std::iter::FromIterator;
 use std::path::Path;
 
 use clarity::vm::costs::ExecutionCost;
diff --git a/stackslib/src/main.rs b/stackslib/src/main.rs
index 652d9bf2dc..3d9029281f 100644
--- a/stackslib/src/main.rs
+++ b/stackslib/src/main.rs
@@ -34,7 +34,6 @@ use tikv_jemallocator::Jemalloc;
 static GLOBAL: Jemalloc = Jemalloc;
 
 use std::collections::{HashMap, HashSet};
-use std::convert::TryFrom;
 use std::fs::{File, OpenOptions};
 use std::io::prelude::*;
 use std::io::BufReader;
diff --git a/stackslib/src/monitoring/mod.rs b/stackslib/src/monitoring/mod.rs
index ff718ba30c..302ff4d0d1 100644
--- a/stackslib/src/monitoring/mod.rs
+++ b/stackslib/src/monitoring/mod.rs
@@ -14,7 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::convert::TryInto;
 use std::error::Error;
 use std::path::PathBuf;
 use std::sync::atomic::{AtomicUsize, Ordering};
diff --git a/stackslib/src/net/api/mod.rs b/stackslib/src/net/api/mod.rs
index 4b45c9f4e0..b6fb21fc2a 100644
--- a/stackslib/src/net/api/mod.rs
+++ b/stackslib/src/net/api/mod.rs
@@ -14,8 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::convert::From;
-
 use clarity::vm::costs::ExecutionCost;
 use stacks_common::codec::read_next;
 use stacks_common::types::chainstate::{BlockHeaderHash, StacksBlockId};
diff --git a/stackslib/src/net/atlas/db.rs b/stackslib/src/net/atlas/db.rs
index 10f48a6114..784bff9639 100644
--- a/stackslib/src/net/atlas/db.rs
+++ b/stackslib/src/net/atlas/db.rs
@@ -34,7 +34,6 @@
 //!
 
 use std::collections::HashSet;
-use std::convert::{From, TryFrom};
 use std::fs;
 
 use clarity::vm::types::QualifiedContractIdentifier;
diff --git a/stackslib/src/net/atlas/mod.rs b/stackslib/src/net/atlas/mod.rs
index ffeb569f95..45100d984b 100644
--- a/stackslib/src/net/atlas/mod.rs
+++ b/stackslib/src/net/atlas/mod.rs
@@ -15,7 +15,6 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::collections::{HashMap, HashSet};
-use std::convert::TryFrom;
 use std::hash::{Hash, Hasher};
 
 use clarity::vm::types::{QualifiedContractIdentifier, SequenceData, TupleData, Value};
diff --git a/stackslib/src/net/atlas/tests.rs b/stackslib/src/net/atlas/tests.rs
index 567d49fe61..2ebcb71316 100644
--- a/stackslib/src/net/atlas/tests.rs
+++ b/stackslib/src/net/atlas/tests.rs
@@ -15,7 +15,6 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::collections::{BinaryHeap, HashMap, HashSet};
-use std::convert::TryFrom;
 use std::{thread, time};
 
 use clarity::vm::types::QualifiedContractIdentifier;
diff --git a/stackslib/src/net/chat.rs b/stackslib/src/net/chat.rs
index c547eb5af5..1b54241197 100644
--- a/stackslib/src/net/chat.rs
+++ b/stackslib/src/net/chat.rs
@@ -15,7 +15,6 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::collections::{HashMap, HashSet, VecDeque};
-use std::convert::TryFrom;
 use std::io::{Read, Write};
 use std::net::SocketAddr;
 use std::{cmp, mem};
diff --git a/stackslib/src/net/codec.rs b/stackslib/src/net/codec.rs
index e4ba530f2e..c0496aa14c 100644
--- a/stackslib/src/net/codec.rs
+++ b/stackslib/src/net/codec.rs
@@ -15,7 +15,6 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::collections::HashSet;
-use std::convert::TryFrom;
 use std::io::prelude::*;
 use std::io::Read;
 use std::{io, mem};
diff --git a/stackslib/src/net/connection.rs b/stackslib/src/net/connection.rs
index 44559fca5c..25d3ee7489 100644
--- a/stackslib/src/net/connection.rs
+++ b/stackslib/src/net/connection.rs
@@ -15,7 +15,6 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::collections::VecDeque;
-use std::convert::TryFrom;
 use std::io::{Read, Write};
 use std::ops::{Deref, DerefMut};
 use std::sync::mpsc::{
diff --git a/stackslib/src/net/db.rs b/stackslib/src/net/db.rs
index 46707cbdbf..1c116a6174 100644
--- a/stackslib/src/net/db.rs
+++ b/stackslib/src/net/db.rs
@@ -15,7 +15,6 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::collections::HashSet;
-use std::convert::{From, TryFrom};
 use std::{fmt, fs};
 
 use clarity::vm::types::{
diff --git a/stackslib/src/net/download.rs b/stackslib/src/net/download.rs
index d44efef4a1..f19d6f47d0 100644
--- a/stackslib/src/net/download.rs
+++ b/stackslib/src/net/download.rs
@@ -15,7 +15,6 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::collections::{HashMap, HashSet, VecDeque};
-use std::convert::TryFrom;
 use std::hash::{Hash, Hasher};
 use std::io::{Read, Write};
 use std::net::{IpAddr, SocketAddr};
@@ -2507,7 +2506,6 @@ impl PeerNetwork {
 #[cfg(test)]
 pub mod test {
     use std::collections::HashMap;
-    use std::convert::TryFrom;
 
     use clarity::vm::clarity::ClarityConnection;
     use clarity::vm::costs::ExecutionCost;
diff --git a/stackslib/src/net/http/request.rs b/stackslib/src/net/http/request.rs
index 36df8235a0..287acb1166 100644
--- a/stackslib/src/net/http/request.rs
+++ b/stackslib/src/net/http/request.rs
@@ -16,7 +16,6 @@
 
 use std::collections::{BTreeMap, HashMap, HashSet};
 use std::io::{Read, Write};
-use std::string::ToString;
 
 use percent_encoding::percent_decode_str;
 use rand::{thread_rng, Rng};
diff --git a/stackslib/src/net/inv/epoch2x.rs b/stackslib/src/net/inv/epoch2x.rs
index 4e97996410..480743a369 100644
--- a/stackslib/src/net/inv/epoch2x.rs
+++ b/stackslib/src/net/inv/epoch2x.rs
@@ -16,7 +16,6 @@
 
 use std::cmp;
 use std::collections::{BTreeMap, HashMap, HashSet};
-use std::convert::TryFrom;
 use std::io::{Read, Write};
 use std::net::SocketAddr;
 
diff --git a/stackslib/src/net/mod.rs b/stackslib/src/net/mod.rs
index fbdc914fb7..6136a4d094 100644
--- a/stackslib/src/net/mod.rs
+++ b/stackslib/src/net/mod.rs
@@ -15,9 +15,7 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::borrow::Borrow;
-use std::cmp::PartialEq;
 use std::collections::{HashMap, HashSet};
-use std::convert::{From, TryFrom};
 use std::hash::{Hash, Hasher};
 use std::io::prelude::*;
 use std::io::{Read, Write};
diff --git a/stackslib/src/net/rpc.rs b/stackslib/src/net/rpc.rs
index d6d75cff17..e2f93d7289 100644
--- a/stackslib/src/net/rpc.rs
+++ b/stackslib/src/net/rpc.rs
@@ -15,7 +15,6 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::collections::{HashMap, HashSet, VecDeque};
-use std::convert::TryFrom;
 use std::io::prelude::*;
 use std::io::{Read, Seek, SeekFrom, Write};
 use std::net::SocketAddr;
diff --git a/stackslib/src/util_lib/boot.rs b/stackslib/src/util_lib/boot.rs
index af3f443278..95cfca9c41 100644
--- a/stackslib/src/util_lib/boot.rs
+++ b/stackslib/src/util_lib/boot.rs
@@ -1,5 +1,3 @@
-use std::convert::TryFrom;
-
 use clarity::vm::database::STXBalance;
 use clarity::vm::types::{PrincipalData, QualifiedContractIdentifier};
 use clarity::vm::ContractName;
diff --git a/stackslib/src/util_lib/db.rs b/stackslib/src/util_lib/db.rs
index 584423ffb8..a06c23408b 100644
--- a/stackslib/src/util_lib/db.rs
+++ b/stackslib/src/util_lib/db.rs
@@ -14,7 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::convert::TryInto;
 use std::io::Error as IOError;
 use std::ops::{Deref, DerefMut};
 use std::path::{Path, PathBuf};
diff --git a/stackslib/src/util_lib/strings.rs b/stackslib/src/util_lib/strings.rs
index 3efb1fc7d9..0486e6bf81 100644
--- a/stackslib/src/util_lib/strings.rs
+++ b/stackslib/src/util_lib/strings.rs
@@ -15,7 +15,6 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::borrow::Borrow;
-use std::convert::TryFrom;
 use std::io::prelude::*;
 use std::io::{Read, Write};
 use std::ops::{Deref, DerefMut};
diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index eb118eb553..7e2751d7a8 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -1,5 +1,4 @@
 use std::collections::HashSet;
-use std::convert::TryInto;
 use std::fs;
 use std::net::{SocketAddr, ToSocketAddrs};
 use std::path::PathBuf;
diff --git a/testnet/stacks-node/src/main.rs b/testnet/stacks-node/src/main.rs
index 29d1fde368..95a1dda4b8 100644
--- a/testnet/stacks-node/src/main.rs
+++ b/testnet/stacks-node/src/main.rs
@@ -32,7 +32,6 @@ pub mod syncctl;
 pub mod tenure;
 
 use std::collections::HashMap;
-use std::convert::TryInto;
 use std::{env, panic, process};
 
 use backtrace::Backtrace;
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index 5e3c39c9e9..5186943197 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -14,7 +14,6 @@ use std::collections::HashMap;
 //
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
-use std::convert::TryFrom;
 use std::thread;
 use std::thread::JoinHandle;
 use std::time::{Duration, Instant};
diff --git a/testnet/stacks-node/src/nakamoto_node/peer.rs b/testnet/stacks-node/src/nakamoto_node/peer.rs
index 2c8beb7744..eeb6789d30 100644
--- a/testnet/stacks-node/src/nakamoto_node/peer.rs
+++ b/testnet/stacks-node/src/nakamoto_node/peer.rs
@@ -14,7 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 use std::collections::VecDeque;
-use std::default::Default;
 use std::net::SocketAddr;
 use std::sync::mpsc::TrySendError;
 use std::time::Duration;
diff --git a/testnet/stacks-node/src/neon_node.rs b/testnet/stacks-node/src/neon_node.rs
index a9c0393674..49064d4971 100644
--- a/testnet/stacks-node/src/neon_node.rs
+++ b/testnet/stacks-node/src/neon_node.rs
@@ -140,8 +140,6 @@
 use std::cmp;
 use std::cmp::Ordering as CmpOrdering;
 use std::collections::{BTreeMap, HashMap, HashSet, VecDeque};
-use std::convert::{TryFrom, TryInto};
-use std::default::Default;
 use std::io::{Read, Write};
 use std::net::SocketAddr;
 use std::sync::mpsc::{Receiver, TrySendError};
diff --git a/testnet/stacks-node/src/node.rs b/testnet/stacks-node/src/node.rs
index cdebdbc781..90c2123079 100644
--- a/testnet/stacks-node/src/node.rs
+++ b/testnet/stacks-node/src/node.rs
@@ -1,5 +1,4 @@
 use std::collections::{HashMap, HashSet};
-use std::convert::TryFrom;
 use std::net::SocketAddr;
 use std::thread::JoinHandle;
 use std::{env, thread, time};
diff --git a/testnet/stacks-node/src/tests/epoch_205.rs b/testnet/stacks-node/src/tests/epoch_205.rs
index 844a314bc6..0f689f00ef 100644
--- a/testnet/stacks-node/src/tests/epoch_205.rs
+++ b/testnet/stacks-node/src/tests/epoch_205.rs
@@ -1,5 +1,4 @@
 use std::collections::HashMap;
-use std::convert::TryFrom;
 use std::sync::atomic::Ordering;
 use std::{env, thread};
 
diff --git a/testnet/stacks-node/src/tests/mempool.rs b/testnet/stacks-node/src/tests/mempool.rs
index cc1f3d8228..8c906cd43e 100644
--- a/testnet/stacks-node/src/tests/mempool.rs
+++ b/testnet/stacks-node/src/tests/mempool.rs
@@ -1,4 +1,3 @@
-use std::convert::{From, TryFrom};
 use std::sync::Mutex;
 
 use clarity::vm::costs::ExecutionCost;
diff --git a/testnet/stacks-node/src/tests/mod.rs b/testnet/stacks-node/src/tests/mod.rs
index 485dd524d2..7dbabae3ed 100644
--- a/testnet/stacks-node/src/tests/mod.rs
+++ b/testnet/stacks-node/src/tests/mod.rs
@@ -14,7 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 use std::collections::HashMap;
-use std::convert::TryInto;
 use std::sync::atomic::AtomicU64;
 use std::sync::Arc;
 
diff --git a/testnet/stacks-node/src/tests/neon_integrations.rs b/testnet/stacks-node/src/tests/neon_integrations.rs
index d751035ac9..cd0c96358e 100644
--- a/testnet/stacks-node/src/tests/neon_integrations.rs
+++ b/testnet/stacks-node/src/tests/neon_integrations.rs
@@ -1,5 +1,4 @@
 use std::collections::{HashMap, HashSet};
-use std::convert::TryFrom;
 use std::path::Path;
 use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::{mpsc, Arc};

From 460d80ba4e2d3926e0e1b955ea18871049349de6 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Wed, 28 Feb 2024 10:29:35 -0800
Subject: [PATCH 0957/1166] feat: test that aggregate key was properly set

---
 .../burn/operations/vote_for_aggregate_key.rs |  2 +-
 .../src/tests/nakamoto_integrations.rs        | 39 ++++++++++++++++---
 .../src/tests/neon_integrations.rs            | 19 ++++-----
 3 files changed, 44 insertions(+), 16 deletions(-)

diff --git a/stackslib/src/chainstate/burn/operations/vote_for_aggregate_key.rs b/stackslib/src/chainstate/burn/operations/vote_for_aggregate_key.rs
index 51c582cd4d..399e365018 100644
--- a/stackslib/src/chainstate/burn/operations/vote_for_aggregate_key.rs
+++ b/stackslib/src/chainstate/burn/operations/vote_for_aggregate_key.rs
@@ -1,5 +1,5 @@
 // Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
-// Copyright (C) 2020 Stacks Open Internet Foundation
+// Copyright (C) 2020-2024 Stacks Open Internet Foundation
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index f02b97e23b..1f36b9737d 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -483,11 +483,12 @@ pub fn boot_to_epoch_3(
     info!("Bootstrapped to Epoch-3.0 boundary, Epoch2x miner should stop");
 }
 
-fn is_key_set_for_cycle(
+/// Use the read-only API to get the aggregate key for a given reward cycle
+pub fn get_key_for_cycle(
     reward_cycle: u64,
     is_mainnet: bool,
     http_origin: &str,
-) -> Result<bool, String> {
+) -> Result<Option<Vec<u8>>, String> {
     let client = reqwest::blocking::Client::new();
     let boot_address = StacksAddress::burn_address(is_mainnet);
     let path = format!("http://{http_origin}/v2/contracts/call-read/{boot_address}/signers-voting/get-approved-aggregate-key");
@@ -513,10 +514,29 @@ fn is_key_set_for_cycle(
     )
     .map_err(|_| "Failed to deserialize Clarity value")?;
 
-    result_value
+    let buff_opt = result_value
         .expect_optional()
-        .map(|v| v.is_some())
-        .map_err(|_| "Response is not optional".to_string())
+        .expect("Expected optional type");
+
+    match buff_opt {
+        Some(buff_val) => {
+            let buff = buff_val
+                .expect_buff(33)
+                .map_err(|_| "Failed to get buffer value")?;
+            Ok(Some(buff))
+        }
+        None => Ok(None),
+    }
+}
+
+/// Use the read-only to check if the aggregate key is set for a given reward cycle
+pub fn is_key_set_for_cycle(
+    reward_cycle: u64,
+    is_mainnet: bool,
+    http_origin: &str,
+) -> Result<bool, String> {
+    let key = get_key_for_cycle(reward_cycle, is_mainnet, &http_origin)?;
+    Ok(key.is_some())
 }
 
 fn signer_vote_if_needed(
@@ -1980,7 +2000,7 @@ fn vote_for_aggregate_key_burn_op() {
 
     info!("Submitted vote for aggregate key op at height {block_height}, mining a few blocks...");
 
-    // the second block should process the vote, after which the balaces should be unchanged
+    // the second block should process the vote, after which the vote should be set
     for _i in 0..2 {
         next_block_and_mine_commit(
             &mut btc_regtest_controller,
@@ -2021,6 +2041,13 @@ fn vote_for_aggregate_key_burn_op() {
         "Expected vote for aggregate key op"
     );
 
+    // Check that the correct key was set
+    let saved_key = get_key_for_cycle(reward_cycle, false, &naka_conf.node.rpc_bind)
+        .expect("Expected to be able to check key is set after voting")
+        .expect("Expected aggregate key to be set");
+
+    assert_eq!(saved_key, aggregate_key.as_bytes().to_vec());
+
     coord_channel
         .lock()
         .expect("Mutex poisoned")
diff --git a/testnet/stacks-node/src/tests/neon_integrations.rs b/testnet/stacks-node/src/tests/neon_integrations.rs
index 746b17cebc..3d63c38ddb 100644
--- a/testnet/stacks-node/src/tests/neon_integrations.rs
+++ b/testnet/stacks-node/src/tests/neon_integrations.rs
@@ -85,6 +85,7 @@ use crate::neon_node::RelayerThread;
 use crate::operations::BurnchainOpSigner;
 use crate::stacks_common::types::PrivateKey;
 use crate::syncctl::PoxSyncWatchdogComms;
+use crate::tests::nakamoto_integrations::get_key_for_cycle;
 use crate::util::hash::{MerkleTree, Sha512Trunc256Sum};
 use crate::util::secp256k1::MessageSignature;
 use crate::{neon, BitcoinRegtestController, BurnchainController, Config, ConfigFile, Keychain};
@@ -2245,8 +2246,6 @@ fn vote_for_aggregate_key_burn_op_test() {
     let spender_stx_addr: StacksAddress = to_addr(&spender_sk);
     let spender_addr: PrincipalData = spender_stx_addr.clone().into();
 
-    let recipient_sk = StacksPrivateKey::new();
-    let recipient_addr = to_addr(&recipient_sk);
     let pox_pubkey = Secp256k1PublicKey::from_hex(
         "02f006a09b59979e2cb8449f58076152af6b124aa29b948a3714b8d5f15aa94ede",
     )
@@ -2260,17 +2259,12 @@ fn vote_for_aggregate_key_burn_op_test() {
     let (mut conf, _miner_account) = neon_integration_test_conf();
 
     let first_bal = 6_000_000_000 * (core::MICROSTACKS_PER_STACKS as u64);
-    let second_bal = 2_000_000_000 * (core::MICROSTACKS_PER_STACKS as u64);
     let stacked_bal = 1_000_000_000 * (core::MICROSTACKS_PER_STACKS as u128);
 
     conf.initial_balances.push(InitialBalance {
         address: spender_addr.clone(),
         amount: first_bal,
     });
-    conf.initial_balances.push(InitialBalance {
-        address: recipient_addr.clone().into(),
-        amount: second_bal,
-    });
 
     // update epoch info so that Epoch 2.1 takes effect
     conf.burnchain.epochs = Some(vec![
@@ -2395,7 +2389,7 @@ fn vote_for_aggregate_key_burn_op_test() {
 
     let pox_addr = PoxAddress::Standard(spender_stx_addr, Some(AddressHashMode::SerializeP2PKH));
 
-    let mut block_height = channel.get_sortitions_processed();
+    let mut block_height = btc_regtest_controller.get_headers_height();
 
     let reward_cycle = burnchain_config
         .block_height_to_reward_cycle(block_height)
@@ -2460,7 +2454,7 @@ fn vote_for_aggregate_key_burn_op_test() {
     // Wait a few blocks to be registered
     for _i in 0..5 {
         next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
-        block_height = channel.get_sortitions_processed();
+        block_height = btc_regtest_controller.get_headers_height();
     }
 
     let reward_cycle = burnchain_config
@@ -2547,6 +2541,13 @@ fn vote_for_aggregate_key_burn_op_test() {
         "Expected vote for aggregate key op"
     );
 
+    // Check that the correct key was set
+    let saved_key = get_key_for_cycle(reward_cycle, false, &conf.node.rpc_bind)
+        .expect("Expected to be able to check key is set after voting")
+        .expect("Expected aggregate key to be set");
+
+    assert_eq!(saved_key, aggregate_key.as_bytes().to_vec());
+
     test_observer::clear();
     channel.stop_chains_coordinator();
 }

From 71b29bd294d37ebe798af960df365e47ebc14718 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Wed, 28 Feb 2024 10:44:11 -0800
Subject: [PATCH 0958/1166] fix: remove unnecessary sortdb schema changes

---
 stackslib/src/chainstate/burn/db/sortdb.rs | 33 ++++------------------
 1 file changed, 5 insertions(+), 28 deletions(-)

diff --git a/stackslib/src/chainstate/burn/db/sortdb.rs b/stackslib/src/chainstate/burn/db/sortdb.rs
index 1d8ae746f4..e61f447ca3 100644
--- a/stackslib/src/chainstate/burn/db/sortdb.rs
+++ b/stackslib/src/chainstate/burn/db/sortdb.rs
@@ -531,7 +531,7 @@ impl FromRow<StacksEpoch> for StacksEpoch {
     }
 }
 
-pub const SORTITION_DB_VERSION: &'static str = "9";
+pub const SORTITION_DB_VERSION: &'static str = "8";
 
 const SORTITION_DB_INITIAL_SCHEMA: &'static [&'static str] = &[
     r#"
@@ -761,9 +761,8 @@ const SORTITION_DB_SCHEMA_8: &'static [&'static str] = &[
         block_hash TEXT NOT NULL,
         block_height INTEGER NOT NULL
     );"#,
-];
-
-const SORTITION_DB_SCHEMA_9: &'static [&'static str] = &[r#"
+    r#"
+    -- table definition for `vote-for-aggregate-key` burn op
     CREATE TABLE vote_for_aggregate_key (
         txid TEXT NOT NULL,
         vtxindex INTEGER NOT NULL,
@@ -778,7 +777,8 @@ const SORTITION_DB_SCHEMA_9: &'static [&'static str] = &[r#"
         signer_key TEXT NOT NULL,
 
         PRIMARY KEY(txid,burn_header_Hash)
-    );"#];
+    );"#,
+];
 
 const SORTITION_DB_INDEXES: &'static [&'static str] = &[
     "CREATE INDEX IF NOT EXISTS snapshots_block_hashes ON snapshots(block_height,index_root,winning_stacks_block_hash);",
@@ -2996,7 +2996,6 @@ impl SortitionDB {
         SortitionDB::apply_schema_6(&db_tx, epochs_ref)?;
         SortitionDB::apply_schema_7(&db_tx, epochs_ref)?;
         SortitionDB::apply_schema_8(&db_tx)?;
-        SortitionDB::apply_schema_9(&db_tx)?;
 
         db_tx.instantiate_index()?;
 
@@ -3228,7 +3227,6 @@ impl SortitionDB {
                     || version == "6"
                     || version == "7"
                     || version == "8"
-                    || version == "9"
             }
             StacksEpochId::Epoch2_05 => {
                 version == "2"
@@ -3238,7 +3236,6 @@ impl SortitionDB {
                     || version == "6"
                     || version == "7"
                     || version == "8"
-                    || version == "9"
             }
             StacksEpochId::Epoch21 => {
                 version == "3"
@@ -3247,7 +3244,6 @@ impl SortitionDB {
                     || version == "6"
                     || version == "7"
                     || version == "8"
-                    || version == "9"
             }
             StacksEpochId::Epoch22 => {
                 version == "3"
@@ -3265,7 +3261,6 @@ impl SortitionDB {
                     || version == "6"
                     || version == "7"
                     || version == "8"
-                    || version == "9"
             }
             StacksEpochId::Epoch24 => {
                 version == "3"
@@ -3284,7 +3279,6 @@ impl SortitionDB {
                     || version == "7"
                     // TODO: This should move to Epoch 30 once it is added
                     || version == "8"
-                    || version == "9"
             }
             StacksEpochId::Epoch30 => {
                 version == "3"
@@ -3293,7 +3287,6 @@ impl SortitionDB {
                     || version == "6"
                     || version == "7"
                     || version == "8"
-                    || version == "9"
             }
         }
     }
@@ -3423,18 +3416,6 @@ impl SortitionDB {
         Ok(())
     }
 
-    fn apply_schema_9(tx: &DBTx) -> Result<(), db_error> {
-        for sql_exec in SORTITION_DB_SCHEMA_9 {
-            tx.execute_batch(sql_exec)?;
-        }
-
-        tx.execute(
-            "INSERT OR REPLACE INTO db_config (version) VALUES (?1)",
-            &["9"],
-        )?;
-        Ok(())
-    }
-
     fn check_schema_version_or_error(&mut self) -> Result<(), db_error> {
         match SortitionDB::get_schema_version(self.conn()) {
             Ok(Some(version)) => {
@@ -3489,10 +3470,6 @@ impl SortitionDB {
                         let tx = self.tx_begin()?;
                         SortitionDB::apply_schema_8(&tx.deref())?;
                         tx.commit()?;
-                    } else if version == "8" {
-                        let tx = self.tx_begin()?;
-                        SortitionDB::apply_schema_9(&tx.deref())?;
-                        tx.commit()?;
                     } else if version == expected_version {
                         return Ok(());
                     } else {

From bad95704a1725aa28984903108706565f7bd38fd Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Wed, 28 Feb 2024 10:51:51 -0800
Subject: [PATCH 0959/1166] fix: comment language

---
 testnet/stacks-node/src/tests/neon_integrations.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/testnet/stacks-node/src/tests/neon_integrations.rs b/testnet/stacks-node/src/tests/neon_integrations.rs
index 55d934fdae..7b15d07bc8 100644
--- a/testnet/stacks-node/src/tests/neon_integrations.rs
+++ b/testnet/stacks-node/src/tests/neon_integrations.rs
@@ -2504,7 +2504,7 @@ fn vote_for_aggregate_key_burn_op_test() {
 
     info!("Submitted vote for aggregate key op at height {block_height}, mining a few blocks...");
 
-    // the second block should process the vote, after which the balaces should be unchanged
+    // the second block should process the vote, after which the vote should be processed
     next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
     next_block_and_wait(&mut btc_regtest_controller, &blocks_processed);
 

From 18761f278d69df42c5f35e7990d74163d1bb1d85 Mon Sep 17 00:00:00 2001
From: Marzi <marzi@trustmachines.co>
Date: Wed, 28 Feb 2024 19:57:07 -0500
Subject: [PATCH 0960/1166] Remove announce_reward_set from
 BlockEventDispatcher trait

---
 stackslib/src/chainstate/coordinator/mod.rs   | 11 -----------
 stackslib/src/chainstate/coordinator/tests.rs |  8 --------
 stackslib/src/chainstate/stacks/db/blocks.rs  | 12 ------------
 stackslib/src/net/mod.rs                      |  9 ---------
 testnet/stacks-node/src/event_dispatcher.rs   |  9 ---------
 5 files changed, 49 deletions(-)

diff --git a/stackslib/src/chainstate/coordinator/mod.rs b/stackslib/src/chainstate/coordinator/mod.rs
index dbfa9f1255..cc6376ca58 100644
--- a/stackslib/src/chainstate/coordinator/mod.rs
+++ b/stackslib/src/chainstate/coordinator/mod.rs
@@ -192,13 +192,6 @@ pub trait BlockEventDispatcher {
         burns: u64,
         reward_recipients: Vec<PoxAddress>,
     );
-
-    fn announce_reward_set(
-        &self,
-        reward_set: &RewardSet,
-        block_id: &StacksBlockId,
-        cycle_number: u64,
-    );
 }
 
 pub struct ChainsCoordinatorConfig {
@@ -364,10 +357,6 @@ impl<'a, T: BlockEventDispatcher> RewardSetProvider for OnChainRewardSetProvider
             }
         }
 
-        // if let Some(dispatcher) = self.0 {
-        //     dispatcher.announce_reward_set(&reward_set, block_id, cycle);
-        // }
-
         Ok(reward_set)
     }
 
diff --git a/stackslib/src/chainstate/coordinator/tests.rs b/stackslib/src/chainstate/coordinator/tests.rs
index 4861e0af7a..e3fc8f21c4 100644
--- a/stackslib/src/chainstate/coordinator/tests.rs
+++ b/stackslib/src/chainstate/coordinator/tests.rs
@@ -443,14 +443,6 @@ impl BlockEventDispatcher for NullEventDispatcher {
         _slot_holders: Vec<PoxAddress>,
     ) {
     }
-
-    fn announce_reward_set(
-        &self,
-        _reward_set: &RewardSet,
-        _block_id: &StacksBlockId,
-        _cycle_number: u64,
-    ) {
-    }
 }
 
 pub fn make_coordinator<'a>(
diff --git a/stackslib/src/chainstate/stacks/db/blocks.rs b/stackslib/src/chainstate/stacks/db/blocks.rs
index fd0d44ed0e..7030b9259d 100644
--- a/stackslib/src/chainstate/stacks/db/blocks.rs
+++ b/stackslib/src/chainstate/stacks/db/blocks.rs
@@ -212,18 +212,6 @@ impl BlockEventDispatcher for DummyEventDispatcher {
             "We should never try to announce to the dummy dispatcher"
         );
     }
-
-    fn announce_reward_set(
-        &self,
-        _reward_set: &RewardSet,
-        _block_id: &StacksBlockId,
-        _cycle_number: u64,
-    ) {
-        assert!(
-            false,
-            "We should never try to announce to the dummy dispatcher"
-        );
-    }
 }
 
 impl MemPoolRejection {
diff --git a/stackslib/src/net/mod.rs b/stackslib/src/net/mod.rs
index e21a1e91c3..5c2e43f260 100644
--- a/stackslib/src/net/mod.rs
+++ b/stackslib/src/net/mod.rs
@@ -1926,15 +1926,6 @@ pub mod test {
         ) {
             // pass
         }
-
-        fn announce_reward_set(
-            &self,
-            _reward_set: &RewardSet,
-            _block_id: &StacksBlockId,
-            _cycle_number: u64,
-        ) {
-            // pass
-        }
     }
 
     // describes a peer's initial configuration
diff --git a/testnet/stacks-node/src/event_dispatcher.rs b/testnet/stacks-node/src/event_dispatcher.rs
index a1f1d86d76..aa80f7fc52 100644
--- a/testnet/stacks-node/src/event_dispatcher.rs
+++ b/testnet/stacks-node/src/event_dispatcher.rs
@@ -639,15 +639,6 @@ impl BlockEventDispatcher for EventDispatcher {
             recipient_info,
         )
     }
-
-    fn announce_reward_set(
-        &self,
-        reward_set: &RewardSet,
-        block_id: &StacksBlockId,
-        cycle_number: u64,
-    ) {
-        self.process_stacker_set(reward_set, block_id, cycle_number)
-    }
 }
 
 impl EventDispatcher {

From 4ebc6358c4a547cd03b6a5769158e41cb48a6e23 Mon Sep 17 00:00:00 2001
From: Marzi <marzi@trustmachines.co>
Date: Wed, 28 Feb 2024 21:01:07 -0500
Subject: [PATCH 0961/1166] Remove StackerSet event type

---
 testnet/stacks-node/src/config.rs             |  5 ---
 testnet/stacks-node/src/event_dispatcher.rs   | 32 +------------------
 .../src/tests/nakamoto_integrations.rs        |  2 +-
 3 files changed, 2 insertions(+), 37 deletions(-)

diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index f7010ca49b..0b41b9c6a3 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -2537,7 +2537,6 @@ pub enum EventKeyType {
     MinedMicroblocks,
     StackerDBChunks,
     BlockProposal,
-    StackerSet,
 }
 
 impl EventKeyType {
@@ -2570,10 +2569,6 @@ impl EventKeyType {
             return Some(EventKeyType::BlockProposal);
         }
 
-        if raw_key == "stacker_set" {
-            return Some(EventKeyType::StackerSet);
-        }
-
         let comps: Vec<_> = raw_key.split("::").collect();
         if comps.len() == 1 {
             let split: Vec<_> = comps[0].split('.').collect();
diff --git a/testnet/stacks-node/src/event_dispatcher.rs b/testnet/stacks-node/src/event_dispatcher.rs
index aa80f7fc52..722ddc7af0 100644
--- a/testnet/stacks-node/src/event_dispatcher.rs
+++ b/testnet/stacks-node/src/event_dispatcher.rs
@@ -17,7 +17,7 @@ use stacks::chainstate::burn::ConsensusHash;
 use stacks::chainstate::coordinator::BlockEventDispatcher;
 use stacks::chainstate::nakamoto::NakamotoBlock;
 use stacks::chainstate::stacks::address::PoxAddress;
-use stacks::chainstate::stacks::boot::{RewardSet, RewardSetData};
+use stacks::chainstate::stacks::boot::RewardSetData;
 use stacks::chainstate::stacks::db::accounts::MinerReward;
 use stacks::chainstate::stacks::db::unconfirmed::ProcessedUnconfirmedState;
 use stacks::chainstate::stacks::db::{MinerRewardInfo, StacksHeaderInfo};
@@ -72,7 +72,6 @@ pub const PATH_BURN_BLOCK_SUBMIT: &str = "new_burn_block";
 pub const PATH_BLOCK_PROCESSED: &str = "new_block";
 pub const PATH_ATTACHMENT_PROCESSED: &str = "attachments/new";
 pub const PATH_PROPOSAL_RESPONSE: &str = "proposal_response";
-pub const PATH_POX_ANCHOR: &str = "new_pox_set";
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct MinedBlockEvent {
@@ -463,7 +462,6 @@ pub struct EventDispatcher {
     mined_microblocks_observers_lookup: HashSet<u16>,
     stackerdb_observers_lookup: HashSet<u16>,
     block_proposal_observers_lookup: HashSet<u16>,
-    pox_stacker_set_observers_lookup: HashSet<u16>,
 }
 
 /// This struct is used specifically for receiving proposal responses.
@@ -656,7 +654,6 @@ impl EventDispatcher {
             mined_microblocks_observers_lookup: HashSet::new(),
             stackerdb_observers_lookup: HashSet::new(),
             block_proposal_observers_lookup: HashSet::new(),
-            pox_stacker_set_observers_lookup: HashSet::new(),
         }
     }
 
@@ -940,30 +937,6 @@ impl EventDispatcher {
             .collect()
     }
 
-    fn process_stacker_set(
-        &self,
-        reward_set: &RewardSet,
-        block_id: &StacksBlockId,
-        cycle_number: u64,
-    ) {
-        let interested_observers =
-            self.filter_observers(&self.pox_stacker_set_observers_lookup, false);
-
-        if interested_observers.is_empty() {
-            return;
-        }
-
-        let payload = json!({
-            "stacker_set": reward_set,
-            "block_id": block_id,
-            "cycle_number": cycle_number
-        });
-
-        for observer in interested_observers.iter() {
-            observer.send_payload(&payload, PATH_POX_ANCHOR);
-        }
-    }
-
     pub fn process_new_mempool_txs(&self, txs: Vec<StacksTransaction>) {
         // lazily assemble payload only if we have observers
         let interested_observers = self.filter_observers(&self.mempool_observers_lookup, true);
@@ -1208,9 +1181,6 @@ impl EventDispatcher {
                 EventKeyType::BlockProposal => {
                     self.block_proposal_observers_lookup.insert(observer_index);
                 }
-                EventKeyType::StackerSet => {
-                    self.pox_stacker_set_observers_lookup.insert(observer_index);
-                }
             }
         }
 
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 37c6ff5f53..40577cf372 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -1035,7 +1035,7 @@ fn correct_burn_outs() {
     let observer_port = test_observer::EVENT_OBSERVER_PORT;
     naka_conf.events_observers.insert(EventObserverConfig {
         endpoint: format!("localhost:{observer_port}"),
-        events_keys: vec![EventKeyType::AnyEvent, EventKeyType::StackerSet],
+        events_keys: vec![EventKeyType::AnyEvent],
     });
 
     let mut btcd_controller = BitcoinCoreController::new(naka_conf.clone());

From 898f59e1fd3f1aa56df34086f2fe3d769c3f962a Mon Sep 17 00:00:00 2001
From: MarvinJanssen <MarvinJanssen@users.noreply.github.com>
Date: Thu, 29 Feb 2024 10:05:44 +0100
Subject: [PATCH 0962/1166] fix: name register TS test

---
 .../tests/bns/name_register.test.ts           | 91 +++++++++----------
 1 file changed, 45 insertions(+), 46 deletions(-)

diff --git a/contrib/core-contract-tests/tests/bns/name_register.test.ts b/contrib/core-contract-tests/tests/bns/name_register.test.ts
index afb7263199..448df6b322 100644
--- a/contrib/core-contract-tests/tests/bns/name_register.test.ts
+++ b/contrib/core-contract-tests/tests/bns/name_register.test.ts
@@ -323,55 +323,54 @@ describe("name revealing workflow", () => {
     expect(result).toBeErr(Cl.int(2022));
   });
 
-  // temp disabled, focusing on importing clarunit correctly
-  // it("should successfully register", () => {
-  //   const name = "bob";
-  //   const merged = new TextEncoder().encode(`${name}.${cases[0].namespace}${cases[0].salt}`);
-  //   const sha256 = createHash("sha256").update(merged).digest();
-  //   const ripemd160 = createHash("ripemd160").update(sha256).digest();
-  //   simnet.callPublicFn("bns", "name-preorder", [Cl.buffer(ripemd160), Cl.uint(2560000)], bob);
+  it("should successfully register", () => {
+    const name = "bob";
+    const merged = new TextEncoder().encode(`${name}.${cases[0].namespace}${cases[0].salt}`);
+    const sha256 = createHash("sha256").update(merged).digest();
+    const ripemd160 = createHash("ripemd160").update(sha256).digest();
+    simnet.callPublicFn("bns", "name-preorder", [Cl.buffer(ripemd160), Cl.uint(2560000)], bob);
 
-  //   const register = simnet.callPublicFn(
-  //     "bns",
-  //     "name-register",
-  //     [
-  //       Cl.bufferFromUtf8(cases[0].namespace),
-  //       Cl.bufferFromUtf8(name),
-  //       Cl.bufferFromUtf8(cases[0].salt),
-  //       Cl.bufferFromUtf8(cases[0].zonefile),
-  //     ],
-  //     bob
-  //   );
-  //   expect(register.result).toBeOk(Cl.bool(true));
+    const register = simnet.callPublicFn(
+      "bns",
+      "name-register",
+      [
+        Cl.bufferFromUtf8(cases[0].namespace),
+        Cl.bufferFromUtf8(name),
+        Cl.bufferFromUtf8(cases[0].salt),
+        Cl.bufferFromUtf8(cases[0].zonefile),
+      ],
+      bob
+    );
+    expect(register.result).toBeOk(Cl.bool(true));
 
-  //   const resolvePrincipal = simnet.callReadOnlyFn(
-  //     "bns",
-  //     "resolve-principal",
-  //     [Cl.standardPrincipal(bob)],
-  //     alice
-  //   );
-  //   expect(resolvePrincipal.result).toBeOk(
-  //     Cl.tuple({
-  //       name: Cl.bufferFromUtf8("bob"),
-  //       namespace: Cl.bufferFromUtf8("blockstack"),
-  //     })
-  //   );
+    const resolvePrincipal = simnet.callReadOnlyFn(
+      "bns",
+      "resolve-principal",
+      [Cl.standardPrincipal(bob)],
+      alice
+    );
+    expect(resolvePrincipal.result).toBeOk(
+      Cl.tuple({
+        name: Cl.bufferFromUtf8("bob"),
+        namespace: Cl.bufferFromUtf8("blockstack"),
+      })
+    );
 
-  //   const nameResolve = simnet.callReadOnlyFn(
-  //     "bns",
-  //     "name-resolve",
-  //     [Cl.bufferFromUtf8(cases[0].namespace), Cl.bufferFromUtf8(name)],
-  //     alice
-  //   );
-  //   expect(nameResolve.result).toBeOk(
-  //     Cl.tuple({
-  //       owner: Cl.standardPrincipal(bob),
-  //       ["zonefile-hash"]: Cl.bufferFromUtf8(cases[0].zonefile),
-  //       ["lease-ending-at"]: Cl.some(Cl.uint(17)),
-  //       ["lease-started-at"]: Cl.uint(7),
-  //     })
-  //   );
-  // });
+    const nameResolve = simnet.callReadOnlyFn(
+      "bns",
+      "name-resolve",
+      [Cl.bufferFromUtf8(cases[0].namespace), Cl.bufferFromUtf8(name)],
+      alice
+    );
+    expect(nameResolve.result).toBeOk(
+      Cl.tuple({
+        owner: Cl.standardPrincipal(bob),
+        ["zonefile-hash"]: Cl.bufferFromUtf8(cases[0].zonefile),
+        ["lease-ending-at"]: Cl.some(Cl.uint(16)),
+        ["lease-started-at"]: Cl.uint(6),
+      })
+    );
+  });
 
   it("should fail registering twice", () => {
     const name = "bob";

From 1625de1da28a6e9b2a0f8f1d5301196c7a19cd78 Mon Sep 17 00:00:00 2001
From: MarvinJanssen <MarvinJanssen@users.noreply.github.com>
Date: Thu, 29 Feb 2024 10:08:01 +0100
Subject: [PATCH 0963/1166] fix: typo in test error message

---
 contrib/core-contract-tests/tests/pox_4_test.clar | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/contrib/core-contract-tests/tests/pox_4_test.clar b/contrib/core-contract-tests/tests/pox_4_test.clar
index dedd0c5d97..2d6f0f49fc 100644
--- a/contrib/core-contract-tests/tests/pox_4_test.clar
+++ b/contrib/core-contract-tests/tests/pox_4_test.clar
@@ -81,10 +81,10 @@
 			(err "Only length 20 should be valid for version 0x04")
 		)
 		(asserts! (is-eq (map check-pox-addr-hashbytes-iter test-lengths (buff-repeat 0x05 (len test-lengths))) length-32-valid)
-			(err "Only length 20 should be valid for version 0x05")
+			(err "Only length 32 should be valid for version 0x05")
 		)
 		(asserts! (is-eq (map check-pox-addr-hashbytes-iter test-lengths (buff-repeat 0x06 (len test-lengths))) length-32-valid)
-			(err "Only length 20 should be valid for version 0x06")
+			(err "Only length 32 should be valid for version 0x06")
 		)
 		(asserts! (is-eq (map check-pox-addr-hashbytes-iter test-lengths (buff-repeat 0x07 (len test-lengths))) length-all-invalid)
 			(err "No length should be valid for version 0x07")
@@ -107,7 +107,6 @@
 
 (define-public (test-get-total-ustx-stacked)
 	(begin 
-		;; @continue
 		(asserts! (is-eq (contract-call? .pox-4 get-total-ustx-stacked u1) u0) (err u111))
 		(ok true)))
 

From 4ad742cdf378734cdedd78cdfa437ac130bb3db4 Mon Sep 17 00:00:00 2001
From: MarvinJanssen <MarvinJanssen@users.noreply.github.com>
Date: Thu, 29 Feb 2024 10:21:47 +0100
Subject: [PATCH 0964/1166] chore: clean up tests

---
 .../core-contract-tests/tests/pox_4_test.clar | 43 ++++++++++++-------
 1 file changed, 28 insertions(+), 15 deletions(-)

diff --git a/contrib/core-contract-tests/tests/pox_4_test.clar b/contrib/core-contract-tests/tests/pox_4_test.clar
index 2d6f0f49fc..704c42bbb2 100644
--- a/contrib/core-contract-tests/tests/pox_4_test.clar
+++ b/contrib/core-contract-tests/tests/pox_4_test.clar
@@ -1,17 +1,25 @@
 (define-public (test-burn-height-to-reward-cycle)
 	(begin 
 		(asserts! (is-eq u2 (contract-call? .pox-4 burn-height-to-reward-cycle u2100)) (err "Burn height 2100 should have been reward cycle 2"))
-		(ok true)))
+		(asserts! (is-eq u3 (contract-call? .pox-4 burn-height-to-reward-cycle u3150)) (err "Burn height 3150 should have been reward cycle 2"))
+		(ok true)
+	)
+)
 
 (define-public (test-reward-cycle-to-burn-height)
 	(begin 
 		(asserts! (is-eq u10500 (contract-call? .pox-4 reward-cycle-to-burn-height u10)) (err "Cycle 10 height should have been at burn height 10500"))
-		(ok true)))
+		(asserts! (is-eq u18900 (contract-call? .pox-4 reward-cycle-to-burn-height u18)) (err "Cycle 18 height should have been at burn height 18900"))
+		(ok true)
+	)
+)
 
 (define-public (test-get-stacker-info-none)
 	(begin 
 		(asserts! (is-none (contract-call? .pox-4 get-stacker-info tx-sender)) (err "By default, tx-sender should not have stacker info"))
-		(ok true)))
+		(ok true)
+	)
+)
 
 
 (define-private (check-pox-addr-version-iter (input (buff 1)))
@@ -93,22 +101,27 @@
 	)
 )
 
-(define-public (test-invalid-lock-height-too-low)
-	(let
-		((actual (contract-call? .pox-4 check-pox-lock-period u0)))
-		(asserts! (not actual) (err u111))
-		(ok true)))
+(define-private (check-pox-lock-period-iter (period uint))
+	(contract-call? .pox-4 check-pox-lock-period period)
+)
 
-(define-public (test-invalid-lock-height-too-high)
-	(let
-		((actual (contract-call? .pox-4 check-pox-lock-period u13)))
-		(asserts! (not actual) (err u111))
-		(ok true)))
+(define-public (test-check-pox-lock-period)
+	(let ((actual (map check-pox-lock-period-iter (list u0 u1 u2 u3 u4 u5 u6 u7 u8 u9 u10 u11 u12 u13))))
+		(asserts! (is-eq
+			actual
+			(list true true true true true true true true true true true true true false))
+			(err {err: "Expected only lock periods 1 to 12 to be valid", actual: actual})
+		)
+		(ok true)
+	)
+)
 
 (define-public (test-get-total-ustx-stacked)
 	(begin 
-		(asserts! (is-eq (contract-call? .pox-4 get-total-ustx-stacked u1) u0) (err u111))
-		(ok true)))
+		(asserts! (is-eq (contract-call? .pox-4 get-total-ustx-stacked u1) u0) (err "Total ustx stacked should be 0"))
+		(ok true)
+	)
+)
 
 
 (define-private (repeat-iter (a (buff 1)) (repeat {i: (buff 1), o: (buff 33)}))

From 07ebe46eafef83cebe6c47ca9ef2c87d28a5b426 Mon Sep 17 00:00:00 2001
From: MarvinJanssen <MarvinJanssen@users.noreply.github.com>
Date: Thu, 29 Feb 2024 10:29:03 +0100
Subject: [PATCH 0965/1166] chore: forgot to switch back to false

---
 contrib/core-contract-tests/tests/pox_4_test.clar | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/contrib/core-contract-tests/tests/pox_4_test.clar b/contrib/core-contract-tests/tests/pox_4_test.clar
index 704c42bbb2..a158d9033e 100644
--- a/contrib/core-contract-tests/tests/pox_4_test.clar
+++ b/contrib/core-contract-tests/tests/pox_4_test.clar
@@ -109,7 +109,7 @@
 	(let ((actual (map check-pox-lock-period-iter (list u0 u1 u2 u3 u4 u5 u6 u7 u8 u9 u10 u11 u12 u13))))
 		(asserts! (is-eq
 			actual
-			(list true true true true true true true true true true true true true false))
+			(list false true true true true true true true true true true true true false))
 			(err {err: "Expected only lock periods 1 to 12 to be valid", actual: actual})
 		)
 		(ok true)

From 4962452c06cb5f6e36819a6fd57e5a03cd1390b6 Mon Sep 17 00:00:00 2001
From: MarvinJanssen <MarvinJanssen@users.noreply.github.com>
Date: Thu, 29 Feb 2024 10:57:57 +0100
Subject: [PATCH 0966/1166] fix: attempt to fix codecov upload

---
 .github/workflows/stacks-core-tests.yml | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/stacks-core-tests.yml b/.github/workflows/stacks-core-tests.yml
index 1e883d3d96..e8d82b4dcb 100644
--- a/.github/workflows/stacks-core-tests.yml
+++ b/.github/workflows/stacks-core-tests.yml
@@ -160,9 +160,10 @@ jobs:
         id: codecov
         uses: stacks-network/actions/codecov@main
         with:
+          fail_ci_if_error: true
           test-name: ${{ matrix.test-name }}
           upload-only: true
-          filename: ./lcov.info
+          filename: ./contrib/core-contract-tests/lcov.info
 
   # Core contract tests on Clarinet v1
   # Check for false positives/negatives

From 8d327754a8a9ad6e8ead8706cb6f91d2714877fa Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Mon, 26 Feb 2024 14:04:43 -0500
Subject: [PATCH 0967/1166] two minor checks

---
 stackslib/src/chainstate/stacks/boot/pox-4.clar | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index d54f3b8d5f..77c8ef2550 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -32,6 +32,7 @@
 (define-constant ERR_DELEGATION_ALREADY_REVOKED 34)
 (define-constant ERR_INVALID_SIGNATURE_PUBKEY 35)
 (define-constant ERR_INVALID_SIGNATURE_RECOVER 36)
+(define-constant ERR_INVALID_REWARD_CYCLE 37)
 
 ;; Valid values for burnchain address versions.
 ;; These first four correspond to address hash modes in Stacks 2.1,
@@ -1368,6 +1369,10 @@
     (asserts! (is-eq
       (unwrap! (principal-construct? (if is-in-mainnet STACKS_ADDR_VERSION_MAINNET STACKS_ADDR_VERSION_TESTNET) (hash160 signer-key)) (err ERR_INVALID_SIGNER_KEY))
       tx-sender) (err ERR_NOT_ALLOWED))
+    ;; Must be called with positive period
+    (asserts! (>= period u1) (err ERR_STACKING_INVALID_LOCK_PERIOD))
+    ;; Must be current or future reward cycle
+    (asserts! (>= reward-cycle (current-pox-reward-cycle)) (err ERR_INVALID_REWARD_CYCLE))
     (map-set signer-key-authorizations { pox-addr: pox-addr, period: period, reward-cycle: reward-cycle, topic: topic, signer-key: signer-key } allowed)
     (ok allowed)))
 

From 11a5ce92b7c7f50d14f91033d88779294985542b Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Mon, 26 Feb 2024 16:18:04 -0500
Subject: [PATCH 0968/1166] updated test_set_signer_key_auth passing again,
 still work remaining

---
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 43 +++++++++++++++----
 1 file changed, 34 insertions(+), 9 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index ebb8c5f078..33567e6d42 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -2642,6 +2642,7 @@ fn test_set_signer_key_auth() {
     let mut signer_nonce = 0;
     let signer_key = &keys[1];
     let signer_public_key = StacksPublicKey::from_private(signer_key);
+    let signer_addr = key_to_stacks_addr(&signer_key);
     let pox_addr = pox_addr_from(&signer_key);
 
     // Only the address associated with `signer-key` can enable auth for that key
@@ -2657,21 +2658,38 @@ fn test_set_signer_key_auth() {
         Some(&alice_key),
     );
 
+    let current_cycle = get_current_reward_cycle(&peer, &burnchain);
+    println!("Current cycle: {}", current_cycle);
+
+    // Test that period is at least u1
+    let invalid_auth_tx_period: StacksTransaction = make_pox_4_set_signer_key_auth(
+        &pox_addr,
+        &signer_key,
+        22,
+        &Pox4SignatureTopic::StackStx,
+        0,
+        false,
+        signer_nonce,
+        Some(&signer_key),
+    );
+
+    // Test that confirmed reward cycle is at least current reward cycle
+
     // Disable auth for `signer-key`
-    let disable_auth_nonce = signer_nonce;
+    signer_nonce += 1;
     let disable_auth_tx: StacksTransaction = make_pox_4_set_signer_key_auth(
         &pox_addr,
         &signer_key,
-        1,
+        22,
         &Pox4SignatureTopic::StackStx,
         lock_period,
         false,
-        disable_auth_nonce,
+        signer_nonce,
         None,
     );
 
     let latest_block =
-        peer.tenure_with_txs(&[invalid_enable_tx, disable_auth_tx], &mut coinbase_nonce);
+        peer.tenure_with_txs(&[invalid_enable_tx, invalid_auth_tx_period, disable_auth_tx], &mut coinbase_nonce);
 
     let alice_txs = get_last_block_sender_transactions(&observer, alice_addr);
     let invalid_enable_tx_result = alice_txs
@@ -2682,11 +2700,18 @@ fn test_set_signer_key_auth() {
     let expected_error = Value::error(Value::Int(19)).unwrap();
     assert_eq!(invalid_enable_tx_result, expected_error);
 
+    let signer_txs = get_last_block_sender_transactions(&observer, signer_addr);
+
+    // // Print all signer transaction receipts
+    println!("signer_txs: {:?}", signer_txs);
+    for tx in signer_txs {
+        println!("txs in signer_tx? {:?}", tx.result);
+    }
     let signer_key_enabled = get_signer_key_authorization_pox_4(
         &mut peer,
         &latest_block,
         &pox_addr,
-        1,
+        22,
         &Pox4SignatureTopic::StackStx,
         lock_period.try_into().unwrap(),
         &signer_public_key,
@@ -2700,7 +2725,7 @@ fn test_set_signer_key_auth() {
     let enable_auth_tx = make_pox_4_set_signer_key_auth(
         &pox_addr,
         &signer_key,
-        1,
+        22,
         &Pox4SignatureTopic::StackStx,
         lock_period,
         true,
@@ -2714,7 +2739,7 @@ fn test_set_signer_key_auth() {
         &mut peer,
         &latest_block,
         &pox_addr,
-        1,
+        22,
         &Pox4SignatureTopic::StackStx,
         lock_period.try_into().unwrap(),
         &signer_public_key,
@@ -2728,7 +2753,7 @@ fn test_set_signer_key_auth() {
     let disable_auth_tx = make_pox_4_set_signer_key_auth(
         &pox_addr,
         &signer_key,
-        1,
+        22,
         &Pox4SignatureTopic::StackStx,
         lock_period,
         false,
@@ -2742,7 +2767,7 @@ fn test_set_signer_key_auth() {
         &mut peer,
         &latest_block,
         &pox_addr,
-        1,
+        22,
         &Pox4SignatureTopic::StackStx,
         lock_period.try_into().unwrap(),
         &signer_public_key,

From 2a63322ea619606706d63137954fad9bbe577805 Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Tue, 27 Feb 2024 07:25:43 -0500
Subject: [PATCH 0969/1166] completed updating test_set_signer_key_auth

---
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 63 +++++++++++++------
 1 file changed, 44 insertions(+), 19 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 33567e6d42..0ddf9075c2 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -2645,6 +2645,8 @@ fn test_set_signer_key_auth() {
     let signer_addr = key_to_stacks_addr(&signer_key);
     let pox_addr = pox_addr_from(&signer_key);
 
+    let current_reward_cycle = get_current_reward_cycle(&peer, &burnchain);
+
     // Only the address associated with `signer-key` can enable auth for that key
     let invalid_enable_nonce = alice_nonce;
     let invalid_enable_tx = make_pox_4_set_signer_key_auth(
@@ -2658,29 +2660,39 @@ fn test_set_signer_key_auth() {
         Some(&alice_key),
     );
 
-    let current_cycle = get_current_reward_cycle(&peer, &burnchain);
-    println!("Current cycle: {}", current_cycle);
-
     // Test that period is at least u1
-    let invalid_auth_tx_period: StacksTransaction = make_pox_4_set_signer_key_auth(
+    let signer_invalid_period_nonce = signer_nonce;
+    signer_nonce += 1;
+    let invalid_tx_period: StacksTransaction = make_pox_4_set_signer_key_auth(
         &pox_addr,
         &signer_key,
-        22,
+        current_reward_cycle,
         &Pox4SignatureTopic::StackStx,
         0,
         false,
-        signer_nonce,
+        signer_invalid_period_nonce,
         Some(&signer_key),
     );
 
+    let signer_invalid_cycle_nonce = signer_nonce;
+    signer_nonce += 1;
     // Test that confirmed reward cycle is at least current reward cycle
+    let invalid_tx_cycle: StacksTransaction = make_pox_4_set_signer_key_auth(
+        &pox_addr, 
+        &signer_key, 
+        1, 
+        &Pox4SignatureTopic::StackStx,
+        1,
+        false,
+        signer_invalid_cycle_nonce,
+        Some(&signer_key),
+    );
 
     // Disable auth for `signer-key`
-    signer_nonce += 1;
     let disable_auth_tx: StacksTransaction = make_pox_4_set_signer_key_auth(
         &pox_addr,
         &signer_key,
-        22,
+        current_reward_cycle,
         &Pox4SignatureTopic::StackStx,
         lock_period,
         false,
@@ -2689,7 +2701,7 @@ fn test_set_signer_key_auth() {
     );
 
     let latest_block =
-        peer.tenure_with_txs(&[invalid_enable_tx, invalid_auth_tx_period, disable_auth_tx], &mut coinbase_nonce);
+        peer.tenure_with_txs(&[invalid_enable_tx, invalid_tx_period, invalid_tx_cycle, disable_auth_tx], &mut coinbase_nonce);
 
     let alice_txs = get_last_block_sender_transactions(&observer, alice_addr);
     let invalid_enable_tx_result = alice_txs
@@ -2702,16 +2714,29 @@ fn test_set_signer_key_auth() {
 
     let signer_txs = get_last_block_sender_transactions(&observer, signer_addr);
 
-    // // Print all signer transaction receipts
-    println!("signer_txs: {:?}", signer_txs);
-    for tx in signer_txs {
-        println!("txs in signer_tx? {:?}", tx.result);
-    }
+    let invalid_tx_period_result = signer_txs.clone()
+        .get(signer_invalid_period_nonce as usize)
+        .unwrap()
+        .result
+        .clone();
+
+    // Check for invalid lock period err
+    assert_eq!(invalid_tx_period_result, Value::error(Value::Int(2)).unwrap());
+
+    let invalid_tx_cycle_result = signer_txs.clone()
+        .get(signer_invalid_cycle_nonce as usize)
+        .unwrap()
+        .result
+        .clone();
+
+    // Check for invalid cycle err
+    assert_eq!(invalid_tx_cycle_result, Value::error(Value::Int(37)).unwrap());
+
     let signer_key_enabled = get_signer_key_authorization_pox_4(
         &mut peer,
         &latest_block,
         &pox_addr,
-        22,
+        current_reward_cycle.clone() as u64,
         &Pox4SignatureTopic::StackStx,
         lock_period.try_into().unwrap(),
         &signer_public_key,
@@ -2725,7 +2750,7 @@ fn test_set_signer_key_auth() {
     let enable_auth_tx = make_pox_4_set_signer_key_auth(
         &pox_addr,
         &signer_key,
-        22,
+        current_reward_cycle,
         &Pox4SignatureTopic::StackStx,
         lock_period,
         true,
@@ -2739,7 +2764,7 @@ fn test_set_signer_key_auth() {
         &mut peer,
         &latest_block,
         &pox_addr,
-        22,
+        current_reward_cycle.clone() as u64,
         &Pox4SignatureTopic::StackStx,
         lock_period.try_into().unwrap(),
         &signer_public_key,
@@ -2753,7 +2778,7 @@ fn test_set_signer_key_auth() {
     let disable_auth_tx = make_pox_4_set_signer_key_auth(
         &pox_addr,
         &signer_key,
-        22,
+        current_reward_cycle,
         &Pox4SignatureTopic::StackStx,
         lock_period,
         false,
@@ -2767,7 +2792,7 @@ fn test_set_signer_key_auth() {
         &mut peer,
         &latest_block,
         &pox_addr,
-        22,
+        current_reward_cycle.clone() as u64,
         &Pox4SignatureTopic::StackStx,
         lock_period.try_into().unwrap(),
         &signer_public_key,

From 37a681dc04c8e173d906b5e2d45efabb692ed482 Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Tue, 27 Feb 2024 07:28:35 -0500
Subject: [PATCH 0970/1166] formatter

---
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 33 ++++++++++++++-----
 1 file changed, 24 insertions(+), 9 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 0ddf9075c2..4f51b81e82 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -2678,9 +2678,9 @@ fn test_set_signer_key_auth() {
     signer_nonce += 1;
     // Test that confirmed reward cycle is at least current reward cycle
     let invalid_tx_cycle: StacksTransaction = make_pox_4_set_signer_key_auth(
-        &pox_addr, 
-        &signer_key, 
-        1, 
+        &pox_addr,
+        &signer_key,
+        1,
         &Pox4SignatureTopic::StackStx,
         1,
         false,
@@ -2700,8 +2700,15 @@ fn test_set_signer_key_auth() {
         None,
     );
 
-    let latest_block =
-        peer.tenure_with_txs(&[invalid_enable_tx, invalid_tx_period, invalid_tx_cycle, disable_auth_tx], &mut coinbase_nonce);
+    let latest_block = peer.tenure_with_txs(
+        &[
+            invalid_enable_tx,
+            invalid_tx_period,
+            invalid_tx_cycle,
+            disable_auth_tx,
+        ],
+        &mut coinbase_nonce,
+    );
 
     let alice_txs = get_last_block_sender_transactions(&observer, alice_addr);
     let invalid_enable_tx_result = alice_txs
@@ -2714,23 +2721,31 @@ fn test_set_signer_key_auth() {
 
     let signer_txs = get_last_block_sender_transactions(&observer, signer_addr);
 
-    let invalid_tx_period_result = signer_txs.clone()
+    let invalid_tx_period_result = signer_txs
+        .clone()
         .get(signer_invalid_period_nonce as usize)
         .unwrap()
         .result
         .clone();
 
     // Check for invalid lock period err
-    assert_eq!(invalid_tx_period_result, Value::error(Value::Int(2)).unwrap());
+    assert_eq!(
+        invalid_tx_period_result,
+        Value::error(Value::Int(2)).unwrap()
+    );
 
-    let invalid_tx_cycle_result = signer_txs.clone()
+    let invalid_tx_cycle_result = signer_txs
+        .clone()
         .get(signer_invalid_cycle_nonce as usize)
         .unwrap()
         .result
         .clone();
 
     // Check for invalid cycle err
-    assert_eq!(invalid_tx_cycle_result, Value::error(Value::Int(37)).unwrap());
+    assert_eq!(
+        invalid_tx_cycle_result,
+        Value::error(Value::Int(37)).unwrap()
+    );
 
     let signer_key_enabled = get_signer_key_authorization_pox_4(
         &mut peer,

From 5a54ae45a572403402846a762f5f869197afd546 Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Thu, 29 Feb 2024 08:18:45 -0500
Subject: [PATCH 0971/1166] remaining tests intact

---
 stackslib/src/chainstate/stacks/boot/pox-4.clar | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index 77c8ef2550..8ccf3567a2 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -117,6 +117,9 @@
 ;;    (6) (reward-cycle-to-burn-height (+ lock-period first-reward-cycle)) == (get unlock-height (stx-account stacker))
 ;;  These invariants only hold while `cur-reward-cycle < (+ lock-period first-reward-cycle)`
 ;;
+(define-map protocols principal (list 10000 uint))
+(define-map protocol-positions {protocol: principal, position-id: uint} {status: (string-ascii 32), collateral: uint})
+
 (define-map stacking-state
     { stacker: principal }
     {

From 8490fd9f999e3005b44644ff9ef6a3944daf52b4 Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Thu, 29 Feb 2024 10:17:55 -0500
Subject: [PATCH 0972/1166] removed throwaway

---
 stackslib/src/chainstate/stacks/boot/pox-4.clar | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index 8ccf3567a2..77c8ef2550 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -117,9 +117,6 @@
 ;;    (6) (reward-cycle-to-burn-height (+ lock-period first-reward-cycle)) == (get unlock-height (stx-account stacker))
 ;;  These invariants only hold while `cur-reward-cycle < (+ lock-period first-reward-cycle)`
 ;;
-(define-map protocols principal (list 10000 uint))
-(define-map protocol-positions {protocol: principal, position-id: uint} {status: (string-ascii 32), collateral: uint})
-
 (define-map stacking-state
     { stacker: principal }
     {

From 770ee39af0f41603a3c96152baad3d3c13d42b7e Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Thu, 29 Feb 2024 12:07:17 -0500
Subject: [PATCH 0973/1166] Round up thresholds using +0.9

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/signer.rs                    | 5 +++--
 testnet/stacks-node/src/nakamoto_node/miner.rs | 3 ++-
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index b92ed0e1de..42e57baf3e 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -156,8 +156,9 @@ impl From<SignerConfig> for Signer {
             .expect("FATAL: Too many registered signers to fit in a u32");
         let num_keys = u32::try_from(signer_config.registered_signers.public_keys.key_ids.len())
             .expect("FATAL: Too many key ids to fit in a u32");
-        let threshold = num_keys * 7 / 10;
-        let dkg_threshold = num_keys * 9 / 10;
+        // Always add +0.9 to force any remainder to round up to the next integer
+        let threshold = (num_keys * 7 + 9) / 10;
+        let dkg_threshold = (num_keys * 9 + 9) / 10;
 
         let coordinator_config = CoordinatorConfig {
             threshold,
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index 5186943197..9ebcb7856b 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -391,7 +391,8 @@ impl BlockMinerThread {
         let slot_ids = slot_ids_addresses.keys().cloned().collect::<Vec<_>>();
         // If more than a threshold percentage of the signers reject the block, we should not wait any further
         let weights: u64 = signer_weights.values().sum();
-        let rejection_threshold = weights / 10 * 7;
+        // Always add +0.9 to force any remainder to round up to the next integer
+        let rejection_threshold = (weights * 7 + 9) / 10;
         let mut rejections = HashSet::new();
         let mut rejections_weight: u64 = 0;
         let now = Instant::now();

From 206eca639fd0bf101f4e4f933af1fcf68062328a Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Thu, 29 Feb 2024 12:58:22 -0500
Subject: [PATCH 0974/1166] Cast to f64 and use ceil instead

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/signer.rs                    | 5 ++---
 testnet/stacks-node/src/nakamoto_node/miner.rs | 3 +--
 2 files changed, 3 insertions(+), 5 deletions(-)

diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index 42e57baf3e..27f42dd69f 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -156,9 +156,8 @@ impl From<SignerConfig> for Signer {
             .expect("FATAL: Too many registered signers to fit in a u32");
         let num_keys = u32::try_from(signer_config.registered_signers.public_keys.key_ids.len())
             .expect("FATAL: Too many key ids to fit in a u32");
-        // Always add +0.9 to force any remainder to round up to the next integer
-        let threshold = (num_keys * 7 + 9) / 10;
-        let dkg_threshold = (num_keys * 9 + 9) / 10;
+        let threshold = (num_keys as f64 * 7_f64 / 10_f64).ceil() as u32;
+        let dkg_threshold = (num_keys as f64 * 9_f64 / 10_f64).ceil() as u32;
 
         let coordinator_config = CoordinatorConfig {
             threshold,
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index 9ebcb7856b..ec57fc3ef7 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -391,8 +391,7 @@ impl BlockMinerThread {
         let slot_ids = slot_ids_addresses.keys().cloned().collect::<Vec<_>>();
         // If more than a threshold percentage of the signers reject the block, we should not wait any further
         let weights: u64 = signer_weights.values().sum();
-        // Always add +0.9 to force any remainder to round up to the next integer
-        let rejection_threshold = (weights * 7 + 9) / 10;
+        let rejection_threshold: u64 = (weights as f64 * 7_f64 / 10_f64).ceil() as u64;
         let mut rejections = HashSet::new();
         let mut rejections_weight: u64 = 0;
         let now = Instant::now();

From e00243f81f6e0d180b588d6368dfc3dbec0ac8fc Mon Sep 17 00:00:00 2001
From: wileyj <2847772+wileyj@users.noreply.github.com>
Date: Thu, 29 Feb 2024 11:42:26 -0800
Subject: [PATCH 0975/1166] conditionally exclude some crates when target os is
 windows or macos

---
 .../workflows/create-source-binary-x64.yml    | 78 -------------------
 clarity/Cargo.toml                            |  2 +-
 libsigner/Cargo.toml                          |  4 +-
 libstackerdb/Cargo.toml                       |  4 +-
 stacks-common/Cargo.toml                      |  4 +-
 stackslib/Cargo.toml                          |  6 +-
 stackslib/src/main.rs                         |  4 +-
 testnet/stacks-node/Cargo.toml                |  2 +-
 testnet/stacks-node/src/main.rs               |  4 +-
 9 files changed, 15 insertions(+), 93 deletions(-)
 delete mode 100644 .github/workflows/create-source-binary-x64.yml

diff --git a/.github/workflows/create-source-binary-x64.yml b/.github/workflows/create-source-binary-x64.yml
deleted file mode 100644
index a1b435aa5f..0000000000
--- a/.github/workflows/create-source-binary-x64.yml
+++ /dev/null
@@ -1,78 +0,0 @@
-## Github workflow to create multiarch binaries from source
-
-name: Create Binaries for x86_64
-
-on:
-  workflow_call:
-    inputs:
-      tag:
-        description: "Tag name of this release (x.y.z)"
-        required: true
-        type: string
-      arch:
-        description: "Stringified JSON object listing of platform matrix"
-        required: false
-        type: string
-        default: >-
-          ["linux-glibc-x64", "linux-musl-x64", "macos-x64", "windows-x64"]
-      cpu:
-        description: "Stringified JSON object listing of target CPU matrix"
-        required: false
-        type: string
-        default: >-
-          ["x86-64", "x86-64-v3"]
-
-## change the display name to the tag being built
-run-name: ${{ inputs.tag }}
-
-concurrency:
-  group: create-binary-${{ github.head_ref || github.ref || github.run_id}}
-  ## Only cancel in progress if this is for a PR
-  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
-
-jobs:
-  ## Runs when the following is true:
-  ##  - tag is provided
-  ##  - workflow is building default branch (master)
-  artifact:
-    if: |
-      inputs.tag != '' && 
-      github.ref == format('refs/heads/{0}', github.event.repository.default_branch)
-    name: Build Binaries
-    runs-on: ubuntu-latest
-    strategy:
-      ## Run a maximum of 10 builds concurrently, using the matrix defined in inputs.arch
-      max-parallel: 10
-      matrix:
-        platform: ${{ fromJson(inputs.arch) }}
-        cpu: ${{ fromJson(inputs.cpu) }}
-    steps:
-      ## Setup Docker for the builds
-      - name: Docker setup
-        uses: stacks-network/actions/docker@main
-
-      ## Build the binaries using defined dockerfiles
-      - name: Build Binary (${{ matrix.platform }}_${{ matrix.cpu }})
-        id: build_binaries
-        uses: docker/build-push-action@0565240e2d4ab88bba5387d719585280857ece09 # 5.0.0
-        with:
-          file: build-scripts/Dockerfile.${{ matrix.platform }}
-          outputs: type=local,dest=./release/${{ matrix.platform }}
-          build-args: |
-            STACKS_NODE_VERSION=${{ inputs.tag || env.GITHUB_SHA_SHORT }}
-            OS_ARCH=${{ matrix.platform }}
-            TARGET_CPU=${{ matrix.cpu }}
-            GIT_BRANCH=${{ env.GITHUB_REF_SHORT }}
-            GIT_COMMIT=${{ env.GITHUB_SHA_SHORT }}
-
-      ## Compress the binary artifact
-      - name: Compress artifact
-        id: compress_artifact
-        run: zip --junk-paths ${{ matrix.platform }}_${{ matrix.cpu }} ./release/${{ matrix.platform }}/*
-
-      ## Upload the binary artifact to the github action (used in `github-release.yml` to create a release)
-      - name: Upload artifact
-        id: upload_artifact
-        uses: actions/upload-artifact@a8a3f3ad30e3422c9c7b888a15615d19a852ae32 # v3.1.3
-        with:
-          path: ${{ matrix.platform }}_${{ matrix.cpu }}.zip
diff --git a/clarity/Cargo.toml b/clarity/Cargo.toml
index c0b82a7fd1..f6a5c70cbf 100644
--- a/clarity/Cargo.toml
+++ b/clarity/Cargo.toml
@@ -56,6 +56,6 @@ developer-mode = []
 slog_json = ["stacks_common/slog_json"]
 testing = []
 
-[target.'cfg(all(target_arch = "x86_64", not(target_env = "msvc")))'.dependencies]
+[target.'cfg(all(target_arch = "x86_64", not(any(target_os="windows"))))'.dependencies]
 sha2-asm = "0.5.3"
 
diff --git a/libsigner/Cargo.toml b/libsigner/Cargo.toml
index 4b1f21eef7..e04dcbbdc1 100644
--- a/libsigner/Cargo.toml
+++ b/libsigner/Cargo.toml
@@ -44,8 +44,8 @@ features = ["arbitrary_precision", "unbounded_depth"]
 version = "0.24.3"
 features = ["serde", "recovery"]
 
-[target.'cfg(all(any(target_arch = "x86_64", target_arch = "x86", target_arch = "aarch64"), not(target_env = "msvc")))'.dependencies]
+[target.'cfg(all(any(target_arch = "x86_64", target_arch = "x86", target_arch = "aarch64"), not(any(target_os="windows"))))'.dependencies]
 sha2 = { version = "0.10", features = ["asm"] }
 
-[target.'cfg(any(not(any(target_arch = "x86_64", target_arch = "x86", target_arch = "aarch64")), target_env = "msvc"))'.dependencies]
+[target.'cfg(any(not(any(target_arch = "x86_64", target_arch = "x86", target_arch = "aarch64")), any(target_os = "windows")))'.dependencies]
 sha2 = { version = "0.10" }
diff --git a/libstackerdb/Cargo.toml b/libstackerdb/Cargo.toml
index 53cf128edc..0d54de5428 100644
--- a/libstackerdb/Cargo.toml
+++ b/libstackerdb/Cargo.toml
@@ -26,8 +26,8 @@ clarity = { path = "../clarity" }
 version = "0.24.3"
 features = ["serde", "recovery"]
 
-[target.'cfg(all(any(target_arch = "x86_64", target_arch = "x86", target_arch = "aarch64"), not(target_env = "msvc")))'.dependencies]
+[target.'cfg(all(any(target_arch = "x86_64", target_arch = "x86", target_arch = "aarch64"), not(any(target_os="windows"))))'.dependencies]
 sha2 = { version = "0.10", features = ["asm"] }
 
-[target.'cfg(any(not(any(target_arch = "x86_64", target_arch = "x86", target_arch = "aarch64")), target_env = "msvc"))'.dependencies]
+[target.'cfg(any(not(any(target_arch = "x86_64", target_arch = "x86", target_arch = "aarch64")), any(target_os = "windows")))'.dependencies]
 sha2 = { version = "0.10" }
diff --git a/stacks-common/Cargo.toml b/stacks-common/Cargo.toml
index 50eadfb85d..d9f987f574 100644
--- a/stacks-common/Cargo.toml
+++ b/stacks-common/Cargo.toml
@@ -78,8 +78,8 @@ developer-mode = []
 slog_json = ["slog-json"]
 testing = []
 
-[target.'cfg(all(any(target_arch = "x86_64", target_arch = "x86", target_arch = "aarch64"), not(target_env = "msvc")))'.dependencies]
+[target.'cfg(all(any(target_arch = "x86_64", target_arch = "x86", target_arch = "aarch64"), not(any(target_os="windows"))))'.dependencies]
 sha2 = { version = "0.10", features = ["asm"] }
 
-[target.'cfg(any(not(any(target_arch = "x86_64", target_arch = "x86", target_arch = "aarch64")), target_env = "msvc"))'.dependencies]
+[target.'cfg(any(not(any(target_arch = "x86_64", target_arch = "x86", target_arch = "aarch64")), any(target_os="windows")))'.dependencies]
 sha2 = { version = "0.10" }
diff --git a/stackslib/Cargo.toml b/stackslib/Cargo.toml
index 8e2c483017..be75337115 100644
--- a/stackslib/Cargo.toml
+++ b/stackslib/Cargo.toml
@@ -59,7 +59,7 @@ siphasher = "0.3.7"
 wsts = { workspace = true }
 hashbrown = { workspace = true }
 
-[target.'cfg(not(target_env = "msvc"))'.dependencies]
+[target.'cfg(not(any(target_os = "macos",target_os="windows", target_arch = "arm" )))'.dependencies]
 tikv-jemallocator = {workspace = true}
 
 [target.'cfg(unix)'.dependencies]
@@ -114,8 +114,8 @@ monitoring_prom = ["prometheus"]
 slog_json = ["slog-json", "stacks-common/slog_json", "clarity/slog_json", "pox-locking/slog_json"]
 testing = []
 
-[target.'cfg(all(any(target_arch = "x86_64", target_arch = "x86", target_arch = "aarch64"), not(target_env = "msvc")))'.dependencies]
+[target.'cfg(all(any(target_arch = "x86_64", target_arch = "x86", target_arch = "aarch64"), not(any(target_os="windows"))))'.dependencies]
 sha2 = { version = "0.10", features = ["asm"] }
 
-[target.'cfg(any(not(any(target_arch = "x86_64", target_arch = "x86", target_arch = "aarch64")), target_env = "msvc"))'.dependencies]
+[target.'cfg(any(not(any(target_arch = "x86_64", target_arch = "x86", target_arch = "aarch64")), any(target_os="windows")))'.dependencies]
 sha2 = { version = "0.10" }
diff --git a/stackslib/src/main.rs b/stackslib/src/main.rs
index 652d9bf2dc..0e0f242b00 100644
--- a/stackslib/src/main.rs
+++ b/stackslib/src/main.rs
@@ -26,10 +26,10 @@ extern crate stacks_common;
 #[macro_use(o, slog_log, slog_trace, slog_debug, slog_info, slog_warn, slog_error)]
 extern crate slog;
 
-#[cfg(not(target_env = "msvc"))]
+#[cfg(not(any(target_os = "macos", target_os = "windows", target_arch = "arm")))]
 use tikv_jemallocator::Jemalloc;
 
-#[cfg(not(target_env = "msvc"))]
+#[cfg(not(any(target_os = "macos", target_os = "windows", target_arch = "arm")))]
 #[global_allocator]
 static GLOBAL: Jemalloc = Jemalloc;
 
diff --git a/testnet/stacks-node/Cargo.toml b/testnet/stacks-node/Cargo.toml
index 71f8808a12..72cc8d2491 100644
--- a/testnet/stacks-node/Cargo.toml
+++ b/testnet/stacks-node/Cargo.toml
@@ -32,7 +32,7 @@ rand = { workspace = true }
 rand_core = { workspace = true }
 hashbrown = { workspace = true }
 
-[target.'cfg(not(target_env = "msvc"))'.dependencies]
+[target.'cfg(not(any(target_os = "macos", target_os="windows", target_arch = "arm")))'.dependencies]
 tikv-jemallocator = {workspace = true}
 
 [dev-dependencies]
diff --git a/testnet/stacks-node/src/main.rs b/testnet/stacks-node/src/main.rs
index 29d1fde368..c636535353 100644
--- a/testnet/stacks-node/src/main.rs
+++ b/testnet/stacks-node/src/main.rs
@@ -43,7 +43,7 @@ use stacks::chainstate::coordinator::{get_next_recipients, OnChainRewardSetProvi
 use stacks::chainstate::stacks::address::PoxAddress;
 use stacks::chainstate::stacks::db::blocks::DummyEventDispatcher;
 use stacks::chainstate::stacks::db::StacksChainState;
-#[cfg(not(target_env = "msvc"))]
+#[cfg(not(any(target_os = "macos", target_os = "windows", target_arch = "arm")))]
 use tikv_jemallocator::Jemalloc;
 
 pub use self::burnchains::{
@@ -60,7 +60,7 @@ use crate::mockamoto::MockamotoNode;
 use crate::neon_node::{BlockMinerThread, TipCandidate};
 use crate::run_loop::boot_nakamoto;
 
-#[cfg(not(target_env = "msvc"))]
+#[cfg(not(any(target_os = "macos", target_os = "windows", target_arch = "arm")))]
 #[global_allocator]
 static GLOBAL: Jemalloc = Jemalloc;
 

From cef2c2feeb2f150f50326c54ba4402cbbb4ff228 Mon Sep 17 00:00:00 2001
From: wileyj <2847772+wileyj@users.noreply.github.com>
Date: Thu, 29 Feb 2024 11:43:49 -0800
Subject: [PATCH 0976/1166] update binary build dockerfiles to set RUSTFLAG if
 target-cpu is provided

---
 build-scripts/Dockerfile.linux-glibc-arm64 | 3 ++-
 build-scripts/Dockerfile.linux-glibc-armv7 | 3 ++-
 build-scripts/Dockerfile.linux-glibc-x64   | 6 +++---
 build-scripts/Dockerfile.linux-musl-arm64  | 5 ++---
 build-scripts/Dockerfile.linux-musl-armv7  | 4 ++--
 build-scripts/Dockerfile.linux-musl-x64    | 8 ++++----
 build-scripts/Dockerfile.macos-arm64       | 5 ++---
 build-scripts/Dockerfile.macos-x64         | 9 ++++-----
 build-scripts/Dockerfile.windows-x64       | 8 ++++----
 9 files changed, 25 insertions(+), 26 deletions(-)

diff --git a/build-scripts/Dockerfile.linux-glibc-arm64 b/build-scripts/Dockerfile.linux-glibc-arm64
index 11e38f8804..2e0587bac6 100644
--- a/build-scripts/Dockerfile.linux-glibc-arm64
+++ b/build-scripts/Dockerfile.linux-glibc-arm64
@@ -21,6 +21,7 @@ RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
     cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli \
     && mkdir -p /out \
     && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
+# --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli 
 
 FROM scratch AS export-stage
-COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
+COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
\ No newline at end of file
diff --git a/build-scripts/Dockerfile.linux-glibc-armv7 b/build-scripts/Dockerfile.linux-glibc-armv7
index cc05298dfe..c28ca7d972 100644
--- a/build-scripts/Dockerfile.linux-glibc-armv7
+++ b/build-scripts/Dockerfile.linux-glibc-armv7
@@ -21,6 +21,7 @@ RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
     cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli \
     && mkdir -p /out \
     && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
+# --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli 
 
 FROM scratch AS export-stage
-COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
+COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
\ No newline at end of file
diff --git a/build-scripts/Dockerfile.linux-glibc-x64 b/build-scripts/Dockerfile.linux-glibc-x64
index 0e2bbdd9be..19f2f89c93 100644
--- a/build-scripts/Dockerfile.linux-glibc-x64
+++ b/build-scripts/Dockerfile.linux-glibc-x64
@@ -7,6 +7,7 @@ ARG BUILD_DIR=/build
 ARG TARGET=x86_64-unknown-linux-gnu
 # Allow us to override the default `--target-cpu` for the given target triplet
 ARG TARGET_CPU
+ENV RUSTFLAGS="${TARGET_CPU:+${RUSTFLAGS} -Ctarget-cpu=${TARGET_CPU}}"
 WORKDIR /src
 
 COPY . .
@@ -17,10 +18,9 @@ RUN apt-get update && apt-get install -y git
 RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
     && cd ${BUILD_DIR} \
     && rustup target add ${TARGET} \
-    ${TARGET_CPU:+RUSTFLAGS="$RUSTFLAGS $TARGET_CPU"} \
-    cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli \
+    && cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli \
     && mkdir -p /out \
     && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
 
 FROM scratch AS export-stage
-COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
+COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
\ No newline at end of file
diff --git a/build-scripts/Dockerfile.linux-musl-arm64 b/build-scripts/Dockerfile.linux-musl-arm64
index 24a07f018a..43b1b8e338 100644
--- a/build-scripts/Dockerfile.linux-musl-arm64
+++ b/build-scripts/Dockerfile.linux-musl-arm64
@@ -16,7 +16,6 @@ RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
     && cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli \
     && mkdir -p /out \
     && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
-
+#  --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli
 FROM scratch AS export-stage
-COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
-
+COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
\ No newline at end of file
diff --git a/build-scripts/Dockerfile.linux-musl-armv7 b/build-scripts/Dockerfile.linux-musl-armv7
index 2ce5a99912..c7ba40b4c4 100644
--- a/build-scripts/Dockerfile.linux-musl-armv7
+++ b/build-scripts/Dockerfile.linux-musl-armv7
@@ -16,6 +16,6 @@ RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
     && cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli \
     && mkdir -p /out \
     && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
-
+#  --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli
 FROM scratch AS export-stage
-COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
+COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
\ No newline at end of file
diff --git a/build-scripts/Dockerfile.linux-musl-x64 b/build-scripts/Dockerfile.linux-musl-x64
index d954708a0a..f1df24a537 100644
--- a/build-scripts/Dockerfile.linux-musl-x64
+++ b/build-scripts/Dockerfile.linux-musl-x64
@@ -5,20 +5,20 @@ ARG GIT_BRANCH='No Branch Info'
 ARG GIT_COMMIT='No Commit Info'
 ARG BUILD_DIR=/build
 ARG TARGET=x86_64-unknown-linux-musl
-# Allow us to override the default `--target-cpu` for the given target triplet
 ARG TARGET_CPU
+ENV RUSTFLAGS="${TARGET_CPU:+${RUSTFLAGS} -Ctarget-cpu=${TARGET_CPU}}"
 WORKDIR /src
 
 COPY . .
 
-RUN apk update && apk add git musl-dev
+RUN echo "RUSTFLAGS: ${RUSTFLAGS}"
+RUN apk update && apk add git musl-dev make
 
 # Run all the build steps in ramdisk in an attempt to speed things up
 RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
     && cd ${BUILD_DIR} \
     && rustup target add ${TARGET} \
-    ${TARGET_CPU:+RUSTFLAGS="$RUSTFLAGS $TARGET_CPU"} \
-    cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli \
+    && cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli \
     && mkdir -p /out \
     && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
 
diff --git a/build-scripts/Dockerfile.macos-arm64 b/build-scripts/Dockerfile.macos-arm64
index 0fd8a1e4c3..8f5c92d4f8 100644
--- a/build-scripts/Dockerfile.macos-arm64
+++ b/build-scripts/Dockerfile.macos-arm64
@@ -24,7 +24,6 @@ RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
     && cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli \
     && mkdir -p /out \
     && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
-
+# --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli 
 FROM scratch AS export-stage
-COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
-
+COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
\ No newline at end of file
diff --git a/build-scripts/Dockerfile.macos-x64 b/build-scripts/Dockerfile.macos-x64
index f61d0574e9..ca14012717 100644
--- a/build-scripts/Dockerfile.macos-x64
+++ b/build-scripts/Dockerfile.macos-x64
@@ -7,6 +7,7 @@ ARG BUILD_DIR=/build
 ARG OSXCROSS="https://github.com/hirosystems/docker-osxcross-rust/releases/download/MacOSX12.0.sdk/osxcross-d904031_MacOSX12.0.sdk.tar.zst"
 ARG TARGET=x86_64-apple-darwin
 ARG TARGET_CPU
+ENV RUSTFLAGS="${TARGET_CPU:+${RUSTFLAGS} -Ctarget-cpu=${TARGET_CPU}}"
 WORKDIR /src
 
 COPY . .
@@ -22,11 +23,9 @@ RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
     && cd ${BUILD_DIR} \
     && rustup target add ${TARGET} \
     && . /opt/osxcross/env-macos-x86_64 \
-    ${TARGET_CPU:+RUSTFLAGS="$RUSTFLAGS $TARGET_CPU"} \
-    cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli \
+    && cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli \
     && mkdir -p /out \
     && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
-
+# --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli 
 FROM scratch AS export-stage
-COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
-
+COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
\ No newline at end of file
diff --git a/build-scripts/Dockerfile.windows-x64 b/build-scripts/Dockerfile.windows-x64
index 3265c05b5c..b7fc4c8f7b 100644
--- a/build-scripts/Dockerfile.windows-x64
+++ b/build-scripts/Dockerfile.windows-x64
@@ -6,11 +6,12 @@ ARG GIT_COMMIT='No Commit Info'
 ARG BUILD_DIR=/build
 ARG TARGET=x86_64-pc-windows-gnu
 ARG TARGET_CPU
+ENV RUSTFLAGS="${TARGET_CPU:+${RUSTFLAGS} -Ctarget-cpu=${TARGET_CPU}}"
 WORKDIR /src
 
 COPY . .
 
-RUN apt-get update && apt-get install -y git gcc-mingw-w64-x86-64
+RUN apt-get update && apt-get install -y git gcc-mingw-w64-x86-64 libclang-dev
 
 # Run all the build steps in ramdisk in an attempt to speed things up
 RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
@@ -18,10 +19,9 @@ RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
     && rustup target add ${TARGET} \
     && CC_x86_64_pc_windows_gnu=x86_64-w64-mingw32-gcc \
     CARGO_TARGET_X86_64_PC_WINDOWS_GNU_LINKER=x86_64-w64-mingw32-gcc \
-    ${TARGET_CPU:+RUSTFLAGS="$RUSTFLAGS $TARGET_CPU"} \
     cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli \
     && mkdir -p /out \
     && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
-
+# --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli
 FROM scratch AS export-stage
-COPY --from=build /out/stacks-inspect.exe /out/blockstack-cli.exe /out/clarity-cli.exe /out/stacks-node.exe /
+COPY --from=build /out/stacks-inspect.exe /out/blockstack-cli.exe /out/clarity-cli.exe /out/stacks-node.exe /
\ No newline at end of file

From 3a648be0739aed5e29985ddbf5fe717806bce1a1 Mon Sep 17 00:00:00 2001
From: wileyj <2847772+wileyj@users.noreply.github.com>
Date: Thu, 29 Feb 2024 11:47:06 -0800
Subject: [PATCH 0977/1166] update workflows to support building x86-64-v3
 binaries, and using glibc-x86-64-v3 arch as default for images

---
 .github/workflows/create-source-binary.yml | 68 +++++++++++++++++-----
 .github/workflows/github-release.yml       | 17 ------
 .github/workflows/image-build-binary.yml   | 31 +++++-----
 .github/workflows/image-build-source.yml   | 11 ++++
 .github/workflows/stacks-core-tests.yml    |  1 -
 5 files changed, 83 insertions(+), 45 deletions(-)

diff --git a/.github/workflows/create-source-binary.yml b/.github/workflows/create-source-binary.yml
index 068170efc5..d0cff1cde6 100644
--- a/.github/workflows/create-source-binary.yml
+++ b/.github/workflows/create-source-binary.yml
@@ -9,12 +9,6 @@ on:
         description: "Tag name of this release (x.y.z)"
         required: true
         type: string
-      arch:
-        description: "Stringified JSON object listing of platform matrix"
-        required: false
-        type: string
-        default: >-
-          ["linux-glibc-arm64", "linux-glibc-armv7", "linux-musl-arm64", "linux-musl-armv7"]
 
 ## change the display name to the tag being built
 run-name: ${{ inputs.tag }}
@@ -30,7 +24,7 @@ jobs:
   ##  - workflow is building default branch (master)
   artifact:
     if: |
-      inputs.tag != '' && 
+      inputs.tag != '' &&
       github.ref == format('refs/heads/{0}', github.event.repository.default_branch)
     name: Build Binaries
     runs-on: ubuntu-latest
@@ -38,33 +32,79 @@ jobs:
       ## Run a maximum of 10 builds concurrently, using the matrix defined in inputs.arch
       max-parallel: 10
       matrix:
-        platform: ${{ fromJson(inputs.arch) }}
+        arch:
+          - linux-musl
+          - linux-glibc
+          - macos
+          - windows
+        cpu:
+          - arm64
+          - armv7
+          - x86-64
+          - x86-64-v3
+        exclude:
+          - arch: windows # excludes windows-arm64
+            cpu: arm64
+          - arch: windows # excludes windows-armv7
+            cpu: armv7
+          - arch: macos # excludes macos-armv7
+            cpu: armv7
+
     steps:
       ## Setup Docker for the builds
       - name: Docker setup
+        id: docker_setup
         uses: stacks-network/actions/docker@main
 
+      - name: Set Local env vars
+        id: set_envars
+        run: |
+          case ${{ matrix.cpu }} in
+              x86-64)
+                  TARGET_CPU="${{ matrix.cpu }}"
+                  DOCKERFILE_CPU="x64"
+                  ARCHIVE_NAME="x64"
+                  ;;
+              x86-64-v3)
+                  TARGET_CPU="${{ matrix.cpu }}"
+                  DOCKERFILE_CPU="x64"
+                  ARCHIVE_NAME="x64-v3"
+                  ;;
+              *)
+                  TARGET_CPU=""
+                  DOCKERFILE_CPU="${{ matrix.cpu }}"
+                  ARCHIVE_NAME="${{ matrix.cpu }}"
+                  ;;
+          esac
+          echo "DOCKERFILE=Dockerfile.${{ matrix.arch }}-${DOCKERFILE_CPU}" >> "$GITHUB_ENV"
+          echo "ZIPFILE=${{ matrix.arch }}-${ARCHIVE_NAME}" >> "$GITHUB_ENV"
+          echo "TARGET_CPU=${TARGET_CPU}" >> "$GITHUB_ENV"
+          echo "DOCKERFILE: ${DOCKERFILE}"
+          echo "ZIPFILE: ${ZIPFILE}"
+          echo "TARGET_CPU: ${TARGET_CPU}"
+
       ## Build the binaries using defined dockerfiles
-      - name: Build Binary (${{ matrix.platform }})
+      - name: Build Binary (${{ matrix.arch }}_${{ matrix.cpu }})
         id: build_binaries
         uses: docker/build-push-action@0565240e2d4ab88bba5387d719585280857ece09 # 5.0.0
         with:
-          file: build-scripts/Dockerfile.${{ matrix.platform }}
-          outputs: type=local,dest=./release/${{ matrix.platform }}
+          file: build-scripts/${{ env.DOCKERFILE }}
+          outputs: type=local,dest=./release/${{ matrix.arch }}
           build-args: |
             STACKS_NODE_VERSION=${{ inputs.tag || env.GITHUB_SHA_SHORT }}
-            OS_ARCH=${{ matrix.platform }}
+            OS_ARCH=${{ matrix.arch }}
+            TARGET_CPU=${{ env.TARGET_CPU }}
             GIT_BRANCH=${{ env.GITHUB_REF_SHORT }}
             GIT_COMMIT=${{ env.GITHUB_SHA_SHORT }}
 
       ## Compress the binary artifact
       - name: Compress artifact
         id: compress_artifact
-        run: zip --junk-paths ${{ matrix.platform }} ./release/${{ matrix.platform }}/*
+        run: zip --junk-paths ${{ env.ZIPFILE }} ./release/${{ matrix.arch }}/*
 
       ## Upload the binary artifact to the github action (used in `github-release.yml` to create a release)
       - name: Upload artifact
         id: upload_artifact
         uses: actions/upload-artifact@a8a3f3ad30e3422c9c7b888a15615d19a852ae32 # v3.1.3
         with:
-          path: ${{ matrix.platform }}.zip
+          path: ${{ env.ZIPFILE }}.zip
diff --git a/.github/workflows/github-release.yml b/.github/workflows/github-release.yml
index 17d75b2d0e..14e7117a95 100644
--- a/.github/workflows/github-release.yml
+++ b/.github/workflows/github-release.yml
@@ -36,21 +36,6 @@ jobs:
       tag: ${{ inputs.tag }}
     secrets: inherit
 
-  ## Build x86_64 binaries from source
-  ##
-  ## Runs when the following is true:
-  ##  - tag is provided
-  ##  - workflow is building default branch (master)
-  build-binaries-x64:
-    if: |
-      inputs.tag != '' && 
-      github.ref == format('refs/heads/{0}', github.event.repository.default_branch)
-    name: Build Binaries (x64_64)
-    uses: ./.github/workflows/create-source-binary-x64.yml
-    with:
-      tag: ${{ inputs.tag }}
-    secrets: inherit
-
   ## Runs when the following is true:
   ##  - tag is provided
   ##  - workflow is building default branch (master)
@@ -62,7 +47,6 @@ jobs:
     runs-on: ubuntu-latest
     needs:
       - build-binaries
-      - build-binaries-x64
     steps:
       ## Downloads the artifacts built in `create-source-binary.yml`
       - name: Download Artifacts
@@ -111,7 +95,6 @@ jobs:
     uses: ./.github/workflows/image-build-binary.yml
     needs:
       - build-binaries
-      - build-binaries-x64
       - create-release
     with:
       tag: ${{ inputs.tag }}
diff --git a/.github/workflows/image-build-binary.yml b/.github/workflows/image-build-binary.yml
index cab5ff162b..11a1012188 100644
--- a/.github/workflows/image-build-binary.yml
+++ b/.github/workflows/image-build-binary.yml
@@ -8,12 +8,7 @@ on:
       tag:
         required: true
         type: string
-        description: "Version tag for alpine images"
-      docker-org:
-        required: false
-        type: string
-        description: "Docker repo org for uploading images (defaults to github org)"
-        default: "${GITHUB_REPOSITORY_OWNER}"
+        description: "Version tag for docker images"
 
 ## Define which docker arch to build for
 env:
@@ -48,14 +43,24 @@ jobs:
     steps:
       ## Setup Docker for the builds
       - name: Docker setup
+        id: docker_setup
         uses: stacks-network/actions/docker@main
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_PASSWORD }}
 
+      ## if the repo owner is not `stacks-network`, default to a docker-org of the repo owner (i.e. github user id)
+      ## this allows forks to run the docker push workflows without having to hardcode a dockerhub org (but it does require docker hub user to match github username)
+      - name: Set Local env vars
+        id: set_envars
+        if: |
+          github.repository_owner != 'stacks-network'
+        run: |
+          echo "docker-org=${{ github.repository_owner }}" >> "$GITHUB_ENV"
+
       ## Set docker metatdata
       ## - depending on the matrix.dist, different tags will be enabled
-      ## ex. alpine will have this tag: `type=ref,event=tag,enable=${{ matrix.dist == 'alpine' }}`
+      ## ex. debian will have this tag: `type=ref,event=tag,enable=${{ matrix.dist == 'debian' }}`
       - name: Docker Metadata ( ${{matrix.dist}} )
         id: docker_metadata
         uses: docker/metadata-action@96383f45573cb7f253c731d3b3ab81c87ef81934 #v5.0.0
@@ -64,12 +69,12 @@ jobs:
             ${{env.docker-org}}/${{ github.event.repository.name }}
             ${{env.docker-org}}/stacks-blockchain
           tags: |
-            type=raw,value=latest,enable=${{ inputs.tag != '' && (github.ref == format('refs/heads/{0}', github.event.repository.default_branch) ) && matrix.dist == 'alpine' }}
-            type=raw,value=${{ inputs.tag }}-${{ matrix.dist }},enable=${{ inputs.tag != '' && matrix.dist == 'alpine'}}
-            type=raw,value=${{ inputs.tag }},enable=${{ inputs.tag != '' && matrix.dist == 'alpine' }}
-            type=ref,event=tag,enable=${{ matrix.dist == 'alpine' }}
-            type=raw,value=latest-${{ matrix.dist }},enable=${{ inputs.tag != '' && (github.ref == format('refs/heads/{0}', github.event.repository.default_branch) ) && matrix.dist == 'debian' }}
-            type=raw,value=${{ inputs.tag }}-${{ matrix.dist }},enable=${{ inputs.tag != '' && matrix.dist == 'debian' }}
+            type=raw,value=latest,enable=${{ inputs.tag != '' && (github.ref == format('refs/heads/{0}', github.event.repository.default_branch) ) && matrix.dist == 'debian' }}
+            type=raw,value=${{ inputs.tag }}-${{ matrix.dist }},enable=${{ inputs.tag != '' && matrix.dist == 'debian'}}
+            type=raw,value=${{ inputs.tag }},enable=${{ inputs.tag != '' && matrix.dist == 'debian' }}
+            type=ref,event=tag,enable=${{ matrix.dist == 'debian' }}
+            type=raw,value=latest-${{ matrix.dist }},enable=${{ inputs.tag != '' && (github.ref == format('refs/heads/{0}', github.event.repository.default_branch) ) && matrix.dist == 'alpine' }}
+            type=raw,value=${{ inputs.tag }}-${{ matrix.dist }},enable=${{ inputs.tag != '' && matrix.dist == 'alpine' }}
 
       ## Build docker image for release
       - name: Build and Push ( ${{matrix.dist}} )
diff --git a/.github/workflows/image-build-source.yml b/.github/workflows/image-build-source.yml
index 1936999b27..c2609caf37 100644
--- a/.github/workflows/image-build-source.yml
+++ b/.github/workflows/image-build-source.yml
@@ -31,11 +31,21 @@ jobs:
     steps:
       ## Setup Docker for the builds
       - name: Docker setup
+        id: docker_setup
         uses: stacks-network/actions/docker@main
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_PASSWORD }}
 
+      ## if the repo owner is not `stacks-network`, default to a docker-org of the repo owner (i.e. github user id)
+      ## this allows forks to run the docker push workflows without having to hardcode a dockerhub org (but it does require docker hub user to match github username)
+      - name: Set Local env vars
+        id: set_envars
+        if: |
+          github.repository_owner != 'stacks-network'
+        run: |
+          echo "docker-org=${{ github.repository_owner }}" >> "$GITHUB_ENV"
+
       ## Set docker metatdata
       - name: Docker Metadata ( ${{matrix.dist}} )
         id: docker_metadata
@@ -62,4 +72,5 @@ jobs:
             STACKS_NODE_VERSION=${{ env.GITHUB_SHA_SHORT }}
             GIT_BRANCH=${{ env.GITHUB_REF_SHORT }}
             GIT_COMMIT=${{ env.GITHUB_SHA_SHORT }}
+            TARGET_CPU=x86-64-v3
           push: ${{ env.DOCKER_PUSH }}
diff --git a/.github/workflows/stacks-core-tests.yml b/.github/workflows/stacks-core-tests.yml
index 1e883d3d96..7e16bd5b22 100644
--- a/.github/workflows/stacks-core-tests.yml
+++ b/.github/workflows/stacks-core-tests.yml
@@ -166,7 +166,6 @@ jobs:
 
   # Core contract tests on Clarinet v1
   # Check for false positives/negatives
-  # https://github.com/stacks-network/stacks-blockchain/pull/4031#pullrequestreview-1713341208
   core-contracts-clarinet-test-clarinet-v1:
     name: Core Contracts Test Clarinet V1
     runs-on: ubuntu-latest

From 886b426414f40d04d7434a0a48810614542cc2a3 Mon Sep 17 00:00:00 2001
From: wileyj <2847772+wileyj@users.noreply.github.com>
Date: Thu, 29 Feb 2024 11:47:57 -0800
Subject: [PATCH 0978/1166] cleanup, add target-cpu arg for source builds

---
 .github/actions/dockerfiles/Dockerfile.alpine-binary | 5 ++---
 .github/actions/dockerfiles/Dockerfile.debian-binary | 9 ++++-----
 .github/actions/dockerfiles/Dockerfile.debian-source | 3 +++
 3 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/.github/actions/dockerfiles/Dockerfile.alpine-binary b/.github/actions/dockerfiles/Dockerfile.alpine-binary
index 2388ffa031..61151f0d2a 100644
--- a/.github/actions/dockerfiles/Dockerfile.alpine-binary
+++ b/.github/actions/dockerfiles/Dockerfile.alpine-binary
@@ -10,13 +10,12 @@ ARG TARGETVARIANT
 ARG REPO=stacks-network/stacks-core
 
 RUN case ${TARGETARCH} in \
-    "amd64")  BIN_ARCH=linux-musl-x64  ;; \
+    "amd64")  BIN_ARCH=linux-musl-x64-v3  ;; \
     "arm64")  BIN_ARCH=linux-musl-arm64  ;; \
     "arm")  BIN_ARCH=linux-musl-armv7  ;; \
     "*") exit 1 ;; \
     esac \
-    && echo "wget  -q https://github.com/${REPO}/releases/download/${TAG}/${BIN_ARCH}.zip -O /${BIN_ARCH}.zip" \
-    && wget  -q https://github.com/${REPO}/releases/download/${TAG}/${BIN_ARCH}.zip -O /${BIN_ARCH}.zip \
+    && wget -q https://github.com/${REPO}/releases/download/${TAG}/${BIN_ARCH}.zip -O /${BIN_ARCH}.zip \
     && unzip ${BIN_ARCH}.zip -d /out
 
 FROM --platform=${TARGETPLATFORM} alpine
diff --git a/.github/actions/dockerfiles/Dockerfile.debian-binary b/.github/actions/dockerfiles/Dockerfile.debian-binary
index 4cec3c4391..7bfd252c04 100644
--- a/.github/actions/dockerfiles/Dockerfile.debian-binary
+++ b/.github/actions/dockerfiles/Dockerfile.debian-binary
@@ -10,13 +10,12 @@ ARG TARGETVARIANT
 ARG REPO=stacks-network/stacks-core
 
 RUN case ${TARGETARCH} in \
-    "amd64")  BIN_ARCH=linux-musl-x64  ;; \
-    "arm64")  BIN_ARCH=linux-musl-arm64  ;; \
-    "arm")  BIN_ARCH=linux-musl-armv7  ;; \
+    "amd64")  BIN_ARCH=linux-glibc-x64-v3  ;; \
+    "arm64")  BIN_ARCH=linux-glibc-arm64  ;; \
+    "arm")  BIN_ARCH=linux-glibc-armv7  ;; \
     "*") exit 1 ;; \
     esac \
-    && echo "wget  -q https://github.com/${REPO}/releases/download/${TAG}/${BIN_ARCH}.zip -O /${BIN_ARCH}.zip" \
-    && wget  -q https://github.com/${REPO}/releases/download/${TAG}/${BIN_ARCH}.zip -O /${BIN_ARCH}.zip \
+    && wget -q https://github.com/${REPO}/releases/download/${TAG}/${BIN_ARCH}.zip -O /${BIN_ARCH}.zip \
     && unzip ${BIN_ARCH}.zip -d /out
 
 FROM --platform=${TARGETPLATFORM} debian:bookworm
diff --git a/.github/actions/dockerfiles/Dockerfile.debian-source b/.github/actions/dockerfiles/Dockerfile.debian-source
index cbdcb9dcda..34ab555018 100644
--- a/.github/actions/dockerfiles/Dockerfile.debian-source
+++ b/.github/actions/dockerfiles/Dockerfile.debian-source
@@ -5,6 +5,9 @@ ARG GIT_BRANCH='No Branch Info'
 ARG GIT_COMMIT='No Commit Info'
 ARG BUILD_DIR=/build
 ARG TARGET=x86_64-unknown-linux-gnu
+# Allow us to override the default `--target-cpu` for the given target triplet
+ARG TARGET_CPU
+ENV RUSTFLAGS="${TARGET_CPU:+${RUSTFLAGS} -Ctarget-cpu=${TARGET_CPU}}"
 WORKDIR /src
 
 COPY . .

From 04d2f7002b600021bc939cca7d14956cefb6394f Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Thu, 29 Feb 2024 14:42:41 -0800
Subject: [PATCH 0979/1166] feat: validate amount with signer key
 authorizations

---
 stacks-signer/src/cli.rs                      |   6 +
 stacks-signer/src/main.rs                     |  24 +-
 .../chainstate/nakamoto/coordinator/tests.rs  |   4 +
 stackslib/src/chainstate/stacks/boot/mod.rs   |  20 ++
 .../src/chainstate/stacks/boot/pox-4.clar     | 130 ++++++--
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 313 ++++++++++++++++--
 stackslib/src/net/tests/mod.rs                |   4 +
 .../src/util_lib/signed_structured_data.rs    |  71 +++-
 testnet/stacks-node/src/mockamoto.rs          |   8 +
 .../src/tests/nakamoto_integrations.rs        |  12 +
 10 files changed, 528 insertions(+), 64 deletions(-)

diff --git a/stacks-signer/src/cli.rs b/stacks-signer/src/cli.rs
index 639b57f3a2..8430bfe319 100644
--- a/stacks-signer/src/cli.rs
+++ b/stacks-signer/src/cli.rs
@@ -236,6 +236,12 @@ pub struct GenerateStackingSignatureArgs {
     /// Use `1` for stack-aggregation-commit
     #[arg(long)]
     pub period: u64,
+    /// The max amount of uSTX that can be used in this unique transaction
+    #[arg(long)]
+    pub max_amount: u128,
+    /// A unique identifier to prevent re-using this authorization
+    #[arg(long)]
+    pub auth_id: u128,
 }
 
 /// Parse the contract ID
diff --git a/stacks-signer/src/main.rs b/stacks-signer/src/main.rs
index e59722dd53..0cc67e56ca 100644
--- a/stacks-signer/src/main.rs
+++ b/stacks-signer/src/main.rs
@@ -315,6 +315,8 @@ fn handle_generate_stacking_signature(
         args.method.topic(),
         config.network.to_chain_id(),
         args.period.into(),
+        args.max_amount,
+        args.auth_id,
     )
     .expect("Failed to generate signature");
 
@@ -403,11 +405,14 @@ pub mod tests {
         lock_period: u128,
         public_key: &Secp256k1PublicKey,
         signature: Vec<u8>,
+        amount: u128,
+        max_amount: u128,
+        auth_id: u128,
     ) -> bool {
         let program = format!(
             r#"
             {}
-            (verify-signer-key-sig {} u{} "{}" u{} (some 0x{}) 0x{})
+            (verify-signer-key-sig {} u{} "{}" u{} (some 0x{}) 0x{} u{} u{} u{})
         "#,
             &*POX_4_CODE,                                               //s
             Value::Tuple(pox_addr.clone().as_clarity_tuple().unwrap()), //p
@@ -416,6 +421,9 @@ pub mod tests {
             lock_period,
             to_hex(signature.as_slice()),
             to_hex(public_key.to_bytes_compressed().as_slice()),
+            amount,
+            max_amount,
+            auth_id,
         );
         execute_v2(&program)
             .expect("FATAL: could not execute program")
@@ -436,6 +444,8 @@ pub mod tests {
             reward_cycle: 6,
             method: Pox4SignatureTopic::StackStx.into(),
             period: 12,
+            max_amount: u128::MAX,
+            auth_id: 1,
         };
 
         let signature = handle_generate_stacking_signature(args.clone(), false);
@@ -448,6 +458,9 @@ pub mod tests {
             args.period.into(),
             &public_key,
             signature.to_rsv(),
+            100,
+            args.max_amount,
+            args.auth_id,
         );
         assert!(valid);
 
@@ -455,6 +468,8 @@ pub mod tests {
         args.period = 6;
         args.method = Pox4SignatureTopic::AggregationCommit.into();
         args.reward_cycle = 7;
+        args.auth_id = 2;
+        args.max_amount = 100;
 
         let signature = handle_generate_stacking_signature(args.clone(), false);
         let public_key = Secp256k1PublicKey::from_private(&config.stacks_private_key);
@@ -466,6 +481,9 @@ pub mod tests {
             args.period.into(),
             &public_key,
             signature.to_rsv(),
+            100,
+            args.max_amount,
+            args.auth_id,
         );
         assert!(valid);
     }
@@ -480,6 +498,8 @@ pub mod tests {
             reward_cycle: 6,
             method: Pox4SignatureTopic::StackStx.into(),
             period: 12,
+            max_amount: u128::MAX,
+            auth_id: 1,
         };
 
         let signature = handle_generate_stacking_signature(args.clone(), false);
@@ -492,6 +512,8 @@ pub mod tests {
             &Pox4SignatureTopic::StackStx,
             CHAIN_ID_TESTNET,
             args.period.into(),
+            args.max_amount,
+            args.auth_id,
         );
 
         let verify_result = public_key.verify(&message_hash.0, &signature);
diff --git a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
index 721149789a..f2dcfe4c18 100644
--- a/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
+++ b/stackslib/src/chainstate/nakamoto/coordinator/tests.rs
@@ -97,6 +97,8 @@ fn advance_to_nakamoto(
                         6,
                         &Pox4SignatureTopic::StackStx,
                         12_u128,
+                        u128::MAX,
+                        1,
                     );
                     let signing_key =
                         StacksPublicKey::from_private(&test_stacker.signer_private_key);
@@ -109,6 +111,8 @@ fn advance_to_nakamoto(
                         &signing_key,
                         34,
                         Some(signature),
+                        u128::MAX,
+                        1,
                     )
                 })
                 .collect()
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index abba9be6c7..59c18a1c55 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -1845,6 +1845,8 @@ pub mod test {
         signer_key: &StacksPublicKey,
         burn_ht: u64,
         signature_opt: Option<Vec<u8>>,
+        max_amount: u128,
+        auth_id: u128,
     ) -> StacksTransaction {
         let addr_tuple = Value::Tuple(addr.as_clarity_tuple().unwrap());
         let signature = match signature_opt {
@@ -1862,6 +1864,8 @@ pub mod test {
                 Value::UInt(lock_period),
                 signature,
                 Value::buff_from(signer_key.to_bytes_compressed()).unwrap(),
+                Value::UInt(max_amount),
+                Value::UInt(auth_id),
             ],
         )
         .unwrap();
@@ -2005,6 +2009,8 @@ pub mod test {
         lock_period: u128,
         signer_key: StacksPublicKey,
         signature_opt: Option<Vec<u8>>,
+        max_amount: u128,
+        auth_id: u128,
     ) -> StacksTransaction {
         let addr_tuple = Value::Tuple(addr.as_clarity_tuple().unwrap());
         let signature = match signature_opt {
@@ -2020,6 +2026,8 @@ pub mod test {
                 addr_tuple,
                 signature,
                 Value::buff_from(signer_key.to_bytes_compressed()).unwrap(),
+                Value::UInt(max_amount),
+                Value::UInt(auth_id),
             ],
         )
         .unwrap();
@@ -2114,6 +2122,8 @@ pub mod test {
         reward_cycle: u128,
         signature_opt: Option<Vec<u8>>,
         signer_key: &Secp256k1PublicKey,
+        max_amount: u128,
+        auth_id: u128,
     ) -> StacksTransaction {
         let addr_tuple = Value::Tuple(pox_addr.as_clarity_tuple().unwrap());
         let signature = match signature_opt {
@@ -2129,6 +2139,8 @@ pub mod test {
                 Value::UInt(reward_cycle),
                 signature,
                 Value::buff_from(signer_key.to_bytes_compressed()).unwrap(),
+                Value::UInt(max_amount),
+                Value::UInt(auth_id),
             ],
         )
         .unwrap();
@@ -2192,6 +2204,8 @@ pub mod test {
         reward_cycle: u128,
         topic: &Pox4SignatureTopic,
         period: u128,
+        max_amount: u128,
+        auth_id: u128,
     ) -> Vec<u8> {
         let signature = make_pox_4_signer_key_signature(
             pox_addr,
@@ -2200,6 +2214,8 @@ pub mod test {
             topic,
             CHAIN_ID_TESTNET,
             period,
+            max_amount,
+            auth_id,
         )
         .unwrap();
 
@@ -2215,6 +2231,8 @@ pub mod test {
         enabled: bool,
         nonce: u64,
         sender_key: Option<&StacksPrivateKey>,
+        max_amount: u128,
+        auth_id: u128,
     ) -> StacksTransaction {
         let signer_pubkey = StacksPublicKey::from_private(signer_key);
         let payload = TransactionPayload::new_contract_call(
@@ -2228,6 +2246,8 @@ pub mod test {
                 Value::string_ascii_from_bytes(topic.get_name_str().into()).unwrap(),
                 Value::buff_from(signer_pubkey.to_bytes_compressed()).unwrap(),
                 Value::Bool(enabled),
+                Value::UInt(max_amount),
+                Value::UInt(auth_id),
             ],
         )
         .unwrap();
diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index d54f3b8d5f..26c1f8c61c 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -32,6 +32,8 @@
 (define-constant ERR_DELEGATION_ALREADY_REVOKED 34)
 (define-constant ERR_INVALID_SIGNATURE_PUBKEY 35)
 (define-constant ERR_INVALID_SIGNATURE_RECOVER 36)
+(define-constant ERR_SIGNER_AUTH_AMOUNT_TOO_HIGH 37)
+(define-constant ERR_SIGNER_AUTH_USED 38)
 
 ;; Valid values for burnchain address versions.
 ;; These first four correspond to address hash modes in Stacks 2.1,
@@ -233,10 +235,30 @@
         topic: (string-ascii 12),
         ;; The PoX address that can be used with this signer key
         pox-addr: { version: (buff 1), hashbytes: (buff 32) },
+        ;; The unique auth-id for this authorization
+        auth-id: uint,
+        ;; The maximum amount of uSTX that can be used (per tx) with this signer key
+        max-amount: uint,
     }
     bool ;; Whether the authorization can be used or not
 )
 
+;; State for tracking used signer key authorizations. This prevents re-use
+;; of the same signature or pre-set authorization for multiple transactions.
+;; Refer to the `signer-key-authorizations` map for the documentation on these fields
+(define-map used-signer-key-authorizations
+    {
+        signer-key: (buff 33),
+        reward-cycle: uint,
+        period: uint,
+        topic: (string-ascii 12),
+        pox-addr: { version: (buff 1), hashbytes: (buff 32) },
+        auth-id: uint,
+        max-amount: uint,
+    }
+    bool ;; Whether the field has been used or not
+)
+
 ;; What's the reward cycle number of the burnchain block height?
 ;; Will runtime-abort if height is less than the first burnchain block (this is intentional)
 (define-read-only (burn-height-to-reward-cycle (height uint))
@@ -603,7 +625,9 @@
                           (start-burn-ht uint)
                           (lock-period uint)
                           (signer-sig (optional (buff 65)))
-                          (signer-key (buff 33)))
+                          (signer-key (buff 33))
+                          (max-amount uint)
+                          (auth-id uint))
     ;; this stacker's first reward cycle is the _next_ reward cycle
     (let ((first-reward-cycle (+ u1 (current-pox-reward-cycle)))
           (specified-reward-cycle (+ u1 (burn-height-to-reward-cycle start-burn-ht))))
@@ -629,7 +653,7 @@
         (err ERR_STACKING_INSUFFICIENT_FUNDS))
 
       ;; Validate ownership of the given signer key
-      (try! (verify-signer-key-sig pox-addr (- first-reward-cycle u1) "stack-stx" lock-period signer-sig signer-key))
+      (try! (consume-signer-key-authorization pox-addr (- first-reward-cycle u1) "stack-stx" lock-period signer-sig signer-key amount-ustx max-amount auth-id))
 
       ;; ensure that stacking can be performed
       (try! (can-stack-stx pox-addr amount-ustx first-reward-cycle lock-period))
@@ -708,12 +732,14 @@
 
 ;; Generate a message hash for validating a signer key.
 ;; The message hash follows SIP018 for signing structured data. The structured data
-;; is the tuple `{ pox-addr: { version, hashbytes }, reward-cycle }`. The domain is
-;; `{ name: "pox-4-signer", version: "1.0.0", chain-id: chain-id }`.
+;; is the tuple `{ pox-addr: { version, hashbytes }, reward-cycle, auth-id, max-amount }`.
+;; The domain is `{ name: "pox-4-signer", version: "1.0.0", chain-id: chain-id }`.
 (define-read-only (get-signer-key-message-hash (pox-addr { version: (buff 1), hashbytes: (buff 32) })
                                                (reward-cycle uint)
                                                (topic (string-ascii 12))
-                                               (period uint))
+                                               (period uint)
+                                               (max-amount uint)
+                                               (auth-id uint))
   (sha256 (concat
     SIP018_MSG_PREFIX
     (concat
@@ -724,6 +750,8 @@
           reward-cycle: reward-cycle,
           topic: topic,
           period: period,
+          auth-id: auth-id,
+          max-amount: max-amount,
         })))))))
 
 ;; Verify a signature from the signing key for this specific stacker.
@@ -747,21 +775,55 @@
                                          (topic (string-ascii 12))
                                          (period uint)
                                          (signer-sig-opt (optional (buff 65)))
-                                         (signer-key (buff 33)))
-  (match signer-sig-opt
-    ;; `signer-sig` is present, verify the signature
-    signer-sig (ok (asserts!
-      (is-eq
-        (unwrap! (secp256k1-recover?
-          (get-signer-key-message-hash pox-addr reward-cycle topic period)
-          signer-sig) (err ERR_INVALID_SIGNATURE_RECOVER))
-        signer-key)
-      (err ERR_INVALID_SIGNATURE_PUBKEY)))
-    ;; `signer-sig` is not present, verify that an authorization was previously added for this key
-    (ok (asserts! (default-to false (map-get? signer-key-authorizations
-          { signer-key: signer-key, reward-cycle: reward-cycle, period: period, topic: topic, pox-addr: pox-addr }))
-        (err ERR_NOT_ALLOWED)))
+                                         (signer-key (buff 33))
+                                         (amount uint)
+                                         (max-amount uint)
+                                         (auth-id uint))
+  (begin
+    ;; Validate that amount is less than or equal to `max-amount`
+    (asserts! (>= max-amount amount) (err ERR_SIGNER_AUTH_AMOUNT_TOO_HIGH))
+    (asserts! (is-none (map-get? used-signer-key-authorizations { signer-key: signer-key, reward-cycle: reward-cycle, topic: topic, period: period, pox-addr: pox-addr, auth-id: auth-id, max-amount: max-amount }))
+              (err ERR_SIGNER_AUTH_USED))
+    (match signer-sig-opt
+      ;; `signer-sig` is present, verify the signature
+      signer-sig (ok (asserts!
+        (is-eq
+          (unwrap! (secp256k1-recover?
+            (get-signer-key-message-hash pox-addr reward-cycle topic period max-amount auth-id)
+            signer-sig) (err ERR_INVALID_SIGNATURE_RECOVER))
+          signer-key)
+        (err ERR_INVALID_SIGNATURE_PUBKEY)))
+      ;; `signer-sig` is not present, verify that an authorization was previously added for this key
+      (ok (asserts! (default-to false (map-get? signer-key-authorizations
+            { signer-key: signer-key, reward-cycle: reward-cycle, period: period, topic: topic, pox-addr: pox-addr, auth-id: auth-id, max-amount: max-amount }))
+          (err ERR_NOT_ALLOWED)))
     ))
+  )
+
+;; This function does two things:
+;;
+;; - Verify that a signer key is authorized to be used
+;; - Updates the `used-signer-key-authorizations` map to prevent reuse
+;;
+;; This "wrapper" method around `verify-signer-key-sig` allows that function to remain
+;; read-only, so that it can be used by clients as a sanity check before submitting a transaction.
+(define-private (consume-signer-key-authorization (pox-addr { version: (buff 1), hashbytes: (buff 32) })
+                                                  (reward-cycle uint)
+                                                  (topic (string-ascii 12))
+                                                  (period uint)
+                                                  (signer-sig-opt (optional (buff 65)))
+                                                  (signer-key (buff 33))
+                                                  (amount uint)
+                                                  (max-amount uint)
+                                                  (auth-id uint))
+  (begin
+    ;; verify the authorization
+    (try! (verify-signer-key-sig pox-addr reward-cycle topic period signer-sig-opt signer-key amount max-amount auth-id))
+    ;; update the `used-signer-key-authorizations` map
+    (asserts! (map-insert used-signer-key-authorizations
+      { signer-key: signer-key, reward-cycle: reward-cycle, topic: topic, period: period, pox-addr: pox-addr, auth-id: auth-id, max-amount: max-amount } true)
+      (err ERR_SIGNER_AUTH_USED))
+    (ok true)))
 
 ;; Commit partially stacked STX and allocate a new PoX reward address slot.
 ;;   This allows a stacker/delegate to lock fewer STX than the minimal threshold in multiple transactions,
@@ -778,7 +840,9 @@
 (define-private (inner-stack-aggregation-commit (pox-addr { version: (buff 1), hashbytes: (buff 32) })
                                                 (reward-cycle uint)
                                                 (signer-sig (optional (buff 65)))
-                                                (signer-key (buff 33)))
+                                                (signer-key (buff 33))
+                                                (max-amount uint)
+                                                (auth-id uint))
   (let ((partial-stacked
          ;; fetch the partial commitments
          (unwrap! (map-get? partial-stacked-by-cycle { pox-addr: pox-addr, sender: tx-sender, reward-cycle: reward-cycle })
@@ -786,8 +850,8 @@
     ;; must be called directly by the tx-sender or by an allowed contract-caller
     (asserts! (check-caller-allowed)
               (err ERR_STACKING_PERMISSION_DENIED))
-    (try! (verify-signer-key-sig pox-addr reward-cycle "agg-commit" u1 signer-sig signer-key))
     (let ((amount-ustx (get stacked-amount partial-stacked)))
+      (try! (consume-signer-key-authorization pox-addr reward-cycle "agg-commit" u1 signer-sig signer-key amount-ustx max-amount auth-id))
       (try! (can-stack-stx pox-addr amount-ustx reward-cycle u1))
       ;; Add the pox addr to the reward cycle, and extract the index of the PoX address
       ;; so the delegator can later use it to call stack-aggregation-increase.
@@ -821,8 +885,10 @@
 (define-public (stack-aggregation-commit (pox-addr { version: (buff 1), hashbytes: (buff 32) })
                                          (reward-cycle uint)
                                          (signer-sig (optional (buff 65)))
-                                         (signer-key (buff 33)))
-    (match (inner-stack-aggregation-commit pox-addr reward-cycle signer-sig signer-key)
+                                         (signer-key (buff 33))
+                                         (max-amount uint)
+                                         (auth-id uint))
+    (match (inner-stack-aggregation-commit pox-addr reward-cycle signer-sig signer-key max-amount auth-id)
         pox-addr-index (ok true)
         commit-err (err commit-err)))
 
@@ -831,8 +897,10 @@
 (define-public (stack-aggregation-commit-indexed (pox-addr { version: (buff 1), hashbytes: (buff 32) })
                                                  (reward-cycle uint)
                                                  (signer-sig (optional (buff 65)))
-                                                 (signer-key (buff 33)))
-    (inner-stack-aggregation-commit pox-addr reward-cycle signer-sig signer-key))
+                                                 (signer-key (buff 33))
+                                                 (max-amount uint)
+                                                 (auth-id uint))
+    (inner-stack-aggregation-commit pox-addr reward-cycle signer-sig signer-key max-amount auth-id))
 
 ;; Commit partially stacked STX to a PoX address which has already received some STX (more than the Stacking min).
 ;; This allows a delegator to lock up marginally more STX from new delegates, even if they collectively do not
@@ -1080,7 +1148,9 @@
 (define-public (stack-extend (extend-count uint)
                              (pox-addr { version: (buff 1), hashbytes: (buff 32) })
                              (signer-sig (optional (buff 65)))
-                             (signer-key (buff 33)))
+                             (signer-key (buff 33))
+                             (max-amount uint)
+                             (auth-id uint))
    (let ((stacker-info (stx-account tx-sender))
          ;; to extend, there must already be an etry in the stacking-state
          (stacker-state (unwrap! (get-stacker-info tx-sender) (err ERR_STACK_EXTEND_NOT_LOCKED)))
@@ -1106,7 +1176,7 @@
               (err ERR_STACKING_IS_DELEGATED))
 
     ;; Verify signature from delegate that allows this sender for this cycle
-    (try! (verify-signer-key-sig pox-addr cur-cycle "stack-extend" extend-count signer-sig signer-key))
+    (try! (consume-signer-key-authorization pox-addr cur-cycle "stack-extend" extend-count signer-sig signer-key u0 max-amount auth-id))
 
     ;; TODO: add more assertions to sanity check the `stacker-info` values with
     ;;       the `stacker-state` values
@@ -1362,13 +1432,15 @@
                                              (reward-cycle uint)
                                              (topic (string-ascii 12))
                                              (signer-key (buff 33))
-                                             (allowed bool))
+                                             (allowed bool)
+                                             (max-amount uint)
+                                             (auth-id uint))
   (begin
     ;; Validate that `tx-sender` has the same pubkey hash as `signer-key`
     (asserts! (is-eq
       (unwrap! (principal-construct? (if is-in-mainnet STACKS_ADDR_VERSION_MAINNET STACKS_ADDR_VERSION_TESTNET) (hash160 signer-key)) (err ERR_INVALID_SIGNER_KEY))
       tx-sender) (err ERR_NOT_ALLOWED))
-    (map-set signer-key-authorizations { pox-addr: pox-addr, period: period, reward-cycle: reward-cycle, topic: topic, signer-key: signer-key } allowed)
+    (map-set signer-key-authorizations { pox-addr: pox-addr, period: period, reward-cycle: reward-cycle, topic: topic, signer-key: signer-key, auth-id: auth-id, max-amount: max-amount } allowed)
     (ok allowed)))
 
 ;; Get the _current_ PoX stacking delegation information for a stacker.  If the information
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index ebb8c5f078..a914646b5f 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -491,6 +491,7 @@ fn pox_extend_transition() {
         AddressHashMode::SerializeP2PKH,
         key_to_stacks_addr(&alice).bytes,
     );
+    let auth_id = 1;
 
     let alice_signature = make_signer_key_signature(
         &alice_pox_addr,
@@ -498,6 +499,8 @@ fn pox_extend_transition() {
         reward_cycle,
         &Pox4SignatureTopic::StackStx,
         4_u128,
+        u128::MAX,
+        auth_id,
     );
     let alice_lockup = make_pox_4_lockup(
         &alice,
@@ -511,6 +514,8 @@ fn pox_extend_transition() {
         &alice_signer_key,
         tip.block_height,
         Some(alice_signature),
+        u128::MAX,
+        auth_id,
     );
     let alice_pox_4_lock_nonce = 2;
     let alice_first_pox_4_unlock_height =
@@ -569,6 +574,8 @@ fn pox_extend_transition() {
         reward_cycle,
         &Pox4SignatureTopic::StackStx,
         3_u128,
+        u128::MAX,
+        2,
     );
 
     let tip = get_tip(peer.sortdb.as_ref());
@@ -581,6 +588,8 @@ fn pox_extend_transition() {
         &StacksPublicKey::from_private(&bob_signer_private),
         tip.block_height,
         Some(bob_signature),
+        u128::MAX,
+        2,
     );
 
     // new signing key needed
@@ -593,6 +602,8 @@ fn pox_extend_transition() {
         reward_cycle,
         &Pox4SignatureTopic::StackExtend,
         6_u128,
+        u128::MAX,
+        3,
     );
 
     // Alice can stack-extend in PoX v2
@@ -603,6 +614,8 @@ fn pox_extend_transition() {
         6,
         alice_signer_key,
         Some(alice_signature),
+        u128::MAX,
+        3,
     );
 
     let alice_pox_4_extend_nonce = 3;
@@ -864,6 +877,8 @@ fn pox_lock_unlock() {
                 reward_cycle,
                 &Pox4SignatureTopic::StackStx,
                 lock_period.into(),
+                u128::MAX,
+                1,
             );
             txs.push(make_pox_4_lockup(
                 key,
@@ -874,6 +889,8 @@ fn pox_lock_unlock() {
                 &StacksPublicKey::from_private(&signer_key),
                 tip_height,
                 Some(signature),
+                u128::MAX,
+                1,
             ));
             pox_addr
         })
@@ -1455,6 +1472,9 @@ fn verify_signer_key_sig(
     reward_cycle: u128,
     period: u128,
     topic: &Pox4SignatureTopic,
+    amount: u128,
+    max_amount: u128,
+    auth_id: u128,
 ) -> Value {
     let result: Value = with_sortdb(peer, |ref mut chainstate, ref mut sortdb| {
         chainstate
@@ -1469,13 +1489,16 @@ fn verify_signer_key_sig(
                         LimitedCostTracker::new_free(),
                         |env| {
                             let program = format!(
-                                "(verify-signer-key-sig {} u{} \"{}\" u{} (some 0x{}) 0x{})",
+                                "(verify-signer-key-sig {} u{} \"{}\" u{} (some 0x{}) 0x{} u{} u{} u{})",
                                 Value::Tuple(pox_addr.clone().as_clarity_tuple().unwrap()),
                                 reward_cycle,
                                 topic.get_name_str(),
                                 period,
                                 to_hex(&signature),
                                 signing_key.to_hex(),
+                                amount,
+                                max_amount,
+                                auth_id
                             );
                             env.eval_read_only(&boot_code_id("pox-4", false), &program)
                         },
@@ -1543,8 +1566,15 @@ fn verify_signer_key_signatures() {
     // Test 1: invalid reward cycle used in signature
 
     let last_reward_cycle = reward_cycle - 1;
-    let signature =
-        make_signer_key_signature(&bob_pox_addr, &bob, last_reward_cycle, &topic, period);
+    let signature = make_signer_key_signature(
+        &bob_pox_addr,
+        &bob,
+        last_reward_cycle,
+        &topic,
+        period,
+        u128::MAX,
+        1,
+    );
 
     let result = verify_signer_key_sig(
         &signature,
@@ -1555,12 +1585,23 @@ fn verify_signer_key_signatures() {
         reward_cycle,
         period,
         &topic,
+        1,
+        u128::MAX,
+        1,
     );
     assert_eq!(result, expected_error);
 
     // Test 2: Invalid pox-addr used in signature
 
-    let signature = make_signer_key_signature(&alice_pox_addr, &bob, reward_cycle, &topic, period);
+    let signature = make_signer_key_signature(
+        &alice_pox_addr,
+        &bob,
+        reward_cycle,
+        &topic,
+        period,
+        u128::MAX,
+        1,
+    );
 
     let result = verify_signer_key_sig(
         &signature,
@@ -1571,13 +1612,24 @@ fn verify_signer_key_signatures() {
         reward_cycle,
         period,
         &topic,
+        1,
+        u128::MAX,
+        1,
     );
 
     assert_eq!(result, expected_error);
 
     // Test 3: Invalid signer key used in signature
 
-    let signature = make_signer_key_signature(&bob_pox_addr, &alice, reward_cycle, &topic, period);
+    let signature = make_signer_key_signature(
+        &bob_pox_addr,
+        &alice,
+        reward_cycle,
+        &topic,
+        period,
+        u128::MAX,
+        1,
+    );
 
     let result = verify_signer_key_sig(
         &signature,
@@ -1588,6 +1640,9 @@ fn verify_signer_key_signatures() {
         reward_cycle,
         period,
         &topic,
+        1,
+        u128::MAX,
+        1,
     );
 
     assert_eq!(result, expected_error);
@@ -1599,6 +1654,8 @@ fn verify_signer_key_signatures() {
         reward_cycle,
         &Pox4SignatureTopic::StackStx,
         period,
+        u128::MAX,
+        1,
     );
     let result = verify_signer_key_sig(
         &signature,
@@ -1609,12 +1666,23 @@ fn verify_signer_key_signatures() {
         reward_cycle,
         period,
         &Pox4SignatureTopic::StackExtend, // different
+        1,
+        u128::MAX,
+        1,
     );
 
     assert_eq!(result, expected_error);
 
     // Test 5: invalid period
-    let signature = make_signer_key_signature(&bob_pox_addr, &bob, reward_cycle, &topic, period);
+    let signature = make_signer_key_signature(
+        &bob_pox_addr,
+        &bob,
+        reward_cycle,
+        &topic,
+        period,
+        u128::MAX,
+        1,
+    );
     let result = verify_signer_key_sig(
         &signature,
         &bob_public_key,
@@ -1624,13 +1692,28 @@ fn verify_signer_key_signatures() {
         reward_cycle,
         period + 1, // different
         &topic,
+        1,
+        u128::MAX,
+        1,
     );
 
     assert_eq!(result, expected_error);
 
+    // TODO: using incorrect auth-id
+    // TODO: using incorrect max-amount
+    // TODO: using amount > max-amount
+
     // Test 6: using a valid signature
 
-    let signature = make_signer_key_signature(&bob_pox_addr, &bob, reward_cycle, &topic, period);
+    let signature = make_signer_key_signature(
+        &bob_pox_addr,
+        &bob,
+        reward_cycle,
+        &topic,
+        period,
+        u128::MAX,
+        1,
+    );
 
     let result = verify_signer_key_sig(
         &signature,
@@ -1641,6 +1724,9 @@ fn verify_signer_key_signatures() {
         reward_cycle,
         period,
         &topic,
+        1,
+        u128::MAX,
+        1,
     );
 
     assert_eq!(result, Value::okay_true());
@@ -1681,6 +1767,8 @@ fn stack_stx_verify_signer_sig() {
         reward_cycle - 1,
         &topic,
         lock_period,
+        u128::MAX,
+        1,
     );
     let invalid_cycle_nonce = stacker_nonce;
     let invalid_cycle_stack = make_pox_4_lockup(
@@ -1692,6 +1780,8 @@ fn stack_stx_verify_signer_sig() {
         &signer_public_key,
         block_height,
         Some(signature),
+        u128::MAX,
+        1,
     );
 
     // test 2: invalid pox addr
@@ -1702,6 +1792,8 @@ fn stack_stx_verify_signer_sig() {
         reward_cycle,
         &topic,
         lock_period,
+        u128::MAX,
+        1,
     );
     let invalid_stacker_nonce = stacker_nonce;
     let invalid_stacker_tx = make_pox_4_lockup(
@@ -1713,6 +1805,8 @@ fn stack_stx_verify_signer_sig() {
         &signer_public_key,
         block_height,
         Some(signature),
+        u128::MAX,
+        1,
     );
 
     // Test 3: invalid key used to sign
@@ -1723,6 +1817,8 @@ fn stack_stx_verify_signer_sig() {
         reward_cycle,
         &topic,
         lock_period,
+        u128::MAX,
+        1,
     );
     let invalid_key_nonce = stacker_nonce;
     let invalid_key_tx = make_pox_4_lockup(
@@ -1734,6 +1830,8 @@ fn stack_stx_verify_signer_sig() {
         &signer_public_key,
         block_height,
         Some(signature),
+        u128::MAX,
+        1,
     );
 
     // Test 4: invalid topic
@@ -1744,6 +1842,8 @@ fn stack_stx_verify_signer_sig() {
         reward_cycle,
         &Pox4SignatureTopic::StackExtend, // wrong topic
         lock_period,
+        u128::MAX,
+        1,
     );
     let invalid_topic_nonce = stacker_nonce;
     let invalid_topic_tx = make_pox_4_lockup(
@@ -1755,6 +1855,8 @@ fn stack_stx_verify_signer_sig() {
         &signer_public_key,
         block_height,
         Some(signature),
+        u128::MAX,
+        1,
     );
 
     // Test 5: invalid period
@@ -1765,6 +1867,8 @@ fn stack_stx_verify_signer_sig() {
         reward_cycle,
         &topic,
         lock_period + 1, // wrong period
+        u128::MAX,
+        1,
     );
     let invalid_period_nonce = stacker_nonce;
     let invalid_period_tx = make_pox_4_lockup(
@@ -1776,12 +1880,25 @@ fn stack_stx_verify_signer_sig() {
         &signer_public_key,
         block_height,
         Some(signature),
+        u128::MAX,
+        1,
     );
 
+    // TODO: invalid auth-id
+    // TODO: invalid amount
+    // TODO: invalid max-amount
+
     // Test 6: valid signature
     stacker_nonce += 1;
-    let signature =
-        make_signer_key_signature(&pox_addr, &signer_key, reward_cycle, &topic, lock_period);
+    let signature = make_signer_key_signature(
+        &pox_addr,
+        &signer_key,
+        reward_cycle,
+        &topic,
+        lock_period,
+        u128::MAX,
+        1,
+    );
     let valid_nonce = stacker_nonce;
     let valid_tx = make_pox_4_lockup(
         &stacker_key,
@@ -1792,6 +1909,8 @@ fn stack_stx_verify_signer_sig() {
         &signer_public_key,
         block_height,
         Some(signature),
+        u128::MAX,
+        1,
     );
 
     let txs = vec![
@@ -1850,6 +1969,8 @@ fn stack_extend_verify_sig() {
         reward_cycle,
         &Pox4SignatureTopic::StackStx,
         lock_period,
+        u128::MAX,
+        1,
     );
     let stack_nonce = stacker_nonce;
     let stack_tx = make_pox_4_lockup(
@@ -1861,6 +1982,8 @@ fn stack_extend_verify_sig() {
         &signer_public_key,
         block_height,
         Some(signature),
+        u128::MAX,
+        1,
     );
 
     // We need a new signer-key for the extend tx
@@ -1874,6 +1997,8 @@ fn stack_extend_verify_sig() {
         reward_cycle - 1,
         &topic,
         lock_period,
+        u128::MAX,
+        1,
     );
     stacker_nonce += 1;
     let invalid_cycle_nonce = stacker_nonce;
@@ -1884,6 +2009,8 @@ fn stack_extend_verify_sig() {
         lock_period,
         signer_public_key.clone(),
         Some(signature),
+        u128::MAX,
+        1,
     );
 
     // Test 2: invalid pox-addr
@@ -1895,6 +2022,8 @@ fn stack_extend_verify_sig() {
         reward_cycle,
         &topic,
         lock_period,
+        u128::MAX,
+        1,
     );
     let invalid_stacker_nonce = stacker_nonce;
     let invalid_stacker_tx = make_pox_4_extend(
@@ -1904,13 +2033,22 @@ fn stack_extend_verify_sig() {
         lock_period,
         signer_public_key.clone(),
         Some(signature),
+        u128::MAX,
+        1,
     );
 
     // Test 3: invalid key used to sign
     stacker_nonce += 1;
     let other_key = Secp256k1PrivateKey::new();
-    let signature =
-        make_signer_key_signature(&pox_addr, &other_key, reward_cycle, &topic, lock_period);
+    let signature = make_signer_key_signature(
+        &pox_addr,
+        &other_key,
+        reward_cycle,
+        &topic,
+        lock_period,
+        u128::MAX,
+        1,
+    );
     let invalid_key_nonce = stacker_nonce;
     let invalid_key_tx = make_pox_4_extend(
         &stacker_key,
@@ -1919,12 +2057,23 @@ fn stack_extend_verify_sig() {
         lock_period,
         signer_public_key.clone(),
         Some(signature),
+        u128::MAX,
+        1,
     );
 
+    // TODO: invalid auth-id, amount, max-amount
+
     // Test 4: valid stack-extend
     stacker_nonce += 1;
-    let signature =
-        make_signer_key_signature(&pox_addr, &signer_key, reward_cycle, &topic, lock_period);
+    let signature = make_signer_key_signature(
+        &pox_addr,
+        &signer_key,
+        reward_cycle,
+        &topic,
+        lock_period,
+        u128::MAX,
+        1,
+    );
     let valid_nonce = stacker_nonce;
     let valid_tx = make_pox_4_extend(
         &stacker_key,
@@ -1933,6 +2082,8 @@ fn stack_extend_verify_sig() {
         lock_period,
         signer_public_key.clone(),
         Some(signature),
+        u128::MAX,
+        1,
     );
 
     peer.tenure_with_txs(
@@ -2026,6 +2177,8 @@ fn stack_agg_commit_verify_sig() {
         reward_cycle, // wrong cycle
         &topic,
         1_u128,
+        u128::MAX,
+        1,
     );
     let invalid_cycle_nonce = delegate_nonce;
     let invalid_cycle_tx = make_pox_4_aggregation_commit_indexed(
@@ -2035,6 +2188,8 @@ fn stack_agg_commit_verify_sig() {
         next_reward_cycle,
         Some(signature),
         &signer_pk,
+        u128::MAX,
+        1,
     );
 
     // Test 2: invalid pox addr
@@ -2046,6 +2201,8 @@ fn stack_agg_commit_verify_sig() {
         next_reward_cycle,
         &topic,
         1_u128,
+        u128::MAX,
+        1,
     );
     let invalid_pox_addr_nonce = delegate_nonce;
     let invalid_stacker_tx = make_pox_4_aggregation_commit_indexed(
@@ -2055,12 +2212,21 @@ fn stack_agg_commit_verify_sig() {
         next_reward_cycle,
         Some(signature),
         &signer_pk,
+        u128::MAX,
+        1,
     );
 
     // Test 3: invalid signature
     delegate_nonce += 1;
-    let signature =
-        make_signer_key_signature(&pox_addr, &delegate_key, next_reward_cycle, &topic, 1_u128);
+    let signature = make_signer_key_signature(
+        &pox_addr,
+        &delegate_key,
+        next_reward_cycle,
+        &topic,
+        1_u128,
+        u128::MAX,
+        1,
+    );
     let invalid_key_nonce = delegate_nonce;
     let invalid_key_tx = make_pox_4_aggregation_commit_indexed(
         &delegate_key,
@@ -2069,6 +2235,8 @@ fn stack_agg_commit_verify_sig() {
         next_reward_cycle,
         Some(signature),
         &signer_pk,
+        u128::MAX,
+        1,
     );
 
     // Test 4: invalid period in signature
@@ -2079,6 +2247,8 @@ fn stack_agg_commit_verify_sig() {
         next_reward_cycle,
         &topic,
         2_u128, // wrong period
+        u128::MAX,
+        1,
     );
     let invalid_period_nonce = delegate_nonce;
     let invalid_period_tx = make_pox_4_aggregation_commit_indexed(
@@ -2088,6 +2258,8 @@ fn stack_agg_commit_verify_sig() {
         next_reward_cycle,
         Some(signature),
         &signer_pk,
+        u128::MAX,
+        1,
     );
 
     // Test 5: invalid topic in signature
@@ -2098,6 +2270,8 @@ fn stack_agg_commit_verify_sig() {
         next_reward_cycle,
         &Pox4SignatureTopic::StackStx, // wrong topic
         1_u128,
+        u128::MAX,
+        1,
     );
     let invalid_topic_nonce = delegate_nonce;
     let invalid_topic_tx = make_pox_4_aggregation_commit_indexed(
@@ -2107,12 +2281,25 @@ fn stack_agg_commit_verify_sig() {
         next_reward_cycle,
         Some(signature),
         &signer_pk,
+        u128::MAX,
+        1,
     );
 
+    // TODO: using incorrect auth-id
+    // TODO: using incorrect max-amount
+    // TODO: using amount > max-amount
+
     // Test 6: valid signature
     delegate_nonce += 1;
-    let signature =
-        make_signer_key_signature(&pox_addr, &signer_sk, next_reward_cycle, &topic, 1_u128);
+    let signature = make_signer_key_signature(
+        &pox_addr,
+        &signer_sk,
+        next_reward_cycle,
+        &topic,
+        1_u128,
+        u128::MAX,
+        1,
+    );
     let valid_nonce = delegate_nonce;
     let valid_tx = make_pox_4_aggregation_commit_indexed(
         &delegate_key,
@@ -2121,6 +2308,8 @@ fn stack_agg_commit_verify_sig() {
         next_reward_cycle,
         Some(signature),
         &signer_pk,
+        u128::MAX,
+        1,
     );
 
     peer.tenure_with_txs(
@@ -2256,6 +2445,8 @@ fn stack_stx_signer_key() {
         reward_cycle,
         &Pox4SignatureTopic::StackStx,
         2_u128,
+        u128::MAX,
+        1,
     );
 
     let txs = vec![make_pox_4_contract_call(
@@ -2269,6 +2460,8 @@ fn stack_stx_signer_key() {
             Value::UInt(2),
             Value::some(Value::buff_from(signature.clone()).unwrap()).unwrap(),
             signer_key_val.clone(),
+            Value::UInt(u128::MAX),
+            Value::UInt(1),
         ],
     )];
 
@@ -2346,6 +2539,8 @@ fn stack_stx_signer_auth() {
         &signer_public_key,
         block_height,
         None,
+        u128::MAX,
+        1,
     );
 
     let enable_auth_nonce = signer_nonce;
@@ -2358,6 +2553,8 @@ fn stack_stx_signer_auth() {
         true,
         signer_nonce,
         None,
+        u128::MAX,
+        1,
     );
 
     // Ensure that stack-stx succeeds with auth
@@ -2372,6 +2569,8 @@ fn stack_stx_signer_auth() {
         &signer_public_key,
         block_height,
         None,
+        u128::MAX,
+        1,
     );
 
     let txs = vec![failed_stack_tx, enable_auth_tx, valid_stack_tx];
@@ -2478,6 +2677,8 @@ fn stack_agg_commit_signer_auth() {
         next_reward_cycle,
         None,
         &signer_pk,
+        u128::MAX,
+        1,
     );
 
     // Signer enables auth
@@ -2491,6 +2692,8 @@ fn stack_agg_commit_signer_auth() {
         true,
         enable_auth_nonce,
         None,
+        u128::MAX,
+        1,
     );
 
     // Stack agg works with auth
@@ -2503,6 +2706,8 @@ fn stack_agg_commit_signer_auth() {
         next_reward_cycle,
         None,
         &signer_pk,
+        u128::MAX,
+        1,
     );
 
     let txs = vec![
@@ -2557,6 +2762,8 @@ fn stack_extend_signer_auth() {
         reward_cycle,
         &Pox4SignatureTopic::StackStx,
         lock_period,
+        u128::MAX,
+        1,
     );
     let stack_nonce = stacker_nonce;
     let stack_tx = make_pox_4_lockup(
@@ -2568,6 +2775,8 @@ fn stack_extend_signer_auth() {
         &signer_public_key,
         block_height,
         Some(signature),
+        u128::MAX,
+        1,
     );
 
     // Stack-extend should fail without auth
@@ -2580,6 +2789,8 @@ fn stack_extend_signer_auth() {
         lock_period,
         signer_public_key.clone(),
         None,
+        u128::MAX,
+        1,
     );
 
     // Enable authorization
@@ -2593,6 +2804,8 @@ fn stack_extend_signer_auth() {
         true,
         enable_auth_nonce,
         None,
+        u128::MAX,
+        1,
     );
 
     // Stack-extend should work with auth
@@ -2605,6 +2818,8 @@ fn stack_extend_signer_auth() {
         lock_period,
         signer_public_key.clone(),
         None,
+        u128::MAX,
+        1,
     );
 
     let txs = vec![stack_tx, invalid_cycle_tx, enable_auth_tx, valid_tx];
@@ -2655,6 +2870,8 @@ fn test_set_signer_key_auth() {
         true,
         invalid_enable_nonce,
         Some(&alice_key),
+        u128::MAX,
+        1,
     );
 
     // Disable auth for `signer-key`
@@ -2668,6 +2885,8 @@ fn test_set_signer_key_auth() {
         false,
         disable_auth_nonce,
         None,
+        u128::MAX,
+        1,
     );
 
     let latest_block =
@@ -2690,6 +2909,8 @@ fn test_set_signer_key_auth() {
         &Pox4SignatureTopic::StackStx,
         lock_period.try_into().unwrap(),
         &signer_public_key,
+        u128::MAX,
+        1,
     );
 
     assert_eq!(signer_key_enabled.unwrap(), false);
@@ -2706,6 +2927,8 @@ fn test_set_signer_key_auth() {
         true,
         enable_auth_nonce,
         None,
+        u128::MAX,
+        1,
     );
 
     let latest_block = peer.tenure_with_txs(&[enable_auth_tx], &mut coinbase_nonce);
@@ -2718,6 +2941,8 @@ fn test_set_signer_key_auth() {
         &Pox4SignatureTopic::StackStx,
         lock_period.try_into().unwrap(),
         &signer_public_key,
+        u128::MAX,
+        1,
     );
 
     assert_eq!(signer_key_enabled.unwrap(), true);
@@ -2734,6 +2959,8 @@ fn test_set_signer_key_auth() {
         false,
         disable_auth_nonce,
         None,
+        u128::MAX,
+        1,
     );
 
     let latest_block = peer.tenure_with_txs(&[disable_auth_tx], &mut coinbase_nonce);
@@ -2746,6 +2973,8 @@ fn test_set_signer_key_auth() {
         &Pox4SignatureTopic::StackStx,
         lock_period.try_into().unwrap(),
         &signer_public_key,
+        u128::MAX,
+        1,
     );
 
     assert_eq!(signer_key_enabled.unwrap(), false);
@@ -2786,6 +3015,8 @@ fn stack_extend_signer_key() {
         reward_cycle,
         &Pox4SignatureTopic::StackStx,
         lock_period,
+        u128::MAX,
+        1,
     );
 
     let txs = vec![make_pox_4_lockup(
@@ -2797,6 +3028,8 @@ fn stack_extend_signer_key() {
         &signer_key,
         block_height,
         Some(signature),
+        u128::MAX,
+        1,
     )];
 
     stacker_nonce += 1;
@@ -2809,21 +3042,19 @@ fn stack_extend_signer_key() {
         reward_cycle,
         &Pox4SignatureTopic::StackExtend,
         1_u128,
+        u128::MAX,
+        1,
     );
 
-    // (define-public (stack-extend (extend-count uint)
-    //                          (pox-addr { version: (buff 1), hashbytes: (buff 32) })
-    //                          (signer-key (buff 33)))
-    let update_txs = vec![make_pox_4_contract_call(
-        stacker_key,
+    let update_txs = vec![make_pox_4_extend(
+        &stacker_key,
         stacker_nonce,
-        "stack-extend",
-        vec![
-            Value::UInt(1),
-            pox_addr_val.clone(),
-            Value::some(Value::buff_from(signature.clone()).unwrap()).unwrap(),
-            signer_extend_key_val.clone(),
-        ],
+        pox_addr.clone(),
+        1,
+        signer_extend_key.clone(),
+        Some(signature),
+        u128::MAX,
+        1,
     )];
 
     latest_block = peer.tenure_with_txs(&update_txs, &mut coinbase_nonce);
@@ -2894,6 +3125,8 @@ fn delegate_stack_stx_signer_key() {
         next_reward_cycle.into(),
         &Pox4SignatureTopic::AggregationCommit,
         1_u128,
+        u128::MAX,
+        1,
     );
 
     let txs = vec![
@@ -2931,6 +3164,8 @@ fn delegate_stack_stx_signer_key() {
                 Value::UInt(next_reward_cycle.into()),
                 Value::some(Value::buff_from(signature).unwrap()).unwrap(),
                 signer_key_val.clone(),
+                Value::UInt(u128::MAX),
+                Value::UInt(1),
             ],
         ),
     ];
@@ -3081,6 +3316,8 @@ fn delegate_stack_stx_extend_signer_key() {
         next_reward_cycle.into(),
         &Pox4SignatureTopic::AggregationCommit,
         1_u128,
+        u128::MAX,
+        1,
     );
 
     let delegate_stack_extend = make_pox_4_delegate_stack_extend(
@@ -3100,6 +3337,8 @@ fn delegate_stack_stx_extend_signer_key() {
             Value::UInt(next_reward_cycle.into()),
             Value::some(Value::buff_from(signature).unwrap()).unwrap(),
             signer_key_val.clone(),
+            Value::UInt(u128::MAX),
+            Value::UInt(1),
         ],
     );
 
@@ -3109,6 +3348,8 @@ fn delegate_stack_stx_extend_signer_key() {
         extend_cycle.into(),
         &Pox4SignatureTopic::AggregationCommit,
         1_u128,
+        u128::MAX,
+        2,
     );
 
     let agg_tx_1 = make_pox_4_contract_call(
@@ -3120,6 +3361,8 @@ fn delegate_stack_stx_extend_signer_key() {
             Value::UInt(extend_cycle.into()),
             Value::some(Value::buff_from(extend_signature).unwrap()).unwrap(),
             signer_extend_key_val.clone(),
+            Value::UInt(u128::MAX),
+            Value::UInt(2),
         ],
     );
 
@@ -3185,6 +3428,8 @@ fn stack_increase() {
         reward_cycle,
         &Pox4SignatureTopic::StackStx,
         lock_period,
+        u128::MAX,
+        1,
     );
 
     let stack_stx = make_pox_4_lockup(
@@ -3196,6 +3441,8 @@ fn stack_increase() {
         &signing_pk,
         block_height as u64,
         Some(signature),
+        u128::MAX,
+        1,
     );
 
     // Initial tx arr includes a stack_stx pox_4 helper found in mod.rs
@@ -3324,6 +3571,8 @@ fn delegate_stack_increase() {
         next_reward_cycle.into(),
         &Pox4SignatureTopic::AggregationCommit,
         1_u128,
+        u128::MAX,
+        1,
     );
 
     let agg_tx = make_pox_4_contract_call(
@@ -3335,6 +3584,8 @@ fn delegate_stack_increase() {
             Value::UInt(next_reward_cycle.into()),
             (Value::some(Value::buff_from(signature).unwrap()).unwrap()),
             signer_key_val.clone(),
+            Value::UInt(u128::MAX),
+            Value::UInt(1),
         ],
     );
 
@@ -3404,6 +3655,8 @@ pub fn get_signer_key_authorization_pox_4(
     topic: &Pox4SignatureTopic,
     period: u128,
     signer_key: &StacksPublicKey,
+    max_amount: u128,
+    auth_id: u128,
 ) -> Option<bool> {
     with_clarity_db_ro(peer, tip, |db| {
         let lookup_tuple = TupleData::from_data(vec![
@@ -3421,6 +3674,8 @@ pub fn get_signer_key_authorization_pox_4(
                 "signer-key".into(),
                 Value::buff_from(signer_key.to_bytes_compressed()).unwrap(),
             ),
+            ("max-amount".into(), Value::UInt(max_amount)),
+            ("auth-id".into(), Value::UInt(auth_id)),
         ])
         .unwrap()
         .into();
diff --git a/stackslib/src/net/tests/mod.rs b/stackslib/src/net/tests/mod.rs
index acff183d92..11d473c1e1 100644
--- a/stackslib/src/net/tests/mod.rs
+++ b/stackslib/src/net/tests/mod.rs
@@ -394,6 +394,8 @@ impl NakamotoBootPlan {
                     reward_cycle.into(),
                     &crate::util_lib::signed_structured_data::pox4::Pox4SignatureTopic::StackStx,
                     12_u128,
+                    u128::MAX,
+                    1,
                 );
                 make_pox_4_lockup(
                     &test_stacker.stacker_private_key,
@@ -404,6 +406,8 @@ impl NakamotoBootPlan {
                     &StacksPublicKey::from_private(&test_stacker.signer_private_key),
                     34,
                     Some(signature),
+                    u128::MAX,
+                    1,
                 )
             })
             .collect();
diff --git a/stackslib/src/util_lib/signed_structured_data.rs b/stackslib/src/util_lib/signed_structured_data.rs
index 019443842d..b2cbbb467b 100644
--- a/stackslib/src/util_lib/signed_structured_data.rs
+++ b/stackslib/src/util_lib/signed_structured_data.rs
@@ -96,6 +96,8 @@ pub mod pox4 {
         topic: &Pox4SignatureTopic,
         chain_id: u32,
         period: u128,
+        max_amount: u128,
+        auth_id: u128,
     ) -> Sha256Sum {
         let domain_tuple = make_pox_4_signed_data_domain(chain_id);
         let data_tuple = Value::Tuple(
@@ -110,6 +112,8 @@ pub mod pox4 {
                     "topic".into(),
                     Value::string_ascii_from_bytes(topic.get_name_str().into()).unwrap(),
                 ),
+                ("auth-id".into(), Value::UInt(auth_id)),
+                ("max-amount".into(), Value::UInt(max_amount)),
             ])
             .unwrap(),
         );
@@ -134,9 +138,18 @@ pub mod pox4 {
         topic: &Pox4SignatureTopic,
         chain_id: u32,
         period: u128,
+        max_amount: u128,
+        auth_id: u128,
     ) -> Result<MessageSignature, &'static str> {
-        let msg_hash =
-            make_pox_4_signer_key_message_hash(pox_addr, reward_cycle, topic, chain_id, period);
+        let msg_hash = make_pox_4_signer_key_message_hash(
+            pox_addr,
+            reward_cycle,
+            topic,
+            chain_id,
+            period,
+            max_amount,
+            auth_id,
+        );
         signer_key.sign(msg_hash.as_bytes())
     }
 
@@ -166,6 +179,8 @@ pub mod pox4 {
             topic: &Pox4SignatureTopic,
             lock_period: u128,
             sender: &PrincipalData,
+            max_amount: u128,
+            auth_id: u128,
         ) -> Vec<u8> {
             let pox_contract_id = boot_code_id(POX_4_NAME, false);
             sim.execute_next_block_as_conn(|conn| {
@@ -178,11 +193,13 @@ pub mod pox4 {
                     LimitedCostTracker::new_free(),
                     |env| {
                         let program = format!(
-                            "(get-signer-key-message-hash {} u{} \"{}\" u{})",
+                            "(get-signer-key-message-hash {} u{} \"{}\" u{} u{} u{})",
                             Value::Tuple(pox_addr.clone().as_clarity_tuple().unwrap()), //p
                             reward_cycle,
                             topic.get_name_str(),
-                            lock_period
+                            lock_period,
+                            max_amount,
+                            auth_id,
                         );
                         env.eval_read_only(&pox_contract_id, &program)
                     },
@@ -242,6 +259,8 @@ pub mod pox4 {
             let reward_cycle: u128 = 1;
             let topic = Pox4SignatureTopic::StackStx;
             let lock_period = 12;
+            let auth_id = 111;
+            let max_amount = u128::MAX;
 
             let expected_hash_vec = make_pox_4_signer_key_message_hash(
                 &pox_addr,
@@ -249,6 +268,8 @@ pub mod pox4 {
                 &Pox4SignatureTopic::StackStx,
                 CHAIN_ID_TESTNET,
                 lock_period,
+                max_amount,
+                auth_id,
             );
             let expected_hash = expected_hash_vec.as_bytes();
 
@@ -261,6 +282,8 @@ pub mod pox4 {
                 &topic,
                 lock_period,
                 &principal,
+                max_amount,
+                auth_id,
             );
             assert_eq!(expected_hash.clone(), result.as_slice());
 
@@ -276,6 +299,8 @@ pub mod pox4 {
                 &topic,
                 lock_period,
                 &principal,
+                max_amount,
+                auth_id,
             );
             assert_ne!(expected_hash.clone(), result.as_slice());
 
@@ -287,6 +312,8 @@ pub mod pox4 {
                 &topic,
                 lock_period,
                 &principal,
+                max_amount,
+                auth_id,
             );
             assert_ne!(expected_hash.clone(), result.as_slice());
 
@@ -298,6 +325,8 @@ pub mod pox4 {
                 &Pox4SignatureTopic::AggregationCommit,
                 lock_period,
                 &principal,
+                max_amount,
+                auth_id,
             );
             assert_ne!(expected_hash.clone(), result.as_slice());
 
@@ -309,6 +338,34 @@ pub mod pox4 {
                 &topic,
                 0,
                 &principal,
+                max_amount,
+                auth_id,
+            );
+            assert_ne!(expected_hash.clone(), result.as_slice());
+
+            // Test 5: invalid max amount
+            let result = call_get_signer_message_hash(
+                &mut sim,
+                &pox_addr,
+                reward_cycle,
+                &topic,
+                lock_period,
+                &principal,
+                1010101,
+                auth_id,
+            );
+            assert_ne!(expected_hash.clone(), result.as_slice());
+
+            // Test 6: invalid auth id
+            let result = call_get_signer_message_hash(
+                &mut sim,
+                &pox_addr,
+                reward_cycle,
+                &topic,
+                lock_period,
+                &principal,
+                max_amount,
+                10101,
             );
             assert_ne!(expected_hash.clone(), result.as_slice());
         }
@@ -316,12 +373,14 @@ pub mod pox4 {
         #[test]
         /// Fixture message hash to test against in other libraries
         fn test_sig_hash_fixture() {
-            let fixture = "3dd864afd98609df3911a7ab6f0338ace129e56ad394d85866d298a7eda3ad98";
+            let fixture = "ec5b88aa81a96a6983c26cdba537a13d253425348ffc0ba6b07130869b025a2d";
             let pox_addr = PoxAddress::standard_burn_address(false);
             let pubkey_hex = "0206952cd8813a64f7b97144c984015490a8f9c5778e8f928fbc8aa6cbf02f48e6";
             let pubkey = Secp256k1PublicKey::from_hex(pubkey_hex).unwrap();
             let reward_cycle: u128 = 1;
             let lock_period = 12;
+            let auth_id = 111;
+            let max_amount = u128::MAX;
 
             let message_hash = make_pox_4_signer_key_message_hash(
                 &pox_addr,
@@ -329,6 +388,8 @@ pub mod pox4 {
                 &Pox4SignatureTopic::StackStx,
                 CHAIN_ID_TESTNET,
                 lock_period,
+                max_amount,
+                auth_id,
             );
 
             assert_eq!(to_hex(message_hash.as_bytes()), fixture);
diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index 2629f4f9b2..6a98d7358f 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -863,6 +863,8 @@ impl MockamotoNode {
                 &Pox4SignatureTopic::StackStx,
                 CHAIN_ID_TESTNET,
                 12_u128,
+                u128::MAX,
+                1,
             )
             .unwrap()
             .to_rsv();
@@ -877,6 +879,8 @@ impl MockamotoNode {
                     ClarityValue::UInt(12),
                     ClarityValue::some(ClarityValue::buff_from(signature).unwrap()).unwrap(),
                     ClarityValue::buff_from(signer_key).unwrap(),
+                    ClarityValue::UInt(u128::MAX),
+                    ClarityValue::UInt(1),
                 ],
             })
         } else {
@@ -887,6 +891,8 @@ impl MockamotoNode {
                 &Pox4SignatureTopic::StackExtend,
                 CHAIN_ID_TESTNET,
                 5_u128,
+                u128::MAX,
+                1,
             )
             .unwrap()
             .to_rsv();
@@ -901,6 +907,8 @@ impl MockamotoNode {
                     pox_address.as_clarity_tuple().unwrap().into(),
                     ClarityValue::some(ClarityValue::buff_from(signature).unwrap()).unwrap(),
                     ClarityValue::buff_from(signer_key).unwrap(),
+                    ClarityValue::UInt(u128::MAX),
+                    ClarityValue::UInt(1),
                 ],
             })
         };
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index e97aefd42a..7bec902315 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -397,6 +397,8 @@ pub fn boot_to_epoch_3(
             &Pox4SignatureTopic::StackStx,
             CHAIN_ID_TESTNET,
             12_u128,
+            u128::MAX,
+            1,
         )
         .unwrap()
         .to_rsv();
@@ -418,6 +420,8 @@ pub fn boot_to_epoch_3(
                 clarity::vm::Value::some(clarity::vm::Value::buff_from(signature).unwrap())
                     .unwrap(),
                 clarity::vm::Value::buff_from(signer_pk.to_bytes_compressed()).unwrap(),
+                clarity::vm::Value::UInt(u128::MAX),
+                clarity::vm::Value::UInt(1),
             ],
         );
         submit_tx(&http_origin, &stacking_tx);
@@ -642,6 +646,8 @@ pub fn boot_to_epoch_3_reward_set(
             &Pox4SignatureTopic::StackStx,
             CHAIN_ID_TESTNET,
             lock_period,
+            u128::MAX,
+            1,
         )
         .unwrap()
         .to_rsv();
@@ -662,6 +668,8 @@ pub fn boot_to_epoch_3_reward_set(
                 clarity::vm::Value::some(clarity::vm::Value::buff_from(signature).unwrap())
                     .unwrap(),
                 clarity::vm::Value::buff_from(signer_pk.to_bytes_compressed()).unwrap(),
+                clarity::vm::Value::UInt(u128::MAX),
+                clarity::vm::Value::UInt(1),
             ],
         );
         submit_tx(&http_origin, &stacking_tx);
@@ -1232,6 +1240,8 @@ fn correct_burn_outs() {
                 &Pox4SignatureTopic::StackStx,
                 CHAIN_ID_TESTNET,
                 1_u128,
+                u128::MAX,
+                1,
             )
             .unwrap()
             .to_rsv();
@@ -1251,6 +1261,8 @@ fn correct_burn_outs() {
                     clarity::vm::Value::some(clarity::vm::Value::buff_from(signature).unwrap())
                         .unwrap(),
                     clarity::vm::Value::buff_from(pk_bytes).unwrap(),
+                    clarity::vm::Value::UInt(u128::MAX),
+                    clarity::vm::Value::UInt(1),
                 ],
             );
             let txid = submit_tx(&http_origin, &stacking_tx);

From f27c77453ddefdea57e1c2413e0e881c9bb31713 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Thu, 29 Feb 2024 16:09:49 -0800
Subject: [PATCH 0980/1166] feat: tests for new signer key auth fields

---
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 554 ++++++++++++++++--
 1 file changed, 501 insertions(+), 53 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index a914646b5f..329a82bd75 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -41,6 +41,7 @@ use stacks_common::types::chainstate::{
 use stacks_common::types::{Address, PrivateKey};
 use stacks_common::util::hash::{hex_bytes, to_hex, Sha256Sum, Sha512Trunc256Sum};
 use stacks_common::util::secp256k1::{Secp256k1PrivateKey, Secp256k1PublicKey};
+use stdext::num::integer::Integer;
 use wsts::curve::point::{Compressed, Point};
 
 use super::test::*;
@@ -1699,11 +1700,83 @@ fn verify_signer_key_signatures() {
 
     assert_eq!(result, expected_error);
 
-    // TODO: using incorrect auth-id
-    // TODO: using incorrect max-amount
-    // TODO: using amount > max-amount
+    // Test incorrect auth-id
+    let signature = make_signer_key_signature(
+        &bob_pox_addr,
+        &bob,
+        reward_cycle,
+        &topic,
+        period,
+        u128::MAX,
+        1,
+    );
+    let result = verify_signer_key_sig(
+        &signature,
+        &bob_public_key,
+        &bob_pox_addr,
+        &mut peer,
+        &latest_block,
+        reward_cycle,
+        period,
+        &topic,
+        1,
+        u128::MAX,
+        2, // different
+    );
+    assert_eq!(result, expected_error);
 
-    // Test 6: using a valid signature
+    // Test incorrect max-amount
+    let signature = make_signer_key_signature(
+        &bob_pox_addr,
+        &bob,
+        reward_cycle,
+        &topic,
+        period,
+        u128::MAX,
+        1,
+    );
+    let result = verify_signer_key_sig(
+        &signature,
+        &bob_public_key,
+        &bob_pox_addr,
+        &mut peer,
+        &latest_block,
+        reward_cycle,
+        period,
+        &topic,
+        1,
+        11111, // different
+        1,
+    );
+    assert_eq!(result, expected_error);
+
+    // Test amount > max-amount
+    let signature = make_signer_key_signature(
+        &bob_pox_addr,
+        &bob,
+        reward_cycle,
+        &topic,
+        period,
+        4, // less than max to invalidate `amount`
+        1,
+    );
+    let result = verify_signer_key_sig(
+        &signature,
+        &bob_public_key,
+        &bob_pox_addr,
+        &mut peer,
+        &latest_block,
+        reward_cycle,
+        period,
+        &topic,
+        5, // different
+        4, // less than amount
+        1,
+    );
+    // Different error code
+    assert_eq!(result, Value::error(Value::Int(37)).unwrap());
+
+    // Test using a valid signature
 
     let signature = make_signer_key_signature(
         &bob_pox_addr,
@@ -1884,11 +1957,82 @@ fn stack_stx_verify_signer_sig() {
         1,
     );
 
-    // TODO: invalid auth-id
-    // TODO: invalid amount
-    // TODO: invalid max-amount
+    // Test invalid auth-id
+    stacker_nonce += 1;
+    let signature = make_signer_key_signature(
+        &pox_addr,
+        &signer_key,
+        reward_cycle,
+        &topic,
+        lock_period,
+        u128::MAX,
+        1,
+    );
+    let invalid_auth_id_nonce = stacker_nonce;
+    let invalid_auth_id_tx = make_pox_4_lockup(
+        &stacker_key,
+        stacker_nonce,
+        min_ustx,
+        &pox_addr,
+        lock_period,
+        &signer_public_key,
+        block_height,
+        Some(signature),
+        u128::MAX,
+        2, // wrong auth-id
+    );
+
+    // Test invalid amount
+    stacker_nonce += 1;
+    let signature = make_signer_key_signature(
+        &pox_addr,
+        &signer_key,
+        reward_cycle,
+        &topic,
+        lock_period,
+        min_ustx.saturating_sub(1),
+        1,
+    );
+    let invalid_amount_nonce = stacker_nonce;
+    let invalid_amount_tx = make_pox_4_lockup(
+        &stacker_key,
+        stacker_nonce,
+        min_ustx,
+        &pox_addr,
+        lock_period,
+        &signer_public_key,
+        block_height,
+        Some(signature),
+        min_ustx.saturating_sub(1),
+        1,
+    );
+
+    // Test invalid max-amount
+    stacker_nonce += 1;
+    let signature = make_signer_key_signature(
+        &pox_addr,
+        &signer_key,
+        reward_cycle,
+        &topic,
+        lock_period,
+        u128::MAX.saturating_sub(1),
+        1,
+    );
+    let invalid_max_amount_nonce = stacker_nonce;
+    let invalid_max_amount_tx = make_pox_4_lockup(
+        &stacker_key,
+        stacker_nonce,
+        min_ustx,
+        &pox_addr,
+        lock_period,
+        &signer_public_key,
+        block_height,
+        Some(signature),
+        u128::MAX, // different than signature
+        1,
+    );
 
-    // Test 6: valid signature
+    // Test: valid signature
     stacker_nonce += 1;
     let signature = make_signer_key_signature(
         &pox_addr,
@@ -1908,7 +2052,7 @@ fn stack_stx_verify_signer_sig() {
         lock_period,
         &signer_public_key,
         block_height,
-        Some(signature),
+        Some(signature.clone()),
         u128::MAX,
         1,
     );
@@ -1919,10 +2063,13 @@ fn stack_stx_verify_signer_sig() {
         invalid_key_tx,
         invalid_topic_tx,
         invalid_period_tx,
+        invalid_auth_id_tx,
+        invalid_amount_tx,
+        invalid_max_amount_tx,
         valid_tx,
     ];
 
-    peer.tenure_with_txs(&txs, &mut coinbase_nonce);
+    let latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
 
     let stacker_txs = get_last_block_sender_transactions(&observer, stacker_addr);
     let expected_error = Value::error(Value::Int(35)).unwrap();
@@ -1935,11 +2082,47 @@ fn stack_stx_verify_signer_sig() {
     assert_eq!(tx_result(invalid_key_nonce), expected_error);
     assert_eq!(tx_result(invalid_period_nonce), expected_error);
     assert_eq!(tx_result(invalid_topic_nonce), expected_error);
+    assert_eq!(tx_result(invalid_auth_id_nonce), expected_error);
+    assert_eq!(tx_result(invalid_max_amount_nonce), expected_error);
+    assert_eq!(
+        tx_result(invalid_amount_nonce),
+        Value::error(Value::Int(37)).unwrap()
+    );
 
     // valid tx should succeed
     tx_result(valid_nonce)
         .expect_result_ok()
         .expect("Expected ok result from tx");
+
+    // Ensure that the used signature cannot be re-used
+    let result = verify_signer_key_sig(
+        &signature,
+        &signer_public_key,
+        &pox_addr,
+        &mut peer,
+        &latest_block,
+        reward_cycle,
+        lock_period,
+        &topic,
+        min_ustx,
+        u128::MAX,
+        1,
+    );
+    let expected_error = Value::error(Value::Int(38)).unwrap();
+    assert_eq!(result, expected_error);
+
+    // Ensure the authorization is stored as used
+    let entry = get_signer_key_authorization_used_pox_4(
+        &mut peer,
+        &latest_block,
+        &pox_addr,
+        reward_cycle.try_into().unwrap(),
+        &topic,
+        lock_period,
+        &signer_public_key,
+        u128::MAX,
+        1,
+    );
 }
 
 #[test]
@@ -2061,7 +2244,74 @@ fn stack_extend_verify_sig() {
         1,
     );
 
-    // TODO: invalid auth-id, amount, max-amount
+    // Test invalid auth-id
+    stacker_nonce += 1;
+    let signature = make_signer_key_signature(
+        &pox_addr,
+        &signer_key,
+        reward_cycle,
+        &topic,
+        lock_period,
+        u128::MAX,
+        1,
+    );
+    let invalid_auth_id_nonce = stacker_nonce;
+    let invalid_auth_id_tx = make_pox_4_extend(
+        &stacker_key,
+        stacker_nonce,
+        pox_addr.clone(),
+        lock_period,
+        signer_public_key.clone(),
+        Some(signature),
+        u128::MAX,
+        2, // wrong auth-id
+    );
+
+    // Test invalid max-amount
+    stacker_nonce += 1;
+    let signature = make_signer_key_signature(
+        &pox_addr,
+        &signer_key,
+        reward_cycle,
+        &topic,
+        lock_period,
+        u128::MAX.saturating_sub(1),
+        1,
+    );
+    let invalid_max_amount_nonce = stacker_nonce;
+    let invalid_max_amount_tx = make_pox_4_extend(
+        &stacker_key,
+        stacker_nonce,
+        pox_addr.clone(),
+        lock_period,
+        signer_public_key.clone(),
+        Some(signature),
+        u128::MAX, // different than signature
+        1,
+    );
+
+    // Test invalid amount
+    stacker_nonce += 1;
+    let signature = make_signer_key_signature(
+        &pox_addr,
+        &signer_key,
+        reward_cycle,
+        &topic,
+        lock_period,
+        min_ustx.saturating_sub(1),
+        1,
+    );
+    let invalid_amount_nonce = stacker_nonce;
+    let invalid_amount_tx = make_pox_4_extend(
+        &stacker_key,
+        stacker_nonce,
+        pox_addr.clone(),
+        lock_period,
+        signer_public_key.clone(),
+        Some(signature),
+        min_ustx.saturating_sub(1), // less than amount
+        1,
+    );
 
     // Test 4: valid stack-extend
     stacker_nonce += 1;
@@ -2078,20 +2328,23 @@ fn stack_extend_verify_sig() {
     let valid_tx = make_pox_4_extend(
         &stacker_key,
         stacker_nonce,
-        pox_addr,
+        pox_addr.clone(),
         lock_period,
         signer_public_key.clone(),
-        Some(signature),
+        Some(signature.clone()),
         u128::MAX,
         1,
     );
 
-    peer.tenure_with_txs(
+    let latest_block = peer.tenure_with_txs(
         &[
             stack_tx,
             invalid_cycle_tx,
             invalid_stacker_tx,
             invalid_key_tx,
+            invalid_auth_id_tx,
+            invalid_max_amount_tx,
+            invalid_amount_tx,
             valid_tx,
         ],
         &mut coinbase_nonce,
@@ -2109,9 +2362,47 @@ fn stack_extend_verify_sig() {
     assert_eq!(tx_result(invalid_cycle_nonce), expected_error);
     assert_eq!(tx_result(invalid_stacker_nonce), expected_error);
     assert_eq!(tx_result(invalid_key_nonce), expected_error);
+    assert_eq!(tx_result(invalid_auth_id_nonce), expected_error);
+    assert_eq!(tx_result(invalid_max_amount_nonce), expected_error);
+    assert_eq!(
+        tx_result(invalid_amount_nonce),
+        Value::error(Value::Int(37)).unwrap()
+    );
+
+    // valid tx should succeed
     tx_result(valid_nonce)
         .expect_result_ok()
         .expect("Expected ok result from tx");
+
+    // Ensure that the used signature cannot be re-used
+    let result = verify_signer_key_sig(
+        &signature,
+        &signer_public_key,
+        &pox_addr,
+        &mut peer,
+        &latest_block,
+        reward_cycle,
+        lock_period,
+        &topic,
+        min_ustx,
+        u128::MAX,
+        1,
+    );
+    let expected_error = Value::error(Value::Int(38)).unwrap();
+    assert_eq!(result, expected_error);
+
+    // Ensure the authorization is stored as used
+    let entry = get_signer_key_authorization_used_pox_4(
+        &mut peer,
+        &latest_block,
+        &pox_addr,
+        reward_cycle.try_into().unwrap(),
+        &topic,
+        lock_period,
+        &signer_public_key,
+        u128::MAX,
+        1,
+    );
 }
 
 #[test]
@@ -2285,11 +2576,76 @@ fn stack_agg_commit_verify_sig() {
         1,
     );
 
-    // TODO: using incorrect auth-id
-    // TODO: using incorrect max-amount
-    // TODO: using amount > max-amount
+    // Test using incorrect auth-id
+    delegate_nonce += 1;
+    let signature = make_signer_key_signature(
+        &pox_addr,
+        &signer_sk,
+        next_reward_cycle,
+        &topic,
+        1_u128,
+        u128::MAX,
+        2, // wrong auth-id
+    );
+    let invalid_auth_id_nonce = delegate_nonce;
+    let invalid_auth_id_tx = make_pox_4_aggregation_commit_indexed(
+        &delegate_key,
+        delegate_nonce,
+        &pox_addr,
+        next_reward_cycle,
+        Some(signature),
+        &signer_pk,
+        u128::MAX,
+        1, // different auth-id
+    );
+
+    // Test incorrect max-amount
+    delegate_nonce += 1;
+    let signature = make_signer_key_signature(
+        &pox_addr,
+        &signer_sk,
+        next_reward_cycle,
+        &topic,
+        1_u128,
+        u128::MAX,
+        1,
+    );
+    let invalid_max_amount_nonce = delegate_nonce;
+    let invalid_max_amount_tx = make_pox_4_aggregation_commit_indexed(
+        &delegate_key,
+        delegate_nonce,
+        &pox_addr,
+        next_reward_cycle,
+        Some(signature),
+        &signer_pk,
+        u128::MAX - 1, // different max-amount
+        1,
+    );
+
+    // Test amount > max-amount
+    delegate_nonce += 1;
+    let signature = make_signer_key_signature(
+        &pox_addr,
+        &signer_sk,
+        next_reward_cycle,
+        &topic,
+        1_u128,
+        min_ustx.saturating_sub(1), // amount > max-amount
+        1,
+    );
+    let invalid_amount_nonce = delegate_nonce;
+    let invalid_amount_tx = make_pox_4_aggregation_commit_indexed(
+        &delegate_key,
+        delegate_nonce,
+        &pox_addr,
+        next_reward_cycle,
+        Some(signature),
+        &signer_pk,
+        min_ustx.saturating_sub(1), // amount > max-amount
+        1,
+    );
 
-    // Test 6: valid signature
+    // Test with valid signature
     delegate_nonce += 1;
     let signature = make_signer_key_signature(
         &pox_addr,
@@ -2306,13 +2662,13 @@ fn stack_agg_commit_verify_sig() {
         delegate_nonce,
         &pox_addr,
         next_reward_cycle,
-        Some(signature),
+        Some(signature.clone()),
         &signer_pk,
         u128::MAX,
         1,
     );
 
-    peer.tenure_with_txs(
+    let latest_block = peer.tenure_with_txs(
         &[
             delegate_tx,
             delegate_stack_stx_tx,
@@ -2321,6 +2677,9 @@ fn stack_agg_commit_verify_sig() {
             invalid_key_tx,
             invalid_period_tx,
             invalid_topic_tx,
+            invalid_auth_id_tx,
+            invalid_max_amount_tx,
+            invalid_amount_tx,
             valid_tx,
         ],
         &mut coinbase_nonce,
@@ -2331,6 +2690,7 @@ fn stack_agg_commit_verify_sig() {
     let tx_result = |nonce: u64| -> Value { txs.get(nonce as usize).unwrap().result.clone() };
 
     let expected_error = Value::error(Value::Int(35)).unwrap();
+    let amount_too_high_error = Value::error(Value::Int(37)).unwrap();
 
     tx_result(delegate_stack_stx_nonce)
         .expect_result_ok()
@@ -2340,9 +2700,42 @@ fn stack_agg_commit_verify_sig() {
     assert_eq!(tx_result(invalid_key_nonce), expected_error);
     assert_eq!(tx_result(invalid_period_nonce), expected_error);
     assert_eq!(tx_result(invalid_topic_nonce), expected_error);
+    assert_eq!(tx_result(invalid_auth_id_nonce), expected_error);
+    assert_eq!(tx_result(invalid_max_amount_nonce), expected_error);
+    assert_eq!(tx_result(invalid_amount_nonce), amount_too_high_error);
     tx_result(valid_nonce)
         .expect_result_ok()
         .expect("Expected ok result from tx");
+
+    // Ensure that the used signature cannot be re-used
+    let result = verify_signer_key_sig(
+        &signature,
+        &signer_pk,
+        &pox_addr,
+        &mut peer,
+        &latest_block,
+        reward_cycle,
+        1,
+        &topic,
+        min_ustx,
+        u128::MAX,
+        1,
+    );
+    let expected_error = Value::error(Value::Int(38)).unwrap();
+    assert_eq!(result, expected_error);
+
+    // Ensure the authorization is stored as used
+    let entry = get_signer_key_authorization_used_pox_4(
+        &mut peer,
+        &latest_block,
+        &pox_addr,
+        reward_cycle.try_into().unwrap(),
+        &topic,
+        1,
+        &signer_pk,
+        u128::MAX,
+        1,
+    );
 }
 
 pub fn assert_latest_was_burn(peer: &mut TestPeer) {
@@ -3647,6 +4040,37 @@ pub fn get_stacking_state_pox_4(
     })
 }
 
+pub fn make_signer_key_authorization_lookup_key(
+    pox_addr: &PoxAddress,
+    reward_cycle: u64,
+    topic: &Pox4SignatureTopic,
+    period: u128,
+    signer_key: &StacksPublicKey,
+    max_amount: u128,
+    auth_id: u128,
+) -> Value {
+    TupleData::from_data(vec![
+        (
+            "pox-addr".into(),
+            pox_addr.as_clarity_tuple().unwrap().into(),
+        ),
+        ("reward-cycle".into(), Value::UInt(reward_cycle.into())),
+        (
+            "topic".into(),
+            Value::string_ascii_from_bytes(topic.get_name_str().into()).unwrap(),
+        ),
+        ("period".into(), Value::UInt(period.into())),
+        (
+            "signer-key".into(),
+            Value::buff_from(signer_key.to_bytes_compressed()).unwrap(),
+        ),
+        ("max-amount".into(), Value::UInt(max_amount)),
+        ("auth-id".into(), Value::UInt(auth_id)),
+    ])
+    .unwrap()
+    .into()
+}
+
 pub fn get_signer_key_authorization_pox_4(
     peer: &mut TestPeer,
     tip: &StacksBlockId,
@@ -3659,42 +4083,66 @@ pub fn get_signer_key_authorization_pox_4(
     auth_id: u128,
 ) -> Option<bool> {
     with_clarity_db_ro(peer, tip, |db| {
-        let lookup_tuple = TupleData::from_data(vec![
-            (
-                "pox-addr".into(),
-                pox_addr.as_clarity_tuple().unwrap().into(),
-            ),
-            ("reward-cycle".into(), Value::UInt(reward_cycle.into())),
-            (
-                "topic".into(),
-                Value::string_ascii_from_bytes(topic.get_name_str().into()).unwrap(),
-            ),
-            ("period".into(), Value::UInt(period.into())),
-            (
-                "signer-key".into(),
-                Value::buff_from(signer_key.to_bytes_compressed()).unwrap(),
-            ),
-            ("max-amount".into(), Value::UInt(max_amount)),
-            ("auth-id".into(), Value::UInt(auth_id)),
-        ])
+        let lookup_tuple = make_signer_key_authorization_lookup_key(
+            &pox_addr,
+            reward_cycle,
+            &topic,
+            period,
+            &signer_key,
+            max_amount,
+            auth_id,
+        );
+        let epoch = db.get_clarity_epoch_version().unwrap();
+        db.fetch_entry_unknown_descriptor(
+            &boot_code_id(boot::POX_4_NAME, false),
+            "signer-key-authorizations",
+            &lookup_tuple,
+            &epoch,
+        )
         .unwrap()
-        .into();
+        .expect_optional()
+        .unwrap()
+        .map(|v| v.expect_bool().unwrap())
+    })
+}
+
+/// Lookup in the `used-signer-key-authorizations` map
+/// for a specific signer key authorization. If no entry is
+/// found, `false` is returned.
+pub fn get_signer_key_authorization_used_pox_4(
+    peer: &mut TestPeer,
+    tip: &StacksBlockId,
+    pox_addr: &PoxAddress,
+    reward_cycle: u64,
+    topic: &Pox4SignatureTopic,
+    period: u128,
+    signer_key: &StacksPublicKey,
+    max_amount: u128,
+    auth_id: u128,
+) -> bool {
+    with_clarity_db_ro(peer, tip, |db| {
+        let lookup_tuple = make_signer_key_authorization_lookup_key(
+            &pox_addr,
+            reward_cycle,
+            &topic,
+            period,
+            &signer_key,
+            max_amount,
+            auth_id,
+        );
         let epoch = db.get_clarity_epoch_version().unwrap();
-        let map_entry = db
-            .fetch_entry_unknown_descriptor(
-                &boot_code_id(boot::POX_4_NAME, false),
-                "signer-key-authorizations",
-                &lookup_tuple,
-                &epoch,
-            )
-            .unwrap()
-            .expect_optional()
-            .unwrap();
-        match map_entry {
-            Some(v) => Some(v.expect_bool().unwrap()),
-            None => None,
-        }
+        db.fetch_entry_unknown_descriptor(
+            &boot_code_id(boot::POX_4_NAME, false),
+            "used-signer-key-authorizations",
+            &lookup_tuple,
+            &epoch,
+        )
+        .unwrap()
+        .expect_optional()
+        .unwrap()
+        .map(|v| v.expect_bool().unwrap())
     })
+    .unwrap_or(false)
 }
 
 pub fn get_partially_stacked_state_pox_4(

From a9ef3ba14f4f0d6d992ada06d689dbd6a1244712 Mon Sep 17 00:00:00 2001
From: MarvinJanssen <MarvinJanssen@users.noreply.github.com>
Date: Fri, 1 Mar 2024 14:08:41 +0100
Subject: [PATCH 0981/1166] chore: enabled disabled unit test

---
 .../tests/bns/name_register.test.ts           | 75 +++++++++----------
 1 file changed, 37 insertions(+), 38 deletions(-)

diff --git a/contrib/core-contract-tests/tests/bns/name_register.test.ts b/contrib/core-contract-tests/tests/bns/name_register.test.ts
index 448df6b322..0647b0a9cc 100644
--- a/contrib/core-contract-tests/tests/bns/name_register.test.ts
+++ b/contrib/core-contract-tests/tests/bns/name_register.test.ts
@@ -557,42 +557,41 @@ describe("register a name again before and after expiration", () => {
     expect(register.result).toBeOk(Cl.bool(true));
   });
 
-  // temp disabled, focusing on importing clarunit correctly
-  // it("should allow someone else to register after expiration", () => {
-  //   simnet.mineEmptyBlocks(cases[0].renewalRule + 5001);
-
-  //   const name = "bob";
-  //   const salt = "2222";
-  //   const merged = new TextEncoder().encode(`${name}.${cases[0].namespace}${salt}`);
-  //   const sha256 = createHash("sha256").update(merged).digest();
-  //   const ripemd160 = createHash("ripemd160").update(sha256).digest();
-  //   simnet.callPublicFn("bns", "name-preorder", [Cl.buffer(ripemd160), Cl.uint(2560000)], charlie);
-  //   const register = simnet.callPublicFn(
-  //     "bns",
-  //     "name-register",
-  //     [
-  //       Cl.bufferFromAscii(cases[0].namespace),
-  //       Cl.bufferFromAscii(name),
-  //       Cl.bufferFromAscii(salt),
-  //       Cl.bufferFromAscii("CHARLIE"),
-  //     ],
-  //     charlie
-  //   );
-  //   expect(register.result).toBeOk(Cl.bool(true));
-
-  //   const resolve = simnet.callReadOnlyFn(
-  //     "bns",
-  //     "name-resolve",
-  //     [Cl.bufferFromAscii(cases[0].namespace), Cl.bufferFromAscii(name)],
-  //     alice
-  //   );
-  //   expect(resolve.result).toBeOk(
-  //     Cl.tuple({
-  //       owner: Cl.standardPrincipal(charlie),
-  //       ["zonefile-hash"]: Cl.bufferFromAscii("CHARLIE"),
-  //       ["lease-ending-at"]: Cl.some(Cl.uint(5030)),
-  //       ["lease-started-at"]: Cl.uint(5020),
-  //     })
-  //   );
-  // });
+  it("should allow someone else to register after expiration", () => {
+    simnet.mineEmptyBlocks(cases[0].renewalRule + 5001);
+
+    const name = "bob";
+    const salt = "2222";
+    const merged = new TextEncoder().encode(`${name}.${cases[0].namespace}${salt}`);
+    const sha256 = createHash("sha256").update(merged).digest();
+    const ripemd160 = createHash("ripemd160").update(sha256).digest();
+    simnet.callPublicFn("bns", "name-preorder", [Cl.buffer(ripemd160), Cl.uint(2560000)], charlie);
+    const register = simnet.callPublicFn(
+      "bns",
+      "name-register",
+      [
+        Cl.bufferFromAscii(cases[0].namespace),
+        Cl.bufferFromAscii(name),
+        Cl.bufferFromAscii(salt),
+        Cl.bufferFromAscii("CHARLIE"),
+      ],
+      charlie
+    );
+    expect(register.result).toBeOk(Cl.bool(true));
+
+    const resolve = simnet.callReadOnlyFn(
+      "bns",
+      "name-resolve",
+      [Cl.bufferFromAscii(cases[0].namespace), Cl.bufferFromAscii(name)],
+      alice
+    );
+    expect(resolve.result).toBeOk(
+      Cl.tuple({
+        owner: Cl.standardPrincipal(charlie),
+        ["zonefile-hash"]: Cl.bufferFromAscii("CHARLIE"),
+        ["lease-ending-at"]: Cl.some(Cl.uint(5029)),
+        ["lease-started-at"]: Cl.uint(5019),
+      })
+    );
+  });
 });

From 533bf19f7c7f1819e2641c2cea87ff1cfea9c045 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Mon, 26 Feb 2024 18:28:37 -0500
Subject: [PATCH 0982/1166] Filter only invalid formed transactions and enforce
 one per signer in stacks-signer

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/mod.rs |   9 -
 stacks-signer/src/runloop.rs    |   8 +-
 stacks-signer/src/signer.rs     | 728 ++++++++++++--------------------
 3 files changed, 268 insertions(+), 477 deletions(-)

diff --git a/stacks-signer/src/client/mod.rs b/stacks-signer/src/client/mod.rs
index 959ce56dbf..138913ee6c 100644
--- a/stacks-signer/src/client/mod.rs
+++ b/stacks-signer/src/client/mod.rs
@@ -207,15 +207,6 @@ pub(crate) mod tests {
         TcpListener::bind(config.node_host).unwrap()
     }
 
-    /// Create a mock server on the same port as the config and write a response to it
-    pub fn mock_server_from_config_and_write_response(
-        config: &GlobalConfig,
-        bytes: &[u8],
-    ) -> [u8; 1024] {
-        let mock_server = mock_server_from_config(config);
-        write_response(mock_server, bytes)
-    }
-
     /// Write a response to the mock server and return the request bytes
     pub fn write_response(mock_server: TcpListener, bytes: &[u8]) -> [u8; 1024] {
         debug!("Writing a response...");
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 0b6a0c05a3..02fb494c6a 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -156,6 +156,12 @@ impl RunLoop {
                     if signer.reward_cycle == prior_reward_cycle {
                         // The signers have been calculated for the next reward cycle. Update the current one
                         debug!("Signer #{}: Next reward cycle ({reward_cycle}) signer set calculated. Updating current reward cycle ({prior_reward_cycle}) signer.", signer.signer_id);
+                        signer.next_signers = new_signer_config
+                            .registered_signers
+                            .signer_ids
+                            .keys()
+                            .copied()
+                            .collect();
                         signer.next_signer_ids = new_signer_config
                             .registered_signers
                             .signer_ids
@@ -201,7 +207,7 @@ impl RunLoop {
             if signer.approved_aggregate_public_key.is_none() {
                 retry_with_exponential_backoff(|| {
                     signer
-                        .update_dkg(&self.stacks_client, current_reward_cycle)
+                        .update_dkg(&self.stacks_client)
                         .map_err(backoff::Error::transient)
                 })?;
             }
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index 27f42dd69f..f2e5c92e38 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -134,10 +134,14 @@ pub struct Signer {
     pub signer_ids: Vec<u32>,
     /// The addresses of other signers mapped to their signer slot ID
     pub signer_slot_ids: HashMap<StacksAddress, u32>,
+    /// The addresses of other signers
+    pub signers: Vec<StacksAddress>,
     /// The other signer ids for the NEXT reward cycle's signers
     pub next_signer_ids: Vec<u32>,
     /// The signer addresses mapped to slot ID for the NEXT reward cycle's signers
     pub next_signer_slot_ids: HashMap<StacksAddress, u32>,
+    /// The addresses of the signers for the NEXT reward cycle
+    pub next_signers: Vec<StacksAddress>,
     /// The reward cycle this signer belongs to
     pub reward_cycle: u64,
     /// The tx fee in uSTX to use if the epoch is pre Nakamoto (Epoch 3.0)
@@ -209,8 +213,15 @@ impl From<SignerConfig> for Signer {
                 .copied()
                 .collect(),
             signer_slot_ids: signer_config.registered_signers.signer_slot_ids,
+            signers: signer_config
+                .registered_signers
+                .signer_ids
+                .keys()
+                .copied()
+                .collect(),
             next_signer_ids: vec![],
             next_signer_slot_ids: HashMap::new(),
+            next_signers: vec![],
             reward_cycle: signer_config.reward_cycle,
             tx_fee_ustx: signer_config.tx_fee_ustx,
             coordinator_selector,
@@ -353,7 +364,6 @@ impl Signer {
         stacks_client: &StacksClient,
         block_validate_response: &BlockValidateResponse,
         res: Sender<Vec<OperationResult>>,
-        current_reward_cycle: u64,
     ) {
         let block_info = match block_validate_response {
             BlockValidateResponse::Ok(block_validate_ok) => {
@@ -364,11 +374,7 @@ impl Signer {
                     debug!("Signer #{}: Received a block validate response for a block we have not seen before. Ignoring...", self.signer_id);
                     return;
                 };
-                let is_valid = self.verify_block_transactions(
-                    stacks_client,
-                    &block_info.block,
-                    current_reward_cycle,
-                );
+                let is_valid = self.verify_block_transactions(stacks_client, &block_info.block);
                 block_info.valid = Some(is_valid);
                 info!(
                     "Signer #{}: Treating block validation for block {} as valid: {:?}",
@@ -413,7 +419,7 @@ impl Signer {
                 msg: Message::NonceRequest(nonce_request),
                 sig: vec![],
             };
-            self.handle_packets(stacks_client, res, &[packet], current_reward_cycle);
+            self.handle_packets(stacks_client, res, &[packet]);
         } else {
             let coordinator_id = self.coordinator_selector.get_coordinator().0;
             if block_info.valid.unwrap_or(false)
@@ -449,7 +455,6 @@ impl Signer {
         stacks_client: &StacksClient,
         res: Sender<Vec<OperationResult>>,
         messages: &[SignerMessage],
-        current_reward_cycle: u64,
     ) {
         let coordinator_pubkey = self.coordinator_selector.get_coordinator().1;
         let packets: Vec<Packet> = messages
@@ -462,7 +467,7 @@ impl Signer {
                 }
             })
             .collect();
-        self.handle_packets(stacks_client, res, &packets, current_reward_cycle);
+        self.handle_packets(stacks_client, res, &packets);
     }
 
     /// Handle proposed blocks submitted by the miners to stackerdb
@@ -492,7 +497,6 @@ impl Signer {
         stacks_client: &StacksClient,
         res: Sender<Vec<OperationResult>>,
         packets: &[Packet],
-        current_reward_cycle: u64,
     ) {
         let signer_outbound_messages = self
             .signing_round
@@ -520,7 +524,7 @@ impl Signer {
         if !operation_results.is_empty() {
             // We have finished a signing or DKG round, either successfully or due to error.
             // Regardless of the why, update our state to Idle as we should not expect the operation to continue.
-            self.process_operation_results(stacks_client, &operation_results, current_reward_cycle);
+            self.process_operation_results(stacks_client, &operation_results);
             self.send_operation_results(res, operation_results);
             self.finish_operation();
         } else if !packets.is_empty() && self.coordinator.state != CoordinatorState::Idle {
@@ -631,7 +635,6 @@ impl Signer {
         &mut self,
         stacks_client: &StacksClient,
         block: &NakamotoBlock,
-        current_reward_cycle: u64,
     ) -> bool {
         if self.approved_aggregate_public_key.is_some() {
             // We do not enforce a block contain any transactions except the aggregate votes when it is NOT already set
@@ -639,9 +642,7 @@ impl Signer {
             debug!("Signer #{}: Already have an aggregate key for reward cycle {}. Skipping transaction verification...", self.signer_id, self.reward_cycle);
             return true;
         }
-        if let Ok(expected_transactions) =
-            self.get_expected_transactions(stacks_client, current_reward_cycle)
-        {
+        if let Ok(expected_transactions) = self.get_expected_transactions(stacks_client) {
             //It might be worth building a hashset of the blocks' txids and checking that against the expected transaction's txid.
             let block_tx_hashset = block.txs.iter().map(|tx| tx.txid()).collect::<HashSet<_>>();
             // Ensure the block contains the transactions we expect
@@ -708,144 +709,73 @@ impl Signer {
         }
     }
 
-    /// Filter out transactions from the stackerdb that are not valid
-    /// i.e. not valid vote-for-aggregate-public-key transactions from registered signers
-    fn filter_invalid_transactions(
+    /// Select one transaction per address by sorting based first on nonce and then txid
+    fn filter_one_transaction_per_address(
         &self,
-        stacks_client: &StacksClient,
-        current_reward_cycle: u64,
-        signer_slot_ids: &HashMap<StacksAddress, u32>,
-        transaction: StacksTransaction,
-    ) -> Option<StacksTransaction> {
-        // Filter out transactions that have already been confirmed (can happen if a signer did not update stacker db since the last block was processed)
+        transactions: Vec<StacksTransaction>,
+    ) -> Vec<StacksTransaction> {
+        let mut filtered_transactions: HashMap<StacksAddress, StacksTransaction> = HashMap::new();
+        for transaction in transactions {
+            let origin_address = transaction.origin_address();
+            let origin_nonce = transaction.get_origin_nonce();
+            if let Some(entry) = filtered_transactions.get_mut(&origin_address) {
+                let entry_nonce = entry.get_origin_nonce();
+                if entry_nonce > origin_nonce
+                    || (entry_nonce == origin_nonce && entry.txid() > transaction.txid())
+                {
+                    *entry = transaction;
+                }
+            } else {
+                filtered_transactions.insert(origin_address, transaction);
+            }
+        }
+        filtered_transactions.into_values().collect()
+    }
+
+    /// Verify that the transaction is a valid vote for the aggregate public key
+    /// Note: it does not verify the function arguments, only that the transaction is validly formed
+    fn valid_vote_transaction(
+        &self,
+        account_nonces: &HashMap<StacksAddress, u64>,
+        transaction: &StacksTransaction,
+    ) -> bool {
         let origin_address = transaction.origin_address();
         let origin_nonce = transaction.get_origin_nonce();
-        let Some(origin_signer_id) = signer_slot_ids.get(&origin_address) else {
+        let Some(account_nonce) = account_nonces.get(&origin_address) else {
             debug!(
-                "Signer #{}: Unrecognized origin address ({origin_address}). Filtering ({}).",
-                self.signer_id,
-                transaction.txid()
-            );
-            return None;
-        };
-        let Ok(account_nonce) = retry_with_exponential_backoff(|| {
-            stacks_client
-                .get_account_nonce(&origin_address)
-                .map_err(backoff::Error::transient)
-        }) else {
-            warn!(
-                "Signer #{}: Unable to get account for transaction origin address: {origin_address}. Filtering ({}).",
+                "Signer #{}: Unrecognized origin address ({origin_address}).",
                 self.signer_id,
-                transaction.txid()
             );
-            return None;
+            return false;
         };
-        // TODO: add a check that we don't have two conflicting transactions in the same block from the same signer. This is a potential attack vector (will result in an invalid block)
-        if origin_nonce < account_nonce {
-            debug!("Signer #{}: Received a transaction with an outdated nonce ({account_nonce} < {origin_nonce}). Filtering ({}).", self.signer_id, transaction.txid());
-            return None;
-        }
         if transaction.is_mainnet() != self.mainnet {
             debug!(
-                "Signer #{}: Received a transaction with an unexpected network. Filtering ({}).",
+                "Signer #{}: Received a transaction for an unexpected network.",
                 self.signer_id,
-                transaction.txid()
             );
-            return None;
-        }
-        let Ok(valid) = retry_with_exponential_backoff(|| {
-            self.verify_payload(
-                stacks_client,
-                &transaction,
-                *origin_signer_id,
-                current_reward_cycle,
-            )
-            .map_err(backoff::Error::transient)
-        }) else {
-            warn!(
-                "Signer #{}: Unable to validate transaction payload. Filtering ({}).",
-                self.signer_id,
-                transaction.txid()
-            );
-            return None;
-        };
-        if !valid {
-            debug!(
-                "Signer #{}: Received a transaction with an invalid payload. Filtering ({}).",
-                self.signer_id,
-                transaction.txid()
-            );
-            return None;
-        }
-        debug!(
-            "Signer #{}: Expect transaction {} ({transaction:?})",
-            self.signer_id,
-            transaction.txid()
-        );
-        Some(transaction)
-    }
-
-    ///Helper function to verify the payload contents of a transaction are as expected
-    fn verify_payload(
-        &self,
-        stacks_client: &StacksClient,
-        transaction: &StacksTransaction,
-        origin_signer_id: u32,
-        current_reward_cycle: u64,
-    ) -> Result<bool, ClientError> {
-        let Some((index, _point, round, reward_cycle)) =
-            Self::parse_vote_for_aggregate_public_key(transaction)
-        else {
-            // The transaction is not a valid vote-for-aggregate-public-key transaction
-            return Ok(false);
-        };
-        if index != origin_signer_id as u64 {
-            // The signer is attempting to vote for another signer id than their own
-            return Ok(false);
-        }
-        let next_reward_cycle = current_reward_cycle.wrapping_add(1);
-        if reward_cycle != next_reward_cycle {
-            // The signer is attempting to vote for a reward cycle that is not the next reward cycle
-            return Ok(false);
-        }
-
-        let vote = stacks_client.get_vote_for_aggregate_public_key(
-            round,
-            reward_cycle,
-            transaction.origin_address(),
-        )?;
-        if vote.is_some() {
-            // The signer has already voted for this round and reward cycle
-            return Ok(false);
+            return false;
         }
-
-        let last_round = stacks_client.get_last_round(reward_cycle)?;
-        // TODO: should we impose a limit on the number of special cased transactions allowed for a single signer at any given time?? In theory only 1 would be required per dkg round i.e. per block
-        if last_round.unwrap_or(0).saturating_add(1) < round {
-            // Do not allow future votes. This is to prevent signers sending a bazillion votes for a future round and clogging the block space
-            // The signer is attempting to vote for a round that is greater than one past the last round
-            return Ok(false);
+        if origin_nonce < *account_nonce {
+            debug!("Signer #{}: Received a transaction with an outdated nonce ({account_nonce} < {origin_nonce}).", self.signer_id);
+            return false;
         }
-        Ok(true)
+        Self::parse_vote_for_aggregate_public_key(transaction).is_some()
     }
 
-    /// Get this signer's transactions from stackerdb, filtering out any invalid transactions
+    /// Get transactions from stackerdb for the given addresses and account nonces, filtering out any malformed transactions
     fn get_signer_transactions(
         &mut self,
-        stacks_client: &StacksClient,
-        current_reward_cycle: u64,
+        nonces: &HashMap<StacksAddress, u64>,
     ) -> Result<Vec<StacksTransaction>, ClientError> {
         let transactions: Vec<_> = self
             .stackerdb
             .get_current_transactions_with_retry(self.signer_id)?
             .into_iter()
             .filter_map(|tx| {
-                self.filter_invalid_transactions(
-                    stacks_client,
-                    current_reward_cycle,
-                    &self.signer_slot_ids,
-                    tx,
-                )
+                if !self.valid_vote_transaction(nonces, &tx) {
+                    return None;
+                }
+                Some(tx)
             })
             .collect();
         Ok(transactions)
@@ -855,7 +785,6 @@ impl Signer {
     fn get_expected_transactions(
         &mut self,
         stacks_client: &StacksClient,
-        current_reward_cycle: u64,
     ) -> Result<Vec<StacksTransaction>, ClientError> {
         if self.next_signer_ids.is_empty() {
             debug!(
@@ -864,20 +793,22 @@ impl Signer {
             );
             return Ok(vec![]);
         }
+        // Get all the account nonces for the next signers
+        let account_nonces = self.get_account_nonces(stacks_client, &self.next_signers);
         let transactions: Vec<_> = self
             .stackerdb
             .get_next_transactions_with_retry(&self.next_signer_ids)?
             .into_iter()
             .filter_map(|tx| {
-                self.filter_invalid_transactions(
-                    stacks_client,
-                    current_reward_cycle,
-                    &self.next_signer_slot_ids,
-                    tx,
-                )
+                if !self.valid_vote_transaction(&account_nonces, &tx) {
+                    return None;
+                }
+                Some(tx)
             })
             .collect();
-        Ok(transactions)
+
+        // We only allow enforcement of one special cased transaction per signer address per block
+        Ok(self.filter_one_transaction_per_address(transactions))
     }
 
     /// Determine the vote for a block and update the block info and nonce request accordingly
@@ -954,7 +885,6 @@ impl Signer {
         &mut self,
         stacks_client: &StacksClient,
         operation_results: &[OperationResult],
-        current_reward_cycle: u64,
     ) {
         for operation_result in operation_results {
             // Signers only every trigger non-taproot signing rounds over blocks. Ignore SignTaproot results
@@ -967,7 +897,7 @@ impl Signer {
                     debug!("Signer #{}: Received a signature result for a taproot signature. Nothing to broadcast as we currently sign blocks with a FROST signature.", self.signer_id);
                 }
                 OperationResult::Dkg(point) => {
-                    self.process_dkg(stacks_client, point, current_reward_cycle);
+                    self.process_dkg(stacks_client, point);
                 }
                 OperationResult::SignError(e) => {
                     warn!("Signer #{}: Received a Sign error: {e:?}", self.signer_id);
@@ -982,12 +912,7 @@ impl Signer {
     }
 
     /// Process a dkg result by broadcasting a vote to the stacks node
-    fn process_dkg(
-        &mut self,
-        stacks_client: &StacksClient,
-        point: &Point,
-        current_reward_cycle: u64,
-    ) {
+    fn process_dkg(&mut self, stacks_client: &StacksClient, point: &Point) {
         let epoch = retry_with_exponential_backoff(|| {
             stacks_client
                 .get_node_epoch()
@@ -1004,19 +929,41 @@ impl Signer {
             None
         };
         // Get our current nonce from the stacks node and compare it against what we have sitting in the stackerdb instance
-        let nonce = self.get_next_nonce(stacks_client, current_reward_cycle);
+        let signer_address = stacks_client.get_signer_address();
+        // Retreieve ALL account nonces as we may have transactions from other signers in our stackerdb slot that we care about
+        let account_nonces = self.get_account_nonces(stacks_client, &self.signers);
+        let account_nonce = account_nonces.get(signer_address).unwrap_or(&0);
+        let signer_transactions = retry_with_exponential_backoff(|| {
+            self.get_signer_transactions(&account_nonces)
+                .map_err(backoff::Error::transient)
+        })
+        .map_err(|e| {
+            warn!(
+                "Signer #{}: Unable to get signer transactions: {e:?}",
+                self.signer_id
+            );
+        })
+        .unwrap_or_default();
+        // If we have a transaction in the stackerdb slot, we need to increment the nonce hence the +1, else should use the account nonce
+        let next_nonce = signer_transactions
+            .first()
+            .map(|tx| tx.get_origin_nonce().wrapping_add(1))
+            .unwrap_or(*account_nonce);
         match stacks_client.build_vote_for_aggregate_public_key(
             self.stackerdb.get_signer_slot_id(),
             self.coordinator.current_dkg_id,
             *point,
             self.reward_cycle,
             tx_fee,
-            nonce,
+            next_nonce,
         ) {
-            Ok(transaction) => {
-                if let Err(e) =
-                    self.broadcast_dkg_vote(stacks_client, transaction, epoch, current_reward_cycle)
-                {
+            Ok(new_transaction) => {
+                if let Err(e) = self.broadcast_dkg_vote(
+                    stacks_client,
+                    epoch,
+                    signer_transactions,
+                    new_transaction,
+                ) {
                     warn!(
                         "Signer #{}: Failed to broadcast DKG vote ({point:?}): {e:?}",
                         self.signer_id
@@ -1032,42 +979,47 @@ impl Signer {
         }
     }
 
-    /// Get the next available nonce, taking into consideration the nonce we have sitting in stackerdb as well as the account nonce
-    fn get_next_nonce(&mut self, stacks_client: &StacksClient, current_reward_cycle: u64) -> u64 {
-        let signer_address = stacks_client.get_signer_address();
-        let mut next_nonce = stacks_client
-            .get_account_nonce(signer_address)
-            .map_err(|e| {
+    // Get the account nonces for the provided list of signer addresses
+    fn get_account_nonces(
+        &self,
+        stacks_client: &StacksClient,
+        signer_addresses: &[StacksAddress],
+    ) -> HashMap<StacksAddress, u64> {
+        let mut account_nonces = HashMap::with_capacity(signer_addresses.len());
+        for address in signer_addresses {
+            let Ok(account_nonce) = retry_with_exponential_backoff(|| {
+                stacks_client
+                    .get_account_nonce(address)
+                    .map_err(backoff::Error::transient)
+            }) else {
                 warn!(
-                    "Signer #{}: Failed to get account nonce for signer: {e:?}",
+                    "Signer #{}: Unable to get account nonce for address: {address}.",
                     self.signer_id
                 );
-            })
-            .unwrap_or(0);
-
-        let current_transactions = self.get_signer_transactions(stacks_client, current_reward_cycle).map_err(|e| {
-            warn!("Signer #{}: Failed to get old transactions: {e:?}. Defaulting to account nonce.", self.signer_id);
-        }).unwrap_or_default();
-
-        for transaction in current_transactions {
-            let origin_nonce = transaction.get_origin_nonce();
-            let origin_address = transaction.origin_address();
-            if origin_address == *signer_address && origin_nonce >= next_nonce {
-                next_nonce = origin_nonce.wrapping_add(1);
-            }
+                continue;
+            };
+            account_nonces.insert(*address, account_nonce);
         }
-        next_nonce
+        account_nonces
     }
 
     /// broadcast the dkg vote transaction according to the current epoch
     fn broadcast_dkg_vote(
         &mut self,
         stacks_client: &StacksClient,
-        new_transaction: StacksTransaction,
         epoch: StacksEpochId,
-        current_reward_cycle: u64,
+        mut signer_transactions: Vec<StacksTransaction>,
+        new_transaction: StacksTransaction,
     ) -> Result<(), ClientError> {
         let txid = new_transaction.txid();
+        if self.approved_aggregate_public_key.is_some() {
+            // We do not enforce a block contain any transactions except the aggregate votes when it is NOT already set
+            info!(
+                "Signer #{}: Already has an aggregate key for reward cycle {}. Do not broadcast the transaction ({txid:?}).",
+                self.signer_id, self.reward_cycle
+            );
+            return Ok(());
+        }
         if epoch >= StacksEpochId::Epoch30 {
             debug!("Signer #{}: Received a DKG result while in epoch 3.0. Broadcast the transaction only to stackerDB.", self.signer_id);
         } else if epoch == StacksEpochId::Epoch25 {
@@ -1082,23 +1034,8 @@ impl Signer {
             return Ok(());
         }
         // For all Pox-4 epochs onwards, broadcast the results also to stackerDB for other signers/miners to observe
-        // TODO: Should we even store transactions if not in prepare phase? Should the miner just ignore all signer transactions if not in prepare phase?
-        let txid = new_transaction.txid();
-        let new_transactions = if self.approved_aggregate_public_key.is_some() {
-            // We do not enforce a block contain any transactions except the aggregate votes when it is NOT already set
-            info!(
-                "Signer #{}: Already has an aggregate key for reward cycle {}. Do not broadcast the transaction ({txid:?}).",
-                self.signer_id, self.reward_cycle
-            );
-            vec![]
-        } else {
-            let mut new_transactions = self.get_signer_transactions(stacks_client, current_reward_cycle).map_err(|e| {
-            warn!("Signer #{}: Failed to get old transactions: {e:?}. Potentially overwriting our existing stackerDB transactions", self.signer_id);
-        }).unwrap_or_default();
-            new_transactions.push(new_transaction);
-            new_transactions
-        };
-        let signer_message = SignerMessage::Transactions(new_transactions);
+        signer_transactions.push(new_transaction);
+        let signer_message = SignerMessage::Transactions(signer_transactions);
         self.stackerdb.send_message_with_retry(signer_message)?;
         info!(
             "Signer #{}: Broadcasted DKG vote transaction ({txid}) to stacker DB",
@@ -1225,11 +1162,7 @@ impl Signer {
     }
 
     /// Update the DKG for the provided signer info, triggering it if required
-    pub fn update_dkg(
-        &mut self,
-        stacks_client: &StacksClient,
-        current_reward_cycle: u64,
-    ) -> Result<(), ClientError> {
+    pub fn update_dkg(&mut self, stacks_client: &StacksClient) -> Result<(), ClientError> {
         let reward_cycle = self.reward_cycle;
         self.approved_aggregate_public_key =
             stacks_client.get_approved_aggregate_key(reward_cycle)?;
@@ -1249,30 +1182,29 @@ impl Signer {
         let coordinator_id = self.coordinator_selector.get_coordinator().0;
         if self.signer_id == coordinator_id && self.state == State::Idle {
             debug!(
-                "Signer #{}: Checking if old transactions exist",
+                "Signer #{}: Checking if old vote transaction exists in StackerDB...",
                 self.signer_id
             );
             // Have I already voted and have a pending transaction? Check stackerdb for the same round number and reward cycle vote transaction
-            let old_transactions = self.get_signer_transactions(stacks_client, current_reward_cycle).map_err(|e| {
-                warn!("Signer #{}: Failed to get old transactions: {e:?}. Potentially overwriting our existing transactions", self.signer_id);
+            // Only get the account nonce of THIS signer as we only care about our own votes, not other signer votes
+            let signer_address = stacks_client.get_signer_address();
+            let account_nonces = self.get_account_nonces(stacks_client, &[signer_address.clone()]);
+            let old_transactions = self.get_signer_transactions(&account_nonces).map_err(|e| {
+                warn!("Signer #{}: Failed to get old signer transactions: {e:?}. May trigger DKG unnecessarily", self.signer_id);
             }).unwrap_or_default();
             // Check if we have an existing vote transaction for the same round and reward cycle
             for transaction in old_transactions.iter() {
-                let origin_address = transaction.origin_address();
-                if &origin_address != stacks_client.get_signer_address() {
-                    continue;
-                }
-                let Some((_index, point, round, _reward_cycle)) =
-                    Self::parse_vote_for_aggregate_public_key(transaction)
-                else {
-                    // The transaction is not a valid vote-for-aggregate-public-key transaction
-                    error!("BUG: Signer #{}: Received an unrecognized transaction ({}) in an already filtered list: {transaction:?}", self.signer_id, transaction.txid());
-                    continue;
-                };
+                let (_index, point, round, reward_cycle) =
+                    Self::parse_vote_for_aggregate_public_key(transaction).expect(&format!("BUG: Signer #{}: Received an invalid {VOTE_FUNCTION_NAME} transaction in an already filtered list: {transaction:?}", self.signer_id));
                 if Some(point) == self.coordinator.aggregate_public_key
                     && round == self.coordinator.current_dkg_id
+                    && reward_cycle == self.reward_cycle
                 {
-                    debug!("Signer #{}: Not triggering a DKG round. Already have a pending vote transaction for aggregate public key {point:?} for round {round}...", self.signer_id);
+                    debug!("Signer #{}: Not triggering a DKG round. Already have a pending vote transaction.", self.signer_id;
+                        "txid" => %transaction.txid(),
+                        "point" => %point,
+                        "round" => round
+                    );
                     return Ok(());
                 }
             }
@@ -1312,12 +1244,7 @@ impl Signer {
                     "Signer #{}: Received a block proposal result from the stacks node...",
                     self.signer_id
                 );
-                self.handle_block_validate_response(
-                    stacks_client,
-                    block_validate_response,
-                    res,
-                    current_reward_cycle,
-                )
+                self.handle_block_validate_response(stacks_client, block_validate_response, res)
             }
             Some(SignerEvent::SignerMessages(signer_set, messages)) => {
                 if *signer_set != self.stackerdb.get_signer_set() {
@@ -1329,7 +1256,7 @@ impl Signer {
                     self.signer_id,
                     messages.len()
                 );
-                self.handle_signer_messages(stacks_client, res, messages, current_reward_cycle);
+                self.handle_signer_messages(stacks_client, res, messages);
             }
             Some(SignerEvent::ProposedBlocks(blocks)) => {
                 if current_reward_cycle != self.reward_cycle {
@@ -1388,7 +1315,6 @@ impl Signer {
 
 #[cfg(test)]
 mod tests {
-    use std::thread::spawn;
 
     use blockstack_lib::chainstate::stacks::boot::SIGNERS_VOTING_NAME;
     use blockstack_lib::chainstate::stacks::{
@@ -1398,113 +1324,24 @@ mod tests {
     use blockstack_lib::util_lib::boot::boot_code_id;
     use blockstack_lib::util_lib::strings::StacksString;
     use clarity::vm::Value;
+    use hashbrown::HashMap;
     use rand::thread_rng;
     use rand_core::RngCore;
-    use serial_test::serial;
     use stacks_common::consts::CHAIN_ID_TESTNET;
     use stacks_common::types::chainstate::StacksPrivateKey;
     use wsts::curve::point::Point;
     use wsts::curve::scalar::Scalar;
 
-    use crate::client::tests::{
-        build_account_nonce_response, build_get_approved_aggregate_key_response,
-        build_get_last_round_response, generate_signer_config, mock_server_from_config,
-        mock_server_from_config_and_write_response, write_response,
-    };
+    use crate::client::tests::generate_signer_config;
     use crate::client::{StacksClient, VOTE_FUNCTION_NAME};
     use crate::config::GlobalConfig;
     use crate::signer::Signer;
 
     #[test]
-    fn filter_invalid_transaction_bad_origin_id() {
-        let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
-        let signer_config = generate_signer_config(&config, 2, 20);
-        let signer = Signer::from(signer_config.clone());
-        let stacks_client = StacksClient::from(&config);
-        let signer_private_key = StacksPrivateKey::new();
-        let invalid_tx = StacksTransaction {
-            version: TransactionVersion::Testnet,
-            chain_id: CHAIN_ID_TESTNET,
-            auth: TransactionAuth::from_p2pkh(&signer_private_key).unwrap(),
-            anchor_mode: TransactionAnchorMode::Any,
-            post_condition_mode: TransactionPostConditionMode::Allow,
-            post_conditions: vec![],
-            payload: TransactionPayload::SmartContract(
-                TransactionSmartContract {
-                    name: "test-contract".into(),
-                    code_body: StacksString::from_str("(/ 1 0)").unwrap(),
-                },
-                None,
-            ),
-        };
-        assert!(signer
-            .filter_invalid_transactions(&stacks_client, 0, &signer.signer_slot_ids, invalid_tx)
-            .is_none());
-    }
-
-    #[test]
-    #[serial]
-    fn filter_invalid_transaction_bad_nonce() {
-        let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
-        let signer_config = generate_signer_config(&config, 2, 20);
-        let signer = Signer::from(signer_config.clone());
-        let stacks_client = StacksClient::from(&config);
-        let signer_private_key = config.stacks_private_key;
-        let vote_contract_id = boot_code_id(SIGNERS_VOTING_NAME, signer.mainnet);
-        let contract_addr = vote_contract_id.issuer.into();
-        let contract_name = vote_contract_id.name.clone();
-        let signer_index = Value::UInt(signer.signer_id as u128);
-        let point = Point::from(Scalar::random(&mut thread_rng()));
-        let point_arg =
-            Value::buff_from(point.compress().data.to_vec()).expect("Failed to create buff");
-        let round = thread_rng().next_u64();
-        let round_arg = Value::UInt(round as u128);
-        let reward_cycle_arg = Value::UInt(signer.reward_cycle as u128);
-        let valid_function_args = vec![
-            signer_index.clone(),
-            point_arg.clone(),
-            round_arg.clone(),
-            reward_cycle_arg.clone(),
-        ];
-        let invalid_tx = StacksClient::build_signed_contract_call_transaction(
-            &contract_addr,
-            contract_name.clone(),
-            VOTE_FUNCTION_NAME.into(),
-            &valid_function_args,
-            &signer_private_key,
-            TransactionVersion::Testnet,
-            config.network.to_chain_id(),
-            0, // Old nonce
-            10,
-        )
-        .unwrap();
-
-        let h = spawn(move || {
-            signer.filter_invalid_transactions(
-                &stacks_client,
-                0,
-                &signer.signer_slot_ids,
-                invalid_tx,
-            )
-        });
-
-        let response = build_account_nonce_response(1);
-        let mock_server = mock_server_from_config(&config);
-        write_response(mock_server, response.as_bytes());
-        assert!(h.join().unwrap().is_none());
-    }
-
-    #[test]
-    #[serial]
-    fn verify_valid_transaction() {
-        // Create a runloop of a valid signer
+    fn valid_vote_transaction() {
         let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
-        let mut signer_config = generate_signer_config(&config, 5, 20);
-        signer_config.reward_cycle = 1;
-
-        // valid transaction
+        let signer_config = generate_signer_config(&config, 5, 20);
         let signer = Signer::from(signer_config.clone());
-        let stacks_client = StacksClient::from(&config);
 
         let signer_private_key = config.stacks_private_key;
         let vote_contract_id = boot_code_id(SIGNERS_VOTING_NAME, signer.mainnet);
@@ -1523,7 +1360,7 @@ mod tests {
             round_arg.clone(),
             reward_cycle_arg.clone(),
         ];
-        let valid_transaction = StacksClient::build_signed_contract_call_transaction(
+        let valid_tx = StacksClient::build_signed_contract_call_transaction(
             &contract_addr,
             contract_name.clone(),
             VOTE_FUNCTION_NAME.into(),
@@ -1535,38 +1372,15 @@ mod tests {
             10,
         )
         .unwrap();
-
-        let vote_response = build_get_approved_aggregate_key_response(None);
-        let last_round_response = build_get_last_round_response(round);
-
-        let h = spawn(move || {
-            assert!(signer
-                .verify_payload(
-                    &stacks_client,
-                    &valid_transaction,
-                    signer.signer_id,
-                    signer.reward_cycle.saturating_sub(1)
-                )
-                .unwrap())
-        });
-
-        let mock_server = mock_server_from_config(&config);
-        write_response(mock_server, vote_response.as_bytes());
-
-        let mock_server = mock_server_from_config(&config);
-        write_response(mock_server, last_round_response.as_bytes());
-
-        h.join().unwrap();
+        let mut account_nonces = HashMap::new();
+        account_nonces.insert(valid_tx.origin_address(), 1);
+        assert!(signer.valid_vote_transaction(&account_nonces, &valid_tx));
     }
 
     #[test]
-    #[serial]
-    fn verify_transaction_filters_malformed_contract_calls() {
-        // Create a runloop of a valid signer
+    fn valid_vote_transaction_malformed_transactions() {
         let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
-        let mut signer_config = generate_signer_config(&config, 5, 20);
-        signer_config.reward_cycle = 1;
-
+        let signer_config = generate_signer_config(&config, 5, 20);
         let signer = Signer::from(signer_config.clone());
 
         let signer_private_key = config.stacks_private_key;
@@ -1641,23 +1455,6 @@ mod tests {
             10,
         )
         .unwrap();
-        let invalid_signer_id_argument = StacksClient::build_signed_contract_call_transaction(
-            &contract_addr,
-            contract_name.clone(),
-            VOTE_FUNCTION_NAME.into(),
-            &[
-                Value::UInt(signer.signer_id.wrapping_add(1) as u128), // Not the signers id
-                point_arg.clone(),
-                round_arg.clone(),
-                reward_cycle_arg.clone(),
-            ],
-            &signer_private_key,
-            TransactionVersion::Testnet,
-            config.network.to_chain_id(),
-            1,
-            10,
-        )
-        .unwrap();
 
         let invalid_function_arg_signer_index =
             StacksClient::build_signed_contract_call_transaction(
@@ -1733,42 +1530,44 @@ mod tests {
             )
             .unwrap();
 
-        let stacks_client = StacksClient::from(&config);
+        let invalid_nonce = StacksClient::build_signed_contract_call_transaction(
+            &contract_addr,
+            contract_name.clone(),
+            VOTE_FUNCTION_NAME.into(),
+            &valid_function_args,
+            &signer_private_key,
+            TransactionVersion::Testnet,
+            config.network.to_chain_id(),
+            0, // Old nonce
+            10,
+        )
+        .unwrap();
+
+        let mut account_nonces = HashMap::new();
+        account_nonces.insert(invalid_not_contract_call.origin_address(), 1);
         for tx in vec![
             invalid_not_contract_call,
             invalid_signers_contract_addr,
             invalid_signers_contract_name,
             invalid_signers_vote_function,
-            invalid_signer_id_argument,
             invalid_function_arg_signer_index,
             invalid_function_arg_key,
             invalid_function_arg_round,
             invalid_function_arg_reward_cycle,
+            invalid_nonce,
         ] {
-            let result = signer
-                .verify_payload(
-                    &stacks_client,
-                    &tx,
-                    signer.signer_id,
-                    signer.reward_cycle.saturating_sub(1),
-                )
-                .unwrap();
-            assert!(!result);
+            assert!(!signer.valid_vote_transaction(&account_nonces, &tx));
         }
     }
 
     #[test]
-    #[serial]
-    fn verify_transaction_filters_invalid_reward_cycle() {
-        // Create a runloop of a valid signer
+    fn filter_one_transaction_per_signer_multiple_addresses() {
         let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
-        let mut signer_config = generate_signer_config(&config, 5, 20);
-        signer_config.reward_cycle = 1;
-
+        let signer_config = generate_signer_config(&config, 5, 20);
         let signer = Signer::from(signer_config.clone());
 
-        let stacks_client = StacksClient::from(&config);
-        let signer_private_key = config.stacks_private_key;
+        let signer_private_key_1 = config.stacks_private_key;
+        let signer_private_key_2 = StacksPrivateKey::new();
         let vote_contract_id = boot_code_id(SIGNERS_VOTING_NAME, signer.mainnet);
         let contract_addr = vote_contract_id.issuer.into();
         let contract_name = vote_contract_id.name.clone();
@@ -1785,70 +1584,50 @@ mod tests {
             round_arg.clone(),
             reward_cycle_arg.clone(),
         ];
-        // Invalid reward cycle (voting for the current is not allowed. only the next)
-        let signer = Signer::from(signer_config.clone());
-        let invalid_reward_cycle = StacksClient::build_signed_contract_call_transaction(
+
+        let valid_tx_1_address_1 = StacksClient::build_signed_contract_call_transaction(
             &contract_addr,
             contract_name.clone(),
             VOTE_FUNCTION_NAME.into(),
             &valid_function_args,
-            &signer_private_key,
+            &signer_private_key_1,
             TransactionVersion::Testnet,
             config.network.to_chain_id(),
             1,
             10,
         )
         .unwrap();
-        let h = spawn(move || {
-            assert!(!signer
-                .verify_payload(
-                    &stacks_client,
-                    &invalid_reward_cycle,
-                    signer.signer_id,
-                    signer.reward_cycle
-                )
-                .unwrap())
-        });
-        h.join().unwrap();
-    }
-
-    #[test]
-    #[serial]
-    fn verify_transaction_filters_already_voted() {
-        // Create a runloop of a valid signer
-        let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
-        let mut signer_config = generate_signer_config(&config, 5, 20);
-        signer_config.reward_cycle = 1;
-
-        let signer = Signer::from(signer_config.clone());
-
-        let signer_private_key = config.stacks_private_key;
-        let vote_contract_id = boot_code_id(SIGNERS_VOTING_NAME, signer.mainnet);
-        let contract_addr = vote_contract_id.issuer.into();
-        let contract_name = vote_contract_id.name.clone();
-        let signer_index = Value::UInt(signer.signer_id as u128);
-        let point = Point::from(Scalar::random(&mut thread_rng()));
-        let point_arg =
-            Value::buff_from(point.compress().data.to_vec()).expect("Failed to create buff");
-        let round = thread_rng().next_u64();
-        let round_arg = Value::UInt(round as u128);
-        let reward_cycle_arg = Value::UInt(signer.reward_cycle as u128);
-        let valid_function_args = vec![
-            signer_index.clone(),
-            point_arg.clone(),
-            round_arg.clone(),
-            reward_cycle_arg.clone(),
-        ];
+        let valid_tx_2_address_1 = StacksClient::build_signed_contract_call_transaction(
+            &contract_addr,
+            contract_name.clone(),
+            VOTE_FUNCTION_NAME.into(),
+            &valid_function_args,
+            &signer_private_key_1,
+            TransactionVersion::Testnet,
+            config.network.to_chain_id(),
+            2,
+            10,
+        )
+        .unwrap();
+        let valid_tx_3_address_1 = StacksClient::build_signed_contract_call_transaction(
+            &contract_addr,
+            contract_name.clone(),
+            VOTE_FUNCTION_NAME.into(),
+            &valid_function_args,
+            &signer_private_key_1,
+            TransactionVersion::Testnet,
+            config.network.to_chain_id(),
+            3,
+            10,
+        )
+        .unwrap();
 
-        // Already voted
-        let signer = Signer::from(signer_config.clone());
-        let stacks_client = StacksClient::from(&config);
-        let invalid_already_voted = StacksClient::build_signed_contract_call_transaction(
+        let valid_tx_1_address_2 = StacksClient::build_signed_contract_call_transaction(
             &contract_addr,
             contract_name.clone(),
             VOTE_FUNCTION_NAME.into(),
             &valid_function_args,
-            &signer_private_key,
+            &signer_private_key_2,
             TransactionVersion::Testnet,
             config.network.to_chain_id(),
             1,
@@ -1856,30 +1635,34 @@ mod tests {
         )
         .unwrap();
 
-        let vote_response = build_get_approved_aggregate_key_response(Some(point));
+        let valid_tx_2_address_2 = StacksClient::build_signed_contract_call_transaction(
+            &contract_addr,
+            contract_name.clone(),
+            VOTE_FUNCTION_NAME.into(),
+            &valid_function_args,
+            &signer_private_key_2,
+            TransactionVersion::Testnet,
+            config.network.to_chain_id(),
+            1,
+            10,
+        )
+        .unwrap();
 
-        let h = spawn(move || {
-            assert!(!signer
-                .verify_payload(
-                    &stacks_client,
-                    &invalid_already_voted,
-                    signer.signer_id,
-                    signer.reward_cycle.saturating_sub(1)
-                )
-                .unwrap())
-        });
-        mock_server_from_config_and_write_response(&config, vote_response.as_bytes());
-        h.join().unwrap();
+        let txs = signer.filter_one_transaction_per_address(vec![
+            valid_tx_1_address_1.clone(),
+            valid_tx_3_address_1,
+            valid_tx_2_address_2,
+            valid_tx_2_address_1.clone(),
+        ]);
+        assert_eq!(txs.len(), 2);
+        assert!(txs.contains(&valid_tx_1_address_1));
+        assert!(txs.contains(&valid_tx_1_address_2));
     }
 
     #[test]
-    #[serial]
-    fn verify_transaction_filters_ivalid_round_number() {
-        // Create a runloop of a valid signer
+    fn filter_one_transaction_per_signer_duplicate_nonces() {
         let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
-        let mut signer_config = generate_signer_config(&config, 5, 20);
-        signer_config.reward_cycle = 1;
-
+        let signer_config = generate_signer_config(&config, 5, 20);
         let signer = Signer::from(signer_config.clone());
 
         let signer_private_key = config.stacks_private_key;
@@ -1899,9 +1682,8 @@ mod tests {
             round_arg.clone(),
             reward_cycle_arg.clone(),
         ];
-        let signer = Signer::from(signer_config.clone());
-        let stacks_client = StacksClient::from(&config);
-        let invalid_round_number = StacksClient::build_signed_contract_call_transaction(
+        let nonce = 0;
+        let valid_tx_1 = StacksClient::build_signed_contract_call_transaction(
             &contract_addr,
             contract_name.clone(),
             VOTE_FUNCTION_NAME.into(),
@@ -1909,27 +1691,39 @@ mod tests {
             &signer_private_key,
             TransactionVersion::Testnet,
             config.network.to_chain_id(),
-            1,
+            nonce,
+            10,
+        )
+        .unwrap();
+        let valid_tx_2 = StacksClient::build_signed_contract_call_transaction(
+            &contract_addr,
+            contract_name.clone(),
+            VOTE_FUNCTION_NAME.into(),
+            &valid_function_args,
+            &signer_private_key,
+            TransactionVersion::Testnet,
+            config.network.to_chain_id(),
+            nonce,
+            10,
+        )
+        .unwrap();
+        let valid_tx_3 = StacksClient::build_signed_contract_call_transaction(
+            &contract_addr,
+            contract_name.clone(),
+            VOTE_FUNCTION_NAME.into(),
+            &valid_function_args,
+            &signer_private_key,
+            TransactionVersion::Testnet,
+            config.network.to_chain_id(),
+            nonce,
             10,
         )
         .unwrap();
 
-        // invalid round number
-        let vote_response = build_get_approved_aggregate_key_response(None);
-        let last_round_response = build_get_last_round_response(0);
-
-        let h = spawn(move || {
-            assert!(!signer
-                .verify_payload(
-                    &stacks_client,
-                    &invalid_round_number,
-                    signer.signer_id,
-                    signer.reward_cycle.saturating_sub(1)
-                )
-                .unwrap())
-        });
-        mock_server_from_config_and_write_response(&config, vote_response.as_bytes());
-        mock_server_from_config_and_write_response(&config, last_round_response.as_bytes());
-        h.join().unwrap();
+        let mut txs = vec![valid_tx_2, valid_tx_1, valid_tx_3];
+        let filtered_txs = signer.filter_one_transaction_per_address(txs.clone());
+        txs.sort_by(|a, b| a.txid().cmp(&b.txid()));
+        assert_eq!(filtered_txs.len(), 1);
+        assert!(filtered_txs.contains(&txs.first().expect("failed to get first tx")));
     }
 }

From f6aa7e351439bfa492866faa7678cf5c932e5f18 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Tue, 27 Feb 2024 13:12:20 -0500
Subject: [PATCH 0983/1166] Make filtering of signer transactions global and
 use in miner

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/stacks_client.rs     |  11 +-
 stacks-signer/src/signer.rs                   | 540 +------------
 .../src/chainstate/nakamoto/signer_set.rs     |  84 +-
 .../src/chainstate/nakamoto/tests/mod.rs      | 759 +++++++++++++++++-
 stackslib/src/chainstate/stacks/boot/mod.rs   |   3 +-
 stackslib/src/net/tests/mod.rs                |   8 +-
 testnet/stacks-node/src/mockamoto.rs          |   4 +-
 .../stacks-node/src/nakamoto_node/miner.rs    |  65 +-
 .../src/tests/nakamoto_integrations.rs        |   8 +-
 testnet/stacks-node/src/tests/signer.rs       | 226 +++++-
 10 files changed, 1101 insertions(+), 607 deletions(-)

diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index caa5c7018a..5e422b3c62 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -17,7 +17,9 @@ use std::net::SocketAddr;
 
 use blockstack_lib::burnchains::Txid;
 use blockstack_lib::chainstate::nakamoto::NakamotoBlock;
-use blockstack_lib::chainstate::stacks::boot::{RewardSet, SIGNERS_NAME, SIGNERS_VOTING_NAME};
+use blockstack_lib::chainstate::stacks::boot::{
+    RewardSet, SIGNERS_NAME, SIGNERS_VOTING_FUNCTION_NAME, SIGNERS_VOTING_NAME,
+};
 use blockstack_lib::chainstate::stacks::{
     StacksTransaction, StacksTransactionSigner, TransactionAnchorMode, TransactionAuth,
     TransactionContractCall, TransactionPayload, TransactionPostConditionMode,
@@ -47,9 +49,6 @@ use wsts::state_machine::PublicKeys;
 use crate::client::{retry_with_exponential_backoff, ClientError};
 use crate::config::{GlobalConfig, RegisteredSignersInfo};
 
-/// The name of the function for casting a DKG result to signer vote contract
-pub const VOTE_FUNCTION_NAME: &str = "vote-for-aggregate-public-key";
-
 /// The Stacks signer client used to communicate with the stacks node
 #[derive(Clone, Debug)]
 pub struct StacksClient {
@@ -502,10 +501,10 @@ impl StacksClient {
         tx_fee: Option<u64>,
         nonce: u64,
     ) -> Result<StacksTransaction, ClientError> {
-        debug!("Building {VOTE_FUNCTION_NAME} transaction...");
+        debug!("Building {SIGNERS_VOTING_FUNCTION_NAME} transaction...");
         let contract_address = boot_code_addr(self.mainnet);
         let contract_name = ContractName::from(SIGNERS_VOTING_NAME);
-        let function_name = ClarityName::from(VOTE_FUNCTION_NAME);
+        let function_name = ClarityName::from(SIGNERS_VOTING_FUNCTION_NAME);
         let function_args = vec![
             ClarityValue::UInt(signer_index as u128),
             ClarityValue::buff_from(point.compress().data.to_vec())?,
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index f2e5c92e38..e759f2ff70 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -17,11 +17,11 @@ use std::collections::VecDeque;
 use std::sync::mpsc::Sender;
 use std::time::Instant;
 
+use blockstack_lib::chainstate::nakamoto::signer_set::NakamotoSigners;
 use blockstack_lib::chainstate::nakamoto::{NakamotoBlock, NakamotoBlockVote};
-use blockstack_lib::chainstate::stacks::boot::SIGNERS_VOTING_NAME;
-use blockstack_lib::chainstate::stacks::{StacksTransaction, TransactionPayload};
+use blockstack_lib::chainstate::stacks::boot::SIGNERS_VOTING_FUNCTION_NAME;
+use blockstack_lib::chainstate::stacks::StacksTransaction;
 use blockstack_lib::net::api::postblock_proposal::BlockValidateResponse;
-use blockstack_lib::util_lib::boot::boot_code_id;
 use hashbrown::{HashMap, HashSet};
 use libsigner::{BlockRejection, BlockResponse, RejectCode, SignerEvent, SignerMessage};
 use slog::{slog_debug, slog_error, slog_info, slog_warn};
@@ -32,7 +32,7 @@ use stacks_common::util::hash::Sha512Trunc256Sum;
 use stacks_common::{debug, error, info, warn};
 use wsts::common::{MerkleRoot, Signature};
 use wsts::curve::keys::PublicKey;
-use wsts::curve::point::{Compressed, Point};
+use wsts::curve::point::Point;
 use wsts::net::{Message, NonceRequest, Packet, SignatureShareRequest};
 use wsts::state_machine::coordinator::fire::Coordinator as FireCoordinator;
 use wsts::state_machine::coordinator::{
@@ -42,9 +42,7 @@ use wsts::state_machine::signer::Signer as WSTSSigner;
 use wsts::state_machine::{OperationResult, SignError};
 use wsts::v2;
 
-use crate::client::{
-    retry_with_exponential_backoff, ClientError, StackerDB, StacksClient, VOTE_FUNCTION_NAME,
-};
+use crate::client::{retry_with_exponential_backoff, ClientError, StackerDB, StacksClient};
 use crate::config::SignerConfig;
 use crate::coordinator::CoordinatorSelector;
 
@@ -709,70 +707,17 @@ impl Signer {
         }
     }
 
-    /// Select one transaction per address by sorting based first on nonce and then txid
-    fn filter_one_transaction_per_address(
-        &self,
-        transactions: Vec<StacksTransaction>,
-    ) -> Vec<StacksTransaction> {
-        let mut filtered_transactions: HashMap<StacksAddress, StacksTransaction> = HashMap::new();
-        for transaction in transactions {
-            let origin_address = transaction.origin_address();
-            let origin_nonce = transaction.get_origin_nonce();
-            if let Some(entry) = filtered_transactions.get_mut(&origin_address) {
-                let entry_nonce = entry.get_origin_nonce();
-                if entry_nonce > origin_nonce
-                    || (entry_nonce == origin_nonce && entry.txid() > transaction.txid())
-                {
-                    *entry = transaction;
-                }
-            } else {
-                filtered_transactions.insert(origin_address, transaction);
-            }
-        }
-        filtered_transactions.into_values().collect()
-    }
-
-    /// Verify that the transaction is a valid vote for the aggregate public key
-    /// Note: it does not verify the function arguments, only that the transaction is validly formed
-    fn valid_vote_transaction(
-        &self,
-        account_nonces: &HashMap<StacksAddress, u64>,
-        transaction: &StacksTransaction,
-    ) -> bool {
-        let origin_address = transaction.origin_address();
-        let origin_nonce = transaction.get_origin_nonce();
-        let Some(account_nonce) = account_nonces.get(&origin_address) else {
-            debug!(
-                "Signer #{}: Unrecognized origin address ({origin_address}).",
-                self.signer_id,
-            );
-            return false;
-        };
-        if transaction.is_mainnet() != self.mainnet {
-            debug!(
-                "Signer #{}: Received a transaction for an unexpected network.",
-                self.signer_id,
-            );
-            return false;
-        }
-        if origin_nonce < *account_nonce {
-            debug!("Signer #{}: Received a transaction with an outdated nonce ({account_nonce} < {origin_nonce}).", self.signer_id);
-            return false;
-        }
-        Self::parse_vote_for_aggregate_public_key(transaction).is_some()
-    }
-
     /// Get transactions from stackerdb for the given addresses and account nonces, filtering out any malformed transactions
     fn get_signer_transactions(
         &mut self,
-        nonces: &HashMap<StacksAddress, u64>,
+        nonces: &std::collections::HashMap<StacksAddress, u64>,
     ) -> Result<Vec<StacksTransaction>, ClientError> {
         let transactions: Vec<_> = self
             .stackerdb
             .get_current_transactions_with_retry(self.signer_id)?
             .into_iter()
             .filter_map(|tx| {
-                if !self.valid_vote_transaction(nonces, &tx) {
+                if !NakamotoSigners::valid_vote_transaction(nonces, &tx, self.mainnet) {
                     return None;
                 }
                 Some(tx)
@@ -797,18 +742,16 @@ impl Signer {
         let account_nonces = self.get_account_nonces(stacks_client, &self.next_signers);
         let transactions: Vec<_> = self
             .stackerdb
-            .get_next_transactions_with_retry(&self.next_signer_ids)?
-            .into_iter()
-            .filter_map(|tx| {
-                if !self.valid_vote_transaction(&account_nonces, &tx) {
-                    return None;
-                }
-                Some(tx)
-            })
-            .collect();
-
+            .get_next_transactions_with_retry(&self.next_signer_ids)?;
+        let mut filtered_transactions = std::collections::HashMap::new();
+        NakamotoSigners::update_filtered_transactions(
+            &mut filtered_transactions,
+            &account_nonces,
+            self.mainnet,
+            transactions,
+        );
         // We only allow enforcement of one special cased transaction per signer address per block
-        Ok(self.filter_one_transaction_per_address(transactions))
+        Ok(filtered_transactions.into_values().collect())
     }
 
     /// Determine the vote for a block and update the block info and nonce request accordingly
@@ -984,8 +927,8 @@ impl Signer {
         &self,
         stacks_client: &StacksClient,
         signer_addresses: &[StacksAddress],
-    ) -> HashMap<StacksAddress, u64> {
-        let mut account_nonces = HashMap::with_capacity(signer_addresses.len());
+    ) -> std::collections::HashMap<StacksAddress, u64> {
+        let mut account_nonces = std::collections::HashMap::with_capacity(signer_addresses.len());
         for address in signer_addresses {
             let Ok(account_nonce) = retry_with_exponential_backoff(|| {
                 stacks_client
@@ -1195,7 +1138,7 @@ impl Signer {
             // Check if we have an existing vote transaction for the same round and reward cycle
             for transaction in old_transactions.iter() {
                 let (_index, point, round, reward_cycle) =
-                    Self::parse_vote_for_aggregate_public_key(transaction).expect(&format!("BUG: Signer #{}: Received an invalid {VOTE_FUNCTION_NAME} transaction in an already filtered list: {transaction:?}", self.signer_id));
+                    NakamotoSigners::parse_vote_for_aggregate_public_key(transaction).expect(&format!("BUG: Signer #{}: Received an invalid {SIGNERS_VOTING_FUNCTION_NAME} transaction in an already filtered list: {transaction:?}", self.signer_id));
                 if Some(point) == self.coordinator.aggregate_public_key
                     && round == self.coordinator.current_dkg_id
                     && reward_cycle == self.reward_cycle
@@ -1281,449 +1224,4 @@ impl Signer {
         }
         Ok(())
     }
-
-    fn parse_vote_for_aggregate_public_key(
-        transaction: &StacksTransaction,
-    ) -> Option<(u64, Point, u64, u64)> {
-        let TransactionPayload::ContractCall(payload) = &transaction.payload else {
-            // Not a contract call so not a special cased vote for aggregate public key transaction
-            return None;
-        };
-        if payload.contract_identifier()
-            != boot_code_id(SIGNERS_VOTING_NAME, transaction.is_mainnet())
-            || payload.function_name != VOTE_FUNCTION_NAME.into()
-        {
-            // This is not a special cased transaction.
-            return None;
-        }
-        if payload.function_args.len() != 4 {
-            return None;
-        }
-        let signer_index_value = payload.function_args.first()?;
-        let signer_index = u64::try_from(signer_index_value.clone().expect_u128().ok()?).ok()?;
-        let point_value = payload.function_args.get(1)?;
-        let point_bytes = point_value.clone().expect_buff(33).ok()?;
-        let compressed_data = Compressed::try_from(point_bytes.as_slice()).ok()?;
-        let point = Point::try_from(&compressed_data).ok()?;
-        let round_value = payload.function_args.get(2)?;
-        let round = u64::try_from(round_value.clone().expect_u128().ok()?).ok()?;
-        let reward_cycle =
-            u64::try_from(payload.function_args.get(3)?.clone().expect_u128().ok()?).ok()?;
-        Some((signer_index, point, round, reward_cycle))
-    }
-}
-
-#[cfg(test)]
-mod tests {
-
-    use blockstack_lib::chainstate::stacks::boot::SIGNERS_VOTING_NAME;
-    use blockstack_lib::chainstate::stacks::{
-        StacksTransaction, TransactionAnchorMode, TransactionAuth, TransactionPayload,
-        TransactionPostConditionMode, TransactionSmartContract, TransactionVersion,
-    };
-    use blockstack_lib::util_lib::boot::boot_code_id;
-    use blockstack_lib::util_lib::strings::StacksString;
-    use clarity::vm::Value;
-    use hashbrown::HashMap;
-    use rand::thread_rng;
-    use rand_core::RngCore;
-    use stacks_common::consts::CHAIN_ID_TESTNET;
-    use stacks_common::types::chainstate::StacksPrivateKey;
-    use wsts::curve::point::Point;
-    use wsts::curve::scalar::Scalar;
-
-    use crate::client::tests::generate_signer_config;
-    use crate::client::{StacksClient, VOTE_FUNCTION_NAME};
-    use crate::config::GlobalConfig;
-    use crate::signer::Signer;
-
-    #[test]
-    fn valid_vote_transaction() {
-        let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
-        let signer_config = generate_signer_config(&config, 5, 20);
-        let signer = Signer::from(signer_config.clone());
-
-        let signer_private_key = config.stacks_private_key;
-        let vote_contract_id = boot_code_id(SIGNERS_VOTING_NAME, signer.mainnet);
-        let contract_addr = vote_contract_id.issuer.into();
-        let contract_name = vote_contract_id.name.clone();
-        let signer_index = Value::UInt(signer.signer_id as u128);
-        let point = Point::from(Scalar::random(&mut thread_rng()));
-        let point_arg =
-            Value::buff_from(point.compress().data.to_vec()).expect("Failed to create buff");
-        let round = thread_rng().next_u64();
-        let round_arg = Value::UInt(round as u128);
-        let reward_cycle_arg = Value::UInt(signer.reward_cycle as u128);
-        let valid_function_args = vec![
-            signer_index.clone(),
-            point_arg.clone(),
-            round_arg.clone(),
-            reward_cycle_arg.clone(),
-        ];
-        let valid_tx = StacksClient::build_signed_contract_call_transaction(
-            &contract_addr,
-            contract_name.clone(),
-            VOTE_FUNCTION_NAME.into(),
-            &valid_function_args,
-            &signer_private_key,
-            TransactionVersion::Testnet,
-            config.network.to_chain_id(),
-            1,
-            10,
-        )
-        .unwrap();
-        let mut account_nonces = HashMap::new();
-        account_nonces.insert(valid_tx.origin_address(), 1);
-        assert!(signer.valid_vote_transaction(&account_nonces, &valid_tx));
-    }
-
-    #[test]
-    fn valid_vote_transaction_malformed_transactions() {
-        let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
-        let signer_config = generate_signer_config(&config, 5, 20);
-        let signer = Signer::from(signer_config.clone());
-
-        let signer_private_key = config.stacks_private_key;
-        let vote_contract_id = boot_code_id(SIGNERS_VOTING_NAME, signer.mainnet);
-        let contract_addr = vote_contract_id.issuer.into();
-        let contract_name = vote_contract_id.name.clone();
-        let signer_index = Value::UInt(signer.signer_id as u128);
-        let point = Point::from(Scalar::random(&mut thread_rng()));
-        let point_arg =
-            Value::buff_from(point.compress().data.to_vec()).expect("Failed to create buff");
-        let round = thread_rng().next_u64();
-        let round_arg = Value::UInt(round as u128);
-        let reward_cycle_arg = Value::UInt(signer.reward_cycle as u128);
-        let valid_function_args = vec![
-            signer_index.clone(),
-            point_arg.clone(),
-            round_arg.clone(),
-            reward_cycle_arg.clone(),
-        ];
-
-        let signer = Signer::from(signer_config.clone());
-        // Create a invalid transaction that is not a contract call
-        let invalid_not_contract_call = StacksTransaction {
-            version: TransactionVersion::Testnet,
-            chain_id: CHAIN_ID_TESTNET,
-            auth: TransactionAuth::from_p2pkh(&signer_private_key).unwrap(),
-            anchor_mode: TransactionAnchorMode::Any,
-            post_condition_mode: TransactionPostConditionMode::Allow,
-            post_conditions: vec![],
-            payload: TransactionPayload::SmartContract(
-                TransactionSmartContract {
-                    name: "test-contract".into(),
-                    code_body: StacksString::from_str("(/ 1 0)").unwrap(),
-                },
-                None,
-            ),
-        };
-        let invalid_signers_contract_addr = StacksClient::build_signed_contract_call_transaction(
-            &config.stacks_address, // Not the signers contract address
-            contract_name.clone(),
-            VOTE_FUNCTION_NAME.into(),
-            &valid_function_args,
-            &signer_private_key,
-            TransactionVersion::Testnet,
-            config.network.to_chain_id(),
-            1,
-            10,
-        )
-        .unwrap();
-        let invalid_signers_contract_name = StacksClient::build_signed_contract_call_transaction(
-            &contract_addr,
-            "bad-signers-contract-name".into(),
-            VOTE_FUNCTION_NAME.into(),
-            &valid_function_args,
-            &signer_private_key,
-            TransactionVersion::Testnet,
-            config.network.to_chain_id(),
-            1,
-            10,
-        )
-        .unwrap();
-
-        let invalid_signers_vote_function = StacksClient::build_signed_contract_call_transaction(
-            &contract_addr,
-            contract_name.clone(),
-            "some-other-function".into(),
-            &valid_function_args,
-            &signer_private_key,
-            TransactionVersion::Testnet,
-            config.network.to_chain_id(),
-            1,
-            10,
-        )
-        .unwrap();
-
-        let invalid_function_arg_signer_index =
-            StacksClient::build_signed_contract_call_transaction(
-                &contract_addr,
-                contract_name.clone(),
-                VOTE_FUNCTION_NAME.into(),
-                &[
-                    point_arg.clone(),
-                    point_arg.clone(),
-                    round_arg.clone(),
-                    reward_cycle_arg.clone(),
-                ],
-                &signer_private_key,
-                TransactionVersion::Testnet,
-                config.network.to_chain_id(),
-                1,
-                10,
-            )
-            .unwrap();
-
-        let invalid_function_arg_key = StacksClient::build_signed_contract_call_transaction(
-            &contract_addr,
-            contract_name.clone(),
-            VOTE_FUNCTION_NAME.into(),
-            &[
-                signer_index.clone(),
-                signer_index.clone(),
-                round_arg.clone(),
-                reward_cycle_arg.clone(),
-            ],
-            &signer_private_key,
-            TransactionVersion::Testnet,
-            config.network.to_chain_id(),
-            1,
-            10,
-        )
-        .unwrap();
-
-        let invalid_function_arg_round = StacksClient::build_signed_contract_call_transaction(
-            &contract_addr,
-            contract_name.clone(),
-            VOTE_FUNCTION_NAME.into(),
-            &[
-                signer_index.clone(),
-                point_arg.clone(),
-                point_arg.clone(),
-                reward_cycle_arg.clone(),
-            ],
-            &signer_private_key,
-            TransactionVersion::Testnet,
-            config.network.to_chain_id(),
-            1,
-            10,
-        )
-        .unwrap();
-
-        let invalid_function_arg_reward_cycle =
-            StacksClient::build_signed_contract_call_transaction(
-                &contract_addr,
-                contract_name.clone(),
-                VOTE_FUNCTION_NAME.into(),
-                &[
-                    signer_index.clone(),
-                    point_arg.clone(),
-                    round_arg.clone(),
-                    point_arg.clone(),
-                ],
-                &signer_private_key,
-                TransactionVersion::Testnet,
-                config.network.to_chain_id(),
-                1,
-                10,
-            )
-            .unwrap();
-
-        let invalid_nonce = StacksClient::build_signed_contract_call_transaction(
-            &contract_addr,
-            contract_name.clone(),
-            VOTE_FUNCTION_NAME.into(),
-            &valid_function_args,
-            &signer_private_key,
-            TransactionVersion::Testnet,
-            config.network.to_chain_id(),
-            0, // Old nonce
-            10,
-        )
-        .unwrap();
-
-        let mut account_nonces = HashMap::new();
-        account_nonces.insert(invalid_not_contract_call.origin_address(), 1);
-        for tx in vec![
-            invalid_not_contract_call,
-            invalid_signers_contract_addr,
-            invalid_signers_contract_name,
-            invalid_signers_vote_function,
-            invalid_function_arg_signer_index,
-            invalid_function_arg_key,
-            invalid_function_arg_round,
-            invalid_function_arg_reward_cycle,
-            invalid_nonce,
-        ] {
-            assert!(!signer.valid_vote_transaction(&account_nonces, &tx));
-        }
-    }
-
-    #[test]
-    fn filter_one_transaction_per_signer_multiple_addresses() {
-        let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
-        let signer_config = generate_signer_config(&config, 5, 20);
-        let signer = Signer::from(signer_config.clone());
-
-        let signer_private_key_1 = config.stacks_private_key;
-        let signer_private_key_2 = StacksPrivateKey::new();
-        let vote_contract_id = boot_code_id(SIGNERS_VOTING_NAME, signer.mainnet);
-        let contract_addr = vote_contract_id.issuer.into();
-        let contract_name = vote_contract_id.name.clone();
-        let signer_index = Value::UInt(signer.signer_id as u128);
-        let point = Point::from(Scalar::random(&mut thread_rng()));
-        let point_arg =
-            Value::buff_from(point.compress().data.to_vec()).expect("Failed to create buff");
-        let round = thread_rng().next_u64();
-        let round_arg = Value::UInt(round as u128);
-        let reward_cycle_arg = Value::UInt(signer.reward_cycle as u128);
-        let valid_function_args = vec![
-            signer_index.clone(),
-            point_arg.clone(),
-            round_arg.clone(),
-            reward_cycle_arg.clone(),
-        ];
-
-        let valid_tx_1_address_1 = StacksClient::build_signed_contract_call_transaction(
-            &contract_addr,
-            contract_name.clone(),
-            VOTE_FUNCTION_NAME.into(),
-            &valid_function_args,
-            &signer_private_key_1,
-            TransactionVersion::Testnet,
-            config.network.to_chain_id(),
-            1,
-            10,
-        )
-        .unwrap();
-        let valid_tx_2_address_1 = StacksClient::build_signed_contract_call_transaction(
-            &contract_addr,
-            contract_name.clone(),
-            VOTE_FUNCTION_NAME.into(),
-            &valid_function_args,
-            &signer_private_key_1,
-            TransactionVersion::Testnet,
-            config.network.to_chain_id(),
-            2,
-            10,
-        )
-        .unwrap();
-        let valid_tx_3_address_1 = StacksClient::build_signed_contract_call_transaction(
-            &contract_addr,
-            contract_name.clone(),
-            VOTE_FUNCTION_NAME.into(),
-            &valid_function_args,
-            &signer_private_key_1,
-            TransactionVersion::Testnet,
-            config.network.to_chain_id(),
-            3,
-            10,
-        )
-        .unwrap();
-
-        let valid_tx_1_address_2 = StacksClient::build_signed_contract_call_transaction(
-            &contract_addr,
-            contract_name.clone(),
-            VOTE_FUNCTION_NAME.into(),
-            &valid_function_args,
-            &signer_private_key_2,
-            TransactionVersion::Testnet,
-            config.network.to_chain_id(),
-            1,
-            10,
-        )
-        .unwrap();
-
-        let valid_tx_2_address_2 = StacksClient::build_signed_contract_call_transaction(
-            &contract_addr,
-            contract_name.clone(),
-            VOTE_FUNCTION_NAME.into(),
-            &valid_function_args,
-            &signer_private_key_2,
-            TransactionVersion::Testnet,
-            config.network.to_chain_id(),
-            1,
-            10,
-        )
-        .unwrap();
-
-        let txs = signer.filter_one_transaction_per_address(vec![
-            valid_tx_1_address_1.clone(),
-            valid_tx_3_address_1,
-            valid_tx_2_address_2,
-            valid_tx_2_address_1.clone(),
-        ]);
-        assert_eq!(txs.len(), 2);
-        assert!(txs.contains(&valid_tx_1_address_1));
-        assert!(txs.contains(&valid_tx_1_address_2));
-    }
-
-    #[test]
-    fn filter_one_transaction_per_signer_duplicate_nonces() {
-        let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
-        let signer_config = generate_signer_config(&config, 5, 20);
-        let signer = Signer::from(signer_config.clone());
-
-        let signer_private_key = config.stacks_private_key;
-        let vote_contract_id = boot_code_id(SIGNERS_VOTING_NAME, signer.mainnet);
-        let contract_addr = vote_contract_id.issuer.into();
-        let contract_name = vote_contract_id.name.clone();
-        let signer_index = Value::UInt(signer.signer_id as u128);
-        let point = Point::from(Scalar::random(&mut thread_rng()));
-        let point_arg =
-            Value::buff_from(point.compress().data.to_vec()).expect("Failed to create buff");
-        let round = thread_rng().next_u64();
-        let round_arg = Value::UInt(round as u128);
-        let reward_cycle_arg = Value::UInt(signer.reward_cycle as u128);
-        let valid_function_args = vec![
-            signer_index.clone(),
-            point_arg.clone(),
-            round_arg.clone(),
-            reward_cycle_arg.clone(),
-        ];
-        let nonce = 0;
-        let valid_tx_1 = StacksClient::build_signed_contract_call_transaction(
-            &contract_addr,
-            contract_name.clone(),
-            VOTE_FUNCTION_NAME.into(),
-            &valid_function_args,
-            &signer_private_key,
-            TransactionVersion::Testnet,
-            config.network.to_chain_id(),
-            nonce,
-            10,
-        )
-        .unwrap();
-        let valid_tx_2 = StacksClient::build_signed_contract_call_transaction(
-            &contract_addr,
-            contract_name.clone(),
-            VOTE_FUNCTION_NAME.into(),
-            &valid_function_args,
-            &signer_private_key,
-            TransactionVersion::Testnet,
-            config.network.to_chain_id(),
-            nonce,
-            10,
-        )
-        .unwrap();
-        let valid_tx_3 = StacksClient::build_signed_contract_call_transaction(
-            &contract_addr,
-            contract_name.clone(),
-            VOTE_FUNCTION_NAME.into(),
-            &valid_function_args,
-            &signer_private_key,
-            TransactionVersion::Testnet,
-            config.network.to_chain_id(),
-            nonce,
-            10,
-        )
-        .unwrap();
-
-        let mut txs = vec![valid_tx_2, valid_tx_1, valid_tx_3];
-        let filtered_txs = signer.filter_one_transaction_per_address(txs.clone());
-        txs.sort_by(|a, b| a.txid().cmp(&b.txid()));
-        assert_eq!(filtered_txs.len(), 1);
-        assert!(filtered_txs.contains(&txs.first().expect("failed to get first tx")));
-    }
 }
diff --git a/stackslib/src/chainstate/nakamoto/signer_set.rs b/stackslib/src/chainstate/nakamoto/signer_set.rs
index c0d6b23717..a39d6bebc2 100644
--- a/stackslib/src/chainstate/nakamoto/signer_set.rs
+++ b/stackslib/src/chainstate/nakamoto/signer_set.rs
@@ -46,7 +46,7 @@ use stacks_common::util::hash::{to_hex, Hash160, MerkleHashFunc, MerkleTree, Sha
 use stacks_common::util::retry::BoundReader;
 use stacks_common::util::secp256k1::MessageSignature;
 use stacks_common::util::vrf::{VRFProof, VRFPublicKey, VRF};
-use wsts::curve::point::Point;
+use wsts::curve::point::{Compressed, Point};
 
 use crate::burnchains::{Burnchain, PoxConstants, Txid};
 use crate::chainstate::burn::db::sortdb::{
@@ -63,7 +63,7 @@ use crate::chainstate::stacks::address::PoxAddress;
 use crate::chainstate::stacks::boot::{
     PoxVersions, RawRewardSetEntry, RewardSet, BOOT_TEST_POX_4_AGG_KEY_CONTRACT,
     BOOT_TEST_POX_4_AGG_KEY_FNAME, POX_4_NAME, SIGNERS_MAX_LIST_SIZE, SIGNERS_NAME, SIGNERS_PK_LEN,
-    SIGNERS_UPDATE_STATE,
+    SIGNERS_UPDATE_STATE, SIGNERS_VOTING_FUNCTION_NAME, SIGNERS_VOTING_NAME,
 };
 use crate::chainstate::stacks::db::{
     ChainstateTx, ClarityTx, DBConfig as ChainstateConfig, MinerPaymentSchedule,
@@ -487,4 +487,84 @@ impl NakamotoSigners {
         }
         Ok(signers)
     }
+
+    /// Verify that the transaction is a valid vote for the aggregate public key
+    /// Note: it does not verify the function arguments, only that the transaction is validly formed
+    /// and has a valid nonce from an expected address
+    pub fn valid_vote_transaction(
+        account_nonces: &HashMap<StacksAddress, u64>,
+        transaction: &StacksTransaction,
+        is_mainnet: bool,
+    ) -> bool {
+        let origin_address = transaction.origin_address();
+        let origin_nonce = transaction.get_origin_nonce();
+        let Some(account_nonce) = account_nonces.get(&origin_address) else {
+            debug!("valid_vote_transaction: Unrecognized origin address ({origin_address}).",);
+            return false;
+        };
+        if transaction.is_mainnet() != is_mainnet {
+            debug!("valid_vote_transaction: Received a transaction for an unexpected network.",);
+            return false;
+        }
+        if origin_nonce < *account_nonce {
+            debug!("valid_vote_transaction: Received a transaction with an outdated nonce ({account_nonce} < {origin_nonce}).");
+            return false;
+        }
+        Self::parse_vote_for_aggregate_public_key(transaction).is_some()
+    }
+
+    pub fn parse_vote_for_aggregate_public_key(
+        transaction: &StacksTransaction,
+    ) -> Option<(u64, Point, u64, u64)> {
+        let TransactionPayload::ContractCall(payload) = &transaction.payload else {
+            // Not a contract call so not a special cased vote for aggregate public key transaction
+            return None;
+        };
+        if payload.contract_identifier()
+            != boot_code_id(SIGNERS_VOTING_NAME, transaction.is_mainnet())
+            || payload.function_name != SIGNERS_VOTING_FUNCTION_NAME.into()
+        {
+            // This is not a special cased transaction.
+            return None;
+        }
+        if payload.function_args.len() != 4 {
+            return None;
+        }
+        let signer_index_value = payload.function_args.first()?;
+        let signer_index = u64::try_from(signer_index_value.clone().expect_u128().ok()?).ok()?;
+        let point_value = payload.function_args.get(1)?;
+        let point_bytes = point_value.clone().expect_buff(33).ok()?;
+        let compressed_data = Compressed::try_from(point_bytes.as_slice()).ok()?;
+        let point = Point::try_from(&compressed_data).ok()?;
+        let round_value = payload.function_args.get(2)?;
+        let round = u64::try_from(round_value.clone().expect_u128().ok()?).ok()?;
+        let reward_cycle =
+            u64::try_from(payload.function_args.get(3)?.clone().expect_u128().ok()?).ok()?;
+        Some((signer_index, point, round, reward_cycle))
+    }
+
+    /// Update the map of filtered valid transactions, selecting one per address based first on lowest nonce, then txid
+    pub fn update_filtered_transactions(
+        filtered_transactions: &mut HashMap<StacksAddress, StacksTransaction>,
+        account_nonces: &HashMap<StacksAddress, u64>,
+        mainnet: bool,
+        transactions: Vec<StacksTransaction>,
+    ) {
+        for transaction in transactions {
+            if NakamotoSigners::valid_vote_transaction(&account_nonces, &transaction, mainnet) {
+                let origin_address = transaction.origin_address();
+                let origin_nonce = transaction.get_origin_nonce();
+                if let Some(entry) = filtered_transactions.get_mut(&origin_address) {
+                    let entry_nonce = entry.get_origin_nonce();
+                    if entry_nonce > origin_nonce
+                        || (entry_nonce == origin_nonce && entry.txid() > transaction.txid())
+                    {
+                        *entry = transaction;
+                    }
+                } else {
+                    filtered_transactions.insert(origin_address, transaction);
+                }
+            }
+        }
+    }
 }
diff --git a/stackslib/src/chainstate/nakamoto/tests/mod.rs b/stackslib/src/chainstate/nakamoto/tests/mod.rs
index 284a0af64d..c27505b516 100644
--- a/stackslib/src/chainstate/nakamoto/tests/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/mod.rs
@@ -15,17 +15,22 @@
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::borrow::BorrowMut;
+use std::collections::HashMap;
 use std::fs;
 
 use clarity::types::chainstate::{PoxId, SortitionId, StacksBlockId};
 use clarity::vm::clarity::ClarityConnection;
 use clarity::vm::costs::ExecutionCost;
 use clarity::vm::types::StacksAddressExtensions;
+use clarity::vm::Value;
+use rand::{thread_rng, RngCore};
 use rusqlite::Connection;
 use stacks_common::address::AddressHashMode;
 use stacks_common::bitvec::BitVec;
 use stacks_common::codec::StacksMessageCodec;
-use stacks_common::consts::{FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH};
+use stacks_common::consts::{
+    CHAIN_ID_MAINNET, CHAIN_ID_TESTNET, FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH,
+};
 use stacks_common::types::chainstate::{
     BlockHeaderHash, BurnchainHeaderHash, ConsensusHash, StacksAddress, StacksPrivateKey,
     StacksPublicKey, StacksWorkScore, TrieHash, VRFSeed,
@@ -37,6 +42,8 @@ use stacks_common::util::secp256k1::{MessageSignature, Secp256k1PublicKey};
 use stacks_common::util::vrf::{VRFPrivateKey, VRFProof, VRFPublicKey, VRF};
 use stdext::prelude::Integer;
 use stx_genesis::GenesisData;
+use wsts::curve::point::Point;
+use wsts::curve::scalar::Scalar;
 
 use crate::burnchains::{BurnchainSigner, PoxConstants, Txid};
 use crate::chainstate::burn::db::sortdb::tests::make_fork_run;
@@ -52,13 +59,16 @@ use crate::chainstate::coordinator::tests::{
 };
 use crate::chainstate::nakamoto::coordinator::tests::boot_nakamoto;
 use crate::chainstate::nakamoto::miner::NakamotoBlockBuilder;
+use crate::chainstate::nakamoto::signer_set::NakamotoSigners;
 use crate::chainstate::nakamoto::tenure::NakamotoTenure;
 use crate::chainstate::nakamoto::test_signers::TestSigners;
 use crate::chainstate::nakamoto::tests::node::TestStacker;
 use crate::chainstate::nakamoto::{
     NakamotoBlock, NakamotoBlockHeader, NakamotoChainState, SortitionHandle, FIRST_STACKS_BLOCK_ID,
 };
-use crate::chainstate::stacks::boot::MINERS_NAME;
+use crate::chainstate::stacks::boot::{
+    MINERS_NAME, SIGNERS_VOTING_FUNCTION_NAME, SIGNERS_VOTING_NAME,
+};
 use crate::chainstate::stacks::db::{
     ChainStateBootData, ChainstateAccountBalance, ChainstateAccountLockup, ChainstateBNSName,
     ChainstateBNSNamespace, StacksAccount, StacksBlockHeaderTypes, StacksChainState,
@@ -67,13 +77,15 @@ use crate::chainstate::stacks::db::{
 use crate::chainstate::stacks::{
     CoinbasePayload, StacksBlock, StacksBlockHeader, StacksTransaction, StacksTransactionSigner,
     TenureChangeCause, TenureChangePayload, ThresholdSignature, TokenTransferMemo,
-    TransactionAnchorMode, TransactionAuth, TransactionPayload, TransactionVersion,
+    TransactionAnchorMode, TransactionAuth, TransactionContractCall, TransactionPayload,
+    TransactionPostConditionMode, TransactionSmartContract, TransactionVersion,
 };
 use crate::core;
 use crate::core::{StacksEpochExtension, STACKS_EPOCH_3_0_MARKER};
 use crate::net::codec::test::check_codec_and_corruption;
 use crate::util_lib::boot::boot_code_id;
 use crate::util_lib::db::Error as db_error;
+use crate::util_lib::strings::StacksString;
 
 /// Get an address's account
 pub fn get_account(
@@ -2068,3 +2080,744 @@ fn test_make_miners_stackerdb_config() {
     assert_eq!(miner_hashbytes[8].1, miner_hash160s[8]);
     assert_eq!(miner_hashbytes[9].1, miner_hash160s[8]);
 }
+
+#[test]
+fn parse_vote_for_aggregate_public_key_valid() {
+    let signer_private_key = StacksPrivateKey::new();
+    let mainnet = false;
+    let chainid = CHAIN_ID_TESTNET;
+    let vote_contract_id = boot_code_id(SIGNERS_VOTING_NAME, mainnet);
+    let contract_addr = vote_contract_id.issuer.into();
+    let contract_name = vote_contract_id.name.clone();
+
+    let signer_index = thread_rng().next_u64();
+    let signer_index_arg = Value::UInt(signer_index as u128);
+
+    let point = Point::from(Scalar::random(&mut thread_rng()));
+    let point_arg =
+        Value::buff_from(point.compress().data.to_vec()).expect("Failed to create buff");
+    let round = thread_rng().next_u64();
+    let round_arg = Value::UInt(round as u128);
+
+    let reward_cycle = thread_rng().next_u64();
+    let reward_cycle_arg = Value::UInt(reward_cycle as u128);
+
+    let valid_function_args = vec![
+        signer_index_arg.clone(),
+        point_arg.clone(),
+        round_arg.clone(),
+        reward_cycle_arg.clone(),
+    ];
+    let valid_tx = StacksTransaction {
+        version: TransactionVersion::Testnet,
+        chain_id: CHAIN_ID_TESTNET,
+        auth: TransactionAuth::from_p2pkh(&signer_private_key).unwrap(),
+        anchor_mode: TransactionAnchorMode::Any,
+        post_condition_mode: TransactionPostConditionMode::Allow,
+        post_conditions: vec![],
+        payload: TransactionPayload::ContractCall(TransactionContractCall {
+            address: contract_addr,
+            contract_name,
+            function_name: SIGNERS_VOTING_FUNCTION_NAME.into(),
+            function_args: valid_function_args,
+        }),
+    };
+    let (res_signer_index, res_point, res_round, res_reward_cycle) =
+        NakamotoSigners::parse_vote_for_aggregate_public_key(&valid_tx).unwrap();
+    assert_eq!(res_signer_index, signer_index);
+    assert_eq!(res_point, point);
+    assert_eq!(res_round, round);
+    assert_eq!(res_reward_cycle, reward_cycle);
+}
+
+#[test]
+fn parse_vote_for_aggregate_public_key_invalid() {
+    let signer_private_key = StacksPrivateKey::new();
+    let mainnet = false;
+    let chainid = CHAIN_ID_TESTNET;
+    let vote_contract_id = boot_code_id(SIGNERS_VOTING_NAME, mainnet);
+    let contract_addr: StacksAddress = vote_contract_id.issuer.into();
+    let contract_name = vote_contract_id.name.clone();
+
+    let signer_index = thread_rng().next_u32();
+    let signer_index_arg = Value::UInt(signer_index as u128);
+
+    let point = Point::from(Scalar::random(&mut thread_rng()));
+    let point_arg =
+        Value::buff_from(point.compress().data.to_vec()).expect("Failed to create buff");
+    let round = thread_rng().next_u64();
+    let round_arg = Value::UInt(round as u128);
+
+    let reward_cycle = thread_rng().next_u64();
+    let reward_cycle_arg = Value::UInt(reward_cycle as u128);
+
+    let valid_function_args = vec![
+        signer_index_arg.clone(),
+        point_arg.clone(),
+        round_arg.clone(),
+        reward_cycle_arg.clone(),
+    ];
+
+    let mut invalid_contract_address = StacksTransaction {
+        version: TransactionVersion::Testnet,
+        chain_id: CHAIN_ID_TESTNET,
+        auth: TransactionAuth::from_p2pkh(&signer_private_key).unwrap(),
+        anchor_mode: TransactionAnchorMode::Any,
+        post_condition_mode: TransactionPostConditionMode::Allow,
+        post_conditions: vec![],
+        payload: TransactionPayload::ContractCall(TransactionContractCall {
+            address: StacksAddress::p2pkh(
+                false,
+                &StacksPublicKey::from_private(&signer_private_key),
+            ),
+            contract_name: contract_name.clone(),
+            function_name: SIGNERS_VOTING_FUNCTION_NAME.into(),
+            function_args: valid_function_args.clone(),
+        }),
+    };
+    invalid_contract_address.set_origin_nonce(1);
+
+    let mut invalid_contract_name = StacksTransaction {
+        version: TransactionVersion::Testnet,
+        chain_id: CHAIN_ID_TESTNET,
+        auth: TransactionAuth::from_p2pkh(&signer_private_key).unwrap(),
+        anchor_mode: TransactionAnchorMode::Any,
+        post_condition_mode: TransactionPostConditionMode::Allow,
+        post_conditions: vec![],
+        payload: TransactionPayload::ContractCall(TransactionContractCall {
+            address: contract_addr.clone(),
+            contract_name: "bad-signers-contract-name".into(),
+            function_name: SIGNERS_VOTING_FUNCTION_NAME.into(),
+            function_args: valid_function_args.clone(),
+        }),
+    };
+    invalid_contract_name.set_origin_nonce(1);
+
+    let mut invalid_signers_vote_function = StacksTransaction {
+        version: TransactionVersion::Testnet,
+        chain_id: CHAIN_ID_TESTNET,
+        auth: TransactionAuth::from_p2pkh(&signer_private_key).unwrap(),
+        anchor_mode: TransactionAnchorMode::Any,
+        post_condition_mode: TransactionPostConditionMode::Allow,
+        post_conditions: vec![],
+        payload: TransactionPayload::ContractCall(TransactionContractCall {
+            address: contract_addr.clone(),
+            contract_name: contract_name.clone(),
+            function_name: "some-other-function".into(),
+            function_args: valid_function_args.clone(),
+        }),
+    };
+    invalid_signers_vote_function.set_origin_nonce(1);
+
+    let mut invalid_function_arg_signer_index = StacksTransaction {
+        version: TransactionVersion::Testnet,
+        chain_id: CHAIN_ID_TESTNET,
+        auth: TransactionAuth::from_p2pkh(&signer_private_key).unwrap(),
+        anchor_mode: TransactionAnchorMode::Any,
+        post_condition_mode: TransactionPostConditionMode::Allow,
+        post_conditions: vec![],
+        payload: TransactionPayload::ContractCall(TransactionContractCall {
+            address: contract_addr.clone(),
+            contract_name: contract_name.clone(),
+            function_name: SIGNERS_VOTING_FUNCTION_NAME.into(),
+            function_args: vec![
+                point_arg.clone(),
+                point_arg.clone(),
+                round_arg.clone(),
+                reward_cycle_arg.clone(),
+            ],
+        }),
+    };
+    invalid_function_arg_signer_index.set_origin_nonce(1);
+
+    let mut invalid_function_arg_key = StacksTransaction {
+        version: TransactionVersion::Testnet,
+        chain_id: CHAIN_ID_TESTNET,
+        auth: TransactionAuth::from_p2pkh(&signer_private_key).unwrap(),
+        anchor_mode: TransactionAnchorMode::Any,
+        post_condition_mode: TransactionPostConditionMode::Allow,
+        post_conditions: vec![],
+        payload: TransactionPayload::ContractCall(TransactionContractCall {
+            address: contract_addr.clone(),
+            contract_name: contract_name.clone(),
+            function_name: SIGNERS_VOTING_FUNCTION_NAME.into(),
+            function_args: vec![
+                signer_index_arg.clone(),
+                signer_index_arg.clone(),
+                round_arg.clone(),
+                reward_cycle_arg.clone(),
+            ],
+        }),
+    };
+    invalid_function_arg_key.set_origin_nonce(1);
+
+    let mut invalid_function_arg_round = StacksTransaction {
+        version: TransactionVersion::Testnet,
+        chain_id: CHAIN_ID_TESTNET,
+        auth: TransactionAuth::from_p2pkh(&signer_private_key).unwrap(),
+        anchor_mode: TransactionAnchorMode::Any,
+        post_condition_mode: TransactionPostConditionMode::Allow,
+        post_conditions: vec![],
+        payload: TransactionPayload::ContractCall(TransactionContractCall {
+            address: contract_addr.clone(),
+            contract_name: contract_name.clone(),
+            function_name: SIGNERS_VOTING_FUNCTION_NAME.into(),
+            function_args: vec![
+                signer_index_arg.clone(),
+                point_arg.clone(),
+                point_arg.clone(),
+                reward_cycle_arg.clone(),
+            ],
+        }),
+    };
+    invalid_function_arg_round.set_origin_nonce(1);
+
+    let mut invalid_function_arg_reward_cycle = StacksTransaction {
+        version: TransactionVersion::Testnet,
+        chain_id: CHAIN_ID_TESTNET,
+        auth: TransactionAuth::from_p2pkh(&signer_private_key).unwrap(),
+        anchor_mode: TransactionAnchorMode::Any,
+        post_condition_mode: TransactionPostConditionMode::Allow,
+        post_conditions: vec![],
+        payload: TransactionPayload::ContractCall(TransactionContractCall {
+            address: contract_addr.clone(),
+            contract_name: contract_name.clone(),
+            function_name: SIGNERS_VOTING_FUNCTION_NAME.into(),
+            function_args: vec![
+                signer_index_arg.clone(),
+                point_arg.clone(),
+                round_arg.clone(),
+                point_arg.clone(),
+            ],
+        }),
+    };
+    invalid_function_arg_reward_cycle.set_origin_nonce(1);
+
+    let mut account_nonces = std::collections::HashMap::new();
+    account_nonces.insert(invalid_contract_name.origin_address(), 1);
+    for (i, tx) in vec![
+        invalid_contract_address,
+        invalid_contract_name,
+        invalid_signers_vote_function,
+        invalid_function_arg_signer_index,
+        invalid_function_arg_key,
+        invalid_function_arg_round,
+        invalid_function_arg_reward_cycle,
+    ]
+    .iter()
+    .enumerate()
+    {
+        assert!(
+            NakamotoSigners::parse_vote_for_aggregate_public_key(&tx).is_none(),
+            "{}",
+            format!("parsed the {i}th transaction: {tx:?}")
+        );
+    }
+}
+
+#[test]
+fn valid_vote_transaction() {
+    let signer_private_key = StacksPrivateKey::new();
+    let mainnet = false;
+    let chainid = CHAIN_ID_TESTNET;
+    let vote_contract_id = boot_code_id(SIGNERS_VOTING_NAME, mainnet);
+    let contract_addr = vote_contract_id.issuer.into();
+    let contract_name = vote_contract_id.name.clone();
+
+    let signer_index = thread_rng().next_u32();
+    let signer_index_arg = Value::UInt(signer_index as u128);
+
+    let point = Point::from(Scalar::random(&mut thread_rng()));
+    let point_arg =
+        Value::buff_from(point.compress().data.to_vec()).expect("Failed to create buff");
+    let round = thread_rng().next_u64();
+    let round_arg = Value::UInt(round as u128);
+
+    let reward_cycle = thread_rng().next_u64();
+    let reward_cycle_arg = Value::UInt(reward_cycle as u128);
+
+    let valid_function_args = vec![
+        signer_index_arg.clone(),
+        point_arg.clone(),
+        round_arg.clone(),
+        reward_cycle_arg.clone(),
+    ];
+    let mut valid_tx = StacksTransaction {
+        version: TransactionVersion::Testnet,
+        chain_id: CHAIN_ID_TESTNET,
+        auth: TransactionAuth::from_p2pkh(&signer_private_key).unwrap(),
+        anchor_mode: TransactionAnchorMode::Any,
+        post_condition_mode: TransactionPostConditionMode::Allow,
+        post_conditions: vec![],
+        payload: TransactionPayload::ContractCall(TransactionContractCall {
+            address: contract_addr,
+            contract_name: contract_name,
+            function_name: SIGNERS_VOTING_FUNCTION_NAME.into(),
+            function_args: valid_function_args,
+        }),
+    };
+    valid_tx.set_origin_nonce(1);
+    let mut account_nonces = std::collections::HashMap::new();
+    account_nonces.insert(valid_tx.origin_address(), 1);
+    assert!(NakamotoSigners::valid_vote_transaction(
+        &account_nonces,
+        &valid_tx,
+        mainnet
+    ));
+}
+
+#[test]
+fn valid_vote_transaction_malformed_transactions() {
+    let signer_private_key = StacksPrivateKey::new();
+    let mainnet = false;
+    let chainid = CHAIN_ID_TESTNET;
+    let vote_contract_id = boot_code_id(SIGNERS_VOTING_NAME, mainnet);
+    let contract_addr: StacksAddress = vote_contract_id.issuer.into();
+    let contract_name = vote_contract_id.name.clone();
+
+    let signer_index = thread_rng().next_u32();
+    let signer_index_arg = Value::UInt(signer_index as u128);
+
+    let point = Point::from(Scalar::random(&mut thread_rng()));
+    let point_arg =
+        Value::buff_from(point.compress().data.to_vec()).expect("Failed to create buff");
+    let round = thread_rng().next_u64();
+    let round_arg = Value::UInt(round as u128);
+
+    let reward_cycle = thread_rng().next_u64();
+    let reward_cycle_arg = Value::UInt(reward_cycle as u128);
+
+    let valid_function_args = vec![
+        signer_index_arg.clone(),
+        point_arg.clone(),
+        round_arg.clone(),
+        reward_cycle_arg.clone(),
+    ];
+    // Create a invalid transaction that is not a contract call
+    let mut invalid_not_contract_call = StacksTransaction {
+        version: TransactionVersion::Testnet,
+        chain_id: CHAIN_ID_TESTNET,
+        auth: TransactionAuth::from_p2pkh(&signer_private_key).unwrap(),
+        anchor_mode: TransactionAnchorMode::Any,
+        post_condition_mode: TransactionPostConditionMode::Allow,
+        post_conditions: vec![],
+        payload: TransactionPayload::SmartContract(
+            TransactionSmartContract {
+                name: "test-contract".into(),
+                code_body: StacksString::from_str("(/ 1 0)").unwrap(),
+            },
+            None,
+        ),
+    };
+    invalid_not_contract_call.set_origin_nonce(1);
+
+    let mut invalid_contract_address = StacksTransaction {
+        version: TransactionVersion::Testnet,
+        chain_id: CHAIN_ID_TESTNET,
+        auth: TransactionAuth::from_p2pkh(&signer_private_key).unwrap(),
+        anchor_mode: TransactionAnchorMode::Any,
+        post_condition_mode: TransactionPostConditionMode::Allow,
+        post_conditions: vec![],
+        payload: TransactionPayload::ContractCall(TransactionContractCall {
+            address: StacksAddress::p2pkh(
+                mainnet,
+                &StacksPublicKey::from_private(&signer_private_key),
+            ),
+            contract_name: contract_name.clone(),
+            function_name: SIGNERS_VOTING_FUNCTION_NAME.into(),
+            function_args: valid_function_args.clone(),
+        }),
+    };
+    invalid_contract_address.set_origin_nonce(1);
+
+    let mut invalid_contract_name = StacksTransaction {
+        version: TransactionVersion::Testnet,
+        chain_id: CHAIN_ID_TESTNET,
+        auth: TransactionAuth::from_p2pkh(&signer_private_key).unwrap(),
+        anchor_mode: TransactionAnchorMode::Any,
+        post_condition_mode: TransactionPostConditionMode::Allow,
+        post_conditions: vec![],
+        payload: TransactionPayload::ContractCall(TransactionContractCall {
+            address: contract_addr.clone(),
+            contract_name: "bad-signers-contract-name".into(),
+            function_name: SIGNERS_VOTING_FUNCTION_NAME.into(),
+            function_args: valid_function_args.clone(),
+        }),
+    };
+    invalid_contract_name.set_origin_nonce(1);
+
+    let mut invalid_network = StacksTransaction {
+        version: TransactionVersion::Mainnet,
+        chain_id: CHAIN_ID_MAINNET,
+        auth: TransactionAuth::from_p2pkh(&signer_private_key).unwrap(),
+        anchor_mode: TransactionAnchorMode::Any,
+        post_condition_mode: TransactionPostConditionMode::Allow,
+        post_conditions: vec![],
+        payload: TransactionPayload::ContractCall(TransactionContractCall {
+            address: contract_addr.clone(),
+            contract_name: contract_name.clone(),
+            function_name: SIGNERS_VOTING_FUNCTION_NAME.into(),
+            function_args: valid_function_args.clone(),
+        }),
+    };
+    invalid_network.set_origin_nonce(1);
+
+    let mut invalid_signers_vote_function = StacksTransaction {
+        version: TransactionVersion::Testnet,
+        chain_id: CHAIN_ID_TESTNET,
+        auth: TransactionAuth::from_p2pkh(&signer_private_key).unwrap(),
+        anchor_mode: TransactionAnchorMode::Any,
+        post_condition_mode: TransactionPostConditionMode::Allow,
+        post_conditions: vec![],
+        payload: TransactionPayload::ContractCall(TransactionContractCall {
+            address: contract_addr.clone(),
+            contract_name: contract_name.clone(),
+            function_name: "some-other-function".into(),
+            function_args: valid_function_args.clone(),
+        }),
+    };
+    invalid_signers_vote_function.set_origin_nonce(1);
+
+    let mut invalid_function_arg_signer_index = StacksTransaction {
+        version: TransactionVersion::Testnet,
+        chain_id: CHAIN_ID_TESTNET,
+        auth: TransactionAuth::from_p2pkh(&signer_private_key).unwrap(),
+        anchor_mode: TransactionAnchorMode::Any,
+        post_condition_mode: TransactionPostConditionMode::Allow,
+        post_conditions: vec![],
+        payload: TransactionPayload::ContractCall(TransactionContractCall {
+            address: contract_addr.clone(),
+            contract_name: contract_name.clone(),
+            function_name: SIGNERS_VOTING_FUNCTION_NAME.into(),
+            function_args: vec![
+                point_arg.clone(),
+                point_arg.clone(),
+                round_arg.clone(),
+                reward_cycle_arg.clone(),
+            ],
+        }),
+    };
+    invalid_function_arg_signer_index.set_origin_nonce(1);
+
+    let mut invalid_function_arg_key = StacksTransaction {
+        version: TransactionVersion::Testnet,
+        chain_id: CHAIN_ID_TESTNET,
+        auth: TransactionAuth::from_p2pkh(&signer_private_key).unwrap(),
+        anchor_mode: TransactionAnchorMode::Any,
+        post_condition_mode: TransactionPostConditionMode::Allow,
+        post_conditions: vec![],
+        payload: TransactionPayload::ContractCall(TransactionContractCall {
+            address: contract_addr.clone(),
+            contract_name: contract_name.clone(),
+            function_name: SIGNERS_VOTING_FUNCTION_NAME.into(),
+            function_args: vec![
+                signer_index_arg.clone(),
+                signer_index_arg.clone(),
+                round_arg.clone(),
+                reward_cycle_arg.clone(),
+            ],
+        }),
+    };
+    invalid_function_arg_key.set_origin_nonce(1);
+
+    let mut invalid_function_arg_round = StacksTransaction {
+        version: TransactionVersion::Testnet,
+        chain_id: CHAIN_ID_TESTNET,
+        auth: TransactionAuth::from_p2pkh(&signer_private_key).unwrap(),
+        anchor_mode: TransactionAnchorMode::Any,
+        post_condition_mode: TransactionPostConditionMode::Allow,
+        post_conditions: vec![],
+        payload: TransactionPayload::ContractCall(TransactionContractCall {
+            address: contract_addr.clone(),
+            contract_name: contract_name.clone(),
+            function_name: SIGNERS_VOTING_FUNCTION_NAME.into(),
+            function_args: vec![
+                signer_index_arg.clone(),
+                point_arg.clone(),
+                point_arg.clone(),
+                reward_cycle_arg.clone(),
+            ],
+        }),
+    };
+    invalid_function_arg_round.set_origin_nonce(1);
+
+    let mut invalid_function_arg_reward_cycle = StacksTransaction {
+        version: TransactionVersion::Testnet,
+        chain_id: CHAIN_ID_TESTNET,
+        auth: TransactionAuth::from_p2pkh(&signer_private_key).unwrap(),
+        anchor_mode: TransactionAnchorMode::Any,
+        post_condition_mode: TransactionPostConditionMode::Allow,
+        post_conditions: vec![],
+        payload: TransactionPayload::ContractCall(TransactionContractCall {
+            address: contract_addr.clone(),
+            contract_name: contract_name.clone(),
+            function_name: SIGNERS_VOTING_FUNCTION_NAME.into(),
+            function_args: vec![
+                signer_index_arg.clone(),
+                point_arg.clone(),
+                round_arg.clone(),
+                point_arg.clone(),
+            ],
+        }),
+    };
+    invalid_function_arg_reward_cycle.set_origin_nonce(1);
+
+    let mut invalid_nonce = StacksTransaction {
+        version: TransactionVersion::Testnet,
+        chain_id: CHAIN_ID_TESTNET,
+        auth: TransactionAuth::from_p2pkh(&signer_private_key).unwrap(),
+        anchor_mode: TransactionAnchorMode::Any,
+        post_condition_mode: TransactionPostConditionMode::Allow,
+        post_conditions: vec![],
+        payload: TransactionPayload::ContractCall(TransactionContractCall {
+            address: contract_addr.clone(),
+            contract_name: contract_name.clone(),
+            function_name: SIGNERS_VOTING_FUNCTION_NAME.into(),
+            function_args: valid_function_args.clone(),
+        }),
+    };
+    invalid_nonce.set_origin_nonce(0); // old nonce
+
+    let mut account_nonces = std::collections::HashMap::new();
+    account_nonces.insert(invalid_not_contract_call.origin_address(), 1);
+    for tx in vec![
+        invalid_not_contract_call,
+        invalid_contract_address,
+        invalid_contract_name,
+        invalid_signers_vote_function,
+        invalid_function_arg_signer_index,
+        invalid_function_arg_key,
+        invalid_function_arg_round,
+        invalid_function_arg_reward_cycle,
+        invalid_nonce,
+        invalid_network,
+    ] {
+        assert!(!NakamotoSigners::valid_vote_transaction(
+            &account_nonces,
+            &tx,
+            mainnet
+        ));
+    }
+}
+
+#[test]
+fn filter_one_transaction_per_signer_multiple_addresses() {
+    let signer_private_key_1 = StacksPrivateKey::new();
+    let signer_private_key_2 = StacksPrivateKey::new();
+    let mainnet = false;
+    let chainid = CHAIN_ID_TESTNET;
+    let vote_contract_id = boot_code_id(SIGNERS_VOTING_NAME, mainnet);
+    let contract_addr: StacksAddress = vote_contract_id.issuer.into();
+    let contract_name = vote_contract_id.name.clone();
+
+    let signer_index = thread_rng().next_u32();
+    let signer_index_arg = Value::UInt(signer_index as u128);
+
+    let point = Point::from(Scalar::random(&mut thread_rng()));
+    let point_arg =
+        Value::buff_from(point.compress().data.to_vec()).expect("Failed to create buff");
+    let round = thread_rng().next_u64();
+    let round_arg = Value::UInt(round as u128);
+
+    let reward_cycle = thread_rng().next_u64();
+    let reward_cycle_arg = Value::UInt(reward_cycle as u128);
+
+    let function_args = vec![
+        signer_index_arg.clone(),
+        point_arg.clone(),
+        round_arg.clone(),
+        reward_cycle_arg.clone(),
+    ];
+
+    let mut valid_tx_1_address_1 = StacksTransaction {
+        version: TransactionVersion::Testnet,
+        chain_id: CHAIN_ID_TESTNET,
+        auth: TransactionAuth::from_p2pkh(&signer_private_key_1).unwrap(),
+        anchor_mode: TransactionAnchorMode::Any,
+        post_condition_mode: TransactionPostConditionMode::Allow,
+        post_conditions: vec![],
+        payload: TransactionPayload::ContractCall(TransactionContractCall {
+            address: contract_addr.clone(),
+            contract_name: contract_name.clone(),
+            function_name: SIGNERS_VOTING_FUNCTION_NAME.into(),
+            function_args: function_args.clone(),
+        }),
+    };
+    valid_tx_1_address_1.set_origin_nonce(1);
+
+    let mut valid_tx_2_address_1 = StacksTransaction {
+        version: TransactionVersion::Testnet,
+        chain_id: CHAIN_ID_TESTNET,
+        auth: TransactionAuth::from_p2pkh(&signer_private_key_1).unwrap(),
+        anchor_mode: TransactionAnchorMode::Any,
+        post_condition_mode: TransactionPostConditionMode::Allow,
+        post_conditions: vec![],
+        payload: TransactionPayload::ContractCall(TransactionContractCall {
+            address: contract_addr.clone(),
+            contract_name: contract_name.clone(),
+            function_name: SIGNERS_VOTING_FUNCTION_NAME.into(),
+            function_args: function_args.clone(),
+        }),
+    };
+    valid_tx_2_address_1.set_origin_nonce(2);
+
+    let mut valid_tx_3_address_1 = StacksTransaction {
+        version: TransactionVersion::Testnet,
+        chain_id: CHAIN_ID_TESTNET,
+        auth: TransactionAuth::from_p2pkh(&signer_private_key_1).unwrap(),
+        anchor_mode: TransactionAnchorMode::Any,
+        post_condition_mode: TransactionPostConditionMode::Allow,
+        post_conditions: vec![],
+        payload: TransactionPayload::ContractCall(TransactionContractCall {
+            address: contract_addr.clone(),
+            contract_name: contract_name.clone(),
+            function_name: SIGNERS_VOTING_FUNCTION_NAME.into(),
+            function_args: function_args.clone(),
+        }),
+    };
+    valid_tx_3_address_1.set_origin_nonce(3);
+
+    let mut valid_tx_1_address_2 = StacksTransaction {
+        version: TransactionVersion::Testnet,
+        chain_id: CHAIN_ID_TESTNET,
+        auth: TransactionAuth::from_p2pkh(&signer_private_key_2).unwrap(),
+        anchor_mode: TransactionAnchorMode::Any,
+        post_condition_mode: TransactionPostConditionMode::Allow,
+        post_conditions: vec![],
+        payload: TransactionPayload::ContractCall(TransactionContractCall {
+            address: contract_addr.clone(),
+            contract_name: contract_name.clone(),
+            function_name: SIGNERS_VOTING_FUNCTION_NAME.into(),
+            function_args: function_args.clone(),
+        }),
+    };
+    valid_tx_1_address_2.set_origin_nonce(1);
+
+    let mut valid_tx_2_address_2 = StacksTransaction {
+        version: TransactionVersion::Testnet,
+        chain_id: CHAIN_ID_TESTNET,
+        auth: TransactionAuth::from_p2pkh(&signer_private_key_2).unwrap(),
+        anchor_mode: TransactionAnchorMode::Any,
+        post_condition_mode: TransactionPostConditionMode::Allow,
+        post_conditions: vec![],
+        payload: TransactionPayload::ContractCall(TransactionContractCall {
+            address: contract_addr,
+            contract_name,
+            function_name: SIGNERS_VOTING_FUNCTION_NAME.into(),
+            function_args,
+        }),
+    };
+    valid_tx_2_address_2.set_origin_nonce(2);
+    let mut filtered_transactions = HashMap::new();
+    let mut account_nonces = std::collections::HashMap::new();
+    account_nonces.insert(valid_tx_1_address_1.origin_address(), 1);
+    account_nonces.insert(valid_tx_1_address_2.origin_address(), 1);
+    NakamotoSigners::update_filtered_transactions(
+        &mut filtered_transactions,
+        &account_nonces,
+        false,
+        vec![
+            valid_tx_1_address_1.clone(),
+            valid_tx_3_address_1,
+            valid_tx_1_address_2.clone(),
+            valid_tx_2_address_2,
+            valid_tx_2_address_1,
+        ],
+    );
+    let txs: Vec<_> = filtered_transactions.into_values().collect();
+    assert_eq!(txs.len(), 2);
+    assert!(txs.contains(&valid_tx_1_address_1));
+    assert!(txs.contains(&valid_tx_1_address_2));
+}
+
+#[test]
+fn filter_one_transaction_per_signer_duplicate_nonces() {
+    let signer_private_key = StacksPrivateKey::new();
+    let mainnet = false;
+    let chainid = CHAIN_ID_TESTNET;
+    let vote_contract_id = boot_code_id(SIGNERS_VOTING_NAME, mainnet);
+    let contract_addr: StacksAddress = vote_contract_id.issuer.into();
+    let contract_name = vote_contract_id.name.clone();
+
+    let signer_index = thread_rng().next_u32();
+    let signer_index_arg = Value::UInt(signer_index as u128);
+
+    let point = Point::from(Scalar::random(&mut thread_rng()));
+    let point_arg =
+        Value::buff_from(point.compress().data.to_vec()).expect("Failed to create buff");
+    let round = thread_rng().next_u64();
+    let round_arg = Value::UInt(round as u128);
+
+    let reward_cycle = thread_rng().next_u64();
+    let reward_cycle_arg = Value::UInt(reward_cycle as u128);
+
+    let function_args = vec![
+        signer_index_arg.clone(),
+        point_arg.clone(),
+        round_arg.clone(),
+        reward_cycle_arg.clone(),
+    ];
+
+    let mut valid_tx_1 = StacksTransaction {
+        version: TransactionVersion::Testnet,
+        chain_id: CHAIN_ID_TESTNET,
+        auth: TransactionAuth::from_p2pkh(&signer_private_key).unwrap(),
+        anchor_mode: TransactionAnchorMode::Any,
+        post_condition_mode: TransactionPostConditionMode::Allow,
+        post_conditions: vec![],
+        payload: TransactionPayload::ContractCall(TransactionContractCall {
+            address: contract_addr.clone(),
+            contract_name: contract_name.clone(),
+            function_name: SIGNERS_VOTING_FUNCTION_NAME.into(),
+            function_args: function_args.clone(),
+        }),
+    };
+    valid_tx_1.set_origin_nonce(0);
+
+    let mut valid_tx_2 = StacksTransaction {
+        version: TransactionVersion::Testnet,
+        chain_id: CHAIN_ID_TESTNET,
+        auth: TransactionAuth::from_p2pkh(&signer_private_key).unwrap(),
+        anchor_mode: TransactionAnchorMode::Any,
+        post_condition_mode: TransactionPostConditionMode::Allow,
+        post_conditions: vec![],
+        payload: TransactionPayload::ContractCall(TransactionContractCall {
+            address: contract_addr.clone(),
+            contract_name: contract_name.clone(),
+            function_name: SIGNERS_VOTING_FUNCTION_NAME.into(),
+            function_args: function_args.clone(),
+        }),
+    };
+    valid_tx_2.set_origin_nonce(0);
+
+    let mut valid_tx_3 = StacksTransaction {
+        version: TransactionVersion::Testnet,
+        chain_id: CHAIN_ID_TESTNET,
+        auth: TransactionAuth::from_p2pkh(&signer_private_key).unwrap(),
+        anchor_mode: TransactionAnchorMode::Any,
+        post_condition_mode: TransactionPostConditionMode::Allow,
+        post_conditions: vec![],
+        payload: TransactionPayload::ContractCall(TransactionContractCall {
+            address: contract_addr,
+            contract_name,
+            function_name: SIGNERS_VOTING_FUNCTION_NAME.into(),
+            function_args,
+        }),
+    };
+    valid_tx_3.set_origin_nonce(0);
+
+    let mut account_nonces = std::collections::HashMap::new();
+    account_nonces.insert(valid_tx_1.origin_address(), 0);
+    let mut txs = vec![valid_tx_2, valid_tx_1, valid_tx_3];
+    let mut filtered_transactions = HashMap::new();
+    NakamotoSigners::update_filtered_transactions(
+        &mut filtered_transactions,
+        &account_nonces,
+        false,
+        txs.clone(),
+    );
+    let filtered_txs: Vec<_> = filtered_transactions.into_values().collect();
+    txs.sort_by(|a, b| a.txid().cmp(&b.txid()));
+    assert_eq!(filtered_txs.len(), 1);
+    assert!(filtered_txs.contains(&txs.first().expect("failed to get first tx")));
+}
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index abba9be6c7..834d83ed20 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -78,6 +78,7 @@ pub const POX_3_NAME: &'static str = "pox-3";
 pub const POX_4_NAME: &'static str = "pox-4";
 pub const SIGNERS_NAME: &'static str = "signers";
 pub const SIGNERS_VOTING_NAME: &'static str = "signers-voting";
+pub const SIGNERS_VOTING_FUNCTION_NAME: &str = "vote-for-aggregate-public-key";
 /// This is the name of a variable in the `.signers` contract which tracks the most recently updated
 /// reward cycle number.
 pub const SIGNERS_UPDATE_STATE: &'static str = "last-set-cycle";
@@ -1933,7 +1934,7 @@ pub mod test {
         let payload = TransactionPayload::new_contract_call(
             boot_code_test_addr(),
             SIGNERS_VOTING_NAME,
-            "vote-for-aggregate-public-key",
+            SIGNERS_VOTING_FUNCTION_NAME,
             vec![
                 Value::UInt(signer_index),
                 aggregate_public_key,
diff --git a/stackslib/src/net/tests/mod.rs b/stackslib/src/net/tests/mod.rs
index acff183d92..9111f10fc0 100644
--- a/stackslib/src/net/tests/mod.rs
+++ b/stackslib/src/net/tests/mod.rs
@@ -46,7 +46,9 @@ use crate::chainstate::stacks::address::PoxAddress;
 use crate::chainstate::stacks::boot::test::{
     key_to_stacks_addr, make_pox_4_lockup, make_signer_key_signature, with_sortdb,
 };
-use crate::chainstate::stacks::boot::MINERS_NAME;
+use crate::chainstate::stacks::boot::{
+    MINERS_NAME, SIGNERS_VOTING_FUNCTION_NAME, SIGNERS_VOTING_NAME,
+};
 use crate::chainstate::stacks::db::{MinerPaymentTxFees, StacksAccount, StacksChainState};
 use crate::chainstate::stacks::events::TransactionOrigin;
 use crate::chainstate::stacks::{
@@ -185,9 +187,9 @@ impl NakamotoBootPlan {
                         function_name,
                         ..
                     }) => {
-                        if contract_name.as_str() == "signers-voting"
+                        if contract_name.as_str() == SIGNERS_VOTING_NAME
                             && address.is_burn()
-                            && function_name.as_str() == "vote-for-aggregate-public-key"
+                            && function_name.as_str() == SIGNERS_VOTING_FUNCTION_NAME
                         {
                             false
                         } else {
diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index 2629f4f9b2..011300bc88 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -49,7 +49,7 @@ use stacks::chainstate::nakamoto::{
     NakamotoBlock, NakamotoBlockHeader, NakamotoChainState, SetupBlockResult,
 };
 use stacks::chainstate::stacks::address::PoxAddress;
-use stacks::chainstate::stacks::boot::SIGNERS_VOTING_NAME;
+use stacks::chainstate::stacks::boot::{SIGNERS_VOTING_FUNCTION_NAME, SIGNERS_VOTING_NAME};
 use stacks::chainstate::stacks::db::{ChainStateBootData, ClarityTx, StacksChainState};
 use stacks::chainstate::stacks::miner::{
     BlockBuilder, BlockBuilderSettings, BlockLimitFunction, MinerStatus, TransactionResult,
@@ -934,7 +934,7 @@ impl MockamotoNode {
         let vote_payload = TransactionPayload::new_contract_call(
             boot_code_addr(false),
             SIGNERS_VOTING_NAME,
-            "vote-for-aggregate-public-key",
+            SIGNERS_VOTING_FUNCTION_NAME,
             vec![
                 ClarityValue::UInt(0),
                 aggregate_public_key_val,
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index ec57fc3ef7..9c886b4343 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -331,48 +331,43 @@ impl BlockMinerThread {
             })
             .collect();
 
-        // There may be more than signer messages, but odds are there is only one transacton per signer
-        let mut transactions_to_include = Vec::with_capacity(signer_messages.len());
+        if signer_messages.is_empty() {
+            return Ok(vec![]);
+        }
+
+        // Get all nonces for the signers from clarity DB to use to validate transactions
+        let account_nonces = chainstate
+            .with_read_only_clarity_tx(&sortdb.index_conn(), &self.parent_tenure_id, |clarity_tx| {
+                clarity_tx.with_clarity_db_readonly(|clarity_db| {
+                    addresses
+                        .iter()
+                        .map(|address| {
+                            (
+                                address.clone(),
+                                clarity_db
+                                    .get_account_nonce(&address.clone().into())
+                                    .unwrap_or(0),
+                            )
+                        })
+                        .collect::<HashMap<StacksAddress, u64>>()
+                })
+            })
+            .unwrap_or_default();
+        let mut filtered_transactions: HashMap<StacksAddress, StacksTransaction> = HashMap::new();
         for (_slot, signer_message) in signer_messages {
             match signer_message {
                 SignerMessage::Transactions(transactions) => {
-                    for transaction in transactions {
-                        let address = transaction.origin_address();
-                        let nonce = transaction.get_origin_nonce();
-                        if !addresses.contains(&address) {
-                            test_debug!("Miner: ignoring transaction ({:?}) with nonce {nonce} from address {address}", transaction.txid());
-                            continue;
-                        }
-
-                        let cur_nonce = chainstate
-                            .with_read_only_clarity_tx(
-                                &sortdb.index_conn(),
-                                &self.parent_tenure_id,
-                                |clarity_tx| {
-                                    clarity_tx.with_clarity_db_readonly(|clarity_db| {
-                                        clarity_db.get_account_nonce(&address.into()).unwrap_or(0)
-                                    })
-                                },
-                            )
-                            .unwrap_or(0);
-
-                        if cur_nonce > nonce {
-                            test_debug!("Miner: ignoring transaction ({:?}) with nonce {nonce} from address {address}", transaction.txid());
-                            continue;
-                        }
-                        debug!("Miner: including signer transaction.";
-                            "nonce" => {nonce},
-                            "origin_address" => %address,
-                            "txid" => %transaction.txid()
-                        );
-                        // TODO : filter out transactions that are not valid votes. Do not include transactions with invalid/duplicate nonces for the same address.
-                        transactions_to_include.push(transaction);
-                    }
+                    NakamotoSigners::update_filtered_transactions(
+                        &mut filtered_transactions,
+                        &account_nonces,
+                        self.config.is_mainnet(),
+                        transactions,
+                    )
                 }
                 _ => {} // Any other message is ignored
             }
         }
-        Ok(transactions_to_include)
+        Ok(filtered_transactions.into_values().collect())
     }
 
     fn wait_for_signer_signature(
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index e97aefd42a..3b46ce24ac 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -30,7 +30,9 @@ use stacks::chainstate::nakamoto::miner::NakamotoBlockBuilder;
 use stacks::chainstate::nakamoto::test_signers::TestSigners;
 use stacks::chainstate::nakamoto::{NakamotoBlock, NakamotoChainState};
 use stacks::chainstate::stacks::address::PoxAddress;
-use stacks::chainstate::stacks::boot::{MINERS_NAME, SIGNERS_VOTING_NAME};
+use stacks::chainstate::stacks::boot::{
+    MINERS_NAME, SIGNERS_VOTING_FUNCTION_NAME, SIGNERS_VOTING_NAME,
+};
 use stacks::chainstate::stacks::db::StacksChainState;
 use stacks::chainstate::stacks::miner::{BlockBuilder, BlockLimitFunction, TransactionResult};
 use stacks::chainstate::stacks::{StacksTransaction, ThresholdSignature, TransactionPayload};
@@ -455,7 +457,7 @@ pub fn boot_to_epoch_3(
                 300,
                 &StacksAddress::burn_address(false),
                 SIGNERS_VOTING_NAME,
-                "vote-for-aggregate-public-key",
+                SIGNERS_VOTING_FUNCTION_NAME,
                 &[
                     clarity::vm::Value::UInt(i as u128),
                     aggregate_public_key.clone(),
@@ -564,7 +566,7 @@ fn signer_vote_if_needed(
                     300,
                     &StacksAddress::burn_address(false),
                     SIGNERS_VOTING_NAME,
-                    "vote-for-aggregate-public-key",
+                    SIGNERS_VOTING_FUNCTION_NAME,
                     &[
                         clarity::vm::Value::UInt(i as u128),
                         aggregate_public_key.clone(),
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index d903f58c43..3fd265d798 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -7,23 +7,35 @@ use std::time::{Duration, Instant};
 use std::{env, thread};
 
 use clarity::boot_util::boot_code_id;
+use clarity::vm::Value;
 use libsigner::{
     BlockResponse, RejectCode, RunningSigner, Signer, SignerEventReceiver, SignerMessage,
     BLOCK_MSG_ID,
 };
+use rand::thread_rng;
+use rand_core::RngCore;
 use stacks::burnchains::Txid;
 use stacks::chainstate::coordinator::comm::CoordinatorChannels;
 use stacks::chainstate::nakamoto::signer_set::NakamotoSigners;
 use stacks::chainstate::nakamoto::{NakamotoBlock, NakamotoBlockHeader, NakamotoBlockVote};
-use stacks::chainstate::stacks::boot::SIGNERS_NAME;
+use stacks::chainstate::stacks::boot::{
+    SIGNERS_NAME, SIGNERS_VOTING_FUNCTION_NAME, SIGNERS_VOTING_NAME,
+};
 use stacks::chainstate::stacks::miner::TransactionEvent;
-use stacks::chainstate::stacks::{StacksPrivateKey, StacksTransaction, ThresholdSignature};
+use stacks::chainstate::stacks::{
+    StacksPrivateKey, StacksTransaction, ThresholdSignature, TransactionAnchorMode,
+    TransactionAuth, TransactionPayload, TransactionPostConditionMode, TransactionSmartContract,
+    TransactionVersion,
+};
 use stacks::core::StacksEpoch;
 use stacks::net::api::postblock_proposal::BlockValidateResponse;
+use stacks::util_lib::strings::StacksString;
 use stacks_common::bitvec::BitVec;
 use stacks_common::codec::{read_next, StacksMessageCodec};
-use stacks_common::consts::SIGNER_SLOTS_PER_USER;
-use stacks_common::types::chainstate::{ConsensusHash, StacksBlockId, TrieHash};
+use stacks_common::consts::{CHAIN_ID_TESTNET, SIGNER_SLOTS_PER_USER};
+use stacks_common::types::chainstate::{
+    ConsensusHash, StacksAddress, StacksBlockId, StacksPublicKey, TrieHash,
+};
 use stacks_common::types::StacksEpochId;
 use stacks_common::util::hash::{MerkleTree, Sha512Trunc256Sum};
 use stacks_common::util::secp256k1::MessageSignature;
@@ -545,38 +557,190 @@ impl SignerTest {
             .unwrap();
         // Get the signer indices
         let reward_cycle = self.get_current_reward_cycle();
-        let valid_signer_index = self.get_signer_index(reward_cycle);
-        let round = self
-            .stacks_client
-            .get_last_round(reward_cycle)
-            .expect("FATAL: failed to get round")
-            .unwrap_or(0)
-            .saturating_add(1);
-        let point = Point::from(Scalar::random(&mut rand::thread_rng()));
-        let invalid_nonce_tx = self
-            .stacks_client
-            .build_vote_for_aggregate_public_key(
-                valid_signer_index,
-                round,
-                point,
-                reward_cycle,
+
+        let signer_private_key = self.signer_stacks_private_keys[0];
+
+        let vote_contract_id = boot_code_id(SIGNERS_VOTING_NAME, false);
+        let contract_addr = vote_contract_id.issuer.into();
+        let contract_name = vote_contract_id.name.clone();
+
+        let signer_index = thread_rng().next_u64();
+        let signer_index_arg = Value::UInt(signer_index as u128);
+
+        let point = Point::from(Scalar::random(&mut thread_rng()));
+        let point_arg =
+            Value::buff_from(point.compress().data.to_vec()).expect("Failed to create buff");
+
+        let round = thread_rng().next_u64();
+        let round_arg = Value::UInt(round as u128);
+
+        let reward_cycle_arg = Value::UInt(reward_cycle as u128);
+        let valid_function_args = vec![
+            signer_index_arg.clone(),
+            point_arg.clone(),
+            round_arg.clone(),
+            reward_cycle_arg.clone(),
+        ];
+
+        // Create a invalid transaction that is not a contract call
+        let invalid_not_contract_call = StacksTransaction {
+            version: TransactionVersion::Testnet,
+            chain_id: CHAIN_ID_TESTNET,
+            auth: TransactionAuth::from_p2pkh(&signer_private_key).unwrap(),
+            anchor_mode: TransactionAnchorMode::Any,
+            post_condition_mode: TransactionPostConditionMode::Allow,
+            post_conditions: vec![],
+            payload: TransactionPayload::SmartContract(
+                TransactionSmartContract {
+                    name: "test-contract".into(),
+                    code_body: StacksString::from_str("(/ 1 0)").unwrap(),
+                },
                 None,
-                0, // Old nonce
+            ),
+        };
+        let invalid_contract_address = StacksClient::build_signed_contract_call_transaction(
+            &StacksAddress::p2pkh(false, &StacksPublicKey::from_private(&signer_private_key)),
+            contract_name.clone(),
+            SIGNERS_VOTING_FUNCTION_NAME.into(),
+            &valid_function_args,
+            &signer_private_key,
+            TransactionVersion::Testnet,
+            CHAIN_ID_TESTNET,
+            1,
+            10,
+        )
+        .unwrap();
+
+        let invalid_contract_name = StacksClient::build_signed_contract_call_transaction(
+            &contract_addr,
+            "bad-signers-contract-name".into(),
+            SIGNERS_VOTING_FUNCTION_NAME.into(),
+            &valid_function_args,
+            &signer_private_key,
+            TransactionVersion::Testnet,
+            CHAIN_ID_TESTNET,
+            1,
+            10,
+        )
+        .unwrap();
+
+        let invalid_signers_vote_function = StacksClient::build_signed_contract_call_transaction(
+            &contract_addr,
+            contract_name.clone(),
+            "some-other-function".into(),
+            &valid_function_args,
+            &signer_private_key,
+            TransactionVersion::Testnet,
+            CHAIN_ID_TESTNET,
+            1,
+            10,
+        )
+        .unwrap();
+
+        let invalid_function_arg_signer_index =
+            StacksClient::build_signed_contract_call_transaction(
+                &contract_addr,
+                contract_name.clone(),
+                SIGNERS_VOTING_FUNCTION_NAME.into(),
+                &[
+                    point_arg.clone(),
+                    point_arg.clone(),
+                    round_arg.clone(),
+                    reward_cycle_arg.clone(),
+                ],
+                &signer_private_key,
+                TransactionVersion::Testnet,
+                CHAIN_ID_TESTNET,
+                1,
+                10,
             )
-            .expect("FATAL: failed to build vote for aggregate public key");
+            .unwrap();
+
+        let invalid_function_arg_key = StacksClient::build_signed_contract_call_transaction(
+            &contract_addr,
+            contract_name.clone(),
+            SIGNERS_VOTING_FUNCTION_NAME.into(),
+            &[
+                signer_index_arg.clone(),
+                signer_index_arg.clone(),
+                round_arg.clone(),
+                reward_cycle_arg.clone(),
+            ],
+            &signer_private_key,
+            TransactionVersion::Testnet,
+            CHAIN_ID_TESTNET,
+            1,
+            10,
+        )
+        .unwrap();
+
+        let invalid_function_arg_round = StacksClient::build_signed_contract_call_transaction(
+            &contract_addr,
+            contract_name.clone(),
+            SIGNERS_VOTING_FUNCTION_NAME.into(),
+            &[
+                signer_index_arg.clone(),
+                point_arg.clone(),
+                point_arg.clone(),
+                reward_cycle_arg.clone(),
+            ],
+            &signer_private_key,
+            TransactionVersion::Testnet,
+            CHAIN_ID_TESTNET,
+            1,
+            10,
+        )
+        .unwrap();
+
+        let invalid_function_arg_reward_cycle =
+            StacksClient::build_signed_contract_call_transaction(
+                &contract_addr,
+                contract_name.clone(),
+                SIGNERS_VOTING_FUNCTION_NAME.into(),
+                &[
+                    signer_index_arg.clone(),
+                    point_arg.clone(),
+                    round_arg.clone(),
+                    point_arg.clone(),
+                ],
+                &signer_private_key,
+                TransactionVersion::Testnet,
+                CHAIN_ID_TESTNET,
+                1,
+                10,
+            )
+            .unwrap();
+
+        let invalid_nonce = StacksClient::build_signed_contract_call_transaction(
+            &contract_addr,
+            contract_name.clone(),
+            SIGNERS_VOTING_FUNCTION_NAME.into(),
+            &valid_function_args,
+            &signer_private_key,
+            TransactionVersion::Testnet,
+            CHAIN_ID_TESTNET,
+            0, // Old nonce
+            10,
+        )
+        .unwrap();
+
         let invalid_stacks_client = StacksClient::new(StacksPrivateKey::new(), host, false);
         let invalid_signer_tx = invalid_stacks_client
-            .build_vote_for_aggregate_public_key(
-                valid_signer_index,
-                round,
-                point,
-                reward_cycle,
-                None,
-                0,
-            )
+            .build_vote_for_aggregate_public_key(0, round, point, reward_cycle, None, 0)
             .expect("FATAL: failed to build vote for aggregate public key");
-        // TODO: add invalid contract calls (one with non 'vote-for-aggregate-public-key' function call and one with invalid function args)
-        vec![invalid_nonce_tx, invalid_signer_tx]
+
+        vec![
+            invalid_nonce,
+            invalid_not_contract_call,
+            invalid_contract_name,
+            invalid_contract_address,
+            invalid_signers_vote_function,
+            invalid_function_arg_key,
+            invalid_function_arg_reward_cycle,
+            invalid_function_arg_round,
+            invalid_function_arg_signer_index,
+            invalid_signer_tx,
+        ]
     }
 
     fn shutdown(self) {

From ce308f33c6df9d620a3d64c36eed8241b0281f04 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 28 Feb 2024 09:03:34 -0500
Subject: [PATCH 0984/1166] CRC: rename point vars to dkg_public_key for
 clarity

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/stacks_client.rs |  8 ++++----
 stacks-signer/src/signer.rs               | 18 +++++++++---------
 2 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index 5e422b3c62..471cec068f 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -483,12 +483,12 @@ impl StacksClient {
                 "Failed to convert aggregate public key to compressed data: {e}"
             ))
         })?;
-        let point = Point::try_from(&compressed_data).map_err(|e| {
+        let dkg_public_key = Point::try_from(&compressed_data).map_err(|e| {
             ClientError::MalformedClarityValue(format!(
                 "Failed to convert aggregate public key to a point: {e}"
             ))
         })?;
-        Ok(Some(point))
+        Ok(Some(dkg_public_key))
     }
 
     /// Helper function to create a stacks transaction for a modifying contract call
@@ -496,7 +496,7 @@ impl StacksClient {
         &self,
         signer_index: u32,
         round: u64,
-        point: Point,
+        dkg_public_key: Point,
         reward_cycle: u64,
         tx_fee: Option<u64>,
         nonce: u64,
@@ -507,7 +507,7 @@ impl StacksClient {
         let function_name = ClarityName::from(SIGNERS_VOTING_FUNCTION_NAME);
         let function_args = vec![
             ClarityValue::UInt(signer_index as u128),
-            ClarityValue::buff_from(point.compress().data.to_vec())?,
+            ClarityValue::buff_from(dkg_public_key.compress().data.to_vec())?,
             ClarityValue::UInt(round as u128),
             ClarityValue::UInt(reward_cycle as u128),
         ];
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index e759f2ff70..e67d203700 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -839,8 +839,8 @@ impl Signer {
                 OperationResult::SignTaproot(_) => {
                     debug!("Signer #{}: Received a signature result for a taproot signature. Nothing to broadcast as we currently sign blocks with a FROST signature.", self.signer_id);
                 }
-                OperationResult::Dkg(point) => {
-                    self.process_dkg(stacks_client, point);
+                OperationResult::Dkg(dkg_public_key) => {
+                    self.process_dkg(stacks_client, dkg_public_key);
                 }
                 OperationResult::SignError(e) => {
                     warn!("Signer #{}: Received a Sign error: {e:?}", self.signer_id);
@@ -855,7 +855,7 @@ impl Signer {
     }
 
     /// Process a dkg result by broadcasting a vote to the stacks node
-    fn process_dkg(&mut self, stacks_client: &StacksClient, point: &Point) {
+    fn process_dkg(&mut self, stacks_client: &StacksClient, dkg_public_key: &Point) {
         let epoch = retry_with_exponential_backoff(|| {
             stacks_client
                 .get_node_epoch()
@@ -895,7 +895,7 @@ impl Signer {
         match stacks_client.build_vote_for_aggregate_public_key(
             self.stackerdb.get_signer_slot_id(),
             self.coordinator.current_dkg_id,
-            *point,
+            *dkg_public_key,
             self.reward_cycle,
             tx_fee,
             next_nonce,
@@ -908,14 +908,14 @@ impl Signer {
                     new_transaction,
                 ) {
                     warn!(
-                        "Signer #{}: Failed to broadcast DKG vote ({point:?}): {e:?}",
+                        "Signer #{}: Failed to broadcast DKG public key vote ({dkg_public_key:?}): {e:?}",
                         self.signer_id
                     );
                 }
             }
             Err(e) => {
                 warn!(
-                    "Signer #{}: Failed to build DKG vote ({point:?}) transaction: {e:?}.",
+                    "Signer #{}: Failed to build DKG public key vote ({dkg_public_key:?}) transaction: {e:?}.",
                     self.signer_id
                 );
             }
@@ -1137,15 +1137,15 @@ impl Signer {
             }).unwrap_or_default();
             // Check if we have an existing vote transaction for the same round and reward cycle
             for transaction in old_transactions.iter() {
-                let (_index, point, round, reward_cycle) =
+                let (_index, dkg_public_key, round, reward_cycle) =
                     NakamotoSigners::parse_vote_for_aggregate_public_key(transaction).expect(&format!("BUG: Signer #{}: Received an invalid {SIGNERS_VOTING_FUNCTION_NAME} transaction in an already filtered list: {transaction:?}", self.signer_id));
-                if Some(point) == self.coordinator.aggregate_public_key
+                if Some(dkg_public_key) == self.coordinator.aggregate_public_key
                     && round == self.coordinator.current_dkg_id
                     && reward_cycle == self.reward_cycle
                 {
                     debug!("Signer #{}: Not triggering a DKG round. Already have a pending vote transaction.", self.signer_id;
                         "txid" => %transaction.txid(),
-                        "point" => %point,
+                        "dkg_public_key" => %dkg_public_key,
                         "round" => round
                     );
                     return Ok(());

From c533146b7d4d1dd38ac381fc54fcd18a3bd3a6bd Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 1 Mar 2024 08:15:05 -0500
Subject: [PATCH 0985/1166] CRC: pull parsed aggregate key vote results into a
 struct

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/signer.rs                   | 14 ++++++-------
 .../src/chainstate/nakamoto/signer_set.rs     | 20 +++++++++++++++----
 .../src/chainstate/nakamoto/tests/mod.rs      | 11 +++++-----
 3 files changed, 28 insertions(+), 17 deletions(-)

diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index e67d203700..fd80138aa1 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -1131,22 +1131,22 @@ impl Signer {
             // Have I already voted and have a pending transaction? Check stackerdb for the same round number and reward cycle vote transaction
             // Only get the account nonce of THIS signer as we only care about our own votes, not other signer votes
             let signer_address = stacks_client.get_signer_address();
-            let account_nonces = self.get_account_nonces(stacks_client, &[signer_address.clone()]);
+            let account_nonces = self.get_account_nonces(stacks_client, &[*signer_address]);
             let old_transactions = self.get_signer_transactions(&account_nonces).map_err(|e| {
                 warn!("Signer #{}: Failed to get old signer transactions: {e:?}. May trigger DKG unnecessarily", self.signer_id);
             }).unwrap_or_default();
             // Check if we have an existing vote transaction for the same round and reward cycle
             for transaction in old_transactions.iter() {
-                let (_index, dkg_public_key, round, reward_cycle) =
-                    NakamotoSigners::parse_vote_for_aggregate_public_key(transaction).expect(&format!("BUG: Signer #{}: Received an invalid {SIGNERS_VOTING_FUNCTION_NAME} transaction in an already filtered list: {transaction:?}", self.signer_id));
-                if Some(dkg_public_key) == self.coordinator.aggregate_public_key
-                    && round == self.coordinator.current_dkg_id
+                let params =
+                    NakamotoSigners::parse_vote_for_aggregate_public_key(transaction).unwrap_or_else(|| panic!("BUG: Signer #{}: Received an invalid {SIGNERS_VOTING_FUNCTION_NAME} transaction in an already filtered list: {transaction:?}", self.signer_id));
+                if Some(params.aggregate_key) == self.coordinator.aggregate_public_key
+                    && params.voting_round == self.coordinator.current_dkg_id
                     && reward_cycle == self.reward_cycle
                 {
                     debug!("Signer #{}: Not triggering a DKG round. Already have a pending vote transaction.", self.signer_id;
                         "txid" => %transaction.txid(),
-                        "dkg_public_key" => %dkg_public_key,
-                        "round" => round
+                        "aggregate_key" => %params.aggregate_key,
+                        "voting_round" => params.voting_round
                     );
                     return Ok(());
                 }
diff --git a/stackslib/src/chainstate/nakamoto/signer_set.rs b/stackslib/src/chainstate/nakamoto/signer_set.rs
index a39d6bebc2..5049286908 100644
--- a/stackslib/src/chainstate/nakamoto/signer_set.rs
+++ b/stackslib/src/chainstate/nakamoto/signer_set.rs
@@ -99,6 +99,13 @@ pub struct SignerCalculation {
     pub events: Vec<StacksTransactionEvent>,
 }
 
+pub struct AggregateKeyVoteParams {
+    pub signer_index: u64,
+    pub aggregate_key: Point,
+    pub voting_round: u64,
+    pub reward_cycle: u64,
+}
+
 impl RawRewardSetEntry {
     pub fn from_pox_4_tuple(is_mainnet: bool, tuple: TupleData) -> Result<Self, ChainstateError> {
         let mut tuple_data = tuple.data_map;
@@ -515,7 +522,7 @@ impl NakamotoSigners {
 
     pub fn parse_vote_for_aggregate_public_key(
         transaction: &StacksTransaction,
-    ) -> Option<(u64, Point, u64, u64)> {
+    ) -> Option<AggregateKeyVoteParams> {
         let TransactionPayload::ContractCall(payload) = &transaction.payload else {
             // Not a contract call so not a special cased vote for aggregate public key transaction
             return None;
@@ -535,12 +542,17 @@ impl NakamotoSigners {
         let point_value = payload.function_args.get(1)?;
         let point_bytes = point_value.clone().expect_buff(33).ok()?;
         let compressed_data = Compressed::try_from(point_bytes.as_slice()).ok()?;
-        let point = Point::try_from(&compressed_data).ok()?;
+        let aggregate_key = Point::try_from(&compressed_data).ok()?;
         let round_value = payload.function_args.get(2)?;
-        let round = u64::try_from(round_value.clone().expect_u128().ok()?).ok()?;
+        let voting_round = u64::try_from(round_value.clone().expect_u128().ok()?).ok()?;
         let reward_cycle =
             u64::try_from(payload.function_args.get(3)?.clone().expect_u128().ok()?).ok()?;
-        Some((signer_index, point, round, reward_cycle))
+        Some(AggregateKeyVoteParams {
+            signer_index,
+            aggregate_key,
+            voting_round,
+            reward_cycle,
+        })
     }
 
     /// Update the map of filtered valid transactions, selecting one per address based first on lowest nonce, then txid
diff --git a/stackslib/src/chainstate/nakamoto/tests/mod.rs b/stackslib/src/chainstate/nakamoto/tests/mod.rs
index c27505b516..28d620b814 100644
--- a/stackslib/src/chainstate/nakamoto/tests/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/tests/mod.rs
@@ -2122,12 +2122,11 @@ fn parse_vote_for_aggregate_public_key_valid() {
             function_args: valid_function_args,
         }),
     };
-    let (res_signer_index, res_point, res_round, res_reward_cycle) =
-        NakamotoSigners::parse_vote_for_aggregate_public_key(&valid_tx).unwrap();
-    assert_eq!(res_signer_index, signer_index);
-    assert_eq!(res_point, point);
-    assert_eq!(res_round, round);
-    assert_eq!(res_reward_cycle, reward_cycle);
+    let params = NakamotoSigners::parse_vote_for_aggregate_public_key(&valid_tx).unwrap();
+    assert_eq!(params.signer_index, signer_index);
+    assert_eq!(params.aggregate_key, point);
+    assert_eq!(params.voting_round, round);
+    assert_eq!(params.reward_cycle, reward_cycle);
 }
 
 #[test]

From 31e4896e5cfdd19d4ed8bacc2e98275c114bb253 Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Fri, 1 Mar 2024 09:39:26 -0500
Subject: [PATCH 0986/1166] fix: update the expected response type for a call
 to `get-vote`

It now returns a tuple including the weight, instead of just the key.

```clarity
(option { aggregate-public-key: (buff 33), signer-weight: uint })
```
---
 stacks-signer/src/client/stacks_client.rs | 37 +++++++++++++----------
 1 file changed, 21 insertions(+), 16 deletions(-)

diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index caa5c7018a..273998c3b9 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -175,7 +175,18 @@ impl StacksClient {
             &function_name,
             function_args,
         )?;
-        self.parse_aggregate_public_key(value)
+        // Return value is of type:
+        // ```clarity
+        // (option { aggregate-public-key: (buff 33), signer-weight: uint })
+        // ```
+        let inner_data = value.expect_optional()?;
+        if let Some(inner_data) = inner_data {
+            let tuple = inner_data.expect_tuple()?;
+            let key_value = tuple.get_owned("aggregate-public-key")?;
+            self.parse_aggregate_public_key(key_value)
+        } else {
+            Ok(None)
+        }
     }
 
     /// Determine the stacks node current epoch
@@ -244,7 +255,12 @@ impl StacksClient {
             &function_name,
             function_args,
         )?;
-        self.parse_aggregate_public_key(value)
+        let inner_data = value.expect_optional()?;
+        if let Some(key_value) = inner_data {
+            self.parse_aggregate_public_key(key_value)
+        } else {
+            Ok(None)
+        }
     }
 
     /// Retrieve the current account nonce for the provided address
@@ -472,11 +488,7 @@ impl StacksClient {
         value: ClarityValue,
     ) -> Result<Option<Point>, ClientError> {
         debug!("Parsing aggregate public key...");
-        let opt = value.clone().expect_optional()?;
-        let Some(inner_data) = opt else {
-            return Ok(None);
-        };
-        let data = inner_data.expect_buff(33)?;
+        let data = value.expect_buff(33)?;
         // It is possible that the point was invalid though when voted upon and this cannot be prevented by pox 4 definitions...
         // Pass up this error if the conversions fail.
         let compressed_data = Compressed::try_from(data.as_slice()).map_err(|e| {
@@ -855,20 +867,13 @@ mod tests {
     fn parse_valid_aggregate_public_key_should_succeed() {
         let mock = MockServerClient::new();
         let orig_point = Point::from(Scalar::random(&mut rand::thread_rng()));
-        let clarity_value = ClarityValue::some(
-            ClarityValue::buff_from(orig_point.compress().as_bytes().to_vec())
-                .expect("BUG: Failed to create clarity value from point"),
-        )
-        .expect("BUG: Failed to create clarity value from point");
+        let clarity_value = ClarityValue::buff_from(orig_point.compress().as_bytes().to_vec())
+            .expect("BUG: Failed to create clarity value from point");
         let result = mock
             .client
             .parse_aggregate_public_key(clarity_value)
             .unwrap();
         assert_eq!(result, Some(orig_point));
-
-        let value = ClarityValue::none();
-        let result = mock.client.parse_aggregate_public_key(value).unwrap();
-        assert!(result.is_none());
     }
 
     #[test]

From 432e9184cb10a085efc7ab195260d8f7a1fc33ea Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Fri, 1 Mar 2024 09:38:16 -0600
Subject: [PATCH 0987/1166] fix: manually calculate current reward cycle ID in
 /v2/pox_info

---
 stackslib/src/net/api/getpoxinfo.rs | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/stackslib/src/net/api/getpoxinfo.rs b/stackslib/src/net/api/getpoxinfo.rs
index f7475c9cde..c9e59b6519 100644
--- a/stackslib/src/net/api/getpoxinfo.rs
+++ b/stackslib/src/net/api/getpoxinfo.rs
@@ -226,12 +226,6 @@ impl RPCPoxInfoData {
             .to_owned()
             .expect_u128()? as u64;
 
-        let reward_cycle_id = res
-            .get("reward-cycle-id")
-            .unwrap_or_else(|_| panic!("FATAL: no 'reward-cycle-id'"))
-            .to_owned()
-            .expect_u128()? as u64;
-
         let reward_cycle_length = res
             .get("reward-cycle-length")
             .unwrap_or_else(|_| panic!("FATAL: no 'reward-cycle-length'"))
@@ -292,7 +286,13 @@ impl RPCPoxInfoData {
             return Err(NetError::DBError(DBError::Corruption));
         }
 
+        let reward_cycle_id = burnchain
+            .block_height_to_reward_cycle(burnchain_tip.block_height)
+            .ok_or_else(|| {
+                NetError::ChainstateError("Current burn block height is before stacks start".into())
+            })?;
         let effective_height = burnchain_tip.block_height - first_burnchain_block_height;
+
         let next_reward_cycle_in = reward_cycle_length - (effective_height % reward_cycle_length);
 
         let next_rewards_start = burnchain_tip.block_height + next_reward_cycle_in;

From 83ac3276dc987dd0e8511eb0cc2756d72cebb5ab Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Thu, 22 Feb 2024 15:57:31 -0600
Subject: [PATCH 0988/1166] chore: remove self_signing mode

* remove self_signing mode from nakamoto-node
* update integration tests that used self_signing to have a blind signing thread which reads/writes through stackerdb
---
 libsigner/src/session.rs                      |  34 +-
 testnet/stacks-node/src/config.rs             |  17 -
 .../stacks-node/src/nakamoto_node/miner.rs    |  68 +--
 testnet/stacks-node/src/run_loop/neon.rs      |  89 ++--
 .../src/tests/nakamoto_integrations.rs        | 395 +++++++++++++-----
 testnet/stacks-node/src/tests/signer.rs       |   7 +-
 6 files changed, 376 insertions(+), 234 deletions(-)

diff --git a/libsigner/src/session.rs b/libsigner/src/session.rs
index e5dbd67f35..4d7e40bf71 100644
--- a/libsigner/src/session.rs
+++ b/libsigner/src/session.rs
@@ -22,6 +22,7 @@ use libstackerdb::{
     stackerdb_get_chunk_path, stackerdb_get_metadata_path, stackerdb_post_chunk_path, SlotMetadata,
     StackerDBChunkAckData, StackerDBChunkData,
 };
+use stacks_common::codec::StacksMessageCodec;
 
 use crate::error::RPCError;
 use crate::http::run_http_request;
@@ -51,7 +52,14 @@ pub trait SignerSession {
     /// Returns Ok(None) if the chunk with the given version does not exist
     /// Returns Err(..) on transport error
     fn get_chunk(&mut self, slot_id: u32, version: u32) -> Result<Option<Vec<u8>>, RPCError> {
-        Ok(self.get_chunks(&[(slot_id, version)])?[0].clone())
+        let mut chunks = self.get_chunks(&[(slot_id, version)])?;
+        // check if chunks is empty because [0] and remove(0) panic on out-of-bounds
+        if chunks.is_empty() {
+            return Ok(None);
+        }
+        // swap_remove breaks the ordering of latest_chunks, but we don't care because we
+        //  only want the first element anyways.
+        Ok(chunks.swap_remove(0))
     }
 
     /// Get a single latest chunk.
@@ -59,7 +67,29 @@ pub trait SignerSession {
     /// Returns Ok(None) if not
     /// Returns Err(..) on transport error
     fn get_latest_chunk(&mut self, slot_id: u32) -> Result<Option<Vec<u8>>, RPCError> {
-        Ok(self.get_latest_chunks(&[(slot_id)])?[0].clone())
+        let mut latest_chunks = self.get_latest_chunks(&[slot_id])?;
+        // check if latest_chunks is empty because [0] and remove(0) panic on out-of-bounds
+        if latest_chunks.is_empty() {
+            return Ok(None);
+        }
+        // swap_remove breaks the ordering of latest_chunks, but we don't care because we
+        //  only want the first element anyways.
+        Ok(latest_chunks.swap_remove(0))
+    }
+
+    /// Get a single latest chunk from the StackerDB and deserialize into `T` using the
+    /// StacksMessageCodec.
+    fn get_latest<T: StacksMessageCodec>(&mut self, slot_id: u32) -> Result<Option<T>, RPCError> {
+        let Some(latest_bytes) = self.get_latest_chunk(slot_id)? else {
+            return Ok(None);
+        };
+        Some(
+            T::consensus_deserialize(&mut latest_bytes.as_slice()).map_err(|e| {
+                let msg = format!("StacksMessageCodec::consensus_deserialize failure: {e}");
+                RPCError::Deserialize(msg)
+            }),
+        )
+        .transpose()
     }
 }
 
diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index 7e2751d7a8..d33ecf0c17 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -12,7 +12,6 @@ use rand::RngCore;
 use stacks::burnchains::bitcoin::BitcoinNetworkType;
 use stacks::burnchains::{Burnchain, MagicBytes, BLOCKSTACK_MAGIC_MAINNET};
 use stacks::chainstate::nakamoto::signer_set::NakamotoSigners;
-use stacks::chainstate::nakamoto::test_signers::TestSigners;
 use stacks::chainstate::stacks::boot::MINERS_NAME;
 use stacks::chainstate::stacks::index::marf::MARFOpenOpts;
 use stacks::chainstate::stacks::index::storage::TrieHashCalculationMode;
@@ -505,19 +504,6 @@ lazy_static! {
 }
 
 impl Config {
-    #[cfg(any(test, feature = "testing"))]
-    pub fn self_signing(&self) -> Option<TestSigners> {
-        if !(self.burnchain.mode == "nakamoto-neon" || self.burnchain.mode == "mockamoto") {
-            return None;
-        }
-        self.miner.self_signing_key.clone()
-    }
-
-    #[cfg(not(any(test, feature = "testing")))]
-    pub fn self_signing(&self) -> Option<TestSigners> {
-        return None;
-    }
-
     /// get the up-to-date burnchain options from the config.
     /// If the config file can't be loaded, then return the existing config
     pub fn get_burnchain_config(&self) -> BurnchainConfig {
@@ -1998,7 +1984,6 @@ pub struct MinerConfig {
     pub candidate_retry_cache_size: u64,
     pub unprocessed_block_deadline_secs: u64,
     pub mining_key: Option<Secp256k1PrivateKey>,
-    pub self_signing_key: Option<TestSigners>,
     /// Amount of time while mining in nakamoto to wait in between mining interim blocks
     pub wait_on_interim_blocks: Duration,
     /// minimum number of transactions that must be in a block if we're going to replace a pending
@@ -2046,7 +2031,6 @@ impl Default for MinerConfig {
             candidate_retry_cache_size: 1024 * 1024,
             unprocessed_block_deadline_secs: 30,
             mining_key: None,
-            self_signing_key: None,
             wait_on_interim_blocks: Duration::from_millis(2_500),
             min_tx_count: 0,
             only_increase_tx_count: false,
@@ -2430,7 +2414,6 @@ impl MinerConfigFile {
                 .as_ref()
                 .map(|x| Secp256k1PrivateKey::from_hex(x))
                 .transpose()?,
-            self_signing_key: Some(TestSigners::default()),
             wait_on_interim_blocks: self
                 .wait_on_interim_blocks_ms
                 .map(Duration::from_millis)
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index ec57fc3ef7..d840e7f7a3 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -31,7 +31,6 @@ use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::burn::{BlockSnapshot, ConsensusHash};
 use stacks::chainstate::nakamoto::miner::{NakamotoBlockBuilder, NakamotoTenureInfo};
 use stacks::chainstate::nakamoto::signer_set::NakamotoSigners;
-use stacks::chainstate::nakamoto::test_signers::TestSigners;
 use stacks::chainstate::nakamoto::{NakamotoBlock, NakamotoBlockVote, NakamotoChainState};
 use stacks::chainstate::stacks::boot::MINERS_NAME;
 use stacks::chainstate::stacks::db::{StacksChainState, StacksHeaderInfo};
@@ -223,21 +222,14 @@ impl BlockMinerThread {
                         warn!("Failed to propose block to stackerdb: {e:?}");
                     }
                 }
+                self.globals.counters.bump_naka_proposed_blocks();
 
-                if let Some(self_signer) = self.config.self_signing() {
-                    if let Err(e) = self.self_sign_and_broadcast(self_signer, new_block.clone()) {
-                        warn!("Error self-signing block: {e:?}");
-                    } else {
-                        self.globals.coord().announce_new_stacks_block();
-                    }
+                if let Err(e) =
+                    self.wait_for_signer_signature_and_broadcast(&stackerdbs, new_block.clone())
+                {
+                    warn!("Error broadcasting block: {e:?}");
                 } else {
-                    if let Err(e) =
-                        self.wait_for_signer_signature_and_broadcast(&stackerdbs, new_block.clone())
-                    {
-                        warn!("Error broadcasting block: {e:?}");
-                    } else {
-                        self.globals.coord().announce_new_stacks_block();
-                    }
+                    self.globals.coord().announce_new_stacks_block();
                 }
 
                 self.globals.counters.bump_naka_mined_blocks();
@@ -548,54 +540,6 @@ impl BlockMinerThread {
         Ok(())
     }
 
-    fn self_sign_and_broadcast(
-        &self,
-        mut signer: TestSigners,
-        mut block: NakamotoBlock,
-    ) -> Result<(), ChainstateError> {
-        let mut chain_state = neon_node::open_chainstate_with_faults(&self.config)
-            .expect("FATAL: could not open chainstate DB");
-        let chainstate_config = chain_state.config();
-        let sort_db = SortitionDB::open(
-            &self.config.get_burn_db_file_path(),
-            true,
-            self.burnchain.pox_constants.clone(),
-        )
-        .expect("FATAL: could not open sortition DB");
-
-        let burn_height = self.burn_block.block_height;
-        let cycle = self
-            .burnchain
-            .block_height_to_reward_cycle(burn_height)
-            .expect("FATAL: no reward cycle for burn block");
-        signer.sign_nakamoto_block(&mut block, cycle);
-
-        let mut sortition_handle = sort_db.index_handle_at_tip();
-        let aggregate_public_key = if block.header.chain_length <= 1 {
-            signer.aggregate_public_key.clone()
-        } else {
-            let aggregate_public_key = NakamotoChainState::get_aggregate_public_key(
-                &mut chain_state,
-                &sort_db,
-                &sortition_handle,
-                &block,
-            )?;
-            aggregate_public_key
-        };
-
-        let (headers_conn, staging_tx) = chain_state.headers_conn_and_staging_tx_begin()?;
-        NakamotoChainState::accept_block(
-            &chainstate_config,
-            block,
-            &mut sortition_handle,
-            &staging_tx,
-            headers_conn,
-            &aggregate_public_key,
-        )?;
-        staging_tx.commit()?;
-        Ok(())
-    }
-
     /// Get the coinbase recipient address, if set in the config and if allowed in this epoch
     fn get_coinbase_recipient(&self, epoch_id: StacksEpochId) -> Option<PrincipalData> {
         if epoch_id < StacksEpochId::Epoch21 && self.config.miner.block_reward_recipient.is_some() {
diff --git a/testnet/stacks-node/src/run_loop/neon.rs b/testnet/stacks-node/src/run_loop/neon.rs
index 3f5c04f4c2..86235ec3bd 100644
--- a/testnet/stacks-node/src/run_loop/neon.rs
+++ b/testnet/stacks-node/src/run_loop/neon.rs
@@ -17,8 +17,7 @@ use stacks::chainstate::coordinator::{
     static_get_heaviest_affirmation_map, static_get_stacks_tip_affirmation_map, ChainsCoordinator,
     ChainsCoordinatorConfig, CoordinatorCommunication, Error as coord_error,
 };
-use stacks::chainstate::nakamoto::NakamotoChainState;
-use stacks::chainstate::stacks::db::{ChainStateBootData, ClarityTx, StacksChainState};
+use stacks::chainstate::stacks::db::{ChainStateBootData, StacksChainState};
 use stacks::chainstate::stacks::miner::{signal_mining_blocked, signal_mining_ready, MinerStatus};
 use stacks::core::StacksEpochId;
 use stacks::net::atlas::{AtlasConfig, AtlasDB, Attachment};
@@ -26,7 +25,7 @@ use stacks::util_lib::db::Error as db_error;
 use stacks_common::deps_common::ctrlc as termination;
 use stacks_common::deps_common::ctrlc::SignalId;
 use stacks_common::types::PublicKey;
-use stacks_common::util::hash::{to_hex, Hash160};
+use stacks_common::util::hash::Hash160;
 use stacks_common::util::{get_epoch_time_secs, sleep_ms};
 use stx_genesis::GenesisData;
 
@@ -47,10 +46,12 @@ use crate::{
 pub const STDERR: i32 = 2;
 
 #[cfg(test)]
-pub type RunLoopCounter = Arc<AtomicU64>;
+#[derive(Clone)]
+pub struct RunLoopCounter(pub Arc<AtomicU64>);
 
 #[cfg(not(test))]
-pub type RunLoopCounter = ();
+#[derive(Clone)]
+pub struct RunLoopCounter();
 
 #[cfg(test)]
 const UNCONDITIONAL_CHAIN_LIVENESS_CHECK: u64 = 30;
@@ -58,7 +59,27 @@ const UNCONDITIONAL_CHAIN_LIVENESS_CHECK: u64 = 30;
 #[cfg(not(test))]
 const UNCONDITIONAL_CHAIN_LIVENESS_CHECK: u64 = 300;
 
-#[derive(Clone)]
+impl Default for RunLoopCounter {
+    #[cfg(test)]
+    fn default() -> Self {
+        RunLoopCounter(Arc::new(AtomicU64::new(0)))
+    }
+    #[cfg(not(test))]
+    fn default() -> Self {
+        Self()
+    }
+}
+
+#[cfg(test)]
+impl std::ops::Deref for RunLoopCounter {
+    type Target = Arc<AtomicU64>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+#[derive(Clone, Default)]
 pub struct Counters {
     pub blocks_processed: RunLoopCounter,
     pub microblocks_processed: RunLoopCounter,
@@ -69,43 +90,18 @@ pub struct Counters {
     pub naka_submitted_vrfs: RunLoopCounter,
     pub naka_submitted_commits: RunLoopCounter,
     pub naka_mined_blocks: RunLoopCounter,
+    pub naka_proposed_blocks: RunLoopCounter,
     pub naka_mined_tenures: RunLoopCounter,
 }
 
 impl Counters {
-    #[cfg(test)]
-    pub fn new() -> Counters {
-        Counters {
-            blocks_processed: RunLoopCounter::new(AtomicU64::new(0)),
-            microblocks_processed: RunLoopCounter::new(AtomicU64::new(0)),
-            missed_tenures: RunLoopCounter::new(AtomicU64::new(0)),
-            missed_microblock_tenures: RunLoopCounter::new(AtomicU64::new(0)),
-            cancelled_commits: RunLoopCounter::new(AtomicU64::new(0)),
-            naka_submitted_vrfs: RunLoopCounter::new(AtomicU64::new(0)),
-            naka_submitted_commits: RunLoopCounter::new(AtomicU64::new(0)),
-            naka_mined_blocks: RunLoopCounter::new(AtomicU64::new(0)),
-            naka_mined_tenures: RunLoopCounter::new(AtomicU64::new(0)),
-        }
-    }
-
-    #[cfg(not(test))]
-    pub fn new() -> Counters {
-        Counters {
-            blocks_processed: (),
-            microblocks_processed: (),
-            missed_tenures: (),
-            missed_microblock_tenures: (),
-            cancelled_commits: (),
-            naka_submitted_vrfs: (),
-            naka_submitted_commits: (),
-            naka_mined_blocks: (),
-            naka_mined_tenures: (),
-        }
+    pub fn new() -> Self {
+        Self::default()
     }
 
     #[cfg(test)]
     fn inc(ctr: &RunLoopCounter) {
-        ctr.fetch_add(1, Ordering::SeqCst);
+        ctr.0.fetch_add(1, Ordering::SeqCst);
     }
 
     #[cfg(not(test))]
@@ -113,7 +109,7 @@ impl Counters {
 
     #[cfg(test)]
     fn set(ctr: &RunLoopCounter, value: u64) {
-        ctr.store(value, Ordering::SeqCst);
+        ctr.0.store(value, Ordering::SeqCst);
     }
 
     #[cfg(not(test))]
@@ -151,6 +147,10 @@ impl Counters {
         Counters::inc(&self.naka_mined_blocks);
     }
 
+    pub fn bump_naka_proposed_blocks(&self) {
+        Counters::inc(&self.naka_proposed_blocks);
+    }
+
     pub fn bump_naka_mined_tenures(&self) {
         Counters::inc(&self.naka_mined_tenures);
     }
@@ -217,7 +217,7 @@ impl RunLoop {
             globals: None,
             coordinator_channels: Some(channels),
             callbacks: RunLoopCallbacks::new(),
-            counters: Counters::new(),
+            counters: Counters::default(),
             should_keep_running,
             event_dispatcher,
             pox_watchdog: None,
@@ -481,23 +481,10 @@ impl RunLoop {
             .map(|e| (e.address.clone(), e.amount))
             .collect();
 
-        // TODO: delete this once aggregate public key voting is working
-        let agg_pubkey_boot_callback = if let Some(self_signer) = self.config.self_signing() {
-            let agg_pub_key = self_signer.aggregate_public_key.clone();
-            info!("Neon node setting agg public key"; "agg_pub_key" => %to_hex(&agg_pub_key.compress().data));
-            let callback = Box::new(move |clarity_tx: &mut ClarityTx| {
-                NakamotoChainState::aggregate_public_key_bootcode(clarity_tx, &agg_pub_key)
-            }) as Box<dyn FnOnce(&mut ClarityTx)>;
-            Some(callback)
-        } else {
-            debug!("Neon node booting with no aggregate public key. Must have signers available to sign blocks.");
-            None
-        };
-
         // instantiate chainstate
         let mut boot_data = ChainStateBootData {
             initial_balances,
-            post_flight_callback: agg_pubkey_boot_callback,
+            post_flight_callback: None,
             first_burnchain_block_hash: burnchain_config.first_block_hash,
             first_burnchain_block_height: burnchain_config.first_block_height as u32,
             first_burnchain_block_timestamp: burnchain_config.first_block_timestamp,
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index e97aefd42a..3fd999a603 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -13,20 +13,23 @@
 //
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
+use std::collections::{HashMap, HashSet};
 use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::{Arc, Mutex};
+use std::thread::JoinHandle;
 use std::time::{Duration, Instant};
 use std::{env, thread};
 
 use clarity::vm::ast::ASTRules;
 use clarity::vm::costs::ExecutionCost;
-use clarity::vm::types::PrincipalData;
+use clarity::vm::types::{PrincipalData, QualifiedContractIdentifier};
 use lazy_static::lazy_static;
-use libsigner::{SignerSession, StackerDBSession};
+use libsigner::{BlockResponse, SignerMessage, SignerSession, StackerDBSession};
 use stacks::burnchains::MagicBytes;
 use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::coordinator::comm::CoordinatorChannels;
 use stacks::chainstate::nakamoto::miner::NakamotoBlockBuilder;
+use stacks::chainstate::nakamoto::signer_set::NakamotoSigners;
 use stacks::chainstate::nakamoto::test_signers::TestSigners;
 use stacks::chainstate::nakamoto::{NakamotoBlock, NakamotoChainState};
 use stacks::chainstate::stacks::address::PoxAddress;
@@ -40,6 +43,7 @@ use stacks::core::{
     PEER_VERSION_EPOCH_2_1, PEER_VERSION_EPOCH_2_2, PEER_VERSION_EPOCH_2_3, PEER_VERSION_EPOCH_2_4,
     PEER_VERSION_EPOCH_2_5, PEER_VERSION_EPOCH_3_0,
 };
+use stacks::libstackerdb::{SlotMetadata, StackerDBChunkData};
 use stacks::net::api::callreadonly::CallReadOnlyRequestBody;
 use stacks::net::api::getstackers::GetStackersResponse;
 use stacks::net::api::postblock_proposal::{
@@ -55,8 +59,8 @@ use stacks_common::consts::{CHAIN_ID_TESTNET, STACKS_EPOCH_MAX};
 use stacks_common::types::chainstate::{
     BlockHeaderHash, StacksAddress, StacksPrivateKey, StacksPublicKey,
 };
-use stacks_common::util::hash::to_hex;
-use stacks_common::util::secp256k1::{MessageSignature, Secp256k1PrivateKey};
+use stacks_common::util::hash::{to_hex, Sha512Trunc256Sum};
+use stacks_common::util::secp256k1::{MessageSignature, Secp256k1PrivateKey, Secp256k1PublicKey};
 
 use super::bitcoin_regtest::BitcoinCoreController;
 use crate::config::{EventKeyType, EventObserverConfig, InitialBalance};
@@ -154,6 +158,32 @@ pub fn get_stacker_set(http_origin: &str, cycle: u64) -> GetStackersResponse {
     res
 }
 
+pub fn get_stackerdb_slot_version(
+    http_origin: &str,
+    contract: &QualifiedContractIdentifier,
+    slot_id: u64,
+) -> Option<u32> {
+    let client = reqwest::blocking::Client::new();
+    let path = format!(
+        "{http_origin}/v2/stackerdb/{}/{}",
+        &contract.issuer, &contract.name
+    );
+    let res = client
+        .get(&path)
+        .send()
+        .unwrap()
+        .json::<Vec<SlotMetadata>>()
+        .unwrap();
+    debug!("StackerDB metadata response: {res:?}");
+    res.iter().find_map(|slot| {
+        if u64::from(slot.slot_id) == slot_id {
+            Some(slot.slot_version)
+        } else {
+            None
+        }
+    })
+}
+
 pub fn add_initial_balances(
     conf: &mut Config,
     accounts: usize,
@@ -171,6 +201,120 @@ pub fn add_initial_balances(
         .collect()
 }
 
+/// Spawn a blind signing thread. `signer` is the private key
+///  of the individual signer who broadcasts the response to the StackerDB
+pub fn blind_signer(
+    conf: &Config,
+    signers: &TestSigners,
+    signer: &Secp256k1PrivateKey,
+    proposals_count: RunLoopCounter,
+) -> JoinHandle<()> {
+    let mut signed_blocks = HashSet::new();
+    let conf = conf.clone();
+    let signers = signers.clone();
+    let signer = signer.clone();
+    let mut last_count = proposals_count.load(Ordering::SeqCst);
+    thread::spawn(move || loop {
+        thread::sleep(Duration::from_millis(100));
+        let cur_count = proposals_count.load(Ordering::SeqCst);
+        if cur_count <= last_count {
+            continue;
+        }
+        last_count = cur_count;
+        match read_and_sign_block_proposal(&conf, &signers, &signer, &signed_blocks) {
+            Ok(signed_block) => {
+                if signed_blocks.contains(&signed_block) {
+                    continue;
+                }
+                info!("Signed block"; "signer_sig_hash" => signed_block.to_hex());
+                signed_blocks.insert(signed_block);
+            }
+            Err(e) => {
+                warn!("Error reading and signing block proposal: {e}");
+            }
+        }
+    })
+}
+
+pub fn read_and_sign_block_proposal(
+    conf: &Config,
+    signers: &TestSigners,
+    signer: &Secp256k1PrivateKey,
+    signed_blocks: &HashSet<Sha512Trunc256Sum>,
+) -> Result<Sha512Trunc256Sum, String> {
+    let burnchain = conf.get_burnchain();
+    let sortdb = burnchain.open_sortition_db(true).unwrap();
+    let tip = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn()).unwrap();
+    let miner_pubkey = StacksPublicKey::from_private(&conf.get_miner_config().mining_key.unwrap());
+    let miner_slot_id = NakamotoChainState::get_miner_slot(&sortdb, &tip, &miner_pubkey)
+        .map_err(|_| "Unable to get miner slot")?
+        .ok_or("No miner slot exists")?;
+    let reward_cycle = burnchain
+        .block_height_to_reward_cycle(tip.block_height)
+        .unwrap();
+    let rpc_sock = conf
+        .node
+        .rpc_bind
+        .clone()
+        .parse()
+        .expect("Failed to parse socket");
+
+    let mut proposed_block: NakamotoBlock = {
+        let miner_contract_id = boot_code_id(MINERS_NAME, false);
+        let mut miners_stackerdb = StackerDBSession::new(rpc_sock, miner_contract_id);
+        miners_stackerdb
+            .get_latest(miner_slot_id)
+            .map_err(|_| "Failed to get latest chunk from the miner slot ID")?
+            .ok_or("No chunk found")?
+    };
+    let proposed_block_hash = format!("0x{}", proposed_block.header.block_hash());
+    let signer_sig_hash = proposed_block.header.signer_signature_hash();
+    if signed_blocks.contains(&signer_sig_hash) {
+        // already signed off on this block, don't sign again.
+        return Ok(signer_sig_hash);
+    }
+
+    info!(
+        "Fetched proposed block from .miners StackerDB";
+        "proposed_block_hash" => &proposed_block_hash,
+        "signer_sig_hash" => &signer_sig_hash.to_hex(),
+    );
+
+    signers
+        .clone()
+        .sign_nakamoto_block(&mut proposed_block, reward_cycle);
+
+    let signer_message = SignerMessage::BlockResponse(BlockResponse::Accepted((
+        signer_sig_hash.clone(),
+        proposed_block.header.signer_signature.clone(),
+    )));
+
+    let signers_contract_id =
+        NakamotoSigners::make_signers_db_contract_id(reward_cycle, libsigner::BLOCK_MSG_ID, false);
+
+    let http_origin = format!("http://{}", &conf.node.rpc_bind);
+    let signers_info = get_stacker_set(&http_origin, reward_cycle);
+    let signer_index = get_signer_index(&signers_info, &Secp256k1PublicKey::from_private(signer))
+        .unwrap()
+        .try_into()
+        .unwrap();
+
+    let next_version = get_stackerdb_slot_version(&http_origin, &signers_contract_id, signer_index)
+        .map(|x| x + 1)
+        .unwrap_or(0);
+    let mut signers_contract_sess = StackerDBSession::new(rpc_sock, signers_contract_id);
+    let mut chunk_to_put = StackerDBChunkData::new(
+        u32::try_from(signer_index).unwrap(),
+        next_version,
+        signer_message.serialize_to_vec(),
+    );
+    chunk_to_put.sign(signer).unwrap();
+    signers_contract_sess
+        .put_chunk(&chunk_to_put)
+        .map_err(|e| e.to_string())?;
+    Ok(signer_sig_hash)
+}
+
 /// Return a working nakamoto-neon config and the miner's bitcoin address to fund
 pub fn naka_neon_integration_conf(seed: Option<&[u8]>) -> (Config, StacksAddress) {
     let mut conf = super::new_test_conf();
@@ -189,7 +333,6 @@ pub fn naka_neon_integration_conf(seed: Option<&[u8]>) -> (Config, StacksAddress
 
     let mining_key = Secp256k1PrivateKey::from_seed(&[1]);
     conf.miner.mining_key = Some(mining_key);
-    conf.miner.self_signing_key = Some(TestSigners::default());
 
     conf.node.miner = true;
     conf.node.wait_time_for_microblocks = 500;
@@ -355,9 +498,10 @@ pub fn setup_stacker(naka_conf: &mut Config) -> Secp256k1PrivateKey {
 ///   for pox-4 to activate
 pub fn boot_to_epoch_3(
     naka_conf: &Config,
-    blocks_processed: &RunLoopCounter,
+    blocks_processed: &Arc<AtomicU64>,
     stacker_sks: &[StacksPrivateKey],
     signer_sks: &[StacksPrivateKey],
+    self_signing: Option<&TestSigners>,
     btc_regtest_controller: &mut BitcoinRegtestController,
 ) {
     assert_eq!(stacker_sks.len(), signer_sks.len());
@@ -439,25 +583,29 @@ pub fn boot_to_epoch_3(
         &naka_conf,
     );
 
-    // If we are self-signing, then we need to vote on the aggregate public key
-    if let Some(mut signers) = naka_conf.self_signing() {
+    // We need to vote on the aggregate public key if this test is self signing
+    if let Some(signers) = self_signing {
         // Get the aggregate key
-        let aggregate_key = signers.generate_aggregate_key(reward_cycle + 1);
+        let aggregate_key = signers.clone().generate_aggregate_key(reward_cycle + 1);
         let aggregate_public_key =
             clarity::vm::Value::buff_from(aggregate_key.compress().data.to_vec())
                 .expect("Failed to serialize aggregate public key");
-
+        let signer_sks_unique: HashMap<_, _> = signer_sks.iter().map(|x| (x.to_hex(), x)).collect();
+        let signer_set = get_stacker_set(&http_origin, reward_cycle + 1);
         // Vote on the aggregate public key
-        for (i, signer_sk) in signer_sks.iter().enumerate() {
+        for signer_sk in signer_sks_unique.values() {
+            let signer_index =
+                get_signer_index(&signer_set, &Secp256k1PublicKey::from_private(signer_sk))
+                    .unwrap();
             let voting_tx = tests::make_contract_call(
-                &signer_sk,
+                signer_sk,
                 0,
                 300,
                 &StacksAddress::burn_address(false),
                 SIGNERS_VOTING_NAME,
                 "vote-for-aggregate-public-key",
                 &[
-                    clarity::vm::Value::UInt(i as u128),
+                    clarity::vm::Value::UInt(u128::try_from(signer_index).unwrap()),
                     aggregate_public_key.clone(),
                     clarity::vm::Value::UInt(0),
                     clarity::vm::Value::UInt(reward_cycle as u128 + 1),
@@ -477,6 +625,32 @@ pub fn boot_to_epoch_3(
     info!("Bootstrapped to Epoch-3.0 boundary, Epoch2x miner should stop");
 }
 
+fn get_signer_index(
+    stacker_set: &GetStackersResponse,
+    signer_key: &Secp256k1PublicKey,
+) -> Result<usize, String> {
+    let Some(ref signer_set) = stacker_set.stacker_set.signers else {
+        return Err("Empty signer set for reward cycle".into());
+    };
+    let signer_key_bytes = signer_key.to_bytes_compressed();
+    signer_set
+        .iter()
+        .enumerate()
+        .find_map(|(ix, entry)| {
+            if entry.signing_key.as_slice() == signer_key_bytes.as_slice() {
+                Some(ix)
+            } else {
+                None
+            }
+        })
+        .ok_or_else(|| {
+            format!(
+                "Signing key not found. {} not found.",
+                to_hex(&signer_key_bytes)
+            )
+        })
+}
+
 fn is_key_set_for_cycle(
     reward_cycle: u64,
     is_mainnet: bool,
@@ -517,63 +691,62 @@ fn signer_vote_if_needed(
     btc_regtest_controller: &BitcoinRegtestController,
     naka_conf: &Config,
     signer_sks: &[StacksPrivateKey], // TODO: Is there some way to get this from the TestSigners?
+    signers: &TestSigners,
 ) {
-    if let Some(mut signers) = naka_conf.self_signing() {
-        // When we reach the next prepare phase, submit new voting transactions
-        let block_height = btc_regtest_controller.get_headers_height();
-        let reward_cycle = btc_regtest_controller
-            .get_burnchain()
-            .block_height_to_reward_cycle(block_height)
-            .unwrap();
-        let prepare_phase_start = btc_regtest_controller
-            .get_burnchain()
-            .pox_constants
-            .prepare_phase_start(
-                btc_regtest_controller.get_burnchain().first_block_height,
-                reward_cycle,
-            );
+    // When we reach the next prepare phase, submit new voting transactions
+    let block_height = btc_regtest_controller.get_headers_height();
+    let reward_cycle = btc_regtest_controller
+        .get_burnchain()
+        .block_height_to_reward_cycle(block_height)
+        .unwrap();
+    let prepare_phase_start = btc_regtest_controller
+        .get_burnchain()
+        .pox_constants
+        .prepare_phase_start(
+            btc_regtest_controller.get_burnchain().first_block_height,
+            reward_cycle,
+        );
 
-        if block_height >= prepare_phase_start {
-            // If the key is already set, do nothing.
-            if is_key_set_for_cycle(
-                reward_cycle + 1,
-                naka_conf.is_mainnet(),
-                &naka_conf.node.rpc_bind,
-            )
-            .unwrap_or(false)
-            {
-                return;
-            }
+    if block_height >= prepare_phase_start {
+        // If the key is already set, do nothing.
+        if is_key_set_for_cycle(
+            reward_cycle + 1,
+            naka_conf.is_mainnet(),
+            &naka_conf.node.rpc_bind,
+        )
+        .unwrap_or(false)
+        {
+            return;
+        }
 
-            // If we are self-signing, then we need to vote on the aggregate public key
-            let http_origin = format!("http://{}", &naka_conf.node.rpc_bind);
-
-            // Get the aggregate key
-            let aggregate_key = signers.generate_aggregate_key(reward_cycle + 1);
-            let aggregate_public_key =
-                clarity::vm::Value::buff_from(aggregate_key.compress().data.to_vec())
-                    .expect("Failed to serialize aggregate public key");
-
-            for (i, signer_sk) in signer_sks.iter().enumerate() {
-                let signer_nonce = get_account(&http_origin, &to_addr(signer_sk)).nonce;
-
-                // Vote on the aggregate public key
-                let voting_tx = tests::make_contract_call(
-                    &signer_sk,
-                    signer_nonce,
-                    300,
-                    &StacksAddress::burn_address(false),
-                    SIGNERS_VOTING_NAME,
-                    "vote-for-aggregate-public-key",
-                    &[
-                        clarity::vm::Value::UInt(i as u128),
-                        aggregate_public_key.clone(),
-                        clarity::vm::Value::UInt(0),
-                        clarity::vm::Value::UInt(reward_cycle as u128 + 1),
-                    ],
-                );
-                submit_tx(&http_origin, &voting_tx);
-            }
+        // If we are self-signing, then we need to vote on the aggregate public key
+        let http_origin = format!("http://{}", &naka_conf.node.rpc_bind);
+
+        // Get the aggregate key
+        let aggregate_key = signers.clone().generate_aggregate_key(reward_cycle + 1);
+        let aggregate_public_key =
+            clarity::vm::Value::buff_from(aggregate_key.compress().data.to_vec())
+                .expect("Failed to serialize aggregate public key");
+
+        for (i, signer_sk) in signer_sks.iter().enumerate() {
+            let signer_nonce = get_account(&http_origin, &to_addr(signer_sk)).nonce;
+
+            // Vote on the aggregate public key
+            let voting_tx = tests::make_contract_call(
+                &signer_sk,
+                signer_nonce,
+                300,
+                &StacksAddress::burn_address(false),
+                SIGNERS_VOTING_NAME,
+                "vote-for-aggregate-public-key",
+                &[
+                    clarity::vm::Value::UInt(i as u128),
+                    aggregate_public_key.clone(),
+                    clarity::vm::Value::UInt(0),
+                    clarity::vm::Value::UInt(reward_cycle as u128 + 1),
+                ],
+            );
+            submit_tx(&http_origin, &voting_tx);
         }
     }
 }
@@ -584,7 +757,7 @@ fn signer_vote_if_needed(
 /// * `signer_pks` - must be the same size as `stacker_sks`
 pub fn boot_to_epoch_3_reward_set(
     naka_conf: &Config,
-    blocks_processed: &RunLoopCounter,
+    blocks_processed: &Arc<AtomicU64>,
     stacker_sks: &[StacksPrivateKey],
     signer_sks: &[StacksPrivateKey],
     btc_regtest_controller: &mut BitcoinRegtestController,
@@ -692,6 +865,7 @@ fn simple_neon_integration() {
         return;
     }
 
+    let signers = TestSigners::default();
     let (mut naka_conf, _miner_account) = naka_neon_integration_conf(None);
     let prom_bind = format!("{}:{}", "127.0.0.1", 6000);
     naka_conf.node.prometheus_bind = Some(prom_bind.clone());
@@ -734,6 +908,7 @@ fn simple_neon_integration() {
         blocks_processed,
         naka_submitted_vrfs: vrfs_submitted,
         naka_submitted_commits: commits_submitted,
+        naka_proposed_blocks: proposals_submitted,
         ..
     } = run_loop.counters();
 
@@ -746,6 +921,7 @@ fn simple_neon_integration() {
         &blocks_processed,
         &[stacker_sk],
         &[sender_signer_sk],
+        Some(&signers),
         &mut btc_regtest_controller,
     );
 
@@ -783,6 +959,8 @@ fn simple_neon_integration() {
     }
 
     info!("Nakamoto miner started...");
+    blind_signer(&naka_conf, &signers, &sender_signer_sk, proposals_submitted);
+
     // first block wakes up the run loop, wait until a key registration has been submitted.
     next_block_and(&mut btc_regtest_controller, 60, || {
         let vrf_count = vrfs_submitted.load(Ordering::SeqCst);
@@ -807,7 +985,12 @@ fn simple_neon_integration() {
         )
         .unwrap();
 
-        signer_vote_if_needed(&btc_regtest_controller, &naka_conf, &[sender_signer_sk]);
+        signer_vote_if_needed(
+            &btc_regtest_controller,
+            &naka_conf,
+            &[sender_signer_sk],
+            &signers,
+        );
     }
 
     // Submit a TX
@@ -844,7 +1027,12 @@ fn simple_neon_integration() {
         )
         .unwrap();
 
-        signer_vote_if_needed(&btc_regtest_controller, &naka_conf, &[sender_signer_sk]);
+        signer_vote_if_needed(
+            &btc_regtest_controller,
+            &naka_conf,
+            &[sender_signer_sk],
+            &signers,
+        );
     }
 
     // load the chain tip, and assert that it is a nakamoto block and at least 30 blocks have advanced in epoch 3
@@ -916,6 +1104,7 @@ fn mine_multiple_per_tenure_integration() {
         return;
     }
 
+    let signers = TestSigners::default();
     let (mut naka_conf, _miner_account) = naka_neon_integration_conf(None);
     let http_origin = format!("http://{}", &naka_conf.node.rpc_bind);
     naka_conf.miner.wait_on_interim_blocks = Duration::from_secs(1);
@@ -960,6 +1149,7 @@ fn mine_multiple_per_tenure_integration() {
         blocks_processed,
         naka_submitted_vrfs: vrfs_submitted,
         naka_submitted_commits: commits_submitted,
+        naka_proposed_blocks: proposals_submitted,
         ..
     } = run_loop.counters();
 
@@ -975,6 +1165,7 @@ fn mine_multiple_per_tenure_integration() {
         &blocks_processed,
         &[stacker_sk],
         &[sender_signer_sk],
+        Some(&signers),
         &mut btc_regtest_controller,
     );
 
@@ -997,6 +1188,8 @@ fn mine_multiple_per_tenure_integration() {
             .stacks_block_height;
 
     info!("Nakamoto miner started...");
+    blind_signer(&naka_conf, &signers, &sender_signer_sk, proposals_submitted);
+
     // first block wakes up the run loop, wait until a key registration has been submitted.
     next_block_and(&mut btc_regtest_controller, 60, || {
         let vrf_count = vrfs_submitted.load(Ordering::SeqCst);
@@ -1093,6 +1286,7 @@ fn correct_burn_outs() {
         return;
     }
 
+    let signers = TestSigners::default();
     let (mut naka_conf, _miner_account) = naka_neon_integration_conf(None);
     naka_conf.burnchain.pox_reward_length = Some(10);
     naka_conf.burnchain.pox_prepare_length = Some(3);
@@ -1149,6 +1343,7 @@ fn correct_burn_outs() {
         blocks_processed,
         naka_submitted_vrfs: vrfs_submitted,
         naka_submitted_commits: commits_submitted,
+        naka_proposed_blocks: proposals_submitted,
         ..
     } = run_loop.counters();
 
@@ -1280,7 +1475,12 @@ fn correct_burn_outs() {
         &naka_conf,
     );
 
-    signer_vote_if_needed(&btc_regtest_controller, &naka_conf, &[sender_signer_sk]);
+    signer_vote_if_needed(
+        &btc_regtest_controller,
+        &naka_conf,
+        &[sender_signer_sk],
+        &signers,
+    );
 
     run_until_burnchain_height(
         &mut btc_regtest_controller,
@@ -1290,6 +1490,7 @@ fn correct_burn_outs() {
     );
 
     info!("Bootstrapped to Epoch-3.0 boundary, Epoch2x miner should stop");
+    blind_signer(&naka_conf, &signers, &sender_signer_sk, proposals_submitted);
 
     // we should already be able to query the stacker set via RPC
     let burnchain = naka_conf.get_burnchain();
@@ -1351,7 +1552,12 @@ fn correct_burn_outs() {
             "The new burnchain tip must have been processed"
         );
 
-        signer_vote_if_needed(&btc_regtest_controller, &naka_conf, &[sender_signer_sk]);
+        signer_vote_if_needed(
+            &btc_regtest_controller,
+            &naka_conf,
+            &[sender_signer_sk],
+            &signers,
+        );
     }
 
     coord_channel
@@ -1399,6 +1605,7 @@ fn block_proposal_api_endpoint() {
         return;
     }
 
+    let signers = TestSigners::default();
     let (mut conf, _miner_account) = naka_neon_integration_conf(None);
     let account_keys = add_initial_balances(&mut conf, 10, 1_000_000);
     let stacker_sk = setup_stacker(&mut conf);
@@ -1430,6 +1637,7 @@ fn block_proposal_api_endpoint() {
         blocks_processed,
         naka_submitted_vrfs: vrfs_submitted,
         naka_submitted_commits: commits_submitted,
+        naka_proposed_blocks: proposals_submitted,
         ..
     } = run_loop.counters();
 
@@ -1442,10 +1650,12 @@ fn block_proposal_api_endpoint() {
         &blocks_processed,
         &[stacker_sk],
         &[sender_signer_sk],
+        Some(&signers),
         &mut btc_regtest_controller,
     );
 
     info!("Bootstrapped to Epoch-3.0 boundary, starting nakamoto miner");
+    blind_signer(&conf, &signers, &sender_signer_sk, proposals_submitted);
 
     let burnchain = conf.get_burnchain();
     let sortdb = burnchain.open_sortition_db(true).unwrap();
@@ -1493,9 +1703,6 @@ fn block_proposal_api_endpoint() {
     // TODO (hack) instantiate the sortdb in the burnchain
     _ = btc_regtest_controller.sortdb_mut();
 
-    // Set up test signer
-    let signer = conf.miner.self_signing_key.as_mut().unwrap();
-
     // ----- Setup boilerplate finished, test block proposal API endpoint -----
 
     let tip = NakamotoChainState::get_canonical_block_header(chainstate.db(), &sortdb)
@@ -1524,19 +1731,13 @@ fn block_proposal_api_endpoint() {
         _ => None,
     });
 
-    // Apply both miner/stacker signatures
-    let mut sign = |mut p: NakamotoBlockProposal| {
+    // Apply miner signature
+    let sign = |p: &NakamotoBlockProposal| {
+        let mut p = p.clone();
         p.block
             .header
             .sign_miner(&privk)
             .expect("Miner failed to sign");
-        let burn_height = burnchain
-            .get_highest_burnchain_block()
-            .unwrap()
-            .unwrap()
-            .block_height;
-        let cycle = burnchain.block_height_to_reward_cycle(burn_height).unwrap();
-        signer.sign_nakamoto_block(&mut p.block, cycle);
         p
     };
 
@@ -1594,15 +1795,15 @@ fn block_proposal_api_endpoint() {
     let test_cases = [
         (
             "Valid Nakamoto block proposal",
-            sign(proposal.clone()),
+            sign(&proposal),
             HTTP_ACCEPTED,
             Some(Ok(())),
         ),
-        ("Must wait", sign(proposal.clone()), HTTP_TOO_MANY, None),
+        ("Must wait", sign(&proposal), HTTP_TOO_MANY, None),
         (
             "Corrupted (bit flipped after signing)",
             (|| {
-                let mut sp = sign(proposal.clone());
+                let mut sp = sign(&proposal);
                 sp.block.header.consensus_hash.0[3] ^= 0x07;
                 sp
             })(),
@@ -1614,7 +1815,7 @@ fn block_proposal_api_endpoint() {
             (|| {
                 let mut p = proposal.clone();
                 p.chain_id ^= 0xFFFFFFFF;
-                sign(p)
+                sign(&p)
             })(),
             HTTP_ACCEPTED,
             Some(Err(ValidateRejectCode::InvalidBlock)),
@@ -1622,7 +1823,7 @@ fn block_proposal_api_endpoint() {
         (
             "Invalid `miner_signature`",
             (|| {
-                let mut sp = sign(proposal.clone());
+                let mut sp = sign(&proposal);
                 sp.block.header.miner_signature.0[1] ^= 0x80;
                 sp
             })(),
@@ -1746,6 +1947,7 @@ fn miner_writes_proposed_block_to_stackerdb() {
         return;
     }
 
+    let signers = TestSigners::default();
     let (mut naka_conf, _miner_account) = naka_neon_integration_conf(None);
     naka_conf.miner.wait_on_interim_blocks = Duration::from_secs(1000);
     let sender_sk = Secp256k1PrivateKey::new();
@@ -1786,6 +1988,7 @@ fn miner_writes_proposed_block_to_stackerdb() {
         blocks_processed,
         naka_submitted_vrfs: vrfs_submitted,
         naka_submitted_commits: commits_submitted,
+        naka_proposed_blocks: proposals_submitted,
         ..
     } = run_loop.counters();
 
@@ -1798,10 +2001,12 @@ fn miner_writes_proposed_block_to_stackerdb() {
         &blocks_processed,
         &[stacker_sk],
         &[sender_signer_sk],
+        Some(&signers),
         &mut btc_regtest_controller,
     );
 
     info!("Nakamoto miner started...");
+    blind_signer(&naka_conf, &signers, &sender_signer_sk, proposals_submitted);
     // first block wakes up the run loop, wait until a key registration has been submitted.
     next_block_and(&mut btc_regtest_controller, 60, || {
         let vrf_count = vrfs_submitted.load(Ordering::SeqCst);
@@ -1840,20 +2045,14 @@ fn miner_writes_proposed_block_to_stackerdb() {
         .expect("Unable to get miner slot")
         .expect("No miner slot exists");
 
-    let chunk = std::thread::spawn(move || {
+    let proposed_block: NakamotoBlock = {
         let miner_contract_id = boot_code_id(MINERS_NAME, false);
         let mut miners_stackerdb = StackerDBSession::new(rpc_sock, miner_contract_id);
         miners_stackerdb
-            .get_latest_chunk(slot_id)
+            .get_latest(slot_id)
             .expect("Failed to get latest chunk from the miner slot ID")
             .expect("No chunk found")
-    })
-    .join()
-    .expect("Failed to join chunk handle");
-
-    // We should now successfully deserialize a chunk
-    let proposed_block = NakamotoBlock::consensus_deserialize(&mut &chunk[..])
-        .expect("Failed to deserialize chunk into block");
+    };
     let proposed_block_hash = format!("0x{}", proposed_block.header.block_hash());
 
     let mut proposed_zero_block = proposed_block.clone();
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index d903f58c43..f16b4347d6 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -92,7 +92,6 @@ impl SignerTest {
             .collect::<Vec<StacksPrivateKey>>();
 
         let (mut naka_conf, _miner_account) = naka_neon_integration_conf(None);
-        naka_conf.miner.self_signing_key = None;
 
         // Setup the signer and coordinator configurations
         let signer_configs = build_signer_config_tomls(
@@ -715,9 +714,9 @@ fn setup_stx_btc_node(
         btc_regtest_controller,
         run_loop_thread,
         run_loop_stopper,
-        vrfs_submitted,
-        commits_submitted,
-        blocks_processed,
+        vrfs_submitted: vrfs_submitted.0,
+        commits_submitted: commits_submitted.0,
+        blocks_processed: blocks_processed.0,
         coord_channel,
         conf: naka_conf,
     }

From a0174b8de1ade41a12d977a441265217168a463c Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Fri, 23 Feb 2024 13:44:08 -0600
Subject: [PATCH 0989/1166] chore: remove mockamoto mode

---
 testnet/stacks-node/src/config.rs          |  122 +--
 testnet/stacks-node/src/main.rs            |    9 -
 testnet/stacks-node/src/mockamoto.rs       | 1111 --------------------
 testnet/stacks-node/src/mockamoto/tests.rs |  414 --------
 4 files changed, 3 insertions(+), 1653 deletions(-)
 delete mode 100644 testnet/stacks-node/src/mockamoto.rs
 delete mode 100644 testnet/stacks-node/src/mockamoto/tests.rs

diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index d33ecf0c17..cc39fb1e52 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -32,7 +32,6 @@ use stacks::net::connection::ConnectionOptions;
 use stacks::net::{Neighbor, NeighborKey};
 use stacks::util_lib::boot::boot_code_id;
 use stacks::util_lib::db::Error as DBError;
-use stacks_common::address::{AddressHashMode, C32_ADDRESS_VERSION_TESTNET_SINGLESIG};
 use stacks_common::consts::SIGNER_SLOTS_PER_USER;
 use stacks_common::types::chainstate::StacksAddress;
 use stacks_common::types::net::PeerAddress;
@@ -274,102 +273,6 @@ impl ConfigFile {
         }
     }
 
-    pub fn mockamoto() -> ConfigFile {
-        let epochs = vec![
-            StacksEpochConfigFile {
-                epoch_name: "1.0".into(),
-                start_height: 0,
-            },
-            StacksEpochConfigFile {
-                epoch_name: "2.0".into(),
-                start_height: 0,
-            },
-            StacksEpochConfigFile {
-                epoch_name: "2.05".into(),
-                start_height: 1,
-            },
-            StacksEpochConfigFile {
-                epoch_name: "2.1".into(),
-                start_height: 2,
-            },
-            StacksEpochConfigFile {
-                epoch_name: "2.2".into(),
-                start_height: 3,
-            },
-            StacksEpochConfigFile {
-                epoch_name: "2.3".into(),
-                start_height: 4,
-            },
-            StacksEpochConfigFile {
-                epoch_name: "2.4".into(),
-                start_height: 5,
-            },
-            StacksEpochConfigFile {
-                epoch_name: "2.5".into(),
-                start_height: 6,
-            },
-            StacksEpochConfigFile {
-                epoch_name: "3.0".into(),
-                start_height: 7,
-            },
-        ];
-
-        let burnchain = BurnchainConfigFile {
-            mode: Some("mockamoto".into()),
-            rpc_port: Some(8332),
-            peer_port: Some(8333),
-            peer_host: Some("localhost".into()),
-            username: Some("blockstack".into()),
-            password: Some("blockstacksystem".into()),
-            magic_bytes: Some("M3".into()),
-            epochs: Some(epochs),
-            pox_prepare_length: Some(3),
-            pox_reward_length: Some(36),
-            ..BurnchainConfigFile::default()
-        };
-
-        let node = NodeConfigFile {
-            bootstrap_node: None,
-            miner: Some(true),
-            stacker: Some(true),
-            ..NodeConfigFile::default()
-        };
-
-        let mining_key = Secp256k1PrivateKey::new();
-        let miner = MinerConfigFile {
-            mining_key: Some(mining_key.to_hex()),
-            ..MinerConfigFile::default()
-        };
-
-        let mock_private_key = Secp256k1PrivateKey::from_seed(&[0]);
-        let mock_public_key = Secp256k1PublicKey::from_private(&mock_private_key);
-        let mock_address = StacksAddress::from_public_keys(
-            C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
-            &AddressHashMode::SerializeP2PKH,
-            1,
-            &vec![mock_public_key],
-        )
-        .unwrap();
-
-        info!(
-            "Mockamoto starting. Initial balance set to mock_private_key = {}",
-            mock_private_key.to_hex()
-        );
-
-        let ustx_balance = vec![InitialBalanceFile {
-            address: mock_address.to_string(),
-            amount: 1_000_000_000_000,
-        }];
-
-        ConfigFile {
-            burnchain: Some(burnchain),
-            node: Some(node),
-            miner: Some(miner),
-            ustx_balance: Some(ustx_balance),
-            ..ConfigFile::default()
-        }
-    }
-
     pub fn helium() -> ConfigFile {
         // ## Settings for local testnet, relying on a local bitcoind server
         // ## running with the following bitcoin.conf:
@@ -630,7 +533,7 @@ impl Config {
         }
 
         // check if the Epoch 3.0 burnchain settings as configured are going to be valid.
-        if self.burnchain.mode == "nakamoto-neon" || self.burnchain.mode == "mockamoto" {
+        if self.burnchain.mode == "nakamoto-neon" {
             self.check_nakamoto_config(&burnchain);
         }
     }
@@ -862,15 +765,7 @@ impl Config {
     }
 
     pub fn from_config_file(config_file: ConfigFile) -> Result<Config, String> {
-        if config_file.burnchain.as_ref().map(|b| b.mode.clone()) == Some(Some("mockamoto".into()))
-        {
-            // in the case of mockamoto, use `ConfigFile::mockamoto()` as the default for
-            //  processing a user-supplied config
-            let default = Self::from_config_default(ConfigFile::mockamoto(), Config::default())?;
-            Self::from_config_default(config_file, default)
-        } else {
-            Self::from_config_default(config_file, Config::default())
-        }
+        Self::from_config_default(config_file, Config::default())
     }
 
     fn from_config_default(config_file: ConfigFile, default: Config) -> Result<Config, String> {
@@ -896,7 +791,6 @@ impl Config {
             "krypton",
             "xenon",
             "mainnet",
-            "mockamoto",
             "nakamoto-neon",
         ];
 
@@ -1335,7 +1229,7 @@ impl BurnchainConfig {
         match self.mode.as_str() {
             "mainnet" => ("mainnet".to_string(), BitcoinNetworkType::Mainnet),
             "xenon" => ("testnet".to_string(), BitcoinNetworkType::Testnet),
-            "helium" | "neon" | "argon" | "krypton" | "mocknet" | "mockamoto" | "nakamoto-neon" => {
+            "helium" | "neon" | "argon" | "krypton" | "mocknet" | "nakamoto-neon" => {
                 ("regtest".to_string(), BitcoinNetworkType::Regtest)
             }
             other => panic!("Invalid stacks-node mode: {other}"),
@@ -1566,9 +1460,6 @@ pub struct NodeConfig {
     pub chain_liveness_poll_time_secs: u64,
     /// stacker DBs we replicate
     pub stacker_dbs: Vec<QualifiedContractIdentifier>,
-    /// if running in mockamoto mode, how long to wait between each
-    /// simulated bitcoin block
-    pub mockamoto_time_ms: u64,
 }
 
 #[derive(Clone, Debug)]
@@ -1849,7 +1740,6 @@ impl Default for NodeConfig {
             fault_injection_hide_blocks: false,
             chain_liveness_poll_time_secs: 300,
             stacker_dbs: vec![],
-            mockamoto_time_ms: 3_000,
         }
     }
 }
@@ -2250,9 +2140,6 @@ pub struct NodeConfigFile {
     pub chain_liveness_poll_time_secs: Option<u64>,
     /// Stacker DBs we replicate
     pub stacker_dbs: Option<Vec<String>>,
-    /// if running in mockamoto mode, how long to wait between each
-    /// simulated bitcoin block
-    pub mockamoto_time_ms: Option<u64>,
 }
 
 impl NodeConfigFile {
@@ -2328,9 +2215,6 @@ impl NodeConfigFile {
                 .iter()
                 .filter_map(|contract_id| QualifiedContractIdentifier::parse(contract_id).ok())
                 .collect(),
-            mockamoto_time_ms: self
-                .mockamoto_time_ms
-                .unwrap_or(default_node_config.mockamoto_time_ms),
         };
         Ok(node_config)
     }
diff --git a/testnet/stacks-node/src/main.rs b/testnet/stacks-node/src/main.rs
index 95a1dda4b8..bf54c1601d 100644
--- a/testnet/stacks-node/src/main.rs
+++ b/testnet/stacks-node/src/main.rs
@@ -22,7 +22,6 @@ pub mod event_dispatcher;
 pub mod genesis_data;
 pub mod globals;
 pub mod keychain;
-pub mod mockamoto;
 pub mod nakamoto_node;
 pub mod neon_node;
 pub mod node;
@@ -55,7 +54,6 @@ pub use self::node::{ChainTip, Node};
 pub use self::run_loop::{helium, neon};
 pub use self::tenure::Tenure;
 use crate::chain_data::MinerStats;
-use crate::mockamoto::MockamotoNode;
 use crate::neon_node::{BlockMinerThread, TipCandidate};
 use crate::run_loop::boot_nakamoto;
 
@@ -322,10 +320,6 @@ fn main() {
             args.finish();
             ConfigFile::mainnet()
         }
-        "mockamoto" => {
-            args.finish();
-            ConfigFile::mockamoto()
-        }
         "check-config" => {
             let config_path: String = args.value_from_str("--config").unwrap();
             args.finish();
@@ -449,9 +443,6 @@ fn main() {
     {
         let mut run_loop = neon::RunLoop::new(conf);
         run_loop.start(None, mine_start.unwrap_or(0));
-    } else if conf.burnchain.mode == "mockamoto" {
-        let mut mockamoto = MockamotoNode::new(&conf).unwrap();
-        mockamoto.run();
     } else if conf.burnchain.mode == "nakamoto-neon" {
         let mut run_loop = boot_nakamoto::BootRunLoop::new(conf).unwrap();
         run_loop.start(None, 0);
diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
deleted file mode 100644
index 2629f4f9b2..0000000000
--- a/testnet/stacks-node/src/mockamoto.rs
+++ /dev/null
@@ -1,1111 +0,0 @@
-// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
-// Copyright (C) 2020-2023 Stacks Open Internet Foundation
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-use std::sync::atomic::AtomicBool;
-use std::sync::mpsc::{sync_channel, Receiver, RecvTimeoutError};
-use std::sync::{Arc, Mutex};
-use std::thread;
-use std::thread::{sleep, JoinHandle};
-use std::time::Duration;
-
-use clarity::vm::ast::ASTRules;
-use clarity::vm::Value as ClarityValue;
-use lazy_static::lazy_static;
-use stacks::burnchains::bitcoin::address::{
-    BitcoinAddress, LegacyBitcoinAddress, LegacyBitcoinAddressType,
-};
-use stacks::burnchains::bitcoin::{
-    BitcoinBlock, BitcoinInputType, BitcoinNetworkType, BitcoinTransaction,
-    BitcoinTxInputStructured, BitcoinTxOutput,
-};
-use stacks::burnchains::db::{BurnchainDB, BurnchainHeaderReader};
-use stacks::burnchains::{
-    BurnchainBlock, BurnchainBlockHeader, BurnchainSigner, Error as BurnchainError, Txid,
-};
-use stacks::chainstate::burn::db::sortdb::SortitionDB;
-use stacks::chainstate::burn::operations::leader_block_commit::BURN_BLOCK_MINED_AT_MODULUS;
-use stacks::chainstate::burn::operations::{
-    BlockstackOperationType, LeaderBlockCommitOp, LeaderKeyRegisterOp,
-};
-use stacks::chainstate::burn::BlockSnapshot;
-use stacks::chainstate::coordinator::comm::CoordinatorReceivers;
-use stacks::chainstate::coordinator::{
-    ChainsCoordinator, ChainsCoordinatorConfig, CoordinatorCommunication,
-};
-use stacks::chainstate::nakamoto::test_signers::TestSigners;
-use stacks::chainstate::nakamoto::{
-    NakamotoBlock, NakamotoBlockHeader, NakamotoChainState, SetupBlockResult,
-};
-use stacks::chainstate::stacks::address::PoxAddress;
-use stacks::chainstate::stacks::boot::SIGNERS_VOTING_NAME;
-use stacks::chainstate::stacks::db::{ChainStateBootData, ClarityTx, StacksChainState};
-use stacks::chainstate::stacks::miner::{
-    BlockBuilder, BlockBuilderSettings, BlockLimitFunction, MinerStatus, TransactionResult,
-};
-use stacks::chainstate::stacks::{
-    CoinbasePayload, Error as ChainstateError, StacksBlockBuilder, StacksTransaction,
-    StacksTransactionSigner, TenureChangeCause, TenureChangePayload, ThresholdSignature,
-    TransactionAuth, TransactionContractCall, TransactionPayload, TransactionVersion,
-    MAX_EPOCH_SIZE, MINER_BLOCK_CONSENSUS_HASH, MINER_BLOCK_HEADER_HASH,
-};
-use stacks::core::mempool::MemPoolWalkSettings;
-use stacks::core::{
-    MemPoolDB, StacksEpoch, BLOCK_LIMIT_MAINNET_10, HELIUM_BLOCK_LIMIT_20, PEER_VERSION_EPOCH_1_0,
-    PEER_VERSION_EPOCH_2_0, PEER_VERSION_EPOCH_2_05, PEER_VERSION_EPOCH_2_1,
-    PEER_VERSION_EPOCH_2_2, PEER_VERSION_EPOCH_2_3, PEER_VERSION_EPOCH_2_4, PEER_VERSION_EPOCH_2_5,
-    PEER_VERSION_EPOCH_3_0, STACKS_EPOCH_3_0_MARKER, TX_BLOCK_LIMIT_PROPORTION_HEURISTIC,
-};
-use stacks::net::atlas::{AtlasConfig, AtlasDB};
-use stacks::net::relay::Relayer;
-use stacks::net::stackerdb::StackerDBs;
-use stacks::util_lib::boot::boot_code_addr;
-use stacks::util_lib::db::Error as DBError;
-use stacks::util_lib::signed_structured_data::pox4::{
-    make_pox_4_signer_key_signature, Pox4SignatureTopic,
-};
-use stacks_common::address::{AddressHashMode, C32_ADDRESS_VERSION_TESTNET_SINGLESIG};
-use stacks_common::bitvec::BitVec;
-use stacks_common::codec::StacksMessageCodec;
-use stacks_common::consts::{
-    CHAIN_ID_TESTNET, FIRST_BURNCHAIN_CONSENSUS_HASH, FIRST_STACKS_BLOCK_HASH, STACKS_EPOCH_MAX,
-};
-use stacks_common::types::chainstate::{
-    BlockHeaderHash, BurnchainHeaderHash, ConsensusHash, StacksAddress, StacksBlockId,
-    StacksPrivateKey, VRFSeed,
-};
-use stacks_common::types::{PrivateKey, StacksEpochId};
-use stacks_common::util::hash::{to_hex, Hash160, MerkleTree, Sha512Trunc256Sum};
-use stacks_common::util::secp256k1::{MessageSignature, Secp256k1PrivateKey, Secp256k1PublicKey};
-use stacks_common::util::vrf::{VRFPrivateKey, VRFProof, VRFPublicKey, VRF};
-
-use crate::globals::{NeonGlobals as Globals, RelayerDirective};
-use crate::neon::Counters;
-use crate::neon_node::{PeerThread, StacksNode, BLOCK_PROCESSOR_STACK_SIZE};
-use crate::syncctl::PoxSyncWatchdogComms;
-use crate::{Config, EventDispatcher};
-
-#[cfg(test)]
-mod tests;
-
-lazy_static! {
-    pub static ref STACKS_EPOCHS_MOCKAMOTO: [StacksEpoch; 9] = [
-        StacksEpoch {
-            epoch_id: StacksEpochId::Epoch10,
-            start_height: 0,
-            end_height: 0,
-            block_limit: BLOCK_LIMIT_MAINNET_10.clone(),
-            network_epoch: PEER_VERSION_EPOCH_1_0
-        },
-        StacksEpoch {
-            epoch_id: StacksEpochId::Epoch20,
-            start_height: 0,
-            end_height: 1,
-            block_limit: HELIUM_BLOCK_LIMIT_20.clone(),
-            network_epoch: PEER_VERSION_EPOCH_2_0
-        },
-        StacksEpoch {
-            epoch_id: StacksEpochId::Epoch2_05,
-            start_height: 1,
-            end_height: 2,
-            block_limit: HELIUM_BLOCK_LIMIT_20.clone(),
-            network_epoch: PEER_VERSION_EPOCH_2_05
-        },
-        StacksEpoch {
-            epoch_id: StacksEpochId::Epoch21,
-            start_height: 2,
-            end_height: 3,
-            block_limit: HELIUM_BLOCK_LIMIT_20.clone(),
-            network_epoch: PEER_VERSION_EPOCH_2_1
-        },
-        StacksEpoch {
-            epoch_id: StacksEpochId::Epoch22,
-            start_height: 3,
-            end_height: 4,
-            block_limit: HELIUM_BLOCK_LIMIT_20.clone(),
-            network_epoch: PEER_VERSION_EPOCH_2_2
-        },
-        StacksEpoch {
-            epoch_id: StacksEpochId::Epoch23,
-            start_height: 4,
-            end_height: 5,
-            block_limit: HELIUM_BLOCK_LIMIT_20.clone(),
-            network_epoch: PEER_VERSION_EPOCH_2_3
-        },
-        StacksEpoch {
-            epoch_id: StacksEpochId::Epoch24,
-            start_height: 5,
-            end_height: 6,
-            block_limit: HELIUM_BLOCK_LIMIT_20.clone(),
-            network_epoch: PEER_VERSION_EPOCH_2_4
-        },
-        StacksEpoch {
-            epoch_id: StacksEpochId::Epoch25,
-            start_height: 6,
-            end_height: 7,
-            block_limit: HELIUM_BLOCK_LIMIT_20.clone(),
-            network_epoch: PEER_VERSION_EPOCH_2_5
-        },
-        StacksEpoch {
-            epoch_id: StacksEpochId::Epoch30,
-            start_height: 7,
-            end_height: STACKS_EPOCH_MAX,
-            block_limit: HELIUM_BLOCK_LIMIT_20.clone(),
-            network_epoch: PEER_VERSION_EPOCH_3_0
-        },
-    ];
-}
-
-/// Produce a mock bitcoin block that is descended from `parent_snapshot` and includes
-/// `ops`. This method uses `miner_pkh` to set the inputs and outputs of any supplied
-/// block commits or leader key registrations
-fn make_burn_block(
-    parent_snapshot: &BlockSnapshot,
-    miner_pkh: &Hash160,
-    ops: Vec<BlockstackOperationType>,
-) -> Result<BitcoinBlock, BurnchainError> {
-    let block_height = parent_snapshot.block_height + 1;
-    let mut mock_burn_hash_contents = [0u8; 32];
-    mock_burn_hash_contents[0..8].copy_from_slice((block_height + 1).to_be_bytes().as_ref());
-
-    let txs = ops.into_iter().map(|op| {
-        let mut data = match &op {
-            BlockstackOperationType::LeaderKeyRegister(op) => op.serialize_to_vec(),
-            BlockstackOperationType::LeaderBlockCommit(op) => op.serialize_to_vec(),
-            _ => panic!("Attempted to mock unexpected blockstack operation."),
-        };
-
-        data.remove(0);
-
-        let (inputs, outputs) = if let BlockstackOperationType::LeaderBlockCommit(ref op) = op {
-            let burn_output = BitcoinTxOutput {
-                units: op.burn_fee,
-                address: BitcoinAddress::Legacy(LegacyBitcoinAddress {
-                    addrtype: LegacyBitcoinAddressType::PublicKeyHash,
-                    network_id: BitcoinNetworkType::Testnet,
-                    bytes: Hash160([0; 20]),
-                }),
-            };
-
-            let change_output = BitcoinTxOutput {
-                units: 1_000_000_000_000,
-                address: BitcoinAddress::Legacy(LegacyBitcoinAddress {
-                    addrtype: LegacyBitcoinAddressType::PublicKeyHash,
-                    network_id: BitcoinNetworkType::Testnet,
-                    bytes: miner_pkh.clone(),
-                }),
-            };
-
-            let tx_ref = (parent_snapshot.winning_block_txid.clone(), 3);
-
-            let input = BitcoinTxInputStructured {
-                keys: vec![],
-                num_required: 0,
-                in_type: BitcoinInputType::Standard,
-                tx_ref,
-            };
-
-            (
-                vec![input.into()],
-                vec![burn_output.clone(), burn_output, change_output],
-            )
-        } else {
-            (
-                vec![BitcoinTxInputStructured {
-                    keys: vec![],
-                    num_required: 0,
-                    in_type: BitcoinInputType::Standard,
-                    tx_ref: (Txid([0; 32]), 0),
-                }
-                .into()],
-                vec![BitcoinTxOutput {
-                    units: 1_000_000_000_000,
-                    address: BitcoinAddress::Legacy(LegacyBitcoinAddress {
-                        addrtype: LegacyBitcoinAddressType::PublicKeyHash,
-                        network_id: BitcoinNetworkType::Testnet,
-                        bytes: miner_pkh.clone(),
-                    }),
-                }],
-            )
-        };
-
-        BitcoinTransaction {
-            txid: op.txid(),
-            vtxindex: op.vtxindex(),
-            opcode: op.opcode() as u8,
-            data,
-            data_amt: 0,
-            inputs,
-            outputs,
-        }
-    });
-
-    Ok(BitcoinBlock {
-        block_height,
-        block_hash: BurnchainHeaderHash(mock_burn_hash_contents),
-        parent_block_hash: parent_snapshot.burn_header_hash.clone(),
-        txs: txs.collect(),
-        timestamp: 100 * u64::from(block_height + 1),
-    })
-}
-
-/// This struct wraps all the state required for operating a
-/// stacks-node in `mockamoto` mode.
-///
-/// This mode of operation is a single-node network in which bitcoin
-/// blocks are simulated: no `bitcoind` is communicated with (either
-/// operating as regtest, testnet or mainnet). This operation mode
-/// is useful for testing the stacks-only operation of Nakamoto.
-///
-/// During operation, the mockamoto node issues `stack-stx` and
-/// `stack-extend` contract-calls to ensure that the miner is a member
-/// of the current stacking set. This ensures nakamoto blocks can be
-/// produced with tenure change txs.
-///
-pub struct MockamotoNode {
-    sortdb: SortitionDB,
-    mempool: MemPoolDB,
-    chainstate: StacksChainState,
-    self_signer: TestSigners,
-    miner_key: StacksPrivateKey,
-    vrf_key: VRFPrivateKey,
-    relay_rcv: Option<Receiver<RelayerDirective>>,
-    coord_rcv: Option<CoordinatorReceivers>,
-    dispatcher: EventDispatcher,
-    pub globals: Globals,
-    config: Config,
-}
-
-struct MockamotoBlockBuilder {
-    txs: Vec<StacksTransaction>,
-    bytes_so_far: u64,
-}
-
-/// This struct is used by mockamoto to pass the burnchain indexer
-///  parameter to the `ChainsCoordinator`. It errors on every
-///  invocation except `read_burnchain_headers`.
-///
-/// The `ChainsCoordinator` only uses this indexer for evaluating
-///  affirmation maps, which should never be evaluated in mockamoto.
-/// This is passed to the Burnchain DB block processor, though, which
-///  requires `read_burnchain_headers` (to generate affirmation maps)
-struct MockBurnchainIndexer(BurnchainDB);
-
-impl BurnchainHeaderReader for MockBurnchainIndexer {
-    fn read_burnchain_headers(
-        &self,
-        start_height: u64,
-        end_height: u64,
-    ) -> Result<Vec<BurnchainBlockHeader>, DBError> {
-        let mut output = vec![];
-        for i in start_height..end_height {
-            let header = BurnchainDB::get_burnchain_header(self.0.conn(), i)
-                .map_err(|e| DBError::Other(e.to_string()))?
-                .ok_or_else(|| DBError::NotFoundError)?;
-            output.push(header);
-        }
-        Ok(output)
-    }
-    fn get_burnchain_headers_height(&self) -> Result<u64, DBError> {
-        Err(DBError::NoDBError)
-    }
-    fn find_burnchain_header_height(
-        &self,
-        _header_hash: &BurnchainHeaderHash,
-    ) -> Result<Option<u64>, DBError> {
-        Err(DBError::NoDBError)
-    }
-}
-
-impl BlockBuilder for MockamotoBlockBuilder {
-    fn try_mine_tx_with_len(
-        &mut self,
-        clarity_tx: &mut ClarityTx,
-        tx: &StacksTransaction,
-        tx_len: u64,
-        limit_behavior: &BlockLimitFunction,
-        ast_rules: ASTRules,
-    ) -> TransactionResult {
-        if self.bytes_so_far + tx_len >= MAX_EPOCH_SIZE.into() {
-            return TransactionResult::skipped(tx, "BlockSizeLimit".into());
-        }
-
-        if BlockLimitFunction::NO_LIMIT_HIT != *limit_behavior {
-            return TransactionResult::skipped(tx, "LimitReached".into());
-        }
-
-        let (fee, receipt) = match StacksChainState::process_transaction(
-            clarity_tx, tx, true, ast_rules,
-        ) {
-            Ok(x) => x,
-            Err(ChainstateError::CostOverflowError(cost_before, cost_after, total_budget)) => {
-                clarity_tx.reset_cost(cost_before.clone());
-                if total_budget.proportion_largest_dimension(&cost_before)
-                    < TX_BLOCK_LIMIT_PROPORTION_HEURISTIC
-                {
-                    warn!(
-                        "Transaction {} consumed over {}% of block budget, marking as invalid; budget was {}",
-                        tx.txid(),
-                        100 - TX_BLOCK_LIMIT_PROPORTION_HEURISTIC,
-                        &total_budget
-                    );
-                    return TransactionResult::error(&tx, ChainstateError::TransactionTooBigError);
-                } else {
-                    warn!(
-                        "Transaction {} reached block cost {}; budget was {}",
-                        tx.txid(),
-                        &cost_after,
-                        &total_budget
-                    );
-                    return TransactionResult::skipped_due_to_error(
-                        &tx,
-                        ChainstateError::BlockTooBigError,
-                    );
-                }
-            }
-            Err(e) => return TransactionResult::error(&tx, e),
-        };
-
-        info!("Include tx";
-              "tx" => %tx.txid(),
-              "payload" => tx.payload.name(),
-              "origin" => %tx.origin_address());
-
-        self.txs.push(tx.clone());
-        self.bytes_so_far += tx_len;
-
-        TransactionResult::success(tx, fee, receipt)
-    }
-}
-
-impl MockamotoNode {
-    pub fn new(config: &Config) -> Result<MockamotoNode, String> {
-        let miner_key = config
-            .miner
-            .mining_key
-            .clone()
-            .ok_or("Mockamoto node must be configured with `miner.mining_key`")?;
-        let vrf_key = VRFPrivateKey::new();
-
-        let stacker_pk = Secp256k1PublicKey::from_private(&miner_key);
-        let stacker_pk_hash = Hash160::from_node_public_key(&stacker_pk);
-
-        let stacker = StacksAddress {
-            version: C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
-            bytes: stacker_pk_hash,
-        };
-
-        let burnchain = config.get_burnchain();
-        let (sortdb, _burndb) = burnchain
-            .connect_db(
-                true,
-                BurnchainHeaderHash([0; 32]),
-                100,
-                STACKS_EPOCHS_MOCKAMOTO.to_vec(),
-            )
-            .map_err(|e| e.to_string())?;
-
-        let mut initial_balances: Vec<_> = config
-            .initial_balances
-            .iter()
-            .map(|balance| (balance.address.clone(), balance.amount))
-            .collect();
-
-        initial_balances.push((stacker.into(), 100_000_000_000_000));
-
-        // Create a boot contract to initialize the aggregate public key prior to Pox-4 activation
-        let self_signer = TestSigners::default();
-        let agg_pub_key = self_signer.aggregate_public_key.clone();
-        info!("Mockamoto node setting agg public key"; "agg_pub_key" => %to_hex(&self_signer.aggregate_public_key.compress().data));
-        let callback = move |clarity_tx: &mut ClarityTx| {
-            NakamotoChainState::aggregate_public_key_bootcode(clarity_tx, &agg_pub_key);
-        };
-        let mut boot_data =
-            ChainStateBootData::new(&burnchain, initial_balances, Some(Box::new(callback)));
-        let (chainstate, boot_receipts) = StacksChainState::open_and_exec(
-            config.is_mainnet(),
-            config.burnchain.chain_id,
-            &config.get_chainstate_path_str(),
-            Some(&mut boot_data),
-            Some(config.node.get_marf_opts()),
-        )
-        .unwrap();
-        let mempool = PeerThread::connect_mempool_db(config);
-
-        let (coord_rcv, coord_comms) = CoordinatorCommunication::instantiate();
-        let miner_status = Arc::new(Mutex::new(MinerStatus::make_ready(100)));
-        let (relay_send, relay_rcv) = sync_channel(10);
-        let counters = Counters::new();
-        let should_keep_running = Arc::new(AtomicBool::new(true));
-        let sync_comms = PoxSyncWatchdogComms::new(should_keep_running.clone());
-
-        let globals = Globals::new(
-            coord_comms,
-            miner_status,
-            relay_send,
-            counters,
-            sync_comms,
-            should_keep_running,
-            0,
-        );
-
-        let mut event_dispatcher = EventDispatcher::new();
-        for observer in config.events_observers.iter() {
-            event_dispatcher.register_observer(observer);
-        }
-
-        crate::run_loop::announce_boot_receipts(
-            &mut event_dispatcher,
-            &chainstate,
-            &burnchain.pox_constants,
-            &boot_receipts,
-        );
-
-        Ok(MockamotoNode {
-            sortdb,
-            self_signer,
-            chainstate,
-            miner_key,
-            vrf_key,
-            relay_rcv: Some(relay_rcv),
-            coord_rcv: Some(coord_rcv),
-            dispatcher: event_dispatcher,
-            mempool,
-            globals,
-            config: config.clone(),
-        })
-    }
-
-    fn spawn_chains_coordinator(&mut self) -> JoinHandle<()> {
-        let config = self.config.clone();
-        let atlas_config = AtlasConfig::new(false);
-
-        let (chainstate, _) = self.chainstate.reopen().unwrap();
-        let coord_config = ChainsCoordinatorConfig {
-            always_use_affirmation_maps: false,
-            require_affirmed_anchor_blocks: false,
-            ..ChainsCoordinatorConfig::new()
-        };
-        let mut dispatcher = self.dispatcher.clone();
-        let burnchain = self.config.get_burnchain();
-        let burndb = burnchain.open_burnchain_db(true).unwrap();
-        let coordinator_indexer = MockBurnchainIndexer(burndb);
-        let atlas_db = AtlasDB::connect(
-            atlas_config.clone(),
-            &self.config.get_atlas_db_file_path(),
-            true,
-        )
-        .unwrap();
-        let miner_status = Arc::new(Mutex::new(MinerStatus::make_ready(100)));
-        let coordinator_receivers = self.coord_rcv.take().unwrap();
-
-        thread::Builder::new()
-            .name(format!("chains-coordinator-{}", &config.node.rpc_bind))
-            .stack_size(BLOCK_PROCESSOR_STACK_SIZE)
-            .spawn(move || {
-                debug!(
-                    "chains-coordinator thread ID is {:?}",
-                    thread::current().id()
-                );
-                ChainsCoordinator::run(
-                    coord_config,
-                    chainstate,
-                    burnchain,
-                    &mut dispatcher,
-                    coordinator_receivers,
-                    atlas_config,
-                    Some(&mut ()),
-                    Some(&mut ()),
-                    miner_status,
-                    coordinator_indexer,
-                    atlas_db,
-                );
-            })
-            .expect("FATAL: failed to start chains coordinator thread")
-    }
-
-    pub fn run(&mut self) {
-        info!("Starting the mockamoto node by issuing initial empty mock burn blocks");
-        let coordinator = self.spawn_chains_coordinator();
-
-        self.produce_burnchain_block(true).unwrap();
-        self.produce_burnchain_block(true).unwrap();
-        self.produce_burnchain_block(true).unwrap();
-        self.produce_burnchain_block(true).unwrap();
-        self.produce_burnchain_block(true).unwrap();
-        self.produce_burnchain_block(true).unwrap();
-
-        let mut p2p_net = StacksNode::setup_peer_network(
-            &self.config,
-            &self.config.atlas,
-            self.config.get_burnchain(),
-        );
-
-        let stackerdbs = StackerDBs::connect(&self.config.get_stacker_db_file_path(), true)
-            .expect("FATAL: failed to connect to stacker DB");
-
-        let _relayer = Relayer::from_p2p(&mut p2p_net, stackerdbs);
-
-        let relayer_rcv = self.relay_rcv.take().unwrap();
-        let relayer_globals = self.globals.clone();
-        let mock_relayer_thread = thread::Builder::new()
-            .name("mock-relayer".into())
-            .spawn(move || {
-                while relayer_globals.keep_running() {
-                    match relayer_rcv.recv_timeout(Duration::from_millis(500)) {
-                        Ok(dir) => {
-                            if let RelayerDirective::Exit = dir {
-                                break;
-                            }
-                        }
-                        Err(RecvTimeoutError::Timeout) => continue,
-                        Err(e) => {
-                            warn!("Error accepting relayer directive: {e:?}");
-                            break;
-                        }
-                    }
-                }
-            })
-            .expect("FATAL: failed to start mock relayer thread");
-
-        let peer_thread = PeerThread::new_all(
-            self.globals.clone(),
-            &self.config,
-            self.config.get_burnchain().pox_constants,
-            p2p_net,
-        );
-
-        let ev_dispatcher = self.dispatcher.clone();
-        let peer_thread = thread::Builder::new()
-            .stack_size(BLOCK_PROCESSOR_STACK_SIZE)
-            .name("p2p".into())
-            .spawn(move || {
-                StacksNode::p2p_main(peer_thread, ev_dispatcher);
-            })
-            .expect("FATAL: failed to start p2p thread");
-
-        while self.globals.keep_running() {
-            self.produce_burnchain_block(false).unwrap();
-            let expected_chain_length = self.mine_and_stage_block().unwrap();
-            self.globals.coord().announce_new_stacks_block();
-            let _ = self.wait_for_stacks_block(expected_chain_length);
-            sleep(Duration::from_millis(self.config.node.mockamoto_time_ms));
-        }
-
-        self.globals.coord().stop_chains_coordinator();
-
-        if let Err(e) = coordinator.join() {
-            warn!("Error joining coordinator thread during shutdown: {e:?}");
-        }
-        if let Err(e) = mock_relayer_thread.join() {
-            warn!("Error joining coordinator thread during shutdown: {e:?}");
-        }
-        if let Err(e) = peer_thread.join() {
-            warn!("Error joining p2p thread during shutdown: {e:?}");
-        }
-    }
-
-    #[cfg_attr(test, mutants::skip)]
-    fn wait_for_stacks_block(&mut self, expected_length: u64) -> Result<(), ChainstateError> {
-        while self.globals.keep_running() {
-            let chain_length = match NakamotoChainState::get_canonical_block_header(
-                self.chainstate.db(),
-                &self.sortdb,
-            ) {
-                Ok(Some(chain_tip)) => chain_tip.stacks_block_height,
-                Ok(None) | Err(ChainstateError::NoSuchBlockError) => 0,
-                Err(e) => return Err(e),
-            };
-            if chain_length >= expected_length {
-                return Ok(());
-            }
-            sleep(Duration::from_millis(100));
-        }
-        Err(ChainstateError::NoSuchBlockError)
-    }
-
-    fn produce_burnchain_block(&mut self, initializing: bool) -> Result<(), BurnchainError> {
-        let miner_pk = Secp256k1PublicKey::from_private(&self.miner_key);
-        let miner_pk_hash = Hash160::from_node_public_key(&miner_pk);
-
-        let parent_snapshot = SortitionDB::get_canonical_burn_chain_tip(&self.sortdb.conn())?;
-        info!("Mocking bitcoin block"; "parent_height" => parent_snapshot.block_height);
-        let burn_height = parent_snapshot.block_height + 1;
-
-        let mut ops = vec![];
-
-        if burn_height == 1 {
-            let mut txid = [2u8; 32];
-            txid[0..8].copy_from_slice((burn_height + 1).to_be_bytes().as_ref());
-            let key_register = LeaderKeyRegisterOp {
-                consensus_hash: ConsensusHash([0; 20]),
-                public_key: VRFPublicKey::from_private(&self.vrf_key),
-                memo: miner_pk_hash.as_bytes().to_vec(),
-                txid: Txid(txid),
-                vtxindex: 0,
-                block_height: burn_height,
-                burn_header_hash: BurnchainHeaderHash([0; 32]),
-            };
-            ops.push(BlockstackOperationType::LeaderKeyRegister(key_register));
-        } else if !initializing {
-            let mut txid = [1u8; 32];
-            txid[0..8].copy_from_slice((burn_height + 1).to_be_bytes().as_ref());
-            txid[8..16].copy_from_slice((0u64).to_be_bytes().as_ref());
-
-            let (parent_block_ptr, parent_vtxindex) =
-                if parent_snapshot.winning_block_txid.as_bytes() == &[0; 32] {
-                    (0, 0)
-                } else {
-                    (parent_snapshot.block_height.try_into().unwrap(), 0)
-                };
-
-            let parent_vrf_proof = NakamotoChainState::get_block_vrf_proof(
-                self.chainstate.db(),
-                &parent_snapshot.consensus_hash,
-            )
-            .map_err(|_e| BurnchainError::MissingParentBlock)?
-            .unwrap_or_else(|| VRFProof::empty());
-
-            let vrf_seed = VRFSeed::from_proof(&parent_vrf_proof);
-            let parent_block_id = parent_snapshot.get_canonical_stacks_block_id();
-
-            let block_commit = LeaderBlockCommitOp {
-                block_header_hash: BlockHeaderHash(parent_block_id.0),
-                new_seed: vrf_seed,
-                parent_block_ptr,
-                parent_vtxindex,
-                key_block_ptr: 1,
-                key_vtxindex: 0,
-                memo: vec![STACKS_EPOCH_3_0_MARKER],
-                burn_fee: 5000,
-                input: (parent_snapshot.winning_block_txid.clone(), 3),
-                burn_parent_modulus: u8::try_from(
-                    parent_snapshot.block_height % BURN_BLOCK_MINED_AT_MODULUS,
-                )
-                .unwrap(),
-                apparent_sender: BurnchainSigner(miner_pk_hash.to_string()),
-                commit_outs: vec![
-                    PoxAddress::Standard(StacksAddress::burn_address(false), None),
-                    PoxAddress::Standard(StacksAddress::burn_address(false), None),
-                ],
-                sunset_burn: 0,
-                txid: Txid(txid),
-                vtxindex: 0,
-                block_height: burn_height,
-                burn_header_hash: BurnchainHeaderHash([0; 32]),
-            };
-            ops.push(BlockstackOperationType::LeaderBlockCommit(block_commit))
-        }
-
-        let new_burn_block = make_burn_block(&parent_snapshot, &miner_pk_hash, ops)?;
-
-        let burnchain = self.config.get_burnchain();
-        let burndb = burnchain.open_burnchain_db(true).unwrap();
-        let indexer = MockBurnchainIndexer(burndb);
-        let mut burndb = burnchain.open_burnchain_db(true).unwrap();
-
-        burndb.store_new_burnchain_block(
-            &burnchain,
-            &indexer,
-            &BurnchainBlock::Bitcoin(new_burn_block),
-            StacksEpochId::Epoch30,
-        )?;
-
-        self.globals.coord().announce_new_burn_block();
-        let mut cur_snapshot = SortitionDB::get_canonical_burn_chain_tip(&self.sortdb.conn())?;
-        while cur_snapshot.burn_header_hash == parent_snapshot.burn_header_hash {
-            thread::sleep(Duration::from_millis(100));
-            cur_snapshot = SortitionDB::get_canonical_burn_chain_tip(&self.sortdb.conn())?;
-        }
-
-        Ok(())
-    }
-
-    fn mine_stacks_block(&mut self) -> Result<NakamotoBlock, ChainstateError> {
-        let miner_principal = StacksAddress::from_public_keys(
-            C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
-            &AddressHashMode::SerializeP2PKH,
-            1,
-            &vec![Secp256k1PublicKey::from_private(&self.miner_key)],
-        )
-        .unwrap()
-        .into();
-        let sortition_tip = SortitionDB::get_canonical_burn_chain_tip(self.sortdb.conn())?;
-        let chain_id = self.chainstate.chain_id;
-        let (mut chainstate_tx, clarity_instance) = self.chainstate.chainstate_tx_begin().unwrap();
-
-        let (is_genesis, chain_tip_bh, chain_tip_ch) =
-            match NakamotoChainState::get_canonical_block_header(&chainstate_tx, &self.sortdb) {
-                Ok(Some(chain_tip)) => (
-                    false,
-                    chain_tip.anchored_header.block_hash(),
-                    chain_tip.consensus_hash,
-                ),
-                Ok(None) | Err(ChainstateError::NoSuchBlockError) =>
-                // No stacks tip yet, parent should be genesis
-                {
-                    (
-                        true,
-                        FIRST_STACKS_BLOCK_HASH,
-                        FIRST_BURNCHAIN_CONSENSUS_HASH,
-                    )
-                }
-                Err(e) => return Err(e),
-            };
-
-        let parent_block_id = StacksBlockId::new(&chain_tip_ch, &chain_tip_bh);
-
-        let (parent_chain_length, parent_burn_height) = if is_genesis {
-            (0, 0)
-        } else {
-            let tip_info = NakamotoChainState::get_block_header(&chainstate_tx, &parent_block_id)?
-                .ok_or(ChainstateError::NoSuchBlockError)?;
-            (tip_info.stacks_block_height, tip_info.burn_header_height)
-        };
-
-        let miner_nonce = if is_genesis {
-            0
-        } else {
-            let sortdb_conn = self.sortdb.index_conn();
-            let mut clarity_conn = clarity_instance.read_only_connection_checked(
-                &parent_block_id,
-                &chainstate_tx,
-                &sortdb_conn,
-            )?;
-            StacksChainState::get_nonce(&mut clarity_conn, &miner_principal)
-        };
-
-        info!(
-            "Mining block"; "parent_chain_length" => parent_chain_length, "chain_tip_bh" => %chain_tip_bh,
-            "chain_tip_ch" => %chain_tip_ch, "miner_account" => %miner_principal, "miner_nonce" => %miner_nonce,
-        );
-
-        let vrf_proof = VRF::prove(&self.vrf_key, sortition_tip.sortition_hash.as_bytes());
-        let coinbase_tx_payload =
-            TransactionPayload::Coinbase(CoinbasePayload([1; 32]), None, Some(vrf_proof));
-        let mut coinbase_tx = StacksTransaction::new(
-            TransactionVersion::Testnet,
-            TransactionAuth::from_p2pkh(&self.miner_key).unwrap(),
-            coinbase_tx_payload,
-        );
-        coinbase_tx.chain_id = chain_id;
-        coinbase_tx.set_origin_nonce(miner_nonce + 1);
-        let mut coinbase_tx_signer = StacksTransactionSigner::new(&coinbase_tx);
-        coinbase_tx_signer.sign_origin(&self.miner_key).unwrap();
-        let coinbase_tx = coinbase_tx_signer.get_tx().unwrap();
-
-        let miner_pk = Secp256k1PublicKey::from_private(&self.miner_key);
-        let miner_pk_hash = Hash160::from_node_public_key(&miner_pk);
-
-        // Add a tenure change transaction to the block:
-        //  as of now every mockamoto block is a tenure-change.
-        // If mockamoto mode changes to support non-tenure-changing blocks, this will have
-        //  to be gated.
-        let tenure_change_tx_payload = TransactionPayload::TenureChange(TenureChangePayload {
-            tenure_consensus_hash: sortition_tip.consensus_hash.clone(),
-            prev_tenure_consensus_hash: chain_tip_ch.clone(),
-            burn_view_consensus_hash: sortition_tip.consensus_hash,
-            previous_tenure_end: parent_block_id,
-            previous_tenure_blocks: 1,
-            cause: TenureChangeCause::BlockFound,
-            pubkey_hash: miner_pk_hash,
-        });
-        let mut tenure_tx = StacksTransaction::new(
-            TransactionVersion::Testnet,
-            TransactionAuth::from_p2pkh(&self.miner_key).unwrap(),
-            tenure_change_tx_payload,
-        );
-        tenure_tx.chain_id = chain_id;
-        tenure_tx.set_origin_nonce(miner_nonce);
-        let mut tenure_tx_signer = StacksTransactionSigner::new(&tenure_tx);
-        tenure_tx_signer.sign_origin(&self.miner_key).unwrap();
-        let tenure_tx = tenure_tx_signer.get_tx().unwrap();
-
-        let pox_address = PoxAddress::Standard(
-            StacksAddress::burn_address(false),
-            Some(AddressHashMode::SerializeP2PKH),
-        );
-
-        let signer_sk = Secp256k1PrivateKey::from_seed(&[1, 2, 3, 4]);
-        let signer_key = Secp256k1PublicKey::from_private(&signer_sk).to_bytes_compressed();
-        let signer_addr = StacksAddress::from_public_keys(
-            C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
-            &AddressHashMode::SerializeP2PKH,
-            1,
-            &vec![Secp256k1PublicKey::from_private(&signer_sk)],
-        )
-        .unwrap()
-        .into();
-
-        let block_height = sortition_tip.block_height;
-        let reward_cycle = self
-            .sortdb
-            .pox_constants
-            .block_height_to_reward_cycle(self.sortdb.first_block_height, block_height)
-            .unwrap();
-
-        let stack_stx_payload = if parent_chain_length < 2 {
-            let signature = make_pox_4_signer_key_signature(
-                &pox_address,
-                &signer_sk,
-                reward_cycle.into(),
-                &Pox4SignatureTopic::StackStx,
-                CHAIN_ID_TESTNET,
-                12_u128,
-            )
-            .unwrap()
-            .to_rsv();
-            TransactionPayload::ContractCall(TransactionContractCall {
-                address: StacksAddress::burn_address(false),
-                contract_name: "pox-4".try_into().unwrap(),
-                function_name: "stack-stx".try_into().unwrap(),
-                function_args: vec![
-                    ClarityValue::UInt(99_000_000_000_000),
-                    pox_address.as_clarity_tuple().unwrap().into(),
-                    ClarityValue::UInt(u128::from(parent_burn_height)),
-                    ClarityValue::UInt(12),
-                    ClarityValue::some(ClarityValue::buff_from(signature).unwrap()).unwrap(),
-                    ClarityValue::buff_from(signer_key).unwrap(),
-                ],
-            })
-        } else {
-            let signature = make_pox_4_signer_key_signature(
-                &pox_address,
-                &signer_sk,
-                reward_cycle.into(),
-                &Pox4SignatureTopic::StackExtend,
-                CHAIN_ID_TESTNET,
-                5_u128,
-            )
-            .unwrap()
-            .to_rsv();
-            // NOTE: stack-extend doesn't currently work, because the PoX-4 lockup
-            //  special functions have not been implemented.
-            TransactionPayload::ContractCall(TransactionContractCall {
-                address: StacksAddress::burn_address(false),
-                contract_name: "pox-4".try_into().unwrap(),
-                function_name: "stack-extend".try_into().unwrap(),
-                function_args: vec![
-                    ClarityValue::UInt(5),
-                    pox_address.as_clarity_tuple().unwrap().into(),
-                    ClarityValue::some(ClarityValue::buff_from(signature).unwrap()).unwrap(),
-                    ClarityValue::buff_from(signer_key).unwrap(),
-                ],
-            })
-        };
-        let mut stack_stx_tx = StacksTransaction::new(
-            TransactionVersion::Testnet,
-            TransactionAuth::from_p2pkh(&self.miner_key).unwrap(),
-            stack_stx_payload,
-        );
-        stack_stx_tx.chain_id = chain_id;
-        stack_stx_tx.set_origin_nonce(miner_nonce + 2);
-        let mut stack_stx_tx_signer = StacksTransactionSigner::new(&stack_stx_tx);
-        stack_stx_tx_signer.sign_origin(&self.miner_key).unwrap();
-        let stacks_stx_tx = stack_stx_tx_signer.get_tx().unwrap();
-
-        let signer_nonce = if is_genesis {
-            0
-        } else {
-            let sortdb_conn = self.sortdb.index_conn();
-            let mut clarity_conn = clarity_instance.read_only_connection_checked(
-                &parent_block_id,
-                &chainstate_tx,
-                &sortdb_conn,
-            )?;
-            StacksChainState::get_nonce(&mut clarity_conn, &signer_addr)
-        };
-        let mut next_signer = self.self_signer.clone();
-        let next_agg_key = next_signer.generate_aggregate_key(reward_cycle + 1);
-        let aggregate_public_key_val =
-            ClarityValue::buff_from(next_agg_key.compress().data.to_vec())
-                .expect("Failed to serialize aggregate public key");
-        let vote_payload = TransactionPayload::new_contract_call(
-            boot_code_addr(false),
-            SIGNERS_VOTING_NAME,
-            "vote-for-aggregate-public-key",
-            vec![
-                ClarityValue::UInt(0),
-                aggregate_public_key_val,
-                ClarityValue::UInt(0),
-                ClarityValue::UInt((reward_cycle + 1).into()),
-            ],
-        )
-        .unwrap();
-        let mut vote_tx = StacksTransaction::new(
-            TransactionVersion::Testnet,
-            TransactionAuth::from_p2pkh(&signer_sk).unwrap(),
-            vote_payload,
-        );
-        vote_tx.chain_id = chain_id;
-        vote_tx.set_origin_nonce(signer_nonce);
-        let mut vote_tx_signer = StacksTransactionSigner::new(&vote_tx);
-        vote_tx_signer.sign_origin(&signer_sk).unwrap();
-        let vote_tx = vote_tx_signer.get_tx().unwrap();
-
-        let sortdb_handle = self.sortdb.index_conn();
-        let SetupBlockResult {
-            mut clarity_tx,
-            matured_miner_rewards_opt,
-            ..
-        } = NakamotoChainState::setup_block(
-            &mut chainstate_tx,
-            clarity_instance,
-            &sortdb_handle,
-            self.sortdb.first_block_height,
-            &self.sortdb.pox_constants,
-            chain_tip_ch.clone(),
-            chain_tip_bh.clone(),
-            parent_chain_length,
-            parent_burn_height,
-            sortition_tip.burn_header_hash.clone(),
-            sortition_tip.block_height.try_into().map_err(|_| {
-                ChainstateError::InvalidStacksBlock("Burn block height exceeded u32".into())
-            })?,
-            true,
-            parent_chain_length + 1,
-            false,
-        )?;
-
-        let txs = vec![tenure_tx, coinbase_tx, stacks_stx_tx, vote_tx];
-
-        let _ = match StacksChainState::process_block_transactions(
-            &mut clarity_tx,
-            &txs,
-            0,
-            ASTRules::PrecheckSize,
-        ) {
-            Err(e) => {
-                let msg = format!("Mined invalid stacks block {e:?}");
-                warn!("{msg}");
-
-                clarity_tx.rollback_block();
-                return Err(ChainstateError::InvalidStacksBlock(msg));
-            }
-            Ok((block_fees, _block_burns, txs_receipts)) => (block_fees, txs_receipts),
-        };
-
-        let bytes_so_far = txs.iter().map(|tx| tx.tx_len()).sum();
-        let mut builder = MockamotoBlockBuilder { txs, bytes_so_far };
-        let _ = match StacksBlockBuilder::select_and_apply_transactions(
-            &mut clarity_tx,
-            &mut builder,
-            &mut self.mempool,
-            parent_chain_length,
-            &[],
-            BlockBuilderSettings {
-                max_miner_time_ms: 15_000,
-                mempool_settings: MemPoolWalkSettings::default(),
-                miner_status: Arc::new(Mutex::new(MinerStatus::make_ready(10000))),
-            },
-            None,
-            ASTRules::PrecheckSize,
-        ) {
-            Ok(x) => x,
-            Err(e) => {
-                let msg = format!("Mined invalid stacks block {e:?}");
-                warn!("{msg}");
-
-                clarity_tx.rollback_block();
-                return Err(ChainstateError::InvalidStacksBlock(msg));
-            }
-        };
-
-        let _lockup_events = match NakamotoChainState::finish_block(
-            &mut clarity_tx,
-            matured_miner_rewards_opt.as_ref(),
-        ) {
-            Err(ChainstateError::InvalidStacksBlock(e)) => {
-                clarity_tx.rollback_block();
-                return Err(ChainstateError::InvalidStacksBlock(e));
-            }
-            Err(e) => return Err(e),
-            Ok(lockup_events) => lockup_events,
-        };
-
-        let state_index_root = clarity_tx.seal();
-        let tx_merkle_tree: MerkleTree<Sha512Trunc256Sum> = builder.txs.iter().collect();
-        clarity_tx
-            .commit_mined_block(&StacksBlockId::new(
-                &MINER_BLOCK_CONSENSUS_HASH,
-                &MINER_BLOCK_HEADER_HASH,
-            ))
-            .unwrap();
-        chainstate_tx.commit().unwrap();
-
-        let mut block = NakamotoBlock {
-            header: NakamotoBlockHeader {
-                version: 100,
-                chain_length: parent_chain_length + 1,
-                burn_spent: sortition_tip.total_burn,
-                tx_merkle_root: tx_merkle_tree.root(),
-                state_index_root,
-                signer_signature: ThresholdSignature::empty(),
-                miner_signature: MessageSignature::empty(),
-                consensus_hash: sortition_tip.consensus_hash.clone(),
-                parent_block_id: StacksBlockId::new(&chain_tip_ch, &chain_tip_bh),
-                signer_bitvec: BitVec::zeros(1)
-                    .expect("BUG: bitvec of length-1 failed to construct"),
-            },
-            txs: builder.txs,
-        };
-
-        let miner_signature = self
-            .miner_key
-            .sign(block.header.miner_signature_hash().as_bytes())
-            .unwrap();
-
-        block.header.miner_signature = miner_signature;
-
-        Ok(block)
-    }
-
-    #[cfg_attr(test, mutants::skip)]
-    fn mine_and_stage_block(&mut self) -> Result<u64, ChainstateError> {
-        let mut block = self.mine_stacks_block()?;
-        let config = self.chainstate.config();
-        let chain_length = block.header.chain_length;
-        let mut sortition_handle = self.sortdb.index_handle_at_tip();
-        let burn_tip = SortitionDB::get_canonical_burn_chain_tip(&self.sortdb.conn())?;
-        let cycle = self
-            .sortdb
-            .pox_constants
-            .block_height_to_reward_cycle(self.sortdb.first_block_height, burn_tip.block_height)
-            .unwrap();
-        self.self_signer.sign_nakamoto_block(&mut block, cycle);
-
-        let aggregate_public_key = if chain_length <= 1 {
-            self.self_signer.aggregate_public_key
-        } else {
-            let aggregate_public_key = NakamotoChainState::get_aggregate_public_key(
-                &mut self.chainstate,
-                &self.sortdb,
-                &sortition_handle,
-                &block,
-            )?;
-            aggregate_public_key
-        };
-        let (headers_conn, staging_tx) = self.chainstate.headers_conn_and_staging_tx_begin()?;
-        NakamotoChainState::accept_block(
-            &config,
-            block,
-            &mut sortition_handle,
-            &staging_tx,
-            headers_conn,
-            &aggregate_public_key,
-        )?;
-        staging_tx.commit()?;
-        Ok(chain_length)
-    }
-}
diff --git a/testnet/stacks-node/src/mockamoto/tests.rs b/testnet/stacks-node/src/mockamoto/tests.rs
deleted file mode 100644
index cbbed76071..0000000000
--- a/testnet/stacks-node/src/mockamoto/tests.rs
+++ /dev/null
@@ -1,414 +0,0 @@
-use std::thread;
-use std::time::{Duration, Instant};
-
-use clarity::vm::costs::ExecutionCost;
-use stacks::chainstate::burn::db::sortdb::SortitionDB;
-use stacks::chainstate::nakamoto::NakamotoChainState;
-use stacks::chainstate::stacks::db::StacksChainState;
-use stacks_common::types::chainstate::{StacksAddress, StacksPrivateKey};
-use stacks_common::types::net::PeerAddress;
-use stacks_common::types::StacksEpochId;
-use stacks_common::util::get_epoch_time_secs;
-use stacks_common::util::hash::to_hex;
-
-use super::MockamotoNode;
-use crate::config::{EventKeyType, EventObserverConfig};
-use crate::neon_node::PeerThread;
-use crate::tests::neon_integrations::{get_pox_info, submit_tx, test_observer};
-use crate::tests::{make_stacks_transfer, to_addr};
-use crate::{Config, ConfigFile};
-
-#[test]
-fn observe_100_blocks() {
-    let mut conf = Config::from_config_file(ConfigFile::mockamoto()).unwrap();
-    conf.node.working_dir = format!(
-        "/tmp/stacks-node-tests/mock_observe_100_blocks-{}",
-        get_epoch_time_secs()
-    );
-    conf.node.rpc_bind = "127.0.0.1:19343".into();
-    conf.node.p2p_bind = "127.0.0.1:19344".into();
-    conf.connection_options.public_ip_address = Some((PeerAddress::from_ipv4(127, 0, 0, 1), 20443));
-    conf.node.mockamoto_time_ms = 10;
-
-    let submitter_sk = StacksPrivateKey::from_seed(&[1]);
-    let submitter_addr = to_addr(&submitter_sk);
-    conf.add_initial_balance(submitter_addr.to_string(), 1_000_000);
-    let recipient_addr = StacksAddress::burn_address(false).into();
-
-    let observer_port = 19300;
-    test_observer::spawn_at(observer_port);
-    conf.events_observers.insert(EventObserverConfig {
-        endpoint: format!("localhost:{observer_port}"),
-        events_keys: vec![EventKeyType::AnyEvent],
-    });
-
-    let mut mockamoto = MockamotoNode::new(&conf).unwrap();
-    let globals = mockamoto.globals.clone();
-
-    let mut mempool = PeerThread::connect_mempool_db(&conf);
-    let (mut chainstate, _) = StacksChainState::open(
-        conf.is_mainnet(),
-        conf.burnchain.chain_id,
-        &conf.get_chainstate_path_str(),
-        None,
-    )
-    .unwrap();
-    let burnchain = conf.get_burnchain();
-    let sortdb = burnchain.open_sortition_db(true).unwrap();
-
-    let start = Instant::now();
-
-    let node_thread = thread::Builder::new()
-        .name("mockamoto-main".into())
-        .spawn(move || mockamoto.run())
-        .expect("FATAL: failed to start mockamoto main thread");
-
-    // make a transfer tx to test that the mockamoto miner picks up txs from the mempool
-    let tx_fee = 200;
-    let transfer_tx = make_stacks_transfer(&submitter_sk, 0, tx_fee, &recipient_addr, 100);
-    let transfer_tx_hex = format!("0x{}", to_hex(&transfer_tx));
-
-    let mut sent_tx = false;
-
-    // complete within 2 minutes or abort
-    let completed = loop {
-        if Instant::now().duration_since(start) > Duration::from_secs(120) {
-            break false;
-        }
-        let latest_block = test_observer::get_blocks().pop();
-        thread::sleep(Duration::from_secs(1));
-        let Some(ref latest_block) = latest_block else {
-            info!("No block observed yet!");
-            continue;
-        };
-        let stacks_block_height = latest_block.get("block_height").unwrap().as_u64().unwrap();
-        info!("Block height observed: {stacks_block_height}");
-
-        if stacks_block_height >= 1 && !sent_tx {
-            let tip = NakamotoChainState::get_canonical_block_header(chainstate.db(), &sortdb)
-                .unwrap()
-                .unwrap();
-            // Bypass admission checks
-            mempool
-                .submit_raw(
-                    &mut chainstate,
-                    &sortdb,
-                    &tip.consensus_hash,
-                    &tip.anchored_header.block_hash(),
-                    transfer_tx.clone(),
-                    &ExecutionCost::max_value(),
-                    &StacksEpochId::Epoch30,
-                )
-                .unwrap();
-
-            sent_tx = true;
-        }
-
-        if stacks_block_height >= 100 {
-            break true;
-        }
-    };
-
-    globals.signal_stop();
-
-    node_thread
-        .join()
-        .expect("Failed to join node thread to exit");
-
-    let transfer_tx_included = test_observer::get_blocks()
-        .into_iter()
-        .find(|block_json| {
-            block_json["transactions"]
-                .as_array()
-                .unwrap()
-                .iter()
-                .find(|tx_json| tx_json["raw_tx"].as_str() == Some(&transfer_tx_hex))
-                .is_some()
-        })
-        .is_some();
-
-    assert!(
-        transfer_tx_included,
-        "Mockamoto node failed to include the transfer tx"
-    );
-
-    assert!(
-        completed,
-        "Mockamoto node failed to produce and announce 100 blocks before timeout"
-    );
-}
-
-#[test]
-fn mempool_rpc_submit() {
-    let mut conf = Config::from_config_file(ConfigFile::mockamoto()).unwrap();
-    conf.node.working_dir = format!(
-        "/tmp/stacks-node-tests/mempool_rpc_submit-{}",
-        get_epoch_time_secs()
-    );
-    conf.node.rpc_bind = "127.0.0.1:19743".into();
-    conf.node.p2p_bind = "127.0.0.1:19744".into();
-    conf.node.mockamoto_time_ms = 10;
-
-    let submitter_sk = StacksPrivateKey::from_seed(&[1]);
-    let submitter_addr = to_addr(&submitter_sk);
-    conf.add_initial_balance(submitter_addr.to_string(), 1_000);
-    let recipient_addr = StacksAddress::burn_address(false).into();
-
-    let observer_port = 19800;
-    test_observer::spawn_at(observer_port);
-    conf.events_observers.insert(EventObserverConfig {
-        endpoint: format!("localhost:{observer_port}"),
-        events_keys: vec![EventKeyType::AnyEvent],
-    });
-
-    let mut mockamoto = MockamotoNode::new(&conf).unwrap();
-    let globals = mockamoto.globals.clone();
-
-    let http_origin = format!("http://{}", &conf.node.rpc_bind);
-
-    let start = Instant::now();
-
-    let node_thread = thread::Builder::new()
-        .name("mockamoto-main".into())
-        .spawn(move || mockamoto.run())
-        .expect("FATAL: failed to start mockamoto main thread");
-
-    // make a transfer tx to test that the mockamoto miner picks up txs from the mempool
-    let tx_fee = 200;
-    let transfer_tx = make_stacks_transfer(&submitter_sk, 0, tx_fee, &recipient_addr, 100);
-    let transfer_tx_hex = format!("0x{}", to_hex(&transfer_tx));
-
-    let mut sent_tx = false;
-
-    // complete within 2 minutes or abort
-    let completed = loop {
-        if Instant::now().duration_since(start) > Duration::from_secs(120) {
-            break false;
-        }
-        let latest_block = test_observer::get_blocks().pop();
-        thread::sleep(Duration::from_secs(1));
-        let Some(ref latest_block) = latest_block else {
-            info!("No block observed yet!");
-            continue;
-        };
-        let stacks_block_height = latest_block.get("block_height").unwrap().as_u64().unwrap();
-        info!("Block height observed: {stacks_block_height}");
-
-        if stacks_block_height >= 1 && !sent_tx {
-            // Enforce admission checks by utilizing the RPC endpoint
-            submit_tx(&http_origin, &transfer_tx);
-            sent_tx = true;
-        }
-
-        if stacks_block_height >= 100 {
-            break true;
-        }
-    };
-
-    globals.signal_stop();
-
-    node_thread
-        .join()
-        .expect("Failed to join node thread to exit");
-
-    let transfer_tx_included = test_observer::get_blocks()
-        .into_iter()
-        .find(|block_json| {
-            block_json["transactions"]
-                .as_array()
-                .unwrap()
-                .iter()
-                .find(|tx_json| tx_json["raw_tx"].as_str() == Some(&transfer_tx_hex))
-                .is_some()
-        })
-        .is_some();
-
-    assert!(
-        transfer_tx_included,
-        "Mockamoto node failed to include the transfer tx"
-    );
-
-    assert!(
-        completed,
-        "Mockamoto node failed to produce and announce 100 blocks before timeout"
-    );
-}
-
-#[test]
-fn observe_set_aggregate_key() {
-    let mut conf = Config::from_config_file(ConfigFile::mockamoto()).unwrap();
-    conf.node.mockamoto_time_ms = 10;
-    conf.node.p2p_bind = "127.0.0.1:20443".into();
-    conf.node.rpc_bind = "127.0.0.1:20444".into();
-    conf.connection_options.public_ip_address = Some((PeerAddress::from_ipv4(127, 0, 0, 1), 20443));
-
-    let submitter_sk = StacksPrivateKey::from_seed(&[1]);
-    let submitter_addr = to_addr(&submitter_sk);
-    conf.add_initial_balance(submitter_addr.to_string(), 1_000);
-
-    test_observer::spawn();
-    let observer_port = test_observer::EVENT_OBSERVER_PORT;
-    conf.events_observers.insert(EventObserverConfig {
-        endpoint: format!("localhost:{observer_port}"),
-        events_keys: vec![EventKeyType::AnyEvent],
-    });
-
-    let mut mockamoto = MockamotoNode::new(&conf).unwrap();
-    let mut signer = mockamoto.self_signer.clone();
-
-    let globals = mockamoto.globals.clone();
-
-    StacksChainState::open(
-        conf.is_mainnet(),
-        conf.burnchain.chain_id,
-        &conf.get_chainstate_path_str(),
-        None,
-    )
-    .unwrap();
-    let sortition_tip = SortitionDB::get_canonical_burn_chain_tip(mockamoto.sortdb.conn()).unwrap();
-
-    let start = Instant::now();
-    // Get the reward cycle of the sortition tip
-    let reward_cycle = mockamoto
-        .sortdb
-        .pox_constants
-        .block_height_to_reward_cycle(
-            mockamoto.sortdb.first_block_height,
-            sortition_tip.block_height,
-        )
-        .unwrap_or_else(|| {
-            panic!(
-                "Failed to determine reward cycle of block height: {}",
-                sortition_tip.block_height
-            )
-        });
-
-    // Get the aggregate public key of the original reward cycle to compare against
-    let expected_cur_key = signer.generate_aggregate_key(reward_cycle);
-    let expected_next_key = signer.generate_aggregate_key(reward_cycle + 1);
-
-    let node_thread = thread::Builder::new()
-        .name("mockamoto-main".into())
-        .spawn(move || {
-            mockamoto.run();
-            let aggregate_key_block_header = NakamotoChainState::get_canonical_block_header(
-                mockamoto.chainstate.db(),
-                &mockamoto.sortdb,
-            )
-            .unwrap()
-            .unwrap();
-            // Get the aggregate public key of the original reward cycle
-            let orig_aggregate_key = mockamoto
-                .chainstate
-                .get_aggregate_public_key_pox_4(
-                    &mockamoto.sortdb,
-                    &aggregate_key_block_header.index_block_hash(),
-                    reward_cycle,
-                )
-                .unwrap();
-            // Get the aggregate public key of the next reward cycle that we manually overwrote
-            let new_aggregate_key = mockamoto
-                .chainstate
-                .get_aggregate_public_key_pox_4(
-                    &mockamoto.sortdb,
-                    &aggregate_key_block_header.index_block_hash(),
-                    reward_cycle + 1,
-                )
-                .unwrap();
-            (orig_aggregate_key, new_aggregate_key)
-        })
-        .expect("FATAL: failed to start mockamoto main thread");
-
-    // complete within 5 seconds or abort (we are only observing one block)
-    let completed = loop {
-        if Instant::now().duration_since(start) > Duration::from_secs(120) {
-            break false;
-        }
-        let latest_block = test_observer::get_blocks().pop();
-        thread::sleep(Duration::from_secs(1));
-        let Some(ref latest_block) = latest_block else {
-            info!("No block observed yet!");
-            continue;
-        };
-        let stacks_block_height = latest_block.get("block_height").unwrap().as_u64().unwrap();
-        info!("Block height observed: {stacks_block_height}");
-        if stacks_block_height >= 100 {
-            break true;
-        }
-    };
-
-    globals.signal_stop();
-
-    let (orig_aggregate_key, new_aggregate_key) = node_thread
-        .join()
-        .expect("Failed to join node thread to exit");
-
-    assert!(
-        completed,
-        "Mockamoto node failed to produce and announce its block before timeout"
-    );
-
-    // Did we set and retrieve the aggregate key correctly?
-    assert_eq!(orig_aggregate_key.unwrap(), expected_cur_key);
-    assert_eq!(new_aggregate_key.unwrap(), expected_next_key);
-}
-
-#[test]
-fn rpc_pox_info() {
-    let mut conf = Config::from_config_file(ConfigFile::mockamoto()).unwrap();
-    conf.node.mockamoto_time_ms = 10;
-    conf.node.rpc_bind = "127.0.0.1:19543".into();
-    conf.node.p2p_bind = "127.0.0.1:19544".into();
-
-    let observer_port = 19500;
-    test_observer::spawn_at(observer_port);
-    conf.events_observers.insert(EventObserverConfig {
-        endpoint: format!("localhost:{observer_port}"),
-        events_keys: vec![EventKeyType::AnyEvent],
-    });
-
-    let mut mockamoto = MockamotoNode::new(&conf).unwrap();
-    let globals = mockamoto.globals.clone();
-
-    let http_origin = format!("http://{}", &conf.node.rpc_bind);
-
-    let start = Instant::now();
-
-    let node_thread = thread::Builder::new()
-        .name("mockamoto-main".into())
-        .spawn(move || mockamoto.run())
-        .expect("FATAL: failed to start mockamoto main thread");
-
-    // mine 5 blocks
-    let completed = loop {
-        // complete within 2 minutes or abort
-        if Instant::now().duration_since(start) > Duration::from_secs(120) {
-            break false;
-        }
-        let latest_block = test_observer::get_blocks().pop();
-        thread::sleep(Duration::from_secs(1));
-        let Some(ref latest_block) = latest_block else {
-            info!("No block observed yet!");
-            continue;
-        };
-        let stacks_block_height = latest_block.get("block_height").unwrap().as_u64().unwrap();
-        info!("Block height observed: {stacks_block_height}");
-
-        if stacks_block_height >= 5 {
-            break true;
-        }
-    };
-
-    // fetch rpc poxinfo
-    let _pox_info = get_pox_info(&http_origin);
-
-    globals.signal_stop();
-
-    assert!(
-        completed,
-        "Mockamoto node failed to produce and announce 100 blocks before timeout"
-    );
-    node_thread
-        .join()
-        .expect("Failed to join node thread to exit");
-}

From b815506502d9efdeba4a44d6990f6a80916b0492 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Fri, 23 Feb 2024 14:07:57 -0600
Subject: [PATCH 0990/1166] chore: remove genesis-initialization of aggregate
 pub key

---
 stackslib/src/chainstate/stacks/boot/mod.rs |  3 +-
 stackslib/src/clarity_vm/clarity.rs         | 51 +--------------------
 2 files changed, 3 insertions(+), 51 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index abba9be6c7..74927cdf9a 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -90,7 +90,7 @@ const POX_4_BODY: &'static str = std::include_str!("pox-4.clar");
 pub const SIGNERS_BODY: &'static str = std::include_str!("signers.clar");
 pub const SIGNERS_DB_0_BODY: &'static str = std::include_str!("signers-0-xxx.clar");
 pub const SIGNERS_DB_1_BODY: &'static str = std::include_str!("signers-1-xxx.clar");
-const SIGNERS_VOTING_BODY: &'static str = std::include_str!("signers-voting.clar");
+pub const SIGNERS_VOTING_BODY: &'static str = std::include_str!("signers-voting.clar");
 
 pub const COSTS_1_NAME: &'static str = "costs";
 pub const COSTS_2_NAME: &'static str = "costs-2";
@@ -119,7 +119,6 @@ lazy_static! {
     pub static ref POX_3_TESTNET_CODE: String =
         format!("{}\n{}", BOOT_CODE_POX_TESTNET_CONSTS, POX_3_BODY);
     pub static ref POX_4_CODE: String = format!("{}", POX_4_BODY);
-    pub static ref SIGNER_VOTING_CODE: String = format!("{}", SIGNERS_VOTING_BODY);
     pub static ref BOOT_CODE_COST_VOTING_TESTNET: String = make_testnet_cost_voting();
     pub static ref STACKS_BOOT_CODE_MAINNET: [(&'static str, &'static str); 6] = [
         ("pox", &BOOT_CODE_POX_MAINNET),
diff --git a/stackslib/src/clarity_vm/clarity.rs b/stackslib/src/clarity_vm/clarity.rs
index 81a421cdef..ac764e0e91 100644
--- a/stackslib/src/clarity_vm/clarity.rs
+++ b/stackslib/src/clarity_vm/clarity.rs
@@ -50,7 +50,7 @@ use crate::chainstate::stacks::boot::{
     BOOT_TEST_POX_4_AGG_KEY_CONTRACT, BOOT_TEST_POX_4_AGG_KEY_FNAME, COSTS_2_NAME, COSTS_3_NAME,
     MINERS_NAME, POX_2_MAINNET_CODE, POX_2_NAME, POX_2_TESTNET_CODE, POX_3_MAINNET_CODE,
     POX_3_NAME, POX_3_TESTNET_CODE, POX_4_CODE, POX_4_NAME, SIGNERS_BODY, SIGNERS_DB_0_BODY,
-    SIGNERS_DB_1_BODY, SIGNERS_NAME, SIGNERS_VOTING_NAME, SIGNER_VOTING_CODE,
+    SIGNERS_DB_1_BODY, SIGNERS_NAME, SIGNERS_VOTING_BODY, SIGNERS_VOTING_NAME,
 };
 use crate::chainstate::stacks::db::{StacksAccount, StacksChainState};
 use crate::chainstate::stacks::events::{StacksTransactionEvent, StacksTransactionReceipt};
@@ -1457,59 +1457,12 @@ impl<'a, 'b> ClarityBlockConnection<'a, 'b> {
                 }
             }
 
-            let initialized_agg_key = if !mainnet {
-                let agg_key_value_opt = self
-                    .with_readonly_clarity_env(
-                        false,
-                        self.chain_id,
-                        ClarityVersion::Clarity2,
-                        StacksAddress::burn_address(false).into(),
-                        None,
-                        LimitedCostTracker::Free,
-                        |vm_env| {
-                            vm_env.execute_contract_allow_private(
-                                &boot_code_id(BOOT_TEST_POX_4_AGG_KEY_CONTRACT, false),
-                                BOOT_TEST_POX_4_AGG_KEY_FNAME,
-                                &[],
-                                true,
-                            )
-                        },
-                    )
-                    .map(|agg_key_value| {
-                        agg_key_value
-                            .expect_buff(33)
-                            .expect("FATAL: test aggregate pub key must be a buffer")
-                    })
-                    .ok();
-                agg_key_value_opt
-            } else {
-                None
-            };
-
-            let mut signers_voting_code = SIGNER_VOTING_CODE.clone();
-            if !mainnet {
-                if let Some(ref agg_pub_key) = initialized_agg_key {
-                    let hex_agg_pub_key = to_hex(agg_pub_key);
-                    for set_in_reward_cycle in 0..pox_4_first_cycle {
-                        info!(
-                            "Setting initial aggregate-public-key in PoX-4";
-                            "agg_pub_key" => &hex_agg_pub_key,
-                            "reward_cycle" => set_in_reward_cycle,
-                            "pox_4_first_cycle" => pox_4_first_cycle,
-                        );
-                        let set_str = format!("(map-set aggregate-public-keys u{set_in_reward_cycle} 0x{hex_agg_pub_key})");
-                        signers_voting_code.push_str("\n");
-                        signers_voting_code.push_str(&set_str);
-                    }
-                }
-            }
-
             let signers_voting_contract_id = boot_code_id(SIGNERS_VOTING_NAME, mainnet);
             let payload = TransactionPayload::SmartContract(
                 TransactionSmartContract {
                     name: ContractName::try_from(SIGNERS_VOTING_NAME)
                         .expect("FATAL: invalid boot-code contract name"),
-                    code_body: StacksString::from_str(&signers_voting_code)
+                    code_body: StacksString::from_str(SIGNERS_VOTING_BODY)
                         .expect("FATAL: invalid boot code body"),
                 },
                 Some(ClarityVersion::Clarity2),

From b04386d4f5950484f1618703ff22b87317b6a138 Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Thu, 29 Feb 2024 00:06:09 -0500
Subject: [PATCH 0991/1166] feat: setup `blind-signer` lib and binary

This is a thread, for use in testing, that blindly signs blocks and
submits signer votes.
---
 Cargo.lock                                    |  15 +
 Cargo.toml                                    |   8 +-
 blind-signer/Cargo.toml                       |  30 ++
 blind-signer/src/lib.rs                       | 290 ++++++++++++++++++
 blind-signer/src/main.rs                      |  41 +++
 testnet/stacks-node/Cargo.toml                |   6 +
 .../burnchains/bitcoin_regtest_controller.rs  |   5 +-
 testnet/stacks-node/src/chain_data.rs         |   1 +
 testnet/stacks-node/src/config.rs             |   2 +
 testnet/stacks-node/src/event_dispatcher.rs   |   3 +-
 testnet/stacks-node/src/globals.rs            |   2 +-
 testnet/stacks-node/src/lib.rs                |   9 +
 testnet/stacks-node/src/main.rs               |   6 +-
 testnet/stacks-node/src/nakamoto_node.rs      |   2 +-
 .../stacks-node/src/nakamoto_node/miner.rs    |   5 +-
 testnet/stacks-node/src/nakamoto_node/peer.rs |   3 +-
 .../stacks-node/src/nakamoto_node/relayer.rs  |   8 +-
 testnet/stacks-node/src/neon_node.rs          |   5 +-
 testnet/stacks-node/src/node.rs               |   3 +-
 .../stacks-node/src/run_loop/boot_nakamoto.rs |   2 +-
 testnet/stacks-node/src/run_loop/helium.rs    |   5 +-
 testnet/stacks-node/src/run_loop/nakamoto.rs  |   5 +-
 testnet/stacks-node/src/run_loop/neon.rs      |   5 +-
 testnet/stacks-node/src/syncctl.rs            |   2 +-
 testnet/stacks-node/src/tenure.rs             |   3 +-
 .../stacks-node/src/tests/bitcoin_regtest.rs  |   2 +-
 testnet/stacks-node/src/tests/epoch_205.rs    |   3 +-
 testnet/stacks-node/src/tests/epoch_21.rs     |   3 +-
 testnet/stacks-node/src/tests/epoch_22.rs     |   4 +-
 testnet/stacks-node/src/tests/epoch_23.rs     |   3 +-
 testnet/stacks-node/src/tests/epoch_24.rs     |   7 +-
 testnet/stacks-node/src/tests/integrations.rs |   2 +-
 .../src/tests/nakamoto_integrations.rs        | 261 +---------------
 .../src/tests/neon_integrations.rs            |  53 +---
 testnet/stacks-node/src/tests/signer.rs       |   6 +-
 testnet/stacks-node/src/tests/stackerdb.rs    |   5 +-
 testnet/stacks-node/src/utils.rs              | 195 ++++++++++++
 37 files changed, 663 insertions(+), 347 deletions(-)
 create mode 100644 blind-signer/Cargo.toml
 create mode 100644 blind-signer/src/lib.rs
 create mode 100644 blind-signer/src/main.rs
 create mode 100644 testnet/stacks-node/src/lib.rs
 create mode 100644 testnet/stacks-node/src/utils.rs

diff --git a/Cargo.lock b/Cargo.lock
index aedba0ffaa..ab0e3e0e96 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -522,6 +522,20 @@ dependencies = [
  "wyz",
 ]
 
+[[package]]
+name = "blind-signer"
+version = "0.1.0"
+dependencies = [
+ "libsigner",
+ "pico-args",
+ "reqwest",
+ "serde_json",
+ "slog",
+ "stacks-common",
+ "stacks-node",
+ "stackslib",
+]
+
 [[package]]
 name = "block-buffer"
 version = "0.9.0"
@@ -3496,6 +3510,7 @@ dependencies = [
  "async-std",
  "backtrace",
  "base64 0.12.3",
+ "blind-signer",
  "chrono",
  "clarity",
  "hashbrown 0.14.3",
diff --git a/Cargo.toml b/Cargo.toml
index 66791df99c..d24c04a8ba 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -10,11 +10,13 @@ members = [
     "contrib/tools/relay-server",
     "libsigner",
     "stacks-signer",
-    "testnet/stacks-node"]
+    "testnet/stacks-node",
+    "blind-signer",
+]
 
 # Dependencies we want to keep the same between workspace members
-[workspace.dependencies]  
-ed25519-dalek = { version = "2.1.1", features = ["serde", "rand_core"] } 
+[workspace.dependencies]
+ed25519-dalek = { version = "2.1.1", features = ["serde", "rand_core"] }
 hashbrown = "0.14.3"
 rand_core = "0.6"
 rand = "0.8"
diff --git a/blind-signer/Cargo.toml b/blind-signer/Cargo.toml
new file mode 100644
index 0000000000..a4087aec80
--- /dev/null
+++ b/blind-signer/Cargo.toml
@@ -0,0 +1,30 @@
+[package]
+name = "blind-signer"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+slog = { version = "2.5.2", features = ["max_level_trace"] }
+pico-args = "0.5.0"
+reqwest = { version = "0.11", default_features = false, features = [
+  "blocking",
+  "json",
+  "rustls",
+  "rustls-tls",
+] }
+serde_json = { version = "1.0", features = [
+  "arbitrary_precision",
+  "raw_value",
+] }
+stacks = { package = "stackslib", path = "../stackslib" }
+stacks-common = { path = "../stacks-common" }
+libsigner = { path = "../libsigner" }
+stacks-node = { path = "../testnet/stacks-node" }
+
+[lib]
+name = "blind_signer"
+path = "src/lib.rs"
+
+[[bin]]
+name = "blind-signer"
+path = "src/main.rs"
diff --git a/blind-signer/src/lib.rs b/blind-signer/src/lib.rs
new file mode 100644
index 0000000000..5bc8d0f99d
--- /dev/null
+++ b/blind-signer/src/lib.rs
@@ -0,0 +1,290 @@
+use libsigner::{BlockResponse, SignerMessage, SignerSession, StackerDBSession};
+use stacks::chainstate::burn::db::sortdb::SortitionDB;
+use stacks::chainstate::nakamoto::signer_set::NakamotoSigners;
+use stacks::chainstate::nakamoto::test_signers::TestSigners;
+use stacks::chainstate::nakamoto::{NakamotoBlock, NakamotoChainState};
+use stacks::chainstate::stacks::boot::{MINERS_NAME, SIGNERS_VOTING_NAME};
+use stacks::clarity::vm::types::QualifiedContractIdentifier;
+use stacks::clarity::vm::Value;
+use stacks::codec::StacksMessageCodec;
+use stacks::libstackerdb::{SlotMetadata, StackerDBChunkData};
+use stacks::net::api::callreadonly::CallReadOnlyRequestBody;
+use stacks::net::api::getstackers::GetStackersResponse;
+use stacks::types::chainstate::StacksAddress;
+use stacks::util::hash::to_hex;
+use stacks::util_lib::boot::boot_code_id;
+use stacks_common::types::chainstate::StacksPublicKey;
+use stacks_common::util::hash::Sha512Trunc256Sum;
+use stacks_common::util::secp256k1::{Secp256k1PrivateKey, Secp256k1PublicKey};
+use stacks_node::config::Config;
+use stacks_node::utils::{get_account, make_contract_call, submit_tx, to_addr};
+use std::{
+    collections::HashSet,
+    thread::{self, JoinHandle},
+    time::Duration,
+};
+
+#[allow(unused_imports)]
+#[macro_use(o, slog_log, slog_trace, slog_debug, slog_info, slog_warn, slog_error)]
+extern crate slog;
+#[macro_use]
+extern crate stacks_common;
+
+/// Spawn a blind signing thread. `signer` is the private key
+///  of the individual signer who broadcasts the response to the StackerDB
+pub fn blind_signer(
+    conf: &Config,
+    signers: &TestSigners,
+    signer: &Secp256k1PrivateKey,
+) -> JoinHandle<()> {
+    let mut signed_blocks = HashSet::new();
+    let conf = conf.clone();
+    let signers = signers.clone();
+    let signer = signer.clone();
+    thread::spawn(move || loop {
+        thread::sleep(Duration::from_millis(500));
+        match read_and_sign_block_proposal(&conf, &signers, &signer, &signed_blocks) {
+            Ok(signed_block) => {
+                if signed_blocks.contains(&signed_block) {
+                    continue;
+                }
+                info!("Signed block"; "signer_sig_hash" => signed_block.to_hex());
+                signed_blocks.insert(signed_block);
+            }
+            Err(e) => {
+                warn!("Error reading and signing block proposal: {e}");
+            }
+        }
+
+        signer_vote_if_needed(&conf, &signers, &signer);
+    })
+}
+
+pub fn read_and_sign_block_proposal(
+    conf: &Config,
+    signers: &TestSigners,
+    signer: &Secp256k1PrivateKey,
+    signed_blocks: &HashSet<Sha512Trunc256Sum>,
+) -> Result<Sha512Trunc256Sum, String> {
+    let burnchain = conf.get_burnchain();
+    let sortdb = burnchain.open_sortition_db(true).unwrap();
+    let tip = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn()).unwrap();
+    let miner_pubkey = StacksPublicKey::from_private(&conf.get_miner_config().mining_key.unwrap());
+    let miner_slot_id = NakamotoChainState::get_miner_slot(&sortdb, &tip, &miner_pubkey)
+        .map_err(|_| "Unable to get miner slot")?
+        .ok_or("No miner slot exists")?;
+    let reward_cycle = burnchain
+        .block_height_to_reward_cycle(tip.block_height)
+        .unwrap();
+    let rpc_sock = conf
+        .node
+        .rpc_bind
+        .clone()
+        .parse()
+        .expect("Failed to parse socket");
+
+    let mut proposed_block: NakamotoBlock = {
+        let miner_contract_id = boot_code_id(MINERS_NAME, false);
+        let mut miners_stackerdb = StackerDBSession::new(rpc_sock, miner_contract_id);
+        miners_stackerdb
+            .get_latest(miner_slot_id)
+            .map_err(|_| "Failed to get latest chunk from the miner slot ID")?
+            .ok_or("No chunk found")?
+    };
+    let proposed_block_hash = format!("0x{}", proposed_block.header.block_hash());
+    let signer_sig_hash = proposed_block.header.signer_signature_hash();
+    if signed_blocks.contains(&signer_sig_hash) {
+        // already signed off on this block, don't sign again.
+        return Ok(signer_sig_hash);
+    }
+
+    info!(
+        "Fetched proposed block from .miners StackerDB";
+        "proposed_block_hash" => &proposed_block_hash,
+        "signer_sig_hash" => &signer_sig_hash.to_hex(),
+    );
+
+    signers
+        .clone()
+        .sign_nakamoto_block(&mut proposed_block, reward_cycle);
+
+    let signer_message = SignerMessage::BlockResponse(BlockResponse::Accepted((
+        signer_sig_hash.clone(),
+        proposed_block.header.signer_signature.clone(),
+    )));
+
+    let signers_contract_id =
+        NakamotoSigners::make_signers_db_contract_id(reward_cycle, libsigner::BLOCK_MSG_ID, false);
+
+    let http_origin = format!("http://{}", &conf.node.rpc_bind);
+    let signers_info = get_stacker_set(&http_origin, reward_cycle);
+    let signer_index = get_signer_index(&signers_info, &Secp256k1PublicKey::from_private(signer))
+        .unwrap()
+        .try_into()
+        .unwrap();
+
+    let next_version = get_stackerdb_slot_version(&http_origin, &signers_contract_id, signer_index)
+        .map(|x| x + 1)
+        .unwrap_or(0);
+    let mut signers_contract_sess = StackerDBSession::new(rpc_sock, signers_contract_id);
+    let mut chunk_to_put = StackerDBChunkData::new(
+        u32::try_from(signer_index).unwrap(),
+        next_version,
+        signer_message.serialize_to_vec(),
+    );
+    chunk_to_put.sign(signer).unwrap();
+    signers_contract_sess
+        .put_chunk(&chunk_to_put)
+        .map_err(|e| e.to_string())?;
+    Ok(signer_sig_hash)
+}
+
+fn signer_vote_if_needed(conf: &Config, signers: &TestSigners, signer: &Secp256k1PrivateKey) {
+    let burnchain = conf.get_burnchain();
+    let sortdb = burnchain.open_sortition_db(true).unwrap();
+    let tip = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn()).unwrap();
+    let reward_cycle = burnchain
+        .block_height_to_reward_cycle(tip.block_height)
+        .unwrap();
+    let prepare_phase_start = burnchain
+        .pox_constants
+        .prepare_phase_start(burnchain.first_block_height, reward_cycle);
+
+    if tip.block_height >= prepare_phase_start {
+        // If the key is already set, do nothing.
+        if is_key_set_for_cycle(reward_cycle + 1, conf.is_mainnet(), &conf.node.rpc_bind)
+            .unwrap_or(false)
+        {
+            return;
+        }
+
+        // If we are self-signing, then we need to vote on the aggregate public key
+        let http_origin = format!("http://{}", &conf.node.rpc_bind);
+
+        // Get the aggregate key
+        let aggregate_key = signers.clone().generate_aggregate_key(reward_cycle + 1);
+        let aggregate_public_key = Value::buff_from(aggregate_key.compress().data.to_vec())
+            .expect("Failed to serialize aggregate public key");
+
+        let signer_nonce = get_account(&http_origin, &to_addr(signer)).nonce;
+
+        // Vote on the aggregate public key
+        let voting_tx = make_contract_call(
+            &signer,
+            signer_nonce,
+            300,
+            &StacksAddress::burn_address(false),
+            SIGNERS_VOTING_NAME,
+            "vote-for-aggregate-public-key",
+            &[
+                Value::UInt(0),
+                aggregate_public_key.clone(),
+                Value::UInt(0),
+                Value::UInt(reward_cycle as u128 + 1),
+            ],
+        );
+        submit_tx(&http_origin, &voting_tx);
+    }
+}
+
+pub fn get_stacker_set(http_origin: &str, cycle: u64) -> GetStackersResponse {
+    let client = reqwest::blocking::Client::new();
+    let path = format!("{http_origin}/v2/stacker_set/{cycle}");
+    let res = client
+        .get(&path)
+        .send()
+        .unwrap()
+        .json::<serde_json::Value>()
+        .unwrap();
+    info!("Stacker set response: {res}");
+    let res = serde_json::from_value(res).unwrap();
+    res
+}
+
+fn get_signer_index(
+    stacker_set: &GetStackersResponse,
+    signer_key: &Secp256k1PublicKey,
+) -> Result<usize, String> {
+    let Some(ref signer_set) = stacker_set.stacker_set.signers else {
+        return Err("Empty signer set for reward cycle".into());
+    };
+    let signer_key_bytes = signer_key.to_bytes_compressed();
+    signer_set
+        .iter()
+        .enumerate()
+        .find_map(|(ix, entry)| {
+            if entry.signing_key.as_slice() == signer_key_bytes.as_slice() {
+                Some(ix)
+            } else {
+                None
+            }
+        })
+        .ok_or_else(|| {
+            format!(
+                "Signing key not found. {} not found.",
+                to_hex(&signer_key_bytes)
+            )
+        })
+}
+
+pub fn get_stackerdb_slot_version(
+    http_origin: &str,
+    contract: &QualifiedContractIdentifier,
+    slot_id: u64,
+) -> Option<u32> {
+    let client = reqwest::blocking::Client::new();
+    let path = format!(
+        "{http_origin}/v2/stackerdb/{}/{}",
+        &contract.issuer, &contract.name
+    );
+    let res = client
+        .get(&path)
+        .send()
+        .unwrap()
+        .json::<Vec<SlotMetadata>>()
+        .unwrap();
+    debug!("StackerDB metadata response: {res:?}");
+    res.iter().find_map(|slot| {
+        if u64::from(slot.slot_id) == slot_id {
+            Some(slot.slot_version)
+        } else {
+            None
+        }
+    })
+}
+
+fn is_key_set_for_cycle(
+    reward_cycle: u64,
+    is_mainnet: bool,
+    http_origin: &str,
+) -> Result<bool, String> {
+    let client = reqwest::blocking::Client::new();
+    let boot_address = StacksAddress::burn_address(is_mainnet);
+    let path = format!("http://{http_origin}/v2/contracts/call-read/{boot_address}/signers-voting/get-approved-aggregate-key");
+    let body = CallReadOnlyRequestBody {
+        sender: boot_address.to_string(),
+        sponsor: None,
+        arguments: vec![Value::UInt(reward_cycle as u128)
+            .serialize_to_hex()
+            .map_err(|_| "Failed to serialize reward cycle")?],
+    };
+    let res = client
+        .post(&path)
+        .json(&body)
+        .send()
+        .map_err(|_| "Failed to send request")?
+        .json::<serde_json::Value>()
+        .map_err(|_| "Failed to extract json Value")?;
+    let result_value = Value::try_deserialize_hex_untyped(
+        &res.get("result")
+            .ok_or("No result in response")?
+            .as_str()
+            .ok_or("Result is not a string")?[2..],
+    )
+    .map_err(|_| "Failed to deserialize Clarity value")?;
+
+    result_value
+        .expect_optional()
+        .map(|v| v.is_some())
+        .map_err(|_| "Response is not optional".to_string())
+}
diff --git a/blind-signer/src/main.rs b/blind-signer/src/main.rs
new file mode 100644
index 0000000000..e7409ffbff
--- /dev/null
+++ b/blind-signer/src/main.rs
@@ -0,0 +1,41 @@
+#[macro_use]
+extern crate stacks_common;
+
+use std::{process, thread::park};
+
+use pico_args::Arguments;
+use stacks::{
+    chainstate::nakamoto::test_signers::TestSigners, util::secp256k1::Secp256k1PrivateKey,
+};
+use stacks_node::config::{Config, ConfigFile};
+
+#[allow(unused_imports)]
+#[macro_use(o, slog_log, slog_trace, slog_debug, slog_info, slog_warn, slog_error)]
+extern crate slog;
+
+fn main() {
+    let mut args = Arguments::from_env();
+    let config_path: String = args.value_from_str("--config").unwrap();
+    args.finish();
+    info!("Loading config at path {}", config_path);
+    let config_file = match ConfigFile::from_path(&config_path) {
+        Ok(config_file) => config_file,
+        Err(e) => {
+            warn!("Invalid config file: {}", e);
+            process::exit(1);
+        }
+    };
+
+    let conf = match Config::from_config_file(config_file) {
+        Ok(conf) => conf,
+        Err(e) => {
+            warn!("Invalid config: {}", e);
+            process::exit(1);
+        }
+    };
+
+    let signers = TestSigners::default();
+    let sender_signer_sk = Secp256k1PrivateKey::new();
+    blind_signer::blind_signer(&conf, &signers, &sender_signer_sk);
+    park();
+}
diff --git a/testnet/stacks-node/Cargo.toml b/testnet/stacks-node/Cargo.toml
index 71f8808a12..0e5862ddbf 100644
--- a/testnet/stacks-node/Cargo.toml
+++ b/testnet/stacks-node/Cargo.toml
@@ -31,6 +31,7 @@ wsts = { workspace = true }
 rand = { workspace = true }
 rand_core = { workspace = true }
 hashbrown = { workspace = true }
+reqwest = { version = "0.11", default_features = false, features = ["blocking", "json", "rustls", "rustls-tls"] }
 
 [target.'cfg(not(target_env = "msvc"))'.dependencies]
 tikv-jemallocator = {workspace = true}
@@ -44,6 +45,7 @@ clarity = { path = "../../clarity", features = ["default", "testing"]}
 stacks-common = { path = "../../stacks-common", features = ["default", "testing"] }
 stacks = { package = "stackslib", path = "../../stackslib", features = ["default", "testing"] }
 stacks-signer = { path = "../../stacks-signer" }
+blind-signer = { path = "../../blind-signer" }
 tracing = "0.1.37"
 tracing-subscriber = { version = "0.3.17", features = ["env-filter"] }
 wsts = {workspace = true}
@@ -61,6 +63,10 @@ path = "src/main.rs"
 name = "stacks-events"
 path = "src/stacks_events.rs"
 
+[lib]
+name = "stacks_node"
+path = "src/lib.rs"
+
 [features]
 monitoring_prom = ["stacks/monitoring_prom"]
 slog_json = ["stacks/slog_json", "stacks-common/slog_json", "clarity/slog_json"]
diff --git a/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs b/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
index f2e6f69542..0507162ad4 100644
--- a/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
+++ b/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
@@ -53,9 +53,9 @@ use stacks_common::types::chainstate::BurnchainHeaderHash;
 use stacks_common::util::hash::{hex_bytes, Hash160};
 use stacks_common::util::secp256k1::Secp256k1PublicKey;
 use stacks_common::util::sleep_ms;
+use stacks_node::config::Config;
 
 use super::super::operations::BurnchainOpSigner;
-use super::super::Config;
 use super::{BurnchainController, BurnchainTip, Error as BurnchainControllerError};
 
 /// The number of bitcoin blocks that can have
@@ -2556,8 +2556,9 @@ mod tests {
     use std::fs::File;
     use std::io::Write;
 
+    use stacks_node::config::DEFAULT_SATS_PER_VB;
+
     use super::*;
-    use crate::config::DEFAULT_SATS_PER_VB;
 
     #[test]
     fn test_get_satoshis_per_byte() {
diff --git a/testnet/stacks-node/src/chain_data.rs b/testnet/stacks-node/src/chain_data.rs
index 4170cf6f6d..cf502058af 100644
--- a/testnet/stacks-node/src/chain_data.rs
+++ b/testnet/stacks-node/src/chain_data.rs
@@ -17,6 +17,7 @@
 use std::collections::HashMap;
 use std::process::{Command, Stdio};
 
+use serde::{Deserialize, Serialize};
 use stacks::burnchains::bitcoin::address::BitcoinAddress;
 use stacks::burnchains::bitcoin::{BitcoinNetworkType, BitcoinTxOutput};
 use stacks::burnchains::{Burnchain, BurnchainSigner, Error as BurnchainError, Txid};
diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index cc39fb1e52..d8b2192191 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -9,6 +9,7 @@ use clarity::vm::costs::ExecutionCost;
 use clarity::vm::types::{AssetIdentifier, PrincipalData, QualifiedContractIdentifier};
 use lazy_static::lazy_static;
 use rand::RngCore;
+use serde::Deserialize;
 use stacks::burnchains::bitcoin::BitcoinNetworkType;
 use stacks::burnchains::{Burnchain, MagicBytes, BLOCKSTACK_MAGIC_MAINNET};
 use stacks::chainstate::nakamoto::signer_set::NakamotoSigners;
@@ -33,6 +34,7 @@ use stacks::net::{Neighbor, NeighborKey};
 use stacks::util_lib::boot::boot_code_id;
 use stacks::util_lib::db::Error as DBError;
 use stacks_common::consts::SIGNER_SLOTS_PER_USER;
+use stacks_common::test_debug;
 use stacks_common::types::chainstate::StacksAddress;
 use stacks_common::types::net::PeerAddress;
 use stacks_common::types::Address;
diff --git a/testnet/stacks-node/src/event_dispatcher.rs b/testnet/stacks-node/src/event_dispatcher.rs
index 90272bd0b8..88774e35eb 100644
--- a/testnet/stacks-node/src/event_dispatcher.rs
+++ b/testnet/stacks-node/src/event_dispatcher.rs
@@ -39,8 +39,7 @@ use stacks::net::stackerdb::StackerDBEventDispatcher;
 use stacks_common::codec::StacksMessageCodec;
 use stacks_common::types::chainstate::{BlockHeaderHash, BurnchainHeaderHash, StacksBlockId};
 use stacks_common::util::hash::bytes_to_hex;
-
-use super::config::{EventKeyType, EventObserverConfig};
+use stacks_node::config::{EventKeyType, EventObserverConfig};
 
 #[derive(Debug, Clone)]
 struct EventObserver {
diff --git a/testnet/stacks-node/src/globals.rs b/testnet/stacks-node/src/globals.rs
index a6a2fdad3c..3e4b32fbae 100644
--- a/testnet/stacks-node/src/globals.rs
+++ b/testnet/stacks-node/src/globals.rs
@@ -12,8 +12,8 @@ use stacks::chainstate::stacks::db::StacksChainState;
 use stacks::chainstate::stacks::miner::MinerStatus;
 use stacks::net::NetworkResult;
 use stacks_common::types::chainstate::{BlockHeaderHash, BurnchainHeaderHash, ConsensusHash};
+use stacks_node::config::MinerConfig;
 
-use crate::config::MinerConfig;
 use crate::neon::Counters;
 use crate::neon_node::LeaderKeyRegistrationState;
 use crate::run_loop::RegisteredKey;
diff --git a/testnet/stacks-node/src/lib.rs b/testnet/stacks-node/src/lib.rs
new file mode 100644
index 0000000000..a7ca5cd959
--- /dev/null
+++ b/testnet/stacks-node/src/lib.rs
@@ -0,0 +1,9 @@
+#[allow(unused_imports)]
+#[macro_use(o, slog_log, slog_trace, slog_debug, slog_info, slog_warn, slog_error)]
+extern crate slog;
+#[macro_use]
+extern crate stacks_common;
+
+pub mod chain_data;
+pub mod config;
+pub mod utils;
diff --git a/testnet/stacks-node/src/main.rs b/testnet/stacks-node/src/main.rs
index bf54c1601d..1d0f3d8114 100644
--- a/testnet/stacks-node/src/main.rs
+++ b/testnet/stacks-node/src/main.rs
@@ -12,12 +12,12 @@ extern crate slog;
 
 pub use stacks_common::util;
 use stacks_common::util::hash::hex_bytes;
+use stacks_node::chain_data::MinerStats;
+use stacks_node::config::{Config, ConfigFile};
 
 pub mod monitoring;
 
 pub mod burnchains;
-pub mod chain_data;
-pub mod config;
 pub mod event_dispatcher;
 pub mod genesis_data;
 pub mod globals;
@@ -47,13 +47,11 @@ use tikv_jemallocator::Jemalloc;
 pub use self::burnchains::{
     BitcoinRegtestController, BurnchainController, BurnchainTip, MocknetController,
 };
-pub use self::config::{Config, ConfigFile};
 pub use self::event_dispatcher::EventDispatcher;
 pub use self::keychain::Keychain;
 pub use self::node::{ChainTip, Node};
 pub use self::run_loop::{helium, neon};
 pub use self::tenure::Tenure;
-use crate::chain_data::MinerStats;
 use crate::neon_node::{BlockMinerThread, TipCandidate};
 use crate::run_loop::boot_nakamoto;
 
diff --git a/testnet/stacks-node/src/nakamoto_node.rs b/testnet/stacks-node/src/nakamoto_node.rs
index 302382f170..d8543f8537 100644
--- a/testnet/stacks-node/src/nakamoto_node.rs
+++ b/testnet/stacks-node/src/nakamoto_node.rs
@@ -30,11 +30,11 @@ use stacks::net::stackerdb::StackerDBs;
 use stacks_common::types::chainstate::SortitionId;
 use stacks_common::types::StacksEpochId;
 
-use super::{Config, EventDispatcher, Keychain};
 use crate::burnchains::bitcoin_regtest_controller::addr2str;
 use crate::neon_node::{LeaderKeyRegistrationState, StacksNode as NeonNode};
 use crate::run_loop::nakamoto::{Globals, RunLoop};
 use crate::run_loop::RegisteredKey;
+use crate::Keychain;
 
 pub mod miner;
 pub mod peer;
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index d840e7f7a3..9eac0b52ef 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -46,14 +46,15 @@ use stacks_common::types::chainstate::{StacksAddress, StacksBlockId};
 use stacks_common::types::{PrivateKey, StacksEpochId};
 use stacks_common::util::hash::{Hash160, Sha512Trunc256Sum};
 use stacks_common::util::vrf::VRFProof;
+use stacks_node::config::Config;
 use wsts::curve::point::Point;
 
 use super::relayer::RelayerThread;
-use super::{Config, Error as NakamotoNodeError, EventDispatcher, Keychain};
+use super::{Error as NakamotoNodeError, Keychain};
 use crate::nakamoto_node::VRF_MOCK_MINER_KEY;
 use crate::run_loop::nakamoto::Globals;
 use crate::run_loop::RegisteredKey;
-use crate::{neon_node, ChainTip};
+use crate::{neon_node, ChainTip, EventDispatcher};
 
 /// If the miner was interrupted while mining a block, how long should the
 ///  miner thread sleep before trying again?
diff --git a/testnet/stacks-node/src/nakamoto_node/peer.rs b/testnet/stacks-node/src/nakamoto_node/peer.rs
index eeb6789d30..0bd73da5fc 100644
--- a/testnet/stacks-node/src/nakamoto_node/peer.rs
+++ b/testnet/stacks-node/src/nakamoto_node/peer.rs
@@ -31,12 +31,13 @@ use stacks::net::dns::{DNSClient, DNSResolver};
 use stacks::net::p2p::PeerNetwork;
 use stacks::net::RPCHandlerArgs;
 use stacks_common::util::hash::Sha256Sum;
+use stacks_node::config::Config;
 
 use crate::burnchains::make_bitcoin_indexer;
 use crate::nakamoto_node::relayer::RelayerDirective;
 use crate::neon_node::open_chainstate_with_faults;
 use crate::run_loop::nakamoto::{Globals, RunLoop};
-use crate::{Config, EventDispatcher};
+use crate::EventDispatcher;
 
 /// Thread that runs the network state machine, handling both p2p and http requests.
 pub struct PeerThread {
diff --git a/testnet/stacks-node/src/nakamoto_node/relayer.rs b/testnet/stacks-node/src/nakamoto_node/relayer.rs
index 1ee3135c24..09d661f775 100644
--- a/testnet/stacks-node/src/nakamoto_node/relayer.rs
+++ b/testnet/stacks-node/src/nakamoto_node/relayer.rs
@@ -50,11 +50,9 @@ use stacks_common::types::StacksEpochId;
 use stacks_common::util::get_epoch_time_ms;
 use stacks_common::util::hash::Hash160;
 use stacks_common::util::vrf::{VRFProof, VRFPublicKey};
+use stacks_node::config::Config;
 
-use super::{
-    BlockCommits, Config, Error as NakamotoNodeError, EventDispatcher, Keychain,
-    BLOCK_PROCESSOR_STACK_SIZE,
-};
+use super::{BlockCommits, Error as NakamotoNodeError, Keychain, BLOCK_PROCESSOR_STACK_SIZE};
 use crate::burnchains::BurnchainController;
 use crate::nakamoto_node::miner::{BlockMinerThread, MinerDirective};
 use crate::neon_node::{
@@ -62,7 +60,7 @@ use crate::neon_node::{
 };
 use crate::run_loop::nakamoto::{Globals, RunLoop};
 use crate::run_loop::RegisteredKey;
-use crate::BitcoinRegtestController;
+use crate::{BitcoinRegtestController, EventDispatcher};
 
 /// Command types for the Nakamoto relayer thread, issued to it by other threads
 pub enum RelayerDirective {
diff --git a/testnet/stacks-node/src/neon_node.rs b/testnet/stacks-node/src/neon_node.rs
index 49064d4971..7bd69b028e 100644
--- a/testnet/stacks-node/src/neon_node.rs
+++ b/testnet/stacks-node/src/neon_node.rs
@@ -201,13 +201,14 @@ use stacks_common::util::hash::{to_hex, Hash160, Sha256Sum};
 use stacks_common::util::secp256k1::Secp256k1PrivateKey;
 use stacks_common::util::vrf::{VRFProof, VRFPublicKey};
 use stacks_common::util::{get_epoch_time_ms, get_epoch_time_secs};
+use stacks_node::chain_data::MinerStats;
+use stacks_node::config::Config;
 
-use super::{BurnchainController, Config, EventDispatcher, Keychain};
+use super::{BurnchainController, EventDispatcher, Keychain};
 use crate::burnchains::bitcoin_regtest_controller::{
     addr2str, BitcoinRegtestController, OngoingBlockCommit,
 };
 use crate::burnchains::make_bitcoin_indexer;
-use crate::chain_data::MinerStats;
 use crate::globals::{NeonGlobals as Globals, RelayerDirective};
 use crate::run_loop::neon::RunLoop;
 use crate::run_loop::RegisteredKey;
diff --git a/testnet/stacks-node/src/node.rs b/testnet/stacks-node/src/node.rs
index 90c2123079..b004f9de3f 100644
--- a/testnet/stacks-node/src/node.rs
+++ b/testnet/stacks-node/src/node.rs
@@ -44,8 +44,9 @@ use stacks_common::util::get_epoch_time_secs;
 use stacks_common::util::hash::Sha256Sum;
 use stacks_common::util::secp256k1::Secp256k1PrivateKey;
 use stacks_common::util::vrf::VRFPublicKey;
+use stacks_node::config::Config;
 
-use super::{BurnchainController, BurnchainTip, Config, EventDispatcher, Keychain, Tenure};
+use super::{BurnchainController, BurnchainTip, EventDispatcher, Keychain, Tenure};
 use crate::burnchains::make_bitcoin_indexer;
 use crate::genesis_data::USE_TEST_GENESIS_CHAINSTATE;
 use crate::run_loop;
diff --git a/testnet/stacks-node/src/run_loop/boot_nakamoto.rs b/testnet/stacks-node/src/run_loop/boot_nakamoto.rs
index dec1ca757f..c6116de495 100644
--- a/testnet/stacks-node/src/run_loop/boot_nakamoto.rs
+++ b/testnet/stacks-node/src/run_loop/boot_nakamoto.rs
@@ -24,11 +24,11 @@ use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::coordinator::comm::CoordinatorChannels;
 use stacks::core::StacksEpochExtension;
 use stacks_common::types::{StacksEpoch, StacksEpochId};
+use stacks_node::config::Config;
 
 use crate::neon::Counters;
 use crate::run_loop::nakamoto::RunLoop as NakaRunLoop;
 use crate::run_loop::neon::RunLoop as NeonRunLoop;
-use crate::Config;
 
 /// This runloop handles booting to Nakamoto:
 /// During epochs [1.0, 2.5], it runs a neon run_loop.
diff --git a/testnet/stacks-node/src/run_loop/helium.rs b/testnet/stacks-node/src/run_loop/helium.rs
index c7212d4132..53e876d2ea 100644
--- a/testnet/stacks-node/src/run_loop/helium.rs
+++ b/testnet/stacks-node/src/run_loop/helium.rs
@@ -1,11 +1,10 @@
 use stacks::chainstate::stacks::db::ClarityTx;
 use stacks_common::types::chainstate::BurnchainHeaderHash;
+use stacks_node::config::Config;
 
 use super::RunLoopCallbacks;
 use crate::burnchains::Error as BurnchainControllerError;
-use crate::{
-    BitcoinRegtestController, BurnchainController, ChainTip, Config, MocknetController, Node,
-};
+use crate::{BitcoinRegtestController, BurnchainController, ChainTip, MocknetController, Node};
 
 /// RunLoop is coordinating a simulated burnchain and some simulated nodes
 /// taking turns in producing blocks.
diff --git a/testnet/stacks-node/src/run_loop/nakamoto.rs b/testnet/stacks-node/src/run_loop/nakamoto.rs
index 0b3702a994..8e64cb75a8 100644
--- a/testnet/stacks-node/src/run_loop/nakamoto.rs
+++ b/testnet/stacks-node/src/run_loop/nakamoto.rs
@@ -33,6 +33,7 @@ use stacks::core::StacksEpochId;
 use stacks::net::atlas::{AtlasConfig, AtlasDB, Attachment};
 use stacks_common::types::PublicKey;
 use stacks_common::util::hash::Hash160;
+use stacks_node::config::Config;
 use stx_genesis::GenesisData;
 
 use crate::burnchains::make_bitcoin_indexer;
@@ -46,9 +47,7 @@ use crate::node::{
 use crate::run_loop::neon;
 use crate::run_loop::neon::Counters;
 use crate::syncctl::{PoxSyncWatchdog, PoxSyncWatchdogComms};
-use crate::{
-    run_loop, BitcoinRegtestController, BurnchainController, Config, EventDispatcher, Keychain,
-};
+use crate::{run_loop, BitcoinRegtestController, BurnchainController, EventDispatcher, Keychain};
 
 pub const STDERR: i32 = 2;
 pub type Globals = GenericGlobals<nakamoto_node::relayer::RelayerDirective>;
diff --git a/testnet/stacks-node/src/run_loop/neon.rs b/testnet/stacks-node/src/run_loop/neon.rs
index 86235ec3bd..e65ee90ecf 100644
--- a/testnet/stacks-node/src/run_loop/neon.rs
+++ b/testnet/stacks-node/src/run_loop/neon.rs
@@ -27,6 +27,7 @@ use stacks_common::deps_common::ctrlc::SignalId;
 use stacks_common::types::PublicKey;
 use stacks_common::util::hash::Hash160;
 use stacks_common::util::{get_epoch_time_secs, sleep_ms};
+use stacks_node::config::Config;
 use stx_genesis::GenesisData;
 
 use super::RunLoopCallbacks;
@@ -39,9 +40,7 @@ use crate::node::{
     use_test_genesis_chainstate,
 };
 use crate::syncctl::{PoxSyncWatchdog, PoxSyncWatchdogComms};
-use crate::{
-    run_loop, BitcoinRegtestController, BurnchainController, Config, EventDispatcher, Keychain,
-};
+use crate::{run_loop, BitcoinRegtestController, BurnchainController, EventDispatcher, Keychain};
 
 pub const STDERR: i32 = 2;
 
diff --git a/testnet/stacks-node/src/syncctl.rs b/testnet/stacks-node/src/syncctl.rs
index ff68126a83..92915e8ed8 100644
--- a/testnet/stacks-node/src/syncctl.rs
+++ b/testnet/stacks-node/src/syncctl.rs
@@ -5,9 +5,9 @@ use std::sync::Arc;
 use stacks::burnchains::{Burnchain, Error as burnchain_error};
 use stacks::chainstate::stacks::db::StacksChainState;
 use stacks_common::util::{get_epoch_time_secs, sleep_ms};
+use stacks_node::config::Config;
 
 use crate::burnchains::BurnchainTip;
-use crate::Config;
 
 // amount of time to wait for an inv or download sync to complete.
 // These _really should_ complete before the PoX sync watchdog permits processing the next reward
diff --git a/testnet/stacks-node/src/tenure.rs b/testnet/stacks-node/src/tenure.rs
index 882a65d06b..985489acec 100644
--- a/testnet/stacks-node/src/tenure.rs
+++ b/testnet/stacks-node/src/tenure.rs
@@ -16,10 +16,11 @@ use stacks::core::mempool::MemPoolDB;
 use stacks_common::types::chainstate::VRFSeed;
 use stacks_common::util::hash::Hash160;
 use stacks_common::util::vrf::VRFProof;
+use stacks_node::config::Config;
 
 /// Only used by the Helium (Mocknet) node
 use super::node::ChainTip;
-use super::{BurnchainTip, Config};
+use super::BurnchainTip;
 
 pub struct TenureArtifacts {
     pub anchored_block: StacksBlock,
diff --git a/testnet/stacks-node/src/tests/bitcoin_regtest.rs b/testnet/stacks-node/src/tests/bitcoin_regtest.rs
index 6391dd9b2a..4f0bfe603b 100644
--- a/testnet/stacks-node/src/tests/bitcoin_regtest.rs
+++ b/testnet/stacks-node/src/tests/bitcoin_regtest.rs
@@ -9,9 +9,9 @@ use stacks::chainstate::burn::operations::BlockstackOperationType::{
 use stacks::chainstate::stacks::StacksPrivateKey;
 use stacks::core::StacksEpochId;
 use stacks_common::util::hash::hex_bytes;
+use stacks_node::config::InitialBalance;
 
 use super::PUBLISH_CONTRACT;
-use crate::config::InitialBalance;
 use crate::helium::RunLoop;
 use crate::tests::to_addr;
 use crate::Config;
diff --git a/testnet/stacks-node/src/tests/epoch_205.rs b/testnet/stacks-node/src/tests/epoch_205.rs
index 0f689f00ef..1fe0e50994 100644
--- a/testnet/stacks-node/src/tests/epoch_205.rs
+++ b/testnet/stacks-node/src/tests/epoch_205.rs
@@ -24,8 +24,9 @@ use stacks_common::types::chainstate::{
 };
 use stacks_common::util::hash::hex_bytes;
 use stacks_common::util::sleep_ms;
+use stacks_node::config::{EventKeyType, EventObserverConfig, InitialBalance};
+use stacks_node::utils::{get_account, submit_tx};
 
-use crate::config::{EventKeyType, EventObserverConfig, InitialBalance};
 use crate::tests::bitcoin_regtest::BitcoinCoreController;
 use crate::tests::neon_integrations::*;
 use crate::tests::{
diff --git a/testnet/stacks-node/src/tests/epoch_21.rs b/testnet/stacks-node/src/tests/epoch_21.rs
index e26468a254..4fdfbcc8ac 100644
--- a/testnet/stacks-node/src/tests/epoch_21.rs
+++ b/testnet/stacks-node/src/tests/epoch_21.rs
@@ -33,9 +33,10 @@ use stacks_common::types::PrivateKey;
 use stacks_common::util::hash::{Hash160, Sha256Sum};
 use stacks_common::util::secp256k1::{Secp256k1PrivateKey, Secp256k1PublicKey};
 use stacks_common::util::sleep_ms;
+use stacks_node::config::{Config, EventKeyType, EventObserverConfig, InitialBalance};
+use stacks_node::utils::{get_account, submit_tx};
 
 use crate::burnchains::bitcoin_regtest_controller::UTXO;
-use crate::config::{Config, EventKeyType, EventObserverConfig, InitialBalance};
 use crate::neon::RunLoopCounter;
 use crate::operations::BurnchainOpSigner;
 use crate::stacks_common::address::AddressHashMode;
diff --git a/testnet/stacks-node/src/tests/epoch_22.rs b/testnet/stacks-node/src/tests/epoch_22.rs
index 5c58b26ded..3c9acdc70e 100644
--- a/testnet/stacks-node/src/tests/epoch_22.rs
+++ b/testnet/stacks-node/src/tests/epoch_22.rs
@@ -16,9 +16,9 @@ use stacks_common::types::PrivateKey;
 use stacks_common::util::hash::Hash160;
 use stacks_common::util::secp256k1::Secp256k1PublicKey;
 use stacks_common::util::sleep_ms;
+use stacks_node::config::{EventKeyType, EventObserverConfig, InitialBalance};
+use stacks_node::utils::{get_account, submit_tx};
 
-use super::neon_integrations::get_account;
-use crate::config::{EventKeyType, EventObserverConfig, InitialBalance};
 use crate::neon_node::StacksNode;
 use crate::stacks_common::types::Address;
 use crate::stacks_common::util::hash::bytes_to_hex;
diff --git a/testnet/stacks-node/src/tests/epoch_23.rs b/testnet/stacks-node/src/tests/epoch_23.rs
index 740785e182..32c0b10b43 100644
--- a/testnet/stacks-node/src/tests/epoch_23.rs
+++ b/testnet/stacks-node/src/tests/epoch_23.rs
@@ -21,8 +21,9 @@ use stacks::burnchains::{Burnchain, PoxConstants};
 use stacks::core;
 use stacks::core::STACKS_EPOCH_MAX;
 use stacks_common::util::sleep_ms;
+use stacks_node::config::{EventKeyType, EventObserverConfig, InitialBalance};
+use stacks_node::utils::submit_tx;
 
-use crate::config::{EventKeyType, EventObserverConfig, InitialBalance};
 use crate::tests::bitcoin_regtest::BitcoinCoreController;
 use crate::tests::neon_integrations::*;
 use crate::tests::*;
diff --git a/testnet/stacks-node/src/tests/epoch_24.rs b/testnet/stacks-node/src/tests/epoch_24.rs
index b88441838a..d1f8b42089 100644
--- a/testnet/stacks-node/src/tests/epoch_24.rs
+++ b/testnet/stacks-node/src/tests/epoch_24.rs
@@ -35,12 +35,13 @@ use stacks_common::types::Address;
 use stacks_common::util::hash::{bytes_to_hex, hex_bytes, Hash160};
 use stacks_common::util::secp256k1::Secp256k1PublicKey;
 use stacks_common::util::sleep_ms;
+use stacks_node::config::{EventKeyType, EventObserverConfig, InitialBalance};
+use stacks_node::utils::{get_account, submit_tx};
 
-use crate::config::{EventKeyType, EventObserverConfig, InitialBalance};
 use crate::tests::bitcoin_regtest::BitcoinCoreController;
 use crate::tests::neon_integrations::{
-    get_account, get_chain_info, get_pox_info, neon_integration_test_conf, next_block_and_wait,
-    submit_tx, test_observer, wait_for_runloop,
+    get_chain_info, get_pox_info, neon_integration_test_conf, next_block_and_wait, test_observer,
+    wait_for_runloop,
 };
 use crate::tests::{make_contract_call, to_addr};
 use crate::{neon, BitcoinRegtestController, BurnchainController};
diff --git a/testnet/stacks-node/src/tests/integrations.rs b/testnet/stacks-node/src/tests/integrations.rs
index 2bb9bd891e..e798681a16 100644
--- a/testnet/stacks-node/src/tests/integrations.rs
+++ b/testnet/stacks-node/src/tests/integrations.rs
@@ -34,12 +34,12 @@ use stacks::net::api::getistraitimplemented::GetIsTraitImplementedResponse;
 use stacks_common::codec::StacksMessageCodec;
 use stacks_common::types::chainstate::{StacksAddress, StacksBlockId, VRFSeed};
 use stacks_common::util::hash::{hex_bytes, to_hex, Sha256Sum};
+use stacks_node::config::InitialBalance;
 
 use super::{
     make_contract_call, make_contract_publish, make_stacks_transfer, to_addr, ADDR_4, SK_1, SK_2,
     SK_3,
 };
-use crate::config::InitialBalance;
 use crate::helium::RunLoop;
 use crate::tests::make_sponsored_stacks_transfer_on_testnet;
 
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 3fd999a603..652bdb5583 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -13,23 +13,22 @@
 //
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
-use std::collections::{HashMap, HashSet};
+use std::collections::HashMap;
 use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::{Arc, Mutex};
-use std::thread::JoinHandle;
 use std::time::{Duration, Instant};
 use std::{env, thread};
 
+use blind_signer::blind_signer;
 use clarity::vm::ast::ASTRules;
 use clarity::vm::costs::ExecutionCost;
 use clarity::vm::types::{PrincipalData, QualifiedContractIdentifier};
 use lazy_static::lazy_static;
-use libsigner::{BlockResponse, SignerMessage, SignerSession, StackerDBSession};
+use libsigner::{SignerSession, StackerDBSession};
 use stacks::burnchains::MagicBytes;
 use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::coordinator::comm::CoordinatorChannels;
 use stacks::chainstate::nakamoto::miner::NakamotoBlockBuilder;
-use stacks::chainstate::nakamoto::signer_set::NakamotoSigners;
 use stacks::chainstate::nakamoto::test_signers::TestSigners;
 use stacks::chainstate::nakamoto::{NakamotoBlock, NakamotoChainState};
 use stacks::chainstate::stacks::address::PoxAddress;
@@ -43,7 +42,7 @@ use stacks::core::{
     PEER_VERSION_EPOCH_2_1, PEER_VERSION_EPOCH_2_2, PEER_VERSION_EPOCH_2_3, PEER_VERSION_EPOCH_2_4,
     PEER_VERSION_EPOCH_2_5, PEER_VERSION_EPOCH_3_0,
 };
-use stacks::libstackerdb::{SlotMetadata, StackerDBChunkData};
+use stacks::libstackerdb::SlotMetadata;
 use stacks::net::api::callreadonly::CallReadOnlyRequestBody;
 use stacks::net::api::getstackers::GetStackersResponse;
 use stacks::net::api::postblock_proposal::{
@@ -59,16 +58,17 @@ use stacks_common::consts::{CHAIN_ID_TESTNET, STACKS_EPOCH_MAX};
 use stacks_common::types::chainstate::{
     BlockHeaderHash, StacksAddress, StacksPrivateKey, StacksPublicKey,
 };
-use stacks_common::util::hash::{to_hex, Sha512Trunc256Sum};
+use stacks_common::util::hash::to_hex;
 use stacks_common::util::secp256k1::{MessageSignature, Secp256k1PrivateKey, Secp256k1PublicKey};
+use stacks_node::config::{EventKeyType, EventObserverConfig, InitialBalance};
+use stacks_node::utils::{get_account, submit_tx};
 
 use super::bitcoin_regtest::BitcoinCoreController;
-use crate::config::{EventKeyType, EventObserverConfig, InitialBalance};
-use crate::neon::{Counters, RunLoopCounter};
+use crate::neon::Counters;
 use crate::run_loop::boot_nakamoto;
 use crate::tests::neon_integrations::{
-    get_account, get_chain_info_result, get_pox_info, next_block_and_wait,
-    run_until_burnchain_height, submit_tx, test_observer, wait_for_runloop,
+    get_chain_info_result, get_pox_info, next_block_and_wait, run_until_burnchain_height,
+    test_observer, wait_for_runloop,
 };
 use crate::tests::{make_stacks_transfer, to_addr};
 use crate::{tests, BitcoinRegtestController, BurnchainController, Config, ConfigFile, Keychain};
@@ -201,120 +201,6 @@ pub fn add_initial_balances(
         .collect()
 }
 
-/// Spawn a blind signing thread. `signer` is the private key
-///  of the individual signer who broadcasts the response to the StackerDB
-pub fn blind_signer(
-    conf: &Config,
-    signers: &TestSigners,
-    signer: &Secp256k1PrivateKey,
-    proposals_count: RunLoopCounter,
-) -> JoinHandle<()> {
-    let mut signed_blocks = HashSet::new();
-    let conf = conf.clone();
-    let signers = signers.clone();
-    let signer = signer.clone();
-    let mut last_count = proposals_count.load(Ordering::SeqCst);
-    thread::spawn(move || loop {
-        thread::sleep(Duration::from_millis(100));
-        let cur_count = proposals_count.load(Ordering::SeqCst);
-        if cur_count <= last_count {
-            continue;
-        }
-        last_count = cur_count;
-        match read_and_sign_block_proposal(&conf, &signers, &signer, &signed_blocks) {
-            Ok(signed_block) => {
-                if signed_blocks.contains(&signed_block) {
-                    continue;
-                }
-                info!("Signed block"; "signer_sig_hash" => signed_block.to_hex());
-                signed_blocks.insert(signed_block);
-            }
-            Err(e) => {
-                warn!("Error reading and signing block proposal: {e}");
-            }
-        }
-    })
-}
-
-pub fn read_and_sign_block_proposal(
-    conf: &Config,
-    signers: &TestSigners,
-    signer: &Secp256k1PrivateKey,
-    signed_blocks: &HashSet<Sha512Trunc256Sum>,
-) -> Result<Sha512Trunc256Sum, String> {
-    let burnchain = conf.get_burnchain();
-    let sortdb = burnchain.open_sortition_db(true).unwrap();
-    let tip = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn()).unwrap();
-    let miner_pubkey = StacksPublicKey::from_private(&conf.get_miner_config().mining_key.unwrap());
-    let miner_slot_id = NakamotoChainState::get_miner_slot(&sortdb, &tip, &miner_pubkey)
-        .map_err(|_| "Unable to get miner slot")?
-        .ok_or("No miner slot exists")?;
-    let reward_cycle = burnchain
-        .block_height_to_reward_cycle(tip.block_height)
-        .unwrap();
-    let rpc_sock = conf
-        .node
-        .rpc_bind
-        .clone()
-        .parse()
-        .expect("Failed to parse socket");
-
-    let mut proposed_block: NakamotoBlock = {
-        let miner_contract_id = boot_code_id(MINERS_NAME, false);
-        let mut miners_stackerdb = StackerDBSession::new(rpc_sock, miner_contract_id);
-        miners_stackerdb
-            .get_latest(miner_slot_id)
-            .map_err(|_| "Failed to get latest chunk from the miner slot ID")?
-            .ok_or("No chunk found")?
-    };
-    let proposed_block_hash = format!("0x{}", proposed_block.header.block_hash());
-    let signer_sig_hash = proposed_block.header.signer_signature_hash();
-    if signed_blocks.contains(&signer_sig_hash) {
-        // already signed off on this block, don't sign again.
-        return Ok(signer_sig_hash);
-    }
-
-    info!(
-        "Fetched proposed block from .miners StackerDB";
-        "proposed_block_hash" => &proposed_block_hash,
-        "signer_sig_hash" => &signer_sig_hash.to_hex(),
-    );
-
-    signers
-        .clone()
-        .sign_nakamoto_block(&mut proposed_block, reward_cycle);
-
-    let signer_message = SignerMessage::BlockResponse(BlockResponse::Accepted((
-        signer_sig_hash.clone(),
-        proposed_block.header.signer_signature.clone(),
-    )));
-
-    let signers_contract_id =
-        NakamotoSigners::make_signers_db_contract_id(reward_cycle, libsigner::BLOCK_MSG_ID, false);
-
-    let http_origin = format!("http://{}", &conf.node.rpc_bind);
-    let signers_info = get_stacker_set(&http_origin, reward_cycle);
-    let signer_index = get_signer_index(&signers_info, &Secp256k1PublicKey::from_private(signer))
-        .unwrap()
-        .try_into()
-        .unwrap();
-
-    let next_version = get_stackerdb_slot_version(&http_origin, &signers_contract_id, signer_index)
-        .map(|x| x + 1)
-        .unwrap_or(0);
-    let mut signers_contract_sess = StackerDBSession::new(rpc_sock, signers_contract_id);
-    let mut chunk_to_put = StackerDBChunkData::new(
-        u32::try_from(signer_index).unwrap(),
-        next_version,
-        signer_message.serialize_to_vec(),
-    );
-    chunk_to_put.sign(signer).unwrap();
-    signers_contract_sess
-        .put_chunk(&chunk_to_put)
-        .map_err(|e| e.to_string())?;
-    Ok(signer_sig_hash)
-}
-
 /// Return a working nakamoto-neon config and the miner's bitcoin address to fund
 pub fn naka_neon_integration_conf(seed: Option<&[u8]>) -> (Config, StacksAddress) {
     let mut conf = super::new_test_conf();
@@ -687,70 +573,6 @@ fn is_key_set_for_cycle(
         .map_err(|_| "Response is not optional".to_string())
 }
 
-fn signer_vote_if_needed(
-    btc_regtest_controller: &BitcoinRegtestController,
-    naka_conf: &Config,
-    signer_sks: &[StacksPrivateKey], // TODO: Is there some way to get this from the TestSigners?
-    signers: &TestSigners,
-) {
-    // When we reach the next prepare phase, submit new voting transactions
-    let block_height = btc_regtest_controller.get_headers_height();
-    let reward_cycle = btc_regtest_controller
-        .get_burnchain()
-        .block_height_to_reward_cycle(block_height)
-        .unwrap();
-    let prepare_phase_start = btc_regtest_controller
-        .get_burnchain()
-        .pox_constants
-        .prepare_phase_start(
-            btc_regtest_controller.get_burnchain().first_block_height,
-            reward_cycle,
-        );
-
-    if block_height >= prepare_phase_start {
-        // If the key is already set, do nothing.
-        if is_key_set_for_cycle(
-            reward_cycle + 1,
-            naka_conf.is_mainnet(),
-            &naka_conf.node.rpc_bind,
-        )
-        .unwrap_or(false)
-        {
-            return;
-        }
-
-        // If we are self-signing, then we need to vote on the aggregate public key
-        let http_origin = format!("http://{}", &naka_conf.node.rpc_bind);
-
-        // Get the aggregate key
-        let aggregate_key = signers.clone().generate_aggregate_key(reward_cycle + 1);
-        let aggregate_public_key =
-            clarity::vm::Value::buff_from(aggregate_key.compress().data.to_vec())
-                .expect("Failed to serialize aggregate public key");
-
-        for (i, signer_sk) in signer_sks.iter().enumerate() {
-            let signer_nonce = get_account(&http_origin, &to_addr(signer_sk)).nonce;
-
-            // Vote on the aggregate public key
-            let voting_tx = tests::make_contract_call(
-                &signer_sk,
-                signer_nonce,
-                300,
-                &StacksAddress::burn_address(false),
-                SIGNERS_VOTING_NAME,
-                "vote-for-aggregate-public-key",
-                &[
-                    clarity::vm::Value::UInt(i as u128),
-                    aggregate_public_key.clone(),
-                    clarity::vm::Value::UInt(0),
-                    clarity::vm::Value::UInt(reward_cycle as u128 + 1),
-                ],
-            );
-            submit_tx(&http_origin, &voting_tx);
-        }
-    }
-}
-
 ///
 /// * `stacker_sks` - must be a private key for sending a large `stack-stx` transaction in order
 ///   for pox-4 to activate
@@ -908,7 +730,6 @@ fn simple_neon_integration() {
         blocks_processed,
         naka_submitted_vrfs: vrfs_submitted,
         naka_submitted_commits: commits_submitted,
-        naka_proposed_blocks: proposals_submitted,
         ..
     } = run_loop.counters();
 
@@ -959,7 +780,7 @@ fn simple_neon_integration() {
     }
 
     info!("Nakamoto miner started...");
-    blind_signer(&naka_conf, &signers, &sender_signer_sk, proposals_submitted);
+    blind_signer(&naka_conf, &signers, &sender_signer_sk);
 
     // first block wakes up the run loop, wait until a key registration has been submitted.
     next_block_and(&mut btc_regtest_controller, 60, || {
@@ -984,13 +805,6 @@ fn simple_neon_integration() {
             &commits_submitted,
         )
         .unwrap();
-
-        signer_vote_if_needed(
-            &btc_regtest_controller,
-            &naka_conf,
-            &[sender_signer_sk],
-            &signers,
-        );
     }
 
     // Submit a TX
@@ -1026,13 +840,6 @@ fn simple_neon_integration() {
             &commits_submitted,
         )
         .unwrap();
-
-        signer_vote_if_needed(
-            &btc_regtest_controller,
-            &naka_conf,
-            &[sender_signer_sk],
-            &signers,
-        );
     }
 
     // load the chain tip, and assert that it is a nakamoto block and at least 30 blocks have advanced in epoch 3
@@ -1149,7 +956,6 @@ fn mine_multiple_per_tenure_integration() {
         blocks_processed,
         naka_submitted_vrfs: vrfs_submitted,
         naka_submitted_commits: commits_submitted,
-        naka_proposed_blocks: proposals_submitted,
         ..
     } = run_loop.counters();
 
@@ -1188,7 +994,7 @@ fn mine_multiple_per_tenure_integration() {
             .stacks_block_height;
 
     info!("Nakamoto miner started...");
-    blind_signer(&naka_conf, &signers, &sender_signer_sk, proposals_submitted);
+    blind_signer(&naka_conf, &signers, &sender_signer_sk);
 
     // first block wakes up the run loop, wait until a key registration has been submitted.
     next_block_and(&mut btc_regtest_controller, 60, || {
@@ -1343,7 +1149,6 @@ fn correct_burn_outs() {
         blocks_processed,
         naka_submitted_vrfs: vrfs_submitted,
         naka_submitted_commits: commits_submitted,
-        naka_proposed_blocks: proposals_submitted,
         ..
     } = run_loop.counters();
 
@@ -1454,33 +1259,7 @@ fn correct_burn_outs() {
         })
         .unwrap();
 
-    let block_height = btc_regtest_controller.get_headers_height();
-    let reward_cycle = btc_regtest_controller
-        .get_burnchain()
-        .block_height_to_reward_cycle(block_height)
-        .unwrap();
-    let prepare_phase_start = btc_regtest_controller
-        .get_burnchain()
-        .pox_constants
-        .prepare_phase_start(
-            btc_regtest_controller.get_burnchain().first_block_height,
-            reward_cycle,
-        );
-
-    // Run until the prepare phase
-    run_until_burnchain_height(
-        &mut btc_regtest_controller,
-        &blocks_processed,
-        prepare_phase_start,
-        &naka_conf,
-    );
-
-    signer_vote_if_needed(
-        &btc_regtest_controller,
-        &naka_conf,
-        &[sender_signer_sk],
-        &signers,
-    );
+    blind_signer(&naka_conf, &signers, &sender_signer_sk);
 
     run_until_burnchain_height(
         &mut btc_regtest_controller,
@@ -1490,7 +1269,6 @@ fn correct_burn_outs() {
     );
 
     info!("Bootstrapped to Epoch-3.0 boundary, Epoch2x miner should stop");
-    blind_signer(&naka_conf, &signers, &sender_signer_sk, proposals_submitted);
 
     // we should already be able to query the stacker set via RPC
     let burnchain = naka_conf.get_burnchain();
@@ -1551,13 +1329,6 @@ fn correct_burn_outs() {
             tip_sn.block_height > prior_tip,
             "The new burnchain tip must have been processed"
         );
-
-        signer_vote_if_needed(
-            &btc_regtest_controller,
-            &naka_conf,
-            &[sender_signer_sk],
-            &signers,
-        );
     }
 
     coord_channel
@@ -1637,7 +1408,6 @@ fn block_proposal_api_endpoint() {
         blocks_processed,
         naka_submitted_vrfs: vrfs_submitted,
         naka_submitted_commits: commits_submitted,
-        naka_proposed_blocks: proposals_submitted,
         ..
     } = run_loop.counters();
 
@@ -1655,7 +1425,7 @@ fn block_proposal_api_endpoint() {
     );
 
     info!("Bootstrapped to Epoch-3.0 boundary, starting nakamoto miner");
-    blind_signer(&conf, &signers, &sender_signer_sk, proposals_submitted);
+    blind_signer(&conf, &signers, &sender_signer_sk);
 
     let burnchain = conf.get_burnchain();
     let sortdb = burnchain.open_sortition_db(true).unwrap();
@@ -1988,7 +1758,6 @@ fn miner_writes_proposed_block_to_stackerdb() {
         blocks_processed,
         naka_submitted_vrfs: vrfs_submitted,
         naka_submitted_commits: commits_submitted,
-        naka_proposed_blocks: proposals_submitted,
         ..
     } = run_loop.counters();
 
@@ -2006,7 +1775,7 @@ fn miner_writes_proposed_block_to_stackerdb() {
     );
 
     info!("Nakamoto miner started...");
-    blind_signer(&naka_conf, &signers, &sender_signer_sk, proposals_submitted);
+    blind_signer(&naka_conf, &signers, &sender_signer_sk);
     // first block wakes up the run loop, wait until a key registration has been submitted.
     next_block_and(&mut btc_regtest_controller, 60, || {
         let vrf_count = vrfs_submitted.load(Ordering::SeqCst);
diff --git a/testnet/stacks-node/src/tests/neon_integrations.rs b/testnet/stacks-node/src/tests/neon_integrations.rs
index cd0c96358e..0609bb479d 100644
--- a/testnet/stacks-node/src/tests/neon_integrations.rs
+++ b/testnet/stacks-node/src/tests/neon_integrations.rs
@@ -61,6 +61,8 @@ use stacks_common::types::chainstate::{
 use stacks_common::util::hash::{bytes_to_hex, hex_bytes, to_hex, Hash160};
 use stacks_common::util::secp256k1::{Secp256k1PrivateKey, Secp256k1PublicKey};
 use stacks_common::util::{get_epoch_time_ms, get_epoch_time_secs, sleep_ms};
+use stacks_node::config::{EventKeyType, EventObserverConfig, FeeEstimatorName, InitialBalance};
+use stacks_node::utils::{get_account, submit_tx};
 
 use super::bitcoin_regtest::BitcoinCoreController;
 use super::{
@@ -69,7 +71,6 @@ use super::{
     SK_2, SK_3,
 };
 use crate::burnchains::bitcoin_regtest_controller::{self, BitcoinRPCRequest, UTXO};
-use crate::config::{EventKeyType, EventObserverConfig, FeeEstimatorName, InitialBalance};
 use crate::neon_node::RelayerThread;
 use crate::operations::BurnchainOpSigner;
 use crate::stacks_common::types::PrivateKey;
@@ -697,32 +698,6 @@ pub fn wait_for_microblocks(microblocks_processed: &Arc<AtomicU64>, timeout: u64
     return true;
 }
 
-/// returns Txid string
-pub fn submit_tx(http_origin: &str, tx: &Vec<u8>) -> String {
-    let client = reqwest::blocking::Client::new();
-    let path = format!("{}/v2/transactions", http_origin);
-    let res = client
-        .post(&path)
-        .header("Content-Type", "application/octet-stream")
-        .body(tx.clone())
-        .send()
-        .unwrap();
-    if res.status().is_success() {
-        let res: String = res.json().unwrap();
-        assert_eq!(
-            res,
-            StacksTransaction::consensus_deserialize(&mut &tx[..])
-                .unwrap()
-                .txid()
-                .to_string()
-        );
-        return res;
-    } else {
-        eprintln!("Submit tx error: {}", res.text().unwrap());
-        panic!("");
-    }
-}
-
 pub fn get_unconfirmed_tx(http_origin: &str, txid: &Txid) -> Option<String> {
     let client = reqwest::blocking::Client::new();
     let path = format!("{}/v2/transactions/unconfirmed/{}", http_origin, txid);
@@ -1196,30 +1171,6 @@ pub fn get_balance<F: std::fmt::Display>(http_origin: &str, account: &F) -> u128
     get_account(http_origin, account).balance
 }
 
-#[derive(Debug)]
-pub struct Account {
-    pub balance: u128,
-    pub locked: u128,
-    pub nonce: u64,
-}
-
-pub fn get_account<F: std::fmt::Display>(http_origin: &str, account: &F) -> Account {
-    let client = reqwest::blocking::Client::new();
-    let path = format!("{}/v2/accounts/{}?proof=0", http_origin, account);
-    let res = client
-        .get(&path)
-        .send()
-        .unwrap()
-        .json::<AccountEntryResponse>()
-        .unwrap();
-    info!("Account response: {:#?}", res);
-    Account {
-        balance: u128::from_str_radix(&res.balance[2..], 16).unwrap(),
-        locked: u128::from_str_radix(&res.locked[2..], 16).unwrap(),
-        nonce: res.nonce,
-    }
-}
-
 pub fn get_pox_info(http_origin: &str) -> Option<RPCPoxInfoData> {
     let client = reqwest::blocking::Client::new();
     let path = format!("{}/v2/pox", http_origin);
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index f16b4347d6..3c90b0dcf5 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -27,6 +27,9 @@ use stacks_common::types::chainstate::{ConsensusHash, StacksBlockId, TrieHash};
 use stacks_common::types::StacksEpochId;
 use stacks_common::util::hash::{MerkleTree, Sha512Trunc256Sum};
 use stacks_common::util::secp256k1::MessageSignature;
+use stacks_node::config::{
+    Config as NeonConfig, EventKeyType, EventObserverConfig, InitialBalance,
+};
 use stacks_signer::client::{StackerDB, StacksClient};
 use stacks_signer::config::{build_signer_config_tomls, GlobalConfig as SignerConfig, Network};
 use stacks_signer::runloop::RunLoopCommand;
@@ -40,7 +43,6 @@ use wsts::curve::scalar::Scalar;
 use wsts::state_machine::OperationResult;
 use wsts::taproot::SchnorrProof;
 
-use crate::config::{Config as NeonConfig, EventKeyType, EventObserverConfig, InitialBalance};
 use crate::event_dispatcher::MinedNakamotoBlockEvent;
 use crate::neon::Counters;
 use crate::run_loop::boot_nakamoto;
@@ -91,7 +93,7 @@ impl SignerTest {
             .map(|_| StacksPrivateKey::new())
             .collect::<Vec<StacksPrivateKey>>();
 
-        let (mut naka_conf, _miner_account) = naka_neon_integration_conf(None);
+        let (naka_conf, _miner_account) = naka_neon_integration_conf(None);
 
         // Setup the signer and coordinator configurations
         let signer_configs = build_signer_config_tomls(
diff --git a/testnet/stacks-node/src/tests/stackerdb.rs b/testnet/stacks-node/src/tests/stackerdb.rs
index e24b5c5c24..66eeee04ce 100644
--- a/testnet/stacks-node/src/tests/stackerdb.rs
+++ b/testnet/stacks-node/src/tests/stackerdb.rs
@@ -21,13 +21,14 @@ use stacks::chainstate::stacks::StacksPrivateKey;
 use stacks::libstackerdb::{StackerDBChunkAckData, StackerDBChunkData};
 use stacks_common::types::chainstate::StacksAddress;
 use stacks_common::util::hash::Sha512Trunc256Sum;
+use stacks_node::config::{EventKeyType, EventObserverConfig, InitialBalance};
+use stacks_node::utils::submit_tx;
 use {reqwest, serde_json};
 
 use super::bitcoin_regtest::BitcoinCoreController;
 use crate::burnchains::BurnchainController;
-use crate::config::{EventKeyType, EventObserverConfig, InitialBalance};
 use crate::tests::neon_integrations::{
-    neon_integration_test_conf, next_block_and_wait, submit_tx, test_observer, wait_for_runloop,
+    neon_integration_test_conf, next_block_and_wait, test_observer, wait_for_runloop,
 };
 use crate::tests::{make_contract_publish, to_addr};
 use crate::{neon, BitcoinRegtestController};
diff --git a/testnet/stacks-node/src/utils.rs b/testnet/stacks-node/src/utils.rs
new file mode 100644
index 0000000000..3a01415c40
--- /dev/null
+++ b/testnet/stacks-node/src/utils.rs
@@ -0,0 +1,195 @@
+use clarity::vm::{ClarityName, ContractName, Value};
+use stacks::address::{AddressHashMode, C32_ADDRESS_VERSION_TESTNET_SINGLESIG};
+use stacks::chainstate::stacks::{
+    StacksTransaction, StacksTransactionSigner, TransactionAnchorMode, TransactionAuth,
+    TransactionContractCall, TransactionPayload, TransactionPostConditionMode,
+    TransactionSpendingCondition, TransactionVersion,
+};
+use stacks::codec::StacksMessageCodec;
+use stacks::core::CHAIN_ID_TESTNET;
+use stacks::net::api::getaccount::AccountEntryResponse;
+use stacks::types::chainstate::{StacksAddress, StacksPrivateKey, StacksPublicKey};
+
+#[derive(Debug)]
+pub struct Account {
+    pub balance: u128,
+    pub locked: u128,
+    pub nonce: u64,
+}
+
+pub fn get_account<F: std::fmt::Display>(http_origin: &str, account: &F) -> Account {
+    let client = reqwest::blocking::Client::new();
+    let path = format!("{}/v2/accounts/{}?proof=0", http_origin, account);
+    let res = client
+        .get(&path)
+        .send()
+        .unwrap()
+        .json::<AccountEntryResponse>()
+        .unwrap();
+    info!("Account response: {:#?}", res);
+    Account {
+        balance: u128::from_str_radix(&res.balance[2..], 16).unwrap(),
+        locked: u128::from_str_radix(&res.locked[2..], 16).unwrap(),
+        nonce: res.nonce,
+    }
+}
+
+pub fn to_addr(sk: &StacksPrivateKey) -> StacksAddress {
+    StacksAddress::from_public_keys(
+        C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
+        &AddressHashMode::SerializeP2PKH,
+        1,
+        &vec![StacksPublicKey::from_private(sk)],
+    )
+    .unwrap()
+}
+
+pub fn serialize_sign_standard_single_sig_tx(
+    payload: TransactionPayload,
+    sender: &StacksPrivateKey,
+    nonce: u64,
+    tx_fee: u64,
+) -> Vec<u8> {
+    serialize_sign_standard_single_sig_tx_anchor_mode(
+        payload,
+        sender,
+        nonce,
+        tx_fee,
+        TransactionAnchorMode::OnChainOnly,
+    )
+}
+
+pub fn serialize_sign_standard_single_sig_tx_anchor_mode(
+    payload: TransactionPayload,
+    sender: &StacksPrivateKey,
+    nonce: u64,
+    tx_fee: u64,
+    anchor_mode: TransactionAnchorMode,
+) -> Vec<u8> {
+    serialize_sign_standard_single_sig_tx_anchor_mode_version(
+        payload,
+        sender,
+        nonce,
+        tx_fee,
+        anchor_mode,
+        TransactionVersion::Testnet,
+    )
+}
+
+pub fn serialize_sign_standard_single_sig_tx_anchor_mode_version(
+    payload: TransactionPayload,
+    sender: &StacksPrivateKey,
+    nonce: u64,
+    tx_fee: u64,
+    anchor_mode: TransactionAnchorMode,
+    version: TransactionVersion,
+) -> Vec<u8> {
+    serialize_sign_tx_anchor_mode_version(
+        payload,
+        sender,
+        None,
+        nonce,
+        None,
+        tx_fee,
+        anchor_mode,
+        version,
+    )
+}
+
+pub fn serialize_sign_tx_anchor_mode_version(
+    payload: TransactionPayload,
+    sender: &StacksPrivateKey,
+    payer: Option<&StacksPrivateKey>,
+    sender_nonce: u64,
+    payer_nonce: Option<u64>,
+    tx_fee: u64,
+    anchor_mode: TransactionAnchorMode,
+    version: TransactionVersion,
+) -> Vec<u8> {
+    let mut sender_spending_condition =
+        TransactionSpendingCondition::new_singlesig_p2pkh(StacksPublicKey::from_private(sender))
+            .expect("Failed to create p2pkh spending condition from public key.");
+    sender_spending_condition.set_nonce(sender_nonce);
+
+    let auth = match (payer, payer_nonce) {
+        (Some(payer), Some(payer_nonce)) => {
+            let mut payer_spending_condition = TransactionSpendingCondition::new_singlesig_p2pkh(
+                StacksPublicKey::from_private(payer),
+            )
+            .expect("Failed to create p2pkh spending condition from public key.");
+            payer_spending_condition.set_nonce(payer_nonce);
+            payer_spending_condition.set_tx_fee(tx_fee);
+            TransactionAuth::Sponsored(sender_spending_condition, payer_spending_condition)
+        }
+        _ => {
+            sender_spending_condition.set_tx_fee(tx_fee);
+            TransactionAuth::Standard(sender_spending_condition)
+        }
+    };
+    let mut unsigned_tx = StacksTransaction::new(version, auth, payload);
+    unsigned_tx.anchor_mode = anchor_mode;
+    unsigned_tx.post_condition_mode = TransactionPostConditionMode::Allow;
+    unsigned_tx.chain_id = CHAIN_ID_TESTNET;
+
+    let mut tx_signer = StacksTransactionSigner::new(&unsigned_tx);
+    tx_signer.sign_origin(sender).unwrap();
+    if let (Some(payer), Some(_)) = (payer, payer_nonce) {
+        tx_signer.sign_sponsor(payer).unwrap();
+    }
+
+    let mut buf = vec![];
+    tx_signer
+        .get_tx()
+        .unwrap()
+        .consensus_serialize(&mut buf)
+        .unwrap();
+    buf
+}
+
+pub fn make_contract_call(
+    sender: &StacksPrivateKey,
+    nonce: u64,
+    tx_fee: u64,
+    contract_addr: &StacksAddress,
+    contract_name: &str,
+    function_name: &str,
+    function_args: &[Value],
+) -> Vec<u8> {
+    let contract_name = ContractName::from(contract_name);
+    let function_name = ClarityName::from(function_name);
+
+    let payload = TransactionContractCall {
+        address: contract_addr.clone(),
+        contract_name,
+        function_name,
+        function_args: function_args.iter().map(|x| x.clone()).collect(),
+    };
+
+    serialize_sign_standard_single_sig_tx(payload.into(), sender, nonce, tx_fee)
+}
+
+/// returns Txid string
+pub fn submit_tx(http_origin: &str, tx: &Vec<u8>) -> String {
+    let client = reqwest::blocking::Client::new();
+    let path = format!("{}/v2/transactions", http_origin);
+    let res = client
+        .post(&path)
+        .header("Content-Type", "application/octet-stream")
+        .body(tx.clone())
+        .send()
+        .unwrap();
+    if res.status().is_success() {
+        let res: String = res.json().unwrap();
+        assert_eq!(
+            res,
+            StacksTransaction::consensus_deserialize(&mut &tx[..])
+                .unwrap()
+                .txid()
+                .to_string()
+        );
+        return res;
+    } else {
+        eprintln!("Submit tx error: {}", res.text().unwrap());
+        panic!("");
+    }
+}

From fd54d9d81bf2639e8ba943f731411a76dfb21610 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 28 Feb 2024 19:05:14 -0500
Subject: [PATCH 0992/1166] Fix signer id use in stackerdb

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/mod.rs           |  15 +-
 stacks-signer/src/client/stackerdb.rs     |   6 +-
 stacks-signer/src/client/stacks_client.rs | 125 ++-------------
 stacks-signer/src/config.rs               |  32 ++--
 stacks-signer/src/coordinator.rs          |   4 +-
 stacks-signer/src/runloop.rs              | 178 ++++++++++++++++++----
 stacks-signer/src/signer.rs               |  58 +++----
 7 files changed, 215 insertions(+), 203 deletions(-)

diff --git a/stacks-signer/src/client/mod.rs b/stacks-signer/src/client/mod.rs
index 138913ee6c..424564a9fb 100644
--- a/stacks-signer/src/client/mod.rs
+++ b/stacks-signer/src/client/mod.rs
@@ -99,9 +99,6 @@ pub enum ClientError {
     /// No reward set exists for the given reward cycle
     #[error("No reward set exists for reward cycle {0}")]
     NoRewardSet(u64),
-    /// Reward set contained corrupted data
-    #[error("{0}")]
-    CorruptedRewardSet(String),
     /// Stacks node does not support a feature we need
     #[error("Stacks node does not support a required feature: {0}")]
     UnsupportedStacksFeature(String),
@@ -156,7 +153,7 @@ pub(crate) mod tests {
     use wsts::state_machine::PublicKeys;
 
     use super::*;
-    use crate::config::{GlobalConfig, RegisteredSignersInfo, SignerConfig};
+    use crate::config::{GlobalConfig, ParsedSignerEntries, SignerConfig};
 
     pub struct MockServerClient {
         pub server: TcpListener,
@@ -425,7 +422,7 @@ pub(crate) mod tests {
         let mut start_key_id = 1u32;
         let mut end_key_id = start_key_id;
         let mut signer_public_keys = HashMap::new();
-        let mut signer_slot_ids = HashMap::new();
+        let mut signer_slot_ids = vec![];
         let ecdsa_private_key = config.ecdsa_private_key;
         let ecdsa_public_key =
             ecdsa::PublicKey::new(&ecdsa_private_key).expect("Failed to create ecdsa public key");
@@ -459,7 +456,7 @@ pub(crate) mod tests {
                     &StacksPublicKey::from_slice(ecdsa_public_key.to_bytes().as_slice())
                         .expect("Failed to create stacks public key"),
                 );
-                signer_slot_ids.insert(address, signer_id); // Note in a real world situation, these would not always match
+                signer_slot_ids.push(signer_id); // Note in a real world situation, these would not always match
                 signer_ids.insert(address, signer_id);
 
                 continue;
@@ -486,7 +483,7 @@ pub(crate) mod tests {
                 &StacksPublicKey::from_slice(public_key.to_bytes().as_slice())
                     .expect("Failed to create stacks public key"),
             );
-            signer_slot_ids.insert(address, signer_id); // Note in a real world situation, these would not always match
+            signer_slot_ids.push(signer_id); // Note in a real world situation, these would not always match
             signer_ids.insert(address, signer_id);
             start_key_id = end_key_id;
         }
@@ -495,14 +492,14 @@ pub(crate) mod tests {
             signer_id: 0,
             signer_slot_id: 0,
             key_ids: signer_key_ids.get(&0).cloned().unwrap_or_default(),
-            registered_signers: RegisteredSignersInfo {
-                signer_slot_ids,
+            signer_entries: ParsedSignerEntries {
                 public_keys,
                 coordinator_key_ids,
                 signer_key_ids,
                 signer_ids,
                 signer_public_keys,
             },
+            signer_slot_ids,
             ecdsa_private_key: config.ecdsa_private_key,
             stacks_private_key: config.stacks_private_key,
             node_host: config.node_host,
diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index affd43ab2a..13fb77af78 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -225,19 +225,17 @@ impl StackerDB {
         Ok(transactions)
     }
 
-    /// Get the latest signer transactions from signer ids for the current reward cycle
+    /// Get this signer's latest transactions from stackerdb
     pub fn get_current_transactions_with_retry(
         &mut self,
-        signer_id: u32,
     ) -> Result<Vec<StacksTransaction>, ClientError> {
-        debug!("Signer #{signer_id}: Getting latest transactions from stacker db",);
         let Some(transactions_session) = self
             .signers_message_stackerdb_sessions
             .get_mut(&TRANSACTIONS_MSG_ID)
         else {
             return Err(ClientError::NotConnected);
         };
-        Self::get_transactions(transactions_session, &[signer_id])
+        Self::get_transactions(transactions_session, &[self.signer_slot_id])
     }
 
     /// Get the latest signer transactions from signer ids for the next reward cycle
diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index 471cec068f..da67e6f448 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -18,7 +18,7 @@ use std::net::SocketAddr;
 use blockstack_lib::burnchains::Txid;
 use blockstack_lib::chainstate::nakamoto::NakamotoBlock;
 use blockstack_lib::chainstate::stacks::boot::{
-    RewardSet, SIGNERS_NAME, SIGNERS_VOTING_FUNCTION_NAME, SIGNERS_VOTING_NAME,
+    NakamotoSignerEntry, SIGNERS_VOTING_FUNCTION_NAME, SIGNERS_VOTING_NAME,
 };
 use blockstack_lib::chainstate::stacks::{
     StacksTransaction, StacksTransactionSigner, TransactionAnchorMode, TransactionAuth,
@@ -34,20 +34,17 @@ use blockstack_lib::net::api::postblock_proposal::NakamotoBlockProposal;
 use blockstack_lib::util_lib::boot::{boot_code_addr, boot_code_id};
 use clarity::vm::types::{PrincipalData, QualifiedContractIdentifier};
 use clarity::vm::{ClarityName, ContractName, Value as ClarityValue};
-use hashbrown::{HashMap, HashSet};
 use serde_json::json;
-use slog::{slog_debug, slog_warn};
+use slog::slog_debug;
 use stacks_common::codec::StacksMessageCodec;
 use stacks_common::consts::{CHAIN_ID_MAINNET, CHAIN_ID_TESTNET};
+use stacks_common::debug;
 use stacks_common::types::chainstate::{StacksAddress, StacksPrivateKey, StacksPublicKey};
 use stacks_common::types::StacksEpochId;
-use stacks_common::{debug, warn};
-use wsts::curve::ecdsa;
 use wsts::curve::point::{Compressed, Point};
-use wsts::state_machine::PublicKeys;
 
 use crate::client::{retry_with_exponential_backoff, ClientError};
-use crate::config::{GlobalConfig, RegisteredSignersInfo};
+use crate::config::GlobalConfig;
 
 /// The Stacks signer client used to communicate with the stacks node
 #[derive(Clone, Debug)]
@@ -296,8 +293,11 @@ impl StacksClient {
         Ok(round)
     }
 
-    /// Get the reward set from the stacks node for the given reward cycle
-    pub fn get_reward_set(&self, reward_cycle: u64) -> Result<RewardSet, ClientError> {
+    /// Get the reward set signers from the stacks node for the given reward cycle
+    pub fn get_reward_set_signers(
+        &self,
+        reward_cycle: u64,
+    ) -> Result<Option<Vec<NakamotoSignerEntry>>, ClientError> {
         debug!("Getting reward set for reward cycle {reward_cycle}...");
         let send_request = || {
             self.stacks_node_client
@@ -310,104 +310,7 @@ impl StacksClient {
             return Err(ClientError::RequestFailure(response.status()));
         }
         let stackers_response = response.json::<GetStackersResponse>()?;
-        Ok(stackers_response.stacker_set)
-    }
-
-    /// Get the registered signers for a specific reward cycle
-    /// Returns None if no signers are registered or its not Nakamoto cycle
-    pub fn get_registered_signers_info(
-        &self,
-        reward_cycle: u64,
-    ) -> Result<Option<RegisteredSignersInfo>, ClientError> {
-        debug!("Getting registered signers for reward cycle {reward_cycle}...");
-        let reward_set = self.get_reward_set(reward_cycle)?;
-        let Some(reward_set_signers) = reward_set.signers else {
-            warn!("No reward set signers found for reward cycle {reward_cycle}.");
-            return Ok(None);
-        };
-        if reward_set_signers.is_empty() {
-            warn!("No registered signers found for reward cycle {reward_cycle}.");
-            return Ok(None);
-        }
-        // signer uses a Vec<u32> for its key_ids, but coordinator uses a HashSet for each signer since it needs to do lots of lookups
-        let mut weight_end = 1;
-        let mut coordinator_key_ids = HashMap::with_capacity(4000);
-        let mut signer_key_ids = HashMap::with_capacity(reward_set_signers.len());
-        let mut signer_ids = HashMap::with_capacity(reward_set_signers.len());
-        let mut public_keys = PublicKeys {
-            signers: HashMap::with_capacity(reward_set_signers.len()),
-            key_ids: HashMap::with_capacity(4000),
-        };
-        let mut signer_public_keys = HashMap::with_capacity(reward_set_signers.len());
-        for (i, entry) in reward_set_signers.iter().enumerate() {
-            let signer_id = u32::try_from(i).expect("FATAL: number of signers exceeds u32::MAX");
-            let ecdsa_public_key = ecdsa::PublicKey::try_from(entry.signing_key.as_slice()).map_err(|e| {
-                ClientError::CorruptedRewardSet(format!(
-                        "Reward cycle {reward_cycle} failed to convert signing key to ecdsa::PublicKey: {e}"
-                    ))
-                })?;
-            let signer_public_key = Point::try_from(&Compressed::from(ecdsa_public_key.to_bytes()))
-                .map_err(|e| {
-                    ClientError::CorruptedRewardSet(format!(
-                        "Reward cycle {reward_cycle} failed to convert signing key to Point: {e}"
-                    ))
-                })?;
-            let stacks_public_key = StacksPublicKey::from_slice(entry.signing_key.as_slice()).map_err(|e| {
-                    ClientError::CorruptedRewardSet(format!(
-                        "Reward cycle {reward_cycle} failed to convert signing key to StacksPublicKey: {e}"
-                    ))
-                })?;
-
-            let stacks_address = StacksAddress::p2pkh(self.mainnet, &stacks_public_key);
-
-            signer_ids.insert(stacks_address, signer_id);
-            signer_public_keys.insert(signer_id, signer_public_key);
-            let weight_start = weight_end;
-            weight_end = weight_start + entry.weight;
-            for key_id in weight_start..weight_end {
-                public_keys.key_ids.insert(key_id, ecdsa_public_key);
-                public_keys.signers.insert(signer_id, ecdsa_public_key);
-                coordinator_key_ids
-                    .entry(signer_id)
-                    .or_insert(HashSet::with_capacity(entry.weight as usize))
-                    .insert(key_id);
-                signer_key_ids
-                    .entry(signer_id)
-                    .or_insert(Vec::with_capacity(entry.weight as usize))
-                    .push(key_id);
-            }
-        }
-
-        let signer_set =
-            u32::try_from(reward_cycle % 2).expect("FATAL: reward_cycle % 2 exceeds u32::MAX");
-        let signer_stackerdb_contract_id = boot_code_id(SIGNERS_NAME, self.mainnet);
-        // Get the signer writers from the stacker-db to find the signer slot id
-        let signer_slots_weights = self
-            .get_stackerdb_signer_slots(&signer_stackerdb_contract_id, signer_set)
-            .unwrap();
-        let mut signer_slot_ids = HashMap::with_capacity(signer_slots_weights.len());
-        for (index, (address, _)) in signer_slots_weights.into_iter().enumerate() {
-            signer_slot_ids.insert(
-                address,
-                u32::try_from(index).expect("FATAL: number of signers exceeds u32::MAX"),
-            );
-        }
-
-        for address in signer_ids.keys() {
-            if !signer_slot_ids.contains_key(address) {
-                debug!("Signer {address} does not have a slot id in the stackerdb");
-                return Ok(None);
-            }
-        }
-
-        Ok(Some(RegisteredSignersInfo {
-            public_keys,
-            signer_key_ids,
-            signer_ids,
-            signer_slot_ids,
-            signer_public_keys,
-            coordinator_key_ids,
-        }))
+        Ok(stackers_response.stacker_set.signers)
     }
 
     /// Retreive the current pox data from the stacks node
@@ -687,7 +590,9 @@ mod tests {
 
     use blockstack_lib::chainstate::nakamoto::NakamotoBlockHeader;
     use blockstack_lib::chainstate::stacks::address::PoxAddress;
-    use blockstack_lib::chainstate::stacks::boot::{NakamotoSignerEntry, PoxStartCycleInfo};
+    use blockstack_lib::chainstate::stacks::boot::{
+        NakamotoSignerEntry, PoxStartCycleInfo, RewardSet,
+    };
     use blockstack_lib::chainstate::stacks::ThresholdSignature;
     use rand::thread_rng;
     use rand_core::RngCore;
@@ -1232,9 +1137,9 @@ mod tests {
         let stackers_response_json = serde_json::to_string(&stackers_response)
             .expect("Failed to serialize get stacker response");
         let response = format!("HTTP/1.1 200 OK\n\n{stackers_response_json}");
-        let h = spawn(move || mock.client.get_reward_set(0));
+        let h = spawn(move || mock.client.get_reward_set_signers(0));
         write_response(mock.server, response.as_bytes());
-        assert_eq!(h.join().unwrap().unwrap(), stacker_set);
+        assert_eq!(h.join().unwrap().unwrap(), stacker_set.signers);
     }
 
     #[test]
diff --git a/stacks-signer/src/config.rs b/stacks-signer/src/config.rs
index bb09d3262d..6eefa8cf5b 100644
--- a/stacks-signer/src/config.rs
+++ b/stacks-signer/src/config.rs
@@ -110,22 +110,20 @@ impl Network {
     }
 }
 
-/// The registered signer information for a specific reward cycle
+/// Parsed Reward Set
 #[derive(Debug, Clone)]
-pub struct RegisteredSignersInfo {
-    /// The signer to key ids mapping for the coordinator
-    pub coordinator_key_ids: HashMap<u32, HashSet<u32>>,
-    /// The signer to key ids mapping for the signers
-    pub signer_key_ids: HashMap<u32, Vec<u32>>,
-    /// The signer ids to wsts pubilc keys mapping
-    pub signer_public_keys: HashMap<u32, Point>,
-    /// The signer addresses mapped to their signer ids
+pub struct ParsedSignerEntries {
+    /// The signer addresses mapped to signer id
     pub signer_ids: HashMap<StacksAddress, u32>,
-    /// The signer slot id for a signer address registered in stackerdb
-    /// This corresponds to their unique index when voting in a reward cycle
-    pub signer_slot_ids: HashMap<StacksAddress, u32>,
-    /// The public keys for the reward cycle
+    /// The signer ids mapped to public key and key ids mapped to public keys
     pub public_keys: PublicKeys,
+    /// The signer ids mapped to key ids
+    pub signer_key_ids: HashMap<u32, Vec<u32>>,
+    /// The signer ids mapped to wsts public keys
+    pub signer_public_keys: HashMap<u32, Point>,
+    /// The signer ids mapped to a hash set of key ids
+    /// The wsts coordinator uses a hash set for each signer since it needs to do lots of lookups
+    pub coordinator_key_ids: HashMap<u32, HashSet<u32>>,
 }
 
 /// The Configuration info needed for an individual signer per reward cycle
@@ -133,14 +131,16 @@ pub struct RegisteredSignersInfo {
 pub struct SignerConfig {
     /// The reward cycle of the configuration
     pub reward_cycle: u64,
-    /// The signer ID assigned to this signer
+    /// The signer ID assigned to this signer to be used in DKG and Sign rounds
     pub signer_id: u32,
-    /// The index into the signers list of this signer's key (may be different from signer_id)
+    /// The signer stackerdb slot id (may be different from signer_id)
     pub signer_slot_id: u32,
     /// This signer's key ids
     pub key_ids: Vec<u32>,
     /// The registered signers for this reward cycle
-    pub registered_signers: RegisteredSignersInfo,
+    pub signer_entries: ParsedSignerEntries,
+    /// The signer slot ids of all signers registered for this reward cycle
+    pub signer_slot_ids: Vec<u32>,
     /// The Scalar representation of the private key for signer communication
     pub ecdsa_private_key: Scalar,
     /// The private key for this signer
diff --git a/stacks-signer/src/coordinator.rs b/stacks-signer/src/coordinator.rs
index 2c23fd0b32..234d1ade84 100644
--- a/stacks-signer/src/coordinator.rs
+++ b/stacks-signer/src/coordinator.rs
@@ -174,7 +174,7 @@ mod tests {
         let number_of_tests = 5;
         let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
         let public_keys = generate_signer_config(&config, 10, 4000)
-            .registered_signers
+            .signer_entries
             .public_keys;
         let mut results = Vec::new();
 
@@ -197,7 +197,7 @@ mod tests {
     ) -> Vec<Vec<u32>> {
         let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
         let public_keys = generate_signer_config(&config, 10, 4000)
-            .registered_signers
+            .signer_entries
             .public_keys;
         let mut results = Vec::new();
         let same_hash = generate_random_consensus_hash();
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 02fb494c6a..649dec7385 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -18,16 +18,20 @@ use std::sync::mpsc::Sender;
 use std::time::Duration;
 
 use blockstack_lib::chainstate::burn::ConsensusHashExtensions;
-use hashbrown::HashMap;
+use blockstack_lib::chainstate::stacks::boot::{NakamotoSignerEntry, SIGNERS_NAME};
+use blockstack_lib::util_lib::boot::boot_code_id;
+use hashbrown::{HashMap, HashSet};
 use libsigner::{SignerEvent, SignerRunLoop};
 use slog::{slog_debug, slog_error, slog_info, slog_warn};
-use stacks_common::types::chainstate::ConsensusHash;
+use stacks_common::types::chainstate::{ConsensusHash, StacksAddress, StacksPublicKey};
 use stacks_common::{debug, error, info, warn};
+use wsts::curve::ecdsa;
+use wsts::curve::point::{Compressed, Point};
 use wsts::state_machine::coordinator::State as CoordinatorState;
-use wsts::state_machine::OperationResult;
+use wsts::state_machine::{OperationResult, PublicKeys};
 
 use crate::client::{retry_with_exponential_backoff, ClientError, StacksClient};
-use crate::config::{GlobalConfig, SignerConfig};
+use crate::config::{GlobalConfig, ParsedSignerEntries, SignerConfig};
 use crate::signer::{Command as SignerCommand, Signer, State as SignerState};
 
 /// Which operation to perform
@@ -78,27 +82,116 @@ impl From<GlobalConfig> for RunLoop {
 }
 
 impl RunLoop {
+    /// Parse Nakamoto signer entries into relevant signer information
+    pub fn parse_nakamoto_signer_entries(
+        signers: &[NakamotoSignerEntry],
+        is_mainnet: bool,
+    ) -> ParsedSignerEntries {
+        let mut weight_end = 1;
+        let mut coordinator_key_ids = HashMap::with_capacity(4000);
+        let mut signer_key_ids = HashMap::with_capacity(signers.len());
+        let mut signer_ids = HashMap::with_capacity(signers.len());
+        let mut public_keys = PublicKeys {
+            signers: HashMap::with_capacity(signers.len()),
+            key_ids: HashMap::with_capacity(4000),
+        };
+        let mut signer_public_keys = HashMap::with_capacity(signers.len());
+        for (i, entry) in signers.iter().enumerate() {
+            // TODO: track these signer ids as non participating if any of the conversions fail
+            let signer_id = u32::try_from(i).expect("FATAL: number of signers exceeds u32::MAX");
+            let ecdsa_public_key = ecdsa::PublicKey::try_from(entry.signing_key.as_slice())
+                .expect("FATAL: corrupted signing key");
+            let signer_public_key = Point::try_from(&Compressed::from(ecdsa_public_key.to_bytes()))
+                .expect("FATAL: corrupted signing key");
+            let stacks_public_key = StacksPublicKey::from_slice(entry.signing_key.as_slice())
+                .expect("FATAL: Corrupted signing key");
+
+            let stacks_address = StacksAddress::p2pkh(is_mainnet, &stacks_public_key);
+            signer_ids.insert(stacks_address, signer_id);
+            signer_public_keys.insert(signer_id, signer_public_key);
+            let weight_start = weight_end;
+            weight_end = weight_start + entry.weight;
+            for key_id in weight_start..weight_end {
+                public_keys.key_ids.insert(key_id, ecdsa_public_key);
+                public_keys.signers.insert(signer_id, ecdsa_public_key);
+                coordinator_key_ids
+                    .entry(signer_id)
+                    .or_insert(HashSet::with_capacity(entry.weight as usize))
+                    .insert(key_id);
+                signer_key_ids
+                    .entry(signer_id)
+                    .or_insert(Vec::with_capacity(entry.weight as usize))
+                    .push(key_id);
+            }
+        }
+        ParsedSignerEntries {
+            signer_ids,
+            public_keys,
+            signer_key_ids,
+            signer_public_keys,
+            coordinator_key_ids,
+        }
+    }
+
+    /// Get the registered signers for a specific reward cycle
+    /// Returns None if no signers are registered or its not Nakamoto cycle
+    pub fn get_parsed_reward_set(
+        &self,
+        reward_cycle: u64,
+    ) -> Result<Option<ParsedSignerEntries>, ClientError> {
+        debug!("Getting registered signers for reward cycle {reward_cycle}...");
+        let Some(signers) = self.stacks_client.get_reward_set_signers(reward_cycle)? else {
+            warn!("No reward set signers found for reward cycle {reward_cycle}.");
+            return Ok(None);
+        };
+        if signers.is_empty() {
+            warn!("No registered signers found for reward cycle {reward_cycle}.");
+            return Ok(None);
+        }
+        Ok(Some(Self::parse_nakamoto_signer_entries(
+            &signers,
+            self.config.network.is_mainnet(),
+        )))
+    }
+
+    /// Get the stackerdb signer slots for a specific reward cycle
+    pub fn get_parsed_signer_slots(
+        &self,
+        stacks_client: &StacksClient,
+        reward_cycle: u64,
+    ) -> Result<HashMap<StacksAddress, u32>, ClientError> {
+        let signer_set =
+            u32::try_from(reward_cycle % 2).expect("FATAL: reward_cycle % 2 exceeds u32::MAX");
+        let signer_stackerdb_contract_id =
+            boot_code_id(SIGNERS_NAME, self.config.network.is_mainnet());
+        // Get the signer writers from the stacker-db to find the signer slot id
+        let stackerdb_signer_slots =
+            stacks_client.get_stackerdb_signer_slots(&signer_stackerdb_contract_id, signer_set)?;
+        let mut signer_slot_ids = HashMap::with_capacity(stackerdb_signer_slots.len());
+        for (index, (address, _)) in stackerdb_signer_slots.into_iter().enumerate() {
+            signer_slot_ids.insert(
+                address,
+                u32::try_from(index).expect("FATAL: number of signers exceeds u32::MAX"),
+            );
+        }
+        Ok(signer_slot_ids)
+    }
     /// Get a signer configuration for a specific reward cycle from the stacks node
     fn get_signer_config(&mut self, reward_cycle: u64) -> Option<SignerConfig> {
         // We can only register for a reward cycle if a reward set exists.
-        let registered_signers = self
-            .stacks_client
-            .get_registered_signers_info(reward_cycle).map_err(|e| {
-                error!(
-                    "Failed to retrieve registered signers info for reward cycle {reward_cycle}: {e}"
-                );
-                e
-            }).ok()??;
-
+        let signer_entries = self.get_parsed_reward_set(reward_cycle).ok()??;
+        let signer_slot_ids = self
+            .get_parsed_signer_slots(&self.stacks_client, reward_cycle)
+            .ok()?;
         let current_addr = self.stacks_client.get_signer_address();
 
-        let Some(signer_slot_id) = registered_signers.signer_slot_ids.get(current_addr) else {
+        let Some(signer_slot_id) = signer_slot_ids.get(current_addr) else {
             warn!(
                     "Signer {current_addr} was not found in stacker db. Must not be registered for this reward cycle {reward_cycle}."
                 );
             return None;
         };
-        let Some(signer_id) = registered_signers.signer_ids.get(current_addr) else {
+        let Some(signer_id) = signer_entries.signer_ids.get(current_addr) else {
             warn!(
                 "Signer {current_addr} was found in stacker db but not the reward set for reward cycle {reward_cycle}."
             );
@@ -107,7 +200,7 @@ impl RunLoop {
         info!(
             "Signer #{signer_id} ({current_addr}) is registered for reward cycle {reward_cycle}."
         );
-        let key_ids = registered_signers
+        let key_ids = signer_entries
             .signer_key_ids
             .get(signer_id)
             .cloned()
@@ -117,7 +210,8 @@ impl RunLoop {
             signer_id: *signer_id,
             signer_slot_id: *signer_slot_id,
             key_ids,
-            registered_signers,
+            signer_entries,
+            signer_slot_ids: signer_slot_ids.into_values().collect(),
             ecdsa_private_key: self.config.ecdsa_private_key,
             stacks_private_key: self.config.stacks_private_key,
             node_host: self.config.node_host,
@@ -156,20 +250,13 @@ impl RunLoop {
                     if signer.reward_cycle == prior_reward_cycle {
                         // The signers have been calculated for the next reward cycle. Update the current one
                         debug!("Signer #{}: Next reward cycle ({reward_cycle}) signer set calculated. Updating current reward cycle ({prior_reward_cycle}) signer.", signer.signer_id);
-                        signer.next_signers = new_signer_config
-                            .registered_signers
+                        signer.next_signer_addresses = new_signer_config
+                            .signer_entries
                             .signer_ids
                             .keys()
                             .copied()
                             .collect();
-                        signer.next_signer_ids = new_signer_config
-                            .registered_signers
-                            .signer_ids
-                            .values()
-                            .copied()
-                            .collect();
-                        signer.next_signer_slot_ids =
-                            new_signer_config.registered_signers.signer_slot_ids.clone();
+                        signer.next_signer_slot_ids = new_signer_config.signer_slot_ids.clone();
                     }
                 }
                 self.stacks_signers
@@ -301,3 +388,40 @@ impl SignerRunLoop<Vec<OperationResult>, RunLoopCommand> for RunLoop {
         None
     }
 }
+#[cfg(test)]
+mod tests {
+    use blockstack_lib::chainstate::stacks::boot::NakamotoSignerEntry;
+    use stacks_common::types::chainstate::{StacksPrivateKey, StacksPublicKey};
+
+    use super::RunLoop;
+
+    #[test]
+    fn parse_nakamoto_signer_entries_test() {
+        let nmb_signers = 10;
+        let weight = 10;
+        let mut signer_entries = Vec::with_capacity(nmb_signers);
+        for _ in 0..nmb_signers {
+            let key = StacksPublicKey::from_private(&StacksPrivateKey::new()).to_bytes_compressed();
+            let mut signing_key = [0u8; 33];
+            signing_key.copy_from_slice(&key);
+            signer_entries.push(NakamotoSignerEntry {
+                signing_key,
+                stacked_amt: 0,
+                weight,
+            });
+        }
+
+        let parsed_entries = RunLoop::parse_nakamoto_signer_entries(&signer_entries, false);
+        assert_eq!(parsed_entries.signer_ids.len(), nmb_signers);
+        let mut signer_ids = parsed_entries
+            .signer_ids
+            .into_values()
+            .into_iter()
+            .collect::<Vec<_>>();
+        signer_ids.sort();
+        assert_eq!(
+            signer_ids,
+            (0..nmb_signers as u32).into_iter().collect::<Vec<_>>()
+        );
+    }
+}
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index fd80138aa1..29960874c2 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -128,18 +128,14 @@ pub struct Signer {
     pub mainnet: bool,
     /// The signer id
     pub signer_id: u32,
-    /// The other signer ids for this signer's reward cycle
-    pub signer_ids: Vec<u32>,
-    /// The addresses of other signers mapped to their signer slot ID
-    pub signer_slot_ids: HashMap<StacksAddress, u32>,
+    /// The signer slot ids for the signers in the reward cycle
+    pub signer_slot_ids: Vec<u32>,
     /// The addresses of other signers
-    pub signers: Vec<StacksAddress>,
-    /// The other signer ids for the NEXT reward cycle's signers
-    pub next_signer_ids: Vec<u32>,
-    /// The signer addresses mapped to slot ID for the NEXT reward cycle's signers
-    pub next_signer_slot_ids: HashMap<StacksAddress, u32>,
+    pub signer_addresses: Vec<StacksAddress>,
+    /// The signer slot ids for the signers in the NEXT reward cycle
+    pub next_signer_slot_ids: Vec<u32>,
     /// The addresses of the signers for the NEXT reward cycle
-    pub next_signers: Vec<StacksAddress>,
+    pub next_signer_addresses: Vec<StacksAddress>,
     /// The reward cycle this signer belongs to
     pub reward_cycle: u64,
     /// The tx fee in uSTX to use if the epoch is pre Nakamoto (Epoch 3.0)
@@ -154,9 +150,9 @@ impl From<SignerConfig> for Signer {
     fn from(signer_config: SignerConfig) -> Self {
         let stackerdb = StackerDB::from(&signer_config);
 
-        let num_signers = u32::try_from(signer_config.registered_signers.public_keys.signers.len())
+        let num_signers = u32::try_from(signer_config.signer_entries.public_keys.signers.len())
             .expect("FATAL: Too many registered signers to fit in a u32");
-        let num_keys = u32::try_from(signer_config.registered_signers.public_keys.key_ids.len())
+        let num_keys = u32::try_from(signer_config.signer_entries.public_keys.key_ids.len())
             .expect("FATAL: Too many key ids to fit in a u32");
         let threshold = (num_keys as f64 * 7_f64 / 10_f64).ceil() as u32;
         let dkg_threshold = (num_keys as f64 * 9_f64 / 10_f64).ceil() as u32;
@@ -172,8 +168,8 @@ impl From<SignerConfig> for Signer {
             dkg_end_timeout: signer_config.dkg_end_timeout,
             nonce_timeout: signer_config.nonce_timeout,
             sign_timeout: signer_config.sign_timeout,
-            signer_key_ids: signer_config.registered_signers.coordinator_key_ids,
-            signer_public_keys: signer_config.registered_signers.signer_public_keys,
+            signer_key_ids: signer_config.signer_entries.coordinator_key_ids,
+            signer_public_keys: signer_config.signer_entries.signer_public_keys,
         };
 
         let coordinator = FireCoordinator::new(coordinator_config);
@@ -184,10 +180,10 @@ impl From<SignerConfig> for Signer {
             signer_config.signer_id,
             signer_config.key_ids,
             signer_config.ecdsa_private_key,
-            signer_config.registered_signers.public_keys.clone(),
+            signer_config.signer_entries.public_keys.clone(),
         );
         let coordinator_selector =
-            CoordinatorSelector::from(signer_config.registered_signers.public_keys);
+            CoordinatorSelector::from(signer_config.signer_entries.public_keys);
 
         debug!(
             "Signer #{}: initial coordinator is signer {}",
@@ -204,22 +200,14 @@ impl From<SignerConfig> for Signer {
             stackerdb,
             mainnet: signer_config.mainnet,
             signer_id: signer_config.signer_id,
-            signer_ids: signer_config
-                .registered_signers
+            signer_addresses: signer_config
+                .signer_entries
                 .signer_ids
-                .values()
-                .copied()
+                .into_keys()
                 .collect(),
-            signer_slot_ids: signer_config.registered_signers.signer_slot_ids,
-            signers: signer_config
-                .registered_signers
-                .signer_ids
-                .keys()
-                .copied()
-                .collect(),
-            next_signer_ids: vec![],
-            next_signer_slot_ids: HashMap::new(),
-            next_signers: vec![],
+            signer_slot_ids: signer_config.signer_slot_ids.clone(),
+            next_signer_slot_ids: vec![],
+            next_signer_addresses: vec![],
             reward_cycle: signer_config.reward_cycle,
             tx_fee_ustx: signer_config.tx_fee_ustx,
             coordinator_selector,
@@ -714,7 +702,7 @@ impl Signer {
     ) -> Result<Vec<StacksTransaction>, ClientError> {
         let transactions: Vec<_> = self
             .stackerdb
-            .get_current_transactions_with_retry(self.signer_id)?
+            .get_current_transactions_with_retry()?
             .into_iter()
             .filter_map(|tx| {
                 if !NakamotoSigners::valid_vote_transaction(nonces, &tx, self.mainnet) {
@@ -731,7 +719,7 @@ impl Signer {
         &mut self,
         stacks_client: &StacksClient,
     ) -> Result<Vec<StacksTransaction>, ClientError> {
-        if self.next_signer_ids.is_empty() {
+        if self.next_signer_slot_ids.is_empty() {
             debug!(
                 "Signer #{}: No next signers. Skipping transaction retrieval.",
                 self.signer_id
@@ -739,10 +727,10 @@ impl Signer {
             return Ok(vec![]);
         }
         // Get all the account nonces for the next signers
-        let account_nonces = self.get_account_nonces(stacks_client, &self.next_signers);
+        let account_nonces = self.get_account_nonces(stacks_client, &self.next_signer_addresses);
         let transactions: Vec<_> = self
             .stackerdb
-            .get_next_transactions_with_retry(&self.next_signer_ids)?;
+            .get_next_transactions_with_retry(&self.next_signer_slot_ids)?;
         let mut filtered_transactions = std::collections::HashMap::new();
         NakamotoSigners::update_filtered_transactions(
             &mut filtered_transactions,
@@ -874,7 +862,7 @@ impl Signer {
         // Get our current nonce from the stacks node and compare it against what we have sitting in the stackerdb instance
         let signer_address = stacks_client.get_signer_address();
         // Retreieve ALL account nonces as we may have transactions from other signers in our stackerdb slot that we care about
-        let account_nonces = self.get_account_nonces(stacks_client, &self.signers);
+        let account_nonces = self.get_account_nonces(stacks_client, &self.signer_addresses);
         let account_nonce = account_nonces.get(signer_address).unwrap_or(&0);
         let signer_transactions = retry_with_exponential_backoff(|| {
             self.get_signer_transactions(&account_nonces)

From 73fd5e0309b5f62135a71c2dd6f3dea8ba406977 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Thu, 29 Feb 2024 10:45:19 -0500
Subject: [PATCH 0993/1166] Wrap signer slot ID in a struct to prevent
 conflation with signer ID

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/mod.rs         |  7 ++++---
 stacks-signer/src/client/stackerdb.rs   | 21 +++++++++++----------
 stacks-signer/src/config.rs             |  6 ++++--
 stacks-signer/src/runloop.rs            | 16 +++++++---------
 stacks-signer/src/signer.rs             | 16 +++++++++++++---
 testnet/stacks-node/src/tests/signer.rs |  8 +++++---
 6 files changed, 44 insertions(+), 30 deletions(-)

diff --git a/stacks-signer/src/client/mod.rs b/stacks-signer/src/client/mod.rs
index 424564a9fb..63dc0e9a1f 100644
--- a/stacks-signer/src/client/mod.rs
+++ b/stacks-signer/src/client/mod.rs
@@ -154,6 +154,7 @@ pub(crate) mod tests {
 
     use super::*;
     use crate::config::{GlobalConfig, ParsedSignerEntries, SignerConfig};
+    use crate::signer::SignerSlotID;
 
     pub struct MockServerClient {
         pub server: TcpListener,
@@ -456,7 +457,7 @@ pub(crate) mod tests {
                     &StacksPublicKey::from_slice(ecdsa_public_key.to_bytes().as_slice())
                         .expect("Failed to create stacks public key"),
                 );
-                signer_slot_ids.push(signer_id); // Note in a real world situation, these would not always match
+                signer_slot_ids.push(SignerSlotID(signer_id));
                 signer_ids.insert(address, signer_id);
 
                 continue;
@@ -483,14 +484,14 @@ pub(crate) mod tests {
                 &StacksPublicKey::from_slice(public_key.to_bytes().as_slice())
                     .expect("Failed to create stacks public key"),
             );
-            signer_slot_ids.push(signer_id); // Note in a real world situation, these would not always match
+            signer_slot_ids.push(SignerSlotID(signer_id));
             signer_ids.insert(address, signer_id);
             start_key_id = end_key_id;
         }
         SignerConfig {
             reward_cycle,
             signer_id: 0,
-            signer_slot_id: 0,
+            signer_slot_id: SignerSlotID(rand::thread_rng().gen_range(0..num_signers)), // Give a random signer slot id between 0 and num_signers
             key_ids: signer_key_ids.get(&0).cloned().unwrap_or_default(),
             signer_entries: ParsedSignerEntries {
                 public_keys,
diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index 13fb77af78..77f4d679d9 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -33,6 +33,7 @@ use stacks_common::{debug, warn};
 use super::ClientError;
 use crate::client::retry_with_exponential_backoff;
 use crate::config::SignerConfig;
+use crate::signer::SignerSlotID;
 
 /// The StackerDB client for communicating with the .signers contract
 pub struct StackerDB {
@@ -42,9 +43,9 @@ pub struct StackerDB {
     /// The private key used in all stacks node communications
     stacks_private_key: StacksPrivateKey,
     /// A map of a message ID to last chunk version for each session
-    slot_versions: HashMap<u32, HashMap<u32, u32>>,
+    slot_versions: HashMap<u32, HashMap<SignerSlotID, u32>>,
     /// The signer slot ID -- the index into the signer list for this signer daemon's signing key.
-    signer_slot_id: u32,
+    signer_slot_id: SignerSlotID,
     /// The reward cycle of the connecting signer
     reward_cycle: u64,
     /// The stacker-db transaction msg session for the NEXT reward cycle
@@ -69,7 +70,7 @@ impl StackerDB {
         stacks_private_key: StacksPrivateKey,
         is_mainnet: bool,
         reward_cycle: u64,
-        signer_slot_id: u32,
+        signer_slot_id: SignerSlotID,
     ) -> Self {
         let mut signers_message_stackerdb_sessions = HashMap::new();
         let stackerdb_issuer = boot_code_addr(is_mainnet);
@@ -134,7 +135,7 @@ impl StackerDB {
                 1
             };
 
-            let mut chunk = StackerDBChunkData::new(slot_id, slot_version, message_bytes.clone());
+            let mut chunk = StackerDBChunkData::new(slot_id.0, slot_version, message_bytes.clone());
             chunk.sign(&self.stacks_private_key)?;
 
             let Some(session) = self.signers_message_stackerdb_sessions.get_mut(&msg_id) else {
@@ -184,11 +185,11 @@ impl StackerDB {
     /// Get the transactions from stackerdb for the signers
     fn get_transactions(
         transactions_session: &mut StackerDBSession,
-        signer_ids: &[u32],
+        signer_ids: &[SignerSlotID],
     ) -> Result<Vec<StacksTransaction>, ClientError> {
         let send_request = || {
             transactions_session
-                .get_latest_chunks(signer_ids)
+                .get_latest_chunks(&signer_ids.iter().map(|id| id.0).collect::<Vec<_>>())
                 .map_err(backoff::Error::transient)
         };
         let chunk_ack = retry_with_exponential_backoff(send_request)?;
@@ -241,7 +242,7 @@ impl StackerDB {
     /// Get the latest signer transactions from signer ids for the next reward cycle
     pub fn get_next_transactions_with_retry(
         &mut self,
-        signer_ids: &[u32],
+        signer_ids: &[SignerSlotID],
     ) -> Result<Vec<StacksTransaction>, ClientError> {
         debug!("Getting latest chunks from stackerdb for the following signers: {signer_ids:?}",);
         Self::get_transactions(&mut self.next_transaction_session, signer_ids)
@@ -253,7 +254,7 @@ impl StackerDB {
     }
 
     /// Retrieve the signer slot ID
-    pub fn get_signer_slot_id(&mut self) -> u32 {
+    pub fn get_signer_slot_id(&mut self) -> SignerSlotID {
         self.signer_slot_id
     }
 }
@@ -300,8 +301,8 @@ mod tests {
         let signer_message = SignerMessage::Transactions(vec![tx.clone()]);
         let message = signer_message.serialize_to_vec();
 
-        let signer_ids = vec![0, 1];
-        let h = spawn(move || stackerdb.get_next_transactions_with_retry(&signer_ids));
+        let signer_slot_ids = vec![SignerSlotID(0), SignerSlotID(1)];
+        let h = spawn(move || stackerdb.get_next_transactions_with_retry(&signer_slot_ids));
         let mut response_bytes = b"HTTP/1.1 200 OK\n\n".to_vec();
         response_bytes.extend(message);
         let mock_server = mock_server_from_config(&config);
diff --git a/stacks-signer/src/config.rs b/stacks-signer/src/config.rs
index 6eefa8cf5b..d8c7b4a8e9 100644
--- a/stacks-signer/src/config.rs
+++ b/stacks-signer/src/config.rs
@@ -32,6 +32,8 @@ use wsts::curve::point::Point;
 use wsts::curve::scalar::Scalar;
 use wsts::state_machine::PublicKeys;
 
+use crate::signer::SignerSlotID;
+
 const EVENT_TIMEOUT_MS: u64 = 5000;
 // Default transaction fee in microstacks (if unspecificed in the config file)
 // TODO: Use the fee estimation endpoint to get the default fee.
@@ -134,13 +136,13 @@ pub struct SignerConfig {
     /// The signer ID assigned to this signer to be used in DKG and Sign rounds
     pub signer_id: u32,
     /// The signer stackerdb slot id (may be different from signer_id)
-    pub signer_slot_id: u32,
+    pub signer_slot_id: SignerSlotID,
     /// This signer's key ids
     pub key_ids: Vec<u32>,
     /// The registered signers for this reward cycle
     pub signer_entries: ParsedSignerEntries,
     /// The signer slot ids of all signers registered for this reward cycle
-    pub signer_slot_ids: Vec<u32>,
+    pub signer_slot_ids: Vec<SignerSlotID>,
     /// The Scalar representation of the private key for signer communication
     pub ecdsa_private_key: Scalar,
     /// The private key for this signer
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 649dec7385..c0ec846acd 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -32,7 +32,7 @@ use wsts::state_machine::{OperationResult, PublicKeys};
 
 use crate::client::{retry_with_exponential_backoff, ClientError, StacksClient};
 use crate::config::{GlobalConfig, ParsedSignerEntries, SignerConfig};
-use crate::signer::{Command as SignerCommand, Signer, State as SignerState};
+use crate::signer::{Command as SignerCommand, Signer, SignerSlotID, State as SignerState};
 
 /// Which operation to perform
 #[derive(PartialEq, Clone, Debug)]
@@ -159,7 +159,7 @@ impl RunLoop {
         &self,
         stacks_client: &StacksClient,
         reward_cycle: u64,
-    ) -> Result<HashMap<StacksAddress, u32>, ClientError> {
+    ) -> Result<HashMap<StacksAddress, SignerSlotID>, ClientError> {
         let signer_set =
             u32::try_from(reward_cycle % 2).expect("FATAL: reward_cycle % 2 exceeds u32::MAX");
         let signer_stackerdb_contract_id =
@@ -171,7 +171,9 @@ impl RunLoop {
         for (index, (address, _)) in stackerdb_signer_slots.into_iter().enumerate() {
             signer_slot_ids.insert(
                 address,
-                u32::try_from(index).expect("FATAL: number of signers exceeds u32::MAX"),
+                SignerSlotID(
+                    u32::try_from(index).expect("FATAL: number of signers exceeds u32::MAX"),
+                ),
             );
         }
         Ok(signer_slot_ids)
@@ -413,15 +415,11 @@ mod tests {
 
         let parsed_entries = RunLoop::parse_nakamoto_signer_entries(&signer_entries, false);
         assert_eq!(parsed_entries.signer_ids.len(), nmb_signers);
-        let mut signer_ids = parsed_entries
-            .signer_ids
-            .into_values()
-            .into_iter()
-            .collect::<Vec<_>>();
+        let mut signer_ids = parsed_entries.signer_ids.into_values().collect::<Vec<_>>();
         signer_ids.sort();
         assert_eq!(
             signer_ids,
-            (0..nmb_signers as u32).into_iter().collect::<Vec<_>>()
+            (0..nmb_signers).map(|id| id as u32).collect::<Vec<_>>()
         );
     }
 }
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index 29960874c2..59962e5ae5 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -46,6 +46,16 @@ use crate::client::{retry_with_exponential_backoff, ClientError, StackerDB, Stac
 use crate::config::SignerConfig;
 use crate::coordinator::CoordinatorSelector;
 
+/// The signer StackerDB slot ID, purposefully wrapped to prevent conflation with SignerID
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Copy, PartialOrd, Ord)]
+pub struct SignerSlotID(pub u32);
+
+impl std::fmt::Display for SignerSlotID {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
 /// Additional Info about a proposed block
 pub struct BlockInfo {
     /// The block we are considering
@@ -129,11 +139,11 @@ pub struct Signer {
     /// The signer id
     pub signer_id: u32,
     /// The signer slot ids for the signers in the reward cycle
-    pub signer_slot_ids: Vec<u32>,
+    pub signer_slot_ids: Vec<SignerSlotID>,
     /// The addresses of other signers
     pub signer_addresses: Vec<StacksAddress>,
     /// The signer slot ids for the signers in the NEXT reward cycle
-    pub next_signer_slot_ids: Vec<u32>,
+    pub next_signer_slot_ids: Vec<SignerSlotID>,
     /// The addresses of the signers for the NEXT reward cycle
     pub next_signer_addresses: Vec<StacksAddress>,
     /// The reward cycle this signer belongs to
@@ -881,7 +891,7 @@ impl Signer {
             .map(|tx| tx.get_origin_nonce().wrapping_add(1))
             .unwrap_or(*account_nonce);
         match stacks_client.build_vote_for_aggregate_public_key(
-            self.stackerdb.get_signer_slot_id(),
+            self.stackerdb.get_signer_slot_id().0,
             self.coordinator.current_dkg_id,
             *dkg_public_key,
             self.reward_cycle,
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index 3fd265d798..c0c2e72e2b 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -42,7 +42,7 @@ use stacks_common::util::secp256k1::MessageSignature;
 use stacks_signer::client::{StackerDB, StacksClient};
 use stacks_signer::config::{build_signer_config_tomls, GlobalConfig as SignerConfig, Network};
 use stacks_signer::runloop::RunLoopCommand;
-use stacks_signer::signer::Command as SignerCommand;
+use stacks_signer::signer::{Command as SignerCommand, SignerSlotID};
 use tracing_subscriber::prelude::*;
 use tracing_subscriber::{fmt, EnvFilter};
 use wsts::common::Signature;
@@ -531,7 +531,7 @@ impl SignerTest {
             .unwrap()
     }
 
-    fn get_signer_index(&self, reward_cycle: u64) -> u32 {
+    fn get_signer_index(&self, reward_cycle: u64) -> SignerSlotID {
         let valid_signer_set =
             u32::try_from(reward_cycle % 2).expect("FATAL: reward_cycle % 2 exceeds u32::MAX");
         let signer_stackerdb_contract_id = boot_code_id(SIGNERS_NAME, false);
@@ -541,7 +541,9 @@ impl SignerTest {
             .expect("FATAL: failed to get signer slots from stackerdb")
             .iter()
             .position(|(address, _)| address == self.stacks_client.get_signer_address())
-            .map(|pos| u32::try_from(pos).expect("FATAL: number of signers exceeds u32::MAX"))
+            .map(|pos| {
+                SignerSlotID(u32::try_from(pos).expect("FATAL: number of signers exceeds u32::MAX"))
+            })
             .expect("FATAL: signer not registered")
     }
 

From 16c07e63a90fc4f7d0fe4937d977e6a64cee6ec3 Mon Sep 17 00:00:00 2001
From: BowTiedRadone <bowtiedradone@gmail.com>
Date: Fri, 1 Mar 2024 20:36:50 +0200
Subject: [PATCH 0994/1166] added property tests for pox-4 read only functions

---
 .../tests/pox-4/pox-4.prop.test.ts            | 434 ++++++++++++++++++
 1 file changed, 434 insertions(+)
 create mode 100644 contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts

diff --git a/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts b/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
new file mode 100644
index 0000000000..65dc88cc08
--- /dev/null
+++ b/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
@@ -0,0 +1,434 @@
+import Cl, { ClarityType, bufferCV, isClarityType } from "@stacks/transactions";
+import { assert, describe, expect, it } from "vitest";
+import fc from "fast-check";
+
+const POX_4 = "pox-4";
+const GET_POX_INFO = "get-pox-info";
+
+describe("test pox-4 contract read only functions", () => {
+  it("should return correct reward-cycle-to-burn-height", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.nat(),
+        (account, reward_cycle) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            POX_4,
+            GET_POX_INFO,
+            [],
+            account
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+          const first_burn_block_height =
+            pox_4_info.value.data["first-burnchain-block-height"];
+          const reward_cycle_length =
+            pox_4_info.value.data["reward-cycle-length"];
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "reward-cycle-to-burn-height",
+            [Cl.uintCV(reward_cycle)],
+            account
+          );
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.UInt));
+          assert(isClarityType(first_burn_block_height, ClarityType.UInt));
+          assert(isClarityType(reward_cycle_length, ClarityType.UInt));
+
+          const expected =
+            Number(first_burn_block_height.value) +
+            Number(reward_cycle_length.value) * reward_cycle;
+          expect(actual).toBeUint(expected);
+        }
+      ),
+      { numRuns: 300 }
+    );
+  });
+
+  it("should return correct burn-height-to-reward-cycle", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.nat(),
+        (account, burn_height) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            POX_4,
+            GET_POX_INFO,
+            [],
+            account
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+          const first_burn_block_height =
+            pox_4_info.value.data["first-burnchain-block-height"];
+          const reward_cycle_length =
+            pox_4_info.value.data["reward-cycle-length"];
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "burn-height-to-reward-cycle",
+            [Cl.uintCV(burn_height)],
+            account
+          );
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.UInt));
+          assert(isClarityType(first_burn_block_height, ClarityType.UInt));
+          assert(isClarityType(reward_cycle_length, ClarityType.UInt));
+          const expected = Math.floor(
+            (burn_height - Number(first_burn_block_height.value)) /
+              Number(reward_cycle_length.value)
+          );
+          expect(actual).toBeUint(expected);
+        }
+      ),
+      { numRuns: 300 }
+    );
+  });
+
+  it("should return none stacker-info", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.constantFrom(...simnet.getAccounts().values()),
+        (stacker, caller) => {
+          // Arrange
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "get-stacker-info",
+            [Cl.principalCV(stacker)],
+            caller
+          );
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.OptionalNone));
+          expect(actual).toBeNone();
+        }
+      )
+    );
+  });
+
+  it("should return correct check-caller-allowed", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        (caller) => {
+          // Arrange
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "check-caller-allowed",
+            [],
+            caller
+          );
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.BoolTrue));
+          expect(actual).toBeBool(true);
+        }
+      )
+    );
+  });
+
+  it("should return u0 get-reward-set-size", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.nat(),
+        (caller, reward_cycle) => {
+          // Arrange
+          const expected = 0;
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "get-reward-set-size",
+            [Cl.uintCV(reward_cycle)],
+            caller
+          );
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.UInt));
+          expect(actual).toBeUint(expected);
+        }
+      )
+    );
+  });
+
+  it("should return u0 get-total-ustx-stacked", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.nat(),
+        (caller, reward_cycle) => {
+          // Arrange
+          const expected = 0;
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "get-total-ustx-stacked",
+            [Cl.uintCV(reward_cycle)],
+            caller
+          );
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.UInt));
+          expect(actual).toBeUint(expected);
+        }
+      )
+    );
+  });
+
+  it("should return none get-reward-set-pox-address", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.nat(),
+        fc.nat(),
+        (caller, index, reward_cycle) => {
+          // Arrange
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "get-reward-set-pox-address",
+            [Cl.uintCV(index), Cl.uintCV(reward_cycle)],
+            caller
+          );
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.OptionalNone));
+          expect(actual).toBeNone();
+        }
+      )
+    );
+  });
+
+  it("should return correct get-stacking-minimum", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        (caller) => {
+          // Arrange
+          const testnet_stacking_threshold_25 = 8000;
+
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            POX_4,
+            GET_POX_INFO,
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+          const stx_liq_supply =
+            pox_4_info.value.data["total-liquid-supply-ustx"];
+
+          assert(isClarityType(stx_liq_supply, ClarityType.UInt));
+          const expected = Math.floor(
+            Number(stx_liq_supply.value) / testnet_stacking_threshold_25
+          );
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "get-stacking-minimum",
+            [],
+            caller
+          );
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.UInt));
+          expect(actual).toBeUint(expected);
+        }
+      )
+    );
+  });
+
+  it("should return correct check-pox-addr-version", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.nat({ max: 255 }),
+        (caller, version) => {
+          // Arrange
+          const expected = version > 6 ? false : true;
+
+          // Act
+          let { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "check-pox-addr-version",
+            [Cl.bufferCV(Uint8Array.from([version]))],
+            caller
+          );
+
+          // Assert
+          assert(
+            isClarityType(
+              actual,
+              expected ? ClarityType.BoolTrue : ClarityType.BoolFalse
+            )
+          );
+          expect(actual).toBeBool(expected);
+        }
+      )
+    );
+  });
+
+  it("should return correct check-pox-lock-period", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.nat(),
+        (caller, reward_cycles) => {
+          // Arrange
+          const expected =
+            reward_cycles > 0 && reward_cycles <= 12 ? true : false;
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "check-pox-lock-period",
+            [Cl.uintCV(reward_cycles)],
+            caller
+          );
+
+          // Assert
+          assert(
+            isClarityType(
+              actual,
+              expected ? ClarityType.BoolTrue : ClarityType.BoolFalse
+            )
+          );
+          expect(actual).toBeBool(expected);
+        }
+      )
+    ),
+      { numRuns: 250 };
+  });
+
+  it("should return correct can-stack-stx", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.nat({ max: 255 }),
+        fc.array(fc.nat({ max: 255 }), { maxLength: 32 }),
+        fc.bigInt({ min: 0n, max: 340282366920938463463374607431768211455n }),
+        fc.nat(),
+        fc.nat(),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const testnet_stacking_threshold_25 = 8000;
+
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            POX_4,
+            GET_POX_INFO,
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+          const stacking_valid_amount = amount_ustx > 0;
+          const pox_lock_period_valid = num_cycles > 0 && num_cycles <= 12;
+          const pox_version_valid = version <= 6;
+          const pox_hashbytes_valid =
+            hashbytes.length === 20 || hashbytes.length === 32;
+          const stx_liq_supply =
+            pox_4_info.value.data["total-liquid-supply-ustx"];
+
+          assert(isClarityType(stx_liq_supply, ClarityType.UInt));
+          const stacking_threshold_met =
+            amount_ustx >=
+            Math.floor(
+              Number(stx_liq_supply.value) / testnet_stacking_threshold_25
+            );
+          const expectedResponseErr = !stacking_threshold_met
+            ? 11
+            : !stacking_valid_amount
+            ? 18
+            : !pox_lock_period_valid
+            ? 2
+            : !pox_version_valid
+            ? 13
+            : !pox_hashbytes_valid
+            ? 13
+            : 0;
+          const expectedResponseOk = true;
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "can-stack-stx",
+            [
+              Cl.tupleCV({
+                version: bufferCV(Uint8Array.from([version])),
+                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uintCV(amount_ustx),
+              Cl.uintCV(first_rew_cycle),
+              Cl.uintCV(num_cycles),
+            ],
+            caller
+          );
+
+          // Assert
+          assert(
+            isClarityType(
+              actual,
+              stacking_threshold_met &&
+                stacking_valid_amount &&
+                pox_lock_period_valid &&
+                pox_version_valid &&
+                pox_hashbytes_valid
+                ? ClarityType.ResponseOk
+                : ClarityType.ResponseErr
+            )
+          );
+
+          assert(
+            isClarityType(
+              actual.value,
+              stacking_threshold_met &&
+                stacking_valid_amount &&
+                pox_lock_period_valid &&
+                pox_version_valid &&
+                pox_hashbytes_valid
+                ? ClarityType.BoolTrue
+                : ClarityType.Int
+            )
+          );
+          if (expectedResponseErr === 0) {
+            expect(actual).toBeOk(
+              Cl.responseOkCV(Cl.boolCV(expectedResponseOk))
+            );
+            expect(actual.value).toBeBool(expectedResponseOk);
+          } else {
+            expect(actual).toBeErr(Cl.intCV(expectedResponseErr));
+            expect(actual.value).toBeInt(expectedResponseErr);
+          }
+        }
+      ),
+      { numRuns: 300 }
+    );
+  });
+});

From 301fb2056bfb2b2d3c66f2e287ee488217d06e67 Mon Sep 17 00:00:00 2001
From: BowTiedRadone <bowtiedradone@gmail.com>
Date: Fri, 1 Mar 2024 20:46:36 +0200
Subject: [PATCH 0995/1166] rename get-stacker-info test

---
 contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts b/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
index 65dc88cc08..54d5f5dd22 100644
--- a/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
+++ b/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
@@ -94,7 +94,7 @@ describe("test pox-4 contract read only functions", () => {
     );
   });
 
-  it("should return none stacker-info", () => {
+  it("should return none get-stacker-info", () => {
     fc.assert(
       fc.property(
         fc.constantFrom(...simnet.getAccounts().values()),

From aa0f6d7e4ba422b126bd4239589f9b7e6b9f0db8 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Tue, 27 Feb 2024 11:49:38 -0500
Subject: [PATCH 0996/1166] chore: Remove unnecessary `sha2-asm` dependency

---
 Cargo.lock         | 12 +-----------
 clarity/Cargo.toml |  3 ---
 2 files changed, 1 insertion(+), 14 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index aedba0ffaa..d4cf3e3c08 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -730,7 +730,6 @@ dependencies = [
  "serde_derive",
  "serde_json",
  "serde_stacker",
- "sha2-asm 0.5.5",
  "slog",
  "stacks-common",
  "time 0.2.27",
@@ -3298,16 +3297,7 @@ dependencies = [
  "cfg-if 1.0.0",
  "cpufeatures",
  "digest 0.10.7",
- "sha2-asm 0.6.3",
-]
-
-[[package]]
-name = "sha2-asm"
-version = "0.5.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a7c2f225be6502f2134e6bbb35bb5e2957e41ffa0495ed08bce2e2b4ca885da4"
-dependencies = [
- "cc",
+ "sha2-asm",
 ]
 
 [[package]]
diff --git a/clarity/Cargo.toml b/clarity/Cargo.toml
index c0b82a7fd1..4d51cf3e4e 100644
--- a/clarity/Cargo.toml
+++ b/clarity/Cargo.toml
@@ -56,6 +56,3 @@ developer-mode = []
 slog_json = ["stacks_common/slog_json"]
 testing = []
 
-[target.'cfg(all(target_arch = "x86_64", not(target_env = "msvc")))'.dependencies]
-sha2-asm = "0.5.3"
-

From 1999ab5f447242fb17fe3bc4560ec8b6714ecb01 Mon Sep 17 00:00:00 2001
From: wileyj <2847772+wileyj@users.noreply.github.com>
Date: Fri, 1 Mar 2024 17:01:51 -0800
Subject: [PATCH 0997/1166] remove comments, switch to bookworm images

---
 .github/actions/dockerfiles/Dockerfile.debian-source | 2 +-
 Dockerfile.debian                                    | 5 ++---
 build-scripts/Dockerfile.linux-glibc-arm64           | 5 ++---
 build-scripts/Dockerfile.linux-glibc-armv7           | 5 ++---
 build-scripts/Dockerfile.linux-glibc-x64             | 4 ++--
 build-scripts/Dockerfile.linux-musl-arm64            | 4 ++--
 build-scripts/Dockerfile.linux-musl-armv7            | 4 ++--
 build-scripts/Dockerfile.linux-musl-x64              | 1 -
 build-scripts/Dockerfile.macos-arm64                 | 4 ++--
 build-scripts/Dockerfile.macos-x64                   | 4 ++--
 build-scripts/Dockerfile.windows-x64                 | 6 +++---
 11 files changed, 20 insertions(+), 24 deletions(-)

diff --git a/.github/actions/dockerfiles/Dockerfile.debian-source b/.github/actions/dockerfiles/Dockerfile.debian-source
index 34ab555018..b8da585fe2 100644
--- a/.github/actions/dockerfiles/Dockerfile.debian-source
+++ b/.github/actions/dockerfiles/Dockerfile.debian-source
@@ -1,4 +1,4 @@
-FROM rust:bullseye as build
+FROM rust:bookworm as build
 
 ARG STACKS_NODE_VERSION="No Version Info"
 ARG GIT_BRANCH='No Branch Info'
diff --git a/Dockerfile.debian b/Dockerfile.debian
index 4b9a56b8c5..8b6759527e 100644
--- a/Dockerfile.debian
+++ b/Dockerfile.debian
@@ -1,4 +1,4 @@
-FROM rust:bullseye as build
+FROM rust:bookworm as build
 
 ARG STACKS_NODE_VERSION="No Version Info"
 ARG GIT_BRANCH='No Branch Info'
@@ -14,9 +14,8 @@ RUN cd testnet/stacks-node && cargo build --features monitoring_prom,slog_json -
 
 RUN cp target/release/stacks-node /out
 
-FROM debian:bullseye-slim
+FROM debian:bookworm-slim
 
-RUN apt update && apt install -y netcat
 COPY --from=build /out/ /bin/
 
 CMD ["stacks-node", "mainnet"]
diff --git a/build-scripts/Dockerfile.linux-glibc-arm64 b/build-scripts/Dockerfile.linux-glibc-arm64
index 2e0587bac6..0d13237878 100644
--- a/build-scripts/Dockerfile.linux-glibc-arm64
+++ b/build-scripts/Dockerfile.linux-glibc-arm64
@@ -1,4 +1,4 @@
-FROM rust:bullseye as build
+FROM rust:bookworm as build
 
 ARG STACKS_NODE_VERSION="No Version Info"
 ARG GIT_BRANCH='No Branch Info'
@@ -21,7 +21,6 @@ RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
     cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli \
     && mkdir -p /out \
     && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
-# --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli 
 
 FROM scratch AS export-stage
-COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
\ No newline at end of file
+COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
diff --git a/build-scripts/Dockerfile.linux-glibc-armv7 b/build-scripts/Dockerfile.linux-glibc-armv7
index c28ca7d972..8192067449 100644
--- a/build-scripts/Dockerfile.linux-glibc-armv7
+++ b/build-scripts/Dockerfile.linux-glibc-armv7
@@ -1,4 +1,4 @@
-FROM rust:bullseye as build
+FROM rust:bookworm as build
 
 ARG STACKS_NODE_VERSION="No Version Info"
 ARG GIT_BRANCH='No Branch Info'
@@ -21,7 +21,6 @@ RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
     cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli \
     && mkdir -p /out \
     && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
-# --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli 
 
 FROM scratch AS export-stage
-COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
\ No newline at end of file
+COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
diff --git a/build-scripts/Dockerfile.linux-glibc-x64 b/build-scripts/Dockerfile.linux-glibc-x64
index 19f2f89c93..60bd20d6d8 100644
--- a/build-scripts/Dockerfile.linux-glibc-x64
+++ b/build-scripts/Dockerfile.linux-glibc-x64
@@ -1,4 +1,4 @@
-FROM rust:bullseye as build
+FROM rust:bookworm as build
 
 ARG STACKS_NODE_VERSION="No Version Info"
 ARG GIT_BRANCH='No Branch Info'
@@ -23,4 +23,4 @@ RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
     && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
 
 FROM scratch AS export-stage
-COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
\ No newline at end of file
+COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
diff --git a/build-scripts/Dockerfile.linux-musl-arm64 b/build-scripts/Dockerfile.linux-musl-arm64
index 43b1b8e338..e126a1407a 100644
--- a/build-scripts/Dockerfile.linux-musl-arm64
+++ b/build-scripts/Dockerfile.linux-musl-arm64
@@ -16,6 +16,6 @@ RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
     && cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli \
     && mkdir -p /out \
     && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
-#  --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli
+
 FROM scratch AS export-stage
-COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
\ No newline at end of file
+COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
diff --git a/build-scripts/Dockerfile.linux-musl-armv7 b/build-scripts/Dockerfile.linux-musl-armv7
index c7ba40b4c4..2ce5a99912 100644
--- a/build-scripts/Dockerfile.linux-musl-armv7
+++ b/build-scripts/Dockerfile.linux-musl-armv7
@@ -16,6 +16,6 @@ RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
     && cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli \
     && mkdir -p /out \
     && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
-#  --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli
+
 FROM scratch AS export-stage
-COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
\ No newline at end of file
+COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
diff --git a/build-scripts/Dockerfile.linux-musl-x64 b/build-scripts/Dockerfile.linux-musl-x64
index f1df24a537..6765c4fdb1 100644
--- a/build-scripts/Dockerfile.linux-musl-x64
+++ b/build-scripts/Dockerfile.linux-musl-x64
@@ -11,7 +11,6 @@ WORKDIR /src
 
 COPY . .
 
-RUN echo "RUSTFLAGS: ${RUSTFLAGS}"
 RUN apk update && apk add git musl-dev make
 
 # Run all the build steps in ramdisk in an attempt to speed things up
diff --git a/build-scripts/Dockerfile.macos-arm64 b/build-scripts/Dockerfile.macos-arm64
index 8f5c92d4f8..c754f05a08 100644
--- a/build-scripts/Dockerfile.macos-arm64
+++ b/build-scripts/Dockerfile.macos-arm64
@@ -24,6 +24,6 @@ RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
     && cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli \
     && mkdir -p /out \
     && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
-# --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli 
+
 FROM scratch AS export-stage
-COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
\ No newline at end of file
+COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
diff --git a/build-scripts/Dockerfile.macos-x64 b/build-scripts/Dockerfile.macos-x64
index ca14012717..5a33621fa6 100644
--- a/build-scripts/Dockerfile.macos-x64
+++ b/build-scripts/Dockerfile.macos-x64
@@ -26,6 +26,6 @@ RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
     && cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli \
     && mkdir -p /out \
     && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
-# --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli 
+
 FROM scratch AS export-stage
-COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
\ No newline at end of file
+COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
diff --git a/build-scripts/Dockerfile.windows-x64 b/build-scripts/Dockerfile.windows-x64
index b7fc4c8f7b..502add30bc 100644
--- a/build-scripts/Dockerfile.windows-x64
+++ b/build-scripts/Dockerfile.windows-x64
@@ -1,4 +1,4 @@
-FROM rust:bullseye as build
+FROM rust:bookworm as build
 
 ARG STACKS_NODE_VERSION="No Version Info"
 ARG GIT_BRANCH='No Branch Info'
@@ -22,6 +22,6 @@ RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
     cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli \
     && mkdir -p /out \
     && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
-# --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli
+
 FROM scratch AS export-stage
-COPY --from=build /out/stacks-inspect.exe /out/blockstack-cli.exe /out/clarity-cli.exe /out/stacks-node.exe /
\ No newline at end of file
+COPY --from=build /out/stacks-inspect.exe /out/blockstack-cli.exe /out/clarity-cli.exe /out/stacks-node.exe /

From ac03fc769a5f428d92898f7204e2c1ef1d97cce8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?M=C3=A5rten=20Blankfors?= <marten@blankfors.se>
Date: Mon, 4 Mar 2024 11:38:58 +0100
Subject: [PATCH 0998/1166] fix: Port binding conflict in
 client::stackerdb::tests

---
 Cargo.lock                                 | 78 ----------------------
 stacks-signer/Cargo.toml                   |  1 -
 stacks-signer/src/client/stackerdb.rs      |  5 +-
 stacks-signer/src/client/stacks_client.rs  |  3 -
 stacks-signer/src/tests/conf/signer-0.toml |  1 -
 stacks-signer/src/tests/conf/signer-1.toml |  3 +-
 stacks-signer/src/tests/conf/signer-2.toml |  5 --
 stacks-signer/src/tests/conf/signer-3.toml |  5 --
 8 files changed, 2 insertions(+), 99 deletions(-)
 delete mode 100644 stacks-signer/src/tests/conf/signer-2.toml
 delete mode 100644 stacks-signer/src/tests/conf/signer-3.toml

diff --git a/Cargo.lock b/Cargo.lock
index d4cf3e3c08..c831a5fbaf 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -988,19 +988,6 @@ dependencies = [
  "syn 2.0.48",
 ]
 
-[[package]]
-name = "dashmap"
-version = "5.5.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "978747c1d849a7d2ee5e8adc0159961c48fb7e5db2f06af6723b80123bb53856"
-dependencies = [
- "cfg-if 1.0.0",
- "hashbrown 0.14.3",
- "lock_api",
- "once_cell",
- "parking_lot_core",
-]
-
 [[package]]
 name = "data-encoding"
 version = "2.5.0"
@@ -1989,16 +1976,6 @@ version = "0.4.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "01cda141df6706de531b6c46c3a33ecca755538219bd484262fa09410c13539c"
 
-[[package]]
-name = "lock_api"
-version = "0.4.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c168f8615b12bc01f9c17e2eb0cc07dcae1940121185446edc3744920e8ef45"
-dependencies = [
- "autocfg",
- "scopeguard",
-]
-
 [[package]]
 name = "log"
 version = "0.4.20"
@@ -2278,29 +2255,6 @@ version = "2.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bb813b8af86854136c6922af0598d719255ecb2179515e6e7730d468f05c9cae"
 
-[[package]]
-name = "parking_lot"
-version = "0.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3742b2c103b9f06bc9fff0a37ff4912935851bee6d36f3c02bcc755bcfec228f"
-dependencies = [
- "lock_api",
- "parking_lot_core",
-]
-
-[[package]]
-name = "parking_lot_core"
-version = "0.9.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c42a9226546d68acdd9c0a280d17ce19bfe27a46bf68784e4066115788d008e"
-dependencies = [
- "cfg-if 1.0.0",
- "libc",
- "redox_syscall",
- "smallvec",
- "windows-targets 0.48.5",
-]
-
 [[package]]
 name = "percent-encoding"
 version = "2.3.1"
@@ -3067,12 +3021,6 @@ version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294"
 
-[[package]]
-name = "scopeguard"
-version = "1.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
-
 [[package]]
 name = "sct"
 version = "0.7.1"
@@ -3224,31 +3172,6 @@ dependencies = [
  "serde",
 ]
 
-[[package]]
-name = "serial_test"
-version = "3.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "953ad9342b3aaca7cb43c45c097dd008d4907070394bd0751a0aa8817e5a018d"
-dependencies = [
- "dashmap",
- "futures",
- "lazy_static",
- "log",
- "parking_lot",
- "serial_test_derive",
-]
-
-[[package]]
-name = "serial_test_derive"
-version = "3.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b93fb4adc70021ac1b47f7d45e8cc4169baaa7ea58483bc5b721d19a26202212"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.48",
-]
-
 [[package]]
 name = "sha1"
 version = "0.6.1"
@@ -3536,7 +3459,6 @@ dependencies = [
  "serde_derive",
  "serde_json",
  "serde_stacker",
- "serial_test",
  "slog",
  "slog-json",
  "slog-term",
diff --git a/stacks-signer/Cargo.toml b/stacks-signer/Cargo.toml
index 8944c10342..99b02761c2 100644
--- a/stacks-signer/Cargo.toml
+++ b/stacks-signer/Cargo.toml
@@ -44,7 +44,6 @@ wsts = { workspace = true }
 rand = { workspace = true }
 
 [dev-dependencies]
-serial_test = "3.0.0"
 clarity = { path = "../clarity", features = ["testing"] }
 
 [dependencies.serde_json]
diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index 77f4d679d9..1e9e2e30f6 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -269,14 +269,12 @@ mod tests {
         TransactionSmartContract, TransactionVersion,
     };
     use blockstack_lib::util_lib::strings::StacksString;
-    use serial_test::serial;
 
     use super::*;
     use crate::client::tests::{generate_signer_config, mock_server_from_config, write_response};
     use crate::config::GlobalConfig;
 
     #[test]
-    #[serial]
     fn get_signer_transactions_with_retry_should_succeed() {
         let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
         let signer_config = generate_signer_config(&config, 5, 20);
@@ -320,9 +318,8 @@ mod tests {
     }
 
     #[test]
-    #[serial]
     fn send_signer_message_with_retry_should_succeed() {
-        let config = GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
+        let config = GlobalConfig::load_from_file("./src/tests/conf/signer-1.toml").unwrap();
         let signer_config = generate_signer_config(&config, 5, 20);
         let mut stackerdb = StackerDB::from(&signer_config);
 
diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index da67e6f448..054e4fb374 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -596,7 +596,6 @@ mod tests {
     use blockstack_lib::chainstate::stacks::ThresholdSignature;
     use rand::thread_rng;
     use rand_core::RngCore;
-    use serial_test::serial;
     use stacks_common::bitvec::BitVec;
     use stacks_common::consts::{CHAIN_ID_TESTNET, SIGNER_SLOTS_PER_USER};
     use stacks_common::types::chainstate::{ConsensusHash, StacksBlockId, TrieHash};
@@ -837,7 +836,6 @@ mod tests {
 
     #[ignore]
     #[test]
-    #[serial]
     fn build_vote_for_aggregate_public_key_should_succeed() {
         let mock = MockServerClient::new();
         let point = Point::from(Scalar::random(&mut rand::thread_rng()));
@@ -861,7 +859,6 @@ mod tests {
 
     #[ignore]
     #[test]
-    #[serial]
     fn broadcast_vote_for_aggregate_public_key_should_succeed() {
         let mock = MockServerClient::new();
         let point = Point::from(Scalar::random(&mut rand::thread_rng()));
diff --git a/stacks-signer/src/tests/conf/signer-0.toml b/stacks-signer/src/tests/conf/signer-0.toml
index 42083c30a7..2c30d82326 100644
--- a/stacks-signer/src/tests/conf/signer-0.toml
+++ b/stacks-signer/src/tests/conf/signer-0.toml
@@ -1,4 +1,3 @@
-
 stacks_private_key = "6a1fc1a3183018c6d79a4e11e154d2bdad2d89ac8bc1b0a021de8b4d28774fbb01"
 node_host = "127.0.0.1:20443"
 endpoint = "localhost:30000"
diff --git a/stacks-signer/src/tests/conf/signer-1.toml b/stacks-signer/src/tests/conf/signer-1.toml
index 38897ae48c..99facfc1d2 100644
--- a/stacks-signer/src/tests/conf/signer-1.toml
+++ b/stacks-signer/src/tests/conf/signer-1.toml
@@ -1,5 +1,4 @@
-
 stacks_private_key = "126e916e77359ccf521e168feea1fcb9626c59dc375cae00c7464303381c7dff01"
-node_host = "127.0.0.1:20443"
+node_host = "127.0.0.1:20444"
 endpoint = "localhost:30001"
 network = "testnet"
diff --git a/stacks-signer/src/tests/conf/signer-2.toml b/stacks-signer/src/tests/conf/signer-2.toml
deleted file mode 100644
index 9235b2e076..0000000000
--- a/stacks-signer/src/tests/conf/signer-2.toml
+++ /dev/null
@@ -1,5 +0,0 @@
-
-stacks_private_key = "b169d0d1408f66d16beb321857f525f9014dfc289f1aeedbcf96e78afeb8eb4001"
-node_host = "127.0.0.1:20443"
-endpoint = "localhost:30002"
-network = "testnet"
diff --git a/stacks-signer/src/tests/conf/signer-3.toml b/stacks-signer/src/tests/conf/signer-3.toml
deleted file mode 100644
index b96eef0098..0000000000
--- a/stacks-signer/src/tests/conf/signer-3.toml
+++ /dev/null
@@ -1,5 +0,0 @@
-
-stacks_private_key = "63cef3cd8880969b7f2450ca13b9ca57fd3cd3f7ee57ec6ed7654a84d39181e401"
-node_host = "127.0.0.1:20443"
-endpoint = "localhost:30003"
-network = "testnet"

From 168d7aeb98ab0661a7d02ce4d6990e3444430205 Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Thu, 29 Feb 2024 20:09:03 -0500
Subject: [PATCH 0999/1166] stack-increase param changes

---
 stackslib/src/chainstate/stacks/boot/mod.rs     |  4 ++++
 stackslib/src/chainstate/stacks/boot/pox-4.clar | 11 ++++++++++-
 2 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 59c18a1c55..83198d02e7 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -2152,6 +2152,10 @@ pub mod test {
         key: &StacksPrivateKey,
         nonce: u64,
         amount: u128,
+        // signer_key: StacksPublicKey,
+        // signature_opt: Option<Vec<u8>>,
+        // max_amount: u128,
+        // auth_id: u128,
     ) -> StacksTransaction {
         let payload = TransactionPayload::new_contract_call(
             boot_code_test_addr(),
diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index 26c1f8c61c..c238a9d767 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -1101,7 +1101,12 @@
 ;; *New in Stacks 2.1*
 ;; This method locks up an additional amount of STX from `tx-sender`'s, indicated
 ;; by `increase-by`.  The `tx-sender` must already be Stacking.
-(define-public (stack-increase (increase-by uint))
+(define-public (stack-increase 
+  (increase-by uint)
+  (signer-sig (optional (buff 65)))
+  (signer-key (buff 33))
+  (max-amount uint)
+  (auth-id uint))
    (let ((stacker-info (stx-account tx-sender))
          (amount-stacked (get locked stacker-info))
          (amount-unlocked (get unlocked stacker-info))
@@ -1129,6 +1134,10 @@
       ;; stacker must not be delegating
       (asserts! (is-none (get delegated-to stacker-state))
                 (err ERR_STACKING_IS_DELEGATED))
+
+      ;; Validate that amount is less than or equal to `max-amount`
+      (asserts! (>= max-amount amount) (err ERR_SIGNER_AUTH_AMOUNT_TOO_HIGH))
+      
       ;; update reward cycle amounts
       (asserts! (is-some (fold increase-reward-cycle-entry
             (get reward-set-indexes stacker-state)

From f39f0880e4ae3518f878c75a4eb118aaf79d93ac Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Sun, 3 Mar 2024 11:18:09 -0500
Subject: [PATCH 1000/1166] topic field updated from (ascii 12) to (ascii 14)

---
 .../src/chainstate/stacks/boot/pox-4.clar     | 37 ++++++++++++-------
 1 file changed, 24 insertions(+), 13 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index c238a9d767..2e1ed3a169 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -232,7 +232,7 @@
         period: uint,
         ;; A string representing the function where this authorization is valid. Either
         ;; `stack-stx`, `stack-extend`, or `agg-commit`.
-        topic: (string-ascii 12),
+        topic: (string-ascii 14),
         ;; The PoX address that can be used with this signer key
         pox-addr: { version: (buff 1), hashbytes: (buff 32) },
         ;; The unique auth-id for this authorization
@@ -251,7 +251,7 @@
         signer-key: (buff 33),
         reward-cycle: uint,
         period: uint,
-        topic: (string-ascii 12),
+        topic: (string-ascii 14),
         pox-addr: { version: (buff 1), hashbytes: (buff 32) },
         auth-id: uint,
         max-amount: uint,
@@ -736,7 +736,7 @@
 ;; The domain is `{ name: "pox-4-signer", version: "1.0.0", chain-id: chain-id }`.
 (define-read-only (get-signer-key-message-hash (pox-addr { version: (buff 1), hashbytes: (buff 32) })
                                                (reward-cycle uint)
-                                               (topic (string-ascii 12))
+                                               (topic (string-ascii 14))
                                                (period uint)
                                                (max-amount uint)
                                                (auth-id uint))
@@ -772,7 +772,7 @@
 ;; added for this key.
 (define-read-only (verify-signer-key-sig (pox-addr { version: (buff 1), hashbytes: (buff 32) })
                                          (reward-cycle uint)
-                                         (topic (string-ascii 12))
+                                         (topic (string-ascii 14))
                                          (period uint)
                                          (signer-sig-opt (optional (buff 65)))
                                          (signer-key (buff 33))
@@ -809,7 +809,7 @@
 ;; read-only, so that it can be used by clients as a sanity check before submitting a transaction.
 (define-private (consume-signer-key-authorization (pox-addr { version: (buff 1), hashbytes: (buff 32) })
                                                   (reward-cycle uint)
-                                                  (topic (string-ascii 12))
+                                                  (topic (string-ascii 14))
                                                   (period uint)
                                                   (signer-sig-opt (optional (buff 65)))
                                                   (signer-key (buff 33))
@@ -1067,19 +1067,23 @@
 ;; `(some stacker)` as the listed stacker, and must be an upcoming reward cycle.
 (define-private (increase-reward-cycle-entry
                   (reward-cycle-index uint)
-                  (updates (optional { first-cycle: uint, reward-cycle: uint, stacker: principal, add-amount: uint })))
+                  (updates (optional { first-cycle: uint, reward-cycle: uint, stacker: principal, add-amount: uint, signer-key: (buff 33) })))
     (let ((data (try! updates))
           (first-cycle (get first-cycle data))
-          (reward-cycle (get reward-cycle data)))
+          (reward-cycle (get reward-cycle data))
+          (passed-signer-key (get signer-key data)))
     (if (> first-cycle reward-cycle)
         ;; not at first cycle to process yet
         (some { first-cycle: first-cycle, reward-cycle: (+ u1 reward-cycle), stacker: (get stacker data), add-amount: (get add-amount data) })
         (let ((existing-entry (unwrap-panic (map-get? reward-cycle-pox-address-list { reward-cycle: reward-cycle, index: reward-cycle-index })))
               (existing-total (unwrap-panic (map-get? reward-cycle-total-stacked { reward-cycle: reward-cycle })))
+              (existing-signer-key (get signer existing-entry))
               (add-amount (get add-amount data))
               (total-ustx (+ (get total-ustx existing-total) add-amount)))
             ;; stacker must match
             (asserts! (is-eq (get stacker existing-entry) (some (get stacker data))) none)
+            ;; signer-key must match
+            (asserts! (is-eq existing-signer-key passed-signer-key) none)
             ;; update the pox-address list
             (map-set reward-cycle-pox-address-list
                      { reward-cycle: reward-cycle, index: reward-cycle-index }
@@ -1100,7 +1104,8 @@
 ;; Increase the number of STX locked.
 ;; *New in Stacks 2.1*
 ;; This method locks up an additional amount of STX from `tx-sender`'s, indicated
-;; by `increase-by`.  The `tx-sender` must already be Stacking.
+;; by `increase-by`.  The `tx-sender` must already be Stacking & must not be
+;; straddling more than one signer-key for the cycles effected. 
 (define-public (stack-increase 
   (increase-by uint)
   (signer-sig (optional (buff 65)))
@@ -1115,7 +1120,9 @@
          (first-increased-cycle (+ cur-cycle u1))
          (stacker-state (unwrap! (map-get? stacking-state
                                           { stacker: tx-sender })
-                                          (err ERR_STACK_INCREASE_NOT_LOCKED))))
+                                          (err ERR_STACK_INCREASE_NOT_LOCKED)))
+         (cur-pox-addr (get pox-addr stacker-state))
+         (cur-period (get lock-period stacker-state)))
       ;; tx-sender must be currently locked
       (asserts! (> amount-stacked u0)
                 (err ERR_STACK_INCREASE_NOT_LOCKED))
@@ -1136,15 +1143,19 @@
                 (err ERR_STACKING_IS_DELEGATED))
 
       ;; Validate that amount is less than or equal to `max-amount`
-      (asserts! (>= max-amount amount) (err ERR_SIGNER_AUTH_AMOUNT_TOO_HIGH))
-      
+      (asserts! (>= max-amount (+ increase-by amount-stacked)) (err ERR_SIGNER_AUTH_AMOUNT_TOO_HIGH))
+
+      ;; Verify signature from delegate that allows this sender for this cycle
+      (try! (consume-signer-key-authorization cur-pox-addr cur-cycle "stack-increase" cur-period signer-sig signer-key increase-by max-amount auth-id))
+
       ;; update reward cycle amounts
       (asserts! (is-some (fold increase-reward-cycle-entry
             (get reward-set-indexes stacker-state)
             (some { first-cycle: first-increased-cycle,
                     reward-cycle: (get first-reward-cycle stacker-state),
                     stacker: tx-sender,
-                    add-amount: increase-by })))
+                    add-amount: increase-by,
+                    signer-key: signer-key })))
             (err ERR_STACKING_UNREACHABLE))
       ;; NOTE: stacking-state map is unchanged: it does not track amount-stacked in PoX-4
       (ok { stacker: tx-sender, total-locked: (+ amount-stacked increase-by)})))
@@ -1439,7 +1450,7 @@
 (define-public (set-signer-key-authorization (pox-addr { version: (buff 1), hashbytes: (buff 32)})
                                              (period uint)
                                              (reward-cycle uint)
-                                             (topic (string-ascii 12))
+                                             (topic (string-ascii 14))
                                              (signer-key (buff 33))
                                              (allowed bool)
                                              (max-amount uint)

From e258eb022878de614bcdfdc62c0bb935ee6f90de Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Sun, 3 Mar 2024 11:44:38 -0500
Subject: [PATCH 1001/1166] updated increase-reward-cycle-entry tuple

---
 stackslib/src/chainstate/stacks/boot/pox-4.clar | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index 2e1ed3a169..62f3040bf5 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -1074,7 +1074,7 @@
           (passed-signer-key (get signer-key data)))
     (if (> first-cycle reward-cycle)
         ;; not at first cycle to process yet
-        (some { first-cycle: first-cycle, reward-cycle: (+ u1 reward-cycle), stacker: (get stacker data), add-amount: (get add-amount data) })
+        (some { first-cycle: first-cycle, reward-cycle: (+ u1 reward-cycle), stacker: (get stacker data), add-amount: (get add-amount data), signer-key: (get signer-key data) })
         (let ((existing-entry (unwrap-panic (map-get? reward-cycle-pox-address-list { reward-cycle: reward-cycle, index: reward-cycle-index })))
               (existing-total (unwrap-panic (map-get? reward-cycle-total-stacked { reward-cycle: reward-cycle })))
               (existing-signer-key (get signer existing-entry))
@@ -1099,7 +1099,8 @@
             (some { first-cycle: first-cycle,
                     reward-cycle: (+ u1 reward-cycle),
                     stacker: (get stacker data),
-                    add-amount: (get add-amount data) })))))
+                    add-amount: (get add-amount data),
+                    signer-key: passed-signer-key })))))
 
 ;; Increase the number of STX locked.
 ;; *New in Stacks 2.1*

From 32eecc9882151fc701494b3e47cb63bbdd91f8e8 Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Sun, 3 Mar 2024 13:57:27 -0500
Subject: [PATCH 1002/1166] compiling, need to update make_pox_4_stack_increase

---
 stackslib/src/chainstate/stacks/boot/mod.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 83198d02e7..d4d1bfa323 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -2152,7 +2152,7 @@ pub mod test {
         key: &StacksPrivateKey,
         nonce: u64,
         amount: u128,
-        // signer_key: StacksPublicKey,
+        // signer_key: &Secp256k1PublicKey,
         // signature_opt: Option<Vec<u8>>,
         // max_amount: u128,
         // auth_id: u128,
@@ -2160,6 +2160,7 @@ pub mod test {
         let payload = TransactionPayload::new_contract_call(
             boot_code_test_addr(),
             POX_4_NAME,
+            // Need to add/create signature
             "stack-increase",
             vec![Value::UInt(amount)],
         )

From cf1d7e7e4018e61ed77bd1e8392aeecd032036ad Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Mon, 4 Mar 2024 06:17:13 -0800
Subject: [PATCH 1003/1166] feat: tests for stack-increase w signer key

---
 stackslib/src/chainstate/stacks/boot/mod.rs   | 20 +++++--
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 55 ++++++++-----------
 .../src/util_lib/signed_structured_data.rs    |  2 +
 3 files changed, 38 insertions(+), 39 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index d4d1bfa323..a8a5eda51b 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -2152,17 +2152,25 @@ pub mod test {
         key: &StacksPrivateKey,
         nonce: u64,
         amount: u128,
-        // signer_key: &Secp256k1PublicKey,
-        // signature_opt: Option<Vec<u8>>,
-        // max_amount: u128,
-        // auth_id: u128,
+        signer_key: &Secp256k1PublicKey,
+        signature_opt: Option<Vec<u8>>,
+        max_amount: u128,
+        auth_id: u128,
     ) -> StacksTransaction {
+        let signature = signature_opt
+            .map(|sig| Value::some(Value::buff_from(sig).unwrap()).unwrap())
+            .unwrap_or_else(|| Value::none());
         let payload = TransactionPayload::new_contract_call(
             boot_code_test_addr(),
             POX_4_NAME,
-            // Need to add/create signature
             "stack-increase",
-            vec![Value::UInt(amount)],
+            vec![
+                Value::UInt(amount),
+                signature,
+                Value::buff_from(signer_key.to_bytes_compressed()).unwrap(),
+                Value::UInt(max_amount),
+                Value::UInt(auth_id),
+            ],
         )
         .unwrap();
 
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 329a82bd75..53ec86e113 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -2290,30 +2290,7 @@ fn stack_extend_verify_sig() {
         1,
     );
 
-    // Test invalid amount
-    stacker_nonce += 1;
-    let signature = make_signer_key_signature(
-        &pox_addr,
-        &signer_key,
-        reward_cycle,
-        &topic,
-        lock_period,
-        min_ustx.saturating_sub(1),
-        1,
-    );
-    let invalid_amount_nonce = stacker_nonce;
-    let invalid_amount_tx = make_pox_4_extend(
-        &stacker_key,
-        stacker_nonce,
-        pox_addr.clone(),
-        lock_period,
-        signer_public_key.clone(),
-        Some(signature),
-        min_ustx.saturating_sub(1), // less than amount
-        1,
-    );
-
-    // Test 4: valid stack-extend
+    // Test: valid stack-extend
     stacker_nonce += 1;
     let signature = make_signer_key_signature(
         &pox_addr,
@@ -2344,7 +2321,6 @@ fn stack_extend_verify_sig() {
             invalid_key_tx,
             invalid_auth_id_tx,
             invalid_max_amount_tx,
-            invalid_amount_tx,
             valid_tx,
         ],
         &mut coinbase_nonce,
@@ -2364,10 +2340,6 @@ fn stack_extend_verify_sig() {
     assert_eq!(tx_result(invalid_key_nonce), expected_error);
     assert_eq!(tx_result(invalid_auth_id_nonce), expected_error);
     assert_eq!(tx_result(invalid_max_amount_nonce), expected_error);
-    assert_eq!(
-        tx_result(invalid_amount_nonce),
-        Value::error(Value::Int(37)).unwrap()
-    );
 
     // valid tx should succeed
     tx_result(valid_nonce)
@@ -2714,7 +2686,7 @@ fn stack_agg_commit_verify_sig() {
         &pox_addr,
         &mut peer,
         &latest_block,
-        reward_cycle,
+        next_reward_cycle,
         1,
         &topic,
         min_ustx,
@@ -2729,7 +2701,7 @@ fn stack_agg_commit_verify_sig() {
         &mut peer,
         &latest_block,
         &pox_addr,
-        reward_cycle.try_into().unwrap(),
+        next_reward_cycle.try_into().unwrap(),
         &topic,
         1,
         &signer_pk,
@@ -3852,8 +3824,25 @@ fn stack_increase() {
 
     alice_nonce += 1;
 
-    let stack_increase =
-        make_pox_4_stack_increase(alice_stacking_private_key, alice_nonce, min_ustx);
+    let signature = make_signer_key_signature(
+        &pox_addr,
+        &signing_sk,
+        reward_cycle,
+        &Pox4SignatureTopic::StackIncrease,
+        lock_period,
+        u128::MAX,
+        1,
+    );
+
+    let stack_increase = make_pox_4_stack_increase(
+        alice_stacking_private_key,
+        alice_nonce,
+        min_ustx,
+        &signing_pk,
+        Some(signature),
+        u128::MAX,
+        1,
+    );
     // Next tx arr includes a stack_increase pox_4 helper found in mod.rs
     let txs = vec![stack_increase];
     let latest_block = peer.tenure_with_txs(&txs, &mut coinbase_nonce);
diff --git a/stackslib/src/util_lib/signed_structured_data.rs b/stackslib/src/util_lib/signed_structured_data.rs
index b2cbbb467b..cb0f7b7ad4 100644
--- a/stackslib/src/util_lib/signed_structured_data.rs
+++ b/stackslib/src/util_lib/signed_structured_data.rs
@@ -84,6 +84,7 @@ pub mod pox4 {
         StackStx("stack-stx"),
         AggregationCommit("agg-commit"),
         StackExtend("stack-extend"),
+        StackIncrease("stack-increase"),
     });
 
     pub fn make_pox_4_signed_data_domain(chain_id: u32) -> Value {
@@ -126,6 +127,7 @@ pub mod pox4 {
                 "stack-stx" => Pox4SignatureTopic::StackStx,
                 "agg-commit" => Pox4SignatureTopic::AggregationCommit,
                 "stack-extend" => Pox4SignatureTopic::StackExtend,
+                "stack-increase" => Pox4SignatureTopic::StackIncrease,
                 _ => panic!("Invalid pox-4 signature topic"),
             }
         }

From 755bab9508ff7f0b9ccc2728edf4438fa948f39b Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Mon, 4 Mar 2024 06:29:35 -0800
Subject: [PATCH 1004/1166] fix: merge conflicts from next

---
 stackslib/src/chainstate/stacks/boot/pox-4.clar  |  9 ++++++++-
 .../src/chainstate/stacks/boot/pox_4_tests.rs    | 16 ++++++++++------
 2 files changed, 18 insertions(+), 7 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index af74bebac0..b13beba798 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -32,6 +32,9 @@
 (define-constant ERR_DELEGATION_ALREADY_REVOKED 34)
 (define-constant ERR_INVALID_SIGNATURE_PUBKEY 35)
 (define-constant ERR_INVALID_SIGNATURE_RECOVER 36)
+(define-constant ERR_INVALID_REWARD_CYCLE 37)
+(define-constant ERR_SIGNER_AUTH_AMOUNT_TOO_HIGH 38)
+(define-constant ERR_SIGNER_AUTH_USED 39)
 
 ;; Valid values for burnchain address versions.
 ;; These first four correspond to address hash modes in Stacks 2.1,
@@ -1459,7 +1462,11 @@
     (asserts! (is-eq
       (unwrap! (principal-construct? (if is-in-mainnet STACKS_ADDR_VERSION_MAINNET STACKS_ADDR_VERSION_TESTNET) (hash160 signer-key)) (err ERR_INVALID_SIGNER_KEY))
       tx-sender) (err ERR_NOT_ALLOWED))
-    (map-set signer-key-authorizations { pox-addr: pox-addr, period: period, reward-cycle: reward-cycle, topic: topic, signer-key: signer-key } allowed)
+    ;; Must be called with positive period
+    (asserts! (>= period u1) (err ERR_STACKING_INVALID_LOCK_PERIOD))
+    ;; Must be current or future reward cycle
+    (asserts! (>= reward-cycle (current-pox-reward-cycle)) (err ERR_INVALID_REWARD_CYCLE))
+    (map-set signer-key-authorizations { pox-addr: pox-addr, period: period, reward-cycle: reward-cycle, topic: topic, signer-key: signer-key, auth-id: auth-id, max-amount: max-amount } allowed)
     (ok allowed)))
 
 ;; Get the _current_ PoX stacking delegation information for a stacker.  If the information
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 7629befd61..41b4c0bda8 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -1774,7 +1774,7 @@ fn verify_signer_key_signatures() {
         1,
     );
     // Different error code
-    assert_eq!(result, Value::error(Value::Int(37)).unwrap());
+    assert_eq!(result, Value::error(Value::Int(38)).unwrap());
 
     // Test using a valid signature
 
@@ -2086,7 +2086,7 @@ fn stack_stx_verify_signer_sig() {
     assert_eq!(tx_result(invalid_max_amount_nonce), expected_error);
     assert_eq!(
         tx_result(invalid_amount_nonce),
-        Value::error(Value::Int(37)).unwrap()
+        Value::error(Value::Int(38)).unwrap()
     );
 
     // valid tx should succeed
@@ -2108,7 +2108,7 @@ fn stack_stx_verify_signer_sig() {
         u128::MAX,
         1,
     );
-    let expected_error = Value::error(Value::Int(38)).unwrap();
+    let expected_error = Value::error(Value::Int(39)).unwrap();
     assert_eq!(result, expected_error);
 
     // Ensure the authorization is stored as used
@@ -2360,7 +2360,7 @@ fn stack_extend_verify_sig() {
         u128::MAX,
         1,
     );
-    let expected_error = Value::error(Value::Int(38)).unwrap();
+    let expected_error = Value::error(Value::Int(39)).unwrap();
     assert_eq!(result, expected_error);
 
     // Ensure the authorization is stored as used
@@ -2662,7 +2662,7 @@ fn stack_agg_commit_verify_sig() {
     let tx_result = |nonce: u64| -> Value { txs.get(nonce as usize).unwrap().result.clone() };
 
     let expected_error = Value::error(Value::Int(35)).unwrap();
-    let amount_too_high_error = Value::error(Value::Int(37)).unwrap();
+    let amount_too_high_error = Value::error(Value::Int(38)).unwrap();
 
     tx_result(delegate_stack_stx_nonce)
         .expect_result_ok()
@@ -2693,7 +2693,7 @@ fn stack_agg_commit_verify_sig() {
         u128::MAX,
         1,
     );
-    let expected_error = Value::error(Value::Int(38)).unwrap();
+    let expected_error = Value::error(Value::Int(39)).unwrap();
     assert_eq!(result, expected_error);
 
     // Ensure the authorization is stored as used
@@ -3254,6 +3254,8 @@ fn test_set_signer_key_auth() {
         false,
         signer_invalid_period_nonce,
         Some(&signer_key),
+        u128::MAX,
+        1,
     );
 
     let signer_invalid_cycle_nonce = signer_nonce;
@@ -3268,6 +3270,8 @@ fn test_set_signer_key_auth() {
         false,
         signer_invalid_cycle_nonce,
         Some(&signer_key),
+        u128::MAX,
+        1,
     );
 
     // Disable auth for `signer-key`

From 05e26e080555e02c7850726d71a1855974cb5284 Mon Sep 17 00:00:00 2001
From: Matthew Little <zone117x@gmail.com>
Date: Mon, 4 Mar 2024 15:34:49 +0100
Subject: [PATCH 1005/1166] fix: resolve DNS/hostnames for signer node_host
 value #4466

---
 Cargo.lock                                    |  1 +
 libsigner/src/http.rs                         |  2 +-
 libsigner/src/session.rs                      | 10 +++++-----
 stacks-signer/Cargo.toml                      |  1 +
 stacks-signer/src/cli.rs                      |  2 +-
 stacks-signer/src/client/mod.rs               |  2 +-
 stacks-signer/src/client/stackerdb.rs         |  8 +++-----
 stacks-signer/src/config.rs                   | 20 ++++++-------------
 stacks-signer/src/main.rs                     |  5 ++---
 stacks-signer/src/runloop.rs                  |  2 +-
 .../stacks-node/src/nakamoto_node/miner.rs    | 10 ++++------
 11 files changed, 26 insertions(+), 37 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index d4cf3e3c08..60439cd973 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3546,6 +3546,7 @@ dependencies = [
  "toml 0.5.11",
  "tracing",
  "tracing-subscriber",
+ "url",
  "wsts",
 ]
 
diff --git a/libsigner/src/http.rs b/libsigner/src/http.rs
index f5ba9bb2bf..95f2e2b3cb 100644
--- a/libsigner/src/http.rs
+++ b/libsigner/src/http.rs
@@ -224,7 +224,7 @@ pub fn decode_http_body(headers: &HashMap<String, String>, mut buf: &[u8]) -> io
 /// Return the HTTP reply, decoded if it was chunked
 pub fn run_http_request<S: Read + Write>(
     sock: &mut S,
-    host: &SocketAddr,
+    host: &str,
     verb: &str,
     path: &str,
     content_type: Option<&str>,
diff --git a/libsigner/src/session.rs b/libsigner/src/session.rs
index e5dbd67f35..56658bf29d 100644
--- a/libsigner/src/session.rs
+++ b/libsigner/src/session.rs
@@ -31,7 +31,7 @@ pub trait SignerSession {
     /// connect to the replica
     fn connect(
         &mut self,
-        host: SocketAddr,
+        host: String,
         stackerdb_contract_id: QualifiedContractIdentifier,
     ) -> Result<(), RPCError>;
     /// query the replica for a list of chunks
@@ -66,7 +66,7 @@ pub trait SignerSession {
 /// signer session for a stackerdb instance
 pub struct StackerDBSession {
     /// host we're talking to
-    pub host: SocketAddr,
+    pub host: String,
     /// contract we're talking to
     pub stackerdb_contract_id: QualifiedContractIdentifier,
     /// connection to the replica
@@ -76,7 +76,7 @@ pub struct StackerDBSession {
 impl StackerDBSession {
     /// instantiate but don't connect
     pub fn new(
-        host: SocketAddr,
+        host: String,
         stackerdb_contract_id: QualifiedContractIdentifier,
     ) -> StackerDBSession {
         StackerDBSession {
@@ -89,7 +89,7 @@ impl StackerDBSession {
     /// connect or reconnect to the node
     fn connect_or_reconnect(&mut self) -> Result<(), RPCError> {
         debug!("connect to {}", &self.host);
-        self.sock = Some(TcpStream::connect(self.host)?);
+        self.sock = Some(TcpStream::connect(&self.host)?);
         Ok(())
     }
 
@@ -134,7 +134,7 @@ impl SignerSession for StackerDBSession {
     /// connect to the replica
     fn connect(
         &mut self,
-        host: SocketAddr,
+        host: String,
         stackerdb_contract_id: QualifiedContractIdentifier,
     ) -> Result<(), RPCError> {
         self.host = host;
diff --git a/stacks-signer/Cargo.toml b/stacks-signer/Cargo.toml
index 8944c10342..f3363997c3 100644
--- a/stacks-signer/Cargo.toml
+++ b/stacks-signer/Cargo.toml
@@ -42,6 +42,7 @@ tracing = "0.1.37"
 tracing-subscriber = { version = "0.3.17", features = ["env-filter"] }
 wsts = { workspace = true }
 rand = { workspace = true }
+url = "2.1.0"
 
 [dev-dependencies]
 serial_test = "3.0.0"
diff --git a/stacks-signer/src/cli.rs b/stacks-signer/src/cli.rs
index 639b57f3a2..b7a3312f65 100644
--- a/stacks-signer/src/cli.rs
+++ b/stacks-signer/src/cli.rs
@@ -67,7 +67,7 @@ pub enum Command {
 pub struct StackerDBArgs {
     /// The Stacks node to connect to
     #[arg(long)]
-    pub host: SocketAddr,
+    pub host: String,
     /// The stacker-db contract to use. Must be in the format of "STACKS_ADDRESS.CONTRACT_NAME"
     #[arg(short, long, value_parser = parse_contract)]
     pub contract: QualifiedContractIdentifier,
diff --git a/stacks-signer/src/client/mod.rs b/stacks-signer/src/client/mod.rs
index 63dc0e9a1f..c5bc348ab2 100644
--- a/stacks-signer/src/client/mod.rs
+++ b/stacks-signer/src/client/mod.rs
@@ -168,7 +168,7 @@ pub(crate) mod tests {
             let mut config =
                 GlobalConfig::load_from_file("./src/tests/conf/signer-0.toml").unwrap();
             let (server, mock_server_addr) = mock_server_random();
-            config.node_host = mock_server_addr;
+            config.node_host = mock_server_addr.to_string();
 
             let client = StacksClient::from(&config);
             Self {
diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index 77f4d679d9..3fe8da8bef 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -14,8 +14,6 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 //
-use std::net::SocketAddr;
-
 use blockstack_lib::chainstate::nakamoto::signer_set::NakamotoSigners;
 use blockstack_lib::chainstate::stacks::StacksTransaction;
 use blockstack_lib::util_lib::boot::boot_code_addr;
@@ -55,7 +53,7 @@ pub struct StackerDB {
 impl From<&SignerConfig> for StackerDB {
     fn from(config: &SignerConfig) -> Self {
         StackerDB::new(
-            config.node_host,
+            config.node_host.to_string(),
             config.stacks_private_key,
             config.mainnet,
             config.reward_cycle,
@@ -66,7 +64,7 @@ impl From<&SignerConfig> for StackerDB {
 impl StackerDB {
     /// Create a new StackerDB client
     pub fn new(
-        host: SocketAddr,
+        host: String,
         stacks_private_key: StacksPrivateKey,
         is_mainnet: bool,
         reward_cycle: u64,
@@ -78,7 +76,7 @@ impl StackerDB {
             signers_message_stackerdb_sessions.insert(
                 msg_id,
                 StackerDBSession::new(
-                    host,
+                    host.to_string(),
                     QualifiedContractIdentifier::new(
                         stackerdb_issuer.into(),
                         ContractName::from(
diff --git a/stacks-signer/src/config.rs b/stacks-signer/src/config.rs
index d8c7b4a8e9..3acad46c17 100644
--- a/stacks-signer/src/config.rs
+++ b/stacks-signer/src/config.rs
@@ -148,7 +148,7 @@ pub struct SignerConfig {
     /// The private key for this signer
     pub stacks_private_key: StacksPrivateKey,
     /// The node host for this signer
-    pub node_host: SocketAddr,
+    pub node_host: String,
     /// Whether this signer is running on mainnet or not
     pub mainnet: bool,
     /// timeout to gather DkgPublicShares messages
@@ -169,7 +169,7 @@ pub struct SignerConfig {
 #[derive(Clone, Debug)]
 pub struct GlobalConfig {
     /// endpoint to the stacks node
-    pub node_host: SocketAddr,
+    pub node_host: String,
     /// endpoint to the event receiver
     pub endpoint: SocketAddr,
     /// The Scalar representation of the private key for signer communication
@@ -254,17 +254,9 @@ impl TryFrom<RawConfigFile> for GlobalConfig {
     /// Attempt to decode the raw config file's primitive types into our types.
     /// NOTE: network access is required for this to work
     fn try_from(raw_data: RawConfigFile) -> Result<Self, Self::Error> {
-        let node_host = raw_data
-            .node_host
-            .to_socket_addrs()
-            .map_err(|_| {
-                ConfigError::BadField("node_host".to_string(), raw_data.node_host.clone())
-            })?
-            .next()
-            .ok_or(ConfigError::BadField(
-                "node_host".to_string(),
-                raw_data.node_host.clone(),
-            ))?;
+        url::Url::parse(&format!("http://{}", raw_data.node_host)).map_err(|_| {
+            ConfigError::BadField("node_host".to_string(), raw_data.node_host.clone())
+        })?;
 
         let endpoint = raw_data
             .endpoint
@@ -307,7 +299,7 @@ impl TryFrom<RawConfigFile> for GlobalConfig {
         let nonce_timeout = raw_data.nonce_timeout_ms.map(Duration::from_millis);
         let sign_timeout = raw_data.sign_timeout_ms.map(Duration::from_millis);
         Ok(Self {
-            node_host,
+            node_host: raw_data.node_host,
             endpoint,
             stacks_private_key,
             ecdsa_private_key,
diff --git a/stacks-signer/src/main.rs b/stacks-signer/src/main.rs
index e59722dd53..f5c4fc5bd7 100644
--- a/stacks-signer/src/main.rs
+++ b/stacks-signer/src/main.rs
@@ -28,7 +28,6 @@ extern crate toml;
 
 use std::fs::File;
 use std::io::{self, BufRead, Write};
-use std::net::SocketAddr;
 use std::path::{Path, PathBuf};
 use std::sync::mpsc::{channel, Receiver, Sender};
 use std::time::Duration;
@@ -63,8 +62,8 @@ struct SpawnedSigner {
 }
 
 /// Create a new stacker db session
-fn stackerdb_session(host: SocketAddr, contract: QualifiedContractIdentifier) -> StackerDBSession {
-    let mut session = StackerDBSession::new(host, contract.clone());
+fn stackerdb_session(host: String, contract: QualifiedContractIdentifier) -> StackerDBSession {
+    let mut session = StackerDBSession::new(host.to_string(), contract.clone());
     session.connect(host, contract).unwrap();
     session
 }
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index c0ec846acd..ef5ffacdc3 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -216,7 +216,7 @@ impl RunLoop {
             signer_slot_ids: signer_slot_ids.into_values().collect(),
             ecdsa_private_key: self.config.ecdsa_private_key,
             stacks_private_key: self.config.stacks_private_key,
-            node_host: self.config.node_host,
+            node_host: self.config.node_host.to_string(),
             mainnet: self.config.network.is_mainnet(),
             dkg_end_timeout: self.config.dkg_end_timeout,
             dkg_private_timeout: self.config.dkg_private_timeout,
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index 9c886b4343..fcad415e1d 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -151,10 +151,6 @@ impl BlockMinerThread {
         let miners_contract_id = boot_code_id(MINERS_NAME, self.config.is_mainnet());
         let stackerdbs = StackerDBs::connect(&self.config.get_stacker_db_file_path(), true)
             .expect("FATAL: failed to connect to stacker DB");
-        let rpc_sock = self.config.node.rpc_bind.parse().expect(&format!(
-            "Failed to parse socket: {}",
-            &self.config.node.rpc_bind
-        ));
         let Some(miner_privkey) = self.config.miner.mining_key else {
             warn!("No mining key configured, cannot mine");
             return;
@@ -204,8 +200,10 @@ impl BlockMinerThread {
                     Ok(Some(chunk)) => {
                         // Propose the block to the observing signers through the .miners stackerdb instance
                         let miner_contract_id = boot_code_id(MINERS_NAME, self.config.is_mainnet());
-                        let mut miners_stackerdb =
-                            StackerDBSession::new(rpc_sock, miner_contract_id);
+                        let mut miners_stackerdb = StackerDBSession::new(
+                            self.config.node.rpc_bind.to_string(),
+                            miner_contract_id,
+                        );
                         match miners_stackerdb.put_chunk(&chunk) {
                             Ok(ack) => {
                                 info!("Proposed block to stackerdb: {ack:?}");

From 7fd3bb5c6a13c88f39eac2118ac71433ada21e74 Mon Sep 17 00:00:00 2001
From: BowTiedRadone <bowtiedradone@gmail.com>
Date: Mon, 4 Mar 2024 16:51:39 +0200
Subject: [PATCH 1006/1166] Split conditional tests

---
 .../tests/pox-4/pox-4.prop.test.ts            | 332 ++++++++++++------
 1 file changed, 231 insertions(+), 101 deletions(-)

diff --git a/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts b/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
index 54d5f5dd22..d084d7759d 100644
--- a/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
+++ b/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
@@ -1,9 +1,11 @@
-import Cl, { ClarityType, bufferCV, isClarityType } from "@stacks/transactions";
+import { Cl, ClarityType, bufferCV, isClarityType } from "@stacks/transactions";
 import { assert, describe, expect, it } from "vitest";
 import fc from "fast-check";
 
 const POX_4 = "pox-4";
 const GET_POX_INFO = "get-pox-info";
+const testnet_stacking_threshold_25 = 8000;
+fc.configureGlobal({ numRuns: 250 });
 
 describe("test pox-4 contract read only functions", () => {
   it("should return correct reward-cycle-to-burn-height", () => {
@@ -31,7 +33,7 @@ describe("test pox-4 contract read only functions", () => {
           const { result: actual } = simnet.callReadOnlyFn(
             POX_4,
             "reward-cycle-to-burn-height",
-            [Cl.uintCV(reward_cycle)],
+            [Cl.uint(reward_cycle)],
             account
           );
 
@@ -45,8 +47,7 @@ describe("test pox-4 contract read only functions", () => {
             Number(reward_cycle_length.value) * reward_cycle;
           expect(actual).toBeUint(expected);
         }
-      ),
-      { numRuns: 300 }
+      )
     );
   });
 
@@ -75,7 +76,7 @@ describe("test pox-4 contract read only functions", () => {
           const { result: actual } = simnet.callReadOnlyFn(
             POX_4,
             "burn-height-to-reward-cycle",
-            [Cl.uintCV(burn_height)],
+            [Cl.uint(burn_height)],
             account
           );
 
@@ -89,8 +90,7 @@ describe("test pox-4 contract read only functions", () => {
           );
           expect(actual).toBeUint(expected);
         }
-      ),
-      { numRuns: 300 }
+      )
     );
   });
 
@@ -106,7 +106,7 @@ describe("test pox-4 contract read only functions", () => {
           const { result: actual } = simnet.callReadOnlyFn(
             POX_4,
             "get-stacker-info",
-            [Cl.principalCV(stacker)],
+            [Cl.principal(stacker)],
             caller
           );
 
@@ -118,7 +118,7 @@ describe("test pox-4 contract read only functions", () => {
     );
   });
 
-  it("should return correct check-caller-allowed", () => {
+  it("should return true check-caller-allowed", () => {
     fc.assert(
       fc.property(
         fc.constantFrom(...simnet.getAccounts().values()),
@@ -154,7 +154,7 @@ describe("test pox-4 contract read only functions", () => {
           const { result: actual } = simnet.callReadOnlyFn(
             POX_4,
             "get-reward-set-size",
-            [Cl.uintCV(reward_cycle)],
+            [Cl.uint(reward_cycle)],
             caller
           );
 
@@ -179,7 +179,7 @@ describe("test pox-4 contract read only functions", () => {
           const { result: actual } = simnet.callReadOnlyFn(
             POX_4,
             "get-total-ustx-stacked",
-            [Cl.uintCV(reward_cycle)],
+            [Cl.uint(reward_cycle)],
             caller
           );
 
@@ -204,7 +204,7 @@ describe("test pox-4 contract read only functions", () => {
           const { result: actual } = simnet.callReadOnlyFn(
             POX_4,
             "get-reward-set-pox-address",
-            [Cl.uintCV(index), Cl.uintCV(reward_cycle)],
+            [Cl.uint(index), Cl.uint(reward_cycle)],
             caller
           );
 
@@ -222,7 +222,6 @@ describe("test pox-4 contract read only functions", () => {
         fc.constantFrom(...simnet.getAccounts().values()),
         (caller) => {
           // Arrange
-          const testnet_stacking_threshold_25 = 8000;
 
           const { result: pox_4_info } = simnet.callReadOnlyFn(
             POX_4,
@@ -257,77 +256,206 @@ describe("test pox-4 contract read only functions", () => {
     );
   });
 
-  it("should return correct check-pox-addr-version", () => {
+  it("should return true check-pox-addr-version for version <= 6 ", () => {
     fc.assert(
       fc.property(
         fc.constantFrom(...simnet.getAccounts().values()),
-        fc.nat({ max: 255 }),
+        fc.nat({ max: 6 }),
         (caller, version) => {
           // Arrange
-          const expected = version > 6 ? false : true;
+          const expected = true;
 
           // Act
           let { result: actual } = simnet.callReadOnlyFn(
             POX_4,
             "check-pox-addr-version",
-            [Cl.bufferCV(Uint8Array.from([version]))],
+            [Cl.buffer(Uint8Array.from([version]))],
             caller
           );
 
           // Assert
-          assert(
-            isClarityType(
-              actual,
-              expected ? ClarityType.BoolTrue : ClarityType.BoolFalse
-            )
+          assert(isClarityType(actual, ClarityType.BoolTrue));
+          expect(actual).toBeBool(expected);
+        }
+      )
+    );
+  });
+
+  it("should return false check-pox-addr-version for version > 6", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 7, max: 255 }),
+        (caller, version) => {
+          // Arrange
+          const expected = false;
+
+          // Act
+          let { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "check-pox-addr-version",
+            [Cl.buffer(Uint8Array.from([version]))],
+            caller
           );
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.BoolFalse));
           expect(actual).toBeBool(expected);
         }
       )
     );
   });
 
-  it("should return correct check-pox-lock-period", () => {
+  it("should return true check-pox-lock-period for valid reward cycles number", () => {
     fc.assert(
       fc.property(
         fc.constantFrom(...simnet.getAccounts().values()),
-        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
         (caller, reward_cycles) => {
           // Arrange
-          const expected =
-            reward_cycles > 0 && reward_cycles <= 12 ? true : false;
+          const expected = true;
 
           // Act
           const { result: actual } = simnet.callReadOnlyFn(
             POX_4,
             "check-pox-lock-period",
-            [Cl.uintCV(reward_cycles)],
+            [Cl.uint(reward_cycles)],
             caller
           );
 
           // Assert
-          assert(
-            isClarityType(
-              actual,
-              expected ? ClarityType.BoolTrue : ClarityType.BoolFalse
-            )
+          assert(isClarityType(actual, ClarityType.BoolTrue));
+          expect(actual).toBeBool(expected);
+        }
+      )
+    );
+  });
+
+  it("should return false check-pox-lock-period for reward cycles number > 12", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 13 }),
+        (caller, reward_cycles) => {
+          // Arrange
+          const expected = false;
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "check-pox-lock-period",
+            [Cl.uint(reward_cycles)],
+            caller
           );
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.BoolFalse));
           expect(actual).toBeBool(expected);
         }
       )
-    ),
-      { numRuns: 250 };
+    );
   });
 
-  it("should return correct can-stack-stx", () => {
+  it("should return false check-pox-lock-period for reward cycles number == 0", () => {
     fc.assert(
       fc.property(
         fc.constantFrom(...simnet.getAccounts().values()),
-        fc.nat({ max: 255 }),
-        fc.array(fc.nat({ max: 255 }), { maxLength: 32 }),
-        fc.bigInt({ min: 0n, max: 340282366920938463463374607431768211455n }),
+        (caller) => {
+          // Arrange
+          const reward_cycles = 0;
+          const expected = false;
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "check-pox-lock-period",
+            [Cl.uint(reward_cycles)],
+            caller
+          );
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.BoolFalse));
+          expect(actual).toBeBool(expected);
+        }
+      )
+    );
+  });
+
+  it("should return (ok true) can-stack-stx for versions 0-4 valid pox addresses, hashbytes, amount, cycles number", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 0, max: 4 }),
+        fc.array(fc.nat({ max: 255 }), {
+          minLength: 20,
+          maxLength: 20,
+        }),
+        fc.bigInt({
+          min: 125_000_000_000n,
+          max: 340282366920938463463374607431768211455n,
+        }),
         fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            POX_4,
+            GET_POX_INFO,
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+          const expectedResponseOk = true;
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "can-stack-stx",
+            [
+              Cl.tuple({
+                version: bufferCV(Uint8Array.from([version])),
+                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseOk));
+          assert(isClarityType(actual.value, ClarityType.BoolTrue));
+          expect(actual).toBeOk(Cl.bool(expectedResponseOk));
+        }
+      )
+    );
+  });
+
+  it("should return (ok true) can-stack-stx for versions 5/6 valid pox addresses, hashbytes, amount, cycles number", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 5, max: 6 }),
+        fc.array(fc.nat({ max: 255 }), {
+          minLength: 32,
+          maxLength: 32,
+        }),
+        fc.bigInt({
+          min: 125_000_000_000n,
+          max: 340282366920938463463374607431768211455n,
+        }),
         fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
         (
           caller,
           version,
@@ -337,7 +465,6 @@ describe("test pox-4 contract read only functions", () => {
           num_cycles
         ) => {
           // Arrange
-          const testnet_stacking_threshold_25 = 8000;
 
           const { result: pox_4_info } = simnet.callReadOnlyFn(
             POX_4,
@@ -348,31 +475,6 @@ describe("test pox-4 contract read only functions", () => {
           assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
           assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
 
-          const stacking_valid_amount = amount_ustx > 0;
-          const pox_lock_period_valid = num_cycles > 0 && num_cycles <= 12;
-          const pox_version_valid = version <= 6;
-          const pox_hashbytes_valid =
-            hashbytes.length === 20 || hashbytes.length === 32;
-          const stx_liq_supply =
-            pox_4_info.value.data["total-liquid-supply-ustx"];
-
-          assert(isClarityType(stx_liq_supply, ClarityType.UInt));
-          const stacking_threshold_met =
-            amount_ustx >=
-            Math.floor(
-              Number(stx_liq_supply.value) / testnet_stacking_threshold_25
-            );
-          const expectedResponseErr = !stacking_threshold_met
-            ? 11
-            : !stacking_valid_amount
-            ? 18
-            : !pox_lock_period_valid
-            ? 2
-            : !pox_version_valid
-            ? 13
-            : !pox_hashbytes_valid
-            ? 13
-            : 0;
           const expectedResponseOk = true;
 
           // Act
@@ -380,55 +482,83 @@ describe("test pox-4 contract read only functions", () => {
             POX_4,
             "can-stack-stx",
             [
-              Cl.tupleCV({
+              Cl.tuple({
                 version: bufferCV(Uint8Array.from([version])),
                 hashbytes: bufferCV(Uint8Array.from(hashbytes)),
               }),
-              Cl.uintCV(amount_ustx),
-              Cl.uintCV(first_rew_cycle),
-              Cl.uintCV(num_cycles),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
             ],
             caller
           );
 
           // Assert
-          assert(
-            isClarityType(
-              actual,
-              stacking_threshold_met &&
-                stacking_valid_amount &&
-                pox_lock_period_valid &&
-                pox_version_valid &&
-                pox_hashbytes_valid
-                ? ClarityType.ResponseOk
-                : ClarityType.ResponseErr
-            )
+          assert(isClarityType(actual, ClarityType.ResponseOk));
+          assert(isClarityType(actual.value, ClarityType.BoolTrue));
+          expect(actual).toBeOk(Cl.bool(expectedResponseOk));
+        }
+      )
+    );
+  });
+
+  it("should return (err 13) can-stack-stx for versions 0-4 pox addresses having hasbytes longer than 20", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 0, max: 4 }),
+        fc.array(fc.nat({ max: 255 }), {
+          minLength: 21,
+          maxLength: 32,
+        }),
+        fc.bigInt({
+          min: 125_000_000_000n,
+          max: 340282366920938463463374607431768211455n,
+        }),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            POX_4,
+            GET_POX_INFO,
+            [],
+            caller
           );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+          const expectedResponseErr = 13;
 
-          assert(
-            isClarityType(
-              actual.value,
-              stacking_threshold_met &&
-                stacking_valid_amount &&
-                pox_lock_period_valid &&
-                pox_version_valid &&
-                pox_hashbytes_valid
-                ? ClarityType.BoolTrue
-                : ClarityType.Int
-            )
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "can-stack-stx",
+            [
+              Cl.tuple({
+                version: bufferCV(Uint8Array.from([version])),
+                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
           );
-          if (expectedResponseErr === 0) {
-            expect(actual).toBeOk(
-              Cl.responseOkCV(Cl.boolCV(expectedResponseOk))
-            );
-            expect(actual.value).toBeBool(expectedResponseOk);
-          } else {
-            expect(actual).toBeErr(Cl.intCV(expectedResponseErr));
-            expect(actual.value).toBeInt(expectedResponseErr);
-          }
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
         }
-      ),
-      { numRuns: 300 }
+      )
     );
   });
 });

From f4054a09ac95b4c93cec2109862f1f447571951e Mon Sep 17 00:00:00 2001
From: BowTiedDevOps <157840260+BowTiedDevOps@users.noreply.github.com>
Date: Mon, 4 Mar 2024 18:19:07 +0200
Subject: [PATCH 1007/1166] feat: replace old rustfmt action with custom one
 for alias input

---
 .github/workflows/ci.yml | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 552196e4ce..434c977a56 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -80,7 +80,9 @@ jobs:
 
       - name: Rustfmt
         id: rustfmt
-        uses: actions-rust-lang/rustfmt@2d1d4e9f72379428552fa1def0b898733fb8472d # v1.1.0
+        uses: stacks-network/actions/rustfmt@main
+        with:
+          alias: "fmt-stacks"
 
   ######################################################################################
   ## Create a tagged github release

From f4ae100e6c30e8ec1f670ab444ba1e03e5c215f0 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Mon, 4 Mar 2024 08:21:51 -0800
Subject: [PATCH 1008/1166] fix: mutants

---
 stackslib/src/util_lib/signed_structured_data.rs | 2 ++
 testnet/stacks-node/src/mockamoto.rs             | 1 +
 2 files changed, 3 insertions(+)

diff --git a/stackslib/src/util_lib/signed_structured_data.rs b/stackslib/src/util_lib/signed_structured_data.rs
index cb0f7b7ad4..a61e77e48c 100644
--- a/stackslib/src/util_lib/signed_structured_data.rs
+++ b/stackslib/src/util_lib/signed_structured_data.rs
@@ -122,6 +122,7 @@ pub mod pox4 {
     }
 
     impl Into<Pox4SignatureTopic> for &'static str {
+        #[cfg_attr(test, mutants::skip)]
         fn into(self) -> Pox4SignatureTopic {
             match self {
                 "stack-stx" => Pox4SignatureTopic::StackStx,
@@ -133,6 +134,7 @@ pub mod pox4 {
         }
     }
 
+    #[cfg_attr(test, mutants::skip)]
     pub fn make_pox_4_signer_key_signature(
         pox_addr: &PoxAddress,
         signer_key: &StacksPrivateKey,
diff --git a/testnet/stacks-node/src/mockamoto.rs b/testnet/stacks-node/src/mockamoto.rs
index a15b0f886c..fa1d58777b 100644
--- a/testnet/stacks-node/src/mockamoto.rs
+++ b/testnet/stacks-node/src/mockamoto.rs
@@ -732,6 +732,7 @@ impl MockamotoNode {
         Ok(())
     }
 
+    #[cfg_attr(test, mutants::skip)]
     fn mine_stacks_block(&mut self) -> Result<NakamotoBlock, ChainstateError> {
         let miner_principal = StacksAddress::from_public_keys(
             C32_ADDRESS_VERSION_TESTNET_SINGLESIG,

From 1fb9876412153e7c43a430621e0f7a224cdf964e Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Mon, 4 Mar 2024 11:37:29 -0500
Subject: [PATCH 1009/1166] Revert "feat: setup `blind-signer` lib and binary"

This reverts commit b04386d4f5950484f1618703ff22b87317b6a138.
Since the signer is ready, this blind signer is not necessary and it is
better to not add this additional component that needs to be kept
updated.
---
 Cargo.lock                                    |  15 -
 Cargo.toml                                    |   8 +-
 blind-signer/Cargo.toml                       |  30 --
 blind-signer/src/lib.rs                       | 290 ------------------
 blind-signer/src/main.rs                      |  41 ---
 testnet/stacks-node/Cargo.toml                |   6 -
 .../burnchains/bitcoin_regtest_controller.rs  |   5 +-
 testnet/stacks-node/src/chain_data.rs         |   1 -
 testnet/stacks-node/src/config.rs             |   2 -
 testnet/stacks-node/src/event_dispatcher.rs   |   3 +-
 testnet/stacks-node/src/globals.rs            |   2 +-
 testnet/stacks-node/src/lib.rs                |   9 -
 testnet/stacks-node/src/main.rs               |   6 +-
 testnet/stacks-node/src/nakamoto_node.rs      |   2 +-
 .../stacks-node/src/nakamoto_node/miner.rs    |   5 +-
 testnet/stacks-node/src/nakamoto_node/peer.rs |   3 +-
 .../stacks-node/src/nakamoto_node/relayer.rs  |   8 +-
 testnet/stacks-node/src/neon_node.rs          |   5 +-
 testnet/stacks-node/src/node.rs               |   3 +-
 .../stacks-node/src/run_loop/boot_nakamoto.rs |   2 +-
 testnet/stacks-node/src/run_loop/helium.rs    |   5 +-
 testnet/stacks-node/src/run_loop/nakamoto.rs  |   5 +-
 testnet/stacks-node/src/run_loop/neon.rs      |   5 +-
 testnet/stacks-node/src/syncctl.rs            |   2 +-
 testnet/stacks-node/src/tenure.rs             |   3 +-
 .../stacks-node/src/tests/bitcoin_regtest.rs  |   2 +-
 testnet/stacks-node/src/tests/epoch_205.rs    |   3 +-
 testnet/stacks-node/src/tests/epoch_21.rs     |   3 +-
 testnet/stacks-node/src/tests/epoch_22.rs     |   4 +-
 testnet/stacks-node/src/tests/epoch_23.rs     |   3 +-
 testnet/stacks-node/src/tests/epoch_24.rs     |   7 +-
 testnet/stacks-node/src/tests/integrations.rs |   2 +-
 .../src/tests/nakamoto_integrations.rs        | 261 +++++++++++++++-
 .../src/tests/neon_integrations.rs            |  53 +++-
 testnet/stacks-node/src/tests/signer.rs       |   6 +-
 testnet/stacks-node/src/tests/stackerdb.rs    |   5 +-
 testnet/stacks-node/src/utils.rs              | 195 ------------
 37 files changed, 347 insertions(+), 663 deletions(-)
 delete mode 100644 blind-signer/Cargo.toml
 delete mode 100644 blind-signer/src/lib.rs
 delete mode 100644 blind-signer/src/main.rs
 delete mode 100644 testnet/stacks-node/src/lib.rs
 delete mode 100644 testnet/stacks-node/src/utils.rs

diff --git a/Cargo.lock b/Cargo.lock
index ab0e3e0e96..aedba0ffaa 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -522,20 +522,6 @@ dependencies = [
  "wyz",
 ]
 
-[[package]]
-name = "blind-signer"
-version = "0.1.0"
-dependencies = [
- "libsigner",
- "pico-args",
- "reqwest",
- "serde_json",
- "slog",
- "stacks-common",
- "stacks-node",
- "stackslib",
-]
-
 [[package]]
 name = "block-buffer"
 version = "0.9.0"
@@ -3510,7 +3496,6 @@ dependencies = [
  "async-std",
  "backtrace",
  "base64 0.12.3",
- "blind-signer",
  "chrono",
  "clarity",
  "hashbrown 0.14.3",
diff --git a/Cargo.toml b/Cargo.toml
index d24c04a8ba..66791df99c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -10,13 +10,11 @@ members = [
     "contrib/tools/relay-server",
     "libsigner",
     "stacks-signer",
-    "testnet/stacks-node",
-    "blind-signer",
-]
+    "testnet/stacks-node"]
 
 # Dependencies we want to keep the same between workspace members
-[workspace.dependencies]
-ed25519-dalek = { version = "2.1.1", features = ["serde", "rand_core"] }
+[workspace.dependencies]  
+ed25519-dalek = { version = "2.1.1", features = ["serde", "rand_core"] } 
 hashbrown = "0.14.3"
 rand_core = "0.6"
 rand = "0.8"
diff --git a/blind-signer/Cargo.toml b/blind-signer/Cargo.toml
deleted file mode 100644
index a4087aec80..0000000000
--- a/blind-signer/Cargo.toml
+++ /dev/null
@@ -1,30 +0,0 @@
-[package]
-name = "blind-signer"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-slog = { version = "2.5.2", features = ["max_level_trace"] }
-pico-args = "0.5.0"
-reqwest = { version = "0.11", default_features = false, features = [
-  "blocking",
-  "json",
-  "rustls",
-  "rustls-tls",
-] }
-serde_json = { version = "1.0", features = [
-  "arbitrary_precision",
-  "raw_value",
-] }
-stacks = { package = "stackslib", path = "../stackslib" }
-stacks-common = { path = "../stacks-common" }
-libsigner = { path = "../libsigner" }
-stacks-node = { path = "../testnet/stacks-node" }
-
-[lib]
-name = "blind_signer"
-path = "src/lib.rs"
-
-[[bin]]
-name = "blind-signer"
-path = "src/main.rs"
diff --git a/blind-signer/src/lib.rs b/blind-signer/src/lib.rs
deleted file mode 100644
index 5bc8d0f99d..0000000000
--- a/blind-signer/src/lib.rs
+++ /dev/null
@@ -1,290 +0,0 @@
-use libsigner::{BlockResponse, SignerMessage, SignerSession, StackerDBSession};
-use stacks::chainstate::burn::db::sortdb::SortitionDB;
-use stacks::chainstate::nakamoto::signer_set::NakamotoSigners;
-use stacks::chainstate::nakamoto::test_signers::TestSigners;
-use stacks::chainstate::nakamoto::{NakamotoBlock, NakamotoChainState};
-use stacks::chainstate::stacks::boot::{MINERS_NAME, SIGNERS_VOTING_NAME};
-use stacks::clarity::vm::types::QualifiedContractIdentifier;
-use stacks::clarity::vm::Value;
-use stacks::codec::StacksMessageCodec;
-use stacks::libstackerdb::{SlotMetadata, StackerDBChunkData};
-use stacks::net::api::callreadonly::CallReadOnlyRequestBody;
-use stacks::net::api::getstackers::GetStackersResponse;
-use stacks::types::chainstate::StacksAddress;
-use stacks::util::hash::to_hex;
-use stacks::util_lib::boot::boot_code_id;
-use stacks_common::types::chainstate::StacksPublicKey;
-use stacks_common::util::hash::Sha512Trunc256Sum;
-use stacks_common::util::secp256k1::{Secp256k1PrivateKey, Secp256k1PublicKey};
-use stacks_node::config::Config;
-use stacks_node::utils::{get_account, make_contract_call, submit_tx, to_addr};
-use std::{
-    collections::HashSet,
-    thread::{self, JoinHandle},
-    time::Duration,
-};
-
-#[allow(unused_imports)]
-#[macro_use(o, slog_log, slog_trace, slog_debug, slog_info, slog_warn, slog_error)]
-extern crate slog;
-#[macro_use]
-extern crate stacks_common;
-
-/// Spawn a blind signing thread. `signer` is the private key
-///  of the individual signer who broadcasts the response to the StackerDB
-pub fn blind_signer(
-    conf: &Config,
-    signers: &TestSigners,
-    signer: &Secp256k1PrivateKey,
-) -> JoinHandle<()> {
-    let mut signed_blocks = HashSet::new();
-    let conf = conf.clone();
-    let signers = signers.clone();
-    let signer = signer.clone();
-    thread::spawn(move || loop {
-        thread::sleep(Duration::from_millis(500));
-        match read_and_sign_block_proposal(&conf, &signers, &signer, &signed_blocks) {
-            Ok(signed_block) => {
-                if signed_blocks.contains(&signed_block) {
-                    continue;
-                }
-                info!("Signed block"; "signer_sig_hash" => signed_block.to_hex());
-                signed_blocks.insert(signed_block);
-            }
-            Err(e) => {
-                warn!("Error reading and signing block proposal: {e}");
-            }
-        }
-
-        signer_vote_if_needed(&conf, &signers, &signer);
-    })
-}
-
-pub fn read_and_sign_block_proposal(
-    conf: &Config,
-    signers: &TestSigners,
-    signer: &Secp256k1PrivateKey,
-    signed_blocks: &HashSet<Sha512Trunc256Sum>,
-) -> Result<Sha512Trunc256Sum, String> {
-    let burnchain = conf.get_burnchain();
-    let sortdb = burnchain.open_sortition_db(true).unwrap();
-    let tip = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn()).unwrap();
-    let miner_pubkey = StacksPublicKey::from_private(&conf.get_miner_config().mining_key.unwrap());
-    let miner_slot_id = NakamotoChainState::get_miner_slot(&sortdb, &tip, &miner_pubkey)
-        .map_err(|_| "Unable to get miner slot")?
-        .ok_or("No miner slot exists")?;
-    let reward_cycle = burnchain
-        .block_height_to_reward_cycle(tip.block_height)
-        .unwrap();
-    let rpc_sock = conf
-        .node
-        .rpc_bind
-        .clone()
-        .parse()
-        .expect("Failed to parse socket");
-
-    let mut proposed_block: NakamotoBlock = {
-        let miner_contract_id = boot_code_id(MINERS_NAME, false);
-        let mut miners_stackerdb = StackerDBSession::new(rpc_sock, miner_contract_id);
-        miners_stackerdb
-            .get_latest(miner_slot_id)
-            .map_err(|_| "Failed to get latest chunk from the miner slot ID")?
-            .ok_or("No chunk found")?
-    };
-    let proposed_block_hash = format!("0x{}", proposed_block.header.block_hash());
-    let signer_sig_hash = proposed_block.header.signer_signature_hash();
-    if signed_blocks.contains(&signer_sig_hash) {
-        // already signed off on this block, don't sign again.
-        return Ok(signer_sig_hash);
-    }
-
-    info!(
-        "Fetched proposed block from .miners StackerDB";
-        "proposed_block_hash" => &proposed_block_hash,
-        "signer_sig_hash" => &signer_sig_hash.to_hex(),
-    );
-
-    signers
-        .clone()
-        .sign_nakamoto_block(&mut proposed_block, reward_cycle);
-
-    let signer_message = SignerMessage::BlockResponse(BlockResponse::Accepted((
-        signer_sig_hash.clone(),
-        proposed_block.header.signer_signature.clone(),
-    )));
-
-    let signers_contract_id =
-        NakamotoSigners::make_signers_db_contract_id(reward_cycle, libsigner::BLOCK_MSG_ID, false);
-
-    let http_origin = format!("http://{}", &conf.node.rpc_bind);
-    let signers_info = get_stacker_set(&http_origin, reward_cycle);
-    let signer_index = get_signer_index(&signers_info, &Secp256k1PublicKey::from_private(signer))
-        .unwrap()
-        .try_into()
-        .unwrap();
-
-    let next_version = get_stackerdb_slot_version(&http_origin, &signers_contract_id, signer_index)
-        .map(|x| x + 1)
-        .unwrap_or(0);
-    let mut signers_contract_sess = StackerDBSession::new(rpc_sock, signers_contract_id);
-    let mut chunk_to_put = StackerDBChunkData::new(
-        u32::try_from(signer_index).unwrap(),
-        next_version,
-        signer_message.serialize_to_vec(),
-    );
-    chunk_to_put.sign(signer).unwrap();
-    signers_contract_sess
-        .put_chunk(&chunk_to_put)
-        .map_err(|e| e.to_string())?;
-    Ok(signer_sig_hash)
-}
-
-fn signer_vote_if_needed(conf: &Config, signers: &TestSigners, signer: &Secp256k1PrivateKey) {
-    let burnchain = conf.get_burnchain();
-    let sortdb = burnchain.open_sortition_db(true).unwrap();
-    let tip = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn()).unwrap();
-    let reward_cycle = burnchain
-        .block_height_to_reward_cycle(tip.block_height)
-        .unwrap();
-    let prepare_phase_start = burnchain
-        .pox_constants
-        .prepare_phase_start(burnchain.first_block_height, reward_cycle);
-
-    if tip.block_height >= prepare_phase_start {
-        // If the key is already set, do nothing.
-        if is_key_set_for_cycle(reward_cycle + 1, conf.is_mainnet(), &conf.node.rpc_bind)
-            .unwrap_or(false)
-        {
-            return;
-        }
-
-        // If we are self-signing, then we need to vote on the aggregate public key
-        let http_origin = format!("http://{}", &conf.node.rpc_bind);
-
-        // Get the aggregate key
-        let aggregate_key = signers.clone().generate_aggregate_key(reward_cycle + 1);
-        let aggregate_public_key = Value::buff_from(aggregate_key.compress().data.to_vec())
-            .expect("Failed to serialize aggregate public key");
-
-        let signer_nonce = get_account(&http_origin, &to_addr(signer)).nonce;
-
-        // Vote on the aggregate public key
-        let voting_tx = make_contract_call(
-            &signer,
-            signer_nonce,
-            300,
-            &StacksAddress::burn_address(false),
-            SIGNERS_VOTING_NAME,
-            "vote-for-aggregate-public-key",
-            &[
-                Value::UInt(0),
-                aggregate_public_key.clone(),
-                Value::UInt(0),
-                Value::UInt(reward_cycle as u128 + 1),
-            ],
-        );
-        submit_tx(&http_origin, &voting_tx);
-    }
-}
-
-pub fn get_stacker_set(http_origin: &str, cycle: u64) -> GetStackersResponse {
-    let client = reqwest::blocking::Client::new();
-    let path = format!("{http_origin}/v2/stacker_set/{cycle}");
-    let res = client
-        .get(&path)
-        .send()
-        .unwrap()
-        .json::<serde_json::Value>()
-        .unwrap();
-    info!("Stacker set response: {res}");
-    let res = serde_json::from_value(res).unwrap();
-    res
-}
-
-fn get_signer_index(
-    stacker_set: &GetStackersResponse,
-    signer_key: &Secp256k1PublicKey,
-) -> Result<usize, String> {
-    let Some(ref signer_set) = stacker_set.stacker_set.signers else {
-        return Err("Empty signer set for reward cycle".into());
-    };
-    let signer_key_bytes = signer_key.to_bytes_compressed();
-    signer_set
-        .iter()
-        .enumerate()
-        .find_map(|(ix, entry)| {
-            if entry.signing_key.as_slice() == signer_key_bytes.as_slice() {
-                Some(ix)
-            } else {
-                None
-            }
-        })
-        .ok_or_else(|| {
-            format!(
-                "Signing key not found. {} not found.",
-                to_hex(&signer_key_bytes)
-            )
-        })
-}
-
-pub fn get_stackerdb_slot_version(
-    http_origin: &str,
-    contract: &QualifiedContractIdentifier,
-    slot_id: u64,
-) -> Option<u32> {
-    let client = reqwest::blocking::Client::new();
-    let path = format!(
-        "{http_origin}/v2/stackerdb/{}/{}",
-        &contract.issuer, &contract.name
-    );
-    let res = client
-        .get(&path)
-        .send()
-        .unwrap()
-        .json::<Vec<SlotMetadata>>()
-        .unwrap();
-    debug!("StackerDB metadata response: {res:?}");
-    res.iter().find_map(|slot| {
-        if u64::from(slot.slot_id) == slot_id {
-            Some(slot.slot_version)
-        } else {
-            None
-        }
-    })
-}
-
-fn is_key_set_for_cycle(
-    reward_cycle: u64,
-    is_mainnet: bool,
-    http_origin: &str,
-) -> Result<bool, String> {
-    let client = reqwest::blocking::Client::new();
-    let boot_address = StacksAddress::burn_address(is_mainnet);
-    let path = format!("http://{http_origin}/v2/contracts/call-read/{boot_address}/signers-voting/get-approved-aggregate-key");
-    let body = CallReadOnlyRequestBody {
-        sender: boot_address.to_string(),
-        sponsor: None,
-        arguments: vec![Value::UInt(reward_cycle as u128)
-            .serialize_to_hex()
-            .map_err(|_| "Failed to serialize reward cycle")?],
-    };
-    let res = client
-        .post(&path)
-        .json(&body)
-        .send()
-        .map_err(|_| "Failed to send request")?
-        .json::<serde_json::Value>()
-        .map_err(|_| "Failed to extract json Value")?;
-    let result_value = Value::try_deserialize_hex_untyped(
-        &res.get("result")
-            .ok_or("No result in response")?
-            .as_str()
-            .ok_or("Result is not a string")?[2..],
-    )
-    .map_err(|_| "Failed to deserialize Clarity value")?;
-
-    result_value
-        .expect_optional()
-        .map(|v| v.is_some())
-        .map_err(|_| "Response is not optional".to_string())
-}
diff --git a/blind-signer/src/main.rs b/blind-signer/src/main.rs
deleted file mode 100644
index e7409ffbff..0000000000
--- a/blind-signer/src/main.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-#[macro_use]
-extern crate stacks_common;
-
-use std::{process, thread::park};
-
-use pico_args::Arguments;
-use stacks::{
-    chainstate::nakamoto::test_signers::TestSigners, util::secp256k1::Secp256k1PrivateKey,
-};
-use stacks_node::config::{Config, ConfigFile};
-
-#[allow(unused_imports)]
-#[macro_use(o, slog_log, slog_trace, slog_debug, slog_info, slog_warn, slog_error)]
-extern crate slog;
-
-fn main() {
-    let mut args = Arguments::from_env();
-    let config_path: String = args.value_from_str("--config").unwrap();
-    args.finish();
-    info!("Loading config at path {}", config_path);
-    let config_file = match ConfigFile::from_path(&config_path) {
-        Ok(config_file) => config_file,
-        Err(e) => {
-            warn!("Invalid config file: {}", e);
-            process::exit(1);
-        }
-    };
-
-    let conf = match Config::from_config_file(config_file) {
-        Ok(conf) => conf,
-        Err(e) => {
-            warn!("Invalid config: {}", e);
-            process::exit(1);
-        }
-    };
-
-    let signers = TestSigners::default();
-    let sender_signer_sk = Secp256k1PrivateKey::new();
-    blind_signer::blind_signer(&conf, &signers, &sender_signer_sk);
-    park();
-}
diff --git a/testnet/stacks-node/Cargo.toml b/testnet/stacks-node/Cargo.toml
index 0e5862ddbf..71f8808a12 100644
--- a/testnet/stacks-node/Cargo.toml
+++ b/testnet/stacks-node/Cargo.toml
@@ -31,7 +31,6 @@ wsts = { workspace = true }
 rand = { workspace = true }
 rand_core = { workspace = true }
 hashbrown = { workspace = true }
-reqwest = { version = "0.11", default_features = false, features = ["blocking", "json", "rustls", "rustls-tls"] }
 
 [target.'cfg(not(target_env = "msvc"))'.dependencies]
 tikv-jemallocator = {workspace = true}
@@ -45,7 +44,6 @@ clarity = { path = "../../clarity", features = ["default", "testing"]}
 stacks-common = { path = "../../stacks-common", features = ["default", "testing"] }
 stacks = { package = "stackslib", path = "../../stackslib", features = ["default", "testing"] }
 stacks-signer = { path = "../../stacks-signer" }
-blind-signer = { path = "../../blind-signer" }
 tracing = "0.1.37"
 tracing-subscriber = { version = "0.3.17", features = ["env-filter"] }
 wsts = {workspace = true}
@@ -63,10 +61,6 @@ path = "src/main.rs"
 name = "stacks-events"
 path = "src/stacks_events.rs"
 
-[lib]
-name = "stacks_node"
-path = "src/lib.rs"
-
 [features]
 monitoring_prom = ["stacks/monitoring_prom"]
 slog_json = ["stacks/slog_json", "stacks-common/slog_json", "clarity/slog_json"]
diff --git a/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs b/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
index 0507162ad4..f2e6f69542 100644
--- a/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
+++ b/testnet/stacks-node/src/burnchains/bitcoin_regtest_controller.rs
@@ -53,9 +53,9 @@ use stacks_common::types::chainstate::BurnchainHeaderHash;
 use stacks_common::util::hash::{hex_bytes, Hash160};
 use stacks_common::util::secp256k1::Secp256k1PublicKey;
 use stacks_common::util::sleep_ms;
-use stacks_node::config::Config;
 
 use super::super::operations::BurnchainOpSigner;
+use super::super::Config;
 use super::{BurnchainController, BurnchainTip, Error as BurnchainControllerError};
 
 /// The number of bitcoin blocks that can have
@@ -2556,9 +2556,8 @@ mod tests {
     use std::fs::File;
     use std::io::Write;
 
-    use stacks_node::config::DEFAULT_SATS_PER_VB;
-
     use super::*;
+    use crate::config::DEFAULT_SATS_PER_VB;
 
     #[test]
     fn test_get_satoshis_per_byte() {
diff --git a/testnet/stacks-node/src/chain_data.rs b/testnet/stacks-node/src/chain_data.rs
index cf502058af..4170cf6f6d 100644
--- a/testnet/stacks-node/src/chain_data.rs
+++ b/testnet/stacks-node/src/chain_data.rs
@@ -17,7 +17,6 @@
 use std::collections::HashMap;
 use std::process::{Command, Stdio};
 
-use serde::{Deserialize, Serialize};
 use stacks::burnchains::bitcoin::address::BitcoinAddress;
 use stacks::burnchains::bitcoin::{BitcoinNetworkType, BitcoinTxOutput};
 use stacks::burnchains::{Burnchain, BurnchainSigner, Error as BurnchainError, Txid};
diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index d8b2192191..cc39fb1e52 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -9,7 +9,6 @@ use clarity::vm::costs::ExecutionCost;
 use clarity::vm::types::{AssetIdentifier, PrincipalData, QualifiedContractIdentifier};
 use lazy_static::lazy_static;
 use rand::RngCore;
-use serde::Deserialize;
 use stacks::burnchains::bitcoin::BitcoinNetworkType;
 use stacks::burnchains::{Burnchain, MagicBytes, BLOCKSTACK_MAGIC_MAINNET};
 use stacks::chainstate::nakamoto::signer_set::NakamotoSigners;
@@ -34,7 +33,6 @@ use stacks::net::{Neighbor, NeighborKey};
 use stacks::util_lib::boot::boot_code_id;
 use stacks::util_lib::db::Error as DBError;
 use stacks_common::consts::SIGNER_SLOTS_PER_USER;
-use stacks_common::test_debug;
 use stacks_common::types::chainstate::StacksAddress;
 use stacks_common::types::net::PeerAddress;
 use stacks_common::types::Address;
diff --git a/testnet/stacks-node/src/event_dispatcher.rs b/testnet/stacks-node/src/event_dispatcher.rs
index 88774e35eb..90272bd0b8 100644
--- a/testnet/stacks-node/src/event_dispatcher.rs
+++ b/testnet/stacks-node/src/event_dispatcher.rs
@@ -39,7 +39,8 @@ use stacks::net::stackerdb::StackerDBEventDispatcher;
 use stacks_common::codec::StacksMessageCodec;
 use stacks_common::types::chainstate::{BlockHeaderHash, BurnchainHeaderHash, StacksBlockId};
 use stacks_common::util::hash::bytes_to_hex;
-use stacks_node::config::{EventKeyType, EventObserverConfig};
+
+use super::config::{EventKeyType, EventObserverConfig};
 
 #[derive(Debug, Clone)]
 struct EventObserver {
diff --git a/testnet/stacks-node/src/globals.rs b/testnet/stacks-node/src/globals.rs
index 3e4b32fbae..a6a2fdad3c 100644
--- a/testnet/stacks-node/src/globals.rs
+++ b/testnet/stacks-node/src/globals.rs
@@ -12,8 +12,8 @@ use stacks::chainstate::stacks::db::StacksChainState;
 use stacks::chainstate::stacks::miner::MinerStatus;
 use stacks::net::NetworkResult;
 use stacks_common::types::chainstate::{BlockHeaderHash, BurnchainHeaderHash, ConsensusHash};
-use stacks_node::config::MinerConfig;
 
+use crate::config::MinerConfig;
 use crate::neon::Counters;
 use crate::neon_node::LeaderKeyRegistrationState;
 use crate::run_loop::RegisteredKey;
diff --git a/testnet/stacks-node/src/lib.rs b/testnet/stacks-node/src/lib.rs
deleted file mode 100644
index a7ca5cd959..0000000000
--- a/testnet/stacks-node/src/lib.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-#[allow(unused_imports)]
-#[macro_use(o, slog_log, slog_trace, slog_debug, slog_info, slog_warn, slog_error)]
-extern crate slog;
-#[macro_use]
-extern crate stacks_common;
-
-pub mod chain_data;
-pub mod config;
-pub mod utils;
diff --git a/testnet/stacks-node/src/main.rs b/testnet/stacks-node/src/main.rs
index 1d0f3d8114..bf54c1601d 100644
--- a/testnet/stacks-node/src/main.rs
+++ b/testnet/stacks-node/src/main.rs
@@ -12,12 +12,12 @@ extern crate slog;
 
 pub use stacks_common::util;
 use stacks_common::util::hash::hex_bytes;
-use stacks_node::chain_data::MinerStats;
-use stacks_node::config::{Config, ConfigFile};
 
 pub mod monitoring;
 
 pub mod burnchains;
+pub mod chain_data;
+pub mod config;
 pub mod event_dispatcher;
 pub mod genesis_data;
 pub mod globals;
@@ -47,11 +47,13 @@ use tikv_jemallocator::Jemalloc;
 pub use self::burnchains::{
     BitcoinRegtestController, BurnchainController, BurnchainTip, MocknetController,
 };
+pub use self::config::{Config, ConfigFile};
 pub use self::event_dispatcher::EventDispatcher;
 pub use self::keychain::Keychain;
 pub use self::node::{ChainTip, Node};
 pub use self::run_loop::{helium, neon};
 pub use self::tenure::Tenure;
+use crate::chain_data::MinerStats;
 use crate::neon_node::{BlockMinerThread, TipCandidate};
 use crate::run_loop::boot_nakamoto;
 
diff --git a/testnet/stacks-node/src/nakamoto_node.rs b/testnet/stacks-node/src/nakamoto_node.rs
index d8543f8537..302382f170 100644
--- a/testnet/stacks-node/src/nakamoto_node.rs
+++ b/testnet/stacks-node/src/nakamoto_node.rs
@@ -30,11 +30,11 @@ use stacks::net::stackerdb::StackerDBs;
 use stacks_common::types::chainstate::SortitionId;
 use stacks_common::types::StacksEpochId;
 
+use super::{Config, EventDispatcher, Keychain};
 use crate::burnchains::bitcoin_regtest_controller::addr2str;
 use crate::neon_node::{LeaderKeyRegistrationState, StacksNode as NeonNode};
 use crate::run_loop::nakamoto::{Globals, RunLoop};
 use crate::run_loop::RegisteredKey;
-use crate::Keychain;
 
 pub mod miner;
 pub mod peer;
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index 82d48544b6..ea29833b4d 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -46,15 +46,14 @@ use stacks_common::types::chainstate::{StacksAddress, StacksBlockId};
 use stacks_common::types::{PrivateKey, StacksEpochId};
 use stacks_common::util::hash::{Hash160, Sha512Trunc256Sum};
 use stacks_common::util::vrf::VRFProof;
-use stacks_node::config::Config;
 use wsts::curve::point::Point;
 
 use super::relayer::RelayerThread;
-use super::{Error as NakamotoNodeError, Keychain};
+use super::{Config, Error as NakamotoNodeError, EventDispatcher, Keychain};
 use crate::nakamoto_node::VRF_MOCK_MINER_KEY;
 use crate::run_loop::nakamoto::Globals;
 use crate::run_loop::RegisteredKey;
-use crate::{neon_node, ChainTip, EventDispatcher};
+use crate::{neon_node, ChainTip};
 
 /// If the miner was interrupted while mining a block, how long should the
 ///  miner thread sleep before trying again?
diff --git a/testnet/stacks-node/src/nakamoto_node/peer.rs b/testnet/stacks-node/src/nakamoto_node/peer.rs
index 0bd73da5fc..eeb6789d30 100644
--- a/testnet/stacks-node/src/nakamoto_node/peer.rs
+++ b/testnet/stacks-node/src/nakamoto_node/peer.rs
@@ -31,13 +31,12 @@ use stacks::net::dns::{DNSClient, DNSResolver};
 use stacks::net::p2p::PeerNetwork;
 use stacks::net::RPCHandlerArgs;
 use stacks_common::util::hash::Sha256Sum;
-use stacks_node::config::Config;
 
 use crate::burnchains::make_bitcoin_indexer;
 use crate::nakamoto_node::relayer::RelayerDirective;
 use crate::neon_node::open_chainstate_with_faults;
 use crate::run_loop::nakamoto::{Globals, RunLoop};
-use crate::EventDispatcher;
+use crate::{Config, EventDispatcher};
 
 /// Thread that runs the network state machine, handling both p2p and http requests.
 pub struct PeerThread {
diff --git a/testnet/stacks-node/src/nakamoto_node/relayer.rs b/testnet/stacks-node/src/nakamoto_node/relayer.rs
index 09d661f775..1ee3135c24 100644
--- a/testnet/stacks-node/src/nakamoto_node/relayer.rs
+++ b/testnet/stacks-node/src/nakamoto_node/relayer.rs
@@ -50,9 +50,11 @@ use stacks_common::types::StacksEpochId;
 use stacks_common::util::get_epoch_time_ms;
 use stacks_common::util::hash::Hash160;
 use stacks_common::util::vrf::{VRFProof, VRFPublicKey};
-use stacks_node::config::Config;
 
-use super::{BlockCommits, Error as NakamotoNodeError, Keychain, BLOCK_PROCESSOR_STACK_SIZE};
+use super::{
+    BlockCommits, Config, Error as NakamotoNodeError, EventDispatcher, Keychain,
+    BLOCK_PROCESSOR_STACK_SIZE,
+};
 use crate::burnchains::BurnchainController;
 use crate::nakamoto_node::miner::{BlockMinerThread, MinerDirective};
 use crate::neon_node::{
@@ -60,7 +62,7 @@ use crate::neon_node::{
 };
 use crate::run_loop::nakamoto::{Globals, RunLoop};
 use crate::run_loop::RegisteredKey;
-use crate::{BitcoinRegtestController, EventDispatcher};
+use crate::BitcoinRegtestController;
 
 /// Command types for the Nakamoto relayer thread, issued to it by other threads
 pub enum RelayerDirective {
diff --git a/testnet/stacks-node/src/neon_node.rs b/testnet/stacks-node/src/neon_node.rs
index 7bd69b028e..49064d4971 100644
--- a/testnet/stacks-node/src/neon_node.rs
+++ b/testnet/stacks-node/src/neon_node.rs
@@ -201,14 +201,13 @@ use stacks_common::util::hash::{to_hex, Hash160, Sha256Sum};
 use stacks_common::util::secp256k1::Secp256k1PrivateKey;
 use stacks_common::util::vrf::{VRFProof, VRFPublicKey};
 use stacks_common::util::{get_epoch_time_ms, get_epoch_time_secs};
-use stacks_node::chain_data::MinerStats;
-use stacks_node::config::Config;
 
-use super::{BurnchainController, EventDispatcher, Keychain};
+use super::{BurnchainController, Config, EventDispatcher, Keychain};
 use crate::burnchains::bitcoin_regtest_controller::{
     addr2str, BitcoinRegtestController, OngoingBlockCommit,
 };
 use crate::burnchains::make_bitcoin_indexer;
+use crate::chain_data::MinerStats;
 use crate::globals::{NeonGlobals as Globals, RelayerDirective};
 use crate::run_loop::neon::RunLoop;
 use crate::run_loop::RegisteredKey;
diff --git a/testnet/stacks-node/src/node.rs b/testnet/stacks-node/src/node.rs
index b004f9de3f..90c2123079 100644
--- a/testnet/stacks-node/src/node.rs
+++ b/testnet/stacks-node/src/node.rs
@@ -44,9 +44,8 @@ use stacks_common::util::get_epoch_time_secs;
 use stacks_common::util::hash::Sha256Sum;
 use stacks_common::util::secp256k1::Secp256k1PrivateKey;
 use stacks_common::util::vrf::VRFPublicKey;
-use stacks_node::config::Config;
 
-use super::{BurnchainController, BurnchainTip, EventDispatcher, Keychain, Tenure};
+use super::{BurnchainController, BurnchainTip, Config, EventDispatcher, Keychain, Tenure};
 use crate::burnchains::make_bitcoin_indexer;
 use crate::genesis_data::USE_TEST_GENESIS_CHAINSTATE;
 use crate::run_loop;
diff --git a/testnet/stacks-node/src/run_loop/boot_nakamoto.rs b/testnet/stacks-node/src/run_loop/boot_nakamoto.rs
index c6116de495..dec1ca757f 100644
--- a/testnet/stacks-node/src/run_loop/boot_nakamoto.rs
+++ b/testnet/stacks-node/src/run_loop/boot_nakamoto.rs
@@ -24,11 +24,11 @@ use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::coordinator::comm::CoordinatorChannels;
 use stacks::core::StacksEpochExtension;
 use stacks_common::types::{StacksEpoch, StacksEpochId};
-use stacks_node::config::Config;
 
 use crate::neon::Counters;
 use crate::run_loop::nakamoto::RunLoop as NakaRunLoop;
 use crate::run_loop::neon::RunLoop as NeonRunLoop;
+use crate::Config;
 
 /// This runloop handles booting to Nakamoto:
 /// During epochs [1.0, 2.5], it runs a neon run_loop.
diff --git a/testnet/stacks-node/src/run_loop/helium.rs b/testnet/stacks-node/src/run_loop/helium.rs
index 53e876d2ea..c7212d4132 100644
--- a/testnet/stacks-node/src/run_loop/helium.rs
+++ b/testnet/stacks-node/src/run_loop/helium.rs
@@ -1,10 +1,11 @@
 use stacks::chainstate::stacks::db::ClarityTx;
 use stacks_common::types::chainstate::BurnchainHeaderHash;
-use stacks_node::config::Config;
 
 use super::RunLoopCallbacks;
 use crate::burnchains::Error as BurnchainControllerError;
-use crate::{BitcoinRegtestController, BurnchainController, ChainTip, MocknetController, Node};
+use crate::{
+    BitcoinRegtestController, BurnchainController, ChainTip, Config, MocknetController, Node,
+};
 
 /// RunLoop is coordinating a simulated burnchain and some simulated nodes
 /// taking turns in producing blocks.
diff --git a/testnet/stacks-node/src/run_loop/nakamoto.rs b/testnet/stacks-node/src/run_loop/nakamoto.rs
index 8e64cb75a8..0b3702a994 100644
--- a/testnet/stacks-node/src/run_loop/nakamoto.rs
+++ b/testnet/stacks-node/src/run_loop/nakamoto.rs
@@ -33,7 +33,6 @@ use stacks::core::StacksEpochId;
 use stacks::net::atlas::{AtlasConfig, AtlasDB, Attachment};
 use stacks_common::types::PublicKey;
 use stacks_common::util::hash::Hash160;
-use stacks_node::config::Config;
 use stx_genesis::GenesisData;
 
 use crate::burnchains::make_bitcoin_indexer;
@@ -47,7 +46,9 @@ use crate::node::{
 use crate::run_loop::neon;
 use crate::run_loop::neon::Counters;
 use crate::syncctl::{PoxSyncWatchdog, PoxSyncWatchdogComms};
-use crate::{run_loop, BitcoinRegtestController, BurnchainController, EventDispatcher, Keychain};
+use crate::{
+    run_loop, BitcoinRegtestController, BurnchainController, Config, EventDispatcher, Keychain,
+};
 
 pub const STDERR: i32 = 2;
 pub type Globals = GenericGlobals<nakamoto_node::relayer::RelayerDirective>;
diff --git a/testnet/stacks-node/src/run_loop/neon.rs b/testnet/stacks-node/src/run_loop/neon.rs
index e65ee90ecf..86235ec3bd 100644
--- a/testnet/stacks-node/src/run_loop/neon.rs
+++ b/testnet/stacks-node/src/run_loop/neon.rs
@@ -27,7 +27,6 @@ use stacks_common::deps_common::ctrlc::SignalId;
 use stacks_common::types::PublicKey;
 use stacks_common::util::hash::Hash160;
 use stacks_common::util::{get_epoch_time_secs, sleep_ms};
-use stacks_node::config::Config;
 use stx_genesis::GenesisData;
 
 use super::RunLoopCallbacks;
@@ -40,7 +39,9 @@ use crate::node::{
     use_test_genesis_chainstate,
 };
 use crate::syncctl::{PoxSyncWatchdog, PoxSyncWatchdogComms};
-use crate::{run_loop, BitcoinRegtestController, BurnchainController, EventDispatcher, Keychain};
+use crate::{
+    run_loop, BitcoinRegtestController, BurnchainController, Config, EventDispatcher, Keychain,
+};
 
 pub const STDERR: i32 = 2;
 
diff --git a/testnet/stacks-node/src/syncctl.rs b/testnet/stacks-node/src/syncctl.rs
index 92915e8ed8..ff68126a83 100644
--- a/testnet/stacks-node/src/syncctl.rs
+++ b/testnet/stacks-node/src/syncctl.rs
@@ -5,9 +5,9 @@ use std::sync::Arc;
 use stacks::burnchains::{Burnchain, Error as burnchain_error};
 use stacks::chainstate::stacks::db::StacksChainState;
 use stacks_common::util::{get_epoch_time_secs, sleep_ms};
-use stacks_node::config::Config;
 
 use crate::burnchains::BurnchainTip;
+use crate::Config;
 
 // amount of time to wait for an inv or download sync to complete.
 // These _really should_ complete before the PoX sync watchdog permits processing the next reward
diff --git a/testnet/stacks-node/src/tenure.rs b/testnet/stacks-node/src/tenure.rs
index 985489acec..882a65d06b 100644
--- a/testnet/stacks-node/src/tenure.rs
+++ b/testnet/stacks-node/src/tenure.rs
@@ -16,11 +16,10 @@ use stacks::core::mempool::MemPoolDB;
 use stacks_common::types::chainstate::VRFSeed;
 use stacks_common::util::hash::Hash160;
 use stacks_common::util::vrf::VRFProof;
-use stacks_node::config::Config;
 
 /// Only used by the Helium (Mocknet) node
 use super::node::ChainTip;
-use super::BurnchainTip;
+use super::{BurnchainTip, Config};
 
 pub struct TenureArtifacts {
     pub anchored_block: StacksBlock,
diff --git a/testnet/stacks-node/src/tests/bitcoin_regtest.rs b/testnet/stacks-node/src/tests/bitcoin_regtest.rs
index 4f0bfe603b..6391dd9b2a 100644
--- a/testnet/stacks-node/src/tests/bitcoin_regtest.rs
+++ b/testnet/stacks-node/src/tests/bitcoin_regtest.rs
@@ -9,9 +9,9 @@ use stacks::chainstate::burn::operations::BlockstackOperationType::{
 use stacks::chainstate::stacks::StacksPrivateKey;
 use stacks::core::StacksEpochId;
 use stacks_common::util::hash::hex_bytes;
-use stacks_node::config::InitialBalance;
 
 use super::PUBLISH_CONTRACT;
+use crate::config::InitialBalance;
 use crate::helium::RunLoop;
 use crate::tests::to_addr;
 use crate::Config;
diff --git a/testnet/stacks-node/src/tests/epoch_205.rs b/testnet/stacks-node/src/tests/epoch_205.rs
index 1fe0e50994..0f689f00ef 100644
--- a/testnet/stacks-node/src/tests/epoch_205.rs
+++ b/testnet/stacks-node/src/tests/epoch_205.rs
@@ -24,9 +24,8 @@ use stacks_common::types::chainstate::{
 };
 use stacks_common::util::hash::hex_bytes;
 use stacks_common::util::sleep_ms;
-use stacks_node::config::{EventKeyType, EventObserverConfig, InitialBalance};
-use stacks_node::utils::{get_account, submit_tx};
 
+use crate::config::{EventKeyType, EventObserverConfig, InitialBalance};
 use crate::tests::bitcoin_regtest::BitcoinCoreController;
 use crate::tests::neon_integrations::*;
 use crate::tests::{
diff --git a/testnet/stacks-node/src/tests/epoch_21.rs b/testnet/stacks-node/src/tests/epoch_21.rs
index 4fdfbcc8ac..e26468a254 100644
--- a/testnet/stacks-node/src/tests/epoch_21.rs
+++ b/testnet/stacks-node/src/tests/epoch_21.rs
@@ -33,10 +33,9 @@ use stacks_common::types::PrivateKey;
 use stacks_common::util::hash::{Hash160, Sha256Sum};
 use stacks_common::util::secp256k1::{Secp256k1PrivateKey, Secp256k1PublicKey};
 use stacks_common::util::sleep_ms;
-use stacks_node::config::{Config, EventKeyType, EventObserverConfig, InitialBalance};
-use stacks_node::utils::{get_account, submit_tx};
 
 use crate::burnchains::bitcoin_regtest_controller::UTXO;
+use crate::config::{Config, EventKeyType, EventObserverConfig, InitialBalance};
 use crate::neon::RunLoopCounter;
 use crate::operations::BurnchainOpSigner;
 use crate::stacks_common::address::AddressHashMode;
diff --git a/testnet/stacks-node/src/tests/epoch_22.rs b/testnet/stacks-node/src/tests/epoch_22.rs
index 3c9acdc70e..5c58b26ded 100644
--- a/testnet/stacks-node/src/tests/epoch_22.rs
+++ b/testnet/stacks-node/src/tests/epoch_22.rs
@@ -16,9 +16,9 @@ use stacks_common::types::PrivateKey;
 use stacks_common::util::hash::Hash160;
 use stacks_common::util::secp256k1::Secp256k1PublicKey;
 use stacks_common::util::sleep_ms;
-use stacks_node::config::{EventKeyType, EventObserverConfig, InitialBalance};
-use stacks_node::utils::{get_account, submit_tx};
 
+use super::neon_integrations::get_account;
+use crate::config::{EventKeyType, EventObserverConfig, InitialBalance};
 use crate::neon_node::StacksNode;
 use crate::stacks_common::types::Address;
 use crate::stacks_common::util::hash::bytes_to_hex;
diff --git a/testnet/stacks-node/src/tests/epoch_23.rs b/testnet/stacks-node/src/tests/epoch_23.rs
index 32c0b10b43..740785e182 100644
--- a/testnet/stacks-node/src/tests/epoch_23.rs
+++ b/testnet/stacks-node/src/tests/epoch_23.rs
@@ -21,9 +21,8 @@ use stacks::burnchains::{Burnchain, PoxConstants};
 use stacks::core;
 use stacks::core::STACKS_EPOCH_MAX;
 use stacks_common::util::sleep_ms;
-use stacks_node::config::{EventKeyType, EventObserverConfig, InitialBalance};
-use stacks_node::utils::submit_tx;
 
+use crate::config::{EventKeyType, EventObserverConfig, InitialBalance};
 use crate::tests::bitcoin_regtest::BitcoinCoreController;
 use crate::tests::neon_integrations::*;
 use crate::tests::*;
diff --git a/testnet/stacks-node/src/tests/epoch_24.rs b/testnet/stacks-node/src/tests/epoch_24.rs
index d1f8b42089..b88441838a 100644
--- a/testnet/stacks-node/src/tests/epoch_24.rs
+++ b/testnet/stacks-node/src/tests/epoch_24.rs
@@ -35,13 +35,12 @@ use stacks_common::types::Address;
 use stacks_common::util::hash::{bytes_to_hex, hex_bytes, Hash160};
 use stacks_common::util::secp256k1::Secp256k1PublicKey;
 use stacks_common::util::sleep_ms;
-use stacks_node::config::{EventKeyType, EventObserverConfig, InitialBalance};
-use stacks_node::utils::{get_account, submit_tx};
 
+use crate::config::{EventKeyType, EventObserverConfig, InitialBalance};
 use crate::tests::bitcoin_regtest::BitcoinCoreController;
 use crate::tests::neon_integrations::{
-    get_chain_info, get_pox_info, neon_integration_test_conf, next_block_and_wait, test_observer,
-    wait_for_runloop,
+    get_account, get_chain_info, get_pox_info, neon_integration_test_conf, next_block_and_wait,
+    submit_tx, test_observer, wait_for_runloop,
 };
 use crate::tests::{make_contract_call, to_addr};
 use crate::{neon, BitcoinRegtestController, BurnchainController};
diff --git a/testnet/stacks-node/src/tests/integrations.rs b/testnet/stacks-node/src/tests/integrations.rs
index e798681a16..2bb9bd891e 100644
--- a/testnet/stacks-node/src/tests/integrations.rs
+++ b/testnet/stacks-node/src/tests/integrations.rs
@@ -34,12 +34,12 @@ use stacks::net::api::getistraitimplemented::GetIsTraitImplementedResponse;
 use stacks_common::codec::StacksMessageCodec;
 use stacks_common::types::chainstate::{StacksAddress, StacksBlockId, VRFSeed};
 use stacks_common::util::hash::{hex_bytes, to_hex, Sha256Sum};
-use stacks_node::config::InitialBalance;
 
 use super::{
     make_contract_call, make_contract_publish, make_stacks_transfer, to_addr, ADDR_4, SK_1, SK_2,
     SK_3,
 };
+use crate::config::InitialBalance;
 use crate::helium::RunLoop;
 use crate::tests::make_sponsored_stacks_transfer_on_testnet;
 
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index d6d087b2dd..1c4a5c4015 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -13,22 +13,23 @@
 //
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::{Arc, Mutex};
+use std::thread::JoinHandle;
 use std::time::{Duration, Instant};
 use std::{env, thread};
 
-use blind_signer::blind_signer;
 use clarity::vm::ast::ASTRules;
 use clarity::vm::costs::ExecutionCost;
 use clarity::vm::types::{PrincipalData, QualifiedContractIdentifier};
 use lazy_static::lazy_static;
-use libsigner::{SignerSession, StackerDBSession};
+use libsigner::{BlockResponse, SignerMessage, SignerSession, StackerDBSession};
 use stacks::burnchains::MagicBytes;
 use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::coordinator::comm::CoordinatorChannels;
 use stacks::chainstate::nakamoto::miner::NakamotoBlockBuilder;
+use stacks::chainstate::nakamoto::signer_set::NakamotoSigners;
 use stacks::chainstate::nakamoto::test_signers::TestSigners;
 use stacks::chainstate::nakamoto::{NakamotoBlock, NakamotoChainState};
 use stacks::chainstate::stacks::address::PoxAddress;
@@ -44,7 +45,7 @@ use stacks::core::{
     PEER_VERSION_EPOCH_2_1, PEER_VERSION_EPOCH_2_2, PEER_VERSION_EPOCH_2_3, PEER_VERSION_EPOCH_2_4,
     PEER_VERSION_EPOCH_2_5, PEER_VERSION_EPOCH_3_0,
 };
-use stacks::libstackerdb::SlotMetadata;
+use stacks::libstackerdb::{SlotMetadata, StackerDBChunkData};
 use stacks::net::api::callreadonly::CallReadOnlyRequestBody;
 use stacks::net::api::getstackers::GetStackersResponse;
 use stacks::net::api::postblock_proposal::{
@@ -60,17 +61,16 @@ use stacks_common::consts::{CHAIN_ID_TESTNET, STACKS_EPOCH_MAX};
 use stacks_common::types::chainstate::{
     BlockHeaderHash, StacksAddress, StacksPrivateKey, StacksPublicKey,
 };
-use stacks_common::util::hash::to_hex;
+use stacks_common::util::hash::{to_hex, Sha512Trunc256Sum};
 use stacks_common::util::secp256k1::{MessageSignature, Secp256k1PrivateKey, Secp256k1PublicKey};
-use stacks_node::config::{EventKeyType, EventObserverConfig, InitialBalance};
-use stacks_node::utils::{get_account, submit_tx};
 
 use super::bitcoin_regtest::BitcoinCoreController;
-use crate::neon::Counters;
+use crate::config::{EventKeyType, EventObserverConfig, InitialBalance};
+use crate::neon::{Counters, RunLoopCounter};
 use crate::run_loop::boot_nakamoto;
 use crate::tests::neon_integrations::{
-    get_chain_info_result, get_pox_info, next_block_and_wait, run_until_burnchain_height,
-    test_observer, wait_for_runloop,
+    get_account, get_chain_info_result, get_pox_info, next_block_and_wait,
+    run_until_burnchain_height, submit_tx, test_observer, wait_for_runloop,
 };
 use crate::tests::{make_stacks_transfer, to_addr};
 use crate::{tests, BitcoinRegtestController, BurnchainController, Config, ConfigFile, Keychain};
@@ -203,6 +203,120 @@ pub fn add_initial_balances(
         .collect()
 }
 
+/// Spawn a blind signing thread. `signer` is the private key
+///  of the individual signer who broadcasts the response to the StackerDB
+pub fn blind_signer(
+    conf: &Config,
+    signers: &TestSigners,
+    signer: &Secp256k1PrivateKey,
+    proposals_count: RunLoopCounter,
+) -> JoinHandle<()> {
+    let mut signed_blocks = HashSet::new();
+    let conf = conf.clone();
+    let signers = signers.clone();
+    let signer = signer.clone();
+    let mut last_count = proposals_count.load(Ordering::SeqCst);
+    thread::spawn(move || loop {
+        thread::sleep(Duration::from_millis(100));
+        let cur_count = proposals_count.load(Ordering::SeqCst);
+        if cur_count <= last_count {
+            continue;
+        }
+        last_count = cur_count;
+        match read_and_sign_block_proposal(&conf, &signers, &signer, &signed_blocks) {
+            Ok(signed_block) => {
+                if signed_blocks.contains(&signed_block) {
+                    continue;
+                }
+                info!("Signed block"; "signer_sig_hash" => signed_block.to_hex());
+                signed_blocks.insert(signed_block);
+            }
+            Err(e) => {
+                warn!("Error reading and signing block proposal: {e}");
+            }
+        }
+    })
+}
+
+pub fn read_and_sign_block_proposal(
+    conf: &Config,
+    signers: &TestSigners,
+    signer: &Secp256k1PrivateKey,
+    signed_blocks: &HashSet<Sha512Trunc256Sum>,
+) -> Result<Sha512Trunc256Sum, String> {
+    let burnchain = conf.get_burnchain();
+    let sortdb = burnchain.open_sortition_db(true).unwrap();
+    let tip = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn()).unwrap();
+    let miner_pubkey = StacksPublicKey::from_private(&conf.get_miner_config().mining_key.unwrap());
+    let miner_slot_id = NakamotoChainState::get_miner_slot(&sortdb, &tip, &miner_pubkey)
+        .map_err(|_| "Unable to get miner slot")?
+        .ok_or("No miner slot exists")?;
+    let reward_cycle = burnchain
+        .block_height_to_reward_cycle(tip.block_height)
+        .unwrap();
+    let rpc_sock = conf
+        .node
+        .rpc_bind
+        .clone()
+        .parse()
+        .expect("Failed to parse socket");
+
+    let mut proposed_block: NakamotoBlock = {
+        let miner_contract_id = boot_code_id(MINERS_NAME, false);
+        let mut miners_stackerdb = StackerDBSession::new(rpc_sock, miner_contract_id);
+        miners_stackerdb
+            .get_latest(miner_slot_id)
+            .map_err(|_| "Failed to get latest chunk from the miner slot ID")?
+            .ok_or("No chunk found")?
+    };
+    let proposed_block_hash = format!("0x{}", proposed_block.header.block_hash());
+    let signer_sig_hash = proposed_block.header.signer_signature_hash();
+    if signed_blocks.contains(&signer_sig_hash) {
+        // already signed off on this block, don't sign again.
+        return Ok(signer_sig_hash);
+    }
+
+    info!(
+        "Fetched proposed block from .miners StackerDB";
+        "proposed_block_hash" => &proposed_block_hash,
+        "signer_sig_hash" => &signer_sig_hash.to_hex(),
+    );
+
+    signers
+        .clone()
+        .sign_nakamoto_block(&mut proposed_block, reward_cycle);
+
+    let signer_message = SignerMessage::BlockResponse(BlockResponse::Accepted((
+        signer_sig_hash.clone(),
+        proposed_block.header.signer_signature.clone(),
+    )));
+
+    let signers_contract_id =
+        NakamotoSigners::make_signers_db_contract_id(reward_cycle, libsigner::BLOCK_MSG_ID, false);
+
+    let http_origin = format!("http://{}", &conf.node.rpc_bind);
+    let signers_info = get_stacker_set(&http_origin, reward_cycle);
+    let signer_index = get_signer_index(&signers_info, &Secp256k1PublicKey::from_private(signer))
+        .unwrap()
+        .try_into()
+        .unwrap();
+
+    let next_version = get_stackerdb_slot_version(&http_origin, &signers_contract_id, signer_index)
+        .map(|x| x + 1)
+        .unwrap_or(0);
+    let mut signers_contract_sess = StackerDBSession::new(rpc_sock, signers_contract_id);
+    let mut chunk_to_put = StackerDBChunkData::new(
+        u32::try_from(signer_index).unwrap(),
+        next_version,
+        signer_message.serialize_to_vec(),
+    );
+    chunk_to_put.sign(signer).unwrap();
+    signers_contract_sess
+        .put_chunk(&chunk_to_put)
+        .map_err(|e| e.to_string())?;
+    Ok(signer_sig_hash)
+}
+
 /// Return a working nakamoto-neon config and the miner's bitcoin address to fund
 pub fn naka_neon_integration_conf(seed: Option<&[u8]>) -> (Config, StacksAddress) {
     let mut conf = super::new_test_conf();
@@ -575,6 +689,70 @@ fn is_key_set_for_cycle(
         .map_err(|_| "Response is not optional".to_string())
 }
 
+fn signer_vote_if_needed(
+    btc_regtest_controller: &BitcoinRegtestController,
+    naka_conf: &Config,
+    signer_sks: &[StacksPrivateKey], // TODO: Is there some way to get this from the TestSigners?
+    signers: &TestSigners,
+) {
+    // When we reach the next prepare phase, submit new voting transactions
+    let block_height = btc_regtest_controller.get_headers_height();
+    let reward_cycle = btc_regtest_controller
+        .get_burnchain()
+        .block_height_to_reward_cycle(block_height)
+        .unwrap();
+    let prepare_phase_start = btc_regtest_controller
+        .get_burnchain()
+        .pox_constants
+        .prepare_phase_start(
+            btc_regtest_controller.get_burnchain().first_block_height,
+            reward_cycle,
+        );
+
+    if block_height >= prepare_phase_start {
+        // If the key is already set, do nothing.
+        if is_key_set_for_cycle(
+            reward_cycle + 1,
+            naka_conf.is_mainnet(),
+            &naka_conf.node.rpc_bind,
+        )
+        .unwrap_or(false)
+        {
+            return;
+        }
+
+        // If we are self-signing, then we need to vote on the aggregate public key
+        let http_origin = format!("http://{}", &naka_conf.node.rpc_bind);
+
+        // Get the aggregate key
+        let aggregate_key = signers.clone().generate_aggregate_key(reward_cycle + 1);
+        let aggregate_public_key =
+            clarity::vm::Value::buff_from(aggregate_key.compress().data.to_vec())
+                .expect("Failed to serialize aggregate public key");
+
+        for (i, signer_sk) in signer_sks.iter().enumerate() {
+            let signer_nonce = get_account(&http_origin, &to_addr(signer_sk)).nonce;
+
+            // Vote on the aggregate public key
+            let voting_tx = tests::make_contract_call(
+                &signer_sk,
+                signer_nonce,
+                300,
+                &StacksAddress::burn_address(false),
+                SIGNERS_VOTING_NAME,
+                "vote-for-aggregate-public-key",
+                &[
+                    clarity::vm::Value::UInt(i as u128),
+                    aggregate_public_key.clone(),
+                    clarity::vm::Value::UInt(0),
+                    clarity::vm::Value::UInt(reward_cycle as u128 + 1),
+                ],
+            );
+            submit_tx(&http_origin, &voting_tx);
+        }
+    }
+}
+
 ///
 /// * `stacker_sks` - must be a private key for sending a large `stack-stx` transaction in order
 ///   for pox-4 to activate
@@ -732,6 +910,7 @@ fn simple_neon_integration() {
         blocks_processed,
         naka_submitted_vrfs: vrfs_submitted,
         naka_submitted_commits: commits_submitted,
+        naka_proposed_blocks: proposals_submitted,
         ..
     } = run_loop.counters();
 
@@ -782,7 +961,7 @@ fn simple_neon_integration() {
     }
 
     info!("Nakamoto miner started...");
-    blind_signer(&naka_conf, &signers, &sender_signer_sk);
+    blind_signer(&naka_conf, &signers, &sender_signer_sk, proposals_submitted);
 
     // first block wakes up the run loop, wait until a key registration has been submitted.
     next_block_and(&mut btc_regtest_controller, 60, || {
@@ -807,6 +986,13 @@ fn simple_neon_integration() {
             &commits_submitted,
         )
         .unwrap();
+
+        signer_vote_if_needed(
+            &btc_regtest_controller,
+            &naka_conf,
+            &[sender_signer_sk],
+            &signers,
+        );
     }
 
     // Submit a TX
@@ -842,6 +1028,13 @@ fn simple_neon_integration() {
             &commits_submitted,
         )
         .unwrap();
+
+        signer_vote_if_needed(
+            &btc_regtest_controller,
+            &naka_conf,
+            &[sender_signer_sk],
+            &signers,
+        );
     }
 
     // load the chain tip, and assert that it is a nakamoto block and at least 30 blocks have advanced in epoch 3
@@ -958,6 +1151,7 @@ fn mine_multiple_per_tenure_integration() {
         blocks_processed,
         naka_submitted_vrfs: vrfs_submitted,
         naka_submitted_commits: commits_submitted,
+        naka_proposed_blocks: proposals_submitted,
         ..
     } = run_loop.counters();
 
@@ -996,7 +1190,7 @@ fn mine_multiple_per_tenure_integration() {
             .stacks_block_height;
 
     info!("Nakamoto miner started...");
-    blind_signer(&naka_conf, &signers, &sender_signer_sk);
+    blind_signer(&naka_conf, &signers, &sender_signer_sk, proposals_submitted);
 
     // first block wakes up the run loop, wait until a key registration has been submitted.
     next_block_and(&mut btc_regtest_controller, 60, || {
@@ -1151,6 +1345,7 @@ fn correct_burn_outs() {
         blocks_processed,
         naka_submitted_vrfs: vrfs_submitted,
         naka_submitted_commits: commits_submitted,
+        naka_proposed_blocks: proposals_submitted,
         ..
     } = run_loop.counters();
 
@@ -1261,7 +1456,33 @@ fn correct_burn_outs() {
         })
         .unwrap();
 
-    blind_signer(&naka_conf, &signers, &sender_signer_sk);
+    let block_height = btc_regtest_controller.get_headers_height();
+    let reward_cycle = btc_regtest_controller
+        .get_burnchain()
+        .block_height_to_reward_cycle(block_height)
+        .unwrap();
+    let prepare_phase_start = btc_regtest_controller
+        .get_burnchain()
+        .pox_constants
+        .prepare_phase_start(
+            btc_regtest_controller.get_burnchain().first_block_height,
+            reward_cycle,
+        );
+
+    // Run until the prepare phase
+    run_until_burnchain_height(
+        &mut btc_regtest_controller,
+        &blocks_processed,
+        prepare_phase_start,
+        &naka_conf,
+    );
+
+    signer_vote_if_needed(
+        &btc_regtest_controller,
+        &naka_conf,
+        &[sender_signer_sk],
+        &signers,
+    );
 
     run_until_burnchain_height(
         &mut btc_regtest_controller,
@@ -1271,6 +1492,7 @@ fn correct_burn_outs() {
     );
 
     info!("Bootstrapped to Epoch-3.0 boundary, Epoch2x miner should stop");
+    blind_signer(&naka_conf, &signers, &sender_signer_sk, proposals_submitted);
 
     // we should already be able to query the stacker set via RPC
     let burnchain = naka_conf.get_burnchain();
@@ -1331,6 +1553,13 @@ fn correct_burn_outs() {
             tip_sn.block_height > prior_tip,
             "The new burnchain tip must have been processed"
         );
+
+        signer_vote_if_needed(
+            &btc_regtest_controller,
+            &naka_conf,
+            &[sender_signer_sk],
+            &signers,
+        );
     }
 
     coord_channel
@@ -1410,6 +1639,7 @@ fn block_proposal_api_endpoint() {
         blocks_processed,
         naka_submitted_vrfs: vrfs_submitted,
         naka_submitted_commits: commits_submitted,
+        naka_proposed_blocks: proposals_submitted,
         ..
     } = run_loop.counters();
 
@@ -1427,7 +1657,7 @@ fn block_proposal_api_endpoint() {
     );
 
     info!("Bootstrapped to Epoch-3.0 boundary, starting nakamoto miner");
-    blind_signer(&conf, &signers, &sender_signer_sk);
+    blind_signer(&conf, &signers, &sender_signer_sk, proposals_submitted);
 
     let burnchain = conf.get_burnchain();
     let sortdb = burnchain.open_sortition_db(true).unwrap();
@@ -1760,6 +1990,7 @@ fn miner_writes_proposed_block_to_stackerdb() {
         blocks_processed,
         naka_submitted_vrfs: vrfs_submitted,
         naka_submitted_commits: commits_submitted,
+        naka_proposed_blocks: proposals_submitted,
         ..
     } = run_loop.counters();
 
@@ -1777,7 +2008,7 @@ fn miner_writes_proposed_block_to_stackerdb() {
     );
 
     info!("Nakamoto miner started...");
-    blind_signer(&naka_conf, &signers, &sender_signer_sk);
+    blind_signer(&naka_conf, &signers, &sender_signer_sk, proposals_submitted);
     // first block wakes up the run loop, wait until a key registration has been submitted.
     next_block_and(&mut btc_regtest_controller, 60, || {
         let vrf_count = vrfs_submitted.load(Ordering::SeqCst);
diff --git a/testnet/stacks-node/src/tests/neon_integrations.rs b/testnet/stacks-node/src/tests/neon_integrations.rs
index 0609bb479d..cd0c96358e 100644
--- a/testnet/stacks-node/src/tests/neon_integrations.rs
+++ b/testnet/stacks-node/src/tests/neon_integrations.rs
@@ -61,8 +61,6 @@ use stacks_common::types::chainstate::{
 use stacks_common::util::hash::{bytes_to_hex, hex_bytes, to_hex, Hash160};
 use stacks_common::util::secp256k1::{Secp256k1PrivateKey, Secp256k1PublicKey};
 use stacks_common::util::{get_epoch_time_ms, get_epoch_time_secs, sleep_ms};
-use stacks_node::config::{EventKeyType, EventObserverConfig, FeeEstimatorName, InitialBalance};
-use stacks_node::utils::{get_account, submit_tx};
 
 use super::bitcoin_regtest::BitcoinCoreController;
 use super::{
@@ -71,6 +69,7 @@ use super::{
     SK_2, SK_3,
 };
 use crate::burnchains::bitcoin_regtest_controller::{self, BitcoinRPCRequest, UTXO};
+use crate::config::{EventKeyType, EventObserverConfig, FeeEstimatorName, InitialBalance};
 use crate::neon_node::RelayerThread;
 use crate::operations::BurnchainOpSigner;
 use crate::stacks_common::types::PrivateKey;
@@ -698,6 +697,32 @@ pub fn wait_for_microblocks(microblocks_processed: &Arc<AtomicU64>, timeout: u64
     return true;
 }
 
+/// returns Txid string
+pub fn submit_tx(http_origin: &str, tx: &Vec<u8>) -> String {
+    let client = reqwest::blocking::Client::new();
+    let path = format!("{}/v2/transactions", http_origin);
+    let res = client
+        .post(&path)
+        .header("Content-Type", "application/octet-stream")
+        .body(tx.clone())
+        .send()
+        .unwrap();
+    if res.status().is_success() {
+        let res: String = res.json().unwrap();
+        assert_eq!(
+            res,
+            StacksTransaction::consensus_deserialize(&mut &tx[..])
+                .unwrap()
+                .txid()
+                .to_string()
+        );
+        return res;
+    } else {
+        eprintln!("Submit tx error: {}", res.text().unwrap());
+        panic!("");
+    }
+}
+
 pub fn get_unconfirmed_tx(http_origin: &str, txid: &Txid) -> Option<String> {
     let client = reqwest::blocking::Client::new();
     let path = format!("{}/v2/transactions/unconfirmed/{}", http_origin, txid);
@@ -1171,6 +1196,30 @@ pub fn get_balance<F: std::fmt::Display>(http_origin: &str, account: &F) -> u128
     get_account(http_origin, account).balance
 }
 
+#[derive(Debug)]
+pub struct Account {
+    pub balance: u128,
+    pub locked: u128,
+    pub nonce: u64,
+}
+
+pub fn get_account<F: std::fmt::Display>(http_origin: &str, account: &F) -> Account {
+    let client = reqwest::blocking::Client::new();
+    let path = format!("{}/v2/accounts/{}?proof=0", http_origin, account);
+    let res = client
+        .get(&path)
+        .send()
+        .unwrap()
+        .json::<AccountEntryResponse>()
+        .unwrap();
+    info!("Account response: {:#?}", res);
+    Account {
+        balance: u128::from_str_radix(&res.balance[2..], 16).unwrap(),
+        locked: u128::from_str_radix(&res.locked[2..], 16).unwrap(),
+        nonce: res.nonce,
+    }
+}
+
 pub fn get_pox_info(http_origin: &str) -> Option<RPCPoxInfoData> {
     let client = reqwest::blocking::Client::new();
     let path = format!("{}/v2/pox", http_origin);
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index 353890aa09..1330b4879b 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -39,9 +39,6 @@ use stacks_common::types::chainstate::{
 use stacks_common::types::StacksEpochId;
 use stacks_common::util::hash::{MerkleTree, Sha512Trunc256Sum};
 use stacks_common::util::secp256k1::MessageSignature;
-use stacks_node::config::{
-    Config as NeonConfig, EventKeyType, EventObserverConfig, InitialBalance,
-};
 use stacks_signer::client::{StackerDB, StacksClient};
 use stacks_signer::config::{build_signer_config_tomls, GlobalConfig as SignerConfig, Network};
 use stacks_signer::runloop::RunLoopCommand;
@@ -55,6 +52,7 @@ use wsts::curve::scalar::Scalar;
 use wsts::state_machine::OperationResult;
 use wsts::taproot::SchnorrProof;
 
+use crate::config::{Config as NeonConfig, EventKeyType, EventObserverConfig, InitialBalance};
 use crate::event_dispatcher::MinedNakamotoBlockEvent;
 use crate::neon::Counters;
 use crate::run_loop::boot_nakamoto;
@@ -105,7 +103,7 @@ impl SignerTest {
             .map(|_| StacksPrivateKey::new())
             .collect::<Vec<StacksPrivateKey>>();
 
-        let (naka_conf, _miner_account) = naka_neon_integration_conf(None);
+        let (mut naka_conf, _miner_account) = naka_neon_integration_conf(None);
 
         // Setup the signer and coordinator configurations
         let signer_configs = build_signer_config_tomls(
diff --git a/testnet/stacks-node/src/tests/stackerdb.rs b/testnet/stacks-node/src/tests/stackerdb.rs
index 66eeee04ce..e24b5c5c24 100644
--- a/testnet/stacks-node/src/tests/stackerdb.rs
+++ b/testnet/stacks-node/src/tests/stackerdb.rs
@@ -21,14 +21,13 @@ use stacks::chainstate::stacks::StacksPrivateKey;
 use stacks::libstackerdb::{StackerDBChunkAckData, StackerDBChunkData};
 use stacks_common::types::chainstate::StacksAddress;
 use stacks_common::util::hash::Sha512Trunc256Sum;
-use stacks_node::config::{EventKeyType, EventObserverConfig, InitialBalance};
-use stacks_node::utils::submit_tx;
 use {reqwest, serde_json};
 
 use super::bitcoin_regtest::BitcoinCoreController;
 use crate::burnchains::BurnchainController;
+use crate::config::{EventKeyType, EventObserverConfig, InitialBalance};
 use crate::tests::neon_integrations::{
-    neon_integration_test_conf, next_block_and_wait, test_observer, wait_for_runloop,
+    neon_integration_test_conf, next_block_and_wait, submit_tx, test_observer, wait_for_runloop,
 };
 use crate::tests::{make_contract_publish, to_addr};
 use crate::{neon, BitcoinRegtestController};
diff --git a/testnet/stacks-node/src/utils.rs b/testnet/stacks-node/src/utils.rs
deleted file mode 100644
index 3a01415c40..0000000000
--- a/testnet/stacks-node/src/utils.rs
+++ /dev/null
@@ -1,195 +0,0 @@
-use clarity::vm::{ClarityName, ContractName, Value};
-use stacks::address::{AddressHashMode, C32_ADDRESS_VERSION_TESTNET_SINGLESIG};
-use stacks::chainstate::stacks::{
-    StacksTransaction, StacksTransactionSigner, TransactionAnchorMode, TransactionAuth,
-    TransactionContractCall, TransactionPayload, TransactionPostConditionMode,
-    TransactionSpendingCondition, TransactionVersion,
-};
-use stacks::codec::StacksMessageCodec;
-use stacks::core::CHAIN_ID_TESTNET;
-use stacks::net::api::getaccount::AccountEntryResponse;
-use stacks::types::chainstate::{StacksAddress, StacksPrivateKey, StacksPublicKey};
-
-#[derive(Debug)]
-pub struct Account {
-    pub balance: u128,
-    pub locked: u128,
-    pub nonce: u64,
-}
-
-pub fn get_account<F: std::fmt::Display>(http_origin: &str, account: &F) -> Account {
-    let client = reqwest::blocking::Client::new();
-    let path = format!("{}/v2/accounts/{}?proof=0", http_origin, account);
-    let res = client
-        .get(&path)
-        .send()
-        .unwrap()
-        .json::<AccountEntryResponse>()
-        .unwrap();
-    info!("Account response: {:#?}", res);
-    Account {
-        balance: u128::from_str_radix(&res.balance[2..], 16).unwrap(),
-        locked: u128::from_str_radix(&res.locked[2..], 16).unwrap(),
-        nonce: res.nonce,
-    }
-}
-
-pub fn to_addr(sk: &StacksPrivateKey) -> StacksAddress {
-    StacksAddress::from_public_keys(
-        C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
-        &AddressHashMode::SerializeP2PKH,
-        1,
-        &vec![StacksPublicKey::from_private(sk)],
-    )
-    .unwrap()
-}
-
-pub fn serialize_sign_standard_single_sig_tx(
-    payload: TransactionPayload,
-    sender: &StacksPrivateKey,
-    nonce: u64,
-    tx_fee: u64,
-) -> Vec<u8> {
-    serialize_sign_standard_single_sig_tx_anchor_mode(
-        payload,
-        sender,
-        nonce,
-        tx_fee,
-        TransactionAnchorMode::OnChainOnly,
-    )
-}
-
-pub fn serialize_sign_standard_single_sig_tx_anchor_mode(
-    payload: TransactionPayload,
-    sender: &StacksPrivateKey,
-    nonce: u64,
-    tx_fee: u64,
-    anchor_mode: TransactionAnchorMode,
-) -> Vec<u8> {
-    serialize_sign_standard_single_sig_tx_anchor_mode_version(
-        payload,
-        sender,
-        nonce,
-        tx_fee,
-        anchor_mode,
-        TransactionVersion::Testnet,
-    )
-}
-
-pub fn serialize_sign_standard_single_sig_tx_anchor_mode_version(
-    payload: TransactionPayload,
-    sender: &StacksPrivateKey,
-    nonce: u64,
-    tx_fee: u64,
-    anchor_mode: TransactionAnchorMode,
-    version: TransactionVersion,
-) -> Vec<u8> {
-    serialize_sign_tx_anchor_mode_version(
-        payload,
-        sender,
-        None,
-        nonce,
-        None,
-        tx_fee,
-        anchor_mode,
-        version,
-    )
-}
-
-pub fn serialize_sign_tx_anchor_mode_version(
-    payload: TransactionPayload,
-    sender: &StacksPrivateKey,
-    payer: Option<&StacksPrivateKey>,
-    sender_nonce: u64,
-    payer_nonce: Option<u64>,
-    tx_fee: u64,
-    anchor_mode: TransactionAnchorMode,
-    version: TransactionVersion,
-) -> Vec<u8> {
-    let mut sender_spending_condition =
-        TransactionSpendingCondition::new_singlesig_p2pkh(StacksPublicKey::from_private(sender))
-            .expect("Failed to create p2pkh spending condition from public key.");
-    sender_spending_condition.set_nonce(sender_nonce);
-
-    let auth = match (payer, payer_nonce) {
-        (Some(payer), Some(payer_nonce)) => {
-            let mut payer_spending_condition = TransactionSpendingCondition::new_singlesig_p2pkh(
-                StacksPublicKey::from_private(payer),
-            )
-            .expect("Failed to create p2pkh spending condition from public key.");
-            payer_spending_condition.set_nonce(payer_nonce);
-            payer_spending_condition.set_tx_fee(tx_fee);
-            TransactionAuth::Sponsored(sender_spending_condition, payer_spending_condition)
-        }
-        _ => {
-            sender_spending_condition.set_tx_fee(tx_fee);
-            TransactionAuth::Standard(sender_spending_condition)
-        }
-    };
-    let mut unsigned_tx = StacksTransaction::new(version, auth, payload);
-    unsigned_tx.anchor_mode = anchor_mode;
-    unsigned_tx.post_condition_mode = TransactionPostConditionMode::Allow;
-    unsigned_tx.chain_id = CHAIN_ID_TESTNET;
-
-    let mut tx_signer = StacksTransactionSigner::new(&unsigned_tx);
-    tx_signer.sign_origin(sender).unwrap();
-    if let (Some(payer), Some(_)) = (payer, payer_nonce) {
-        tx_signer.sign_sponsor(payer).unwrap();
-    }
-
-    let mut buf = vec![];
-    tx_signer
-        .get_tx()
-        .unwrap()
-        .consensus_serialize(&mut buf)
-        .unwrap();
-    buf
-}
-
-pub fn make_contract_call(
-    sender: &StacksPrivateKey,
-    nonce: u64,
-    tx_fee: u64,
-    contract_addr: &StacksAddress,
-    contract_name: &str,
-    function_name: &str,
-    function_args: &[Value],
-) -> Vec<u8> {
-    let contract_name = ContractName::from(contract_name);
-    let function_name = ClarityName::from(function_name);
-
-    let payload = TransactionContractCall {
-        address: contract_addr.clone(),
-        contract_name,
-        function_name,
-        function_args: function_args.iter().map(|x| x.clone()).collect(),
-    };
-
-    serialize_sign_standard_single_sig_tx(payload.into(), sender, nonce, tx_fee)
-}
-
-/// returns Txid string
-pub fn submit_tx(http_origin: &str, tx: &Vec<u8>) -> String {
-    let client = reqwest::blocking::Client::new();
-    let path = format!("{}/v2/transactions", http_origin);
-    let res = client
-        .post(&path)
-        .header("Content-Type", "application/octet-stream")
-        .body(tx.clone())
-        .send()
-        .unwrap();
-    if res.status().is_success() {
-        let res: String = res.json().unwrap();
-        assert_eq!(
-            res,
-            StacksTransaction::consensus_deserialize(&mut &tx[..])
-                .unwrap()
-                .txid()
-                .to_string()
-        );
-        return res;
-    } else {
-        eprintln!("Submit tx error: {}", res.text().unwrap());
-        panic!("");
-    }
-}

From e9290cb978344622740f6801c873336d4e7f1a11 Mon Sep 17 00:00:00 2001
From: Matthew Little <zone117x@gmail.com>
Date: Mon, 4 Mar 2024 17:59:19 +0100
Subject: [PATCH 1010/1166] chore: pr feedback around string ownership

---
 libsigner/src/session.rs                       | 13 +++++--------
 stacks-signer/src/client/stackerdb.rs          |  6 +++---
 stacks-signer/src/main.rs                      | 14 +++++++-------
 testnet/stacks-node/src/nakamoto_node/miner.rs |  6 ++----
 4 files changed, 17 insertions(+), 22 deletions(-)

diff --git a/libsigner/src/session.rs b/libsigner/src/session.rs
index 56658bf29d..7aa7796040 100644
--- a/libsigner/src/session.rs
+++ b/libsigner/src/session.rs
@@ -31,7 +31,7 @@ pub trait SignerSession {
     /// connect to the replica
     fn connect(
         &mut self,
-        host: String,
+        host: &str,
         stackerdb_contract_id: QualifiedContractIdentifier,
     ) -> Result<(), RPCError>;
     /// query the replica for a list of chunks
@@ -75,12 +75,9 @@ pub struct StackerDBSession {
 
 impl StackerDBSession {
     /// instantiate but don't connect
-    pub fn new(
-        host: String,
-        stackerdb_contract_id: QualifiedContractIdentifier,
-    ) -> StackerDBSession {
+    pub fn new(host: &str, stackerdb_contract_id: QualifiedContractIdentifier) -> StackerDBSession {
         StackerDBSession {
-            host,
+            host: host.to_owned(),
             stackerdb_contract_id,
             sock: None,
         }
@@ -134,10 +131,10 @@ impl SignerSession for StackerDBSession {
     /// connect to the replica
     fn connect(
         &mut self,
-        host: String,
+        host: &str,
         stackerdb_contract_id: QualifiedContractIdentifier,
     ) -> Result<(), RPCError> {
-        self.host = host;
+        self.host = host.to_owned();
         self.stackerdb_contract_id = stackerdb_contract_id;
         self.connect_or_reconnect()
     }
diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index 3fe8da8bef..ecdba4676f 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -53,7 +53,7 @@ pub struct StackerDB {
 impl From<&SignerConfig> for StackerDB {
     fn from(config: &SignerConfig) -> Self {
         StackerDB::new(
-            config.node_host.to_string(),
+            &config.node_host,
             config.stacks_private_key,
             config.mainnet,
             config.reward_cycle,
@@ -64,7 +64,7 @@ impl From<&SignerConfig> for StackerDB {
 impl StackerDB {
     /// Create a new StackerDB client
     pub fn new(
-        host: String,
+        host: &str,
         stacks_private_key: StacksPrivateKey,
         is_mainnet: bool,
         reward_cycle: u64,
@@ -76,7 +76,7 @@ impl StackerDB {
             signers_message_stackerdb_sessions.insert(
                 msg_id,
                 StackerDBSession::new(
-                    host.to_string(),
+                    host,
                     QualifiedContractIdentifier::new(
                         stackerdb_issuer.into(),
                         ContractName::from(
diff --git a/stacks-signer/src/main.rs b/stacks-signer/src/main.rs
index f5c4fc5bd7..9b2aabfda9 100644
--- a/stacks-signer/src/main.rs
+++ b/stacks-signer/src/main.rs
@@ -62,9 +62,9 @@ struct SpawnedSigner {
 }
 
 /// Create a new stacker db session
-fn stackerdb_session(host: String, contract: QualifiedContractIdentifier) -> StackerDBSession {
-    let mut session = StackerDBSession::new(host.to_string(), contract.clone());
-    session.connect(host, contract).unwrap();
+fn stackerdb_session(host: &str, contract: QualifiedContractIdentifier) -> StackerDBSession {
+    let mut session = StackerDBSession::new(host, contract.clone());
+    session.connect(&host, contract).unwrap();
     session
 }
 
@@ -159,28 +159,28 @@ fn process_sign_result(sign_res: &[OperationResult]) {
 
 fn handle_get_chunk(args: GetChunkArgs) {
     debug!("Getting chunk...");
-    let mut session = stackerdb_session(args.db_args.host, args.db_args.contract);
+    let mut session = stackerdb_session(&args.db_args.host, args.db_args.contract);
     let chunk_opt = session.get_chunk(args.slot_id, args.slot_version).unwrap();
     write_chunk_to_stdout(chunk_opt);
 }
 
 fn handle_get_latest_chunk(args: GetLatestChunkArgs) {
     debug!("Getting latest chunk...");
-    let mut session = stackerdb_session(args.db_args.host, args.db_args.contract);
+    let mut session = stackerdb_session(&args.db_args.host, args.db_args.contract);
     let chunk_opt = session.get_latest_chunk(args.slot_id).unwrap();
     write_chunk_to_stdout(chunk_opt);
 }
 
 fn handle_list_chunks(args: StackerDBArgs) {
     debug!("Listing chunks...");
-    let mut session = stackerdb_session(args.host, args.contract);
+    let mut session = stackerdb_session(&args.host, args.contract);
     let chunk_list = session.list_chunks().unwrap();
     println!("{}", serde_json::to_string(&chunk_list).unwrap());
 }
 
 fn handle_put_chunk(args: PutChunkArgs) {
     debug!("Putting chunk...");
-    let mut session = stackerdb_session(args.db_args.host, args.db_args.contract);
+    let mut session = stackerdb_session(&args.db_args.host, args.db_args.contract);
     let mut chunk = StackerDBChunkData::new(args.slot_id, args.slot_version, args.data);
     chunk.sign(&args.private_key).unwrap();
     let chunk_ack = session.put_chunk(&chunk).unwrap();
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index fcad415e1d..98998d7c35 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -200,10 +200,8 @@ impl BlockMinerThread {
                     Ok(Some(chunk)) => {
                         // Propose the block to the observing signers through the .miners stackerdb instance
                         let miner_contract_id = boot_code_id(MINERS_NAME, self.config.is_mainnet());
-                        let mut miners_stackerdb = StackerDBSession::new(
-                            self.config.node.rpc_bind.to_string(),
-                            miner_contract_id,
-                        );
+                        let mut miners_stackerdb =
+                            StackerDBSession::new(&self.config.node.rpc_bind, miner_contract_id);
                         match miners_stackerdb.put_chunk(&chunk) {
                             Ok(ack) => {
                                 info!("Proposed block to stackerdb: {ack:?}");

From 59a9a7a99495df8b244449e23eef16ccc08fa735 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Mon, 4 Mar 2024 08:59:35 -0800
Subject: [PATCH 1011/1166] chore: test for `stack-increase` with different
 signer keys

---
 .../src/chainstate/stacks/boot/pox-4.clar     |   3 +-
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 118 ++++++++++++++++++
 2 files changed, 120 insertions(+), 1 deletion(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index b13beba798..c174c0faca 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -35,6 +35,7 @@
 (define-constant ERR_INVALID_REWARD_CYCLE 37)
 (define-constant ERR_SIGNER_AUTH_AMOUNT_TOO_HIGH 38)
 (define-constant ERR_SIGNER_AUTH_USED 39)
+(define-constant ERR_INVALID_INCREASE 40)
 
 ;; Valid values for burnchain address versions.
 ;; These first four correspond to address hash modes in Stacks 2.1,
@@ -1158,7 +1159,7 @@
                     stacker: tx-sender,
                     add-amount: increase-by,
                     signer-key: signer-key })))
-            (err ERR_STACKING_UNREACHABLE))
+            (err ERR_INVALID_INCREASE))
       ;; NOTE: stacking-state map is unchanged: it does not track amount-stacked in PoX-4
       (ok { stacker: tx-sender, total-locked: (+ amount-stacked increase-by)})))
 
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 41b4c0bda8..83d1523001 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -2710,6 +2710,124 @@ fn stack_agg_commit_verify_sig() {
     );
 }
 
+#[test]
+/// Verify that when calling `stack-increase`, the function
+/// fails if the signer key for each cycle being updated is not the same
+/// as the provided `signer-key` argument
+fn stack_increase_different_signer_keys() {
+    let lock_period = 1;
+    let observer = TestEventObserver::new();
+    let (burnchain, mut peer, keys, latest_block, block_height, coinbase_nonce) =
+        prepare_pox4_test(function_name!(), Some(&observer));
+
+    let mut coinbase_nonce = coinbase_nonce;
+
+    let mut stacker_nonce = 0;
+    let stacker_key = &keys[0];
+    let min_ustx = get_stacking_minimum(&mut peer, &latest_block);
+    let stacker_addr = key_to_stacks_addr(&stacker_key);
+    let signer_sk = &keys[1];
+    let signer_pk = StacksPublicKey::from_private(signer_sk);
+    let pox_addr = pox_addr_from(&signer_sk);
+
+    // Second key is used in `stack-extend`
+    let second_signer_sk = &keys[2];
+    let second_signer_pk = StacksPublicKey::from_private(second_signer_sk);
+
+    let reward_cycle = get_current_reward_cycle(&peer, &burnchain);
+
+    // Setup: stack-stx
+    let signature = make_signer_key_signature(
+        &pox_addr,
+        &signer_sk,
+        reward_cycle,
+        &Pox4SignatureTopic::StackStx,
+        lock_period,
+        u128::MAX,
+        1,
+    );
+    let stack_nonce = stacker_nonce;
+    let stack_tx = make_pox_4_lockup(
+        &stacker_key,
+        stacker_nonce,
+        min_ustx,
+        &pox_addr,
+        lock_period,
+        &signer_pk,
+        block_height,
+        Some(signature),
+        u128::MAX,
+        1,
+    );
+
+    stacker_nonce += 1;
+    let signature = make_signer_key_signature(
+        &pox_addr,
+        &second_signer_sk,
+        reward_cycle,
+        &Pox4SignatureTopic::StackExtend,
+        lock_period,
+        u128::MAX,
+        1,
+    );
+    let extend_nonce = stacker_nonce;
+    let extend_tx = make_pox_4_extend(
+        &stacker_key,
+        stacker_nonce,
+        pox_addr.clone(),
+        lock_period,
+        second_signer_pk.clone(),
+        Some(signature.clone()),
+        u128::MAX,
+        1,
+    );
+
+    stacker_nonce += 1;
+    let signature = make_signer_key_signature(
+        &pox_addr,
+        &signer_sk,
+        reward_cycle,
+        &Pox4SignatureTopic::StackIncrease,
+        2, // 2 cycles total (1 from stack-stx, 1 from extend)
+        u128::MAX,
+        1,
+    );
+    let increase_nonce = stacker_nonce;
+    let stack_increase = make_pox_4_stack_increase(
+        &stacker_key,
+        stacker_nonce,
+        min_ustx,
+        &signer_pk,
+        Some(signature),
+        u128::MAX,
+        1,
+    );
+
+    let latest_block =
+        peer.tenure_with_txs(&[stack_tx, extend_tx, stack_increase], &mut coinbase_nonce);
+
+    let txs = get_last_block_sender_transactions(&observer, stacker_addr.clone());
+
+    let tx_result = |nonce: u64| -> Value { txs.get(nonce as usize).unwrap().result.clone() };
+
+    // stack-stx should work
+    tx_result(stack_nonce)
+        .expect_result_ok()
+        .expect("Expected ok result from tx");
+    // `stack-extend` should work
+    tx_result(extend_nonce)
+        .expect_result_ok()
+        .expect("Expected ok result from tx");
+    let increase_result = tx_result(increase_nonce);
+
+    // Validate that the error is not due to the signature
+    assert_ne!(
+        tx_result(increase_nonce),
+        Value::error(Value::Int(35)).unwrap()
+    );
+    assert_eq!(increase_result, Value::error(Value::Int(40)).unwrap())
+}
+
 pub fn assert_latest_was_burn(peer: &mut TestPeer) {
     let tip = get_tip(peer.sortdb.as_ref());
     let tip_index_block = tip.get_canonical_stacks_block_id();

From c1a6f2fe6483047a6e293b13c1d6864fce75ed30 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Mon, 4 Mar 2024 11:29:23 -0500
Subject: [PATCH 1012/1166] Add config option to provide authorization password
 to block proposal endpoint

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/cli.rs                      |  3 ++
 stacks-signer/src/client/stacks_client.rs     | 15 +++++-
 stacks-signer/src/config.rs                   |  7 +++
 stacks-signer/src/main.rs                     |  1 +
 stacks-signer/src/tests/conf/signer-0.toml    |  1 +
 stacks-signer/src/tests/conf/signer-1.toml    |  1 +
 stacks-signer/src/tests/conf/signer-4.toml    |  1 +
 stackslib/src/net/api/mod.rs                  |  4 +-
 stackslib/src/net/api/postblock_proposal.rs   | 26 +++++-----
 stackslib/src/net/connection.rs               |  3 ++
 stackslib/src/net/httpcore.rs                 |  3 ++
 .../src/tests/nakamoto_integrations.rs        | 47 ++++++++++++++-----
 testnet/stacks-node/src/tests/signer.rs       | 12 ++++-
 13 files changed, 97 insertions(+), 27 deletions(-)

diff --git a/stacks-signer/src/cli.rs b/stacks-signer/src/cli.rs
index 639b57f3a2..af19875678 100644
--- a/stacks-signer/src/cli.rs
+++ b/stacks-signer/src/cli.rs
@@ -173,6 +173,9 @@ pub struct GenerateFilesArgs {
     /// The number of milliseconds to wait when polling for events from the stacker-db instance.
     #[arg(long)]
     pub timeout: Option<u64>,
+    #[arg(long)]
+    /// The authorization password to use to connect to the validate block proposal node endpoint
+    pub password: String,
 }
 
 #[derive(Clone, Debug)]
diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index 054e4fb374..7dd72ae380 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -34,6 +34,7 @@ use blockstack_lib::net::api::postblock_proposal::NakamotoBlockProposal;
 use blockstack_lib::util_lib::boot::{boot_code_addr, boot_code_id};
 use clarity::vm::types::{PrincipalData, QualifiedContractIdentifier};
 use clarity::vm::{ClarityName, ContractName, Value as ClarityValue};
+use reqwest::header::AUTHORIZATION;
 use serde_json::json;
 use slog::slog_debug;
 use stacks_common::codec::StacksMessageCodec;
@@ -63,6 +64,8 @@ pub struct StacksClient {
     mainnet: bool,
     /// The Client used to make HTTP connects
     stacks_node_client: reqwest::blocking::Client,
+    /// the auth password for the stacks node
+    auth_password: String,
 }
 
 impl From<&GlobalConfig> for StacksClient {
@@ -75,13 +78,19 @@ impl From<&GlobalConfig> for StacksClient {
             chain_id: config.network.to_chain_id(),
             stacks_node_client: reqwest::blocking::Client::new(),
             mainnet: config.network.is_mainnet(),
+            auth_password: config.auth_password.clone(),
         }
     }
 }
 
 impl StacksClient {
-    /// Create a new signer StacksClient with the provided private key, stacks node host endpoint, and version
-    pub fn new(stacks_private_key: StacksPrivateKey, node_host: SocketAddr, mainnet: bool) -> Self {
+    /// Create a new signer StacksClient with the provided private key, stacks node host endpoint, version, and auth password
+    pub fn new(
+        stacks_private_key: StacksPrivateKey,
+        node_host: SocketAddr,
+        auth_password: String,
+        mainnet: bool,
+    ) -> Self {
         let pubkey = StacksPublicKey::from_private(&stacks_private_key);
         let tx_version = if mainnet {
             TransactionVersion::Mainnet
@@ -102,6 +111,7 @@ impl StacksClient {
             chain_id,
             stacks_node_client: reqwest::blocking::Client::new(),
             mainnet,
+            auth_password,
         }
     }
 
@@ -214,6 +224,7 @@ impl StacksClient {
             self.stacks_node_client
                 .post(self.block_proposal_path())
                 .header("Content-Type", "application/json")
+                .header(AUTHORIZATION, self.auth_password.clone())
                 .json(&block_proposal)
                 .send()
                 .map_err(backoff::Error::transient)
diff --git a/stacks-signer/src/config.rs b/stacks-signer/src/config.rs
index d8c7b4a8e9..9bbdc4f982 100644
--- a/stacks-signer/src/config.rs
+++ b/stacks-signer/src/config.rs
@@ -194,6 +194,8 @@ pub struct GlobalConfig {
     pub sign_timeout: Option<Duration>,
     /// the STX tx fee to use in uSTX
     pub tx_fee_ustx: u64,
+    /// the authorization password for the block proposal endpoint
+    pub auth_password: String,
 }
 
 /// Internal struct for loading up the config file
@@ -222,6 +224,8 @@ struct RawConfigFile {
     pub sign_timeout_ms: Option<u64>,
     /// the STX tx fee to use in uSTX
     pub tx_fee_ustx: Option<u64>,
+    /// The authorization password for the block proposal endpoint
+    pub auth_password: String,
 }
 
 impl RawConfigFile {
@@ -320,6 +324,7 @@ impl TryFrom<RawConfigFile> for GlobalConfig {
             nonce_timeout,
             sign_timeout,
             tx_fee_ustx: raw_data.tx_fee_ustx.unwrap_or(TX_FEE_USTX),
+            auth_password: raw_data.auth_password,
         })
     }
 }
@@ -350,6 +355,7 @@ pub fn build_signer_config_tomls(
     node_host: &str,
     timeout: Option<Duration>,
     network: &Network,
+    password: &str,
 ) -> Vec<String> {
     let mut signer_config_tomls = vec![];
 
@@ -364,6 +370,7 @@ stacks_private_key = "{stacks_private_key}"
 node_host = "{node_host}"
 endpoint = "{endpoint}"
 network = "{network}"
+auth_password = "{password}"
 "#
         );
 
diff --git a/stacks-signer/src/main.rs b/stacks-signer/src/main.rs
index e59722dd53..194e7fb480 100644
--- a/stacks-signer/src/main.rs
+++ b/stacks-signer/src/main.rs
@@ -292,6 +292,7 @@ fn handle_generate_files(args: GenerateFilesArgs) {
         &args.host.to_string(),
         args.timeout.map(Duration::from_millis),
         &args.network,
+        &args.password,
     );
     debug!("Built {:?} signer config tomls.", signer_config_tomls.len());
     for (i, file_contents) in signer_config_tomls.iter().enumerate() {
diff --git a/stacks-signer/src/tests/conf/signer-0.toml b/stacks-signer/src/tests/conf/signer-0.toml
index 2c30d82326..449392c2e3 100644
--- a/stacks-signer/src/tests/conf/signer-0.toml
+++ b/stacks-signer/src/tests/conf/signer-0.toml
@@ -2,3 +2,4 @@ stacks_private_key = "6a1fc1a3183018c6d79a4e11e154d2bdad2d89ac8bc1b0a021de8b4d28
 node_host = "127.0.0.1:20443"
 endpoint = "localhost:30000"
 network = "testnet"
+auth_password = "12345"
diff --git a/stacks-signer/src/tests/conf/signer-1.toml b/stacks-signer/src/tests/conf/signer-1.toml
index 99facfc1d2..3d293af640 100644
--- a/stacks-signer/src/tests/conf/signer-1.toml
+++ b/stacks-signer/src/tests/conf/signer-1.toml
@@ -2,3 +2,4 @@ stacks_private_key = "126e916e77359ccf521e168feea1fcb9626c59dc375cae00c746430338
 node_host = "127.0.0.1:20444"
 endpoint = "localhost:30001"
 network = "testnet"
+auth_password = "12345"
diff --git a/stacks-signer/src/tests/conf/signer-4.toml b/stacks-signer/src/tests/conf/signer-4.toml
index 87cda83327..0e80a1aa6f 100644
--- a/stacks-signer/src/tests/conf/signer-4.toml
+++ b/stacks-signer/src/tests/conf/signer-4.toml
@@ -3,3 +3,4 @@ stacks_private_key = "e427196ae29197b1db6d5495ff26bf0675f48a4f07b200c0814b95734e
 node_host = "127.0.0.1:20443"
 endpoint = "localhost:30004"
 network = "testnet"
+auth_password = "12345"
diff --git a/stackslib/src/net/api/mod.rs b/stackslib/src/net/api/mod.rs
index b6fb21fc2a..c1a042aef4 100644
--- a/stackslib/src/net/api/mod.rs
+++ b/stackslib/src/net/api/mod.rs
@@ -112,7 +112,9 @@ impl StacksHttp {
             liststackerdbreplicas::RPCListStackerDBReplicasRequestHandler::new(),
         );
         self.register_rpc_endpoint(postblock::RPCPostBlockRequestHandler::new());
-        self.register_rpc_endpoint(postblock_proposal::RPCBlockProposalRequestHandler::new());
+        self.register_rpc_endpoint(postblock_proposal::RPCBlockProposalRequestHandler::new(
+            self.block_proposal_token.clone(),
+        ));
         self.register_rpc_endpoint(postfeerate::RPCPostFeeRateRequestHandler::new());
         self.register_rpc_endpoint(postmempoolquery::RPCMempoolQueryRequestHandler::new());
         self.register_rpc_endpoint(postmicroblock::RPCPostMicroblockRequestHandler::new());
diff --git a/stackslib/src/net/api/postblock_proposal.rs b/stackslib/src/net/api/postblock_proposal.rs
index 72b85c5778..50b0415297 100644
--- a/stackslib/src/net/api/postblock_proposal.rs
+++ b/stackslib/src/net/api/postblock_proposal.rs
@@ -342,11 +342,15 @@ impl NakamotoBlockProposal {
 #[derive(Clone, Default)]
 pub struct RPCBlockProposalRequestHandler {
     pub block_proposal: Option<NakamotoBlockProposal>,
+    pub auth: Option<String>,
 }
 
 impl RPCBlockProposalRequestHandler {
-    pub fn new() -> Self {
-        Self::default()
+    pub fn new(auth: Option<String>) -> Self {
+        Self {
+            block_proposal: None,
+            auth,
+        }
     }
 
     /// Decode a JSON-encoded block proposal
@@ -375,24 +379,22 @@ impl HttpRequest for RPCBlockProposalRequestHandler {
         query: Option<&str>,
         body: &[u8],
     ) -> Result<HttpRequestContents, Error> {
-        // Only accept requests from localhost
-        let is_loopback = match preamble.host {
-            // Should never be DNS
-            PeerHost::DNS(..) => false,
-            PeerHost::IP(addr, ..) => addr.is_loopback(),
+        // If no authorization is set, then the block proposal endpoint is not enabled
+        let Some(password) = &self.auth else {
+            return Err(Error::Http(400, "Bad Request.".into()));
         };
-
-        if !is_loopback {
-            return Err(Error::Http(403, "Forbidden".into()));
+        let Some(auth_header) = preamble.headers.get("authorization") else {
+            return Err(Error::Http(401, "Unauthorized".into()));
+        };
+        if auth_header != password {
+            return Err(Error::Http(401, "Unauthorized".into()));
         }
-
         if preamble.get_content_length() == 0 {
             return Err(Error::DecodeError(
                 "Invalid Http request: expected non-zero-length body for block proposal endpoint"
                     .to_string(),
             ));
         }
-
         if preamble.get_content_length() > MAX_PAYLOAD_LEN {
             return Err(Error::DecodeError(
                 "Invalid Http request: BlockProposal body is too big".to_string(),
diff --git a/stackslib/src/net/connection.rs b/stackslib/src/net/connection.rs
index 25d3ee7489..878ab04efb 100644
--- a/stackslib/src/net/connection.rs
+++ b/stackslib/src/net/connection.rs
@@ -415,6 +415,8 @@ pub struct ConnectionOptions {
     /// the reward cycle in which Nakamoto activates, and thus needs to run both the epoch
     /// 2.x and Nakamoto state machines.
     pub force_nakamoto_epoch_transition: bool,
+    /// The authorization token to enable the block proposal RPC endpoint
+    pub block_proposal_token: Option<String>,
 }
 
 impl std::default::Default for ConnectionOptions {
@@ -508,6 +510,7 @@ impl std::default::Default for ConnectionOptions {
             disable_stackerdb_get_chunks: false,
             force_disconnect_interval: None,
             force_nakamoto_epoch_transition: false,
+            block_proposal_token: None,
         }
     }
 }
diff --git a/stackslib/src/net/httpcore.rs b/stackslib/src/net/httpcore.rs
index 074605bcd9..04dd185e10 100644
--- a/stackslib/src/net/httpcore.rs
+++ b/stackslib/src/net/httpcore.rs
@@ -871,6 +871,8 @@ pub struct StacksHttp {
     pub maximum_call_argument_size: u32,
     /// Maximum execution budget of a read-only call
     pub read_only_call_limit: ExecutionCost,
+    /// The authorization token to enable the block proposal RPC endpoint
+    pub block_proposal_token: Option<String>,
 }
 
 impl StacksHttp {
@@ -886,6 +888,7 @@ impl StacksHttp {
             request_handlers: vec![],
             maximum_call_argument_size: conn_opts.maximum_call_argument_size,
             read_only_call_limit: conn_opts.read_only_call_limit.clone(),
+            block_proposal_token: conn_opts.block_proposal_token.clone(),
         };
         http.register_rpc_methods();
         http
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 3b46ce24ac..6cd15a4d31 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -21,6 +21,7 @@ use std::{env, thread};
 use clarity::vm::ast::ASTRules;
 use clarity::vm::costs::ExecutionCost;
 use clarity::vm::types::PrincipalData;
+use http_types::headers::AUTHORIZATION;
 use lazy_static::lazy_static;
 use libsigner::{SignerSession, StackerDBSession};
 use stacks::burnchains::MagicBytes;
@@ -1402,6 +1403,8 @@ fn block_proposal_api_endpoint() {
     }
 
     let (mut conf, _miner_account) = naka_neon_integration_conf(None);
+    let password = "12345".to_string();
+    conf.connection_options.block_proposal_token = Some(password.clone());
     let account_keys = add_initial_balances(&mut conf, 10, 1_000_000);
     let stacker_sk = setup_stacker(&mut conf);
     let sender_signer_sk = Secp256k1PrivateKey::new();
@@ -1593,6 +1596,7 @@ fn block_proposal_api_endpoint() {
 
     const HTTP_ACCEPTED: u16 = 202;
     const HTTP_TOO_MANY: u16 = 429;
+    const HTTP_NOT_AUTHORIZED: u16 = 401;
     let test_cases = [
         (
             "Valid Nakamoto block proposal",
@@ -1631,6 +1635,12 @@ fn block_proposal_api_endpoint() {
             HTTP_ACCEPTED,
             Some(Err(ValidateRejectCode::ChainstateError)),
         ),
+        (
+            "Not authorized",
+            sign(proposal.clone()),
+            HTTP_NOT_AUTHORIZED,
+            None,
+        ),
     ];
 
     // Build HTTP client
@@ -1647,12 +1657,18 @@ fn block_proposal_api_endpoint() {
         test_cases.iter().enumerate()
     {
         // Send POST request
-        let mut response = client
+        let request_builder = client
             .post(&path)
             .header("Content-Type", "application/json")
-            .json(block_proposal)
-            .send()
-            .expect("Failed to POST");
+            .json(block_proposal);
+        let mut response = if expected_http_code == &HTTP_NOT_AUTHORIZED {
+            request_builder.send().expect("Failed to POST")
+        } else {
+            request_builder
+                .header(AUTHORIZATION.to_string(), password.to_string())
+                .send()
+                .expect("Failed to POST")
+        };
         let start_time = Instant::now();
         while ix != 1 && response.status().as_u16() == HTTP_TOO_MANY {
             if start_time.elapsed() > Duration::from_secs(30) {
@@ -1661,20 +1677,29 @@ fn block_proposal_api_endpoint() {
             }
             info!("Waiting for prior request to finish processing, and then resubmitting");
             thread::sleep(Duration::from_secs(5));
-            response = client
+            let request_builder = client
                 .post(&path)
                 .header("Content-Type", "application/json")
-                .json(block_proposal)
-                .send()
-                .expect("Failed to POST");
+                .json(block_proposal);
+            response = if expected_http_code == &HTTP_NOT_AUTHORIZED {
+                request_builder.send().expect("Failed to POST")
+            } else {
+                request_builder
+                    .header(AUTHORIZATION.to_string(), password.to_string())
+                    .send()
+                    .expect("Failed to POST")
+            };
         }
 
         let response_code = response.status().as_u16();
-        let response_json = response.json::<serde_json::Value>();
-
+        let response_json = if expected_http_code != &HTTP_NOT_AUTHORIZED {
+            response.json::<serde_json::Value>().unwrap().to_string()
+        } else {
+            "No json response".to_string()
+        };
         info!(
             "Block proposal submitted and checked for HTTP response";
-            "response_json" => %response_json.unwrap(),
+            "response_json" => response_json,
             "request_json" => serde_json::to_string(block_proposal).unwrap(),
             "response_code" => response_code,
             "test_description" => test_description,
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index c0c2e72e2b..0be42768be 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -105,6 +105,10 @@ impl SignerTest {
 
         let (mut naka_conf, _miner_account) = naka_neon_integration_conf(None);
         naka_conf.miner.self_signing_key = None;
+        // So the combination is... one, two, three, four, five? That's the stupidest combination I've ever heard in my life!
+        // That's the kind of thing an idiot would have on his luggage!
+        let password = "12345";
+        naka_conf.connection_options.block_proposal_token = Some(password.to_string());
 
         // Setup the signer and coordinator configurations
         let signer_configs = build_signer_config_tomls(
@@ -112,6 +116,7 @@ impl SignerTest {
             &naka_conf.node.rpc_bind,
             Some(Duration::from_millis(128)), // Timeout defaults to 5 seconds. Let's override it to 128 milliseconds.
             &Network::Testnet,
+            password,
         );
 
         let mut running_signers = Vec::new();
@@ -726,7 +731,12 @@ impl SignerTest {
         )
         .unwrap();
 
-        let invalid_stacks_client = StacksClient::new(StacksPrivateKey::new(), host, false);
+        let invalid_stacks_client = StacksClient::new(
+            StacksPrivateKey::new(),
+            host,
+            "12345".to_string(), // That's amazing. I've got the same combination on my luggage!
+            false,
+        );
         let invalid_signer_tx = invalid_stacks_client
             .build_vote_for_aggregate_public_key(0, round, point, reward_cycle, None, 0)
             .expect("FATAL: failed to build vote for aggregate public key");

From 2493821cc9d4bbd94b1b86946d0bffbbfd6c0d83 Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Mon, 4 Mar 2024 10:51:00 -0500
Subject: [PATCH 1013/1166] fix: use the correct tip to retrieve signer nonces

---
 testnet/stacks-node/src/nakamoto_node/miner.rs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index 9c886b4343..16eb159447 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -335,9 +335,13 @@ impl BlockMinerThread {
             return Ok(vec![]);
         }
 
+        let (consensus_hash, block_bhh) =
+            SortitionDB::get_canonical_stacks_chain_tip_hash(sortdb.conn()).unwrap();
+        let stacks_block_id = StacksBlockId::new(&consensus_hash, &block_bhh);
+
         // Get all nonces for the signers from clarity DB to use to validate transactions
         let account_nonces = chainstate
-            .with_read_only_clarity_tx(&sortdb.index_conn(), &self.parent_tenure_id, |clarity_tx| {
+            .with_read_only_clarity_tx(&sortdb.index_conn(), &stacks_block_id, |clarity_tx| {
                 clarity_tx.with_clarity_db_readonly(|clarity_db| {
                     addresses
                         .iter()

From ad27ac4dedf8711e596412effdc9137e0fd9a03d Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Thu, 29 Feb 2024 20:55:06 -0500
Subject: [PATCH 1014/1166] chore(clarity): Allocate `HashMap`s with capacity
 when possible

---
 clarity/src/vm/ast/traits_resolver/mod.rs |  8 ++--
 clarity/src/vm/ast/types.rs               |  5 +--
 clarity/src/vm/contexts.rs                | 46 ++++++-----------------
 clarity/src/vm/costs/mod.rs               |  7 ++--
 clarity/src/vm/coverage.rs                |  5 ++-
 5 files changed, 22 insertions(+), 49 deletions(-)

diff --git a/clarity/src/vm/ast/traits_resolver/mod.rs b/clarity/src/vm/ast/traits_resolver/mod.rs
index 7c4cdbf959..4cdb2f54a9 100644
--- a/clarity/src/vm/ast/traits_resolver/mod.rs
+++ b/clarity/src/vm/ast/traits_resolver/mod.rs
@@ -46,14 +46,12 @@ impl TraitsResolver {
     }
 
     pub fn run(&mut self, contract_ast: &mut ContractAST) -> ParseResult<()> {
-        let exprs = contract_ast.pre_expressions[..].to_vec();
         let mut referenced_traits = HashMap::new();
 
-        for exp in exprs.iter() {
+        for exp in contract_ast.pre_expressions.iter() {
             // Top-level comment nodes have been filtered from `args` by `try_parse_pre_expr`.
-            let (define_type, args) = match self.try_parse_pre_expr(exp) {
-                Some(x) => x,
-                None => continue,
+            let Some((define_type, args)) = self.try_parse_pre_expr(exp) else {
+                continue;
             };
 
             match define_type {
diff --git a/clarity/src/vm/ast/types.rs b/clarity/src/vm/ast/types.rs
index 87ab844b85..aedd31eae3 100644
--- a/clarity/src/vm/ast/types.rs
+++ b/clarity/src/vm/ast/types.rs
@@ -79,10 +79,7 @@ pub struct PreExpressionsDrain {
 
 impl PreExpressionsDrain {
     pub fn new(pre_exprs_drain: Drain<PreSymbolicExpression>, sorting: Option<Vec<usize>>) -> Self {
-        let mut pre_expressions = HashMap::new();
-        for (index, pre_expr) in pre_exprs_drain.enumerate() {
-            pre_expressions.insert(index, pre_expr);
-        }
+        let pre_expressions: HashMap<_, _> = pre_exprs_drain.enumerate().collect();
 
         let sorting = match sorting {
             Some(sorting) if !sorting.is_empty() => Some(sorting),
diff --git a/clarity/src/vm/contexts.rs b/clarity/src/vm/contexts.rs
index 4b2d6c46d2..de7b07036e 100644
--- a/clarity/src/vm/contexts.rs
+++ b/clarity/src/vm/contexts.rs
@@ -306,10 +306,7 @@ impl AssetMap {
         asset: AssetIdentifier,
         transfered: Value,
     ) {
-        let principal_map = self
-            .asset_map
-            .entry(principal.clone())
-            .or_insert_with(|| HashMap::new());
+        let principal_map = self.asset_map.entry(principal.clone()).or_default();
 
         if let Some(map_entry) = principal_map.get_mut(&asset) {
             map_entry.push(transfered);
@@ -326,10 +323,7 @@ impl AssetMap {
     ) -> Result<()> {
         let next_amount = self.get_next_amount(principal, &asset, amount)?;
 
-        let principal_map = self
-            .token_map
-            .entry(principal.clone())
-            .or_insert_with(|| HashMap::new());
+        let principal_map = self.token_map.entry(principal.clone()).or_default();
         principal_map.insert(asset, next_amount);
 
         Ok(())
@@ -362,10 +356,7 @@ impl AssetMap {
         // After this point, this function will not fail.
         for (principal, mut principal_map) in other.asset_map.drain() {
             for (asset, mut transfers) in principal_map.drain() {
-                let landing_map = self
-                    .asset_map
-                    .entry(principal.clone())
-                    .or_insert_with(|| HashMap::new());
+                let landing_map = self.asset_map.entry(principal.clone()).or_default();
                 if let Some(landing_vec) = landing_map.get_mut(&asset) {
                     landing_vec.append(&mut transfers);
                 } else {
@@ -383,10 +374,7 @@ impl AssetMap {
         }
 
         for (principal, asset, amount) in to_add.into_iter() {
-            let principal_map = self
-                .token_map
-                .entry(principal)
-                .or_insert_with(|| HashMap::new());
+            let principal_map = self.token_map.entry(principal).or_default();
             principal_map.insert(asset, amount);
         }
 
@@ -394,9 +382,9 @@ impl AssetMap {
     }
 
     pub fn to_table(mut self) -> HashMap<PrincipalData, HashMap<AssetIdentifier, AssetMapEntry>> {
-        let mut map = HashMap::new();
+        let mut map = HashMap::with_capacity(self.token_map.len());
         for (principal, mut principal_map) in self.token_map.drain() {
-            let mut output_map = HashMap::new();
+            let mut output_map = HashMap::with_capacity(principal_map.len());
             for (asset, amount) in principal_map.drain() {
                 output_map.insert(asset, AssetMapEntry::Token(amount));
             }
@@ -404,9 +392,7 @@ impl AssetMap {
         }
 
         for (principal, stx_amount) in self.stx_map.drain() {
-            let output_map = map
-                .entry(principal.clone())
-                .or_insert_with(|| HashMap::new());
+            let output_map = map.entry(principal.clone()).or_default();
             output_map.insert(
                 AssetIdentifier::STX(),
                 AssetMapEntry::STX(stx_amount as u128),
@@ -414,9 +400,7 @@ impl AssetMap {
         }
 
         for (principal, stx_burned_amount) in self.burn_map.drain() {
-            let output_map = map
-                .entry(principal.clone())
-                .or_insert_with(|| HashMap::new());
+            let output_map = map.entry(principal.clone()).or_default();
             output_map.insert(
                 AssetIdentifier::STX_burned(),
                 AssetMapEntry::Burn(stx_burned_amount as u128),
@@ -424,9 +408,7 @@ impl AssetMap {
         }
 
         for (principal, mut principal_map) in self.asset_map.drain() {
-            let output_map = map
-                .entry(principal.clone())
-                .or_insert_with(|| HashMap::new());
+            let output_map = map.entry(principal.clone()).or_default();
             for (asset, transfers) in principal_map.drain() {
                 output_map.insert(asset, AssetMapEntry::Asset(transfers));
             }
@@ -436,17 +418,11 @@ impl AssetMap {
     }
 
     pub fn get_stx(&self, principal: &PrincipalData) -> Option<u128> {
-        match self.stx_map.get(principal) {
-            Some(value) => Some(*value),
-            None => None,
-        }
+        self.stx_map.get(principal).copied()
     }
 
     pub fn get_stx_burned(&self, principal: &PrincipalData) -> Option<u128> {
-        match self.burn_map.get(principal) {
-            Some(value) => Some(*value),
-            None => None,
-        }
+        self.burn_map.get(principal).copied()
     }
 
     pub fn get_stx_burned_total(&self) -> Result<u128> {
diff --git a/clarity/src/vm/costs/mod.rs b/clarity/src/vm/costs/mod.rs
index e0a664ac64..ebb767b0e5 100644
--- a/clarity/src/vm/costs/mod.rs
+++ b/clarity/src/vm/costs/mod.rs
@@ -811,9 +811,10 @@ impl TrackerData {
 
         self.contract_call_circuits = contract_call_circuits;
 
-        let mut cost_contracts = HashMap::new();
-        let mut m = HashMap::new();
-        for f in ClarityCostFunction::ALL.iter() {
+        let iter = ClarityCostFunction::ALL.iter();
+        let mut cost_contracts = HashMap::with_capacity(iter.len());
+        let mut m = HashMap::with_capacity(iter.len());
+        for f in iter {
             let cost_function_ref = cost_function_references.remove(f).unwrap_or_else(|| {
                 ClarityCostFunctionReference::new(boot_costs_id.clone(), f.get_name())
             });
diff --git a/clarity/src/vm/coverage.rs b/clarity/src/vm/coverage.rs
index ea62981696..be8a647e9c 100644
--- a/clarity/src/vm/coverage.rs
+++ b/clarity/src/vm/coverage.rs
@@ -72,8 +72,9 @@ impl CoverageReporter {
 
     pub fn to_file<P: AsRef<std::path::Path> + Copy>(&self, filename: P) -> std::io::Result<()> {
         let f = File::create(filename)?;
-        let mut coverage = HashMap::new();
-        for (contract, execution_map) in self.executed_lines.iter() {
+        let iter = self.executed_lines.iter();
+        let mut coverage = HashMap::with_capacity(iter.len());
+        for (contract, execution_map) in iter {
             let mut executed_lines = execution_map
                 .iter()
                 .map(|(line, count)| (*line, *count))

From 5f4d1fb2e7204d1bad89d4373d5769ffdc295ecc Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Mon, 4 Mar 2024 10:08:00 -0500
Subject: [PATCH 1015/1166] chore: Address PR feedback

---
 clarity/src/vm/costs/mod.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/clarity/src/vm/costs/mod.rs b/clarity/src/vm/costs/mod.rs
index ebb767b0e5..f70fbe6990 100644
--- a/clarity/src/vm/costs/mod.rs
+++ b/clarity/src/vm/costs/mod.rs
@@ -812,8 +812,9 @@ impl TrackerData {
         self.contract_call_circuits = contract_call_circuits;
 
         let iter = ClarityCostFunction::ALL.iter();
-        let mut cost_contracts = HashMap::with_capacity(iter.len());
-        let mut m = HashMap::with_capacity(iter.len());
+        let iter_len = iter.len();
+        let mut cost_contracts = HashMap::with_capacity(iter_len);
+        let mut m = HashMap::with_capacity(iter_len);
         for f in iter {
             let cost_function_ref = cost_function_references.remove(f).unwrap_or_else(|| {
                 ClarityCostFunctionReference::new(boot_costs_id.clone(), f.get_name())

From 60c9e333c4ae7ca1c1ed0d0940a330b33017b13a Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Mon, 4 Mar 2024 11:53:45 -0800
Subject: [PATCH 1016/1166] fix: add block_proposal_token to file type

---
 testnet/stacks-node/src/config.rs | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index 7e2751d7a8..a5adf1e5b2 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -180,6 +180,25 @@ mod tests {
             "ST2TFVBMRPS5SSNP98DQKQ5JNB2B6NZM91C4K3P7B"
         );
     }
+
+    #[test]
+    fn should_load_block_proposal_token() {
+        let config = Config::from_config_file(
+            ConfigFile::from_str(
+                r#"
+                [connection_options]
+                block_proposal_token = "password"
+                "#,
+            )
+            .unwrap(),
+        )
+        .expect("Expected to be able to parse block proposal token from file");
+
+        assert_eq!(
+            config.connection_options.block_proposal_token,
+            Some("password".to_string())
+        );
+    }
 }
 
 impl ConfigFile {
@@ -2106,6 +2125,7 @@ pub struct ConnectionOptionsFile {
     pub force_disconnect_interval: Option<u64>,
     pub antientropy_public: Option<bool>,
     pub private_neighbors: Option<bool>,
+    pub block_proposal_token: Option<String>,
 }
 
 impl ConnectionOptionsFile {
@@ -2229,6 +2249,7 @@ impl ConnectionOptionsFile {
             max_sockets: self.max_sockets.unwrap_or(800) as usize,
             antientropy_public: self.antientropy_public.unwrap_or(true),
             private_neighbors: self.private_neighbors.unwrap_or(true),
+            block_proposal_token: self.block_proposal_token,
             ..ConnectionOptions::default()
         })
     }

From ed90d5fed7f9c6189514b404703c8c0510f6735a Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Mon, 4 Mar 2024 12:24:09 -0800
Subject: [PATCH 1017/1166] feat: more tests for verifying key in
 stack-increase

---
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 307 +++++++++++++++++-
 1 file changed, 296 insertions(+), 11 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 83d1523001..a785fe2f6a 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -1868,8 +1868,8 @@ fn stack_stx_verify_signer_sig() {
         u128::MAX,
         1,
     );
-    let invalid_stacker_nonce = stacker_nonce;
-    let invalid_stacker_tx = make_pox_4_lockup(
+    let invalid_pox_addr_nonce = stacker_nonce;
+    let invalid_pox_addr_tx = make_pox_4_lockup(
         &stacker_key,
         stacker_nonce,
         min_ustx,
@@ -2059,7 +2059,7 @@ fn stack_stx_verify_signer_sig() {
 
     let txs = vec![
         invalid_cycle_stack,
-        invalid_stacker_tx,
+        invalid_pox_addr_tx,
         invalid_key_tx,
         invalid_topic_tx,
         invalid_period_tx,
@@ -2078,7 +2078,7 @@ fn stack_stx_verify_signer_sig() {
     let tx_result =
         |nonce: u64| -> Value { stacker_txs.get(nonce as usize).unwrap().result.clone() };
     assert_eq!(tx_result(invalid_cycle_nonce), expected_error);
-    assert_eq!(tx_result(invalid_stacker_nonce), expected_error);
+    assert_eq!(tx_result(invalid_pox_addr_nonce), expected_error);
     assert_eq!(tx_result(invalid_key_nonce), expected_error);
     assert_eq!(tx_result(invalid_period_nonce), expected_error);
     assert_eq!(tx_result(invalid_topic_nonce), expected_error);
@@ -2208,8 +2208,8 @@ fn stack_extend_verify_sig() {
         u128::MAX,
         1,
     );
-    let invalid_stacker_nonce = stacker_nonce;
-    let invalid_stacker_tx = make_pox_4_extend(
+    let invalid_pox_addr_nonce = stacker_nonce;
+    let invalid_pox_addr_tx = make_pox_4_extend(
         &stacker_key,
         stacker_nonce,
         pox_addr.clone(),
@@ -2317,7 +2317,7 @@ fn stack_extend_verify_sig() {
         &[
             stack_tx,
             invalid_cycle_tx,
-            invalid_stacker_tx,
+            invalid_pox_addr_tx,
             invalid_key_tx,
             invalid_auth_id_tx,
             invalid_max_amount_tx,
@@ -2336,7 +2336,7 @@ fn stack_extend_verify_sig() {
         .expect_result_ok()
         .expect("Expected ok result from tx");
     assert_eq!(tx_result(invalid_cycle_nonce), expected_error);
-    assert_eq!(tx_result(invalid_stacker_nonce), expected_error);
+    assert_eq!(tx_result(invalid_pox_addr_nonce), expected_error);
     assert_eq!(tx_result(invalid_key_nonce), expected_error);
     assert_eq!(tx_result(invalid_auth_id_nonce), expected_error);
     assert_eq!(tx_result(invalid_max_amount_nonce), expected_error);
@@ -2468,7 +2468,7 @@ fn stack_agg_commit_verify_sig() {
         1,
     );
     let invalid_pox_addr_nonce = delegate_nonce;
-    let invalid_stacker_tx = make_pox_4_aggregation_commit_indexed(
+    let invalid_pox_addr_tx = make_pox_4_aggregation_commit_indexed(
         &delegate_key,
         delegate_nonce,
         &pox_addr,
@@ -2479,7 +2479,7 @@ fn stack_agg_commit_verify_sig() {
         1,
     );
 
-    // Test 3: invalid signature
+    // Test 3: invalid private key
     delegate_nonce += 1;
     let signature = make_signer_key_signature(
         &pox_addr,
@@ -2645,7 +2645,7 @@ fn stack_agg_commit_verify_sig() {
             delegate_tx,
             delegate_stack_stx_tx,
             invalid_cycle_tx,
-            invalid_stacker_tx,
+            invalid_pox_addr_tx,
             invalid_key_tx,
             invalid_period_tx,
             invalid_topic_tx,
@@ -2710,6 +2710,291 @@ fn stack_agg_commit_verify_sig() {
     );
 }
 
+#[test]
+fn stack_increase_verify_signer_key() {
+    let lock_period = 1;
+    let observer = TestEventObserver::new();
+    let (burnchain, mut peer, keys, latest_block, block_height, coinbase_nonce) =
+        prepare_pox4_test(function_name!(), Some(&observer));
+
+    let mut coinbase_nonce = coinbase_nonce;
+
+    let mut stacker_nonce = 0;
+    let stacker_key = &keys[0];
+    let min_ustx = get_stacking_minimum(&mut peer, &latest_block);
+    let stacker_addr = key_to_stacks_addr(&stacker_key);
+    let signer_sk = &keys[1];
+    let signer_pk = StacksPublicKey::from_private(signer_sk);
+    let pox_addr = pox_addr_from(&signer_sk);
+
+    let reward_cycle = get_current_reward_cycle(&peer, &burnchain);
+    let topic = Pox4SignatureTopic::StackIncrease;
+
+    // Setup: stack-stx
+    let signature = make_signer_key_signature(
+        &pox_addr,
+        &signer_sk,
+        reward_cycle,
+        &Pox4SignatureTopic::StackStx,
+        lock_period,
+        u128::MAX,
+        1,
+    );
+    let stack_nonce = stacker_nonce;
+    let stack_tx = make_pox_4_lockup(
+        &stacker_key,
+        stacker_nonce,
+        min_ustx,
+        &pox_addr,
+        lock_period,
+        &signer_pk,
+        block_height,
+        Some(signature),
+        u128::MAX,
+        1,
+    );
+
+    // invalid reward cycle
+    stacker_nonce += 1;
+    let signature = make_signer_key_signature(
+        &pox_addr,
+        &signer_sk,
+        reward_cycle - 1, // invalid
+        &topic,
+        lock_period,
+        u128::MAX,
+        1,
+    );
+    let invalid_cycle_nonce = stacker_nonce;
+    let invalid_cycle_tx = make_pox_4_stack_increase(
+        &stacker_key,
+        stacker_nonce,
+        min_ustx,
+        &signer_pk,
+        Some(signature),
+        u128::MAX,
+        1,
+    );
+
+    // invalid pox addr
+    stacker_nonce += 1;
+    let other_pox_addr = pox_addr_from(&Secp256k1PrivateKey::new());
+    let signature = make_signer_key_signature(
+        &other_pox_addr, // different than existing
+        &signer_sk,
+        reward_cycle,
+        &topic,
+        lock_period,
+        u128::MAX,
+        1,
+    );
+    let invalid_pox_addr_nonce = stacker_nonce;
+    let invalid_pox_addr_tx = make_pox_4_stack_increase(
+        &stacker_key,
+        stacker_nonce,
+        min_ustx,
+        &signer_pk,
+        Some(signature),
+        u128::MAX,
+        1,
+    );
+
+    // invalid private key
+    stacker_nonce += 1;
+    let signature = make_signer_key_signature(
+        &pox_addr,
+        &stacker_key, // different than signer
+        reward_cycle,
+        &topic,
+        lock_period,
+        u128::MAX,
+        1,
+    );
+    let invalid_key_nonce = stacker_nonce;
+    let invalid_key_tx = make_pox_4_stack_increase(
+        &stacker_key,
+        stacker_nonce,
+        min_ustx,
+        &signer_pk,
+        Some(signature),
+        u128::MAX,
+        1,
+    );
+
+    // invalid period
+    stacker_nonce += 1;
+    let signature = make_signer_key_signature(
+        &pox_addr,
+        &signer_sk,
+        reward_cycle,
+        &topic,
+        lock_period + 1, // wrong
+        u128::MAX,
+        1,
+    );
+    let invalid_period_nonce = stacker_nonce;
+    let invalid_period_tx = make_pox_4_stack_increase(
+        &stacker_key,
+        stacker_nonce,
+        min_ustx,
+        &signer_pk,
+        Some(signature),
+        u128::MAX,
+        1,
+    );
+
+    // invalid topic
+    stacker_nonce += 1;
+    let signature = make_signer_key_signature(
+        &pox_addr,
+        &signer_sk,
+        reward_cycle,
+        &Pox4SignatureTopic::StackExtend, // wrong topic
+        lock_period,
+        u128::MAX,
+        1,
+    );
+    let invalid_topic_nonce = stacker_nonce;
+    let invalid_topic_tx = make_pox_4_stack_increase(
+        &stacker_key,
+        stacker_nonce,
+        min_ustx,
+        &signer_pk,
+        Some(signature),
+        u128::MAX,
+        1,
+    );
+
+    // invalid auth-id
+    stacker_nonce += 1;
+    let signature = make_signer_key_signature(
+        &pox_addr,
+        &signer_sk,
+        reward_cycle,
+        &topic,
+        lock_period,
+        u128::MAX,
+        2, // wrong auth-id
+    );
+    let invalid_auth_id_nonce = stacker_nonce;
+    let invalid_auth_id_tx = make_pox_4_stack_increase(
+        &stacker_key,
+        stacker_nonce,
+        min_ustx,
+        &signer_pk,
+        Some(signature),
+        u128::MAX,
+        1,
+    );
+
+    // invalid max-amount
+    stacker_nonce += 1;
+    let signature = make_signer_key_signature(
+        &pox_addr,
+        &signer_sk,
+        reward_cycle,
+        &topic,
+        lock_period,
+        u128::MAX.saturating_sub(1),
+        1,
+    );
+    let invalid_max_amount_nonce = stacker_nonce;
+    let invalid_max_amount_tx = make_pox_4_stack_increase(
+        &stacker_key,
+        stacker_nonce,
+        min_ustx,
+        &signer_pk,
+        Some(signature),
+        u128::MAX, // different than signature
+        1,
+    );
+
+    // invalid amount
+    stacker_nonce += 1;
+    let signature = make_signer_key_signature(
+        &pox_addr,
+        &signer_sk,
+        reward_cycle,
+        &topic,
+        lock_period,
+        min_ustx.saturating_sub(1),
+        1,
+    );
+    let invalid_amount_nonce = stacker_nonce;
+    let invalid_amount_tx = make_pox_4_stack_increase(
+        &stacker_key,
+        stacker_nonce,
+        min_ustx,
+        &signer_pk,
+        Some(signature),
+        min_ustx.saturating_sub(1),
+        1,
+    );
+
+    // Valid tx
+    stacker_nonce += 1;
+    let signature = make_signer_key_signature(
+        &pox_addr,
+        &signer_sk,
+        reward_cycle,
+        &Pox4SignatureTopic::StackIncrease,
+        lock_period,
+        u128::MAX,
+        1,
+    );
+    let valid_nonce = stacker_nonce;
+    let stack_increase = make_pox_4_stack_increase(
+        &stacker_key,
+        stacker_nonce,
+        min_ustx,
+        &signer_pk,
+        Some(signature),
+        u128::MAX,
+        1,
+    );
+
+    let latest_block = peer.tenure_with_txs(
+        &[
+            stack_tx,
+            invalid_cycle_tx,
+            invalid_pox_addr_tx,
+            invalid_key_tx,
+            invalid_period_tx,
+            invalid_topic_tx,
+            invalid_auth_id_tx,
+            invalid_max_amount_tx,
+            invalid_amount_tx,
+            stack_increase,
+        ],
+        &mut coinbase_nonce,
+    );
+
+    let txs = get_last_block_sender_transactions(&observer, stacker_addr);
+    let tx_result = |nonce: u64| -> Value { txs.get(nonce as usize).unwrap().result.clone() };
+    let signature_error = Value::error(Value::Int(35)).unwrap();
+
+    // stack-stx should work
+    tx_result(stack_nonce)
+        .expect_result_ok()
+        .expect("Expected ok result from tx");
+    assert_eq!(tx_result(invalid_cycle_nonce), signature_error);
+    assert_eq!(tx_result(invalid_pox_addr_nonce), signature_error);
+    assert_eq!(tx_result(invalid_key_nonce), signature_error);
+    assert_eq!(tx_result(invalid_period_nonce), signature_error);
+    assert_eq!(tx_result(invalid_topic_nonce), signature_error);
+    assert_eq!(tx_result(invalid_auth_id_nonce), signature_error);
+    assert_eq!(tx_result(invalid_max_amount_nonce), signature_error);
+    assert_eq!(
+        tx_result(invalid_amount_nonce),
+        Value::error(Value::Int(38)).unwrap()
+    );
+
+    // valid tx should succeed
+    tx_result(valid_nonce)
+        .expect_result_ok()
+        .expect("Expected ok result from tx");
+}
+
 #[test]
 /// Verify that when calling `stack-increase`, the function
 /// fails if the signer key for each cycle being updated is not the same

From f00f4ebc78a3ebc2a61b40e852165673d1f8e1fc Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Mon, 4 Mar 2024 13:07:43 -0800
Subject: [PATCH 1018/1166] fix: another mutant

---
 stackslib/src/util_lib/signed_structured_data.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/stackslib/src/util_lib/signed_structured_data.rs b/stackslib/src/util_lib/signed_structured_data.rs
index a61e77e48c..9cc0eaa0f1 100644
--- a/stackslib/src/util_lib/signed_structured_data.rs
+++ b/stackslib/src/util_lib/signed_structured_data.rs
@@ -91,6 +91,7 @@ pub mod pox4 {
         make_structured_data_domain("pox-4-signer", "1.0.0", chain_id)
     }
 
+    #[cfg_attr(test, mutants::skip)]
     pub fn make_pox_4_signer_key_message_hash(
         pox_addr: &PoxAddress,
         reward_cycle: u128,

From 5ea730c2249ffa71386dbdcb8c1853379ec6f958 Mon Sep 17 00:00:00 2001
From: Marzi <marzi@trustmachines.co>
Date: Sat, 2 Mar 2024 20:13:11 -0500
Subject: [PATCH 1019/1166] Ctrl-C graceful shutdown during burnchain
 initialization + retry logic when adding a bootstrap node

---
 stackslib/src/burnchains/mod.rs              |  4 ++
 testnet/stacks-node/src/config.rs            | 39 ++++++++++++++++-
 testnet/stacks-node/src/run_loop/nakamoto.rs | 18 +++++++-
 testnet/stacks-node/src/run_loop/neon.rs     | 45 +++++++++++++++-----
 4 files changed, 91 insertions(+), 15 deletions(-)

diff --git a/stackslib/src/burnchains/mod.rs b/stackslib/src/burnchains/mod.rs
index c6e4204542..aa3c833237 100644
--- a/stackslib/src/burnchains/mod.rs
+++ b/stackslib/src/burnchains/mod.rs
@@ -682,6 +682,8 @@ pub enum Error {
     UnknownBlock(BurnchainHeaderHash),
     NonCanonicalPoxId(PoxId, PoxId),
     CoordinatorClosed,
+    /// Graceful shutdown error
+    ShutdownInitiated,
 }
 
 impl fmt::Display for Error {
@@ -706,6 +708,7 @@ impl fmt::Display for Error {
                 parent, child
             ),
             Error::CoordinatorClosed => write!(f, "ChainsCoordinator channel hung up"),
+            Error::ShutdownInitiated => write!(f, "Graceful shutdown was initiated"),
         }
     }
 }
@@ -728,6 +731,7 @@ impl error::Error for Error {
             Error::UnknownBlock(_) => None,
             Error::NonCanonicalPoxId(_, _) => None,
             Error::CoordinatorClosed => None,
+            Error::ShutdownInitiated => None,
         }
     }
 }
diff --git a/testnet/stacks-node/src/config.rs b/testnet/stacks-node/src/config.rs
index 7e2751d7a8..ba771dae6b 100644
--- a/testnet/stacks-node/src/config.rs
+++ b/testnet/stacks-node/src/config.rs
@@ -1,9 +1,9 @@
 use std::collections::HashSet;
-use std::fs;
 use std::net::{SocketAddr, ToSocketAddrs};
 use std::path::PathBuf;
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
+use std::{fs, thread};
 
 use clarity::vm::costs::ExecutionCost;
 use clarity::vm::types::{AssetIdentifier, PrincipalData, QualifiedContractIdentifier};
@@ -1927,7 +1927,42 @@ impl NodeConfig {
         let pubkey = Secp256k1PublicKey::from_hex(pubkey_str)
             .unwrap_or_else(|_| panic!("Invalid public key '{pubkey_str}'"));
         debug!("Resolve '{}'", &hostport);
-        let sockaddr = hostport.to_socket_addrs().unwrap().next().unwrap();
+
+        let mut attempts = 0;
+        let max_attempts = 5;
+        let mut delay = Duration::from_secs(2);
+
+        let sockaddr = loop {
+            match hostport.to_socket_addrs() {
+                Ok(mut addrs) => {
+                    if let Some(addr) = addrs.next() {
+                        break addr;
+                    } else {
+                        panic!("No addresses found for '{}'", hostport);
+                    }
+                }
+                Err(e) => {
+                    if attempts >= max_attempts {
+                        panic!(
+                            "Failed to resolve '{}' after {} attempts: {}",
+                            hostport, max_attempts, e
+                        );
+                    } else {
+                        error!(
+                            "Attempt {} - Failed to resolve '{}': {}. Retrying in {:?}...",
+                            attempts + 1,
+                            hostport,
+                            e,
+                            delay
+                        );
+                        thread::sleep(delay);
+                        attempts += 1;
+                        delay *= 2;
+                    }
+                }
+            }
+        };
+
         let neighbor = NodeConfig::default_neighbor(sockaddr, pubkey, chain_id, peer_version);
         self.bootstrap_node.push(neighbor);
     }
diff --git a/testnet/stacks-node/src/run_loop/nakamoto.rs b/testnet/stacks-node/src/run_loop/nakamoto.rs
index 0b3702a994..dd13b2d32c 100644
--- a/testnet/stacks-node/src/run_loop/nakamoto.rs
+++ b/testnet/stacks-node/src/run_loop/nakamoto.rs
@@ -20,7 +20,7 @@ use std::thread::JoinHandle;
 use std::{cmp, thread};
 
 use stacks::burnchains::bitcoin::address::{BitcoinAddress, LegacyBitcoinAddressType};
-use stacks::burnchains::Burnchain;
+use stacks::burnchains::{Burnchain, Error as burnchain_error};
 use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::burn::BlockSnapshot;
 use stacks::chainstate::coordinator::comm::{CoordinatorChannels, CoordinatorReceivers};
@@ -400,13 +400,27 @@ impl RunLoop {
 
         // setup the termination handler, allow it to error if a prior runloop already set it
         neon::RunLoop::setup_termination_handler(self.should_keep_running.clone(), true);
-        let mut burnchain = neon::RunLoop::instantiate_burnchain_state(
+
+        let burnchain_result = neon::RunLoop::instantiate_burnchain_state(
             &self.config,
             self.should_keep_running.clone(),
             burnchain_opt,
             coordinator_senders.clone(),
         );
 
+        let mut burnchain = match burnchain_result {
+            Ok(burnchain_controller) => burnchain_controller,
+            Err(burnchain_error::ShutdownInitiated) => {
+                info!("Exiting stacks-node");
+                return;
+            }
+            Err(e) => {
+                error!("Error initializing burnchain: {}", e);
+                info!("Exiting stacks-node");
+                return;
+            }
+        };
+
         let burnchain_config = burnchain.get_burnchain();
         self.burnchain = Some(burnchain_config.clone());
 
diff --git a/testnet/stacks-node/src/run_loop/neon.rs b/testnet/stacks-node/src/run_loop/neon.rs
index 3f5c04f4c2..f053c58cff 100644
--- a/testnet/stacks-node/src/run_loop/neon.rs
+++ b/testnet/stacks-node/src/run_loop/neon.rs
@@ -8,7 +8,7 @@ use std::{cmp, thread};
 
 use libc;
 use stacks::burnchains::bitcoin::address::{BitcoinAddress, LegacyBitcoinAddressType};
-use stacks::burnchains::Burnchain;
+use stacks::burnchains::{Burnchain, Error as burnchain_error};
 use stacks::chainstate::burn::db::sortdb::SortitionDB;
 use stacks::chainstate::burn::BlockSnapshot;
 use stacks::chainstate::coordinator::comm::{CoordinatorChannels, CoordinatorReceivers};
@@ -31,7 +31,7 @@ use stacks_common::util::{get_epoch_time_secs, sleep_ms};
 use stx_genesis::GenesisData;
 
 use super::RunLoopCallbacks;
-use crate::burnchains::make_bitcoin_indexer;
+use crate::burnchains::{make_bitcoin_indexer, Error};
 use crate::globals::NeonGlobals as Globals;
 use crate::monitoring::{start_serving_monitoring_metrics, MonitoringError};
 use crate::neon_node::{StacksNode, BLOCK_PROCESSOR_STACK_SIZE, RELAYER_MAX_BUFFER};
@@ -393,13 +393,13 @@ impl RunLoop {
         should_keep_running: Arc<AtomicBool>,
         burnchain_opt: Option<Burnchain>,
         coordinator_senders: CoordinatorChannels,
-    ) -> BitcoinRegtestController {
+    ) -> Result<BitcoinRegtestController, burnchain_error> {
         // Initialize and start the burnchain.
         let mut burnchain_controller = BitcoinRegtestController::with_burnchain(
             config.clone(),
             Some(coordinator_senders),
             burnchain_opt,
-            Some(should_keep_running),
+            Some(should_keep_running.clone()),
         );
 
         let burnchain = burnchain_controller.get_burnchain();
@@ -448,13 +448,21 @@ impl RunLoop {
             }
         };
 
-        match burnchain_controller.start(Some(target_burnchain_block_height)) {
-            Ok(_) => {}
-            Err(e) => {
+        burnchain_controller
+            .start(Some(target_burnchain_block_height))
+            .map_err(|e| {
+                match e {
+                    Error::CoordinatorClosed => {
+                        if !should_keep_running.load(Ordering::SeqCst) {
+                            info!("Shutdown initiated during burnchain initialization: {}", e);
+                            return burnchain_error::ShutdownInitiated;
+                        }
+                    }
+                    Error::IndexerError(_) => {}
+                }
                 error!("Burnchain controller stopped: {}", e);
                 panic!();
-            }
-        };
+            })?;
 
         // if the chainstate DBs don't exist, this will instantiate them
         if let Err(e) = burnchain_controller.connect_dbs() {
@@ -464,7 +472,7 @@ impl RunLoop {
 
         // TODO (hack) instantiate the sortdb in the burnchain
         let _ = burnchain_controller.sortdb_mut();
-        burnchain_controller
+        Ok(burnchain_controller)
     }
 
     /// Boot up the stacks chainstate.
@@ -514,6 +522,7 @@ impl RunLoop {
             get_bulk_initial_names: Some(Box::new(move || get_names(use_test_genesis_data))),
         };
 
+        info!("About to call open_and_exec");
         let (chain_state_db, receipts) = StacksChainState::open_and_exec(
             self.config.is_mainnet(),
             self.config.burnchain.chain_id,
@@ -1007,13 +1016,27 @@ impl RunLoop {
             .expect("Run loop already started, can only start once after initialization.");
 
         Self::setup_termination_handler(self.should_keep_running.clone(), false);
-        let mut burnchain = Self::instantiate_burnchain_state(
+
+        let burnchain_result = Self::instantiate_burnchain_state(
             &self.config,
             self.should_keep_running.clone(),
             burnchain_opt,
             coordinator_senders.clone(),
         );
 
+        let mut burnchain = match burnchain_result {
+            Ok(burnchain_controller) => burnchain_controller,
+            Err(burnchain_error::ShutdownInitiated) => {
+                info!("Exiting stacks-node");
+                return;
+            }
+            Err(e) => {
+                error!("Error initializing burnchain: {}", e);
+                info!("Exiting stacks-node");
+                return;
+            }
+        };
+
         let burnchain_config = burnchain.get_burnchain();
         self.burnchain = Some(burnchain_config.clone());
 

From d5af26e0ce2f5b3b032f430d8adb1081516074c9 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@blockstack.com>
Date: Mon, 4 Mar 2024 16:04:38 -0600
Subject: [PATCH 1020/1166] chore: add comment to the manual calculation of
 reward_cycle_id

---
 stackslib/src/net/api/getpoxinfo.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/stackslib/src/net/api/getpoxinfo.rs b/stackslib/src/net/api/getpoxinfo.rs
index c9e59b6519..b463609849 100644
--- a/stackslib/src/net/api/getpoxinfo.rs
+++ b/stackslib/src/net/api/getpoxinfo.rs
@@ -286,6 +286,9 @@ impl RPCPoxInfoData {
             return Err(NetError::DBError(DBError::Corruption));
         }
 
+        // Manually calculate `reward_cycle_id` so that clients don't get an "off by one" view at
+        //  reward cycle boundaries (because if the reward cycle is loaded from clarity, its
+        //  evaluated in the last mined Stacks block, not the most recent burn block).
         let reward_cycle_id = burnchain
             .block_height_to_reward_cycle(burnchain_tip.block_height)
             .ok_or_else(|| {

From 2f52d4151f5e419fc46280248a4ac7ff90dec33c Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Mon, 4 Mar 2024 14:05:58 -0800
Subject: [PATCH 1021/1166] fix: update tests in mock for
 `get-approved-agg-key`

---
 stacks-signer/src/client/mod.rs | 18 +++++++++++++-----
 1 file changed, 13 insertions(+), 5 deletions(-)

diff --git a/stacks-signer/src/client/mod.rs b/stacks-signer/src/client/mod.rs
index 63dc0e9a1f..ad7df0f330 100644
--- a/stacks-signer/src/client/mod.rs
+++ b/stacks-signer/src/client/mod.rs
@@ -137,6 +137,7 @@ pub(crate) mod tests {
     };
     use blockstack_lib::util_lib::boot::boot_code_id;
     use clarity::vm::costs::ExecutionCost;
+    use clarity::vm::types::TupleData;
     use clarity::vm::Value as ClarityValue;
     use hashbrown::{HashMap, HashSet};
     use rand::distributions::Standard;
@@ -331,11 +332,18 @@ pub(crate) mod tests {
     /// Build a response for the get_approved_aggregate_key request
     pub fn build_get_approved_aggregate_key_response(point: Option<Point>) -> String {
         let clarity_value = if let Some(point) = point {
-            ClarityValue::some(
-                ClarityValue::buff_from(point.compress().as_bytes().to_vec())
-                    .expect("BUG: Failed to create clarity value from point"),
-            )
-            .expect("BUG: Failed to create clarity value from point")
+            ClarityValue::some(ClarityValue::Tuple(
+                TupleData::from_data(vec![
+                    (
+                        "aggregate-public-key".into(),
+                        ClarityValue::buff_from(point.compress().as_bytes().to_vec())
+                            .expect("BUG: Failed to create clarity value from point"),
+                    ),
+                    ("signer-weight".into(), ClarityValue::UInt(1)), // fixed for testing purposes
+                ])
+                .expect("BUG: Failed to create clarity value from tuple data"),
+            ))
+            .expect("BUG: Failed to create clarity value from tuple data")
         } else {
             ClarityValue::none()
         };

From afcfc96cf9aa7239c6c97dd7525916c416a15b1a Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Mon, 4 Mar 2024 14:15:43 -0800
Subject: [PATCH 1022/1166] feat: improved docs and changelog

---
 CHANGELOG.md                                  |  3 ++-
 .../src/chainstate/stacks/boot/pox-4.clar     | 23 +++++++++++++++++--
 2 files changed, 23 insertions(+), 3 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 96c8b8a17f..9bab7a19d4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -13,9 +13,10 @@ and this project adheres to the versioning scheme outlined in the [README.md](RE
 - New `/new_pox_anchor` endpoint for broadcasting PoX anchor block processing.
 - Stacker bitvec in NakamotoBlock
 - New [`pox-4` contract](./stackslib/src/chainstate/stacks/boot/pox-4.clar) that reflects changes in how Stackers are signers in Nakamoto:
-  - `stack-stx`, `stack-extend`, and `stack-aggregation-commit` now include a `signer-key` parameter, which represents the public key used by the Signer. This key is used for determining the signer set in Nakamoto.
+  - `stack-stx`, `stack-extend`, `stack-increase` and `stack-aggregation-commit` now include a `signer-key` parameter, which represents the public key used by the Signer. This key is used for determining the signer set in Nakamoto.
   - Functions that include a `signer-key` parameter also include a `signer-sig` parameter to demonstrate that the owner of `signer-key` is approving that particular Stacking operation. For more details, refer to the `verify-signer-key-sig` method in the `pox-4` contract.
   - Signer key authorizations can be added via `set-signer-key-authorization` to omit the need for `signer-key` signatures
+  - A `max-amount` field is a field in signer key authorizations and defines the maximum amount of STX that can be locked in a single transaction.
 
 ### Modified
 
diff --git a/stackslib/src/chainstate/stacks/boot/pox-4.clar b/stackslib/src/chainstate/stacks/boot/pox-4.clar
index c174c0faca..681f8d9eab 100644
--- a/stackslib/src/chainstate/stacks/boot/pox-4.clar
+++ b/stackslib/src/chainstate/stacks/boot/pox-4.clar
@@ -233,7 +233,7 @@
         ;; this refers to `extend-count`. For `stack-aggregation-commit`, this is `u1`.
         period: uint,
         ;; A string representing the function where this authorization is valid. Either
-        ;; `stack-stx`, `stack-extend`, or `agg-commit`.
+        ;; `stack-stx`, `stack-extend`, `stack-increase` or `agg-commit`.
         topic: (string-ascii 14),
         ;; The PoX address that can be used with this signer key
         pox-addr: { version: (buff 1), hashbytes: (buff 32) },
@@ -620,6 +620,10 @@
 ;; * The Stacker will receive rewards in the reward cycle following `start-burn-ht`.
 ;; Importantly, `start-burn-ht` may not be further into the future than the next reward cycle,
 ;; and in most cases should be set to the current burn block height.
+;; 
+;; To ensure that the Stacker is authorized to use the provided `signer-key`, the stacker
+;; must provide either a signature have an authorization already saved. Refer to
+;; `verify-signer-key-sig` for more information.
 ;;
 ;; The tokens will unlock and be returned to the Stacker (tx-sender) automatically.
 (define-public (stack-stx (amount-ustx uint)
@@ -764,6 +768,10 @@
 ;; the lock period are inflexible, which means that the stacker must confirm their transaction
 ;; during the exact reward cycle and with the exact period that the signature or authorization was
 ;; generated for.
+;; 
+;; The `amount` field is checked to ensure it is not larger than `max-amount`, which is
+;; a field in the authorization. `auth-id` is a random uint to prevent authorization
+;; replays.
 ;;
 ;; This function does not verify the payload of the authorization. The caller of
 ;; this function must ensure that the payload (reward cycle, period, topic, and pox-addr)
@@ -772,6 +780,10 @@
 ;; When `signer-sig` is present, the public key is recovered from the signature
 ;; and compared to `signer-key`. If `signer-sig` is `none`, the function verifies that an authorization was previously
 ;; added for this key.
+;; 
+;; This function checks to ensure that the authorization hasn't been used yet, but it
+;; does _not_ store the authorization as used. The function `consume-signer-key-authorization`
+;; handles that, and this read-only function is exposed for client-side verification.
 (define-read-only (verify-signer-key-sig (pox-addr { version: (buff 1), hashbytes: (buff 32) })
                                          (reward-cycle uint)
                                          (topic (string-ascii 14))
@@ -1109,6 +1121,8 @@
 ;; This method locks up an additional amount of STX from `tx-sender`'s, indicated
 ;; by `increase-by`.  The `tx-sender` must already be Stacking & must not be
 ;; straddling more than one signer-key for the cycles effected. 
+;; Refer to `verify-signer-key-sig` for more information on the authorization parameters
+;; included here.
 (define-public (stack-increase 
   (increase-by uint)
   (signer-sig (optional (buff 65)))
@@ -1168,6 +1182,9 @@
 ;; This method extends the `tx-sender`'s current lockup for an additional `extend-count`
 ;;    and associates `pox-addr` with the rewards, The `signer-key` will be the key
 ;;    used for signing. The `tx-sender` can thus decide to change the key when extending.
+;; 
+;; Because no additional STX are locked in this function, the `amount` field used
+;; to verify the signer key authorization is zero. Refer to `verify-signer-key-sig` for more information.
 (define-public (stack-extend (extend-count uint)
                              (pox-addr { version: (buff 1), hashbytes: (buff 32) })
                              (signer-sig (optional (buff 65)))
@@ -1447,7 +1464,9 @@
 ;; in `stack-stx` and `stack-extend`, the `reward-cycle` refers to the reward cycle
 ;; where the transaction is confirmed, **not** the reward cycle where stacking begins.
 ;; The `period` parameter must match the exact lock period (or extend count) used
-;; in the stacking transaction.
+;; in the stacking transaction. The `max-amount` parameter specifies the maximum amount
+;; of STX that can be locked in an individual stacking transaction. `auth-id` is a
+;; random uint to prevent replays.
 ;;
 ;; *New in Stacks 3.0*
 (define-public (set-signer-key-authorization (pox-addr { version: (buff 1), hashbytes: (buff 32)})

From 4e0b56ad79e04259f09698a755d74967db7ece7a Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Mon, 4 Mar 2024 14:22:23 -0800
Subject: [PATCH 1023/1166] fix: missed sortdb version check

---
 stackslib/src/chainstate/burn/db/sortdb.rs | 2 --
 1 file changed, 2 deletions(-)

diff --git a/stackslib/src/chainstate/burn/db/sortdb.rs b/stackslib/src/chainstate/burn/db/sortdb.rs
index 5977431d32..a18b0355e0 100644
--- a/stackslib/src/chainstate/burn/db/sortdb.rs
+++ b/stackslib/src/chainstate/burn/db/sortdb.rs
@@ -3133,7 +3133,6 @@ impl SortitionDB {
                     || version == "6"
                     || version == "7"
                     || version == "8"
-                    || version == "9"
             }
             StacksEpochId::Epoch23 => {
                 version == "3"
@@ -3150,7 +3149,6 @@ impl SortitionDB {
                     || version == "6"
                     || version == "7"
                     || version == "8"
-                    || version == "9"
             }
             StacksEpochId::Epoch25 => {
                 version == "3"

From 138fa3aa9894aa29f7f74a64951e546028df90a1 Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Mon, 4 Mar 2024 21:00:13 -0500
Subject: [PATCH 1024/1166] fix: different mock reponse for `get-vote`

---
 stacks-signer/src/client/mod.rs           | 14 ++++++++++++++
 stacks-signer/src/client/stacks_client.rs |  7 ++++---
 2 files changed, 18 insertions(+), 3 deletions(-)

diff --git a/stacks-signer/src/client/mod.rs b/stacks-signer/src/client/mod.rs
index ad7df0f330..7c057fdf7c 100644
--- a/stacks-signer/src/client/mod.rs
+++ b/stacks-signer/src/client/mod.rs
@@ -331,6 +331,20 @@ pub(crate) mod tests {
 
     /// Build a response for the get_approved_aggregate_key request
     pub fn build_get_approved_aggregate_key_response(point: Option<Point>) -> String {
+        let clarity_value = if let Some(point) = point {
+            ClarityValue::some(
+                ClarityValue::buff_from(point.compress().as_bytes().to_vec())
+                    .expect("BUG: Failed to create clarity value from point"),
+            )
+            .expect("BUG: Failed to create clarity value from point")
+        } else {
+            ClarityValue::none()
+        };
+        build_read_only_response(&clarity_value)
+    }
+
+    /// Build a response for the get_approved_aggregate_key request
+    pub fn build_get_vote_for_aggregate_key_response(point: Option<Point>) -> String {
         let clarity_value = if let Some(point) = point {
             ClarityValue::some(ClarityValue::Tuple(
                 TupleData::from_data(vec![
diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index 62869a7494..73ff41a0ce 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -619,7 +619,8 @@ mod tests {
     use crate::client::tests::{
         build_account_nonce_response, build_get_approved_aggregate_key_response,
         build_get_last_round_response, build_get_peer_info_response, build_get_pox_data_response,
-        build_read_only_response, write_response, MockServerClient,
+        build_get_vote_for_aggregate_key_response, build_read_only_response, write_response,
+        MockServerClient,
     };
 
     #[test]
@@ -1149,7 +1150,7 @@ mod tests {
         let mock = MockServerClient::new();
         let point = Point::from(Scalar::random(&mut rand::thread_rng()));
         let stacks_address = mock.client.stacks_address;
-        let key_response = build_get_approved_aggregate_key_response(Some(point));
+        let key_response = build_get_vote_for_aggregate_key_response(Some(point));
         let h = spawn(move || {
             mock.client
                 .get_vote_for_aggregate_public_key(0, 0, stacks_address)
@@ -1159,7 +1160,7 @@ mod tests {
 
         let mock = MockServerClient::new();
         let stacks_address = mock.client.stacks_address;
-        let key_response = build_get_approved_aggregate_key_response(None);
+        let key_response = build_get_vote_for_aggregate_key_response(None);
         let h = spawn(move || {
             mock.client
                 .get_vote_for_aggregate_public_key(0, 0, stacks_address)

From 9760ced0a5dbbde830d1102076636628837045b4 Mon Sep 17 00:00:00 2001
From: Matthew Little <zone117x@gmail.com>
Date: Tue, 5 Mar 2024 10:22:51 +0100
Subject: [PATCH 1025/1166] chore: pr feedback

---
 libsigner/src/session.rs                              |  6 +++---
 libsigner/src/tests/http.rs                           |  8 ++++----
 stacks-signer/src/client/mod.rs                       |  4 ++--
 stacks-signer/src/main.rs                             |  2 +-
 .../stacks-node/src/tests/nakamoto_integrations.rs    | 10 ++--------
 testnet/stacks-node/src/tests/signer.rs               | 11 +----------
 6 files changed, 13 insertions(+), 28 deletions(-)

diff --git a/libsigner/src/session.rs b/libsigner/src/session.rs
index 7aa7796040..d86a3a3d4c 100644
--- a/libsigner/src/session.rs
+++ b/libsigner/src/session.rs
@@ -31,7 +31,7 @@ pub trait SignerSession {
     /// connect to the replica
     fn connect(
         &mut self,
-        host: &str,
+        host: String,
         stackerdb_contract_id: QualifiedContractIdentifier,
     ) -> Result<(), RPCError>;
     /// query the replica for a list of chunks
@@ -131,10 +131,10 @@ impl SignerSession for StackerDBSession {
     /// connect to the replica
     fn connect(
         &mut self,
-        host: &str,
+        host: String,
         stackerdb_contract_id: QualifiedContractIdentifier,
     ) -> Result<(), RPCError> {
-        self.host = host.to_owned();
+        self.host = host;
         self.stackerdb_contract_id = stackerdb_contract_id;
         self.connect_or_reconnect()
     }
diff --git a/libsigner/src/tests/http.rs b/libsigner/src/tests/http.rs
index 3fac7c337c..d2b052fae9 100644
--- a/libsigner/src/tests/http.rs
+++ b/libsigner/src/tests/http.rs
@@ -264,7 +264,7 @@ fn test_run_http_request_with_body() {
 
         let result_chunked = run_http_request(
             &mut msock_chunked,
-            &"127.0.0.1:20443".parse().unwrap(),
+            &"127.0.0.1:20443",
             verb,
             path,
             content_type,
@@ -275,7 +275,7 @@ fn test_run_http_request_with_body() {
 
         let result_plain = run_http_request(
             &mut msock_plain,
-            &"127.0.0.1:20443".parse().unwrap(),
+            &"127.0.0.1:20443",
             verb,
             path,
             content_type,
@@ -321,7 +321,7 @@ fn test_run_http_request_no_body() {
 
         let result_chunked = run_http_request(
             &mut msock_chunked,
-            &"127.0.0.1:20443".parse().unwrap(),
+            &"127.0.0.1:20443",
             verb,
             path,
             content_type,
@@ -330,7 +330,7 @@ fn test_run_http_request_no_body() {
         .unwrap();
         let result_plain = run_http_request(
             &mut msock_plain,
-            &"127.0.0.1:20443".parse().unwrap(),
+            &"127.0.0.1:20443",
             verb,
             path,
             content_type,
diff --git a/stacks-signer/src/client/mod.rs b/stacks-signer/src/client/mod.rs
index c5bc348ab2..daed26a177 100644
--- a/stacks-signer/src/client/mod.rs
+++ b/stacks-signer/src/client/mod.rs
@@ -202,7 +202,7 @@ pub(crate) mod tests {
 
     /// Create a mock server on a same port as in the config
     pub fn mock_server_from_config(config: &GlobalConfig) -> TcpListener {
-        TcpListener::bind(config.node_host).unwrap()
+        TcpListener::bind(config.node_host.to_string()).unwrap()
     }
 
     /// Write a response to the mock server and return the request bytes
@@ -503,7 +503,7 @@ pub(crate) mod tests {
             signer_slot_ids,
             ecdsa_private_key: config.ecdsa_private_key,
             stacks_private_key: config.stacks_private_key,
-            node_host: config.node_host,
+            node_host: config.node_host.to_string(),
             mainnet: config.network.is_mainnet(),
             dkg_end_timeout: config.dkg_end_timeout,
             dkg_private_timeout: config.dkg_private_timeout,
diff --git a/stacks-signer/src/main.rs b/stacks-signer/src/main.rs
index 9b2aabfda9..85d80c13c7 100644
--- a/stacks-signer/src/main.rs
+++ b/stacks-signer/src/main.rs
@@ -64,7 +64,7 @@ struct SpawnedSigner {
 /// Create a new stacker db session
 fn stackerdb_session(host: &str, contract: QualifiedContractIdentifier) -> StackerDBSession {
     let mut session = StackerDBSession::new(host, contract.clone());
-    session.connect(&host, contract).unwrap();
+    session.connect(host.to_string(), contract).unwrap();
     session
 }
 
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 3b46ce24ac..3c661a7652 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -1827,13 +1827,6 @@ fn miner_writes_proposed_block_to_stackerdb() {
     )
     .unwrap();
 
-    let rpc_sock = naka_conf
-        .node
-        .rpc_bind
-        .clone()
-        .parse()
-        .expect("Failed to parse socket");
-
     let sortdb = naka_conf.get_burnchain().open_sortition_db(true).unwrap();
     let tip = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn()).unwrap();
     let miner_pubkey =
@@ -1844,7 +1837,8 @@ fn miner_writes_proposed_block_to_stackerdb() {
 
     let chunk = std::thread::spawn(move || {
         let miner_contract_id = boot_code_id(MINERS_NAME, false);
-        let mut miners_stackerdb = StackerDBSession::new(rpc_sock, miner_contract_id);
+        let mut miners_stackerdb =
+            StackerDBSession::new(&naka_conf.node.rpc_bind, miner_contract_id);
         miners_stackerdb
             .get_latest_chunk(slot_id)
             .expect("Failed to get latest chunk from the miner slot ID")
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index c0c2e72e2b..713ba4a3fb 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -1285,15 +1285,6 @@ fn stackerdb_filter_bad_transactions() {
     assert_ne!(current_signers_dkg, next_signers_dkg);
 
     info!("------------------------- Submit Invalid Transactions -------------------------");
-    let host = signer_test
-        .running_nodes
-        .conf
-        .node
-        .rpc_bind
-        .to_socket_addrs()
-        .unwrap()
-        .next()
-        .unwrap();
 
     let signer_private_key = signer_test
         .signer_stacks_private_keys
@@ -1308,7 +1299,7 @@ fn stackerdb_filter_bad_transactions() {
     // Must submit to the NEXT reward cycle slots as they are the ones looked at by the CURRENT miners
     let signer_index = signer_test.get_signer_index(next_reward_cycle);
     let mut stackerdb = StackerDB::new(
-        host,
+        &signer_test.running_nodes.conf.node.rpc_bind,
         signer_private_key,
         false,
         next_reward_cycle,

From 5e1147ef57d83cf1522bf764ca81ac3d39255952 Mon Sep 17 00:00:00 2001
From: BowTiedRadone <bowtiedradone@gmail.com>
Date: Tue, 5 Mar 2024 16:49:33 +0200
Subject: [PATCH 1026/1166] Added tests for minimal-can-stack-stx

---
 .../tests/pox-4/pox-4.prop.test.ts            | 786 +++++++++++++++++-
 1 file changed, 782 insertions(+), 4 deletions(-)

diff --git a/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts b/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
index d084d7759d..a377fa9915 100644
--- a/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
+++ b/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
@@ -1,10 +1,25 @@
-import { Cl, ClarityType, bufferCV, isClarityType } from "@stacks/transactions";
+import {
+  Cl,
+  ClarityType,
+  bufferCV,
+  cvToJSON,
+  isClarityType,
+} from "@stacks/transactions";
 import { assert, describe, expect, it } from "vitest";
 import fc from "fast-check";
 
+// contracts
 const POX_4 = "pox-4";
+// methods
 const GET_POX_INFO = "get-pox-info";
-const testnet_stacking_threshold_25 = 8000;
+// contract consts
+const TESTNET_STACKING_THRESHOLD_25 = 8000;
+// error codes
+const ERR_STACKING_INVALID_LOCK_PERIOD = 2;
+const ERR_STACKING_THRESHOLD_NOT_MET = 11;
+const ERR_STACKING_INVALID_POX_ADDRESS = 13;
+const ERR_STACKING_INVALID_AMOUNT = 18;
+
 fc.configureGlobal({ numRuns: 250 });
 
 describe("test pox-4 contract read only functions", () => {
@@ -237,7 +252,7 @@ describe("test pox-4 contract read only functions", () => {
 
           assert(isClarityType(stx_liq_supply, ClarityType.UInt));
           const expected = Math.floor(
-            Number(stx_liq_supply.value) / testnet_stacking_threshold_25
+            Number(stx_liq_supply.value) / TESTNET_STACKING_THRESHOLD_25
           );
 
           // Act
@@ -502,6 +517,69 @@ describe("test pox-4 contract read only functions", () => {
     );
   });
 
+  it("should return (err 13) can-stack-stx for pox addresses having version > 6", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({
+          min: 7,
+          max: 255,
+        }),
+        fc.array(fc.nat({ max: 255 }), {
+          minLength: 32,
+          maxLength: 32,
+        }),
+        fc.bigInt({
+          min: 125_000_000_000n,
+          max: 340282366920938463463374607431768211455n,
+        }),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            POX_4,
+            GET_POX_INFO,
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+          const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "can-stack-stx",
+            [
+              Cl.tuple({
+                version: bufferCV(Uint8Array.from([version])),
+                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
+        }
+      )
+    );
+  });
+
   it("should return (err 13) can-stack-stx for versions 0-4 pox addresses having hasbytes longer than 20", () => {
     fc.assert(
       fc.property(
@@ -535,7 +613,182 @@ describe("test pox-4 contract read only functions", () => {
           assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
           assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
 
-          const expectedResponseErr = 13;
+          const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "can-stack-stx",
+            [
+              Cl.tuple({
+                version: bufferCV(Uint8Array.from([version])),
+                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
+        }
+      )
+    );
+  });
+
+  it("should return (err 13) can-stack-stx for versions 0-4 pox addresses having hasbytes shorter than 20", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 0, max: 4 }),
+        fc.array(fc.nat({ max: 255 }), {
+          maxLength: 19,
+        }),
+        fc.bigInt({
+          min: 125_000_000_000n,
+          max: 340282366920938463463374607431768211455n,
+        }),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            POX_4,
+            GET_POX_INFO,
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+          const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "can-stack-stx",
+            [
+              Cl.tuple({
+                version: bufferCV(Uint8Array.from([version])),
+                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
+        }
+      )
+    );
+  });
+
+  it("should return (err 13) can-stack-stx for versions 5/6 pox addresses having hashbytes shorter than 32", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 0, max: 4 }),
+        fc.array(fc.nat({ max: 255 }), {
+          maxLength: 31,
+        }),
+        fc.bigInt({
+          min: 125_000_000_000n,
+          max: 340282366920938463463374607431768211455n,
+        }),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            POX_4,
+            GET_POX_INFO,
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+          const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "can-stack-stx",
+            [
+              Cl.tuple({
+                version: bufferCV(Uint8Array.from([version])),
+                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
+        }
+      )
+    );
+  });
+
+  it("should return (err 11) can-stack-stx for unmet stacking threshold", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 0, max: 6 }),
+        fc.array(fc.nat({ max: 255 })),
+        fc.bigInt({
+          min: 0n,
+          max: 124_999_999_999n,
+        }),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            POX_4,
+            GET_POX_INFO,
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+          const expectedResponseErr = ERR_STACKING_THRESHOLD_NOT_MET;
 
           // Act
           const { result: actual } = simnet.callReadOnlyFn(
@@ -561,4 +814,529 @@ describe("test pox-4 contract read only functions", () => {
       )
     );
   });
+
+  it("should return (err 2) can-stack-stx for lock period > 12", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 0, max: 6 }),
+        fc.array(fc.nat({ max: 255 })),
+        fc.bigInt({
+          min: 125_000_000_000n,
+          max: 340282366920938463463374607431768211455n,
+        }),
+        fc.nat(),
+        fc.integer({ min: 13 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            POX_4,
+            GET_POX_INFO,
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+          const expectedResponseErr = ERR_STACKING_INVALID_LOCK_PERIOD;
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "can-stack-stx",
+            [
+              Cl.tuple({
+                version: bufferCV(Uint8Array.from([version])),
+                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
+        }
+      )
+    );
+  });
+
+  // minimal can stack stx
+  it("should return (ok true) minimal-can-stack-stx for versions 0-4 valid pox addresses, hashbytes, amount, cycles number", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 0, max: 4 }),
+        fc.array(fc.nat({ max: 255 }), {
+          minLength: 20,
+          maxLength: 20,
+        }),
+        fc.bigInt({
+          min: 125_000_000_000n,
+          max: 340282366920938463463374607431768211455n,
+        }),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            POX_4,
+            GET_POX_INFO,
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+          const expectedResponseOk = true;
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "minimal-can-stack-stx",
+            [
+              Cl.tuple({
+                version: bufferCV(Uint8Array.from([version])),
+                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseOk));
+          assert(isClarityType(actual.value, ClarityType.BoolTrue));
+          expect(actual).toBeOk(Cl.bool(expectedResponseOk));
+        }
+      )
+    );
+  });
+
+  it("should return (ok true) minimal-can-stack-stx for versions 5/6 valid pox addresses, hashbytes, amount, cycles number", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 5, max: 6 }),
+        fc.array(fc.nat({ max: 255 }), {
+          minLength: 32,
+          maxLength: 32,
+        }),
+        fc.bigInt({
+          min: 125_000_000_000n,
+          max: 340282366920938463463374607431768211455n,
+        }),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            POX_4,
+            GET_POX_INFO,
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+          const expectedResponseOk = true;
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "minimal-can-stack-stx",
+            [
+              Cl.tuple({
+                version: bufferCV(Uint8Array.from([version])),
+                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseOk));
+          assert(isClarityType(actual.value, ClarityType.BoolTrue));
+          expect(actual).toBeOk(Cl.bool(expectedResponseOk));
+        }
+      )
+    );
+  });
+
+  it("should return (err 13) minimal-can-stack-stx for pox addresses having version > 6", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({
+          min: 7,
+          max: 255,
+        }),
+        fc.array(fc.nat({ max: 255 }), {
+          minLength: 32,
+          maxLength: 32,
+        }),
+        fc.bigInt({
+          min: 125_000_000_000n,
+          max: 340282366920938463463374607431768211455n,
+        }),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            POX_4,
+            GET_POX_INFO,
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+          const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "minimal-can-stack-stx",
+            [
+              Cl.tuple({
+                version: bufferCV(Uint8Array.from([version])),
+                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
+        }
+      )
+    );
+  });
+
+  it("should return (err 13) minimal-can-stack-stx for versions 0-4 pox addresses having hasbytes longer than 20", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 0, max: 4 }),
+        fc.array(fc.nat({ max: 255 }), {
+          minLength: 21,
+          maxLength: 32,
+        }),
+        fc.bigInt({
+          min: 125_000_000_000n,
+          max: 340282366920938463463374607431768211455n,
+        }),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            POX_4,
+            GET_POX_INFO,
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+          const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "minimal-can-stack-stx",
+            [
+              Cl.tuple({
+                version: bufferCV(Uint8Array.from([version])),
+                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
+        }
+      )
+    );
+  });
+
+  it("should return (err 13) minimal-can-stack-stx for versions 0-4 pox addresses having hasbytes shorter than 20", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 0, max: 4 }),
+        fc.array(fc.nat({ max: 255 }), {
+          maxLength: 19,
+        }),
+        fc.bigInt({
+          min: 125_000_000_000n,
+          max: 340282366920938463463374607431768211455n,
+        }),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            POX_4,
+            GET_POX_INFO,
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+          const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "minimal-can-stack-stx",
+            [
+              Cl.tuple({
+                version: bufferCV(Uint8Array.from([version])),
+                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
+        }
+      )
+    );
+  });
+
+  it("should return (err 13) minimal-can-stack-stx for versions 5/6 pox addresses having hashbytes shorter than 32", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 0, max: 4 }),
+        fc.array(fc.nat({ max: 255 }), {
+          maxLength: 31,
+        }),
+        fc.bigInt({
+          min: 125_000_000_000n,
+          max: 340282366920938463463374607431768211455n,
+        }),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            POX_4,
+            GET_POX_INFO,
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+          const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "minimal-can-stack-stx",
+            [
+              Cl.tuple({
+                version: bufferCV(Uint8Array.from([version])),
+                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
+        }
+      )
+    );
+  });
+
+  it("should return (err 2) minimal-can-stack-stx for lock period > 12", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 0, max: 6 }),
+        fc.array(fc.nat({ max: 255 })),
+        fc.bigInt({
+          min: 125_000_000_000n,
+          max: 340282366920938463463374607431768211455n,
+        }),
+        fc.nat(),
+        fc.integer({ min: 13 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            POX_4,
+            GET_POX_INFO,
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+          const expectedResponseErr = ERR_STACKING_INVALID_LOCK_PERIOD;
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "minimal-can-stack-stx",
+            [
+              Cl.tuple({
+                version: bufferCV(Uint8Array.from([version])),
+                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
+        }
+      )
+    );
+  });
+
+  it("should return (err 18) minimal-can-stack-stx for amount == 0", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer(),
+        fc.array(fc.nat({ max: 255 })),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (caller, version, hashbytes, first_rew_cycle, num_cycles) => {
+          // Arrange
+          const amount_ustx = 0;
+
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            POX_4,
+            GET_POX_INFO,
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+          const expectedResponseErr = ERR_STACKING_INVALID_AMOUNT;
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "minimal-can-stack-stx",
+            [
+              Cl.tuple({
+                version: bufferCV(Uint8Array.from([version])),
+                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
+        }
+      )
+    );
+  });
 });

From ac9836ddff460c058e9cce315d87f8b973b79083 Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Tue, 5 Mar 2024 10:13:13 -0500
Subject: [PATCH 1027/1166] ci: disable `fail_ci_if_error` until codecov upload
 is fixed

---
 .github/workflows/stacks-core-tests.yml | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/stacks-core-tests.yml b/.github/workflows/stacks-core-tests.yml
index e8d82b4dcb..5105c6535e 100644
--- a/.github/workflows/stacks-core-tests.yml
+++ b/.github/workflows/stacks-core-tests.yml
@@ -160,7 +160,8 @@ jobs:
         id: codecov
         uses: stacks-network/actions/codecov@main
         with:
-          fail_ci_if_error: true
+          # We'd like to uncomment the below line once the codecov upload is working
+          # fail_ci_if_error: true
           test-name: ${{ matrix.test-name }}
           upload-only: true
           filename: ./contrib/core-contract-tests/lcov.info

From c0d4c28c40b7515b3ecd3dbe4822a595d0460dde Mon Sep 17 00:00:00 2001
From: Matthew Little <zone117x@gmail.com>
Date: Tue, 5 Mar 2024 16:27:09 +0100
Subject: [PATCH 1028/1166] chore: fix merge conflict

---
 testnet/stacks-node/src/tests/nakamoto_integrations.rs | 10 ++--------
 testnet/stacks-node/src/tests/signer.rs                |  2 +-
 2 files changed, 3 insertions(+), 9 deletions(-)

diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 00ea8cfe70..ff0f088f3a 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -254,16 +254,10 @@ pub fn read_and_sign_block_proposal(
     let reward_cycle = burnchain
         .block_height_to_reward_cycle(tip.block_height)
         .unwrap();
-    let rpc_sock = conf
-        .node
-        .rpc_bind
-        .clone()
-        .parse()
-        .expect("Failed to parse socket");
 
     let mut proposed_block: NakamotoBlock = {
         let miner_contract_id = boot_code_id(MINERS_NAME, false);
-        let mut miners_stackerdb = StackerDBSession::new(rpc_sock, miner_contract_id);
+        let mut miners_stackerdb = StackerDBSession::new(&conf.node.rpc_bind, miner_contract_id);
         miners_stackerdb
             .get_latest(miner_slot_id)
             .map_err(|_| "Failed to get latest chunk from the miner slot ID")?
@@ -304,7 +298,7 @@ pub fn read_and_sign_block_proposal(
     let next_version = get_stackerdb_slot_version(&http_origin, &signers_contract_id, signer_index)
         .map(|x| x + 1)
         .unwrap_or(0);
-    let mut signers_contract_sess = StackerDBSession::new(rpc_sock, signers_contract_id);
+    let mut signers_contract_sess = StackerDBSession::new(&conf.node.rpc_bind, signers_contract_id);
     let mut chunk_to_put = StackerDBChunkData::new(
         u32::try_from(signer_index).unwrap(),
         next_version,
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index 9159d319ad..fc8d84aa96 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -103,7 +103,7 @@ impl SignerTest {
             .map(|_| StacksPrivateKey::new())
             .collect::<Vec<StacksPrivateKey>>();
 
-        let (mut naka_conf, _miner_account) = naka_neon_integration_conf(None);
+        let (naka_conf, _miner_account) = naka_neon_integration_conf(None);
 
         // Setup the signer and coordinator configurations
         let signer_configs = build_signer_config_tomls(

From 11dd4d14d191bf0b0547ee8d10b05968c26e6af2 Mon Sep 17 00:00:00 2001
From: wileyj <2847772+wileyj@users.noreply.github.com>
Date: Tue, 5 Mar 2024 12:22:59 -0800
Subject: [PATCH 1029/1166] addressing PR comments/default x64 builds to
 variant 3

---
 .../dockerfiles/Dockerfile.alpine-binary      | 16 ++++++-----
 .../dockerfiles/Dockerfile.debian-binary      | 16 ++++++-----
 .github/workflows/create-source-binary.yml    | 27 ++++++++++++++-----
 .github/workflows/image-build-binary.yml      |  5 ++--
 .github/workflows/image-build-source.yml      |  5 ++--
 5 files changed, 45 insertions(+), 24 deletions(-)

diff --git a/.github/actions/dockerfiles/Dockerfile.alpine-binary b/.github/actions/dockerfiles/Dockerfile.alpine-binary
index 61151f0d2a..eae3a123bf 100644
--- a/.github/actions/dockerfiles/Dockerfile.alpine-binary
+++ b/.github/actions/dockerfiles/Dockerfile.alpine-binary
@@ -7,14 +7,18 @@ ARG TARGETPLATFORM
 ARG BUILDPLATFORM
 ARG TARGETARCH
 ARG TARGETVARIANT
-ARG REPO=stacks-network/stacks-core
+ARG REPO
 
-RUN case ${TARGETARCH} in \
-    "amd64")  BIN_ARCH=linux-musl-x64-v3  ;; \
-    "arm64")  BIN_ARCH=linux-musl-arm64  ;; \
-    "arm")  BIN_ARCH=linux-musl-armv7  ;; \
-    "*") exit 1 ;; \
+RUN case ${TARGETPLATFORM} in \
+    linux/amd64/v2) BIN_ARCH=linux-glibc-x64-v2 ;; \
+    linux/amd64*) BIN_ARCH=linux-glibc-x64 ;; \
+    linux/arm64*) BIN_ARCH=linux-glibc-arm64 ;; \
+    linux/arm/v7) BIN_ARCH=linux-glibc-armv7 ;; \
+    *) exit 1 ;; \
     esac \
+    && echo "TARGETPLATFORM: $TARGETPLATFORM" \
+    && echo "BIN_ARCH: $BIN_ARCH" \
+    && echo "wget -q https://github.com/${REPO}/releases/download/${TAG}/${BIN_ARCH}.zip -O /${BIN_ARCH}.zip" \
     && wget -q https://github.com/${REPO}/releases/download/${TAG}/${BIN_ARCH}.zip -O /${BIN_ARCH}.zip \
     && unzip ${BIN_ARCH}.zip -d /out
 
diff --git a/.github/actions/dockerfiles/Dockerfile.debian-binary b/.github/actions/dockerfiles/Dockerfile.debian-binary
index 7bfd252c04..f446190853 100644
--- a/.github/actions/dockerfiles/Dockerfile.debian-binary
+++ b/.github/actions/dockerfiles/Dockerfile.debian-binary
@@ -7,14 +7,18 @@ ARG TARGETPLATFORM
 ARG BUILDPLATFORM
 ARG TARGETARCH
 ARG TARGETVARIANT
-ARG REPO=stacks-network/stacks-core
+ARG REPO
 
-RUN case ${TARGETARCH} in \
-    "amd64")  BIN_ARCH=linux-glibc-x64-v3  ;; \
-    "arm64")  BIN_ARCH=linux-glibc-arm64  ;; \
-    "arm")  BIN_ARCH=linux-glibc-armv7  ;; \
-    "*") exit 1 ;; \
+RUN case ${TARGETPLATFORM} in \
+    linux/amd64/v2) BIN_ARCH=linux-glibc-x64-v2 ;; \
+    linux/amd64*) BIN_ARCH=linux-glibc-x64 ;; \
+    linux/arm64*) BIN_ARCH=linux-glibc-arm64 ;; \
+    linux/arm/v7) BIN_ARCH=linux-glibc-armv7 ;; \
+    *) exit 1 ;; \
     esac \
+    && echo "TARGETPLATFORM: $TARGETPLATFORM" \
+    && echo "BIN_ARCH: $BIN_ARCH" \
+    && echo "wget -q https://github.com/${REPO}/releases/download/${TAG}/${BIN_ARCH}.zip -O /${BIN_ARCH}.zip" \
     && wget -q https://github.com/${REPO}/releases/download/${TAG}/${BIN_ARCH}.zip -O /${BIN_ARCH}.zip \
     && unzip ${BIN_ARCH}.zip -d /out
 
diff --git a/.github/workflows/create-source-binary.yml b/.github/workflows/create-source-binary.yml
index d0cff1cde6..0848cf2eb4 100644
--- a/.github/workflows/create-source-binary.yml
+++ b/.github/workflows/create-source-binary.yml
@@ -40,8 +40,10 @@ jobs:
         cpu:
           - arm64
           - armv7
-          - x86-64
-          - x86-64-v3
+          - x86-64 ## defaults to x86-64-v3 variant - intel haswell (2013) and newer
+          # - x86-64-v2 ## intel nehalem (2008) and newer
+          # - x86-64-v3 ## intel haswell (2013) and newer
+          # - x86-64-v4 ## intel skylake (2017) and newer
         exclude:
           - arch: windows # excludes windows-arm64
             cpu: arm64
@@ -57,19 +59,33 @@ jobs:
         uses: stacks-network/actions/docker@main
 
       - name: Set Local env vars
-        id: set_envars
+        id: set_env
         run: |
           case ${{ matrix.cpu }} in
               x86-64)
-                  TARGET_CPU="${{ matrix.cpu }}"
+                  ## default x64 builds to use v3 variant. TARGET_CPU is required to build for v3 via RUSTFLAGS
+                  TARGET_CPU="${{ matrix.cpu }}-v3"
                   DOCKERFILE_CPU="x64"
                   ARCHIVE_NAME="x64"
                   ;;
+              x86-64-v2)
+                  ## intel nehalem (2008) and newer
+                  TARGET_CPU="${{ matrix.cpu }}"
+                  DOCKERFILE_CPU="x64"
+                  ARCHIVE_NAME="x64-v2"
+                  ;;
               x86-64-v3)
+                  ## intel haswell (2013) and newer
                   TARGET_CPU="${{ matrix.cpu }}"
                   DOCKERFILE_CPU="x64"
                   ARCHIVE_NAME="x64-v3"
                   ;;
+              x86-64-v4)
+                  ## intel skylake (2017) and newer
+                  TARGET_CPU="${{ matrix.cpu }}"
+                  DOCKERFILE_CPU="x64"
+                  ARCHIVE_NAME="x64-v4"
+                  ;;
               *)
                   TARGET_CPU=""
                   DOCKERFILE_CPU="${{ matrix.cpu }}"
@@ -79,9 +95,6 @@ jobs:
           echo "DOCKERFILE=Dockerfile.${{ matrix.arch }}-${DOCKERFILE_CPU}" >> "$GITHUB_ENV"
           echo "ZIPFILE=${{ matrix.arch }}-${ARCHIVE_NAME}" >> "$GITHUB_ENV"
           echo "TARGET_CPU=${TARGET_CPU}" >> "$GITHUB_ENV"
-          echo "DOCKERFILE: ${DOCKERFILE}"
-          echo "ZIPFILE: ${ZIPFILE}"
-          echo "TARGET_CPU: ${TARGET_CPU}"
 
       ## Build the binaries using defined dockerfiles
       - name: Build Binary (${{ matrix.arch }}_${{ matrix.cpu }})
diff --git a/.github/workflows/image-build-binary.yml b/.github/workflows/image-build-binary.yml
index 11a1012188..b804ae3be6 100644
--- a/.github/workflows/image-build-binary.yml
+++ b/.github/workflows/image-build-binary.yml
@@ -12,7 +12,7 @@ on:
 
 ## Define which docker arch to build for
 env:
-  docker_platforms: "linux/arm64, linux/arm/v7, linux/amd64, linux/amd64/v2, linux/amd64/v3"
+  docker_platforms: "linux/arm64, linux/arm/v7, linux/amd64, linux/amd64/v3"
   docker-org: blockstack
 
 concurrency:
@@ -52,7 +52,7 @@ jobs:
       ## if the repo owner is not `stacks-network`, default to a docker-org of the repo owner (i.e. github user id)
       ## this allows forks to run the docker push workflows without having to hardcode a dockerhub org (but it does require docker hub user to match github username)
       - name: Set Local env vars
-        id: set_envars
+        id: set_env
         if: |
           github.repository_owner != 'stacks-network'
         run: |
@@ -65,6 +65,7 @@ jobs:
         id: docker_metadata
         uses: docker/metadata-action@96383f45573cb7f253c731d3b3ab81c87ef81934 #v5.0.0
         with:
+          ## tag images with current repo name `stacks-core` as well as legacy `stacks-blockchain`
           images: |
             ${{env.docker-org}}/${{ github.event.repository.name }}
             ${{env.docker-org}}/stacks-blockchain
diff --git a/.github/workflows/image-build-source.yml b/.github/workflows/image-build-source.yml
index c2609caf37..ebb9afc679 100644
--- a/.github/workflows/image-build-source.yml
+++ b/.github/workflows/image-build-source.yml
@@ -8,7 +8,7 @@ on:
 
 ## Define which docker arch to build for
 env:
-  docker_platforms: linux/amd64
+  docker_platforms: "linux/amd64"
   docker-org: blockstack
 
 concurrency:
@@ -40,7 +40,7 @@ jobs:
       ## if the repo owner is not `stacks-network`, default to a docker-org of the repo owner (i.e. github user id)
       ## this allows forks to run the docker push workflows without having to hardcode a dockerhub org (but it does require docker hub user to match github username)
       - name: Set Local env vars
-        id: set_envars
+        id: set_env
         if: |
           github.repository_owner != 'stacks-network'
         run: |
@@ -68,7 +68,6 @@ jobs:
           tags: ${{ steps.docker_metadata.outputs.tags }}
           labels: ${{ steps.docker_metadata.outputs.labels }}
           build-args: |
-            REPO=${{ github.repository_owner }}/${{ github.event.repository.name }}
             STACKS_NODE_VERSION=${{ env.GITHUB_SHA_SHORT }}
             GIT_BRANCH=${{ env.GITHUB_REF_SHORT }}
             GIT_COMMIT=${{ env.GITHUB_SHA_SHORT }}

From 1c5764ecb18f8cae33ba0c72c2d2e649b48203ee Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Tue, 5 Mar 2024 12:52:21 -0800
Subject: [PATCH 1030/1166] fix: expected reward cycle in integration test for
 pox info

---
 .../src/tests/neon_integrations.rs            | 19 +++++++++++++------
 1 file changed, 13 insertions(+), 6 deletions(-)

diff --git a/testnet/stacks-node/src/tests/neon_integrations.rs b/testnet/stacks-node/src/tests/neon_integrations.rs
index cd0c96358e..5ea49c1cc9 100644
--- a/testnet/stacks-node/src/tests/neon_integrations.rs
+++ b/testnet/stacks-node/src/tests/neon_integrations.rs
@@ -6082,6 +6082,7 @@ fn pox_integration_test() {
     let http_origin = format!("http://{}", &conf.node.rpc_bind);
 
     btc_regtest_controller.bootstrap_chain(201);
+    let burnchain = burnchain_config.clone();
 
     eprintln!("Chain bootstrapped...");
 
@@ -6139,9 +6140,12 @@ fn pox_integration_test() {
         pox_info.rejection_fraction,
         Some(pox_constants.pox_rejection_fraction)
     );
-    assert_eq!(pox_info.reward_cycle_id, 0);
-    assert_eq!(pox_info.current_cycle.id, 0);
-    assert_eq!(pox_info.next_cycle.id, 1);
+    let reward_cycle = burnchain
+        .block_height_to_reward_cycle(sort_height)
+        .expect("Expected to be able to get reward cycle");
+    assert_eq!(pox_info.reward_cycle_id, reward_cycle);
+    assert_eq!(pox_info.current_cycle.id, reward_cycle);
+    assert_eq!(pox_info.next_cycle.id, reward_cycle + 1);
     assert_eq!(
         pox_info.reward_cycle_length as u32,
         pox_constants.reward_cycle_length
@@ -6184,6 +6188,9 @@ fn pox_integration_test() {
     }
 
     let pox_info = get_pox_info(&http_origin).unwrap();
+    let reward_cycle = burnchain
+        .block_height_to_reward_cycle(sort_height)
+        .expect("Expected to be able to get reward cycle");
 
     assert_eq!(
         &pox_info.contract_id,
@@ -6207,9 +6214,9 @@ fn pox_integration_test() {
         pox_info.rejection_fraction,
         Some(pox_constants.pox_rejection_fraction)
     );
-    assert_eq!(pox_info.reward_cycle_id, 14);
-    assert_eq!(pox_info.current_cycle.id, 14);
-    assert_eq!(pox_info.next_cycle.id, 15);
+    assert_eq!(pox_info.reward_cycle_id, reward_cycle);
+    assert_eq!(pox_info.current_cycle.id, reward_cycle);
+    assert_eq!(pox_info.next_cycle.id, reward_cycle + 1);
     assert_eq!(
         pox_info.reward_cycle_length as u32,
         pox_constants.reward_cycle_length

From fc2d52c742546f0daa411340e3867a292f2676e9 Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Tue, 5 Mar 2024 16:23:29 -0500
Subject: [PATCH 1031/1166] feat: gate `target-cpu=native` with `portable`
 feature

We believe this can cause some problems with docker images.
---
 .cargo/config                                        | 6 ++++--
 .github/actions/dockerfiles/Dockerfile.debian-source | 2 +-
 stacks-signer/Cargo.toml                             | 2 ++
 testnet/stacks-node/Cargo.toml                       | 1 +
 4 files changed, 8 insertions(+), 3 deletions(-)

diff --git a/.cargo/config b/.cargo/config
index 38785b2bf0..a3f905bff3 100644
--- a/.cargo/config
+++ b/.cargo/config
@@ -3,9 +3,11 @@ stacks-node = "run --package stacks-node --"
 fmt-stacks = "fmt -- --config group_imports=StdExternalCrate,imports_granularity=Module"
 
 # For x86_64 CPUs, default to `native` and override in CI for release builds
-# This makes it slightly faster for users running locally built binaries
+# This makes it slightly faster for users running locally built binaries.
+# This can cause trouble when building "portable" binaries, such as for docker,
+# so disable it with the "portable" feature.
 # TODO: Same for other targets?
-[target.'cfg(all(target_arch = "x86_64"))']
+[target.'cfg(all(target_arch = "x86_64", not(feature = portable))']
 rustflags = ["-Ctarget-cpu=native"]
 
 # Needed by perf to generate flamegraphs.
diff --git a/.github/actions/dockerfiles/Dockerfile.debian-source b/.github/actions/dockerfiles/Dockerfile.debian-source
index cbdcb9dcda..13f4553613 100644
--- a/.github/actions/dockerfiles/Dockerfile.debian-source
+++ b/.github/actions/dockerfiles/Dockerfile.debian-source
@@ -16,7 +16,7 @@ RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
     && cd ${BUILD_DIR} \
     && rustup target add ${TARGET} \
     && rustup component add rustfmt \
-    && cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} \
+    && cargo build --features monitoring_prom,slog_json,portable --release --workspace --target ${TARGET} \
     && mkdir -p /out \
     && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
 
diff --git a/stacks-signer/Cargo.toml b/stacks-signer/Cargo.toml
index 0bf969e4af..f6fb9ce80c 100644
--- a/stacks-signer/Cargo.toml
+++ b/stacks-signer/Cargo.toml
@@ -55,3 +55,5 @@ features = ["arbitrary_precision", "unbounded_depth"]
 version = "0.24.3"
 features = ["serde", "recovery"]
 
+[features]
+portable = []
diff --git a/testnet/stacks-node/Cargo.toml b/testnet/stacks-node/Cargo.toml
index 71f8808a12..ca88a36189 100644
--- a/testnet/stacks-node/Cargo.toml
+++ b/testnet/stacks-node/Cargo.toml
@@ -65,4 +65,5 @@ path = "src/stacks_events.rs"
 monitoring_prom = ["stacks/monitoring_prom"]
 slog_json = ["stacks/slog_json", "stacks-common/slog_json", "clarity/slog_json"]
 prod-genesis-chainstate = []
+portable = []
 default = []

From 574f73248cbfb0d091348f93785af87597c9d630 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Wed, 7 Feb 2024 19:03:41 -0800
Subject: [PATCH 1032/1166] feat: setup basic signerDB

---
 Cargo.lock                                 |   1 +
 stacks-signer/Cargo.toml                   |   4 +
 stacks-signer/src/client/mod.rs            |   1 +
 stacks-signer/src/config.rs                |  12 +
 stacks-signer/src/lib.rs                   |   2 +
 stacks-signer/src/runloop.rs               |   1 +
 stacks-signer/src/signer.rs                | 172 ++++++++-----
 stacks-signer/src/signerdb.rs              | 280 +++++++++++++++++++++
 stacks-signer/src/tests/conf/signer-0.toml |   1 +
 9 files changed, 416 insertions(+), 58 deletions(-)
 create mode 100644 stacks-signer/src/signerdb.rs

diff --git a/Cargo.lock b/Cargo.lock
index 4aa6412fef..2309083304 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3454,6 +3454,7 @@ dependencies = [
  "rand 0.8.5",
  "rand_core 0.6.4",
  "reqwest",
+ "rusqlite",
  "secp256k1",
  "serde",
  "serde_derive",
diff --git a/stacks-signer/Cargo.toml b/stacks-signer/Cargo.toml
index 0bf969e4af..1d49b88fc8 100644
--- a/stacks-signer/Cargo.toml
+++ b/stacks-signer/Cargo.toml
@@ -47,6 +47,10 @@ url = "2.1.0"
 [dev-dependencies]
 clarity = { path = "../clarity", features = ["testing"] }
 
+[dependencies.rusqlite]
+version = "=0.24.2"
+features = ["blob", "serde_json", "i128_blob", "bundled", "trace"]
+
 [dependencies.serde_json]
 version = "1.0"
 features = ["arbitrary_precision", "unbounded_depth"]
diff --git a/stacks-signer/src/client/mod.rs b/stacks-signer/src/client/mod.rs
index 8f458811ff..8e4302904c 100644
--- a/stacks-signer/src/client/mod.rs
+++ b/stacks-signer/src/client/mod.rs
@@ -533,6 +533,7 @@ pub(crate) mod tests {
             nonce_timeout: config.nonce_timeout,
             sign_timeout: config.sign_timeout,
             tx_fee_ustx: config.tx_fee_ustx,
+            db_path: config.db_path.clone(),
         }
     }
 }
diff --git a/stacks-signer/src/config.rs b/stacks-signer/src/config.rs
index 2897bfdf0b..38337a7ac1 100644
--- a/stacks-signer/src/config.rs
+++ b/stacks-signer/src/config.rs
@@ -163,6 +163,8 @@ pub struct SignerConfig {
     pub sign_timeout: Option<Duration>,
     /// the STX tx fee to use in uSTX
     pub tx_fee_ustx: u64,
+    /// The path to the signer's database file
+    pub db_path: Option<PathBuf>,
 }
 
 /// The parsed configuration for the signer
@@ -196,6 +198,8 @@ pub struct GlobalConfig {
     pub tx_fee_ustx: u64,
     /// the authorization password for the block proposal endpoint
     pub auth_password: String,
+    /// The path to the signer's database file
+    pub db_path: Option<PathBuf>,
 }
 
 /// Internal struct for loading up the config file
@@ -226,6 +230,8 @@ struct RawConfigFile {
     pub tx_fee_ustx: Option<u64>,
     /// The authorization password for the block proposal endpoint
     pub auth_password: String,
+    /// The path to the signer's database file
+    pub db_path: Option<String>,
 }
 
 impl RawConfigFile {
@@ -302,6 +308,11 @@ impl TryFrom<RawConfigFile> for GlobalConfig {
         let dkg_private_timeout = raw_data.dkg_private_timeout_ms.map(Duration::from_millis);
         let nonce_timeout = raw_data.nonce_timeout_ms.map(Duration::from_millis);
         let sign_timeout = raw_data.sign_timeout_ms.map(Duration::from_millis);
+        let db_path = if let Some(db_path) = raw_data.db_path {
+            Some(PathBuf::from(db_path))
+        } else {
+            None
+        };
         Ok(Self {
             node_host: raw_data.node_host,
             endpoint,
@@ -317,6 +328,7 @@ impl TryFrom<RawConfigFile> for GlobalConfig {
             sign_timeout,
             tx_fee_ustx: raw_data.tx_fee_ustx.unwrap_or(TX_FEE_USTX),
             auth_password: raw_data.auth_password,
+            db_path,
         })
     }
 }
diff --git a/stacks-signer/src/lib.rs b/stacks-signer/src/lib.rs
index f3438e8bbc..9dcd0a069f 100644
--- a/stacks-signer/src/lib.rs
+++ b/stacks-signer/src/lib.rs
@@ -32,3 +32,5 @@ pub mod coordinator;
 pub mod runloop;
 /// The signer module for processing events
 pub mod signer;
+/// The state module for the signer
+pub mod signerdb;
diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index ef5ffacdc3..1ef9f5c537 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -224,6 +224,7 @@ impl RunLoop {
             nonce_timeout: self.config.nonce_timeout,
             sign_timeout: self.config.sign_timeout,
             tx_fee_ustx: self.config.tx_fee_ustx,
+            db_path: self.config.db_path.clone(),
         })
     }
 
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index 59962e5ae5..9ec89c9819 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -14,6 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 use std::collections::VecDeque;
+use std::path::PathBuf;
 use std::sync::mpsc::Sender;
 use std::time::Instant;
 
@@ -22,8 +23,9 @@ use blockstack_lib::chainstate::nakamoto::{NakamotoBlock, NakamotoBlockVote};
 use blockstack_lib::chainstate::stacks::boot::SIGNERS_VOTING_FUNCTION_NAME;
 use blockstack_lib::chainstate::stacks::StacksTransaction;
 use blockstack_lib::net::api::postblock_proposal::BlockValidateResponse;
-use hashbrown::{HashMap, HashSet};
+use hashbrown::HashSet;
 use libsigner::{BlockRejection, BlockResponse, RejectCode, SignerEvent, SignerMessage};
+use serde_derive::{Deserialize, Serialize};
 use slog::{slog_debug, slog_error, slog_info, slog_warn};
 use stacks_common::codec::{read_next, StacksMessageCodec};
 use stacks_common::types::chainstate::StacksAddress;
@@ -45,6 +47,7 @@ use wsts::v2;
 use crate::client::{retry_with_exponential_backoff, ClientError, StackerDB, StacksClient};
 use crate::config::SignerConfig;
 use crate::coordinator::CoordinatorSelector;
+use crate::signerdb::SignerDb;
 
 /// The signer StackerDB slot ID, purposefully wrapped to prevent conflation with SignerID
 #[derive(Debug, Clone, PartialEq, Eq, Hash, Copy, PartialOrd, Ord)]
@@ -57,11 +60,12 @@ impl std::fmt::Display for SignerSlotID {
 }
 
 /// Additional Info about a proposed block
+#[derive(Serialize, Deserialize, Debug, PartialEq)]
 pub struct BlockInfo {
     /// The block we are considering
-    block: NakamotoBlock,
+    pub block: NakamotoBlock,
     /// Our vote on the block if we have one yet
-    vote: Option<NakamotoBlockVote>,
+    pub vote: Option<NakamotoBlockVote>,
     /// Whether the block contents are valid
     valid: Option<bool>,
     /// The associated packet nonce request if we have one
@@ -92,6 +96,11 @@ impl BlockInfo {
             signed_over: true,
         }
     }
+
+    /// Return the block's signer signature hash
+    pub fn signer_signature_hash(&self) -> Sha512Trunc256Sum {
+        self.block.header.signer_signature_hash()
+    }
 }
 
 /// Which signer operation to perform
@@ -127,9 +136,6 @@ pub struct Signer {
     pub signing_round: WSTSSigner<v2::Signer>,
     /// the state of the signer
     pub state: State,
-    /// Observed blocks that we have seen so far
-    // TODO: cleanup storage and garbage collect this stuff
-    pub blocks: HashMap<Sha512Trunc256Sum, BlockInfo>,
     /// Received Commands that need to be processed
     pub commands: VecDeque<Command>,
     /// The stackerdb client
@@ -154,6 +160,10 @@ pub struct Signer {
     pub coordinator_selector: CoordinatorSelector,
     /// The approved key registered to the contract
     pub approved_aggregate_public_key: Option<Point>,
+    /// Signer DB path
+    pub db_path: Option<PathBuf>,
+    /// SignerDB for state management
+    pub signer_db: SignerDb,
 }
 
 impl From<SignerConfig> for Signer {
@@ -200,12 +210,12 @@ impl From<SignerConfig> for Signer {
             signer_config.signer_id,
             coordinator_selector.get_coordinator().0
         );
-
+        let signer_db =
+            SignerDb::new(&signer_config.db_path).expect("Failed to connect to signer Db");
         Self {
             coordinator,
             signing_round,
             state: State::Idle,
-            blocks: HashMap::new(),
             commands: VecDeque::new(),
             stackerdb,
             mainnet: signer_config.mainnet,
@@ -222,6 +232,8 @@ impl From<SignerConfig> for Signer {
             tx_fee_ustx: signer_config.tx_fee_ustx,
             coordinator_selector,
             approved_aggregate_public_key: None,
+            db_path: signer_config.db_path.clone(),
+            signer_db,
         }
     }
 }
@@ -287,10 +299,11 @@ impl Signer {
                     return;
                 }
                 let signer_signature_hash = block.header.signer_signature_hash();
-                let block_info = self
-                    .blocks
-                    .entry(signer_signature_hash)
-                    .or_insert_with(|| BlockInfo::new(block.clone()));
+                let mut block_info = self
+                    .signer_db
+                    .block_lookup(&signer_signature_hash)
+                    .unwrap_or_else(|_| Some(BlockInfo::new(block.clone())))
+                    .unwrap_or_else(|| BlockInfo::new(block.clone()));
                 if block_info.signed_over {
                     debug!("Signer #{}: Received a sign command for a block we are already signing over. Ignore it.", self.signer_id);
                     return;
@@ -309,6 +322,11 @@ impl Signer {
                         let ack = self.stackerdb.send_message_with_retry(msg.into());
                         debug!("Signer #{}: ACK: {ack:?}", self.signer_id);
                         block_info.signed_over = true;
+                        self.signer_db
+                            .insert_block(&block_info)
+                            .unwrap_or_else(|e| {
+                                error!("Failed to insert block in DB: {e:?}");
+                            });
                     }
                     Err(e) => {
                         error!(
@@ -361,34 +379,48 @@ impl Signer {
         block_validate_response: &BlockValidateResponse,
         res: Sender<Vec<OperationResult>>,
     ) {
-        let block_info = match block_validate_response {
+        let mut block_info = match block_validate_response {
             BlockValidateResponse::Ok(block_validate_ok) => {
                 let signer_signature_hash = block_validate_ok.signer_signature_hash;
                 // For mutability reasons, we need to take the block_info out of the map and add it back after processing
-                let Some(mut block_info) = self.blocks.remove(&signer_signature_hash) else {
-                    // We have not seen this block before. Why are we getting a response for it?
-                    debug!("Signer #{}: Received a block validate response for a block we have not seen before. Ignoring...", self.signer_id);
-                    return;
+                let mut block_info = match self.signer_db.block_lookup(&signer_signature_hash) {
+                    Ok(Some(block_info)) => block_info,
+                    Ok(None) => {
+                        // We have not seen this block before. Why are we getting a response for it?
+                        debug!("Received a block validate response for a block we have not seen before. Ignoring...");
+                        return;
+                    }
+                    Err(e) => {
+                        error!("Failed to lookup block in signer db: {:?}", e);
+                        return;
+                    }
                 };
                 let is_valid = self.verify_block_transactions(stacks_client, &block_info.block);
                 block_info.valid = Some(is_valid);
+                self.signer_db
+                    .insert_block(&block_info)
+                    .expect("Failed to insert block in DB");
                 info!(
                     "Signer #{}: Treating block validation for block {} as valid: {:?}",
                     self.signer_id,
                     &block_info.block.block_id(),
                     block_info.valid
                 );
-                // Add the block info back to the map
-                self.blocks
-                    .entry(signer_signature_hash)
-                    .or_insert(block_info)
+                block_info
             }
             BlockValidateResponse::Reject(block_validate_reject) => {
                 let signer_signature_hash = block_validate_reject.signer_signature_hash;
-                let Some(block_info) = self.blocks.get_mut(&signer_signature_hash) else {
-                    // We have not seen this block before. Why are we getting a response for it?
-                    debug!("Signer #{}: Received a block validate response for a block we have not seen before. Ignoring...", self.signer_id);
-                    return;
+                let mut block_info = match self.signer_db.block_lookup(&signer_signature_hash) {
+                    Ok(Some(block_info)) => block_info,
+                    Ok(None) => {
+                        // We have not seen this block before. Why are we getting a response for it?
+                        debug!("Received a block validate response for a block we have not seen before. Ignoring...");
+                        return;
+                    }
+                    Err(e) => {
+                        error!("Failed to lookup block in signer db: {:?}", e);
+                        return;
+                    }
                 };
                 block_info.valid = Some(false);
                 // Submit a rejection response to the .signers contract for miners
@@ -409,7 +441,7 @@ impl Signer {
         if let Some(mut nonce_request) = block_info.nonce_request.take() {
             debug!("Signer #{}: Received a block validate response from the stacks node for a block we already received a nonce request for. Responding to the nonce request...", self.signer_id);
             // We have received validation from the stacks node. Determine our vote and update the request message
-            Self::determine_vote(self.signer_id, block_info, &mut nonce_request);
+            Self::determine_vote(self.signer_id, &mut block_info, &mut nonce_request);
             // Send the nonce request through with our vote
             let packet = Packet {
                 msg: Message::NonceRequest(nonce_request),
@@ -443,6 +475,9 @@ impl Signer {
                 );
             }
         }
+        self.signer_db
+            .insert_block(&block_info)
+            .expect("Failed to insert block in DB");
     }
 
     /// Handle signer messages submitted to signers stackerdb
@@ -470,10 +505,11 @@ impl Signer {
     fn handle_proposed_blocks(&mut self, stacks_client: &StacksClient, blocks: &[NakamotoBlock]) {
         for block in blocks {
             // Store the block in our cache
-            self.blocks.insert(
-                block.header.signer_signature_hash(),
-                BlockInfo::new(block.clone()),
-            );
+            self.signer_db
+                .insert_block(&BlockInfo::new(block.clone()))
+                .unwrap_or_else(|e| {
+                    error!("Failed to insert block in DB: {e:?}");
+                });
             // Submit the block for validation
             stacks_client
                 .submit_block_for_validation(block.clone())
@@ -544,10 +580,12 @@ impl Signer {
             );
             return false;
         };
+
         match self
-            .blocks
-            .get(&block_vote.signer_signature_hash)
-            .map(|block_info| &block_info.vote)
+            .signer_db
+            .block_lookup(&block_vote.signer_signature_hash)
+            .expect("Failed to connect to signer DB")
+            .map(|b| b.vote)
         {
             Some(Some(vote)) => {
                 // Overwrite with our agreed upon value in case another message won majority or the coordinator is trying to cheat...
@@ -594,25 +632,28 @@ impl Signer {
             return false;
         };
         let signer_signature_hash = block.header.signer_signature_hash();
-        let Some(block_info) = self.blocks.get_mut(&signer_signature_hash) else {
-            // We have not seen this block before. Cache it. Send a RPC to the stacks node to validate it.
-            debug!("Signer #{}: We have received a block sign request for a block we have not seen before. Cache the nonce request and submit the block for validation...", self.signer_id);
-            // We need to update our state to OperationInProgress so we can respond to the nonce request from this signer once we get our validation back
-            self.update_operation();
-            // Store the block in our cache
-            self.blocks.insert(
-                signer_signature_hash,
-                BlockInfo::new_with_request(block.clone(), nonce_request.clone()),
-            );
-            stacks_client
-                .submit_block_for_validation(block)
-                .unwrap_or_else(|e| {
-                    warn!(
-                        "Signer #{}: Failed to submit block for validation: {e:?}",
-                        self.signer_id
-                    );
-                });
-            return false;
+        let mut block_info = match self
+            .signer_db
+            .block_lookup(&signer_signature_hash)
+            .expect("Failed to connect to signer DB")
+        {
+            Some(block_info) => block_info,
+            None => {
+                debug!("We have received a block sign request for a block we have not seen before. Cache the nonce request and submit the block for validation...");
+                let block_info = BlockInfo::new_with_request(block.clone(), nonce_request.clone());
+                self.signer_db
+                    .insert_block(&block_info)
+                    .expect("Failed to insert block in DB");
+                stacks_client
+                    .submit_block_for_validation(block)
+                    .unwrap_or_else(|e| {
+                        warn!(
+                            "Signer #{}: Failed to submit block for validation: {e:?}",
+                            self.signer_id
+                        );
+                    });
+                return false;
+            }
         };
 
         if block_info.valid.is_none() {
@@ -622,7 +663,10 @@ impl Signer {
             return false;
         }
 
-        Self::determine_vote(self.signer_id, block_info, nonce_request);
+        Self::determine_vote(self.signer_id, &mut block_info, nonce_request);
+        self.signer_db
+            .insert_block(&block_info)
+            .expect("Failed to insert block in DB");
         true
     }
 
@@ -999,7 +1043,9 @@ impl Signer {
         };
 
         // TODO: proper garbage collection...This is currently our only cleanup of blocks
-        self.blocks.remove(&block_vote.signer_signature_hash);
+        self.signer_db
+            .remove_block(&block_vote.signer_signature_hash)
+            .expect("Failed to remove block from to signer DB");
 
         let block_submission = if block_vote.rejected {
             // We signed a rejection message. Return a rejection message
@@ -1030,13 +1076,23 @@ impl Signer {
 
         let block: NakamotoBlock = read_next(&mut &message[..]).ok().unwrap_or({
             // This is not a block so maybe its across its hash
-            let Some(block_vote): Option<NakamotoBlockVote> = read_next(&mut &message[..]).ok() else {
+            let Some(block_vote): Option<NakamotoBlockVote> = read_next(&mut &message[..]).ok()
+            else {
                 // This is not a block vote either. We cannot process this error
-                debug!("Signer #{}: Received a signature error for a non-block. Nothing to broadcast.", self.signer_id);
+                debug!(
+                    "Signer #{}: Received a signature error for a non-block. Nothing to broadcast.",
+                    self.signer_id
+                );
                 return;
             };
-            let Some(block_info) = self.blocks.remove(&block_vote.signer_signature_hash) else {
-                debug!("Signer #{}: Received a signature result for a block we have not seen before. Ignoring...", self.signer_id);
+            let Some(block_info) = self
+                .signer_db
+                .block_lookup(&block_vote.signer_signature_hash)
+                .expect("Failed to connect to signer DB")
+            else {
+                debug!(
+                    "Received a signature result for a block we have not seen before. Ignoring..."
+                );
                 return;
             };
             block_info.block
diff --git a/stacks-signer/src/signerdb.rs b/stacks-signer/src/signerdb.rs
new file mode 100644
index 0000000000..be1aae2a5d
--- /dev/null
+++ b/stacks-signer/src/signerdb.rs
@@ -0,0 +1,280 @@
+// Copyright (C) 2013-2020 Blockstack PBC, a public benefit corporation
+// Copyright (C) 2020 Stacks Open Internet Foundation
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+use std::path::PathBuf;
+
+use blockstack_lib::util_lib::db::{
+    query_row, sqlite_open, table_exists, tx_begin_immediate, Error as DBError,
+};
+use rusqlite::{
+    Connection, Error as SqliteError, OpenFlags, ToSql, Transaction as SqlTransaction, NO_PARAMS,
+};
+use stacks_common::util::hash::Sha512Trunc256Sum;
+
+use crate::signer::BlockInfo;
+
+/// This struct manages a SQLite database connection
+/// for the signer.
+#[derive(Debug)]
+pub struct SignerDb {
+    /// The SQLite database path
+    pub db_path: Option<PathBuf>,
+    // /// Connection to the DB
+    // /// TODO: Figure out how to manage this connection
+    // connection: Option<Connection>,
+}
+
+const CREATE_BLOCKS_TABLE: &'static str = "
+CREATE TABLE IF NOT EXISTS blocks (
+    signer_signature_hash TEXT PRIMARY KEY,
+    block_info TEXT NOT NULL
+)";
+
+impl SignerDb {
+    /// Create a new `SignerState` instance.
+    /// This will create a new SQLite database at the given path
+    /// if one doesn't exist.
+    pub fn new(db_path: &Option<PathBuf>) -> Result<SignerDb, DBError> {
+        let signer_db = SignerDb {
+            db_path: db_path.clone(),
+        };
+        let mut connection = signer_db.get_connection()?;
+        connection.pragma_update(None, "journal_mode", &"WAL".to_sql().unwrap())?;
+        connection.pragma_update(None, "synchronous", &"NORMAL".to_sql().unwrap())?;
+        let tx = tx_begin_immediate(&mut connection).expect("Unable to begin tx");
+        Self::instantiate_db(&tx).expect("Could not instantiate SignerDB");
+        tx.commit().expect("Unable to commit tx");
+
+        let tx = tx_begin_immediate(&mut connection).expect("Unable to begin tx");
+        Self::instantiate_db(&tx).expect("Could not instantiate SignerDB");
+        tx.commit().expect("Unable to commit tx");
+        Ok(SignerDb {
+            db_path: db_path.clone(),
+        })
+    }
+
+    fn db_already_instantiated(db: &SqlTransaction, table_name: &str) -> Result<bool, SqliteError> {
+        table_exists(db, table_name)
+    }
+
+    fn instantiate_db(db: &SqlTransaction) -> Result<(), SqliteError> {
+        if !Self::db_already_instantiated(db, "blocks")? {
+            db.execute(CREATE_BLOCKS_TABLE, NO_PARAMS)?;
+        }
+
+        Ok(())
+    }
+
+    fn get_connection(&self) -> Result<Connection, DBError> {
+        let db_path = self.db_path.clone().unwrap_or(PathBuf::from(":memory:"));
+        if &db_path == &PathBuf::from(":memory:") {
+            return Ok(self.memory_conn());
+        }
+        sqlite_open(
+            &db_path,
+            OpenFlags::SQLITE_OPEN_READ_WRITE | OpenFlags::SQLITE_OPEN_CREATE,
+            false,
+        )
+        .map_err(|e| DBError::from(e))
+    }
+
+    /// Fetch a block from the database using the block's
+    /// `signer_signature_hash`
+    pub fn block_lookup(&self, hash: &Sha512Trunc256Sum) -> Result<Option<BlockInfo>, DBError> {
+        let conn = self.get_connection()?;
+        let result: Option<String> = query_row(
+            &conn,
+            "SELECT block_info FROM blocks WHERE signer_signature_hash = ?",
+            &[format!("{}", hash)],
+        )?;
+        if let Some(block_info) = result {
+            let block_info: BlockInfo =
+                serde_json::from_str(&block_info).map_err(|e| DBError::SerializationError(e))?;
+            Ok(Some(block_info))
+        } else {
+            Ok(None)
+        }
+    }
+
+    /// Insert a block into the database.
+    /// `hash` is the `signer_signature_hash` of the block.
+    pub fn insert_block(&mut self, block_info: &BlockInfo) -> Result<(), DBError> {
+        let mut conn = self.get_connection()?;
+        let block_json =
+            serde_json::to_string(&block_info).expect("Unable to serialize block info");
+        let hash = &block_info.signer_signature_hash();
+        let tx = tx_begin_immediate(&mut conn).expect("Unable to begin tx");
+        tx.execute(
+            "INSERT OR REPLACE INTO blocks (signer_signature_hash, block_info) VALUES (?1, ?2)",
+            &[format!("{}", hash), block_json],
+        )
+        .map_err(|e| {
+            return DBError::Other(format!(
+                "Unable to insert block into db: {:?}",
+                e.to_string()
+            ));
+        })?;
+        tx.commit().expect("Unable to commit tx");
+        Ok(())
+    }
+
+    /// Remove a block
+    pub fn remove_block(&mut self, hash: &Sha512Trunc256Sum) -> Result<(), DBError> {
+        let mut conn = self.get_connection()?;
+        let tx = tx_begin_immediate(&mut conn).expect("Unable to begin tx");
+        tx.execute(
+            "DELETE FROM blocks WHERE signer_signature_hash = ?",
+            &[format!("{}", hash)],
+        )
+        .map_err(|e| DBError::from(e))?;
+        tx.commit().map_err(|e| DBError::from(e))?;
+        Ok(())
+    }
+
+    /// Generate a new memory-backed DB
+    pub fn memory_db() -> SignerDb {
+        SignerDb {
+            db_path: Some(PathBuf::from(":memory:")),
+        }
+    }
+
+    /// Generate a new memory-backed DB connection
+    pub fn memory_conn(&self) -> Connection {
+        let db = Connection::open_in_memory().expect("Could not create in-memory db");
+        db
+    }
+}
+
+#[cfg(test)]
+pub fn test_signer_db(db_path: &str) -> SignerDb {
+    use std::fs;
+
+    if fs::metadata(&db_path).is_ok() {
+        fs::remove_file(&db_path).unwrap();
+    }
+    SignerDb::new(&Some(db_path.into())).expect("Failed to create signer db")
+}
+
+#[cfg(test)]
+mod tests {
+    use blockstack_lib::chainstate::{
+        nakamoto::{NakamotoBlock, NakamotoBlockHeader, NakamotoBlockVote},
+        stacks::ThresholdSignature,
+    };
+    use stacks_common::{
+        bitvec::BitVec,
+        types::chainstate::{ConsensusHash, StacksBlockId, TrieHash},
+        util::secp256k1::MessageSignature,
+    };
+
+    use super::*;
+    use std::fs;
+
+    fn _wipe_db(db_path: &PathBuf) {
+        if fs::metadata(db_path).is_ok() {
+            fs::remove_file(db_path).unwrap();
+        }
+    }
+
+    fn create_block_override(
+        overrides: impl FnOnce(&mut NakamotoBlock),
+    ) -> (BlockInfo, NakamotoBlock) {
+        let header = NakamotoBlockHeader {
+            version: 1,
+            chain_length: 2,
+            burn_spent: 3,
+            consensus_hash: ConsensusHash([0x04; 20]),
+            parent_block_id: StacksBlockId([0x05; 32]),
+            tx_merkle_root: Sha512Trunc256Sum([0x06; 32]),
+            state_index_root: TrieHash([0x07; 32]),
+            miner_signature: MessageSignature::empty(),
+            signer_signature: ThresholdSignature::empty(),
+            signer_bitvec: BitVec::zeros(1).unwrap(),
+        };
+        let mut block = NakamotoBlock {
+            header,
+            txs: vec![],
+        };
+        overrides(&mut block);
+        (BlockInfo::new(block.clone()), block)
+    }
+
+    fn create_block() -> (BlockInfo, NakamotoBlock) {
+        create_block_override(|_| {})
+    }
+
+    fn tmp_db_path() -> Option<PathBuf> {
+        Some(format!("/tmp/stacks-signer-test-{}.sqlite", rand::random::<u64>()).into())
+    }
+
+    #[test]
+    fn test_basic_signer_db() {
+        let db_path = tmp_db_path();
+        let mut db = SignerDb::new(&db_path).expect("Failed to create signer db");
+        let (block_info, block) = create_block();
+        db.insert_block(&block_info)
+            .expect("Unable to insert block into db");
+
+        let block_info = db
+            .block_lookup(&block.header.signer_signature_hash())
+            .unwrap()
+            .expect("Unable to get block from db");
+
+        assert_eq!(BlockInfo::new(block.clone()), block_info);
+    }
+
+    #[test]
+    fn test_update_block() {
+        let db_path = tmp_db_path();
+        let mut db = SignerDb::new(&db_path).expect("Failed to create signer db");
+        let (block_info, block) = create_block();
+        db.insert_block(&block_info)
+            .expect("Unable to insert block into db");
+
+        let block_info = db
+            .block_lookup(&block.header.signer_signature_hash())
+            .unwrap()
+            .expect("Unable to get block from db");
+
+        assert_eq!(BlockInfo::new(block.clone()), block_info);
+
+        let old_block_info = block_info;
+        let old_block = block;
+
+        let (mut block_info, block) = create_block_override(|b| {
+            b.header.signer_signature = old_block.header.signer_signature.clone();
+        });
+        assert_eq!(
+            block_info.signer_signature_hash(),
+            old_block_info.signer_signature_hash()
+        );
+        let vote = NakamotoBlockVote {
+            signer_signature_hash: Sha512Trunc256Sum([0x01; 32]),
+            rejected: false,
+        };
+        block_info.vote = Some(vote.clone());
+        db.insert_block(&block_info)
+            .expect("Unable to insert block into db");
+
+        let block_info = db
+            .block_lookup(&block.header.signer_signature_hash())
+            .unwrap()
+            .expect("Unable to get block from db");
+
+        assert_ne!(old_block_info, block_info);
+        assert_eq!(block_info.vote, Some(vote));
+    }
+}
diff --git a/stacks-signer/src/tests/conf/signer-0.toml b/stacks-signer/src/tests/conf/signer-0.toml
index 449392c2e3..32183e0e79 100644
--- a/stacks-signer/src/tests/conf/signer-0.toml
+++ b/stacks-signer/src/tests/conf/signer-0.toml
@@ -3,3 +3,4 @@ node_host = "127.0.0.1:20443"
 endpoint = "localhost:30000"
 network = "testnet"
 auth_password = "12345"
+db_path = ":memory:"

From 644cc0d29f783650ca456fd57a74d6a8261f222d Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Mon, 5 Feb 2024 14:57:18 -0800
Subject: [PATCH 1033/1166] feat: add error code to StackerDBChunkAckData

---
 libstackerdb/src/libstackerdb.rs            |  2 +
 stacks-signer/src/client/stackerdb.rs       | 33 ++++++++------
 stackslib/src/net/api/poststackerdbchunk.rs | 48 +++++++++++++--------
 3 files changed, 52 insertions(+), 31 deletions(-)

diff --git a/libstackerdb/src/libstackerdb.rs b/libstackerdb/src/libstackerdb.rs
index df74075f64..0a04015e7c 100644
--- a/libstackerdb/src/libstackerdb.rs
+++ b/libstackerdb/src/libstackerdb.rs
@@ -104,6 +104,8 @@ pub struct StackerDBChunkAckData {
     pub reason: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub metadata: Option<SlotMetadata>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub code: Option<u32>,
 }
 
 impl SlotMetadata {
diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index 78275f56cf..ab9c1509ea 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -16,6 +16,7 @@
 //
 use blockstack_lib::chainstate::nakamoto::signer_set::NakamotoSigners;
 use blockstack_lib::chainstate::stacks::StacksTransaction;
+use blockstack_lib::net::api::poststackerdbchunk::StackerDBErrorCodes;
 use blockstack_lib::util_lib::boot::boot_code_addr;
 use clarity::vm::types::QualifiedContractIdentifier;
 use clarity::vm::ContractName;
@@ -161,20 +162,25 @@ impl StackerDB {
             } else {
                 warn!("Chunk rejected by stackerdb: {chunk_ack:?}");
             }
-            if let Some(reason) = chunk_ack.reason {
-                // TODO: fix this jankiness. Update stackerdb to use an error code mapping instead of just a string
-                // See: https://github.com/stacks-network/stacks-blockchain/issues/3917
-                if reason.contains("Data for this slot and version already exist") {
-                    warn!("Failed to send message to stackerdb due to wrong version number {}. Incrementing and retrying...", slot_version);
-                    if let Some(versions) = self.slot_versions.get_mut(&msg_id) {
-                        // NOTE: per the above, this is always executed
-                        versions.insert(slot_id, slot_version.saturating_add(1));
-                    } else {
-                        return Err(ClientError::NotConnected);
+            if let Some(code) = chunk_ack.code {
+                match StackerDBErrorCodes::from_code(code) {
+                    Some(StackerDBErrorCodes::DataAlreadyExists) => {
+                        warn!("Failed to send message to stackerdb due to wrong version number {}. Incrementing and retrying...", slot_version);
+                        if let Some(versions) = self.slot_versions.get_mut(&msg_id) {
+                            // NOTE: per the above, this is always executed
+                            versions.insert(slot_id, slot_version.saturating_add(1));
+                        } else {
+                            return Err(ClientError::NotConnected);
+                        }
+                    }
+                    _ => {
+                        warn!("Failed to send message to stackerdb: {:?}", chunk_ack);
+                        return Err(ClientError::PutChunkRejected(
+                            chunk_ack
+                                .reason
+                                .unwrap_or_else(|| "No reason given".to_string()),
+                        ));
                     }
-                } else {
-                    warn!("Failed to send message to stackerdb: {}", reason);
-                    return Err(ClientError::PutChunkRejected(reason));
                 }
             }
         }
@@ -343,6 +349,7 @@ mod tests {
             accepted: true,
             reason: None,
             metadata: None,
+            code: None,
         };
         let mock_server = mock_server_from_config(&config);
         let h = spawn(move || stackerdb.send_message_with_retry(signer_message));
diff --git a/stackslib/src/net/api/poststackerdbchunk.rs b/stackslib/src/net/api/poststackerdbchunk.rs
index d7901534e0..195c1cb96f 100644
--- a/stackslib/src/net/api/poststackerdbchunk.rs
+++ b/stackslib/src/net/api/poststackerdbchunk.rs
@@ -145,6 +145,14 @@ impl StackerDBErrorCodes {
             "reason": self.reason()
         })
     }
+
+    pub fn from_code(code: u32) -> Option<Self> {
+        match code {
+            0 => Some(Self::DataAlreadyExists),
+            1 => Some(Self::NoSuchSlot),
+            _ => None,
+        }
+    }
 }
 
 impl RPCRequestHandler for RPCPostStackerDBChunkRequestHandler {
@@ -219,31 +227,34 @@ impl RPCRequestHandler for RPCPostStackerDBChunkRequestHandler {
                             }
                         };
 
-                    let (reason, slot_metadata_opt) = if let Some(slot_metadata) = slot_metadata_opt
-                    {
-                        let code = if let NetError::BadSlotSigner(..) = e {
-                            StackerDBErrorCodes::BadSigner
+                    let (reason, slot_metadata_opt, err_code) =
+                        if let Some(slot_metadata) = slot_metadata_opt {
+                            let code = if let NetError::BadSlotSigner(..) = e {
+                                StackerDBErrorCodes::BadSigner
+                            } else {
+                                StackerDBErrorCodes::DataAlreadyExists
+                            };
+
+                            (
+                                serde_json::to_string(&code.clone().into_json())
+                                    .unwrap_or("(unable to encode JSON)".to_string()),
+                                Some(slot_metadata),
+                                code,
+                            )
                         } else {
-                            StackerDBErrorCodes::DataAlreadyExists
+                            (
+                                serde_json::to_string(&StackerDBErrorCodes::NoSuchSlot.into_json())
+                                    .unwrap_or("(unable to encode JSON)".to_string()),
+                                None,
+                                StackerDBErrorCodes::DataAlreadyExists,
+                            )
                         };
 
-                        (
-                            serde_json::to_string(&code.into_json())
-                                .unwrap_or("(unable to encode JSON)".to_string()),
-                            Some(slot_metadata),
-                        )
-                    } else {
-                        (
-                            serde_json::to_string(&StackerDBErrorCodes::NoSuchSlot.into_json())
-                                .unwrap_or("(unable to encode JSON)".to_string()),
-                            None,
-                        )
-                    };
-
                     let ack = StackerDBChunkAckData {
                         accepted: false,
                         reason: Some(reason),
                         metadata: slot_metadata_opt,
+                        code: Some(err_code.code()),
                     };
                     return Ok(ack);
                 }
@@ -281,6 +292,7 @@ impl RPCRequestHandler for RPCPostStackerDBChunkRequestHandler {
                     accepted: true,
                     reason: None,
                     metadata: Some(slot_metadata),
+                    code: None,
                 };
 
                 return Ok(ack);

From fdba3e96947481be21fee0e73b9f9bb724a9e559 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?M=C3=A5rten=20Blankfors?= <marten@blankfors.se>
Date: Wed, 6 Mar 2024 10:48:45 +0100
Subject: [PATCH 1034/1166] fix: Get rid of some unnecessary trait bounds

Note: It's often tempting to put trait bounds on structs but in most
scenarios the general rule of thumb should be to use trait bounds
in impl blocks but let structs just declare data structures and
not behavior.

For further reading: https://stackoverflow.com/questions/49229332/should-trait-bounds-be-duplicated-in-struct-and-impl
---
 libsigner/src/runloop.rs | 10 +---------
 1 file changed, 1 insertion(+), 9 deletions(-)

diff --git a/libsigner/src/runloop.rs b/libsigner/src/runloop.rs
index 32b0326008..54dd58e175 100644
--- a/libsigner/src/runloop.rs
+++ b/libsigner/src/runloop.rs
@@ -93,12 +93,7 @@ pub trait SignerRunLoop<R: Send, CMD: Send> {
 }
 
 /// The top-level signer implementation
-pub struct Signer<
-    CMD: Send,
-    R: Send,
-    SL: SignerRunLoop<R, CMD> + Send + Sync,
-    EV: EventReceiver + Send,
-> {
+pub struct Signer<CMD, R, SL, EV> {
     /// the runloop itself
     signer_loop: Option<SL>,
     /// the event receiver to use
@@ -107,8 +102,6 @@ pub struct Signer<
     command_receiver: Option<Receiver<CMD>>,
     /// the result sender to use
     result_sender: Option<Sender<R>>,
-    /// marker to permit the R type
-    _phantom: PhantomData<R>,
 }
 
 /// The running signer implementation
@@ -215,7 +208,6 @@ impl<
             event_receiver: Some(event_receiver),
             command_receiver: Some(command_receiver),
             result_sender: Some(result_sender),
-            _phantom: PhantomData,
         }
     }
 

From 6d59036f5e8acb1cde3fbbabb54b490076718f5f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?M=C3=A5rten=20Blankfors?= <marten@blankfors.se>
Date: Wed, 6 Mar 2024 11:11:55 +0100
Subject: [PATCH 1035/1166] feat: Relax trait bound requirements of creating
 and spawning signers

---
 libsigner/src/runloop.rs      | 16 +++++++++-------
 stacks-signer/src/signerdb.rs |  6 ++++--
 2 files changed, 13 insertions(+), 9 deletions(-)

diff --git a/libsigner/src/runloop.rs b/libsigner/src/runloop.rs
index 54dd58e175..0b7eb2dbcf 100644
--- a/libsigner/src/runloop.rs
+++ b/libsigner/src/runloop.rs
@@ -189,13 +189,7 @@ pub fn set_runloop_signal_handler<ST: EventStopSignaler + Send + 'static>(mut st
     }).expect("FATAL: failed to set signal handler");
 }
 
-impl<
-        CMD: Send + 'static,
-        R: Send + 'static,
-        SL: SignerRunLoop<R, CMD> + Send + Sync + 'static,
-        EV: EventReceiver + Send + 'static,
-    > Signer<CMD, R, SL, EV>
-{
+impl<CMD, R, SL, EV> Signer<CMD, R, SL, EV> {
     /// Create a new signer with the given runloop and event receiver.
     pub fn new(
         runloop: SL,
@@ -210,7 +204,15 @@ impl<
             result_sender: Some(result_sender),
         }
     }
+}
 
+impl<
+        CMD: Send + 'static,
+        R: Send + 'static,
+        SL: SignerRunLoop<R, CMD> + Send + 'static,
+        EV: EventReceiver + Send + 'static,
+    > Signer<CMD, R, SL, EV>
+{
     /// This is a helper function to spawn both the runloop and event receiver in their own
     /// threads.  Advanced signers may not need this method, and instead opt to run the receiver
     /// and runloop directly.  However, this method is present to help signer developers to get
diff --git a/stacks-signer/src/signerdb.rs b/stacks-signer/src/signerdb.rs
index be1aae2a5d..269fb327b0 100644
--- a/stacks-signer/src/signerdb.rs
+++ b/stacks-signer/src/signerdb.rs
@@ -33,8 +33,7 @@ pub struct SignerDb {
     /// The SQLite database path
     pub db_path: Option<PathBuf>,
     // /// Connection to the DB
-    // /// TODO: Figure out how to manage this connection
-    // connection: Option<Connection>,
+    connection: Option<Connection>,
 }
 
 const CREATE_BLOCKS_TABLE: &'static str = "
@@ -50,6 +49,7 @@ impl SignerDb {
     pub fn new(db_path: &Option<PathBuf>) -> Result<SignerDb, DBError> {
         let signer_db = SignerDb {
             db_path: db_path.clone(),
+            connection: None,
         };
         let mut connection = signer_db.get_connection()?;
         connection.pragma_update(None, "journal_mode", &"WAL".to_sql().unwrap())?;
@@ -63,6 +63,7 @@ impl SignerDb {
         tx.commit().expect("Unable to commit tx");
         Ok(SignerDb {
             db_path: db_path.clone(),
+            connection: None,
         })
     }
 
@@ -148,6 +149,7 @@ impl SignerDb {
     pub fn memory_db() -> SignerDb {
         SignerDb {
             db_path: Some(PathBuf::from(":memory:")),
+            connection: None,
         }
     }
 

From a2afceebdfd7fcae163895caa69c4ef294a6319d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?M=C3=A5rten=20Blankfors?= <marten@blankfors.se>
Date: Wed, 6 Mar 2024 11:39:11 +0100
Subject: [PATCH 1036/1166] feat: Make SignerDB store a rusqlite Connection

---
 stacks-signer/src/signer.rs   |  2 +-
 stacks-signer/src/signerdb.rs | 91 +++++++++++------------------------
 2 files changed, 28 insertions(+), 65 deletions(-)

diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index 9ec89c9819..7ffc509c9b 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -211,7 +211,7 @@ impl From<SignerConfig> for Signer {
             coordinator_selector.get_coordinator().0
         );
         let signer_db =
-            SignerDb::new(&signer_config.db_path).expect("Failed to connect to signer Db");
+            SignerDb::new(signer_config.db_path.clone()).expect("Failed to connect to signer Db");
         Self {
             coordinator,
             signing_round,
diff --git a/stacks-signer/src/signerdb.rs b/stacks-signer/src/signerdb.rs
index 269fb327b0..fdf9b94b5a 100644
--- a/stacks-signer/src/signerdb.rs
+++ b/stacks-signer/src/signerdb.rs
@@ -19,9 +19,7 @@ use std::path::PathBuf;
 use blockstack_lib::util_lib::db::{
     query_row, sqlite_open, table_exists, tx_begin_immediate, Error as DBError,
 };
-use rusqlite::{
-    Connection, Error as SqliteError, OpenFlags, ToSql, Transaction as SqlTransaction, NO_PARAMS,
-};
+use rusqlite::{Connection, Error as SqliteError, OpenFlags, NO_PARAMS};
 use stacks_common::util::hash::Sha512Trunc256Sum;
 
 use crate::signer::BlockInfo;
@@ -30,10 +28,8 @@ use crate::signer::BlockInfo;
 /// for the signer.
 #[derive(Debug)]
 pub struct SignerDb {
-    /// The SQLite database path
-    pub db_path: Option<PathBuf>,
-    // /// Connection to the DB
-    connection: Option<Connection>,
+    /// Connection to the SQLite database
+    db: Connection,
 }
 
 const CREATE_BLOCKS_TABLE: &'static str = "
@@ -46,58 +42,41 @@ impl SignerDb {
     /// Create a new `SignerState` instance.
     /// This will create a new SQLite database at the given path
     /// if one doesn't exist.
-    pub fn new(db_path: &Option<PathBuf>) -> Result<SignerDb, DBError> {
-        let signer_db = SignerDb {
-            db_path: db_path.clone(),
-            connection: None,
-        };
-        let mut connection = signer_db.get_connection()?;
-        connection.pragma_update(None, "journal_mode", &"WAL".to_sql().unwrap())?;
-        connection.pragma_update(None, "synchronous", &"NORMAL".to_sql().unwrap())?;
-        let tx = tx_begin_immediate(&mut connection).expect("Unable to begin tx");
-        Self::instantiate_db(&tx).expect("Could not instantiate SignerDB");
-        tx.commit().expect("Unable to commit tx");
+    pub fn new(db_path: Option<PathBuf>) -> Result<SignerDb, DBError> {
+        let connection = Self::connect(&db_path)?;
 
-        let tx = tx_begin_immediate(&mut connection).expect("Unable to begin tx");
-        Self::instantiate_db(&tx).expect("Could not instantiate SignerDB");
-        tx.commit().expect("Unable to commit tx");
-        Ok(SignerDb {
-            db_path: db_path.clone(),
-            connection: None,
-        })
-    }
+        let signer_db = Self { db: connection };
+
+        signer_db.instantiate_db()?;
 
-    fn db_already_instantiated(db: &SqlTransaction, table_name: &str) -> Result<bool, SqliteError> {
-        table_exists(db, table_name)
+        Ok(signer_db)
     }
 
-    fn instantiate_db(db: &SqlTransaction) -> Result<(), SqliteError> {
-        if !Self::db_already_instantiated(db, "blocks")? {
-            db.execute(CREATE_BLOCKS_TABLE, NO_PARAMS)?;
+    fn instantiate_db(&self) -> Result<(), DBError> {
+        if !table_exists(&self.db, "blocks")? {
+            self.db.execute(CREATE_BLOCKS_TABLE, NO_PARAMS)?;
         }
 
         Ok(())
     }
 
-    fn get_connection(&self) -> Result<Connection, DBError> {
-        let db_path = self.db_path.clone().unwrap_or(PathBuf::from(":memory:"));
-        if &db_path == &PathBuf::from(":memory:") {
-            return Ok(self.memory_conn());
+    fn connect(db_path: &Option<PathBuf>) -> Result<Connection, SqliteError> {
+        if let Some(path) = db_path {
+            sqlite_open(
+                path,
+                OpenFlags::SQLITE_OPEN_READ_WRITE | OpenFlags::SQLITE_OPEN_CREATE,
+                false,
+            )
+        } else {
+            Connection::open_in_memory()
         }
-        sqlite_open(
-            &db_path,
-            OpenFlags::SQLITE_OPEN_READ_WRITE | OpenFlags::SQLITE_OPEN_CREATE,
-            false,
-        )
-        .map_err(|e| DBError::from(e))
     }
 
     /// Fetch a block from the database using the block's
     /// `signer_signature_hash`
     pub fn block_lookup(&self, hash: &Sha512Trunc256Sum) -> Result<Option<BlockInfo>, DBError> {
-        let conn = self.get_connection()?;
         let result: Option<String> = query_row(
-            &conn,
+            &self.db,
             "SELECT block_info FROM blocks WHERE signer_signature_hash = ?",
             &[format!("{}", hash)],
         )?;
@@ -113,11 +92,10 @@ impl SignerDb {
     /// Insert a block into the database.
     /// `hash` is the `signer_signature_hash` of the block.
     pub fn insert_block(&mut self, block_info: &BlockInfo) -> Result<(), DBError> {
-        let mut conn = self.get_connection()?;
         let block_json =
             serde_json::to_string(&block_info).expect("Unable to serialize block info");
         let hash = &block_info.signer_signature_hash();
-        let tx = tx_begin_immediate(&mut conn).expect("Unable to begin tx");
+        let tx = tx_begin_immediate(&mut self.db).expect("Unable to begin tx");
         tx.execute(
             "INSERT OR REPLACE INTO blocks (signer_signature_hash, block_info) VALUES (?1, ?2)",
             &[format!("{}", hash), block_json],
@@ -134,8 +112,7 @@ impl SignerDb {
 
     /// Remove a block
     pub fn remove_block(&mut self, hash: &Sha512Trunc256Sum) -> Result<(), DBError> {
-        let mut conn = self.get_connection()?;
-        let tx = tx_begin_immediate(&mut conn).expect("Unable to begin tx");
+        let tx = tx_begin_immediate(&mut self.db).expect("Unable to begin tx");
         tx.execute(
             "DELETE FROM blocks WHERE signer_signature_hash = ?",
             &[format!("{}", hash)],
@@ -144,20 +121,6 @@ impl SignerDb {
         tx.commit().map_err(|e| DBError::from(e))?;
         Ok(())
     }
-
-    /// Generate a new memory-backed DB
-    pub fn memory_db() -> SignerDb {
-        SignerDb {
-            db_path: Some(PathBuf::from(":memory:")),
-            connection: None,
-        }
-    }
-
-    /// Generate a new memory-backed DB connection
-    pub fn memory_conn(&self) -> Connection {
-        let db = Connection::open_in_memory().expect("Could not create in-memory db");
-        db
-    }
 }
 
 #[cfg(test)]
@@ -167,7 +130,7 @@ pub fn test_signer_db(db_path: &str) -> SignerDb {
     if fs::metadata(&db_path).is_ok() {
         fs::remove_file(&db_path).unwrap();
     }
-    SignerDb::new(&Some(db_path.into())).expect("Failed to create signer db")
+    SignerDb::new(Some(db_path.into())).expect("Failed to create signer db")
 }
 
 #[cfg(test)]
@@ -225,7 +188,7 @@ mod tests {
     #[test]
     fn test_basic_signer_db() {
         let db_path = tmp_db_path();
-        let mut db = SignerDb::new(&db_path).expect("Failed to create signer db");
+        let mut db = SignerDb::new(db_path).expect("Failed to create signer db");
         let (block_info, block) = create_block();
         db.insert_block(&block_info)
             .expect("Unable to insert block into db");
@@ -241,7 +204,7 @@ mod tests {
     #[test]
     fn test_update_block() {
         let db_path = tmp_db_path();
-        let mut db = SignerDb::new(&db_path).expect("Failed to create signer db");
+        let mut db = SignerDb::new(db_path).expect("Failed to create signer db");
         let (block_info, block) = create_block();
         db.insert_block(&block_info)
             .expect("Unable to insert block into db");

From b1c7e594d4e2b33c22bea9f48ca688ee570a1c87 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?M=C3=A5rten=20Blankfors?= <marten@blankfors.se>
Date: Wed, 6 Mar 2024 13:43:15 +0100
Subject: [PATCH 1037/1166] feat: Remove unnecessary transactions

---
 stacks-signer/src/signerdb.rs | 35 +++++++++++++++--------------------
 1 file changed, 15 insertions(+), 20 deletions(-)

diff --git a/stacks-signer/src/signerdb.rs b/stacks-signer/src/signerdb.rs
index fdf9b94b5a..5afe13e83f 100644
--- a/stacks-signer/src/signerdb.rs
+++ b/stacks-signer/src/signerdb.rs
@@ -16,9 +16,7 @@
 
 use std::path::PathBuf;
 
-use blockstack_lib::util_lib::db::{
-    query_row, sqlite_open, table_exists, tx_begin_immediate, Error as DBError,
-};
+use blockstack_lib::util_lib::db::{query_row, sqlite_open, table_exists, Error as DBError};
 use rusqlite::{Connection, Error as SqliteError, OpenFlags, NO_PARAMS};
 use stacks_common::util::hash::Sha512Trunc256Sum;
 
@@ -95,30 +93,27 @@ impl SignerDb {
         let block_json =
             serde_json::to_string(&block_info).expect("Unable to serialize block info");
         let hash = &block_info.signer_signature_hash();
-        let tx = tx_begin_immediate(&mut self.db).expect("Unable to begin tx");
-        tx.execute(
-            "INSERT OR REPLACE INTO blocks (signer_signature_hash, block_info) VALUES (?1, ?2)",
-            &[format!("{}", hash), block_json],
-        )
-        .map_err(|e| {
-            return DBError::Other(format!(
-                "Unable to insert block into db: {:?}",
-                e.to_string()
-            ));
-        })?;
-        tx.commit().expect("Unable to commit tx");
+        self.db
+            .execute(
+                "INSERT OR REPLACE INTO blocks (signer_signature_hash, block_info) VALUES (?1, ?2)",
+                &[format!("{}", hash), block_json],
+            )
+            .map_err(|e| {
+                return DBError::Other(format!(
+                    "Unable to insert block into db: {:?}",
+                    e.to_string()
+                ));
+            })?;
         Ok(())
     }
 
     /// Remove a block
     pub fn remove_block(&mut self, hash: &Sha512Trunc256Sum) -> Result<(), DBError> {
-        let tx = tx_begin_immediate(&mut self.db).expect("Unable to begin tx");
-        tx.execute(
+        self.db.execute(
             "DELETE FROM blocks WHERE signer_signature_hash = ?",
             &[format!("{}", hash)],
-        )
-        .map_err(|e| DBError::from(e))?;
-        tx.commit().map_err(|e| DBError::from(e))?;
+        )?;
+
         Ok(())
     }
 }

From 4084b88b3133c4295e5f227e6e6e33a9d195fdab Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?M=C3=A5rten=20Blankfors?= <marten@blankfors.se>
Date: Wed, 6 Mar 2024 14:25:47 +0100
Subject: [PATCH 1038/1166] feat: Non-optional database path for SignerDB

---
 stacks-signer/src/config.rs                | 15 ++++------
 stacks-signer/src/signer.rs                |  4 +--
 stacks-signer/src/signerdb.rs              | 32 ++++++++++------------
 stacks-signer/src/tests/conf/signer-1.toml |  1 +
 stacks-signer/src/tests/conf/signer-4.toml |  6 ----
 5 files changed, 23 insertions(+), 35 deletions(-)
 delete mode 100644 stacks-signer/src/tests/conf/signer-4.toml

diff --git a/stacks-signer/src/config.rs b/stacks-signer/src/config.rs
index 38337a7ac1..a344bac5e6 100644
--- a/stacks-signer/src/config.rs
+++ b/stacks-signer/src/config.rs
@@ -164,7 +164,7 @@ pub struct SignerConfig {
     /// the STX tx fee to use in uSTX
     pub tx_fee_ustx: u64,
     /// The path to the signer's database file
-    pub db_path: Option<PathBuf>,
+    pub db_path: PathBuf,
 }
 
 /// The parsed configuration for the signer
@@ -199,7 +199,7 @@ pub struct GlobalConfig {
     /// the authorization password for the block proposal endpoint
     pub auth_password: String,
     /// The path to the signer's database file
-    pub db_path: Option<PathBuf>,
+    pub db_path: PathBuf,
 }
 
 /// Internal struct for loading up the config file
@@ -230,8 +230,8 @@ struct RawConfigFile {
     pub tx_fee_ustx: Option<u64>,
     /// The authorization password for the block proposal endpoint
     pub auth_password: String,
-    /// The path to the signer's database file
-    pub db_path: Option<String>,
+    /// The path to the signer's database file or :memory: for an in-memory database
+    pub db_path: String,
 }
 
 impl RawConfigFile {
@@ -308,11 +308,8 @@ impl TryFrom<RawConfigFile> for GlobalConfig {
         let dkg_private_timeout = raw_data.dkg_private_timeout_ms.map(Duration::from_millis);
         let nonce_timeout = raw_data.nonce_timeout_ms.map(Duration::from_millis);
         let sign_timeout = raw_data.sign_timeout_ms.map(Duration::from_millis);
-        let db_path = if let Some(db_path) = raw_data.db_path {
-            Some(PathBuf::from(db_path))
-        } else {
-            None
-        };
+        let db_path = raw_data.db_path.into();
+
         Ok(Self {
             node_host: raw_data.node_host,
             endpoint,
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index 7ffc509c9b..6941b5838e 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -161,7 +161,7 @@ pub struct Signer {
     /// The approved key registered to the contract
     pub approved_aggregate_public_key: Option<Point>,
     /// Signer DB path
-    pub db_path: Option<PathBuf>,
+    pub db_path: PathBuf,
     /// SignerDB for state management
     pub signer_db: SignerDb,
 }
@@ -211,7 +211,7 @@ impl From<SignerConfig> for Signer {
             coordinator_selector.get_coordinator().0
         );
         let signer_db =
-            SignerDb::new(signer_config.db_path.clone()).expect("Failed to connect to signer Db");
+            SignerDb::new(&signer_config.db_path).expect("Failed to connect to signer Db");
         Self {
             coordinator,
             signing_round,
diff --git a/stacks-signer/src/signerdb.rs b/stacks-signer/src/signerdb.rs
index 5afe13e83f..78b302330e 100644
--- a/stacks-signer/src/signerdb.rs
+++ b/stacks-signer/src/signerdb.rs
@@ -14,7 +14,7 @@
 // You should have received a copy of the GNU General Public License
 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::path::PathBuf;
+use std::path::Path;
 
 use blockstack_lib::util_lib::db::{query_row, sqlite_open, table_exists, Error as DBError};
 use rusqlite::{Connection, Error as SqliteError, OpenFlags, NO_PARAMS};
@@ -39,9 +39,9 @@ CREATE TABLE IF NOT EXISTS blocks (
 impl SignerDb {
     /// Create a new `SignerState` instance.
     /// This will create a new SQLite database at the given path
-    /// if one doesn't exist.
-    pub fn new(db_path: Option<PathBuf>) -> Result<SignerDb, DBError> {
-        let connection = Self::connect(&db_path)?;
+    /// or an in-memory database if the path is ":memory:"
+    pub fn new(db_path: impl AsRef<Path>) -> Result<SignerDb, DBError> {
+        let connection = Self::connect(db_path)?;
 
         let signer_db = Self { db: connection };
 
@@ -58,16 +58,12 @@ impl SignerDb {
         Ok(())
     }
 
-    fn connect(db_path: &Option<PathBuf>) -> Result<Connection, SqliteError> {
-        if let Some(path) = db_path {
-            sqlite_open(
-                path,
-                OpenFlags::SQLITE_OPEN_READ_WRITE | OpenFlags::SQLITE_OPEN_CREATE,
-                false,
-            )
-        } else {
-            Connection::open_in_memory()
-        }
+    fn connect(db_path: impl AsRef<Path>) -> Result<Connection, SqliteError> {
+        sqlite_open(
+            db_path,
+            OpenFlags::SQLITE_OPEN_READ_WRITE | OpenFlags::SQLITE_OPEN_CREATE,
+            false,
+        )
     }
 
     /// Fetch a block from the database using the block's
@@ -125,7 +121,7 @@ pub fn test_signer_db(db_path: &str) -> SignerDb {
     if fs::metadata(&db_path).is_ok() {
         fs::remove_file(&db_path).unwrap();
     }
-    SignerDb::new(Some(db_path.into())).expect("Failed to create signer db")
+    SignerDb::new(db_path).expect("Failed to create signer db")
 }
 
 #[cfg(test)]
@@ -141,7 +137,7 @@ mod tests {
     };
 
     use super::*;
-    use std::fs;
+    use std::{fs, path::PathBuf};
 
     fn _wipe_db(db_path: &PathBuf) {
         if fs::metadata(db_path).is_ok() {
@@ -176,8 +172,8 @@ mod tests {
         create_block_override(|_| {})
     }
 
-    fn tmp_db_path() -> Option<PathBuf> {
-        Some(format!("/tmp/stacks-signer-test-{}.sqlite", rand::random::<u64>()).into())
+    fn tmp_db_path() -> PathBuf {
+        format!("/tmp/stacks-signer-test-{}.sqlite", rand::random::<u64>()).into()
     }
 
     #[test]
diff --git a/stacks-signer/src/tests/conf/signer-1.toml b/stacks-signer/src/tests/conf/signer-1.toml
index 3d293af640..7bade0e39b 100644
--- a/stacks-signer/src/tests/conf/signer-1.toml
+++ b/stacks-signer/src/tests/conf/signer-1.toml
@@ -3,3 +3,4 @@ node_host = "127.0.0.1:20444"
 endpoint = "localhost:30001"
 network = "testnet"
 auth_password = "12345"
+db_path = ":memory:"
diff --git a/stacks-signer/src/tests/conf/signer-4.toml b/stacks-signer/src/tests/conf/signer-4.toml
deleted file mode 100644
index 0e80a1aa6f..0000000000
--- a/stacks-signer/src/tests/conf/signer-4.toml
+++ /dev/null
@@ -1,6 +0,0 @@
-
-stacks_private_key = "e427196ae29197b1db6d5495ff26bf0675f48a4f07b200c0814b95734ecda60f01"
-node_host = "127.0.0.1:20443"
-endpoint = "localhost:30004"
-network = "testnet"
-auth_password = "12345"

From 8d0e8005c8b15c3a4ec42fa3715e5972d49ad875 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?M=C3=A5rten=20Blankfors?= <marten@blankfors.se>
Date: Wed, 6 Mar 2024 14:41:14 +0100
Subject: [PATCH 1039/1166] fix: Add missin signer ID to debug logs

---
 stacks-signer/src/signer.rs | 18 ++++++++++++------
 1 file changed, 12 insertions(+), 6 deletions(-)

diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index 6941b5838e..d53173453c 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -387,11 +387,14 @@ impl Signer {
                     Ok(Some(block_info)) => block_info,
                     Ok(None) => {
                         // We have not seen this block before. Why are we getting a response for it?
-                        debug!("Received a block validate response for a block we have not seen before. Ignoring...");
+                        debug!("Signer #{}: Received a block validate response for a block we have not seen before. Ignoring...", self.signer_id);
                         return;
                     }
                     Err(e) => {
-                        error!("Failed to lookup block in signer db: {:?}", e);
+                        error!(
+                            "Signer #{}: Failed to lookup block in signer db: {:?}",
+                            self.signer_id, e
+                        );
                         return;
                     }
                 };
@@ -414,11 +417,14 @@ impl Signer {
                     Ok(Some(block_info)) => block_info,
                     Ok(None) => {
                         // We have not seen this block before. Why are we getting a response for it?
-                        debug!("Received a block validate response for a block we have not seen before. Ignoring...");
+                        debug!("Signer #{}: Received a block validate response for a block we have not seen before. Ignoring...", self.signer_id);
                         return;
                     }
                     Err(e) => {
-                        error!("Failed to lookup block in signer db: {:?}", e);
+                        error!(
+                            "Signer #{}: Failed to lookup block in signer db: {:?}",
+                            self.signer_id, e
+                        );
                         return;
                     }
                 };
@@ -639,7 +645,7 @@ impl Signer {
         {
             Some(block_info) => block_info,
             None => {
-                debug!("We have received a block sign request for a block we have not seen before. Cache the nonce request and submit the block for validation...");
+                debug!("Signer #{}: We have received a block sign request for a block we have not seen before. Cache the nonce request and submit the block for validation...", self.signer_id);
                 let block_info = BlockInfo::new_with_request(block.clone(), nonce_request.clone());
                 self.signer_db
                     .insert_block(&block_info)
@@ -1091,7 +1097,7 @@ impl Signer {
                 .expect("Failed to connect to signer DB")
             else {
                 debug!(
-                    "Received a signature result for a block we have not seen before. Ignoring..."
+                    "Signer #{}: Received a signature result for a block we have not seen before. Ignoring...", self.signer_id
                 );
                 return;
             };

From b1c981a19e9bd5bb476767bbf2dd6a270e7eac8f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?M=C3=A5rten=20Blankfors?= <marten@blankfors.se>
Date: Wed, 6 Mar 2024 16:09:05 +0100
Subject: [PATCH 1040/1166] fix: cargo fmt-stacks

---
 stacks-signer/src/signerdb.rs | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/stacks-signer/src/signerdb.rs b/stacks-signer/src/signerdb.rs
index 78b302330e..e97a0c0e5d 100644
--- a/stacks-signer/src/signerdb.rs
+++ b/stacks-signer/src/signerdb.rs
@@ -126,18 +126,18 @@ pub fn test_signer_db(db_path: &str) -> SignerDb {
 
 #[cfg(test)]
 mod tests {
-    use blockstack_lib::chainstate::{
-        nakamoto::{NakamotoBlock, NakamotoBlockHeader, NakamotoBlockVote},
-        stacks::ThresholdSignature,
-    };
-    use stacks_common::{
-        bitvec::BitVec,
-        types::chainstate::{ConsensusHash, StacksBlockId, TrieHash},
-        util::secp256k1::MessageSignature,
+    use std::fs;
+    use std::path::PathBuf;
+
+    use blockstack_lib::chainstate::nakamoto::{
+        NakamotoBlock, NakamotoBlockHeader, NakamotoBlockVote,
     };
+    use blockstack_lib::chainstate::stacks::ThresholdSignature;
+    use stacks_common::bitvec::BitVec;
+    use stacks_common::types::chainstate::{ConsensusHash, StacksBlockId, TrieHash};
+    use stacks_common::util::secp256k1::MessageSignature;
 
     use super::*;
-    use std::{fs, path::PathBuf};
 
     fn _wipe_db(db_path: &PathBuf) {
         if fs::metadata(db_path).is_ok() {

From 195c413ef5318bca1a0155264d3576a5be99e4aa Mon Sep 17 00:00:00 2001
From: BowTiedRadone <bowtiedradone@gmail.com>
Date: Wed, 6 Mar 2024 19:04:20 +0200
Subject: [PATCH 1041/1166] added tests for read only functions

- get-check-delegation
- get-delegation-info
- get-allowance-contract-callers
- get-pox-info
- minimal-can-stack-stx
---
 .../tests/pox-4/pox-4.prop.test.ts            | 2843 +++++++++--------
 1 file changed, 1514 insertions(+), 1329 deletions(-)

diff --git a/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts b/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
index a377fa9915..506ebd2864 100644
--- a/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
+++ b/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
@@ -1,1342 +1,1527 @@
-import {
-  Cl,
-  ClarityType,
-  bufferCV,
-  cvToJSON,
-  isClarityType,
-} from "@stacks/transactions";
+import { Cl, ClarityType, isClarityType } from "@stacks/transactions";
 import { assert, describe, expect, it } from "vitest";
 import fc from "fast-check";
 
-// contracts
+// Contracts
 const POX_4 = "pox-4";
-// methods
+// Methods
 const GET_POX_INFO = "get-pox-info";
-// contract consts
+const GET_STACKER_INFO = "get-stacker-info";
+const REWARD_CYCLE_TO_BURN_HEIGHT = "reward-cycle-to-burn-height";
+const BURN_HEIGHT_TO_REWARD_CYCLE = "burn-height-to-reward-cycle";
+const CURRENT_POX_REWARD_CYCLE = "current-pox-reward-cycle";
+const CHECK_CALLER_ALLOWED = "check-caller-allowed";
+const GET_REWARD_SET_SIZE = "get-reward-set-size";
+const GET_REWARD_SET_POX_ADDRESS = "get-reward-set-pox-address";
+const GET_TOTAL_USTX_STACKED = "get-total-ustx-stacked";
+const CHECK_POX_ADDR_VERSION = "check-pox-addr-version";
+const CHECK_POX_LOCK_PERIOD = "check-pox-lock-period";
+const GET_STACKING_MINIMUM = "get-stacking-minimum";
+const CAN_STACK_STX = "can-stack-stx";
+const MINIMAL_CAN_STACK_STX = "minimal-can-stack-stx";
+const GET_CHECK_DELEGATION = "get-check-delegation";
+const GET_DELEGATION_INFO = "get-delegation-info";
+const GET_ALLOWANCE_CONTRACT_CALLERS = "get-allowance-contract-callers";
+const ALLOW_CONTRACT_CALLER = "allow-contract-caller";
+// Contract Consts
 const TESTNET_STACKING_THRESHOLD_25 = 8000;
-// error codes
+const TESTNET_REWARD_CYCLE_LENGTH = 1050;
+const TESTNET_PREPARE_CYCLE_LENGTH = 50;
+const INITIAL_TOTAL_LIQ_SUPPLY = 1_000_000_000_000_000;
+const MIN_AMOUNT_USTX = 125_000_000_000n;
+// Clarity Constraints
+const MAX_CLAR_UINT = 340282366920938463463374607431768211455n;
+// Error Codes
 const ERR_STACKING_INVALID_LOCK_PERIOD = 2;
 const ERR_STACKING_THRESHOLD_NOT_MET = 11;
 const ERR_STACKING_INVALID_POX_ADDRESS = 13;
 const ERR_STACKING_INVALID_AMOUNT = 18;
 
-fc.configureGlobal({ numRuns: 250 });
-
-describe("test pox-4 contract read only functions", () => {
-  it("should return correct reward-cycle-to-burn-height", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.nat(),
-        (account, reward_cycle) => {
-          // Arrange
-          const { result: pox_4_info } = simnet.callReadOnlyFn(
-            POX_4,
-            GET_POX_INFO,
-            [],
-            account
-          );
-          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
-          const first_burn_block_height =
-            pox_4_info.value.data["first-burnchain-block-height"];
-          const reward_cycle_length =
-            pox_4_info.value.data["reward-cycle-length"];
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "reward-cycle-to-burn-height",
-            [Cl.uint(reward_cycle)],
-            account
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.UInt));
-          assert(isClarityType(first_burn_block_height, ClarityType.UInt));
-          assert(isClarityType(reward_cycle_length, ClarityType.UInt));
-
-          const expected =
-            Number(first_burn_block_height.value) +
-            Number(reward_cycle_length.value) * reward_cycle;
-          expect(actual).toBeUint(expected);
-        }
-      )
-    );
-  });
-
-  it("should return correct burn-height-to-reward-cycle", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.nat(),
-        (account, burn_height) => {
-          // Arrange
-          const { result: pox_4_info } = simnet.callReadOnlyFn(
-            POX_4,
-            GET_POX_INFO,
-            [],
-            account
-          );
-          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
-          const first_burn_block_height =
-            pox_4_info.value.data["first-burnchain-block-height"];
-          const reward_cycle_length =
-            pox_4_info.value.data["reward-cycle-length"];
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "burn-height-to-reward-cycle",
-            [Cl.uint(burn_height)],
-            account
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.UInt));
-          assert(isClarityType(first_burn_block_height, ClarityType.UInt));
-          assert(isClarityType(reward_cycle_length, ClarityType.UInt));
-          const expected = Math.floor(
-            (burn_height - Number(first_burn_block_height.value)) /
-              Number(reward_cycle_length.value)
-          );
-          expect(actual).toBeUint(expected);
-        }
-      )
-    );
-  });
-
-  it("should return none get-stacker-info", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.constantFrom(...simnet.getAccounts().values()),
-        (stacker, caller) => {
-          // Arrange
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "get-stacker-info",
-            [Cl.principal(stacker)],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.OptionalNone));
-          expect(actual).toBeNone();
-        }
-      )
-    );
-  });
-
-  it("should return true check-caller-allowed", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        (caller) => {
-          // Arrange
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "check-caller-allowed",
-            [],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.BoolTrue));
-          expect(actual).toBeBool(true);
-        }
-      )
-    );
-  });
-
-  it("should return u0 get-reward-set-size", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.nat(),
-        (caller, reward_cycle) => {
-          // Arrange
-          const expected = 0;
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "get-reward-set-size",
-            [Cl.uint(reward_cycle)],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.UInt));
-          expect(actual).toBeUint(expected);
-        }
-      )
-    );
-  });
-
-  it("should return u0 get-total-ustx-stacked", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.nat(),
-        (caller, reward_cycle) => {
-          // Arrange
-          const expected = 0;
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "get-total-ustx-stacked",
-            [Cl.uint(reward_cycle)],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.UInt));
-          expect(actual).toBeUint(expected);
-        }
-      )
-    );
-  });
-
-  it("should return none get-reward-set-pox-address", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.nat(),
-        fc.nat(),
-        (caller, index, reward_cycle) => {
-          // Arrange
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "get-reward-set-pox-address",
-            [Cl.uint(index), Cl.uint(reward_cycle)],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.OptionalNone));
-          expect(actual).toBeNone();
-        }
-      )
-    );
-  });
-
-  it("should return correct get-stacking-minimum", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        (caller) => {
-          // Arrange
-
-          const { result: pox_4_info } = simnet.callReadOnlyFn(
-            POX_4,
-            GET_POX_INFO,
-            [],
-            caller
-          );
-          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
-          const stx_liq_supply =
-            pox_4_info.value.data["total-liquid-supply-ustx"];
-
-          assert(isClarityType(stx_liq_supply, ClarityType.UInt));
-          const expected = Math.floor(
-            Number(stx_liq_supply.value) / TESTNET_STACKING_THRESHOLD_25
-          );
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "get-stacking-minimum",
-            [],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.UInt));
-          expect(actual).toBeUint(expected);
-        }
-      )
-    );
-  });
-
-  it("should return true check-pox-addr-version for version <= 6 ", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.nat({ max: 6 }),
-        (caller, version) => {
-          // Arrange
-          const expected = true;
-
-          // Act
-          let { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "check-pox-addr-version",
-            [Cl.buffer(Uint8Array.from([version]))],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.BoolTrue));
-          expect(actual).toBeBool(expected);
-        }
-      )
-    );
-  });
-
-  it("should return false check-pox-addr-version for version > 6", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.integer({ min: 7, max: 255 }),
-        (caller, version) => {
-          // Arrange
-          const expected = false;
-
-          // Act
-          let { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "check-pox-addr-version",
-            [Cl.buffer(Uint8Array.from([version]))],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.BoolFalse));
-          expect(actual).toBeBool(expected);
-        }
-      )
-    );
-  });
-
-  it("should return true check-pox-lock-period for valid reward cycles number", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.integer({ min: 1, max: 12 }),
-        (caller, reward_cycles) => {
-          // Arrange
-          const expected = true;
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "check-pox-lock-period",
-            [Cl.uint(reward_cycles)],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.BoolTrue));
-          expect(actual).toBeBool(expected);
-        }
-      )
-    );
-  });
-
-  it("should return false check-pox-lock-period for reward cycles number > 12", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.integer({ min: 13 }),
-        (caller, reward_cycles) => {
-          // Arrange
-          const expected = false;
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "check-pox-lock-period",
-            [Cl.uint(reward_cycles)],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.BoolFalse));
-          expect(actual).toBeBool(expected);
-        }
-      )
-    );
-  });
-
-  it("should return false check-pox-lock-period for reward cycles number == 0", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        (caller) => {
-          // Arrange
-          const reward_cycles = 0;
-          const expected = false;
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "check-pox-lock-period",
-            [Cl.uint(reward_cycles)],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.BoolFalse));
-          expect(actual).toBeBool(expected);
-        }
-      )
-    );
-  });
-
-  it("should return (ok true) can-stack-stx for versions 0-4 valid pox addresses, hashbytes, amount, cycles number", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.integer({ min: 0, max: 4 }),
-        fc.array(fc.nat({ max: 255 }), {
-          minLength: 20,
-          maxLength: 20,
-        }),
-        fc.bigInt({
-          min: 125_000_000_000n,
-          max: 340282366920938463463374607431768211455n,
-        }),
-        fc.nat(),
-        fc.integer({ min: 1, max: 12 }),
-        (
-          caller,
-          version,
-          hashbytes,
-          amount_ustx,
-          first_rew_cycle,
-          num_cycles
-        ) => {
-          // Arrange
-          const { result: pox_4_info } = simnet.callReadOnlyFn(
-            POX_4,
-            GET_POX_INFO,
-            [],
-            caller
-          );
-          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
-          const expectedResponseOk = true;
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "can-stack-stx",
-            [
-              Cl.tuple({
-                version: bufferCV(Uint8Array.from([version])),
-                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
-              }),
-              Cl.uint(amount_ustx),
-              Cl.uint(first_rew_cycle),
-              Cl.uint(num_cycles),
-            ],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.ResponseOk));
-          assert(isClarityType(actual.value, ClarityType.BoolTrue));
-          expect(actual).toBeOk(Cl.bool(expectedResponseOk));
-        }
-      )
-    );
-  });
-
-  it("should return (ok true) can-stack-stx for versions 5/6 valid pox addresses, hashbytes, amount, cycles number", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.integer({ min: 5, max: 6 }),
-        fc.array(fc.nat({ max: 255 }), {
-          minLength: 32,
-          maxLength: 32,
-        }),
-        fc.bigInt({
-          min: 125_000_000_000n,
-          max: 340282366920938463463374607431768211455n,
-        }),
-        fc.nat(),
-        fc.integer({ min: 1, max: 12 }),
-        (
-          caller,
-          version,
-          hashbytes,
-          amount_ustx,
-          first_rew_cycle,
-          num_cycles
-        ) => {
-          // Arrange
-
-          const { result: pox_4_info } = simnet.callReadOnlyFn(
-            POX_4,
-            GET_POX_INFO,
-            [],
-            caller
-          );
-          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
-          const expectedResponseOk = true;
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "can-stack-stx",
-            [
-              Cl.tuple({
-                version: bufferCV(Uint8Array.from([version])),
-                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
-              }),
-              Cl.uint(amount_ustx),
-              Cl.uint(first_rew_cycle),
-              Cl.uint(num_cycles),
-            ],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.ResponseOk));
-          assert(isClarityType(actual.value, ClarityType.BoolTrue));
-          expect(actual).toBeOk(Cl.bool(expectedResponseOk));
-        }
-      )
-    );
-  });
-
-  it("should return (err 13) can-stack-stx for pox addresses having version > 6", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.integer({
-          min: 7,
-          max: 255,
-        }),
-        fc.array(fc.nat({ max: 255 }), {
-          minLength: 32,
-          maxLength: 32,
-        }),
-        fc.bigInt({
-          min: 125_000_000_000n,
-          max: 340282366920938463463374607431768211455n,
-        }),
-        fc.nat(),
-        fc.integer({ min: 1, max: 12 }),
-        (
-          caller,
-          version,
-          hashbytes,
-          amount_ustx,
-          first_rew_cycle,
-          num_cycles
-        ) => {
-          // Arrange
-          const { result: pox_4_info } = simnet.callReadOnlyFn(
-            POX_4,
-            GET_POX_INFO,
-            [],
-            caller
-          );
-          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
-          const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "can-stack-stx",
-            [
-              Cl.tuple({
-                version: bufferCV(Uint8Array.from([version])),
-                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
-              }),
-              Cl.uint(amount_ustx),
-              Cl.uint(first_rew_cycle),
-              Cl.uint(num_cycles),
-            ],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.ResponseErr));
-          assert(isClarityType(actual.value, ClarityType.Int));
-          expect(actual).toBeErr(Cl.int(expectedResponseErr));
-        }
-      )
-    );
-  });
-
-  it("should return (err 13) can-stack-stx for versions 0-4 pox addresses having hasbytes longer than 20", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.integer({ min: 0, max: 4 }),
-        fc.array(fc.nat({ max: 255 }), {
-          minLength: 21,
-          maxLength: 32,
-        }),
-        fc.bigInt({
-          min: 125_000_000_000n,
-          max: 340282366920938463463374607431768211455n,
-        }),
-        fc.nat(),
-        fc.integer({ min: 1, max: 12 }),
-        (
-          caller,
-          version,
-          hashbytes,
-          amount_ustx,
-          first_rew_cycle,
-          num_cycles
-        ) => {
-          // Arrange
-          const { result: pox_4_info } = simnet.callReadOnlyFn(
-            POX_4,
-            GET_POX_INFO,
-            [],
-            caller
-          );
-          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
-          const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "can-stack-stx",
-            [
-              Cl.tuple({
-                version: bufferCV(Uint8Array.from([version])),
-                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
-              }),
-              Cl.uint(amount_ustx),
-              Cl.uint(first_rew_cycle),
-              Cl.uint(num_cycles),
-            ],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.ResponseErr));
-          assert(isClarityType(actual.value, ClarityType.Int));
-          expect(actual).toBeErr(Cl.int(expectedResponseErr));
-        }
-      )
-    );
-  });
-
-  it("should return (err 13) can-stack-stx for versions 0-4 pox addresses having hasbytes shorter than 20", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.integer({ min: 0, max: 4 }),
-        fc.array(fc.nat({ max: 255 }), {
-          maxLength: 19,
-        }),
-        fc.bigInt({
-          min: 125_000_000_000n,
-          max: 340282366920938463463374607431768211455n,
-        }),
-        fc.nat(),
-        fc.integer({ min: 1, max: 12 }),
-        (
-          caller,
-          version,
-          hashbytes,
-          amount_ustx,
-          first_rew_cycle,
-          num_cycles
-        ) => {
-          // Arrange
-          const { result: pox_4_info } = simnet.callReadOnlyFn(
-            POX_4,
-            GET_POX_INFO,
-            [],
-            caller
-          );
-          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
-          const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "can-stack-stx",
-            [
-              Cl.tuple({
-                version: bufferCV(Uint8Array.from([version])),
-                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
-              }),
-              Cl.uint(amount_ustx),
-              Cl.uint(first_rew_cycle),
-              Cl.uint(num_cycles),
-            ],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.ResponseErr));
-          assert(isClarityType(actual.value, ClarityType.Int));
-          expect(actual).toBeErr(Cl.int(expectedResponseErr));
-        }
-      )
-    );
-  });
-
-  it("should return (err 13) can-stack-stx for versions 5/6 pox addresses having hashbytes shorter than 32", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.integer({ min: 0, max: 4 }),
-        fc.array(fc.nat({ max: 255 }), {
-          maxLength: 31,
-        }),
-        fc.bigInt({
-          min: 125_000_000_000n,
-          max: 340282366920938463463374607431768211455n,
-        }),
-        fc.nat(),
-        fc.integer({ min: 1, max: 12 }),
-        (
-          caller,
-          version,
-          hashbytes,
-          amount_ustx,
-          first_rew_cycle,
-          num_cycles
-        ) => {
-          // Arrange
-          const { result: pox_4_info } = simnet.callReadOnlyFn(
-            POX_4,
-            GET_POX_INFO,
-            [],
-            caller
-          );
-          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
-          const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "can-stack-stx",
-            [
-              Cl.tuple({
-                version: bufferCV(Uint8Array.from([version])),
-                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
-              }),
-              Cl.uint(amount_ustx),
-              Cl.uint(first_rew_cycle),
-              Cl.uint(num_cycles),
-            ],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.ResponseErr));
-          assert(isClarityType(actual.value, ClarityType.Int));
-          expect(actual).toBeErr(Cl.int(expectedResponseErr));
-        }
-      )
-    );
-  });
-
-  it("should return (err 11) can-stack-stx for unmet stacking threshold", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.integer({ min: 0, max: 6 }),
-        fc.array(fc.nat({ max: 255 })),
-        fc.bigInt({
-          min: 0n,
-          max: 124_999_999_999n,
-        }),
-        fc.nat(),
-        fc.integer({ min: 1, max: 12 }),
-        (
-          caller,
-          version,
-          hashbytes,
-          amount_ustx,
-          first_rew_cycle,
-          num_cycles
-        ) => {
-          // Arrange
-          const { result: pox_4_info } = simnet.callReadOnlyFn(
-            POX_4,
-            GET_POX_INFO,
-            [],
-            caller
-          );
-          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
-          const expectedResponseErr = ERR_STACKING_THRESHOLD_NOT_MET;
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "can-stack-stx",
-            [
-              Cl.tuple({
-                version: bufferCV(Uint8Array.from([version])),
-                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
-              }),
-              Cl.uint(amount_ustx),
-              Cl.uint(first_rew_cycle),
-              Cl.uint(num_cycles),
-            ],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.ResponseErr));
-          assert(isClarityType(actual.value, ClarityType.Int));
-          expect(actual).toBeErr(Cl.int(expectedResponseErr));
-        }
-      )
-    );
-  });
-
-  it("should return (err 2) can-stack-stx for lock period > 12", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.integer({ min: 0, max: 6 }),
-        fc.array(fc.nat({ max: 255 })),
-        fc.bigInt({
-          min: 125_000_000_000n,
-          max: 340282366920938463463374607431768211455n,
-        }),
-        fc.nat(),
-        fc.integer({ min: 13 }),
-        (
-          caller,
-          version,
-          hashbytes,
-          amount_ustx,
-          first_rew_cycle,
-          num_cycles
-        ) => {
-          // Arrange
-          const { result: pox_4_info } = simnet.callReadOnlyFn(
-            POX_4,
-            GET_POX_INFO,
-            [],
-            caller
-          );
-          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
-          const expectedResponseErr = ERR_STACKING_INVALID_LOCK_PERIOD;
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "can-stack-stx",
-            [
-              Cl.tuple({
-                version: bufferCV(Uint8Array.from([version])),
-                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
-              }),
-              Cl.uint(amount_ustx),
-              Cl.uint(first_rew_cycle),
-              Cl.uint(num_cycles),
-            ],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.ResponseErr));
-          assert(isClarityType(actual.value, ClarityType.Int));
-          expect(actual).toBeErr(Cl.int(expectedResponseErr));
-        }
-      )
-    );
-  });
-
-  // minimal can stack stx
-  it("should return (ok true) minimal-can-stack-stx for versions 0-4 valid pox addresses, hashbytes, amount, cycles number", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.integer({ min: 0, max: 4 }),
-        fc.array(fc.nat({ max: 255 }), {
-          minLength: 20,
-          maxLength: 20,
-        }),
-        fc.bigInt({
-          min: 125_000_000_000n,
-          max: 340282366920938463463374607431768211455n,
-        }),
-        fc.nat(),
-        fc.integer({ min: 1, max: 12 }),
-        (
-          caller,
-          version,
-          hashbytes,
-          amount_ustx,
-          first_rew_cycle,
-          num_cycles
-        ) => {
-          // Arrange
-          const { result: pox_4_info } = simnet.callReadOnlyFn(
-            POX_4,
-            GET_POX_INFO,
-            [],
-            caller
-          );
-          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
-          const expectedResponseOk = true;
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "minimal-can-stack-stx",
-            [
-              Cl.tuple({
-                version: bufferCV(Uint8Array.from([version])),
-                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
-              }),
-              Cl.uint(amount_ustx),
-              Cl.uint(first_rew_cycle),
-              Cl.uint(num_cycles),
-            ],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.ResponseOk));
-          assert(isClarityType(actual.value, ClarityType.BoolTrue));
-          expect(actual).toBeOk(Cl.bool(expectedResponseOk));
-        }
-      )
-    );
-  });
-
-  it("should return (ok true) minimal-can-stack-stx for versions 5/6 valid pox addresses, hashbytes, amount, cycles number", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.integer({ min: 5, max: 6 }),
-        fc.array(fc.nat({ max: 255 }), {
-          minLength: 32,
-          maxLength: 32,
-        }),
-        fc.bigInt({
-          min: 125_000_000_000n,
-          max: 340282366920938463463374607431768211455n,
-        }),
-        fc.nat(),
-        fc.integer({ min: 1, max: 12 }),
-        (
-          caller,
-          version,
-          hashbytes,
-          amount_ustx,
-          first_rew_cycle,
-          num_cycles
-        ) => {
-          // Arrange
-
-          const { result: pox_4_info } = simnet.callReadOnlyFn(
-            POX_4,
-            GET_POX_INFO,
-            [],
-            caller
-          );
-          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
-          const expectedResponseOk = true;
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "minimal-can-stack-stx",
-            [
-              Cl.tuple({
-                version: bufferCV(Uint8Array.from([version])),
-                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
-              }),
-              Cl.uint(amount_ustx),
-              Cl.uint(first_rew_cycle),
-              Cl.uint(num_cycles),
-            ],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.ResponseOk));
-          assert(isClarityType(actual.value, ClarityType.BoolTrue));
-          expect(actual).toBeOk(Cl.bool(expectedResponseOk));
-        }
-      )
-    );
-  });
-
-  it("should return (err 13) minimal-can-stack-stx for pox addresses having version > 6", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.integer({
-          min: 7,
-          max: 255,
-        }),
-        fc.array(fc.nat({ max: 255 }), {
-          minLength: 32,
-          maxLength: 32,
-        }),
-        fc.bigInt({
-          min: 125_000_000_000n,
-          max: 340282366920938463463374607431768211455n,
-        }),
-        fc.nat(),
-        fc.integer({ min: 1, max: 12 }),
-        (
-          caller,
-          version,
-          hashbytes,
-          amount_ustx,
-          first_rew_cycle,
-          num_cycles
-        ) => {
-          // Arrange
-          const { result: pox_4_info } = simnet.callReadOnlyFn(
-            POX_4,
-            GET_POX_INFO,
-            [],
-            caller
-          );
-          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
-          const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "minimal-can-stack-stx",
-            [
-              Cl.tuple({
-                version: bufferCV(Uint8Array.from([version])),
-                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
-              }),
-              Cl.uint(amount_ustx),
-              Cl.uint(first_rew_cycle),
-              Cl.uint(num_cycles),
-            ],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.ResponseErr));
-          assert(isClarityType(actual.value, ClarityType.Int));
-          expect(actual).toBeErr(Cl.int(expectedResponseErr));
-        }
-      )
-    );
-  });
-
-  it("should return (err 13) minimal-can-stack-stx for versions 0-4 pox addresses having hasbytes longer than 20", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.integer({ min: 0, max: 4 }),
-        fc.array(fc.nat({ max: 255 }), {
-          minLength: 21,
-          maxLength: 32,
-        }),
-        fc.bigInt({
-          min: 125_000_000_000n,
-          max: 340282366920938463463374607431768211455n,
-        }),
-        fc.nat(),
-        fc.integer({ min: 1, max: 12 }),
-        (
-          caller,
-          version,
-          hashbytes,
-          amount_ustx,
-          first_rew_cycle,
-          num_cycles
-        ) => {
-          // Arrange
-          const { result: pox_4_info } = simnet.callReadOnlyFn(
-            POX_4,
-            GET_POX_INFO,
-            [],
-            caller
-          );
-          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
-          const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "minimal-can-stack-stx",
-            [
-              Cl.tuple({
-                version: bufferCV(Uint8Array.from([version])),
-                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
-              }),
-              Cl.uint(amount_ustx),
-              Cl.uint(first_rew_cycle),
-              Cl.uint(num_cycles),
-            ],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.ResponseErr));
-          assert(isClarityType(actual.value, ClarityType.Int));
-          expect(actual).toBeErr(Cl.int(expectedResponseErr));
-        }
-      )
-    );
-  });
-
-  it("should return (err 13) minimal-can-stack-stx for versions 0-4 pox addresses having hasbytes shorter than 20", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.integer({ min: 0, max: 4 }),
-        fc.array(fc.nat({ max: 255 }), {
-          maxLength: 19,
-        }),
-        fc.bigInt({
-          min: 125_000_000_000n,
-          max: 340282366920938463463374607431768211455n,
-        }),
-        fc.nat(),
-        fc.integer({ min: 1, max: 12 }),
-        (
-          caller,
-          version,
-          hashbytes,
-          amount_ustx,
-          first_rew_cycle,
-          num_cycles
-        ) => {
-          // Arrange
-          const { result: pox_4_info } = simnet.callReadOnlyFn(
-            POX_4,
-            GET_POX_INFO,
-            [],
-            caller
-          );
-          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
-          const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "minimal-can-stack-stx",
-            [
-              Cl.tuple({
-                version: bufferCV(Uint8Array.from([version])),
-                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
-              }),
-              Cl.uint(amount_ustx),
-              Cl.uint(first_rew_cycle),
-              Cl.uint(num_cycles),
-            ],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.ResponseErr));
-          assert(isClarityType(actual.value, ClarityType.Int));
-          expect(actual).toBeErr(Cl.int(expectedResponseErr));
-        }
-      )
-    );
-  });
-
-  it("should return (err 13) minimal-can-stack-stx for versions 5/6 pox addresses having hashbytes shorter than 32", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.integer({ min: 0, max: 4 }),
-        fc.array(fc.nat({ max: 255 }), {
-          maxLength: 31,
-        }),
-        fc.bigInt({
-          min: 125_000_000_000n,
-          max: 340282366920938463463374607431768211455n,
-        }),
-        fc.nat(),
-        fc.integer({ min: 1, max: 12 }),
-        (
-          caller,
-          version,
-          hashbytes,
-          amount_ustx,
-          first_rew_cycle,
-          num_cycles
-        ) => {
-          // Arrange
-          const { result: pox_4_info } = simnet.callReadOnlyFn(
-            POX_4,
-            GET_POX_INFO,
-            [],
-            caller
-          );
-          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
-          const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "minimal-can-stack-stx",
-            [
-              Cl.tuple({
-                version: bufferCV(Uint8Array.from([version])),
-                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
-              }),
-              Cl.uint(amount_ustx),
-              Cl.uint(first_rew_cycle),
-              Cl.uint(num_cycles),
-            ],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.ResponseErr));
-          assert(isClarityType(actual.value, ClarityType.Int));
-          expect(actual).toBeErr(Cl.int(expectedResponseErr));
-        }
-      )
-    );
-  });
-
-  it("should return (err 2) minimal-can-stack-stx for lock period > 12", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.integer({ min: 0, max: 6 }),
-        fc.array(fc.nat({ max: 255 })),
-        fc.bigInt({
-          min: 125_000_000_000n,
-          max: 340282366920938463463374607431768211455n,
-        }),
-        fc.nat(),
-        fc.integer({ min: 13 }),
-        (
-          caller,
-          version,
-          hashbytes,
-          amount_ustx,
-          first_rew_cycle,
-          num_cycles
-        ) => {
-          // Arrange
-          const { result: pox_4_info } = simnet.callReadOnlyFn(
-            POX_4,
-            GET_POX_INFO,
-            [],
-            caller
-          );
-          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
-          const expectedResponseErr = ERR_STACKING_INVALID_LOCK_PERIOD;
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "minimal-can-stack-stx",
-            [
-              Cl.tuple({
-                version: bufferCV(Uint8Array.from([version])),
-                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
-              }),
-              Cl.uint(amount_ustx),
-              Cl.uint(first_rew_cycle),
-              Cl.uint(num_cycles),
-            ],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.ResponseErr));
-          assert(isClarityType(actual.value, ClarityType.Int));
-          expect(actual).toBeErr(Cl.int(expectedResponseErr));
-        }
-      )
-    );
-  });
-
-  it("should return (err 18) minimal-can-stack-stx for amount == 0", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.integer(),
-        fc.array(fc.nat({ max: 255 })),
-        fc.nat(),
-        fc.integer({ min: 1, max: 12 }),
-        (caller, version, hashbytes, first_rew_cycle, num_cycles) => {
-          // Arrange
-          const amount_ustx = 0;
-
-          const { result: pox_4_info } = simnet.callReadOnlyFn(
-            POX_4,
-            GET_POX_INFO,
-            [],
-            caller
-          );
-          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
-          const expectedResponseErr = ERR_STACKING_INVALID_AMOUNT;
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "minimal-can-stack-stx",
-            [
-              Cl.tuple({
-                version: bufferCV(Uint8Array.from([version])),
-                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
-              }),
-              Cl.uint(amount_ustx),
-              Cl.uint(first_rew_cycle),
-              Cl.uint(num_cycles),
-            ],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.ResponseErr));
-          assert(isClarityType(actual.value, ClarityType.Int));
-          expect(actual).toBeErr(Cl.int(expectedResponseErr));
-        }
-      )
-    );
+describe("test pox-4 contract", () => {
+  describe("test pox-4 contract read only functions", () => {
+    it("should return correct reward-cycle-to-burn-height", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.nat(),
+          (account, reward_cycle) => {
+            // Arrange
+            const { result: pox_4_info } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_POX_INFO,
+              [],
+              account
+            );
+            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+            const first_burn_block_height =
+              pox_4_info.value.data["first-burnchain-block-height"];
+            const reward_cycle_length =
+              pox_4_info.value.data["reward-cycle-length"];
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              REWARD_CYCLE_TO_BURN_HEIGHT,
+              [Cl.uint(reward_cycle)],
+              account
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.UInt));
+            assert(isClarityType(first_burn_block_height, ClarityType.UInt));
+            assert(isClarityType(reward_cycle_length, ClarityType.UInt));
+
+            const expected =
+              Number(first_burn_block_height.value) +
+              Number(reward_cycle_length.value) * reward_cycle;
+            expect(actual).toBeUint(expected);
+          }
+        )
+      );
+    });
+
+    it("should return correct burn-height-to-reward-cycle", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.nat(),
+          (account, burn_height) => {
+            // Arrange
+            const { result: pox_4_info } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_POX_INFO,
+              [],
+              account
+            );
+            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+            const first_burn_block_height =
+              pox_4_info.value.data["first-burnchain-block-height"];
+            const reward_cycle_length =
+              pox_4_info.value.data["reward-cycle-length"];
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              BURN_HEIGHT_TO_REWARD_CYCLE,
+              [Cl.uint(burn_height)],
+              account
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.UInt));
+            assert(isClarityType(first_burn_block_height, ClarityType.UInt));
+            assert(isClarityType(reward_cycle_length, ClarityType.UInt));
+            const expected = Math.floor(
+              (burn_height - Number(first_burn_block_height.value)) /
+                Number(reward_cycle_length.value)
+            );
+            expect(actual).toBeUint(expected);
+          }
+        )
+      );
+    });
+
+    it("should return u0 current-pox-reward-cycle", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          (caller) => {
+            // Arrange
+            let expected = 0;
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              CURRENT_POX_REWARD_CYCLE,
+              [],
+              caller
+            );
+            // Assert
+            assert(isClarityType(actual, ClarityType.UInt));
+            expect(actual).toBeUint(expected);
+          }
+        )
+      );
+    });
+
+    it("should return none get-stacker-info", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.constantFrom(...simnet.getAccounts().values()),
+          (stacker, caller) => {
+            // Arrange
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_STACKER_INFO,
+              [Cl.principal(stacker)],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.OptionalNone));
+            expect(actual).toBeNone();
+          }
+        )
+      );
+    });
+
+    it("should return true check-caller-allowed", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          (caller) => {
+            // Arrange
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              CHECK_CALLER_ALLOWED,
+              [],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.BoolTrue));
+            expect(actual).toBeBool(true);
+          }
+        )
+      );
+    });
+
+    it("should return u0 get-reward-set-size", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.nat(),
+          (caller, reward_cycle) => {
+            // Arrange
+            const expected = 0;
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_REWARD_SET_SIZE,
+              [Cl.uint(reward_cycle)],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.UInt));
+            expect(actual).toBeUint(expected);
+          }
+        )
+      );
+    });
+
+    it("should return u0 get-total-ustx-stacked", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.nat(),
+          (caller, reward_cycle) => {
+            // Arrange
+            const expected = 0;
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_TOTAL_USTX_STACKED,
+              [Cl.uint(reward_cycle)],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.UInt));
+            expect(actual).toBeUint(expected);
+          }
+        )
+      );
+    });
+
+    it("should return none get-reward-set-pox-address", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.nat(),
+          fc.nat(),
+          (caller, index, reward_cycle) => {
+            // Arrange
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_REWARD_SET_POX_ADDRESS,
+              [Cl.uint(index), Cl.uint(reward_cycle)],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.OptionalNone));
+            expect(actual).toBeNone();
+          }
+        )
+      );
+    });
+
+    it("should return correct get-stacking-minimum", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          (caller) => {
+            // Arrange
+
+            const { result: pox_4_info } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_POX_INFO,
+              [],
+              caller
+            );
+            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+            const stx_liq_supply =
+              pox_4_info.value.data["total-liquid-supply-ustx"];
+
+            assert(isClarityType(stx_liq_supply, ClarityType.UInt));
+            const expected = Math.floor(
+              Number(stx_liq_supply.value) / TESTNET_STACKING_THRESHOLD_25
+            );
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_STACKING_MINIMUM,
+              [],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.UInt));
+            expect(actual).toBeUint(expected);
+          }
+        )
+      );
+    });
+
+    it("should return true check-pox-addr-version for version <= 6 ", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.nat({ max: 6 }),
+          (caller, version) => {
+            // Arrange
+            const expected = true;
+
+            // Act
+            let { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              CHECK_POX_ADDR_VERSION,
+              [Cl.buffer(Uint8Array.from([version]))],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.BoolTrue));
+            expect(actual).toBeBool(expected);
+          }
+        )
+      );
+    });
+
+    it("should return false check-pox-addr-version for version > 6", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.integer({ min: 7, max: 255 }),
+          (caller, version) => {
+            // Arrange
+            const expected = false;
+
+            // Act
+            let { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              CHECK_POX_ADDR_VERSION,
+              [Cl.buffer(Uint8Array.from([version]))],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.BoolFalse));
+            expect(actual).toBeBool(expected);
+          }
+        )
+      );
+    });
+
+    it("should return true check-pox-lock-period for valid reward cycles number", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.integer({ min: 1, max: 12 }),
+          (caller, reward_cycles) => {
+            // Arrange
+            const expected = true;
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              CHECK_POX_LOCK_PERIOD,
+              [Cl.uint(reward_cycles)],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.BoolTrue));
+            expect(actual).toBeBool(expected);
+          }
+        )
+      );
+    });
+
+    it("should return false check-pox-lock-period for reward cycles number > 12", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.integer({ min: 13 }),
+          (caller, reward_cycles) => {
+            // Arrange
+            const expected = false;
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              CHECK_POX_LOCK_PERIOD,
+              [Cl.uint(reward_cycles)],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.BoolFalse));
+            expect(actual).toBeBool(expected);
+          }
+        )
+      );
+    });
+
+    it("should return false check-pox-lock-period for reward cycles number == 0", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          (caller) => {
+            // Arrange
+            const reward_cycles = 0;
+            const expected = false;
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              CHECK_POX_LOCK_PERIOD,
+              [Cl.uint(reward_cycles)],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.BoolFalse));
+            expect(actual).toBeBool(expected);
+          }
+        )
+      );
+    });
+
+    it("should return (ok true) can-stack-stx for versions 0-4 valid pox addresses, hashbytes, amount, cycles number", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.integer({ min: 0, max: 4 }),
+          fc.array(fc.nat({ max: 255 }), {
+            minLength: 20,
+            maxLength: 20,
+          }),
+          fc.bigInt({
+            min: MIN_AMOUNT_USTX,
+            max: MAX_CLAR_UINT,
+          }),
+          fc.nat(),
+          fc.integer({ min: 1, max: 12 }),
+          (
+            caller,
+            version,
+            hashbytes,
+            amount_ustx,
+            first_rew_cycle,
+            num_cycles
+          ) => {
+            // Arrange
+            const { result: pox_4_info } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_POX_INFO,
+              [],
+              caller
+            );
+            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+            const expectedResponseOk = true;
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              CAN_STACK_STX,
+              [
+                Cl.tuple({
+                  version: Cl.buffer(Uint8Array.from([version])),
+                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+                }),
+                Cl.uint(amount_ustx),
+                Cl.uint(first_rew_cycle),
+                Cl.uint(num_cycles),
+              ],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.ResponseOk));
+            assert(isClarityType(actual.value, ClarityType.BoolTrue));
+            expect(actual).toBeOk(Cl.bool(expectedResponseOk));
+          }
+        )
+      );
+    });
+
+    it("should return (ok true) can-stack-stx for versions 5/6 valid pox addresses, hashbytes, amount, cycles number", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.integer({ min: 5, max: 6 }),
+          fc.array(fc.nat({ max: 255 }), {
+            minLength: 32,
+            maxLength: 32,
+          }),
+          fc.bigInt({
+            min: MIN_AMOUNT_USTX,
+            max: MAX_CLAR_UINT,
+          }),
+          fc.nat(),
+          fc.integer({ min: 1, max: 12 }),
+          (
+            caller,
+            version,
+            hashbytes,
+            amount_ustx,
+            first_rew_cycle,
+            num_cycles
+          ) => {
+            // Arrange
+
+            const { result: pox_4_info } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_POX_INFO,
+              [],
+              caller
+            );
+            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+            const expectedResponseOk = true;
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              CAN_STACK_STX,
+              [
+                Cl.tuple({
+                  version: Cl.buffer(Uint8Array.from([version])),
+                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+                }),
+                Cl.uint(amount_ustx),
+                Cl.uint(first_rew_cycle),
+                Cl.uint(num_cycles),
+              ],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.ResponseOk));
+            assert(isClarityType(actual.value, ClarityType.BoolTrue));
+            expect(actual).toBeOk(Cl.bool(expectedResponseOk));
+          }
+        )
+      );
+    });
+
+    it("should return (err 13) can-stack-stx for pox addresses having version > 6", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.integer({
+            min: 7,
+            max: 255,
+          }),
+          fc.array(fc.nat({ max: 255 }), {
+            minLength: 32,
+            maxLength: 32,
+          }),
+          fc.bigInt({
+            min: MIN_AMOUNT_USTX,
+            max: MAX_CLAR_UINT,
+          }),
+          fc.nat(),
+          fc.integer({ min: 1, max: 12 }),
+          (
+            caller,
+            version,
+            hashbytes,
+            amount_ustx,
+            first_rew_cycle,
+            num_cycles
+          ) => {
+            // Arrange
+            const { result: pox_4_info } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_POX_INFO,
+              [],
+              caller
+            );
+            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+            const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              CAN_STACK_STX,
+              [
+                Cl.tuple({
+                  version: Cl.buffer(Uint8Array.from([version])),
+                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+                }),
+                Cl.uint(amount_ustx),
+                Cl.uint(first_rew_cycle),
+                Cl.uint(num_cycles),
+              ],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.ResponseErr));
+            assert(isClarityType(actual.value, ClarityType.Int));
+            expect(actual).toBeErr(Cl.int(expectedResponseErr));
+          }
+        )
+      );
+    });
+
+    it("should return (err 13) can-stack-stx for versions 0-4 pox addresses having hasbytes longer than 20", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.integer({ min: 0, max: 4 }),
+          fc.array(fc.nat({ max: 255 }), {
+            minLength: 21,
+            maxLength: 32,
+          }),
+          fc.bigInt({
+            min: MIN_AMOUNT_USTX,
+            max: MAX_CLAR_UINT,
+          }),
+          fc.nat(),
+          fc.integer({ min: 1, max: 12 }),
+          (
+            caller,
+            version,
+            hashbytes,
+            amount_ustx,
+            first_rew_cycle,
+            num_cycles
+          ) => {
+            // Arrange
+            const { result: pox_4_info } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_POX_INFO,
+              [],
+              caller
+            );
+            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+            const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              CAN_STACK_STX,
+              [
+                Cl.tuple({
+                  version: Cl.buffer(Uint8Array.from([version])),
+                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+                }),
+                Cl.uint(amount_ustx),
+                Cl.uint(first_rew_cycle),
+                Cl.uint(num_cycles),
+              ],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.ResponseErr));
+            assert(isClarityType(actual.value, ClarityType.Int));
+            expect(actual).toBeErr(Cl.int(expectedResponseErr));
+          }
+        )
+      );
+    });
+
+    it("should return (err 13) can-stack-stx for versions 0-4 pox addresses having hasbytes shorter than 20", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.integer({ min: 0, max: 4 }),
+          fc.array(fc.nat({ max: 255 }), {
+            maxLength: 19,
+          }),
+          fc.bigInt({
+            min: MIN_AMOUNT_USTX,
+            max: MAX_CLAR_UINT,
+          }),
+          fc.nat(),
+          fc.integer({ min: 1, max: 12 }),
+          (
+            caller,
+            version,
+            hashbytes,
+            amount_ustx,
+            first_rew_cycle,
+            num_cycles
+          ) => {
+            // Arrange
+            const { result: pox_4_info } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_POX_INFO,
+              [],
+              caller
+            );
+            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+            const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              CAN_STACK_STX,
+              [
+                Cl.tuple({
+                  version: Cl.buffer(Uint8Array.from([version])),
+                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+                }),
+                Cl.uint(amount_ustx),
+                Cl.uint(first_rew_cycle),
+                Cl.uint(num_cycles),
+              ],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.ResponseErr));
+            assert(isClarityType(actual.value, ClarityType.Int));
+            expect(actual).toBeErr(Cl.int(expectedResponseErr));
+          }
+        )
+      );
+    });
+
+    it("should return (err 13) can-stack-stx for versions 5/6 pox addresses having hashbytes shorter than 32", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.integer({ min: 0, max: 4 }),
+          fc.array(fc.nat({ max: 255 }), {
+            maxLength: 31,
+          }),
+          fc.bigInt({
+            min: MIN_AMOUNT_USTX,
+            max: MAX_CLAR_UINT,
+          }),
+          fc.nat(),
+          fc.integer({ min: 1, max: 12 }),
+          (
+            caller,
+            version,
+            hashbytes,
+            amount_ustx,
+            first_rew_cycle,
+            num_cycles
+          ) => {
+            // Arrange
+            const { result: pox_4_info } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_POX_INFO,
+              [],
+              caller
+            );
+            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+            const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              CAN_STACK_STX,
+              [
+                Cl.tuple({
+                  version: Cl.buffer(Uint8Array.from([version])),
+                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+                }),
+                Cl.uint(amount_ustx),
+                Cl.uint(first_rew_cycle),
+                Cl.uint(num_cycles),
+              ],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.ResponseErr));
+            assert(isClarityType(actual.value, ClarityType.Int));
+            expect(actual).toBeErr(Cl.int(expectedResponseErr));
+          }
+        )
+      );
+    });
+
+    it("should return (err 11) can-stack-stx for unmet stacking threshold", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.integer({ min: 0, max: 6 }),
+          fc.array(fc.nat({ max: 255 })),
+          fc.bigInt({
+            min: 0n,
+            max: 124_999_999_999n,
+          }),
+          fc.nat(),
+          fc.integer({ min: 1, max: 12 }),
+          (
+            caller,
+            version,
+            hashbytes,
+            amount_ustx,
+            first_rew_cycle,
+            num_cycles
+          ) => {
+            // Arrange
+            const { result: pox_4_info } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_POX_INFO,
+              [],
+              caller
+            );
+            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+            const expectedResponseErr = ERR_STACKING_THRESHOLD_NOT_MET;
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              CAN_STACK_STX,
+              [
+                Cl.tuple({
+                  version: Cl.buffer(Uint8Array.from([version])),
+                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+                }),
+                Cl.uint(amount_ustx),
+                Cl.uint(first_rew_cycle),
+                Cl.uint(num_cycles),
+              ],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.ResponseErr));
+            assert(isClarityType(actual.value, ClarityType.Int));
+            expect(actual).toBeErr(Cl.int(expectedResponseErr));
+          }
+        )
+      );
+    });
+
+    it("should return (err 2) can-stack-stx for lock period > 12", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.integer({ min: 0, max: 6 }),
+          fc.array(fc.nat({ max: 255 })),
+          fc.bigInt({
+            min: MIN_AMOUNT_USTX,
+            max: MAX_CLAR_UINT,
+          }),
+          fc.nat(),
+          fc.integer({ min: 13 }),
+          (
+            caller,
+            version,
+            hashbytes,
+            amount_ustx,
+            first_rew_cycle,
+            num_cycles
+          ) => {
+            // Arrange
+            const { result: pox_4_info } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_POX_INFO,
+              [],
+              caller
+            );
+            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+            const expectedResponseErr = ERR_STACKING_INVALID_LOCK_PERIOD;
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              CAN_STACK_STX,
+              [
+                Cl.tuple({
+                  version: Cl.buffer(Uint8Array.from([version])),
+                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+                }),
+                Cl.uint(amount_ustx),
+                Cl.uint(first_rew_cycle),
+                Cl.uint(num_cycles),
+              ],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.ResponseErr));
+            assert(isClarityType(actual.value, ClarityType.Int));
+            expect(actual).toBeErr(Cl.int(expectedResponseErr));
+          }
+        )
+      );
+    });
+
+    // minimal can stack stx
+    it("should return (ok true) minimal-can-stack-stx for versions 0-4 valid pox addresses, hashbytes, amount, cycles number", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.integer({ min: 0, max: 4 }),
+          fc.array(fc.nat({ max: 255 }), {
+            minLength: 20,
+            maxLength: 20,
+          }),
+          fc.bigInt({
+            min: MIN_AMOUNT_USTX,
+            max: MAX_CLAR_UINT,
+          }),
+          fc.nat(),
+          fc.integer({ min: 1, max: 12 }),
+          (
+            caller,
+            version,
+            hashbytes,
+            amount_ustx,
+            first_rew_cycle,
+            num_cycles
+          ) => {
+            // Arrange
+            const { result: pox_4_info } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_POX_INFO,
+              [],
+              caller
+            );
+            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+            const expectedResponseOk = true;
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              MINIMAL_CAN_STACK_STX,
+              [
+                Cl.tuple({
+                  version: Cl.buffer(Uint8Array.from([version])),
+                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+                }),
+                Cl.uint(amount_ustx),
+                Cl.uint(first_rew_cycle),
+                Cl.uint(num_cycles),
+              ],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.ResponseOk));
+            assert(isClarityType(actual.value, ClarityType.BoolTrue));
+            expect(actual).toBeOk(Cl.bool(expectedResponseOk));
+          }
+        )
+      );
+    });
+
+    it("should return (ok true) minimal-can-stack-stx for versions 5/6 valid pox addresses, hashbytes, amount, cycles number", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.integer({ min: 5, max: 6 }),
+          fc.array(fc.nat({ max: 255 }), {
+            minLength: 32,
+            maxLength: 32,
+          }),
+          fc.bigInt({
+            min: MIN_AMOUNT_USTX,
+            max: MAX_CLAR_UINT,
+          }),
+          fc.nat(),
+          fc.integer({ min: 1, max: 12 }),
+          (
+            caller,
+            version,
+            hashbytes,
+            amount_ustx,
+            first_rew_cycle,
+            num_cycles
+          ) => {
+            // Arrange
+
+            const { result: pox_4_info } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_POX_INFO,
+              [],
+              caller
+            );
+            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+            const expectedResponseOk = true;
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              MINIMAL_CAN_STACK_STX,
+              [
+                Cl.tuple({
+                  version: Cl.buffer(Uint8Array.from([version])),
+                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+                }),
+                Cl.uint(amount_ustx),
+                Cl.uint(first_rew_cycle),
+                Cl.uint(num_cycles),
+              ],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.ResponseOk));
+            assert(isClarityType(actual.value, ClarityType.BoolTrue));
+            expect(actual).toBeOk(Cl.bool(expectedResponseOk));
+          }
+        )
+      );
+    });
+
+    it("should return (err 13) minimal-can-stack-stx for pox addresses having version > 6", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.integer({
+            min: 7,
+            max: 255,
+          }),
+          fc.array(fc.nat({ max: 255 }), {
+            minLength: 32,
+            maxLength: 32,
+          }),
+          fc.bigInt({
+            min: MIN_AMOUNT_USTX,
+            max: MAX_CLAR_UINT,
+          }),
+          fc.nat(),
+          fc.integer({ min: 1, max: 12 }),
+          (
+            caller,
+            version,
+            hashbytes,
+            amount_ustx,
+            first_rew_cycle,
+            num_cycles
+          ) => {
+            // Arrange
+            const { result: pox_4_info } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_POX_INFO,
+              [],
+              caller
+            );
+            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+            const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              MINIMAL_CAN_STACK_STX,
+              [
+                Cl.tuple({
+                  version: Cl.buffer(Uint8Array.from([version])),
+                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+                }),
+                Cl.uint(amount_ustx),
+                Cl.uint(first_rew_cycle),
+                Cl.uint(num_cycles),
+              ],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.ResponseErr));
+            assert(isClarityType(actual.value, ClarityType.Int));
+            expect(actual).toBeErr(Cl.int(expectedResponseErr));
+          }
+        )
+      );
+    });
+
+    it("should return (err 13) minimal-can-stack-stx for versions 0-4 pox addresses having hasbytes longer than 20", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.integer({ min: 0, max: 4 }),
+          fc.array(fc.nat({ max: 255 }), {
+            minLength: 21,
+            maxLength: 32,
+          }),
+          fc.bigInt({
+            min: MIN_AMOUNT_USTX,
+            max: MAX_CLAR_UINT,
+          }),
+          fc.nat(),
+          fc.integer({ min: 1, max: 12 }),
+          (
+            caller,
+            version,
+            hashbytes,
+            amount_ustx,
+            first_rew_cycle,
+            num_cycles
+          ) => {
+            // Arrange
+            const { result: pox_4_info } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_POX_INFO,
+              [],
+              caller
+            );
+            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+            const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              MINIMAL_CAN_STACK_STX,
+              [
+                Cl.tuple({
+                  version: Cl.buffer(Uint8Array.from([version])),
+                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+                }),
+                Cl.uint(amount_ustx),
+                Cl.uint(first_rew_cycle),
+                Cl.uint(num_cycles),
+              ],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.ResponseErr));
+            assert(isClarityType(actual.value, ClarityType.Int));
+            expect(actual).toBeErr(Cl.int(expectedResponseErr));
+          }
+        )
+      );
+    });
+
+    it("should return (err 13) minimal-can-stack-stx for versions 0-4 pox addresses having hasbytes shorter than 20", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.integer({ min: 0, max: 4 }),
+          fc.array(fc.nat({ max: 255 }), {
+            maxLength: 19,
+          }),
+          fc.bigInt({
+            min: MIN_AMOUNT_USTX,
+            max: MAX_CLAR_UINT,
+          }),
+          fc.nat(),
+          fc.integer({ min: 1, max: 12 }),
+          (
+            caller,
+            version,
+            hashbytes,
+            amount_ustx,
+            first_rew_cycle,
+            num_cycles
+          ) => {
+            // Arrange
+            const { result: pox_4_info } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_POX_INFO,
+              [],
+              caller
+            );
+            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+            const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              MINIMAL_CAN_STACK_STX,
+              [
+                Cl.tuple({
+                  version: Cl.buffer(Uint8Array.from([version])),
+                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+                }),
+                Cl.uint(amount_ustx),
+                Cl.uint(first_rew_cycle),
+                Cl.uint(num_cycles),
+              ],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.ResponseErr));
+            assert(isClarityType(actual.value, ClarityType.Int));
+            expect(actual).toBeErr(Cl.int(expectedResponseErr));
+          }
+        )
+      );
+    });
+
+    it("should return (err 13) minimal-can-stack-stx for versions 5/6 pox addresses having hashbytes shorter than 32", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.integer({ min: 0, max: 4 }),
+          fc.array(fc.nat({ max: 255 }), {
+            maxLength: 31,
+          }),
+          fc.bigInt({
+            min: MIN_AMOUNT_USTX,
+            max: MAX_CLAR_UINT,
+          }),
+          fc.nat(),
+          fc.integer({ min: 1, max: 12 }),
+          (
+            caller,
+            version,
+            hashbytes,
+            amount_ustx,
+            first_rew_cycle,
+            num_cycles
+          ) => {
+            // Arrange
+            const { result: pox_4_info } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_POX_INFO,
+              [],
+              caller
+            );
+            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+            const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              MINIMAL_CAN_STACK_STX,
+              [
+                Cl.tuple({
+                  version: Cl.buffer(Uint8Array.from([version])),
+                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+                }),
+                Cl.uint(amount_ustx),
+                Cl.uint(first_rew_cycle),
+                Cl.uint(num_cycles),
+              ],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.ResponseErr));
+            assert(isClarityType(actual.value, ClarityType.Int));
+            expect(actual).toBeErr(Cl.int(expectedResponseErr));
+          }
+        )
+      );
+    });
+
+    it("should return (err 2) minimal-can-stack-stx for lock period > 12", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.integer({ min: 0, max: 6 }),
+          fc.array(fc.nat({ max: 255 })),
+          fc.bigInt({
+            min: MIN_AMOUNT_USTX,
+            max: MAX_CLAR_UINT,
+          }),
+          fc.nat(),
+          fc.integer({ min: 13 }),
+          (
+            caller,
+            version,
+            hashbytes,
+            amount_ustx,
+            first_rew_cycle,
+            num_cycles
+          ) => {
+            // Arrange
+            const { result: pox_4_info } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_POX_INFO,
+              [],
+              caller
+            );
+            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+            const expectedResponseErr = ERR_STACKING_INVALID_LOCK_PERIOD;
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              MINIMAL_CAN_STACK_STX,
+              [
+                Cl.tuple({
+                  version: Cl.buffer(Uint8Array.from([version])),
+                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+                }),
+                Cl.uint(amount_ustx),
+                Cl.uint(first_rew_cycle),
+                Cl.uint(num_cycles),
+              ],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.ResponseErr));
+            assert(isClarityType(actual.value, ClarityType.Int));
+            expect(actual).toBeErr(Cl.int(expectedResponseErr));
+          }
+        )
+      );
+    });
+
+    it("should return (err 18) minimal-can-stack-stx for amount == 0", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.integer({ min: 0, max: 6 }),
+          fc.array(fc.nat({ max: 255 }), { maxLength: 32 }),
+          fc.nat(),
+          fc.integer({ min: 1, max: 12 }),
+          (caller, version, hashbytes, first_rew_cycle, num_cycles) => {
+            // Arrange
+            const amount_ustx = 0;
+
+            const { result: pox_4_info } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_POX_INFO,
+              [],
+              caller
+            );
+            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+            const expectedResponseErr = ERR_STACKING_INVALID_AMOUNT;
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              MINIMAL_CAN_STACK_STX,
+              [
+                Cl.tuple({
+                  version: Cl.buffer(Uint8Array.from([version])),
+                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+                }),
+                Cl.uint(amount_ustx),
+                Cl.uint(first_rew_cycle),
+                Cl.uint(num_cycles),
+              ],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.ResponseErr));
+            assert(isClarityType(actual.value, ClarityType.Int));
+            expect(actual).toBeErr(Cl.int(expectedResponseErr));
+          }
+        )
+      );
+    });
+
+    it("should return none get-check-delegation", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          (caller) => {
+            // Arrange
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_CHECK_DELEGATION,
+              [Cl.principal(caller)],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.OptionalNone));
+          }
+        )
+      );
+    });
+
+    it("should return none get-delegation-info", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          (caller) => {
+            // Arrange
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_DELEGATION_INFO,
+              [Cl.principal(caller)],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.OptionalNone));
+          }
+        )
+      );
+    });
+
+    it("should return correct get-pox-info", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          (caller) => {
+            // Arrange
+            const expected_reward_cycle_id = 0,
+              expected_first_burn_block_height = 0;
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_POX_INFO,
+              [],
+              caller
+            );
+            // Assert
+            assert(isClarityType(actual, ClarityType.ResponseOk));
+            assert(isClarityType(actual.value, ClarityType.Tuple));
+            expect(actual.value.data["first-burnchain-block-height"]).toBeUint(
+              expected_first_burn_block_height
+            );
+            expect(actual.value.data["min-amount-ustx"]).toBeUint(
+              MIN_AMOUNT_USTX
+            );
+            expect(actual.value.data["prepare-cycle-length"]).toBeUint(
+              TESTNET_PREPARE_CYCLE_LENGTH
+            );
+            expect(actual.value.data["reward-cycle-id"]).toBeUint(
+              expected_reward_cycle_id
+            );
+            expect(actual.value.data["reward-cycle-length"]).toBeUint(
+              TESTNET_REWARD_CYCLE_LENGTH
+            );
+            expect(actual.value.data["total-liquid-supply-ustx"]).toBeUint(
+              INITIAL_TOTAL_LIQ_SUPPLY
+            );
+          }
+        )
+      );
+    });
+
+    it("should return none get-allowance-contract-caller", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.constantFrom(...simnet.getAccounts().values()),
+          (caller, sender, contract_caller) => {
+            // Arrange
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_ALLOWANCE_CONTRACT_CALLERS,
+              [Cl.principal(sender), Cl.principal(contract_caller)],
+              caller
+            );
+            // Assert
+            assert(isClarityType(actual, ClarityType.OptionalNone));
+          }
+        )
+      );
+    });
+
+    it("should return some get-allowance-contract-caller after allow-contract-caller", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.constantFrom(...simnet.getAccounts().values()),
+          (caller, sender, contract_caller) => {
+            // Arrange
+            const { result: allow } = simnet.callPublicFn(
+              POX_4,
+              ALLOW_CONTRACT_CALLER,
+              [Cl.principal(contract_caller), Cl.none()],
+              sender
+            );
+
+            assert(isClarityType(allow, ClarityType.ResponseOk));
+            assert(isClarityType(allow.value, ClarityType.BoolTrue));
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_ALLOWANCE_CONTRACT_CALLERS,
+              [Cl.principal(sender), Cl.principal(contract_caller)],
+              caller
+            );
+            // Assert
+            assert(isClarityType(actual, ClarityType.OptionalSome));
+            assert(isClarityType(actual.value, ClarityType.Tuple));
+            expect(actual.value).toBeTuple({ "until-burn-ht": Cl.none() });
+          }
+        )
+      );
+    });
+
+    // get-signer-key-message-hash
+    // verify-signer-key-sig
+    // get-num-reward-set-pox-addresses
+    // get-partial-stacked-by-cycle
   });
 });

From 18d0ec6e91d70b2c10ddceb4987823c560a9b58a Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Thu, 29 Feb 2024 13:29:14 -0500
Subject: [PATCH 1042/1166] chore: Reduce `BTreeMap` lookups in
 `TupleData::from_data()`

---
 clarity/src/vm/types/mod.rs | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/clarity/src/vm/types/mod.rs b/clarity/src/vm/types/mod.rs
index 1c25e1c380..6a988fd59a 100644
--- a/clarity/src/vm/types/mod.rs
+++ b/clarity/src/vm/types/mod.rs
@@ -19,9 +19,11 @@ pub mod serialization;
 #[allow(clippy::result_large_err)]
 pub mod signatures;
 
+use std::collections::btree_map::Entry;
 use std::collections::BTreeMap;
 use std::{char, cmp, fmt, str};
 
+use hashbrown::hash_map::OccupiedEntry;
 use regex::Regex;
 use stacks_common::address::c32;
 use stacks_common::types::chainstate::StacksAddress;
@@ -1527,11 +1529,11 @@ impl TupleData {
         let mut data_map = BTreeMap::new();
         for (name, value) in data.into_iter() {
             let type_info = TypeSignature::type_of(&value)?;
-            if type_map.contains_key(&name) {
-                return Err(CheckErrors::NameAlreadyUsed(name.into()).into());
-            } else {
-                type_map.insert(name.clone(), type_info);
-            }
+            let entry = type_map.entry(name.clone());
+            match entry {
+                Entry::Vacant(e) => e.insert(type_info),
+                Entry::Occupied(_) => return Err(CheckErrors::NameAlreadyUsed(name.into()).into()),
+            };
             data_map.insert(name, value);
         }
 

From 7312618d6027ac9d88710f1bb2a0531fdb1c923b Mon Sep 17 00:00:00 2001
From: BowTiedDevOps <157840260+BowTiedDevOps@users.noreply.github.com>
Date: Wed, 6 Mar 2024 20:03:14 +0200
Subject: [PATCH 1043/1166] feat: move release dockerfiles to composite

---
 .github/workflows/create-source-binary.yml | 64 ++++++++++------------
 build-scripts/Dockerfile.linux-glibc-arm64 | 26 ---------
 build-scripts/Dockerfile.linux-glibc-armv7 | 26 ---------
 build-scripts/Dockerfile.linux-glibc-x64   | 26 ---------
 build-scripts/Dockerfile.linux-musl-arm64  | 22 --------
 build-scripts/Dockerfile.linux-musl-armv7  | 21 -------
 build-scripts/Dockerfile.linux-musl-x64    | 27 ---------
 build-scripts/Dockerfile.macos-arm64       | 30 ----------
 build-scripts/Dockerfile.macos-x64         | 32 -----------
 build-scripts/Dockerfile.windows-x64       | 27 ---------
 build-scripts/build-dist.sh                | 45 ---------------
 11 files changed, 29 insertions(+), 317 deletions(-)
 delete mode 100644 build-scripts/Dockerfile.linux-glibc-arm64
 delete mode 100644 build-scripts/Dockerfile.linux-glibc-armv7
 delete mode 100644 build-scripts/Dockerfile.linux-glibc-x64
 delete mode 100644 build-scripts/Dockerfile.linux-musl-arm64
 delete mode 100644 build-scripts/Dockerfile.linux-musl-armv7
 delete mode 100644 build-scripts/Dockerfile.linux-musl-x64
 delete mode 100644 build-scripts/Dockerfile.macos-arm64
 delete mode 100644 build-scripts/Dockerfile.macos-x64
 delete mode 100644 build-scripts/Dockerfile.windows-x64
 delete mode 100755 build-scripts/build-dist.sh

diff --git a/.github/workflows/create-source-binary.yml b/.github/workflows/create-source-binary.yml
index 068170efc5..e367292ee5 100644
--- a/.github/workflows/create-source-binary.yml
+++ b/.github/workflows/create-source-binary.yml
@@ -9,12 +9,6 @@ on:
         description: "Tag name of this release (x.y.z)"
         required: true
         type: string
-      arch:
-        description: "Stringified JSON object listing of platform matrix"
-        required: false
-        type: string
-        default: >-
-          ["linux-glibc-arm64", "linux-glibc-armv7", "linux-musl-arm64", "linux-musl-armv7"]
 
 ## change the display name to the tag being built
 run-name: ${{ inputs.tag }}
@@ -30,7 +24,7 @@ jobs:
   ##  - workflow is building default branch (master)
   artifact:
     if: |
-      inputs.tag != '' && 
+      inputs.tag != '' &&
       github.ref == format('refs/heads/{0}', github.event.repository.default_branch)
     name: Build Binaries
     runs-on: ubuntu-latest
@@ -38,33 +32,33 @@ jobs:
       ## Run a maximum of 10 builds concurrently, using the matrix defined in inputs.arch
       max-parallel: 10
       matrix:
-        platform: ${{ fromJson(inputs.arch) }}
+        arch:
+          - linux-musl
+          - linux-glibc
+          - macos
+          - windows
+        cpu:
+          - arm64
+          - armv7
+          - x86-64 # defaults to x86-64-v3 variant - intel haswell (2013) and newer
+          # - x86-64-v2 ## intel nehalem (2008) and newer
+          # - x86-64-v3 ## intel haswell (2013) and newer
+          # - x86-64-v4 ## intel skylake (2017) and newer
+        exclude:
+          - arch: windows # excludes windows-arm64
+            cpu: arm64
+          - arch: windows # excludes windows-armv7
+            cpu: armv7
+          - arch: macos # excludes macos-armv7
+            cpu: armv7
+    env:
+      TEST_TIMEOUT: 30
     steps:
-      ## Setup Docker for the builds
-      - name: Docker setup
-        uses: stacks-network/actions/docker@main
-
-      ## Build the binaries using defined dockerfiles
-      - name: Build Binary (${{ matrix.platform }})
-        id: build_binaries
-        uses: docker/build-push-action@0565240e2d4ab88bba5387d719585280857ece09 # 5.0.0
-        with:
-          file: build-scripts/Dockerfile.${{ matrix.platform }}
-          outputs: type=local,dest=./release/${{ matrix.platform }}
-          build-args: |
-            STACKS_NODE_VERSION=${{ inputs.tag || env.GITHUB_SHA_SHORT }}
-            OS_ARCH=${{ matrix.platform }}
-            GIT_BRANCH=${{ env.GITHUB_REF_SHORT }}
-            GIT_COMMIT=${{ env.GITHUB_SHA_SHORT }}
-
-      ## Compress the binary artifact
-      - name: Compress artifact
-        id: compress_artifact
-        run: zip --junk-paths ${{ matrix.platform }} ./release/${{ matrix.platform }}/*
-
-      ## Upload the binary artifact to the github action (used in `github-release.yml` to create a release)
-      - name: Upload artifact
-        id: upload_artifact
-        uses: actions/upload-artifact@a8a3f3ad30e3422c9c7b888a15615d19a852ae32 # v3.1.3
+      - name: Build Binary (${{ matrix.arch }}_${{ matrix.cpu }})
+        id: build_binary
+        timeout-minutes: ${{ fromJSON(env.TEST_TIMEOUT) }}
+        uses: stacks-network/actions/stacks-core/create-source-binary@main
         with:
-          path: ${{ matrix.platform }}.zip
+          arch: ${{ matrix.arch }}
+          cpu: ${{ matrix.cpu }}
+          tag: ${{ inputs.tag }}
diff --git a/build-scripts/Dockerfile.linux-glibc-arm64 b/build-scripts/Dockerfile.linux-glibc-arm64
deleted file mode 100644
index 11e38f8804..0000000000
--- a/build-scripts/Dockerfile.linux-glibc-arm64
+++ /dev/null
@@ -1,26 +0,0 @@
-FROM rust:bullseye as build
-
-ARG STACKS_NODE_VERSION="No Version Info"
-ARG GIT_BRANCH='No Branch Info'
-ARG GIT_COMMIT='No Commit Info'
-ARG BUILD_DIR=/build
-ARG TARGET=aarch64-unknown-linux-gnu
-WORKDIR /src
-
-COPY . .
-
-RUN apt-get update && apt-get install -y git gcc-aarch64-linux-gnu
-
-# Run all the build steps in ramdisk in an attempt to speed things up
-RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
-    && cd ${BUILD_DIR} \
-    && rustup target add ${TARGET} \
-    && CC=aarch64-linux-gnu-gcc \
-    CC_aarch64_unknown_linux_gnu=aarch64-linux-gnu-gcc \
-    CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER=aarch64-linux-gnu-gcc \
-    cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli \
-    && mkdir -p /out \
-    && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
-
-FROM scratch AS export-stage
-COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
diff --git a/build-scripts/Dockerfile.linux-glibc-armv7 b/build-scripts/Dockerfile.linux-glibc-armv7
deleted file mode 100644
index cc05298dfe..0000000000
--- a/build-scripts/Dockerfile.linux-glibc-armv7
+++ /dev/null
@@ -1,26 +0,0 @@
-FROM rust:bullseye as build
-
-ARG STACKS_NODE_VERSION="No Version Info"
-ARG GIT_BRANCH='No Branch Info'
-ARG GIT_COMMIT='No Commit Info'
-ARG BUILD_DIR=/build
-ARG TARGET=armv7-unknown-linux-gnueabihf
-WORKDIR /src
-
-COPY . .
-
-RUN apt-get update && apt-get install -y git gcc-arm-linux-gnueabihf
-
-# Run all the build steps in ramdisk in an attempt to speed things up
-RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
-    && cd ${BUILD_DIR} \
-    && rustup target add ${TARGET} \
-    && CC=arm-linux-gnueabihf-gcc \
-    CC_armv7_unknown_linux_gnueabihf=arm-linux-gnueabihf-gcc \
-    CARGO_TARGET_ARMV7_UNKNOWN_LINUX_GNUEABIHF_LINKER=arm-linux-gnueabihf-gcc \
-    cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli \
-    && mkdir -p /out \
-    && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
-
-FROM scratch AS export-stage
-COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
diff --git a/build-scripts/Dockerfile.linux-glibc-x64 b/build-scripts/Dockerfile.linux-glibc-x64
deleted file mode 100644
index 0e2bbdd9be..0000000000
--- a/build-scripts/Dockerfile.linux-glibc-x64
+++ /dev/null
@@ -1,26 +0,0 @@
-FROM rust:bullseye as build
-
-ARG STACKS_NODE_VERSION="No Version Info"
-ARG GIT_BRANCH='No Branch Info'
-ARG GIT_COMMIT='No Commit Info'
-ARG BUILD_DIR=/build
-ARG TARGET=x86_64-unknown-linux-gnu
-# Allow us to override the default `--target-cpu` for the given target triplet
-ARG TARGET_CPU
-WORKDIR /src
-
-COPY . .
-
-RUN apt-get update && apt-get install -y git
-
-# Run all the build steps in ramdisk in an attempt to speed things up
-RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
-    && cd ${BUILD_DIR} \
-    && rustup target add ${TARGET} \
-    ${TARGET_CPU:+RUSTFLAGS="$RUSTFLAGS $TARGET_CPU"} \
-    cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli \
-    && mkdir -p /out \
-    && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
-
-FROM scratch AS export-stage
-COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
diff --git a/build-scripts/Dockerfile.linux-musl-arm64 b/build-scripts/Dockerfile.linux-musl-arm64
deleted file mode 100644
index 24a07f018a..0000000000
--- a/build-scripts/Dockerfile.linux-musl-arm64
+++ /dev/null
@@ -1,22 +0,0 @@
-FROM messense/rust-musl-cross:aarch64-musl as build
-
-ARG STACKS_NODE_VERSION="No Version Info"
-ARG GIT_BRANCH='No Branch Info'
-ARG GIT_COMMIT='No Commit Info'
-ARG BUILD_DIR=/build
-ARG TARGET=aarch64-unknown-linux-musl
-WORKDIR /src
-
-COPY . .
-
-# Run all the build steps in ramdisk in an attempt to speed things up
-RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
-    && cd ${BUILD_DIR} \
-    && rustup target add ${TARGET} \
-    && cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli \
-    && mkdir -p /out \
-    && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
-
-FROM scratch AS export-stage
-COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
-
diff --git a/build-scripts/Dockerfile.linux-musl-armv7 b/build-scripts/Dockerfile.linux-musl-armv7
deleted file mode 100644
index 2ce5a99912..0000000000
--- a/build-scripts/Dockerfile.linux-musl-armv7
+++ /dev/null
@@ -1,21 +0,0 @@
-FROM messense/rust-musl-cross:armv7-musleabihf as build
-
-ARG STACKS_NODE_VERSION="No Version Info"
-ARG GIT_BRANCH='No Branch Info'
-ARG GIT_COMMIT='No Commit Info'
-ARG BUILD_DIR=/build
-ARG TARGET=armv7-unknown-linux-musleabihf
-WORKDIR /src
-
-COPY . .
-
-# Run all the build steps in ramdisk in an attempt to speed things up
-RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
-    && cd ${BUILD_DIR} \
-    && rustup target add ${TARGET} \
-    && cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli \
-    && mkdir -p /out \
-    && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
-
-FROM scratch AS export-stage
-COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
diff --git a/build-scripts/Dockerfile.linux-musl-x64 b/build-scripts/Dockerfile.linux-musl-x64
deleted file mode 100644
index d954708a0a..0000000000
--- a/build-scripts/Dockerfile.linux-musl-x64
+++ /dev/null
@@ -1,27 +0,0 @@
-FROM rust:alpine as build
-
-ARG STACKS_NODE_VERSION="No Version Info"
-ARG GIT_BRANCH='No Branch Info'
-ARG GIT_COMMIT='No Commit Info'
-ARG BUILD_DIR=/build
-ARG TARGET=x86_64-unknown-linux-musl
-# Allow us to override the default `--target-cpu` for the given target triplet
-ARG TARGET_CPU
-WORKDIR /src
-
-COPY . .
-
-RUN apk update && apk add git musl-dev
-
-# Run all the build steps in ramdisk in an attempt to speed things up
-RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
-    && cd ${BUILD_DIR} \
-    && rustup target add ${TARGET} \
-    ${TARGET_CPU:+RUSTFLAGS="$RUSTFLAGS $TARGET_CPU"} \
-    cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli \
-    && mkdir -p /out \
-    && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
-
-FROM scratch AS export-stage
-COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
-
diff --git a/build-scripts/Dockerfile.macos-arm64 b/build-scripts/Dockerfile.macos-arm64
deleted file mode 100644
index 0fd8a1e4c3..0000000000
--- a/build-scripts/Dockerfile.macos-arm64
+++ /dev/null
@@ -1,30 +0,0 @@
-FROM rust:bullseye as build
-
-ARG STACKS_NODE_VERSION="No Version Info"
-ARG GIT_BRANCH='No Branch Info'
-ARG GIT_COMMIT='No Commit Info'
-ARG BUILD_DIR=/build
-ARG OSXCROSS="https://github.com/hirosystems/docker-osxcross-rust/releases/download/MacOSX12.0.sdk/osxcross-d904031_MacOSX12.0.sdk.tar.zst"
-ARG TARGET=aarch64-apple-darwin
-WORKDIR /src
-
-COPY . .
-
-RUN apt-get update && apt-get install -y clang zstd
-
-# Retrieve and install osxcross 
-RUN wget -nc -O /tmp/osxcross.tar.zst ${OSXCROSS} \
-    && mkdir -p /opt/osxcross && tar -xaf /tmp/osxcross.tar.zst -C /opt/osxcross
-
-# Run all the build steps in ramdisk in an attempt to speed things up
-RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
-    && cd ${BUILD_DIR} \
-    && rustup target add ${TARGET} \
-    && . /opt/osxcross/env-macos-aarch64 \
-    && cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli \
-    && mkdir -p /out \
-    && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
-
-FROM scratch AS export-stage
-COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
-
diff --git a/build-scripts/Dockerfile.macos-x64 b/build-scripts/Dockerfile.macos-x64
deleted file mode 100644
index f61d0574e9..0000000000
--- a/build-scripts/Dockerfile.macos-x64
+++ /dev/null
@@ -1,32 +0,0 @@
-FROM rust:bullseye as build
-
-ARG STACKS_NODE_VERSION="No Version Info"
-ARG GIT_BRANCH='No Branch Info'
-ARG GIT_COMMIT='No Commit Info'
-ARG BUILD_DIR=/build
-ARG OSXCROSS="https://github.com/hirosystems/docker-osxcross-rust/releases/download/MacOSX12.0.sdk/osxcross-d904031_MacOSX12.0.sdk.tar.zst"
-ARG TARGET=x86_64-apple-darwin
-ARG TARGET_CPU
-WORKDIR /src
-
-COPY . .
-
-RUN apt-get update && apt-get install -y clang zstd
-
-# Retrieve and install osxcross 
-RUN wget -nc -O /tmp/osxcross.tar.zst ${OSXCROSS} \
-    && mkdir -p /opt/osxcross && tar -xaf /tmp/osxcross.tar.zst -C /opt/osxcross
-
-# Run all the build steps in ramdisk in an attempt to speed things up
-RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
-    && cd ${BUILD_DIR} \
-    && rustup target add ${TARGET} \
-    && . /opt/osxcross/env-macos-x86_64 \
-    ${TARGET_CPU:+RUSTFLAGS="$RUSTFLAGS $TARGET_CPU"} \
-    cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli \
-    && mkdir -p /out \
-    && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
-
-FROM scratch AS export-stage
-COPY --from=build /out/stacks-inspect /out/blockstack-cli /out/clarity-cli /out/stacks-node /
-
diff --git a/build-scripts/Dockerfile.windows-x64 b/build-scripts/Dockerfile.windows-x64
deleted file mode 100644
index 3265c05b5c..0000000000
--- a/build-scripts/Dockerfile.windows-x64
+++ /dev/null
@@ -1,27 +0,0 @@
-FROM rust:bullseye as build
-
-ARG STACKS_NODE_VERSION="No Version Info"
-ARG GIT_BRANCH='No Branch Info'
-ARG GIT_COMMIT='No Commit Info'
-ARG BUILD_DIR=/build
-ARG TARGET=x86_64-pc-windows-gnu
-ARG TARGET_CPU
-WORKDIR /src
-
-COPY . .
-
-RUN apt-get update && apt-get install -y git gcc-mingw-w64-x86-64
-
-# Run all the build steps in ramdisk in an attempt to speed things up
-RUN --mount=type=tmpfs,target=${BUILD_DIR} cp -R /src/. ${BUILD_DIR}/ \
-    && cd ${BUILD_DIR} \
-    && rustup target add ${TARGET} \
-    && CC_x86_64_pc_windows_gnu=x86_64-w64-mingw32-gcc \
-    CARGO_TARGET_X86_64_PC_WINDOWS_GNU_LINKER=x86_64-w64-mingw32-gcc \
-    ${TARGET_CPU:+RUSTFLAGS="$RUSTFLAGS $TARGET_CPU"} \
-    cargo build --features monitoring_prom,slog_json --release --workspace --target ${TARGET} --bin stacks-node --bin stacks-inspect --bin clarity-cli --bin blockstack-cli \
-    && mkdir -p /out \
-    && cp -R ${BUILD_DIR}/target/${TARGET}/release/. /out
-
-FROM scratch AS export-stage
-COPY --from=build /out/stacks-inspect.exe /out/blockstack-cli.exe /out/clarity-cli.exe /out/stacks-node.exe /
diff --git a/build-scripts/build-dist.sh b/build-scripts/build-dist.sh
deleted file mode 100755
index 8be8f4f8a7..0000000000
--- a/build-scripts/build-dist.sh
+++ /dev/null
@@ -1,45 +0,0 @@
-#!/bin/bash
-
-set -e
-
-script_path="$(dirname "$0")"
-src_dir="$(dirname "$script_path")"
-cd "$src_dir"
-
-build_platform () {
-  echo "Building $1"
-  rm -rf dist/$1
-  DOCKER_BUILDKIT=1 docker build --progress=plain -o dist/$1 -f ./build-scripts/Dockerfile.$1 .
-}
-
-case $DIST_TARGET_FILTER in
-  (*[![:blank:]]*)
-    case $DIST_TARGET_FILTER in
-      linux-glibc-x64)      build_platform linux-glibc-x64 ;;
-      linux-glibc-arm64)    build_platform linux-glibc-arm64 ;;
-      linux-glibc-armv7)    build_platform linux-glibc-armv7 ;;
-      linux-musl-x64)       build_platform linux-musl-x64 ;;
-      linux-musl-arm64)     build_platform linux-musl-arm64 ;;
-      linux-musl-armv7)     build_platform linux-musl-armv7 ;;
-      windows-x64)          build_platform windows-x64 ;;
-      macos-x64)            build_platform macos-x64 ;;
-      macos-arm64)          build_platform macos-arm64 ;;
-      *)
-        echo "Invalid dist target filter '$DIST_TARGET_FILTER'"
-        exit 1
-        ;;
-    esac
-    ;;
-  (*)
-    echo "Building distrubtions for all targets."
-    build_platform linux-glibc-x64
-    build_platform linux-glibc-arm64
-    build_platform linux-glibc-armv7
-    build_platform linux-musl-x64
-    build_platform linux-musl-arm64
-    build_platform linux-musl-armv7
-    build_platform windows-x64
-    build_platform macos-x64
-    build_platform macos-arm64
-    ;;
-esac

From ceff67302eb6ac7d5b8ef1e0ec9c102936187b9f Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Wed, 6 Mar 2024 13:05:07 -0500
Subject: [PATCH 1044/1166] If the node fails to submit a block, do not
 unconditionally reattempt

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 testnet/stacks-node/src/neon_node.rs | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/testnet/stacks-node/src/neon_node.rs b/testnet/stacks-node/src/neon_node.rs
index 49064d4971..918a7f9c2d 100644
--- a/testnet/stacks-node/src/neon_node.rs
+++ b/testnet/stacks-node/src/neon_node.rs
@@ -516,6 +516,8 @@ pub(crate) struct BlockMinerThread {
     burn_block: BlockSnapshot,
     /// Handle to the node's event dispatcher
     event_dispatcher: EventDispatcher,
+    /// Failed to submit last attempted block
+    failed_to_submit_last_attempt: bool,
 }
 
 /// State representing the microblock miner.
@@ -1020,6 +1022,7 @@ impl BlockMinerThread {
             registered_key,
             burn_block,
             event_dispatcher: rt.event_dispatcher.clone(),
+            failed_to_submit_last_attempt: false,
         }
     }
 
@@ -1543,7 +1546,9 @@ impl BlockMinerThread {
             Self::find_inflight_mined_blocks(self.burn_block.block_height, &self.last_mined_blocks);
 
         // has the tip changed from our previously-mined block for this epoch?
-        let (attempt, max_txs) = if last_mined_blocks.len() <= 1 {
+        let should_unconditionally_mine = last_mined_blocks.is_empty()
+            || (last_mined_blocks.len() == 1 && self.failed_to_submit_last_attempt);
+        let (attempt, max_txs) = if should_unconditionally_mine {
             // always mine if we've not mined a block for this epoch yet, or
             // if we've mined just one attempt, unconditionally try again (so we
             // can use `subsequent_miner_time_ms` in this attempt)
@@ -2482,12 +2487,14 @@ impl BlockMinerThread {
 
         let res = bitcoin_controller.submit_operation(target_epoch_id, op, &mut op_signer, attempt);
         if res.is_none() {
+            self.failed_to_submit_last_attempt = true;
             if !self.config.node.mock_mining {
                 warn!("Relayer: Failed to submit Bitcoin transaction");
                 return None;
-            } else {
-                debug!("Relayer: Mock-mining enabled; not sending Bitcoin transaction");
             }
+            debug!("Relayer: Mock-mining enabled; not sending Bitcoin transaction");
+        } else {
+            self.failed_to_submit_last_attempt = false;
         }
 
         Some(MinerThreadResult::Block(

From 1ca367d7f05ee2ec8fcf693b278bf57b8c80c83b Mon Sep 17 00:00:00 2001
From: BowTiedRadone <bowtiedradone@gmail.com>
Date: Wed, 6 Mar 2024 20:14:27 +0200
Subject: [PATCH 1045/1166] added tests for get-num-reward-set-pox-addresses,
 get-partial-stacked-by-cycle

---
 .../tests/pox-4/pox-4.prop.test.ts            | 60 ++++++++++++++++++-
 1 file changed, 57 insertions(+), 3 deletions(-)

diff --git a/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts b/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
index 506ebd2864..d16dd76f1a 100644
--- a/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
+++ b/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
@@ -22,6 +22,8 @@ const MINIMAL_CAN_STACK_STX = "minimal-can-stack-stx";
 const GET_CHECK_DELEGATION = "get-check-delegation";
 const GET_DELEGATION_INFO = "get-delegation-info";
 const GET_ALLOWANCE_CONTRACT_CALLERS = "get-allowance-contract-callers";
+const GET_NUM_REWARD_SET_POX_ADDRESSES = "get-num-reward-set-pox-addresses";
+const GET_PARTIAL_STACKED_BY_CYCLE = "get-partial-stacked-by-cycle";
 const ALLOW_CONTRACT_CALLER = "allow-contract-caller";
 // Contract Consts
 const TESTNET_STACKING_THRESHOLD_25 = 8000;
@@ -1486,7 +1488,7 @@ describe("test pox-4 contract", () => {
       );
     });
 
-    it("should return some get-allowance-contract-caller after allow-contract-caller", () => {
+    it("should return some(until-burn-ht: none) get-allowance-contract-caller after allow-contract-caller", () => {
       fc.assert(
         fc.property(
           fc.constantFrom(...simnet.getAccounts().values()),
@@ -1519,9 +1521,61 @@ describe("test pox-4 contract", () => {
       );
     });
 
+    it("should return u0 get-num-reward-set-pox-addresses", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.nat(),
+          (caller, reward_cycle) => {
+            // Arrange
+            const expected = 0;
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_NUM_REWARD_SET_POX_ADDRESSES,
+              [Cl.uint(reward_cycle)],
+              caller
+            );
+            // Assert
+            assert(isClarityType(actual, ClarityType.UInt));
+            expect(actual).toBeUint(expected);
+          }
+        )
+      );
+    });
+
+    it("should return none get-partial-stacked-by-cycle", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.nat({ max: 6 }),
+          fc.array(fc.nat({ max: 255 }), { maxLength: 32 }),
+          fc.nat(),
+          fc.constantFrom(...simnet.getAccounts().values()),
+          (caller, version, hashbytes, reward_cycle, sender) => {
+            // Arrange
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_PARTIAL_STACKED_BY_CYCLE,
+              [
+                Cl.tuple({
+                  version: Cl.buffer(Uint8Array.from([version])),
+                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+                }),
+                Cl.uint(reward_cycle),
+                Cl.principal(sender),
+              ],
+              caller
+            );
+            // Assert
+            assert(isClarityType(actual, ClarityType.OptionalNone));
+          }
+        )
+      );
+    });
+
     // get-signer-key-message-hash
     // verify-signer-key-sig
-    // get-num-reward-set-pox-addresses
-    // get-partial-stacked-by-cycle
   });
 });

From 166d736c8ed5006176212be9e5774c1e8c68d548 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?M=C3=A5rten=20Blankfors?= <marten@blankfors.se>
Date: Wed, 6 Mar 2024 20:00:06 +0100
Subject: [PATCH 1046/1166] fix: Add db_path to build_signer_config_tomls and
 add a unit test for it

---
 stacks-signer/src/config.rs | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/stacks-signer/src/config.rs b/stacks-signer/src/config.rs
index a344bac5e6..e3e647c3d5 100644
--- a/stacks-signer/src/config.rs
+++ b/stacks-signer/src/config.rs
@@ -372,6 +372,7 @@ node_host = "{node_host}"
 endpoint = "{endpoint}"
 network = "{network}"
 auth_password = "{password}"
+db_path = ":memory:"
 "#
         );
 
@@ -390,3 +391,27 @@ event_timeout = {event_timeout_ms}
 
     signer_config_tomls
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn build_signer_config_tomls_should_produce_deserializable_strings() {
+        let pk = StacksPrivateKey::from_hex(
+            "eb05c83546fdd2c79f10f5ad5434a90dd28f7e3acb7c092157aa1bc3656b012c01",
+        )
+        .unwrap();
+
+        let node_host = "localhost";
+        let network = Network::Testnet;
+        let password = "melon";
+
+        let config_tomls = build_signer_config_tomls(&[pk], node_host, None, &network, password);
+
+        let config =
+            RawConfigFile::load_from_str(&config_tomls[0]).expect("Failed to parse config file");
+
+        assert_eq!(config.auth_password, "melon");
+    }
+}

From bc0858b4c17184a255fb92047d55fc3433396b9b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?M=C3=A5rten=20Blankfors?= <marten@blankfors.se>
Date: Wed, 6 Mar 2024 20:13:11 +0100
Subject: [PATCH 1047/1166] feat: Test signerdb with in-memory db

---
 stacks-signer/src/signerdb.rs | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

diff --git a/stacks-signer/src/signerdb.rs b/stacks-signer/src/signerdb.rs
index e97a0c0e5d..9b211a603d 100644
--- a/stacks-signer/src/signerdb.rs
+++ b/stacks-signer/src/signerdb.rs
@@ -176,9 +176,7 @@ mod tests {
         format!("/tmp/stacks-signer-test-{}.sqlite", rand::random::<u64>()).into()
     }
 
-    #[test]
-    fn test_basic_signer_db() {
-        let db_path = tmp_db_path();
+    fn test_basic_signer_db_with_path(db_path: impl AsRef<Path>) {
         let mut db = SignerDb::new(db_path).expect("Failed to create signer db");
         let (block_info, block) = create_block();
         db.insert_block(&block_info)
@@ -192,6 +190,17 @@ mod tests {
         assert_eq!(BlockInfo::new(block.clone()), block_info);
     }
 
+    #[test]
+    fn test_basic_signer_db() {
+        let db_path = tmp_db_path();
+        test_basic_signer_db_with_path(db_path)
+    }
+
+    #[test]
+    fn test_basic_signer_db_in_memory() {
+        test_basic_signer_db_with_path(":memory:")
+    }
+
     #[test]
     fn test_update_block() {
         let db_path = tmp_db_path();

From 6e3a1413b8cc023ba3e2f36a43e53e534a14c90d Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Wed, 6 Mar 2024 15:22:29 -0800
Subject: [PATCH 1048/1166] fix: use testnet consts when generating xenon
 config

---
 stackslib/src/core/mod.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/stackslib/src/core/mod.rs b/stackslib/src/core/mod.rs
index 45556adf7a..0f44d7af9a 100644
--- a/stackslib/src/core/mod.rs
+++ b/stackslib/src/core/mod.rs
@@ -374,14 +374,14 @@ lazy_static! {
         },
         StacksEpoch {
             epoch_id: StacksEpochId::Epoch25,
-            start_height: BITCOIN_MAINNET_STACKS_25_BURN_HEIGHT,
-            end_height: BITCOIN_MAINNET_STACKS_30_BURN_HEIGHT,
+            start_height: BITCOIN_TESTNET_STACKS_25_BURN_HEIGHT,
+            end_height: BITCOIN_TESTNET_STACKS_30_BURN_HEIGHT,
             block_limit: BLOCK_LIMIT_MAINNET_21.clone(),
             network_epoch: PEER_VERSION_EPOCH_2_5
         },
         StacksEpoch {
             epoch_id: StacksEpochId::Epoch30,
-            start_height: BITCOIN_MAINNET_STACKS_30_BURN_HEIGHT,
+            start_height: BITCOIN_TESTNET_STACKS_30_BURN_HEIGHT,
             end_height: STACKS_EPOCH_MAX,
             block_limit: BLOCK_LIMIT_MAINNET_21.clone(),
             network_epoch: PEER_VERSION_EPOCH_3_0

From 19c959f7b7f216150d3d1008668ac6562d68388f Mon Sep 17 00:00:00 2001
From: BowTiedRadone <bowtiedradone@gmail.com>
Date: Thu, 7 Mar 2024 14:09:12 +0200
Subject: [PATCH 1049/1166] added test for get-signer-key-message-hash and
 utils file

---
 .../tests/pox-4/pox-4-utils/utils.ts          |  58 +++++++
 .../tests/pox-4/pox-4.prop.test.ts            | 164 +++++++-----------
 2 files changed, 116 insertions(+), 106 deletions(-)
 create mode 100644 contrib/core-contract-tests/tests/pox-4/pox-4-utils/utils.ts

diff --git a/contrib/core-contract-tests/tests/pox-4/pox-4-utils/utils.ts b/contrib/core-contract-tests/tests/pox-4/pox-4-utils/utils.ts
new file mode 100644
index 0000000000..81164c3338
--- /dev/null
+++ b/contrib/core-contract-tests/tests/pox-4/pox-4-utils/utils.ts
@@ -0,0 +1,58 @@
+import { Cl, ClarityValue, serializeCV } from "@stacks/transactions";
+import { createHash } from "crypto";
+
+function sha256(data: Buffer): Buffer {
+  return createHash("sha256").update(data).digest();
+}
+
+function structuredDataHash(structuredData: ClarityValue): Buffer {
+  return sha256(Buffer.from(serializeCV(structuredData)));
+}
+
+const generateDomainHash = () =>
+  Cl.tuple({
+    name: Cl.stringAscii("pox-4-signer"),
+    version: Cl.stringAscii("1.0.0"),
+    "chain-id": Cl.uint(2147483648),
+  });
+
+const generateMessageHash = (
+  version: number,
+  hashbytes: number[],
+  reward_cycle: number,
+  topic: string,
+  period: number
+) =>
+  Cl.tuple({
+    "pox-addr": Cl.tuple({
+      version: Cl.buffer(Uint8Array.from([version])),
+      hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+    }),
+    "reward-cycle": Cl.uint(reward_cycle),
+    topic: Cl.stringAscii(topic),
+    period: Cl.uint(period),
+  });
+
+const generateMessagePrefixBuffer = (prefix: string) =>
+  Buffer.from(prefix, "hex");
+
+export const buildSignerKeyMessageHash = (
+  version: number,
+  hashbytes: number[],
+  reward_cycle: number,
+  topic: string,
+  period: number
+) => {
+  const sip018_msg_prefix = "534950303138";
+  const domain_hash = structuredDataHash(generateDomainHash());
+  const message_hash = structuredDataHash(
+    generateMessageHash(version, hashbytes, reward_cycle, topic, period)
+  );
+  const structuredDataPrefix = generateMessagePrefixBuffer(sip018_msg_prefix);
+
+  const signer_key_message_hash = sha256(
+    Buffer.concat([structuredDataPrefix, domain_hash, message_hash])
+  );
+
+  return signer_key_message_hash;
+};
diff --git a/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts b/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
index d16dd76f1a..b54eaafa5c 100644
--- a/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
+++ b/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
@@ -1,36 +1,39 @@
 import { Cl, ClarityType, isClarityType } from "@stacks/transactions";
 import { assert, describe, expect, it } from "vitest";
 import fc from "fast-check";
+import { buildSignerKeyMessageHash } from "./pox-4-utils/utils";
 
 // Contracts
 const POX_4 = "pox-4";
 // Methods
-const GET_POX_INFO = "get-pox-info";
-const GET_STACKER_INFO = "get-stacker-info";
-const REWARD_CYCLE_TO_BURN_HEIGHT = "reward-cycle-to-burn-height";
+const ALLOW_CONTRACT_CALLER = "allow-contract-caller";
 const BURN_HEIGHT_TO_REWARD_CYCLE = "burn-height-to-reward-cycle";
-const CURRENT_POX_REWARD_CYCLE = "current-pox-reward-cycle";
+const CAN_STACK_STX = "can-stack-stx";
 const CHECK_CALLER_ALLOWED = "check-caller-allowed";
-const GET_REWARD_SET_SIZE = "get-reward-set-size";
-const GET_REWARD_SET_POX_ADDRESS = "get-reward-set-pox-address";
-const GET_TOTAL_USTX_STACKED = "get-total-ustx-stacked";
 const CHECK_POX_ADDR_VERSION = "check-pox-addr-version";
 const CHECK_POX_LOCK_PERIOD = "check-pox-lock-period";
-const GET_STACKING_MINIMUM = "get-stacking-minimum";
-const CAN_STACK_STX = "can-stack-stx";
-const MINIMAL_CAN_STACK_STX = "minimal-can-stack-stx";
+const CURRENT_POX_REWARD_CYCLE = "current-pox-reward-cycle";
+const GET_ALLOWANCE_CONTRACT_CALLERS = "get-allowance-contract-callers";
 const GET_CHECK_DELEGATION = "get-check-delegation";
 const GET_DELEGATION_INFO = "get-delegation-info";
-const GET_ALLOWANCE_CONTRACT_CALLERS = "get-allowance-contract-callers";
 const GET_NUM_REWARD_SET_POX_ADDRESSES = "get-num-reward-set-pox-addresses";
 const GET_PARTIAL_STACKED_BY_CYCLE = "get-partial-stacked-by-cycle";
-const ALLOW_CONTRACT_CALLER = "allow-contract-caller";
+const GET_POX_INFO = "get-pox-info";
+const GET_REWARD_SET_POX_ADDRESS = "get-reward-set-pox-address";
+const GET_REWARD_SET_SIZE = "get-reward-set-size";
+const GET_SIGNER_KEY_MESSAGE_HASH = "get-signer-key-message-hash";
+const GET_STACKER_INFO = "get-stacker-info";
+const GET_STACKING_MINIMUM = "get-stacking-minimum";
+const GET_TOTAL_USTX_STACKED = "get-total-ustx-stacked";
+const MINIMAL_CAN_STACK_STX = "minimal-can-stack-stx";
+const REWARD_CYCLE_TO_BURN_HEIGHT = "reward-cycle-to-burn-height";
+const VERIFY_SIGNER_KEY_SIG = "verify-signer-key-sig";
 // Contract Consts
-const TESTNET_STACKING_THRESHOLD_25 = 8000;
-const TESTNET_REWARD_CYCLE_LENGTH = 1050;
-const TESTNET_PREPARE_CYCLE_LENGTH = 50;
 const INITIAL_TOTAL_LIQ_SUPPLY = 1_000_000_000_000_000;
 const MIN_AMOUNT_USTX = 125_000_000_000n;
+const TESTNET_PREPARE_CYCLE_LENGTH = 50;
+const TESTNET_REWARD_CYCLE_LENGTH = 1050;
+const TESTNET_STACKING_THRESHOLD_25 = 8000;
 // Clarity Constraints
 const MAX_CLAR_UINT = 340282366920938463463374607431768211455n;
 // Error Codes
@@ -56,12 +59,10 @@ describe("test pox-4 contract", () => {
             );
             assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
             assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
             const first_burn_block_height =
               pox_4_info.value.data["first-burnchain-block-height"];
             const reward_cycle_length =
               pox_4_info.value.data["reward-cycle-length"];
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -69,12 +70,10 @@ describe("test pox-4 contract", () => {
               [Cl.uint(reward_cycle)],
               account
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.UInt));
             assert(isClarityType(first_burn_block_height, ClarityType.UInt));
             assert(isClarityType(reward_cycle_length, ClarityType.UInt));
-
             const expected =
               Number(first_burn_block_height.value) +
               Number(reward_cycle_length.value) * reward_cycle;
@@ -99,12 +98,10 @@ describe("test pox-4 contract", () => {
             );
             assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
             assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
             const first_burn_block_height =
               pox_4_info.value.data["first-burnchain-block-height"];
             const reward_cycle_length =
               pox_4_info.value.data["reward-cycle-length"];
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -112,7 +109,6 @@ describe("test pox-4 contract", () => {
               [Cl.uint(burn_height)],
               account
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.UInt));
             assert(isClarityType(first_burn_block_height, ClarityType.UInt));
@@ -156,7 +152,6 @@ describe("test pox-4 contract", () => {
           fc.constantFrom(...simnet.getAccounts().values()),
           (stacker, caller) => {
             // Arrange
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -164,7 +159,6 @@ describe("test pox-4 contract", () => {
               [Cl.principal(stacker)],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.OptionalNone));
             expect(actual).toBeNone();
@@ -179,7 +173,6 @@ describe("test pox-4 contract", () => {
           fc.constantFrom(...simnet.getAccounts().values()),
           (caller) => {
             // Arrange
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -187,7 +180,6 @@ describe("test pox-4 contract", () => {
               [],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.BoolTrue));
             expect(actual).toBeBool(true);
@@ -204,7 +196,6 @@ describe("test pox-4 contract", () => {
           (caller, reward_cycle) => {
             // Arrange
             const expected = 0;
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -212,7 +203,6 @@ describe("test pox-4 contract", () => {
               [Cl.uint(reward_cycle)],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.UInt));
             expect(actual).toBeUint(expected);
@@ -229,7 +219,6 @@ describe("test pox-4 contract", () => {
           (caller, reward_cycle) => {
             // Arrange
             const expected = 0;
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -237,7 +226,6 @@ describe("test pox-4 contract", () => {
               [Cl.uint(reward_cycle)],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.UInt));
             expect(actual).toBeUint(expected);
@@ -254,7 +242,6 @@ describe("test pox-4 contract", () => {
           fc.nat(),
           (caller, index, reward_cycle) => {
             // Arrange
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -262,7 +249,6 @@ describe("test pox-4 contract", () => {
               [Cl.uint(index), Cl.uint(reward_cycle)],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.OptionalNone));
             expect(actual).toBeNone();
@@ -277,7 +263,6 @@ describe("test pox-4 contract", () => {
           fc.constantFrom(...simnet.getAccounts().values()),
           (caller) => {
             // Arrange
-
             const { result: pox_4_info } = simnet.callReadOnlyFn(
               POX_4,
               GET_POX_INFO,
@@ -286,15 +271,12 @@ describe("test pox-4 contract", () => {
             );
             assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
             assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
             const stx_liq_supply =
               pox_4_info.value.data["total-liquid-supply-ustx"];
-
             assert(isClarityType(stx_liq_supply, ClarityType.UInt));
             const expected = Math.floor(
               Number(stx_liq_supply.value) / TESTNET_STACKING_THRESHOLD_25
             );
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -302,7 +284,6 @@ describe("test pox-4 contract", () => {
               [],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.UInt));
             expect(actual).toBeUint(expected);
@@ -319,7 +300,6 @@ describe("test pox-4 contract", () => {
           (caller, version) => {
             // Arrange
             const expected = true;
-
             // Act
             let { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -327,7 +307,6 @@ describe("test pox-4 contract", () => {
               [Cl.buffer(Uint8Array.from([version]))],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.BoolTrue));
             expect(actual).toBeBool(expected);
@@ -344,7 +323,6 @@ describe("test pox-4 contract", () => {
           (caller, version) => {
             // Arrange
             const expected = false;
-
             // Act
             let { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -352,7 +330,6 @@ describe("test pox-4 contract", () => {
               [Cl.buffer(Uint8Array.from([version]))],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.BoolFalse));
             expect(actual).toBeBool(expected);
@@ -369,7 +346,6 @@ describe("test pox-4 contract", () => {
           (caller, reward_cycles) => {
             // Arrange
             const expected = true;
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -377,7 +353,6 @@ describe("test pox-4 contract", () => {
               [Cl.uint(reward_cycles)],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.BoolTrue));
             expect(actual).toBeBool(expected);
@@ -394,7 +369,6 @@ describe("test pox-4 contract", () => {
           (caller, reward_cycles) => {
             // Arrange
             const expected = false;
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -402,7 +376,6 @@ describe("test pox-4 contract", () => {
               [Cl.uint(reward_cycles)],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.BoolFalse));
             expect(actual).toBeBool(expected);
@@ -419,7 +392,6 @@ describe("test pox-4 contract", () => {
             // Arrange
             const reward_cycles = 0;
             const expected = false;
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -427,7 +399,6 @@ describe("test pox-4 contract", () => {
               [Cl.uint(reward_cycles)],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.BoolFalse));
             expect(actual).toBeBool(expected);
@@ -468,9 +439,7 @@ describe("test pox-4 contract", () => {
             );
             assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
             assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
             const expectedResponseOk = true;
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -486,7 +455,6 @@ describe("test pox-4 contract", () => {
               ],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.ResponseOk));
             assert(isClarityType(actual.value, ClarityType.BoolTrue));
@@ -520,7 +488,6 @@ describe("test pox-4 contract", () => {
             num_cycles
           ) => {
             // Arrange
-
             const { result: pox_4_info } = simnet.callReadOnlyFn(
               POX_4,
               GET_POX_INFO,
@@ -529,9 +496,7 @@ describe("test pox-4 contract", () => {
             );
             assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
             assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
             const expectedResponseOk = true;
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -547,7 +512,6 @@ describe("test pox-4 contract", () => {
               ],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.ResponseOk));
             assert(isClarityType(actual.value, ClarityType.BoolTrue));
@@ -592,9 +556,7 @@ describe("test pox-4 contract", () => {
             );
             assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
             assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
             const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -610,7 +572,6 @@ describe("test pox-4 contract", () => {
               ],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.ResponseErr));
             assert(isClarityType(actual.value, ClarityType.Int));
@@ -652,9 +613,7 @@ describe("test pox-4 contract", () => {
             );
             assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
             assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
             const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -670,7 +629,6 @@ describe("test pox-4 contract", () => {
               ],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.ResponseErr));
             assert(isClarityType(actual.value, ClarityType.Int));
@@ -711,9 +669,7 @@ describe("test pox-4 contract", () => {
             );
             assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
             assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
             const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -729,7 +685,6 @@ describe("test pox-4 contract", () => {
               ],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.ResponseErr));
             assert(isClarityType(actual.value, ClarityType.Int));
@@ -770,9 +725,7 @@ describe("test pox-4 contract", () => {
             );
             assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
             assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
             const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -788,7 +741,6 @@ describe("test pox-4 contract", () => {
               ],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.ResponseErr));
             assert(isClarityType(actual.value, ClarityType.Int));
@@ -827,9 +779,7 @@ describe("test pox-4 contract", () => {
             );
             assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
             assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
             const expectedResponseErr = ERR_STACKING_THRESHOLD_NOT_MET;
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -845,7 +795,6 @@ describe("test pox-4 contract", () => {
               ],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.ResponseErr));
             assert(isClarityType(actual.value, ClarityType.Int));
@@ -884,9 +833,7 @@ describe("test pox-4 contract", () => {
             );
             assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
             assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
             const expectedResponseErr = ERR_STACKING_INVALID_LOCK_PERIOD;
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -902,7 +849,6 @@ describe("test pox-4 contract", () => {
               ],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.ResponseErr));
             assert(isClarityType(actual.value, ClarityType.Int));
@@ -912,7 +858,6 @@ describe("test pox-4 contract", () => {
       );
     });
 
-    // minimal can stack stx
     it("should return (ok true) minimal-can-stack-stx for versions 0-4 valid pox addresses, hashbytes, amount, cycles number", () => {
       fc.assert(
         fc.property(
@@ -945,9 +890,7 @@ describe("test pox-4 contract", () => {
             );
             assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
             assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
             const expectedResponseOk = true;
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -963,7 +906,6 @@ describe("test pox-4 contract", () => {
               ],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.ResponseOk));
             assert(isClarityType(actual.value, ClarityType.BoolTrue));
@@ -997,7 +939,6 @@ describe("test pox-4 contract", () => {
             num_cycles
           ) => {
             // Arrange
-
             const { result: pox_4_info } = simnet.callReadOnlyFn(
               POX_4,
               GET_POX_INFO,
@@ -1006,9 +947,7 @@ describe("test pox-4 contract", () => {
             );
             assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
             assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
             const expectedResponseOk = true;
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -1024,7 +963,6 @@ describe("test pox-4 contract", () => {
               ],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.ResponseOk));
             assert(isClarityType(actual.value, ClarityType.BoolTrue));
@@ -1069,9 +1007,7 @@ describe("test pox-4 contract", () => {
             );
             assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
             assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
             const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -1087,7 +1023,6 @@ describe("test pox-4 contract", () => {
               ],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.ResponseErr));
             assert(isClarityType(actual.value, ClarityType.Int));
@@ -1129,9 +1064,7 @@ describe("test pox-4 contract", () => {
             );
             assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
             assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
             const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -1147,7 +1080,6 @@ describe("test pox-4 contract", () => {
               ],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.ResponseErr));
             assert(isClarityType(actual.value, ClarityType.Int));
@@ -1188,9 +1120,7 @@ describe("test pox-4 contract", () => {
             );
             assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
             assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
             const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -1206,7 +1136,6 @@ describe("test pox-4 contract", () => {
               ],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.ResponseErr));
             assert(isClarityType(actual.value, ClarityType.Int));
@@ -1247,9 +1176,7 @@ describe("test pox-4 contract", () => {
             );
             assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
             assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
             const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -1265,7 +1192,6 @@ describe("test pox-4 contract", () => {
               ],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.ResponseErr));
             assert(isClarityType(actual.value, ClarityType.Int));
@@ -1304,9 +1230,7 @@ describe("test pox-4 contract", () => {
             );
             assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
             assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
             const expectedResponseErr = ERR_STACKING_INVALID_LOCK_PERIOD;
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -1322,7 +1246,6 @@ describe("test pox-4 contract", () => {
               ],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.ResponseErr));
             assert(isClarityType(actual.value, ClarityType.Int));
@@ -1343,7 +1266,6 @@ describe("test pox-4 contract", () => {
           (caller, version, hashbytes, first_rew_cycle, num_cycles) => {
             // Arrange
             const amount_ustx = 0;
-
             const { result: pox_4_info } = simnet.callReadOnlyFn(
               POX_4,
               GET_POX_INFO,
@@ -1352,9 +1274,7 @@ describe("test pox-4 contract", () => {
             );
             assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
             assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
             const expectedResponseErr = ERR_STACKING_INVALID_AMOUNT;
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -1370,7 +1290,6 @@ describe("test pox-4 contract", () => {
               ],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.ResponseErr));
             assert(isClarityType(actual.value, ClarityType.Int));
@@ -1386,7 +1305,6 @@ describe("test pox-4 contract", () => {
           fc.constantFrom(...simnet.getAccounts().values()),
           (caller) => {
             // Arrange
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -1394,7 +1312,6 @@ describe("test pox-4 contract", () => {
               [Cl.principal(caller)],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.OptionalNone));
           }
@@ -1408,7 +1325,6 @@ describe("test pox-4 contract", () => {
           fc.constantFrom(...simnet.getAccounts().values()),
           (caller) => {
             // Arrange
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -1416,7 +1332,6 @@ describe("test pox-4 contract", () => {
               [Cl.principal(caller)],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.OptionalNone));
           }
@@ -1473,7 +1388,6 @@ describe("test pox-4 contract", () => {
           fc.constantFrom(...simnet.getAccounts().values()),
           (caller, sender, contract_caller) => {
             // Arrange
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -1502,7 +1416,6 @@ describe("test pox-4 contract", () => {
               [Cl.principal(contract_caller), Cl.none()],
               sender
             );
-
             assert(isClarityType(allow, ClarityType.ResponseOk));
             assert(isClarityType(allow.value, ClarityType.BoolTrue));
             // Act
@@ -1575,7 +1488,46 @@ describe("test pox-4 contract", () => {
       );
     });
 
-    // get-signer-key-message-hash
+    it("should return correct hash get-signer-key-message-hash", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.nat({ max: 6 }),
+          fc.array(fc.nat({ max: 255 }), { maxLength: 32 }),
+          fc.nat(),
+          fc.nat(),
+          (caller, version, hashbytes, reward_cycle, period) => {
+            // Arrange
+            const topic = "test";
+            const signer_key_message_hash = buildSignerKeyMessageHash(
+              version,
+              hashbytes,
+              reward_cycle,
+              topic,
+              period
+            );
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_SIGNER_KEY_MESSAGE_HASH,
+              [
+                Cl.tuple({
+                  version: Cl.buffer(Uint8Array.from([version])),
+                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+                }),
+                Cl.uint(reward_cycle),
+                Cl.stringAscii(topic),
+                Cl.uint(period),
+              ],
+              caller
+            );
+            // Assert
+            assert(isClarityType(actual, ClarityType.Buffer));
+            expect(actual).toBeBuff(signer_key_message_hash);
+          }
+        )
+      );
+    });
     // verify-signer-key-sig
   });
 });

From 2e7a9165e5a2693721f5aefcad39501068b2ee97 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Fri, 1 Mar 2024 17:38:58 -0500
Subject: [PATCH 1050/1166] chore: Optimize `TraitsResolver` by using fewer
 allocations

---
 clarity/src/vm/ast/traits_resolver/mod.rs | 40 ++++++++++-------------
 1 file changed, 17 insertions(+), 23 deletions(-)

diff --git a/clarity/src/vm/ast/traits_resolver/mod.rs b/clarity/src/vm/ast/traits_resolver/mod.rs
index 4cdb2f54a9..bff0c40e7c 100644
--- a/clarity/src/vm/ast/traits_resolver/mod.rs
+++ b/clarity/src/vm/ast/traits_resolver/mod.rs
@@ -50,7 +50,7 @@ impl TraitsResolver {
 
         for exp in contract_ast.pre_expressions.iter() {
             // Top-level comment nodes have been filtered from `args` by `try_parse_pre_expr`.
-            let Some((define_type, args)) = self.try_parse_pre_expr(exp) else {
+            let Some((define_type, args)) = self.try_parse_pre_expr(&exp) else {
                 continue;
             };
 
@@ -71,7 +71,7 @@ impl TraitsResolver {
 
                             // Traverse and probe for generics nested in the trait definition
                             self.probe_for_generics(
-                                trait_definition.iter().collect(),
+                                trait_definition.iter(),
                                 &mut referenced_traits,
                                 true,
                             )?;
@@ -144,7 +144,7 @@ impl TraitsResolver {
                 | DefineFunctions::PrivateFunction
                 | DefineFunctions::ReadOnlyFunction => {
                     // Traverse and probe for generics in functions type definitions
-                    self.probe_for_generics(args, &mut referenced_traits, true)?;
+                    self.probe_for_generics(args.into_iter(), &mut referenced_traits, true)?;
                 }
                 DefineFunctions::Constant
                 | DefineFunctions::Map
@@ -152,7 +152,11 @@ impl TraitsResolver {
                 | DefineFunctions::FungibleToken
                 | DefineFunctions::NonFungibleToken => {
                     if !args.is_empty() {
-                        self.probe_for_generics(args[1..].to_vec(), &mut referenced_traits, false)?;
+                        self.probe_for_generics(
+                            args[1..].to_vec().into_iter(),
+                            &mut referenced_traits,
+                            false,
+                        )?;
                     }
                 }
             };
@@ -180,31 +184,25 @@ impl TraitsResolver {
     ) -> Option<(DefineFunctions, Vec<&'a PreSymbolicExpression>)> {
         let expressions = expression.match_list()?;
         // Filter comment nodes out of the list of expressions.
-        let filtered_expressions: Vec<&PreSymbolicExpression> = expressions
+        let mut filtered_expressions = expressions
             .iter()
-            .filter(|expr| expr.match_comment().is_none())
-            .collect();
-        let (function_name, args) = filtered_expressions.split_first()?;
-        let function_name = function_name.match_atom()?;
+            .filter(|expr| expr.match_comment().is_none());
+        let function_name = filtered_expressions.next()?.match_atom()?;
         let define_type = DefineFunctions::lookup_by_name(function_name)?;
-        Some((define_type, args.to_vec()))
+        Some((define_type, filtered_expressions.collect()))
     }
 
     #[allow(clippy::only_used_in_recursion)]
-    fn probe_for_generics(
+    fn probe_for_generics<'a>(
         &mut self,
-        exprs: Vec<&PreSymbolicExpression>,
+        exprs: impl Iterator<Item = &'a PreSymbolicExpression>,
         referenced_traits: &mut HashMap<ClarityName, PreSymbolicExpression>,
         should_reference: bool,
     ) -> ParseResult<()> {
-        for &expression in exprs.iter() {
+        for expression in exprs {
             match &expression.pre_expr {
                 List(list) => {
-                    self.probe_for_generics(
-                        list.iter().collect(),
-                        referenced_traits,
-                        should_reference,
-                    )?;
+                    self.probe_for_generics(list.iter(), referenced_traits, should_reference)?;
                 }
                 TraitReference(trait_name) => {
                     if should_reference {
@@ -214,11 +212,7 @@ impl TraitsResolver {
                     }
                 }
                 Tuple(atoms) => {
-                    self.probe_for_generics(
-                        atoms.iter().collect(),
-                        referenced_traits,
-                        should_reference,
-                    )?;
+                    self.probe_for_generics(atoms.iter(), referenced_traits, should_reference)?;
                 }
                 _ => { /* no-op */ }
             }

From 4eb89e4aae720b8e422677a7f109479bbe05705f Mon Sep 17 00:00:00 2001
From: BowTiedRadone <bowtiedradone@gmail.com>
Date: Thu, 7 Mar 2024 16:49:58 +0200
Subject: [PATCH 1051/1166] updated get-signer-key-message-hash test to match
 the new function structure

---
 .../tests/pox-4/pox-4-utils/utils.ts          | 20 +++++++++++--
 .../tests/pox-4/pox-4.prop.test.ts            | 30 +++++++++++++++----
 2 files changed, 41 insertions(+), 9 deletions(-)

diff --git a/contrib/core-contract-tests/tests/pox-4/pox-4-utils/utils.ts b/contrib/core-contract-tests/tests/pox-4/pox-4-utils/utils.ts
index 81164c3338..1f53c81a92 100644
--- a/contrib/core-contract-tests/tests/pox-4/pox-4-utils/utils.ts
+++ b/contrib/core-contract-tests/tests/pox-4/pox-4-utils/utils.ts
@@ -21,7 +21,9 @@ const generateMessageHash = (
   hashbytes: number[],
   reward_cycle: number,
   topic: string,
-  period: number
+  period: number,
+  auth_id: number,
+  max_amount: number
 ) =>
   Cl.tuple({
     "pox-addr": Cl.tuple({
@@ -31,6 +33,8 @@ const generateMessageHash = (
     "reward-cycle": Cl.uint(reward_cycle),
     topic: Cl.stringAscii(topic),
     period: Cl.uint(period),
+    "auth-id": Cl.uint(auth_id),
+    "max-amount": Cl.uint(max_amount),
   });
 
 const generateMessagePrefixBuffer = (prefix: string) =>
@@ -41,12 +45,22 @@ export const buildSignerKeyMessageHash = (
   hashbytes: number[],
   reward_cycle: number,
   topic: string,
-  period: number
+  period: number,
+  max_amount: number,
+  auth_id: number
 ) => {
   const sip018_msg_prefix = "534950303138";
   const domain_hash = structuredDataHash(generateDomainHash());
   const message_hash = structuredDataHash(
-    generateMessageHash(version, hashbytes, reward_cycle, topic, period)
+    generateMessageHash(
+      version,
+      hashbytes,
+      reward_cycle,
+      topic,
+      period,
+      auth_id,
+      max_amount
+    )
   );
   const structuredDataPrefix = generateMessagePrefixBuffer(sip018_msg_prefix);
 
diff --git a/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts b/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
index b54eaafa5c..e1c1e04833 100644
--- a/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
+++ b/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
@@ -1,6 +1,6 @@
 import { Cl, ClarityType, isClarityType } from "@stacks/transactions";
-import { assert, describe, expect, it } from "vitest";
 import fc from "fast-check";
+import { assert, describe, expect, it } from "vitest";
 import { buildSignerKeyMessageHash } from "./pox-4-utils/utils";
 
 // Contracts
@@ -1496,15 +1496,31 @@ describe("test pox-4 contract", () => {
           fc.array(fc.nat({ max: 255 }), { maxLength: 32 }),
           fc.nat(),
           fc.nat(),
-          (caller, version, hashbytes, reward_cycle, period) => {
+          // fc.asciiString({ maxLength: 10, minLength: 1 }),
+          fc.nat(),
+          fc.nat(),
+          (
+            caller,
+            version,
+            hashbytes,
+            reward_cycle,
+            period,
+            // topic,
+            max_amount,
+            auth_id
+          ) => {
             // Arrange
-            const topic = "test";
+            // clarinet bug string:
+            // r;NT="
+
             const signer_key_message_hash = buildSignerKeyMessageHash(
               version,
               hashbytes,
               reward_cycle,
-              topic,
-              period
+              "topic",
+              period,
+              max_amount,
+              auth_id
             );
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
@@ -1516,8 +1532,10 @@ describe("test pox-4 contract", () => {
                   hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
                 }),
                 Cl.uint(reward_cycle),
-                Cl.stringAscii(topic),
+                Cl.stringAscii("topic"),
                 Cl.uint(period),
+                Cl.uint(max_amount),
+                Cl.uint(auth_id),
               ],
               caller
             );

From f8150929d57dccfed24b01bda32e07bc3a47885e Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Thu, 7 Mar 2024 07:58:26 -0800
Subject: [PATCH 1052/1166] fix: merge conflicts

---
 .../src/tests/nakamoto_integrations.rs        | 28 ++-----------------
 1 file changed, 2 insertions(+), 26 deletions(-)

diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 658c683f87..f8f256bf5e 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -657,32 +657,6 @@ fn get_signer_index(
         })
 }
 
-fn get_signer_index(
-    stacker_set: &GetStackersResponse,
-    signer_key: &Secp256k1PublicKey,
-) -> Result<usize, String> {
-    let Some(ref signer_set) = stacker_set.stacker_set.signers else {
-        return Err("Empty signer set for reward cycle".into());
-    };
-    let signer_key_bytes = signer_key.to_bytes_compressed();
-    signer_set
-        .iter()
-        .enumerate()
-        .find_map(|(ix, entry)| {
-            if entry.signing_key.as_slice() == signer_key_bytes.as_slice() {
-                Some(ix)
-            } else {
-                None
-            }
-        })
-        .ok_or_else(|| {
-            format!(
-                "Signing key not found. {} not found.",
-                to_hex(&signer_key_bytes)
-            )
-        })
-}
-
 /// Use the read-only API to get the aggregate key for a given reward cycle
 pub fn get_key_for_cycle(
     reward_cycle: u64,
@@ -2169,6 +2143,7 @@ fn vote_for_aggregate_key_burn_op() {
         return;
     }
 
+    let signers = TestSigners::default();
     let (mut naka_conf, _miner_account) = naka_neon_integration_conf(None);
     let _http_origin = format!("http://{}", &naka_conf.node.rpc_bind);
     naka_conf.miner.wait_on_interim_blocks = Duration::from_secs(1);
@@ -2213,6 +2188,7 @@ fn vote_for_aggregate_key_burn_op() {
         &blocks_processed,
         &[stacker_sk],
         &[signer_sk],
+        Some(&signers),
         &mut btc_regtest_controller,
     );
 

From 37f226561550035a879be1e676bdb69320e5212f Mon Sep 17 00:00:00 2001
From: BowTiedRadone <bowtiedradone@gmail.com>
Date: Thu, 7 Mar 2024 20:21:11 +0200
Subject: [PATCH 1053/1166] Move utils to test file, inlined methods and
 contract name

---
 .../tests/pox-4/pox-4-utils/utils.ts          |  72 ----
 .../tests/pox-4/pox-4.prop.test.ts            | 342 ++++++++++--------
 2 files changed, 198 insertions(+), 216 deletions(-)
 delete mode 100644 contrib/core-contract-tests/tests/pox-4/pox-4-utils/utils.ts

diff --git a/contrib/core-contract-tests/tests/pox-4/pox-4-utils/utils.ts b/contrib/core-contract-tests/tests/pox-4/pox-4-utils/utils.ts
deleted file mode 100644
index 1f53c81a92..0000000000
--- a/contrib/core-contract-tests/tests/pox-4/pox-4-utils/utils.ts
+++ /dev/null
@@ -1,72 +0,0 @@
-import { Cl, ClarityValue, serializeCV } from "@stacks/transactions";
-import { createHash } from "crypto";
-
-function sha256(data: Buffer): Buffer {
-  return createHash("sha256").update(data).digest();
-}
-
-function structuredDataHash(structuredData: ClarityValue): Buffer {
-  return sha256(Buffer.from(serializeCV(structuredData)));
-}
-
-const generateDomainHash = () =>
-  Cl.tuple({
-    name: Cl.stringAscii("pox-4-signer"),
-    version: Cl.stringAscii("1.0.0"),
-    "chain-id": Cl.uint(2147483648),
-  });
-
-const generateMessageHash = (
-  version: number,
-  hashbytes: number[],
-  reward_cycle: number,
-  topic: string,
-  period: number,
-  auth_id: number,
-  max_amount: number
-) =>
-  Cl.tuple({
-    "pox-addr": Cl.tuple({
-      version: Cl.buffer(Uint8Array.from([version])),
-      hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
-    }),
-    "reward-cycle": Cl.uint(reward_cycle),
-    topic: Cl.stringAscii(topic),
-    period: Cl.uint(period),
-    "auth-id": Cl.uint(auth_id),
-    "max-amount": Cl.uint(max_amount),
-  });
-
-const generateMessagePrefixBuffer = (prefix: string) =>
-  Buffer.from(prefix, "hex");
-
-export const buildSignerKeyMessageHash = (
-  version: number,
-  hashbytes: number[],
-  reward_cycle: number,
-  topic: string,
-  period: number,
-  max_amount: number,
-  auth_id: number
-) => {
-  const sip018_msg_prefix = "534950303138";
-  const domain_hash = structuredDataHash(generateDomainHash());
-  const message_hash = structuredDataHash(
-    generateMessageHash(
-      version,
-      hashbytes,
-      reward_cycle,
-      topic,
-      period,
-      auth_id,
-      max_amount
-    )
-  );
-  const structuredDataPrefix = generateMessagePrefixBuffer(sip018_msg_prefix);
-
-  const signer_key_message_hash = sha256(
-    Buffer.concat([structuredDataPrefix, domain_hash, message_hash])
-  );
-
-  return signer_key_message_hash;
-};
diff --git a/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts b/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
index e1c1e04833..1a56d314c2 100644
--- a/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
+++ b/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
@@ -1,47 +1,101 @@
-import { Cl, ClarityType, isClarityType } from "@stacks/transactions";
+import {
+  Cl,
+  ClarityType,
+  ClarityValue,
+  isClarityType,
+  serializeCV,
+} from "@stacks/transactions";
 import fc from "fast-check";
 import { assert, describe, expect, it } from "vitest";
-import { buildSignerKeyMessageHash } from "./pox-4-utils/utils";
+import { createHash } from "crypto";
 
-// Contracts
-const POX_4 = "pox-4";
-// Methods
-const ALLOW_CONTRACT_CALLER = "allow-contract-caller";
-const BURN_HEIGHT_TO_REWARD_CYCLE = "burn-height-to-reward-cycle";
-const CAN_STACK_STX = "can-stack-stx";
-const CHECK_CALLER_ALLOWED = "check-caller-allowed";
-const CHECK_POX_ADDR_VERSION = "check-pox-addr-version";
-const CHECK_POX_LOCK_PERIOD = "check-pox-lock-period";
-const CURRENT_POX_REWARD_CYCLE = "current-pox-reward-cycle";
-const GET_ALLOWANCE_CONTRACT_CALLERS = "get-allowance-contract-callers";
-const GET_CHECK_DELEGATION = "get-check-delegation";
-const GET_DELEGATION_INFO = "get-delegation-info";
-const GET_NUM_REWARD_SET_POX_ADDRESSES = "get-num-reward-set-pox-addresses";
-const GET_PARTIAL_STACKED_BY_CYCLE = "get-partial-stacked-by-cycle";
-const GET_POX_INFO = "get-pox-info";
-const GET_REWARD_SET_POX_ADDRESS = "get-reward-set-pox-address";
-const GET_REWARD_SET_SIZE = "get-reward-set-size";
-const GET_SIGNER_KEY_MESSAGE_HASH = "get-signer-key-message-hash";
-const GET_STACKER_INFO = "get-stacker-info";
-const GET_STACKING_MINIMUM = "get-stacking-minimum";
-const GET_TOTAL_USTX_STACKED = "get-total-ustx-stacked";
-const MINIMAL_CAN_STACK_STX = "minimal-can-stack-stx";
-const REWARD_CYCLE_TO_BURN_HEIGHT = "reward-cycle-to-burn-height";
-const VERIFY_SIGNER_KEY_SIG = "verify-signer-key-sig";
 // Contract Consts
 const INITIAL_TOTAL_LIQ_SUPPLY = 1_000_000_000_000_000;
 const MIN_AMOUNT_USTX = 125_000_000_000n;
 const TESTNET_PREPARE_CYCLE_LENGTH = 50;
 const TESTNET_REWARD_CYCLE_LENGTH = 1050;
 const TESTNET_STACKING_THRESHOLD_25 = 8000;
-// Clarity Constraints
+// Clarity
 const MAX_CLAR_UINT = 340282366920938463463374607431768211455n;
+const TESTNET_CHAIN_ID = 2147483648;
+const SIP_018_MESSAGE_PREFIX = "534950303138";
 // Error Codes
 const ERR_STACKING_INVALID_LOCK_PERIOD = 2;
 const ERR_STACKING_THRESHOLD_NOT_MET = 11;
 const ERR_STACKING_INVALID_POX_ADDRESS = 13;
 const ERR_STACKING_INVALID_AMOUNT = 18;
 
+function sha256(data: Buffer): Buffer {
+  return createHash("sha256").update(data).digest();
+}
+
+function structuredDataHash(structuredData: ClarityValue): Buffer {
+  return sha256(Buffer.from(serializeCV(structuredData)));
+}
+
+const generateDomainHash = (): ClarityValue =>
+  Cl.tuple({
+    name: Cl.stringAscii("pox-4-signer"),
+    version: Cl.stringAscii("1.0.0"),
+    "chain-id": Cl.uint(TESTNET_CHAIN_ID),
+  });
+
+const generateMessageHash = (
+  version: number,
+  hashbytes: number[],
+  reward_cycle: number,
+  topic: string,
+  period: number,
+  auth_id: number,
+  max_amount: number
+): ClarityValue =>
+  Cl.tuple({
+    "pox-addr": Cl.tuple({
+      version: Cl.buffer(Uint8Array.from([version])),
+      hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+    }),
+    "reward-cycle": Cl.uint(reward_cycle),
+    topic: Cl.stringAscii(topic),
+    period: Cl.uint(period),
+    "auth-id": Cl.uint(auth_id),
+    "max-amount": Cl.uint(max_amount),
+  });
+
+const generateMessagePrefixBuffer = (prefix: string) =>
+  Buffer.from(prefix, "hex");
+
+export const buildSignerKeyMessageHash = (
+  version: number,
+  hashbytes: number[],
+  reward_cycle: number,
+  topic: string,
+  period: number,
+  max_amount: number,
+  auth_id: number
+) => {
+  const domain_hash = structuredDataHash(generateDomainHash());
+  const message_hash = structuredDataHash(
+    generateMessageHash(
+      version,
+      hashbytes,
+      reward_cycle,
+      topic,
+      period,
+      auth_id,
+      max_amount
+    )
+  );
+  const structuredDataPrefix = generateMessagePrefixBuffer(
+    SIP_018_MESSAGE_PREFIX
+  );
+
+  const signer_key_message_hash = sha256(
+    Buffer.concat([structuredDataPrefix, domain_hash, message_hash])
+  );
+
+  return signer_key_message_hash;
+};
+
 describe("test pox-4 contract", () => {
   describe("test pox-4 contract read only functions", () => {
     it("should return correct reward-cycle-to-burn-height", () => {
@@ -52,8 +106,8 @@ describe("test pox-4 contract", () => {
           (account, reward_cycle) => {
             // Arrange
             const { result: pox_4_info } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_POX_INFO,
+              "pox-4",
+              "get-pox-info",
               [],
               account
             );
@@ -65,8 +119,8 @@ describe("test pox-4 contract", () => {
               pox_4_info.value.data["reward-cycle-length"];
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              REWARD_CYCLE_TO_BURN_HEIGHT,
+              "pox-4",
+              "reward-cycle-to-burn-height",
               [Cl.uint(reward_cycle)],
               account
             );
@@ -91,8 +145,8 @@ describe("test pox-4 contract", () => {
           (account, burn_height) => {
             // Arrange
             const { result: pox_4_info } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_POX_INFO,
+              "pox-4",
+              "get-pox-info",
               [],
               account
             );
@@ -104,8 +158,8 @@ describe("test pox-4 contract", () => {
               pox_4_info.value.data["reward-cycle-length"];
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              BURN_HEIGHT_TO_REWARD_CYCLE,
+              "pox-4",
+              "burn-height-to-reward-cycle",
               [Cl.uint(burn_height)],
               account
             );
@@ -132,8 +186,8 @@ describe("test pox-4 contract", () => {
             let expected = 0;
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              CURRENT_POX_REWARD_CYCLE,
+              "pox-4",
+              "current-pox-reward-cycle",
               [],
               caller
             );
@@ -154,8 +208,8 @@ describe("test pox-4 contract", () => {
             // Arrange
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_STACKER_INFO,
+              "pox-4",
+              "get-stacker-info",
               [Cl.principal(stacker)],
               caller
             );
@@ -175,8 +229,8 @@ describe("test pox-4 contract", () => {
             // Arrange
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              CHECK_CALLER_ALLOWED,
+              "pox-4",
+              "check-caller-allowed",
               [],
               caller
             );
@@ -198,8 +252,8 @@ describe("test pox-4 contract", () => {
             const expected = 0;
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_REWARD_SET_SIZE,
+              "pox-4",
+              "get-reward-set-size",
               [Cl.uint(reward_cycle)],
               caller
             );
@@ -221,8 +275,8 @@ describe("test pox-4 contract", () => {
             const expected = 0;
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_TOTAL_USTX_STACKED,
+              "pox-4",
+              "get-total-ustx-stacked",
               [Cl.uint(reward_cycle)],
               caller
             );
@@ -244,8 +298,8 @@ describe("test pox-4 contract", () => {
             // Arrange
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_REWARD_SET_POX_ADDRESS,
+              "pox-4",
+              "get-reward-set-pox-address",
               [Cl.uint(index), Cl.uint(reward_cycle)],
               caller
             );
@@ -264,8 +318,8 @@ describe("test pox-4 contract", () => {
           (caller) => {
             // Arrange
             const { result: pox_4_info } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_POX_INFO,
+              "pox-4",
+              "get-pox-info",
               [],
               caller
             );
@@ -279,8 +333,8 @@ describe("test pox-4 contract", () => {
             );
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_STACKING_MINIMUM,
+              "pox-4",
+              "get-stacking-minimum",
               [],
               caller
             );
@@ -302,8 +356,8 @@ describe("test pox-4 contract", () => {
             const expected = true;
             // Act
             let { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              CHECK_POX_ADDR_VERSION,
+              "pox-4",
+              "check-pox-addr-version",
               [Cl.buffer(Uint8Array.from([version]))],
               caller
             );
@@ -325,8 +379,8 @@ describe("test pox-4 contract", () => {
             const expected = false;
             // Act
             let { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              CHECK_POX_ADDR_VERSION,
+              "pox-4",
+              "check-pox-addr-version",
               [Cl.buffer(Uint8Array.from([version]))],
               caller
             );
@@ -348,8 +402,8 @@ describe("test pox-4 contract", () => {
             const expected = true;
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              CHECK_POX_LOCK_PERIOD,
+              "pox-4",
+              "check-pox-lock-period",
               [Cl.uint(reward_cycles)],
               caller
             );
@@ -371,8 +425,8 @@ describe("test pox-4 contract", () => {
             const expected = false;
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              CHECK_POX_LOCK_PERIOD,
+              "pox-4",
+              "check-pox-lock-period",
               [Cl.uint(reward_cycles)],
               caller
             );
@@ -394,8 +448,8 @@ describe("test pox-4 contract", () => {
             const expected = false;
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              CHECK_POX_LOCK_PERIOD,
+              "pox-4",
+              "check-pox-lock-period",
               [Cl.uint(reward_cycles)],
               caller
             );
@@ -432,8 +486,8 @@ describe("test pox-4 contract", () => {
           ) => {
             // Arrange
             const { result: pox_4_info } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_POX_INFO,
+              "pox-4",
+              "get-pox-info",
               [],
               caller
             );
@@ -442,8 +496,8 @@ describe("test pox-4 contract", () => {
             const expectedResponseOk = true;
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              CAN_STACK_STX,
+              "pox-4",
+              "can-stack-stx",
               [
                 Cl.tuple({
                   version: Cl.buffer(Uint8Array.from([version])),
@@ -489,8 +543,8 @@ describe("test pox-4 contract", () => {
           ) => {
             // Arrange
             const { result: pox_4_info } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_POX_INFO,
+              "pox-4",
+              "get-pox-info",
               [],
               caller
             );
@@ -499,8 +553,8 @@ describe("test pox-4 contract", () => {
             const expectedResponseOk = true;
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              CAN_STACK_STX,
+              "pox-4",
+              "can-stack-stx",
               [
                 Cl.tuple({
                   version: Cl.buffer(Uint8Array.from([version])),
@@ -549,8 +603,8 @@ describe("test pox-4 contract", () => {
           ) => {
             // Arrange
             const { result: pox_4_info } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_POX_INFO,
+              "pox-4",
+              "get-pox-info",
               [],
               caller
             );
@@ -559,8 +613,8 @@ describe("test pox-4 contract", () => {
             const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              CAN_STACK_STX,
+              "pox-4",
+              "can-stack-stx",
               [
                 Cl.tuple({
                   version: Cl.buffer(Uint8Array.from([version])),
@@ -606,8 +660,8 @@ describe("test pox-4 contract", () => {
           ) => {
             // Arrange
             const { result: pox_4_info } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_POX_INFO,
+              "pox-4",
+              "get-pox-info",
               [],
               caller
             );
@@ -616,8 +670,8 @@ describe("test pox-4 contract", () => {
             const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              CAN_STACK_STX,
+              "pox-4",
+              "can-stack-stx",
               [
                 Cl.tuple({
                   version: Cl.buffer(Uint8Array.from([version])),
@@ -662,8 +716,8 @@ describe("test pox-4 contract", () => {
           ) => {
             // Arrange
             const { result: pox_4_info } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_POX_INFO,
+              "pox-4",
+              "get-pox-info",
               [],
               caller
             );
@@ -672,8 +726,8 @@ describe("test pox-4 contract", () => {
             const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              CAN_STACK_STX,
+              "pox-4",
+              "can-stack-stx",
               [
                 Cl.tuple({
                   version: Cl.buffer(Uint8Array.from([version])),
@@ -718,8 +772,8 @@ describe("test pox-4 contract", () => {
           ) => {
             // Arrange
             const { result: pox_4_info } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_POX_INFO,
+              "pox-4",
+              "get-pox-info",
               [],
               caller
             );
@@ -728,8 +782,8 @@ describe("test pox-4 contract", () => {
             const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              CAN_STACK_STX,
+              "pox-4",
+              "can-stack-stx",
               [
                 Cl.tuple({
                   version: Cl.buffer(Uint8Array.from([version])),
@@ -772,8 +826,8 @@ describe("test pox-4 contract", () => {
           ) => {
             // Arrange
             const { result: pox_4_info } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_POX_INFO,
+              "pox-4",
+              "get-pox-info",
               [],
               caller
             );
@@ -782,8 +836,8 @@ describe("test pox-4 contract", () => {
             const expectedResponseErr = ERR_STACKING_THRESHOLD_NOT_MET;
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              CAN_STACK_STX,
+              "pox-4",
+              "can-stack-stx",
               [
                 Cl.tuple({
                   version: Cl.buffer(Uint8Array.from([version])),
@@ -826,8 +880,8 @@ describe("test pox-4 contract", () => {
           ) => {
             // Arrange
             const { result: pox_4_info } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_POX_INFO,
+              "pox-4",
+              "get-pox-info",
               [],
               caller
             );
@@ -836,8 +890,8 @@ describe("test pox-4 contract", () => {
             const expectedResponseErr = ERR_STACKING_INVALID_LOCK_PERIOD;
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              CAN_STACK_STX,
+              "pox-4",
+              "can-stack-stx",
               [
                 Cl.tuple({
                   version: Cl.buffer(Uint8Array.from([version])),
@@ -883,8 +937,8 @@ describe("test pox-4 contract", () => {
           ) => {
             // Arrange
             const { result: pox_4_info } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_POX_INFO,
+              "pox-4",
+              "get-pox-info",
               [],
               caller
             );
@@ -893,8 +947,8 @@ describe("test pox-4 contract", () => {
             const expectedResponseOk = true;
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              MINIMAL_CAN_STACK_STX,
+              "pox-4",
+              "minimal-can-stack-stx",
               [
                 Cl.tuple({
                   version: Cl.buffer(Uint8Array.from([version])),
@@ -940,8 +994,8 @@ describe("test pox-4 contract", () => {
           ) => {
             // Arrange
             const { result: pox_4_info } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_POX_INFO,
+              "pox-4",
+              "get-pox-info",
               [],
               caller
             );
@@ -950,8 +1004,8 @@ describe("test pox-4 contract", () => {
             const expectedResponseOk = true;
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              MINIMAL_CAN_STACK_STX,
+              "pox-4",
+              "minimal-can-stack-stx",
               [
                 Cl.tuple({
                   version: Cl.buffer(Uint8Array.from([version])),
@@ -1000,8 +1054,8 @@ describe("test pox-4 contract", () => {
           ) => {
             // Arrange
             const { result: pox_4_info } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_POX_INFO,
+              "pox-4",
+              "get-pox-info",
               [],
               caller
             );
@@ -1010,8 +1064,8 @@ describe("test pox-4 contract", () => {
             const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              MINIMAL_CAN_STACK_STX,
+              "pox-4",
+              "minimal-can-stack-stx",
               [
                 Cl.tuple({
                   version: Cl.buffer(Uint8Array.from([version])),
@@ -1057,8 +1111,8 @@ describe("test pox-4 contract", () => {
           ) => {
             // Arrange
             const { result: pox_4_info } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_POX_INFO,
+              "pox-4",
+              "get-pox-info",
               [],
               caller
             );
@@ -1067,8 +1121,8 @@ describe("test pox-4 contract", () => {
             const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              MINIMAL_CAN_STACK_STX,
+              "pox-4",
+              "minimal-can-stack-stx",
               [
                 Cl.tuple({
                   version: Cl.buffer(Uint8Array.from([version])),
@@ -1113,8 +1167,8 @@ describe("test pox-4 contract", () => {
           ) => {
             // Arrange
             const { result: pox_4_info } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_POX_INFO,
+              "pox-4",
+              "get-pox-info",
               [],
               caller
             );
@@ -1123,8 +1177,8 @@ describe("test pox-4 contract", () => {
             const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              MINIMAL_CAN_STACK_STX,
+              "pox-4",
+              "minimal-can-stack-stx",
               [
                 Cl.tuple({
                   version: Cl.buffer(Uint8Array.from([version])),
@@ -1169,8 +1223,8 @@ describe("test pox-4 contract", () => {
           ) => {
             // Arrange
             const { result: pox_4_info } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_POX_INFO,
+              "pox-4",
+              "get-pox-info",
               [],
               caller
             );
@@ -1179,8 +1233,8 @@ describe("test pox-4 contract", () => {
             const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              MINIMAL_CAN_STACK_STX,
+              "pox-4",
+              "minimal-can-stack-stx",
               [
                 Cl.tuple({
                   version: Cl.buffer(Uint8Array.from([version])),
@@ -1223,8 +1277,8 @@ describe("test pox-4 contract", () => {
           ) => {
             // Arrange
             const { result: pox_4_info } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_POX_INFO,
+              "pox-4",
+              "get-pox-info",
               [],
               caller
             );
@@ -1233,8 +1287,8 @@ describe("test pox-4 contract", () => {
             const expectedResponseErr = ERR_STACKING_INVALID_LOCK_PERIOD;
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              MINIMAL_CAN_STACK_STX,
+              "pox-4",
+              "minimal-can-stack-stx",
               [
                 Cl.tuple({
                   version: Cl.buffer(Uint8Array.from([version])),
@@ -1267,8 +1321,8 @@ describe("test pox-4 contract", () => {
             // Arrange
             const amount_ustx = 0;
             const { result: pox_4_info } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_POX_INFO,
+              "pox-4",
+              "get-pox-info",
               [],
               caller
             );
@@ -1277,8 +1331,8 @@ describe("test pox-4 contract", () => {
             const expectedResponseErr = ERR_STACKING_INVALID_AMOUNT;
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              MINIMAL_CAN_STACK_STX,
+              "pox-4",
+              "minimal-can-stack-stx",
               [
                 Cl.tuple({
                   version: Cl.buffer(Uint8Array.from([version])),
@@ -1307,8 +1361,8 @@ describe("test pox-4 contract", () => {
             // Arrange
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_CHECK_DELEGATION,
+              "pox-4",
+              "get-check-delegation",
               [Cl.principal(caller)],
               caller
             );
@@ -1327,8 +1381,8 @@ describe("test pox-4 contract", () => {
             // Arrange
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_DELEGATION_INFO,
+              "pox-4",
+              "get-delegation-info",
               [Cl.principal(caller)],
               caller
             );
@@ -1349,8 +1403,8 @@ describe("test pox-4 contract", () => {
               expected_first_burn_block_height = 0;
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_POX_INFO,
+              "pox-4",
+              "get-pox-info",
               [],
               caller
             );
@@ -1390,8 +1444,8 @@ describe("test pox-4 contract", () => {
             // Arrange
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_ALLOWANCE_CONTRACT_CALLERS,
+              "pox-4",
+              "get-allowance-contract-callers",
               [Cl.principal(sender), Cl.principal(contract_caller)],
               caller
             );
@@ -1411,8 +1465,8 @@ describe("test pox-4 contract", () => {
           (caller, sender, contract_caller) => {
             // Arrange
             const { result: allow } = simnet.callPublicFn(
-              POX_4,
-              ALLOW_CONTRACT_CALLER,
+              "pox-4",
+              "allow-contract-caller",
               [Cl.principal(contract_caller), Cl.none()],
               sender
             );
@@ -1420,8 +1474,8 @@ describe("test pox-4 contract", () => {
             assert(isClarityType(allow.value, ClarityType.BoolTrue));
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_ALLOWANCE_CONTRACT_CALLERS,
+              "pox-4",
+              "get-allowance-contract-callers",
               [Cl.principal(sender), Cl.principal(contract_caller)],
               caller
             );
@@ -1444,8 +1498,8 @@ describe("test pox-4 contract", () => {
             const expected = 0;
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_NUM_REWARD_SET_POX_ADDRESSES,
+              "pox-4",
+              "get-num-reward-set-pox-addresses",
               [Cl.uint(reward_cycle)],
               caller
             );
@@ -1469,8 +1523,8 @@ describe("test pox-4 contract", () => {
             // Arrange
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_PARTIAL_STACKED_BY_CYCLE,
+              "pox-4",
+              "get-partial-stacked-by-cycle",
               [
                 Cl.tuple({
                   version: Cl.buffer(Uint8Array.from([version])),
@@ -1524,8 +1578,8 @@ describe("test pox-4 contract", () => {
             );
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_SIGNER_KEY_MESSAGE_HASH,
+              "pox-4",
+              "get-signer-key-message-hash",
               [
                 Cl.tuple({
                   version: Cl.buffer(Uint8Array.from([version])),

From b4274f3209aad083ef2b3fa86578eec413712b3a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?M=C3=A5rten=20Blankfors?= <marten@blankfors.se>
Date: Thu, 7 Mar 2024 21:48:52 +0100
Subject: [PATCH 1054/1166] fix: Add `mutants::sip` cfg attribute to
 StackerDBErrorCodes::from_code

Co-authored-by: Hank Stoever <hstove@gmail.com>
---
 stackslib/src/net/api/poststackerdbchunk.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/stackslib/src/net/api/poststackerdbchunk.rs b/stackslib/src/net/api/poststackerdbchunk.rs
index 195c1cb96f..1d35a8b908 100644
--- a/stackslib/src/net/api/poststackerdbchunk.rs
+++ b/stackslib/src/net/api/poststackerdbchunk.rs
@@ -146,6 +146,7 @@ impl StackerDBErrorCodes {
         })
     }
 
+    #[cfg_attr(test, mutants::skip)]
     pub fn from_code(code: u32) -> Option<Self> {
         match code {
             0 => Some(Self::DataAlreadyExists),

From 60c6abc866b0cd6a41f738887f8458c9e1e086e5 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Thu, 7 Mar 2024 19:08:09 -0500
Subject: [PATCH 1055/1166] If data already exists in a stackerdb slot, update
 version number

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/client/stackerdb.rs | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/stacks-signer/src/client/stackerdb.rs b/stacks-signer/src/client/stackerdb.rs
index ab9c1509ea..b6a7accdc0 100644
--- a/stacks-signer/src/client/stackerdb.rs
+++ b/stacks-signer/src/client/stackerdb.rs
@@ -120,7 +120,7 @@ impl StackerDB {
         let msg_id = message.msg_id();
         let slot_id = self.signer_slot_id;
         loop {
-            let slot_version = if let Some(versions) = self.slot_versions.get_mut(&msg_id) {
+            let mut slot_version = if let Some(versions) = self.slot_versions.get_mut(&msg_id) {
                 if let Some(version) = versions.get(&slot_id) {
                     *version
                 } else {
@@ -165,7 +165,12 @@ impl StackerDB {
             if let Some(code) = chunk_ack.code {
                 match StackerDBErrorCodes::from_code(code) {
                     Some(StackerDBErrorCodes::DataAlreadyExists) => {
-                        warn!("Failed to send message to stackerdb due to wrong version number {}. Incrementing and retrying...", slot_version);
+                        if let Some(slot_metadata) = chunk_ack.metadata {
+                            warn!("Failed to send message to stackerdb due to wrong version number. Attempted {}. Expected {}. Retrying...", slot_version, slot_metadata.slot_version);
+                            slot_version = slot_metadata.slot_version;
+                        } else {
+                            warn!("Failed to send message to stackerdb due to wrong version number. Attempted {}. Expected unkown version number. Incrementing and retrying...", slot_version);
+                        }
                         if let Some(versions) = self.slot_versions.get_mut(&msg_id) {
                             // NOTE: per the above, this is always executed
                             versions.insert(slot_id, slot_version.saturating_add(1));

From 24af4a8d42c7e20fb850bb4cb1155a2769c24006 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Thu, 7 Mar 2024 17:13:43 -0800
Subject: [PATCH 1056/1166] feat: add signer-key to stack-increase event

---
 pox-locking/src/events.rs                     | 34 ++++++++++++++-
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 43 +++++++++++++++++--
 2 files changed, 72 insertions(+), 5 deletions(-)

diff --git a/pox-locking/src/events.rs b/pox-locking/src/events.rs
index e61ee916dc..baf78161a4 100644
--- a/pox-locking/src/events.rs
+++ b/pox-locking/src/events.rs
@@ -136,6 +136,10 @@ fn create_event_info_data_code(
                         signer-sig: {signer_sig},
                         ;; equal to args[5]
                         signer-key: {signer_key},
+                        ;; equal to args[6]
+                        max-amount: {max_amount},
+                        ;; equal to args[7]
+                        auth-id: {auth_id},
                     }}
                 }}
                 "#,
@@ -145,6 +149,8 @@ fn create_event_info_data_code(
                 start_burn_height = &args[2],
                 signer_sig = &args.get(4).unwrap_or(&Value::none()),
                 signer_key = &args.get(5).unwrap_or(&Value::none()),
+                max_amount = &args.get(6).unwrap_or(&Value::none()),
+                auth_id = &args.get(7).unwrap_or(&Value::none()),
             )
         }
         "delegate-stack-stx" => {
@@ -195,11 +201,23 @@ fn create_event_info_data_code(
                         ;; derived from args[0]
                         total-locked: (+ {increase_by} (get locked (stx-account tx-sender))),
                         ;; pox addr increased
-                        pox-addr: (get pox-addr (unwrap-panic (map-get? stacking-state {{ stacker: tx-sender }})))
+                        pox-addr: (get pox-addr (unwrap-panic (map-get? stacking-state {{ stacker: tx-sender }}))),
+                        ;; signer sig (args[1])
+                        signer-sig: {signer_sig},
+                        ;; signer key (args[2])
+                        signer-key: {signer_key},
+                        ;; equal to args[3]
+                        max-amount: {max_amount},
+                        ;; equal to args[4]
+                        auth-id: {auth_id},
                     }}
                 }}
                 "#,
-                increase_by = &args[0]
+                increase_by = &args[0],
+                signer_sig = &args.get(1).unwrap_or(&Value::none()),
+                signer_key = &args.get(2).unwrap_or(&Value::none()),
+                max_amount = &args.get(3).unwrap_or(&Value::none()),
+                auth_id = &args.get(4).unwrap_or(&Value::none()),
             )
         }
         "delegate-stack-increase" => {
@@ -259,6 +277,10 @@ fn create_event_info_data_code(
                         signer-sig: {signer_sig},
                         ;; equal to args[3]
                         signer-key: {signer_key},
+                        ;; equal to args[4]
+                        max-amount: {max_amount},
+                        ;; equal to args[5]
+                        auth-id: {auth_id},
                     }}
                 }})
                 "#,
@@ -266,6 +288,8 @@ fn create_event_info_data_code(
                 pox_addr = &args[1],
                 signer_sig = &args.get(2).unwrap_or(&Value::none()),
                 signer_key = &args.get(3).map_or("none".to_string(), |v| v.to_string()),
+                max_amount = &args.get(4).unwrap_or(&Value::none()),
+                auth_id = &args.get(5).unwrap_or(&Value::none()),
             )
         }
         "delegate-stack-extend" => {
@@ -326,6 +350,10 @@ fn create_event_info_data_code(
                         signer-sig: {signer_sig},
                         ;; equal to args[3]
                         signer-key: {signer_key},
+                        ;; equal to args[4]
+                        max-amount: {max_amount},
+                        ;; equal to args[5]
+                        auth-id: {auth_id},
                     }}
                 }}
                 "#,
@@ -333,6 +361,8 @@ fn create_event_info_data_code(
                 reward_cycle = &args[1],
                 signer_sig = &args.get(2).unwrap_or(&Value::none()),
                 signer_key = &args.get(3).unwrap_or(&Value::none()),
+                max_amount = &args.get(4).unwrap_or(&Value::none()),
+                auth_id = &args.get(5).unwrap_or(&Value::none()),
             )
         }
         "stack-aggregation-increase" => {
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index a785fe2f6a..a26d375eeb 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -503,6 +503,8 @@ fn pox_extend_transition() {
         u128::MAX,
         auth_id,
     );
+    let alice_stack_signature = alice_signature.clone();
+    let alice_stack_signer_key = alice_signer_key.clone();
     let alice_lockup = make_pox_4_lockup(
         &alice,
         2,
@@ -613,8 +615,8 @@ fn pox_extend_transition() {
         3,
         alice_pox_addr.clone(),
         6,
-        alice_signer_key,
-        Some(alice_signature),
+        alice_signer_key.clone(),
+        Some(alice_signature.clone()),
         u128::MAX,
         3,
     );
@@ -731,6 +733,16 @@ fn pox_extend_transition() {
         ),
         ("pox-addr", pox_addr_val.clone()),
         ("lock-period", Value::UInt(4)),
+        (
+            "signer-sig",
+            Value::some(Value::buff_from(alice_stack_signature).unwrap()).unwrap(),
+        ),
+        (
+            "signer-key",
+            Value::buff_from(alice_stack_signer_key.to_bytes_compressed()).unwrap(),
+        ),
+        ("max-amount", Value::UInt(u128::MAX)),
+        ("auth-id", Value::UInt(1)),
     ]);
     let common_data = PoxPrintFields {
         op_name: "stack-stx".to_string(),
@@ -4311,7 +4323,7 @@ fn stack_increase() {
         alice_nonce,
         min_ustx,
         &signing_pk,
-        Some(signature),
+        Some(signature.clone()),
         u128::MAX,
         1,
     );
@@ -4322,6 +4334,8 @@ fn stack_increase() {
 
     let actual_result = stacker_transactions.first().cloned().unwrap().result;
 
+    let increase_event = &stacker_transactions.first().cloned().unwrap().events[0];
+
     let expected_result = Value::okay(Value::Tuple(
         TupleData::from_data(vec![
             (
@@ -4334,6 +4348,29 @@ fn stack_increase() {
     ))
     .unwrap();
 
+    let increase_op_data = HashMap::from([
+        (
+            "signer-sig",
+            Value::some(Value::buff_from(signature).unwrap()).unwrap(),
+        ),
+        (
+            "signer-key",
+            Value::buff_from(signing_pk.to_bytes_compressed()).unwrap(),
+        ),
+        ("max-amount", Value::UInt(u128::MAX)),
+        ("auth-id", Value::UInt(1)),
+    ]);
+
+    let common_data = PoxPrintFields {
+        op_name: "stack-increase".to_string(),
+        stacker: Value::Principal(PrincipalData::from(alice_address.clone())),
+        balance: Value::UInt(10234866375000),
+        locked: Value::UInt(5133625000),
+        burnchain_unlock_height: Value::UInt(125),
+    };
+
+    check_pox_print_event(&increase_event, common_data, increase_op_data);
+
     // Testing stack_increase response is equal to expected response
     // Test is straightforward because 'stack-increase' in PoX-4 is the same as PoX-3
     assert_eq!(actual_result, expected_result);

From 458abfa1d804a8e82f1545c2fa7942b3e66d6b37 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Thu, 7 Mar 2024 17:55:15 -0800
Subject: [PATCH 1057/1166] fix: update tests with new stack-stx args

---
 testnet/stacks-node/src/tests/neon_integrations.rs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/testnet/stacks-node/src/tests/neon_integrations.rs b/testnet/stacks-node/src/tests/neon_integrations.rs
index d5f1e351f4..fb4cbc2533 100644
--- a/testnet/stacks-node/src/tests/neon_integrations.rs
+++ b/testnet/stacks-node/src/tests/neon_integrations.rs
@@ -2401,6 +2401,8 @@ fn vote_for_aggregate_key_burn_op_test() {
         &Pox4SignatureTopic::StackStx,
         CHAIN_ID_TESTNET,
         12,
+        u128::MAX,
+        1,
     )
     .unwrap();
 
@@ -2420,6 +2422,8 @@ fn vote_for_aggregate_key_burn_op_test() {
             Value::UInt(12),
             Value::some(Value::buff_from(signature.to_rsv()).unwrap()).unwrap(),
             Value::buff_from(signer_pk_bytes.clone()).unwrap(),
+            Value::UInt(u128::MAX),
+            Value::UInt(1),
         ],
     );
 

From 27087a3d3e3d7993e91b61c580d5815b3fdb3853 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Thu, 7 Mar 2024 17:58:54 -0800
Subject: [PATCH 1058/1166] fix: cargo fmt error

---
 testnet/stacks-node/src/tests/neon_integrations.rs | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/testnet/stacks-node/src/tests/neon_integrations.rs b/testnet/stacks-node/src/tests/neon_integrations.rs
index fb4cbc2533..ff46fba9a2 100644
--- a/testnet/stacks-node/src/tests/neon_integrations.rs
+++ b/testnet/stacks-node/src/tests/neon_integrations.rs
@@ -36,13 +36,10 @@ use stacks::chainstate::stacks::{
 use stacks::clarity_cli::vm_execute as execute;
 use stacks::core::mempool::MemPoolWalkTxTypes;
 use stacks::core::{
-    self, PEER_VERSION_EPOCH_2_2, PEER_VERSION_EPOCH_2_3, PEER_VERSION_EPOCH_2_4,
-    PEER_VERSION_EPOCH_2_5,
-};
-use stacks::core::{
-    StacksEpoch, StacksEpochId, BLOCK_LIMIT_MAINNET_20, BLOCK_LIMIT_MAINNET_205,
+    self, StacksEpoch, StacksEpochId, BLOCK_LIMIT_MAINNET_20, BLOCK_LIMIT_MAINNET_205,
     BLOCK_LIMIT_MAINNET_21, CHAIN_ID_TESTNET, HELIUM_BLOCK_LIMIT_20, PEER_VERSION_EPOCH_1_0,
     PEER_VERSION_EPOCH_2_0, PEER_VERSION_EPOCH_2_05, PEER_VERSION_EPOCH_2_1,
+    PEER_VERSION_EPOCH_2_2, PEER_VERSION_EPOCH_2_3, PEER_VERSION_EPOCH_2_4, PEER_VERSION_EPOCH_2_5,
 };
 use stacks::net::api::getaccount::AccountEntryResponse;
 use stacks::net::api::getcontractsrc::ContractSrcResponse;

From 7572bb01155b38f7a3681baa851c6f68b006a51d Mon Sep 17 00:00:00 2001
From: BowTiedRadone <bowtiedradone@gmail.com>
Date: Fri, 8 Mar 2024 13:10:10 +0200
Subject: [PATCH 1059/1166] Update according to comments

---
 .../tests/pox-4/pox-4.prop.test.ts            | 2916 ++++++++---------
 1 file changed, 1454 insertions(+), 1462 deletions(-)

diff --git a/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts b/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
index 1a56d314c2..b82d212477 100644
--- a/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
+++ b/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
@@ -96,1510 +96,1502 @@ export const buildSignerKeyMessageHash = (
   return signer_key_message_hash;
 };
 
-describe("test pox-4 contract", () => {
-  describe("test pox-4 contract read only functions", () => {
-    it("should return correct reward-cycle-to-burn-height", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.nat(),
-          (account, reward_cycle) => {
-            // Arrange
-            const { result: pox_4_info } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-pox-info",
-              [],
-              account
-            );
-            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-            const first_burn_block_height =
-              pox_4_info.value.data["first-burnchain-block-height"];
-            const reward_cycle_length =
-              pox_4_info.value.data["reward-cycle-length"];
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "reward-cycle-to-burn-height",
-              [Cl.uint(reward_cycle)],
-              account
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.UInt));
-            assert(isClarityType(first_burn_block_height, ClarityType.UInt));
-            assert(isClarityType(reward_cycle_length, ClarityType.UInt));
-            const expected =
-              Number(first_burn_block_height.value) +
-              Number(reward_cycle_length.value) * reward_cycle;
-            expect(actual).toBeUint(expected);
-          }
-        )
-      );
-    });
+describe("test pox-4 contract read only functions", () => {
+  it("should return correct reward-cycle-to-burn-height", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.nat(),
+        (account, reward_cycle) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-pox-info",
+            [],
+            account
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+          const first_burn_block_height =
+            pox_4_info.value.data["first-burnchain-block-height"];
+          const reward_cycle_length =
+            pox_4_info.value.data["reward-cycle-length"];
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "reward-cycle-to-burn-height",
+            [Cl.uint(reward_cycle)],
+            account
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.UInt));
+          assert(isClarityType(first_burn_block_height, ClarityType.UInt));
+          assert(isClarityType(reward_cycle_length, ClarityType.UInt));
+          const expected =
+            Number(first_burn_block_height.value) +
+            Number(reward_cycle_length.value) * reward_cycle;
+          expect(actual).toBeUint(expected);
+        }
+      )
+    );
+  });
 
-    it("should return correct burn-height-to-reward-cycle", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.nat(),
-          (account, burn_height) => {
-            // Arrange
-            const { result: pox_4_info } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-pox-info",
-              [],
-              account
-            );
-            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-            const first_burn_block_height =
-              pox_4_info.value.data["first-burnchain-block-height"];
-            const reward_cycle_length =
-              pox_4_info.value.data["reward-cycle-length"];
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "burn-height-to-reward-cycle",
-              [Cl.uint(burn_height)],
-              account
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.UInt));
-            assert(isClarityType(first_burn_block_height, ClarityType.UInt));
-            assert(isClarityType(reward_cycle_length, ClarityType.UInt));
-            const expected = Math.floor(
-              (burn_height - Number(first_burn_block_height.value)) /
-                Number(reward_cycle_length.value)
-            );
-            expect(actual).toBeUint(expected);
-          }
-        )
-      );
-    });
+  it("should return correct burn-height-to-reward-cycle", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.nat(),
+        (account, burn_height) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-pox-info",
+            [],
+            account
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+          const first_burn_block_height =
+            pox_4_info.value.data["first-burnchain-block-height"];
+          const reward_cycle_length =
+            pox_4_info.value.data["reward-cycle-length"];
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "burn-height-to-reward-cycle",
+            [Cl.uint(burn_height)],
+            account
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.UInt));
+          assert(isClarityType(first_burn_block_height, ClarityType.UInt));
+          assert(isClarityType(reward_cycle_length, ClarityType.UInt));
+          const expected = Math.floor(
+            (burn_height - Number(first_burn_block_height.value)) /
+              Number(reward_cycle_length.value)
+          );
+          expect(actual).toBeUint(expected);
+        }
+      )
+    );
+  });
 
-    it("should return u0 current-pox-reward-cycle", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          (caller) => {
-            // Arrange
-            let expected = 0;
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "current-pox-reward-cycle",
-              [],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.UInt));
-            expect(actual).toBeUint(expected);
-          }
-        )
-      );
-    });
+  it("should return u0 current-pox-reward-cycle", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        (caller) => {
+          // Arrange
+          let expected = 0;
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "current-pox-reward-cycle",
+            [],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.UInt));
+          expect(actual).toBeUint(expected);
+        }
+      )
+    );
+  });
 
-    it("should return none get-stacker-info", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.constantFrom(...simnet.getAccounts().values()),
-          (stacker, caller) => {
-            // Arrange
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-stacker-info",
-              [Cl.principal(stacker)],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.OptionalNone));
-            expect(actual).toBeNone();
-          }
-        )
-      );
-    });
+  it("should return none get-stacker-info", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.constantFrom(...simnet.getAccounts().values()),
+        (stacker, caller) => {
+          // Arrange
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-stacker-info",
+            [Cl.principal(stacker)],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.OptionalNone));
+          expect(actual).toBeNone();
+        }
+      )
+    );
+  });
 
-    it("should return true check-caller-allowed", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          (caller) => {
-            // Arrange
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "check-caller-allowed",
-              [],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.BoolTrue));
-            expect(actual).toBeBool(true);
-          }
-        )
-      );
-    });
+  it("should return true check-caller-allowed", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        (caller) => {
+          // Arrange
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "check-caller-allowed",
+            [],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.BoolTrue));
+          expect(actual).toBeBool(true);
+        }
+      )
+    );
+  });
 
-    it("should return u0 get-reward-set-size", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.nat(),
-          (caller, reward_cycle) => {
-            // Arrange
-            const expected = 0;
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-reward-set-size",
-              [Cl.uint(reward_cycle)],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.UInt));
-            expect(actual).toBeUint(expected);
-          }
-        )
-      );
-    });
+  it("should return u0 get-reward-set-size", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.nat(),
+        (caller, reward_cycle) => {
+          // Arrange
+          const expected = 0;
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-reward-set-size",
+            [Cl.uint(reward_cycle)],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.UInt));
+          expect(actual).toBeUint(expected);
+        }
+      )
+    );
+  });
 
-    it("should return u0 get-total-ustx-stacked", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.nat(),
-          (caller, reward_cycle) => {
-            // Arrange
-            const expected = 0;
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-total-ustx-stacked",
-              [Cl.uint(reward_cycle)],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.UInt));
-            expect(actual).toBeUint(expected);
-          }
-        )
-      );
-    });
+  it("should return u0 get-total-ustx-stacked", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.nat(),
+        (caller, reward_cycle) => {
+          // Arrange
+          const expected = 0;
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-total-ustx-stacked",
+            [Cl.uint(reward_cycle)],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.UInt));
+          expect(actual).toBeUint(expected);
+        }
+      )
+    );
+  });
 
-    it("should return none get-reward-set-pox-address", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.nat(),
-          fc.nat(),
-          (caller, index, reward_cycle) => {
-            // Arrange
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-reward-set-pox-address",
-              [Cl.uint(index), Cl.uint(reward_cycle)],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.OptionalNone));
-            expect(actual).toBeNone();
-          }
-        )
-      );
-    });
+  it("should return none get-reward-set-pox-address", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.nat(),
+        fc.nat(),
+        (caller, index, reward_cycle) => {
+          // Arrange
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-reward-set-pox-address",
+            [Cl.uint(index), Cl.uint(reward_cycle)],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.OptionalNone));
+          expect(actual).toBeNone();
+        }
+      )
+    );
+  });
 
-    it("should return correct get-stacking-minimum", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          (caller) => {
-            // Arrange
-            const { result: pox_4_info } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-pox-info",
-              [],
-              caller
-            );
-            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-            const stx_liq_supply =
-              pox_4_info.value.data["total-liquid-supply-ustx"];
-            assert(isClarityType(stx_liq_supply, ClarityType.UInt));
-            const expected = Math.floor(
-              Number(stx_liq_supply.value) / TESTNET_STACKING_THRESHOLD_25
-            );
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-stacking-minimum",
-              [],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.UInt));
-            expect(actual).toBeUint(expected);
-          }
-        )
-      );
-    });
+  it("should return correct get-stacking-minimum", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        (caller) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-pox-info",
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+          const stx_liq_supply =
+            pox_4_info.value.data["total-liquid-supply-ustx"];
+          assert(isClarityType(stx_liq_supply, ClarityType.UInt));
+          const expected = Math.floor(
+            Number(stx_liq_supply.value) / TESTNET_STACKING_THRESHOLD_25
+          );
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-stacking-minimum",
+            [],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.UInt));
+          expect(actual).toBeUint(expected);
+        }
+      )
+    );
+  });
 
-    it("should return true check-pox-addr-version for version <= 6 ", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.nat({ max: 6 }),
-          (caller, version) => {
-            // Arrange
-            const expected = true;
-            // Act
-            let { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "check-pox-addr-version",
-              [Cl.buffer(Uint8Array.from([version]))],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.BoolTrue));
-            expect(actual).toBeBool(expected);
-          }
-        )
-      );
-    });
+  it("should return true check-pox-addr-version for version <= 6 ", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.nat({ max: 6 }),
+        (caller, version) => {
+          // Arrange
+          const expected = true;
+          // Act
+          let { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "check-pox-addr-version",
+            [Cl.buffer(Uint8Array.from([version]))],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.BoolTrue));
+          expect(actual).toBeBool(expected);
+        }
+      )
+    );
+  });
 
-    it("should return false check-pox-addr-version for version > 6", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.integer({ min: 7, max: 255 }),
-          (caller, version) => {
-            // Arrange
-            const expected = false;
-            // Act
-            let { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "check-pox-addr-version",
-              [Cl.buffer(Uint8Array.from([version]))],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.BoolFalse));
-            expect(actual).toBeBool(expected);
-          }
-        )
-      );
-    });
+  it("should return false check-pox-addr-version for version > 6", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 7, max: 255 }),
+        (caller, version) => {
+          // Arrange
+          const expected = false;
+          // Act
+          let { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "check-pox-addr-version",
+            [Cl.buffer(Uint8Array.from([version]))],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.BoolFalse));
+          expect(actual).toBeBool(expected);
+        }
+      )
+    );
+  });
 
-    it("should return true check-pox-lock-period for valid reward cycles number", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.integer({ min: 1, max: 12 }),
-          (caller, reward_cycles) => {
-            // Arrange
-            const expected = true;
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "check-pox-lock-period",
-              [Cl.uint(reward_cycles)],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.BoolTrue));
-            expect(actual).toBeBool(expected);
-          }
-        )
-      );
-    });
+  it("should return true check-pox-lock-period for valid reward cycles number", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 1, max: 12 }),
+        (caller, valid_reward_cycles) => {
+          // Arrange
+          const expected = true;
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "check-pox-lock-period",
+            [Cl.uint(valid_reward_cycles)],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.BoolTrue));
+          expect(actual).toBeBool(expected);
+        }
+      )
+    );
+  });
 
-    it("should return false check-pox-lock-period for reward cycles number > 12", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.integer({ min: 13 }),
-          (caller, reward_cycles) => {
-            // Arrange
-            const expected = false;
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "check-pox-lock-period",
-              [Cl.uint(reward_cycles)],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.BoolFalse));
-            expect(actual).toBeBool(expected);
-          }
-        )
-      );
-    });
+  it("should return false check-pox-lock-period for reward cycles number > 12", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 13 }),
+        (caller, invalid_reward_cycles) => {
+          // Arrange
+          const expected = false;
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "check-pox-lock-period",
+            [Cl.uint(invalid_reward_cycles)],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.BoolFalse));
+          expect(actual).toBeBool(expected);
+        }
+      )
+    );
+  });
 
-    it("should return false check-pox-lock-period for reward cycles number == 0", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          (caller) => {
-            // Arrange
-            const reward_cycles = 0;
-            const expected = false;
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "check-pox-lock-period",
-              [Cl.uint(reward_cycles)],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.BoolFalse));
-            expect(actual).toBeBool(expected);
-          }
-        )
-      );
-    });
+  it("should return false check-pox-lock-period for reward cycles number == 0", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        (caller) => {
+          // Arrange
+          const invalid_reward_cycles = 0;
+          const expected = false;
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "check-pox-lock-period",
+            [Cl.uint(invalid_reward_cycles)],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.BoolFalse));
+          expect(actual).toBeBool(expected);
+        }
+      )
+    );
+  });
 
-    it("should return (ok true) can-stack-stx for versions 0-4 valid pox addresses, hashbytes, amount, cycles number", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.integer({ min: 0, max: 4 }),
-          fc.array(fc.nat({ max: 255 }), {
-            minLength: 20,
-            maxLength: 20,
-          }),
-          fc.bigInt({
-            min: MIN_AMOUNT_USTX,
-            max: MAX_CLAR_UINT,
-          }),
-          fc.nat(),
-          fc.integer({ min: 1, max: 12 }),
-          (
-            caller,
-            version,
-            hashbytes,
-            amount_ustx,
-            first_rew_cycle,
-            num_cycles
-          ) => {
-            // Arrange
-            const { result: pox_4_info } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-pox-info",
-              [],
-              caller
-            );
-            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-            const expectedResponseOk = true;
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "can-stack-stx",
-              [
-                Cl.tuple({
-                  version: Cl.buffer(Uint8Array.from([version])),
-                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
-                }),
-                Cl.uint(amount_ustx),
-                Cl.uint(first_rew_cycle),
-                Cl.uint(num_cycles),
-              ],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.ResponseOk));
-            assert(isClarityType(actual.value, ClarityType.BoolTrue));
-            expect(actual).toBeOk(Cl.bool(expectedResponseOk));
-          }
-        )
-      );
-    });
+  it("should return (ok true) can-stack-stx for versions 0-4 valid pox addresses, hashbytes, amount, cycles number", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 0, max: 4 }),
+        fc.array(fc.nat({ max: 255 }), {
+          minLength: 20,
+          maxLength: 20,
+        }),
+        fc.bigInt({
+          min: MIN_AMOUNT_USTX,
+          max: MAX_CLAR_UINT,
+        }),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-pox-info",
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+          const expectedResponseOk = true;
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "can-stack-stx",
+            [
+              Cl.tuple({
+                version: Cl.buffer(Uint8Array.from([version])),
+                hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseOk));
+          assert(isClarityType(actual.value, ClarityType.BoolTrue));
+          expect(actual).toBeOk(Cl.bool(expectedResponseOk));
+        }
+      )
+    );
+  });
 
-    it("should return (ok true) can-stack-stx for versions 5/6 valid pox addresses, hashbytes, amount, cycles number", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.integer({ min: 5, max: 6 }),
-          fc.array(fc.nat({ max: 255 }), {
-            minLength: 32,
-            maxLength: 32,
-          }),
-          fc.bigInt({
-            min: MIN_AMOUNT_USTX,
-            max: MAX_CLAR_UINT,
-          }),
-          fc.nat(),
-          fc.integer({ min: 1, max: 12 }),
-          (
-            caller,
-            version,
-            hashbytes,
-            amount_ustx,
-            first_rew_cycle,
-            num_cycles
-          ) => {
-            // Arrange
-            const { result: pox_4_info } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-pox-info",
-              [],
-              caller
-            );
-            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-            const expectedResponseOk = true;
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "can-stack-stx",
-              [
-                Cl.tuple({
-                  version: Cl.buffer(Uint8Array.from([version])),
-                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
-                }),
-                Cl.uint(amount_ustx),
-                Cl.uint(first_rew_cycle),
-                Cl.uint(num_cycles),
-              ],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.ResponseOk));
-            assert(isClarityType(actual.value, ClarityType.BoolTrue));
-            expect(actual).toBeOk(Cl.bool(expectedResponseOk));
-          }
-        )
-      );
-    });
+  it("should return (ok true) can-stack-stx for versions 5/6 valid pox addresses, hashbytes, amount, cycles number", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 5, max: 6 }),
+        fc.array(fc.nat({ max: 255 }), {
+          minLength: 32,
+          maxLength: 32,
+        }),
+        fc.bigInt({
+          min: MIN_AMOUNT_USTX,
+          max: MAX_CLAR_UINT,
+        }),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-pox-info",
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+          const expectedResponseOk = true;
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "can-stack-stx",
+            [
+              Cl.tuple({
+                version: Cl.buffer(Uint8Array.from([version])),
+                hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseOk));
+          assert(isClarityType(actual.value, ClarityType.BoolTrue));
+          expect(actual).toBeOk(Cl.bool(expectedResponseOk));
+        }
+      )
+    );
+  });
 
-    it("should return (err 13) can-stack-stx for pox addresses having version > 6", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.integer({
-            min: 7,
-            max: 255,
-          }),
-          fc.array(fc.nat({ max: 255 }), {
-            minLength: 32,
-            maxLength: 32,
-          }),
-          fc.bigInt({
-            min: MIN_AMOUNT_USTX,
-            max: MAX_CLAR_UINT,
-          }),
-          fc.nat(),
-          fc.integer({ min: 1, max: 12 }),
-          (
-            caller,
-            version,
-            hashbytes,
-            amount_ustx,
-            first_rew_cycle,
-            num_cycles
-          ) => {
-            // Arrange
-            const { result: pox_4_info } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-pox-info",
-              [],
-              caller
-            );
-            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-            const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "can-stack-stx",
-              [
-                Cl.tuple({
-                  version: Cl.buffer(Uint8Array.from([version])),
-                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
-                }),
-                Cl.uint(amount_ustx),
-                Cl.uint(first_rew_cycle),
-                Cl.uint(num_cycles),
-              ],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.ResponseErr));
-            assert(isClarityType(actual.value, ClarityType.Int));
-            expect(actual).toBeErr(Cl.int(expectedResponseErr));
-          }
-        )
-      );
-    });
+  it("should return (err 13) can-stack-stx for pox addresses having version > 6", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({
+          min: 7,
+          max: 255,
+        }),
+        fc.array(fc.nat({ max: 255 }), {
+          maxLength: 32,
+        }),
+        fc.bigInt({
+          min: MIN_AMOUNT_USTX,
+          max: MAX_CLAR_UINT,
+        }),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-pox-info",
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+          const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "can-stack-stx",
+            [
+              Cl.tuple({
+                version: Cl.buffer(Uint8Array.from([version])),
+                hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
+        }
+      )
+    );
+  });
 
-    it("should return (err 13) can-stack-stx for versions 0-4 pox addresses having hasbytes longer than 20", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.integer({ min: 0, max: 4 }),
-          fc.array(fc.nat({ max: 255 }), {
-            minLength: 21,
-            maxLength: 32,
-          }),
-          fc.bigInt({
-            min: MIN_AMOUNT_USTX,
-            max: MAX_CLAR_UINT,
-          }),
-          fc.nat(),
-          fc.integer({ min: 1, max: 12 }),
-          (
-            caller,
-            version,
-            hashbytes,
-            amount_ustx,
-            first_rew_cycle,
-            num_cycles
-          ) => {
-            // Arrange
-            const { result: pox_4_info } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-pox-info",
-              [],
-              caller
-            );
-            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-            const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "can-stack-stx",
-              [
-                Cl.tuple({
-                  version: Cl.buffer(Uint8Array.from([version])),
-                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
-                }),
-                Cl.uint(amount_ustx),
-                Cl.uint(first_rew_cycle),
-                Cl.uint(num_cycles),
-              ],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.ResponseErr));
-            assert(isClarityType(actual.value, ClarityType.Int));
-            expect(actual).toBeErr(Cl.int(expectedResponseErr));
-          }
-        )
-      );
-    });
+  it("should return (err 13) can-stack-stx for versions 0-4 pox addresses having hasbytes longer than 20", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 0, max: 4 }),
+        fc.array(fc.nat({ max: 255 }), {
+          minLength: 21,
+          maxLength: 32,
+        }),
+        fc.bigInt({
+          min: MIN_AMOUNT_USTX,
+          max: MAX_CLAR_UINT,
+        }),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-pox-info",
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+          const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "can-stack-stx",
+            [
+              Cl.tuple({
+                version: Cl.buffer(Uint8Array.from([version])),
+                hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
+        }
+      )
+    );
+  });
 
-    it("should return (err 13) can-stack-stx for versions 0-4 pox addresses having hasbytes shorter than 20", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.integer({ min: 0, max: 4 }),
-          fc.array(fc.nat({ max: 255 }), {
-            maxLength: 19,
-          }),
-          fc.bigInt({
-            min: MIN_AMOUNT_USTX,
-            max: MAX_CLAR_UINT,
-          }),
-          fc.nat(),
-          fc.integer({ min: 1, max: 12 }),
-          (
-            caller,
-            version,
-            hashbytes,
-            amount_ustx,
-            first_rew_cycle,
-            num_cycles
-          ) => {
-            // Arrange
-            const { result: pox_4_info } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-pox-info",
-              [],
-              caller
-            );
-            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-            const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "can-stack-stx",
-              [
-                Cl.tuple({
-                  version: Cl.buffer(Uint8Array.from([version])),
-                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
-                }),
-                Cl.uint(amount_ustx),
-                Cl.uint(first_rew_cycle),
-                Cl.uint(num_cycles),
-              ],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.ResponseErr));
-            assert(isClarityType(actual.value, ClarityType.Int));
-            expect(actual).toBeErr(Cl.int(expectedResponseErr));
-          }
-        )
-      );
-    });
+  it("should return (err 13) can-stack-stx for versions 0-4 pox addresses having hasbytes shorter than 20", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 0, max: 4 }),
+        fc.array(fc.nat({ max: 255 }), {
+          maxLength: 19,
+        }),
+        fc.bigInt({
+          min: MIN_AMOUNT_USTX,
+          max: MAX_CLAR_UINT,
+        }),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-pox-info",
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+          const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "can-stack-stx",
+            [
+              Cl.tuple({
+                version: Cl.buffer(Uint8Array.from([version])),
+                hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
+        }
+      )
+    );
+  });
 
-    it("should return (err 13) can-stack-stx for versions 5/6 pox addresses having hashbytes shorter than 32", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.integer({ min: 0, max: 4 }),
-          fc.array(fc.nat({ max: 255 }), {
-            maxLength: 31,
-          }),
-          fc.bigInt({
-            min: MIN_AMOUNT_USTX,
-            max: MAX_CLAR_UINT,
-          }),
-          fc.nat(),
-          fc.integer({ min: 1, max: 12 }),
-          (
-            caller,
-            version,
-            hashbytes,
-            amount_ustx,
-            first_rew_cycle,
-            num_cycles
-          ) => {
-            // Arrange
-            const { result: pox_4_info } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-pox-info",
-              [],
-              caller
-            );
-            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-            const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "can-stack-stx",
-              [
-                Cl.tuple({
-                  version: Cl.buffer(Uint8Array.from([version])),
-                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
-                }),
-                Cl.uint(amount_ustx),
-                Cl.uint(first_rew_cycle),
-                Cl.uint(num_cycles),
-              ],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.ResponseErr));
-            assert(isClarityType(actual.value, ClarityType.Int));
-            expect(actual).toBeErr(Cl.int(expectedResponseErr));
-          }
-        )
-      );
-    });
+  it("should return (err 13) can-stack-stx for versions 5/6 pox addresses having hashbytes shorter than 32", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 0, max: 4 }),
+        fc.array(fc.nat({ max: 255 }), {
+          maxLength: 31,
+        }),
+        fc.bigInt({
+          min: MIN_AMOUNT_USTX,
+          max: MAX_CLAR_UINT,
+        }),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-pox-info",
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+          const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "can-stack-stx",
+            [
+              Cl.tuple({
+                version: Cl.buffer(Uint8Array.from([version])),
+                hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
+        }
+      )
+    );
+  });
 
-    it("should return (err 11) can-stack-stx for unmet stacking threshold", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.integer({ min: 0, max: 6 }),
-          fc.array(fc.nat({ max: 255 })),
-          fc.bigInt({
-            min: 0n,
-            max: 124_999_999_999n,
-          }),
-          fc.nat(),
-          fc.integer({ min: 1, max: 12 }),
-          (
-            caller,
-            version,
-            hashbytes,
-            amount_ustx,
-            first_rew_cycle,
-            num_cycles
-          ) => {
-            // Arrange
-            const { result: pox_4_info } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-pox-info",
-              [],
-              caller
-            );
-            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-            const expectedResponseErr = ERR_STACKING_THRESHOLD_NOT_MET;
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "can-stack-stx",
-              [
-                Cl.tuple({
-                  version: Cl.buffer(Uint8Array.from([version])),
-                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
-                }),
-                Cl.uint(amount_ustx),
-                Cl.uint(first_rew_cycle),
-                Cl.uint(num_cycles),
-              ],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.ResponseErr));
-            assert(isClarityType(actual.value, ClarityType.Int));
-            expect(actual).toBeErr(Cl.int(expectedResponseErr));
-          }
-        )
-      );
-    });
+  it("should return (err 11) can-stack-stx for unmet stacking threshold", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 0, max: 6 }),
+        fc.array(fc.nat({ max: 255 })),
+        fc.bigInt({
+          min: 0n,
+          max: 124_999_999_999n,
+        }),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-pox-info",
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+          const expectedResponseErr = ERR_STACKING_THRESHOLD_NOT_MET;
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "can-stack-stx",
+            [
+              Cl.tuple({
+                version: Cl.buffer(Uint8Array.from([version])),
+                hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
+        }
+      )
+    );
+  });
 
-    it("should return (err 2) can-stack-stx for lock period > 12", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.integer({ min: 0, max: 6 }),
-          fc.array(fc.nat({ max: 255 })),
-          fc.bigInt({
-            min: MIN_AMOUNT_USTX,
-            max: MAX_CLAR_UINT,
-          }),
-          fc.nat(),
-          fc.integer({ min: 13 }),
-          (
-            caller,
-            version,
-            hashbytes,
-            amount_ustx,
-            first_rew_cycle,
-            num_cycles
-          ) => {
-            // Arrange
-            const { result: pox_4_info } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-pox-info",
-              [],
-              caller
-            );
-            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-            const expectedResponseErr = ERR_STACKING_INVALID_LOCK_PERIOD;
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "can-stack-stx",
-              [
-                Cl.tuple({
-                  version: Cl.buffer(Uint8Array.from([version])),
-                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
-                }),
-                Cl.uint(amount_ustx),
-                Cl.uint(first_rew_cycle),
-                Cl.uint(num_cycles),
-              ],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.ResponseErr));
-            assert(isClarityType(actual.value, ClarityType.Int));
-            expect(actual).toBeErr(Cl.int(expectedResponseErr));
-          }
-        )
-      );
-    });
+  it("should return (err 2) can-stack-stx for lock period > 12", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 0, max: 6 }),
+        fc.array(fc.nat({ max: 255 })),
+        fc.bigInt({
+          min: MIN_AMOUNT_USTX,
+          max: MAX_CLAR_UINT,
+        }),
+        fc.nat(),
+        fc.integer({ min: 13 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-pox-info",
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+          const expectedResponseErr = ERR_STACKING_INVALID_LOCK_PERIOD;
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "can-stack-stx",
+            [
+              Cl.tuple({
+                version: Cl.buffer(Uint8Array.from([version])),
+                hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
+        }
+      )
+    );
+  });
 
-    it("should return (ok true) minimal-can-stack-stx for versions 0-4 valid pox addresses, hashbytes, amount, cycles number", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.integer({ min: 0, max: 4 }),
-          fc.array(fc.nat({ max: 255 }), {
-            minLength: 20,
-            maxLength: 20,
-          }),
-          fc.bigInt({
-            min: MIN_AMOUNT_USTX,
-            max: MAX_CLAR_UINT,
-          }),
-          fc.nat(),
-          fc.integer({ min: 1, max: 12 }),
-          (
-            caller,
-            version,
-            hashbytes,
-            amount_ustx,
-            first_rew_cycle,
-            num_cycles
-          ) => {
-            // Arrange
-            const { result: pox_4_info } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-pox-info",
-              [],
-              caller
-            );
-            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-            const expectedResponseOk = true;
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "minimal-can-stack-stx",
-              [
-                Cl.tuple({
-                  version: Cl.buffer(Uint8Array.from([version])),
-                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
-                }),
-                Cl.uint(amount_ustx),
-                Cl.uint(first_rew_cycle),
-                Cl.uint(num_cycles),
-              ],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.ResponseOk));
-            assert(isClarityType(actual.value, ClarityType.BoolTrue));
-            expect(actual).toBeOk(Cl.bool(expectedResponseOk));
-          }
-        )
-      );
-    });
+  it("should return (ok true) minimal-can-stack-stx for versions 0-4 valid pox addresses, hashbytes, amount, cycles number", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 0, max: 4 }),
+        fc.array(fc.nat({ max: 255 }), {
+          minLength: 20,
+          maxLength: 20,
+        }),
+        fc.bigInt({
+          min: MIN_AMOUNT_USTX,
+          max: MAX_CLAR_UINT,
+        }),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-pox-info",
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+          const expectedResponseOk = true;
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "minimal-can-stack-stx",
+            [
+              Cl.tuple({
+                version: Cl.buffer(Uint8Array.from([version])),
+                hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseOk));
+          assert(isClarityType(actual.value, ClarityType.BoolTrue));
+          expect(actual).toBeOk(Cl.bool(expectedResponseOk));
+        }
+      )
+    );
+  });
 
-    it("should return (ok true) minimal-can-stack-stx for versions 5/6 valid pox addresses, hashbytes, amount, cycles number", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.integer({ min: 5, max: 6 }),
-          fc.array(fc.nat({ max: 255 }), {
-            minLength: 32,
-            maxLength: 32,
-          }),
-          fc.bigInt({
-            min: MIN_AMOUNT_USTX,
-            max: MAX_CLAR_UINT,
-          }),
-          fc.nat(),
-          fc.integer({ min: 1, max: 12 }),
-          (
-            caller,
-            version,
-            hashbytes,
-            amount_ustx,
-            first_rew_cycle,
-            num_cycles
-          ) => {
-            // Arrange
-            const { result: pox_4_info } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-pox-info",
-              [],
-              caller
-            );
-            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-            const expectedResponseOk = true;
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "minimal-can-stack-stx",
-              [
-                Cl.tuple({
-                  version: Cl.buffer(Uint8Array.from([version])),
-                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
-                }),
-                Cl.uint(amount_ustx),
-                Cl.uint(first_rew_cycle),
-                Cl.uint(num_cycles),
-              ],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.ResponseOk));
-            assert(isClarityType(actual.value, ClarityType.BoolTrue));
-            expect(actual).toBeOk(Cl.bool(expectedResponseOk));
-          }
-        )
-      );
-    });
+  it("should return (ok true) minimal-can-stack-stx for versions 5/6 valid pox addresses, hashbytes, amount, cycles number", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 5, max: 6 }),
+        fc.array(fc.nat({ max: 255 }), {
+          minLength: 32,
+          maxLength: 32,
+        }),
+        fc.bigInt({
+          min: MIN_AMOUNT_USTX,
+          max: MAX_CLAR_UINT,
+        }),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-pox-info",
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+          const expectedResponseOk = true;
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "minimal-can-stack-stx",
+            [
+              Cl.tuple({
+                version: Cl.buffer(Uint8Array.from([version])),
+                hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseOk));
+          assert(isClarityType(actual.value, ClarityType.BoolTrue));
+          expect(actual).toBeOk(Cl.bool(expectedResponseOk));
+        }
+      )
+    );
+  });
 
-    it("should return (err 13) minimal-can-stack-stx for pox addresses having version > 6", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.integer({
-            min: 7,
-            max: 255,
-          }),
-          fc.array(fc.nat({ max: 255 }), {
-            minLength: 32,
-            maxLength: 32,
-          }),
-          fc.bigInt({
-            min: MIN_AMOUNT_USTX,
-            max: MAX_CLAR_UINT,
-          }),
-          fc.nat(),
-          fc.integer({ min: 1, max: 12 }),
-          (
-            caller,
-            version,
-            hashbytes,
-            amount_ustx,
-            first_rew_cycle,
-            num_cycles
-          ) => {
-            // Arrange
-            const { result: pox_4_info } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-pox-info",
-              [],
-              caller
-            );
-            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-            const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "minimal-can-stack-stx",
-              [
-                Cl.tuple({
-                  version: Cl.buffer(Uint8Array.from([version])),
-                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
-                }),
-                Cl.uint(amount_ustx),
-                Cl.uint(first_rew_cycle),
-                Cl.uint(num_cycles),
-              ],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.ResponseErr));
-            assert(isClarityType(actual.value, ClarityType.Int));
-            expect(actual).toBeErr(Cl.int(expectedResponseErr));
-          }
-        )
-      );
-    });
+  it("should return (err 13) minimal-can-stack-stx for pox addresses having version > 6", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({
+          min: 7,
+          max: 255,
+        }),
+        fc.array(fc.nat({ max: 255 }), {
+          maxLength: 32,
+        }),
+        fc.bigInt({
+          min: MIN_AMOUNT_USTX,
+          max: MAX_CLAR_UINT,
+        }),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-pox-info",
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+          const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "minimal-can-stack-stx",
+            [
+              Cl.tuple({
+                version: Cl.buffer(Uint8Array.from([version])),
+                hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
+        }
+      )
+    );
+  });
 
-    it("should return (err 13) minimal-can-stack-stx for versions 0-4 pox addresses having hasbytes longer than 20", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.integer({ min: 0, max: 4 }),
-          fc.array(fc.nat({ max: 255 }), {
-            minLength: 21,
-            maxLength: 32,
-          }),
-          fc.bigInt({
-            min: MIN_AMOUNT_USTX,
-            max: MAX_CLAR_UINT,
-          }),
-          fc.nat(),
-          fc.integer({ min: 1, max: 12 }),
-          (
-            caller,
-            version,
-            hashbytes,
-            amount_ustx,
-            first_rew_cycle,
-            num_cycles
-          ) => {
-            // Arrange
-            const { result: pox_4_info } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-pox-info",
-              [],
-              caller
-            );
-            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-            const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "minimal-can-stack-stx",
-              [
-                Cl.tuple({
-                  version: Cl.buffer(Uint8Array.from([version])),
-                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
-                }),
-                Cl.uint(amount_ustx),
-                Cl.uint(first_rew_cycle),
-                Cl.uint(num_cycles),
-              ],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.ResponseErr));
-            assert(isClarityType(actual.value, ClarityType.Int));
-            expect(actual).toBeErr(Cl.int(expectedResponseErr));
-          }
-        )
-      );
-    });
+  it("should return (err 13) minimal-can-stack-stx for versions 0-4 pox addresses having hasbytes longer than 20", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 0, max: 4 }),
+        fc.array(fc.nat({ max: 255 }), {
+          minLength: 21,
+          maxLength: 32,
+        }),
+        fc.bigInt({
+          min: MIN_AMOUNT_USTX,
+          max: MAX_CLAR_UINT,
+        }),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-pox-info",
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+          const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "minimal-can-stack-stx",
+            [
+              Cl.tuple({
+                version: Cl.buffer(Uint8Array.from([version])),
+                hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
+        }
+      )
+    );
+  });
 
-    it("should return (err 13) minimal-can-stack-stx for versions 0-4 pox addresses having hasbytes shorter than 20", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.integer({ min: 0, max: 4 }),
-          fc.array(fc.nat({ max: 255 }), {
-            maxLength: 19,
-          }),
-          fc.bigInt({
-            min: MIN_AMOUNT_USTX,
-            max: MAX_CLAR_UINT,
-          }),
-          fc.nat(),
-          fc.integer({ min: 1, max: 12 }),
-          (
-            caller,
-            version,
-            hashbytes,
-            amount_ustx,
-            first_rew_cycle,
-            num_cycles
-          ) => {
-            // Arrange
-            const { result: pox_4_info } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-pox-info",
-              [],
-              caller
-            );
-            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-            const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "minimal-can-stack-stx",
-              [
-                Cl.tuple({
-                  version: Cl.buffer(Uint8Array.from([version])),
-                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
-                }),
-                Cl.uint(amount_ustx),
-                Cl.uint(first_rew_cycle),
-                Cl.uint(num_cycles),
-              ],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.ResponseErr));
-            assert(isClarityType(actual.value, ClarityType.Int));
-            expect(actual).toBeErr(Cl.int(expectedResponseErr));
-          }
-        )
-      );
-    });
+  it("should return (err 13) minimal-can-stack-stx for versions 0-4 pox addresses having hasbytes shorter than 20", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 0, max: 4 }),
+        fc.array(fc.nat({ max: 255 }), {
+          maxLength: 19,
+        }),
+        fc.bigInt({
+          min: MIN_AMOUNT_USTX,
+          max: MAX_CLAR_UINT,
+        }),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-pox-info",
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+          const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "minimal-can-stack-stx",
+            [
+              Cl.tuple({
+                version: Cl.buffer(Uint8Array.from([version])),
+                hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
+        }
+      )
+    );
+  });
 
-    it("should return (err 13) minimal-can-stack-stx for versions 5/6 pox addresses having hashbytes shorter than 32", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.integer({ min: 0, max: 4 }),
-          fc.array(fc.nat({ max: 255 }), {
-            maxLength: 31,
-          }),
-          fc.bigInt({
-            min: MIN_AMOUNT_USTX,
-            max: MAX_CLAR_UINT,
-          }),
-          fc.nat(),
-          fc.integer({ min: 1, max: 12 }),
-          (
-            caller,
-            version,
-            hashbytes,
-            amount_ustx,
-            first_rew_cycle,
-            num_cycles
-          ) => {
-            // Arrange
-            const { result: pox_4_info } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-pox-info",
-              [],
-              caller
-            );
-            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-            const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "minimal-can-stack-stx",
-              [
-                Cl.tuple({
-                  version: Cl.buffer(Uint8Array.from([version])),
-                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
-                }),
-                Cl.uint(amount_ustx),
-                Cl.uint(first_rew_cycle),
-                Cl.uint(num_cycles),
-              ],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.ResponseErr));
-            assert(isClarityType(actual.value, ClarityType.Int));
-            expect(actual).toBeErr(Cl.int(expectedResponseErr));
-          }
-        )
-      );
-    });
+  it("should return (err 13) minimal-can-stack-stx for versions 5/6 pox addresses having hashbytes shorter than 32", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 0, max: 4 }),
+        fc.array(fc.nat({ max: 255 }), {
+          maxLength: 31,
+        }),
+        fc.bigInt({
+          min: MIN_AMOUNT_USTX,
+          max: MAX_CLAR_UINT,
+        }),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-pox-info",
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+          const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "minimal-can-stack-stx",
+            [
+              Cl.tuple({
+                version: Cl.buffer(Uint8Array.from([version])),
+                hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
+        }
+      )
+    );
+  });
 
-    it("should return (err 2) minimal-can-stack-stx for lock period > 12", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.integer({ min: 0, max: 6 }),
-          fc.array(fc.nat({ max: 255 })),
-          fc.bigInt({
-            min: MIN_AMOUNT_USTX,
-            max: MAX_CLAR_UINT,
-          }),
-          fc.nat(),
-          fc.integer({ min: 13 }),
-          (
-            caller,
-            version,
-            hashbytes,
-            amount_ustx,
-            first_rew_cycle,
-            num_cycles
-          ) => {
-            // Arrange
-            const { result: pox_4_info } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-pox-info",
-              [],
-              caller
-            );
-            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-            const expectedResponseErr = ERR_STACKING_INVALID_LOCK_PERIOD;
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "minimal-can-stack-stx",
-              [
-                Cl.tuple({
-                  version: Cl.buffer(Uint8Array.from([version])),
-                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
-                }),
-                Cl.uint(amount_ustx),
-                Cl.uint(first_rew_cycle),
-                Cl.uint(num_cycles),
-              ],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.ResponseErr));
-            assert(isClarityType(actual.value, ClarityType.Int));
-            expect(actual).toBeErr(Cl.int(expectedResponseErr));
-          }
-        )
-      );
-    });
+  it("should return (err 2) minimal-can-stack-stx for lock period > 12", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 0, max: 6 }),
+        fc.array(fc.nat({ max: 255 })),
+        fc.bigInt({
+          min: MIN_AMOUNT_USTX,
+          max: MAX_CLAR_UINT,
+        }),
+        fc.nat(),
+        fc.integer({ min: 13 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-pox-info",
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+          const expectedResponseErr = ERR_STACKING_INVALID_LOCK_PERIOD;
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "minimal-can-stack-stx",
+            [
+              Cl.tuple({
+                version: Cl.buffer(Uint8Array.from([version])),
+                hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
+        }
+      )
+    );
+  });
 
-    it("should return (err 18) minimal-can-stack-stx for amount == 0", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.integer({ min: 0, max: 6 }),
-          fc.array(fc.nat({ max: 255 }), { maxLength: 32 }),
-          fc.nat(),
-          fc.integer({ min: 1, max: 12 }),
-          (caller, version, hashbytes, first_rew_cycle, num_cycles) => {
-            // Arrange
-            const amount_ustx = 0;
-            const { result: pox_4_info } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-pox-info",
-              [],
-              caller
-            );
-            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-            const expectedResponseErr = ERR_STACKING_INVALID_AMOUNT;
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "minimal-can-stack-stx",
-              [
-                Cl.tuple({
-                  version: Cl.buffer(Uint8Array.from([version])),
-                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
-                }),
-                Cl.uint(amount_ustx),
-                Cl.uint(first_rew_cycle),
-                Cl.uint(num_cycles),
-              ],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.ResponseErr));
-            assert(isClarityType(actual.value, ClarityType.Int));
-            expect(actual).toBeErr(Cl.int(expectedResponseErr));
-          }
-        )
-      );
-    });
+  it("should return (err 18) minimal-can-stack-stx for amount == 0", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 0, max: 6 }),
+        fc.array(fc.nat({ max: 255 }), { maxLength: 32 }),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (caller, version, hashbytes, first_rew_cycle, num_cycles) => {
+          // Arrange
+          const amount_ustx = 0;
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-pox-info",
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+          const expectedResponseErr = ERR_STACKING_INVALID_AMOUNT;
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "minimal-can-stack-stx",
+            [
+              Cl.tuple({
+                version: Cl.buffer(Uint8Array.from([version])),
+                hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
+        }
+      )
+    );
+  });
 
-    it("should return none get-check-delegation", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          (caller) => {
-            // Arrange
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-check-delegation",
-              [Cl.principal(caller)],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.OptionalNone));
-          }
-        )
-      );
-    });
+  it("should return none get-check-delegation", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        (caller) => {
+          // Arrange
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-check-delegation",
+            [Cl.principal(caller)],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.OptionalNone));
+        }
+      )
+    );
+  });
 
-    it("should return none get-delegation-info", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          (caller) => {
-            // Arrange
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-delegation-info",
-              [Cl.principal(caller)],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.OptionalNone));
-          }
-        )
-      );
-    });
+  it("should return none get-delegation-info", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        (caller) => {
+          // Arrange
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-delegation-info",
+            [Cl.principal(caller)],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.OptionalNone));
+        }
+      )
+    );
+  });
+
+  it("should return correct get-pox-info", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        (caller) => {
+          // Arrange
+          const expected_reward_cycle_id = 0,
+            expected_first_burn_block_height = 0;
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-pox-info",
+            [],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseOk));
+          assert(isClarityType(actual.value, ClarityType.Tuple));
+          expect(actual.value.data["first-burnchain-block-height"]).toBeUint(
+            expected_first_burn_block_height
+          );
+          expect(actual.value.data["min-amount-ustx"]).toBeUint(
+            MIN_AMOUNT_USTX
+          );
+          expect(actual.value.data["prepare-cycle-length"]).toBeUint(
+            TESTNET_PREPARE_CYCLE_LENGTH
+          );
+          expect(actual.value.data["reward-cycle-id"]).toBeUint(
+            expected_reward_cycle_id
+          );
+          expect(actual.value.data["reward-cycle-length"]).toBeUint(
+            TESTNET_REWARD_CYCLE_LENGTH
+          );
+          expect(actual.value.data["total-liquid-supply-ustx"]).toBeUint(
+            INITIAL_TOTAL_LIQ_SUPPLY
+          );
+        }
+      )
+    );
+  });
 
-    it("should return correct get-pox-info", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          (caller) => {
-            // Arrange
-            const expected_reward_cycle_id = 0,
-              expected_first_burn_block_height = 0;
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-pox-info",
-              [],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.ResponseOk));
-            assert(isClarityType(actual.value, ClarityType.Tuple));
-            expect(actual.value.data["first-burnchain-block-height"]).toBeUint(
-              expected_first_burn_block_height
-            );
-            expect(actual.value.data["min-amount-ustx"]).toBeUint(
-              MIN_AMOUNT_USTX
-            );
-            expect(actual.value.data["prepare-cycle-length"]).toBeUint(
-              TESTNET_PREPARE_CYCLE_LENGTH
-            );
-            expect(actual.value.data["reward-cycle-id"]).toBeUint(
-              expected_reward_cycle_id
-            );
-            expect(actual.value.data["reward-cycle-length"]).toBeUint(
-              TESTNET_REWARD_CYCLE_LENGTH
-            );
-            expect(actual.value.data["total-liquid-supply-ustx"]).toBeUint(
-              INITIAL_TOTAL_LIQ_SUPPLY
-            );
-          }
-        )
-      );
-    });
+  it("should return none get-allowance-contract-caller", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.constantFrom(...simnet.getAccounts().values()),
+        (caller, sender, contract_caller) => {
+          // Arrange
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-allowance-contract-callers",
+            [Cl.principal(sender), Cl.principal(contract_caller)],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.OptionalNone));
+        }
+      )
+    );
+  });
 
-    it("should return none get-allowance-contract-caller", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.constantFrom(...simnet.getAccounts().values()),
-          (caller, sender, contract_caller) => {
-            // Arrange
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-allowance-contract-callers",
-              [Cl.principal(sender), Cl.principal(contract_caller)],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.OptionalNone));
-          }
-        )
-      );
-    });
+  it("should return some(until-burn-ht: none) get-allowance-contract-caller after allow-contract-caller", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.constantFrom(...simnet.getAccounts().values()),
+        (caller, sender, contract_caller) => {
+          // Arrange
+          const { result: allow } = simnet.callPublicFn(
+            "pox-4",
+            "allow-contract-caller",
+            [Cl.principal(contract_caller), Cl.none()],
+            sender
+          );
+          assert(isClarityType(allow, ClarityType.ResponseOk));
+          assert(isClarityType(allow.value, ClarityType.BoolTrue));
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-allowance-contract-callers",
+            [Cl.principal(sender), Cl.principal(contract_caller)],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.OptionalSome));
+          assert(isClarityType(actual.value, ClarityType.Tuple));
+          expect(actual.value).toBeTuple({ "until-burn-ht": Cl.none() });
+        }
+      )
+    );
+  });
 
-    it("should return some(until-burn-ht: none) get-allowance-contract-caller after allow-contract-caller", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.constantFrom(...simnet.getAccounts().values()),
-          (caller, sender, contract_caller) => {
-            // Arrange
-            const { result: allow } = simnet.callPublicFn(
-              "pox-4",
-              "allow-contract-caller",
-              [Cl.principal(contract_caller), Cl.none()],
-              sender
-            );
-            assert(isClarityType(allow, ClarityType.ResponseOk));
-            assert(isClarityType(allow.value, ClarityType.BoolTrue));
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-allowance-contract-callers",
-              [Cl.principal(sender), Cl.principal(contract_caller)],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.OptionalSome));
-            assert(isClarityType(actual.value, ClarityType.Tuple));
-            expect(actual.value).toBeTuple({ "until-burn-ht": Cl.none() });
-          }
-        )
-      );
-    });
+  it("should return u0 get-num-reward-set-pox-addresses", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.nat(),
+        (caller, reward_cycle) => {
+          // Arrange
+          const expected = 0;
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-num-reward-set-pox-addresses",
+            [Cl.uint(reward_cycle)],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.UInt));
+          expect(actual).toBeUint(expected);
+        }
+      )
+    );
+  });
 
-    it("should return u0 get-num-reward-set-pox-addresses", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.nat(),
-          (caller, reward_cycle) => {
-            // Arrange
-            const expected = 0;
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-num-reward-set-pox-addresses",
-              [Cl.uint(reward_cycle)],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.UInt));
-            expect(actual).toBeUint(expected);
-          }
-        )
-      );
-    });
+  it("should return none get-partial-stacked-by-cycle", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.nat({ max: 6 }),
+        fc.array(fc.nat({ max: 255 }), { maxLength: 32 }),
+        fc.nat(),
+        fc.constantFrom(...simnet.getAccounts().values()),
+        (caller, version, hashbytes, reward_cycle, sender) => {
+          // Arrange
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-partial-stacked-by-cycle",
+            [
+              Cl.tuple({
+                version: Cl.buffer(Uint8Array.from([version])),
+                hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(reward_cycle),
+              Cl.principal(sender),
+            ],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.OptionalNone));
+        }
+      )
+    );
+  });
 
-    it("should return none get-partial-stacked-by-cycle", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.nat({ max: 6 }),
-          fc.array(fc.nat({ max: 255 }), { maxLength: 32 }),
-          fc.nat(),
-          fc.constantFrom(...simnet.getAccounts().values()),
-          (caller, version, hashbytes, reward_cycle, sender) => {
-            // Arrange
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-partial-stacked-by-cycle",
-              [
-                Cl.tuple({
-                  version: Cl.buffer(Uint8Array.from([version])),
-                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
-                }),
-                Cl.uint(reward_cycle),
-                Cl.principal(sender),
-              ],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.OptionalNone));
-          }
-        )
-      );
-    });
+  it("should return correct hash get-signer-key-message-hash", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.nat({ max: 6 }),
+        fc.array(fc.nat({ max: 255 }), { maxLength: 32 }),
+        fc.nat(),
+        fc.nat(),
+        fc.nat(),
+        fc.nat(),
+        (
+          caller,
+          version,
+          hashbytes,
+          reward_cycle,
+          period,
+          max_amount,
+          auth_id
+        ) => {
+          // Arrange
 
-    it("should return correct hash get-signer-key-message-hash", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.nat({ max: 6 }),
-          fc.array(fc.nat({ max: 255 }), { maxLength: 32 }),
-          fc.nat(),
-          fc.nat(),
-          // fc.asciiString({ maxLength: 10, minLength: 1 }),
-          fc.nat(),
-          fc.nat(),
-          (
-            caller,
+          const signer_key_message_hash = buildSignerKeyMessageHash(
             version,
             hashbytes,
             reward_cycle,
+            "topic",
             period,
-            // topic,
             max_amount,
             auth_id
-          ) => {
-            // Arrange
-            // clarinet bug string:
-            // r;NT="
-
-            const signer_key_message_hash = buildSignerKeyMessageHash(
-              version,
-              hashbytes,
-              reward_cycle,
-              "topic",
-              period,
-              max_amount,
-              auth_id
-            );
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-signer-key-message-hash",
-              [
-                Cl.tuple({
-                  version: Cl.buffer(Uint8Array.from([version])),
-                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
-                }),
-                Cl.uint(reward_cycle),
-                Cl.stringAscii("topic"),
-                Cl.uint(period),
-                Cl.uint(max_amount),
-                Cl.uint(auth_id),
-              ],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.Buffer));
-            expect(actual).toBeBuff(signer_key_message_hash);
-          }
-        )
-      );
-    });
-    // verify-signer-key-sig
+          );
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-signer-key-message-hash",
+            [
+              Cl.tuple({
+                version: Cl.buffer(Uint8Array.from([version])),
+                hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(reward_cycle),
+              Cl.stringAscii("topic"),
+              Cl.uint(period),
+              Cl.uint(max_amount),
+              Cl.uint(auth_id),
+            ],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.Buffer));
+          expect(actual).toBeBuff(signer_key_message_hash);
+        }
+      )
+    );
   });
+  // verify-signer-key-sig
 });

From 20083e0b33ca21061e4ca630d573503f955d8692 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Thu, 7 Mar 2024 15:27:27 -0500
Subject: [PATCH 1060/1166] update signer logging to include reward cycle to
 differentiate current and next signers

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/runloop.rs |  23 +--
 stacks-signer/src/signer.rs  | 285 ++++++++++++++++++++++-------------
 2 files changed, 193 insertions(+), 115 deletions(-)

diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 1ef9f5c537..dff6f46ae5 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -236,7 +236,7 @@ impl RunLoop {
             let old_reward_cycle = signer.reward_cycle;
             if old_reward_cycle == reward_cycle {
                 //If the signer is already registered for the reward cycle, we don't need to do anything further here
-                debug!("Signer is configured for reward cycle {reward_cycle}.")
+                debug!("Signer is already configured for reward cycle {reward_cycle}.")
             } else {
                 needs_refresh = true;
             }
@@ -252,7 +252,7 @@ impl RunLoop {
                 if let Some(signer) = self.stacks_signers.get_mut(&prior_reward_set) {
                     if signer.reward_cycle == prior_reward_cycle {
                         // The signers have been calculated for the next reward cycle. Update the current one
-                        debug!("Signer #{}: Next reward cycle ({reward_cycle}) signer set calculated. Updating current reward cycle ({prior_reward_cycle}) signer.", signer.signer_id);
+                        debug!("Reward cycle #{} Signer #{}: Next reward cycle ({reward_cycle}) signer set calculated. Reconfiguring signer.", signer.reward_cycle, signer.signer_id);
                         signer.next_signer_addresses = new_signer_config
                             .signer_entries
                             .signer_ids
@@ -264,7 +264,7 @@ impl RunLoop {
                 }
                 self.stacks_signers
                     .insert(reward_index, Signer::from(new_signer_config));
-                debug!("Signer #{signer_id} for reward cycle {reward_cycle} initialized. Initialized {} signers", self.stacks_signers.len());
+                debug!("Reward cycle #{reward_cycle} Signer #{signer_id} initialized.");
             } else {
                 warn!("Signer is not registered for reward cycle {reward_cycle}. Waiting for confirmed registration...");
             }
@@ -286,7 +286,7 @@ impl RunLoop {
                 .refresh_coordinator(&pox_consensus_hash);
             if old_coordinator_id != updated_coordinator_id {
                 debug!(
-                    "Signer #{}: Coordinator updated. Resetting state to Idle.", signer.signer_id;
+                    "Reward cycle #{} Signer #{}: Coordinator updated. Resetting state to Idle.", signer.reward_cycle, signer.signer_id;
                     "old_coordinator_id" => {old_coordinator_id},
                     "updated_coordinator_id" => {updated_coordinator_id},
                     "pox_consensus_hash" => %pox_consensus_hash
@@ -303,12 +303,14 @@ impl RunLoop {
             }
         }
         if self.stacks_signers.is_empty() {
-            info!("Signer is not registered for the current {current_reward_cycle} or next {next_reward_cycle} reward cycles. Waiting for confirmed registration...");
+            info!("Signer is not registered for the current reward cycle ({current_reward_cycle}) or next reward cycle ({next_reward_cycle}). Waiting for confirmed registration...");
             self.state = State::Uninitialized;
             return Err(ClientError::NotRegistered);
         }
+        if self.state != State::Initialized {
+            info!("Signer runloop successfully initialized!");
+        }
         self.state = State::Initialized;
-        info!("Runloop successfully initialized!");
         Ok(())
     }
 }
@@ -362,19 +364,20 @@ impl SignerRunLoop<Vec<OperationResult>, RunLoopCommand> for RunLoop {
                 current_reward_cycle,
             ) {
                 error!(
-                    "Signer #{} for reward cycle {} errored processing event: {e}",
-                    signer.signer_id, signer.reward_cycle
+                    "Reward cycle #{} Signer #{} errored processing event: {e}",
+                    signer.reward_cycle, signer.signer_id,
                 );
             }
             if let Some(command) = self.commands.pop_front() {
                 let reward_cycle = command.reward_cycle;
                 if signer.reward_cycle != reward_cycle {
                     warn!(
-                        "Signer #{}: not registered for reward cycle {reward_cycle}. Ignoring command: {command:?}", signer.signer_id
+                        "Reward cycle #{} Signer #{}: not registered for reward cycle {reward_cycle}. Ignoring command: {command:?}", signer.reward_cycle, signer.signer_id
                     );
                 } else {
                     info!(
-                        "Signer #{}: Queuing an external runloop command ({:?}): {command:?}",
+                        "Reward cycle #{} Signer #{}: Queuing an external runloop command ({:?}): {command:?}",
+                        signer.reward_cycle,
                         signer.signer_id,
                         signer
                             .signing_round
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index d53173453c..6ac16664ec 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -206,7 +206,8 @@ impl From<SignerConfig> for Signer {
             CoordinatorSelector::from(signer_config.signer_entries.public_keys);
 
         debug!(
-            "Signer #{}: initial coordinator is signer {}",
+            "Reward cycle #{} Signer #{}: initial coordinator is signer {}",
+            signer_config.reward_cycle,
             signer_config.signer_id,
             coordinator_selector.get_coordinator().0
         );
@@ -256,7 +257,7 @@ impl Signer {
         match command {
             Command::Dkg => {
                 if self.approved_aggregate_public_key.is_some() {
-                    debug!("Signer #{}: Already have an aggregate key for reward cycle {}. Ignoring DKG command.", self.signer_id, self.reward_cycle);
+                    debug!("Reward cycle #{} Signer #{}: Already have an aggregate key. Ignoring DKG command.", self.reward_cycle, self.signer_id);
                     return;
                 }
                 let vote_round = match retry_with_exponential_backoff(|| {
@@ -266,14 +267,15 @@ impl Signer {
                 }) {
                     Ok(last_round) => last_round,
                     Err(e) => {
-                        error!("Signer #{}: Unable to perform DKG. Failed to get last round from stacks node: {e:?}", self.signer_id);
+                        error!("Reward cycle #{} Signer #{}: Unable to perform DKG. Failed to get last round from stacks node: {e:?}", self.reward_cycle, self.signer_id);
                         return;
                     }
                 };
                 // The dkg id will increment internally following "start_dkg_round" so do not increment it here
                 self.coordinator.current_dkg_id = vote_round.unwrap_or(0);
                 info!(
-                    "Signer #{}: Starting DKG vote",
+                    "Reward cycle #{} Signer #{}: Starting DKG vote",
+                    self.reward_cycle,
                     self.signer_id;
                     "round" => self.coordinator.current_dkg_id.wrapping_add(1),
                     "cycle" => self.reward_cycle,
@@ -281,10 +283,16 @@ impl Signer {
                 match self.coordinator.start_dkg_round() {
                     Ok(msg) => {
                         let ack = self.stackerdb.send_message_with_retry(msg.into());
-                        debug!("Signer #{}: ACK: {ack:?}", self.signer_id);
+                        debug!(
+                            "Reward cycle #{} Signer #{}: ACK: {ack:?}",
+                            self.reward_cycle, self.signer_id
+                        );
                     }
                     Err(e) => {
-                        error!("Signer #{}: Failed to start DKG: {e:?}", self.signer_id);
+                        error!(
+                            "Reward cycle #{} Signer #{}: Failed to start DKG: {e:?}",
+                            self.reward_cycle, self.signer_id
+                        );
                         return;
                     }
                 }
@@ -295,7 +303,7 @@ impl Signer {
                 merkle_root,
             } => {
                 if self.approved_aggregate_public_key.is_none() {
-                    debug!("Signer #{}: Cannot sign a block without an approved aggregate public key. Ignore it.", self.signer_id);
+                    debug!("Reward cycle #{} Signer #{}: Cannot sign a block without an approved aggregate public key. Ignore it.", self.reward_cycle, self.signer_id);
                     return;
                 }
                 let signer_signature_hash = block.header.signer_signature_hash();
@@ -305,10 +313,10 @@ impl Signer {
                     .unwrap_or_else(|_| Some(BlockInfo::new(block.clone())))
                     .unwrap_or_else(|| BlockInfo::new(block.clone()));
                 if block_info.signed_over {
-                    debug!("Signer #{}: Received a sign command for a block we are already signing over. Ignore it.", self.signer_id);
+                    debug!("Reward cycle #{} Signer #{}: Received a sign command for a block we are already signing over. Ignore it.", self.reward_cycle, self.signer_id);
                     return;
                 }
-                info!("Signer #{}: Signing block", self.signer_id;
+                info!("Reward cycle #{} Signer #{}: Signing block", self.reward_cycle, self.signer_id;
                          "block_consensus_hash" => %block.header.consensus_hash,
                          "block_height" => block.header.chain_length,
                          "pre_sign_block_id" => %block.block_id(),
@@ -320,7 +328,10 @@ impl Signer {
                 ) {
                     Ok(msg) => {
                         let ack = self.stackerdb.send_message_with_retry(msg.into());
-                        debug!("Signer #{}: ACK: {ack:?}", self.signer_id);
+                        debug!(
+                            "Reward cycle #{} Signer #{}: ACK: {ack:?}",
+                            self.reward_cycle, self.signer_id
+                        );
                         block_info.signed_over = true;
                         self.signer_db
                             .insert_block(&block_info)
@@ -330,8 +341,8 @@ impl Signer {
                     }
                     Err(e) => {
                         error!(
-                            "Signer #{}: Failed to start signing block: {e:?}",
-                            self.signer_id
+                            "Reward cycle #{} Signer #{}: Failed to start signing block: {e:?}",
+                            self.reward_cycle, self.signer_id
                         );
                         return;
                     }
@@ -348,7 +359,8 @@ impl Signer {
             State::Idle => {
                 if coordinator_id != self.signer_id {
                     debug!(
-                        "Signer #{}: Coordinator is {coordinator_id:?}. Will not process any commands...",
+                        "Reward cycle #{} Signer #{}: Coordinator is {coordinator_id:?}. Will not process any commands...",
+                        self.reward_cycle,
                         self.signer_id
                     );
                     return;
@@ -357,15 +369,16 @@ impl Signer {
                     self.execute_command(stacks_client, &command);
                 } else {
                     debug!(
-                        "Signer #{}: Nothing to process. Waiting for command...",
-                        self.signer_id
+                        "Reward cycle #{} Signer #{}: Nothing to process. Waiting for command...",
+                        self.reward_cycle, self.signer_id
                     );
                 }
             }
             State::OperationInProgress => {
                 // We cannot execute the next command until the current one is finished...
                 debug!(
-                    "Signer #{}: Waiting for coordinator {coordinator_id:?} operation to finish...",
+                    "Reward cycle #{} Signer #{}: Waiting for coordinator {coordinator_id:?} operation to finish...",
+                    self.reward_cycle,
                     self.signer_id,
                 );
             }
@@ -387,13 +400,13 @@ impl Signer {
                     Ok(Some(block_info)) => block_info,
                     Ok(None) => {
                         // We have not seen this block before. Why are we getting a response for it?
-                        debug!("Signer #{}: Received a block validate response for a block we have not seen before. Ignoring...", self.signer_id);
+                        debug!("Reward Cycle #{} Signer #{}: Received a block validate response for a block we have not seen before. Ignoring...", self.reward_cycle, self.signer_id);
                         return;
                     }
                     Err(e) => {
                         error!(
-                            "Signer #{}: Failed to lookup block in signer db: {:?}",
-                            self.signer_id, e
+                            "Rewrad Cycle #{} Signer #{}: Failed to lookup block in signer db: {:?}",
+                            self.reward_cycle, self.signer_id, e
                         );
                         return;
                     }
@@ -404,7 +417,8 @@ impl Signer {
                     .insert_block(&block_info)
                     .expect("Failed to insert block in DB");
                 info!(
-                    "Signer #{}: Treating block validation for block {} as valid: {:?}",
+                    "Reward cycle #{} Signer #{}: Treating block validation for block {} as valid: {:?}",
+                    self.reward_cycle,
                     self.signer_id,
                     &block_info.block.block_id(),
                     block_info.valid
@@ -417,13 +431,13 @@ impl Signer {
                     Ok(Some(block_info)) => block_info,
                     Ok(None) => {
                         // We have not seen this block before. Why are we getting a response for it?
-                        debug!("Signer #{}: Received a block validate response for a block we have not seen before. Ignoring...", self.signer_id);
+                        debug!("Reward Cycle #{} Signer #{}: Received a block validate response for a block we have not seen before. Ignoring...", self.reward_cycle, self.signer_id);
                         return;
                     }
                     Err(e) => {
                         error!(
-                            "Signer #{}: Failed to lookup block in signer db: {:?}",
-                            self.signer_id, e
+                            "Reward Cycle #{} Signer #{}: Failed to lookup block in signer db: {:?}",
+                            self.reward_cycle, self.signer_id, e
                         );
                         return;
                     }
@@ -431,13 +445,14 @@ impl Signer {
                 block_info.valid = Some(false);
                 // Submit a rejection response to the .signers contract for miners
                 // to observe so they know to send another block and to prove signers are doing work);
-                warn!("Signer #{}: Broadcasting a block rejection due to stacks node validation failure...", self.signer_id);
+                warn!("Reward cycle #{} Signer #{}: Broadcasting a block rejection due to stacks node validation failure...", self.reward_cycle, self.signer_id);
                 if let Err(e) = self
                     .stackerdb
                     .send_message_with_retry(block_validate_reject.clone().into())
                 {
                     warn!(
-                        "Signer #{}: Failed to send block rejection to stacker-db: {e:?}",
+                        "Reward cycle #{} Signer #{}: Failed to send block rejection to stacker-db: {e:?}",
+                        self.reward_cycle,
                         self.signer_id
                     );
                 }
@@ -445,9 +460,14 @@ impl Signer {
             }
         };
         if let Some(mut nonce_request) = block_info.nonce_request.take() {
-            debug!("Signer #{}: Received a block validate response from the stacks node for a block we already received a nonce request for. Responding to the nonce request...", self.signer_id);
+            debug!("Reward cycle #{} Signer #{}: Received a block validate response from the stacks node for a block we already received a nonce request for. Responding to the nonce request...", self.reward_cycle, self.signer_id);
             // We have received validation from the stacks node. Determine our vote and update the request message
-            Self::determine_vote(self.signer_id, &mut block_info, &mut nonce_request);
+            Self::determine_vote(
+                self.signer_id,
+                self.reward_cycle,
+                &mut block_info,
+                &mut nonce_request,
+            );
             // Send the nonce request through with our vote
             let packet = Packet {
                 msg: Message::NonceRequest(nonce_request),
@@ -462,7 +482,8 @@ impl Signer {
             {
                 // We are the coordinator. Trigger a signing round for this block
                 debug!(
-                    "Signer #{}: triggering a signing round over the block {}",
+                    "Reward cycle #{} Signer #{}: triggering a signing round over the block {}",
+                    self.reward_cycle,
                     self.signer_id,
                     block_info.block.header.block_hash()
                 );
@@ -473,7 +494,7 @@ impl Signer {
                 });
             } else {
                 debug!(
-                    "Signer #{} ignoring block.", self.signer_id;
+                    "Reward cycle #{} Signer #{} ignoring block.", self.reward_cycle, self.signer_id;
                     "block_hash" => block_info.block.header.block_hash(),
                     "valid" => block_info.valid,
                     "signed_over" => block_info.signed_over,
@@ -521,8 +542,8 @@ impl Signer {
                 .submit_block_for_validation(block.clone())
                 .unwrap_or_else(|e| {
                     warn!(
-                        "Signer #{}: Failed to submit block for validation: {e:?}",
-                        self.signer_id
+                        "Reward cycle #{} Signer #{}: Failed to submit block for validation: {e:?}",
+                        self.reward_cycle, self.signer_id
                     );
                 });
         }
@@ -541,7 +562,8 @@ impl Signer {
             .process_inbound_messages(packets)
             .unwrap_or_else(|e| {
                 error!(
-                    "Signer #{}: Failed to process inbound messages as a signer: {e:?}",
+                    "Reward cycle #{} Signer #{}: Failed to process inbound messages as a signer: {e:?}",
+                    self.reward_cycle,
                     self.signer_id
                 );
                 vec![]
@@ -553,7 +575,8 @@ impl Signer {
             .process_inbound_messages(packets)
             .unwrap_or_else(|e| {
                 error!(
-                    "Signer #{}: Failed to process inbound messages as a coordinator: {e:?}",
+                    "Reward cycle #{} Signer #{}: Failed to process inbound messages as a coordinator: {e:?}",
+                    self.reward_cycle,
                     self.signer_id
                 );
                 (vec![], vec![])
@@ -581,7 +604,8 @@ impl Signer {
         else {
             // We currently reject anything that is not a block vote
             debug!(
-                "Signer #{}: Received a signature share request for an unknown message stream. Reject it.",
+                "Reward cycle #{} Signer #{}: Received a signature share request for an unknown message stream. Reject it.",
+                self.reward_cycle,
                 self.signer_id
             );
             return false;
@@ -596,8 +620,8 @@ impl Signer {
             Some(Some(vote)) => {
                 // Overwrite with our agreed upon value in case another message won majority or the coordinator is trying to cheat...
                 debug!(
-                    "Signer #{}: set vote for {} to {vote:?}",
-                    self.signer_id, block_vote.rejected
+                    "Reward cycle #{} Signer #{}: set vote for {} to {vote:?}",
+                    self.reward_cycle, self.signer_id, block_vote.rejected
                 );
                 request.message = vote.serialize_to_vec();
                 true
@@ -606,14 +630,14 @@ impl Signer {
                 // We never agreed to sign this block. Reject it.
                 // This can happen if the coordinator received enough votes to sign yes
                 // or no on a block before we received validation from the stacks node.
-                debug!("Signer #{}: Received a signature share request for a block we never agreed to sign. Ignore it.", self.signer_id);
+                debug!("Reward cycle #{} Signer #{}: Received a signature share request for a block we never agreed to sign. Ignore it.", self.reward_cycle, self.signer_id);
                 false
             }
             None => {
                 // We will only sign across block hashes or block hashes + b'n' byte for
                 // blocks we have seen a Nonce Request for (and subsequent validation)
                 // We are missing the context here necessary to make a decision. Reject the block
-                debug!("Signer #{}: Received a signature share request from an unknown block. Reject it.", self.signer_id);
+                debug!("Reward cycle #{} Signer #{}: Received a signature share request from an unknown block. Reject it.", self.reward_cycle, self.signer_id);
                 false
             }
         }
@@ -632,7 +656,8 @@ impl Signer {
         else {
             // We currently reject anything that is not a block
             debug!(
-                "Signer #{}: Received a nonce request for an unknown message stream. Reject it.",
+                "Reward cycle #{} Signer #{}: Received a nonce request for an unknown message stream. Reject it.",
+                self.reward_cycle,
                 self.signer_id
             );
             return false;
@@ -645,7 +670,7 @@ impl Signer {
         {
             Some(block_info) => block_info,
             None => {
-                debug!("Signer #{}: We have received a block sign request for a block we have not seen before. Cache the nonce request and submit the block for validation...", self.signer_id);
+                debug!("Reward Cycle #{} Signer #{}: We have received a block sign request for a block we have not seen before. Cache the nonce request and submit the block for validation...", self.reward_cycle, self.signer_id);
                 let block_info = BlockInfo::new_with_request(block.clone(), nonce_request.clone());
                 self.signer_db
                     .insert_block(&block_info)
@@ -654,7 +679,8 @@ impl Signer {
                     .submit_block_for_validation(block)
                     .unwrap_or_else(|e| {
                         warn!(
-                            "Signer #{}: Failed to submit block for validation: {e:?}",
+                            "Reward Cycle #{} Signer #{}: Failed to submit block for validation: {e:?}",
+                            self.reward_cycle,
                             self.signer_id
                         );
                     });
@@ -664,12 +690,17 @@ impl Signer {
 
         if block_info.valid.is_none() {
             // We have not yet received validation from the stacks node. Cache the request and wait for validation
-            debug!("Signer #{}: We have yet to receive validation from the stacks node for a nonce request. Cache the nonce request and wait for block validation...", self.signer_id);
+            debug!("Reward cycle #{} Signer #{}: We have yet to receive validation from the stacks node for a nonce request. Cache the nonce request and wait for block validation...", self.reward_cycle, self.signer_id);
             block_info.nonce_request = Some(nonce_request.clone());
             return false;
         }
 
-        Self::determine_vote(self.signer_id, &mut block_info, nonce_request);
+        Self::determine_vote(
+            self.signer_id,
+            self.reward_cycle,
+            &mut block_info,
+            nonce_request,
+        );
         self.signer_db
             .insert_block(&block_info)
             .expect("Failed to insert block in DB");
@@ -685,7 +716,7 @@ impl Signer {
         if self.approved_aggregate_public_key.is_some() {
             // We do not enforce a block contain any transactions except the aggregate votes when it is NOT already set
             // TODO: should be only allow special cased transactions during prepare phase before a key is set?
-            debug!("Signer #{}: Already have an aggregate key for reward cycle {}. Skipping transaction verification...", self.signer_id, self.reward_cycle);
+            debug!("Reward cycle #{} Signer #{}: Already have an aggregate key for reward cycle {}. Skipping transaction verification...", self.reward_cycle, self.signer_id, self.reward_cycle);
             return true;
         }
         if let Ok(expected_transactions) = self.get_expected_transactions(stacks_client) {
@@ -697,14 +728,16 @@ impl Signer {
                 .filter_map(|tx| {
                     if !block_tx_hashset.contains(&tx.txid()) {
                         debug!(
-                            "Signer #{}: expected txid {} is in the block",
+                            "Reward cycle #{} Signer #{}: expected txid {} is in the block",
+                            self.reward_cycle,
                             self.signer_id,
                             &tx.txid()
                         );
                         Some(tx)
                     } else {
                         debug!(
-                            "Signer #{}: missing expected txid {}",
+                            "Reward cycle #{} Signer #{}: missing expected txid {}",
+                            self.reward_cycle,
                             self.signer_id,
                             &tx.txid()
                         );
@@ -714,7 +747,7 @@ impl Signer {
                 .collect::<Vec<_>>();
             let is_valid = missing_transactions.is_empty();
             if !is_valid {
-                debug!("Signer #{}: Broadcasting a block rejection due to missing expected transactions...", self.signer_id);
+                debug!("Reward cycle #{} Signer #{}: Broadcasting a block rejection due to missing expected transactions...", self.reward_cycle, self.signer_id);
                 let block_rejection = BlockRejection::new(
                     block.header.signer_signature_hash(),
                     RejectCode::MissingTransactions(missing_transactions),
@@ -725,7 +758,8 @@ impl Signer {
                     .send_message_with_retry(block_rejection.into())
                 {
                     warn!(
-                        "Signer #{}: Failed to send block rejection to stacker-db: {e:?}",
+                        "Reward cycle #{} Signer #{}: Failed to send block rejection to stacker-db: {e:?}",
+                        self.reward_cycle,
                         self.signer_id
                     );
                 }
@@ -734,7 +768,8 @@ impl Signer {
         } else {
             // Failed to connect to the stacks node to get transactions. Cannot validate the block. Reject it.
             debug!(
-                "Signer #{}: Broadcasting a block rejection due to signer connectivity issues...",
+                "Reward cycle #{} Signer #{}: Broadcasting a block rejection due to signer connectivity issues...",
+                self.reward_cycle,
                 self.signer_id
             );
             let block_rejection = BlockRejection::new(
@@ -747,7 +782,8 @@ impl Signer {
                 .send_message_with_retry(block_rejection.into())
             {
                 warn!(
-                    "Signer #{}: Failed to send block submission to stacker-db: {e:?}",
+                    "Reward cycle #{} Signer #{}: Failed to send block submission to stacker-db: {e:?}",
+                    self.reward_cycle,
                     self.signer_id
                 );
             }
@@ -781,8 +817,8 @@ impl Signer {
     ) -> Result<Vec<StacksTransaction>, ClientError> {
         if self.next_signer_slot_ids.is_empty() {
             debug!(
-                "Signer #{}: No next signers. Skipping transaction retrieval.",
-                self.signer_id
+                "Reward cycle #{} Signer #{}: No next signers. Skipping transaction retrieval.",
+                self.reward_cycle, self.signer_id
             );
             return Ok(vec![]);
         }
@@ -805,19 +841,22 @@ impl Signer {
     /// Determine the vote for a block and update the block info and nonce request accordingly
     fn determine_vote(
         signer_id: u32,
+        reward_cycle: u64,
         block_info: &mut BlockInfo,
         nonce_request: &mut NonceRequest,
     ) {
         let rejected = !block_info.valid.unwrap_or(false);
         if rejected {
             debug!(
-                "Signer #{}: Rejecting block {}",
+                "Reward cycle #{} Signer #{}: Rejecting block {}",
+                reward_cycle,
                 signer_id,
                 block_info.block.block_id()
             );
         } else {
             debug!(
-                "Signer #{}: Accepting block {}",
+                "Reward cycle #{} Signer #{}: Accepting block {}",
+                reward_cycle,
                 signer_id,
                 block_info.block.block_id()
             );
@@ -863,8 +902,8 @@ impl Signer {
             Some(packet)
         } else {
             debug!(
-                "Signer #{}: Failed to verify wsts packet with {}: {packet:?}",
-                self.signer_id, coordinator_public_key
+                "Reward cycle #{} Signer #{}: Failed to verify wsts packet with {}: {packet:?}",
+                self.reward_cycle, self.signer_id, coordinator_public_key
             );
             None
         }
@@ -881,21 +920,30 @@ impl Signer {
             // Signers only every trigger non-taproot signing rounds over blocks. Ignore SignTaproot results
             match operation_result {
                 OperationResult::Sign(signature) => {
-                    debug!("Signer #{}: Received signature result", self.signer_id);
+                    debug!(
+                        "Reward cycle #{} Signer #{}: Received signature result",
+                        self.reward_cycle, self.signer_id
+                    );
                     self.process_signature(signature);
                 }
                 OperationResult::SignTaproot(_) => {
-                    debug!("Signer #{}: Received a signature result for a taproot signature. Nothing to broadcast as we currently sign blocks with a FROST signature.", self.signer_id);
+                    debug!("Reward cycle #{} Signer #{}: Received a signature result for a taproot signature. Nothing to broadcast as we currently sign blocks with a FROST signature.", self.reward_cycle, self.signer_id);
                 }
                 OperationResult::Dkg(dkg_public_key) => {
                     self.process_dkg(stacks_client, dkg_public_key);
                 }
                 OperationResult::SignError(e) => {
-                    warn!("Signer #{}: Received a Sign error: {e:?}", self.signer_id);
+                    warn!(
+                        "Reward cycle #{} Signer #{}: Received a Sign error: {e:?}",
+                        self.reward_cycle, self.signer_id
+                    );
                     self.process_sign_error(e);
                 }
                 OperationResult::DkgError(e) => {
-                    warn!("Signer #{}: Received a DKG error: {e:?}", self.signer_id);
+                    warn!(
+                        "Reward cycle #{} Signer #{}: Received a DKG error: {e:?}",
+                        self.reward_cycle, self.signer_id
+                    );
                     // TODO: process these errors and track malicious signers to report
                 }
             }
@@ -912,7 +960,8 @@ impl Signer {
         .unwrap_or(StacksEpochId::Epoch24);
         let tx_fee = if epoch < StacksEpochId::Epoch30 {
             debug!(
-                "Signer #{}: in pre Epoch 3.0 cycles, must set a transaction fee for the DKG vote.",
+                "Reward cycle #{} Signer #{}: in pre Epoch 3.0 cycles, must set a transaction fee for the DKG vote.",
+                self.reward_cycle,
                 self.signer_id
             );
             Some(self.tx_fee_ustx)
@@ -930,8 +979,8 @@ impl Signer {
         })
         .map_err(|e| {
             warn!(
-                "Signer #{}: Unable to get signer transactions: {e:?}",
-                self.signer_id
+                "Reward cycle #{} Signer #{}: Unable to get signer transactions: {e:?}",
+                self.reward_cycle, self.signer_id
             );
         })
         .unwrap_or_default();
@@ -956,14 +1005,16 @@ impl Signer {
                     new_transaction,
                 ) {
                     warn!(
-                        "Signer #{}: Failed to broadcast DKG public key vote ({dkg_public_key:?}): {e:?}",
+                        "Reward cycle #{} Signer #{}: Failed to broadcast DKG public key vote ({dkg_public_key:?}): {e:?}",
+                        self.reward_cycle,
                         self.signer_id
                     );
                 }
             }
             Err(e) => {
                 warn!(
-                    "Signer #{}: Failed to build DKG public key vote ({dkg_public_key:?}) transaction: {e:?}.",
+                    "Reward cycle #{} Signer #{}: Failed to build DKG public key vote ({dkg_public_key:?}) transaction: {e:?}.",
+                    self.reward_cycle,
                     self.signer_id
                 );
             }
@@ -984,7 +1035,8 @@ impl Signer {
                     .map_err(backoff::Error::transient)
             }) else {
                 warn!(
-                    "Signer #{}: Unable to get account nonce for address: {address}.",
+                    "Reward cycle #{} Signer #{}: Unable to get account nonce for address: {address}.",
+                    self.reward_cycle,
                     self.signer_id
                 );
                 continue;
@@ -1006,22 +1058,23 @@ impl Signer {
         if self.approved_aggregate_public_key.is_some() {
             // We do not enforce a block contain any transactions except the aggregate votes when it is NOT already set
             info!(
-                "Signer #{}: Already has an aggregate key for reward cycle {}. Do not broadcast the transaction ({txid:?}).",
-                self.signer_id, self.reward_cycle
+                "Reward cycle #{} Signer #{}: Already has an approved aggregate key. Do not broadcast the transaction ({txid:?}).",
+                self.reward_cycle, self.signer_id
             );
             return Ok(());
         }
         if epoch >= StacksEpochId::Epoch30 {
-            debug!("Signer #{}: Received a DKG result while in epoch 3.0. Broadcast the transaction only to stackerDB.", self.signer_id);
+            debug!("Reward cycle #{} Signer #{}: Received a DKG result while in epoch 3.0. Broadcast the transaction only to stackerDB.", self.reward_cycle, self.signer_id);
         } else if epoch == StacksEpochId::Epoch25 {
-            debug!("Signer #{}: Received a DKG result while in epoch 2.5. Broadcast the transaction to the mempool.", self.signer_id);
+            debug!("Reward cycle #{} Signer #{}: Received a DKG result while in epoch 2.5. Broadcast the transaction to the mempool.", self.reward_cycle, self.signer_id);
             stacks_client.submit_transaction(&new_transaction)?;
             info!(
-                "Signer #{}: Submitted DKG vote transaction ({txid:?}) to the mempool",
+                "Reward cycle #{} Signer #{}: Submitted DKG vote transaction ({txid:?}) to the mempool",
+                self.reward_cycle,
                 self.signer_id
             );
         } else {
-            debug!("Signer #{}: Received a DKG result, but are in an unsupported epoch. Do not broadcast the transaction ({}).", self.signer_id, new_transaction.txid());
+            debug!("Reward cycle #{} Signer #{}: Received a DKG result, but are in an unsupported epoch. Do not broadcast the transaction ({}).", self.reward_cycle, self.signer_id, new_transaction.txid());
             return Ok(());
         }
         // For all Pox-4 epochs onwards, broadcast the results also to stackerDB for other signers/miners to observe
@@ -1029,8 +1082,8 @@ impl Signer {
         let signer_message = SignerMessage::Transactions(signer_transactions);
         self.stackerdb.send_message_with_retry(signer_message)?;
         info!(
-            "Signer #{}: Broadcasted DKG vote transaction ({txid}) to stacker DB",
-            self.signer_id,
+            "Reward cycle #{} Signer #{}: Broadcasted DKG vote transaction ({txid}) to stacker DB",
+            self.reward_cycle, self.signer_id,
         );
         Ok(())
     }
@@ -1042,7 +1095,8 @@ impl Signer {
         let message = self.coordinator.get_message();
         let Some(block_vote): Option<NakamotoBlockVote> = read_next(&mut &message[..]).ok() else {
             debug!(
-                "Signer #{}: Received a signature result for a non-block. Nothing to broadcast.",
+                "Reward cycle #{} Signer #{}: Received a signature result for a non-block. Nothing to broadcast.",
+                self.reward_cycle,
                 self.signer_id
             );
             return;
@@ -1063,13 +1117,13 @@ impl Signer {
 
         // Submit signature result to miners to observe
         debug!(
-            "Signer #{}: submit block response {block_submission:?}",
-            self.signer_id
+            "Reward cycle #{} Signer #{}: submit block response {block_submission:?}",
+            self.reward_cycle, self.signer_id
         );
         if let Err(e) = self.stackerdb.send_message_with_retry(block_submission) {
             warn!(
-                "Signer #{}: Failed to send block submission to stacker-db: {e:?}",
-                self.signer_id
+                "Reward cycle #{} Signer #{}: Failed to send block submission to stacker-db: {e:?}",
+                self.reward_cycle, self.signer_id
             );
         }
     }
@@ -1086,7 +1140,8 @@ impl Signer {
             else {
                 // This is not a block vote either. We cannot process this error
                 debug!(
-                    "Signer #{}: Received a signature error for a non-block. Nothing to broadcast.",
+                    "Reward Cycle #{} Signer #{}: Received a signature error for a non-block. Nothing to broadcast.",
+                    self.reward_cycle,
                     self.signer_id
                 );
                 return;
@@ -1097,7 +1152,7 @@ impl Signer {
                 .expect("Failed to connect to signer DB")
             else {
                 debug!(
-                    "Signer #{}: Received a signature result for a block we have not seen before. Ignoring...", self.signer_id
+                    "Reward Cycle #{} Signer #{}: Received a signature result for a block we have not seen before. Ignoring...", self.reward_cycle, self.signer_id
                 );
                 return;
             };
@@ -1106,8 +1161,8 @@ impl Signer {
         let block_rejection =
             BlockRejection::new(block.header.signer_signature_hash(), RejectCode::from(e));
         debug!(
-            "Signer #{}: Broadcasting block rejection: {block_rejection:?}",
-            self.signer_id
+            "Reward cycle #{} Signer #{}: Broadcasting block rejection: {block_rejection:?}",
+            self.reward_cycle, self.signer_id
         );
         // Submit signature result to miners to observe
         if let Err(e) = self
@@ -1115,7 +1170,8 @@ impl Signer {
             .send_message_with_retry(block_rejection.into())
         {
             warn!(
-                "Signer #{}: Failed to send block rejection submission to stacker-db: {e:?}",
+                "Reward cycle #{} Signer #{}: Failed to send block rejection submission to stacker-db: {e:?}",
+                self.reward_cycle,
                 self.signer_id
             );
         }
@@ -1131,13 +1187,14 @@ impl Signer {
         match res.send(operation_results) {
             Ok(_) => {
                 debug!(
-                    "Signer #{}: Successfully sent {} operation result(s)",
-                    self.signer_id, nmb_results
+                    "Reward cycle #{} Signer #{}: Successfully sent {} operation result(s)",
+                    self.reward_cycle, self.signer_id, nmb_results
                 )
             }
             Err(e) => {
                 warn!(
-                    "Signer #{}: Failed to send {nmb_results} operation results: {e:?}",
+                    "Reward cycle #{} Signer #{}: Failed to send {nmb_results} operation results: {e:?}",
+                    self.reward_cycle,
                     self.signer_id
                 );
             }
@@ -1147,17 +1204,22 @@ impl Signer {
     /// Sending all provided packets through stackerdb with a retry
     fn send_outbound_messages(&mut self, outbound_messages: Vec<Packet>) {
         debug!(
-            "Signer #{}: Sending {} messages to other stacker-db instances.",
+            "Reward cycle #{} Signer #{}: Sending {} messages to other stacker-db instances.",
+            self.reward_cycle,
             self.signer_id,
             outbound_messages.len()
         );
         for msg in outbound_messages {
             let ack = self.stackerdb.send_message_with_retry(msg.into());
             if let Ok(ack) = ack {
-                debug!("Signer #{}: send outbound ACK: {ack:?}", self.signer_id);
+                debug!(
+                    "Reward cycle #{} Signer #{}: send outbound ACK: {ack:?}",
+                    self.reward_cycle, self.signer_id
+                );
             } else {
                 warn!(
-                    "Signer #{}: Failed to send message to stacker-db instance: {ack:?}",
+                    "Reward cycle #{} Signer #{}: Failed to send message to stacker-db instance: {ack:?}",
+                    self.reward_cycle,
                     self.signer_id
                 );
             }
@@ -1177,15 +1239,16 @@ impl Signer {
                 .set_aggregate_public_key(self.approved_aggregate_public_key);
             // We have an approved aggregate public key. Do nothing further
             debug!(
-                "Signer #{}: Have updated DKG value to {:?}.",
-                self.signer_id, self.approved_aggregate_public_key
+                "Reward cycle #{} Signer #{}: Have updated DKG value to {:?}.",
+                self.reward_cycle, self.signer_id, self.approved_aggregate_public_key
             );
             return Ok(());
         };
         let coordinator_id = self.coordinator_selector.get_coordinator().0;
         if self.signer_id == coordinator_id && self.state == State::Idle {
             debug!(
-                "Signer #{}: Checking if old vote transaction exists in StackerDB...",
+                "Reward cycle #{} Signer #{}: Checking if old vote transaction exists in StackerDB...",
+                self.reward_cycle,
                 self.signer_id
             );
             // Have I already voted and have a pending transaction? Check stackerdb for the same round number and reward cycle vote transaction
@@ -1193,7 +1256,7 @@ impl Signer {
             let signer_address = stacks_client.get_signer_address();
             let account_nonces = self.get_account_nonces(stacks_client, &[*signer_address]);
             let old_transactions = self.get_signer_transactions(&account_nonces).map_err(|e| {
-                warn!("Signer #{}: Failed to get old signer transactions: {e:?}. May trigger DKG unnecessarily", self.signer_id);
+                warn!("Reward cycle #{} Signer #{}: Failed to get old signer transactions: {e:?}. May trigger DKG unnecessarily", self.reward_cycle, self.signer_id);
             }).unwrap_or_default();
             // Check if we have an existing vote transaction for the same round and reward cycle
             for transaction in old_transactions.iter() {
@@ -1203,7 +1266,7 @@ impl Signer {
                     && params.voting_round == self.coordinator.current_dkg_id
                     && reward_cycle == self.reward_cycle
                 {
-                    debug!("Signer #{}: Not triggering a DKG round. Already have a pending vote transaction.", self.signer_id;
+                    debug!("Reward cycle #{} Signer #{}: Not triggering a DKG round. Already have a pending vote transaction.", self.reward_cycle, self.signer_id;
                         "txid" => %transaction.txid(),
                         "aggregate_key" => %params.aggregate_key,
                         "voting_round" => params.voting_round
@@ -1221,11 +1284,11 @@ impl Signer {
             {
                 // TODO Check if the vote failed and we need to retrigger the DKG round not just if we have already voted...
                 // TODO need logic to trigger another DKG round if a certain amount of time passes and we still have no confirmed DKG vote
-                debug!("Signer #{}: Not triggering a DKG round. Already voted and we may need to wait for more votes to arrive.", self.signer_id);
+                debug!("Reward cycle #{} Signer #{}: Not triggering a DKG round. Already voted and we may need to wait for more votes to arrive.", self.reward_cycle, self.signer_id);
                 return Ok(());
             }
             if self.commands.front() != Some(&Command::Dkg) {
-                info!("Signer #{} is the current coordinator for {reward_cycle} and must trigger DKG. Queuing DKG command...", self.signer_id);
+                info!("Reward cycle #{} Signer #{} is the current coordinator and must trigger DKG. Queuing DKG command...", self.reward_cycle, self.signer_id);
                 self.commands.push_front(Command::Dkg);
             }
         }
@@ -1240,22 +1303,27 @@ impl Signer {
         res: Sender<Vec<OperationResult>>,
         current_reward_cycle: u64,
     ) -> Result<(), ClientError> {
-        debug!("Signer #{}: Processing event: {event:?}", self.signer_id);
+        debug!(
+            "Reward cycle #{} Signer #{}: Processing event: {event:?}",
+            self.reward_cycle, self.signer_id
+        );
         match event {
             Some(SignerEvent::BlockValidationResponse(block_validate_response)) => {
                 debug!(
-                    "Signer #{}: Received a block proposal result from the stacks node...",
+                    "Reward cycle #{} Signer #{}: Received a block proposal result from the stacks node...",
+                    self.reward_cycle,
                     self.signer_id
                 );
                 self.handle_block_validate_response(stacks_client, block_validate_response, res)
             }
             Some(SignerEvent::SignerMessages(signer_set, messages)) => {
                 if *signer_set != self.stackerdb.get_signer_set() {
-                    debug!("Signer #{}: Received a signer message for a reward cycle that does not belong to this signer. Ignoring...", self.signer_id);
+                    debug!("Reward cycle #{} Signer #{}: Received a signer message for a reward cycle that does not belong to this signer. Ignoring...", self.reward_cycle, self.signer_id);
                     return Ok(());
                 }
                 debug!(
-                    "Signer #{}: Received {} messages from the other signers...",
+                    "Reward cycle #{} Signer #{}: Received {} messages from the other signers...",
+                    self.reward_cycle,
                     self.signer_id,
                     messages.len()
                 );
@@ -1264,22 +1332,29 @@ impl Signer {
             Some(SignerEvent::ProposedBlocks(blocks)) => {
                 if current_reward_cycle != self.reward_cycle {
                     // There is not point in processing blocks if we are not the current reward cycle (we can never actually contribute to signing these blocks)
-                    debug!("Signer #{}: Received a proposed block, but this signer's reward cycle ({}) is not the current one ({}). Ignoring...", self.signer_id, self.reward_cycle, current_reward_cycle);
+                    debug!("Reward cycle #{} Signer #{}: Received a proposed block, but this signer's reward cycle is not the current one ({}). Ignoring...", self.reward_cycle, self.signer_id, current_reward_cycle);
                     return Ok(());
                 }
                 debug!(
-                    "Signer #{}: Received {} block proposals from the miners...",
+                    "Reward cycle #{} Signer #{}: Received {} block proposals from the miners...",
+                    self.reward_cycle,
                     self.signer_id,
                     blocks.len()
                 );
                 self.handle_proposed_blocks(stacks_client, blocks);
             }
             Some(SignerEvent::StatusCheck) => {
-                debug!("Signer #{}: Received a status check event.", self.signer_id)
+                debug!(
+                    "Reward cycle #{} Signer #{}: Received a status check event.",
+                    self.reward_cycle, self.signer_id
+                )
             }
             None => {
                 // No event. Do nothing.
-                debug!("Signer #{}: No event received", self.signer_id)
+                debug!(
+                    "Reward cycle #{} Signer #{}: No event received",
+                    self.reward_cycle, self.signer_id
+                )
             }
         }
         Ok(())

From 28bcd1bc1b6f12c2223bb57704a4ca9cd792507b Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 8 Mar 2024 09:56:58 -0500
Subject: [PATCH 1061/1166] CRC: add helper display for signer and reward cycle

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/runloop.rs |  15 +-
 stacks-signer/src/signer.rs  | 411 ++++++++++-------------------------
 2 files changed, 117 insertions(+), 309 deletions(-)

diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index dff6f46ae5..d131d5884b 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -252,7 +252,7 @@ impl RunLoop {
                 if let Some(signer) = self.stacks_signers.get_mut(&prior_reward_set) {
                     if signer.reward_cycle == prior_reward_cycle {
                         // The signers have been calculated for the next reward cycle. Update the current one
-                        debug!("Reward cycle #{} Signer #{}: Next reward cycle ({reward_cycle}) signer set calculated. Reconfiguring signer.", signer.reward_cycle, signer.signer_id);
+                        debug!("{signer}: Next reward cycle ({reward_cycle}) signer set calculated. Reconfiguring signer.");
                         signer.next_signer_addresses = new_signer_config
                             .signer_entries
                             .signer_ids
@@ -286,7 +286,7 @@ impl RunLoop {
                 .refresh_coordinator(&pox_consensus_hash);
             if old_coordinator_id != updated_coordinator_id {
                 debug!(
-                    "Reward cycle #{} Signer #{}: Coordinator updated. Resetting state to Idle.", signer.reward_cycle, signer.signer_id;
+                    "{signer}: Coordinator updated. Resetting state to Idle.";
                     "old_coordinator_id" => {old_coordinator_id},
                     "updated_coordinator_id" => {updated_coordinator_id},
                     "pox_consensus_hash" => %pox_consensus_hash
@@ -363,22 +363,17 @@ impl SignerRunLoop<Vec<OperationResult>, RunLoopCommand> for RunLoop {
                 res.clone(),
                 current_reward_cycle,
             ) {
-                error!(
-                    "Reward cycle #{} Signer #{} errored processing event: {e}",
-                    signer.reward_cycle, signer.signer_id,
-                );
+                error!("{signer}: errored processing event: {e}");
             }
             if let Some(command) = self.commands.pop_front() {
                 let reward_cycle = command.reward_cycle;
                 if signer.reward_cycle != reward_cycle {
                     warn!(
-                        "Reward cycle #{} Signer #{}: not registered for reward cycle {reward_cycle}. Ignoring command: {command:?}", signer.reward_cycle, signer.signer_id
+                        "{signer}: not registered for reward cycle {reward_cycle}. Ignoring command: {command:?}"
                     );
                 } else {
                     info!(
-                        "Reward cycle #{} Signer #{}: Queuing an external runloop command ({:?}): {command:?}",
-                        signer.reward_cycle,
-                        signer.signer_id,
+                        "{signer}: Queuing an external runloop command ({:?}): {command:?}",
                         signer
                             .signing_round
                             .public_keys
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index 6ac16664ec..b03a2da366 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -166,6 +166,16 @@ pub struct Signer {
     pub signer_db: SignerDb,
 }
 
+impl std::fmt::Display for Signer {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "Reward Cycle #{} Signer #{}",
+            self.reward_cycle, self.signer_id,
+        )
+    }
+}
+
 impl From<SignerConfig> for Signer {
     fn from(signer_config: SignerConfig) -> Self {
         let stackerdb = StackerDB::from(&signer_config);
@@ -267,32 +277,24 @@ impl Signer {
                 }) {
                     Ok(last_round) => last_round,
                     Err(e) => {
-                        error!("Reward cycle #{} Signer #{}: Unable to perform DKG. Failed to get last round from stacks node: {e:?}", self.reward_cycle, self.signer_id);
+                        error!("{self}: Unable to perform DKG. Failed to get last round from stacks node: {e:?}");
                         return;
                     }
                 };
                 // The dkg id will increment internally following "start_dkg_round" so do not increment it here
                 self.coordinator.current_dkg_id = vote_round.unwrap_or(0);
                 info!(
-                    "Reward cycle #{} Signer #{}: Starting DKG vote",
-                    self.reward_cycle,
-                    self.signer_id;
+                    "{self}: Starting DKG vote";
                     "round" => self.coordinator.current_dkg_id.wrapping_add(1),
                     "cycle" => self.reward_cycle,
                 );
                 match self.coordinator.start_dkg_round() {
                     Ok(msg) => {
                         let ack = self.stackerdb.send_message_with_retry(msg.into());
-                        debug!(
-                            "Reward cycle #{} Signer #{}: ACK: {ack:?}",
-                            self.reward_cycle, self.signer_id
-                        );
+                        debug!("{self}: ACK: {ack:?}",);
                     }
                     Err(e) => {
-                        error!(
-                            "Reward cycle #{} Signer #{}: Failed to start DKG: {e:?}",
-                            self.reward_cycle, self.signer_id
-                        );
+                        error!("{self}: Failed to start DKG: {e:?}",);
                         return;
                     }
                 }
@@ -303,7 +305,7 @@ impl Signer {
                 merkle_root,
             } => {
                 if self.approved_aggregate_public_key.is_none() {
-                    debug!("Reward cycle #{} Signer #{}: Cannot sign a block without an approved aggregate public key. Ignore it.", self.reward_cycle, self.signer_id);
+                    debug!("{self}: Cannot sign a block without an approved aggregate public key. Ignore it.");
                     return;
                 }
                 let signer_signature_hash = block.header.signer_signature_hash();
@@ -313,10 +315,10 @@ impl Signer {
                     .unwrap_or_else(|_| Some(BlockInfo::new(block.clone())))
                     .unwrap_or_else(|| BlockInfo::new(block.clone()));
                 if block_info.signed_over {
-                    debug!("Reward cycle #{} Signer #{}: Received a sign command for a block we are already signing over. Ignore it.", self.reward_cycle, self.signer_id);
+                    debug!("{self}: Received a sign command for a block we are already signing over. Ignore it.");
                     return;
                 }
-                info!("Reward cycle #{} Signer #{}: Signing block", self.reward_cycle, self.signer_id;
+                info!("{self}: Signing block";
                          "block_consensus_hash" => %block.header.consensus_hash,
                          "block_height" => block.header.chain_length,
                          "pre_sign_block_id" => %block.block_id(),
@@ -328,22 +330,16 @@ impl Signer {
                 ) {
                     Ok(msg) => {
                         let ack = self.stackerdb.send_message_with_retry(msg.into());
-                        debug!(
-                            "Reward cycle #{} Signer #{}: ACK: {ack:?}",
-                            self.reward_cycle, self.signer_id
-                        );
+                        debug!("{self}: ACK: {ack:?}",);
                         block_info.signed_over = true;
                         self.signer_db
                             .insert_block(&block_info)
                             .unwrap_or_else(|e| {
-                                error!("Failed to insert block in DB: {e:?}");
+                                error!("{self}: Failed to insert block in DB: {e:?}");
                             });
                     }
                     Err(e) => {
-                        error!(
-                            "Reward cycle #{} Signer #{}: Failed to start signing block: {e:?}",
-                            self.reward_cycle, self.signer_id
-                        );
+                        error!("{self}: Failed to start signing block: {e:?}",);
                         return;
                     }
                 }
@@ -359,28 +355,19 @@ impl Signer {
             State::Idle => {
                 if coordinator_id != self.signer_id {
                     debug!(
-                        "Reward cycle #{} Signer #{}: Coordinator is {coordinator_id:?}. Will not process any commands...",
-                        self.reward_cycle,
-                        self.signer_id
+                        "{self}: Coordinator is {coordinator_id:?}. Will not process any commands...",
                     );
                     return;
                 }
                 if let Some(command) = self.commands.pop_front() {
                     self.execute_command(stacks_client, &command);
                 } else {
-                    debug!(
-                        "Reward cycle #{} Signer #{}: Nothing to process. Waiting for command...",
-                        self.reward_cycle, self.signer_id
-                    );
+                    debug!("{self}: Nothing to process. Waiting for command...",);
                 }
             }
             State::OperationInProgress => {
                 // We cannot execute the next command until the current one is finished...
-                debug!(
-                    "Reward cycle #{} Signer #{}: Waiting for coordinator {coordinator_id:?} operation to finish...",
-                    self.reward_cycle,
-                    self.signer_id,
-                );
+                debug!("{self}: Waiting for coordinator {coordinator_id:?} operation to finish...",);
             }
         }
     }
@@ -400,14 +387,11 @@ impl Signer {
                     Ok(Some(block_info)) => block_info,
                     Ok(None) => {
                         // We have not seen this block before. Why are we getting a response for it?
-                        debug!("Reward Cycle #{} Signer #{}: Received a block validate response for a block we have not seen before. Ignoring...", self.reward_cycle, self.signer_id);
+                        debug!("{self}: Received a block validate response for a block we have not seen before. Ignoring...");
                         return;
                     }
                     Err(e) => {
-                        error!(
-                            "Rewrad Cycle #{} Signer #{}: Failed to lookup block in signer db: {:?}",
-                            self.reward_cycle, self.signer_id, e
-                        );
+                        error!("{self}: Failed to lookup block in signer db: {e:?}",);
                         return;
                     }
                 };
@@ -415,11 +399,9 @@ impl Signer {
                 block_info.valid = Some(is_valid);
                 self.signer_db
                     .insert_block(&block_info)
-                    .expect("Failed to insert block in DB");
+                    .expect(&format!("{self}: Failed to insert block in DB"));
                 info!(
-                    "Reward cycle #{} Signer #{}: Treating block validation for block {} as valid: {:?}",
-                    self.reward_cycle,
-                    self.signer_id,
+                    "{self}: Treating block validation for block {} as valid: {:?}",
                     &block_info.block.block_id(),
                     block_info.valid
                 );
@@ -431,43 +413,31 @@ impl Signer {
                     Ok(Some(block_info)) => block_info,
                     Ok(None) => {
                         // We have not seen this block before. Why are we getting a response for it?
-                        debug!("Reward Cycle #{} Signer #{}: Received a block validate response for a block we have not seen before. Ignoring...", self.reward_cycle, self.signer_id);
+                        debug!("{self}: Received a block validate response for a block we have not seen before. Ignoring...");
                         return;
                     }
                     Err(e) => {
-                        error!(
-                            "Reward Cycle #{} Signer #{}: Failed to lookup block in signer db: {:?}",
-                            self.reward_cycle, self.signer_id, e
-                        );
+                        error!("{self}: Failed to lookup block in signer db: {e:?}");
                         return;
                     }
                 };
                 block_info.valid = Some(false);
                 // Submit a rejection response to the .signers contract for miners
                 // to observe so they know to send another block and to prove signers are doing work);
-                warn!("Reward cycle #{} Signer #{}: Broadcasting a block rejection due to stacks node validation failure...", self.reward_cycle, self.signer_id);
+                warn!("{self}: Broadcasting a block rejection due to stacks node validation failure...");
                 if let Err(e) = self
                     .stackerdb
                     .send_message_with_retry(block_validate_reject.clone().into())
                 {
-                    warn!(
-                        "Reward cycle #{} Signer #{}: Failed to send block rejection to stacker-db: {e:?}",
-                        self.reward_cycle,
-                        self.signer_id
-                    );
+                    warn!("{self}: Failed to send block rejection to stacker-db: {e:?}",);
                 }
                 block_info
             }
         };
         if let Some(mut nonce_request) = block_info.nonce_request.take() {
-            debug!("Reward cycle #{} Signer #{}: Received a block validate response from the stacks node for a block we already received a nonce request for. Responding to the nonce request...", self.reward_cycle, self.signer_id);
+            debug!("{self}: Received a block validate response from the stacks node for a block we already received a nonce request for. Responding to the nonce request...");
             // We have received validation from the stacks node. Determine our vote and update the request message
-            Self::determine_vote(
-                self.signer_id,
-                self.reward_cycle,
-                &mut block_info,
-                &mut nonce_request,
-            );
+            self.determine_vote(&mut block_info, &mut nonce_request);
             // Send the nonce request through with our vote
             let packet = Packet {
                 msg: Message::NonceRequest(nonce_request),
@@ -482,9 +452,7 @@ impl Signer {
             {
                 // We are the coordinator. Trigger a signing round for this block
                 debug!(
-                    "Reward cycle #{} Signer #{}: triggering a signing round over the block {}",
-                    self.reward_cycle,
-                    self.signer_id,
+                    "{self}: triggering a signing round over the block {}",
                     block_info.block.header.block_hash()
                 );
                 self.commands.push_back(Command::Sign {
@@ -494,7 +462,7 @@ impl Signer {
                 });
             } else {
                 debug!(
-                    "Reward cycle #{} Signer #{} ignoring block.", self.reward_cycle, self.signer_id;
+                    "{self}: ignoring block.";
                     "block_hash" => block_info.block.header.block_hash(),
                     "valid" => block_info.valid,
                     "signed_over" => block_info.signed_over,
@@ -504,7 +472,7 @@ impl Signer {
         }
         self.signer_db
             .insert_block(&block_info)
-            .expect("Failed to insert block in DB");
+            .expect(&format!("{self}: Failed to insert block in DB"));
     }
 
     /// Handle signer messages submitted to signers stackerdb
@@ -535,16 +503,13 @@ impl Signer {
             self.signer_db
                 .insert_block(&BlockInfo::new(block.clone()))
                 .unwrap_or_else(|e| {
-                    error!("Failed to insert block in DB: {e:?}");
+                    error!("{self}: Failed to insert block in DB: {e:?}");
                 });
             // Submit the block for validation
             stacks_client
                 .submit_block_for_validation(block.clone())
                 .unwrap_or_else(|e| {
-                    warn!(
-                        "Reward cycle #{} Signer #{}: Failed to submit block for validation: {e:?}",
-                        self.reward_cycle, self.signer_id
-                    );
+                    warn!("{self}: Failed to submit block for validation: {e:?}");
                 });
         }
     }
@@ -561,11 +526,7 @@ impl Signer {
             .signing_round
             .process_inbound_messages(packets)
             .unwrap_or_else(|e| {
-                error!(
-                    "Reward cycle #{} Signer #{}: Failed to process inbound messages as a signer: {e:?}",
-                    self.reward_cycle,
-                    self.signer_id
-                );
+                error!("{self}: Failed to process inbound messages as a signer: {e:?}",);
                 vec![]
             });
 
@@ -574,11 +535,7 @@ impl Signer {
             .coordinator
             .process_inbound_messages(packets)
             .unwrap_or_else(|e| {
-                error!(
-                    "Reward cycle #{} Signer #{}: Failed to process inbound messages as a coordinator: {e:?}",
-                    self.reward_cycle,
-                    self.signer_id
-                );
+                error!("{self}: Failed to process inbound messages as a coordinator: {e:?}");
                 (vec![], vec![])
             });
 
@@ -604,9 +561,7 @@ impl Signer {
         else {
             // We currently reject anything that is not a block vote
             debug!(
-                "Reward cycle #{} Signer #{}: Received a signature share request for an unknown message stream. Reject it.",
-                self.reward_cycle,
-                self.signer_id
+                "{self}: Received a signature share request for an unknown message stream. Reject it.",
             );
             return false;
         };
@@ -614,15 +569,12 @@ impl Signer {
         match self
             .signer_db
             .block_lookup(&block_vote.signer_signature_hash)
-            .expect("Failed to connect to signer DB")
+            .expect(&format!("{self}: Failed to connect to DB"))
             .map(|b| b.vote)
         {
             Some(Some(vote)) => {
                 // Overwrite with our agreed upon value in case another message won majority or the coordinator is trying to cheat...
-                debug!(
-                    "Reward cycle #{} Signer #{}: set vote for {} to {vote:?}",
-                    self.reward_cycle, self.signer_id, block_vote.rejected
-                );
+                debug!("{self}: set vote for {} to {vote:?}", block_vote.rejected);
                 request.message = vote.serialize_to_vec();
                 true
             }
@@ -630,14 +582,16 @@ impl Signer {
                 // We never agreed to sign this block. Reject it.
                 // This can happen if the coordinator received enough votes to sign yes
                 // or no on a block before we received validation from the stacks node.
-                debug!("Reward cycle #{} Signer #{}: Received a signature share request for a block we never agreed to sign. Ignore it.", self.reward_cycle, self.signer_id);
+                debug!("{self}: Received a signature share request for a block we never agreed to sign. Ignore it.");
                 false
             }
             None => {
                 // We will only sign across block hashes or block hashes + b'n' byte for
                 // blocks we have seen a Nonce Request for (and subsequent validation)
                 // We are missing the context here necessary to make a decision. Reject the block
-                debug!("Reward cycle #{} Signer #{}: Received a signature share request from an unknown block. Reject it.", self.reward_cycle, self.signer_id);
+                debug!(
+                    "{self}: Received a signature share request from an unknown block. Reject it."
+                );
                 false
             }
         }
@@ -655,11 +609,7 @@ impl Signer {
         let Some(block): Option<NakamotoBlock> = read_next(&mut &nonce_request.message[..]).ok()
         else {
             // We currently reject anything that is not a block
-            debug!(
-                "Reward cycle #{} Signer #{}: Received a nonce request for an unknown message stream. Reject it.",
-                self.reward_cycle,
-                self.signer_id
-            );
+            debug!("{self}: Received a nonce request for an unknown message stream. Reject it.",);
             return false;
         };
         let signer_signature_hash = block.header.signer_signature_hash();
@@ -670,19 +620,15 @@ impl Signer {
         {
             Some(block_info) => block_info,
             None => {
-                debug!("Reward Cycle #{} Signer #{}: We have received a block sign request for a block we have not seen before. Cache the nonce request and submit the block for validation...", self.reward_cycle, self.signer_id);
+                debug!("{self}: We have received a block sign request for a block we have not seen before. Cache the nonce request and submit the block for validation...");
                 let block_info = BlockInfo::new_with_request(block.clone(), nonce_request.clone());
                 self.signer_db
                     .insert_block(&block_info)
-                    .expect("Failed to insert block in DB");
+                    .expect(&format!("{self}: Failed to insert block in DB"));
                 stacks_client
                     .submit_block_for_validation(block)
                     .unwrap_or_else(|e| {
-                        warn!(
-                            "Reward Cycle #{} Signer #{}: Failed to submit block for validation: {e:?}",
-                            self.reward_cycle,
-                            self.signer_id
-                        );
+                        warn!("{self}: Failed to submit block for validation: {e:?}",);
                     });
                 return false;
             }
@@ -690,20 +636,15 @@ impl Signer {
 
         if block_info.valid.is_none() {
             // We have not yet received validation from the stacks node. Cache the request and wait for validation
-            debug!("Reward cycle #{} Signer #{}: We have yet to receive validation from the stacks node for a nonce request. Cache the nonce request and wait for block validation...", self.reward_cycle, self.signer_id);
+            debug!("{self}: We have yet to receive validation from the stacks node for a nonce request. Cache the nonce request and wait for block validation...");
             block_info.nonce_request = Some(nonce_request.clone());
             return false;
         }
 
-        Self::determine_vote(
-            self.signer_id,
-            self.reward_cycle,
-            &mut block_info,
-            nonce_request,
-        );
+        self.determine_vote(&mut block_info, nonce_request);
         self.signer_db
             .insert_block(&block_info)
-            .expect("Failed to insert block in DB");
+            .expect(&format!("{self}: Failed to insert block in DB"));
         true
     }
 
@@ -716,7 +657,7 @@ impl Signer {
         if self.approved_aggregate_public_key.is_some() {
             // We do not enforce a block contain any transactions except the aggregate votes when it is NOT already set
             // TODO: should be only allow special cased transactions during prepare phase before a key is set?
-            debug!("Reward cycle #{} Signer #{}: Already have an aggregate key for reward cycle {}. Skipping transaction verification...", self.reward_cycle, self.signer_id, self.reward_cycle);
+            debug!("{self}: Already have an aggregate key. Skipping transaction verification...");
             return true;
         }
         if let Ok(expected_transactions) = self.get_expected_transactions(stacks_client) {
@@ -727,27 +668,17 @@ impl Signer {
                 .into_iter()
                 .filter_map(|tx| {
                     if !block_tx_hashset.contains(&tx.txid()) {
-                        debug!(
-                            "Reward cycle #{} Signer #{}: expected txid {} is in the block",
-                            self.reward_cycle,
-                            self.signer_id,
-                            &tx.txid()
-                        );
+                        debug!("{self}: expected txid {} is in the block", &tx.txid());
                         Some(tx)
                     } else {
-                        debug!(
-                            "Reward cycle #{} Signer #{}: missing expected txid {}",
-                            self.reward_cycle,
-                            self.signer_id,
-                            &tx.txid()
-                        );
+                        debug!("{self}: missing expected txid {}", &tx.txid());
                         None
                     }
                 })
                 .collect::<Vec<_>>();
             let is_valid = missing_transactions.is_empty();
             if !is_valid {
-                debug!("Reward cycle #{} Signer #{}: Broadcasting a block rejection due to missing expected transactions...", self.reward_cycle, self.signer_id);
+                debug!("{self}: Broadcasting a block rejection due to missing expected transactions...");
                 let block_rejection = BlockRejection::new(
                     block.header.signer_signature_hash(),
                     RejectCode::MissingTransactions(missing_transactions),
@@ -757,21 +688,13 @@ impl Signer {
                     .stackerdb
                     .send_message_with_retry(block_rejection.into())
                 {
-                    warn!(
-                        "Reward cycle #{} Signer #{}: Failed to send block rejection to stacker-db: {e:?}",
-                        self.reward_cycle,
-                        self.signer_id
-                    );
+                    warn!("{self}: Failed to send block rejection to stacker-db: {e:?}",);
                 }
             }
             is_valid
         } else {
             // Failed to connect to the stacks node to get transactions. Cannot validate the block. Reject it.
-            debug!(
-                "Reward cycle #{} Signer #{}: Broadcasting a block rejection due to signer connectivity issues...",
-                self.reward_cycle,
-                self.signer_id
-            );
+            debug!("{self}: Broadcasting a block rejection due to signer connectivity issues...",);
             let block_rejection = BlockRejection::new(
                 block.header.signer_signature_hash(),
                 RejectCode::ConnectivityIssues,
@@ -781,11 +704,7 @@ impl Signer {
                 .stackerdb
                 .send_message_with_retry(block_rejection.into())
             {
-                warn!(
-                    "Reward cycle #{} Signer #{}: Failed to send block submission to stacker-db: {e:?}",
-                    self.reward_cycle,
-                    self.signer_id
-                );
+                warn!("{self}: Failed to send block submission to stacker-db: {e:?}",);
             }
             false
         }
@@ -816,10 +735,7 @@ impl Signer {
         stacks_client: &StacksClient,
     ) -> Result<Vec<StacksTransaction>, ClientError> {
         if self.next_signer_slot_ids.is_empty() {
-            debug!(
-                "Reward cycle #{} Signer #{}: No next signers. Skipping transaction retrieval.",
-                self.reward_cycle, self.signer_id
-            );
+            debug!("{self}: No next signers. Skipping transaction retrieval.",);
             return Ok(vec![]);
         }
         // Get all the account nonces for the next signers
@@ -839,27 +755,12 @@ impl Signer {
     }
 
     /// Determine the vote for a block and update the block info and nonce request accordingly
-    fn determine_vote(
-        signer_id: u32,
-        reward_cycle: u64,
-        block_info: &mut BlockInfo,
-        nonce_request: &mut NonceRequest,
-    ) {
+    fn determine_vote(&self, block_info: &mut BlockInfo, nonce_request: &mut NonceRequest) {
         let rejected = !block_info.valid.unwrap_or(false);
         if rejected {
-            debug!(
-                "Reward cycle #{} Signer #{}: Rejecting block {}",
-                reward_cycle,
-                signer_id,
-                block_info.block.block_id()
-            );
+            debug!("{self}: Rejecting block {}", block_info.block.block_id());
         } else {
-            debug!(
-                "Reward cycle #{} Signer #{}: Accepting block {}",
-                reward_cycle,
-                signer_id,
-                block_info.block.block_id()
-            );
+            debug!("{self}: Accepting block {}", block_info.block.block_id());
         }
         let block_vote = NakamotoBlockVote {
             signer_signature_hash: block_info.block.header.signer_signature_hash(),
@@ -902,8 +803,8 @@ impl Signer {
             Some(packet)
         } else {
             debug!(
-                "Reward cycle #{} Signer #{}: Failed to verify wsts packet with {}: {packet:?}",
-                self.reward_cycle, self.signer_id, coordinator_public_key
+                "{self}: Failed to verify wsts packet with {}: {packet:?}",
+                coordinator_public_key
             );
             None
         }
@@ -920,30 +821,21 @@ impl Signer {
             // Signers only every trigger non-taproot signing rounds over blocks. Ignore SignTaproot results
             match operation_result {
                 OperationResult::Sign(signature) => {
-                    debug!(
-                        "Reward cycle #{} Signer #{}: Received signature result",
-                        self.reward_cycle, self.signer_id
-                    );
+                    debug!("{self}: Received signature result");
                     self.process_signature(signature);
                 }
                 OperationResult::SignTaproot(_) => {
-                    debug!("Reward cycle #{} Signer #{}: Received a signature result for a taproot signature. Nothing to broadcast as we currently sign blocks with a FROST signature.", self.reward_cycle, self.signer_id);
+                    debug!("{self}: Received a signature result for a taproot signature. Nothing to broadcast as we currently sign blocks with a FROST signature.");
                 }
                 OperationResult::Dkg(dkg_public_key) => {
                     self.process_dkg(stacks_client, dkg_public_key);
                 }
                 OperationResult::SignError(e) => {
-                    warn!(
-                        "Reward cycle #{} Signer #{}: Received a Sign error: {e:?}",
-                        self.reward_cycle, self.signer_id
-                    );
+                    warn!("{self}: Received a Sign error: {e:?}");
                     self.process_sign_error(e);
                 }
                 OperationResult::DkgError(e) => {
-                    warn!(
-                        "Reward cycle #{} Signer #{}: Received a DKG error: {e:?}",
-                        self.reward_cycle, self.signer_id
-                    );
+                    warn!("{self}: Received a DKG error: {e:?}");
                     // TODO: process these errors and track malicious signers to report
                 }
             }
@@ -959,11 +851,7 @@ impl Signer {
         })
         .unwrap_or(StacksEpochId::Epoch24);
         let tx_fee = if epoch < StacksEpochId::Epoch30 {
-            debug!(
-                "Reward cycle #{} Signer #{}: in pre Epoch 3.0 cycles, must set a transaction fee for the DKG vote.",
-                self.reward_cycle,
-                self.signer_id
-            );
+            debug!("{self}: in pre Epoch 3.0 cycles, must set a transaction fee for the DKG vote.");
             Some(self.tx_fee_ustx)
         } else {
             None
@@ -978,10 +866,7 @@ impl Signer {
                 .map_err(backoff::Error::transient)
         })
         .map_err(|e| {
-            warn!(
-                "Reward cycle #{} Signer #{}: Unable to get signer transactions: {e:?}",
-                self.reward_cycle, self.signer_id
-            );
+            warn!("{self}: Unable to get signer transactions: {e:?}");
         })
         .unwrap_or_default();
         // If we have a transaction in the stackerdb slot, we need to increment the nonce hence the +1, else should use the account nonce
@@ -1005,17 +890,13 @@ impl Signer {
                     new_transaction,
                 ) {
                     warn!(
-                        "Reward cycle #{} Signer #{}: Failed to broadcast DKG public key vote ({dkg_public_key:?}): {e:?}",
-                        self.reward_cycle,
-                        self.signer_id
+                        "{self}: Failed to broadcast DKG public key vote ({dkg_public_key:?}): {e:?}"
                     );
                 }
             }
             Err(e) => {
                 warn!(
-                    "Reward cycle #{} Signer #{}: Failed to build DKG public key vote ({dkg_public_key:?}) transaction: {e:?}.",
-                    self.reward_cycle,
-                    self.signer_id
+                    "{self}: Failed to build DKG public key vote ({dkg_public_key:?}) transaction: {e:?}."
                 );
             }
         }
@@ -1034,11 +915,7 @@ impl Signer {
                     .get_account_nonce(address)
                     .map_err(backoff::Error::transient)
             }) else {
-                warn!(
-                    "Reward cycle #{} Signer #{}: Unable to get account nonce for address: {address}.",
-                    self.reward_cycle,
-                    self.signer_id
-                );
+                warn!("{self}: Unable to get account nonce for address: {address}.");
                 continue;
             };
             account_nonces.insert(*address, account_nonce);
@@ -1058,33 +935,25 @@ impl Signer {
         if self.approved_aggregate_public_key.is_some() {
             // We do not enforce a block contain any transactions except the aggregate votes when it is NOT already set
             info!(
-                "Reward cycle #{} Signer #{}: Already has an approved aggregate key. Do not broadcast the transaction ({txid:?}).",
-                self.reward_cycle, self.signer_id
+                "{self}: Already has an approved aggregate key. Do not broadcast the transaction ({txid:?})."
             );
             return Ok(());
         }
         if epoch >= StacksEpochId::Epoch30 {
-            debug!("Reward cycle #{} Signer #{}: Received a DKG result while in epoch 3.0. Broadcast the transaction only to stackerDB.", self.reward_cycle, self.signer_id);
+            debug!("{self}: Received a DKG result while in epoch 3.0. Broadcast the transaction only to stackerDB.");
         } else if epoch == StacksEpochId::Epoch25 {
-            debug!("Reward cycle #{} Signer #{}: Received a DKG result while in epoch 2.5. Broadcast the transaction to the mempool.", self.reward_cycle, self.signer_id);
+            debug!("{self}: Received a DKG result while in epoch 2.5. Broadcast the transaction to the mempool.");
             stacks_client.submit_transaction(&new_transaction)?;
-            info!(
-                "Reward cycle #{} Signer #{}: Submitted DKG vote transaction ({txid:?}) to the mempool",
-                self.reward_cycle,
-                self.signer_id
-            );
+            info!("{self}: Submitted DKG vote transaction ({txid:?}) to the mempool");
         } else {
-            debug!("Reward cycle #{} Signer #{}: Received a DKG result, but are in an unsupported epoch. Do not broadcast the transaction ({}).", self.reward_cycle, self.signer_id, new_transaction.txid());
+            debug!("{self}: Received a DKG result, but are in an unsupported epoch. Do not broadcast the transaction ({}).", new_transaction.txid());
             return Ok(());
         }
         // For all Pox-4 epochs onwards, broadcast the results also to stackerDB for other signers/miners to observe
         signer_transactions.push(new_transaction);
         let signer_message = SignerMessage::Transactions(signer_transactions);
         self.stackerdb.send_message_with_retry(signer_message)?;
-        info!(
-            "Reward cycle #{} Signer #{}: Broadcasted DKG vote transaction ({txid}) to stacker DB",
-            self.reward_cycle, self.signer_id,
-        );
+        info!("{self}: Broadcasted DKG vote transaction ({txid}) to stacker DB");
         Ok(())
     }
 
@@ -1094,18 +963,14 @@ impl Signer {
         // Deserialize the signature result and broadcast an appropriate Reject or Approval message to stackerdb
         let message = self.coordinator.get_message();
         let Some(block_vote): Option<NakamotoBlockVote> = read_next(&mut &message[..]).ok() else {
-            debug!(
-                "Reward cycle #{} Signer #{}: Received a signature result for a non-block. Nothing to broadcast.",
-                self.reward_cycle,
-                self.signer_id
-            );
+            debug!("{self}: Received a signature result for a non-block. Nothing to broadcast.");
             return;
         };
 
         // TODO: proper garbage collection...This is currently our only cleanup of blocks
         self.signer_db
             .remove_block(&block_vote.signer_signature_hash)
-            .expect("Failed to remove block from to signer DB");
+            .expect(&format!("{self}: Failed to remove block from to signer DB"));
 
         let block_submission = if block_vote.rejected {
             // We signed a rejection message. Return a rejection message
@@ -1116,15 +981,9 @@ impl Signer {
         };
 
         // Submit signature result to miners to observe
-        debug!(
-            "Reward cycle #{} Signer #{}: submit block response {block_submission:?}",
-            self.reward_cycle, self.signer_id
-        );
+        debug!("{self}: submit block response {block_submission:?}");
         if let Err(e) = self.stackerdb.send_message_with_retry(block_submission) {
-            warn!(
-                "Reward cycle #{} Signer #{}: Failed to send block submission to stacker-db: {e:?}",
-                self.reward_cycle, self.signer_id
-            );
+            warn!("{self}: Failed to send block submission to stacker-db: {e:?}");
         }
     }
 
@@ -1140,19 +999,17 @@ impl Signer {
             else {
                 // This is not a block vote either. We cannot process this error
                 debug!(
-                    "Reward Cycle #{} Signer #{}: Received a signature error for a non-block. Nothing to broadcast.",
-                    self.reward_cycle,
-                    self.signer_id
+                    "{self}: Received a signature error for a non-block. Nothing to broadcast."
                 );
                 return;
             };
             let Some(block_info) = self
                 .signer_db
                 .block_lookup(&block_vote.signer_signature_hash)
-                .expect("Failed to connect to signer DB")
+                .expect(&format!("{self}: Failed to connect to signer DB"))
             else {
                 debug!(
-                    "Reward Cycle #{} Signer #{}: Received a signature result for a block we have not seen before. Ignoring...", self.reward_cycle, self.signer_id
+                    "{self}: Received a signature result for a block we have not seen before. Ignoring..."
                 );
                 return;
             };
@@ -1160,20 +1017,13 @@ impl Signer {
         });
         let block_rejection =
             BlockRejection::new(block.header.signer_signature_hash(), RejectCode::from(e));
-        debug!(
-            "Reward cycle #{} Signer #{}: Broadcasting block rejection: {block_rejection:?}",
-            self.reward_cycle, self.signer_id
-        );
+        debug!("{self}: Broadcasting block rejection: {block_rejection:?}");
         // Submit signature result to miners to observe
         if let Err(e) = self
             .stackerdb
             .send_message_with_retry(block_rejection.into())
         {
-            warn!(
-                "Reward cycle #{} Signer #{}: Failed to send block rejection submission to stacker-db: {e:?}",
-                self.reward_cycle,
-                self.signer_id
-            );
+            warn!("{self}: Failed to send block rejection submission to stacker-db: {e:?}");
         }
     }
 
@@ -1186,17 +1036,10 @@ impl Signer {
         let nmb_results = operation_results.len();
         match res.send(operation_results) {
             Ok(_) => {
-                debug!(
-                    "Reward cycle #{} Signer #{}: Successfully sent {} operation result(s)",
-                    self.reward_cycle, self.signer_id, nmb_results
-                )
+                debug!("{self}: Successfully sent {nmb_results} operation result(s)")
             }
             Err(e) => {
-                warn!(
-                    "Reward cycle #{} Signer #{}: Failed to send {nmb_results} operation results: {e:?}",
-                    self.reward_cycle,
-                    self.signer_id
-                );
+                warn!("{self}: Failed to send {nmb_results} operation results: {e:?}");
             }
         }
     }
@@ -1204,24 +1047,15 @@ impl Signer {
     /// Sending all provided packets through stackerdb with a retry
     fn send_outbound_messages(&mut self, outbound_messages: Vec<Packet>) {
         debug!(
-            "Reward cycle #{} Signer #{}: Sending {} messages to other stacker-db instances.",
-            self.reward_cycle,
-            self.signer_id,
+            "{self}: Sending {} messages to other stacker-db instances.",
             outbound_messages.len()
         );
         for msg in outbound_messages {
             let ack = self.stackerdb.send_message_with_retry(msg.into());
             if let Ok(ack) = ack {
-                debug!(
-                    "Reward cycle #{} Signer #{}: send outbound ACK: {ack:?}",
-                    self.reward_cycle, self.signer_id
-                );
+                debug!("{self}: send outbound ACK: {ack:?}");
             } else {
-                warn!(
-                    "Reward cycle #{} Signer #{}: Failed to send message to stacker-db instance: {ack:?}",
-                    self.reward_cycle,
-                    self.signer_id
-                );
+                warn!("{self}: Failed to send message to stacker-db instance: {ack:?}");
             }
         }
     }
@@ -1239,34 +1073,30 @@ impl Signer {
                 .set_aggregate_public_key(self.approved_aggregate_public_key);
             // We have an approved aggregate public key. Do nothing further
             debug!(
-                "Reward cycle #{} Signer #{}: Have updated DKG value to {:?}.",
-                self.reward_cycle, self.signer_id, self.approved_aggregate_public_key
+                "{self}: Have updated DKG value to {:?}.",
+                self.approved_aggregate_public_key
             );
             return Ok(());
         };
         let coordinator_id = self.coordinator_selector.get_coordinator().0;
         if self.signer_id == coordinator_id && self.state == State::Idle {
-            debug!(
-                "Reward cycle #{} Signer #{}: Checking if old vote transaction exists in StackerDB...",
-                self.reward_cycle,
-                self.signer_id
-            );
+            debug!("{self}: Checking if old vote transaction exists in StackerDB...");
             // Have I already voted and have a pending transaction? Check stackerdb for the same round number and reward cycle vote transaction
             // Only get the account nonce of THIS signer as we only care about our own votes, not other signer votes
             let signer_address = stacks_client.get_signer_address();
             let account_nonces = self.get_account_nonces(stacks_client, &[*signer_address]);
             let old_transactions = self.get_signer_transactions(&account_nonces).map_err(|e| {
-                warn!("Reward cycle #{} Signer #{}: Failed to get old signer transactions: {e:?}. May trigger DKG unnecessarily", self.reward_cycle, self.signer_id);
+                warn!("{self}: Failed to get old signer transactions: {e:?}. May trigger DKG unnecessarily");
             }).unwrap_or_default();
             // Check if we have an existing vote transaction for the same round and reward cycle
             for transaction in old_transactions.iter() {
                 let params =
-                    NakamotoSigners::parse_vote_for_aggregate_public_key(transaction).unwrap_or_else(|| panic!("BUG: Signer #{}: Received an invalid {SIGNERS_VOTING_FUNCTION_NAME} transaction in an already filtered list: {transaction:?}", self.signer_id));
+                    NakamotoSigners::parse_vote_for_aggregate_public_key(transaction).unwrap_or_else(|| panic!("BUG: {self}: Received an invalid {SIGNERS_VOTING_FUNCTION_NAME} transaction in an already filtered list: {transaction:?}"));
                 if Some(params.aggregate_key) == self.coordinator.aggregate_public_key
                     && params.voting_round == self.coordinator.current_dkg_id
                     && reward_cycle == self.reward_cycle
                 {
-                    debug!("Reward cycle #{} Signer #{}: Not triggering a DKG round. Already have a pending vote transaction.", self.reward_cycle, self.signer_id;
+                    debug!("{self}: Not triggering a DKG round. Already have a pending vote transaction.";
                         "txid" => %transaction.txid(),
                         "aggregate_key" => %params.aggregate_key,
                         "voting_round" => params.voting_round
@@ -1284,11 +1114,11 @@ impl Signer {
             {
                 // TODO Check if the vote failed and we need to retrigger the DKG round not just if we have already voted...
                 // TODO need logic to trigger another DKG round if a certain amount of time passes and we still have no confirmed DKG vote
-                debug!("Reward cycle #{} Signer #{}: Not triggering a DKG round. Already voted and we may need to wait for more votes to arrive.", self.reward_cycle, self.signer_id);
+                debug!("{self}: Not triggering a DKG round. Already voted and we may need to wait for more votes to arrive.");
                 return Ok(());
             }
             if self.commands.front() != Some(&Command::Dkg) {
-                info!("Reward cycle #{} Signer #{} is the current coordinator and must trigger DKG. Queuing DKG command...", self.reward_cycle, self.signer_id);
+                info!("{self} is the current coordinator and must trigger DKG. Queuing DKG command...");
                 self.commands.push_front(Command::Dkg);
             }
         }
@@ -1303,28 +1133,19 @@ impl Signer {
         res: Sender<Vec<OperationResult>>,
         current_reward_cycle: u64,
     ) -> Result<(), ClientError> {
-        debug!(
-            "Reward cycle #{} Signer #{}: Processing event: {event:?}",
-            self.reward_cycle, self.signer_id
-        );
+        debug!("{self}: Processing event: {event:?}");
         match event {
             Some(SignerEvent::BlockValidationResponse(block_validate_response)) => {
-                debug!(
-                    "Reward cycle #{} Signer #{}: Received a block proposal result from the stacks node...",
-                    self.reward_cycle,
-                    self.signer_id
-                );
+                debug!("{self}: Received a block proposal result from the stacks node...");
                 self.handle_block_validate_response(stacks_client, block_validate_response, res)
             }
             Some(SignerEvent::SignerMessages(signer_set, messages)) => {
                 if *signer_set != self.stackerdb.get_signer_set() {
-                    debug!("Reward cycle #{} Signer #{}: Received a signer message for a reward cycle that does not belong to this signer. Ignoring...", self.reward_cycle, self.signer_id);
+                    debug!("{self}: Received a signer message for a reward cycle that does not belong to this signer. Ignoring...");
                     return Ok(());
                 }
                 debug!(
-                    "Reward cycle #{} Signer #{}: Received {} messages from the other signers...",
-                    self.reward_cycle,
-                    self.signer_id,
+                    "{self}: Received {} messages from the other signers...",
                     messages.len()
                 );
                 self.handle_signer_messages(stacks_client, res, messages);
@@ -1332,29 +1153,21 @@ impl Signer {
             Some(SignerEvent::ProposedBlocks(blocks)) => {
                 if current_reward_cycle != self.reward_cycle {
                     // There is not point in processing blocks if we are not the current reward cycle (we can never actually contribute to signing these blocks)
-                    debug!("Reward cycle #{} Signer #{}: Received a proposed block, but this signer's reward cycle is not the current one ({}). Ignoring...", self.reward_cycle, self.signer_id, current_reward_cycle);
+                    debug!("{self}: Received a proposed block, but this signer's reward cycle is not the current one ({current_reward_cycle}). Ignoring...");
                     return Ok(());
                 }
                 debug!(
-                    "Reward cycle #{} Signer #{}: Received {} block proposals from the miners...",
-                    self.reward_cycle,
-                    self.signer_id,
+                    "{self}: Received {} block proposals from the miners...",
                     blocks.len()
                 );
                 self.handle_proposed_blocks(stacks_client, blocks);
             }
             Some(SignerEvent::StatusCheck) => {
-                debug!(
-                    "Reward cycle #{} Signer #{}: Received a status check event.",
-                    self.reward_cycle, self.signer_id
-                )
+                debug!("{self}: Received a status check event.")
             }
             None => {
                 // No event. Do nothing.
-                debug!(
-                    "Reward cycle #{} Signer #{}: No event received",
-                    self.reward_cycle, self.signer_id
-                )
+                debug!("{self}: No event received")
             }
         }
         Ok(())

From 91bf380f18e770a33761c0c87f0e03b8b52517d7 Mon Sep 17 00:00:00 2001
From: BowTiedRadone <bowtiedradone@gmail.com>
Date: Fri, 8 Mar 2024 18:53:36 +0200
Subject: [PATCH 1062/1166] added tests for verify-signer-key-sig

---
 .../tests/pox-4/pox-4.prop.test.ts            | 257 +++++++++++++++++-
 1 file changed, 249 insertions(+), 8 deletions(-)

diff --git a/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts b/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
index b82d212477..485d42eebd 100644
--- a/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
+++ b/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
@@ -2,8 +2,11 @@ import {
   Cl,
   ClarityType,
   ClarityValue,
+  createStacksPrivateKey,
   isClarityType,
+  pubKeyfromPrivKey,
   serializeCV,
+  signWithKey,
 } from "@stacks/transactions";
 import fc from "fast-check";
 import { assert, describe, expect, it } from "vitest";
@@ -24,14 +27,39 @@ const ERR_STACKING_INVALID_LOCK_PERIOD = 2;
 const ERR_STACKING_THRESHOLD_NOT_MET = 11;
 const ERR_STACKING_INVALID_POX_ADDRESS = 13;
 const ERR_STACKING_INVALID_AMOUNT = 18;
+const ERR_INVALID_SIGNATURE_PUBKEY = 35;
+const ERR_SIGNER_AUTH_AMOUNT_TOO_HIGH = 38;
+// Private Keys
+const privateKeyMapping: {
+  [key: string]: string;
+} = {
+  ST1PQHQKV0RJXZFY1DGX8MNSNYVE3VGZJSRTPGZGM:
+    "753b7cc01a1a2e86221266a154af739463fce51219d97e4f856cd7200c3bd2a601",
+  ST1SJ3DTE5DN7X54YDH5D64R3BCB6A2AG2ZQ8YPD5:
+    "7287ba251d44a4d3fd9276c88ce34c5c52a038955511cccaf77e61068649c17801",
+  ST2CY5V39NHDPWSXMW9QDT3HC3GD6Q6XX4CFRK9AG:
+    "530d9f61984c888536871c6573073bdfc0058896dc1adfe9a6a10dfacadc209101",
+  ST2JHG361ZXG51QTKY2NQCVBPPRRE2KZB1HR05NNC:
+    "d655b2523bcd65e34889725c73064feb17ceb796831c0e111ba1a552b0f31b3901",
+  ST2NEB84ASENDXKYGJPQW86YXQCEFEX2ZQPG87ND:
+    "f9d7206a47f14d2870c163ebab4bf3e70d18f5d14ce1031f3902fbbc894fe4c701",
+  ST2REHHS5J3CERCRBEPMGH7921Q6PYKAADT7JP2VB:
+    "3eccc5dac8056590432db6a35d52b9896876a3d5cbdea53b72400bc9c2099fe801",
+  ST3AM1A56AK2C1XAFJ4115ZSV26EB49BVQ10MGCS0:
+    "7036b29cb5e235e5fd9b09ae3e8eec4404e44906814d5d01cbca968a60ed4bfb01",
+  ST3PF13W7Z0RRM42A8VZRVFQ75SV1K26RXEP8YGKJ:
+    "b463f0df6c05d2f156393eee73f8016c5372caa0e9e29a901bb7171d90dc4f1401",
+  ST3NBRSFKX28FQ2ZJ1MAKX58HKHSDGNV5N7R21XCP:
+    "6a1a754ba863d7bab14adbbc3f8ebb090af9e871ace621d3e5ab634e1422885e01",
+  STNHKEPYEPJ8ET55ZZ0M5A34J0R3N5FM2CMMMAZ6:
+    "de433bdfa14ec43aa1098d5be594c8ffb20a31485ff9de2923b2689471c401b801",
+};
 
-function sha256(data: Buffer): Buffer {
-  return createHash("sha256").update(data).digest();
-}
+const sha256 = (data: Buffer): Buffer =>
+  createHash("sha256").update(data).digest();
 
-function structuredDataHash(structuredData: ClarityValue): Buffer {
-  return sha256(Buffer.from(serializeCV(structuredData)));
-}
+const structuredDataHash = (structuredData: ClarityValue): Buffer =>
+  sha256(Buffer.from(serializeCV(structuredData)));
 
 const generateDomainHash = (): ClarityValue =>
   Cl.tuple({
@@ -64,7 +92,7 @@ const generateMessageHash = (
 const generateMessagePrefixBuffer = (prefix: string) =>
   Buffer.from(prefix, "hex");
 
-export const buildSignerKeyMessageHash = (
+const buildSignerKeyMessageHash = (
   version: number,
   hashbytes: number[],
   reward_cycle: number,
@@ -96,6 +124,14 @@ export const buildSignerKeyMessageHash = (
   return signer_key_message_hash;
 };
 
+const signMessageHash = (privateKey: string, messageHash: Buffer) => {
+  const data = signWithKey(
+    createStacksPrivateKey(privateKey),
+    messageHash.toString("hex")
+  ).data;
+  return Buffer.from(data.slice(2) + data.slice(0, 2), "hex");
+};
+
 describe("test pox-4 contract read only functions", () => {
   it("should return correct reward-cycle-to-burn-height", () => {
     fc.assert(
@@ -1593,5 +1629,210 @@ describe("test pox-4 contract read only functions", () => {
       )
     );
   });
-  // verify-signer-key-sig
+
+  it("should return (ok true) verify-signer-key-sig called with correct data", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.nat({ max: 6 }),
+        fc.array(fc.nat({ max: 255 }), { maxLength: 32 }),
+        fc.nat(),
+        fc.nat(),
+        fc.nat(),
+        fc.nat(),
+        fc.nat(),
+        (
+          caller,
+          version,
+          hashbytes,
+          reward_cycle,
+          period,
+          amount,
+          max_amount,
+          auth_id
+        ) => {
+          // Arrange
+          fc.pre(amount <= max_amount);
+          const signer_private_key = privateKeyMapping[caller] ?? "";
+          const signer_key_message_hash = buildSignerKeyMessageHash(
+            version,
+            hashbytes,
+            reward_cycle,
+            "topic",
+            period,
+            max_amount,
+            auth_id
+          );
+          const signer_sig = signMessageHash(
+            signer_private_key,
+            signer_key_message_hash
+          );
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "verify-signer-key-sig",
+            [
+              Cl.tuple({
+                version: Cl.buffer(Uint8Array.from([version])),
+                hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(reward_cycle),
+              Cl.stringAscii("topic"),
+              Cl.uint(period),
+              Cl.some(Cl.buffer(signer_sig)),
+              Cl.buffer(pubKeyfromPrivKey(signer_private_key).data),
+              Cl.uint(amount),
+              Cl.uint(max_amount),
+              Cl.uint(auth_id),
+            ],
+            caller
+          );
+          assert(isClarityType(actual, ClarityType.ResponseOk));
+          assert(isClarityType(actual.value, ClarityType.BoolTrue));
+          expect(actual).toBeOk(Cl.bool(true));
+          expect(actual.value).toBeBool(true);
+        }
+      )
+    );
+  });
+
+  it("should return (err 35) verify-signer-key-sig called with wrong public key", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.nat({ max: 6 }),
+        fc.array(fc.nat({ max: 255 }), { maxLength: 32 }),
+        fc.nat(),
+        fc.nat(),
+        fc.nat(),
+        fc.nat(),
+        fc.nat(),
+        fc.constantFrom(...simnet.getAccounts().values()),
+        (
+          caller,
+          version,
+          hashbytes,
+          reward_cycle,
+          period,
+          amount,
+          max_amount,
+          auth_id,
+          wrong_address
+        ) => {
+          // Arrange
+          fc.pre(amount <= max_amount);
+          fc.pre(wrong_address !== caller);
+          const expectedResponseErr = ERR_INVALID_SIGNATURE_PUBKEY;
+          const signer_private_key = privateKeyMapping[caller];
+          const wrong_private_key = privateKeyMapping[wrong_address];
+          const signer_key_message_hash = buildSignerKeyMessageHash(
+            version,
+            hashbytes,
+            reward_cycle,
+            "topic",
+            period,
+            max_amount,
+            auth_id
+          );
+          const signer_sig = signMessageHash(
+            signer_private_key,
+            signer_key_message_hash
+          );
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "verify-signer-key-sig",
+            [
+              Cl.tuple({
+                version: Cl.buffer(Uint8Array.from([version])),
+                hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(reward_cycle),
+              Cl.stringAscii("topic"),
+              Cl.uint(period),
+              Cl.some(Cl.buffer(signer_sig)),
+              Cl.buffer(pubKeyfromPrivKey(wrong_private_key).data),
+              Cl.uint(amount),
+              Cl.uint(max_amount),
+              Cl.uint(auth_id),
+            ],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
+          expect(actual.value).toBeInt(expectedResponseErr);
+        }
+      )
+    );
+  });
+
+  it("should return (err 38) verify-signer-key-sig called with wrong public key", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.nat({ max: 6 }),
+        fc.array(fc.nat({ max: 255 }), { maxLength: 32 }),
+        fc.nat(),
+        fc.nat(),
+        fc.nat(),
+        fc.nat(),
+        fc.nat(),
+        (
+          caller,
+          version,
+          hashbytes,
+          reward_cycle,
+          period,
+          amount,
+          max_amount,
+          auth_id
+        ) => {
+          // Arrange
+          fc.pre(amount > max_amount);
+          const expectedResponseErr = ERR_SIGNER_AUTH_AMOUNT_TOO_HIGH;
+          const signer_private_key = privateKeyMapping[caller];
+          const signer_key_message_hash = buildSignerKeyMessageHash(
+            version,
+            hashbytes,
+            reward_cycle,
+            "topic",
+            period,
+            max_amount,
+            auth_id
+          );
+          const signer_sig = signMessageHash(
+            signer_private_key,
+            signer_key_message_hash
+          );
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "verify-signer-key-sig",
+            [
+              Cl.tuple({
+                version: Cl.buffer(Uint8Array.from([version])),
+                hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(reward_cycle),
+              Cl.stringAscii("topic"),
+              Cl.uint(period),
+              Cl.some(Cl.buffer(signer_sig)),
+              Cl.buffer(pubKeyfromPrivKey(signer_private_key).data),
+              Cl.uint(amount),
+              Cl.uint(max_amount),
+              Cl.uint(auth_id),
+            ],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
+          expect(actual.value).toBeInt(expectedResponseErr);
+        }
+      )
+    );
+  });
 });

From 13251ac5308e08feb09c0d98905f44ed1149d9f8 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Fri, 8 Mar 2024 10:11:57 -0800
Subject: [PATCH 1063/1166] fix: cargo fmt error

---
 .../src/chainstate/burn/operations/vote_for_aggregate_key.rs    | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stackslib/src/chainstate/burn/operations/vote_for_aggregate_key.rs b/stackslib/src/chainstate/burn/operations/vote_for_aggregate_key.rs
index 399e365018..3fe7e85d1c 100644
--- a/stackslib/src/chainstate/burn/operations/vote_for_aggregate_key.rs
+++ b/stackslib/src/chainstate/burn/operations/vote_for_aggregate_key.rs
@@ -216,7 +216,6 @@ impl StacksMessageCodec for VoteForAggregateKeyOp {
 
 #[cfg(test)]
 mod tests {
-    use crate::chainstate::burn::operations::{Error as op_error, VoteForAggregateKeyOp};
     use stacks_common::deps_common::bitcoin::blockdata::script::Builder;
     use stacks_common::types::chainstate::{BurnchainHeaderHash, StacksAddress};
     use stacks_common::types::StacksPublicKeyBuffer;
@@ -231,6 +230,7 @@ mod tests {
         BitcoinTxInputRaw, BitcoinTxInputStructured, BitcoinTxOutput,
     };
     use crate::burnchains::{BurnchainTransaction, Txid};
+    use crate::chainstate::burn::operations::{Error as op_error, VoteForAggregateKeyOp};
     use crate::chainstate::burn::Opcodes;
     use crate::chainstate::stacks::address::{PoxAddress, StacksAddressExtensions};
 

From aef79182536e9f271e2c8c5dfb825082774fda68 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Thu, 7 Mar 2024 13:06:26 -0600
Subject: [PATCH 1064/1166] chore: add more logging to the event receiver

---
 libsigner/src/events.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/libsigner/src/events.rs b/libsigner/src/events.rs
index 94bb17a85b..0d73b9579a 100644
--- a/libsigner/src/events.rs
+++ b/libsigner/src/events.rs
@@ -225,7 +225,9 @@ impl EventReceiver for SignerEventReceiver {
             if event_receiver.is_stopped() {
                 return Err(EventError::Terminated);
             }
+            debug!("Request handling");
             let request = http_server.recv()?;
+            debug!("Got request"; "method" => %request.method(), "path" => request.url());
 
             if request.url() == "/status" {
                 request

From 044ebf0fd42a2abdde4300b1712b05ec1f2466fc Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Thu, 7 Mar 2024 13:27:15 -0600
Subject: [PATCH 1065/1166] chore: log miner blockers

---
 stackslib/src/chainstate/stacks/miner.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/stackslib/src/chainstate/stacks/miner.rs b/stackslib/src/chainstate/stacks/miner.rs
index c04b03dcda..c6ac84a079 100644
--- a/stackslib/src/chainstate/stacks/miner.rs
+++ b/stackslib/src/chainstate/stacks/miner.rs
@@ -118,6 +118,7 @@ impl std::fmt::Display for MinerStatus {
 
 /// halt mining
 pub fn signal_mining_blocked(miner_status: Arc<Mutex<MinerStatus>>) {
+    debug!("Signaling miner to block"; "thread_id" => ?std::thread::current().id());
     match miner_status.lock() {
         Ok(mut status) => {
             status.add_blocked();

From ac9d7ba2a7a9207232b2a539d68c910f87cfe981 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Thu, 7 Mar 2024 14:55:50 -0600
Subject: [PATCH 1066/1166] do not block miner on burnchain updates in nakamoto

---
 testnet/stacks-node/src/nakamoto_node/relayer.rs | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/testnet/stacks-node/src/nakamoto_node/relayer.rs b/testnet/stacks-node/src/nakamoto_node/relayer.rs
index 1ee3135c24..d0072c35d4 100644
--- a/testnet/stacks-node/src/nakamoto_node/relayer.rs
+++ b/testnet/stacks-node/src/nakamoto_node/relayer.rs
@@ -244,11 +244,6 @@ impl RelayerThread {
             self.min_network_download_passes = net_result.num_download_passes + 1;
             self.min_network_inv_passes = net_result.num_inv_sync_passes + 1;
             self.last_network_block_height_ts = get_epoch_time_ms();
-            debug!(
-                "Relayer: block mining until the next download pass {}",
-                self.min_network_download_passes
-            );
-            signal_mining_blocked(self.globals.get_miner_status());
         }
 
         let net_receipts = self

From bdfc3604b10134559624ef5b8e28f0f2e624c9d3 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Fri, 8 Mar 2024 10:50:32 -0600
Subject: [PATCH 1067/1166] more logging

---
 .../stacks-node/src/nakamoto_node/miner.rs    | 22 ++++++++++++++++---
 .../stacks-node/src/nakamoto_node/relayer.rs  |  3 ++-
 2 files changed, 21 insertions(+), 4 deletions(-)

diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index 3546e48b93..b4f52292a6 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -144,6 +144,12 @@ impl BlockMinerThread {
     pub fn run_miner(mut self, prior_miner: Option<JoinHandle<()>>) {
         // when starting a new tenure, block the mining thread if its currently running.
         // the new mining thread will join it (so that the new mining thread stalls, not the relayer)
+        debug!(
+            "New miner thread starting";
+            "had_prior_miner" => prior_miner.is_some(),
+            "parent_tenure_id" => %self.parent_tenure_id,
+            "thread_id" => ?thread::current().id(),
+        );
         if let Some(prior_miner) = prior_miner {
             Self::stop_miner(&self.globals, prior_miner);
         }
@@ -960,9 +966,19 @@ impl ParentStacksBlockInfo {
             None
         };
 
-        debug!("Mining tenure's last consensus hash: {} (height {} hash {}), stacks tip consensus hash: {} (height {} hash {})",
-               &check_burn_block.consensus_hash, check_burn_block.block_height, &check_burn_block.burn_header_hash,
-               &parent_snapshot.consensus_hash, parent_snapshot.block_height, &parent_snapshot.burn_header_hash);
+        debug!(
+            "Looked up parent information";
+            "parent_tenure_id" => %parent_tenure_id,
+            "parent_tenure_consensus_hash" => %parent_tenure_header.consensus_hash,
+            "parent_tenure_burn_hash" => %parent_tenure_header.burn_header_hash,
+            "parent_tenure_burn_height" => parent_tenure_header.burn_header_height,
+            "mining_consensus_hash" => %check_burn_block.consensus_hash,
+            "mining_burn_hash" => %check_burn_block.burn_header_hash,
+            "mining_burn_height" => check_burn_block.block_height,
+            "stacks_tip_consensus_hash" => %parent_snapshot.consensus_hash,
+            "stacks_tip_burn_hash" => %parent_snapshot.burn_header_hash,
+            "stacks_tip_burn_height" => parent_snapshot.block_height,
+        );
 
         let coinbase_nonce = {
             let principal = miner_address.into();
diff --git a/testnet/stacks-node/src/nakamoto_node/relayer.rs b/testnet/stacks-node/src/nakamoto_node/relayer.rs
index d0072c35d4..78051a52fd 100644
--- a/testnet/stacks-node/src/nakamoto_node/relayer.rs
+++ b/testnet/stacks-node/src/nakamoto_node/relayer.rs
@@ -562,6 +562,7 @@ impl RelayerThread {
             "Relayer: Spawn tenure thread";
             "height" => last_burn_block.block_height,
             "burn_header_hash" => %burn_header_hash,
+            "parent_tenure_id" => %parent_tenure_id,
         );
 
         let miner_thread_state =
@@ -588,7 +589,7 @@ impl RelayerThread {
         let new_miner_state = self.create_block_miner(vrf_key, burn_tip, parent_tenure_start)?;
 
         let new_miner_handle = std::thread::Builder::new()
-            .name(format!("miner-{}", self.local_peer.data_url))
+            .name(format!("miner.{parent_tenure_start}"))
             .stack_size(BLOCK_PROCESSOR_STACK_SIZE)
             .spawn(move || new_miner_state.run_miner(prior_tenure_thread))
             .map_err(|e| {

From 79f0da40261ee5349aa3040f274f2fb6887b88ed Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 8 Mar 2024 12:43:08 -0500
Subject: [PATCH 1068/1166] Add logging to stop_tenure and stop_miner

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 testnet/stacks-node/src/nakamoto_node/miner.rs   | 5 +++++
 testnet/stacks-node/src/nakamoto_node/relayer.rs | 6 ++++--
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index b4f52292a6..1e450020da 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -134,11 +134,16 @@ impl BlockMinerThread {
 
     /// Stop a miner tenure by blocking the miner and then joining the tenure thread
     pub fn stop_miner(globals: &Globals, prior_miner: JoinHandle<()>) {
+        let id = prior_miner.thread().id();
+        debug!("Blocking miner thread ID {:?}", id);
         globals.block_miner();
+        debug!("Joining miner thread ID {:?}", id);
         prior_miner
             .join()
             .expect("FATAL: IO failure joining prior mining thread");
+        debug!("Joined miner thread ID {:?}", id);
         globals.unblock_miner();
+        debug!("Unblocked miner.");
     }
 
     pub fn run_miner(mut self, prior_miner: Option<JoinHandle<()>>) {
diff --git a/testnet/stacks-node/src/nakamoto_node/relayer.rs b/testnet/stacks-node/src/nakamoto_node/relayer.rs
index 78051a52fd..ceb68c6630 100644
--- a/testnet/stacks-node/src/nakamoto_node/relayer.rs
+++ b/testnet/stacks-node/src/nakamoto_node/relayer.rs
@@ -596,7 +596,7 @@ impl RelayerThread {
                 error!("Relayer: Failed to start tenure thread: {:?}", &e);
                 NakamotoNodeError::SpawnError(e)
             })?;
-
+        debug!("Relayer: started tenure thread ID {:?}", new_miner_handle.thread().id());
         self.miner_thread.replace(new_miner_handle);
 
         Ok(())
@@ -606,8 +606,10 @@ impl RelayerThread {
         // when stopping a tenure, block the mining thread if its currently running, then join it.
         // do this in a new thread will (so that the new thread stalls, not the relayer)
         let Some(prior_tenure_thread) = self.miner_thread.take() else {
+            debug!("Relayer: no tenure thread to stop");
             return Ok(());
         };
+        let id = prior_tenure_thread.thread().id();
         let globals = self.globals.clone();
 
         let stop_handle = std::thread::Builder::new()
@@ -619,7 +621,7 @@ impl RelayerThread {
             })?;
 
         self.miner_thread.replace(stop_handle);
-
+        debug!("Relayer: stopped tenure thread ID {id:?}");
         Ok(())
     }
 

From 893a5a83bfc0b11bfae88e23f54085623fa5462a Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 8 Mar 2024 12:57:37 -0500
Subject: [PATCH 1069/1166] Add redundent parent tenure ID printing in
 run_miner

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 testnet/stacks-node/src/nakamoto_node/miner.rs   | 1 +
 testnet/stacks-node/src/nakamoto_node/relayer.rs | 5 ++++-
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index 1e450020da..f133883f3c 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -155,6 +155,7 @@ impl BlockMinerThread {
             "parent_tenure_id" => %self.parent_tenure_id,
             "thread_id" => ?thread::current().id(),
         );
+        debug!("Parent tenure ID: {:?}", self.parent_tenure_id);
         if let Some(prior_miner) = prior_miner {
             Self::stop_miner(&self.globals, prior_miner);
         }
diff --git a/testnet/stacks-node/src/nakamoto_node/relayer.rs b/testnet/stacks-node/src/nakamoto_node/relayer.rs
index ceb68c6630..7219665676 100644
--- a/testnet/stacks-node/src/nakamoto_node/relayer.rs
+++ b/testnet/stacks-node/src/nakamoto_node/relayer.rs
@@ -596,7 +596,10 @@ impl RelayerThread {
                 error!("Relayer: Failed to start tenure thread: {:?}", &e);
                 NakamotoNodeError::SpawnError(e)
             })?;
-        debug!("Relayer: started tenure thread ID {:?}", new_miner_handle.thread().id());
+        debug!(
+            "Relayer: started tenure thread ID {:?}",
+            new_miner_handle.thread().id()
+        );
         self.miner_thread.replace(new_miner_handle);
 
         Ok(())

From 77438205f22218f63b224a1b7433e6286ca1d030 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 8 Mar 2024 13:01:26 -0500
Subject: [PATCH 1070/1166] Add logging to success and failure cases in
 handle_sortition

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 .../stacks-node/src/nakamoto_node/relayer.rs  | 31 ++++++++++++++-----
 1 file changed, 24 insertions(+), 7 deletions(-)

diff --git a/testnet/stacks-node/src/nakamoto_node/relayer.rs b/testnet/stacks-node/src/nakamoto_node/relayer.rs
index 7219665676..f638ae9324 100644
--- a/testnet/stacks-node/src/nakamoto_node/relayer.rs
+++ b/testnet/stacks-node/src/nakamoto_node/relayer.rs
@@ -641,18 +641,35 @@ impl RelayerThread {
             MinerDirective::BeginTenure {
                 parent_tenure_start,
                 burnchain_tip,
-            } => {
-                let _ = self.start_new_tenure(parent_tenure_start, burnchain_tip);
-            }
+            } => match self.start_new_tenure(parent_tenure_start, burnchain_tip) {
+                Ok(()) => {
+                    debug!("Relayer: successfully started new tenure.");
+                }
+                Err(e) => {
+                    error!("Relayer: Failed to start new tenure: {:?}", e);
+                }
+            },
             MinerDirective::ContinueTenure { new_burn_view: _ } => {
                 // TODO: in this case, we eventually want to undergo a tenure
                 //  change to switch to the new burn view, but right now, we will
                 //  simply end our current tenure if it exists
-                let _ = self.stop_tenure();
-            }
-            MinerDirective::StopTenure => {
-                let _ = self.stop_tenure();
+                match self.stop_tenure() {
+                    Ok(()) => {
+                        debug!("Relayer: successfully stopped tenure.");
+                    }
+                    Err(e) => {
+                        error!("Relayer: Failed to stop tenure: {:?}", e);
+                    }
+                }
             }
+            MinerDirective::StopTenure => match self.stop_tenure() {
+                Ok(()) => {
+                    debug!("Relayer: successfully stopped tenure.");
+                }
+                Err(e) => {
+                    error!("Relayer: Failed to stop tenure: {:?}", e);
+                }
+            },
         }
 
         true

From fa8647dbcef6d2abd61a362760c8afdf7e65a633 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 8 Mar 2024 14:57:22 -0500
Subject: [PATCH 1071/1166] Log if an outdated signature block hash arrives

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 testnet/stacks-node/src/nakamoto_node/miner.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index f133883f3c..aeca1b4a8d 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -422,12 +422,13 @@ impl BlockMinerThread {
                         {
                             // The signature is valid across the signer signature hash of the original proposed block
                             // Immediately return and update the block with this new signature before appending it to the chain
-                            debug!("Miner: received a signature accross the proposed block's signer signature hash ({signer_signature_hash:?}): {signature:?}");
+                            info!("Miner: received a signature accross the proposed block's signer signature hash ({signer_signature_hash:?}): {signature:?}");
                             return Ok(signature);
                         }
                         // We received an accepted block for some unknown block hash...Useless! Ignore it.
                         // Keep waiting for a threshold number of signers to either reject the proposed block
                         // or return valid signature to show up across the proposed block
+                        debug!("Miner: received a signature for an unknown block hash: {hash:?}. Ignoring it.");
                     }
                     SignerMessage::BlockResponse(BlockResponse::Rejected(block_rejection)) => {
                         // First check that this block rejection is for the block we proposed

From 9df82bbec912e16984b67fecc345f5eefbba6710 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 8 Mar 2024 15:08:24 -0500
Subject: [PATCH 1072/1166] Log in wait_for_signer_signature on outdated
 signature and stackerdb queries

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 testnet/stacks-node/src/nakamoto_node/miner.rs | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index aeca1b4a8d..88d13d22e1 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -397,6 +397,10 @@ impl BlockMinerThread {
         debug!("Miner: waiting for block response from reward cycle {reward_cycle } signers...");
         while now.elapsed() < self.config.miner.wait_on_signers {
             // Get the block responses from the signers for the block we just proposed
+            debug!("Miner: retreiving latest signer messsages";
+                "signers_contract_id" => %signers_contract_id,
+                "slot_ids" => ?slot_ids,
+            );
             let signer_chunks = stackerdbs
                 .get_latest_chunks(&signers_contract_id, &slot_ids)
                 .expect("FATAL: could not get latest chunks from stacker DB");
@@ -411,6 +415,7 @@ impl BlockMinerThread {
                     })
                 })
                 .collect();
+            debug!("Miner: retrieved {} signer messages", signer_messages.len());
             for (signer_id, signer_message) in signer_messages {
                 match signer_message {
                     SignerMessage::BlockResponse(BlockResponse::Accepted((hash, signature))) => {

From abb78614b8510d31f6f7540a6e662016ba22e7c7 Mon Sep 17 00:00:00 2001
From: Matthew Little <zone117x@gmail.com>
Date: Thu, 22 Feb 2024 18:33:02 +0100
Subject: [PATCH 1073/1166] feat: add `end-of-cycle-id` to synthetic pox events

---
 pox-locking/src/events.rs | 40 +++++++++++++++++++++++++++++++--------
 1 file changed, 32 insertions(+), 8 deletions(-)

diff --git a/pox-locking/src/events.rs b/pox-locking/src/events.rs
index baf78161a4..c290e5fd82 100644
--- a/pox-locking/src/events.rs
+++ b/pox-locking/src/events.rs
@@ -115,6 +115,9 @@ fn create_event_info_data_code(
         "stack-stx" => {
             format!(
                 r#"
+                (let (
+                    (unlock-burn-height (reward-cycle-to-burn-height (+ (current-pox-reward-cycle) u1 {lock_period})))
+                )
                 {{
                     data: {{
                         ;; amount of ustx to lock.
@@ -122,7 +125,7 @@ fn create_event_info_data_code(
                         lock-amount: {lock_amount},
                         ;; burnchain height when the unlock finishes.
                         ;; derived from args[3]
-                        unlock-burn-height: (reward-cycle-to-burn-height (+ (current-pox-reward-cycle) u1 {lock_period})),
+                        unlock-burn-height: unlock-burn-height,
                         ;; PoX address tuple.
                         ;; equal to args[1].
                         pox-addr: {pox_addr},
@@ -140,8 +143,10 @@ fn create_event_info_data_code(
                         max-amount: {max_amount},
                         ;; equal to args[7]
                         auth-id: {auth_id},
+                        ;; Get end cycle ID
+                        end-cycle-id: (burn-height-to-reward-cycle unlock-burn-height),
                     }}
-                }}
+                }})
                 "#,
                 lock_amount = &args[0],
                 lock_period = &args[3],
@@ -156,6 +161,9 @@ fn create_event_info_data_code(
         "delegate-stack-stx" => {
             format!(
                 r#"
+                (let (
+                    (unlock-burn-height (reward-cycle-to-burn-height (+ (current-pox-reward-cycle) u1 {lock_period})))
+                )
                 {{
                     data: {{
                         ;; amount of ustx to lock.
@@ -163,7 +171,7 @@ fn create_event_info_data_code(
                         lock-amount: {lock_amount},
                         ;; burnchain height when the unlock finishes.
                         ;; derived from args[4]
-                        unlock-burn-height: (reward-cycle-to-burn-height (+ (current-pox-reward-cycle) u1 {lock_period})),
+                        unlock-burn-height: unlock-burn-height,
                         ;; PoX address tuple.
                         ;; equal to args[2]
                         pox-addr: {pox_addr},
@@ -178,8 +186,10 @@ fn create_event_info_data_code(
                         ;; stacker
                         ;; equal to args[0]
                         stacker: '{stacker},
+                        ;; Get end cycle ID
+                        end-cycle-id: (burn-height-to-reward-cycle unlock-burn-height),
                     }}
-                }}
+                }})
                 "#,
                 stacker = &args[0],
                 lock_amount = &args[1],
@@ -210,6 +220,8 @@ fn create_event_info_data_code(
                         max-amount: {max_amount},
                         ;; equal to args[4]
                         auth-id: {auth_id},
+                        ;; Get end cycle ID
+                        end-cycle-id: (burn-height-to-reward-cycle (get unlock-height (stx-account tx-sender))),
                     }}
                 }}
                 "#,
@@ -239,7 +251,9 @@ fn create_event_info_data_code(
                         delegator: tx-sender,
                         ;; stacker
                         ;; equal to args[0]
-                        stacker: '{stacker}
+                        stacker: '{stacker},
+                        ;; Get end cycle ID
+                        end-cycle-id: (burn-height-to-reward-cycle (get unlock-height (stx-account '{stacker}))),
                     }}
                 }}
                 "#,
@@ -281,6 +295,8 @@ fn create_event_info_data_code(
                         max-amount: {max_amount},
                         ;; equal to args[5]
                         auth-id: {auth_id},
+                        ;; Get end cycle ID
+                        end-cycle-id: (burn-height-to-reward-cycle new-unlock-ht),
                     }}
                 }})
                 "#,
@@ -320,7 +336,9 @@ fn create_event_info_data_code(
                         delegator: tx-sender,
                         ;; stacker
                         ;; equal to args[0]
-                        stacker: '{stacker}
+                        stacker: '{stacker},
+                        ;; Get end cycle ID
+                        end-cycle-id: (burn-height-to-reward-cycle new-unlock-ht),
                     }}
                 }})
                 "#,
@@ -354,6 +372,8 @@ fn create_event_info_data_code(
                         max-amount: {max_amount},
                         ;; equal to args[5]
                         auth-id: {auth_id},
+                        ;; Get end cycle ID
+                        end-cycle-id: (burn-height-to-reward-cycle (get unlock-height (stx-account tx-sender))),
                     }}
                 }}
                 "#,
@@ -383,7 +403,9 @@ fn create_event_info_data_code(
                         ;; delegator (this is the caller)
                         delegator: tx-sender,
                         ;; equal to args[2]
-                        reward-cycle-index: {reward_cycle_index}
+                        reward-cycle-index: {reward_cycle_index},
+                        ;; Get end cycle ID
+                        end-cycle-id: (burn-height-to-reward-cycle (get unlock-height (stx-account tx-sender))),
                     }}
                 }}
                 "#,
@@ -408,7 +430,9 @@ fn create_event_info_data_code(
                         unlock-burn-height: {until_burn_height},
                         ;; optional PoX address tuple.
                         ;; equal to args[3].
-                        pox-addr: {pox_addr}
+                        pox-addr: {pox_addr},
+                        ;; Get end cycle ID
+                        end-cycle-id: (burn-height-to-reward-cycle {until_burn_height}),
                     }}
                 }}
                 "#,

From 4d2147ba1f16d4dcc725e4beb737c735b518bf1d Mon Sep 17 00:00:00 2001
From: Matthew Little <zone117x@gmail.com>
Date: Thu, 22 Feb 2024 19:32:08 +0100
Subject: [PATCH 1074/1166] feat: attempt `start-cycle-id` with prepare phase
 offset

---
 pox-locking/src/events.rs | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/pox-locking/src/events.rs b/pox-locking/src/events.rs
index c290e5fd82..ab60d6e36c 100644
--- a/pox-locking/src/events.rs
+++ b/pox-locking/src/events.rs
@@ -111,12 +111,20 @@ fn create_event_info_data_code(
     args: &[Value],
     response: &ResponseData,
 ) -> String {
+    // If a given burn block height is in a prepare phase, then the stacker will be in the _next_ reward cycle, so bump the cycle by 1
+    let prepare_phase_cycle_offset = r#"
+        (prepare-phase-offset (if (< (mod (+ (- %height% (var-get first-burnchain-block-height)) (var-get pox-prepare-cycle-length))
+            (var-get pox-reward-cycle-length))
+            (var-get pox-prepare-cycle-length))) u0 u1))
+    "#;
+
     match function_name {
         "stack-stx" => {
             format!(
                 r#"
                 (let (
                     (unlock-burn-height (reward-cycle-to-burn-height (+ (current-pox-reward-cycle) u1 {lock_period})))
+                    {prepare_phase_cycle_offset}
                 )
                 {{
                     data: {{
@@ -145,6 +153,8 @@ fn create_event_info_data_code(
                         auth-id: {auth_id},
                         ;; Get end cycle ID
                         end-cycle-id: (burn-height-to-reward-cycle unlock-burn-height),
+                        ;; Get start cycle ID
+                        start-cycle-id: (+ current-pox-reward-cycle prepare-phase-offset),
                     }}
                 }})
                 "#,
@@ -156,6 +166,8 @@ fn create_event_info_data_code(
                 signer_key = &args.get(5).unwrap_or(&Value::none()),
                 max_amount = &args.get(6).unwrap_or(&Value::none()),
                 auth_id = &args.get(7).unwrap_or(&Value::none()),
+                prepare_phase_cycle_offset =
+                prepare_phase_cycle_offset.replace("%height%", "burn-block-height"),
             )
         }
         "delegate-stack-stx" => {

From 38e3994b3d23207610bc4ecd5227f445ba1593f5 Mon Sep 17 00:00:00 2001
From: Matthew Little <zone117x@gmail.com>
Date: Thu, 22 Feb 2024 20:35:22 +0100
Subject: [PATCH 1075/1166] feat: add `start-cycle-id` with prepare phase
 offset to remaining events

---
 pox-locking/src/events.rs | 53 +++++++++++++++++++++++++++++----------
 1 file changed, 40 insertions(+), 13 deletions(-)

diff --git a/pox-locking/src/events.rs b/pox-locking/src/events.rs
index ab60d6e36c..0d5dbf51e6 100644
--- a/pox-locking/src/events.rs
+++ b/pox-locking/src/events.rs
@@ -112,10 +112,11 @@ fn create_event_info_data_code(
     response: &ResponseData,
 ) -> String {
     // If a given burn block height is in a prepare phase, then the stacker will be in the _next_ reward cycle, so bump the cycle by 1
-    let prepare_phase_cycle_offset = r#"
-        (prepare-phase-offset (if (< (mod (+ (- %height% (var-get first-burnchain-block-height)) (var-get pox-prepare-cycle-length))
-            (var-get pox-reward-cycle-length))
-            (var-get pox-prepare-cycle-length))) u0 u1))
+    let prepare_offset = r#"
+        (prepare-offset (if (<
+            (mod (- %height% (var-get first-burnchain-block-height)) (var-get pox-reward-cycle-length))
+            (- (var-get pox-reward-cycle-length) (var-get pox-prepare-cycle-length))
+        ) u0 u1))
     "#;
 
     match function_name {
@@ -124,7 +125,7 @@ fn create_event_info_data_code(
                 r#"
                 (let (
                     (unlock-burn-height (reward-cycle-to-burn-height (+ (current-pox-reward-cycle) u1 {lock_period})))
-                    {prepare_phase_cycle_offset}
+                    {prepare_offset}
                 )
                 {{
                     data: {{
@@ -154,7 +155,7 @@ fn create_event_info_data_code(
                         ;; Get end cycle ID
                         end-cycle-id: (burn-height-to-reward-cycle unlock-burn-height),
                         ;; Get start cycle ID
-                        start-cycle-id: (+ current-pox-reward-cycle prepare-phase-offset),
+                        start-cycle-id: (+ current-pox-reward-cycle prepare-offset),
                     }}
                 }})
                 "#,
@@ -166,8 +167,7 @@ fn create_event_info_data_code(
                 signer_key = &args.get(5).unwrap_or(&Value::none()),
                 max_amount = &args.get(6).unwrap_or(&Value::none()),
                 auth_id = &args.get(7).unwrap_or(&Value::none()),
-                prepare_phase_cycle_offset =
-                prepare_phase_cycle_offset.replace("%height%", "burn-block-height"),
+                prepare_offset = prepare_offset.replace("%height%", "burn-block-height"),
             )
         }
         "delegate-stack-stx" => {
@@ -200,6 +200,8 @@ fn create_event_info_data_code(
                         stacker: '{stacker},
                         ;; Get end cycle ID
                         end-cycle-id: (burn-height-to-reward-cycle unlock-burn-height),
+                        ;; Get start cycle ID
+                        start-cycle-id: (+ current-pox-reward-cycle prepare-offset),
                     }}
                 }})
                 "#,
@@ -208,11 +210,16 @@ fn create_event_info_data_code(
                 pox_addr = &args[2],
                 start_burn_height = &args[3],
                 lock_period = &args[4],
+                prepare_offset = prepare_offset.replace("%height%", "burn-block-height"),
             )
         }
         "stack-increase" => {
             format!(
                 r#"
+                (let (
+                    (unlock-height (get unlock-height (stx-account tx-sender)))
+                    {prepare_offset}
+                )
                 {{
                     data: {{
                         ;; amount to increase by
@@ -233,15 +240,18 @@ fn create_event_info_data_code(
                         ;; equal to args[4]
                         auth-id: {auth_id},
                         ;; Get end cycle ID
-                        end-cycle-id: (burn-height-to-reward-cycle (get unlock-height (stx-account tx-sender))),
+                        end-cycle-id: (burn-height-to-reward-cycle unlock-height),
+                        ;; Get start cycle ID
+                        start-cycle-id: (+ (burn-height-to-reward-cycle unlock-height) prepare-offset),
                     }}
-                }}
+                }})
                 "#,
                 increase_by = &args[0],
                 signer_sig = &args.get(1).unwrap_or(&Value::none()),
                 signer_key = &args.get(2).unwrap_or(&Value::none()),
                 max_amount = &args.get(3).unwrap_or(&Value::none()),
                 auth_id = &args.get(4).unwrap_or(&Value::none()),
+                prepare_offset = prepare_offset.replace("%height%", "unlock-height"),
             )
         }
         "delegate-stack-increase" => {
@@ -288,6 +298,7 @@ fn create_event_info_data_code(
                             unlock-in-cycle))
                     (last-extend-cycle  (- (+ first-extend-cycle {extend_count}) u1))
                     (new-unlock-ht (reward-cycle-to-burn-height (+ u1 last-extend-cycle)))
+                    {prepare_offset}
                 )
                 {{
                     data: {{
@@ -309,6 +320,8 @@ fn create_event_info_data_code(
                         auth-id: {auth_id},
                         ;; Get end cycle ID
                         end-cycle-id: (burn-height-to-reward-cycle new-unlock-ht),
+                        ;; Get start cycle ID
+                        start-cycle-id: (+ (burn-height-to-reward-cycle unlock-height) prepare-offset),
                     }}
                 }})
                 "#,
@@ -318,6 +331,7 @@ fn create_event_info_data_code(
                 signer_key = &args.get(3).map_or("none".to_string(), |v| v.to_string()),
                 max_amount = &args.get(4).unwrap_or(&Value::none()),
                 auth_id = &args.get(5).unwrap_or(&Value::none()),
+                prepare_offset = prepare_offset.replace("%height%", "unlock-height"),
             )
         }
         "delegate-stack-extend" => {
@@ -362,6 +376,9 @@ fn create_event_info_data_code(
         "stack-aggregation-commit" | "stack-aggregation-commit-indexed" => {
             format!(
                 r#"
+                (let (
+                    {prepare_offset}
+                )
                 {{
                     data: {{
                         ;; pox addr locked up
@@ -386,8 +403,10 @@ fn create_event_info_data_code(
                         auth-id: {auth_id},
                         ;; Get end cycle ID
                         end-cycle-id: (burn-height-to-reward-cycle (get unlock-height (stx-account tx-sender))),
+                        ;; Get start cycle ID
+                        start-cycle-id: (+ current-pox-reward-cycle prepare-offset),
                     }}
-                }}
+                }})
                 "#,
                 pox_addr = &args[0],
                 reward_cycle = &args[1],
@@ -395,11 +414,16 @@ fn create_event_info_data_code(
                 signer_key = &args.get(3).unwrap_or(&Value::none()),
                 max_amount = &args.get(4).unwrap_or(&Value::none()),
                 auth_id = &args.get(5).unwrap_or(&Value::none()),
+                prepare_offset = prepare_offset.replace("%height%", "burn-block-height"),
             )
         }
         "stack-aggregation-increase" => {
             format!(
                 r#"
+                (let (
+                    (unlock-height (get unlock-height (stx-account tx-sender)))
+                    {prepare_offset}
+                )
                 {{
                     data: {{
                         ;; pox addr locked up
@@ -417,13 +441,16 @@ fn create_event_info_data_code(
                         ;; equal to args[2]
                         reward-cycle-index: {reward_cycle_index},
                         ;; Get end cycle ID
-                        end-cycle-id: (burn-height-to-reward-cycle (get unlock-height (stx-account tx-sender))),
+                        end-cycle-id: (burn-height-to-reward-cycle unlock-height),
+                        ;; Get start cycle ID
+                        start-cycle-id: (+ (burn-height-to-reward-cycle unlock-height) prepare-offset),
                     }}
-                }}
+                }})
                 "#,
                 pox_addr = &args[0],
                 reward_cycle = &args[1],
                 reward_cycle_index = &args.get(2).unwrap_or(&Value::none()),
+                prepare_offset = prepare_offset.replace("%height%", "unlock-height"),
             )
         }
         "delegate-stx" => {

From 8c22c0019e4f9e97d0d1ff470671db592b17f4c1 Mon Sep 17 00:00:00 2001
From: Matthew Little <zone117x@gmail.com>
Date: Thu, 22 Feb 2024 20:52:03 +0100
Subject: [PATCH 1076/1166] chore: add missing prepare_offset str

---
 pox-locking/src/events.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/pox-locking/src/events.rs b/pox-locking/src/events.rs
index 0d5dbf51e6..7564e68252 100644
--- a/pox-locking/src/events.rs
+++ b/pox-locking/src/events.rs
@@ -175,6 +175,7 @@ fn create_event_info_data_code(
                 r#"
                 (let (
                     (unlock-burn-height (reward-cycle-to-burn-height (+ (current-pox-reward-cycle) u1 {lock_period})))
+                    {prepare_offset}
                 )
                 {{
                     data: {{

From f7071c0c27c12e9d3ccc01687ffc3fa435b7568e Mon Sep 17 00:00:00 2001
From: Marzi <marzi@trustmachines.co>
Date: Thu, 7 Mar 2024 21:10:58 -0500
Subject: [PATCH 1077/1166] Add pox-4 test to ensure pox-events are emitted +
 Clarity fixes for pox event info

---
 pox-locking/src/events.rs                     |  22 +-
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 372 +++++++++++++++++-
 2 files changed, 381 insertions(+), 13 deletions(-)

diff --git a/pox-locking/src/events.rs b/pox-locking/src/events.rs
index 7564e68252..cb2a1c47be 100644
--- a/pox-locking/src/events.rs
+++ b/pox-locking/src/events.rs
@@ -153,9 +153,9 @@ fn create_event_info_data_code(
                         ;; equal to args[7]
                         auth-id: {auth_id},
                         ;; Get end cycle ID
-                        end-cycle-id: (burn-height-to-reward-cycle unlock-burn-height),
+                        end-cycle-id: (some (burn-height-to-reward-cycle unlock-burn-height)),
                         ;; Get start cycle ID
-                        start-cycle-id: (+ current-pox-reward-cycle prepare-offset),
+                        start-cycle-id: (+ (current-pox-reward-cycle) prepare-offset),
                     }}
                 }})
                 "#,
@@ -200,9 +200,9 @@ fn create_event_info_data_code(
                         ;; equal to args[0]
                         stacker: '{stacker},
                         ;; Get end cycle ID
-                        end-cycle-id: (burn-height-to-reward-cycle unlock-burn-height),
+                        end-cycle-id: (some (burn-height-to-reward-cycle unlock-burn-height)),
                         ;; Get start cycle ID
-                        start-cycle-id: (+ current-pox-reward-cycle prepare-offset),
+                        start-cycle-id: (+ (current-pox-reward-cycle) prepare-offset),
                     }}
                 }})
                 "#,
@@ -241,7 +241,7 @@ fn create_event_info_data_code(
                         ;; equal to args[4]
                         auth-id: {auth_id},
                         ;; Get end cycle ID
-                        end-cycle-id: (burn-height-to-reward-cycle unlock-height),
+                        end-cycle-id: (some (burn-height-to-reward-cycle unlock-height)),
                         ;; Get start cycle ID
                         start-cycle-id: (+ (burn-height-to-reward-cycle unlock-height) prepare-offset),
                     }}
@@ -320,7 +320,7 @@ fn create_event_info_data_code(
                         ;; equal to args[5]
                         auth-id: {auth_id},
                         ;; Get end cycle ID
-                        end-cycle-id: (burn-height-to-reward-cycle new-unlock-ht),
+                        end-cycle-id: (some (burn-height-to-reward-cycle new-unlock-ht)),
                         ;; Get start cycle ID
                         start-cycle-id: (+ (burn-height-to-reward-cycle unlock-height) prepare-offset),
                     }}
@@ -403,9 +403,9 @@ fn create_event_info_data_code(
                         ;; equal to args[5]
                         auth-id: {auth_id},
                         ;; Get end cycle ID
-                        end-cycle-id: (burn-height-to-reward-cycle (get unlock-height (stx-account tx-sender))),
+                        end-cycle-id: (some (burn-height-to-reward-cycle (get unlock-height (stx-account tx-sender)))),
                         ;; Get start cycle ID
-                        start-cycle-id: (+ current-pox-reward-cycle prepare-offset),
+                        start-cycle-id: (+ (current-pox-reward-cycle) prepare-offset),
                     }}
                 }})
                 "#,
@@ -442,7 +442,7 @@ fn create_event_info_data_code(
                         ;; equal to args[2]
                         reward-cycle-index: {reward_cycle_index},
                         ;; Get end cycle ID
-                        end-cycle-id: (burn-height-to-reward-cycle unlock-height),
+                        end-cycle-id: (some (burn-height-to-reward-cycle unlock-height)),
                         ;; Get start cycle ID
                         start-cycle-id: (+ (burn-height-to-reward-cycle unlock-height) prepare-offset),
                     }}
@@ -472,7 +472,9 @@ fn create_event_info_data_code(
                         ;; equal to args[3].
                         pox-addr: {pox_addr},
                         ;; Get end cycle ID
-                        end-cycle-id: (burn-height-to-reward-cycle {until_burn_height}),
+                        end-cycle-id: (match {until_burn_height}
+	                            height (some (burn-height-to-reward-cycle height))
+	                            none),
                     }}
                 }}
                 "#,
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index a26d375eeb..dbb7ded119 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -34,6 +34,7 @@ use clarity::vm::types::{
     StacksAddressExtensions, StandardPrincipalData, TupleData, TupleTypeSignature, TypeSignature,
     Value, NONE,
 };
+use clarity::vm::Value::Optional;
 use stacks_common::address::AddressHashMode;
 use stacks_common::types::chainstate::{
     BlockHeaderHash, BurnchainHeaderHash, StacksAddress, StacksBlockId, VRFSeed,
@@ -53,9 +54,9 @@ use crate::chainstate::burn::{BlockSnapshot, ConsensusHash};
 use crate::chainstate::coordinator::tests::pox_addr_from;
 use crate::chainstate::stacks::address::{PoxAddress, PoxAddressType20, PoxAddressType32};
 use crate::chainstate::stacks::boot::pox_2_tests::{
-    check_pox_print_event, generate_pox_clarity_value, get_reward_set_entries_at,
-    get_stacking_state_pox, get_stx_account_at, with_clarity_db_ro, PoxPrintFields,
-    StackingStateCheckData,
+    check_pox_print_event, generate_pox_clarity_value, get_partial_stacked,
+    get_reward_set_entries_at, get_stacking_state_pox, get_stx_account_at, with_clarity_db_ro,
+    PoxPrintFields, StackingStateCheckData,
 };
 use crate::chainstate::stacks::boot::{
     BOOT_CODE_COST_VOTING_TESTNET as BOOT_CODE_COST_VOTING, BOOT_CODE_POX_TESTNET, POX_2_NAME,
@@ -1289,6 +1290,371 @@ fn pox_3_unlocks() {
     }
 }
 
+// This tests calls most of Clarity functions to check the existence of `start-cycle-id` and `end-cycle-id`
+// in emitted pox events.
+// In this set up, Steph is a solo stacker and invokes `stack-stx`, `stack-increase` and `stack-extend` functions
+// Alice delegates to Bob via `delegate-stx`
+// And Bob as the delegate, invokes 'delegate-stack-stx' and 'stack-aggregation-commit-indexed'
+#[test]
+fn pox_4_check_cycle_id_range_in_print_events() {
+    // Config for this test
+    let (epochs, pox_constants) = make_test_epochs_pox();
+
+    let mut burnchain = Burnchain::default_unittest(
+        0,
+        &BurnchainHeaderHash::from_hex(BITCOIN_REGTEST_FIRST_BLOCK_HASH).unwrap(),
+    );
+    burnchain.pox_constants = pox_constants.clone();
+
+    let observer = TestEventObserver::new();
+
+    let (mut peer, mut keys) = instantiate_pox_peer_with_epoch(
+        &burnchain,
+        function_name!(),
+        Some(epochs.clone()),
+        Some(&observer),
+    );
+
+    assert_eq!(burnchain.pox_constants.reward_slots(), 6);
+    let mut coinbase_nonce = 0;
+    let mut latest_block = None;
+
+    // alice
+    let alice = keys.pop().unwrap();
+    let alice_address = key_to_stacks_addr(&alice);
+    let alice_principal = PrincipalData::from(alice_address.clone());
+    let alice_pox_addr = pox_addr_from(&alice);
+
+    // bob
+    let bob = keys.pop().unwrap();
+    let bob_address = key_to_stacks_addr(&bob);
+    let bob_principal = PrincipalData::from(bob_address.clone());
+    let bob_pox_addr = pox_addr_from(&bob);
+    let bob_signing_key = Secp256k1PublicKey::from_private(&bob);
+    let bob_pox_addr_val = Value::Tuple(bob_pox_addr.as_clarity_tuple().unwrap());
+
+    // steph the solo stacker stacks stx so nakamoto signer set stays stacking.
+    let steph_key = keys.pop().unwrap();
+    let steph_address = key_to_stacks_addr(&steph_key);
+    let steph_principal = PrincipalData::from(steph_address.clone());
+    let steph_pox_addr_val =
+        make_pox_addr(AddressHashMode::SerializeP2PKH, steph_address.bytes.clone());
+    let steph_pox_addr = pox_addr_from(&steph_key);
+    let steph_signing_key = Secp256k1PublicKey::from_private(&steph_key);
+    let steph_key_val = Value::buff_from(steph_signing_key.to_bytes_compressed()).unwrap();
+
+    let mut alice_nonce = 0;
+    let mut steph_nonce = 0;
+    let mut bob_nonce = 0;
+
+    // Advance into pox4
+    let target_height = burnchain.pox_constants.pox_4_activation_height;
+    // produce blocks until the first reward phase that everyone should be in
+    while get_tip(peer.sortdb.as_ref()).block_height < u64::from(target_height) {
+        latest_block = Some(peer.tenure_with_txs(&[], &mut coinbase_nonce));
+    }
+
+    let reward_cycle = get_current_reward_cycle(&peer, &burnchain);
+    let steph_pox_addr = pox_addr_from(&steph_key);
+    let pox_addr_val = Value::Tuple(steph_pox_addr.clone().as_clarity_tuple().unwrap());
+
+    info!(
+        "Block height: {}",
+        get_tip(peer.sortdb.as_ref()).block_height
+    );
+
+    let lock_period = 1;
+    let block_height = get_tip(peer.sortdb.as_ref()).block_height;
+    let min_ustx = get_stacking_minimum(&mut peer, &latest_block.unwrap());
+
+    //stack-stx
+    let steph_stack_stx_nonce = steph_nonce;
+    let signature = make_signer_key_signature(
+        &steph_pox_addr,
+        &steph_key,
+        reward_cycle,
+        &Pox4SignatureTopic::StackStx,
+        lock_period,
+    );
+    let steph_stacking = make_pox_4_lockup(
+        &steph_key,
+        steph_stack_stx_nonce,
+        min_ustx,
+        &steph_pox_addr.clone(),
+        lock_period,
+        &steph_signing_key,
+        block_height,
+        Some(signature),
+    );
+    steph_nonce += 1;
+
+    //stack-increase
+    let steph_stack_increase_nonce = steph_nonce;
+    let steph_stack_increase =
+        make_pox_4_stack_increase(&steph_key, steph_stack_increase_nonce, 100);
+    steph_nonce += 1;
+
+    //stack-extend
+    let steph_stack_extend_nonce = steph_nonce;
+    let stack_extend_signature = make_signer_key_signature(
+        &steph_pox_addr,
+        &steph_key,
+        reward_cycle,
+        &Pox4SignatureTopic::StackExtend,
+        1_u128,
+    );
+
+    let steph_stack_extend = make_pox_4_extend(
+        &steph_key,
+        steph_stack_extend_nonce,
+        steph_pox_addr,
+        lock_period,
+        steph_signing_key,
+        Some(stack_extend_signature),
+    );
+    steph_nonce += 1;
+
+    // alice delegates STX to Bob
+    let alice_delegation_amount_min_ustx = get_stacking_minimum(&mut peer, &latest_block.unwrap());
+    let target_height = get_tip(peer.sortdb.as_ref()).block_height + 10;
+    let alice_delegate = make_pox_4_delegate_stx(
+        &alice,
+        alice_nonce,
+        alice_delegation_amount_min_ustx,
+        bob_principal.clone(),
+        Some(target_height as u128),
+        Some(bob_pox_addr.clone()),
+    );
+    let alice_delegate_nonce = alice_nonce;
+    alice_nonce += 1;
+
+    let curr_height = get_tip(peer.sortdb.as_ref()).block_height;
+    let bob_delegate_stack_nonce = bob_nonce;
+    let bob_delegate_stack = make_pox_4_delegate_stack_stx(
+        &bob,
+        bob_nonce,
+        alice_principal.clone(),
+        alice_delegation_amount_min_ustx,
+        bob_pox_addr.clone(),
+        curr_height as u128,
+        lock_period,
+    );
+    bob_nonce += 1;
+
+    let reward_cycle = get_current_reward_cycle(&peer, &burnchain);
+    let next_reward_cycle = reward_cycle + 1;
+
+    let bob_aggregation_commit_nonce = bob_nonce;
+    let signature = make_signer_key_signature(
+        &bob_pox_addr,
+        &bob,
+        next_reward_cycle,
+        &Pox4SignatureTopic::AggregationCommit,
+        lock_period,
+    );
+    let bob_aggregation_commit = make_pox_4_aggregation_commit_indexed(
+        &bob,
+        bob_aggregation_commit_nonce,
+        &bob_pox_addr,
+        next_reward_cycle,
+        Some(signature),
+        &bob_signing_key,
+    );
+    bob_nonce += 1;
+
+    latest_block = Some(peer.tenure_with_txs(
+        &[
+            steph_stacking,
+            steph_stack_increase,
+            steph_stack_extend,
+            alice_delegate,
+            bob_delegate_stack,
+            bob_aggregation_commit,
+        ],
+        &mut coinbase_nonce,
+    ));
+
+    let blocks = observer.get_blocks();
+    let mut steph_txs = HashMap::new();
+    let mut alice_txs = HashMap::new();
+    let mut bob_txs = HashMap::new();
+
+    for b in blocks.into_iter() {
+        for r in b.receipts.into_iter() {
+            if let TransactionOrigin::Stacks(ref t) = r.transaction {
+                let addr = t.auth.origin().address_testnet();
+                if addr == steph_address {
+                    steph_txs.insert(t.auth.get_origin_nonce(), r);
+                } else if addr == alice_address {
+                    alice_txs.insert(t.auth.get_origin_nonce(), r);
+                } else if addr == bob_address {
+                    bob_txs.insert(t.auth.get_origin_nonce(), r);
+                }
+            }
+        }
+    }
+
+    assert_eq!(steph_txs.len() as u64, 3);
+    assert_eq!(alice_txs.len() as u64, 1);
+    assert_eq!(bob_txs.len() as u64, 2);
+
+    let steph_stack_stx_tx = &steph_txs.get(&steph_stack_stx_nonce);
+    let steph_stack_extend_tx = &steph_txs.get(&steph_stack_extend_nonce);
+    let steph_stack_increase_tx = &steph_txs.get(&steph_stack_increase_nonce);
+    let bob_delegate_stack_stx_tx = &bob_txs.get(&bob_delegate_stack_nonce);
+    let bob_aggregation_commit_tx = &bob_txs.get(&bob_aggregation_commit_nonce);
+    let alice_delegate_tx = &alice_txs.get(&alice_delegate_nonce);
+
+    // Check event for stack-stx tx
+    let steph_stacking_tx_events = &steph_stack_stx_tx.unwrap().clone().events;
+    assert_eq!(steph_stacking_tx_events.len() as u64, 2);
+    let steph_stacking_tx_event = &steph_stacking_tx_events[0];
+    let steph_stacking_op_data = HashMap::from([
+        ("start-cycle-id", Value::UInt(22)),
+        (
+            "end-cycle-id",
+            Optional(OptionalData {
+                data: Some(Box::from(Value::UInt(24))),
+            }),
+        ),
+    ]);
+    let common_data = PoxPrintFields {
+        op_name: "stack-stx".to_string(),
+        stacker: steph_principal.clone().into(),
+        balance: Value::UInt(10240000000000),
+        locked: Value::UInt(0),
+        burnchain_unlock_height: Value::UInt(0),
+    };
+    check_pox_print_event(steph_stacking_tx_event, common_data, steph_stacking_op_data);
+
+    // Check event for stack-increase tx
+    let steph_stack_increase_tx_events = &steph_stack_increase_tx.unwrap().clone().events;
+    assert_eq!(steph_stack_increase_tx_events.len() as u64, 2);
+    let steph_stack_increase_tx_event = &steph_stack_increase_tx_events[0];
+    let steph_stack_increase_op_data = HashMap::from([
+        ("start-cycle-id", Value::UInt(24)),
+        (
+            "end-cycle-id",
+            Optional(OptionalData {
+                data: Some(Box::from(Value::UInt(24))),
+            }),
+        ),
+    ]);
+    let common_data = PoxPrintFields {
+        op_name: "stack-increase".to_string(),
+        stacker: steph_principal.clone().into(),
+        balance: Value::UInt(10234866375000),
+        locked: Value::UInt(5133625000),
+        burnchain_unlock_height: Value::UInt(120),
+    };
+    check_pox_print_event(
+        steph_stack_increase_tx_event,
+        common_data,
+        steph_stack_increase_op_data,
+    );
+
+    // Check event for stack-extend tx
+    let steph_stack_extend_tx_events = &steph_stack_extend_tx.unwrap().clone().events;
+    assert_eq!(steph_stack_extend_tx_events.len() as u64, 2);
+    let steph_stack_extend_tx_event = &steph_stack_extend_tx_events[0];
+    let steph_stacking_op_data = HashMap::from([
+        ("start-cycle-id", Value::UInt(24)),
+        (
+            "end-cycle-id",
+            Optional(OptionalData {
+                data: Some(Box::from(Value::UInt(25))),
+            }),
+        ),
+    ]);
+    let common_data = PoxPrintFields {
+        op_name: "stack-extend".to_string(),
+        stacker: steph_principal.clone().into(),
+        balance: Value::UInt(10234866374900),
+        locked: Value::UInt(5133625100),
+        burnchain_unlock_height: Value::UInt(120),
+    };
+    check_pox_print_event(
+        steph_stack_extend_tx_event,
+        common_data,
+        steph_stacking_op_data,
+    );
+
+    // Check event for delegate-stx tx
+    let alice_delegation_tx_events = &alice_delegate_tx.unwrap().clone().events;
+    assert_eq!(alice_delegation_tx_events.len() as u64, 1);
+    let alice_delegation_tx_event = &alice_delegation_tx_events[0];
+    let alice_delegate_stx_op_data = HashMap::from([(
+        "end-cycle-id",
+        Optional(OptionalData {
+            data: Some(Box::from(Value::UInt(24))),
+        }),
+    )]);
+    let common_data = PoxPrintFields {
+        op_name: "delegate-stx".to_string(),
+        stacker: alice_principal.clone().into(),
+        balance: Value::UInt(10240000000000),
+        locked: Value::UInt(0),
+        burnchain_unlock_height: Value::UInt(0),
+    };
+    check_pox_print_event(
+        alice_delegation_tx_event,
+        common_data,
+        alice_delegate_stx_op_data,
+    );
+
+    // Check event for delegate-stack-stx tx
+    let bob_delegate_stack_stx_tx_events = &bob_delegate_stack_stx_tx.unwrap().clone().events;
+    assert_eq!(bob_delegate_stack_stx_tx_events.len() as u64, 2);
+    let bob_delegate_stack_stx_tx_event = &bob_delegate_stack_stx_tx_events[0];
+    let bob_delegate_stack_stx_tx_op_data = HashMap::from([
+        ("start-cycle-id", Value::UInt(22)),
+        (
+            "end-cycle-id",
+            Optional(OptionalData {
+                data: Some(Box::from(Value::UInt(24))),
+            }),
+        ),
+    ]);
+    let common_data = PoxPrintFields {
+        op_name: "delegate-stack-stx".to_string(),
+        stacker: alice_principal.clone().into(),
+        balance: Value::UInt(10240000000000),
+        locked: Value::UInt(0),
+        burnchain_unlock_height: Value::UInt(0),
+    };
+    check_pox_print_event(
+        bob_delegate_stack_stx_tx_event,
+        common_data,
+        bob_delegate_stack_stx_tx_op_data,
+    );
+
+    // Check event for aggregation_commit tx
+    let bob_aggregation_commit_tx_events = &bob_aggregation_commit_tx.unwrap().clone().events;
+    assert_eq!(bob_aggregation_commit_tx_events.len() as u64, 1);
+    let bob_aggregation_commit_tx_event = &bob_aggregation_commit_tx_events[0];
+    let bob_aggregation_commit_tx_op_data = HashMap::from([
+        ("start-cycle-id", Value::UInt(22)),
+        (
+            "end-cycle-id",
+            Optional(OptionalData {
+                data: Some(Box::from(Value::UInt(0))), //Is this supposed to be 0?!
+            }),
+        ),
+    ]);
+    let common_data = PoxPrintFields {
+        op_name: "stack-aggregation-commit-indexed".to_string(),
+        stacker: bob_principal.clone().into(),
+        balance: Value::UInt(10240000000000),
+        locked: Value::UInt(0),
+        burnchain_unlock_height: Value::UInt(0),
+    };
+    check_pox_print_event(
+        bob_aggregation_commit_tx_event,
+        common_data,
+        bob_aggregation_commit_tx_op_data,
+    );
+}
+
 // test that revoke-delegate-stx calls emit an event and
 // test that revoke-delegate-stx is only successfull if user has delegated.
 #[test]

From d1f4c1aed15c713bfc40c18f8b11ca04562016c1 Mon Sep 17 00:00:00 2001
From: Marzi <marzi@trustmachines.co>
Date: Fri, 8 Mar 2024 00:26:36 -0500
Subject: [PATCH 1078/1166] Add additional required args for pox function calls
 after rebase

---
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 32 +++++++++++++++++--
 1 file changed, 30 insertions(+), 2 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index dbb7ded119..3cd180543a 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -1375,6 +1375,8 @@ fn pox_4_check_cycle_id_range_in_print_events() {
         reward_cycle,
         &Pox4SignatureTopic::StackStx,
         lock_period,
+        u128::MAX,
+        1,
     );
     let steph_stacking = make_pox_4_lockup(
         &steph_key,
@@ -1385,13 +1387,31 @@ fn pox_4_check_cycle_id_range_in_print_events() {
         &steph_signing_key,
         block_height,
         Some(signature),
+        u128::MAX,
+        1,
     );
     steph_nonce += 1;
 
     //stack-increase
     let steph_stack_increase_nonce = steph_nonce;
-    let steph_stack_increase =
-        make_pox_4_stack_increase(&steph_key, steph_stack_increase_nonce, 100);
+    let signature = make_signer_key_signature(
+        &steph_pox_addr,
+        &steph_key,
+        reward_cycle,
+        &Pox4SignatureTopic::StackIncrease,
+        lock_period,
+        u128::MAX,
+        1,
+    );
+    let steph_stack_increase = make_pox_4_stack_increase(
+        &steph_key,
+        steph_stack_increase_nonce,
+        100,
+        &steph_signing_key,
+        Some(signature),
+        u128::MAX,
+        1,
+    );
     steph_nonce += 1;
 
     //stack-extend
@@ -1402,6 +1422,8 @@ fn pox_4_check_cycle_id_range_in_print_events() {
         reward_cycle,
         &Pox4SignatureTopic::StackExtend,
         1_u128,
+        u128::MAX,
+        1,
     );
 
     let steph_stack_extend = make_pox_4_extend(
@@ -1411,6 +1433,8 @@ fn pox_4_check_cycle_id_range_in_print_events() {
         lock_period,
         steph_signing_key,
         Some(stack_extend_signature),
+        u128::MAX,
+        1,
     );
     steph_nonce += 1;
 
@@ -1451,6 +1475,8 @@ fn pox_4_check_cycle_id_range_in_print_events() {
         next_reward_cycle,
         &Pox4SignatureTopic::AggregationCommit,
         lock_period,
+        u128::MAX,
+        1,
     );
     let bob_aggregation_commit = make_pox_4_aggregation_commit_indexed(
         &bob,
@@ -1459,6 +1485,8 @@ fn pox_4_check_cycle_id_range_in_print_events() {
         next_reward_cycle,
         Some(signature),
         &bob_signing_key,
+        u128::MAX,
+        1,
     );
     bob_nonce += 1;
 

From 503afd997d1117a58b431ea00fb4d6a4ab006220 Mon Sep 17 00:00:00 2001
From: Marzi <marzi@trustmachines.co>
Date: Fri, 8 Mar 2024 15:30:30 -0500
Subject: [PATCH 1079/1166] Add cycle info to remaining synthetic pox events

---
 pox-locking/src/events.rs                     | 43 +++++++++++++++++--
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 27 +++++++-----
 2 files changed, 57 insertions(+), 13 deletions(-)

diff --git a/pox-locking/src/events.rs b/pox-locking/src/events.rs
index cb2a1c47be..a2d6095a14 100644
--- a/pox-locking/src/events.rs
+++ b/pox-locking/src/events.rs
@@ -258,6 +258,10 @@ fn create_event_info_data_code(
         "delegate-stack-increase" => {
             format!(
                 r#"
+                (let (
+                    (unlock-height (get unlock-height (stx-account tx-sender)))
+                    {prepare_offset}
+                )
                 {{
                     data: {{
                         ;; pox addr
@@ -277,12 +281,15 @@ fn create_event_info_data_code(
                         stacker: '{stacker},
                         ;; Get end cycle ID
                         end-cycle-id: (burn-height-to-reward-cycle (get unlock-height (stx-account '{stacker}))),
+                        ;; Get start cycle ID
+                        start-cycle-id: (+ (burn-height-to-reward-cycle unlock-height) prepare-offset),
                     }}
                 }}
                 "#,
                 stacker = &args[0],
                 pox_addr = &args[1],
                 increase_by = &args[2],
+                prepare_offset = prepare_offset.replace("%height%", "unlock-height"),
             )
         }
         "stack-extend" => {
@@ -366,6 +373,8 @@ fn create_event_info_data_code(
                         stacker: '{stacker},
                         ;; Get end cycle ID
                         end-cycle-id: (burn-height-to-reward-cycle new-unlock-ht),
+                        ;; Get start cycle ID
+                        start-cycle-id: (+ (burn-height-to-reward-cycle unlock-height) prepare-offset),
                     }}
                 }})
                 "#,
@@ -457,6 +466,9 @@ fn create_event_info_data_code(
         "delegate-stx" => {
             format!(
                 r#"
+                (let (
+                    {prepare_offset}
+                )
                 {{
                     data: {{
                         ;; amount of ustx to delegate.
@@ -475,31 +487,56 @@ fn create_event_info_data_code(
                         end-cycle-id: (match {until_burn_height}
 	                            height (some (burn-height-to-reward-cycle height))
 	                            none),
+                        ;; Get start cycle ID
+                        start-cycle-id: (+ (current-pox-reward-cycle) prepare-offset),
                     }}
-                }}
+                }})
                 "#,
                 amount_ustx = &args[0],
                 delegate_to = &args[1],
                 until_burn_height = &args[2],
                 pox_addr = &args[3],
+                prepare_offset = prepare_offset.replace("%height%", "burn-block-height"),
             )
         }
         "revoke-delegate-stx" => {
             if let Value::Optional(opt) = *response.data.clone() {
+                eprintln!("Response data in revoke-delegate-stx is: {:?}", opt.data);
                 format!(
                     r#"
+                    (let (
+                        {prepare_offset}
+                    )
                     {{
-                        data: {{ delegate-to: '{delegate_to} }}
-                    }}
+                        data: {{
+                            delegate-to: '{delegate_to},
+                            ;; Get end cycle ID
+                            end-cycle-id: (match {until_burn_height}
+                                    height (some (burn-height-to-reward-cycle height))
+                                    none),
+                            ;; Get start cycle ID
+                            start-cycle-id: (+ (current-pox-reward-cycle) prepare-offset),
+                        }},
+                    }})
                     "#,
                     delegate_to = opt
                         .data
+                        .clone()
                         .map(|boxed_value| *boxed_value)
                         .unwrap()
                         .expect_tuple()
                         .expect("FATAL: unexpected clarity value")
                         .get("delegated-to")
+                        .unwrap(),
+                    until_burn_height = opt
+                        .data
+                        .map(|boxed_value| *boxed_value)
                         .unwrap()
+                        .expect_tuple()
+                        .expect("FATAL: unexpected clarity value")
+                        .get("until-burn-ht")
+                        .unwrap(),
+                    prepare_offset = prepare_offset.replace("%height%", "burn-block-height"),
                 )
             } else {
                 "{data: {unimplemented: true}}".into()
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 3cd180543a..93479a4b34 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -1611,12 +1611,15 @@ fn pox_4_check_cycle_id_range_in_print_events() {
     let alice_delegation_tx_events = &alice_delegate_tx.unwrap().clone().events;
     assert_eq!(alice_delegation_tx_events.len() as u64, 1);
     let alice_delegation_tx_event = &alice_delegation_tx_events[0];
-    let alice_delegate_stx_op_data = HashMap::from([(
-        "end-cycle-id",
-        Optional(OptionalData {
-            data: Some(Box::from(Value::UInt(24))),
-        }),
-    )]);
+    let alice_delegate_stx_op_data = HashMap::from([
+        ("start-cycle-id", Value::UInt(22)),
+        (
+            "end-cycle-id",
+            Optional(OptionalData {
+                data: Some(Box::from(Value::UInt(24))),
+            }),
+        ),
+    ]);
     let common_data = PoxPrintFields {
         op_name: "delegate-stx".to_string(),
         stacker: alice_principal.clone().into(),
@@ -1835,10 +1838,14 @@ fn pox_4_revoke_delegate_stx_events() {
     let revoke_delegation_tx_events = &alice_txs.get(&alice_revoke_nonce).unwrap().clone().events;
     assert_eq!(revoke_delegation_tx_events.len() as u64, 1);
     let revoke_delegation_tx_event = &revoke_delegation_tx_events[0];
-    let revoke_delegate_stx_op_data = HashMap::from([(
-        "delegate-to",
-        Value::Principal(PrincipalData::from(bob_address.clone())),
-    )]);
+    let revoke_delegate_stx_op_data = HashMap::from([
+        ("start-cycle-id", Value::UInt(22)),
+        ("end-cycle-id", Optional(OptionalData { data: None })),
+        (
+            "delegate-to",
+            Value::Principal(PrincipalData::from(bob_address.clone())),
+        ),
+    ]);
     let common_data = PoxPrintFields {
         op_name: "revoke-delegate-stx".to_string(),
         stacker: alice_principal.clone().into(),

From cc2109abb2ac922012ba02869cb495f6f74ac445 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 8 Mar 2024 16:29:23 -0500
Subject: [PATCH 1080/1166] Have miners abort signing a block if the burn tip
 changes

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 testnet/stacks-node/src/nakamoto_node/miner.rs | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index 3546e48b93..3aaf6392a2 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -364,15 +364,13 @@ impl BlockMinerThread {
 
     fn wait_for_signer_signature(
         &self,
+        sortdb: &SortitionDB,
         stackerdbs: &StackerDBs,
         aggregate_public_key: &Point,
         signer_signature_hash: &Sha512Trunc256Sum,
         signer_weights: HashMap<StacksAddress, u64>,
+        reward_cycle: u64,
     ) -> Result<ThresholdSignature, NakamotoNodeError> {
-        let reward_cycle = self
-            .burnchain
-            .block_height_to_reward_cycle(self.burn_block.block_height)
-            .expect("FATAL: no reward cycle for burn block");
         let (signers_contract_id, slot_ids_addresses) =
             self.get_stackerdb_contract_and_slots(stackerdbs, BLOCK_MSG_ID, reward_cycle)?;
         let slot_ids = slot_ids_addresses.keys().cloned().collect::<Vec<_>>();
@@ -384,6 +382,10 @@ impl BlockMinerThread {
         let now = Instant::now();
         debug!("Miner: waiting for block response from reward cycle {reward_cycle } signers...");
         while now.elapsed() < self.config.miner.wait_on_signers {
+            if self.check_burn_tip_changed(&sortdb).is_err() {
+                info!("Miner: burnchain tip changed while waiting for signer signature.");
+                return Err(NakamotoNodeError::BurnchainTipChanged);
+            }
             // Get the block responses from the signers for the block we just proposed
             let signer_chunks = stackerdbs
                 .get_latest_chunks(&signers_contract_id, &slot_ids)
@@ -513,10 +515,12 @@ impl BlockMinerThread {
         )?;
         let signature = self
             .wait_for_signer_signature(
+                &sort_db,
                 &stackerdbs,
                 &aggregate_public_key,
                 &block.header.signer_signature_hash(),
                 signer_weights,
+                reward_cycle,
             )
             .map_err(|e| {
                 ChainstateError::InvalidStacksBlock(format!("Invalid Nakamoto block: {e:?}"))

From e577139b64423aa045ccfafd57743f5f90bfe8ab Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Fri, 8 Mar 2024 16:29:23 -0500
Subject: [PATCH 1081/1166] Have miners abort signing a block if the burn tip
 changes

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 testnet/stacks-node/src/nakamoto_node/miner.rs | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index 88d13d22e1..4a4411479d 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -376,15 +376,13 @@ impl BlockMinerThread {
 
     fn wait_for_signer_signature(
         &self,
+        sortdb: &SortitionDB,
         stackerdbs: &StackerDBs,
         aggregate_public_key: &Point,
         signer_signature_hash: &Sha512Trunc256Sum,
         signer_weights: HashMap<StacksAddress, u64>,
+        reward_cycle: u64,
     ) -> Result<ThresholdSignature, NakamotoNodeError> {
-        let reward_cycle = self
-            .burnchain
-            .block_height_to_reward_cycle(self.burn_block.block_height)
-            .expect("FATAL: no reward cycle for burn block");
         let (signers_contract_id, slot_ids_addresses) =
             self.get_stackerdb_contract_and_slots(stackerdbs, BLOCK_MSG_ID, reward_cycle)?;
         let slot_ids = slot_ids_addresses.keys().cloned().collect::<Vec<_>>();
@@ -396,6 +394,10 @@ impl BlockMinerThread {
         let now = Instant::now();
         debug!("Miner: waiting for block response from reward cycle {reward_cycle } signers...");
         while now.elapsed() < self.config.miner.wait_on_signers {
+            if self.check_burn_tip_changed(&sortdb).is_err() {
+                info!("Miner: burnchain tip changed while waiting for signer signature.");
+                return Err(NakamotoNodeError::BurnchainTipChanged);
+            }
             // Get the block responses from the signers for the block we just proposed
             debug!("Miner: retreiving latest signer messsages";
                 "signers_contract_id" => %signers_contract_id,
@@ -531,10 +533,12 @@ impl BlockMinerThread {
         )?;
         let signature = self
             .wait_for_signer_signature(
+                &sort_db,
                 &stackerdbs,
                 &aggregate_public_key,
                 &block.header.signer_signature_hash(),
                 signer_weights,
+                reward_cycle,
             )
             .map_err(|e| {
                 ChainstateError::InvalidStacksBlock(format!("Invalid Nakamoto block: {e:?}"))

From 009ba808dc2e3234fd07648afd57f3f653e8dbe5 Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Fri, 8 Mar 2024 17:02:05 -0500
Subject: [PATCH 1082/1166] chore: cleanup excessive logging

---
 testnet/stacks-node/src/nakamoto_node/miner.rs | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index 88d13d22e1..486c9afc5a 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -135,15 +135,11 @@ impl BlockMinerThread {
     /// Stop a miner tenure by blocking the miner and then joining the tenure thread
     pub fn stop_miner(globals: &Globals, prior_miner: JoinHandle<()>) {
         let id = prior_miner.thread().id();
-        debug!("Blocking miner thread ID {:?}", id);
         globals.block_miner();
-        debug!("Joining miner thread ID {:?}", id);
         prior_miner
             .join()
             .expect("FATAL: IO failure joining prior mining thread");
-        debug!("Joined miner thread ID {:?}", id);
         globals.unblock_miner();
-        debug!("Unblocked miner.");
     }
 
     pub fn run_miner(mut self, prior_miner: Option<JoinHandle<()>>) {
@@ -155,7 +151,6 @@ impl BlockMinerThread {
             "parent_tenure_id" => %self.parent_tenure_id,
             "thread_id" => ?thread::current().id(),
         );
-        debug!("Parent tenure ID: {:?}", self.parent_tenure_id);
         if let Some(prior_miner) = prior_miner {
             Self::stop_miner(&self.globals, prior_miner);
         }

From 429cc1e0478609ada9bb32ebcc3e858cdd42ad44 Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Fri, 8 Mar 2024 17:06:25 -0500
Subject: [PATCH 1083/1166] chore: remove unused variable

---
 testnet/stacks-node/src/nakamoto_node/miner.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index 486c9afc5a..e90d5ffb76 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -134,7 +134,6 @@ impl BlockMinerThread {
 
     /// Stop a miner tenure by blocking the miner and then joining the tenure thread
     pub fn stop_miner(globals: &Globals, prior_miner: JoinHandle<()>) {
-        let id = prior_miner.thread().id();
         globals.block_miner();
         prior_miner
             .join()

From 05c4a7af602e11e154af0cd22e5f251ede33481a Mon Sep 17 00:00:00 2001
From: BowTiedRadone <bowtiedradone@gmail.com>
Date: Fri, 1 Mar 2024 20:36:50 +0200
Subject: [PATCH 1084/1166] added property tests for pox-4 read only functions

---
 .../tests/pox-4/pox-4.prop.test.ts            | 434 ++++++++++++++++++
 1 file changed, 434 insertions(+)
 create mode 100644 contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts

diff --git a/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts b/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
new file mode 100644
index 0000000000..65dc88cc08
--- /dev/null
+++ b/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
@@ -0,0 +1,434 @@
+import Cl, { ClarityType, bufferCV, isClarityType } from "@stacks/transactions";
+import { assert, describe, expect, it } from "vitest";
+import fc from "fast-check";
+
+const POX_4 = "pox-4";
+const GET_POX_INFO = "get-pox-info";
+
+describe("test pox-4 contract read only functions", () => {
+  it("should return correct reward-cycle-to-burn-height", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.nat(),
+        (account, reward_cycle) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            POX_4,
+            GET_POX_INFO,
+            [],
+            account
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+          const first_burn_block_height =
+            pox_4_info.value.data["first-burnchain-block-height"];
+          const reward_cycle_length =
+            pox_4_info.value.data["reward-cycle-length"];
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "reward-cycle-to-burn-height",
+            [Cl.uintCV(reward_cycle)],
+            account
+          );
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.UInt));
+          assert(isClarityType(first_burn_block_height, ClarityType.UInt));
+          assert(isClarityType(reward_cycle_length, ClarityType.UInt));
+
+          const expected =
+            Number(first_burn_block_height.value) +
+            Number(reward_cycle_length.value) * reward_cycle;
+          expect(actual).toBeUint(expected);
+        }
+      ),
+      { numRuns: 300 }
+    );
+  });
+
+  it("should return correct burn-height-to-reward-cycle", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.nat(),
+        (account, burn_height) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            POX_4,
+            GET_POX_INFO,
+            [],
+            account
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+          const first_burn_block_height =
+            pox_4_info.value.data["first-burnchain-block-height"];
+          const reward_cycle_length =
+            pox_4_info.value.data["reward-cycle-length"];
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "burn-height-to-reward-cycle",
+            [Cl.uintCV(burn_height)],
+            account
+          );
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.UInt));
+          assert(isClarityType(first_burn_block_height, ClarityType.UInt));
+          assert(isClarityType(reward_cycle_length, ClarityType.UInt));
+          const expected = Math.floor(
+            (burn_height - Number(first_burn_block_height.value)) /
+              Number(reward_cycle_length.value)
+          );
+          expect(actual).toBeUint(expected);
+        }
+      ),
+      { numRuns: 300 }
+    );
+  });
+
+  it("should return none stacker-info", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.constantFrom(...simnet.getAccounts().values()),
+        (stacker, caller) => {
+          // Arrange
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "get-stacker-info",
+            [Cl.principalCV(stacker)],
+            caller
+          );
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.OptionalNone));
+          expect(actual).toBeNone();
+        }
+      )
+    );
+  });
+
+  it("should return correct check-caller-allowed", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        (caller) => {
+          // Arrange
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "check-caller-allowed",
+            [],
+            caller
+          );
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.BoolTrue));
+          expect(actual).toBeBool(true);
+        }
+      )
+    );
+  });
+
+  it("should return u0 get-reward-set-size", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.nat(),
+        (caller, reward_cycle) => {
+          // Arrange
+          const expected = 0;
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "get-reward-set-size",
+            [Cl.uintCV(reward_cycle)],
+            caller
+          );
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.UInt));
+          expect(actual).toBeUint(expected);
+        }
+      )
+    );
+  });
+
+  it("should return u0 get-total-ustx-stacked", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.nat(),
+        (caller, reward_cycle) => {
+          // Arrange
+          const expected = 0;
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "get-total-ustx-stacked",
+            [Cl.uintCV(reward_cycle)],
+            caller
+          );
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.UInt));
+          expect(actual).toBeUint(expected);
+        }
+      )
+    );
+  });
+
+  it("should return none get-reward-set-pox-address", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.nat(),
+        fc.nat(),
+        (caller, index, reward_cycle) => {
+          // Arrange
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "get-reward-set-pox-address",
+            [Cl.uintCV(index), Cl.uintCV(reward_cycle)],
+            caller
+          );
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.OptionalNone));
+          expect(actual).toBeNone();
+        }
+      )
+    );
+  });
+
+  it("should return correct get-stacking-minimum", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        (caller) => {
+          // Arrange
+          const testnet_stacking_threshold_25 = 8000;
+
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            POX_4,
+            GET_POX_INFO,
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+          const stx_liq_supply =
+            pox_4_info.value.data["total-liquid-supply-ustx"];
+
+          assert(isClarityType(stx_liq_supply, ClarityType.UInt));
+          const expected = Math.floor(
+            Number(stx_liq_supply.value) / testnet_stacking_threshold_25
+          );
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "get-stacking-minimum",
+            [],
+            caller
+          );
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.UInt));
+          expect(actual).toBeUint(expected);
+        }
+      )
+    );
+  });
+
+  it("should return correct check-pox-addr-version", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.nat({ max: 255 }),
+        (caller, version) => {
+          // Arrange
+          const expected = version > 6 ? false : true;
+
+          // Act
+          let { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "check-pox-addr-version",
+            [Cl.bufferCV(Uint8Array.from([version]))],
+            caller
+          );
+
+          // Assert
+          assert(
+            isClarityType(
+              actual,
+              expected ? ClarityType.BoolTrue : ClarityType.BoolFalse
+            )
+          );
+          expect(actual).toBeBool(expected);
+        }
+      )
+    );
+  });
+
+  it("should return correct check-pox-lock-period", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.nat(),
+        (caller, reward_cycles) => {
+          // Arrange
+          const expected =
+            reward_cycles > 0 && reward_cycles <= 12 ? true : false;
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "check-pox-lock-period",
+            [Cl.uintCV(reward_cycles)],
+            caller
+          );
+
+          // Assert
+          assert(
+            isClarityType(
+              actual,
+              expected ? ClarityType.BoolTrue : ClarityType.BoolFalse
+            )
+          );
+          expect(actual).toBeBool(expected);
+        }
+      )
+    ),
+      { numRuns: 250 };
+  });
+
+  it("should return correct can-stack-stx", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.nat({ max: 255 }),
+        fc.array(fc.nat({ max: 255 }), { maxLength: 32 }),
+        fc.bigInt({ min: 0n, max: 340282366920938463463374607431768211455n }),
+        fc.nat(),
+        fc.nat(),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const testnet_stacking_threshold_25 = 8000;
+
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            POX_4,
+            GET_POX_INFO,
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+          const stacking_valid_amount = amount_ustx > 0;
+          const pox_lock_period_valid = num_cycles > 0 && num_cycles <= 12;
+          const pox_version_valid = version <= 6;
+          const pox_hashbytes_valid =
+            hashbytes.length === 20 || hashbytes.length === 32;
+          const stx_liq_supply =
+            pox_4_info.value.data["total-liquid-supply-ustx"];
+
+          assert(isClarityType(stx_liq_supply, ClarityType.UInt));
+          const stacking_threshold_met =
+            amount_ustx >=
+            Math.floor(
+              Number(stx_liq_supply.value) / testnet_stacking_threshold_25
+            );
+          const expectedResponseErr = !stacking_threshold_met
+            ? 11
+            : !stacking_valid_amount
+            ? 18
+            : !pox_lock_period_valid
+            ? 2
+            : !pox_version_valid
+            ? 13
+            : !pox_hashbytes_valid
+            ? 13
+            : 0;
+          const expectedResponseOk = true;
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "can-stack-stx",
+            [
+              Cl.tupleCV({
+                version: bufferCV(Uint8Array.from([version])),
+                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uintCV(amount_ustx),
+              Cl.uintCV(first_rew_cycle),
+              Cl.uintCV(num_cycles),
+            ],
+            caller
+          );
+
+          // Assert
+          assert(
+            isClarityType(
+              actual,
+              stacking_threshold_met &&
+                stacking_valid_amount &&
+                pox_lock_period_valid &&
+                pox_version_valid &&
+                pox_hashbytes_valid
+                ? ClarityType.ResponseOk
+                : ClarityType.ResponseErr
+            )
+          );
+
+          assert(
+            isClarityType(
+              actual.value,
+              stacking_threshold_met &&
+                stacking_valid_amount &&
+                pox_lock_period_valid &&
+                pox_version_valid &&
+                pox_hashbytes_valid
+                ? ClarityType.BoolTrue
+                : ClarityType.Int
+            )
+          );
+          if (expectedResponseErr === 0) {
+            expect(actual).toBeOk(
+              Cl.responseOkCV(Cl.boolCV(expectedResponseOk))
+            );
+            expect(actual.value).toBeBool(expectedResponseOk);
+          } else {
+            expect(actual).toBeErr(Cl.intCV(expectedResponseErr));
+            expect(actual.value).toBeInt(expectedResponseErr);
+          }
+        }
+      ),
+      { numRuns: 300 }
+    );
+  });
+});

From 2d8516eb3910b6617d7f2a81045eced4bc3a10a5 Mon Sep 17 00:00:00 2001
From: BowTiedRadone <bowtiedradone@gmail.com>
Date: Fri, 1 Mar 2024 20:46:36 +0200
Subject: [PATCH 1085/1166] rename get-stacker-info test

---
 contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts b/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
index 65dc88cc08..54d5f5dd22 100644
--- a/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
+++ b/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
@@ -94,7 +94,7 @@ describe("test pox-4 contract read only functions", () => {
     );
   });
 
-  it("should return none stacker-info", () => {
+  it("should return none get-stacker-info", () => {
     fc.assert(
       fc.property(
         fc.constantFrom(...simnet.getAccounts().values()),

From 1dfed13a71e61275f791abc7638ccb03ec51b7cd Mon Sep 17 00:00:00 2001
From: BowTiedRadone <bowtiedradone@gmail.com>
Date: Mon, 4 Mar 2024 16:51:39 +0200
Subject: [PATCH 1086/1166] Split conditional tests

---
 .../tests/pox-4/pox-4.prop.test.ts            | 332 ++++++++++++------
 1 file changed, 231 insertions(+), 101 deletions(-)

diff --git a/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts b/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
index 54d5f5dd22..d084d7759d 100644
--- a/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
+++ b/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
@@ -1,9 +1,11 @@
-import Cl, { ClarityType, bufferCV, isClarityType } from "@stacks/transactions";
+import { Cl, ClarityType, bufferCV, isClarityType } from "@stacks/transactions";
 import { assert, describe, expect, it } from "vitest";
 import fc from "fast-check";
 
 const POX_4 = "pox-4";
 const GET_POX_INFO = "get-pox-info";
+const testnet_stacking_threshold_25 = 8000;
+fc.configureGlobal({ numRuns: 250 });
 
 describe("test pox-4 contract read only functions", () => {
   it("should return correct reward-cycle-to-burn-height", () => {
@@ -31,7 +33,7 @@ describe("test pox-4 contract read only functions", () => {
           const { result: actual } = simnet.callReadOnlyFn(
             POX_4,
             "reward-cycle-to-burn-height",
-            [Cl.uintCV(reward_cycle)],
+            [Cl.uint(reward_cycle)],
             account
           );
 
@@ -45,8 +47,7 @@ describe("test pox-4 contract read only functions", () => {
             Number(reward_cycle_length.value) * reward_cycle;
           expect(actual).toBeUint(expected);
         }
-      ),
-      { numRuns: 300 }
+      )
     );
   });
 
@@ -75,7 +76,7 @@ describe("test pox-4 contract read only functions", () => {
           const { result: actual } = simnet.callReadOnlyFn(
             POX_4,
             "burn-height-to-reward-cycle",
-            [Cl.uintCV(burn_height)],
+            [Cl.uint(burn_height)],
             account
           );
 
@@ -89,8 +90,7 @@ describe("test pox-4 contract read only functions", () => {
           );
           expect(actual).toBeUint(expected);
         }
-      ),
-      { numRuns: 300 }
+      )
     );
   });
 
@@ -106,7 +106,7 @@ describe("test pox-4 contract read only functions", () => {
           const { result: actual } = simnet.callReadOnlyFn(
             POX_4,
             "get-stacker-info",
-            [Cl.principalCV(stacker)],
+            [Cl.principal(stacker)],
             caller
           );
 
@@ -118,7 +118,7 @@ describe("test pox-4 contract read only functions", () => {
     );
   });
 
-  it("should return correct check-caller-allowed", () => {
+  it("should return true check-caller-allowed", () => {
     fc.assert(
       fc.property(
         fc.constantFrom(...simnet.getAccounts().values()),
@@ -154,7 +154,7 @@ describe("test pox-4 contract read only functions", () => {
           const { result: actual } = simnet.callReadOnlyFn(
             POX_4,
             "get-reward-set-size",
-            [Cl.uintCV(reward_cycle)],
+            [Cl.uint(reward_cycle)],
             caller
           );
 
@@ -179,7 +179,7 @@ describe("test pox-4 contract read only functions", () => {
           const { result: actual } = simnet.callReadOnlyFn(
             POX_4,
             "get-total-ustx-stacked",
-            [Cl.uintCV(reward_cycle)],
+            [Cl.uint(reward_cycle)],
             caller
           );
 
@@ -204,7 +204,7 @@ describe("test pox-4 contract read only functions", () => {
           const { result: actual } = simnet.callReadOnlyFn(
             POX_4,
             "get-reward-set-pox-address",
-            [Cl.uintCV(index), Cl.uintCV(reward_cycle)],
+            [Cl.uint(index), Cl.uint(reward_cycle)],
             caller
           );
 
@@ -222,7 +222,6 @@ describe("test pox-4 contract read only functions", () => {
         fc.constantFrom(...simnet.getAccounts().values()),
         (caller) => {
           // Arrange
-          const testnet_stacking_threshold_25 = 8000;
 
           const { result: pox_4_info } = simnet.callReadOnlyFn(
             POX_4,
@@ -257,77 +256,206 @@ describe("test pox-4 contract read only functions", () => {
     );
   });
 
-  it("should return correct check-pox-addr-version", () => {
+  it("should return true check-pox-addr-version for version <= 6 ", () => {
     fc.assert(
       fc.property(
         fc.constantFrom(...simnet.getAccounts().values()),
-        fc.nat({ max: 255 }),
+        fc.nat({ max: 6 }),
         (caller, version) => {
           // Arrange
-          const expected = version > 6 ? false : true;
+          const expected = true;
 
           // Act
           let { result: actual } = simnet.callReadOnlyFn(
             POX_4,
             "check-pox-addr-version",
-            [Cl.bufferCV(Uint8Array.from([version]))],
+            [Cl.buffer(Uint8Array.from([version]))],
             caller
           );
 
           // Assert
-          assert(
-            isClarityType(
-              actual,
-              expected ? ClarityType.BoolTrue : ClarityType.BoolFalse
-            )
+          assert(isClarityType(actual, ClarityType.BoolTrue));
+          expect(actual).toBeBool(expected);
+        }
+      )
+    );
+  });
+
+  it("should return false check-pox-addr-version for version > 6", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 7, max: 255 }),
+        (caller, version) => {
+          // Arrange
+          const expected = false;
+
+          // Act
+          let { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "check-pox-addr-version",
+            [Cl.buffer(Uint8Array.from([version]))],
+            caller
           );
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.BoolFalse));
           expect(actual).toBeBool(expected);
         }
       )
     );
   });
 
-  it("should return correct check-pox-lock-period", () => {
+  it("should return true check-pox-lock-period for valid reward cycles number", () => {
     fc.assert(
       fc.property(
         fc.constantFrom(...simnet.getAccounts().values()),
-        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
         (caller, reward_cycles) => {
           // Arrange
-          const expected =
-            reward_cycles > 0 && reward_cycles <= 12 ? true : false;
+          const expected = true;
 
           // Act
           const { result: actual } = simnet.callReadOnlyFn(
             POX_4,
             "check-pox-lock-period",
-            [Cl.uintCV(reward_cycles)],
+            [Cl.uint(reward_cycles)],
             caller
           );
 
           // Assert
-          assert(
-            isClarityType(
-              actual,
-              expected ? ClarityType.BoolTrue : ClarityType.BoolFalse
-            )
+          assert(isClarityType(actual, ClarityType.BoolTrue));
+          expect(actual).toBeBool(expected);
+        }
+      )
+    );
+  });
+
+  it("should return false check-pox-lock-period for reward cycles number > 12", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 13 }),
+        (caller, reward_cycles) => {
+          // Arrange
+          const expected = false;
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "check-pox-lock-period",
+            [Cl.uint(reward_cycles)],
+            caller
           );
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.BoolFalse));
           expect(actual).toBeBool(expected);
         }
       )
-    ),
-      { numRuns: 250 };
+    );
   });
 
-  it("should return correct can-stack-stx", () => {
+  it("should return false check-pox-lock-period for reward cycles number == 0", () => {
     fc.assert(
       fc.property(
         fc.constantFrom(...simnet.getAccounts().values()),
-        fc.nat({ max: 255 }),
-        fc.array(fc.nat({ max: 255 }), { maxLength: 32 }),
-        fc.bigInt({ min: 0n, max: 340282366920938463463374607431768211455n }),
+        (caller) => {
+          // Arrange
+          const reward_cycles = 0;
+          const expected = false;
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "check-pox-lock-period",
+            [Cl.uint(reward_cycles)],
+            caller
+          );
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.BoolFalse));
+          expect(actual).toBeBool(expected);
+        }
+      )
+    );
+  });
+
+  it("should return (ok true) can-stack-stx for versions 0-4 valid pox addresses, hashbytes, amount, cycles number", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 0, max: 4 }),
+        fc.array(fc.nat({ max: 255 }), {
+          minLength: 20,
+          maxLength: 20,
+        }),
+        fc.bigInt({
+          min: 125_000_000_000n,
+          max: 340282366920938463463374607431768211455n,
+        }),
         fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            POX_4,
+            GET_POX_INFO,
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+          const expectedResponseOk = true;
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "can-stack-stx",
+            [
+              Cl.tuple({
+                version: bufferCV(Uint8Array.from([version])),
+                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseOk));
+          assert(isClarityType(actual.value, ClarityType.BoolTrue));
+          expect(actual).toBeOk(Cl.bool(expectedResponseOk));
+        }
+      )
+    );
+  });
+
+  it("should return (ok true) can-stack-stx for versions 5/6 valid pox addresses, hashbytes, amount, cycles number", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 5, max: 6 }),
+        fc.array(fc.nat({ max: 255 }), {
+          minLength: 32,
+          maxLength: 32,
+        }),
+        fc.bigInt({
+          min: 125_000_000_000n,
+          max: 340282366920938463463374607431768211455n,
+        }),
         fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
         (
           caller,
           version,
@@ -337,7 +465,6 @@ describe("test pox-4 contract read only functions", () => {
           num_cycles
         ) => {
           // Arrange
-          const testnet_stacking_threshold_25 = 8000;
 
           const { result: pox_4_info } = simnet.callReadOnlyFn(
             POX_4,
@@ -348,31 +475,6 @@ describe("test pox-4 contract read only functions", () => {
           assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
           assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
 
-          const stacking_valid_amount = amount_ustx > 0;
-          const pox_lock_period_valid = num_cycles > 0 && num_cycles <= 12;
-          const pox_version_valid = version <= 6;
-          const pox_hashbytes_valid =
-            hashbytes.length === 20 || hashbytes.length === 32;
-          const stx_liq_supply =
-            pox_4_info.value.data["total-liquid-supply-ustx"];
-
-          assert(isClarityType(stx_liq_supply, ClarityType.UInt));
-          const stacking_threshold_met =
-            amount_ustx >=
-            Math.floor(
-              Number(stx_liq_supply.value) / testnet_stacking_threshold_25
-            );
-          const expectedResponseErr = !stacking_threshold_met
-            ? 11
-            : !stacking_valid_amount
-            ? 18
-            : !pox_lock_period_valid
-            ? 2
-            : !pox_version_valid
-            ? 13
-            : !pox_hashbytes_valid
-            ? 13
-            : 0;
           const expectedResponseOk = true;
 
           // Act
@@ -380,55 +482,83 @@ describe("test pox-4 contract read only functions", () => {
             POX_4,
             "can-stack-stx",
             [
-              Cl.tupleCV({
+              Cl.tuple({
                 version: bufferCV(Uint8Array.from([version])),
                 hashbytes: bufferCV(Uint8Array.from(hashbytes)),
               }),
-              Cl.uintCV(amount_ustx),
-              Cl.uintCV(first_rew_cycle),
-              Cl.uintCV(num_cycles),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
             ],
             caller
           );
 
           // Assert
-          assert(
-            isClarityType(
-              actual,
-              stacking_threshold_met &&
-                stacking_valid_amount &&
-                pox_lock_period_valid &&
-                pox_version_valid &&
-                pox_hashbytes_valid
-                ? ClarityType.ResponseOk
-                : ClarityType.ResponseErr
-            )
+          assert(isClarityType(actual, ClarityType.ResponseOk));
+          assert(isClarityType(actual.value, ClarityType.BoolTrue));
+          expect(actual).toBeOk(Cl.bool(expectedResponseOk));
+        }
+      )
+    );
+  });
+
+  it("should return (err 13) can-stack-stx for versions 0-4 pox addresses having hasbytes longer than 20", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 0, max: 4 }),
+        fc.array(fc.nat({ max: 255 }), {
+          minLength: 21,
+          maxLength: 32,
+        }),
+        fc.bigInt({
+          min: 125_000_000_000n,
+          max: 340282366920938463463374607431768211455n,
+        }),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            POX_4,
+            GET_POX_INFO,
+            [],
+            caller
           );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+          const expectedResponseErr = 13;
 
-          assert(
-            isClarityType(
-              actual.value,
-              stacking_threshold_met &&
-                stacking_valid_amount &&
-                pox_lock_period_valid &&
-                pox_version_valid &&
-                pox_hashbytes_valid
-                ? ClarityType.BoolTrue
-                : ClarityType.Int
-            )
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "can-stack-stx",
+            [
+              Cl.tuple({
+                version: bufferCV(Uint8Array.from([version])),
+                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
           );
-          if (expectedResponseErr === 0) {
-            expect(actual).toBeOk(
-              Cl.responseOkCV(Cl.boolCV(expectedResponseOk))
-            );
-            expect(actual.value).toBeBool(expectedResponseOk);
-          } else {
-            expect(actual).toBeErr(Cl.intCV(expectedResponseErr));
-            expect(actual.value).toBeInt(expectedResponseErr);
-          }
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
         }
-      ),
-      { numRuns: 300 }
+      )
     );
   });
 });

From b1166b6268e2ff40aa17d970416c6116fbc09534 Mon Sep 17 00:00:00 2001
From: BowTiedRadone <bowtiedradone@gmail.com>
Date: Tue, 5 Mar 2024 16:49:33 +0200
Subject: [PATCH 1087/1166] Added tests for minimal-can-stack-stx

---
 .../tests/pox-4/pox-4.prop.test.ts            | 786 +++++++++++++++++-
 1 file changed, 782 insertions(+), 4 deletions(-)

diff --git a/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts b/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
index d084d7759d..a377fa9915 100644
--- a/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
+++ b/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
@@ -1,10 +1,25 @@
-import { Cl, ClarityType, bufferCV, isClarityType } from "@stacks/transactions";
+import {
+  Cl,
+  ClarityType,
+  bufferCV,
+  cvToJSON,
+  isClarityType,
+} from "@stacks/transactions";
 import { assert, describe, expect, it } from "vitest";
 import fc from "fast-check";
 
+// contracts
 const POX_4 = "pox-4";
+// methods
 const GET_POX_INFO = "get-pox-info";
-const testnet_stacking_threshold_25 = 8000;
+// contract consts
+const TESTNET_STACKING_THRESHOLD_25 = 8000;
+// error codes
+const ERR_STACKING_INVALID_LOCK_PERIOD = 2;
+const ERR_STACKING_THRESHOLD_NOT_MET = 11;
+const ERR_STACKING_INVALID_POX_ADDRESS = 13;
+const ERR_STACKING_INVALID_AMOUNT = 18;
+
 fc.configureGlobal({ numRuns: 250 });
 
 describe("test pox-4 contract read only functions", () => {
@@ -237,7 +252,7 @@ describe("test pox-4 contract read only functions", () => {
 
           assert(isClarityType(stx_liq_supply, ClarityType.UInt));
           const expected = Math.floor(
-            Number(stx_liq_supply.value) / testnet_stacking_threshold_25
+            Number(stx_liq_supply.value) / TESTNET_STACKING_THRESHOLD_25
           );
 
           // Act
@@ -502,6 +517,69 @@ describe("test pox-4 contract read only functions", () => {
     );
   });
 
+  it("should return (err 13) can-stack-stx for pox addresses having version > 6", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({
+          min: 7,
+          max: 255,
+        }),
+        fc.array(fc.nat({ max: 255 }), {
+          minLength: 32,
+          maxLength: 32,
+        }),
+        fc.bigInt({
+          min: 125_000_000_000n,
+          max: 340282366920938463463374607431768211455n,
+        }),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            POX_4,
+            GET_POX_INFO,
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+          const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "can-stack-stx",
+            [
+              Cl.tuple({
+                version: bufferCV(Uint8Array.from([version])),
+                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
+        }
+      )
+    );
+  });
+
   it("should return (err 13) can-stack-stx for versions 0-4 pox addresses having hasbytes longer than 20", () => {
     fc.assert(
       fc.property(
@@ -535,7 +613,182 @@ describe("test pox-4 contract read only functions", () => {
           assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
           assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
 
-          const expectedResponseErr = 13;
+          const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "can-stack-stx",
+            [
+              Cl.tuple({
+                version: bufferCV(Uint8Array.from([version])),
+                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
+        }
+      )
+    );
+  });
+
+  it("should return (err 13) can-stack-stx for versions 0-4 pox addresses having hasbytes shorter than 20", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 0, max: 4 }),
+        fc.array(fc.nat({ max: 255 }), {
+          maxLength: 19,
+        }),
+        fc.bigInt({
+          min: 125_000_000_000n,
+          max: 340282366920938463463374607431768211455n,
+        }),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            POX_4,
+            GET_POX_INFO,
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+          const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "can-stack-stx",
+            [
+              Cl.tuple({
+                version: bufferCV(Uint8Array.from([version])),
+                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
+        }
+      )
+    );
+  });
+
+  it("should return (err 13) can-stack-stx for versions 5/6 pox addresses having hashbytes shorter than 32", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 0, max: 4 }),
+        fc.array(fc.nat({ max: 255 }), {
+          maxLength: 31,
+        }),
+        fc.bigInt({
+          min: 125_000_000_000n,
+          max: 340282366920938463463374607431768211455n,
+        }),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            POX_4,
+            GET_POX_INFO,
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+          const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "can-stack-stx",
+            [
+              Cl.tuple({
+                version: bufferCV(Uint8Array.from([version])),
+                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
+        }
+      )
+    );
+  });
+
+  it("should return (err 11) can-stack-stx for unmet stacking threshold", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 0, max: 6 }),
+        fc.array(fc.nat({ max: 255 })),
+        fc.bigInt({
+          min: 0n,
+          max: 124_999_999_999n,
+        }),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            POX_4,
+            GET_POX_INFO,
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+          const expectedResponseErr = ERR_STACKING_THRESHOLD_NOT_MET;
 
           // Act
           const { result: actual } = simnet.callReadOnlyFn(
@@ -561,4 +814,529 @@ describe("test pox-4 contract read only functions", () => {
       )
     );
   });
+
+  it("should return (err 2) can-stack-stx for lock period > 12", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 0, max: 6 }),
+        fc.array(fc.nat({ max: 255 })),
+        fc.bigInt({
+          min: 125_000_000_000n,
+          max: 340282366920938463463374607431768211455n,
+        }),
+        fc.nat(),
+        fc.integer({ min: 13 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            POX_4,
+            GET_POX_INFO,
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+          const expectedResponseErr = ERR_STACKING_INVALID_LOCK_PERIOD;
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "can-stack-stx",
+            [
+              Cl.tuple({
+                version: bufferCV(Uint8Array.from([version])),
+                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
+        }
+      )
+    );
+  });
+
+  // minimal can stack stx
+  it("should return (ok true) minimal-can-stack-stx for versions 0-4 valid pox addresses, hashbytes, amount, cycles number", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 0, max: 4 }),
+        fc.array(fc.nat({ max: 255 }), {
+          minLength: 20,
+          maxLength: 20,
+        }),
+        fc.bigInt({
+          min: 125_000_000_000n,
+          max: 340282366920938463463374607431768211455n,
+        }),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            POX_4,
+            GET_POX_INFO,
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+          const expectedResponseOk = true;
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "minimal-can-stack-stx",
+            [
+              Cl.tuple({
+                version: bufferCV(Uint8Array.from([version])),
+                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseOk));
+          assert(isClarityType(actual.value, ClarityType.BoolTrue));
+          expect(actual).toBeOk(Cl.bool(expectedResponseOk));
+        }
+      )
+    );
+  });
+
+  it("should return (ok true) minimal-can-stack-stx for versions 5/6 valid pox addresses, hashbytes, amount, cycles number", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 5, max: 6 }),
+        fc.array(fc.nat({ max: 255 }), {
+          minLength: 32,
+          maxLength: 32,
+        }),
+        fc.bigInt({
+          min: 125_000_000_000n,
+          max: 340282366920938463463374607431768211455n,
+        }),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            POX_4,
+            GET_POX_INFO,
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+          const expectedResponseOk = true;
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "minimal-can-stack-stx",
+            [
+              Cl.tuple({
+                version: bufferCV(Uint8Array.from([version])),
+                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseOk));
+          assert(isClarityType(actual.value, ClarityType.BoolTrue));
+          expect(actual).toBeOk(Cl.bool(expectedResponseOk));
+        }
+      )
+    );
+  });
+
+  it("should return (err 13) minimal-can-stack-stx for pox addresses having version > 6", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({
+          min: 7,
+          max: 255,
+        }),
+        fc.array(fc.nat({ max: 255 }), {
+          minLength: 32,
+          maxLength: 32,
+        }),
+        fc.bigInt({
+          min: 125_000_000_000n,
+          max: 340282366920938463463374607431768211455n,
+        }),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            POX_4,
+            GET_POX_INFO,
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+          const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "minimal-can-stack-stx",
+            [
+              Cl.tuple({
+                version: bufferCV(Uint8Array.from([version])),
+                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
+        }
+      )
+    );
+  });
+
+  it("should return (err 13) minimal-can-stack-stx for versions 0-4 pox addresses having hasbytes longer than 20", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 0, max: 4 }),
+        fc.array(fc.nat({ max: 255 }), {
+          minLength: 21,
+          maxLength: 32,
+        }),
+        fc.bigInt({
+          min: 125_000_000_000n,
+          max: 340282366920938463463374607431768211455n,
+        }),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            POX_4,
+            GET_POX_INFO,
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+          const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "minimal-can-stack-stx",
+            [
+              Cl.tuple({
+                version: bufferCV(Uint8Array.from([version])),
+                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
+        }
+      )
+    );
+  });
+
+  it("should return (err 13) minimal-can-stack-stx for versions 0-4 pox addresses having hasbytes shorter than 20", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 0, max: 4 }),
+        fc.array(fc.nat({ max: 255 }), {
+          maxLength: 19,
+        }),
+        fc.bigInt({
+          min: 125_000_000_000n,
+          max: 340282366920938463463374607431768211455n,
+        }),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            POX_4,
+            GET_POX_INFO,
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+          const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "minimal-can-stack-stx",
+            [
+              Cl.tuple({
+                version: bufferCV(Uint8Array.from([version])),
+                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
+        }
+      )
+    );
+  });
+
+  it("should return (err 13) minimal-can-stack-stx for versions 5/6 pox addresses having hashbytes shorter than 32", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 0, max: 4 }),
+        fc.array(fc.nat({ max: 255 }), {
+          maxLength: 31,
+        }),
+        fc.bigInt({
+          min: 125_000_000_000n,
+          max: 340282366920938463463374607431768211455n,
+        }),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            POX_4,
+            GET_POX_INFO,
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+          const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "minimal-can-stack-stx",
+            [
+              Cl.tuple({
+                version: bufferCV(Uint8Array.from([version])),
+                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
+        }
+      )
+    );
+  });
+
+  it("should return (err 2) minimal-can-stack-stx for lock period > 12", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 0, max: 6 }),
+        fc.array(fc.nat({ max: 255 })),
+        fc.bigInt({
+          min: 125_000_000_000n,
+          max: 340282366920938463463374607431768211455n,
+        }),
+        fc.nat(),
+        fc.integer({ min: 13 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            POX_4,
+            GET_POX_INFO,
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+          const expectedResponseErr = ERR_STACKING_INVALID_LOCK_PERIOD;
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "minimal-can-stack-stx",
+            [
+              Cl.tuple({
+                version: bufferCV(Uint8Array.from([version])),
+                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
+        }
+      )
+    );
+  });
+
+  it("should return (err 18) minimal-can-stack-stx for amount == 0", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer(),
+        fc.array(fc.nat({ max: 255 })),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (caller, version, hashbytes, first_rew_cycle, num_cycles) => {
+          // Arrange
+          const amount_ustx = 0;
+
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            POX_4,
+            GET_POX_INFO,
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+          const expectedResponseErr = ERR_STACKING_INVALID_AMOUNT;
+
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            POX_4,
+            "minimal-can-stack-stx",
+            [
+              Cl.tuple({
+                version: bufferCV(Uint8Array.from([version])),
+                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
+        }
+      )
+    );
+  });
 });

From 895ba1c94c6a4101bdbbac3ddc0b1977ed0580b0 Mon Sep 17 00:00:00 2001
From: BowTiedRadone <bowtiedradone@gmail.com>
Date: Wed, 6 Mar 2024 19:04:20 +0200
Subject: [PATCH 1088/1166] added tests for read only functions

- get-check-delegation
- get-delegation-info
- get-allowance-contract-callers
- get-pox-info
- minimal-can-stack-stx
---
 .../tests/pox-4/pox-4.prop.test.ts            | 2843 +++++++++--------
 1 file changed, 1514 insertions(+), 1329 deletions(-)

diff --git a/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts b/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
index a377fa9915..506ebd2864 100644
--- a/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
+++ b/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
@@ -1,1342 +1,1527 @@
-import {
-  Cl,
-  ClarityType,
-  bufferCV,
-  cvToJSON,
-  isClarityType,
-} from "@stacks/transactions";
+import { Cl, ClarityType, isClarityType } from "@stacks/transactions";
 import { assert, describe, expect, it } from "vitest";
 import fc from "fast-check";
 
-// contracts
+// Contracts
 const POX_4 = "pox-4";
-// methods
+// Methods
 const GET_POX_INFO = "get-pox-info";
-// contract consts
+const GET_STACKER_INFO = "get-stacker-info";
+const REWARD_CYCLE_TO_BURN_HEIGHT = "reward-cycle-to-burn-height";
+const BURN_HEIGHT_TO_REWARD_CYCLE = "burn-height-to-reward-cycle";
+const CURRENT_POX_REWARD_CYCLE = "current-pox-reward-cycle";
+const CHECK_CALLER_ALLOWED = "check-caller-allowed";
+const GET_REWARD_SET_SIZE = "get-reward-set-size";
+const GET_REWARD_SET_POX_ADDRESS = "get-reward-set-pox-address";
+const GET_TOTAL_USTX_STACKED = "get-total-ustx-stacked";
+const CHECK_POX_ADDR_VERSION = "check-pox-addr-version";
+const CHECK_POX_LOCK_PERIOD = "check-pox-lock-period";
+const GET_STACKING_MINIMUM = "get-stacking-minimum";
+const CAN_STACK_STX = "can-stack-stx";
+const MINIMAL_CAN_STACK_STX = "minimal-can-stack-stx";
+const GET_CHECK_DELEGATION = "get-check-delegation";
+const GET_DELEGATION_INFO = "get-delegation-info";
+const GET_ALLOWANCE_CONTRACT_CALLERS = "get-allowance-contract-callers";
+const ALLOW_CONTRACT_CALLER = "allow-contract-caller";
+// Contract Consts
 const TESTNET_STACKING_THRESHOLD_25 = 8000;
-// error codes
+const TESTNET_REWARD_CYCLE_LENGTH = 1050;
+const TESTNET_PREPARE_CYCLE_LENGTH = 50;
+const INITIAL_TOTAL_LIQ_SUPPLY = 1_000_000_000_000_000;
+const MIN_AMOUNT_USTX = 125_000_000_000n;
+// Clarity Constraints
+const MAX_CLAR_UINT = 340282366920938463463374607431768211455n;
+// Error Codes
 const ERR_STACKING_INVALID_LOCK_PERIOD = 2;
 const ERR_STACKING_THRESHOLD_NOT_MET = 11;
 const ERR_STACKING_INVALID_POX_ADDRESS = 13;
 const ERR_STACKING_INVALID_AMOUNT = 18;
 
-fc.configureGlobal({ numRuns: 250 });
-
-describe("test pox-4 contract read only functions", () => {
-  it("should return correct reward-cycle-to-burn-height", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.nat(),
-        (account, reward_cycle) => {
-          // Arrange
-          const { result: pox_4_info } = simnet.callReadOnlyFn(
-            POX_4,
-            GET_POX_INFO,
-            [],
-            account
-          );
-          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
-          const first_burn_block_height =
-            pox_4_info.value.data["first-burnchain-block-height"];
-          const reward_cycle_length =
-            pox_4_info.value.data["reward-cycle-length"];
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "reward-cycle-to-burn-height",
-            [Cl.uint(reward_cycle)],
-            account
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.UInt));
-          assert(isClarityType(first_burn_block_height, ClarityType.UInt));
-          assert(isClarityType(reward_cycle_length, ClarityType.UInt));
-
-          const expected =
-            Number(first_burn_block_height.value) +
-            Number(reward_cycle_length.value) * reward_cycle;
-          expect(actual).toBeUint(expected);
-        }
-      )
-    );
-  });
-
-  it("should return correct burn-height-to-reward-cycle", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.nat(),
-        (account, burn_height) => {
-          // Arrange
-          const { result: pox_4_info } = simnet.callReadOnlyFn(
-            POX_4,
-            GET_POX_INFO,
-            [],
-            account
-          );
-          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
-          const first_burn_block_height =
-            pox_4_info.value.data["first-burnchain-block-height"];
-          const reward_cycle_length =
-            pox_4_info.value.data["reward-cycle-length"];
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "burn-height-to-reward-cycle",
-            [Cl.uint(burn_height)],
-            account
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.UInt));
-          assert(isClarityType(first_burn_block_height, ClarityType.UInt));
-          assert(isClarityType(reward_cycle_length, ClarityType.UInt));
-          const expected = Math.floor(
-            (burn_height - Number(first_burn_block_height.value)) /
-              Number(reward_cycle_length.value)
-          );
-          expect(actual).toBeUint(expected);
-        }
-      )
-    );
-  });
-
-  it("should return none get-stacker-info", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.constantFrom(...simnet.getAccounts().values()),
-        (stacker, caller) => {
-          // Arrange
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "get-stacker-info",
-            [Cl.principal(stacker)],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.OptionalNone));
-          expect(actual).toBeNone();
-        }
-      )
-    );
-  });
-
-  it("should return true check-caller-allowed", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        (caller) => {
-          // Arrange
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "check-caller-allowed",
-            [],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.BoolTrue));
-          expect(actual).toBeBool(true);
-        }
-      )
-    );
-  });
-
-  it("should return u0 get-reward-set-size", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.nat(),
-        (caller, reward_cycle) => {
-          // Arrange
-          const expected = 0;
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "get-reward-set-size",
-            [Cl.uint(reward_cycle)],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.UInt));
-          expect(actual).toBeUint(expected);
-        }
-      )
-    );
-  });
-
-  it("should return u0 get-total-ustx-stacked", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.nat(),
-        (caller, reward_cycle) => {
-          // Arrange
-          const expected = 0;
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "get-total-ustx-stacked",
-            [Cl.uint(reward_cycle)],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.UInt));
-          expect(actual).toBeUint(expected);
-        }
-      )
-    );
-  });
-
-  it("should return none get-reward-set-pox-address", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.nat(),
-        fc.nat(),
-        (caller, index, reward_cycle) => {
-          // Arrange
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "get-reward-set-pox-address",
-            [Cl.uint(index), Cl.uint(reward_cycle)],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.OptionalNone));
-          expect(actual).toBeNone();
-        }
-      )
-    );
-  });
-
-  it("should return correct get-stacking-minimum", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        (caller) => {
-          // Arrange
-
-          const { result: pox_4_info } = simnet.callReadOnlyFn(
-            POX_4,
-            GET_POX_INFO,
-            [],
-            caller
-          );
-          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
-          const stx_liq_supply =
-            pox_4_info.value.data["total-liquid-supply-ustx"];
-
-          assert(isClarityType(stx_liq_supply, ClarityType.UInt));
-          const expected = Math.floor(
-            Number(stx_liq_supply.value) / TESTNET_STACKING_THRESHOLD_25
-          );
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "get-stacking-minimum",
-            [],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.UInt));
-          expect(actual).toBeUint(expected);
-        }
-      )
-    );
-  });
-
-  it("should return true check-pox-addr-version for version <= 6 ", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.nat({ max: 6 }),
-        (caller, version) => {
-          // Arrange
-          const expected = true;
-
-          // Act
-          let { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "check-pox-addr-version",
-            [Cl.buffer(Uint8Array.from([version]))],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.BoolTrue));
-          expect(actual).toBeBool(expected);
-        }
-      )
-    );
-  });
-
-  it("should return false check-pox-addr-version for version > 6", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.integer({ min: 7, max: 255 }),
-        (caller, version) => {
-          // Arrange
-          const expected = false;
-
-          // Act
-          let { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "check-pox-addr-version",
-            [Cl.buffer(Uint8Array.from([version]))],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.BoolFalse));
-          expect(actual).toBeBool(expected);
-        }
-      )
-    );
-  });
-
-  it("should return true check-pox-lock-period for valid reward cycles number", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.integer({ min: 1, max: 12 }),
-        (caller, reward_cycles) => {
-          // Arrange
-          const expected = true;
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "check-pox-lock-period",
-            [Cl.uint(reward_cycles)],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.BoolTrue));
-          expect(actual).toBeBool(expected);
-        }
-      )
-    );
-  });
-
-  it("should return false check-pox-lock-period for reward cycles number > 12", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.integer({ min: 13 }),
-        (caller, reward_cycles) => {
-          // Arrange
-          const expected = false;
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "check-pox-lock-period",
-            [Cl.uint(reward_cycles)],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.BoolFalse));
-          expect(actual).toBeBool(expected);
-        }
-      )
-    );
-  });
-
-  it("should return false check-pox-lock-period for reward cycles number == 0", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        (caller) => {
-          // Arrange
-          const reward_cycles = 0;
-          const expected = false;
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "check-pox-lock-period",
-            [Cl.uint(reward_cycles)],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.BoolFalse));
-          expect(actual).toBeBool(expected);
-        }
-      )
-    );
-  });
-
-  it("should return (ok true) can-stack-stx for versions 0-4 valid pox addresses, hashbytes, amount, cycles number", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.integer({ min: 0, max: 4 }),
-        fc.array(fc.nat({ max: 255 }), {
-          minLength: 20,
-          maxLength: 20,
-        }),
-        fc.bigInt({
-          min: 125_000_000_000n,
-          max: 340282366920938463463374607431768211455n,
-        }),
-        fc.nat(),
-        fc.integer({ min: 1, max: 12 }),
-        (
-          caller,
-          version,
-          hashbytes,
-          amount_ustx,
-          first_rew_cycle,
-          num_cycles
-        ) => {
-          // Arrange
-          const { result: pox_4_info } = simnet.callReadOnlyFn(
-            POX_4,
-            GET_POX_INFO,
-            [],
-            caller
-          );
-          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
-          const expectedResponseOk = true;
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "can-stack-stx",
-            [
-              Cl.tuple({
-                version: bufferCV(Uint8Array.from([version])),
-                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
-              }),
-              Cl.uint(amount_ustx),
-              Cl.uint(first_rew_cycle),
-              Cl.uint(num_cycles),
-            ],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.ResponseOk));
-          assert(isClarityType(actual.value, ClarityType.BoolTrue));
-          expect(actual).toBeOk(Cl.bool(expectedResponseOk));
-        }
-      )
-    );
-  });
-
-  it("should return (ok true) can-stack-stx for versions 5/6 valid pox addresses, hashbytes, amount, cycles number", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.integer({ min: 5, max: 6 }),
-        fc.array(fc.nat({ max: 255 }), {
-          minLength: 32,
-          maxLength: 32,
-        }),
-        fc.bigInt({
-          min: 125_000_000_000n,
-          max: 340282366920938463463374607431768211455n,
-        }),
-        fc.nat(),
-        fc.integer({ min: 1, max: 12 }),
-        (
-          caller,
-          version,
-          hashbytes,
-          amount_ustx,
-          first_rew_cycle,
-          num_cycles
-        ) => {
-          // Arrange
-
-          const { result: pox_4_info } = simnet.callReadOnlyFn(
-            POX_4,
-            GET_POX_INFO,
-            [],
-            caller
-          );
-          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
-          const expectedResponseOk = true;
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "can-stack-stx",
-            [
-              Cl.tuple({
-                version: bufferCV(Uint8Array.from([version])),
-                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
-              }),
-              Cl.uint(amount_ustx),
-              Cl.uint(first_rew_cycle),
-              Cl.uint(num_cycles),
-            ],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.ResponseOk));
-          assert(isClarityType(actual.value, ClarityType.BoolTrue));
-          expect(actual).toBeOk(Cl.bool(expectedResponseOk));
-        }
-      )
-    );
-  });
-
-  it("should return (err 13) can-stack-stx for pox addresses having version > 6", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.integer({
-          min: 7,
-          max: 255,
-        }),
-        fc.array(fc.nat({ max: 255 }), {
-          minLength: 32,
-          maxLength: 32,
-        }),
-        fc.bigInt({
-          min: 125_000_000_000n,
-          max: 340282366920938463463374607431768211455n,
-        }),
-        fc.nat(),
-        fc.integer({ min: 1, max: 12 }),
-        (
-          caller,
-          version,
-          hashbytes,
-          amount_ustx,
-          first_rew_cycle,
-          num_cycles
-        ) => {
-          // Arrange
-          const { result: pox_4_info } = simnet.callReadOnlyFn(
-            POX_4,
-            GET_POX_INFO,
-            [],
-            caller
-          );
-          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
-          const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "can-stack-stx",
-            [
-              Cl.tuple({
-                version: bufferCV(Uint8Array.from([version])),
-                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
-              }),
-              Cl.uint(amount_ustx),
-              Cl.uint(first_rew_cycle),
-              Cl.uint(num_cycles),
-            ],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.ResponseErr));
-          assert(isClarityType(actual.value, ClarityType.Int));
-          expect(actual).toBeErr(Cl.int(expectedResponseErr));
-        }
-      )
-    );
-  });
-
-  it("should return (err 13) can-stack-stx for versions 0-4 pox addresses having hasbytes longer than 20", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.integer({ min: 0, max: 4 }),
-        fc.array(fc.nat({ max: 255 }), {
-          minLength: 21,
-          maxLength: 32,
-        }),
-        fc.bigInt({
-          min: 125_000_000_000n,
-          max: 340282366920938463463374607431768211455n,
-        }),
-        fc.nat(),
-        fc.integer({ min: 1, max: 12 }),
-        (
-          caller,
-          version,
-          hashbytes,
-          amount_ustx,
-          first_rew_cycle,
-          num_cycles
-        ) => {
-          // Arrange
-          const { result: pox_4_info } = simnet.callReadOnlyFn(
-            POX_4,
-            GET_POX_INFO,
-            [],
-            caller
-          );
-          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
-          const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "can-stack-stx",
-            [
-              Cl.tuple({
-                version: bufferCV(Uint8Array.from([version])),
-                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
-              }),
-              Cl.uint(amount_ustx),
-              Cl.uint(first_rew_cycle),
-              Cl.uint(num_cycles),
-            ],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.ResponseErr));
-          assert(isClarityType(actual.value, ClarityType.Int));
-          expect(actual).toBeErr(Cl.int(expectedResponseErr));
-        }
-      )
-    );
-  });
-
-  it("should return (err 13) can-stack-stx for versions 0-4 pox addresses having hasbytes shorter than 20", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.integer({ min: 0, max: 4 }),
-        fc.array(fc.nat({ max: 255 }), {
-          maxLength: 19,
-        }),
-        fc.bigInt({
-          min: 125_000_000_000n,
-          max: 340282366920938463463374607431768211455n,
-        }),
-        fc.nat(),
-        fc.integer({ min: 1, max: 12 }),
-        (
-          caller,
-          version,
-          hashbytes,
-          amount_ustx,
-          first_rew_cycle,
-          num_cycles
-        ) => {
-          // Arrange
-          const { result: pox_4_info } = simnet.callReadOnlyFn(
-            POX_4,
-            GET_POX_INFO,
-            [],
-            caller
-          );
-          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
-          const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "can-stack-stx",
-            [
-              Cl.tuple({
-                version: bufferCV(Uint8Array.from([version])),
-                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
-              }),
-              Cl.uint(amount_ustx),
-              Cl.uint(first_rew_cycle),
-              Cl.uint(num_cycles),
-            ],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.ResponseErr));
-          assert(isClarityType(actual.value, ClarityType.Int));
-          expect(actual).toBeErr(Cl.int(expectedResponseErr));
-        }
-      )
-    );
-  });
-
-  it("should return (err 13) can-stack-stx for versions 5/6 pox addresses having hashbytes shorter than 32", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.integer({ min: 0, max: 4 }),
-        fc.array(fc.nat({ max: 255 }), {
-          maxLength: 31,
-        }),
-        fc.bigInt({
-          min: 125_000_000_000n,
-          max: 340282366920938463463374607431768211455n,
-        }),
-        fc.nat(),
-        fc.integer({ min: 1, max: 12 }),
-        (
-          caller,
-          version,
-          hashbytes,
-          amount_ustx,
-          first_rew_cycle,
-          num_cycles
-        ) => {
-          // Arrange
-          const { result: pox_4_info } = simnet.callReadOnlyFn(
-            POX_4,
-            GET_POX_INFO,
-            [],
-            caller
-          );
-          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
-          const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "can-stack-stx",
-            [
-              Cl.tuple({
-                version: bufferCV(Uint8Array.from([version])),
-                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
-              }),
-              Cl.uint(amount_ustx),
-              Cl.uint(first_rew_cycle),
-              Cl.uint(num_cycles),
-            ],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.ResponseErr));
-          assert(isClarityType(actual.value, ClarityType.Int));
-          expect(actual).toBeErr(Cl.int(expectedResponseErr));
-        }
-      )
-    );
-  });
-
-  it("should return (err 11) can-stack-stx for unmet stacking threshold", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.integer({ min: 0, max: 6 }),
-        fc.array(fc.nat({ max: 255 })),
-        fc.bigInt({
-          min: 0n,
-          max: 124_999_999_999n,
-        }),
-        fc.nat(),
-        fc.integer({ min: 1, max: 12 }),
-        (
-          caller,
-          version,
-          hashbytes,
-          amount_ustx,
-          first_rew_cycle,
-          num_cycles
-        ) => {
-          // Arrange
-          const { result: pox_4_info } = simnet.callReadOnlyFn(
-            POX_4,
-            GET_POX_INFO,
-            [],
-            caller
-          );
-          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
-          const expectedResponseErr = ERR_STACKING_THRESHOLD_NOT_MET;
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "can-stack-stx",
-            [
-              Cl.tuple({
-                version: bufferCV(Uint8Array.from([version])),
-                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
-              }),
-              Cl.uint(amount_ustx),
-              Cl.uint(first_rew_cycle),
-              Cl.uint(num_cycles),
-            ],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.ResponseErr));
-          assert(isClarityType(actual.value, ClarityType.Int));
-          expect(actual).toBeErr(Cl.int(expectedResponseErr));
-        }
-      )
-    );
-  });
-
-  it("should return (err 2) can-stack-stx for lock period > 12", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.integer({ min: 0, max: 6 }),
-        fc.array(fc.nat({ max: 255 })),
-        fc.bigInt({
-          min: 125_000_000_000n,
-          max: 340282366920938463463374607431768211455n,
-        }),
-        fc.nat(),
-        fc.integer({ min: 13 }),
-        (
-          caller,
-          version,
-          hashbytes,
-          amount_ustx,
-          first_rew_cycle,
-          num_cycles
-        ) => {
-          // Arrange
-          const { result: pox_4_info } = simnet.callReadOnlyFn(
-            POX_4,
-            GET_POX_INFO,
-            [],
-            caller
-          );
-          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
-          const expectedResponseErr = ERR_STACKING_INVALID_LOCK_PERIOD;
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "can-stack-stx",
-            [
-              Cl.tuple({
-                version: bufferCV(Uint8Array.from([version])),
-                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
-              }),
-              Cl.uint(amount_ustx),
-              Cl.uint(first_rew_cycle),
-              Cl.uint(num_cycles),
-            ],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.ResponseErr));
-          assert(isClarityType(actual.value, ClarityType.Int));
-          expect(actual).toBeErr(Cl.int(expectedResponseErr));
-        }
-      )
-    );
-  });
-
-  // minimal can stack stx
-  it("should return (ok true) minimal-can-stack-stx for versions 0-4 valid pox addresses, hashbytes, amount, cycles number", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.integer({ min: 0, max: 4 }),
-        fc.array(fc.nat({ max: 255 }), {
-          minLength: 20,
-          maxLength: 20,
-        }),
-        fc.bigInt({
-          min: 125_000_000_000n,
-          max: 340282366920938463463374607431768211455n,
-        }),
-        fc.nat(),
-        fc.integer({ min: 1, max: 12 }),
-        (
-          caller,
-          version,
-          hashbytes,
-          amount_ustx,
-          first_rew_cycle,
-          num_cycles
-        ) => {
-          // Arrange
-          const { result: pox_4_info } = simnet.callReadOnlyFn(
-            POX_4,
-            GET_POX_INFO,
-            [],
-            caller
-          );
-          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
-          const expectedResponseOk = true;
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "minimal-can-stack-stx",
-            [
-              Cl.tuple({
-                version: bufferCV(Uint8Array.from([version])),
-                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
-              }),
-              Cl.uint(amount_ustx),
-              Cl.uint(first_rew_cycle),
-              Cl.uint(num_cycles),
-            ],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.ResponseOk));
-          assert(isClarityType(actual.value, ClarityType.BoolTrue));
-          expect(actual).toBeOk(Cl.bool(expectedResponseOk));
-        }
-      )
-    );
-  });
-
-  it("should return (ok true) minimal-can-stack-stx for versions 5/6 valid pox addresses, hashbytes, amount, cycles number", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.integer({ min: 5, max: 6 }),
-        fc.array(fc.nat({ max: 255 }), {
-          minLength: 32,
-          maxLength: 32,
-        }),
-        fc.bigInt({
-          min: 125_000_000_000n,
-          max: 340282366920938463463374607431768211455n,
-        }),
-        fc.nat(),
-        fc.integer({ min: 1, max: 12 }),
-        (
-          caller,
-          version,
-          hashbytes,
-          amount_ustx,
-          first_rew_cycle,
-          num_cycles
-        ) => {
-          // Arrange
-
-          const { result: pox_4_info } = simnet.callReadOnlyFn(
-            POX_4,
-            GET_POX_INFO,
-            [],
-            caller
-          );
-          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
-          const expectedResponseOk = true;
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "minimal-can-stack-stx",
-            [
-              Cl.tuple({
-                version: bufferCV(Uint8Array.from([version])),
-                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
-              }),
-              Cl.uint(amount_ustx),
-              Cl.uint(first_rew_cycle),
-              Cl.uint(num_cycles),
-            ],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.ResponseOk));
-          assert(isClarityType(actual.value, ClarityType.BoolTrue));
-          expect(actual).toBeOk(Cl.bool(expectedResponseOk));
-        }
-      )
-    );
-  });
-
-  it("should return (err 13) minimal-can-stack-stx for pox addresses having version > 6", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.integer({
-          min: 7,
-          max: 255,
-        }),
-        fc.array(fc.nat({ max: 255 }), {
-          minLength: 32,
-          maxLength: 32,
-        }),
-        fc.bigInt({
-          min: 125_000_000_000n,
-          max: 340282366920938463463374607431768211455n,
-        }),
-        fc.nat(),
-        fc.integer({ min: 1, max: 12 }),
-        (
-          caller,
-          version,
-          hashbytes,
-          amount_ustx,
-          first_rew_cycle,
-          num_cycles
-        ) => {
-          // Arrange
-          const { result: pox_4_info } = simnet.callReadOnlyFn(
-            POX_4,
-            GET_POX_INFO,
-            [],
-            caller
-          );
-          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
-          const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "minimal-can-stack-stx",
-            [
-              Cl.tuple({
-                version: bufferCV(Uint8Array.from([version])),
-                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
-              }),
-              Cl.uint(amount_ustx),
-              Cl.uint(first_rew_cycle),
-              Cl.uint(num_cycles),
-            ],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.ResponseErr));
-          assert(isClarityType(actual.value, ClarityType.Int));
-          expect(actual).toBeErr(Cl.int(expectedResponseErr));
-        }
-      )
-    );
-  });
-
-  it("should return (err 13) minimal-can-stack-stx for versions 0-4 pox addresses having hasbytes longer than 20", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.integer({ min: 0, max: 4 }),
-        fc.array(fc.nat({ max: 255 }), {
-          minLength: 21,
-          maxLength: 32,
-        }),
-        fc.bigInt({
-          min: 125_000_000_000n,
-          max: 340282366920938463463374607431768211455n,
-        }),
-        fc.nat(),
-        fc.integer({ min: 1, max: 12 }),
-        (
-          caller,
-          version,
-          hashbytes,
-          amount_ustx,
-          first_rew_cycle,
-          num_cycles
-        ) => {
-          // Arrange
-          const { result: pox_4_info } = simnet.callReadOnlyFn(
-            POX_4,
-            GET_POX_INFO,
-            [],
-            caller
-          );
-          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
-          const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "minimal-can-stack-stx",
-            [
-              Cl.tuple({
-                version: bufferCV(Uint8Array.from([version])),
-                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
-              }),
-              Cl.uint(amount_ustx),
-              Cl.uint(first_rew_cycle),
-              Cl.uint(num_cycles),
-            ],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.ResponseErr));
-          assert(isClarityType(actual.value, ClarityType.Int));
-          expect(actual).toBeErr(Cl.int(expectedResponseErr));
-        }
-      )
-    );
-  });
-
-  it("should return (err 13) minimal-can-stack-stx for versions 0-4 pox addresses having hasbytes shorter than 20", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.integer({ min: 0, max: 4 }),
-        fc.array(fc.nat({ max: 255 }), {
-          maxLength: 19,
-        }),
-        fc.bigInt({
-          min: 125_000_000_000n,
-          max: 340282366920938463463374607431768211455n,
-        }),
-        fc.nat(),
-        fc.integer({ min: 1, max: 12 }),
-        (
-          caller,
-          version,
-          hashbytes,
-          amount_ustx,
-          first_rew_cycle,
-          num_cycles
-        ) => {
-          // Arrange
-          const { result: pox_4_info } = simnet.callReadOnlyFn(
-            POX_4,
-            GET_POX_INFO,
-            [],
-            caller
-          );
-          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
-          const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "minimal-can-stack-stx",
-            [
-              Cl.tuple({
-                version: bufferCV(Uint8Array.from([version])),
-                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
-              }),
-              Cl.uint(amount_ustx),
-              Cl.uint(first_rew_cycle),
-              Cl.uint(num_cycles),
-            ],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.ResponseErr));
-          assert(isClarityType(actual.value, ClarityType.Int));
-          expect(actual).toBeErr(Cl.int(expectedResponseErr));
-        }
-      )
-    );
-  });
-
-  it("should return (err 13) minimal-can-stack-stx for versions 5/6 pox addresses having hashbytes shorter than 32", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.integer({ min: 0, max: 4 }),
-        fc.array(fc.nat({ max: 255 }), {
-          maxLength: 31,
-        }),
-        fc.bigInt({
-          min: 125_000_000_000n,
-          max: 340282366920938463463374607431768211455n,
-        }),
-        fc.nat(),
-        fc.integer({ min: 1, max: 12 }),
-        (
-          caller,
-          version,
-          hashbytes,
-          amount_ustx,
-          first_rew_cycle,
-          num_cycles
-        ) => {
-          // Arrange
-          const { result: pox_4_info } = simnet.callReadOnlyFn(
-            POX_4,
-            GET_POX_INFO,
-            [],
-            caller
-          );
-          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
-          const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "minimal-can-stack-stx",
-            [
-              Cl.tuple({
-                version: bufferCV(Uint8Array.from([version])),
-                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
-              }),
-              Cl.uint(amount_ustx),
-              Cl.uint(first_rew_cycle),
-              Cl.uint(num_cycles),
-            ],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.ResponseErr));
-          assert(isClarityType(actual.value, ClarityType.Int));
-          expect(actual).toBeErr(Cl.int(expectedResponseErr));
-        }
-      )
-    );
-  });
-
-  it("should return (err 2) minimal-can-stack-stx for lock period > 12", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.integer({ min: 0, max: 6 }),
-        fc.array(fc.nat({ max: 255 })),
-        fc.bigInt({
-          min: 125_000_000_000n,
-          max: 340282366920938463463374607431768211455n,
-        }),
-        fc.nat(),
-        fc.integer({ min: 13 }),
-        (
-          caller,
-          version,
-          hashbytes,
-          amount_ustx,
-          first_rew_cycle,
-          num_cycles
-        ) => {
-          // Arrange
-          const { result: pox_4_info } = simnet.callReadOnlyFn(
-            POX_4,
-            GET_POX_INFO,
-            [],
-            caller
-          );
-          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
-          const expectedResponseErr = ERR_STACKING_INVALID_LOCK_PERIOD;
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "minimal-can-stack-stx",
-            [
-              Cl.tuple({
-                version: bufferCV(Uint8Array.from([version])),
-                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
-              }),
-              Cl.uint(amount_ustx),
-              Cl.uint(first_rew_cycle),
-              Cl.uint(num_cycles),
-            ],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.ResponseErr));
-          assert(isClarityType(actual.value, ClarityType.Int));
-          expect(actual).toBeErr(Cl.int(expectedResponseErr));
-        }
-      )
-    );
-  });
-
-  it("should return (err 18) minimal-can-stack-stx for amount == 0", () => {
-    fc.assert(
-      fc.property(
-        fc.constantFrom(...simnet.getAccounts().values()),
-        fc.integer(),
-        fc.array(fc.nat({ max: 255 })),
-        fc.nat(),
-        fc.integer({ min: 1, max: 12 }),
-        (caller, version, hashbytes, first_rew_cycle, num_cycles) => {
-          // Arrange
-          const amount_ustx = 0;
-
-          const { result: pox_4_info } = simnet.callReadOnlyFn(
-            POX_4,
-            GET_POX_INFO,
-            [],
-            caller
-          );
-          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
-          const expectedResponseErr = ERR_STACKING_INVALID_AMOUNT;
-
-          // Act
-          const { result: actual } = simnet.callReadOnlyFn(
-            POX_4,
-            "minimal-can-stack-stx",
-            [
-              Cl.tuple({
-                version: bufferCV(Uint8Array.from([version])),
-                hashbytes: bufferCV(Uint8Array.from(hashbytes)),
-              }),
-              Cl.uint(amount_ustx),
-              Cl.uint(first_rew_cycle),
-              Cl.uint(num_cycles),
-            ],
-            caller
-          );
-
-          // Assert
-          assert(isClarityType(actual, ClarityType.ResponseErr));
-          assert(isClarityType(actual.value, ClarityType.Int));
-          expect(actual).toBeErr(Cl.int(expectedResponseErr));
-        }
-      )
-    );
+describe("test pox-4 contract", () => {
+  describe("test pox-4 contract read only functions", () => {
+    it("should return correct reward-cycle-to-burn-height", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.nat(),
+          (account, reward_cycle) => {
+            // Arrange
+            const { result: pox_4_info } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_POX_INFO,
+              [],
+              account
+            );
+            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+            const first_burn_block_height =
+              pox_4_info.value.data["first-burnchain-block-height"];
+            const reward_cycle_length =
+              pox_4_info.value.data["reward-cycle-length"];
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              REWARD_CYCLE_TO_BURN_HEIGHT,
+              [Cl.uint(reward_cycle)],
+              account
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.UInt));
+            assert(isClarityType(first_burn_block_height, ClarityType.UInt));
+            assert(isClarityType(reward_cycle_length, ClarityType.UInt));
+
+            const expected =
+              Number(first_burn_block_height.value) +
+              Number(reward_cycle_length.value) * reward_cycle;
+            expect(actual).toBeUint(expected);
+          }
+        )
+      );
+    });
+
+    it("should return correct burn-height-to-reward-cycle", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.nat(),
+          (account, burn_height) => {
+            // Arrange
+            const { result: pox_4_info } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_POX_INFO,
+              [],
+              account
+            );
+            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+            const first_burn_block_height =
+              pox_4_info.value.data["first-burnchain-block-height"];
+            const reward_cycle_length =
+              pox_4_info.value.data["reward-cycle-length"];
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              BURN_HEIGHT_TO_REWARD_CYCLE,
+              [Cl.uint(burn_height)],
+              account
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.UInt));
+            assert(isClarityType(first_burn_block_height, ClarityType.UInt));
+            assert(isClarityType(reward_cycle_length, ClarityType.UInt));
+            const expected = Math.floor(
+              (burn_height - Number(first_burn_block_height.value)) /
+                Number(reward_cycle_length.value)
+            );
+            expect(actual).toBeUint(expected);
+          }
+        )
+      );
+    });
+
+    it("should return u0 current-pox-reward-cycle", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          (caller) => {
+            // Arrange
+            let expected = 0;
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              CURRENT_POX_REWARD_CYCLE,
+              [],
+              caller
+            );
+            // Assert
+            assert(isClarityType(actual, ClarityType.UInt));
+            expect(actual).toBeUint(expected);
+          }
+        )
+      );
+    });
+
+    it("should return none get-stacker-info", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.constantFrom(...simnet.getAccounts().values()),
+          (stacker, caller) => {
+            // Arrange
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_STACKER_INFO,
+              [Cl.principal(stacker)],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.OptionalNone));
+            expect(actual).toBeNone();
+          }
+        )
+      );
+    });
+
+    it("should return true check-caller-allowed", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          (caller) => {
+            // Arrange
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              CHECK_CALLER_ALLOWED,
+              [],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.BoolTrue));
+            expect(actual).toBeBool(true);
+          }
+        )
+      );
+    });
+
+    it("should return u0 get-reward-set-size", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.nat(),
+          (caller, reward_cycle) => {
+            // Arrange
+            const expected = 0;
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_REWARD_SET_SIZE,
+              [Cl.uint(reward_cycle)],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.UInt));
+            expect(actual).toBeUint(expected);
+          }
+        )
+      );
+    });
+
+    it("should return u0 get-total-ustx-stacked", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.nat(),
+          (caller, reward_cycle) => {
+            // Arrange
+            const expected = 0;
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_TOTAL_USTX_STACKED,
+              [Cl.uint(reward_cycle)],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.UInt));
+            expect(actual).toBeUint(expected);
+          }
+        )
+      );
+    });
+
+    it("should return none get-reward-set-pox-address", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.nat(),
+          fc.nat(),
+          (caller, index, reward_cycle) => {
+            // Arrange
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_REWARD_SET_POX_ADDRESS,
+              [Cl.uint(index), Cl.uint(reward_cycle)],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.OptionalNone));
+            expect(actual).toBeNone();
+          }
+        )
+      );
+    });
+
+    it("should return correct get-stacking-minimum", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          (caller) => {
+            // Arrange
+
+            const { result: pox_4_info } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_POX_INFO,
+              [],
+              caller
+            );
+            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+            const stx_liq_supply =
+              pox_4_info.value.data["total-liquid-supply-ustx"];
+
+            assert(isClarityType(stx_liq_supply, ClarityType.UInt));
+            const expected = Math.floor(
+              Number(stx_liq_supply.value) / TESTNET_STACKING_THRESHOLD_25
+            );
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_STACKING_MINIMUM,
+              [],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.UInt));
+            expect(actual).toBeUint(expected);
+          }
+        )
+      );
+    });
+
+    it("should return true check-pox-addr-version for version <= 6 ", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.nat({ max: 6 }),
+          (caller, version) => {
+            // Arrange
+            const expected = true;
+
+            // Act
+            let { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              CHECK_POX_ADDR_VERSION,
+              [Cl.buffer(Uint8Array.from([version]))],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.BoolTrue));
+            expect(actual).toBeBool(expected);
+          }
+        )
+      );
+    });
+
+    it("should return false check-pox-addr-version for version > 6", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.integer({ min: 7, max: 255 }),
+          (caller, version) => {
+            // Arrange
+            const expected = false;
+
+            // Act
+            let { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              CHECK_POX_ADDR_VERSION,
+              [Cl.buffer(Uint8Array.from([version]))],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.BoolFalse));
+            expect(actual).toBeBool(expected);
+          }
+        )
+      );
+    });
+
+    it("should return true check-pox-lock-period for valid reward cycles number", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.integer({ min: 1, max: 12 }),
+          (caller, reward_cycles) => {
+            // Arrange
+            const expected = true;
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              CHECK_POX_LOCK_PERIOD,
+              [Cl.uint(reward_cycles)],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.BoolTrue));
+            expect(actual).toBeBool(expected);
+          }
+        )
+      );
+    });
+
+    it("should return false check-pox-lock-period for reward cycles number > 12", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.integer({ min: 13 }),
+          (caller, reward_cycles) => {
+            // Arrange
+            const expected = false;
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              CHECK_POX_LOCK_PERIOD,
+              [Cl.uint(reward_cycles)],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.BoolFalse));
+            expect(actual).toBeBool(expected);
+          }
+        )
+      );
+    });
+
+    it("should return false check-pox-lock-period for reward cycles number == 0", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          (caller) => {
+            // Arrange
+            const reward_cycles = 0;
+            const expected = false;
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              CHECK_POX_LOCK_PERIOD,
+              [Cl.uint(reward_cycles)],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.BoolFalse));
+            expect(actual).toBeBool(expected);
+          }
+        )
+      );
+    });
+
+    it("should return (ok true) can-stack-stx for versions 0-4 valid pox addresses, hashbytes, amount, cycles number", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.integer({ min: 0, max: 4 }),
+          fc.array(fc.nat({ max: 255 }), {
+            minLength: 20,
+            maxLength: 20,
+          }),
+          fc.bigInt({
+            min: MIN_AMOUNT_USTX,
+            max: MAX_CLAR_UINT,
+          }),
+          fc.nat(),
+          fc.integer({ min: 1, max: 12 }),
+          (
+            caller,
+            version,
+            hashbytes,
+            amount_ustx,
+            first_rew_cycle,
+            num_cycles
+          ) => {
+            // Arrange
+            const { result: pox_4_info } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_POX_INFO,
+              [],
+              caller
+            );
+            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+            const expectedResponseOk = true;
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              CAN_STACK_STX,
+              [
+                Cl.tuple({
+                  version: Cl.buffer(Uint8Array.from([version])),
+                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+                }),
+                Cl.uint(amount_ustx),
+                Cl.uint(first_rew_cycle),
+                Cl.uint(num_cycles),
+              ],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.ResponseOk));
+            assert(isClarityType(actual.value, ClarityType.BoolTrue));
+            expect(actual).toBeOk(Cl.bool(expectedResponseOk));
+          }
+        )
+      );
+    });
+
+    it("should return (ok true) can-stack-stx for versions 5/6 valid pox addresses, hashbytes, amount, cycles number", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.integer({ min: 5, max: 6 }),
+          fc.array(fc.nat({ max: 255 }), {
+            minLength: 32,
+            maxLength: 32,
+          }),
+          fc.bigInt({
+            min: MIN_AMOUNT_USTX,
+            max: MAX_CLAR_UINT,
+          }),
+          fc.nat(),
+          fc.integer({ min: 1, max: 12 }),
+          (
+            caller,
+            version,
+            hashbytes,
+            amount_ustx,
+            first_rew_cycle,
+            num_cycles
+          ) => {
+            // Arrange
+
+            const { result: pox_4_info } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_POX_INFO,
+              [],
+              caller
+            );
+            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+            const expectedResponseOk = true;
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              CAN_STACK_STX,
+              [
+                Cl.tuple({
+                  version: Cl.buffer(Uint8Array.from([version])),
+                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+                }),
+                Cl.uint(amount_ustx),
+                Cl.uint(first_rew_cycle),
+                Cl.uint(num_cycles),
+              ],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.ResponseOk));
+            assert(isClarityType(actual.value, ClarityType.BoolTrue));
+            expect(actual).toBeOk(Cl.bool(expectedResponseOk));
+          }
+        )
+      );
+    });
+
+    it("should return (err 13) can-stack-stx for pox addresses having version > 6", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.integer({
+            min: 7,
+            max: 255,
+          }),
+          fc.array(fc.nat({ max: 255 }), {
+            minLength: 32,
+            maxLength: 32,
+          }),
+          fc.bigInt({
+            min: MIN_AMOUNT_USTX,
+            max: MAX_CLAR_UINT,
+          }),
+          fc.nat(),
+          fc.integer({ min: 1, max: 12 }),
+          (
+            caller,
+            version,
+            hashbytes,
+            amount_ustx,
+            first_rew_cycle,
+            num_cycles
+          ) => {
+            // Arrange
+            const { result: pox_4_info } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_POX_INFO,
+              [],
+              caller
+            );
+            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+            const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              CAN_STACK_STX,
+              [
+                Cl.tuple({
+                  version: Cl.buffer(Uint8Array.from([version])),
+                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+                }),
+                Cl.uint(amount_ustx),
+                Cl.uint(first_rew_cycle),
+                Cl.uint(num_cycles),
+              ],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.ResponseErr));
+            assert(isClarityType(actual.value, ClarityType.Int));
+            expect(actual).toBeErr(Cl.int(expectedResponseErr));
+          }
+        )
+      );
+    });
+
+    it("should return (err 13) can-stack-stx for versions 0-4 pox addresses having hasbytes longer than 20", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.integer({ min: 0, max: 4 }),
+          fc.array(fc.nat({ max: 255 }), {
+            minLength: 21,
+            maxLength: 32,
+          }),
+          fc.bigInt({
+            min: MIN_AMOUNT_USTX,
+            max: MAX_CLAR_UINT,
+          }),
+          fc.nat(),
+          fc.integer({ min: 1, max: 12 }),
+          (
+            caller,
+            version,
+            hashbytes,
+            amount_ustx,
+            first_rew_cycle,
+            num_cycles
+          ) => {
+            // Arrange
+            const { result: pox_4_info } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_POX_INFO,
+              [],
+              caller
+            );
+            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+            const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              CAN_STACK_STX,
+              [
+                Cl.tuple({
+                  version: Cl.buffer(Uint8Array.from([version])),
+                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+                }),
+                Cl.uint(amount_ustx),
+                Cl.uint(first_rew_cycle),
+                Cl.uint(num_cycles),
+              ],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.ResponseErr));
+            assert(isClarityType(actual.value, ClarityType.Int));
+            expect(actual).toBeErr(Cl.int(expectedResponseErr));
+          }
+        )
+      );
+    });
+
+    it("should return (err 13) can-stack-stx for versions 0-4 pox addresses having hasbytes shorter than 20", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.integer({ min: 0, max: 4 }),
+          fc.array(fc.nat({ max: 255 }), {
+            maxLength: 19,
+          }),
+          fc.bigInt({
+            min: MIN_AMOUNT_USTX,
+            max: MAX_CLAR_UINT,
+          }),
+          fc.nat(),
+          fc.integer({ min: 1, max: 12 }),
+          (
+            caller,
+            version,
+            hashbytes,
+            amount_ustx,
+            first_rew_cycle,
+            num_cycles
+          ) => {
+            // Arrange
+            const { result: pox_4_info } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_POX_INFO,
+              [],
+              caller
+            );
+            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+            const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              CAN_STACK_STX,
+              [
+                Cl.tuple({
+                  version: Cl.buffer(Uint8Array.from([version])),
+                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+                }),
+                Cl.uint(amount_ustx),
+                Cl.uint(first_rew_cycle),
+                Cl.uint(num_cycles),
+              ],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.ResponseErr));
+            assert(isClarityType(actual.value, ClarityType.Int));
+            expect(actual).toBeErr(Cl.int(expectedResponseErr));
+          }
+        )
+      );
+    });
+
+    it("should return (err 13) can-stack-stx for versions 5/6 pox addresses having hashbytes shorter than 32", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.integer({ min: 0, max: 4 }),
+          fc.array(fc.nat({ max: 255 }), {
+            maxLength: 31,
+          }),
+          fc.bigInt({
+            min: MIN_AMOUNT_USTX,
+            max: MAX_CLAR_UINT,
+          }),
+          fc.nat(),
+          fc.integer({ min: 1, max: 12 }),
+          (
+            caller,
+            version,
+            hashbytes,
+            amount_ustx,
+            first_rew_cycle,
+            num_cycles
+          ) => {
+            // Arrange
+            const { result: pox_4_info } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_POX_INFO,
+              [],
+              caller
+            );
+            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+            const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              CAN_STACK_STX,
+              [
+                Cl.tuple({
+                  version: Cl.buffer(Uint8Array.from([version])),
+                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+                }),
+                Cl.uint(amount_ustx),
+                Cl.uint(first_rew_cycle),
+                Cl.uint(num_cycles),
+              ],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.ResponseErr));
+            assert(isClarityType(actual.value, ClarityType.Int));
+            expect(actual).toBeErr(Cl.int(expectedResponseErr));
+          }
+        )
+      );
+    });
+
+    it("should return (err 11) can-stack-stx for unmet stacking threshold", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.integer({ min: 0, max: 6 }),
+          fc.array(fc.nat({ max: 255 })),
+          fc.bigInt({
+            min: 0n,
+            max: 124_999_999_999n,
+          }),
+          fc.nat(),
+          fc.integer({ min: 1, max: 12 }),
+          (
+            caller,
+            version,
+            hashbytes,
+            amount_ustx,
+            first_rew_cycle,
+            num_cycles
+          ) => {
+            // Arrange
+            const { result: pox_4_info } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_POX_INFO,
+              [],
+              caller
+            );
+            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+            const expectedResponseErr = ERR_STACKING_THRESHOLD_NOT_MET;
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              CAN_STACK_STX,
+              [
+                Cl.tuple({
+                  version: Cl.buffer(Uint8Array.from([version])),
+                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+                }),
+                Cl.uint(amount_ustx),
+                Cl.uint(first_rew_cycle),
+                Cl.uint(num_cycles),
+              ],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.ResponseErr));
+            assert(isClarityType(actual.value, ClarityType.Int));
+            expect(actual).toBeErr(Cl.int(expectedResponseErr));
+          }
+        )
+      );
+    });
+
+    it("should return (err 2) can-stack-stx for lock period > 12", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.integer({ min: 0, max: 6 }),
+          fc.array(fc.nat({ max: 255 })),
+          fc.bigInt({
+            min: MIN_AMOUNT_USTX,
+            max: MAX_CLAR_UINT,
+          }),
+          fc.nat(),
+          fc.integer({ min: 13 }),
+          (
+            caller,
+            version,
+            hashbytes,
+            amount_ustx,
+            first_rew_cycle,
+            num_cycles
+          ) => {
+            // Arrange
+            const { result: pox_4_info } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_POX_INFO,
+              [],
+              caller
+            );
+            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+            const expectedResponseErr = ERR_STACKING_INVALID_LOCK_PERIOD;
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              CAN_STACK_STX,
+              [
+                Cl.tuple({
+                  version: Cl.buffer(Uint8Array.from([version])),
+                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+                }),
+                Cl.uint(amount_ustx),
+                Cl.uint(first_rew_cycle),
+                Cl.uint(num_cycles),
+              ],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.ResponseErr));
+            assert(isClarityType(actual.value, ClarityType.Int));
+            expect(actual).toBeErr(Cl.int(expectedResponseErr));
+          }
+        )
+      );
+    });
+
+    // minimal can stack stx
+    it("should return (ok true) minimal-can-stack-stx for versions 0-4 valid pox addresses, hashbytes, amount, cycles number", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.integer({ min: 0, max: 4 }),
+          fc.array(fc.nat({ max: 255 }), {
+            minLength: 20,
+            maxLength: 20,
+          }),
+          fc.bigInt({
+            min: MIN_AMOUNT_USTX,
+            max: MAX_CLAR_UINT,
+          }),
+          fc.nat(),
+          fc.integer({ min: 1, max: 12 }),
+          (
+            caller,
+            version,
+            hashbytes,
+            amount_ustx,
+            first_rew_cycle,
+            num_cycles
+          ) => {
+            // Arrange
+            const { result: pox_4_info } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_POX_INFO,
+              [],
+              caller
+            );
+            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+            const expectedResponseOk = true;
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              MINIMAL_CAN_STACK_STX,
+              [
+                Cl.tuple({
+                  version: Cl.buffer(Uint8Array.from([version])),
+                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+                }),
+                Cl.uint(amount_ustx),
+                Cl.uint(first_rew_cycle),
+                Cl.uint(num_cycles),
+              ],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.ResponseOk));
+            assert(isClarityType(actual.value, ClarityType.BoolTrue));
+            expect(actual).toBeOk(Cl.bool(expectedResponseOk));
+          }
+        )
+      );
+    });
+
+    it("should return (ok true) minimal-can-stack-stx for versions 5/6 valid pox addresses, hashbytes, amount, cycles number", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.integer({ min: 5, max: 6 }),
+          fc.array(fc.nat({ max: 255 }), {
+            minLength: 32,
+            maxLength: 32,
+          }),
+          fc.bigInt({
+            min: MIN_AMOUNT_USTX,
+            max: MAX_CLAR_UINT,
+          }),
+          fc.nat(),
+          fc.integer({ min: 1, max: 12 }),
+          (
+            caller,
+            version,
+            hashbytes,
+            amount_ustx,
+            first_rew_cycle,
+            num_cycles
+          ) => {
+            // Arrange
+
+            const { result: pox_4_info } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_POX_INFO,
+              [],
+              caller
+            );
+            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+            const expectedResponseOk = true;
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              MINIMAL_CAN_STACK_STX,
+              [
+                Cl.tuple({
+                  version: Cl.buffer(Uint8Array.from([version])),
+                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+                }),
+                Cl.uint(amount_ustx),
+                Cl.uint(first_rew_cycle),
+                Cl.uint(num_cycles),
+              ],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.ResponseOk));
+            assert(isClarityType(actual.value, ClarityType.BoolTrue));
+            expect(actual).toBeOk(Cl.bool(expectedResponseOk));
+          }
+        )
+      );
+    });
+
+    it("should return (err 13) minimal-can-stack-stx for pox addresses having version > 6", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.integer({
+            min: 7,
+            max: 255,
+          }),
+          fc.array(fc.nat({ max: 255 }), {
+            minLength: 32,
+            maxLength: 32,
+          }),
+          fc.bigInt({
+            min: MIN_AMOUNT_USTX,
+            max: MAX_CLAR_UINT,
+          }),
+          fc.nat(),
+          fc.integer({ min: 1, max: 12 }),
+          (
+            caller,
+            version,
+            hashbytes,
+            amount_ustx,
+            first_rew_cycle,
+            num_cycles
+          ) => {
+            // Arrange
+            const { result: pox_4_info } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_POX_INFO,
+              [],
+              caller
+            );
+            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+            const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              MINIMAL_CAN_STACK_STX,
+              [
+                Cl.tuple({
+                  version: Cl.buffer(Uint8Array.from([version])),
+                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+                }),
+                Cl.uint(amount_ustx),
+                Cl.uint(first_rew_cycle),
+                Cl.uint(num_cycles),
+              ],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.ResponseErr));
+            assert(isClarityType(actual.value, ClarityType.Int));
+            expect(actual).toBeErr(Cl.int(expectedResponseErr));
+          }
+        )
+      );
+    });
+
+    it("should return (err 13) minimal-can-stack-stx for versions 0-4 pox addresses having hasbytes longer than 20", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.integer({ min: 0, max: 4 }),
+          fc.array(fc.nat({ max: 255 }), {
+            minLength: 21,
+            maxLength: 32,
+          }),
+          fc.bigInt({
+            min: MIN_AMOUNT_USTX,
+            max: MAX_CLAR_UINT,
+          }),
+          fc.nat(),
+          fc.integer({ min: 1, max: 12 }),
+          (
+            caller,
+            version,
+            hashbytes,
+            amount_ustx,
+            first_rew_cycle,
+            num_cycles
+          ) => {
+            // Arrange
+            const { result: pox_4_info } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_POX_INFO,
+              [],
+              caller
+            );
+            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+            const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              MINIMAL_CAN_STACK_STX,
+              [
+                Cl.tuple({
+                  version: Cl.buffer(Uint8Array.from([version])),
+                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+                }),
+                Cl.uint(amount_ustx),
+                Cl.uint(first_rew_cycle),
+                Cl.uint(num_cycles),
+              ],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.ResponseErr));
+            assert(isClarityType(actual.value, ClarityType.Int));
+            expect(actual).toBeErr(Cl.int(expectedResponseErr));
+          }
+        )
+      );
+    });
+
+    it("should return (err 13) minimal-can-stack-stx for versions 0-4 pox addresses having hasbytes shorter than 20", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.integer({ min: 0, max: 4 }),
+          fc.array(fc.nat({ max: 255 }), {
+            maxLength: 19,
+          }),
+          fc.bigInt({
+            min: MIN_AMOUNT_USTX,
+            max: MAX_CLAR_UINT,
+          }),
+          fc.nat(),
+          fc.integer({ min: 1, max: 12 }),
+          (
+            caller,
+            version,
+            hashbytes,
+            amount_ustx,
+            first_rew_cycle,
+            num_cycles
+          ) => {
+            // Arrange
+            const { result: pox_4_info } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_POX_INFO,
+              [],
+              caller
+            );
+            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+            const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              MINIMAL_CAN_STACK_STX,
+              [
+                Cl.tuple({
+                  version: Cl.buffer(Uint8Array.from([version])),
+                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+                }),
+                Cl.uint(amount_ustx),
+                Cl.uint(first_rew_cycle),
+                Cl.uint(num_cycles),
+              ],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.ResponseErr));
+            assert(isClarityType(actual.value, ClarityType.Int));
+            expect(actual).toBeErr(Cl.int(expectedResponseErr));
+          }
+        )
+      );
+    });
+
+    it("should return (err 13) minimal-can-stack-stx for versions 5/6 pox addresses having hashbytes shorter than 32", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.integer({ min: 0, max: 4 }),
+          fc.array(fc.nat({ max: 255 }), {
+            maxLength: 31,
+          }),
+          fc.bigInt({
+            min: MIN_AMOUNT_USTX,
+            max: MAX_CLAR_UINT,
+          }),
+          fc.nat(),
+          fc.integer({ min: 1, max: 12 }),
+          (
+            caller,
+            version,
+            hashbytes,
+            amount_ustx,
+            first_rew_cycle,
+            num_cycles
+          ) => {
+            // Arrange
+            const { result: pox_4_info } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_POX_INFO,
+              [],
+              caller
+            );
+            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+            const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              MINIMAL_CAN_STACK_STX,
+              [
+                Cl.tuple({
+                  version: Cl.buffer(Uint8Array.from([version])),
+                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+                }),
+                Cl.uint(amount_ustx),
+                Cl.uint(first_rew_cycle),
+                Cl.uint(num_cycles),
+              ],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.ResponseErr));
+            assert(isClarityType(actual.value, ClarityType.Int));
+            expect(actual).toBeErr(Cl.int(expectedResponseErr));
+          }
+        )
+      );
+    });
+
+    it("should return (err 2) minimal-can-stack-stx for lock period > 12", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.integer({ min: 0, max: 6 }),
+          fc.array(fc.nat({ max: 255 })),
+          fc.bigInt({
+            min: MIN_AMOUNT_USTX,
+            max: MAX_CLAR_UINT,
+          }),
+          fc.nat(),
+          fc.integer({ min: 13 }),
+          (
+            caller,
+            version,
+            hashbytes,
+            amount_ustx,
+            first_rew_cycle,
+            num_cycles
+          ) => {
+            // Arrange
+            const { result: pox_4_info } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_POX_INFO,
+              [],
+              caller
+            );
+            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+            const expectedResponseErr = ERR_STACKING_INVALID_LOCK_PERIOD;
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              MINIMAL_CAN_STACK_STX,
+              [
+                Cl.tuple({
+                  version: Cl.buffer(Uint8Array.from([version])),
+                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+                }),
+                Cl.uint(amount_ustx),
+                Cl.uint(first_rew_cycle),
+                Cl.uint(num_cycles),
+              ],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.ResponseErr));
+            assert(isClarityType(actual.value, ClarityType.Int));
+            expect(actual).toBeErr(Cl.int(expectedResponseErr));
+          }
+        )
+      );
+    });
+
+    it("should return (err 18) minimal-can-stack-stx for amount == 0", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.integer({ min: 0, max: 6 }),
+          fc.array(fc.nat({ max: 255 }), { maxLength: 32 }),
+          fc.nat(),
+          fc.integer({ min: 1, max: 12 }),
+          (caller, version, hashbytes, first_rew_cycle, num_cycles) => {
+            // Arrange
+            const amount_ustx = 0;
+
+            const { result: pox_4_info } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_POX_INFO,
+              [],
+              caller
+            );
+            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+
+            const expectedResponseErr = ERR_STACKING_INVALID_AMOUNT;
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              MINIMAL_CAN_STACK_STX,
+              [
+                Cl.tuple({
+                  version: Cl.buffer(Uint8Array.from([version])),
+                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+                }),
+                Cl.uint(amount_ustx),
+                Cl.uint(first_rew_cycle),
+                Cl.uint(num_cycles),
+              ],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.ResponseErr));
+            assert(isClarityType(actual.value, ClarityType.Int));
+            expect(actual).toBeErr(Cl.int(expectedResponseErr));
+          }
+        )
+      );
+    });
+
+    it("should return none get-check-delegation", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          (caller) => {
+            // Arrange
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_CHECK_DELEGATION,
+              [Cl.principal(caller)],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.OptionalNone));
+          }
+        )
+      );
+    });
+
+    it("should return none get-delegation-info", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          (caller) => {
+            // Arrange
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_DELEGATION_INFO,
+              [Cl.principal(caller)],
+              caller
+            );
+
+            // Assert
+            assert(isClarityType(actual, ClarityType.OptionalNone));
+          }
+        )
+      );
+    });
+
+    it("should return correct get-pox-info", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          (caller) => {
+            // Arrange
+            const expected_reward_cycle_id = 0,
+              expected_first_burn_block_height = 0;
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_POX_INFO,
+              [],
+              caller
+            );
+            // Assert
+            assert(isClarityType(actual, ClarityType.ResponseOk));
+            assert(isClarityType(actual.value, ClarityType.Tuple));
+            expect(actual.value.data["first-burnchain-block-height"]).toBeUint(
+              expected_first_burn_block_height
+            );
+            expect(actual.value.data["min-amount-ustx"]).toBeUint(
+              MIN_AMOUNT_USTX
+            );
+            expect(actual.value.data["prepare-cycle-length"]).toBeUint(
+              TESTNET_PREPARE_CYCLE_LENGTH
+            );
+            expect(actual.value.data["reward-cycle-id"]).toBeUint(
+              expected_reward_cycle_id
+            );
+            expect(actual.value.data["reward-cycle-length"]).toBeUint(
+              TESTNET_REWARD_CYCLE_LENGTH
+            );
+            expect(actual.value.data["total-liquid-supply-ustx"]).toBeUint(
+              INITIAL_TOTAL_LIQ_SUPPLY
+            );
+          }
+        )
+      );
+    });
+
+    it("should return none get-allowance-contract-caller", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.constantFrom(...simnet.getAccounts().values()),
+          (caller, sender, contract_caller) => {
+            // Arrange
+
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_ALLOWANCE_CONTRACT_CALLERS,
+              [Cl.principal(sender), Cl.principal(contract_caller)],
+              caller
+            );
+            // Assert
+            assert(isClarityType(actual, ClarityType.OptionalNone));
+          }
+        )
+      );
+    });
+
+    it("should return some get-allowance-contract-caller after allow-contract-caller", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.constantFrom(...simnet.getAccounts().values()),
+          (caller, sender, contract_caller) => {
+            // Arrange
+            const { result: allow } = simnet.callPublicFn(
+              POX_4,
+              ALLOW_CONTRACT_CALLER,
+              [Cl.principal(contract_caller), Cl.none()],
+              sender
+            );
+
+            assert(isClarityType(allow, ClarityType.ResponseOk));
+            assert(isClarityType(allow.value, ClarityType.BoolTrue));
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_ALLOWANCE_CONTRACT_CALLERS,
+              [Cl.principal(sender), Cl.principal(contract_caller)],
+              caller
+            );
+            // Assert
+            assert(isClarityType(actual, ClarityType.OptionalSome));
+            assert(isClarityType(actual.value, ClarityType.Tuple));
+            expect(actual.value).toBeTuple({ "until-burn-ht": Cl.none() });
+          }
+        )
+      );
+    });
+
+    // get-signer-key-message-hash
+    // verify-signer-key-sig
+    // get-num-reward-set-pox-addresses
+    // get-partial-stacked-by-cycle
   });
 });

From e891474e9cbd76d61a0f3d9efe3755f1ee37bd8b Mon Sep 17 00:00:00 2001
From: BowTiedRadone <bowtiedradone@gmail.com>
Date: Wed, 6 Mar 2024 20:14:27 +0200
Subject: [PATCH 1089/1166] added tests for get-num-reward-set-pox-addresses,
 get-partial-stacked-by-cycle

---
 .../tests/pox-4/pox-4.prop.test.ts            | 60 ++++++++++++++++++-
 1 file changed, 57 insertions(+), 3 deletions(-)

diff --git a/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts b/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
index 506ebd2864..d16dd76f1a 100644
--- a/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
+++ b/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
@@ -22,6 +22,8 @@ const MINIMAL_CAN_STACK_STX = "minimal-can-stack-stx";
 const GET_CHECK_DELEGATION = "get-check-delegation";
 const GET_DELEGATION_INFO = "get-delegation-info";
 const GET_ALLOWANCE_CONTRACT_CALLERS = "get-allowance-contract-callers";
+const GET_NUM_REWARD_SET_POX_ADDRESSES = "get-num-reward-set-pox-addresses";
+const GET_PARTIAL_STACKED_BY_CYCLE = "get-partial-stacked-by-cycle";
 const ALLOW_CONTRACT_CALLER = "allow-contract-caller";
 // Contract Consts
 const TESTNET_STACKING_THRESHOLD_25 = 8000;
@@ -1486,7 +1488,7 @@ describe("test pox-4 contract", () => {
       );
     });
 
-    it("should return some get-allowance-contract-caller after allow-contract-caller", () => {
+    it("should return some(until-burn-ht: none) get-allowance-contract-caller after allow-contract-caller", () => {
       fc.assert(
         fc.property(
           fc.constantFrom(...simnet.getAccounts().values()),
@@ -1519,9 +1521,61 @@ describe("test pox-4 contract", () => {
       );
     });
 
+    it("should return u0 get-num-reward-set-pox-addresses", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.nat(),
+          (caller, reward_cycle) => {
+            // Arrange
+            const expected = 0;
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_NUM_REWARD_SET_POX_ADDRESSES,
+              [Cl.uint(reward_cycle)],
+              caller
+            );
+            // Assert
+            assert(isClarityType(actual, ClarityType.UInt));
+            expect(actual).toBeUint(expected);
+          }
+        )
+      );
+    });
+
+    it("should return none get-partial-stacked-by-cycle", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.nat({ max: 6 }),
+          fc.array(fc.nat({ max: 255 }), { maxLength: 32 }),
+          fc.nat(),
+          fc.constantFrom(...simnet.getAccounts().values()),
+          (caller, version, hashbytes, reward_cycle, sender) => {
+            // Arrange
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_PARTIAL_STACKED_BY_CYCLE,
+              [
+                Cl.tuple({
+                  version: Cl.buffer(Uint8Array.from([version])),
+                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+                }),
+                Cl.uint(reward_cycle),
+                Cl.principal(sender),
+              ],
+              caller
+            );
+            // Assert
+            assert(isClarityType(actual, ClarityType.OptionalNone));
+          }
+        )
+      );
+    });
+
     // get-signer-key-message-hash
     // verify-signer-key-sig
-    // get-num-reward-set-pox-addresses
-    // get-partial-stacked-by-cycle
   });
 });

From cd82f1c7cfcad42f5bf2506a2846a88d0e6339d8 Mon Sep 17 00:00:00 2001
From: BowTiedRadone <bowtiedradone@gmail.com>
Date: Thu, 7 Mar 2024 14:09:12 +0200
Subject: [PATCH 1090/1166] added test for get-signer-key-message-hash and
 utils file

---
 .../tests/pox-4/pox-4-utils/utils.ts          |  58 +++++++
 .../tests/pox-4/pox-4.prop.test.ts            | 164 +++++++-----------
 2 files changed, 116 insertions(+), 106 deletions(-)
 create mode 100644 contrib/core-contract-tests/tests/pox-4/pox-4-utils/utils.ts

diff --git a/contrib/core-contract-tests/tests/pox-4/pox-4-utils/utils.ts b/contrib/core-contract-tests/tests/pox-4/pox-4-utils/utils.ts
new file mode 100644
index 0000000000..81164c3338
--- /dev/null
+++ b/contrib/core-contract-tests/tests/pox-4/pox-4-utils/utils.ts
@@ -0,0 +1,58 @@
+import { Cl, ClarityValue, serializeCV } from "@stacks/transactions";
+import { createHash } from "crypto";
+
+function sha256(data: Buffer): Buffer {
+  return createHash("sha256").update(data).digest();
+}
+
+function structuredDataHash(structuredData: ClarityValue): Buffer {
+  return sha256(Buffer.from(serializeCV(structuredData)));
+}
+
+const generateDomainHash = () =>
+  Cl.tuple({
+    name: Cl.stringAscii("pox-4-signer"),
+    version: Cl.stringAscii("1.0.0"),
+    "chain-id": Cl.uint(2147483648),
+  });
+
+const generateMessageHash = (
+  version: number,
+  hashbytes: number[],
+  reward_cycle: number,
+  topic: string,
+  period: number
+) =>
+  Cl.tuple({
+    "pox-addr": Cl.tuple({
+      version: Cl.buffer(Uint8Array.from([version])),
+      hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+    }),
+    "reward-cycle": Cl.uint(reward_cycle),
+    topic: Cl.stringAscii(topic),
+    period: Cl.uint(period),
+  });
+
+const generateMessagePrefixBuffer = (prefix: string) =>
+  Buffer.from(prefix, "hex");
+
+export const buildSignerKeyMessageHash = (
+  version: number,
+  hashbytes: number[],
+  reward_cycle: number,
+  topic: string,
+  period: number
+) => {
+  const sip018_msg_prefix = "534950303138";
+  const domain_hash = structuredDataHash(generateDomainHash());
+  const message_hash = structuredDataHash(
+    generateMessageHash(version, hashbytes, reward_cycle, topic, period)
+  );
+  const structuredDataPrefix = generateMessagePrefixBuffer(sip018_msg_prefix);
+
+  const signer_key_message_hash = sha256(
+    Buffer.concat([structuredDataPrefix, domain_hash, message_hash])
+  );
+
+  return signer_key_message_hash;
+};
diff --git a/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts b/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
index d16dd76f1a..b54eaafa5c 100644
--- a/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
+++ b/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
@@ -1,36 +1,39 @@
 import { Cl, ClarityType, isClarityType } from "@stacks/transactions";
 import { assert, describe, expect, it } from "vitest";
 import fc from "fast-check";
+import { buildSignerKeyMessageHash } from "./pox-4-utils/utils";
 
 // Contracts
 const POX_4 = "pox-4";
 // Methods
-const GET_POX_INFO = "get-pox-info";
-const GET_STACKER_INFO = "get-stacker-info";
-const REWARD_CYCLE_TO_BURN_HEIGHT = "reward-cycle-to-burn-height";
+const ALLOW_CONTRACT_CALLER = "allow-contract-caller";
 const BURN_HEIGHT_TO_REWARD_CYCLE = "burn-height-to-reward-cycle";
-const CURRENT_POX_REWARD_CYCLE = "current-pox-reward-cycle";
+const CAN_STACK_STX = "can-stack-stx";
 const CHECK_CALLER_ALLOWED = "check-caller-allowed";
-const GET_REWARD_SET_SIZE = "get-reward-set-size";
-const GET_REWARD_SET_POX_ADDRESS = "get-reward-set-pox-address";
-const GET_TOTAL_USTX_STACKED = "get-total-ustx-stacked";
 const CHECK_POX_ADDR_VERSION = "check-pox-addr-version";
 const CHECK_POX_LOCK_PERIOD = "check-pox-lock-period";
-const GET_STACKING_MINIMUM = "get-stacking-minimum";
-const CAN_STACK_STX = "can-stack-stx";
-const MINIMAL_CAN_STACK_STX = "minimal-can-stack-stx";
+const CURRENT_POX_REWARD_CYCLE = "current-pox-reward-cycle";
+const GET_ALLOWANCE_CONTRACT_CALLERS = "get-allowance-contract-callers";
 const GET_CHECK_DELEGATION = "get-check-delegation";
 const GET_DELEGATION_INFO = "get-delegation-info";
-const GET_ALLOWANCE_CONTRACT_CALLERS = "get-allowance-contract-callers";
 const GET_NUM_REWARD_SET_POX_ADDRESSES = "get-num-reward-set-pox-addresses";
 const GET_PARTIAL_STACKED_BY_CYCLE = "get-partial-stacked-by-cycle";
-const ALLOW_CONTRACT_CALLER = "allow-contract-caller";
+const GET_POX_INFO = "get-pox-info";
+const GET_REWARD_SET_POX_ADDRESS = "get-reward-set-pox-address";
+const GET_REWARD_SET_SIZE = "get-reward-set-size";
+const GET_SIGNER_KEY_MESSAGE_HASH = "get-signer-key-message-hash";
+const GET_STACKER_INFO = "get-stacker-info";
+const GET_STACKING_MINIMUM = "get-stacking-minimum";
+const GET_TOTAL_USTX_STACKED = "get-total-ustx-stacked";
+const MINIMAL_CAN_STACK_STX = "minimal-can-stack-stx";
+const REWARD_CYCLE_TO_BURN_HEIGHT = "reward-cycle-to-burn-height";
+const VERIFY_SIGNER_KEY_SIG = "verify-signer-key-sig";
 // Contract Consts
-const TESTNET_STACKING_THRESHOLD_25 = 8000;
-const TESTNET_REWARD_CYCLE_LENGTH = 1050;
-const TESTNET_PREPARE_CYCLE_LENGTH = 50;
 const INITIAL_TOTAL_LIQ_SUPPLY = 1_000_000_000_000_000;
 const MIN_AMOUNT_USTX = 125_000_000_000n;
+const TESTNET_PREPARE_CYCLE_LENGTH = 50;
+const TESTNET_REWARD_CYCLE_LENGTH = 1050;
+const TESTNET_STACKING_THRESHOLD_25 = 8000;
 // Clarity Constraints
 const MAX_CLAR_UINT = 340282366920938463463374607431768211455n;
 // Error Codes
@@ -56,12 +59,10 @@ describe("test pox-4 contract", () => {
             );
             assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
             assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
             const first_burn_block_height =
               pox_4_info.value.data["first-burnchain-block-height"];
             const reward_cycle_length =
               pox_4_info.value.data["reward-cycle-length"];
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -69,12 +70,10 @@ describe("test pox-4 contract", () => {
               [Cl.uint(reward_cycle)],
               account
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.UInt));
             assert(isClarityType(first_burn_block_height, ClarityType.UInt));
             assert(isClarityType(reward_cycle_length, ClarityType.UInt));
-
             const expected =
               Number(first_burn_block_height.value) +
               Number(reward_cycle_length.value) * reward_cycle;
@@ -99,12 +98,10 @@ describe("test pox-4 contract", () => {
             );
             assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
             assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
             const first_burn_block_height =
               pox_4_info.value.data["first-burnchain-block-height"];
             const reward_cycle_length =
               pox_4_info.value.data["reward-cycle-length"];
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -112,7 +109,6 @@ describe("test pox-4 contract", () => {
               [Cl.uint(burn_height)],
               account
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.UInt));
             assert(isClarityType(first_burn_block_height, ClarityType.UInt));
@@ -156,7 +152,6 @@ describe("test pox-4 contract", () => {
           fc.constantFrom(...simnet.getAccounts().values()),
           (stacker, caller) => {
             // Arrange
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -164,7 +159,6 @@ describe("test pox-4 contract", () => {
               [Cl.principal(stacker)],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.OptionalNone));
             expect(actual).toBeNone();
@@ -179,7 +173,6 @@ describe("test pox-4 contract", () => {
           fc.constantFrom(...simnet.getAccounts().values()),
           (caller) => {
             // Arrange
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -187,7 +180,6 @@ describe("test pox-4 contract", () => {
               [],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.BoolTrue));
             expect(actual).toBeBool(true);
@@ -204,7 +196,6 @@ describe("test pox-4 contract", () => {
           (caller, reward_cycle) => {
             // Arrange
             const expected = 0;
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -212,7 +203,6 @@ describe("test pox-4 contract", () => {
               [Cl.uint(reward_cycle)],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.UInt));
             expect(actual).toBeUint(expected);
@@ -229,7 +219,6 @@ describe("test pox-4 contract", () => {
           (caller, reward_cycle) => {
             // Arrange
             const expected = 0;
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -237,7 +226,6 @@ describe("test pox-4 contract", () => {
               [Cl.uint(reward_cycle)],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.UInt));
             expect(actual).toBeUint(expected);
@@ -254,7 +242,6 @@ describe("test pox-4 contract", () => {
           fc.nat(),
           (caller, index, reward_cycle) => {
             // Arrange
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -262,7 +249,6 @@ describe("test pox-4 contract", () => {
               [Cl.uint(index), Cl.uint(reward_cycle)],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.OptionalNone));
             expect(actual).toBeNone();
@@ -277,7 +263,6 @@ describe("test pox-4 contract", () => {
           fc.constantFrom(...simnet.getAccounts().values()),
           (caller) => {
             // Arrange
-
             const { result: pox_4_info } = simnet.callReadOnlyFn(
               POX_4,
               GET_POX_INFO,
@@ -286,15 +271,12 @@ describe("test pox-4 contract", () => {
             );
             assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
             assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
             const stx_liq_supply =
               pox_4_info.value.data["total-liquid-supply-ustx"];
-
             assert(isClarityType(stx_liq_supply, ClarityType.UInt));
             const expected = Math.floor(
               Number(stx_liq_supply.value) / TESTNET_STACKING_THRESHOLD_25
             );
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -302,7 +284,6 @@ describe("test pox-4 contract", () => {
               [],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.UInt));
             expect(actual).toBeUint(expected);
@@ -319,7 +300,6 @@ describe("test pox-4 contract", () => {
           (caller, version) => {
             // Arrange
             const expected = true;
-
             // Act
             let { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -327,7 +307,6 @@ describe("test pox-4 contract", () => {
               [Cl.buffer(Uint8Array.from([version]))],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.BoolTrue));
             expect(actual).toBeBool(expected);
@@ -344,7 +323,6 @@ describe("test pox-4 contract", () => {
           (caller, version) => {
             // Arrange
             const expected = false;
-
             // Act
             let { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -352,7 +330,6 @@ describe("test pox-4 contract", () => {
               [Cl.buffer(Uint8Array.from([version]))],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.BoolFalse));
             expect(actual).toBeBool(expected);
@@ -369,7 +346,6 @@ describe("test pox-4 contract", () => {
           (caller, reward_cycles) => {
             // Arrange
             const expected = true;
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -377,7 +353,6 @@ describe("test pox-4 contract", () => {
               [Cl.uint(reward_cycles)],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.BoolTrue));
             expect(actual).toBeBool(expected);
@@ -394,7 +369,6 @@ describe("test pox-4 contract", () => {
           (caller, reward_cycles) => {
             // Arrange
             const expected = false;
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -402,7 +376,6 @@ describe("test pox-4 contract", () => {
               [Cl.uint(reward_cycles)],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.BoolFalse));
             expect(actual).toBeBool(expected);
@@ -419,7 +392,6 @@ describe("test pox-4 contract", () => {
             // Arrange
             const reward_cycles = 0;
             const expected = false;
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -427,7 +399,6 @@ describe("test pox-4 contract", () => {
               [Cl.uint(reward_cycles)],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.BoolFalse));
             expect(actual).toBeBool(expected);
@@ -468,9 +439,7 @@ describe("test pox-4 contract", () => {
             );
             assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
             assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
             const expectedResponseOk = true;
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -486,7 +455,6 @@ describe("test pox-4 contract", () => {
               ],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.ResponseOk));
             assert(isClarityType(actual.value, ClarityType.BoolTrue));
@@ -520,7 +488,6 @@ describe("test pox-4 contract", () => {
             num_cycles
           ) => {
             // Arrange
-
             const { result: pox_4_info } = simnet.callReadOnlyFn(
               POX_4,
               GET_POX_INFO,
@@ -529,9 +496,7 @@ describe("test pox-4 contract", () => {
             );
             assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
             assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
             const expectedResponseOk = true;
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -547,7 +512,6 @@ describe("test pox-4 contract", () => {
               ],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.ResponseOk));
             assert(isClarityType(actual.value, ClarityType.BoolTrue));
@@ -592,9 +556,7 @@ describe("test pox-4 contract", () => {
             );
             assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
             assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
             const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -610,7 +572,6 @@ describe("test pox-4 contract", () => {
               ],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.ResponseErr));
             assert(isClarityType(actual.value, ClarityType.Int));
@@ -652,9 +613,7 @@ describe("test pox-4 contract", () => {
             );
             assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
             assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
             const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -670,7 +629,6 @@ describe("test pox-4 contract", () => {
               ],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.ResponseErr));
             assert(isClarityType(actual.value, ClarityType.Int));
@@ -711,9 +669,7 @@ describe("test pox-4 contract", () => {
             );
             assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
             assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
             const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -729,7 +685,6 @@ describe("test pox-4 contract", () => {
               ],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.ResponseErr));
             assert(isClarityType(actual.value, ClarityType.Int));
@@ -770,9 +725,7 @@ describe("test pox-4 contract", () => {
             );
             assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
             assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
             const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -788,7 +741,6 @@ describe("test pox-4 contract", () => {
               ],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.ResponseErr));
             assert(isClarityType(actual.value, ClarityType.Int));
@@ -827,9 +779,7 @@ describe("test pox-4 contract", () => {
             );
             assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
             assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
             const expectedResponseErr = ERR_STACKING_THRESHOLD_NOT_MET;
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -845,7 +795,6 @@ describe("test pox-4 contract", () => {
               ],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.ResponseErr));
             assert(isClarityType(actual.value, ClarityType.Int));
@@ -884,9 +833,7 @@ describe("test pox-4 contract", () => {
             );
             assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
             assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
             const expectedResponseErr = ERR_STACKING_INVALID_LOCK_PERIOD;
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -902,7 +849,6 @@ describe("test pox-4 contract", () => {
               ],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.ResponseErr));
             assert(isClarityType(actual.value, ClarityType.Int));
@@ -912,7 +858,6 @@ describe("test pox-4 contract", () => {
       );
     });
 
-    // minimal can stack stx
     it("should return (ok true) minimal-can-stack-stx for versions 0-4 valid pox addresses, hashbytes, amount, cycles number", () => {
       fc.assert(
         fc.property(
@@ -945,9 +890,7 @@ describe("test pox-4 contract", () => {
             );
             assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
             assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
             const expectedResponseOk = true;
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -963,7 +906,6 @@ describe("test pox-4 contract", () => {
               ],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.ResponseOk));
             assert(isClarityType(actual.value, ClarityType.BoolTrue));
@@ -997,7 +939,6 @@ describe("test pox-4 contract", () => {
             num_cycles
           ) => {
             // Arrange
-
             const { result: pox_4_info } = simnet.callReadOnlyFn(
               POX_4,
               GET_POX_INFO,
@@ -1006,9 +947,7 @@ describe("test pox-4 contract", () => {
             );
             assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
             assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
             const expectedResponseOk = true;
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -1024,7 +963,6 @@ describe("test pox-4 contract", () => {
               ],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.ResponseOk));
             assert(isClarityType(actual.value, ClarityType.BoolTrue));
@@ -1069,9 +1007,7 @@ describe("test pox-4 contract", () => {
             );
             assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
             assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
             const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -1087,7 +1023,6 @@ describe("test pox-4 contract", () => {
               ],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.ResponseErr));
             assert(isClarityType(actual.value, ClarityType.Int));
@@ -1129,9 +1064,7 @@ describe("test pox-4 contract", () => {
             );
             assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
             assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
             const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -1147,7 +1080,6 @@ describe("test pox-4 contract", () => {
               ],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.ResponseErr));
             assert(isClarityType(actual.value, ClarityType.Int));
@@ -1188,9 +1120,7 @@ describe("test pox-4 contract", () => {
             );
             assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
             assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
             const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -1206,7 +1136,6 @@ describe("test pox-4 contract", () => {
               ],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.ResponseErr));
             assert(isClarityType(actual.value, ClarityType.Int));
@@ -1247,9 +1176,7 @@ describe("test pox-4 contract", () => {
             );
             assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
             assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
             const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -1265,7 +1192,6 @@ describe("test pox-4 contract", () => {
               ],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.ResponseErr));
             assert(isClarityType(actual.value, ClarityType.Int));
@@ -1304,9 +1230,7 @@ describe("test pox-4 contract", () => {
             );
             assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
             assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
             const expectedResponseErr = ERR_STACKING_INVALID_LOCK_PERIOD;
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -1322,7 +1246,6 @@ describe("test pox-4 contract", () => {
               ],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.ResponseErr));
             assert(isClarityType(actual.value, ClarityType.Int));
@@ -1343,7 +1266,6 @@ describe("test pox-4 contract", () => {
           (caller, version, hashbytes, first_rew_cycle, num_cycles) => {
             // Arrange
             const amount_ustx = 0;
-
             const { result: pox_4_info } = simnet.callReadOnlyFn(
               POX_4,
               GET_POX_INFO,
@@ -1352,9 +1274,7 @@ describe("test pox-4 contract", () => {
             );
             assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
             assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-
             const expectedResponseErr = ERR_STACKING_INVALID_AMOUNT;
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -1370,7 +1290,6 @@ describe("test pox-4 contract", () => {
               ],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.ResponseErr));
             assert(isClarityType(actual.value, ClarityType.Int));
@@ -1386,7 +1305,6 @@ describe("test pox-4 contract", () => {
           fc.constantFrom(...simnet.getAccounts().values()),
           (caller) => {
             // Arrange
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -1394,7 +1312,6 @@ describe("test pox-4 contract", () => {
               [Cl.principal(caller)],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.OptionalNone));
           }
@@ -1408,7 +1325,6 @@ describe("test pox-4 contract", () => {
           fc.constantFrom(...simnet.getAccounts().values()),
           (caller) => {
             // Arrange
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -1416,7 +1332,6 @@ describe("test pox-4 contract", () => {
               [Cl.principal(caller)],
               caller
             );
-
             // Assert
             assert(isClarityType(actual, ClarityType.OptionalNone));
           }
@@ -1473,7 +1388,6 @@ describe("test pox-4 contract", () => {
           fc.constantFrom(...simnet.getAccounts().values()),
           (caller, sender, contract_caller) => {
             // Arrange
-
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
               POX_4,
@@ -1502,7 +1416,6 @@ describe("test pox-4 contract", () => {
               [Cl.principal(contract_caller), Cl.none()],
               sender
             );
-
             assert(isClarityType(allow, ClarityType.ResponseOk));
             assert(isClarityType(allow.value, ClarityType.BoolTrue));
             // Act
@@ -1575,7 +1488,46 @@ describe("test pox-4 contract", () => {
       );
     });
 
-    // get-signer-key-message-hash
+    it("should return correct hash get-signer-key-message-hash", () => {
+      fc.assert(
+        fc.property(
+          fc.constantFrom(...simnet.getAccounts().values()),
+          fc.nat({ max: 6 }),
+          fc.array(fc.nat({ max: 255 }), { maxLength: 32 }),
+          fc.nat(),
+          fc.nat(),
+          (caller, version, hashbytes, reward_cycle, period) => {
+            // Arrange
+            const topic = "test";
+            const signer_key_message_hash = buildSignerKeyMessageHash(
+              version,
+              hashbytes,
+              reward_cycle,
+              topic,
+              period
+            );
+            // Act
+            const { result: actual } = simnet.callReadOnlyFn(
+              POX_4,
+              GET_SIGNER_KEY_MESSAGE_HASH,
+              [
+                Cl.tuple({
+                  version: Cl.buffer(Uint8Array.from([version])),
+                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+                }),
+                Cl.uint(reward_cycle),
+                Cl.stringAscii(topic),
+                Cl.uint(period),
+              ],
+              caller
+            );
+            // Assert
+            assert(isClarityType(actual, ClarityType.Buffer));
+            expect(actual).toBeBuff(signer_key_message_hash);
+          }
+        )
+      );
+    });
     // verify-signer-key-sig
   });
 });

From 1218ddc956412aa5a79e16a545ecdc6447033ab4 Mon Sep 17 00:00:00 2001
From: BowTiedRadone <bowtiedradone@gmail.com>
Date: Thu, 7 Mar 2024 16:49:58 +0200
Subject: [PATCH 1091/1166] updated get-signer-key-message-hash test to match
 the new function structure

---
 .../tests/pox-4/pox-4-utils/utils.ts          | 20 +++++++++++--
 .../tests/pox-4/pox-4.prop.test.ts            | 30 +++++++++++++++----
 2 files changed, 41 insertions(+), 9 deletions(-)

diff --git a/contrib/core-contract-tests/tests/pox-4/pox-4-utils/utils.ts b/contrib/core-contract-tests/tests/pox-4/pox-4-utils/utils.ts
index 81164c3338..1f53c81a92 100644
--- a/contrib/core-contract-tests/tests/pox-4/pox-4-utils/utils.ts
+++ b/contrib/core-contract-tests/tests/pox-4/pox-4-utils/utils.ts
@@ -21,7 +21,9 @@ const generateMessageHash = (
   hashbytes: number[],
   reward_cycle: number,
   topic: string,
-  period: number
+  period: number,
+  auth_id: number,
+  max_amount: number
 ) =>
   Cl.tuple({
     "pox-addr": Cl.tuple({
@@ -31,6 +33,8 @@ const generateMessageHash = (
     "reward-cycle": Cl.uint(reward_cycle),
     topic: Cl.stringAscii(topic),
     period: Cl.uint(period),
+    "auth-id": Cl.uint(auth_id),
+    "max-amount": Cl.uint(max_amount),
   });
 
 const generateMessagePrefixBuffer = (prefix: string) =>
@@ -41,12 +45,22 @@ export const buildSignerKeyMessageHash = (
   hashbytes: number[],
   reward_cycle: number,
   topic: string,
-  period: number
+  period: number,
+  max_amount: number,
+  auth_id: number
 ) => {
   const sip018_msg_prefix = "534950303138";
   const domain_hash = structuredDataHash(generateDomainHash());
   const message_hash = structuredDataHash(
-    generateMessageHash(version, hashbytes, reward_cycle, topic, period)
+    generateMessageHash(
+      version,
+      hashbytes,
+      reward_cycle,
+      topic,
+      period,
+      auth_id,
+      max_amount
+    )
   );
   const structuredDataPrefix = generateMessagePrefixBuffer(sip018_msg_prefix);
 
diff --git a/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts b/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
index b54eaafa5c..e1c1e04833 100644
--- a/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
+++ b/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
@@ -1,6 +1,6 @@
 import { Cl, ClarityType, isClarityType } from "@stacks/transactions";
-import { assert, describe, expect, it } from "vitest";
 import fc from "fast-check";
+import { assert, describe, expect, it } from "vitest";
 import { buildSignerKeyMessageHash } from "./pox-4-utils/utils";
 
 // Contracts
@@ -1496,15 +1496,31 @@ describe("test pox-4 contract", () => {
           fc.array(fc.nat({ max: 255 }), { maxLength: 32 }),
           fc.nat(),
           fc.nat(),
-          (caller, version, hashbytes, reward_cycle, period) => {
+          // fc.asciiString({ maxLength: 10, minLength: 1 }),
+          fc.nat(),
+          fc.nat(),
+          (
+            caller,
+            version,
+            hashbytes,
+            reward_cycle,
+            period,
+            // topic,
+            max_amount,
+            auth_id
+          ) => {
             // Arrange
-            const topic = "test";
+            // clarinet bug string:
+            // r;NT="
+
             const signer_key_message_hash = buildSignerKeyMessageHash(
               version,
               hashbytes,
               reward_cycle,
-              topic,
-              period
+              "topic",
+              period,
+              max_amount,
+              auth_id
             );
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
@@ -1516,8 +1532,10 @@ describe("test pox-4 contract", () => {
                   hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
                 }),
                 Cl.uint(reward_cycle),
-                Cl.stringAscii(topic),
+                Cl.stringAscii("topic"),
                 Cl.uint(period),
+                Cl.uint(max_amount),
+                Cl.uint(auth_id),
               ],
               caller
             );

From 3652f2fb497ff750b5a334e021f05781c09a0619 Mon Sep 17 00:00:00 2001
From: BowTiedRadone <bowtiedradone@gmail.com>
Date: Thu, 7 Mar 2024 20:21:11 +0200
Subject: [PATCH 1092/1166] Move utils to test file, inlined methods and
 contract name

---
 .../tests/pox-4/pox-4-utils/utils.ts          |  72 ----
 .../tests/pox-4/pox-4.prop.test.ts            | 342 ++++++++++--------
 2 files changed, 198 insertions(+), 216 deletions(-)
 delete mode 100644 contrib/core-contract-tests/tests/pox-4/pox-4-utils/utils.ts

diff --git a/contrib/core-contract-tests/tests/pox-4/pox-4-utils/utils.ts b/contrib/core-contract-tests/tests/pox-4/pox-4-utils/utils.ts
deleted file mode 100644
index 1f53c81a92..0000000000
--- a/contrib/core-contract-tests/tests/pox-4/pox-4-utils/utils.ts
+++ /dev/null
@@ -1,72 +0,0 @@
-import { Cl, ClarityValue, serializeCV } from "@stacks/transactions";
-import { createHash } from "crypto";
-
-function sha256(data: Buffer): Buffer {
-  return createHash("sha256").update(data).digest();
-}
-
-function structuredDataHash(structuredData: ClarityValue): Buffer {
-  return sha256(Buffer.from(serializeCV(structuredData)));
-}
-
-const generateDomainHash = () =>
-  Cl.tuple({
-    name: Cl.stringAscii("pox-4-signer"),
-    version: Cl.stringAscii("1.0.0"),
-    "chain-id": Cl.uint(2147483648),
-  });
-
-const generateMessageHash = (
-  version: number,
-  hashbytes: number[],
-  reward_cycle: number,
-  topic: string,
-  period: number,
-  auth_id: number,
-  max_amount: number
-) =>
-  Cl.tuple({
-    "pox-addr": Cl.tuple({
-      version: Cl.buffer(Uint8Array.from([version])),
-      hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
-    }),
-    "reward-cycle": Cl.uint(reward_cycle),
-    topic: Cl.stringAscii(topic),
-    period: Cl.uint(period),
-    "auth-id": Cl.uint(auth_id),
-    "max-amount": Cl.uint(max_amount),
-  });
-
-const generateMessagePrefixBuffer = (prefix: string) =>
-  Buffer.from(prefix, "hex");
-
-export const buildSignerKeyMessageHash = (
-  version: number,
-  hashbytes: number[],
-  reward_cycle: number,
-  topic: string,
-  period: number,
-  max_amount: number,
-  auth_id: number
-) => {
-  const sip018_msg_prefix = "534950303138";
-  const domain_hash = structuredDataHash(generateDomainHash());
-  const message_hash = structuredDataHash(
-    generateMessageHash(
-      version,
-      hashbytes,
-      reward_cycle,
-      topic,
-      period,
-      auth_id,
-      max_amount
-    )
-  );
-  const structuredDataPrefix = generateMessagePrefixBuffer(sip018_msg_prefix);
-
-  const signer_key_message_hash = sha256(
-    Buffer.concat([structuredDataPrefix, domain_hash, message_hash])
-  );
-
-  return signer_key_message_hash;
-};
diff --git a/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts b/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
index e1c1e04833..1a56d314c2 100644
--- a/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
+++ b/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
@@ -1,47 +1,101 @@
-import { Cl, ClarityType, isClarityType } from "@stacks/transactions";
+import {
+  Cl,
+  ClarityType,
+  ClarityValue,
+  isClarityType,
+  serializeCV,
+} from "@stacks/transactions";
 import fc from "fast-check";
 import { assert, describe, expect, it } from "vitest";
-import { buildSignerKeyMessageHash } from "./pox-4-utils/utils";
+import { createHash } from "crypto";
 
-// Contracts
-const POX_4 = "pox-4";
-// Methods
-const ALLOW_CONTRACT_CALLER = "allow-contract-caller";
-const BURN_HEIGHT_TO_REWARD_CYCLE = "burn-height-to-reward-cycle";
-const CAN_STACK_STX = "can-stack-stx";
-const CHECK_CALLER_ALLOWED = "check-caller-allowed";
-const CHECK_POX_ADDR_VERSION = "check-pox-addr-version";
-const CHECK_POX_LOCK_PERIOD = "check-pox-lock-period";
-const CURRENT_POX_REWARD_CYCLE = "current-pox-reward-cycle";
-const GET_ALLOWANCE_CONTRACT_CALLERS = "get-allowance-contract-callers";
-const GET_CHECK_DELEGATION = "get-check-delegation";
-const GET_DELEGATION_INFO = "get-delegation-info";
-const GET_NUM_REWARD_SET_POX_ADDRESSES = "get-num-reward-set-pox-addresses";
-const GET_PARTIAL_STACKED_BY_CYCLE = "get-partial-stacked-by-cycle";
-const GET_POX_INFO = "get-pox-info";
-const GET_REWARD_SET_POX_ADDRESS = "get-reward-set-pox-address";
-const GET_REWARD_SET_SIZE = "get-reward-set-size";
-const GET_SIGNER_KEY_MESSAGE_HASH = "get-signer-key-message-hash";
-const GET_STACKER_INFO = "get-stacker-info";
-const GET_STACKING_MINIMUM = "get-stacking-minimum";
-const GET_TOTAL_USTX_STACKED = "get-total-ustx-stacked";
-const MINIMAL_CAN_STACK_STX = "minimal-can-stack-stx";
-const REWARD_CYCLE_TO_BURN_HEIGHT = "reward-cycle-to-burn-height";
-const VERIFY_SIGNER_KEY_SIG = "verify-signer-key-sig";
 // Contract Consts
 const INITIAL_TOTAL_LIQ_SUPPLY = 1_000_000_000_000_000;
 const MIN_AMOUNT_USTX = 125_000_000_000n;
 const TESTNET_PREPARE_CYCLE_LENGTH = 50;
 const TESTNET_REWARD_CYCLE_LENGTH = 1050;
 const TESTNET_STACKING_THRESHOLD_25 = 8000;
-// Clarity Constraints
+// Clarity
 const MAX_CLAR_UINT = 340282366920938463463374607431768211455n;
+const TESTNET_CHAIN_ID = 2147483648;
+const SIP_018_MESSAGE_PREFIX = "534950303138";
 // Error Codes
 const ERR_STACKING_INVALID_LOCK_PERIOD = 2;
 const ERR_STACKING_THRESHOLD_NOT_MET = 11;
 const ERR_STACKING_INVALID_POX_ADDRESS = 13;
 const ERR_STACKING_INVALID_AMOUNT = 18;
 
+function sha256(data: Buffer): Buffer {
+  return createHash("sha256").update(data).digest();
+}
+
+function structuredDataHash(structuredData: ClarityValue): Buffer {
+  return sha256(Buffer.from(serializeCV(structuredData)));
+}
+
+const generateDomainHash = (): ClarityValue =>
+  Cl.tuple({
+    name: Cl.stringAscii("pox-4-signer"),
+    version: Cl.stringAscii("1.0.0"),
+    "chain-id": Cl.uint(TESTNET_CHAIN_ID),
+  });
+
+const generateMessageHash = (
+  version: number,
+  hashbytes: number[],
+  reward_cycle: number,
+  topic: string,
+  period: number,
+  auth_id: number,
+  max_amount: number
+): ClarityValue =>
+  Cl.tuple({
+    "pox-addr": Cl.tuple({
+      version: Cl.buffer(Uint8Array.from([version])),
+      hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+    }),
+    "reward-cycle": Cl.uint(reward_cycle),
+    topic: Cl.stringAscii(topic),
+    period: Cl.uint(period),
+    "auth-id": Cl.uint(auth_id),
+    "max-amount": Cl.uint(max_amount),
+  });
+
+const generateMessagePrefixBuffer = (prefix: string) =>
+  Buffer.from(prefix, "hex");
+
+export const buildSignerKeyMessageHash = (
+  version: number,
+  hashbytes: number[],
+  reward_cycle: number,
+  topic: string,
+  period: number,
+  max_amount: number,
+  auth_id: number
+) => {
+  const domain_hash = structuredDataHash(generateDomainHash());
+  const message_hash = structuredDataHash(
+    generateMessageHash(
+      version,
+      hashbytes,
+      reward_cycle,
+      topic,
+      period,
+      auth_id,
+      max_amount
+    )
+  );
+  const structuredDataPrefix = generateMessagePrefixBuffer(
+    SIP_018_MESSAGE_PREFIX
+  );
+
+  const signer_key_message_hash = sha256(
+    Buffer.concat([structuredDataPrefix, domain_hash, message_hash])
+  );
+
+  return signer_key_message_hash;
+};
+
 describe("test pox-4 contract", () => {
   describe("test pox-4 contract read only functions", () => {
     it("should return correct reward-cycle-to-burn-height", () => {
@@ -52,8 +106,8 @@ describe("test pox-4 contract", () => {
           (account, reward_cycle) => {
             // Arrange
             const { result: pox_4_info } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_POX_INFO,
+              "pox-4",
+              "get-pox-info",
               [],
               account
             );
@@ -65,8 +119,8 @@ describe("test pox-4 contract", () => {
               pox_4_info.value.data["reward-cycle-length"];
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              REWARD_CYCLE_TO_BURN_HEIGHT,
+              "pox-4",
+              "reward-cycle-to-burn-height",
               [Cl.uint(reward_cycle)],
               account
             );
@@ -91,8 +145,8 @@ describe("test pox-4 contract", () => {
           (account, burn_height) => {
             // Arrange
             const { result: pox_4_info } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_POX_INFO,
+              "pox-4",
+              "get-pox-info",
               [],
               account
             );
@@ -104,8 +158,8 @@ describe("test pox-4 contract", () => {
               pox_4_info.value.data["reward-cycle-length"];
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              BURN_HEIGHT_TO_REWARD_CYCLE,
+              "pox-4",
+              "burn-height-to-reward-cycle",
               [Cl.uint(burn_height)],
               account
             );
@@ -132,8 +186,8 @@ describe("test pox-4 contract", () => {
             let expected = 0;
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              CURRENT_POX_REWARD_CYCLE,
+              "pox-4",
+              "current-pox-reward-cycle",
               [],
               caller
             );
@@ -154,8 +208,8 @@ describe("test pox-4 contract", () => {
             // Arrange
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_STACKER_INFO,
+              "pox-4",
+              "get-stacker-info",
               [Cl.principal(stacker)],
               caller
             );
@@ -175,8 +229,8 @@ describe("test pox-4 contract", () => {
             // Arrange
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              CHECK_CALLER_ALLOWED,
+              "pox-4",
+              "check-caller-allowed",
               [],
               caller
             );
@@ -198,8 +252,8 @@ describe("test pox-4 contract", () => {
             const expected = 0;
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_REWARD_SET_SIZE,
+              "pox-4",
+              "get-reward-set-size",
               [Cl.uint(reward_cycle)],
               caller
             );
@@ -221,8 +275,8 @@ describe("test pox-4 contract", () => {
             const expected = 0;
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_TOTAL_USTX_STACKED,
+              "pox-4",
+              "get-total-ustx-stacked",
               [Cl.uint(reward_cycle)],
               caller
             );
@@ -244,8 +298,8 @@ describe("test pox-4 contract", () => {
             // Arrange
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_REWARD_SET_POX_ADDRESS,
+              "pox-4",
+              "get-reward-set-pox-address",
               [Cl.uint(index), Cl.uint(reward_cycle)],
               caller
             );
@@ -264,8 +318,8 @@ describe("test pox-4 contract", () => {
           (caller) => {
             // Arrange
             const { result: pox_4_info } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_POX_INFO,
+              "pox-4",
+              "get-pox-info",
               [],
               caller
             );
@@ -279,8 +333,8 @@ describe("test pox-4 contract", () => {
             );
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_STACKING_MINIMUM,
+              "pox-4",
+              "get-stacking-minimum",
               [],
               caller
             );
@@ -302,8 +356,8 @@ describe("test pox-4 contract", () => {
             const expected = true;
             // Act
             let { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              CHECK_POX_ADDR_VERSION,
+              "pox-4",
+              "check-pox-addr-version",
               [Cl.buffer(Uint8Array.from([version]))],
               caller
             );
@@ -325,8 +379,8 @@ describe("test pox-4 contract", () => {
             const expected = false;
             // Act
             let { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              CHECK_POX_ADDR_VERSION,
+              "pox-4",
+              "check-pox-addr-version",
               [Cl.buffer(Uint8Array.from([version]))],
               caller
             );
@@ -348,8 +402,8 @@ describe("test pox-4 contract", () => {
             const expected = true;
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              CHECK_POX_LOCK_PERIOD,
+              "pox-4",
+              "check-pox-lock-period",
               [Cl.uint(reward_cycles)],
               caller
             );
@@ -371,8 +425,8 @@ describe("test pox-4 contract", () => {
             const expected = false;
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              CHECK_POX_LOCK_PERIOD,
+              "pox-4",
+              "check-pox-lock-period",
               [Cl.uint(reward_cycles)],
               caller
             );
@@ -394,8 +448,8 @@ describe("test pox-4 contract", () => {
             const expected = false;
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              CHECK_POX_LOCK_PERIOD,
+              "pox-4",
+              "check-pox-lock-period",
               [Cl.uint(reward_cycles)],
               caller
             );
@@ -432,8 +486,8 @@ describe("test pox-4 contract", () => {
           ) => {
             // Arrange
             const { result: pox_4_info } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_POX_INFO,
+              "pox-4",
+              "get-pox-info",
               [],
               caller
             );
@@ -442,8 +496,8 @@ describe("test pox-4 contract", () => {
             const expectedResponseOk = true;
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              CAN_STACK_STX,
+              "pox-4",
+              "can-stack-stx",
               [
                 Cl.tuple({
                   version: Cl.buffer(Uint8Array.from([version])),
@@ -489,8 +543,8 @@ describe("test pox-4 contract", () => {
           ) => {
             // Arrange
             const { result: pox_4_info } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_POX_INFO,
+              "pox-4",
+              "get-pox-info",
               [],
               caller
             );
@@ -499,8 +553,8 @@ describe("test pox-4 contract", () => {
             const expectedResponseOk = true;
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              CAN_STACK_STX,
+              "pox-4",
+              "can-stack-stx",
               [
                 Cl.tuple({
                   version: Cl.buffer(Uint8Array.from([version])),
@@ -549,8 +603,8 @@ describe("test pox-4 contract", () => {
           ) => {
             // Arrange
             const { result: pox_4_info } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_POX_INFO,
+              "pox-4",
+              "get-pox-info",
               [],
               caller
             );
@@ -559,8 +613,8 @@ describe("test pox-4 contract", () => {
             const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              CAN_STACK_STX,
+              "pox-4",
+              "can-stack-stx",
               [
                 Cl.tuple({
                   version: Cl.buffer(Uint8Array.from([version])),
@@ -606,8 +660,8 @@ describe("test pox-4 contract", () => {
           ) => {
             // Arrange
             const { result: pox_4_info } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_POX_INFO,
+              "pox-4",
+              "get-pox-info",
               [],
               caller
             );
@@ -616,8 +670,8 @@ describe("test pox-4 contract", () => {
             const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              CAN_STACK_STX,
+              "pox-4",
+              "can-stack-stx",
               [
                 Cl.tuple({
                   version: Cl.buffer(Uint8Array.from([version])),
@@ -662,8 +716,8 @@ describe("test pox-4 contract", () => {
           ) => {
             // Arrange
             const { result: pox_4_info } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_POX_INFO,
+              "pox-4",
+              "get-pox-info",
               [],
               caller
             );
@@ -672,8 +726,8 @@ describe("test pox-4 contract", () => {
             const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              CAN_STACK_STX,
+              "pox-4",
+              "can-stack-stx",
               [
                 Cl.tuple({
                   version: Cl.buffer(Uint8Array.from([version])),
@@ -718,8 +772,8 @@ describe("test pox-4 contract", () => {
           ) => {
             // Arrange
             const { result: pox_4_info } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_POX_INFO,
+              "pox-4",
+              "get-pox-info",
               [],
               caller
             );
@@ -728,8 +782,8 @@ describe("test pox-4 contract", () => {
             const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              CAN_STACK_STX,
+              "pox-4",
+              "can-stack-stx",
               [
                 Cl.tuple({
                   version: Cl.buffer(Uint8Array.from([version])),
@@ -772,8 +826,8 @@ describe("test pox-4 contract", () => {
           ) => {
             // Arrange
             const { result: pox_4_info } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_POX_INFO,
+              "pox-4",
+              "get-pox-info",
               [],
               caller
             );
@@ -782,8 +836,8 @@ describe("test pox-4 contract", () => {
             const expectedResponseErr = ERR_STACKING_THRESHOLD_NOT_MET;
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              CAN_STACK_STX,
+              "pox-4",
+              "can-stack-stx",
               [
                 Cl.tuple({
                   version: Cl.buffer(Uint8Array.from([version])),
@@ -826,8 +880,8 @@ describe("test pox-4 contract", () => {
           ) => {
             // Arrange
             const { result: pox_4_info } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_POX_INFO,
+              "pox-4",
+              "get-pox-info",
               [],
               caller
             );
@@ -836,8 +890,8 @@ describe("test pox-4 contract", () => {
             const expectedResponseErr = ERR_STACKING_INVALID_LOCK_PERIOD;
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              CAN_STACK_STX,
+              "pox-4",
+              "can-stack-stx",
               [
                 Cl.tuple({
                   version: Cl.buffer(Uint8Array.from([version])),
@@ -883,8 +937,8 @@ describe("test pox-4 contract", () => {
           ) => {
             // Arrange
             const { result: pox_4_info } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_POX_INFO,
+              "pox-4",
+              "get-pox-info",
               [],
               caller
             );
@@ -893,8 +947,8 @@ describe("test pox-4 contract", () => {
             const expectedResponseOk = true;
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              MINIMAL_CAN_STACK_STX,
+              "pox-4",
+              "minimal-can-stack-stx",
               [
                 Cl.tuple({
                   version: Cl.buffer(Uint8Array.from([version])),
@@ -940,8 +994,8 @@ describe("test pox-4 contract", () => {
           ) => {
             // Arrange
             const { result: pox_4_info } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_POX_INFO,
+              "pox-4",
+              "get-pox-info",
               [],
               caller
             );
@@ -950,8 +1004,8 @@ describe("test pox-4 contract", () => {
             const expectedResponseOk = true;
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              MINIMAL_CAN_STACK_STX,
+              "pox-4",
+              "minimal-can-stack-stx",
               [
                 Cl.tuple({
                   version: Cl.buffer(Uint8Array.from([version])),
@@ -1000,8 +1054,8 @@ describe("test pox-4 contract", () => {
           ) => {
             // Arrange
             const { result: pox_4_info } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_POX_INFO,
+              "pox-4",
+              "get-pox-info",
               [],
               caller
             );
@@ -1010,8 +1064,8 @@ describe("test pox-4 contract", () => {
             const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              MINIMAL_CAN_STACK_STX,
+              "pox-4",
+              "minimal-can-stack-stx",
               [
                 Cl.tuple({
                   version: Cl.buffer(Uint8Array.from([version])),
@@ -1057,8 +1111,8 @@ describe("test pox-4 contract", () => {
           ) => {
             // Arrange
             const { result: pox_4_info } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_POX_INFO,
+              "pox-4",
+              "get-pox-info",
               [],
               caller
             );
@@ -1067,8 +1121,8 @@ describe("test pox-4 contract", () => {
             const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              MINIMAL_CAN_STACK_STX,
+              "pox-4",
+              "minimal-can-stack-stx",
               [
                 Cl.tuple({
                   version: Cl.buffer(Uint8Array.from([version])),
@@ -1113,8 +1167,8 @@ describe("test pox-4 contract", () => {
           ) => {
             // Arrange
             const { result: pox_4_info } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_POX_INFO,
+              "pox-4",
+              "get-pox-info",
               [],
               caller
             );
@@ -1123,8 +1177,8 @@ describe("test pox-4 contract", () => {
             const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              MINIMAL_CAN_STACK_STX,
+              "pox-4",
+              "minimal-can-stack-stx",
               [
                 Cl.tuple({
                   version: Cl.buffer(Uint8Array.from([version])),
@@ -1169,8 +1223,8 @@ describe("test pox-4 contract", () => {
           ) => {
             // Arrange
             const { result: pox_4_info } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_POX_INFO,
+              "pox-4",
+              "get-pox-info",
               [],
               caller
             );
@@ -1179,8 +1233,8 @@ describe("test pox-4 contract", () => {
             const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              MINIMAL_CAN_STACK_STX,
+              "pox-4",
+              "minimal-can-stack-stx",
               [
                 Cl.tuple({
                   version: Cl.buffer(Uint8Array.from([version])),
@@ -1223,8 +1277,8 @@ describe("test pox-4 contract", () => {
           ) => {
             // Arrange
             const { result: pox_4_info } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_POX_INFO,
+              "pox-4",
+              "get-pox-info",
               [],
               caller
             );
@@ -1233,8 +1287,8 @@ describe("test pox-4 contract", () => {
             const expectedResponseErr = ERR_STACKING_INVALID_LOCK_PERIOD;
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              MINIMAL_CAN_STACK_STX,
+              "pox-4",
+              "minimal-can-stack-stx",
               [
                 Cl.tuple({
                   version: Cl.buffer(Uint8Array.from([version])),
@@ -1267,8 +1321,8 @@ describe("test pox-4 contract", () => {
             // Arrange
             const amount_ustx = 0;
             const { result: pox_4_info } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_POX_INFO,
+              "pox-4",
+              "get-pox-info",
               [],
               caller
             );
@@ -1277,8 +1331,8 @@ describe("test pox-4 contract", () => {
             const expectedResponseErr = ERR_STACKING_INVALID_AMOUNT;
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              MINIMAL_CAN_STACK_STX,
+              "pox-4",
+              "minimal-can-stack-stx",
               [
                 Cl.tuple({
                   version: Cl.buffer(Uint8Array.from([version])),
@@ -1307,8 +1361,8 @@ describe("test pox-4 contract", () => {
             // Arrange
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_CHECK_DELEGATION,
+              "pox-4",
+              "get-check-delegation",
               [Cl.principal(caller)],
               caller
             );
@@ -1327,8 +1381,8 @@ describe("test pox-4 contract", () => {
             // Arrange
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_DELEGATION_INFO,
+              "pox-4",
+              "get-delegation-info",
               [Cl.principal(caller)],
               caller
             );
@@ -1349,8 +1403,8 @@ describe("test pox-4 contract", () => {
               expected_first_burn_block_height = 0;
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_POX_INFO,
+              "pox-4",
+              "get-pox-info",
               [],
               caller
             );
@@ -1390,8 +1444,8 @@ describe("test pox-4 contract", () => {
             // Arrange
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_ALLOWANCE_CONTRACT_CALLERS,
+              "pox-4",
+              "get-allowance-contract-callers",
               [Cl.principal(sender), Cl.principal(contract_caller)],
               caller
             );
@@ -1411,8 +1465,8 @@ describe("test pox-4 contract", () => {
           (caller, sender, contract_caller) => {
             // Arrange
             const { result: allow } = simnet.callPublicFn(
-              POX_4,
-              ALLOW_CONTRACT_CALLER,
+              "pox-4",
+              "allow-contract-caller",
               [Cl.principal(contract_caller), Cl.none()],
               sender
             );
@@ -1420,8 +1474,8 @@ describe("test pox-4 contract", () => {
             assert(isClarityType(allow.value, ClarityType.BoolTrue));
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_ALLOWANCE_CONTRACT_CALLERS,
+              "pox-4",
+              "get-allowance-contract-callers",
               [Cl.principal(sender), Cl.principal(contract_caller)],
               caller
             );
@@ -1444,8 +1498,8 @@ describe("test pox-4 contract", () => {
             const expected = 0;
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_NUM_REWARD_SET_POX_ADDRESSES,
+              "pox-4",
+              "get-num-reward-set-pox-addresses",
               [Cl.uint(reward_cycle)],
               caller
             );
@@ -1469,8 +1523,8 @@ describe("test pox-4 contract", () => {
             // Arrange
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_PARTIAL_STACKED_BY_CYCLE,
+              "pox-4",
+              "get-partial-stacked-by-cycle",
               [
                 Cl.tuple({
                   version: Cl.buffer(Uint8Array.from([version])),
@@ -1524,8 +1578,8 @@ describe("test pox-4 contract", () => {
             );
             // Act
             const { result: actual } = simnet.callReadOnlyFn(
-              POX_4,
-              GET_SIGNER_KEY_MESSAGE_HASH,
+              "pox-4",
+              "get-signer-key-message-hash",
               [
                 Cl.tuple({
                   version: Cl.buffer(Uint8Array.from([version])),

From b77be1009055221f8c2c6312cde570b2d2fc9b96 Mon Sep 17 00:00:00 2001
From: BowTiedRadone <bowtiedradone@gmail.com>
Date: Fri, 8 Mar 2024 13:10:10 +0200
Subject: [PATCH 1093/1166] Update according to comments

---
 .../tests/pox-4/pox-4.prop.test.ts            | 2916 ++++++++---------
 1 file changed, 1454 insertions(+), 1462 deletions(-)

diff --git a/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts b/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
index 1a56d314c2..b82d212477 100644
--- a/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
+++ b/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
@@ -96,1510 +96,1502 @@ export const buildSignerKeyMessageHash = (
   return signer_key_message_hash;
 };
 
-describe("test pox-4 contract", () => {
-  describe("test pox-4 contract read only functions", () => {
-    it("should return correct reward-cycle-to-burn-height", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.nat(),
-          (account, reward_cycle) => {
-            // Arrange
-            const { result: pox_4_info } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-pox-info",
-              [],
-              account
-            );
-            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-            const first_burn_block_height =
-              pox_4_info.value.data["first-burnchain-block-height"];
-            const reward_cycle_length =
-              pox_4_info.value.data["reward-cycle-length"];
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "reward-cycle-to-burn-height",
-              [Cl.uint(reward_cycle)],
-              account
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.UInt));
-            assert(isClarityType(first_burn_block_height, ClarityType.UInt));
-            assert(isClarityType(reward_cycle_length, ClarityType.UInt));
-            const expected =
-              Number(first_burn_block_height.value) +
-              Number(reward_cycle_length.value) * reward_cycle;
-            expect(actual).toBeUint(expected);
-          }
-        )
-      );
-    });
+describe("test pox-4 contract read only functions", () => {
+  it("should return correct reward-cycle-to-burn-height", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.nat(),
+        (account, reward_cycle) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-pox-info",
+            [],
+            account
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+          const first_burn_block_height =
+            pox_4_info.value.data["first-burnchain-block-height"];
+          const reward_cycle_length =
+            pox_4_info.value.data["reward-cycle-length"];
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "reward-cycle-to-burn-height",
+            [Cl.uint(reward_cycle)],
+            account
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.UInt));
+          assert(isClarityType(first_burn_block_height, ClarityType.UInt));
+          assert(isClarityType(reward_cycle_length, ClarityType.UInt));
+          const expected =
+            Number(first_burn_block_height.value) +
+            Number(reward_cycle_length.value) * reward_cycle;
+          expect(actual).toBeUint(expected);
+        }
+      )
+    );
+  });
 
-    it("should return correct burn-height-to-reward-cycle", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.nat(),
-          (account, burn_height) => {
-            // Arrange
-            const { result: pox_4_info } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-pox-info",
-              [],
-              account
-            );
-            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-            const first_burn_block_height =
-              pox_4_info.value.data["first-burnchain-block-height"];
-            const reward_cycle_length =
-              pox_4_info.value.data["reward-cycle-length"];
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "burn-height-to-reward-cycle",
-              [Cl.uint(burn_height)],
-              account
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.UInt));
-            assert(isClarityType(first_burn_block_height, ClarityType.UInt));
-            assert(isClarityType(reward_cycle_length, ClarityType.UInt));
-            const expected = Math.floor(
-              (burn_height - Number(first_burn_block_height.value)) /
-                Number(reward_cycle_length.value)
-            );
-            expect(actual).toBeUint(expected);
-          }
-        )
-      );
-    });
+  it("should return correct burn-height-to-reward-cycle", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.nat(),
+        (account, burn_height) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-pox-info",
+            [],
+            account
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+          const first_burn_block_height =
+            pox_4_info.value.data["first-burnchain-block-height"];
+          const reward_cycle_length =
+            pox_4_info.value.data["reward-cycle-length"];
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "burn-height-to-reward-cycle",
+            [Cl.uint(burn_height)],
+            account
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.UInt));
+          assert(isClarityType(first_burn_block_height, ClarityType.UInt));
+          assert(isClarityType(reward_cycle_length, ClarityType.UInt));
+          const expected = Math.floor(
+            (burn_height - Number(first_burn_block_height.value)) /
+              Number(reward_cycle_length.value)
+          );
+          expect(actual).toBeUint(expected);
+        }
+      )
+    );
+  });
 
-    it("should return u0 current-pox-reward-cycle", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          (caller) => {
-            // Arrange
-            let expected = 0;
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "current-pox-reward-cycle",
-              [],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.UInt));
-            expect(actual).toBeUint(expected);
-          }
-        )
-      );
-    });
+  it("should return u0 current-pox-reward-cycle", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        (caller) => {
+          // Arrange
+          let expected = 0;
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "current-pox-reward-cycle",
+            [],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.UInt));
+          expect(actual).toBeUint(expected);
+        }
+      )
+    );
+  });
 
-    it("should return none get-stacker-info", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.constantFrom(...simnet.getAccounts().values()),
-          (stacker, caller) => {
-            // Arrange
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-stacker-info",
-              [Cl.principal(stacker)],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.OptionalNone));
-            expect(actual).toBeNone();
-          }
-        )
-      );
-    });
+  it("should return none get-stacker-info", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.constantFrom(...simnet.getAccounts().values()),
+        (stacker, caller) => {
+          // Arrange
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-stacker-info",
+            [Cl.principal(stacker)],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.OptionalNone));
+          expect(actual).toBeNone();
+        }
+      )
+    );
+  });
 
-    it("should return true check-caller-allowed", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          (caller) => {
-            // Arrange
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "check-caller-allowed",
-              [],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.BoolTrue));
-            expect(actual).toBeBool(true);
-          }
-        )
-      );
-    });
+  it("should return true check-caller-allowed", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        (caller) => {
+          // Arrange
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "check-caller-allowed",
+            [],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.BoolTrue));
+          expect(actual).toBeBool(true);
+        }
+      )
+    );
+  });
 
-    it("should return u0 get-reward-set-size", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.nat(),
-          (caller, reward_cycle) => {
-            // Arrange
-            const expected = 0;
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-reward-set-size",
-              [Cl.uint(reward_cycle)],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.UInt));
-            expect(actual).toBeUint(expected);
-          }
-        )
-      );
-    });
+  it("should return u0 get-reward-set-size", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.nat(),
+        (caller, reward_cycle) => {
+          // Arrange
+          const expected = 0;
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-reward-set-size",
+            [Cl.uint(reward_cycle)],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.UInt));
+          expect(actual).toBeUint(expected);
+        }
+      )
+    );
+  });
 
-    it("should return u0 get-total-ustx-stacked", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.nat(),
-          (caller, reward_cycle) => {
-            // Arrange
-            const expected = 0;
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-total-ustx-stacked",
-              [Cl.uint(reward_cycle)],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.UInt));
-            expect(actual).toBeUint(expected);
-          }
-        )
-      );
-    });
+  it("should return u0 get-total-ustx-stacked", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.nat(),
+        (caller, reward_cycle) => {
+          // Arrange
+          const expected = 0;
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-total-ustx-stacked",
+            [Cl.uint(reward_cycle)],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.UInt));
+          expect(actual).toBeUint(expected);
+        }
+      )
+    );
+  });
 
-    it("should return none get-reward-set-pox-address", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.nat(),
-          fc.nat(),
-          (caller, index, reward_cycle) => {
-            // Arrange
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-reward-set-pox-address",
-              [Cl.uint(index), Cl.uint(reward_cycle)],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.OptionalNone));
-            expect(actual).toBeNone();
-          }
-        )
-      );
-    });
+  it("should return none get-reward-set-pox-address", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.nat(),
+        fc.nat(),
+        (caller, index, reward_cycle) => {
+          // Arrange
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-reward-set-pox-address",
+            [Cl.uint(index), Cl.uint(reward_cycle)],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.OptionalNone));
+          expect(actual).toBeNone();
+        }
+      )
+    );
+  });
 
-    it("should return correct get-stacking-minimum", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          (caller) => {
-            // Arrange
-            const { result: pox_4_info } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-pox-info",
-              [],
-              caller
-            );
-            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-            const stx_liq_supply =
-              pox_4_info.value.data["total-liquid-supply-ustx"];
-            assert(isClarityType(stx_liq_supply, ClarityType.UInt));
-            const expected = Math.floor(
-              Number(stx_liq_supply.value) / TESTNET_STACKING_THRESHOLD_25
-            );
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-stacking-minimum",
-              [],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.UInt));
-            expect(actual).toBeUint(expected);
-          }
-        )
-      );
-    });
+  it("should return correct get-stacking-minimum", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        (caller) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-pox-info",
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+          const stx_liq_supply =
+            pox_4_info.value.data["total-liquid-supply-ustx"];
+          assert(isClarityType(stx_liq_supply, ClarityType.UInt));
+          const expected = Math.floor(
+            Number(stx_liq_supply.value) / TESTNET_STACKING_THRESHOLD_25
+          );
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-stacking-minimum",
+            [],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.UInt));
+          expect(actual).toBeUint(expected);
+        }
+      )
+    );
+  });
 
-    it("should return true check-pox-addr-version for version <= 6 ", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.nat({ max: 6 }),
-          (caller, version) => {
-            // Arrange
-            const expected = true;
-            // Act
-            let { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "check-pox-addr-version",
-              [Cl.buffer(Uint8Array.from([version]))],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.BoolTrue));
-            expect(actual).toBeBool(expected);
-          }
-        )
-      );
-    });
+  it("should return true check-pox-addr-version for version <= 6 ", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.nat({ max: 6 }),
+        (caller, version) => {
+          // Arrange
+          const expected = true;
+          // Act
+          let { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "check-pox-addr-version",
+            [Cl.buffer(Uint8Array.from([version]))],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.BoolTrue));
+          expect(actual).toBeBool(expected);
+        }
+      )
+    );
+  });
 
-    it("should return false check-pox-addr-version for version > 6", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.integer({ min: 7, max: 255 }),
-          (caller, version) => {
-            // Arrange
-            const expected = false;
-            // Act
-            let { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "check-pox-addr-version",
-              [Cl.buffer(Uint8Array.from([version]))],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.BoolFalse));
-            expect(actual).toBeBool(expected);
-          }
-        )
-      );
-    });
+  it("should return false check-pox-addr-version for version > 6", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 7, max: 255 }),
+        (caller, version) => {
+          // Arrange
+          const expected = false;
+          // Act
+          let { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "check-pox-addr-version",
+            [Cl.buffer(Uint8Array.from([version]))],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.BoolFalse));
+          expect(actual).toBeBool(expected);
+        }
+      )
+    );
+  });
 
-    it("should return true check-pox-lock-period for valid reward cycles number", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.integer({ min: 1, max: 12 }),
-          (caller, reward_cycles) => {
-            // Arrange
-            const expected = true;
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "check-pox-lock-period",
-              [Cl.uint(reward_cycles)],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.BoolTrue));
-            expect(actual).toBeBool(expected);
-          }
-        )
-      );
-    });
+  it("should return true check-pox-lock-period for valid reward cycles number", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 1, max: 12 }),
+        (caller, valid_reward_cycles) => {
+          // Arrange
+          const expected = true;
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "check-pox-lock-period",
+            [Cl.uint(valid_reward_cycles)],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.BoolTrue));
+          expect(actual).toBeBool(expected);
+        }
+      )
+    );
+  });
 
-    it("should return false check-pox-lock-period for reward cycles number > 12", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.integer({ min: 13 }),
-          (caller, reward_cycles) => {
-            // Arrange
-            const expected = false;
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "check-pox-lock-period",
-              [Cl.uint(reward_cycles)],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.BoolFalse));
-            expect(actual).toBeBool(expected);
-          }
-        )
-      );
-    });
+  it("should return false check-pox-lock-period for reward cycles number > 12", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 13 }),
+        (caller, invalid_reward_cycles) => {
+          // Arrange
+          const expected = false;
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "check-pox-lock-period",
+            [Cl.uint(invalid_reward_cycles)],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.BoolFalse));
+          expect(actual).toBeBool(expected);
+        }
+      )
+    );
+  });
 
-    it("should return false check-pox-lock-period for reward cycles number == 0", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          (caller) => {
-            // Arrange
-            const reward_cycles = 0;
-            const expected = false;
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "check-pox-lock-period",
-              [Cl.uint(reward_cycles)],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.BoolFalse));
-            expect(actual).toBeBool(expected);
-          }
-        )
-      );
-    });
+  it("should return false check-pox-lock-period for reward cycles number == 0", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        (caller) => {
+          // Arrange
+          const invalid_reward_cycles = 0;
+          const expected = false;
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "check-pox-lock-period",
+            [Cl.uint(invalid_reward_cycles)],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.BoolFalse));
+          expect(actual).toBeBool(expected);
+        }
+      )
+    );
+  });
 
-    it("should return (ok true) can-stack-stx for versions 0-4 valid pox addresses, hashbytes, amount, cycles number", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.integer({ min: 0, max: 4 }),
-          fc.array(fc.nat({ max: 255 }), {
-            minLength: 20,
-            maxLength: 20,
-          }),
-          fc.bigInt({
-            min: MIN_AMOUNT_USTX,
-            max: MAX_CLAR_UINT,
-          }),
-          fc.nat(),
-          fc.integer({ min: 1, max: 12 }),
-          (
-            caller,
-            version,
-            hashbytes,
-            amount_ustx,
-            first_rew_cycle,
-            num_cycles
-          ) => {
-            // Arrange
-            const { result: pox_4_info } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-pox-info",
-              [],
-              caller
-            );
-            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-            const expectedResponseOk = true;
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "can-stack-stx",
-              [
-                Cl.tuple({
-                  version: Cl.buffer(Uint8Array.from([version])),
-                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
-                }),
-                Cl.uint(amount_ustx),
-                Cl.uint(first_rew_cycle),
-                Cl.uint(num_cycles),
-              ],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.ResponseOk));
-            assert(isClarityType(actual.value, ClarityType.BoolTrue));
-            expect(actual).toBeOk(Cl.bool(expectedResponseOk));
-          }
-        )
-      );
-    });
+  it("should return (ok true) can-stack-stx for versions 0-4 valid pox addresses, hashbytes, amount, cycles number", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 0, max: 4 }),
+        fc.array(fc.nat({ max: 255 }), {
+          minLength: 20,
+          maxLength: 20,
+        }),
+        fc.bigInt({
+          min: MIN_AMOUNT_USTX,
+          max: MAX_CLAR_UINT,
+        }),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-pox-info",
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+          const expectedResponseOk = true;
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "can-stack-stx",
+            [
+              Cl.tuple({
+                version: Cl.buffer(Uint8Array.from([version])),
+                hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseOk));
+          assert(isClarityType(actual.value, ClarityType.BoolTrue));
+          expect(actual).toBeOk(Cl.bool(expectedResponseOk));
+        }
+      )
+    );
+  });
 
-    it("should return (ok true) can-stack-stx for versions 5/6 valid pox addresses, hashbytes, amount, cycles number", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.integer({ min: 5, max: 6 }),
-          fc.array(fc.nat({ max: 255 }), {
-            minLength: 32,
-            maxLength: 32,
-          }),
-          fc.bigInt({
-            min: MIN_AMOUNT_USTX,
-            max: MAX_CLAR_UINT,
-          }),
-          fc.nat(),
-          fc.integer({ min: 1, max: 12 }),
-          (
-            caller,
-            version,
-            hashbytes,
-            amount_ustx,
-            first_rew_cycle,
-            num_cycles
-          ) => {
-            // Arrange
-            const { result: pox_4_info } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-pox-info",
-              [],
-              caller
-            );
-            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-            const expectedResponseOk = true;
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "can-stack-stx",
-              [
-                Cl.tuple({
-                  version: Cl.buffer(Uint8Array.from([version])),
-                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
-                }),
-                Cl.uint(amount_ustx),
-                Cl.uint(first_rew_cycle),
-                Cl.uint(num_cycles),
-              ],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.ResponseOk));
-            assert(isClarityType(actual.value, ClarityType.BoolTrue));
-            expect(actual).toBeOk(Cl.bool(expectedResponseOk));
-          }
-        )
-      );
-    });
+  it("should return (ok true) can-stack-stx for versions 5/6 valid pox addresses, hashbytes, amount, cycles number", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 5, max: 6 }),
+        fc.array(fc.nat({ max: 255 }), {
+          minLength: 32,
+          maxLength: 32,
+        }),
+        fc.bigInt({
+          min: MIN_AMOUNT_USTX,
+          max: MAX_CLAR_UINT,
+        }),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-pox-info",
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+          const expectedResponseOk = true;
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "can-stack-stx",
+            [
+              Cl.tuple({
+                version: Cl.buffer(Uint8Array.from([version])),
+                hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseOk));
+          assert(isClarityType(actual.value, ClarityType.BoolTrue));
+          expect(actual).toBeOk(Cl.bool(expectedResponseOk));
+        }
+      )
+    );
+  });
 
-    it("should return (err 13) can-stack-stx for pox addresses having version > 6", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.integer({
-            min: 7,
-            max: 255,
-          }),
-          fc.array(fc.nat({ max: 255 }), {
-            minLength: 32,
-            maxLength: 32,
-          }),
-          fc.bigInt({
-            min: MIN_AMOUNT_USTX,
-            max: MAX_CLAR_UINT,
-          }),
-          fc.nat(),
-          fc.integer({ min: 1, max: 12 }),
-          (
-            caller,
-            version,
-            hashbytes,
-            amount_ustx,
-            first_rew_cycle,
-            num_cycles
-          ) => {
-            // Arrange
-            const { result: pox_4_info } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-pox-info",
-              [],
-              caller
-            );
-            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-            const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "can-stack-stx",
-              [
-                Cl.tuple({
-                  version: Cl.buffer(Uint8Array.from([version])),
-                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
-                }),
-                Cl.uint(amount_ustx),
-                Cl.uint(first_rew_cycle),
-                Cl.uint(num_cycles),
-              ],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.ResponseErr));
-            assert(isClarityType(actual.value, ClarityType.Int));
-            expect(actual).toBeErr(Cl.int(expectedResponseErr));
-          }
-        )
-      );
-    });
+  it("should return (err 13) can-stack-stx for pox addresses having version > 6", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({
+          min: 7,
+          max: 255,
+        }),
+        fc.array(fc.nat({ max: 255 }), {
+          maxLength: 32,
+        }),
+        fc.bigInt({
+          min: MIN_AMOUNT_USTX,
+          max: MAX_CLAR_UINT,
+        }),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-pox-info",
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+          const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "can-stack-stx",
+            [
+              Cl.tuple({
+                version: Cl.buffer(Uint8Array.from([version])),
+                hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
+        }
+      )
+    );
+  });
 
-    it("should return (err 13) can-stack-stx for versions 0-4 pox addresses having hasbytes longer than 20", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.integer({ min: 0, max: 4 }),
-          fc.array(fc.nat({ max: 255 }), {
-            minLength: 21,
-            maxLength: 32,
-          }),
-          fc.bigInt({
-            min: MIN_AMOUNT_USTX,
-            max: MAX_CLAR_UINT,
-          }),
-          fc.nat(),
-          fc.integer({ min: 1, max: 12 }),
-          (
-            caller,
-            version,
-            hashbytes,
-            amount_ustx,
-            first_rew_cycle,
-            num_cycles
-          ) => {
-            // Arrange
-            const { result: pox_4_info } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-pox-info",
-              [],
-              caller
-            );
-            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-            const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "can-stack-stx",
-              [
-                Cl.tuple({
-                  version: Cl.buffer(Uint8Array.from([version])),
-                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
-                }),
-                Cl.uint(amount_ustx),
-                Cl.uint(first_rew_cycle),
-                Cl.uint(num_cycles),
-              ],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.ResponseErr));
-            assert(isClarityType(actual.value, ClarityType.Int));
-            expect(actual).toBeErr(Cl.int(expectedResponseErr));
-          }
-        )
-      );
-    });
+  it("should return (err 13) can-stack-stx for versions 0-4 pox addresses having hasbytes longer than 20", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 0, max: 4 }),
+        fc.array(fc.nat({ max: 255 }), {
+          minLength: 21,
+          maxLength: 32,
+        }),
+        fc.bigInt({
+          min: MIN_AMOUNT_USTX,
+          max: MAX_CLAR_UINT,
+        }),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-pox-info",
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+          const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "can-stack-stx",
+            [
+              Cl.tuple({
+                version: Cl.buffer(Uint8Array.from([version])),
+                hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
+        }
+      )
+    );
+  });
 
-    it("should return (err 13) can-stack-stx for versions 0-4 pox addresses having hasbytes shorter than 20", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.integer({ min: 0, max: 4 }),
-          fc.array(fc.nat({ max: 255 }), {
-            maxLength: 19,
-          }),
-          fc.bigInt({
-            min: MIN_AMOUNT_USTX,
-            max: MAX_CLAR_UINT,
-          }),
-          fc.nat(),
-          fc.integer({ min: 1, max: 12 }),
-          (
-            caller,
-            version,
-            hashbytes,
-            amount_ustx,
-            first_rew_cycle,
-            num_cycles
-          ) => {
-            // Arrange
-            const { result: pox_4_info } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-pox-info",
-              [],
-              caller
-            );
-            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-            const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "can-stack-stx",
-              [
-                Cl.tuple({
-                  version: Cl.buffer(Uint8Array.from([version])),
-                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
-                }),
-                Cl.uint(amount_ustx),
-                Cl.uint(first_rew_cycle),
-                Cl.uint(num_cycles),
-              ],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.ResponseErr));
-            assert(isClarityType(actual.value, ClarityType.Int));
-            expect(actual).toBeErr(Cl.int(expectedResponseErr));
-          }
-        )
-      );
-    });
+  it("should return (err 13) can-stack-stx for versions 0-4 pox addresses having hasbytes shorter than 20", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 0, max: 4 }),
+        fc.array(fc.nat({ max: 255 }), {
+          maxLength: 19,
+        }),
+        fc.bigInt({
+          min: MIN_AMOUNT_USTX,
+          max: MAX_CLAR_UINT,
+        }),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-pox-info",
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+          const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "can-stack-stx",
+            [
+              Cl.tuple({
+                version: Cl.buffer(Uint8Array.from([version])),
+                hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
+        }
+      )
+    );
+  });
 
-    it("should return (err 13) can-stack-stx for versions 5/6 pox addresses having hashbytes shorter than 32", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.integer({ min: 0, max: 4 }),
-          fc.array(fc.nat({ max: 255 }), {
-            maxLength: 31,
-          }),
-          fc.bigInt({
-            min: MIN_AMOUNT_USTX,
-            max: MAX_CLAR_UINT,
-          }),
-          fc.nat(),
-          fc.integer({ min: 1, max: 12 }),
-          (
-            caller,
-            version,
-            hashbytes,
-            amount_ustx,
-            first_rew_cycle,
-            num_cycles
-          ) => {
-            // Arrange
-            const { result: pox_4_info } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-pox-info",
-              [],
-              caller
-            );
-            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-            const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "can-stack-stx",
-              [
-                Cl.tuple({
-                  version: Cl.buffer(Uint8Array.from([version])),
-                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
-                }),
-                Cl.uint(amount_ustx),
-                Cl.uint(first_rew_cycle),
-                Cl.uint(num_cycles),
-              ],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.ResponseErr));
-            assert(isClarityType(actual.value, ClarityType.Int));
-            expect(actual).toBeErr(Cl.int(expectedResponseErr));
-          }
-        )
-      );
-    });
+  it("should return (err 13) can-stack-stx for versions 5/6 pox addresses having hashbytes shorter than 32", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 0, max: 4 }),
+        fc.array(fc.nat({ max: 255 }), {
+          maxLength: 31,
+        }),
+        fc.bigInt({
+          min: MIN_AMOUNT_USTX,
+          max: MAX_CLAR_UINT,
+        }),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-pox-info",
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+          const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "can-stack-stx",
+            [
+              Cl.tuple({
+                version: Cl.buffer(Uint8Array.from([version])),
+                hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
+        }
+      )
+    );
+  });
 
-    it("should return (err 11) can-stack-stx for unmet stacking threshold", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.integer({ min: 0, max: 6 }),
-          fc.array(fc.nat({ max: 255 })),
-          fc.bigInt({
-            min: 0n,
-            max: 124_999_999_999n,
-          }),
-          fc.nat(),
-          fc.integer({ min: 1, max: 12 }),
-          (
-            caller,
-            version,
-            hashbytes,
-            amount_ustx,
-            first_rew_cycle,
-            num_cycles
-          ) => {
-            // Arrange
-            const { result: pox_4_info } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-pox-info",
-              [],
-              caller
-            );
-            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-            const expectedResponseErr = ERR_STACKING_THRESHOLD_NOT_MET;
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "can-stack-stx",
-              [
-                Cl.tuple({
-                  version: Cl.buffer(Uint8Array.from([version])),
-                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
-                }),
-                Cl.uint(amount_ustx),
-                Cl.uint(first_rew_cycle),
-                Cl.uint(num_cycles),
-              ],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.ResponseErr));
-            assert(isClarityType(actual.value, ClarityType.Int));
-            expect(actual).toBeErr(Cl.int(expectedResponseErr));
-          }
-        )
-      );
-    });
+  it("should return (err 11) can-stack-stx for unmet stacking threshold", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 0, max: 6 }),
+        fc.array(fc.nat({ max: 255 })),
+        fc.bigInt({
+          min: 0n,
+          max: 124_999_999_999n,
+        }),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-pox-info",
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+          const expectedResponseErr = ERR_STACKING_THRESHOLD_NOT_MET;
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "can-stack-stx",
+            [
+              Cl.tuple({
+                version: Cl.buffer(Uint8Array.from([version])),
+                hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
+        }
+      )
+    );
+  });
 
-    it("should return (err 2) can-stack-stx for lock period > 12", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.integer({ min: 0, max: 6 }),
-          fc.array(fc.nat({ max: 255 })),
-          fc.bigInt({
-            min: MIN_AMOUNT_USTX,
-            max: MAX_CLAR_UINT,
-          }),
-          fc.nat(),
-          fc.integer({ min: 13 }),
-          (
-            caller,
-            version,
-            hashbytes,
-            amount_ustx,
-            first_rew_cycle,
-            num_cycles
-          ) => {
-            // Arrange
-            const { result: pox_4_info } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-pox-info",
-              [],
-              caller
-            );
-            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-            const expectedResponseErr = ERR_STACKING_INVALID_LOCK_PERIOD;
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "can-stack-stx",
-              [
-                Cl.tuple({
-                  version: Cl.buffer(Uint8Array.from([version])),
-                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
-                }),
-                Cl.uint(amount_ustx),
-                Cl.uint(first_rew_cycle),
-                Cl.uint(num_cycles),
-              ],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.ResponseErr));
-            assert(isClarityType(actual.value, ClarityType.Int));
-            expect(actual).toBeErr(Cl.int(expectedResponseErr));
-          }
-        )
-      );
-    });
+  it("should return (err 2) can-stack-stx for lock period > 12", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 0, max: 6 }),
+        fc.array(fc.nat({ max: 255 })),
+        fc.bigInt({
+          min: MIN_AMOUNT_USTX,
+          max: MAX_CLAR_UINT,
+        }),
+        fc.nat(),
+        fc.integer({ min: 13 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-pox-info",
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+          const expectedResponseErr = ERR_STACKING_INVALID_LOCK_PERIOD;
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "can-stack-stx",
+            [
+              Cl.tuple({
+                version: Cl.buffer(Uint8Array.from([version])),
+                hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
+        }
+      )
+    );
+  });
 
-    it("should return (ok true) minimal-can-stack-stx for versions 0-4 valid pox addresses, hashbytes, amount, cycles number", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.integer({ min: 0, max: 4 }),
-          fc.array(fc.nat({ max: 255 }), {
-            minLength: 20,
-            maxLength: 20,
-          }),
-          fc.bigInt({
-            min: MIN_AMOUNT_USTX,
-            max: MAX_CLAR_UINT,
-          }),
-          fc.nat(),
-          fc.integer({ min: 1, max: 12 }),
-          (
-            caller,
-            version,
-            hashbytes,
-            amount_ustx,
-            first_rew_cycle,
-            num_cycles
-          ) => {
-            // Arrange
-            const { result: pox_4_info } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-pox-info",
-              [],
-              caller
-            );
-            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-            const expectedResponseOk = true;
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "minimal-can-stack-stx",
-              [
-                Cl.tuple({
-                  version: Cl.buffer(Uint8Array.from([version])),
-                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
-                }),
-                Cl.uint(amount_ustx),
-                Cl.uint(first_rew_cycle),
-                Cl.uint(num_cycles),
-              ],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.ResponseOk));
-            assert(isClarityType(actual.value, ClarityType.BoolTrue));
-            expect(actual).toBeOk(Cl.bool(expectedResponseOk));
-          }
-        )
-      );
-    });
+  it("should return (ok true) minimal-can-stack-stx for versions 0-4 valid pox addresses, hashbytes, amount, cycles number", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 0, max: 4 }),
+        fc.array(fc.nat({ max: 255 }), {
+          minLength: 20,
+          maxLength: 20,
+        }),
+        fc.bigInt({
+          min: MIN_AMOUNT_USTX,
+          max: MAX_CLAR_UINT,
+        }),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-pox-info",
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+          const expectedResponseOk = true;
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "minimal-can-stack-stx",
+            [
+              Cl.tuple({
+                version: Cl.buffer(Uint8Array.from([version])),
+                hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseOk));
+          assert(isClarityType(actual.value, ClarityType.BoolTrue));
+          expect(actual).toBeOk(Cl.bool(expectedResponseOk));
+        }
+      )
+    );
+  });
 
-    it("should return (ok true) minimal-can-stack-stx for versions 5/6 valid pox addresses, hashbytes, amount, cycles number", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.integer({ min: 5, max: 6 }),
-          fc.array(fc.nat({ max: 255 }), {
-            minLength: 32,
-            maxLength: 32,
-          }),
-          fc.bigInt({
-            min: MIN_AMOUNT_USTX,
-            max: MAX_CLAR_UINT,
-          }),
-          fc.nat(),
-          fc.integer({ min: 1, max: 12 }),
-          (
-            caller,
-            version,
-            hashbytes,
-            amount_ustx,
-            first_rew_cycle,
-            num_cycles
-          ) => {
-            // Arrange
-            const { result: pox_4_info } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-pox-info",
-              [],
-              caller
-            );
-            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-            const expectedResponseOk = true;
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "minimal-can-stack-stx",
-              [
-                Cl.tuple({
-                  version: Cl.buffer(Uint8Array.from([version])),
-                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
-                }),
-                Cl.uint(amount_ustx),
-                Cl.uint(first_rew_cycle),
-                Cl.uint(num_cycles),
-              ],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.ResponseOk));
-            assert(isClarityType(actual.value, ClarityType.BoolTrue));
-            expect(actual).toBeOk(Cl.bool(expectedResponseOk));
-          }
-        )
-      );
-    });
+  it("should return (ok true) minimal-can-stack-stx for versions 5/6 valid pox addresses, hashbytes, amount, cycles number", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 5, max: 6 }),
+        fc.array(fc.nat({ max: 255 }), {
+          minLength: 32,
+          maxLength: 32,
+        }),
+        fc.bigInt({
+          min: MIN_AMOUNT_USTX,
+          max: MAX_CLAR_UINT,
+        }),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-pox-info",
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+          const expectedResponseOk = true;
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "minimal-can-stack-stx",
+            [
+              Cl.tuple({
+                version: Cl.buffer(Uint8Array.from([version])),
+                hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseOk));
+          assert(isClarityType(actual.value, ClarityType.BoolTrue));
+          expect(actual).toBeOk(Cl.bool(expectedResponseOk));
+        }
+      )
+    );
+  });
 
-    it("should return (err 13) minimal-can-stack-stx for pox addresses having version > 6", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.integer({
-            min: 7,
-            max: 255,
-          }),
-          fc.array(fc.nat({ max: 255 }), {
-            minLength: 32,
-            maxLength: 32,
-          }),
-          fc.bigInt({
-            min: MIN_AMOUNT_USTX,
-            max: MAX_CLAR_UINT,
-          }),
-          fc.nat(),
-          fc.integer({ min: 1, max: 12 }),
-          (
-            caller,
-            version,
-            hashbytes,
-            amount_ustx,
-            first_rew_cycle,
-            num_cycles
-          ) => {
-            // Arrange
-            const { result: pox_4_info } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-pox-info",
-              [],
-              caller
-            );
-            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-            const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "minimal-can-stack-stx",
-              [
-                Cl.tuple({
-                  version: Cl.buffer(Uint8Array.from([version])),
-                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
-                }),
-                Cl.uint(amount_ustx),
-                Cl.uint(first_rew_cycle),
-                Cl.uint(num_cycles),
-              ],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.ResponseErr));
-            assert(isClarityType(actual.value, ClarityType.Int));
-            expect(actual).toBeErr(Cl.int(expectedResponseErr));
-          }
-        )
-      );
-    });
+  it("should return (err 13) minimal-can-stack-stx for pox addresses having version > 6", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({
+          min: 7,
+          max: 255,
+        }),
+        fc.array(fc.nat({ max: 255 }), {
+          maxLength: 32,
+        }),
+        fc.bigInt({
+          min: MIN_AMOUNT_USTX,
+          max: MAX_CLAR_UINT,
+        }),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-pox-info",
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+          const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "minimal-can-stack-stx",
+            [
+              Cl.tuple({
+                version: Cl.buffer(Uint8Array.from([version])),
+                hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
+        }
+      )
+    );
+  });
 
-    it("should return (err 13) minimal-can-stack-stx for versions 0-4 pox addresses having hasbytes longer than 20", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.integer({ min: 0, max: 4 }),
-          fc.array(fc.nat({ max: 255 }), {
-            minLength: 21,
-            maxLength: 32,
-          }),
-          fc.bigInt({
-            min: MIN_AMOUNT_USTX,
-            max: MAX_CLAR_UINT,
-          }),
-          fc.nat(),
-          fc.integer({ min: 1, max: 12 }),
-          (
-            caller,
-            version,
-            hashbytes,
-            amount_ustx,
-            first_rew_cycle,
-            num_cycles
-          ) => {
-            // Arrange
-            const { result: pox_4_info } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-pox-info",
-              [],
-              caller
-            );
-            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-            const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "minimal-can-stack-stx",
-              [
-                Cl.tuple({
-                  version: Cl.buffer(Uint8Array.from([version])),
-                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
-                }),
-                Cl.uint(amount_ustx),
-                Cl.uint(first_rew_cycle),
-                Cl.uint(num_cycles),
-              ],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.ResponseErr));
-            assert(isClarityType(actual.value, ClarityType.Int));
-            expect(actual).toBeErr(Cl.int(expectedResponseErr));
-          }
-        )
-      );
-    });
+  it("should return (err 13) minimal-can-stack-stx for versions 0-4 pox addresses having hasbytes longer than 20", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 0, max: 4 }),
+        fc.array(fc.nat({ max: 255 }), {
+          minLength: 21,
+          maxLength: 32,
+        }),
+        fc.bigInt({
+          min: MIN_AMOUNT_USTX,
+          max: MAX_CLAR_UINT,
+        }),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-pox-info",
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+          const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "minimal-can-stack-stx",
+            [
+              Cl.tuple({
+                version: Cl.buffer(Uint8Array.from([version])),
+                hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
+        }
+      )
+    );
+  });
 
-    it("should return (err 13) minimal-can-stack-stx for versions 0-4 pox addresses having hasbytes shorter than 20", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.integer({ min: 0, max: 4 }),
-          fc.array(fc.nat({ max: 255 }), {
-            maxLength: 19,
-          }),
-          fc.bigInt({
-            min: MIN_AMOUNT_USTX,
-            max: MAX_CLAR_UINT,
-          }),
-          fc.nat(),
-          fc.integer({ min: 1, max: 12 }),
-          (
-            caller,
-            version,
-            hashbytes,
-            amount_ustx,
-            first_rew_cycle,
-            num_cycles
-          ) => {
-            // Arrange
-            const { result: pox_4_info } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-pox-info",
-              [],
-              caller
-            );
-            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-            const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "minimal-can-stack-stx",
-              [
-                Cl.tuple({
-                  version: Cl.buffer(Uint8Array.from([version])),
-                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
-                }),
-                Cl.uint(amount_ustx),
-                Cl.uint(first_rew_cycle),
-                Cl.uint(num_cycles),
-              ],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.ResponseErr));
-            assert(isClarityType(actual.value, ClarityType.Int));
-            expect(actual).toBeErr(Cl.int(expectedResponseErr));
-          }
-        )
-      );
-    });
+  it("should return (err 13) minimal-can-stack-stx for versions 0-4 pox addresses having hasbytes shorter than 20", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 0, max: 4 }),
+        fc.array(fc.nat({ max: 255 }), {
+          maxLength: 19,
+        }),
+        fc.bigInt({
+          min: MIN_AMOUNT_USTX,
+          max: MAX_CLAR_UINT,
+        }),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-pox-info",
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+          const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "minimal-can-stack-stx",
+            [
+              Cl.tuple({
+                version: Cl.buffer(Uint8Array.from([version])),
+                hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
+        }
+      )
+    );
+  });
 
-    it("should return (err 13) minimal-can-stack-stx for versions 5/6 pox addresses having hashbytes shorter than 32", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.integer({ min: 0, max: 4 }),
-          fc.array(fc.nat({ max: 255 }), {
-            maxLength: 31,
-          }),
-          fc.bigInt({
-            min: MIN_AMOUNT_USTX,
-            max: MAX_CLAR_UINT,
-          }),
-          fc.nat(),
-          fc.integer({ min: 1, max: 12 }),
-          (
-            caller,
-            version,
-            hashbytes,
-            amount_ustx,
-            first_rew_cycle,
-            num_cycles
-          ) => {
-            // Arrange
-            const { result: pox_4_info } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-pox-info",
-              [],
-              caller
-            );
-            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-            const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "minimal-can-stack-stx",
-              [
-                Cl.tuple({
-                  version: Cl.buffer(Uint8Array.from([version])),
-                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
-                }),
-                Cl.uint(amount_ustx),
-                Cl.uint(first_rew_cycle),
-                Cl.uint(num_cycles),
-              ],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.ResponseErr));
-            assert(isClarityType(actual.value, ClarityType.Int));
-            expect(actual).toBeErr(Cl.int(expectedResponseErr));
-          }
-        )
-      );
-    });
+  it("should return (err 13) minimal-can-stack-stx for versions 5/6 pox addresses having hashbytes shorter than 32", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 0, max: 4 }),
+        fc.array(fc.nat({ max: 255 }), {
+          maxLength: 31,
+        }),
+        fc.bigInt({
+          min: MIN_AMOUNT_USTX,
+          max: MAX_CLAR_UINT,
+        }),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-pox-info",
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+          const expectedResponseErr = ERR_STACKING_INVALID_POX_ADDRESS;
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "minimal-can-stack-stx",
+            [
+              Cl.tuple({
+                version: Cl.buffer(Uint8Array.from([version])),
+                hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
+        }
+      )
+    );
+  });
 
-    it("should return (err 2) minimal-can-stack-stx for lock period > 12", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.integer({ min: 0, max: 6 }),
-          fc.array(fc.nat({ max: 255 })),
-          fc.bigInt({
-            min: MIN_AMOUNT_USTX,
-            max: MAX_CLAR_UINT,
-          }),
-          fc.nat(),
-          fc.integer({ min: 13 }),
-          (
-            caller,
-            version,
-            hashbytes,
-            amount_ustx,
-            first_rew_cycle,
-            num_cycles
-          ) => {
-            // Arrange
-            const { result: pox_4_info } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-pox-info",
-              [],
-              caller
-            );
-            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-            const expectedResponseErr = ERR_STACKING_INVALID_LOCK_PERIOD;
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "minimal-can-stack-stx",
-              [
-                Cl.tuple({
-                  version: Cl.buffer(Uint8Array.from([version])),
-                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
-                }),
-                Cl.uint(amount_ustx),
-                Cl.uint(first_rew_cycle),
-                Cl.uint(num_cycles),
-              ],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.ResponseErr));
-            assert(isClarityType(actual.value, ClarityType.Int));
-            expect(actual).toBeErr(Cl.int(expectedResponseErr));
-          }
-        )
-      );
-    });
+  it("should return (err 2) minimal-can-stack-stx for lock period > 12", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 0, max: 6 }),
+        fc.array(fc.nat({ max: 255 })),
+        fc.bigInt({
+          min: MIN_AMOUNT_USTX,
+          max: MAX_CLAR_UINT,
+        }),
+        fc.nat(),
+        fc.integer({ min: 13 }),
+        (
+          caller,
+          version,
+          hashbytes,
+          amount_ustx,
+          first_rew_cycle,
+          num_cycles
+        ) => {
+          // Arrange
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-pox-info",
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+          const expectedResponseErr = ERR_STACKING_INVALID_LOCK_PERIOD;
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "minimal-can-stack-stx",
+            [
+              Cl.tuple({
+                version: Cl.buffer(Uint8Array.from([version])),
+                hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
+        }
+      )
+    );
+  });
 
-    it("should return (err 18) minimal-can-stack-stx for amount == 0", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.integer({ min: 0, max: 6 }),
-          fc.array(fc.nat({ max: 255 }), { maxLength: 32 }),
-          fc.nat(),
-          fc.integer({ min: 1, max: 12 }),
-          (caller, version, hashbytes, first_rew_cycle, num_cycles) => {
-            // Arrange
-            const amount_ustx = 0;
-            const { result: pox_4_info } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-pox-info",
-              [],
-              caller
-            );
-            assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
-            assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
-            const expectedResponseErr = ERR_STACKING_INVALID_AMOUNT;
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "minimal-can-stack-stx",
-              [
-                Cl.tuple({
-                  version: Cl.buffer(Uint8Array.from([version])),
-                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
-                }),
-                Cl.uint(amount_ustx),
-                Cl.uint(first_rew_cycle),
-                Cl.uint(num_cycles),
-              ],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.ResponseErr));
-            assert(isClarityType(actual.value, ClarityType.Int));
-            expect(actual).toBeErr(Cl.int(expectedResponseErr));
-          }
-        )
-      );
-    });
+  it("should return (err 18) minimal-can-stack-stx for amount == 0", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.integer({ min: 0, max: 6 }),
+        fc.array(fc.nat({ max: 255 }), { maxLength: 32 }),
+        fc.nat(),
+        fc.integer({ min: 1, max: 12 }),
+        (caller, version, hashbytes, first_rew_cycle, num_cycles) => {
+          // Arrange
+          const amount_ustx = 0;
+          const { result: pox_4_info } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-pox-info",
+            [],
+            caller
+          );
+          assert(isClarityType(pox_4_info, ClarityType.ResponseOk));
+          assert(isClarityType(pox_4_info.value, ClarityType.Tuple));
+          const expectedResponseErr = ERR_STACKING_INVALID_AMOUNT;
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "minimal-can-stack-stx",
+            [
+              Cl.tuple({
+                version: Cl.buffer(Uint8Array.from([version])),
+                hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(amount_ustx),
+              Cl.uint(first_rew_cycle),
+              Cl.uint(num_cycles),
+            ],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
+        }
+      )
+    );
+  });
 
-    it("should return none get-check-delegation", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          (caller) => {
-            // Arrange
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-check-delegation",
-              [Cl.principal(caller)],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.OptionalNone));
-          }
-        )
-      );
-    });
+  it("should return none get-check-delegation", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        (caller) => {
+          // Arrange
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-check-delegation",
+            [Cl.principal(caller)],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.OptionalNone));
+        }
+      )
+    );
+  });
 
-    it("should return none get-delegation-info", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          (caller) => {
-            // Arrange
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-delegation-info",
-              [Cl.principal(caller)],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.OptionalNone));
-          }
-        )
-      );
-    });
+  it("should return none get-delegation-info", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        (caller) => {
+          // Arrange
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-delegation-info",
+            [Cl.principal(caller)],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.OptionalNone));
+        }
+      )
+    );
+  });
+
+  it("should return correct get-pox-info", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        (caller) => {
+          // Arrange
+          const expected_reward_cycle_id = 0,
+            expected_first_burn_block_height = 0;
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-pox-info",
+            [],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseOk));
+          assert(isClarityType(actual.value, ClarityType.Tuple));
+          expect(actual.value.data["first-burnchain-block-height"]).toBeUint(
+            expected_first_burn_block_height
+          );
+          expect(actual.value.data["min-amount-ustx"]).toBeUint(
+            MIN_AMOUNT_USTX
+          );
+          expect(actual.value.data["prepare-cycle-length"]).toBeUint(
+            TESTNET_PREPARE_CYCLE_LENGTH
+          );
+          expect(actual.value.data["reward-cycle-id"]).toBeUint(
+            expected_reward_cycle_id
+          );
+          expect(actual.value.data["reward-cycle-length"]).toBeUint(
+            TESTNET_REWARD_CYCLE_LENGTH
+          );
+          expect(actual.value.data["total-liquid-supply-ustx"]).toBeUint(
+            INITIAL_TOTAL_LIQ_SUPPLY
+          );
+        }
+      )
+    );
+  });
 
-    it("should return correct get-pox-info", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          (caller) => {
-            // Arrange
-            const expected_reward_cycle_id = 0,
-              expected_first_burn_block_height = 0;
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-pox-info",
-              [],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.ResponseOk));
-            assert(isClarityType(actual.value, ClarityType.Tuple));
-            expect(actual.value.data["first-burnchain-block-height"]).toBeUint(
-              expected_first_burn_block_height
-            );
-            expect(actual.value.data["min-amount-ustx"]).toBeUint(
-              MIN_AMOUNT_USTX
-            );
-            expect(actual.value.data["prepare-cycle-length"]).toBeUint(
-              TESTNET_PREPARE_CYCLE_LENGTH
-            );
-            expect(actual.value.data["reward-cycle-id"]).toBeUint(
-              expected_reward_cycle_id
-            );
-            expect(actual.value.data["reward-cycle-length"]).toBeUint(
-              TESTNET_REWARD_CYCLE_LENGTH
-            );
-            expect(actual.value.data["total-liquid-supply-ustx"]).toBeUint(
-              INITIAL_TOTAL_LIQ_SUPPLY
-            );
-          }
-        )
-      );
-    });
+  it("should return none get-allowance-contract-caller", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.constantFrom(...simnet.getAccounts().values()),
+        (caller, sender, contract_caller) => {
+          // Arrange
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-allowance-contract-callers",
+            [Cl.principal(sender), Cl.principal(contract_caller)],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.OptionalNone));
+        }
+      )
+    );
+  });
 
-    it("should return none get-allowance-contract-caller", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.constantFrom(...simnet.getAccounts().values()),
-          (caller, sender, contract_caller) => {
-            // Arrange
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-allowance-contract-callers",
-              [Cl.principal(sender), Cl.principal(contract_caller)],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.OptionalNone));
-          }
-        )
-      );
-    });
+  it("should return some(until-burn-ht: none) get-allowance-contract-caller after allow-contract-caller", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.constantFrom(...simnet.getAccounts().values()),
+        (caller, sender, contract_caller) => {
+          // Arrange
+          const { result: allow } = simnet.callPublicFn(
+            "pox-4",
+            "allow-contract-caller",
+            [Cl.principal(contract_caller), Cl.none()],
+            sender
+          );
+          assert(isClarityType(allow, ClarityType.ResponseOk));
+          assert(isClarityType(allow.value, ClarityType.BoolTrue));
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-allowance-contract-callers",
+            [Cl.principal(sender), Cl.principal(contract_caller)],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.OptionalSome));
+          assert(isClarityType(actual.value, ClarityType.Tuple));
+          expect(actual.value).toBeTuple({ "until-burn-ht": Cl.none() });
+        }
+      )
+    );
+  });
 
-    it("should return some(until-burn-ht: none) get-allowance-contract-caller after allow-contract-caller", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.constantFrom(...simnet.getAccounts().values()),
-          (caller, sender, contract_caller) => {
-            // Arrange
-            const { result: allow } = simnet.callPublicFn(
-              "pox-4",
-              "allow-contract-caller",
-              [Cl.principal(contract_caller), Cl.none()],
-              sender
-            );
-            assert(isClarityType(allow, ClarityType.ResponseOk));
-            assert(isClarityType(allow.value, ClarityType.BoolTrue));
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-allowance-contract-callers",
-              [Cl.principal(sender), Cl.principal(contract_caller)],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.OptionalSome));
-            assert(isClarityType(actual.value, ClarityType.Tuple));
-            expect(actual.value).toBeTuple({ "until-burn-ht": Cl.none() });
-          }
-        )
-      );
-    });
+  it("should return u0 get-num-reward-set-pox-addresses", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.nat(),
+        (caller, reward_cycle) => {
+          // Arrange
+          const expected = 0;
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-num-reward-set-pox-addresses",
+            [Cl.uint(reward_cycle)],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.UInt));
+          expect(actual).toBeUint(expected);
+        }
+      )
+    );
+  });
 
-    it("should return u0 get-num-reward-set-pox-addresses", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.nat(),
-          (caller, reward_cycle) => {
-            // Arrange
-            const expected = 0;
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-num-reward-set-pox-addresses",
-              [Cl.uint(reward_cycle)],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.UInt));
-            expect(actual).toBeUint(expected);
-          }
-        )
-      );
-    });
+  it("should return none get-partial-stacked-by-cycle", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.nat({ max: 6 }),
+        fc.array(fc.nat({ max: 255 }), { maxLength: 32 }),
+        fc.nat(),
+        fc.constantFrom(...simnet.getAccounts().values()),
+        (caller, version, hashbytes, reward_cycle, sender) => {
+          // Arrange
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-partial-stacked-by-cycle",
+            [
+              Cl.tuple({
+                version: Cl.buffer(Uint8Array.from([version])),
+                hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(reward_cycle),
+              Cl.principal(sender),
+            ],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.OptionalNone));
+        }
+      )
+    );
+  });
 
-    it("should return none get-partial-stacked-by-cycle", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.nat({ max: 6 }),
-          fc.array(fc.nat({ max: 255 }), { maxLength: 32 }),
-          fc.nat(),
-          fc.constantFrom(...simnet.getAccounts().values()),
-          (caller, version, hashbytes, reward_cycle, sender) => {
-            // Arrange
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-partial-stacked-by-cycle",
-              [
-                Cl.tuple({
-                  version: Cl.buffer(Uint8Array.from([version])),
-                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
-                }),
-                Cl.uint(reward_cycle),
-                Cl.principal(sender),
-              ],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.OptionalNone));
-          }
-        )
-      );
-    });
+  it("should return correct hash get-signer-key-message-hash", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.nat({ max: 6 }),
+        fc.array(fc.nat({ max: 255 }), { maxLength: 32 }),
+        fc.nat(),
+        fc.nat(),
+        fc.nat(),
+        fc.nat(),
+        (
+          caller,
+          version,
+          hashbytes,
+          reward_cycle,
+          period,
+          max_amount,
+          auth_id
+        ) => {
+          // Arrange
 
-    it("should return correct hash get-signer-key-message-hash", () => {
-      fc.assert(
-        fc.property(
-          fc.constantFrom(...simnet.getAccounts().values()),
-          fc.nat({ max: 6 }),
-          fc.array(fc.nat({ max: 255 }), { maxLength: 32 }),
-          fc.nat(),
-          fc.nat(),
-          // fc.asciiString({ maxLength: 10, minLength: 1 }),
-          fc.nat(),
-          fc.nat(),
-          (
-            caller,
+          const signer_key_message_hash = buildSignerKeyMessageHash(
             version,
             hashbytes,
             reward_cycle,
+            "topic",
             period,
-            // topic,
             max_amount,
             auth_id
-          ) => {
-            // Arrange
-            // clarinet bug string:
-            // r;NT="
-
-            const signer_key_message_hash = buildSignerKeyMessageHash(
-              version,
-              hashbytes,
-              reward_cycle,
-              "topic",
-              period,
-              max_amount,
-              auth_id
-            );
-            // Act
-            const { result: actual } = simnet.callReadOnlyFn(
-              "pox-4",
-              "get-signer-key-message-hash",
-              [
-                Cl.tuple({
-                  version: Cl.buffer(Uint8Array.from([version])),
-                  hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
-                }),
-                Cl.uint(reward_cycle),
-                Cl.stringAscii("topic"),
-                Cl.uint(period),
-                Cl.uint(max_amount),
-                Cl.uint(auth_id),
-              ],
-              caller
-            );
-            // Assert
-            assert(isClarityType(actual, ClarityType.Buffer));
-            expect(actual).toBeBuff(signer_key_message_hash);
-          }
-        )
-      );
-    });
-    // verify-signer-key-sig
+          );
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "get-signer-key-message-hash",
+            [
+              Cl.tuple({
+                version: Cl.buffer(Uint8Array.from([version])),
+                hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(reward_cycle),
+              Cl.stringAscii("topic"),
+              Cl.uint(period),
+              Cl.uint(max_amount),
+              Cl.uint(auth_id),
+            ],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.Buffer));
+          expect(actual).toBeBuff(signer_key_message_hash);
+        }
+      )
+    );
   });
+  // verify-signer-key-sig
 });

From 27d68f48ec960d7df78f14f0b22e3a854c0bcb5a Mon Sep 17 00:00:00 2001
From: BowTiedRadone <bowtiedradone@gmail.com>
Date: Fri, 8 Mar 2024 18:53:36 +0200
Subject: [PATCH 1094/1166] added tests for verify-signer-key-sig

---
 .../tests/pox-4/pox-4.prop.test.ts            | 257 +++++++++++++++++-
 1 file changed, 249 insertions(+), 8 deletions(-)

diff --git a/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts b/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
index b82d212477..485d42eebd 100644
--- a/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
+++ b/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
@@ -2,8 +2,11 @@ import {
   Cl,
   ClarityType,
   ClarityValue,
+  createStacksPrivateKey,
   isClarityType,
+  pubKeyfromPrivKey,
   serializeCV,
+  signWithKey,
 } from "@stacks/transactions";
 import fc from "fast-check";
 import { assert, describe, expect, it } from "vitest";
@@ -24,14 +27,39 @@ const ERR_STACKING_INVALID_LOCK_PERIOD = 2;
 const ERR_STACKING_THRESHOLD_NOT_MET = 11;
 const ERR_STACKING_INVALID_POX_ADDRESS = 13;
 const ERR_STACKING_INVALID_AMOUNT = 18;
+const ERR_INVALID_SIGNATURE_PUBKEY = 35;
+const ERR_SIGNER_AUTH_AMOUNT_TOO_HIGH = 38;
+// Private Keys
+const privateKeyMapping: {
+  [key: string]: string;
+} = {
+  ST1PQHQKV0RJXZFY1DGX8MNSNYVE3VGZJSRTPGZGM:
+    "753b7cc01a1a2e86221266a154af739463fce51219d97e4f856cd7200c3bd2a601",
+  ST1SJ3DTE5DN7X54YDH5D64R3BCB6A2AG2ZQ8YPD5:
+    "7287ba251d44a4d3fd9276c88ce34c5c52a038955511cccaf77e61068649c17801",
+  ST2CY5V39NHDPWSXMW9QDT3HC3GD6Q6XX4CFRK9AG:
+    "530d9f61984c888536871c6573073bdfc0058896dc1adfe9a6a10dfacadc209101",
+  ST2JHG361ZXG51QTKY2NQCVBPPRRE2KZB1HR05NNC:
+    "d655b2523bcd65e34889725c73064feb17ceb796831c0e111ba1a552b0f31b3901",
+  ST2NEB84ASENDXKYGJPQW86YXQCEFEX2ZQPG87ND:
+    "f9d7206a47f14d2870c163ebab4bf3e70d18f5d14ce1031f3902fbbc894fe4c701",
+  ST2REHHS5J3CERCRBEPMGH7921Q6PYKAADT7JP2VB:
+    "3eccc5dac8056590432db6a35d52b9896876a3d5cbdea53b72400bc9c2099fe801",
+  ST3AM1A56AK2C1XAFJ4115ZSV26EB49BVQ10MGCS0:
+    "7036b29cb5e235e5fd9b09ae3e8eec4404e44906814d5d01cbca968a60ed4bfb01",
+  ST3PF13W7Z0RRM42A8VZRVFQ75SV1K26RXEP8YGKJ:
+    "b463f0df6c05d2f156393eee73f8016c5372caa0e9e29a901bb7171d90dc4f1401",
+  ST3NBRSFKX28FQ2ZJ1MAKX58HKHSDGNV5N7R21XCP:
+    "6a1a754ba863d7bab14adbbc3f8ebb090af9e871ace621d3e5ab634e1422885e01",
+  STNHKEPYEPJ8ET55ZZ0M5A34J0R3N5FM2CMMMAZ6:
+    "de433bdfa14ec43aa1098d5be594c8ffb20a31485ff9de2923b2689471c401b801",
+};
 
-function sha256(data: Buffer): Buffer {
-  return createHash("sha256").update(data).digest();
-}
+const sha256 = (data: Buffer): Buffer =>
+  createHash("sha256").update(data).digest();
 
-function structuredDataHash(structuredData: ClarityValue): Buffer {
-  return sha256(Buffer.from(serializeCV(structuredData)));
-}
+const structuredDataHash = (structuredData: ClarityValue): Buffer =>
+  sha256(Buffer.from(serializeCV(structuredData)));
 
 const generateDomainHash = (): ClarityValue =>
   Cl.tuple({
@@ -64,7 +92,7 @@ const generateMessageHash = (
 const generateMessagePrefixBuffer = (prefix: string) =>
   Buffer.from(prefix, "hex");
 
-export const buildSignerKeyMessageHash = (
+const buildSignerKeyMessageHash = (
   version: number,
   hashbytes: number[],
   reward_cycle: number,
@@ -96,6 +124,14 @@ export const buildSignerKeyMessageHash = (
   return signer_key_message_hash;
 };
 
+const signMessageHash = (privateKey: string, messageHash: Buffer) => {
+  const data = signWithKey(
+    createStacksPrivateKey(privateKey),
+    messageHash.toString("hex")
+  ).data;
+  return Buffer.from(data.slice(2) + data.slice(0, 2), "hex");
+};
+
 describe("test pox-4 contract read only functions", () => {
   it("should return correct reward-cycle-to-burn-height", () => {
     fc.assert(
@@ -1593,5 +1629,210 @@ describe("test pox-4 contract read only functions", () => {
       )
     );
   });
-  // verify-signer-key-sig
+
+  it("should return (ok true) verify-signer-key-sig called with correct data", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.nat({ max: 6 }),
+        fc.array(fc.nat({ max: 255 }), { maxLength: 32 }),
+        fc.nat(),
+        fc.nat(),
+        fc.nat(),
+        fc.nat(),
+        fc.nat(),
+        (
+          caller,
+          version,
+          hashbytes,
+          reward_cycle,
+          period,
+          amount,
+          max_amount,
+          auth_id
+        ) => {
+          // Arrange
+          fc.pre(amount <= max_amount);
+          const signer_private_key = privateKeyMapping[caller] ?? "";
+          const signer_key_message_hash = buildSignerKeyMessageHash(
+            version,
+            hashbytes,
+            reward_cycle,
+            "topic",
+            period,
+            max_amount,
+            auth_id
+          );
+          const signer_sig = signMessageHash(
+            signer_private_key,
+            signer_key_message_hash
+          );
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "verify-signer-key-sig",
+            [
+              Cl.tuple({
+                version: Cl.buffer(Uint8Array.from([version])),
+                hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(reward_cycle),
+              Cl.stringAscii("topic"),
+              Cl.uint(period),
+              Cl.some(Cl.buffer(signer_sig)),
+              Cl.buffer(pubKeyfromPrivKey(signer_private_key).data),
+              Cl.uint(amount),
+              Cl.uint(max_amount),
+              Cl.uint(auth_id),
+            ],
+            caller
+          );
+          assert(isClarityType(actual, ClarityType.ResponseOk));
+          assert(isClarityType(actual.value, ClarityType.BoolTrue));
+          expect(actual).toBeOk(Cl.bool(true));
+          expect(actual.value).toBeBool(true);
+        }
+      )
+    );
+  });
+
+  it("should return (err 35) verify-signer-key-sig called with wrong public key", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.nat({ max: 6 }),
+        fc.array(fc.nat({ max: 255 }), { maxLength: 32 }),
+        fc.nat(),
+        fc.nat(),
+        fc.nat(),
+        fc.nat(),
+        fc.nat(),
+        fc.constantFrom(...simnet.getAccounts().values()),
+        (
+          caller,
+          version,
+          hashbytes,
+          reward_cycle,
+          period,
+          amount,
+          max_amount,
+          auth_id,
+          wrong_address
+        ) => {
+          // Arrange
+          fc.pre(amount <= max_amount);
+          fc.pre(wrong_address !== caller);
+          const expectedResponseErr = ERR_INVALID_SIGNATURE_PUBKEY;
+          const signer_private_key = privateKeyMapping[caller];
+          const wrong_private_key = privateKeyMapping[wrong_address];
+          const signer_key_message_hash = buildSignerKeyMessageHash(
+            version,
+            hashbytes,
+            reward_cycle,
+            "topic",
+            period,
+            max_amount,
+            auth_id
+          );
+          const signer_sig = signMessageHash(
+            signer_private_key,
+            signer_key_message_hash
+          );
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "verify-signer-key-sig",
+            [
+              Cl.tuple({
+                version: Cl.buffer(Uint8Array.from([version])),
+                hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(reward_cycle),
+              Cl.stringAscii("topic"),
+              Cl.uint(period),
+              Cl.some(Cl.buffer(signer_sig)),
+              Cl.buffer(pubKeyfromPrivKey(wrong_private_key).data),
+              Cl.uint(amount),
+              Cl.uint(max_amount),
+              Cl.uint(auth_id),
+            ],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
+          expect(actual.value).toBeInt(expectedResponseErr);
+        }
+      )
+    );
+  });
+
+  it("should return (err 38) verify-signer-key-sig called with wrong public key", () => {
+    fc.assert(
+      fc.property(
+        fc.constantFrom(...simnet.getAccounts().values()),
+        fc.nat({ max: 6 }),
+        fc.array(fc.nat({ max: 255 }), { maxLength: 32 }),
+        fc.nat(),
+        fc.nat(),
+        fc.nat(),
+        fc.nat(),
+        fc.nat(),
+        (
+          caller,
+          version,
+          hashbytes,
+          reward_cycle,
+          period,
+          amount,
+          max_amount,
+          auth_id
+        ) => {
+          // Arrange
+          fc.pre(amount > max_amount);
+          const expectedResponseErr = ERR_SIGNER_AUTH_AMOUNT_TOO_HIGH;
+          const signer_private_key = privateKeyMapping[caller];
+          const signer_key_message_hash = buildSignerKeyMessageHash(
+            version,
+            hashbytes,
+            reward_cycle,
+            "topic",
+            period,
+            max_amount,
+            auth_id
+          );
+          const signer_sig = signMessageHash(
+            signer_private_key,
+            signer_key_message_hash
+          );
+          // Act
+          const { result: actual } = simnet.callReadOnlyFn(
+            "pox-4",
+            "verify-signer-key-sig",
+            [
+              Cl.tuple({
+                version: Cl.buffer(Uint8Array.from([version])),
+                hashbytes: Cl.buffer(Uint8Array.from(hashbytes)),
+              }),
+              Cl.uint(reward_cycle),
+              Cl.stringAscii("topic"),
+              Cl.uint(period),
+              Cl.some(Cl.buffer(signer_sig)),
+              Cl.buffer(pubKeyfromPrivKey(signer_private_key).data),
+              Cl.uint(amount),
+              Cl.uint(max_amount),
+              Cl.uint(auth_id),
+            ],
+            caller
+          );
+          // Assert
+          assert(isClarityType(actual, ClarityType.ResponseErr));
+          assert(isClarityType(actual.value, ClarityType.Int));
+          expect(actual).toBeErr(Cl.int(expectedResponseErr));
+          expect(actual.value).toBeInt(expectedResponseErr);
+        }
+      )
+    );
+  });
 });

From db8f0cce88235005001066b5df1014bd278769f8 Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Fri, 8 Mar 2024 19:28:12 -0500
Subject: [PATCH 1095/1166] chore: log coordinator state

---
 stacks-signer/src/signer.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index b03a2da366..053be6755b 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -367,7 +367,7 @@ impl Signer {
             }
             State::OperationInProgress => {
                 // We cannot execute the next command until the current one is finished...
-                debug!("{self}: Waiting for coordinator {coordinator_id:?} operation to finish...",);
+                debug!("{self}: Waiting for coordinator {coordinator_id:?} operation to finish. Coordinator state = {:?}", self.coordinator.state);
             }
         }
     }

From d56895a600fe8972ffc8a41befad95dea0fc9d6d Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Fri, 8 Mar 2024 18:50:57 -0600
Subject: [PATCH 1096/1166] feat: use block proposal struct for miner ->
 signers comms. check claimed reward-cycle

---
 libsigner/src/events.rs                       | 37 +++++++++++--
 libsigner/src/libsigner.rs                    |  3 +-
 stacks-signer/src/signer.rs                   | 25 +++++++--
 stackslib/src/chainstate/nakamoto/miner.rs    |  4 +-
 .../stacks-node/src/nakamoto_node/miner.rs    | 54 ++++++++++++-------
 5 files changed, 93 insertions(+), 30 deletions(-)

diff --git a/libsigner/src/events.rs b/libsigner/src/events.rs
index 0d73b9579a..ce26447e5a 100644
--- a/libsigner/src/events.rs
+++ b/libsigner/src/events.rs
@@ -50,11 +50,22 @@ use wsts::state_machine::signer;
 use crate::http::{decode_http_body, decode_http_request};
 use crate::{EventError, SignerMessage};
 
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+/// BlockProposal sent to signers
+pub struct BlockProposalSigners {
+    /// The block itself
+    pub block: NakamotoBlock,
+    /// The burn height the block is mined during
+    pub burn_height: u64,
+    /// The reward cycle the block is mined during
+    pub reward_cycle: u64,
+}
+
 /// Event enum for newly-arrived signer subscribed events
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub enum SignerEvent {
     /// The miner proposed blocks for signers to observe and sign
-    ProposedBlocks(Vec<NakamotoBlock>),
+    ProposedBlocks(Vec<BlockProposalSigners>),
     /// The signer messages for other signers and miners to observe
     /// The u32 is the signer set to which the message belongs (either 0 or 1)
     SignerMessages(u32, Vec<SignerMessage>),
@@ -64,6 +75,26 @@ pub enum SignerEvent {
     StatusCheck,
 }
 
+impl StacksMessageCodec for BlockProposalSigners {
+    fn consensus_serialize<W: Write>(&self, fd: &mut W) -> Result<(), CodecError> {
+        self.block.consensus_serialize(fd)?;
+        self.burn_height.consensus_serialize(fd)?;
+        self.reward_cycle.consensus_serialize(fd)?;
+        Ok(())
+    }
+
+    fn consensus_deserialize<R: Read>(fd: &mut R) -> Result<Self, CodecError> {
+        let block = NakamotoBlock::consensus_deserialize(fd)?;
+        let burn_height = u64::consensus_deserialize(fd)?;
+        let reward_cycle = u64::consensus_deserialize(fd)?;
+        Ok(BlockProposalSigners {
+            block,
+            burn_height,
+            reward_cycle,
+        })
+    }
+}
+
 /// Trait to implement a stop-signaler for the event receiver thread.
 /// The caller calls `send()` and the event receiver loop (which lives in a separate thread) will
 /// terminate.
@@ -337,10 +368,10 @@ fn process_stackerdb_event(
         .map_err(|e| EventError::Deserialize(format!("Could not decode body to JSON: {:?}", &e)))?;
 
     let signer_event = if event.contract_id == boot_code_id(MINERS_NAME, is_mainnet) {
-        let blocks: Vec<NakamotoBlock> = event
+        let blocks: Vec<BlockProposalSigners> = event
             .modified_slots
             .iter()
-            .filter_map(|chunk| read_next::<NakamotoBlock, _>(&mut &chunk.data[..]).ok())
+            .filter_map(|chunk| read_next::<BlockProposalSigners, _>(&mut &chunk.data[..]).ok())
             .collect();
         SignerEvent::ProposedBlocks(blocks)
     } else if event.contract_id.name.to_string().starts_with(SIGNERS_NAME)
diff --git a/libsigner/src/libsigner.rs b/libsigner/src/libsigner.rs
index e48f4014e1..1ae699d6ec 100644
--- a/libsigner/src/libsigner.rs
+++ b/libsigner/src/libsigner.rs
@@ -45,7 +45,8 @@ mod session;
 
 pub use crate::error::{EventError, RPCError};
 pub use crate::events::{
-    EventReceiver, EventStopSignaler, SignerEvent, SignerEventReceiver, SignerStopSignaler,
+    BlockProposalSigners, EventReceiver, EventStopSignaler, SignerEvent, SignerEventReceiver,
+    SignerStopSignaler,
 };
 pub use crate::messages::{
     BlockRejection, BlockResponse, RejectCode, SignerMessage, BLOCK_MSG_ID, TRANSACTIONS_MSG_ID,
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index 053be6755b..4159eedf36 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -24,7 +24,9 @@ use blockstack_lib::chainstate::stacks::boot::SIGNERS_VOTING_FUNCTION_NAME;
 use blockstack_lib::chainstate::stacks::StacksTransaction;
 use blockstack_lib::net::api::postblock_proposal::BlockValidateResponse;
 use hashbrown::HashSet;
-use libsigner::{BlockRejection, BlockResponse, RejectCode, SignerEvent, SignerMessage};
+use libsigner::{
+    BlockProposalSigners, BlockRejection, BlockResponse, RejectCode, SignerEvent, SignerMessage,
+};
 use serde_derive::{Deserialize, Serialize};
 use slog::{slog_debug, slog_error, slog_info, slog_warn};
 use stacks_common::codec::{read_next, StacksMessageCodec};
@@ -497,17 +499,30 @@ impl Signer {
     }
 
     /// Handle proposed blocks submitted by the miners to stackerdb
-    fn handle_proposed_blocks(&mut self, stacks_client: &StacksClient, blocks: &[NakamotoBlock]) {
-        for block in blocks {
+    fn handle_proposed_blocks(
+        &mut self,
+        stacks_client: &StacksClient,
+        proposals: &[BlockProposalSigners],
+    ) {
+        for proposal in proposals {
+            if proposal.reward_cycle != self.reward_cycle {
+                debug!(
+                    "Signer #{}: Received proposal for block outside of my reward cycle, ignoring.",
+                    self.signer_id;
+                    "proposal_reward_cycle" => proposal.reward_cycle,
+                    "proposal_burn_height" => proposal.burn_height,
+                );
+                continue;
+            }
             // Store the block in our cache
             self.signer_db
-                .insert_block(&BlockInfo::new(block.clone()))
+                .insert_block(&BlockInfo::new(proposal.block.clone()))
                 .unwrap_or_else(|e| {
                     error!("{self}: Failed to insert block in DB: {e:?}");
                 });
             // Submit the block for validation
             stacks_client
-                .submit_block_for_validation(block.clone())
+                .submit_block_for_validation(proposal.block.clone())
                 .unwrap_or_else(|e| {
                     warn!("{self}: Failed to submit block for validation: {e:?}");
                 });
diff --git a/stackslib/src/chainstate/nakamoto/miner.rs b/stackslib/src/chainstate/nakamoto/miner.rs
index 5edeac4c63..961fd32db0 100644
--- a/stackslib/src/chainstate/nakamoto/miner.rs
+++ b/stackslib/src/chainstate/nakamoto/miner.rs
@@ -524,11 +524,11 @@ impl NakamotoBlockBuilder {
     /// Returns Some(chunk) if the given key corresponds to one of the expected miner slots
     /// Returns None if not
     /// Returns an error on signing or DB error
-    pub fn make_stackerdb_block_proposal(
+    pub fn make_stackerdb_block_proposal<T: StacksMessageCodec>(
         sortdb: &SortitionDB,
         tip: &BlockSnapshot,
         stackerdbs: &StackerDBs,
-        block: &NakamotoBlock,
+        block: &T,
         miner_privkey: &StacksPrivateKey,
         miners_contract_id: &QualifiedContractIdentifier,
     ) -> Result<Option<StackerDBChunkData>, Error> {
diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index 4a4411479d..c7e772b20e 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -23,8 +23,8 @@ use clarity::vm::clarity::ClarityConnection;
 use clarity::vm::types::{PrincipalData, QualifiedContractIdentifier};
 use hashbrown::HashSet;
 use libsigner::{
-    BlockResponse, RejectCode, SignerMessage, SignerSession, StackerDBSession, BLOCK_MSG_ID,
-    TRANSACTIONS_MSG_ID,
+    BlockProposalSigners, BlockResponse, RejectCode, SignerMessage, SignerSession,
+    StackerDBSession, BLOCK_MSG_ID, TRANSACTIONS_MSG_ID,
 };
 use stacks::burnchains::{Burnchain, BurnchainParameters};
 use stacks::chainstate::burn::db::sortdb::SortitionDB;
@@ -199,37 +199,53 @@ impl BlockMinerThread {
             .expect("FATAL: could not open sortition DB");
             let tip = SortitionDB::get_canonical_burn_chain_tip(sort_db.conn())
                 .expect("FATAL: could not retrieve chain tip");
+            let reward_cycle = self
+                .burnchain
+                .pox_constants
+                .block_height_to_reward_cycle(
+                    self.burnchain.first_block_height,
+                    self.burn_block.block_height,
+                )
+                .expect("FATAL: building on a burn block that is before the first burn block");
             if let Some(new_block) = new_block {
-                match NakamotoBlockBuilder::make_stackerdb_block_proposal(
+                let proposal_msg = BlockProposalSigners {
+                    block: new_block.clone(),
+                    burn_height: self.burn_block.block_height,
+                    reward_cycle,
+                };
+                let proposal = match NakamotoBlockBuilder::make_stackerdb_block_proposal(
                     &sort_db,
                     &tip,
                     &stackerdbs,
-                    &new_block,
+                    &proposal_msg,
                     &miner_privkey,
                     &miners_contract_id,
                 ) {
-                    Ok(Some(chunk)) => {
-                        // Propose the block to the observing signers through the .miners stackerdb instance
-                        let miner_contract_id = boot_code_id(MINERS_NAME, self.config.is_mainnet());
-                        let mut miners_stackerdb =
-                            StackerDBSession::new(&self.config.node.rpc_bind, miner_contract_id);
-                        match miners_stackerdb.put_chunk(&chunk) {
-                            Ok(ack) => {
-                                info!("Proposed block to stackerdb: {ack:?}");
-                            }
-                            Err(e) => {
-                                warn!("Failed to propose block to stackerdb {e:?}");
-                                return;
-                            }
-                        }
-                    }
+                    Ok(Some(chunk)) => chunk,
                     Ok(None) => {
                         warn!("Failed to propose block to stackerdb: no slot available");
+                        continue;
                     }
                     Err(e) => {
                         warn!("Failed to propose block to stackerdb: {e:?}");
+                        continue;
+                    }
+                };
+
+                // Propose the block to the observing signers through the .miners stackerdb instance
+                let miner_contract_id = boot_code_id(MINERS_NAME, self.config.is_mainnet());
+                let mut miners_stackerdb =
+                    StackerDBSession::new(&self.config.node.rpc_bind, miner_contract_id);
+                match miners_stackerdb.put_chunk(&proposal) {
+                    Ok(ack) => {
+                        info!("Proposed block to stackerdb: {ack:?}");
+                    }
+                    Err(e) => {
+                        warn!("Failed to propose block to stackerdb {e:?}");
+                        return;
                     }
                 }
+
                 self.globals.counters.bump_naka_proposed_blocks();
 
                 if let Err(e) =

From b9c9ece00f64d6a4d03f2d305f4511bfac571f78 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Fri, 8 Mar 2024 21:01:20 -0600
Subject: [PATCH 1097/1166] feat: add a parity check and filter events sent to
 the signer instances

---
 stacks-signer/src/runloop.rs            | 16 ++++++++++++++++
 testnet/stacks-node/src/tests/signer.rs |  4 +++-
 2 files changed, 19 insertions(+), 1 deletion(-)

diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index d131d5884b..4a9a8d528e 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -357,6 +357,22 @@ impl SignerRunLoop<Vec<OperationResult>, RunLoopCommand> for RunLoop {
             error!("Failed to refresh signers: {e}. Signer may have an outdated view of the network. Attempting to process event anyway.");
         }
         for signer in self.stacks_signers.values_mut() {
+            let event_parity = match event {
+                Some(SignerEvent::BlockValidationResponse(_)) => Some(current_reward_cycle % 2),
+                // Block proposal events do have reward cycles, but each proposal has its own cycle,
+                //  and the vec could be heterogenous, so, don't differentiate.
+                Some(SignerEvent::ProposedBlocks(_)) => None,
+                Some(SignerEvent::SignerMessages(msg_parity, ..)) => {
+                    Some(u64::from(msg_parity) % 2)
+                }
+                Some(SignerEvent::StatusCheck) => None,
+                None => None,
+            };
+            let other_signer_parity = (signer.reward_cycle + 1) % 2;
+            if event_parity == Some(other_signer_parity) {
+                continue;
+            }
+
             if let Err(e) = signer.process_event(
                 &self.stacks_client,
                 event.as_ref(),
diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index 54e851be9f..ebdef33d46 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -447,7 +447,9 @@ impl SignerTest {
                             panic!("Received SignError {}", sign_error);
                         }
                         OperationResult::Dkg(point) => {
-                            panic!("Received aggregate_group_key {point}");
+                            // should not panic, because DKG may have just run for the
+                            //   next reward cycle.
+                            info!("Received aggregate_group_key {point}");
                         }
                     }
                 }

From b61b2be0d4d4633cba9a01640b0d82dc8571955d Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Fri, 8 Mar 2024 21:58:00 -0600
Subject: [PATCH 1098/1166] logs: signer block responses to info. display
 formatting for block response

---
 libsigner/src/messages.rs              | 21 +++++++++++++++++++++
 stacks-signer/src/signer.rs            | 11 +++++++----
 stackslib/src/chainstate/stacks/mod.rs |  6 ++++++
 3 files changed, 34 insertions(+), 4 deletions(-)

diff --git a/libsigner/src/messages.rs b/libsigner/src/messages.rs
index 6135312a87..debb432189 100644
--- a/libsigner/src/messages.rs
+++ b/libsigner/src/messages.rs
@@ -823,6 +823,27 @@ pub enum BlockResponse {
     Rejected(BlockRejection),
 }
 
+impl std::fmt::Display for BlockResponse {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            BlockResponse::Accepted(a) => {
+                write!(
+                    f,
+                    "BlockAccepted: signer_sighash = {}, signature = {}",
+                    a.0, a.1
+                )
+            }
+            BlockResponse::Rejected(r) => {
+                write!(
+                    f,
+                    "BlockRejected: signer_sighash = {}, code = {}, reason = {}",
+                    r.reason_code, r.reason, r.signer_signature_hash
+                )
+            }
+        }
+    }
+}
+
 impl BlockResponse {
     /// Create a new accepted BlockResponse for the provided block signer signature hash and signature
     pub fn accepted(hash: Sha512Trunc256Sum, sig: Signature) -> Self {
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index 4159eedf36..e7d78637d9 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -989,15 +989,18 @@ impl Signer {
 
         let block_submission = if block_vote.rejected {
             // We signed a rejection message. Return a rejection message
-            BlockResponse::rejected(block_vote.signer_signature_hash, signature.clone()).into()
+            BlockResponse::rejected(block_vote.signer_signature_hash, signature.clone())
         } else {
             // we agreed to sign the block hash. Return an approval message
-            BlockResponse::accepted(block_vote.signer_signature_hash, signature.clone()).into()
+            BlockResponse::accepted(block_vote.signer_signature_hash, signature.clone())
         };
 
         // Submit signature result to miners to observe
-        debug!("{self}: submit block response {block_submission:?}");
-        if let Err(e) = self.stackerdb.send_message_with_retry(block_submission) {
+        info!("{self}: Submit block response: {block_submission}");
+        if let Err(e) = self
+            .stackerdb
+            .send_message_with_retry(block_submission.into())
+        {
             warn!("{self}: Failed to send block submission to stacker-db: {e:?}");
         }
     }
diff --git a/stackslib/src/chainstate/stacks/mod.rs b/stackslib/src/chainstate/stacks/mod.rs
index 7247a28f7e..f9ad4fff3f 100644
--- a/stackslib/src/chainstate/stacks/mod.rs
+++ b/stackslib/src/chainstate/stacks/mod.rs
@@ -693,6 +693,12 @@ impl FromSql for ThresholdSignature {
     }
 }
 
+impl fmt::Display for ThresholdSignature {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        to_hex(&self.serialize_to_vec()).fmt(f)
+    }
+}
+
 impl ToSql for ThresholdSignature {
     fn to_sql(&self) -> rusqlite::Result<ToSqlOutput> {
         let bytes = self.serialize_to_vec();

From 92325502d21a477e9f8db4057c283566b59a784c Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Fri, 8 Mar 2024 22:05:55 -0600
Subject: [PATCH 1099/1166] logs: better miner assembly and broadcasting
 logging

---
 testnet/stacks-node/src/nakamoto_node/miner.rs | 18 +++++++++++-------
 1 file changed, 11 insertions(+), 7 deletions(-)

diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index c7e772b20e..dc75ef56c4 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -253,6 +253,14 @@ impl BlockMinerThread {
                 {
                     warn!("Error broadcasting block: {e:?}");
                 } else {
+                    info!(
+                        "Miner: Block signed by signer set and broadcasted";
+                        "signer_sighash" => %new_block.header.signer_signature_hash(),
+                        "block_hash" => %new_block.header.block_hash(),
+                        "stacks_block_id" => %new_block.header.block_id(),
+                        "block_height" => new_block.header.chain_length,
+                        "consensus_hash" => %new_block.header.consensus_hash,
+                    );
                     self.globals.coord().announce_new_stacks_block();
                 }
 
@@ -861,15 +869,11 @@ impl BlockMinerThread {
         block.header.miner_signature = miner_signature;
 
         info!(
-            "Miner: Succeeded assembling {} block #{}: {}, with {} txs",
-            if parent_block_info.parent_block_total_burn == 0 {
-                "Genesis"
-            } else {
-                "Stacks"
-            },
+            "Miner: Assembled block #{} for signer set proposal: {}, with {} txs",
             block.header.chain_length,
             block.header.block_hash(),
-            block.txs.len(),
+            block.txs.len();
+            "signer_sighash" => %block.header.signer_signature_hash(),
         );
 
         // last chance -- confirm that the stacks tip is unchanged (since it could have taken long

From 8cdbf08aa5099a2e5b4e256c94b999082e148463 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Fri, 8 Mar 2024 23:27:02 -0600
Subject: [PATCH 1100/1166] logs: add coordinator id to signer binary logging

---
 stacks-signer/src/signer.rs | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index e7d78637d9..aa4c205a25 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -172,8 +172,10 @@ impl std::fmt::Display for Signer {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(
             f,
-            "Reward Cycle #{} Signer #{}",
-            self.reward_cycle, self.signer_id,
+            "Cycle #{} Signer #{}(C:{})",
+            self.reward_cycle,
+            self.signer_id,
+            self.coordinator_selector.get_coordinator().0,
         )
     }
 }
@@ -454,8 +456,9 @@ impl Signer {
             {
                 // We are the coordinator. Trigger a signing round for this block
                 debug!(
-                    "{self}: triggering a signing round over the block {}",
-                    block_info.block.header.block_hash()
+                    "{self}: attempt to trigger a signing round for block";
+                    "signer_sighash" => %block_info.block.header.signer_signature_hash(),
+                    "block_hash" => %block_info.block.header.block_hash(),
                 );
                 self.commands.push_back(Command::Sign {
                     block: block_info.block.clone(),

From a736360ee42a54019f400d950a578697e89552c5 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Sat, 9 Mar 2024 09:30:51 -0600
Subject: [PATCH 1101/1166] logs: improved rejection logging, debug logs in the
 db

---
 stacks-signer/src/signer.rs   | 13 ++++++++++---
 stacks-signer/src/signerdb.rs | 12 ++++++++++++
 2 files changed, 22 insertions(+), 3 deletions(-)

diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index aa4c205a25..5bff83629d 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -592,7 +592,10 @@ impl Signer {
         {
             Some(Some(vote)) => {
                 // Overwrite with our agreed upon value in case another message won majority or the coordinator is trying to cheat...
-                debug!("{self}: set vote for {} to {vote:?}", block_vote.rejected);
+                debug!(
+                    "{self}: Set vote (rejected = {}) to {vote:?}", block_vote.rejected;
+                    "requested_sighash" => %block_vote.signer_signature_hash,
+                );
                 request.message = vote.serialize_to_vec();
                 true
             }
@@ -600,7 +603,10 @@ impl Signer {
                 // We never agreed to sign this block. Reject it.
                 // This can happen if the coordinator received enough votes to sign yes
                 // or no on a block before we received validation from the stacks node.
-                debug!("{self}: Received a signature share request for a block we never agreed to sign. Ignore it.");
+                debug!(
+                    "{self}: Received a signature share request for a block we never agreed to sign. Ignore it.";
+                    "requested_sighash" => %block_vote.signer_signature_hash,
+                );
                 false
             }
             None => {
@@ -608,7 +614,8 @@ impl Signer {
                 // blocks we have seen a Nonce Request for (and subsequent validation)
                 // We are missing the context here necessary to make a decision. Reject the block
                 debug!(
-                    "{self}: Received a signature share request from an unknown block. Reject it."
+                    "{self}: Received a signature share request from an unknown block. Reject it.";
+                    "requested_sighash" => %block_vote.signer_signature_hash,
                 );
                 false
             }
diff --git a/stacks-signer/src/signerdb.rs b/stacks-signer/src/signerdb.rs
index 9b211a603d..fdd2ec6fe6 100644
--- a/stacks-signer/src/signerdb.rs
+++ b/stacks-signer/src/signerdb.rs
@@ -18,6 +18,8 @@ use std::path::Path;
 
 use blockstack_lib::util_lib::db::{query_row, sqlite_open, table_exists, Error as DBError};
 use rusqlite::{Connection, Error as SqliteError, OpenFlags, NO_PARAMS};
+use slog::slog_debug;
+use stacks_common::debug;
 use stacks_common::util::hash::Sha512Trunc256Sum;
 
 use crate::signer::BlockInfo;
@@ -89,6 +91,16 @@ impl SignerDb {
         let block_json =
             serde_json::to_string(&block_info).expect("Unable to serialize block info");
         let hash = &block_info.signer_signature_hash();
+        debug!(
+            "Inserting block_info: sighash = {hash}, vote = {:?}",
+            block_info.vote.as_ref().map(|v| {
+                if v.rejected {
+                    "REJECT"
+                } else {
+                    "ACCEPT"
+                }
+            })
+        );
         self.db
             .execute(
                 "INSERT OR REPLACE INTO blocks (signer_signature_hash, block_info) VALUES (?1, ?2)",

From 31d52272b76d311c2ddacb635d72d8358e7b0caf Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Fri, 8 Mar 2024 17:02:05 -0500
Subject: [PATCH 1102/1166] chore: cleanup excessive logging

---
 testnet/stacks-node/src/nakamoto_node/miner.rs | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index dc75ef56c4..e77964d3de 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -135,15 +135,11 @@ impl BlockMinerThread {
     /// Stop a miner tenure by blocking the miner and then joining the tenure thread
     pub fn stop_miner(globals: &Globals, prior_miner: JoinHandle<()>) {
         let id = prior_miner.thread().id();
-        debug!("Blocking miner thread ID {:?}", id);
         globals.block_miner();
-        debug!("Joining miner thread ID {:?}", id);
         prior_miner
             .join()
             .expect("FATAL: IO failure joining prior mining thread");
-        debug!("Joined miner thread ID {:?}", id);
         globals.unblock_miner();
-        debug!("Unblocked miner.");
     }
 
     pub fn run_miner(mut self, prior_miner: Option<JoinHandle<()>>) {
@@ -155,7 +151,6 @@ impl BlockMinerThread {
             "parent_tenure_id" => %self.parent_tenure_id,
             "thread_id" => ?thread::current().id(),
         );
-        debug!("Parent tenure ID: {:?}", self.parent_tenure_id);
         if let Some(prior_miner) = prior_miner {
             Self::stop_miner(&self.globals, prior_miner);
         }

From dd95ad00e8fe4a62b9ebc4409e4cce8ddc659e53 Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Fri, 8 Mar 2024 17:06:25 -0500
Subject: [PATCH 1103/1166] chore: remove unused variable

---
 testnet/stacks-node/src/nakamoto_node/miner.rs | 1 -
 1 file changed, 1 deletion(-)

diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index e77964d3de..752492286c 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -134,7 +134,6 @@ impl BlockMinerThread {
 
     /// Stop a miner tenure by blocking the miner and then joining the tenure thread
     pub fn stop_miner(globals: &Globals, prior_miner: JoinHandle<()>) {
-        let id = prior_miner.thread().id();
         globals.block_miner();
         prior_miner
             .join()

From 9997c1b032d33c89bd09d57514db0c273b4314b2 Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Sat, 9 Mar 2024 09:11:04 -0500
Subject: [PATCH 1104/1166] Cleanup outdated signers

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/runloop.rs | 11 +++++++++++
 stacks-signer/src/signer.rs  |  5 +++++
 2 files changed, 16 insertions(+)

diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 4a9a8d528e..a5ff642b6c 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -356,7 +356,13 @@ impl SignerRunLoop<Vec<OperationResult>, RunLoopCommand> for RunLoop {
             }
             error!("Failed to refresh signers: {e}. Signer may have an outdated view of the network. Attempting to process event anyway.");
         }
+        let mut outdated_signers = Vec::with_capacity(self.stacks_signers.len());
         for signer in self.stacks_signers.values_mut() {
+            if signer.reward_cycle < current_reward_cycle {
+                debug!("{signer}: Signer's tenure has completed. Ignoring event: {event:?}");
+                outdated_signers.push(signer.reward_cycle % 2);
+                continue;
+            }
             let event_parity = match event {
                 Some(SignerEvent::BlockValidationResponse(_)) => Some(current_reward_cycle % 2),
                 // Block proposal events do have reward cycles, but each proposal has its own cycle,
@@ -402,6 +408,11 @@ impl SignerRunLoop<Vec<OperationResult>, RunLoopCommand> for RunLoop {
             // After processing event, run the next command for each signer
             signer.process_next_command(&self.stacks_client);
         }
+        for i in outdated_signers.into_iter() {
+            if let Some(signer) = self.stacks_signers.remove(&i) {
+                info!("{signer}: Tenure has completed. Removing signer from runloop.",);
+            }
+        }
         None
     }
 }
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index 5bff83629d..190e4d0533 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -128,6 +128,8 @@ pub enum State {
     Idle,
     /// The signer is executing a DKG or Sign round
     OperationInProgress,
+    /// The signer's reward cycle has finished
+    TenureCompleted,
 }
 
 /// The stacks signer registered for the reward cycle
@@ -373,6 +375,9 @@ impl Signer {
                 // We cannot execute the next command until the current one is finished...
                 debug!("{self}: Waiting for coordinator {coordinator_id:?} operation to finish. Coordinator state = {:?}", self.coordinator.state);
             }
+            State::TenureCompleted => {
+                debug!("{self}: Tenure completed. Will not process any more commands.",);
+            }
         }
     }
 

From 59f2377d690e44e35c66a19ea4999bdd6f0f84bf Mon Sep 17 00:00:00 2001
From: Jacinta Ferrant <jacinta@trustmachines.co>
Date: Sat, 9 Mar 2024 09:22:29 -0500
Subject: [PATCH 1105/1166] Cleanup outdated signer within refresh signer

Signed-off-by: Jacinta Ferrant <jacinta@trustmachines.co>
---
 stacks-signer/src/runloop.rs | 23 ++++++++++++++---------
 stacks-signer/src/signer.rs  |  2 +-
 2 files changed, 15 insertions(+), 10 deletions(-)

diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index a5ff642b6c..942e2dd38e 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -279,7 +279,14 @@ impl RunLoop {
         self.refresh_signer_config(next_reward_cycle);
         // TODO: do not use an empty consensus hash
         let pox_consensus_hash = ConsensusHash::empty();
+        let mut to_delete = Vec::new();
         for signer in self.stacks_signers.values_mut() {
+            if signer.reward_cycle < current_reward_cycle {
+                debug!("{signer}: Signer's tenure has completed.");
+                // We don't really need this state, but it's useful for debugging
+                signer.state = SignerState::TenureCompleted;
+                to_delete.push(signer.reward_cycle % 2);
+            }
             let old_coordinator_id = signer.coordinator_selector.get_coordinator().0;
             let updated_coordinator_id = signer
                 .coordinator_selector
@@ -302,6 +309,11 @@ impl RunLoop {
                 })?;
             }
         }
+        for i in to_delete.into_iter() {
+            if let Some(signer) = self.stacks_signers.remove(&i) {
+                info!("{signer}: Tenure has completed. Removing signer from runloop.",);
+            }
+        }
         if self.stacks_signers.is_empty() {
             info!("Signer is not registered for the current reward cycle ({current_reward_cycle}) or next reward cycle ({next_reward_cycle}). Waiting for confirmed registration...");
             self.state = State::Uninitialized;
@@ -356,11 +368,9 @@ impl SignerRunLoop<Vec<OperationResult>, RunLoopCommand> for RunLoop {
             }
             error!("Failed to refresh signers: {e}. Signer may have an outdated view of the network. Attempting to process event anyway.");
         }
-        let mut outdated_signers = Vec::with_capacity(self.stacks_signers.len());
         for signer in self.stacks_signers.values_mut() {
-            if signer.reward_cycle < current_reward_cycle {
-                debug!("{signer}: Signer's tenure has completed. Ignoring event: {event:?}");
-                outdated_signers.push(signer.reward_cycle % 2);
+            if signer.state == SignerState::TenureCompleted {
+                warn!("{signer}: Signer's tenure has completed. This signer should have been cleaned up during refresh.");
                 continue;
             }
             let event_parity = match event {
@@ -408,11 +418,6 @@ impl SignerRunLoop<Vec<OperationResult>, RunLoopCommand> for RunLoop {
             // After processing event, run the next command for each signer
             signer.process_next_command(&self.stacks_client);
         }
-        for i in outdated_signers.into_iter() {
-            if let Some(signer) = self.stacks_signers.remove(&i) {
-                info!("{signer}: Tenure has completed. Removing signer from runloop.",);
-            }
-        }
         None
     }
 }
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index 190e4d0533..4d5c470440 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -376,7 +376,7 @@ impl Signer {
                 debug!("{self}: Waiting for coordinator {coordinator_id:?} operation to finish. Coordinator state = {:?}", self.coordinator.state);
             }
             State::TenureCompleted => {
-                debug!("{self}: Tenure completed. Will not process any more commands.",);
+                warn!("{self}: Tenure completed. This signer should have been cleaned up during refresh.",);
             }
         }
     }

From d1d1365d55d28db66fa170e1416aea46c2060e81 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Sat, 9 Mar 2024 09:50:11 -0800
Subject: [PATCH 1106/1166] fix: try not deleting accepted blocks from signerDB

---
 stacks-signer/src/signer.rs   | 12 +++++++-----
 stacks-signer/src/signerdb.rs |  5 ++++-
 2 files changed, 11 insertions(+), 6 deletions(-)

diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index 5bff83629d..5dfbdc2138 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -73,7 +73,7 @@ pub struct BlockInfo {
     /// The associated packet nonce request if we have one
     nonce_request: Option<NonceRequest>,
     /// Whether this block is already being signed over
-    signed_over: bool,
+    pub signed_over: bool,
 }
 
 impl BlockInfo {
@@ -992,10 +992,12 @@ impl Signer {
             return;
         };
 
-        // TODO: proper garbage collection...This is currently our only cleanup of blocks
-        self.signer_db
-            .remove_block(&block_vote.signer_signature_hash)
-            .expect(&format!("{self}: Failed to remove block from to signer DB"));
+        // WIP: try not deleting a block from signerDB until we have a better garbage collection strategy.
+        // This causes issues when we have to reprocess a block and we have already deleted it from the signerDB
+        // // TODO: proper garbage collection...This is currently our only cleanup of blocks
+        // self.signer_db
+        //     .remove_block(&block_vote.signer_signature_hash)
+        //     .expect(&format!("{self}: Failed to remove block from to signer DB"));
 
         let block_submission = if block_vote.rejected {
             // We signed a rejection message. Return a rejection message
diff --git a/stacks-signer/src/signerdb.rs b/stacks-signer/src/signerdb.rs
index fdd2ec6fe6..bd24804ec6 100644
--- a/stacks-signer/src/signerdb.rs
+++ b/stacks-signer/src/signerdb.rs
@@ -91,8 +91,10 @@ impl SignerDb {
         let block_json =
             serde_json::to_string(&block_info).expect("Unable to serialize block info");
         let hash = &block_info.signer_signature_hash();
+        let block_id = &block_info.block.block_id();
+        let signed_over = &block_info.signed_over;
         debug!(
-            "Inserting block_info: sighash = {hash}, vote = {:?}",
+            "Inserting block_info: sighash = {hash}, block_id = {block_id}, signed = {signed_over} vote = {:?}",
             block_info.vote.as_ref().map(|v| {
                 if v.rejected {
                     "REJECT"
@@ -117,6 +119,7 @@ impl SignerDb {
 
     /// Remove a block
     pub fn remove_block(&mut self, hash: &Sha512Trunc256Sum) -> Result<(), DBError> {
+        debug!("Deleting block_info: sighash = {hash}");
         self.db.execute(
             "DELETE FROM blocks WHERE signer_signature_hash = ?",
             &[format!("{}", hash)],

From 1d0929977a0999ce04732359aaae74488ba07c66 Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Sat, 9 Mar 2024 15:20:16 -0600
Subject: [PATCH 1107/1166] feat: signer does not treat repeated proposals as
 new

---
 stacks-signer/src/signer.rs | 56 +++++++++++++++++++++++++++----------
 1 file changed, 41 insertions(+), 15 deletions(-)

diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index 5dfbdc2138..1e35f167d6 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -21,7 +21,7 @@ use std::time::Instant;
 use blockstack_lib::chainstate::nakamoto::signer_set::NakamotoSigners;
 use blockstack_lib::chainstate::nakamoto::{NakamotoBlock, NakamotoBlockVote};
 use blockstack_lib::chainstate::stacks::boot::SIGNERS_VOTING_FUNCTION_NAME;
-use blockstack_lib::chainstate::stacks::StacksTransaction;
+use blockstack_lib::chainstate::stacks::{StacksTransaction, ThresholdSignature};
 use blockstack_lib::net::api::postblock_proposal::BlockValidateResponse;
 use hashbrown::HashSet;
 use libsigner::{
@@ -510,25 +510,51 @@ impl Signer {
         for proposal in proposals {
             if proposal.reward_cycle != self.reward_cycle {
                 debug!(
-                    "Signer #{}: Received proposal for block outside of my reward cycle, ignoring.",
-                    self.signer_id;
+                    "{self}: Received proposal for block outside of my reward cycle, ignoring.";
                     "proposal_reward_cycle" => proposal.reward_cycle,
                     "proposal_burn_height" => proposal.burn_height,
                 );
                 continue;
             }
-            // Store the block in our cache
-            self.signer_db
-                .insert_block(&BlockInfo::new(proposal.block.clone()))
-                .unwrap_or_else(|e| {
-                    error!("{self}: Failed to insert block in DB: {e:?}");
-                });
-            // Submit the block for validation
-            stacks_client
-                .submit_block_for_validation(proposal.block.clone())
-                .unwrap_or_else(|e| {
-                    warn!("{self}: Failed to submit block for validation: {e:?}");
-                });
+            let sig_hash = proposal.block.header.signer_signature_hash();
+            match self.signer_db.block_lookup(&sig_hash) {
+                Ok(Some(block)) => {
+                    debug!(
+                        "{self}: Received proposal for block already known, ignoring new proposal.";
+                        "signer_sighash" => %sig_hash,
+                        "proposal_burn_height" => proposal.burn_height,
+                        "vote" => ?block.vote.as_ref().map(|v| {
+                            if v.rejected {
+                                "REJECT"
+                            } else {
+                                "ACCEPT"
+                            }
+                        }),
+                        "signed_over" => block.signed_over,
+                    );
+                    continue;
+                }
+                Ok(None) => {
+                    // Store the block in our cache
+                    self.signer_db
+                        .insert_block(&BlockInfo::new(proposal.block.clone()))
+                        .unwrap_or_else(|e| {
+                            error!("{self}: Failed to insert block in DB: {e:?}");
+                        });
+                    // Submit the block for validation
+                    stacks_client
+                        .submit_block_for_validation(proposal.block.clone())
+                        .unwrap_or_else(|e| {
+                            warn!("{self}: Failed to submit block for validation: {e:?}");
+                        });
+                }
+                Err(e) => {
+                    error!(
+                        "{self}: Failed to lookup block in DB: {e:?}. Dropping proposal request."
+                    );
+                    continue;
+                }
+            }
         }
     }
 

From d24e1a06221c004c48f176b05fdae2ff8e2fe076 Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Sat, 9 Mar 2024 16:50:52 -0500
Subject: [PATCH 1108/1166] chore: use index to make the code more readable

---
 stacks-signer/src/runloop.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 942e2dd38e..56e95a6319 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -280,12 +280,12 @@ impl RunLoop {
         // TODO: do not use an empty consensus hash
         let pox_consensus_hash = ConsensusHash::empty();
         let mut to_delete = Vec::new();
-        for signer in self.stacks_signers.values_mut() {
+        for (idx, signer) in &mut self.stacks_signers {
             if signer.reward_cycle < current_reward_cycle {
                 debug!("{signer}: Signer's tenure has completed.");
                 // We don't really need this state, but it's useful for debugging
                 signer.state = SignerState::TenureCompleted;
-                to_delete.push(signer.reward_cycle % 2);
+                to_delete.push(*idx);
             }
             let old_coordinator_id = signer.coordinator_selector.get_coordinator().0;
             let updated_coordinator_id = signer

From f077e08d11829594e91d0f9663e2a0ec76a4d1ad Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Sun, 10 Mar 2024 15:35:50 -0400
Subject: [PATCH 1109/1166] fix: use http/1.1, not http/1.0

---
 libsigner/src/events.rs    | 2 +-
 libsigner/src/http.rs      | 4 ++--
 libsigner/src/tests/mod.rs | 6 +++---
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/libsigner/src/events.rs b/libsigner/src/events.rs
index ce26447e5a..009a741bf4 100644
--- a/libsigner/src/events.rs
+++ b/libsigner/src/events.rs
@@ -226,7 +226,7 @@ impl EventStopSignaler for SignerStopSignaler {
             // We need to send actual data to trigger the event receiver
             let body = "Yo. Shut this shit down!".to_string();
             let req = format!(
-                "POST /shutdown HTTP/1.0\r\nContent-Length: {}\r\n\r\n{}",
+                "POST /shutdown HTTP/1.1\r\nContent-Length: {}\r\n\r\n{}",
                 &body.len(),
                 body
             );
diff --git a/libsigner/src/http.rs b/libsigner/src/http.rs
index 95f2e2b3cb..fe841415a9 100644
--- a/libsigner/src/http.rs
+++ b/libsigner/src/http.rs
@@ -238,12 +238,12 @@ pub fn run_http_request<S: Read + Write>(
 
     let req_txt = if let Some(content_type) = content_type {
         format!(
-            "{} {} HTTP/1.0\r\nHost: {}\r\nConnection: close\r\nContent-Type: {}\r\n{}User-Agent: libsigner/0.1\r\nAccept: */*\r\n\r\n",
+            "{} {} HTTP/1.1\r\nHost: {}\r\nConnection: close\r\nContent-Type: {}\r\n{}User-Agent: libsigner/0.1\r\nAccept: */*\r\n\r\n",
             verb, path, host, content_type, content_length_hdr
         )
     } else {
         format!(
-            "{} {} HTTP/1.0\r\nHost: {}\r\nConnection: close\r\n{}User-Agent: libsigner/0.1\r\nAccept: */*\r\n\r\n",
+            "{} {} HTTP/1.1\r\nHost: {}\r\nConnection: close\r\n{}User-Agent: libsigner/0.1\r\nAccept: */*\r\n\r\n",
             verb, path, host, content_length_hdr
         )
     };
diff --git a/libsigner/src/tests/mod.rs b/libsigner/src/tests/mod.rs
index 9f320b42fc..b632034555 100644
--- a/libsigner/src/tests/mod.rs
+++ b/libsigner/src/tests/mod.rs
@@ -135,7 +135,7 @@ fn test_simple_signer() {
 
             let ev = &thread_chunks[num_sent];
             let body = serde_json::to_string(ev).unwrap();
-            let req = format!("POST /stackerdb_chunks HTTP/1.0\r\nConnection: close\r\nContent-Length: {}\r\n\r\n{}", &body.len(), body);
+            let req = format!("POST /stackerdb_chunks HTTP/1.1\r\nConnection: close\r\nContent-Length: {}\r\n\r\n{}", &body.len(), body);
             debug!("Send:\n{}", &req);
 
             sock.write_all(req.as_bytes()).unwrap();
@@ -188,13 +188,13 @@ fn test_status_endpoint() {
                 return;
             }
         };
-        let req = "GET /status HTTP/1.0\r\nConnection: close\r\n\r\n";
+        let req = "GET /status HTTP/1.1\r\nConnection: close\r\n\r\n";
 
         sock.write_all(req.as_bytes()).unwrap();
         let mut buf = [0; 128];
         let _ = sock.read(&mut buf).unwrap();
         let res_str = std::str::from_utf8(&buf).unwrap();
-        let expected_status_res = "HTTP/1.0 200 OK\r\n";
+        let expected_status_res = "HTTP/1.1 200 OK\r\n";
         assert_eq!(expected_status_res, &res_str[..expected_status_res.len()]);
         sock.flush().unwrap();
     });

From ec2364b46c27900213bc2b644cc0d1a9ae03901b Mon Sep 17 00:00:00 2001
From: BowTiedRadone <bowtiedradone@gmail.com>
Date: Mon, 11 Mar 2024 00:11:05 +0200
Subject: [PATCH 1110/1166] Add assertion to CI failing test

---
 contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts b/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
index 485d42eebd..4eb0c1e27b 100644
--- a/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
+++ b/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
@@ -1515,6 +1515,7 @@ describe("test pox-4 contract read only functions", () => {
           // Assert
           assert(isClarityType(actual, ClarityType.OptionalSome));
           assert(isClarityType(actual.value, ClarityType.Tuple));
+          expect(actual).toBeSome(Cl.tuple({ "until-burn-ht": Cl.none() }));
           expect(actual.value).toBeTuple({ "until-burn-ht": Cl.none() });
         }
       )

From 912acb886851c3d9f5dd4aac729189023cb0e659 Mon Sep 17 00:00:00 2001
From: BowTiedRadone <92028479+BowTiedRadone@users.noreply.github.com>
Date: Mon, 11 Mar 2024 13:00:25 +0200
Subject: [PATCH 1111/1166] Remove assertion that causes Typescript error

Co-authored-by: Nikos Baxevanis <nikos.baxevanis@gmail.com>
---
 contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts | 1 -
 1 file changed, 1 deletion(-)

diff --git a/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts b/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
index 4eb0c1e27b..454480c41f 100644
--- a/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
+++ b/contrib/core-contract-tests/tests/pox-4/pox-4.prop.test.ts
@@ -1516,7 +1516,6 @@ describe("test pox-4 contract read only functions", () => {
           assert(isClarityType(actual, ClarityType.OptionalSome));
           assert(isClarityType(actual.value, ClarityType.Tuple));
           expect(actual).toBeSome(Cl.tuple({ "until-burn-ht": Cl.none() }));
-          expect(actual.value).toBeTuple({ "until-burn-ht": Cl.none() });
         }
       )
     );

From 59d7907ee1cd0be0c0bf53690691985c180ed684 Mon Sep 17 00:00:00 2001
From: ASuciuX <151519329+ASuciuX@users.noreply.github.com>
Date: Mon, 11 Mar 2024 13:53:42 +0200
Subject: [PATCH 1112/1166] feat: rename 'get'/'put' methods in clarity to
 'get_data'/'put_data'

---
 clarity/src/vm/database/clarity_db.rs        | 60 +++++++++++---------
 clarity/src/vm/database/clarity_store.rs     | 22 +++----
 clarity/src/vm/database/key_value_wrapper.rs | 25 ++++----
 clarity/src/vm/database/structures.rs        |  6 +-
 stackslib/src/chainstate/stacks/boot/mod.rs  |  4 +-
 stackslib/src/clarity_vm/database/marf.rs    | 12 ++--
 stackslib/src/clarity_vm/database/mod.rs     |  6 +-
 stackslib/src/net/api/getaccount.rs          |  8 +--
 stackslib/src/net/api/getcontractsrc.rs      |  4 +-
 stackslib/src/net/api/getdatavar.rs          |  8 ++-
 stackslib/src/net/api/getmapentry.rs         |  4 +-
 11 files changed, 85 insertions(+), 74 deletions(-)

diff --git a/clarity/src/vm/database/clarity_db.rs b/clarity/src/vm/database/clarity_db.rs
index 4388e88e58..b395f88c6d 100644
--- a/clarity/src/vm/database/clarity_db.rs
+++ b/clarity/src/vm/database/clarity_db.rs
@@ -472,22 +472,26 @@ impl<'a> ClarityDatabase<'a> {
         self.store.set_block_hash(bhh, query_pending_data)
     }
 
-    pub fn put<T: ClaritySerializable>(&mut self, key: &str, value: &T) -> Result<()> {
-        self.store.put(&key, &value.serialize())
+    pub fn put_data<T: ClaritySerializable>(&mut self, key: &str, value: &T) -> Result<()> {
+        self.store.put_data(&key, &value.serialize())
     }
 
     /// Like `put()`, but returns the serialized byte size of the stored value
-    pub fn put_with_size<T: ClaritySerializable>(&mut self, key: &str, value: &T) -> Result<u64> {
+    pub fn put_data_with_size<T: ClaritySerializable>(
+        &mut self,
+        key: &str,
+        value: &T,
+    ) -> Result<u64> {
         let serialized = value.serialize();
-        self.store.put(&key, &serialized)?;
+        self.store.put_data(&key, &serialized)?;
         Ok(byte_len_of_serialization(&serialized))
     }
 
-    pub fn get<T>(&mut self, key: &str) -> Result<Option<T>>
+    pub fn get_data<T>(&mut self, key: &str) -> Result<Option<T>>
     where
         T: ClarityDeserializable<T>,
     {
-        self.store.get::<T>(key)
+        self.store.get_data::<T>(key)
     }
 
     pub fn put_value(&mut self, key: &str, value: Value, epoch: &StacksEpochId) -> Result<()> {
@@ -524,7 +528,7 @@ impl<'a> ClarityDatabase<'a> {
 
         let size = serialized.len() as u64;
         let hex_serialized = to_hex(serialized.as_slice());
-        self.store.put(&key, &hex_serialized)?;
+        self.store.put_data(&key, &hex_serialized)?;
 
         Ok(pre_sanitized_size.unwrap_or(size))
     }
@@ -540,11 +544,11 @@ impl<'a> ClarityDatabase<'a> {
             .map_err(|e| InterpreterError::DBError(e.to_string()).into())
     }
 
-    pub fn get_with_proof<T>(&mut self, key: &str) -> Result<Option<(T, Vec<u8>)>>
+    pub fn get_data_with_proof<T>(&mut self, key: &str) -> Result<Option<(T, Vec<u8>)>>
     where
         T: ClarityDeserializable<T>,
     {
-        self.store.get_with_proof(key)
+        self.store.get_data_with_proof(key)
     }
 
     pub fn make_key_for_trip(
@@ -787,7 +791,7 @@ impl<'a> ClarityDatabase<'a> {
     /// The instantiation of subsequent epochs may bump up the epoch version in the clarity DB if
     /// Clarity is updated in that epoch.
     pub fn get_clarity_epoch_version(&mut self) -> Result<StacksEpochId> {
-        let out = match self.get(Self::clarity_state_epoch_key())? {
+        let out = match self.get_data(Self::clarity_state_epoch_key())? {
             Some(x) => u32::try_into(x).map_err(|_| {
                 InterpreterError::Expect("Bad Clarity epoch version in stored Clarity state".into())
             })?,
@@ -798,7 +802,7 @@ impl<'a> ClarityDatabase<'a> {
 
     /// Should be called _after_ all of the epoch's initialization has been invoked
     pub fn set_clarity_epoch_version(&mut self, epoch: StacksEpochId) -> Result<()> {
-        self.put(Self::clarity_state_epoch_key(), &(epoch as u32))
+        self.put_data(Self::clarity_state_epoch_key(), &(epoch as u32))
     }
 
     /// Returns the _current_ total liquid ustx
@@ -1131,12 +1135,12 @@ impl<'a> ClarityDatabase<'a> {
 
     pub fn get_stx_btc_ops_processed(&mut self) -> Result<u64> {
         Ok(self
-            .get("vm_pox::stx_btc_ops::processed_blocks")?
+            .get_data("vm_pox::stx_btc_ops::processed_blocks")?
             .unwrap_or(0))
     }
 
     pub fn set_stx_btc_ops_processed(&mut self, processed: u64) -> Result<()> {
-        self.put("vm_pox::stx_btc_ops::processed_blocks", &processed)
+        self.put_data("vm_pox::stx_btc_ops::processed_blocks", &processed)
     }
 }
 
@@ -1158,7 +1162,7 @@ impl<'a> ClarityDatabase<'a> {
     ) -> Result<()> {
         let key = ClarityDatabase::make_microblock_pubkey_height_key(pubkey_hash);
         let value = format!("{}", &height);
-        self.put(&key, &value)
+        self.put_data(&key, &value)
     }
 
     pub fn get_cc_special_cases_handler(&self) -> Option<SpecialCaseHandler> {
@@ -1195,7 +1199,7 @@ impl<'a> ClarityDatabase<'a> {
         })?;
 
         let value_str = to_hex(&value_bytes);
-        self.put(&key, &value_str)
+        self.put_data(&key, &value_str)
     }
 
     pub fn get_microblock_pubkey_hash_height(
@@ -1203,7 +1207,7 @@ impl<'a> ClarityDatabase<'a> {
         pubkey_hash: &Hash160,
     ) -> Result<Option<u32>> {
         let key = ClarityDatabase::make_microblock_pubkey_height_key(pubkey_hash);
-        self.get(&key)?
+        self.get_data(&key)?
             .map(|height_str: String| {
                 height_str.parse::<u32>().map_err(|_| {
                     InterpreterError::Expect(
@@ -1221,7 +1225,7 @@ impl<'a> ClarityDatabase<'a> {
         height: u32,
     ) -> Result<Option<(StandardPrincipalData, u16)>> {
         let key = ClarityDatabase::make_microblock_poison_key(height);
-        self.get(&key)?
+        self.get_data(&key)?
             .map(|reporter_hex_str: String| {
                 let reporter_value = Value::try_deserialize_hex_untyped(&reporter_hex_str)
                     .map_err(|_| {
@@ -1776,7 +1780,7 @@ impl<'a> ClarityDatabase<'a> {
             StoreType::CirculatingSupply,
             token_name,
         );
-        self.put(&supply_key, &(0_u128))?;
+        self.put_data(&supply_key, &(0_u128))?;
 
         Ok(data)
     }
@@ -1830,7 +1834,7 @@ impl<'a> ClarityDatabase<'a> {
             StoreType::CirculatingSupply,
             token_name,
         );
-        let current_supply: u128 = self.get(&key)?.ok_or_else(|| {
+        let current_supply: u128 = self.get_data(&key)?.ok_or_else(|| {
             InterpreterError::Expect("ERROR: Clarity VM failed to track token supply.".into())
         })?;
 
@@ -1844,7 +1848,7 @@ impl<'a> ClarityDatabase<'a> {
             }
         }
 
-        self.put(&key, &new_supply)
+        self.put_data(&key, &new_supply)
     }
 
     pub fn checked_decrease_token_supply(
@@ -1858,7 +1862,7 @@ impl<'a> ClarityDatabase<'a> {
             StoreType::CirculatingSupply,
             token_name,
         );
-        let current_supply: u128 = self.get(&key)?.ok_or_else(|| {
+        let current_supply: u128 = self.get_data(&key)?.ok_or_else(|| {
             InterpreterError::Expect("ERROR: Clarity VM failed to track token supply.".into())
         })?;
 
@@ -1868,7 +1872,7 @@ impl<'a> ClarityDatabase<'a> {
 
         let new_supply = current_supply - amount;
 
-        self.put(&key, &new_supply)
+        self.put_data(&key, &new_supply)
     }
 
     pub fn get_ft_balance(
@@ -1889,7 +1893,7 @@ impl<'a> ClarityDatabase<'a> {
             &principal.serialize(),
         );
 
-        let result = self.get(&key)?;
+        let result = self.get_data(&key)?;
         match result {
             None => Ok(0),
             Some(balance) => Ok(balance),
@@ -1909,7 +1913,7 @@ impl<'a> ClarityDatabase<'a> {
             token_name,
             &principal.serialize(),
         );
-        self.put(&key, &balance)
+        self.put_data(&key, &balance)
     }
 
     pub fn get_ft_supply(
@@ -1922,7 +1926,7 @@ impl<'a> ClarityDatabase<'a> {
             StoreType::CirculatingSupply,
             token_name,
         );
-        let supply = self.get(&key)?.ok_or_else(|| {
+        let supply = self.get_data(&key)?.ok_or_else(|| {
             InterpreterError::Expect("ERROR: Clarity VM failed to track token supply.".into())
         })?;
         Ok(supply)
@@ -2098,7 +2102,7 @@ impl<'a> ClarityDatabase<'a> {
     pub fn get_account_stx_balance(&mut self, principal: &PrincipalData) -> Result<STXBalance> {
         let key = ClarityDatabase::make_key_for_account_balance(principal);
         debug!("Fetching account balance"; "principal" => %principal.to_string());
-        let result = self.get(&key)?;
+        let result = self.get_data(&key)?;
         Ok(match result {
             None => STXBalance::zero(),
             Some(balance) => balance,
@@ -2107,7 +2111,7 @@ impl<'a> ClarityDatabase<'a> {
 
     pub fn get_account_nonce(&mut self, principal: &PrincipalData) -> Result<u64> {
         let key = ClarityDatabase::make_key_for_account_nonce(principal);
-        let result = self.get(&key)?;
+        let result = self.get_data(&key)?;
         Ok(match result {
             None => 0,
             Some(nonce) => nonce,
@@ -2116,7 +2120,7 @@ impl<'a> ClarityDatabase<'a> {
 
     pub fn set_account_nonce(&mut self, principal: &PrincipalData, nonce: u64) -> Result<()> {
         let key = ClarityDatabase::make_key_for_account_nonce(principal);
-        self.put(&key, &nonce)
+        self.put_data(&key, &nonce)
     }
 }
 
diff --git a/clarity/src/vm/database/clarity_store.rs b/clarity/src/vm/database/clarity_store.rs
index f093c5a3c8..afe2c550ba 100644
--- a/clarity/src/vm/database/clarity_store.rs
+++ b/clarity/src/vm/database/clarity_store.rs
@@ -58,14 +58,14 @@ pub type SpecialCaseHandler = &'static dyn Fn(
 //    attempt to continue processing in the event of an unexpected storage error.
 pub trait ClarityBackingStore {
     /// put K-V data into the committed datastore
-    fn put_all(&mut self, items: Vec<(String, String)>) -> Result<()>;
+    fn put_all_data(&mut self, items: Vec<(String, String)>) -> Result<()>;
     /// fetch K-V out of the committed datastore
-    fn get(&mut self, key: &str) -> Result<Option<String>>;
+    fn get_data(&mut self, key: &str) -> Result<Option<String>>;
     /// fetch K-V out of the committed datastore, along with the byte representation
     ///  of the Merkle proof for that key-value pair
-    fn get_with_proof(&mut self, key: &str) -> Result<Option<(String, Vec<u8>)>>;
+    fn get_data_with_proof(&mut self, key: &str) -> Result<Option<(String, Vec<u8>)>>;
     fn has_entry(&mut self, key: &str) -> Result<bool> {
-        Ok(self.get(key)?.is_some())
+        Ok(self.get_data(key)?.is_some())
     }
 
     /// change the current MARF context to service reads from a different chain_tip
@@ -109,7 +109,7 @@ pub trait ClarityBackingStore {
     ) -> Result<(StacksBlockId, Sha512Trunc256Sum)> {
         let key = make_contract_hash_key(contract);
         let contract_commitment = self
-            .get(&key)?
+            .get_data(&key)?
             .map(|x| ContractCommitment::deserialize(&x))
             .ok_or_else(|| CheckErrors::NoSuchContract(contract.to_string()))?;
         let ContractCommitment {
@@ -232,11 +232,11 @@ impl ClarityBackingStore for NullBackingStore {
         panic!("NullBackingStore can't set block hash")
     }
 
-    fn get(&mut self, _key: &str) -> Result<Option<String>> {
+    fn get_data(&mut self, _key: &str) -> Result<Option<String>> {
         panic!("NullBackingStore can't retrieve data")
     }
 
-    fn get_with_proof(&mut self, _key: &str) -> Result<Option<(String, Vec<u8>)>> {
+    fn get_data_with_proof(&mut self, _key: &str) -> Result<Option<(String, Vec<u8>)>> {
         panic!("NullBackingStore can't retrieve data")
     }
 
@@ -260,7 +260,7 @@ impl ClarityBackingStore for NullBackingStore {
         panic!("NullBackingStore can't get current block height")
     }
 
-    fn put_all(&mut self, mut _items: Vec<(String, String)>) -> Result<()> {
+    fn put_all_data(&mut self, mut _items: Vec<(String, String)>) -> Result<()> {
         panic!("NullBackingStore cannot put")
     }
 }
@@ -301,11 +301,11 @@ impl ClarityBackingStore for MemoryBackingStore {
         Err(RuntimeErrorType::UnknownBlockHeaderHash(BlockHeaderHash(bhh.0)).into())
     }
 
-    fn get(&mut self, key: &str) -> Result<Option<String>> {
+    fn get_data(&mut self, key: &str) -> Result<Option<String>> {
         SqliteConnection::get(self.get_side_store(), key)
     }
 
-    fn get_with_proof(&mut self, key: &str) -> Result<Option<(String, Vec<u8>)>> {
+    fn get_data_with_proof(&mut self, key: &str) -> Result<Option<(String, Vec<u8>)>> {
         Ok(SqliteConnection::get(self.get_side_store(), key)?.map(|x| (x, vec![])))
     }
 
@@ -337,7 +337,7 @@ impl ClarityBackingStore for MemoryBackingStore {
         None
     }
 
-    fn put_all(&mut self, items: Vec<(String, String)>) -> Result<()> {
+    fn put_all_data(&mut self, items: Vec<(String, String)>) -> Result<()> {
         for (key, value) in items.into_iter() {
             SqliteConnection::put(self.get_side_store(), &key, &value)?;
         }
diff --git a/clarity/src/vm/database/key_value_wrapper.rs b/clarity/src/vm/database/key_value_wrapper.rs
index 65de1adce4..69eb74b39e 100644
--- a/clarity/src/vm/database/key_value_wrapper.rs
+++ b/clarity/src/vm/database/key_value_wrapper.rs
@@ -284,7 +284,7 @@ impl<'a> RollbackWrapper<'a> {
             let all_edits =
                 rollback_check_pre_bottom_commit(last_item.edits, &mut self.lookup_map)?;
             if all_edits.len() > 0 {
-                self.store.put_all(all_edits).map_err(|e| {
+                self.store.put_all_data(all_edits).map_err(|e| {
                     InterpreterError::Expect(format!(
                         "ERROR: Failed to commit data to sql store: {e:?}"
                     ))
@@ -308,7 +308,7 @@ impl<'a> RollbackWrapper<'a> {
     }
 }
 
-fn inner_put<T>(
+fn inner_put_data<T>(
     lookup_map: &mut HashMap<T, Vec<String>>,
     edits: &mut Vec<(T, RollbackValueCheck)>,
     key: T,
@@ -322,14 +322,14 @@ fn inner_put<T>(
 }
 
 impl<'a> RollbackWrapper<'a> {
-    pub fn put(&mut self, key: &str, value: &str) -> InterpreterResult<()> {
+    pub fn put_data(&mut self, key: &str, value: &str) -> InterpreterResult<()> {
         let current = self.stack.last_mut().ok_or_else(|| {
             InterpreterError::Expect(
                 "ERROR: Clarity VM attempted PUT on non-nested context.".into(),
             )
         })?;
 
-        Ok(inner_put(
+        Ok(inner_put_data(
             &mut self.lookup_map,
             &mut current.edits,
             key.to_string(),
@@ -359,17 +359,17 @@ impl<'a> RollbackWrapper<'a> {
 
     /// this function will only return commitment proofs for values _already_ materialized
     ///  in the underlying store. otherwise it returns None.
-    pub fn get_with_proof<T>(&mut self, key: &str) -> InterpreterResult<Option<(T, Vec<u8>)>>
+    pub fn get_data_with_proof<T>(&mut self, key: &str) -> InterpreterResult<Option<(T, Vec<u8>)>>
     where
         T: ClarityDeserializable<T>,
     {
         self.store
-            .get_with_proof(key)?
+            .get_data_with_proof(key)?
             .map(|(value, proof)| Ok((T::deserialize(&value)?, proof)))
             .transpose()
     }
 
-    pub fn get<T>(&mut self, key: &str) -> InterpreterResult<Option<T>>
+    pub fn get_data<T>(&mut self, key: &str) -> InterpreterResult<Option<T>>
     where
         T: ClarityDeserializable<T>,
     {
@@ -386,7 +386,10 @@ impl<'a> RollbackWrapper<'a> {
             }
         }
         // otherwise, lookup from store
-        self.store.get(key)?.map(|x| T::deserialize(&x)).transpose()
+        self.store
+            .get_data(key)?
+            .map(|x| T::deserialize(&x))
+            .transpose()
     }
 
     pub fn deserialize_value(
@@ -423,7 +426,7 @@ impl<'a> RollbackWrapper<'a> {
                 return Ok(Some(Self::deserialize_value(x, expected, epoch)?));
             }
         }
-        let stored_data = self.store.get(key).map_err(|_| {
+        let stored_data = self.store.get_data(key).map_err(|_| {
             SerializationError::DeserializationError("ERROR: Clarity backing store failure".into())
         })?;
         match stored_data {
@@ -449,7 +452,7 @@ impl<'a> RollbackWrapper<'a> {
     ) -> InterpreterResult<()> {
         let key = make_contract_hash_key(contract);
         let value = self.store.make_contract_commitment(content_hash);
-        self.put(&key, &value)
+        self.put_data(&key, &value)
     }
 
     pub fn insert_metadata(
@@ -466,7 +469,7 @@ impl<'a> RollbackWrapper<'a> {
 
         let metadata_key = (contract.clone(), key.to_string());
 
-        Ok(inner_put(
+        Ok(inner_put_data(
             &mut self.metadata_lookup_map,
             &mut current.metadata_edits,
             metadata_key,
diff --git a/clarity/src/vm/database/structures.rs b/clarity/src/vm/database/structures.rs
index 937eda2bdc..e4fab929bd 100644
--- a/clarity/src/vm/database/structures.rs
+++ b/clarity/src/vm/database/structures.rs
@@ -375,7 +375,7 @@ impl<'db, 'conn> STXBalanceSnapshot<'db, 'conn> {
 
     pub fn save(self) -> Result<()> {
         let key = ClarityDatabase::make_key_for_account_balance(&self.principal);
-        self.db_ref.put(&key, &self.balance)
+        self.db_ref.put_data(&key, &self.balance)
     }
 
     pub fn transfer_to(mut self, recipient: &PrincipalData, amount: u128) -> Result<()> {
@@ -386,7 +386,7 @@ impl<'db, 'conn> STXBalanceSnapshot<'db, 'conn> {
         let recipient_key = ClarityDatabase::make_key_for_account_balance(recipient);
         let mut recipient_balance = self
             .db_ref
-            .get(&recipient_key)?
+            .get_data(&recipient_key)?
             .unwrap_or(STXBalance::zero());
 
         recipient_balance
@@ -394,7 +394,7 @@ impl<'db, 'conn> STXBalanceSnapshot<'db, 'conn> {
             .ok_or(Error::Runtime(RuntimeErrorType::ArithmeticOverflow, None))?;
 
         self.debit(amount)?;
-        self.db_ref.put(&recipient_key, &recipient_balance)?;
+        self.db_ref.put_data(&recipient_key, &recipient_balance)?;
         self.save()?;
         Ok(())
     }
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 67f485429b..a66559156d 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -296,7 +296,7 @@ impl StacksChainState {
     pub fn handled_pox_cycle_start(clarity_db: &mut ClarityDatabase, cycle_number: u64) -> bool {
         let db_key = Self::handled_pox_cycle_start_key(cycle_number);
         match clarity_db
-            .get::<String>(&db_key)
+            .get_data::<String>(&db_key)
             .expect("FATAL: DB error when checking PoX cycle start")
         {
             Some(x) => x == POX_CYCLE_START_HANDLED_VALUE,
@@ -309,7 +309,7 @@ impl StacksChainState {
         cycle_number: u64,
     ) -> Result<(), clarity::vm::errors::Error> {
         let db_key = Self::handled_pox_cycle_start_key(cycle_number);
-        db.put(&db_key, &POX_CYCLE_START_HANDLED_VALUE.to_string())?;
+        db.put_data(&db_key, &POX_CYCLE_START_HANDLED_VALUE.to_string())?;
         Ok(())
     }
 
diff --git a/stackslib/src/clarity_vm/database/marf.rs b/stackslib/src/clarity_vm/database/marf.rs
index 876168d878..3e4088b6eb 100644
--- a/stackslib/src/clarity_vm/database/marf.rs
+++ b/stackslib/src/clarity_vm/database/marf.rs
@@ -395,7 +395,7 @@ impl<'a> ClarityBackingStore for ReadOnlyMarfStore<'a> {
             .expect("Attempted to get the open chain tip from an unopened context.")
     }
 
-    fn get_with_proof(&mut self, key: &str) -> InterpreterResult<Option<(String, Vec<u8>)>> {
+    fn get_data_with_proof(&mut self, key: &str) -> InterpreterResult<Option<(String, Vec<u8>)>> {
         self.marf
             .get_with_proof(&self.chain_tip, key)
             .or_else(|e| match e {
@@ -417,7 +417,7 @@ impl<'a> ClarityBackingStore for ReadOnlyMarfStore<'a> {
             .transpose()
     }
 
-    fn get(&mut self, key: &str) -> InterpreterResult<Option<String>> {
+    fn get_data(&mut self, key: &str) -> InterpreterResult<Option<String>> {
         trace!("MarfedKV get: {:?} tip={}", key, &self.chain_tip);
         self.marf
             .get(&self.chain_tip, key)
@@ -447,7 +447,7 @@ impl<'a> ClarityBackingStore for ReadOnlyMarfStore<'a> {
             .transpose()
     }
 
-    fn put_all(&mut self, _items: Vec<(String, String)>) -> InterpreterResult<()> {
+    fn put_all_data(&mut self, _items: Vec<(String, String)>) -> InterpreterResult<()> {
         error!("Attempted to commit changes to read-only MARF");
         panic!("BUG: attempted commit to read-only MARF");
     }
@@ -563,7 +563,7 @@ impl<'a> ClarityBackingStore for WritableMarfStore<'a> {
         Some(&handle_contract_call_special_cases)
     }
 
-    fn get(&mut self, key: &str) -> InterpreterResult<Option<String>> {
+    fn get_data(&mut self, key: &str) -> InterpreterResult<Option<String>> {
         trace!("MarfedKV get: {:?} tip={}", key, &self.chain_tip);
         self.marf
             .get(&self.chain_tip, key)
@@ -593,7 +593,7 @@ impl<'a> ClarityBackingStore for WritableMarfStore<'a> {
             .transpose()
     }
 
-    fn get_with_proof(&mut self, key: &str) -> InterpreterResult<Option<(String, Vec<u8>)>> {
+    fn get_data_with_proof(&mut self, key: &str) -> InterpreterResult<Option<(String, Vec<u8>)>> {
         self.marf
             .get_with_proof(&self.chain_tip, key)
             .or_else(|e| match e {
@@ -678,7 +678,7 @@ impl<'a> ClarityBackingStore for WritableMarfStore<'a> {
         }
     }
 
-    fn put_all(&mut self, items: Vec<(String, String)>) -> InterpreterResult<()> {
+    fn put_all_data(&mut self, items: Vec<(String, String)>) -> InterpreterResult<()> {
         let mut keys = Vec::new();
         let mut values = Vec::new();
         for (key, value) in items.into_iter() {
diff --git a/stackslib/src/clarity_vm/database/mod.rs b/stackslib/src/clarity_vm/database/mod.rs
index fdf45f3d21..c9c21957f3 100644
--- a/stackslib/src/clarity_vm/database/mod.rs
+++ b/stackslib/src/clarity_vm/database/mod.rs
@@ -728,11 +728,11 @@ impl ClarityBackingStore for MemoryBackingStore {
         Err(RuntimeErrorType::UnknownBlockHeaderHash(BlockHeaderHash(bhh.0)).into())
     }
 
-    fn get(&mut self, key: &str) -> InterpreterResult<Option<String>> {
+    fn get_data(&mut self, key: &str) -> InterpreterResult<Option<String>> {
         SqliteConnection::get(self.get_side_store(), key)
     }
 
-    fn get_with_proof(&mut self, key: &str) -> InterpreterResult<Option<(String, Vec<u8>)>> {
+    fn get_data_with_proof(&mut self, key: &str) -> InterpreterResult<Option<(String, Vec<u8>)>> {
         Ok(SqliteConnection::get(self.get_side_store(), key)?.map(|x| (x, vec![])))
     }
 
@@ -764,7 +764,7 @@ impl ClarityBackingStore for MemoryBackingStore {
         Some(&handle_contract_call_special_cases)
     }
 
-    fn put_all(&mut self, items: Vec<(String, String)>) -> InterpreterResult<()> {
+    fn put_all_data(&mut self, items: Vec<(String, String)>) -> InterpreterResult<()> {
         for (key, value) in items.into_iter() {
             SqliteConnection::put(self.get_side_store(), &key, &value)?;
         }
diff --git a/stackslib/src/net/api/getaccount.rs b/stackslib/src/net/api/getaccount.rs
index f29f62cb9b..9aa5ef260c 100644
--- a/stackslib/src/net/api/getaccount.rs
+++ b/stackslib/src/net/api/getaccount.rs
@@ -152,14 +152,14 @@ impl RPCRequestHandler for RPCGetAccountRequestHandler {
                         let v3_unlock_height = clarity_db.get_v3_unlock_height().ok()?;
                         let (balance, balance_proof) = if with_proof {
                             clarity_db
-                                .get_with_proof::<STXBalance>(&key)
+                                .get_data_with_proof::<STXBalance>(&key)
                                 .ok()
                                 .flatten()
                                 .map(|(a, b)| (a, Some(format!("0x{}", to_hex(&b)))))
                                 .unwrap_or_else(|| (STXBalance::zero(), Some("".into())))
                         } else {
                             clarity_db
-                                .get::<STXBalance>(&key)
+                                .get_data::<STXBalance>(&key)
                                 .ok()
                                 .flatten()
                                 .map(|a| (a, None))
@@ -169,14 +169,14 @@ impl RPCRequestHandler for RPCGetAccountRequestHandler {
                         let key = ClarityDatabase::make_key_for_account_nonce(&account);
                         let (nonce, nonce_proof) = if with_proof {
                             clarity_db
-                                .get_with_proof(&key)
+                                .get_data_with_proof(&key)
                                 .ok()
                                 .flatten()
                                 .map(|(a, b)| (a, Some(format!("0x{}", to_hex(&b)))))
                                 .unwrap_or_else(|| (0, Some("".into())))
                         } else {
                             clarity_db
-                                .get(&key)
+                                .get_data(&key)
                                 .ok()
                                 .flatten()
                                 .map(|a| (a, None))
diff --git a/stackslib/src/net/api/getcontractsrc.rs b/stackslib/src/net/api/getcontractsrc.rs
index 505299d769..ab97d45eb4 100644
--- a/stackslib/src/net/api/getcontractsrc.rs
+++ b/stackslib/src/net/api/getcontractsrc.rs
@@ -141,12 +141,12 @@ impl RPCRequestHandler for RPCGetContractSrcRequestHandler {
                         let source = db.get_contract_src(&contract_identifier)?;
                         let contract_commit_key = make_contract_hash_key(&contract_identifier);
                         let (contract_commit, proof) = if with_proof {
-                            db.get_with_proof::<ContractCommitment>(&contract_commit_key)
+                            db.get_data_with_proof::<ContractCommitment>(&contract_commit_key)
                                 .ok()
                                 .flatten()
                                 .map(|(a, b)| (a, Some(format!("0x{}", to_hex(&b)))))?
                         } else {
-                            db.get::<ContractCommitment>(&contract_commit_key)
+                            db.get_data::<ContractCommitment>(&contract_commit_key)
                                 .ok()
                                 .flatten()
                                 .map(|a| (a, None))?
diff --git a/stackslib/src/net/api/getdatavar.rs b/stackslib/src/net/api/getdatavar.rs
index aa1c1116af..d6ef8f0dec 100644
--- a/stackslib/src/net/api/getdatavar.rs
+++ b/stackslib/src/net/api/getdatavar.rs
@@ -154,12 +154,16 @@ impl RPCRequestHandler for RPCGetDataVarRequestHandler {
                 clarity_tx.with_clarity_db_readonly(|clarity_db| {
                     let (value_hex, marf_proof): (String, _) = if with_proof {
                         clarity_db
-                            .get_with_proof(&key)
+                            .get_data_with_proof(&key)
                             .ok()
                             .flatten()
                             .map(|(a, b)| (a, Some(format!("0x{}", to_hex(&b)))))?
                     } else {
-                        clarity_db.get(&key).ok().flatten().map(|a| (a, None))?
+                        clarity_db
+                            .get_data(&key)
+                            .ok()
+                            .flatten()
+                            .map(|a| (a, None))?
                     };
 
                     let data = format!("0x{}", value_hex);
diff --git a/stackslib/src/net/api/getmapentry.rs b/stackslib/src/net/api/getmapentry.rs
index 099ae260bd..1265d8e07f 100644
--- a/stackslib/src/net/api/getmapentry.rs
+++ b/stackslib/src/net/api/getmapentry.rs
@@ -183,7 +183,7 @@ impl RPCRequestHandler for RPCGetMapEntryRequestHandler {
                     clarity_tx.with_clarity_db_readonly(|clarity_db| {
                         let (value_hex, marf_proof): (String, _) = if with_proof {
                             clarity_db
-                                .get_with_proof(&key)
+                                .get_data_with_proof(&key)
                                 .ok()
                                 .flatten()
                                 .map(|(a, b)| (a, Some(format!("0x{}", to_hex(&b)))))
@@ -193,7 +193,7 @@ impl RPCRequestHandler for RPCGetMapEntryRequestHandler {
                                 })
                         } else {
                             clarity_db
-                                .get(&key)
+                                .get_data(&key)
                                 .ok()
                                 .flatten()
                                 .map(|a| (a, None))

From a1c226c308aae10ee133de1329aff3cad1c482fa Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Mon, 11 Mar 2024 08:22:55 -0700
Subject: [PATCH 1113/1166] feat: select coordinator just from pubkey alone

---
 stacks-signer/src/coordinator.rs | 18 +++++++++---------
 stacks-signer/src/signer.rs      |  2 +-
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/stacks-signer/src/coordinator.rs b/stacks-signer/src/coordinator.rs
index 234d1ade84..fc582ec77e 100644
--- a/stacks-signer/src/coordinator.rs
+++ b/stacks-signer/src/coordinator.rs
@@ -20,7 +20,6 @@ use blockstack_lib::chainstate::burn::ConsensusHashExtensions;
 use slog::slog_debug;
 use stacks_common::debug;
 use stacks_common::types::chainstate::ConsensusHash;
-use stacks_common::util::hash::Sha256Sum;
 use wsts::curve::ecdsa;
 use wsts::state_machine::PublicKeys;
 
@@ -136,7 +135,7 @@ impl CoordinatorSelector {
         )
     }
 
-    /// Calculate the ordered list of coordinator ids by comparing the provided public keys against the pox consensus hash
+    /// Calculate the ordered list of coordinator ids by comparing the provided public keys
     pub fn calculate_coordinator_ids(
         public_keys: &PublicKeys,
         pox_consensus_hash: &ConsensusHash,
@@ -147,13 +146,14 @@ impl CoordinatorSelector {
             .signers
             .iter()
             .map(|(&id, pk)| {
-                let pk_bytes = pk.to_bytes();
-                let mut buffer =
-                    Vec::with_capacity(pk_bytes.len() + pox_consensus_hash.as_bytes().len());
-                buffer.extend_from_slice(&pk_bytes[..]);
-                buffer.extend_from_slice(pox_consensus_hash.as_bytes());
-                let digest = Sha256Sum::from_data(&buffer).as_bytes().to_vec();
-                (id, digest)
+                (id, pk.to_bytes())
+                // WIP: removing this to try and improve stability / debugability of coordinator selection
+                // let mut buffer =
+                //     Vec::with_capacity(pk_bytes.len() + pox_consensus_hash.as_bytes().len());
+                // buffer.extend_from_slice(&pk_bytes[..]);
+                // buffer.extend_from_slice(pox_consensus_hash.as_bytes());
+                // let digest = Sha256Sum::from_data(&buffer).as_bytes().to_vec();
+                // (id, digest)
             })
             .collect::<Vec<_>>();
 
diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index 26701c254a..6323053006 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -21,7 +21,7 @@ use std::time::Instant;
 use blockstack_lib::chainstate::nakamoto::signer_set::NakamotoSigners;
 use blockstack_lib::chainstate::nakamoto::{NakamotoBlock, NakamotoBlockVote};
 use blockstack_lib::chainstate::stacks::boot::SIGNERS_VOTING_FUNCTION_NAME;
-use blockstack_lib::chainstate::stacks::{StacksTransaction, ThresholdSignature};
+use blockstack_lib::chainstate::stacks::StacksTransaction;
 use blockstack_lib::net::api::postblock_proposal::BlockValidateResponse;
 use hashbrown::HashSet;
 use libsigner::{

From 830b10dc57681e9fa6ff8edb19a17a6d21ccb380 Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Sun, 10 Mar 2024 19:59:19 -0400
Subject: [PATCH 1114/1166] chore: cleanup unused field

---
 .../stacks-node/src/nakamoto_node/miner.rs    | 25 -------------------
 1 file changed, 25 deletions(-)

diff --git a/testnet/stacks-node/src/nakamoto_node/miner.rs b/testnet/stacks-node/src/nakamoto_node/miner.rs
index 752492286c..0882990839 100644
--- a/testnet/stacks-node/src/nakamoto_node/miner.rs
+++ b/testnet/stacks-node/src/nakamoto_node/miner.rs
@@ -39,7 +39,6 @@ use stacks::chainstate::stacks::{
     TenureChangeCause, TenureChangePayload, ThresholdSignature, TransactionAnchorMode,
     TransactionPayload, TransactionVersion,
 };
-use stacks::core::FIRST_BURNCHAIN_CONSENSUS_HASH;
 use stacks::net::stackerdb::StackerDBs;
 use stacks_common::codec::{read_next, StacksMessageCodec};
 use stacks_common::types::chainstate::{StacksAddress, StacksBlockId};
@@ -83,8 +82,6 @@ struct ParentTenureInfo {
 struct ParentStacksBlockInfo {
     /// Header metadata for the Stacks block we're going to build on top of
     stacks_parent_header: StacksHeaderInfo,
-    /// the total amount burned in the sortition that selected the Stacks block parent
-    parent_block_total_burn: u64,
     /// nonce to use for this new block's coinbase transaction
     coinbase_nonce: u64,
     parent_tenure: Option<ParentTenureInfo>,
@@ -692,7 +689,6 @@ impl BlockMinerThread {
                     parent_tenure_blocks: 0,
                 }),
                 stacks_parent_header: chain_tip.metadata,
-                parent_block_total_burn: 0,
                 coinbase_nonce: 0,
             });
         };
@@ -915,26 +911,6 @@ impl ParentStacksBlockInfo {
         .expect("Failed to look up block's parent snapshot")
         .expect("Failed to look up block's parent snapshot");
 
-        let parent_sortition_id = &parent_snapshot.sortition_id;
-
-        let parent_block_total_burn =
-            if &stacks_tip_header.consensus_hash == &FIRST_BURNCHAIN_CONSENSUS_HASH {
-                0
-            } else {
-                let parent_burn_block =
-                    SortitionDB::get_block_snapshot(burn_db.conn(), parent_sortition_id)
-                        .expect("SortitionDB failure.")
-                        .ok_or_else(|| {
-                            error!(
-                                "Failed to find block snapshot for the parent sortition";
-                                "parent_sortition_id" => %parent_sortition_id
-                            );
-                            NakamotoNodeError::SnapshotNotFoundForChainTip
-                        })?;
-
-                parent_burn_block.total_burn
-            };
-
         // don't mine off of an old burnchain block
         let burn_chain_tip = SortitionDB::get_canonical_burn_chain_tip(burn_db.conn())
             .expect("FATAL: failed to query sortition DB for canonical burn chain tip");
@@ -1029,7 +1005,6 @@ impl ParentStacksBlockInfo {
 
         Ok(ParentStacksBlockInfo {
             stacks_parent_header: stacks_tip_header,
-            parent_block_total_burn,
             coinbase_nonce,
             parent_tenure: parent_tenure_info,
         })

From fd1750108c00005fa1238fc4894f1e716bd45174 Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Mon, 11 Mar 2024 11:19:10 -0400
Subject: [PATCH 1115/1166] feat: skip rest of loop when signer's tenure has
 completed

---
 stacks-signer/src/runloop.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 56e95a6319..359b5a18fa 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -286,6 +286,7 @@ impl RunLoop {
                 // We don't really need this state, but it's useful for debugging
                 signer.state = SignerState::TenureCompleted;
                 to_delete.push(*idx);
+                continue;
             }
             let old_coordinator_id = signer.coordinator_selector.get_coordinator().0;
             let updated_coordinator_id = signer

From 6daf9730c2d23f94cfac85d5ba4df5d57ccb52ae Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Mon, 11 Mar 2024 11:37:37 -0400
Subject: [PATCH 1116/1166] logs: quiet warning when signer is not registered
 for future cycle

---
 stacks-signer/src/runloop.rs | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 359b5a18fa..0d76a36eeb 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -229,7 +229,7 @@ impl RunLoop {
     }
 
     /// Refresh signer configuration for a specific reward cycle
-    fn refresh_signer_config(&mut self, reward_cycle: u64) {
+    fn refresh_signer_config(&mut self, reward_cycle: u64, current: bool) {
         let reward_index = reward_cycle % 2;
         let mut needs_refresh = false;
         if let Some(signer) = self.stacks_signers.get_mut(&reward_index) {
@@ -266,7 +266,11 @@ impl RunLoop {
                     .insert(reward_index, Signer::from(new_signer_config));
                 debug!("Reward cycle #{reward_cycle} Signer #{signer_id} initialized.");
             } else {
-                warn!("Signer is not registered for reward cycle {reward_cycle}. Waiting for confirmed registration...");
+                if current {
+                    warn!("Signer is not registered for the current reward cycle ({reward_cycle}). Waiting for confirmed registration...");
+                } else {
+                    debug!("Signer is not registered for reward cycle {reward_cycle}. Waiting for confirmed registration...");
+                }
             }
         }
     }
@@ -275,8 +279,8 @@ impl RunLoop {
     /// Note: this will trigger DKG if required
     fn refresh_signers(&mut self, current_reward_cycle: u64) -> Result<(), ClientError> {
         let next_reward_cycle = current_reward_cycle.saturating_add(1);
-        self.refresh_signer_config(current_reward_cycle);
-        self.refresh_signer_config(next_reward_cycle);
+        self.refresh_signer_config(current_reward_cycle, true);
+        self.refresh_signer_config(next_reward_cycle, false);
         // TODO: do not use an empty consensus hash
         let pox_consensus_hash = ConsensusHash::empty();
         let mut to_delete = Vec::new();

From 17656a3863ef531bda6faa66fad9ba0ae582346e Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Mon, 11 Mar 2024 13:15:58 -0400
Subject: [PATCH 1117/1166] chore: ensure all http/1.1 requests are properly
 structured

---
 libsigner/src/events.rs    | 10 +++++++---
 libsigner/src/tests/mod.rs | 12 ++++++++++--
 2 files changed, 17 insertions(+), 5 deletions(-)

diff --git a/libsigner/src/events.rs b/libsigner/src/events.rs
index 009a741bf4..1c29ec941e 100644
--- a/libsigner/src/events.rs
+++ b/libsigner/src/events.rs
@@ -226,11 +226,15 @@ impl EventStopSignaler for SignerStopSignaler {
             // We need to send actual data to trigger the event receiver
             let body = "Yo. Shut this shit down!".to_string();
             let req = format!(
-                "POST /shutdown HTTP/1.1\r\nContent-Length: {}\r\n\r\n{}",
-                &body.len(),
+                "POST /shutdown HTTP/1.1\r\nHost: {}\r\nConnection: close\r\nContent-Length: {}\r\nContent-Type: text/plain\r\n\r\n{}",
+                self.local_addr,
+                body.len(),
                 body
             );
-            stream.write_all(req.as_bytes()).unwrap();
+            match stream.write_all(req.as_bytes()) {
+                Err(e) => error!("Failed to send shutdown request: {}", e),
+                _ => (),
+            };
         }
     }
 }
diff --git a/libsigner/src/tests/mod.rs b/libsigner/src/tests/mod.rs
index b632034555..1d3e1f3cc0 100644
--- a/libsigner/src/tests/mod.rs
+++ b/libsigner/src/tests/mod.rs
@@ -135,7 +135,12 @@ fn test_simple_signer() {
 
             let ev = &thread_chunks[num_sent];
             let body = serde_json::to_string(ev).unwrap();
-            let req = format!("POST /stackerdb_chunks HTTP/1.1\r\nConnection: close\r\nContent-Length: {}\r\n\r\n{}", &body.len(), body);
+            let req = format!(
+                "POST /stackerdb_chunks HTTP/1.1\r\nHost: {}\r\nConnection: close\r\nContent-Type: application/json\r\nContent-Length: {}\r\n\r\n{}",
+                endpoint,
+                &body.len(),
+                body
+            );
             debug!("Send:\n{}", &req);
 
             sock.write_all(req.as_bytes()).unwrap();
@@ -188,7 +193,10 @@ fn test_status_endpoint() {
                 return;
             }
         };
-        let req = "GET /status HTTP/1.1\r\nConnection: close\r\n\r\n";
+        let req = format!(
+            "GET /status HTTP/1.1\r\nHost: {}\r\nConnection: close\r\n\r\n",
+            endpoint
+        );
 
         sock.write_all(req.as_bytes()).unwrap();
         let mut buf = [0; 128];

From 7891f7e3f005d3111acb6f3c6723e6a6c4c979d8 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Mon, 11 Mar 2024 10:18:57 -0700
Subject: [PATCH 1118/1166] feat: add const to determine whether to rotate
 coordinator

---
 stacks-signer/src/coordinator.rs | 35 +++++++++++++++++++-------------
 1 file changed, 21 insertions(+), 14 deletions(-)

diff --git a/stacks-signer/src/coordinator.rs b/stacks-signer/src/coordinator.rs
index fc582ec77e..3f82d1e49c 100644
--- a/stacks-signer/src/coordinator.rs
+++ b/stacks-signer/src/coordinator.rs
@@ -20,6 +20,7 @@ use blockstack_lib::chainstate::burn::ConsensusHashExtensions;
 use slog::slog_debug;
 use stacks_common::debug;
 use stacks_common::types::chainstate::ConsensusHash;
+use stacks_common::util::hash::Sha256Sum;
 use wsts::curve::ecdsa;
 use wsts::state_machine::PublicKeys;
 
@@ -68,6 +69,9 @@ impl From<PublicKeys> for CoordinatorSelector {
     }
 }
 
+/// Whether or not to rotate to new coordinators in `update_coordinator`
+const ROTATE_COORDINATORS: bool = false;
+
 impl CoordinatorSelector {
     /// Update the coordinator id
     fn update_coordinator(&mut self, new_coordinator_ids: Vec<u32>) {
@@ -80,7 +84,7 @@ impl CoordinatorSelector {
                 .coordinator_ids
                 .first()
                 .expect("FATAL: No registered signers");
-            if new_coordinator_id == self.coordinator_id {
+            if ROTATE_COORDINATORS && new_coordinator_id == self.coordinator_id {
                 // If the newly selected coordinator is the same as the current and we have more than one available, advance immediately to the next
                 if self.coordinator_ids.len() > 1 {
                     new_index = new_index.saturating_add(1);
@@ -88,12 +92,16 @@ impl CoordinatorSelector {
             }
             new_index
         } else {
-            let mut new_index = self.coordinator_index.saturating_add(1);
-            if new_index == self.coordinator_ids.len() {
-                // We have exhausted all potential coordinators. Go back to the start
-                new_index = 0;
+            if ROTATE_COORDINATORS {
+                let mut new_index = self.coordinator_index.saturating_add(1);
+                if new_index == self.coordinator_ids.len() {
+                    // We have exhausted all potential coordinators. Go back to the start
+                    new_index = 0;
+                }
+                new_index
+            } else {
+                self.coordinator_index
             }
-            new_index
         };
         self.coordinator_id = *self
             .coordinator_ids
@@ -146,14 +154,13 @@ impl CoordinatorSelector {
             .signers
             .iter()
             .map(|(&id, pk)| {
-                (id, pk.to_bytes())
-                // WIP: removing this to try and improve stability / debugability of coordinator selection
-                // let mut buffer =
-                //     Vec::with_capacity(pk_bytes.len() + pox_consensus_hash.as_bytes().len());
-                // buffer.extend_from_slice(&pk_bytes[..]);
-                // buffer.extend_from_slice(pox_consensus_hash.as_bytes());
-                // let digest = Sha256Sum::from_data(&buffer).as_bytes().to_vec();
-                // (id, digest)
+                let pk_bytes = pk.to_bytes();
+                let mut buffer =
+                    Vec::with_capacity(pk_bytes.len() + pox_consensus_hash.as_bytes().len());
+                buffer.extend_from_slice(&pk_bytes[..]);
+                buffer.extend_from_slice(pox_consensus_hash.as_bytes());
+                let digest = Sha256Sum::from_data(&buffer).as_bytes().to_vec();
+                (id, digest)
             })
             .collect::<Vec<_>>();
 

From 36ae800d35891b4bde9dcd5d818d6d98bbdb7b1a Mon Sep 17 00:00:00 2001
From: BowTiedDevOps <157840260+BowTiedDevOps@users.noreply.github.com>
Date: Mon, 11 Mar 2024 21:20:08 +0200
Subject: [PATCH 1119/1166] feat: remove test timeout env variable

---
 .github/workflows/create-source-binary.yml | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/.github/workflows/create-source-binary.yml b/.github/workflows/create-source-binary.yml
index e367292ee5..4072fb7284 100644
--- a/.github/workflows/create-source-binary.yml
+++ b/.github/workflows/create-source-binary.yml
@@ -51,12 +51,9 @@ jobs:
             cpu: armv7
           - arch: macos # excludes macos-armv7
             cpu: armv7
-    env:
-      TEST_TIMEOUT: 30
     steps:
       - name: Build Binary (${{ matrix.arch }}_${{ matrix.cpu }})
         id: build_binary
-        timeout-minutes: ${{ fromJSON(env.TEST_TIMEOUT) }}
         uses: stacks-network/actions/stacks-core/create-source-binary@main
         with:
           arch: ${{ matrix.arch }}

From c3d3ab7dfab321d7d12715d459954ddecab35e3f Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Mon, 11 Mar 2024 12:40:40 -0700
Subject: [PATCH 1120/1166] Revert "Merge remote-tracking branch 'origin' into
 feat/vote-for-key-burnop"

This reverts commit c48924515c07d34f3205878c69be116306a6cb4b, reversing
changes made to 13251ac5308e08feb09c0d98905f44ed1149d9f8.
---
 .github/workflows/github-release.yml        |   2 +-
 clarity/src/vm/contexts.rs                  |   2 +-
 stackslib/src/chainstate/burn/db/sortdb.rs  |  32 ++--
 stackslib/src/net/api/poststackerdbchunk.rs |  38 ++--
 stackslib/src/net/chat.rs                   |  11 +-
 stackslib/src/net/mod.rs                    |  11 +-
 stackslib/src/net/p2p.rs                    |  19 +-
 stackslib/src/net/stackerdb/mod.rs          |   5 -
 stackslib/src/net/stackerdb/sync.rs         |  25 +--
 stackslib/src/net/stackerdb/tests/sync.rs   | 196 +-------------------
 testnet/stacks-node/src/node.rs             |  10 -
 11 files changed, 52 insertions(+), 299 deletions(-)

diff --git a/.github/workflows/github-release.yml b/.github/workflows/github-release.yml
index 90d6b3e3d9..17d75b2d0e 100644
--- a/.github/workflows/github-release.yml
+++ b/.github/workflows/github-release.yml
@@ -75,7 +75,7 @@ jobs:
       ## Generate a checksums file to be added to the release page
       - name: Generate Checksums
         id: generate_checksum
-        uses: jmgilman/actions-generate-checksum@3ea6dc9bf8eecf28e2ecc982fab683484a1a8561 # v1.0.1
+        uses: jmgilman/actions-generate-checksum@24a35957fba81c6cbaefeb1e3d59ee56e3db5077 # v1.0.0
         with:
           method: sha512
           output: CHECKSUMS.txt
diff --git a/clarity/src/vm/contexts.rs b/clarity/src/vm/contexts.rs
index 36855b867f..de7b07036e 100644
--- a/clarity/src/vm/contexts.rs
+++ b/clarity/src/vm/contexts.rs
@@ -1336,7 +1336,7 @@ impl<'a, 'b, 'hooks> Environment<'a, 'b, 'hooks> {
         self.global_context.begin();
         let result = stx_transfer_consolidated(self, from, to, amount, memo);
         match result {
-            Ok(value) => match value.clone().expect_result()? {
+            Ok(value) => match value.clone().expect_result() {
                 Ok(_) => {
                     self.global_context.commit()?;
                     Ok(value)
diff --git a/stackslib/src/chainstate/burn/db/sortdb.rs b/stackslib/src/chainstate/burn/db/sortdb.rs
index 86da7f9dcf..a18b0355e0 100644
--- a/stackslib/src/chainstate/burn/db/sortdb.rs
+++ b/stackslib/src/chainstate/burn/db/sortdb.rs
@@ -4222,13 +4222,26 @@ impl SortitionDB {
             .unwrap_or(&burnchain.first_block_hash)
             .clone();
 
+        let rc = burnchain
+            .block_height_to_reward_cycle(chain_tip.block_height)
+            .expect("FATAL: block height does not have a reward cycle");
+
+        let rc_height = burnchain.reward_cycle_to_block_height(rc);
+        let rc_consensus_hash = SortitionDB::get_ancestor_snapshot(
+            conn,
+            cmp::min(chain_tip.block_height, rc_height),
+            &chain_tip.sortition_id,
+        )?
+        .map(|sn| sn.consensus_hash)
+        .ok_or(db_error::NotFoundError)?;
+
         test_debug!(
             "Chain view: {},{}-{},{},{}",
             chain_tip.block_height,
             chain_tip.burn_header_hash,
             stable_block_height,
             &burn_stable_block_hash,
-            &chain_tip.canonical_stacks_tip_consensus_hash,
+            &rc_consensus_hash,
         );
         Ok(BurnchainView {
             burn_block_height: chain_tip.block_height,
@@ -4236,7 +4249,7 @@ impl SortitionDB {
             burn_stable_block_height: stable_block_height,
             burn_stable_block_hash: burn_stable_block_hash,
             last_burn_block_hashes: last_burn_block_hashes,
-            rc_consensus_hash: chain_tip.canonical_stacks_tip_consensus_hash,
+            rc_consensus_hash,
         })
     }
 }
@@ -4489,21 +4502,6 @@ impl SortitionDB {
             .map(|(ch, bhh, _height)| (ch, bhh))
     }
 
-    #[cfg(test)]
-    pub fn set_canonical_stacks_chain_tip(
-        conn: &Connection,
-        ch: &ConsensusHash,
-        bhh: &BlockHeaderHash,
-        height: u64,
-    ) -> Result<(), db_error> {
-        let tip = SortitionDB::get_canonical_burn_chain_tip(conn)?;
-        let args: &[&dyn ToSql] = &[ch, bhh, &u64_to_sql(height)?, &tip.sortition_id];
-        conn.execute("UPDATE snapshots SET canonical_stacks_tip_consensus_hash = ?1, canonical_stacks_tip_hash = ?2, canonical_stacks_tip_height = ?3
-                    WHERE sortition_id = ?4", args)
-            .map_err(db_error::SqliteError)?;
-        Ok(())
-    }
-
     /// Get the maximum arrival index for any known snapshot.
     fn get_max_arrival_index(conn: &Connection) -> Result<u64, db_error> {
         match conn
diff --git a/stackslib/src/net/api/poststackerdbchunk.rs b/stackslib/src/net/api/poststackerdbchunk.rs
index 3972082a6a..1d35a8b908 100644
--- a/stackslib/src/net/api/poststackerdbchunk.rs
+++ b/stackslib/src/net/api/poststackerdbchunk.rs
@@ -228,27 +228,29 @@ impl RPCRequestHandler for RPCPostStackerDBChunkRequestHandler {
                             }
                         };
 
-                    let (reason, slot_metadata_opt) = if let Some(slot_metadata) = slot_metadata_opt
-                    {
-                        let code = if let NetError::BadSlotSigner(..) = e {
-                            StackerDBErrorCodes::BadSigner
+                    let (reason, slot_metadata_opt, err_code) =
+                        if let Some(slot_metadata) = slot_metadata_opt {
+                            let code = if let NetError::BadSlotSigner(..) = e {
+                                StackerDBErrorCodes::BadSigner
+                            } else {
+                                StackerDBErrorCodes::DataAlreadyExists
+                            };
+
+                            (
+                                serde_json::to_string(&code.clone().into_json())
+                                    .unwrap_or("(unable to encode JSON)".to_string()),
+                                Some(slot_metadata),
+                                code,
+                            )
                         } else {
-                            StackerDBErrorCodes::DataAlreadyExists
+                            (
+                                serde_json::to_string(&StackerDBErrorCodes::NoSuchSlot.into_json())
+                                    .unwrap_or("(unable to encode JSON)".to_string()),
+                                None,
+                                StackerDBErrorCodes::DataAlreadyExists,
+                            )
                         };
 
-                        (
-                            serde_json::to_string(&code.into_json())
-                                .unwrap_or("(unable to encode JSON)".to_string()),
-                            Some(slot_metadata),
-                        )
-                    } else {
-                        (
-                            serde_json::to_string(&StackerDBErrorCodes::NoSuchSlot.into_json())
-                                .unwrap_or("(unable to encode JSON)".to_string()),
-                            None,
-                        )
-                    };
-
                     let ack = StackerDBChunkAckData {
                         accepted: false,
                         reason: Some(reason),
diff --git a/stackslib/src/net/chat.rs b/stackslib/src/net/chat.rs
index ee26120313..1b54241197 100644
--- a/stackslib/src/net/chat.rs
+++ b/stackslib/src/net/chat.rs
@@ -1345,8 +1345,8 @@ impl ConversationP2P {
                 self.update_from_stacker_db_handshake_data(stackerdb_accept);
             } else {
                 // remote peer's burnchain view has diverged, so assume no longer replicating (we
-                // can't talk to it anyway).  This can happen once per burnchain block for a few
-                // seconds as nodes begin processing the next Stacks blocks, but it's harmless -- at worst, it
+                // can't talk to it anyway).  This can happen once per reward cycle for a few
+                // minutes as nodes begin the next reward cycle, but it's harmless -- at worst, it
                 // just means that no stacker DB replication happens between this peer and
                 // localhost during this time.
                 self.clear_stacker_db_handshake_data();
@@ -1898,16 +1898,13 @@ impl ConversationP2P {
         let local_peer = network.get_local_peer();
         let burnchain_view = network.get_chain_view();
 
-        // remote peer's Stacks chain tip is different from ours, meaning it might have a different
-        // stackerdb configuration view (and we won't be able to authenticate their chunks, and
-        // vice versa)
         if burnchain_view.rc_consensus_hash != getchunkinv.rc_consensus_hash {
             debug!(
                 "{:?}: NACK StackerDBGetChunkInv; {} != {}",
                 local_peer, &burnchain_view.rc_consensus_hash, &getchunkinv.rc_consensus_hash
             );
             return Ok(StacksMessageType::Nack(NackData::new(
-                NackErrorCodes::StaleView,
+                NackErrorCodes::InvalidPoxFork,
             )));
         }
 
@@ -1949,7 +1946,7 @@ impl ConversationP2P {
                 local_peer, &burnchain_view.rc_consensus_hash, &getchunk.rc_consensus_hash
             );
             return Ok(StacksMessageType::Nack(NackData::new(
-                NackErrorCodes::StaleView,
+                NackErrorCodes::InvalidPoxFork,
             )));
         }
 
diff --git a/stackslib/src/net/mod.rs b/stackslib/src/net/mod.rs
index 96102f5169..e9e309ccf7 100644
--- a/stackslib/src/net/mod.rs
+++ b/stackslib/src/net/mod.rs
@@ -1017,7 +1017,6 @@ pub mod NackErrorCodes {
     pub const InvalidMessage: u32 = 5;
     pub const NoSuchDB: u32 = 6;
     pub const StaleVersion: u32 = 7;
-    pub const StaleView: u32 = 8;
 }
 
 #[derive(Debug, Clone, PartialEq)]
@@ -1040,9 +1039,7 @@ pub struct NatPunchData {
 /// Inform the remote peer of (a page of) the list of stacker DB contracts this node supports
 #[derive(Debug, Clone, PartialEq)]
 pub struct StackerDBHandshakeData {
-    /// current reward cycle consensus hash (i.e. the consensus hash of the Stacks tip in the
-    /// current reward cycle, which commits to both the Stacks block tip and the underlying PoX
-    /// history).
+    /// current reward cycle ID
     pub rc_consensus_hash: ConsensusHash,
     /// list of smart contracts that we index.
     /// there can be as many as 256 entries.
@@ -1054,7 +1051,7 @@ pub struct StackerDBHandshakeData {
 pub struct StackerDBGetChunkInvData {
     /// smart contract being used to determine chunk quantity and order
     pub contract_id: QualifiedContractIdentifier,
-    /// consensus hash of the Stacks chain tip in this reward cycle
+    /// consensus hash of the sortition that started this reward cycle
     pub rc_consensus_hash: ConsensusHash,
 }
 
@@ -1073,7 +1070,7 @@ pub struct StackerDBChunkInvData {
 pub struct StackerDBGetChunkData {
     /// smart contract being used to determine slot quantity and order
     pub contract_id: QualifiedContractIdentifier,
-    /// consensus hash of the Stacks chain tip in this reward cycle
+    /// consensus hash of the sortition that started this reward cycle
     pub rc_consensus_hash: ConsensusHash,
     /// slot ID
     pub slot_id: u32,
@@ -1086,7 +1083,7 @@ pub struct StackerDBGetChunkData {
 pub struct StackerDBPushChunkData {
     /// smart contract being used to determine chunk quantity and order
     pub contract_id: QualifiedContractIdentifier,
-    /// consensus hash of the Stacks chain tip in this reward cycle
+    /// consensus hash of the sortition that started this reward cycle
     pub rc_consensus_hash: ConsensusHash,
     /// the pushed chunk
     pub chunk_data: StackerDBChunkData,
diff --git a/stackslib/src/net/p2p.rs b/stackslib/src/net/p2p.rs
index d0f27558d9..345426aa3a 100644
--- a/stackslib/src/net/p2p.rs
+++ b/stackslib/src/net/p2p.rs
@@ -5246,12 +5246,9 @@ impl PeerNetwork {
         let burnchain_tip_changed = sn.block_height != self.chain_view.burn_block_height;
         let stacks_tip_changed = self.stacks_tip != stacks_tip;
         let mut ret: HashMap<NeighborKey, Vec<StacksMessage>> = HashMap::new();
-        let mut need_stackerdb_refresh = sn.canonical_stacks_tip_consensus_hash
-            != self.burnchain_tip.canonical_stacks_tip_consensus_hash;
 
-        if sn.block_height != self.chain_view.burn_block_height
-            || self.num_state_machine_passes == 0
-        {
+        if burnchain_tip_changed || stacks_tip_changed {
+            // only do the needful depending on what changed
             debug!(
                 "{:?}: load chain view for burn block {}",
                 &self.local_peer, sn.block_height
@@ -5332,17 +5329,7 @@ impl PeerNetwork {
                 .get_last_selected_anchor_block_txid()?
                 .unwrap_or(Txid([0x00; 32]));
 
-            test_debug!(
-                "{:?}: chain view is {:?}",
-                &self.get_local_peer(),
-                &self.chain_view
-            );
-            need_stackerdb_refresh = true;
-        }
-
-        if need_stackerdb_refresh {
-            // refresh stackerdb configs -- canonical stacks tip has changed
-            debug!("{:?}: Refresh all stackerdbs", &self.get_local_peer());
+            // refresh stackerdb configs
             self.refresh_stacker_db_configs(sortdb, chainstate)?;
         }
 
diff --git a/stackslib/src/net/stackerdb/mod.rs b/stackslib/src/net/stackerdb/mod.rs
index 42abeaa7b4..0213c0f96c 100644
--- a/stackslib/src/net/stackerdb/mod.rs
+++ b/stackslib/src/net/stackerdb/mod.rs
@@ -164,8 +164,6 @@ pub struct StackerDBSyncResult {
     dead: HashSet<NeighborKey>,
     /// neighbors that misbehaved while syncing
     broken: HashSet<NeighborKey>,
-    /// neighbors that have stale views, but are otherwise online
-    pub(crate) stale: HashSet<NeighborAddress>,
 }
 
 /// Settings for the Stacker DB
@@ -387,8 +385,6 @@ pub struct StackerDBSync<NC: NeighborComms> {
     /// whether or not we should immediately re-fetch chunks because we learned about new chunks
     /// from our peers when they replied to our chunk-pushes with new inventory state
     need_resync: bool,
-    /// Track stale neighbors
-    pub(crate) stale_neighbors: HashSet<NeighborAddress>,
 }
 
 impl StackerDBSyncResult {
@@ -401,7 +397,6 @@ impl StackerDBSyncResult {
             chunks_to_store: vec![chunk.chunk_data],
             dead: HashSet::new(),
             broken: HashSet::new(),
-            stale: HashSet::new(),
         }
     }
 }
diff --git a/stackslib/src/net/stackerdb/sync.rs b/stackslib/src/net/stackerdb/sync.rs
index a74883f956..bf76092a72 100644
--- a/stackslib/src/net/stackerdb/sync.rs
+++ b/stackslib/src/net/stackerdb/sync.rs
@@ -33,9 +33,9 @@ use crate::net::stackerdb::{
     StackerDBConfig, StackerDBSync, StackerDBSyncResult, StackerDBSyncState, StackerDBs,
 };
 use crate::net::{
-    Error as net_error, NackData, NackErrorCodes, Neighbor, NeighborAddress, NeighborKey,
-    StackerDBChunkData, StackerDBChunkInvData, StackerDBGetChunkData, StackerDBGetChunkInvData,
-    StackerDBPushChunkData, StacksMessageType,
+    Error as net_error, NackData, Neighbor, NeighborAddress, NeighborKey, StackerDBChunkData,
+    StackerDBChunkInvData, StackerDBGetChunkData, StackerDBGetChunkInvData, StackerDBPushChunkData,
+    StacksMessageType,
 };
 
 const MAX_CHUNKS_IN_FLIGHT: usize = 6;
@@ -71,7 +71,6 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
             total_pushed: 0,
             last_run_ts: 0,
             need_resync: false,
-            stale_neighbors: HashSet::new(),
         };
         dbsync.reset(None, config);
         dbsync
@@ -178,7 +177,6 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
             chunks_to_store: chunks,
             dead: self.comms.take_dead_neighbors(),
             broken: self.comms.take_broken_neighbors(),
-            stale: std::mem::replace(&mut self.stale_neighbors, HashSet::new()),
         };
 
         // keep all connected replicas, and replenish from config hints and the DB as needed
@@ -678,7 +676,6 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
                             &network.get_chain_view().rc_consensus_hash,
                             &db_data.rc_consensus_hash
                         );
-                        self.connected_replicas.remove(&naddr);
                         continue;
                     }
                     db_data
@@ -690,10 +687,6 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
                         &naddr,
                         data.error_code
                     );
-                    self.connected_replicas.remove(&naddr);
-                    if data.error_code == NackErrorCodes::StaleView {
-                        self.stale_neighbors.insert(naddr);
-                    }
                     continue;
                 }
                 x => {
@@ -806,15 +799,10 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
                         &naddr,
                         data.error_code
                     );
-                    self.connected_replicas.remove(&naddr);
-                    if data.error_code == NackErrorCodes::StaleView {
-                        self.stale_neighbors.insert(naddr);
-                    }
                     continue;
                 }
                 x => {
                     info!("Received unexpected message {:?}", &x);
-                    self.connected_replicas.remove(&naddr);
                     continue;
                 }
             };
@@ -940,14 +928,10 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
                         data.error_code
                     );
                     self.connected_replicas.remove(&naddr);
-                    if data.error_code == NackErrorCodes::StaleView {
-                        self.stale_neighbors.insert(naddr);
-                    }
                     continue;
                 }
                 x => {
                     info!("Received unexpected message {:?}", &x);
-                    self.connected_replicas.remove(&naddr);
                     continue;
                 }
             };
@@ -1087,9 +1071,6 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
                         data.error_code
                     );
                     self.connected_replicas.remove(&naddr);
-                    if data.error_code == NackErrorCodes::StaleView {
-                        self.stale_neighbors.insert(naddr);
-                    }
                     continue;
                 }
                 x => {
diff --git a/stackslib/src/net/stackerdb/tests/sync.rs b/stackslib/src/net/stackerdb/tests/sync.rs
index eeb2f5aae5..bcbf584b05 100644
--- a/stackslib/src/net/stackerdb/tests/sync.rs
+++ b/stackslib/src/net/stackerdb/tests/sync.rs
@@ -26,12 +26,11 @@ use stacks_common::address::{
     AddressHashMode, C32_ADDRESS_VERSION_MAINNET_MULTISIG, C32_ADDRESS_VERSION_MAINNET_SINGLESIG,
 };
 use stacks_common::types::chainstate::{
-    BlockHeaderHash, ConsensusHash, StacksAddress, StacksPrivateKey, StacksPublicKey,
+    ConsensusHash, StacksAddress, StacksPrivateKey, StacksPublicKey,
 };
 use stacks_common::util::hash::{Hash160, Sha512Trunc256Sum};
 use stacks_common::util::secp256k1::{MessageSignature, Secp256k1PrivateKey};
 
-use crate::chainstate::burn::db::sortdb::SortitionDB;
 use crate::net::relay::Relayer;
 use crate::net::stackerdb::db::SlotValidation;
 use crate::net::stackerdb::{StackerDBConfig, StackerDBs};
@@ -281,199 +280,6 @@ fn test_stackerdb_replica_2_neighbors_1_chunk() {
     })
 }
 
-#[test]
-fn test_stackerdb_replica_2_neighbors_1_chunk_stale_view() {
-    with_timeout(600, || {
-        std::env::set_var("STACKS_TEST_DISABLE_EDGE_TRIGGER_TEST", "1");
-        let mut peer_1_config = TestPeerConfig::from_port(BASE_PORT);
-        let mut peer_2_config = TestPeerConfig::from_port(BASE_PORT + 2);
-
-        peer_1_config.allowed = -1;
-        peer_2_config.allowed = -1;
-
-        // short-lived walks...
-        peer_1_config.connection_opts.walk_max_duration = 10;
-        peer_2_config.connection_opts.walk_max_duration = 10;
-
-        // peer 1 crawls peer 2, and peer 2 crawls peer 1
-        peer_1_config.add_neighbor(&peer_2_config.to_neighbor());
-        peer_2_config.add_neighbor(&peer_1_config.to_neighbor());
-
-        // set up stacker DBs for both peers
-        let idx_1 = add_stackerdb(&mut peer_1_config, Some(StackerDBConfig::template()));
-        let idx_2 = add_stackerdb(&mut peer_2_config, Some(StackerDBConfig::template()));
-
-        let mut peer_1 = TestPeer::new(peer_1_config);
-        let mut peer_2 = TestPeer::new(peer_2_config);
-
-        // peer 1 gets the DB
-        setup_stackerdb(&mut peer_1, idx_1, true, 1);
-        setup_stackerdb(&mut peer_2, idx_2, false, 1);
-
-        // verify that peer 1 got the data
-        let peer_1_db_chunks = load_stackerdb(&peer_1, idx_1);
-        assert_eq!(peer_1_db_chunks.len(), 1);
-        assert_eq!(peer_1_db_chunks[0].0.slot_id, 0);
-        assert_eq!(peer_1_db_chunks[0].0.slot_version, 1);
-        assert!(peer_1_db_chunks[0].1.len() > 0);
-
-        // verify that peer 2 did NOT get the data
-        let peer_2_db_chunks = load_stackerdb(&peer_2, idx_2);
-        assert_eq!(peer_2_db_chunks.len(), 1);
-        assert_eq!(peer_2_db_chunks[0].0.slot_id, 0);
-        assert_eq!(peer_2_db_chunks[0].0.slot_version, 0);
-        assert!(peer_2_db_chunks[0].1.len() == 0);
-
-        let peer_1_db_configs = peer_1.config.get_stacker_db_configs();
-        let peer_2_db_configs = peer_2.config.get_stacker_db_configs();
-
-        // force peer 2 to have a stale view
-        let (old_tip_ch, old_tip_bh) = {
-            let sortdb = peer_1.sortdb();
-            let (tip_bh, tip_ch) =
-                SortitionDB::get_canonical_stacks_chain_tip_hash(sortdb.conn()).unwrap();
-            SortitionDB::set_canonical_stacks_chain_tip(
-                sortdb.conn(),
-                &ConsensusHash([0x22; 20]),
-                &BlockHeaderHash([0x33; 32]),
-                45,
-            )
-            .unwrap();
-            (tip_bh, tip_ch)
-        };
-
-        let mut i = 0;
-        let mut peer_1_stale = false;
-        let mut peer_2_stale = false;
-        loop {
-            // run peer network state-machines
-            peer_1.network.stacker_db_configs = peer_1_db_configs.clone();
-            peer_2.network.stacker_db_configs = peer_2_db_configs.clone();
-
-            let res_1 = peer_1.step_with_ibd(false);
-            let res_2 = peer_2.step_with_ibd(false);
-
-            if let Ok(mut res) = res_1 {
-                for sync_res in res.stacker_db_sync_results.iter() {
-                    assert_eq!(sync_res.chunks_to_store.len(), 0);
-                    if sync_res.stale.len() > 0 {
-                        peer_1_stale = true;
-                    }
-                }
-                Relayer::process_stacker_db_chunks(
-                    &mut peer_1.network.stackerdbs,
-                    &peer_1_db_configs,
-                    res.stacker_db_sync_results,
-                    None,
-                )
-                .unwrap();
-                Relayer::process_pushed_stacker_db_chunks(
-                    &mut peer_1.network.stackerdbs,
-                    &peer_1_db_configs,
-                    &mut res.unhandled_messages,
-                    None,
-                )
-                .unwrap();
-            }
-
-            if let Ok(mut res) = res_2 {
-                for sync_res in res.stacker_db_sync_results.iter() {
-                    assert_eq!(sync_res.chunks_to_store.len(), 0);
-                    if sync_res.stale.len() > 0 {
-                        peer_2_stale = true;
-                    }
-                }
-                Relayer::process_stacker_db_chunks(
-                    &mut peer_2.network.stackerdbs,
-                    &peer_2_db_configs,
-                    res.stacker_db_sync_results,
-                    None,
-                )
-                .unwrap();
-                Relayer::process_pushed_stacker_db_chunks(
-                    &mut peer_2.network.stackerdbs,
-                    &peer_2_db_configs,
-                    &mut res.unhandled_messages,
-                    None,
-                )
-                .unwrap();
-            }
-
-            if peer_1_stale && peer_2_stale {
-                break;
-            }
-
-            i += 1;
-        }
-
-        debug!("Completed stacker DB stale detection in {} step(s)", i);
-
-        // fix and re-run
-        {
-            let sortdb = peer_1.sortdb();
-            SortitionDB::set_canonical_stacks_chain_tip(sortdb.conn(), &old_tip_ch, &old_tip_bh, 0)
-                .unwrap();
-
-            // force chain view refresh
-            peer_1.network.num_state_machine_passes = 0;
-        }
-
-        let mut i = 0;
-        loop {
-            // run peer network state-machines
-            peer_1.network.stacker_db_configs = peer_1_db_configs.clone();
-            peer_2.network.stacker_db_configs = peer_2_db_configs.clone();
-
-            let res_1 = peer_1.step_with_ibd(false);
-            let res_2 = peer_2.step_with_ibd(false);
-
-            if let Ok(mut res) = res_1 {
-                Relayer::process_stacker_db_chunks(
-                    &mut peer_1.network.stackerdbs,
-                    &peer_1_db_configs,
-                    res.stacker_db_sync_results,
-                    None,
-                )
-                .unwrap();
-                Relayer::process_pushed_stacker_db_chunks(
-                    &mut peer_1.network.stackerdbs,
-                    &peer_1_db_configs,
-                    &mut res.unhandled_messages,
-                    None,
-                )
-                .unwrap();
-            }
-
-            if let Ok(mut res) = res_2 {
-                Relayer::process_stacker_db_chunks(
-                    &mut peer_2.network.stackerdbs,
-                    &peer_2_db_configs,
-                    res.stacker_db_sync_results,
-                    None,
-                )
-                .unwrap();
-                Relayer::process_pushed_stacker_db_chunks(
-                    &mut peer_2.network.stackerdbs,
-                    &peer_2_db_configs,
-                    &mut res.unhandled_messages,
-                    None,
-                )
-                .unwrap();
-            }
-
-            let db1 = load_stackerdb(&peer_1, idx_1);
-            let db2 = load_stackerdb(&peer_2, idx_2);
-
-            if db1 == db2 {
-                break;
-            }
-            i += 1;
-        }
-
-        debug!("Completed stacker DB sync in {} step(s)", i);
-    })
-}
-
 #[test]
 #[ignore]
 fn test_stackerdb_replica_2_neighbors_10_chunks() {
diff --git a/testnet/stacks-node/src/node.rs b/testnet/stacks-node/src/node.rs
index 77117a6822..90c2123079 100644
--- a/testnet/stacks-node/src/node.rs
+++ b/testnet/stacks-node/src/node.rs
@@ -345,15 +345,6 @@ impl Node {
         }
 
         let burnchain_config = config.get_burnchain();
-
-        // instantiate DBs
-        let _burnchain_db = BurnchainDB::connect(
-            &burnchain_config.get_burnchaindb_path(),
-            &burnchain_config,
-            true,
-        )
-        .expect("FATAL: failed to connect to burnchain DB");
-
         run_loop::announce_boot_receipts(
             &mut event_dispatcher,
             &chain_state,
@@ -533,7 +524,6 @@ impl Node {
         let consensus_hash = burnchain_tip.block_snapshot.consensus_hash;
 
         let burnchain = self.config.get_burnchain();
-
         let sortdb = SortitionDB::open(
             &self.config.get_burn_db_file_path(),
             true,

From 3202e2748963aa0c0da330727f1fe28f5620a51b Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Mon, 11 Mar 2024 16:05:51 -0400
Subject: [PATCH 1121/1166] fix: use two different blocks for signing test

---
 testnet/stacks-node/src/tests/signer.rs | 60 +++++++++++++++++++------
 1 file changed, 46 insertions(+), 14 deletions(-)

diff --git a/testnet/stacks-node/src/tests/signer.rs b/testnet/stacks-node/src/tests/signer.rs
index ebdef33d46..fb867db0a3 100644
--- a/testnet/stacks-node/src/tests/signer.rs
+++ b/testnet/stacks-node/src/tests/signer.rs
@@ -965,8 +965,8 @@ fn stackerdb_sign() {
 
     info!("------------------------- Test Setup -------------------------");
 
-    info!("Creating an invalid block to sign...");
-    let header = NakamotoBlockHeader {
+    info!("Creating invalid blocks to sign...");
+    let header1 = NakamotoBlockHeader {
         version: 1,
         chain_length: 2,
         burn_spent: 3,
@@ -978,12 +978,12 @@ fn stackerdb_sign() {
         signer_signature: ThresholdSignature::empty(),
         signer_bitvec: BitVec::zeros(1).unwrap(),
     };
-    let mut block = NakamotoBlock {
-        header,
+    let mut block1 = NakamotoBlock {
+        header: header1,
         txs: vec![],
     };
-    let tx_merkle_root = {
-        let txid_vecs = block
+    let tx_merkle_root1 = {
+        let txid_vecs = block1
             .txs
             .iter()
             .map(|tx| tx.txid().as_bytes().to_vec())
@@ -991,14 +991,46 @@ fn stackerdb_sign() {
 
         MerkleTree::<Sha512Trunc256Sum>::new(&txid_vecs).root()
     };
-    block.header.tx_merkle_root = tx_merkle_root;
+    block1.header.tx_merkle_root = tx_merkle_root1;
+
+    let header2 = NakamotoBlockHeader {
+        version: 1,
+        chain_length: 3,
+        burn_spent: 4,
+        consensus_hash: ConsensusHash([0x05; 20]),
+        parent_block_id: StacksBlockId([0x06; 32]),
+        tx_merkle_root: Sha512Trunc256Sum([0x07; 32]),
+        state_index_root: TrieHash([0x08; 32]),
+        miner_signature: MessageSignature::empty(),
+        signer_signature: ThresholdSignature::empty(),
+        signer_bitvec: BitVec::zeros(1).unwrap(),
+    };
+    let mut block2 = NakamotoBlock {
+        header: header2,
+        txs: vec![],
+    };
+    let tx_merkle_root2 = {
+        let txid_vecs = block2
+            .txs
+            .iter()
+            .map(|tx| tx.txid().as_bytes().to_vec())
+            .collect();
+
+        MerkleTree::<Sha512Trunc256Sum>::new(&txid_vecs).root()
+    };
+    block2.header.tx_merkle_root = tx_merkle_root2;
 
     // The block is invalid so the signers should return a signature across a rejection
-    let block_vote = NakamotoBlockVote {
-        signer_signature_hash: block.header.signer_signature_hash(),
+    let block1_vote = NakamotoBlockVote {
+        signer_signature_hash: block1.header.signer_signature_hash(),
+        rejected: true,
+    };
+    let msg1 = block1_vote.serialize_to_vec();
+    let block2_vote = NakamotoBlockVote {
+        signer_signature_hash: block2.header.signer_signature_hash(),
         rejected: true,
     };
-    let msg = block_vote.serialize_to_vec();
+    let msg2 = block2_vote.serialize_to_vec();
 
     let timeout = Duration::from_secs(200);
     let mut signer_test = SignerTest::new(10);
@@ -1012,7 +1044,7 @@ fn stackerdb_sign() {
     let sign_command = RunLoopCommand {
         reward_cycle,
         command: SignerCommand::Sign {
-            block: block.clone(),
+            block: block1,
             is_taproot: false,
             merkle_root: None,
         },
@@ -1020,7 +1052,7 @@ fn stackerdb_sign() {
     let sign_taproot_command = RunLoopCommand {
         reward_cycle,
         command: SignerCommand::Sign {
-            block: block.clone(),
+            block: block2,
             is_taproot: true,
             merkle_root: None,
         },
@@ -1037,12 +1069,12 @@ fn stackerdb_sign() {
     let schnorr_proofs = signer_test.wait_for_taproot_signatures(timeout);
 
     for frost_signature in frost_signatures {
-        assert!(frost_signature.verify(&key, &msg));
+        assert!(frost_signature.verify(&key, &msg1));
     }
     for schnorr_proof in schnorr_proofs {
         let tweaked_key = tweaked_public_key(&key, None);
         assert!(
-            schnorr_proof.verify(&tweaked_key.x(), &msg),
+            schnorr_proof.verify(&tweaked_key.x(), &msg2),
             "Schnorr proof verification failed"
         );
     }

From deaeeb518b780ed815a92ad6c888ee9c4e6f987f Mon Sep 17 00:00:00 2001
From: Hugo Caillard <911307+hugocaillard@users.noreply.github.com>
Date: Mon, 11 Mar 2024 22:33:48 +0100
Subject: [PATCH 1122/1166] feat: return any value type from
 execute_contract_allow_private

---
 clarity/src/vm/callables.rs |  4 ++--
 clarity/src/vm/contexts.rs  | 15 +++++++++++----
 2 files changed, 13 insertions(+), 6 deletions(-)

diff --git a/clarity/src/vm/callables.rs b/clarity/src/vm/callables.rs
index 32e7d05514..9cd991ec97 100644
--- a/clarity/src/vm/callables.rs
+++ b/clarity/src/vm/callables.rs
@@ -340,8 +340,8 @@ impl DefinedFunction {
     pub fn apply(&self, args: &[Value], env: &mut Environment) -> Result<Value> {
         match self.define_type {
             DefineType::Private => self.execute_apply(args, env),
-            DefineType::Public => env.execute_function_as_transaction(self, args, None),
-            DefineType::ReadOnly => env.execute_function_as_transaction(self, args, None),
+            DefineType::Public => env.execute_function_as_transaction(self, args, None, false),
+            DefineType::ReadOnly => env.execute_function_as_transaction(self, args, None, false),
         }
     }
 
diff --git a/clarity/src/vm/contexts.rs b/clarity/src/vm/contexts.rs
index de7b07036e..0dd98c63f4 100644
--- a/clarity/src/vm/contexts.rs
+++ b/clarity/src/vm/contexts.rs
@@ -1139,8 +1139,7 @@ impl<'a, 'b, 'hooks> Environment<'a, 'b, 'hooks> {
                 return Err(CheckErrors::CircularReference(vec![func_identifier.to_string()]).into())
             }
             self.call_stack.insert(&func_identifier, true);
-
-            let res = self.execute_function_as_transaction(&func, &args, Some(&contract.contract_context));
+            let res = self.execute_function_as_transaction(&func, &args, Some(&contract.contract_context), allow_private);
             self.call_stack.remove(&func_identifier, true)?;
 
             match res {
@@ -1168,6 +1167,7 @@ impl<'a, 'b, 'hooks> Environment<'a, 'b, 'hooks> {
         function: &DefinedFunction,
         args: &[Value],
         next_contract_context: Option<&ContractContext>,
+        allow_private: bool,
     ) -> Result<Value> {
         let make_read_only = function.is_read_only();
 
@@ -1196,7 +1196,7 @@ impl<'a, 'b, 'hooks> Environment<'a, 'b, 'hooks> {
             self.global_context.roll_back()?;
             result
         } else {
-            self.global_context.handle_tx_result(result)
+            self.global_context.handle_tx_result(result, allow_private)
         }
     }
 
@@ -1726,7 +1726,11 @@ impl<'a, 'hooks> GlobalContext<'a, 'hooks> {
         self.database.roll_back()
     }
 
-    pub fn handle_tx_result(&mut self, result: Result<Value>) -> Result<Value> {
+    pub fn handle_tx_result(
+        &mut self,
+        result: Result<Value>,
+        allow_private: bool,
+    ) -> Result<Value> {
         if let Ok(result) = result {
             if let Value::Response(data) = result {
                 if data.committed {
@@ -1735,6 +1739,9 @@ impl<'a, 'hooks> GlobalContext<'a, 'hooks> {
                     self.roll_back()?;
                 }
                 Ok(Value::Response(data))
+            } else if allow_private {
+                self.commit()?;
+                Ok(result)
             } else {
                 Err(
                     CheckErrors::PublicFunctionMustReturnResponse(TypeSignature::type_of(&result)?)

From 99b54f5f62109916a0cadd218b226cc31cda694c Mon Sep 17 00:00:00 2001
From: Hugo Caillard <911307+hugocaillard@users.noreply.github.com>
Date: Tue, 12 Mar 2024 11:27:37 +0100
Subject: [PATCH 1123/1166] fix: feature flag allow_private to return any value

---
 clarity/src/vm/contexts.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/clarity/src/vm/contexts.rs b/clarity/src/vm/contexts.rs
index 0dd98c63f4..3176fc9551 100644
--- a/clarity/src/vm/contexts.rs
+++ b/clarity/src/vm/contexts.rs
@@ -1739,7 +1739,7 @@ impl<'a, 'hooks> GlobalContext<'a, 'hooks> {
                     self.roll_back()?;
                 }
                 Ok(Value::Response(data))
-            } else if allow_private {
+            } else if allow_private && cfg!(feature = "developer-mode") {
                 self.commit()?;
                 Ok(result)
             } else {

From b7e2590539cfca1497dca1e41fe6040c980f0242 Mon Sep 17 00:00:00 2001
From: Matthew Little <zone117x@gmail.com>
Date: Tue, 12 Mar 2024 14:14:57 +0100
Subject: [PATCH 1124/1166] fix: JSON serialization for stacked_amt u128 should
 use string

---
 stackslib/src/chainstate/stacks/boot/mod.rs | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 67f485429b..4347afcdc9 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -213,10 +213,30 @@ fn hex_deserialize<'de, D: serde::Deserializer<'de>>(
     Ok(bytes)
 }
 
+fn serialize_u128_as_string<S>(value: &u128, serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: serde::Serializer,
+{
+    serializer.serialize_str(&value.to_string())
+}
+
+fn deserialize_u128_from_string<'de, D>(deserializer: D) -> Result<u128, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    use std::str::FromStr;
+    let s = String::deserialize(deserializer)?;
+    u128::from_str(&s).map_err(serde::de::Error::custom)
+}
+
 #[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
 pub struct NakamotoSignerEntry {
     #[serde(serialize_with = "hex_serialize", deserialize_with = "hex_deserialize")]
     pub signing_key: [u8; 33],
+    #[serde(
+        serialize_with = "serialize_u128_as_string",
+        deserialize_with = "deserialize_u128_from_string"
+    )]
     pub stacked_amt: u128,
     pub weight: u32,
 }

From abb47dd806a890c843770deb83dcef80aed0dec0 Mon Sep 17 00:00:00 2001
From: Matthew Little <zone117x@gmail.com>
Date: Tue, 12 Mar 2024 14:22:13 +0100
Subject: [PATCH 1125/1166] feat: add `pox_stx_threshold` amount to
 `/new_block` event data

---
 stacks-signer/src/client/stacks_client.rs     |  1 +
 stackslib/src/chainstate/coordinator/tests.rs |  1 +
 stackslib/src/chainstate/stacks/boot/mod.rs   | 36 +++++++++++++++++++
 3 files changed, 38 insertions(+)

diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index 80481d5981..9d300c09b3 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -1143,6 +1143,7 @@ mod tests {
                 stacked_amt: rand::thread_rng().next_u64() as u128,
                 weight: 1,
             }]),
+            pox_stx_threshold: None,
         };
         let stackers_response = GetStackersResponse {
             stacker_set: stacker_set.clone(),
diff --git a/stackslib/src/chainstate/coordinator/tests.rs b/stackslib/src/chainstate/coordinator/tests.rs
index e3fc8f21c4..3367bf5549 100644
--- a/stackslib/src/chainstate/coordinator/tests.rs
+++ b/stackslib/src/chainstate/coordinator/tests.rs
@@ -511,6 +511,7 @@ impl RewardSetProvider for StubbedRewardSetProvider {
                 missed_reward_slots: vec![],
             },
             signers: None,
+            pox_stx_threshold: None,
         })
     }
 
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 67f485429b..f9f128c3e4 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -213,6 +213,34 @@ fn hex_deserialize<'de, D: serde::Deserializer<'de>>(
     Ok(bytes)
 }
 
+fn serialize_optional_u128_as_string<S>(
+    value: &Option<u128>,
+    serializer: S,
+) -> Result<S::Ok, S::Error>
+where
+    S: serde::Serializer,
+{
+    match value {
+        Some(v) => serializer.serialize_str(&v.to_string()),
+        None => serializer.serialize_none(),
+    }
+}
+
+fn deserialize_optional_u128_from_string<'de, D>(deserializer: D) -> Result<Option<u128>, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    use std::str::FromStr;
+    let opt_str = Option::<String>::deserialize(deserializer)?;
+    match opt_str {
+        Some(s) => {
+            let parsed = u128::from_str(&s).map_err(serde::de::Error::custom)?;
+            Ok(Some(parsed))
+        }
+        None => Ok(None),
+    }
+}
+
 #[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
 pub struct NakamotoSignerEntry {
     #[serde(serialize_with = "hex_serialize", deserialize_with = "hex_deserialize")]
@@ -228,6 +256,12 @@ pub struct RewardSet {
     #[serde(skip_serializing_if = "Option::is_none", default)]
     // only generated for nakamoto reward sets
     pub signers: Option<Vec<NakamotoSignerEntry>>,
+    #[serde(
+        serialize_with = "serialize_optional_u128_as_string",
+        deserialize_with = "deserialize_optional_u128_from_string",
+        skip_serializing_if = "Option::is_none"
+    )]
+    pub pox_stx_threshold: Option<u128>,
 }
 
 #[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
@@ -260,6 +294,7 @@ impl RewardSet {
                 missed_reward_slots: vec![],
             },
             signers: None,
+            pox_stx_threshold: None,
         }
     }
 
@@ -843,6 +878,7 @@ impl StacksChainState {
                 missed_reward_slots: missed_slots,
             },
             signers: signer_set,
+            pox_stx_threshold: Some(threshold),
         }
     }
 

From e3a76f7c3c2327c22ea2d5de39bb33238931fd01 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Tue, 12 Mar 2024 07:25:18 -0700
Subject: [PATCH 1126/1166] feat: fix nakamoto integration test

---
 testnet/stacks-node/src/tests/nakamoto_integrations.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 2dc0472ecb..c5f106b3d8 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -2212,6 +2212,7 @@ fn vote_for_aggregate_key_burn_op() {
         blocks_processed,
         naka_submitted_vrfs: vrfs_submitted,
         naka_submitted_commits: commits_submitted,
+        naka_proposed_blocks: proposals_submitted,
         ..
     } = run_loop.counters();
 
@@ -2244,6 +2245,7 @@ fn vote_for_aggregate_key_burn_op() {
     .unwrap();
 
     info!("Nakamoto miner started...");
+    blind_signer(&naka_conf, &signers, &signer_sk, proposals_submitted);
     // first block wakes up the run loop, wait until a key registration has been submitted.
     next_block_and(&mut btc_regtest_controller, 60, || {
         let vrf_count = vrfs_submitted.load(Ordering::SeqCst);

From 481b01c5363ee7319a7f676c308a41d8ae34e3d1 Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Tue, 12 Mar 2024 10:28:10 -0400
Subject: [PATCH 1127/1166] fix: add reward cycle to signerdb

The blocks should always be associated with a specific reward cycle so
that the signers do not take actions on blocks from the previous cycle.
---
 stacks-signer/src/signer.rs   | 32 +++++++++++--------
 stacks-signer/src/signerdb.rs | 58 ++++++++++++++++++++++++-----------
 2 files changed, 59 insertions(+), 31 deletions(-)

diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index 6323053006..3de6cc13a2 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -317,7 +317,7 @@ impl Signer {
                 let signer_signature_hash = block.header.signer_signature_hash();
                 let mut block_info = self
                     .signer_db
-                    .block_lookup(&signer_signature_hash)
+                    .block_lookup(self.reward_cycle, &signer_signature_hash)
                     .unwrap_or_else(|_| Some(BlockInfo::new(block.clone())))
                     .unwrap_or_else(|| BlockInfo::new(block.clone()));
                 if block_info.signed_over {
@@ -339,7 +339,7 @@ impl Signer {
                         debug!("{self}: ACK: {ack:?}",);
                         block_info.signed_over = true;
                         self.signer_db
-                            .insert_block(&block_info)
+                            .insert_block(self.reward_cycle, &block_info)
                             .unwrap_or_else(|e| {
                                 error!("{self}: Failed to insert block in DB: {e:?}");
                             });
@@ -392,7 +392,10 @@ impl Signer {
             BlockValidateResponse::Ok(block_validate_ok) => {
                 let signer_signature_hash = block_validate_ok.signer_signature_hash;
                 // For mutability reasons, we need to take the block_info out of the map and add it back after processing
-                let mut block_info = match self.signer_db.block_lookup(&signer_signature_hash) {
+                let mut block_info = match self
+                    .signer_db
+                    .block_lookup(self.reward_cycle, &signer_signature_hash)
+                {
                     Ok(Some(block_info)) => block_info,
                     Ok(None) => {
                         // We have not seen this block before. Why are we getting a response for it?
@@ -407,7 +410,7 @@ impl Signer {
                 let is_valid = self.verify_block_transactions(stacks_client, &block_info.block);
                 block_info.valid = Some(is_valid);
                 self.signer_db
-                    .insert_block(&block_info)
+                    .insert_block(self.reward_cycle, &block_info)
                     .expect(&format!("{self}: Failed to insert block in DB"));
                 info!(
                     "{self}: Treating block validation for block {} as valid: {:?}",
@@ -418,7 +421,10 @@ impl Signer {
             }
             BlockValidateResponse::Reject(block_validate_reject) => {
                 let signer_signature_hash = block_validate_reject.signer_signature_hash;
-                let mut block_info = match self.signer_db.block_lookup(&signer_signature_hash) {
+                let mut block_info = match self
+                    .signer_db
+                    .block_lookup(self.reward_cycle, &signer_signature_hash)
+                {
                     Ok(Some(block_info)) => block_info,
                     Ok(None) => {
                         // We have not seen this block before. Why are we getting a response for it?
@@ -481,7 +487,7 @@ impl Signer {
             }
         }
         self.signer_db
-            .insert_block(&block_info)
+            .insert_block(self.reward_cycle, &block_info)
             .expect(&format!("{self}: Failed to insert block in DB"));
     }
 
@@ -522,7 +528,7 @@ impl Signer {
                 continue;
             }
             let sig_hash = proposal.block.header.signer_signature_hash();
-            match self.signer_db.block_lookup(&sig_hash) {
+            match self.signer_db.block_lookup(self.reward_cycle, &sig_hash) {
                 Ok(Some(block)) => {
                     debug!(
                         "{self}: Received proposal for block already known, ignoring new proposal.";
@@ -542,7 +548,7 @@ impl Signer {
                 Ok(None) => {
                     // Store the block in our cache
                     self.signer_db
-                        .insert_block(&BlockInfo::new(proposal.block.clone()))
+                        .insert_block(self.reward_cycle, &BlockInfo::new(proposal.block.clone()))
                         .unwrap_or_else(|e| {
                             error!("{self}: Failed to insert block in DB: {e:?}");
                         });
@@ -617,7 +623,7 @@ impl Signer {
 
         match self
             .signer_db
-            .block_lookup(&block_vote.signer_signature_hash)
+            .block_lookup(self.reward_cycle, &block_vote.signer_signature_hash)
             .expect(&format!("{self}: Failed to connect to DB"))
             .map(|b| b.vote)
         {
@@ -671,7 +677,7 @@ impl Signer {
         let signer_signature_hash = block.header.signer_signature_hash();
         let mut block_info = match self
             .signer_db
-            .block_lookup(&signer_signature_hash)
+            .block_lookup(self.reward_cycle, &signer_signature_hash)
             .expect("Failed to connect to signer DB")
         {
             Some(block_info) => block_info,
@@ -679,7 +685,7 @@ impl Signer {
                 debug!("{self}: We have received a block sign request for a block we have not seen before. Cache the nonce request and submit the block for validation...");
                 let block_info = BlockInfo::new_with_request(block.clone(), nonce_request.clone());
                 self.signer_db
-                    .insert_block(&block_info)
+                    .insert_block(self.reward_cycle, &block_info)
                     .expect(&format!("{self}: Failed to insert block in DB"));
                 stacks_client
                     .submit_block_for_validation(block)
@@ -699,7 +705,7 @@ impl Signer {
 
         self.determine_vote(&mut block_info, nonce_request);
         self.signer_db
-            .insert_block(&block_info)
+            .insert_block(self.reward_cycle, &block_info)
             .expect(&format!("{self}: Failed to insert block in DB"));
         true
     }
@@ -1066,7 +1072,7 @@ impl Signer {
             };
             let Some(block_info) = self
                 .signer_db
-                .block_lookup(&block_vote.signer_signature_hash)
+                .block_lookup(self.reward_cycle, &block_vote.signer_signature_hash)
                 .expect(&format!("{self}: Failed to connect to signer DB"))
             else {
                 debug!(
diff --git a/stacks-signer/src/signerdb.rs b/stacks-signer/src/signerdb.rs
index bd24804ec6..052025b91a 100644
--- a/stacks-signer/src/signerdb.rs
+++ b/stacks-signer/src/signerdb.rs
@@ -34,8 +34,10 @@ pub struct SignerDb {
 
 const CREATE_BLOCKS_TABLE: &'static str = "
 CREATE TABLE IF NOT EXISTS blocks (
-    signer_signature_hash TEXT PRIMARY KEY,
-    block_info TEXT NOT NULL
+    reward_cycle INTEGER NOT NULL,
+    signer_signature_hash TEXT NOT NULL,
+    block_info TEXT NOT NULL,
+    PRIMARY KEY (reward_cycle, signer_signature_hash)
 )";
 
 impl SignerDb {
@@ -70,11 +72,15 @@ impl SignerDb {
 
     /// Fetch a block from the database using the block's
     /// `signer_signature_hash`
-    pub fn block_lookup(&self, hash: &Sha512Trunc256Sum) -> Result<Option<BlockInfo>, DBError> {
+    pub fn block_lookup(
+        &self,
+        reward_cycle: u64,
+        hash: &Sha512Trunc256Sum,
+    ) -> Result<Option<BlockInfo>, DBError> {
         let result: Option<String> = query_row(
             &self.db,
-            "SELECT block_info FROM blocks WHERE signer_signature_hash = ?",
-            &[format!("{}", hash)],
+            "SELECT block_info FROM blocks WHERE reward_cycle = ? AND signer_signature_hash = ?",
+            &[&reward_cycle.to_string(), &format!("{}", hash)],
         )?;
         if let Some(block_info) = result {
             let block_info: BlockInfo =
@@ -87,14 +93,18 @@ impl SignerDb {
 
     /// Insert a block into the database.
     /// `hash` is the `signer_signature_hash` of the block.
-    pub fn insert_block(&mut self, block_info: &BlockInfo) -> Result<(), DBError> {
+    pub fn insert_block(
+        &mut self,
+        reward_cycle: u64,
+        block_info: &BlockInfo,
+    ) -> Result<(), DBError> {
         let block_json =
             serde_json::to_string(&block_info).expect("Unable to serialize block info");
         let hash = &block_info.signer_signature_hash();
         let block_id = &block_info.block.block_id();
         let signed_over = &block_info.signed_over;
         debug!(
-            "Inserting block_info: sighash = {hash}, block_id = {block_id}, signed = {signed_over} vote = {:?}",
+            "Inserting block_info: reward_cycle = {reward_cycle}, sighash = {hash}, block_id = {block_id}, signed = {signed_over} vote = {:?}",
             block_info.vote.as_ref().map(|v| {
                 if v.rejected {
                     "REJECT"
@@ -105,8 +115,8 @@ impl SignerDb {
         );
         self.db
             .execute(
-                "INSERT OR REPLACE INTO blocks (signer_signature_hash, block_info) VALUES (?1, ?2)",
-                &[format!("{}", hash), block_json],
+                "INSERT OR REPLACE INTO blocks (reward_cycle, signer_signature_hash, block_info) VALUES (?1, ?2, ?3)",
+                &[reward_cycle.to_string(), format!("{}", hash), block_json],
             )
             .map_err(|e| {
                 return DBError::Other(format!(
@@ -118,11 +128,15 @@ impl SignerDb {
     }
 
     /// Remove a block
-    pub fn remove_block(&mut self, hash: &Sha512Trunc256Sum) -> Result<(), DBError> {
+    pub fn remove_block(
+        &mut self,
+        reward_cycle: u64,
+        hash: &Sha512Trunc256Sum,
+    ) -> Result<(), DBError> {
         debug!("Deleting block_info: sighash = {hash}");
         self.db.execute(
-            "DELETE FROM blocks WHERE signer_signature_hash = ?",
-            &[format!("{}", hash)],
+            "DELETE FROM blocks WHERE reward_cycle = ? AND signer_signature_hash = ?",
+            &[reward_cycle.to_string(), format!("{}", hash)],
         )?;
 
         Ok(())
@@ -193,16 +207,23 @@ mod tests {
 
     fn test_basic_signer_db_with_path(db_path: impl AsRef<Path>) {
         let mut db = SignerDb::new(db_path).expect("Failed to create signer db");
+        let reward_cycle = 1;
         let (block_info, block) = create_block();
-        db.insert_block(&block_info)
+        db.insert_block(reward_cycle, &block_info)
             .expect("Unable to insert block into db");
 
         let block_info = db
-            .block_lookup(&block.header.signer_signature_hash())
+            .block_lookup(reward_cycle, &block.header.signer_signature_hash())
             .unwrap()
             .expect("Unable to get block from db");
 
         assert_eq!(BlockInfo::new(block.clone()), block_info);
+
+        // Test looking up a block from a different reward cycle
+        let block_info = db
+            .block_lookup(reward_cycle + 1, &block.header.signer_signature_hash())
+            .unwrap();
+        assert!(block_info.is_none());
     }
 
     #[test]
@@ -220,12 +241,13 @@ mod tests {
     fn test_update_block() {
         let db_path = tmp_db_path();
         let mut db = SignerDb::new(db_path).expect("Failed to create signer db");
+        let reward_cycle = 42;
         let (block_info, block) = create_block();
-        db.insert_block(&block_info)
+        db.insert_block(reward_cycle, &block_info)
             .expect("Unable to insert block into db");
 
         let block_info = db
-            .block_lookup(&block.header.signer_signature_hash())
+            .block_lookup(reward_cycle, &block.header.signer_signature_hash())
             .unwrap()
             .expect("Unable to get block from db");
 
@@ -246,11 +268,11 @@ mod tests {
             rejected: false,
         };
         block_info.vote = Some(vote.clone());
-        db.insert_block(&block_info)
+        db.insert_block(reward_cycle, &block_info)
             .expect("Unable to insert block into db");
 
         let block_info = db
-            .block_lookup(&block.header.signer_signature_hash())
+            .block_lookup(reward_cycle, &block.header.signer_signature_hash())
             .unwrap()
             .expect("Unable to get block from db");
 

From 25fba11b99006cd2ef792f909148f2bcb41d68b0 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Tue, 12 Mar 2024 09:28:51 -0700
Subject: [PATCH 1128/1166] feat: include signer bitvec in nakamoto block event

---
 testnet/stacks-node/src/event_dispatcher.rs            | 4 ++++
 testnet/stacks-node/src/tests/nakamoto_integrations.rs | 9 +++++++++
 2 files changed, 13 insertions(+)

diff --git a/testnet/stacks-node/src/event_dispatcher.rs b/testnet/stacks-node/src/event_dispatcher.rs
index 722ddc7af0..9bd33cd800 100644
--- a/testnet/stacks-node/src/event_dispatcher.rs
+++ b/testnet/stacks-node/src/event_dispatcher.rs
@@ -102,6 +102,7 @@ pub struct MinedNakamotoBlockEvent {
     pub block_size: u64,
     pub cost: ExecutionCost,
     pub tx_events: Vec<TransactionEvent>,
+    pub signer_bitvec: String,
 }
 
 impl EventObserver {
@@ -1023,6 +1024,8 @@ impl EventDispatcher {
             return;
         }
 
+        let signer_bitvec = bytes_to_hex(block.header.signer_bitvec.serialize_to_vec().as_slice());
+
         let payload = serde_json::to_value(MinedNakamotoBlockEvent {
             target_burn_height,
             block_hash: block.header.block_hash().to_string(),
@@ -1031,6 +1034,7 @@ impl EventDispatcher {
             block_size: block_size_bytes,
             cost: consumed.clone(),
             tx_events,
+            signer_bitvec,
         })
         .unwrap();
 
diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 075c745537..78e046e410 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -52,11 +52,13 @@ use stacks::net::api::getstackers::GetStackersResponse;
 use stacks::net::api::postblock_proposal::{
     BlockValidateReject, BlockValidateResponse, NakamotoBlockProposal, ValidateRejectCode,
 };
+use stacks::util::hash::hex_bytes;
 use stacks::util_lib::boot::boot_code_id;
 use stacks::util_lib::signed_structured_data::pox4::{
     make_pox_4_signer_key_signature, Pox4SignatureTopic,
 };
 use stacks_common::address::AddressHashMode;
+use stacks_common::bitvec::BitVec;
 use stacks_common::codec::StacksMessageCodec;
 use stacks_common::consts::{CHAIN_ID_TESTNET, STACKS_EPOCH_MAX};
 use stacks_common::types::chainstate::{
@@ -2143,6 +2145,13 @@ fn miner_writes_proposed_block_to_stackerdb() {
         "proposed_block_hash" => &proposed_block_hash,
     );
 
+    let signer_bitvec_str = observed_block.signer_bitvec.clone();
+    let signer_bitvec_bytes = hex_bytes(&signer_bitvec_str).unwrap();
+    let signer_bitvec = BitVec::<4000>::consensus_deserialize(&mut signer_bitvec_bytes.as_slice())
+        .expect("Failed to deserialize signer bitvec");
+
+    assert_eq!(signer_bitvec.len(), 1);
+
     assert_eq!(
         format!("0x{}", observed_block.block_hash),
         proposed_zero_block_hash,

From a97117cd2e08683f8b79b06f9ec8803abf6a8e0d Mon Sep 17 00:00:00 2001
From: Matthew Little <zone117x@gmail.com>
Date: Tue, 12 Mar 2024 17:59:46 +0100
Subject: [PATCH 1129/1166] chore: fix tests

---
 stackslib/src/chainstate/stacks/boot/mod.rs | 14 +++++---------
 1 file changed, 5 insertions(+), 9 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index f9f128c3e4..42c6ef8fb0 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -230,13 +230,10 @@ fn deserialize_optional_u128_from_string<'de, D>(deserializer: D) -> Result<Opti
 where
     D: serde::Deserializer<'de>,
 {
-    use std::str::FromStr;
-    let opt_str = Option::<String>::deserialize(deserializer)?;
-    match opt_str {
-        Some(s) => {
-            let parsed = u128::from_str(&s).map_err(serde::de::Error::custom)?;
-            Ok(Some(parsed))
-        }
+    use serde::de::Error;
+    let s: Option<String> = Option::deserialize(deserializer)?;
+    match s {
+        Some(str_val) => str_val.parse::<u128>().map(Some).map_err(D::Error::custom),
         None => Ok(None),
     }
 }
@@ -258,8 +255,7 @@ pub struct RewardSet {
     pub signers: Option<Vec<NakamotoSignerEntry>>,
     #[serde(
         serialize_with = "serialize_optional_u128_as_string",
-        deserialize_with = "deserialize_optional_u128_from_string",
-        skip_serializing_if = "Option::is_none"
+        deserialize_with = "deserialize_optional_u128_from_string"
     )]
     pub pox_stx_threshold: Option<u128>,
 }

From 27df25951faf6b899cf6d3879bf4fb5c6cd03d33 Mon Sep 17 00:00:00 2001
From: Matthew Little <zone117x@gmail.com>
Date: Tue, 12 Mar 2024 18:24:26 +0100
Subject: [PATCH 1130/1166] chore: simplify syntax

---
 stackslib/src/chainstate/stacks/boot/mod.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 42c6ef8fb0..f93ab59cb3 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -230,10 +230,9 @@ fn deserialize_optional_u128_from_string<'de, D>(deserializer: D) -> Result<Opti
 where
     D: serde::Deserializer<'de>,
 {
-    use serde::de::Error;
     let s: Option<String> = Option::deserialize(deserializer)?;
     match s {
-        Some(str_val) => str_val.parse::<u128>().map(Some).map_err(D::Error::custom),
+        Some(str_val) => str_val.parse::<u128>().map(Some).map_err(serde::de::Error::custom),
         None => Ok(None),
     }
 }

From ebbfe1e87e59041d5d300a69b5323b16b8b3db00 Mon Sep 17 00:00:00 2001
From: Matthew Little <zone117x@gmail.com>
Date: Tue, 12 Mar 2024 18:34:05 +0100
Subject: [PATCH 1131/1166] chore: pr feedback pox_stx_threshold to
 pox_ustx_threshold

---
 stacks-signer/src/client/stacks_client.rs     |  2 +-
 stackslib/src/chainstate/coordinator/tests.rs |  2 +-
 stackslib/src/chainstate/stacks/boot/mod.rs   | 11 +++++++----
 3 files changed, 9 insertions(+), 6 deletions(-)

diff --git a/stacks-signer/src/client/stacks_client.rs b/stacks-signer/src/client/stacks_client.rs
index 9d300c09b3..1cf142e13d 100644
--- a/stacks-signer/src/client/stacks_client.rs
+++ b/stacks-signer/src/client/stacks_client.rs
@@ -1143,7 +1143,7 @@ mod tests {
                 stacked_amt: rand::thread_rng().next_u64() as u128,
                 weight: 1,
             }]),
-            pox_stx_threshold: None,
+            pox_ustx_threshold: None,
         };
         let stackers_response = GetStackersResponse {
             stacker_set: stacker_set.clone(),
diff --git a/stackslib/src/chainstate/coordinator/tests.rs b/stackslib/src/chainstate/coordinator/tests.rs
index 3367bf5549..8bf7383d0b 100644
--- a/stackslib/src/chainstate/coordinator/tests.rs
+++ b/stackslib/src/chainstate/coordinator/tests.rs
@@ -511,7 +511,7 @@ impl RewardSetProvider for StubbedRewardSetProvider {
                 missed_reward_slots: vec![],
             },
             signers: None,
-            pox_stx_threshold: None,
+            pox_ustx_threshold: None,
         })
     }
 
diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index f93ab59cb3..687e04af24 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -232,7 +232,10 @@ where
 {
     let s: Option<String> = Option::deserialize(deserializer)?;
     match s {
-        Some(str_val) => str_val.parse::<u128>().map(Some).map_err(serde::de::Error::custom),
+        Some(str_val) => str_val
+            .parse::<u128>()
+            .map(Some)
+            .map_err(serde::de::Error::custom),
         None => Ok(None),
     }
 }
@@ -256,7 +259,7 @@ pub struct RewardSet {
         serialize_with = "serialize_optional_u128_as_string",
         deserialize_with = "deserialize_optional_u128_from_string"
     )]
-    pub pox_stx_threshold: Option<u128>,
+    pub pox_ustx_threshold: Option<u128>,
 }
 
 #[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
@@ -289,7 +292,7 @@ impl RewardSet {
                 missed_reward_slots: vec![],
             },
             signers: None,
-            pox_stx_threshold: None,
+            pox_ustx_threshold: None,
         }
     }
 
@@ -873,7 +876,7 @@ impl StacksChainState {
                 missed_reward_slots: missed_slots,
             },
             signers: signer_set,
-            pox_stx_threshold: Some(threshold),
+            pox_ustx_threshold: Some(threshold),
         }
     }
 

From cc997bfce21dbd4bad7ac9fc02cb4ceee931d06a Mon Sep 17 00:00:00 2001
From: janniks <janniks@users.noreply.github.com>
Date: Tue, 12 Mar 2024 18:17:16 +0100
Subject: [PATCH 1132/1166] test: cleanup pox event test

---
 pox-locking/src/events.rs                     |  5 +-
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 74 ++++++-------------
 2 files changed, 26 insertions(+), 53 deletions(-)

diff --git a/pox-locking/src/events.rs b/pox-locking/src/events.rs
index a2d6095a14..70123602b0 100644
--- a/pox-locking/src/events.rs
+++ b/pox-locking/src/events.rs
@@ -112,6 +112,7 @@ fn create_event_info_data_code(
     response: &ResponseData,
 ) -> String {
     // If a given burn block height is in a prepare phase, then the stacker will be in the _next_ reward cycle, so bump the cycle by 1
+    // `prepare_offset` is 1 or 0, depending on whether current execution is in a prepare phase or not
     let prepare_offset = r#"
         (prepare-offset (if (<
             (mod (- %height% (var-get first-burnchain-block-height)) (var-get pox-reward-cycle-length))
@@ -243,7 +244,7 @@ fn create_event_info_data_code(
                         ;; Get end cycle ID
                         end-cycle-id: (some (burn-height-to-reward-cycle unlock-height)),
                         ;; Get start cycle ID
-                        start-cycle-id: (+ (burn-height-to-reward-cycle unlock-height) prepare-offset),
+                        start-cycle-id: (+ (current-pox-reward-cycle) prepare-offset),
                     }}
                 }})
                 "#,
@@ -252,7 +253,7 @@ fn create_event_info_data_code(
                 signer_key = &args.get(2).unwrap_or(&Value::none()),
                 max_amount = &args.get(3).unwrap_or(&Value::none()),
                 auth_id = &args.get(4).unwrap_or(&Value::none()),
-                prepare_offset = prepare_offset.replace("%height%", "unlock-height"),
+                prepare_offset = prepare_offset.replace("%height%", "burn-block-height"),
             )
         }
         "delegate-stack-increase" => {
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 93479a4b34..04a289c987 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -1290,7 +1290,7 @@ fn pox_3_unlocks() {
     }
 }
 
-// This tests calls most of Clarity functions to check the existence of `start-cycle-id` and `end-cycle-id`
+// This tests calls most pox-4 Clarity functions to check the existence of `start-cycle-id` and `end-cycle-id`
 // in emitted pox events.
 // In this set up, Steph is a solo stacker and invokes `stack-stx`, `stack-increase` and `stack-extend` functions
 // Alice delegates to Bob via `delegate-stx`
@@ -1355,8 +1355,7 @@ fn pox_4_check_cycle_id_range_in_print_events() {
     }
 
     let reward_cycle = get_current_reward_cycle(&peer, &burnchain);
-    let steph_pox_addr = pox_addr_from(&steph_key);
-    let pox_addr_val = Value::Tuple(steph_pox_addr.clone().as_clarity_tuple().unwrap());
+    let next_reward_cycle = reward_cycle + 1;
 
     info!(
         "Block height: {}",
@@ -1367,7 +1366,7 @@ fn pox_4_check_cycle_id_range_in_print_events() {
     let block_height = get_tip(peer.sortdb.as_ref()).block_height;
     let min_ustx = get_stacking_minimum(&mut peer, &latest_block.unwrap());
 
-    //stack-stx
+    // stack-stx
     let steph_stack_stx_nonce = steph_nonce;
     let signature = make_signer_key_signature(
         &steph_pox_addr,
@@ -1392,7 +1391,7 @@ fn pox_4_check_cycle_id_range_in_print_events() {
     );
     steph_nonce += 1;
 
-    //stack-increase
+    // stack-increase
     let steph_stack_increase_nonce = steph_nonce;
     let signature = make_signer_key_signature(
         &steph_pox_addr,
@@ -1414,7 +1413,7 @@ fn pox_4_check_cycle_id_range_in_print_events() {
     );
     steph_nonce += 1;
 
-    //stack-extend
+    // stack-extend
     let steph_stack_extend_nonce = steph_nonce;
     let stack_extend_signature = make_signer_key_signature(
         &steph_pox_addr,
@@ -1425,7 +1424,6 @@ fn pox_4_check_cycle_id_range_in_print_events() {
         u128::MAX,
         1,
     );
-
     let steph_stack_extend = make_pox_4_extend(
         &steph_key,
         steph_stack_extend_nonce,
@@ -1438,13 +1436,12 @@ fn pox_4_check_cycle_id_range_in_print_events() {
     );
     steph_nonce += 1;
 
-    // alice delegates STX to Bob
-    let alice_delegation_amount_min_ustx = get_stacking_minimum(&mut peer, &latest_block.unwrap());
+    // alice delegates STX to bob
     let target_height = get_tip(peer.sortdb.as_ref()).block_height + 10;
     let alice_delegate = make_pox_4_delegate_stx(
         &alice,
         alice_nonce,
-        alice_delegation_amount_min_ustx,
+        min_ustx,
         bob_principal.clone(),
         Some(target_height as u128),
         Some(bob_pox_addr.clone()),
@@ -1458,16 +1455,13 @@ fn pox_4_check_cycle_id_range_in_print_events() {
         &bob,
         bob_nonce,
         alice_principal.clone(),
-        alice_delegation_amount_min_ustx,
+        min_ustx,
         bob_pox_addr.clone(),
         curr_height as u128,
         lock_period,
     );
     bob_nonce += 1;
 
-    let reward_cycle = get_current_reward_cycle(&peer, &burnchain);
-    let next_reward_cycle = reward_cycle + 1;
-
     let bob_aggregation_commit_nonce = bob_nonce;
     let signature = make_signer_key_signature(
         &bob_pox_addr,
@@ -1502,6 +1496,13 @@ fn pox_4_check_cycle_id_range_in_print_events() {
         &mut coinbase_nonce,
     ));
 
+    let tip = get_tip(peer.sortdb.as_ref());
+    let tipId = StacksBlockId::new(&tip.consensus_hash, &tip.canonical_stacks_tip_hash);
+    assert_eq!(tipId, latest_block.unwrap());
+
+    let in_prepare_phase = burnchain.is_in_prepare_phase(tip.block_height);
+    assert_eq!(in_prepare_phase, false);
+
     let blocks = observer.get_blocks();
     let mut steph_txs = HashMap::new();
     let mut alice_txs = HashMap::new();
@@ -1539,12 +1540,7 @@ fn pox_4_check_cycle_id_range_in_print_events() {
     let steph_stacking_tx_event = &steph_stacking_tx_events[0];
     let steph_stacking_op_data = HashMap::from([
         ("start-cycle-id", Value::UInt(22)),
-        (
-            "end-cycle-id",
-            Optional(OptionalData {
-                data: Some(Box::from(Value::UInt(24))),
-            }),
-        ),
+        ("end-cycle-id", Value::some(Value::UInt(24)).unwrap()),
     ]);
     let common_data = PoxPrintFields {
         op_name: "stack-stx".to_string(),
@@ -1560,13 +1556,9 @@ fn pox_4_check_cycle_id_range_in_print_events() {
     assert_eq!(steph_stack_increase_tx_events.len() as u64, 2);
     let steph_stack_increase_tx_event = &steph_stack_increase_tx_events[0];
     let steph_stack_increase_op_data = HashMap::from([
-        ("start-cycle-id", Value::UInt(24)),
-        (
-            "end-cycle-id",
-            Optional(OptionalData {
-                data: Some(Box::from(Value::UInt(24))),
-            }),
-        ),
+        // in the same block, so we essentially want to be able to disregard the first event (stack-stx)
+        ("start-cycle-id", Value::UInt(22)),
+        ("end-cycle-id", Value::some(Value::UInt(24)).unwrap()),
     ]);
     let common_data = PoxPrintFields {
         op_name: "stack-increase".to_string(),
@@ -1587,12 +1579,7 @@ fn pox_4_check_cycle_id_range_in_print_events() {
     let steph_stack_extend_tx_event = &steph_stack_extend_tx_events[0];
     let steph_stacking_op_data = HashMap::from([
         ("start-cycle-id", Value::UInt(24)),
-        (
-            "end-cycle-id",
-            Optional(OptionalData {
-                data: Some(Box::from(Value::UInt(25))),
-            }),
-        ),
+        ("end-cycle-id", Value::some(Value::UInt(25)).unwrap()),
     ]);
     let common_data = PoxPrintFields {
         op_name: "stack-extend".to_string(),
@@ -1613,12 +1600,7 @@ fn pox_4_check_cycle_id_range_in_print_events() {
     let alice_delegation_tx_event = &alice_delegation_tx_events[0];
     let alice_delegate_stx_op_data = HashMap::from([
         ("start-cycle-id", Value::UInt(22)),
-        (
-            "end-cycle-id",
-            Optional(OptionalData {
-                data: Some(Box::from(Value::UInt(24))),
-            }),
-        ),
+        ("end-cycle-id", Value::some(Value::UInt(24)).unwrap()),
     ]);
     let common_data = PoxPrintFields {
         op_name: "delegate-stx".to_string(),
@@ -1639,12 +1621,7 @@ fn pox_4_check_cycle_id_range_in_print_events() {
     let bob_delegate_stack_stx_tx_event = &bob_delegate_stack_stx_tx_events[0];
     let bob_delegate_stack_stx_tx_op_data = HashMap::from([
         ("start-cycle-id", Value::UInt(22)),
-        (
-            "end-cycle-id",
-            Optional(OptionalData {
-                data: Some(Box::from(Value::UInt(24))),
-            }),
-        ),
+        ("end-cycle-id", Value::some(Value::UInt(24)).unwrap()),
     ]);
     let common_data = PoxPrintFields {
         op_name: "delegate-stack-stx".to_string(),
@@ -1665,12 +1642,7 @@ fn pox_4_check_cycle_id_range_in_print_events() {
     let bob_aggregation_commit_tx_event = &bob_aggregation_commit_tx_events[0];
     let bob_aggregation_commit_tx_op_data = HashMap::from([
         ("start-cycle-id", Value::UInt(22)),
-        (
-            "end-cycle-id",
-            Optional(OptionalData {
-                data: Some(Box::from(Value::UInt(0))), //Is this supposed to be 0?!
-            }),
-        ),
+        ("end-cycle-id", Value::some(Value::UInt(0)).unwrap()), //Is this supposed to be 0?!
     ]);
     let common_data = PoxPrintFields {
         op_name: "stack-aggregation-commit-indexed".to_string(),

From ab915e31bac129fb017ee66602bb82ffc12be953 Mon Sep 17 00:00:00 2001
From: janniks <janniks@users.noreply.github.com>
Date: Tue, 12 Mar 2024 23:38:10 +0100
Subject: [PATCH 1133/1166] fix: update start and end cycle id generation

---
 pox-locking/src/events.rs                     |  61 +++----
 .../src/chainstate/stacks/boot/pox_4_tests.rs | 171 ++++++++++++++++--
 2 files changed, 182 insertions(+), 50 deletions(-)

diff --git a/pox-locking/src/events.rs b/pox-locking/src/events.rs
index 70123602b0..f01fde2d63 100644
--- a/pox-locking/src/events.rs
+++ b/pox-locking/src/events.rs
@@ -156,7 +156,7 @@ fn create_event_info_data_code(
                         ;; Get end cycle ID
                         end-cycle-id: (some (burn-height-to-reward-cycle unlock-burn-height)),
                         ;; Get start cycle ID
-                        start-cycle-id: (+ (current-pox-reward-cycle) prepare-offset),
+                        start-cycle-id: (+ (current-pox-reward-cycle) u1 prepare-offset),
                     }}
                 }})
                 "#,
@@ -203,7 +203,7 @@ fn create_event_info_data_code(
                         ;; Get end cycle ID
                         end-cycle-id: (some (burn-height-to-reward-cycle unlock-burn-height)),
                         ;; Get start cycle ID
-                        start-cycle-id: (+ (current-pox-reward-cycle) prepare-offset),
+                        start-cycle-id: (+ (current-pox-reward-cycle) u1 prepare-offset),
                     }}
                 }})
                 "#,
@@ -244,7 +244,7 @@ fn create_event_info_data_code(
                         ;; Get end cycle ID
                         end-cycle-id: (some (burn-height-to-reward-cycle unlock-height)),
                         ;; Get start cycle ID
-                        start-cycle-id: (+ (current-pox-reward-cycle) prepare-offset),
+                        start-cycle-id: (+ (current-pox-reward-cycle) u1 prepare-offset),
                     }}
                 }})
                 "#,
@@ -260,7 +260,7 @@ fn create_event_info_data_code(
             format!(
                 r#"
                 (let (
-                    (unlock-height (get unlock-height (stx-account tx-sender)))
+                    (unlock-height (get unlock-height (stx-account '{stacker})))
                     {prepare_offset}
                 )
                 {{
@@ -281,16 +281,16 @@ fn create_event_info_data_code(
                         ;; equal to args[0]
                         stacker: '{stacker},
                         ;; Get end cycle ID
-                        end-cycle-id: (burn-height-to-reward-cycle (get unlock-height (stx-account '{stacker}))),
+                        end-cycle-id: (some (burn-height-to-reward-cycle unlock-height)),
                         ;; Get start cycle ID
-                        start-cycle-id: (+ (burn-height-to-reward-cycle unlock-height) prepare-offset),
+                        start-cycle-id: (+ (current-pox-reward-cycle) u1 prepare-offset),
                     }}
                 }}
                 "#,
                 stacker = &args[0],
                 pox_addr = &args[1],
                 increase_by = &args[2],
-                prepare_offset = prepare_offset.replace("%height%", "unlock-height"),
+                prepare_offset = prepare_offset.replace("%height%", "burn-block-height"),
             )
         }
         "stack-extend" => {
@@ -330,7 +330,7 @@ fn create_event_info_data_code(
                         ;; Get end cycle ID
                         end-cycle-id: (some (burn-height-to-reward-cycle new-unlock-ht)),
                         ;; Get start cycle ID
-                        start-cycle-id: (+ (burn-height-to-reward-cycle unlock-height) prepare-offset),
+                        start-cycle-id: (+ (current-pox-reward-cycle) u1 prepare-offset),
                     }}
                 }})
                 "#,
@@ -340,7 +340,7 @@ fn create_event_info_data_code(
                 signer_key = &args.get(3).map_or("none".to_string(), |v| v.to_string()),
                 max_amount = &args.get(4).unwrap_or(&Value::none()),
                 auth_id = &args.get(5).unwrap_or(&Value::none()),
-                prepare_offset = prepare_offset.replace("%height%", "unlock-height"),
+                prepare_offset = prepare_offset.replace("%height%", "burn-block-height"),
             )
         }
         "delegate-stack-extend" => {
@@ -356,6 +356,7 @@ fn create_event_info_data_code(
                             unlock-in-cycle))
                     (last-extend-cycle  (- (+ first-extend-cycle {extend_count}) u1))
                     (new-unlock-ht (reward-cycle-to-burn-height (+ u1 last-extend-cycle)))
+                    {prepare_offset}
                 )
                 {{
                     data: {{
@@ -373,15 +374,16 @@ fn create_event_info_data_code(
                         ;; equal to args[0]
                         stacker: '{stacker},
                         ;; Get end cycle ID
-                        end-cycle-id: (burn-height-to-reward-cycle new-unlock-ht),
+                        end-cycle-id: (some (burn-height-to-reward-cycle new-unlock-ht)),
                         ;; Get start cycle ID
-                        start-cycle-id: (+ (burn-height-to-reward-cycle unlock-height) prepare-offset),
+                        start-cycle-id: (+ (current-pox-reward-cycle) u1 prepare-offset),
                     }}
                 }})
                 "#,
                 stacker = &args[0],
                 pox_addr = &args[1],
-                extend_count = &args[2]
+                extend_count = &args[2],
+                prepare_offset = prepare_offset.replace("%height%", "burn-block-height"),
             )
         }
         "stack-aggregation-commit" | "stack-aggregation-commit-indexed" => {
@@ -413,9 +415,9 @@ fn create_event_info_data_code(
                         ;; equal to args[5]
                         auth-id: {auth_id},
                         ;; Get end cycle ID
-                        end-cycle-id: (some (burn-height-to-reward-cycle (get unlock-height (stx-account tx-sender)))),
+                        end-cycle-id: (some {reward_cycle}),
                         ;; Get start cycle ID
-                        start-cycle-id: (+ (current-pox-reward-cycle) prepare-offset),
+                        start-cycle-id: {reward_cycle},
                     }}
                 }})
                 "#,
@@ -452,9 +454,9 @@ fn create_event_info_data_code(
                         ;; equal to args[2]
                         reward-cycle-index: {reward_cycle_index},
                         ;; Get end cycle ID
-                        end-cycle-id: (some (burn-height-to-reward-cycle unlock-height)),
+                        end-cycle-id: (some {reward_cycle}),
                         ;; Get start cycle ID
-                        start-cycle-id: (+ (burn-height-to-reward-cycle unlock-height) prepare-offset),
+                        start-cycle-id: {reward_cycle},
                     }}
                 }})
                 "#,
@@ -486,10 +488,11 @@ fn create_event_info_data_code(
                         pox-addr: {pox_addr},
                         ;; Get end cycle ID
                         end-cycle-id: (match {until_burn_height}
-	                            height (some (burn-height-to-reward-cycle height))
-	                            none),
+                            height (some (burn-height-to-reward-cycle height))
+                            none
+                        ),
                         ;; Get start cycle ID
-                        start-cycle-id: (+ (current-pox-reward-cycle) prepare-offset),
+                        start-cycle-id: (+ (current-pox-reward-cycle) u1 prepare-offset),
                     }}
                 }})
                 "#,
@@ -505,20 +508,15 @@ fn create_event_info_data_code(
                 eprintln!("Response data in revoke-delegate-stx is: {:?}", opt.data);
                 format!(
                     r#"
-                    (let (
-                        {prepare_offset}
-                    )
                     {{
                         data: {{
                             delegate-to: '{delegate_to},
                             ;; Get end cycle ID
-                            end-cycle-id: (match {until_burn_height}
-                                    height (some (burn-height-to-reward-cycle height))
-                                    none),
+                            end-cycle-id: (some (+ (current-pox-reward-cycle) u1)),
                             ;; Get start cycle ID
-                            start-cycle-id: (+ (current-pox-reward-cycle) prepare-offset),
+                            start-cycle-id: (+ (current-pox-reward-cycle) u1),
                         }},
-                    }})
+                    }}
                     "#,
                     delegate_to = opt
                         .data
@@ -529,15 +527,6 @@ fn create_event_info_data_code(
                         .expect("FATAL: unexpected clarity value")
                         .get("delegated-to")
                         .unwrap(),
-                    until_burn_height = opt
-                        .data
-                        .map(|boxed_value| *boxed_value)
-                        .unwrap()
-                        .expect_tuple()
-                        .expect("FATAL: unexpected clarity value")
-                        .get("until-burn-ht")
-                        .unwrap(),
-                    prepare_offset = prepare_offset.replace("%height%", "burn-block-height"),
                 )
             } else {
                 "{data: {unimplemented: true}}".into()
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 04a289c987..1461ed0ab4 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -1437,7 +1437,9 @@ fn pox_4_check_cycle_id_range_in_print_events() {
     steph_nonce += 1;
 
     // alice delegates STX to bob
-    let target_height = get_tip(peer.sortdb.as_ref()).block_height + 10;
+    let target_height = get_tip(peer.sortdb.as_ref()).block_height
+        + (3 * pox_constants.reward_cycle_length as u64) // 3 cycles (next cycle + 2)
+        + 1; // additional few blocks shouldn't matter to unlock-cycle
     let alice_delegate = make_pox_4_delegate_stx(
         &alice,
         alice_nonce,
@@ -1539,8 +1541,12 @@ fn pox_4_check_cycle_id_range_in_print_events() {
     assert_eq!(steph_stacking_tx_events.len() as u64, 2);
     let steph_stacking_tx_event = &steph_stacking_tx_events[0];
     let steph_stacking_op_data = HashMap::from([
-        ("start-cycle-id", Value::UInt(22)),
-        ("end-cycle-id", Value::some(Value::UInt(24)).unwrap()),
+        // matches the expected cycle, since we're not in a prepare phase
+        ("start-cycle-id", Value::UInt(next_reward_cycle)),
+        (
+            "end-cycle-id",
+            Value::some(Value::UInt(next_reward_cycle + lock_period)).unwrap(),
+        ),
     ]);
     let common_data = PoxPrintFields {
         op_name: "stack-stx".to_string(),
@@ -1556,9 +1562,12 @@ fn pox_4_check_cycle_id_range_in_print_events() {
     assert_eq!(steph_stack_increase_tx_events.len() as u64, 2);
     let steph_stack_increase_tx_event = &steph_stack_increase_tx_events[0];
     let steph_stack_increase_op_data = HashMap::from([
-        // in the same block, so we essentially want to be able to disregard the first event (stack-stx)
-        ("start-cycle-id", Value::UInt(22)),
-        ("end-cycle-id", Value::some(Value::UInt(24)).unwrap()),
+        // `stack-increase` is in the same block as `stack-stx`, so we essentially want to be able to override the first event
+        ("start-cycle-id", Value::UInt(next_reward_cycle)),
+        (
+            "end-cycle-id",
+            Value::some(Value::UInt(next_reward_cycle + lock_period)).unwrap(),
+        ),
     ]);
     let common_data = PoxPrintFields {
         op_name: "stack-increase".to_string(),
@@ -1578,8 +1587,11 @@ fn pox_4_check_cycle_id_range_in_print_events() {
     assert_eq!(steph_stack_extend_tx_events.len() as u64, 2);
     let steph_stack_extend_tx_event = &steph_stack_extend_tx_events[0];
     let steph_stacking_op_data = HashMap::from([
-        ("start-cycle-id", Value::UInt(24)),
-        ("end-cycle-id", Value::some(Value::UInt(25)).unwrap()),
+        ("start-cycle-id", Value::UInt(next_reward_cycle)),
+        (
+            "end-cycle-id",
+            Value::some(Value::UInt(next_reward_cycle + lock_period + 1)).unwrap(),
+        ),
     ]);
     let common_data = PoxPrintFields {
         op_name: "stack-extend".to_string(),
@@ -1599,8 +1611,11 @@ fn pox_4_check_cycle_id_range_in_print_events() {
     assert_eq!(alice_delegation_tx_events.len() as u64, 1);
     let alice_delegation_tx_event = &alice_delegation_tx_events[0];
     let alice_delegate_stx_op_data = HashMap::from([
-        ("start-cycle-id", Value::UInt(22)),
-        ("end-cycle-id", Value::some(Value::UInt(24)).unwrap()),
+        ("start-cycle-id", Value::UInt(next_reward_cycle)),
+        (
+            "end-cycle-id",
+            Value::some(Value::UInt(next_reward_cycle + 2)).unwrap(),
+        ),
     ]);
     let common_data = PoxPrintFields {
         op_name: "delegate-stx".to_string(),
@@ -1620,8 +1635,11 @@ fn pox_4_check_cycle_id_range_in_print_events() {
     assert_eq!(bob_delegate_stack_stx_tx_events.len() as u64, 2);
     let bob_delegate_stack_stx_tx_event = &bob_delegate_stack_stx_tx_events[0];
     let bob_delegate_stack_stx_tx_op_data = HashMap::from([
-        ("start-cycle-id", Value::UInt(22)),
-        ("end-cycle-id", Value::some(Value::UInt(24)).unwrap()),
+        ("start-cycle-id", Value::UInt(next_reward_cycle)),
+        (
+            "end-cycle-id",
+            Value::some(Value::UInt(next_reward_cycle + lock_period)).unwrap(),
+        ),
     ]);
     let common_data = PoxPrintFields {
         op_name: "delegate-stack-stx".to_string(),
@@ -1641,8 +1659,11 @@ fn pox_4_check_cycle_id_range_in_print_events() {
     assert_eq!(bob_aggregation_commit_tx_events.len() as u64, 1);
     let bob_aggregation_commit_tx_event = &bob_aggregation_commit_tx_events[0];
     let bob_aggregation_commit_tx_op_data = HashMap::from([
-        ("start-cycle-id", Value::UInt(22)),
-        ("end-cycle-id", Value::some(Value::UInt(0)).unwrap()), //Is this supposed to be 0?!
+        ("start-cycle-id", Value::UInt(next_reward_cycle)),
+        (
+            "end-cycle-id",
+            Value::some(Value::UInt(next_reward_cycle)).unwrap(),
+        ),
     ]);
     let common_data = PoxPrintFields {
         op_name: "stack-aggregation-commit-indexed".to_string(),
@@ -1658,6 +1679,128 @@ fn pox_4_check_cycle_id_range_in_print_events() {
     );
 }
 
+// This tests calls some pox-4 Clarity functions to check the existence of `start-cycle-id` and `end-cycle-id`
+// in emitted pox events.
+// In this setup, Steph solo stacks in the prepare phase
+#[test]
+fn pox_4_check_cycle_id_range_in_print_events_in_prepare_phase() {
+    // Config for this test
+    let (epochs, pox_constants) = make_test_epochs_pox();
+
+    let mut burnchain = Burnchain::default_unittest(
+        0,
+        &BurnchainHeaderHash::from_hex(BITCOIN_REGTEST_FIRST_BLOCK_HASH).unwrap(),
+    );
+    burnchain.pox_constants = pox_constants.clone();
+
+    let observer = TestEventObserver::new();
+
+    let (mut peer, mut keys) = instantiate_pox_peer_with_epoch(
+        &burnchain,
+        function_name!(),
+        Some(epochs.clone()),
+        Some(&observer),
+    );
+
+    assert_eq!(burnchain.pox_constants.reward_slots(), 6);
+    let mut coinbase_nonce = 0;
+    let mut latest_block = None;
+
+    let steph_key = keys.pop().unwrap();
+    let steph_address = key_to_stacks_addr(&steph_key);
+    let steph_principal = PrincipalData::from(steph_address.clone());
+    let steph_pox_addr_val =
+        make_pox_addr(AddressHashMode::SerializeP2PKH, steph_address.bytes.clone());
+    let steph_pox_addr = pox_addr_from(&steph_key);
+    let steph_signing_key = Secp256k1PublicKey::from_private(&steph_key);
+    let steph_key_val = Value::buff_from(steph_signing_key.to_bytes_compressed()).unwrap();
+
+    let mut steph_nonce = 0;
+
+    // Advance into pox4
+    let target_height = burnchain.pox_constants.pox_4_activation_height;
+    // produce blocks until the first reward phase that everyone should be in
+    while get_tip(peer.sortdb.as_ref()).block_height < u64::from(target_height) {
+        latest_block = Some(peer.tenure_with_txs(&[], &mut coinbase_nonce));
+    }
+    // produce blocks until the we're in the prepare phase
+    while !burnchain.is_in_prepare_phase(get_tip(peer.sortdb.as_ref()).block_height) {
+        latest_block = Some(peer.tenure_with_txs(&[], &mut coinbase_nonce));
+    }
+
+    let steph_balance = get_balance(&mut peer, &steph_principal);
+
+    info!(
+        "Block height: {}",
+        get_tip(peer.sortdb.as_ref()).block_height
+    );
+
+    let min_ustx = get_stacking_minimum(&mut peer, &latest_block.unwrap()) * 120 / 100; // * 1.2
+
+    // stack-stx
+    let steph_lock_period = 2;
+    let current_cycle = get_current_reward_cycle(&peer, &burnchain);
+    let next_cycle = current_cycle + 1;
+    let signature = make_signer_key_signature(
+        &steph_pox_addr,
+        &steph_key,
+        current_cycle,
+        &Pox4SignatureTopic::StackStx,
+        steph_lock_period,
+        u128::MAX,
+        1,
+    );
+    let steph_stacking = make_pox_4_lockup(
+        &steph_key,
+        steph_nonce,
+        min_ustx,
+        &steph_pox_addr.clone(),
+        steph_lock_period,
+        &steph_signing_key,
+        get_tip(peer.sortdb.as_ref()).block_height,
+        Some(signature),
+        u128::MAX,
+        1,
+    );
+    steph_nonce += 1;
+
+    latest_block = Some(peer.tenure_with_txs(&[steph_stacking.clone()], &mut coinbase_nonce));
+
+    let txs: HashMap<_, _> = observer
+        .get_blocks()
+        .into_iter()
+        .flat_map(|b| b.receipts)
+        .filter_map(|r| match r.transaction {
+            TransactionOrigin::Stacks(ref t) => Some((t.txid(), r.clone())),
+            _ => None,
+        })
+        .collect();
+
+    // Check event for stack-stx tx
+    let steph_stacking_receipt = txs.get(&steph_stacking.txid()).unwrap().clone();
+    assert_eq!(steph_stacking_receipt.events.len(), 2);
+    let steph_stacking_op_data = HashMap::from([
+        ("prep", Value::UInt(1)),                        // DEBUG
+        ("start-cycle-id", Value::UInt(next_cycle + 1)), // +1 because steph stacked during the prepare phase
+        (
+            "end-cycle-id",
+            Value::some(Value::UInt(next_cycle + steph_lock_period)).unwrap(),
+        ),
+    ]);
+    let common_data = PoxPrintFields {
+        op_name: "stack-stx".to_string(),
+        stacker: steph_principal.clone().into(),
+        balance: Value::UInt(steph_balance),
+        locked: Value::UInt(0),
+        burnchain_unlock_height: Value::UInt(0),
+    };
+    check_pox_print_event(
+        &steph_stacking_receipt.events[0],
+        common_data,
+        steph_stacking_op_data,
+    );
+}
+
 // test that revoke-delegate-stx calls emit an event and
 // test that revoke-delegate-stx is only successfull if user has delegated.
 #[test]

From 54651f40e92c357521ee55ef53e2b59da1e8e4a1 Mon Sep 17 00:00:00 2001
From: janniks <janniks@users.noreply.github.com>
Date: Wed, 13 Mar 2024 00:00:10 +0100
Subject: [PATCH 1134/1166] chore: remove unneeded lets

---
 pox-locking/src/events.rs | 13 ++-----------
 1 file changed, 2 insertions(+), 11 deletions(-)

diff --git a/pox-locking/src/events.rs b/pox-locking/src/events.rs
index f01fde2d63..e01b01a0fd 100644
--- a/pox-locking/src/events.rs
+++ b/pox-locking/src/events.rs
@@ -389,9 +389,6 @@ fn create_event_info_data_code(
         "stack-aggregation-commit" | "stack-aggregation-commit-indexed" => {
             format!(
                 r#"
-                (let (
-                    {prepare_offset}
-                )
                 {{
                     data: {{
                         ;; pox addr locked up
@@ -419,7 +416,7 @@ fn create_event_info_data_code(
                         ;; Get start cycle ID
                         start-cycle-id: {reward_cycle},
                     }}
-                }})
+                }}
                 "#,
                 pox_addr = &args[0],
                 reward_cycle = &args[1],
@@ -427,16 +424,11 @@ fn create_event_info_data_code(
                 signer_key = &args.get(3).unwrap_or(&Value::none()),
                 max_amount = &args.get(4).unwrap_or(&Value::none()),
                 auth_id = &args.get(5).unwrap_or(&Value::none()),
-                prepare_offset = prepare_offset.replace("%height%", "burn-block-height"),
             )
         }
         "stack-aggregation-increase" => {
             format!(
                 r#"
-                (let (
-                    (unlock-height (get unlock-height (stx-account tx-sender)))
-                    {prepare_offset}
-                )
                 {{
                     data: {{
                         ;; pox addr locked up
@@ -458,12 +450,11 @@ fn create_event_info_data_code(
                         ;; Get start cycle ID
                         start-cycle-id: {reward_cycle},
                     }}
-                }})
+                }}
                 "#,
                 pox_addr = &args[0],
                 reward_cycle = &args[1],
                 reward_cycle_index = &args.get(2).unwrap_or(&Value::none()),
-                prepare_offset = prepare_offset.replace("%height%", "unlock-height"),
             )
         }
         "delegate-stx" => {

From a5e655070a5dc2cc244556d716aa42017e077445 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Wed, 13 Mar 2024 07:22:23 -0700
Subject: [PATCH 1135/1166] feat: add signer bitvec to `/new_block`

---
 stackslib/src/chainstate/coordinator/mod.rs   |  2 ++
 stackslib/src/chainstate/coordinator/tests.rs |  1 +
 stackslib/src/chainstate/nakamoto/mod.rs      |  3 ++
 stackslib/src/chainstate/stacks/db/blocks.rs  |  3 ++
 stackslib/src/net/mod.rs                      |  1 +
 testnet/stacks-node/src/event_dispatcher.rs   | 32 ++++++++++++++++++-
 testnet/stacks-node/src/run_loop/mod.rs       |  1 +
 7 files changed, 42 insertions(+), 1 deletion(-)

diff --git a/stackslib/src/chainstate/coordinator/mod.rs b/stackslib/src/chainstate/coordinator/mod.rs
index a05cbc94b1..bd1d184597 100644
--- a/stackslib/src/chainstate/coordinator/mod.rs
+++ b/stackslib/src/chainstate/coordinator/mod.rs
@@ -26,6 +26,7 @@ use clarity::vm::costs::ExecutionCost;
 use clarity::vm::database::BurnStateDB;
 use clarity::vm::types::{PrincipalData, QualifiedContractIdentifier};
 use clarity::vm::Value;
+use stacks_common::bitvec::BitVec;
 use stacks_common::types::chainstate::{
     BlockHeaderHash, BurnchainHeaderHash, PoxId, SortitionId, StacksBlockId,
 };
@@ -177,6 +178,7 @@ pub trait BlockEventDispatcher {
         mblock_confirmed_consumed: &ExecutionCost,
         pox_constants: &PoxConstants,
         reward_set_data: &Option<RewardSetData>,
+        signer_bitvec: &Option<BitVec<4000>>,
     );
 
     /// called whenever a burn block is about to be
diff --git a/stackslib/src/chainstate/coordinator/tests.rs b/stackslib/src/chainstate/coordinator/tests.rs
index e3fc8f21c4..36afd22bcc 100644
--- a/stackslib/src/chainstate/coordinator/tests.rs
+++ b/stackslib/src/chainstate/coordinator/tests.rs
@@ -427,6 +427,7 @@ impl BlockEventDispatcher for NullEventDispatcher {
         _confirmed_mblock_cost: &ExecutionCost,
         _pox_constants: &PoxConstants,
         _reward_set_data: &Option<RewardSetData>,
+        _signer_bitvec: &Option<BitVec<4000>>,
     ) {
         assert!(
             false,
diff --git a/stackslib/src/chainstate/nakamoto/mod.rs b/stackslib/src/chainstate/nakamoto/mod.rs
index 8ab9f22697..173bb2ca86 100644
--- a/stackslib/src/chainstate/nakamoto/mod.rs
+++ b/stackslib/src/chainstate/nakamoto/mod.rs
@@ -1437,6 +1437,8 @@ impl NakamotoChainState {
         // succeeds, since *we have already processed* the block.
         Self::infallible_set_block_processed(stacks_chain_state, &block_id);
 
+        let signer_bitvec = (&next_ready_block).header.signer_bitvec.clone();
+
         // announce the block, if we're connected to an event dispatcher
         if let Some(dispatcher) = dispatcher_opt {
             let block_event = (
@@ -1459,6 +1461,7 @@ impl NakamotoChainState {
                 &receipt.parent_microblocks_cost,
                 &pox_constants,
                 &reward_set_data,
+                &Some(signer_bitvec),
             );
         }
 
diff --git a/stackslib/src/chainstate/stacks/db/blocks.rs b/stackslib/src/chainstate/stacks/db/blocks.rs
index f55168171c..1c924f95ec 100644
--- a/stackslib/src/chainstate/stacks/db/blocks.rs
+++ b/stackslib/src/chainstate/stacks/db/blocks.rs
@@ -37,6 +37,7 @@ use rand::{thread_rng, Rng, RngCore};
 use rusqlite::{Connection, DatabaseName, Error as sqlite_error, OptionalExtension};
 use serde::Serialize;
 use serde_json::json;
+use stacks_common::bitvec::BitVec;
 use stacks_common::codec::{read_next, write_next, MAX_MESSAGE_LEN};
 use stacks_common::types::chainstate::{
     BurnchainHeaderHash, SortitionId, StacksAddress, StacksBlockId,
@@ -182,6 +183,7 @@ impl BlockEventDispatcher for DummyEventDispatcher {
         _confirmed_mblock_cost: &ExecutionCost,
         _pox_constants: &PoxConstants,
         _reward_set_data: &Option<RewardSetData>,
+        _signer_bitvec: &Option<BitVec<4000>>,
     ) {
         assert!(
             false,
@@ -6142,6 +6144,7 @@ impl StacksChainState {
                 &epoch_receipt.parent_microblocks_cost,
                 &pox_constants,
                 &reward_set_data,
+                &None,
             );
         }
 
diff --git a/stackslib/src/net/mod.rs b/stackslib/src/net/mod.rs
index d212aa50fd..d3d6137373 100644
--- a/stackslib/src/net/mod.rs
+++ b/stackslib/src/net/mod.rs
@@ -1901,6 +1901,7 @@ pub mod test {
             _confirmed_mblock_cost: &ExecutionCost,
             pox_constants: &PoxConstants,
             reward_set_data: &Option<RewardSetData>,
+            _signer_bitvec: &Option<BitVec<4000>>,
         ) {
             self.blocks.lock().unwrap().push(TestEventObserverBlock {
                 block: block.clone(),
diff --git a/testnet/stacks-node/src/event_dispatcher.rs b/testnet/stacks-node/src/event_dispatcher.rs
index 9bd33cd800..7b8e4108ce 100644
--- a/testnet/stacks-node/src/event_dispatcher.rs
+++ b/testnet/stacks-node/src/event_dispatcher.rs
@@ -36,6 +36,7 @@ use stacks::net::api::postblock_proposal::{
 };
 use stacks::net::atlas::{Attachment, AttachmentInstance};
 use stacks::net::stackerdb::StackerDBEventDispatcher;
+use stacks_common::bitvec::BitVec;
 use stacks_common::codec::StacksMessageCodec;
 use stacks_common::types::chainstate::{BlockHeaderHash, BurnchainHeaderHash, StacksBlockId};
 use stacks_common::util::hash::bytes_to_hex;
@@ -389,6 +390,7 @@ impl EventObserver {
         mblock_confirmed_consumed: &ExecutionCost,
         pox_constants: &PoxConstants,
         reward_set_data: &Option<RewardSetData>,
+        signer_bitvec_opt: &Option<BitVec<4000>>,
     ) -> serde_json::Value {
         // Serialize events to JSON
         let serialized_events: Vec<serde_json::Value> = filtered_events
@@ -434,6 +436,13 @@ impl EventObserver {
             "pox_v3_unlock_height": pox_constants.v3_unlock_height,
         });
 
+        if let Some(signer_bitvec) = signer_bitvec_opt {
+            payload.as_object_mut().unwrap().insert(
+                "signer_bitvec".to_string(),
+                serde_json::to_value(signer_bitvec).unwrap_or_default(),
+            );
+        }
+
         if let Some(reward_set_data) = reward_set_data {
             payload.as_object_mut().unwrap().insert(
                 "reward_set".to_string(),
@@ -603,6 +612,7 @@ impl BlockEventDispatcher for EventDispatcher {
         mblock_confirmed_consumed: &ExecutionCost,
         pox_constants: &PoxConstants,
         reward_set_data: &Option<RewardSetData>,
+        signer_bitvec: &Option<BitVec<4000>>,
     ) {
         self.process_chain_tip(
             block,
@@ -619,6 +629,7 @@ impl BlockEventDispatcher for EventDispatcher {
             mblock_confirmed_consumed,
             pox_constants,
             reward_set_data,
+            signer_bitvec,
         );
     }
 
@@ -800,6 +811,7 @@ impl EventDispatcher {
         mblock_confirmed_consumed: &ExecutionCost,
         pox_constants: &PoxConstants,
         reward_set_data: &Option<RewardSetData>,
+        signer_bitvec: &Option<BitVec<4000>>,
     ) {
         let all_receipts = receipts.to_owned();
         let (dispatch_matrix, events) = self.create_dispatch_matrix_and_event_vector(&all_receipts);
@@ -850,6 +862,7 @@ impl EventDispatcher {
                         mblock_confirmed_consumed,
                         pox_constants,
                         reward_set_data,
+                        signer_bitvec,
                     );
 
                 // Send payload
@@ -1024,7 +1037,11 @@ impl EventDispatcher {
             return;
         }
 
-        let signer_bitvec = bytes_to_hex(block.header.signer_bitvec.serialize_to_vec().as_slice());
+        let signer_bitvec = serde_json::to_value(block.header.signer_bitvec.clone())
+            .unwrap_or_default()
+            .as_str()
+            .unwrap_or_default()
+            .to_string();
 
         let payload = serde_json::to_value(MinedNakamotoBlockEvent {
             target_burn_height,
@@ -1198,6 +1215,7 @@ mod test {
     use stacks::burnchains::{PoxConstants, Txid};
     use stacks::chainstate::stacks::db::StacksHeaderInfo;
     use stacks::chainstate::stacks::StacksBlock;
+    use stacks_common::bitvec::BitVec;
     use stacks_common::types::chainstate::{BurnchainHeaderHash, StacksBlockId};
 
     use crate::event_dispatcher::EventObserver;
@@ -1221,6 +1239,7 @@ mod test {
         let anchored_consumed = ExecutionCost::zero();
         let mblock_confirmed_consumed = ExecutionCost::zero();
         let pox_constants = PoxConstants::testnet_default();
+        let signer_bitvec = BitVec::zeros(2).expect("Failed to create BitVec with length 2");
 
         let payload = observer.make_new_block_processed_payload(
             filtered_events,
@@ -1237,6 +1256,7 @@ mod test {
             &mblock_confirmed_consumed,
             &pox_constants,
             &None,
+            &Some(signer_bitvec.clone()),
         );
         assert_eq!(
             payload
@@ -1246,5 +1266,15 @@ mod test {
                 .unwrap(),
             pox_constants.v1_unlock_height as u64
         );
+
+        let expected_bitvec_str = serde_json::to_value(signer_bitvec)
+            .unwrap_or_default()
+            .as_str()
+            .unwrap()
+            .to_string();
+        assert_eq!(
+            payload.get("signer_bitvec").unwrap().as_str().unwrap(),
+            expected_bitvec_str
+        );
     }
 }
diff --git a/testnet/stacks-node/src/run_loop/mod.rs b/testnet/stacks-node/src/run_loop/mod.rs
index 49cb4fb337..01f848c2e6 100644
--- a/testnet/stacks-node/src/run_loop/mod.rs
+++ b/testnet/stacks-node/src/run_loop/mod.rs
@@ -193,5 +193,6 @@ pub fn announce_boot_receipts(
         &ExecutionCost::zero(),
         pox_constants,
         &None,
+        &None,
     );
 }

From fdf193554e1313ec157a7a99c589d2e9a2d6fe61 Mon Sep 17 00:00:00 2001
From: Hugo Caillard <911307+hugocaillard@users.noreply.github.com>
Date: Wed, 13 Mar 2024 16:44:02 +0100
Subject: [PATCH 1136/1166] refactor: add a new 'devtools' feature in clarity
 crate

---
 clarity/Cargo.toml         | 2 +-
 clarity/src/vm/contexts.rs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/clarity/Cargo.toml b/clarity/Cargo.toml
index 4d51cf3e4e..36caeb828b 100644
--- a/clarity/Cargo.toml
+++ b/clarity/Cargo.toml
@@ -55,4 +55,4 @@ default = []
 developer-mode = []
 slog_json = ["stacks_common/slog_json"]
 testing = []
-
+devtools = []
diff --git a/clarity/src/vm/contexts.rs b/clarity/src/vm/contexts.rs
index 3176fc9551..4e408ca540 100644
--- a/clarity/src/vm/contexts.rs
+++ b/clarity/src/vm/contexts.rs
@@ -1739,7 +1739,7 @@ impl<'a, 'hooks> GlobalContext<'a, 'hooks> {
                     self.roll_back()?;
                 }
                 Ok(Value::Response(data))
-            } else if allow_private && cfg!(feature = "developer-mode") {
+            } else if allow_private && cfg!(feature = "devtools") {
                 self.commit()?;
                 Ok(result)
             } else {

From 6b01281e4ca640751d92c7e2c3d604d74ecf6329 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Wed, 13 Mar 2024 08:46:21 -0700
Subject: [PATCH 1137/1166] fix: add wsts::Point validation to
 `vote-for-aggregate-key` burn op

---
 .../burn/operations/vote_for_aggregate_key.rs | 45 +++++++++++++++++--
 1 file changed, 42 insertions(+), 3 deletions(-)

diff --git a/stackslib/src/chainstate/burn/operations/vote_for_aggregate_key.rs b/stackslib/src/chainstate/burn/operations/vote_for_aggregate_key.rs
index 3fe7e85d1c..3933eacaa6 100644
--- a/stackslib/src/chainstate/burn/operations/vote_for_aggregate_key.rs
+++ b/stackslib/src/chainstate/burn/operations/vote_for_aggregate_key.rs
@@ -21,6 +21,7 @@ use stacks_common::deps_common::bitcoin::blockdata::script::Builder;
 use stacks_common::types::chainstate::{BurnchainHeaderHash, StacksAddress};
 use stacks_common::types::StacksPublicKeyBuffer;
 use stacks_common::util::secp256k1::Secp256k1PublicKey;
+use wsts::curve::point::{Compressed, Point};
 
 use crate::burnchains::bitcoin::bits::parse_script;
 use crate::burnchains::bitcoin::{BitcoinTxInput, BitcoinTxInputStructured};
@@ -172,14 +173,27 @@ impl VoteForAggregateKeyOp {
         })
     }
 
+    /// Check the payload of a vote-for-aggregate-key burn op.
+    /// Both `signer_key` and `aggregate_key` are checked for validity against
+    /// `Secp256k1PublicKey` from `stacks_common` as well as `Point` from wsts.
     pub fn check(&self) -> Result<(), op_error> {
         // Check to see if the aggregate key is valid
-        Secp256k1PublicKey::from_slice(self.aggregate_key.as_bytes())
+        let aggregate_key_bytes = self.aggregate_key.as_bytes();
+        Secp256k1PublicKey::from_slice(aggregate_key_bytes)
             .map_err(|_| op_error::VoteForAggregateKeyInvalidKey)?;
 
+        let compressed = Compressed::try_from(aggregate_key_bytes.clone())
+            .map_err(|_| op_error::VoteForAggregateKeyInvalidKey)?;
+        Point::try_from(&compressed).map_err(|_| op_error::VoteForAggregateKeyInvalidKey)?;
+
         // Check to see if the signer key is valid
-        Secp256k1PublicKey::from_slice(self.signer_key.as_bytes())
+        let signer_key_bytes = self.signer_key.as_bytes();
+        Secp256k1PublicKey::from_slice(signer_key_bytes)
+            .map_err(|_| op_error::VoteForAggregateKeyInvalidKey)?;
+
+        let compressed = Compressed::try_from(signer_key_bytes.clone())
             .map_err(|_| op_error::VoteForAggregateKeyInvalidKey)?;
+        Point::try_from(&compressed).map_err(|_| op_error::VoteForAggregateKeyInvalidKey)?;
 
         Ok(())
     }
@@ -217,8 +231,9 @@ impl StacksMessageCodec for VoteForAggregateKeyOp {
 #[cfg(test)]
 mod tests {
     use stacks_common::deps_common::bitcoin::blockdata::script::Builder;
+    use stacks_common::types;
     use stacks_common::types::chainstate::{BurnchainHeaderHash, StacksAddress};
-    use stacks_common::types::StacksPublicKeyBuffer;
+    use stacks_common::types::{Address, StacksPublicKeyBuffer};
     use stacks_common::util::hash::*;
     use stacks_common::util::secp256k1::Secp256k1PublicKey;
 
@@ -381,4 +396,28 @@ mod tests {
             &signer_key.to_bytes_compressed().as_slice().into()
         );
     }
+
+    #[test]
+    fn test_key_validation() {
+        let sender_addr = "ST2QKZ4FKHAH1NQKYKYAYZPY440FEPK7GZ1R5HBP2";
+        let sender = StacksAddress::from_string(sender_addr).unwrap();
+        let op = VoteForAggregateKeyOp {
+            sender,
+            reward_cycle: 10,
+            round: 1,
+            signer_index: 12,
+            signer_key: StacksPublicKeyBuffer([0x00; 33]),
+            aggregate_key: StacksPublicKeyBuffer([0x00; 33]),
+            txid: Txid([10u8; 32]),
+            vtxindex: 10,
+            block_height: 10,
+            burn_header_hash: BurnchainHeaderHash([0x10; 32]),
+        };
+
+        match op.check() {
+            Ok(_) => panic!("Invalid key should not pass validation"),
+            Err(op_error::VoteForAggregateKeyInvalidKey) => (),
+            Err(e) => panic!("Unexpected error: {:?}", e),
+        }
+    }
 }

From 4ea7e1a104cbe4b05af2d5b241b98254ca435f3d Mon Sep 17 00:00:00 2001
From: Hugo Caillard <911307+hugocaillard@users.noreply.github.com>
Date: Wed, 13 Mar 2024 11:36:00 +0100
Subject: [PATCH 1138/1166] test: upgrade core-contract-tests dependencies

---
 .../deployments/default.simnet-plan.yaml      |   87 +
 contrib/core-contract-tests/package-lock.json | 2442 ++++++++++-------
 contrib/core-contract-tests/package.json      |   15 +-
 contrib/core-contract-tests/vitest.config.js  |   13 +-
 4 files changed, 1488 insertions(+), 1069 deletions(-)
 create mode 100644 contrib/core-contract-tests/deployments/default.simnet-plan.yaml

diff --git a/contrib/core-contract-tests/deployments/default.simnet-plan.yaml b/contrib/core-contract-tests/deployments/default.simnet-plan.yaml
new file mode 100644
index 0000000000..573a58fe51
--- /dev/null
+++ b/contrib/core-contract-tests/deployments/default.simnet-plan.yaml
@@ -0,0 +1,87 @@
+---
+id: 0
+name: "Simulated deployment, used as a default for `clarinet console`, `clarinet test` and `clarinet check`"
+network: simnet
+genesis:
+  wallets:
+    - name: deployer
+      address: ST1PQHQKV0RJXZFY1DGX8MNSNYVE3VGZJSRTPGZGM
+      balance: "100000000000000"
+    - name: wallet_1
+      address: ST1SJ3DTE5DN7X54YDH5D64R3BCB6A2AG2ZQ8YPD5
+      balance: "100000000000000"
+    - name: wallet_2
+      address: ST2CY5V39NHDPWSXMW9QDT3HC3GD6Q6XX4CFRK9AG
+      balance: "100000000000000"
+    - name: wallet_3
+      address: ST2JHG361ZXG51QTKY2NQCVBPPRRE2KZB1HR05NNC
+      balance: "100000000000000"
+    - name: wallet_4
+      address: ST2NEB84ASENDXKYGJPQW86YXQCEFEX2ZQPG87ND
+      balance: "100000000000000"
+    - name: wallet_5
+      address: ST2REHHS5J3CERCRBEPMGH7921Q6PYKAADT7JP2VB
+      balance: "100000000000000"
+    - name: wallet_6
+      address: ST3AM1A56AK2C1XAFJ4115ZSV26EB49BVQ10MGCS0
+      balance: "100000000000000"
+    - name: wallet_7
+      address: ST3PF13W7Z0RRM42A8VZRVFQ75SV1K26RXEP8YGKJ
+      balance: "100000000000000"
+    - name: wallet_8
+      address: ST3NBRSFKX28FQ2ZJ1MAKX58HKHSDGNV5N7R21XCP
+      balance: "100000000000000"
+    - name: wallet_9
+      address: STNHKEPYEPJ8ET55ZZ0M5A34J0R3N5FM2CMMMAZ6
+      balance: "100000000000000"
+  contracts:
+    - costs
+    - pox
+    - pox-2
+    - pox-3
+    - pox-4
+    - lockup
+    - costs-2
+    - costs-3
+    - cost-voting
+    - bns
+plan:
+  batches:
+    - id: 0
+      transactions:
+        - emulated-contract-publish:
+            contract-name: bns
+            emulated-sender: ST1PQHQKV0RJXZFY1DGX8MNSNYVE3VGZJSRTPGZGM
+            path: "../../stackslib/src/chainstate/stacks/boot/bns.clar"
+            clarity-version: 2
+        - emulated-contract-publish:
+            contract-name: bns_test
+            emulated-sender: ST1PQHQKV0RJXZFY1DGX8MNSNYVE3VGZJSRTPGZGM
+            path: "./tests/bns_test.clar"
+            clarity-version: 2
+        - emulated-contract-publish:
+            contract-name: pox-4
+            emulated-sender: ST1PQHQKV0RJXZFY1DGX8MNSNYVE3VGZJSRTPGZGM
+            path: "../../stackslib/src/chainstate/stacks/boot/pox-4.clar"
+            clarity-version: 2
+        - emulated-contract-publish:
+            contract-name: pox-mainnet
+            emulated-sender: ST1PQHQKV0RJXZFY1DGX8MNSNYVE3VGZJSRTPGZGM
+            path: "../../stackslib/src/chainstate/stacks/boot/pox-mainnet.clar"
+            clarity-version: 2
+        - emulated-contract-publish:
+            contract-name: pox_4_test
+            emulated-sender: ST1PQHQKV0RJXZFY1DGX8MNSNYVE3VGZJSRTPGZGM
+            path: "./tests/pox_4_test.clar"
+            clarity-version: 2
+        - emulated-contract-publish:
+            contract-name: signers
+            emulated-sender: ST1PQHQKV0RJXZFY1DGX8MNSNYVE3VGZJSRTPGZGM
+            path: "../../stackslib/src/chainstate/stacks/boot/signers.clar"
+            clarity-version: 2
+        - emulated-contract-publish:
+            contract-name: signers-voting
+            emulated-sender: ST1PQHQKV0RJXZFY1DGX8MNSNYVE3VGZJSRTPGZGM
+            path: "../../stackslib/src/chainstate/stacks/boot/signers-voting.clar"
+            clarity-version: 2
+      epoch: "2.4"
diff --git a/contrib/core-contract-tests/package-lock.json b/contrib/core-contract-tests/package-lock.json
index cb7cba8a42..02c1d40f41 100644
--- a/contrib/core-contract-tests/package-lock.json
+++ b/contrib/core-contract-tests/package-lock.json
@@ -9,15 +9,15 @@
       "version": "1.0.0",
       "license": "ISC",
       "dependencies": {
-        "@hirosystems/clarinet-sdk": "^1.1.0",
+        "@hirosystems/clarinet-sdk": "^2.4.0-beta3",
         "@stacks/clarunit": "0.0.1",
         "@stacks/transactions": "^6.12.0",
         "chokidar-cli": "^3.0.0",
         "fast-check": "^3.15.1",
-        "typescript": "^5.2.2",
-        "vite": "^4.4.9",
-        "vitest": "^0.34.4",
-        "vitest-environment-clarinet": "^1.0.0"
+        "typescript": "^5.4.2",
+        "vite": "^5.1.6",
+        "vitest": "^1.3.1",
+        "vitest-environment-clarinet": "^2.0.0"
       }
     },
     "node_modules/@aashutoshrathi/word-wrap": {
@@ -28,10 +28,70 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/@esbuild/aix-ppc64": {
+      "version": "0.19.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.19.12.tgz",
+      "integrity": "sha512-bmoCYyWdEL3wDQIVbcyzRyeKLgk2WtWLTWz1ZIAZF/EGbNOwSA6ew3PftJ1PqMiOOGu0OyFMzG53L0zqIpPeNA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/android-arm": {
+      "version": "0.19.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.19.12.tgz",
+      "integrity": "sha512-qg/Lj1mu3CdQlDEEiWrlC4eaPZ1KztwGJ9B6J+/6G+/4ewxJg7gqj8eVYWvao1bXrqGiW2rsBZFSX3q2lcW05w==",
+      "cpu": [
+        "arm"
+      ],
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/android-arm64": {
+      "version": "0.19.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.19.12.tgz",
+      "integrity": "sha512-P0UVNGIienjZv3f5zq0DP3Nt2IE/3plFzuaS96vihvD0Hd6H/q4WXUGpCxD/E8YrSXfNyRPbpTq+T8ZQioSuPA==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/android-x64": {
+      "version": "0.19.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.19.12.tgz",
+      "integrity": "sha512-3k7ZoUW6Q6YqhdhIaq/WZ7HwBpnFBlW905Fa4s4qWJyiNOgT1dOqDiVAQFwBH7gBRZr17gLrlFCRzF6jFh7Kew==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
     "node_modules/@esbuild/darwin-arm64": {
-      "version": "0.18.20",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.18.20.tgz",
-      "integrity": "sha512-bxRHW5kHU38zS2lPTPOyuyTm+S+eobPUnTNkdJEfAddYgEcll4xkT8DB9d2008DtTbl7uJag2HuE5NZAZgnNEA==",
+      "version": "0.19.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.19.12.tgz",
+      "integrity": "sha512-B6IeSgZgtEzGC42jsI+YYu9Z3HKRxp8ZT3cqhvliEHovq8HSX2YX8lNocDn79gCKJXOSaEot9MVYky7AKjCs8g==",
       "cpu": [
         "arm64"
       ],
@@ -43,6 +103,276 @@
         "node": ">=12"
       }
     },
+    "node_modules/@esbuild/darwin-x64": {
+      "version": "0.19.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.19.12.tgz",
+      "integrity": "sha512-hKoVkKzFiToTgn+41qGhsUJXFlIjxI/jSYeZf3ugemDYZldIXIxhvwN6erJGlX4t5h417iFuheZ7l+YVn05N3A==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.19.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.19.12.tgz",
+      "integrity": "sha512-4aRvFIXmwAcDBw9AueDQ2YnGmz5L6obe5kmPT8Vd+/+x/JMVKCgdcRwH6APrbpNXsPz+K653Qg8HB/oXvXVukA==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/freebsd-x64": {
+      "version": "0.19.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.19.12.tgz",
+      "integrity": "sha512-EYoXZ4d8xtBoVN7CEwWY2IN4ho76xjYXqSXMNccFSx2lgqOG/1TBPW0yPx1bJZk94qu3tX0fycJeeQsKovA8gg==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-arm": {
+      "version": "0.19.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.19.12.tgz",
+      "integrity": "sha512-J5jPms//KhSNv+LO1S1TX1UWp1ucM6N6XuL6ITdKWElCu8wXP72l9MM0zDTzzeikVyqFE6U8YAV9/tFyj0ti+w==",
+      "cpu": [
+        "arm"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-arm64": {
+      "version": "0.19.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.19.12.tgz",
+      "integrity": "sha512-EoTjyYyLuVPfdPLsGVVVC8a0p1BFFvtpQDB/YLEhaXyf/5bczaGeN15QkR+O4S5LeJ92Tqotve7i1jn35qwvdA==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-ia32": {
+      "version": "0.19.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.19.12.tgz",
+      "integrity": "sha512-Thsa42rrP1+UIGaWz47uydHSBOgTUnwBwNq59khgIwktK6x60Hivfbux9iNR0eHCHzOLjLMLfUMLCypBkZXMHA==",
+      "cpu": [
+        "ia32"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-loong64": {
+      "version": "0.19.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.19.12.tgz",
+      "integrity": "sha512-LiXdXA0s3IqRRjm6rV6XaWATScKAXjI4R4LoDlvO7+yQqFdlr1Bax62sRwkVvRIrwXxvtYEHHI4dm50jAXkuAA==",
+      "cpu": [
+        "loong64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-mips64el": {
+      "version": "0.19.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.19.12.tgz",
+      "integrity": "sha512-fEnAuj5VGTanfJ07ff0gOA6IPsvrVHLVb6Lyd1g2/ed67oU1eFzL0r9WL7ZzscD+/N6i3dWumGE1Un4f7Amf+w==",
+      "cpu": [
+        "mips64el"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-ppc64": {
+      "version": "0.19.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.19.12.tgz",
+      "integrity": "sha512-nYJA2/QPimDQOh1rKWedNOe3Gfc8PabU7HT3iXWtNUbRzXS9+vgB0Fjaqr//XNbd82mCxHzik2qotuI89cfixg==",
+      "cpu": [
+        "ppc64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-riscv64": {
+      "version": "0.19.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.19.12.tgz",
+      "integrity": "sha512-2MueBrlPQCw5dVJJpQdUYgeqIzDQgw3QtiAHUC4RBz9FXPrskyyU3VI1hw7C0BSKB9OduwSJ79FTCqtGMWqJHg==",
+      "cpu": [
+        "riscv64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-s390x": {
+      "version": "0.19.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.19.12.tgz",
+      "integrity": "sha512-+Pil1Nv3Umes4m3AZKqA2anfhJiVmNCYkPchwFJNEJN5QxmTs1uzyy4TvmDrCRNT2ApwSari7ZIgrPeUx4UZDg==",
+      "cpu": [
+        "s390x"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/linux-x64": {
+      "version": "0.19.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.19.12.tgz",
+      "integrity": "sha512-B71g1QpxfwBvNrfyJdVDexenDIt1CiDN1TIXLbhOw0KhJzE78KIFGX6OJ9MrtC0oOqMWf+0xop4qEU8JrJTwCg==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/netbsd-x64": {
+      "version": "0.19.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.19.12.tgz",
+      "integrity": "sha512-3ltjQ7n1owJgFbuC61Oj++XhtzmymoCihNFgT84UAmJnxJfm4sYCiSLTXZtE00VWYpPMYc+ZQmB6xbSdVh0JWA==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/openbsd-x64": {
+      "version": "0.19.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.19.12.tgz",
+      "integrity": "sha512-RbrfTB9SWsr0kWmb9srfF+L933uMDdu9BIzdA7os2t0TXhCRjrQyCeOt6wVxr79CKD4c+p+YhCj31HBkYcXebw==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/sunos-x64": {
+      "version": "0.19.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.19.12.tgz",
+      "integrity": "sha512-HKjJwRrW8uWtCQnQOz9qcU3mUZhTUQvi56Q8DPTLLB+DawoiQdjsYq+j+D3s9I8VFtDr+F9CjgXKKC4ss89IeA==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-arm64": {
+      "version": "0.19.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.19.12.tgz",
+      "integrity": "sha512-URgtR1dJnmGvX864pn1B2YUYNzjmXkuJOIqG2HdU62MVS4EHpU2946OZoTMnRUHklGtJdJZ33QfzdjGACXhn1A==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-ia32": {
+      "version": "0.19.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.19.12.tgz",
+      "integrity": "sha512-+ZOE6pUkMOJfmxmBZElNOx72NKpIa/HFOMGzu8fqzQJ5kgf6aTGrcJaFsNiVMH4JKpMipyK+7k0n2UXN7a8YKQ==",
+      "cpu": [
+        "ia32"
+      ],
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@esbuild/win32-x64": {
+      "version": "0.19.12",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.19.12.tgz",
+      "integrity": "sha512-T1QyPSDCyMXaO3pzBkF96E8xMkiRYbUEZADd29SyPGabqxMViNoii+NcK7eWJAEoU6RZyEm5lVSIjTmcdoB9HA==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
     "node_modules/@eslint-community/eslint-utils": {
       "version": "4.4.0",
       "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.4.0.tgz",
@@ -96,12 +426,15 @@
       }
     },
     "node_modules/@hirosystems/clarinet-sdk": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/@hirosystems/clarinet-sdk/-/clarinet-sdk-1.2.0.tgz",
-      "integrity": "sha512-O0Gyh3pwwOVJTbLlxHG6vSB/KXr+U/nZzd2kpubQO4Qqxjn5/vo8l8J+/fwKOxhzM4QOa42M1sCaVZSB/PkTFg==",
+      "version": "2.4.0-beta3",
+      "resolved": "https://registry.npmjs.org/@hirosystems/clarinet-sdk/-/clarinet-sdk-2.4.0-beta3.tgz",
+      "integrity": "sha512-O10yx4KtTXqi9/5LOGdLgQqt4M28/VLv7p9T9XOOy4j3mF81h+ZbvE4JH07BPJgZwQkupsGuouAnj5wD+OsIrg==",
       "dependencies": {
-        "@hirosystems/clarinet-sdk-wasm": "^1.2.0",
-        "@stacks/transactions": "^6.9.0",
+        "@hirosystems/clarinet-sdk-wasm": "^2.4.0-beta3",
+        "@stacks/encryption": "^6.12.0",
+        "@stacks/network": "^6.11.3",
+        "@stacks/stacking": "^6.11.4-pr.36558cf.0",
+        "@stacks/transactions": "^6.12.0",
         "kolorist": "^1.8.0",
         "prompts": "^2.4.2",
         "vitest": "^1.0.4",
@@ -115,334 +448,14 @@
       }
     },
     "node_modules/@hirosystems/clarinet-sdk-wasm": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/@hirosystems/clarinet-sdk-wasm/-/clarinet-sdk-wasm-1.2.0.tgz",
-      "integrity": "sha512-TnJ243lEgIqHSIeMdEHi1hJceFBJ5mWfjfXv86GKaoyVOS6yX1vGL2a6ZuVO9FfWPNxsiSvaQV/FndVuansAVQ=="
-    },
-    "node_modules/@hirosystems/clarinet-sdk/node_modules/@esbuild/darwin-arm64": {
-      "version": "0.19.10",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.19.10.tgz",
-      "integrity": "sha512-YSRRs2zOpwypck+6GL3wGXx2gNP7DXzetmo5pHXLrY/VIMsS59yKfjPizQ4lLt5vEI80M41gjm2BxrGZ5U+VMA==",
-      "cpu": [
-        "arm64"
-      ],
-      "optional": true,
-      "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
+      "version": "2.4.0-beta3",
+      "resolved": "https://registry.npmjs.org/@hirosystems/clarinet-sdk-wasm/-/clarinet-sdk-wasm-2.4.0-beta3.tgz",
+      "integrity": "sha512-m4PHoE38F+YzH5WDwK5CuRs3/RZWGstIPx4bq2vX6ut1ETE2S9LkS8q91RFF4FnZHnI5f8LwxflTbaxE+RSNrA=="
     },
-    "node_modules/@hirosystems/clarinet-sdk/node_modules/@vitest/expect": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-1.1.0.tgz",
-      "integrity": "sha512-9IE2WWkcJo2BR9eqtY5MIo3TPmS50Pnwpm66A6neb2hvk/QSLfPXBz2qdiwUOQkwyFuuXEUj5380CbwfzW4+/w==",
-      "dependencies": {
-        "@vitest/spy": "1.1.0",
-        "@vitest/utils": "1.1.0",
-        "chai": "^4.3.10"
-      },
-      "funding": {
-        "url": "https://opencollective.com/vitest"
-      }
-    },
-    "node_modules/@hirosystems/clarinet-sdk/node_modules/@vitest/runner": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-1.1.0.tgz",
-      "integrity": "sha512-zdNLJ00pm5z/uhbWF6aeIJCGMSyTyWImy3Fcp9piRGvueERFlQFbUwCpzVce79OLm2UHk9iwaMSOaU9jVHgNVw==",
-      "dependencies": {
-        "@vitest/utils": "1.1.0",
-        "p-limit": "^5.0.0",
-        "pathe": "^1.1.1"
-      },
-      "funding": {
-        "url": "https://opencollective.com/vitest"
-      }
-    },
-    "node_modules/@hirosystems/clarinet-sdk/node_modules/@vitest/snapshot": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-1.1.0.tgz",
-      "integrity": "sha512-5O/wyZg09V5qmNmAlUgCBqflvn2ylgsWJRRuPrnHEfDNT6tQpQ8O1isNGgo+VxofISHqz961SG3iVvt3SPK/QQ==",
-      "dependencies": {
-        "magic-string": "^0.30.5",
-        "pathe": "^1.1.1",
-        "pretty-format": "^29.7.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/vitest"
-      }
-    },
-    "node_modules/@hirosystems/clarinet-sdk/node_modules/@vitest/spy": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-1.1.0.tgz",
-      "integrity": "sha512-sNOVSU/GE+7+P76qYo+VXdXhXffzWZcYIPQfmkiRxaNCSPiLANvQx5Mx6ZURJ/ndtEkUJEpvKLXqAYTKEY+lTg==",
-      "dependencies": {
-        "tinyspy": "^2.2.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/vitest"
-      }
-    },
-    "node_modules/@hirosystems/clarinet-sdk/node_modules/@vitest/utils": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-1.1.0.tgz",
-      "integrity": "sha512-z+s510fKmYz4Y41XhNs3vcuFTFhcij2YF7F8VQfMEYAAUfqQh0Zfg7+w9xdgFGhPf3tX3TicAe+8BDITk6ampQ==",
-      "dependencies": {
-        "diff-sequences": "^29.6.3",
-        "loupe": "^2.3.7",
-        "pretty-format": "^29.7.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/vitest"
-      }
-    },
-    "node_modules/@hirosystems/clarinet-sdk/node_modules/esbuild": {
-      "version": "0.19.10",
-      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.19.10.tgz",
-      "integrity": "sha512-S1Y27QGt/snkNYrRcswgRFqZjaTG5a5xM3EQo97uNBnH505pdzSNe/HLBq1v0RO7iK/ngdbhJB6mDAp0OK+iUA==",
-      "hasInstallScript": true,
-      "bin": {
-        "esbuild": "bin/esbuild"
-      },
-      "engines": {
-        "node": ">=12"
-      },
-      "optionalDependencies": {
-        "@esbuild/aix-ppc64": "0.19.10",
-        "@esbuild/android-arm": "0.19.10",
-        "@esbuild/android-arm64": "0.19.10",
-        "@esbuild/android-x64": "0.19.10",
-        "@esbuild/darwin-arm64": "0.19.10",
-        "@esbuild/darwin-x64": "0.19.10",
-        "@esbuild/freebsd-arm64": "0.19.10",
-        "@esbuild/freebsd-x64": "0.19.10",
-        "@esbuild/linux-arm": "0.19.10",
-        "@esbuild/linux-arm64": "0.19.10",
-        "@esbuild/linux-ia32": "0.19.10",
-        "@esbuild/linux-loong64": "0.19.10",
-        "@esbuild/linux-mips64el": "0.19.10",
-        "@esbuild/linux-ppc64": "0.19.10",
-        "@esbuild/linux-riscv64": "0.19.10",
-        "@esbuild/linux-s390x": "0.19.10",
-        "@esbuild/linux-x64": "0.19.10",
-        "@esbuild/netbsd-x64": "0.19.10",
-        "@esbuild/openbsd-x64": "0.19.10",
-        "@esbuild/sunos-x64": "0.19.10",
-        "@esbuild/win32-arm64": "0.19.10",
-        "@esbuild/win32-ia32": "0.19.10",
-        "@esbuild/win32-x64": "0.19.10"
-      }
-    },
-    "node_modules/@hirosystems/clarinet-sdk/node_modules/local-pkg": {
-      "version": "0.5.0",
-      "resolved": "https://registry.npmjs.org/local-pkg/-/local-pkg-0.5.0.tgz",
-      "integrity": "sha512-ok6z3qlYyCDS4ZEU27HaU6x/xZa9Whf8jD4ptH5UZTQYZVYeb9bnZ3ojVhiJNLiXK1Hfc0GNbLXcmZ5plLDDBg==",
-      "dependencies": {
-        "mlly": "^1.4.2",
-        "pkg-types": "^1.0.3"
-      },
-      "engines": {
-        "node": ">=14"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/antfu"
-      }
-    },
-    "node_modules/@hirosystems/clarinet-sdk/node_modules/p-limit": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-5.0.0.tgz",
-      "integrity": "sha512-/Eaoq+QyLSiXQ4lyYV23f14mZRQcXnxfHrN0vCai+ak9G0pp9iEQukIIZq5NccEvwRB8PUnZT0KsOoDCINS1qQ==",
-      "dependencies": {
-        "yocto-queue": "^1.0.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/@hirosystems/clarinet-sdk/node_modules/rollup": {
-      "version": "4.9.1",
-      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.9.1.tgz",
-      "integrity": "sha512-pgPO9DWzLoW/vIhlSoDByCzcpX92bKEorbgXuZrqxByte3JFk2xSW2JEeAcyLc9Ru9pqcNNW+Ob7ntsk2oT/Xw==",
-      "bin": {
-        "rollup": "dist/bin/rollup"
-      },
-      "engines": {
-        "node": ">=18.0.0",
-        "npm": ">=8.0.0"
-      },
-      "optionalDependencies": {
-        "@rollup/rollup-android-arm-eabi": "4.9.1",
-        "@rollup/rollup-android-arm64": "4.9.1",
-        "@rollup/rollup-darwin-arm64": "4.9.1",
-        "@rollup/rollup-darwin-x64": "4.9.1",
-        "@rollup/rollup-linux-arm-gnueabihf": "4.9.1",
-        "@rollup/rollup-linux-arm64-gnu": "4.9.1",
-        "@rollup/rollup-linux-arm64-musl": "4.9.1",
-        "@rollup/rollup-linux-riscv64-gnu": "4.9.1",
-        "@rollup/rollup-linux-x64-gnu": "4.9.1",
-        "@rollup/rollup-linux-x64-musl": "4.9.1",
-        "@rollup/rollup-win32-arm64-msvc": "4.9.1",
-        "@rollup/rollup-win32-ia32-msvc": "4.9.1",
-        "@rollup/rollup-win32-x64-msvc": "4.9.1",
-        "fsevents": "~2.3.2"
-      }
-    },
-    "node_modules/@hirosystems/clarinet-sdk/node_modules/tinypool": {
-      "version": "0.8.1",
-      "resolved": "https://registry.npmjs.org/tinypool/-/tinypool-0.8.1.tgz",
-      "integrity": "sha512-zBTCK0cCgRROxvs9c0CGK838sPkeokNGdQVUUwHAbynHFlmyJYj825f/oRs528HaIJ97lo0pLIlDUzwN+IorWg==",
-      "engines": {
-        "node": ">=14.0.0"
-      }
-    },
-    "node_modules/@hirosystems/clarinet-sdk/node_modules/vite": {
-      "version": "5.0.10",
-      "resolved": "https://registry.npmjs.org/vite/-/vite-5.0.10.tgz",
-      "integrity": "sha512-2P8J7WWgmc355HUMlFrwofacvr98DAjoE52BfdbwQtyLH06XKwaL/FMnmKM2crF0iX4MpmMKoDlNCB1ok7zHCw==",
-      "dependencies": {
-        "esbuild": "^0.19.3",
-        "postcss": "^8.4.32",
-        "rollup": "^4.2.0"
-      },
-      "bin": {
-        "vite": "bin/vite.js"
-      },
-      "engines": {
-        "node": "^18.0.0 || >=20.0.0"
-      },
-      "funding": {
-        "url": "https://github.com/vitejs/vite?sponsor=1"
-      },
-      "optionalDependencies": {
-        "fsevents": "~2.3.3"
-      },
-      "peerDependencies": {
-        "@types/node": "^18.0.0 || >=20.0.0",
-        "less": "*",
-        "lightningcss": "^1.21.0",
-        "sass": "*",
-        "stylus": "*",
-        "sugarss": "*",
-        "terser": "^5.4.0"
-      },
-      "peerDependenciesMeta": {
-        "@types/node": {
-          "optional": true
-        },
-        "less": {
-          "optional": true
-        },
-        "lightningcss": {
-          "optional": true
-        },
-        "sass": {
-          "optional": true
-        },
-        "stylus": {
-          "optional": true
-        },
-        "sugarss": {
-          "optional": true
-        },
-        "terser": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/@hirosystems/clarinet-sdk/node_modules/vite-node": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/vite-node/-/vite-node-1.1.0.tgz",
-      "integrity": "sha512-jV48DDUxGLEBdHCQvxL1mEh7+naVy+nhUUUaPAZLd3FJgXuxQiewHcfeZebbJ6onDqNGkP4r3MhQ342PRlG81Q==",
-      "dependencies": {
-        "cac": "^6.7.14",
-        "debug": "^4.3.4",
-        "pathe": "^1.1.1",
-        "picocolors": "^1.0.0",
-        "vite": "^5.0.0"
-      },
-      "bin": {
-        "vite-node": "vite-node.mjs"
-      },
-      "engines": {
-        "node": "^18.0.0 || >=20.0.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/vitest"
-      }
-    },
-    "node_modules/@hirosystems/clarinet-sdk/node_modules/vitest": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/vitest/-/vitest-1.1.0.tgz",
-      "integrity": "sha512-oDFiCrw7dd3Jf06HoMtSRARivvyjHJaTxikFxuqJjO76U436PqlVw1uLn7a8OSPrhSfMGVaRakKpA2lePdw79A==",
-      "dependencies": {
-        "@vitest/expect": "1.1.0",
-        "@vitest/runner": "1.1.0",
-        "@vitest/snapshot": "1.1.0",
-        "@vitest/spy": "1.1.0",
-        "@vitest/utils": "1.1.0",
-        "acorn-walk": "^8.3.0",
-        "cac": "^6.7.14",
-        "chai": "^4.3.10",
-        "debug": "^4.3.4",
-        "execa": "^8.0.1",
-        "local-pkg": "^0.5.0",
-        "magic-string": "^0.30.5",
-        "pathe": "^1.1.1",
-        "picocolors": "^1.0.0",
-        "std-env": "^3.5.0",
-        "strip-literal": "^1.3.0",
-        "tinybench": "^2.5.1",
-        "tinypool": "^0.8.1",
-        "vite": "^5.0.0",
-        "vite-node": "1.1.0",
-        "why-is-node-running": "^2.2.2"
-      },
-      "bin": {
-        "vitest": "vitest.mjs"
-      },
-      "engines": {
-        "node": "^18.0.0 || >=20.0.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/vitest"
-      },
-      "peerDependencies": {
-        "@edge-runtime/vm": "*",
-        "@types/node": "^18.0.0 || >=20.0.0",
-        "@vitest/browser": "^1.0.0",
-        "@vitest/ui": "^1.0.0",
-        "happy-dom": "*",
-        "jsdom": "*"
-      },
-      "peerDependenciesMeta": {
-        "@edge-runtime/vm": {
-          "optional": true
-        },
-        "@types/node": {
-          "optional": true
-        },
-        "@vitest/browser": {
-          "optional": true
-        },
-        "@vitest/ui": {
-          "optional": true
-        },
-        "happy-dom": {
-          "optional": true
-        },
-        "jsdom": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/@humanwhocodes/config-array": {
-      "version": "0.11.14",
-      "resolved": "https://registry.npmjs.org/@humanwhocodes/config-array/-/config-array-0.11.14.tgz",
-      "integrity": "sha512-3T8LkOmg45BV5FICb15QQMsyUSWrQ8AygVfC7ZG32zOalnqrilm018ZVCw0eapXux8FtA33q8PSRSstjee3jSg==",
+    "node_modules/@humanwhocodes/config-array": {
+      "version": "0.11.14",
+      "resolved": "https://registry.npmjs.org/@humanwhocodes/config-array/-/config-array-0.11.14.tgz",
+      "integrity": "sha512-3T8LkOmg45BV5FICb15QQMsyUSWrQ8AygVfC7ZG32zOalnqrilm018ZVCw0eapXux8FtA33q8PSRSstjee3jSg==",
       "dependencies": {
         "@humanwhocodes/object-schema": "^2.0.2",
         "debug": "^4.3.1",
@@ -539,61 +552,34 @@
         "node": ">= 8"
       }
     },
-    "node_modules/@rollup/rollup-darwin-arm64": {
-      "version": "4.9.1",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.9.1.tgz",
-      "integrity": "sha512-LtYcLNM+bhsaKAIGwVkh5IOWhaZhjTfNOkGzGqdHvhiCUVuJDalvDxEdSnhFzAn+g23wgsycmZk1vbnaibZwwA==",
+    "node_modules/@rollup/rollup-android-arm-eabi": {
+      "version": "4.13.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.13.0.tgz",
+      "integrity": "sha512-5ZYPOuaAqEH/W3gYsRkxQATBW3Ii1MfaT4EQstTnLKViLi2gLSQmlmtTpGucNP3sXEpOiI5tdGhjdE111ekyEg==",
       "cpu": [
-        "arm64"
+        "arm"
       ],
       "optional": true,
       "os": [
-        "darwin"
+        "android"
       ]
     },
-    "node_modules/@sinclair/typebox": {
-      "version": "0.27.8",
-      "resolved": "https://registry.npmjs.org/@sinclair/typebox/-/typebox-0.27.8.tgz",
-      "integrity": "sha512-+Fj43pSMwJs4KRrH/938Uf+uAELIgVBmQzg/q1YG10djyfA3TnrU8N8XzqCh/okZdszqBQTZf96idMfE5lnwTA=="
-    },
-    "node_modules/@stacks/clarunit": {
-      "version": "0.0.1",
-      "resolved": "https://registry.npmjs.org/@stacks/clarunit/-/clarunit-0.0.1.tgz",
-      "integrity": "sha512-AKf14ycQJjyUWL6yfvXU+yMqvkCfUy2NarHbAmXx6tXfv/fyXueGkjTZTh8+0r20+XoxEvhJTnBfoAA74VLNtg==",
-      "dependencies": {
-        "@hirosystems/clarinet-sdk": "^1.2.0",
-        "@stacks/transactions": "^6.11.0",
-        "chokidar-cli": "^3.0.0",
-        "eslint": "^8.56.0",
-        "path": "^0.12.7",
-        "typescript": "^5.2.2",
-        "vite": "^4.4.9",
-        "vitest": "^1.1.0",
-        "vitest-environment-clarinet": "^1.0.0"
-      },
-      "bin": {
-        "clarunit": "src/cli.ts"
-      }
-    },
-    "node_modules/@stacks/clarunit/node_modules/@esbuild/darwin-arm64": {
-      "version": "0.19.12",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.19.12.tgz",
-      "integrity": "sha512-B6IeSgZgtEzGC42jsI+YYu9Z3HKRxp8ZT3cqhvliEHovq8HSX2YX8lNocDn79gCKJXOSaEot9MVYky7AKjCs8g==",
+    "node_modules/@rollup/rollup-android-arm64": {
+      "version": "4.13.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.13.0.tgz",
+      "integrity": "sha512-BSbaCmn8ZadK3UAQdlauSvtaJjhlDEjS5hEVVIN3A4bbl3X+otyf/kOJV08bYiRxfejP3DXFzO2jz3G20107+Q==",
       "cpu": [
         "arm64"
       ],
       "optional": true,
       "os": [
-        "darwin"
-      ],
-      "engines": {
-        "node": ">=12"
-      }
+        "android"
+      ]
     },
-    "node_modules/@stacks/clarunit/node_modules/@rollup/rollup-darwin-arm64": {
-      "version": "4.12.0",
-      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.12.0.tgz",
-      "integrity": "sha512-X64tZd8dRE/QTrBIEs63kaOBG0b5GVEd3ccoLtyf6IdXtHdh8h+I56C2yC3PtC9Ucnv0CpNFJLqKFVgCYe0lOQ==",
+    "node_modules/@rollup/rollup-darwin-arm64": {
+      "version": "4.13.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.13.0.tgz",
+      "integrity": "sha512-Ovf2evVaP6sW5Ut0GHyUSOqA6tVKfrTHddtmxGQc1CTQa1Cw3/KMCDEEICZBbyppcwnhMwcDce9ZRxdWRpVd6g==",
       "cpu": [
         "arm64"
       ],
@@ -602,348 +588,601 @@
         "darwin"
       ]
     },
-    "node_modules/@stacks/clarunit/node_modules/@vitest/expect": {
-      "version": "1.3.1",
-      "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-1.3.1.tgz",
-      "integrity": "sha512-xofQFwIzfdmLLlHa6ag0dPV8YsnKOCP1KdAeVVh34vSjN2dcUiXYCD9htu/9eM7t8Xln4v03U9HLxLpPlsXdZw==",
-      "dependencies": {
-        "@vitest/spy": "1.3.1",
-        "@vitest/utils": "1.3.1",
-        "chai": "^4.3.10"
-      },
+    "node_modules/@rollup/rollup-darwin-x64": {
+      "version": "4.13.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.13.0.tgz",
+      "integrity": "sha512-U+Jcxm89UTK592vZ2J9st9ajRv/hrwHdnvyuJpa5A2ngGSVHypigidkQJP+YiGL6JODiUeMzkqQzbCG3At81Gg==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
+      "version": "4.13.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.13.0.tgz",
+      "integrity": "sha512-8wZidaUJUTIR5T4vRS22VkSMOVooG0F4N+JSwQXWSRiC6yfEsFMLTYRFHvby5mFFuExHa/yAp9juSphQQJAijQ==",
+      "cpu": [
+        "arm"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-gnu": {
+      "version": "4.13.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.13.0.tgz",
+      "integrity": "sha512-Iu0Kno1vrD7zHQDxOmvweqLkAzjxEVqNhUIXBsZ8hu8Oak7/5VTPrxOEZXYC1nmrBVJp0ZcL2E7lSuuOVaE3+w==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-musl": {
+      "version": "4.13.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.13.0.tgz",
+      "integrity": "sha512-C31QrW47llgVyrRjIwiOwsHFcaIwmkKi3PCroQY5aVq4H0A5v/vVVAtFsI1nfBngtoRpeREvZOkIhmRwUKkAdw==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
+      "version": "4.13.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.13.0.tgz",
+      "integrity": "sha512-Oq90dtMHvthFOPMl7pt7KmxzX7E71AfyIhh+cPhLY9oko97Zf2C9tt/XJD4RgxhaGeAraAXDtqxvKE1y/j35lA==",
+      "cpu": [
+        "riscv64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-gnu": {
+      "version": "4.13.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.13.0.tgz",
+      "integrity": "sha512-yUD/8wMffnTKuiIsl6xU+4IA8UNhQ/f1sAnQebmE/lyQ8abjsVyDkyRkWop0kdMhKMprpNIhPmYlCxgHrPoXoA==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-x64-musl": {
+      "version": "4.13.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.13.0.tgz",
+      "integrity": "sha512-9RyNqoFNdF0vu/qqX63fKotBh43fJQeYC98hCaf89DYQpv+xu0D8QFSOS0biA7cGuqJFOc1bJ+m2rhhsKcw1hw==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-arm64-msvc": {
+      "version": "4.13.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.13.0.tgz",
+      "integrity": "sha512-46ue8ymtm/5PUU6pCvjlic0z82qWkxv54GTJZgHrQUuZnVH+tvvSP0LsozIDsCBFO4VjJ13N68wqrKSeScUKdA==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-ia32-msvc": {
+      "version": "4.13.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.13.0.tgz",
+      "integrity": "sha512-P5/MqLdLSlqxbeuJ3YDeX37srC8mCflSyTrUsgbU1c/U9j6l2g2GiIdYaGD9QjdMQPMSgYm7hgg0551wHyIluw==",
+      "cpu": [
+        "ia32"
+      ],
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-msvc": {
+      "version": "4.13.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.13.0.tgz",
+      "integrity": "sha512-UKXUQNbO3DOhzLRwHSpa0HnhhCgNODvfoPWv2FCXme8N/ANFfhIPMGuOT+QuKd16+B5yxZ0HdpNlqPvTMS1qfw==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@scure/base": {
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/@scure/base/-/base-1.1.5.tgz",
+      "integrity": "sha512-Brj9FiG2W1MRQSTB212YVPRrcbjkv48FoZi/u4l/zds/ieRrqsh7aUf6CLwkAq61oKXr/ZlTzlY66gLIj3TFTQ==",
       "funding": {
-        "url": "https://opencollective.com/vitest"
+        "url": "https://paulmillr.com/funding/"
       }
     },
-    "node_modules/@stacks/clarunit/node_modules/@vitest/runner": {
-      "version": "1.3.1",
-      "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-1.3.1.tgz",
-      "integrity": "sha512-5FzF9c3jG/z5bgCnjr8j9LNq/9OxV2uEBAITOXfoe3rdZJTdO7jzThth7FXv/6b+kdY65tpRQB7WaKhNZwX+Kg==",
+    "node_modules/@scure/bip39": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@scure/bip39/-/bip39-1.1.0.tgz",
+      "integrity": "sha512-pwrPOS16VeTKg98dYXQyIjJEcWfz7/1YJIwxUEPFfQPtc86Ym/1sVgQ2RLoD43AazMk2l/unK4ITySSpW2+82w==",
+      "funding": [
+        {
+          "type": "individual",
+          "url": "https://paulmillr.com/funding/"
+        }
+      ],
       "dependencies": {
-        "@vitest/utils": "1.3.1",
-        "p-limit": "^5.0.0",
-        "pathe": "^1.1.1"
-      },
-      "funding": {
-        "url": "https://opencollective.com/vitest"
+        "@noble/hashes": "~1.1.1",
+        "@scure/base": "~1.1.0"
       }
     },
-    "node_modules/@stacks/clarunit/node_modules/@vitest/snapshot": {
-      "version": "1.3.1",
-      "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-1.3.1.tgz",
-      "integrity": "sha512-EF++BZbt6RZmOlE3SuTPu/NfwBF6q4ABS37HHXzs2LUVPBLx2QoY/K0fKpRChSo8eLiuxcbCVfqKgx/dplCDuQ==",
+    "node_modules/@sinclair/typebox": {
+      "version": "0.27.8",
+      "resolved": "https://registry.npmjs.org/@sinclair/typebox/-/typebox-0.27.8.tgz",
+      "integrity": "sha512-+Fj43pSMwJs4KRrH/938Uf+uAELIgVBmQzg/q1YG10djyfA3TnrU8N8XzqCh/okZdszqBQTZf96idMfE5lnwTA=="
+    },
+    "node_modules/@stacks/clarunit": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmjs.org/@stacks/clarunit/-/clarunit-0.0.1.tgz",
+      "integrity": "sha512-AKf14ycQJjyUWL6yfvXU+yMqvkCfUy2NarHbAmXx6tXfv/fyXueGkjTZTh8+0r20+XoxEvhJTnBfoAA74VLNtg==",
       "dependencies": {
-        "magic-string": "^0.30.5",
-        "pathe": "^1.1.1",
-        "pretty-format": "^29.7.0"
+        "@hirosystems/clarinet-sdk": "^1.2.0",
+        "@stacks/transactions": "^6.11.0",
+        "chokidar-cli": "^3.0.0",
+        "eslint": "^8.56.0",
+        "path": "^0.12.7",
+        "typescript": "^5.2.2",
+        "vite": "^4.4.9",
+        "vitest": "^1.1.0",
+        "vitest-environment-clarinet": "^1.0.0"
       },
-      "funding": {
-        "url": "https://opencollective.com/vitest"
+      "bin": {
+        "clarunit": "src/cli.ts"
       }
     },
-    "node_modules/@stacks/clarunit/node_modules/@vitest/spy": {
-      "version": "1.3.1",
-      "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-1.3.1.tgz",
-      "integrity": "sha512-xAcW+S099ylC9VLU7eZfdT9myV67Nor9w9zhf0mGCYJSO+zM2839tOeROTdikOi/8Qeusffvxb/MyBSOja1Uig==",
-      "dependencies": {
-        "tinyspy": "^2.2.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/vitest"
+    "node_modules/@stacks/clarunit/node_modules/@esbuild/android-arm": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.18.20.tgz",
+      "integrity": "sha512-fyi7TDI/ijKKNZTUJAQqiG5T7YjJXgnzkURqmGj13C6dCqckZBLdl4h7bkhHt/t0WP+zO9/zwroDvANaOqO5Sw==",
+      "cpu": [
+        "arm"
+      ],
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
       }
     },
-    "node_modules/@stacks/clarunit/node_modules/@vitest/utils": {
-      "version": "1.3.1",
-      "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-1.3.1.tgz",
-      "integrity": "sha512-d3Waie/299qqRyHTm2DjADeTaNdNSVsnwHPWrs20JMpjh6eiVq7ggggweO8rc4arhf6rRkWuHKwvxGvejUXZZQ==",
-      "dependencies": {
-        "diff-sequences": "^29.6.3",
-        "estree-walker": "^3.0.3",
-        "loupe": "^2.3.7",
-        "pretty-format": "^29.7.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/vitest"
+    "node_modules/@stacks/clarunit/node_modules/@esbuild/android-arm64": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.18.20.tgz",
+      "integrity": "sha512-Nz4rJcchGDtENV0eMKUNa6L12zz2zBDXuhj/Vjh18zGqB44Bi7MBMSXjgunJgjRhCmKOjnPuZp4Mb6OKqtMHLQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=12"
       }
     },
-    "node_modules/@stacks/clarunit/node_modules/esbuild": {
-      "version": "0.19.12",
-      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.19.12.tgz",
-      "integrity": "sha512-aARqgq8roFBj054KvQr5f1sFu0D65G+miZRCuJyJ0G13Zwx7vRar5Zhn2tkQNzIXcBrNVsv/8stehpj+GAjgbg==",
-      "hasInstallScript": true,
-      "bin": {
-        "esbuild": "bin/esbuild"
-      },
+    "node_modules/@stacks/clarunit/node_modules/@esbuild/android-x64": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.18.20.tgz",
+      "integrity": "sha512-8GDdlePJA8D6zlZYJV/jnrRAi6rOiNaCC/JclcXpB+KIuvfBN4owLtgzY2bsxnx666XjJx2kDPUmnTtR8qKQUg==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "android"
+      ],
       "engines": {
         "node": ">=12"
-      },
-      "optionalDependencies": {
-        "@esbuild/aix-ppc64": "0.19.12",
-        "@esbuild/android-arm": "0.19.12",
-        "@esbuild/android-arm64": "0.19.12",
-        "@esbuild/android-x64": "0.19.12",
-        "@esbuild/darwin-arm64": "0.19.12",
-        "@esbuild/darwin-x64": "0.19.12",
-        "@esbuild/freebsd-arm64": "0.19.12",
-        "@esbuild/freebsd-x64": "0.19.12",
-        "@esbuild/linux-arm": "0.19.12",
-        "@esbuild/linux-arm64": "0.19.12",
-        "@esbuild/linux-ia32": "0.19.12",
-        "@esbuild/linux-loong64": "0.19.12",
-        "@esbuild/linux-mips64el": "0.19.12",
-        "@esbuild/linux-ppc64": "0.19.12",
-        "@esbuild/linux-riscv64": "0.19.12",
-        "@esbuild/linux-s390x": "0.19.12",
-        "@esbuild/linux-x64": "0.19.12",
-        "@esbuild/netbsd-x64": "0.19.12",
-        "@esbuild/openbsd-x64": "0.19.12",
-        "@esbuild/sunos-x64": "0.19.12",
-        "@esbuild/win32-arm64": "0.19.12",
-        "@esbuild/win32-ia32": "0.19.12",
-        "@esbuild/win32-x64": "0.19.12"
       }
     },
-    "node_modules/@stacks/clarunit/node_modules/local-pkg": {
-      "version": "0.5.0",
-      "resolved": "https://registry.npmjs.org/local-pkg/-/local-pkg-0.5.0.tgz",
-      "integrity": "sha512-ok6z3qlYyCDS4ZEU27HaU6x/xZa9Whf8jD4ptH5UZTQYZVYeb9bnZ3ojVhiJNLiXK1Hfc0GNbLXcmZ5plLDDBg==",
-      "dependencies": {
-        "mlly": "^1.4.2",
-        "pkg-types": "^1.0.3"
-      },
+    "node_modules/@stacks/clarunit/node_modules/@esbuild/darwin-arm64": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.18.20.tgz",
+      "integrity": "sha512-bxRHW5kHU38zS2lPTPOyuyTm+S+eobPUnTNkdJEfAddYgEcll4xkT8DB9d2008DtTbl7uJag2HuE5NZAZgnNEA==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
       "engines": {
-        "node": ">=14"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/antfu"
+        "node": ">=12"
       }
     },
-    "node_modules/@stacks/clarunit/node_modules/p-limit": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-5.0.0.tgz",
-      "integrity": "sha512-/Eaoq+QyLSiXQ4lyYV23f14mZRQcXnxfHrN0vCai+ak9G0pp9iEQukIIZq5NccEvwRB8PUnZT0KsOoDCINS1qQ==",
-      "dependencies": {
-        "yocto-queue": "^1.0.0"
-      },
+    "node_modules/@stacks/clarunit/node_modules/@esbuild/darwin-x64": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.18.20.tgz",
+      "integrity": "sha512-pc5gxlMDxzm513qPGbCbDukOdsGtKhfxD1zJKXjCCcU7ju50O7MeAZ8c4krSJcOIJGFR+qx21yMMVYwiQvyTyQ==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
       "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+        "node": ">=12"
       }
     },
-    "node_modules/@stacks/clarunit/node_modules/rollup": {
-      "version": "4.12.0",
-      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.12.0.tgz",
-      "integrity": "sha512-wz66wn4t1OHIJw3+XU7mJJQV/2NAfw5OAk6G6Hoo3zcvz/XOfQ52Vgi+AN4Uxoxi0KBBwk2g8zPrTDA4btSB/Q==",
-      "dependencies": {
-        "@types/estree": "1.0.5"
-      },
-      "bin": {
-        "rollup": "dist/bin/rollup"
-      },
+    "node_modules/@stacks/clarunit/node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.18.20.tgz",
+      "integrity": "sha512-yqDQHy4QHevpMAaxhhIwYPMv1NECwOvIpGCZkECn8w2WFHXjEwrBn3CeNIYsibZ/iZEUemj++M26W3cNR5h+Tw==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
       "engines": {
-        "node": ">=18.0.0",
-        "npm": ">=8.0.0"
-      },
-      "optionalDependencies": {
-        "@rollup/rollup-android-arm-eabi": "4.12.0",
-        "@rollup/rollup-android-arm64": "4.12.0",
-        "@rollup/rollup-darwin-arm64": "4.12.0",
-        "@rollup/rollup-darwin-x64": "4.12.0",
-        "@rollup/rollup-linux-arm-gnueabihf": "4.12.0",
-        "@rollup/rollup-linux-arm64-gnu": "4.12.0",
-        "@rollup/rollup-linux-arm64-musl": "4.12.0",
-        "@rollup/rollup-linux-riscv64-gnu": "4.12.0",
-        "@rollup/rollup-linux-x64-gnu": "4.12.0",
-        "@rollup/rollup-linux-x64-musl": "4.12.0",
-        "@rollup/rollup-win32-arm64-msvc": "4.12.0",
-        "@rollup/rollup-win32-ia32-msvc": "4.12.0",
-        "@rollup/rollup-win32-x64-msvc": "4.12.0",
-        "fsevents": "~2.3.2"
+        "node": ">=12"
       }
     },
-    "node_modules/@stacks/clarunit/node_modules/strip-literal": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/strip-literal/-/strip-literal-2.0.0.tgz",
-      "integrity": "sha512-f9vHgsCWBq2ugHAkGMiiYY+AYG0D/cbloKKg0nhaaaSNsujdGIpVXCNsrJpCKr5M0f4aI31mr13UjY6GAuXCKA==",
-      "dependencies": {
-        "js-tokens": "^8.0.2"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/antfu"
+    "node_modules/@stacks/clarunit/node_modules/@esbuild/freebsd-x64": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.18.20.tgz",
+      "integrity": "sha512-tgWRPPuQsd3RmBZwarGVHZQvtzfEBOreNuxEMKFcd5DaDn2PbBxfwLcj4+aenoh7ctXcbXmOQIn8HI6mCSw5MQ==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=12"
       }
     },
-    "node_modules/@stacks/clarunit/node_modules/tinypool": {
-      "version": "0.8.2",
-      "resolved": "https://registry.npmjs.org/tinypool/-/tinypool-0.8.2.tgz",
-      "integrity": "sha512-SUszKYe5wgsxnNOVlBYO6IC+8VGWdVGZWAqUxp3UErNBtptZvWbwyUOyzNL59zigz2rCA92QiL3wvG+JDSdJdQ==",
+    "node_modules/@stacks/clarunit/node_modules/@esbuild/linux-arm": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.18.20.tgz",
+      "integrity": "sha512-/5bHkMWnq1EgKr1V+Ybz3s1hWXok7mDFUMQ4cG10AfW3wL02PSZi5kFpYKrptDsgb2WAJIvRcDm+qIvXf/apvg==",
+      "cpu": [
+        "arm"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
       "engines": {
-        "node": ">=14.0.0"
+        "node": ">=12"
       }
     },
-    "node_modules/@stacks/clarunit/node_modules/vite-node": {
-      "version": "1.3.1",
-      "resolved": "https://registry.npmjs.org/vite-node/-/vite-node-1.3.1.tgz",
-      "integrity": "sha512-azbRrqRxlWTJEVbzInZCTchx0X69M/XPTCz4H+TLvlTcR/xH/3hkRqhOakT41fMJCMzXTu4UvegkZiEoJAWvng==",
-      "dependencies": {
-        "cac": "^6.7.14",
-        "debug": "^4.3.4",
-        "pathe": "^1.1.1",
-        "picocolors": "^1.0.0",
-        "vite": "^5.0.0"
-      },
-      "bin": {
-        "vite-node": "vite-node.mjs"
-      },
+    "node_modules/@stacks/clarunit/node_modules/@esbuild/linux-arm64": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.18.20.tgz",
+      "integrity": "sha512-2YbscF+UL7SQAVIpnWvYwM+3LskyDmPhe31pE7/aoTMFKKzIc9lLbyGUpmmb8a8AixOL61sQ/mFh3jEjHYFvdA==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
       "engines": {
-        "node": "^18.0.0 || >=20.0.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/vitest"
+        "node": ">=12"
       }
     },
-    "node_modules/@stacks/clarunit/node_modules/vite-node/node_modules/vite": {
-      "version": "5.1.4",
-      "resolved": "https://registry.npmjs.org/vite/-/vite-5.1.4.tgz",
-      "integrity": "sha512-n+MPqzq+d9nMVTKyewqw6kSt+R3CkvF9QAKY8obiQn8g1fwTscKxyfaYnC632HtBXAQGc1Yjomphwn1dtwGAHg==",
+    "node_modules/@stacks/clarunit/node_modules/@esbuild/linux-ia32": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.18.20.tgz",
+      "integrity": "sha512-P4etWwq6IsReT0E1KHU40bOnzMHoH73aXp96Fs8TIT6z9Hu8G6+0SHSw9i2isWrD2nbx2qo5yUqACgdfVGx7TA==",
+      "cpu": [
+        "ia32"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@stacks/clarunit/node_modules/@esbuild/linux-loong64": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.18.20.tgz",
+      "integrity": "sha512-nXW8nqBTrOpDLPgPY9uV+/1DjxoQ7DoB2N8eocyq8I9XuqJ7BiAMDMf9n1xZM9TgW0J8zrquIb/A7s3BJv7rjg==",
+      "cpu": [
+        "loong64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@stacks/clarunit/node_modules/@esbuild/linux-mips64el": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.18.20.tgz",
+      "integrity": "sha512-d5NeaXZcHp8PzYy5VnXV3VSd2D328Zb+9dEq5HE6bw6+N86JVPExrA6O68OPwobntbNJ0pzCpUFZTo3w0GyetQ==",
+      "cpu": [
+        "mips64el"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@stacks/clarunit/node_modules/@esbuild/linux-ppc64": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.18.20.tgz",
+      "integrity": "sha512-WHPyeScRNcmANnLQkq6AfyXRFr5D6N2sKgkFo2FqguP44Nw2eyDlbTdZwd9GYk98DZG9QItIiTlFLHJHjxP3FA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@stacks/clarunit/node_modules/@esbuild/linux-riscv64": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.18.20.tgz",
+      "integrity": "sha512-WSxo6h5ecI5XH34KC7w5veNnKkju3zBRLEQNY7mv5mtBmrP/MjNBCAlsM2u5hDBlS3NGcTQpoBvRzqBcRtpq1A==",
+      "cpu": [
+        "riscv64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@stacks/clarunit/node_modules/@esbuild/linux-s390x": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.18.20.tgz",
+      "integrity": "sha512-+8231GMs3mAEth6Ja1iK0a1sQ3ohfcpzpRLH8uuc5/KVDFneH6jtAJLFGafpzpMRO6DzJ6AvXKze9LfFMrIHVQ==",
+      "cpu": [
+        "s390x"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@stacks/clarunit/node_modules/@esbuild/linux-x64": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.18.20.tgz",
+      "integrity": "sha512-UYqiqemphJcNsFEskc73jQ7B9jgwjWrSayxawS6UVFZGWrAAtkzjxSqnoclCXxWtfwLdzU+vTpcNYhpn43uP1w==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@stacks/clarunit/node_modules/@esbuild/netbsd-x64": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.18.20.tgz",
+      "integrity": "sha512-iO1c++VP6xUBUmltHZoMtCUdPlnPGdBom6IrO4gyKPFFVBKioIImVooR5I83nTew5UOYrk3gIJhbZh8X44y06A==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@stacks/clarunit/node_modules/@esbuild/openbsd-x64": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.18.20.tgz",
+      "integrity": "sha512-e5e4YSsuQfX4cxcygw/UCPIEP6wbIL+se3sxPdCiMbFLBWu0eiZOJ7WoD+ptCLrmjZBK1Wk7I6D/I3NglUGOxg==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@stacks/clarunit/node_modules/@esbuild/sunos-x64": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.18.20.tgz",
+      "integrity": "sha512-kDbFRFp0YpTQVVrqUd5FTYmWo45zGaXe0X8E1G/LKFC0v8x0vWrhOWSLITcCn63lmZIxfOMXtCfti/RxN/0wnQ==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@stacks/clarunit/node_modules/@esbuild/win32-arm64": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.18.20.tgz",
+      "integrity": "sha512-ddYFR6ItYgoaq4v4JmQQaAI5s7npztfV4Ag6NrhiaW0RrnOXqBkgwZLofVTlq1daVTQNhtI5oieTvkRPfZrePg==",
+      "cpu": [
+        "arm64"
+      ],
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@stacks/clarunit/node_modules/@esbuild/win32-ia32": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.18.20.tgz",
+      "integrity": "sha512-Wv7QBi3ID/rROT08SABTS7eV4hX26sVduqDOTe1MvGMjNd3EjOz4b7zeexIR62GTIEKrfJXKL9LFxTYgkyeu7g==",
+      "cpu": [
+        "ia32"
+      ],
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@stacks/clarunit/node_modules/@esbuild/win32-x64": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.18.20.tgz",
+      "integrity": "sha512-kTdfRcSiDfQca/y9QIkng02avJ+NCaQvrMejlsB3RRv5sE9rRoeBPISaZpKxHELzRxZyLvNts1P27W3wV+8geQ==",
+      "cpu": [
+        "x64"
+      ],
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/@stacks/clarunit/node_modules/@hirosystems/clarinet-sdk": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/@hirosystems/clarinet-sdk/-/clarinet-sdk-1.3.0.tgz",
+      "integrity": "sha512-CB6+E8gcFJp2Q+iYZ74opI+GJBsAEc54SdPdMY8lvz/H7lHonQtyjn0aOPl8Th5jcC3Cq+yqb6APDWbBr07vUA==",
       "dependencies": {
-        "esbuild": "^0.19.3",
-        "postcss": "^8.4.35",
-        "rollup": "^4.2.0"
+        "@hirosystems/clarinet-sdk-wasm": "^2.2.0",
+        "@stacks/transactions": "^6.9.0",
+        "kolorist": "^1.8.0",
+        "prompts": "^2.4.2",
+        "vitest": "^1.0.4",
+        "yargs": "^17.7.2"
       },
       "bin": {
-        "vite": "bin/vite.js"
+        "clarinet-sdk": "dist/cjs/bin/index.js"
       },
       "engines": {
-        "node": "^18.0.0 || >=20.0.0"
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/@stacks/clarunit/node_modules/@hirosystems/clarinet-sdk-wasm": {
+      "version": "2.3.2",
+      "resolved": "https://registry.npmjs.org/@hirosystems/clarinet-sdk-wasm/-/clarinet-sdk-wasm-2.3.2.tgz",
+      "integrity": "sha512-Uz5RX06hRB05S6JPyS5j1F7HOPmmRArqR8c+61IUlOarPwYxum2MmLW7DnmsKWuC/m6wD8zbxUN22xRpHLFJWA=="
+    },
+    "node_modules/@stacks/clarunit/node_modules/esbuild": {
+      "version": "0.18.20",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.18.20.tgz",
+      "integrity": "sha512-ceqxoedUrcayh7Y7ZX6NdbbDzGROiyVBgC4PriJThBKSVPWnnFHZAkfI1lJT8QFkOwH4qOS2SJkS4wvpGl8BpA==",
+      "hasInstallScript": true,
+      "bin": {
+        "esbuild": "bin/esbuild"
       },
-      "funding": {
-        "url": "https://github.com/vitejs/vite?sponsor=1"
+      "engines": {
+        "node": ">=12"
       },
       "optionalDependencies": {
-        "fsevents": "~2.3.3"
-      },
-      "peerDependencies": {
-        "@types/node": "^18.0.0 || >=20.0.0",
-        "less": "*",
-        "lightningcss": "^1.21.0",
-        "sass": "*",
-        "stylus": "*",
-        "sugarss": "*",
-        "terser": "^5.4.0"
-      },
-      "peerDependenciesMeta": {
-        "@types/node": {
-          "optional": true
-        },
-        "less": {
-          "optional": true
-        },
-        "lightningcss": {
-          "optional": true
-        },
-        "sass": {
-          "optional": true
-        },
-        "stylus": {
-          "optional": true
-        },
-        "sugarss": {
-          "optional": true
-        },
-        "terser": {
-          "optional": true
-        }
+        "@esbuild/android-arm": "0.18.20",
+        "@esbuild/android-arm64": "0.18.20",
+        "@esbuild/android-x64": "0.18.20",
+        "@esbuild/darwin-arm64": "0.18.20",
+        "@esbuild/darwin-x64": "0.18.20",
+        "@esbuild/freebsd-arm64": "0.18.20",
+        "@esbuild/freebsd-x64": "0.18.20",
+        "@esbuild/linux-arm": "0.18.20",
+        "@esbuild/linux-arm64": "0.18.20",
+        "@esbuild/linux-ia32": "0.18.20",
+        "@esbuild/linux-loong64": "0.18.20",
+        "@esbuild/linux-mips64el": "0.18.20",
+        "@esbuild/linux-ppc64": "0.18.20",
+        "@esbuild/linux-riscv64": "0.18.20",
+        "@esbuild/linux-s390x": "0.18.20",
+        "@esbuild/linux-x64": "0.18.20",
+        "@esbuild/netbsd-x64": "0.18.20",
+        "@esbuild/openbsd-x64": "0.18.20",
+        "@esbuild/sunos-x64": "0.18.20",
+        "@esbuild/win32-arm64": "0.18.20",
+        "@esbuild/win32-ia32": "0.18.20",
+        "@esbuild/win32-x64": "0.18.20"
       }
     },
-    "node_modules/@stacks/clarunit/node_modules/vitest": {
-      "version": "1.3.1",
-      "resolved": "https://registry.npmjs.org/vitest/-/vitest-1.3.1.tgz",
-      "integrity": "sha512-/1QJqXs8YbCrfv/GPQ05wAZf2eakUPLPa18vkJAKE7RXOKfVHqMZZ1WlTjiwl6Gcn65M5vpNUB6EFLnEdRdEXQ==",
-      "dependencies": {
-        "@vitest/expect": "1.3.1",
-        "@vitest/runner": "1.3.1",
-        "@vitest/snapshot": "1.3.1",
-        "@vitest/spy": "1.3.1",
-        "@vitest/utils": "1.3.1",
-        "acorn-walk": "^8.3.2",
-        "chai": "^4.3.10",
-        "debug": "^4.3.4",
-        "execa": "^8.0.1",
-        "local-pkg": "^0.5.0",
-        "magic-string": "^0.30.5",
-        "pathe": "^1.1.1",
-        "picocolors": "^1.0.0",
-        "std-env": "^3.5.0",
-        "strip-literal": "^2.0.0",
-        "tinybench": "^2.5.1",
-        "tinypool": "^0.8.2",
-        "vite": "^5.0.0",
-        "vite-node": "1.3.1",
-        "why-is-node-running": "^2.2.2"
-      },
+    "node_modules/@stacks/clarunit/node_modules/rollup": {
+      "version": "3.29.4",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-3.29.4.tgz",
+      "integrity": "sha512-oWzmBZwvYrU0iJHtDmhsm662rC15FRXmcjCk1xD771dFDx5jJ02ufAQQTn0etB2emNk4J9EZg/yWKpsn9BWGRw==",
       "bin": {
-        "vitest": "vitest.mjs"
+        "rollup": "dist/bin/rollup"
       },
       "engines": {
-        "node": "^18.0.0 || >=20.0.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/vitest"
-      },
-      "peerDependencies": {
-        "@edge-runtime/vm": "*",
-        "@types/node": "^18.0.0 || >=20.0.0",
-        "@vitest/browser": "1.3.1",
-        "@vitest/ui": "1.3.1",
-        "happy-dom": "*",
-        "jsdom": "*"
+        "node": ">=14.18.0",
+        "npm": ">=8.0.0"
       },
-      "peerDependenciesMeta": {
-        "@edge-runtime/vm": {
-          "optional": true
-        },
-        "@types/node": {
-          "optional": true
-        },
-        "@vitest/browser": {
-          "optional": true
-        },
-        "@vitest/ui": {
-          "optional": true
-        },
-        "happy-dom": {
-          "optional": true
-        },
-        "jsdom": {
-          "optional": true
-        }
+      "optionalDependencies": {
+        "fsevents": "~2.3.2"
       }
     },
-    "node_modules/@stacks/clarunit/node_modules/vitest/node_modules/vite": {
-      "version": "5.1.4",
-      "resolved": "https://registry.npmjs.org/vite/-/vite-5.1.4.tgz",
-      "integrity": "sha512-n+MPqzq+d9nMVTKyewqw6kSt+R3CkvF9QAKY8obiQn8g1fwTscKxyfaYnC632HtBXAQGc1Yjomphwn1dtwGAHg==",
+    "node_modules/@stacks/clarunit/node_modules/vite": {
+      "version": "4.5.2",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-4.5.2.tgz",
+      "integrity": "sha512-tBCZBNSBbHQkaGyhGCDUGqeo2ph8Fstyp6FMSvTtsXeZSPpSMGlviAOav2hxVTqFcx8Hj/twtWKsMJXNY0xI8w==",
       "dependencies": {
-        "esbuild": "^0.19.3",
-        "postcss": "^8.4.35",
-        "rollup": "^4.2.0"
+        "esbuild": "^0.18.10",
+        "postcss": "^8.4.27",
+        "rollup": "^3.27.1"
       },
       "bin": {
         "vite": "bin/vite.js"
       },
       "engines": {
-        "node": "^18.0.0 || >=20.0.0"
+        "node": "^14.18.0 || >=16.0.0"
       },
       "funding": {
         "url": "https://github.com/vitejs/vite?sponsor=1"
       },
       "optionalDependencies": {
-        "fsevents": "~2.3.3"
+        "fsevents": "~2.3.2"
       },
       "peerDependencies": {
-        "@types/node": "^18.0.0 || >=20.0.0",
+        "@types/node": ">= 14",
         "less": "*",
         "lightningcss": "^1.21.0",
         "sass": "*",
@@ -975,6 +1214,15 @@
         }
       }
     },
+    "node_modules/@stacks/clarunit/node_modules/vitest-environment-clarinet": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/vitest-environment-clarinet/-/vitest-environment-clarinet-1.1.0.tgz",
+      "integrity": "sha512-abf6VPWVyzZ6Ynz3kNqKZGsJuS0MH5xKyJeR9dgE5Y4dQ34KaBoTeA2jzgamDUxyX1y+5/yA/SBQab4sZjX8Sg==",
+      "peerDependencies": {
+        "@hirosystems/clarinet-sdk": "1",
+        "vitest": "1"
+      }
+    },
     "node_modules/@stacks/common": {
       "version": "6.10.0",
       "resolved": "https://registry.npmjs.org/@stacks/common/-/common-6.10.0.tgz",
@@ -984,6 +1232,22 @@
         "@types/node": "^18.0.4"
       }
     },
+    "node_modules/@stacks/encryption": {
+      "version": "6.12.0",
+      "resolved": "https://registry.npmjs.org/@stacks/encryption/-/encryption-6.12.0.tgz",
+      "integrity": "sha512-CubE51pHrcxx3yA+xapevPgA9UDleIoEaUZ06/9uD91B42yvTg37HyS8t06rzukU9q+X7Cv2I/+vbuf4nJIo8g==",
+      "dependencies": {
+        "@noble/hashes": "1.1.5",
+        "@noble/secp256k1": "1.7.1",
+        "@scure/bip39": "1.1.0",
+        "@stacks/common": "^6.10.0",
+        "@types/node": "^18.0.4",
+        "base64-js": "^1.5.1",
+        "bs58": "^5.0.0",
+        "ripemd160-min": "^0.0.6",
+        "varuint-bitcoin": "^1.1.2"
+      }
+    },
     "node_modules/@stacks/network": {
       "version": "6.11.3",
       "resolved": "https://registry.npmjs.org/@stacks/network/-/network-6.11.3.tgz",
@@ -993,6 +1257,36 @@
         "cross-fetch": "^3.1.5"
       }
     },
+    "node_modules/@stacks/stacking": {
+      "version": "6.12.0",
+      "resolved": "https://registry.npmjs.org/@stacks/stacking/-/stacking-6.12.0.tgz",
+      "integrity": "sha512-XBxwbaCGRPnjpjspb3CBXrlZl6xR+gghLMz9PQNPdpuIbBDFa0SGeHgqjtpVU+2DVL4UyBx8PVsAWtlssyVGng==",
+      "dependencies": {
+        "@scure/base": "1.1.1",
+        "@stacks/common": "^6.10.0",
+        "@stacks/encryption": "^6.12.0",
+        "@stacks/network": "^6.11.3",
+        "@stacks/stacks-blockchain-api-types": "^0.61.0",
+        "@stacks/transactions": "^6.12.0",
+        "bs58": "^5.0.0"
+      }
+    },
+    "node_modules/@stacks/stacking/node_modules/@scure/base": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/@scure/base/-/base-1.1.1.tgz",
+      "integrity": "sha512-ZxOhsSyxYwLJj3pLZCefNitxsj093tb2vq90mp2txoYeBqbcjDjqFhyM8eUjq/uFm6zJ+mUuqxlS2FkuSY1MTA==",
+      "funding": [
+        {
+          "type": "individual",
+          "url": "https://paulmillr.com/funding/"
+        }
+      ]
+    },
+    "node_modules/@stacks/stacks-blockchain-api-types": {
+      "version": "0.61.0",
+      "resolved": "https://registry.npmjs.org/@stacks/stacks-blockchain-api-types/-/stacks-blockchain-api-types-0.61.0.tgz",
+      "integrity": "sha512-yPOfTUboo5eA9BZL/hqMcM71GstrFs9YWzOrJFPeP4cOO1wgYvAcckgBRbgiE3NqeX0A7SLZLDAXLZbATuRq9w=="
+    },
     "node_modules/@stacks/transactions": {
       "version": "6.12.0",
       "resolved": "https://registry.npmjs.org/@stacks/transactions/-/transactions-6.12.0.tgz",
@@ -1014,28 +1308,15 @@
         "@types/node": "*"
       }
     },
-    "node_modules/@types/chai": {
-      "version": "4.3.9",
-      "resolved": "https://registry.npmjs.org/@types/chai/-/chai-4.3.9.tgz",
-      "integrity": "sha512-69TtiDzu0bcmKQv3yg1Zx409/Kd7r0b5F1PfpYJfSHzLGtB53547V4u+9iqKYsTu/O2ai6KTb0TInNpvuQ3qmg=="
-    },
-    "node_modules/@types/chai-subset": {
-      "version": "1.3.4",
-      "resolved": "https://registry.npmjs.org/@types/chai-subset/-/chai-subset-1.3.4.tgz",
-      "integrity": "sha512-CCWNXrJYSUIojZ1149ksLl3AN9cmZ5djf+yUoVVV+NuYrtydItQVlL2ZDqyC6M6O9LWRnVf8yYDxbXHO2TfQZg==",
-      "dependencies": {
-        "@types/chai": "*"
-      }
-    },
     "node_modules/@types/estree": {
       "version": "1.0.5",
       "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.5.tgz",
       "integrity": "sha512-/kYRxGDLWzHOB7q+wtSUQlFrtcdUccpfy+X+9iMBpHK8QLLhx2wIPYuS5DYtR9Wa/YlZAbIovy7qVdB1Aq6Lyw=="
     },
     "node_modules/@types/node": {
-      "version": "18.18.8",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-18.18.8.tgz",
-      "integrity": "sha512-OLGBaaK5V3VRBS1bAkMVP2/W9B+H8meUfl866OrMNQqt7wDgdpWPp5o6gmIc9pB+lIQHSq4ZL8ypeH1vPxcPaQ==",
+      "version": "18.19.23",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-18.19.23.tgz",
+      "integrity": "sha512-wtE3d0OUfNKtZYAqZb8HAWGxxXsImJcPUAgZNw+dWFxO6s5tIwIjyKnY76tsTatsNCLJPkVYwUpq15D38ng9Aw==",
       "dependencies": {
         "undici-types": "~5.26.4"
       }
@@ -1046,12 +1327,12 @@
       "integrity": "sha512-zuVdFrMJiuCDQUMCzQaD6KL28MjnqqN8XnAqiEq9PNm/hCPTSGfrXCOfwj1ow4LFb/tNymJPwsNbVePc1xFqrQ=="
     },
     "node_modules/@vitest/expect": {
-      "version": "0.34.6",
-      "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-0.34.6.tgz",
-      "integrity": "sha512-QUzKpUQRc1qC7qdGo7rMK3AkETI7w18gTCUrsNnyjjJKYiuUB9+TQK3QnR1unhCnWRC0AbKv2omLGQDF/mIjOw==",
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-1.3.1.tgz",
+      "integrity": "sha512-xofQFwIzfdmLLlHa6ag0dPV8YsnKOCP1KdAeVVh34vSjN2dcUiXYCD9htu/9eM7t8Xln4v03U9HLxLpPlsXdZw==",
       "dependencies": {
-        "@vitest/spy": "0.34.6",
-        "@vitest/utils": "0.34.6",
+        "@vitest/spy": "1.3.1",
+        "@vitest/utils": "1.3.1",
         "chai": "^4.3.10"
       },
       "funding": {
@@ -1059,59 +1340,85 @@
       }
     },
     "node_modules/@vitest/runner": {
-      "version": "0.34.6",
-      "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-0.34.6.tgz",
-      "integrity": "sha512-1CUQgtJSLF47NnhN+F9X2ycxUP0kLHQ/JWvNHbeBfwW8CzEGgeskzNnHDyv1ieKTltuR6sdIHV+nmR6kPxQqzQ==",
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-1.3.1.tgz",
+      "integrity": "sha512-5FzF9c3jG/z5bgCnjr8j9LNq/9OxV2uEBAITOXfoe3rdZJTdO7jzThth7FXv/6b+kdY65tpRQB7WaKhNZwX+Kg==",
       "dependencies": {
-        "@vitest/utils": "0.34.6",
-        "p-limit": "^4.0.0",
+        "@vitest/utils": "1.3.1",
+        "p-limit": "^5.0.0",
         "pathe": "^1.1.1"
       },
       "funding": {
         "url": "https://opencollective.com/vitest"
       }
     },
+    "node_modules/@vitest/runner/node_modules/p-limit": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-5.0.0.tgz",
+      "integrity": "sha512-/Eaoq+QyLSiXQ4lyYV23f14mZRQcXnxfHrN0vCai+ak9G0pp9iEQukIIZq5NccEvwRB8PUnZT0KsOoDCINS1qQ==",
+      "dependencies": {
+        "yocto-queue": "^1.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/@vitest/runner/node_modules/yocto-queue": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-1.0.0.tgz",
+      "integrity": "sha512-9bnSc/HEW2uRy67wc+T8UwauLuPJVn28jb+GtJY16iiKWyvmYJRXVT4UamsAEGQfPohgr2q4Tq0sQbQlxTfi1g==",
+      "engines": {
+        "node": ">=12.20"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/@vitest/snapshot": {
-      "version": "0.34.6",
-      "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-0.34.6.tgz",
-      "integrity": "sha512-B3OZqYn6k4VaN011D+ve+AA4whM4QkcwcrwaKwAbyyvS/NB1hCWjFIBQxAQQSQir9/RtyAAGuq+4RJmbn2dH4w==",
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-1.3.1.tgz",
+      "integrity": "sha512-EF++BZbt6RZmOlE3SuTPu/NfwBF6q4ABS37HHXzs2LUVPBLx2QoY/K0fKpRChSo8eLiuxcbCVfqKgx/dplCDuQ==",
       "dependencies": {
-        "magic-string": "^0.30.1",
+        "magic-string": "^0.30.5",
         "pathe": "^1.1.1",
-        "pretty-format": "^29.5.0"
+        "pretty-format": "^29.7.0"
       },
       "funding": {
         "url": "https://opencollective.com/vitest"
       }
     },
     "node_modules/@vitest/spy": {
-      "version": "0.34.6",
-      "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-0.34.6.tgz",
-      "integrity": "sha512-xaCvneSaeBw/cz8ySmF7ZwGvL0lBjfvqc1LpQ/vcdHEvpLn3Ff1vAvjw+CoGn0802l++5L/pxb7whwcWAw+DUQ==",
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-1.3.1.tgz",
+      "integrity": "sha512-xAcW+S099ylC9VLU7eZfdT9myV67Nor9w9zhf0mGCYJSO+zM2839tOeROTdikOi/8Qeusffvxb/MyBSOja1Uig==",
       "dependencies": {
-        "tinyspy": "^2.1.1"
+        "tinyspy": "^2.2.0"
       },
       "funding": {
         "url": "https://opencollective.com/vitest"
       }
     },
     "node_modules/@vitest/utils": {
-      "version": "0.34.6",
-      "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-0.34.6.tgz",
-      "integrity": "sha512-IG5aDD8S6zlvloDsnzHw0Ut5xczlF+kv2BOTo+iXfPr54Yhi5qbVOgGB1hZaVq4iJ4C/MZ2J0y15IlsV/ZcI0A==",
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-1.3.1.tgz",
+      "integrity": "sha512-d3Waie/299qqRyHTm2DjADeTaNdNSVsnwHPWrs20JMpjh6eiVq7ggggweO8rc4arhf6rRkWuHKwvxGvejUXZZQ==",
       "dependencies": {
-        "diff-sequences": "^29.4.3",
-        "loupe": "^2.3.6",
-        "pretty-format": "^29.5.0"
+        "diff-sequences": "^29.6.3",
+        "estree-walker": "^3.0.3",
+        "loupe": "^2.3.7",
+        "pretty-format": "^29.7.0"
       },
       "funding": {
         "url": "https://opencollective.com/vitest"
       }
     },
     "node_modules/acorn": {
-      "version": "8.11.2",
-      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.11.2.tgz",
-      "integrity": "sha512-nc0Axzp/0FILLEVsm4fNwLCwMttvhEI263QtVPQcbpfZZ3ts0hLsZGOpE6czNlid7CJ9MlyH8reXkpsf3YUY4w==",
+      "version": "8.11.3",
+      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.11.3.tgz",
+      "integrity": "sha512-Y9rRfJG5jcKOE0CLisYbojUjIrIEE7AGMzA/Sm4BslANhbS+cDMpgBdcPT91oJ7OuJ9hYJBx59RjbhxVnrF8Xg==",
       "bin": {
         "acorn": "bin/acorn"
       },
@@ -1159,11 +1466,14 @@
       }
     },
     "node_modules/ansi-styles": {
-      "version": "5.2.0",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-5.2.0.tgz",
-      "integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==",
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+      "dependencies": {
+        "color-convert": "^2.0.1"
+      },
       "engines": {
-        "node": ">=10"
+        "node": ">=8"
       },
       "funding": {
         "url": "https://github.com/chalk/ansi-styles?sponsor=1"
@@ -1204,6 +1514,25 @@
       "resolved": "https://registry.npmjs.org/base-x/-/base-x-4.0.0.tgz",
       "integrity": "sha512-FuwxlW4H5kh37X/oW59pwTzzTKRzfrrQwhmyspRM7swOEZcHtDZSCt45U6oKgtuFE+WYPblePMVIPR4RZrh/hw=="
     },
+    "node_modules/base64-js": {
+      "version": "1.5.1",
+      "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz",
+      "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ]
+    },
     "node_modules/binary-extensions": {
       "version": "2.2.0",
       "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-2.2.0.tgz",
@@ -1232,6 +1561,14 @@
         "node": ">=8"
       }
     },
+    "node_modules/bs58": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/bs58/-/bs58-5.0.0.tgz",
+      "integrity": "sha512-r+ihvQJvahgYT50JD05dyJNKlmmSlMoOGwn1lCcEzanPglg7TxYjioQUYehQ9mAR/+hOSd2jRc/Z2y5UxBymvQ==",
+      "dependencies": {
+        "base-x": "^4.0.0"
+      }
+    },
     "node_modules/c32check": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/c32check/-/c32check-2.0.0.tgz",
@@ -1269,9 +1606,9 @@
       }
     },
     "node_modules/chai": {
-      "version": "4.3.10",
-      "resolved": "https://registry.npmjs.org/chai/-/chai-4.3.10.tgz",
-      "integrity": "sha512-0UXG04VuVbruMUYbJ6JctvH0YnC/4q3/AkT18q4NaITo91CUm0liMS9VqzT9vZhVQ/1eqPanMWjBM+Juhfb/9g==",
+      "version": "4.4.1",
+      "resolved": "https://registry.npmjs.org/chai/-/chai-4.4.1.tgz",
+      "integrity": "sha512-13sOfMv2+DWduEU+/xbun3LScLoqN17nBeTLUsmDfKdoiC1fr0n9PU4guu4AhRcOVFk/sW8LyZWHuhWtQZiF+g==",
       "dependencies": {
         "assertion-error": "^1.1.0",
         "check-error": "^1.0.3",
@@ -1300,36 +1637,6 @@
         "url": "https://github.com/chalk/chalk?sponsor=1"
       }
     },
-    "node_modules/chalk/node_modules/ansi-styles": {
-      "version": "4.3.0",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
-      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
-      "dependencies": {
-        "color-convert": "^2.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
-      }
-    },
-    "node_modules/chalk/node_modules/color-convert": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
-      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
-      "dependencies": {
-        "color-name": "~1.1.4"
-      },
-      "engines": {
-        "node": ">=7.0.0"
-      }
-    },
-    "node_modules/chalk/node_modules/color-name": {
-      "version": "1.1.4",
-      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
-      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA=="
-    },
     "node_modules/check-error": {
       "version": "1.0.3",
       "resolved": "https://registry.npmjs.org/check-error/-/check-error-1.0.3.tgz",
@@ -1342,15 +1649,9 @@
       }
     },
     "node_modules/chokidar": {
-      "version": "3.5.3",
-      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.5.3.tgz",
-      "integrity": "sha512-Dr3sfKRP6oTcjf2JmUmFJfeVMvXBdegxB0iVQ5eb2V10uFJUCAS8OByZdVAyVb8xXNz3GjjTgj9kLWsZTqE6kw==",
-      "funding": [
-        {
-          "type": "individual",
-          "url": "https://paulmillr.com/funding/"
-        }
-      ],
+      "version": "3.6.0",
+      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-3.6.0.tgz",
+      "integrity": "sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==",
       "dependencies": {
         "anymatch": "~3.1.2",
         "braces": "~3.0.2",
@@ -1363,6 +1664,9 @@
       "engines": {
         "node": ">= 8.10.0"
       },
+      "funding": {
+        "url": "https://paulmillr.com/funding/"
+      },
       "optionalDependencies": {
         "fsevents": "~2.3.2"
       }
@@ -1413,11 +1717,35 @@
         "wrap-ansi": "^5.1.0"
       }
     },
+    "node_modules/chokidar-cli/node_modules/color-convert": {
+      "version": "1.9.3",
+      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz",
+      "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==",
+      "dependencies": {
+        "color-name": "1.1.3"
+      }
+    },
+    "node_modules/chokidar-cli/node_modules/color-name": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz",
+      "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw=="
+    },
     "node_modules/chokidar-cli/node_modules/emoji-regex": {
       "version": "7.0.3",
       "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-7.0.3.tgz",
       "integrity": "sha512-CwBLREIQ7LvYFB0WyRvwhq5N5qPhc6PMjD6bYggFlI5YyDgl+0vxq5VHbMOFqLg7hfWzmu8T5Z1QofhmTIhItA=="
     },
+    "node_modules/chokidar-cli/node_modules/find-up": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/find-up/-/find-up-3.0.0.tgz",
+      "integrity": "sha512-1yD6RmLI1XBfxugvORwlck6f75tYL+iR0jqwsOrOxMZyGYqUuDhJ0l4AXdO1iX/FTs9cBAMEk1gWSEx1kSbylg==",
+      "dependencies": {
+        "locate-path": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
     "node_modules/chokidar-cli/node_modules/is-fullwidth-code-point": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz",
@@ -1426,6 +1754,51 @@
         "node": ">=4"
       }
     },
+    "node_modules/chokidar-cli/node_modules/locate-path": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-3.0.0.tgz",
+      "integrity": "sha512-7AO748wWnIhNqAuaty2ZWHkQHRSNfPVIsPIfwEOWO22AmaoVrWavlOcMR5nzTLNYvp36X220/maaRsrec1G65A==",
+      "dependencies": {
+        "p-locate": "^3.0.0",
+        "path-exists": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/chokidar-cli/node_modules/p-limit": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz",
+      "integrity": "sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==",
+      "dependencies": {
+        "p-try": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/chokidar-cli/node_modules/p-locate": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-3.0.0.tgz",
+      "integrity": "sha512-x+12w/To+4GFfgJhBEpiDcLozRJGegY+Ei7/z0tSLkMmxGZNybVMSfWj9aJn8Z5Fc7dBUNJOOVgPv2H7IwulSQ==",
+      "dependencies": {
+        "p-limit": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/chokidar-cli/node_modules/path-exists": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-3.0.0.tgz",
+      "integrity": "sha512-bpC7GYwiDYQ4wYLe+FA8lhRjhQCMcQGuSgGGqDkg/QerRWw9CmGRT0iSOVRSZJ29NMLZgIzqaljJ63oaL4NIJQ==",
+      "engines": {
+        "node": ">=4"
+      }
+    },
     "node_modules/chokidar-cli/node_modules/string-width": {
       "version": "3.1.0",
       "resolved": "https://registry.npmjs.org/string-width/-/string-width-3.1.0.tgz",
@@ -1508,17 +1881,20 @@
       }
     },
     "node_modules/color-convert": {
-      "version": "1.9.3",
-      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz",
-      "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==",
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
+      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
       "dependencies": {
-        "color-name": "1.1.3"
+        "color-name": "~1.1.4"
+      },
+      "engines": {
+        "node": ">=7.0.0"
       }
     },
     "node_modules/color-name": {
-      "version": "1.1.3",
-      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz",
-      "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw=="
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
+      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA=="
     },
     "node_modules/concat-map": {
       "version": "0.0.1",
@@ -1611,9 +1987,9 @@
       "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="
     },
     "node_modules/esbuild": {
-      "version": "0.18.20",
-      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.18.20.tgz",
-      "integrity": "sha512-ceqxoedUrcayh7Y7ZX6NdbbDzGROiyVBgC4PriJThBKSVPWnnFHZAkfI1lJT8QFkOwH4qOS2SJkS4wvpGl8BpA==",
+      "version": "0.19.12",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.19.12.tgz",
+      "integrity": "sha512-aARqgq8roFBj054KvQr5f1sFu0D65G+miZRCuJyJ0G13Zwx7vRar5Zhn2tkQNzIXcBrNVsv/8stehpj+GAjgbg==",
       "hasInstallScript": true,
       "bin": {
         "esbuild": "bin/esbuild"
@@ -1622,34 +1998,35 @@
         "node": ">=12"
       },
       "optionalDependencies": {
-        "@esbuild/android-arm": "0.18.20",
-        "@esbuild/android-arm64": "0.18.20",
-        "@esbuild/android-x64": "0.18.20",
-        "@esbuild/darwin-arm64": "0.18.20",
-        "@esbuild/darwin-x64": "0.18.20",
-        "@esbuild/freebsd-arm64": "0.18.20",
-        "@esbuild/freebsd-x64": "0.18.20",
-        "@esbuild/linux-arm": "0.18.20",
-        "@esbuild/linux-arm64": "0.18.20",
-        "@esbuild/linux-ia32": "0.18.20",
-        "@esbuild/linux-loong64": "0.18.20",
-        "@esbuild/linux-mips64el": "0.18.20",
-        "@esbuild/linux-ppc64": "0.18.20",
-        "@esbuild/linux-riscv64": "0.18.20",
-        "@esbuild/linux-s390x": "0.18.20",
-        "@esbuild/linux-x64": "0.18.20",
-        "@esbuild/netbsd-x64": "0.18.20",
-        "@esbuild/openbsd-x64": "0.18.20",
-        "@esbuild/sunos-x64": "0.18.20",
-        "@esbuild/win32-arm64": "0.18.20",
-        "@esbuild/win32-ia32": "0.18.20",
-        "@esbuild/win32-x64": "0.18.20"
+        "@esbuild/aix-ppc64": "0.19.12",
+        "@esbuild/android-arm": "0.19.12",
+        "@esbuild/android-arm64": "0.19.12",
+        "@esbuild/android-x64": "0.19.12",
+        "@esbuild/darwin-arm64": "0.19.12",
+        "@esbuild/darwin-x64": "0.19.12",
+        "@esbuild/freebsd-arm64": "0.19.12",
+        "@esbuild/freebsd-x64": "0.19.12",
+        "@esbuild/linux-arm": "0.19.12",
+        "@esbuild/linux-arm64": "0.19.12",
+        "@esbuild/linux-ia32": "0.19.12",
+        "@esbuild/linux-loong64": "0.19.12",
+        "@esbuild/linux-mips64el": "0.19.12",
+        "@esbuild/linux-ppc64": "0.19.12",
+        "@esbuild/linux-riscv64": "0.19.12",
+        "@esbuild/linux-s390x": "0.19.12",
+        "@esbuild/linux-x64": "0.19.12",
+        "@esbuild/netbsd-x64": "0.19.12",
+        "@esbuild/openbsd-x64": "0.19.12",
+        "@esbuild/sunos-x64": "0.19.12",
+        "@esbuild/win32-arm64": "0.19.12",
+        "@esbuild/win32-ia32": "0.19.12",
+        "@esbuild/win32-x64": "0.19.12"
       }
     },
     "node_modules/escalade": {
-      "version": "3.1.1",
-      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz",
-      "integrity": "sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==",
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.2.tgz",
+      "integrity": "sha512-ErCHMCae19vR8vQGe50xIsVomy19rg6gFu3+r3jkEO46suLMWBksvVyoGgQV+jOfl84ZSOSlmv6Gxa89PmTGmA==",
       "engines": {
         "node": ">=6"
       }
@@ -1728,108 +2105,32 @@
         "estraverse": "^5.2.0"
       },
       "engines": {
-        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/eslint"
-      }
-    },
-    "node_modules/eslint-visitor-keys": {
-      "version": "3.4.3",
-      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz",
-      "integrity": "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==",
-      "engines": {
-        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
-      },
-      "funding": {
-        "url": "https://opencollective.com/eslint"
-      }
-    },
-    "node_modules/eslint/node_modules/find-up": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz",
-      "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==",
-      "dependencies": {
-        "locate-path": "^6.0.0",
-        "path-exists": "^4.0.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/eslint/node_modules/glob-parent": {
-      "version": "6.0.2",
-      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz",
-      "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==",
-      "dependencies": {
-        "is-glob": "^4.0.3"
-      },
-      "engines": {
-        "node": ">=10.13.0"
-      }
-    },
-    "node_modules/eslint/node_modules/locate-path": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz",
-      "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==",
-      "dependencies": {
-        "p-locate": "^5.0.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/eslint/node_modules/p-limit": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz",
-      "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==",
-      "dependencies": {
-        "yocto-queue": "^0.1.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/eslint/node_modules/p-locate": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz",
-      "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==",
-      "dependencies": {
-        "p-limit": "^3.0.2"
-      },
-      "engines": {
-        "node": ">=10"
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
       },
       "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+        "url": "https://opencollective.com/eslint"
       }
     },
-    "node_modules/eslint/node_modules/path-exists": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
-      "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==",
+    "node_modules/eslint-visitor-keys": {
+      "version": "3.4.3",
+      "resolved": "https://registry.npmjs.org/eslint-visitor-keys/-/eslint-visitor-keys-3.4.3.tgz",
+      "integrity": "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==",
       "engines": {
-        "node": ">=8"
+        "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
       }
     },
-    "node_modules/eslint/node_modules/yocto-queue": {
-      "version": "0.1.0",
-      "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz",
-      "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==",
-      "engines": {
-        "node": ">=10"
+    "node_modules/eslint/node_modules/glob-parent": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz",
+      "integrity": "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==",
+      "dependencies": {
+        "is-glob": "^4.0.3"
       },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+      "engines": {
+        "node": ">=10.13.0"
       }
     },
     "node_modules/espree": {
@@ -1917,9 +2218,9 @@
       }
     },
     "node_modules/fast-check": {
-      "version": "3.15.1",
-      "resolved": "https://registry.npmjs.org/fast-check/-/fast-check-3.15.1.tgz",
-      "integrity": "sha512-GutOXZ+SCxGaFWfHe0Pbeq8PrkpGtPxA9/hdkI3s9YzqeMlrq5RdJ+QfYZ/S93jMX+tAyqgW0z5c9ppD+vkGUw==",
+      "version": "3.16.0",
+      "resolved": "https://registry.npmjs.org/fast-check/-/fast-check-3.16.0.tgz",
+      "integrity": "sha512-k8GtQHi4pJoRQ1gVDFQno+/FVkowo/ehiz/aCj9O/D7HRWb1sSFzNrw+iPVU8QlWtH+jNwbuN+dDVg3QkS56DQ==",
       "funding": [
         {
           "type": "individual",
@@ -1983,14 +2284,18 @@
       }
     },
     "node_modules/find-up": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/find-up/-/find-up-3.0.0.tgz",
-      "integrity": "sha512-1yD6RmLI1XBfxugvORwlck6f75tYL+iR0jqwsOrOxMZyGYqUuDhJ0l4AXdO1iX/FTs9cBAMEk1gWSEx1kSbylg==",
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz",
+      "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==",
       "dependencies": {
-        "locate-path": "^3.0.0"
+        "locate-path": "^6.0.0",
+        "path-exists": "^4.0.0"
       },
       "engines": {
-        "node": ">=6"
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
     "node_modules/flat-cache": {
@@ -2162,9 +2467,9 @@
       }
     },
     "node_modules/inherits": {
-      "version": "2.0.3",
-      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz",
-      "integrity": "sha512-x00IRNXNy63jwGkJmzPigoySHbaqpNuzKbBOmzK+g2OdZpQ9w+sxCN+VSB3ja7IAge2OP2qpfxTjeNcyjmW1uw=="
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="
     },
     "node_modules/is-binary-path": {
       "version": "2.1.0",
@@ -2268,9 +2573,9 @@
       "integrity": "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw=="
     },
     "node_modules/jsonc-parser": {
-      "version": "3.2.0",
-      "resolved": "https://registry.npmjs.org/jsonc-parser/-/jsonc-parser-3.2.0.tgz",
-      "integrity": "sha512-gfFQZrcTc8CnKXp6Y4/CBT3fTc0OVuDofpre4aEeEpSBPV5X5v4+Vmx+8snU7RLPrNHPKSgLxGo9YuQzz20o+w=="
+      "version": "3.2.1",
+      "resolved": "https://registry.npmjs.org/jsonc-parser/-/jsonc-parser-3.2.1.tgz",
+      "integrity": "sha512-AilxAyFOAcK5wA1+LeaySVBrHsGQvUFCDWXKpZjzaL0PqW+xfBOttn8GNtWKFWqneyMZj41MWF9Kl6iPWLwgOA=="
     },
     "node_modules/keyv": {
       "version": "4.5.4",
@@ -2306,9 +2611,13 @@
       }
     },
     "node_modules/local-pkg": {
-      "version": "0.4.3",
-      "resolved": "https://registry.npmjs.org/local-pkg/-/local-pkg-0.4.3.tgz",
-      "integrity": "sha512-SFppqq5p42fe2qcZQqqEOiVRXl+WCP1MdT6k7BDEW1j++sp5fIY+/fdRQitvKgB5BrBcmrs5m/L0v2FrU5MY1g==",
+      "version": "0.5.0",
+      "resolved": "https://registry.npmjs.org/local-pkg/-/local-pkg-0.5.0.tgz",
+      "integrity": "sha512-ok6z3qlYyCDS4ZEU27HaU6x/xZa9Whf8jD4ptH5UZTQYZVYeb9bnZ3ojVhiJNLiXK1Hfc0GNbLXcmZ5plLDDBg==",
+      "dependencies": {
+        "mlly": "^1.4.2",
+        "pkg-types": "^1.0.3"
+      },
       "engines": {
         "node": ">=14"
       },
@@ -2317,15 +2626,17 @@
       }
     },
     "node_modules/locate-path": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-3.0.0.tgz",
-      "integrity": "sha512-7AO748wWnIhNqAuaty2ZWHkQHRSNfPVIsPIfwEOWO22AmaoVrWavlOcMR5nzTLNYvp36X220/maaRsrec1G65A==",
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz",
+      "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==",
       "dependencies": {
-        "p-locate": "^3.0.0",
-        "path-exists": "^3.0.0"
+        "p-locate": "^5.0.0"
       },
       "engines": {
-        "node": ">=6"
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
     "node_modules/lodash.clonedeep": {
@@ -2357,9 +2668,9 @@
       }
     },
     "node_modules/magic-string": {
-      "version": "0.30.5",
-      "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.5.tgz",
-      "integrity": "sha512-7xlpfBaQaP/T6Vh8MO/EqXSW5En6INHEvEXQiuff7Gku0PWjU3uf6w/j9o7O+SpB5fOAkrI5HeoNgwjEO0pFsA==",
+      "version": "0.30.8",
+      "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.8.tgz",
+      "integrity": "sha512-ISQTe55T2ao7XtlAStud6qwYPZjE4GK1S/BeVPus4jrq6JuOnQ00YKQC581RWhR122W7msZV263KzVeLoqidyQ==",
       "dependencies": {
         "@jridgewell/sourcemap-codec": "^1.4.15"
       },
@@ -2395,14 +2706,14 @@
       }
     },
     "node_modules/mlly": {
-      "version": "1.4.2",
-      "resolved": "https://registry.npmjs.org/mlly/-/mlly-1.4.2.tgz",
-      "integrity": "sha512-i/Ykufi2t1EZ6NaPLdfnZk2AX8cs0d+mTzVKuPfqPKPatxLApaBoxJQ9x1/uckXtrS/U5oisPMDkNs0yQTaBRg==",
+      "version": "1.6.1",
+      "resolved": "https://registry.npmjs.org/mlly/-/mlly-1.6.1.tgz",
+      "integrity": "sha512-vLgaHvaeunuOXHSmEbZ9izxPx3USsk8KCQ8iC+aTlp5sKRSoZvwhHh5L9VbKSaVC6sJDqbyohIS76E2VmHIPAA==",
       "dependencies": {
-        "acorn": "^8.10.0",
-        "pathe": "^1.1.1",
+        "acorn": "^8.11.3",
+        "pathe": "^1.1.2",
         "pkg-types": "^1.0.3",
-        "ufo": "^1.3.0"
+        "ufo": "^1.3.2"
       }
     },
     "node_modules/ms": {
@@ -2460,9 +2771,9 @@
       }
     },
     "node_modules/npm-run-path": {
-      "version": "5.2.0",
-      "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-5.2.0.tgz",
-      "integrity": "sha512-W4/tgAXFqFA0iL7fk0+uQ3g7wkL8xJmx3XdK0VGb4cHW//eZTtKGvFBBoRKVTpY7n6ze4NL9ly7rgXcHufqXKg==",
+      "version": "5.3.0",
+      "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-5.3.0.tgz",
+      "integrity": "sha512-ppwTtiJZq0O/ai0z7yfudtBpWIoxM8yE6nHi1X47eFR2EWORqfbu6CnPlNsjeN683eT0qG6H/Pyf9fCcvjnnnQ==",
       "dependencies": {
         "path-key": "^4.0.0"
       },
@@ -2523,39 +2834,28 @@
       }
     },
     "node_modules/p-limit": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-4.0.0.tgz",
-      "integrity": "sha512-5b0R4txpzjPWVw/cXXUResoD4hb6U/x9BH08L7nw+GN1sezDzPdxeRvpc9c433fZhBan/wusjbCsqwqm4EIBIQ==",
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz",
+      "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==",
       "dependencies": {
-        "yocto-queue": "^1.0.0"
+        "yocto-queue": "^0.1.0"
       },
       "engines": {
-        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+        "node": ">=10"
       },
       "funding": {
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
     "node_modules/p-locate": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-3.0.0.tgz",
-      "integrity": "sha512-x+12w/To+4GFfgJhBEpiDcLozRJGegY+Ei7/z0tSLkMmxGZNybVMSfWj9aJn8Z5Fc7dBUNJOOVgPv2H7IwulSQ==",
-      "dependencies": {
-        "p-limit": "^2.0.0"
-      },
-      "engines": {
-        "node": ">=6"
-      }
-    },
-    "node_modules/p-locate/node_modules/p-limit": {
-      "version": "2.3.0",
-      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-2.3.0.tgz",
-      "integrity": "sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==",
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz",
+      "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==",
       "dependencies": {
-        "p-try": "^2.0.0"
+        "p-limit": "^3.0.2"
       },
       "engines": {
-        "node": ">=6"
+        "node": ">=10"
       },
       "funding": {
         "url": "https://github.com/sponsors/sindresorhus"
@@ -2590,11 +2890,11 @@
       }
     },
     "node_modules/path-exists": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-3.0.0.tgz",
-      "integrity": "sha512-bpC7GYwiDYQ4wYLe+FA8lhRjhQCMcQGuSgGGqDkg/QerRWw9CmGRT0iSOVRSZJ29NMLZgIzqaljJ63oaL4NIJQ==",
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
+      "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==",
       "engines": {
-        "node": ">=4"
+        "node": ">=8"
       }
     },
     "node_modules/path-is-absolute": {
@@ -2614,9 +2914,9 @@
       }
     },
     "node_modules/pathe": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/pathe/-/pathe-1.1.1.tgz",
-      "integrity": "sha512-d+RQGp0MAYTIaDBIMmOfMwz3E+LOZnxx1HZd5R18mmCZY0QBlK0LDZfPc8FW8Ed2DlvsuE6PRjroDY+wg4+j/Q=="
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/pathe/-/pathe-1.1.2.tgz",
+      "integrity": "sha512-whLdWMYL2TwI08hn8/ZqAbrVemu0LNaNNJZX73O6qaIdCTfXutsLhMkjdENX0qhsQ9uIimo4/aQOmXkoon2nDQ=="
     },
     "node_modules/pathval": {
       "version": "1.1.1",
@@ -2700,6 +3000,17 @@
         "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
       }
     },
+    "node_modules/pretty-format/node_modules/ansi-styles": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-5.2.0.tgz",
+      "integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
     "node_modules/process": {
       "version": "0.11.10",
       "resolved": "https://registry.npmjs.org/process/-/process-0.11.10.tgz",
@@ -2822,18 +3133,42 @@
         "url": "https://github.com/sponsors/isaacs"
       }
     },
+    "node_modules/ripemd160-min": {
+      "version": "0.0.6",
+      "resolved": "https://registry.npmjs.org/ripemd160-min/-/ripemd160-min-0.0.6.tgz",
+      "integrity": "sha512-+GcJgQivhs6S9qvLogusiTcS9kQUfgR75whKuy5jIhuiOfQuJ8fjqxV6EGD5duH1Y/FawFUMtMhyeq3Fbnib8A==",
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/rollup": {
-      "version": "3.29.4",
-      "resolved": "https://registry.npmjs.org/rollup/-/rollup-3.29.4.tgz",
-      "integrity": "sha512-oWzmBZwvYrU0iJHtDmhsm662rC15FRXmcjCk1xD771dFDx5jJ02ufAQQTn0etB2emNk4J9EZg/yWKpsn9BWGRw==",
+      "version": "4.13.0",
+      "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.13.0.tgz",
+      "integrity": "sha512-3YegKemjoQnYKmsBlOHfMLVPPA5xLkQ8MHLLSw/fBrFaVkEayL51DilPpNNLq1exr98F2B1TzrV0FUlN3gWRPg==",
+      "dependencies": {
+        "@types/estree": "1.0.5"
+      },
       "bin": {
         "rollup": "dist/bin/rollup"
       },
       "engines": {
-        "node": ">=14.18.0",
+        "node": ">=18.0.0",
         "npm": ">=8.0.0"
       },
       "optionalDependencies": {
+        "@rollup/rollup-android-arm-eabi": "4.13.0",
+        "@rollup/rollup-android-arm64": "4.13.0",
+        "@rollup/rollup-darwin-arm64": "4.13.0",
+        "@rollup/rollup-darwin-x64": "4.13.0",
+        "@rollup/rollup-linux-arm-gnueabihf": "4.13.0",
+        "@rollup/rollup-linux-arm64-gnu": "4.13.0",
+        "@rollup/rollup-linux-arm64-musl": "4.13.0",
+        "@rollup/rollup-linux-riscv64-gnu": "4.13.0",
+        "@rollup/rollup-linux-x64-gnu": "4.13.0",
+        "@rollup/rollup-linux-x64-musl": "4.13.0",
+        "@rollup/rollup-win32-arm64-msvc": "4.13.0",
+        "@rollup/rollup-win32-ia32-msvc": "4.13.0",
+        "@rollup/rollup-win32-x64-msvc": "4.13.0",
         "fsevents": "~2.3.2"
       }
     },
@@ -2859,6 +3194,25 @@
         "queue-microtask": "^1.2.2"
       }
     },
+    "node_modules/safe-buffer": {
+      "version": "5.2.1",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+      "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ]
+    },
     "node_modules/set-blocking": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz",
@@ -2969,11 +3323,11 @@
       }
     },
     "node_modules/strip-literal": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/strip-literal/-/strip-literal-1.3.0.tgz",
-      "integrity": "sha512-PugKzOsyXpArk0yWmUwqOZecSO0GH0bPoctLcqNDH9J04pVW3lflYE0ujElBGTloevcxF5MofAOZ7C5l2b+wLg==",
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/strip-literal/-/strip-literal-2.0.0.tgz",
+      "integrity": "sha512-f9vHgsCWBq2ugHAkGMiiYY+AYG0D/cbloKKg0nhaaaSNsujdGIpVXCNsrJpCKr5M0f4aI31mr13UjY6GAuXCKA==",
       "dependencies": {
-        "acorn": "^8.10.0"
+        "js-tokens": "^8.0.2"
       },
       "funding": {
         "url": "https://github.com/sponsors/antfu"
@@ -2996,22 +3350,22 @@
       "integrity": "sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw=="
     },
     "node_modules/tinybench": {
-      "version": "2.5.1",
-      "resolved": "https://registry.npmjs.org/tinybench/-/tinybench-2.5.1.tgz",
-      "integrity": "sha512-65NKvSuAVDP/n4CqH+a9w2kTlLReS9vhsAP06MWx+/89nMinJyB2icyl58RIcqCmIggpojIGeuJGhjU1aGMBSg=="
+      "version": "2.6.0",
+      "resolved": "https://registry.npmjs.org/tinybench/-/tinybench-2.6.0.tgz",
+      "integrity": "sha512-N8hW3PG/3aOoZAN5V/NSAEDz0ZixDSSt5b/a05iqtpgfLWMSVuCo7w0k2vVvEjdrIoeGqZzweX2WlyioNIHchA=="
     },
     "node_modules/tinypool": {
-      "version": "0.7.0",
-      "resolved": "https://registry.npmjs.org/tinypool/-/tinypool-0.7.0.tgz",
-      "integrity": "sha512-zSYNUlYSMhJ6Zdou4cJwo/p7w5nmAH17GRfU/ui3ctvjXFErXXkruT4MWW6poDeXgCaIBlGLrfU6TbTXxyGMww==",
+      "version": "0.8.2",
+      "resolved": "https://registry.npmjs.org/tinypool/-/tinypool-0.8.2.tgz",
+      "integrity": "sha512-SUszKYe5wgsxnNOVlBYO6IC+8VGWdVGZWAqUxp3UErNBtptZvWbwyUOyzNL59zigz2rCA92QiL3wvG+JDSdJdQ==",
       "engines": {
         "node": ">=14.0.0"
       }
     },
     "node_modules/tinyspy": {
-      "version": "2.2.0",
-      "resolved": "https://registry.npmjs.org/tinyspy/-/tinyspy-2.2.0.tgz",
-      "integrity": "sha512-d2eda04AN/cPOR89F7Xv5bK/jrQEhmcLFe6HFldoeO9AJtps+fqEnh486vnT/8y4bw38pSyxDcTCAq+Ks2aJTg==",
+      "version": "2.2.1",
+      "resolved": "https://registry.npmjs.org/tinyspy/-/tinyspy-2.2.1.tgz",
+      "integrity": "sha512-KYad6Vy5VDWV4GH3fjpseMQ/XU2BhIYP7Vzd0LG44qRWm/Yt2WCOTicFdvmgo6gWaqooMQCawTtILVQJupKu7A==",
       "engines": {
         "node": ">=14.0.0"
       }
@@ -3063,9 +3417,9 @@
       }
     },
     "node_modules/typescript": {
-      "version": "5.2.2",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.2.2.tgz",
-      "integrity": "sha512-mI4WrpHsbCIcwT9cF4FZvr80QUeKvsUsUvKDoR+X/7XHQH98xYD8YHZg7ANtz2GtZt/CBq2QJ0thkGJMHfqc1w==",
+      "version": "5.4.2",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.4.2.tgz",
+      "integrity": "sha512-+2/g0Fds1ERlP6JsakQQDXjZdZMM+rqpamFZJEKh4kwTIn3iDkgKtby0CeNd5ATNZ4Ry1ax15TMx0W2V+miizQ==",
       "bin": {
         "tsc": "bin/tsc",
         "tsserver": "bin/tsserver"
@@ -3075,9 +3429,9 @@
       }
     },
     "node_modules/ufo": {
-      "version": "1.3.1",
-      "resolved": "https://registry.npmjs.org/ufo/-/ufo-1.3.1.tgz",
-      "integrity": "sha512-uY/99gMLIOlJPwATcMVYfqDSxUR9//AUcgZMzwfSTJPDKzA1S8mX4VLqa+fiAtveraQUBCz4FFcwVZBGbwBXIw=="
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/ufo/-/ufo-1.4.0.tgz",
+      "integrity": "sha512-Hhy+BhRBleFjpJ2vchUNN40qgkh0366FWJGqVLYBHev0vpHTrXSA0ryT+74UiW6KWsldNurQMKGqCm1M2zBciQ=="
     },
     "node_modules/undici-types": {
       "version": "5.26.5",
@@ -3100,29 +3454,42 @@
         "inherits": "2.0.3"
       }
     },
+    "node_modules/util/node_modules/inherits": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz",
+      "integrity": "sha512-x00IRNXNy63jwGkJmzPigoySHbaqpNuzKbBOmzK+g2OdZpQ9w+sxCN+VSB3ja7IAge2OP2qpfxTjeNcyjmW1uw=="
+    },
+    "node_modules/varuint-bitcoin": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/varuint-bitcoin/-/varuint-bitcoin-1.1.2.tgz",
+      "integrity": "sha512-4EVb+w4rx+YfVM32HQX42AbbT7/1f5zwAYhIujKXKk8NQK+JfRVl3pqT3hjNn/L+RstigmGGKVwHA/P0wgITZw==",
+      "dependencies": {
+        "safe-buffer": "^5.1.1"
+      }
+    },
     "node_modules/vite": {
-      "version": "4.5.0",
-      "resolved": "https://registry.npmjs.org/vite/-/vite-4.5.0.tgz",
-      "integrity": "sha512-ulr8rNLA6rkyFAlVWw2q5YJ91v098AFQ2R0PRFwPzREXOUJQPtFUG0t+/ZikhaOCDqFoDhN6/v8Sq0o4araFAw==",
+      "version": "5.1.6",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-5.1.6.tgz",
+      "integrity": "sha512-yYIAZs9nVfRJ/AiOLCA91zzhjsHUgMjB+EigzFb6W2XTLO8JixBCKCjvhKZaye+NKYHCrkv3Oh50dH9EdLU2RA==",
       "dependencies": {
-        "esbuild": "^0.18.10",
-        "postcss": "^8.4.27",
-        "rollup": "^3.27.1"
+        "esbuild": "^0.19.3",
+        "postcss": "^8.4.35",
+        "rollup": "^4.2.0"
       },
       "bin": {
         "vite": "bin/vite.js"
       },
       "engines": {
-        "node": "^14.18.0 || >=16.0.0"
+        "node": "^18.0.0 || >=20.0.0"
       },
       "funding": {
         "url": "https://github.com/vitejs/vite?sponsor=1"
       },
       "optionalDependencies": {
-        "fsevents": "~2.3.2"
+        "fsevents": "~2.3.3"
       },
       "peerDependencies": {
-        "@types/node": ">= 14",
+        "@types/node": "^18.0.0 || >=20.0.0",
         "less": "*",
         "lightningcss": "^1.21.0",
         "sass": "*",
@@ -3155,80 +3522,76 @@
       }
     },
     "node_modules/vite-node": {
-      "version": "0.34.6",
-      "resolved": "https://registry.npmjs.org/vite-node/-/vite-node-0.34.6.tgz",
-      "integrity": "sha512-nlBMJ9x6n7/Amaz6F3zJ97EBwR2FkzhBRxF5e+jE6LA3yi6Wtc2lyTij1OnDMIr34v5g/tVQtsVAzhT0jc5ygA==",
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/vite-node/-/vite-node-1.3.1.tgz",
+      "integrity": "sha512-azbRrqRxlWTJEVbzInZCTchx0X69M/XPTCz4H+TLvlTcR/xH/3hkRqhOakT41fMJCMzXTu4UvegkZiEoJAWvng==",
       "dependencies": {
         "cac": "^6.7.14",
         "debug": "^4.3.4",
-        "mlly": "^1.4.0",
         "pathe": "^1.1.1",
         "picocolors": "^1.0.0",
-        "vite": "^3.0.0 || ^4.0.0 || ^5.0.0-0"
+        "vite": "^5.0.0"
       },
       "bin": {
         "vite-node": "vite-node.mjs"
       },
       "engines": {
-        "node": ">=v14.18.0"
+        "node": "^18.0.0 || >=20.0.0"
       },
       "funding": {
         "url": "https://opencollective.com/vitest"
       }
     },
     "node_modules/vitest": {
-      "version": "0.34.6",
-      "resolved": "https://registry.npmjs.org/vitest/-/vitest-0.34.6.tgz",
-      "integrity": "sha512-+5CALsOvbNKnS+ZHMXtuUC7nL8/7F1F2DnHGjSsszX8zCjWSSviphCb/NuS9Nzf4Q03KyyDRBAXhF/8lffME4Q==",
-      "dependencies": {
-        "@types/chai": "^4.3.5",
-        "@types/chai-subset": "^1.3.3",
-        "@types/node": "*",
-        "@vitest/expect": "0.34.6",
-        "@vitest/runner": "0.34.6",
-        "@vitest/snapshot": "0.34.6",
-        "@vitest/spy": "0.34.6",
-        "@vitest/utils": "0.34.6",
-        "acorn": "^8.9.0",
-        "acorn-walk": "^8.2.0",
-        "cac": "^6.7.14",
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/vitest/-/vitest-1.3.1.tgz",
+      "integrity": "sha512-/1QJqXs8YbCrfv/GPQ05wAZf2eakUPLPa18vkJAKE7RXOKfVHqMZZ1WlTjiwl6Gcn65M5vpNUB6EFLnEdRdEXQ==",
+      "dependencies": {
+        "@vitest/expect": "1.3.1",
+        "@vitest/runner": "1.3.1",
+        "@vitest/snapshot": "1.3.1",
+        "@vitest/spy": "1.3.1",
+        "@vitest/utils": "1.3.1",
+        "acorn-walk": "^8.3.2",
         "chai": "^4.3.10",
         "debug": "^4.3.4",
-        "local-pkg": "^0.4.3",
-        "magic-string": "^0.30.1",
+        "execa": "^8.0.1",
+        "local-pkg": "^0.5.0",
+        "magic-string": "^0.30.5",
         "pathe": "^1.1.1",
         "picocolors": "^1.0.0",
-        "std-env": "^3.3.3",
-        "strip-literal": "^1.0.1",
-        "tinybench": "^2.5.0",
-        "tinypool": "^0.7.0",
-        "vite": "^3.1.0 || ^4.0.0 || ^5.0.0-0",
-        "vite-node": "0.34.6",
+        "std-env": "^3.5.0",
+        "strip-literal": "^2.0.0",
+        "tinybench": "^2.5.1",
+        "tinypool": "^0.8.2",
+        "vite": "^5.0.0",
+        "vite-node": "1.3.1",
         "why-is-node-running": "^2.2.2"
       },
       "bin": {
         "vitest": "vitest.mjs"
       },
       "engines": {
-        "node": ">=v14.18.0"
+        "node": "^18.0.0 || >=20.0.0"
       },
       "funding": {
         "url": "https://opencollective.com/vitest"
       },
       "peerDependencies": {
         "@edge-runtime/vm": "*",
-        "@vitest/browser": "*",
-        "@vitest/ui": "*",
+        "@types/node": "^18.0.0 || >=20.0.0",
+        "@vitest/browser": "1.3.1",
+        "@vitest/ui": "1.3.1",
         "happy-dom": "*",
-        "jsdom": "*",
-        "playwright": "*",
-        "safaridriver": "*",
-        "webdriverio": "*"
+        "jsdom": "*"
       },
       "peerDependenciesMeta": {
         "@edge-runtime/vm": {
           "optional": true
         },
+        "@types/node": {
+          "optional": true
+        },
         "@vitest/browser": {
           "optional": true
         },
@@ -3240,25 +3603,16 @@
         },
         "jsdom": {
           "optional": true
-        },
-        "playwright": {
-          "optional": true
-        },
-        "safaridriver": {
-          "optional": true
-        },
-        "webdriverio": {
-          "optional": true
         }
       }
     },
     "node_modules/vitest-environment-clarinet": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/vitest-environment-clarinet/-/vitest-environment-clarinet-1.0.3.tgz",
-      "integrity": "sha512-h/FeWPiEBS4a359Y8ZNo8nsftsfEoyLtZpJdnvDggDzcEUNkAsssU4tQzLp+KPm2VohAleqjFGSYMOGRbgLtDA==",
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/vitest-environment-clarinet/-/vitest-environment-clarinet-2.0.0.tgz",
+      "integrity": "sha512-NW8Z0JPV/hwB1WkvGiGED9JmXsefPUjImJRbO3BEsxdL8qxA1y2EAwuqjfmvXYDeisQSnZGbfns7DN8eDxJnpg==",
       "peerDependencies": {
-        "@hirosystems/clarinet-sdk": "1",
-        "vitest": "0"
+        "@hirosystems/clarinet-sdk": "2",
+        "vitest": "^1.3.1"
       }
     },
     "node_modules/webidl-conversions": {
@@ -3325,36 +3679,6 @@
         "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
       }
     },
-    "node_modules/wrap-ansi/node_modules/ansi-styles": {
-      "version": "4.3.0",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
-      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
-      "dependencies": {
-        "color-convert": "^2.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
-      }
-    },
-    "node_modules/wrap-ansi/node_modules/color-convert": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
-      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
-      "dependencies": {
-        "color-name": "~1.1.4"
-      },
-      "engines": {
-        "node": ">=7.0.0"
-      }
-    },
-    "node_modules/wrap-ansi/node_modules/color-name": {
-      "version": "1.1.4",
-      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
-      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA=="
-    },
     "node_modules/wrappy": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
@@ -3394,11 +3718,11 @@
       }
     },
     "node_modules/yocto-queue": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-1.0.0.tgz",
-      "integrity": "sha512-9bnSc/HEW2uRy67wc+T8UwauLuPJVn28jb+GtJY16iiKWyvmYJRXVT4UamsAEGQfPohgr2q4Tq0sQbQlxTfi1g==",
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz",
+      "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==",
       "engines": {
-        "node": ">=12.20"
+        "node": ">=10"
       },
       "funding": {
         "url": "https://github.com/sponsors/sindresorhus"
diff --git a/contrib/core-contract-tests/package.json b/contrib/core-contract-tests/package.json
index 774870d8f9..e9cb750ef3 100644
--- a/contrib/core-contract-tests/package.json
+++ b/contrib/core-contract-tests/package.json
@@ -3,6 +3,7 @@
   "version": "1.0.0",
   "description": "Run unit tests on this project.",
   "private": true,
+  "type": "module",
   "scripts": {
     "test": "vitest run -- --coverage",
     "genhtml": "genhtml lcov.info --branch-coverage -o coverage/"
@@ -10,14 +11,14 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@hirosystems/clarinet-sdk": "^1.1.0",
+    "@hirosystems/clarinet-sdk": "^2.4.0-beta3",
+    "@stacks/clarunit": "0.0.1",
     "@stacks/transactions": "^6.12.0",
     "chokidar-cli": "^3.0.0",
-    "@stacks/clarunit": "0.0.1",
     "fast-check": "^3.15.1",
-    "typescript": "^5.2.2",
-    "vite": "^4.4.9",
-    "vitest": "^0.34.4",
-    "vitest-environment-clarinet": "^1.0.0"
+    "typescript": "^5.4.2",
+    "vite": "^5.1.6",
+    "vitest": "^1.3.1",
+    "vitest-environment-clarinet": "^2.0.0"
   }
-}
\ No newline at end of file
+}
diff --git a/contrib/core-contract-tests/vitest.config.js b/contrib/core-contract-tests/vitest.config.js
index f856409052..364c55f735 100644
--- a/contrib/core-contract-tests/vitest.config.js
+++ b/contrib/core-contract-tests/vitest.config.js
@@ -1,7 +1,10 @@
 /// <reference types="vitest" />
 
 import { defineConfig } from "vite";
-import { vitestSetupFilePath, getClarinetVitestsArgv } from "@hirosystems/clarinet-sdk/vitest";
+import {
+  vitestSetupFilePath,
+  getClarinetVitestsArgv,
+} from "@hirosystems/clarinet-sdk/vitest";
 
 /*
   In this file, Vitest is configured so that it works seamlessly with Clarinet and the Simnet.
@@ -11,7 +14,7 @@ import { vitestSetupFilePath, getClarinetVitestsArgv } from "@hirosystems/clarin
 
   `vitestSetupFilePath` points to a file in the `@hirosystems/clarinet-sdk` package that does two things:
     - run `before` hooks to initialize the simnet and `after` hooks to collect costs and coverage reports.
-    - load custom Vitest matchers to work with Clarity values (such as `expect(...).toBeUint()`).
+    - load custom vitest matchers to work with Clarity values (such as `expect(...).toBeUint()`)
 
   The `getClarinetVitestsArgv()` will parse options passed to the command `vitest run --`
     - vitest run -- --manifest ./Clarinet.toml  # pass a custom path
@@ -21,7 +24,11 @@ import { vitestSetupFilePath, getClarinetVitestsArgv } from "@hirosystems/clarin
 export default defineConfig({
   test: {
     environment: "clarinet", // use vitest-environment-clarinet
-    singleThread: true,
+    pool: "forks",
+    poolOptions: {
+      threads: { singleThread: true },
+      forks: { singleFork: true },
+    },
     setupFiles: [
       vitestSetupFilePath,
       // custom setup files can be added here

From 407c8b2cc114866382a59feee597581cb4197517 Mon Sep 17 00:00:00 2001
From: Hugo Caillard <911307+hugocaillard@users.noreply.github.com>
Date: Wed, 13 Mar 2024 11:42:59 +0100
Subject: [PATCH 1139/1166] test: upgrade clarinet-sdk beta

---
 contrib/core-contract-tests/package-lock.json | 8 ++++----
 contrib/core-contract-tests/package.json      | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/contrib/core-contract-tests/package-lock.json b/contrib/core-contract-tests/package-lock.json
index 02c1d40f41..8a91b61382 100644
--- a/contrib/core-contract-tests/package-lock.json
+++ b/contrib/core-contract-tests/package-lock.json
@@ -9,7 +9,7 @@
       "version": "1.0.0",
       "license": "ISC",
       "dependencies": {
-        "@hirosystems/clarinet-sdk": "^2.4.0-beta3",
+        "@hirosystems/clarinet-sdk": "^2.4.0-beta4",
         "@stacks/clarunit": "0.0.1",
         "@stacks/transactions": "^6.12.0",
         "chokidar-cli": "^3.0.0",
@@ -426,9 +426,9 @@
       }
     },
     "node_modules/@hirosystems/clarinet-sdk": {
-      "version": "2.4.0-beta3",
-      "resolved": "https://registry.npmjs.org/@hirosystems/clarinet-sdk/-/clarinet-sdk-2.4.0-beta3.tgz",
-      "integrity": "sha512-O10yx4KtTXqi9/5LOGdLgQqt4M28/VLv7p9T9XOOy4j3mF81h+ZbvE4JH07BPJgZwQkupsGuouAnj5wD+OsIrg==",
+      "version": "2.4.0-beta4",
+      "resolved": "https://registry.npmjs.org/@hirosystems/clarinet-sdk/-/clarinet-sdk-2.4.0-beta4.tgz",
+      "integrity": "sha512-BBhPN0vEtNBG7gSR1CzAfbJED836damTgeKwAnNMUMVasIxzvclyFMRYyt2UOpjxuN7daPcObLZlHye0Ob70oQ==",
       "dependencies": {
         "@hirosystems/clarinet-sdk-wasm": "^2.4.0-beta3",
         "@stacks/encryption": "^6.12.0",
diff --git a/contrib/core-contract-tests/package.json b/contrib/core-contract-tests/package.json
index e9cb750ef3..d69b94779c 100644
--- a/contrib/core-contract-tests/package.json
+++ b/contrib/core-contract-tests/package.json
@@ -11,7 +11,7 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@hirosystems/clarinet-sdk": "^2.4.0-beta3",
+    "@hirosystems/clarinet-sdk": "^2.4.0-beta4",
     "@stacks/clarunit": "0.0.1",
     "@stacks/transactions": "^6.12.0",
     "chokidar-cli": "^3.0.0",

From b3ae5c55033ebdcf31b74595e4cd1176542f2a25 Mon Sep 17 00:00:00 2001
From: Hugo Caillard <911307+hugocaillard@users.noreply.github.com>
Date: Wed, 13 Mar 2024 14:32:45 +0100
Subject: [PATCH 1140/1166] ci: update stacks-core-tests

---
 .github/workflows/stacks-core-tests.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/stacks-core-tests.yml b/.github/workflows/stacks-core-tests.yml
index f737729562..0a16aa6d65 100644
--- a/.github/workflows/stacks-core-tests.yml
+++ b/.github/workflows/stacks-core-tests.yml
@@ -87,7 +87,7 @@ jobs:
         uses: stacks-network/actions/stacks-core/testenv@main
         with:
           btc-version: "25.0"
-          
+
       ## Run test matrix using restored cache of archive file
       ##   - Test will timeout after env.TEST_TIMEOUT minutes
       - name: Run Tests
@@ -153,7 +153,7 @@ jobs:
           node-version: 18.x
           cache: "npm"
           cache-dependency-path: "./contrib/core-contract-tests/package-lock.json"
-      - run: npm ci
+      - run: npm ci -f # need to force the update as long as we are using a beta version of the clarinet-sdk
       - run: npm test
       ## Upload code coverage file
       - name: Code Coverage

From 929bf1b577540864bfcf9805b6d8d5de2252cfe0 Mon Sep 17 00:00:00 2001
From: Hugo Caillard <911307+hugocaillard@users.noreply.github.com>
Date: Wed, 13 Mar 2024 17:36:36 +0100
Subject: [PATCH 1141/1166] chore: add comment

---
 clarity/src/vm/contexts.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/clarity/src/vm/contexts.rs b/clarity/src/vm/contexts.rs
index 4e408ca540..305c121988 100644
--- a/clarity/src/vm/contexts.rs
+++ b/clarity/src/vm/contexts.rs
@@ -1726,6 +1726,9 @@ impl<'a, 'hooks> GlobalContext<'a, 'hooks> {
         self.database.roll_back()
     }
 
+    // the allow_private parameter allows private functions calls to return any Clarity type
+    // and not just Response. It only has effect is the devtools feature is enabled. eg:
+    // clarity = { version = "*", features = ["devtools"] }
     pub fn handle_tx_result(
         &mut self,
         result: Result<Value>,

From 238a099ba974933fa62e93849dc6d70f3ed1a631 Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Wed, 13 Mar 2024 12:49:37 -0400
Subject: [PATCH 1142/1166] fix: correct deserialization size check

This fixes the condition controlling a debug message related to value
sanitization.
---
 clarity/src/vm/types/serialization.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/clarity/src/vm/types/serialization.rs b/clarity/src/vm/types/serialization.rs
index c7a92203b4..7dcda788a8 100644
--- a/clarity/src/vm/types/serialization.rs
+++ b/clarity/src/vm/types/serialization.rs
@@ -559,7 +559,7 @@ impl Value {
                 }
             };
 
-            if expect_size as u64 > bytes_read {
+            if bytes_read > expect_size as u64 {
                 // this can happen due to sanitization, so its no longer indicative of a *problem* with the node.
                 debug!(
                     "Deserialized more bytes than expected size during deserialization. Expected size = {}, bytes read = {}, type = {}",

From d499381042613136e65b5556bbe3214a2647b9ef Mon Sep 17 00:00:00 2001
From: janniks <janniks@users.noreply.github.com>
Date: Wed, 13 Mar 2024 18:41:16 +0100
Subject: [PATCH 1143/1166] fix: update revoke pox event

---
 pox-locking/src/events.rs                           | 2 +-
 stackslib/src/chainstate/stacks/boot/pox_4_tests.rs | 6 ++++--
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/pox-locking/src/events.rs b/pox-locking/src/events.rs
index e01b01a0fd..576d8d2c03 100644
--- a/pox-locking/src/events.rs
+++ b/pox-locking/src/events.rs
@@ -503,7 +503,7 @@ fn create_event_info_data_code(
                         data: {{
                             delegate-to: '{delegate_to},
                             ;; Get end cycle ID
-                            end-cycle-id: (some (+ (current-pox-reward-cycle) u1)),
+                            end-cycle-id: none,
                             ;; Get start cycle ID
                             start-cycle-id: (+ (current-pox-reward-cycle) u1),
                         }},
diff --git a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
index 1461ed0ab4..f1803e2c97 100644
--- a/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/pox_4_tests.rs
@@ -1780,7 +1780,6 @@ fn pox_4_check_cycle_id_range_in_print_events_in_prepare_phase() {
     let steph_stacking_receipt = txs.get(&steph_stacking.txid()).unwrap().clone();
     assert_eq!(steph_stacking_receipt.events.len(), 2);
     let steph_stacking_op_data = HashMap::from([
-        ("prep", Value::UInt(1)),                        // DEBUG
         ("start-cycle-id", Value::UInt(next_cycle + 1)), // +1 because steph stacked during the prepare phase
         (
             "end-cycle-id",
@@ -1861,7 +1860,10 @@ fn pox_4_revoke_delegate_stx_events() {
         get_tip(peer.sortdb.as_ref()).block_height
     );
     let block_height = get_tip(peer.sortdb.as_ref()).block_height;
+    let current_cycle = get_current_reward_cycle(&peer, &burnchain);
+    let next_cycle = current_cycle + 1;
     let min_ustx = get_stacking_minimum(&mut peer, &latest_block.unwrap());
+
     let steph_stacking = make_pox_4_contract_call(
         &steph,
         0,
@@ -1954,7 +1956,7 @@ fn pox_4_revoke_delegate_stx_events() {
     assert_eq!(revoke_delegation_tx_events.len() as u64, 1);
     let revoke_delegation_tx_event = &revoke_delegation_tx_events[0];
     let revoke_delegate_stx_op_data = HashMap::from([
-        ("start-cycle-id", Value::UInt(22)),
+        ("start-cycle-id", Value::UInt(next_cycle)),
         ("end-cycle-id", Optional(OptionalData { data: None })),
         (
             "delegate-to",

From 49eb61a705e7f64be204ecdf15fcca3bd623dabc Mon Sep 17 00:00:00 2001
From: Brice Dobry <brice@hiro.so>
Date: Wed, 13 Mar 2024 16:03:41 -0400
Subject: [PATCH 1144/1166] chore: delete commented code

We decided that since the signerdb is in the filesystem, we do not need
to garbage collect it.
---
 stacks-signer/src/signer.rs | 7 -------
 1 file changed, 7 deletions(-)

diff --git a/stacks-signer/src/signer.rs b/stacks-signer/src/signer.rs
index 3de6cc13a2..65c32dc1cc 100644
--- a/stacks-signer/src/signer.rs
+++ b/stacks-signer/src/signer.rs
@@ -1029,13 +1029,6 @@ impl Signer {
             return;
         };
 
-        // WIP: try not deleting a block from signerDB until we have a better garbage collection strategy.
-        // This causes issues when we have to reprocess a block and we have already deleted it from the signerDB
-        // // TODO: proper garbage collection...This is currently our only cleanup of blocks
-        // self.signer_db
-        //     .remove_block(&block_vote.signer_signature_hash)
-        //     .expect(&format!("{self}: Failed to remove block from to signer DB"));
-
         let block_submission = if block_vote.rejected {
             // We signed a rejection message. Return a rejection message
             BlockResponse::rejected(block_vote.signer_signature_hash, signature.clone())

From f5910989b941564057fd3100d50e4f89a3aea4c7 Mon Sep 17 00:00:00 2001
From: Hank Stoever <hstove@gmail.com>
Date: Thu, 14 Mar 2024 11:06:35 -0700
Subject: [PATCH 1145/1166] fix: remove `--reward-cycle` from `stacks-signer
 run`

---
 stacks-signer/src/cli.rs  | 18 +++++++++++++-----
 stacks-signer/src/main.rs |  4 ++--
 2 files changed, 15 insertions(+), 7 deletions(-)

diff --git a/stacks-signer/src/cli.rs b/stacks-signer/src/cli.rs
index a9afa33827..ac4da4e2f7 100644
--- a/stacks-signer/src/cli.rs
+++ b/stacks-signer/src/cli.rs
@@ -55,7 +55,7 @@ pub enum Command {
     /// Run a DKG round through the stacker-db instance
     Dkg(RunDkgArgs),
     /// Run the signer, waiting for events from the stacker-db instance
-    Run(RunDkgArgs),
+    Run(RunSignerArgs),
     /// Generate necessary files for running a collection of signers
     GenerateFiles(GenerateFilesArgs),
     /// Generate a signature for Stacking transactions
@@ -124,7 +124,7 @@ pub struct PutChunkArgs {
 /// Arguments for the dkg-sign and sign command
 pub struct SignArgs {
     /// Path to config file
-    #[arg(long, value_name = "FILE")]
+    #[arg(long, short, value_name = "FILE")]
     pub config: PathBuf,
     /// The reward cycle the signer is registered for and wants to sign for
     /// Note: this must be the current reward cycle of the node
@@ -138,16 +138,24 @@ pub struct SignArgs {
 }
 
 #[derive(Parser, Debug, Clone)]
-/// Arguments for the Run and Dkg commands
+/// Arguments for the Dkg command
 pub struct RunDkgArgs {
     /// Path to config file
-    #[arg(long, value_name = "FILE")]
+    #[arg(long, short, value_name = "FILE")]
     pub config: PathBuf,
     /// The reward cycle the signer is registered for and wants to peform DKG for
     #[arg(long, short)]
     pub reward_cycle: u64,
 }
 
+#[derive(Parser, Debug, Clone)]
+/// Arguments for the Run command
+pub struct RunSignerArgs {
+    /// Path to config file
+    #[arg(long, short, value_name = "FILE")]
+    pub config: PathBuf,
+}
+
 #[derive(Parser, Debug, Clone)]
 /// Arguments for the generate-files command
 pub struct GenerateFilesArgs {
@@ -230,7 +238,7 @@ pub struct GenerateStackingSignatureArgs {
     #[arg(short, long)]
     pub reward_cycle: u64,
     /// Path to config file
-    #[arg(long, value_name = "FILE")]
+    #[arg(long, short, value_name = "FILE")]
     pub config: PathBuf,
     /// Topic for signature
     #[arg(long)]
diff --git a/stacks-signer/src/main.rs b/stacks-signer/src/main.rs
index e9c0af22f2..95136271b7 100644
--- a/stacks-signer/src/main.rs
+++ b/stacks-signer/src/main.rs
@@ -46,7 +46,7 @@ use stacks_common::util::secp256k1::{MessageSignature, Secp256k1PublicKey};
 use stacks_common::{debug, error};
 use stacks_signer::cli::{
     Cli, Command, GenerateFilesArgs, GenerateStackingSignatureArgs, GetChunkArgs,
-    GetLatestChunkArgs, PutChunkArgs, RunDkgArgs, SignArgs, StackerDBArgs,
+    GetLatestChunkArgs, PutChunkArgs, RunDkgArgs, RunSignerArgs, SignArgs, StackerDBArgs,
 };
 use stacks_signer::config::{build_signer_config_tomls, GlobalConfig};
 use stacks_signer::runloop::{RunLoop, RunLoopCommand};
@@ -252,7 +252,7 @@ fn handle_dkg_sign(args: SignArgs) {
     spawned_signer.running_signer.stop();
 }
 
-fn handle_run(args: RunDkgArgs) {
+fn handle_run(args: RunSignerArgs) {
     debug!("Running signer...");
     let spawned_signer = spawn_running_signer(&args.config);
     println!("Signer spawned successfully. Waiting for messages to process...");

From 33ea8f6fe8503acfec8649ffd8b5897e6f601a3f Mon Sep 17 00:00:00 2001
From: Matthew Little <zone117x@gmail.com>
Date: Fri, 15 Mar 2024 14:17:11 +0100
Subject: [PATCH 1146/1166] fix: json serialization for PoxAddress in RewardSet
 #4492

---
 stackslib/src/chainstate/stacks/boot/mod.rs | 25 +++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 8330912da3..151ee91d80 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -256,6 +256,27 @@ where
     u128::from_str(&s).map_err(serde::de::Error::custom)
 }
 
+fn serialize_pox_addresses<S>(value: &Vec<PoxAddress>, serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: serde::Serializer,
+{
+    serializer.collect_seq(value.iter().cloned().map(|a| a.to_b58()))
+}
+
+fn deserialize_pox_addresses<'de, D>(deserializer: D) -> Result<Vec<PoxAddress>, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    Vec::<String>::deserialize(deserializer)?
+        .into_iter()
+        .map(|s| {
+            PoxAddress::from_b58(&s).ok_or_else(|| {
+                serde::de::Error::custom(format!("Failed to decode PoxAddress from Base58: {}", s))
+            })
+        })
+        .collect()
+}
+
 #[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
 pub struct NakamotoSignerEntry {
     #[serde(serialize_with = "hex_serialize", deserialize_with = "hex_deserialize")]
@@ -270,6 +291,10 @@ pub struct NakamotoSignerEntry {
 
 #[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
 pub struct RewardSet {
+    #[serde(
+        serialize_with = "serialize_pox_addresses",
+        deserialize_with = "deserialize_pox_addresses"
+    )]
     pub rewarded_addresses: Vec<PoxAddress>,
     pub start_cycle_state: PoxStartCycleInfo,
     #[serde(skip_serializing_if = "Option::is_none", default)]

From be879382c70fdf1996ed26a5bf718469d05c9da0 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Thu, 14 Mar 2024 16:10:26 -0400
Subject: [PATCH 1147/1166] fix: Unit/integration tests (except
 `test_epoch_switch_pox_3_contract_instantiation`)

---
 libsigner/src/messages.rs | 19 +++++++++++++++----
 stackslib/src/main.rs     |  2 +-
 2 files changed, 16 insertions(+), 5 deletions(-)

diff --git a/libsigner/src/messages.rs b/libsigner/src/messages.rs
index 477712b224..765827237d 100644
--- a/libsigner/src/messages.rs
+++ b/libsigner/src/messages.rs
@@ -33,10 +33,12 @@ use clarity::vm::types::QualifiedContractIdentifier;
 use hashbrown::HashMap;
 use serde::{Deserialize, Serialize};
 use stacks_common::codec::{
-    read_next, read_next_at_most, read_next_exact, write_next, Error as CodecError,
-    StacksMessageCodec,
+    read_next, read_next_at_most, read_next_at_most_with_epoch, read_next_exact, write_next,
+    Error as CodecError, StacksMessageCodec, MAX_MESSAGE_LEN,
 };
+use stacks_common::types::StacksEpochId;
 use stacks_common::util::hash::Sha512Trunc256Sum;
+use stacks_common::util::retry::BoundReader;
 use tiny_http::{
     Method as HttpMethod, Request as HttpRequest, Response as HttpResponse, Server as HttpServer,
 };
@@ -208,7 +210,11 @@ impl StacksMessageCodec for SignerMessage {
                 SignerMessage::BlockResponse(block_response)
             }
             SignerMessageTypePrefix::Transactions => {
-                let transactions = read_next::<Vec<StacksTransaction>, _>(fd)?;
+                // I don't think these messages are stored on the blockchain, so `StacksEpochId::latest()` should be fine
+                let transactions: Vec<StacksTransaction> = {
+                    let mut bound_read = BoundReader::from_reader(fd, MAX_MESSAGE_LEN as u64);
+                    read_next_at_most_with_epoch(&mut bound_read, u32::MAX, StacksEpochId::latest())
+                }?;
                 SignerMessage::Transactions(transactions)
             }
         };
@@ -852,7 +858,12 @@ impl StacksMessageCodec for RejectCode {
                 RejectCode::InsufficientSigners(read_next::<Vec<u32>, _>(fd)?)
             }
             RejectCodeTypePrefix::MissingTransactions => {
-                RejectCode::MissingTransactions(read_next::<Vec<StacksTransaction>, _>(fd)?)
+                // I don't think these messages are stored on the blockchain, so `StacksEpochId::latest()` should be fine
+                let transactions: Vec<StacksTransaction> = {
+                    let mut bound_read = BoundReader::from_reader(fd, MAX_MESSAGE_LEN as u64);
+                    read_next_at_most_with_epoch(&mut bound_read, u32::MAX, StacksEpochId::latest())
+                }?;
+                RejectCode::MissingTransactions(transactions)
             }
             RejectCodeTypePrefix::ConnectivityIssues => RejectCode::ConnectivityIssues,
         };
diff --git a/stackslib/src/main.rs b/stackslib/src/main.rs
index 9f682bbfd7..6af5a958d2 100644
--- a/stackslib/src/main.rs
+++ b/stackslib/src/main.rs
@@ -70,7 +70,7 @@ use libstackerdb::StackerDBChunkData;
 use rusqlite::types::ToSql;
 use rusqlite::{Connection, OpenFlags};
 use serde_json::{json, Value};
-use stacks_common::codec::{DeserializeWithEpoch, read_next, StacksMessageCodec};
+use stacks_common::codec::{read_next, DeserializeWithEpoch, StacksMessageCodec};
 use stacks_common::types::chainstate::{
     BlockHeaderHash, BurnchainHeaderHash, PoxId, StacksAddress, StacksBlockId,
 };

From 9664056710df8f0dd52bb9650b1ced5d5ac175b2 Mon Sep 17 00:00:00 2001
From: Matthew Little <zone117x@gmail.com>
Date: Fri, 15 Mar 2024 16:47:32 +0100
Subject: [PATCH 1148/1166] fix: move event-dispatcher related code out of
 consensus & migration critical area

---
 stackslib/src/chainstate/stacks/boot/mod.rs |  77 +------------
 testnet/stacks-node/src/event_dispatcher.rs | 115 ++++++++++++++++----
 2 files changed, 96 insertions(+), 96 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/mod.rs b/stackslib/src/chainstate/stacks/boot/mod.rs
index 151ee91d80..cea468ef0b 100644
--- a/stackslib/src/chainstate/stacks/boot/mod.rs
+++ b/stackslib/src/chainstate/stacks/boot/mod.rs
@@ -213,97 +213,22 @@ fn hex_deserialize<'de, D: serde::Deserializer<'de>>(
     Ok(bytes)
 }
 
-fn serialize_optional_u128_as_string<S>(
-    value: &Option<u128>,
-    serializer: S,
-) -> Result<S::Ok, S::Error>
-where
-    S: serde::Serializer,
-{
-    match value {
-        Some(v) => serializer.serialize_str(&v.to_string()),
-        None => serializer.serialize_none(),
-    }
-}
-
-fn deserialize_optional_u128_from_string<'de, D>(deserializer: D) -> Result<Option<u128>, D::Error>
-where
-    D: serde::Deserializer<'de>,
-{
-    let s: Option<String> = Option::deserialize(deserializer)?;
-    match s {
-        Some(str_val) => str_val
-            .parse::<u128>()
-            .map(Some)
-            .map_err(serde::de::Error::custom),
-        None => Ok(None),
-    }
-}
-
-fn serialize_u128_as_string<S>(value: &u128, serializer: S) -> Result<S::Ok, S::Error>
-where
-    S: serde::Serializer,
-{
-    serializer.serialize_str(&value.to_string())
-}
-
-fn deserialize_u128_from_string<'de, D>(deserializer: D) -> Result<u128, D::Error>
-where
-    D: serde::Deserializer<'de>,
-{
-    use std::str::FromStr;
-    let s = String::deserialize(deserializer)?;
-    u128::from_str(&s).map_err(serde::de::Error::custom)
-}
-
-fn serialize_pox_addresses<S>(value: &Vec<PoxAddress>, serializer: S) -> Result<S::Ok, S::Error>
-where
-    S: serde::Serializer,
-{
-    serializer.collect_seq(value.iter().cloned().map(|a| a.to_b58()))
-}
-
-fn deserialize_pox_addresses<'de, D>(deserializer: D) -> Result<Vec<PoxAddress>, D::Error>
-where
-    D: serde::Deserializer<'de>,
-{
-    Vec::<String>::deserialize(deserializer)?
-        .into_iter()
-        .map(|s| {
-            PoxAddress::from_b58(&s).ok_or_else(|| {
-                serde::de::Error::custom(format!("Failed to decode PoxAddress from Base58: {}", s))
-            })
-        })
-        .collect()
-}
-
 #[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
 pub struct NakamotoSignerEntry {
     #[serde(serialize_with = "hex_serialize", deserialize_with = "hex_deserialize")]
     pub signing_key: [u8; 33],
-    #[serde(
-        serialize_with = "serialize_u128_as_string",
-        deserialize_with = "deserialize_u128_from_string"
-    )]
     pub stacked_amt: u128,
     pub weight: u32,
 }
 
 #[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
 pub struct RewardSet {
-    #[serde(
-        serialize_with = "serialize_pox_addresses",
-        deserialize_with = "deserialize_pox_addresses"
-    )]
     pub rewarded_addresses: Vec<PoxAddress>,
     pub start_cycle_state: PoxStartCycleInfo,
     #[serde(skip_serializing_if = "Option::is_none", default)]
     // only generated for nakamoto reward sets
     pub signers: Option<Vec<NakamotoSignerEntry>>,
-    #[serde(
-        serialize_with = "serialize_optional_u128_as_string",
-        deserialize_with = "deserialize_optional_u128_from_string"
-    )]
+    #[serde(default)]
     pub pox_ustx_threshold: Option<u128>,
 }
 
diff --git a/testnet/stacks-node/src/event_dispatcher.rs b/testnet/stacks-node/src/event_dispatcher.rs
index 7b8e4108ce..b1c855e53d 100644
--- a/testnet/stacks-node/src/event_dispatcher.rs
+++ b/testnet/stacks-node/src/event_dispatcher.rs
@@ -17,7 +17,9 @@ use stacks::chainstate::burn::ConsensusHash;
 use stacks::chainstate::coordinator::BlockEventDispatcher;
 use stacks::chainstate::nakamoto::NakamotoBlock;
 use stacks::chainstate::stacks::address::PoxAddress;
-use stacks::chainstate::stacks::boot::RewardSetData;
+use stacks::chainstate::stacks::boot::{
+    NakamotoSignerEntry, PoxStartCycleInfo, RewardSet, RewardSetData,
+};
 use stacks::chainstate::stacks::db::accounts::MinerReward;
 use stacks::chainstate::stacks::db::unconfirmed::ProcessedUnconfirmedState;
 use stacks::chainstate::stacks::db::{MinerRewardInfo, StacksHeaderInfo};
@@ -36,6 +38,7 @@ use stacks::net::api::postblock_proposal::{
 };
 use stacks::net::atlas::{Attachment, AttachmentInstance};
 use stacks::net::stackerdb::StackerDBEventDispatcher;
+use stacks::util::hash::to_hex;
 use stacks_common::bitvec::BitVec;
 use stacks_common::codec::StacksMessageCodec;
 use stacks_common::types::chainstate::{BlockHeaderHash, BurnchainHeaderHash, StacksBlockId};
@@ -106,6 +109,79 @@ pub struct MinedNakamotoBlockEvent {
     pub signer_bitvec: String,
 }
 
+fn serialize_u128_as_string<S>(value: &u128, serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: serde::Serializer,
+{
+    serializer.serialize_str(&value.to_string())
+}
+
+fn serialize_pox_addresses<S>(value: &Vec<PoxAddress>, serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: serde::Serializer,
+{
+    serializer.collect_seq(value.iter().cloned().map(|a| a.to_b58()))
+}
+
+fn serialize_optional_u128_as_string<S>(
+    value: &Option<u128>,
+    serializer: S,
+) -> Result<S::Ok, S::Error>
+where
+    S: serde::Serializer,
+{
+    match value {
+        Some(v) => serializer.serialize_str(&v.to_string()),
+        None => serializer.serialize_none(),
+    }
+}
+
+fn hex_serialize<S: serde::Serializer>(addr: &[u8; 33], s: S) -> Result<S::Ok, S::Error> {
+    s.serialize_str(&to_hex(addr))
+}
+
+#[derive(Debug, PartialEq, Clone, Serialize)]
+pub struct RewardSetEventPayload {
+    #[serde(serialize_with = "serialize_pox_addresses")]
+    pub rewarded_addresses: Vec<PoxAddress>,
+    pub start_cycle_state: PoxStartCycleInfo,
+    #[serde(skip_serializing_if = "Option::is_none", default)]
+    // only generated for nakamoto reward sets
+    pub signers: Option<Vec<NakamotoSignerEntryPayload>>,
+    #[serde(serialize_with = "serialize_optional_u128_as_string")]
+    pub pox_ustx_threshold: Option<u128>,
+}
+
+#[derive(Debug, PartialEq, Clone, Serialize)]
+pub struct NakamotoSignerEntryPayload {
+    #[serde(serialize_with = "hex_serialize")]
+    pub signing_key: [u8; 33],
+    #[serde(serialize_with = "serialize_u128_as_string")]
+    pub stacked_amt: u128,
+    pub weight: u32,
+}
+
+impl RewardSetEventPayload {
+    pub fn signer_entry_to_payload(entry: &NakamotoSignerEntry) -> NakamotoSignerEntryPayload {
+        NakamotoSignerEntryPayload {
+            signing_key: entry.signing_key,
+            stacked_amt: entry.stacked_amt,
+            weight: entry.weight,
+        }
+    }
+    pub fn from_reward_set(reward_set: &RewardSet) -> Self {
+        Self {
+            rewarded_addresses: reward_set.rewarded_addresses.clone(),
+            start_cycle_state: reward_set.start_cycle_state.clone(),
+            signers: reward_set
+                .signers
+                .as_ref()
+                .map(|signers| signers.iter().map(Self::signer_entry_to_payload).collect()),
+            pox_ustx_threshold: reward_set.pox_ustx_threshold,
+        }
+    }
+}
+
 impl EventObserver {
     pub fn send_payload(&self, payload: &serde_json::Value, path: &str) {
         let body = match serde_json::to_vec(&payload) {
@@ -410,8 +486,22 @@ impl EventObserver {
             tx_index += 1;
         }
 
+        let signer_bitvec_value = signer_bitvec_opt
+            .as_ref()
+            .map(|bitvec| serde_json::to_value(bitvec).unwrap_or_default())
+            .unwrap_or_default();
+
+        let (reward_set_value, cycle_number_value) = match &reward_set_data {
+            Some(data) => (
+                serde_json::to_value(&RewardSetEventPayload::from_reward_set(&data.reward_set))
+                    .unwrap_or_default(),
+                serde_json::to_value(data.cycle_number).unwrap_or_default(),
+            ),
+            None => (serde_json::Value::Null, serde_json::Value::Null),
+        };
+
         // Wrap events
-        let mut payload = json!({
+        let payload = json!({
             "block_hash": format!("0x{}", block.block_hash),
             "block_height": metadata.stacks_block_height,
             "burn_block_hash": format!("0x{}", metadata.burn_header_hash),
@@ -434,26 +524,11 @@ impl EventObserver {
             "pox_v1_unlock_height": pox_constants.v1_unlock_height,
             "pox_v2_unlock_height": pox_constants.v2_unlock_height,
             "pox_v3_unlock_height": pox_constants.v3_unlock_height,
+            "signer_bitvec": signer_bitvec_value,
+            "reward_set": reward_set_value,
+            "cycle_number": cycle_number_value,
         });
 
-        if let Some(signer_bitvec) = signer_bitvec_opt {
-            payload.as_object_mut().unwrap().insert(
-                "signer_bitvec".to_string(),
-                serde_json::to_value(signer_bitvec).unwrap_or_default(),
-            );
-        }
-
-        if let Some(reward_set_data) = reward_set_data {
-            payload.as_object_mut().unwrap().insert(
-                "reward_set".to_string(),
-                serde_json::to_value(&reward_set_data.reward_set).unwrap_or_default(),
-            );
-            payload.as_object_mut().unwrap().insert(
-                "cycle_number".to_string(),
-                serde_json::to_value(reward_set_data.cycle_number).unwrap_or_default(),
-            );
-        }
-
         payload
     }
 }

From 6e4d9cce7305d2c47504ec00cead5ba1a159a3ed Mon Sep 17 00:00:00 2001
From: Aaron Blankstein <aaron@hiro.so>
Date: Fri, 15 Mar 2024 11:43:15 -0500
Subject: [PATCH 1149/1166] chore: add TODO for tracking burnchain/stacks views

---
 stacks-signer/src/runloop.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/stacks-signer/src/runloop.rs b/stacks-signer/src/runloop.rs
index 0d76a36eeb..607bb8489a 100644
--- a/stacks-signer/src/runloop.rs
+++ b/stacks-signer/src/runloop.rs
@@ -266,6 +266,7 @@ impl RunLoop {
                     .insert(reward_index, Signer::from(new_signer_config));
                 debug!("Reward cycle #{reward_cycle} Signer #{signer_id} initialized.");
             } else {
+                // TODO: Update `current` here once the signer binary is tracking its own latest burnchain/stacks views.
                 if current {
                     warn!("Signer is not registered for the current reward cycle ({reward_cycle}). Waiting for confirmed registration...");
                 } else {

From 23b44ebf7cfd83c2dfe5ecad30904e933a0dae98 Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Fri, 15 Mar 2024 16:56:14 -0400
Subject: [PATCH 1150/1166] fix: Unit/integration tests (except
 `test_epoch_switch_pox_3_contract_instantiation`)

---
 stackslib/src/chainstate/nakamoto/staging_blocks.rs | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/stackslib/src/chainstate/nakamoto/staging_blocks.rs b/stackslib/src/chainstate/nakamoto/staging_blocks.rs
index c0d9177783..4673793a98 100644
--- a/stackslib/src/chainstate/nakamoto/staging_blocks.rs
+++ b/stackslib/src/chainstate/nakamoto/staging_blocks.rs
@@ -30,7 +30,8 @@ use crate::chainstate::nakamoto::{NakamotoBlock, NakamotoChainState};
 use crate::chainstate::stacks::db::StacksChainState;
 use crate::chainstate::stacks::index::marf::MarfConnection;
 use crate::chainstate::stacks::{Error as ChainstateError, StacksBlock, StacksBlockHeader};
-use crate::stacks_common::codec::StacksMessageCodec;
+use crate::stacks_common::codec::{DeserializeWithEpoch, StacksMessageCodec};
+use crate::stacks_common::types::StacksEpochId;
 use crate::util_lib::db::{
     query_int, query_row, query_row_panic, query_rows, sqlite_open, tx_begin_immediate, u64_to_sql,
     DBConn, Error as DBError, FromRow,
@@ -173,7 +174,10 @@ impl<'a> NakamotoStagingBlocksConnRef<'a> {
         let Some(block_bytes) = res else {
             return Ok(None);
         };
-        let block = NakamotoBlock::consensus_deserialize(&mut block_bytes.as_slice())?;
+        let block = NakamotoBlock::consensus_deserialize_with_epoch(
+            &mut block_bytes.as_slice(),
+            StacksEpochId::latest(),
+        )?;
         if &block.header.block_id() != index_block_hash {
             error!(
                 "Staging DB corruption: expected {}, got {}",
@@ -208,7 +212,7 @@ impl<'a> NakamotoStagingBlocksConnRef<'a> {
         self
             .query_row_and_then(query, NO_PARAMS, |row| {
                 let data: Vec<u8> = row.get("data")?;
-                let block = NakamotoBlock::consensus_deserialize(&mut data.as_slice())?;
+                let block = NakamotoBlock::consensus_deserialize_with_epoch(&mut data.as_slice(), StacksEpochId::latest())?;
                 Ok(Some((
                     block,
                     u64::try_from(data.len()).expect("FATAL: block is bigger than a u64"),

From 61edcf35fd3e2924dcbf8c5cf15ae5f5621addb4 Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Tue, 5 Mar 2024 07:43:59 -0500
Subject: [PATCH 1151/1166] created new threshold-weight private function

---
 .../src/chainstate/stacks/boot/signers-voting.clar    | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers-voting.clar b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
index a5ca200304..6dfd06f530 100644
--- a/stackslib/src/chainstate/stacks/boot/signers-voting.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
@@ -81,6 +81,13 @@
 (define-read-only (get-approved-aggregate-key (reward-cycle uint))
     (map-get? aggregate-public-keys reward-cycle))
 
+;; get the weight required for consensus threshold
+(define-private (get-threshold-weight (reward-cycle uint))
+    (let  ((total-weight (try! (get-and-cache-total-weight reward-cycle))))
+        (ok (/ (+ (* total-weight threshold-consensus) u999) u1000))
+    )
+)
+
 (define-private (is-in-voting-window (height uint) (reward-cycle uint))
     (let ((last-cycle (unwrap-panic (contract-call? .signers get-last-set-cycle))))
         (and (is-eq last-cycle reward-cycle)
@@ -134,7 +141,7 @@
             ;; vote by signer weight
             (signer-weight (try! (get-signer-weight signer-index reward-cycle)))
             (new-total (+ signer-weight (default-to u0 (map-get? tally tally-key))))
-            (total-weight (try! (get-and-cache-total-weight reward-cycle))))
+            (threshold-weight (try! (get-threshold-weight reward-cycle))))
         ;; Check that the key has not yet been set for this reward cycle
         (asserts! (is-none (map-get? aggregate-public-keys reward-cycle)) (err ERR_OUT_OF_VOTING_WINDOW))
         ;; Check that the aggregate public key is the correct length
@@ -158,7 +165,7 @@
             new-total: new-total,
         })
         ;; If the new total weight is greater than or equal to the threshold consensus
-        (if (>= (/ (* new-total u1000) total-weight) threshold-consensus)
+        (if (>= new-total threshold-weight)
             ;; Save this approved aggregate public key for this reward cycle.
             ;; If there is not already a key for this cycle, the insert will
             ;; return true and an event will be created.

From b28af86cc4335a0ba7f06903e0da808a2a69f106 Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Tue, 5 Mar 2024 09:48:28 -0500
Subject: [PATCH 1152/1166] updated precision from three-figures to two

---
 stackslib/src/chainstate/stacks/boot/signers-voting.clar | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers-voting.clar b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
index 6dfd06f530..2b1e937835 100644
--- a/stackslib/src/chainstate/stacks/boot/signers-voting.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
@@ -26,7 +26,7 @@
 
 ;; Threshold consensus, expressed as parts-per-thousand to allow for integer
 ;; division with higher precision (e.g. 700 for 70%).
-(define-constant threshold-consensus u700)
+(define-constant threshold-consensus u70)
 
 ;; Maps reward-cycle ids to last round
 (define-map rounds uint uint)
@@ -84,7 +84,7 @@
 ;; get the weight required for consensus threshold
 (define-private (get-threshold-weight (reward-cycle uint))
     (let  ((total-weight (try! (get-and-cache-total-weight reward-cycle))))
-        (ok (/ (+ (* total-weight threshold-consensus) u999) u1000))
+        (ok (/ (+ (* total-weight threshold-consensus) u99) u100))
     )
 )
 

From 113b1714645eac79eb5bb98dcd40c3b0a1a53f34 Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Tue, 5 Mar 2024 13:18:07 -0500
Subject: [PATCH 1153/1166] formatting

---
 stackslib/src/chainstate/stacks/boot/signers-voting.clar | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers-voting.clar b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
index 2b1e937835..bf9cb51f08 100644
--- a/stackslib/src/chainstate/stacks/boot/signers-voting.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
@@ -84,9 +84,7 @@
 ;; get the weight required for consensus threshold
 (define-private (get-threshold-weight (reward-cycle uint))
     (let  ((total-weight (try! (get-and-cache-total-weight reward-cycle))))
-        (ok (/ (+ (* total-weight threshold-consensus) u99) u100))
-    )
-)
+        (ok (/ (+ (* total-weight threshold-consensus) u99) u100))))
 
 (define-private (is-in-voting-window (height uint) (reward-cycle uint))
     (let ((last-cycle (unwrap-panic (contract-call? .signers get-last-set-cycle))))

From 04ab036bd564a8c29d767e956c26e3abe3cf63bc Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Wed, 6 Mar 2024 10:44:58 -0500
Subject: [PATCH 1154/1166] updating round-data correctly

---
 .../stacks/boot/signers-voting.clar           | 21 ++++++++++++++++---
 1 file changed, 18 insertions(+), 3 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers-voting.clar b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
index bf9cb51f08..dddd0281af 100644
--- a/stackslib/src/chainstate/stacks/boot/signers-voting.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
@@ -20,6 +20,7 @@
 (define-constant ERR_DUPLICATE_VOTE u15)
 (define-constant ERR_FAILED_TO_RETRIEVE_SIGNERS u16)
 (define-constant ERR_INVALID_ROUND u17)
+(define-constant ERR_GET_SIGNER_WEIGHT u18)
 
 (define-constant pox-info
     (unwrap-panic (contract-call? .pox-4 get-pox-info)))
@@ -39,6 +40,9 @@
 ;; necessary to recalculate it on every vote.
 (define-map cycle-total-weight uint uint)
 
+;; Maps voting data (count, current weight) per reward cycle & round
+(define-map round-data {reward-cycle: uint, round: uint} {votes-count: uint, votes-weight: uint})
+
 (define-read-only (burn-height-to-reward-cycle (height uint))
     (/ (- height (get first-burnchain-block-height pox-info)) (get reward-cycle-length pox-info)))
 
@@ -54,6 +58,9 @@
 (define-read-only (get-vote (reward-cycle uint) (round uint) (signer principal))
     (map-get? votes {reward-cycle: reward-cycle, round: round, signer: signer}))
 
+(define-read-only (get-current-round-info)
+    (map-get? round-data {reward-cycle: (current-reward-cycle), round: (default-to u0 (get-last-round (current-reward-cycle)))}))
+
 (define-read-only (get-candidate-info (reward-cycle uint) (round uint) (candidate (buff 33)))
     {candidate-weight: (default-to u0 (map-get? tally {reward-cycle: reward-cycle, round: round, aggregate-public-key: candidate})),
     total-weight: (map-get? cycle-total-weight reward-cycle)})
@@ -82,7 +89,7 @@
     (map-get? aggregate-public-keys reward-cycle))
 
 ;; get the weight required for consensus threshold
-(define-private (get-threshold-weight (reward-cycle uint))
+(define-public (get-threshold-weight (reward-cycle uint))
     (let  ((total-weight (try! (get-and-cache-total-weight reward-cycle))))
         (ok (/ (+ (* total-weight threshold-consensus) u99) u100))))
 
@@ -137,9 +144,13 @@
 (define-public (vote-for-aggregate-public-key (signer-index uint) (key (buff 33)) (round uint) (reward-cycle uint))
     (let ((tally-key {reward-cycle: reward-cycle, round: round, aggregate-public-key: key})
             ;; vote by signer weight
-            (signer-weight (try! (get-signer-weight signer-index reward-cycle)))
+            (signer-weight (unwrap! (get-signer-weight signer-index reward-cycle) (err ERR_GET_SIGNER_WEIGHT)))
             (new-total (+ signer-weight (default-to u0 (map-get? tally tally-key))))
-            (threshold-weight (try! (get-threshold-weight reward-cycle))))
+            (threshold-weight (try! (get-threshold-weight reward-cycle)))
+            (current-round (default-to {
+                votes-count: u0, 
+                votes-weight: u0} (map-get? round-data {reward-cycle: reward-cycle, round: round})))
+                )
         ;; Check that the key has not yet been set for this reward cycle
         (asserts! (is-none (map-get? aggregate-public-keys reward-cycle)) (err ERR_OUT_OF_VOTING_WINDOW))
         ;; Check that the aggregate public key is the correct length
@@ -152,6 +163,10 @@
         (try! (update-last-round reward-cycle round))
         ;; Update the tally for this aggregate public key candidate
         (map-set tally tally-key new-total)
+        ;; Update the current round data
+        (map-set round-data {reward-cycle: reward-cycle, round: round} {
+            votes-count: (+ (get votes-count current-round) u1),
+            votes-weight: (+ (get votes-weight current-round) signer-weight)})
         ;; Update used aggregate public keys
         (map-set used-aggregate-public-keys key reward-cycle)
         (print {

From 693c457168b19f51347b1031b3f5a23d7af5173f Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Wed, 6 Mar 2024 12:48:50 -0500
Subject: [PATCH 1155/1166] completed read-only

---
 stackslib/src/chainstate/stacks/boot/signers-voting.clar | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers-voting.clar b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
index dddd0281af..bd5fdc4a0a 100644
--- a/stackslib/src/chainstate/stacks/boot/signers-voting.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
@@ -89,10 +89,15 @@
     (map-get? aggregate-public-keys reward-cycle))
 
 ;; get the weight required for consensus threshold
-(define-public (get-threshold-weight (reward-cycle uint))
+(define-private (get-threshold-weight (reward-cycle uint))
     (let  ((total-weight (try! (get-and-cache-total-weight reward-cycle))))
         (ok (/ (+ (* total-weight threshold-consensus) u99) u100))))
 
+;; get the weight required for consensus threshold (read-only)
+(define-read-only (get-threshold-weight-read-only (reward-cycle uint))
+    (let  ((total-weight (default-to u0 (map-get? cycle-total-weight reward-cycle))))
+        (/ (+ (* total-weight threshold-consensus) u99) u100)))
+
 (define-private (is-in-voting-window (height uint) (reward-cycle uint))
     (let ((last-cycle (unwrap-panic (contract-call? .signers get-last-set-cycle))))
         (and (is-eq last-cycle reward-cycle)

From 77c72d8ea85d55ab4d7cfb7c309f687e561cf23f Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Wed, 6 Mar 2024 13:16:01 -0500
Subject: [PATCH 1156/1166] refactored to remove duplicated
 get-threshold-weight

---
 .../src/chainstate/stacks/boot/signers-voting.clar | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers-voting.clar b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
index bd5fdc4a0a..b9bb96749b 100644
--- a/stackslib/src/chainstate/stacks/boot/signers-voting.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
@@ -89,15 +89,14 @@
     (map-get? aggregate-public-keys reward-cycle))
 
 ;; get the weight required for consensus threshold
-(define-private (get-threshold-weight (reward-cycle uint))
-    (let  ((total-weight (try! (get-and-cache-total-weight reward-cycle))))
-        (ok (/ (+ (* total-weight threshold-consensus) u99) u100))))
-
-;; get the weight required for consensus threshold (read-only)
-(define-read-only (get-threshold-weight-read-only (reward-cycle uint))
+(define-read-only (get-threshold-weight (reward-cycle uint))
     (let  ((total-weight (default-to u0 (map-get? cycle-total-weight reward-cycle))))
         (/ (+ (* total-weight threshold-consensus) u99) u100)))
 
+;; get the voting data for specific reward cycle and round
+(define-private (get-voting-data (reward-cycle uint) (round uint))
+    (unwrap-panic (map-get? round-data {reward-cycle: reward-cycle, round: round})))
+
 (define-private (is-in-voting-window (height uint) (reward-cycle uint))
     (let ((last-cycle (unwrap-panic (contract-call? .signers get-last-set-cycle))))
         (and (is-eq last-cycle reward-cycle)
@@ -151,7 +150,8 @@
             ;; vote by signer weight
             (signer-weight (unwrap! (get-signer-weight signer-index reward-cycle) (err ERR_GET_SIGNER_WEIGHT)))
             (new-total (+ signer-weight (default-to u0 (map-get? tally tally-key))))
-            (threshold-weight (try! (get-threshold-weight reward-cycle)))
+            (cached-weight (try! (get-and-cache-total-weight reward-cycle)))
+            (threshold-weight (get-threshold-weight reward-cycle))
             (current-round (default-to {
                 votes-count: u0, 
                 votes-weight: u0} (map-get? round-data {reward-cycle: reward-cycle, round: round})))

From 6286cb9db2e98aa89d1f8ac0d6821c6114ade410 Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Wed, 6 Mar 2024 16:03:05 -0500
Subject: [PATCH 1157/1166] removed leftover function

---
 stackslib/src/chainstate/stacks/boot/signers-voting.clar | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers-voting.clar b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
index b9bb96749b..516337b9c5 100644
--- a/stackslib/src/chainstate/stacks/boot/signers-voting.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
@@ -95,7 +95,7 @@
 
 ;; get the voting data for specific reward cycle and round
 (define-private (get-voting-data (reward-cycle uint) (round uint))
-    (unwrap-panic (map-get? round-data {reward-cycle: reward-cycle, round: round})))
+    (map-get? round-data {reward-cycle: reward-cycle, round: round}))
 
 (define-private (is-in-voting-window (height uint) (reward-cycle uint))
     (let ((last-cycle (unwrap-panic (contract-call? .signers get-last-set-cycle))))

From c389885c0ae62d378f3121b7a4707d47680187cb Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Wed, 6 Mar 2024 16:09:47 -0500
Subject: [PATCH 1158/1166] added params to round-data getter

---
 stackslib/src/chainstate/stacks/boot/signers-voting.clar | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers-voting.clar b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
index 516337b9c5..34f3300d7a 100644
--- a/stackslib/src/chainstate/stacks/boot/signers-voting.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
@@ -58,8 +58,8 @@
 (define-read-only (get-vote (reward-cycle uint) (round uint) (signer principal))
     (map-get? votes {reward-cycle: reward-cycle, round: round, signer: signer}))
 
-(define-read-only (get-current-round-info)
-    (map-get? round-data {reward-cycle: (current-reward-cycle), round: (default-to u0 (get-last-round (current-reward-cycle)))}))
+(define-read-only (get-round-info (reward-cycle uint) (round uint))
+    (map-get? round-data {reward-cycle: reward-cycle, round: round}))
 
 (define-read-only (get-candidate-info (reward-cycle uint) (round uint) (candidate (buff 33)))
     {candidate-weight: (default-to u0 (map-get? tally {reward-cycle: reward-cycle, round: round, aggregate-public-key: candidate})),
@@ -93,10 +93,6 @@
     (let  ((total-weight (default-to u0 (map-get? cycle-total-weight reward-cycle))))
         (/ (+ (* total-weight threshold-consensus) u99) u100)))
 
-;; get the voting data for specific reward cycle and round
-(define-private (get-voting-data (reward-cycle uint) (round uint))
-    (map-get? round-data {reward-cycle: reward-cycle, round: round}))
-
 (define-private (is-in-voting-window (height uint) (reward-cycle uint))
     (let ((last-cycle (unwrap-panic (contract-call? .signers get-last-set-cycle))))
         (and (is-eq last-cycle reward-cycle)

From a7b00959ae79d339cee0794b8cb27f3c705bc8bf Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Wed, 6 Mar 2024 16:10:51 -0500
Subject: [PATCH 1159/1166] updated comment

---
 stackslib/src/chainstate/stacks/boot/signers-voting.clar | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers-voting.clar b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
index 34f3300d7a..078e94f765 100644
--- a/stackslib/src/chainstate/stacks/boot/signers-voting.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
@@ -25,8 +25,8 @@
 (define-constant pox-info
     (unwrap-panic (contract-call? .pox-4 get-pox-info)))
 
-;; Threshold consensus, expressed as parts-per-thousand to allow for integer
-;; division with higher precision (e.g. 700 for 70%).
+;; Threshold consensus, expressed as parts-per-hundred to allow for integer
+;; division with higher precision (e.g. 70 for 70%).
 (define-constant threshold-consensus u70)
 
 ;; Maps reward-cycle ids to last round

From 08afdddf61d0dcbb12301f07b6f6670a109467b9 Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Thu, 7 Mar 2024 15:29:10 -0500
Subject: [PATCH 1160/1166] get-round-info read-only test now functional

---
 .../chainstate/stacks/boot/signers_tests.rs   | 17 ++++
 .../stacks/boot/signers_voting_tests.rs       | 87 ++++++++++++++++++-
 2 files changed, 103 insertions(+), 1 deletion(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_tests.rs
index a97a0c1e09..9578ad97f0 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_tests.rs
@@ -541,3 +541,20 @@ pub fn get_signer_index(
         })
         .expect("signer not found") as u128
 }
+
+pub fn get_round_info(
+    peer: &mut TestPeer<'_>,
+    latest_block_id: StacksBlockId,
+    reward_cycle: u128,
+    round: u128) -> Option<Value> {
+        let round_tuple = readonly_call(
+            peer,
+            &latest_block_id,
+            "signers-voting".into(),
+            "get-round-info".into(),
+            vec![Value::UInt(reward_cycle), Value::UInt(round)],
+        )
+        .expect_optional()
+        .unwrap();
+    round_tuple
+}
diff --git a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
index 5ac7d461c2..b1323ffa74 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
@@ -64,7 +64,7 @@ use crate::chainstate::stacks::boot::pox_2_tests::{
 use crate::chainstate::stacks::boot::pox_4_tests::{
     assert_latest_was_burn, get_last_block_sender_transactions, get_tip, make_test_epochs_pox,
 };
-use crate::chainstate::stacks::boot::signers_tests::{get_signer_index, prepare_signers_test};
+use crate::chainstate::stacks::boot::signers_tests::{get_signer_index, prepare_signers_test, get_round_info};
 use crate::chainstate::stacks::boot::{
     BOOT_CODE_COST_VOTING_TESTNET as BOOT_CODE_COST_VOTING, BOOT_CODE_POX_TESTNET, SIGNERS_NAME,
     SIGNERS_VOTING_NAME,
@@ -2048,6 +2048,91 @@ fn vote_for_aggregate_public_key_mixed_rounds() {
     assert_eq!(alice_vote_tx.events.len(), 0);
 }
 
+// In this test case, Alice & Bob vote & we test the new getter
+#[test]
+fn test_get_round_info() {
+     // Test setup
+     let alice = TestStacker::from_seed(&[3, 4]);
+     let bob = TestStacker::from_seed(&[5, 6]);
+     let observer = TestEventObserver::new();
+ 
+     // Alice - Signer 1
+     let alice_key = &alice.signer_private_key;
+     let alice_address = key_to_stacks_addr(alice_key);
+     let alice_principal = PrincipalData::from(alice_address);
+ 
+     // Bob - Signer 2
+     let bob_key = &bob.signer_private_key;
+     let bob_address = key_to_stacks_addr(bob_key);
+     let bob_principal = PrincipalData::from(bob_address);
+ 
+     let (mut peer, mut test_signers, latest_block_id, current_reward_cycle) = prepare_signers_test(
+         function_name!(),
+         vec![
+             (alice_principal.clone(), 1000),
+             (bob_principal.clone(), 1000),
+         ],
+         &[alice.clone(), bob.clone()],
+         Some(&observer),
+     );
+ 
+     // Alice and Bob will each have voted once while booting to Nakamoto
+     let alice_nonce = 1;
+     let bob_nonce = 1;
+ 
+     let cycle_id = current_reward_cycle;
+ 
+     // create vote txs
+     let alice_index = get_signer_index(&mut peer, latest_block_id, alice_address, cycle_id);
+     let bob_index = get_signer_index(&mut peer, latest_block_id, bob_address, cycle_id);
+ 
+     let mut signers = TestSigners::default();
+     let aggregate_key = signers.generate_aggregate_key(cycle_id as u64 + 1);
+     let aggregate_public_key = Value::buff_from(aggregate_key.compress().data.to_vec())
+         .expect("Failed to serialize aggregate public key");
+ 
+     let aggregate_public_key_ill_formed = Value::buff_from_byte(0x00);
+ 
+     let txs = vec![
+         // Alice casts vote correctly
+         make_signers_vote_for_aggregate_public_key_value(
+             alice_key,
+             alice_nonce,
+             alice_index,
+             aggregate_public_key.clone(),
+             0,
+             cycle_id + 1,
+         ),
+         // Bob casts a vote correctly
+         make_signers_vote_for_aggregate_public_key_value(
+             bob_key,
+             bob_nonce,
+             bob_index,
+             aggregate_public_key.clone(),
+             0,
+             cycle_id + 1,
+         ),
+     ];
+ 
+     //
+     // vote in the first burn block of prepare phase
+     //
+     let blocks_and_sizes = nakamoto_tenure(&mut peer, &mut test_signers, vec![txs]);
+
+    // Proceed to the next prepare phase
+    let _ = nakamoto_tenure(&mut peer, &mut test_signers, Vec::new());
+    let _ = nakamoto_tenure(&mut peer, &mut test_signers, Vec::new());
+    let _ = nakamoto_tenure(&mut peer, &mut test_signers, Vec::new());
+    let _ = nakamoto_tenure(&mut peer, &mut test_signers, Vec::new());
+    let _ = nakamoto_tenure(&mut peer, &mut test_signers, Vec::new());
+    let _ = nakamoto_tenure(&mut peer, &mut test_signers, Vec::new());
+
+     let round_info = get_round_info(&mut peer, latest_block_id, cycle_id, 0);
+
+     println!("Round Info: {:?}", round_info);
+ 
+}
+
 fn nakamoto_tenure(
     peer: &mut TestPeer,
     test_signers: &mut TestSigners,

From 058adbf8f3fb67c92eaea4ae93e6b7585a7c695f Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Thu, 7 Mar 2024 16:58:13 -0500
Subject: [PATCH 1161/1166] simplified test

---
 .../chainstate/stacks/boot/signers_tests.rs   |  21 ++--
 .../stacks/boot/signers_voting_tests.rs       | 115 ++++++------------
 2 files changed, 48 insertions(+), 88 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_tests.rs
index 9578ad97f0..38906badb8 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_tests.rs
@@ -546,15 +546,16 @@ pub fn get_round_info(
     peer: &mut TestPeer<'_>,
     latest_block_id: StacksBlockId,
     reward_cycle: u128,
-    round: u128) -> Option<Value> {
-        let round_tuple = readonly_call(
-            peer,
-            &latest_block_id,
-            "signers-voting".into(),
-            "get-round-info".into(),
-            vec![Value::UInt(reward_cycle), Value::UInt(round)],
-        )
-        .expect_optional()
-        .unwrap();
+    round: u128,
+) -> Option<Value> {
+    let round_tuple = readonly_call(
+        peer,
+        &latest_block_id,
+        "signers-voting".into(),
+        "get-round-info".into(),
+        vec![Value::UInt(reward_cycle), Value::UInt(round)],
+    )
+    .expect_optional()
+    .unwrap();
     round_tuple
 }
diff --git a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
index b1323ffa74..9c4ab5e04a 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
@@ -64,7 +64,9 @@ use crate::chainstate::stacks::boot::pox_2_tests::{
 use crate::chainstate::stacks::boot::pox_4_tests::{
     assert_latest_was_burn, get_last_block_sender_transactions, get_tip, make_test_epochs_pox,
 };
-use crate::chainstate::stacks::boot::signers_tests::{get_signer_index, prepare_signers_test, get_round_info};
+use crate::chainstate::stacks::boot::signers_tests::{
+    get_round_info, get_signer_index, prepare_signers_test,
+};
 use crate::chainstate::stacks::boot::{
     BOOT_CODE_COST_VOTING_TESTNET as BOOT_CODE_COST_VOTING, BOOT_CODE_POX_TESTNET, SIGNERS_NAME,
     SIGNERS_VOTING_NAME,
@@ -2051,86 +2053,43 @@ fn vote_for_aggregate_public_key_mixed_rounds() {
 // In this test case, Alice & Bob vote & we test the new getter
 #[test]
 fn test_get_round_info() {
-     // Test setup
-     let alice = TestStacker::from_seed(&[3, 4]);
-     let bob = TestStacker::from_seed(&[5, 6]);
-     let observer = TestEventObserver::new();
- 
-     // Alice - Signer 1
-     let alice_key = &alice.signer_private_key;
-     let alice_address = key_to_stacks_addr(alice_key);
-     let alice_principal = PrincipalData::from(alice_address);
- 
-     // Bob - Signer 2
-     let bob_key = &bob.signer_private_key;
-     let bob_address = key_to_stacks_addr(bob_key);
-     let bob_principal = PrincipalData::from(bob_address);
- 
-     let (mut peer, mut test_signers, latest_block_id, current_reward_cycle) = prepare_signers_test(
-         function_name!(),
-         vec![
-             (alice_principal.clone(), 1000),
-             (bob_principal.clone(), 1000),
-         ],
-         &[alice.clone(), bob.clone()],
-         Some(&observer),
-     );
- 
-     // Alice and Bob will each have voted once while booting to Nakamoto
-     let alice_nonce = 1;
-     let bob_nonce = 1;
- 
-     let cycle_id = current_reward_cycle;
- 
-     // create vote txs
-     let alice_index = get_signer_index(&mut peer, latest_block_id, alice_address, cycle_id);
-     let bob_index = get_signer_index(&mut peer, latest_block_id, bob_address, cycle_id);
- 
-     let mut signers = TestSigners::default();
-     let aggregate_key = signers.generate_aggregate_key(cycle_id as u64 + 1);
-     let aggregate_public_key = Value::buff_from(aggregate_key.compress().data.to_vec())
-         .expect("Failed to serialize aggregate public key");
- 
-     let aggregate_public_key_ill_formed = Value::buff_from_byte(0x00);
- 
-     let txs = vec![
-         // Alice casts vote correctly
-         make_signers_vote_for_aggregate_public_key_value(
-             alice_key,
-             alice_nonce,
-             alice_index,
-             aggregate_public_key.clone(),
-             0,
-             cycle_id + 1,
-         ),
-         // Bob casts a vote correctly
-         make_signers_vote_for_aggregate_public_key_value(
-             bob_key,
-             bob_nonce,
-             bob_index,
-             aggregate_public_key.clone(),
-             0,
-             cycle_id + 1,
-         ),
-     ];
- 
-     //
-     // vote in the first burn block of prepare phase
-     //
-     let blocks_and_sizes = nakamoto_tenure(&mut peer, &mut test_signers, vec![txs]);
+    // Test setup
+    let alice = TestStacker::from_seed(&[3, 4]);
+    let bob = TestStacker::from_seed(&[5, 6]);
+    let observer = TestEventObserver::new();
 
-    // Proceed to the next prepare phase
-    let _ = nakamoto_tenure(&mut peer, &mut test_signers, Vec::new());
-    let _ = nakamoto_tenure(&mut peer, &mut test_signers, Vec::new());
-    let _ = nakamoto_tenure(&mut peer, &mut test_signers, Vec::new());
-    let _ = nakamoto_tenure(&mut peer, &mut test_signers, Vec::new());
-    let _ = nakamoto_tenure(&mut peer, &mut test_signers, Vec::new());
-    let _ = nakamoto_tenure(&mut peer, &mut test_signers, Vec::new());
+    // Alice - Signer 1
+    let alice_key = &alice.signer_private_key;
+    let alice_address = key_to_stacks_addr(alice_key);
+    let alice_principal = PrincipalData::from(alice_address);
+
+    // Bob - Signer 2
+    let bob_key = &bob.signer_private_key;
+    let bob_address = key_to_stacks_addr(bob_key);
+    let bob_principal = PrincipalData::from(bob_address);
+
+    let (mut peer, mut test_signers, latest_block_id, current_reward_cycle) = prepare_signers_test(
+        function_name!(),
+        vec![
+            (alice_principal.clone(), 1000),
+            (bob_principal.clone(), 1000),
+        ],
+        &[alice.clone(), bob.clone()],
+        Some(&observer),
+    );
+
+    // Get the current creward cycle
+    let cycle_id = current_reward_cycle;
 
-     let round_info = get_round_info(&mut peer, latest_block_id, cycle_id, 0);
+    let round_info = get_round_info(&mut peer, latest_block_id, cycle_id, 0)
+        .unwrap()
+        .expect_tuple()
+        .unwrap();
+    let votes_count = round_info.get("votes-count").unwrap();
+    let votes_weight = round_info.get("votes-weight").unwrap();
 
-     println!("Round Info: {:?}", round_info);
- 
+    assert_eq!(votes_count, &Value::UInt(2));
+    assert_eq!(votes_weight, &Value::UInt(4));
 }
 
 fn nakamoto_tenure(

From bb02ca11f03c1d0cea98a43df3bd950598efd6d7 Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Thu, 7 Mar 2024 17:27:04 -0500
Subject: [PATCH 1162/1166] added test for get-threshold-weight getter

---
 .../stacks/boot/signers_voting_tests.rs       | 81 ++++++++++++++++++-
 1 file changed, 78 insertions(+), 3 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
index 9c4ab5e04a..aef41ef4a5 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_voting_tests.rs
@@ -65,7 +65,7 @@ use crate::chainstate::stacks::boot::pox_4_tests::{
     assert_latest_was_burn, get_last_block_sender_transactions, get_tip, make_test_epochs_pox,
 };
 use crate::chainstate::stacks::boot::signers_tests::{
-    get_round_info, get_signer_index, prepare_signers_test,
+    get_signer_index, prepare_signers_test, readonly_call,
 };
 use crate::chainstate::stacks::boot::{
     BOOT_CODE_COST_VOTING_TESTNET as BOOT_CODE_COST_VOTING, BOOT_CODE_POX_TESTNET, SIGNERS_NAME,
@@ -2050,7 +2050,8 @@ fn vote_for_aggregate_public_key_mixed_rounds() {
     assert_eq!(alice_vote_tx.events.len(), 0);
 }
 
-// In this test case, Alice & Bob vote & we test the new getter
+// In this test case, Alice & Bob advance through setup & check
+// the round info from the very first reward cycle & round.
 #[test]
 fn test_get_round_info() {
     // Test setup
@@ -2068,7 +2069,7 @@ fn test_get_round_info() {
     let bob_address = key_to_stacks_addr(bob_key);
     let bob_principal = PrincipalData::from(bob_address);
 
-    let (mut peer, mut test_signers, latest_block_id, current_reward_cycle) = prepare_signers_test(
+    let (mut peer, test_signers, latest_block_id, current_reward_cycle) = prepare_signers_test(
         function_name!(),
         vec![
             (alice_principal.clone(), 1000),
@@ -2092,6 +2093,80 @@ fn test_get_round_info() {
     assert_eq!(votes_weight, &Value::UInt(4));
 }
 
+pub fn get_round_info(
+    peer: &mut TestPeer<'_>,
+    latest_block_id: StacksBlockId,
+    reward_cycle: u128,
+    round: u128,
+) -> Option<Value> {
+    let round_tuple = readonly_call(
+        peer,
+        &latest_block_id,
+        "signers-voting".into(),
+        "get-round-info".into(),
+        vec![Value::UInt(reward_cycle), Value::UInt(round)],
+    )
+    .expect_optional()
+    .unwrap();
+    round_tuple
+}
+
+// In this test case, Alice & Bob advance through setup & check
+// the weight threshold info from the very first reward cycle & round.
+#[test]
+fn test_get_threshold_weight() {
+    // Test setup
+    let alice = TestStacker::from_seed(&[3, 4]);
+    let bob = TestStacker::from_seed(&[5, 6]);
+    let observer = TestEventObserver::new();
+
+    // Alice - Signer 1
+    let alice_key = &alice.signer_private_key;
+    let alice_address = key_to_stacks_addr(alice_key);
+    let alice_principal = PrincipalData::from(alice_address);
+
+    // Bob - Signer 2
+    let bob_key = &bob.signer_private_key;
+    let bob_address = key_to_stacks_addr(bob_key);
+    let bob_principal = PrincipalData::from(bob_address);
+
+    let (mut peer, test_signers, latest_block_id, current_reward_cycle) = prepare_signers_test(
+        function_name!(),
+        vec![
+            (alice_principal.clone(), 1000),
+            (bob_principal.clone(), 1000),
+        ],
+        &[alice.clone(), bob.clone()],
+        Some(&observer),
+    );
+
+    // Get the current creward cycle
+    let cycle_id = current_reward_cycle;
+
+    // Call get-threshold-weight
+    let threshold_weight: u128 = get_threshold_weight(&mut peer, latest_block_id, cycle_id);
+
+    // Since there are four votes, the threshold weight should be 3 (75% of 4)
+    assert_eq!(threshold_weight, 3);
+}
+
+pub fn get_threshold_weight(
+    peer: &mut TestPeer<'_>,
+    latest_block_id: StacksBlockId,
+    reward_cycle: u128,
+) -> u128 {
+    let threshold_weight = readonly_call(
+        peer,
+        &latest_block_id,
+        "signers-voting".into(),
+        "get-threshold-weight".into(),
+        vec![Value::UInt(reward_cycle)],
+    )
+    .expect_u128()
+    .unwrap();
+    threshold_weight
+}
+
 fn nakamoto_tenure(
     peer: &mut TestPeer,
     test_signers: &mut TestSigners,

From 52938920634e77f58ca531c9add5b5ac2176e360 Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Thu, 7 Mar 2024 17:31:27 -0500
Subject: [PATCH 1163/1166] removed duplicate get_round_info

---
 .../chainstate/stacks/boot/signers_tests.rs    | 18 ------------------
 1 file changed, 18 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers_tests.rs b/stackslib/src/chainstate/stacks/boot/signers_tests.rs
index 38906badb8..a97a0c1e09 100644
--- a/stackslib/src/chainstate/stacks/boot/signers_tests.rs
+++ b/stackslib/src/chainstate/stacks/boot/signers_tests.rs
@@ -541,21 +541,3 @@ pub fn get_signer_index(
         })
         .expect("signer not found") as u128
 }
-
-pub fn get_round_info(
-    peer: &mut TestPeer<'_>,
-    latest_block_id: StacksBlockId,
-    reward_cycle: u128,
-    round: u128,
-) -> Option<Value> {
-    let round_tuple = readonly_call(
-        peer,
-        &latest_block_id,
-        "signers-voting".into(),
-        "get-round-info".into(),
-        vec![Value::UInt(reward_cycle), Value::UInt(round)],
-    )
-    .expect_optional()
-    .unwrap();
-    round_tuple
-}

From 6e4113c701d388f61effd6f7e13ce788753044fc Mon Sep 17 00:00:00 2001
From: jesus <jnajera1917@gmail.com>
Date: Fri, 15 Mar 2024 16:17:50 -0500
Subject: [PATCH 1164/1166] fixed botched tests, removed extra issue

---
 stackslib/src/chainstate/stacks/boot/signers-voting.clar | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/stackslib/src/chainstate/stacks/boot/signers-voting.clar b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
index 078e94f765..1fea756e93 100644
--- a/stackslib/src/chainstate/stacks/boot/signers-voting.clar
+++ b/stackslib/src/chainstate/stacks/boot/signers-voting.clar
@@ -20,7 +20,6 @@
 (define-constant ERR_DUPLICATE_VOTE u15)
 (define-constant ERR_FAILED_TO_RETRIEVE_SIGNERS u16)
 (define-constant ERR_INVALID_ROUND u17)
-(define-constant ERR_GET_SIGNER_WEIGHT u18)
 
 (define-constant pox-info
     (unwrap-panic (contract-call? .pox-4 get-pox-info)))
@@ -144,7 +143,7 @@
 (define-public (vote-for-aggregate-public-key (signer-index uint) (key (buff 33)) (round uint) (reward-cycle uint))
     (let ((tally-key {reward-cycle: reward-cycle, round: round, aggregate-public-key: key})
             ;; vote by signer weight
-            (signer-weight (unwrap! (get-signer-weight signer-index reward-cycle) (err ERR_GET_SIGNER_WEIGHT)))
+            (signer-weight (try! (get-signer-weight signer-index reward-cycle)))
             (new-total (+ signer-weight (default-to u0 (map-get? tally tally-key))))
             (cached-weight (try! (get-and-cache-total-weight reward-cycle)))
             (threshold-weight (get-threshold-weight reward-cycle))

From 373c082ed56cfbbfc3f31946f297b2283cf22db7 Mon Sep 17 00:00:00 2001
From: Matthew Little <zone117x@gmail.com>
Date: Mon, 18 Mar 2024 13:13:59 +0100
Subject: [PATCH 1165/1166] chore: fix integration test

---
 testnet/stacks-node/src/tests/nakamoto_integrations.rs | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/testnet/stacks-node/src/tests/nakamoto_integrations.rs b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
index 4ffed3b97c..d0cef8f988 100644
--- a/testnet/stacks-node/src/tests/nakamoto_integrations.rs
+++ b/testnet/stacks-node/src/tests/nakamoto_integrations.rs
@@ -1606,7 +1606,10 @@ fn correct_burn_outs() {
 
     let new_blocks_with_reward_set: Vec<serde_json::Value> = test_observer::get_blocks()
         .into_iter()
-        .filter(|block| block.get("reward_set").is_some() && block.get("cycle_number").is_some())
+        .filter(|block| {
+            block.get("reward_set").map_or(false, |v| !v.is_null())
+                && block.get("cycle_number").map_or(false, |v| !v.is_null())
+        })
         .collect();
     info!(
         "Announced blocks that include reward sets: {:#?}",

From 8cdd2dd46fb08467c176b61af06338769b329b7b Mon Sep 17 00:00:00 2001
From: Jeff Bencin <jeff.bencin@gmail.com>
Date: Mon, 18 Mar 2024 15:30:06 -0400
Subject: [PATCH 1166/1166] fix:
 `stackslib/src/chainstate/coordinator/tests.rs` passes

---
 stackslib/src/chainstate/coordinator/tests.rs | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/stackslib/src/chainstate/coordinator/tests.rs b/stackslib/src/chainstate/coordinator/tests.rs
index bfd54ca4ca..0a7d0e50d9 100644
--- a/stackslib/src/chainstate/coordinator/tests.rs
+++ b/stackslib/src/chainstate/coordinator/tests.rs
@@ -702,7 +702,7 @@ fn make_genesis_block_with_recipients(
         ),
         key_block_ptr: 1, // all registers happen in block height 1
         key_vtxindex: (1 + key_index) as u16,
-        memo: vec![STACKS_EPOCH_3_0_MARKER],
+        memo: vec![STACKS_EPOCH_2_4_MARKER],
         new_seed: VRFSeed::from_proof(&proof),
         commit_outs,
 
@@ -973,7 +973,7 @@ fn make_stacks_block_with_input(
         ),
         key_block_ptr: 1, // all registers happen in block height 1
         key_vtxindex: (1 + key_index) as u16,
-        memo: vec![STACKS_EPOCH_3_0_MARKER],
+        memo: vec![STACKS_EPOCH_2_4_MARKER],
         new_seed: VRFSeed::from_proof(&proof),
         commit_outs,
 
@@ -4427,7 +4427,7 @@ fn test_epoch_switch_pox_3_contract_instantiation() {
         &committers,
         pox_consts.clone(),
         None,
-        StacksEpochId::Epoch30,
+        StacksEpochId::Epoch24,
     );
 
     let mut coord = make_coordinator(path, Some(burnchain_conf));
@@ -4541,9 +4541,7 @@ fn test_epoch_switch_pox_3_contract_instantiation() {
             x if x >= 8 && x < 12 => StacksEpochId::Epoch21,
             x if x >= 12 && x < 16 => StacksEpochId::Epoch22,
             x if x >= 16 && x < 20 => StacksEpochId::Epoch23,
-            x if x >= 20 && x < 24 => StacksEpochId::Epoch24,
-            x if x >= 24 && x < 28 => StacksEpochId::Epoch25,
-            _ => StacksEpochId::Epoch30,
+            _ => StacksEpochId::Epoch24,
         };
         assert_eq!(
             chainstate